can: sja1000: stop misusing member base_addr of struct net_device

As discussed on the netdev mailing list, the member "base_addr" of
"struct net_device" should not be (mis)used to store the virtual
address to the SJA1000 register area. According to David Miller,
it's only use is to allow ISA and similar primitive bus devices to
have their I/O ports changed via ifconfig. The virtual address is
now stored in the private data structure of the SJA1000 device and
the callback functions use "struct sja1000_priv" instead of the
unneeded "struct net_device".

Signed-off-by: Wolfgang Grandegger <wg@grandegger.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 54 insertions, 54 deletions

diff --git a/drivers/net/can/sja1000/sja1000.c b/drivers/net/can/sja1000/sja1000.c
index b689964f182c..571f133a8fec 100644
--- a/drivers/net/can/sja1000/sja1000.c
+++ b/drivers/net/can/sja1000/sja1000.c
@@ -89,7 +89,7 @@ static int sja1000_probe_chip(struct net_device *dev)
 {
         struct sja1000_priv *priv = netdev_priv(dev);
 
-        if (dev->base_addr && (priv->read_reg(dev, 0) == 0xFF)) {
+        if (priv->reg_base && (priv->read_reg(priv, 0) == 0xFF)) {
                 printk(KERN_INFO "%s: probing @0x%lX failed\n",
                        DRV_NAME, dev->base_addr);
                 return 0;
@@ -100,11 +100,11 @@ static int sja1000_probe_chip(struct net_device *dev)
 static void set_reset_mode(struct net_device *dev)
 {
         struct sja1000_priv *priv = netdev_priv(dev);
-        unsigned char status = priv->read_reg(dev, REG_MOD);
+        unsigned char status = priv->read_reg(priv, REG_MOD);
         int i;
 
         /* disable interrupts */
-        priv->write_reg(dev, REG_IER, IRQ_OFF);
+        priv->write_reg(priv, REG_IER, IRQ_OFF);
 
         for (i = 0; i < 100; i++) {
                 /* check reset bit */
@@ -113,9 +113,9 @@ static void set_reset_mode(struct net_device *dev)
                         return;
                 }
 
-                priv->write_reg(dev, REG_MOD, MOD_RM);  /* reset chip */
+                priv->write_reg(priv, REG_MOD, MOD_RM); /* reset chip */
                 udelay(10);
-                status = priv->read_reg(dev, REG_MOD);
+                status = priv->read_reg(priv, REG_MOD);
         }
 
         dev_err(dev->dev.parent, "setting SJA1000 into reset mode failed!\n");
@@ -124,7 +124,7 @@ static void set_reset_mode(struct net_device *dev)
 static void set_normal_mode(struct net_device *dev)
 {
         struct sja1000_priv *priv = netdev_priv(dev);
-        unsigned char status = priv->read_reg(dev, REG_MOD);
+        unsigned char status = priv->read_reg(priv, REG_MOD);
         int i;
 
         for (i = 0; i < 100; i++) {
@@ -132,14 +132,14 @@ static void set_normal_mode(struct net_device *dev)
                 if ((status & MOD_RM) == 0) {
                         priv->can.state = CAN_STATE_ERROR_ACTIVE;
                         /* enable all interrupts */
-                        priv->write_reg(dev, REG_IER, IRQ_ALL);
+                        priv->write_reg(priv, REG_IER, IRQ_ALL);
                         return;
                 }
 
                 /* set chip to normal mode */
-                priv->write_reg(dev, REG_MOD, 0x00);
+                priv->write_reg(priv, REG_MOD, 0x00);
                 udelay(10);
-                status = priv->read_reg(dev, REG_MOD);
+                status = priv->read_reg(priv, REG_MOD);
         }
 
         dev_err(dev->dev.parent, "setting SJA1000 into normal mode failed!\n");
@@ -154,9 +154,9 @@ static void sja1000_start(struct net_device *dev)
                 set_reset_mode(dev);
 
         /* Clear error counters and error code capture */
-        priv->write_reg(dev, REG_TXERR, 0x0);
-        priv->write_reg(dev, REG_RXERR, 0x0);
-        priv->read_reg(dev, REG_ECC);
+        priv->write_reg(priv, REG_TXERR, 0x0);
+        priv->write_reg(priv, REG_RXERR, 0x0);
+        priv->read_reg(priv, REG_ECC);
 
         /* leave reset mode */
         set_normal_mode(dev);
@@ -198,8 +198,8 @@ static int sja1000_set_bittiming(struct net_device *dev)
         dev_info(dev->dev.parent,
                  "setting BTR0=0x%02x BTR1=0x%02x\n", btr0, btr1);
 
-        priv->write_reg(dev, REG_BTR0, btr0);
-        priv->write_reg(dev, REG_BTR1, btr1);
+        priv->write_reg(priv, REG_BTR0, btr0);
+        priv->write_reg(priv, REG_BTR1, btr1);
 
         return 0;
 }
@@ -217,20 +217,20 @@ static void chipset_init(struct net_device *dev)
         struct sja1000_priv *priv = netdev_priv(dev);
 
         /* set clock divider and output control register */
-        priv->write_reg(dev, REG_CDR, priv->cdr | CDR_PELICAN);
+        priv->write_reg(priv, REG_CDR, priv->cdr | CDR_PELICAN);
 
         /* set acceptance filter (accept all) */
-        priv->write_reg(dev, REG_ACCC0, 0x00);
-        priv->write_reg(dev, REG_ACCC1, 0x00);
-        priv->write_reg(dev, REG_ACCC2, 0x00);
-        priv->write_reg(dev, REG_ACCC3, 0x00);
+        priv->write_reg(priv, REG_ACCC0, 0x00);
+        priv->write_reg(priv, REG_ACCC1, 0x00);
+        priv->write_reg(priv, REG_ACCC2, 0x00);
+        priv->write_reg(priv, REG_ACCC3, 0x00);
 
-        priv->write_reg(dev, REG_ACCM0, 0xFF);
-        priv->write_reg(dev, REG_ACCM1, 0xFF);
-        priv->write_reg(dev, REG_ACCM2, 0xFF);
-        priv->write_reg(dev, REG_ACCM3, 0xFF);
+        priv->write_reg(priv, REG_ACCM0, 0xFF);
+        priv->write_reg(priv, REG_ACCM1, 0xFF);
+        priv->write_reg(priv, REG_ACCM2, 0xFF);
+        priv->write_reg(priv, REG_ACCM3, 0xFF);
 
-        priv->write_reg(dev, REG_OCR, priv->ocr | OCR_MODE_NORMAL);
+        priv->write_reg(priv, REG_OCR, priv->ocr | OCR_MODE_NORMAL);
 }
 
 /*
@@ -261,27 +261,27 @@ static int sja1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
         if (id & CAN_EFF_FLAG) {
                 fi |= FI_FF;
                 dreg = EFF_BUF;
-                priv->write_reg(dev, REG_FI, fi);
-                priv->write_reg(dev, REG_ID1, (id & 0x1fe00000) >> (5 + 16));
-                priv->write_reg(dev, REG_ID2, (id & 0x001fe000) >> (5 + 8));
-                priv->write_reg(dev, REG_ID3, (id & 0x00001fe0) >> 5);
-                priv->write_reg(dev, REG_ID4, (id & 0x0000001f) << 3);
+                priv->write_reg(priv, REG_FI, fi);
+                priv->write_reg(priv, REG_ID1, (id & 0x1fe00000) >> (5 + 16));
+                priv->write_reg(priv, REG_ID2, (id & 0x001fe000) >> (5 + 8));
+                priv->write_reg(priv, REG_ID3, (id & 0x00001fe0) >> 5);
+                priv->write_reg(priv, REG_ID4, (id & 0x0000001f) << 3);
         } else {
                 dreg = SFF_BUF;
-                priv->write_reg(dev, REG_FI, fi);
-                priv->write_reg(dev, REG_ID1, (id & 0x000007f8) >> 3);
-                priv->write_reg(dev, REG_ID2, (id & 0x00000007) << 5);
+                priv->write_reg(priv, REG_FI, fi);
+                priv->write_reg(priv, REG_ID1, (id & 0x000007f8) >> 3);
+                priv->write_reg(priv, REG_ID2, (id & 0x00000007) << 5);
         }
 
         for (i = 0; i < dlc; i++)
-                priv->write_reg(dev, dreg++, cf->data[i]);
+                priv->write_reg(priv, dreg++, cf->data[i]);
 
         stats->tx_bytes += dlc;
         dev->trans_start = jiffies;
 
         can_put_echo_skb(skb, dev, 0);
 
-        priv->write_reg(dev, REG_CMR, CMD_TR);
+        priv->write_reg(priv, REG_CMR, CMD_TR);
 
         return 0;
 }
@@ -304,22 +304,22 @@ static void sja1000_rx(struct net_device *dev)
         skb->dev = dev;
         skb->protocol = htons(ETH_P_CAN);
 
-        fi = priv->read_reg(dev, REG_FI);
+        fi = priv->read_reg(priv, REG_FI);
         dlc = fi & 0x0F;
 
         if (fi & FI_FF) {
                 /* extended frame format (EFF) */
                 dreg = EFF_BUF;
-                id = (priv->read_reg(dev, REG_ID1) << (5 + 16))
-                    | (priv->read_reg(dev, REG_ID2) << (5 + 8))
-                    | (priv->read_reg(dev, REG_ID3) << 5)
-                    | (priv->read_reg(dev, REG_ID4) >> 3);
+                id = (priv->read_reg(priv, REG_ID1) << (5 + 16))
+                    | (priv->read_reg(priv, REG_ID2) << (5 + 8))
+                    | (priv->read_reg(priv, REG_ID3) << 5)
+                    | (priv->read_reg(priv, REG_ID4) >> 3);
                 id |= CAN_EFF_FLAG;
         } else {
                 /* standard frame format (SFF) */
                 dreg = SFF_BUF;
-                id = (priv->read_reg(dev, REG_ID1) << 3)
-                    | (priv->read_reg(dev, REG_ID2) >> 5);
+                id = (priv->read_reg(priv, REG_ID1) << 3)
+                    | (priv->read_reg(priv, REG_ID2) >> 5);
         }
 
         if (fi & FI_RTR)
@@ -330,13 +330,13 @@ static void sja1000_rx(struct net_device *dev)
         cf->can_id = id;
         cf->can_dlc = dlc;
         for (i = 0; i < dlc; i++)
-                cf->data[i] = priv->read_reg(dev, dreg++);
+                cf->data[i] = priv->read_reg(priv, dreg++);
 
         while (i < 8)
                 cf->data[i++] = 0;
 
         /* release receive buffer */
-        priv->write_reg(dev, REG_CMR, CMD_RRB);
+        priv->write_reg(priv, REG_CMR, CMD_RRB);
 
         netif_rx(skb);
 
@@ -371,7 +371,7 @@ static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status)
                 cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW;
                 stats->rx_over_errors++;
                 stats->rx_errors++;
-                priv->write_reg(dev, REG_CMR, CMD_CDO); /* clear bit */
+                priv->write_reg(priv, REG_CMR, CMD_CDO);        /* clear bit */
         }
 
         if (isrc & IRQ_EI) {
@@ -392,7 +392,7 @@ static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status)
                 priv->can.can_stats.bus_error++;
                 stats->rx_errors++;
 
-                ecc = priv->read_reg(dev, REG_ECC);
+                ecc = priv->read_reg(priv, REG_ECC);
 
                 cf->can_id |= CAN_ERR_PROT | CAN_ERR_BUSERROR;
 
@@ -426,7 +426,7 @@ static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status)
         if (isrc & IRQ_ALI) {
                 /* arbitration lost interrupt */
                 dev_dbg(dev->dev.parent, "arbitration lost interrupt\n");
-                alc = priv->read_reg(dev, REG_ALC);
+                alc = priv->read_reg(priv, REG_ALC);
                 priv->can.can_stats.arbitration_lost++;
                 stats->rx_errors++;
                 cf->can_id |= CAN_ERR_LOSTARB;
@@ -435,8 +435,8 @@ static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status)
 
         if (state != priv->can.state && (state == CAN_STATE_ERROR_WARNING ||
                                          state == CAN_STATE_ERROR_PASSIVE)) {
-                uint8_t rxerr = priv->read_reg(dev, REG_RXERR);
-                uint8_t txerr = priv->read_reg(dev, REG_TXERR);
+                uint8_t rxerr = priv->read_reg(priv, REG_RXERR);
+                uint8_t txerr = priv->read_reg(priv, REG_TXERR);
                 cf->can_id |= CAN_ERR_CRTL;
                 if (state == CAN_STATE_ERROR_WARNING) {
                         priv->can.can_stats.error_warning++;
@@ -471,15 +471,15 @@ irqreturn_t sja1000_interrupt(int irq, void *dev_id)
         int n = 0;
 
         /* Shared interrupts and IRQ off? */
-        if (priv->read_reg(dev, REG_IER) == IRQ_OFF)
+        if (priv->read_reg(priv, REG_IER) == IRQ_OFF)
                 return IRQ_NONE;
 
         if (priv->pre_irq)
-                priv->pre_irq(dev);
+                priv->pre_irq(priv);
 
-        while ((isrc = priv->read_reg(dev, REG_IR)) && (n < SJA1000_MAX_IRQ)) {
+        while ((isrc = priv->read_reg(priv, REG_IR)) && (n < SJA1000_MAX_IRQ)) {
                 n++;
-                status = priv->read_reg(dev, REG_SR);
+                status = priv->read_reg(priv, REG_SR);
 
                 if (isrc & IRQ_WUI)
                         dev_warn(dev->dev.parent, "wakeup interrupt\n");
@@ -494,7 +494,7 @@ irqreturn_t sja1000_interrupt(int irq, void *dev_id)
                         /* receive interrupt */
                         while (status & SR_RBS) {
                                 sja1000_rx(dev);
-                                status = priv->read_reg(dev, REG_SR);
+                                status = priv->read_reg(priv, REG_SR);
                         }
                 }
                 if (isrc & (IRQ_DOI | IRQ_EI | IRQ_BEI | IRQ_EPI | IRQ_ALI)) {
@@ -505,7 +505,7 @@ irqreturn_t sja1000_interrupt(int irq, void *dev_id)
         }
 
         if (priv->post_irq)
-                priv->post_irq(dev);
+                priv->post_irq(priv);
 
         if (n >= SJA1000_MAX_IRQ)
                 dev_dbg(dev->dev.parent, "%d messages handled in ISR", n);