#ifndef __ASM_HARDWARE_IT8152_H
 #define __ASM_HARDWARE_IT8152_H
-extern unsigned long it8152_base_address;
+extern void __iomem *it8152_base_address;
 
 #define IT8152_IO_BASE                 (it8152_base_address + 0x03e00000)
 #define IT8152_CFGREG_BASE             (it8152_base_address + 0x03f00000)
 
 
 #define APBC_CLK(_name, _reg, _fnclksel, _rate)                        \
 struct clk clk_##_name = {                                     \
-               .clk_rst        = (void __iomem *)APBC_##_reg,  \
+               .clk_rst        = APBC_##_reg,                  \
                .fnclksel       = _fnclksel,                    \
                .rate           = _rate,                        \
                .ops            = &apbc_clk_ops,                \
 
 #define APBC_CLK_OPS(_name, _reg, _fnclksel, _rate, _ops)      \
 struct clk clk_##_name = {                                     \
-               .clk_rst        = (void __iomem *)APBC_##_reg,  \
+               .clk_rst        = APBC_##_reg,                  \
                .fnclksel       = _fnclksel,                    \
                .rate           = _rate,                        \
                .ops            = _ops,                         \
 
 #define APMU_CLK(_name, _reg, _eval, _rate)                    \
 struct clk clk_##_name = {                                     \
-               .clk_rst        = (void __iomem *)APMU_##_reg,  \
+               .clk_rst        = APMU_##_reg,                  \
                .enable_val     = _eval,                        \
                .rate           = _rate,                        \
                .ops            = &apmu_clk_ops,                \
 
 #define APMU_CLK_OPS(_name, _reg, _eval, _rate, _ops)          \
 struct clk clk_##_name = {                                     \
-               .clk_rst        = (void __iomem *)APMU_##_reg,  \
+               .clk_rst        = APMU_##_reg,                  \
                .enable_val     = _eval,                        \
                .rate           = _rate,                        \
                .ops            = _ops,                         \
 
 static struct map_desc standard_io_desc[] __initdata = {
        {
                .pfn            = __phys_to_pfn(APB_PHYS_BASE),
-               .virtual        = APB_VIRT_BASE,
+               .virtual        = (unsigned long)APB_VIRT_BASE,
                .length         = APB_PHYS_SIZE,
                .type           = MT_DEVICE,
        }, {
                .pfn            = __phys_to_pfn(AXI_PHYS_BASE),
-               .virtual        = AXI_VIRT_BASE,
+               .virtual        = (unsigned long)AXI_VIRT_BASE,
                .length         = AXI_PHYS_SIZE,
                .type           = MT_DEVICE,
        },
 
 #ifndef __ASM_MACH_ADDR_MAP_H
 #define __ASM_MACH_ADDR_MAP_H
 
+#ifndef __ASSEMBLER__
+#define IOMEM(x)       ((void __iomem *)(x))
+#else
+#define IOMEM(x)       (x)
+#endif
+
 /* APB - Application Subsystem Peripheral Bus
  *
  * NOTE: the DMA controller registers are actually on the AXI fabric #1
  * peripherals on APB, let's count it into the ABP mapping area.
  */
 #define APB_PHYS_BASE          0xd4000000
-#define APB_VIRT_BASE          0xfe000000
+#define APB_VIRT_BASE          IOMEM(0xfe000000)
 #define APB_PHYS_SIZE          0x00200000
 
 #define AXI_PHYS_BASE          0xd4200000
-#define AXI_VIRT_BASE          0xfe200000
+#define AXI_VIRT_BASE          IOMEM(0xfe200000)
 #define AXI_PHYS_SIZE          0x00200000
 
 /* Static Memory Controller - Chip Select 0 and 1 */
 
 
 void mmp2_clear_pmic_int(void)
 {
-       unsigned long mfpr_pmic, data;
+       void __iomem *mfpr_pmic;
+       unsigned long data;
 
        mfpr_pmic = APB_VIRT_BASE + 0x1e000 + 0x2c4;
        data = __raw_readl(mfpr_pmic);
 
                                BALLOON3_NAND_CONTROL_REG);
                if (balloon3_ctl_set)
                        __raw_writel(balloon3_ctl_set,
-                               BALLOON3_NAND_CONTROL_REG |
+                               BALLOON3_NAND_CONTROL_REG +
                                BALLOON3_FPGA_SETnCLR);
        }
 
        __raw_writew(
                BALLOON3_NAND_CONTROL_FLCE0 | BALLOON3_NAND_CONTROL_FLCE1 |
                BALLOON3_NAND_CONTROL_FLCE2 | BALLOON3_NAND_CONTROL_FLCE3,
-               BALLOON3_NAND_CONTROL_REG | BALLOON3_FPGA_SETnCLR);
+               BALLOON3_NAND_CONTROL_REG + BALLOON3_FPGA_SETnCLR);
 
        /* Deassert correct nCE line */
        __raw_writew(BALLOON3_NAND_CONTROL_FLCE0 << chip,
        int ret;
 
        __raw_writew(BALLOON3_NAND_CONTROL2_16BIT,
-               BALLOON3_NAND_CONTROL2_REG | BALLOON3_FPGA_SETnCLR);
+               BALLOON3_NAND_CONTROL2_REG + BALLOON3_FPGA_SETnCLR);
 
        ver = __raw_readw(BALLOON3_FPGA_VER);
        if (ver < 0x4f08)
                BALLOON3_NAND_CONTROL_FLCE0 | BALLOON3_NAND_CONTROL_FLCE1 |
                BALLOON3_NAND_CONTROL_FLCE2 | BALLOON3_NAND_CONTROL_FLCE3 |
                BALLOON3_NAND_CONTROL_FLWP,
-               BALLOON3_NAND_CONTROL_REG | BALLOON3_FPGA_SETnCLR);
+               BALLOON3_NAND_CONTROL_REG + BALLOON3_FPGA_SETnCLR);
        return 0;
 
 err2:
 
 static struct map_desc balloon3_io_desc[] __initdata = {
        {       /* CPLD/FPGA */
-               .virtual        =  BALLOON3_FPGA_VIRT,
+               .virtual        = (unsigned long)BALLOON3_FPGA_VIRT,
                .pfn            = __phys_to_pfn(BALLOON3_FPGA_PHYS),
                .length         = BALLOON3_FPGA_LENGTH,
                .type           = MT_DEVICE,
 
 
 #include <asm/hardware/it8152.h>
 
-unsigned long it8152_base_address;
+void __iomem *it8152_base_address;
 static int cmx2xx_it8152_irq_gpio;
 
 static void cmx2xx_it8152_irq_demux(unsigned int irq, struct irq_desc *desc)
 
 #define CMX2XX_NR_IRQS         (IRQ_BOARD_START + 40)
 
 /* virtual addresses for statically mapped regions */
-#define CMX2XX_VIRT_BASE       (0xe8000000)
+#define CMX2XX_VIRT_BASE       (void __iomem *)(0xe8000000)
 #define CMX2XX_IT8152_VIRT     (CMX2XX_VIRT_BASE)
 
 /* physical address if local-bus attached devices */
 /* Map PCI companion statically */
 static struct map_desc cmx2xx_io_desc[] __initdata = {
        [0] = { /* PCI bridge */
-               .virtual        = CMX2XX_IT8152_VIRT,
+               .virtual        = (unsigned long)CMX2XX_IT8152_VIRT,
                .pfn            = __phys_to_pfn(PXA_CS4_PHYS),
                .length         = SZ_64M,
                .type           = MT_DEVICE
 
  * Peripheral Bus
  */
 #define PERIPH_PHYS            0x40000000
-#define PERIPH_VIRT            0xf2000000
+#define PERIPH_VIRT            IOMEM(0xf2000000)
 #define PERIPH_SIZE            0x02000000
 
 /*
  */
 #define PXA2XX_SMEMC_PHYS      0x48000000
 #define PXA3XX_SMEMC_PHYS      0x4a000000
-#define SMEMC_VIRT             0xf6000000
+#define SMEMC_VIRT             IOMEM(0xf6000000)
 #define SMEMC_SIZE             0x00100000
 
 /*
  * Dynamic Memory Controller (only on PXA3xx)
  */
 #define DMEMC_PHYS             0x48100000
-#define DMEMC_VIRT             0xf6100000
+#define DMEMC_VIRT             IOMEM(0xf6100000)
 #define DMEMC_SIZE             0x00100000
 
 /*
  * Internal Memory Controller (PXA27x and later)
  */
 #define IMEMC_PHYS             0x58000000
-#define IMEMC_VIRT             0xfe000000
+#define IMEMC_VIRT             IOMEM(0xfe000000)
 #define IMEMC_SIZE             0x00100000
 
 #endif /* __ASM_MACH_ADDR_MAP_H */
 
 };
 
 #define BALLOON3_FPGA_PHYS     PXA_CS4_PHYS
-#define BALLOON3_FPGA_VIRT     (0xf1000000)    /* as per balloon2 */
+#define BALLOON3_FPGA_VIRT     IOMEM(0xf1000000)       /* as per balloon2 */
 #define BALLOON3_FPGA_LENGTH   0x01000000
 
 #define        BALLOON3_FPGA_SETnCLR           (0x1000)
 
  * Note that not all PXA2xx chips implement all those addresses, and the
  * kernel only maps the minimum needed range of this mapping.
  */
-#define io_p2v(x) (0xf2000000 + ((x) & 0x01ffffff) + (((x) & 0x1c000000) >> 1))
 #define io_v2p(x) (0x3c000000 + ((x) & 0x01ffffff) + (((x) & 0x0e000000) << 1))
+#define io_p2v(x) IOMEM(0xf2000000 + ((x) & 0x01ffffff) + (((x) & 0x1c000000) >> 1))
 
 #ifndef __ASSEMBLY__
-
-# define __REG(x)      (*((volatile u32 *)io_p2v(x)))
+# define IOMEM(x) ((void __iomem *)(x))
+# define __REG(x)      (*((volatile u32 __iomem *)io_p2v(x)))
 
 /* With indexed regs we don't want to feed the index through io_p2v()
    especially if it is a variable, otherwise horrible code will result. */
 # define __REG2(x,y)   \
-       (*(volatile u32 *)((u32)&__REG(x) + (y)))
+       (*(volatile u32 __iomem*)((u32)&__REG(x) + (y)))
 
 # define __PREG(x)     (io_v2p((u32)&(x)))
 
 #else
 
+# define IOMEM(x)      x 
 # define __REG(x)      io_p2v(x)
 # define __PREG(x)     io_v2p(x)
 
 
 #define __ASM_ARCH_LPD270_H
 
 #define LPD270_CPLD_PHYS       PXA_CS2_PHYS
-#define LPD270_CPLD_VIRT       0xf0000000
+#define LPD270_CPLD_VIRT       IOMEM(0xf0000000)
 #define LPD270_CPLD_SIZE       0x00100000
 
 #define LPD270_ETH_PHYS                (PXA_CS2_PHYS + 0x01000000)
 
 /* CPLD registers  */
-#define LPD270_CPLD_REG(x)     ((unsigned long)(LPD270_CPLD_VIRT + (x)))
+#define LPD270_CPLD_REG(x)     (LPD270_CPLD_VIRT + (x))
 #define LPD270_CONTROL         LPD270_CPLD_REG(0x00)
 #define LPD270_PERIPHERAL0     LPD270_CPLD_REG(0x04)
 #define LPD270_PERIPHERAL1     LPD270_CPLD_REG(0x08)
 
 #define __ARCH_PXA_MTD_XIP_H__
 
 #include <mach/regs-ost.h>
-#include <mach/regs-intc.h>
 
 #define xip_irqpending()       (ICIP & ICMR)
 
 
 
 /* Various addresses  */
 #define PALMTX_PCMCIA_PHYS     0x28000000
-#define PALMTX_PCMCIA_VIRT     0xf0000000
+#define PALMTX_PCMCIA_VIRT     IOMEM(0xf0000000)
 #define PALMTX_PCMCIA_SIZE     0x100000
 
 #define PALMTX_PHYS_RAM_START  0xa0000000
 
 #define PALMTX_NAND_ALE_PHYS   (PALMTX_PHYS_NAND_START | (1 << 24))
 #define PALMTX_NAND_CLE_PHYS   (PALMTX_PHYS_NAND_START | (1 << 25))
-#define PALMTX_NAND_ALE_VIRT   0xff100000
-#define PALMTX_NAND_CLE_VIRT   0xff200000
+#define PALMTX_NAND_ALE_VIRT   IOMEM(0xff100000)
+#define PALMTX_NAND_CLE_VIRT   IOMEM(0xff200000)
 
 /* TOUCHSCREEN */
 #define AC97_LINK_FRAME                        21
 
 
 #define PXA2XX_SMEMC_BASE      0x48000000
 #define PXA3XX_SMEMC_BASE      0x4a000000
-#define SMEMC_VIRT             0xf6000000
+#define SMEMC_VIRT             IOMEM(0xf6000000)
 
 #define MDCNFG         (SMEMC_VIRT + 0x00)  /* SDRAM Configuration Register 0 */
 #define MDREFR         (SMEMC_VIRT + 0x04)  /* SDRAM Refresh Control Register */
 
  * Be gentle, and remap that over 32kB...
  */
 
-#define ZEUS_CPLD              (0xf0000000)
+#define ZEUS_CPLD              IOMEM(0xf0000000)
 #define ZEUS_CPLD_VERSION      (ZEUS_CPLD + 0x0000)
 #define ZEUS_CPLD_ISA_IRQ      (ZEUS_CPLD + 0x1000)
 #define ZEUS_CPLD_CONTROL      (ZEUS_CPLD + 0x2000)
 /* CPLD register bits */
 #define ZEUS_CPLD_CONTROL_CF_RST        0x01
 
-#define ZEUS_PC104IO           (0xf1000000)
+#define ZEUS_PC104IO           IOMEM(0xf1000000)
 
 #define ZEUS_SRAM_SIZE         (256 * 1024)
 
 
 
 #include "generic.h"
 
-#define IRQ_BASE               (void __iomem *)io_p2v(0x40d00000)
+#define IRQ_BASE               io_p2v(0x40d00000)
 
 #define ICIP                   (0x000)
 #define ICMR                   (0x004)
                0x40d00130,
        };
 
-       return (void __iomem *)io_p2v(phys_base[i]);
+       return io_p2v(phys_base[i]);
 }
 
 void pxa_mask_irq(struct irq_data *d)
 
 
 static struct map_desc lpd270_io_desc[] __initdata = {
        {
-               .virtual        = LPD270_CPLD_VIRT,
+               .virtual        = (unsigned long)LPD270_CPLD_VIRT,
                .pfn            = __phys_to_pfn(LPD270_CPLD_PHYS),
                .length         = LPD270_CPLD_SIZE,
                .type           = MT_DEVICE,
 
                                 unsigned int ctrl)
 {
        struct nand_chip *this = mtd->priv;
-       unsigned long nandaddr = (unsigned long)this->IO_ADDR_W;
+       char __iomem *nandaddr = this->IO_ADDR_W;
 
        if (cmd == NAND_CMD_NONE)
                return;
  ******************************************************************************/
 static struct map_desc palmtx_io_desc[] __initdata = {
 {
-       .virtual        = PALMTX_PCMCIA_VIRT,
+       .virtual        = (unsigned long)PALMTX_PCMCIA_VIRT,
        .pfn            = __phys_to_pfn(PALMTX_PCMCIA_PHYS),
        .length         = PALMTX_PCMCIA_SIZE,
        .type           = MT_DEVICE,
 }, {
-       .virtual        = PALMTX_NAND_ALE_VIRT,
+       .virtual        = (unsigned long)PALMTX_NAND_ALE_VIRT,
        .pfn            = __phys_to_pfn(PALMTX_NAND_ALE_PHYS),
        .length         = SZ_1M,
        .type           = MT_DEVICE,
 }, {
-       .virtual        = PALMTX_NAND_CLE_VIRT,
+       .virtual        = (unsigned long)PALMTX_NAND_CLE_VIRT,
        .pfn            = __phys_to_pfn(PALMTX_NAND_CLE_PHYS),
        .length         = SZ_1M,
        .type           = MT_DEVICE,
 
 
 static struct map_desc pxa25x_io_desc[] __initdata = {
        {       /* Mem Ctl */
-               .virtual        = SMEMC_VIRT,
+               .virtual        = (unsigned long)SMEMC_VIRT,
                .pfn            = __phys_to_pfn(PXA2XX_SMEMC_BASE),
                .length         = 0x00200000,
                .type           = MT_DEVICE
 
 
 static struct map_desc pxa27x_io_desc[] __initdata = {
        {       /* Mem Ctl */
-               .virtual        = SMEMC_VIRT,
+               .virtual        = (unsigned long)SMEMC_VIRT,
                .pfn            = __phys_to_pfn(PXA2XX_SMEMC_BASE),
                .length         = 0x00200000,
                .type           = MT_DEVICE
 
 
 static struct map_desc pxa3xx_io_desc[] __initdata = {
        {       /* Mem Ctl */
-               .virtual        = SMEMC_VIRT,
+               .virtual        = (unsigned long)SMEMC_VIRT,
                .pfn            = __phys_to_pfn(PXA3XX_SMEMC_BASE),
                .length         = 0x00200000,
                .type           = MT_DEVICE
 
 
 static struct map_desc zeus_io_desc[] __initdata = {
        {
-               .virtual = ZEUS_CPLD_VERSION,
+               .virtual = (unsigned long)ZEUS_CPLD_VERSION,
                .pfn     = __phys_to_pfn(ZEUS_CPLD_VERSION_PHYS),
                .length  = 0x1000,
                .type    = MT_DEVICE,
        },
        {
-               .virtual = ZEUS_CPLD_ISA_IRQ,
+               .virtual = (unsigned long)ZEUS_CPLD_ISA_IRQ,
                .pfn     = __phys_to_pfn(ZEUS_CPLD_ISA_IRQ_PHYS),
                .length  = 0x1000,
                .type    = MT_DEVICE,
        },
        {
-               .virtual = ZEUS_CPLD_CONTROL,
+               .virtual = (unsigned long)ZEUS_CPLD_CONTROL,
                .pfn     = __phys_to_pfn(ZEUS_CPLD_CONTROL_PHYS),
                .length  = 0x1000,
                .type    = MT_DEVICE,
        },
        {
-               .virtual = ZEUS_PC104IO,
+               .virtual = (unsigned long)ZEUS_PC104IO,
                .pfn     = __phys_to_pfn(ZEUS_PC104IO_PHYS),
                .length  = 0x00800000,
                .type    = MT_DEVICE,
 
                struct gpio_chip *c = &chips[i].chip;
 
                sprintf(chips[i].label, "gpio-%d", i);
-               chips[i].regbase = (void __iomem *)GPIO_BANK(i);
+               chips[i].regbase = GPIO_BANK(i);
 
                c->base  = gpio;
                c->label = chips[i].label;
 
 
 #define MFP_ADDR_END   { MFP_PIN_INVALID, 0 }
 
-void __init mfp_init_base(unsigned long mfpr_base);
+void __init mfp_init_base(void __iomem *mfpr_base);
 void __init mfp_init_addr(struct mfp_addr_map *map);
 
 /*
 
        spin_unlock_irqrestore(&mfp_spin_lock, flags);
 }
 
-void __init mfp_init_base(unsigned long mfpr_base)
+void __init mfp_init_base(void __iomem *mfpr_base)
 {
        int i;
 
        for (i = 0; i < ARRAY_SIZE(mfp_table); i++)
                mfp_table[i].config = -1;
 
-       mfpr_mmio_base = (void __iomem *)mfpr_base;
+       mfpr_mmio_base = mfpr_base;
 }
 
 void __init mfp_init_addr(struct mfp_addr_map *map)
 
 static int balloon3_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
                                       const socket_state_t *state)
 {
-       __raw_writew(BALLOON3_CF_RESET, BALLOON3_CF_CONTROL_REG |
+       __raw_writew(BALLOON3_CF_RESET, BALLOON3_CF_CONTROL_REG +
                        ((state->flags & SS_RESET) ?
                        BALLOON3_FPGA_SETnCLR : 0));
        return 0;
 
 #include "regs.h"
 #include "reg_bits.h"
 
-static unsigned long virt_base_2700;
+static void __iomem *virt_base_2700;
 
 #define write_reg(val, reg) do { writel((val), (reg)); } while(0)
 
 {
        /* make frame buffer memory enter self-refresh mode */
        write_reg_dly(LMPWR_MC_PWR_SRM, LMPWR);
-       while (LMPWRSTAT != LMPWRSTAT_MC_PWR_SRM)
+       while (readl(LMPWRSTAT) != LMPWRSTAT_MC_PWR_SRM)
                ; /* empty statement */
 
        /* reset the device, since it's initial state is 'mostly sleeping' */
                ret = -EINVAL;
                goto err3;
        }
-       virt_base_2700 = (unsigned long)mfbi->reg_virt_addr;
+       virt_base_2700 = mfbi->reg_virt_addr;
 
        mfbi->fb_virt_addr = ioremap_nocache(mfbi->fb_phys_addr,
                                             res_size(mfbi->fb_req));