/*
* 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;
        }
}