From: Heiko Schocher <hs@denx.de>
To: u-boot@lists.denx.de
Subject: [U-Boot] [PATCH v2 03/10] powerpc, 8xx: Use IO accessors to access IO memory
Date: Thu, 6 Jul 2017 11:41:26 +0200 [thread overview]
Message-ID: <595E05C6.1030805@denx.de> (raw)
In-Reply-To: <dd151817f5bcc3e6038a1644d81cb02557f7668a.1499329461.git.christophe.leroy@c-s.fr>
Hello Christophe,
Am 06.07.2017 um 10:33 schrieb Christophe Leroy:
> Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
> ---
> arch/powerpc/cpu/mpc8xx/cpu.c | 58 +++---
> arch/powerpc/cpu/mpc8xx/cpu_init.c | 98 ++++------
> arch/powerpc/cpu/mpc8xx/fec.c | 262 +++++++++++++------------
> arch/powerpc/cpu/mpc8xx/immap.c | 120 ++++++------
> arch/powerpc/cpu/mpc8xx/interrupts.c | 65 +++---
> arch/powerpc/cpu/mpc8xx/reginfo.c | 70 ++++---
> arch/powerpc/cpu/mpc8xx/serial.c | 182 ++++++++---------
> arch/powerpc/cpu/mpc8xx/speed.c | 5 +-
> arch/powerpc/cpu/mpc8xx/spi.c | 166 +++++++---------
> arch/powerpc/include/asm/iopin_8xx.h | 369 +++++++++++++++++++++++------------
> arch/powerpc/lib/time.c | 7 +-
> include/watchdog.h | 2 +-
> 12 files changed, 739 insertions(+), 665 deletions(-)
Reviewed-by: Heiko Schocher <hs@denx.de>
bye,
Heiko
>
> diff --git a/arch/powerpc/cpu/mpc8xx/cpu.c b/arch/powerpc/cpu/mpc8xx/cpu.c
> index 80b9596813..28cc182957 100644
> --- a/arch/powerpc/cpu/mpc8xx/cpu.c
> +++ b/arch/powerpc/cpu/mpc8xx/cpu.c
> @@ -41,7 +41,7 @@ static int check_CPU (long clock, uint pvr, uint immr)
> {
> char *id_str =
> NULL;
> - volatile immap_t *immap = (immap_t *) (immr & 0xFFFF0000);
> + immap_t __iomem *immap = (immap_t __iomem *)(immr & 0xFFFF0000);
> uint k, m;
> char buf[32];
> char pre = 'X';
> @@ -54,7 +54,7 @@ static int check_CPU (long clock, uint pvr, uint immr)
> return -1;
>
> k = (immr << 16) |
> - immap->im_cpm.cp_dparam16[PROFF_REVNUM / sizeof(u16)];
> + in_be16(&immap->im_cpm.cp_dparam16[PROFF_REVNUM / sizeof(u16)]);
> m = 0;
> suf = "";
>
> @@ -95,10 +95,9 @@ static int check_CPU (long clock, uint pvr, uint immr)
>
> /* do we have a FEC (860T/P or 852/859/866/885)? */
>
> - immap->im_cpm.cp_fec.fec_addr_low = 0x12345678;
> - if (immap->im_cpm.cp_fec.fec_addr_low == 0x12345678) {
> + out_be32(&immap->im_cpm.cp_fec.fec_addr_low, 0x12345678);
> + if (in_be32(&immap->im_cpm.cp_fec.fec_addr_low) == 0x12345678)
> printf (" FEC present");
> - }
>
> if (!m) {
> puts (cpu_warning);
> @@ -127,11 +126,11 @@ int checkcpu (void)
>
> int checkicache (void)
> {
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> - volatile memctl8xx_t *memctl = &immap->im_memctl;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + memctl8xx_t __iomem *memctl = &immap->im_memctl;
> u32 cacheon = rd_ic_cst () & IDC_ENABLED;
> -
> - u32 k = memctl->memc_br0 & ~0x00007fff; /* probe in flash memoryarea */
> + /* probe in flash memoryarea */
> + u32 k = in_be32(&memctl->memc_br0) & ~0x00007fff;
> u32 m;
> u32 lines = -1;
>
> @@ -168,11 +167,11 @@ int checkicache (void)
>
> int checkdcache (void)
> {
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> - volatile memctl8xx_t *memctl = &immap->im_memctl;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + memctl8xx_t __iomem *memctl = &immap->im_memctl;
> u32 cacheon = rd_dc_cst () & IDC_ENABLED;
> -
> - u32 k = memctl->memc_br0 & ~0x00007fff; /* probe in flash memoryarea */
> + /* probe in flash memoryarea */
> + u32 k = in_be32(&memctl->memc_br0) & ~0x00007fff;
> u32 m;
> u32 lines = -1;
>
> @@ -204,12 +203,12 @@ void upmconfig (uint upm, uint * table, uint size)
> {
> uint i;
> uint addr = 0;
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> - volatile memctl8xx_t *memctl = &immap->im_memctl;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + memctl8xx_t __iomem *memctl = &immap->im_memctl;
>
> for (i = 0; i < size; i++) {
> - memctl->memc_mdr = table[i]; /* (16-15) */
> - memctl->memc_mcr = addr | upm; /* (16-16) */
> + out_be32(&memctl->memc_mdr, table[i]); /* (16-15) */
> + out_be32(&memctl->memc_mcr, addr | upm); /* (16-16) */
> addr++;
> }
> }
> @@ -220,9 +219,10 @@ int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
> {
> ulong msr, addr;
>
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> - immap->im_clkrst.car_plprcr |= PLPRCR_CSR; /* Checkstop Reset enable */
> + /* Checkstop Reset enable */
> + setbits_be32(&immap->im_clkrst.car_plprcr, PLPRCR_CSR);
>
> /* Interrupts and MMU off */
> __asm__ volatile ("mtspr 81, 0");
> @@ -260,14 +260,13 @@ int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
> unsigned long get_tbclk (void)
> {
> uint immr = get_immr (0); /* Return full IMMR contents */
> - volatile immap_t *immap = (volatile immap_t *)(immr & 0xFFFF0000);
> + immap_t __iomem *immap = (immap_t __iomem *)(immr & 0xFFFF0000);
> ulong oscclk, factor, pll;
>
> - if (immap->im_clkrst.car_sccr & SCCR_TBS) {
> + if (in_be32(&immap->im_clkrst.car_sccr) & SCCR_TBS)
> return (gd->cpu_clk / 16);
> - }
>
> - pll = immap->im_clkrst.car_plprcr;
> + pll = in_be32(&immap->im_clkrst.car_plprcr);
>
> #define PLPRCR_val(a) ((pll & PLPRCR_ ## a ## _MSK) >> PLPRCR_ ## a ## _SHIFT)
>
> @@ -287,9 +286,10 @@ unsigned long get_tbclk (void)
>
> oscclk = gd->cpu_clk / factor;
>
> - if ((immap->im_clkrst.car_sccr & SCCR_RTSEL) == 0 || factor > 2) {
> + if ((in_be32(&immap->im_clkrst.car_sccr) & SCCR_RTSEL) == 0 ||
> + factor > 2)
> return (oscclk / 4);
> - }
> +
> return (oscclk / 16);
> }
>
> @@ -300,7 +300,7 @@ void watchdog_reset (void)
> {
> int re_enable = disable_interrupts ();
>
> - reset_8xx_watchdog ((immap_t *) CONFIG_SYS_IMMR);
> + reset_8xx_watchdog((immap_t __iomem *)CONFIG_SYS_IMMR);
> if (re_enable)
> enable_interrupts ();
> }
> @@ -308,13 +308,13 @@ void watchdog_reset (void)
>
> #if defined(CONFIG_WATCHDOG)
>
> -void reset_8xx_watchdog (volatile immap_t * immr)
> +void reset_8xx_watchdog(immap_t __iomem *immr)
> {
> /*
> * All other boards use the MPC8xx Internal Watchdog
> */
> - immr->im_siu_conf.sc_swsr = 0x556c; /* write magic1 */
> - immr->im_siu_conf.sc_swsr = 0xaa39; /* write magic2 */
> + out_be16(&immr->im_siu_conf.sc_swsr, 0x556c); /* write magic1 */
> + out_be16(&immr->im_siu_conf.sc_swsr, 0xaa39); /* write magic2 */
> }
> #endif /* CONFIG_WATCHDOG */
>
> diff --git a/arch/powerpc/cpu/mpc8xx/cpu_init.c b/arch/powerpc/cpu/mpc8xx/cpu_init.c
> index 0f935aff9e..cf1280983a 100644
> --- a/arch/powerpc/cpu/mpc8xx/cpu_init.c
> +++ b/arch/powerpc/cpu/mpc8xx/cpu_init.c
> @@ -10,6 +10,7 @@
>
> #include <mpc8xx.h>
> #include <commproc.h>
> +#include <asm/io.h>
>
> /*
> * Breath some life into the CPU...
> @@ -18,46 +19,41 @@
> * initialize a bunch of registers,
> * initialize the UPM's
> */
> -void cpu_init_f (volatile immap_t * immr)
> +void cpu_init_f(immap_t __iomem *immr)
> {
> - volatile memctl8xx_t *memctl = &immr->im_memctl;
> -# ifdef CONFIG_SYS_PLPRCR
> - ulong mfmask;
> -# endif
> + memctl8xx_t __iomem *memctl = &immr->im_memctl;
> ulong reg;
>
> /* SYPCR - contains watchdog control (11-9) */
>
> - immr->im_siu_conf.sc_sypcr = CONFIG_SYS_SYPCR;
> + out_be32(&immr->im_siu_conf.sc_sypcr, CONFIG_SYS_SYPCR);
>
> #if defined(CONFIG_WATCHDOG)
> reset_8xx_watchdog (immr);
> #endif /* CONFIG_WATCHDOG */
>
> /* SIUMCR - contains debug pin configuration (11-6) */
> - immr->im_siu_conf.sc_siumcr |= CONFIG_SYS_SIUMCR;
> + setbits_be32(&immr->im_siu_conf.sc_siumcr, CONFIG_SYS_SIUMCR);
> /* initialize timebase status and control register (11-26) */
> /* unlock TBSCRK */
>
> - immr->im_sitk.sitk_tbscrk = KAPWR_KEY;
> - immr->im_sit.sit_tbscr = CONFIG_SYS_TBSCR;
> + out_be32(&immr->im_sitk.sitk_tbscrk, KAPWR_KEY);
> + out_be16(&immr->im_sit.sit_tbscr, CONFIG_SYS_TBSCR);
>
> /* initialize the PIT (11-31) */
>
> - immr->im_sitk.sitk_piscrk = KAPWR_KEY;
> - immr->im_sit.sit_piscr = CONFIG_SYS_PISCR;
> + out_be32(&immr->im_sitk.sitk_piscrk, KAPWR_KEY);
> + out_be16(&immr->im_sit.sit_piscr, CONFIG_SYS_PISCR);
>
> /* System integration timers. Don't change EBDF! (15-27) */
>
> - immr->im_clkrstk.cark_sccrk = KAPWR_KEY;
> - reg = immr->im_clkrst.car_sccr;
> - reg &= SCCR_MASK;
> - reg |= CONFIG_SYS_SCCR;
> - immr->im_clkrst.car_sccr = reg;
> + out_be32(&immr->im_clkrstk.cark_sccrk, KAPWR_KEY);
> + clrsetbits_be32(&immr->im_clkrst.car_sccr, ~SCCR_MASK,
> + CONFIG_SYS_SCCR);
>
> /* PLL (CPU clock) settings (15-30) */
>
> - immr->im_clkrstk.cark_plprcrk = KAPWR_KEY;
> + out_be32(&immr->im_clkrstk.cark_plprcrk, KAPWR_KEY);
>
> /* If CONFIG_SYS_PLPRCR (set in the various *_config.h files) tries to
> * set the MF field, then just copy CONFIG_SYS_PLPRCR over car_plprcr,
> @@ -67,27 +63,19 @@ void cpu_init_f (volatile immap_t * immr)
> * For newer (starting MPC866) chips PLPRCR layout is different.
> */
> #ifdef CONFIG_SYS_PLPRCR
> - mfmask = PLPRCR_MFACT_MSK;
> -
> - if ((CONFIG_SYS_PLPRCR & mfmask) != 0)
> - reg = CONFIG_SYS_PLPRCR; /* reset control bits */
> - else {
> - reg = immr->im_clkrst.car_plprcr;
> - reg &= mfmask; /* isolate MF-related fields */
> - reg |= CONFIG_SYS_PLPRCR; /* reset control bits */
> - }
> - immr->im_clkrst.car_plprcr = reg;
> + if ((CONFIG_SYS_PLPRCR & PLPRCR_MFACT_MSK) != 0) /* reset control bits*/
> + out_be32(&immr->im_clkrst.car_plprcr, CONFIG_SYS_PLPRCR);
> + else /* isolate MF-related fields and reset control bits */
> + clrsetbits_be32(&immr->im_clkrst.car_plprcr, ~PLPRCR_MFACT_MSK,
> + CONFIG_SYS_PLPRCR);
> #endif
>
> /*
> * Memory Controller:
> */
>
> - /* perform BR0 reset that MPC850 Rev. A can't guarantee */
> - reg = memctl->memc_br0;
> - reg &= BR_PS_MSK; /* Clear everything except Port Size bits */
> - reg |= BR_V; /* then add just the "Bank Valid" bit */
> - memctl->memc_br0 = reg;
> + /* Clear everything except Port Size bits & add the "Bank Valid" bit */
> + clrsetbits_be32(&memctl->memc_br0, ~BR_PS_MSK, BR_V);
>
> /* Map banks 0 (and maybe 1) to the FLASH banks 0 (and 1) at
> * preliminary addresses - these have to be modified later
> @@ -114,61 +102,61 @@ void cpu_init_f (volatile immap_t * immr)
> */
>
> #if defined(CONFIG_SYS_OR0_REMAP)
> - memctl->memc_or0 = CONFIG_SYS_OR0_REMAP;
> + out_be32(&memctl->memc_or0, CONFIG_SYS_OR0_REMAP);
> #endif
> #if defined(CONFIG_SYS_OR1_REMAP)
> - memctl->memc_or1 = CONFIG_SYS_OR1_REMAP;
> + out_be32(&memctl->memc_or1, CONFIG_SYS_OR1_REMAP);
> #endif
> #if defined(CONFIG_SYS_OR5_REMAP)
> - memctl->memc_or5 = CONFIG_SYS_OR5_REMAP;
> + out_be32(&memctl->memc_or5, CONFIG_SYS_OR5_REMAP);
> #endif
>
> /* now restrict to preliminary range */
> - memctl->memc_br0 = CONFIG_SYS_BR0_PRELIM;
> - memctl->memc_or0 = CONFIG_SYS_OR0_PRELIM;
> + out_be32(&memctl->memc_br0, CONFIG_SYS_BR0_PRELIM);
> + out_be32(&memctl->memc_or0, CONFIG_SYS_OR0_PRELIM);
>
> #if (defined(CONFIG_SYS_OR1_PRELIM) && defined(CONFIG_SYS_BR1_PRELIM))
> - memctl->memc_or1 = CONFIG_SYS_OR1_PRELIM;
> - memctl->memc_br1 = CONFIG_SYS_BR1_PRELIM;
> + out_be32(&memctl->memc_or1, CONFIG_SYS_OR1_PRELIM);
> + out_be32(&memctl->memc_br1, CONFIG_SYS_BR1_PRELIM);
> #endif
>
> #if defined(CONFIG_SYS_OR2_PRELIM) && defined(CONFIG_SYS_BR2_PRELIM)
> - memctl->memc_or2 = CONFIG_SYS_OR2_PRELIM;
> - memctl->memc_br2 = CONFIG_SYS_BR2_PRELIM;
> + out_be32(&memctl->memc_or2, CONFIG_SYS_OR2_PRELIM);
> + out_be32(&memctl->memc_br2, CONFIG_SYS_BR2_PRELIM);
> #endif
>
> #if defined(CONFIG_SYS_OR3_PRELIM) && defined(CONFIG_SYS_BR3_PRELIM)
> - memctl->memc_or3 = CONFIG_SYS_OR3_PRELIM;
> - memctl->memc_br3 = CONFIG_SYS_BR3_PRELIM;
> + out_be32(&memctl->memc_or3, CONFIG_SYS_OR3_PRELIM);
> + out_be32(&memctl->memc_br3, CONFIG_SYS_BR3_PRELIM);
> #endif
>
> #if defined(CONFIG_SYS_OR4_PRELIM) && defined(CONFIG_SYS_BR4_PRELIM)
> - memctl->memc_or4 = CONFIG_SYS_OR4_PRELIM;
> - memctl->memc_br4 = CONFIG_SYS_BR4_PRELIM;
> + out_be32(&memctl->memc_or4, CONFIG_SYS_OR4_PRELIM);
> + out_be32(&memctl->memc_br4, CONFIG_SYS_BR4_PRELIM);
> #endif
>
> #if defined(CONFIG_SYS_OR5_PRELIM) && defined(CONFIG_SYS_BR5_PRELIM)
> - memctl->memc_or5 = CONFIG_SYS_OR5_PRELIM;
> - memctl->memc_br5 = CONFIG_SYS_BR5_PRELIM;
> + out_be32(&memctl->memc_or5, CONFIG_SYS_OR5_PRELIM);
> + out_be32(&memctl->memc_br5, CONFIG_SYS_BR5_PRELIM);
> #endif
>
> #if defined(CONFIG_SYS_OR6_PRELIM) && defined(CONFIG_SYS_BR6_PRELIM)
> - memctl->memc_or6 = CONFIG_SYS_OR6_PRELIM;
> - memctl->memc_br6 = CONFIG_SYS_BR6_PRELIM;
> + out_be32(&memctl->memc_or6, CONFIG_SYS_OR6_PRELIM);
> + out_be32(&memctl->memc_br6, CONFIG_SYS_BR6_PRELIM);
> #endif
>
> #if defined(CONFIG_SYS_OR7_PRELIM) && defined(CONFIG_SYS_BR7_PRELIM)
> - memctl->memc_or7 = CONFIG_SYS_OR7_PRELIM;
> - memctl->memc_br7 = CONFIG_SYS_BR7_PRELIM;
> + out_be32(&memctl->memc_or7, CONFIG_SYS_OR7_PRELIM);
> + out_be32(&memctl->memc_br7, CONFIG_SYS_BR7_PRELIM);
> #endif
>
> /*
> * Reset CPM
> */
> - immr->im_cpm.cp_cpcr = CPM_CR_RST | CPM_CR_FLG;
> - do { /* Spin until command processed */
> - __asm__ ("eieio");
> - } while (immr->im_cpm.cp_cpcr & CPM_CR_FLG);
> + out_be16(&immr->im_cpm.cp_cpcr, CPM_CR_RST | CPM_CR_FLG);
> + /* Spin until command processed */
> + while (in_be16(&immr->im_cpm.cp_cpcr) & CPM_CR_FLG)
> + ;
> }
>
> /*
> diff --git a/arch/powerpc/cpu/mpc8xx/fec.c b/arch/powerpc/cpu/mpc8xx/fec.c
> index 7aa526d7ec..eaaea2d4e8 100644
> --- a/arch/powerpc/cpu/mpc8xx/fec.c
> +++ b/arch/powerpc/cpu/mpc8xx/fec.c
> @@ -10,6 +10,7 @@
> #include <commproc.h>
> #include <malloc.h>
> #include <net.h>
> +#include <asm/io.h>
>
> #include <phy.h>
>
> @@ -115,12 +116,12 @@ static uint txIdx; /* index of the current TX buffer */
> * Provide for Double Buffering
> */
>
> -typedef volatile struct CommonBufferDescriptor {
> +struct common_buf_desc {
> cbd_t rxbd[PKTBUFSRX]; /* Rx BD */
> cbd_t txbd[TX_BUF_CNT]; /* Tx BD */
> -} RTXBD;
> +};
>
> -static RTXBD *rtx = NULL;
> +static struct common_buf_desc __iomem *rtx;
>
> static int fec_send(struct eth_device *dev, void *packet, int length);
> static int fec_recv(struct eth_device* dev);
> @@ -189,13 +190,15 @@ static int fec_send(struct eth_device *dev, void *packet, int length)
> {
> int j, rc;
> struct ether_fcc_info_s *efis = dev->priv;
> - volatile fec_t *fecp = (volatile fec_t *)(CONFIG_SYS_IMMR + efis->fecp_offset);
> + fec_t __iomem *fecp =
> + (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset);
>
> /* section 16.9.23.3
> * Wait for ready
> */
> j = 0;
> - while ((rtx->txbd[txIdx].cbd_sc & BD_ENET_TX_READY) && (j<TOUT_LOOP)) {
> + while ((in_be16(&rtx->txbd[txIdx].cbd_sc) & BD_ENET_TX_READY) &&
> + (j < TOUT_LOOP)) {
> udelay(1);
> j++;
> }
> @@ -203,16 +206,18 @@ static int fec_send(struct eth_device *dev, void *packet, int length)
> printf("TX not ready\n");
> }
>
> - rtx->txbd[txIdx].cbd_bufaddr = (uint)packet;
> - rtx->txbd[txIdx].cbd_datlen = length;
> - rtx->txbd[txIdx].cbd_sc |= BD_ENET_TX_READY | BD_ENET_TX_LAST;
> - __asm__ ("eieio");
> + out_be32(&rtx->txbd[txIdx].cbd_bufaddr, (uint)packet);
> + out_be16(&rtx->txbd[txIdx].cbd_datlen, length);
> + setbits_be16(&rtx->txbd[txIdx].cbd_sc,
> + BD_ENET_TX_READY | BD_ENET_TX_LAST);
>
> /* Activate transmit Buffer Descriptor polling */
> - fecp->fec_x_des_active = 0x01000000; /* Descriptor polling active */
> + /* Descriptor polling active */
> + out_be32(&fecp->fec_x_des_active, 0x01000000);
>
> j = 0;
> - while ((rtx->txbd[txIdx].cbd_sc & BD_ENET_TX_READY) && (j<TOUT_LOOP)) {
> + while ((in_be16(&rtx->txbd[txIdx].cbd_sc) & BD_ENET_TX_READY) &&
> + (j < TOUT_LOOP)) {
> udelay(1);
> j++;
> }
> @@ -220,7 +225,7 @@ static int fec_send(struct eth_device *dev, void *packet, int length)
> printf("TX timeout\n");
> }
> /* return only status bits */;
> - rc = (rtx->txbd[txIdx].cbd_sc & BD_ENET_TX_STATS);
> + rc = in_be16(&rtx->txbd[txIdx].cbd_sc) & BD_ENET_TX_STATS;
>
> txIdx = (txIdx + 1) % TX_BUF_CNT;
>
> @@ -230,21 +235,20 @@ static int fec_send(struct eth_device *dev, void *packet, int length)
> static int fec_recv (struct eth_device *dev)
> {
> struct ether_fcc_info_s *efis = dev->priv;
> - volatile fec_t *fecp =
> - (volatile fec_t *) (CONFIG_SYS_IMMR + efis->fecp_offset);
> + fec_t __iomem *fecp =
> + (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset);
> int length;
>
> for (;;) {
> /* section 16.9.23.2 */
> - if (rtx->rxbd[rxIdx].cbd_sc & BD_ENET_RX_EMPTY) {
> + if (in_be16(&rtx->rxbd[rxIdx].cbd_sc) & BD_ENET_RX_EMPTY) {
> length = -1;
> break; /* nothing received - leave for() loop */
> }
>
> - length = rtx->rxbd[rxIdx].cbd_datlen;
> + length = in_be16(&rtx->rxbd[rxIdx].cbd_datlen);
>
> - if (rtx->rxbd[rxIdx].cbd_sc & 0x003f) {
> - } else {
> + if (!(in_be16(&rtx->rxbd[rxIdx].cbd_sc) & 0x003f)) {
> uchar *rx = net_rx_packets[rxIdx];
>
> length -= 4;
> @@ -263,22 +267,21 @@ static int fec_recv (struct eth_device *dev)
> }
>
> /* Give the buffer back to the FEC. */
> - rtx->rxbd[rxIdx].cbd_datlen = 0;
> + out_be16(&rtx->rxbd[rxIdx].cbd_datlen, 0);
>
> /* wrap around buffer index when necessary */
> if ((rxIdx + 1) >= PKTBUFSRX) {
> - rtx->rxbd[PKTBUFSRX - 1].cbd_sc =
> - (BD_ENET_RX_WRAP | BD_ENET_RX_EMPTY);
> + out_be16(&rtx->rxbd[PKTBUFSRX - 1].cbd_sc,
> + BD_ENET_RX_WRAP | BD_ENET_RX_EMPTY);
> rxIdx = 0;
> } else {
> - rtx->rxbd[rxIdx].cbd_sc = BD_ENET_RX_EMPTY;
> + out_be16(&rtx->rxbd[rxIdx].cbd_sc, BD_ENET_RX_EMPTY);
> rxIdx++;
> }
>
> - __asm__ ("eieio");
> -
> /* Try to fill Buffer Descriptors */
> - fecp->fec_r_des_active = 0x01000000; /* Descriptor polling active */
> + /* Descriptor polling active */
> + out_be32(&fecp->fec_r_des_active, 0x01000000);
> }
>
> return length;
> @@ -313,11 +316,12 @@ static inline void fec_10Mbps(struct eth_device *dev)
> struct ether_fcc_info_s *efis = dev->priv;
> int fecidx = efis->ether_index;
> uint mask = (fecidx == 0) ? 0x0000010 : 0x0000008;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> if ((unsigned int)fecidx >= 2)
> hang();
>
> - ((volatile immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_cptr |= mask;
> + setbits_be32(&immr->im_cpm.cp_cptr, mask);
> }
>
> static inline void fec_100Mbps(struct eth_device *dev)
> @@ -325,11 +329,12 @@ static inline void fec_100Mbps(struct eth_device *dev)
> struct ether_fcc_info_s *efis = dev->priv;
> int fecidx = efis->ether_index;
> uint mask = (fecidx == 0) ? 0x0000010 : 0x0000008;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> if ((unsigned int)fecidx >= 2)
> hang();
>
> - ((volatile immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_cptr &= ~mask;
> + clrbits_be32(&immr->im_cpm.cp_cptr, mask);
> }
>
> #endif
> @@ -337,25 +342,27 @@ static inline void fec_100Mbps(struct eth_device *dev)
> static inline void fec_full_duplex(struct eth_device *dev)
> {
> struct ether_fcc_info_s *efis = dev->priv;
> - volatile fec_t *fecp = (volatile fec_t *)(CONFIG_SYS_IMMR + efis->fecp_offset);
> + fec_t __iomem *fecp =
> + (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset);
>
> - fecp->fec_r_cntrl &= ~FEC_RCNTRL_DRT;
> - fecp->fec_x_cntrl |= FEC_TCNTRL_FDEN; /* FD enable */
> + clrbits_be32(&fecp->fec_r_cntrl, FEC_RCNTRL_DRT);
> + setbits_be32(&fecp->fec_x_cntrl, FEC_TCNTRL_FDEN); /* FD enable */
> }
>
> static inline void fec_half_duplex(struct eth_device *dev)
> {
> struct ether_fcc_info_s *efis = dev->priv;
> - volatile fec_t *fecp = (volatile fec_t *)(CONFIG_SYS_IMMR + efis->fecp_offset);
> + fec_t __iomem *fecp =
> + (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset);
>
> - fecp->fec_r_cntrl |= FEC_RCNTRL_DRT;
> - fecp->fec_x_cntrl &= ~FEC_TCNTRL_FDEN; /* FD disable */
> + setbits_be32(&fecp->fec_r_cntrl, FEC_RCNTRL_DRT);
> + clrbits_be32(&fecp->fec_x_cntrl, FEC_TCNTRL_FDEN); /* FD disable */
> }
>
> static void fec_pin_init(int fecidx)
> {
> bd_t *bd = gd->bd;
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> /*
> * Set MII speed to 2.5 MHz or slightly below.
> @@ -369,12 +376,13 @@ static void fec_pin_init(int fecidx)
> *
> * All MII configuration is done via FEC1 registers:
> */
> - immr->im_cpm.cp_fec1.fec_mii_speed = ((bd->bi_intfreq + 4999999) / 5000000) << 1;
> + out_be32(&immr->im_cpm.cp_fec1.fec_mii_speed,
> + ((bd->bi_intfreq + 4999999) / 5000000) << 1);
>
> #if defined(CONFIG_MPC885_FAMILY) && defined(WANT_MII)
> /* use MDC for MII */
> - immr->im_ioport.iop_pdpar |= 0x0080;
> - immr->im_ioport.iop_pddir &= ~0x0080;
> + setbits_be16(&immr->im_ioport.iop_pdpar, 0x0080);
> + clrbits_be16(&immr->im_ioport.iop_pddir, 0x0080);
> #endif
>
> if (fecidx == 0) {
> @@ -384,37 +392,37 @@ static void fec_pin_init(int fecidx)
>
> #if !defined(CONFIG_RMII)
>
> - immr->im_ioport.iop_papar |= 0xf830;
> - immr->im_ioport.iop_padir |= 0x0830;
> - immr->im_ioport.iop_padir &= ~0xf000;
> + setbits_be16(&immr->im_ioport.iop_papar, 0xf830);
> + setbits_be16(&immr->im_ioport.iop_padir, 0x0830);
> + clrbits_be16(&immr->im_ioport.iop_padir, 0xf000);
>
> - immr->im_cpm.cp_pbpar |= 0x00001001;
> - immr->im_cpm.cp_pbdir &= ~0x00001001;
> + setbits_be32(&immr->im_cpm.cp_pbpar, 0x00001001);
> + clrbits_be32(&immr->im_cpm.cp_pbdir, 0x00001001);
>
> - immr->im_ioport.iop_pcpar |= 0x000c;
> - immr->im_ioport.iop_pcdir &= ~0x000c;
> + setbits_be16(&immr->im_ioport.iop_pcpar, 0x000c);
> + clrbits_be16(&immr->im_ioport.iop_pcdir, 0x000c);
>
> - immr->im_cpm.cp_pepar |= 0x00000003;
> - immr->im_cpm.cp_pedir |= 0x00000003;
> - immr->im_cpm.cp_peso &= ~0x00000003;
> + setbits_be32(&immr->im_cpm.cp_pepar, 0x00000003);
> + setbits_be32(&immr->im_cpm.cp_pedir, 0x00000003);
> + clrbits_be32(&immr->im_cpm.cp_peso, 0x00000003);
>
> - immr->im_cpm.cp_cptr &= ~0x00000100;
> + clrbits_be32(&immr->im_cpm.cp_cptr, 0x00000100);
>
> #else
>
> #if !defined(CONFIG_FEC1_PHY_NORXERR)
> - immr->im_ioport.iop_papar |= 0x1000;
> - immr->im_ioport.iop_padir &= ~0x1000;
> + setbits_be16(&immr->im_ioport.iop_papar, 0x1000);
> + clrbits_be16(&immr->im_ioport.iop_padir, 0x1000);
> #endif
> - immr->im_ioport.iop_papar |= 0xe810;
> - immr->im_ioport.iop_padir |= 0x0810;
> - immr->im_ioport.iop_padir &= ~0xe000;
> + setbits_be16(&immr->im_ioport.iop_papar, 0xe810);
> + setbits_be16(&immr->im_ioport.iop_padir, 0x0810);
> + clrbits_be16(&immr->im_ioport.iop_padir, 0xe000);
>
> - immr->im_cpm.cp_pbpar |= 0x00000001;
> - immr->im_cpm.cp_pbdir &= ~0x00000001;
> + setbits_be32(&immr->im_cpm.cp_pbpar, 0x00000001);
> + clrbits_be32(&immr->im_cpm.cp_pbdir, 0x00000001);
>
> - immr->im_cpm.cp_cptr |= 0x00000100;
> - immr->im_cpm.cp_cptr &= ~0x00000050;
> + setbits_be32(&immr->im_cpm.cp_cptr, 0x00000100);
> + clrbits_be32(&immr->im_cpm.cp_cptr, 0x00000050);
>
> #endif /* !CONFIG_RMII */
>
> @@ -422,9 +430,8 @@ static void fec_pin_init(int fecidx)
> /*
> * Configure all of port D for MII.
> */
> - immr->im_ioport.iop_pdpar = 0x1fff;
> -
> - immr->im_ioport.iop_pddir = 0x1fff; /* Rev. D and later */
> + out_be16(&immr->im_ioport.iop_pdpar, 0x1fff);
> + out_be16(&immr->im_ioport.iop_pddir, 0x1fff);
> #endif
>
> #endif /* CONFIG_ETHER_ON_FEC1 */
> @@ -435,26 +442,26 @@ static void fec_pin_init(int fecidx)
> #if defined(CONFIG_MPC885_FAMILY) /* MPC87x/88x have got 2 FECs and different pinout */
>
> #if !defined(CONFIG_RMII)
> - immr->im_cpm.cp_pepar |= 0x0003fffc;
> - immr->im_cpm.cp_pedir |= 0x0003fffc;
> - immr->im_cpm.cp_peso &= ~0x000087fc;
> - immr->im_cpm.cp_peso |= 0x00037800;
> + setbits_be32(&immr->im_cpm.cp_pepar, 0x0003fffc);
> + setbits_be32(&immr->im_cpm.cp_pedir, 0x0003fffc);
> + clrbits_be32(&immr->im_cpm.cp_peso, 0x000087fc);
> + setbits_be32(&immr->im_cpm.cp_peso, 0x00037800);
>
> - immr->im_cpm.cp_cptr &= ~0x00000080;
> + clrbits_be32(&immr->im_cpm.cp_cptr, 0x00000080);
> #else
>
> #if !defined(CONFIG_FEC2_PHY_NORXERR)
> - immr->im_cpm.cp_pepar |= 0x00000010;
> - immr->im_cpm.cp_pedir |= 0x00000010;
> - immr->im_cpm.cp_peso &= ~0x00000010;
> + setbits_be32(&immr->im_cpm.cp_pepar, 0x00000010);
> + setbits_be32(&immr->im_cpm.cp_pedir, 0x00000010);
> + clrbits_be32(&immr->im_cpm.cp_peso, 0x00000010);
> #endif
> - immr->im_cpm.cp_pepar |= 0x00039620;
> - immr->im_cpm.cp_pedir |= 0x00039620;
> - immr->im_cpm.cp_peso |= 0x00031000;
> - immr->im_cpm.cp_peso &= ~0x00008620;
> + setbits_be32(&immr->im_cpm.cp_pepar, 0x00039620);
> + setbits_be32(&immr->im_cpm.cp_pedir, 0x00039620);
> + setbits_be32(&immr->im_cpm.cp_peso, 0x00031000);
> + clrbits_be32(&immr->im_cpm.cp_peso, 0x00008620);
>
> - immr->im_cpm.cp_cptr |= 0x00000080;
> - immr->im_cpm.cp_cptr &= ~0x00000028;
> + setbits_be32(&immr->im_cpm.cp_cptr, 0x00000080);
> + clrbits_be32(&immr->im_cpm.cp_cptr, 0x00000028);
> #endif /* CONFIG_RMII */
>
> #endif /* CONFIG_MPC885_FAMILY */
> @@ -464,7 +471,7 @@ static void fec_pin_init(int fecidx)
> }
> }
>
> -static int fec_reset(volatile fec_t *fecp)
> +static int fec_reset(fec_t __iomem *fecp)
> {
> int i;
>
> @@ -476,12 +483,11 @@ static int fec_reset(volatile fec_t *fecp)
> * still in progress.
> */
>
> - fecp->fec_ecntrl = FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET;
> - for (i = 0;
> - (fecp->fec_ecntrl & FEC_ECNTRL_RESET) && (i < FEC_RESET_DELAY);
> - ++i) {
> + out_be32(&fecp->fec_ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET);
> + for (i = 0; (in_be32(&fecp->fec_ecntrl) & FEC_ECNTRL_RESET) &&
> + (i < FEC_RESET_DELAY); ++i)
> udelay (1);
> - }
> +
> if (i == FEC_RESET_DELAY)
> return -1;
>
> @@ -491,9 +497,9 @@ static int fec_reset(volatile fec_t *fecp)
> static int fec_init (struct eth_device *dev, bd_t * bd)
> {
> struct ether_fcc_info_s *efis = dev->priv;
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> - volatile fec_t *fecp =
> - (volatile fec_t *) (CONFIG_SYS_IMMR + efis->fecp_offset);
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + fec_t __iomem *fecp =
> + (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset);
> int i;
>
> #if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
> @@ -510,41 +516,42 @@ static int fec_init (struct eth_device *dev, bd_t * bd)
>
> /* We use strictly polling mode only
> */
> - fecp->fec_imask = 0;
> + out_be32(&fecp->fec_imask, 0);
>
> /* Clear any pending interrupt
> */
> - fecp->fec_ievent = 0xffc0;
> + out_be32(&fecp->fec_ievent, 0xffc0);
>
> /* No need to set the IVEC register */
>
> /* Set station address
> */
> #define ea dev->enetaddr
> - fecp->fec_addr_low = (ea[0] << 24) | (ea[1] << 16) | (ea[2] << 8) | (ea[3]);
> - fecp->fec_addr_high = (ea[4] << 8) | (ea[5]);
> + out_be32(&fecp->fec_addr_low, (ea[0] << 24) | (ea[1] << 16) |
> + (ea[2] << 8) | ea[3]);
> + out_be16(&fecp->fec_addr_high, (ea[4] << 8) | ea[5]);
> #undef ea
>
> #if defined(CONFIG_CMD_CDP)
> /*
> * Turn on multicast address hash table
> */
> - fecp->fec_hash_table_high = 0xffffffff;
> - fecp->fec_hash_table_low = 0xffffffff;
> + out_be32(&fecp->fec_hash_table_high, 0xffffffff);
> + out_be32(&fecp->fec_hash_table_low, 0xffffffff);
> #else
> /* Clear multicast address hash table
> */
> - fecp->fec_hash_table_high = 0;
> - fecp->fec_hash_table_low = 0;
> + out_be32(&fecp->fec_hash_table_high, 0);
> + out_be32(&fecp->fec_hash_table_low, 0);
> #endif
>
> /* Set maximum receive buffer size.
> */
> - fecp->fec_r_buff_size = PKT_MAXBLR_SIZE;
> + out_be32(&fecp->fec_r_buff_size, PKT_MAXBLR_SIZE);
>
> /* Set maximum frame length
> */
> - fecp->fec_r_hash = PKT_MAXBUF_SIZE;
> + out_be32(&fecp->fec_r_hash, PKT_MAXBUF_SIZE);
>
> /*
> * Setup Buffers and Buffer Desriptors
> @@ -553,18 +560,19 @@ static int fec_init (struct eth_device *dev, bd_t * bd)
> txIdx = 0;
>
> if (!rtx)
> - rtx = (RTXBD *)(immr->im_cpm.cp_dpmem + CPM_FEC_BASE);
> + rtx = (struct common_buf_desc __iomem *)
> + (immr->im_cpm.cp_dpmem + CPM_FEC_BASE);
> /*
> * Setup Receiver Buffer Descriptors (13.14.24.18)
> * Settings:
> * Empty, Wrap
> */
> for (i = 0; i < PKTBUFSRX; i++) {
> - rtx->rxbd[i].cbd_sc = BD_ENET_RX_EMPTY;
> - rtx->rxbd[i].cbd_datlen = 0; /* Reset */
> - rtx->rxbd[i].cbd_bufaddr = (uint) net_rx_packets[i];
> + out_be16(&rtx->rxbd[i].cbd_sc, BD_ENET_RX_EMPTY);
> + out_be16(&rtx->rxbd[i].cbd_datlen, 0); /* Reset */
> + out_be32(&rtx->rxbd[i].cbd_bufaddr, (uint)net_rx_packets[i]);
> }
> - rtx->rxbd[PKTBUFSRX - 1].cbd_sc |= BD_ENET_RX_WRAP;
> + setbits_be16(&rtx->rxbd[PKTBUFSRX - 1].cbd_sc, BD_ENET_RX_WRAP);
>
> /*
> * Setup Ethernet Transmitter Buffer Descriptors (13.14.24.19)
> @@ -572,26 +580,26 @@ static int fec_init (struct eth_device *dev, bd_t * bd)
> * Last, Tx CRC
> */
> for (i = 0; i < TX_BUF_CNT; i++) {
> - rtx->txbd[i].cbd_sc = BD_ENET_TX_LAST | BD_ENET_TX_TC;
> - rtx->txbd[i].cbd_datlen = 0; /* Reset */
> - rtx->txbd[i].cbd_bufaddr = (uint) (&txbuf[0]);
> + out_be16(&rtx->txbd[i].cbd_sc, BD_ENET_TX_LAST | BD_ENET_TX_TC);
> + out_be16(&rtx->txbd[i].cbd_datlen, 0); /* Reset */
> + out_be32(&rtx->txbd[i].cbd_bufaddr, (uint)txbuf);
> }
> - rtx->txbd[TX_BUF_CNT - 1].cbd_sc |= BD_ENET_TX_WRAP;
> + setbits_be16(&rtx->txbd[TX_BUF_CNT - 1].cbd_sc, BD_ENET_TX_WRAP);
>
> /* Set receive and transmit descriptor base
> */
> - fecp->fec_r_des_start = (unsigned int) (&rtx->rxbd[0]);
> - fecp->fec_x_des_start = (unsigned int) (&rtx->txbd[0]);
> + out_be32(&fecp->fec_r_des_start, (__force unsigned int)rtx->rxbd);
> + out_be32(&fecp->fec_x_des_start, (__force unsigned int)rtx->txbd);
>
> /* Enable MII mode
> */
> /* Half duplex mode */
> - fecp->fec_r_cntrl = FEC_RCNTRL_MII_MODE | FEC_RCNTRL_DRT;
> - fecp->fec_x_cntrl = 0;
> + out_be32(&fecp->fec_r_cntrl, FEC_RCNTRL_MII_MODE | FEC_RCNTRL_DRT);
> + out_be32(&fecp->fec_x_cntrl, 0);
>
> /* Enable big endian and don't care about SDMA FC.
> */
> - fecp->fec_fun_code = 0x78000000;
> + out_be32(&fecp->fec_fun_code, 0x78000000);
>
> /*
> * Setup the pin configuration of the FEC
> @@ -604,7 +612,7 @@ static int fec_init (struct eth_device *dev, bd_t * bd)
> /*
> * Now enable the transmit and receive processing
> */
> - fecp->fec_ecntrl = FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN;
> + out_be32(&fecp->fec_ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
>
> if (efis->phy_addr == -1) {
> #ifdef CONFIG_SYS_DISCOVER_PHY
> @@ -647,7 +655,8 @@ static int fec_init (struct eth_device *dev, bd_t * bd)
> #endif
>
> /* And last, try to fill Rx Buffer Descriptors */
> - fecp->fec_r_des_active = 0x01000000; /* Descriptor polling active */
> + /* Descriptor polling active */
> + out_be32(&fecp->fec_r_des_active, 0x01000000);
>
> efis->initialized = 1;
>
> @@ -658,7 +667,8 @@ static int fec_init (struct eth_device *dev, bd_t * bd)
> static void fec_halt(struct eth_device* dev)
> {
> struct ether_fcc_info_s *efis = dev->priv;
> - volatile fec_t *fecp = (volatile fec_t *)(CONFIG_SYS_IMMR + efis->fecp_offset);
> + fec_t __iomem *fecp =
> + (fec_t __iomem *)(CONFIG_SYS_IMMR + efis->fecp_offset);
> int i;
>
> /* avoid halt if initialized; mii gets stuck otherwise */
> @@ -673,12 +683,11 @@ static void fec_halt(struct eth_device* dev)
> * still in progress.
> */
>
> - fecp->fec_ecntrl = FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET;
> - for (i = 0;
> - (fecp->fec_ecntrl & FEC_ECNTRL_RESET) && (i < FEC_RESET_DELAY);
> - ++i) {
> + out_be32(&fecp->fec_ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET);
> + for (i = 0; (in_be32(&fecp->fec_ecntrl) & FEC_ECNTRL_RESET) &&
> + (i < FEC_RESET_DELAY); ++i)
> udelay (1);
> - }
> +
> if (i == FEC_RESET_DELAY) {
> printf ("FEC_RESET_DELAY timeout\n");
> return;
> @@ -717,23 +726,24 @@ static uint
> mii_send(uint mii_cmd)
> {
> uint mii_reply;
> - volatile fec_t *ep;
> + fec_t __iomem *ep;
> int cnt;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> - ep = &(((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_fec);
> + ep = &immr->im_cpm.cp_fec;
>
> - ep->fec_mii_data = mii_cmd; /* command to phy */
> + out_be32(&ep->fec_mii_data, mii_cmd); /* command to phy */
>
> /* wait for mii complete */
> cnt = 0;
> - while (!(ep->fec_ievent & FEC_ENET_MII)) {
> + while (!(in_be32(&ep->fec_ievent) & FEC_ENET_MII)) {
> if (++cnt > 1000) {
> printf("mii_send STUCK!\n");
> break;
> }
> }
> - mii_reply = ep->fec_mii_data; /* result from phy */
> - ep->fec_ievent = FEC_ENET_MII; /* clear MII complete */
> + mii_reply = in_be32(&ep->fec_mii_data); /* result from phy */
> + out_be32(&ep->fec_ievent, FEC_ENET_MII); /* clear MII complete */
> return (mii_reply & 0xffff); /* data read from phy */
> }
> #endif
> @@ -782,23 +792,23 @@ static int mii_discover_phy(struct eth_device *dev)
> */
> static void __mii_init(void)
> {
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> - volatile fec_t *fecp = &(immr->im_cpm.cp_fec);
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + fec_t __iomem *fecp = &immr->im_cpm.cp_fec;
>
> if (fec_reset(fecp) < 0)
> printf ("FEC_RESET_DELAY timeout\n");
>
> /* We use strictly polling mode only
> */
> - fecp->fec_imask = 0;
> + out_be32(&fecp->fec_imask, 0);
>
> /* Clear any pending interrupt
> */
> - fecp->fec_ievent = 0xffc0;
> + out_be32(&fecp->fec_ievent, 0xffc0);
>
> /* Now enable the transmit and receive processing
> */
> - fecp->fec_ecntrl = FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN;
> + out_be32(&fecp->fec_ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
> }
>
> void mii_init (void)
> diff --git a/arch/powerpc/cpu/mpc8xx/immap.c b/arch/powerpc/cpu/mpc8xx/immap.c
> index 5ff6aa5e3b..63cc664e92 100644
> --- a/arch/powerpc/cpu/mpc8xx/immap.c
> +++ b/arch/powerpc/cpu/mpc8xx/immap.c
> @@ -15,64 +15,60 @@
> #include <asm/8xx_immap.h>
> #include <commproc.h>
> #include <asm/iopin_8xx.h>
> +#include <asm/io.h>
>
> DECLARE_GLOBAL_DATA_PTR;
>
> int
> do_siuinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
> {
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> -
> - volatile sysconf8xx_t *sc = &immap->im_siu_conf;
> -
> - printf ("SIUMCR= %08x SYPCR = %08x\n", sc->sc_siumcr, sc->sc_sypcr);
> - printf ("SWT = %08x\n", sc->sc_swt);
> - printf ("SIPEND= %08x SIMASK= %08x\n", sc->sc_sipend, sc->sc_simask);
> - printf ("SIEL = %08x SIVEC = %08x\n", sc->sc_siel, sc->sc_sivec);
> - printf ("TESR = %08x SDCR = %08x\n", sc->sc_tesr, sc->sc_sdcr);
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + sysconf8xx_t __iomem *sc = &immap->im_siu_conf;
> +
> + printf("SIUMCR= %08x SYPCR = %08x\n",
> + in_be32(&sc->sc_siumcr), in_be32(&sc->sc_sypcr));
> + printf("SWT = %08x\n", in_be32(&sc->sc_swt));
> + printf("SIPEND= %08x SIMASK= %08x\n",
> + in_be32(&sc->sc_sipend), in_be32(&sc->sc_simask));
> + printf("SIEL = %08x SIVEC = %08x\n",
> + in_be32(&sc->sc_siel), in_be32(&sc->sc_sivec));
> + printf("TESR = %08x SDCR = %08x\n",
> + in_be32(&sc->sc_tesr), in_be32(&sc->sc_sdcr));
> return 0;
> }
>
> int
> do_memcinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
> {
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> -
> - volatile memctl8xx_t *memctl = &immap->im_memctl;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + memctl8xx_t __iomem *memctl = &immap->im_memctl;
> int nbanks = 8;
> - volatile uint *p = &memctl->memc_br0;
> + uint __iomem *p = &memctl->memc_br0;
> int i;
>
> - for (i = 0; i < nbanks; i++, p += 2) {
> - if (i < 10) {
> - printf ("BR%d = %08x OR%d = %08x\n",
> - i, p[0], i, p[1]);
> - } else {
> - printf ("BR%d = %08x OR%d = %08x\n",
> - i, p[0], i, p[1]);
> - }
> - }
> -
> - printf ("MAR = %08x", memctl->memc_mar);
> - printf (" MCR = %08x\n", memctl->memc_mcr);
> - printf ("MAMR = %08x MBMR = %08x",
> - memctl->memc_mamr, memctl->memc_mbmr);
> - printf ("\nMSTAT = %04x\n", memctl->memc_mstat);
> - printf ("MPTPR = %04x MDR = %08x\n",
> - memctl->memc_mptpr, memctl->memc_mdr);
> + for (i = 0; i < nbanks; i++, p += 2)
> + printf("BR%-2d = %08x OR%-2d = %08x\n",
> + i, in_be32(p), i, in_be32(p + 1));
> +
> + printf("MAR = %08x", in_be32(&memctl->memc_mar));
> + printf(" MCR = %08x\n", in_be32(&memctl->memc_mcr));
> + printf("MAMR = %08x MBMR = %08x",
> + in_be32(&memctl->memc_mamr), in_be32(&memctl->memc_mbmr));
> + printf("\nMSTAT = %04x\n", in_be16(&memctl->memc_mstat));
> + printf("MPTPR = %04x MDR = %08x\n",
> + in_be16(&memctl->memc_mptpr), in_be32(&memctl->memc_mdr));
> return 0;
> }
>
> int
> do_carinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
> {
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> -
> - volatile car8xx_t *car = &immap->im_clkrst;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + car8xx_t __iomem *car = &immap->im_clkrst;
>
> - printf ("SCCR = %08x\n", car->car_sccr);
> - printf ("PLPRCR= %08x\n", car->car_plprcr);
> - printf ("RSR = %08x\n", car->car_rsr);
> + printf("SCCR = %08x\n", in_be32(&car->car_sccr));
> + printf("PLPRCR= %08x\n", in_be32(&car->car_plprcr));
> + printf("RSR = %08x\n", in_be32(&car->car_rsr));
> return 0;
> }
>
> @@ -130,11 +126,10 @@ static void binary (char *label, uint value, int nbits)
> int
> do_iopinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
> {
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> -
> - volatile iop8xx_t *iop = &immap->im_ioport;
> - volatile ushort *l, *r;
> - volatile uint *R;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + iop8xx_t __iomem *iop = &immap->im_ioport;
> + ushort __iomem *l, *r;
> + uint __iomem *R;
>
> counter = 0;
> header ();
> @@ -145,14 +140,14 @@ do_iopinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
>
> l = &iop->iop_padir;
> R = &immap->im_cpm.cp_pbdir;
> - binary ("PA_DIR", *l++, PA_NBITS);
> - binary ("PB_DIR", *R++, PB_NBITS);
> - binary ("PA_PAR", *l++, PA_NBITS);
> - binary ("PB_PAR", *R++, PB_NBITS);
> - binary ("PA_ODR", *l++, PA_NB_ODR);
> - binary ("PB_ODR", *R++, PB_NB_ODR);
> - binary ("PA_DAT", *l++, PA_NBITS);
> - binary ("PB_DAT", *R++, PB_NBITS);
> + binary("PA_DIR", in_be16(l++), PA_NBITS);
> + binary("PB_DIR", in_be32(R++), PB_NBITS);
> + binary("PA_PAR", in_be16(l++), PA_NBITS);
> + binary("PB_PAR", in_be32(R++), PB_NBITS);
> + binary("PA_ODR", in_be16(l++), PA_NB_ODR);
> + binary("PB_ODR", in_be32(R++), PB_NB_ODR);
> + binary("PA_DAT", in_be16(l++), PA_NBITS);
> + binary("PB_DAT", in_be32(R++), PB_NBITS);
>
> header ();
>
> @@ -162,16 +157,16 @@ do_iopinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
>
> l = &iop->iop_pcdir;
> r = &iop->iop_pddir;
> - binary ("PC_DIR", *l++, PC_NBITS);
> - binary ("PD_DIR", *r++, PD_NBITS);
> - binary ("PC_PAR", *l++, PC_NBITS);
> - binary ("PD_PAR", *r++, PD_NBITS);
> - binary ("PC_SO ", *l++, PC_NBITS);
> - binary (" ", 0, 0);
> + binary("PC_DIR", in_be16(l++), PC_NBITS);
> + binary("PD_DIR", in_be16(r++), PD_NBITS);
> + binary("PC_PAR", in_be16(l++), PC_NBITS);
> + binary("PD_PAR", in_be16(r++), PD_NBITS);
> + binary("PC_SO ", in_be16(l++), PC_NBITS);
> + binary(" ", 0, 0);
> r++;
> - binary ("PC_DAT", *l++, PC_NBITS);
> - binary ("PD_DAT", *r++, PD_NBITS);
> - binary ("PC_INT", *l++, PC_NBITS);
> + binary("PC_DAT", in_be16(l++), PC_NBITS);
> + binary("PD_DAT", in_be16(r++), PD_NBITS);
> + binary("PC_INT", in_be16(l++), PC_NBITS);
>
> header ();
> return 0;
> @@ -343,14 +338,13 @@ static void prbrg (int n, uint val)
> int
> do_brginfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
> {
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> -
> - volatile cpm8xx_t *cp = &immap->im_cpm;
> - volatile uint *p = &cp->cp_brgc1;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + cpm8xx_t __iomem *cp = &immap->im_cpm;
> + uint __iomem *p = &cp->cp_brgc1;
> int i = 1;
>
> while (i <= 4)
> - prbrg (i++, *p++);
> + prbrg(i++, in_be32(p++));
>
> return 0;
> }
> diff --git a/arch/powerpc/cpu/mpc8xx/interrupts.c b/arch/powerpc/cpu/mpc8xx/interrupts.c
> index f090ad9ecb..db6df74b5e 100644
> --- a/arch/powerpc/cpu/mpc8xx/interrupts.c
> +++ b/arch/powerpc/cpu/mpc8xx/interrupts.c
> @@ -9,6 +9,7 @@
> #include <mpc8xx.h>
> #include <mpc8xx_irq.h>
> #include <asm/processor.h>
> +#include <asm/io.h>
> #include <commproc.h>
>
> /************************************************************************/
> @@ -31,12 +32,12 @@ static void cpm_interrupt (void *regs);
>
> int interrupt_init_cpu (unsigned *decrementer_count)
> {
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> *decrementer_count = get_tbclk () / CONFIG_SYS_HZ;
>
> /* disable all interrupts */
> - immr->im_siu_conf.sc_simask = 0;
> + out_be32(&immr->im_siu_conf.sc_simask, 0);
>
> /* Configure CPM interrupts */
> cpm_interrupt_init ();
> @@ -51,25 +52,24 @@ int interrupt_init_cpu (unsigned *decrementer_count)
> */
> void external_interrupt (struct pt_regs *regs)
> {
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
> int irq;
> - ulong simask, newmask;
> + ulong simask;
> ulong vec, v_bit;
>
> /*
> * read the SIVEC register and shift the bits down
> * to get the irq number
> */
> - vec = immr->im_siu_conf.sc_sivec;
> + vec = in_be32(&immr->im_siu_conf.sc_sivec);
> irq = vec >> 26;
> v_bit = 0x80000000UL >> irq;
>
> /*
> * Read Interrupt Mask Register and Mask Interrupts
> */
> - simask = immr->im_siu_conf.sc_simask;
> - newmask = simask & (~(0xFFFF0000 >> irq));
> - immr->im_siu_conf.sc_simask = newmask;
> + simask = in_be32(&immr->im_siu_conf.sc_simask);
> + clrbits_be32(&immr->im_siu_conf.sc_simask, 0xFFFF0000 >> irq);
>
> if (!(irq & 0x1)) { /* External Interrupt ? */
> ulong siel;
> @@ -77,13 +77,13 @@ void external_interrupt (struct pt_regs *regs)
> /*
> * Read Interrupt Edge/Level Register
> */
> - siel = immr->im_siu_conf.sc_siel;
> + siel = in_be32(&immr->im_siu_conf.sc_siel);
>
> if (siel & v_bit) { /* edge triggered interrupt ? */
> /*
> * Rewrite SIPEND Register to clear interrupt
> */
> - immr->im_siu_conf.sc_sipend = v_bit;
> + out_be32(&immr->im_siu_conf.sc_sipend, v_bit);
> }
> }
>
> @@ -98,7 +98,7 @@ void external_interrupt (struct pt_regs *regs)
> /*
> * Re-Enable old Interrupt Mask
> */
> - immr->im_siu_conf.sc_simask = simask;
> + out_be32(&immr->im_siu_conf.sc_simask, simask);
> }
>
> /************************************************************************/
> @@ -108,28 +108,28 @@ void external_interrupt (struct pt_regs *regs)
> */
> static void cpm_interrupt (void *regs)
> {
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
> uint vec;
>
> /*
> * Get the vector by setting the ACK bit
> * and then reading the register.
> */
> - immr->im_cpic.cpic_civr = 1;
> - vec = immr->im_cpic.cpic_civr;
> + out_be16(&immr->im_cpic.cpic_civr, 1);
> + vec = in_be16(&immr->im_cpic.cpic_civr);
> vec >>= 11;
>
> if (cpm_vecs[vec].handler != NULL) {
> (*cpm_vecs[vec].handler) (cpm_vecs[vec].arg);
> } else {
> - immr->im_cpic.cpic_cimr &= ~(1 << vec);
> + clrbits_be32(&immr->im_cpic.cpic_cimr, 1 << vec);
> printf ("Masking bogus CPM interrupt vector 0x%x\n", vec);
> }
> /*
> * After servicing the interrupt,
> * we have to remove the status indicator.
> */
> - immr->im_cpic.cpic_cisr |= (1 << vec);
> + setbits_be32(&immr->im_cpic.cpic_cisr, 1 << vec);
> }
>
> /*
> @@ -149,7 +149,7 @@ static void cpm_error_interrupt (void *dummy)
> void irq_install_handler (int vec, interrupt_handler_t * handler,
> void *arg)
> {
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> if ((vec & CPMVEC_OFFSET) != 0) {
> /* CPM interrupt */
> @@ -161,7 +161,7 @@ void irq_install_handler (int vec, interrupt_handler_t * handler,
> }
> cpm_vecs[vec].handler = handler;
> cpm_vecs[vec].arg = arg;
> - immr->im_cpic.cpic_cimr |= (1 << vec);
> + setbits_be32(&immr->im_cpic.cpic_cimr, 1 << vec);
> } else {
> /* SIU interrupt */
> if (irq_vecs[vec].handler != NULL) {
> @@ -172,23 +172,23 @@ void irq_install_handler (int vec, interrupt_handler_t * handler,
> }
> irq_vecs[vec].handler = handler;
> irq_vecs[vec].arg = arg;
> - immr->im_siu_conf.sc_simask |= 1 << (31 - vec);
> + setbits_be32(&immr->im_siu_conf.sc_simask, 1 << (31 - vec));
> }
> }
>
> void irq_free_handler (int vec)
> {
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> if ((vec & CPMVEC_OFFSET) != 0) {
> /* CPM interrupt */
> vec &= 0xffff;
> - immr->im_cpic.cpic_cimr &= ~(1 << vec);
> + clrbits_be32(&immr->im_cpic.cpic_cimr, 1 << vec);
> cpm_vecs[vec].handler = NULL;
> cpm_vecs[vec].arg = NULL;
> } else {
> /* SIU interrupt */
> - immr->im_siu_conf.sc_simask &= ~(1 << (31 - vec));
> + clrbits_be32(&immr->im_siu_conf.sc_simask, 1 << (31 - vec));
> irq_vecs[vec].handler = NULL;
> irq_vecs[vec].arg = NULL;
> }
> @@ -198,26 +198,25 @@ void irq_free_handler (int vec)
>
> static void cpm_interrupt_init (void)
> {
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + uint cicr;
>
> /*
> * Initialize the CPM interrupt controller.
> */
>
> - immr->im_cpic.cpic_cicr =
> - (CICR_SCD_SCC4 |
> - CICR_SCC_SCC3 |
> - CICR_SCB_SCC2 |
> - CICR_SCA_SCC1) | ((CPM_INTERRUPT / 2) << 13) | CICR_HP_MASK;
> + cicr = CICR_SCD_SCC4 | CICR_SCC_SCC3 | CICR_SCB_SCC2 | CICR_SCA_SCC1 |
> + ((CPM_INTERRUPT / 2) << 13) | CICR_HP_MASK;
>
> - immr->im_cpic.cpic_cimr = 0;
> + out_be32(&immr->im_cpic.cpic_cicr, cicr);
> + out_be32(&immr->im_cpic.cpic_cimr, 0);
>
> /*
> * Install the error handler.
> */
> irq_install_handler (CPMVEC_ERROR, cpm_error_interrupt, NULL);
>
> - immr->im_cpic.cpic_cicr |= CICR_IEN;
> + setbits_be32(&immr->im_cpic.cpic_cicr, CICR_IEN);
>
> /*
> * Install the cpm interrupt handler
> @@ -234,10 +233,10 @@ static void cpm_interrupt_init (void)
> */
> void timer_interrupt_cpu (struct pt_regs *regs)
> {
> - volatile immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> /* Reset Timer Expired and Timers Interrupt Status */
> - immr->im_clkrstk.cark_plprcrk = KAPWR_KEY;
> + out_be32(&immr->im_clkrstk.cark_plprcrk, KAPWR_KEY);
> __asm__ ("nop");
> /*
> Clear TEXPS (and TMIST on older chips). SPLSS (on older
> @@ -253,7 +252,7 @@ void timer_interrupt_cpu (struct pt_regs *regs)
> to itself. If a bit value should be preserved, read the
> register, ZERO the bit and write, not OR, the result back.
> */
> - immr->im_clkrst.car_plprcr = immr->im_clkrst.car_plprcr;
> + setbits_be32(&immr->im_clkrst.car_plprcr, 0);
> }
>
> /************************************************************************/
> diff --git a/arch/powerpc/cpu/mpc8xx/reginfo.c b/arch/powerpc/cpu/mpc8xx/reginfo.c
> index b5a962431e..48615cad01 100644
> --- a/arch/powerpc/cpu/mpc8xx/reginfo.c
> +++ b/arch/powerpc/cpu/mpc8xx/reginfo.c
> @@ -7,56 +7,62 @@
>
> #include <common.h>
> #include <mpc8xx.h>
> +#include <asm/io.h>
>
> void mpc8xx_reginfo(void)
> {
> - volatile immap_t *immap = (immap_t *)CONFIG_SYS_IMMR;
> - volatile memctl8xx_t *memctl = &immap->im_memctl;
> - volatile sysconf8xx_t *sysconf = &immap->im_siu_conf;
> - volatile sit8xx_t *timers = &immap->im_sit;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + memctl8xx_t __iomem *memctl = &immap->im_memctl;
> + sysconf8xx_t __iomem *sysconf = &immap->im_siu_conf;
> + sit8xx_t __iomem *timers = &immap->im_sit;
>
> /* Hopefully more PowerPC knowledgable people will add code to display
> * other useful registers
> */
>
> printf ("\nSystem Configuration registers\n"
> -
> "\tIMMR\t0x%08X\n", get_immr(0));
>
> - printf("\tSIUMCR\t0x%08X", sysconf->sc_siumcr);
> - printf("\tSYPCR\t0x%08X\n",sysconf->sc_sypcr);
> + printf("\tSIUMCR\t0x%08X", in_be32(&sysconf->sc_siumcr));
> + printf("\tSYPCR\t0x%08X\n", in_be32(&sysconf->sc_sypcr));
>
> - printf("\tSWT\t0x%08X", sysconf->sc_swt);
> - printf("\tSWSR\t0x%04X\n", sysconf->sc_swsr);
> + printf("\tSWT\t0x%08X", in_be32(&sysconf->sc_swt));
> + printf("\tSWSR\t0x%04X\n", in_be16(&sysconf->sc_swsr));
>
> printf("\tSIPEND\t0x%08X\tSIMASK\t0x%08X\n",
> - sysconf->sc_sipend, sysconf->sc_simask);
> + in_be32(&sysconf->sc_sipend), in_be32(&sysconf->sc_simask));
> printf("\tSIEL\t0x%08X\tSIVEC\t0x%08X\n",
> - sysconf->sc_siel, sysconf->sc_sivec);
> + in_be32(&sysconf->sc_siel), in_be32(&sysconf->sc_sivec));
> printf("\tTESR\t0x%08X\tSDCR\t0x%08X\n",
> - sysconf->sc_tesr, sysconf->sc_sdcr);
> -
> - printf ("Memory Controller Registers\n"
> + in_be32(&sysconf->sc_tesr), in_be32(&sysconf->sc_sdcr));
>
> - "\tBR0\t0x%08X\tOR0\t0x%08X \n", memctl->memc_br0, memctl->memc_or0);
> - printf("\tBR1\t0x%08X\tOR1\t0x%08X \n", memctl->memc_br1, memctl->memc_or1);
> - printf("\tBR2\t0x%08X\tOR2\t0x%08X \n", memctl->memc_br2, memctl->memc_or2);
> - printf("\tBR3\t0x%08X\tOR3\t0x%08X \n", memctl->memc_br3, memctl->memc_or3);
> - printf("\tBR4\t0x%08X\tOR4\t0x%08X \n", memctl->memc_br4, memctl->memc_or4);
> - printf("\tBR5\t0x%08X\tOR5\t0x%08X \n", memctl->memc_br5, memctl->memc_or5);
> - printf("\tBR6\t0x%08X\tOR6\t0x%08X \n", memctl->memc_br6, memctl->memc_or6);
> - printf("\tBR7\t0x%08X\tOR7\t0x%08X \n", memctl->memc_br7, memctl->memc_or7);
> - printf ("\n"
> - "\tmamr\t0x%08X\tmbmr\t0x%08X \n",
> - memctl->memc_mamr, memctl->memc_mbmr );
> - printf("\tmstat\t0x%08X\tmptpr\t0x%08X \n",
> - memctl->memc_mstat, memctl->memc_mptpr );
> - printf("\tmdr\t0x%08X \n", memctl->memc_mdr);
> + printf("Memory Controller Registers\n");
> + printf("\tBR0\t0x%08X\tOR0\t0x%08X\n", in_be32(&memctl->memc_br0),
> + in_be32(&memctl->memc_or0));
> + printf("\tBR1\t0x%08X\tOR1\t0x%08X\n", in_be32(&memctl->memc_br1),
> + in_be32(&memctl->memc_or1));
> + printf("\tBR2\t0x%08X\tOR2\t0x%08X\n", in_be32(&memctl->memc_br2),
> + in_be32(&memctl->memc_or2));
> + printf("\tBR3\t0x%08X\tOR3\t0x%08X\n", in_be32(&memctl->memc_br3),
> + in_be32(&memctl->memc_or3));
> + printf("\tBR4\t0x%08X\tOR4\t0x%08X\n", in_be32(&memctl->memc_br4),
> + in_be32(&memctl->memc_or4));
> + printf("\tBR5\t0x%08X\tOR5\t0x%08X\n", in_be32(&memctl->memc_br5),
> + in_be32(&memctl->memc_or5));
> + printf("\tBR6\t0x%08X\tOR6\t0x%08X\n", in_be32(&memctl->memc_br6),
> + in_be32(&memctl->memc_or6));
> + printf("\tBR7\t0x%08X\tOR7\t0x%08X\n", in_be32(&memctl->memc_br7),
> + in_be32(&memctl->memc_or7));
> + printf("\n\tmamr\t0x%08X\tmbmr\t0x%08X\n", in_be32(&memctl->memc_mamr),
> + in_be32(&memctl->memc_mbmr));
> + printf("\tmstat\t0x%04X\tmptpr\t0x%04X\n", in_be16(&memctl->memc_mstat),
> + in_be16(&memctl->memc_mptpr));
> + printf("\tmdr\t0x%08X\n", in_be32(&memctl->memc_mdr));
>
> - printf ("\nSystem Integration Timers\n"
> - "\tTBSCR\t0x%08X\tRTCSC\t0x%08X \n",
> - timers->sit_tbscr, timers->sit_rtcsc);
> - printf("\tPISCR\t0x%08X \n", timers->sit_piscr);
> + printf("\nSystem Integration Timers\n");
> + printf("\tTBSCR\t0x%04X\tRTCSC\t0x%04X\n",
> + in_be16(&timers->sit_tbscr), in_be16(&timers->sit_rtcsc));
> + printf("\tPISCR\t0x%04X\n", in_be16(&timers->sit_piscr));
>
> /*
> * May be some CPM info here?
> diff --git a/arch/powerpc/cpu/mpc8xx/serial.c b/arch/powerpc/cpu/mpc8xx/serial.c
> index d4f1a41a1a..598ca2a7b0 100644
> --- a/arch/powerpc/cpu/mpc8xx/serial.c
> +++ b/arch/powerpc/cpu/mpc8xx/serial.c
> @@ -20,11 +20,13 @@ DECLARE_GLOBAL_DATA_PTR;
> #define SMC_INDEX 0
> #define PROFF_SMC PROFF_SMC1
> #define CPM_CR_CH_SMC CPM_CR_CH_SMC1
> +#define IOPINS 0xc0
>
> #elif defined(CONFIG_8xx_CONS_SMC2) /* Console on SMC2 */
> #define SMC_INDEX 1
> #define PROFF_SMC PROFF_SMC2
> #define CPM_CR_CH_SMC CPM_CR_CH_SMC2
> +#define IOPINS 0xc00
>
> #endif /* CONFIG_8xx_CONS_SMCx */
>
> @@ -37,15 +39,15 @@ DECLARE_GLOBAL_DATA_PTR;
> #endif
> #endif
>
> -typedef volatile struct serialbuffer {
> +struct serialbuffer {
> cbd_t rxbd; /* Rx BD */
> cbd_t txbd; /* Tx BD */
> uint rxindex; /* index for next character to read */
> - volatile uchar rxbuf[CONFIG_SYS_SMC_RXBUFLEN];/* rx buffers */
> - volatile uchar txbuf; /* tx buffers */
> -} serialbuffer_t;
> + uchar rxbuf[CONFIG_SYS_SMC_RXBUFLEN];/* rx buffers */
> + uchar txbuf; /* tx buffers */
> +};
>
> -static void serial_setdivisor(volatile cpm8xx_t *cp)
> +static void serial_setdivisor(cpm8xx_t __iomem *cp)
> {
> int divisor=(gd->cpu_clk + 8*gd->baudrate)/16/gd->baudrate;
>
> @@ -58,11 +60,11 @@ static void serial_setdivisor(volatile cpm8xx_t *cp)
> divisor /= CONFIG_SYS_BRGCLK_PRESCALE;
> #endif
>
> - if(divisor<=0x1000) {
> - cp->cp_brgc1=((divisor-1)<<1) | CPM_BRG_EN;
> - } else {
> - cp->cp_brgc1=((divisor/16-1)<<1) | CPM_BRG_EN | CPM_BRG_DIV16;
> - }
> + if (divisor <= 0x1000)
> + out_be32(&cp->cp_brgc1, ((divisor - 1) << 1) | CPM_BRG_EN);
> + else
> + out_be32(&cp->cp_brgc1, ((divisor / 16 - 1) << 1) | CPM_BRG_EN |
> + CPM_BRG_DIV16);
> }
>
> /*
> @@ -72,8 +74,8 @@ static void serial_setdivisor(volatile cpm8xx_t *cp)
>
> static void smc_setbrg (void)
> {
> - volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
> - volatile cpm8xx_t *cp = &(im->im_cpm);
> + immap_t __iomem *im = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + cpm8xx_t __iomem *cp = &(im->im_cpm);
>
> /* Set up the baud rate generator.
> * See 8xx_io/commproc.c for details.
> @@ -81,117 +83,107 @@ static void smc_setbrg (void)
> * Wire BRG1 to SMCx
> */
>
> - cp->cp_simode = 0x00000000;
> + out_be32(&cp->cp_simode, 0);
>
> serial_setdivisor(cp);
> }
>
> static int smc_init (void)
> {
> - volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
> - volatile smc_t *sp;
> - volatile smc_uart_t *up;
> - volatile cpm8xx_t *cp = &(im->im_cpm);
> - uint dpaddr;
> - volatile serialbuffer_t *rtx;
> + immap_t __iomem *im = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + smc_t __iomem *sp;
> + smc_uart_t __iomem *up;
> + cpm8xx_t __iomem *cp = &(im->im_cpm);
> + struct serialbuffer __iomem *rtx;
>
> /* initialize pointers to SMC */
>
> - sp = (smc_t *) &(cp->cp_smc[SMC_INDEX]);
> - up = (smc_uart_t *) &cp->cp_dparam[PROFF_SMC];
> + sp = cp->cp_smc + SMC_INDEX;
> + up = (smc_uart_t __iomem *)&cp->cp_dparam[PROFF_SMC];
> /* Disable relocation */
> - up->smc_rpbase = 0;
> + out_be16(&up->smc_rpbase, 0);
>
> /* Disable transmitter/receiver. */
> - sp->smc_smcmr &= ~(SMCMR_REN | SMCMR_TEN);
> + clrbits_be16(&sp->smc_smcmr, SMCMR_REN | SMCMR_TEN);
>
> /* Enable SDMA. */
> - im->im_siu_conf.sc_sdcr = 1;
> + out_be32(&im->im_siu_conf.sc_sdcr, 1);
>
> /* clear error conditions */
> #ifdef CONFIG_SYS_SDSR
> - im->im_sdma.sdma_sdsr = CONFIG_SYS_SDSR;
> + out_8(&im->im_sdma.sdma_sdsr, CONFIG_SYS_SDSR);
> #else
> - im->im_sdma.sdma_sdsr = 0x83;
> + out_8(&im->im_sdma.sdma_sdsr, 0x83);
> #endif
>
> /* clear SDMA interrupt mask */
> #ifdef CONFIG_SYS_SDMR
> - im->im_sdma.sdma_sdmr = CONFIG_SYS_SDMR;
> + out_8(&im->im_sdma.sdma_sdmr, CONFIG_SYS_SDMR);
> #else
> - im->im_sdma.sdma_sdmr = 0x00;
> + out_8(&im->im_sdma.sdma_sdmr, 0x00);
> #endif
>
> -#if defined(CONFIG_8xx_CONS_SMC1)
> - /* Use Port B for SMC1 instead of other functions. */
> - cp->cp_pbpar |= 0x000000c0;
> - cp->cp_pbdir &= ~0x000000c0;
> - cp->cp_pbodr &= ~0x000000c0;
> -#else /* CONFIG_8xx_CONS_SMC2 */
> - /* Use Port B for SMC2 instead of other functions.
> - */
> - cp->cp_pbpar |= 0x00000c00;
> - cp->cp_pbdir &= ~0x00000c00;
> - cp->cp_pbodr &= ~0x00000c00;
> -#endif
> + /* Use Port B for SMCx instead of other functions. */
> + setbits_be32(&cp->cp_pbpar, IOPINS);
> + clrbits_be32(&cp->cp_pbdir, IOPINS);
> + clrbits_be16(&cp->cp_pbodr, IOPINS);
>
> /* Set the physical address of the host memory buffers in
> * the buffer descriptors.
> */
> - dpaddr = CPM_SERIAL_BASE;
> -
> - rtx = (serialbuffer_t *)&cp->cp_dpmem[dpaddr];
> + rtx = (struct serialbuffer __iomem *)&cp->cp_dpmem[CPM_SERIAL_BASE];
> /* Allocate space for two buffer descriptors in the DP ram.
> * For now, this address seems OK, but it may have to
> * change with newer versions of the firmware.
> * damm: allocating space after the two buffers for rx/tx data
> */
>
> - rtx->rxbd.cbd_bufaddr = (uint) &rtx->rxbuf;
> - rtx->rxbd.cbd_sc = 0;
> + out_be32(&rtx->rxbd.cbd_bufaddr, (__force uint)&rtx->rxbuf);
> + out_be16(&rtx->rxbd.cbd_sc, 0);
>
> - rtx->txbd.cbd_bufaddr = (uint) &rtx->txbuf;
> - rtx->txbd.cbd_sc = 0;
> + out_be32(&rtx->txbd.cbd_bufaddr, (__force uint)&rtx->txbuf);
> + out_be16(&rtx->txbd.cbd_sc, 0);
>
> /* Set up the uart parameters in the parameter ram. */
> - up->smc_rbase = dpaddr;
> - up->smc_tbase = dpaddr+sizeof(cbd_t);
> - up->smc_rfcr = SMC_EB;
> - up->smc_tfcr = SMC_EB;
> + out_be16(&up->smc_rbase, CPM_SERIAL_BASE);
> + out_be16(&up->smc_tbase, CPM_SERIAL_BASE + sizeof(cbd_t));
> + out_8(&up->smc_rfcr, SMC_EB);
> + out_8(&up->smc_tfcr, SMC_EB);
>
> /* Set UART mode, 8 bit, no parity, one stop.
> * Enable receive and transmit.
> */
> - sp->smc_smcmr = smcr_mk_clen(9) | SMCMR_SM_UART;
> + out_be16(&sp->smc_smcmr, smcr_mk_clen(9) | SMCMR_SM_UART);
>
> /* Mask all interrupts and remove anything pending.
> */
> - sp->smc_smcm = 0;
> - sp->smc_smce = 0xff;
> + out_8(&sp->smc_smcm, 0);
> + out_8(&sp->smc_smce, 0xff);
>
> /* Set up the baud rate generator */
> smc_setbrg ();
>
> /* Make the first buffer the only buffer. */
> - rtx->txbd.cbd_sc |= BD_SC_WRAP;
> - rtx->rxbd.cbd_sc |= BD_SC_EMPTY | BD_SC_WRAP;
> + setbits_be16(&rtx->txbd.cbd_sc, BD_SC_WRAP);
> + setbits_be16(&rtx->rxbd.cbd_sc, BD_SC_EMPTY | BD_SC_WRAP);
>
> /* single/multi character receive. */
> - up->smc_mrblr = CONFIG_SYS_SMC_RXBUFLEN;
> - up->smc_maxidl = CONFIG_SYS_MAXIDLE;
> - rtx->rxindex = 0;
> + out_be16(&up->smc_mrblr, CONFIG_SYS_SMC_RXBUFLEN);
> + out_be16(&up->smc_maxidl, CONFIG_SYS_MAXIDLE);
> + out_be32(&rtx->rxindex, 0);
>
> /* Initialize Tx/Rx parameters. */
> - while (cp->cp_cpcr & CPM_CR_FLG) /* wait if cp is busy */
> - ;
> + while (in_be16(&cp->cp_cpcr) & CPM_CR_FLG) /* wait if cp is busy */
> + ;
>
> - cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SMC, CPM_CR_INIT_TRX) | CPM_CR_FLG;
> + out_be16(&cp->cp_cpcr,
> + mk_cr_cmd(CPM_CR_CH_SMC, CPM_CR_INIT_TRX) | CPM_CR_FLG);
>
> - while (cp->cp_cpcr & CPM_CR_FLG) /* wait if cp is busy */
> - ;
> + while (in_be16(&cp->cp_cpcr) & CPM_CR_FLG) /* wait if cp is busy */
> + ;
>
> /* Enable transmitter/receiver. */
> - sp->smc_smcmr |= SMCMR_REN | SMCMR_TEN;
> + setbits_be16(&sp->smc_smcmr, SMCMR_REN | SMCMR_TEN);
>
> return (0);
> }
> @@ -199,28 +191,22 @@ static int smc_init (void)
> static void
> smc_putc(const char c)
> {
> - volatile smc_uart_t *up;
> - volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
> - volatile cpm8xx_t *cpmp = &(im->im_cpm);
> - volatile serialbuffer_t *rtx;
> + immap_t __iomem *im = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + cpm8xx_t __iomem *cpmp = &(im->im_cpm);
> + struct serialbuffer __iomem *rtx;
>
> if (c == '\n')
> smc_putc ('\r');
>
> - up = (smc_uart_t *)&cpmp->cp_dparam[PROFF_SMC];
> -
> - rtx = (serialbuffer_t *)&cpmp->cp_dpmem[up->smc_rbase];
> + rtx = (struct serialbuffer __iomem *)&cpmp->cp_dpmem[CPM_SERIAL_BASE];
>
> /* Wait for last character to go. */
> - rtx->txbuf = c;
> - rtx->txbd.cbd_datlen = 1;
> - rtx->txbd.cbd_sc |= BD_SC_READY;
> - __asm__("eieio");
> + out_8(&rtx->txbuf, c);
> + out_be16(&rtx->txbd.cbd_datlen, 1);
> + setbits_be16(&rtx->txbd.cbd_sc, BD_SC_READY);
>
> - while (rtx->txbd.cbd_sc & BD_SC_READY) {
> + while (in_be16(&rtx->txbd.cbd_sc) & BD_SC_READY)
> WATCHDOG_RESET ();
> - __asm__("eieio");
> - }
> }
>
> static void
> @@ -234,46 +220,44 @@ smc_puts (const char *s)
> static int
> smc_getc(void)
> {
> - volatile smc_uart_t *up;
> - volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
> - volatile cpm8xx_t *cpmp = &(im->im_cpm);
> - volatile serialbuffer_t *rtx;
> + immap_t __iomem *im = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + cpm8xx_t __iomem *cpmp = &(im->im_cpm);
> + struct serialbuffer __iomem *rtx;
> unsigned char c;
> + uint rxindex;
>
> - up = (smc_uart_t *)&cpmp->cp_dparam[PROFF_SMC];
> - rtx = (serialbuffer_t *)&cpmp->cp_dpmem[up->smc_rbase];
> + rtx = (struct serialbuffer __iomem *)&cpmp->cp_dpmem[CPM_SERIAL_BASE];
>
> /* Wait for character to show up. */
> - while (rtx->rxbd.cbd_sc & BD_SC_EMPTY)
> + while (in_be16(&rtx->rxbd.cbd_sc) & BD_SC_EMPTY)
> WATCHDOG_RESET ();
>
> /* the characters are read one by one,
> * use the rxindex to know the next char to deliver
> */
> - c = *(unsigned char *) (rtx->rxbd.cbd_bufaddr+rtx->rxindex);
> - rtx->rxindex++;
> + rxindex = in_be32(&rtx->rxindex);
> + c = in_8(rtx->rxbuf + rxindex);
> + rxindex++;
>
> /* check if all char are readout, then make prepare for next receive */
> - if (rtx->rxindex >= rtx->rxbd.cbd_datlen) {
> - rtx->rxindex = 0;
> - rtx->rxbd.cbd_sc |= BD_SC_EMPTY;
> + if (rxindex >= in_be16(&rtx->rxbd.cbd_datlen)) {
> + rxindex = 0;
> + setbits_be16(&rtx->rxbd.cbd_sc, BD_SC_EMPTY);
> }
> + out_be32(&rtx->rxindex, rxindex);
> return(c);
> }
>
> static int
> smc_tstc(void)
> {
> - volatile smc_uart_t *up;
> - volatile immap_t *im = (immap_t *)CONFIG_SYS_IMMR;
> - volatile cpm8xx_t *cpmp = &(im->im_cpm);
> - volatile serialbuffer_t *rtx;
> -
> - up = (smc_uart_t *)&cpmp->cp_dparam[PROFF_SMC];
> + immap_t __iomem *im = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + cpm8xx_t __iomem *cpmp = &(im->im_cpm);
> + struct serialbuffer __iomem *rtx;
>
> - rtx = (serialbuffer_t *)&cpmp->cp_dpmem[up->smc_rbase];
> + rtx = (struct serialbuffer __iomem *)&cpmp->cp_dpmem[CPM_SERIAL_BASE];
>
> - return !(rtx->rxbd.cbd_sc & BD_SC_EMPTY);
> + return !(in_be16(&rtx->rxbd.cbd_sc) & BD_SC_EMPTY);
> }
>
> struct serial_device serial_smc_device =
> diff --git a/arch/powerpc/cpu/mpc8xx/speed.c b/arch/powerpc/cpu/mpc8xx/speed.c
> index 751c089a6d..c91427e904 100644
> --- a/arch/powerpc/cpu/mpc8xx/speed.c
> +++ b/arch/powerpc/cpu/mpc8xx/speed.c
> @@ -8,6 +8,7 @@
> #include <common.h>
> #include <mpc8xx.h>
> #include <asm/processor.h>
> +#include <asm/io.h>
>
> DECLARE_GLOBAL_DATA_PTR;
>
> @@ -38,8 +39,8 @@ void get_brgclk(uint sccr)
> int get_clocks (void)
> {
> uint immr = get_immr (0); /* Return full IMMR contents */
> - volatile immap_t *immap = (immap_t *) (immr & 0xFFFF0000);
> - uint sccr = immap->im_clkrst.car_sccr;
> + immap_t __iomem *immap = (immap_t __iomem *)(immr & 0xFFFF0000);
> + uint sccr = in_be32(&immap->im_clkrst.car_sccr);
> /*
> * If for some reason measuring the gclk frequency won't
> * work, we return the hardwired value.
> diff --git a/arch/powerpc/cpu/mpc8xx/spi.c b/arch/powerpc/cpu/mpc8xx/spi.c
> index c7863ecd09..e7d197f968 100644
> --- a/arch/powerpc/cpu/mpc8xx/spi.c
> +++ b/arch/powerpc/cpu/mpc8xx/spi.c
> @@ -44,6 +44,9 @@
> #define CONFIG_SYS_SPI_INIT_OFFSET 0xB00
> #endif
>
> +#define CPM_SPI_BASE_RX CPM_SPI_BASE
> +#define CPM_SPI_BASE_TX (CPM_SPI_BASE + sizeof(cbd_t))
> +
> /* -------------------
> * Function prototypes
> * ------------------- */
> @@ -80,19 +83,13 @@ static uchar *txbuf =
> * *********************************************************************** */
> void spi_init_f (void)
> {
> - unsigned int dpaddr;
> -
> - volatile spi_t *spi;
> - volatile immap_t *immr;
> - volatile cpm8xx_t *cp;
> - volatile cbd_t *tbdf, *rbdf;
> -
> - immr = (immap_t *) CONFIG_SYS_IMMR;
> - cp = (cpm8xx_t *) &immr->im_cpm;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + cpm8xx_t __iomem *cp = &immr->im_cpm;
> + spi_t __iomem *spi = (spi_t __iomem *)&cp->cp_dparam[PROFF_SPI];
> + cbd_t __iomem *tbdf, *rbdf;
>
> - spi = (spi_t *)&cp->cp_dparam[PROFF_SPI];
> /* Disable relocation */
> - spi->spi_rpbase = 0;
> + out_be16(&spi->spi_rpbase, 0);
>
> /* 1 */
> /* ------------------------------------------------
> @@ -107,8 +104,7 @@ void spi_init_f (void)
> * PBPAR[30] = 1 [0x00000002] -> PERI: (SPICLK)
> * PBPAR[31] = 0 [0x00000001] -> GPIO: (CS for PCUE/CCM-EEPROM)
> * -------------------------------------------- */
> - cp->cp_pbpar |= 0x0000000E; /* set bits */
> - cp->cp_pbpar &= ~0x00000001; /* reset bit */
> + clrsetbits_be32(&cp->cp_pbpar, 0x00000001, 0x0000000E); /* set bits */
>
> /* ----------------------------------------------
> * In/Out or per. Function 0/1
> @@ -117,7 +113,7 @@ void spi_init_f (void)
> * PBDIR[30] = 1 [0x00000002] -> PERI1: SPICLK
> * PBDIR[31] = 1 [0x00000001] -> GPIO OUT: CS for PCUE/CCM-EEPROM
> * ---------------------------------------------- */
> - cp->cp_pbdir |= 0x0000000F;
> + setbits_be32(&cp->cp_pbdir, 0x0000000F);
>
> /* ----------------------------------------------
> * open drain or active output
> @@ -127,29 +123,26 @@ void spi_init_f (void)
> * PBODR[31] = 0 [0x00000001] -> active output: GPIO OUT: CS for PCUE/CCM
> * ---------------------------------------------- */
>
> - cp->cp_pbodr |= 0x00000008;
> - cp->cp_pbodr &= ~0x00000007;
> + clrsetbits_be16(&cp->cp_pbodr, 0x00000007, 0x00000008);
>
> /* Initialize the parameter ram.
> * We need to make sure many things are initialized to zero
> */
> - spi->spi_rstate = 0;
> - spi->spi_rdp = 0;
> - spi->spi_rbptr = 0;
> - spi->spi_rbc = 0;
> - spi->spi_rxtmp = 0;
> - spi->spi_tstate = 0;
> - spi->spi_tdp = 0;
> - spi->spi_tbptr = 0;
> - spi->spi_tbc = 0;
> - spi->spi_txtmp = 0;
> -
> - dpaddr = CPM_SPI_BASE;
> + out_be32(&spi->spi_rstate, 0);
> + out_be32(&spi->spi_rdp, 0);
> + out_be16(&spi->spi_rbptr, 0);
> + out_be16(&spi->spi_rbc, 0);
> + out_be32(&spi->spi_rxtmp, 0);
> + out_be32(&spi->spi_tstate, 0);
> + out_be32(&spi->spi_tdp, 0);
> + out_be16(&spi->spi_tbptr, 0);
> + out_be16(&spi->spi_tbc, 0);
> + out_be32(&spi->spi_txtmp, 0);
>
> /* 3 */
> /* Set up the SPI parameters in the parameter ram */
> - spi->spi_rbase = dpaddr;
> - spi->spi_tbase = dpaddr + sizeof (cbd_t);
> + out_be16(&spi->spi_rbase, CPM_SPI_BASE_RX);
> + out_be16(&spi->spi_tbase, CPM_SPI_BASE_TX);
>
> /***********IMPORTANT******************/
>
> @@ -160,45 +153,47 @@ void spi_init_f (void)
> * is missing from the sample I2C driver. If you dont
> * initialize these pointers, the kernel hangs.
> */
> - spi->spi_rbptr = spi->spi_rbase;
> - spi->spi_tbptr = spi->spi_tbase;
> + out_be16(&spi->spi_rbptr, CPM_SPI_BASE_RX);
> + out_be16(&spi->spi_tbptr, CPM_SPI_BASE_TX);
>
> /* 4 */
> /* Init SPI Tx + Rx Parameters */
> - while (cp->cp_cpcr & CPM_CR_FLG)
> + while (in_be16(&cp->cp_cpcr) & CPM_CR_FLG)
> ;
> - cp->cp_cpcr = mk_cr_cmd(CPM_CR_CH_SPI, CPM_CR_INIT_TRX) | CPM_CR_FLG;
> - while (cp->cp_cpcr & CPM_CR_FLG)
> +
> + out_be16(&cp->cp_cpcr, mk_cr_cmd(CPM_CR_CH_SPI, CPM_CR_INIT_TRX) |
> + CPM_CR_FLG);
> + while (in_be16(&cp->cp_cpcr) & CPM_CR_FLG)
> ;
>
> /* 5 */
> /* Set SDMA configuration register */
> - immr->im_siu_conf.sc_sdcr = 0x0001;
> + out_be32(&immr->im_siu_conf.sc_sdcr, 0x0001);
>
> /* 6 */
> /* Set to big endian. */
> - spi->spi_tfcr = SMC_EB;
> - spi->spi_rfcr = SMC_EB;
> + out_8(&spi->spi_tfcr, SMC_EB);
> + out_8(&spi->spi_rfcr, SMC_EB);
>
> /* 7 */
> /* Set maximum receive size. */
> - spi->spi_mrblr = MAX_BUFFER;
> + out_be16(&spi->spi_mrblr, MAX_BUFFER);
>
> /* 8 + 9 */
> /* tx and rx buffer descriptors */
> - tbdf = (cbd_t *) & cp->cp_dpmem[spi->spi_tbase];
> - rbdf = (cbd_t *) & cp->cp_dpmem[spi->spi_rbase];
> + tbdf = (cbd_t __iomem *)&cp->cp_dpmem[CPM_SPI_BASE_TX];
> + rbdf = (cbd_t __iomem *)&cp->cp_dpmem[CPM_SPI_BASE_RX];
>
> - tbdf->cbd_sc &= ~BD_SC_READY;
> - rbdf->cbd_sc &= ~BD_SC_EMPTY;
> + clrbits_be16(&tbdf->cbd_sc, BD_SC_READY);
> + clrbits_be16(&rbdf->cbd_sc, BD_SC_EMPTY);
>
> /* Set the bd's rx and tx buffer address pointers */
> - rbdf->cbd_bufaddr = (ulong) rxbuf;
> - tbdf->cbd_bufaddr = (ulong) txbuf;
> + out_be32(&rbdf->cbd_bufaddr, (ulong)rxbuf);
> + out_be32(&tbdf->cbd_bufaddr, (ulong)txbuf);
>
> /* 10 + 11 */
> - cp->cp_spim = 0; /* Mask all SPI events */
> - cp->cp_spie = SPI_EMASK; /* Clear all SPI events */
> + out_8(&cp->cp_spim, 0); /* Mask all SPI events */
> + out_8(&cp->cp_spie, SPI_EMASK); /* Clear all SPI events */
>
> return;
> }
> @@ -216,28 +211,24 @@ void spi_init_f (void)
> * *********************************************************************** */
> void spi_init_r (void)
> {
> - volatile cpm8xx_t *cp;
> - volatile spi_t *spi;
> - volatile immap_t *immr;
> - volatile cbd_t *tbdf, *rbdf;
> -
> - immr = (immap_t *) CONFIG_SYS_IMMR;
> - cp = (cpm8xx_t *) &immr->im_cpm;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + cpm8xx_t __iomem *cp = &immr->im_cpm;
> + spi_t __iomem *spi = (spi_t __iomem *)&cp->cp_dparam[PROFF_SPI];
> + cbd_t __iomem *tbdf, *rbdf;
>
> - spi = (spi_t *)&cp->cp_dparam[PROFF_SPI];
> /* Disable relocation */
> - spi->spi_rpbase = 0;
> + out_be16(&spi->spi_rpbase, 0);
>
> /* tx and rx buffer descriptors */
> - tbdf = (cbd_t *) & cp->cp_dpmem[spi->spi_tbase];
> - rbdf = (cbd_t *) & cp->cp_dpmem[spi->spi_rbase];
> + tbdf = (cbd_t __iomem *)&cp->cp_dpmem[CPM_SPI_BASE_TX];
> + rbdf = (cbd_t __iomem *)&cp->cp_dpmem[CPM_SPI_BASE_RX];
>
> /* Allocate memory for RX and TX buffers */
> rxbuf = (uchar *) malloc (MAX_BUFFER);
> txbuf = (uchar *) malloc (MAX_BUFFER);
>
> - rbdf->cbd_bufaddr = (ulong) rxbuf;
> - tbdf->cbd_bufaddr = (ulong) txbuf;
> + out_be32(&rbdf->cbd_bufaddr, (ulong)rxbuf);
> + out_be32(&tbdf->cbd_bufaddr, (ulong)txbuf);
>
> return;
> }
> @@ -301,59 +292,46 @@ ssize_t spi_read (uchar *addr, int alen, uchar *buffer, int len)
> **************************************************************************** */
> ssize_t spi_xfer (size_t count)
> {
> - volatile immap_t *immr;
> - volatile cpm8xx_t *cp;
> - volatile spi_t *spi;
> - cbd_t *tbdf, *rbdf;
> - ushort loop;
> + immap_t __iomem *immr = (immap_t __iomem *)CONFIG_SYS_IMMR;
> + cpm8xx_t __iomem *cp = &immr->im_cpm;
> + spi_t __iomem *spi = (spi_t __iomem *)&cp->cp_dparam[PROFF_SPI];
> + cbd_t __iomem *tbdf, *rbdf;
> int tm;
>
> - immr = (immap_t *) CONFIG_SYS_IMMR;
> - cp = (cpm8xx_t *) &immr->im_cpm;
> -
> - spi = (spi_t *)&cp->cp_dparam[PROFF_SPI];
> /* Disable relocation */
> - spi->spi_rpbase = 0;
> + out_be16(&spi->spi_rpbase, 0);
>
> - tbdf = (cbd_t *) & cp->cp_dpmem[spi->spi_tbase];
> - rbdf = (cbd_t *) & cp->cp_dpmem[spi->spi_rbase];
> + tbdf = (cbd_t __iomem *)&cp->cp_dpmem[CPM_SPI_BASE_TX];
> + rbdf = (cbd_t __iomem *)&cp->cp_dpmem[CPM_SPI_BASE_RX];
>
> /* Set CS for device */
> - cp->cp_pbdat &= ~0x0001;
> + clrbits_be32(&cp->cp_pbdat, 0x0001);
>
> /* Setting tx bd status and data length */
> - tbdf->cbd_sc = BD_SC_READY | BD_SC_LAST | BD_SC_WRAP;
> - tbdf->cbd_datlen = count;
> + out_be16(&tbdf->cbd_sc, BD_SC_READY | BD_SC_LAST | BD_SC_WRAP);
> + out_be16(&tbdf->cbd_datlen, count);
>
> /* Setting rx bd status and data length */
> - rbdf->cbd_sc = BD_SC_EMPTY | BD_SC_WRAP;
> - rbdf->cbd_datlen = 0; /* rx length has no significance */
> -
> - loop = cp->cp_spmode & SPMODE_LOOP;
> - cp->cp_spmode = /*SPMODE_DIV16 |*/ /* BRG/16 mode not used here */
> - loop |
> - SPMODE_REV |
> - SPMODE_MSTR |
> - SPMODE_EN |
> - SPMODE_LEN(8) | /* 8 Bits per char */
> - SPMODE_PM(0x8) ; /* medium speed */
> - cp->cp_spim = 0; /* Mask all SPI events */
> - cp->cp_spie = SPI_EMASK; /* Clear all SPI events */
> + out_be16(&rbdf->cbd_sc, BD_SC_EMPTY | BD_SC_WRAP);
> + out_be16(&rbdf->cbd_datlen, 0); /* rx length has no significance */
> +
> + clrsetbits_be16(&cp->cp_spmode, ~SPMODE_LOOP, SPMODE_REV | SPMODE_MSTR |
> + SPMODE_EN | SPMODE_LEN(8) | SPMODE_PM(0x8));
> + out_8(&cp->cp_spim, 0); /* Mask all SPI events */
> + out_8(&cp->cp_spie, SPI_EMASK); /* Clear all SPI events */
>
> /* start spi transfer */
> - cp->cp_spcom |= SPI_STR; /* Start transmit */
> + setbits_8(&cp->cp_spcom, SPI_STR); /* Start transmit */
>
> /* --------------------------------
> * Wait for SPI transmit to get out
> * or time out (1 second = 1000 ms)
> * -------------------------------- */
> for (tm=0; tm<1000; ++tm) {
> - if (cp->cp_spie & SPI_TXB) { /* Tx Buffer Empty */
> + if (in_8(&cp->cp_spie) & SPI_TXB) /* Tx Buffer Empty */
> break;
> - }
> - if ((tbdf->cbd_sc & BD_SC_READY) == 0) {
> + if ((in_be16(&tbdf->cbd_sc) & BD_SC_READY) == 0)
> break;
> - }
> udelay (1000);
> }
> if (tm >= 1000) {
> @@ -361,7 +339,7 @@ ssize_t spi_xfer (size_t count)
> }
>
> /* Clear CS for device */
> - cp->cp_pbdat |= 0x0001;
> + setbits_be32(&cp->cp_pbdat, 0x0001);
>
> return count;
> }
> diff --git a/arch/powerpc/include/asm/iopin_8xx.h b/arch/powerpc/include/asm/iopin_8xx.h
> index 8db0fa2a1c..beca988d77 100644
> --- a/arch/powerpc/include/asm/iopin_8xx.h
> +++ b/arch/powerpc/include/asm/iopin_8xx.h
> @@ -12,6 +12,7 @@
>
> #include <linux/types.h>
> #include <asm/8xx_immap.h>
> +#include <asm/io.h>
>
> #ifdef __KERNEL__
>
> @@ -29,54 +30,72 @@ typedef struct {
> static __inline__ void
> iopin_set_high(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_padat;
> - *datp |= (1 << (15 - iopin->pin));
> + ushort __iomem *datp = &immap->im_ioport.iop_padat;
> +
> + setbits_be16(datp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbdat;
> - *datp |= (1 << (31 - iopin->pin));
> + uint __iomem *datp = &immap->im_cpm.cp_pbdat;
> +
> + setbits_be32(datp, 1 << (31 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcdat;
> - *datp |= (1 << (15 - iopin->pin));
> + ushort __iomem *datp = &immap->im_ioport.iop_pcdat;
> +
> + setbits_be16(datp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pddat;
> - *datp |= (1 << (15 - iopin->pin));
> + ushort __iomem *datp = &immap->im_ioport.iop_pddat;
> +
> + setbits_be16(datp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ void
> iopin_set_low(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_padat;
> - *datp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *datp = &immap->im_ioport.iop_padat;
> +
> + clrbits_be16(datp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbdat;
> - *datp &= ~(1 << (31 - iopin->pin));
> + uint __iomem *datp = &immap->im_cpm.cp_pbdat;
> +
> + clrbits_be32(datp, 1 << (31 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcdat;
> - *datp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *datp = &immap->im_ioport.iop_pcdat;
> +
> + clrbits_be16(datp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pddat;
> - *datp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *datp = &immap->im_ioport.iop_pddat;
> +
> + clrbits_be16(datp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ uint
> iopin_is_high(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_padat;
> - return (*datp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *datp = &immap->im_ioport.iop_padat;
> +
> + return (in_be16(datp) >> (15 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbdat;
> - return (*datp >> (31 - iopin->pin)) & 1;
> + uint __iomem *datp = &immap->im_cpm.cp_pbdat;
> +
> + return (in_be32(datp) >> (31 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcdat;
> - return (*datp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *datp = &immap->im_ioport.iop_pcdat;
> +
> + return (in_be16(datp) >> (15 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pddat;
> - return (*datp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *datp = &immap->im_ioport.iop_pddat;
> +
> + return (in_be16(datp) >> (15 - iopin->pin)) & 1;
> }
> return 0;
> }
> @@ -84,18 +103,24 @@ iopin_is_high(iopin_t *iopin)
> static __inline__ uint
> iopin_is_low(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_padat;
> - return ((*datp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *datp = &immap->im_ioport.iop_padat;
> +
> + return ((in_be16(datp) >> (15 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbdat;
> - return ((*datp >> (31 - iopin->pin)) & 1) ^ 1;
> + uint __iomem *datp = &immap->im_cpm.cp_pbdat;
> +
> + return ((in_be32(datp) >> (31 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcdat;
> - return ((*datp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *datp = &immap->im_ioport.iop_pcdat;
> +
> + return ((in_be16(datp) >> (15 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *datp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pddat;
> - return ((*datp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *datp = &immap->im_ioport.iop_pddat;
> +
> + return ((in_be16(datp) >> (15 - iopin->pin)) & 1) ^ 1;
> }
> return 0;
> }
> @@ -103,54 +128,72 @@ iopin_is_low(iopin_t *iopin)
> static __inline__ void
> iopin_set_out(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_padir;
> - *dirp |= (1 << (15 - iopin->pin));
> + ushort __iomem *dirp = &immap->im_ioport.iop_padir;
> +
> + setbits_be16(dirp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbdir;
> - *dirp |= (1 << (31 - iopin->pin));
> + uint __iomem *dirp = &immap->im_cpm.cp_pbdir;
> +
> + setbits_be32(dirp, 1 << (31 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcdir;
> - *dirp |= (1 << (15 - iopin->pin));
> + ushort __iomem *dirp = &immap->im_ioport.iop_pcdir;
> +
> + setbits_be16(dirp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pddir;
> - *dirp |= (1 << (15 - iopin->pin));
> + ushort __iomem *dirp = &immap->im_ioport.iop_pddir;
> +
> + setbits_be16(dirp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ void
> iopin_set_in(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_padir;
> - *dirp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *dirp = &immap->im_ioport.iop_padir;
> +
> + clrbits_be16(dirp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbdir;
> - *dirp &= ~(1 << (31 - iopin->pin));
> + uint __iomem *dirp = &immap->im_cpm.cp_pbdir;
> +
> + clrbits_be32(dirp, 1 << (31 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcdir;
> - *dirp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *dirp = &immap->im_ioport.iop_pcdir;
> +
> + clrbits_be16(dirp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pddir;
> - *dirp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *dirp = &immap->im_ioport.iop_pddir;
> +
> + clrbits_be16(dirp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ uint
> iopin_is_out(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_padir;
> - return (*dirp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *dirp = &immap->im_ioport.iop_padir;
> +
> + return (in_be16(dirp) >> (15 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbdir;
> - return (*dirp >> (31 - iopin->pin)) & 1;
> + uint __iomem *dirp = &immap->im_cpm.cp_pbdir;
> +
> + return (in_be32(dirp) >> (31 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcdir;
> - return (*dirp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *dirp = &immap->im_ioport.iop_pcdir;
> +
> + return (in_be16(dirp) >> (15 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pddir;
> - return (*dirp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *dirp = &immap->im_ioport.iop_pddir;
> +
> + return (in_be16(dirp) >> (15 - iopin->pin)) & 1;
> }
> return 0;
> }
> @@ -158,18 +201,24 @@ iopin_is_out(iopin_t *iopin)
> static __inline__ uint
> iopin_is_in(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_padir;
> - return ((*dirp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *dirp = &immap->im_ioport.iop_padir;
> +
> + return ((in_be16(dirp) >> (15 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbdir;
> - return ((*dirp >> (31 - iopin->pin)) & 1) ^ 1;
> + uint __iomem *dirp = &immap->im_cpm.cp_pbdir;
> +
> + return ((in_be32(dirp) >> (31 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcdir;
> - return ((*dirp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *dirp = &immap->im_ioport.iop_pcdir;
> +
> + return ((in_be16(dirp) >> (15 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *dirp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pddir;
> - return ((*dirp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *dirp = &immap->im_ioport.iop_pddir;
> +
> + return ((in_be16(dirp) >> (15 - iopin->pin)) & 1) ^ 1;
> }
> return 0;
> }
> @@ -177,36 +226,48 @@ iopin_is_in(iopin_t *iopin)
> static __inline__ void
> iopin_set_odr(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *odrp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_paodr;
> - *odrp |= (1 << (15 - iopin->pin));
> + ushort __iomem *odrp = &immap->im_ioport.iop_paodr;
> +
> + setbits_be16(odrp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile ushort *odrp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbodr;
> - *odrp |= (1 << (31 - iopin->pin));
> + ushort __iomem *odrp = &immap->im_cpm.cp_pbodr;
> +
> + setbits_be16(odrp, 1 << (31 - iopin->pin));
> }
> }
>
> static __inline__ void
> iopin_set_act(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *odrp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_paodr;
> - *odrp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *odrp = &immap->im_ioport.iop_paodr;
> +
> + clrbits_be16(odrp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile ushort *odrp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbodr;
> - *odrp &= ~(1 << (31 - iopin->pin));
> + ushort __iomem *odrp = &immap->im_cpm.cp_pbodr;
> +
> + clrbits_be16(odrp, 1 << (31 - iopin->pin));
> }
> }
>
> static __inline__ uint
> iopin_is_odr(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *odrp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_paodr;
> - return (*odrp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *odrp = &immap->im_ioport.iop_paodr;
> +
> + return (in_be16(odrp) >> (15 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile ushort *odrp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbodr;
> - return (*odrp >> (31 - iopin->pin)) & 1;
> + ushort __iomem *odrp = &immap->im_cpm.cp_pbodr;
> +
> + return (in_be16(odrp) >> (31 - iopin->pin)) & 1;
> }
> return 0;
> }
> @@ -214,12 +275,16 @@ iopin_is_odr(iopin_t *iopin)
> static __inline__ uint
> iopin_is_act(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *odrp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_paodr;
> - return ((*odrp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *odrp = &immap->im_ioport.iop_paodr;
> +
> + return ((in_be16(odrp) >> (15 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile ushort *odrp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbodr;
> - return ((*odrp >> (31 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *odrp = &immap->im_cpm.cp_pbodr;
> +
> + return ((in_be16(odrp) >> (31 - iopin->pin)) & 1) ^ 1;
> }
> return 0;
> }
> @@ -227,54 +292,72 @@ iopin_is_act(iopin_t *iopin)
> static __inline__ void
> iopin_set_ded(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_papar;
> - *parp |= (1 << (15 - iopin->pin));
> + ushort __iomem *parp = &immap->im_ioport.iop_papar;
> +
> + setbits_be16(parp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbpar;
> - *parp |= (1 << (31 - iopin->pin));
> + uint __iomem *parp = &immap->im_cpm.cp_pbpar;
> +
> + setbits_be32(parp, 1 << (31 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcpar;
> - *parp |= (1 << (15 - iopin->pin));
> + ushort __iomem *parp = &immap->im_ioport.iop_pcpar;
> +
> + setbits_be16(parp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pdpar;
> - *parp |= (1 << (15 - iopin->pin));
> + ushort __iomem *parp = &immap->im_ioport.iop_pdpar;
> +
> + setbits_be16(parp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ void
> iopin_set_gen(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_papar;
> - *parp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *parp = &immap->im_ioport.iop_papar;
> +
> + clrbits_be16(parp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbpar;
> - *parp &= ~(1 << (31 - iopin->pin));
> + uint __iomem *parp = &immap->im_cpm.cp_pbpar;
> +
> + clrbits_be32(parp, 1 << (31 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcpar;
> - *parp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *parp = &immap->im_ioport.iop_pcpar;
> +
> + clrbits_be16(parp, 1 << (15 - iopin->pin));
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pdpar;
> - *parp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *parp = &immap->im_ioport.iop_pdpar;
> +
> + clrbits_be16(parp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ uint
> iopin_is_ded(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_papar;
> - return (*parp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *parp = &immap->im_ioport.iop_papar;
> +
> + return (in_be16(parp) >> (15 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbpar;
> - return (*parp >> (31 - iopin->pin)) & 1;
> + uint __iomem *parp = &immap->im_cpm.cp_pbpar;
> +
> + return (in_be32(parp) >> (31 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcpar;
> - return (*parp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *parp = &immap->im_ioport.iop_pcpar;
> +
> + return (in_be16(parp) >> (15 - iopin->pin)) & 1;
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pdpar;
> - return (*parp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *parp = &immap->im_ioport.iop_pdpar;
> +
> + return (in_be16(parp) >> (15 - iopin->pin)) & 1;
> }
> return 0;
> }
> @@ -282,18 +365,24 @@ iopin_is_ded(iopin_t *iopin)
> static __inline__ uint
> iopin_is_gen(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTA) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_papar;
> - return ((*parp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *parp = &immap->im_ioport.iop_papar;
> +
> + return ((in_be16(parp) >> (15 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTB) {
> - volatile uint *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_cpm.cp_pbpar;
> - return ((*parp >> (31 - iopin->pin)) & 1) ^ 1;
> + uint __iomem *parp = &immap->im_cpm.cp_pbpar;
> +
> + return ((in_be32(parp) >> (31 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcpar;
> - return ((*parp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *parp = &immap->im_ioport.iop_pcpar;
> +
> + return ((in_be16(parp) >> (15 - iopin->pin)) & 1) ^ 1;
> } else if (iopin->port == IOPIN_PORTD) {
> - volatile ushort *parp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pdpar;
> - return ((*parp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *parp = &immap->im_ioport.iop_pdpar;
> +
> + return ((in_be16(parp) >> (15 - iopin->pin)) & 1) ^ 1;
> }
> return 0;
> }
> @@ -301,27 +390,36 @@ iopin_is_gen(iopin_t *iopin)
> static __inline__ void
> iopin_set_opt2(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *sorp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcso;
> - *sorp |= (1 << (15 - iopin->pin));
> + ushort __iomem *sorp = &immap->im_ioport.iop_pcso;
> +
> + setbits_be16(sorp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ void
> iopin_set_opt1(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *sorp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcso;
> - *sorp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *sorp = &immap->im_ioport.iop_pcso;
> +
> + clrbits_be16(sorp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ uint
> iopin_is_opt2(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *sorp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcso;
> - return (*sorp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *sorp = &immap->im_ioport.iop_pcso;
> +
> + return (in_be16(sorp) >> (15 - iopin->pin)) & 1;
> }
> return 0;
> }
> @@ -329,9 +427,12 @@ iopin_is_opt2(iopin_t *iopin)
> static __inline__ uint
> iopin_is_opt1(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *sorp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcso;
> - return ((*sorp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *sorp = &immap->im_ioport.iop_pcso;
> +
> + return ((in_be16(sorp) >> (15 - iopin->pin)) & 1) ^ 1;
> }
> return 0;
> }
> @@ -339,27 +440,36 @@ iopin_is_opt1(iopin_t *iopin)
> static __inline__ void
> iopin_set_falledge(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *intp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcint;
> - *intp |= (1 << (15 - iopin->pin));
> + ushort __iomem *intp = &immap->im_ioport.iop_pcint;
> +
> + setbits_be16(intp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ void
> iopin_set_anyedge(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *intp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcint;
> - *intp &= ~(1 << (15 - iopin->pin));
> + ushort __iomem *intp = &immap->im_ioport.iop_pcint;
> +
> + clrbits_be16(intp, 1 << (15 - iopin->pin));
> }
> }
>
> static __inline__ uint
> iopin_is_falledge(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *intp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcint;
> - return (*intp >> (15 - iopin->pin)) & 1;
> + ushort __iomem *intp = &immap->im_ioport.iop_pcint;
> +
> + return (in_be16(intp) >> (15 - iopin->pin)) & 1;
> }
> return 0;
> }
> @@ -367,9 +477,12 @@ iopin_is_falledge(iopin_t *iopin)
> static __inline__ uint
> iopin_is_anyedge(iopin_t *iopin)
> {
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
> +
> if (iopin->port == IOPIN_PORTC) {
> - volatile ushort *intp = &((immap_t *)CONFIG_SYS_IMMR)->im_ioport.iop_pcint;
> - return ((*intp >> (15 - iopin->pin)) & 1) ^ 1;
> + ushort __iomem *intp = &immap->im_ioport.iop_pcint;
> +
> + return ((in_be16(intp) >> (15 - iopin->pin)) & 1) ^ 1;
> }
> return 0;
> }
> diff --git a/arch/powerpc/lib/time.c b/arch/powerpc/lib/time.c
> index 4cbb65eb68..41a271a42d 100644
> --- a/arch/powerpc/lib/time.c
> +++ b/arch/powerpc/lib/time.c
> @@ -6,6 +6,7 @@
> */
>
> #include <common.h>
> +#include <asm/io.h>
>
> /* ------------------------------------------------------------------------- */
>
> @@ -65,10 +66,10 @@ int timer_init(void)
> unsigned long temp;
>
> #if defined(CONFIG_8xx)
> - volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
> + immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
>
> /* unlock */
> - immap->im_sitk.sitk_tbk = KAPWR_KEY;
> + out_be32(&immap->im_sitk.sitk_tbk, KAPWR_KEY);
> #endif
>
> /* reset */
> @@ -77,7 +78,7 @@ int timer_init(void)
>
> #if defined(CONFIG_8xx)
> /* enable */
> - immap->im_sit.sit_tbscr |= TBSCR_TBE;
> + setbits_be16(&immap->im_sit.sit_tbscr, TBSCR_TBE);
> #endif
> return (0);
> }
> diff --git a/include/watchdog.h b/include/watchdog.h
> index a3a2eeaf1b..64b59f107a 100644
> --- a/include/watchdog.h
> +++ b/include/watchdog.h
> @@ -74,7 +74,7 @@ int init_func_watchdog_reset(void);
>
> /* MPC 8xx */
> #if defined(CONFIG_8xx) && !defined(__ASSEMBLY__)
> - void reset_8xx_watchdog(volatile immap_t *immr);
> + void reset_8xx_watchdog(immap_t __iomem *immr);
> #endif
>
> #if defined(CONFIG_HW_WATCHDOG) && !defined(__ASSEMBLY__)
>
--
DENX Software Engineering GmbH, Managing Director: Wolfgang Denk
HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany
next prev parent reply other threads:[~2017-07-06 9:41 UTC|newest]
Thread overview: 35+ messages / expand[flat|nested] mbox.gz Atom feed top
2017-07-06 8:33 [U-Boot] [PATCH v2 0/10] powerpc, 8xx: Modernise the 8xx Christophe Leroy
2017-07-06 8:33 ` [U-Boot] [PATCH v2 01/10] powerpc, 8xx: move immap.c in arch/powerpc/cpu/mpc8xx/ Christophe Leroy
2017-07-06 8:41 ` Christophe LEROY
2017-07-06 9:40 ` Heiko Schocher
2017-07-09 0:24 ` [U-Boot] [U-Boot, v2, " Tom Rini
2017-07-06 8:33 ` [U-Boot] [PATCH v2 02/10] powerpc, 8xx: move specific reginfo Christophe Leroy
2017-07-06 9:40 ` Heiko Schocher
2017-07-09 0:24 ` [U-Boot] [U-Boot,v2,02/10] " Tom Rini
2017-07-06 8:33 ` [U-Boot] [PATCH v2 03/10] powerpc, 8xx: Use IO accessors to access IO memory Christophe Leroy
2017-07-06 9:41 ` Heiko Schocher [this message]
2017-07-09 0:24 ` [U-Boot] [U-Boot, v2, " Tom Rini
2017-07-06 8:33 ` [U-Boot] [PATCH v2 04/10] powerpc, 8xx: Implement GLL2 ERRATA Christophe Leroy
2017-07-06 9:43 ` Heiko Schocher
2017-07-06 10:56 ` Wolfgang Denk
2017-07-06 11:12 ` Christophe LEROY
2017-07-06 11:18 ` Christophe LEROY
2017-07-06 11:20 ` Wolfgang Denk
2017-07-06 8:33 ` [U-Boot] [PATCH v2 05/10] powerpc, 8xx: Handle checkpatch errors and some of the warnings/checks Christophe Leroy
2017-07-06 9:43 ` Heiko Schocher
2017-07-09 0:24 ` [U-Boot] [U-Boot, v2, " Tom Rini
2017-07-06 8:33 ` [U-Boot] [PATCH v2 06/10] powerpc, 8xx: Properly set CPM frequency in the device tree Christophe Leroy
2017-07-06 9:46 ` Heiko Schocher
2017-07-09 0:25 ` [U-Boot] [U-Boot, v2, " Tom Rini
2017-07-06 8:33 ` [U-Boot] [PATCH v2 07/10] powerpc, 8xx: Migrate to Kconfig Christophe Leroy
2017-07-06 8:57 ` Bin Meng
2017-07-06 9:47 ` Heiko Schocher
2017-07-09 0:25 ` [U-Boot] [U-Boot,v2,07/10] " Tom Rini
2017-07-06 8:33 ` [U-Boot] [PATCH v2 08/10] powerpc, 8xx: move FEC Ethernet driver in drivers/net Christophe Leroy
2017-07-06 8:54 ` Bin Meng
2017-07-06 12:02 ` Tom Rini
2017-07-09 0:25 ` [U-Boot] [U-Boot, v2, " Tom Rini
2017-07-06 8:33 ` [U-Boot] [PATCH v2 09/10] powerpc, 8xx: move SPI driver to drivers/spi/ Christophe Leroy
2017-07-09 0:25 ` [U-Boot] [U-Boot, v2, " Tom Rini
2017-07-06 8:33 ` [U-Boot] [PATCH v2 10/10] powerpc, 8xx: move Serial driver to drivers/serial/ Christophe Leroy
2017-07-09 0:25 ` [U-Boot] [U-Boot, v2, " Tom Rini
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=595E05C6.1030805@denx.de \
--to=hs@denx.de \
--cc=u-boot@lists.denx.de \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.