94 files changed, 5239 insertions, 793 deletions

diff --git a/arch/arm/mach-omap2/Kconfig b/arch/arm/mach-omap2/Kconfig
index 75b1c7efae7e..7309aab305a9 100644
--- a/arch/arm/mach-omap2/Kconfig
+++ b/arch/arm/mach-omap2/Kconfig
@@ -65,6 +65,10 @@ config MACH_OMAP3EVM
         bool "OMAP 3530 EVM board"
         depends on ARCH_OMAP3 && ARCH_OMAP34XX
 
+config MACH_OMAP3517EVM
+        bool "OMAP3517/ AM3517 EVM board"
+        depends on ARCH_OMAP3 && ARCH_OMAP34XX
+
 config MACH_OMAP3_PANDORA
         bool "OMAP3 Pandora"
         depends on ARCH_OMAP3 && ARCH_OMAP34XX
@@ -73,9 +77,21 @@ config MACH_OMAP_3430SDP
         bool "OMAP 3430 SDP board"
         depends on ARCH_OMAP3 && ARCH_OMAP34XX
 
+config MACH_NOKIA_N800
+       bool
+
+config MACH_NOKIA_N810
+       bool
+
+config MACH_NOKIA_N810_WIMAX
+       bool
+
 config MACH_NOKIA_N8X0
         bool "Nokia N800/N810"
         depends on ARCH_OMAP2420
+        select MACH_NOKIA_N800
+        select MACH_NOKIA_N810
+        select MACH_NOKIA_N810_WIMAX
 
 config MACH_NOKIA_RX51
         bool "Nokia RX-51 board"
@@ -85,6 +101,30 @@ config MACH_OMAP_ZOOM2
         bool "OMAP3 Zoom2 board"
         depends on ARCH_OMAP3 && ARCH_OMAP34XX
 
+config MACH_OMAP_ZOOM3
+        bool "OMAP3630 Zoom3 board"
+        depends on ARCH_OMAP3 && ARCH_OMAP34XX
+
+config MACH_CM_T35
+        bool "CompuLab CM-T35 module"
+        depends on ARCH_OMAP3 && ARCH_OMAP34XX
+
+config MACH_IGEP0020
+        bool "IGEP0020"
+        depends on ARCH_OMAP3 && ARCH_OMAP34XX
+
+config MACH_OMAP_3630SDP
+        bool "OMAP3630 SDP board"
+        depends on ARCH_OMAP3 && ARCH_OMAP34XX
+
 config MACH_OMAP_4430SDP
         bool "OMAP 4430 SDP board"
         depends on ARCH_OMAP4
+
+config OMAP3_EMU
+        bool "OMAP3 debugging peripherals"
+        depends on ARCH_OMAP3
+        select OC_ETM
+        help
+          Say Y here to enable debugging hardware of omap3
+
diff --git a/arch/arm/mach-omap2/Makefile b/arch/arm/mach-omap2/Makefile
index 8cb16777661a..32548a4510c5 100644
--- a/arch/arm/mach-omap2/Makefile
+++ b/arch/arm/mach-omap2/Makefile
@@ -31,7 +31,7 @@ obj-$(CONFIG_ARCH_OMAP2)		+= sdrc2xxx.o
 ifeq ($(CONFIG_PM),y)
 obj-$(CONFIG_ARCH_OMAP2)                += pm24xx.o
 obj-$(CONFIG_ARCH_OMAP24XX)             += sleep24xx.o
-obj-$(CONFIG_ARCH_OMAP3)                += pm34xx.o sleep34xx.o
+obj-$(CONFIG_ARCH_OMAP3)                += pm34xx.o sleep34xx.o cpuidle34xx.o
 obj-$(CONFIG_PM_DEBUG)                  += pm-debug.o
 endif
 
@@ -44,6 +44,12 @@ obj-$(CONFIG_ARCH_OMAP4)		+= cm4xxx.o
 obj-$(CONFIG_ARCH_OMAP2)                += clock24xx.o
 obj-$(CONFIG_ARCH_OMAP3)                += clock34xx.o
 
+# EMU peripherals
+obj-$(CONFIG_OMAP3_EMU)         += emu.o
+
+obj-$(CONFIG_OMAP_MBOX_FWK)             += mailbox_mach.o
+mailbox_mach-objs                       := mailbox.o
+
 iommu-y                                 += iommu2.o
 iommu-$(CONFIG_ARCH_OMAP3)              += omap3-iommu.o
 
@@ -69,17 +75,33 @@ obj-$(CONFIG_MACH_OMAP_3430SDP)		+= board-3430sdp.o \
                                            mmc-twl4030.o
 obj-$(CONFIG_MACH_NOKIA_N8X0)           += board-n8x0.o
 obj-$(CONFIG_MACH_NOKIA_RX51)           += board-rx51.o \
+                                           board-rx51-sdram.o \
                                            board-rx51-peripherals.o \
                                            mmc-twl4030.o
 obj-$(CONFIG_MACH_OMAP_ZOOM2)           += board-zoom2.o \
+                                           board-zoom-peripherals.o \
+                                           mmc-twl4030.o \
+                                           board-zoom-debugboard.o
+obj-$(CONFIG_MACH_OMAP_ZOOM3)           += board-zoom3.o \
+                                           board-zoom-peripherals.o \
                                            mmc-twl4030.o \
                                            board-zoom-debugboard.o
+obj-$(CONFIG_MACH_OMAP_3630SDP)         += board-3630sdp.o \
+                                           board-zoom-peripherals.o \
+                                           mmc-twl4030.o
+obj-$(CONFIG_MACH_CM_T35)               += board-cm-t35.o \
+                                           mmc-twl4030.o
+obj-$(CONFIG_MACH_IGEP0020)             += board-igep0020.o \
+                                           mmc-twl4030.o
 
 obj-$(CONFIG_MACH_OMAP_4430SDP)         += board-4430sdp.o
 
+obj-$(CONFIG_MACH_OMAP3517EVM)     += board-am3517evm.o
+
 # Platform specific device init code
 obj-y                                   += usb-musb.o
 obj-$(CONFIG_MACH_OMAP2_TUSB6010)       += usb-tusb6010.o
+obj-y                                   += usb-ehci.o
 
 onenand-$(CONFIG_MTD_ONENAND_OMAP2)     := gpmc-onenand.o
 obj-y                                   += $(onenand-m) $(onenand-y)
diff --git a/arch/arm/mach-omap2/board-2430sdp.c b/arch/arm/mach-omap2/board-2430sdp.c
index 42217b32f835..db9374bc528b 100644
--- a/arch/arm/mach-omap2/board-2430sdp.c
+++ b/arch/arm/mach-omap2/board-2430sdp.c
@@ -31,12 +31,12 @@
 #include <asm/mach/flash.h>
 
 #include <mach/gpio.h>
-#include <mach/mux.h>
-#include <mach/board.h>
-#include <mach/common.h>
-#include <mach/gpmc.h>
-#include <mach/usb.h>
-#include <mach/gpmc-smc91x.h>
+#include <plat/mux.h>
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/gpmc.h>
+#include <plat/usb.h>
+#include <plat/gpmc-smc91x.h>
 
 #include "mmc-twl4030.h"
 
@@ -221,7 +221,7 @@ static void __init omap_2430sdp_map_io(void)
 MACHINE_START(OMAP_2430SDP, "OMAP2430 sdp2430 board")
         /* Maintainer: Syed Khasim - Texas Instruments Inc */
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap_2430sdp_map_io,
         .init_irq       = omap_2430sdp_init_irq,
diff --git a/arch/arm/mach-omap2/board-3430sdp.c b/arch/arm/mach-omap2/board-3430sdp.c
index efaf053eba85..491364e44c7d 100644
--- a/arch/arm/mach-omap2/board-3430sdp.c
+++ b/arch/arm/mach-omap2/board-3430sdp.c
@@ -17,6 +17,7 @@
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <linux/input.h>
+#include <linux/input/matrix_keypad.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
 #include <linux/i2c/twl4030.h>
@@ -29,17 +30,16 @@
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
-#include <mach/mcspi.h>
-#include <mach/mux.h>
-#include <mach/board.h>
-#include <mach/usb.h>
-#include <mach/common.h>
-#include <mach/dma.h>
-#include <mach/gpmc.h>
+#include <plat/mcspi.h>
+#include <plat/mux.h>
+#include <plat/board.h>
+#include <plat/usb.h>
+#include <plat/common.h>
+#include <plat/dma.h>
+#include <plat/gpmc.h>
 
-#include <mach/control.h>
-#include <mach/keypad.h>
-#include <mach/gpmc-smc91x.h>
+#include <plat/control.h>
+#include <plat/gpmc-smc91x.h>
 
 #include "sdram-qimonda-hyb18m512160af-6.h"
 #include "mmc-twl4030.h"
@@ -410,6 +410,15 @@ static struct regulator_init_data sdp3430_vpll2 = {
         .consumer_supplies      = &sdp3430_vdvi_supply,
 };
 
+static struct twl4030_codec_audio_data sdp3430_audio = {
+        .audio_mclk = 26000000,
+};
+
+static struct twl4030_codec_data sdp3430_codec = {
+        .audio_mclk = 26000000,
+        .audio = &sdp3430_audio,
+};
+
 static struct twl4030_platform_data sdp3430_twldata = {
         .irq_base       = TWL4030_IRQ_BASE,
         .irq_end        = TWL4030_IRQ_END,
@@ -420,6 +429,7 @@ static struct twl4030_platform_data sdp3430_twldata = {
         .madc           = &sdp3430_madc_data,
         .keypad         = &sdp3430_kp_data,
         .usb            = &sdp3430_usb_data,
+        .codec          = &sdp3430_codec,
 
         .vaux1          = &sdp3430_vaux1,
         .vaux2          = &sdp3430_vaux2,
@@ -484,6 +494,18 @@ static void enable_board_wakeup_source(void)
         omap_cfg_reg(AF26_34XX_SYS_NIRQ); /* T2 interrupt line (keypad) */
 }
 
+static struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
+
+        .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+
+        .phy_reset  = true,
+        .reset_gpio_port[0]  = 57,
+        .reset_gpio_port[1]  = 61,
+        .reset_gpio_port[2]  = -EINVAL
+};
+
 static void __init omap_3430sdp_init(void)
 {
         omap3430_i2c_init();
@@ -500,6 +522,7 @@ static void __init omap_3430sdp_init(void)
         usb_musb_init();
         board_smc91x_init();
         enable_board_wakeup_source();
+        usb_ehci_init(&ehci_pdata);
 }
 
 static void __init omap_3430sdp_map_io(void)
@@ -511,7 +534,7 @@ static void __init omap_3430sdp_map_io(void)
 MACHINE_START(OMAP_3430SDP, "OMAP3430 3430SDP board")
         /* Maintainer: Syed Khasim - Texas Instruments Inc */
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap_3430sdp_map_io,
         .init_irq       = omap_3430sdp_init_irq,
diff --git a/arch/arm/mach-omap2/board-3630sdp.c b/arch/arm/mach-omap2/board-3630sdp.c
new file mode 100755
index 000000000000..348b70b98336
--- /dev/null
+++ b/arch/arm/mach-omap2/board-3630sdp.c
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2009 Texas Instruments Inc.
+ *
+ * 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 <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/gpio.h>
+
+#include <asm/mach-types.h>
+#include <asm/mach/arch.h>
+
+#include <plat/common.h>
+#include <plat/board.h>
+#include <plat/gpmc-smc91x.h>
+#include <plat/mux.h>
+#include <plat/usb.h>
+
+#include <mach/board-zoom.h>
+
+#include "sdram-hynix-h8mbx00u0mer-0em.h"
+
+#if defined(CONFIG_SMC91X) || defined(CONFIG_SMC91X_MODULE)
+
+static struct omap_smc91x_platform_data board_smc91x_data = {
+        .cs             = 3,
+        .flags          = GPMC_MUX_ADD_DATA | IORESOURCE_IRQ_LOWLEVEL,
+};
+
+static void __init board_smc91x_init(void)
+{
+        board_smc91x_data.gpio_irq = 158;
+        gpmc_smc91x_init(&board_smc91x_data);
+}
+
+#else
+
+static inline void board_smc91x_init(void)
+{
+}
+
+#endif /* defined(CONFIG_SMC91X) || defined(CONFIG_SMC91X_MODULE) */
+
+static void enable_board_wakeup_source(void)
+{
+        omap_cfg_reg(AF26_34XX_SYS_NIRQ); /* T2 interrupt line (keypad) */
+}
+
+static struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
+
+        .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+
+        .phy_reset  = true,
+        .reset_gpio_port[0]  = 126,
+        .reset_gpio_port[1]  = 61,
+        .reset_gpio_port[2]  = -EINVAL
+};
+
+static void __init omap_sdp_map_io(void)
+{
+        omap2_set_globals_343x();
+        omap2_map_common_io();
+}
+
+static struct omap_board_config_kernel sdp_config[] __initdata = {
+};
+
+static void __init omap_sdp_init_irq(void)
+{
+        omap_board_config = sdp_config;
+        omap_board_config_size = ARRAY_SIZE(sdp_config);
+        omap2_init_common_hw(h8mbx00u0mer0em_sdrc_params,
+                        h8mbx00u0mer0em_sdrc_params);
+        omap_init_irq();
+        omap_gpio_init();
+}
+
+static void __init omap_sdp_init(void)
+{
+        zoom_peripherals_init();
+        board_smc91x_init();
+        enable_board_wakeup_source();
+        usb_ehci_init(&ehci_pdata);
+}
+
+MACHINE_START(OMAP_3630SDP, "OMAP 3630SDP board")
+        .phys_io        = 0x48000000,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
+        .boot_params    = 0x80000100,
+        .map_io         = omap_sdp_map_io,
+        .init_irq       = omap_sdp_init_irq,
+        .init_machine   = omap_sdp_init,
+        .timer          = &omap_timer,
+MACHINE_END
diff --git a/arch/arm/mach-omap2/board-4430sdp.c b/arch/arm/mach-omap2/board-4430sdp.c
index eb37c40ea83a..0c6be6b4a7e2 100644
--- a/arch/arm/mach-omap2/board-4430sdp.c
+++ b/arch/arm/mach-omap2/board-4430sdp.c
@@ -23,10 +23,10 @@
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
-#include <mach/board.h>
-#include <mach/common.h>
-#include <mach/control.h>
-#include <mach/timer-gp.h>
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/control.h>
+#include <plat/timer-gp.h>
 #include <asm/hardware/gic.h>
 
 static struct platform_device sdp4430_lcd_device = {
@@ -52,12 +52,23 @@ static struct omap_board_config_kernel sdp4430_config[] __initdata = {
 
 static void __init gic_init_irq(void)
 {
-        gic_dist_init(0, OMAP2_IO_ADDRESS(OMAP44XX_GIC_DIST_BASE), 29);
-        gic_cpu_init(0, OMAP2_IO_ADDRESS(OMAP44XX_GIC_CPU_BASE));
+        void __iomem *base;
+
+        /* Static mapping, never released */
+        base = ioremap(OMAP44XX_GIC_DIST_BASE, SZ_4K);
+        BUG_ON(!base);
+        gic_dist_init(0, base, 29);
+
+        /* Static mapping, never released */
+        gic_cpu_base_addr = ioremap(OMAP44XX_GIC_CPU_BASE, SZ_512);
+        BUG_ON(!gic_cpu_base_addr);
+        gic_cpu_init(0, gic_cpu_base_addr);
 }
 
 static void __init omap_4430sdp_init_irq(void)
 {
+        omap_board_config = sdp4430_config;
+        omap_board_config_size = ARRAY_SIZE(sdp4430_config);
         omap2_init_common_hw(NULL, NULL);
 #ifdef CONFIG_OMAP_32K_TIMER
         omap2_gp_clockevent_set_gptimer(1);
@@ -70,8 +81,6 @@ static void __init omap_4430sdp_init_irq(void)
 static void __init omap_4430sdp_init(void)
 {
         platform_add_devices(sdp4430_devices, ARRAY_SIZE(sdp4430_devices));
-        omap_board_config = sdp4430_config;
-        omap_board_config_size = ARRAY_SIZE(sdp4430_config);
         omap_serial_init();
 }
 
@@ -84,7 +93,7 @@ static void __init omap_4430sdp_map_io(void)
 MACHINE_START(OMAP_4430SDP, "OMAP4430 4430SDP board")
         /* Maintainer: Santosh Shilimkar - Texas Instruments Inc */
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap_4430sdp_map_io,
         .init_irq       = omap_4430sdp_init_irq,
diff --git a/arch/arm/mach-omap2/board-am3517evm.c b/arch/arm/mach-omap2/board-am3517evm.c
new file mode 100644
index 000000000000..415a13d767cc
--- /dev/null
+++ b/arch/arm/mach-omap2/board-am3517evm.c
@@ -0,0 +1,86 @@
+/*
+ * linux/arch/arm/mach-omap2/board-am3517evm.c
+ *
+ * Copyright (C) 2009 Texas Instruments Incorporated
+ * Author: Ranjith Lohithakshan <ranjithl@ti.com>
+ *
+ * Based on mach-omap2/board-omap3evm.c
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as  published by the
+ * Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
+ * whether express or implied; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+
+#include <mach/hardware.h>
+#include <asm/mach-types.h>
+#include <asm/mach/arch.h>
+#include <asm/mach/map.h>
+
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/usb.h>
+
+/*
+ * Board initialization
+ */
+static struct omap_board_config_kernel am3517_evm_config[] __initdata = {
+};
+
+static struct platform_device *am3517_evm_devices[] __initdata = {
+};
+
+static void __init am3517_evm_init_irq(void)
+{
+        omap_board_config = am3517_evm_config;
+        omap_board_config_size = ARRAY_SIZE(am3517_evm_config);
+
+        omap2_init_common_hw(NULL, NULL);
+        omap_init_irq();
+        omap_gpio_init();
+}
+
+static struct ehci_hcd_omap_platform_data ehci_pdata __initdata = {
+        .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+
+        .phy_reset  = true,
+        .reset_gpio_port[0]  = 57,
+        .reset_gpio_port[1]  = -EINVAL,
+        .reset_gpio_port[2]  = -EINVAL
+};
+
+static void __init am3517_evm_init(void)
+{
+        platform_add_devices(am3517_evm_devices,
+                                ARRAY_SIZE(am3517_evm_devices));
+
+        omap_serial_init();
+        usb_ehci_init(&ehci_pdata);
+}
+
+static void __init am3517_evm_map_io(void)
+{
+        omap2_set_globals_343x();
+        omap2_map_common_io();
+}
+
+MACHINE_START(OMAP3517EVM, "OMAP3517/AM3517 EVM")
+        .phys_io        = 0x48000000,
+        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .boot_params    = 0x80000100,
+        .map_io         = am3517_evm_map_io,
+        .init_irq       = am3517_evm_init_irq,
+        .init_machine   = am3517_evm_init,
+        .timer          = &omap_timer,
+MACHINE_END
diff --git a/arch/arm/mach-omap2/board-apollon.c b/arch/arm/mach-omap2/board-apollon.c
index a1132288c701..8a2ce77a02ec 100644
--- a/arch/arm/mach-omap2/board-apollon.c
+++ b/arch/arm/mach-omap2/board-apollon.c
@@ -33,13 +33,13 @@
 #include <asm/mach/flash.h>
 
 #include <mach/gpio.h>
-#include <mach/led.h>
-#include <mach/mux.h>
-#include <mach/usb.h>
-#include <mach/board.h>
-#include <mach/common.h>
-#include <mach/gpmc.h>
-#include <mach/control.h>
+#include <plat/led.h>
+#include <plat/mux.h>
+#include <plat/usb.h>
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/gpmc.h>
+#include <plat/control.h>
 
 /* LED & Switch macros */
 #define LED0_GPIO13             13
@@ -333,7 +333,7 @@ static void __init omap_apollon_map_io(void)
 MACHINE_START(OMAP_APOLLON, "OMAP24xx Apollon")
         /* Maintainer: Kyungmin Park <kyungmin.park@samsung.com> */
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap_apollon_map_io,
         .init_irq       = omap_apollon_init_irq,
diff --git a/arch/arm/mach-omap2/board-cm-t35.c b/arch/arm/mach-omap2/board-cm-t35.c
new file mode 100644
index 000000000000..22c45290db63
--- /dev/null
+++ b/arch/arm/mach-omap2/board-cm-t35.c
@@ -0,0 +1,507 @@
+/*
+ * board-cm-t35.c (CompuLab CM-T35 module)
+ *
+ * Copyright (C) 2009 CompuLab, Ltd.
+ * Author: Mike Rapoport <mike@compulab.co.il>
+ *
+ * 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/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/input/matrix_keypad.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+
+#include <linux/i2c/at24.h>
+#include <linux/i2c/twl4030.h>
+#include <linux/regulator/machine.h>
+
+#include <asm/mach-types.h>
+#include <asm/mach/arch.h>
+#include <asm/mach/map.h>
+
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/mux.h>
+#include <plat/nand.h>
+#include <plat/gpmc.h>
+#include <plat/usb.h>
+
+#include <mach/hardware.h>
+
+#include "sdram-micron-mt46h32m32lf-6.h"
+#include "mmc-twl4030.h"
+
+#define CM_T35_GPIO_PENDOWN     57
+
+#define CM_T35_SMSC911X_CS      5
+#define CM_T35_SMSC911X_GPIO    163
+#define SB_T35_SMSC911X_CS      4
+#define SB_T35_SMSC911X_GPIO    65
+
+#define NAND_BLOCK_SIZE         SZ_128K
+#define GPMC_CS0_BASE           0x60
+#define GPMC_CS0_BASE_ADDR      (OMAP34XX_GPMC_VIRT + GPMC_CS0_BASE)
+
+#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
+#include <linux/smsc911x.h>
+
+static struct smsc911x_platform_config cm_t35_smsc911x_config = {
+        .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
+        .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
+        .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS,
+        .phy_interface  = PHY_INTERFACE_MODE_MII,
+};
+
+static struct resource cm_t35_smsc911x_resources[] = {
+        {
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = OMAP_GPIO_IRQ(CM_T35_SMSC911X_GPIO),
+                .end    = OMAP_GPIO_IRQ(CM_T35_SMSC911X_GPIO),
+                .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
+        },
+};
+
+static struct platform_device cm_t35_smsc911x_device = {
+        .name           = "smsc911x",
+        .id             = 0,
+        .num_resources  = ARRAY_SIZE(cm_t35_smsc911x_resources),
+        .resource       = cm_t35_smsc911x_resources,
+        .dev            = {
+                .platform_data = &cm_t35_smsc911x_config,
+        },
+};
+
+static struct resource sb_t35_smsc911x_resources[] = {
+        {
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = OMAP_GPIO_IRQ(SB_T35_SMSC911X_GPIO),
+                .end    = OMAP_GPIO_IRQ(SB_T35_SMSC911X_GPIO),
+                .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
+        },
+};
+
+static struct platform_device sb_t35_smsc911x_device = {
+        .name           = "smsc911x",
+        .id             = 1,
+        .num_resources  = ARRAY_SIZE(sb_t35_smsc911x_resources),
+        .resource       = sb_t35_smsc911x_resources,
+        .dev            = {
+                .platform_data = &cm_t35_smsc911x_config,
+        },
+};
+
+static void __init cm_t35_init_smsc911x(struct platform_device *dev,
+                                        int cs, int irq_gpio)
+{
+        unsigned long cs_mem_base;
+
+        if (gpmc_cs_request(cs, SZ_16M, &cs_mem_base) < 0) {
+                pr_err("CM-T35: Failed request for GPMC mem for smsc911x\n");
+                return;
+        }
+
+        dev->resource[0].start = cs_mem_base + 0x0;
+        dev->resource[0].end   = cs_mem_base + 0xff;
+
+        if ((gpio_request(irq_gpio, "ETH IRQ") == 0) &&
+            (gpio_direction_input(irq_gpio) == 0)) {
+                gpio_export(irq_gpio, 0);
+        } else {
+                pr_err("CM-T35: could not obtain gpio for SMSC911X IRQ\n");
+                return;
+        }
+
+        platform_device_register(dev);
+}
+
+static void __init cm_t35_init_ethernet(void)
+{
+        cm_t35_init_smsc911x(&cm_t35_smsc911x_device,
+                             CM_T35_SMSC911X_CS, CM_T35_SMSC911X_GPIO);
+        cm_t35_init_smsc911x(&sb_t35_smsc911x_device,
+                             SB_T35_SMSC911X_CS, SB_T35_SMSC911X_GPIO);
+}
+#else
+static inline void __init cm_t35_init_ethernet(void) { return; }
+#endif
+
+#if defined(CONFIG_LEDS_GPIO) || defined(CONFIG_LEDS_GPIO_MODULE)
+#include <linux/leds.h>
+
+static struct gpio_led cm_t35_leds[] = {
+        [0] = {
+                .gpio                   = 186,
+                .name                   = "cm-t35:green",
+                .default_trigger        = "heartbeat",
+                .active_low             = 0,
+        },
+};
+
+static struct gpio_led_platform_data cm_t35_led_pdata = {
+        .num_leds       = ARRAY_SIZE(cm_t35_leds),
+        .leds           = cm_t35_leds,
+};
+
+static struct platform_device cm_t35_led_device = {
+        .name           = "leds-gpio",
+        .id             = -1,
+        .dev            = {
+                .platform_data  = &cm_t35_led_pdata,
+        },
+};
+
+static void __init cm_t35_init_led(void)
+{
+        platform_device_register(&cm_t35_led_device);
+}
+#else
+static inline void cm_t35_init_led(void) {}
+#endif
+
+#if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+
+static struct mtd_partition cm_t35_nand_partitions[] = {
+        {
+                .name           = "xloader",
+                .offset         = 0,                    /* Offset = 0x00000 */
+                .size           = 4 * NAND_BLOCK_SIZE,
+                .mask_flags     = MTD_WRITEABLE
+        },
+        {
+                .name           = "uboot",
+                .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x80000 */
+                .size           = 15 * NAND_BLOCK_SIZE,
+        },
+        {
+                .name           = "uboot environment",
+                .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x260000 */
+                .size           = 2 * NAND_BLOCK_SIZE,
+        },
+        {
+                .name           = "linux",
+                .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x280000 */
+                .size           = 32 * NAND_BLOCK_SIZE,
+        },
+        {
+                .name           = "rootfs",
+                .offset         = MTDPART_OFS_APPEND,   /* Offset = 0x680000 */
+                .size           = MTDPART_SIZ_FULL,
+        },
+};
+
+static struct omap_nand_platform_data cm_t35_nand_data = {
+        .parts                  = cm_t35_nand_partitions,
+        .nr_parts               = ARRAY_SIZE(cm_t35_nand_partitions),
+        .dma_channel            = -1,   /* disable DMA in OMAP NAND driver */
+        .cs                     = 0,
+        .gpmc_cs_baseaddr       = (void __iomem *)GPMC_CS0_BASE_ADDR,
+        .gpmc_baseaddr          = (void __iomem *)OMAP34XX_GPMC_VIRT,
+
+};
+
+static struct resource cm_t35_nand_resource = {
+        .flags          = IORESOURCE_MEM,
+};
+
+static struct platform_device cm_t35_nand_device = {
+        .name           = "omap2-nand",
+        .id             = -1,
+        .num_resources  = 1,
+        .resource       = &cm_t35_nand_resource,
+        .dev            = {
+                .platform_data  = &cm_t35_nand_data,
+        },
+};
+
+static void __init cm_t35_init_nand(void)
+{
+        if (platform_device_register(&cm_t35_nand_device) < 0)
+                pr_err("CM-T35: Unable to register NAND device\n");
+}
+#else
+static inline void cm_t35_init_nand(void) {}
+#endif
+
+#if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
+        defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
+#include <linux/spi/spi.h>
+#include <linux/spi/ads7846.h>
+
+#include <plat/mcspi.h>
+
+static struct omap2_mcspi_device_config ads7846_mcspi_config = {
+        .turbo_mode     = 0,
+        .single_channel = 1,    /* 0: slave, 1: master */
+};
+
+static int ads7846_get_pendown_state(void)
+{
+        return !gpio_get_value(CM_T35_GPIO_PENDOWN);
+}
+
+static struct ads7846_platform_data ads7846_config = {
+        .x_max                  = 0x0fff,
+        .y_max                  = 0x0fff,
+        .x_plate_ohms           = 180,
+        .pressure_max           = 255,
+        .debounce_max           = 10,
+        .debounce_tol           = 3,
+        .debounce_rep           = 1,
+        .get_pendown_state      = ads7846_get_pendown_state,
+        .keep_vref_on           = 1,
+};
+
+static struct spi_board_info cm_t35_spi_board_info[] __initdata = {
+        {
+                .modalias               = "ads7846",
+                .bus_num                = 1,
+                .chip_select            = 0,
+                .max_speed_hz           = 1500000,
+                .controller_data        = &ads7846_mcspi_config,
+                .irq                    = OMAP_GPIO_IRQ(CM_T35_GPIO_PENDOWN),
+                .platform_data          = &ads7846_config,
+        },
+};
+
+static void __init cm_t35_init_ads7846(void)
+{
+        if ((gpio_request(CM_T35_GPIO_PENDOWN, "ADS7846_PENDOWN") == 0) &&
+            (gpio_direction_input(CM_T35_GPIO_PENDOWN) == 0)) {
+                gpio_export(CM_T35_GPIO_PENDOWN, 0);
+        } else {
+                pr_err("CM-T35: could not obtain gpio for ADS7846_PENDOWN\n");
+                return;
+        }
+
+        spi_register_board_info(cm_t35_spi_board_info,
+                                ARRAY_SIZE(cm_t35_spi_board_info));
+}
+#else
+static inline void cm_t35_init_ads7846(void) {}
+#endif
+
+static struct regulator_consumer_supply cm_t35_vmmc1_supply = {
+        .supply                 = "vmmc",
+};
+
+static struct regulator_consumer_supply cm_t35_vsim_supply = {
+        .supply                 = "vmmc_aux",
+};
+
+/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
+static struct regulator_init_data cm_t35_vmmc1 = {
+        .constraints = {
+                .min_uV                 = 1850000,
+                .max_uV                 = 3150000,
+                .valid_modes_mask       = REGULATOR_MODE_NORMAL
+                                        | REGULATOR_MODE_STANDBY,
+                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
+                                        | REGULATOR_CHANGE_MODE
+                                        | REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies  = 1,
+        .consumer_supplies      = &cm_t35_vmmc1_supply,
+};
+
+/* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */
+static struct regulator_init_data cm_t35_vsim = {
+        .constraints = {
+                .min_uV                 = 1800000,
+                .max_uV                 = 3000000,
+                .valid_modes_mask       = REGULATOR_MODE_NORMAL
+                                        | REGULATOR_MODE_STANDBY,
+                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
+                                        | REGULATOR_CHANGE_MODE
+                                        | REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies  = 1,
+        .consumer_supplies      = &cm_t35_vsim_supply,
+};
+
+static struct twl4030_usb_data cm_t35_usb_data = {
+        .usb_mode       = T2_USB_MODE_ULPI,
+};
+
+static int cm_t35_keymap[] = {
+        KEY(0, 0, KEY_A),       KEY(0, 1, KEY_B),       KEY(0, 2, KEY_LEFT),
+        KEY(1, 0, KEY_UP),      KEY(1, 1, KEY_ENTER),   KEY(1, 2, KEY_DOWN),
+        KEY(2, 0, KEY_RIGHT),   KEY(2, 1, KEY_C),       KEY(2, 2, KEY_D),
+};
+
+static struct matrix_keymap_data cm_t35_keymap_data = {
+        .keymap                 = cm_t35_keymap,
+        .keymap_size            = ARRAY_SIZE(cm_t35_keymap),
+};
+
+static struct twl4030_keypad_data cm_t35_kp_data = {
+        .keymap_data    = &cm_t35_keymap_data,
+        .rows           = 3,
+        .cols           = 3,
+        .rep            = 1,
+};
+
+static struct twl4030_hsmmc_info mmc[] = {
+        {
+                .mmc            = 1,
+                .wires          = 4,
+                .gpio_cd        = -EINVAL,
+                .gpio_wp        = -EINVAL,
+
+        },
+        {
+                .mmc            = 2,
+                .wires          = 4,
+                .transceiver    = 1,
+                .gpio_cd        = -EINVAL,
+                .gpio_wp        = -EINVAL,
+                .ocr_mask       = 0x00100000,   /* 3.3V */
+        },
+        {}      /* Terminator */
+};
+
+static struct ehci_hcd_omap_platform_data ehci_pdata = {
+        .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+
+        .phy_reset  = true,
+        .reset_gpio_port[0]  = -EINVAL,
+        .reset_gpio_port[1]  = -EINVAL,
+        .reset_gpio_port[2]  = -EINVAL
+};
+
+static int cm_t35_twl_gpio_setup(struct device *dev, unsigned gpio,
+                                 unsigned ngpio)
+{
+        int wlan_rst = gpio + 2;
+
+        if ((gpio_request(wlan_rst, "WLAN RST") == 0) &&
+            (gpio_direction_output(wlan_rst, 1) == 0)) {
+                gpio_export(wlan_rst, 0);
+
+                udelay(10);
+                gpio_set_value(wlan_rst, 0);
+                udelay(10);
+                gpio_set_value(wlan_rst, 1);
+        } else {
+                pr_err("CM-T35: could not obtain gpio for WiFi reset\n");
+        }
+
+        /* gpio + 0 is "mmc0_cd" (input/IRQ) */
+        mmc[0].gpio_cd = gpio + 0;
+        twl4030_mmc_init(mmc);
+
+        /* link regulators to MMC adapters */
+        cm_t35_vmmc1_supply.dev = mmc[0].dev;
+        cm_t35_vsim_supply.dev = mmc[0].dev;
+
+        /* setup USB with proper PHY reset GPIOs */
+        ehci_pdata.reset_gpio_port[0] = gpio + 6;
+        ehci_pdata.reset_gpio_port[1] = gpio + 7;
+
+        usb_ehci_init(&ehci_pdata);
+
+        return 0;
+}
+
+static struct twl4030_gpio_platform_data cm_t35_gpio_data = {
+        .gpio_base      = OMAP_MAX_GPIO_LINES,
+        .irq_base       = TWL4030_GPIO_IRQ_BASE,
+        .irq_end        = TWL4030_GPIO_IRQ_END,
+        .setup          = cm_t35_twl_gpio_setup,
+};
+
+static struct twl4030_platform_data cm_t35_twldata = {
+        .irq_base       = TWL4030_IRQ_BASE,
+        .irq_end        = TWL4030_IRQ_END,
+
+        /* platform_data for children goes here */
+        .keypad         = &cm_t35_kp_data,
+        .usb            = &cm_t35_usb_data,
+        .gpio           = &cm_t35_gpio_data,
+        .vmmc1          = &cm_t35_vmmc1,
+        .vsim           = &cm_t35_vsim,
+};
+
+static struct i2c_board_info __initdata cm_t35_i2c_boardinfo[] = {
+        {
+                I2C_BOARD_INFO("tps65930", 0x48),
+                .flags          = I2C_CLIENT_WAKE,
+                .irq            = INT_34XX_SYS_NIRQ,
+                .platform_data  = &cm_t35_twldata,
+        },
+};
+
+static void __init cm_t35_init_i2c(void)
+{
+        omap_register_i2c_bus(1, 2600, cm_t35_i2c_boardinfo,
+                              ARRAY_SIZE(cm_t35_i2c_boardinfo));
+}
+
+static struct omap_board_config_kernel cm_t35_config[] __initdata = {
+};
+
+static void __init cm_t35_init_irq(void)
+{
+        omap_board_config = cm_t35_config;
+        omap_board_config_size = ARRAY_SIZE(cm_t35_config);
+
+        omap2_init_common_hw(mt46h32m32lf6_sdrc_params,
+                             mt46h32m32lf6_sdrc_params);
+        omap_init_irq();
+        omap_gpio_init();
+}
+
+static void __init cm_t35_map_io(void)
+{
+        omap2_set_globals_343x();
+        omap2_map_common_io();
+}
+
+static void __init cm_t35_init(void)
+{
+        omap_serial_init();
+        cm_t35_init_i2c();
+        cm_t35_init_nand();
+        cm_t35_init_ads7846();
+        cm_t35_init_ethernet();
+        cm_t35_init_led();
+
+        usb_musb_init();
+
+        omap_cfg_reg(AF26_34XX_SYS_NIRQ);
+}
+
+MACHINE_START(CM_T35, "Compulab CM-T35")
+        .phys_io        = 0x48000000,
+        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .boot_params    = 0x80000100,
+        .map_io         = cm_t35_map_io,
+        .init_irq       = cm_t35_init_irq,
+        .init_machine   = cm_t35_init,
+        .timer          = &omap_timer,
+MACHINE_END
diff --git a/arch/arm/mach-omap2/board-generic.c b/arch/arm/mach-omap2/board-generic.c
index 2e09a1c444cb..7e6e6ca88be5 100644
--- a/arch/arm/mach-omap2/board-generic.c
+++ b/arch/arm/mach-omap2/board-generic.c
@@ -26,10 +26,10 @@
 #include <asm/mach/map.h>
 
 #include <mach/gpio.h>
-#include <mach/mux.h>
-#include <mach/usb.h>
-#include <mach/board.h>
-#include <mach/common.h>
+#include <plat/mux.h>
+#include <plat/usb.h>
+#include <plat/board.h>
+#include <plat/common.h>
 
 static struct omap_board_config_kernel generic_config[] = {
 };
@@ -56,7 +56,7 @@ static void __init omap_generic_map_io(void)
 MACHINE_START(OMAP_GENERIC, "Generic OMAP24xx")
         /* Maintainer: Paul Mundt <paul.mundt@nokia.com> */
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap_generic_map_io,
         .init_irq       = omap_generic_init_irq,
diff --git a/arch/arm/mach-omap2/board-h4.c b/arch/arm/mach-omap2/board-h4.c
index eaa02d012c5c..cfb7f1257d20 100644
--- a/arch/arm/mach-omap2/board-h4.c
+++ b/arch/arm/mach-omap2/board-h4.c
@@ -31,16 +31,16 @@
 #include <asm/mach/map.h>
 #include <asm/mach/flash.h>
 
-#include <mach/control.h>
+#include <plat/control.h>
 #include <mach/gpio.h>
-#include <mach/mux.h>
-#include <mach/usb.h>
-#include <mach/board.h>
-#include <mach/common.h>
-#include <mach/keypad.h>
-#include <mach/menelaus.h>
-#include <mach/dma.h>
-#include <mach/gpmc.h>
+#include <plat/mux.h>
+#include <plat/usb.h>
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/keypad.h>
+#include <plat/menelaus.h>
+#include <plat/dma.h>
+#include <plat/gpmc.h>
 
 #define H4_FLASH_CS     0
 #define H4_SMC91X_CS    1
@@ -376,7 +376,7 @@ static void __init omap_h4_map_io(void)
 MACHINE_START(OMAP_H4, "OMAP2420 H4 board")
         /* Maintainer: Paul Mundt <paul.mundt@nokia.com> */
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap_h4_map_io,
         .init_irq       = omap_h4_init_irq,
diff --git a/arch/arm/mach-omap2/board-igep0020.c b/arch/arm/mach-omap2/board-igep0020.c
new file mode 100644
index 000000000000..fa62e80c13b7
--- /dev/null
+++ b/arch/arm/mach-omap2/board-igep0020.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2009 Integration Software and Electronic Engineering.
+ *
+ * Modified from mach-omap2/board-generic.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 <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <linux/interrupt.h>
+
+#include <linux/regulator/machine.h>
+#include <linux/i2c/twl4030.h>
+
+#include <asm/mach-types.h>
+#include <asm/mach/arch.h>
+
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/gpmc.h>
+#include <plat/mux.h>
+#include <plat/usb.h>
+
+#include "mmc-twl4030.h"
+
+#define IGEP2_SMSC911X_CS       5
+#define IGEP2_SMSC911X_GPIO     176
+#define IGEP2_GPIO_USBH_NRESET  24
+#define IGEP2_GPIO_LED0_RED     26
+#define IGEP2_GPIO_LED0_GREEN   27
+#define IGEP2_GPIO_LED1_RED     28
+
+#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
+
+#include <linux/smsc911x.h>
+
+static struct smsc911x_platform_config igep2_smsc911x_config = {
+        .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
+        .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
+        .flags          = SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS  ,
+        .phy_interface  = PHY_INTERFACE_MODE_MII,
+};
+
+static struct resource igep2_smsc911x_resources[] = {
+        {
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = OMAP_GPIO_IRQ(IGEP2_SMSC911X_GPIO),
+                .end    = OMAP_GPIO_IRQ(IGEP2_SMSC911X_GPIO),
+                .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
+        },
+};
+
+static struct platform_device igep2_smsc911x_device = {
+        .name           = "smsc911x",
+        .id             = 0,
+        .num_resources  = ARRAY_SIZE(igep2_smsc911x_resources),
+        .resource       = igep2_smsc911x_resources,
+        .dev            = {
+                .platform_data = &igep2_smsc911x_config,
+        },
+};
+
+static inline void __init igep2_init_smsc911x(void)
+{
+        unsigned long cs_mem_base;
+
+        if (gpmc_cs_request(IGEP2_SMSC911X_CS, SZ_16M, &cs_mem_base) < 0) {
+                pr_err("IGEP v2: Failed request for GPMC mem for smsc911x\n");
+                gpmc_cs_free(IGEP2_SMSC911X_CS);
+                return;
+        }
+
+        igep2_smsc911x_resources[0].start = cs_mem_base + 0x0;
+        igep2_smsc911x_resources[0].end   = cs_mem_base + 0xff;
+
+        if ((gpio_request(IGEP2_SMSC911X_GPIO, "SMSC911X IRQ") == 0) &&
+            (gpio_direction_input(IGEP2_SMSC911X_GPIO) == 0)) {
+                gpio_export(IGEP2_SMSC911X_GPIO, 0);
+        } else {
+                pr_err("IGEP v2: Could not obtain gpio for for SMSC911X IRQ\n");
+                return;
+        }
+
+        platform_device_register(&igep2_smsc911x_device);
+}
+
+#else
+static inline void __init igep2_init_smsc911x(void) { }
+#endif
+
+static struct omap_board_config_kernel igep2_config[] __initdata = {
+};
+
+static struct regulator_consumer_supply igep2_vmmc1_supply = {
+        .supply         = "vmmc",
+};
+
+/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
+static struct regulator_init_data igep2_vmmc1 = {
+        .constraints = {
+                .min_uV                 = 1850000,
+                .max_uV                 = 3150000,
+                .valid_modes_mask       = REGULATOR_MODE_NORMAL
+                                        | REGULATOR_MODE_STANDBY,
+                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
+                                        | REGULATOR_CHANGE_MODE
+                                        | REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies  = 1,
+        .consumer_supplies      = &igep2_vmmc1_supply,
+};
+
+static struct twl4030_hsmmc_info mmc[] = {
+        {
+                .mmc            = 1,
+                .wires          = 4,
+                .gpio_cd        = -EINVAL,
+                .gpio_wp        = -EINVAL,
+        },
+        {
+                .mmc            = 2,
+                .wires          = 4,
+                .gpio_cd        = -EINVAL,
+                .gpio_wp        = -EINVAL,
+        },
+        {}      /* Terminator */
+};
+
+static int igep2_twl_gpio_setup(struct device *dev,
+                unsigned gpio, unsigned ngpio)
+{
+        /* gpio + 0 is "mmc0_cd" (input/IRQ) */
+        mmc[0].gpio_cd = gpio + 0;
+        twl4030_mmc_init(mmc);
+
+        /* link regulators to MMC adapters ... we "know" the
+         * regulators will be set up only *after* we return.
+        */
+        igep2_vmmc1_supply.dev = mmc[0].dev;
+
+        return 0;
+};
+
+static struct twl4030_gpio_platform_data igep2_gpio_data = {
+        .gpio_base      = OMAP_MAX_GPIO_LINES,
+        .irq_base       = TWL4030_GPIO_IRQ_BASE,
+        .irq_end        = TWL4030_GPIO_IRQ_END,
+        .use_leds       = false,
+        .setup          = igep2_twl_gpio_setup,
+};
+
+static struct twl4030_usb_data igep2_usb_data = {
+        .usb_mode       = T2_USB_MODE_ULPI,
+};
+
+static void __init igep2_init_irq(void)
+{
+        omap_board_config = igep2_config;
+        omap_board_config_size = ARRAY_SIZE(igep2_config);
+        omap2_init_common_hw(NULL, NULL);
+        omap_init_irq();
+        omap_gpio_init();
+}
+
+static struct twl4030_platform_data igep2_twldata = {
+        .irq_base       = TWL4030_IRQ_BASE,
+        .irq_end        = TWL4030_IRQ_END,
+
+        /* platform_data for children goes here */
+        .usb            = &igep2_usb_data,
+        .gpio           = &igep2_gpio_data,
+        .vmmc1          = &igep2_vmmc1,
+
+};
+
+static struct i2c_board_info __initdata igep2_i2c_boardinfo[] = {
+        {
+                I2C_BOARD_INFO("twl4030", 0x48),
+                .flags          = I2C_CLIENT_WAKE,
+                .irq            = INT_34XX_SYS_NIRQ,
+                .platform_data  = &igep2_twldata,
+        },
+};
+
+static int __init igep2_i2c_init(void)
+{
+        omap_register_i2c_bus(1, 2600, igep2_i2c_boardinfo,
+                        ARRAY_SIZE(igep2_i2c_boardinfo));
+        /* 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, NULL, 0);
+        return 0;
+}
+
+static void __init igep2_init(void)
+{
+        igep2_i2c_init();
+        omap_serial_init();
+        usb_musb_init();
+
+        igep2_init_smsc911x();
+
+        /* GPIO userspace leds */
+        if ((gpio_request(IGEP2_GPIO_LED0_RED, "GPIO_LED0_RED") == 0) &&
+            (gpio_direction_output(IGEP2_GPIO_LED0_RED, 1) == 0)) {
+                gpio_export(IGEP2_GPIO_LED0_RED, 0);
+                gpio_set_value(IGEP2_GPIO_LED0_RED, 0);
+        } else
+                pr_warning("IGEP v2: Could not obtain gpio GPIO_LED0_RED\n");
+
+        if ((gpio_request(IGEP2_GPIO_LED0_GREEN, "GPIO_LED0_GREEN") == 0) &&
+            (gpio_direction_output(IGEP2_GPIO_LED0_GREEN, 1) == 0)) {
+                gpio_export(IGEP2_GPIO_LED0_GREEN, 0);
+                gpio_set_value(IGEP2_GPIO_LED0_GREEN, 0);
+        } else
+                pr_warning("IGEP v2: Could not obtain gpio GPIO_LED0_GREEN\n");
+
+        if ((gpio_request(IGEP2_GPIO_LED1_RED, "GPIO_LED1_RED") == 0) &&
+            (gpio_direction_output(IGEP2_GPIO_LED1_RED, 1) == 0)) {
+                gpio_export(IGEP2_GPIO_LED1_RED, 0);
+                gpio_set_value(IGEP2_GPIO_LED1_RED, 0);
+        } else
+                pr_warning("IGEP v2: Could not obtain gpio GPIO_LED1_RED\n");
+}
+
+static void __init igep2_map_io(void)
+{
+        omap2_set_globals_343x();
+        omap2_map_common_io();
+}
+
+MACHINE_START(IGEP0020, "IGEP v2 board")
+        .phys_io        = 0x48000000,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
+        .boot_params    = 0x80000100,
+        .map_io         = igep2_map_io,
+        .init_irq       = igep2_init_irq,
+        .init_machine   = igep2_init,
+        .timer          = &omap_timer,
+MACHINE_END
diff --git a/arch/arm/mach-omap2/board-ldp.c b/arch/arm/mach-omap2/board-ldp.c
index d110a7fdfbd8..c062238fe881 100644
--- a/arch/arm/mach-omap2/board-ldp.c
+++ b/arch/arm/mach-omap2/board-ldp.c
@@ -16,6 +16,7 @@
 #include <linux/platform_device.h>
 #include <linux/delay.h>
 #include <linux/input.h>
+#include <linux/input/matrix_keypad.h>
 #include <linux/gpio_keys.h>
 #include <linux/workqueue.h>
 #include <linux/err.h>
@@ -32,16 +33,15 @@
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
-#include <mach/mcspi.h>
+#include <plat/mcspi.h>
 #include <mach/gpio.h>
-#include <mach/board.h>
-#include <mach/common.h>
-#include <mach/gpmc.h>
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/gpmc.h>
 
 #include <asm/delay.h>
-#include <mach/control.h>
-#include <mach/usb.h>
-#include <mach/keypad.h>
+#include <plat/control.h>
+#include <plat/usb.h>
 
 #include "mmc-twl4030.h"
 
@@ -399,7 +399,7 @@ static void __init omap_ldp_map_io(void)
 
 MACHINE_START(OMAP_LDP, "OMAP LDP board")
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap_ldp_map_io,
         .init_irq       = omap_ldp_init_irq,
diff --git a/arch/arm/mach-omap2/board-n8x0.c b/arch/arm/mach-omap2/board-n8x0.c
index 8341632d260b..764ab1ed576d 100644
--- a/arch/arm/mach-omap2/board-n8x0.c
+++ b/arch/arm/mach-omap2/board-n8x0.c
@@ -23,12 +23,12 @@
 #include <asm/mach/arch.h>
 #include <asm/mach-types.h>
 
-#include <mach/board.h>
-#include <mach/common.h>
+#include <plat/board.h>
+#include <plat/common.h>
 #include <mach/irqs.h>
-#include <mach/mcspi.h>
-#include <mach/onenand.h>
-#include <mach/serial.h>
+#include <plat/mcspi.h>
+#include <plat/onenand.h>
+#include <plat/serial.h>
 
 static struct omap2_mcspi_device_config p54spi_mcspi_config = {
         .turbo_mode     = 0,
@@ -121,7 +121,7 @@ static void __init n8x0_init_machine(void)
 
 MACHINE_START(NOKIA_N800, "Nokia N800")
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = n8x0_map_io,
         .init_irq       = n8x0_init_irq,
@@ -131,7 +131,7 @@ MACHINE_END
 
 MACHINE_START(NOKIA_N810, "Nokia N810")
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = n8x0_map_io,
         .init_irq       = n8x0_init_irq,
@@ -141,7 +141,7 @@ MACHINE_END
 
 MACHINE_START(NOKIA_N810_WIMAX, "Nokia N810 WiMAX")
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = n8x0_map_io,
         .init_irq       = n8x0_init_irq,
diff --git a/arch/arm/mach-omap2/board-omap3beagle.c b/arch/arm/mach-omap2/board-omap3beagle.c
index 70df6b4dbcd4..41480bd0e58a 100644
--- a/arch/arm/mach-omap2/board-omap3beagle.c
+++ b/arch/arm/mach-omap2/board-omap3beagle.c
@@ -37,13 +37,13 @@
 #include <asm/mach/map.h>
 #include <asm/mach/flash.h>
 
-#include <mach/board.h>
-#include <mach/common.h>
-#include <mach/gpmc.h>
-#include <mach/nand.h>
-#include <mach/mux.h>
-#include <mach/usb.h>
-#include <mach/timer-gp.h>
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/gpmc.h>
+#include <plat/nand.h>
+#include <plat/mux.h>
+#include <plat/usb.h>
+#include <plat/timer-gp.h>
 
 #include "mmc-twl4030.h"
 
@@ -162,7 +162,7 @@ static int beagle_twl_gpio_setup(struct device *dev,
 
         /* TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, active low) */
         gpio_request(gpio + TWL4030_GPIO_MAX, "nEN_USB_PWR");
-        gpio_direction_output(gpio + TWL4030_GPIO_MAX, 1);
+        gpio_direction_output(gpio + TWL4030_GPIO_MAX, 0);
 
         /* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
         gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;
@@ -254,6 +254,15 @@ static struct twl4030_usb_data beagle_usb_data = {
         .usb_mode       = T2_USB_MODE_ULPI,
 };
 
+static struct twl4030_codec_audio_data beagle_audio_data = {
+        .audio_mclk = 26000000,
+};
+
+static struct twl4030_codec_data beagle_codec_data = {
+        .audio_mclk = 26000000,
+        .audio = &beagle_audio_data,
+};
+
 static struct twl4030_platform_data beagle_twldata = {
         .irq_base       = TWL4030_IRQ_BASE,
         .irq_end        = TWL4030_IRQ_END,
@@ -261,6 +270,7 @@ static struct twl4030_platform_data beagle_twldata = {
         /* platform_data for children goes here */
         .usb            = &beagle_usb_data,
         .gpio           = &beagle_gpio_data,
+        .codec          = &beagle_codec_data,
         .vmmc1          = &beagle_vmmc1,
         .vsim           = &beagle_vsim,
         .vdac           = &beagle_vdac,
@@ -400,6 +410,18 @@ static void __init omap3beagle_flash_init(void)
         }
 }
 
+static struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
+
+        .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+
+        .phy_reset  = true,
+        .reset_gpio_port[0]  = -EINVAL,
+        .reset_gpio_port[1]  = 147,
+        .reset_gpio_port[2]  = -EINVAL
+};
+
 static void __init omap3_beagle_init(void)
 {
         omap3_beagle_i2c_init();
@@ -413,6 +435,7 @@ static void __init omap3_beagle_init(void)
         gpio_direction_output(170, true);
 
         usb_musb_init();
+        usb_ehci_init(&ehci_pdata);
         omap3beagle_flash_init();
 
         /* Ensure SDRC pins are mux'd for self-refresh */
@@ -429,7 +452,7 @@ static void __init omap3_beagle_map_io(void)
 MACHINE_START(OMAP3_BEAGLE, "OMAP3 Beagle Board")
         /* Maintainer: Syed Mohammed Khasim - http://beagleboard.org */
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap3_beagle_map_io,
         .init_irq       = omap3_beagle_init_irq,
diff --git a/arch/arm/mach-omap2/board-omap3evm.c b/arch/arm/mach-omap2/board-omap3evm.c
index e4ec0c591216..5efc2e9068db 100644
--- a/arch/arm/mach-omap2/board-omap3evm.c
+++ b/arch/arm/mach-omap2/board-omap3evm.c
@@ -20,36 +20,76 @@
 #include <linux/clk.h>
 #include <linux/gpio.h>
 #include <linux/input.h>
+#include <linux/input/matrix_keypad.h>
 #include <linux/leds.h>
+#include <linux/interrupt.h>
 
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
 #include <linux/i2c/twl4030.h>
 #include <linux/usb/otg.h>
+#include <linux/smsc911x.h>
+
+#include <linux/regulator/machine.h>
 
 #include <mach/hardware.h>
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
-#include <mach/board.h>
-#include <mach/mux.h>
-#include <mach/usb.h>
-#include <mach/common.h>
-#include <mach/mcspi.h>
-#include <mach/keypad.h>
+#include <plat/board.h>
+#include <plat/mux.h>
+#include <plat/usb.h>
+#include <plat/common.h>
+#include <plat/mcspi.h>
 
 #include "sdram-micron-mt46h32m32lf-6.h"
 #include "mmc-twl4030.h"
 
 #define OMAP3_EVM_TS_GPIO       175
+#define OMAP3_EVM_EHCI_VBUS     22
+#define OMAP3_EVM_EHCI_SELECT   61
 
 #define OMAP3EVM_ETHR_START     0x2c000000
 #define OMAP3EVM_ETHR_SIZE      1024
+#define OMAP3EVM_ETHR_ID_REV    0x50
 #define OMAP3EVM_ETHR_GPIO_IRQ  176
-#define OMAP3EVM_SMC911X_CS     5
+#define OMAP3EVM_SMSC911X_CS    5
+
+static u8 omap3_evm_version;
+
+u8 get_omap3_evm_rev(void)
+{
+        return omap3_evm_version;
+}
+EXPORT_SYMBOL(get_omap3_evm_rev);
+
+static void __init omap3_evm_get_revision(void)
+{
+        void __iomem *ioaddr;
+        unsigned int smsc_id;
+
+        /* Ethernet PHY ID is stored at ID_REV register */
+        ioaddr = ioremap_nocache(OMAP3EVM_ETHR_START, SZ_1K);
+        if (!ioaddr)
+                return;
+        smsc_id = readl(ioaddr + OMAP3EVM_ETHR_ID_REV) & 0xFFFF0000;
+        iounmap(ioaddr);
+
+        switch (smsc_id) {
+        /*SMSC9115 chipset*/
+        case 0x01150000:
+                omap3_evm_version = OMAP3EVM_BOARD_GEN_1;
+                break;
+        /*SMSC 9220 chipset*/
+        case 0x92200000:
+        default:
+                omap3_evm_version = OMAP3EVM_BOARD_GEN_2;
+        }
+}
 
-static struct resource omap3evm_smc911x_resources[] = {
+#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
+static struct resource omap3evm_smsc911x_resources[] = {
         [0] =   {
                 .start  = OMAP3EVM_ETHR_START,
                 .end    = (OMAP3EVM_ETHR_START + OMAP3EVM_ETHR_SIZE - 1),
@@ -58,24 +98,34 @@ static struct resource omap3evm_smc911x_resources[] = {
         [1] =   {
                 .start  = OMAP_GPIO_IRQ(OMAP3EVM_ETHR_GPIO_IRQ),
                 .end    = OMAP_GPIO_IRQ(OMAP3EVM_ETHR_GPIO_IRQ),
-                .flags  = IORESOURCE_IRQ,
+                .flags  = (IORESOURCE_IRQ | IRQF_TRIGGER_LOW),
         },
 };
 
-static struct platform_device omap3evm_smc911x_device = {
-        .name           = "smc911x",
+static struct smsc911x_platform_config smsc911x_config = {
+        .phy_interface  = PHY_INTERFACE_MODE_MII,
+        .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
+        .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
+        .flags          = (SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS),
+};
+
+static struct platform_device omap3evm_smsc911x_device = {
+        .name           = "smsc911x",
         .id             = -1,
-        .num_resources  = ARRAY_SIZE(omap3evm_smc911x_resources),
-        .resource       = &omap3evm_smc911x_resources[0],
+        .num_resources  = ARRAY_SIZE(omap3evm_smsc911x_resources),
+        .resource       = &omap3evm_smsc911x_resources[0],
+        .dev            = {
+                .platform_data = &smsc911x_config,
+        },
 };
 
-static inline void __init omap3evm_init_smc911x(void)
+static inline void __init omap3evm_init_smsc911x(void)
 {
         int eth_cs;
         struct clk *l3ck;
         unsigned int rate;
 
-        eth_cs = OMAP3EVM_SMC911X_CS;
+        eth_cs = OMAP3EVM_SMSC911X_CS;
 
         l3ck = clk_get(NULL, "l3_ck");
         if (IS_ERR(l3ck))
@@ -83,15 +133,58 @@ static inline void __init omap3evm_init_smc911x(void)
         else
                 rate = clk_get_rate(l3ck);
 
-        if (gpio_request(OMAP3EVM_ETHR_GPIO_IRQ, "SMC911x irq") < 0) {
-                printk(KERN_ERR "Failed to request GPIO%d for smc911x IRQ\n",
+        if (gpio_request(OMAP3EVM_ETHR_GPIO_IRQ, "SMSC911x irq") < 0) {
+                printk(KERN_ERR "Failed to request GPIO%d for smsc911x IRQ\n",
                         OMAP3EVM_ETHR_GPIO_IRQ);
                 return;
         }
 
         gpio_direction_input(OMAP3EVM_ETHR_GPIO_IRQ);
+        platform_device_register(&omap3evm_smsc911x_device);
 }
 
+#else
+static inline void __init omap3evm_init_smsc911x(void) { return; }
+#endif
+
+static struct regulator_consumer_supply omap3evm_vmmc1_supply = {
+        .supply                 = "vmmc",
+};
+
+static struct regulator_consumer_supply omap3evm_vsim_supply = {
+        .supply                 = "vmmc_aux",
+};
+
+/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
+static struct regulator_init_data omap3evm_vmmc1 = {
+        .constraints = {
+                .min_uV                 = 1850000,
+                .max_uV                 = 3150000,
+                .valid_modes_mask       = REGULATOR_MODE_NORMAL
+                                        | REGULATOR_MODE_STANDBY,
+                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
+                                        | REGULATOR_CHANGE_MODE
+                                        | REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies  = 1,
+        .consumer_supplies      = &omap3evm_vmmc1_supply,
+};
+
+/* VSIM for MMC1 pins DAT4..DAT7 (2 mA, plus card == max 50 mA) */
+static struct regulator_init_data omap3evm_vsim = {
+        .constraints = {
+                .min_uV                 = 1800000,
+                .max_uV                 = 3000000,
+                .valid_modes_mask       = REGULATOR_MODE_NORMAL
+                                        | REGULATOR_MODE_STANDBY,
+                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
+                                        | REGULATOR_CHANGE_MODE
+                                        | REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies  = 1,
+        .consumer_supplies      = &omap3evm_vsim_supply,
+};
+
 static struct twl4030_hsmmc_info mmc[] = {
         {
                 .mmc            = 1,
@@ -134,6 +227,10 @@ static int omap3evm_twl_gpio_setup(struct device *dev,
         mmc[0].gpio_cd = gpio + 0;
         twl4030_mmc_init(mmc);
 
+        /* link regulators to MMC adapters */
+        omap3evm_vmmc1_supply.dev = mmc[0].dev;
+        omap3evm_vsim_supply.dev = mmc[0].dev;
+
         /*
          * Most GPIOs are for USB OTG.  Some are mostly sent to
          * the P2 connector; notably LEDA for the LCD backlight.
@@ -194,6 +291,15 @@ static struct twl4030_madc_platform_data omap3evm_madc_data = {
         .irq_line       = 1,
 };
 
+static struct twl4030_codec_audio_data omap3evm_audio_data = {
+        .audio_mclk = 26000000,
+};
+
+static struct twl4030_codec_data omap3evm_codec_data = {
+        .audio_mclk = 26000000,
+        .audio = &omap3evm_audio_data,
+};
+
 static struct twl4030_platform_data omap3evm_twldata = {
         .irq_base       = TWL4030_IRQ_BASE,
         .irq_end        = TWL4030_IRQ_END,
@@ -203,6 +309,7 @@ static struct twl4030_platform_data omap3evm_twldata = {
         .madc           = &omap3evm_madc_data,
         .usb            = &omap3evm_usb_data,
         .gpio           = &omap3evm_gpio_data,
+        .codec          = &omap3evm_codec_data,
 };
 
 static struct i2c_board_info __initdata omap3evm_i2c_boardinfo[] = {
@@ -216,6 +323,13 @@ static struct i2c_board_info __initdata omap3evm_i2c_boardinfo[] = {
 
 static int __init omap3_evm_i2c_init(void)
 {
+        /*
+         * REVISIT: These entries can be set in omap3evm_twl_data
+         * after a merge with MFD tree
+         */
+        omap3evm_twldata.vmmc1 = &omap3evm_vmmc1;
+        omap3evm_twldata.vsim = &omap3evm_vsim;
+
         omap_register_i2c_bus(1, 2600, omap3evm_i2c_boardinfo,
                         ARRAY_SIZE(omap3evm_i2c_boardinfo));
         omap_register_i2c_bus(2, 400, NULL, 0);
@@ -289,16 +403,29 @@ static void __init omap3_evm_init_irq(void)
         omap2_init_common_hw(mt46h32m32lf6_sdrc_params, NULL);
         omap_init_irq();
         omap_gpio_init();
-        omap3evm_init_smc911x();
 }
 
 static struct platform_device *omap3_evm_devices[] __initdata = {
         &omap3_evm_lcd_device,
-        &omap3evm_smc911x_device,
+};
+
+static struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
+
+        .port_mode[0] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+        .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+
+        .phy_reset  = true,
+        /* PHY reset GPIO will be runtime programmed based on EVM version */
+        .reset_gpio_port[0]  = -EINVAL,
+        .reset_gpio_port[1]  = -EINVAL,
+        .reset_gpio_port[2]  = -EINVAL
 };
 
 static void __init omap3_evm_init(void)
 {
+        omap3_evm_get_revision();
+
         omap3_evm_i2c_init();
 
         platform_add_devices(omap3_evm_devices, ARRAY_SIZE(omap3_evm_devices));
@@ -311,8 +438,32 @@ static void __init omap3_evm_init(void)
         /* OMAP3EVM uses ISP1504 phy and so register nop transceiver */
         usb_nop_xceiv_register();
 #endif
+        if (get_omap3_evm_rev() >= OMAP3EVM_BOARD_GEN_2) {
+                /* enable EHCI VBUS using GPIO22 */
+                omap_cfg_reg(AF9_34XX_GPIO22);
+                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_cfg_reg(U3_34XX_GPIO61);
+                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_cfg_reg(AH14_34XX_GPIO21);
+                ehci_pdata.reset_gpio_port[1] = 21;
+
+        } else {
+                /* setup EHCI phy reset on MDC */
+                omap_cfg_reg(AF4_34XX_GPIO135_OUT);
+                ehci_pdata.reset_gpio_port[1] = 135;
+        }
         usb_musb_init();
+        usb_ehci_init(&ehci_pdata);
         ads7846_dev_init();
+        omap3evm_init_smsc911x();
 }
 
 static void __init omap3_evm_map_io(void)
@@ -324,7 +475,7 @@ static void __init omap3_evm_map_io(void)
 MACHINE_START(OMAP3EVM, "OMAP3 EVM")
         /* Maintainer: Syed Mohammed Khasim - Texas Instruments */
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap3_evm_map_io,
         .init_irq       = omap3_evm_init_irq,
diff --git a/arch/arm/mach-omap2/board-omap3pandora.c b/arch/arm/mach-omap2/board-omap3pandora.c
index 7f6bf8772af7..2db5ba5b3bf7 100644
--- a/arch/arm/mach-omap2/board-omap3pandora.c
+++ b/arch/arm/mach-omap2/board-omap3pandora.c
@@ -27,20 +27,20 @@
 #include <linux/i2c/twl4030.h>
 #include <linux/leds.h>
 #include <linux/input.h>
+#include <linux/input/matrix_keypad.h>
 #include <linux/gpio_keys.h>
 
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
-#include <mach/board.h>
-#include <mach/common.h>
+#include <plat/board.h>
+#include <plat/common.h>
 #include <mach/gpio.h>
 #include <mach/hardware.h>
-#include <mach/mcspi.h>
-#include <mach/usb.h>
-#include <mach/keypad.h>
-#include <mach/mux.h>
+#include <plat/mcspi.h>
+#include <plat/usb.h>
+#include <plat/mux.h>
 
 #include "sdram-micron-mt46h32m32lf-6.h"
 #include "mmc-twl4030.h"
@@ -134,50 +134,50 @@ static void __init pandora_keys_gpio_init(void)
 }
 
 static int board_keymap[] = {
-        /* col, row, code */
+        /* row, col, code */
         KEY(0, 0, KEY_9),
-        KEY(0, 1, KEY_0),
-        KEY(0, 2, KEY_BACKSPACE),
-        KEY(0, 3, KEY_O),
-        KEY(0, 4, KEY_P),
-        KEY(0, 5, KEY_K),
-        KEY(0, 6, KEY_L),
-        KEY(0, 7, KEY_ENTER),
-        KEY(1, 0, KEY_8),
+        KEY(0, 1, KEY_8),
+        KEY(0, 2, KEY_I),
+        KEY(0, 3, KEY_J),
+        KEY(0, 4, KEY_N),
+        KEY(0, 5, KEY_M),
+        KEY(1, 0, KEY_0),
         KEY(1, 1, KEY_7),
-        KEY(1, 2, KEY_6),
-        KEY(1, 3, KEY_5),
-        KEY(1, 4, KEY_4),
-        KEY(1, 5, KEY_3),
-        KEY(1, 6, KEY_2),
-        KEY(1, 7, KEY_1),
-        KEY(2, 0, KEY_I),
-        KEY(2, 1, KEY_U),
+        KEY(1, 2, KEY_U),
+        KEY(1, 3, KEY_H),
+        KEY(1, 4, KEY_B),
+        KEY(1, 5, KEY_SPACE),
+        KEY(2, 0, KEY_BACKSPACE),
+        KEY(2, 1, KEY_6),
         KEY(2, 2, KEY_Y),
-        KEY(2, 3, KEY_T),
-        KEY(2, 4, KEY_R),
-        KEY(2, 5, KEY_E),
-        KEY(2, 6, KEY_W),
-        KEY(2, 7, KEY_Q),
-        KEY(3, 0, KEY_J),
-        KEY(3, 1, KEY_H),
-        KEY(3, 2, KEY_G),
+        KEY(2, 3, KEY_G),
+        KEY(2, 4, KEY_V),
+        KEY(2, 5, KEY_FN),
+        KEY(3, 0, KEY_O),
+        KEY(3, 1, KEY_5),
+        KEY(3, 2, KEY_T),
         KEY(3, 3, KEY_F),
-        KEY(3, 4, KEY_D),
-        KEY(3, 5, KEY_S),
-        KEY(3, 6, KEY_A),
-        KEY(3, 7, KEY_LEFTSHIFT),
-        KEY(4, 0, KEY_N),
-        KEY(4, 1, KEY_B),
-        KEY(4, 2, KEY_V),
-        KEY(4, 3, KEY_C),
+        KEY(3, 4, KEY_C),
+        KEY(4, 0, KEY_P),
+        KEY(4, 1, KEY_4),
+        KEY(4, 2, KEY_R),
+        KEY(4, 3, KEY_D),
         KEY(4, 4, KEY_X),
-        KEY(4, 5, KEY_Z),
-        KEY(4, 6, KEY_DOT),
-        KEY(4, 7, KEY_COMMA),
-        KEY(5, 0, KEY_M),
-        KEY(5, 1, KEY_SPACE),
-        KEY(5, 2, KEY_FN),
+        KEY(5, 0, KEY_K),
+        KEY(5, 1, KEY_3),
+        KEY(5, 2, KEY_E),
+        KEY(5, 3, KEY_S),
+        KEY(5, 4, KEY_Z),
+        KEY(6, 0, KEY_L),
+        KEY(6, 1, KEY_2),
+        KEY(6, 2, KEY_W),
+        KEY(6, 3, KEY_A),
+        KEY(6, 4, KEY_DOT),
+        KEY(7, 0, KEY_ENTER),
+        KEY(7, 1, KEY_1),
+        KEY(7, 2, KEY_Q),
+        KEY(7, 3, KEY_LEFTSHIFT),
+        KEY(7, 4, KEY_COMMA),
 };
 
 static struct matrix_keymap_data board_map_data = {
@@ -281,11 +281,21 @@ static struct twl4030_usb_data omap3pandora_usb_data = {
         .usb_mode       = T2_USB_MODE_ULPI,
 };
 
+static struct twl4030_codec_audio_data omap3pandora_audio_data = {
+        .audio_mclk = 26000000,
+};
+
+static struct twl4030_codec_data omap3pandora_codec_data = {
+        .audio_mclk = 26000000,
+        .audio = &omap3pandora_audio_data,
+};
+
 static struct twl4030_platform_data omap3pandora_twldata = {
         .irq_base       = TWL4030_IRQ_BASE,
         .irq_end        = TWL4030_IRQ_END,
         .gpio           = &omap3pandora_gpio_data,
         .usb            = &omap3pandora_usb_data,
+        .codec          = &omap3pandora_codec_data,
         .vmmc1          = &pandora_vmmc1,
         .vmmc2          = &pandora_vmmc2,
         .keypad         = &pandora_kp_data,
@@ -387,6 +397,18 @@ static struct platform_device *omap3pandora_devices[] __initdata = {
         &pandora_keys_gpio,
 };
 
+static struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
+
+        .port_mode[0] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[1] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+        .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+
+        .phy_reset  = true,
+        .reset_gpio_port[0]  = 16,
+        .reset_gpio_port[1]  = -EINVAL,
+        .reset_gpio_port[2]  = -EINVAL
+};
+
 static void __init omap3pandora_init(void)
 {
         omap3pandora_i2c_init();
@@ -396,6 +418,7 @@ static void __init omap3pandora_init(void)
         spi_register_board_info(omap3pandora_spi_board_info,
                         ARRAY_SIZE(omap3pandora_spi_board_info));
         omap3pandora_ads7846_init();
+        usb_ehci_init(&ehci_pdata);
         pandora_keys_gpio_init();
         usb_musb_init();
 
@@ -412,7 +435,7 @@ static void __init omap3pandora_map_io(void)
 
 MACHINE_START(OMAP3_PANDORA, "Pandora Handheld Console")
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap3pandora_map_io,
         .init_irq       = omap3pandora_init_irq,
diff --git a/arch/arm/mach-omap2/board-overo.c b/arch/arm/mach-omap2/board-overo.c
index 9917d2fddc2f..52dfd51a938e 100644
--- a/arch/arm/mach-omap2/board-overo.c
+++ b/arch/arm/mach-omap2/board-overo.c
@@ -38,14 +38,14 @@
 #include <asm/mach/flash.h>
 #include <asm/mach/map.h>
 
-#include <mach/board.h>
-#include <mach/common.h>
+#include <plat/board.h>
+#include <plat/common.h>
 #include <mach/gpio.h>
-#include <mach/gpmc.h>
+#include <plat/gpmc.h>
 #include <mach/hardware.h>
-#include <mach/nand.h>
-#include <mach/mux.h>
-#include <mach/usb.h>
+#include <plat/nand.h>
+#include <plat/mux.h>
+#include <plat/usb.h>
 
 #include "sdram-micron-mt46h32m32lf-6.h"
 #include "mmc-twl4030.h"
@@ -67,7 +67,7 @@
 #if defined(CONFIG_TOUCHSCREEN_ADS7846) || \
         defined(CONFIG_TOUCHSCREEN_ADS7846_MODULE)
 
-#include <mach/mcspi.h>
+#include <plat/mcspi.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/ads7846.h>
 
@@ -329,6 +329,15 @@ static struct regulator_init_data overo_vmmc1 = {
         .consumer_supplies      = &overo_vmmc1_supply,
 };
 
+static struct twl4030_codec_audio_data overo_audio_data = {
+        .audio_mclk = 26000000,
+};
+
+static struct twl4030_codec_data overo_codec_data = {
+        .audio_mclk = 26000000,
+        .audio = &overo_audio_data,
+};
+
 /* mmc2 (WLAN) and Bluetooth don't use twl4030 regulators */
 
 static struct twl4030_platform_data overo_twldata = {
@@ -336,6 +345,7 @@ static struct twl4030_platform_data overo_twldata = {
         .irq_end        = TWL4030_IRQ_END,
         .gpio           = &overo_gpio_data,
         .usb            = &overo_usb_data,
+        .codec          = &overo_codec_data,
         .vmmc1          = &overo_vmmc1,
 };
 
@@ -384,6 +394,18 @@ static struct platform_device *overo_devices[] __initdata = {
         &overo_lcd_device,
 };
 
+static struct ehci_hcd_omap_platform_data ehci_pdata __initconst = {
+        .port_mode[0] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+        .port_mode[1] = EHCI_HCD_OMAP_MODE_PHY,
+        .port_mode[2] = EHCI_HCD_OMAP_MODE_UNKNOWN,
+
+        .phy_reset  = true,
+        .reset_gpio_port[0]  = -EINVAL,
+        .reset_gpio_port[1]  = OVERO_GPIO_USBH_NRESET,
+        .reset_gpio_port[2]  = -EINVAL
+};
+
+
 static void __init overo_init(void)
 {
         overo_i2c_init();
@@ -391,6 +413,7 @@ static void __init overo_init(void)
         omap_serial_init();
         overo_flash_init();
         usb_musb_init();
+        usb_ehci_init(&ehci_pdata);
         overo_ads7846_init();
         overo_init_smsc911x();
 
@@ -433,14 +456,6 @@ static void __init overo_init(void)
         else
                 printk(KERN_ERR "could not obtain gpio for "
                                         "OVERO_GPIO_USBH_CPEN\n");
-
-        if ((gpio_request(OVERO_GPIO_USBH_NRESET,
-                          "OVERO_GPIO_USBH_NRESET") == 0) &&
-            (gpio_direction_output(OVERO_GPIO_USBH_NRESET, 1) == 0))
-                gpio_export(OVERO_GPIO_USBH_NRESET, 0);
-        else
-                printk(KERN_ERR "could not obtain gpio for "
-                                        "OVERO_GPIO_USBH_NRESET\n");
 }
 
 static void __init overo_map_io(void)
@@ -451,7 +466,7 @@ static void __init overo_map_io(void)
 
 MACHINE_START(OVERO, "Gumstix Overo")
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = overo_map_io,
         .init_irq       = overo_init_irq,
diff --git a/arch/arm/mach-omap2/board-rx51-peripherals.c b/arch/arm/mach-omap2/board-rx51-peripherals.c
index 2b0eb1ba5d7f..15ce6514c5fd 100644
--- a/arch/arm/mach-omap2/board-rx51-peripherals.c
+++ b/arch/arm/mach-omap2/board-rx51-peripherals.c
@@ -12,30 +12,139 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/input.h>
+#include <linux/input/matrix_keypad.h>
 #include <linux/spi/spi.h>
+#include <linux/spi/wl12xx.h>
 #include <linux/i2c.h>
 #include <linux/i2c/twl4030.h>
 #include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/regulator/machine.h>
 #include <linux/gpio.h>
+#include <linux/gpio_keys.h>
 #include <linux/mmc/host.h>
 
-#include <mach/mcspi.h>
-#include <mach/mux.h>
-#include <mach/board.h>
-#include <mach/common.h>
-#include <mach/dma.h>
-#include <mach/gpmc.h>
-#include <mach/keypad.h>
-#include <mach/onenand.h>
-#include <mach/gpmc-smc91x.h>
+#include <plat/mcspi.h>
+#include <plat/mux.h>
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/dma.h>
+#include <plat/gpmc.h>
+#include <plat/onenand.h>
+#include <plat/gpmc-smc91x.h>
 
 #include "mmc-twl4030.h"
 
 #define SYSTEM_REV_B_USES_VAUX3 0x1699
 #define SYSTEM_REV_S_USES_VAUX3 0x8
 
+#define RX51_WL1251_POWER_GPIO          87
+#define RX51_WL1251_IRQ_GPIO            42
+
+/* list all spi devices here */
+enum {
+        RX51_SPI_WL1251,
+};
+
+static struct wl12xx_platform_data wl1251_pdata;
+
+static struct omap2_mcspi_device_config wl1251_mcspi_config = {
+        .turbo_mode     = 0,
+        .single_channel = 1,
+};
+
+static struct spi_board_info rx51_peripherals_spi_board_info[] __initdata = {
+        [RX51_SPI_WL1251] = {
+                .modalias               = "wl1251",
+                .bus_num                = 4,
+                .chip_select            = 0,
+                .max_speed_hz           = 48000000,
+                .mode                   = SPI_MODE_2,
+                .controller_data        = &wl1251_mcspi_config,
+                .platform_data          = &wl1251_pdata,
+        },
+};
+
+#if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)
+
+#define RX51_GPIO_CAMERA_LENS_COVER     110
+#define RX51_GPIO_CAMERA_FOCUS          68
+#define RX51_GPIO_CAMERA_CAPTURE        69
+#define RX51_GPIO_KEYPAD_SLIDE          71
+#define RX51_GPIO_LOCK_BUTTON           113
+#define RX51_GPIO_PROXIMITY             89
+
+#define RX51_GPIO_DEBOUNCE_TIMEOUT      10
+
+static struct gpio_keys_button rx51_gpio_keys[] = {
+        {
+                .desc                   = "Camera Lens Cover",
+                .type                   = EV_SW,
+                .code                   = SW_CAMERA_LENS_COVER,
+                .gpio                   = RX51_GPIO_CAMERA_LENS_COVER,
+                .active_low             = 1,
+                .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
+        }, {
+                .desc                   = "Camera Focus",
+                .type                   = EV_KEY,
+                .code                   = KEY_CAMERA_FOCUS,
+                .gpio                   = RX51_GPIO_CAMERA_FOCUS,
+                .active_low             = 1,
+                .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
+        }, {
+                .desc                   = "Camera Capture",
+                .type                   = EV_KEY,
+                .code                   = KEY_CAMERA,
+                .gpio                   = RX51_GPIO_CAMERA_CAPTURE,
+                .active_low             = 1,
+                .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
+        }, {
+                .desc                   = "Lock Button",
+                .type                   = EV_KEY,
+                .code                   = KEY_SCREENLOCK,
+                .gpio                   = RX51_GPIO_LOCK_BUTTON,
+                .active_low             = 1,
+                .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
+        }, {
+                .desc                   = "Keypad Slide",
+                .type                   = EV_SW,
+                .code                   = SW_KEYPAD_SLIDE,
+                .gpio                   = RX51_GPIO_KEYPAD_SLIDE,
+                .active_low             = 1,
+                .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
+        }, {
+                .desc                   = "Proximity Sensor",
+                .type                   = EV_SW,
+                .code                   = SW_FRONT_PROXIMITY,
+                .gpio                   = RX51_GPIO_PROXIMITY,
+                .active_low             = 0,
+                .debounce_interval      = RX51_GPIO_DEBOUNCE_TIMEOUT,
+        }
+};
+
+static struct gpio_keys_platform_data rx51_gpio_keys_data = {
+        .buttons        = rx51_gpio_keys,
+        .nbuttons       = ARRAY_SIZE(rx51_gpio_keys),
+};
+
+static struct platform_device rx51_gpio_keys_device = {
+        .name   = "gpio-keys",
+        .id     = -1,
+        .dev    = {
+                .platform_data  = &rx51_gpio_keys_data,
+        },
+};
+
+static void __init rx51_add_gpio_keys(void)
+{
+        platform_device_register(&rx51_gpio_keys_device);
+}
+#else
+static void __init rx51_add_gpio_keys(void)
+{
+}
+#endif /* CONFIG_KEYBOARD_GPIO || CONFIG_KEYBOARD_GPIO_MODULE */
+
 static int board_keymap[] = {
         KEY(0, 0, KEY_Q),
         KEY(0, 1, KEY_O),
@@ -536,10 +645,64 @@ static inline void board_smc91x_init(void)
 
 #endif
 
+static void rx51_wl1251_set_power(bool enable)
+{
+        gpio_set_value(RX51_WL1251_POWER_GPIO, enable);
+}
+
+static void __init rx51_init_wl1251(void)
+{
+        int irq, ret;
+
+        ret = gpio_request(RX51_WL1251_POWER_GPIO, "wl1251 power");
+        if (ret < 0)
+                goto error;
+
+        ret = gpio_direction_output(RX51_WL1251_POWER_GPIO, 0);
+        if (ret < 0)
+                goto err_power;
+
+        ret = gpio_request(RX51_WL1251_IRQ_GPIO, "wl1251 irq");
+        if (ret < 0)
+                goto err_power;
+
+        ret = gpio_direction_input(RX51_WL1251_IRQ_GPIO);
+        if (ret < 0)
+                goto err_irq;
+
+        irq = gpio_to_irq(RX51_WL1251_IRQ_GPIO);
+        if (irq < 0)
+                goto err_irq;
+
+        wl1251_pdata.set_power = rx51_wl1251_set_power;
+        rx51_peripherals_spi_board_info[RX51_SPI_WL1251].irq = irq;
+
+        return;
+
+err_irq:
+        gpio_free(RX51_WL1251_IRQ_GPIO);
+
+err_power:
+        gpio_free(RX51_WL1251_POWER_GPIO);
+
+error:
+        printk(KERN_ERR "wl1251 board initialisation failed\n");
+        wl1251_pdata.set_power = NULL;
+
+        /*
+         * Now rx51_peripherals_spi_board_info[1].irq is zero and
+         * set_power is null, and wl1251_probe() will fail.
+         */
+}
+
 void __init rx51_peripherals_init(void)
 {
         rx51_i2c_init();
         board_onenand_init();
         board_smc91x_init();
+        rx51_add_gpio_keys();
+        rx51_init_wl1251();
+        spi_register_board_info(rx51_peripherals_spi_board_info,
+                                ARRAY_SIZE(rx51_peripherals_spi_board_info));
 }
 
diff --git a/arch/arm/mach-omap2/board-rx51-sdram.c b/arch/arm/mach-omap2/board-rx51-sdram.c
new file mode 100644
index 000000000000..f392844195d2
--- /dev/null
+++ b/arch/arm/mach-omap2/board-rx51-sdram.c
@@ -0,0 +1,221 @@
+/*
+ * SDRC register values for RX51
+ *
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * Lauri Leukkunen <lauri.leukkunen@nokia.com>
+ *
+ * Original code by Juha Yrjola <juha.yrjola@solidboot.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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+
+#include <plat/io.h>
+#include <plat/common.h>
+#include <plat/clock.h>
+#include <plat/sdrc.h>
+
+
+/* In picoseconds, except for tREF (ns), tXP, tCKE, tWTR (clks) */
+struct sdram_timings {
+        u32 casl;
+        u32 tDAL;
+        u32 tDPL;
+        u32 tRRD;
+        u32 tRCD;
+        u32 tRP;
+        u32 tRAS;
+        u32 tRC;
+        u32 tRFC;
+        u32 tXSR;
+
+        u32 tREF; /* in ns */
+
+        u32 tXP;
+        u32 tCKE;
+        u32 tWTR;
+};
+
+struct omap_sdrc_params rx51_sdrc_params[4];
+
+static const struct sdram_timings rx51_timings[] = {
+        {
+                .casl = 3,
+                .tDAL = 33000,
+                .tDPL = 15000,
+                .tRRD = 12000,
+                .tRCD = 22500,
+                .tRP = 18000,
+                .tRAS = 42000,
+                .tRC = 66000,
+                .tRFC = 138000,
+                .tXSR = 200000,
+
+                .tREF = 7800,
+
+                .tXP = 2,
+                .tCKE = 2,
+                .tWTR = 2
+        },
+};
+
+static unsigned long sdrc_get_fclk_period(long rate)
+{
+        /* In picoseconds */
+        return 1000000000 / rate;
+}
+
+static unsigned int sdrc_ps_to_ticks(unsigned int time_ps, long rate)
+{
+        unsigned long tick_ps;
+
+        /* Calculate in picosecs to yield more exact results */
+        tick_ps = sdrc_get_fclk_period(rate);
+
+        return (time_ps + tick_ps - 1) / tick_ps;
+}
+#undef DEBUG
+#ifdef DEBUG
+static int set_sdrc_timing_regval(u32 *regval, int st_bit, int end_bit,
+                                int ticks, long rate, const char *name)
+#else
+static int set_sdrc_timing_regval(u32 *regval, int st_bit, int end_bit,
+                               int ticks)
+#endif
+{
+        int mask, nr_bits;
+
+        nr_bits = end_bit - st_bit + 1;
+        if (ticks >= 1 << nr_bits)
+                return -1;
+        mask = (1 << nr_bits) - 1;
+        *regval &= ~(mask << st_bit);
+        *regval |= ticks << st_bit;
+#ifdef DEBUG
+        printk(KERN_INFO "SDRC %s: %i ticks %i ns\n", name, ticks,
+                        (unsigned int)sdrc_get_fclk_period(rate) * ticks /
+                        1000);
+#endif
+
+        return 0;
+}
+
+#ifdef DEBUG
+#define SDRC_SET_ONE(reg, st, end, field, rate) \
+        if (set_sdrc_timing_regval((reg), (st), (end), \
+                        rx51_timings->field, (rate), #field) < 0) \
+                err = -1;
+#else
+#define SDRC_SET_ONE(reg, st, end, field, rate) \
+        if (set_sdrc_timing_regval((reg), (st), (end), \
+                        rx51_timings->field) < 0) \
+                err = -1;
+#endif
+
+#ifdef DEBUG
+static int set_sdrc_timing_regval_ps(u32 *regval, int st_bit, int end_bit,
+                                int time, long rate, const char *name)
+#else
+static int set_sdrc_timing_regval_ps(u32 *regval, int st_bit, int end_bit,
+                                int time, long rate)
+#endif
+{
+        int ticks, ret;
+        ret = 0;
+
+        if (time == 0)
+                ticks = 0;
+        else
+                ticks = sdrc_ps_to_ticks(time, rate);
+
+#ifdef DEBUG
+        ret = set_sdrc_timing_regval(regval, st_bit, end_bit, ticks,
+                                     rate, name);
+#else
+        ret = set_sdrc_timing_regval(regval, st_bit, end_bit, ticks);
+#endif
+
+        return ret;
+}
+
+#ifdef DEBUG
+#define SDRC_SET_ONE_PS(reg, st, end, field, rate) \
+        if (set_sdrc_timing_regval_ps((reg), (st), (end), \
+                        rx51_timings->field, \
+                        (rate), #field) < 0) \
+                err = -1;
+
+#else
+#define SDRC_SET_ONE_PS(reg, st, end, field, rate) \
+        if (set_sdrc_timing_regval_ps((reg), (st), (end), \
+                        rx51_timings->field, (rate)) < 0) \
+                err = -1;
+#endif
+
+static int sdrc_timings(int id, long rate)
+{
+        u32 ticks_per_ms;
+        u32 rfr, l;
+        u32 actim_ctrla = 0, actim_ctrlb = 0;
+        u32 rfr_ctrl;
+        int err = 0;
+        long l3_rate = rate / 1000;
+
+        SDRC_SET_ONE_PS(&actim_ctrla,  0,  4, tDAL, l3_rate);
+        SDRC_SET_ONE_PS(&actim_ctrla,  6,  8, tDPL, l3_rate);
+        SDRC_SET_ONE_PS(&actim_ctrla,  9, 11, tRRD, l3_rate);
+        SDRC_SET_ONE_PS(&actim_ctrla, 12, 14, tRCD, l3_rate);
+        SDRC_SET_ONE_PS(&actim_ctrla, 15, 17, tRP, l3_rate);
+        SDRC_SET_ONE_PS(&actim_ctrla, 18, 21, tRAS, l3_rate);
+        SDRC_SET_ONE_PS(&actim_ctrla, 22, 26, tRC, l3_rate);
+        SDRC_SET_ONE_PS(&actim_ctrla, 27, 31, tRFC, l3_rate);
+
+        SDRC_SET_ONE_PS(&actim_ctrlb,  0,  7, tXSR, l3_rate);
+
+        SDRC_SET_ONE(&actim_ctrlb,  8, 10, tXP, l3_rate);
+        SDRC_SET_ONE(&actim_ctrlb, 12, 14, tCKE, l3_rate);
+        SDRC_SET_ONE(&actim_ctrlb, 16, 17, tWTR, l3_rate);
+
+        ticks_per_ms = l3_rate;
+        rfr = rx51_timings[0].tREF * ticks_per_ms / 1000000;
+        if (rfr > 65535 + 50)
+                rfr = 65535;
+        else
+                rfr -= 50;
+
+#ifdef DEBUG
+        printk(KERN_INFO "SDRC tREF: %i ticks\n", rfr);
+#endif
+
+        l = rfr << 8;
+        rfr_ctrl = l | 0x1; /* autorefresh, reload counter with 1xARCV */
+
+        rx51_sdrc_params[id].rate = rate;
+        rx51_sdrc_params[id].actim_ctrla = actim_ctrla;
+        rx51_sdrc_params[id].actim_ctrlb = actim_ctrlb;
+        rx51_sdrc_params[id].rfr_ctrl = rfr_ctrl;
+        rx51_sdrc_params[id].mr = 0x32;
+
+        rx51_sdrc_params[id + 1].rate = 0;
+
+        return err;
+}
+
+struct omap_sdrc_params *rx51_get_sdram_timings(void)
+{
+        int err;
+
+        err = sdrc_timings(0, 41500000);
+        err |= sdrc_timings(1, 83000000);
+        err |= sdrc_timings(2, 166000000);
+
+        return &rx51_sdrc_params[0];
+}
+
diff --git a/arch/arm/mach-omap2/board-rx51.c b/arch/arm/mach-omap2/board-rx51.c
index f9196c3b1a7b..1bb1de245917 100644
--- a/arch/arm/mach-omap2/board-rx51.c
+++ b/arch/arm/mach-omap2/board-rx51.c
@@ -22,14 +22,15 @@
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
-#include <mach/mcspi.h>
-#include <mach/mux.h>
-#include <mach/board.h>
-#include <mach/common.h>
-#include <mach/keypad.h>
-#include <mach/dma.h>
-#include <mach/gpmc.h>
-#include <mach/usb.h>
+#include <plat/mcspi.h>
+#include <plat/mux.h>
+#include <plat/board.h>
+#include <plat/common.h>
+#include <plat/dma.h>
+#include <plat/gpmc.h>
+#include <plat/usb.h>
+
+struct omap_sdrc_params *rx51_get_sdram_timings(void);
 
 static struct omap_lcd_config rx51_lcd_config = {
         .ctrl_name      = "internal",
@@ -56,9 +57,12 @@ static struct omap_board_config_kernel rx51_config[] = {
 
 static void __init rx51_init_irq(void)
 {
+        struct omap_sdrc_params *sdrc_params;
+
         omap_board_config = rx51_config;
         omap_board_config_size = ARRAY_SIZE(rx51_config);
-        omap2_init_common_hw(NULL, NULL);
+        sdrc_params = rx51_get_sdram_timings();
+        omap2_init_common_hw(sdrc_params, sdrc_params);
         omap_init_irq();
         omap_gpio_init();
 }
@@ -85,7 +89,7 @@ static void __init rx51_map_io(void)
 MACHINE_START(NOKIA_RX51, "Nokia RX-51 board")
         /* Maintainer: Lauri Leukkunen <lauri.leukkunen@nokia.com> */
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = rx51_map_io,
         .init_irq       = rx51_init_irq,
diff --git a/arch/arm/mach-omap2/board-zoom-debugboard.c b/arch/arm/mach-omap2/board-zoom-debugboard.c
index 1f13e2a1f322..bb4018b60642 100644
--- a/arch/arm/mach-omap2/board-zoom-debugboard.c
+++ b/arch/arm/mach-omap2/board-zoom-debugboard.c
@@ -14,20 +14,20 @@
 #include <linux/smsc911x.h>
 #include <linux/interrupt.h>
 
-#include <mach/gpmc.h>
+#include <plat/gpmc.h>
 
-#define ZOOM2_SMSC911X_CS       7
-#define ZOOM2_SMSC911X_GPIO     158
-#define ZOOM2_QUADUART_CS       3
-#define ZOOM2_QUADUART_GPIO     102
+#define ZOOM_SMSC911X_CS        7
+#define ZOOM_SMSC911X_GPIO      158
+#define ZOOM_QUADUART_CS        3
+#define ZOOM_QUADUART_GPIO      102
 #define QUART_CLK               1843200
 #define DEBUG_BASE              0x08000000
-#define ZOOM2_ETHR_START        DEBUG_BASE
+#define ZOOM_ETHR_START DEBUG_BASE
 
-static struct resource zoom2_smsc911x_resources[] = {
+static struct resource zoom_smsc911x_resources[] = {
         [0] = {
-                .start  = ZOOM2_ETHR_START,
-                .end    = ZOOM2_ETHR_START + SZ_4K,
+                .start  = ZOOM_ETHR_START,
+                .end    = ZOOM_ETHR_START + SZ_4K,
                 .flags  = IORESOURCE_MEM,
         },
         [1] = {
@@ -35,42 +35,42 @@ static struct resource zoom2_smsc911x_resources[] = {
         },
 };
 
-static struct smsc911x_platform_config zoom2_smsc911x_config = {
+static struct smsc911x_platform_config zoom_smsc911x_config = {
         .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
         .irq_type       = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
         .flags          = SMSC911X_USE_32BIT,
         .phy_interface  = PHY_INTERFACE_MODE_MII,
 };
 
-static struct platform_device zoom2_smsc911x_device = {
+static struct platform_device zoom_smsc911x_device = {
         .name           = "smsc911x",
         .id             = -1,
-        .num_resources  = ARRAY_SIZE(zoom2_smsc911x_resources),
-        .resource       = zoom2_smsc911x_resources,
+        .num_resources  = ARRAY_SIZE(zoom_smsc911x_resources),
+        .resource       = zoom_smsc911x_resources,
         .dev            = {
-                .platform_data = &zoom2_smsc911x_config,
+                .platform_data = &zoom_smsc911x_config,
         },
 };
 
-static inline void __init zoom2_init_smsc911x(void)
+static inline void __init zoom_init_smsc911x(void)
 {
         int eth_cs;
         unsigned long cs_mem_base;
         int eth_gpio = 0;
 
-        eth_cs = ZOOM2_SMSC911X_CS;
+        eth_cs = ZOOM_SMSC911X_CS;
 
         if (gpmc_cs_request(eth_cs, SZ_16M, &cs_mem_base) < 0) {
                 printk(KERN_ERR "Failed to request GPMC mem for smsc911x\n");
                 return;
         }
 
-        zoom2_smsc911x_resources[0].start = cs_mem_base + 0x0;
-        zoom2_smsc911x_resources[0].end   = cs_mem_base + 0xff;
+        zoom_smsc911x_resources[0].start = cs_mem_base + 0x0;
+        zoom_smsc911x_resources[0].end   = cs_mem_base + 0xff;
 
-        eth_gpio = ZOOM2_SMSC911X_GPIO;
+        eth_gpio = ZOOM_SMSC911X_GPIO;
 
-        zoom2_smsc911x_resources[1].start = OMAP_GPIO_IRQ(eth_gpio);
+        zoom_smsc911x_resources[1].start = OMAP_GPIO_IRQ(eth_gpio);
 
         if (gpio_request(eth_gpio, "smsc911x irq") < 0) {
                 printk(KERN_ERR "Failed to request GPIO%d for smsc911x IRQ\n",
@@ -94,7 +94,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
         }
 };
 
-static struct platform_device zoom2_debugboard_serial_device = {
+static struct platform_device zoom_debugboard_serial_device = {
         .name                   = "serial8250",
         .id                     = 3,
         .dev                    = {
@@ -102,13 +102,13 @@ static struct platform_device zoom2_debugboard_serial_device = {
         },
 };
 
-static inline void __init zoom2_init_quaduart(void)
+static inline void __init zoom_init_quaduart(void)
 {
         int quart_cs;
         unsigned long cs_mem_base;
         int quart_gpio = 0;
 
-        quart_cs = ZOOM2_QUADUART_CS;
+        quart_cs = ZOOM_QUADUART_CS;
 
         if (gpmc_cs_request(quart_cs, SZ_1M, &cs_mem_base) < 0) {
                 printk(KERN_ERR "Failed to request GPMC mem"
@@ -116,7 +116,7 @@ static inline void __init zoom2_init_quaduart(void)
                 return;
         }
 
-        quart_gpio = ZOOM2_QUADUART_GPIO;
+        quart_gpio = ZOOM_QUADUART_GPIO;
 
         if (gpio_request(quart_gpio, "TL16CP754C GPIO") < 0) {
                 printk(KERN_ERR "Failed to request GPIO%d for TL16CP754C\n",
@@ -126,15 +126,15 @@ static inline void __init zoom2_init_quaduart(void)
         gpio_direction_input(quart_gpio);
 }
 
-static inline int omap_zoom2_debugboard_detect(void)
+static inline int omap_zoom_debugboard_detect(void)
 {
         int debug_board_detect = 0;
         int ret = 1;
 
-        debug_board_detect = ZOOM2_SMSC911X_GPIO;
+        debug_board_detect = ZOOM_SMSC911X_GPIO;
 
-        if (gpio_request(debug_board_detect, "Zoom2 debug board detect") < 0) {
-                printk(KERN_ERR "Failed to request GPIO%d for Zoom2 debug"
+        if (gpio_request(debug_board_detect, "Zoom debug board detect") < 0) {
+                printk(KERN_ERR "Failed to request GPIO%d for Zoom debug"
                 "board detect\n", debug_board_detect);
                 return 0;
         }
@@ -147,17 +147,17 @@ static inline int omap_zoom2_debugboard_detect(void)
         return ret;
 }
 
-static struct platform_device *zoom2_devices[] __initdata = {
-        &zoom2_smsc911x_device,
-        &zoom2_debugboard_serial_device,
+static struct platform_device *zoom_devices[] __initdata = {
+        &zoom_smsc911x_device,
+        &zoom_debugboard_serial_device,
 };
 
-int __init omap_zoom2_debugboard_init(void)
+int __init zoom_debugboard_init(void)
 {
-        if (!omap_zoom2_debugboard_detect())
+        if (!omap_zoom_debugboard_detect())
                 return 0;
 
-        zoom2_init_smsc911x();
-        zoom2_init_quaduart();
-        return platform_add_devices(zoom2_devices, ARRAY_SIZE(zoom2_devices));
+        zoom_init_smsc911x();
+        zoom_init_quaduart();
+        return platform_add_devices(zoom_devices, ARRAY_SIZE(zoom_devices));
 }
diff --git a/arch/arm/mach-omap2/board-zoom-peripherals.c b/arch/arm/mach-omap2/board-zoom-peripherals.c
new file mode 100755
index 000000000000..f14baa392760
--- /dev/null
+++ b/arch/arm/mach-omap2/board-zoom-peripherals.c
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2009 Texas Instruments Inc.
+ *
+ * Modified from mach-omap2/board-zoom2.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 <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/input/matrix_keypad.h>
+#include <linux/gpio.h>
+#include <linux/i2c/twl4030.h>
+#include <linux/regulator/machine.h>
+
+#include <asm/mach-types.h>
+#include <asm/mach/arch.h>
+#include <asm/mach/map.h>
+
+#include <plat/common.h>
+#include <plat/usb.h>
+
+#include "mmc-twl4030.h"
+
+/* Zoom2 has Qwerty keyboard*/
+static int board_keymap[] = {
+        KEY(0, 0, KEY_E),
+        KEY(0, 1, KEY_R),
+        KEY(0, 2, KEY_T),
+        KEY(0, 3, KEY_HOME),
+        KEY(0, 6, KEY_I),
+        KEY(0, 7, KEY_LEFTSHIFT),
+        KEY(1, 0, KEY_D),
+        KEY(1, 1, KEY_F),
+        KEY(1, 2, KEY_G),
+        KEY(1, 3, KEY_SEND),
+        KEY(1, 6, KEY_K),
+        KEY(1, 7, KEY_ENTER),
+        KEY(2, 0, KEY_X),
+        KEY(2, 1, KEY_C),
+        KEY(2, 2, KEY_V),
+        KEY(2, 3, KEY_END),
+        KEY(2, 6, KEY_DOT),
+        KEY(2, 7, KEY_CAPSLOCK),
+        KEY(3, 0, KEY_Z),
+        KEY(3, 1, KEY_KPPLUS),
+        KEY(3, 2, KEY_B),
+        KEY(3, 3, KEY_F1),
+        KEY(3, 6, KEY_O),
+        KEY(3, 7, KEY_SPACE),
+        KEY(4, 0, KEY_W),
+        KEY(4, 1, KEY_Y),
+        KEY(4, 2, KEY_U),
+        KEY(4, 3, KEY_F2),
+        KEY(4, 4, KEY_VOLUMEUP),
+        KEY(4, 6, KEY_L),
+        KEY(4, 7, KEY_LEFT),
+        KEY(5, 0, KEY_S),
+        KEY(5, 1, KEY_H),
+        KEY(5, 2, KEY_J),
+        KEY(5, 3, KEY_F3),
+        KEY(5, 5, KEY_VOLUMEDOWN),
+        KEY(5, 6, KEY_M),
+        KEY(5, 7, KEY_ENTER),
+        KEY(6, 0, KEY_Q),
+        KEY(6, 1, KEY_A),
+        KEY(6, 2, KEY_N),
+        KEY(6, 3, KEY_BACKSPACE),
+        KEY(6, 6, KEY_P),
+        KEY(6, 7, KEY_SELECT),
+        KEY(7, 0, KEY_PROG1),   /*MACRO 1 <User defined> */
+        KEY(7, 1, KEY_PROG2),   /*MACRO 2 <User defined> */
+        KEY(7, 2, KEY_PROG3),   /*MACRO 3 <User defined> */
+        KEY(7, 3, KEY_PROG4),   /*MACRO 4 <User defined> */
+        KEY(7, 5, KEY_RIGHT),
+        KEY(7, 6, KEY_UP),
+        KEY(7, 7, KEY_DOWN)
+};
+
+static struct matrix_keymap_data board_map_data = {
+        .keymap                 = board_keymap,
+        .keymap_size            = ARRAY_SIZE(board_keymap),
+};
+
+static struct twl4030_keypad_data zoom_kp_twl4030_data = {
+        .keymap_data    = &board_map_data,
+        .rows           = 8,
+        .cols           = 8,
+        .rep            = 1,
+};
+
+static struct regulator_consumer_supply zoom_vmmc1_supply = {
+        .supply         = "vmmc",
+};
+
+static struct regulator_consumer_supply zoom_vsim_supply = {
+        .supply         = "vmmc_aux",
+};
+
+static struct regulator_consumer_supply zoom_vmmc2_supply = {
+        .supply         = "vmmc",
+};
+
+/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
+static struct regulator_init_data zoom_vmmc1 = {
+        .constraints = {
+                .min_uV                 = 1850000,
+                .max_uV                 = 3150000,
+                .valid_modes_mask       = REGULATOR_MODE_NORMAL
+                                        | REGULATOR_MODE_STANDBY,
+                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
+                                        | REGULATOR_CHANGE_MODE
+                                        | REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies  = 1,
+        .consumer_supplies      = &zoom_vmmc1_supply,
+};
+
+/* VMMC2 for MMC2 card */
+static struct regulator_init_data zoom_vmmc2 = {
+        .constraints = {
+                .min_uV                 = 1850000,
+                .max_uV                 = 1850000,
+                .apply_uV               = true,
+                .valid_modes_mask       = REGULATOR_MODE_NORMAL
+                                        | REGULATOR_MODE_STANDBY,
+                .valid_ops_mask         = REGULATOR_CHANGE_MODE
+                                        | REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies  = 1,
+        .consumer_supplies      = &zoom_vmmc2_supply,
+};
+
+/* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
+static struct regulator_init_data zoom_vsim = {
+        .constraints = {
+                .min_uV                 = 1800000,
+                .max_uV                 = 3000000,
+                .valid_modes_mask       = REGULATOR_MODE_NORMAL
+                                        | REGULATOR_MODE_STANDBY,
+                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
+                                        | REGULATOR_CHANGE_MODE
+                                        | REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies  = 1,
+        .consumer_supplies      = &zoom_vsim_supply,
+};
+
+static struct twl4030_hsmmc_info mmc[] __initdata = {
+        {
+                .mmc            = 1,
+                .wires          = 4,
+                .gpio_wp        = -EINVAL,
+        },
+        {
+                .mmc            = 2,
+                .wires          = 4,
+                .gpio_wp        = -EINVAL,
+        },
+        {}      /* Terminator */
+};
+
+static int zoom_twl_gpio_setup(struct device *dev,
+                unsigned gpio, unsigned ngpio)
+{
+        /* gpio + 0 is "mmc0_cd" (input/IRQ),
+         * gpio + 1 is "mmc1_cd" (input/IRQ)
+         */
+        mmc[0].gpio_cd = gpio + 0;
+        mmc[1].gpio_cd = gpio + 1;
+        twl4030_mmc_init(mmc);
+
+        /* link regulators to MMC adapters ... we "know" the
+         * regulators will be set up only *after* we return.
+        */
+        zoom_vmmc1_supply.dev = mmc[0].dev;
+        zoom_vsim_supply.dev = mmc[0].dev;
+        zoom_vmmc2_supply.dev = mmc[1].dev;
+
+        return 0;
+}
+
+
+static int zoom_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 zoom_bci_data = {
+        .battery_tmp_tbl        = zoom_batt_table,
+        .tblsize                = ARRAY_SIZE(zoom_batt_table),
+};
+
+static struct twl4030_usb_data zoom_usb_data = {
+        .usb_mode       = T2_USB_MODE_ULPI,
+};
+
+static struct twl4030_gpio_platform_data zoom_gpio_data = {
+        .gpio_base      = OMAP_MAX_GPIO_LINES,
+        .irq_base       = TWL4030_GPIO_IRQ_BASE,
+        .irq_end        = TWL4030_GPIO_IRQ_END,
+        .setup          = zoom_twl_gpio_setup,
+};
+
+static struct twl4030_madc_platform_data zoom_madc_data = {
+        .irq_line       = 1,
+};
+
+static struct twl4030_codec_audio_data zoom_audio_data = {
+        .audio_mclk = 26000000,
+};
+
+static struct twl4030_codec_data zoom_codec_data = {
+        .audio_mclk = 26000000,
+        .audio = &zoom_audio_data,
+};
+
+static struct twl4030_platform_data zoom_twldata = {
+        .irq_base       = TWL4030_IRQ_BASE,
+        .irq_end        = TWL4030_IRQ_END,
+
+        /* platform_data for children goes here */
+        .bci            = &zoom_bci_data,
+        .madc           = &zoom_madc_data,
+        .usb            = &zoom_usb_data,
+        .gpio           = &zoom_gpio_data,
+        .keypad         = &zoom_kp_twl4030_data,
+        .codec          = &zoom_codec_data,
+        .vmmc2          = &zoom_vmmc2,
+        .vsim           = &zoom_vsim,
+
+};
+
+static struct i2c_board_info __initdata zoom_i2c_boardinfo[] = {
+        {
+                I2C_BOARD_INFO("twl5030", 0x48),
+                .flags          = I2C_CLIENT_WAKE,
+                .irq            = INT_34XX_SYS_NIRQ,
+                .platform_data  = &zoom_twldata,
+        },
+};
+
+static int __init omap_i2c_init(void)
+{
+        omap_register_i2c_bus(1, 2400, zoom_i2c_boardinfo,
+                        ARRAY_SIZE(zoom_i2c_boardinfo));
+        omap_register_i2c_bus(2, 400, NULL, 0);
+        omap_register_i2c_bus(3, 400, NULL, 0);
+        return 0;
+}
+
+void __init zoom_peripherals_init(void)
+{
+        omap_i2c_init();
+        omap_serial_init();
+        usb_musb_init();
+}
diff --git a/arch/arm/mach-omap2/board-zoom2.c b/arch/arm/mach-omap2/board-zoom2.c
index fd3369d5e5cb..d94d047c7dce 100644
--- a/arch/arm/mach-omap2/board-zoom2.c
+++ b/arch/arm/mach-omap2/board-zoom2.c
@@ -14,223 +14,41 @@
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/gpio.h>
-#include <linux/i2c/twl4030.h>
-#include <linux/regulator/machine.h>
 
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 
-#include <mach/common.h>
-#include <mach/usb.h>
-#include <mach/keypad.h>
+#include <plat/common.h>
+#include <plat/board.h>
 
-#include "mmc-twl4030.h"
-#include "sdram-micron-mt46h32m32lf-6.h"
-
-/* Zoom2 has Qwerty keyboard*/
-static int board_keymap[] = {
-        KEY(0, 0, KEY_E),
-        KEY(1, 0, KEY_R),
-        KEY(2, 0, KEY_T),
-        KEY(3, 0, KEY_HOME),
-        KEY(6, 0, KEY_I),
-        KEY(7, 0, KEY_LEFTSHIFT),
-        KEY(0, 1, KEY_D),
-        KEY(1, 1, KEY_F),
-        KEY(2, 1, KEY_G),
-        KEY(3, 1, KEY_SEND),
-        KEY(6, 1, KEY_K),
-        KEY(7, 1, KEY_ENTER),
-        KEY(0, 2, KEY_X),
-        KEY(1, 2, KEY_C),
-        KEY(2, 2, KEY_V),
-        KEY(3, 2, KEY_END),
-        KEY(6, 2, KEY_DOT),
-        KEY(7, 2, KEY_CAPSLOCK),
-        KEY(0, 3, KEY_Z),
-        KEY(1, 3, KEY_KPPLUS),
-        KEY(2, 3, KEY_B),
-        KEY(3, 3, KEY_F1),
-        KEY(6, 3, KEY_O),
-        KEY(7, 3, KEY_SPACE),
-        KEY(0, 4, KEY_W),
-        KEY(1, 4, KEY_Y),
-        KEY(2, 4, KEY_U),
-        KEY(3, 4, KEY_F2),
-        KEY(4, 4, KEY_VOLUMEUP),
-        KEY(6, 4, KEY_L),
-        KEY(7, 4, KEY_LEFT),
-        KEY(0, 5, KEY_S),
-        KEY(1, 5, KEY_H),
-        KEY(2, 5, KEY_J),
-        KEY(3, 5, KEY_F3),
-        KEY(5, 5, KEY_VOLUMEDOWN),
-        KEY(6, 5, KEY_M),
-        KEY(4, 5, KEY_ENTER),
-        KEY(7, 5, KEY_RIGHT),
-        KEY(0, 6, KEY_Q),
-        KEY(1, 6, KEY_A),
-        KEY(2, 6, KEY_N),
-        KEY(3, 6, KEY_BACKSPACE),
-        KEY(6, 6, KEY_P),
-        KEY(7, 6, KEY_UP),
-        KEY(6, 7, KEY_SELECT),
-        KEY(7, 7, KEY_DOWN),
-        KEY(0, 7, KEY_PROG1),   /*MACRO 1 <User defined> */
-        KEY(1, 7, KEY_PROG2),   /*MACRO 2 <User defined> */
-        KEY(2, 7, KEY_PROG3),   /*MACRO 3 <User defined> */
-        KEY(3, 7, KEY_PROG4),   /*MACRO 4 <User defined> */
-        0
-};
-
-static struct matrix_keymap_data board_map_data = {
-        .keymap                 = board_keymap,
-        .keymap_size            = ARRAY_SIZE(board_keymap),
-};
-
-static struct twl4030_keypad_data zoom2_kp_twl4030_data = {
-        .keymap_data    = &board_map_data,
-        .rows           = 8,
-        .cols           = 8,
-        .rep            = 1,
-};
-
-static struct omap_board_config_kernel zoom2_config[] __initdata = {
-};
-
-static struct regulator_consumer_supply zoom2_vmmc1_supply = {
-        .supply         = "vmmc",
-};
-
-static struct regulator_consumer_supply zoom2_vsim_supply = {
-        .supply         = "vmmc_aux",
-};
-
-static struct regulator_consumer_supply zoom2_vmmc2_supply = {
-        .supply         = "vmmc",
-};
-
-/* VMMC1 for OMAP VDD_MMC1 (i/o) and MMC1 card */
-static struct regulator_init_data zoom2_vmmc1 = {
-        .constraints = {
-                .min_uV                 = 1850000,
-                .max_uV                 = 3150000,
-                .valid_modes_mask       = REGULATOR_MODE_NORMAL
-                                        | REGULATOR_MODE_STANDBY,
-                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
-                                        | REGULATOR_CHANGE_MODE
-                                        | REGULATOR_CHANGE_STATUS,
-        },
-        .num_consumer_supplies  = 1,
-        .consumer_supplies      = &zoom2_vmmc1_supply,
-};
-
-/* VMMC2 for MMC2 card */
-static struct regulator_init_data zoom2_vmmc2 = {
-        .constraints = {
-                .min_uV                 = 1850000,
-                .max_uV                 = 1850000,
-                .apply_uV               = true,
-                .valid_modes_mask       = REGULATOR_MODE_NORMAL
-                                        | REGULATOR_MODE_STANDBY,
-                .valid_ops_mask         = REGULATOR_CHANGE_MODE
-                                        | REGULATOR_CHANGE_STATUS,
-        },
-        .num_consumer_supplies  = 1,
-        .consumer_supplies      = &zoom2_vmmc2_supply,
-};
-
-/* VSIM for OMAP VDD_MMC1A (i/o for DAT4..DAT7) */
-static struct regulator_init_data zoom2_vsim = {
-        .constraints = {
-                .min_uV                 = 1800000,
-                .max_uV                 = 3000000,
-                .valid_modes_mask       = REGULATOR_MODE_NORMAL
-                                        | REGULATOR_MODE_STANDBY,
-                .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
-                                        | REGULATOR_CHANGE_MODE
-                                        | REGULATOR_CHANGE_STATUS,
-        },
-        .num_consumer_supplies  = 1,
-        .consumer_supplies      = &zoom2_vsim_supply,
-};
-
-static struct twl4030_hsmmc_info mmc[] __initdata = {
-        {
-                .mmc            = 1,
-                .wires          = 4,
-                .gpio_wp        = -EINVAL,
-        },
-        {
-                .mmc            = 2,
-                .wires          = 4,
-                .gpio_wp        = -EINVAL,
-        },
-        {}      /* Terminator */
-};
+#include <mach/board-zoom.h>
 
-static int zoom2_twl_gpio_setup(struct device *dev,
-                unsigned gpio, unsigned ngpio)
-{
-        /* gpio + 0 is "mmc0_cd" (input/IRQ),
-         * gpio + 1 is "mmc1_cd" (input/IRQ)
-         */
-        mmc[0].gpio_cd = gpio + 0;
-        mmc[1].gpio_cd = gpio + 1;
-        twl4030_mmc_init(mmc);
-
-        /* link regulators to MMC adapters ... we "know" the
-         * regulators will be set up only *after* we return.
-        */
-        zoom2_vmmc1_supply.dev = mmc[0].dev;
-        zoom2_vsim_supply.dev = mmc[0].dev;
-        zoom2_vmmc2_supply.dev = mmc[1].dev;
-
-        return 0;
-}
-
-
-static int zoom2_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 zoom2_bci_data = {
-        .battery_tmp_tbl        = zoom2_batt_table,
-        .tblsize                = ARRAY_SIZE(zoom2_batt_table),
-};
-
-static struct twl4030_usb_data zoom2_usb_data = {
-        .usb_mode       = T2_USB_MODE_ULPI,
-};
+#include "sdram-micron-mt46h32m32lf-6.h"
 
 static void __init omap_zoom2_init_irq(void)
 {
-        omap_board_config = zoom2_config;
-        omap_board_config_size = ARRAY_SIZE(zoom2_config);
         omap2_init_common_hw(mt46h32m32lf6_sdrc_params,
                                  mt46h32m32lf6_sdrc_params);
         omap_init_irq();
         omap_gpio_init();
 }
 
-static struct twl4030_gpio_platform_data zoom2_gpio_data = {
-        .gpio_base      = OMAP_MAX_GPIO_LINES,
-        .irq_base       = TWL4030_GPIO_IRQ_BASE,
-        .irq_end        = TWL4030_GPIO_IRQ_END,
-        .setup          = zoom2_twl_gpio_setup,
-};
+/* REVISIT: These audio entries can be removed once MFD code is merged */
+#if 0
 
 static struct twl4030_madc_platform_data zoom2_madc_data = {
         .irq_line       = 1,
 };
 
+static struct twl4030_codec_audio_data zoom2_audio_data = {
+        .audio_mclk = 26000000,
+};
+
+static struct twl4030_codec_data zoom2_codec_data = {
+        .audio_mclk = 26000000,
+        .audio = &zoom2_audio_data,
+};
+
 static struct twl4030_platform_data zoom2_twldata = {
         .irq_base       = TWL4030_IRQ_BASE,
         .irq_end        = TWL4030_IRQ_END,
@@ -241,38 +59,19 @@ static struct twl4030_platform_data zoom2_twldata = {
         .usb            = &zoom2_usb_data,
         .gpio           = &zoom2_gpio_data,
         .keypad         = &zoom2_kp_twl4030_data,
+        .codec          = &zoom2_codec_data,
         .vmmc1          = &zoom2_vmmc1,
         .vmmc2          = &zoom2_vmmc2,
         .vsim           = &zoom2_vsim,
 
 };
 
-static struct i2c_board_info __initdata zoom2_i2c_boardinfo[] = {
-        {
-                I2C_BOARD_INFO("twl4030", 0x48),
-                .flags          = I2C_CLIENT_WAKE,
-                .irq            = INT_34XX_SYS_NIRQ,
-                .platform_data  = &zoom2_twldata,
-        },
-};
-
-static int __init omap_i2c_init(void)
-{
-        omap_register_i2c_bus(1, 2600, zoom2_i2c_boardinfo,
-                        ARRAY_SIZE(zoom2_i2c_boardinfo));
-        omap_register_i2c_bus(2, 400, NULL, 0);
-        omap_register_i2c_bus(3, 400, NULL, 0);
-        return 0;
-}
-
-extern int __init omap_zoom2_debugboard_init(void);
+#endif
 
 static void __init omap_zoom2_init(void)
 {
-        omap_i2c_init();
-        omap_serial_init();
-        omap_zoom2_debugboard_init();
-        usb_musb_init();
+        zoom_peripherals_init();
+        zoom_debugboard_init();
 }
 
 static void __init omap_zoom2_map_io(void)
@@ -283,7 +82,7 @@ static void __init omap_zoom2_map_io(void)
 
 MACHINE_START(OMAP_ZOOM2, "OMAP Zoom2 board")
         .phys_io        = 0x48000000,
-        .io_pg_offst    = ((0xd8000000) >> 18) & 0xfffc,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
         .map_io         = omap_zoom2_map_io,
         .init_irq       = omap_zoom2_init_irq,
diff --git a/arch/arm/mach-omap2/board-zoom3.c b/arch/arm/mach-omap2/board-zoom3.c
new file mode 100644
index 000000000000..8d965a6516c8
--- /dev/null
+++ b/arch/arm/mach-omap2/board-zoom3.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2009 Texas Instruments Inc.
+ *
+ *
+ * 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 <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/gpio.h>
+
+#include <asm/mach-types.h>
+#include <asm/mach/arch.h>
+
+#include <mach/board-zoom.h>
+
+#include <plat/common.h>
+#include <plat/board.h>
+
+#include "sdram-hynix-h8mbx00u0mer-0em.h"
+
+static void __init omap_zoom_map_io(void)
+{
+        omap2_set_globals_343x();
+        omap2_map_common_io();
+}
+
+static struct omap_board_config_kernel zoom_config[] __initdata = {
+};
+
+static void __init omap_zoom_init_irq(void)
+{
+        omap_board_config = zoom_config;
+        omap_board_config_size = ARRAY_SIZE(zoom_config);
+        omap2_init_common_hw(h8mbx00u0mer0em_sdrc_params,
+                        h8mbx00u0mer0em_sdrc_params);
+        omap_init_irq();
+        omap_gpio_init();
+}
+
+static void __init omap_zoom_init(void)
+{
+        zoom_peripherals_init();
+        zoom_debugboard_init();
+}
+
+MACHINE_START(OMAP_ZOOM3, "OMAP Zoom3 board")
+        .phys_io        = 0x48000000,
+        .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
+        .boot_params    = 0x80000100,
+        .map_io         = omap_zoom_map_io,
+        .init_irq       = omap_zoom_init_irq,
+        .init_machine   = omap_zoom_init,
+        .timer          = &omap_timer,
+MACHINE_END
diff --git a/arch/arm/mach-omap2/clock.c b/arch/arm/mach-omap2/clock.c
index f2a92d614f0f..4716206547ac 100644
--- a/arch/arm/mach-omap2/clock.c
+++ b/arch/arm/mach-omap2/clock.c
@@ -24,13 +24,13 @@
 #include <linux/io.h>
 #include <linux/bitops.h>
 
-#include <mach/clock.h>
-#include <mach/clockdomain.h>
-#include <mach/cpu.h>
-#include <mach/prcm.h>
+#include <plat/clock.h>
+#include <plat/clockdomain.h>
+#include <plat/cpu.h>
+#include <plat/prcm.h>
 #include <asm/div64.h>
 
-#include <mach/sdrc.h>
+#include <plat/sdrc.h>
 #include "sdrc.h"
 #include "clock.h"
 #include "prm.h"
diff --git a/arch/arm/mach-omap2/clock.h b/arch/arm/mach-omap2/clock.h
index 9ae7540f8af2..43b6bedaafd6 100644
--- a/arch/arm/mach-omap2/clock.h
+++ b/arch/arm/mach-omap2/clock.h
@@ -16,7 +16,7 @@
 #ifndef __ARCH_ARM_MACH_OMAP2_CLOCK_H
 #define __ARCH_ARM_MACH_OMAP2_CLOCK_H
 
-#include <mach/clock.h>
+#include <plat/clock.h>
 
 /* The maximum error between a target DPLL rate and the rounded rate in Hz */
 #define DEFAULT_DPLL_RATE_TOLERANCE     50000
diff --git a/arch/arm/mach-omap2/clock24xx.c b/arch/arm/mach-omap2/clock24xx.c
index e2dbedd581e8..e70e7e000eaa 100644
--- a/arch/arm/mach-omap2/clock24xx.c
+++ b/arch/arm/mach-omap2/clock24xx.c
@@ -28,13 +28,13 @@
 #include <linux/cpufreq.h>
 #include <linux/bitops.h>
 
-#include <mach/clock.h>
-#include <mach/sram.h>
-#include <mach/prcm.h>
+#include <plat/clock.h>
+#include <plat/sram.h>
+#include <plat/prcm.h>
 #include <asm/div64.h>
 #include <asm/clkdev.h>
 
-#include <mach/sdrc.h>
+#include <plat/sdrc.h>
 #include "clock.h"
 #include "prm.h"
 #include "prm-regbits-24xx.h"
diff --git a/arch/arm/mach-omap2/clock34xx.c b/arch/arm/mach-omap2/clock34xx.c
index 489556eecbd1..9f2feaf79865 100644
--- a/arch/arm/mach-omap2/clock34xx.c
+++ b/arch/arm/mach-omap2/clock34xx.c
@@ -27,13 +27,13 @@
 #include <linux/limits.h>
 #include <linux/bitops.h>
 
-#include <mach/cpu.h>
-#include <mach/clock.h>
-#include <mach/sram.h>
+#include <plat/cpu.h>
+#include <plat/clock.h>
+#include <plat/sram.h>
 #include <asm/div64.h>
 #include <asm/clkdev.h>
 
-#include <mach/sdrc.h>
+#include <plat/sdrc.h>
 #include "clock.h"
 #include "prm.h"
 #include "prm-regbits-34xx.h"
@@ -119,7 +119,7 @@ static struct omap_clk omap34xx_clks[] = {
         CLK(NULL,       "dpll3_m2x2_ck", &dpll3_m2x2_ck, CK_343X),
         CLK(NULL,       "dpll3_m3_ck",  &dpll3_m3_ck,   CK_343X),
         CLK(NULL,       "dpll3_m3x2_ck", &dpll3_m3x2_ck, CK_343X),
-        CLK(NULL,       "emu_core_alwon_ck", &emu_core_alwon_ck, CK_343X),
+        CLK("etb",      "emu_core_alwon_ck", &emu_core_alwon_ck, CK_343X),
         CLK(NULL,       "dpll4_ck",     &dpll4_ck,      CK_343X),
         CLK(NULL,       "dpll4_x2_ck",  &dpll4_x2_ck,   CK_343X),
         CLK(NULL,       "omap_96m_alwon_fck", &omap_96m_alwon_fck, CK_343X),
@@ -138,7 +138,7 @@ static struct omap_clk omap34xx_clks[] = {
         CLK(NULL,       "dpll4_m5x2_ck", &dpll4_m5x2_ck, CK_343X),
         CLK(NULL,       "dpll4_m6_ck",  &dpll4_m6_ck,   CK_343X),
         CLK(NULL,       "dpll4_m6x2_ck", &dpll4_m6x2_ck, CK_343X),
-        CLK(NULL,       "emu_per_alwon_ck", &emu_per_alwon_ck, CK_343X),
+        CLK("etb",      "emu_per_alwon_ck", &emu_per_alwon_ck, CK_343X),
         CLK(NULL,       "dpll5_ck",     &dpll5_ck,      CK_3430ES2),
         CLK(NULL,       "dpll5_m2_ck",  &dpll5_m2_ck,   CK_3430ES2),
         CLK(NULL,       "clkout2_src_ck", &clkout2_src_ck, CK_343X),
@@ -147,7 +147,7 @@ static struct omap_clk omap34xx_clks[] = {
         CLK(NULL,       "dpll1_fck",    &dpll1_fck,     CK_343X),
         CLK(NULL,       "mpu_ck",       &mpu_ck,        CK_343X),
         CLK(NULL,       "arm_fck",      &arm_fck,       CK_343X),
-        CLK(NULL,       "emu_mpu_alwon_ck", &emu_mpu_alwon_ck, CK_343X),
+        CLK("etb",      "emu_mpu_alwon_ck", &emu_mpu_alwon_ck, CK_343X),
         CLK(NULL,       "dpll2_fck",    &dpll2_fck,     CK_343X),
         CLK(NULL,       "iva2_ck",      &iva2_ck,       CK_343X),
         CLK(NULL,       "l3_ick",       &l3_ick,        CK_343X),
@@ -302,7 +302,7 @@ static struct omap_clk omap34xx_clks[] = {
         CLK("omap-mcbsp.2", "fck",      &mcbsp2_fck,    CK_343X),
         CLK("omap-mcbsp.3", "fck",      &mcbsp3_fck,    CK_343X),
         CLK("omap-mcbsp.4", "fck",      &mcbsp4_fck,    CK_343X),
-        CLK(NULL,       "emu_src_ck",   &emu_src_ck,    CK_343X),
+        CLK("etb",      "emu_src_ck",   &emu_src_ck,    CK_343X),
         CLK(NULL,       "pclk_fck",     &pclk_fck,      CK_343X),
         CLK(NULL,       "pclkx2_fck",   &pclkx2_fck,    CK_343X),
         CLK(NULL,       "atclk_fck",    &atclk_fck,     CK_343X),
@@ -473,7 +473,7 @@ static u16 _omap3_dpll_compute_freqsel(struct clk *clk, u8 n)
         unsigned long fint;
         u16 f = 0;
 
-        fint = clk->dpll_data->clk_ref->rate / (n + 1);
+        fint = clk->dpll_data->clk_ref->rate / n;
 
         pr_debug("clock: fint is %lu\n", fint);
 
diff --git a/arch/arm/mach-omap2/clock34xx.h b/arch/arm/mach-omap2/clock34xx.h
index c8119781e00a..8fe1bcb23dd9 100644
--- a/arch/arm/mach-omap2/clock34xx.h
+++ b/arch/arm/mach-omap2/clock34xx.h
@@ -19,7 +19,7 @@
 #ifndef __ARCH_ARM_MACH_OMAP2_CLOCK34XX_H
 #define __ARCH_ARM_MACH_OMAP2_CLOCK34XX_H
 
-#include <mach/control.h>
+#include <plat/control.h>
 
 #include "clock.h"
 #include "cm.h"
@@ -489,9 +489,9 @@ static struct clk core_ck = {
 static struct clk dpll3_m2x2_ck = {
         .name           = "dpll3_m2x2_ck",
         .ops            = &clkops_null,
-        .parent         = &dpll3_x2_ck,
+        .parent         = &dpll3_m2_ck,
         .clkdm_name     = "dpll3_clkdm",
-        .recalc         = &followparent_recalc,
+        .recalc         = &omap3_clkoutx2_recalc,
 };
 
 /* The PWRDN bit is apparently only available on 3430ES2 and above */
diff --git a/arch/arm/mach-omap2/clockdomain.c b/arch/arm/mach-omap2/clockdomain.c
index 58aff8485df9..fcd82320a6a3 100644
--- a/arch/arm/mach-omap2/clockdomain.c
+++ b/arch/arm/mach-omap2/clockdomain.c
@@ -28,14 +28,14 @@
 
 #include <linux/bitops.h>
 
-#include <mach/clock.h>
+#include <plat/clock.h>
 
 #include "prm.h"
 #include "prm-regbits-24xx.h"
 #include "cm.h"
 
-#include <mach/powerdomain.h>
-#include <mach/clockdomain.h>
+#include <plat/powerdomain.h>
+#include <plat/clockdomain.h>
 
 /* clkdm_list contains all registered struct clockdomains */
 static LIST_HEAD(clkdm_list);
diff --git a/arch/arm/mach-omap2/clockdomains.h b/arch/arm/mach-omap2/clockdomains.h
index fe319ae4ca0a..c4ee0761d908 100644
--- a/arch/arm/mach-omap2/clockdomains.h
+++ b/arch/arm/mach-omap2/clockdomains.h
@@ -10,7 +10,7 @@
 #ifndef __ARCH_ARM_MACH_OMAP2_CLOCKDOMAINS_H
 #define __ARCH_ARM_MACH_OMAP2_CLOCKDOMAINS_H
 
-#include <mach/clockdomain.h>
+#include <plat/clockdomain.h>
 
 /*
  * OMAP2/3-common clockdomains
diff --git a/arch/arm/mach-omap2/cm.h b/arch/arm/mach-omap2/cm.h
index cfd0b726ba44..a2fcfcc253cc 100644
--- a/arch/arm/mach-omap2/cm.h
+++ b/arch/arm/mach-omap2/cm.h
@@ -17,11 +17,11 @@
 #include "prcm-common.h"
 
 #define OMAP2420_CM_REGADDR(module, reg)                                \
-                        OMAP2_IO_ADDRESS(OMAP2420_CM_BASE + (module) + (reg))
+                        OMAP2_L4_IO_ADDRESS(OMAP2420_CM_BASE + (module) + (reg))
 #define OMAP2430_CM_REGADDR(module, reg)                                \
-                        OMAP2_IO_ADDRESS(OMAP2430_CM_BASE + (module) + (reg))
+                        OMAP2_L4_IO_ADDRESS(OMAP2430_CM_BASE + (module) + (reg))
 #define OMAP34XX_CM_REGADDR(module, reg)                                \
-                        OMAP2_IO_ADDRESS(OMAP3430_CM_BASE + (module) + (reg))
+                        OMAP2_L4_IO_ADDRESS(OMAP3430_CM_BASE + (module) + (reg))
 
 /*
  * Architecture-specific global CM registers
diff --git a/arch/arm/mach-omap2/control.c b/arch/arm/mach-omap2/control.c
index 5f3aad977842..cdd1f35636dd 100644
--- a/arch/arm/mach-omap2/control.c
+++ b/arch/arm/mach-omap2/control.c
@@ -15,11 +15,127 @@
 #include <linux/kernel.h>
 #include <linux/io.h>
 
-#include <mach/common.h>
-#include <mach/control.h>
+#include <plat/common.h>
+#include <plat/control.h>
+#include <plat/sdrc.h>
+#include "cm-regbits-34xx.h"
+#include "prm-regbits-34xx.h"
+#include "cm.h"
+#include "prm.h"
+#include "sdrc.h"
 
 static void __iomem *omap2_ctrl_base;
 
+#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_PM)
+struct omap3_scratchpad {
+        u32 boot_config_ptr;
+        u32 public_restore_ptr;
+        u32 secure_ram_restore_ptr;
+        u32 sdrc_module_semaphore;
+        u32 prcm_block_offset;
+        u32 sdrc_block_offset;
+};
+
+struct omap3_scratchpad_prcm_block {
+        u32 prm_clksrc_ctrl;
+        u32 prm_clksel;
+        u32 cm_clksel_core;
+        u32 cm_clksel_wkup;
+        u32 cm_clken_pll;
+        u32 cm_autoidle_pll;
+        u32 cm_clksel1_pll;
+        u32 cm_clksel2_pll;
+        u32 cm_clksel3_pll;
+        u32 cm_clken_pll_mpu;
+        u32 cm_autoidle_pll_mpu;
+        u32 cm_clksel1_pll_mpu;
+        u32 cm_clksel2_pll_mpu;
+        u32 prcm_block_size;
+};
+
+struct omap3_scratchpad_sdrc_block {
+        u16 sysconfig;
+        u16 cs_cfg;
+        u16 sharing;
+        u16 err_type;
+        u32 dll_a_ctrl;
+        u32 dll_b_ctrl;
+        u32 power;
+        u32 cs_0;
+        u32 mcfg_0;
+        u16 mr_0;
+        u16 emr_1_0;
+        u16 emr_2_0;
+        u16 emr_3_0;
+        u32 actim_ctrla_0;
+        u32 actim_ctrlb_0;
+        u32 rfr_ctrl_0;
+        u32 cs_1;
+        u32 mcfg_1;
+        u16 mr_1;
+        u16 emr_1_1;
+        u16 emr_2_1;
+        u16 emr_3_1;
+        u32 actim_ctrla_1;
+        u32 actim_ctrlb_1;
+        u32 rfr_ctrl_1;
+        u16 dcdl_1_ctrl;
+        u16 dcdl_2_ctrl;
+        u32 flags;
+        u32 block_size;
+};
+
+void *omap3_secure_ram_storage;
+
+/*
+ * This is used to store ARM registers in SDRAM before attempting
+ * an MPU OFF. The save and restore happens from the SRAM sleep code.
+ * The address is stored in scratchpad, so that it can be used
+ * during the restore path.
+ */
+u32 omap3_arm_context[128];
+
+struct omap3_control_regs {
+        u32 sysconfig;
+        u32 devconf0;
+        u32 mem_dftrw0;
+        u32 mem_dftrw1;
+        u32 msuspendmux_0;
+        u32 msuspendmux_1;
+        u32 msuspendmux_2;
+        u32 msuspendmux_3;
+        u32 msuspendmux_4;
+        u32 msuspendmux_5;
+        u32 sec_ctrl;
+        u32 devconf1;
+        u32 csirxfe;
+        u32 iva2_bootaddr;
+        u32 iva2_bootmod;
+        u32 debobs_0;
+        u32 debobs_1;
+        u32 debobs_2;
+        u32 debobs_3;
+        u32 debobs_4;
+        u32 debobs_5;
+        u32 debobs_6;
+        u32 debobs_7;
+        u32 debobs_8;
+        u32 prog_io0;
+        u32 prog_io1;
+        u32 dss_dpll_spreading;
+        u32 core_dpll_spreading;
+        u32 per_dpll_spreading;
+        u32 usbhost_dpll_spreading;
+        u32 pbias_lite;
+        u32 temp_sensor;
+        u32 sramldo4;
+        u32 sramldo5;
+        u32 csi;
+};
+
+static struct omap3_control_regs control_context;
+#endif /* CONFIG_ARCH_OMAP3 && CONFIG_PM */
+
 #define OMAP_CTRL_REGADDR(reg)          (omap2_ctrl_base + (reg))
 
 void __init omap2_set_globals_control(struct omap_globals *omap2_globals)
@@ -62,3 +178,268 @@ void omap_ctrl_writel(u32 val, u16 offset)
         __raw_writel(val, OMAP_CTRL_REGADDR(offset));
 }
 
+#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_PM)
+/*
+ * Clears the scratchpad contents in case of cold boot-
+ * called during bootup
+ */
+void omap3_clear_scratchpad_contents(void)
+{
+        u32 max_offset = OMAP343X_SCRATCHPAD_ROM_OFFSET;
+        u32 *v_addr;
+        u32 offset = 0;
+        v_addr = OMAP2_L4_IO_ADDRESS(OMAP343X_SCRATCHPAD_ROM);
+        if (prm_read_mod_reg(OMAP3430_GR_MOD, OMAP3_PRM_RSTST_OFFSET) &
+                OMAP3430_GLOBAL_COLD_RST) {
+                for ( ; offset <= max_offset; offset += 0x4)
+                        __raw_writel(0x0, (v_addr + offset));
+                prm_set_mod_reg_bits(OMAP3430_GLOBAL_COLD_RST, OMAP3430_GR_MOD,
+                        OMAP3_PRM_RSTST_OFFSET);
+        }
+}
+
+/* Populate the scratchpad structure with restore structure */
+void omap3_save_scratchpad_contents(void)
+{
+        void * __iomem scratchpad_address;
+        u32 arm_context_addr;
+        struct omap3_scratchpad scratchpad_contents;
+        struct omap3_scratchpad_prcm_block prcm_block_contents;
+        struct omap3_scratchpad_sdrc_block sdrc_block_contents;
+
+        /* Populate the Scratchpad contents */
+        scratchpad_contents.boot_config_ptr = 0x0;
+        if (omap_rev() != OMAP3430_REV_ES3_0 &&
+                                        omap_rev() != OMAP3430_REV_ES3_1)
+                scratchpad_contents.public_restore_ptr =
+                        virt_to_phys(get_restore_pointer());
+        else
+                scratchpad_contents.public_restore_ptr =
+                        virt_to_phys(get_es3_restore_pointer());
+        if (omap_type() == OMAP2_DEVICE_TYPE_GP)
+                scratchpad_contents.secure_ram_restore_ptr = 0x0;
+        else
+                scratchpad_contents.secure_ram_restore_ptr =
+                        (u32) __pa(omap3_secure_ram_storage);
+        scratchpad_contents.sdrc_module_semaphore = 0x0;
+        scratchpad_contents.prcm_block_offset = 0x2C;
+        scratchpad_contents.sdrc_block_offset = 0x64;
+
+        /* Populate the PRCM block contents */
+        prcm_block_contents.prm_clksrc_ctrl = prm_read_mod_reg(OMAP3430_GR_MOD,
+                        OMAP3_PRM_CLKSRC_CTRL_OFFSET);
+        prcm_block_contents.prm_clksel = prm_read_mod_reg(OMAP3430_CCR_MOD,
+                        OMAP3_PRM_CLKSEL_OFFSET);
+        prcm_block_contents.cm_clksel_core =
+                        cm_read_mod_reg(CORE_MOD, CM_CLKSEL);
+        prcm_block_contents.cm_clksel_wkup =
+                        cm_read_mod_reg(WKUP_MOD, CM_CLKSEL);
+        prcm_block_contents.cm_clken_pll =
+                        cm_read_mod_reg(PLL_MOD, CM_CLKEN);
+        prcm_block_contents.cm_autoidle_pll =
+                        cm_read_mod_reg(PLL_MOD, OMAP3430_CM_AUTOIDLE_PLL);
+        prcm_block_contents.cm_clksel1_pll =
+                        cm_read_mod_reg(PLL_MOD, OMAP3430_CM_CLKSEL1_PLL);
+        prcm_block_contents.cm_clksel2_pll =
+                        cm_read_mod_reg(PLL_MOD, OMAP3430_CM_CLKSEL2_PLL);
+        prcm_block_contents.cm_clksel3_pll =
+                        cm_read_mod_reg(PLL_MOD, OMAP3430_CM_CLKSEL3);
+        prcm_block_contents.cm_clken_pll_mpu =
+                        cm_read_mod_reg(MPU_MOD, OMAP3430_CM_CLKEN_PLL);
+        prcm_block_contents.cm_autoidle_pll_mpu =
+                        cm_read_mod_reg(MPU_MOD, OMAP3430_CM_AUTOIDLE_PLL);
+        prcm_block_contents.cm_clksel1_pll_mpu =
+                        cm_read_mod_reg(MPU_MOD, OMAP3430_CM_CLKSEL1_PLL);
+        prcm_block_contents.cm_clksel2_pll_mpu =
+                        cm_read_mod_reg(MPU_MOD, OMAP3430_CM_CLKSEL2_PLL);
+        prcm_block_contents.prcm_block_size = 0x0;
+
+        /* Populate the SDRC block contents */
+        sdrc_block_contents.sysconfig =
+                        (sdrc_read_reg(SDRC_SYSCONFIG) & 0xFFFF);
+        sdrc_block_contents.cs_cfg =
+                        (sdrc_read_reg(SDRC_CS_CFG) & 0xFFFF);
+        sdrc_block_contents.sharing =
+                        (sdrc_read_reg(SDRC_SHARING) & 0xFFFF);
+        sdrc_block_contents.err_type =
+                        (sdrc_read_reg(SDRC_ERR_TYPE) & 0xFFFF);
+        sdrc_block_contents.dll_a_ctrl = sdrc_read_reg(SDRC_DLLA_CTRL);
+        sdrc_block_contents.dll_b_ctrl = 0x0;
+        /*
+         * Due to a OMAP3 errata (1.142), on EMU/HS devices SRDC should
+         * be programed to issue automatic self refresh on timeout
+         * of AUTO_CNT = 1 prior to any transition to OFF mode.
+         */
+        if ((omap_type() != OMAP2_DEVICE_TYPE_GP)
+                        && (omap_rev() >= OMAP3430_REV_ES3_0))
+                sdrc_block_contents.power = (sdrc_read_reg(SDRC_POWER) &
+                                ~(SDRC_POWER_AUTOCOUNT_MASK|
+                                SDRC_POWER_CLKCTRL_MASK)) |
+                                (1 << SDRC_POWER_AUTOCOUNT_SHIFT) |
+                                SDRC_SELF_REFRESH_ON_AUTOCOUNT;
+        else
+                sdrc_block_contents.power = sdrc_read_reg(SDRC_POWER);
+
+        sdrc_block_contents.cs_0 = 0x0;
+        sdrc_block_contents.mcfg_0 = sdrc_read_reg(SDRC_MCFG_0);
+        sdrc_block_contents.mr_0 = (sdrc_read_reg(SDRC_MR_0) & 0xFFFF);
+        sdrc_block_contents.emr_1_0 = 0x0;
+        sdrc_block_contents.emr_2_0 = 0x0;
+        sdrc_block_contents.emr_3_0 = 0x0;
+        sdrc_block_contents.actim_ctrla_0 =
+                        sdrc_read_reg(SDRC_ACTIM_CTRL_A_0);
+        sdrc_block_contents.actim_ctrlb_0 =
+                        sdrc_read_reg(SDRC_ACTIM_CTRL_B_0);
+        sdrc_block_contents.rfr_ctrl_0 =
+                        sdrc_read_reg(SDRC_RFR_CTRL_0);
+        sdrc_block_contents.cs_1 = 0x0;
+        sdrc_block_contents.mcfg_1 = sdrc_read_reg(SDRC_MCFG_1);
+        sdrc_block_contents.mr_1 = sdrc_read_reg(SDRC_MR_1) & 0xFFFF;
+        sdrc_block_contents.emr_1_1 = 0x0;
+        sdrc_block_contents.emr_2_1 = 0x0;
+        sdrc_block_contents.emr_3_1 = 0x0;
+        sdrc_block_contents.actim_ctrla_1 =
+                        sdrc_read_reg(SDRC_ACTIM_CTRL_A_1);
+        sdrc_block_contents.actim_ctrlb_1 =
+                        sdrc_read_reg(SDRC_ACTIM_CTRL_B_1);
+        sdrc_block_contents.rfr_ctrl_1 =
+                        sdrc_read_reg(SDRC_RFR_CTRL_1);
+        sdrc_block_contents.dcdl_1_ctrl = 0x0;
+        sdrc_block_contents.dcdl_2_ctrl = 0x0;
+        sdrc_block_contents.flags = 0x0;
+        sdrc_block_contents.block_size = 0x0;
+
+        arm_context_addr = virt_to_phys(omap3_arm_context);
+
+        /* Copy all the contents to the scratchpad location */
+        scratchpad_address = OMAP2_L4_IO_ADDRESS(OMAP343X_SCRATCHPAD);
+        memcpy_toio(scratchpad_address, &scratchpad_contents,
+                 sizeof(scratchpad_contents));
+        /* Scratchpad contents being 32 bits, a divide by 4 done here */
+        memcpy_toio(scratchpad_address +
+                scratchpad_contents.prcm_block_offset,
+                &prcm_block_contents, sizeof(prcm_block_contents));
+        memcpy_toio(scratchpad_address +
+                scratchpad_contents.sdrc_block_offset,
+                &sdrc_block_contents, sizeof(sdrc_block_contents));
+        /*
+         * Copies the address of the location in SDRAM where ARM
+         * registers get saved during a MPU OFF transition.
+         */
+        memcpy_toio(scratchpad_address +
+                scratchpad_contents.sdrc_block_offset +
+                sizeof(sdrc_block_contents), &arm_context_addr, 4);
+}
+
+void omap3_control_save_context(void)
+{
+        control_context.sysconfig = omap_ctrl_readl(OMAP2_CONTROL_SYSCONFIG);
+        control_context.devconf0 = omap_ctrl_readl(OMAP2_CONTROL_DEVCONF0);
+        control_context.mem_dftrw0 =
+                        omap_ctrl_readl(OMAP343X_CONTROL_MEM_DFTRW0);
+        control_context.mem_dftrw1 =
+                        omap_ctrl_readl(OMAP343X_CONTROL_MEM_DFTRW1);
+        control_context.msuspendmux_0 =
+                        omap_ctrl_readl(OMAP2_CONTROL_MSUSPENDMUX_0);
+        control_context.msuspendmux_1 =
+                        omap_ctrl_readl(OMAP2_CONTROL_MSUSPENDMUX_1);
+        control_context.msuspendmux_2 =
+                        omap_ctrl_readl(OMAP2_CONTROL_MSUSPENDMUX_2);
+        control_context.msuspendmux_3 =
+                        omap_ctrl_readl(OMAP2_CONTROL_MSUSPENDMUX_3);
+        control_context.msuspendmux_4 =
+                        omap_ctrl_readl(OMAP2_CONTROL_MSUSPENDMUX_4);
+        control_context.msuspendmux_5 =
+                        omap_ctrl_readl(OMAP2_CONTROL_MSUSPENDMUX_5);
+        control_context.sec_ctrl = omap_ctrl_readl(OMAP2_CONTROL_SEC_CTRL);
+        control_context.devconf1 = omap_ctrl_readl(OMAP343X_CONTROL_DEVCONF1);
+        control_context.csirxfe = omap_ctrl_readl(OMAP343X_CONTROL_CSIRXFE);
+        control_context.iva2_bootaddr =
+                        omap_ctrl_readl(OMAP343X_CONTROL_IVA2_BOOTADDR);
+        control_context.iva2_bootmod =
+                        omap_ctrl_readl(OMAP343X_CONTROL_IVA2_BOOTMOD);
+        control_context.debobs_0 = omap_ctrl_readl(OMAP343X_CONTROL_DEBOBS(0));
+        control_context.debobs_1 = omap_ctrl_readl(OMAP343X_CONTROL_DEBOBS(1));
+        control_context.debobs_2 = omap_ctrl_readl(OMAP343X_CONTROL_DEBOBS(2));
+        control_context.debobs_3 = omap_ctrl_readl(OMAP343X_CONTROL_DEBOBS(3));
+        control_context.debobs_4 = omap_ctrl_readl(OMAP343X_CONTROL_DEBOBS(4));
+        control_context.debobs_5 = omap_ctrl_readl(OMAP343X_CONTROL_DEBOBS(5));
+        control_context.debobs_6 = omap_ctrl_readl(OMAP343X_CONTROL_DEBOBS(6));
+        control_context.debobs_7 = omap_ctrl_readl(OMAP343X_CONTROL_DEBOBS(7));
+        control_context.debobs_8 = omap_ctrl_readl(OMAP343X_CONTROL_DEBOBS(8));
+        control_context.prog_io0 = omap_ctrl_readl(OMAP343X_CONTROL_PROG_IO0);
+        control_context.prog_io1 = omap_ctrl_readl(OMAP343X_CONTROL_PROG_IO1);
+        control_context.dss_dpll_spreading =
+                        omap_ctrl_readl(OMAP343X_CONTROL_DSS_DPLL_SPREADING);
+        control_context.core_dpll_spreading =
+                        omap_ctrl_readl(OMAP343X_CONTROL_CORE_DPLL_SPREADING);
+        control_context.per_dpll_spreading =
+                        omap_ctrl_readl(OMAP343X_CONTROL_PER_DPLL_SPREADING);
+        control_context.usbhost_dpll_spreading =
+                omap_ctrl_readl(OMAP343X_CONTROL_USBHOST_DPLL_SPREADING);
+        control_context.pbias_lite =
+                        omap_ctrl_readl(OMAP343X_CONTROL_PBIAS_LITE);
+        control_context.temp_sensor =
+                        omap_ctrl_readl(OMAP343X_CONTROL_TEMP_SENSOR);
+        control_context.sramldo4 = omap_ctrl_readl(OMAP343X_CONTROL_SRAMLDO4);
+        control_context.sramldo5 = omap_ctrl_readl(OMAP343X_CONTROL_SRAMLDO5);
+        control_context.csi = omap_ctrl_readl(OMAP343X_CONTROL_CSI);
+        return;
+}
+
+void omap3_control_restore_context(void)
+{
+        omap_ctrl_writel(control_context.sysconfig, OMAP2_CONTROL_SYSCONFIG);
+        omap_ctrl_writel(control_context.devconf0, OMAP2_CONTROL_DEVCONF0);
+        omap_ctrl_writel(control_context.mem_dftrw0,
+                                        OMAP343X_CONTROL_MEM_DFTRW0);
+        omap_ctrl_writel(control_context.mem_dftrw1,
+                                        OMAP343X_CONTROL_MEM_DFTRW1);
+        omap_ctrl_writel(control_context.msuspendmux_0,
+                                        OMAP2_CONTROL_MSUSPENDMUX_0);
+        omap_ctrl_writel(control_context.msuspendmux_1,
+                                        OMAP2_CONTROL_MSUSPENDMUX_1);
+        omap_ctrl_writel(control_context.msuspendmux_2,
+                                        OMAP2_CONTROL_MSUSPENDMUX_2);
+        omap_ctrl_writel(control_context.msuspendmux_3,
+                                        OMAP2_CONTROL_MSUSPENDMUX_3);
+        omap_ctrl_writel(control_context.msuspendmux_4,
+                                        OMAP2_CONTROL_MSUSPENDMUX_4);
+        omap_ctrl_writel(control_context.msuspendmux_5,
+                                        OMAP2_CONTROL_MSUSPENDMUX_5);
+        omap_ctrl_writel(control_context.sec_ctrl, OMAP2_CONTROL_SEC_CTRL);
+        omap_ctrl_writel(control_context.devconf1, OMAP343X_CONTROL_DEVCONF1);
+        omap_ctrl_writel(control_context.csirxfe, OMAP343X_CONTROL_CSIRXFE);
+        omap_ctrl_writel(control_context.iva2_bootaddr,
+                                        OMAP343X_CONTROL_IVA2_BOOTADDR);
+        omap_ctrl_writel(control_context.iva2_bootmod,
+                                        OMAP343X_CONTROL_IVA2_BOOTMOD);
+        omap_ctrl_writel(control_context.debobs_0, OMAP343X_CONTROL_DEBOBS(0));
+        omap_ctrl_writel(control_context.debobs_1, OMAP343X_CONTROL_DEBOBS(1));
+        omap_ctrl_writel(control_context.debobs_2, OMAP343X_CONTROL_DEBOBS(2));
+        omap_ctrl_writel(control_context.debobs_3, OMAP343X_CONTROL_DEBOBS(3));
+        omap_ctrl_writel(control_context.debobs_4, OMAP343X_CONTROL_DEBOBS(4));
+        omap_ctrl_writel(control_context.debobs_5, OMAP343X_CONTROL_DEBOBS(5));
+        omap_ctrl_writel(control_context.debobs_6, OMAP343X_CONTROL_DEBOBS(6));
+        omap_ctrl_writel(control_context.debobs_7, OMAP343X_CONTROL_DEBOBS(7));
+        omap_ctrl_writel(control_context.debobs_8, OMAP343X_CONTROL_DEBOBS(8));
+        omap_ctrl_writel(control_context.prog_io0, OMAP343X_CONTROL_PROG_IO0);
+        omap_ctrl_writel(control_context.prog_io1, OMAP343X_CONTROL_PROG_IO1);
+        omap_ctrl_writel(control_context.dss_dpll_spreading,
+                                        OMAP343X_CONTROL_DSS_DPLL_SPREADING);
+        omap_ctrl_writel(control_context.core_dpll_spreading,
+                                        OMAP343X_CONTROL_CORE_DPLL_SPREADING);
+        omap_ctrl_writel(control_context.per_dpll_spreading,
+                                        OMAP343X_CONTROL_PER_DPLL_SPREADING);
+        omap_ctrl_writel(control_context.usbhost_dpll_spreading,
+                                OMAP343X_CONTROL_USBHOST_DPLL_SPREADING);
+        omap_ctrl_writel(control_context.pbias_lite,
+                                        OMAP343X_CONTROL_PBIAS_LITE);
+        omap_ctrl_writel(control_context.temp_sensor,
+                                        OMAP343X_CONTROL_TEMP_SENSOR);
+        omap_ctrl_writel(control_context.sramldo4, OMAP343X_CONTROL_SRAMLDO4);
+        omap_ctrl_writel(control_context.sramldo5, OMAP343X_CONTROL_SRAMLDO5);
+        omap_ctrl_writel(control_context.csi, OMAP343X_CONTROL_CSI);
+        return;
+}
+#endif /* CONFIG_ARCH_OMAP3 && CONFIG_PM */
diff --git a/arch/arm/mach-omap2/cpuidle34xx.c b/arch/arm/mach-omap2/cpuidle34xx.c
new file mode 100644
index 000000000000..a26d6a08ae3f
--- /dev/null
+++ b/arch/arm/mach-omap2/cpuidle34xx.c
@@ -0,0 +1,318 @@
+/*
+ * linux/arch/arm/mach-omap2/cpuidle34xx.c
+ *
+ * OMAP3 CPU IDLE Routines
+ *
+ * Copyright (C) 2008 Texas Instruments, Inc.
+ * Rajendra Nayak <rnayak@ti.com>
+ *
+ * Copyright (C) 2007 Texas Instruments, Inc.
+ * Karthik Dasu <karthik-dp@ti.com>
+ *
+ * Copyright (C) 2006 Nokia Corporation
+ * Tony Lindgren <tony@atomide.com>
+ *
+ * Copyright (C) 2005 Texas Instruments, Inc.
+ * Richard Woodruff <r-woodruff2@ti.com>
+ *
+ * Based on pm.c for omap2
+ *
+ * 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 <linux/sched.h>
+#include <linux/cpuidle.h>
+
+#include <plat/prcm.h>
+#include <plat/irqs.h>
+#include <plat/powerdomain.h>
+#include <plat/clockdomain.h>
+#include <plat/control.h>
+#include <plat/serial.h>
+
+#include "pm.h"
+
+#ifdef CONFIG_CPU_IDLE
+
+#define OMAP3_MAX_STATES 7
+#define OMAP3_STATE_C1 0 /* C1 - MPU WFI + Core active */
+#define OMAP3_STATE_C2 1 /* C2 - MPU WFI + Core inactive */
+#define OMAP3_STATE_C3 2 /* C3 - MPU CSWR + Core inactive */
+#define OMAP3_STATE_C4 3 /* C4 - MPU OFF + Core iactive */
+#define OMAP3_STATE_C5 4 /* C5 - MPU RET + Core RET */
+#define OMAP3_STATE_C6 5 /* C6 - MPU OFF + Core RET */
+#define OMAP3_STATE_C7 6 /* C7 - MPU OFF + Core OFF */
+
+struct omap3_processor_cx {
+        u8 valid;
+        u8 type;
+        u32 sleep_latency;
+        u32 wakeup_latency;
+        u32 mpu_state;
+        u32 core_state;
+        u32 threshold;
+        u32 flags;
+};
+
+struct omap3_processor_cx omap3_power_states[OMAP3_MAX_STATES];
+struct omap3_processor_cx current_cx_state;
+struct powerdomain *mpu_pd, *core_pd;
+
+static int omap3_idle_bm_check(void)
+{
+        if (!omap3_can_sleep())
+                return 1;
+        return 0;
+}
+
+static int _cpuidle_allow_idle(struct powerdomain *pwrdm,
+                                struct clockdomain *clkdm)
+{
+        omap2_clkdm_allow_idle(clkdm);
+        return 0;
+}
+
+static int _cpuidle_deny_idle(struct powerdomain *pwrdm,
+                                struct clockdomain *clkdm)
+{
+        omap2_clkdm_deny_idle(clkdm);
+        return 0;
+}
+
+/**
+ * omap3_enter_idle - Programs OMAP3 to enter the specified state
+ * @dev: cpuidle device
+ * @state: The target state to be programmed
+ *
+ * Called from the CPUidle framework to program the device to the
+ * specified target state selected by the governor.
+ */
+static int omap3_enter_idle(struct cpuidle_device *dev,
+                        struct cpuidle_state *state)
+{
+        struct omap3_processor_cx *cx = cpuidle_get_statedata(state);
+        struct timespec ts_preidle, ts_postidle, ts_idle;
+        u32 mpu_state = cx->mpu_state, core_state = cx->core_state;
+
+        current_cx_state = *cx;
+
+        /* Used to keep track of the total time in idle */
+        getnstimeofday(&ts_preidle);
+
+        local_irq_disable();
+        local_fiq_disable();
+
+        if (!enable_off_mode) {
+                if (mpu_state < PWRDM_POWER_RET)
+                        mpu_state = PWRDM_POWER_RET;
+                if (core_state < PWRDM_POWER_RET)
+                        core_state = PWRDM_POWER_RET;
+        }
+
+        pwrdm_set_next_pwrst(mpu_pd, mpu_state);
+        pwrdm_set_next_pwrst(core_pd, core_state);
+
+        if (omap_irq_pending() || need_resched())
+                goto return_sleep_time;
+
+        if (cx->type == OMAP3_STATE_C1) {
+                pwrdm_for_each_clkdm(mpu_pd, _cpuidle_deny_idle);
+                pwrdm_for_each_clkdm(core_pd, _cpuidle_deny_idle);
+        }
+
+        /* Execute ARM wfi */
+        omap_sram_idle();
+
+        if (cx->type == OMAP3_STATE_C1) {
+                pwrdm_for_each_clkdm(mpu_pd, _cpuidle_allow_idle);
+                pwrdm_for_each_clkdm(core_pd, _cpuidle_allow_idle);
+        }
+
+return_sleep_time:
+        getnstimeofday(&ts_postidle);
+        ts_idle = timespec_sub(ts_postidle, ts_preidle);
+
+        local_irq_enable();
+        local_fiq_enable();
+
+        return (u32)timespec_to_ns(&ts_idle)/1000;
+}
+
+/**
+ * omap3_enter_idle_bm - Checks for any bus activity
+ * @dev: cpuidle device
+ * @state: The target state to be programmed
+ *
+ * Used for C states with CPUIDLE_FLAG_CHECK_BM flag set. This
+ * function checks for any pending activity and then programs the
+ * device to the specified or a safer state.
+ */
+static int omap3_enter_idle_bm(struct cpuidle_device *dev,
+                               struct cpuidle_state *state)
+{
+        struct cpuidle_state *new_state = state;
+
+        if ((state->flags & CPUIDLE_FLAG_CHECK_BM) && omap3_idle_bm_check()) {
+                BUG_ON(!dev->safe_state);
+                new_state = dev->safe_state;
+        }
+
+        dev->last_state = new_state;
+        return omap3_enter_idle(dev, new_state);
+}
+
+DEFINE_PER_CPU(struct cpuidle_device, omap3_idle_dev);
+
+/* omap3_init_power_states - Initialises the OMAP3 specific C states.
+ *
+ * Below is the desciption of each C state.
+ *      C1 . MPU WFI + Core active
+ *      C2 . MPU WFI + Core inactive
+ *      C3 . MPU CSWR + Core inactive
+ *      C4 . MPU OFF + Core inactive
+ *      C5 . MPU CSWR + Core CSWR
+ *      C6 . MPU OFF + Core CSWR
+ *      C7 . MPU OFF + Core OFF
+ */
+void omap_init_power_states(void)
+{
+        /* C1 . MPU WFI + Core active */
+        omap3_power_states[OMAP3_STATE_C1].valid = 1;
+        omap3_power_states[OMAP3_STATE_C1].type = OMAP3_STATE_C1;
+        omap3_power_states[OMAP3_STATE_C1].sleep_latency = 2;
+        omap3_power_states[OMAP3_STATE_C1].wakeup_latency = 2;
+        omap3_power_states[OMAP3_STATE_C1].threshold = 5;
+        omap3_power_states[OMAP3_STATE_C1].mpu_state = PWRDM_POWER_ON;
+        omap3_power_states[OMAP3_STATE_C1].core_state = PWRDM_POWER_ON;
+        omap3_power_states[OMAP3_STATE_C1].flags = CPUIDLE_FLAG_TIME_VALID;
+
+        /* C2 . MPU WFI + Core inactive */
+        omap3_power_states[OMAP3_STATE_C2].valid = 1;
+        omap3_power_states[OMAP3_STATE_C2].type = OMAP3_STATE_C2;
+        omap3_power_states[OMAP3_STATE_C2].sleep_latency = 10;
+        omap3_power_states[OMAP3_STATE_C2].wakeup_latency = 10;
+        omap3_power_states[OMAP3_STATE_C2].threshold = 30;
+        omap3_power_states[OMAP3_STATE_C2].mpu_state = PWRDM_POWER_ON;
+        omap3_power_states[OMAP3_STATE_C2].core_state = PWRDM_POWER_ON;
+        omap3_power_states[OMAP3_STATE_C2].flags = CPUIDLE_FLAG_TIME_VALID;
+
+        /* C3 . MPU CSWR + Core inactive */
+        omap3_power_states[OMAP3_STATE_C3].valid = 1;
+        omap3_power_states[OMAP3_STATE_C3].type = OMAP3_STATE_C3;
+        omap3_power_states[OMAP3_STATE_C3].sleep_latency = 50;
+        omap3_power_states[OMAP3_STATE_C3].wakeup_latency = 50;
+        omap3_power_states[OMAP3_STATE_C3].threshold = 300;
+        omap3_power_states[OMAP3_STATE_C3].mpu_state = PWRDM_POWER_RET;
+        omap3_power_states[OMAP3_STATE_C3].core_state = PWRDM_POWER_ON;
+        omap3_power_states[OMAP3_STATE_C3].flags = CPUIDLE_FLAG_TIME_VALID |
+                                CPUIDLE_FLAG_CHECK_BM;
+
+        /* C4 . MPU OFF + Core inactive */
+        omap3_power_states[OMAP3_STATE_C4].valid = 1;
+        omap3_power_states[OMAP3_STATE_C4].type = OMAP3_STATE_C4;
+        omap3_power_states[OMAP3_STATE_C4].sleep_latency = 1500;
+        omap3_power_states[OMAP3_STATE_C4].wakeup_latency = 1800;
+        omap3_power_states[OMAP3_STATE_C4].threshold = 4000;
+        omap3_power_states[OMAP3_STATE_C4].mpu_state = PWRDM_POWER_OFF;
+        omap3_power_states[OMAP3_STATE_C4].core_state = PWRDM_POWER_ON;
+        omap3_power_states[OMAP3_STATE_C4].flags = CPUIDLE_FLAG_TIME_VALID |
+                                CPUIDLE_FLAG_CHECK_BM;
+
+        /* C5 . MPU CSWR + Core CSWR*/
+        omap3_power_states[OMAP3_STATE_C5].valid = 1;
+        omap3_power_states[OMAP3_STATE_C5].type = OMAP3_STATE_C5;
+        omap3_power_states[OMAP3_STATE_C5].sleep_latency = 2500;
+        omap3_power_states[OMAP3_STATE_C5].wakeup_latency = 7500;
+        omap3_power_states[OMAP3_STATE_C5].threshold = 12000;
+        omap3_power_states[OMAP3_STATE_C5].mpu_state = PWRDM_POWER_RET;
+        omap3_power_states[OMAP3_STATE_C5].core_state = PWRDM_POWER_RET;
+        omap3_power_states[OMAP3_STATE_C5].flags = CPUIDLE_FLAG_TIME_VALID |
+                                CPUIDLE_FLAG_CHECK_BM;
+
+        /* C6 . MPU OFF + Core CSWR */
+        omap3_power_states[OMAP3_STATE_C6].valid = 1;
+        omap3_power_states[OMAP3_STATE_C6].type = OMAP3_STATE_C6;
+        omap3_power_states[OMAP3_STATE_C6].sleep_latency = 3000;
+        omap3_power_states[OMAP3_STATE_C6].wakeup_latency = 8500;
+        omap3_power_states[OMAP3_STATE_C6].threshold = 15000;
+        omap3_power_states[OMAP3_STATE_C6].mpu_state = PWRDM_POWER_OFF;
+        omap3_power_states[OMAP3_STATE_C6].core_state = PWRDM_POWER_RET;
+        omap3_power_states[OMAP3_STATE_C6].flags = CPUIDLE_FLAG_TIME_VALID |
+                                CPUIDLE_FLAG_CHECK_BM;
+
+        /* C7 . MPU OFF + Core OFF */
+        omap3_power_states[OMAP3_STATE_C7].valid = 1;
+        omap3_power_states[OMAP3_STATE_C7].type = OMAP3_STATE_C7;
+        omap3_power_states[OMAP3_STATE_C7].sleep_latency = 10000;
+        omap3_power_states[OMAP3_STATE_C7].wakeup_latency = 30000;
+        omap3_power_states[OMAP3_STATE_C7].threshold = 300000;
+        omap3_power_states[OMAP3_STATE_C7].mpu_state = PWRDM_POWER_OFF;
+        omap3_power_states[OMAP3_STATE_C7].core_state = PWRDM_POWER_OFF;
+        omap3_power_states[OMAP3_STATE_C7].flags = CPUIDLE_FLAG_TIME_VALID |
+                                CPUIDLE_FLAG_CHECK_BM;
+}
+
+struct cpuidle_driver omap3_idle_driver = {
+        .name =         "omap3_idle",
+        .owner =        THIS_MODULE,
+};
+
+/**
+ * omap3_idle_init - Init routine for OMAP3 idle
+ *
+ * Registers the OMAP3 specific cpuidle driver with the cpuidle
+ * framework with the valid set of states.
+ */
+int __init omap3_idle_init(void)
+{
+        int i, count = 0;
+        struct omap3_processor_cx *cx;
+        struct cpuidle_state *state;
+        struct cpuidle_device *dev;
+
+        mpu_pd = pwrdm_lookup("mpu_pwrdm");
+        core_pd = pwrdm_lookup("core_pwrdm");
+
+        omap_init_power_states();
+        cpuidle_register_driver(&omap3_idle_driver);
+
+        dev = &per_cpu(omap3_idle_dev, smp_processor_id());
+
+        for (i = OMAP3_STATE_C1; i < OMAP3_MAX_STATES; i++) {
+                cx = &omap3_power_states[i];
+                state = &dev->states[count];
+
+                if (!cx->valid)
+                        continue;
+                cpuidle_set_statedata(state, cx);
+                state->exit_latency = cx->sleep_latency + cx->wakeup_latency;
+                state->target_residency = cx->threshold;
+                state->flags = cx->flags;
+                state->enter = (state->flags & CPUIDLE_FLAG_CHECK_BM) ?
+                        omap3_enter_idle_bm : omap3_enter_idle;
+                if (cx->type == OMAP3_STATE_C1)
+                        dev->safe_state = state;
+                sprintf(state->name, "C%d", count+1);
+                count++;
+        }
+
+        if (!count)
+                return -EINVAL;
+        dev->state_count = count;
+
+        if (cpuidle_register_device(dev)) {
+                printk(KERN_ERR "%s: CPUidle register device failed\n",
+                       __func__);
+                return -EIO;
+        }
+
+        return 0;
+}
+#else
+int __init omap3_idle_init(void)
+{
+        return 0;
+}
+#endif /* CONFIG_CPU_IDLE */
diff --git a/arch/arm/mach-omap2/devices.c b/arch/arm/mach-omap2/devices.c
index faf7a1e0c525..733d3dcff98b 100644
--- a/arch/arm/mach-omap2/devices.c
+++ b/arch/arm/mach-omap2/devices.c
@@ -20,12 +20,12 @@
 #include <asm/mach-types.h>
 #include <asm/mach/map.h>
 
-#include <mach/control.h>
-#include <mach/tc.h>
-#include <mach/board.h>
-#include <mach/mux.h>
+#include <plat/control.h>
+#include <plat/tc.h>
+#include <plat/board.h>
+#include <plat/mux.h>
 #include <mach/gpio.h>
-#include <mach/mmc.h>
+#include <plat/mmc.h>
 
 #if defined(CONFIG_VIDEO_OMAP2) || defined(CONFIG_VIDEO_OMAP2_MODULE)
 
@@ -136,9 +136,10 @@ static inline void omap_init_camera(void)
 
 #if defined(CONFIG_OMAP_MBOX_FWK) || defined(CONFIG_OMAP_MBOX_FWK_MODULE)
 
-#define MBOX_REG_SIZE   0x120
+#define MBOX_REG_SIZE   0x120
 
-static struct resource omap2_mbox_resources[] = {
+#ifdef CONFIG_ARCH_OMAP2
+static struct resource omap_mbox_resources[] = {
         {
                 .start          = OMAP24XX_MAILBOX_BASE,
                 .end            = OMAP24XX_MAILBOX_BASE + MBOX_REG_SIZE - 1,
@@ -153,8 +154,10 @@ static struct resource omap2_mbox_resources[] = {
                 .flags          = IORESOURCE_IRQ,
         },
 };
+#endif
 
-static struct resource omap3_mbox_resources[] = {
+#ifdef CONFIG_ARCH_OMAP3
+static struct resource omap_mbox_resources[] = {
         {
                 .start          = OMAP34XX_MAILBOX_BASE,
                 .end            = OMAP34XX_MAILBOX_BASE + MBOX_REG_SIZE - 1,
@@ -165,6 +168,24 @@ static struct resource omap3_mbox_resources[] = {
                 .flags          = IORESOURCE_IRQ,
         },
 };
+#endif
+
+#ifdef CONFIG_ARCH_OMAP4
+
+#define OMAP4_MBOX_REG_SIZE     0x130
+static struct resource omap_mbox_resources[] = {
+        {
+                .start          = OMAP44XX_MAILBOX_BASE,
+                .end            = OMAP44XX_MAILBOX_BASE +
+                                        OMAP4_MBOX_REG_SIZE - 1,
+                .flags          = IORESOURCE_MEM,
+        },
+        {
+                .start          = INT_44XX_MAIL_U0_MPU,
+                .flags          = IORESOURCE_IRQ,
+        },
+};
+#endif
 
 static struct platform_device mbox_device = {
         .name           = "omap2-mailbox",
@@ -173,12 +194,9 @@ static struct platform_device mbox_device = {
 
 static inline void omap_init_mbox(void)
 {
-        if (cpu_is_omap2420()) {
-                mbox_device.num_resources = ARRAY_SIZE(omap2_mbox_resources);
-                mbox_device.resource = omap2_mbox_resources;
-        } else if (cpu_is_omap3430()) {
-                mbox_device.num_resources = ARRAY_SIZE(omap3_mbox_resources);
-                mbox_device.resource = omap3_mbox_resources;
+        if (cpu_is_omap2420() || cpu_is_omap3430() || cpu_is_omap44xx()) {
+                mbox_device.num_resources = ARRAY_SIZE(omap_mbox_resources);
+                mbox_device.resource = omap_mbox_resources;
         } else {
                 pr_err("%s: platform not supported\n", __func__);
                 return;
@@ -250,7 +268,7 @@ static inline void omap_init_sti(void) {}
 
 #if defined(CONFIG_SPI_OMAP24XX) || defined(CONFIG_SPI_OMAP24XX_MODULE)
 
-#include <mach/mcspi.h>
+#include <plat/mcspi.h>
 
 #define OMAP2_MCSPI1_BASE               0x48098000
 #define OMAP2_MCSPI2_BASE               0x4809a000
@@ -575,7 +593,7 @@ static inline void omap2_mmc_mux(struct omap_mmc_platform_data *mmc_controller,
                 }
         }
 
-        if (cpu_is_omap3430()) {
+        if (cpu_is_omap34xx()) {
                 if (controller_nr == 0) {
                         omap_cfg_reg(N28_3430_MMC1_CLK);
                         omap_cfg_reg(M27_3430_MMC1_CMD);
@@ -609,6 +627,12 @@ static inline void omap2_mmc_mux(struct omap_mmc_platform_data *mmc_controller,
                                 omap_cfg_reg(AG4_3430_MMC2_DAT2);
                                 omap_cfg_reg(AF4_3430_MMC2_DAT3);
                         }
+                        if (mmc_controller->slots[0].wires == 8) {
+                                omap_cfg_reg(AE4_3430_MMC2_DAT4);
+                                omap_cfg_reg(AH3_3430_MMC2_DAT5);
+                                omap_cfg_reg(AF3_3430_MMC2_DAT6);
+                                omap_cfg_reg(AE3_3430_MMC2_DAT7);
+                        }
                 }
 
                 /*
diff --git a/arch/arm/mach-omap2/emu.c b/arch/arm/mach-omap2/emu.c
new file mode 100644
index 000000000000..ec0d984a26fc
--- /dev/null
+++ b/arch/arm/mach-omap2/emu.c
@@ -0,0 +1,66 @@
+/*
+ * emu.c
+ *
+ * ETM and ETB CoreSight components' resources as found in OMAP3xxx.
+ *
+ * Copyright (C) 2009 Nokia Corporation.
+ * Alexander Shishkin
+ *
+ * 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 <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/amba/bus.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Alexander Shishkin");
+
+/* Cortex CoreSight components within omap3xxx EMU */
+#define ETM_BASE        (L4_EMU_34XX_PHYS + 0x10000)
+#define DBG_BASE        (L4_EMU_34XX_PHYS + 0x11000)
+#define ETB_BASE        (L4_EMU_34XX_PHYS + 0x1b000)
+#define DAPCTL          (L4_EMU_34XX_PHYS + 0x1d000)
+
+static struct amba_device omap3_etb_device = {
+        .dev            = {
+                .init_name = "etb",
+        },
+        .res            = {
+                .start  = ETB_BASE,
+                .end    = ETB_BASE + SZ_4K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        .periphid       = 0x000bb907,
+};
+
+static struct amba_device omap3_etm_device = {
+        .dev            = {
+                .init_name = "etm",
+        },
+        .res            = {
+                .start  = ETM_BASE,
+                .end    = ETM_BASE + SZ_4K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        .periphid       = 0x102bb921,
+};
+
+static int __init emu_init(void)
+{
+        amba_device_register(&omap3_etb_device, &iomem_resource);
+        amba_device_register(&omap3_etm_device, &iomem_resource);
+
+        return 0;
+}
+
+subsys_initcall(emu_init);
+
diff --git a/arch/arm/mach-omap2/gpmc-onenand.c b/arch/arm/mach-omap2/gpmc-onenand.c
index 54fec53a48e7..7bb69220adfa 100644
--- a/arch/arm/mach-omap2/gpmc-onenand.c
+++ b/arch/arm/mach-omap2/gpmc-onenand.c
@@ -17,9 +17,9 @@
 
 #include <asm/mach/flash.h>
 
-#include <mach/onenand.h>
-#include <mach/board.h>
-#include <mach/gpmc.h>
+#include <plat/onenand.h>
+#include <plat/board.h>
+#include <plat/gpmc.h>
 
 static struct omap_onenand_platform_data *gpmc_onenand_data;
 
diff --git a/arch/arm/mach-omap2/gpmc-smc91x.c b/arch/arm/mach-omap2/gpmc-smc91x.c
index df99d31d8b64..6083e21b3be6 100644
--- a/arch/arm/mach-omap2/gpmc-smc91x.c
+++ b/arch/arm/mach-omap2/gpmc-smc91x.c
@@ -17,9 +17,9 @@
 #include <linux/io.h>
 #include <linux/smc91x.h>
 
-#include <mach/board.h>
-#include <mach/gpmc.h>
-#include <mach/gpmc-smc91x.h>
+#include <plat/board.h>
+#include <plat/gpmc.h>
+#include <plat/gpmc-smc91x.h>
 
 static struct omap_smc91x_platform_data *gpmc_cfg;
 
diff --git a/arch/arm/mach-omap2/gpmc.c b/arch/arm/mach-omap2/gpmc.c
index 15876828db23..e86f5ca180ea 100644
--- a/arch/arm/mach-omap2/gpmc.c
+++ b/arch/arm/mach-omap2/gpmc.c
@@ -24,9 +24,9 @@
 #include <linux/module.h>
 
 #include <asm/mach-types.h>
-#include <mach/gpmc.h>
+#include <plat/gpmc.h>
 
-#include <mach/sdrc.h>
+#include <plat/sdrc.h>
 
 /* GPMC register offsets */
 #define GPMC_REVISION           0x00
@@ -62,6 +62,33 @@
 #define ENABLE_PREFETCH         (0x1 << 7)
 #define DMA_MPU_MODE            2
 
+/* Structure to save gpmc cs context */
+struct gpmc_cs_config {
+        u32 config1;
+        u32 config2;
+        u32 config3;
+        u32 config4;
+        u32 config5;
+        u32 config6;
+        u32 config7;
+        int is_valid;
+};
+
+/*
+ * Structure to save/restore gpmc context
+ * to support core off on OMAP3
+ */
+struct omap3_gpmc_regs {
+        u32 sysconfig;
+        u32 irqenable;
+        u32 timeout_ctrl;
+        u32 config;
+        u32 prefetch_config1;
+        u32 prefetch_config2;
+        u32 prefetch_control;
+        struct gpmc_cs_config cs_context[GPMC_CS_NUM];
+};
+
 static struct resource  gpmc_mem_root;
 static struct resource  gpmc_cs_mem[GPMC_CS_NUM];
 static DEFINE_SPINLOCK(gpmc_mem_lock);
@@ -261,7 +288,7 @@ static void gpmc_cs_enable_mem(int cs, u32 base, u32 size)
         l = (base >> GPMC_CHUNK_SHIFT) & 0x3f;
         l &= ~(0x0f << 8);
         l |= ((mask >> GPMC_CHUNK_SHIFT) & 0x0f) << 8;
-        l |= 1 << 6;            /* CSVALID */
+        l |= GPMC_CONFIG7_CSVALID;
         gpmc_cs_write_reg(cs, GPMC_CS_CONFIG7, l);
 }
 
@@ -270,7 +297,7 @@ static void gpmc_cs_disable_mem(int cs)
         u32 l;
 
         l = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
-        l &= ~(1 << 6);         /* CSVALID */
+        l &= ~GPMC_CONFIG7_CSVALID;
         gpmc_cs_write_reg(cs, GPMC_CS_CONFIG7, l);
 }
 
@@ -290,7 +317,7 @@ static int gpmc_cs_mem_enabled(int cs)
         u32 l;
 
         l = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG7);
-        return l & (1 << 6);
+        return l & GPMC_CONFIG7_CSVALID;
 }
 
 int gpmc_cs_set_reserved(int cs, int reserved)
@@ -366,7 +393,7 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
         if (r < 0)
                 goto out;
 
-        gpmc_cs_enable_mem(cs, res->start, res->end - res->start + 1);
+        gpmc_cs_enable_mem(cs, res->start, resource_size(res));
         *base = res->start;
         gpmc_cs_set_reserved(cs, 1);
 out:
@@ -378,7 +405,7 @@ EXPORT_SYMBOL(gpmc_cs_request);
 void gpmc_cs_free(int cs)
 {
         spin_lock(&gpmc_mem_lock);
-        if (cs >= GPMC_CS_NUM || !gpmc_cs_reserved(cs)) {
+        if (cs >= GPMC_CS_NUM || cs < 0 || !gpmc_cs_reserved(cs)) {
                 printk(KERN_ERR "Trying to free non-reserved GPMC CS%d\n", cs);
                 BUG();
                 spin_unlock(&gpmc_mem_lock);
@@ -516,3 +543,68 @@ void __init gpmc_init(void)
         gpmc_write_reg(GPMC_SYSCONFIG, l);
         gpmc_mem_init();
 }
+
+#ifdef CONFIG_ARCH_OMAP3
+static struct omap3_gpmc_regs gpmc_context;
+
+void omap3_gpmc_save_context()
+{
+        int i;
+        gpmc_context.sysconfig = gpmc_read_reg(GPMC_SYSCONFIG);
+        gpmc_context.irqenable = gpmc_read_reg(GPMC_IRQENABLE);
+        gpmc_context.timeout_ctrl = gpmc_read_reg(GPMC_TIMEOUT_CONTROL);
+        gpmc_context.config = gpmc_read_reg(GPMC_CONFIG);
+        gpmc_context.prefetch_config1 = gpmc_read_reg(GPMC_PREFETCH_CONFIG1);
+        gpmc_context.prefetch_config2 = gpmc_read_reg(GPMC_PREFETCH_CONFIG2);
+        gpmc_context.prefetch_control = gpmc_read_reg(GPMC_PREFETCH_CONTROL);
+        for (i = 0; i < GPMC_CS_NUM; i++) {
+                gpmc_context.cs_context[i].is_valid = gpmc_cs_mem_enabled(i);
+                if (gpmc_context.cs_context[i].is_valid) {
+                        gpmc_context.cs_context[i].config1 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG1);
+                        gpmc_context.cs_context[i].config2 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG2);
+                        gpmc_context.cs_context[i].config3 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG3);
+                        gpmc_context.cs_context[i].config4 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG4);
+                        gpmc_context.cs_context[i].config5 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG5);
+                        gpmc_context.cs_context[i].config6 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG6);
+                        gpmc_context.cs_context[i].config7 =
+                                gpmc_cs_read_reg(i, GPMC_CS_CONFIG7);
+                }
+        }
+}
+
+void omap3_gpmc_restore_context()
+{
+        int i;
+        gpmc_write_reg(GPMC_SYSCONFIG, gpmc_context.sysconfig);
+        gpmc_write_reg(GPMC_IRQENABLE, gpmc_context.irqenable);
+        gpmc_write_reg(GPMC_TIMEOUT_CONTROL, gpmc_context.timeout_ctrl);
+        gpmc_write_reg(GPMC_CONFIG, gpmc_context.config);
+        gpmc_write_reg(GPMC_PREFETCH_CONFIG1, gpmc_context.prefetch_config1);
+        gpmc_write_reg(GPMC_PREFETCH_CONFIG2, gpmc_context.prefetch_config2);
+        gpmc_write_reg(GPMC_PREFETCH_CONTROL, gpmc_context.prefetch_control);
+        for (i = 0; i < GPMC_CS_NUM; i++) {
+                if (gpmc_context.cs_context[i].is_valid) {
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG1,
+                                gpmc_context.cs_context[i].config1);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG2,
+                                gpmc_context.cs_context[i].config2);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG3,
+                                gpmc_context.cs_context[i].config3);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG4,
+                                gpmc_context.cs_context[i].config4);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG5,
+                                gpmc_context.cs_context[i].config5);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG6,
+                                gpmc_context.cs_context[i].config6);
+                        gpmc_cs_write_reg(i, GPMC_CS_CONFIG7,
+                                gpmc_context.cs_context[i].config7);
+                }
+        }
+}
+#endif /* CONFIG_ARCH_OMAP3 */
diff --git a/arch/arm/mach-omap2/id.c b/arch/arm/mach-omap2/id.c
index a98201cc265c..f48a4b2654dd 100644
--- a/arch/arm/mach-omap2/id.c
+++ b/arch/arm/mach-omap2/id.c
@@ -21,13 +21,14 @@
 
 #include <asm/cputype.h>
 
-#include <mach/common.h>
-#include <mach/control.h>
-#include <mach/cpu.h>
+#include <plat/common.h>
+#include <plat/control.h>
+#include <plat/cpu.h>
 
 static struct omap_chip_id omap_chip;
 static unsigned int omap_revision;
 
+u32 omap3_features;
 
 unsigned int omap_rev(void)
 {
@@ -52,11 +53,11 @@ int omap_type(void)
 {
         u32 val = 0;
 
-        if (cpu_is_omap24xx())
+        if (cpu_is_omap24xx()) {
                 val = omap_ctrl_readl(OMAP24XX_CONTROL_STATUS);
-        else if (cpu_is_omap34xx())
+        } else if (cpu_is_omap34xx()) {
                 val = omap_ctrl_readl(OMAP343X_CONTROL_STATUS);
-        else {
+        } else {
                 pr_err("Cannot detect omap type!\n");
                 goto out;
         }
@@ -155,12 +156,37 @@ void __init omap24xx_check_revision(void)
         pr_info("\n");
 }
 
-void __init omap34xx_check_revision(void)
+#define OMAP3_CHECK_FEATURE(status,feat)                                \
+        if (((status & OMAP3_ ##feat## _MASK)                           \
+                >> OMAP3_ ##feat## _SHIFT) != FEAT_ ##feat## _NONE) {   \
+                omap3_features |= OMAP3_HAS_ ##feat;                    \
+        }
+
+void __init omap3_check_features(void)
+{
+        u32 status;
+
+        omap3_features = 0;
+
+        status = omap_ctrl_readl(OMAP3_CONTROL_OMAP_STATUS);
+
+        OMAP3_CHECK_FEATURE(status, L2CACHE);
+        OMAP3_CHECK_FEATURE(status, IVA);
+        OMAP3_CHECK_FEATURE(status, SGX);
+        OMAP3_CHECK_FEATURE(status, NEON);
+        OMAP3_CHECK_FEATURE(status, ISP);
+
+        /*
+         * TODO: Get additional info (where applicable)
+         *       e.g. Size of L2 cache.
+         */
+}
+
+void __init omap3_check_revision(void)
 {
         u32 cpuid, idcode;
         u16 hawkeye;
         u8 rev;
-        char *rev_name = "ES1.0";
 
         /*
          * We cannot access revision registers on ES1.0.
@@ -170,7 +196,7 @@ void __init omap34xx_check_revision(void)
         cpuid = read_cpuid(CPUID_ID);
         if ((((cpuid >> 4) & 0xfff) == 0xc08) && ((cpuid & 0xf) == 0x0)) {
                 omap_revision = OMAP3430_REV_ES1_0;
-                goto out;
+                return;
         }
 
         /*
@@ -183,33 +209,115 @@ void __init omap34xx_check_revision(void)
         hawkeye = (idcode >> 12) & 0xffff;
         rev = (idcode >> 28) & 0xff;
 
-        if (hawkeye == 0xb7ae) {
+        switch (hawkeye) {
+        case 0xb7ae:
+                /* Handle 34xx/35xx devices */
                 switch (rev) {
-                case 0:
+                case 0: /* Take care of early samples */
+                case 1:
                         omap_revision = OMAP3430_REV_ES2_0;
-                        rev_name = "ES2.0";
                         break;
                 case 2:
                         omap_revision = OMAP3430_REV_ES2_1;
-                        rev_name = "ES2.1";
                         break;
                 case 3:
                         omap_revision = OMAP3430_REV_ES3_0;
-                        rev_name = "ES3.0";
                         break;
                 case 4:
-                        omap_revision = OMAP3430_REV_ES3_1;
-                        rev_name = "ES3.1";
-                        break;
+                /* FALLTHROUGH */
                 default:
                         /* Use the latest known revision as default */
                         omap_revision = OMAP3430_REV_ES3_1;
-                        rev_name = "Unknown revision\n";
                 }
+                break;
+        case 0xb868:
+                /* Handle OMAP35xx/AM35xx devices
+                 *
+                 * Set the device to be OMAP3505 here. Actual device
+                 * is identified later based on the features.
+                 */
+                omap_revision = OMAP3505_REV(rev);
+                break;
+        case 0xb891:
+        /* FALLTHROUGH */
+        default:
+                /* Unknown default to latest silicon rev as default*/
+                omap_revision = OMAP3630_REV_ES1_0;
         }
+}
 
-out:
-        pr_info("OMAP%04x %s\n", omap_rev() >> 16, rev_name);
+#define OMAP3_SHOW_FEATURE(feat)                \
+        if (omap3_has_ ##feat())                \
+                printk(#feat" ");
+
+void __init omap3_cpuinfo(void)
+{
+        u8 rev = GET_OMAP_REVISION();
+        char cpu_name[16], cpu_rev[16];
+
+        /* OMAP3430 and OMAP3530 are assumed to be same.
+         *
+         * OMAP3525, OMAP3515 and OMAP3503 can be detected only based
+         * on available features. Upon detection, update the CPU id
+         * and CPU class bits.
+         */
+        if (cpu_is_omap3630()) {
+                strcpy(cpu_name, "OMAP3630");
+        } else if (cpu_is_omap3505()) {
+                /*
+                 * AM35xx devices
+                 */
+                if (omap3_has_sgx()) {
+                        omap_revision = OMAP3517_REV(rev);
+                        strcpy(cpu_name, "AM3517");
+                } else {
+                        /* Already set in omap3_check_revision() */
+                        strcpy(cpu_name, "AM3505");
+                }
+        } else if (omap3_has_iva() && omap3_has_sgx()) {
+                /* OMAP3430, OMAP3525, OMAP3515, OMAP3503 devices */
+                strcpy(cpu_name, "OMAP3430/3530");
+        } else if (omap3_has_sgx()) {
+                omap_revision = OMAP3525_REV(rev);
+                strcpy(cpu_name, "OMAP3525");
+        } else if (omap3_has_iva()) {
+                omap_revision = OMAP3515_REV(rev);
+                strcpy(cpu_name, "OMAP3515");
+        } else {
+                omap_revision = OMAP3503_REV(rev);
+                strcpy(cpu_name, "OMAP3503");
+        }
+
+        switch (rev) {
+        case OMAP_REVBITS_00:
+                strcpy(cpu_rev, "1.0");
+                break;
+        case OMAP_REVBITS_10:
+                strcpy(cpu_rev, "2.0");
+                break;
+        case OMAP_REVBITS_20:
+                strcpy(cpu_rev, "2.1");
+                break;
+        case OMAP_REVBITS_30:
+                strcpy(cpu_rev, "3.0");
+                break;
+        case OMAP_REVBITS_40:
+        /* FALLTHROUGH */
+        default:
+                /* Use the latest known revision as default */
+                strcpy(cpu_rev, "3.1");
+        }
+
+        /* Print verbose information */
+        pr_info("%s ES%s (", cpu_name, cpu_rev);
+
+        OMAP3_SHOW_FEATURE(l2cache);
+        OMAP3_SHOW_FEATURE(iva);
+        OMAP3_SHOW_FEATURE(sgx);
+        OMAP3_SHOW_FEATURE(neon);
+        OMAP3_SHOW_FEATURE(isp);
+
+        printk(")\n");
 }
 
 /*
@@ -221,15 +329,18 @@ void __init omap2_check_revision(void)
          * At this point we have an idea about the processor revision set
          * earlier with omap2_set_globals_tap().
          */
-        if (cpu_is_omap24xx())
+        if (cpu_is_omap24xx()) {
                 omap24xx_check_revision();
-        else if (cpu_is_omap34xx())
-                omap34xx_check_revision();
-        else if (cpu_is_omap44xx()) {
+        } else if (cpu_is_omap34xx()) {
+                omap3_check_revision();
+                omap3_check_features();
+                omap3_cpuinfo();
+        } else if (cpu_is_omap44xx()) {
                 printk(KERN_INFO "FIXME: CPU revision = OMAP4430\n");
                 return;
-        } else
+        } else {
                 pr_err("OMAP revision unknown, please fix!\n");
+        }
 
         /*
          * OK, now we know the exact revision. Initialize omap_chip bits
@@ -241,6 +352,8 @@ void __init omap2_check_revision(void)
         } else if (cpu_is_omap242x()) {
                 /* Currently only supports 2420ES2.1.1 and 2420-all */
                 omap_chip.oc |= CHIP_IS_OMAP2420;
+        } else if (cpu_is_omap3505() || cpu_is_omap3517()) {
+                omap_chip.oc = CHIP_IS_OMAP3430 | CHIP_IS_OMAP3430ES3_1;
         } else if (cpu_is_omap343x()) {
                 omap_chip.oc = CHIP_IS_OMAP3430;
                 if (omap_rev() == OMAP3430_REV_ES1_0)
@@ -252,6 +365,8 @@ void __init omap2_check_revision(void)
                         omap_chip.oc |= CHIP_IS_OMAP3430ES3_0;
                 else if (omap_rev() == OMAP3430_REV_ES3_1)
                         omap_chip.oc |= CHIP_IS_OMAP3430ES3_1;
+                else if (omap_rev() == OMAP3630_REV_ES1_0)
+                        omap_chip.oc |= CHIP_IS_OMAP3630ES1;
         } else {
                 pr_err("Uninitialized omap_chip, please fix!\n");
         }
diff --git a/arch/arm/mach-omap2/include/mach/board-zoom.h b/arch/arm/mach-omap2/include/mach/board-zoom.h
new file mode 100644
index 000000000000..c93b29e21b78
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/board-zoom.h
@@ -0,0 +1,5 @@
+/*
+ * Defines for zoom boards
+ */
+extern int __init zoom_debugboard_init(void);
+extern void __init zoom_peripherals_init(void);
diff --git a/arch/arm/mach-omap2/include/mach/clkdev.h b/arch/arm/mach-omap2/include/mach/clkdev.h
new file mode 100644
index 000000000000..53b027441c56
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/clkdev.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/clkdev.h
+ */
+
+#include <plat/clkdev.h>
diff --git a/arch/arm/mach-omap2/include/mach/debug-macro.S b/arch/arm/mach-omap2/include/mach/debug-macro.S
new file mode 100644
index 000000000000..e9f255df9163
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/debug-macro.S
@@ -0,0 +1,59 @@
+/* arch/arm/mach-omap2/include/mach/debug-macro.S
+ *
+ * Debugging macro include header
+ *
+ *  Copyright (C) 1994-1999 Russell King
+ *  Moved from linux/arch/arm/kernel/debug.S by Ben Dooks
+ *
+ * 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.
+ *
+*/
+
+                .macro  addruart,rx
+                mrc     p15, 0, \rx, c1, c0
+                tst     \rx, #1                 @ MMU enabled?
+#ifdef  CONFIG_ARCH_OMAP2
+                moveq   \rx, #0x48000000        @ physical base address
+                movne   \rx, #0xfa000000        @ virtual base
+                orr     \rx, \rx, #0x0006a000
+#ifdef CONFIG_OMAP_LL_DEBUG_UART2
+                add     \rx, \rx, #0x00002000   @ UART 2
+#endif
+#ifdef CONFIG_OMAP_LL_DEBUG_UART3
+                add     \rx, \rx, #0x00004000   @ UART 3
+#endif
+
+#elif defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_ARCH_OMAP4)
+                moveq   \rx, #0x48000000        @ physical base address
+                movne   \rx, #0xfa000000        @ virtual base
+                orr     \rx, \rx, #0x0006a000
+#ifdef CONFIG_OMAP_LL_DEBUG_UART2
+                add     \rx, \rx, #0x00002000   @ UART 2
+#endif
+#ifdef CONFIG_OMAP_LL_DEBUG_UART3
+                add     \rx, \rx, #0x00fb0000   @ UART 3
+                add     \rx, \rx, #0x00006000
+#endif
+#endif
+                .endm
+
+                .macro  senduart,rd,rx
+                strb    \rd, [\rx]
+                .endm
+
+                .macro  busyuart,rd,rx
+1001:           ldrb    \rd, [\rx, #(0x5 << 2)] @ OMAP-1510 and friends
+                and     \rd, \rd, #0x60
+                teq     \rd, #0x60
+                beq     1002f
+                ldrb    \rd, [\rx, #(0x5 << 0)] @ OMAP-730 only
+                and     \rd, \rd, #0x60
+                teq     \rd, #0x60
+                bne     1001b
+1002:
+                .endm
+
+                .macro  waituart,rd,rx
+                .endm
diff --git a/arch/arm/mach-omap2/include/mach/entry-macro.S b/arch/arm/mach-omap2/include/mach/entry-macro.S
new file mode 100644
index 000000000000..c7f1720bf282
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/entry-macro.S
@@ -0,0 +1,124 @@
+/*
+ * arch/arm/plat-omap/include/mach/entry-macro.S
+ *
+ * Low-level IRQ helper macros for OMAP-based platforms
+ *
+ * Copyright (C) 2009 Texas Instruments
+ * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
+ *
+ * This file is licensed under  the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+#include <mach/hardware.h>
+#include <mach/io.h>
+#include <mach/irqs.h>
+#include <asm/hardware/gic.h>
+
+#include <plat/omap24xx.h>
+#include <plat/omap34xx.h>
+
+/* REVISIT: This should be set dynamically if CONFIG_MULTI_OMAP2 is selected */
+#if defined(CONFIG_ARCH_OMAP2420) || defined(CONFIG_ARCH_OMAP2430)
+#define OMAP2_VA_IC_BASE                OMAP2_L4_IO_ADDRESS(OMAP24XX_IC_BASE)
+#elif defined(CONFIG_ARCH_OMAP34XX)
+#define OMAP2_VA_IC_BASE                OMAP2_L4_IO_ADDRESS(OMAP34XX_IC_BASE)
+#endif
+#if defined(CONFIG_ARCH_OMAP4)
+#include <plat/omap44xx.h>
+#endif
+#define INTCPS_SIR_IRQ_OFFSET   0x0040          /* Active interrupt offset */
+#define ACTIVEIRQ_MASK          0x7f            /* Active interrupt bits */
+
+                .macro  disable_fiq
+                .endm
+
+                .macro  get_irqnr_preamble, base, tmp
+                .endm
+
+                .macro  arch_ret_to_user, tmp1, tmp2
+                .endm
+
+#ifndef CONFIG_ARCH_OMAP4
+                .macro  get_irqnr_and_base, irqnr, irqstat, base, tmp
+                ldr     \base, =OMAP2_VA_IC_BASE
+                ldr     \irqnr, [\base, #0x98] /* IRQ pending reg 1 */
+                cmp     \irqnr, #0x0
+                bne     2222f
+                ldr     \irqnr, [\base, #0xb8] /* IRQ pending reg 2 */
+                cmp     \irqnr, #0x0
+                bne     2222f
+                ldr     \irqnr, [\base, #0xd8] /* IRQ pending reg 3 */
+                cmp     \irqnr, #0x0
+2222:
+                ldrne   \irqnr, [\base, #INTCPS_SIR_IRQ_OFFSET]
+                and     \irqnr, \irqnr, #ACTIVEIRQ_MASK /* Clear spurious bits */
+
+                .endm
+#else
+#define OMAP44XX_VA_GIC_CPU_BASE        OMAP2_L4_IO_ADDRESS(OMAP44XX_GIC_CPU_BASE)
+
+                /*
+                 * The interrupt numbering scheme is defined in the
+                 * interrupt controller spec.  To wit:
+                 *
+                 * Interrupts 0-15 are IPI
+                 * 16-28 are reserved
+                 * 29-31 are local.  We allow 30 to be used for the watchdog.
+                 * 32-1020 are global
+                 * 1021-1022 are reserved
+                 * 1023 is "spurious" (no interrupt)
+                 *
+                 * For now, we ignore all local interrupts so only return an
+                 * interrupt if it's between 30 and 1020.  The test_for_ipi
+                 * routine below will pick up on IPIs.
+                 * A simple read from the controller will tell us the number
+                 * of the highest priority enabled interrupt.
+                 * We then just need to check whether it is in the
+                 * valid range for an IRQ (30-1020 inclusive).
+                 */
+                .macro  get_irqnr_and_base, irqnr, irqstat, base, tmp
+                ldr     \base, =OMAP44XX_VA_GIC_CPU_BASE
+                ldr     \irqstat, [\base, #GIC_CPU_INTACK]
+
+                ldr     \tmp, =1021
+
+                bic     \irqnr, \irqstat, #0x1c00
+
+                cmp     \irqnr, #29
+                cmpcc   \irqnr, \irqnr
+                cmpne   \irqnr, \tmp
+                cmpcs   \irqnr, \irqnr
+                .endm
+
+                /* We assume that irqstat (the raw value of the IRQ acknowledge
+                 * register) is preserved from the macro above.
+                 * If there is an IPI, we immediately signal end of interrupt
+                 * on the controller, since this requires the original irqstat
+                 * value which we won't easily be able to recreate later.
+                 */
+
+                .macro test_for_ipi, irqnr, irqstat, base, tmp
+                bic     \irqnr, \irqstat, #0x1c00
+                cmp     \irqnr, #16
+                it      cc
+                strcc   \irqstat, [\base, #GIC_CPU_EOI]
+                it      cs
+                cmpcs   \irqnr, \irqnr
+                .endm
+
+                /* As above, this assumes that irqstat and base are preserved */
+
+                .macro test_for_ltirq, irqnr, irqstat, base, tmp
+                bic     \irqnr, \irqstat, #0x1c00
+                mov     \tmp, #0
+                cmp     \irqnr, #29
+                itt     eq
+                moveq   \tmp, #1
+                streq   \irqstat, [\base, #GIC_CPU_EOI]
+                cmp     \tmp, #0
+                .endm
+#endif
+
+                .macro  irq_prio_table
+                .endm
diff --git a/arch/arm/mach-omap2/include/mach/gpio.h b/arch/arm/mach-omap2/include/mach/gpio.h
new file mode 100644
index 000000000000..be4d290d57ee
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/gpio.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/gpio.h
+ */
+
+#include <plat/gpio.h>
diff --git a/arch/arm/mach-omap2/include/mach/hardware.h b/arch/arm/mach-omap2/include/mach/hardware.h
new file mode 100644
index 000000000000..78edf9d33f71
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/hardware.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/hardware.h
+ */
+
+#include <plat/hardware.h>
diff --git a/arch/arm/mach-omap2/include/mach/io.h b/arch/arm/mach-omap2/include/mach/io.h
new file mode 100644
index 000000000000..fd78f31aa1ad
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/io.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/io.h
+ */
+
+#include <plat/io.h>
diff --git a/arch/arm/mach-omap2/include/mach/irqs.h b/arch/arm/mach-omap2/include/mach/irqs.h
new file mode 100644
index 000000000000..44dab7725696
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/irqs.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/irqs.h
+ */
+
+#include <plat/irqs.h>
diff --git a/arch/arm/mach-omap2/include/mach/memory.h b/arch/arm/mach-omap2/include/mach/memory.h
new file mode 100644
index 000000000000..ca6d32a917dd
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/memory.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/memory.h
+ */
+
+#include <plat/memory.h>
diff --git a/arch/arm/mach-omap2/include/mach/smp.h b/arch/arm/mach-omap2/include/mach/smp.h
new file mode 100644
index 000000000000..323675f21b69
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/smp.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/smp.h
+ */
+
+#include <plat/smp.h>
diff --git a/arch/arm/mach-omap2/include/mach/system.h b/arch/arm/mach-omap2/include/mach/system.h
new file mode 100644
index 000000000000..d488721ab90b
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/system.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/system.h
+ */
+
+#include <plat/system.h>
diff --git a/arch/arm/mach-omap2/include/mach/timex.h b/arch/arm/mach-omap2/include/mach/timex.h
new file mode 100644
index 000000000000..de9f8fc40e7c
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/timex.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/timex.h
+ */
+
+#include <plat/timex.h>
diff --git a/arch/arm/mach-omap2/include/mach/uncompress.h b/arch/arm/mach-omap2/include/mach/uncompress.h
new file mode 100644
index 000000000000..78e0557bfd4e
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/uncompress.h
@@ -0,0 +1,5 @@
+/*
+ * arch/arm/mach-omap2/include/mach/uncompress.h
+ */
+
+#include <plat/uncompress.h>
diff --git a/arch/arm/mach-omap2/include/mach/vmalloc.h b/arch/arm/mach-omap2/include/mach/vmalloc.h
new file mode 100644
index 000000000000..9ce9b6e8ad23
--- /dev/null
+++ b/arch/arm/mach-omap2/include/mach/vmalloc.h
@@ -0,0 +1,20 @@
+/*
+ *  arch/arm/plat-omap/include/mach/vmalloc.h
+ *
+ *  Copyright (C) 2000 Russell King.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#define VMALLOC_END       (PAGE_OFFSET + 0x38000000)
diff --git a/arch/arm/mach-omap2/io.c b/arch/arm/mach-omap2/io.c
index e3a3bad1d84f..59d28b2fd8c5 100644
--- a/arch/arm/mach-omap2/io.c
+++ b/arch/arm/mach-omap2/io.c
@@ -27,24 +27,24 @@
 
 #include <asm/mach/map.h>
 
-#include <mach/mux.h>
-#include <mach/omapfb.h>
-#include <mach/sram.h>
-#include <mach/sdrc.h>
-#include <mach/gpmc.h>
-#include <mach/serial.h>
+#include <plat/mux.h>
+#include <plat/omapfb.h>
+#include <plat/sram.h>
+#include <plat/sdrc.h>
+#include <plat/gpmc.h>
+#include <plat/serial.h>
 
 #ifndef CONFIG_ARCH_OMAP4       /* FIXME: Remove this once clkdev is ready */
 #include "clock.h"
 
-#include <mach/omap-pm.h>
-#include <mach/powerdomain.h>
+#include <plat/omap-pm.h>
+#include <plat/powerdomain.h>
 #include "powerdomains.h"
 
-#include <mach/clockdomain.h>
+#include <plat/clockdomain.h>
 #include "clockdomains.h"
 #endif
-#include <mach/omap_hwmod.h>
+#include <plat/omap_hwmod.h>
 #include "omap_hwmod_2420.h"
 #include "omap_hwmod_2430.h"
 #include "omap_hwmod_34xx.h"
@@ -203,6 +203,24 @@ static struct map_desc omap44xx_io_desc[] __initdata = {
                 .type           = MT_DEVICE,
         },
         {
+                .virtual        = OMAP44XX_EMIF1_VIRT,
+                .pfn            = __phys_to_pfn(OMAP44XX_EMIF1_PHYS),
+                .length         = OMAP44XX_EMIF1_SIZE,
+                .type           = MT_DEVICE,
+        },
+        {
+                .virtual        = OMAP44XX_EMIF2_VIRT,
+                .pfn            = __phys_to_pfn(OMAP44XX_EMIF2_PHYS),
+                .length         = OMAP44XX_EMIF2_SIZE,
+                .type           = MT_DEVICE,
+        },
+        {
+                .virtual        = OMAP44XX_DMM_VIRT,
+                .pfn            = __phys_to_pfn(OMAP44XX_DMM_PHYS),
+                .length         = OMAP44XX_DMM_SIZE,
+                .type           = MT_DEVICE,
+        },
+        {
                 .virtual        = L4_PER_44XX_VIRT,
                 .pfn            = __phys_to_pfn(L4_PER_44XX_PHYS),
                 .length         = L4_PER_44XX_SIZE,
@@ -302,7 +320,9 @@ void __init omap2_init_common_hw(struct omap_sdrc_params *sdrc_cs0,
         pwrdm_init(powerdomains_omap);
         clkdm_init(clockdomains_omap, clkdm_pwrdm_autodeps);
         omap2_clk_init();
+#endif
         omap_serial_early_init();
+#ifndef CONFIG_ARCH_OMAP4
         omap_hwmod_late_init();
         omap_pm_if_init();
         omap2_sdrc_init(sdrc_cs0, sdrc_cs1);
diff --git a/arch/arm/mach-omap2/iommu2.c b/arch/arm/mach-omap2/iommu2.c
index 4a0e1cd5c1f4..6f4b7cc8f4d1 100644
--- a/arch/arm/mach-omap2/iommu2.c
+++ b/arch/arm/mach-omap2/iommu2.c
@@ -17,7 +17,7 @@
 #include <linux/module.h>
 #include <linux/stringify.h>
 
-#include <mach/iommu.h>
+#include <plat/iommu.h>
 
 /*
  * omap2 architecture specific register bit definitions
diff --git a/arch/arm/mach-omap2/irq.c b/arch/arm/mach-omap2/irq.c
index b82863887f10..e9bc782fa414 100644
--- a/arch/arm/mach-omap2/irq.c
+++ b/arch/arm/mach-omap2/irq.c
@@ -25,6 +25,10 @@
 #define INTC_SYSSTATUS          0x0014
 #define INTC_SIR                0x0040
 #define INTC_CONTROL            0x0048
+#define INTC_PROTECTION         0x004C
+#define INTC_IDLE               0x0050
+#define INTC_THRESHOLD          0x0068
+#define INTC_MIR0               0x0084
 #define INTC_MIR_CLEAR0         0x0088
 #define INTC_MIR_SET0           0x008c
 #define INTC_PENDING_IRQ0       0x0098
@@ -48,6 +52,18 @@ static struct omap_irq_bank {
         },
 };
 
+/* Structure to save interrupt controller context */
+struct omap3_intc_regs {
+        u32 sysconfig;
+        u32 protection;
+        u32 idle;
+        u32 threshold;
+        u32 ilr[INTCPS_NR_IRQS];
+        u32 mir[INTCPS_NR_MIR_REGS];
+};
+
+static struct omap3_intc_regs intc_context[ARRAY_SIZE(irq_banks)];
+
 /* INTC bank register get/set */
 
 static void intc_bank_write_reg(u32 val, struct omap_irq_bank *bank, u16 reg)
@@ -178,12 +194,20 @@ void __init omap_init_irq(void)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(irq_banks); i++) {
+                unsigned long base;
                 struct omap_irq_bank *bank = irq_banks + i;
 
                 if (cpu_is_omap24xx())
-                        bank->base_reg = OMAP2_IO_ADDRESS(OMAP24XX_IC_BASE);
+                        base = OMAP24XX_IC_BASE;
                 else if (cpu_is_omap34xx())
-                        bank->base_reg = OMAP2_IO_ADDRESS(OMAP34XX_IC_BASE);
+                        base = OMAP34XX_IC_BASE;
+
+                /* Static mapping, never released */
+                bank->base_reg = ioremap(base, SZ_4K);
+                if (!bank->base_reg) {
+                        printk(KERN_ERR "Could not ioremap irq bank%i\n", i);
+                        continue;
+                }
 
                 omap_irq_bank_init_one(bank);
 
@@ -201,3 +225,53 @@ void __init omap_init_irq(void)
         }
 }
 
+#ifdef CONFIG_ARCH_OMAP3
+void omap_intc_save_context(void)
+{
+        int ind = 0, i = 0;
+        for (ind = 0; ind < ARRAY_SIZE(irq_banks); ind++) {
+                struct omap_irq_bank *bank = irq_banks + ind;
+                intc_context[ind].sysconfig =
+                        intc_bank_read_reg(bank, INTC_SYSCONFIG);
+                intc_context[ind].protection =
+                        intc_bank_read_reg(bank, INTC_PROTECTION);
+                intc_context[ind].idle =
+                        intc_bank_read_reg(bank, INTC_IDLE);
+                intc_context[ind].threshold =
+                        intc_bank_read_reg(bank, INTC_THRESHOLD);
+                for (i = 0; i < INTCPS_NR_IRQS; i++)
+                        intc_context[ind].ilr[i] =
+                                intc_bank_read_reg(bank, (0x100 + 0x4*i));
+                for (i = 0; i < INTCPS_NR_MIR_REGS; i++)
+                        intc_context[ind].mir[i] =
+                                intc_bank_read_reg(&irq_banks[0], INTC_MIR0 +
+                                (0x20 * i));
+        }
+}
+
+void omap_intc_restore_context(void)
+{
+        int ind = 0, i = 0;
+
+        for (ind = 0; ind < ARRAY_SIZE(irq_banks); ind++) {
+                struct omap_irq_bank *bank = irq_banks + ind;
+                intc_bank_write_reg(intc_context[ind].sysconfig,
+                                        bank, INTC_SYSCONFIG);
+                intc_bank_write_reg(intc_context[ind].sysconfig,
+                                        bank, INTC_SYSCONFIG);
+                intc_bank_write_reg(intc_context[ind].protection,
+                                        bank, INTC_PROTECTION);
+                intc_bank_write_reg(intc_context[ind].idle,
+                                        bank, INTC_IDLE);
+                intc_bank_write_reg(intc_context[ind].threshold,
+                                        bank, INTC_THRESHOLD);
+                for (i = 0; i < INTCPS_NR_IRQS; i++)
+                        intc_bank_write_reg(intc_context[ind].ilr[i],
+                                bank, (0x100 + 0x4*i));
+                for (i = 0; i < INTCPS_NR_MIR_REGS; i++)
+                        intc_bank_write_reg(intc_context[ind].mir[i],
+                                 &irq_banks[0], INTC_MIR0 + (0x20 * i));
+        }
+        /* MIRs are saved and restore with other PRCM registers */
+}
+#endif /* CONFIG_ARCH_OMAP3 */
diff --git a/arch/arm/mach-omap2/mailbox.c b/arch/arm/mach-omap2/mailbox.c
index c035ad3426d0..281ab6342448 100644
--- a/arch/arm/mach-omap2/mailbox.c
+++ b/arch/arm/mach-omap2/mailbox.c
@@ -15,9 +15,11 @@
 #include <linux/err.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
-#include <mach/mailbox.h>
+#include <plat/mailbox.h>
 #include <mach/irqs.h>
 
+#define DRV_NAME "omap2-mailbox"
+
 #define MAILBOX_REVISION                0x000
 #define MAILBOX_SYSCONFIG               0x010
 #define MAILBOX_SYSSTATUS               0x014
@@ -27,8 +29,12 @@
 #define MAILBOX_IRQSTATUS(u)            (0x100 + 8 * (u))
 #define MAILBOX_IRQENABLE(u)            (0x104 + 8 * (u))
 
-#define MAILBOX_IRQ_NEWMSG(u)           (1 << (2 * (u)))
-#define MAILBOX_IRQ_NOTFULL(u)          (1 << (2 * (u) + 1))
+#define OMAP4_MAILBOX_IRQSTATUS(u)      (0x104 + 10 * (u))
+#define OMAP4_MAILBOX_IRQENABLE(u)      (0x108 + 10 * (u))
+#define OMAP4_MAILBOX_IRQENABLE_CLR(u)  (0x10c + 10 * (u))
+
+#define MAILBOX_IRQ_NEWMSG(m)           (1 << (2 * (m)))
+#define MAILBOX_IRQ_NOTFULL(m)          (1 << (2 * (m) + 1))
 
 /* SYSCONFIG: register bit definition */
 #define AUTOIDLE        (1 << 0)
@@ -39,7 +45,11 @@
 #define RESETDONE       (1 << 0)
 
 #define MBOX_REG_SIZE                   0x120
+
+#define OMAP4_MBOX_REG_SIZE             0x130
+
 #define MBOX_NR_REGS                    (MBOX_REG_SIZE / sizeof(u32))
+#define OMAP4_MBOX_NR_REGS              (OMAP4_MBOX_REG_SIZE / sizeof(u32))
 
 static void __iomem *mbox_base;
 
@@ -56,7 +66,8 @@ struct omap_mbox2_priv {
         unsigned long irqstatus;
         u32 newmsg_bit;
         u32 notfull_bit;
-        u32 ctx[MBOX_NR_REGS];
+        u32 ctx[OMAP4_MBOX_NR_REGS];
+        unsigned long irqdisable;
 };
 
 static struct clk *mbox_ick_handle;
@@ -82,8 +93,9 @@ static int omap2_mbox_startup(struct omap_mbox *mbox)
 
         mbox_ick_handle = clk_get(NULL, "mailboxes_ick");
         if (IS_ERR(mbox_ick_handle)) {
-                pr_err("Can't get mailboxes_ick\n");
-                return -ENODEV;
+                printk(KERN_ERR "Could not get mailboxes_ick: %d\n",
+                        PTR_ERR(mbox_ick_handle));
+                return PTR_ERR(mbox_ick_handle);
         }
         clk_enable(mbox_ick_handle);
 
@@ -115,6 +127,7 @@ static void omap2_mbox_shutdown(struct omap_mbox *mbox)
 {
         clk_disable(mbox_ick_handle);
         clk_put(mbox_ick_handle);
+        mbox_ick_handle = NULL;
 }
 
 /* Mailbox FIFO handle functions */
@@ -143,7 +156,7 @@ static int omap2_mbox_fifo_full(struct omap_mbox *mbox)
 {
         struct omap_mbox2_fifo *fifo =
                 &((struct omap_mbox2_priv *)mbox->priv)->tx_fifo;
-        return (mbox_read_reg(fifo->fifo_stat));
+        return mbox_read_reg(fifo->fifo_stat);
 }
 
 /* Mailbox IRQ handle functions */
@@ -163,10 +176,9 @@ static void omap2_mbox_disable_irq(struct omap_mbox *mbox,
 {
         struct omap_mbox2_priv *p = (struct omap_mbox2_priv *)mbox->priv;
         u32 l, bit = (irq == IRQ_TX) ? p->notfull_bit : p->newmsg_bit;
-
-        l = mbox_read_reg(p->irqenable);
+        l = mbox_read_reg(p->irqdisable);
         l &= ~bit;
-        mbox_write_reg(l, p->irqenable);
+        mbox_write_reg(l, p->irqdisable);
 }
 
 static void omap2_mbox_ack_irq(struct omap_mbox *mbox,
@@ -189,15 +201,19 @@ static int omap2_mbox_is_irq(struct omap_mbox *mbox,
         u32 enable = mbox_read_reg(p->irqenable);
         u32 status = mbox_read_reg(p->irqstatus);
 
-        return (enable & status & bit);
+        return (int)(enable & status & bit);
 }
 
 static void omap2_mbox_save_ctx(struct omap_mbox *mbox)
 {
         int i;
         struct omap_mbox2_priv *p = mbox->priv;
-
-        for (i = 0; i < MBOX_NR_REGS; i++) {
+        int nr_regs;
+        if (cpu_is_omap44xx())
+                nr_regs = OMAP4_MBOX_NR_REGS;
+        else
+                nr_regs = MBOX_NR_REGS;
+        for (i = 0; i < nr_regs; i++) {
                 p->ctx[i] = mbox_read_reg(i * sizeof(u32));
 
                 dev_dbg(mbox->dev, "%s: [%02x] %08x\n", __func__,
@@ -209,8 +225,12 @@ static void omap2_mbox_restore_ctx(struct omap_mbox *mbox)
 {
         int i;
         struct omap_mbox2_priv *p = mbox->priv;
-
-        for (i = 0; i < MBOX_NR_REGS; i++) {
+        int nr_regs;
+        if (cpu_is_omap44xx())
+                nr_regs = OMAP4_MBOX_NR_REGS;
+        else
+                nr_regs = MBOX_NR_REGS;
+        for (i = 0; i < nr_regs; i++) {
                 mbox_write_reg(p->ctx[i], i * sizeof(u32));
 
                 dev_dbg(mbox->dev, "%s: [%02x] %08x\n", __func__,
@@ -242,7 +262,6 @@ static struct omap_mbox_ops omap2_mbox_ops = {
  */
 
 /* FIXME: the following structs should be filled automatically by the user id */
-
 /* DSP */
 static struct omap_mbox2_priv omap2_mbox_dsp_priv = {
         .tx_fifo = {
@@ -257,8 +276,36 @@ static struct omap_mbox2_priv omap2_mbox_dsp_priv = {
         .irqstatus      = MAILBOX_IRQSTATUS(0),
         .notfull_bit    = MAILBOX_IRQ_NOTFULL(0),
         .newmsg_bit     = MAILBOX_IRQ_NEWMSG(1),
+        .irqdisable     = MAILBOX_IRQENABLE(0),
+};
+
+
+
+/* OMAP4 specific data structure. Use the cpu_is_omap4xxx()
+to use this*/
+static struct omap_mbox2_priv omap2_mbox_1_priv = {
+        .tx_fifo = {
+                .msg            = MAILBOX_MESSAGE(0),
+                .fifo_stat      = MAILBOX_FIFOSTATUS(0),
+        },
+        .rx_fifo = {
+                .msg            = MAILBOX_MESSAGE(1),
+                .msg_stat       = MAILBOX_MSGSTATUS(1),
+        },
+        .irqenable      = OMAP4_MAILBOX_IRQENABLE(0),
+        .irqstatus      = OMAP4_MAILBOX_IRQSTATUS(0),
+        .notfull_bit    = MAILBOX_IRQ_NOTFULL(0),
+        .newmsg_bit     = MAILBOX_IRQ_NEWMSG(1),
+        .irqdisable     = OMAP4_MAILBOX_IRQENABLE_CLR(0),
 };
 
+struct omap_mbox mbox_1_info = {
+        .name   = "mailbox-1",
+        .ops    = &omap2_mbox_ops,
+        .priv   = &omap2_mbox_1_priv,
+};
+EXPORT_SYMBOL(mbox_1_info);
+
 struct omap_mbox mbox_dsp_info = {
         .name   = "dsp",
         .ops    = &omap2_mbox_ops,
@@ -266,6 +313,30 @@ struct omap_mbox mbox_dsp_info = {
 };
 EXPORT_SYMBOL(mbox_dsp_info);
 
+static struct omap_mbox2_priv omap2_mbox_2_priv = {
+        .tx_fifo = {
+                .msg            = MAILBOX_MESSAGE(3),
+                .fifo_stat      = MAILBOX_FIFOSTATUS(3),
+        },
+        .rx_fifo = {
+                .msg            = MAILBOX_MESSAGE(2),
+                .msg_stat       = MAILBOX_MSGSTATUS(2),
+        },
+        .irqenable      = OMAP4_MAILBOX_IRQENABLE(0),
+        .irqstatus      = OMAP4_MAILBOX_IRQSTATUS(0),
+        .notfull_bit    = MAILBOX_IRQ_NOTFULL(3),
+        .newmsg_bit     = MAILBOX_IRQ_NEWMSG(2),
+        .irqdisable     = OMAP4_MAILBOX_IRQENABLE_CLR(0),
+};
+
+struct omap_mbox mbox_2_info = {
+        .name   = "mailbox-2",
+        .ops    = &omap2_mbox_ops,
+        .priv   = &omap2_mbox_2_priv,
+};
+EXPORT_SYMBOL(mbox_2_info);
+
+
 #if defined(CONFIG_ARCH_OMAP2420) /* IVA */
 static struct omap_mbox2_priv omap2_mbox_iva_priv = {
         .tx_fifo = {
@@ -280,6 +351,7 @@ static struct omap_mbox2_priv omap2_mbox_iva_priv = {
         .irqstatus      = MAILBOX_IRQSTATUS(3),
         .notfull_bit    = MAILBOX_IRQ_NOTFULL(2),
         .newmsg_bit     = MAILBOX_IRQ_NEWMSG(3),
+        .irqdisable     = MAILBOX_IRQENABLE(3),
 };
 
 static struct omap_mbox mbox_iva_info = {
@@ -300,22 +372,36 @@ static int __devinit omap2_mbox_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "invalid mem resource\n");
                 return -ENODEV;
         }
-        mbox_base = ioremap(res->start, res->end - res->start);
+        mbox_base = ioremap(res->start, resource_size(res));
         if (!mbox_base)
                 return -ENOMEM;
 
         /* DSP or IVA2 IRQ */
-        ret = platform_get_irq(pdev, 0);
-        if (ret < 0) {
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+
+        if (unlikely(!res)) {
                 dev_err(&pdev->dev, "invalid irq resource\n");
+                ret = -ENODEV;
                 goto err_dsp;
         }
-        mbox_dsp_info.irq = ret;
-
-        ret = omap_mbox_register(&pdev->dev, &mbox_dsp_info);
+        if (cpu_is_omap44xx()) {
+                mbox_1_info.irq = res->start;
+                ret = omap_mbox_register(&pdev->dev, &mbox_1_info);
+        } else {
+                mbox_dsp_info.irq = res->start;
+                ret = omap_mbox_register(&pdev->dev, &mbox_dsp_info);
+        }
         if (ret)
                 goto err_dsp;
 
+        if (cpu_is_omap44xx()) {
+                mbox_2_info.irq = res->start;
+                ret = omap_mbox_register(&pdev->dev, &mbox_2_info);
+                if (ret) {
+                        omap_mbox_unregister(&mbox_1_info);
+                        goto err_dsp;
+                }
+        }
 #if defined(CONFIG_ARCH_OMAP2420) /* IVA */
         if (cpu_is_omap2420()) {
                 /* IVA IRQ */
@@ -335,6 +421,7 @@ static int __devinit omap2_mbox_probe(struct platform_device *pdev)
 
 err_iva1:
         omap_mbox_unregister(&mbox_dsp_info);
+
 err_dsp:
         iounmap(mbox_base);
         return ret;
@@ -345,7 +432,12 @@ static int __devexit omap2_mbox_remove(struct platform_device *pdev)
 #if defined(CONFIG_ARCH_OMAP2420)
         omap_mbox_unregister(&mbox_iva_info);
 #endif
-        omap_mbox_unregister(&mbox_dsp_info);
+
+        if (cpu_is_omap44xx()) {
+                omap_mbox_unregister(&mbox_2_info);
+                omap_mbox_unregister(&mbox_1_info);
+        } else
+                omap_mbox_unregister(&mbox_dsp_info);
         iounmap(mbox_base);
         return 0;
 }
@@ -354,7 +446,7 @@ static struct platform_driver omap2_mbox_driver = {
         .probe = omap2_mbox_probe,
         .remove = __devexit_p(omap2_mbox_remove),
         .driver = {
-                .name = "omap2-mailbox",
+                .name = DRV_NAME,
         },
 };
 
@@ -372,6 +464,6 @@ module_init(omap2_mbox_init);
 module_exit(omap2_mbox_exit);
 
 MODULE_LICENSE("GPL v2");
-MODULE_DESCRIPTION("omap mailbox: omap2/3 architecture specific functions");
+MODULE_DESCRIPTION("omap mailbox: omap2/3/4 architecture specific functions");
 MODULE_AUTHOR("Hiroshi DOYU <Hiroshi.DOYU@nokia.com>, Paul Mundt");
-MODULE_ALIAS("platform:omap2-mailbox");
+MODULE_ALIAS("platform:"DRV_NAME);
diff --git a/arch/arm/mach-omap2/mcbsp.c b/arch/arm/mach-omap2/mcbsp.c
index a846aa1ebb4d..baa451733850 100644
--- a/arch/arm/mach-omap2/mcbsp.c
+++ b/arch/arm/mach-omap2/mcbsp.c
@@ -18,10 +18,10 @@
 #include <linux/platform_device.h>
 
 #include <mach/irqs.h>
-#include <mach/dma.h>
-#include <mach/mux.h>
-#include <mach/cpu.h>
-#include <mach/mcbsp.h>
+#include <plat/dma.h>
+#include <plat/mux.h>
+#include <plat/cpu.h>
+#include <plat/mcbsp.h>
 
 static void omap2_mcbsp2_mux_setup(void)
 {
diff --git a/arch/arm/mach-omap2/mmc-twl4030.c b/arch/arm/mach-omap2/mmc-twl4030.c
index c9c59a2db4e2..0c3c72d934bf 100644
--- a/arch/arm/mach-omap2/mmc-twl4030.c
+++ b/arch/arm/mach-omap2/mmc-twl4030.c
@@ -20,9 +20,9 @@
 #include <linux/regulator/consumer.h>
 
 #include <mach/hardware.h>
-#include <mach/control.h>
-#include <mach/mmc.h>
-#include <mach/board.h>
+#include <plat/control.h>
+#include <plat/mmc.h>
+#include <plat/board.h>
 
 #include "mmc-twl4030.h"
 
@@ -213,7 +213,7 @@ static int twl4030_mmc_get_context_loss(struct device *dev)
 static int twl_mmc1_set_power(struct device *dev, int slot, int power_on,
                                 int vdd)
 {
-        u32 reg;
+        u32 reg, prog_io;
         int ret = 0;
         struct twl_mmc_controller *c = &hsmmc[0];
         struct omap_mmc_platform_data *mmc = dev->platform_data;
@@ -245,7 +245,14 @@ static int twl_mmc1_set_power(struct device *dev, int slot, int power_on,
                 }
 
                 reg = omap_ctrl_readl(control_pbias_offset);
-                reg |= OMAP2_PBIASSPEEDCTRL0;
+                if (cpu_is_omap3630()) {
+                        /* Set MMC I/O to 52Mhz */
+                        prog_io = omap_ctrl_readl(OMAP343X_CONTROL_PROG_IO1);
+                        prog_io |= OMAP3630_PRG_SDMMC1_SPEEDCTRL;
+                        omap_ctrl_writel(prog_io, OMAP343X_CONTROL_PROG_IO1);
+                } else {
+                        reg |= OMAP2_PBIASSPEEDCTRL0;
+                }
                 reg &= ~OMAP2_PBIASLITEPWRDNZ0;
                 omap_ctrl_writel(reg, control_pbias_offset);
 
@@ -489,6 +496,12 @@ void __init twl4030_mmc_init(struct twl4030_hsmmc_info *controllers)
                         /* on-chip level shifting via PBIAS0/PBIAS1 */
                         mmc->slots[0].set_power = twl_mmc1_set_power;
                         mmc->slots[0].set_sleep = twl_mmc1_set_sleep;
+
+                        /* Omap3630 HSMMC1 supports only 4-bit */
+                        if (cpu_is_omap3630() && c->wires > 4) {
+                                c->wires = 4;
+                                mmc->slots[0].wires = c->wires;
+                        }
                         break;
                 case 2:
                         if (c->ext_clock)
diff --git a/arch/arm/mach-omap2/mux.c b/arch/arm/mach-omap2/mux.c
index b5fac32aae70..c18a94eca641 100644
--- a/arch/arm/mach-omap2/mux.c
+++ b/arch/arm/mach-omap2/mux.c
@@ -30,8 +30,8 @@
 
 #include <asm/system.h>
 
-#include <mach/control.h>
-#include <mach/mux.h>
+#include <plat/control.h>
+#include <plat/mux.h>
 
 #ifdef CONFIG_OMAP_MUX
 
@@ -532,6 +532,14 @@ MUX_CFG_34XX("AG4_3430_MMC2_DAT2", 0x160,
                 OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP)
 MUX_CFG_34XX("AF4_3430_MMC2_DAT3", 0x162,
                 OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP)
+MUX_CFG_34XX("AE4_3430_MMC2_DAT4", 0x164,
+                OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP)
+MUX_CFG_34XX("AH3_3430_MMC2_DAT5", 0x166,
+                OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP)
+MUX_CFG_34XX("AF3_3430_MMC2_DAT6", 0x168,
+                OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP)
+MUX_CFG_34XX("AE3_3430_MMC2_DAT7", 0x16A,
+                OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP)
 
 /* MMC3 */
 MUX_CFG_34XX("AF10_3430_MMC3_CLK", 0x5d8,
@@ -551,6 +559,13 @@ MUX_CFG_34XX("AF13_3430_MMC3_DAT3", 0x5e2,
 MUX_CFG_34XX("AF26_34XX_SYS_NIRQ", 0x1E0,
                 OMAP3_WAKEUP_EN | OMAP34XX_PIN_INPUT_PULLUP |
                 OMAP34XX_MUX_MODE0)
+/* EHCI GPIO's on OMAP3EVM (Rev >= E) */
+MUX_CFG_34XX("AH14_34XX_GPIO21", 0x5ea,
+        OMAP34XX_MUX_MODE4 | OMAP34XX_PIN_INPUT_PULLUP)
+MUX_CFG_34XX("AF9_34XX_GPIO22", 0x5ec,
+        OMAP34XX_MUX_MODE4 | OMAP34XX_PIN_INPUT_PULLUP)
+MUX_CFG_34XX("U3_34XX_GPIO61", 0x0c8,
+        OMAP34XX_MUX_MODE4 | OMAP34XX_PIN_INPUT_PULLUP)
 };
 
 #define OMAP34XX_PINS_SZ        ARRAY_SIZE(omap34xx_pins)
diff --git a/arch/arm/mach-omap2/omap-smp.c b/arch/arm/mach-omap2/omap-smp.c
index 48ee295db275..4890bcf4dadd 100644
--- a/arch/arm/mach-omap2/omap-smp.c
+++ b/arch/arm/mach-omap2/omap-smp.c
@@ -24,13 +24,14 @@
 #include <asm/localtimer.h>
 #include <asm/smp_scu.h>
 #include <mach/hardware.h>
+#include <plat/common.h>
 
 /* Registers used for communicating startup information */
-#define OMAP4_AUXCOREBOOT_REG0          (OMAP44XX_VA_WKUPGEN_BASE + 0x800)
-#define OMAP4_AUXCOREBOOT_REG1          (OMAP44XX_VA_WKUPGEN_BASE + 0x804)
+static void __iomem *omap4_auxcoreboot_reg0;
+static void __iomem *omap4_auxcoreboot_reg1;
 
 /* SCU base address */
-static void __iomem *scu_base = OMAP44XX_VA_SCU_BASE;
+static void __iomem *scu_base;
 
 /*
  * Use SCU config register to count number of cores
@@ -53,8 +54,7 @@ void __cpuinit platform_secondary_init(unsigned int cpu)
          * core (e.g. timer irq), then they will not have been enabled
          * for us: do so
          */
-
-        gic_cpu_init(0, OMAP2_IO_ADDRESS(OMAP44XX_GIC_CPU_BASE));
+        gic_cpu_init(0, gic_cpu_base_addr);
 
         /*
          * Synchronise with the boot thread.
@@ -79,7 +79,7 @@ int __cpuinit boot_secondary(unsigned int cpu, struct task_struct *idle)
          * the AuxCoreBoot1 register is updated with cpu state
          * A barrier is added to ensure that write buffer is drained
          */
-        __raw_writel(cpu, OMAP4_AUXCOREBOOT_REG1);
+        __raw_writel(cpu, omap4_auxcoreboot_reg1);
         smp_wmb();
 
         timeout = jiffies + (1 * HZ);
@@ -104,7 +104,7 @@ static void __init wakeup_secondary(void)
          * A barrier is added to ensure that write buffer is drained
          */
         __raw_writel(virt_to_phys(omap_secondary_startup),         \
-                                        OMAP4_AUXCOREBOOT_REG0);
+                                        omap4_auxcoreboot_reg0);
         smp_wmb();
 
         /*
@@ -120,7 +120,13 @@ static void __init wakeup_secondary(void)
  */
 void __init smp_init_cpus(void)
 {
-        unsigned int i, ncores = get_core_count();
+        unsigned int i, ncores;
+
+        /* Never released */
+        scu_base = ioremap(OMAP44XX_SCU_BASE, SZ_256);
+        BUG_ON(!scu_base);
+
+        ncores = get_core_count();
 
         for (i = 0; i < ncores; i++)
                 set_cpu_possible(i, true);
@@ -130,6 +136,7 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
 {
         unsigned int ncores = get_core_count();
         unsigned int cpu = smp_processor_id();
+        void __iomem *omap4_wkupgen_base;
         int i;
 
         /* sanity check */
@@ -161,6 +168,12 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
         for (i = 0; i < max_cpus; i++)
                 set_cpu_present(i, true);
 
+        /* Never released */
+        omap4_wkupgen_base = ioremap(OMAP44XX_WKUPGEN_BASE, SZ_4K);
+        BUG_ON(!omap4_wkupgen_base);
+        omap4_auxcoreboot_reg0 = omap4_wkupgen_base + 0x800;
+        omap4_auxcoreboot_reg1 = omap4_wkupgen_base + 0x804;
+
         if (max_cpus > 1) {
                 /*
                  * Enable the local timer or broadcast device for the
diff --git a/arch/arm/mach-omap2/omap3-iommu.c b/arch/arm/mach-omap2/omap3-iommu.c
index 194189c746c2..fbbcb5c83367 100644
--- a/arch/arm/mach-omap2/omap3-iommu.c
+++ b/arch/arm/mach-omap2/omap3-iommu.c
@@ -12,49 +12,52 @@
 
 #include <linux/platform_device.h>
 
-#include <mach/iommu.h>
+#include <plat/iommu.h>
 
-#define OMAP3_MMU1_BASE 0x480bd400
-#define OMAP3_MMU2_BASE 0x5d000000
-#define OMAP3_MMU1_IRQ  24
-#define OMAP3_MMU2_IRQ  28
-
-
-static unsigned long iommu_base[] __initdata = {
-        OMAP3_MMU1_BASE,
-        OMAP3_MMU2_BASE,
-};
-
-static int iommu_irq[] __initdata = {
-        OMAP3_MMU1_IRQ,
-        OMAP3_MMU2_IRQ,
+struct iommu_device {
+        resource_size_t base;
+        int irq;
+        struct iommu_platform_data pdata;
+        struct resource res[2];
 };
 
-static const struct iommu_platform_data omap3_iommu_pdata[] __initconst = {
+static struct iommu_device devices[] = {
         {
-                .name = "isp",
-                .nr_tlb_entries = 8,
-                .clk_name = "cam_ick",
+                .base = 0x480bd400,
+                .irq = 24,
+                .pdata = {
+                        .name = "isp",
+                        .nr_tlb_entries = 8,
+                        .clk_name = "cam_ick",
+                },
         },
 #if defined(CONFIG_MPU_BRIDGE_IOMMU)
         {
-                .name = "iva2",
-                .nr_tlb_entries = 32,
-                .clk_name = "iva2_ck",
+                .base = 0x5d000000,
+                .irq = 28,
+                .pdata = {
+                        .name = "iva2",
+                        .nr_tlb_entries = 32,
+                        .clk_name = "iva2_ck",
+                },
         },
 #endif
 };
-#define NR_IOMMU_DEVICES ARRAY_SIZE(omap3_iommu_pdata)
+#define NR_IOMMU_DEVICES ARRAY_SIZE(devices)
 
 static struct platform_device *omap3_iommu_pdev[NR_IOMMU_DEVICES];
 
 static int __init omap3_iommu_init(void)
 {
         int i, err;
+        struct resource res[] = {
+                { .flags = IORESOURCE_MEM },
+                { .flags = IORESOURCE_IRQ },
+        };
 
         for (i = 0; i < NR_IOMMU_DEVICES; i++) {
                 struct platform_device *pdev;
-                struct resource res[2];
+                const struct iommu_device *d = &devices[i];
 
                 pdev = platform_device_alloc("omap-iommu", i);
                 if (!pdev) {
@@ -62,19 +65,16 @@ static int __init omap3_iommu_init(void)
                         goto err_out;
                 }
 
-                memset(res, 0,  sizeof(res));
-                res[0].start = iommu_base[i];
-                res[0].end = iommu_base[i] + MMU_REG_SIZE - 1;
-                res[0].flags = IORESOURCE_MEM;
-                res[1].start = res[1].end = iommu_irq[i];
-                res[1].flags = IORESOURCE_IRQ;
+                res[0].start = d->base;
+                res[0].end = d->base + MMU_REG_SIZE - 1;
+                res[1].start = res[1].end = d->irq;
 
                 err = platform_device_add_resources(pdev, res,
                                                     ARRAY_SIZE(res));
                 if (err)
                         goto err_out;
-                err = platform_device_add_data(pdev, &omap3_iommu_pdata[i],
-                                               sizeof(omap3_iommu_pdata[0]));
+                err = platform_device_add_data(pdev, &d->pdata,
+                                               sizeof(d->pdata));
                 if (err)
                         goto err_out;
                 err = platform_device_add(pdev);
diff --git a/arch/arm/mach-omap2/omap_hwmod.c b/arch/arm/mach-omap2/omap_hwmod.c
index d2e0f1c95961..633b216a8b26 100644
--- a/arch/arm/mach-omap2/omap_hwmod.c
+++ b/arch/arm/mach-omap2/omap_hwmod.c
@@ -45,11 +45,11 @@
 #include <linux/mutex.h>
 #include <linux/bootmem.h>
 
-#include <mach/cpu.h>
-#include <mach/clockdomain.h>
-#include <mach/powerdomain.h>
-#include <mach/clock.h>
-#include <mach/omap_hwmod.h>
+#include <plat/cpu.h>
+#include <plat/clockdomain.h>
+#include <plat/powerdomain.h>
+#include <plat/clock.h>
+#include <plat/omap_hwmod.h>
 
 #include "cm.h"
 
@@ -496,6 +496,7 @@ static void __iomem *_find_mpu_rt_base(struct omap_hwmod *oh, u8 index)
         struct omap_hwmod_addr_space *mem;
         int i;
         int found = 0;
+        void __iomem *va_start;
 
         if (!oh || oh->slaves_cnt == 0)
                 return NULL;
@@ -509,16 +510,20 @@ static void __iomem *_find_mpu_rt_base(struct omap_hwmod *oh, u8 index)
                 }
         }
 
-        /* XXX use ioremap() instead? */
-
-        if (found)
+        if (found) {
+                va_start = ioremap(mem->pa_start, mem->pa_end - mem->pa_start);
+                if (!va_start) {
+                        pr_err("omap_hwmod: %s: Could not ioremap\n", oh->name);
+                        return NULL;
+                }
                 pr_debug("omap_hwmod: %s: MPU register target at va %p\n",
-                         oh->name, OMAP2_IO_ADDRESS(mem->pa_start));
-        else
+                         oh->name, va_start);
+        } else {
                 pr_debug("omap_hwmod: %s: no MPU register target found\n",
                          oh->name);
+        }
 
-        return (found) ? OMAP2_IO_ADDRESS(mem->pa_start) : NULL;
+        return (found) ? va_start : NULL;
 }
 
 /**
@@ -1148,6 +1153,7 @@ int omap_hwmod_unregister(struct omap_hwmod *oh)
         pr_debug("omap_hwmod: %s: unregistering\n", oh->name);
 
         mutex_lock(&omap_hwmod_mutex);
+        iounmap(oh->_rt_va);
         list_del(&oh->node);
         mutex_unlock(&omap_hwmod_mutex);
 
diff --git a/arch/arm/mach-omap2/omap_hwmod_2420.h b/arch/arm/mach-omap2/omap_hwmod_2420.h
index 767e4965ac4e..a9ca1b99a301 100644
--- a/arch/arm/mach-omap2/omap_hwmod_2420.h
+++ b/arch/arm/mach-omap2/omap_hwmod_2420.h
@@ -16,10 +16,10 @@
 
 #ifdef CONFIG_ARCH_OMAP2420
 
-#include <mach/omap_hwmod.h>
+#include <plat/omap_hwmod.h>
 #include <mach/irqs.h>
-#include <mach/cpu.h>
-#include <mach/dma.h>
+#include <plat/cpu.h>
+#include <plat/dma.h>
 
 #include "prm-regbits-24xx.h"
 
diff --git a/arch/arm/mach-omap2/omap_hwmod_2430.h b/arch/arm/mach-omap2/omap_hwmod_2430.h
index a412be6420ec..59a208bea6c2 100644
--- a/arch/arm/mach-omap2/omap_hwmod_2430.h
+++ b/arch/arm/mach-omap2/omap_hwmod_2430.h
@@ -16,10 +16,10 @@
 
 #ifdef CONFIG_ARCH_OMAP2430
 
-#include <mach/omap_hwmod.h>
+#include <plat/omap_hwmod.h>
 #include <mach/irqs.h>
-#include <mach/cpu.h>
-#include <mach/dma.h>
+#include <plat/cpu.h>
+#include <plat/dma.h>
 
 #include "prm-regbits-24xx.h"
 
diff --git a/arch/arm/mach-omap2/omap_hwmod_34xx.h b/arch/arm/mach-omap2/omap_hwmod_34xx.h
index 1e069f831575..b6076b9c364e 100644
--- a/arch/arm/mach-omap2/omap_hwmod_34xx.h
+++ b/arch/arm/mach-omap2/omap_hwmod_34xx.h
@@ -14,10 +14,10 @@
 
 #ifdef CONFIG_ARCH_OMAP34XX
 
-#include <mach/omap_hwmod.h>
+#include <plat/omap_hwmod.h>
 #include <mach/irqs.h>
-#include <mach/cpu.h>
-#include <mach/dma.h>
+#include <plat/cpu.h>
+#include <plat/dma.h>
 
 #include "prm-regbits-34xx.h"
 
diff --git a/arch/arm/mach-omap2/pm-debug.c b/arch/arm/mach-omap2/pm-debug.c
index 2fc4d6abbd0a..8baa30d2acfb 100644
--- a/arch/arm/mach-omap2/pm-debug.c
+++ b/arch/arm/mach-omap2/pm-debug.c
@@ -26,10 +26,10 @@
 #include <linux/io.h>
 #include <linux/module.h>
 
-#include <mach/clock.h>
-#include <mach/board.h>
-#include <mach/powerdomain.h>
-#include <mach/clockdomain.h>
+#include <plat/clock.h>
+#include <plat/board.h>
+#include <plat/powerdomain.h>
+#include <plat/clockdomain.h>
 
 #include "prm.h"
 #include "cm.h"
@@ -51,7 +51,8 @@ int omap2_pm_debug;
         regs[reg_count++].val = __raw_readl(reg)
 #define DUMP_INTC_REG(reg, off) \
         regs[reg_count].name = #reg; \
-        regs[reg_count++].val = __raw_readl(OMAP2_IO_ADDRESS(0x480fe000 + (off)))
+        regs[reg_count++].val = \
+                         __raw_readl(OMAP2_L4_IO_ADDRESS(0x480fe000 + (off)))
 
 static int __init pm_dbg_init(void);
 
@@ -526,6 +527,29 @@ static int __init pwrdms_setup(struct powerdomain *pwrdm, void *dir)
         return 0;
 }
 
+static int option_get(void *data, u64 *val)
+{
+        u32 *option = data;
+
+        *val = *option;
+
+        return 0;
+}
+
+static int option_set(void *data, u64 val)
+{
+        u32 *option = data;
+
+        *option = val;
+
+        if (option == &enable_off_mode)
+                omap3_pm_off_mode_enable(val);
+
+        return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(pm_dbg_option_fops, option_get, option_set, "%llu\n");
+
 static int __init pm_dbg_init(void)
 {
         int i;
@@ -568,6 +592,12 @@ static int __init pm_dbg_init(void)
 
                 }
 
+        (void) debugfs_create_file("enable_off_mode", S_IRUGO | S_IWUGO, d,
+                                   &enable_off_mode, &pm_dbg_option_fops);
+        (void) debugfs_create_file("sleep_while_idle", S_IRUGO | S_IWUGO, d,
+                                   &sleep_while_idle, &pm_dbg_option_fops);
+        (void) debugfs_create_file("wakeup_timer_seconds", S_IRUGO | S_IWUGO, d,
+                                   &wakeup_timer_seconds, &pm_dbg_option_fops);
         pm_dbg_init_done = 1;
 
         return 0;
diff --git a/arch/arm/mach-omap2/pm.h b/arch/arm/mach-omap2/pm.h
index 8400f5768923..0bf345db7147 100644
--- a/arch/arm/mach-omap2/pm.h
+++ b/arch/arm/mach-omap2/pm.h
@@ -11,11 +11,24 @@
 #ifndef __ARCH_ARM_MACH_OMAP2_PM_H
 #define __ARCH_ARM_MACH_OMAP2_PM_H
 
-#include <mach/powerdomain.h>
+#include <plat/powerdomain.h>
+
+extern u32 enable_off_mode;
+extern u32 sleep_while_idle;
+
+extern void *omap3_secure_ram_storage;
+extern void omap3_pm_off_mode_enable(int);
+extern void omap_sram_idle(void);
+extern int omap3_can_sleep(void);
+extern int set_pwrdm_state(struct powerdomain *pwrdm, u32 state);
+extern int omap3_idle_init(void);
 
 extern int omap3_pm_get_suspend_state(struct powerdomain *pwrdm);
 extern int omap3_pm_set_suspend_state(struct powerdomain *pwrdm, int state);
 
+extern u32 wakeup_timer_seconds;
+extern struct omap_dm_timer *gptimer_wakeup;
+
 #ifdef CONFIG_PM_DEBUG
 extern void omap2_pm_dump(int mode, int resume, unsigned int us);
 extern int omap2_pm_debug;
@@ -36,6 +49,7 @@ extern void omap24xx_cpu_suspend(u32 dll_ctrl, void __iomem *sdrc_dlla_ctrl,
                                         void __iomem *sdrc_power);
 extern void omap34xx_cpu_suspend(u32 *addr, int save_state);
 extern void save_secure_ram_context(u32 *addr);
+extern void omap3_save_scratchpad_contents(void);
 
 extern unsigned int omap24xx_idle_loop_suspend_sz;
 extern unsigned int omap34xx_suspend_sz;
diff --git a/arch/arm/mach-omap2/pm24xx.c b/arch/arm/mach-omap2/pm24xx.c
index bff5c4e89742..cba05b9f041f 100644
--- a/arch/arm/mach-omap2/pm24xx.c
+++ b/arch/arm/mach-omap2/pm24xx.c
@@ -36,12 +36,12 @@
 #include <asm/mach-types.h>
 
 #include <mach/irqs.h>
-#include <mach/clock.h>
-#include <mach/sram.h>
-#include <mach/control.h>
-#include <mach/mux.h>
-#include <mach/dma.h>
-#include <mach/board.h>
+#include <plat/clock.h>
+#include <plat/sram.h>
+#include <plat/control.h>
+#include <plat/mux.h>
+#include <plat/dma.h>
+#include <plat/board.h>
 
 #include "prm.h"
 #include "prm-regbits-24xx.h"
@@ -50,8 +50,8 @@
 #include "sdrc.h"
 #include "pm.h"
 
-#include <mach/powerdomain.h>
-#include <mach/clockdomain.h>
+#include <plat/powerdomain.h>
+#include <plat/clockdomain.h>
 
 static void (*omap2_sram_idle)(void);
 static void (*omap2_sram_suspend)(u32 dllctrl, void __iomem *sdrc_dlla_ctrl,
diff --git a/arch/arm/mach-omap2/pm34xx.c b/arch/arm/mach-omap2/pm34xx.c
index 378c2f618358..81ed252a0f8a 100644
--- a/arch/arm/mach-omap2/pm34xx.c
+++ b/arch/arm/mach-omap2/pm34xx.c
@@ -5,6 +5,9 @@
  * Tony Lindgren <tony@atomide.com>
  * Jouni Hogander
  *
+ * Copyright (C) 2007 Texas Instruments, Inc.
+ * Rajendra Nayak <rnayak@ti.com>
+ *
  * Copyright (C) 2005 Texas Instruments, Inc.
  * Richard Woodruff <r-woodruff2@ti.com>
  *
@@ -22,12 +25,20 @@
 #include <linux/list.h>
 #include <linux/err.h>
 #include <linux/gpio.h>
+#include <linux/clk.h>
+
+#include <plat/sram.h>
+#include <plat/clockdomain.h>
+#include <plat/powerdomain.h>
+#include <plat/control.h>
+#include <plat/serial.h>
+#include <plat/sdrc.h>
+#include <plat/prcm.h>
+#include <plat/gpmc.h>
+#include <plat/dma.h>
+#include <plat/dmtimer.h>
 
-#include <mach/sram.h>
-#include <mach/clockdomain.h>
-#include <mach/powerdomain.h>
-#include <mach/control.h>
-#include <mach/serial.h>
+#include <asm/tlbflush.h>
 
 #include "cm.h"
 #include "cm-regbits-34xx.h"
@@ -35,6 +46,16 @@
 
 #include "prm.h"
 #include "pm.h"
+#include "sdrc.h"
+
+/* Scratchpad offsets */
+#define OMAP343X_TABLE_ADDRESS_OFFSET      0x31
+#define OMAP343X_TABLE_VALUE_OFFSET        0x30
+#define OMAP343X_CONTROL_REG_VALUE_OFFSET  0x32
+
+u32 enable_off_mode;
+u32 sleep_while_idle;
+u32 wakeup_timer_seconds;
 
 struct power_state {
         struct powerdomain *pwrdm;
@@ -49,7 +70,112 @@ static LIST_HEAD(pwrst_list);
 
 static void (*_omap_sram_idle)(u32 *addr, int save_state);
 
-static struct powerdomain *mpu_pwrdm;
+static int (*_omap_save_secure_sram)(u32 *addr);
+
+static struct powerdomain *mpu_pwrdm, *neon_pwrdm;
+static struct powerdomain *core_pwrdm, *per_pwrdm;
+static struct powerdomain *cam_pwrdm;
+
+static inline void omap3_per_save_context(void)
+{
+        omap_gpio_save_context();
+}
+
+static inline void omap3_per_restore_context(void)
+{
+        omap_gpio_restore_context();
+}
+
+static void omap3_enable_io_chain(void)
+{
+        int timeout = 0;
+
+        if (omap_rev() >= OMAP3430_REV_ES3_1) {
+                prm_set_mod_reg_bits(OMAP3430_EN_IO_CHAIN, WKUP_MOD, PM_WKEN);
+                /* Do a readback to assure write has been done */
+                prm_read_mod_reg(WKUP_MOD, PM_WKEN);
+
+                while (!(prm_read_mod_reg(WKUP_MOD, PM_WKST) &
+                         OMAP3430_ST_IO_CHAIN)) {
+                        timeout++;
+                        if (timeout > 1000) {
+                                printk(KERN_ERR "Wake up daisy chain "
+                                       "activation failed.\n");
+                                return;
+                        }
+                        prm_set_mod_reg_bits(OMAP3430_ST_IO_CHAIN,
+                                             WKUP_MOD, PM_WKST);
+                }
+        }
+}
+
+static void omap3_disable_io_chain(void)
+{
+        if (omap_rev() >= OMAP3430_REV_ES3_1)
+                prm_clear_mod_reg_bits(OMAP3430_EN_IO_CHAIN, WKUP_MOD, PM_WKEN);
+}
+
+static void omap3_core_save_context(void)
+{
+        u32 control_padconf_off;
+
+        /* Save the padconf registers */
+        control_padconf_off = omap_ctrl_readl(OMAP343X_CONTROL_PADCONF_OFF);
+        control_padconf_off |= START_PADCONF_SAVE;
+        omap_ctrl_writel(control_padconf_off, OMAP343X_CONTROL_PADCONF_OFF);
+        /* wait for the save to complete */
+        while (!omap_ctrl_readl(OMAP343X_CONTROL_GENERAL_PURPOSE_STATUS)
+                        & PADCONF_SAVE_DONE)
+                ;
+        /* Save the Interrupt controller context */
+        omap_intc_save_context();
+        /* Save the GPMC context */
+        omap3_gpmc_save_context();
+        /* Save the system control module context, padconf already save above*/
+        omap3_control_save_context();
+        omap_dma_global_context_save();
+}
+
+static void omap3_core_restore_context(void)
+{
+        /* Restore the control module context, padconf restored by h/w */
+        omap3_control_restore_context();
+        /* Restore the GPMC context */
+        omap3_gpmc_restore_context();
+        /* Restore the interrupt controller context */
+        omap_intc_restore_context();
+        omap_dma_global_context_restore();
+}
+
+/*
+ * FIXME: This function should be called before entering off-mode after
+ * OMAP3 secure services have been accessed. Currently it is only called
+ * once during boot sequence, but this works as we are not using secure
+ * services.
+ */
+static void omap3_save_secure_ram_context(u32 target_mpu_state)
+{
+        u32 ret;
+
+        if (omap_type() != OMAP2_DEVICE_TYPE_GP) {
+                /*
+                 * MPU next state must be set to POWER_ON temporarily,
+                 * otherwise the WFI executed inside the ROM code
+                 * will hang the system.
+                 */
+                pwrdm_set_next_pwrst(mpu_pwrdm, PWRDM_POWER_ON);
+                ret = _omap_save_secure_sram((u32 *)
+                                __pa(omap3_secure_ram_storage));
+                pwrdm_set_next_pwrst(mpu_pwrdm, target_mpu_state);
+                /* Following is for error tracking, it should not happen */
+                if (ret) {
+                        printk(KERN_ERR "save_secure_sram() returns %08x\n",
+                                ret);
+                        while (1)
+                                ;
+                }
+        }
+}
 
 /*
  * PRCM Interrupt Handler Helper Function
@@ -161,7 +287,36 @@ static irqreturn_t prcm_interrupt_handler (int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static void omap_sram_idle(void)
+static void restore_control_register(u32 val)
+{
+        __asm__ __volatile__ ("mcr p15, 0, %0, c1, c0, 0" : : "r" (val));
+}
+
+/* Function to restore the table entry that was modified for enabling MMU */
+static void restore_table_entry(void)
+{
+        u32 *scratchpad_address;
+        u32 previous_value, control_reg_value;
+        u32 *address;
+
+        scratchpad_address = OMAP2_L4_IO_ADDRESS(OMAP343X_SCRATCHPAD);
+
+        /* Get address of entry that was modified */
+        address = (u32 *)__raw_readl(scratchpad_address +
+                                     OMAP343X_TABLE_ADDRESS_OFFSET);
+        /* Get the previous value which needs to be restored */
+        previous_value = __raw_readl(scratchpad_address +
+                                     OMAP343X_TABLE_VALUE_OFFSET);
+        address = __va(address);
+        *address = previous_value;
+        flush_tlb_all();
+        control_reg_value = __raw_readl(scratchpad_address
+                                        + OMAP343X_CONTROL_REG_VALUE_OFFSET);
+        /* This will enable caches and prediction */
+        restore_control_register(control_reg_value);
+}
+
+void omap_sram_idle(void)
 {
         /* Variable to tell what needs to be saved and restored
          * in omap_sram_idle*/
@@ -169,17 +324,32 @@ static void omap_sram_idle(void)
         /* save_state = 1 => Only L1 and logic lost */
         /* save_state = 2 => Only L2 lost */
         /* save_state = 3 => L1, L2 and logic lost */
-        int save_state = 0, mpu_next_state;
+        int save_state = 0;
+        int mpu_next_state = PWRDM_POWER_ON;
+        int per_next_state = PWRDM_POWER_ON;
+        int core_next_state = PWRDM_POWER_ON;
+        int core_prev_state, per_prev_state;
+        u32 sdrc_pwr = 0;
+        int per_state_modified = 0;
 
         if (!_omap_sram_idle)
                 return;
 
+        pwrdm_clear_all_prev_pwrst(mpu_pwrdm);
+        pwrdm_clear_all_prev_pwrst(neon_pwrdm);
+        pwrdm_clear_all_prev_pwrst(core_pwrdm);
+        pwrdm_clear_all_prev_pwrst(per_pwrdm);
+
         mpu_next_state = pwrdm_read_next_pwrst(mpu_pwrdm);
         switch (mpu_next_state) {
+        case PWRDM_POWER_ON:
         case PWRDM_POWER_RET:
                 /* No need to save context */
                 save_state = 0;
                 break;
+        case PWRDM_POWER_OFF:
+                save_state = 3;
+                break;
         default:
                 /* Invalid state */
                 printk(KERN_ERR "Invalid mpu state in sram_idle\n");
@@ -187,68 +357,115 @@ static void omap_sram_idle(void)
         }
         pwrdm_pre_transition();
 
-        omap2_gpio_prepare_for_retention();
-        omap_uart_prepare_idle(0);
-        omap_uart_prepare_idle(1);
-        omap_uart_prepare_idle(2);
+        /* NEON control */
+        if (pwrdm_read_pwrst(neon_pwrdm) == PWRDM_POWER_ON)
+                pwrdm_set_next_pwrst(neon_pwrdm, mpu_next_state);
+
+        /* PER */
+        per_next_state = pwrdm_read_next_pwrst(per_pwrdm);
+        core_next_state = pwrdm_read_next_pwrst(core_pwrdm);
+        if (per_next_state < PWRDM_POWER_ON) {
+                omap_uart_prepare_idle(2);
+                omap2_gpio_prepare_for_retention();
+                if (per_next_state == PWRDM_POWER_OFF) {
+                        if (core_next_state == PWRDM_POWER_ON) {
+                                per_next_state = PWRDM_POWER_RET;
+                                pwrdm_set_next_pwrst(per_pwrdm, per_next_state);
+                                per_state_modified = 1;
+                        } else
+                                omap3_per_save_context();
+                }
+        }
+
+        if (pwrdm_read_pwrst(cam_pwrdm) == PWRDM_POWER_ON)
+                omap2_clkdm_deny_idle(mpu_pwrdm->pwrdm_clkdms[0]);
+
+        /* CORE */
+        if (core_next_state < PWRDM_POWER_ON) {
+                omap_uart_prepare_idle(0);
+                omap_uart_prepare_idle(1);
+                if (core_next_state == PWRDM_POWER_OFF) {
+                        omap3_core_save_context();
+                        omap3_prcm_save_context();
+                }
+                /* Enable IO-PAD and IO-CHAIN wakeups */
+                prm_set_mod_reg_bits(OMAP3430_EN_IO, WKUP_MOD, PM_WKEN);
+                omap3_enable_io_chain();
+        }
+
+        /*
+        * On EMU/HS devices ROM code restores a SRDC value
+        * from scratchpad which has automatic self refresh on timeout
+        * of AUTO_CNT = 1 enabled. This takes care of errata 1.142.
+        * Hence store/restore the SDRC_POWER register here.
+        */
+        if (omap_rev() >= OMAP3430_REV_ES3_0 &&
+            omap_type() != OMAP2_DEVICE_TYPE_GP &&
+            core_next_state == PWRDM_POWER_OFF)
+                sdrc_pwr = sdrc_read_reg(SDRC_POWER);
 
-        _omap_sram_idle(NULL, save_state);
+        /*
+         * omap3_arm_context is the location where ARM registers
+         * get saved. The restore path then reads from this
+         * location and restores them back.
+         */
+        _omap_sram_idle(omap3_arm_context, save_state);
         cpu_init();
 
-        omap_uart_resume_idle(2);
-        omap_uart_resume_idle(1);
-        omap_uart_resume_idle(0);
-        omap2_gpio_resume_after_retention();
+        /* Restore normal SDRC POWER settings */
+        if (omap_rev() >= OMAP3430_REV_ES3_0 &&
+            omap_type() != OMAP2_DEVICE_TYPE_GP &&
+            core_next_state == PWRDM_POWER_OFF)
+                sdrc_write_reg(sdrc_pwr, SDRC_POWER);
+
+        /* Restore table entry modified during MMU restoration */
+        if (pwrdm_read_prev_pwrst(mpu_pwrdm) == PWRDM_POWER_OFF)
+                restore_table_entry();
+
+        /* CORE */
+        if (core_next_state < PWRDM_POWER_ON) {
+                core_prev_state = pwrdm_read_prev_pwrst(core_pwrdm);
+                if (core_prev_state == PWRDM_POWER_OFF) {
+                        omap3_core_restore_context();
+                        omap3_prcm_restore_context();
+                        omap3_sram_restore_context();
+                        omap2_sms_restore_context();
+                }
+                omap_uart_resume_idle(0);
+                omap_uart_resume_idle(1);
+                if (core_next_state == PWRDM_POWER_OFF)
+                        prm_clear_mod_reg_bits(OMAP3430_AUTO_OFF,
+                                               OMAP3430_GR_MOD,
+                                               OMAP3_PRM_VOLTCTRL_OFFSET);
+        }
 
-        pwrdm_post_transition();
+        /* PER */
+        if (per_next_state < PWRDM_POWER_ON) {
+                per_prev_state = pwrdm_read_prev_pwrst(per_pwrdm);
+                if (per_prev_state == PWRDM_POWER_OFF)
+                        omap3_per_restore_context();
+                omap2_gpio_resume_after_retention();
+                omap_uart_resume_idle(2);
+                if (per_state_modified)
+                        pwrdm_set_next_pwrst(per_pwrdm, PWRDM_POWER_OFF);
+        }
 
-}
+        /* Disable IO-PAD and IO-CHAIN wakeup */
+        if (core_next_state < PWRDM_POWER_ON) {
+                prm_clear_mod_reg_bits(OMAP3430_EN_IO, WKUP_MOD, PM_WKEN);
+                omap3_disable_io_chain();
+        }
 
-/*
- * Check if functional clocks are enabled before entering
- * sleep. This function could be behind CONFIG_PM_DEBUG
- * when all drivers are configuring their sysconfig registers
- * properly and using their clocks properly.
- */
-static int omap3_fclks_active(void)
-{
-        u32 fck_core1 = 0, fck_core3 = 0, fck_sgx = 0, fck_dss = 0,
-                fck_cam = 0, fck_per = 0, fck_usbhost = 0;
+        pwrdm_post_transition();
 
-        fck_core1 = cm_read_mod_reg(CORE_MOD,
-                                    CM_FCLKEN1);
-        if (omap_rev() > OMAP3430_REV_ES1_0) {
-                fck_core3 = cm_read_mod_reg(CORE_MOD,
-                                            OMAP3430ES2_CM_FCLKEN3);
-                fck_sgx = cm_read_mod_reg(OMAP3430ES2_SGX_MOD,
-                                          CM_FCLKEN);
-                fck_usbhost = cm_read_mod_reg(OMAP3430ES2_USBHOST_MOD,
-                                              CM_FCLKEN);
-        } else
-                fck_sgx = cm_read_mod_reg(GFX_MOD,
-                                          OMAP3430ES2_CM_FCLKEN3);
-        fck_dss = cm_read_mod_reg(OMAP3430_DSS_MOD,
-                                  CM_FCLKEN);
-        fck_cam = cm_read_mod_reg(OMAP3430_CAM_MOD,
-                                  CM_FCLKEN);
-        fck_per = cm_read_mod_reg(OMAP3430_PER_MOD,
-                                  CM_FCLKEN);
-
-        /* Ignore UART clocks.  These are handled by UART core (serial.c) */
-        fck_core1 &= ~(OMAP3430_EN_UART1 | OMAP3430_EN_UART2);
-        fck_per &= ~OMAP3430_EN_UART3;
-
-        if (fck_core1 | fck_core3 | fck_sgx | fck_dss |
-            fck_cam | fck_per | fck_usbhost)
-                return 1;
-        return 0;
+        omap2_clkdm_allow_idle(mpu_pwrdm->pwrdm_clkdms[0]);
 }
 
-static int omap3_can_sleep(void)
+int omap3_can_sleep(void)
 {
-        if (!omap_uart_can_sleep())
+        if (!sleep_while_idle)
                 return 0;
-        if (omap3_fclks_active())
+        if (!omap_uart_can_sleep())
                 return 0;
         return 1;
 }
@@ -256,7 +473,7 @@ static int omap3_can_sleep(void)
 /* This sets pwrdm state (other than mpu & core. Currently only ON &
  * RET are supported. Function is assuming that clkdm doesn't have
  * hw_sup mode enabled. */
-static int set_pwrdm_state(struct powerdomain *pwrdm, u32 state)
+int set_pwrdm_state(struct powerdomain *pwrdm, u32 state)
 {
         u32 cur_state;
         int sleep_switch = 0;
@@ -306,7 +523,7 @@ static void omap3_pm_idle(void)
         if (!omap3_can_sleep())
                 goto out;
 
-        if (omap_irq_pending())
+        if (omap_irq_pending() || need_resched())
                 goto out;
 
         omap_sram_idle();
@@ -319,6 +536,22 @@ out:
 #ifdef CONFIG_SUSPEND
 static suspend_state_t suspend_state;
 
+static void omap2_pm_wakeup_on_timer(u32 seconds)
+{
+        u32 tick_rate, cycles;
+
+        if (!seconds)
+                return;
+
+        tick_rate = clk_get_rate(omap_dm_timer_get_fclk(gptimer_wakeup));
+        cycles = tick_rate * seconds;
+        omap_dm_timer_stop(gptimer_wakeup);
+        omap_dm_timer_set_load_start(gptimer_wakeup, 0, 0xffffffff - cycles);
+
+        pr_info("PM: Resume timer in %d secs (%d ticks at %d ticks/sec.)\n",
+                seconds, cycles, tick_rate);
+}
+
 static int omap3_pm_prepare(void)
 {
         disable_hlt();
@@ -330,6 +563,9 @@ static int omap3_pm_suspend(void)
         struct power_state *pwrst;
         int state, ret = 0;
 
+        if (wakeup_timer_seconds)
+                omap2_pm_wakeup_on_timer(wakeup_timer_seconds);
+
         /* Read current next_pwrsts */
         list_for_each_entry(pwrst, &pwrst_list, node)
                 pwrst->saved_state = pwrdm_read_next_pwrst(pwrst->pwrdm);
@@ -639,14 +875,15 @@ static void __init prcm_setup_regs(void)
         prm_write_mod_reg(OMAP3430_IO_EN | OMAP3430_WKUP_EN,
                           OCP_MOD, OMAP3_PRM_IRQENABLE_MPU_OFFSET);
 
-        /* Enable GPIO wakeups in PER */
+        /* Enable wakeups in PER */
         prm_write_mod_reg(OMAP3430_EN_GPIO2 | OMAP3430_EN_GPIO3 |
                           OMAP3430_EN_GPIO4 | OMAP3430_EN_GPIO5 |
-                          OMAP3430_EN_GPIO6, OMAP3430_PER_MOD, PM_WKEN);
+                          OMAP3430_EN_GPIO6 | OMAP3430_EN_UART3,
+                          OMAP3430_PER_MOD, PM_WKEN);
         /* and allow them to wake up MPU */
         prm_write_mod_reg(OMAP3430_GRPSEL_GPIO2 | OMAP3430_EN_GPIO3 |
                           OMAP3430_GRPSEL_GPIO4 | OMAP3430_EN_GPIO5 |
-                          OMAP3430_GRPSEL_GPIO6,
+                          OMAP3430_GRPSEL_GPIO6 | OMAP3430_EN_UART3,
                           OMAP3430_PER_MOD, OMAP3430_PM_MPUGRPSEL);
 
         /* Don't attach IVA interrupts */
@@ -689,6 +926,22 @@ static void __init prcm_setup_regs(void)
         omap3_d2d_idle();
 }
 
+void omap3_pm_off_mode_enable(int enable)
+{
+        struct power_state *pwrst;
+        u32 state;
+
+        if (enable)
+                state = PWRDM_POWER_OFF;
+        else
+                state = PWRDM_POWER_RET;
+
+        list_for_each_entry(pwrst, &pwrst_list, node) {
+                pwrst->next_state = state;
+                set_pwrdm_state(pwrst->pwrdm, state);
+        }
+}
+
 int omap3_pm_get_suspend_state(struct powerdomain *pwrdm)
 {
         struct power_state *pwrst;
@@ -748,6 +1001,15 @@ static int __init clkdms_setup(struct clockdomain *clkdm, void *unused)
         return 0;
 }
 
+void omap_push_sram_idle(void)
+{
+        _omap_sram_idle = omap_sram_push(omap34xx_cpu_suspend,
+                                        omap34xx_cpu_suspend_sz);
+        if (omap_type() != OMAP2_DEVICE_TYPE_GP)
+                _omap_save_secure_sram = omap_sram_push(save_secure_ram_context,
+                                save_secure_ram_context_sz);
+}
+
 static int __init omap3_pm_init(void)
 {
         struct power_state *pwrst, *tmp;
@@ -785,15 +1047,47 @@ static int __init omap3_pm_init(void)
                 goto err2;
         }
 
-        _omap_sram_idle = omap_sram_push(omap34xx_cpu_suspend,
-                                         omap34xx_cpu_suspend_sz);
+        neon_pwrdm = pwrdm_lookup("neon_pwrdm");
+        per_pwrdm = pwrdm_lookup("per_pwrdm");
+        core_pwrdm = pwrdm_lookup("core_pwrdm");
+        cam_pwrdm = pwrdm_lookup("cam_pwrdm");
 
+        omap_push_sram_idle();
 #ifdef CONFIG_SUSPEND
         suspend_set_ops(&omap_pm_ops);
 #endif /* CONFIG_SUSPEND */
 
         pm_idle = omap3_pm_idle;
+        omap3_idle_init();
+
+        pwrdm_add_wkdep(neon_pwrdm, mpu_pwrdm);
+        /*
+         * REVISIT: This wkdep is only necessary when GPIO2-6 are enabled for
+         * IO-pad wakeup.  Otherwise it will unnecessarily waste power
+         * waking up PER with every CORE wakeup - see
+         * http://marc.info/?l=linux-omap&m=121852150710062&w=2
+        */
+        pwrdm_add_wkdep(per_pwrdm, core_pwrdm);
+
+        if (omap_type() != OMAP2_DEVICE_TYPE_GP) {
+                omap3_secure_ram_storage =
+                        kmalloc(0x803F, GFP_KERNEL);
+                if (!omap3_secure_ram_storage)
+                        printk(KERN_ERR "Memory allocation failed when"
+                                        "allocating for secure sram context\n");
+
+                local_irq_disable();
+                local_fiq_disable();
+
+                omap_dma_global_context_save();
+                omap3_save_secure_ram_context(PWRDM_POWER_ON);
+                omap_dma_global_context_restore();
+
+                local_irq_enable();
+                local_fiq_enable();
+        }
 
+        omap3_save_scratchpad_contents();
 err1:
         return ret;
 err2:
diff --git a/arch/arm/mach-omap2/powerdomain.c b/arch/arm/mach-omap2/powerdomain.c
index f00289abd30f..b6990e377783 100644
--- a/arch/arm/mach-omap2/powerdomain.c
+++ b/arch/arm/mach-omap2/powerdomain.c
@@ -31,9 +31,9 @@
 #include "prm.h"
 #include "prm-regbits-34xx.h"
 
-#include <mach/cpu.h>
-#include <mach/powerdomain.h>
-#include <mach/clockdomain.h>
+#include <plat/cpu.h>
+#include <plat/powerdomain.h>
+#include <plat/clockdomain.h>
 
 #include "pm.h"
 
diff --git a/arch/arm/mach-omap2/powerdomains.h b/arch/arm/mach-omap2/powerdomains.h
index 691470ea4c6a..057b2e3e2c35 100644
--- a/arch/arm/mach-omap2/powerdomains.h
+++ b/arch/arm/mach-omap2/powerdomains.h
@@ -63,7 +63,7 @@
  * XXX encode hardware fixed wakeup dependencies -- esp. for 3430 CORE
  */
 
-#include <mach/powerdomain.h>
+#include <plat/powerdomain.h>
 
 #include "prcm-common.h"
 #include "prm.h"
diff --git a/arch/arm/mach-omap2/powerdomains24xx.h b/arch/arm/mach-omap2/powerdomains24xx.h
index 9f08dc3f7fd2..bd249a495aa9 100644
--- a/arch/arm/mach-omap2/powerdomains24xx.h
+++ b/arch/arm/mach-omap2/powerdomains24xx.h
@@ -20,7 +20,7 @@
  * the array in mach-omap2/powerdomains.h.
  */
 
-#include <mach/powerdomain.h>
+#include <plat/powerdomain.h>
 
 #include "prcm-common.h"
 #include "prm.h"
diff --git a/arch/arm/mach-omap2/powerdomains34xx.h b/arch/arm/mach-omap2/powerdomains34xx.h
index 4dcf94b800ab..fd09b0827df0 100644
--- a/arch/arm/mach-omap2/powerdomains34xx.h
+++ b/arch/arm/mach-omap2/powerdomains34xx.h
@@ -20,7 +20,7 @@
  * the array in mach-omap2/powerdomains.h.
  */
 
-#include <mach/powerdomain.h>
+#include <plat/powerdomain.h>
 
 #include "prcm-common.h"
 #include "prm.h"
@@ -338,7 +338,13 @@ static struct powerdomain usbhost_pwrdm = {
         .sleepdep_srcs    = dss_per_usbhost_sleepdeps,
         .pwrsts           = PWRSTS_OFF_RET_ON,
         .pwrsts_logic_ret = PWRDM_POWER_RET,
-        .flags            = PWRDM_HAS_HDWR_SAR, /* for USBHOST ctrlr only */
+        /*
+         * REVISIT: Enabling usb host save and restore mechanism seems to
+         * leave the usb host domain permanently in ACTIVE mode after
+         * changing the usb host power domain state from OFF to active once.
+         * Disabling for now.
+         */
+        /*.flags          = PWRDM_HAS_HDWR_SAR,*/ /* for USBHOST ctrlr only */
         .banks            = 1,
         .pwrsts_mem_ret   = {
                 [0] = PWRDM_POWER_RET, /* MEMRETSTATE */
diff --git a/arch/arm/mach-omap2/prcm.c b/arch/arm/mach-omap2/prcm.c
index ced555a4cd1a..029d376198d4 100644
--- a/arch/arm/mach-omap2/prcm.c
+++ b/arch/arm/mach-omap2/prcm.c
@@ -7,6 +7,9 @@
  *
  * Written by Tony Lindgren <tony.lindgren@nokia.com>
  *
+ * Copyright (C) 2007 Texas Instruments, Inc.
+ * Rajendra Nayak <rnayak@ti.com>
+ *
  * Some pieces of code Copyright (C) 2005 Texas Instruments, Inc.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,10 +22,13 @@
 #include <linux/io.h>
 #include <linux/delay.h>
 
-#include <mach/common.h>
-#include <mach/prcm.h>
+#include <plat/common.h>
+#include <plat/prcm.h>
+#include <plat/irqs.h>
+#include <plat/control.h>
 
 #include "clock.h"
+#include "cm.h"
 #include "prm.h"
 #include "prm-regbits-24xx.h"
 
@@ -31,6 +37,89 @@ static void __iomem *cm_base;
 
 #define MAX_MODULE_ENABLE_WAIT          100000
 
+struct omap3_prcm_regs {
+        u32 control_padconf_sys_nirq;
+        u32 iva2_cm_clksel1;
+        u32 iva2_cm_clksel2;
+        u32 cm_sysconfig;
+        u32 sgx_cm_clksel;
+        u32 wkup_cm_clksel;
+        u32 dss_cm_clksel;
+        u32 cam_cm_clksel;
+        u32 per_cm_clksel;
+        u32 emu_cm_clksel;
+        u32 emu_cm_clkstctrl;
+        u32 pll_cm_autoidle2;
+        u32 pll_cm_clksel4;
+        u32 pll_cm_clksel5;
+        u32 pll_cm_clken;
+        u32 pll_cm_clken2;
+        u32 cm_polctrl;
+        u32 iva2_cm_fclken;
+        u32 iva2_cm_clken_pll;
+        u32 core_cm_fclken1;
+        u32 core_cm_fclken3;
+        u32 sgx_cm_fclken;
+        u32 wkup_cm_fclken;
+        u32 dss_cm_fclken;
+        u32 cam_cm_fclken;
+        u32 per_cm_fclken;
+        u32 usbhost_cm_fclken;
+        u32 core_cm_iclken1;
+        u32 core_cm_iclken2;
+        u32 core_cm_iclken3;
+        u32 sgx_cm_iclken;
+        u32 wkup_cm_iclken;
+        u32 dss_cm_iclken;
+        u32 cam_cm_iclken;
+        u32 per_cm_iclken;
+        u32 usbhost_cm_iclken;
+        u32 iva2_cm_autiidle2;
+        u32 mpu_cm_autoidle2;
+        u32 pll_cm_autoidle;
+        u32 iva2_cm_clkstctrl;
+        u32 mpu_cm_clkstctrl;
+        u32 core_cm_clkstctrl;
+        u32 sgx_cm_clkstctrl;
+        u32 dss_cm_clkstctrl;
+        u32 cam_cm_clkstctrl;
+        u32 per_cm_clkstctrl;
+        u32 neon_cm_clkstctrl;
+        u32 usbhost_cm_clkstctrl;
+        u32 core_cm_autoidle1;
+        u32 core_cm_autoidle2;
+        u32 core_cm_autoidle3;
+        u32 wkup_cm_autoidle;
+        u32 dss_cm_autoidle;
+        u32 cam_cm_autoidle;
+        u32 per_cm_autoidle;
+        u32 usbhost_cm_autoidle;
+        u32 sgx_cm_sleepdep;
+        u32 dss_cm_sleepdep;
+        u32 cam_cm_sleepdep;
+        u32 per_cm_sleepdep;
+        u32 usbhost_cm_sleepdep;
+        u32 cm_clkout_ctrl;
+        u32 prm_clkout_ctrl;
+        u32 sgx_pm_wkdep;
+        u32 dss_pm_wkdep;
+        u32 cam_pm_wkdep;
+        u32 per_pm_wkdep;
+        u32 neon_pm_wkdep;
+        u32 usbhost_pm_wkdep;
+        u32 core_pm_mpugrpsel1;
+        u32 iva2_pm_ivagrpsel1;
+        u32 core_pm_mpugrpsel3;
+        u32 core_pm_ivagrpsel3;
+        u32 wkup_pm_mpugrpsel;
+        u32 wkup_pm_ivagrpsel;
+        u32 per_pm_mpugrpsel;
+        u32 per_pm_ivagrpsel;
+        u32 wkup_pm_wken;
+};
+
+struct omap3_prcm_regs prcm_context;
+
 u32 omap_prcm_get_reset_sources(void)
 {
         /* XXX This presumably needs modification for 34XX */
@@ -46,9 +135,18 @@ void omap_prcm_arch_reset(char mode)
 
         if (cpu_is_omap24xx())
                 prcm_offs = WKUP_MOD;
-        else if (cpu_is_omap34xx())
+        else if (cpu_is_omap34xx()) {
+                u32 l;
+
                 prcm_offs = OMAP3430_GR_MOD;
-        else
+                l = ('B' << 24) | ('M' << 16) | mode;
+                /* Reserve the first word in scratchpad for communicating
+                 * with the boot ROM. A pointer to a data structure
+                 * describing the boot process can be stored there,
+                 * cf. OMAP34xx TRM, Initialization / Software Booting
+                 * Configuration. */
+                omap_writel(l, OMAP343X_SCRATCHPAD + 4);
+        } else
                 WARN_ON(1);
 
         prm_set_mod_reg_bits(OMAP_RST_DPLL3, prcm_offs, RM_RSTCTRL);
@@ -168,3 +266,308 @@ void __init omap2_set_globals_prcm(struct omap_globals *omap2_globals)
         prm_base = omap2_globals->prm;
         cm_base = omap2_globals->cm;
 }
+
+#ifdef CONFIG_ARCH_OMAP3
+void omap3_prcm_save_context(void)
+{
+        prcm_context.control_padconf_sys_nirq =
+                         omap_ctrl_readl(OMAP343X_CONTROL_PADCONF_SYSNIRQ);
+        prcm_context.iva2_cm_clksel1 =
+                         cm_read_mod_reg(OMAP3430_IVA2_MOD, CM_CLKSEL1);
+        prcm_context.iva2_cm_clksel2 =
+                         cm_read_mod_reg(OMAP3430_IVA2_MOD, CM_CLKSEL2);
+        prcm_context.cm_sysconfig = __raw_readl(OMAP3430_CM_SYSCONFIG);
+        prcm_context.sgx_cm_clksel =
+                         cm_read_mod_reg(OMAP3430ES2_SGX_MOD, CM_CLKSEL);
+        prcm_context.wkup_cm_clksel = cm_read_mod_reg(WKUP_MOD, CM_CLKSEL);
+        prcm_context.dss_cm_clksel =
+                         cm_read_mod_reg(OMAP3430_DSS_MOD, CM_CLKSEL);
+        prcm_context.cam_cm_clksel =
+                         cm_read_mod_reg(OMAP3430_CAM_MOD, CM_CLKSEL);
+        prcm_context.per_cm_clksel =
+                         cm_read_mod_reg(OMAP3430_PER_MOD, CM_CLKSEL);
+        prcm_context.emu_cm_clksel =
+                         cm_read_mod_reg(OMAP3430_EMU_MOD, CM_CLKSEL1);
+        prcm_context.emu_cm_clkstctrl =
+                         cm_read_mod_reg(OMAP3430_EMU_MOD, CM_CLKSTCTRL);
+        prcm_context.pll_cm_autoidle2 =
+                         cm_read_mod_reg(PLL_MOD, CM_AUTOIDLE2);
+        prcm_context.pll_cm_clksel4 =
+                        cm_read_mod_reg(PLL_MOD, OMAP3430ES2_CM_CLKSEL4);
+        prcm_context.pll_cm_clksel5 =
+                         cm_read_mod_reg(PLL_MOD, OMAP3430ES2_CM_CLKSEL5);
+        prcm_context.pll_cm_clken =
+                        cm_read_mod_reg(PLL_MOD, CM_CLKEN);
+        prcm_context.pll_cm_clken2 =
+                        cm_read_mod_reg(PLL_MOD, OMAP3430ES2_CM_CLKEN2);
+        prcm_context.cm_polctrl = __raw_readl(OMAP3430_CM_POLCTRL);
+        prcm_context.iva2_cm_fclken =
+                         cm_read_mod_reg(OMAP3430_IVA2_MOD, CM_FCLKEN);
+        prcm_context.iva2_cm_clken_pll = cm_read_mod_reg(OMAP3430_IVA2_MOD,
+                        OMAP3430_CM_CLKEN_PLL);
+        prcm_context.core_cm_fclken1 =
+                         cm_read_mod_reg(CORE_MOD, CM_FCLKEN1);
+        prcm_context.core_cm_fclken3 =
+                         cm_read_mod_reg(CORE_MOD, OMAP3430ES2_CM_FCLKEN3);
+        prcm_context.sgx_cm_fclken =
+                         cm_read_mod_reg(OMAP3430ES2_SGX_MOD, CM_FCLKEN);
+        prcm_context.wkup_cm_fclken =
+                         cm_read_mod_reg(WKUP_MOD, CM_FCLKEN);
+        prcm_context.dss_cm_fclken =
+                         cm_read_mod_reg(OMAP3430_DSS_MOD, CM_FCLKEN);
+        prcm_context.cam_cm_fclken =
+                         cm_read_mod_reg(OMAP3430_CAM_MOD, CM_FCLKEN);
+        prcm_context.per_cm_fclken =
+                         cm_read_mod_reg(OMAP3430_PER_MOD, CM_FCLKEN);
+        prcm_context.usbhost_cm_fclken =
+                         cm_read_mod_reg(OMAP3430ES2_USBHOST_MOD, CM_FCLKEN);
+        prcm_context.core_cm_iclken1 =
+                         cm_read_mod_reg(CORE_MOD, CM_ICLKEN1);
+        prcm_context.core_cm_iclken2 =
+                         cm_read_mod_reg(CORE_MOD, CM_ICLKEN2);
+        prcm_context.core_cm_iclken3 =
+                         cm_read_mod_reg(CORE_MOD, CM_ICLKEN3);
+        prcm_context.sgx_cm_iclken =
+                         cm_read_mod_reg(OMAP3430ES2_SGX_MOD, CM_ICLKEN);
+        prcm_context.wkup_cm_iclken =
+                         cm_read_mod_reg(WKUP_MOD, CM_ICLKEN);
+        prcm_context.dss_cm_iclken =
+                         cm_read_mod_reg(OMAP3430_DSS_MOD, CM_ICLKEN);
+        prcm_context.cam_cm_iclken =
+                         cm_read_mod_reg(OMAP3430_CAM_MOD, CM_ICLKEN);
+        prcm_context.per_cm_iclken =
+                         cm_read_mod_reg(OMAP3430_PER_MOD, CM_ICLKEN);
+        prcm_context.usbhost_cm_iclken =
+                         cm_read_mod_reg(OMAP3430ES2_USBHOST_MOD, CM_ICLKEN);
+        prcm_context.iva2_cm_autiidle2 =
+                         cm_read_mod_reg(OMAP3430_IVA2_MOD, CM_AUTOIDLE2);
+        prcm_context.mpu_cm_autoidle2 =
+                         cm_read_mod_reg(MPU_MOD, CM_AUTOIDLE2);
+        prcm_context.pll_cm_autoidle =
+                         cm_read_mod_reg(PLL_MOD, CM_AUTOIDLE);
+        prcm_context.iva2_cm_clkstctrl =
+                         cm_read_mod_reg(OMAP3430_IVA2_MOD, CM_CLKSTCTRL);
+        prcm_context.mpu_cm_clkstctrl =
+                         cm_read_mod_reg(MPU_MOD, CM_CLKSTCTRL);
+        prcm_context.core_cm_clkstctrl =
+                         cm_read_mod_reg(CORE_MOD, CM_CLKSTCTRL);
+        prcm_context.sgx_cm_clkstctrl =
+                         cm_read_mod_reg(OMAP3430ES2_SGX_MOD, CM_CLKSTCTRL);
+        prcm_context.dss_cm_clkstctrl =
+                         cm_read_mod_reg(OMAP3430_DSS_MOD, CM_CLKSTCTRL);
+        prcm_context.cam_cm_clkstctrl =
+                         cm_read_mod_reg(OMAP3430_CAM_MOD, CM_CLKSTCTRL);
+        prcm_context.per_cm_clkstctrl =
+                         cm_read_mod_reg(OMAP3430_PER_MOD, CM_CLKSTCTRL);
+        prcm_context.neon_cm_clkstctrl =
+                         cm_read_mod_reg(OMAP3430_NEON_MOD, CM_CLKSTCTRL);
+        prcm_context.usbhost_cm_clkstctrl =
+                         cm_read_mod_reg(OMAP3430ES2_USBHOST_MOD, CM_CLKSTCTRL);
+        prcm_context.core_cm_autoidle1 =
+                         cm_read_mod_reg(CORE_MOD, CM_AUTOIDLE1);
+        prcm_context.core_cm_autoidle2 =
+                         cm_read_mod_reg(CORE_MOD, CM_AUTOIDLE2);
+        prcm_context.core_cm_autoidle3 =
+                         cm_read_mod_reg(CORE_MOD, CM_AUTOIDLE3);
+        prcm_context.wkup_cm_autoidle =
+                         cm_read_mod_reg(WKUP_MOD, CM_AUTOIDLE);
+        prcm_context.dss_cm_autoidle =
+                         cm_read_mod_reg(OMAP3430_DSS_MOD, CM_AUTOIDLE);
+        prcm_context.cam_cm_autoidle =
+                         cm_read_mod_reg(OMAP3430_CAM_MOD, CM_AUTOIDLE);
+        prcm_context.per_cm_autoidle =
+                         cm_read_mod_reg(OMAP3430_PER_MOD, CM_AUTOIDLE);
+        prcm_context.usbhost_cm_autoidle =
+                         cm_read_mod_reg(OMAP3430ES2_USBHOST_MOD, CM_AUTOIDLE);
+        prcm_context.sgx_cm_sleepdep =
+                 cm_read_mod_reg(OMAP3430ES2_SGX_MOD, OMAP3430_CM_SLEEPDEP);
+        prcm_context.dss_cm_sleepdep =
+                 cm_read_mod_reg(OMAP3430_DSS_MOD, OMAP3430_CM_SLEEPDEP);
+        prcm_context.cam_cm_sleepdep =
+                 cm_read_mod_reg(OMAP3430_CAM_MOD, OMAP3430_CM_SLEEPDEP);
+        prcm_context.per_cm_sleepdep =
+                 cm_read_mod_reg(OMAP3430_PER_MOD, OMAP3430_CM_SLEEPDEP);
+        prcm_context.usbhost_cm_sleepdep =
+                 cm_read_mod_reg(OMAP3430ES2_USBHOST_MOD, OMAP3430_CM_SLEEPDEP);
+        prcm_context.cm_clkout_ctrl = cm_read_mod_reg(OMAP3430_CCR_MOD,
+                 OMAP3_CM_CLKOUT_CTRL_OFFSET);
+        prcm_context.prm_clkout_ctrl = prm_read_mod_reg(OMAP3430_CCR_MOD,
+                OMAP3_PRM_CLKOUT_CTRL_OFFSET);
+        prcm_context.sgx_pm_wkdep =
+                 prm_read_mod_reg(OMAP3430ES2_SGX_MOD, PM_WKDEP);
+        prcm_context.dss_pm_wkdep =
+                 prm_read_mod_reg(OMAP3430_DSS_MOD, PM_WKDEP);
+        prcm_context.cam_pm_wkdep =
+                 prm_read_mod_reg(OMAP3430_CAM_MOD, PM_WKDEP);
+        prcm_context.per_pm_wkdep =
+                 prm_read_mod_reg(OMAP3430_PER_MOD, PM_WKDEP);
+        prcm_context.neon_pm_wkdep =
+                 prm_read_mod_reg(OMAP3430_NEON_MOD, PM_WKDEP);
+        prcm_context.usbhost_pm_wkdep =
+                 prm_read_mod_reg(OMAP3430ES2_USBHOST_MOD, PM_WKDEP);
+        prcm_context.core_pm_mpugrpsel1 =
+                 prm_read_mod_reg(CORE_MOD, OMAP3430_PM_MPUGRPSEL1);
+        prcm_context.iva2_pm_ivagrpsel1 =
+                 prm_read_mod_reg(OMAP3430_IVA2_MOD, OMAP3430_PM_IVAGRPSEL1);
+        prcm_context.core_pm_mpugrpsel3 =
+                 prm_read_mod_reg(CORE_MOD, OMAP3430ES2_PM_MPUGRPSEL3);
+        prcm_context.core_pm_ivagrpsel3 =
+                 prm_read_mod_reg(CORE_MOD, OMAP3430ES2_PM_IVAGRPSEL3);
+        prcm_context.wkup_pm_mpugrpsel =
+                 prm_read_mod_reg(WKUP_MOD, OMAP3430_PM_MPUGRPSEL);
+        prcm_context.wkup_pm_ivagrpsel =
+                 prm_read_mod_reg(WKUP_MOD, OMAP3430_PM_IVAGRPSEL);
+        prcm_context.per_pm_mpugrpsel =
+                 prm_read_mod_reg(OMAP3430_PER_MOD, OMAP3430_PM_MPUGRPSEL);
+        prcm_context.per_pm_ivagrpsel =
+                 prm_read_mod_reg(OMAP3430_PER_MOD, OMAP3430_PM_IVAGRPSEL);
+        prcm_context.wkup_pm_wken = prm_read_mod_reg(WKUP_MOD, PM_WKEN);
+        return;
+}
+
+void omap3_prcm_restore_context(void)
+{
+        omap_ctrl_writel(prcm_context.control_padconf_sys_nirq,
+                                         OMAP343X_CONTROL_PADCONF_SYSNIRQ);
+        cm_write_mod_reg(prcm_context.iva2_cm_clksel1, OMAP3430_IVA2_MOD,
+                                         CM_CLKSEL1);
+        cm_write_mod_reg(prcm_context.iva2_cm_clksel2, OMAP3430_IVA2_MOD,
+                                         CM_CLKSEL2);
+        __raw_writel(prcm_context.cm_sysconfig, OMAP3430_CM_SYSCONFIG);
+        cm_write_mod_reg(prcm_context.sgx_cm_clksel, OMAP3430ES2_SGX_MOD,
+                                         CM_CLKSEL);
+        cm_write_mod_reg(prcm_context.wkup_cm_clksel, WKUP_MOD, CM_CLKSEL);
+        cm_write_mod_reg(prcm_context.dss_cm_clksel, OMAP3430_DSS_MOD,
+                                         CM_CLKSEL);
+        cm_write_mod_reg(prcm_context.cam_cm_clksel, OMAP3430_CAM_MOD,
+                                         CM_CLKSEL);
+        cm_write_mod_reg(prcm_context.per_cm_clksel, OMAP3430_PER_MOD,
+                                         CM_CLKSEL);
+        cm_write_mod_reg(prcm_context.emu_cm_clksel, OMAP3430_EMU_MOD,
+                                         CM_CLKSEL1);
+        cm_write_mod_reg(prcm_context.emu_cm_clkstctrl, OMAP3430_EMU_MOD,
+                                         CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.pll_cm_autoidle2, PLL_MOD,
+                                         CM_AUTOIDLE2);
+        cm_write_mod_reg(prcm_context.pll_cm_clksel4, PLL_MOD,
+                                        OMAP3430ES2_CM_CLKSEL4);
+        cm_write_mod_reg(prcm_context.pll_cm_clksel5, PLL_MOD,
+                                         OMAP3430ES2_CM_CLKSEL5);
+        cm_write_mod_reg(prcm_context.pll_cm_clken, PLL_MOD, CM_CLKEN);
+        cm_write_mod_reg(prcm_context.pll_cm_clken2, PLL_MOD,
+                                        OMAP3430ES2_CM_CLKEN2);
+        __raw_writel(prcm_context.cm_polctrl, OMAP3430_CM_POLCTRL);
+        cm_write_mod_reg(prcm_context.iva2_cm_fclken, OMAP3430_IVA2_MOD,
+                                         CM_FCLKEN);
+        cm_write_mod_reg(prcm_context.iva2_cm_clken_pll, OMAP3430_IVA2_MOD,
+                                        OMAP3430_CM_CLKEN_PLL);
+        cm_write_mod_reg(prcm_context.core_cm_fclken1, CORE_MOD, CM_FCLKEN1);
+        cm_write_mod_reg(prcm_context.core_cm_fclken3, CORE_MOD,
+                                         OMAP3430ES2_CM_FCLKEN3);
+        cm_write_mod_reg(prcm_context.sgx_cm_fclken, OMAP3430ES2_SGX_MOD,
+                                         CM_FCLKEN);
+        cm_write_mod_reg(prcm_context.wkup_cm_fclken, WKUP_MOD, CM_FCLKEN);
+        cm_write_mod_reg(prcm_context.dss_cm_fclken, OMAP3430_DSS_MOD,
+                                         CM_FCLKEN);
+        cm_write_mod_reg(prcm_context.cam_cm_fclken, OMAP3430_CAM_MOD,
+                                         CM_FCLKEN);
+        cm_write_mod_reg(prcm_context.per_cm_fclken, OMAP3430_PER_MOD,
+                                         CM_FCLKEN);
+        cm_write_mod_reg(prcm_context.usbhost_cm_fclken,
+                                         OMAP3430ES2_USBHOST_MOD, CM_FCLKEN);
+        cm_write_mod_reg(prcm_context.core_cm_iclken1, CORE_MOD, CM_ICLKEN1);
+        cm_write_mod_reg(prcm_context.core_cm_iclken2, CORE_MOD, CM_ICLKEN2);
+        cm_write_mod_reg(prcm_context.core_cm_iclken3, CORE_MOD, CM_ICLKEN3);
+        cm_write_mod_reg(prcm_context.sgx_cm_iclken, OMAP3430ES2_SGX_MOD,
+                                        CM_ICLKEN);
+        cm_write_mod_reg(prcm_context.wkup_cm_iclken, WKUP_MOD, CM_ICLKEN);
+        cm_write_mod_reg(prcm_context.dss_cm_iclken, OMAP3430_DSS_MOD,
+                                        CM_ICLKEN);
+        cm_write_mod_reg(prcm_context.cam_cm_iclken, OMAP3430_CAM_MOD,
+                                        CM_ICLKEN);
+        cm_write_mod_reg(prcm_context.per_cm_iclken, OMAP3430_PER_MOD,
+                                        CM_ICLKEN);
+        cm_write_mod_reg(prcm_context.usbhost_cm_iclken,
+                                        OMAP3430ES2_USBHOST_MOD, CM_ICLKEN);
+        cm_write_mod_reg(prcm_context.iva2_cm_autiidle2, OMAP3430_IVA2_MOD,
+                                        CM_AUTOIDLE2);
+        cm_write_mod_reg(prcm_context.mpu_cm_autoidle2, MPU_MOD, CM_AUTOIDLE2);
+        cm_write_mod_reg(prcm_context.pll_cm_autoidle, PLL_MOD, CM_AUTOIDLE);
+        cm_write_mod_reg(prcm_context.iva2_cm_clkstctrl, OMAP3430_IVA2_MOD,
+                                        CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.mpu_cm_clkstctrl, MPU_MOD, CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.core_cm_clkstctrl, CORE_MOD,
+                                        CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.sgx_cm_clkstctrl, OMAP3430ES2_SGX_MOD,
+                                        CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.dss_cm_clkstctrl, OMAP3430_DSS_MOD,
+                                        CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.cam_cm_clkstctrl, OMAP3430_CAM_MOD,
+                                        CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.per_cm_clkstctrl, OMAP3430_PER_MOD,
+                                        CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.neon_cm_clkstctrl, OMAP3430_NEON_MOD,
+                                        CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.usbhost_cm_clkstctrl,
+                                        OMAP3430ES2_USBHOST_MOD, CM_CLKSTCTRL);
+        cm_write_mod_reg(prcm_context.core_cm_autoidle1, CORE_MOD,
+                                        CM_AUTOIDLE1);
+        cm_write_mod_reg(prcm_context.core_cm_autoidle2, CORE_MOD,
+                                        CM_AUTOIDLE2);
+        cm_write_mod_reg(prcm_context.core_cm_autoidle3, CORE_MOD,
+                                        CM_AUTOIDLE3);
+        cm_write_mod_reg(prcm_context.wkup_cm_autoidle, WKUP_MOD, CM_AUTOIDLE);
+        cm_write_mod_reg(prcm_context.dss_cm_autoidle, OMAP3430_DSS_MOD,
+                                        CM_AUTOIDLE);
+        cm_write_mod_reg(prcm_context.cam_cm_autoidle, OMAP3430_CAM_MOD,
+                                        CM_AUTOIDLE);
+        cm_write_mod_reg(prcm_context.per_cm_autoidle, OMAP3430_PER_MOD,
+                                        CM_AUTOIDLE);
+        cm_write_mod_reg(prcm_context.usbhost_cm_autoidle,
+                                        OMAP3430ES2_USBHOST_MOD, CM_AUTOIDLE);
+        cm_write_mod_reg(prcm_context.sgx_cm_sleepdep, OMAP3430ES2_SGX_MOD,
+                                        OMAP3430_CM_SLEEPDEP);
+        cm_write_mod_reg(prcm_context.dss_cm_sleepdep, OMAP3430_DSS_MOD,
+                                        OMAP3430_CM_SLEEPDEP);
+        cm_write_mod_reg(prcm_context.cam_cm_sleepdep, OMAP3430_CAM_MOD,
+                                        OMAP3430_CM_SLEEPDEP);
+        cm_write_mod_reg(prcm_context.per_cm_sleepdep, OMAP3430_PER_MOD,
+                                        OMAP3430_CM_SLEEPDEP);
+        cm_write_mod_reg(prcm_context.usbhost_cm_sleepdep,
+                                OMAP3430ES2_USBHOST_MOD, OMAP3430_CM_SLEEPDEP);
+        cm_write_mod_reg(prcm_context.cm_clkout_ctrl, OMAP3430_CCR_MOD,
+                                        OMAP3_CM_CLKOUT_CTRL_OFFSET);
+        prm_write_mod_reg(prcm_context.prm_clkout_ctrl, OMAP3430_CCR_MOD,
+                                        OMAP3_PRM_CLKOUT_CTRL_OFFSET);
+        prm_write_mod_reg(prcm_context.sgx_pm_wkdep, OMAP3430ES2_SGX_MOD,
+                                        PM_WKDEP);
+        prm_write_mod_reg(prcm_context.dss_pm_wkdep, OMAP3430_DSS_MOD,
+                                        PM_WKDEP);
+        prm_write_mod_reg(prcm_context.cam_pm_wkdep, OMAP3430_CAM_MOD,
+                                        PM_WKDEP);
+        prm_write_mod_reg(prcm_context.per_pm_wkdep, OMAP3430_PER_MOD,
+                                        PM_WKDEP);
+        prm_write_mod_reg(prcm_context.neon_pm_wkdep, OMAP3430_NEON_MOD,
+                                        PM_WKDEP);
+        prm_write_mod_reg(prcm_context.usbhost_pm_wkdep,
+                                        OMAP3430ES2_USBHOST_MOD, PM_WKDEP);
+        prm_write_mod_reg(prcm_context.core_pm_mpugrpsel1, CORE_MOD,
+                                        OMAP3430_PM_MPUGRPSEL1);
+        prm_write_mod_reg(prcm_context.iva2_pm_ivagrpsel1, OMAP3430_IVA2_MOD,
+                                        OMAP3430_PM_IVAGRPSEL1);
+        prm_write_mod_reg(prcm_context.core_pm_mpugrpsel3, CORE_MOD,
+                                        OMAP3430ES2_PM_MPUGRPSEL3);
+        prm_write_mod_reg(prcm_context.core_pm_ivagrpsel3, CORE_MOD,
+                                        OMAP3430ES2_PM_IVAGRPSEL3);
+        prm_write_mod_reg(prcm_context.wkup_pm_mpugrpsel, WKUP_MOD,
+                                        OMAP3430_PM_MPUGRPSEL);
+        prm_write_mod_reg(prcm_context.wkup_pm_ivagrpsel, WKUP_MOD,
+                                        OMAP3430_PM_IVAGRPSEL);
+        prm_write_mod_reg(prcm_context.per_pm_mpugrpsel, OMAP3430_PER_MOD,
+                                        OMAP3430_PM_MPUGRPSEL);
+        prm_write_mod_reg(prcm_context.per_pm_ivagrpsel, OMAP3430_PER_MOD,
+                                         OMAP3430_PM_IVAGRPSEL);
+        prm_write_mod_reg(prcm_context.wkup_pm_wken, WKUP_MOD, PM_WKEN);
+        return;
+}
+#endif
diff --git a/arch/arm/mach-omap2/prm-regbits-34xx.h b/arch/arm/mach-omap2/prm-regbits-34xx.h
index 9fd03a2ec95c..8f21bae6dc1c 100644
--- a/arch/arm/mach-omap2/prm-regbits-34xx.h
+++ b/arch/arm/mach-omap2/prm-regbits-34xx.h
@@ -365,6 +365,7 @@
 /* PM_PREPWSTST_GFX specific bits */
 
 /* PM_WKEN_WKUP specific bits */
+#define OMAP3430_EN_IO_CHAIN                            (1 << 16)
 #define OMAP3430_EN_IO                                  (1 << 8)
 #define OMAP3430_EN_GPIO1                               (1 << 3)
 
@@ -373,6 +374,7 @@
 /* PM_IVA2GRPSEL_WKUP specific bits */
 
 /* PM_WKST_WKUP specific bits */
+#define OMAP3430_ST_IO_CHAIN                            (1 << 16)
 #define OMAP3430_ST_IO                                  (1 << 8)
 
 /* PRM_CLKSEL */
diff --git a/arch/arm/mach-omap2/prm.h b/arch/arm/mach-omap2/prm.h
index 03c467c35f54..a117f853ea39 100644
--- a/arch/arm/mach-omap2/prm.h
+++ b/arch/arm/mach-omap2/prm.h
@@ -17,11 +17,11 @@
 #include "prcm-common.h"
 
 #define OMAP2420_PRM_REGADDR(module, reg)                               \
-                        OMAP2_IO_ADDRESS(OMAP2420_PRM_BASE + (module) + (reg))
+                OMAP2_L4_IO_ADDRESS(OMAP2420_PRM_BASE + (module) + (reg))
 #define OMAP2430_PRM_REGADDR(module, reg)                               \
-                        OMAP2_IO_ADDRESS(OMAP2430_PRM_BASE + (module) + (reg))
+                OMAP2_L4_IO_ADDRESS(OMAP2430_PRM_BASE + (module) + (reg))
 #define OMAP34XX_PRM_REGADDR(module, reg)                               \
-                        OMAP2_IO_ADDRESS(OMAP3430_PRM_BASE + (module) + (reg))
+                OMAP2_L4_IO_ADDRESS(OMAP3430_PRM_BASE + (module) + (reg))
 
 /*
  * Architecture-specific global PRM registers
diff --git a/arch/arm/mach-omap2/sdram-hynix-h8mbx00u0mer-0em.h b/arch/arm/mach-omap2/sdram-hynix-h8mbx00u0mer-0em.h
new file mode 100644
index 000000000000..8bfaf342a028
--- /dev/null
+++ b/arch/arm/mach-omap2/sdram-hynix-h8mbx00u0mer-0em.h
@@ -0,0 +1,51 @@
+/*
+ * SDRC register values for the Hynix H8MBX00U0MER-0EM
+ *
+ * Copyright (C) 2009 Texas Instruments, Inc.
+ *
+ * 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.
+ */
+
+#ifndef __ARCH_ARM_MACH_OMAP2_SDRAM_HYNIX_H8MBX00U0MER0EM
+#define __ARCH_ARM_MACH_OMAP2_SDRAM_HYNIX_H8MBX00U0MER0EM
+
+#include <plat/sdrc.h>
+
+/* Hynix H8MBX00U0MER-0EM */
+static struct omap_sdrc_params h8mbx00u0mer0em_sdrc_params[] = {
+        [0] = {
+                .rate        = 200000000,
+                .actim_ctrla = 0xa2e1b4c6,
+                .actim_ctrlb = 0x0002131c,
+                .rfr_ctrl    = 0x0005e601,
+                .mr          = 0x00000032,
+        },
+        [1] = {
+                .rate        = 166000000,
+                .actim_ctrla = 0x629db4c6,
+                .actim_ctrlb = 0x00012214,
+                .rfr_ctrl    = 0x0004dc01,
+                .mr          = 0x00000032,
+        },
+        [2] = {
+                .rate        = 100000000,
+                .actim_ctrla = 0x51912284,
+                .actim_ctrlb = 0x0002120e,
+                .rfr_ctrl    = 0x0002d101,
+                .mr          = 0x00000022,
+        },
+        [3] = {
+                .rate        = 83000000,
+                .actim_ctrla = 0x31512283,
+                .actim_ctrlb = 0x0001220a,
+                .rfr_ctrl    = 0x00025501,
+                .mr          = 0x00000022,
+        },
+        [4] = {
+                .rate        = 0
+        },
+};
+
+#endif
diff --git a/arch/arm/mach-omap2/sdram-micron-mt46h32m32lf-6.h b/arch/arm/mach-omap2/sdram-micron-mt46h32m32lf-6.h
index 02e1c2d4705f..a391b4939f74 100644
--- a/arch/arm/mach-omap2/sdram-micron-mt46h32m32lf-6.h
+++ b/arch/arm/mach-omap2/sdram-micron-mt46h32m32lf-6.h
@@ -14,7 +14,7 @@
 #ifndef ARCH_ARM_MACH_OMAP2_SDRAM_MICRON_MT46H32M32LF
 #define ARCH_ARM_MACH_OMAP2_SDRAM_MICRON_MT46H32M32LF
 
-#include <mach/sdrc.h>
+#include <plat/sdrc.h>
 
 /* Micron MT46H32M32LF-6 */
 /* XXX Using ARE = 0x1 (no autorefresh burst) -- can this be changed? */
diff --git a/arch/arm/mach-omap2/sdram-qimonda-hyb18m512160af-6.h b/arch/arm/mach-omap2/sdram-qimonda-hyb18m512160af-6.h
index 3751d293cb1f..0e518a72831f 100644
--- a/arch/arm/mach-omap2/sdram-qimonda-hyb18m512160af-6.h
+++ b/arch/arm/mach-omap2/sdram-qimonda-hyb18m512160af-6.h
@@ -14,7 +14,7 @@
 #ifndef ARCH_ARM_MACH_OMAP2_SDRAM_QIMONDA_HYB18M512160AF6
 #define ARCH_ARM_MACH_OMAP2_SDRAM_QIMONDA_HYB18M512160AF6
 
-#include <mach/sdrc.h>
+#include <plat/sdrc.h>
 
 /* Qimonda HYB18M512160AF-6 */
 static struct omap_sdrc_params hyb18m512160af6_sdrc_params[] = {
diff --git a/arch/arm/mach-omap2/sdrc.c b/arch/arm/mach-omap2/sdrc.c
index 9e3bd4fa7810..9a592199321c 100644
--- a/arch/arm/mach-omap2/sdrc.c
+++ b/arch/arm/mach-omap2/sdrc.c
@@ -23,13 +23,13 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 
-#include <mach/common.h>
-#include <mach/clock.h>
-#include <mach/sram.h>
+#include <plat/common.h>
+#include <plat/clock.h>
+#include <plat/sram.h>
 
 #include "prm.h"
 
-#include <mach/sdrc.h>
+#include <plat/sdrc.h>
 #include "sdrc.h"
 
 static struct omap_sdrc_params *sdrc_init_params_cs0, *sdrc_init_params_cs1;
@@ -37,12 +37,38 @@ static struct omap_sdrc_params *sdrc_init_params_cs0, *sdrc_init_params_cs1;
 void __iomem *omap2_sdrc_base;
 void __iomem *omap2_sms_base;
 
+struct omap2_sms_regs {
+        u32     sms_sysconfig;
+};
+
+static struct omap2_sms_regs sms_context;
+
 /* SDRC_POWER register bits */
 #define SDRC_POWER_EXTCLKDIS_SHIFT              3
 #define SDRC_POWER_PWDENA_SHIFT                 2
 #define SDRC_POWER_PAGEPOLICY_SHIFT             0
 
 /**
+ * omap2_sms_save_context - Save SMS registers
+ *
+ * Save SMS registers that need to be restored after off mode.
+ */
+void omap2_sms_save_context(void)
+{
+        sms_context.sms_sysconfig = sms_read_reg(SMS_SYSCONFIG);
+}
+
+/**
+ * omap2_sms_restore_context - Restore SMS registers
+ *
+ * Restore SMS registers that need to be Restored after off mode.
+ */
+void omap2_sms_restore_context(void)
+{
+        sms_write_reg(sms_context.sms_sysconfig, SMS_SYSCONFIG);
+}
+
+/**
  * omap2_sdrc_get_params - return SDRC register values for a given clock rate
  * @r: SDRC clock rate (in Hz)
  * @sdrc_cs0: chip select 0 ram timings **
@@ -132,4 +158,5 @@ void __init omap2_sdrc_init(struct omap_sdrc_params *sdrc_cs0,
         l = (1 << SDRC_POWER_EXTCLKDIS_SHIFT) |
                 (1 << SDRC_POWER_PAGEPOLICY_SHIFT);
         sdrc_write_reg(l, SDRC_POWER);
+        omap2_sms_save_context();
 }
diff --git a/arch/arm/mach-omap2/sdrc.h b/arch/arm/mach-omap2/sdrc.h
index 0837eda5f2b6..48207b018989 100644
--- a/arch/arm/mach-omap2/sdrc.h
+++ b/arch/arm/mach-omap2/sdrc.h
@@ -15,7 +15,7 @@
  */
 #undef DEBUG
 
-#include <mach/sdrc.h>
+#include <plat/sdrc.h>
 
 #ifndef __ASSEMBLER__
 extern void __iomem *omap2_sdrc_base;
@@ -48,9 +48,12 @@ static inline u32 sms_read_reg(u16 reg)
         return __raw_readl(OMAP_SMS_REGADDR(reg));
 }
 #else
-#define OMAP242X_SDRC_REGADDR(reg)      OMAP2_IO_ADDRESS(OMAP2420_SDRC_BASE + (reg))
-#define OMAP243X_SDRC_REGADDR(reg)      OMAP2_IO_ADDRESS(OMAP243X_SDRC_BASE + (reg))
-#define OMAP34XX_SDRC_REGADDR(reg)      OMAP2_IO_ADDRESS(OMAP343X_SDRC_BASE + (reg))
+#define OMAP242X_SDRC_REGADDR(reg)                                      \
+                        OMAP2_L3_IO_ADDRESS(OMAP2420_SDRC_BASE + (reg))
+#define OMAP243X_SDRC_REGADDR(reg)                                      \
+                        OMAP2_L3_IO_ADDRESS(OMAP243X_SDRC_BASE + (reg))
+#define OMAP34XX_SDRC_REGADDR(reg)                                      \
+                        OMAP2_L3_IO_ADDRESS(OMAP343X_SDRC_BASE + (reg))
 #endif  /* __ASSEMBLER__ */
 
 #endif
diff --git a/arch/arm/mach-omap2/sdrc2xxx.c b/arch/arm/mach-omap2/sdrc2xxx.c
index feaec7eaf6bd..0f4d27aef44d 100644
--- a/arch/arm/mach-omap2/sdrc2xxx.c
+++ b/arch/arm/mach-omap2/sdrc2xxx.c
@@ -24,13 +24,13 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 
-#include <mach/common.h>
-#include <mach/clock.h>
-#include <mach/sram.h>
+#include <plat/common.h>
+#include <plat/clock.h>
+#include <plat/sram.h>
 
 #include "prm.h"
 #include "clock.h"
-#include <mach/sdrc.h>
+#include <plat/sdrc.h>
 #include "sdrc.h"
 
 /* Memory timing, DLL mode flags */
diff --git a/arch/arm/mach-omap2/serial.c b/arch/arm/mach-omap2/serial.c
index ae2186892c85..2e17b57f5b23 100644
--- a/arch/arm/mach-omap2/serial.c
+++ b/arch/arm/mach-omap2/serial.c
@@ -24,10 +24,10 @@
 #include <linux/clk.h>
 #include <linux/io.h>
 
-#include <mach/common.h>
-#include <mach/board.h>
-#include <mach/clock.h>
-#include <mach/control.h>
+#include <plat/common.h>
+#include <plat/board.h>
+#include <plat/clock.h>
+#include <plat/control.h>
 
 #include "prm.h"
 #include "pm.h"
@@ -73,7 +73,6 @@ static LIST_HEAD(uart_list);
 
 static struct plat_serial8250_port serial_platform_data0[] = {
         {
-                .membase        = OMAP2_IO_ADDRESS(OMAP_UART1_BASE),
                 .mapbase        = OMAP_UART1_BASE,
                 .irq            = 72,
                 .flags          = UPF_BOOT_AUTOCONF,
@@ -87,7 +86,6 @@ static struct plat_serial8250_port serial_platform_data0[] = {
 
 static struct plat_serial8250_port serial_platform_data1[] = {
         {
-                .membase        = OMAP2_IO_ADDRESS(OMAP_UART2_BASE),
                 .mapbase        = OMAP_UART2_BASE,
                 .irq            = 73,
                 .flags          = UPF_BOOT_AUTOCONF,
@@ -101,7 +99,6 @@ static struct plat_serial8250_port serial_platform_data1[] = {
 
 static struct plat_serial8250_port serial_platform_data2[] = {
         {
-                .membase        = OMAP2_IO_ADDRESS(OMAP_UART3_BASE),
                 .mapbase        = OMAP_UART3_BASE,
                 .irq            = 74,
                 .flags          = UPF_BOOT_AUTOCONF,
@@ -109,16 +106,6 @@ static struct plat_serial8250_port serial_platform_data2[] = {
                 .regshift       = 2,
                 .uartclk        = OMAP24XX_BASE_BAUD * 16,
         }, {
-#ifdef CONFIG_ARCH_OMAP4
-                .membase        = OMAP2_IO_ADDRESS(OMAP_UART4_BASE),
-                .mapbase        = OMAP_UART4_BASE,
-                .irq            = 70,
-                .flags          = UPF_BOOT_AUTOCONF,
-                .iotype         = UPIO_MEM,
-                .regshift       = 2,
-                .uartclk        = OMAP24XX_BASE_BAUD * 16,
-        }, {
-#endif
                 .flags          = 0
         }
 };
@@ -126,7 +113,6 @@ static struct plat_serial8250_port serial_platform_data2[] = {
 #ifdef CONFIG_ARCH_OMAP4
 static struct plat_serial8250_port serial_platform_data3[] = {
         {
-                .membase        = OMAP2_IO_ADDRESS(OMAP_UART4_BASE),
                 .mapbase        = OMAP_UART4_BASE,
                 .irq            = 70,
                 .flags          = UPF_BOOT_AUTOCONF,
@@ -169,8 +155,6 @@ static inline void __init omap_uart_reset(struct omap_uart_state *uart)
 
 #if defined(CONFIG_PM) && defined(CONFIG_ARCH_OMAP3)
 
-static int enable_off_mode; /* to be removed by full off-mode patches */
-
 static void omap_uart_save_context(struct omap_uart_state *uart)
 {
         u16 lcr = 0;
@@ -549,7 +533,7 @@ static inline void omap_uart_idle_init(struct omap_uart_state *uart) {}
 #define DEV_CREATE_FILE(dev, attr)
 #endif /* CONFIG_PM */
 
-static struct omap_uart_state omap_uart[OMAP_MAX_NR_PORTS] = {
+static struct omap_uart_state omap_uart[] = {
         {
                 .pdev = {
                         .name                   = "serial8250",
@@ -599,12 +583,22 @@ void __init omap_serial_early_init(void)
          * if not needed.
          */
 
-        for (i = 0; i < OMAP_MAX_NR_PORTS; i++) {
+        for (i = 0; i < ARRAY_SIZE(omap_uart); i++) {
                 struct omap_uart_state *uart = &omap_uart[i];
                 struct platform_device *pdev = &uart->pdev;
                 struct device *dev = &pdev->dev;
                 struct plat_serial8250_port *p = dev->platform_data;
 
+                /*
+                 * Module 4KB + L4 interconnect 4KB
+                 * Static mapping, never released
+                 */
+                p->membase = ioremap(p->mapbase, SZ_8K);
+                if (!p->membase) {
+                        printk(KERN_ERR "ioremap failed for uart%i\n", i + 1);
+                        continue;
+                }
+
                 sprintf(name, "uart%d_ick", i+1);
                 uart->ick = clk_get(NULL, name);
                 if (IS_ERR(uart->ick)) {
@@ -641,7 +635,7 @@ void __init omap_serial_init(void)
 {
         int i;
 
-        for (i = 0; i < OMAP_MAX_NR_PORTS; i++) {
+        for (i = 0; i < ARRAY_SIZE(omap_uart); i++) {
                 struct omap_uart_state *uart = &omap_uart[i];
                 struct platform_device *pdev = &uart->pdev;
                 struct device *dev = &pdev->dev;
diff --git a/arch/arm/mach-omap2/sleep24xx.S b/arch/arm/mach-omap2/sleep24xx.S
index 130aadbfa083..c7780cc8d919 100644
--- a/arch/arm/mach-omap2/sleep24xx.S
+++ b/arch/arm/mach-omap2/sleep24xx.S
@@ -29,7 +29,7 @@
 #include <asm/assembler.h>
 #include <mach/io.h>
 
-#include <mach/omap24xx.h>
+#include <plat/omap24xx.h>
 
 #include "sdrc.h"
 
diff --git a/arch/arm/mach-omap2/sleep34xx.S b/arch/arm/mach-omap2/sleep34xx.S
index e5e2553e79a6..15268f8b61de 100644
--- a/arch/arm/mach-omap2/sleep34xx.S
+++ b/arch/arm/mach-omap2/sleep34xx.S
@@ -27,22 +27,35 @@
 #include <linux/linkage.h>
 #include <asm/assembler.h>
 #include <mach/io.h>
-#include <mach/control.h>
+#include <plat/control.h>
 
+#include "cm.h"
 #include "prm.h"
 #include "sdrc.h"
 
 #define PM_PREPWSTST_CORE_V     OMAP34XX_PRM_REGADDR(CORE_MOD, \
                                 OMAP3430_PM_PREPWSTST)
+#define PM_PREPWSTST_CORE_P     0x48306AE8
 #define PM_PREPWSTST_MPU_V      OMAP34XX_PRM_REGADDR(MPU_MOD, \
                                 OMAP3430_PM_PREPWSTST)
-#define PM_PWSTCTRL_MPU_P       OMAP34XX_PRM_REGADDR(MPU_MOD, PM_PWSTCTRL)
+#define PM_PWSTCTRL_MPU_P       OMAP3430_PRM_BASE + MPU_MOD + PM_PWSTCTRL
+#define CM_IDLEST1_CORE_V       OMAP34XX_CM_REGADDR(CORE_MOD, CM_IDLEST1)
+#define SRAM_BASE_P             0x40200000
+#define CONTROL_STAT            0x480022F0
 #define SCRATCHPAD_MEM_OFFS     0x310 /* Move this as correct place is
                                        * available */
-#define SCRATCHPAD_BASE_P       OMAP343X_CTRL_REGADDR(\
-                                OMAP343X_CONTROL_MEM_WKUP +\
-                                SCRATCHPAD_MEM_OFFS)
+#define SCRATCHPAD_BASE_P       (OMAP343X_CTRL_BASE + OMAP343X_CONTROL_MEM_WKUP\
+                                                + SCRATCHPAD_MEM_OFFS)
 #define SDRC_POWER_V            OMAP34XX_SDRC_REGADDR(SDRC_POWER)
+#define SDRC_SYSCONFIG_P        (OMAP343X_SDRC_BASE + SDRC_SYSCONFIG)
+#define SDRC_MR_0_P             (OMAP343X_SDRC_BASE + SDRC_MR_0)
+#define SDRC_EMR2_0_P           (OMAP343X_SDRC_BASE + SDRC_EMR2_0)
+#define SDRC_MANUAL_0_P         (OMAP343X_SDRC_BASE + SDRC_MANUAL_0)
+#define SDRC_MR_1_P             (OMAP343X_SDRC_BASE + SDRC_MR_1)
+#define SDRC_EMR2_1_P           (OMAP343X_SDRC_BASE + SDRC_EMR2_1)
+#define SDRC_MANUAL_1_P         (OMAP343X_SDRC_BASE + SDRC_MANUAL_1)
+#define SDRC_DLLA_STATUS_V      OMAP34XX_SDRC_REGADDR(SDRC_DLLA_STATUS)
+#define SDRC_DLLA_CTRL_V        OMAP34XX_SDRC_REGADDR(SDRC_DLLA_CTRL)
 
         .text
 /* Function call to get the restore pointer for resume from OFF */
@@ -51,7 +64,93 @@ ENTRY(get_restore_pointer)
         adr     r0, restore
         ldmfd   sp!, {pc}     @ restore regs and return
 ENTRY(get_restore_pointer_sz)
-        .word   . - get_restore_pointer_sz
+        .word   . - get_restore_pointer
+
+        .text
+/* Function call to get the restore pointer for for ES3 to resume from OFF */
+ENTRY(get_es3_restore_pointer)
+        stmfd   sp!, {lr}       @ save registers on stack
+        adr     r0, restore_es3
+        ldmfd   sp!, {pc}       @ restore regs and return
+ENTRY(get_es3_restore_pointer_sz)
+        .word   . - get_es3_restore_pointer
+
+ENTRY(es3_sdrc_fix)
+        ldr     r4, sdrc_syscfg         @ get config addr
+        ldr     r5, [r4]                @ get value
+        tst     r5, #0x100              @ is part access blocked
+        it      eq
+        biceq   r5, r5, #0x100          @ clear bit if set
+        str     r5, [r4]                @ write back change
+        ldr     r4, sdrc_mr_0           @ get config addr
+        ldr     r5, [r4]                @ get value
+        str     r5, [r4]                @ write back change
+        ldr     r4, sdrc_emr2_0         @ get config addr
+        ldr     r5, [r4]                @ get value
+        str     r5, [r4]                @ write back change
+        ldr     r4, sdrc_manual_0       @ get config addr
+        mov     r5, #0x2                @ autorefresh command
+        str     r5, [r4]                @ kick off refreshes
+        ldr     r4, sdrc_mr_1           @ get config addr
+        ldr     r5, [r4]                @ get value
+        str     r5, [r4]                @ write back change
+        ldr     r4, sdrc_emr2_1         @ get config addr
+        ldr     r5, [r4]                @ get value
+        str     r5, [r4]                @ write back change
+        ldr     r4, sdrc_manual_1       @ get config addr
+        mov     r5, #0x2                @ autorefresh command
+        str     r5, [r4]                @ kick off refreshes
+        bx      lr
+sdrc_syscfg:
+        .word   SDRC_SYSCONFIG_P
+sdrc_mr_0:
+        .word   SDRC_MR_0_P
+sdrc_emr2_0:
+        .word   SDRC_EMR2_0_P
+sdrc_manual_0:
+        .word   SDRC_MANUAL_0_P
+sdrc_mr_1:
+        .word   SDRC_MR_1_P
+sdrc_emr2_1:
+        .word   SDRC_EMR2_1_P
+sdrc_manual_1:
+        .word   SDRC_MANUAL_1_P
+ENTRY(es3_sdrc_fix_sz)
+        .word   . - es3_sdrc_fix
+
+/* Function to call rom code to save secure ram context */
+ENTRY(save_secure_ram_context)
+        stmfd   sp!, {r1-r12, lr}       @ save registers on stack
+save_secure_ram_debug:
+        /* b save_secure_ram_debug */   @ enable to debug save code
+        adr     r3, api_params          @ r3 points to parameters
+        str     r0, [r3,#0x4]           @ r0 has sdram address
+        ldr     r12, high_mask
+        and     r3, r3, r12
+        ldr     r12, sram_phy_addr_mask
+        orr     r3, r3, r12
+        mov     r0, #25                 @ set service ID for PPA
+        mov     r12, r0                 @ copy secure service ID in r12
+        mov     r1, #0                  @ set task id for ROM code in r1
+        mov     r2, #4                  @ set some flags in r2, r6
+        mov     r6, #0xff
+        mcr     p15, 0, r0, c7, c10, 4  @ data write barrier
+        mcr     p15, 0, r0, c7, c10, 5  @ data memory barrier
+        .word   0xE1600071              @ call SMI monitor (smi #1)
+        nop
+        nop
+        nop
+        nop
+        ldmfd   sp!, {r1-r12, pc}
+sram_phy_addr_mask:
+        .word   SRAM_BASE_P
+high_mask:
+        .word   0xffff
+api_params:
+        .word   0x4, 0x0, 0x0, 0x1, 0x1
+ENTRY(save_secure_ram_context_sz)
+        .word   . - save_secure_ram_context
+
 /*
  * Forces OMAP into idle state
  *
@@ -92,11 +191,29 @@ loop:
         nop
         nop
         nop
-        bl i_dll_wait
+        bl wait_sdrc_ok
 
         ldmfd   sp!, {r0-r12, pc}               @ restore regs and return
+restore_es3:
+        /*b restore_es3*/               @ Enable to debug restore code
+        ldr     r5, pm_prepwstst_core_p
+        ldr     r4, [r5]
+        and     r4, r4, #0x3
+        cmp     r4, #0x0        @ Check if previous power state of CORE is OFF
+        bne     restore
+        adr     r0, es3_sdrc_fix
+        ldr     r1, sram_base
+        ldr     r2, es3_sdrc_fix_sz
+        mov     r2, r2, ror #2
+copy_to_sram:
+        ldmia   r0!, {r3}       @ val = *src
+        stmia   r1!, {r3}       @ *dst = val
+        subs    r2, r2, #0x1    @ num_words--
+        bne     copy_to_sram
+        ldr     r1, sram_base
+        blx     r1
 restore:
-        /* b restore*/  @ Enable to debug restore code
+        /* b restore*/  @ Enable to debug restore code
         /* Check what was the reason for mpu reset and store the reason in r9*/
         /* 1 - Only L1 and logic lost */
         /* 2 - Only L2 lost - In this case, we wont be here */
@@ -108,9 +225,44 @@ restore:
         moveq   r9, #0x3        @ MPU OFF => L1 and L2 lost
         movne   r9, #0x1        @ Only L1 and L2 lost => avoid L2 invalidation
         bne     logic_l1_restore
+        ldr     r0, control_stat
+        ldr     r1, [r0]
+        and     r1, #0x700
+        cmp     r1, #0x300
+        beq     l2_inv_gp
+        mov     r0, #40         @ set service ID for PPA
+        mov     r12, r0         @ copy secure Service ID in r12
+        mov     r1, #0          @ set task id for ROM code in r1
+        mov     r2, #4          @ set some flags in r2, r6
+        mov     r6, #0xff
+        adr     r3, l2_inv_api_params   @ r3 points to dummy parameters
+        mcr     p15, 0, r0, c7, c10, 4  @ data write barrier
+        mcr     p15, 0, r0, c7, c10, 5  @ data memory barrier
+        .word   0xE1600071              @ call SMI monitor (smi #1)
+        /* Write to Aux control register to set some bits */
+        mov     r0, #42         @ set service ID for PPA
+        mov     r12, r0         @ copy secure Service ID in r12
+        mov     r1, #0          @ set task id for ROM code in r1
+        mov     r2, #4          @ set some flags in r2, r6
+        mov     r6, #0xff
+        adr     r3, write_aux_control_params    @ r3 points to parameters
+        mcr     p15, 0, r0, c7, c10, 4  @ data write barrier
+        mcr     p15, 0, r0, c7, c10, 5  @ data memory barrier
+        .word   0xE1600071              @ call SMI monitor (smi #1)
+
+        b       logic_l1_restore
+l2_inv_api_params:
+        .word   0x1, 0x00
+write_aux_control_params:
+        .word   0x1, 0x72
+l2_inv_gp:
         /* Execute smi to invalidate L2 cache */
         mov r12, #0x1                         @ set up to invalide L2
-smi:    .word 0xE1600070                @ Call SMI monitor (smieq)
+smi:    .word 0xE1600070                @ Call SMI monitor (smieq)
+        /* Write to Aux control register to set some bits */
+        mov     r0, #0x72
+        mov     r12, #0x3
+        .word 0xE1600070        @ Call SMI monitor (smieq)
 logic_l1_restore:
         mov     r1, #0
         /* Invalidate all instruction caches to PoU
@@ -391,33 +543,55 @@ skip_l2_inval:
         nop
         nop
         nop
-        bl i_dll_wait
+        bl wait_sdrc_ok
         /* restore regs and return */
         ldmfd   sp!, {r0-r12, pc}
 
-i_dll_wait:
-        ldr     r4, clk_stabilize_delay
+/* Make sure SDRC accesses are ok */
+wait_sdrc_ok:
+        ldr     r4, cm_idlest1_core
+        ldr     r5, [r4]
+        and     r5, r5, #0x2
+        cmp     r5, #0
+        bne     wait_sdrc_ok
+        ldr     r4, sdrc_power
+        ldr     r5, [r4]
+        bic     r5, r5, #0x40
+        str     r5, [r4]
+wait_dll_lock:
+        /* Is dll in lock mode? */
+        ldr     r4, sdrc_dlla_ctrl
+        ldr     r5, [r4]
+        tst     r5, #0x4
+        bxne    lr
+        /* wait till dll locks */
+        ldr     r4, sdrc_dlla_status
+        ldr     r5, [r4]
+        and     r5, r5, #0x4
+        cmp     r5, #0x4
+        bne     wait_dll_lock
+        bx      lr
 
-i_dll_delay:
-        subs    r4, r4, #0x1
-        bne     i_dll_delay
-        ldr     r4, sdrc_power
-        ldr     r5, [r4]
-        bic     r5, r5, #0x40
-        str     r5, [r4]
-        bx      lr
+cm_idlest1_core:
+        .word   CM_IDLEST1_CORE_V
+sdrc_dlla_status:
+        .word   SDRC_DLLA_STATUS_V
+sdrc_dlla_ctrl:
+        .word   SDRC_DLLA_CTRL_V
 pm_prepwstst_core:
         .word   PM_PREPWSTST_CORE_V
+pm_prepwstst_core_p:
+        .word   PM_PREPWSTST_CORE_P
 pm_prepwstst_mpu:
         .word   PM_PREPWSTST_MPU_V
 pm_pwstctrl_mpu:
         .word   PM_PWSTCTRL_MPU_P
 scratchpad_base:
         .word   SCRATCHPAD_BASE_P
+sram_base:
+        .word   SRAM_BASE_P + 0x8000
 sdrc_power:
         .word SDRC_POWER_V
-context_mem:
-        .word   0x803E3E14
 clk_stabilize_delay:
         .word 0x000001FF
 assoc_mask:
@@ -432,5 +606,7 @@ table_entry:
         .word   0x00000C02
 cache_pred_disable_mask:
         .word   0xFFFFE7FB
+control_stat:
+        .word   CONTROL_STAT
 ENTRY(omap34xx_cpu_suspend_sz)
         .word   . - omap34xx_cpu_suspend
diff --git a/arch/arm/mach-omap2/sram242x.S b/arch/arm/mach-omap2/sram242x.S
index 9b62208658bc..92e6e1a12af8 100644
--- a/arch/arm/mach-omap2/sram242x.S
+++ b/arch/arm/mach-omap2/sram242x.S
@@ -128,7 +128,7 @@ omap242x_sdi_prcm_voltctrl:
 prcm_mask_val:
         .word 0xFFFF3FFC
 omap242x_sdi_timer_32ksynct_cr:
-        .word OMAP2_IO_ADDRESS(OMAP2420_32KSYNCT_BASE + 0x010)
+        .word OMAP2_L4_IO_ADDRESS(OMAP2420_32KSYNCT_BASE + 0x010)
 ENTRY(omap242x_sram_ddr_init_sz)
         .word   . - omap242x_sram_ddr_init
 
@@ -224,7 +224,7 @@ omap242x_srs_prcm_voltctrl:
 ddr_prcm_mask_val:
         .word 0xFFFF3FFC
 omap242x_srs_timer_32ksynct:
-        .word OMAP2_IO_ADDRESS(OMAP2420_32KSYNCT_BASE + 0x010)
+        .word OMAP2_L4_IO_ADDRESS(OMAP2420_32KSYNCT_BASE + 0x010)
 
 ENTRY(omap242x_sram_reprogram_sdrc_sz)
         .word   . - omap242x_sram_reprogram_sdrc
diff --git a/arch/arm/mach-omap2/sram243x.S b/arch/arm/mach-omap2/sram243x.S
index df2cd9277c00..ab4973695c71 100644
--- a/arch/arm/mach-omap2/sram243x.S
+++ b/arch/arm/mach-omap2/sram243x.S
@@ -128,7 +128,7 @@ omap243x_sdi_prcm_voltctrl:
 prcm_mask_val:
         .word 0xFFFF3FFC
 omap243x_sdi_timer_32ksynct_cr:
-        .word OMAP2_IO_ADDRESS(OMAP2430_32KSYNCT_BASE + 0x010)
+        .word OMAP2_L4_IO_ADDRESS(OMAP2430_32KSYNCT_BASE + 0x010)
 ENTRY(omap243x_sram_ddr_init_sz)
         .word   . - omap243x_sram_ddr_init
 
@@ -224,7 +224,7 @@ omap243x_srs_prcm_voltctrl:
 ddr_prcm_mask_val:
         .word 0xFFFF3FFC
 omap243x_srs_timer_32ksynct:
-        .word OMAP2_IO_ADDRESS(OMAP2430_32KSYNCT_BASE + 0x010)
+        .word OMAP2_L4_IO_ADDRESS(OMAP2430_32KSYNCT_BASE + 0x010)
 
 ENTRY(omap243x_sram_reprogram_sdrc_sz)
         .word   . - omap243x_sram_reprogram_sdrc
diff --git a/arch/arm/mach-omap2/timer-gp.c b/arch/arm/mach-omap2/timer-gp.c
index e2338c0aebcf..cd04deaa88c5 100644
--- a/arch/arm/mach-omap2/timer-gp.c
+++ b/arch/arm/mach-omap2/timer-gp.c
@@ -37,7 +37,7 @@
 #include <linux/clockchips.h>
 
 #include <asm/mach/time.h>
-#include <mach/dmtimer.h>
+#include <plat/dmtimer.h>
 #include <asm/localtimer.h>
 
 /* MAX_GPTIMER_ID: number of GPTIMERs on the chip */
@@ -47,6 +47,7 @@ static struct omap_dm_timer *gptimer;
 static struct clock_event_device clockevent_gpt;
 static u8 __initdata gptimer_id = 1;
 static u8 __initdata inited;
+struct omap_dm_timer *gptimer_wakeup;
 
 static irqreturn_t omap2_gp_timer_interrupt(int irq, void *dev_id)
 {
@@ -134,6 +135,7 @@ static void __init omap2_gp_clockevent_init(void)
 
         gptimer = omap_dm_timer_request_specific(gptimer_id);
         BUG_ON(gptimer == NULL);
+        gptimer_wakeup = gptimer;
 
 #if defined(CONFIG_OMAP_32K_TIMER)
         src = OMAP_TIMER_SRC_32_KHZ;
@@ -231,7 +233,8 @@ static void __init omap2_gp_clocksource_init(void)
 static void __init omap2_gp_timer_init(void)
 {
 #ifdef CONFIG_LOCAL_TIMERS
-        twd_base = OMAP2_IO_ADDRESS(OMAP44XX_LOCAL_TWD_BASE);
+        twd_base = ioremap(OMAP44XX_LOCAL_TWD_BASE, SZ_256);
+        BUG_ON(!twd_base);
 #endif
         omap_dm_timer_init();
 
diff --git a/arch/arm/mach-omap2/usb-ehci.c b/arch/arm/mach-omap2/usb-ehci.c
new file mode 100644
index 000000000000..e448abd5ec5d
--- /dev/null
+++ b/arch/arm/mach-omap2/usb-ehci.c
@@ -0,0 +1,192 @@
+/*
+ * linux/arch/arm/mach-omap2/usb-ehci.c
+ *
+ * This file will contain the board specific details for the
+ * Synopsys EHCI host controller on OMAP3430
+ *
+ * Copyright (C) 2007 Texas Instruments
+ * Author: Vikram Pandita <vikram.pandita@ti.com>
+ *
+ * Generalization by:
+ * Felipe Balbi <felipe.balbi@nokia.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.
+ */
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <asm/io.h>
+#include <plat/mux.h>
+
+#include <mach/hardware.h>
+#include <mach/irqs.h>
+#include <plat/usb.h>
+
+#if defined(CONFIG_USB_EHCI_HCD) || defined(CONFIG_USB_EHCI_HCD_MODULE)
+
+static struct resource ehci_resources[] = {
+        {
+                .start  = OMAP34XX_EHCI_BASE,
+                .end    = OMAP34XX_EHCI_BASE + SZ_1K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = OMAP34XX_UHH_CONFIG_BASE,
+                .end    = OMAP34XX_UHH_CONFIG_BASE + SZ_1K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = OMAP34XX_USBTLL_BASE,
+                .end    = OMAP34XX_USBTLL_BASE + SZ_4K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {         /* general IRQ */
+                .start   = INT_34XX_EHCI_IRQ,
+                .flags   = IORESOURCE_IRQ,
+        }
+};
+
+static u64 ehci_dmamask = ~(u32)0;
+static struct platform_device ehci_device = {
+        .name           = "ehci-omap",
+        .id             = 0,
+        .dev = {
+                .dma_mask               = &ehci_dmamask,
+                .coherent_dma_mask      = 0xffffffff,
+                .platform_data          = NULL,
+        },
+        .num_resources  = ARRAY_SIZE(ehci_resources),
+        .resource       = ehci_resources,
+};
+
+/* MUX settings for EHCI pins */
+/*
+ * setup_ehci_io_mux - initialize IO pad mux for USBHOST
+ */
+static void setup_ehci_io_mux(enum ehci_hcd_omap_mode *port_mode)
+{
+        switch (port_mode[0]) {
+        case EHCI_HCD_OMAP_MODE_PHY:
+                omap_cfg_reg(Y9_3430_USB1HS_PHY_STP);
+                omap_cfg_reg(Y8_3430_USB1HS_PHY_CLK);
+                omap_cfg_reg(AA14_3430_USB1HS_PHY_DIR);
+                omap_cfg_reg(AA11_3430_USB1HS_PHY_NXT);
+                omap_cfg_reg(W13_3430_USB1HS_PHY_DATA0);
+                omap_cfg_reg(W12_3430_USB1HS_PHY_DATA1);
+                omap_cfg_reg(W11_3430_USB1HS_PHY_DATA2);
+                omap_cfg_reg(Y11_3430_USB1HS_PHY_DATA3);
+                omap_cfg_reg(W9_3430_USB1HS_PHY_DATA4);
+                omap_cfg_reg(Y12_3430_USB1HS_PHY_DATA5);
+                omap_cfg_reg(W8_3430_USB1HS_PHY_DATA6);
+                omap_cfg_reg(Y13_3430_USB1HS_PHY_DATA7);
+                break;
+        case EHCI_HCD_OMAP_MODE_TLL:
+                omap_cfg_reg(Y9_3430_USB1HS_TLL_STP);
+                omap_cfg_reg(Y8_3430_USB1HS_TLL_CLK);
+                omap_cfg_reg(AA14_3430_USB1HS_TLL_DIR);
+                omap_cfg_reg(AA11_3430_USB1HS_TLL_NXT);
+                omap_cfg_reg(W13_3430_USB1HS_TLL_DATA0);
+                omap_cfg_reg(W12_3430_USB1HS_TLL_DATA1);
+                omap_cfg_reg(W11_3430_USB1HS_TLL_DATA2);
+                omap_cfg_reg(Y11_3430_USB1HS_TLL_DATA3);
+                omap_cfg_reg(W9_3430_USB1HS_TLL_DATA4);
+                omap_cfg_reg(Y12_3430_USB1HS_TLL_DATA5);
+                omap_cfg_reg(W8_3430_USB1HS_TLL_DATA6);
+                omap_cfg_reg(Y13_3430_USB1HS_TLL_DATA7);
+                break;
+        case EHCI_HCD_OMAP_MODE_UNKNOWN:
+                /* FALLTHROUGH */
+        default:
+                break;
+        }
+
+        switch (port_mode[1]) {
+        case EHCI_HCD_OMAP_MODE_PHY:
+                omap_cfg_reg(AA10_3430_USB2HS_PHY_STP);
+                omap_cfg_reg(AA8_3430_USB2HS_PHY_CLK);
+                omap_cfg_reg(AA9_3430_USB2HS_PHY_DIR);
+                omap_cfg_reg(AB11_3430_USB2HS_PHY_NXT);
+                omap_cfg_reg(AB10_3430_USB2HS_PHY_DATA0);
+                omap_cfg_reg(AB9_3430_USB2HS_PHY_DATA1);
+                omap_cfg_reg(W3_3430_USB2HS_PHY_DATA2);
+                omap_cfg_reg(T4_3430_USB2HS_PHY_DATA3);
+                omap_cfg_reg(T3_3430_USB2HS_PHY_DATA4);
+                omap_cfg_reg(R3_3430_USB2HS_PHY_DATA5);
+                omap_cfg_reg(R4_3430_USB2HS_PHY_DATA6);
+                omap_cfg_reg(T2_3430_USB2HS_PHY_DATA7);
+                break;
+        case EHCI_HCD_OMAP_MODE_TLL:
+                omap_cfg_reg(AA10_3430_USB2HS_TLL_STP);
+                omap_cfg_reg(AA8_3430_USB2HS_TLL_CLK);
+                omap_cfg_reg(AA9_3430_USB2HS_TLL_DIR);
+                omap_cfg_reg(AB11_3430_USB2HS_TLL_NXT);
+                omap_cfg_reg(AB10_3430_USB2HS_TLL_DATA0);
+                omap_cfg_reg(AB9_3430_USB2HS_TLL_DATA1);
+                omap_cfg_reg(W3_3430_USB2HS_TLL_DATA2);
+                omap_cfg_reg(T4_3430_USB2HS_TLL_DATA3);
+                omap_cfg_reg(T3_3430_USB2HS_TLL_DATA4);
+                omap_cfg_reg(R3_3430_USB2HS_TLL_DATA5);
+                omap_cfg_reg(R4_3430_USB2HS_TLL_DATA6);
+                omap_cfg_reg(T2_3430_USB2HS_TLL_DATA7);
+                break;
+        case EHCI_HCD_OMAP_MODE_UNKNOWN:
+                /* FALLTHROUGH */
+        default:
+                break;
+        }
+
+        switch (port_mode[2]) {
+        case EHCI_HCD_OMAP_MODE_PHY:
+                printk(KERN_WARNING "Port3 can't be used in PHY mode\n");
+                break;
+        case EHCI_HCD_OMAP_MODE_TLL:
+                omap_cfg_reg(AB3_3430_USB3HS_TLL_STP);
+                omap_cfg_reg(AA6_3430_USB3HS_TLL_CLK);
+                omap_cfg_reg(AA3_3430_USB3HS_TLL_DIR);
+                omap_cfg_reg(Y3_3430_USB3HS_TLL_NXT);
+                omap_cfg_reg(AA5_3430_USB3HS_TLL_DATA0);
+                omap_cfg_reg(Y4_3430_USB3HS_TLL_DATA1);
+                omap_cfg_reg(Y5_3430_USB3HS_TLL_DATA2);
+                omap_cfg_reg(W5_3430_USB3HS_TLL_DATA3);
+                omap_cfg_reg(AB12_3430_USB3HS_TLL_DATA4);
+                omap_cfg_reg(AB13_3430_USB3HS_TLL_DATA5);
+                omap_cfg_reg(AA13_3430_USB3HS_TLL_DATA6);
+                omap_cfg_reg(AA12_3430_USB3HS_TLL_DATA7);
+                break;
+        case EHCI_HCD_OMAP_MODE_UNKNOWN:
+                /* FALLTHROUGH */
+        default:
+                break;
+        }
+
+        return;
+}
+
+void __init usb_ehci_init(struct ehci_hcd_omap_platform_data *pdata)
+{
+        platform_device_add_data(&ehci_device, pdata, sizeof(*pdata));
+
+        /* Setup Pin IO MUX for EHCI */
+        if (cpu_is_omap34xx())
+                setup_ehci_io_mux(pdata->port_mode);
+
+        if (platform_device_register(&ehci_device) < 0) {
+                printk(KERN_ERR "Unable to register HS-USB (EHCI) device\n");
+                return;
+        }
+}
+
+#else
+
+void __init usb_ehci_init(struct ehci_hcd_omap_platform_data *pdata)
+
+{
+}
+
+#endif /* CONFIG_USB_EHCI_HCD */
+
diff --git a/arch/arm/mach-omap2/usb-musb.c b/arch/arm/mach-omap2/usb-musb.c
index 1145a2562b0f..a80441dd19b8 100644
--- a/arch/arm/mach-omap2/usb-musb.c
+++ b/arch/arm/mach-omap2/usb-musb.c
@@ -28,8 +28,8 @@
 
 #include <mach/hardware.h>
 #include <mach/irqs.h>
-#include <mach/mux.h>
-#include <mach/usb.h>
+#include <plat/mux.h>
+#include <plat/usb.h>
 
 #ifdef CONFIG_USB_MUSB_SOC
 
diff --git a/arch/arm/mach-omap2/usb-tusb6010.c b/arch/arm/mach-omap2/usb-tusb6010.c
index 8622c24cd270..10a2013c1104 100644
--- a/arch/arm/mach-omap2/usb-tusb6010.c
+++ b/arch/arm/mach-omap2/usb-tusb6010.c
@@ -16,8 +16,8 @@
 
 #include <linux/usb/musb.h>
 
-#include <mach/gpmc.h>
-#include <mach/mux.h>
+#include <plat/gpmc.h>
+#include <plat/mux.h>
 
 
 static u8               async_cs, sync_cs;