xref: /illumos-gate/usr/src/uts/common/io/qede/qede_kstat.c (revision 14b24e2b)

/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, v.1,  (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://opensource.org/licenses/CDDL-1.0.
* 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-2017 Cavium, Inc.
* The contents of this file are subject to the terms of the Common Development
* and Distribution License, v.1,  (the "License").

* You may not use this file except in compliance with the License.

* You can obtain a copy of the License at available
* at http://opensource.org/licenses/CDDL-1.0

* See the License for the specific language governing permissions and
* limitations under the License.
*/


#include "qede.h"

typedef struct  _qede_kstat {
	kstat_named_t qede_hi;
	kstat_named_t qede_lo;
	kstat_named_t version;
	kstat_named_t versionFW;
	kstat_named_t versionMFW;
	kstat_named_t chipID;
	kstat_named_t chipName;
	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 numVports;
	kstat_named_t vportID;
	kstat_named_t intrAlloc;
	kstat_named_t intrFired;
	kstat_named_t lroEnabled;
	kstat_named_t lsoEnabled;
	kstat_named_t jumboEnabled;
	kstat_named_t txTotalPkts;
	kstat_named_t txTotalBytes;
	kstat_named_t txTotalDiscards;
	kstat_named_t rxTotalPkts;
	kstat_named_t rxTotalBytes;
	kstat_named_t rxTotalDiscards;
	kstat_named_t allocbFailures;
} qede_kstat_t;

#define QEDE_KSTAT_SIZE (sizeof (qede_kstat_t) / sizeof (kstat_named_t))

typedef struct _qede_kstat_link {
	kstat_named_t vportID;
    	kstat_named_t uptime;
    	kstat_named_t mtuL2;
    	kstat_named_t speed;
    	kstat_named_t link;
    	kstat_named_t duplex;
    	kstat_named_t pauseRx;
    	kstat_named_t pauseTx;
} qede_kstat_link_t;

#define QEDE_KSTAT_LINK_SIZE \
	(sizeof (qede_kstat_link_t) / sizeof (kstat_named_t))

typedef struct _qede_kstat_intr {
	kstat_named_t intrAlloc;
	kstat_named_t intrFired;
    	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_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_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_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;
} qede_kstat_intr_t;

#define QEDE_KSTAT_INTR_SIZE \
	(sizeof (qede_kstat_intr_t) / sizeof (kstat_named_t))

typedef struct _qede_kstat_vport_stats {
	kstat_named_t	rxUcastBytes;
	kstat_named_t   rxMcastBytes;
	kstat_named_t   rxBcastBytes;
	kstat_named_t	rxUcastPkts;
	kstat_named_t   rxMcastPkts;
	kstat_named_t   rxBcastPkts;
	kstat_named_t   txUcastBytes;
	kstat_named_t	txMcastBytes;
	kstat_named_t	txBcastBytes;
	kstat_named_t   txUcastPkts;
	kstat_named_t	txMcastPkts;
	kstat_named_t	txBcastPkts;
	kstat_named_t	rx64bytePkts;
	kstat_named_t   rx127bytePkts;
	kstat_named_t   rx255bytePkts;
	kstat_named_t   rx511bytePkts;
	kstat_named_t   rx1023bytePkts;
	kstat_named_t   rx1518bytePkts;
	kstat_named_t   rx1522bytePkts;
	kstat_named_t   rx2047bytePkts;
	kstat_named_t   rx4095bytePkts;
	kstat_named_t   rx9216bytePkts;
	kstat_named_t   rx16383bytePkts;
	kstat_named_t   tx64bytePkts;
	kstat_named_t   tx64to127bytePkts;
	kstat_named_t   tx128to255bytePkts;
	kstat_named_t   tx256to511bytePkts;
	kstat_named_t   tx512to1023bytePkts;
	kstat_named_t   tx1024to1518bytePkts;
	kstat_named_t   tx1519to2047bytePkts;
	kstat_named_t   tx2048to4095bytePkts;
	kstat_named_t   tx4096to9216bytePkts;
	kstat_named_t   tx9217to16383bytePkts;
	kstat_named_t	rxMacCtrlFrames;
	kstat_named_t   rxPauseFrames;
	kstat_named_t   txPauseFrames;
	kstat_named_t   rxCRCerrors;
	kstat_named_t   rxAlignErrors;
	kstat_named_t   rxCarrierErrors;
 	kstat_named_t	rxOversizeErrors;
	kstat_named_t   rxJabbers;
	kstat_named_t   rxUndersizePkts;
	kstat_named_t   rxFragments;
	kstat_named_t   txLpiEntryCnt;
	kstat_named_t   txTotalCollisions;
	kstat_named_t   brbTruncates;
	kstat_named_t   noBuffDiscards;
	kstat_named_t   mftagFilterDiscards;
	kstat_named_t   macFilterDiscards;
	kstat_named_t   txErrDropPkts;
	kstat_named_t   coalescedPkts;
	kstat_named_t	coalescedEvents;
	kstat_named_t   coalescedAbortsNum;
	kstat_named_t	nonCoalescedPkts;
	kstat_named_t	coalescedBytes;
} qede_kstat_vport_stats_t;

#define QEDE_KSTAT_VPORT_STATS_SIZE \
	(sizeof (qede_kstat_vport_stats_t) / sizeof (kstat_named_t))

typedef struct _qede_kstat_rxq  {
	kstat_named_t rxqBdTotal;
    	kstat_named_t rxqBdLeft;
    	kstat_named_t rxqBdPageCnt;
    	kstat_named_t rxqBdsPerPage;
    	kstat_named_t rxqBdSize;
    	kstat_named_t rxqBdProdIdx;
    	kstat_named_t rxqBdConsIdx;
    	kstat_named_t rcqBdTotal;
    	kstat_named_t rcqBdLeft;
    	kstat_named_t rcqBdPageCnt;
    	kstat_named_t rcqBdsPerPage;
	kstat_named_t rcqBdSize;
    	kstat_named_t rcqBdProdIdx;
    	kstat_named_t rcqBdConsIdx;
    	kstat_named_t hwRcqConIdx;
    	kstat_named_t rxFreeDescs;
    	kstat_named_t rxActiveDescs;
    	kstat_named_t rxCopyPkts;
    	kstat_named_t rxDropPkts;
    	kstat_named_t rxBufUpInStack;
    	kstat_named_t rxLowWater;
    	kstat_named_t rxLowWaterCnt;
    	kstat_named_t inPollMode;
    	kstat_named_t rxPollCnt;
    	kstat_named_t intrDisableCnt;
    	kstat_named_t intrEnableCnt;
    	kstat_named_t genNumber;
    	kstat_named_t rxRegPkts;
    	kstat_named_t rxJumboPkts;
    	kstat_named_t rxLroPkts;
    	kstat_named_t rxRingTotalPkts;
    	kstat_named_t rxRingTotalBytes;
} qede_kstat_rxq_t;

#define QEDE_KSTAT_RXQ_SIZE \
	(sizeof (qede_kstat_rxq_t) / sizeof (kstat_named_t))

typedef struct _qede_kstat_txq {
	kstat_named_t txBdTotal;
    	kstat_named_t txBdLeft;
    	kstat_named_t txBdPageCnt;
    	kstat_named_t txBdsPerPage;
    	kstat_named_t txBdSize;
    	kstat_named_t hwTxqConIdx;
    	kstat_named_t txBdProdIdx;
    	kstat_named_t txBdConsIdx;
    	kstat_named_t txLowWater;
    	kstat_named_t txRingPause;
    	kstat_named_t txDropPkts;
    	kstat_named_t txCopyPkts;
    	kstat_named_t txBind;
    	kstat_named_t txBindFail;
    	kstat_named_t txPremapped;
    	kstat_named_t txPremappedFail;
    	kstat_named_t txTooManyCookies;
    	kstat_named_t txPullupPkts;
    	kstat_named_t txLsoPkts;
    	kstat_named_t txTooManyMblks;
    	kstat_named_t txMappedPkts;
    	kstat_named_t txJumboPkts;
    	kstat_named_t txRingTotalPkts;
    	kstat_named_t txRingTotalBytes;
} qede_kstat_txq_t;

#define  QEDE_KSTAT_TXQ_SIZE \
	(sizeof (qede_kstat_txq_t) / sizeof (kstat_named_t))


static int
qede_kstat_update(kstat_t *kstats,
    int rw)
{

	qede_kstat_t *pStats = (qede_kstat_t *)kstats->ks_data;
	qede_t *qede = (qede_t *)kstats->ks_private;
	struct ecore_dev *edev = &qede->edev;
        qede_fastpath_t *fp = &qede->fp_array[0];
	qede_rx_ring_t *rx_ring;
	qede_tx_ring_t *tx_ring;
	int i, j;
	char buf[17];

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

	mutex_enter(&qede->kstat_lock);

	snprintf(buf, sizeof (buf), "%16p", (void *)qede);
	strncpy(pStats->qede_hi.value.c, &buf[0], 8);
	pStats->qede_hi.value.c[8] = 0;
	strncpy(pStats->qede_lo.value.c, &buf[8], 8);
	pStats->qede_lo.value.c[8] = 0;


	strncpy(pStats->version.value.c,
	    qede->version,   sizeof (pStats->version.value.c));
	strncpy(pStats->versionFW.value.c,
	    qede->versionFW, sizeof (pStats->versionFW.value.c));
    	strncpy(pStats->versionMFW.value.c,
	    qede->versionMFW, sizeof (pStats->versionMFW.value.c));

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

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

	strncpy(pStats->multiFunction.value.c,
	    ((edev->mf_mode == ECORE_MF_DEFAULT)    ? "DEFAULT"  :
	    (edev->mf_mode == ECORE_MF_OVLAN)   ? "MF-OVLAN" : "Unknown"),
	    sizeof (pStats->multiFunction.value.c));

	pStats->multiFunctionVnics.value.ui64 = 0;

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


	pStats->hwInitDone.value.ui64 =
	    (qede->attach_resources & QEDE_ECORE_HW_INIT)? 1 :  0;
	  /*pStats->numVports.value.ui64 =
	    p_hwfn->hw_info.resc_num[ECORE_VPORT]; */
	pStats->numVports.value.ui64 =  edev->num_hwfns;
	pStats->vportID.value.ui64 = qede->vport_params[0].vport_id;


	strncpy(pStats->intrAlloc.value.c,
	    qede->intrAlloc, sizeof (pStats->intrAlloc.value.c));

	pStats->intrFired.value.ui64 = qede->intrFired;
	pStats->lroEnabled.value.ui64 = qede->lro_enable;
	pStats->lsoEnabled.value.ui64 = qede->lso_enable;
	pStats->jumboEnabled.value.ui64 = qede->jumbo_enable;

	qede->rxTotalPkts = 0;
	qede->rxTotalBytes = 0;
	qede->rxTotalDiscards = 0;
	qede->txTotalPkts = 0;
	qede->txTotalBytes = 0;
	qede->txTotalDiscards = 0;
	qede->allocbFailures = 0;
	for (i = 0; i < qede->num_fp; i++, fp++) {
		rx_ring = fp->rx_ring;
		qede->rxTotalPkts += rx_ring->rx_pkt_cnt;
		qede->rxTotalBytes += rx_ring->rx_byte_cnt;
		qede->rxTotalDiscards += rx_ring->rx_drop_cnt;
		for (j = 0; j < qede->num_tc; j++) {
			tx_ring = fp->tx_ring[j];
			qede->txTotalPkts += tx_ring->tx_pkt_count;
			qede->txTotalBytes += tx_ring->tx_byte_count;
			qede->txTotalDiscards += tx_ring->tx_pkt_dropped;
		}
	}
	pStats->rxTotalPkts.value.ui64 = qede->rxTotalPkts;
	pStats->rxTotalBytes.value.ui64 = qede->rxTotalBytes;
	pStats->rxTotalDiscards.value.ui64 = qede->rxTotalDiscards;
	pStats->txTotalPkts.value.ui64 = qede->txTotalPkts;
	pStats->txTotalBytes.value.ui64 = qede->txTotalBytes;
	pStats->txTotalDiscards.value.ui64 = qede->txTotalDiscards;
	pStats->allocbFailures.value.ui64 = qede->allocbFailures;

       mutex_exit(&qede->kstat_lock);
       return (0);

}

static int
qede_kstat_link_update(kstat_t *kstats, int rw)
{
	qede_kstat_link_t *pStats = (qede_kstat_link_t *)kstats->ks_data;
	qede_t *qede = (qede_t *)kstats->ks_private;
	struct ecore_dev *edev = &qede->edev;

	if (rw == KSTAT_WRITE) {
		return EACCES;
	}
	mutex_enter(&qede->kstat_lock);

	pStats->vportID.value.ui64 = qede->vport_params[0].vport_id;
	pStats->uptime.value.ui64  = (qede->props.link_speed) ?
                                     (ddi_get_time() - qede->props.uptime) : 0;
	pStats->mtuL2.value.ui64   = qede->mtu;
	pStats->speed.value.ui64   = qede->props.link_speed;
	pStats->link.value.ui64    = qede->params.link_state;
	pStats->duplex.value.ui64  = qede->props.link_duplex;
	pStats->pauseRx.value.ui64 = qede->props.rx_pause;
	pStats->pauseTx.value.ui64 = qede->props.tx_pause;

	mutex_exit(&qede->kstat_lock);
	return (0);
}

static int
qede_kstat_intr_update(kstat_t *kstats, int rw)
{

	qede_kstat_intr_t * pStats = (qede_kstat_intr_t *)kstats->ks_data;
	qede_t *qede = (qede_t *)kstats->ks_private;
	struct ecore_dev *edev = &qede->edev;

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

	mutex_enter(&qede->kstat_lock);


	strncpy(pStats->intrAlloc.value.c,
	    qede->intrAlloc, sizeof (pStats->intrAlloc.value.c));

	pStats->intrFired.value.ui64      = qede->intrFired;

	pStats->sb_00.value.ui64          = qede->intrSbCnt[0];
	pStats->sb_01.value.ui64          = qede->intrSbCnt[1];
	pStats->sb_02.value.ui64          = qede->intrSbCnt[2];
	pStats->sb_03.value.ui64          = qede->intrSbCnt[3];
	pStats->sb_04.value.ui64          = qede->intrSbCnt[4];
	pStats->sb_05.value.ui64          = qede->intrSbCnt[5];
	pStats->sb_06.value.ui64          = qede->intrSbCnt[6];

	pStats->sb_nc_00.value.ui64       = qede->intrSbNoChangeCnt[0];
	pStats->sb_nc_01.value.ui64       = qede->intrSbNoChangeCnt[1];
	pStats->sb_nc_02.value.ui64       = qede->intrSbNoChangeCnt[2];
	pStats->sb_nc_03.value.ui64       = qede->intrSbNoChangeCnt[3];
	pStats->sb_nc_04.value.ui64       = qede->intrSbNoChangeCnt[4];
	pStats->sb_nc_05.value.ui64       = qede->intrSbNoChangeCnt[5];
	pStats->sb_nc_06.value.ui64       = qede->intrSbNoChangeCnt[6];


	pStats->sb_poll_00.value.ui64     = qede->intrSbPollCnt[0];
	pStats->sb_poll_01.value.ui64     = qede->intrSbPollCnt[1];
	pStats->sb_poll_02.value.ui64     = qede->intrSbPollCnt[2];
	pStats->sb_poll_03.value.ui64     = qede->intrSbPollCnt[3];
	pStats->sb_poll_04.value.ui64     = qede->intrSbPollCnt[4];
	pStats->sb_poll_05.value.ui64     = qede->intrSbPollCnt[5];
	pStats->sb_poll_06.value.ui64     = qede->intrSbPollCnt[6];

	pStats->sb_poll_nc_00.value.ui64  = qede->intrSbPollNoChangeCnt[0];
	pStats->sb_poll_nc_01.value.ui64  = qede->intrSbPollNoChangeCnt[1];
	pStats->sb_poll_nc_02.value.ui64  = qede->intrSbPollNoChangeCnt[2];
	pStats->sb_poll_nc_03.value.ui64  = qede->intrSbPollNoChangeCnt[3];
	pStats->sb_poll_nc_04.value.ui64  = qede->intrSbPollNoChangeCnt[4];
	pStats->sb_poll_nc_05.value.ui64  = qede->intrSbPollNoChangeCnt[5];
	pStats->sb_poll_nc_06.value.ui64  = qede->intrSbPollNoChangeCnt[6];


    mutex_exit(&qede->kstat_lock);

    return (0);
}

static int
qede_kstat_vport_stats_update(kstat_t *kstats, int rw)
{

	qede_kstat_vport_stats_t *pStats =
	    (qede_kstat_vport_stats_t *)kstats->ks_data;
	qede_t *qede = (qede_t *)kstats->ks_private;
	struct ecore_dev * edev = &qede->edev;
	struct ecore_eth_stats vstats;


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


	mutex_enter(&qede->kstat_lock);

	memset(&vstats, 0, sizeof (struct ecore_eth_stats));
	if(qede->qede_state == QEDE_STATE_STARTED) {
		ecore_get_vport_stats(edev, &vstats);
		memcpy(&qede->save_stats, &vstats,
		    sizeof (struct ecore_eth_stats));
	}

	pStats->rxUcastBytes.value.ui64 = vstats.common.rx_ucast_bytes;
	pStats->rxMcastBytes.value.ui64 = vstats.common.rx_mcast_bytes;
	pStats->rxBcastBytes.value.ui64 = vstats.common.rx_bcast_bytes;
	pStats->rxUcastPkts.value.ui64 = vstats.common.rx_ucast_pkts;
	pStats->rxMcastPkts.value.ui64 = vstats.common.rx_mcast_pkts;
	pStats->rxBcastPkts.value.ui64 = vstats.common.rx_bcast_pkts;
	pStats->txUcastBytes.value.ui64 = vstats.common.tx_ucast_bytes;
	pStats->txMcastBytes.value.ui64 = vstats.common.tx_mcast_bytes;
	pStats->txBcastBytes.value.ui64 = vstats.common.tx_bcast_bytes;
	pStats->txUcastPkts.value.ui64 = vstats.common.tx_ucast_pkts;
	pStats->txMcastPkts.value.ui64 = vstats.common.tx_mcast_pkts;
	pStats->txBcastPkts.value.ui64 = vstats.common.tx_bcast_pkts;
	pStats->rx64bytePkts.value.ui64 = vstats.common.rx_64_byte_packets;
	pStats->rx127bytePkts.value.ui64 =
	    vstats.common.rx_65_to_127_byte_packets;
	pStats->rx255bytePkts.value.ui64 =
	    vstats.common.rx_128_to_255_byte_packets;
	pStats->rx511bytePkts.value.ui64 =
	    vstats.common.rx_256_to_511_byte_packets;
	pStats->rx1023bytePkts.value.ui64 =
	    vstats.common.rx_512_to_1023_byte_packets;
	pStats->rx1518bytePkts.value.ui64 =
	    vstats.common.rx_1024_to_1518_byte_packets;
	pStats->rx1522bytePkts.value.ui64 =
	    vstats.bb.rx_1519_to_1522_byte_packets;
	pStats->rx2047bytePkts.value.ui64 =
	    vstats.bb.rx_1519_to_2047_byte_packets;
	pStats->rx4095bytePkts.value.ui64 =
	    vstats.bb.rx_2048_to_4095_byte_packets;
	pStats->rx9216bytePkts.value.ui64 =
	    vstats.bb.rx_4096_to_9216_byte_packets;
	pStats->rx16383bytePkts.value.ui64 =
	    vstats.bb.rx_9217_to_16383_byte_packets;
	pStats->tx64bytePkts.value.ui64 =
	    vstats.common.tx_64_byte_packets;
	pStats->tx64to127bytePkts.value.ui64 =
	    vstats.common.tx_65_to_127_byte_packets;
	pStats->tx128to255bytePkts.value.ui64 =
	    vstats.common.tx_128_to_255_byte_packets;
	pStats->tx256to511bytePkts.value.ui64 =
	    vstats.common.tx_256_to_511_byte_packets;
	pStats->tx512to1023bytePkts.value.ui64 =
	    vstats.common.tx_512_to_1023_byte_packets;
	pStats->tx1024to1518bytePkts.value.ui64 =
	    vstats.common.tx_1024_to_1518_byte_packets;
	pStats->tx1519to2047bytePkts.value.ui64 =
	    vstats.bb.tx_1519_to_2047_byte_packets;
	pStats->tx2048to4095bytePkts.value.ui64 =
	    vstats.bb.tx_2048_to_4095_byte_packets;
	pStats->tx4096to9216bytePkts.value.ui64 =
	    vstats.bb.tx_4096_to_9216_byte_packets;
	pStats->tx9217to16383bytePkts.value.ui64 =
	    vstats.bb.tx_9217_to_16383_byte_packets;
	pStats->rxMacCtrlFrames.value.ui64 =
	    vstats.common.rx_mac_crtl_frames;
	pStats->rxPauseFrames.value.ui64 =
	    vstats.common.rx_pause_frames;
	pStats->txPauseFrames.value.ui64 =
	    vstats.common.tx_pause_frames;
	pStats->rxCRCerrors.value.ui64 =
	    vstats.common.rx_crc_errors;
	pStats->rxAlignErrors.value.ui64 =
	    vstats.common.rx_align_errors;
	pStats->rxCarrierErrors.value.ui64 =
	    vstats.common.rx_carrier_errors;
	pStats->rxOversizeErrors.value.ui64 =
	    vstats.common.rx_oversize_packets;
	pStats->rxJabbers.value.ui64 =
	    vstats.common.rx_jabbers;
	pStats->rxUndersizePkts.value.ui64 =
	    vstats.common.rx_undersize_packets;
	pStats->rxFragments.value.ui64 =
	    vstats.common.rx_fragments;
	pStats->txLpiEntryCnt.value.ui64 =
	    vstats.bb.tx_lpi_entry_count;
	pStats->txTotalCollisions.value.ui64 =
	    vstats.bb.tx_total_collisions;
	pStats->brbTruncates.value.ui64 =
	    vstats.common.brb_truncates;
	pStats->noBuffDiscards.value.ui64 =
	    vstats.common.no_buff_discards;
	pStats->mftagFilterDiscards.value.ui64 =
	    vstats.common.mftag_filter_discards;
	pStats->macFilterDiscards.value.ui64 =
	    vstats.common.mac_filter_discards;
	pStats->txErrDropPkts.value.ui64 =
	    vstats.common.tx_err_drop_pkts;
	pStats->coalescedPkts.value.ui64 =
	    vstats.common.tpa_coalesced_pkts;
	pStats->coalescedEvents.value.ui64 =
	    vstats.common.tpa_coalesced_events;
	pStats->coalescedAbortsNum.value.ui64 =
	    vstats.common.tpa_aborts_num;
	pStats->nonCoalescedPkts.value.ui64 =
	    vstats.common.tpa_not_coalesced_pkts;
	pStats->coalescedBytes.value.ui64 =
	    vstats.common.tpa_coalesced_bytes;

	mutex_exit(&qede->kstat_lock);

	return (0);
}

static int
qede_kstat_rxq_update(kstat_t *kstats, int rw)
{

	qede_kstat_rxq_t *pStats = (qede_kstat_rxq_t *)kstats->ks_data;
	KstatRingMap *pMap   = (KstatRingMap *)kstats->ks_private;
	qede_t *qede    = (qede_t *)pMap->qede;
	int idx    = pMap->idx;
	struct ecore_dev *edev = &qede->edev;
	qede_rx_ring_t *rx_ring = &qede->rx_array[idx];


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


	mutex_enter(&qede->kstat_lock);

	pStats->rxqBdTotal.value.ui64     = qede->rx_ring_size;
	pStats->rcqBdTotal.value.ui64  = qede->rx_ring_size;
	pStats->rxLowWater.value.ui64     = rx_ring->rx_low_buffer_threshold;

	if(qede->qede_state == QEDE_STATE_STARTED) {

	pStats->rxqBdLeft.value.ui64     =
	    ecore_chain_get_elem_left(&rx_ring->rx_bd_ring);
	pStats->rxqBdPageCnt.value.ui64   =
	    ECORE_CHAIN_PAGE_CNT(qede->rx_ring_size,
	    sizeof (struct eth_rx_bd), ECORE_CHAIN_MODE_NEXT_PTR);
	pStats->rxqBdsPerPage.value.ui64  =
	    ELEMS_PER_PAGE(sizeof (struct eth_rx_bd));
	pStats->rxqBdSize.value.ui64     = sizeof (struct eth_rx_bd);
	pStats->rxqBdProdIdx.value.ui64     =
	    ecore_chain_get_prod_idx(&rx_ring->rx_bd_ring) &
	    (rx_ring->qede->rx_ring_size - 1);
	pStats->rxqBdConsIdx.value.ui64     =
	    ecore_chain_get_cons_idx(&rx_ring->rx_bd_ring) &
	    (rx_ring->qede->rx_ring_size - 1);
	pStats->rcqBdLeft.value.ui64      =
	    ecore_chain_get_elem_left(&rx_ring->rx_cqe_ring);
	pStats->rcqBdPageCnt.value.ui64   =
	    ECORE_CHAIN_PAGE_CNT(qede->rx_ring_size,
	    sizeof (union eth_rx_cqe), ECORE_CHAIN_MODE_PBL);
	pStats->rcqBdsPerPage.value.ui64  =
	    ELEMS_PER_PAGE(sizeof (union eth_rx_cqe));
	pStats->rcqBdSize.value.ui64      = sizeof (union eth_rx_cqe);
	pStats->rcqBdProdIdx.value.ui64   =
	    ecore_chain_get_prod_idx(&rx_ring->rx_cqe_ring) &
	    (rx_ring->qede->rx_ring_size - 1);
	pStats->rcqBdConsIdx.value.ui64   =
	    ecore_chain_get_cons_idx(&rx_ring->rx_cqe_ring) &
	    (rx_ring->qede->rx_ring_size - 1);
	pStats->hwRcqConIdx.value.ui64    =
	    (rx_ring->hw_cons_ptr != NULL) ?
	    HOST_TO_LE_16(*rx_ring->hw_cons_ptr) &
	    (rx_ring->qede->rx_ring_size - 1): 0;
	pStats->rxFreeDescs.value.ui64    =
	    rx_ring->rx_buf_area->passive_buf_list.num_entries;
	pStats->rxActiveDescs.value.ui64  =
	    rx_ring->rx_buf_area->active_buf_list.num_entries;
	pStats->rxBufUpInStack.value.ui64 =
	    rx_ring->rx_buf_area->buf_upstream;
	pStats->rxCopyPkts.value.ui64       =
	    rx_ring->rx_copy_cnt;
	pStats->rxDropPkts.value.ui64     =
	    rx_ring->rx_drop_cnt;
	pStats->rxLowWaterCnt.value.ui64     =
	    rx_ring->rx_low_water_cnt;
	pStats->inPollMode.value.ui64     =
	    rx_ring->fp->disabled_by_poll;
	pStats->rxPollCnt.value.ui64      =
	    rx_ring->rx_poll_cnt;;
	pStats->intrDisableCnt.value.ui64 =
	    rx_ring->intrDisableCnt;
	pStats->intrEnableCnt.value.ui64  =
	    rx_ring->intrEnableCnt;
	pStats->genNumber.value.ui64      =
	    rx_ring->mr_gen_num;
	pStats->rxLroPkts.value.ui64    =
	    rx_ring->rx_lro_pkt_cnt;
	pStats->rxRingTotalPkts.value.ui64    =
	    rx_ring->rx_pkt_cnt;
	pStats->rxRingTotalBytes.value.ui64    =
	    rx_ring->rx_byte_cnt;
	pStats->rxRegPkts.value.ui64    =
	    rx_ring->rx_reg_pkt_cnt;
	pStats->rxJumboPkts.value.ui64    =
	    rx_ring->rx_jumbo_pkt_cnt;

	} else {

	pStats->rxqBdLeft.value.ui64     = 0;
	pStats->rxqBdPageCnt.value.ui64   = 0;
	pStats->rxqBdsPerPage.value.ui64  = 0;
	pStats->rxqBdSize.value.ui64     = 0;
	pStats->rxqBdProdIdx.value.ui64     = 0;
	pStats->rxqBdConsIdx.value.ui64     = 0;
	pStats->rcqBdLeft.value.ui64      = 0;
	pStats->rcqBdPageCnt.value.ui64   = 0;
	pStats->rcqBdsPerPage.value.ui64  = 0;
	pStats->rcqBdSize.value.ui64      = 0;
	pStats->rcqBdProdIdx.value.ui64   = 0;
	pStats->rcqBdConsIdx.value.ui64   = 0;
	pStats->hwRcqConIdx.value.ui64    = 0;
	pStats->rxFreeDescs.value.ui64    = 0;
	pStats->rxActiveDescs.value.ui64  = 0;
	pStats->rxBufUpInStack.value.ui64 = 0;
	pStats->rxCopyPkts.value.ui64       = 0;
	pStats->rxDropPkts.value.ui64     = 0;
	pStats->rxLowWaterCnt.value.ui64     = 0;
	pStats->inPollMode.value.ui64     = 0;
	pStats->rxPollCnt.value.ui64      = 0;
	pStats->intrDisableCnt.value.ui64 = 0;
	pStats->intrEnableCnt.value.ui64  = 0;
	pStats->genNumber.value.ui64      = 0;
	pStats->rxLroPkts.value.ui64    = 0;
	pStats->rxRingTotalPkts.value.ui64  = 0;
	pStats->rxRingTotalBytes.value.ui64       = 0;
	pStats->rxRegPkts.value.ui64    = 0;
	pStats->rxJumboPkts.value.ui64  = 0;
	}

	mutex_exit(&qede->kstat_lock);
	return (0);
}


static int
qede_kstat_txq_update(kstat_t *kstats, int rw)
{

	qede_kstat_txq_t *pStats = (qede_kstat_txq_t *)kstats->ks_data;
	KstatRingMap *pMap   = (KstatRingMap *)kstats->ks_private;
	qede_t *qede    = (qede_t *)pMap->qede;
	int idx    = pMap->idx;
	struct ecore_dev * edev = &qede->edev;
	qede_tx_ring_t *tx_ring = &qede->tx_array[0][idx];


	if (rw == KSTAT_WRITE) {
        	return EACCES;
	}
	mutex_enter(&qede->kstat_lock);

	pStats->txBdTotal.value.ui64     =  qede->tx_ring_size;
	pStats->txBdSize.value.ui64 = sizeof (union eth_tx_bd_types);
	pStats->txLowWater.value.ui64    = qede->tx_recycle_threshold;

	if(qede->qede_state == QEDE_STATE_STARTED) {

	pStats->txBdLeft.value.ui64     =
	    ecore_chain_get_elem_left(&tx_ring->tx_bd_ring);
	pStats->txBdPageCnt.value.ui64  =
	    ECORE_CHAIN_PAGE_CNT(tx_ring->bd_ring_size,
	    sizeof (union eth_tx_bd_types), ECORE_CHAIN_MODE_PBL);
	pStats->txBdsPerPage.value.ui64 =
	    ELEMS_PER_PAGE(sizeof (union eth_tx_bd_types));
	pStats->hwTxqConIdx.value.ui64 =
	    (tx_ring->hw_cons_ptr != NULL) ?
	    HOST_TO_LE_16(*tx_ring->hw_cons_ptr) & TX_RING_MASK : 0;
	pStats->txBdProdIdx.value.ui64 =
	    ecore_chain_get_prod_idx(&tx_ring->tx_bd_ring) & TX_RING_MASK;
	pStats->txBdConsIdx.value.ui64 =
	    ecore_chain_get_cons_idx(&tx_ring->tx_bd_ring) & TX_RING_MASK;
 	pStats->txRingPause.value.ui64      =
	    tx_ring->tx_ring_pause;
	pStats->txDropPkts.value.ui64    = tx_ring->tx_pkt_dropped;
	pStats->txCopyPkts.value.ui64      = tx_ring->tx_copy_count;
	pStats->txBind.value.ui64        = tx_ring->tx_bind_count;
	pStats->txBindFail.value.ui64    = tx_ring->tx_bind_fail;
	pStats->txPremapped.value.ui64      = tx_ring->tx_premap_count;
	pStats->txPremappedFail.value.ui64   = tx_ring->tx_premap_fail;
	pStats->txTooManyCookies.value.ui64   = tx_ring->tx_too_many_cookies;
	pStats->txPullupPkts.value.ui64   = tx_ring->tx_pullup_count;
	pStats->txLsoPkts.value.ui64   = tx_ring->tx_lso_pkt_count;
	pStats->txTooManyMblks.value.ui64   = tx_ring->tx_too_many_mblks;
	pStats->txMappedPkts.value.ui64   = tx_ring->tx_mapped_pkts;
	pStats->txRingTotalPkts.value.ui64    = tx_ring->tx_pkt_count;
	pStats->txRingTotalBytes.value.ui64    = tx_ring->tx_byte_count;
	pStats->txJumboPkts.value.ui64   = tx_ring->tx_jumbo_pkt_count;


  	} else {


	pStats->txBdLeft.value.ui64     = 0;
	pStats->txBdPageCnt.value.ui64     = 0;
	pStats->txBdsPerPage.value.ui64     = 0;
	pStats->hwTxqConIdx.value.ui64 = 0;
	pStats->txBdProdIdx.value.ui64   = 0;
	pStats->txBdConsIdx.value.ui64   = 0;
	pStats->txRingPause.value.ui64        = 0;
	pStats->txDropPkts.value.ui64    = 0;
	pStats->txCopyPkts.value.ui64      = 0;
	pStats->txBind.value.ui64        = 0;
	pStats->txBindFail.value.ui64    = 0;
	pStats->txPremapped.value.ui64   = 0;
	pStats->txPremappedFail.value.ui64  = 0;
	pStats->txTooManyCookies.value.ui64  = 0;
	pStats->txPullupPkts.value.ui64   = 0;
	pStats->txLsoPkts.value.ui64   = 0;
	pStats->txTooManyMblks.value.ui64  = 0;
	pStats->txMappedPkts.value.ui64   = 0;
	pStats->txJumboPkts.value.ui64   = 0;
	pStats->txRingTotalPkts.value.ui64    = 0;
	pStats->txRingTotalBytes.value.ui64    = 0;
	}

	mutex_exit(&qede->kstat_lock);
	return (0);
}

boolean_t
qede_kstat_init_rxq(qede_t *qede, int idx)
{

	char buf[32];

	qede_kstat_rxq_t *pStatsRxq;

#define QEDE_KSTAT_RXQ(f, t)  kstat_named_init(&pStatsRxq->f, #f, t)

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

	if ((qede->kstats_rxq[idx] = kstat_create("qede",
	    qede->instance,
	    buf,
	    "net",
	    KSTAT_TYPE_NAMED,
	    QEDE_KSTAT_RXQ_SIZE,
	    0)) == NULL)
	{
        	/*BnxeLogWarn(qede, "Failed to create rxq%d kstat", idx);*/
		cmn_err(CE_WARN, "Failed to create rxq%d kstat", idx);
        	return (B_FALSE);
	}
        pStatsRxq = (qede_kstat_rxq_t *)qede->kstats_rxq[idx]->ks_data;

	QEDE_KSTAT_RXQ(rxqBdTotal,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxqBdLeft,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxqBdPageCnt,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxqBdsPerPage,  KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxqBdSize,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxqBdProdIdx,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxqBdConsIdx,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rcqBdTotal,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rcqBdLeft,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rcqBdPageCnt,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rcqBdsPerPage,  KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rcqBdSize,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rcqBdProdIdx,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rcqBdConsIdx,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(hwRcqConIdx,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxFreeDescs,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxActiveDescs,  KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxCopyPkts,       KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxDropPkts,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxBufUpInStack, KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxLowWater,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxLowWaterCnt,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(inPollMode,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxPollCnt,        KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(intrDisableCnt, KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(intrEnableCnt,  KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(genNumber,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxRegPkts,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxJumboPkts,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxLroPkts,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxRingTotalPkts,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_RXQ(rxRingTotalBytes,      KSTAT_DATA_UINT64);


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

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

	kstat_install(qede->kstats_rxq[idx]);

	return (B_TRUE);
}


boolean_t
qede_kstat_init_txq(qede_t *qede, int idx)
{
	char buf[32];

	qede_kstat_txq_t *pStatsTxq;

#define QEDE_KSTAT_TXQ(f, t)  kstat_named_init(&pStatsTxq->f, #f, t)

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

        if ((qede->kstats_txq[idx] = kstat_create("qede",
	    qede->instance,
	    buf,
	    "net",
	    KSTAT_TYPE_NAMED,
	    QEDE_KSTAT_TXQ_SIZE,
	    0)) == NULL)  {
        	/*BnxeLogWarn(qede, "Failed to create txq%d kstat", idx);*/
		cmn_err(CE_WARN, "Failed to create txq%d kstat", idx);
        	return (B_FALSE);
	}


	pStatsTxq = (qede_kstat_txq_t *)qede->kstats_txq[idx]->ks_data;

	QEDE_KSTAT_TXQ(txBdTotal,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txBdLeft,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txBdPageCnt,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txBdsPerPage,  KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txBdSize,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(hwTxqConIdx,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txBdProdIdx,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txBdConsIdx,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txLowWater,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txDropPkts,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txCopyPkts,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txRingPause,        KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txDropPkts,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txBind,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txBindFail,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txPremapped,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txPremappedFail,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txTooManyCookies,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txPullupPkts,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txLsoPkts,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txTooManyMblks,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txMappedPkts,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txJumboPkts,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txRingTotalPkts,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_TXQ(txRingTotalBytes,      KSTAT_DATA_UINT64);

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

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

	kstat_install(qede->kstats_txq[idx]);

	return (B_TRUE);

}

boolean_t
qede_kstat_init(qede_t *qede)
{
	qede_kstat_t *pStats;
	qede_kstat_link_t *pStatsLink;
	qede_kstat_intr_t *pStatsIntr;
	qede_kstat_vport_stats_t *pStatsVport;
	int i;

#define QEDE_KSTAT(f, t)            kstat_named_init(&pStats->f, #f, t)
#define QEDE_KSTAT_LINK(f, t)       kstat_named_init(&pStatsLink->f, #f, t)
#define QEDE_KSTAT_INTR(f, t)       kstat_named_init(&pStatsIntr->f, #f, t)
#define QEDE_KSTAT_VPORT(f,t)	    kstat_named_init(&pStatsVport->f, #f, t)


	if ((qede->kstats = kstat_create("qede",
	    qede->instance,
	    "stats",
	    "net",
	    KSTAT_TYPE_NAMED,
	    QEDE_KSTAT_SIZE,
	    0)) == NULL) {
        	/*QedeLogWarn(qede, "Failed to create kstat");*/
		cmn_err(CE_WARN, "Failed to create kstat");
        	return (B_FALSE);
	}

	pStats = (qede_kstat_t *)qede->kstats->ks_data;
	QEDE_KSTAT(qede_hi, KSTAT_DATA_CHAR);
	QEDE_KSTAT(qede_lo, KSTAT_DATA_CHAR);
	QEDE_KSTAT(version, KSTAT_DATA_CHAR);
	QEDE_KSTAT(versionFW, KSTAT_DATA_CHAR);
	QEDE_KSTAT(versionMFW, KSTAT_DATA_CHAR);
	QEDE_KSTAT(chipID, KSTAT_DATA_CHAR);
	QEDE_KSTAT(chipName, KSTAT_DATA_CHAR);
	QEDE_KSTAT(devBDF, KSTAT_DATA_CHAR);
	QEDE_KSTAT(devID, KSTAT_DATA_CHAR);
	QEDE_KSTAT(multiFunction, KSTAT_DATA_CHAR);
	QEDE_KSTAT(multiFunctionVnics, KSTAT_DATA_UINT64);
	QEDE_KSTAT(macAddr, KSTAT_DATA_CHAR);
	QEDE_KSTAT(hwInitDone, KSTAT_DATA_UINT64);
	QEDE_KSTAT(numVports, KSTAT_DATA_UINT64);
	QEDE_KSTAT(vportID, KSTAT_DATA_UINT64);
	QEDE_KSTAT(intrAlloc, KSTAT_DATA_CHAR);
	QEDE_KSTAT(intrFired, KSTAT_DATA_UINT64);
	QEDE_KSTAT(lroEnabled, KSTAT_DATA_UINT64);
	QEDE_KSTAT(lsoEnabled, KSTAT_DATA_UINT64);
	QEDE_KSTAT(jumboEnabled, KSTAT_DATA_UINT64);
	QEDE_KSTAT(txTotalPkts, KSTAT_DATA_UINT64);
	QEDE_KSTAT(txTotalBytes, KSTAT_DATA_UINT64);
	QEDE_KSTAT(txTotalDiscards, KSTAT_DATA_UINT64);
	QEDE_KSTAT(rxTotalPkts, KSTAT_DATA_UINT64);
	QEDE_KSTAT(rxTotalBytes, KSTAT_DATA_UINT64);
	QEDE_KSTAT(rxTotalDiscards, KSTAT_DATA_UINT64);
	QEDE_KSTAT(allocbFailures, KSTAT_DATA_UINT64);

	qede->kstats->ks_update  = qede_kstat_update;
	qede->kstats->ks_private = (void *)qede;

	kstat_install(qede->kstats);

	/****************************************************************/
	if ((qede->kstats_link = kstat_create("qede",
	    qede->instance,
	    "link",
	    "net",
	    KSTAT_TYPE_NAMED,
	    QEDE_KSTAT_LINK_SIZE,
	    0)) == NULL) {
        	/*BnxeLogWarn(qede, "Failed to create link kstat");*/
		cmn_err(CE_WARN, "Failed to create link kstat");
		qede_kstat_fini(qede);
        	return (B_FALSE);
	}

	pStatsLink = (qede_kstat_link_t *)qede->kstats_link->ks_data;

	QEDE_KSTAT_LINK(vportID, KSTAT_DATA_UINT64);
	QEDE_KSTAT_LINK(uptime,  KSTAT_DATA_UINT64);
	QEDE_KSTAT_LINK(mtuL2,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_LINK(speed,   KSTAT_DATA_UINT64);
	QEDE_KSTAT_LINK(link,    KSTAT_DATA_UINT64);
	QEDE_KSTAT_LINK(duplex,  KSTAT_DATA_UINT64);
	QEDE_KSTAT_LINK(pauseRx, KSTAT_DATA_UINT64);
	QEDE_KSTAT_LINK(pauseTx, KSTAT_DATA_UINT64);

	qede->kstats_link->ks_update  = qede_kstat_link_update;
	qede->kstats_link->ks_private = (void *)qede;

	kstat_install(qede->kstats_link);

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

        if ((qede->kstats_intr = kstat_create("qede",
	    qede->instance,
	    "intr",
	    "net",
	    KSTAT_TYPE_NAMED,
	    QEDE_KSTAT_INTR_SIZE,
	    0)) == NULL) {
        	/*BnxeLogWarn(qede, "Failed to create intr kstat");*/
		cmn_err(CE_WARN, "Failed to create intr kstat");
		qede_kstat_fini(qede);
        	return (B_FALSE);
	}


	pStatsIntr = (qede_kstat_intr_t *)qede->kstats_intr->ks_data;

	QEDE_KSTAT_INTR(intrAlloc,      KSTAT_DATA_CHAR);
	QEDE_KSTAT_INTR(intrFired,      KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_00,          KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_01,          KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_02,          KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_03,          KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_04,          KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_05,          KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_06,          KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_nc_00,       KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_nc_01,       KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_nc_02,       KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_nc_03,       KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_nc_04,       KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_nc_05,       KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_nc_06,       KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_poll_00,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_poll_01,     KSTAT_DATA_UINT64);
    	QEDE_KSTAT_INTR(sb_poll_02,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_poll_03,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_poll_04,     KSTAT_DATA_UINT64);
    	QEDE_KSTAT_INTR(sb_poll_05,     KSTAT_DATA_UINT64);
    	QEDE_KSTAT_INTR(sb_poll_06,     KSTAT_DATA_UINT64);
	QEDE_KSTAT_INTR(sb_poll_nc_00,  KSTAT_DATA_UINT64);
    	QEDE_KSTAT_INTR(sb_poll_nc_01,  KSTAT_DATA_UINT64);
    	QEDE_KSTAT_INTR(sb_poll_nc_02,  KSTAT_DATA_UINT64);
    	QEDE_KSTAT_INTR(sb_poll_nc_03,  KSTAT_DATA_UINT64);
    	QEDE_KSTAT_INTR(sb_poll_nc_04,  KSTAT_DATA_UINT64);
    	QEDE_KSTAT_INTR(sb_poll_nc_05,  KSTAT_DATA_UINT64);
    	QEDE_KSTAT_INTR(sb_poll_nc_06,  KSTAT_DATA_UINT64);

	qede->kstats_intr->ks_update  = qede_kstat_intr_update;
    	qede->kstats_intr->ks_private = (void *)qede;

    	kstat_install(qede->kstats_intr);


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

    	if ((qede->kstats_vport = kstat_create("qede",
	    qede->instance,
	    "L2Stats",
	    "net",
	    KSTAT_TYPE_NAMED,
	    QEDE_KSTAT_VPORT_STATS_SIZE,
	    0)) == NULL) {
        	/*BnxeLogWarn(qede, "Failed to create l2chip kstat");*/
		cmn_err(CE_WARN, "Failed to create L2Stats kstat");
		qede_kstat_fini(qede);
        	return (B_FALSE);
	}

	pStatsVport = (qede_kstat_vport_stats_t *)qede->kstats_vport->ks_data;

    	QEDE_KSTAT_VPORT(rxUcastBytes, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxMcastBytes, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxBcastBytes, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxUcastPkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxMcastPkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxBcastPkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txUcastBytes, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txMcastBytes, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txBcastBytes, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txUcastPkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txMcastPkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txBcastPkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx64bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx127bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx255bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx511bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx1023bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx1518bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx1518bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx1522bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx2047bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx4095bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx9216bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rx16383bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx64bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx64to127bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx128to255bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx256to511bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx512to1023bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx1024to1518bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx1519to2047bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx2048to4095bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx4096to9216bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(tx9217to16383bytePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxMacCtrlFrames, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxPauseFrames, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txPauseFrames, KSTAT_DATA_UINT64);
	QEDE_KSTAT_VPORT(rxCRCerrors, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxAlignErrors, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxCarrierErrors, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxOversizeErrors, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxJabbers, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxUndersizePkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(rxFragments, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txLpiEntryCnt, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txTotalCollisions, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(brbTruncates, KSTAT_DATA_UINT64);

    	QEDE_KSTAT_VPORT(noBuffDiscards, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(mftagFilterDiscards, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(macFilterDiscards, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(txErrDropPkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(coalescedPkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(coalescedEvents, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(coalescedAbortsNum, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(nonCoalescedPkts, KSTAT_DATA_UINT64);
    	QEDE_KSTAT_VPORT(coalescedBytes, KSTAT_DATA_UINT64);

    	qede->kstats_vport->ks_update  = qede_kstat_vport_stats_update;
    	qede->kstats_vport->ks_private = (void *)qede;

    	kstat_install(qede->kstats_vport);
    	for (i = 0; i < qede->num_fp; i++) {
		if(!qede_kstat_init_rxq(qede,i))
		{
			qede_kstat_fini(qede);
			return (B_FALSE);
		}
		if(!qede_kstat_init_txq(qede,i))
		{
			qede_kstat_fini(qede);
			return (B_FALSE);
		}

	}

	return (B_TRUE);

}

void
qede_kstat_fini(qede_t *qede)
{
	int i;

	if(qede->kstats) {
		kstat_delete(qede->kstats);
		qede->kstats = NULL;
	}
	if(qede->kstats_link) {
		kstat_delete(qede->kstats_link);
		qede->kstats_link = NULL;
	}
	if(qede->kstats_intr) {
		kstat_delete(qede->kstats_intr);
		qede->kstats_intr = NULL;
	}
	if(qede->kstats_vport) {
		kstat_delete(qede->kstats_vport);
		qede->kstats_vport = NULL;
	}


	for (i = 0; i < qede->num_fp; i++) {
		if(qede->kstats_rxq[i]) {
			kstat_delete(qede->kstats_rxq[i]);
			qede->kstats_rxq[i] = NULL;
		}
		qede->kstats_rxq_map[i].idx = 0;
		qede->kstats_rxq_map[i].qede = NULL;
		if(qede->kstats_txq[i]) {
			kstat_delete(qede->kstats_txq[i]);
			qede->kstats_txq[i] = NULL;
		}
		qede->kstats_txq_map[i].idx = 0;
		qede->kstats_txq_map[i].qede = NULL;
	}
}