1 /*
   2  * CDDL HEADER START
   3  *
   4  * Copyright(c) 2007-2009 Intel Corporation. All rights reserved.
   5  * The contents of this file are subject to the terms of the
   6  * Common Development and Distribution License (the "License").
   7  * You may not use this file except in compliance with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 
  23 /*
  24  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  25  * Use is subject to license terms.
  26  */
  27 
  28 #include "igb_sw.h"
  29 
  30 /*
  31  * Update driver private statistics.
  32  */
  33 static int
  34 igb_update_stats(kstat_t *ks, int rw)
  35 {
  36         igb_t *igb;
  37         struct e1000_hw *hw;
  38         igb_stat_t *igb_ks;
  39         uint32_t val_low, val_high;
  40 #ifdef IGB_DEBUG
  41         int i;
  42 #endif
  43 
  44         if (rw == KSTAT_WRITE)
  45                 return (EACCES);
  46 
  47         igb = (igb_t *)ks->ks_private;
  48         igb_ks = (igb_stat_t *)ks->ks_data;
  49         hw = &igb->hw;
  50 
  51         mutex_enter(&igb->gen_lock);
  52 
  53         /*
  54          * Basic information.
  55          */
  56         igb_ks->link_speed.value.ui64 = igb->link_speed;
  57         igb_ks->reset_count.value.ui64 = igb->reset_count;
  58         igb_ks->dout_sync.value.ui64 = igb->dout_sync;
  59 
  60 #ifdef IGB_DEBUG
  61         igb_ks->rx_frame_error.value.ui64 = 0;
  62         igb_ks->rx_cksum_error.value.ui64 = 0;
  63         igb_ks->rx_exceed_pkt.value.ui64 = 0;
  64         for (i = 0; i < igb->num_rx_rings; i++) {
  65                 igb_ks->rx_frame_error.value.ui64 +=
  66                     igb->rx_rings[i].stat_frame_error;
  67                 igb_ks->rx_cksum_error.value.ui64 +=
  68                     igb->rx_rings[i].stat_cksum_error;
  69                 igb_ks->rx_exceed_pkt.value.ui64 +=
  70                     igb->rx_rings[i].stat_exceed_pkt;
  71         }
  72 
  73         igb_ks->tx_overload.value.ui64 = 0;
  74         igb_ks->tx_fail_no_tbd.value.ui64 = 0;
  75         igb_ks->tx_fail_no_tcb.value.ui64 = 0;
  76         igb_ks->tx_fail_dma_bind.value.ui64 = 0;
  77         igb_ks->tx_reschedule.value.ui64 = 0;
  78         for (i = 0; i < igb->num_tx_rings; i++) {
  79                 igb_ks->tx_overload.value.ui64 +=
  80                     igb->tx_rings[i].stat_overload;
  81                 igb_ks->tx_fail_no_tbd.value.ui64 +=
  82                     igb->tx_rings[i].stat_fail_no_tbd;
  83                 igb_ks->tx_fail_no_tcb.value.ui64 +=
  84                     igb->tx_rings[i].stat_fail_no_tcb;
  85                 igb_ks->tx_fail_dma_bind.value.ui64 +=
  86                     igb->tx_rings[i].stat_fail_dma_bind;
  87                 igb_ks->tx_reschedule.value.ui64 +=
  88                     igb->tx_rings[i].stat_reschedule;
  89         }
  90 
  91         /*
  92          * Hardware calculated statistics.
  93          */
  94         igb_ks->gprc.value.ul += E1000_READ_REG(hw, E1000_GPRC);
  95         igb_ks->gptc.value.ul += E1000_READ_REG(hw, E1000_GPTC);
  96         igb_ks->prc64.value.ul += E1000_READ_REG(hw, E1000_PRC64);
  97         igb_ks->prc127.value.ul += E1000_READ_REG(hw, E1000_PRC127);
  98         igb_ks->prc255.value.ul += E1000_READ_REG(hw, E1000_PRC255);
  99         igb_ks->prc511.value.ul += E1000_READ_REG(hw, E1000_PRC511);
 100         igb_ks->prc1023.value.ul += E1000_READ_REG(hw, E1000_PRC1023);
 101         igb_ks->prc1522.value.ul += E1000_READ_REG(hw, E1000_PRC1522);
 102         igb_ks->ptc64.value.ul += E1000_READ_REG(hw, E1000_PTC64);
 103         igb_ks->ptc127.value.ul += E1000_READ_REG(hw, E1000_PTC127);
 104         igb_ks->ptc255.value.ul += E1000_READ_REG(hw, E1000_PTC255);
 105         igb_ks->ptc511.value.ul += E1000_READ_REG(hw, E1000_PTC511);
 106         igb_ks->ptc1023.value.ul += E1000_READ_REG(hw, E1000_PTC1023);
 107         igb_ks->ptc1522.value.ul += E1000_READ_REG(hw, E1000_PTC1522);
 108 
 109         /*
 110          * The 64-bit register will reset whenever the upper
 111          * 32 bits are read. So we need to read the lower
 112          * 32 bits first, then read the upper 32 bits.
 113          */
 114         val_low = E1000_READ_REG(hw, E1000_GORCL);
 115         val_high = E1000_READ_REG(hw, E1000_GORCH);
 116         igb_ks->gor.value.ui64 += (uint64_t)val_high << 32 | (uint64_t)val_low;
 117 
 118         val_low = E1000_READ_REG(hw, E1000_GOTCL);
 119         val_high = E1000_READ_REG(hw, E1000_GOTCH);
 120         igb_ks->got.value.ui64 += (uint64_t)val_high << 32 | (uint64_t)val_low;
 121 #endif
 122 
 123         igb_ks->symerrs.value.ui64 += E1000_READ_REG(hw, E1000_SYMERRS);
 124         igb_ks->mpc.value.ui64 += E1000_READ_REG(hw, E1000_MPC);
 125         igb_ks->rlec.value.ui64 += E1000_READ_REG(hw, E1000_RLEC);
 126         igb_ks->fcruc.value.ui64 += E1000_READ_REG(hw, E1000_FCRUC);
 127         igb_ks->rfc.value.ul += E1000_READ_REG(hw, E1000_RFC);
 128         igb_ks->tncrs.value.ul += E1000_READ_REG(hw, E1000_TNCRS);
 129         igb_ks->tsctc.value.ul += E1000_READ_REG(hw, E1000_TSCTC);
 130         igb_ks->tsctfc.value.ul += E1000_READ_REG(hw, E1000_TSCTFC);
 131         igb_ks->xonrxc.value.ui64 += E1000_READ_REG(hw, E1000_XONRXC);
 132         igb_ks->xontxc.value.ui64 += E1000_READ_REG(hw, E1000_XONTXC);
 133         igb_ks->xoffrxc.value.ui64 += E1000_READ_REG(hw, E1000_XOFFRXC);
 134         igb_ks->xofftxc.value.ui64 += E1000_READ_REG(hw, E1000_XOFFTXC);
 135 
 136         mutex_exit(&igb->gen_lock);
 137 
 138         if (igb_check_acc_handle(igb->osdep.reg_handle) != DDI_FM_OK) {
 139                 ddi_fm_service_impact(igb->dip, DDI_SERVICE_DEGRADED);
 140                 return (EIO);
 141         }
 142 
 143         return (0);
 144 }
 145 
 146 /*
 147  * Create and initialize the driver private statistics.
 148  */
 149 int
 150 igb_init_stats(igb_t *igb)
 151 {
 152         kstat_t *ks;
 153         igb_stat_t *igb_ks;
 154 
 155         /*
 156          * Create and init kstat
 157          */
 158         ks = kstat_create(MODULE_NAME, ddi_get_instance(igb->dip),
 159             "statistics", "net", KSTAT_TYPE_NAMED,
 160             sizeof (igb_stat_t) / sizeof (kstat_named_t), 0);
 161 
 162         if (ks == NULL) {
 163                 igb_error(igb,
 164                     "Could not create kernel statistics");
 165                 return (IGB_FAILURE);
 166         }
 167 
 168         igb->igb_ks = ks;
 169 
 170         igb_ks = (igb_stat_t *)ks->ks_data;
 171 
 172         /*
 173          * Initialize all the statistics.
 174          */
 175         kstat_named_init(&igb_ks->link_speed, "link_speed",
 176             KSTAT_DATA_UINT64);
 177         kstat_named_init(&igb_ks->reset_count, "reset_count",
 178             KSTAT_DATA_UINT64);
 179         kstat_named_init(&igb_ks->dout_sync, "DMA_out_sync",
 180             KSTAT_DATA_UINT64);
 181 
 182 #ifdef IGB_DEBUG
 183         kstat_named_init(&igb_ks->rx_frame_error, "rx_frame_error",
 184             KSTAT_DATA_UINT64);
 185         kstat_named_init(&igb_ks->rx_cksum_error, "rx_cksum_error",
 186             KSTAT_DATA_UINT64);
 187         kstat_named_init(&igb_ks->rx_exceed_pkt, "rx_exceed_pkt",
 188             KSTAT_DATA_UINT64);
 189         kstat_named_init(&igb_ks->tx_overload, "tx_overload",
 190             KSTAT_DATA_UINT64);
 191         kstat_named_init(&igb_ks->tx_fail_no_tbd, "tx_fail_no_tbd",
 192             KSTAT_DATA_UINT64);
 193         kstat_named_init(&igb_ks->tx_fail_no_tcb, "tx_fail_no_tcb",
 194             KSTAT_DATA_UINT64);
 195         kstat_named_init(&igb_ks->tx_fail_dma_bind, "tx_fail_dma_bind",
 196             KSTAT_DATA_UINT64);
 197         kstat_named_init(&igb_ks->tx_reschedule, "tx_reschedule",
 198             KSTAT_DATA_UINT64);
 199 
 200         kstat_named_init(&igb_ks->gprc, "good_pkts_recvd",
 201             KSTAT_DATA_UINT64);
 202         kstat_named_init(&igb_ks->gptc, "good_pkts_xmitd",
 203             KSTAT_DATA_UINT64);
 204         kstat_named_init(&igb_ks->gor, "good_octets_recvd",
 205             KSTAT_DATA_UINT64);
 206         kstat_named_init(&igb_ks->got, "good_octets_xmitd",
 207             KSTAT_DATA_UINT64);
 208         kstat_named_init(&igb_ks->prc64, "pkts_recvd_(  64b)",
 209             KSTAT_DATA_UINT64);
 210         kstat_named_init(&igb_ks->prc127, "pkts_recvd_(  65- 127b)",
 211             KSTAT_DATA_UINT64);
 212         kstat_named_init(&igb_ks->prc255, "pkts_recvd_( 127- 255b)",
 213             KSTAT_DATA_UINT64);
 214         kstat_named_init(&igb_ks->prc511, "pkts_recvd_( 256- 511b)",
 215             KSTAT_DATA_UINT64);
 216         kstat_named_init(&igb_ks->prc1023, "pkts_recvd_( 511-1023b)",
 217             KSTAT_DATA_UINT64);
 218         kstat_named_init(&igb_ks->prc1522, "pkts_recvd_(1024-1522b)",
 219             KSTAT_DATA_UINT64);
 220         kstat_named_init(&igb_ks->ptc64, "pkts_xmitd_(  64b)",
 221             KSTAT_DATA_UINT64);
 222         kstat_named_init(&igb_ks->ptc127, "pkts_xmitd_(  65- 127b)",
 223             KSTAT_DATA_UINT64);
 224         kstat_named_init(&igb_ks->ptc255, "pkts_xmitd_( 128- 255b)",
 225             KSTAT_DATA_UINT64);
 226         kstat_named_init(&igb_ks->ptc511, "pkts_xmitd_( 255- 511b)",
 227             KSTAT_DATA_UINT64);
 228         kstat_named_init(&igb_ks->ptc1023, "pkts_xmitd_( 512-1023b)",
 229             KSTAT_DATA_UINT64);
 230         kstat_named_init(&igb_ks->ptc1522, "pkts_xmitd_(1024-1522b)",
 231             KSTAT_DATA_UINT64);
 232 #endif
 233 
 234         kstat_named_init(&igb_ks->symerrs, "recv_symbol_errors",
 235             KSTAT_DATA_UINT64);
 236         kstat_named_init(&igb_ks->mpc, "recv_missed_packets",
 237             KSTAT_DATA_UINT64);
 238         kstat_named_init(&igb_ks->rlec, "recv_length_errors",
 239             KSTAT_DATA_UINT64);
 240         kstat_named_init(&igb_ks->fcruc, "recv_unsupport_FC_pkts",
 241             KSTAT_DATA_UINT64);
 242         kstat_named_init(&igb_ks->rfc, "recv_frag",
 243             KSTAT_DATA_UINT64);
 244         kstat_named_init(&igb_ks->tncrs, "xmit_with_no_CRS",
 245             KSTAT_DATA_UINT64);
 246         kstat_named_init(&igb_ks->tsctc, "xmit_TCP_seg_contexts",
 247             KSTAT_DATA_UINT64);
 248         kstat_named_init(&igb_ks->tsctfc, "xmit_TCP_seg_contexts_fail",
 249             KSTAT_DATA_UINT64);
 250         kstat_named_init(&igb_ks->xonrxc, "XONs_recvd",
 251             KSTAT_DATA_UINT64);
 252         kstat_named_init(&igb_ks->xontxc, "XONs_xmitd",
 253             KSTAT_DATA_UINT64);
 254         kstat_named_init(&igb_ks->xoffrxc, "XOFFs_recvd",
 255             KSTAT_DATA_UINT64);
 256         kstat_named_init(&igb_ks->xofftxc, "XOFFs_xmitd",
 257             KSTAT_DATA_UINT64);
 258 
 259         /*
 260          * Function to provide kernel stat update on demand
 261          */
 262         ks->ks_update = igb_update_stats;
 263 
 264         ks->ks_private = (void *)igb;
 265 
 266         /*
 267          * Add kstat to systems kstat chain
 268          */
 269         kstat_install(ks);
 270 
 271         return (IGB_SUCCESS);
 272 }
 273 
 274 /*
 275  * Retrieve a value for one of the statistics for a particular rx ring
 276  */
 277 int
 278 igb_rx_ring_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val)
 279 {
 280         igb_rx_ring_t *rx_ring = (igb_rx_ring_t *)rh;
 281 
 282         switch (stat) {
 283         case MAC_STAT_RBYTES:
 284                 *val = rx_ring->rx_bytes;
 285                 break;
 286 
 287         case MAC_STAT_IPACKETS:
 288                 *val = rx_ring->rx_pkts;
 289                 break;
 290 
 291         default:
 292                 *val = 0;
 293                 return (ENOTSUP);
 294         }
 295 
 296         return (0);
 297 }
 298 
 299 /*
 300  * Retrieve a value for one of the statistics for a particular tx ring
 301  */
 302 int
 303 igb_tx_ring_stat(mac_ring_driver_t rh, uint_t stat, uint64_t *val)
 304 {
 305         igb_tx_ring_t *tx_ring = (igb_tx_ring_t *)rh;
 306 
 307         switch (stat) {
 308         case MAC_STAT_OBYTES:
 309                 *val = tx_ring->tx_bytes;
 310                 break;
 311 
 312         case MAC_STAT_OPACKETS:
 313                 *val = tx_ring->tx_pkts;
 314                 break;
 315 
 316         default:
 317                 *val = 0;
 318                 return (ENOTSUP);
 319         }
 320 
 321         return (0);
 322 }