/********************************************************************** * Author: Cavium Networks * * Contact: support@caviumnetworks.com * This file is part of the OCTEON SDK * * Copyright (c) 2003-2007 Cavium Networks * * This file is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License, Version 2, as * published by the Free Software Foundation. * * This file is distributed in the hope that it will be useful, but * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or * NONINFRINGEMENT. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License * along with this file; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * or visit http://www.gnu.org/licenses/. * * This file may also be available under a different license from Cavium. * Contact Cavium Networks for more information **********************************************************************/ #include #include #include #include #include #include #include "octeon-ethernet.h" #include "ethernet-defines.h" #include "cvmx-helper.h" #include "cvmx-pip.h" static unsigned long long cvm_oct_stats_read_switch(struct net_device *dev, int phy_id, int offset) { struct octeon_ethernet *priv = netdev_priv(dev); priv->mii_info.mdio_write(dev, phy_id, 0x1d, 0xcc00 | offset); return ((uint64_t) priv->mii_info. mdio_read(dev, phy_id, 0x1e) << 16) | (uint64_t) priv->mii_info. mdio_read(dev, phy_id, 0x1f); } static int cvm_oct_stats_switch_show(struct seq_file *m, void *v) { static const int ports[] = { 0, 1, 2, 3, 9, -1 }; struct net_device *dev = cvm_oct_device[0]; int index = 0; while (ports[index] != -1) { /* Latch port */ struct octeon_ethernet *priv = netdev_priv(dev); priv->mii_info.mdio_write(dev, 0x1b, 0x1d, 0xdc00 | ports[index]); seq_printf(m, "\nSwitch Port %d\n", ports[index]); seq_printf(m, "InGoodOctets: %12llu\t" "OutOctets: %12llu\t" "64 Octets: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x00) | (cvm_oct_stats_read_switch(dev, 0x1b, 0x01) << 32), cvm_oct_stats_read_switch(dev, 0x1b, 0x0E) | (cvm_oct_stats_read_switch(dev, 0x1b, 0x0F) << 32), cvm_oct_stats_read_switch(dev, 0x1b, 0x08)); seq_printf(m, "InBadOctets: %12llu\t" "OutUnicast: %12llu\t" "65-127 Octets: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x02), cvm_oct_stats_read_switch(dev, 0x1b, 0x10), cvm_oct_stats_read_switch(dev, 0x1b, 0x09)); seq_printf(m, "InUnicast: %12llu\t" "OutBroadcasts: %12llu\t" "128-255 Octets: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x04), cvm_oct_stats_read_switch(dev, 0x1b, 0x13), cvm_oct_stats_read_switch(dev, 0x1b, 0x0A)); seq_printf(m, "InBroadcasts: %12llu\t" "OutMulticasts: %12llu\t" "256-511 Octets: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x06), cvm_oct_stats_read_switch(dev, 0x1b, 0x12), cvm_oct_stats_read_switch(dev, 0x1b, 0x0B)); seq_printf(m, "InMulticasts: %12llu\t" "OutPause: %12llu\t" "512-1023 Octets:%12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x07), cvm_oct_stats_read_switch(dev, 0x1b, 0x15), cvm_oct_stats_read_switch(dev, 0x1b, 0x0C)); seq_printf(m, "InPause: %12llu\t" "Excessive: %12llu\t" "1024-Max Octets:%12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x16), cvm_oct_stats_read_switch(dev, 0x1b, 0x11), cvm_oct_stats_read_switch(dev, 0x1b, 0x0D)); seq_printf(m, "InUndersize: %12llu\t" "Collisions: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x18), cvm_oct_stats_read_switch(dev, 0x1b, 0x1E)); seq_printf(m, "InFragments: %12llu\t" "Deferred: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x19), cvm_oct_stats_read_switch(dev, 0x1b, 0x05)); seq_printf(m, "InOversize: %12llu\t" "Single: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x1A), cvm_oct_stats_read_switch(dev, 0x1b, 0x14)); seq_printf(m, "InJabber: %12llu\t" "Multiple: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x1B), cvm_oct_stats_read_switch(dev, 0x1b, 0x17)); seq_printf(m, "In RxErr: %12llu\t" "OutFCSErr: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x1C), cvm_oct_stats_read_switch(dev, 0x1b, 0x03)); seq_printf(m, "InFCSErr: %12llu\t" "Late: %12llu\n", cvm_oct_stats_read_switch(dev, 0x1b, 0x1D), cvm_oct_stats_read_switch(dev, 0x1b, 0x1F)); index++; } return 0; } /** * User is reading /proc/octeon_ethernet_stats * * @m: * @v: * Returns */ static int cvm_oct_stats_show(struct seq_file *m, void *v) { struct octeon_ethernet *priv; int port; for (port = 0; port < TOTAL_NUMBER_OF_PORTS; port++) { if (cvm_oct_device[port]) { priv = netdev_priv(cvm_oct_device[port]); seq_printf(m, "\nOcteon Port %d (%s)\n", port, cvm_oct_device[port]->name); seq_printf(m, "rx_packets: %12lu\t" "tx_packets: %12lu\n", priv->stats.rx_packets, priv->stats.tx_packets); seq_printf(m, "rx_bytes: %12lu\t" "tx_bytes: %12lu\n", priv->stats.rx_bytes, priv->stats.tx_bytes); seq_printf(m, "rx_errors: %12lu\t" "tx_errors: %12lu\n", priv->stats.rx_errors, priv->stats.tx_errors); seq_printf(m, "rx_dropped: %12lu\t" "tx_dropped: %12lu\n", priv->stats.rx_dropped, priv->stats.tx_dropped); seq_printf(m, "rx_length_errors: %12lu\t" "tx_aborted_errors: %12lu\n", priv->stats.rx_length_errors, priv->stats.tx_aborted_errors); seq_printf(m, "rx_over_errors: %12lu\t" "tx_carrier_errors: %12lu\n", priv->stats.rx_over_errors, priv->stats.tx_carrier_errors); seq_printf(m, "rx_crc_errors: %12lu\t" "tx_fifo_errors: %12lu\n", priv->stats.rx_crc_errors, priv->stats.tx_fifo_errors); seq_printf(m, "rx_frame_errors: %12lu\t" "tx_heartbeat_errors: %12lu\n", priv->stats.rx_frame_errors, priv->stats.tx_heartbeat_errors); seq_printf(m, "rx_fifo_errors: %12lu\t" "tx_window_errors: %12lu\n", priv->stats.rx_fifo_errors, priv->stats.tx_window_errors); seq_printf(m, "rx_missed_errors: %12lu\t" "multicast: %12lu\n", priv->stats.rx_missed_errors, priv->stats.multicast); } } if (cvm_oct_device[0]) { priv = netdev_priv(cvm_oct_device[0]); if (priv->imode == CVMX_HELPER_INTERFACE_MODE_GMII) cvm_oct_stats_switch_show(m, v); } return 0; } /** * /proc/octeon_ethernet_stats was openned. Use the single_open iterator * * @inode: * @file: * Returns */ static int cvm_oct_stats_open(struct inode *inode, struct file *file) { return single_open(file, cvm_oct_stats_show, NULL); } static const struct file_operations cvm_oct_stats_operations = { .open = cvm_oct_stats_open, .read = seq_read, .llseek = seq_lseek, .release = single_release, }; void cvm_oct_proc_initialize(void) { struct proc_dir_entry *entry = create_proc_entry("octeon_ethernet_stats", 0, NULL); if (entry) entry->proc_fops = &cvm_oct_stats_operations; } void cvm_oct_proc_shutdown(void) { remove_proc_entry("octeon_ethernet_stats", NULL); }