tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

3c59x: use netstats in net_device structure

Use net_device_stats from net_device structure instead of local.

Signed-off-by: Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
Acked-by: Steffen Klassert <klassert@mathematik.tu-chemnitz.de>
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>

authored by Paulius Zaleckas and committed by Jeff Garzik 1daad055 aa807f79

+35 -36
unified split
+35 -36
drivers/net/3c59x.c
··· 600 struct sk_buff* tx_skbuff[TX_RING_SIZE]; 601 unsigned int cur_rx, cur_tx; /* The next free ring entry */ 602 unsigned int dirty_rx, dirty_tx; /* The ring entries to be free()ed. */ 603 - struct net_device_stats stats; /* Generic stats */ 604 struct vortex_extra_stats xstats; /* NIC-specific extra stats */ 605 struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */ 606 dma_addr_t tx_skb_dma; /* Allocated DMA address for bus master ctrl DMA. */ ··· 1874 1875 issue_and_wait(dev, TxReset); 1876 1877 - vp->stats.tx_errors++; 1878 if (vp->full_bus_master_tx) { 1879 printk(KERN_DEBUG "%s: Resetting the Tx ring pointer.\n", dev->name); 1880 if (vp->cur_tx - vp->dirty_tx > 0 && ioread32(ioaddr + DownListPtr) == 0) ··· 1886 iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold); 1887 iowrite16(DownUnstall, ioaddr + EL3_CMD); 1888 } else { 1889 - vp->stats.tx_dropped++; 1890 netif_wake_queue(dev); 1891 } 1892 ··· 1927 } 1928 dump_tx_ring(dev); 1929 } 1930 - if (tx_status & 0x14) vp->stats.tx_fifo_errors++; 1931 - if (tx_status & 0x38) vp->stats.tx_aborted_errors++; 1932 if (tx_status & 0x08) vp->xstats.tx_max_collisions++; 1933 iowrite8(0, ioaddr + TxStatus); 1934 if (tx_status & 0x30) { /* txJabber or txUnderrun */ ··· 2050 if (vortex_debug > 2) 2051 printk(KERN_DEBUG "%s: Tx error, status %2.2x.\n", 2052 dev->name, tx_status); 2053 - if (tx_status & 0x04) vp->stats.tx_fifo_errors++; 2054 - if (tx_status & 0x38) vp->stats.tx_aborted_errors++; 2055 if (tx_status & 0x30) { 2056 issue_and_wait(dev, TxReset); 2057 } ··· 2349 } else { 2350 printk(KERN_DEBUG "boomerang_interrupt: no skb!\n"); 2351 } 2352 - /* vp->stats.tx_packets++; Counted below. */ 2353 dirty_tx++; 2354 } 2355 vp->dirty_tx = dirty_tx; ··· 2408 unsigned char rx_error = ioread8(ioaddr + RxErrors); 2409 if (vortex_debug > 2) 2410 printk(KERN_DEBUG " Rx error: status %2.2x.\n", rx_error); 2411 - vp->stats.rx_errors++; 2412 - if (rx_error & 0x01) vp->stats.rx_over_errors++; 2413 - if (rx_error & 0x02) vp->stats.rx_length_errors++; 2414 - if (rx_error & 0x04) vp->stats.rx_frame_errors++; 2415 - if (rx_error & 0x08) vp->stats.rx_crc_errors++; 2416 - if (rx_error & 0x10) vp->stats.rx_length_errors++; 2417 } else { 2418 /* The packet length: up to 4.5K!. */ 2419 int pkt_len = rx_status & 0x1fff; ··· 2445 skb->protocol = eth_type_trans(skb, dev); 2446 netif_rx(skb); 2447 dev->last_rx = jiffies; 2448 - vp->stats.rx_packets++; 2449 /* Wait a limited time to go to next packet. */ 2450 for (i = 200; i >= 0; i--) 2451 if ( ! (ioread16(ioaddr + EL3_STATUS) & CmdInProgress)) ··· 2454 } else if (vortex_debug > 0) 2455 printk(KERN_NOTICE "%s: No memory to allocate a sk_buff of " 2456 "size %d.\n", dev->name, pkt_len); 2457 - vp->stats.rx_dropped++; 2458 } 2459 issue_and_wait(dev, RxDiscard); 2460 } ··· 2481 unsigned char rx_error = rx_status >> 16; 2482 if (vortex_debug > 2) 2483 printk(KERN_DEBUG " Rx error: status %2.2x.\n", rx_error); 2484 - vp->stats.rx_errors++; 2485 - if (rx_error & 0x01) vp->stats.rx_over_errors++; 2486 - if (rx_error & 0x02) vp->stats.rx_length_errors++; 2487 - if (rx_error & 0x04) vp->stats.rx_frame_errors++; 2488 - if (rx_error & 0x08) vp->stats.rx_crc_errors++; 2489 - if (rx_error & 0x10) vp->stats.rx_length_errors++; 2490 } else { 2491 /* The packet length: up to 4.5K!. */ 2492 int pkt_len = rx_status & 0x1fff; ··· 2528 } 2529 netif_rx(skb); 2530 dev->last_rx = jiffies; 2531 - vp->stats.rx_packets++; 2532 } 2533 entry = (++vp->cur_rx) % RX_RING_SIZE; 2534 } ··· 2590 del_timer_sync(&vp->rx_oom_timer); 2591 del_timer_sync(&vp->timer); 2592 2593 - /* Turn off statistics ASAP. We update vp->stats below. */ 2594 iowrite16(StatsDisable, ioaddr + EL3_CMD); 2595 2596 /* Disable the receiver and transmitter. */ ··· 2727 update_stats(ioaddr, dev); 2728 spin_unlock_irqrestore (&vp->lock, flags); 2729 } 2730 - return &vp->stats; 2731 } 2732 2733 /* Update statistics. ··· 2747 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */ 2748 /* Switch to the stats window, and read everything. */ 2749 EL3WINDOW(6); 2750 - vp->stats.tx_carrier_errors += ioread8(ioaddr + 0); 2751 - vp->stats.tx_heartbeat_errors += ioread8(ioaddr + 1); 2752 - vp->stats.tx_window_errors += ioread8(ioaddr + 4); 2753 - vp->stats.rx_fifo_errors += ioread8(ioaddr + 5); 2754 - vp->stats.tx_packets += ioread8(ioaddr + 6); 2755 - vp->stats.tx_packets += (ioread8(ioaddr + 9)&0x30) << 4; 2756 /* Rx packets */ ioread8(ioaddr + 7); /* Must read to clear */ 2757 /* Don't bother with register 9, an extension of registers 6&7. 2758 If we do use the 6&7 values the atomic update assumption above 2759 is invalid. */ 2760 - vp->stats.rx_bytes += ioread16(ioaddr + 10); 2761 - vp->stats.tx_bytes += ioread16(ioaddr + 12); 2762 /* Extra stats for get_ethtool_stats() */ 2763 vp->xstats.tx_multiple_collisions += ioread8(ioaddr + 2); 2764 vp->xstats.tx_single_collisions += ioread8(ioaddr + 3); ··· 2766 EL3WINDOW(4); 2767 vp->xstats.rx_bad_ssd += ioread8(ioaddr + 12); 2768 2769 - vp->stats.collisions = vp->xstats.tx_multiple_collisions 2770 + vp->xstats.tx_single_collisions 2771 + vp->xstats.tx_max_collisions; 2772 2773 { 2774 u8 up = ioread8(ioaddr + 13); 2775 - vp->stats.rx_bytes += (up & 0x0f) << 16; 2776 - vp->stats.tx_bytes += (up & 0xf0) << 12; 2777 } 2778 2779 EL3WINDOW(old_window >> 13);
··· 600 struct sk_buff* tx_skbuff[TX_RING_SIZE]; 601 unsigned int cur_rx, cur_tx; /* The next free ring entry */ 602 unsigned int dirty_rx, dirty_tx; /* The ring entries to be free()ed. */ 603 struct vortex_extra_stats xstats; /* NIC-specific extra stats */ 604 struct sk_buff *tx_skb; /* Packet being eaten by bus master ctrl. */ 605 dma_addr_t tx_skb_dma; /* Allocated DMA address for bus master ctrl DMA. */ ··· 1875 1876 issue_and_wait(dev, TxReset); 1877 1878 + dev->stats.tx_errors++; 1879 if (vp->full_bus_master_tx) { 1880 printk(KERN_DEBUG "%s: Resetting the Tx ring pointer.\n", dev->name); 1881 if (vp->cur_tx - vp->dirty_tx > 0 && ioread32(ioaddr + DownListPtr) == 0) ··· 1887 iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold); 1888 iowrite16(DownUnstall, ioaddr + EL3_CMD); 1889 } else { 1890 + dev->stats.tx_dropped++; 1891 netif_wake_queue(dev); 1892 } 1893 ··· 1928 } 1929 dump_tx_ring(dev); 1930 } 1931 + if (tx_status & 0x14) dev->stats.tx_fifo_errors++; 1932 + if (tx_status & 0x38) dev->stats.tx_aborted_errors++; 1933 if (tx_status & 0x08) vp->xstats.tx_max_collisions++; 1934 iowrite8(0, ioaddr + TxStatus); 1935 if (tx_status & 0x30) { /* txJabber or txUnderrun */ ··· 2051 if (vortex_debug > 2) 2052 printk(KERN_DEBUG "%s: Tx error, status %2.2x.\n", 2053 dev->name, tx_status); 2054 + if (tx_status & 0x04) dev->stats.tx_fifo_errors++; 2055 + if (tx_status & 0x38) dev->stats.tx_aborted_errors++; 2056 if (tx_status & 0x30) { 2057 issue_and_wait(dev, TxReset); 2058 } ··· 2350 } else { 2351 printk(KERN_DEBUG "boomerang_interrupt: no skb!\n"); 2352 } 2353 + /* dev->stats.tx_packets++; Counted below. */ 2354 dirty_tx++; 2355 } 2356 vp->dirty_tx = dirty_tx; ··· 2409 unsigned char rx_error = ioread8(ioaddr + RxErrors); 2410 if (vortex_debug > 2) 2411 printk(KERN_DEBUG " Rx error: status %2.2x.\n", rx_error); 2412 + dev->stats.rx_errors++; 2413 + if (rx_error & 0x01) dev->stats.rx_over_errors++; 2414 + if (rx_error & 0x02) dev->stats.rx_length_errors++; 2415 + if (rx_error & 0x04) dev->stats.rx_frame_errors++; 2416 + if (rx_error & 0x08) dev->stats.rx_crc_errors++; 2417 + if (rx_error & 0x10) dev->stats.rx_length_errors++; 2418 } else { 2419 /* The packet length: up to 4.5K!. */ 2420 int pkt_len = rx_status & 0x1fff; ··· 2446 skb->protocol = eth_type_trans(skb, dev); 2447 netif_rx(skb); 2448 dev->last_rx = jiffies; 2449 + dev->stats.rx_packets++; 2450 /* Wait a limited time to go to next packet. */ 2451 for (i = 200; i >= 0; i--) 2452 if ( ! (ioread16(ioaddr + EL3_STATUS) & CmdInProgress)) ··· 2455 } else if (vortex_debug > 0) 2456 printk(KERN_NOTICE "%s: No memory to allocate a sk_buff of " 2457 "size %d.\n", dev->name, pkt_len); 2458 + dev->stats.rx_dropped++; 2459 } 2460 issue_and_wait(dev, RxDiscard); 2461 } ··· 2482 unsigned char rx_error = rx_status >> 16; 2483 if (vortex_debug > 2) 2484 printk(KERN_DEBUG " Rx error: status %2.2x.\n", rx_error); 2485 + dev->stats.rx_errors++; 2486 + if (rx_error & 0x01) dev->stats.rx_over_errors++; 2487 + if (rx_error & 0x02) dev->stats.rx_length_errors++; 2488 + if (rx_error & 0x04) dev->stats.rx_frame_errors++; 2489 + if (rx_error & 0x08) dev->stats.rx_crc_errors++; 2490 + if (rx_error & 0x10) dev->stats.rx_length_errors++; 2491 } else { 2492 /* The packet length: up to 4.5K!. */ 2493 int pkt_len = rx_status & 0x1fff; ··· 2529 } 2530 netif_rx(skb); 2531 dev->last_rx = jiffies; 2532 + dev->stats.rx_packets++; 2533 } 2534 entry = (++vp->cur_rx) % RX_RING_SIZE; 2535 } ··· 2591 del_timer_sync(&vp->rx_oom_timer); 2592 del_timer_sync(&vp->timer); 2593 2594 + /* Turn off statistics ASAP. We update dev->stats below. */ 2595 iowrite16(StatsDisable, ioaddr + EL3_CMD); 2596 2597 /* Disable the receiver and transmitter. */ ··· 2728 update_stats(ioaddr, dev); 2729 spin_unlock_irqrestore (&vp->lock, flags); 2730 } 2731 + return &dev->stats; 2732 } 2733 2734 /* Update statistics. ··· 2748 /* Unlike the 3c5x9 we need not turn off stats updates while reading. */ 2749 /* Switch to the stats window, and read everything. */ 2750 EL3WINDOW(6); 2751 + dev->stats.tx_carrier_errors += ioread8(ioaddr + 0); 2752 + dev->stats.tx_heartbeat_errors += ioread8(ioaddr + 1); 2753 + dev->stats.tx_window_errors += ioread8(ioaddr + 4); 2754 + dev->stats.rx_fifo_errors += ioread8(ioaddr + 5); 2755 + dev->stats.tx_packets += ioread8(ioaddr + 6); 2756 + dev->stats.tx_packets += (ioread8(ioaddr + 9)&0x30) << 4; 2757 /* Rx packets */ ioread8(ioaddr + 7); /* Must read to clear */ 2758 /* Don't bother with register 9, an extension of registers 6&7. 2759 If we do use the 6&7 values the atomic update assumption above 2760 is invalid. */ 2761 + dev->stats.rx_bytes += ioread16(ioaddr + 10); 2762 + dev->stats.tx_bytes += ioread16(ioaddr + 12); 2763 /* Extra stats for get_ethtool_stats() */ 2764 vp->xstats.tx_multiple_collisions += ioread8(ioaddr + 2); 2765 vp->xstats.tx_single_collisions += ioread8(ioaddr + 3); ··· 2767 EL3WINDOW(4); 2768 vp->xstats.rx_bad_ssd += ioread8(ioaddr + 12); 2769 2770 + dev->stats.collisions = vp->xstats.tx_multiple_collisions 2771 + vp->xstats.tx_single_collisions 2772 + vp->xstats.tx_max_collisions; 2773 2774 { 2775 u8 up = ioread8(ioaddr + 13); 2776 + dev->stats.rx_bytes += (up & 0x0f) << 16; 2777 + dev->stats.tx_bytes += (up & 0xf0) << 12; 2778 } 2779 2780 EL3WINDOW(old_window >> 13);