irda: convert to internal stats

Convert IRDA drivers to use already existing net_device_stats structure
in network device. This is a pre-cursor to conversion to net_device
ops. Compile tested only.

Signed-off-by: Stephen Hemminger <shemminger@vyatta.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 22 insertions, 30 deletions

diff --git a/drivers/net/irda/pxaficp_ir.c b/drivers/net/irda/pxaficp_ir.c
index 004a9aab3a50..31794c2363ec 100644
--- a/drivers/net/irda/pxaficp_ir.c
+++ b/drivers/net/irda/pxaficp_ir.c
@@ -108,7 +108,6 @@ struct pxa_irda {
         int                     txdma;
         int                     rxdma;
 
-        struct net_device_stats stats;
         struct irlap_cb         *irlap;
         struct qos_info         qos;
 
@@ -258,14 +257,15 @@ static irqreturn_t pxa_irda_sir_irq(int irq, void *dev_id)
                         data = STRBR;
                         if (lsr & (LSR_OE | LSR_PE | LSR_FE | LSR_BI)) {
                                 printk(KERN_DEBUG "pxa_ir: sir receiving error\n");
-                                si->stats.rx_errors++;
+                                dev->stats.rx_errors++;
                                 if (lsr & LSR_FE)
-                                        si->stats.rx_frame_errors++;
+                                        dev->stats.rx_frame_errors++;
                                 if (lsr & LSR_OE)
-                                        si->stats.rx_fifo_errors++;
+                                        dev->stats.rx_fifo_errors++;
                         } else {
-                                si->stats.rx_bytes++;
-                                async_unwrap_char(dev, &si->stats, &si->rx_buff, data);
+                                dev->stats.rx_bytes++;
+                                async_unwrap_char(dev, &dev->stats,
+                                                  &si->rx_buff, data);
                         }
                         lsr = STLSR;
                 }
@@ -277,8 +277,8 @@ static irqreturn_t pxa_irda_sir_irq(int irq, void *dev_id)
 
         case 0x0C: /* Character Timeout Indication */
                 do  {
-                    si->stats.rx_bytes++;
-                    async_unwrap_char(dev, &si->stats, &si->rx_buff, STRBR);
+                    dev->stats.rx_bytes++;
+                    async_unwrap_char(dev, &dev->stats, &si->rx_buff, STRBR);
                 } while (STLSR & LSR_DR);
                 si->last_oscr = OSCR;
                 break;
@@ -290,9 +290,8 @@ static irqreturn_t pxa_irda_sir_irq(int irq, void *dev_id)
                 }
 
                 if (si->tx_buff.len == 0) {
-                        si->stats.tx_packets++;
-                        si->stats.tx_bytes += si->tx_buff.data -
-                                              si->tx_buff.head;
+                        dev->stats.tx_packets++;
+                        dev->stats.tx_bytes += si->tx_buff.data - si->tx_buff.head;
 
                         /* We need to ensure that the transmitter has finished. */
                         while ((STLSR & LSR_TEMT) == 0)
@@ -343,10 +342,10 @@ static void pxa_irda_fir_dma_tx_irq(int channel, void *data)
         DCSR(channel) = dcsr & ~DCSR_RUN;
 
         if (dcsr & DCSR_ENDINTR)  {
-                si->stats.tx_packets++;
-                si->stats.tx_bytes += si->dma_tx_buff_len;
+                dev->stats.tx_packets++;
+                dev->stats.tx_bytes += si->dma_tx_buff_len;
         } else {
-                si->stats.tx_errors++;
+                dev->stats.tx_errors++;
         }
 
         while (ICSR1 & ICSR1_TBY)
@@ -392,14 +391,14 @@ static void pxa_irda_fir_irq_eif(struct pxa_irda *si, struct net_device *dev, in
                 data = ICDR;
 
                 if (stat & (ICSR1_CRE | ICSR1_ROR)) {
-                        si->stats.rx_errors++;
+                        dev->stats.rx_errors++;
                         if (stat & ICSR1_CRE) {
                                 printk(KERN_DEBUG "pxa_ir: fir receive CRC error\n");
-                                si->stats.rx_crc_errors++;
+                                dev->stats.rx_crc_errors++;
                         }
                         if (stat & ICSR1_ROR) {
                                 printk(KERN_DEBUG "pxa_ir: fir receive overrun\n");
-                                si->stats.rx_over_errors++;
+                                dev->stats.rx_over_errors++;
                         }
                 } else  {
                         si->dma_rx_buff[len++] = data;
@@ -415,14 +414,14 @@ static void pxa_irda_fir_irq_eif(struct pxa_irda *si, struct net_device *dev, in
 
                 if (icsr0 & ICSR0_FRE) {
                         printk(KERN_ERR "pxa_ir: dropping erroneous frame\n");
-                        si->stats.rx_dropped++;
+                        dev->stats.rx_dropped++;
                         return;
                 }
 
                 skb = alloc_skb(len+1,GFP_ATOMIC);
                 if (!skb)  {
                         printk(KERN_ERR "pxa_ir: fir out of memory for receive skb\n");
-                        si->stats.rx_dropped++;
+                        dev->stats.rx_dropped++;
                         return;
                 }
 
@@ -437,8 +436,8 @@ static void pxa_irda_fir_irq_eif(struct pxa_irda *si, struct net_device *dev, in
                 skb->protocol = htons(ETH_P_IRDA);
                 netif_rx(skb);
 
-                si->stats.rx_packets++;
-                si->stats.rx_bytes += len;
+                dev->stats.rx_packets++;
+                dev->stats.rx_bytes += len;
         }
 }
 
@@ -457,10 +456,10 @@ static irqreturn_t pxa_irda_fir_irq(int irq, void *dev_id)
         if (icsr0 & (ICSR0_FRE | ICSR0_RAB)) {
                 if (icsr0 & ICSR0_FRE) {
                         printk(KERN_DEBUG "pxa_ir: fir receive frame error\n");
-                        si->stats.rx_frame_errors++;
+                        dev->stats.rx_frame_errors++;
                 } else {
                         printk(KERN_DEBUG "pxa_ir: fir receive abort\n");
-                        si->stats.rx_errors++;
+                        dev->stats.rx_errors++;
                 }
                 ICSR0 = icsr0 & (ICSR0_FRE | ICSR0_RAB);
         }
@@ -589,12 +588,6 @@ static int pxa_irda_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)
         return ret;
 }
 
-static struct net_device_stats *pxa_irda_stats(struct net_device *dev)
-{
-        struct pxa_irda *si = netdev_priv(dev);
-        return &si->stats;
-}
-
 static void pxa_irda_startup(struct pxa_irda *si)
 {
         /* Disable STUART interrupts */
@@ -857,7 +850,6 @@ static int pxa_irda_probe(struct platform_device *pdev)
         dev->open               = pxa_irda_start;
         dev->stop               = pxa_irda_stop;
         dev->do_ioctl           = pxa_irda_ioctl;
-        dev->get_stats          = pxa_irda_stats;
 
         irda_init_max_qos_capabilies(&si->qos);