Fixed sparse warnings mainly due to lack of __iomem.
Signed-off-by: Jeff Garzik <jgarzik@pobox.com>
 
        /* get a pointer to the register memory */
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       priv->regs = (struct gfar *)
-               ioremap(r->start, sizeof (struct gfar));
+       priv->regs = ioremap(r->start, sizeof (struct gfar));
 
        if (NULL == priv->regs) {
                err = -ENOMEM;
        return 0;
 
 register_fail:
-       iounmap((void *) priv->regs);
+       iounmap(priv->regs);
 regs_fail:
        free_netdev(dev);
        return err;
 
        platform_set_drvdata(pdev, NULL);
 
-       iounmap((void *) priv->regs);
+       iounmap(priv->regs);
        free_netdev(dev);
 
        return 0;
 
        /* Zero out the rmon mib registers if it has them */
        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
-               memset((void *) &(priv->regs->rmon), 0,
-                      sizeof (struct rmon_mib));
+               memset_io(&(priv->regs->rmon), 0, sizeof (struct rmon_mib));
 
                /* Mask off the CAM interrupts */
                gfar_write(&priv->regs->rmon.cam1, 0xffffffff);
 void gfar_halt(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
-       struct gfar *regs = priv->regs;
+       struct gfar __iomem *regs = priv->regs;
        u32 tempval;
 
        /* Mask all interrupts */
 void stop_gfar(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
-       struct gfar *regs = priv->regs;
+       struct gfar __iomem *regs = priv->regs;
        unsigned long flags;
 
        phy_stop(priv->phydev);
 void gfar_start(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
-       struct gfar *regs = priv->regs;
+       struct gfar __iomem *regs = priv->regs;
        u32 tempval;
 
        /* Enable Rx and Tx in MACCFG1 */
        unsigned long vaddr;
        int i;
        struct gfar_private *priv = netdev_priv(dev);
-       struct gfar *regs = priv->regs;
+       struct gfar __iomem *regs = priv->regs;
        int err = 0;
        u32 rctrl = 0;
        u32 attrs = 0;
 static void adjust_link(struct net_device *dev)
 {
        struct gfar_private *priv = netdev_priv(dev);
-       struct gfar *regs = priv->regs;
+       struct gfar __iomem *regs = priv->regs;
        unsigned long flags;
        struct phy_device *phydev = priv->phydev;
        int new_state = 0;
 {
        struct dev_mc_list *mc_ptr;
        struct gfar_private *priv = netdev_priv(dev);
-       struct gfar *regs = priv->regs;
+       struct gfar __iomem *regs = priv->regs;
        u32 tempval;
 
        if(dev->flags & IFF_PROMISC) {
        int idx;
        char tmpbuf[MAC_ADDR_LEN];
        u32 tempval;
-       u32 *macptr = &priv->regs->macstnaddr1;
+       u32 __iomem *macptr = &priv->regs->macstnaddr1;
 
        macptr += num*2;
 
 
        struct rxbd8 *cur_rx;           /* Next free rx ring entry */
        struct txbd8 *cur_tx;           /* Next free ring entry */
        struct txbd8 *dirty_tx;         /* The Ring entry to be freed. */
-       struct gfar *regs;      /* Pointer to the GFAR memory mapped Registers */
-       u32 *hash_regs[16];
+       struct gfar __iomem *regs;      /* Pointer to the GFAR memory mapped Registers */
+       u32 __iomem *hash_regs[16];
        int hash_width;
        struct net_device_stats stats; /* linux network statistics */
        struct gfar_extra_stats extra_stats;
        uint32_t msg_enable;
 };
 
-static inline u32 gfar_read(volatile unsigned *addr)
+static inline u32 gfar_read(volatile unsigned __iomem *addr)
 {
        u32 val;
        val = in_be32(addr);
        return val;
 }
 
-static inline void gfar_write(volatile unsigned *addr, u32 val)
+static inline void gfar_write(volatile unsigned __iomem *addr, u32 val)
 {
        out_be32(addr, val);
 }
 
        u64 *extra = (u64 *) & priv->extra_stats;
 
        if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
-               u32 *rmon = (u32 *) & priv->regs->rmon;
+               u32 __iomem *rmon = (u32 __iomem *) & priv->regs->rmon;
                struct gfar_stats *stats = (struct gfar_stats *) buf;
 
                for (i = 0; i < GFAR_RMON_LEN; i++)
-                       stats->rmon[i] = (u64) (rmon[i]);
+                       stats->rmon[i] = (u64) gfar_read(&rmon[i]);
 
                for (i = 0; i < GFAR_EXTRA_STATS_LEN; i++)
                        stats->extra[i] = extra[i];
 {
        int i;
        struct gfar_private *priv = netdev_priv(dev);
-       u32 *theregs = (u32 *) priv->regs;
+       u32 __iomem *theregs = (u32 __iomem *) priv->regs;
        u32 *buf = (u32 *) regbuf;
 
        for (i = 0; i < sizeof (struct gfar) / sizeof (u32); i++)
-               buf[i] = theregs[i];
+               buf[i] = gfar_read(&theregs[i]);
 }
 
 /* Convert microseconds to ethernet clock ticks, which changes
 
  * All PHY configuration is done through the TSEC1 MIIM regs */
 int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value)
 {
-       struct gfar_mii *regs = bus->priv;
+       struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
 
        /* Set the PHY address and the register address we want to write */
        gfar_write(®s->miimadd, (mii_id << 8) | regnum);
  * configuration has to be done through the TSEC1 MIIM regs */
 int gfar_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
 {
-       struct gfar_mii *regs = bus->priv;
+       struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
        u16 value;
 
        /* Set the PHY address and the register address we want to read */
 /* Reset the MIIM registers, and wait for the bus to free */
 int gfar_mdio_reset(struct mii_bus *bus)
 {
-       struct gfar_mii *regs = bus->priv;
+       struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
        unsigned int timeout = PHY_INIT_TIMEOUT;
 
        spin_lock_bh(&bus->mdio_lock);
 {
        struct platform_device *pdev = to_platform_device(dev);
        struct gianfar_mdio_data *pdata;
-       struct gfar_mii *regs;
+       struct gfar_mii __iomem *regs;
        struct mii_bus *new_bus;
        struct resource *r;
        int err = 0;
        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
        /* Set the PHY base address */
-       regs = (struct gfar_mii *) ioremap(r->start,
-                       sizeof (struct gfar_mii));
+       regs = ioremap(r->start, sizeof (struct gfar_mii));
 
        if (NULL == regs) {
                err = -ENOMEM;
                goto reg_map_fail;
        }
 
-       new_bus->priv = regs;
+       new_bus->priv = (void __force *)regs;
 
        new_bus->irq = pdata->irq;
 
        return 0;
 
 bus_register_fail:
-       iounmap((void *) regs);
+       iounmap(regs);
 reg_map_fail:
        kfree(new_bus);
 
 
        dev_set_drvdata(dev, NULL);
 
-       iounmap((void *) (&bus->priv));
+       iounmap((void __iomem *)bus->priv);
        bus->priv = NULL;
        kfree(bus);