Gitiles
Code Review Sign In
code.illumos.org / illumos-gate / bbb9d5d65bf8372aae4b8821c80e218b8b832846 / . / usr / src / uts / common / io / nxge / nxge_kstats.c
blob: 34cfafc58dbaf24c52d9b16d008c89a391f371a1 [file] [log] [blame]
/*
* 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, NULL, 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, NULL, 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, NULL, 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, NULL, 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, NULL, 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, NULL, 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, NULL, 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, NULL, 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, NULL, 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, NULL, 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);
}