xref: /illumos-gate/usr/src/uts/common/io/bnxe/bnxe_kstat.c (revision 55fea89d)

/*
 * 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 2014 QLogic Corporation
 * The contents of this file are subject to the terms of the
 * QLogic End User License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the License at
 * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/
 * QLogic_End_User_Software_License.txt
 * See the License for the specific language governing permissions
 * and limitations under the License.
 */

/*
 * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
 */

#include "bnxe.h"

typedef struct _BnxeKstat
{
    kstat_named_t umdev_hi;
    kstat_named_t umdev_lo;
    kstat_named_t version;
    kstat_named_t versionFW;
    kstat_named_t versionBC;
    kstat_named_t chipName;
    kstat_named_t chipID;
    kstat_named_t devBDF;
    kstat_named_t devID;
    kstat_named_t multiFunction;
    kstat_named_t multiFunctionVnics;
    kstat_named_t macAddr;
    kstat_named_t hwInitDone;
    kstat_named_t clientsHw;
    kstat_named_t clientsDevi;
    kstat_named_t clientsBound;
    kstat_named_t txMsgPullUp;
    kstat_named_t intrAlloc;
    kstat_named_t intrFired;
    kstat_named_t timerFired;
    kstat_named_t timerReply;
    kstat_named_t timerNoReplyTotal;
    kstat_named_t timerNoReplyCurrent;
    kstat_named_t timerDone;
    kstat_named_t workQueueInstCnt;
    kstat_named_t workItemInstQueued;
    kstat_named_t workItemInstError;
    kstat_named_t workItemInstComplete;
    kstat_named_t workItemInstHighWater;
    kstat_named_t workQueueDelayCnt;
    kstat_named_t workItemDelayQueued;
    kstat_named_t workItemDelayError;
    kstat_named_t workItemDelayComplete;
    kstat_named_t workItemDelayHighWater;
    kstat_named_t memAllocBlocks;
    kstat_named_t memAllocDMAs;
    kstat_named_t memAllocBARs;
} BnxeKstat;

#define BNXE_KSTAT_SIZE (sizeof(BnxeKstat) / sizeof(kstat_named_t))

typedef struct _BnxeKstatLink
{
    kstat_named_t clients;
    kstat_named_t uptime;
    kstat_named_t mtuL2;
    kstat_named_t mtuFCOE;
    kstat_named_t speed;
    kstat_named_t link;
    kstat_named_t duplex;
    kstat_named_t pauseRx;
    kstat_named_t pauseTx;
} BnxeKstatLink;

#define BNXE_KSTAT_LINK_SIZE (sizeof(BnxeKstatLink) / sizeof(kstat_named_t))

typedef struct _BnxeKstatIntr
{
    kstat_named_t intrAlloc;
    kstat_named_t intrFired;
    kstat_named_t intrWrongState;
    kstat_named_t intrInDisabled;
    kstat_named_t intrZeroStatus;
    kstat_named_t sb_00;
    kstat_named_t sb_01;
    kstat_named_t sb_02;
    kstat_named_t sb_03;
    kstat_named_t sb_04;
    kstat_named_t sb_05;
    kstat_named_t sb_06;
    kstat_named_t sb_07;
    kstat_named_t sb_08;
    kstat_named_t sb_09;
    kstat_named_t sb_10;
    kstat_named_t sb_11;
    kstat_named_t sb_12;
    kstat_named_t sb_13;
    kstat_named_t sb_14;
    kstat_named_t sb_15;
    kstat_named_t sb_16;
    kstat_named_t sb_nc_00;
    kstat_named_t sb_nc_01;
    kstat_named_t sb_nc_02;
    kstat_named_t sb_nc_03;
    kstat_named_t sb_nc_04;
    kstat_named_t sb_nc_05;
    kstat_named_t sb_nc_06;
    kstat_named_t sb_nc_07;
    kstat_named_t sb_nc_08;
    kstat_named_t sb_nc_09;
    kstat_named_t sb_nc_10;
    kstat_named_t sb_nc_11;
    kstat_named_t sb_nc_12;
    kstat_named_t sb_nc_13;
    kstat_named_t sb_nc_14;
    kstat_named_t sb_nc_15;
    kstat_named_t sb_nc_16;
    kstat_named_t sb_poll_00;
    kstat_named_t sb_poll_01;
    kstat_named_t sb_poll_02;
    kstat_named_t sb_poll_03;
    kstat_named_t sb_poll_04;
    kstat_named_t sb_poll_05;
    kstat_named_t sb_poll_06;
    kstat_named_t sb_poll_07;
    kstat_named_t sb_poll_08;
    kstat_named_t sb_poll_09;
    kstat_named_t sb_poll_10;
    kstat_named_t sb_poll_11;
    kstat_named_t sb_poll_12;
    kstat_named_t sb_poll_13;
    kstat_named_t sb_poll_14;
    kstat_named_t sb_poll_15;
    kstat_named_t sb_poll_16;
    kstat_named_t sb_poll_nc_00;
    kstat_named_t sb_poll_nc_01;
    kstat_named_t sb_poll_nc_02;
    kstat_named_t sb_poll_nc_03;
    kstat_named_t sb_poll_nc_04;
    kstat_named_t sb_poll_nc_05;
    kstat_named_t sb_poll_nc_06;
    kstat_named_t sb_poll_nc_07;
    kstat_named_t sb_poll_nc_08;
    kstat_named_t sb_poll_nc_09;
    kstat_named_t sb_poll_nc_10;
    kstat_named_t sb_poll_nc_11;
    kstat_named_t sb_poll_nc_12;
    kstat_named_t sb_poll_nc_13;
    kstat_named_t sb_poll_nc_14;
    kstat_named_t sb_poll_nc_15;
    kstat_named_t sb_poll_nc_16;
} BnxeKstatIntr;

#define BNXE_KSTAT_INTR_SIZE (sizeof(BnxeKstatIntr) / sizeof(kstat_named_t))

typedef struct _BnxeKstatL2Chip
{
    kstat_named_t IfHCInOctets;
    kstat_named_t IfHCInBadOctets;
    kstat_named_t IfHCOutOctets;
    kstat_named_t IfHCOutBadOctets;
    kstat_named_t IfHCOutPkts;
    kstat_named_t IfHCInPkts;
    kstat_named_t IfHCInUcastPkts;
    kstat_named_t IfHCInMulticastPkts;
    kstat_named_t IfHCInBroadcastPkts;
    kstat_named_t IfHCOutUcastPkts;
    kstat_named_t IfHCOutMulticastPkts;
    kstat_named_t IfHCOutBroadcastPkts;
    kstat_named_t IfHCInUcastOctets;
    kstat_named_t IfHCInMulticastOctets;
    kstat_named_t IfHCInBroadcastOctets;
    kstat_named_t IfHCOutUcastOctets;
    kstat_named_t IfHCOutMulticastOctets;
    kstat_named_t IfHCOutBroadcastOctets;
    kstat_named_t IfHCOutDiscards;
    kstat_named_t IfHCInFalseCarrierErrors;
    kstat_named_t Dot3StatsInternalMacTransmitErrors;
    kstat_named_t Dot3StatsCarrierSenseErrors;
    kstat_named_t Dot3StatsFCSErrors;
    kstat_named_t Dot3StatsAlignmentErrors;
    kstat_named_t Dot3StatsSingleCollisionFrames;
    kstat_named_t Dot3StatsMultipleCollisionFrames;
    kstat_named_t Dot3StatsDeferredTransmissions;
    kstat_named_t Dot3StatsExcessiveCollisions;
    kstat_named_t Dot3StatsLateCollisions;
    kstat_named_t EtherStatsCollisions;
    kstat_named_t EtherStatsFragments;
    kstat_named_t EtherStatsJabbers;
    kstat_named_t EtherStatsUndersizePkts;
    kstat_named_t EtherStatsOverrsizePkts;
    kstat_named_t EtherStatsTx64Octets;
    kstat_named_t EtherStatsTx65to127Octets;
    kstat_named_t EtherStatsTx128to255Octets;
    kstat_named_t EtherStatsTx256to511Octets;
    kstat_named_t EtherStatsTx512to1023Octets;
    kstat_named_t EtherStatsTx1024to1522Octets;
    kstat_named_t EtherStatsTxOver1522Octets;
    kstat_named_t XonPauseFramesReceived;
    kstat_named_t XoffPauseFramesReceived;
    kstat_named_t OutXonSent;
    kstat_named_t OutXoffSent;
    kstat_named_t FlowControlDone;
    kstat_named_t MacControlFramesReceived;
    kstat_named_t XoffStateEntered;
    kstat_named_t IfInFramesL2FilterDiscards;
    kstat_named_t IfInTTL0Discards;
    kstat_named_t IfInxxOverflowDiscards;
    kstat_named_t IfInMBUFDiscards;
    kstat_named_t IfInErrors;
    kstat_named_t IfInErrorsOctets;
    kstat_named_t IfInNoBrbBuffer;
    kstat_named_t NigBrbPacket;
    kstat_named_t NigBrbTruncate;
    kstat_named_t NigFlowCtrlDiscard;
    kstat_named_t NigFlowCtrlOctets;
    kstat_named_t NigFlowCtrlPacket;
    kstat_named_t NigMngDiscard;
    kstat_named_t NigMngOctetInp;
    kstat_named_t NigMngOctetOut;
    kstat_named_t NigMngPacketInp;
    kstat_named_t NigMngPacketOut;
    kstat_named_t NigPbfOctets;
    kstat_named_t NigPbfPacket;
    kstat_named_t NigSafcInp;
} BnxeKstatL2Chip;

#define BNXE_KSTAT_L2_CHIP_SIZE (sizeof(BnxeKstatL2Chip) / sizeof(kstat_named_t))

typedef struct _BnxeKstatL2Driver
{
    kstat_named_t RxIPv4FragCount;
    kstat_named_t RxIpCsErrorCount;
    kstat_named_t RxTcpCsErrorCount;
    kstat_named_t RxLlcSnapCount;
    kstat_named_t RxPhyErrorCount;
    kstat_named_t RxIpv6ExtCount;
    kstat_named_t TxNoL2Bd;
    kstat_named_t TxNoSqWqe;
    kstat_named_t TxL2AssemblyBufUse;
} BnxeKstatL2Driver;

#define BNXE_KSTAT_L2_DRIVER_SIZE (sizeof(BnxeKstatL2Driver) / sizeof(kstat_named_t))

typedef struct _BnxeKstatEthStats
{
    /* lm_stats_t */
    kstat_named_t txFramesOk;         // LM_STATS_FRAMES_XMITTED_OK
    kstat_named_t rxFramesOk;         // LM_STATS_FRAMES_RECEIVED_OK
    kstat_named_t txErr;              // LM_STATS_ERRORED_TRANSMIT_CNT
    kstat_named_t rxErr;              // LM_STATS_ERRORED_RECEIVE_CNT
    kstat_named_t rxCrcErr;           // LM_STATS_RCV_CRC_ERROR
    kstat_named_t alignErr;           // LM_STATS_ALIGNMENT_ERROR
    kstat_named_t collisionsSingle;   // LM_STATS_SINGLE_COLLISION_FRAMES
    kstat_named_t collisionsMultiple; // LM_STATS_MULTIPLE_COLLISION_FRAMES
    kstat_named_t framesDeferred;     // LM_STATS_FRAMES_DEFERRED
    kstat_named_t collisonsMax;       // LM_STATS_MAX_COLLISIONS
    kstat_named_t rxOverrun;          // LM_STATS_RCV_OVERRUN
    kstat_named_t txOverrun;          // LM_STATS_XMIT_UNDERRUN
    kstat_named_t txFramesUnicast;    // LM_STATS_UNICAST_FRAMES_XMIT
    kstat_named_t txFramesMulticast;  // LM_STATS_MULTICAST_FRAMES_XMIT
    kstat_named_t txFramesBroadcast;  // LM_STATS_BROADCAST_FRAMES_XMIT
    kstat_named_t rxFramesUnicast;    // LM_STATS_UNICAST_FRAMES_RCV
    kstat_named_t rxFramesMulticast;  // LM_STATS_MULTICAST_FRAMES_RCV
    kstat_named_t rxFramesBroadcast;  // LM_STATS_BROADCAST_FRAMES_RCV
    kstat_named_t rxNoBufferDrop;     // LM_STATS_RCV_NO_BUFFER_DROP
    kstat_named_t rxBytes;            // LM_STATS_BYTES_RCV
    kstat_named_t txBytes;            // LM_STATS_BYTES_XMIT
    kstat_named_t offloadIP4;         // LM_STATS_IP4_OFFLOAD
    kstat_named_t offloadTCP;         // LM_STATS_TCP_OFFLOAD
    kstat_named_t ifInDiscards;       // LM_STATS_IF_IN_DISCARDS
    kstat_named_t ifInErrors;         // LM_STATS_IF_IN_ERRORS
    kstat_named_t ifOutErrors;        // LM_STATS_IF_OUT_ERRORS
    kstat_named_t offloadIP6;         // LM_STATS_IP6_OFFLOAD
    kstat_named_t offloadTCP6;        // LM_STATS_TCP6_OFFLOAD
    kstat_named_t txDiscards;         // LM_STATS_XMIT_DISCARDS
    kstat_named_t rxBytesUnicast;     // LM_STATS_DIRECTED_BYTES_RCV
    kstat_named_t rxBytesMulticast;   // LM_STATS_MULTICAST_BYTES_RCV
    kstat_named_t rxBytesBroadcast;   // LM_STATS_BROADCAST_BYTES_RCV
    kstat_named_t txBytesUnicast;     // LM_STATS_DIRECTED_BYTES_XMIT
    kstat_named_t txBytesMulticast;   // LM_STATS_MULTICAST_BYTES_XMIT
    kstat_named_t txBytesBroadcast;   // LM_STATS_BROADCAST_BYTES_XMIT
} BnxeKstatEthStats;

#define BNXE_KSTAT_ETH_STATS_SIZE (sizeof(BnxeKstatEthStats) / sizeof(kstat_named_t))

typedef struct _BnxeKstatFcoe
{
    kstat_named_t pdev_hi;
    kstat_named_t pdev_lo;
    kstat_named_t instance;
    kstat_named_t macAddr;
    kstat_named_t pwwn_hi;
    kstat_named_t pwwn_lo;
    kstat_named_t mtu;
    kstat_named_t initWqeTx;
    kstat_named_t initWqeTxErr;
    kstat_named_t initCqeRx;
    kstat_named_t initCqeRxErr;
    kstat_named_t offloadConnWqeTx;
    kstat_named_t offloadConnWqeTxErr;
    kstat_named_t offloadConnCqeRx;
    kstat_named_t offloadConnCqeRxErr;
    kstat_named_t enableConnWqeTx;
    kstat_named_t enableConnWqeTxErr;
    kstat_named_t enableConnCqeRx;
    kstat_named_t enableConnCqeRxErr;
    kstat_named_t disableConnWqeTx;
    kstat_named_t disableConnWqeTxErr;
    kstat_named_t disableConnCqeRx;
    kstat_named_t disableConnCqeRxErr;
    kstat_named_t destroyConnWqeTx;
    kstat_named_t destroyConnWqeTxErr;
    kstat_named_t destroyConnCqeRx;
    kstat_named_t destroyConnCqeRxErr;
    kstat_named_t destroyWqeTx;
    kstat_named_t destroyWqeTxErr;
    kstat_named_t destroyCqeRx;
    kstat_named_t destroyCqeRxErr;
    kstat_named_t compRequestCqeRx;
    kstat_named_t compRequestCqeRxErr;
    kstat_named_t statWqeTx;
    kstat_named_t statWqeTxErr;
    kstat_named_t statCqeRx;
    kstat_named_t statCqeRxErr;
} BnxeKstatFcoe;

#define BNXE_KSTAT_FCOE_SIZE (sizeof(BnxeKstatFcoe) / sizeof(kstat_named_t))

typedef struct _BnxeKstatDcbx
{
    kstat_named_t dcbx_sync;
    kstat_named_t dcbx_vers;
    kstat_named_t overwrite_settings;
    kstat_named_t prio_tag;
    kstat_named_t prio_tag_fcoe;
    kstat_named_t prio_tag_iscsi;
    kstat_named_t prio_tag_net;
    kstat_named_t pfc;
    kstat_named_t pfc_prio_0;
    kstat_named_t pfc_prio_1;
    kstat_named_t pfc_prio_2;
    kstat_named_t pfc_prio_3;
    kstat_named_t pfc_prio_4;
    kstat_named_t pfc_prio_5;
    kstat_named_t pfc_prio_6;
    kstat_named_t pfc_prio_7;
    kstat_named_t ets;
    kstat_named_t ets_prio_0_pg;
    kstat_named_t ets_prio_1_pg;
    kstat_named_t ets_prio_2_pg;
    kstat_named_t ets_prio_3_pg;
    kstat_named_t ets_prio_4_pg;
    kstat_named_t ets_prio_5_pg;
    kstat_named_t ets_prio_6_pg;
    kstat_named_t ets_prio_7_pg;
    kstat_named_t ets_pg_0_bw;
    kstat_named_t ets_pg_1_bw;
    kstat_named_t ets_pg_2_bw;
    kstat_named_t ets_pg_3_bw;
    kstat_named_t ets_pg_4_bw;
    kstat_named_t ets_pg_5_bw;
    kstat_named_t ets_pg_6_bw;
    kstat_named_t ets_pg_7_bw;
    kstat_named_t lldp;
    kstat_named_t lldp_tx_interval;
    kstat_named_t lldp_tx_fast_interval;
    kstat_named_t amib_apptlv_willing;
    kstat_named_t amib_apptlv_tx;
    kstat_named_t amib_apptlv_net_prio;
    kstat_named_t amib_apptlv_tbl_0_prio;
    kstat_named_t amib_apptlv_tbl_0_appid;
    kstat_named_t amib_apptlv_tbl_1_prio;
    kstat_named_t amib_apptlv_tbl_1_appid;
    kstat_named_t amib_apptlv_tbl_2_prio;
    kstat_named_t amib_apptlv_tbl_2_appid;
    kstat_named_t amib_apptlv_tbl_3_prio;
    kstat_named_t amib_apptlv_tbl_3_appid;
    kstat_named_t amib_pgtlv_willing;
    kstat_named_t amib_pgtlv_tx;
    kstat_named_t amib_pgtlv_tc_supported;
    kstat_named_t amib_pgtlv_ets;
    kstat_named_t amib_pgtlv_pg_0_bw;
    kstat_named_t amib_pgtlv_pg_1_bw;
    kstat_named_t amib_pgtlv_pg_2_bw;
    kstat_named_t amib_pgtlv_pg_3_bw;
    kstat_named_t amib_pgtlv_pg_4_bw;
    kstat_named_t amib_pgtlv_pg_5_bw;
    kstat_named_t amib_pgtlv_pg_6_bw;
    kstat_named_t amib_pgtlv_pg_7_bw;
    kstat_named_t amib_pgtlv_prio_0_map;
    kstat_named_t amib_pgtlv_prio_1_map;
    kstat_named_t amib_pgtlv_prio_2_map;
    kstat_named_t amib_pgtlv_prio_3_map;
    kstat_named_t amib_pgtlv_prio_4_map;
    kstat_named_t amib_pgtlv_prio_5_map;
    kstat_named_t amib_pgtlv_prio_6_map;
    kstat_named_t amib_pgtlv_prio_7_map;
    kstat_named_t amib_pfctlv_willing;
    kstat_named_t amib_pfctlv_tx;
    kstat_named_t amib_pfctlv_pfc;
    kstat_named_t amib_pfctlv_pfc_map;
    kstat_named_t rmib_apptlv_willing;
    kstat_named_t rmib_apptlv_tbl_0_prio;
    kstat_named_t rmib_apptlv_tbl_0_appid;
    kstat_named_t rmib_apptlv_tbl_1_prio;
    kstat_named_t rmib_apptlv_tbl_1_appid;
    kstat_named_t rmib_apptlv_tbl_2_prio;
    kstat_named_t rmib_apptlv_tbl_2_appid;
    kstat_named_t rmib_apptlv_tbl_3_prio;
    kstat_named_t rmib_apptlv_tbl_3_appid;
    kstat_named_t rmib_pgtlv_willing;
    kstat_named_t rmib_pgtlv_tc_supported;
    kstat_named_t rmib_pgtlv_pg_0_bw;
    kstat_named_t rmib_pgtlv_pg_1_bw;
    kstat_named_t rmib_pgtlv_pg_2_bw;
    kstat_named_t rmib_pgtlv_pg_3_bw;
    kstat_named_t rmib_pgtlv_pg_4_bw;
    kstat_named_t rmib_pgtlv_pg_5_bw;
    kstat_named_t rmib_pgtlv_pg_6_bw;
    kstat_named_t rmib_pgtlv_pg_7_bw;
    kstat_named_t rmib_pgtlv_prio_0_map;
    kstat_named_t rmib_pgtlv_prio_1_map;
    kstat_named_t rmib_pgtlv_prio_2_map;
    kstat_named_t rmib_pgtlv_prio_3_map;
    kstat_named_t rmib_pgtlv_prio_4_map;
    kstat_named_t rmib_pgtlv_prio_5_map;
    kstat_named_t rmib_pgtlv_prio_6_map;
    kstat_named_t rmib_pgtlv_prio_7_map;
    kstat_named_t rmib_pfctlv_willing;
    kstat_named_t rmib_pfctlv_pfc_map;
    kstat_named_t rmib_pfctlv_capable;
    kstat_named_t lmib_apptlv_tbl_0_prio;
    kstat_named_t lmib_apptlv_tbl_0_appid;
    kstat_named_t lmib_apptlv_tbl_1_prio;
    kstat_named_t lmib_apptlv_tbl_1_appid;
    kstat_named_t lmib_apptlv_tbl_2_prio;
    kstat_named_t lmib_apptlv_tbl_2_appid;
    kstat_named_t lmib_apptlv_tbl_3_prio;
    kstat_named_t lmib_apptlv_tbl_3_appid;
    kstat_named_t lmib_apptlv_mismatch;
    kstat_named_t lmib_pgtlv_ets;
    kstat_named_t lmib_pgtlv_tc_supported;
    kstat_named_t lmib_pgtlv_pg_0_bw;
    kstat_named_t lmib_pgtlv_pg_1_bw;
    kstat_named_t lmib_pgtlv_pg_2_bw;
    kstat_named_t lmib_pgtlv_pg_3_bw;
    kstat_named_t lmib_pgtlv_pg_4_bw;
    kstat_named_t lmib_pgtlv_pg_5_bw;
    kstat_named_t lmib_pgtlv_pg_6_bw;
    kstat_named_t lmib_pgtlv_pg_7_bw;
    kstat_named_t lmib_pgtlv_prio_0_map;
    kstat_named_t lmib_pgtlv_prio_1_map;
    kstat_named_t lmib_pgtlv_prio_2_map;
    kstat_named_t lmib_pgtlv_prio_3_map;
    kstat_named_t lmib_pgtlv_prio_4_map;
    kstat_named_t lmib_pgtlv_prio_5_map;
    kstat_named_t lmib_pgtlv_prio_6_map;
    kstat_named_t lmib_pgtlv_prio_7_map;
    kstat_named_t lmib_pfctlv_pfc;
    kstat_named_t lmib_pfctlv_pfc_map;
    kstat_named_t lmib_pfctlv_capable;
    kstat_named_t lmib_pfctlv_mismatch;
    kstat_named_t dcbx_frames_rx;
    kstat_named_t dcbx_frames_tx;
    kstat_named_t pfc_frames_rx;
    kstat_named_t pfc_frames_tx;
} BnxeKstatDcbx;

#define BNXE_KSTAT_DCBX_SIZE (sizeof(BnxeKstatDcbx) / sizeof(kstat_named_t))

typedef struct _BnxeKstatRxq
{
    kstat_named_t rxqBdTotal;
    kstat_named_t rxqBdLeft;
    kstat_named_t rxqBdPageCnt;
    kstat_named_t rxqBdsPerPage;
    kstat_named_t rxqBdSize;
    kstat_named_t rxqBdsSkipEop;
    kstat_named_t rxqBdProdIdx;
    kstat_named_t rxqBdConsIdx;
    kstat_named_t hwRxqConIdx;
    kstat_named_t sgeBdTotal;
    kstat_named_t sgeBdLeft;
    kstat_named_t sgeBdPageCnt;
    kstat_named_t sgeBdsPerPage;
    kstat_named_t sgeBdSize;
    kstat_named_t sgeBdsSkipEop;
    kstat_named_t sgeBdProdIdx;
    kstat_named_t sgeBdConsIdx;
    kstat_named_t rcqBdTotal;
    kstat_named_t rcqBdLeft;
    kstat_named_t rcqBdPageCnt;
    kstat_named_t rcqBdsPerPage;
    kstat_named_t rcqBdSize;
    kstat_named_t rcqBdsSkipEop;
    kstat_named_t rcqBdProdIdx;
    kstat_named_t rcqBdConsIdx;
    kstat_named_t hwRcqConIdx;
    kstat_named_t rxFreeDescs;
    kstat_named_t rxActiveDescs;
    kstat_named_t rxDoneDescs;
    kstat_named_t rxWaitingDescs;
    kstat_named_t rxCopied;
    kstat_named_t rxDiscards;
    kstat_named_t rxBufUpInStack;
    kstat_named_t rxLowWater;
    kstat_named_t inPollMode;
    kstat_named_t pollCnt;
    kstat_named_t intrDisableCnt;
    kstat_named_t intrEnableCnt;
    kstat_named_t genNumber;
} BnxeKstatRxq;

#define BNXE_KSTAT_RXQ_SIZE (sizeof(BnxeKstatRxq) / sizeof(kstat_named_t))

typedef struct _BnxeKstatTxq
{
    kstat_named_t txBdTotal;
    kstat_named_t txBdLeft;
    kstat_named_t txBdPageCnt;
    kstat_named_t txBdsPerPage;
    kstat_named_t txBdSize;
    kstat_named_t txBdsSkipEop;
    kstat_named_t hwTxqConIdx;
    kstat_named_t txPktIdx;
    kstat_named_t txBdProdIdx;
    kstat_named_t txBdConsIdx;
    kstat_named_t txSentPkts;
    kstat_named_t txFreeDesc;
    kstat_named_t txWaitingPkts;
    kstat_named_t txLowWater;
    kstat_named_t txFailed;
    kstat_named_t txDiscards;
    kstat_named_t txRecycle;
    kstat_named_t txCopied;
    kstat_named_t txBlocked;
    kstat_named_t txWait;
} BnxeKstatTxq;

#define BNXE_KSTAT_TXQ_SIZE (sizeof(BnxeKstatTxq) / sizeof(kstat_named_t))


static int BnxeKstatUpdate(kstat_t * kstats,
                           int       rw)
{
    BnxeKstat *   pStats = (BnxeKstat *)kstats->ks_data;
    um_device_t * pUM    = (um_device_t *)kstats->ks_private;
    lm_device_t * pLM    = (lm_device_t *)pUM;
    char buf[17]; /* 16 max for kstat string */

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    BNXE_LOCK_ENTER_STATS(pUM);

    snprintf(buf, sizeof(buf), "%p", (void *)pUM);
    strncpy(pStats->umdev_hi.value.c, &buf[0], 8);
    pStats->umdev_hi.value.c[8] = 0;
    strncpy(pStats->umdev_lo.value.c, &buf[8], 8);
    pStats->umdev_lo.value.c[8] = 0;

    strncpy(pStats->version.value.c,   pUM->version,   sizeof(pStats->version.value.c));
    strncpy(pStats->versionFW.value.c, pUM->versionFW, sizeof(pStats->versionFW.value.c));
    strncpy(pStats->versionBC.value.c, pUM->versionBC, sizeof(pStats->versionBC.value.c));

    strncpy(pStats->chipName.value.c, pUM->chipName, sizeof(pStats->chipName.value.c));
    strncpy(pStats->chipID.value.c,   pUM->chipID,   sizeof(pStats->chipID.value.c));

    strncpy(pStats->devBDF.value.c, pUM->bus_dev_func,  sizeof(pStats->devBDF.value.c));
    strncpy(pStats->devID.value.c,  pUM->vendor_device, sizeof(pStats->devID.value.c));

    strncpy(pStats->multiFunction.value.c,
            ((pUM->lm_dev.params.mf_mode == SINGLE_FUNCTION)     ? "Single"  :
             (pUM->lm_dev.params.mf_mode == MULTI_FUNCTION_SD)   ? "MF-SD"   :
             (pUM->lm_dev.params.mf_mode == MULTI_FUNCTION_SI)   ? "MF-SI"   :
             (pUM->lm_dev.params.mf_mode == MULTI_FUNCTION_AFEX) ? "MF-AFEX" :
                                                                   "Unknown"),
            sizeof(pStats->multiFunction.value.c));
    pStats->multiFunctionVnics.value.ui64 = IS_MULTI_VNIC(&pUM->lm_dev) ? pLM->params.vnics_per_port : 0;

    snprintf(pStats->macAddr.value.c, 16, "%02x%02x%02x%02x%02x%02x",
             pLM->params.mac_addr[0], pLM->params.mac_addr[1],
             pLM->params.mac_addr[2], pLM->params.mac_addr[3],
             pLM->params.mac_addr[4], pLM->params.mac_addr[5]);

    pStats->hwInitDone.value.ui64 = pUM->hwInitDone;

    snprintf(pStats->clientsHw.value.c, 16, BnxeClientsHw(pUM));
    snprintf(pStats->clientsDevi.value.c, 16, BnxeClientsDevi(pUM));
    snprintf(pStats->clientsBound.value.c, 16, BnxeClientsBound(pUM));

    pStats->txMsgPullUp.value.ui64 = pUM->txMsgPullUp;

    strncpy(pStats->intrAlloc.value.c, pUM->intrAlloc, sizeof(pStats->intrAlloc.value.c));
    pStats->intrFired.value.ui64 = pUM->intrFired;

    pStats->timerFired.value.ui64          = pLM->vars.stats.stats_collect.timer_wakeup;
    pStats->timerReply.value.ui64          = pLM->vars.stats.stats_collect.stats_fw.drv_counter;
    pStats->timerNoReplyTotal.value.ui64   = pLM->vars.stats.stats_collect.stats_fw.timer_wakeup_no_completion_total;
    pStats->timerNoReplyCurrent.value.ui64 = pLM->vars.stats.stats_collect.stats_fw.timer_wakeup_no_completion_current;
    pStats->timerDone.value.ui64           = pLM->vars.stats.stats_collect.stats_fw.b_completion_done;

    pStats->workQueueInstCnt.value.ui64      = s_list_entry_cnt(&pUM->workqs.instq.workQueue);
    pStats->workItemInstQueued.value.ui64    = pUM->workqs.instq.workItemQueued;
    pStats->workItemInstError.value.ui64     = pUM->workqs.instq.workItemError;
    pStats->workItemInstComplete.value.ui64  = pUM->workqs.instq.workItemComplete;
    pStats->workItemInstHighWater.value.ui64 = pUM->workqs.instq.highWater;

    pStats->workQueueDelayCnt.value.ui64      = s_list_entry_cnt(&pUM->workqs.delayq.workQueue);
    pStats->workItemDelayQueued.value.ui64    = pUM->workqs.delayq.workItemQueued;
    pStats->workItemDelayError.value.ui64     = pUM->workqs.delayq.workItemError;
    pStats->workItemDelayComplete.value.ui64  = pUM->workqs.delayq.workItemComplete;
    pStats->workItemDelayHighWater.value.ui64 = pUM->workqs.delayq.highWater;

    pStats->memAllocBlocks.value.ui64 = d_list_entry_cnt(&pUM->memBlockList);
    pStats->memAllocDMAs.value.ui64   = d_list_entry_cnt(&pUM->memDmaList);
    pStats->memAllocBARs.value.ui64   = d_list_entry_cnt(&pUM->memRegionList);

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


static int BnxeKstatLinkUpdate(kstat_t * kstats,
                               int       rw)
{
    BnxeKstatLink * pStats = (BnxeKstatLink *)kstats->ks_data;
    um_device_t *   pUM    = (um_device_t *)kstats->ks_private;
    lm_device_t *   pLM    = (lm_device_t *)pUM;

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    BNXE_LOCK_ENTER_STATS(pUM);

    snprintf(pStats->clients.value.c, 16, BnxeClientsBound(pUM));
    pStats->uptime.value.ui64  = (pUM->props.link_speed) ?
                                     (ddi_get_time() - pUM->props.uptime) : 0;
    pStats->mtuL2.value.ui64   = pUM->lm_dev.params.mtu[LM_CLI_IDX_NDIS];
    pStats->mtuFCOE.value.ui64 = (BNXE_FCOE(pUM)) ?
                                     pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE] :
                                     0;
    pStats->speed.value.ui64   = pUM->props.link_speed;
    pStats->link.value.ui64    = (!pUM->props.link_speed) ? 0 : 1;
    pStats->duplex.value.ui64  = pUM->props.link_duplex;
    pStats->pauseRx.value.ui64 = pUM->props.link_rxpause;
    pStats->pauseTx.value.ui64 = pUM->props.link_txpause;

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


static int BnxeKstatIntrUpdate(kstat_t * kstats,
                               int       rw)
{
    BnxeKstatIntr * pStats = (BnxeKstatIntr *)kstats->ks_data;
    um_device_t *   pUM    = (um_device_t *)kstats->ks_private;
    lm_device_t *   pLM    = (lm_device_t *)pUM;

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    BNXE_LOCK_ENTER_STATS(pUM);

    strncpy(pStats->intrAlloc.value.c, pUM->intrAlloc, sizeof(pStats->intrAlloc.value.c));
    pStats->intrFired.value.ui64      = pUM->intrFired;
    pStats->intrWrongState.value.ui64 = pLM->vars.dbg_intr_in_wrong_state;
    pStats->intrInDisabled.value.ui64 = pLM->vars.dbg_intr_in_disabled;
    pStats->intrZeroStatus.value.ui64 = pLM->vars.dbg_intr_zero_status;
    pStats->sb_00.value.ui64          = pUM->intrSbCnt[0];
    pStats->sb_01.value.ui64          = pUM->intrSbCnt[1];
    pStats->sb_02.value.ui64          = pUM->intrSbCnt[2];
    pStats->sb_03.value.ui64          = pUM->intrSbCnt[3];
    pStats->sb_04.value.ui64          = pUM->intrSbCnt[4];
    pStats->sb_05.value.ui64          = pUM->intrSbCnt[5];
    pStats->sb_06.value.ui64          = pUM->intrSbCnt[6];
    pStats->sb_07.value.ui64          = pUM->intrSbCnt[7];
    pStats->sb_08.value.ui64          = pUM->intrSbCnt[8];
    pStats->sb_09.value.ui64          = pUM->intrSbCnt[9];
    pStats->sb_10.value.ui64          = pUM->intrSbCnt[10];
    pStats->sb_11.value.ui64          = pUM->intrSbCnt[11];
    pStats->sb_12.value.ui64          = pUM->intrSbCnt[12];
    pStats->sb_13.value.ui64          = pUM->intrSbCnt[13];
    pStats->sb_14.value.ui64          = pUM->intrSbCnt[14];
    pStats->sb_15.value.ui64          = pUM->intrSbCnt[15];
    pStats->sb_16.value.ui64          = pUM->intrSbCnt[16];
    pStats->sb_nc_00.value.ui64       = pUM->intrSbNoChangeCnt[0];
    pStats->sb_nc_01.value.ui64       = pUM->intrSbNoChangeCnt[1];
    pStats->sb_nc_02.value.ui64       = pUM->intrSbNoChangeCnt[2];
    pStats->sb_nc_03.value.ui64       = pUM->intrSbNoChangeCnt[3];
    pStats->sb_nc_04.value.ui64       = pUM->intrSbNoChangeCnt[4];
    pStats->sb_nc_05.value.ui64       = pUM->intrSbNoChangeCnt[5];
    pStats->sb_nc_06.value.ui64       = pUM->intrSbNoChangeCnt[6];
    pStats->sb_nc_07.value.ui64       = pUM->intrSbNoChangeCnt[7];
    pStats->sb_nc_08.value.ui64       = pUM->intrSbNoChangeCnt[8];
    pStats->sb_nc_09.value.ui64       = pUM->intrSbNoChangeCnt[9];
    pStats->sb_nc_10.value.ui64       = pUM->intrSbNoChangeCnt[10];
    pStats->sb_nc_11.value.ui64       = pUM->intrSbNoChangeCnt[11];
    pStats->sb_nc_12.value.ui64       = pUM->intrSbNoChangeCnt[12];
    pStats->sb_nc_13.value.ui64       = pUM->intrSbNoChangeCnt[13];
    pStats->sb_nc_14.value.ui64       = pUM->intrSbNoChangeCnt[14];
    pStats->sb_nc_15.value.ui64       = pUM->intrSbNoChangeCnt[15];
    pStats->sb_nc_16.value.ui64       = pUM->intrSbNoChangeCnt[16];
    pStats->sb_poll_00.value.ui64     = pUM->intrSbPollCnt[0];
    pStats->sb_poll_01.value.ui64     = pUM->intrSbPollCnt[1];
    pStats->sb_poll_02.value.ui64     = pUM->intrSbPollCnt[2];
    pStats->sb_poll_03.value.ui64     = pUM->intrSbPollCnt[3];
    pStats->sb_poll_04.value.ui64     = pUM->intrSbPollCnt[4];
    pStats->sb_poll_05.value.ui64     = pUM->intrSbPollCnt[5];
    pStats->sb_poll_06.value.ui64     = pUM->intrSbPollCnt[6];
    pStats->sb_poll_07.value.ui64     = pUM->intrSbPollCnt[7];
    pStats->sb_poll_08.value.ui64     = pUM->intrSbPollCnt[8];
    pStats->sb_poll_09.value.ui64     = pUM->intrSbPollCnt[9];
    pStats->sb_poll_10.value.ui64     = pUM->intrSbPollCnt[10];
    pStats->sb_poll_11.value.ui64     = pUM->intrSbPollCnt[11];
    pStats->sb_poll_12.value.ui64     = pUM->intrSbPollCnt[12];
    pStats->sb_poll_13.value.ui64     = pUM->intrSbPollCnt[13];
    pStats->sb_poll_14.value.ui64     = pUM->intrSbPollCnt[14];
    pStats->sb_poll_15.value.ui64     = pUM->intrSbPollCnt[15];
    pStats->sb_poll_16.value.ui64     = pUM->intrSbPollCnt[16];
    pStats->sb_poll_nc_00.value.ui64  = pUM->intrSbPollNoChangeCnt[0];
    pStats->sb_poll_nc_01.value.ui64  = pUM->intrSbPollNoChangeCnt[1];
    pStats->sb_poll_nc_02.value.ui64  = pUM->intrSbPollNoChangeCnt[2];
    pStats->sb_poll_nc_03.value.ui64  = pUM->intrSbPollNoChangeCnt[3];
    pStats->sb_poll_nc_04.value.ui64  = pUM->intrSbPollNoChangeCnt[4];
    pStats->sb_poll_nc_05.value.ui64  = pUM->intrSbPollNoChangeCnt[5];
    pStats->sb_poll_nc_06.value.ui64  = pUM->intrSbPollNoChangeCnt[6];
    pStats->sb_poll_nc_07.value.ui64  = pUM->intrSbPollNoChangeCnt[7];
    pStats->sb_poll_nc_08.value.ui64  = pUM->intrSbPollNoChangeCnt[8];
    pStats->sb_poll_nc_09.value.ui64  = pUM->intrSbPollNoChangeCnt[9];
    pStats->sb_poll_nc_10.value.ui64  = pUM->intrSbPollNoChangeCnt[10];
    pStats->sb_poll_nc_11.value.ui64  = pUM->intrSbPollNoChangeCnt[11];
    pStats->sb_poll_nc_12.value.ui64  = pUM->intrSbPollNoChangeCnt[12];
    pStats->sb_poll_nc_13.value.ui64  = pUM->intrSbPollNoChangeCnt[13];
    pStats->sb_poll_nc_14.value.ui64  = pUM->intrSbPollNoChangeCnt[14];
    pStats->sb_poll_nc_15.value.ui64  = pUM->intrSbPollNoChangeCnt[15];
    pStats->sb_poll_nc_16.value.ui64  = pUM->intrSbPollNoChangeCnt[16];

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


static int BnxeKstatL2ChipUpdate(kstat_t * kstats,
                                 int       rw)
{
    BnxeKstatL2Chip * pStats = (BnxeKstatL2Chip *)kstats->ks_data;
    um_device_t *     pUM    = (um_device_t *)kstats->ks_private;
    lm_device_t *     pLM    = (lm_device_t *)pUM;
    b10_l2_chip_statistics_t b10_l2_stats;

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    BNXE_LOCK_ENTER_STATS(pUM);

    lm_stats_get_l2_chip_stats(pLM, &b10_l2_stats,
                               L2_CHIP_STATISTICS_VER_NUM_1);

    pStats->IfHCInOctets.value.ui64                       = b10_l2_stats.IfHCInOctets;
    pStats->IfHCInBadOctets.value.ui64                    = b10_l2_stats.IfHCInBadOctets;
    pStats->IfHCOutOctets.value.ui64                      = b10_l2_stats.IfHCOutOctets;
    pStats->IfHCOutBadOctets.value.ui64                   = b10_l2_stats.IfHCOutBadOctets;
    pStats->IfHCOutPkts.value.ui64                        = b10_l2_stats.IfHCOutPkts;
    pStats->IfHCInPkts.value.ui64                         = b10_l2_stats.IfHCInPkts;
    pStats->IfHCInUcastPkts.value.ui64                    = b10_l2_stats.IfHCInUcastPkts;
    pStats->IfHCInMulticastPkts.value.ui64                = b10_l2_stats.IfHCInMulticastPkts;
    pStats->IfHCInBroadcastPkts.value.ui64                = b10_l2_stats.IfHCInBroadcastPkts;
    pStats->IfHCOutUcastPkts.value.ui64                   = b10_l2_stats.IfHCOutUcastPkts;
    pStats->IfHCOutMulticastPkts.value.ui64               = b10_l2_stats.IfHCOutMulticastPkts;
    pStats->IfHCOutBroadcastPkts.value.ui64               = b10_l2_stats.IfHCOutBroadcastPkts;
    pStats->IfHCInUcastOctets.value.ui64                  = b10_l2_stats.IfHCInUcastOctets;
    pStats->IfHCInMulticastOctets.value.ui64              = b10_l2_stats.IfHCInMulticastOctets;
    pStats->IfHCInBroadcastOctets.value.ui64              = b10_l2_stats.IfHCInBroadcastOctets;
    pStats->IfHCOutUcastOctets.value.ui64                 = b10_l2_stats.IfHCOutUcastOctets;
    pStats->IfHCOutMulticastOctets.value.ui64             = b10_l2_stats.IfHCOutMulticastOctets;
    pStats->IfHCOutBroadcastOctets.value.ui64             = b10_l2_stats.IfHCOutBroadcastOctets;
    pStats->IfHCOutDiscards.value.ui64                    = b10_l2_stats.IfHCOutDiscards;
    pStats->IfHCInFalseCarrierErrors.value.ui64           = b10_l2_stats.IfHCInFalseCarrierErrors;
    pStats->Dot3StatsInternalMacTransmitErrors.value.ui64 = b10_l2_stats.Dot3StatsInternalMacTransmitErrors;
    pStats->Dot3StatsCarrierSenseErrors.value.ui64        = b10_l2_stats.Dot3StatsCarrierSenseErrors;
    pStats->Dot3StatsFCSErrors.value.ui64                 = b10_l2_stats.Dot3StatsFCSErrors;
    pStats->Dot3StatsAlignmentErrors.value.ui64           = b10_l2_stats.Dot3StatsAlignmentErrors;
    pStats->Dot3StatsSingleCollisionFrames.value.ui64     = b10_l2_stats.Dot3StatsSingleCollisionFrames;
    pStats->Dot3StatsMultipleCollisionFrames.value.ui64   = b10_l2_stats.Dot3StatsMultipleCollisionFrames;
    pStats->Dot3StatsDeferredTransmissions.value.ui64     = b10_l2_stats.Dot3StatsDeferredTransmissions;
    pStats->Dot3StatsExcessiveCollisions.value.ui64       = b10_l2_stats.Dot3StatsExcessiveCollisions;
    pStats->Dot3StatsLateCollisions.value.ui64            = b10_l2_stats.Dot3StatsLateCollisions;
    pStats->EtherStatsCollisions.value.ui64               = b10_l2_stats.EtherStatsCollisions;
    pStats->EtherStatsFragments.value.ui64                = b10_l2_stats.EtherStatsFragments;
    pStats->EtherStatsJabbers.value.ui64                  = b10_l2_stats.EtherStatsJabbers;
    pStats->EtherStatsUndersizePkts.value.ui64            = b10_l2_stats.EtherStatsUndersizePkts;
    pStats->EtherStatsOverrsizePkts.value.ui64            = b10_l2_stats.EtherStatsOverrsizePkts;
    pStats->EtherStatsTx64Octets.value.ui64               = b10_l2_stats.EtherStatsPktsTx64Octets;
    pStats->EtherStatsTx65to127Octets.value.ui64          = b10_l2_stats.EtherStatsPktsTx65Octetsto127Octets;
    pStats->EtherStatsTx128to255Octets.value.ui64         = b10_l2_stats.EtherStatsPktsTx128Octetsto255Octets;
    pStats->EtherStatsTx256to511Octets.value.ui64         = b10_l2_stats.EtherStatsPktsTx256Octetsto511Octets;
    pStats->EtherStatsTx512to1023Octets.value.ui64        = b10_l2_stats.EtherStatsPktsTx512Octetsto1023Octets;
    pStats->EtherStatsTx1024to1522Octets.value.ui64       = b10_l2_stats.EtherStatsPktsTx1024Octetsto1522Octets;
    pStats->EtherStatsTxOver1522Octets.value.ui64         = b10_l2_stats.EtherStatsPktsTxOver1522Octets;
    pStats->XonPauseFramesReceived.value.ui64             = b10_l2_stats.XonPauseFramesReceived;
    pStats->XoffPauseFramesReceived.value.ui64            = b10_l2_stats.XoffPauseFramesReceived;
    pStats->OutXonSent.value.ui64                         = b10_l2_stats.OutXonSent;
    pStats->OutXoffSent.value.ui64                        = b10_l2_stats.OutXoffSent;
    pStats->FlowControlDone.value.ui64                    = b10_l2_stats.FlowControlDone;
    pStats->MacControlFramesReceived.value.ui64           = b10_l2_stats.MacControlFramesReceived;
    pStats->XoffStateEntered.value.ui64                   = b10_l2_stats.XoffStateEntered;
    pStats->IfInFramesL2FilterDiscards.value.ui64         = b10_l2_stats.IfInFramesL2FilterDiscards;
    pStats->IfInTTL0Discards.value.ui64                   = b10_l2_stats.IfInTTL0Discards;
    pStats->IfInxxOverflowDiscards.value.ui64             = b10_l2_stats.IfInxxOverflowDiscards;
    pStats->IfInMBUFDiscards.value.ui64                   = b10_l2_stats.IfInMBUFDiscards;
    pStats->IfInErrors.value.ui64                         = b10_l2_stats.IfInErrors;
    pStats->IfInErrorsOctets.value.ui64                   = b10_l2_stats.IfInErrorsOctets;
    pStats->IfInNoBrbBuffer.value.ui64                    = b10_l2_stats.IfInNoBrbBuffer;
    pStats->NigBrbPacket.value.ui64                       = b10_l2_stats.Nig_brb_packet;
    pStats->NigBrbTruncate.value.ui64                     = b10_l2_stats.Nig_brb_truncate;
    pStats->NigFlowCtrlDiscard.value.ui64                 = b10_l2_stats.Nig_flow_ctrl_discard;
    pStats->NigFlowCtrlOctets.value.ui64                  = b10_l2_stats.Nig_flow_ctrl_octets;
    pStats->NigFlowCtrlPacket.value.ui64                  = b10_l2_stats.Nig_flow_ctrl_packet;
    pStats->NigMngDiscard.value.ui64                      = b10_l2_stats.Nig_mng_discard;
    pStats->NigMngOctetInp.value.ui64                     = b10_l2_stats.Nig_mng_octet_inp;
    pStats->NigMngOctetOut.value.ui64                     = b10_l2_stats.Nig_mng_octet_out;
    pStats->NigMngPacketInp.value.ui64                    = b10_l2_stats.Nig_mng_packet_inp;
    pStats->NigMngPacketOut.value.ui64                    = b10_l2_stats.Nig_mng_packet_out;
    pStats->NigPbfOctets.value.ui64                       = b10_l2_stats.Nig_pbf_octets;
    pStats->NigPbfPacket.value.ui64                       = b10_l2_stats.Nig_pbf_packet;
    pStats->NigSafcInp.value.ui64                         = b10_l2_stats.Nig_safc_inp;

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


static int BnxeKstatL2DriverUpdate(kstat_t * kstats,
                                   int       rw)
{
    BnxeKstatL2Driver * pStats = (BnxeKstatL2Driver *)kstats->ks_data;
    um_device_t *       pUM    = (um_device_t *)kstats->ks_private;
    lm_device_t *       pLM    = (lm_device_t *)pUM;
    b10_l2_driver_statistics_t b10_l2_stats;

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    BNXE_LOCK_ENTER_STATS(pUM);

    lm_stats_get_l2_driver_stats(pLM, &b10_l2_stats);

    pStats->RxIPv4FragCount.value.ui64    = b10_l2_stats.RxIPv4FragCount;
    pStats->RxIpCsErrorCount.value.ui64   = b10_l2_stats.RxIpCsErrorCount;
    pStats->RxTcpCsErrorCount.value.ui64  = b10_l2_stats.RxTcpCsErrorCount;
    pStats->RxLlcSnapCount.value.ui64     = b10_l2_stats.RxLlcSnapCount;
    pStats->RxPhyErrorCount.value.ui64    = b10_l2_stats.RxPhyErrorCount;
    pStats->RxIpv6ExtCount.value.ui64     = b10_l2_stats.RxIpv6ExtCount;
    pStats->TxNoL2Bd.value.ui64           = b10_l2_stats.TxNoL2Bd;
    pStats->TxNoSqWqe.value.ui64          = b10_l2_stats.TxNoSqWqe;
    pStats->TxL2AssemblyBufUse.value.ui64 = b10_l2_stats.TxL2AssemblyBufUse;

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


static int BnxeKstatL2StatsUpdate(kstat_t * kstats,
                                  int       rw)
{
    BnxeKstatEthStats * pStats = (BnxeKstatEthStats *)kstats->ks_data;
    um_device_t *       pUM    = (um_device_t *)kstats->ks_private;
    lm_device_t *       pLM    = (lm_device_t *)pUM;

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    BNXE_LOCK_ENTER_STATS(pUM);

    lm_get_stats(pLM, LM_STATS_FRAMES_XMITTED_OK,         (u64_t *)&pStats->txFramesOk.value.ui64);
    lm_get_stats(pLM, LM_STATS_FRAMES_RECEIVED_OK,        (u64_t *)&pStats->rxFramesOk.value.ui64);
    lm_get_stats(pLM, LM_STATS_ERRORED_TRANSMIT_CNT,      (u64_t *)&pStats->txErr.value.ui64);
    lm_get_stats(pLM, LM_STATS_ERRORED_RECEIVE_CNT,       (u64_t *)&pStats->rxErr.value.ui64);
    lm_get_stats(pLM, LM_STATS_RCV_CRC_ERROR,             (u64_t *)&pStats->rxCrcErr.value.ui64);
    lm_get_stats(pLM, LM_STATS_ALIGNMENT_ERROR,           (u64_t *)&pStats->alignErr.value.ui64);
    lm_get_stats(pLM, LM_STATS_SINGLE_COLLISION_FRAMES,   (u64_t *)&pStats->collisionsSingle.value.ui64);
    lm_get_stats(pLM, LM_STATS_MULTIPLE_COLLISION_FRAMES, (u64_t *)&pStats->collisionsMultiple.value.ui64);
    lm_get_stats(pLM, LM_STATS_FRAMES_DEFERRED,           (u64_t *)&pStats->framesDeferred.value.ui64);
    lm_get_stats(pLM, LM_STATS_MAX_COLLISIONS,            (u64_t *)&pStats->collisonsMax.value.ui64);
    lm_get_stats(pLM, LM_STATS_RCV_OVERRUN,               (u64_t *)&pStats->rxOverrun.value.ui64);
    lm_get_stats(pLM, LM_STATS_XMIT_UNDERRUN,             (u64_t *)&pStats->txOverrun.value.ui64);
    lm_get_stats(pLM, LM_STATS_UNICAST_FRAMES_XMIT,       (u64_t *)&pStats->txFramesUnicast.value.ui64);
    lm_get_stats(pLM, LM_STATS_MULTICAST_FRAMES_XMIT,     (u64_t *)&pStats->txFramesMulticast.value.ui64);
    lm_get_stats(pLM, LM_STATS_BROADCAST_FRAMES_XMIT,     (u64_t *)&pStats->txFramesBroadcast.value.ui64);
    lm_get_stats(pLM, LM_STATS_UNICAST_FRAMES_RCV,        (u64_t *)&pStats->rxFramesUnicast.value.ui64);
    lm_get_stats(pLM, LM_STATS_MULTICAST_FRAMES_RCV,      (u64_t *)&pStats->rxFramesMulticast.value.ui64);
    lm_get_stats(pLM, LM_STATS_BROADCAST_FRAMES_RCV,      (u64_t *)&pStats->rxFramesBroadcast.value.ui64);
    lm_get_stats(pLM, LM_STATS_RCV_NO_BUFFER_DROP,        (u64_t *)&pStats->rxNoBufferDrop.value.ui64);
    lm_get_stats(pLM, LM_STATS_BYTES_RCV,                 (u64_t *)&pStats->rxBytes.value.ui64);
    lm_get_stats(pLM, LM_STATS_BYTES_XMIT,                (u64_t *)&pStats->txBytes.value.ui64);
    lm_get_stats(pLM, LM_STATS_IP4_OFFLOAD,               (u64_t *)&pStats->offloadIP4.value.ui64);
    lm_get_stats(pLM, LM_STATS_TCP_OFFLOAD,               (u64_t *)&pStats->offloadTCP.value.ui64);
    lm_get_stats(pLM, LM_STATS_IF_IN_DISCARDS,            (u64_t *)&pStats->ifInDiscards.value.ui64);
    lm_get_stats(pLM, LM_STATS_IF_IN_ERRORS,              (u64_t *)&pStats->ifInErrors.value.ui64);
    lm_get_stats(pLM, LM_STATS_IF_OUT_ERRORS,             (u64_t *)&pStats->ifOutErrors.value.ui64);
    lm_get_stats(pLM, LM_STATS_IP6_OFFLOAD,               (u64_t *)&pStats->offloadIP6.value.ui64);
    lm_get_stats(pLM, LM_STATS_TCP6_OFFLOAD,              (u64_t *)&pStats->offloadTCP6.value.ui64);
    lm_get_stats(pLM, LM_STATS_XMIT_DISCARDS,             (u64_t *)&pStats->txDiscards.value.ui64);
    lm_get_stats(pLM, LM_STATS_DIRECTED_BYTES_RCV,        (u64_t *)&pStats->rxBytesUnicast.value.ui64);
    lm_get_stats(pLM, LM_STATS_MULTICAST_BYTES_RCV,       (u64_t *)&pStats->rxBytesMulticast.value.ui64);
    lm_get_stats(pLM, LM_STATS_BROADCAST_BYTES_RCV,       (u64_t *)&pStats->rxBytesBroadcast.value.ui64);
    lm_get_stats(pLM, LM_STATS_DIRECTED_BYTES_XMIT,       (u64_t *)&pStats->txBytesUnicast.value.ui64);
    lm_get_stats(pLM, LM_STATS_MULTICAST_BYTES_XMIT,      (u64_t *)&pStats->txBytesMulticast.value.ui64);
    lm_get_stats(pLM, LM_STATS_BROADCAST_BYTES_XMIT,      (u64_t *)&pStats->txBytesBroadcast.value.ui64);

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


static int BnxeKstatFcoeUpdate(kstat_t * kstats,
                               int       rw)
{
    BnxeKstatFcoe * pStats = (BnxeKstatFcoe *)kstats->ks_data;
    um_device_t * pUM      = (um_device_t *)kstats->ks_private;
    lm_device_t * pLM      = (lm_device_t *)pUM;
    char buf[17]; /* 16 max for kstat string */

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    BNXE_LOCK_ENTER_STATS(pUM);

    if (pUM->fcoe.pDev)
    {
        snprintf(buf, sizeof(buf), "%p", (void *)pUM->fcoe.pDev);
        strncpy(pStats->pdev_hi.value.c, &buf[0], 8);
        pStats->pdev_hi.value.c[8] = 0;
        strncpy(pStats->pdev_lo.value.c, &buf[8], 8);
        pStats->pdev_lo.value.c[8] = 0;

        snprintf(pStats->instance.value.c, 16, "bnxef%d",
                 ddi_get_instance(pUM->fcoe.pDev));

        if ((pUM->fcoe.wwn.fcp_pwwn[0] == 0) &&
            (pUM->fcoe.wwn.fcp_pwwn[1] == 0) &&
            (pUM->fcoe.wwn.fcp_pwwn[2] == 0) &&
            (pUM->fcoe.wwn.fcp_pwwn[3] == 0) &&
            (pUM->fcoe.wwn.fcp_pwwn[4] == 0) &&
            (pUM->fcoe.wwn.fcp_pwwn[5] == 0) &&
            (pUM->fcoe.wwn.fcp_pwwn[6] == 0) &&
            (pUM->fcoe.wwn.fcp_pwwn[7] == 0))
        {
            snprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x%02x%02x",
                     0x20, 0x00,
                     pLM->hw_info.fcoe_mac_addr[0],
                     pLM->hw_info.fcoe_mac_addr[1],
                     pLM->hw_info.fcoe_mac_addr[2],
                     pLM->hw_info.fcoe_mac_addr[3],
                     pLM->hw_info.fcoe_mac_addr[4],
                     pLM->hw_info.fcoe_mac_addr[5]);
        }
        else
        {
            snprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x%02x%02x",
                     pUM->fcoe.wwn.fcp_pwwn[0],
                     pUM->fcoe.wwn.fcp_pwwn[1],
                     pUM->fcoe.wwn.fcp_pwwn[2],
                     pUM->fcoe.wwn.fcp_pwwn[3],
                     pUM->fcoe.wwn.fcp_pwwn[4],
                     pUM->fcoe.wwn.fcp_pwwn[5],
                     pUM->fcoe.wwn.fcp_pwwn[7],
                     pUM->fcoe.wwn.fcp_pwwn[7]);
        }
        strncpy(pStats->pwwn_hi.value.c, &buf[0], 8);
        pStats->pwwn_hi.value.c[8] = 0;
        strncpy(pStats->pwwn_lo.value.c, &buf[8], 8);
        pStats->pwwn_lo.value.c[8] = 0;
    }
    else
    {
        strncpy(pStats->pdev_hi.value.c,  "none", sizeof(pStats->pdev_hi.value.c));
        strncpy(pStats->pdev_lo.value.c,  "none", sizeof(pStats->pdev_lo.value.c));
        strncpy(pStats->instance.value.c, "none", sizeof(pStats->instance.value.c));
        strncpy(pStats->pwwn_hi.value.c,  "none", sizeof(pStats->pwwn_hi.value.c));
        strncpy(pStats->pwwn_lo.value.c,  "none", sizeof(pStats->pwwn_lo.value.c));
    }

    snprintf(pStats->macAddr.value.c, 16, "%02x%02x%02x%02x%02x%02x",
             pLM->hw_info.fcoe_mac_addr[0], pLM->hw_info.fcoe_mac_addr[1],
             pLM->hw_info.fcoe_mac_addr[2], pLM->hw_info.fcoe_mac_addr[3],
             pLM->hw_info.fcoe_mac_addr[4], pLM->hw_info.fcoe_mac_addr[5]);

    pStats->mtu.value.ui64                 = pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE];
    pStats->initWqeTx.value.ui64           = pUM->fcoe.stats.initWqeTx;
    pStats->initWqeTxErr.value.ui64        = pUM->fcoe.stats.initWqeTxErr;
    pStats->initCqeRx.value.ui64           = pUM->fcoe.stats.initCqeRx;
    pStats->initCqeRxErr.value.ui64        = pUM->fcoe.stats.initCqeRxErr;
    pStats->offloadConnWqeTx.value.ui64    = pUM->fcoe.stats.offloadConnWqeTx;
    pStats->offloadConnWqeTxErr.value.ui64 = pUM->fcoe.stats.offloadConnWqeTxErr;
    pStats->offloadConnCqeRx.value.ui64    = pUM->fcoe.stats.offloadConnCqeRx;
    pStats->offloadConnCqeRxErr.value.ui64 = pUM->fcoe.stats.offloadConnCqeRxErr;
    pStats->enableConnWqeTx.value.ui64     = pUM->fcoe.stats.enableConnWqeTx;
    pStats->enableConnWqeTxErr.value.ui64  = pUM->fcoe.stats.enableConnWqeTxErr;
    pStats->enableConnCqeRx.value.ui64     = pUM->fcoe.stats.enableConnCqeRx;
    pStats->enableConnCqeRxErr.value.ui64  = pUM->fcoe.stats.enableConnCqeRxErr;
    pStats->disableConnWqeTx.value.ui64    = pUM->fcoe.stats.disableConnWqeTx;
    pStats->disableConnWqeTxErr.value.ui64 = pUM->fcoe.stats.disableConnWqeTxErr;
    pStats->disableConnCqeRx.value.ui64    = pUM->fcoe.stats.disableConnCqeRx;
    pStats->disableConnCqeRxErr.value.ui64 = pUM->fcoe.stats.disableConnCqeRxErr;
    pStats->destroyConnWqeTx.value.ui64    = pUM->fcoe.stats.destroyConnWqeTx;
    pStats->destroyConnWqeTxErr.value.ui64 = pUM->fcoe.stats.destroyConnWqeTxErr;
    pStats->destroyConnCqeRx.value.ui64    = pUM->fcoe.stats.destroyConnCqeRx;
    pStats->destroyConnCqeRxErr.value.ui64 = pUM->fcoe.stats.destroyConnCqeRxErr;
    pStats->destroyWqeTx.value.ui64        = pUM->fcoe.stats.destroyWqeTx;
    pStats->destroyWqeTxErr.value.ui64     = pUM->fcoe.stats.destroyWqeTxErr;
    pStats->destroyCqeRx.value.ui64        = pUM->fcoe.stats.destroyCqeRx;
    pStats->destroyCqeRxErr.value.ui64     = pUM->fcoe.stats.destroyCqeRxErr;
    pStats->compRequestCqeRx.value.ui64    = pUM->fcoe.stats.compRequestCqeRx;
    pStats->compRequestCqeRxErr.value.ui64 = pUM->fcoe.stats.compRequestCqeRxErr;
    pStats->statWqeTx.value.ui64           = pUM->fcoe.stats.statWqeTx;
    pStats->statWqeTxErr.value.ui64        = pUM->fcoe.stats.statWqeTxErr;
    pStats->statCqeRx.value.ui64           = pUM->fcoe.stats.statCqeRx;
    pStats->statCqeRxErr.value.ui64        = pUM->fcoe.stats.statCqeRxErr;

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


static int count_trailing_zeros(int number)
{
    int x, y, z;

    x = y = z = 0;

    for (y = 7; y >= 0; y--)
    {
        x = number / (1 << y);
        number = number - x * (1 << y);
        z++;

        if (x == 1)
        {
            z = 0;
        }
    }

    /* Add fix for all zero value */
    if (z == 8)
    {
        z = 0;
    }

    return z;
}


static int BnxeKstatDcbxUpdate(kstat_t * kstats,
                               int       rw)
{
    BnxeKstatDcbx * pStats = (BnxeKstatDcbx *)kstats->ks_data;
    um_device_t * pUM      = (um_device_t *)kstats->ks_private;
    lm_device_t * pLM      = (lm_device_t *)pUM;
    b10_lldp_params_get_t lldp_params;
    b10_dcbx_params_get_t dcbx_params;
    int fcoe_priority = -1;
    int iscsi_priority = -1;
    admin_priority_app_table_t * app_table;
    char buf[17]; /* 16 max for kstat string */
    int i;

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    lm_dcbx_lldp_read_params(pLM, &lldp_params);
    lm_dcbx_read_params(pLM, &dcbx_params);

    BNXE_LOCK_ENTER_STATS(pUM);

    snprintf(pStats->dcbx_sync.value.c, 16, "%s",
             (!dcbx_params.config_dcbx_params.dcb_enable) ? "disabled" :
             (dcbx_params.dcb_current_oper_state_bitmap &
              DCBX_CURRENT_STATE_IS_SYNC) ? "IN SYNC" : "OUT OF SYNC");

    snprintf(pStats->dcbx_vers.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.admin_dcbx_version) ?
                 "IEEE" : "CEE");

    snprintf(pStats->overwrite_settings.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.overwrite_settings) ?
                 "yes" : "no");

    if (dcbx_params.dcb_current_oper_state_bitmap &
        PRIORITY_TAGGING_IS_CURRENTLY_OPERATIONAL)
    {
        snprintf(pStats->prio_tag.value.c, 16, "operational");

        app_table = dcbx_params.local_priority_app_table;

        for (i = 0; i <= 3; i++)
        {
            if (app_table[i].valid)
            {
                if ((app_table[i].traffic_type == TRAFFIC_TYPE_ETH) &&
                    (app_table[i].app_id == 0x8906))
                {
                    fcoe_priority = count_trailing_zeros(app_table[i].priority);
                }

                if ((app_table[i].traffic_type != TRAFFIC_TYPE_ETH) &&
                    (app_table[i].app_id == 3260))
                {
                    iscsi_priority = count_trailing_zeros(app_table[i].priority);
                }
            }
        }

        snprintf(pStats->prio_tag_fcoe.value.c,  16, "%d", fcoe_priority);
        snprintf(pStats->prio_tag_iscsi.value.c, 16, "%d", iscsi_priority);
        snprintf(pStats->prio_tag_net.value.c,   16, "%d",
                 dcbx_params.config_dcbx_params.admin_default_priority);
    }
    else
    {
        snprintf(pStats->prio_tag.value.c, 16, "not operational");

        snprintf(pStats->prio_tag_fcoe.value.c,  16, "-");
        snprintf(pStats->prio_tag_iscsi.value.c, 16, "-");
        snprintf(pStats->prio_tag_net.value.c,   16, "-");
    }

    if (dcbx_params.dcb_current_oper_state_bitmap &
        PFC_IS_CURRENTLY_OPERATIONAL)
    {
        snprintf(pStats->pfc.value.c, 16, "operational");

#define GET_PFC_PRIO(f, p)                                     \
        snprintf(pStats->f.value.c, 16, "%s",                  \
                 ((dcbx_params.local_pfc_bitmap >> (p)) & 1) ? \
                     "enabled" : "disabled")

        GET_PFC_PRIO(pfc_prio_0, 0);
        GET_PFC_PRIO(pfc_prio_1, 1);
        GET_PFC_PRIO(pfc_prio_2, 2);
        GET_PFC_PRIO(pfc_prio_3, 3);
        GET_PFC_PRIO(pfc_prio_4, 4);
        GET_PFC_PRIO(pfc_prio_5, 5);
        GET_PFC_PRIO(pfc_prio_6, 6);
        GET_PFC_PRIO(pfc_prio_7, 7);
    }
    else
    {
        snprintf(pStats->pfc.value.c, 16, "not operational");

#define NO_PFC_PRIO(f)                       \
        snprintf(pStats->f.value.c, 16, "-")

        NO_PFC_PRIO(pfc_prio_0);
        NO_PFC_PRIO(pfc_prio_1);
        NO_PFC_PRIO(pfc_prio_2);
        NO_PFC_PRIO(pfc_prio_3);
        NO_PFC_PRIO(pfc_prio_4);
        NO_PFC_PRIO(pfc_prio_5);
        NO_PFC_PRIO(pfc_prio_6);
        NO_PFC_PRIO(pfc_prio_7);
    }

    if (dcbx_params.dcb_current_oper_state_bitmap &
        ETS_IS_CURRENTLY_OPERATIONAL)
    {
        snprintf(pStats->ets.value.c, 16, "operational");

#define GET_PRIO_PG(f, p)                                   \
        snprintf(pStats->f.value.c, 16, "%d",               \
                 dcbx_params.local_configuration_ets_pg[p])

        GET_PRIO_PG(ets_prio_0_pg, 0);
        GET_PRIO_PG(ets_prio_1_pg, 1);
        GET_PRIO_PG(ets_prio_2_pg, 2);
        GET_PRIO_PG(ets_prio_3_pg, 3);
        GET_PRIO_PG(ets_prio_4_pg, 4);
        GET_PRIO_PG(ets_prio_5_pg, 5);
        GET_PRIO_PG(ets_prio_6_pg, 6);
        GET_PRIO_PG(ets_prio_7_pg, 7);

#define GET_PG_BW(f, p)                                            \
        snprintf(pStats->f.value.c, 16, "%d",                      \
                 dcbx_params.local_configuration_bw_percentage[p])

        GET_PG_BW(ets_pg_0_bw, 0);
        GET_PG_BW(ets_pg_1_bw, 1);
        GET_PG_BW(ets_pg_2_bw, 2);
        GET_PG_BW(ets_pg_3_bw, 3);
        GET_PG_BW(ets_pg_4_bw, 4);
        GET_PG_BW(ets_pg_5_bw, 5);
        GET_PG_BW(ets_pg_6_bw, 6);
        GET_PG_BW(ets_pg_7_bw, 7);
    }
    else
    {
        snprintf(pStats->ets.value.c, 16, "not operational");

#define NO_PRIO_PG(f)                        \
        snprintf(pStats->f.value.c, 16, "-")

        NO_PRIO_PG(ets_prio_0_pg);
        NO_PRIO_PG(ets_prio_1_pg);
        NO_PRIO_PG(ets_prio_2_pg);
        NO_PRIO_PG(ets_prio_3_pg);
        NO_PRIO_PG(ets_prio_4_pg);
        NO_PRIO_PG(ets_prio_5_pg);
        NO_PRIO_PG(ets_prio_6_pg);
        NO_PRIO_PG(ets_prio_7_pg);

#define NO_PG_BW(f)                          \
        snprintf(pStats->f.value.c, 16, "-")

        NO_PG_BW(ets_pg_0_bw);
        NO_PG_BW(ets_pg_1_bw);
        NO_PG_BW(ets_pg_2_bw);
        NO_PG_BW(ets_pg_3_bw);
        NO_PG_BW(ets_pg_4_bw);
        NO_PG_BW(ets_pg_5_bw);
        NO_PG_BW(ets_pg_6_bw);
        NO_PG_BW(ets_pg_7_bw);
    }

    if (lldp_params.admin_status && (lldp_params.admin_status != LLDP_DISABLED))
    {
        snprintf(pStats->lldp.value.c, 16, "%s",
                 (lldp_params.admin_status == LLDP_TX_ONLY)  ? "tx only"   :
                 (lldp_params.admin_status == LLDP_RX_ONLY)  ? "rx only"   :
                 (lldp_params.admin_status == LLDP_TX_RX)    ? "tx and rx" :
                                                               "unknown");
        snprintf(pStats->lldp_tx_interval.value.c, 16, "%d seconds",
                 lldp_params.config_lldp_params.msg_tx_interval);
        snprintf(pStats->lldp_tx_fast_interval.value.c, 16, "%d seconds",
                 lldp_params.config_lldp_params.msg_fast_tx);
    }
    else
    {
        snprintf(pStats->lldp.value.c, 16, "disabled");
        snprintf(pStats->lldp_tx_interval.value.c, 16, "-");
        snprintf(pStats->lldp_tx_fast_interval.value.c, 16, "-");
    }

    /* -------------------- ADMIN MIB -------------------- */

    snprintf(pStats->amib_apptlv_willing.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.admin_app_priority_willing) ?
                 "willing" : "not willing");
    snprintf(pStats->amib_apptlv_tx.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.admin_application_priority_tx_enable) ?
                 "enabled" : "disabled");
    snprintf(pStats->amib_apptlv_net_prio.value.c, 16, "%d",
             dcbx_params.config_dcbx_params.admin_default_priority);

#define GET_PRIO_APP_TABLE(table, f1, f2)                   \
    if (table.valid)                                        \
    {                                                       \
        snprintf(pStats->f1.value.c, 16, "%d",              \
                 count_trailing_zeros(table.priority));     \
        snprintf(pStats->f2.value.c, 16,                    \
                 (table.traffic_type == TRAFFIC_TYPE_ETH) ? \
                     "ether=0x%x" : "port=%d",              \
                 table.app_id);                             \
    }                                                       \
    else                                                    \
    {                                                       \
        snprintf(pStats->f1.value.c, 16, "-");              \
        snprintf(pStats->f2.value.c, 16, "-");              \
    }

    GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params.
                       admin_priority_app_table[0],
                       amib_apptlv_tbl_0_prio,
                       amib_apptlv_tbl_0_appid);
    GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params.
                       admin_priority_app_table[1],
                       amib_apptlv_tbl_1_prio,
                       amib_apptlv_tbl_1_appid);
    GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params.
                       admin_priority_app_table[2],
                       amib_apptlv_tbl_2_prio,
                       amib_apptlv_tbl_2_appid);
    GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params.
                       admin_priority_app_table[3],
                       amib_apptlv_tbl_3_prio,
                       amib_apptlv_tbl_3_appid);

    snprintf(pStats->amib_pgtlv_willing.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.admin_ets_willing) ?
                 "willing" : "not willing");
    snprintf(pStats->amib_pgtlv_tx.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.admin_ets_configuration_tx_enable) ?
                 "enabled" : "disabled");
    snprintf(pStats->amib_pgtlv_tc_supported.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.admin_tc_supported_tx_enable) ?
                 "advertised" : "not advertised");
    snprintf(pStats->amib_pgtlv_ets.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.admin_ets_enable) ?
                 "enabled" : "disabled");

#define AMIB_GET_PG_TLV_BW(f, p)                       \
        snprintf(pStats->f.value.c, 16, "%d",          \
                 dcbx_params.config_dcbx_params.       \
                 admin_configuration_bw_percentage[p])

    AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_0_bw, 0);
    AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_1_bw, 1);
    AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_2_bw, 2);
    AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_3_bw, 3);
    AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_4_bw, 4);
    AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_5_bw, 5);
    AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_6_bw, 6);
    AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_7_bw, 7);

#define AMIB_GET_PG_TLV_MAP(f, p)                \
        snprintf(pStats->f.value.c, 16, "%d",    \
                 dcbx_params.config_dcbx_params. \
                 admin_configuration_ets_pg[p])

    AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_0_map, 0);
    AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_1_map, 1);
    AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_2_map, 2);
    AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_3_map, 3);
    AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_4_map, 4);
    AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_5_map, 5);
    AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_6_map, 6);
    AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_7_map, 7);

    snprintf(pStats->amib_pfctlv_willing.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.admin_pfc_willing) ?
                 "willing" : "not willing");
    snprintf(pStats->amib_pfctlv_tx.value.c, 16, "%s",
             (dcbx_params.config_dcbx_params.admin_pfc_tx_enable) ?
                 "enabled" : "disabled");

    if (dcbx_params.config_dcbx_params.admin_pfc_enable)
    {
        snprintf(pStats->amib_pfctlv_pfc.value.c, 16, "enabled");
        snprintf(pStats->amib_pfctlv_pfc_map.value.c, 16, "%d%d%d%d%d%d%d%d",
                 (dcbx_params.config_dcbx_params.admin_pfc_bitmap         % 2),
                 ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /   2) % 2),
                 ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /   4) % 2),
                 ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /   8) % 2),
                 ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /  16) % 2),
                 ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /  32) % 2),
                 ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /  64) % 2),
                 ((dcbx_params.config_dcbx_params.admin_pfc_bitmap / 128) % 2));
    }
    else
    {
        snprintf(pStats->amib_pfctlv_pfc.value.c, 16, "disabled");
        snprintf(pStats->amib_pfctlv_pfc_map.value.c, 16, "-");
    }

    /* -------------------- REMOTE MIB -------------------- */

    snprintf(pStats->rmib_apptlv_willing.value.c, 16, "%s",
             (dcbx_params.remote_app_priority_willing) ?
                 "willing" : "not willing");

    GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[0],
                       rmib_apptlv_tbl_0_prio,
                       rmib_apptlv_tbl_0_appid);
    GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[1],
                       rmib_apptlv_tbl_1_prio,
                       rmib_apptlv_tbl_1_appid);
    GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[2],
                       rmib_apptlv_tbl_2_prio,
                       rmib_apptlv_tbl_2_appid);
    GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[3],
                       rmib_apptlv_tbl_3_prio,
                       rmib_apptlv_tbl_3_appid);

    snprintf(pStats->rmib_pgtlv_willing.value.c, 16, "%s",
             (dcbx_params.remote_ets_willing) ?
                 "willing" : "not willing");

#define RMIB_GET_PG_TLV_BW(f, p)                                    \
        snprintf(pStats->f.value.c, 16, "%d",                       \
                 dcbx_params.remote_configuration_bw_percentage[p])

    RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_0_bw, 0);
    RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_1_bw, 1);
    RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_2_bw, 2);
    RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_3_bw, 3);
    RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_4_bw, 4);
    RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_5_bw, 5);
    RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_6_bw, 6);
    RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_7_bw, 7);

#define RMIB_GET_PG_TLV_MAP(f, p)                            \
        snprintf(pStats->f.value.c, 16, "%d",                \
                 dcbx_params.remote_configuration_ets_pg[p])

    RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_0_map, 0);
    RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_1_map, 1);
    RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_2_map, 2);
    RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_3_map, 3);
    RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_4_map, 4);
    RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_5_map, 5);
    RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_6_map, 6);
    RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_7_map, 7);

    snprintf(pStats->rmib_pgtlv_tc_supported.value.c, 16, "%d",
             dcbx_params.remote_tc_supported);

    snprintf(pStats->rmib_pfctlv_willing.value.c, 16, "%s",
             (dcbx_params.remote_pfc_willing) ?
                 "willing" : "not willing");

    snprintf(pStats->rmib_pfctlv_pfc_map.value.c, 16, "%d%d%d%d%d%d%d%d",
             (dcbx_params.remote_pfc_bitmap         % 2),
             ((dcbx_params.remote_pfc_bitmap /   2) % 2),
             ((dcbx_params.remote_pfc_bitmap /   4) % 2),
             ((dcbx_params.remote_pfc_bitmap /   8) % 2),
             ((dcbx_params.remote_pfc_bitmap /  16) % 2),
             ((dcbx_params.remote_pfc_bitmap /  32) % 2),
             ((dcbx_params.remote_pfc_bitmap /  64) % 2),
             ((dcbx_params.remote_pfc_bitmap / 128) % 2));

    snprintf(pStats->rmib_pfctlv_capable.value.c, 16, "%d",
             dcbx_params.remote_pfc_cap);

    /* -------------------- LOCAL MIB -------------------- */

    GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[0],
                       lmib_apptlv_tbl_0_prio,
                       lmib_apptlv_tbl_0_appid);
    GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[1],
                       lmib_apptlv_tbl_1_prio,
                       lmib_apptlv_tbl_1_appid);
    GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[2],
                       lmib_apptlv_tbl_2_prio,
                       lmib_apptlv_tbl_2_appid);
    GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[3],
                       lmib_apptlv_tbl_3_prio,
                       lmib_apptlv_tbl_3_appid);

    snprintf(pStats->lmib_apptlv_mismatch.value.c, 16, "%s",
             (dcbx_params.priority_app_mismatch) ? "yes" : "no");

    snprintf(pStats->lmib_pgtlv_ets.value.c, 16, "%s",
             (dcbx_params.local_ets_enable) ?
                 "enabled" : "disabled");

#define LMIB_GET_PG_TLV_BW(f, p)                                   \
        snprintf(pStats->f.value.c, 16, "%d",                      \
                 dcbx_params.local_configuration_bw_percentage[p])

    LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_0_bw, 0);
    LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_1_bw, 1);
    LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_2_bw, 2);
    LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_3_bw, 3);
    LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_4_bw, 4);
    LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_5_bw, 5);
    LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_6_bw, 6);
    LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_7_bw, 7);

#define LMIB_GET_PG_TLV_MAP(f, p)                            \
        snprintf(pStats->f.value.c, 16, "%d",                \
                 dcbx_params.local_configuration_ets_pg[p])

    LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_0_map, 0);
    LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_1_map, 1);
    LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_2_map, 2);
    LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_3_map, 3);
    LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_4_map, 4);
    LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_5_map, 5);
    LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_6_map, 6);
    LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_7_map, 7);

    snprintf(pStats->lmib_pgtlv_tc_supported.value.c, 16, "%d",
             dcbx_params.local_tc_supported);

    if (dcbx_params.local_pfc_enable)
    {
        snprintf(pStats->lmib_pfctlv_pfc.value.c, 16, "enabled");
        snprintf(pStats->lmib_pfctlv_pfc_map.value.c, 16, "%d%d%d%d%d%d%d%d",
                 (dcbx_params.local_pfc_bitmap         % 2),
                 ((dcbx_params.local_pfc_bitmap /   2) % 2),
                 ((dcbx_params.local_pfc_bitmap /   4) % 2),
                 ((dcbx_params.local_pfc_bitmap /   8) % 2),
                 ((dcbx_params.local_pfc_bitmap /  16) % 2),
                 ((dcbx_params.local_pfc_bitmap /  32) % 2),
                 ((dcbx_params.local_pfc_bitmap /  64) % 2),
                 ((dcbx_params.local_pfc_bitmap / 128) % 2));

        snprintf(pStats->lmib_pfctlv_capable.value.c, 16, "%d",
                 dcbx_params.local_pfc_caps);

        snprintf(pStats->lmib_pfctlv_mismatch.value.c, 16, "%s",
                 (dcbx_params.pfc_mismatch) ? "yes" : "no");
    }
    else
    {
        snprintf(pStats->lmib_pfctlv_pfc.value.c, 16, "disabled");
        snprintf(pStats->lmib_pfctlv_pfc_map.value.c, 16, "-");
        snprintf(pStats->lmib_pfctlv_capable.value.c, 16, "-");
        snprintf(pStats->lmib_pfctlv_mismatch.value.c, 16, "-");
    }

    /* --------------------------------------------------- */

    pStats->dcbx_frames_rx.value.ui64 = dcbx_params.dcbx_frames_received;
    pStats->dcbx_frames_tx.value.ui64 = dcbx_params.dcbx_frames_sent;
    pStats->pfc_frames_rx.value.ui64  = dcbx_params.pfc_frames_received;
    pStats->pfc_frames_tx.value.ui64  = dcbx_params.pfc_frames_sent;

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


static int BnxeKstatRxRingUpdate(kstat_t * kstats,
                                 int       rw)
{
    BnxeKstatRxq *   pStats = (BnxeKstatRxq *)kstats->ks_data;
    KstatRingMap *   pMap   = (KstatRingMap *)kstats->ks_private;
    um_device_t *    pUM    = (um_device_t *)pMap->pUM;
    int              idx    = pMap->idx;
    lm_device_t *    pLM    = (lm_device_t *)pUM;
    lm_tx_chain_t *  pTxq   = &LM_TXQ(pLM, idx);
    lm_rx_chain_t *  pRxq   = &LM_RXQ(pLM, idx);
    lm_rcq_chain_t * pRcq   = &LM_RCQ(pLM, idx);

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    BNXE_LOCK_ENTER_STATS(pUM);

    pStats->rxqBdTotal.value.ui64     = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].capacity;
    pStats->rxqBdLeft.value.ui64      = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bd_left;
    pStats->rxqBdPageCnt.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].page_cnt;
    pStats->rxqBdsPerPage.value.ui64  = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bds_per_page;
    pStats->rxqBdSize.value.ui64      = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bd_size;
    pStats->rxqBdsSkipEop.value.ui64  = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bds_skip_eop;
    pStats->rxqBdProdIdx.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].prod_idx;
    pStats->rxqBdConsIdx.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].cons_idx;
    pStats->hwRxqConIdx.value.ui64    =
        (pRxq->hw_con_idx_ptr != NULL) ?
            mm_le16_to_cpu(*pRxq->hw_con_idx_ptr) : 0;
    pStats->sgeBdTotal.value.ui64     = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].capacity;
    pStats->sgeBdLeft.value.ui64      = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bd_left;
    pStats->sgeBdPageCnt.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].page_cnt;
    pStats->sgeBdsPerPage.value.ui64  = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bds_per_page;
    pStats->sgeBdSize.value.ui64      = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bd_size;
    pStats->sgeBdsSkipEop.value.ui64  = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bds_skip_eop;
    pStats->sgeBdProdIdx.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].prod_idx;
    pStats->sgeBdConsIdx.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].cons_idx;
    pStats->rcqBdTotal.value.ui64     = pRcq->bd_chain.capacity;
    pStats->rcqBdLeft.value.ui64      = pRcq->bd_chain.bd_left;
    pStats->rcqBdPageCnt.value.ui64   = pRcq->bd_chain.page_cnt;
    pStats->rcqBdsPerPage.value.ui64  = pRcq->bd_chain.bds_per_page;
    pStats->rcqBdSize.value.ui64      = pRcq->bd_chain.bd_size;
    pStats->rcqBdsSkipEop.value.ui64  = pRcq->bd_chain.bds_skip_eop;
    pStats->rcqBdProdIdx.value.ui64   = pRcq->bd_chain.prod_idx;
    pStats->rcqBdConsIdx.value.ui64   = pRcq->bd_chain.cons_idx;
    pStats->hwRcqConIdx.value.ui64    =
        (pRcq->hw_con_idx_ptr != NULL) ?
            mm_le16_to_cpu(*pRcq->hw_con_idx_ptr) : 0;

    pStats->rxFreeDescs.value.ui64    = s_list_entry_cnt(&LM_RXQ(pLM, idx).common.free_descq);
    pStats->rxActiveDescs.value.ui64  = s_list_entry_cnt(&LM_RXQ(pLM, idx).active_descq);
    pStats->rxDoneDescs.value.ui64    = s_list_entry_cnt(&pUM->rxq[idx].doneRxQ);
    pStats->rxWaitingDescs.value.ui64 = s_list_entry_cnt(&pUM->rxq[idx].waitRxQ);
    pStats->rxCopied.value.ui64       = pUM->rxq[idx].rxCopied;
    pStats->rxDiscards.value.ui64     = pUM->rxq[idx].rxDiscards;
    pStats->rxBufUpInStack.value.ui64 = pUM->rxq[idx].rxBufUpInStack;
    pStats->rxLowWater.value.ui64     = pUM->rxq[idx].rxLowWater;
    pStats->inPollMode.value.ui64     = pUM->rxq[idx].inPollMode;
    pStats->pollCnt.value.ui64        = pUM->rxq[idx].pollCnt;
    pStats->intrDisableCnt.value.ui64 = pUM->rxq[idx].intrDisableCnt;
    pStats->intrEnableCnt.value.ui64  = pUM->rxq[idx].intrEnableCnt;
    pStats->genNumber.value.ui64      = pUM->rxq[idx].genNumber;

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


static int BnxeKstatTxRingUpdate(kstat_t * kstats,
                                 int       rw)
{
    BnxeKstatTxq * pStats = (BnxeKstatTxq *)kstats->ks_data;
    KstatRingMap * pMap   = (KstatRingMap *)kstats->ks_private;
    um_device_t *  pUM    = (um_device_t *)pMap->pUM;
    int            idx    = pMap->idx;
    lm_device_t *  pLM    = (lm_device_t *)pUM;

    if (rw == KSTAT_WRITE)
    {
        return EACCES;
    }

    BNXE_LOCK_ENTER_STATS(pUM);

    pStats->txBdTotal.value.ui64     = LM_TXQ(pLM, idx).bd_chain.capacity;
    pStats->txBdLeft.value.ui64      = LM_TXQ(pLM, idx).bd_chain.bd_left;
    pStats->txBdPageCnt.value.ui64   = LM_TXQ(pLM, idx).bd_chain.page_cnt;
    pStats->txBdsPerPage.value.ui64  = LM_TXQ(pLM, idx).bd_chain.bds_per_page;
    pStats->txBdSize.value.ui64      = LM_TXQ(pLM, idx).bd_chain.bd_size;
    pStats->txBdsSkipEop.value.ui64  = LM_TXQ(pLM, idx).bd_chain.bds_skip_eop;
    pStats->hwTxqConIdx.value.ui64   =
        (LM_TXQ(pLM, idx).hw_con_idx_ptr != NULL) ?
            mm_le16_to_cpu(*LM_TXQ(pLM, idx).hw_con_idx_ptr) : 0;
    pStats->txPktIdx.value.ui64      = LM_TXQ(pLM, idx).pkt_idx;
    pStats->txBdProdIdx.value.ui64   = LM_TXQ(pLM, idx).bd_chain.prod_idx;
    pStats->txBdConsIdx.value.ui64   = LM_TXQ(pLM, idx).bd_chain.cons_idx;
    pStats->txSentPkts.value.ui64    = s_list_entry_cnt(&pUM->txq[idx].sentTxQ);
    pStats->txFreeDesc.value.ui64    = s_list_entry_cnt(&pUM->txq[idx].freeTxDescQ);
    pStats->txWaitingPkts.value.ui64 = s_list_entry_cnt(&pUM->txq[idx].waitTxDescQ);
    pStats->txLowWater.value.ui64    = pUM->txq[idx].txLowWater;
    pStats->txFailed.value.ui64      = pUM->txq[idx].txFailed;
    pStats->txDiscards.value.ui64    = pUM->txq[idx].txDiscards;
    pStats->txRecycle.value.ui64     = pUM->txq[idx].txRecycle;
    pStats->txCopied.value.ui64      = pUM->txq[idx].txCopied;
    pStats->txBlocked.value.ui64     = pUM->txq[idx].txBlocked;
    pStats->txWait.value.ui64        = pUM->txq[idx].txWait;

    BNXE_LOCK_EXIT_STATS(pUM);

    return 0;
}


boolean_t BnxeKstatInitRxQ(um_device_t * pUM,
                           int           idx)
{
    char buf[32];

    BnxeKstatRxq * pStatsRxq;
#define BNXE_KSTAT_RXQ(f, t)  kstat_named_init(&pStatsRxq->f, #f, t)

    snprintf(buf, sizeof(buf), "rxq%d", idx);

    if ((pUM->kstats_rxq[idx] = kstat_create("bnxe",
                                             pUM->instance,
                                             buf,
                                             "net",
                                             KSTAT_TYPE_NAMED,
                                             BNXE_KSTAT_RXQ_SIZE,
                                             0)) == NULL)
    {
        BnxeLogWarn(pUM, "Failed to create rxq%d kstat", idx);
        return B_FALSE;
    }

    pStatsRxq = (BnxeKstatRxq *)pUM->kstats_rxq[idx]->ks_data;

    BNXE_KSTAT_RXQ(rxqBdTotal,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxqBdLeft,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxqBdPageCnt,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxqBdsPerPage,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxqBdSize,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxqBdsSkipEop,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxqBdProdIdx,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxqBdConsIdx,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(hwRxqConIdx,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(sgeBdTotal,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(sgeBdLeft,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(sgeBdPageCnt,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(sgeBdsPerPage,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(sgeBdSize,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(sgeBdsSkipEop,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(sgeBdProdIdx,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(sgeBdConsIdx,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rcqBdTotal,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rcqBdLeft,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rcqBdPageCnt,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rcqBdsPerPage,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rcqBdSize,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rcqBdsSkipEop,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rcqBdProdIdx,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rcqBdConsIdx,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(hwRcqConIdx,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxFreeDescs,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxActiveDescs,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxDoneDescs,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxWaitingDescs, KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxCopied,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxDiscards,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxBufUpInStack, KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(rxLowWater,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(inPollMode,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(pollCnt,        KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(intrDisableCnt, KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(intrEnableCnt,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_RXQ(genNumber,      KSTAT_DATA_UINT64);

    pUM->kstats_rxq_map[idx].idx = idx;
    pUM->kstats_rxq_map[idx].pUM = pUM;

    pUM->kstats_rxq[idx]->ks_update  = BnxeKstatRxRingUpdate;
    pUM->kstats_rxq[idx]->ks_private = (void *)&pUM->kstats_rxq_map[idx];

    kstat_install(pUM->kstats_rxq[idx]);

    return B_TRUE;
}


boolean_t BnxeKstatInitTxQ(um_device_t * pUM,
                           int           idx)
{
    char buf[32];

    BnxeKstatTxq * pStatsTxq;
#define BNXE_KSTAT_TXQ(f, t)  kstat_named_init(&pStatsTxq->f, #f, t)

    snprintf(buf, sizeof(buf), "txq%d", idx);

    if ((pUM->kstats_txq[idx] = kstat_create("bnxe",
                                             pUM->instance,
                                             buf,
                                             "net",
                                             KSTAT_TYPE_NAMED,
                                             BNXE_KSTAT_TXQ_SIZE,
                                             0)) == NULL)
    {
        BnxeLogWarn(pUM, "Failed to create txq%d kstat", idx);
        return B_FALSE;
    }

    pStatsTxq = (BnxeKstatTxq *)pUM->kstats_txq[idx]->ks_data;

    BNXE_KSTAT_TXQ(txBdTotal,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txBdLeft,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txBdPageCnt,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txBdsPerPage,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txBdSize,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txBdsSkipEop,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(hwTxqConIdx,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txPktIdx,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txBdProdIdx,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txBdConsIdx,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txSentPkts,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txFreeDesc,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txWaitingPkts, KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txLowWater,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txFailed,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txDiscards,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txRecycle,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txCopied,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txBlocked,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_TXQ(txWait,        KSTAT_DATA_UINT64);

    pUM->kstats_txq_map[idx].idx = idx;
    pUM->kstats_txq_map[idx].pUM = pUM;

    pUM->kstats_txq[idx]->ks_update  = BnxeKstatTxRingUpdate;
    pUM->kstats_txq[idx]->ks_private = (void *)&pUM->kstats_txq_map[idx];

    kstat_install(pUM->kstats_txq[idx]);

    return B_TRUE;
}


boolean_t BnxeKstatInit(um_device_t * pUM)
{
    lm_device_t * pLM = (lm_device_t *)pUM;
    char buf[32];
    int idx;

    BnxeKstat *         pStats;
    BnxeKstatLink *     pStatsLink;
    BnxeKstatIntr *     pStatsIntr;
    BnxeKstatL2Chip *   pStatsL2Chip;
    BnxeKstatL2Driver * pStatsL2Driver;
    BnxeKstatEthStats * pStatsL2Stats;
    BnxeKstatFcoe *     pStatsFcoe;
    BnxeKstatDcbx *     pStatsDcbx;
#define BNXE_KSTAT(f, t)            kstat_named_init(&pStats->f, #f, t)
#define BNXE_KSTAT_LINK(f, t)       kstat_named_init(&pStatsLink->f, #f, t)
#define BNXE_KSTAT_INTR(f, t)       kstat_named_init(&pStatsIntr->f, #f, t)
#define BNXE_KSTAT_L2_CHIP(f, t)    kstat_named_init(&pStatsL2Chip->f, #f, t)
#define BNXE_KSTAT_L2_DRIVER(f, t)  kstat_named_init(&pStatsL2Driver->f, #f, t)
#define BNXE_KSTAT_L2_STATS(f, t)   kstat_named_init(&pStatsL2Stats->f, #f, t)
#define BNXE_KSTAT_FCOE(f, t)       kstat_named_init(&pStatsFcoe->f, #f, t)
#define BNXE_KSTAT_DCBX(f, t)       kstat_named_init(&pStatsDcbx->f, #f, t)

    /****************************************************************/

    if ((pUM->kstats = kstat_create("bnxe",
                                    pUM->instance,
                                    "stats",
                                    "net",
                                    KSTAT_TYPE_NAMED,
                                    BNXE_KSTAT_SIZE,
                                    0)) == NULL)
    {
        BnxeLogWarn(pUM, "Failed to create kstat");
        return B_FALSE;
    }

    pStats = (BnxeKstat *)pUM->kstats->ks_data;

    BNXE_KSTAT(umdev_hi,               KSTAT_DATA_CHAR);
    BNXE_KSTAT(umdev_lo,               KSTAT_DATA_CHAR);
    BNXE_KSTAT(version,                KSTAT_DATA_CHAR);
    BNXE_KSTAT(versionFW,              KSTAT_DATA_CHAR);
    BNXE_KSTAT(versionBC,              KSTAT_DATA_CHAR);
    BNXE_KSTAT(chipName,               KSTAT_DATA_CHAR);
    BNXE_KSTAT(chipID,                 KSTAT_DATA_CHAR);
    BNXE_KSTAT(devBDF,                 KSTAT_DATA_CHAR);
    BNXE_KSTAT(devID,                  KSTAT_DATA_CHAR);
    BNXE_KSTAT(multiFunction,          KSTAT_DATA_CHAR);
    BNXE_KSTAT(multiFunctionVnics,     KSTAT_DATA_UINT64);
    BNXE_KSTAT(macAddr,                KSTAT_DATA_CHAR);
    BNXE_KSTAT(hwInitDone,             KSTAT_DATA_UINT64);
    BNXE_KSTAT(clientsHw,              KSTAT_DATA_CHAR);
    BNXE_KSTAT(clientsDevi,            KSTAT_DATA_CHAR);
    BNXE_KSTAT(clientsBound,           KSTAT_DATA_CHAR);
    BNXE_KSTAT(txMsgPullUp,            KSTAT_DATA_UINT64);
    BNXE_KSTAT(intrAlloc,              KSTAT_DATA_CHAR);
    BNXE_KSTAT(intrFired,              KSTAT_DATA_UINT64);
    BNXE_KSTAT(timerFired,             KSTAT_DATA_UINT64);
    BNXE_KSTAT(timerReply,             KSTAT_DATA_UINT64);
    BNXE_KSTAT(timerNoReplyTotal,      KSTAT_DATA_UINT64);
    BNXE_KSTAT(timerNoReplyCurrent,    KSTAT_DATA_UINT64);
    BNXE_KSTAT(timerDone,              KSTAT_DATA_UINT64);
    BNXE_KSTAT(workQueueInstCnt,       KSTAT_DATA_UINT64);
    BNXE_KSTAT(workItemInstQueued,     KSTAT_DATA_UINT64);
    BNXE_KSTAT(workItemInstError,      KSTAT_DATA_UINT64);
    BNXE_KSTAT(workItemInstComplete,   KSTAT_DATA_UINT64);
    BNXE_KSTAT(workItemInstHighWater,  KSTAT_DATA_UINT64);
    BNXE_KSTAT(workQueueDelayCnt,      KSTAT_DATA_UINT64);
    BNXE_KSTAT(workItemDelayQueued,    KSTAT_DATA_UINT64);
    BNXE_KSTAT(workItemDelayError,     KSTAT_DATA_UINT64);
    BNXE_KSTAT(workItemDelayComplete,  KSTAT_DATA_UINT64);
    BNXE_KSTAT(workItemDelayHighWater, KSTAT_DATA_UINT64);
    BNXE_KSTAT(memAllocBlocks,         KSTAT_DATA_UINT64);
    BNXE_KSTAT(memAllocDMAs,           KSTAT_DATA_UINT64);
    BNXE_KSTAT(memAllocBARs,           KSTAT_DATA_UINT64);

    pUM->kstats->ks_update  = BnxeKstatUpdate;
    pUM->kstats->ks_private = (void *)pUM;

    kstat_install(pUM->kstats);

    /****************************************************************/

    if ((pUM->kstatsLink = kstat_create("bnxe",
                                        pUM->instance,
                                        "link",
                                        "net",
                                        KSTAT_TYPE_NAMED,
                                        BNXE_KSTAT_LINK_SIZE,
                                        0)) == NULL)
    {
        BnxeLogWarn(pUM, "Failed to create link kstat");
        return B_FALSE;
    }

    pStatsLink = (BnxeKstatLink *)pUM->kstatsLink->ks_data;

    BNXE_KSTAT_LINK(clients, KSTAT_DATA_CHAR);
    BNXE_KSTAT_LINK(uptime,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_LINK(mtuL2,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_LINK(mtuFCOE, KSTAT_DATA_UINT64);
    BNXE_KSTAT_LINK(speed,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_LINK(link,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_LINK(duplex,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_LINK(pauseRx, KSTAT_DATA_UINT64);
    BNXE_KSTAT_LINK(pauseTx, KSTAT_DATA_UINT64);

    pUM->kstatsLink->ks_update  = BnxeKstatLinkUpdate;
    pUM->kstatsLink->ks_private = (void *)pUM;

    kstat_install(pUM->kstatsLink);

    /****************************************************************/

    if ((pUM->kstatsIntr = kstat_create("bnxe",
                                        pUM->instance,
                                        "intr",
                                        "net",
                                        KSTAT_TYPE_NAMED,
                                        BNXE_KSTAT_INTR_SIZE,
                                        0)) == NULL)
    {
        BnxeLogWarn(pUM, "Failed to create intr kstat");
        return B_FALSE;
    }

    pStatsIntr = (BnxeKstatIntr *)pUM->kstatsIntr->ks_data;

    BNXE_KSTAT_INTR(intrAlloc,      KSTAT_DATA_CHAR);
    BNXE_KSTAT_INTR(intrFired,      KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(intrWrongState, KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(intrInDisabled, KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(intrZeroStatus, KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_00,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_01,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_02,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_03,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_04,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_05,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_06,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_07,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_08,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_09,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_10,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_11,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_12,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_13,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_14,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_15,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_16,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_00,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_01,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_02,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_03,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_04,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_05,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_06,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_07,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_08,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_09,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_10,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_11,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_12,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_13,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_14,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_15,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_nc_16,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_00,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_01,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_02,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_03,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_04,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_05,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_06,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_07,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_08,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_09,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_10,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_11,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_12,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_13,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_14,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_15,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_16,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_00,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_01,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_02,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_03,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_04,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_05,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_06,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_07,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_08,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_09,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_10,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_11,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_12,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_13,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_14,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_15,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_INTR(sb_poll_nc_16,  KSTAT_DATA_UINT64);

    pUM->kstatsIntr->ks_update  = BnxeKstatIntrUpdate;
    pUM->kstatsIntr->ks_private = (void *)pUM;

    kstat_install(pUM->kstatsIntr);

    /****************************************************************/

    if ((pUM->kstatsL2Chip = kstat_create("bnxe",
                                          pUM->instance,
                                          "l2chip",
                                          "net",
                                          KSTAT_TYPE_NAMED,
                                          BNXE_KSTAT_L2_CHIP_SIZE,
                                          0)) == NULL)
    {
        BnxeLogWarn(pUM, "Failed to create l2chip kstat");
        return B_FALSE;
    }

    pStatsL2Chip = (BnxeKstatL2Chip *)pUM->kstatsL2Chip->ks_data;

    BNXE_KSTAT_L2_CHIP(IfHCInOctets,                       KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCInBadOctets,                    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutOctets,                      KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutBadOctets,                   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutPkts,                        KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCInPkts,                         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCInUcastPkts,                    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCInMulticastPkts,                KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCInBroadcastPkts,                KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutUcastPkts,                   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutMulticastPkts,               KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutBroadcastPkts,               KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCInUcastOctets,                  KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCInMulticastOctets,              KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCInBroadcastOctets,              KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutUcastOctets,                 KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutMulticastOctets,             KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutBroadcastOctets,             KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCOutDiscards,                    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfHCInFalseCarrierErrors,           KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(Dot3StatsInternalMacTransmitErrors, KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(Dot3StatsCarrierSenseErrors,        KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(Dot3StatsFCSErrors,                 KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(Dot3StatsAlignmentErrors,           KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(Dot3StatsSingleCollisionFrames,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(Dot3StatsMultipleCollisionFrames,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(Dot3StatsDeferredTransmissions,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(Dot3StatsExcessiveCollisions,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(Dot3StatsLateCollisions,            KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsCollisions,               KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsFragments,                KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsJabbers,                  KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsUndersizePkts,            KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsOverrsizePkts,            KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsTx64Octets,               KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsTx65to127Octets,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsTx128to255Octets,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsTx256to511Octets,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsTx512to1023Octets,        KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsTx1024to1522Octets,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(EtherStatsTxOver1522Octets,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(XonPauseFramesReceived,             KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(XoffPauseFramesReceived,            KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(OutXonSent,                         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(OutXoffSent,                        KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(FlowControlDone,                    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(MacControlFramesReceived,           KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(XoffStateEntered,                   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfInFramesL2FilterDiscards,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfInTTL0Discards,                   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfInxxOverflowDiscards,             KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfInMBUFDiscards,                   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfInErrors,                         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfInErrorsOctets,                   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(IfInNoBrbBuffer,                    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigBrbPacket,                       KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigBrbTruncate,                     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigFlowCtrlDiscard,                 KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigFlowCtrlOctets,                  KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigFlowCtrlPacket,                  KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigMngDiscard,                      KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigMngOctetInp,                     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigMngOctetOut,                     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigMngPacketInp,                    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigMngPacketOut,                    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigPbfOctets,                       KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigPbfPacket,                       KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_CHIP(NigSafcInp,                         KSTAT_DATA_UINT64);

    pUM->kstatsL2Chip->ks_update  = BnxeKstatL2ChipUpdate;
    pUM->kstatsL2Chip->ks_private = (void *)pUM;

    kstat_install(pUM->kstatsL2Chip);

    /****************************************************************/

    if ((pUM->kstatsL2Driver = kstat_create("bnxe",
                                            pUM->instance,
                                            "l2driver",
                                            "net",
                                            KSTAT_TYPE_NAMED,
                                            BNXE_KSTAT_L2_DRIVER_SIZE,
                                            0)) == NULL)
    {
        BnxeLogWarn(pUM, "Failed to create l2driver kstat");
        return B_FALSE;
    }

    pStatsL2Driver = (BnxeKstatL2Driver *)pUM->kstatsL2Driver->ks_data;

    BNXE_KSTAT_L2_DRIVER(RxIPv4FragCount,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_DRIVER(RxIpCsErrorCount,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_DRIVER(RxTcpCsErrorCount,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_DRIVER(RxLlcSnapCount,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_DRIVER(RxPhyErrorCount,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_DRIVER(RxIpv6ExtCount,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_DRIVER(TxNoL2Bd,           KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_DRIVER(TxNoSqWqe,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_DRIVER(TxL2AssemblyBufUse, KSTAT_DATA_UINT64);

    pUM->kstatsL2Driver->ks_update  = BnxeKstatL2DriverUpdate;
    pUM->kstatsL2Driver->ks_private = (void *)pUM;

    kstat_install(pUM->kstatsL2Driver);

    /****************************************************************/

    if ((pUM->kstatsL2Stats = kstat_create("bnxe",
                                           pUM->instance,
                                           "l2stats",
                                           "net",
                                           KSTAT_TYPE_NAMED,
                                           BNXE_KSTAT_ETH_STATS_SIZE,
                                           0)) == NULL)
    {
        BnxeLogWarn(pUM, "Failed to create l2stats kstat");
        return B_FALSE;
    }

    pStatsL2Stats = (BnxeKstatEthStats *)pUM->kstatsL2Stats->ks_data;

    BNXE_KSTAT_L2_STATS(txFramesOk,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxFramesOk,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txErr,              KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxErr,              KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxCrcErr,           KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(alignErr,           KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(collisionsSingle,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(collisionsMultiple, KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(framesDeferred,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(collisonsMax,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxOverrun,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txOverrun,          KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txFramesUnicast,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txFramesMulticast,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txFramesBroadcast,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxFramesUnicast,    KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxFramesMulticast,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxFramesBroadcast,  KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxNoBufferDrop,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxBytes,            KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txBytes,            KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(offloadIP4,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(offloadTCP,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(ifInDiscards,       KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(ifInErrors,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(ifOutErrors,        KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(offloadIP6,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(offloadTCP6,        KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txDiscards,         KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxBytesUnicast,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxBytesMulticast,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(rxBytesBroadcast,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txBytesUnicast,     KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txBytesMulticast,   KSTAT_DATA_UINT64);
    BNXE_KSTAT_L2_STATS(txBytesBroadcast,   KSTAT_DATA_UINT64);

    pUM->kstatsL2Stats->ks_update  = BnxeKstatL2StatsUpdate;
    pUM->kstatsL2Stats->ks_private = (void *)pUM;

    kstat_install(pUM->kstatsL2Stats);

    /****************************************************************/

    if (BNXE_FCOE(pUM))
    {
        if ((pUM->kstatsFcoe = kstat_create("bnxe",
                                            pUM->instance,
                                            "fcoe",
                                            "net",
                                            KSTAT_TYPE_NAMED,
                                            BNXE_KSTAT_FCOE_SIZE,
                                            0)) == NULL)
        {
            BnxeLogWarn(pUM, "Failed to create fcoe kstat");
            BnxeKstatFini(pUM);
            return B_FALSE;
        }

        pStatsFcoe = (BnxeKstatFcoe *)pUM->kstatsFcoe->ks_data;

        BNXE_KSTAT_FCOE(pdev_hi,             KSTAT_DATA_CHAR);
        BNXE_KSTAT_FCOE(pdev_lo,             KSTAT_DATA_CHAR);
        BNXE_KSTAT_FCOE(instance,            KSTAT_DATA_CHAR);
        BNXE_KSTAT_FCOE(macAddr,             KSTAT_DATA_CHAR);
        BNXE_KSTAT_FCOE(pwwn_hi,             KSTAT_DATA_CHAR);
        BNXE_KSTAT_FCOE(pwwn_lo,             KSTAT_DATA_CHAR);
        BNXE_KSTAT_FCOE(mtu,                 KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(initWqeTx,           KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(initWqeTxErr,        KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(initCqeRx,           KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(initCqeRxErr,        KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(offloadConnWqeTx,    KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(offloadConnWqeTxErr, KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(offloadConnCqeRx,    KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(offloadConnCqeRxErr, KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(enableConnWqeTx,     KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(enableConnWqeTxErr,  KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(enableConnCqeRx,     KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(enableConnCqeRxErr,  KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(disableConnWqeTx,    KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(disableConnWqeTxErr, KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(disableConnCqeRx,    KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(disableConnCqeRxErr, KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(destroyConnWqeTx,    KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(destroyConnWqeTxErr, KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(destroyConnCqeRx,    KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(destroyConnCqeRxErr, KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(destroyWqeTx,        KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(destroyWqeTxErr,     KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(destroyCqeRx,        KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(destroyCqeRxErr,     KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(compRequestCqeRx,    KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(compRequestCqeRxErr, KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(statWqeTx,           KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(statWqeTxErr,        KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(statCqeRx,           KSTAT_DATA_UINT64);
        BNXE_KSTAT_FCOE(statCqeRxErr,        KSTAT_DATA_UINT64);

        pUM->kstatsFcoe->ks_update  = BnxeKstatFcoeUpdate;
        pUM->kstatsFcoe->ks_private = (void *)pUM;

        kstat_install(pUM->kstatsFcoe);

        if (!BnxeKstatInitRxQ(pUM, FCOE_CID(pLM)))
        {
            BnxeKstatFini(pUM);
            return B_FALSE;
        }

        if (!BnxeKstatInitTxQ(pUM, FCOE_CID(pLM)))
        {
            BnxeKstatFini(pUM);
            return B_FALSE;
        }
    }

    /****************************************************************/

    if (IS_DCB_SUPPORTED(pLM))
    {
        if ((pUM->kstatsDcbx = kstat_create("bnxe",
                                            pUM->instance,
                                            "dcbx",
                                            "net",
                                            KSTAT_TYPE_NAMED,
                                            BNXE_KSTAT_DCBX_SIZE,
                                            0)) == NULL)
        {
            BnxeLogWarn(pUM, "Failed to create dcbx kstat");
            BnxeKstatFini(pUM);
            return B_FALSE;
        }

        pStatsDcbx = (BnxeKstatDcbx *)pUM->kstatsDcbx->ks_data;

        BNXE_KSTAT_DCBX(dcbx_sync, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(dcbx_vers, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(overwrite_settings, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(prio_tag, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(prio_tag_fcoe, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(prio_tag_iscsi, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(prio_tag_net, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(pfc, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(pfc_prio_0, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(pfc_prio_1, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(pfc_prio_2, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(pfc_prio_3, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(pfc_prio_4, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(pfc_prio_5, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(pfc_prio_6, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(pfc_prio_7, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_prio_0_pg, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_prio_1_pg, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_prio_2_pg, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_prio_3_pg, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_prio_4_pg, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_prio_5_pg, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_prio_6_pg, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_prio_7_pg, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_pg_0_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_pg_1_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_pg_2_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_pg_3_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_pg_4_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_pg_5_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_pg_6_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(ets_pg_7_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lldp, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lldp_tx_interval, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lldp_tx_fast_interval, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_willing, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_tx, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_net_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_tbl_0_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_tbl_0_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_tbl_1_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_tbl_1_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_tbl_2_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_tbl_2_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_tbl_3_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_apptlv_tbl_3_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_willing, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_tx, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_tc_supported, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_ets, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_pg_0_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_pg_1_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_pg_2_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_pg_3_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_pg_4_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_pg_5_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_pg_6_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_pg_7_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_prio_0_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_prio_1_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_prio_2_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_prio_3_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_prio_4_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_prio_5_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_prio_6_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pgtlv_prio_7_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pfctlv_willing, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pfctlv_tx, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pfctlv_pfc, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(amib_pfctlv_pfc_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_apptlv_willing, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_apptlv_tbl_0_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_apptlv_tbl_0_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_apptlv_tbl_1_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_apptlv_tbl_1_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_apptlv_tbl_2_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_apptlv_tbl_2_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_apptlv_tbl_3_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_apptlv_tbl_3_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_willing, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_tc_supported, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_pg_0_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_pg_1_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_pg_2_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_pg_3_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_pg_4_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_pg_5_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_pg_6_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_pg_7_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_prio_0_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_prio_1_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_prio_2_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_prio_3_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_prio_4_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_prio_5_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_prio_6_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pgtlv_prio_7_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pfctlv_willing, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pfctlv_pfc_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(rmib_pfctlv_capable, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_apptlv_tbl_0_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_apptlv_tbl_0_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_apptlv_tbl_1_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_apptlv_tbl_1_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_apptlv_tbl_2_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_apptlv_tbl_2_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_apptlv_tbl_3_prio, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_apptlv_tbl_3_appid, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_apptlv_mismatch, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_ets, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_tc_supported, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_pg_0_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_pg_1_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_pg_2_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_pg_3_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_pg_4_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_pg_5_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_pg_6_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_pg_7_bw, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_prio_0_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_prio_1_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_prio_2_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_prio_3_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_prio_4_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_prio_5_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_prio_6_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pgtlv_prio_7_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pfctlv_pfc, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pfctlv_pfc_map, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pfctlv_capable, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(lmib_pfctlv_mismatch, KSTAT_DATA_CHAR);
        BNXE_KSTAT_DCBX(dcbx_frames_rx, KSTAT_DATA_UINT64);
        BNXE_KSTAT_DCBX(dcbx_frames_tx, KSTAT_DATA_UINT64);
        BNXE_KSTAT_DCBX(pfc_frames_rx, KSTAT_DATA_UINT64);
        BNXE_KSTAT_DCBX(pfc_frames_tx, KSTAT_DATA_UINT64);

        pUM->kstatsDcbx->ks_update  = BnxeKstatDcbxUpdate;
        pUM->kstatsDcbx->ks_private = (void *)pUM;

        kstat_install(pUM->kstatsDcbx);
    }

    /****************************************************************/

    if (!BnxeProtoFcoeAfex(pUM))
    {
        LM_FOREACH_RSS_IDX(pLM, idx)
        {
            if (!BnxeKstatInitRxQ(pUM, idx))
            {
                BnxeKstatFini(pUM);
                return B_FALSE;
            }
        }

        LM_FOREACH_TSS_IDX(pLM, idx)
        {
            if (!BnxeKstatInitTxQ(pUM, idx))
            {
                BnxeKstatFini(pUM);
                return B_FALSE;
            }
        }
    }

    /****************************************************************/

    return B_TRUE;
}


void BnxeKstatFini(um_device_t * pUM)
{
    lm_device_t * pLM = (lm_device_t *)pUM;
    int idx;

    if (pUM->kstats)
    {
        kstat_delete(pUM->kstats);
        pUM->kstats = NULL;
    }

    if (pUM->kstatsLink)
    {
        kstat_delete(pUM->kstatsLink);
        pUM->kstatsLink = NULL;
    }

    if (pUM->kstatsIntr)
    {
        kstat_delete(pUM->kstatsIntr);
        pUM->kstatsIntr = NULL;
    }

    if (pUM->kstatsL2Chip)
    {
        kstat_delete(pUM->kstatsL2Chip);
        pUM->kstatsL2Chip = NULL;
    }

    if (pUM->kstatsL2Driver)
    {
        kstat_delete(pUM->kstatsL2Driver);
        pUM->kstatsL2Driver = NULL;
    }

    if (pUM->kstatsL2Stats)
    {
        kstat_delete(pUM->kstatsL2Stats);
        pUM->kstatsL2Stats = NULL;
    }

    if (BNXE_FCOE(pUM))
    {
        if (pUM->kstatsFcoe)
        {
            kstat_delete(pUM->kstatsFcoe);
            pUM->kstatsFcoe = NULL;
        }

        idx = FCOE_CID(pLM);

        if (pUM->kstats_rxq[idx])
        {
            kstat_delete(pUM->kstats_rxq[idx]);
            pUM->kstats_rxq[idx] = NULL;
        }

        pUM->kstats_rxq_map[idx].idx = 0;
        pUM->kstats_rxq_map[idx].pUM = NULL;

        if (pUM->kstats_txq[idx])
        {
            kstat_delete(pUM->kstats_txq[idx]);
            pUM->kstats_txq[idx] = NULL;
        }

        pUM->kstats_txq_map[idx].idx = 0;
        pUM->kstats_txq_map[idx].pUM = NULL;
    }

    if (IS_DCB_SUPPORTED(pLM))
    {
        if (pUM->kstatsDcbx)
        {
            kstat_delete(pUM->kstatsDcbx);
            pUM->kstatsDcbx = NULL;
        }
    }

    if (!BnxeProtoFcoeAfex(pUM))
    {
        LM_FOREACH_RSS_IDX(pLM, idx)
        {
            if (pUM->kstats_rxq[idx])
            {
                kstat_delete(pUM->kstats_rxq[idx]);
                pUM->kstats_rxq[idx] = NULL;
            }

            pUM->kstats_rxq_map[idx].idx = 0;
            pUM->kstats_rxq_map[idx].pUM = NULL;
        }

        LM_FOREACH_TSS_IDX(pLM, idx)
        {
            if (pUM->kstats_txq[idx])
            {
                kstat_delete(pUM->kstats_txq[idx]);
                pUM->kstats_txq[idx] = NULL;
            }

            pUM->kstats_txq_map[idx].idx = 0;
            pUM->kstats_txq_map[idx].pUM = NULL;
        }
    }
}