Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

52 files changed, 2682 insertions, 798 deletions

diff --git a/arch/arm/mach-omap1/Kconfig b/arch/arm/mach-omap1/Kconfig
index 3b02d3b944af..e0a028161dde 100644
--- a/arch/arm/mach-omap1/Kconfig
+++ b/arch/arm/mach-omap1/Kconfig
@@ -9,6 +9,7 @@ config ARCH_OMAP730
         depends on ARCH_OMAP1
         bool "OMAP730 Based System"
         select CPU_ARM926T
+        select OMAP_MPU_TIMER
         select ARCH_OMAP_OTG
 
 config ARCH_OMAP850
@@ -22,6 +23,7 @@ config ARCH_OMAP15XX
         default y
         bool "OMAP15xx Based System"
         select CPU_ARM925T
+        select OMAP_MPU_TIMER
 
 config ARCH_OMAP16XX
         depends on ARCH_OMAP1
@@ -128,7 +130,7 @@ config MACH_OMAP_PALMTT
         help
           Support for the Palm Tungsten|T PDA. To boot the kernel, you'll
           need a PalmOS compatible bootloader (Garux); check out
-          http://www.hackndev.com/palm/tt/ for more information.
+          http://garux.sourceforge.net/ for more information.
           Say Y here if you have this PDA model, say N otherwise.
 
 config MACH_SX1
@@ -152,20 +154,11 @@ config MACH_NOKIA770
 config MACH_AMS_DELTA
         bool "Amstrad E3 (Delta)"
         depends on ARCH_OMAP1 && ARCH_OMAP15XX
+        select FIQ
         help
           Support for the Amstrad E3 (codename Delta) videophone. Say Y here
           if you have such a device.
 
-config AMS_DELTA_FIQ
-        bool "Fast Interrupt Request (FIQ) support for the E3"
-        depends on MACH_AMS_DELTA
-        select FIQ
-        help
-          Provide a FIQ handler for the E3.
-          This allows for fast handling of interrupts generated
-          by the clock line of the E3 mailboard (or a PS/2 keyboard)
-          connected to the GPIO based external keyboard port.
-
 config MACH_OMAP_GENERIC
         bool "Generic OMAP board"
         depends on ARCH_OMAP1 && (ARCH_OMAP15XX || ARCH_OMAP16XX)
diff --git a/arch/arm/mach-omap1/Makefile b/arch/arm/mach-omap1/Makefile
index facfaeb1ae5c..5b114d1558c8 100644
--- a/arch/arm/mach-omap1/Makefile
+++ b/arch/arm/mach-omap1/Makefile
@@ -3,12 +3,11 @@
 #
 
 # Common support
-obj-y := io.o id.o sram.o irq.o mux.o flash.o serial.o devices.o
-obj-y += clock.o clock_data.o opp_data.o
+obj-y := io.o id.o sram.o time.o irq.o mux.o flash.o serial.o devices.o dma.o
+obj-y += clock.o clock_data.o opp_data.o reset.o pm_bus.o
 
 obj-$(CONFIG_OMAP_MCBSP) += mcbsp.o
 
-obj-$(CONFIG_OMAP_MPU_TIMER)    += time.o
 obj-$(CONFIG_OMAP_32K_TIMER)    += timer32k.o
 
 # Power Management
@@ -39,8 +38,8 @@ obj-$(CONFIG_MACH_OMAP_PALMTE)		+= board-palmte.o
 obj-$(CONFIG_MACH_OMAP_PALMZ71)         += board-palmz71.o
 obj-$(CONFIG_MACH_OMAP_PALMTT)          += board-palmtt.o
 obj-$(CONFIG_MACH_NOKIA770)             += board-nokia770.o
-obj-$(CONFIG_MACH_AMS_DELTA)            += board-ams-delta.o
-obj-$(CONFIG_AMS_DELTA_FIQ)             += ams-delta-fiq.o ams-delta-fiq-handler.o
+obj-$(CONFIG_MACH_AMS_DELTA)            += board-ams-delta.o ams-delta-fiq.o \
+                                           ams-delta-fiq-handler.o
 obj-$(CONFIG_MACH_SX1)                  += board-sx1.o board-sx1-mmc.o
 obj-$(CONFIG_MACH_HERALD)               += board-htcherald.o
 
@@ -49,6 +48,12 @@ ifeq ($(CONFIG_ARCH_OMAP15XX),y)
 obj-$(CONFIG_MACH_OMAP_INNOVATOR)       += fpga.o
 endif
 
+# GPIO
+obj-$(CONFIG_ARCH_OMAP730)              += gpio7xx.o
+obj-$(CONFIG_ARCH_OMAP850)              += gpio7xx.o
+obj-$(CONFIG_ARCH_OMAP15XX)             += gpio15xx.o
+obj-$(CONFIG_ARCH_OMAP16XX)             += gpio16xx.o
+
 # LEDs support
 led-$(CONFIG_MACH_OMAP_H2)              += leds-h2p2-debug.o
 led-$(CONFIG_MACH_OMAP_H3)              += leds-h2p2-debug.o
diff --git a/arch/arm/mach-omap1/ams-delta-fiq-handler.S b/arch/arm/mach-omap1/ams-delta-fiq-handler.S
index 927d5a181760..c1c5fb6a5b4c 100644
--- a/arch/arm/mach-omap1/ams-delta-fiq-handler.S
+++ b/arch/arm/mach-omap1/ams-delta-fiq-handler.S
@@ -79,7 +79,7 @@
 
 
 /*
- * Register useage
+ * Register usage
  * r8  - temporary
  * r9  - the driver buffer
  * r10 - temporary
diff --git a/arch/arm/mach-omap1/ams-delta-fiq.c b/arch/arm/mach-omap1/ams-delta-fiq.c
index 6c994e2d8879..152b32c15e28 100644
--- a/arch/arm/mach-omap1/ams-delta-fiq.c
+++ b/arch/arm/mach-omap1/ams-delta-fiq.c
@@ -49,7 +49,7 @@ static irqreturn_t deferred_fiq(int irq, void *dev_id)
 
         irq_desc = irq_to_desc(IH_GPIO_BASE);
         if (irq_desc)
-                irq_chip = irq_desc->chip;
+                irq_chip = irq_desc->irq_data.chip;
 
         /*
          * For each handled GPIO interrupt, keep calling its interrupt handler
@@ -62,13 +62,15 @@ static irqreturn_t deferred_fiq(int irq, void *dev_id)
 
                 while (irq_counter[gpio] < fiq_count) {
                         if (gpio != AMS_DELTA_GPIO_PIN_KEYBRD_CLK) {
+                                struct irq_data *d = irq_get_irq_data(irq_num);
+
                                 /*
                                  * It looks like handle_edge_irq() that
                                  * OMAP GPIO edge interrupts default to,
                                  * expects interrupt already unmasked.
                                  */
-                                if (irq_chip && irq_chip->unmask)
-                                        irq_chip->unmask(irq_num);
+                                if (irq_chip && irq_chip->irq_unmask)
+                                        irq_chip->irq_unmask(d);
                         }
                         generic_handle_irq(irq_num);
 
diff --git a/arch/arm/mach-omap1/board-ams-delta.c b/arch/arm/mach-omap1/board-ams-delta.c
index 41992ab71961..f49ce85d2448 100644
--- a/arch/arm/mach-omap1/board-ams-delta.c
+++ b/arch/arm/mach-omap1/board-ams-delta.c
@@ -16,15 +16,19 @@
 #include <linux/init.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/leds.h>
 #include <linux/platform_device.h>
 #include <linux/serial_8250.h>
 
+#include <media/soc_camera.h>
+
 #include <asm/serial.h>
 #include <mach/hardware.h>
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
+#include <plat/io.h>
 #include <plat/board-ams-delta.h>
 #include <mach/gpio.h>
 #include <plat/keypad.h>
@@ -32,90 +36,89 @@
 #include <plat/usb.h>
 #include <plat/board.h>
 #include <plat/common.h>
+#include <mach/camera.h>
 
 #include <mach/ams-delta-fiq.h>
 
 static u8 ams_delta_latch1_reg;
 static u16 ams_delta_latch2_reg;
 
-static int ams_delta_keymap[] = {
+static const unsigned int ams_delta_keymap[] = {
         KEY(0, 0, KEY_F1),              /* Advert    */
 
-        KEY(3, 0, KEY_COFFEE),          /* Games     */
-        KEY(2, 0, KEY_QUESTION),        /* Directory */
-        KEY(3, 2, KEY_CONNECT),         /* Internet  */
-        KEY(2, 1, KEY_SHOP),            /* Services  */
+        KEY(0, 3, KEY_COFFEE),          /* Games     */
+        KEY(0, 2, KEY_QUESTION),        /* Directory */
+        KEY(2, 3, KEY_CONNECT),         /* Internet  */
+        KEY(1, 2, KEY_SHOP),            /* Services  */
         KEY(1, 1, KEY_PHONE),           /* VoiceMail */
 
-        KEY(1, 0, KEY_DELETE),          /* Delete    */
+        KEY(0, 1, KEY_DELETE),          /* Delete    */
         KEY(2, 2, KEY_PLAY),            /* Play      */
-        KEY(0, 1, KEY_PAGEUP),          /* Up        */
-        KEY(3, 1, KEY_PAGEDOWN),        /* Down      */
-        KEY(0, 2, KEY_EMAIL),           /* ReadEmail */
-        KEY(1, 2, KEY_STOP),            /* Stop      */
+        KEY(1, 0, KEY_PAGEUP),          /* Up        */
+        KEY(1, 3, KEY_PAGEDOWN),        /* Down      */
+        KEY(2, 0, KEY_EMAIL),           /* ReadEmail */
+        KEY(2, 1, KEY_STOP),            /* Stop      */
 
         /* Numeric keypad portion */
-        KEY(7, 0, KEY_KP1),
-        KEY(6, 0, KEY_KP2),
-        KEY(5, 0, KEY_KP3),
-        KEY(7, 1, KEY_KP4),
-        KEY(6, 1, KEY_KP5),
-        KEY(5, 1, KEY_KP6),
-        KEY(7, 2, KEY_KP7),
-        KEY(6, 2, KEY_KP8),
-        KEY(5, 2, KEY_KP9),
-        KEY(6, 3, KEY_KP0),
-        KEY(7, 3, KEY_KPASTERISK),
-        KEY(5, 3, KEY_KPDOT),           /* # key     */
-        KEY(2, 7, KEY_NUMLOCK),         /* Mute      */
-        KEY(1, 7, KEY_KPMINUS),         /* Recall    */
-        KEY(1, 6, KEY_KPPLUS),          /* Redial    */
-        KEY(6, 7, KEY_KPSLASH),         /* Handsfree */
-        KEY(0, 6, KEY_ENTER),           /* Video     */
-
-        KEY(4, 7, KEY_CAMERA),          /* Photo     */
-
-        KEY(4, 0, KEY_F2),              /* Home      */
-        KEY(4, 1, KEY_F3),              /* Office    */
-        KEY(4, 2, KEY_F4),              /* Mobile    */
+        KEY(0, 7, KEY_KP1),
+        KEY(0, 6, KEY_KP2),
+        KEY(0, 5, KEY_KP3),
+        KEY(1, 7, KEY_KP4),
+        KEY(1, 6, KEY_KP5),
+        KEY(1, 5, KEY_KP6),
+        KEY(2, 7, KEY_KP7),
+        KEY(2, 6, KEY_KP8),
+        KEY(2, 5, KEY_KP9),
+        KEY(3, 6, KEY_KP0),
+        KEY(3, 7, KEY_KPASTERISK),
+        KEY(3, 5, KEY_KPDOT),           /* # key     */
+        KEY(7, 2, KEY_NUMLOCK),         /* Mute      */
+        KEY(7, 1, KEY_KPMINUS),         /* Recall    */
+        KEY(6, 1, KEY_KPPLUS),          /* Redial    */
+        KEY(7, 6, KEY_KPSLASH),         /* Handsfree */
+        KEY(6, 0, KEY_ENTER),           /* Video     */
+
+        KEY(7, 4, KEY_CAMERA),          /* Photo     */
+
+        KEY(0, 4, KEY_F2),              /* Home      */
+        KEY(1, 4, KEY_F3),              /* Office    */
+        KEY(2, 4, KEY_F4),              /* Mobile    */
         KEY(7, 7, KEY_F5),              /* SMS       */
-        KEY(5, 7, KEY_F6),              /* Email     */
+        KEY(7, 5, KEY_F6),              /* Email     */
 
         /* QWERTY portion of keypad */
-        KEY(4, 3, KEY_Q),
+        KEY(3, 4, KEY_Q),
         KEY(3, 3, KEY_W),
-        KEY(2, 3, KEY_E),
-        KEY(1, 3, KEY_R),
-        KEY(0, 3, KEY_T),
-        KEY(7, 4, KEY_Y),
-        KEY(6, 4, KEY_U),
-        KEY(5, 4, KEY_I),
+        KEY(3, 2, KEY_E),
+        KEY(3, 1, KEY_R),
+        KEY(3, 0, KEY_T),
+        KEY(4, 7, KEY_Y),
+        KEY(4, 6, KEY_U),
+        KEY(4, 5, KEY_I),
         KEY(4, 4, KEY_O),
-        KEY(3, 4, KEY_P),
+        KEY(4, 3, KEY_P),
 
-        KEY(2, 4, KEY_A),
-        KEY(1, 4, KEY_S),
-        KEY(0, 4, KEY_D),
-        KEY(7, 5, KEY_F),
-        KEY(6, 5, KEY_G),
+        KEY(4, 2, KEY_A),
+        KEY(4, 1, KEY_S),
+        KEY(4, 0, KEY_D),
+        KEY(5, 7, KEY_F),
+        KEY(5, 6, KEY_G),
         KEY(5, 5, KEY_H),
-        KEY(4, 5, KEY_J),
-        KEY(3, 5, KEY_K),
-        KEY(2, 5, KEY_L),
+        KEY(5, 4, KEY_J),
+        KEY(5, 3, KEY_K),
+        KEY(5, 2, KEY_L),
 
-        KEY(1, 5, KEY_Z),
-        KEY(0, 5, KEY_X),
-        KEY(7, 6, KEY_C),
+        KEY(5, 1, KEY_Z),
+        KEY(5, 0, KEY_X),
+        KEY(6, 7, KEY_C),
         KEY(6, 6, KEY_V),
-        KEY(5, 6, KEY_B),
-        KEY(4, 6, KEY_N),
-        KEY(3, 6, KEY_M),
-        KEY(2, 6, KEY_SPACE),
-
-        KEY(0, 7, KEY_LEFTSHIFT),       /* Vol up    */
-        KEY(3, 7, KEY_LEFTCTRL),        /* Vol down  */
+        KEY(6, 5, KEY_B),
+        KEY(6, 4, KEY_N),
+        KEY(6, 3, KEY_M),
+        KEY(6, 2, KEY_SPACE),
 
-        0
+        KEY(7, 0, KEY_LEFTSHIFT),       /* Vol up    */
+        KEY(7, 3, KEY_LEFTCTRL),        /* Vol down  */
 };
 
 void ams_delta_latch1_write(u8 mask, u8 value)
@@ -136,7 +139,6 @@ static void __init ams_delta_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
 }
 
 static struct map_desc ams_delta_io_desc[] __initdata = {
@@ -163,7 +165,7 @@ static struct map_desc ams_delta_io_desc[] __initdata = {
         }
 };
 
-static struct omap_lcd_config ams_delta_lcd_config __initdata = {
+static struct omap_lcd_config ams_delta_lcd_config = {
         .ctrl_name      = "internal",
 };
 
@@ -173,10 +175,26 @@ static struct omap_usb_config ams_delta_usb_config __initdata = {
         .pins[0]        = 2,
 };
 
-static struct omap_board_config_kernel ams_delta_config[] = {
+static struct omap_board_config_kernel ams_delta_config[] __initdata = {
         { OMAP_TAG_LCD,         &ams_delta_lcd_config },
 };
 
+static struct resource ams_delta_nand_resources[] = {
+        [0] = {
+                .start  = OMAP1_MPUIO_BASE,
+                .end    = OMAP1_MPUIO_BASE +
+                                OMAP_MPUIO_IO_CNTL + sizeof(u32) - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+};
+
+static struct platform_device ams_delta_nand_device = {
+        .name   = "ams-delta-nand",
+        .id     = -1,
+        .num_resources  = ARRAY_SIZE(ams_delta_nand_resources),
+        .resource       = ams_delta_nand_resources,
+};
+
 static struct resource ams_delta_kp_resources[] = {
         [0] = {
                 .start  = INT_KEYBOARD,
@@ -185,11 +203,15 @@ static struct resource ams_delta_kp_resources[] = {
         },
 };
 
-static struct omap_kp_platform_data ams_delta_kp_data = {
+static const struct matrix_keymap_data ams_delta_keymap_data = {
+        .keymap         = ams_delta_keymap,
+        .keymap_size    = ARRAY_SIZE(ams_delta_keymap),
+};
+
+static struct omap_kp_platform_data ams_delta_kp_data __initdata = {
         .rows           = 8,
         .cols           = 8,
-        .keymap         = ams_delta_keymap,
-        .keymapsize     = ARRAY_SIZE(ams_delta_keymap),
+        .keymap_data    = &ams_delta_keymap_data,
         .delay          = 9,
 };
 
@@ -213,10 +235,57 @@ static struct platform_device ams_delta_led_device = {
         .id     = -1
 };
 
+static struct i2c_board_info ams_delta_camera_board_info[] = {
+        {
+                I2C_BOARD_INFO("ov6650", 0x60),
+        },
+};
+
+#ifdef CONFIG_LEDS_TRIGGERS
+DEFINE_LED_TRIGGER(ams_delta_camera_led_trigger);
+
+static int ams_delta_camera_power(struct device *dev, int power)
+{
+        /*
+         * turn on camera LED
+         */
+        if (power)
+                led_trigger_event(ams_delta_camera_led_trigger, LED_FULL);
+        else
+                led_trigger_event(ams_delta_camera_led_trigger, LED_OFF);
+        return 0;
+}
+#else
+#define ams_delta_camera_power  NULL
+#endif
+
+static struct soc_camera_link ams_delta_iclink = {
+        .bus_id         = 0,    /* OMAP1 SoC camera bus */
+        .i2c_adapter_id = 1,
+        .board_info     = &ams_delta_camera_board_info[0],
+        .module_name    = "ov6650",
+        .power          = ams_delta_camera_power,
+};
+
+static struct platform_device ams_delta_camera_device = {
+        .name   = "soc-camera-pdrv",
+        .id     = 0,
+        .dev    = {
+                .platform_data = &ams_delta_iclink,
+        },
+};
+
+static struct omap1_cam_platform_data ams_delta_camera_platform_data = {
+        .camexclk_khz   = 12000,        /* default 12MHz clock, no extra DPLL */
+        .lclk_khz_max   = 1334,         /* results in 5fps CIF, 10fps QCIF */
+};
+
 static struct platform_device *ams_delta_devices[] __initdata = {
+        &ams_delta_nand_device,
         &ams_delta_kp_device,
         &ams_delta_lcd_device,
         &ams_delta_led_device,
+        &ams_delta_camera_device,
 };
 
 static void __init ams_delta_init(void)
@@ -225,6 +294,20 @@ static void __init ams_delta_init(void)
         omap_cfg_reg(UART1_TX);
         omap_cfg_reg(UART1_RTS);
 
+        /* parallel camera interface */
+        omap_cfg_reg(H19_1610_CAM_EXCLK);
+        omap_cfg_reg(J15_1610_CAM_LCLK);
+        omap_cfg_reg(L18_1610_CAM_VS);
+        omap_cfg_reg(L15_1610_CAM_HS);
+        omap_cfg_reg(L19_1610_CAM_D0);
+        omap_cfg_reg(K14_1610_CAM_D1);
+        omap_cfg_reg(K15_1610_CAM_D2);
+        omap_cfg_reg(K19_1610_CAM_D3);
+        omap_cfg_reg(K18_1610_CAM_D4);
+        omap_cfg_reg(J14_1610_CAM_D5);
+        omap_cfg_reg(J19_1610_CAM_D6);
+        omap_cfg_reg(J18_1610_CAM_D7);
+
         iotable_init(ams_delta_io_desc, ARRAY_SIZE(ams_delta_io_desc));
 
         omap_board_config = ams_delta_config;
@@ -236,18 +319,21 @@ static void __init ams_delta_init(void)
         ams_delta_latch2_write(~0, 0);
 
         omap1_usb_init(&ams_delta_usb_config);
+        omap1_set_camera_info(&ams_delta_camera_platform_data);
+#ifdef CONFIG_LEDS_TRIGGERS
+        led_trigger_register_simple("ams_delta_camera",
+                        &ams_delta_camera_led_trigger);
+#endif
         platform_add_devices(ams_delta_devices, ARRAY_SIZE(ams_delta_devices));
 
-#ifdef CONFIG_AMS_DELTA_FIQ
         ams_delta_init_fiq();
-#endif
 
         omap_writew(omap_readw(ARM_RSTCT1) | 0x0004, ARM_RSTCT1);
 }
 
 static struct plat_serial8250_port ams_delta_modem_ports[] = {
         {
-                .membase        = (void *) AMS_DELTA_MODEM_VIRT,
+                .membase        = IOMEM(AMS_DELTA_MODEM_VIRT),
                 .mapbase        = AMS_DELTA_MODEM_PHYS,
                 .irq            = -EINVAL, /* changed later */
                 .flags          = UPF_BOOT_AUTOCONF,
@@ -271,6 +357,9 @@ static int __init ams_delta_modem_init(void)
 {
         int err;
 
+        if (!machine_is_ams_delta())
+                return -ENODEV;
+
         omap_cfg_reg(M14_1510_GPIO2);
         ams_delta_modem_ports[0].irq =
                         gpio_to_irq(AMS_DELTA_GPIO_PIN_MODEM_IRQ);
@@ -297,8 +386,6 @@ static void __init ams_delta_map_io(void)
 
 MACHINE_START(AMS_DELTA, "Amstrad E3 (Delta)")
         /* Maintainer: Jonathan McDowell <noodles@earth.li> */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = ams_delta_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-fsample.c b/arch/arm/mach-omap1/board-fsample.c
index 180ce79e5eac..87f173d93557 100644
--- a/arch/arm/mach-omap1/board-fsample.c
+++ b/arch/arm/mach-omap1/board-fsample.c
@@ -69,36 +69,35 @@
 #define fsample_cpld_clear(bit) \
     fsample_cpld_write(0xf0 | ((bit) & 15), FSAMPLE_CPLD_SET_CLR)
 
-static int fsample_keymap[] = {
-        KEY(0,0,KEY_UP),
-        KEY(0,1,KEY_RIGHT),
-        KEY(0,2,KEY_LEFT),
-        KEY(0,3,KEY_DOWN),
-        KEY(0,4,KEY_ENTER),
-        KEY(1,0,KEY_F10),
-        KEY(1,1,KEY_SEND),
-        KEY(1,2,KEY_END),
-        KEY(1,3,KEY_VOLUMEDOWN),
-        KEY(1,4,KEY_VOLUMEUP),
-        KEY(1,5,KEY_RECORD),
-        KEY(2,0,KEY_F9),
-        KEY(2,1,KEY_3),
-        KEY(2,2,KEY_6),
-        KEY(2,3,KEY_9),
-        KEY(2,4,KEY_KPDOT),
-        KEY(3,0,KEY_BACK),
-        KEY(3,1,KEY_2),
-        KEY(3,2,KEY_5),
-        KEY(3,3,KEY_8),
-        KEY(3,4,KEY_0),
-        KEY(3,5,KEY_KPSLASH),
-        KEY(4,0,KEY_HOME),
-        KEY(4,1,KEY_1),
-        KEY(4,2,KEY_4),
-        KEY(4,3,KEY_7),
-        KEY(4,4,KEY_KPASTERISK),
-        KEY(4,5,KEY_POWER),
-        0
+static const unsigned int fsample_keymap[] = {
+        KEY(0, 0, KEY_UP),
+        KEY(1, 0, KEY_RIGHT),
+        KEY(2, 0, KEY_LEFT),
+        KEY(3, 0, KEY_DOWN),
+        KEY(4, 0, KEY_ENTER),
+        KEY(0, 1, KEY_F10),
+        KEY(1, 1, KEY_SEND),
+        KEY(2, 1, KEY_END),
+        KEY(3, 1, KEY_VOLUMEDOWN),
+        KEY(4, 1, KEY_VOLUMEUP),
+        KEY(5, 1, KEY_RECORD),
+        KEY(0, 2, KEY_F9),
+        KEY(1, 2, KEY_3),
+        KEY(2, 2, KEY_6),
+        KEY(3, 2, KEY_9),
+        KEY(4, 2, KEY_KPDOT),
+        KEY(0, 3, KEY_BACK),
+        KEY(1, 3, KEY_2),
+        KEY(2, 3, KEY_5),
+        KEY(3, 3, KEY_8),
+        KEY(4, 3, KEY_0),
+        KEY(5, 3, KEY_KPSLASH),
+        KEY(0, 4, KEY_HOME),
+        KEY(1, 4, KEY_1),
+        KEY(2, 4, KEY_4),
+        KEY(3, 4, KEY_7),
+        KEY(4, 4, KEY_KPASTERISK),
+        KEY(5, 4, KEY_POWER),
 };
 
 static struct smc91x_platdata smc91x_info = {
@@ -120,6 +119,15 @@ static struct resource smc91x_resources[] = {
         },
 };
 
+static void __init fsample_init_smc91x(void)
+{
+        fpga_write(1, H2P2_DBG_FPGA_LAN_RESET);
+        mdelay(50);
+        fpga_write(fpga_read(H2P2_DBG_FPGA_LAN_RESET) & ~1,
+                   H2P2_DBG_FPGA_LAN_RESET);
+        mdelay(50);
+}
+
 static struct mtd_partition nor_partitions[] = {
         /* bootloader (U-Boot, etc) in first sector */
         {
@@ -244,11 +252,15 @@ static struct resource kp_resources[] = {
         },
 };
 
+static const struct matrix_keymap_data fsample_keymap_data = {
+        .keymap         = fsample_keymap,
+        .keymap_size    = ARRAY_SIZE(fsample_keymap),
+};
+
 static struct omap_kp_platform_data kp_data = {
         .rows           = 8,
         .cols           = 8,
-        .keymap         = fsample_keymap,
-        .keymapsize     = ARRAY_SIZE(fsample_keymap),
+        .keymap_data    = &fsample_keymap_data,
         .delay          = 4,
 };
 
@@ -275,16 +287,18 @@ static struct platform_device *devices[] __initdata = {
         &lcd_device,
 };
 
-static struct omap_lcd_config fsample_lcd_config __initdata = {
+static struct omap_lcd_config fsample_lcd_config = {
         .ctrl_name      = "internal",
 };
 
-static struct omap_board_config_kernel fsample_config[] = {
+static struct omap_board_config_kernel fsample_config[] __initdata = {
         { OMAP_TAG_LCD,         &fsample_lcd_config },
 };
 
 static void __init omap_fsample_init(void)
 {
+        fsample_init_smc91x();
+
         if (gpio_request(FSAMPLE_NAND_RB_GPIO_PIN, "NAND ready") < 0)
                 BUG();
         gpio_direction_input(FSAMPLE_NAND_RB_GPIO_PIN);
@@ -312,21 +326,10 @@ static void __init omap_fsample_init(void)
         omap_register_i2c_bus(1, 100, NULL, 0);
 }
 
-static void __init fsample_init_smc91x(void)
-{
-        fpga_write(1, H2P2_DBG_FPGA_LAN_RESET);
-        mdelay(50);
-        fpga_write(fpga_read(H2P2_DBG_FPGA_LAN_RESET) & ~1,
-                   H2P2_DBG_FPGA_LAN_RESET);
-        mdelay(50);
-}
-
 static void __init omap_fsample_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
-        fsample_init_smc91x();
 }
 
 /* Only FPGA needs to be mapped here. All others are done with ioremap */
@@ -386,8 +389,6 @@ static void __init omap_fsample_map_io(void)
 
 MACHINE_START(OMAP_FSAMPLE, "OMAP730 F-Sample")
 /* Maintainer: Brian Swetland <swetland@google.com> */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = omap_fsample_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-generic.c b/arch/arm/mach-omap1/board-generic.c
index 93b9ab8fc3be..23f4ab9e2651 100644
--- a/arch/arm/mach-omap1/board-generic.c
+++ b/arch/arm/mach-omap1/board-generic.c
@@ -94,8 +94,6 @@ static void __init omap_generic_map_io(void)
 
 MACHINE_START(OMAP_GENERIC, "Generic OMAP1510/1610/1710")
         /* Maintainer: Tony Lindgren <tony@atomide.com> */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = omap_generic_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-h2-mmc.c b/arch/arm/mach-omap1/board-h2-mmc.c
index b30c4990744d..f2fc43d8382b 100644
--- a/arch/arm/mach-omap1/board-h2-mmc.c
+++ b/arch/arm/mach-omap1/board-h2-mmc.c
@@ -58,8 +58,7 @@ static struct omap_mmc_platform_data mmc1_data = {
         .dma_mask                       = 0xffffffff,
         .slots[0]       = {
                 .set_power              = mmc_set_power,
-                .ocr_mask               = MMC_VDD_28_29 | MMC_VDD_30_31 |
-                                          MMC_VDD_32_33 | MMC_VDD_33_34,
+                .ocr_mask               = MMC_VDD_32_33 | MMC_VDD_33_34,
                 .name                   = "mmcblk",
         },
 };
diff --git a/arch/arm/mach-omap1/board-h2.c b/arch/arm/mach-omap1/board-h2.c
index d2cda58bcc48..ba3bd09c4754 100644
--- a/arch/arm/mach-omap1/board-h2.c
+++ b/arch/arm/mach-omap1/board-h2.c
@@ -52,43 +52,42 @@
 /* At OMAP1610 Innovator the Ethernet is directly connected to CS1 */
 #define OMAP1610_ETHR_START             0x04000300
 
-static int h2_keymap[] = {
+static const unsigned int h2_keymap[] = {
         KEY(0, 0, KEY_LEFT),
-        KEY(0, 1, KEY_RIGHT),
-        KEY(0, 2, KEY_3),
-        KEY(0, 3, KEY_F10),
-        KEY(0, 4, KEY_F5),
-        KEY(0, 5, KEY_9),
-        KEY(1, 0, KEY_DOWN),
+        KEY(1, 0, KEY_RIGHT),
+        KEY(2, 0, KEY_3),
+        KEY(3, 0, KEY_F10),
+        KEY(4, 0, KEY_F5),
+        KEY(5, 0, KEY_9),
+        KEY(0, 1, KEY_DOWN),
         KEY(1, 1, KEY_UP),
-        KEY(1, 2, KEY_2),
-        KEY(1, 3, KEY_F9),
-        KEY(1, 4, KEY_F7),
-        KEY(1, 5, KEY_0),
-        KEY(2, 0, KEY_ENTER),
-        KEY(2, 1, KEY_6),
+        KEY(2, 1, KEY_2),
+        KEY(3, 1, KEY_F9),
+        KEY(4, 1, KEY_F7),
+        KEY(5, 1, KEY_0),
+        KEY(0, 2, KEY_ENTER),
+        KEY(1, 2, KEY_6),
         KEY(2, 2, KEY_1),
-        KEY(2, 3, KEY_F2),
-        KEY(2, 4, KEY_F6),
-        KEY(2, 5, KEY_HOME),
-        KEY(3, 0, KEY_8),
-        KEY(3, 1, KEY_5),
-        KEY(3, 2, KEY_F12),
+        KEY(3, 2, KEY_F2),
+        KEY(4, 2, KEY_F6),
+        KEY(5, 2, KEY_HOME),
+        KEY(0, 3, KEY_8),
+        KEY(1, 3, KEY_5),
+        KEY(2, 3, KEY_F12),
         KEY(3, 3, KEY_F3),
-        KEY(3, 4, KEY_F8),
-        KEY(3, 5, KEY_END),
-        KEY(4, 0, KEY_7),
-        KEY(4, 1, KEY_4),
-        KEY(4, 2, KEY_F11),
-        KEY(4, 3, KEY_F1),
+        KEY(4, 3, KEY_F8),
+        KEY(5, 3, KEY_END),
+        KEY(0, 4, KEY_7),
+        KEY(1, 4, KEY_4),
+        KEY(2, 4, KEY_F11),
+        KEY(3, 4, KEY_F1),
         KEY(4, 4, KEY_F4),
-        KEY(4, 5, KEY_ESC),
-        KEY(5, 0, KEY_F13),
-        KEY(5, 1, KEY_F14),
-        KEY(5, 2, KEY_F15),
-        KEY(5, 3, KEY_F16),
-        KEY(5, 4, KEY_SLEEP),
-        0
+        KEY(5, 4, KEY_ESC),
+        KEY(0, 5, KEY_F13),
+        KEY(1, 5, KEY_F14),
+        KEY(2, 5, KEY_F15),
+        KEY(3, 5, KEY_F16),
+        KEY(4, 5, KEY_SLEEP),
 };
 
 static struct mtd_partition h2_nor_partitions[] = {
@@ -203,7 +202,7 @@ static int h2_nand_dev_ready(struct mtd_info *mtd)
 
 static const char *h2_part_probes[] = { "cmdlinepart", NULL };
 
-struct platform_nand_data h2_nand_platdata = {
+static struct platform_nand_data h2_nand_platdata = {
         .chip   = {
                 .nr_chips               = 1,
                 .chip_offset            = 0,
@@ -270,14 +269,18 @@ static struct resource h2_kp_resources[] = {
         },
 };
 
+static const struct matrix_keymap_data h2_keymap_data = {
+        .keymap         = h2_keymap,
+        .keymap_size    = ARRAY_SIZE(h2_keymap),
+};
+
 static struct omap_kp_platform_data h2_kp_data = {
         .rows           = 8,
         .cols           = 8,
-        .keymap         = h2_keymap,
-        .keymapsize     = ARRAY_SIZE(h2_keymap),
-        .rep            = 1,
+        .keymap_data    = &h2_keymap_data,
+        .rep            = true,
         .delay          = 9,
-        .dbounce        = 1,
+        .dbounce        = true,
 };
 
 static struct platform_device h2_kp_device = {
@@ -374,8 +377,6 @@ static void __init h2_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
-        h2_init_smc91x();
 }
 
 static struct omap_usb_config h2_usb_config __initdata = {
@@ -403,6 +404,8 @@ static struct omap_board_config_kernel h2_config[] __initdata = {
 
 static void __init h2_init(void)
 {
+        h2_init_smc91x();
+
         /* Here we assume the NOR boot config:  NOR on CS3 (possibly swapped
          * to address 0 by a dip switch), NAND on CS2B.  The NAND driver will
          * notice whether a NAND chip is enabled at probe time.
@@ -458,8 +461,6 @@ static void __init h2_map_io(void)
 
 MACHINE_START(OMAP_H2, "TI-H2")
         /* Maintainer: Imre Deak <imre.deak@nokia.com> */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = h2_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-h3-mmc.c b/arch/arm/mach-omap1/board-h3-mmc.c
index 54b0f063e263..2098525e7cc5 100644
--- a/arch/arm/mach-omap1/board-h3-mmc.c
+++ b/arch/arm/mach-omap1/board-h3-mmc.c
@@ -40,8 +40,7 @@ static struct omap_mmc_platform_data mmc1_data = {
         .dma_mask                       = 0xffffffff,
         .slots[0]       = {
                 .set_power              = mmc_set_power,
-                .ocr_mask               = MMC_VDD_28_29 | MMC_VDD_30_31 |
-                                          MMC_VDD_32_33 | MMC_VDD_33_34,
+                .ocr_mask               = MMC_VDD_32_33 | MMC_VDD_33_34,
                 .name                   = "mmcblk",
         },
 };
diff --git a/arch/arm/mach-omap1/board-h3.c b/arch/arm/mach-omap1/board-h3.c
index c2ef4ff846c7..ac48677672ee 100644
--- a/arch/arm/mach-omap1/board-h3.c
+++ b/arch/arm/mach-omap1/board-h3.c
@@ -56,43 +56,42 @@
 
 #define H3_TS_GPIO      48
 
-static int h3_keymap[] = {
+static const unsigned int h3_keymap[] = {
         KEY(0, 0, KEY_LEFT),
-        KEY(0, 1, KEY_RIGHT),
-        KEY(0, 2, KEY_3),
-        KEY(0, 3, KEY_F10),
-        KEY(0, 4, KEY_F5),
-        KEY(0, 5, KEY_9),
-        KEY(1, 0, KEY_DOWN),
+        KEY(1, 0, KEY_RIGHT),
+        KEY(2, 0, KEY_3),
+        KEY(3, 0, KEY_F10),
+        KEY(4, 0, KEY_F5),
+        KEY(5, 0, KEY_9),
+        KEY(0, 1, KEY_DOWN),
         KEY(1, 1, KEY_UP),
-        KEY(1, 2, KEY_2),
-        KEY(1, 3, KEY_F9),
-        KEY(1, 4, KEY_F7),
-        KEY(1, 5, KEY_0),
-        KEY(2, 0, KEY_ENTER),
-        KEY(2, 1, KEY_6),
+        KEY(2, 1, KEY_2),
+        KEY(3, 1, KEY_F9),
+        KEY(4, 1, KEY_F7),
+        KEY(5, 1, KEY_0),
+        KEY(0, 2, KEY_ENTER),
+        KEY(1, 2, KEY_6),
         KEY(2, 2, KEY_1),
-        KEY(2, 3, KEY_F2),
-        KEY(2, 4, KEY_F6),
-        KEY(2, 5, KEY_HOME),
-        KEY(3, 0, KEY_8),
-        KEY(3, 1, KEY_5),
-        KEY(3, 2, KEY_F12),
+        KEY(3, 2, KEY_F2),
+        KEY(4, 2, KEY_F6),
+        KEY(5, 2, KEY_HOME),
+        KEY(0, 3, KEY_8),
+        KEY(1, 3, KEY_5),
+        KEY(2, 3, KEY_F12),
         KEY(3, 3, KEY_F3),
-        KEY(3, 4, KEY_F8),
-        KEY(3, 5, KEY_END),
-        KEY(4, 0, KEY_7),
-        KEY(4, 1, KEY_4),
-        KEY(4, 2, KEY_F11),
-        KEY(4, 3, KEY_F1),
+        KEY(4, 3, KEY_F8),
+        KEY(5, 3, KEY_END),
+        KEY(0, 4, KEY_7),
+        KEY(1, 4, KEY_4),
+        KEY(2, 4, KEY_F11),
+        KEY(3, 4, KEY_F1),
         KEY(4, 4, KEY_F4),
-        KEY(4, 5, KEY_ESC),
-        KEY(5, 0, KEY_F13),
-        KEY(5, 1, KEY_F14),
-        KEY(5, 2, KEY_F15),
-        KEY(5, 3, KEY_F16),
-        KEY(5, 4, KEY_SLEEP),
-        0
+        KEY(5, 4, KEY_ESC),
+        KEY(0, 5, KEY_F13),
+        KEY(1, 5, KEY_F14),
+        KEY(2, 5, KEY_F15),
+        KEY(3, 5, KEY_F16),
+        KEY(4, 5, KEY_SLEEP),
 };
 
 
@@ -205,7 +204,7 @@ static int nand_dev_ready(struct mtd_info *mtd)
 
 static const char *part_probes[] = { "cmdlinepart", NULL };
 
-struct platform_nand_data nand_platdata = {
+static struct platform_nand_data nand_platdata = {
         .chip   = {
                 .nr_chips               = 1,
                 .chip_offset            = 0,
@@ -264,6 +263,15 @@ static struct platform_device smc91x_device = {
         .resource       = smc91x_resources,
 };
 
+static void __init h3_init_smc91x(void)
+{
+        omap_cfg_reg(W15_1710_GPIO40);
+        if (gpio_request(40, "SMC91x irq") < 0) {
+                printk("Error requesting gpio 40 for smc91x irq\n");
+                return;
+        }
+}
+
 #define GPTIMER_BASE            0xFFFB1400
 #define GPTIMER_REGS(x) (0xFFFB1400 + (x * 0x800))
 #define GPTIMER_REGS_SIZE       0x46
@@ -296,14 +304,18 @@ static struct resource h3_kp_resources[] = {
         },
 };
 
+static const struct matrix_keymap_data h3_keymap_data = {
+        .keymap         = h3_keymap,
+        .keymap_size    = ARRAY_SIZE(h3_keymap),
+};
+
 static struct omap_kp_platform_data h3_kp_data = {
         .rows           = 8,
         .cols           = 8,
-        .keymap         = h3_keymap,
-        .keymapsize     = ARRAY_SIZE(h3_keymap),
-        .rep            = 1,
+        .keymap_data    = &h3_keymap_data,
+        .rep            = true,
         .delay          = 9,
-        .dbounce        = 1,
+        .dbounce        = true,
 };
 
 static struct platform_device h3_kp_device = {
@@ -376,6 +388,8 @@ static struct i2c_board_info __initdata h3_i2c_board_info[] = {
 
 static void __init h3_init(void)
 {
+        h3_init_smc91x();
+
         /* Here we assume the NOR boot config:  NOR on CS3 (possibly swapped
          * to address 0 by a dip switch), NAND on CS2B.  The NAND driver will
          * notice whether a NAND chip is enabled at probe time.
@@ -422,21 +436,10 @@ static void __init h3_init(void)
         h3_mmc_init();
 }
 
-static void __init h3_init_smc91x(void)
-{
-        omap_cfg_reg(W15_1710_GPIO40);
-        if (gpio_request(40, "SMC91x irq") < 0) {
-                printk("Error requesting gpio 40 for smc91x irq\n");
-                return;
-        }
-}
-
 static void __init h3_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
-        h3_init_smc91x();
 }
 
 static void __init h3_map_io(void)
@@ -446,8 +449,6 @@ static void __init h3_map_io(void)
 
 MACHINE_START(OMAP_H3, "TI OMAP1710 H3 board")
         /* Maintainer: Texas Instruments, Inc. */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = h3_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-htcherald.c b/arch/arm/mach-omap1/board-htcherald.c
index 311899ff5ffc..ba05a51f9408 100644
--- a/arch/arm/mach-omap1/board-htcherald.c
+++ b/arch/arm/mach-omap1/board-htcherald.c
@@ -30,6 +30,13 @@
 #include <linux/input.h>
 #include <linux/io.h>
 #include <linux/gpio.h>
+#include <linux/gpio_keys.h>
+#include <linux/i2c.h>
+#include <linux/i2c-gpio.h>
+#include <linux/htcpld.h>
+#include <linux/leds.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/ads7846.h>
 
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
@@ -39,6 +46,7 @@
 #include <plat/board.h>
 #include <plat/keypad.h>
 #include <plat/usb.h>
+#include <plat/mmc.h>
 
 #include <mach/irqs.h>
 
@@ -52,74 +60,188 @@
 #define       OMAP_LCDC_CTRL_LCD_EN           (1 << 0)
 #define       OMAP_LCDC_STAT_DONE             (1 << 0)
 
-static struct omap_lcd_config htcherald_lcd_config __initdata = {
-        .ctrl_name      = "internal",
-};
+/* GPIO definitions for the power button and keyboard slide switch */
+#define HTCHERALD_GPIO_POWER 139
+#define HTCHERALD_GPIO_SLIDE 174
+#define HTCHERALD_GIRQ_BTNS 141
 
-static struct omap_board_config_kernel htcherald_config[] __initdata = {
-        { OMAP_TAG_LCD, &htcherald_lcd_config },
-};
+/* GPIO definitions for the touchscreen */
+#define HTCHERALD_GPIO_TS 76
+
+/* HTCPLD definitions */
+
+/*
+ * CPLD Logic
+ *
+ * Chip 3 - 0x03
+ *
+ * Function            7 6 5 4  3 2 1 0
+ * ------------------------------------
+ * DPAD light          x x x x  x x x 1
+ * SoundDev            x x x x  1 x x x
+ * Screen white        1 x x x  x x x x
+ * MMC power on        x x x x  x 1 x x
+ * Happy times (n)     0 x x x  x 1 x x
+ *
+ * Chip 4 - 0x04
+ *
+ * Function            7 6 5 4  3 2 1 0
+ * ------------------------------------
+ * Keyboard light      x x x x  x x x 1
+ * LCD Bright (4)      x x x x  x 1 1 x
+ * LCD Bright (3)      x x x x  x 0 1 x
+ * LCD Bright (2)      x x x x  x 1 0 x
+ * LCD Bright (1)      x x x x  x 0 0 x
+ * LCD Off             x x x x  0 x x x
+ * LCD image (fb)      1 x x x  x x x x
+ * LCD image (white)   0 x x x  x x x x
+ * Caps lock LED       x x 1 x  x x x x
+ *
+ * Chip 5 - 0x05
+ *
+ * Function            7 6 5 4  3 2 1 0
+ * ------------------------------------
+ * Red (solid)         x x x x  x 1 x x
+ * Red (flash)         x x x x  x x 1 x
+ * Green (GSM flash)   x x x x  1 x x x
+ * Green (GSM solid)   x x x 1  x x x x
+ * Green (wifi flash)  x x 1 x  x x x x
+ * Blue (bt flash)     x 1 x x  x x x x
+ * DPAD Int Enable     1 x x x  x x x 0
+ *
+ * (Combinations of the above can be made for different colors.)
+ * The direction pad interrupt enable must be set each time the
+ * interrupt is handled.
+ *
+ * Chip 6 - 0x06
+ *
+ * Function            7 6 5 4  3 2 1 0
+ * ------------------------------------
+ * Vibrator            x x x x  1 x x x
+ * Alt LED             x x x 1  x x x x
+ * Screen white        1 x x x  x x x x
+ * Screen white        x x 1 x  x x x x
+ * Screen white        x 0 x x  x x x x
+ * Enable kbd dpad     x x x x  x x 0 x
+ * Happy Times         0 1 0 x  x x 0 x
+ */
+
+/*
+ * HTCPLD GPIO lines start 16 after OMAP_MAX_GPIO_LINES to account
+ * for the 16 MPUIO lines.
+ */
+#define HTCPLD_GPIO_START_OFFSET        (OMAP_MAX_GPIO_LINES + 16)
+#define HTCPLD_IRQ(chip, offset)        (OMAP_IRQ_END + 8 * (chip) + (offset))
+#define HTCPLD_BASE(chip, offset)       \
+        (HTCPLD_GPIO_START_OFFSET + 8 * (chip) + (offset))
+
+#define HTCPLD_GPIO_LED_DPAD            HTCPLD_BASE(0, 0)
+#define HTCPLD_GPIO_LED_KBD             HTCPLD_BASE(1, 0)
+#define HTCPLD_GPIO_LED_CAPS            HTCPLD_BASE(1, 5)
+#define HTCPLD_GPIO_LED_RED_FLASH       HTCPLD_BASE(2, 1)
+#define HTCPLD_GPIO_LED_RED_SOLID       HTCPLD_BASE(2, 2)
+#define HTCPLD_GPIO_LED_GREEN_FLASH     HTCPLD_BASE(2, 3)
+#define HTCPLD_GPIO_LED_GREEN_SOLID     HTCPLD_BASE(2, 4)
+#define HTCPLD_GPIO_LED_WIFI            HTCPLD_BASE(2, 5)
+#define HTCPLD_GPIO_LED_BT              HTCPLD_BASE(2, 6)
+#define HTCPLD_GPIO_LED_VIBRATE         HTCPLD_BASE(3, 3)
+#define HTCPLD_GPIO_LED_ALT             HTCPLD_BASE(3, 4)
+
+#define HTCPLD_GPIO_RIGHT_KBD           HTCPLD_BASE(6, 7)
+#define HTCPLD_GPIO_UP_KBD              HTCPLD_BASE(6, 6)
+#define HTCPLD_GPIO_LEFT_KBD            HTCPLD_BASE(6, 5)
+#define HTCPLD_GPIO_DOWN_KBD            HTCPLD_BASE(6, 4)
+
+#define HTCPLD_GPIO_RIGHT_DPAD          HTCPLD_BASE(7, 7)
+#define HTCPLD_GPIO_UP_DPAD             HTCPLD_BASE(7, 6)
+#define HTCPLD_GPIO_LEFT_DPAD           HTCPLD_BASE(7, 5)
+#define HTCPLD_GPIO_DOWN_DPAD           HTCPLD_BASE(7, 4)
+#define HTCPLD_GPIO_ENTER_DPAD          HTCPLD_BASE(7, 3)
+
+/*
+ * The htcpld chip requires a gpio write to a specific line
+ * to re-enable interrupts after one has occurred.
+ */
+#define HTCPLD_GPIO_INT_RESET_HI        HTCPLD_BASE(2, 7)
+#define HTCPLD_GPIO_INT_RESET_LO        HTCPLD_BASE(2, 0)
+
+/* Chip 5 */
+#define HTCPLD_IRQ_RIGHT_KBD            HTCPLD_IRQ(0, 7)
+#define HTCPLD_IRQ_UP_KBD               HTCPLD_IRQ(0, 6)
+#define HTCPLD_IRQ_LEFT_KBD             HTCPLD_IRQ(0, 5)
+#define HTCPLD_IRQ_DOWN_KBD             HTCPLD_IRQ(0, 4)
+
+/* Chip 6 */
+#define HTCPLD_IRQ_RIGHT_DPAD           HTCPLD_IRQ(1, 7)
+#define HTCPLD_IRQ_UP_DPAD              HTCPLD_IRQ(1, 6)
+#define HTCPLD_IRQ_LEFT_DPAD            HTCPLD_IRQ(1, 5)
+#define HTCPLD_IRQ_DOWN_DPAD            HTCPLD_IRQ(1, 4)
+#define HTCPLD_IRQ_ENTER_DPAD           HTCPLD_IRQ(1, 3)
 
 /* Keyboard definition */
 
-static int htc_herald_keymap[] = {
+static const unsigned int htc_herald_keymap[] = {
         KEY(0, 0, KEY_RECORD), /* Mail button */
-        KEY(0, 1, KEY_CAMERA), /* Camera */
-        KEY(0, 2, KEY_PHONE), /* Send key */
-        KEY(0, 3, KEY_VOLUMEUP), /* Volume up */
-        KEY(0, 4, KEY_F2),  /* Right bar (landscape) */
-        KEY(0, 5, KEY_MAIL), /* Win key (portrait) */
-        KEY(0, 6, KEY_DIRECTORY), /* Right bar (protrait) */
-        KEY(1, 0, KEY_LEFTCTRL), /* Windows key */
+        KEY(1, 0, KEY_CAMERA), /* Camera */
+        KEY(2, 0, KEY_PHONE), /* Send key */
+        KEY(3, 0, KEY_VOLUMEUP), /* Volume up */
+        KEY(4, 0, KEY_F2),  /* Right bar (landscape) */
+        KEY(5, 0, KEY_MAIL), /* Win key (portrait) */
+        KEY(6, 0, KEY_DIRECTORY), /* Right bar (protrait) */
+        KEY(0, 1, KEY_LEFTCTRL), /* Windows key */
         KEY(1, 1, KEY_COMMA),
-        KEY(1, 2, KEY_M),
-        KEY(1, 3, KEY_K),
-        KEY(1, 4, KEY_SLASH), /* OK key */
-        KEY(1, 5, KEY_I),
-        KEY(1, 6, KEY_U),
-        KEY(2, 0, KEY_LEFTALT),
-        KEY(2, 1, KEY_TAB),
+        KEY(2, 1, KEY_M),
+        KEY(3, 1, KEY_K),
+        KEY(4, 1, KEY_SLASH), /* OK key */
+        KEY(5, 1, KEY_I),
+        KEY(6, 1, KEY_U),
+        KEY(0, 2, KEY_LEFTALT),
+        KEY(1, 2, KEY_TAB),
         KEY(2, 2, KEY_N),
-        KEY(2, 3, KEY_J),
-        KEY(2, 4, KEY_ENTER),
-        KEY(2, 5, KEY_H),
-        KEY(2, 6, KEY_Y),
-        KEY(3, 0, KEY_SPACE),
-        KEY(3, 1, KEY_L),
-        KEY(3, 2, KEY_B),
+        KEY(3, 2, KEY_J),
+        KEY(4, 2, KEY_ENTER),
+        KEY(5, 2, KEY_H),
+        KEY(6, 2, KEY_Y),
+        KEY(0, 3, KEY_SPACE),
+        KEY(1, 3, KEY_L),
+        KEY(2, 3, KEY_B),
         KEY(3, 3, KEY_V),
-        KEY(3, 4, KEY_BACKSPACE),
-        KEY(3, 5, KEY_G),
-        KEY(3, 6, KEY_T),
-        KEY(4, 0, KEY_CAPSLOCK), /* Shift */
-        KEY(4, 1, KEY_C),
-        KEY(4, 2, KEY_F),
-        KEY(4, 3, KEY_R),
+        KEY(4, 3, KEY_BACKSPACE),
+        KEY(5, 3, KEY_G),
+        KEY(6, 3, KEY_T),
+        KEY(0, 4, KEY_CAPSLOCK), /* Shift */
+        KEY(1, 4, KEY_C),
+        KEY(2, 4, KEY_F),
+        KEY(3, 4, KEY_R),
         KEY(4, 4, KEY_O),
-        KEY(4, 5, KEY_E),
-        KEY(4, 6, KEY_D),
-        KEY(5, 0, KEY_X),
-        KEY(5, 1, KEY_Z),
-        KEY(5, 2, KEY_S),
-        KEY(5, 3, KEY_W),
-        KEY(5, 4, KEY_P),
+        KEY(5, 4, KEY_E),
+        KEY(6, 4, KEY_D),
+        KEY(0, 5, KEY_X),
+        KEY(1, 5, KEY_Z),
+        KEY(2, 5, KEY_S),
+        KEY(3, 5, KEY_W),
+        KEY(4, 5, KEY_P),
         KEY(5, 5, KEY_Q),
-        KEY(5, 6, KEY_A),
-        KEY(6, 0, KEY_CONNECT), /* Voice button */
-        KEY(6, 2, KEY_CANCEL), /* End key */
-        KEY(6, 3, KEY_VOLUMEDOWN), /* Volume down */
-        KEY(6, 4, KEY_F1), /* Left bar (landscape) */
-        KEY(6, 5, KEY_WWW), /* OK button (portrait) */
+        KEY(6, 5, KEY_A),
+        KEY(0, 6, KEY_CONNECT), /* Voice button */
+        KEY(2, 6, KEY_CANCEL), /* End key */
+        KEY(3, 6, KEY_VOLUMEDOWN), /* Volume down */
+        KEY(4, 6, KEY_F1), /* Left bar (landscape) */
+        KEY(5, 6, KEY_WWW), /* OK button (portrait) */
         KEY(6, 6, KEY_CALENDAR), /* Left bar (portrait) */
-        0
 };
 
-struct omap_kp_platform_data htcherald_kp_data = {
+static const struct matrix_keymap_data htc_herald_keymap_data = {
+        .keymap         = htc_herald_keymap,
+        .keymap_size    = ARRAY_SIZE(htc_herald_keymap),
+};
+
+static struct omap_kp_platform_data htcherald_kp_data = {
         .rows   = 7,
         .cols   = 7,
         .delay = 20,
-        .rep = 1,
-        .keymap = htc_herald_keymap,
+        .rep = true,
+        .keymap_data = &htc_herald_keymap_data,
 };
 
 static struct resource kp_resources[] = {
@@ -140,6 +262,129 @@ static struct platform_device kp_device = {
         .resource       = kp_resources,
 };
 
+/* GPIO buttons for keyboard slide and power button */
+static struct gpio_keys_button herald_gpio_keys_table[] = {
+        {BTN_0,  HTCHERALD_GPIO_POWER, 1, "POWER", EV_KEY, 1, 20},
+        {SW_LID, HTCHERALD_GPIO_SLIDE, 0, "SLIDE", EV_SW,  1, 20},
+
+        {KEY_LEFT,  HTCPLD_GPIO_LEFT_KBD,  1, "LEFT",  EV_KEY, 1, 20},
+        {KEY_RIGHT, HTCPLD_GPIO_RIGHT_KBD, 1, "RIGHT", EV_KEY, 1, 20},
+        {KEY_UP,    HTCPLD_GPIO_UP_KBD,    1, "UP",    EV_KEY, 1, 20},
+        {KEY_DOWN,  HTCPLD_GPIO_DOWN_KBD,  1, "DOWN",  EV_KEY, 1, 20},
+
+        {KEY_LEFT,  HTCPLD_GPIO_LEFT_DPAD,   1, "DLEFT",  EV_KEY, 1, 20},
+        {KEY_RIGHT, HTCPLD_GPIO_RIGHT_DPAD,  1, "DRIGHT", EV_KEY, 1, 20},
+        {KEY_UP,    HTCPLD_GPIO_UP_DPAD,     1, "DUP",    EV_KEY, 1, 20},
+        {KEY_DOWN,  HTCPLD_GPIO_DOWN_DPAD,   1, "DDOWN",  EV_KEY, 1, 20},
+        {KEY_ENTER, HTCPLD_GPIO_ENTER_DPAD,  1, "DENTER", EV_KEY, 1, 20},
+};
+
+static struct gpio_keys_platform_data herald_gpio_keys_data = {
+        .buttons        = herald_gpio_keys_table,
+        .nbuttons       = ARRAY_SIZE(herald_gpio_keys_table),
+        .rep            = true,
+};
+
+static struct platform_device herald_gpiokeys_device = {
+        .name      = "gpio-keys",
+        .id             = -1,
+        .dev = {
+                .platform_data = &herald_gpio_keys_data,
+        },
+};
+
+/* LEDs for the Herald.  These connect to the HTCPLD GPIO device. */
+static struct gpio_led gpio_leds[] = {
+        {"dpad",        NULL, HTCPLD_GPIO_LED_DPAD,        0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"kbd",         NULL, HTCPLD_GPIO_LED_KBD,         0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"vibrate",     NULL, HTCPLD_GPIO_LED_VIBRATE,     0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"green_solid", NULL, HTCPLD_GPIO_LED_GREEN_SOLID, 0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"green_flash", NULL, HTCPLD_GPIO_LED_GREEN_FLASH, 0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"red_solid",   "mmc0", HTCPLD_GPIO_LED_RED_SOLID, 0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"red_flash",   NULL, HTCPLD_GPIO_LED_RED_FLASH,   0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"wifi",        NULL, HTCPLD_GPIO_LED_WIFI,        0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"bt",          NULL, HTCPLD_GPIO_LED_BT,          0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"caps",        NULL, HTCPLD_GPIO_LED_CAPS,        0, 0, LEDS_GPIO_DEFSTATE_OFF},
+        {"alt",         NULL, HTCPLD_GPIO_LED_ALT,         0, 0, LEDS_GPIO_DEFSTATE_OFF},
+};
+
+static struct gpio_led_platform_data gpio_leds_data = {
+        .leds           = gpio_leds,
+        .num_leds       = ARRAY_SIZE(gpio_leds),
+};
+
+static struct platform_device gpio_leds_device = {
+        .name           = "leds-gpio",
+        .id             = 0,
+        .dev    = {
+                .platform_data  = &gpio_leds_data,
+        },
+};
+
+/* HTC PLD chips */
+
+static struct resource htcpld_resources[] = {
+        [0] = {
+                .start  = OMAP_GPIO_IRQ(HTCHERALD_GIRQ_BTNS),
+                .end    = OMAP_GPIO_IRQ(HTCHERALD_GIRQ_BTNS),
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct htcpld_chip_platform_data htcpld_chips[] = {
+        [0] = {
+                .addr           = 0x03,
+                .reset          = 0x04,
+                .num_gpios      = 8,
+                .gpio_out_base  = HTCPLD_BASE(0, 0),
+                .gpio_in_base   = HTCPLD_BASE(4, 0),
+        },
+        [1] = {
+                .addr           = 0x04,
+                .reset          = 0x8e,
+                .num_gpios      = 8,
+                .gpio_out_base  = HTCPLD_BASE(1, 0),
+                .gpio_in_base   = HTCPLD_BASE(5, 0),
+        },
+        [2] = {
+                .addr           = 0x05,
+                .reset          = 0x80,
+                .num_gpios      = 8,
+                .gpio_out_base  = HTCPLD_BASE(2, 0),
+                .gpio_in_base   = HTCPLD_BASE(6, 0),
+                .irq_base       = HTCPLD_IRQ(0, 0),
+                .num_irqs       = 8,
+        },
+        [3] = {
+                .addr           = 0x06,
+                .reset          = 0x40,
+                .num_gpios      = 8,
+                .gpio_out_base  = HTCPLD_BASE(3, 0),
+                .gpio_in_base   = HTCPLD_BASE(7, 0),
+                .irq_base       = HTCPLD_IRQ(1, 0),
+                .num_irqs       = 8,
+        },
+};
+
+static struct htcpld_core_platform_data htcpld_pfdata = {
+        .int_reset_gpio_hi = HTCPLD_GPIO_INT_RESET_HI,
+        .int_reset_gpio_lo = HTCPLD_GPIO_INT_RESET_LO,
+        .i2c_adapter_id    = 1,
+
+        .chip              = htcpld_chips,
+        .num_chip          = ARRAY_SIZE(htcpld_chips),
+};
+
+static struct platform_device htcpld_device = {
+        .name           = "i2c-htcpld",
+        .id             = -1,
+        .resource       = htcpld_resources,
+        .num_resources  = ARRAY_SIZE(htcpld_resources),
+        .dev    = {
+                .platform_data  = &htcpld_pfdata,
+        },
+};
+
 /* USB Device */
 static struct omap_usb_config htcherald_usb_config __initdata = {
         .otg = 0,
@@ -150,14 +395,71 @@ static struct omap_usb_config htcherald_usb_config __initdata = {
 };
 
 /* LCD Device resources */
+static struct omap_lcd_config htcherald_lcd_config __initdata = {
+        .ctrl_name      = "internal",
+};
+
+static struct omap_board_config_kernel htcherald_config[] __initdata = {
+        { OMAP_TAG_LCD, &htcherald_lcd_config },
+};
+
 static struct platform_device lcd_device = {
         .name           = "lcd_htcherald",
         .id             = -1,
 };
 
+/* MMC Card */
+#if defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE)
+static struct omap_mmc_platform_data htc_mmc1_data = {
+        .nr_slots                       = 1,
+        .switch_slot                    = NULL,
+        .slots[0]       = {
+                .ocr_mask               = MMC_VDD_32_33 | MMC_VDD_33_34,
+                .name                   = "mmcblk",
+                .nomux                  = 1,
+                .wires                  = 4,
+                .switch_pin             = -1,
+        },
+};
+
+static struct omap_mmc_platform_data *htc_mmc_data[1];
+#endif
+
+
+/* Platform devices for the Herald */
 static struct platform_device *devices[] __initdata = {
         &kp_device,
         &lcd_device,
+        &htcpld_device,
+        &gpio_leds_device,
+        &herald_gpiokeys_device,
+};
+
+/*
+ * Touchscreen
+ */
+static const struct ads7846_platform_data htcherald_ts_platform_data = {
+        .model                  = 7846,
+        .keep_vref_on           = 1,
+        .x_plate_ohms           = 496,
+        .gpio_pendown           = HTCHERALD_GPIO_TS,
+        .pressure_max           = 10000,
+        .pressure_min           = 5000,
+        .x_min                  = 528,
+        .x_max                  = 3760,
+        .y_min                  = 624,
+        .y_max                  = 3760,
+};
+
+static struct spi_board_info __initdata htcherald_spi_board_info[] = {
+        {
+                .modalias               = "ads7846",
+                .platform_data          = &htcherald_ts_platform_data,
+                .irq                    = OMAP_GPIO_IRQ(HTCHERALD_GPIO_TS),
+                .max_speed_hz           = 2500000,
+                .bus_num                = 2,
+                .chip_select            = 1,
+        }
 };
 
 /*
@@ -278,8 +580,7 @@ static void __init htcherald_init(void)
 {
         printk(KERN_INFO "HTC Herald init.\n");
 
-        omap_gpio_init();
-
+        /* Do board initialization before we register all the devices */
         omap_board_config = htcherald_config;
         omap_board_config_size = ARRAY_SIZE(htcherald_config);
         platform_add_devices(devices, ARRAY_SIZE(devices));
@@ -288,6 +589,16 @@ static void __init htcherald_init(void)
 
         htcherald_usb_enable();
         omap1_usb_init(&htcherald_usb_config);
+
+        spi_register_board_info(htcherald_spi_board_info,
+                ARRAY_SIZE(htcherald_spi_board_info));
+
+        omap_register_i2c_bus(1, 100, NULL, 0);
+
+#if defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE)
+        htc_mmc_data[0] = &htc_mmc1_data;
+        omap1_init_mmc(htc_mmc_data, 1);
+#endif
 }
 
 static void __init htcherald_init_irq(void)
@@ -300,8 +611,6 @@ static void __init htcherald_init_irq(void)
 MACHINE_START(HERALD, "HTC Herald")
         /* Maintainer: Cory Maccarrone <darkstar6262@gmail.com> */
         /* Maintainer: wing-linux.sourceforge.net */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = htcherald_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-innovator.c b/arch/arm/mach-omap1/board-innovator.c
index 3daf87ad2576..2d9b8cbd7a14 100644
--- a/arch/arm/mach-omap1/board-innovator.c
+++ b/arch/arm/mach-omap1/board-innovator.c
@@ -44,17 +44,16 @@
 /* At OMAP1610 Innovator the Ethernet is directly connected to CS1 */
 #define INNOVATOR1610_ETHR_START        0x04000300
 
-static int innovator_keymap[] = {
+static const unsigned int innovator_keymap[] = {
         KEY(0, 0, KEY_F1),
-        KEY(0, 3, KEY_DOWN),
+        KEY(3, 0, KEY_DOWN),
         KEY(1, 1, KEY_F2),
-        KEY(1, 2, KEY_RIGHT),
-        KEY(2, 0, KEY_F3),
-        KEY(2, 1, KEY_F4),
+        KEY(2, 1, KEY_RIGHT),
+        KEY(0, 2, KEY_F3),
+        KEY(1, 2, KEY_F4),
         KEY(2, 2, KEY_UP),
-        KEY(3, 2, KEY_ENTER),
+        KEY(2, 3, KEY_ENTER),
         KEY(3, 3, KEY_LEFT),
-        0
 };
 
 static struct mtd_partition innovator_partitions[] = {
@@ -126,11 +125,15 @@ static struct resource innovator_kp_resources[] = {
         },
 };
 
+static const struct matrix_keymap_data innovator_keymap_data = {
+        .keymap         = innovator_keymap,
+        .keymap_size    = ARRAY_SIZE(innovator_keymap),
+};
+
 static struct omap_kp_platform_data innovator_kp_data = {
         .rows           = 8,
         .cols           = 8,
-        .keymap         = innovator_keymap,
-        .keymapsize     = ARRAY_SIZE(innovator_keymap),
+        .keymap_data    = &innovator_keymap_data,
         .delay          = 4,
 };
 
@@ -290,13 +293,6 @@ static void __init innovator_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
-#ifdef CONFIG_ARCH_OMAP15XX
-        if (cpu_is_omap1510()) {
-                omap1510_fpga_init_irq();
-        }
-#endif
-        innovator_init_smc91x();
 }
 
 #ifdef CONFIG_ARCH_OMAP15XX
@@ -369,7 +365,7 @@ static struct omap_mmc_platform_data mmc1_data = {
 
 static struct omap_mmc_platform_data *mmc_data[OMAP16XX_NR_MMC];
 
-void __init innovator_mmc_init(void)
+static void __init innovator_mmc_init(void)
 {
         mmc_data[0] = &mmc1_data;
         omap1_init_mmc(mmc_data, OMAP15XX_NR_MMC);
@@ -387,6 +383,10 @@ static struct omap_board_config_kernel innovator_config[] = {
 
 static void __init innovator_init(void)
 {
+        if (cpu_is_omap1510())
+                omap1510_fpga_init_irq();
+        innovator_init_smc91x();
+
 #ifdef CONFIG_ARCH_OMAP15XX
         if (cpu_is_omap1510()) {
                 unsigned char reg;
@@ -459,8 +459,6 @@ static void __init innovator_map_io(void)
 
 MACHINE_START(OMAP_INNOVATOR, "TI-Innovator")
         /* Maintainer: MontaVista Software, Inc. */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = innovator_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-nokia770.c b/arch/arm/mach-omap1/board-nokia770.c
index 51a4539aecf5..cfd084926146 100644
--- a/arch/arm/mach-omap1/board-nokia770.c
+++ b/arch/arm/mach-omap1/board-nokia770.c
@@ -54,19 +54,18 @@ static void __init omap_nokia770_init_irq(void)
         omap_init_irq();
 }
 
-static int nokia770_keymap[] = {
-        KEY(0, 1, GROUP_0 | KEY_UP),
-        KEY(0, 2, GROUP_1 | KEY_F5),
-        KEY(1, 0, GROUP_0 | KEY_LEFT),
+static const unsigned int nokia770_keymap[] = {
+        KEY(1, 0, GROUP_0 | KEY_UP),
+        KEY(2, 0, GROUP_1 | KEY_F5),
+        KEY(0, 1, GROUP_0 | KEY_LEFT),
         KEY(1, 1, GROUP_0 | KEY_ENTER),
-        KEY(1, 2, GROUP_0 | KEY_RIGHT),
-        KEY(2, 0, GROUP_1 | KEY_ESC),
-        KEY(2, 1, GROUP_0 | KEY_DOWN),
+        KEY(2, 1, GROUP_0 | KEY_RIGHT),
+        KEY(0, 2, GROUP_1 | KEY_ESC),
+        KEY(1, 2, GROUP_0 | KEY_DOWN),
         KEY(2, 2, GROUP_1 | KEY_F4),
-        KEY(3, 0, GROUP_2 | KEY_F7),
-        KEY(3, 1, GROUP_2 | KEY_F8),
-        KEY(3, 2, GROUP_2 | KEY_F6),
-        0
+        KEY(0, 3, GROUP_2 | KEY_F7),
+        KEY(1, 3, GROUP_2 | KEY_F8),
+        KEY(2, 3, GROUP_2 | KEY_F6),
 };
 
 static struct resource nokia770_kp_resources[] = {
@@ -77,11 +76,15 @@ static struct resource nokia770_kp_resources[] = {
         },
 };
 
+static const struct matrix_keymap_data nokia770_keymap_data = {
+        .keymap         = nokia770_keymap,
+        .keymap_size    = ARRAY_SIZE(nokia770_keymap),
+};
+
 static struct omap_kp_platform_data nokia770_kp_data = {
         .rows           = 8,
         .cols           = 8,
-        .keymap         = nokia770_keymap,
-        .keymapsize     = ARRAY_SIZE(nokia770_keymap),
+        .keymap_data    = &nokia770_keymap_data,
         .delay          = 4,
 };
 
@@ -112,7 +115,7 @@ static struct mipid_platform_data nokia770_mipid_platform_data = {
         .shutdown = mipid_shutdown,
 };
 
-static void mipid_dev_init(void)
+static void __init mipid_dev_init(void)
 {
         const struct omap_lcd_config *conf;
 
@@ -123,7 +126,7 @@ static void mipid_dev_init(void)
         }
 }
 
-static void ads7846_dev_init(void)
+static void __init ads7846_dev_init(void)
 {
         if (gpio_request(ADS7846_PENDOWN_GPIO, "ADS7846 pendown") < 0)
                 printk(KERN_ERR "can't get ads7846 pen down GPIO\n");
@@ -167,7 +170,7 @@ static struct hwa742_platform_data nokia770_hwa742_platform_data = {
         .te_connected           = 1,
 };
 
-static void hwa742_dev_init(void)
+static void __init hwa742_dev_init(void)
 {
         clk_add_alias("hwa_sys_ck", NULL, "bclk", NULL);
         omapfb_set_ctrl_platform_data(&nokia770_hwa742_platform_data);
@@ -246,7 +249,6 @@ static void __init omap_nokia770_init(void)
         platform_add_devices(nokia770_devices, ARRAY_SIZE(nokia770_devices));
         spi_register_board_info(nokia770_spi_board_info,
                                 ARRAY_SIZE(nokia770_spi_board_info));
-        omap_gpio_init();
         omap_serial_init();
         omap_register_i2c_bus(1, 100, NULL, 0);
         hwa742_dev_init();
@@ -262,8 +264,6 @@ static void __init omap_nokia770_map_io(void)
 }
 
 MACHINE_START(NOKIA770, "Nokia 770")
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = omap_nokia770_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-osk.c b/arch/arm/mach-omap1/board-osk.c
index 679740cc1e90..e68dfde1918e 100644
--- a/arch/arm/mach-omap1/board-osk.c
+++ b/arch/arm/mach-omap1/board-osk.c
@@ -276,16 +276,13 @@ static void __init osk_init_cf(void)
                 return;
         }
         /* the CF I/O IRQ is really active-low */
-        set_irq_type(gpio_to_irq(62), IRQ_TYPE_EDGE_FALLING);
+        irq_set_irq_type(gpio_to_irq(62), IRQ_TYPE_EDGE_FALLING);
 }
 
 static void __init osk_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
-        osk_init_smc91x();
-        osk_init_cf();
 }
 
 static struct omap_usb_config osk_usb_config __initdata = {
@@ -341,25 +338,28 @@ static struct i2c_board_info __initdata mistral_i2c_board_info[] = {
          */
 };
 
-static const int osk_keymap[] = {
+static const unsigned int osk_keymap[] = {
         /* KEY(col, row, code) */
         KEY(0, 0, KEY_F1),              /* SW4 */
-        KEY(0, 3, KEY_UP),              /* (sw2/up) */
+        KEY(3, 0, KEY_UP),              /* (sw2/up) */
         KEY(1, 1, KEY_LEFTCTRL),        /* SW5 */
-        KEY(1, 2, KEY_LEFT),            /* (sw2/left) */
-        KEY(2, 0, KEY_SPACE),           /* SW3 */
-        KEY(2, 1, KEY_ESC),             /* SW6 */
+        KEY(2, 1, KEY_LEFT),            /* (sw2/left) */
+        KEY(0, 2, KEY_SPACE),           /* SW3 */
+        KEY(1, 2, KEY_ESC),             /* SW6 */
         KEY(2, 2, KEY_DOWN),            /* (sw2/down) */
-        KEY(3, 2, KEY_ENTER),           /* (sw2/select) */
+        KEY(2, 3, KEY_ENTER),           /* (sw2/select) */
         KEY(3, 3, KEY_RIGHT),           /* (sw2/right) */
-        0
+};
+
+static const struct matrix_keymap_data osk_keymap_data = {
+        .keymap         = osk_keymap,
+        .keymap_size    = ARRAY_SIZE(osk_keymap),
 };
 
 static struct omap_kp_platform_data osk_kp_data = {
         .rows           = 8,
         .cols           = 8,
-        .keymap         = (int *) osk_keymap,
-        .keymapsize     = ARRAY_SIZE(osk_keymap),
+        .keymap_data    = &osk_keymap_data,
         .delay          = 9,
 };
 
@@ -482,7 +482,7 @@ static void __init osk_mistral_init(void)
         omap_cfg_reg(P20_1610_GPIO4);   /* PENIRQ */
         gpio_request(4, "ts_int");
         gpio_direction_input(4);
-        set_irq_type(gpio_to_irq(4), IRQ_TYPE_EDGE_FALLING);
+        irq_set_irq_type(gpio_to_irq(4), IRQ_TYPE_EDGE_FALLING);
 
         spi_register_board_info(mistral_boardinfo,
                         ARRAY_SIZE(mistral_boardinfo));
@@ -500,7 +500,7 @@ static void __init osk_mistral_init(void)
                 int irq = gpio_to_irq(OMAP_MPUIO(2));
 
                 gpio_direction_input(OMAP_MPUIO(2));
-                set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
+                irq_set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
 #ifdef  CONFIG_PM
                 /* share the IRQ in case someone wants to use the
                  * button for more than wakeup from system sleep.
@@ -541,6 +541,9 @@ static void __init osk_init(void)
 {
         u32 l;
 
+        osk_init_smc91x();
+        osk_init_cf();
+
         /* Workaround for wrong CS3 (NOR flash) timing
          * There are some U-Boot versions out there which configure
          * wrong CS3 memory timings. This mainly leads to CRC
@@ -580,8 +583,6 @@ static void __init osk_map_io(void)
 
 MACHINE_START(OMAP_OSK, "TI-OSK")
         /* Maintainer: Dirk Behme <dirk.behme@de.bosch.com> */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = osk_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-palmte.c b/arch/arm/mach-omap1/board-palmte.c
index 782bb257a85d..c9d38f47845f 100644
--- a/arch/arm/mach-omap1/board-palmte.c
+++ b/arch/arm/mach-omap1/board-palmte.c
@@ -63,28 +63,31 @@ static void __init omap_palmte_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
 }
 
-static const int palmte_keymap[] = {
+static const unsigned int palmte_keymap[] = {
         KEY(0, 0, KEY_F1),              /* Calendar */
-        KEY(0, 1, KEY_F2),              /* Contacts */
-        KEY(0, 2, KEY_F3),              /* Tasks List */
-        KEY(0, 3, KEY_F4),              /* Note Pad */
-        KEY(0, 4, KEY_POWER),
-        KEY(1, 0, KEY_LEFT),
+        KEY(1, 0, KEY_F2),              /* Contacts */
+        KEY(2, 0, KEY_F3),              /* Tasks List */
+        KEY(3, 0, KEY_F4),              /* Note Pad */
+        KEY(4, 0, KEY_POWER),
+        KEY(0, 1, KEY_LEFT),
         KEY(1, 1, KEY_DOWN),
-        KEY(1, 2, KEY_UP),
-        KEY(1, 3, KEY_RIGHT),
-        KEY(1, 4, KEY_ENTER),
-        0,
+        KEY(2, 1, KEY_UP),
+        KEY(3, 1, KEY_RIGHT),
+        KEY(4, 1, KEY_ENTER),
+};
+
+static const struct matrix_keymap_data palmte_keymap_data = {
+        .keymap         = palmte_keymap,
+        .keymap_size    = ARRAY_SIZE(palmte_keymap),
 };
 
 static struct omap_kp_platform_data palmte_kp_data = {
         .rows   = 8,
         .cols   = 8,
-        .keymap = (int *) palmte_keymap,
-        .rep    = 1,
+        .keymap_data = &palmte_keymap_data,
+        .rep    = true,
         .delay  = 12,
 };
 
@@ -227,19 +230,6 @@ static struct spi_board_info palmte_spi_info[] __initdata = {
         },
 };
 
-static void palmte_headphones_detect(void *data, int state)
-{
-        if (state) {
-                /* Headphones connected, disable speaker */
-                gpio_set_value(PALMTE_SPEAKER_GPIO, 0);
-                printk(KERN_INFO "PM: speaker off\n");
-        } else {
-                /* Headphones unplugged, re-enable speaker */
-                gpio_set_value(PALMTE_SPEAKER_GPIO, 1);
-                printk(KERN_INFO "PM: speaker on\n");
-        }
-}
-
 static void __init palmte_misc_gpio_setup(void)
 {
         /* Set TSC2102 PINTDAV pin as input (used by TSC2102 driver) */
@@ -285,8 +275,6 @@ static void __init omap_palmte_map_io(void)
 }
 
 MACHINE_START(OMAP_PALMTE, "OMAP310 based Palm Tungsten E")
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = omap_palmte_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-palmtt.c b/arch/arm/mach-omap1/board-palmtt.c
index 0b35ef54a64f..f04f2d36e7d3 100644
--- a/arch/arm/mach-omap1/board-palmtt.c
+++ b/arch/arm/mach-omap1/board-palmtt.c
@@ -51,19 +51,18 @@
 #define PALMTT_MMC_WP_GPIO      8
 #define PALMTT_HDQ_GPIO         11
 
-static int palmtt_keymap[] = {
+static const unsigned int palmtt_keymap[] = {
         KEY(0, 0, KEY_ESC),
-        KEY(0, 1, KEY_SPACE),
-        KEY(0, 2, KEY_LEFTCTRL),
-        KEY(0, 3, KEY_TAB),
-        KEY(0, 4, KEY_ENTER),
-        KEY(1, 0, KEY_LEFT),
+        KEY(1, 0, KEY_SPACE),
+        KEY(2, 0, KEY_LEFTCTRL),
+        KEY(3, 0, KEY_TAB),
+        KEY(4, 0, KEY_ENTER),
+        KEY(0, 1, KEY_LEFT),
         KEY(1, 1, KEY_DOWN),
-        KEY(1, 2, KEY_UP),
-        KEY(1, 3, KEY_RIGHT),
-        KEY(2, 0, KEY_SLEEP),
-        KEY(2, 4, KEY_Y),
-        0
+        KEY(2, 1, KEY_UP),
+        KEY(3, 1, KEY_RIGHT),
+        KEY(0, 2, KEY_SLEEP),
+        KEY(4, 2, KEY_Y),
 };
 
 static struct mtd_partition palmtt_partitions[] = {
@@ -136,10 +135,15 @@ static struct resource palmtt_kp_resources[] = {
         },
 };
 
+static const struct matrix_keymap_data palmtt_keymap_data = {
+        .keymap         = palmtt_keymap,
+        .keymap_size    = ARRAY_SIZE(palmtt_keymap),
+};
+
 static struct omap_kp_platform_data palmtt_kp_data = {
         .rows   = 6,
         .cols   = 3,
-        .keymap = palmtt_keymap,
+        .keymap_data = &palmtt_keymap_data,
 };
 
 static struct platform_device palmtt_kp_device = {
@@ -317,8 +321,6 @@ static void __init omap_palmtt_map_io(void)
 }
 
 MACHINE_START(OMAP_PALMTT, "OMAP1510 based Palm Tungsten|T")
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = omap_palmtt_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-palmz71.c b/arch/arm/mach-omap1/board-palmz71.c
index 66362903b6e2..45f01d2c3a7a 100644
--- a/arch/arm/mach-omap1/board-palmz71.c
+++ b/arch/arm/mach-omap1/board-palmz71.c
@@ -62,29 +62,32 @@ omap_palmz71_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
 }
 
-static int palmz71_keymap[] = {
+static const unsigned int palmz71_keymap[] = {
         KEY(0, 0, KEY_F1),
-        KEY(0, 1, KEY_F2),
-        KEY(0, 2, KEY_F3),
-        KEY(0, 3, KEY_F4),
-        KEY(0, 4, KEY_POWER),
-        KEY(1, 0, KEY_LEFT),
+        KEY(1, 0, KEY_F2),
+        KEY(2, 0, KEY_F3),
+        KEY(3, 0, KEY_F4),
+        KEY(4, 0, KEY_POWER),
+        KEY(0, 1, KEY_LEFT),
         KEY(1, 1, KEY_DOWN),
-        KEY(1, 2, KEY_UP),
-        KEY(1, 3, KEY_RIGHT),
-        KEY(1, 4, KEY_ENTER),
-        KEY(2, 0, KEY_CAMERA),
-        0,
+        KEY(2, 1, KEY_UP),
+        KEY(3, 1, KEY_RIGHT),
+        KEY(4, 1, KEY_ENTER),
+        KEY(0, 2, KEY_CAMERA),
+};
+
+static const struct matrix_keymap_data palmz71_keymap_data = {
+        .keymap         = palmz71_keymap,
+        .keymap_size    = ARRAY_SIZE(palmz71_keymap),
 };
 
 static struct omap_kp_platform_data palmz71_kp_data = {
         .rows   = 8,
         .cols   = 8,
-        .keymap = palmz71_keymap,
-        .rep    = 1,
+        .keymap_data    = &palmz71_keymap_data,
+        .rep    = true,
         .delay  = 80,
 };
 
@@ -253,12 +256,12 @@ palmz71_powercable(int irq, void *dev_id)
 {
         if (gpio_get_value(PALMZ71_USBDETECT_GPIO)) {
                 printk(KERN_INFO "PM: Power cable connected\n");
-                set_irq_type(gpio_to_irq(PALMZ71_USBDETECT_GPIO),
-                                IRQ_TYPE_EDGE_FALLING);
+                irq_set_irq_type(gpio_to_irq(PALMZ71_USBDETECT_GPIO),
+                                 IRQ_TYPE_EDGE_FALLING);
         } else {
                 printk(KERN_INFO "PM: Power cable disconnected\n");
-                set_irq_type(gpio_to_irq(PALMZ71_USBDETECT_GPIO),
-                                IRQ_TYPE_EDGE_RISING);
+                irq_set_irq_type(gpio_to_irq(PALMZ71_USBDETECT_GPIO),
+                                 IRQ_TYPE_EDGE_RISING);
         }
         return IRQ_HANDLED;
 }
@@ -338,8 +341,6 @@ omap_palmz71_map_io(void)
 }
 
 MACHINE_START(OMAP_PALMZ71, "OMAP310 based Palm Zire71")
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = omap_palmz71_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-perseus2.c b/arch/arm/mach-omap1/board-perseus2.c
index 34ab354758b0..3c8ee8489458 100644
--- a/arch/arm/mach-omap1/board-perseus2.c
+++ b/arch/arm/mach-omap1/board-perseus2.c
@@ -36,36 +36,35 @@
 #include <plat/common.h>
 #include <plat/board.h>
 
-static int p2_keymap[] = {
-        KEY(0,0,KEY_UP),
-        KEY(0,1,KEY_RIGHT),
-        KEY(0,2,KEY_LEFT),
-        KEY(0,3,KEY_DOWN),
-        KEY(0,4,KEY_ENTER),
-        KEY(1,0,KEY_F10),
-        KEY(1,1,KEY_SEND),
-        KEY(1,2,KEY_END),
-        KEY(1,3,KEY_VOLUMEDOWN),
-        KEY(1,4,KEY_VOLUMEUP),
-        KEY(1,5,KEY_RECORD),
-        KEY(2,0,KEY_F9),
-        KEY(2,1,KEY_3),
-        KEY(2,2,KEY_6),
-        KEY(2,3,KEY_9),
-        KEY(2,4,KEY_KPDOT),
-        KEY(3,0,KEY_BACK),
-        KEY(3,1,KEY_2),
-        KEY(3,2,KEY_5),
-        KEY(3,3,KEY_8),
-        KEY(3,4,KEY_0),
-        KEY(3,5,KEY_KPSLASH),
-        KEY(4,0,KEY_HOME),
-        KEY(4,1,KEY_1),
-        KEY(4,2,KEY_4),
-        KEY(4,3,KEY_7),
-        KEY(4,4,KEY_KPASTERISK),
-        KEY(4,5,KEY_POWER),
-        0
+static const unsigned int p2_keymap[] = {
+        KEY(0, 0, KEY_UP),
+        KEY(1, 0, KEY_RIGHT),
+        KEY(2, 0, KEY_LEFT),
+        KEY(3, 0, KEY_DOWN),
+        KEY(4, 0, KEY_ENTER),
+        KEY(0, 1, KEY_F10),
+        KEY(1, 1, KEY_SEND),
+        KEY(2, 1, KEY_END),
+        KEY(3, 1, KEY_VOLUMEDOWN),
+        KEY(4, 1, KEY_VOLUMEUP),
+        KEY(5, 1, KEY_RECORD),
+        KEY(0, 2, KEY_F9),
+        KEY(1, 2, KEY_3),
+        KEY(2, 2, KEY_6),
+        KEY(3, 2, KEY_9),
+        KEY(4, 2, KEY_KPDOT),
+        KEY(0, 3, KEY_BACK),
+        KEY(1, 3, KEY_2),
+        KEY(2, 3, KEY_5),
+        KEY(3, 3, KEY_8),
+        KEY(4, 3, KEY_0),
+        KEY(5, 3, KEY_KPSLASH),
+        KEY(0, 4, KEY_HOME),
+        KEY(1, 4, KEY_1),
+        KEY(2, 4, KEY_4),
+        KEY(3, 4, KEY_7),
+        KEY(4, 4, KEY_KPASTERISK),
+        KEY(5, 4, KEY_POWER),
 };
 
 static struct smc91x_platdata smc91x_info = {
@@ -211,13 +210,17 @@ static struct resource kp_resources[] = {
         },
 };
 
+static const struct matrix_keymap_data p2_keymap_data = {
+        .keymap         = p2_keymap,
+        .keymap_size    = ARRAY_SIZE(p2_keymap),
+};
+
 static struct omap_kp_platform_data kp_data = {
         .rows           = 8,
         .cols           = 8,
-        .keymap         = p2_keymap,
-        .keymapsize     = ARRAY_SIZE(p2_keymap),
+        .keymap_data    = &p2_keymap_data,
         .delay          = 4,
-        .dbounce        = 1,
+        .dbounce        = true,
 };
 
 static struct platform_device kp_device = {
@@ -251,8 +254,19 @@ static struct omap_board_config_kernel perseus2_config[] __initdata = {
         { OMAP_TAG_LCD,         &perseus2_lcd_config },
 };
 
+static void __init perseus2_init_smc91x(void)
+{
+        fpga_write(1, H2P2_DBG_FPGA_LAN_RESET);
+        mdelay(50);
+        fpga_write(fpga_read(H2P2_DBG_FPGA_LAN_RESET) & ~1,
+                   H2P2_DBG_FPGA_LAN_RESET);
+        mdelay(50);
+}
+
 static void __init omap_perseus2_init(void)
 {
+        perseus2_init_smc91x();
+
         if (gpio_request(P2_NAND_RB_GPIO_PIN, "NAND ready") < 0)
                 BUG();
         gpio_direction_input(P2_NAND_RB_GPIO_PIN);
@@ -280,21 +294,10 @@ static void __init omap_perseus2_init(void)
         omap_register_i2c_bus(1, 100, NULL, 0);
 }
 
-static void __init perseus2_init_smc91x(void)
-{
-        fpga_write(1, H2P2_DBG_FPGA_LAN_RESET);
-        mdelay(50);
-        fpga_write(fpga_read(H2P2_DBG_FPGA_LAN_RESET) & ~1,
-                   H2P2_DBG_FPGA_LAN_RESET);
-        mdelay(50);
-}
-
 static void __init omap_perseus2_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
-        perseus2_init_smc91x();
 }
 /* Only FPGA needs to be mapped here. All others are done with ioremap */
 static struct map_desc omap_perseus2_io_desc[] __initdata = {
@@ -347,8 +350,6 @@ static void __init omap_perseus2_map_io(void)
 
 MACHINE_START(OMAP_PERSEUS2, "OMAP730 Perseus2")
         /* Maintainer: Kevin Hilman <kjh@hilman.org> */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = omap_perseus2_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-sx1-mmc.c b/arch/arm/mach-omap1/board-sx1-mmc.c
index 5b33ae8141bc..e8ddd86e3fda 100644
--- a/arch/arm/mach-omap1/board-sx1-mmc.c
+++ b/arch/arm/mach-omap1/board-sx1-mmc.c
@@ -44,8 +44,7 @@ static struct omap_mmc_platform_data mmc1_data = {
         .nr_slots                       = 1,
         .slots[0]       = {
                 .set_power              = mmc_set_power,
-                .ocr_mask               = MMC_VDD_28_29 | MMC_VDD_30_31 |
-                                          MMC_VDD_32_33 | MMC_VDD_33_34,
+                .ocr_mask               = MMC_VDD_32_33 | MMC_VDD_33_34,
                 .name                   = "mmcblk",
         },
 };
diff --git a/arch/arm/mach-omap1/board-sx1.c b/arch/arm/mach-omap1/board-sx1.c
index 2eb148b8de93..0ad781db4e66 100644
--- a/arch/arm/mach-omap1/board-sx1.c
+++ b/arch/arm/mach-omap1/board-sx1.c
@@ -164,36 +164,35 @@ EXPORT_SYMBOL(sx1_setusbpower);
 
 /*----------- Keypad -------------------------*/
 
-static int sx1_keymap[] = {
-        KEY(5, 3, GROUP_0 | 117), /* camera Qt::Key_F17 */
-        KEY(0, 4, GROUP_0 | 114), /* voice memo Qt::Key_F14 */
-        KEY(1, 4, GROUP_2 | 114), /* voice memo */
-        KEY(2, 4, GROUP_3 | 114), /* voice memo */
+static const unsigned int sx1_keymap[] = {
+        KEY(3, 5, GROUP_0 | 117), /* camera Qt::Key_F17 */
+        KEY(4, 0, GROUP_0 | 114), /* voice memo Qt::Key_F14 */
+        KEY(4, 1, GROUP_2 | 114), /* voice memo */
+        KEY(4, 2, GROUP_3 | 114), /* voice memo */
         KEY(0, 0, GROUP_1 | KEY_F12),   /* red button Qt::Key_Hangup */
-        KEY(4, 3, GROUP_1 | KEY_LEFT),
-        KEY(2, 3, GROUP_1 | KEY_DOWN),
-        KEY(1, 3, GROUP_1 | KEY_RIGHT),
-        KEY(0, 3, GROUP_1 | KEY_UP),
+        KEY(3, 4, GROUP_1 | KEY_LEFT),
+        KEY(3, 2, GROUP_1 | KEY_DOWN),
+        KEY(3, 1, GROUP_1 | KEY_RIGHT),
+        KEY(3, 0, GROUP_1 | KEY_UP),
         KEY(3, 3, GROUP_1 | KEY_POWER), /* joystick press or Qt::Key_Select */
-        KEY(5, 0, GROUP_1 | KEY_1),
-        KEY(4, 0, GROUP_1 | KEY_2),
-        KEY(3, 0, GROUP_1 | KEY_3),
-        KEY(3, 4, GROUP_1 | KEY_4),
+        KEY(0, 5, GROUP_1 | KEY_1),
+        KEY(0, 4, GROUP_1 | KEY_2),
+        KEY(0, 3, GROUP_1 | KEY_3),
+        KEY(4, 3, GROUP_1 | KEY_4),
         KEY(4, 4, GROUP_1 | KEY_5),
-        KEY(5, 4, GROUP_1 | KEY_KPASTERISK),/* "*" */
-        KEY(4, 1, GROUP_1 | KEY_6),
-        KEY(5, 1, GROUP_1 | KEY_7),
-        KEY(3, 1, GROUP_1 | KEY_8),
-        KEY(3, 2, GROUP_1 | KEY_9),
-        KEY(5, 2, GROUP_1 | KEY_0),
-        KEY(4, 2, GROUP_1 | 113),       /* # F13 Toggle input method Qt::Key_F13 */
-        KEY(0, 1, GROUP_1 | KEY_F11),   /* green button Qt::Key_Call */
-        KEY(1, 2, GROUP_1 | KEY_YEN),   /* left soft Qt::Key_Context1 */
+        KEY(4, 5, GROUP_1 | KEY_KPASTERISK),/* "*" */
+        KEY(1, 4, GROUP_1 | KEY_6),
+        KEY(1, 5, GROUP_1 | KEY_7),
+        KEY(1, 3, GROUP_1 | KEY_8),
+        KEY(2, 3, GROUP_1 | KEY_9),
+        KEY(2, 5, GROUP_1 | KEY_0),
+        KEY(2, 4, GROUP_1 | 113), /* # F13 Toggle input method Qt::Key_F13 */
+        KEY(1, 0, GROUP_1 | KEY_F11),   /* green button Qt::Key_Call */
+        KEY(2, 1, GROUP_1 | KEY_YEN),   /* left soft Qt::Key_Context1 */
         KEY(2, 2, GROUP_1 | KEY_F8),    /* right soft Qt::Key_Back */
-        KEY(2, 1, GROUP_1 | KEY_LEFTSHIFT), /* shift */
+        KEY(1, 2, GROUP_1 | KEY_LEFTSHIFT), /* shift */
         KEY(1, 1, GROUP_1 | KEY_BACKSPACE), /* C (clear) */
-        KEY(0, 2, GROUP_1 | KEY_F7),    /* menu Qt::Key_Menu */
-        0
+        KEY(2, 0, GROUP_1 | KEY_F7),    /* menu Qt::Key_Menu */
 };
 
 static struct resource sx1_kp_resources[] = {
@@ -204,11 +203,15 @@ static struct resource sx1_kp_resources[] = {
         },
 };
 
+static const struct matrix_keymap_data sx1_keymap_data = {
+        .keymap         = sx1_keymap,
+        .keymap_size    = ARRAY_SIZE(sx1_keymap),
+};
+
 static struct omap_kp_platform_data sx1_kp_data = {
         .rows           = 6,
         .cols           = 6,
-        .keymap = sx1_keymap,
-        .keymapsize = ARRAY_SIZE(sx1_keymap),
+        .keymap_data    = &sx1_keymap_data,
         .delay  = 80,
 };
 
@@ -396,7 +399,7 @@ static void __init omap_sx1_init(void)
         sx1_mmc_init();
 
         /* turn on USB power */
-        /* sx1_setusbpower(1); cant do it here because i2c is not ready */
+        /* sx1_setusbpower(1); can't do it here because i2c is not ready */
         gpio_request(1, "A_IRDA_OFF");
         gpio_request(11, "A_SWITCH");
         gpio_request(15, "A_USB_ON");
@@ -409,7 +412,6 @@ static void __init omap_sx1_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
 }
 /*----------------------------------------*/
 
@@ -419,8 +421,6 @@ static void __init omap_sx1_map_io(void)
 }
 
 MACHINE_START(SX1, "OMAP310 based Siemens SX1")
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = omap_sx1_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/board-voiceblue.c b/arch/arm/mach-omap1/board-voiceblue.c
index 6b3cf14bc757..65d24204937a 100644
--- a/arch/arm/mach-omap1/board-voiceblue.c
+++ b/arch/arm/mach-omap1/board-voiceblue.c
@@ -26,10 +26,12 @@
 #include <linux/smc91x.h>
 
 #include <mach/hardware.h>
+#include <mach/system.h>
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
+#include <plat/board-voiceblue.h>
 #include <plat/common.h>
 #include <mach/gpio.h>
 #include <plat/flash.h>
@@ -83,6 +85,9 @@ static struct platform_device serial_device = {
 
 static int __init ext_uart_init(void)
 {
+        if (!machine_is_voiceblue())
+                return -ENODEV;
+
         return platform_device_register(&serial_device);
 }
 arch_initcall(ext_uart_init);
@@ -158,53 +163,6 @@ static void __init voiceblue_init_irq(void)
 {
         omap1_init_common_hw();
         omap_init_irq();
-        omap_gpio_init();
-}
-
-static void __init voiceblue_init(void)
-{
-        /* mux pins for uarts */
-        omap_cfg_reg(UART1_TX);
-        omap_cfg_reg(UART1_RTS);
-        omap_cfg_reg(UART2_TX);
-        omap_cfg_reg(UART2_RTS);
-        omap_cfg_reg(UART3_TX);
-        omap_cfg_reg(UART3_RX);
-
-        /* Watchdog */
-        gpio_request(0, "Watchdog");
-        /* smc91x reset */
-        gpio_request(7, "SMC91x reset");
-        gpio_direction_output(7, 1);
-        udelay(2);      /* wait at least 100ns */
-        gpio_set_value(7, 0);
-        mdelay(50);     /* 50ms until PHY ready */
-        /* smc91x interrupt pin */
-        gpio_request(8, "SMC91x irq");
-        /* 16C554 reset*/
-        gpio_request(6, "16C554 reset");
-        gpio_direction_output(6, 0);
-        /* 16C554 interrupt pins */
-        gpio_request(12, "16C554 irq");
-        gpio_request(13, "16C554 irq");
-        gpio_request(14, "16C554 irq");
-        gpio_request(15, "16C554 irq");
-        set_irq_type(gpio_to_irq(12), IRQ_TYPE_EDGE_RISING);
-        set_irq_type(gpio_to_irq(13), IRQ_TYPE_EDGE_RISING);
-        set_irq_type(gpio_to_irq(14), IRQ_TYPE_EDGE_RISING);
-        set_irq_type(gpio_to_irq(15), IRQ_TYPE_EDGE_RISING);
-
-        platform_add_devices(voiceblue_devices, ARRAY_SIZE(voiceblue_devices));
-        omap_board_config = voiceblue_config;
-        omap_board_config_size = ARRAY_SIZE(voiceblue_config);
-        omap_serial_init();
-        omap1_usb_init(&voiceblue_usb_config);
-        omap_register_i2c_bus(1, 100, NULL, 0);
-
-        /* There is a good chance board is going up, so enable power LED
-         * (it is connected through invertor) */
-        omap_writeb(0x00, OMAP_LPG1_LCR);
-        omap_writeb(0x00, OMAP_LPG1_PMR);       /* Disable clock */
 }
 
 static void __init voiceblue_map_io(void)
@@ -236,6 +194,9 @@ static struct notifier_block panic_block = {
 
 static int __init voiceblue_setup(void)
 {
+        if (!machine_is_voiceblue())
+                return -ENODEV;
+
         /* Setup panic notifier */
         atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
@@ -270,8 +231,17 @@ void voiceblue_wdt_ping(void)
         gpio_set_value(0, wdt_gpio_state);
 }
 
-void voiceblue_reset(void)
+static void voiceblue_reset(char mode, const char *cmd)
 {
+        /*
+         * Workaround for 5912/1611b bug mentioned in sprz209d.pdf p. 28
+         * "Global Software Reset Affects Traffic Controller Frequency".
+         */
+        if (cpu_is_omap5912()) {
+                omap_writew(omap_readw(DPLL_CTL) & ~(1 << 4), DPLL_CTL);
+                omap_writew(0x8, ARM_RSTCT1);
+        }
+
         set_bit(MACHINE_REBOOT, &machine_state);
         voiceblue_wdt_enable();
         while (1) ;
@@ -281,10 +251,56 @@ EXPORT_SYMBOL(voiceblue_wdt_enable);
 EXPORT_SYMBOL(voiceblue_wdt_disable);
 EXPORT_SYMBOL(voiceblue_wdt_ping);
 
+static void __init voiceblue_init(void)
+{
+        /* mux pins for uarts */
+        omap_cfg_reg(UART1_TX);
+        omap_cfg_reg(UART1_RTS);
+        omap_cfg_reg(UART2_TX);
+        omap_cfg_reg(UART2_RTS);
+        omap_cfg_reg(UART3_TX);
+        omap_cfg_reg(UART3_RX);
+
+        /* Watchdog */
+        gpio_request(0, "Watchdog");
+        /* smc91x reset */
+        gpio_request(7, "SMC91x reset");
+        gpio_direction_output(7, 1);
+        udelay(2);      /* wait at least 100ns */
+        gpio_set_value(7, 0);
+        mdelay(50);     /* 50ms until PHY ready */
+        /* smc91x interrupt pin */
+        gpio_request(8, "SMC91x irq");
+        /* 16C554 reset*/
+        gpio_request(6, "16C554 reset");
+        gpio_direction_output(6, 0);
+        /* 16C554 interrupt pins */
+        gpio_request(12, "16C554 irq");
+        gpio_request(13, "16C554 irq");
+        gpio_request(14, "16C554 irq");
+        gpio_request(15, "16C554 irq");
+        irq_set_irq_type(gpio_to_irq(12), IRQ_TYPE_EDGE_RISING);
+        irq_set_irq_type(gpio_to_irq(13), IRQ_TYPE_EDGE_RISING);
+        irq_set_irq_type(gpio_to_irq(14), IRQ_TYPE_EDGE_RISING);
+        irq_set_irq_type(gpio_to_irq(15), IRQ_TYPE_EDGE_RISING);
+
+        platform_add_devices(voiceblue_devices, ARRAY_SIZE(voiceblue_devices));
+        omap_board_config = voiceblue_config;
+        omap_board_config_size = ARRAY_SIZE(voiceblue_config);
+        omap_serial_init();
+        omap1_usb_init(&voiceblue_usb_config);
+        omap_register_i2c_bus(1, 100, NULL, 0);
+
+        /* There is a good chance board is going up, so enable power LED
+         * (it is connected through invertor) */
+        omap_writeb(0x00, OMAP_LPG1_LCR);
+        omap_writeb(0x00, OMAP_LPG1_PMR);       /* Disable clock */
+
+        arch_reset = voiceblue_reset;
+}
+
 MACHINE_START(VOICEBLUE, "VoiceBlue OMAP5910")
         /* Maintainer: Ladislav Michl <michl@2n.cz> */
-        .phys_io        = 0xfff00000,
-        .io_pg_offst    = ((0xfef00000) >> 18) & 0xfffc,
         .boot_params    = 0x10000100,
         .map_io         = voiceblue_map_io,
         .reserve        = omap_reserve,
diff --git a/arch/arm/mach-omap1/clock.c b/arch/arm/mach-omap1/clock.c
index b8c7fb9d7921..84ef70476b51 100644
--- a/arch/arm/mach-omap1/clock.c
+++ b/arch/arm/mach-omap1/clock.c
@@ -17,9 +17,9 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/io.h>
+#include <linux/clkdev.h>
 
 #include <asm/mach-types.h>
-#include <asm/clkdev.h>
 
 #include <plat/cpu.h>
 #include <plat/usb.h>
diff --git a/arch/arm/mach-omap1/clock_data.c b/arch/arm/mach-omap1/clock_data.c
index af54114b8f08..92400b9eb69f 100644
--- a/arch/arm/mach-omap1/clock_data.c
+++ b/arch/arm/mach-omap1/clock_data.c
@@ -143,7 +143,7 @@ static struct arm_idlect1_clk armper_ck = {
  * activation.  [ GPIO code for 1510 ]
  */
 static struct clk arm_gpio_ck = {
-        .name           = "arm_gpio_ck",
+        .name           = "ick",
         .ops            = &clkops_generic,
         .parent         = &ck_dpll1,
         .flags          = ENABLE_ON_INIT,
@@ -684,7 +684,7 @@ static struct omap_clk omap_clks[] = {
         CLK(NULL,       "ck_sossi",     &sossi_ck,      CK_16XX),
         CLK(NULL,       "arm_ck",       &arm_ck,        CK_16XX | CK_1510 | CK_310),
         CLK(NULL,       "armper_ck",    &armper_ck.clk, CK_16XX | CK_1510 | CK_310),
-        CLK(NULL,       "arm_gpio_ck",  &arm_gpio_ck,   CK_1510 | CK_310),
+        CLK("omap_gpio.0", "ick",       &arm_gpio_ck,   CK_1510 | CK_310),
         CLK(NULL,       "armxor_ck",    &armxor_ck.clk, CK_16XX | CK_1510 | CK_310 | CK_7XX),
         CLK(NULL,       "armtim_ck",    &armtim_ck.clk, CK_16XX | CK_1510 | CK_310),
         CLK("omap_wdt", "fck",          &armwdt_ck.clk, CK_16XX | CK_1510 | CK_310),
@@ -736,9 +736,9 @@ static struct omap_clk omap_clks[] = {
         CLK("mmci-omap.1", "ick",       &armper_ck.clk, CK_16XX),
         /* Virtual clocks */
         CLK(NULL,       "mpu",          &virtual_ck_mpu, CK_16XX | CK_1510 | CK_310),
-        CLK("i2c_omap.1", "fck",        &i2c_fck,       CK_16XX | CK_1510 | CK_310 | CK_7XX),
-        CLK("i2c_omap.1", "ick",        &i2c_ick,       CK_16XX),
-        CLK("i2c_omap.1", "ick",        &dummy_ck,      CK_1510 | CK_310 | CK_7XX),
+        CLK("omap_i2c.1", "fck",        &i2c_fck,       CK_16XX | CK_1510 | CK_310 | CK_7XX),
+        CLK("omap_i2c.1", "ick",        &i2c_ick,       CK_16XX),
+        CLK("omap_i2c.1", "ick",        &dummy_ck,      CK_1510 | CK_310 | CK_7XX),
         CLK("omap1_spi100k.1", "fck",   &dummy_ck,      CK_7XX),
         CLK("omap1_spi100k.1", "ick",   &dummy_ck,      CK_7XX),
         CLK("omap1_spi100k.2", "fck",   &dummy_ck,      CK_7XX),
@@ -823,12 +823,10 @@ int __init omap1_clk_init(void)
                         crystal_type = info->system_clock_type;
         }
 
-#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
-        ck_ref.rate = 13000000;
-#elif defined(CONFIG_ARCH_OMAP16XX)
-        if (crystal_type == 2)
+        if (cpu_is_omap7xx())
+                ck_ref.rate = 13000000;
+        if (cpu_is_omap16xx() && crystal_type == 2)
                 ck_ref.rate = 19200000;
-#endif
 
         pr_info("Clocks: ARM_SYSST: 0x%04x DPLL_CTL: 0x%04x ARM_CKCTL: "
                 "0x%04x\n", omap_readw(ARM_SYSST), omap_readw(DPLL_CTL),
@@ -883,10 +881,11 @@ int __init omap1_clk_init(void)
                ck_dpll1.rate / 1000000, (ck_dpll1.rate / 100000) % 10,
                arm_ck.rate / 1000000, (arm_ck.rate / 100000) % 10);
 
-#if defined(CONFIG_MACH_OMAP_PERSEUS2) || defined(CONFIG_MACH_OMAP_FSAMPLE)
-        /* Select slicer output as OMAP input clock */
-        omap_writew(omap_readw(OMAP7XX_PCC_UPLD_CTRL) & ~0x1, OMAP7XX_PCC_UPLD_CTRL);
-#endif
+        if (machine_is_omap_perseus2() || machine_is_omap_fsample()) {
+                /* Select slicer output as OMAP input clock */
+                omap_writew(omap_readw(OMAP7XX_PCC_UPLD_CTRL) & ~0x1,
+                                OMAP7XX_PCC_UPLD_CTRL);
+        }
 
         /* Amstrad Delta wants BCLK high when inactive */
         if (machine_is_ams_delta())
diff --git a/arch/arm/mach-omap1/devices.c b/arch/arm/mach-omap1/devices.c
index aa0725608fb1..36f26c3fa25e 100644
--- a/arch/arm/mach-omap1/devices.c
+++ b/arch/arm/mach-omap1/devices.c
@@ -9,6 +9,7 @@
  * (at your option) any later version.
  */
 
+#include <linux/dma-mapping.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -16,6 +17,7 @@
 #include <linux/io.h>
 #include <linux/spi/spi.h>
 
+#include <mach/camera.h>
 #include <mach/hardware.h>
 #include <asm/mach/map.h>
 
@@ -25,6 +27,7 @@
 #include <mach/gpio.h>
 #include <plat/mmc.h>
 #include <plat/omap7xx.h>
+#include <plat/mcbsp.h>
 
 /*-------------------------------------------------------------------------*/
 
@@ -191,10 +194,76 @@ static inline void omap_init_spi100k(void)
 }
 #endif
 
+
+#define OMAP1_CAMERA_BASE       0xfffb6800
+#define OMAP1_CAMERA_IOSIZE     0x1c
+
+static struct resource omap1_camera_resources[] = {
+        [0] = {
+                .start  = OMAP1_CAMERA_BASE,
+                .end    = OMAP1_CAMERA_BASE + OMAP1_CAMERA_IOSIZE - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = INT_CAMERA,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static u64 omap1_camera_dma_mask = DMA_BIT_MASK(32);
+
+static struct platform_device omap1_camera_device = {
+        .name           = "omap1-camera",
+        .id             = 0, /* This is used to put cameras on this interface */
+        .dev            = {
+                .dma_mask               = &omap1_camera_dma_mask,
+                .coherent_dma_mask      = DMA_BIT_MASK(32),
+        },
+        .num_resources  = ARRAY_SIZE(omap1_camera_resources),
+        .resource       = omap1_camera_resources,
+};
+
+void __init omap1_camera_init(void *info)
+{
+        struct platform_device *dev = &omap1_camera_device;
+        int ret;
+
+        dev->dev.platform_data = info;
+
+        ret = platform_device_register(dev);
+        if (ret)
+                dev_err(&dev->dev, "unable to register device: %d\n", ret);
+}
+
+
 /*-------------------------------------------------------------------------*/
 
 static inline void omap_init_sti(void) {}
 
+#if defined(CONFIG_SND_SOC) || defined(CONFIG_SND_SOC_MODULE)
+
+static struct platform_device omap_pcm = {
+        .name   = "omap-pcm-audio",
+        .id     = -1,
+};
+
+OMAP_MCBSP_PLATFORM_DEVICE(1);
+OMAP_MCBSP_PLATFORM_DEVICE(2);
+OMAP_MCBSP_PLATFORM_DEVICE(3);
+
+static void omap_init_audio(void)
+{
+        platform_device_register(&omap_mcbsp1);
+        platform_device_register(&omap_mcbsp2);
+        if (!cpu_is_omap7xx())
+                platform_device_register(&omap_mcbsp3);
+        platform_device_register(&omap_pcm);
+}
+
+#else
+static inline void omap_init_audio(void) {}
+#endif
+
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -212,13 +281,16 @@ static inline void omap_init_sti(void) {}
  * Claiming GPIOs, and setting their direction and initial values, is the
  * responsibility of the device drivers.  So is responding to probe().
  *
- * Board-specific knowlege like creating devices or pin setup is to be
+ * Board-specific knowledge like creating devices or pin setup is to be
  * kept out of drivers as much as possible.  In particular, pin setup
  * may be handled by the boot loader, and drivers should expect it will
  * normally have been done by the time they're probed.
  */
 static int __init omap1_init_devices(void)
 {
+        if (!cpu_class_is_omap1())
+                return -ENODEV;
+
         /* please keep these calls, and their implementations above,
          * in alphabetical order so they're easier to sort through.
          */
@@ -227,8 +299,35 @@ static int __init omap1_init_devices(void)
         omap_init_rtc();
         omap_init_spi100k();
         omap_init_sti();
+        omap_init_audio();
 
         return 0;
 }
 arch_initcall(omap1_init_devices);
 
+#if defined(CONFIG_OMAP_WATCHDOG) || defined(CONFIG_OMAP_WATCHDOG_MODULE)
+
+static struct resource wdt_resources[] = {
+        {
+                .start          = 0xfffeb000,
+                .end            = 0xfffeb07F,
+                .flags          = IORESOURCE_MEM,
+        },
+};
+
+static struct platform_device omap_wdt_device = {
+        .name      = "omap_wdt",
+        .id          = -1,
+        .num_resources  = ARRAY_SIZE(wdt_resources),
+        .resource       = wdt_resources,
+};
+
+static int __init omap_init_wdt(void)
+{
+        if (!cpu_is_omap16xx())
+                return -ENODEV;
+
+        return platform_device_register(&omap_wdt_device);
+}
+subsys_initcall(omap_init_wdt);
+#endif
diff --git a/arch/arm/mach-omap1/dma.c b/arch/arm/mach-omap1/dma.c
new file mode 100644
index 000000000000..f5a52204b89f
--- /dev/null
+++ b/arch/arm/mach-omap1/dma.c
@@ -0,0 +1,391 @@
+/*
+ * OMAP1/OMAP7xx - specific DMA driver
+ *
+ * Copyright (C) 2003 - 2008 Nokia Corporation
+ * Author: Juha Yrjölä <juha.yrjola@nokia.com>
+ * DMA channel linking for 1610 by Samuel Ortiz <samuel.ortiz@nokia.com>
+ * Graphics DMA and LCD DMA graphics tranformations
+ * by Imre Deak <imre.deak@nokia.com>
+ * OMAP2/3 support Copyright (C) 2004-2007 Texas Instruments, Inc.
+ * Some functions based on earlier dma-omap.c Copyright (C) 2001 RidgeRun, Inc.
+ *
+ * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
+ * Converted DMA library into platform driver
+ *                   - G, Manjunath Kondaiah <manjugk@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+
+#include <plat/dma.h>
+#include <plat/tc.h>
+#include <plat/irqs.h>
+
+#define OMAP1_DMA_BASE                  (0xfffed800)
+#define OMAP1_LOGICAL_DMA_CH_COUNT      17
+#define OMAP1_DMA_STRIDE                0x40
+
+static u32 errata;
+static u32 enable_1510_mode;
+static u8 dma_stride;
+static enum omap_reg_offsets dma_common_ch_start, dma_common_ch_end;
+
+static u16 reg_map[] = {
+        [GCR]           = 0x400,
+        [GSCR]          = 0x404,
+        [GRST1]         = 0x408,
+        [HW_ID]         = 0x442,
+        [PCH2_ID]       = 0x444,
+        [PCH0_ID]       = 0x446,
+        [PCH1_ID]       = 0x448,
+        [PCHG_ID]       = 0x44a,
+        [PCHD_ID]       = 0x44c,
+        [CAPS_0]        = 0x44e,
+        [CAPS_1]        = 0x452,
+        [CAPS_2]        = 0x456,
+        [CAPS_3]        = 0x458,
+        [CAPS_4]        = 0x45a,
+        [PCH2_SR]       = 0x460,
+        [PCH0_SR]       = 0x480,
+        [PCH1_SR]       = 0x482,
+        [PCHD_SR]       = 0x4c0,
+
+        /* Common Registers */
+        [CSDP]          = 0x00,
+        [CCR]           = 0x02,
+        [CICR]          = 0x04,
+        [CSR]           = 0x06,
+        [CEN]           = 0x10,
+        [CFN]           = 0x12,
+        [CSFI]          = 0x14,
+        [CSEI]          = 0x16,
+        [CPC]           = 0x18, /* 15xx only */
+        [CSAC]          = 0x18,
+        [CDAC]          = 0x1a,
+        [CDEI]          = 0x1c,
+        [CDFI]          = 0x1e,
+        [CLNK_CTRL]     = 0x28,
+
+        /* Channel specific register offsets */
+        [CSSA]          = 0x08,
+        [CDSA]          = 0x0c,
+        [COLOR]         = 0x20,
+        [CCR2]          = 0x24,
+        [LCH_CTRL]      = 0x2a,
+};
+
+static struct resource res[] __initdata = {
+        [0] = {
+                .start  = OMAP1_DMA_BASE,
+                .end    = OMAP1_DMA_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .name   = "0",
+                .start  = INT_DMA_CH0_6,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [2] = {
+                .name   = "1",
+                .start  = INT_DMA_CH1_7,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [3] = {
+                .name   = "2",
+                .start  = INT_DMA_CH2_8,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [4] = {
+                .name   = "3",
+                .start  = INT_DMA_CH3,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [5] = {
+                .name   = "4",
+                .start  = INT_DMA_CH4,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [6] = {
+                .name   = "5",
+                .start  = INT_DMA_CH5,
+                .flags  = IORESOURCE_IRQ,
+        },
+        /* Handled in lcd_dma.c */
+        [7] = {
+                .name   = "6",
+                .start  = INT_1610_DMA_CH6,
+                .flags  = IORESOURCE_IRQ,
+        },
+        /* irq's for omap16xx and omap7xx */
+        [8] = {
+                .name   = "7",
+                .start  = INT_1610_DMA_CH7,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [9] = {
+                .name   = "8",
+                .start  = INT_1610_DMA_CH8,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [10] = {
+                .name  = "9",
+                .start = INT_1610_DMA_CH9,
+                .flags = IORESOURCE_IRQ,
+        },
+        [11] = {
+                .name  = "10",
+                .start = INT_1610_DMA_CH10,
+                .flags = IORESOURCE_IRQ,
+        },
+        [12] = {
+                .name  = "11",
+                .start = INT_1610_DMA_CH11,
+                .flags = IORESOURCE_IRQ,
+        },
+        [13] = {
+                .name  = "12",
+                .start = INT_1610_DMA_CH12,
+                .flags = IORESOURCE_IRQ,
+        },
+        [14] = {
+                .name  = "13",
+                .start = INT_1610_DMA_CH13,
+                .flags = IORESOURCE_IRQ,
+        },
+        [15] = {
+                .name  = "14",
+                .start = INT_1610_DMA_CH14,
+                .flags = IORESOURCE_IRQ,
+        },
+        [16] = {
+                .name  = "15",
+                .start = INT_1610_DMA_CH15,
+                .flags = IORESOURCE_IRQ,
+        },
+        [17] = {
+                .name  = "16",
+                .start = INT_DMA_LCD,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static void __iomem *dma_base;
+static inline void dma_write(u32 val, int reg, int lch)
+{
+        u8  stride;
+        u32 offset;
+
+        stride = (reg >= dma_common_ch_start) ? dma_stride : 0;
+        offset = reg_map[reg] + (stride * lch);
+
+        __raw_writew(val, dma_base + offset);
+        if ((reg > CLNK_CTRL && reg < CCEN) ||
+                        (reg > PCHD_ID && reg < CAPS_2)) {
+                u32 offset2 = reg_map[reg] + 2 + (stride * lch);
+                __raw_writew(val >> 16, dma_base + offset2);
+        }
+}
+
+static inline u32 dma_read(int reg, int lch)
+{
+        u8 stride;
+        u32 offset, val;
+
+        stride = (reg >= dma_common_ch_start) ? dma_stride : 0;
+        offset = reg_map[reg] + (stride * lch);
+
+        val = __raw_readw(dma_base + offset);
+        if ((reg > CLNK_CTRL && reg < CCEN) ||
+                        (reg > PCHD_ID && reg < CAPS_2)) {
+                u16 upper;
+                u32 offset2 = reg_map[reg] + 2 + (stride * lch);
+                upper = __raw_readw(dma_base + offset2);
+                val |= (upper << 16);
+        }
+        return val;
+}
+
+static void omap1_clear_lch_regs(int lch)
+{
+        int i = dma_common_ch_start;
+
+        for (; i <= dma_common_ch_end; i += 1)
+                dma_write(0, i, lch);
+}
+
+static void omap1_clear_dma(int lch)
+{
+        u32 l;
+
+        l = dma_read(CCR, lch);
+        l &= ~OMAP_DMA_CCR_EN;
+        dma_write(l, CCR, lch);
+
+        /* Clear pending interrupts */
+        l = dma_read(CSR, lch);
+}
+
+static void omap1_show_dma_caps(void)
+{
+        if (enable_1510_mode) {
+                printk(KERN_INFO "DMA support for OMAP15xx initialized\n");
+        } else {
+                u16 w;
+                printk(KERN_INFO "OMAP DMA hardware version %d\n",
+                                                        dma_read(HW_ID, 0));
+                printk(KERN_INFO "DMA capabilities: %08x:%08x:%04x:%04x:%04x\n",
+                        dma_read(CAPS_0, 0), dma_read(CAPS_1, 0),
+                        dma_read(CAPS_2, 0), dma_read(CAPS_3, 0),
+                        dma_read(CAPS_4, 0));
+
+                /* Disable OMAP 3.0/3.1 compatibility mode. */
+                w = dma_read(GSCR, 0);
+                w |= 1 << 3;
+                dma_write(w, GSCR, 0);
+        }
+        return;
+}
+
+static u32 configure_dma_errata(void)
+{
+
+        /*
+         * Erratum 3.2/3.3: sometimes 0 is returned if CSAC/CDAC is
+         * read before the DMA controller finished disabling the channel.
+         */
+        if (!cpu_is_omap15xx())
+                SET_DMA_ERRATA(DMA_ERRATA_3_3);
+
+        return errata;
+}
+
+static int __init omap1_system_dma_init(void)
+{
+        struct omap_system_dma_plat_info        *p;
+        struct omap_dma_dev_attr                *d;
+        struct platform_device                  *pdev;
+        int ret;
+
+        pdev = platform_device_alloc("omap_dma_system", 0);
+        if (!pdev) {
+                pr_err("%s: Unable to device alloc for dma\n",
+                        __func__);
+                return -ENOMEM;
+        }
+
+        dma_base = ioremap(res[0].start, resource_size(&res[0]));
+        if (!dma_base) {
+                pr_err("%s: Unable to ioremap\n", __func__);
+                ret = -ENODEV;
+                goto exit_device_put;
+        }
+
+        ret = platform_device_add_resources(pdev, res, ARRAY_SIZE(res));
+        if (ret) {
+                dev_err(&pdev->dev, "%s: Unable to add resources for %s%d\n",
+                        __func__, pdev->name, pdev->id);
+                goto exit_device_put;
+        }
+
+        p = kzalloc(sizeof(struct omap_system_dma_plat_info), GFP_KERNEL);
+        if (!p) {
+                dev_err(&pdev->dev, "%s: Unable to allocate 'p' for %s\n",
+                        __func__, pdev->name);
+                ret = -ENOMEM;
+                goto exit_device_del;
+        }
+
+        d = kzalloc(sizeof(struct omap_dma_dev_attr), GFP_KERNEL);
+        if (!d) {
+                dev_err(&pdev->dev, "%s: Unable to allocate 'd' for %s\n",
+                        __func__, pdev->name);
+                ret = -ENOMEM;
+                goto exit_release_p;
+        }
+
+        d->lch_count            = OMAP1_LOGICAL_DMA_CH_COUNT;
+
+        /* Valid attributes for omap1 plus processors */
+        if (cpu_is_omap15xx())
+                d->dev_caps = ENABLE_1510_MODE;
+        enable_1510_mode = d->dev_caps & ENABLE_1510_MODE;
+
+        d->dev_caps             |= SRC_PORT;
+        d->dev_caps             |= DST_PORT;
+        d->dev_caps             |= SRC_INDEX;
+        d->dev_caps             |= DST_INDEX;
+        d->dev_caps             |= IS_BURST_ONLY4;
+        d->dev_caps             |= CLEAR_CSR_ON_READ;
+        d->dev_caps             |= IS_WORD_16;
+
+
+        d->chan = kzalloc(sizeof(struct omap_dma_lch) *
+                                        (d->lch_count), GFP_KERNEL);
+        if (!d->chan) {
+                dev_err(&pdev->dev, "%s: Memory allocation failed"
+                                        "for d->chan!!!\n", __func__);
+                goto exit_release_d;
+        }
+
+        if (cpu_is_omap15xx())
+                d->chan_count = 9;
+        else if (cpu_is_omap16xx() || cpu_is_omap7xx()) {
+                if (!(d->dev_caps & ENABLE_1510_MODE))
+                        d->chan_count = 16;
+                else
+                        d->chan_count = 9;
+        }
+
+        p->dma_attr = d;
+
+        p->show_dma_caps        = omap1_show_dma_caps;
+        p->clear_lch_regs       = omap1_clear_lch_regs;
+        p->clear_dma            = omap1_clear_dma;
+        p->dma_write            = dma_write;
+        p->dma_read             = dma_read;
+        p->disable_irq_lch      = NULL;
+
+        p->errata = configure_dma_errata();
+
+        ret = platform_device_add_data(pdev, p, sizeof(*p));
+        if (ret) {
+                dev_err(&pdev->dev, "%s: Unable to add resources for %s%d\n",
+                        __func__, pdev->name, pdev->id);
+                goto exit_release_chan;
+        }
+
+        ret = platform_device_add(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "%s: Unable to add resources for %s%d\n",
+                        __func__, pdev->name, pdev->id);
+                goto exit_release_chan;
+        }
+
+        dma_stride              = OMAP1_DMA_STRIDE;
+        dma_common_ch_start     = CPC;
+        dma_common_ch_end       = COLOR;
+
+        return ret;
+
+exit_release_chan:
+        kfree(d->chan);
+exit_release_d:
+        kfree(d);
+exit_release_p:
+        kfree(p);
+exit_device_del:
+        platform_device_del(pdev);
+exit_device_put:
+        platform_device_put(pdev);
+
+        return ret;
+}
+arch_initcall(omap1_system_dma_init);
diff --git a/arch/arm/mach-omap1/flash.c b/arch/arm/mach-omap1/flash.c
index 0b07a78eeaa7..1749cb37dda0 100644
--- a/arch/arm/mach-omap1/flash.c
+++ b/arch/arm/mach-omap1/flash.c
@@ -11,8 +11,9 @@
 
 #include <plat/io.h>
 #include <plat/tc.h>
+#include <plat/flash.h>
 
-void omap1_set_vpp(struct map_info *map, int enable)
+void omap1_set_vpp(struct platform_device *pdev, int enable)
 {
         static int count;
         u32 l;
diff --git a/arch/arm/mach-omap1/fpga.c b/arch/arm/mach-omap1/fpga.c
index 5cfce1636da0..cddbf8b089ce 100644
--- a/arch/arm/mach-omap1/fpga.c
+++ b/arch/arm/mach-omap1/fpga.c
@@ -30,9 +30,9 @@
 #include <plat/fpga.h>
 #include <mach/gpio.h>
 
-static void fpga_mask_irq(unsigned int irq)
+static void fpga_mask_irq(struct irq_data *d)
 {
-        irq -= OMAP_FPGA_IRQ_BASE;
+        unsigned int irq = d->irq - OMAP_FPGA_IRQ_BASE;
 
         if (irq < 8)
                 __raw_writeb((__raw_readb(OMAP1510_FPGA_IMR_LO)
@@ -58,14 +58,14 @@ static inline u32 get_fpga_unmasked_irqs(void)
 }
 
 
-static void fpga_ack_irq(unsigned int irq)
+static void fpga_ack_irq(struct irq_data *d)
 {
         /* Don't need to explicitly ACK FPGA interrupts */
 }
 
-static void fpga_unmask_irq(unsigned int irq)
+static void fpga_unmask_irq(struct irq_data *d)
 {
-        irq -= OMAP_FPGA_IRQ_BASE;
+        unsigned int irq = d->irq - OMAP_FPGA_IRQ_BASE;
 
         if (irq < 8)
                 __raw_writeb((__raw_readb(OMAP1510_FPGA_IMR_LO) | (1 << irq)),
@@ -78,10 +78,10 @@ static void fpga_unmask_irq(unsigned int irq)
                               | (1 << (irq - 16))), INNOVATOR_FPGA_IMR2);
 }
 
-static void fpga_mask_ack_irq(unsigned int irq)
+static void fpga_mask_ack_irq(struct irq_data *d)
 {
-        fpga_mask_irq(irq);
-        fpga_ack_irq(irq);
+        fpga_mask_irq(d);
+        fpga_ack_irq(d);
 }
 
 void innovator_fpga_IRQ_demux(unsigned int irq, struct irq_desc *desc)
@@ -105,17 +105,17 @@ void innovator_fpga_IRQ_demux(unsigned int irq, struct irq_desc *desc)
 
 static struct irq_chip omap_fpga_irq_ack = {
         .name           = "FPGA-ack",
-        .ack            = fpga_mask_ack_irq,
-        .mask           = fpga_mask_irq,
-        .unmask         = fpga_unmask_irq,
+        .irq_ack        = fpga_mask_ack_irq,
+        .irq_mask       = fpga_mask_irq,
+        .irq_unmask     = fpga_unmask_irq,
 };
 
 
 static struct irq_chip omap_fpga_irq = {
         .name           = "FPGA",
-        .ack            = fpga_ack_irq,
-        .mask           = fpga_mask_irq,
-        .unmask         = fpga_unmask_irq,
+        .irq_ack        = fpga_ack_irq,
+        .irq_mask       = fpga_mask_irq,
+        .irq_unmask     = fpga_unmask_irq,
 };
 
 /*
@@ -143,7 +143,7 @@ static struct irq_chip omap_fpga_irq = {
  */
 void omap1510_fpga_init_irq(void)
 {
-        int i;
+        int i, res;
 
         __raw_writeb(0, OMAP1510_FPGA_IMR_LO);
         __raw_writeb(0, OMAP1510_FPGA_IMR_HI);
@@ -156,17 +156,17 @@ void omap1510_fpga_init_irq(void)
                          * The touchscreen interrupt is level-sensitive, so
                          * we'll use the regular mask_ack routine for it.
                          */
-                        set_irq_chip(i, &omap_fpga_irq_ack);
+                        irq_set_chip(i, &omap_fpga_irq_ack);
                 }
                 else {
                         /*
                          * All FPGA interrupts except the touchscreen are
                          * edge-sensitive, so we won't mask them.
                          */
-                        set_irq_chip(i, &omap_fpga_irq);
+                        irq_set_chip(i, &omap_fpga_irq);
                 }
 
-                set_irq_handler(i, handle_edge_irq);
+                irq_set_handler(i, handle_edge_irq);
                 set_irq_flags(i, IRQF_VALID);
         }
 
@@ -177,10 +177,12 @@ void omap1510_fpga_init_irq(void)
          * NOTE: For general GPIO/MPUIO access and interrupts, please see
          * gpio.[ch]
          */
-        gpio_request(13, "FPGA irq");
+        res = gpio_request(13, "FPGA irq");
+        if (res) {
+                pr_err("%s failed to get gpio\n", __func__);
+                return;
+        }
         gpio_direction_input(13);
-        set_irq_type(gpio_to_irq(13), IRQ_TYPE_EDGE_RISING);
-        set_irq_chained_handler(OMAP1510_INT_FPGA, innovator_fpga_IRQ_demux);
+        irq_set_irq_type(gpio_to_irq(13), IRQ_TYPE_EDGE_RISING);
+        irq_set_chained_handler(OMAP1510_INT_FPGA, innovator_fpga_IRQ_demux);
 }
-
-EXPORT_SYMBOL(omap1510_fpga_init_irq);
diff --git a/arch/arm/mach-omap1/gpio15xx.c b/arch/arm/mach-omap1/gpio15xx.c
new file mode 100644
index 000000000000..364137c2042c
--- /dev/null
+++ b/arch/arm/mach-omap1/gpio15xx.c
@@ -0,0 +1,99 @@
+/*
+ * OMAP15xx specific gpio init
+ *
+ * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ * Author:
+ *      Charulatha V <charu@ti.com>
+ *
+ * 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/gpio.h>
+
+#define OMAP1_MPUIO_VBASE               OMAP1_MPUIO_BASE
+#define OMAP1510_GPIO_BASE              0xFFFCE000
+
+/* gpio1 */
+static struct __initdata resource omap15xx_mpu_gpio_resources[] = {
+        {
+                .start  = OMAP1_MPUIO_VBASE,
+                .end    = OMAP1_MPUIO_VBASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_MPUIO,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap15xx_mpu_gpio_config = {
+        .virtual_irq_start      = IH_MPUIO_BASE,
+        .bank_type              = METHOD_MPUIO,
+        .bank_width             = 16,
+        .bank_stride            = 1,
+};
+
+static struct platform_device omap15xx_mpu_gpio = {
+        .name           = "omap_gpio",
+        .id             = 0,
+        .dev            = {
+                .platform_data = &omap15xx_mpu_gpio_config,
+        },
+        .num_resources = ARRAY_SIZE(omap15xx_mpu_gpio_resources),
+        .resource = omap15xx_mpu_gpio_resources,
+};
+
+/* gpio2 */
+static struct __initdata resource omap15xx_gpio_resources[] = {
+        {
+                .start  = OMAP1510_GPIO_BASE,
+                .end    = OMAP1510_GPIO_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_GPIO_BANK1,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap15xx_gpio_config = {
+        .virtual_irq_start      = IH_GPIO_BASE,
+        .bank_type              = METHOD_GPIO_1510,
+        .bank_width             = 16,
+};
+
+static struct platform_device omap15xx_gpio = {
+        .name           = "omap_gpio",
+        .id             = 1,
+        .dev            = {
+                .platform_data = &omap15xx_gpio_config,
+        },
+        .num_resources = ARRAY_SIZE(omap15xx_gpio_resources),
+        .resource = omap15xx_gpio_resources,
+};
+
+/*
+ * omap15xx_gpio_init needs to be done before
+ * machine_init functions access gpio APIs.
+ * Hence omap15xx_gpio_init is a postcore_initcall.
+ */
+static int __init omap15xx_gpio_init(void)
+{
+        if (!cpu_is_omap15xx())
+                return -EINVAL;
+
+        platform_device_register(&omap15xx_mpu_gpio);
+        platform_device_register(&omap15xx_gpio);
+
+        gpio_bank_count = 2;
+        return 0;
+}
+postcore_initcall(omap15xx_gpio_init);
diff --git a/arch/arm/mach-omap1/gpio16xx.c b/arch/arm/mach-omap1/gpio16xx.c
new file mode 100644
index 000000000000..293a246e2824
--- /dev/null
+++ b/arch/arm/mach-omap1/gpio16xx.c
@@ -0,0 +1,200 @@
+/*
+ * OMAP16xx specific gpio init
+ *
+ * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ * Author:
+ *      Charulatha V <charu@ti.com>
+ *
+ * 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/gpio.h>
+
+#define OMAP1610_GPIO1_BASE             0xfffbe400
+#define OMAP1610_GPIO2_BASE             0xfffbec00
+#define OMAP1610_GPIO3_BASE             0xfffbb400
+#define OMAP1610_GPIO4_BASE             0xfffbbc00
+#define OMAP1_MPUIO_VBASE               OMAP1_MPUIO_BASE
+
+/* mpu gpio */
+static struct __initdata resource omap16xx_mpu_gpio_resources[] = {
+        {
+                .start  = OMAP1_MPUIO_VBASE,
+                .end    = OMAP1_MPUIO_VBASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_MPUIO,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap16xx_mpu_gpio_config = {
+        .virtual_irq_start      = IH_MPUIO_BASE,
+        .bank_type              = METHOD_MPUIO,
+        .bank_width             = 16,
+        .bank_stride            = 1,
+};
+
+static struct platform_device omap16xx_mpu_gpio = {
+        .name           = "omap_gpio",
+        .id             = 0,
+        .dev            = {
+                .platform_data = &omap16xx_mpu_gpio_config,
+        },
+        .num_resources = ARRAY_SIZE(omap16xx_mpu_gpio_resources),
+        .resource = omap16xx_mpu_gpio_resources,
+};
+
+/* gpio1 */
+static struct __initdata resource omap16xx_gpio1_resources[] = {
+        {
+                .start  = OMAP1610_GPIO1_BASE,
+                .end    = OMAP1610_GPIO1_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_GPIO_BANK1,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap16xx_gpio1_config = {
+        .virtual_irq_start      = IH_GPIO_BASE,
+        .bank_type              = METHOD_GPIO_1610,
+        .bank_width             = 16,
+};
+
+static struct platform_device omap16xx_gpio1 = {
+        .name           = "omap_gpio",
+        .id             = 1,
+        .dev            = {
+                .platform_data = &omap16xx_gpio1_config,
+        },
+        .num_resources = ARRAY_SIZE(omap16xx_gpio1_resources),
+        .resource = omap16xx_gpio1_resources,
+};
+
+/* gpio2 */
+static struct __initdata resource omap16xx_gpio2_resources[] = {
+        {
+                .start  = OMAP1610_GPIO2_BASE,
+                .end    = OMAP1610_GPIO2_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_1610_GPIO_BANK2,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap16xx_gpio2_config = {
+        .virtual_irq_start      = IH_GPIO_BASE + 16,
+        .bank_type              = METHOD_GPIO_1610,
+        .bank_width             = 16,
+};
+
+static struct platform_device omap16xx_gpio2 = {
+        .name           = "omap_gpio",
+        .id             = 2,
+        .dev            = {
+                .platform_data = &omap16xx_gpio2_config,
+        },
+        .num_resources = ARRAY_SIZE(omap16xx_gpio2_resources),
+        .resource = omap16xx_gpio2_resources,
+};
+
+/* gpio3 */
+static struct __initdata resource omap16xx_gpio3_resources[] = {
+        {
+                .start  = OMAP1610_GPIO3_BASE,
+                .end    = OMAP1610_GPIO3_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_1610_GPIO_BANK3,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap16xx_gpio3_config = {
+        .virtual_irq_start      = IH_GPIO_BASE + 32,
+        .bank_type              = METHOD_GPIO_1610,
+        .bank_width             = 16,
+};
+
+static struct platform_device omap16xx_gpio3 = {
+        .name           = "omap_gpio",
+        .id             = 3,
+        .dev            = {
+                .platform_data = &omap16xx_gpio3_config,
+        },
+        .num_resources = ARRAY_SIZE(omap16xx_gpio3_resources),
+        .resource = omap16xx_gpio3_resources,
+};
+
+/* gpio4 */
+static struct __initdata resource omap16xx_gpio4_resources[] = {
+        {
+                .start  = OMAP1610_GPIO4_BASE,
+                .end    = OMAP1610_GPIO4_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_1610_GPIO_BANK4,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap16xx_gpio4_config = {
+        .virtual_irq_start      = IH_GPIO_BASE + 48,
+        .bank_type              = METHOD_GPIO_1610,
+        .bank_width             = 16,
+};
+
+static struct platform_device omap16xx_gpio4 = {
+        .name           = "omap_gpio",
+        .id             = 4,
+        .dev            = {
+                .platform_data = &omap16xx_gpio4_config,
+        },
+        .num_resources = ARRAY_SIZE(omap16xx_gpio4_resources),
+        .resource = omap16xx_gpio4_resources,
+};
+
+static struct __initdata platform_device * omap16xx_gpio_dev[] = {
+        &omap16xx_mpu_gpio,
+        &omap16xx_gpio1,
+        &omap16xx_gpio2,
+        &omap16xx_gpio3,
+        &omap16xx_gpio4,
+};
+
+/*
+ * omap16xx_gpio_init needs to be done before
+ * machine_init functions access gpio APIs.
+ * Hence omap16xx_gpio_init is a postcore_initcall.
+ */
+static int __init omap16xx_gpio_init(void)
+{
+        int i;
+
+        if (!cpu_is_omap16xx())
+                return -EINVAL;
+
+        for (i = 0; i < ARRAY_SIZE(omap16xx_gpio_dev); i++)
+                platform_device_register(omap16xx_gpio_dev[i]);
+
+        gpio_bank_count = ARRAY_SIZE(omap16xx_gpio_dev);
+
+        return 0;
+}
+postcore_initcall(omap16xx_gpio_init);
diff --git a/arch/arm/mach-omap1/gpio7xx.c b/arch/arm/mach-omap1/gpio7xx.c
new file mode 100644
index 000000000000..c6ad248d63a6
--- /dev/null
+++ b/arch/arm/mach-omap1/gpio7xx.c
@@ -0,0 +1,262 @@
+/*
+ * OMAP7xx specific gpio init
+ *
+ * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ * Author:
+ *      Charulatha V <charu@ti.com>
+ *
+ * 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/gpio.h>
+
+#define OMAP7XX_GPIO1_BASE              0xfffbc000
+#define OMAP7XX_GPIO2_BASE              0xfffbc800
+#define OMAP7XX_GPIO3_BASE              0xfffbd000
+#define OMAP7XX_GPIO4_BASE              0xfffbd800
+#define OMAP7XX_GPIO5_BASE              0xfffbe000
+#define OMAP7XX_GPIO6_BASE              0xfffbe800
+#define OMAP1_MPUIO_VBASE               OMAP1_MPUIO_BASE
+
+/* mpu gpio */
+static struct __initdata resource omap7xx_mpu_gpio_resources[] = {
+        {
+                .start  = OMAP1_MPUIO_VBASE,
+                .end    = OMAP1_MPUIO_VBASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_7XX_MPUIO,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap7xx_mpu_gpio_config = {
+        .virtual_irq_start      = IH_MPUIO_BASE,
+        .bank_type              = METHOD_MPUIO,
+        .bank_width             = 32,
+        .bank_stride            = 2,
+};
+
+static struct platform_device omap7xx_mpu_gpio = {
+        .name           = "omap_gpio",
+        .id             = 0,
+        .dev            = {
+                .platform_data = &omap7xx_mpu_gpio_config,
+        },
+        .num_resources = ARRAY_SIZE(omap7xx_mpu_gpio_resources),
+        .resource = omap7xx_mpu_gpio_resources,
+};
+
+/* gpio1 */
+static struct __initdata resource omap7xx_gpio1_resources[] = {
+        {
+                .start  = OMAP7XX_GPIO1_BASE,
+                .end    = OMAP7XX_GPIO1_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_7XX_GPIO_BANK1,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap7xx_gpio1_config = {
+        .virtual_irq_start      = IH_GPIO_BASE,
+        .bank_type              = METHOD_GPIO_7XX,
+        .bank_width             = 32,
+};
+
+static struct platform_device omap7xx_gpio1 = {
+        .name           = "omap_gpio",
+        .id             = 1,
+        .dev            = {
+                .platform_data = &omap7xx_gpio1_config,
+        },
+        .num_resources = ARRAY_SIZE(omap7xx_gpio1_resources),
+        .resource = omap7xx_gpio1_resources,
+};
+
+/* gpio2 */
+static struct __initdata resource omap7xx_gpio2_resources[] = {
+        {
+                .start  = OMAP7XX_GPIO2_BASE,
+                .end    = OMAP7XX_GPIO2_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_7XX_GPIO_BANK2,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap7xx_gpio2_config = {
+        .virtual_irq_start      = IH_GPIO_BASE + 32,
+        .bank_type              = METHOD_GPIO_7XX,
+        .bank_width             = 32,
+};
+
+static struct platform_device omap7xx_gpio2 = {
+        .name           = "omap_gpio",
+        .id             = 2,
+        .dev            = {
+                .platform_data = &omap7xx_gpio2_config,
+        },
+        .num_resources = ARRAY_SIZE(omap7xx_gpio2_resources),
+        .resource = omap7xx_gpio2_resources,
+};
+
+/* gpio3 */
+static struct __initdata resource omap7xx_gpio3_resources[] = {
+        {
+                .start  = OMAP7XX_GPIO3_BASE,
+                .end    = OMAP7XX_GPIO3_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_7XX_GPIO_BANK3,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap7xx_gpio3_config = {
+        .virtual_irq_start      = IH_GPIO_BASE + 64,
+        .bank_type              = METHOD_GPIO_7XX,
+        .bank_width             = 32,
+};
+
+static struct platform_device omap7xx_gpio3 = {
+        .name           = "omap_gpio",
+        .id             = 3,
+        .dev            = {
+                .platform_data = &omap7xx_gpio3_config,
+        },
+        .num_resources = ARRAY_SIZE(omap7xx_gpio3_resources),
+        .resource = omap7xx_gpio3_resources,
+};
+
+/* gpio4 */
+static struct __initdata resource omap7xx_gpio4_resources[] = {
+        {
+                .start  = OMAP7XX_GPIO4_BASE,
+                .end    = OMAP7XX_GPIO4_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_7XX_GPIO_BANK4,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap7xx_gpio4_config = {
+        .virtual_irq_start      = IH_GPIO_BASE + 96,
+        .bank_type              = METHOD_GPIO_7XX,
+        .bank_width             = 32,
+};
+
+static struct platform_device omap7xx_gpio4 = {
+        .name           = "omap_gpio",
+        .id             = 4,
+        .dev            = {
+                .platform_data = &omap7xx_gpio4_config,
+        },
+        .num_resources = ARRAY_SIZE(omap7xx_gpio4_resources),
+        .resource = omap7xx_gpio4_resources,
+};
+
+/* gpio5 */
+static struct __initdata resource omap7xx_gpio5_resources[] = {
+        {
+                .start  = OMAP7XX_GPIO5_BASE,
+                .end    = OMAP7XX_GPIO5_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_7XX_GPIO_BANK5,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap7xx_gpio5_config = {
+        .virtual_irq_start      = IH_GPIO_BASE + 128,
+        .bank_type              = METHOD_GPIO_7XX,
+        .bank_width             = 32,
+};
+
+static struct platform_device omap7xx_gpio5 = {
+        .name           = "omap_gpio",
+        .id             = 5,
+        .dev            = {
+                .platform_data = &omap7xx_gpio5_config,
+        },
+        .num_resources = ARRAY_SIZE(omap7xx_gpio5_resources),
+        .resource = omap7xx_gpio5_resources,
+};
+
+/* gpio6 */
+static struct __initdata resource omap7xx_gpio6_resources[] = {
+        {
+                .start  = OMAP7XX_GPIO6_BASE,
+                .end    = OMAP7XX_GPIO6_BASE + SZ_2K - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        {
+                .start  = INT_7XX_GPIO_BANK6,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct __initdata omap_gpio_platform_data omap7xx_gpio6_config = {
+        .virtual_irq_start      = IH_GPIO_BASE + 160,
+        .bank_type              = METHOD_GPIO_7XX,
+        .bank_width             = 32,
+};
+
+static struct platform_device omap7xx_gpio6 = {
+        .name           = "omap_gpio",
+        .id             = 6,
+        .dev            = {
+                .platform_data = &omap7xx_gpio6_config,
+        },
+        .num_resources = ARRAY_SIZE(omap7xx_gpio6_resources),
+        .resource = omap7xx_gpio6_resources,
+};
+
+static struct __initdata platform_device * omap7xx_gpio_dev[] = {
+        &omap7xx_mpu_gpio,
+        &omap7xx_gpio1,
+        &omap7xx_gpio2,
+        &omap7xx_gpio3,
+        &omap7xx_gpio4,
+        &omap7xx_gpio5,
+        &omap7xx_gpio6,
+};
+
+/*
+ * omap7xx_gpio_init needs to be done before
+ * machine_init functions access gpio APIs.
+ * Hence omap7xx_gpio_init is a postcore_initcall.
+ */
+static int __init omap7xx_gpio_init(void)
+{
+        int i;
+
+        if (!cpu_is_omap7xx())
+                return -EINVAL;
+
+        for (i = 0; i < ARRAY_SIZE(omap7xx_gpio_dev); i++)
+                platform_device_register(omap7xx_gpio_dev[i]);
+
+        gpio_bank_count = ARRAY_SIZE(omap7xx_gpio_dev);
+
+        return 0;
+}
+postcore_initcall(omap7xx_gpio_init);
diff --git a/arch/arm/mach-omap1/include/mach/ams-delta-fiq.h b/arch/arm/mach-omap1/include/mach/ams-delta-fiq.h
index 7a2df29400ca..23eed0035ed8 100644
--- a/arch/arm/mach-omap1/include/mach/ams-delta-fiq.h
+++ b/arch/arm/mach-omap1/include/mach/ams-delta-fiq.h
@@ -31,7 +31,7 @@
 #endif
 
 /*
- * These are the offsets from the begining of the fiq_buffer. They are put here
+ * These are the offsets from the beginning of the fiq_buffer. They are put here
  * since the buffer and header need to be accessed by drivers servicing devices
  * which generate GPIO interrupts - e.g. keyboard, modem, hook switch.
  */
diff --git a/arch/arm/mach-omap1/include/mach/camera.h b/arch/arm/mach-omap1/include/mach/camera.h
new file mode 100644
index 000000000000..847d00f0bb0a
--- /dev/null
+++ b/arch/arm/mach-omap1/include/mach/camera.h
@@ -0,0 +1,13 @@
+#ifndef __ASM_ARCH_CAMERA_H_
+#define __ASM_ARCH_CAMERA_H_
+
+#include <media/omap1_camera.h>
+
+void omap1_camera_init(void *);
+
+static inline void omap1_set_camera_info(struct omap1_cam_platform_data *info)
+{
+        omap1_camera_init(info);
+}
+
+#endif /* __ASM_ARCH_CAMERA_H_ */
diff --git a/arch/arm/mach-omap1/include/mach/debug-macro.S b/arch/arm/mach-omap1/include/mach/debug-macro.S
index 671408eb4ab4..62856044eb63 100644
--- a/arch/arm/mach-omap1/include/mach/debug-macro.S
+++ b/arch/arm/mach-omap1/include/mach/debug-macro.S
@@ -17,6 +17,9 @@
 
 #include <plat/serial.h>
 
+#define omap_uart_v2p(x)        ((x) - PAGE_OFFSET + PLAT_PHYS_OFFSET)
+#define omap_uart_p2v(x)        ((x) - PLAT_PHYS_OFFSET + PAGE_OFFSET)
+
                 .pushsection .data
 omap_uart_phys: .word   0x0
 omap_uart_virt: .word   0x0
@@ -28,56 +31,58 @@ omap_uart_virt:	.word	0x0
                  * the desired UART phys and virt addresses temporarily into
                  * the omap_uart_phys and omap_uart_virt above.
                  */
-                .macro  addruart, rx, tmp
+                .macro  addruart, rp, rv
 
                 /* Use omap_uart_phys/virt if already configured */
-9:              mrc     p15, 0, \rx, c1, c0
-                tst     \rx, #1                 @ MMU enabled?
-                ldreq   \rx, =__virt_to_phys(omap_uart_phys)    @ physical base address
-                ldrne   \rx, =omap_uart_virt    @ virtual base
-                ldr     \rx, [\rx, #0]
-                cmp     \rx, #0                 @ is port configured?
+9:              mrc     p15, 0, \rp, c1, c0
+                tst     \rp, #1                 @ MMU enabled?
+                ldreq   \rp, =omap_uart_v2p(omap_uart_phys)     @ MMU disabled
+                ldrne   \rp, =omap_uart_phys    @ MMU enabled
+                add     \rv, \rp, #4            @ omap_uart_virt
+                ldr     \rp, [\rp, #0]
+                ldr     \rv, [\rv, #0]
+                cmp     \rp, #0                 @ is port configured?
+                cmpne   \rv, #0
                 bne     99f                     @ already configured
 
                 /* Check the debug UART configuration set in uncompress.h */
-                mrc     p15, 0, \rx, c1, c0
-                tst     \rx, #1                 @ MMU enabled?
-                ldreq   \rx, =OMAP_UART_INFO
-                ldrne   \rx, =__phys_to_virt(OMAP_UART_INFO)
-                ldr     \rx, [\rx, #0]
+                mrc     p15, 0, \rp, c1, c0
+                tst     \rp, #1                 @ MMU enabled?
+                ldreq   \rp, =OMAP_UART_INFO    @ MMU not enabled
+                ldrne   \rp, =omap_uart_p2v(OMAP_UART_INFO)     @ MMU enabled
+                ldr     \rp, [\rp, #0]
 
                 /* Select the UART to use based on the UART1 scratchpad value */
-10:             cmp     \rx, #0                 @ no port configured?
+10:             cmp     \rp, #0                 @ no port configured?
                 beq     11f                     @ if none, try to use UART1
-                cmp     \rx, #OMAP1UART1
+                cmp     \rp, #OMAP1UART1
                 beq     11f                     @ configure OMAP1UART1
-                cmp     \rx, #OMAP1UART2
+                cmp     \rp, #OMAP1UART2
                 beq     12f                     @ configure OMAP1UART2
-                cmp     \rx, #OMAP1UART3
+                cmp     \rp, #OMAP1UART3
                 beq     13f                     @ configure OMAP2UART3
 
                 /* Configure the UART offset from the phys/virt base */
-11:             mov     \rx, #0x00fb0000        @ OMAP1UART1
+11:             mov     \rp, #0x00fb0000        @ OMAP1UART1
                 b       98f
-12:             mov     \rx, #0x00fb0000        @ OMAP1UART1
-                orr     \rx, \rx, #0x00000800   @ OMAP1UART2
+12:             mov     \rp, #0x00fb0000        @ OMAP1UART1
+                orr     \rp, \rp, #0x00000800   @ OMAP1UART2
                 b       98f
-13:             mov     \rx, #0x00fb0000        @ OMAP1UART1
-                orr     \rx, \rx, #0x00000800   @ OMAP1UART2
-                orr     \rx, \rx, #0x00009000   @ OMAP1UART3
+13:             mov     \rp, #0x00fb0000        @ OMAP1UART1
+                orr     \rp, \rp, #0x00000800   @ OMAP1UART2
+                orr     \rp, \rp, #0x00009000   @ OMAP1UART3
 
                 /* Store both phys and virt address for the uart */
-98:             add     \rx, \rx, #0xff000000   @ phys base
-                mrc     p15, 0, \tmp, c1, c0
-                tst     \tmp, #1                @ MMU enabled?
-                ldreq   \tmp, =__virt_to_phys(omap_uart_phys)
-                ldrne   \tmp, =omap_uart_phys
-                str     \rx, [\tmp, #0]
-                sub     \rx, \rx, #0xff000000   @ phys base
-                add     \rx, \rx, #0xfe000000   @ virt base
-                ldreq   \tmp, =__virt_to_phys(omap_uart_virt)
-                ldrne   \tmp, =omap_uart_virt
-                str     \rx, [\tmp, #0]
+98:             add     \rp, \rp, #0xff000000   @ phys base
+                mrc     p15, 0, \rv, c1, c0
+                tst     \rv, #1                 @ MMU enabled?
+                ldreq   \rv, =omap_uart_v2p(omap_uart_phys)     @ MMU disabled
+                ldrne   \rv, =omap_uart_phys    @ MMU enabled
+                str     \rp, [\rv, #0]
+                sub     \rp, \rp, #0xff000000   @ phys base
+                add     \rp, \rp, #0xfe000000   @ virt base
+                add     \rv, \rv, #4            @ omap_uart_lsr
+                str     \rp, [\rv, #0]
                 b       9b
 99:
                 .endm
diff --git a/arch/arm/mach-omap1/include/mach/entry-macro.S b/arch/arm/mach-omap1/include/mach/entry-macro.S
index df9060edda28..bfb4fb1d7382 100644
--- a/arch/arm/mach-omap1/include/mach/entry-macro.S
+++ b/arch/arm/mach-omap1/include/mach/entry-macro.S
@@ -14,20 +14,6 @@
 #include <mach/irqs.h>
 #include <asm/hardware/gic.h>
 
-#if (defined(CONFIG_ARCH_OMAP730)||defined(CONFIG_ARCH_OMAP850)) && \
-        (defined(CONFIG_ARCH_OMAP15XX) || defined(CONFIG_ARCH_OMAP16XX))
-#error "FIXME: OMAP7XX doesn't support multiple-OMAP"
-#elif defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
-#define INT_IH2_IRQ             INT_7XX_IH2_IRQ
-#elif defined(CONFIG_ARCH_OMAP15XX)
-#define INT_IH2_IRQ             INT_1510_IH2_IRQ
-#elif defined(CONFIG_ARCH_OMAP16XX)
-#define INT_IH2_IRQ             INT_1610_IH2_IRQ
-#else
-#warning "IH2 IRQ defaulted"
-#define INT_IH2_IRQ             INT_1510_IH2_IRQ
-#endif
-
                 .macro  disable_fiq
                 .endm
 
@@ -47,9 +33,11 @@
                 beq     1510f
 
                 ldr     \irqnr, [\base, #IRQ_SIR_FIQ_REG_OFFSET]
+                ldr     \tmp, =omap_irq_flags   @ irq flags address
+                ldr     \tmp, [\tmp, #0]        @ irq flags value
                 cmp     \irqnr, #0
                 ldreq   \irqnr, [\base, #IRQ_SIR_IRQ_REG_OFFSET]
-                cmpeq   \irqnr, #INT_IH2_IRQ
+                cmpeq   \irqnr, \tmp
                 ldreq   \base, =OMAP1_IO_ADDRESS(OMAP_IH2_BASE)
                 ldreq   \irqnr, [\base, #IRQ_SIR_IRQ_REG_OFFSET]
                 addeqs  \irqnr, \irqnr, #32
diff --git a/arch/arm/mach-omap1/include/mach/vmalloc.h b/arch/arm/mach-omap1/include/mach/vmalloc.h
index 1b2af14df151..22ec4a479577 100644
--- a/arch/arm/mach-omap1/include/mach/vmalloc.h
+++ b/arch/arm/mach-omap1/include/mach/vmalloc.h
@@ -17,4 +17,4 @@
  * 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 + 0x18000000)
+#define VMALLOC_END     0xd8000000UL
diff --git a/arch/arm/mach-omap1/io.c b/arch/arm/mach-omap1/io.c
index 0ce3fec2d257..870886a29594 100644
--- a/arch/arm/mach-omap1/io.c
+++ b/arch/arm/mach-omap1/io.c
@@ -142,3 +142,42 @@ void __init omap1_init_common_hw(void)
         omap1_mux_init();
 }
 
+/*
+ * NOTE: Please use ioremap + __raw_read/write where possible instead of these
+ */
+
+u8 omap_readb(u32 pa)
+{
+        return __raw_readb(OMAP1_IO_ADDRESS(pa));
+}
+EXPORT_SYMBOL(omap_readb);
+
+u16 omap_readw(u32 pa)
+{
+        return __raw_readw(OMAP1_IO_ADDRESS(pa));
+}
+EXPORT_SYMBOL(omap_readw);
+
+u32 omap_readl(u32 pa)
+{
+        return __raw_readl(OMAP1_IO_ADDRESS(pa));
+}
+EXPORT_SYMBOL(omap_readl);
+
+void omap_writeb(u8 v, u32 pa)
+{
+        __raw_writeb(v, OMAP1_IO_ADDRESS(pa));
+}
+EXPORT_SYMBOL(omap_writeb);
+
+void omap_writew(u16 v, u32 pa)
+{
+        __raw_writew(v, OMAP1_IO_ADDRESS(pa));
+}
+EXPORT_SYMBOL(omap_writew);
+
+void omap_writel(u32 v, u32 pa)
+{
+        __raw_writel(v, OMAP1_IO_ADDRESS(pa));
+}
+EXPORT_SYMBOL(omap_writel);
diff --git a/arch/arm/mach-omap1/irq.c b/arch/arm/mach-omap1/irq.c
index db913c34d1fe..5d3da7a63af3 100644
--- a/arch/arm/mach-omap1/irq.c
+++ b/arch/arm/mach-omap1/irq.c
@@ -57,6 +57,7 @@ struct omap_irq_bank {
         unsigned long wake_enable;
 };
 
+u32 omap_irq_flags;
 static unsigned int irq_bank_count;
 static struct omap_irq_bank *irq_banks;
 
@@ -70,48 +71,48 @@ static inline void irq_bank_writel(unsigned long value, int bank, int offset)
         omap_writel(value, irq_banks[bank].base_reg + offset);
 }
 
-static void omap_ack_irq(unsigned int irq)
+static void omap_ack_irq(struct irq_data *d)
 {
-        if (irq > 31)
+        if (d->irq > 31)
                 omap_writel(0x1, OMAP_IH2_BASE + IRQ_CONTROL_REG_OFFSET);
 
         omap_writel(0x1, OMAP_IH1_BASE + IRQ_CONTROL_REG_OFFSET);
 }
 
-static void omap_mask_irq(unsigned int irq)
+static void omap_mask_irq(struct irq_data *d)
 {
-        int bank = IRQ_BANK(irq);
+        int bank = IRQ_BANK(d->irq);
         u32 l;
 
         l = omap_readl(irq_banks[bank].base_reg + IRQ_MIR_REG_OFFSET);
-        l |= 1 << IRQ_BIT(irq);
+        l |= 1 << IRQ_BIT(d->irq);
         omap_writel(l, irq_banks[bank].base_reg + IRQ_MIR_REG_OFFSET);
 }
 
-static void omap_unmask_irq(unsigned int irq)
+static void omap_unmask_irq(struct irq_data *d)
 {
-        int bank = IRQ_BANK(irq);
+        int bank = IRQ_BANK(d->irq);
         u32 l;
 
         l = omap_readl(irq_banks[bank].base_reg + IRQ_MIR_REG_OFFSET);
-        l &= ~(1 << IRQ_BIT(irq));
+        l &= ~(1 << IRQ_BIT(d->irq));
         omap_writel(l, irq_banks[bank].base_reg + IRQ_MIR_REG_OFFSET);
 }
 
-static void omap_mask_ack_irq(unsigned int irq)
+static void omap_mask_ack_irq(struct irq_data *d)
 {
-        omap_mask_irq(irq);
-        omap_ack_irq(irq);
+        omap_mask_irq(d);
+        omap_ack_irq(d);
 }
 
-static int omap_wake_irq(unsigned int irq, unsigned int enable)
+static int omap_wake_irq(struct irq_data *d, unsigned int enable)
 {
-        int bank = IRQ_BANK(irq);
+        int bank = IRQ_BANK(d->irq);
 
         if (enable)
-                irq_banks[bank].wake_enable |= IRQ_BIT(irq);
+                irq_banks[bank].wake_enable |= IRQ_BIT(d->irq);
         else
-                irq_banks[bank].wake_enable &= ~IRQ_BIT(irq);
+                irq_banks[bank].wake_enable &= ~IRQ_BIT(d->irq);
 
         return 0;
 }
@@ -168,10 +169,10 @@ static struct omap_irq_bank omap1610_irq_banks[] = {
 
 static struct irq_chip omap_irq_chip = {
         .name           = "MPU",
-        .ack            = omap_mask_ack_irq,
-        .mask           = omap_mask_irq,
-        .unmask         = omap_unmask_irq,
-        .set_wake       = omap_wake_irq,
+        .irq_ack        = omap_mask_ack_irq,
+        .irq_mask       = omap_mask_irq,
+        .irq_unmask     = omap_unmask_irq,
+        .irq_set_wake   = omap_wake_irq,
 };
 
 void __init omap_init_irq(void)
@@ -180,22 +181,26 @@ void __init omap_init_irq(void)
 
 #if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
         if (cpu_is_omap7xx()) {
+                omap_irq_flags = INT_7XX_IH2_IRQ;
                 irq_banks = omap7xx_irq_banks;
                 irq_bank_count = ARRAY_SIZE(omap7xx_irq_banks);
         }
 #endif
 #ifdef CONFIG_ARCH_OMAP15XX
         if (cpu_is_omap1510()) {
+                omap_irq_flags = INT_1510_IH2_IRQ;
                 irq_banks = omap1510_irq_banks;
                 irq_bank_count = ARRAY_SIZE(omap1510_irq_banks);
         }
         if (cpu_is_omap310()) {
+                omap_irq_flags = INT_1510_IH2_IRQ;
                 irq_banks = omap310_irq_banks;
                 irq_bank_count = ARRAY_SIZE(omap310_irq_banks);
         }
 #endif
 #if defined(CONFIG_ARCH_OMAP16XX)
         if (cpu_is_omap16xx()) {
+                omap_irq_flags = INT_1510_IH2_IRQ;
                 irq_banks = omap1610_irq_banks;
                 irq_bank_count = ARRAY_SIZE(omap1610_irq_banks);
         }
@@ -225,8 +230,8 @@ void __init omap_init_irq(void)
                         irq_trigger = irq_banks[i].trigger_map >> IRQ_BIT(j);
                         omap_irq_set_cfg(j, 0, 0, irq_trigger);
 
-                        set_irq_chip(j, &omap_irq_chip);
-                        set_irq_handler(j, handle_level_irq);
+                        irq_set_chip_and_handler(j, &omap_irq_chip,
+                                                 handle_level_irq);
                         set_irq_flags(j, IRQF_VALID);
                 }
         }
@@ -234,9 +239,9 @@ void __init omap_init_irq(void)
         /* Unmask level 2 handler */
 
         if (cpu_is_omap7xx())
-                omap_unmask_irq(INT_7XX_IH2_IRQ);
+                omap_unmask_irq(irq_get_irq_data(INT_7XX_IH2_IRQ));
         else if (cpu_is_omap15xx())
-                omap_unmask_irq(INT_1510_IH2_IRQ);
+                omap_unmask_irq(irq_get_irq_data(INT_1510_IH2_IRQ));
         else if (cpu_is_omap16xx())
-                omap_unmask_irq(INT_1610_IH2_IRQ);
+                omap_unmask_irq(irq_get_irq_data(INT_1610_IH2_IRQ));
 }
diff --git a/arch/arm/mach-omap1/lcd_dma.c b/arch/arm/mach-omap1/lcd_dma.c
index 3be11af687bb..453809359ba6 100644
--- a/arch/arm/mach-omap1/lcd_dma.c
+++ b/arch/arm/mach-omap1/lcd_dma.c
@@ -37,7 +37,7 @@ int omap_lcd_dma_running(void)
          * On OMAP1510, internal LCD controller will start the transfer
          * when it gets enabled, so assume DMA running if LCD enabled.
          */
-        if (cpu_is_omap1510())
+        if (cpu_is_omap15xx())
                 if (omap_readw(OMAP_LCDC_CONTROL) & OMAP_LCDC_CTRL_LCD_EN)
                         return 1;
 
@@ -95,7 +95,7 @@ EXPORT_SYMBOL(omap_set_lcd_dma_single_transfer);
 
 void omap_set_lcd_dma_b1_rotation(int rotate)
 {
-        if (cpu_is_omap1510()) {
+        if (cpu_is_omap15xx()) {
                 printk(KERN_ERR "DMA rotation is not supported in 1510 mode\n");
                 BUG();
                 return;
@@ -106,7 +106,7 @@ EXPORT_SYMBOL(omap_set_lcd_dma_b1_rotation);
 
 void omap_set_lcd_dma_b1_mirror(int mirror)
 {
-        if (cpu_is_omap1510()) {
+        if (cpu_is_omap15xx()) {
                 printk(KERN_ERR "DMA mirror is not supported in 1510 mode\n");
                 BUG();
         }
@@ -116,7 +116,7 @@ EXPORT_SYMBOL(omap_set_lcd_dma_b1_mirror);
 
 void omap_set_lcd_dma_b1_vxres(unsigned long vxres)
 {
-        if (cpu_is_omap1510()) {
+        if (cpu_is_omap15xx()) {
                 printk(KERN_ERR "DMA virtual resulotion is not supported "
                                 "in 1510 mode\n");
                 BUG();
@@ -127,7 +127,7 @@ EXPORT_SYMBOL(omap_set_lcd_dma_b1_vxres);
 
 void omap_set_lcd_dma_b1_scale(unsigned int xscale, unsigned int yscale)
 {
-        if (cpu_is_omap1510()) {
+        if (cpu_is_omap15xx()) {
                 printk(KERN_ERR "DMA scale is not supported in 1510 mode\n");
                 BUG();
         }
@@ -177,7 +177,7 @@ static void set_b1_regs(void)
                         bottom = PIXADDR(lcd_dma.xres - 1, lcd_dma.yres - 1);
                         /* 1510 DMA requires the bottom address to be 2 more
                          * than the actual last memory access location. */
-                        if (cpu_is_omap1510() &&
+                        if (cpu_is_omap15xx() &&
                                 lcd_dma.data_type == OMAP_DMA_DATA_TYPE_S32)
                                         bottom += 2;
                         ei = PIXSTEP(0, 0, 1, 0);
@@ -241,7 +241,7 @@ static void set_b1_regs(void)
                 return; /* Suppress warning about uninitialized vars */
         }
 
-        if (cpu_is_omap1510()) {
+        if (cpu_is_omap15xx()) {
                 omap_writew(top >> 16, OMAP1510_DMA_LCD_TOP_F1_U);
                 omap_writew(top, OMAP1510_DMA_LCD_TOP_F1_L);
                 omap_writew(bottom >> 16, OMAP1510_DMA_LCD_BOT_F1_U);
@@ -343,7 +343,7 @@ void omap_free_lcd_dma(void)
                 BUG();
                 return;
         }
-        if (!cpu_is_omap1510())
+        if (!cpu_is_omap15xx())
                 omap_writew(omap_readw(OMAP1610_DMA_LCD_CCR) & ~1,
                             OMAP1610_DMA_LCD_CCR);
         lcd_dma.reserved = 0;
@@ -360,7 +360,7 @@ void omap_enable_lcd_dma(void)
          * connected. Otherwise the OMAP internal controller will
          * start the transfer when it gets enabled.
          */
-        if (cpu_is_omap1510() || !lcd_dma.ext_ctrl)
+        if (cpu_is_omap15xx() || !lcd_dma.ext_ctrl)
                 return;
 
         w = omap_readw(OMAP1610_DMA_LCD_CTRL);
@@ -378,14 +378,14 @@ EXPORT_SYMBOL(omap_enable_lcd_dma);
 void omap_setup_lcd_dma(void)
 {
         BUG_ON(lcd_dma.active);
-        if (!cpu_is_omap1510()) {
+        if (!cpu_is_omap15xx()) {
                 /* Set some reasonable defaults */
                 omap_writew(0x5440, OMAP1610_DMA_LCD_CCR);
                 omap_writew(0x9102, OMAP1610_DMA_LCD_CSDP);
                 omap_writew(0x0004, OMAP1610_DMA_LCD_LCH_CTRL);
         }
         set_b1_regs();
-        if (!cpu_is_omap1510()) {
+        if (!cpu_is_omap15xx()) {
                 u16 w;
 
                 w = omap_readw(OMAP1610_DMA_LCD_CCR);
@@ -407,7 +407,7 @@ void omap_stop_lcd_dma(void)
         u16 w;
 
         lcd_dma.active = 0;
-        if (cpu_is_omap1510() || !lcd_dma.ext_ctrl)
+        if (cpu_is_omap15xx() || !lcd_dma.ext_ctrl)
                 return;
 
         w = omap_readw(OMAP1610_DMA_LCD_CCR);
@@ -424,6 +424,9 @@ static int __init omap_init_lcd_dma(void)
 {
         int r;
 
+        if (!cpu_class_is_omap1())
+                return -ENODEV;
+
         if (cpu_is_omap16xx()) {
                 u16 w;
 
diff --git a/arch/arm/mach-omap1/leds.c b/arch/arm/mach-omap1/leds.c
index 277f356d4cd0..22eb11dde9e7 100644
--- a/arch/arm/mach-omap1/leds.c
+++ b/arch/arm/mach-omap1/leds.c
@@ -17,6 +17,9 @@
 static int __init
 omap_leds_init(void)
 {
+        if (!cpu_class_is_omap1())
+                return -ENODEV;
+
         if (machine_is_omap_innovator())
                 leds_event = innovator_leds_event;
 
diff --git a/arch/arm/mach-omap1/mailbox.c b/arch/arm/mach-omap1/mailbox.c
index 1a85a421007f..c0e1f48aa119 100644
--- a/arch/arm/mach-omap1/mailbox.c
+++ b/arch/arm/mach-omap1/mailbox.c
@@ -133,19 +133,18 @@ static struct omap_mbox1_priv omap1_mbox_dsp_priv = {
         },
 };
 
-struct omap_mbox mbox_dsp_info = {
+static struct omap_mbox mbox_dsp_info = {
         .name   = "dsp",
         .ops    = &omap1_mbox_ops,
         .priv   = &omap1_mbox_dsp_priv,
 };
 
-struct omap_mbox *omap1_mboxes[] = { &mbox_dsp_info, NULL };
+static struct omap_mbox *omap1_mboxes[] = { &mbox_dsp_info, NULL };
 
 static int __devinit omap1_mbox_probe(struct platform_device *pdev)
 {
         struct resource *mem;
         int ret;
-        int i;
         struct omap_mbox **list;
 
         list = omap1_mboxes;
diff --git a/arch/arm/mach-omap1/mcbsp.c b/arch/arm/mach-omap1/mcbsp.c
index b3a796a6da03..d9af9811dedd 100644
--- a/arch/arm/mach-omap1/mcbsp.c
+++ b/arch/arm/mach-omap1/mcbsp.c
@@ -10,6 +10,7 @@
  *
  * Multichannel mode not supported.
  */
+#include <linux/ioport.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/clk.h>
@@ -78,114 +79,307 @@ static struct omap_mcbsp_ops omap1_mcbsp_ops = {
 };
 
 #if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+struct resource omap7xx_mcbsp_res[][6] = {
+        {
+                {
+                        .start = OMAP7XX_MCBSP1_BASE,
+                        .end   = OMAP7XX_MCBSP1_BASE + SZ_256,
+                        .flags = IORESOURCE_MEM,
+                },
+                {
+                        .name  = "rx",
+                        .start = INT_7XX_McBSP1RX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "tx",
+                        .start = INT_7XX_McBSP1TX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "rx",
+                        .start = OMAP_DMA_MCBSP1_RX,
+                        .flags = IORESOURCE_DMA,
+                },
+                {
+                        .name  = "tx",
+                        .start = OMAP_DMA_MCBSP1_TX,
+                        .flags = IORESOURCE_DMA,
+                },
+        },
+        {
+                {
+                        .start = OMAP7XX_MCBSP2_BASE,
+                        .end   = OMAP7XX_MCBSP2_BASE + SZ_256,
+                        .flags = IORESOURCE_MEM,
+                },
+                {
+                        .name  = "rx",
+                        .start = INT_7XX_McBSP2RX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "tx",
+                        .start = INT_7XX_McBSP2TX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "rx",
+                        .start = OMAP_DMA_MCBSP3_RX,
+                        .flags = IORESOURCE_DMA,
+                },
+                {
+                        .name  = "tx",
+                        .start = OMAP_DMA_MCBSP3_TX,
+                        .flags = IORESOURCE_DMA,
+                },
+        },
+};
+
+#define omap7xx_mcbsp_res_0             omap7xx_mcbsp_res[0]
+
 static struct omap_mcbsp_platform_data omap7xx_mcbsp_pdata[] = {
         {
-                .phys_base      = OMAP7XX_MCBSP1_BASE,
-                .dma_rx_sync    = OMAP_DMA_MCBSP1_RX,
-                .dma_tx_sync    = OMAP_DMA_MCBSP1_TX,
-                .rx_irq         = INT_7XX_McBSP1RX,
-                .tx_irq         = INT_7XX_McBSP1TX,
                 .ops            = &omap1_mcbsp_ops,
         },
         {
-                .phys_base      = OMAP7XX_MCBSP2_BASE,
-                .dma_rx_sync    = OMAP_DMA_MCBSP3_RX,
-                .dma_tx_sync    = OMAP_DMA_MCBSP3_TX,
-                .rx_irq         = INT_7XX_McBSP2RX,
-                .tx_irq         = INT_7XX_McBSP2TX,
                 .ops            = &omap1_mcbsp_ops,
         },
 };
-#define OMAP7XX_MCBSP_PDATA_SZ          ARRAY_SIZE(omap7xx_mcbsp_pdata)
-#define OMAP7XX_MCBSP_REG_NUM           (OMAP_MCBSP_REG_XCERH / sizeof(u16) + 1)
+#define OMAP7XX_MCBSP_RES_SZ            ARRAY_SIZE(omap7xx_mcbsp_res[1])
+#define OMAP7XX_MCBSP_COUNT             ARRAY_SIZE(omap7xx_mcbsp_res)
 #else
+#define omap7xx_mcbsp_res_0             NULL
 #define omap7xx_mcbsp_pdata             NULL
-#define OMAP7XX_MCBSP_PDATA_SZ          0
-#define OMAP7XX_MCBSP_REG_NUM           0
+#define OMAP7XX_MCBSP_RES_SZ            0
+#define OMAP7XX_MCBSP_COUNT             0
 #endif
 
 #ifdef CONFIG_ARCH_OMAP15XX
+struct resource omap15xx_mcbsp_res[][6] = {
+        {
+                {
+                        .start = OMAP1510_MCBSP1_BASE,
+                        .end   = OMAP1510_MCBSP1_BASE + SZ_256,
+                        .flags = IORESOURCE_MEM,
+                },
+                {
+                        .name  = "rx",
+                        .start = INT_McBSP1RX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "tx",
+                        .start = INT_McBSP1TX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "rx",
+                        .start = OMAP_DMA_MCBSP1_RX,
+                        .flags = IORESOURCE_DMA,
+                },
+                {
+                        .name  = "tx",
+                        .start = OMAP_DMA_MCBSP1_TX,
+                        .flags = IORESOURCE_DMA,
+                },
+        },
+        {
+                {
+                        .start = OMAP1510_MCBSP2_BASE,
+                        .end   = OMAP1510_MCBSP2_BASE + SZ_256,
+                        .flags = IORESOURCE_MEM,
+                },
+                {
+                        .name  = "rx",
+                        .start = INT_1510_SPI_RX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "tx",
+                        .start = INT_1510_SPI_TX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "rx",
+                        .start = OMAP_DMA_MCBSP2_RX,
+                        .flags = IORESOURCE_DMA,
+                },
+                {
+                        .name  = "tx",
+                        .start = OMAP_DMA_MCBSP2_TX,
+                        .flags = IORESOURCE_DMA,
+                },
+        },
+        {
+                {
+                        .start = OMAP1510_MCBSP3_BASE,
+                        .end   = OMAP1510_MCBSP3_BASE + SZ_256,
+                        .flags = IORESOURCE_MEM,
+                },
+                {
+                        .name  = "rx",
+                        .start = INT_McBSP3RX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "tx",
+                        .start = INT_McBSP3TX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "rx",
+                        .start = OMAP_DMA_MCBSP3_RX,
+                        .flags = IORESOURCE_DMA,
+                },
+                {
+                        .name  = "tx",
+                        .start = OMAP_DMA_MCBSP3_TX,
+                        .flags = IORESOURCE_DMA,
+                },
+        },
+};
+
+#define omap15xx_mcbsp_res_0            omap15xx_mcbsp_res[0]
+
 static struct omap_mcbsp_platform_data omap15xx_mcbsp_pdata[] = {
         {
-                .phys_base      = OMAP1510_MCBSP1_BASE,
-                .dma_rx_sync    = OMAP_DMA_MCBSP1_RX,
-                .dma_tx_sync    = OMAP_DMA_MCBSP1_TX,
-                .rx_irq         = INT_McBSP1RX,
-                .tx_irq         = INT_McBSP1TX,
                 .ops            = &omap1_mcbsp_ops,
         },
         {
-                .phys_base      = OMAP1510_MCBSP2_BASE,
-                .dma_rx_sync    = OMAP_DMA_MCBSP2_RX,
-                .dma_tx_sync    = OMAP_DMA_MCBSP2_TX,
-                .rx_irq         = INT_1510_SPI_RX,
-                .tx_irq         = INT_1510_SPI_TX,
                 .ops            = &omap1_mcbsp_ops,
         },
         {
-                .phys_base      = OMAP1510_MCBSP3_BASE,
-                .dma_rx_sync    = OMAP_DMA_MCBSP3_RX,
-                .dma_tx_sync    = OMAP_DMA_MCBSP3_TX,
-                .rx_irq         = INT_McBSP3RX,
-                .tx_irq         = INT_McBSP3TX,
                 .ops            = &omap1_mcbsp_ops,
         },
 };
-#define OMAP15XX_MCBSP_PDATA_SZ         ARRAY_SIZE(omap15xx_mcbsp_pdata)
-#define OMAP15XX_MCBSP_REG_NUM          (OMAP_MCBSP_REG_XCERH / sizeof(u16) + 1)
+#define OMAP15XX_MCBSP_RES_SZ           ARRAY_SIZE(omap15xx_mcbsp_res[1])
+#define OMAP15XX_MCBSP_COUNT            ARRAY_SIZE(omap15xx_mcbsp_res)
 #else
+#define omap15xx_mcbsp_res_0            NULL
 #define omap15xx_mcbsp_pdata            NULL
-#define OMAP15XX_MCBSP_PDATA_SZ         0
-#define OMAP15XX_MCBSP_REG_NUM          0
+#define OMAP15XX_MCBSP_RES_SZ           0
+#define OMAP15XX_MCBSP_COUNT            0
 #endif
 
 #ifdef CONFIG_ARCH_OMAP16XX
+struct resource omap16xx_mcbsp_res[][6] = {
+        {
+                {
+                        .start = OMAP1610_MCBSP1_BASE,
+                        .end   = OMAP1610_MCBSP1_BASE + SZ_256,
+                        .flags = IORESOURCE_MEM,
+                },
+                {
+                        .name  = "rx",
+                        .start = INT_McBSP1RX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "tx",
+                        .start = INT_McBSP1TX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "rx",
+                        .start = OMAP_DMA_MCBSP1_RX,
+                        .flags = IORESOURCE_DMA,
+                },
+                {
+                        .name  = "tx",
+                        .start = OMAP_DMA_MCBSP1_TX,
+                        .flags = IORESOURCE_DMA,
+                },
+        },
+        {
+                {
+                        .start = OMAP1610_MCBSP2_BASE,
+                        .end   = OMAP1610_MCBSP2_BASE + SZ_256,
+                        .flags = IORESOURCE_MEM,
+                },
+                {
+                        .name  = "rx",
+                        .start = INT_1610_McBSP2_RX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "tx",
+                        .start = INT_1610_McBSP2_TX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "rx",
+                        .start = OMAP_DMA_MCBSP2_RX,
+                        .flags = IORESOURCE_DMA,
+                },
+                {
+                        .name  = "tx",
+                        .start = OMAP_DMA_MCBSP2_TX,
+                        .flags = IORESOURCE_DMA,
+                },
+        },
+        {
+                {
+                        .start = OMAP1610_MCBSP3_BASE,
+                        .end   = OMAP1610_MCBSP3_BASE + SZ_256,
+                        .flags = IORESOURCE_MEM,
+                },
+                {
+                        .name  = "rx",
+                        .start = INT_McBSP3RX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "tx",
+                        .start = INT_McBSP3TX,
+                        .flags = IORESOURCE_IRQ,
+                },
+                {
+                        .name  = "rx",
+                        .start = OMAP_DMA_MCBSP3_RX,
+                        .flags = IORESOURCE_DMA,
+                },
+                {
+                        .name  = "tx",
+                        .start = OMAP_DMA_MCBSP3_TX,
+                        .flags = IORESOURCE_DMA,
+                },
+        },
+};
+
+#define omap16xx_mcbsp_res_0            omap16xx_mcbsp_res[0]
+
 static struct omap_mcbsp_platform_data omap16xx_mcbsp_pdata[] = {
         {
-                .phys_base      = OMAP1610_MCBSP1_BASE,
-                .dma_rx_sync    = OMAP_DMA_MCBSP1_RX,
-                .dma_tx_sync    = OMAP_DMA_MCBSP1_TX,
-                .rx_irq         = INT_McBSP1RX,
-                .tx_irq         = INT_McBSP1TX,
                 .ops            = &omap1_mcbsp_ops,
         },
         {
-                .phys_base      = OMAP1610_MCBSP2_BASE,
-                .dma_rx_sync    = OMAP_DMA_MCBSP2_RX,
-                .dma_tx_sync    = OMAP_DMA_MCBSP2_TX,
-                .rx_irq         = INT_1610_McBSP2_RX,
-                .tx_irq         = INT_1610_McBSP2_TX,
                 .ops            = &omap1_mcbsp_ops,
         },
         {
-                .phys_base      = OMAP1610_MCBSP3_BASE,
-                .dma_rx_sync    = OMAP_DMA_MCBSP3_RX,
-                .dma_tx_sync    = OMAP_DMA_MCBSP3_TX,
-                .rx_irq         = INT_McBSP3RX,
-                .tx_irq         = INT_McBSP3TX,
                 .ops            = &omap1_mcbsp_ops,
         },
 };
-#define OMAP16XX_MCBSP_PDATA_SZ         ARRAY_SIZE(omap16xx_mcbsp_pdata)
-#define OMAP16XX_MCBSP_REG_NUM          (OMAP_MCBSP_REG_XCERH / sizeof(u16) + 1)
+#define OMAP16XX_MCBSP_RES_SZ           ARRAY_SIZE(omap16xx_mcbsp_res[1])
+#define OMAP16XX_MCBSP_COUNT            ARRAY_SIZE(omap16xx_mcbsp_res)
 #else
+#define omap16xx_mcbsp_res_0            NULL
 #define omap16xx_mcbsp_pdata            NULL
-#define OMAP16XX_MCBSP_PDATA_SZ         0
-#define OMAP16XX_MCBSP_REG_NUM          0
+#define OMAP16XX_MCBSP_RES_SZ           0
+#define OMAP16XX_MCBSP_COUNT            0
 #endif
 
-int __init omap1_mcbsp_init(void)
+static int __init omap1_mcbsp_init(void)
 {
-        if (cpu_is_omap7xx()) {
-                omap_mcbsp_count = OMAP7XX_MCBSP_PDATA_SZ;
-                omap_mcbsp_cache_size = OMAP7XX_MCBSP_REG_NUM * sizeof(u16);
-        } else if (cpu_is_omap15xx()) {
-                omap_mcbsp_count = OMAP15XX_MCBSP_PDATA_SZ;
-                omap_mcbsp_cache_size = OMAP15XX_MCBSP_REG_NUM * sizeof(u16);
-        } else if (cpu_is_omap16xx()) {
-                omap_mcbsp_count = OMAP16XX_MCBSP_PDATA_SZ;
-                omap_mcbsp_cache_size = OMAP16XX_MCBSP_REG_NUM * sizeof(u16);
-        }
+        if (!cpu_class_is_omap1())
+                return -ENODEV;
+
+        if (cpu_is_omap7xx())
+                omap_mcbsp_count = OMAP7XX_MCBSP_COUNT;
+        else if (cpu_is_omap15xx())
+                omap_mcbsp_count = OMAP15XX_MCBSP_COUNT;
+        else if (cpu_is_omap16xx())
+                omap_mcbsp_count = OMAP16XX_MCBSP_COUNT;
 
         mcbsp_ptr = kzalloc(omap_mcbsp_count * sizeof(struct omap_mcbsp *),
                                                                 GFP_KERNEL);
@@ -193,16 +387,22 @@ int __init omap1_mcbsp_init(void)
                 return -ENOMEM;
 
         if (cpu_is_omap7xx())
-                omap_mcbsp_register_board_cfg(omap7xx_mcbsp_pdata,
-                                                OMAP7XX_MCBSP_PDATA_SZ);
+                omap_mcbsp_register_board_cfg(omap7xx_mcbsp_res_0,
+                                        OMAP7XX_MCBSP_RES_SZ,
+                                        omap7xx_mcbsp_pdata,
+                                        OMAP7XX_MCBSP_COUNT);
 
         if (cpu_is_omap15xx())
-                omap_mcbsp_register_board_cfg(omap15xx_mcbsp_pdata,
-                                                OMAP15XX_MCBSP_PDATA_SZ);
+                omap_mcbsp_register_board_cfg(omap15xx_mcbsp_res_0,
+                                        OMAP15XX_MCBSP_RES_SZ,
+                                        omap15xx_mcbsp_pdata,
+                                        OMAP15XX_MCBSP_COUNT);
 
         if (cpu_is_omap16xx())
-                omap_mcbsp_register_board_cfg(omap16xx_mcbsp_pdata,
-                                                OMAP16XX_MCBSP_PDATA_SZ);
+                omap_mcbsp_register_board_cfg(omap16xx_mcbsp_res_0,
+                                        OMAP16XX_MCBSP_RES_SZ,
+                                        omap16xx_mcbsp_pdata,
+                                        OMAP16XX_MCBSP_COUNT);
 
         return omap_mcbsp_init();
 }
diff --git a/arch/arm/mach-omap1/mux.c b/arch/arm/mach-omap1/mux.c
index 7835add00344..5fdef7a34828 100644
--- a/arch/arm/mach-omap1/mux.c
+++ b/arch/arm/mach-omap1/mux.c
@@ -343,7 +343,7 @@ MUX_CFG("Y14_1610_CCP_DATAM",	 9,   21,    6,   2,   3,   1,    2,     0,  0)
 #define OMAP1XXX_PINS_SZ        0
 #endif  /* CONFIG_ARCH_OMAP15XX || CONFIG_ARCH_OMAP16XX */
 
-int __init_or_module omap1_cfg_reg(const struct pin_config *cfg)
+static int __init_or_module omap1_cfg_reg(const struct pin_config *cfg)
 {
         static DEFINE_SPINLOCK(mux_spin_lock);
         unsigned long flags;
diff --git a/arch/arm/mach-omap1/pm.c b/arch/arm/mach-omap1/pm.c
index b1d3f9fade23..98ba9784aa15 100644
--- a/arch/arm/mach-omap1/pm.c
+++ b/arch/arm/mach-omap1/pm.c
@@ -647,7 +647,7 @@ static struct irqaction omap_wakeup_irq = {
 
 
 
-static struct platform_suspend_ops omap_pm_ops ={
+static const struct platform_suspend_ops omap_pm_ops = {
         .prepare        = omap_pm_prepare,
         .enter          = omap_pm_enter,
         .finish         = omap_pm_finish,
@@ -661,6 +661,9 @@ static int __init omap_pm_init(void)
         int error;
 #endif
 
+        if (!cpu_class_is_omap1())
+                return -ENODEV;
+
         printk("Power Management for TI OMAP.\n");
 
         /*
diff --git a/arch/arm/mach-omap1/pm.h b/arch/arm/mach-omap1/pm.h
index 56a647986ae9..cd926dcb5e7f 100644
--- a/arch/arm/mach-omap1/pm.h
+++ b/arch/arm/mach-omap1/pm.h
@@ -123,9 +123,9 @@ extern void allow_idle_sleep(void);
 extern void omap1_pm_idle(void);
 extern void omap1_pm_suspend(void);
 
-extern void omap7xx_cpu_suspend(unsigned short, unsigned short);
-extern void omap1510_cpu_suspend(unsigned short, unsigned short);
-extern void omap1610_cpu_suspend(unsigned short, unsigned short);
+extern void omap7xx_cpu_suspend(unsigned long, unsigned long);
+extern void omap1510_cpu_suspend(unsigned long, unsigned long);
+extern void omap1610_cpu_suspend(unsigned long, unsigned long);
 extern void omap7xx_idle_loop_suspend(void);
 extern void omap1510_idle_loop_suspend(void);
 extern void omap1610_idle_loop_suspend(void);
diff --git a/arch/arm/mach-omap1/pm_bus.c b/arch/arm/mach-omap1/pm_bus.c
new file mode 100644
index 000000000000..334fb8871bc3
--- /dev/null
+++ b/arch/arm/mach-omap1/pm_bus.c
@@ -0,0 +1,79 @@
+/*
+ * Runtime PM support code for OMAP1
+ *
+ * Author: Kevin Hilman, Deep Root Systems, LLC
+ *
+ * Copyright (C) 2010 Texas Instruments, Inc.
+ *
+ * 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 <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/io.h>
+#include <linux/pm_runtime.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+
+#include <plat/omap_device.h>
+#include <plat/omap-pm.h>
+
+#ifdef CONFIG_PM_RUNTIME
+static int omap1_pm_runtime_suspend(struct device *dev)
+{
+        int ret;
+
+        dev_dbg(dev, "%s\n", __func__);
+
+        ret = pm_generic_runtime_suspend(dev);
+        if (ret)
+                return ret;
+
+        ret = pm_runtime_clk_suspend(dev);
+        if (ret) {
+                pm_generic_runtime_resume(dev);
+                return ret;
+        }
+
+        return 0;
+}
+
+static int omap1_pm_runtime_resume(struct device *dev)
+{
+        dev_dbg(dev, "%s\n", __func__);
+
+        pm_runtime_clk_resume(dev);
+        return pm_generic_runtime_resume(dev);
+}
+
+static struct dev_power_domain default_power_domain = {
+        .ops = {
+                .runtime_suspend = omap1_pm_runtime_suspend,
+                .runtime_resume = omap1_pm_runtime_resume,
+                USE_PLATFORM_PM_SLEEP_OPS
+        },
+};
+#define OMAP1_PWR_DOMAIN (&default_power_domain)
+#else
+#define OMAP1_PWR_DOMAIN NULL
+#endif /* CONFIG_PM_RUNTIME */
+
+static struct pm_clk_notifier_block platform_bus_notifier = {
+        .pwr_domain = OMAP1_PWR_DOMAIN,
+        .con_ids = { "ick", "fck", NULL, },
+};
+
+static int __init omap1_pm_runtime_init(void)
+{
+        if (!cpu_class_is_omap1())
+                return -ENODEV;
+
+        pm_runtime_clk_add_notifier(&platform_bus_type, &platform_bus_notifier);
+
+        return 0;
+}
+core_initcall(omap1_pm_runtime_init);
+
diff --git a/arch/arm/mach-omap1/reset.c b/arch/arm/mach-omap1/reset.c
new file mode 100644
index 000000000000..ad951ee69205
--- /dev/null
+++ b/arch/arm/mach-omap1/reset.c
@@ -0,0 +1,25 @@
+/*
+ * OMAP1 reset support
+ */
+#include <linux/kernel.h>
+#include <linux/io.h>
+
+#include <mach/hardware.h>
+#include <mach/system.h>
+#include <plat/prcm.h>
+
+void omap1_arch_reset(char mode, const char *cmd)
+{
+        /*
+         * Workaround for 5912/1611b bug mentioned in sprz209d.pdf p. 28
+         * "Global Software Reset Affects Traffic Controller Frequency".
+         */
+        if (cpu_is_omap5912()) {
+                omap_writew(omap_readw(DPLL_CTL) & ~(1 << 4), DPLL_CTL);
+                omap_writew(0x8, ARM_RSTCT1);
+        }
+
+        omap_writew(1, ARM_RSTCT1);
+}
+
+void (*arch_reset)(char, const char *) = omap1_arch_reset;
diff --git a/arch/arm/mach-omap1/serial.c b/arch/arm/mach-omap1/serial.c
index b78d0749f13d..550ca9d9991d 100644
--- a/arch/arm/mach-omap1/serial.c
+++ b/arch/arm/mach-omap1/serial.c
@@ -27,6 +27,8 @@
 #include <mach/gpio.h>
 #include <plat/fpga.h>
 
+#include "pm.h"
+
 static struct clk * uart1_ck;
 static struct clk * uart2_ck;
 static struct clk * uart3_ck;
@@ -52,9 +54,11 @@ static inline void omap_serial_outp(struct plat_serial8250_port *p, int offset,
  */
 static void __init omap_serial_reset(struct plat_serial8250_port *p)
 {
-        omap_serial_outp(p, UART_OMAP_MDR1, 0x07);      /* disable UART */
+        omap_serial_outp(p, UART_OMAP_MDR1,
+                        UART_OMAP_MDR1_DISABLE);        /* disable UART */
         omap_serial_outp(p, UART_OMAP_SCR, 0x08);       /* TX watermark */
-        omap_serial_outp(p, UART_OMAP_MDR1, 0x00);      /* enable UART */
+        omap_serial_outp(p, UART_OMAP_MDR1,
+                        UART_OMAP_MDR1_16X_MODE);       /* enable UART */
 
         if (!cpu_is_omap15xx()) {
                 omap_serial_outp(p, UART_OMAP_SYSC, 0x01);
@@ -254,6 +258,9 @@ late_initcall(omap_serial_wakeup_init);
 
 static int __init omap_init(void)
 {
+        if (!cpu_class_is_omap1())
+                return -ENODEV;
+
         return platform_device_register(&serial_device);
 }
 arch_initcall(omap_init);
diff --git a/arch/arm/mach-omap1/sleep.S b/arch/arm/mach-omap1/sleep.S
index ef771ce8b030..c875bdc902c5 100644
--- a/arch/arm/mach-omap1/sleep.S
+++ b/arch/arm/mach-omap1/sleep.S
@@ -58,6 +58,7 @@
  */
 
 #if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        .align  3
 ENTRY(omap7xx_cpu_suspend)
 
         @ save registers on stack
@@ -137,6 +138,7 @@ ENTRY(omap7xx_cpu_suspend_sz)
 #endif /* CONFIG_ARCH_OMAP730 || CONFIG_ARCH_OMAP850 */
 
 #ifdef CONFIG_ARCH_OMAP15XX
+        .align  3
 ENTRY(omap1510_cpu_suspend)
 
         @ save registers on stack
@@ -211,6 +213,7 @@ ENTRY(omap1510_cpu_suspend_sz)
 #endif /* CONFIG_ARCH_OMAP15XX */
 
 #if defined(CONFIG_ARCH_OMAP16XX)
+        .align  3
 ENTRY(omap1610_cpu_suspend)
 
         @ save registers on stack
diff --git a/arch/arm/mach-omap1/sram.S b/arch/arm/mach-omap1/sram.S
index 7724e520d07c..692587d07ea5 100644
--- a/arch/arm/mach-omap1/sram.S
+++ b/arch/arm/mach-omap1/sram.S
@@ -18,6 +18,7 @@
 /*
  * Reprograms ULPD and CKCTL.
  */
+        .align  3
 ENTRY(omap1_sram_reprogram_clock)
         stmfd   sp!, {r0 - r12, lr}             @ save registers on stack
 
diff --git a/arch/arm/mach-omap1/time.c b/arch/arm/mach-omap1/time.c
index 1be6a214d88d..03e1e1062ad4 100644
--- a/arch/arm/mach-omap1/time.c
+++ b/arch/arm/mach-omap1/time.c
@@ -49,9 +49,14 @@
 #include <mach/hardware.h>
 #include <asm/leds.h>
 #include <asm/irq.h>
+#include <asm/sched_clock.h>
+
 #include <asm/mach/irq.h>
 #include <asm/mach/time.h>
 
+#include <plat/common.h>
+
+#ifdef CONFIG_OMAP_MPU_TIMER
 
 #define OMAP_MPU_TIMER_BASE             OMAP_MPU_TIMER1_BASE
 #define OMAP_MPU_TIMER_OFFSET           0x100
@@ -63,49 +68,50 @@ typedef struct {
 } omap_mpu_timer_regs_t;
 
 #define omap_mpu_timer_base(n)                                                  \
-((volatile omap_mpu_timer_regs_t*)OMAP1_IO_ADDRESS(OMAP_MPU_TIMER_BASE +        \
+((omap_mpu_timer_regs_t __iomem *)OMAP1_IO_ADDRESS(OMAP_MPU_TIMER_BASE +        \
                                  (n)*OMAP_MPU_TIMER_OFFSET))
 
-static inline unsigned long omap_mpu_timer_read(int nr)
+static inline unsigned long notrace omap_mpu_timer_read(int nr)
 {
-        volatile omap_mpu_timer_regs_t* timer = omap_mpu_timer_base(nr);
-        return timer->read_tim;
+        omap_mpu_timer_regs_t __iomem *timer = omap_mpu_timer_base(nr);
+        return readl(&timer->read_tim);
 }
 
 static inline void omap_mpu_set_autoreset(int nr)
 {
-        volatile omap_mpu_timer_regs_t* timer = omap_mpu_timer_base(nr);
+        omap_mpu_timer_regs_t __iomem *timer = omap_mpu_timer_base(nr);
 
-        timer->cntl = timer->cntl | MPU_TIMER_AR;
+        writel(readl(&timer->cntl) | MPU_TIMER_AR, &timer->cntl);
 }
 
 static inline void omap_mpu_remove_autoreset(int nr)
 {
-        volatile omap_mpu_timer_regs_t* timer = omap_mpu_timer_base(nr);
+        omap_mpu_timer_regs_t __iomem *timer = omap_mpu_timer_base(nr);
 
-        timer->cntl = timer->cntl & ~MPU_TIMER_AR;
+        writel(readl(&timer->cntl) & ~MPU_TIMER_AR, &timer->cntl);
 }
 
 static inline void omap_mpu_timer_start(int nr, unsigned long load_val,
                                         int autoreset)
 {
-        volatile omap_mpu_timer_regs_t* timer = omap_mpu_timer_base(nr);
-        unsigned int timerflags = (MPU_TIMER_CLOCK_ENABLE | MPU_TIMER_ST);
+        omap_mpu_timer_regs_t __iomem *timer = omap_mpu_timer_base(nr);
+        unsigned int timerflags = MPU_TIMER_CLOCK_ENABLE | MPU_TIMER_ST;
 
-        if (autoreset) timerflags |= MPU_TIMER_AR;
+        if (autoreset)
+                timerflags |= MPU_TIMER_AR;
 
-        timer->cntl = MPU_TIMER_CLOCK_ENABLE;
+        writel(MPU_TIMER_CLOCK_ENABLE, &timer->cntl);
         udelay(1);
-        timer->load_tim = load_val;
+        writel(load_val, &timer->load_tim);
         udelay(1);
-        timer->cntl = timerflags;
+        writel(timerflags, &timer->cntl);
 }
 
 static inline void omap_mpu_timer_stop(int nr)
 {
-        volatile omap_mpu_timer_regs_t* timer = omap_mpu_timer_base(nr);
+        omap_mpu_timer_regs_t __iomem *timer = omap_mpu_timer_base(nr);
 
-        timer->cntl &= ~MPU_TIMER_ST;
+        writel(readl(&timer->cntl) & ~MPU_TIMER_ST, &timer->cntl);
 }
 
 /*
@@ -184,55 +190,47 @@ static __init void omap_init_mpu_timer(unsigned long rate)
  * ---------------------------------------------------------------------------
  */
 
-static unsigned long omap_mpu_timer2_overflows;
+static DEFINE_CLOCK_DATA(cd);
 
-static irqreturn_t omap_mpu_timer2_interrupt(int irq, void *dev_id)
+static inline unsigned long long notrace _omap_mpu_sched_clock(void)
 {
-        omap_mpu_timer2_overflows++;
-        return IRQ_HANDLED;
+        u32 cyc = ~omap_mpu_timer_read(1);
+        return cyc_to_sched_clock(&cd, cyc, (u32)~0);
 }
 
-static struct irqaction omap_mpu_timer2_irq = {
-        .name           = "mpu_timer2",
-        .flags          = IRQF_DISABLED,
-        .handler        = omap_mpu_timer2_interrupt,
-};
-
-static cycle_t mpu_read(struct clocksource *cs)
+#ifndef CONFIG_OMAP_32K_TIMER
+unsigned long long notrace sched_clock(void)
+{
+        return _omap_mpu_sched_clock();
+}
+#else
+static unsigned long long notrace omap_mpu_sched_clock(void)
 {
-        return ~omap_mpu_timer_read(1);
+        return _omap_mpu_sched_clock();
 }
+#endif
 
-static struct clocksource clocksource_mpu = {
-        .name           = "mpu_timer2",
-        .rating         = 300,
-        .read           = mpu_read,
-        .mask           = CLOCKSOURCE_MASK(32),
-        .shift          = 24,
-        .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
-};
+static void notrace mpu_update_sched_clock(void)
+{
+        u32 cyc = ~omap_mpu_timer_read(1);
+        update_sched_clock(&cd, cyc, (u32)~0);
+}
 
 static void __init omap_init_clocksource(unsigned long rate)
 {
+        omap_mpu_timer_regs_t __iomem *timer = omap_mpu_timer_base(1);
         static char err[] __initdata = KERN_ERR
                         "%s: can't register clocksource!\n";
 
-        clocksource_mpu.mult
-                = clocksource_khz2mult(rate/1000, clocksource_mpu.shift);
-
-        setup_irq(INT_TIMER2, &omap_mpu_timer2_irq);
         omap_mpu_timer_start(1, ~0, 1);
+        init_sched_clock(&cd, mpu_update_sched_clock, 32, rate);
 
-        if (clocksource_register(&clocksource_mpu))
-                printk(err, clocksource_mpu.name);
+        if (clocksource_mmio_init(&timer->read_tim, "mpu_timer2", rate,
+                        300, 32, clocksource_mmio_readl_down))
+                printk(err, "mpu_timer2");
 }
 
-/*
- * ---------------------------------------------------------------------------
- * Timer initialization
- * ---------------------------------------------------------------------------
- */
-static void __init omap_timer_init(void)
+static void __init omap_mpu_timer_init(void)
 {
         struct clk      *ck_ref = clk_get(NULL, "ck_ref");
         unsigned long   rate;
@@ -249,6 +247,66 @@ static void __init omap_timer_init(void)
         omap_init_clocksource(rate);
 }
 
+#else
+static inline void omap_mpu_timer_init(void)
+{
+        pr_err("Bogus timer, should not happen\n");
+}
+#endif  /* CONFIG_OMAP_MPU_TIMER */
+
+#if defined(CONFIG_OMAP_MPU_TIMER) && defined(CONFIG_OMAP_32K_TIMER)
+static unsigned long long (*preferred_sched_clock)(void);
+
+unsigned long long notrace sched_clock(void)
+{
+        if (!preferred_sched_clock)
+                return 0;
+
+        return preferred_sched_clock();
+}
+
+static inline void preferred_sched_clock_init(bool use_32k_sched_clock)
+{
+        if (use_32k_sched_clock)
+                preferred_sched_clock = omap_32k_sched_clock;
+        else
+                preferred_sched_clock = omap_mpu_sched_clock;
+}
+#else
+static inline void preferred_sched_clock_init(bool use_32k_sched_clcok)
+{
+}
+#endif
+
+static inline int omap_32k_timer_usable(void)
+{
+        int res = false;
+
+        if (cpu_is_omap730() || cpu_is_omap15xx())
+                return res;
+
+#ifdef CONFIG_OMAP_32K_TIMER
+        res = omap_32k_timer_init();
+#endif
+
+        return res;
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * Timer initialization
+ * ---------------------------------------------------------------------------
+ */
+static void __init omap_timer_init(void)
+{
+        if (omap_32k_timer_usable()) {
+                preferred_sched_clock_init(1);
+        } else {
+                omap_mpu_timer_init();
+                preferred_sched_clock_init(0);
+        }
+}
+
 struct sys_timer omap_timer = {
         .init           = omap_timer_init,
 };
diff --git a/arch/arm/mach-omap1/timer32k.c b/arch/arm/mach-omap1/timer32k.c
index 20cfbcc6c60c..13d7b8f145bd 100644
--- a/arch/arm/mach-omap1/timer32k.c
+++ b/arch/arm/mach-omap1/timer32k.c
@@ -52,10 +52,9 @@
 #include <asm/irq.h>
 #include <asm/mach/irq.h>
 #include <asm/mach/time.h>
+#include <plat/common.h>
 #include <plat/dmtimer.h>
 
-struct sys_timer omap_timer;
-
 /*
  * ---------------------------------------------------------------------------
  * 32KHz OS timer
@@ -181,14 +180,14 @@ static __init void omap_init_32k_timer(void)
  * Timer initialization
  * ---------------------------------------------------------------------------
  */
-static void __init omap_timer_init(void)
+bool __init omap_32k_timer_init(void)
 {
+        omap_init_clocksource_32k();
+
 #ifdef CONFIG_OMAP_DM_TIMER
         omap_dm_timer_init();
 #endif
         omap_init_32k_timer();
-}
 
-struct sys_timer omap_timer = {
-        .init           = omap_timer_init,
-};
+        return true;
+}