Changeset 0190cfd in rtems-libbsd


Ignore:
Timestamp:
Sep 22, 2017, 7:41:19 AM (19 months ago)
Author:
Christian Mauderer <Christian.Mauderer@…>
Branches:
647dd08ae2aa69b935c2847ea450fb824322ecae, c6261f97870562d4c797cfb1ff1ba0affb85a916
Children:
c6f4aa6
Parents:
80a7fe6
git-author:
Christian Mauderer <Christian.Mauderer@…> (09/22/17 07:41:19)
git-committer:
Sebastian Huber <sebastian.huber@…> (09/22/17 08:17:26)
Message:

if_atsam: Move statistics to sysctl.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • rtemsbsd/sys/dev/atsam/if_atsam.c

    r80a7fe6 r0190cfd  
    4848#include <sys/module.h>
    4949#include <sys/bus.h>
     50#include <sys/sysctl.h>
    5051
    5152#include <net/if.h>
     
    122123
    123124#define WATCHDOG_TIMEOUT                        5
    124 
    125 #define SIO_RTEMS_SHOW_STATS _IO('i', 250)
    126125
    127126/* FIXME: Make these configurable */
     
    170169        size_t amount_tx_buf;
    171170        ring_buffer tx_ring;
     171        struct callout tick_ch;
    172172
    173173        /*
     
    177177        uint8_t link_speed;
    178178        uint8_t link_duplex;
    179         struct callout mii_tick_ch;
    180179
    181180        /*
    182181         * Statistics
    183182         */
    184         unsigned rx_overrun_errors;
    185         unsigned rx_interrupts;
    186         unsigned tx_complete_int;
    187         unsigned tx_tur_errors;
    188         unsigned tx_rlex_errors;
    189         unsigned tx_tfc_errors;
    190         unsigned tx_hresp_errors;
    191         unsigned tx_interrupts;
     183        struct if_atsam_stats {
     184                /* Software */
     185                uint32_t rx_overrun_errors;
     186                uint32_t rx_interrupts;
     187                uint32_t tx_complete_int;
     188                uint32_t tx_tur_errors;
     189                uint32_t tx_rlex_errors;
     190                uint32_t tx_tfc_errors;
     191                uint32_t tx_hresp_errors;
     192                uint32_t tx_interrupts;
     193
     194                /* Hardware */
     195                uint64_t octets_transm;
     196                uint32_t frames_transm;
     197                uint32_t broadcast_frames_transm;
     198                uint32_t multicast_frames_transm;
     199                uint32_t pause_frames_transm;
     200                uint32_t frames_64_byte_transm;
     201                uint32_t frames_65_to_127_byte_transm;
     202                uint32_t frames_128_to_255_byte_transm;
     203                uint32_t frames_256_to_511_byte_transm;
     204                uint32_t frames_512_to_1023_byte_transm;
     205                uint32_t frames_1024_to_1518_byte_transm;
     206                uint32_t frames_greater_1518_byte_transm;
     207                uint32_t transmit_underruns;
     208                uint32_t single_collision_frames;
     209                uint32_t multiple_collision_frames;
     210                uint32_t excessive_collisions;
     211                uint32_t late_collisions;
     212                uint32_t deferred_transmission_frames;
     213                uint32_t carrier_sense_errors;
     214                uint64_t octets_rec;
     215                uint32_t frames_rec;
     216                uint32_t broadcast_frames_rec;
     217                uint32_t multicast_frames_rec;
     218                uint32_t pause_frames_rec;
     219                uint32_t frames_64_byte_rec;
     220                uint32_t frames_65_to_127_byte_rec;
     221                uint32_t frames_128_to_255_byte_rec;
     222                uint32_t frames_256_to_511_byte_rec;
     223                uint32_t frames_512_to_1023_byte_rec;
     224                uint32_t frames_1024_to_1518_byte_rec;
     225                uint32_t frames_1519_to_maximum_byte_rec;
     226                uint32_t undersize_frames_rec;
     227                uint32_t oversize_frames_rec;
     228                uint32_t jabbers_rec;
     229                uint32_t frame_check_sequence_errors;
     230                uint32_t length_field_frame_errors;
     231                uint32_t receive_symbol_errors;
     232                uint32_t alignment_errors;
     233                uint32_t receive_resource_errors;
     234                uint32_t receive_overrun;
     235                uint32_t ip_header_checksum_errors;
     236                uint32_t tcp_checksum_errors;
     237                uint32_t udp_checksum_errors;
     238        } stats;
    192239} if_atsam_softc;
    193240
    194 static void if_atsam_watchdog(void *arg);
     241static void if_atsam_poll_hw_stats(struct if_atsam_softc *sc);
    195242
    196243#define IF_ATSAM_LOCK(sc) mtx_lock(&(sc)->mtx)
     
    361408        /* Check receive interrupts */
    362409        if ((irq_status_val & GMAC_IER_ROVR) != 0) {
    363                 ++sc->rx_overrun_errors;
     410                ++sc->stats.rx_overrun_errors;
    364411                rx_event = ATSAMV7_ETH_RX_EVENT_INTERRUPT;
    365412        }
     
    369416        /* Send events to receive task and switch off rx interrupts */
    370417        if (rx_event != 0) {
    371                 ++sc->rx_interrupts;
     418                ++sc->stats.rx_interrupts;
    372419                /* Erase the interrupts for RX completion and errors */
    373420                GMAC_DisableIt(pHw, GMAC_IER_RCOMP | GMAC_IER_ROVR, 0);
     
    375422        }
    376423        if ((irq_status_val & GMAC_IER_TUR) != 0) {
    377                 ++sc->tx_tur_errors;
     424                ++sc->stats.tx_tur_errors;
    378425                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    379426        }
    380427        if ((irq_status_val & GMAC_IER_RLEX) != 0) {
    381                 ++sc->tx_rlex_errors;
     428                ++sc->stats.tx_rlex_errors;
    382429                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    383430        }
    384431        if ((irq_status_val & GMAC_IER_TFC) != 0) {
    385                 ++sc->tx_tfc_errors;
     432                ++sc->stats.tx_tfc_errors;
    386433                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    387434        }
    388435        if ((irq_status_val & GMAC_IER_HRESP) != 0) {
    389                 ++sc->tx_hresp_errors;
     436                ++sc->stats.tx_hresp_errors;
    390437                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    391438        }
    392439        if ((irq_status_val & GMAC_IER_TCOMP) != 0) {
    393                 ++sc->tx_complete_int;
     440                ++sc->stats.tx_complete_int;
    394441                tx_event = ATSAMV7_ETH_TX_EVENT_INTERRUPT;
    395442        }
    396443        /* Send events to transmit task and switch off tx interrupts */
    397444        if (tx_event != 0) {
    398                 ++sc->tx_interrupts;
     445                ++sc->stats.tx_interrupts;
    399446                /* Erase the interrupts for TX completion and errors */
    400447                GMAC_DisableIt(pHw, GMAC_INT_TX_BITS, 0);
     
    846893
    847894static void
    848 if_atsam_mii_tick(void *context)
     895if_atsam_tick(void *context)
    849896{
    850897        if_atsam_softc *sc = context;
    851898
    852         if (sc->miibus == NULL)
    853                 return;
     899        if_atsam_poll_hw_stats(sc);
    854900
    855901        IF_ATSAM_UNLOCK(sc);
    856902
    857903        mii_tick(device_get_softc(sc->miibus));
    858         callout_reset(&sc->mii_tick_ch, hz, if_atsam_mii_tick, sc);
     904        callout_reset(&sc->tick_ch, hz, if_atsam_tick, sc);
    859905}
    860906
     
    924970                if_atsam_tx_daemon, sc);
    925971
    926         callout_reset(&sc->mii_tick_ch, hz, if_atsam_mii_tick, sc);
     972        callout_reset(&sc->tick_ch, hz, if_atsam_tick, sc);
    927973
    928974        ifp->if_drv_flags |= IFF_DRV_RUNNING;
     
    946992
    947993
    948 /*
    949  * Show interface statistics
    950  */
    951 static void if_atsam_stats(struct if_atsam_softc *sc)
    952 {
    953         int eno = EIO;
    954         Gmac *pHw;
    955 
    956         pHw = sc->Gmac_inst.gGmacd.pHw;
    957 
    958         printf("\n** Context Statistics **\n");
    959         printf("Rx interrupts: %u\n", sc->rx_interrupts);
    960         printf("Tx interrupts: %u\n", sc->tx_interrupts);
    961         printf("Error Tur Tx interrupts: %u\n\n", sc->tx_tur_errors);
    962         printf("Error Rlex Tx interrupts: %u\n\n", sc->tx_rlex_errors);
    963         printf("Error Tfc Tx interrupts: %u\n\n", sc->tx_tfc_errors);
    964         printf("Error Hresp Tx interrupts: %u\n\n", sc->tx_hresp_errors);
    965         printf("Tx complete interrupts: %u\n\n", sc->tx_complete_int);
    966         printf("\n** Statistics **\n");
    967         printf("Octets Transmitted Low: %lu\n", pHw->GMAC_OTLO);
    968         printf("Octets Transmitted High: %lu\n", pHw->GMAC_OTHI);
    969         printf("Frames Transmitted: %lu\n", pHw->GMAC_FT);
    970         printf("Broadcast Frames Transmitted: %lu\n", pHw->GMAC_BCFT);
    971         printf("Multicast Frames Transmitted: %lu\n", pHw->GMAC_MFT);
    972         printf("Pause Frames Transmitted: %lu\n", pHw->GMAC_PFT);
    973         printf("64 Byte Frames Transmitted: %lu\n", pHw->GMAC_BFT64);
    974         printf("65 to 127 Byte Frames Transmitted: %lu\n", pHw->GMAC_TBFT127);
    975         printf("128 to 255 Byte Frames Transmitted: %lu\n", pHw->GMAC_TBFR255);
    976         printf("256 to 511 Byte Frames Transmitted: %lu\n", pHw->GMAC_TBFT511);
    977         printf("512 to 1023 Byte Frames Transmitted: %lu\n",
    978             pHw->GMAC_TBFT1023);
    979         printf("1024 to 1518 Byte Frames Transmitted: %lu\n",
    980             pHw->GMAC_TBFT1518);
    981         printf("Greater Than 1518 Byte Frames Transmitted: %lu\n",
    982             pHw->GMAC_GTBFT1518);
    983         printf("Transmit Underruns: %lu\n", pHw->GMAC_TUR);
    984         printf("Single Collision Frames: %lu\n", pHw->GMAC_SCF);
    985         printf("Multiple Collision Frames: %lu\n", pHw->GMAC_MCF);
    986         printf("Excessive Collisions: %lu\n", pHw->GMAC_EC);
    987         printf("Late Collisions: %lu\n", pHw->GMAC_LC);
    988         printf("Deferred Transmission Frames: %lu\n", pHw->GMAC_DTF);
    989         printf("Carrier Sense Errors: %lu\n", pHw->GMAC_CSE);
    990         printf("Octets Received Low: %lu\n", pHw->GMAC_ORLO);
    991         printf("Octets Received High: %lu\n", pHw->GMAC_ORHI);
    992         printf("Frames Received: %lu\n", pHw->GMAC_FR);
    993         printf("Broadcast Frames Received: %lu\n", pHw->GMAC_BCFR);
    994         printf("Multicast Frames Received: %lu\n", pHw->GMAC_MFR);
    995         printf("Pause Frames Received: %lu\n", pHw->GMAC_PFR);
    996         printf("64 Byte Frames Received: %lu\n", pHw->GMAC_BFR64);
    997         printf("65 to 127 Byte Frames Received: %lu\n", pHw->GMAC_TBFR127);
    998         printf("128 to 255 Byte Frames Received: %lu\n", pHw->GMAC_TBFR255);
    999         printf("256 to 511 Byte Frames Received: %lu\n", pHw->GMAC_TBFR511);
    1000         printf("512 to 1023 Byte Frames Received: %lu\n", pHw->GMAC_TBFR1023);
    1001         printf("1024 to 1518 Byte Frames Received: %lu\n", pHw->GMAC_TBFR1518);
    1002         printf("1519 to Maximum Byte Frames Received: %lu\n",
    1003             pHw->GMAC_TBFR1518);
    1004         printf("Undersize Frames Received: %lu\n", pHw->GMAC_UFR);
    1005         printf("Oversize Frames Received: %lu\n", pHw->GMAC_OFR);
    1006         printf("Jabbers Received: %lu\n", pHw->GMAC_JR);
    1007         printf("Frame Check Sequence Errors: %lu\n", pHw->GMAC_FCSE);
    1008         printf("Length Field Frame Errors: %lu\n", pHw->GMAC_LFFE);
    1009         printf("Receive Symbol Errors: %lu\n", pHw->GMAC_RSE);
    1010         printf("Alignment Errors: %lu\n", pHw->GMAC_AE);
    1011         printf("Receive Resource Errors: %lu\n", pHw->GMAC_RRE);
    1012         printf("Receive Overrun: %lu\n", pHw->GMAC_ROE);
    1013         printf("IP Header Checksum Errors: %lu\n", pHw->GMAC_IHCE);
    1014         printf("TCP Checksum Errors: %lu\n", pHw->GMAC_TCE);
    1015         printf("UDP Checksum Errors: %lu\n", pHw->GMAC_UCE);
     994static void
     995if_atsam_poll_hw_stats(struct if_atsam_softc *sc)
     996{
     997        uint64_t octets;
     998        Gmac *pHw = sc->Gmac_inst.gGmacd.pHw;
     999
     1000        octets = pHw->GMAC_OTLO;
     1001        octets |= pHw->GMAC_OTHI << 32;
     1002        sc->stats.octets_transm += octets;
     1003        sc->stats.frames_transm += pHw->GMAC_FT;
     1004        sc->stats.broadcast_frames_transm += pHw->GMAC_BCFT;
     1005        sc->stats.multicast_frames_transm += pHw->GMAC_MFT;
     1006        sc->stats.pause_frames_transm += pHw->GMAC_PFT;
     1007        sc->stats.frames_64_byte_transm += pHw->GMAC_BFT64;
     1008        sc->stats.frames_65_to_127_byte_transm += pHw->GMAC_TBFT127;
     1009        sc->stats.frames_128_to_255_byte_transm += pHw->GMAC_TBFT255;
     1010        sc->stats.frames_256_to_511_byte_transm += pHw->GMAC_TBFT511;
     1011        sc->stats.frames_512_to_1023_byte_transm += pHw->GMAC_TBFT1023;
     1012        sc->stats.frames_1024_to_1518_byte_transm += pHw->GMAC_TBFT1518;
     1013        sc->stats.frames_greater_1518_byte_transm += pHw->GMAC_GTBFT1518;
     1014        sc->stats.transmit_underruns += pHw->GMAC_TUR;
     1015        sc->stats.single_collision_frames += pHw->GMAC_SCF;
     1016        sc->stats.multiple_collision_frames += pHw->GMAC_MCF;
     1017        sc->stats.excessive_collisions += pHw->GMAC_EC;
     1018        sc->stats.late_collisions += pHw->GMAC_LC;
     1019        sc->stats.deferred_transmission_frames += pHw->GMAC_DTF;
     1020        sc->stats.carrier_sense_errors += pHw->GMAC_CSE;
     1021
     1022        octets = pHw->GMAC_ORLO;
     1023        octets |= pHw->GMAC_ORHI << 32;
     1024        sc->stats.octets_rec += octets;
     1025        sc->stats.frames_rec += pHw->GMAC_FR;
     1026        sc->stats.broadcast_frames_rec += pHw->GMAC_BCFR;
     1027        sc->stats.multicast_frames_rec += pHw->GMAC_MFR;
     1028        sc->stats.pause_frames_rec += pHw->GMAC_PFR;
     1029        sc->stats.frames_64_byte_rec += pHw->GMAC_BFR64;
     1030        sc->stats.frames_65_to_127_byte_rec += pHw->GMAC_TBFR127;
     1031        sc->stats.frames_128_to_255_byte_rec += pHw->GMAC_TBFR255;
     1032        sc->stats.frames_256_to_511_byte_rec += pHw->GMAC_TBFR511;
     1033        sc->stats.frames_512_to_1023_byte_rec += pHw->GMAC_TBFR1023;
     1034        sc->stats.frames_1024_to_1518_byte_rec += pHw->GMAC_TBFR1518;
     1035        sc->stats.frames_1519_to_maximum_byte_rec += pHw->GMAC_TMXBFR;
     1036        sc->stats.undersize_frames_rec += pHw->GMAC_UFR;
     1037        sc->stats.oversize_frames_rec += pHw->GMAC_OFR;
     1038        sc->stats.jabbers_rec += pHw->GMAC_JR;
     1039        sc->stats.frame_check_sequence_errors += pHw->GMAC_FCSE;
     1040        sc->stats.length_field_frame_errors += pHw->GMAC_LFFE;
     1041        sc->stats.receive_symbol_errors += pHw->GMAC_RSE;
     1042        sc->stats.alignment_errors += pHw->GMAC_AE;
     1043        sc->stats.receive_resource_errors += pHw->GMAC_RRE;
     1044        sc->stats.receive_overrun += pHw->GMAC_ROE;
     1045
     1046        sc->stats.ip_header_checksum_errors += pHw->GMAC_IHCE;
     1047        sc->stats.tcp_checksum_errors += pHw->GMAC_TCE;
     1048        sc->stats.udp_checksum_errors += pHw->GMAC_UCE;
     1049}
     1050
     1051
     1052static void
     1053if_atsam_add_sysctls(device_t dev)
     1054{
     1055        struct if_atsam_softc *sc = device_get_softc(dev);
     1056        struct sysctl_ctx_list *ctx;
     1057        struct sysctl_oid_list *statsnode;
     1058        struct sysctl_oid_list *hwstatsnode;
     1059        struct sysctl_oid_list *child;
     1060        struct sysctl_oid *tree;
     1061
     1062        ctx = device_get_sysctl_ctx(dev);
     1063        child = SYSCTL_CHILDREN(device_get_sysctl_tree(dev));
     1064
     1065        tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", CTLFLAG_RD,
     1066                               NULL, "if_atsam statistics");
     1067        statsnode = SYSCTL_CHILDREN(tree);
     1068
     1069        tree = SYSCTL_ADD_NODE(ctx, statsnode, OID_AUTO, "sw", CTLFLAG_RD,
     1070                               NULL, "if_atsam software statistics");
     1071        child = SYSCTL_CHILDREN(tree);
     1072
     1073        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "rx_overrun_errors",
     1074            CTLFLAG_RD, &sc->stats.rx_overrun_errors, 0,
     1075            "RX overrun errors");
     1076        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "rx_interrupts",
     1077            CTLFLAG_RD, &sc->stats.rx_interrupts, 0,
     1078            "Rx interrupts");
     1079        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_complete_int",
     1080            CTLFLAG_RD, &sc->stats.tx_complete_int, 0,
     1081            "Tx complete interrupts");
     1082        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_tur_errors",
     1083            CTLFLAG_RD, &sc->stats.tx_tur_errors, 0,
     1084            "Error Tur Tx interrupts");
     1085        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_rlex_errors",
     1086            CTLFLAG_RD, &sc->stats.tx_rlex_errors, 0,
     1087            "Error Rlex Tx interrupts");
     1088        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_tfc_errors",
     1089            CTLFLAG_RD, &sc->stats.tx_tfc_errors, 0,
     1090            "Error Tfc Tx interrupts");
     1091        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_hresp_errors",
     1092            CTLFLAG_RD, &sc->stats.tx_hresp_errors, 0,
     1093            "Error Hresp Tx interrupts");
     1094        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tx_interrupts",
     1095            CTLFLAG_RD, &sc->stats.tx_interrupts, 0,
     1096            "Tx interrupts");
     1097
     1098        tree = SYSCTL_ADD_NODE(ctx, statsnode, OID_AUTO, "hw", CTLFLAG_RD,
     1099                               NULL, "if_atsam hardware statistics");
     1100        hwstatsnode = SYSCTL_CHILDREN(tree);
     1101
     1102        tree = SYSCTL_ADD_NODE(ctx, hwstatsnode, OID_AUTO, "tx", CTLFLAG_RD,
     1103                               NULL, "if_atsam hardware transmit statistics");
     1104        child = SYSCTL_CHILDREN(tree);
     1105
     1106        SYSCTL_ADD_UQUAD(ctx, child, OID_AUTO, "octets_transm",
     1107            CTLFLAG_RD, &sc->stats.octets_transm,
     1108            "Octets Transmitted");
     1109        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_transm",
     1110            CTLFLAG_RD, &sc->stats.frames_transm, 0,
     1111            "Frames Transmitted");
     1112        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "broadcast_frames_transm",
     1113            CTLFLAG_RD, &sc->stats.broadcast_frames_transm, 0,
     1114            "Broadcast Frames Transmitted");
     1115        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "multicast_frames_transm",
     1116            CTLFLAG_RD, &sc->stats.multicast_frames_transm, 0,
     1117            "Multicast Frames Transmitted");
     1118        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "pause_frames_transm",
     1119            CTLFLAG_RD, &sc->stats.pause_frames_transm, 0,
     1120            "Pause Frames Transmitted");
     1121        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_64_byte_transm",
     1122            CTLFLAG_RD, &sc->stats.frames_64_byte_transm, 0,
     1123            "64 Byte Frames Transmitted");
     1124        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_65_to_127_byte_transm",
     1125            CTLFLAG_RD, &sc->stats.frames_65_to_127_byte_transm, 0,
     1126            "65 to 127 Byte Frames Transmitted");
     1127        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_128_to_255_byte_transm",
     1128            CTLFLAG_RD, &sc->stats.frames_128_to_255_byte_transm, 0,
     1129            "128 to 255 Byte Frames Transmitted");
     1130        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_256_to_511_byte_transm",
     1131            CTLFLAG_RD, &sc->stats.frames_256_to_511_byte_transm, 0,
     1132            "256 to 511 Byte Frames Transmitted");
     1133        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_512_to_1023_byte_transm",
     1134            CTLFLAG_RD, &sc->stats.frames_512_to_1023_byte_transm, 0,
     1135            "512 to 1023 Byte Frames Transmitted");
     1136        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_1024_to_1518_byte_transm",
     1137            CTLFLAG_RD, &sc->stats.frames_1024_to_1518_byte_transm, 0,
     1138            "1024 to 1518 Byte Frames Transmitted");
     1139        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_greater_1518_byte_transm",
     1140            CTLFLAG_RD, &sc->stats.frames_greater_1518_byte_transm, 0,
     1141            "Greater Than 1518 Byte Frames Transmitted");
     1142        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "transmit_underruns",
     1143            CTLFLAG_RD, &sc->stats.transmit_underruns, 0,
     1144            "Transmit Underruns");
     1145        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "single_collision_frames",
     1146            CTLFLAG_RD, &sc->stats.single_collision_frames, 0,
     1147            "Single Collision Frames");
     1148        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "multiple_collision_frames",
     1149            CTLFLAG_RD, &sc->stats.multiple_collision_frames, 0,
     1150            "Multiple Collision Frames");
     1151        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "excessive_collisions",
     1152            CTLFLAG_RD, &sc->stats.excessive_collisions, 0,
     1153            "Excessive Collisions");
     1154        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "late_collisions",
     1155            CTLFLAG_RD, &sc->stats.late_collisions, 0,
     1156            "Late Collisions");
     1157        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "deferred_transmission_frames",
     1158            CTLFLAG_RD, &sc->stats.deferred_transmission_frames, 0,
     1159            "Deferred Transmission Frames");
     1160        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "carrier_sense_errors",
     1161            CTLFLAG_RD, &sc->stats.carrier_sense_errors, 0,
     1162            "Carrier Sense Errors");
     1163
     1164        tree = SYSCTL_ADD_NODE(ctx, hwstatsnode, OID_AUTO, "rx", CTLFLAG_RD,
     1165                               NULL, "if_atsam hardware receive statistics");
     1166        child = SYSCTL_CHILDREN(tree);
     1167
     1168        SYSCTL_ADD_UQUAD(ctx, child, OID_AUTO, "octets_rec",
     1169            CTLFLAG_RD, &sc->stats.octets_rec,
     1170            "Octets Received");
     1171        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_rec",
     1172            CTLFLAG_RD, &sc->stats.frames_rec, 0,
     1173            "Frames Received");
     1174        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "broadcast_frames_rec",
     1175            CTLFLAG_RD, &sc->stats.broadcast_frames_rec, 0,
     1176            "Broadcast Frames Received");
     1177        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "multicast_frames_rec",
     1178            CTLFLAG_RD, &sc->stats.multicast_frames_rec, 0,
     1179            "Multicast Frames Received");
     1180        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "pause_frames_rec",
     1181            CTLFLAG_RD, &sc->stats.pause_frames_rec, 0,
     1182            "Pause Frames Received");
     1183        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_64_byte_rec",
     1184            CTLFLAG_RD, &sc->stats.frames_64_byte_rec, 0,
     1185            "64 Byte Frames Received");
     1186        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_65_to_127_byte_rec",
     1187            CTLFLAG_RD, &sc->stats.frames_65_to_127_byte_rec, 0,
     1188            "65 to 127 Byte Frames Received");
     1189        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_128_to_255_byte_rec",
     1190            CTLFLAG_RD, &sc->stats.frames_128_to_255_byte_rec, 0,
     1191            "128 to 255 Byte Frames Received");
     1192        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_256_to_511_byte_rec",
     1193            CTLFLAG_RD, &sc->stats.frames_256_to_511_byte_rec, 0,
     1194            "256 to 511 Byte Frames Received");
     1195        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_512_to_1023_byte_rec",
     1196            CTLFLAG_RD, &sc->stats.frames_512_to_1023_byte_rec, 0,
     1197            "512 to 1023 Byte Frames Received");
     1198        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_1024_to_1518_byte_rec",
     1199            CTLFLAG_RD, &sc->stats.frames_1024_to_1518_byte_rec, 0,
     1200            "1024 to 1518 Byte Frames Received");
     1201        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frames_1519_to_maximum_byte_rec",
     1202            CTLFLAG_RD, &sc->stats.frames_1519_to_maximum_byte_rec, 0,
     1203            "1519 to Maximum Byte Frames Received");
     1204        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "undersize_frames_rec",
     1205            CTLFLAG_RD, &sc->stats.undersize_frames_rec, 0,
     1206            "Undersize Frames Received");
     1207        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "oversize_frames_rec",
     1208            CTLFLAG_RD, &sc->stats.oversize_frames_rec, 0,
     1209            "Oversize Frames Received");
     1210        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "jabbers_rec",
     1211            CTLFLAG_RD, &sc->stats.jabbers_rec, 0,
     1212            "Jabbers Received");
     1213        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "frame_check_sequence_errors",
     1214            CTLFLAG_RD, &sc->stats.frame_check_sequence_errors, 0,
     1215            "Frame Check Sequence Errors");
     1216        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "length_field_frame_errors",
     1217            CTLFLAG_RD, &sc->stats.length_field_frame_errors, 0,
     1218            "Length Field Frame Errors");
     1219        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "receive_symbol_errors",
     1220            CTLFLAG_RD, &sc->stats.receive_symbol_errors, 0,
     1221            "Receive Symbol Errors");
     1222        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "alignment_errors",
     1223            CTLFLAG_RD, &sc->stats.alignment_errors, 0,
     1224            "Alignment Errors");
     1225        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "receive_resource_errors",
     1226            CTLFLAG_RD, &sc->stats.receive_resource_errors, 0,
     1227            "Receive Resource Errors");
     1228        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "receive_overrun",
     1229            CTLFLAG_RD, &sc->stats.receive_overrun, 0,
     1230            "Receive Overrun");
     1231        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "ip_header_checksum_errors",
     1232            CTLFLAG_RD, &sc->stats.ip_header_checksum_errors, 0,
     1233            "IP Header Checksum Errors");
     1234        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "tcp_checksum_errors",
     1235            CTLFLAG_RD, &sc->stats.tcp_checksum_errors, 0,
     1236            "TCP Checksum Errors");
     1237        SYSCTL_ADD_UINT(ctx, child, OID_AUTO, "udp_checksum_errors",
     1238            CTLFLAG_RD, &sc->stats.udp_checksum_errors, 0,
     1239            "UDP Checksum Errors");
    10161240}
    10171241
     
    11021326                }
    11031327                break;
    1104         case SIO_RTEMS_SHOW_STATS:
    1105                 if_atsam_stats(sc);
    1106                 break;
    11071328        default:
    11081329                rv = ether_ioctl(ifp, command, data);
     
    11631384         * MII Bus
    11641385         */
    1165         callout_init_mtx(&sc->mii_tick_ch, &sc->mtx, CALLOUT_RETURNUNLOCKED);
     1386        callout_init_mtx(&sc->tick_ch, &sc->mtx, CALLOUT_RETURNUNLOCKED);
    11661387        mii_attach(dev, &sc->miibus, ifp,
    11671388            if_atsam_mii_ifmedia_upd, if_atsam_mii_ifmedia_sts, BMSR_DEFCAPMASK,
     
    11861407        ether_ifattach(ifp, eaddr);
    11871408
     1409        if_atsam_add_sysctls(dev);
     1410
    11881411        return (0);
    11891412}
Note: See TracChangeset for help on using the changeset viewer.