usr/src/uts/common/io/nxge/nxge_kstats.c

root/usr/src/uts/common/io/nxge/nxge_kstats.c
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/nxge/nxge_impl.h>
#include <sys/nxge/nxge_hio.h>

#include <inet/mi.h>

#define RDC_NAME_FORMAT1        "RDC Channel"
#define TDC_NAME_FORMAT1        "TDC Channel"
#define CH_NAME_FORMAT          " %d Stats"
#define TDC_NAME_FORMAT         "TDC Channel %d Stats"
#define RDC_NAME_FORMAT         "RDC Channel %d Stats"

void nxge_mac_init_kstats(p_nxge_t, struct kstat *);
void nxge_xmac_init_kstats(struct kstat *);
void nxge_bmac_init_kstats(struct kstat *);

/* ARGSUSED */
void
nxge_init_statsp(p_nxge_t nxgep)
{
        size_t stats_size;

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_init_statsp"));

        stats_size = sizeof (nxge_stats_t);
        nxgep->statsp = KMEM_ZALLOC(stats_size, KM_SLEEP);
        nxgep->statsp->stats_size = stats_size;

        NXGE_DEBUG_MSG((nxgep, KST_CTL, " <== nxge_init_statsp"));
}

typedef struct {
        uint8_t index;
        uint8_t type;
        char *name;
} nxge_kstat_index_t;

typedef enum {
        RDC_STAT_PACKETS = 0,
        RDC_STAT_BYTES,
        RDC_STAT_ERRORS,
        RDC_STAT_DCF_ERR,
        RDC_STAT_RCR_ACK_ERR,
        RDC_STAT_RCR_DC_FIFOFLOW_ERR,
        RDC_STAT_RCR_SHA_PAR_ERR,
        RDC_STAT_RBR_PRE_PAR_ERR,
        RDC_STAT_WRED_DROP,
        RDC_STAT_RBR_PRE_EMTY,
        RDC_STAT_RCR_SHADOW_FULL,
        RDC_STAT_RBR_TMOUT,
        RDC_STAT_RSP_CNT_ERR,
        RDC_STAT_BYTE_EN_BUS,
        RDC_STAT_RSP_DAT_ERR,
        RDC_STAT_PKT_TOO_LONG_ERR,
        RDC_STAT_COMPL_L2_ERR,
        RDC_STAT_COMPL_L4_CKSUM_ERR,
        RDC_STAT_COMPL_ZCP_SOFT_ERR,
        RDC_STAT_COMPL_FFLP_SOFT_ERR,
        RDC_STAT_CONFIG_ERR,
        RDC_STAT_RCRINCON,
        RDC_STAT_RCRFULL,
        RDC_STAT_RBR_EMPTY,
        RDC_STAT_RBR_FULL,
        RDC_STAT_RBRLOGPAGE,
        RDC_STAT_CFIGLOGPAGE,
        RDC_STAT_PORT_DROP_PKT,
        RDC_STAT_RCRTO,
        RDC_STAT_RCRTHRES,
        RDC_STAT_MEX,
        RDC_STAT_ID_MIS,
        RDC_STAT_ZCP_EOP,
        RDC_STAT_IPP_EOP,
        RDC_STAT_END
} nxge_rdc_stat_index_t;

nxge_kstat_index_t nxge_rdc_stats[] = {
        {RDC_STAT_PACKETS, KSTAT_DATA_UINT64, "rdc_packets"},
        {RDC_STAT_BYTES, KSTAT_DATA_UINT64, "rdc_bytes"},
        {RDC_STAT_ERRORS, KSTAT_DATA_ULONG, "rdc_errors"},
        {RDC_STAT_DCF_ERR, KSTAT_DATA_ULONG, "rdc_dcf_err"},
        {RDC_STAT_RCR_ACK_ERR, KSTAT_DATA_ULONG, "rdc_rcr_ack_err"},
        {RDC_STAT_RCR_DC_FIFOFLOW_ERR, KSTAT_DATA_ULONG, "rdc_dc_fifoflow_err"},
        {RDC_STAT_RCR_SHA_PAR_ERR, KSTAT_DATA_ULONG, "rdc_rcr_sha_par_err"},
        {RDC_STAT_RBR_PRE_PAR_ERR, KSTAT_DATA_ULONG, "rdc_rbr_pre_par_err"},
        {RDC_STAT_WRED_DROP, KSTAT_DATA_ULONG, "rdc_wred_drop"},
        {RDC_STAT_RBR_PRE_EMTY, KSTAT_DATA_ULONG, "rdc_rbr_pre_empty"},
        {RDC_STAT_RCR_SHADOW_FULL, KSTAT_DATA_ULONG, "rdc_rcr_shadow_full"},
        {RDC_STAT_RBR_TMOUT, KSTAT_DATA_ULONG, "rdc_rbr_tmout"},
        {RDC_STAT_RSP_CNT_ERR, KSTAT_DATA_ULONG, "rdc_rsp_cnt_err"},
        {RDC_STAT_BYTE_EN_BUS, KSTAT_DATA_ULONG, "rdc_byte_en_bus"},
        {RDC_STAT_RSP_DAT_ERR, KSTAT_DATA_ULONG, "rdc_rsp_dat_err"},
        {RDC_STAT_PKT_TOO_LONG_ERR, KSTAT_DATA_ULONG, "rdc_pkt_too_long_err"},
        {RDC_STAT_COMPL_L2_ERR, KSTAT_DATA_ULONG, "rdc_compl_l2_err"},
        {RDC_STAT_COMPL_L4_CKSUM_ERR, KSTAT_DATA_ULONG, "rdc_compl_l4_cksum"},
        {RDC_STAT_COMPL_ZCP_SOFT_ERR, KSTAT_DATA_ULONG,
                "rdc_compl_zcp_soft_err"},
        {RDC_STAT_COMPL_FFLP_SOFT_ERR, KSTAT_DATA_ULONG,
                "rdc_compl_fflp_soft_err"},
        {RDC_STAT_CONFIG_ERR, KSTAT_DATA_ULONG, "rdc_config_err"},
        {RDC_STAT_RCRINCON, KSTAT_DATA_ULONG, "rdc_rcrincon"},
        {RDC_STAT_RCRFULL, KSTAT_DATA_ULONG, "rdc_rcrfull"},
        {RDC_STAT_RBR_EMPTY, KSTAT_DATA_ULONG, "rdc_rbr_empty"},
        {RDC_STAT_RBR_FULL, KSTAT_DATA_ULONG, "rdc_rbrfull"},
        {RDC_STAT_RBRLOGPAGE, KSTAT_DATA_ULONG, "rdc_rbrlogpage"},
        {RDC_STAT_CFIGLOGPAGE, KSTAT_DATA_ULONG, "rdc_cfiglogpage"},
        {RDC_STAT_PORT_DROP_PKT, KSTAT_DATA_ULONG, "rdc_port_drop_pkt"},
        {RDC_STAT_RCRTO, KSTAT_DATA_ULONG, "rdc_rcrto"},
        {RDC_STAT_RCRTHRES, KSTAT_DATA_ULONG, "rdc_rcrthres"},
        {RDC_STAT_MEX, KSTAT_DATA_ULONG, "rdc_mex"},
        {RDC_STAT_ID_MIS, KSTAT_DATA_ULONG, "rdc_id_mismatch"},
        {RDC_STAT_ZCP_EOP, KSTAT_DATA_ULONG, "rdc_zcp_eop"},
        {RDC_STAT_IPP_EOP, KSTAT_DATA_ULONG, "rdc_ipp_eop"},
        {RDC_STAT_END, KSTAT_DATA_ULONG, NULL}
};

typedef enum {
        RDC_SYS_STAT_PRE_PAR_ERR = 0,
        RDC_SYS_STAT_SHA_PAR_ERR,
        RDC_SYS_STAT_ID_MISMATCH,
        RDC_SYS_STAT_IPP_EOP_ERR,
        RDC_SYS_STAT_ZCP_EOP_ERR,
        RDC_SYS_STAT_END
} nxge_rdc_sys_stat_idx_t;

nxge_kstat_index_t nxge_rdc_sys_stats[] = {
        {RDC_SYS_STAT_PRE_PAR_ERR, KSTAT_DATA_UINT64, "rdc_pre_par_err"},
        {RDC_SYS_STAT_SHA_PAR_ERR, KSTAT_DATA_UINT64, "rdc_sha_par_err"},
        {RDC_SYS_STAT_ID_MISMATCH, KSTAT_DATA_UINT64, "rdc_stat_id_mismatch"},
        {RDC_SYS_STAT_IPP_EOP_ERR, KSTAT_DATA_UINT64, "rdc_ipp_eop_err"},
        {RDC_SYS_STAT_ZCP_EOP_ERR, KSTAT_DATA_UINT64, "rdc_zcp_eop_err"},
        {RDC_SYS_STAT_END, KSTAT_DATA_UINT64, NULL}
};

typedef enum {
        TDC_STAT_PACKETS = 0,
        TDC_STAT_BYTES,
        TDC_STAT_ERRORS,
        TDC_STAT_TX_INITS,
        TDC_STAT_TX_NO_BUF,
        TDC_STAT_MBOX_ERR,
        TDC_STAT_PKT_SIZE_ERR,
        TDC_STAT_TX_RING_OFLOW,
        TDC_STAT_PREF_BUF_ECC_ERR,
        TDC_STAT_NACK_PREF,
        TDC_STAT_NACK_PKT_RD,
        TDC_STAT_CONF_PART_ERR,
        TDC_STAT_PKT_PRT_ERR,
        TDC_STAT_RESET_FAIL,
        TDC_STAT_TX_STARTS,
        TDC_STAT_TX_NOCANPUT,
        TDC_STAT_TX_MSGDUP_FAIL,
        TDC_STAT_TX_ALLOCB_FAIL,
        TDC_STAT_TX_NO_DESC,
        TDC_STAT_TX_DMA_BIND_FAIL,
        TDC_STAT_TX_UFLOW,
        TDC_STAT_TX_HDR_PKTS,
        TDC_STAT_TX_DDI_PKTS,
        TDC_STAT_TX_DVMA_PKTS,
        TDC_STAT_TX_MAX_PEND,
        TDC_STAT_END
} nxge_tdc_stats_index_t;

nxge_kstat_index_t nxge_tdc_stats[] = {
        {TDC_STAT_PACKETS, KSTAT_DATA_UINT64, "tdc_packets"},
        {TDC_STAT_BYTES, KSTAT_DATA_UINT64, "tdc_bytes"},
        {TDC_STAT_ERRORS, KSTAT_DATA_UINT64, "tdc_errors"},
        {TDC_STAT_TX_INITS, KSTAT_DATA_ULONG, "tdc_tx_inits"},
        {TDC_STAT_TX_NO_BUF, KSTAT_DATA_ULONG, "tdc_tx_no_buf"},
        {TDC_STAT_MBOX_ERR, KSTAT_DATA_ULONG, "tdc_mbox_err"},
        {TDC_STAT_PKT_SIZE_ERR, KSTAT_DATA_ULONG, "tdc_pkt_size_err"},
        {TDC_STAT_TX_RING_OFLOW,
                KSTAT_DATA_ULONG, "tdc_tx_ring_oflow"},
        {TDC_STAT_PREF_BUF_ECC_ERR,
                KSTAT_DATA_ULONG, "tdc_pref_buf_err_err"},
        {TDC_STAT_NACK_PREF, KSTAT_DATA_ULONG, "tdc_nack_pref"},
        {TDC_STAT_NACK_PKT_RD, KSTAT_DATA_ULONG, "tdc_nack_pkt_rd"},
        {TDC_STAT_CONF_PART_ERR,
                KSTAT_DATA_ULONG, "tdc_conf_part_err"},
        {TDC_STAT_PKT_PRT_ERR, KSTAT_DATA_ULONG, "tdc_pkt_prt_err"},
        {TDC_STAT_RESET_FAIL, KSTAT_DATA_ULONG, "tdc_reset_fail"},
        {TDC_STAT_TX_STARTS, KSTAT_DATA_ULONG, "tdc_tx_starts"},
        {TDC_STAT_TX_NOCANPUT, KSTAT_DATA_ULONG, "tdc_tx_nocanput"},
        {TDC_STAT_TX_MSGDUP_FAIL, KSTAT_DATA_ULONG, "tdc_tx_msgdup_fail"},
        {TDC_STAT_TX_ALLOCB_FAIL, KSTAT_DATA_ULONG, "tdc_tx_allocb_fail"},
        {TDC_STAT_TX_NO_DESC, KSTAT_DATA_ULONG, "tdc_tx_no_desc"},
        {TDC_STAT_TX_DMA_BIND_FAIL, KSTAT_DATA_ULONG, "tdc_tx_dma_bind_fail"},
        {TDC_STAT_TX_UFLOW, KSTAT_DATA_ULONG, "tdc_tx_uflow"},
        {TDC_STAT_TX_HDR_PKTS, KSTAT_DATA_ULONG, "tdc_tx_hdr_pkts"},
        {TDC_STAT_TX_DDI_PKTS, KSTAT_DATA_ULONG, "tdc_tx_ddi_pkts"},
        {TDC_STAT_TX_DVMA_PKTS, KSTAT_DATA_ULONG, "tdc_tx_dvma_pkts"},
        {TDC_STAT_TX_MAX_PEND, KSTAT_DATA_ULONG, "tdc_tx_max_pend"},
        {TDC_STAT_END, KSTAT_DATA_ULONG, NULL}
};

/* IPP Statistics definitions */
typedef enum {
        IPP_STAT_EOP_MISS = 0,
        IPP_STAT_SOP_MISS,
        IPP_STAT_DFIFO_UE,
        IPP_STAT_ECC_ERR,
        IPP_STAT_PFIFO_PERR,
        IPP_STAT_PFIFO_OVER,
        IPP_STAT_PFIFO_UND,
        IPP_STAT_BAD_CS,
        IPP_STAT_BAD_DIS,
        IPP_STAT_END
} nxge_ipp_stat_index_t;

nxge_kstat_index_t nxge_ipp_stats[] = {
        {IPP_STAT_EOP_MISS, KSTAT_DATA_ULONG, "rxipp_eop_miss"},
        {IPP_STAT_SOP_MISS, KSTAT_DATA_ULONG, "rxipp_sop_miss"},
        {IPP_STAT_DFIFO_UE, KSTAT_DATA_ULONG, "rxipp_dfifo_ue"},
        {IPP_STAT_ECC_ERR, KSTAT_DATA_ULONG, "rxipp_ecc_err"},
        {IPP_STAT_PFIFO_PERR, KSTAT_DATA_ULONG, "rxipp_pfifo_perr"},
        {IPP_STAT_PFIFO_OVER, KSTAT_DATA_ULONG, "rxipp_pfifo_over"},
        {IPP_STAT_PFIFO_UND, KSTAT_DATA_ULONG, "rxipp_pfifo_und"},
        {IPP_STAT_BAD_CS, KSTAT_DATA_ULONG, "rxipp_bad_cs"},
        {IPP_STAT_BAD_DIS, KSTAT_DATA_ULONG, "rxipp_bad_dis"},
        {IPP_STAT_END, KSTAT_DATA_ULONG, NULL}
};

/* TXC Statistics definitions */
typedef enum {
        TXC_STAT_PKT_STUFFED = 0,
        TXC_STAT_PKT_XMIT,
        TXC_STAT_RO_CORRECT_ERR,
        TXC_STAT_RO_UNCORRECT_ERR,
        TXC_STAT_SF_CORRECT_ERR,
        TXC_STAT_SF_UNCORRECT_ERR,
        TXC_STAT_ADDRESS_FAILED,
        TXC_STAT_DMA_FAILED,
        TXC_STAT_LENGTH_FAILED,
        TXC_STAT_PKT_ASSY_DEAD,
        TXC_STAT_REORDER_ERR,
        TXC_STAT_END
} nxge_txc_stat_index_t;

nxge_kstat_index_t nxge_txc_stats[] = {
        {TXC_STAT_PKT_STUFFED, KSTAT_DATA_ULONG, "txc_pkt_stuffed"},
        {TXC_STAT_PKT_XMIT, KSTAT_DATA_ULONG, "txc_pkt_xmit"},
        {TXC_STAT_RO_CORRECT_ERR, KSTAT_DATA_ULONG, "txc_ro_correct_err"},
        {TXC_STAT_RO_UNCORRECT_ERR, KSTAT_DATA_ULONG, "txc_ro_uncorrect_err"},
        {TXC_STAT_SF_CORRECT_ERR, KSTAT_DATA_ULONG, "txc_sf_correct_err"},
        {TXC_STAT_SF_UNCORRECT_ERR, KSTAT_DATA_ULONG, "txc_sf_uncorrect_err"},
        {TXC_STAT_ADDRESS_FAILED, KSTAT_DATA_ULONG, "txc_address_failed"},
        {TXC_STAT_DMA_FAILED, KSTAT_DATA_ULONG, "txc_dma_failed"},
        {TXC_STAT_LENGTH_FAILED, KSTAT_DATA_ULONG, "txc_length_failed"},
        {TXC_STAT_PKT_ASSY_DEAD, KSTAT_DATA_ULONG, "txc_pkt_assy_dead"},
        {TXC_STAT_REORDER_ERR, KSTAT_DATA_ULONG, "txc_reorder_err"},
        {TXC_STAT_END, KSTAT_DATA_ULONG, NULL}
};

typedef enum {
        XMAC_STAT_TX_FRAME_CNT = 0,
        XMAC_STAT_TX_UNDERFLOW_ERR,
        XMAC_STAT_TX_MAXPKTSIZE_ERR,
        XMAC_STAT_TX_OVERFLOW_ERR,
        XMAC_STAT_TX_FIFO_XFR_ERR,
        XMAC_STAT_TX_BYTE_CNT,
        XMAC_STAT_RX_FRAME_CNT,
        XMAC_STAT_RX_UNDERFLOW_ERR,
        XMAC_STAT_RX_OVERFLOW_ERR,
        XMAC_STAT_RX_CRC_ERR_CNT,
        XMAC_STAT_RX_LEN_ERR_CNT,
        XMAC_STAT_RX_VIOL_ERR_CNT,
        XMAC_STAT_RX_BYTE_CNT,
        XMAC_STAT_RX_HIST1_CNT,
        XMAC_STAT_RX_HIST2_CNT,
        XMAC_STAT_RX_HIST3_CNT,
        XMAC_STAT_RX_HIST4_CNT,
        XMAC_STAT_RX_HIST5_CNT,
        XMAC_STAT_RX_HIST6_CNT,
        XMAC_STAT_RX_HIST7_CNT,
        XMAC_STAT_RX_BROADCAST_CNT,
        XMAC_STAT_RX_MULT_CNT,
        XMAC_STAT_RX_FRAG_CNT,
        XMAC_STAT_RX_FRAME_ALIGN_ERR_CNT,
        XMAC_STAT_RX_LINKFAULT_ERR_CNT,
        XMAC_STAT_RX_REMOTEFAULT_ERR,
        XMAC_STAT_RX_LOCALFAULT_ERR,
        XMAC_STAT_RX_PAUSE_CNT,
        XMAC_STAT_TX_PAUSE_STATE,
        XMAC_STAT_TX_NOPAUSE_STATE,
        XMAC_STAT_XPCS_DESKEW_ERR_CNT,
#ifdef  NXGE_DEBUG_SYMBOL_ERR
        XMAC_STAT_XPCS_SYMBOL_L0_ERR_CNT,
        XMAC_STAT_XPCS_SYMBOL_L1_ERR_CNT,
        XMAC_STAT_XPCS_SYMBOL_L2_ERR_CNT,
        XMAC_STAT_XPCS_SYMBOL_L3_ERR_CNT,
#endif
        XMAC_STAT_END
} nxge_xmac_stat_index_t;

nxge_kstat_index_t nxge_xmac_stats[] = {
        {XMAC_STAT_TX_FRAME_CNT, KSTAT_DATA_ULONG, "txmac_frame_cnt"},
        {XMAC_STAT_TX_UNDERFLOW_ERR, KSTAT_DATA_ULONG, "tmac_underflow_err"},
        {XMAC_STAT_TX_MAXPKTSIZE_ERR, KSTAT_DATA_ULONG, "txmac_maxpktsize_err"},
        {XMAC_STAT_TX_OVERFLOW_ERR, KSTAT_DATA_ULONG, "txmac_overflow_err"},
        {XMAC_STAT_TX_FIFO_XFR_ERR, KSTAT_DATA_ULONG, "txmac_fifo_xfr_err"},
        {XMAC_STAT_TX_BYTE_CNT, KSTAT_DATA_ULONG, "txmac_byte_cnt"},
        {XMAC_STAT_RX_FRAME_CNT, KSTAT_DATA_ULONG, "rxmac_frame_cnt"},
        {XMAC_STAT_RX_UNDERFLOW_ERR, KSTAT_DATA_ULONG, "rxmac_underflow_err"},
        {XMAC_STAT_RX_OVERFLOW_ERR, KSTAT_DATA_ULONG, "rxmac_overflow_err"},
        {XMAC_STAT_RX_CRC_ERR_CNT, KSTAT_DATA_ULONG, "rxmac_crc_err"},
        {XMAC_STAT_RX_LEN_ERR_CNT, KSTAT_DATA_ULONG, "rxmac_length_err"},
        {XMAC_STAT_RX_VIOL_ERR_CNT, KSTAT_DATA_ULONG, "rxmac_code_violations"},
        {XMAC_STAT_RX_BYTE_CNT, KSTAT_DATA_ULONG, "rxmac_byte_cnt"},
        {XMAC_STAT_RX_HIST1_CNT, KSTAT_DATA_ULONG, "rxmac_64_cnt"},
        {XMAC_STAT_RX_HIST2_CNT, KSTAT_DATA_ULONG, "rxmac_65_127_cnt"},
        {XMAC_STAT_RX_HIST3_CNT, KSTAT_DATA_ULONG, "rxmac_128_255_cnt"},
        {XMAC_STAT_RX_HIST4_CNT, KSTAT_DATA_ULONG, "rxmac_256_511_cnt"},
        {XMAC_STAT_RX_HIST5_CNT, KSTAT_DATA_ULONG, "rxmac_512_1023_cnt"},
        {XMAC_STAT_RX_HIST6_CNT, KSTAT_DATA_ULONG, "rxmac_1024_1522_cnt"},
        {XMAC_STAT_RX_HIST7_CNT, KSTAT_DATA_ULONG, "rxmac_jumbo_cnt"},
        {XMAC_STAT_RX_BROADCAST_CNT, KSTAT_DATA_ULONG, "rxmac_broadcast_cnt"},
        {XMAC_STAT_RX_MULT_CNT, KSTAT_DATA_ULONG, "rxmac_multicast_cnt"},
        {XMAC_STAT_RX_FRAG_CNT, KSTAT_DATA_ULONG, "rxmac_fragment_cnt"},
        {XMAC_STAT_RX_FRAME_ALIGN_ERR_CNT,
                KSTAT_DATA_ULONG, "rxmac_alignment_err"},
        {XMAC_STAT_RX_LINKFAULT_ERR_CNT,
                KSTAT_DATA_ULONG, "rxmac_linkfault_errs"},
        {XMAC_STAT_RX_REMOTEFAULT_ERR,
                KSTAT_DATA_ULONG, "rxmac_remote_faults"},
        {XMAC_STAT_RX_LOCALFAULT_ERR,
                KSTAT_DATA_ULONG, "rxmac_local_faults"},
        {XMAC_STAT_RX_PAUSE_CNT, KSTAT_DATA_ULONG, "rxmac_pause_cnt"},
        {XMAC_STAT_TX_PAUSE_STATE, KSTAT_DATA_ULONG, "txmac_pause_state"},
        {XMAC_STAT_TX_NOPAUSE_STATE, KSTAT_DATA_ULONG, "txmac_nopause_state"},
        {XMAC_STAT_XPCS_DESKEW_ERR_CNT,
                KSTAT_DATA_ULONG, "xpcs_deskew_err_cnt"},
#ifdef  NXGE_DEBUG_SYMBOL_ERR
        {XMAC_STAT_XPCS_SYMBOL_L0_ERR_CNT,
                KSTAT_DATA_ULONG, "xpcs_ln0_symbol_err_cnt"},
        {XMAC_STAT_XPCS_SYMBOL_L1_ERR_CNT,
                KSTAT_DATA_ULONG, "xpcs_ln1_symbol_err_cnt"},
        {XMAC_STAT_XPCS_SYMBOL_L2_ERR_CNT,
                KSTAT_DATA_ULONG, "xpcs_ln2_symbol_err_cnt"},
        {XMAC_STAT_XPCS_SYMBOL_L3_ERR_CNT,
                KSTAT_DATA_ULONG, "xpcs_ln3_symbol_err_cnt"},
#endif
        {XMAC_STAT_END, KSTAT_DATA_ULONG, NULL}
};

typedef enum {
        BMAC_STAT_TX_FRAME_CNT = 0,
        BMAC_STAT_TX_UNDERRUN_ERR,
        BMAC_STAT_TX_MAX_PKT_ERR,
        BMAC_STAT_TX_BYTE_CNT,
        BMAC_STAT_RX_FRAME_CNT,
        BMAC_STAT_RX_BYTE_CNT,
        BMAC_STAT_RX_OVERFLOW_ERR,
        BMAC_STAT_RX_ALIGN_ERR_CNT,
        BMAC_STAT_RX_CRC_ERR_CNT,
        BMAC_STAT_RX_LEN_ERR_CNT,
        BMAC_STAT_RX_VIOL_ERR_CNT,
        BMAC_STAT_RX_PAUSE_CNT,
        BMAC_STAT_RX_PAUSE_STATE,
        BMAC_STAT_RX_NOPAUSE_STATE,
        BMAC_STAT_END
} nxge_bmac_stat_index_t;

nxge_kstat_index_t nxge_bmac_stats[] = {
        {BMAC_STAT_TX_FRAME_CNT, KSTAT_DATA_ULONG, "txmac_frame_cnt"},
        {BMAC_STAT_TX_UNDERRUN_ERR, KSTAT_DATA_ULONG, "txmac_underrun_err"},
        {BMAC_STAT_TX_MAX_PKT_ERR, KSTAT_DATA_ULONG, "txmac_max_pkt_err"},
        {BMAC_STAT_TX_BYTE_CNT, KSTAT_DATA_ULONG, "txmac_byte_cnt"},
        {BMAC_STAT_RX_FRAME_CNT, KSTAT_DATA_ULONG, "rxmac_frame_cnt"},
        {BMAC_STAT_RX_BYTE_CNT, KSTAT_DATA_ULONG, "rxmac_byte_cnt"},
        {BMAC_STAT_RX_OVERFLOW_ERR, KSTAT_DATA_ULONG, "rxmac_overflow_err"},
        {BMAC_STAT_RX_ALIGN_ERR_CNT, KSTAT_DATA_ULONG, "rxmac_align_err_cnt"},
        {BMAC_STAT_RX_CRC_ERR_CNT, KSTAT_DATA_ULONG, "rxmac_crc_err_cnt"},
        {BMAC_STAT_RX_LEN_ERR_CNT, KSTAT_DATA_ULONG, "rxmac_len_err_cnt"},
        {BMAC_STAT_RX_VIOL_ERR_CNT, KSTAT_DATA_ULONG, "rxmac_viol_err_cnt"},
        {BMAC_STAT_RX_PAUSE_CNT, KSTAT_DATA_ULONG, "rxmac_pause_cnt"},
        {BMAC_STAT_RX_PAUSE_STATE, KSTAT_DATA_ULONG, "txmac_pause_state"},
        {BMAC_STAT_RX_NOPAUSE_STATE, KSTAT_DATA_ULONG, "tx_nopause_state"},
        {BMAC_STAT_END, KSTAT_DATA_ULONG, NULL}
};

typedef enum {
        ZCP_STAT_ERRORS,
        ZCP_STAT_INITS,
        ZCP_STAT_RRFIFO_UNDERRUN,
        ZCP_STAT_RRFIFO_OVERRUN,
        ZCP_STAT_RSPFIFO_UNCORR_ERR,
        ZCP_STAT_BUFFER_OVERFLOW,
        ZCP_STAT_STAT_TBL_PERR,
        ZCP_STAT_DYN_TBL_PERR,
        ZCP_STAT_BUF_TBL_PERR,
        ZCP_STAT_TT_PROGRAM_ERR,
        ZCP_STAT_RSP_TT_INDEX_ERR,
        ZCP_STAT_SLV_TT_INDEX_ERR,
        ZCP_STAT_ZCP_TT_INDEX_ERR,
        ZCP_STAT_ZCP_ACCESS_FAIL,
        ZCP_CFIFO_ECC,
        ZCP_STAT_END
} nxge_zcp_stat_index_t;

nxge_kstat_index_t nxge_zcp_stats[] = {
        {ZCP_STAT_ERRORS, KSTAT_DATA_ULONG, "zcp_erros"},
        {ZCP_STAT_INITS, KSTAT_DATA_ULONG, "zcp_inits"},
        {ZCP_STAT_RRFIFO_UNDERRUN, KSTAT_DATA_ULONG, "zcp_rrfifo_underrun"},
        {ZCP_STAT_RRFIFO_OVERRUN, KSTAT_DATA_ULONG, "zcp_rrfifo_overrun"},
        {ZCP_STAT_RSPFIFO_UNCORR_ERR, KSTAT_DATA_ULONG,
        "zcp_rspfifo_uncorr_err"},
        {ZCP_STAT_BUFFER_OVERFLOW, KSTAT_DATA_ULONG, "zcp_buffer_overflow"},
        {ZCP_STAT_STAT_TBL_PERR, KSTAT_DATA_ULONG, "zcp_stat_tbl_perr"},
        {ZCP_STAT_DYN_TBL_PERR, KSTAT_DATA_ULONG, "zcp_dyn_tbl_perr"},
        {ZCP_STAT_BUF_TBL_PERR, KSTAT_DATA_ULONG, "zcp_buf_tbl_perr"},
        {ZCP_STAT_TT_PROGRAM_ERR, KSTAT_DATA_ULONG, "zcp_tt_program_err"},
        {ZCP_STAT_RSP_TT_INDEX_ERR, KSTAT_DATA_ULONG, "zcp_rsp_tt_index_err"},
        {ZCP_STAT_SLV_TT_INDEX_ERR, KSTAT_DATA_ULONG, "zcp_slv_tt_index_err"},
        {ZCP_STAT_ZCP_TT_INDEX_ERR, KSTAT_DATA_ULONG, "zcp_zcp_tt_index_err"},
        {ZCP_STAT_ZCP_ACCESS_FAIL, KSTAT_DATA_ULONG, "zcp_access_fail"},
        {ZCP_STAT_ZCP_ACCESS_FAIL, KSTAT_DATA_ULONG, "zcp_cfifo_ecc"},
        {ZCP_STAT_END, KSTAT_DATA_ULONG, NULL}
};

typedef enum {
        FFLP_STAT_TCAM_PERR,
        FFLP_STAT_TCAM_ECC_ERR,
        FFLP_STAT_VLAN_PERR,
        FFLP_STAT_HASH_LOOKUP_ERR,
        FFLP_STAT_HASH_P0_PIO_ERR,
        FFLP_STAT_HASH_P1_PIO_ERR,
        FFLP_STAT_HASH_P2_PIO_ERR,
        FFLP_STAT_HASH_P3_PIO_ERR,
        FFLP_STAT_HASH_P4_PIO_ERR,
        FFLP_STAT_HASH_P5_PIO_ERR,
        FFLP_STAT_HASH_P6_PIO_ERR,
        FFLP_STAT_HASH_P7_PIO_ERR,
        FFLP_STAT_END
} nxge_fflp_stat_index_t;

nxge_kstat_index_t nxge_fflp_stats[] = {
        {FFLP_STAT_TCAM_PERR, KSTAT_DATA_ULONG, "fflp_tcam_perr"},
        {FFLP_STAT_TCAM_ECC_ERR, KSTAT_DATA_ULONG, "fflp_tcam_ecc_err"},
        {FFLP_STAT_VLAN_PERR, KSTAT_DATA_ULONG, "fflp_vlan_perr"},
        {FFLP_STAT_HASH_LOOKUP_ERR, KSTAT_DATA_ULONG, "fflp_hash_lookup_err"},
        {FFLP_STAT_HASH_P0_PIO_ERR, KSTAT_DATA_ULONG, "fflp_hash_p0_pio_err"},
        {FFLP_STAT_HASH_P1_PIO_ERR, KSTAT_DATA_ULONG, "fflp_hash_p1_pio_err"},
        {FFLP_STAT_HASH_P2_PIO_ERR, KSTAT_DATA_ULONG, "fflp_hash_p2_pio_err"},
        {FFLP_STAT_HASH_P3_PIO_ERR, KSTAT_DATA_ULONG, "fflp_hash_p3_pio_err"},
        {FFLP_STAT_HASH_P4_PIO_ERR, KSTAT_DATA_ULONG, "fflp_hash_p4_pio_err"},
        {FFLP_STAT_HASH_P5_PIO_ERR, KSTAT_DATA_ULONG, "fflp_hash_p5_pio_err"},
        {FFLP_STAT_HASH_P6_PIO_ERR, KSTAT_DATA_ULONG, "fflp_hash_p6_pio_err"},
        {FFLP_STAT_HASH_P7_PIO_ERR, KSTAT_DATA_ULONG, "fflp_hash_p7_pio_err"},
        {FFLP_STAT_END, KSTAT_DATA_ULONG, NULL}
};

typedef enum {
        MMAC_MAX_ADDR,
        MMAC_AVAIL_ADDR,
        MMAC_ADDR_POOL1,
        MMAC_ADDR_POOL2,
        MMAC_ADDR_POOL3,
        MMAC_ADDR_POOL4,
        MMAC_ADDR_POOL5,
        MMAC_ADDR_POOL6,
        MMAC_ADDR_POOL7,
        MMAC_ADDR_POOL8,
        MMAC_ADDR_POOL9,
        MMAC_ADDR_POOL10,
        MMAC_ADDR_POOL11,
        MMAC_ADDR_POOL12,
        MMAC_ADDR_POOL13,
        MMAC_ADDR_POOL14,
        MMAC_ADDR_POOL15,
        MMAC_ADDR_POOL16,
        MMAC_STATS_END
} nxge_mmac_stat_index_t;

nxge_kstat_index_t nxge_mmac_stats[] = {
        {MMAC_MAX_ADDR, KSTAT_DATA_UINT64, "max_mmac_addr"},
        {MMAC_AVAIL_ADDR, KSTAT_DATA_UINT64, "avail_mmac_addr"},
        {MMAC_ADDR_POOL1, KSTAT_DATA_UINT64, "mmac_addr_1"},
        {MMAC_ADDR_POOL2, KSTAT_DATA_UINT64, "mmac_addr_2"},
        {MMAC_ADDR_POOL3, KSTAT_DATA_UINT64, "mmac_addr_3"},
        {MMAC_ADDR_POOL4, KSTAT_DATA_UINT64, "mmac_addr_4"},
        {MMAC_ADDR_POOL5, KSTAT_DATA_UINT64, "mmac_addr_5"},
        {MMAC_ADDR_POOL6, KSTAT_DATA_UINT64, "mmac_addr_6"},
        {MMAC_ADDR_POOL7, KSTAT_DATA_UINT64, "mmac_addr_7"},
        {MMAC_ADDR_POOL8, KSTAT_DATA_UINT64, "mmac_addr_8"},
        {MMAC_ADDR_POOL9, KSTAT_DATA_UINT64, "mmac_addr_9"},
        {MMAC_ADDR_POOL10, KSTAT_DATA_UINT64, "mmac_addr_10"},
        {MMAC_ADDR_POOL11, KSTAT_DATA_UINT64, "mmac_addr_11"},
        {MMAC_ADDR_POOL12, KSTAT_DATA_UINT64, "mmac_addr_12"},
        {MMAC_ADDR_POOL13, KSTAT_DATA_UINT64, "mmac_addr_13"},
        {MMAC_ADDR_POOL14, KSTAT_DATA_UINT64, "mmac_addr_14"},
        {MMAC_ADDR_POOL15, KSTAT_DATA_UINT64, "mmac_addr_15"},
        {MMAC_ADDR_POOL16, KSTAT_DATA_UINT64, "mmac_addr_16"},
        {MMAC_STATS_END, KSTAT_DATA_UINT64, NULL},
};

/* ARGSUSED */
int
nxge_tdc_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_tdc_kstat_t tdc_kstatsp;
        p_nxge_tx_ring_stats_t statsp;
        int channel;
        char *ch_name, *end;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_rxstat_update"));

        ch_name = ksp->ks_name;
        ch_name += strlen(TDC_NAME_FORMAT1);
        channel = mi_strtol(ch_name, &end, 10);

        tdc_kstatsp = (p_nxge_tdc_kstat_t)ksp->ks_data;
        statsp = (p_nxge_tx_ring_stats_t)&nxgep->statsp->tdc_stats[channel];

        NXGE_DEBUG_MSG((nxgep, KST_CTL,
            "nxge_tdc_stat_update data $%p statsp $%p channel %d",
            ksp->ks_data, statsp, channel));

        if (rw == KSTAT_WRITE) {
                statsp->opackets = tdc_kstatsp->opackets.value.ull;
                statsp->obytes = tdc_kstatsp->obytes.value.ull;
                statsp->oerrors = tdc_kstatsp->oerrors.value.ull;
                statsp->mbox_err = tdc_kstatsp->mbox_err.value.ul;
                statsp->pkt_size_err = tdc_kstatsp->pkt_size_err.value.ul;
                statsp->tx_ring_oflow = tdc_kstatsp->tx_ring_oflow.value.ul;
                statsp->pre_buf_par_err =
                    tdc_kstatsp->pref_buf_ecc_err.value.ul;
                statsp->nack_pref = tdc_kstatsp->nack_pref.value.ul;
                statsp->nack_pkt_rd = tdc_kstatsp->nack_pkt_rd.value.ul;
                statsp->conf_part_err = tdc_kstatsp->conf_part_err.value.ul;
                statsp->pkt_part_err = tdc_kstatsp->pkt_prt_err.value.ul;
        } else {
                tdc_kstatsp->opackets.value.ull = statsp->opackets;
                tdc_kstatsp->obytes.value.ull = statsp->obytes;
                tdc_kstatsp->oerrors.value.ull = statsp->oerrors;
                tdc_kstatsp->tx_hdr_pkts.value.ull = statsp->tx_hdr_pkts;
                tdc_kstatsp->tx_ddi_pkts.value.ull = statsp->tx_ddi_pkts;
                tdc_kstatsp->tx_dvma_pkts.value.ull = statsp->tx_dvma_pkts;
                tdc_kstatsp->tx_max_pend.value.ull = statsp->tx_max_pend;
                tdc_kstatsp->mbox_err.value.ul = statsp->mbox_err;
                tdc_kstatsp->pkt_size_err.value.ul = statsp->pkt_size_err;
                tdc_kstatsp->tx_ring_oflow.value.ul = statsp->tx_ring_oflow;
                tdc_kstatsp->pref_buf_ecc_err.value.ul =
                    statsp->pre_buf_par_err;
                tdc_kstatsp->nack_pref.value.ul = statsp->nack_pref;
                tdc_kstatsp->nack_pkt_rd.value.ul = statsp->nack_pkt_rd;
                tdc_kstatsp->conf_part_err.value.ul = statsp->conf_part_err;
                tdc_kstatsp->pkt_prt_err.value.ul = statsp->pkt_part_err;
                tdc_kstatsp->tx_starts.value.ul = statsp->tx_starts;
                tdc_kstatsp->tx_nocanput.value.ul = statsp->tx_nocanput;
                tdc_kstatsp->tx_msgdup_fail.value.ul = statsp->tx_msgdup_fail;
                tdc_kstatsp->tx_allocb_fail.value.ul = statsp->tx_allocb_fail;
                tdc_kstatsp->tx_no_desc.value.ul = statsp->tx_no_desc;
                tdc_kstatsp->tx_dma_bind_fail.value.ul =
                    statsp->tx_dma_bind_fail;
        }
        NXGE_DEBUG_MSG((nxgep, KST_CTL, " <== nxge_tdc_stat_update"));
        return (0);
}

/* ARGSUSED */
int
nxge_rdc_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_rdc_kstat_t rdc_kstatsp;
        p_nxge_rx_ring_stats_t statsp;
        int channel;
        char *ch_name, *end;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_rdc_stat_update"));

        ch_name = ksp->ks_name;
        ch_name += strlen(RDC_NAME_FORMAT1);
        channel = mi_strtol(ch_name, &end, 10);

        rdc_kstatsp = (p_nxge_rdc_kstat_t)ksp->ks_data;
        statsp = (p_nxge_rx_ring_stats_t)&nxgep->statsp->rdc_stats[channel];

        NXGE_DEBUG_MSG((nxgep, KST_CTL,
            "nxge_rdc_stat_update $%p statsp $%p channel %d",
            ksp->ks_data, statsp, channel));

        if (rw == KSTAT_WRITE) {
                statsp->dcf_err = rdc_kstatsp->dcf_err.value.ul;
                statsp->rcr_ack_err = rdc_kstatsp->rcr_ack_err.value.ul;
                statsp->dc_fifo_err = rdc_kstatsp->dc_fifoflow_err.value.ul;
                statsp->rcr_sha_par = rdc_kstatsp->rcr_sha_par_err.value.ul;
                statsp->rbr_pre_par = rdc_kstatsp->rbr_pre_par_err.value.ul;
                statsp->wred_drop = rdc_kstatsp->wred_drop.value.ul;
                statsp->rbr_pre_empty = rdc_kstatsp->rbr_pre_emty.value.ul;
                statsp->rcr_shadow_full = rdc_kstatsp->rcr_shadow_full.value.ul;
                statsp->rx_rbr_tmout = rdc_kstatsp->rbr_tmout.value.ul;
                statsp->rsp_cnt_err = rdc_kstatsp->rsp_cnt_err.value.ul;
                statsp->byte_en_bus = rdc_kstatsp->byte_en_bus.value.ul;
                statsp->rsp_dat_err = rdc_kstatsp->rsp_dat_err.value.ul;
                statsp->pkt_too_long_err =
                    rdc_kstatsp->pkt_too_long_err.value.ul;
                statsp->l2_err = rdc_kstatsp->compl_l2_err.value.ul;
                statsp->l4_cksum_err = rdc_kstatsp->compl_l4_cksum_err.value.ul;
                statsp->fflp_soft_err =
                    rdc_kstatsp->compl_fflp_soft_err.value.ul;
                statsp->zcp_soft_err = rdc_kstatsp->compl_zcp_soft_err.value.ul;
                statsp->config_err = rdc_kstatsp->config_err.value.ul;
                statsp->rcrincon = rdc_kstatsp->rcrincon.value.ul;
                statsp->rcrfull = rdc_kstatsp->rcrfull.value.ul;
                statsp->rbr_empty = rdc_kstatsp->rbr_empty.value.ul;
                statsp->rbrfull = rdc_kstatsp->rbrfull.value.ul;
                statsp->rbrlogpage = rdc_kstatsp->rbrlogpage.value.ul;
                statsp->cfiglogpage = rdc_kstatsp->cfiglogpage.value.ul;
        } else {
                rdc_kstatsp->ipackets.value.ull = statsp->ipackets;
                rdc_kstatsp->rbytes.value.ull = statsp->ibytes;
                rdc_kstatsp->errors.value.ul = statsp->ierrors;
                rdc_kstatsp->dcf_err.value.ul = statsp->dcf_err;
                rdc_kstatsp->rcr_ack_err.value.ul = statsp->rcr_ack_err;
                rdc_kstatsp->dc_fifoflow_err.value.ul = statsp->dc_fifo_err;
                rdc_kstatsp->rcr_sha_par_err.value.ul = statsp->rcr_sha_par;
                rdc_kstatsp->rbr_pre_par_err.value.ul = statsp->rbr_pre_par;
                rdc_kstatsp->wred_drop.value.ul = statsp->wred_drop;
                rdc_kstatsp->port_drop_pkt.value.ul = statsp->port_drop_pkt;
                rdc_kstatsp->rbr_pre_emty.value.ul = statsp->rbr_pre_empty;
                rdc_kstatsp->rcr_shadow_full.value.ul = statsp->rcr_shadow_full;
                rdc_kstatsp->rbr_tmout.value.ul = statsp->rx_rbr_tmout;
                rdc_kstatsp->rsp_cnt_err.value.ul = statsp->rsp_cnt_err;
                rdc_kstatsp->byte_en_bus.value.ul = statsp->byte_en_bus;
                rdc_kstatsp->rsp_dat_err.value.ul = statsp->rsp_dat_err;
                rdc_kstatsp->pkt_too_long_err.value.ul =
                    statsp->pkt_too_long_err;
                rdc_kstatsp->compl_l2_err.value.ul = statsp->l2_err;
                rdc_kstatsp->compl_l4_cksum_err.value.ul = statsp->l4_cksum_err;
                rdc_kstatsp->compl_fflp_soft_err.value.ul =
                    statsp->fflp_soft_err;
                rdc_kstatsp->compl_zcp_soft_err.value.ul = statsp->zcp_soft_err;
                rdc_kstatsp->config_err.value.ul = statsp->config_err;
                rdc_kstatsp->rcrincon.value.ul = statsp->rcrincon;
                rdc_kstatsp->rcrfull.value.ul = statsp->rcrfull;
                rdc_kstatsp->rbr_empty.value.ul = statsp->rbr_empty;
                rdc_kstatsp->rbrfull.value.ul = statsp->rbrfull;
                rdc_kstatsp->rbrlogpage.value.ul = statsp->rbrlogpage;
                rdc_kstatsp->cfiglogpage.value.ul = statsp->cfiglogpage;
        }

        NXGE_DEBUG_MSG((nxgep, KST_CTL, " <== nxge_rdc_stat_update"));
        return (0);
}

/* ARGSUSED */
int
nxge_rdc_sys_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_rdc_sys_kstat_t rdc_sys_kstatsp;
        p_nxge_rdc_sys_stats_t statsp;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_rdc_sys_stat_update"));

        rdc_sys_kstatsp = (p_nxge_rdc_sys_kstat_t)ksp->ks_data;
        statsp = (p_nxge_rdc_sys_stats_t)&nxgep->statsp->rdc_sys_stats;

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "nxge_rdc_sys_stat_update %llx",
            ksp->ks_data));

        if (rw == KSTAT_WRITE) {
                statsp->id_mismatch = rdc_sys_kstatsp->id_mismatch.value.ul;
                statsp->ipp_eop_err = rdc_sys_kstatsp->ipp_eop_err.value.ul;
                statsp->zcp_eop_err = rdc_sys_kstatsp->zcp_eop_err.value.ul;
        } else {
                rdc_sys_kstatsp->id_mismatch.value.ul = statsp->id_mismatch;
                rdc_sys_kstatsp->ipp_eop_err.value.ul = statsp->ipp_eop_err;
                rdc_sys_kstatsp->zcp_eop_err.value.ul = statsp->zcp_eop_err;
        }
        NXGE_DEBUG_MSG((nxgep, KST_CTL, " <== nxge_rdc_sys_stat_update"));
        return (0);
}

/* ARGSUSED */
static int
nxge_txc_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_txc_kstat_t txc_kstatsp;
        p_nxge_txc_stats_t statsp;

        nxgep = (p_nxge_t)ksp->ks_private;

        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_txc_stat_update"));

        txc_kstatsp = (p_nxge_txc_kstat_t)ksp->ks_data;
        statsp = (p_nxge_txc_stats_t)&nxgep->statsp->txc_stats;

        if (rw == KSTAT_WRITE) {
                statsp->pkt_stuffed = txc_kstatsp->pkt_stuffed.value.ul;
                statsp->pkt_xmit = txc_kstatsp->pkt_xmit.value.ul;
                statsp->ro_correct_err = txc_kstatsp->ro_correct_err.value.ul;
                statsp->ro_uncorrect_err =
                    txc_kstatsp->ro_uncorrect_err.value.ul;
                statsp->sf_correct_err = txc_kstatsp->sf_correct_err.value.ul;
                statsp->sf_uncorrect_err =
                    txc_kstatsp->sf_uncorrect_err.value.ul;
                statsp->address_failed = txc_kstatsp->address_failed.value.ul;
                statsp->dma_failed = txc_kstatsp->dma_failed.value.ul;
                statsp->length_failed = txc_kstatsp->length_failed.value.ul;
                statsp->pkt_assy_dead = txc_kstatsp->pkt_assy_dead.value.ul;
                statsp->reorder_err = txc_kstatsp->reorder_err.value.ul;
        } else {
                txc_kstatsp->pkt_stuffed.value.ul = statsp->pkt_stuffed;
                txc_kstatsp->pkt_xmit.value.ul = statsp->pkt_xmit;
                txc_kstatsp->ro_correct_err.value.ul = statsp->ro_correct_err;
                txc_kstatsp->ro_uncorrect_err.value.ul =
                    statsp->ro_uncorrect_err;
                txc_kstatsp->sf_correct_err.value.ul = statsp->sf_correct_err;
                txc_kstatsp->sf_uncorrect_err.value.ul =
                    statsp->sf_uncorrect_err;
                txc_kstatsp->address_failed.value.ul = statsp->address_failed;
                txc_kstatsp->dma_failed.value.ul = statsp->dma_failed;
                txc_kstatsp->length_failed.value.ul = statsp->length_failed;
                txc_kstatsp->pkt_assy_dead.value.ul = statsp->pkt_assy_dead;
                txc_kstatsp->reorder_err.value.ul = statsp->reorder_err;
        }
        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_txc_stat_update"));
        return (0);
}

/* ARGSUSED */
int
nxge_ipp_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_ipp_kstat_t ipp_kstatsp;
        p_nxge_ipp_stats_t statsp;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_ipp_stat_update"));

        ipp_kstatsp = (p_nxge_ipp_kstat_t)ksp->ks_data;
        statsp = (p_nxge_ipp_stats_t)&nxgep->statsp->ipp_stats;

        if (rw == KSTAT_WRITE) {
                statsp->eop_miss = ipp_kstatsp->eop_miss.value.ul;
                statsp->sop_miss = ipp_kstatsp->sop_miss.value.ul;
                statsp->dfifo_ue = ipp_kstatsp->dfifo_ue.value.ul;
                statsp->ecc_err_cnt = ipp_kstatsp->ecc_err_cnt.value.ul;
                statsp->pfifo_perr = ipp_kstatsp->pfifo_perr.value.ul;
                statsp->pfifo_over = ipp_kstatsp->pfifo_over.value.ul;
                statsp->pfifo_und = ipp_kstatsp->pfifo_und.value.ul;
                statsp->bad_cs_cnt = ipp_kstatsp->bad_cs_cnt.value.ul;
                statsp->pkt_dis_cnt = ipp_kstatsp->pkt_dis_cnt.value.ul;
        } else {
                ipp_kstatsp->eop_miss.value.ul = statsp->eop_miss;
                ipp_kstatsp->sop_miss.value.ul = statsp->sop_miss;
                ipp_kstatsp->dfifo_ue.value.ul = statsp->dfifo_ue;
                ipp_kstatsp->ecc_err_cnt.value.ul = statsp->ecc_err_cnt;
                ipp_kstatsp->pfifo_perr.value.ul = statsp->pfifo_perr;
                ipp_kstatsp->pfifo_over.value.ul = statsp->pfifo_over;
                ipp_kstatsp->pfifo_und.value.ul = statsp->pfifo_und;
                ipp_kstatsp->bad_cs_cnt.value.ul = statsp->bad_cs_cnt;
                ipp_kstatsp->pkt_dis_cnt.value.ul = statsp->pkt_dis_cnt;
        }
        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_ipp_stat_update"));
        return (0);
}

/* ARGSUSED */
int
nxge_xmac_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_xmac_kstat_t xmac_kstatsp;
        p_nxge_xmac_stats_t statsp;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_xmac_stat_update"));

        xmac_kstatsp = (p_nxge_xmac_kstat_t)ksp->ks_data;
        statsp = (p_nxge_xmac_stats_t)&nxgep->statsp->xmac_stats;

        if (rw == KSTAT_WRITE) {
                statsp->tx_frame_cnt = xmac_kstatsp->tx_frame_cnt.value.ul;
                statsp->tx_underflow_err =
                    xmac_kstatsp->tx_underflow_err.value.ul;
                statsp->tx_maxpktsize_err =
                    xmac_kstatsp->tx_maxpktsize_err.value.ul;
                statsp->tx_overflow_err =
                    xmac_kstatsp->tx_overflow_err.value.ul;
                statsp->tx_fifo_xfr_err =
                    xmac_kstatsp->tx_fifo_xfr_err.value.ul;
                statsp->tx_byte_cnt = xmac_kstatsp->tx_byte_cnt.value.ul;
                statsp->rx_underflow_err =
                    xmac_kstatsp->rx_underflow_err.value.ul;
                statsp->rx_overflow_err =
                    xmac_kstatsp->rx_overflow_err.value.ul;
                statsp->rx_crc_err_cnt = xmac_kstatsp->rx_crc_err_cnt.value.ul;
                statsp->rx_len_err_cnt = xmac_kstatsp->rx_len_err_cnt.value.ul;
                statsp->rx_viol_err_cnt =
                    xmac_kstatsp->rx_viol_err_cnt.value.ul;
                statsp->rx_byte_cnt = xmac_kstatsp->rx_byte_cnt.value.ul;
                statsp->rx_frame_cnt = xmac_kstatsp->rx_frame_cnt.value.ul;
                statsp->rx_hist1_cnt = xmac_kstatsp->rx_hist1_cnt.value.ul;
                statsp->rx_hist2_cnt = xmac_kstatsp->rx_hist2_cnt.value.ul;
                statsp->rx_hist3_cnt = xmac_kstatsp->rx_hist3_cnt.value.ul;
                statsp->rx_hist4_cnt = xmac_kstatsp->rx_hist4_cnt.value.ul;
                statsp->rx_hist5_cnt = xmac_kstatsp->rx_hist5_cnt.value.ul;
                statsp->rx_hist6_cnt = xmac_kstatsp->rx_hist6_cnt.value.ul;
                statsp->rx_hist7_cnt = xmac_kstatsp->rx_hist7_cnt.value.ul;
                statsp->rx_mult_cnt = xmac_kstatsp->rx_mult_cnt.value.ul;
                statsp->rx_frag_cnt = xmac_kstatsp->rx_frag_cnt.value.ul;
                statsp->rx_frame_align_err_cnt =
                    xmac_kstatsp->rx_frame_align_err_cnt.value.ul;
                statsp->rx_linkfault_err_cnt =
                    xmac_kstatsp->rx_linkfault_err_cnt.value.ul;
                statsp->rx_localfault_err =
                    xmac_kstatsp->rx_local_fault_err_cnt.value.ul;
                statsp->rx_remotefault_err =
                    xmac_kstatsp->rx_remote_fault_err_cnt.value.ul;
                statsp->xpcs_deskew_err_cnt =
                    xmac_kstatsp->xpcs_deskew_err_cnt.value.ul;
#ifdef  NXGE_DEBUG_SYMBOL_ERR
                statsp->xpcs_ln0_symbol_err_cnt =
                    xmac_kstatsp->xpcs_ln0_symbol_err_cnt.value.ul;
                statsp->xpcs_ln1_symbol_err_cnt =
                    xmac_kstatsp->xpcs_ln1_symbol_err_cnt.value.ul;
                statsp->xpcs_ln2_symbol_err_cnt =
                    xmac_kstatsp->xpcs_ln2_symbol_err_cnt.value.ul;
                statsp->xpcs_ln3_symbol_err_cnt =
                    xmac_kstatsp->xpcs_ln3_symbol_err_cnt.value.ul;
#endif
        } else {
                xmac_kstatsp->tx_frame_cnt.value.ul = statsp->tx_frame_cnt;
                xmac_kstatsp->tx_underflow_err.value.ul =
                    statsp->tx_underflow_err;
                xmac_kstatsp->tx_maxpktsize_err.value.ul =
                    statsp->tx_maxpktsize_err;
                xmac_kstatsp->tx_overflow_err.value.ul =
                    statsp->tx_overflow_err;
                xmac_kstatsp->tx_fifo_xfr_err.value.ul =
                    statsp->tx_fifo_xfr_err;
                xmac_kstatsp->tx_byte_cnt.value.ul = statsp->tx_byte_cnt;
                xmac_kstatsp->rx_underflow_err.value.ul =
                    statsp->rx_underflow_err;
                xmac_kstatsp->rx_overflow_err.value.ul =
                    statsp->rx_overflow_err;
                xmac_kstatsp->rx_crc_err_cnt.value.ul = statsp->rx_crc_err_cnt;
                xmac_kstatsp->rx_len_err_cnt.value.ul = statsp->rx_len_err_cnt;
                xmac_kstatsp->rx_viol_err_cnt.value.ul =
                    statsp->rx_viol_err_cnt;
                xmac_kstatsp->rx_byte_cnt.value.ul = statsp->rx_byte_cnt;
                xmac_kstatsp->rx_frame_cnt.value.ul = statsp->rx_frame_cnt;
                xmac_kstatsp->rx_hist1_cnt.value.ul = statsp->rx_hist1_cnt;
                xmac_kstatsp->rx_hist2_cnt.value.ul = statsp->rx_hist2_cnt;
                xmac_kstatsp->rx_hist3_cnt.value.ul = statsp->rx_hist3_cnt;
                xmac_kstatsp->rx_hist4_cnt.value.ul = statsp->rx_hist4_cnt;
                xmac_kstatsp->rx_hist5_cnt.value.ul = statsp->rx_hist5_cnt;
                xmac_kstatsp->rx_hist6_cnt.value.ul = statsp->rx_hist6_cnt;
                xmac_kstatsp->rx_hist7_cnt.value.ul = statsp->rx_hist7_cnt;
                xmac_kstatsp->rx_mult_cnt.value.ul = statsp->rx_mult_cnt;
                xmac_kstatsp->rx_frag_cnt.value.ul = statsp->rx_frag_cnt;
                xmac_kstatsp->rx_frame_align_err_cnt.value.ul =
                    statsp->rx_frame_align_err_cnt;
                xmac_kstatsp->rx_linkfault_err_cnt.value.ul =
                    statsp->rx_linkfault_err_cnt;
                xmac_kstatsp->rx_local_fault_err_cnt.value.ul =
                    statsp->rx_localfault_err;
                xmac_kstatsp->rx_remote_fault_err_cnt.value.ul =
                    statsp->rx_remotefault_err;
                xmac_kstatsp->xpcs_deskew_err_cnt.value.ul =
                    statsp->xpcs_deskew_err_cnt;
#ifdef  NXGE_DEBUG_SYMBOL_ERR
                xmac_kstatsp->xpcs_ln0_symbol_err_cnt.value.ul =
                    statsp->xpcs_ln0_symbol_err_cnt;
                xmac_kstatsp->xpcs_ln1_symbol_err_cnt.value.ul =
                    statsp->xpcs_ln1_symbol_err_cnt;
                xmac_kstatsp->xpcs_ln2_symbol_err_cnt.value.ul =
                    statsp->xpcs_ln2_symbol_err_cnt;
                xmac_kstatsp->xpcs_ln3_symbol_err_cnt.value.ul =
                    statsp->xpcs_ln3_symbol_err_cnt;
#endif
        }
        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_xmac_stat_update"));
        return (0);
}

/* ARGSUSED */
int
nxge_bmac_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_bmac_kstat_t bmac_kstatsp;
        p_nxge_bmac_stats_t statsp;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_bmac_stat_update"));

        bmac_kstatsp = (p_nxge_bmac_kstat_t)ksp->ks_data;
        statsp = (p_nxge_bmac_stats_t)&nxgep->statsp->bmac_stats;

        if (rw == KSTAT_WRITE) {
                statsp->tx_frame_cnt = bmac_kstatsp->tx_frame_cnt.value.ul;
                statsp->tx_underrun_err =
                    bmac_kstatsp->tx_underrun_err.value.ul;
                statsp->tx_max_pkt_err = bmac_kstatsp->tx_max_pkt_err.value.ul;
                statsp->tx_byte_cnt = bmac_kstatsp->tx_byte_cnt.value.ul;
                statsp->rx_frame_cnt = bmac_kstatsp->rx_frame_cnt.value.ul;
                statsp->rx_byte_cnt = bmac_kstatsp->rx_byte_cnt.value.ul;
                statsp->rx_overflow_err =
                    bmac_kstatsp->rx_overflow_err.value.ul;
                statsp->rx_align_err_cnt =
                    bmac_kstatsp->rx_align_err_cnt.value.ul;
                statsp->rx_crc_err_cnt = bmac_kstatsp->rx_crc_err_cnt.value.ul;
                statsp->rx_len_err_cnt = bmac_kstatsp->rx_len_err_cnt.value.ul;
                statsp->rx_viol_err_cnt =
                    bmac_kstatsp->rx_viol_err_cnt.value.ul;
        } else {
                bmac_kstatsp->tx_frame_cnt.value.ul = statsp->tx_frame_cnt;
                bmac_kstatsp->tx_underrun_err.value.ul =
                    statsp->tx_underrun_err;
                bmac_kstatsp->tx_max_pkt_err.value.ul = statsp->tx_max_pkt_err;
                bmac_kstatsp->tx_byte_cnt.value.ul = statsp->tx_byte_cnt;
                bmac_kstatsp->rx_frame_cnt.value.ul = statsp->rx_frame_cnt;
                bmac_kstatsp->rx_byte_cnt.value.ul = statsp->rx_byte_cnt;
                bmac_kstatsp->rx_overflow_err.value.ul =
                    statsp->rx_overflow_err;
                bmac_kstatsp->rx_align_err_cnt.value.ul =
                    statsp->rx_align_err_cnt;
                bmac_kstatsp->rx_crc_err_cnt.value.ul = statsp->rx_crc_err_cnt;
                bmac_kstatsp->rx_len_err_cnt.value.ul = statsp->rx_len_err_cnt;
                bmac_kstatsp->rx_viol_err_cnt.value.ul =
                    statsp->rx_viol_err_cnt;
        }
        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_bmac_stat_update"));
        return (0);
}

/* ARGSUSED */
int
nxge_zcp_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_zcp_kstat_t zcp_kstatsp;
        p_nxge_zcp_stats_t statsp;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_zcp_stat_update"));

        zcp_kstatsp = (p_nxge_zcp_kstat_t)ksp->ks_data;
        statsp = (p_nxge_zcp_stats_t)&nxgep->statsp->zcp_stats;

        if (rw == KSTAT_WRITE) {
                statsp->rrfifo_underrun = zcp_kstatsp->rrfifo_underrun.value.ul;
                statsp->rrfifo_overrun = zcp_kstatsp->rrfifo_overrun.value.ul;
                statsp->rspfifo_uncorr_err =
                    zcp_kstatsp->rspfifo_uncorr_err.value.ul;
                statsp->buffer_overflow = zcp_kstatsp->buffer_overflow.value.ul;
                statsp->stat_tbl_perr = zcp_kstatsp->stat_tbl_perr.value.ul;
                statsp->dyn_tbl_perr = zcp_kstatsp->dyn_tbl_perr.value.ul;
                statsp->buf_tbl_perr = zcp_kstatsp->buf_tbl_perr.value.ul;
                statsp->tt_program_err = zcp_kstatsp->tt_program_err.value.ul;
                statsp->rsp_tt_index_err =
                    zcp_kstatsp->rsp_tt_index_err.value.ul;
                statsp->slv_tt_index_err =
                    zcp_kstatsp->slv_tt_index_err.value.ul;
                statsp->zcp_tt_index_err =
                    zcp_kstatsp->zcp_tt_index_err.value.ul;
                statsp->cfifo_ecc = zcp_kstatsp->cfifo_ecc.value.ul;
        } else {
                zcp_kstatsp->rrfifo_underrun.value.ul = statsp->rrfifo_underrun;
                zcp_kstatsp->rrfifo_overrun.value.ul = statsp->rrfifo_overrun;
                zcp_kstatsp->rspfifo_uncorr_err.value.ul =
                    statsp->rspfifo_uncorr_err;
                zcp_kstatsp->buffer_overflow.value.ul =
                    statsp->buffer_overflow;
                zcp_kstatsp->stat_tbl_perr.value.ul = statsp->stat_tbl_perr;
                zcp_kstatsp->dyn_tbl_perr.value.ul = statsp->dyn_tbl_perr;
                zcp_kstatsp->buf_tbl_perr.value.ul = statsp->buf_tbl_perr;
                zcp_kstatsp->tt_program_err.value.ul = statsp->tt_program_err;
                zcp_kstatsp->rsp_tt_index_err.value.ul =
                    statsp->rsp_tt_index_err;
                zcp_kstatsp->slv_tt_index_err.value.ul =
                    statsp->slv_tt_index_err;
                zcp_kstatsp->zcp_tt_index_err.value.ul =
                    statsp->zcp_tt_index_err;
                zcp_kstatsp->cfifo_ecc.value.ul = statsp->cfifo_ecc;
        }
        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_zcp_stat_update"));
        return (0);
}

/* ARGSUSED */
int
nxge_fflp_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_fflp_kstat_t fflp_kstatsp;
        p_nxge_fflp_stats_t statsp;
        int ldc_grp;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_fflp_stat_update"));

        fflp_kstatsp = (p_nxge_fflp_kstat_t)ksp->ks_data;
        statsp = (p_nxge_fflp_stats_t)&nxgep->statsp->fflp_stats;

        if (rw == KSTAT_WRITE) {
                statsp->tcam_parity_err = fflp_kstatsp->fflp_tcam_perr.value.ul;
                statsp->tcam_ecc_err = fflp_kstatsp->fflp_tcam_ecc_err.value.ul;
                statsp->vlan_parity_err = fflp_kstatsp->fflp_vlan_perr.value.ul;
                statsp->hash_lookup_err =
                    fflp_kstatsp->fflp_hasht_lookup_err.value.ul;
                for (ldc_grp = 0; ldc_grp < MAX_PARTITION; ldc_grp++) {
                        statsp->hash_pio_err[ldc_grp] =
                            fflp_kstatsp->fflp_hasht_data_err[ldc_grp].
                            value.ul;
                }
        } else {
                fflp_kstatsp->fflp_tcam_perr.value.ul =
                    fflp_kstatsp->fflp_tcam_perr.value.ul;
                fflp_kstatsp->fflp_tcam_ecc_err.value.ul = statsp->tcam_ecc_err;
                fflp_kstatsp->fflp_vlan_perr.value.ul = statsp->vlan_parity_err;
                fflp_kstatsp->fflp_hasht_lookup_err.value.ul =
                    statsp->hash_lookup_err;
                for (ldc_grp = 0; ldc_grp < MAX_PARTITION; ldc_grp++) {
                        fflp_kstatsp->fflp_hasht_data_err[ldc_grp].value.ul =
                            statsp->hash_pio_err[ldc_grp];
                }
        }
        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_fflp_stat_update"));
        return (0);
}

/* ARGSUSED */
static uint64_t
nxge_mac_octet_to_u64(struct ether_addr addr)
{
        int i;
        uint64_t addr64 = 0;

        for (i = ETHERADDRL - 1; i >= 0; i--) {
                addr64 <<= 8;
                addr64 |= addr.ether_addr_octet[i];
        }
        return (addr64);
}

/* ARGSUSED */
int
nxge_mmac_stat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_mmac_kstat_t mmac_kstatsp;
        p_nxge_mmac_stats_t statsp;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_mmac_stat_update"));

        mmac_kstatsp = (p_nxge_mmac_kstat_t)ksp->ks_data;
        statsp = (p_nxge_mmac_stats_t)&nxgep->statsp->mmac_stats;

        if (rw == KSTAT_WRITE) {
                cmn_err(CE_WARN, "Can not write mmac stats");
        } else {
                mmac_kstatsp->mmac_max_addr_cnt.value.ul =
                    statsp->mmac_max_cnt;
                mmac_kstatsp->mmac_avail_addr_cnt.value.ul =
                    statsp->mmac_avail_cnt;
                mmac_kstatsp->mmac_addr1.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[0]);
                mmac_kstatsp->mmac_addr2.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[1]);
                mmac_kstatsp->mmac_addr3.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[2]);
                mmac_kstatsp->mmac_addr4.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[3]);
                mmac_kstatsp->mmac_addr5.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[4]);
                mmac_kstatsp->mmac_addr6.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[5]);
                mmac_kstatsp->mmac_addr7.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[6]);
                mmac_kstatsp->mmac_addr8.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[7]);
                mmac_kstatsp->mmac_addr9.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[8]);
                mmac_kstatsp->mmac_addr10.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[9]);
                mmac_kstatsp->mmac_addr11.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[10]);
                mmac_kstatsp->mmac_addr12.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[11]);
                mmac_kstatsp->mmac_addr13.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[12]);
                mmac_kstatsp->mmac_addr14.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[13]);
                mmac_kstatsp->mmac_addr15.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[14]);
                mmac_kstatsp->mmac_addr16.value.ul =
                    nxge_mac_octet_to_u64(statsp->mmac_avail_pool[15]);
        }
        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_mmac_stat_update"));
        return (0);
}

/* ARGSUSED */
static kstat_t *
nxge_setup_local_kstat(p_nxge_t nxgep, int instance, char *name,
        const nxge_kstat_index_t *ksip, size_t count,
        int (*update) (kstat_t *, int))
{
        kstat_t *ksp;
        kstat_named_t *knp;
        int i;

        ksp = kstat_create(NXGE_DRIVER_NAME, instance, name, "net",
            KSTAT_TYPE_NAMED, count, 0);
        if (ksp == NULL)
                return (NULL);

        ksp->ks_private = (void *)nxgep;
        ksp->ks_update = update;
        knp = ksp->ks_data;

        for (i = 0; ksip[i].name != NULL; i++) {
                kstat_named_init(&knp[i], ksip[i].name, ksip[i].type);
        }

        kstat_install(ksp);
        return (ksp);
}

/* ARGSUSED */
void
nxge_setup_rdc_kstats(p_nxge_t nxgep, int channel)
{
        char stat_name[64];

        /* Setup RDC statistics */
        (void) sprintf(stat_name, "%s" CH_NAME_FORMAT,
            RDC_NAME_FORMAT1, channel);
        nxgep->statsp->rdc_ksp[channel] = nxge_setup_local_kstat(nxgep,
            nxgep->instance,
            stat_name,
            nxge_rdc_stats,
            RDC_STAT_END,
            nxge_rdc_stat_update);
#ifdef  NXGE_DEBUG_ERROR
        if (nxgep->statsp->rdc_ksp[channel] == NULL)
                NXGE_DEBUG_MSG((nxgep, KST_CTL,
                    "kstat_create failed for rdc channel %d", channel));
#endif
}

void
nxge_setup_tdc_kstats(p_nxge_t nxgep, int channel)
{
        char stat_name[64];

        /* Setup TDC statistics */
        (void) sprintf(stat_name, "%s" CH_NAME_FORMAT,
            TDC_NAME_FORMAT1, channel);
        nxgep->statsp->tdc_ksp[channel] = nxge_setup_local_kstat(nxgep,
            nxgep->instance,
            stat_name,
            nxge_tdc_stats,
            TDC_STAT_END,
            nxge_tdc_stat_update);
#ifdef  NXGE_DEBUG_ERROR
        if (nxgep->statsp->tdc_ksp[channel] == NULL) {
                NXGE_DEBUG_MSG((nxgep, KST_CTL,
                    "kstat_create failed for tdc channel %d", channel));
        }
#endif
}

void
nxge_setup_kstats(p_nxge_t nxgep)
{
        struct kstat *ksp;
        p_nxge_port_kstat_t nxgekp;
        size_t nxge_kstat_sz;
        char mmac_name[64];

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_setup_kstats"));

        /* Setup RDC System statistics */
        nxgep->statsp->rdc_sys_ksp = nxge_setup_local_kstat(nxgep,
            nxgep->instance,
            "RDC System Stats",
            &nxge_rdc_sys_stats[0],
            RDC_SYS_STAT_END,
            nxge_rdc_sys_stat_update);

        /* Setup IPP statistics */
        nxgep->statsp->ipp_ksp = nxge_setup_local_kstat(nxgep,
            nxgep->instance,
            "IPP Stats",
            &nxge_ipp_stats[0],
            IPP_STAT_END,
            nxge_ipp_stat_update);
#ifdef  NXGE_DEBUG_ERROR
        if (nxgep->istatsp->pp_ksp == NULL)
                NXGE_DEBUG_MSG((nxgep, KST_CTL, "kstat_create failed for ipp"));
#endif

        /* Setup TXC statistics */
        nxgep->statsp->txc_ksp = nxge_setup_local_kstat(nxgep,
            nxgep->instance, "TXC Stats", &nxge_txc_stats[0],
            TXC_STAT_END, nxge_txc_stat_update);
#ifdef  NXGE_DEBUG_ERROR
        if (nxgep->statsp->txc_ksp == NULL)
                NXGE_DEBUG_MSG((nxgep, KST_CTL, "kstat_create failed for txc"));
#endif

        /* Setup ZCP statistics */
        nxgep->statsp->zcp_ksp = nxge_setup_local_kstat(nxgep,
            nxgep->instance, "ZCP Stats", &nxge_zcp_stats[0],
            ZCP_STAT_END, nxge_zcp_stat_update);
#ifdef  NXGE_DEBUG_ERROR
        if (nxgep->statsp->zcp_ksp == NULL)
                NXGE_DEBUG_MSG((nxgep, KST_CTL, "kstat_create failed for zcp"));
#endif

        /* Setup FFLP statistics */
        nxgep->statsp->fflp_ksp[0] = nxge_setup_local_kstat(nxgep,
            nxgep->instance, "FFLP Stats", &nxge_fflp_stats[0],
            FFLP_STAT_END, nxge_fflp_stat_update);

#ifdef  NXGE_DEBUG_ERROR
        if (nxgep->statsp->fflp_ksp == NULL)
                NXGE_DEBUG_MSG((nxgep, KST_CTL,
                    "kstat_create failed for fflp"));
#endif

        (void) sprintf(mmac_name, "MMAC Stats%d", nxgep->instance);
        nxgep->statsp->mmac_ksp = nxge_setup_local_kstat(nxgep,
            nxgep->instance, "MMAC Stats", &nxge_mmac_stats[0],
            MMAC_STATS_END, nxge_mmac_stat_update);

        nxge_kstat_sz = sizeof (nxge_port_kstat_t) +
            sizeof (nxge_mac_kstat_t) - sizeof (kstat_named_t);

        if ((ksp = kstat_create(NXGE_DRIVER_NAME, nxgep->instance,
            "Port Stats", "net", KSTAT_TYPE_NAMED,
            nxge_kstat_sz / sizeof (kstat_named_t), 0)) == NULL) {
                NXGE_DEBUG_MSG((nxgep, KST_CTL, "kstat_create failed"));
                NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_setup_kstats"));
                return;
        }

        /*
         * kstats
         */
        nxgekp = (p_nxge_port_kstat_t)ksp->ks_data;

        /*
         * transceiver state informations.
         */
        kstat_named_init(&nxgekp->xcvr_inits, "xcvr_inits",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->xcvr_inuse, "xcvr_inuse",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->xcvr_addr, "xcvr_addr",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->xcvr_id, "xcvr_id",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_autoneg, "cap_autoneg",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_10gfdx, "cap_10gfdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_10ghdx, "cap_10ghdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_1000fdx, "cap_1000fdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_1000hdx, "cap_1000hdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_100T4, "cap_100T4",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_100fdx, "cap_100fdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_100hdx, "cap_100hdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_10fdx, "cap_10fdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_10hdx, "cap_10hdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_asmpause, "cap_asmpause",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->cap_pause, "cap_pause",
            KSTAT_DATA_ULONG);

        /*
         * Link partner capabilities.
         */
        kstat_named_init(&nxgekp->lp_cap_autoneg, "lp_cap_autoneg",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_10gfdx, "lp_cap_10gfdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_10ghdx, "lp_cap_10ghdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_1000fdx, "lp_cap_1000fdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_1000hdx, "lp_cap_1000hdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_100T4, "lp_cap_100T4",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_100fdx, "lp_cap_100fdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_100hdx, "lp_cap_100hdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_10fdx, "lp_cap_10fdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_10hdx, "lp_cap_10hdx",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_asmpause, "lp_cap_asmpause",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->lp_cap_pause, "lp_cap_pause",
            KSTAT_DATA_ULONG);
        /*
         * Shared link setup.
         */
        kstat_named_init(&nxgekp->link_T4, "link_T4",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->link_speed, "link_speed",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->link_duplex, "link_duplex",
            KSTAT_DATA_CHAR);
        kstat_named_init(&nxgekp->link_asmpause, "link_asmpause",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->link_pause, "link_pause",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->link_up, "link_up",
            KSTAT_DATA_ULONG);

        /*
         * Let the user know the MTU currently in use by the physical MAC
         * port.
         */
        kstat_named_init(&nxgekp->mac_mtu, "mac_mtu",
            KSTAT_DATA_ULONG);

        /*
         * Loopback statistics.
         */
        kstat_named_init(&nxgekp->lb_mode, "lb_mode",
            KSTAT_DATA_ULONG);

        /*
         * This tells the user whether the driver is in QOS mode or not.
         */
        kstat_named_init(&nxgekp->qos_mode, "qos_mode",
            KSTAT_DATA_ULONG);

        /*
         * This tells whether the instance is trunked or not
         */
        kstat_named_init(&nxgekp->trunk_mode, "trunk_mode",
            KSTAT_DATA_ULONG);

#if defined MULTI_DATA_TX || defined MULTI_DATA_TXV2
        kstat_named_init(&nxgekp->mdt_reqs, "mdt_reqs",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->mdt_hdr_bufs, "mdt_hdr_bufs",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->mdt_pld_bufs, "mdt_pld_bufs",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->mdt_pkts, "mdt_pkts",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->mdt_hdrs, "mdt_hdrs",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->mdt_plds, "mdt_plds",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->mdt_hdr_bind_fail, "mdt_hdr_bind_fail",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->mdt_pld_bind_fail, "mdt_pld_bind_fail",
            KSTAT_DATA_ULONG);
#endif
#ifdef ACCEPT_JUMBO
        kstat_named_init(&nxgekp->tx_jumbo_pkts, "tx_jumbo_pkts",
            KSTAT_DATA_ULONG);
#endif

        /*
         * Rx Statistics.
         */
#ifdef ACCEPT_JUMBO
        kstat_named_init(&nxgekp->rx_jumbo_pkts, "rx_jumbo_pkts",
            KSTAT_DATA_ULONG);
#endif
        /* General MAC statistics */
        kstat_named_init(&nxgekp->ifspeed, "ifspeed",
            KSTAT_DATA_UINT64);
        kstat_named_init(&nxgekp->promisc, "promisc",
            KSTAT_DATA_CHAR);
        kstat_named_init(&nxgekp->rev_id, "rev_id",
            KSTAT_DATA_ULONG);

        ksp->ks_update = nxge_port_kstat_update;
        ksp->ks_private = (void *) nxgep;
        if (nxgep->mac.porttype == PORT_TYPE_XMAC)
                nxge_xmac_init_kstats(ksp);
        else
                nxge_bmac_init_kstats(ksp);
        kstat_install(ksp);
        nxgep->statsp->port_ksp = ksp;
        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_setup_kstats"));
}

/* ARGSUSED */
void
nxge_xmac_init_kstats(struct kstat *ksp)
{
        p_nxge_xmac_kstat_t nxgekp;

        nxgekp = (p_nxge_xmac_kstat_t)ksp->ks_data;

        /*
         * Transmit MAC statistics.
         */
        kstat_named_init(&nxgekp->tx_frame_cnt, "txmac_frame_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_underflow_err, "txmac_underflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_overflow_err, "txmac_overflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_maxpktsize_err, "txmac_maxpktsize_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_fifo_xfr_err, "txmac_fifo_xfr_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_byte_cnt, "txmac_byte_cnt",
            KSTAT_DATA_ULONG);

        /* Receive MAC statistics */
        kstat_named_init(&nxgekp->rx_frame_cnt, "rxmac_frame_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_overflow_err, "rxmac_overflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_underflow_err, "rxmac_underflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_crc_err_cnt, "rxmac_crc_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_len_err_cnt, "rxmac_length_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_viol_err_cnt, "rxmac_code_violations",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_byte_cnt, "rxmac_byte_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_frame_align_err_cnt,
            "rxmac_alignment_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_hist1_cnt, "rxmac_64_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_hist2_cnt, "rxmac_65_127_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_hist3_cnt, "rxmac_128_255_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_hist4_cnt, "rxmac_256_511_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_hist5_cnt, "rxmac_512_1023_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_hist6_cnt, "rxmac_1024_1522_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_hist7_cnt, "rxmac_jumbo_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_broadcast_cnt, "rxmac_broadcast_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_mult_cnt, "rxmac_multicast_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_frag_cnt, "rxmac_fragment_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_linkfault_err_cnt, "rxmac_linkfault_errs",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_remote_fault_err_cnt,
            "rxmac_remote_faults",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_local_fault_err_cnt, "rxmac_local_faults",
            KSTAT_DATA_ULONG);

        /* XPCS statistics */

        kstat_named_init(&nxgekp->xpcs_deskew_err_cnt, "xpcs_deskew_err_cnt",
            KSTAT_DATA_ULONG);
#ifdef  NXGE_DEBUG_SYMBOL_ERR
        kstat_named_init(&nxgekp->xpcs_ln0_symbol_err_cnt,
            "xpcs_ln0_symbol_err_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->xpcs_ln1_symbol_err_cnt,
            "xpcs_ln1_symbol_err_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->xpcs_ln2_symbol_err_cnt,
            "xpcs_ln2_symbol_err_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->xpcs_ln3_symbol_err_cnt,
            "xpcs_ln3_symbol_err_cnt",
            KSTAT_DATA_ULONG);
#endif
}

/* ARGSUSED */
void
nxge_bmac_init_kstats(struct kstat *ksp)
{
        p_nxge_bmac_kstat_t nxgekp;

        nxgekp = (p_nxge_bmac_kstat_t)ksp->ks_data;

        /*
         * Transmit MAC statistics.
         */
        kstat_named_init(&nxgekp->tx_frame_cnt, "txmac_frame_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_underrun_err, "txmac_underflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_max_pkt_err, "txmac_maxpktsize_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_byte_cnt, "txmac_byte_cnt",
            KSTAT_DATA_ULONG);

        /* Receive MAC statistics */
        kstat_named_init(&nxgekp->rx_overflow_err, "rxmac_overflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_crc_err_cnt, "rxmac_crc_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_len_err_cnt, "rxmac_length_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_viol_err_cnt, "rxmac_code_violations",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_byte_cnt, "rxmac_byte_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_align_err_cnt, "rxmac_alignment_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_frame_cnt, "rxmac_frame_cnt",
            KSTAT_DATA_ULONG);
}

/* ARGSUSED */
void
nxge_mac_init_kstats(p_nxge_t nxgep, struct kstat *ksp)
{
        p_nxge_mac_kstat_t nxgekp;

        nxgekp = (p_nxge_mac_kstat_t)ksp->ks_data;

        /*
         * Transmit MAC statistics.
         */
        kstat_named_init(&nxgekp->tx_frame_cnt, "txmac_frame_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_underflow_err, "txmac_underflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_overflow_err, "txmac_overflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_maxpktsize_err, "txmac_maxpktsize_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_fifo_xfr_err, "txmac_fifo_xfr_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->tx_byte_cnt, "txmac_byte_cnt",
            KSTAT_DATA_ULONG);

        /*
         * Receive MAC statistics
         */
        kstat_named_init(&nxgekp->rx_overflow_err, "rxmac_overflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_underflow_err, "rxmac_underflow_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_crc_err_cnt, "rxmac_crc_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_len_err_cnt, "rxmac_length_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_viol_err_cnt, "rxmac_code_violations",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_byte_cnt, "rxmac_byte_cnt",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_frame_align_err_cnt,
            "rxmac_alignment_err",
            KSTAT_DATA_ULONG);
        kstat_named_init(&nxgekp->rx_frame_cnt, "rxmac_frame_cnt",
            KSTAT_DATA_ULONG);
        if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
                kstat_named_init(&nxgekp->rx_hist1_cnt, "rxmac_64_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_hist2_cnt, "rxmac_65_127_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_hist3_cnt, "rxmac_128_255_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_hist4_cnt, "rxmac_256_511_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_hist5_cnt, "rxmac_512_1023_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_hist6_cnt, "rxmac_1024_1522_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_hist7_cnt, "rxmac_jumbo_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_broadcast_cnt,
                    "rxmac_broadcast_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_mult_cnt, "rxmac_multicast_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_frag_cnt, "rxmac_fragment_cnt",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_linkfault_err_cnt,
                    "rxmac_linkfault_errs",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_remote_fault_err_cnt,
                    "rxmac_remote_faults",
                    KSTAT_DATA_ULONG);
                kstat_named_init(&nxgekp->rx_local_fault_err_cnt,
                    "rxmac_local_faults",
                    KSTAT_DATA_ULONG);
        }
}

/* ARGSUSED */
void
nxge_destroy_kstats(p_nxge_t nxgep)
{
        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_destroy_kstats"));

        if (nxgep->statsp == NULL)
                return;
        if (nxgep->statsp->ksp)
                kstat_delete(nxgep->statsp->ksp);

        if (nxgep->statsp->rdc_sys_ksp)
                kstat_delete(nxgep->statsp->rdc_sys_ksp);
        if (nxgep->statsp->fflp_ksp[0])
                kstat_delete(nxgep->statsp->fflp_ksp[0]);
        if (nxgep->statsp->ipp_ksp)
                kstat_delete(nxgep->statsp->ipp_ksp);
        if (nxgep->statsp->txc_ksp)
                kstat_delete(nxgep->statsp->txc_ksp);
        if (nxgep->statsp->mac_ksp)
                kstat_delete(nxgep->statsp->mac_ksp);
        if (nxgep->statsp->zcp_ksp)
                kstat_delete(nxgep->statsp->zcp_ksp);
        if (nxgep->statsp->port_ksp)
                kstat_delete(nxgep->statsp->port_ksp);
        if (nxgep->statsp->mmac_ksp)
                kstat_delete(nxgep->statsp->mmac_ksp);
        if (nxgep->statsp)
                KMEM_FREE(nxgep->statsp, nxgep->statsp->stats_size);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_destroy_kstats"));
}

/* ARGSUSED */
int
nxge_port_kstat_update(kstat_t *ksp, int rw)
{
        p_nxge_t nxgep;
        p_nxge_stats_t statsp;
        p_nxge_port_kstat_t nxgekp;

        nxgep = (p_nxge_t)ksp->ks_private;
        if (nxgep == NULL)
                return (-1);

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_port_kstat_update"));
        statsp = (p_nxge_stats_t)nxgep->statsp;
        nxgekp = (p_nxge_port_kstat_t)ksp->ks_data;
        nxge_save_cntrs(nxgep);

        if (rw == KSTAT_WRITE) {
                /*
                 * transceiver state informations.
                 */
                statsp->mac_stats.xcvr_inits = nxgekp->xcvr_inits.value.ul;

                /*
                 * Tx Statistics.
                 */
#if defined MULTI_DATA_TX || defined MULTI_DATA_TXV2
                statsp->port_stats.mdt_reqs = nxgekp->mdt_reqs.value.ul;
                statsp->port_stats.mdt_hdr_bufs = nxgekp->mdt_hdr_bufs.value.ul;
                statsp->port_stats.mdt_pld_bufs = nxgekp->mdt_pld_bufs.value.ul;
                statsp->port_stats.mdt_pkts = nxgekp->mdt_pkts.value.ul;
                statsp->port_stats.mdt_hdrs = nxgekp->mdt_hdrs.value.ul;
                statsp->port_stats.mdt_plds = nxgekp->mdt_plds.value.ul;
                statsp->port_stats.mdt_hdr_bind_fail =
                    nxgekp->mdt_hdr_bind_fail.value.ul;
                statsp->port_stats.mdt_pld_bind_fail =
                    nxgekp->mdt_pld_bind_fail.value.ul;
#endif
#ifdef ACCEPT_JUMBO
                statsp->port_stats.tx_jumbo_pkts =
                    nxgekp->tx_jumbo_pkts.value.ul;
#endif
                /*
                 * Rx Statistics.
                 */
#ifdef ACCEPT_JUMBO
                statsp->port_stats.rx_jumbo_pkts =
                    nxgekp->rx_jumbo_pkts.value.ul;
#endif
                if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
                        (void) nxge_xmac_stat_update(ksp, KSTAT_WRITE);
                } else {
                        (void) nxge_bmac_stat_update(ksp, KSTAT_WRITE);
                }
                return (0);
        } else {
                if (nxgep->filter.all_phys_cnt)
                        (void) strcpy(nxgekp->promisc.value.c, "phys");
                else if (nxgep->filter.all_multicast_cnt)
                        (void) strcpy(nxgekp->promisc.value.c, "multi");
                else
                        (void) strcpy(nxgekp->promisc.value.c, "off");
                nxgekp->ifspeed.value.ul =
                    statsp->mac_stats.link_speed * 1000000ULL;
                nxgekp->rev_id.value.ul = statsp->mac_stats.rev_id;

                /*
                 * transceiver state informations.
                 */
                nxgekp->xcvr_inits.value.ul = statsp->mac_stats.xcvr_inits;
                nxgekp->xcvr_inuse.value.ul = statsp->mac_stats.xcvr_inuse;
                nxgekp->xcvr_addr.value.ul = statsp->mac_stats.xcvr_portn;
                nxgekp->xcvr_id.value.ul = statsp->mac_stats.xcvr_id;
                nxgekp->cap_autoneg.value.ul = statsp->mac_stats.cap_autoneg;
                nxgekp->cap_10gfdx.value.ul = statsp->mac_stats.cap_10gfdx;
                nxgekp->cap_10ghdx.value.ul = statsp->mac_stats.cap_10ghdx;
                nxgekp->cap_1000fdx.value.ul = statsp->mac_stats.cap_1000fdx;
                nxgekp->cap_1000hdx.value.ul = statsp->mac_stats.cap_1000hdx;
                nxgekp->cap_100T4.value.ul = statsp->mac_stats.cap_100T4;
                nxgekp->cap_100fdx.value.ul = statsp->mac_stats.cap_100fdx;
                nxgekp->cap_100hdx.value.ul = statsp->mac_stats.cap_100hdx;
                nxgekp->cap_10fdx.value.ul = statsp->mac_stats.cap_10fdx;
                nxgekp->cap_10hdx.value.ul = statsp->mac_stats.cap_10hdx;
                nxgekp->cap_asmpause.value.ul =
                    statsp->mac_stats.cap_asmpause;
                nxgekp->cap_pause.value.ul = statsp->mac_stats.cap_pause;

                /*
                 * Link partner capabilities.
                 */
                nxgekp->lp_cap_autoneg.value.ul =
                    statsp->mac_stats.lp_cap_autoneg;
                nxgekp->lp_cap_10gfdx.value.ul =
                    statsp->mac_stats.lp_cap_10gfdx;
                nxgekp->lp_cap_10ghdx.value.ul =
                    statsp->mac_stats.lp_cap_10ghdx;
                nxgekp->lp_cap_1000fdx.value.ul =
                    statsp->mac_stats.lp_cap_1000fdx;
                nxgekp->lp_cap_1000hdx.value.ul =
                    statsp->mac_stats.lp_cap_1000hdx;
                nxgekp->lp_cap_100T4.value.ul =
                    statsp->mac_stats.lp_cap_100T4;
                nxgekp->lp_cap_100fdx.value.ul =
                    statsp->mac_stats.lp_cap_100fdx;
                nxgekp->lp_cap_100hdx.value.ul =
                    statsp->mac_stats.lp_cap_100hdx;
                nxgekp->lp_cap_10fdx.value.ul =
                    statsp->mac_stats.lp_cap_10fdx;
                nxgekp->lp_cap_10hdx.value.ul =
                    statsp->mac_stats.lp_cap_10hdx;
                nxgekp->lp_cap_asmpause.value.ul =
                    statsp->mac_stats.lp_cap_asmpause;
                nxgekp->lp_cap_pause.value.ul =
                    statsp->mac_stats.lp_cap_pause;

                /*
                 * Physical link statistics.
                 */
                nxgekp->link_T4.value.ul = statsp->mac_stats.link_T4;
                nxgekp->link_speed.value.ul = statsp->mac_stats.link_speed;
                if (statsp->mac_stats.link_duplex == 2)
                        (void) strcpy(nxgekp->link_duplex.value.c, "full");
                else if (statsp->mac_stats.link_duplex == 1)
                        (void) strcpy(nxgekp->link_duplex.value.c, "half");
                else
                        (void) strcpy(nxgekp->link_duplex.value.c, "unknown");
                nxgekp->link_asmpause.value.ul =
                    statsp->mac_stats.link_asmpause;
                nxgekp->link_pause.value.ul = statsp->mac_stats.link_pause;
                nxgekp->link_up.value.ul = statsp->mac_stats.link_up;

                /*
                 * Lets the user know the MTU currently in use by the physical
                 * MAC port.
                 */
                nxgekp->mac_mtu.value.ul = statsp->mac_stats.mac_mtu;

                /*
                 * Loopback statistics.
                 */
                nxgekp->lb_mode.value.ul = statsp->port_stats.lb_mode;

                /*
                 * This tells the user whether the driver is in QOS mode or
                 * not.
                 */
                nxgekp->qos_mode.value.ul = statsp->port_stats.qos_mode;

                /*
                 * This tells whether the instance is trunked or not
                 */
                nxgekp->trunk_mode.value.ul = statsp->port_stats.trunk_mode;

#if defined MULTI_DATA_TX || defined MULTI_DATA_TXV2
                nxgekp->mdt_reqs.value.ul = statsp->port_stats.mdt_reqs;
                nxgekp->mdt_hdr_bufs.value.ul =
                    statsp->port_stats.mdt_hdr_bufs;
                nxgekp->mdt_pld_bufs.value.ul =
                    statsp->port_stats.mdt_pld_bufs;
                nxgekp->mdt_pkts.value.ul = statsp->port_stats.mdt_pkts;
                nxgekp->mdt_hdrs.value.ul = statsp->port_stats.mdt_hdrs;
                nxgekp->mdt_plds.value.ul = statsp->port_stats.mdt_plds;
                nxgekp->mdt_hdr_bind_fail.value.ul =
                    statsp->port_stats.mdt_hdr_bind_fail;
                nxgekp->mdt_pld_bind_fail.value.ul =
                    statsp->port_stats.mdt_pld_bind_fail;
#endif
#ifdef ACCEPT_JUMBO
                nxgekp->tx_jumbo_pkts.value.ul =
                    statsp->port_stats.tx_jumbo_pkts;
#endif
#ifdef TX_MBLK_DEST
                nxgekp->tx_1_desc.value.ul = statsp->port_stats.tx_1_desc;
                nxgekp->tx_2_desc.value.ul = statsp->port_stats.tx_2_desc;
                nxgekp->tx_3_desc.value.ul = statsp->port_stats.tx_3_desc;
                nxgekp->tx_4_desc.value.ul = statsp->port_stats.tx_4_desc;
                nxgekp->tx_5_desc.value.ul = statsp->port_stats.tx_5_desc;
                nxgekp->tx_6_desc.value.ul = statsp->port_stats.tx_6_desc;
                nxgekp->tx_7_desc.value.ul = statsp->port_stats.tx_7_desc;
                nxgekp->tx_8_desc.value.ul = statsp->port_stats.tx_8_desc;
                nxgekp->tx_max_desc.value.ul =
                    statsp->port_stats.tx_max_desc;
#endif
                /*
                 * Rx Statistics.
                 */
#ifdef ACCEPT_JUMBO
                nxgekp->rx_jumbo_pkts.value.ul =
                    statsp->port_stats.rx_jumbo_pkts;
#endif
                if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
                        (void) nxge_xmac_stat_update(ksp, KSTAT_READ);
                } else {
                        (void) nxge_bmac_stat_update(ksp, KSTAT_READ);
                }
        }

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "<== nxge_port_kstat_update"));
        return (0);
}

/*
 * if this is the first init do not bother to save the
 * counters.
 */
/* ARGSUSED */
void
nxge_save_cntrs(p_nxge_t nxgep)
{
        p_nxge_stats_t statsp;
        uint64_t val;
        npi_handle_t handle;
        uint8_t portn;
        uint8_t cnt8;
        uint16_t cnt16;
        uint32_t cnt32;

        NXGE_DEBUG_MSG((nxgep, DDI_CTL, "==> nxge_save_cntrs"));

        statsp = (p_nxge_stats_t)nxgep->statsp;
        handle = nxgep->npi_handle;
        portn = nxgep->mac.portnum;

        MUTEX_ENTER(&nxgep->ouraddr_lock);

        if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
                /*
                 * Transmit MAC statistics.
                 */
                XMAC_REG_RD(handle, portn, XTXMAC_FRM_CNT_REG, &val);
                statsp->xmac_stats.tx_frame_cnt += (val & XTXMAC_FRM_CNT_MASK);
                XMAC_REG_RD(handle, portn, XTXMAC_BYTE_CNT_REG, &val);
                statsp->xmac_stats.tx_byte_cnt += (val & XTXMAC_BYTE_CNT_MASK);
                /*
                 * Receive XMAC statistics.
                 */
                XMAC_REG_RD(handle, portn, XRXMAC_CRC_ER_CNT_REG, &val);
                statsp->xmac_stats.rx_crc_err_cnt +=
                    (val & XRXMAC_CRC_ER_CNT_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_MPSZER_CNT_REG, &val);
                statsp->xmac_stats.rx_len_err_cnt +=
                    (val & XRXMAC_MPSZER_CNT_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_CD_VIO_CNT_REG, &val);
                statsp->xmac_stats.rx_viol_err_cnt +=
                    (val & XRXMAC_CD_VIO_CNT_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_BT_CNT_REG, &val);
                statsp->xmac_stats.rx_byte_cnt += (val & XRXMAC_BT_CNT_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_HIST_CNT1_REG, &val);
                statsp->xmac_stats.rx_hist1_cnt +=
                    (val & XRXMAC_HIST_CNT1_MASK);
                statsp->xmac_stats.rx_frame_cnt +=
                    (val & XRXMAC_HIST_CNT1_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_HIST_CNT2_REG, &val);
                statsp->xmac_stats.rx_hist2_cnt +=
                    (val & XRXMAC_HIST_CNT2_MASK);
                statsp->xmac_stats.rx_frame_cnt +=
                    (val & XRXMAC_HIST_CNT2_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_HIST_CNT3_REG, &val);
                statsp->xmac_stats.rx_hist3_cnt +=
                    (val & XRXMAC_HIST_CNT3_MASK);
                statsp->xmac_stats.rx_frame_cnt +=
                    (val & XRXMAC_HIST_CNT3_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_HIST_CNT4_REG, &val);
                statsp->xmac_stats.rx_hist4_cnt +=
                    (val & XRXMAC_HIST_CNT4_MASK);
                statsp->xmac_stats.rx_frame_cnt +=
                    (val & XRXMAC_HIST_CNT4_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_HIST_CNT5_REG, &val);
                statsp->xmac_stats.rx_hist5_cnt +=
                    (val & XRXMAC_HIST_CNT5_MASK);
                statsp->xmac_stats.rx_frame_cnt +=
                    (val & XRXMAC_HIST_CNT5_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_HIST_CNT6_REG, &val);
                statsp->xmac_stats.rx_hist6_cnt +=
                    (val & XRXMAC_HIST_CNT6_MASK);
                statsp->xmac_stats.rx_frame_cnt +=
                    (val & XRXMAC_HIST_CNT6_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_HIST_CNT7_REG, &val);
                statsp->xmac_stats.rx_hist7_cnt +=
                    (val & XRXMAC_HIST_CNT7_MASK);
                statsp->xmac_stats.rx_frame_cnt +=
                    (val & XRXMAC_HIST_CNT7_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_BC_FRM_CNT_REG, &val);
                statsp->xmac_stats.rx_broadcast_cnt +=
                    (val & XRXMAC_BC_FRM_CNT_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_MC_FRM_CNT_REG, &val);
                statsp->xmac_stats.rx_mult_cnt +=
                    (val & XRXMAC_MC_FRM_CNT_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_FRAG_CNT_REG, &val);
                statsp->xmac_stats.rx_frag_cnt += (val & XRXMAC_FRAG_CNT_MASK);

                XMAC_REG_RD(handle, portn, XRXMAC_AL_ER_CNT_REG, &val);
                statsp->xmac_stats.rx_frame_align_err_cnt +=
                    (val & XRXMAC_AL_ER_CNT_MASK);

                XMAC_REG_RD(handle, portn, XMAC_LINK_FLT_CNT_REG, &val);
                statsp->xmac_stats.rx_linkfault_err_cnt +=
                    (val & XMAC_LINK_FLT_CNT_MASK);

                (void) npi_xmac_xpcs_read(handle, portn,
                    XPCS_REG_DESCWERR_COUNTER, &cnt32);
                statsp->xmac_stats.xpcs_deskew_err_cnt +=
                    (val & XMAC_XPCS_DESKEW_ERR_CNT_MASK);

#ifdef  NXGE_DEBUG_SYMBOL_ERR
                (void) npi_xmac_xpcs_read(handle, portn,
                    XPCS_REG_SYMBOL_ERR_L0_1_COUNTER, &cnt32);
                statsp->xmac_stats.xpcs_ln0_symbol_err_cnt +=
                    (cnt32 & XMAC_XPCS_SYM_ERR_CNT_L0_MASK);
                statsp->xmac_stats.xpcs_ln1_symbol_err_cnt +=
                    ((cnt32 & XMAC_XPCS_SYM_ERR_CNT_L1_MASK) >>
                    XMAC_XPCS_SYM_ERR_CNT_L1_SHIFT);
                (void) npi_xmac_xpcs_read(handle, portn,
                    XPCS_REG_SYMBOL_ERR_L2_3_COUNTER, &cnt32);
                statsp->xmac_stats.xpcs_ln2_symbol_err_cnt +=
                    (cnt32 & XMAC_XPCS_SYM_ERR_CNT_L2_MASK);
                statsp->xmac_stats.xpcs_ln3_symbol_err_cnt +=
                    ((cnt32 & XMAC_XPCS_SYM_ERR_CNT_L3_MASK) >>
                    XMAC_XPCS_SYM_ERR_CNT_L3_SHIFT);
#endif
        } else if (nxgep->mac.porttype == PORT_TYPE_BMAC) {
                /*
                 * Transmit MAC statistics.
                 */
                BMAC_REG_RD(handle, portn, BTXMAC_FRM_CNT_REG, &val);
                statsp->bmac_stats.tx_frame_cnt += (val & BTXMAC_FRM_CNT_MASK);
                /* Clear register as it is not auto clear on read */
                BMAC_REG_WR(handle, portn, BTXMAC_FRM_CNT_REG, 0);

                BMAC_REG_RD(handle, portn, BTXMAC_BYTE_CNT_REG, &val);
                statsp->bmac_stats.tx_byte_cnt += (val & BTXMAC_BYTE_CNT_MASK);
                /* Clear register as it is not auto clear on read */
                BMAC_REG_WR(handle, portn, BTXMAC_BYTE_CNT_REG, 0);

                /*
                 * Receive MAC statistics.
                 */
                BMAC_REG_RD(handle, portn, RXMAC_FRM_CNT_REG, &val);
                statsp->bmac_stats.rx_frame_cnt += (val & RXMAC_FRM_CNT_MASK);
                /* Clear register as it is not auto clear on read */
                BMAC_REG_WR(handle, portn, RXMAC_FRM_CNT_REG, 0);

                BMAC_REG_RD(handle, portn, BRXMAC_BYTE_CNT_REG, &val);
                statsp->bmac_stats.rx_byte_cnt += (val & BRXMAC_BYTE_CNT_MASK);
                /* Clear register as it is not auto clear on read */
                BMAC_REG_WR(handle, portn, BRXMAC_BYTE_CNT_REG, 0);

                BMAC_REG_RD(handle, portn, BMAC_AL_ER_CNT_REG, &val);
                statsp->bmac_stats.rx_align_err_cnt +=
                    (val & BMAC_AL_ER_CNT_MASK);
                /* Clear register as it is not auto clear on read */
                BMAC_REG_WR(handle, portn, BMAC_AL_ER_CNT_REG, 0);

                BMAC_REG_RD(handle, portn, MAC_LEN_ER_CNT_REG, &val);
                statsp->bmac_stats.rx_len_err_cnt +=
                    (val & MAC_LEN_ER_CNT_MASK);
                /* Clear register as it is not auto clear on read */
                BMAC_REG_WR(handle, portn, MAC_LEN_ER_CNT_REG, 0);

                BMAC_REG_RD(handle, portn, BMAC_CRC_ER_CNT_REG, &val);
                statsp->bmac_stats.rx_crc_err_cnt +=
                    (val & BMAC_CRC_ER_CNT_MASK);
                /* Clear register as it is not auto clear on read */
                BMAC_REG_WR(handle, portn, BMAC_CRC_ER_CNT_REG, 0);

                BMAC_REG_RD(handle, portn, BMAC_CD_VIO_CNT_REG, &val);
                statsp->bmac_stats.rx_viol_err_cnt +=
                    (val & BMAC_CD_VIO_CNT_MASK);
                /* Clear register as it is not auto clear on read */
                BMAC_REG_WR(handle, portn, BMAC_CD_VIO_CNT_REG, 0);
        }
        if (isLDOMguest(nxgep)) {
                MUTEX_EXIT(&nxgep->ouraddr_lock);
                goto nxge_save_cntrs_exit;
        }
        /* Update IPP counters */
        (void) npi_ipp_get_ecc_err_count(handle, portn, &cnt8);
        statsp->ipp_stats.ecc_err_cnt += cnt8;
        (void) npi_ipp_get_pkt_dis_count(handle, portn, &cnt16);
        statsp->ipp_stats.pkt_dis_cnt += cnt16;
        (void) npi_ipp_get_cs_err_count(handle, portn, &cnt16);
        statsp->ipp_stats.bad_cs_cnt += cnt16;

        MUTEX_EXIT(&nxgep->ouraddr_lock);

nxge_save_cntrs_exit:
        NXGE_DEBUG_MSG((nxgep, DDI_CTL, "<== nxge_save_cntrs"));
}

uint64_t
nxge_m_rx_stat(
        nxge_t *nxgep,
        uint_t stat)
{
        p_nxge_stats_t statsp;
        nxge_grp_set_t *rx_set;
        int8_t set[NXGE_MAX_RDCS];
        int i, cursor;

        uint64_t val = 0;

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_m_rx_stat"));
        statsp = (p_nxge_stats_t)nxgep->statsp;

        rx_set = &nxgep->rx_set;
        for (i = 0, cursor = 0; i < NXGE_MAX_RDCS; i++) {
                if ((1 << i) & rx_set->owned.map) {
                        set[cursor++] = (uint8_t)i;
                }
        }

        for (i = 0; i < cursor; i++) {
                int rdc = set[i];
                switch (stat) {
                case MAC_STAT_IERRORS:
                case ETHER_STAT_MACRCV_ERRORS:
                        val += statsp->rdc_stats[rdc].ierrors;
                        break;

                case MAC_STAT_RBYTES:
                        val += statsp->rdc_stats[rdc].ibytes;
                        break;

                case MAC_STAT_IPACKETS:
                        val += statsp->rdc_stats[rdc].ipackets;
                        break;

                default:
                        break;
                }
        }

        return (val);
}

uint64_t
nxge_m_tx_stat(
        nxge_t *nxgep,
        uint_t stat)
{
        p_nxge_stats_t statsp;
        nxge_grp_set_t *tx_set;
        int8_t set[NXGE_MAX_TDCS];
        int i, cursor;

        uint64_t val = 0;

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_m_tx_stat"));
        statsp = (p_nxge_stats_t)nxgep->statsp;

        tx_set = &nxgep->tx_set;
        for (i = 0, cursor = 0; i < NXGE_MAX_TDCS; i++) {
                if ((1 << i) & tx_set->owned.map) {
                        set[cursor++] = (uint8_t)i;
                }
        }

        for (i = 0; i < cursor; i++) {
                int tdc = set[i];
                switch (stat) {
                case MAC_STAT_OERRORS:
                        val += statsp->tdc_stats[tdc].oerrors;
                        break;

                case MAC_STAT_OBYTES:
                        val += statsp->tdc_stats[tdc].obytes;
                        break;

                case MAC_STAT_OPACKETS:
                        val += statsp->tdc_stats[tdc].opackets;
                        break;

                default:
                        break;
                }
        }

        return (val);
}

/*
 * Retrieve a value for one of the statistics for a particular rx ring
 */
int
nxge_rx_ring_stat(mac_ring_driver_t rdriver, uint_t stat, uint64_t *val)
{
        p_nxge_ring_handle_t    rhp = (p_nxge_ring_handle_t)rdriver;
        p_nxge_t                nxgep = rhp->nxgep;
        int                     r_index;
        p_nxge_stats_t          statsp;

        ASSERT(nxgep != NULL);
        statsp = (p_nxge_stats_t)nxgep->statsp;
        ASSERT(statsp != NULL);
        r_index = rhp->index + nxgep->pt_config.hw_config.start_rdc;

        if (statsp->rdc_ksp[r_index] == NULL)
                return (0);

        switch (stat) {
        case MAC_STAT_IERRORS:
                *val = statsp->rdc_stats[r_index].ierrors;
                break;

        case MAC_STAT_RBYTES:
                *val = statsp->rdc_stats[r_index].ibytes;
                break;

        case MAC_STAT_IPACKETS:
                *val = statsp->rdc_stats[r_index].ipackets;
                break;

        default:
                *val = 0;
                return (ENOTSUP);
        }

        return (0);
}

/*
 * Retrieve a value for one of the statistics for a particular tx ring
 */
int
nxge_tx_ring_stat(mac_ring_driver_t rdriver, uint_t stat, uint64_t *val)
{
        p_nxge_ring_handle_t    rhp = (p_nxge_ring_handle_t)rdriver;
        p_nxge_t                nxgep = rhp->nxgep;
        int                     r_index;
        p_nxge_stats_t          statsp;

        ASSERT(nxgep != NULL);
        statsp = (p_nxge_stats_t)nxgep->statsp;
        ASSERT(statsp != NULL);
        r_index = nxgep->pt_config.hw_config.tdc.start + rhp->index;

        if (statsp->tdc_ksp[r_index] == NULL)
                return (0);

        switch (stat) {
        case MAC_STAT_OERRORS:
                *val = statsp->tdc_stats[r_index].oerrors;
                break;

        case MAC_STAT_OBYTES:
                *val = statsp->tdc_stats[r_index].obytes;
                break;

        case MAC_STAT_OPACKETS:
                *val = statsp->tdc_stats[r_index].opackets;
                break;

        default:
                *val = 0;
                return (ENOTSUP);
        }

        return (0);
}

/* ARGSUSED */
int
nxge_m_stat(void *arg, uint_t stat, uint64_t *value)
{
        p_nxge_t nxgep = (p_nxge_t)arg;
        p_nxge_stats_t statsp;
        uint64_t val = 0;

        NXGE_DEBUG_MSG((nxgep, KST_CTL, "==> nxge_m_stat"));
        statsp = (p_nxge_stats_t)nxgep->statsp;

        switch (stat) {
        case MAC_STAT_IFSPEED:
                val = statsp->mac_stats.link_speed * 1000000ull;
                break;

        case MAC_STAT_MULTIRCV:
                val = statsp->port_stats.multircv;
                break;

        case MAC_STAT_BRDCSTRCV:
                val = statsp->port_stats.brdcstrcv;
                break;

        case MAC_STAT_MULTIXMT:
                val = statsp->port_stats.multixmt;
                break;

        case MAC_STAT_BRDCSTXMT:
                val = statsp->port_stats.brdcstxmt;
                break;

        case MAC_STAT_NORCVBUF:
                val = statsp->port_stats.norcvbuf;
                break;

        case MAC_STAT_IERRORS:
        case ETHER_STAT_MACRCV_ERRORS:
                val = nxge_m_rx_stat(nxgep, stat);
                break;

        case MAC_STAT_OERRORS:
                val = nxge_m_tx_stat(nxgep, stat);
                break;

        case MAC_STAT_NOXMTBUF:
                val = statsp->port_stats.noxmtbuf;
                break;

        case MAC_STAT_COLLISIONS:
                val = 0;
                break;

        case MAC_STAT_RBYTES:
                val = nxge_m_rx_stat(nxgep, stat);
                break;

        case MAC_STAT_IPACKETS:
                val = nxge_m_rx_stat(nxgep, stat);
                break;

        case MAC_STAT_OBYTES:
                val = nxge_m_tx_stat(nxgep, stat);
                break;

        case MAC_STAT_OPACKETS:
                val = nxge_m_tx_stat(nxgep, stat);
                break;
        case MAC_STAT_LINK_STATE:
                val = statsp->mac_stats.link_duplex;
                break;
        case MAC_STAT_LINK_UP:
                val = statsp->mac_stats.link_up;
                break;
        case MAC_STAT_PROMISC:
                val = statsp->mac_stats.promisc;
                break;
        case ETHER_STAT_SQE_ERRORS:
                val = 0;
                break;

        case ETHER_STAT_ALIGN_ERRORS:
                if (nxgep->mac.porttype == PORT_TYPE_XMAC)
                        val = statsp->xmac_stats.rx_frame_align_err_cnt;
                else if (nxgep->mac.porttype == PORT_TYPE_BMAC)
                        val = statsp->bmac_stats.rx_align_err_cnt;
                else
                        val = 0;
                break;

        case ETHER_STAT_FCS_ERRORS:
                if (nxgep->mac.porttype == PORT_TYPE_XMAC)
                        val = statsp->xmac_stats.rx_crc_err_cnt;
                else if (nxgep->mac.porttype == PORT_TYPE_BMAC)
                        val = statsp->bmac_stats.rx_crc_err_cnt;
                else
                        val = 0;
                break;

        case ETHER_STAT_FIRST_COLLISIONS:
                val = 0;
                break;

        case ETHER_STAT_MULTI_COLLISIONS:
                val = 0;
                break;

        case ETHER_STAT_TX_LATE_COLLISIONS:
                val = 0;
                break;

        case ETHER_STAT_EX_COLLISIONS:
                val = 0;
                break;

        case ETHER_STAT_DEFER_XMTS:
                val = 0;
                break;

        case ETHER_STAT_MACXMT_ERRORS:
                if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
                        val = statsp->xmac_stats.tx_underflow_err +
                            statsp->xmac_stats.tx_maxpktsize_err +
                            statsp->xmac_stats.tx_overflow_err +
                            statsp->xmac_stats.tx_fifo_xfr_err;
                } else {
                        val = statsp->bmac_stats.tx_underrun_err +
                            statsp->bmac_stats.tx_max_pkt_err;
                }
                break;

        case ETHER_STAT_CARRIER_ERRORS:
                if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
                        val = statsp->xmac_stats.rx_linkfault_err_cnt;
                } else {
                        val = statsp->mac_stats.xcvr_inits +
                            statsp->mac_stats.serdes_inits;
                }
                break;

        case ETHER_STAT_TOOLONG_ERRORS:
                if (nxgep->mac.porttype == PORT_TYPE_XMAC) {
                        val = statsp->xmac_stats.tx_maxpktsize_err +
                            statsp->xmac_stats.rx_len_err_cnt;

                } else {
                        val = statsp->bmac_stats.rx_len_err_cnt +
                            statsp->bmac_stats.tx_max_pkt_err;
                }
                break;


        case ETHER_STAT_XCVR_ADDR:
                val = statsp->mac_stats.xcvr_portn;
                break;
        case ETHER_STAT_XCVR_ID:
                val = statsp->mac_stats.xcvr_id;
                break;

        case ETHER_STAT_XCVR_INUSE:
                val = statsp->mac_stats.xcvr_inuse;
                break;

        case ETHER_STAT_CAP_1000FDX:
                val = statsp->mac_stats.cap_1000fdx;
                break;

        case ETHER_STAT_CAP_1000HDX:
                val = statsp->mac_stats.cap_1000hdx;
                break;

        case ETHER_STAT_CAP_100FDX:
                val = statsp->mac_stats.cap_100fdx;
                break;

        case ETHER_STAT_CAP_100HDX:
                val = statsp->mac_stats.cap_100hdx;
                break;

        case ETHER_STAT_CAP_10FDX:
                val = statsp->mac_stats.cap_10fdx;
                break;

        case ETHER_STAT_CAP_10HDX:
                val = statsp->mac_stats.cap_10hdx;
                break;

        case ETHER_STAT_CAP_ASMPAUSE:
                val = statsp->mac_stats.cap_asmpause;
                val = 1;
                break;

        case ETHER_STAT_CAP_PAUSE:
                val = statsp->mac_stats.cap_pause;
                break;

        case ETHER_STAT_CAP_AUTONEG:
                val = statsp->mac_stats.cap_autoneg;
                break;

        case ETHER_STAT_ADV_CAP_1000FDX:
                val = statsp->mac_stats.adv_cap_1000fdx;
                break;

        case ETHER_STAT_ADV_CAP_1000HDX:
                val = statsp->mac_stats.adv_cap_1000hdx;
                break;

        case ETHER_STAT_ADV_CAP_100FDX:
                val = statsp->mac_stats.adv_cap_100fdx;
                break;

        case ETHER_STAT_ADV_CAP_100HDX:
                val = statsp->mac_stats.adv_cap_100hdx;
                break;

        case ETHER_STAT_ADV_CAP_10FDX:
                val = statsp->mac_stats.adv_cap_10fdx;
                break;

        case ETHER_STAT_ADV_CAP_10HDX:
                val = statsp->mac_stats.adv_cap_10hdx;
                break;

        case ETHER_STAT_ADV_CAP_ASMPAUSE:
                val = statsp->mac_stats.adv_cap_asmpause;
                break;

        case ETHER_STAT_ADV_CAP_PAUSE:
                val = statsp->mac_stats.adv_cap_pause;
                break;

        case ETHER_STAT_ADV_CAP_AUTONEG:
                val = statsp->mac_stats.adv_cap_autoneg;
                break;

        case ETHER_STAT_LP_CAP_1000FDX:
                val = statsp->mac_stats.lp_cap_1000fdx;
                break;

        case ETHER_STAT_LP_CAP_1000HDX:
                val = statsp->mac_stats.lp_cap_1000hdx;
                break;

        case ETHER_STAT_LP_CAP_100FDX:
                val = statsp->mac_stats.lp_cap_100fdx;
                break;

        case ETHER_STAT_LP_CAP_100HDX:
                val = statsp->mac_stats.lp_cap_100hdx;
                break;

        case ETHER_STAT_LP_CAP_10FDX:
                val = statsp->mac_stats.lp_cap_10fdx;
                break;

        case ETHER_STAT_LP_CAP_10HDX:
                val = statsp->mac_stats.lp_cap_10hdx;
                break;

        case ETHER_STAT_LP_CAP_ASMPAUSE:
                val = statsp->mac_stats.lp_cap_asmpause;
                break;

        case ETHER_STAT_LP_CAP_PAUSE:
                val = statsp->mac_stats.lp_cap_pause;
                break;

        case ETHER_STAT_LP_CAP_AUTONEG:
                val = statsp->mac_stats.lp_cap_autoneg;
                break;

        case ETHER_STAT_LINK_ASMPAUSE:
                val = statsp->mac_stats.link_asmpause;
                break;

        case ETHER_STAT_LINK_PAUSE:
                val = statsp->mac_stats.link_pause;
                break;

        case ETHER_STAT_LINK_AUTONEG:
                val = statsp->mac_stats.cap_autoneg;
                break;

        case ETHER_STAT_LINK_DUPLEX:
                val = statsp->mac_stats.link_duplex;
                break;

        default:
                /*
                 * Shouldn't reach here...
                 */
#ifdef NXGE_DEBUG
                NXGE_ERROR_MSG((nxgep, KST_CTL,
                    "nxge_m_stat: unrecognized parameter value = 0x%x",
                    stat));
#endif

                return (ENOTSUP);
        }
        *value = val;
        return (0);
}
Illumos
