xref: /titanic_41/usr/src/uts/common/io/bnxe/bnxe_kstat.c (revision f391a51a4e9639750045473dba1cc2831267c93e)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2014 QLogic Corporation
24  * The contents of this file are subject to the terms of the
25  * QLogic End User License (the "License").
26  * You may not use this file except in compliance with the License.
27  *
28  * You can obtain a copy of the License at
29  * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/
30  * QLogic_End_User_Software_License.txt
31  * See the License for the specific language governing permissions
32  * and limitations under the License.
33  */
34 
35 /*
36  * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
37  */
38 
39 #include "bnxe.h"
40 
41 typedef struct _BnxeKstat
42 {
43     kstat_named_t umdev_hi;
44     kstat_named_t umdev_lo;
45     kstat_named_t version;
46     kstat_named_t versionFW;
47     kstat_named_t versionBC;
48     kstat_named_t chipName;
49     kstat_named_t chipID;
50     kstat_named_t devBDF;
51     kstat_named_t devID;
52     kstat_named_t multiFunction;
53     kstat_named_t multiFunctionVnics;
54     kstat_named_t macAddr;
55     kstat_named_t hwInitDone;
56     kstat_named_t clientsHw;
57     kstat_named_t clientsDevi;
58     kstat_named_t clientsBound;
59     kstat_named_t txMsgPullUp;
60     kstat_named_t intrAlloc;
61     kstat_named_t intrFired;
62     kstat_named_t timerFired;
63     kstat_named_t timerReply;
64     kstat_named_t timerNoReplyTotal;
65     kstat_named_t timerNoReplyCurrent;
66     kstat_named_t timerDone;
67     kstat_named_t workQueueInstCnt;
68     kstat_named_t workItemInstQueued;
69     kstat_named_t workItemInstError;
70     kstat_named_t workItemInstComplete;
71     kstat_named_t workItemInstHighWater;
72     kstat_named_t workQueueDelayCnt;
73     kstat_named_t workItemDelayQueued;
74     kstat_named_t workItemDelayError;
75     kstat_named_t workItemDelayComplete;
76     kstat_named_t workItemDelayHighWater;
77     kstat_named_t memAllocBlocks;
78     kstat_named_t memAllocDMAs;
79     kstat_named_t memAllocBARs;
80 } BnxeKstat;
81 
82 #define BNXE_KSTAT_SIZE (sizeof(BnxeKstat) / sizeof(kstat_named_t))
83 
84 typedef struct _BnxeKstatLink
85 {
86     kstat_named_t clients;
87     kstat_named_t uptime;
88     kstat_named_t mtuL2;
89     kstat_named_t mtuFCOE;
90     kstat_named_t speed;
91     kstat_named_t link;
92     kstat_named_t duplex;
93     kstat_named_t pauseRx;
94     kstat_named_t pauseTx;
95 } BnxeKstatLink;
96 
97 #define BNXE_KSTAT_LINK_SIZE (sizeof(BnxeKstatLink) / sizeof(kstat_named_t))
98 
99 typedef struct _BnxeKstatIntr
100 {
101     kstat_named_t intrAlloc;
102     kstat_named_t intrFired;
103     kstat_named_t intrWrongState;
104     kstat_named_t intrInDisabled;
105     kstat_named_t intrZeroStatus;
106     kstat_named_t sb_00;
107     kstat_named_t sb_01;
108     kstat_named_t sb_02;
109     kstat_named_t sb_03;
110     kstat_named_t sb_04;
111     kstat_named_t sb_05;
112     kstat_named_t sb_06;
113     kstat_named_t sb_07;
114     kstat_named_t sb_08;
115     kstat_named_t sb_09;
116     kstat_named_t sb_10;
117     kstat_named_t sb_11;
118     kstat_named_t sb_12;
119     kstat_named_t sb_13;
120     kstat_named_t sb_14;
121     kstat_named_t sb_15;
122     kstat_named_t sb_16;
123     kstat_named_t sb_nc_00;
124     kstat_named_t sb_nc_01;
125     kstat_named_t sb_nc_02;
126     kstat_named_t sb_nc_03;
127     kstat_named_t sb_nc_04;
128     kstat_named_t sb_nc_05;
129     kstat_named_t sb_nc_06;
130     kstat_named_t sb_nc_07;
131     kstat_named_t sb_nc_08;
132     kstat_named_t sb_nc_09;
133     kstat_named_t sb_nc_10;
134     kstat_named_t sb_nc_11;
135     kstat_named_t sb_nc_12;
136     kstat_named_t sb_nc_13;
137     kstat_named_t sb_nc_14;
138     kstat_named_t sb_nc_15;
139     kstat_named_t sb_nc_16;
140     kstat_named_t sb_poll_00;
141     kstat_named_t sb_poll_01;
142     kstat_named_t sb_poll_02;
143     kstat_named_t sb_poll_03;
144     kstat_named_t sb_poll_04;
145     kstat_named_t sb_poll_05;
146     kstat_named_t sb_poll_06;
147     kstat_named_t sb_poll_07;
148     kstat_named_t sb_poll_08;
149     kstat_named_t sb_poll_09;
150     kstat_named_t sb_poll_10;
151     kstat_named_t sb_poll_11;
152     kstat_named_t sb_poll_12;
153     kstat_named_t sb_poll_13;
154     kstat_named_t sb_poll_14;
155     kstat_named_t sb_poll_15;
156     kstat_named_t sb_poll_16;
157     kstat_named_t sb_poll_nc_00;
158     kstat_named_t sb_poll_nc_01;
159     kstat_named_t sb_poll_nc_02;
160     kstat_named_t sb_poll_nc_03;
161     kstat_named_t sb_poll_nc_04;
162     kstat_named_t sb_poll_nc_05;
163     kstat_named_t sb_poll_nc_06;
164     kstat_named_t sb_poll_nc_07;
165     kstat_named_t sb_poll_nc_08;
166     kstat_named_t sb_poll_nc_09;
167     kstat_named_t sb_poll_nc_10;
168     kstat_named_t sb_poll_nc_11;
169     kstat_named_t sb_poll_nc_12;
170     kstat_named_t sb_poll_nc_13;
171     kstat_named_t sb_poll_nc_14;
172     kstat_named_t sb_poll_nc_15;
173     kstat_named_t sb_poll_nc_16;
174 } BnxeKstatIntr;
175 
176 #define BNXE_KSTAT_INTR_SIZE (sizeof(BnxeKstatIntr) / sizeof(kstat_named_t))
177 
178 typedef struct _BnxeKstatL2Chip
179 {
180     kstat_named_t IfHCInOctets;
181     kstat_named_t IfHCInBadOctets;
182     kstat_named_t IfHCOutOctets;
183     kstat_named_t IfHCOutBadOctets;
184     kstat_named_t IfHCOutPkts;
185     kstat_named_t IfHCInPkts;
186     kstat_named_t IfHCInUcastPkts;
187     kstat_named_t IfHCInMulticastPkts;
188     kstat_named_t IfHCInBroadcastPkts;
189     kstat_named_t IfHCOutUcastPkts;
190     kstat_named_t IfHCOutMulticastPkts;
191     kstat_named_t IfHCOutBroadcastPkts;
192     kstat_named_t IfHCInUcastOctets;
193     kstat_named_t IfHCInMulticastOctets;
194     kstat_named_t IfHCInBroadcastOctets;
195     kstat_named_t IfHCOutUcastOctets;
196     kstat_named_t IfHCOutMulticastOctets;
197     kstat_named_t IfHCOutBroadcastOctets;
198     kstat_named_t IfHCOutDiscards;
199     kstat_named_t IfHCInFalseCarrierErrors;
200     kstat_named_t Dot3StatsInternalMacTransmitErrors;
201     kstat_named_t Dot3StatsCarrierSenseErrors;
202     kstat_named_t Dot3StatsFCSErrors;
203     kstat_named_t Dot3StatsAlignmentErrors;
204     kstat_named_t Dot3StatsSingleCollisionFrames;
205     kstat_named_t Dot3StatsMultipleCollisionFrames;
206     kstat_named_t Dot3StatsDeferredTransmissions;
207     kstat_named_t Dot3StatsExcessiveCollisions;
208     kstat_named_t Dot3StatsLateCollisions;
209     kstat_named_t EtherStatsCollisions;
210     kstat_named_t EtherStatsFragments;
211     kstat_named_t EtherStatsJabbers;
212     kstat_named_t EtherStatsUndersizePkts;
213     kstat_named_t EtherStatsOverrsizePkts;
214     kstat_named_t EtherStatsTx64Octets;
215     kstat_named_t EtherStatsTx65to127Octets;
216     kstat_named_t EtherStatsTx128to255Octets;
217     kstat_named_t EtherStatsTx256to511Octets;
218     kstat_named_t EtherStatsTx512to1023Octets;
219     kstat_named_t EtherStatsTx1024to1522Octets;
220     kstat_named_t EtherStatsTxOver1522Octets;
221     kstat_named_t XonPauseFramesReceived;
222     kstat_named_t XoffPauseFramesReceived;
223     kstat_named_t OutXonSent;
224     kstat_named_t OutXoffSent;
225     kstat_named_t FlowControlDone;
226     kstat_named_t MacControlFramesReceived;
227     kstat_named_t XoffStateEntered;
228     kstat_named_t IfInFramesL2FilterDiscards;
229     kstat_named_t IfInTTL0Discards;
230     kstat_named_t IfInxxOverflowDiscards;
231     kstat_named_t IfInMBUFDiscards;
232     kstat_named_t IfInErrors;
233     kstat_named_t IfInErrorsOctets;
234     kstat_named_t IfInNoBrbBuffer;
235     kstat_named_t NigBrbPacket;
236     kstat_named_t NigBrbTruncate;
237     kstat_named_t NigFlowCtrlDiscard;
238     kstat_named_t NigFlowCtrlOctets;
239     kstat_named_t NigFlowCtrlPacket;
240     kstat_named_t NigMngDiscard;
241     kstat_named_t NigMngOctetInp;
242     kstat_named_t NigMngOctetOut;
243     kstat_named_t NigMngPacketInp;
244     kstat_named_t NigMngPacketOut;
245     kstat_named_t NigPbfOctets;
246     kstat_named_t NigPbfPacket;
247     kstat_named_t NigSafcInp;
248 } BnxeKstatL2Chip;
249 
250 #define BNXE_KSTAT_L2_CHIP_SIZE (sizeof(BnxeKstatL2Chip) / sizeof(kstat_named_t))
251 
252 typedef struct _BnxeKstatL2Driver
253 {
254     kstat_named_t RxIPv4FragCount;
255     kstat_named_t RxIpCsErrorCount;
256     kstat_named_t RxTcpCsErrorCount;
257     kstat_named_t RxLlcSnapCount;
258     kstat_named_t RxPhyErrorCount;
259     kstat_named_t RxIpv6ExtCount;
260     kstat_named_t TxNoL2Bd;
261     kstat_named_t TxNoSqWqe;
262     kstat_named_t TxL2AssemblyBufUse;
263 } BnxeKstatL2Driver;
264 
265 #define BNXE_KSTAT_L2_DRIVER_SIZE (sizeof(BnxeKstatL2Driver) / sizeof(kstat_named_t))
266 
267 typedef struct _BnxeKstatEthStats
268 {
269     /* lm_stats_t */
270     kstat_named_t txFramesOk;         // LM_STATS_FRAMES_XMITTED_OK
271     kstat_named_t rxFramesOk;         // LM_STATS_FRAMES_RECEIVED_OK
272     kstat_named_t txErr;              // LM_STATS_ERRORED_TRANSMIT_CNT
273     kstat_named_t rxErr;              // LM_STATS_ERRORED_RECEIVE_CNT
274     kstat_named_t rxCrcErr;           // LM_STATS_RCV_CRC_ERROR
275     kstat_named_t alignErr;           // LM_STATS_ALIGNMENT_ERROR
276     kstat_named_t collisionsSingle;   // LM_STATS_SINGLE_COLLISION_FRAMES
277     kstat_named_t collisionsMultiple; // LM_STATS_MULTIPLE_COLLISION_FRAMES
278     kstat_named_t framesDeferred;     // LM_STATS_FRAMES_DEFERRED
279     kstat_named_t collisonsMax;       // LM_STATS_MAX_COLLISIONS
280     kstat_named_t rxOverrun;          // LM_STATS_RCV_OVERRUN
281     kstat_named_t txOverrun;          // LM_STATS_XMIT_UNDERRUN
282     kstat_named_t txFramesUnicast;    // LM_STATS_UNICAST_FRAMES_XMIT
283     kstat_named_t txFramesMulticast;  // LM_STATS_MULTICAST_FRAMES_XMIT
284     kstat_named_t txFramesBroadcast;  // LM_STATS_BROADCAST_FRAMES_XMIT
285     kstat_named_t rxFramesUnicast;    // LM_STATS_UNICAST_FRAMES_RCV
286     kstat_named_t rxFramesMulticast;  // LM_STATS_MULTICAST_FRAMES_RCV
287     kstat_named_t rxFramesBroadcast;  // LM_STATS_BROADCAST_FRAMES_RCV
288     kstat_named_t rxNoBufferDrop;     // LM_STATS_RCV_NO_BUFFER_DROP
289     kstat_named_t rxBytes;            // LM_STATS_BYTES_RCV
290     kstat_named_t txBytes;            // LM_STATS_BYTES_XMIT
291     kstat_named_t offloadIP4;         // LM_STATS_IP4_OFFLOAD
292     kstat_named_t offloadTCP;         // LM_STATS_TCP_OFFLOAD
293     kstat_named_t ifInDiscards;       // LM_STATS_IF_IN_DISCARDS
294     kstat_named_t ifInErrors;         // LM_STATS_IF_IN_ERRORS
295     kstat_named_t ifOutErrors;        // LM_STATS_IF_OUT_ERRORS
296     kstat_named_t offloadIP6;         // LM_STATS_IP6_OFFLOAD
297     kstat_named_t offloadTCP6;        // LM_STATS_TCP6_OFFLOAD
298     kstat_named_t txDiscards;         // LM_STATS_XMIT_DISCARDS
299     kstat_named_t rxBytesUnicast;     // LM_STATS_DIRECTED_BYTES_RCV
300     kstat_named_t rxBytesMulticast;   // LM_STATS_MULTICAST_BYTES_RCV
301     kstat_named_t rxBytesBroadcast;   // LM_STATS_BROADCAST_BYTES_RCV
302     kstat_named_t txBytesUnicast;     // LM_STATS_DIRECTED_BYTES_XMIT
303     kstat_named_t txBytesMulticast;   // LM_STATS_MULTICAST_BYTES_XMIT
304     kstat_named_t txBytesBroadcast;   // LM_STATS_BROADCAST_BYTES_XMIT
305 } BnxeKstatEthStats;
306 
307 #define BNXE_KSTAT_ETH_STATS_SIZE (sizeof(BnxeKstatEthStats) / sizeof(kstat_named_t))
308 
309 typedef struct _BnxeKstatFcoe
310 {
311     kstat_named_t pdev_hi;
312     kstat_named_t pdev_lo;
313     kstat_named_t instance;
314     kstat_named_t macAddr;
315     kstat_named_t pwwn_hi;
316     kstat_named_t pwwn_lo;
317     kstat_named_t mtu;
318     kstat_named_t initWqeTx;
319     kstat_named_t initWqeTxErr;
320     kstat_named_t initCqeRx;
321     kstat_named_t initCqeRxErr;
322     kstat_named_t offloadConnWqeTx;
323     kstat_named_t offloadConnWqeTxErr;
324     kstat_named_t offloadConnCqeRx;
325     kstat_named_t offloadConnCqeRxErr;
326     kstat_named_t enableConnWqeTx;
327     kstat_named_t enableConnWqeTxErr;
328     kstat_named_t enableConnCqeRx;
329     kstat_named_t enableConnCqeRxErr;
330     kstat_named_t disableConnWqeTx;
331     kstat_named_t disableConnWqeTxErr;
332     kstat_named_t disableConnCqeRx;
333     kstat_named_t disableConnCqeRxErr;
334     kstat_named_t destroyConnWqeTx;
335     kstat_named_t destroyConnWqeTxErr;
336     kstat_named_t destroyConnCqeRx;
337     kstat_named_t destroyConnCqeRxErr;
338     kstat_named_t destroyWqeTx;
339     kstat_named_t destroyWqeTxErr;
340     kstat_named_t destroyCqeRx;
341     kstat_named_t destroyCqeRxErr;
342     kstat_named_t compRequestCqeRx;
343     kstat_named_t compRequestCqeRxErr;
344     kstat_named_t statWqeTx;
345     kstat_named_t statWqeTxErr;
346     kstat_named_t statCqeRx;
347     kstat_named_t statCqeRxErr;
348 } BnxeKstatFcoe;
349 
350 #define BNXE_KSTAT_FCOE_SIZE (sizeof(BnxeKstatFcoe) / sizeof(kstat_named_t))
351 
352 typedef struct _BnxeKstatDcbx
353 {
354     kstat_named_t dcbx_sync;
355     kstat_named_t dcbx_vers;
356     kstat_named_t overwrite_settings;
357     kstat_named_t prio_tag;
358     kstat_named_t prio_tag_fcoe;
359     kstat_named_t prio_tag_iscsi;
360     kstat_named_t prio_tag_net;
361     kstat_named_t pfc;
362     kstat_named_t pfc_prio_0;
363     kstat_named_t pfc_prio_1;
364     kstat_named_t pfc_prio_2;
365     kstat_named_t pfc_prio_3;
366     kstat_named_t pfc_prio_4;
367     kstat_named_t pfc_prio_5;
368     kstat_named_t pfc_prio_6;
369     kstat_named_t pfc_prio_7;
370     kstat_named_t ets;
371     kstat_named_t ets_prio_0_pg;
372     kstat_named_t ets_prio_1_pg;
373     kstat_named_t ets_prio_2_pg;
374     kstat_named_t ets_prio_3_pg;
375     kstat_named_t ets_prio_4_pg;
376     kstat_named_t ets_prio_5_pg;
377     kstat_named_t ets_prio_6_pg;
378     kstat_named_t ets_prio_7_pg;
379     kstat_named_t ets_pg_0_bw;
380     kstat_named_t ets_pg_1_bw;
381     kstat_named_t ets_pg_2_bw;
382     kstat_named_t ets_pg_3_bw;
383     kstat_named_t ets_pg_4_bw;
384     kstat_named_t ets_pg_5_bw;
385     kstat_named_t ets_pg_6_bw;
386     kstat_named_t ets_pg_7_bw;
387     kstat_named_t lldp;
388     kstat_named_t lldp_tx_interval;
389     kstat_named_t lldp_tx_fast_interval;
390     kstat_named_t amib_apptlv_willing;
391     kstat_named_t amib_apptlv_tx;
392     kstat_named_t amib_apptlv_net_prio;
393     kstat_named_t amib_apptlv_tbl_0_prio;
394     kstat_named_t amib_apptlv_tbl_0_appid;
395     kstat_named_t amib_apptlv_tbl_1_prio;
396     kstat_named_t amib_apptlv_tbl_1_appid;
397     kstat_named_t amib_apptlv_tbl_2_prio;
398     kstat_named_t amib_apptlv_tbl_2_appid;
399     kstat_named_t amib_apptlv_tbl_3_prio;
400     kstat_named_t amib_apptlv_tbl_3_appid;
401     kstat_named_t amib_pgtlv_willing;
402     kstat_named_t amib_pgtlv_tx;
403     kstat_named_t amib_pgtlv_tc_supported;
404     kstat_named_t amib_pgtlv_ets;
405     kstat_named_t amib_pgtlv_pg_0_bw;
406     kstat_named_t amib_pgtlv_pg_1_bw;
407     kstat_named_t amib_pgtlv_pg_2_bw;
408     kstat_named_t amib_pgtlv_pg_3_bw;
409     kstat_named_t amib_pgtlv_pg_4_bw;
410     kstat_named_t amib_pgtlv_pg_5_bw;
411     kstat_named_t amib_pgtlv_pg_6_bw;
412     kstat_named_t amib_pgtlv_pg_7_bw;
413     kstat_named_t amib_pgtlv_prio_0_map;
414     kstat_named_t amib_pgtlv_prio_1_map;
415     kstat_named_t amib_pgtlv_prio_2_map;
416     kstat_named_t amib_pgtlv_prio_3_map;
417     kstat_named_t amib_pgtlv_prio_4_map;
418     kstat_named_t amib_pgtlv_prio_5_map;
419     kstat_named_t amib_pgtlv_prio_6_map;
420     kstat_named_t amib_pgtlv_prio_7_map;
421     kstat_named_t amib_pfctlv_willing;
422     kstat_named_t amib_pfctlv_tx;
423     kstat_named_t amib_pfctlv_pfc;
424     kstat_named_t amib_pfctlv_pfc_map;
425     kstat_named_t rmib_apptlv_willing;
426     kstat_named_t rmib_apptlv_tbl_0_prio;
427     kstat_named_t rmib_apptlv_tbl_0_appid;
428     kstat_named_t rmib_apptlv_tbl_1_prio;
429     kstat_named_t rmib_apptlv_tbl_1_appid;
430     kstat_named_t rmib_apptlv_tbl_2_prio;
431     kstat_named_t rmib_apptlv_tbl_2_appid;
432     kstat_named_t rmib_apptlv_tbl_3_prio;
433     kstat_named_t rmib_apptlv_tbl_3_appid;
434     kstat_named_t rmib_pgtlv_willing;
435     kstat_named_t rmib_pgtlv_tc_supported;
436     kstat_named_t rmib_pgtlv_pg_0_bw;
437     kstat_named_t rmib_pgtlv_pg_1_bw;
438     kstat_named_t rmib_pgtlv_pg_2_bw;
439     kstat_named_t rmib_pgtlv_pg_3_bw;
440     kstat_named_t rmib_pgtlv_pg_4_bw;
441     kstat_named_t rmib_pgtlv_pg_5_bw;
442     kstat_named_t rmib_pgtlv_pg_6_bw;
443     kstat_named_t rmib_pgtlv_pg_7_bw;
444     kstat_named_t rmib_pgtlv_prio_0_map;
445     kstat_named_t rmib_pgtlv_prio_1_map;
446     kstat_named_t rmib_pgtlv_prio_2_map;
447     kstat_named_t rmib_pgtlv_prio_3_map;
448     kstat_named_t rmib_pgtlv_prio_4_map;
449     kstat_named_t rmib_pgtlv_prio_5_map;
450     kstat_named_t rmib_pgtlv_prio_6_map;
451     kstat_named_t rmib_pgtlv_prio_7_map;
452     kstat_named_t rmib_pfctlv_willing;
453     kstat_named_t rmib_pfctlv_pfc_map;
454     kstat_named_t rmib_pfctlv_capable;
455     kstat_named_t lmib_apptlv_tbl_0_prio;
456     kstat_named_t lmib_apptlv_tbl_0_appid;
457     kstat_named_t lmib_apptlv_tbl_1_prio;
458     kstat_named_t lmib_apptlv_tbl_1_appid;
459     kstat_named_t lmib_apptlv_tbl_2_prio;
460     kstat_named_t lmib_apptlv_tbl_2_appid;
461     kstat_named_t lmib_apptlv_tbl_3_prio;
462     kstat_named_t lmib_apptlv_tbl_3_appid;
463     kstat_named_t lmib_apptlv_mismatch;
464     kstat_named_t lmib_pgtlv_ets;
465     kstat_named_t lmib_pgtlv_tc_supported;
466     kstat_named_t lmib_pgtlv_pg_0_bw;
467     kstat_named_t lmib_pgtlv_pg_1_bw;
468     kstat_named_t lmib_pgtlv_pg_2_bw;
469     kstat_named_t lmib_pgtlv_pg_3_bw;
470     kstat_named_t lmib_pgtlv_pg_4_bw;
471     kstat_named_t lmib_pgtlv_pg_5_bw;
472     kstat_named_t lmib_pgtlv_pg_6_bw;
473     kstat_named_t lmib_pgtlv_pg_7_bw;
474     kstat_named_t lmib_pgtlv_prio_0_map;
475     kstat_named_t lmib_pgtlv_prio_1_map;
476     kstat_named_t lmib_pgtlv_prio_2_map;
477     kstat_named_t lmib_pgtlv_prio_3_map;
478     kstat_named_t lmib_pgtlv_prio_4_map;
479     kstat_named_t lmib_pgtlv_prio_5_map;
480     kstat_named_t lmib_pgtlv_prio_6_map;
481     kstat_named_t lmib_pgtlv_prio_7_map;
482     kstat_named_t lmib_pfctlv_pfc;
483     kstat_named_t lmib_pfctlv_pfc_map;
484     kstat_named_t lmib_pfctlv_capable;
485     kstat_named_t lmib_pfctlv_mismatch;
486     kstat_named_t dcbx_frames_rx;
487     kstat_named_t dcbx_frames_tx;
488     kstat_named_t pfc_frames_rx;
489     kstat_named_t pfc_frames_tx;
490 } BnxeKstatDcbx;
491 
492 #define BNXE_KSTAT_DCBX_SIZE (sizeof(BnxeKstatDcbx) / sizeof(kstat_named_t))
493 
494 typedef struct _BnxeKstatRxq
495 {
496     kstat_named_t rxqBdTotal;
497     kstat_named_t rxqBdLeft;
498     kstat_named_t rxqBdPageCnt;
499     kstat_named_t rxqBdsPerPage;
500     kstat_named_t rxqBdSize;
501     kstat_named_t rxqBdsSkipEop;
502     kstat_named_t rxqBdProdIdx;
503     kstat_named_t rxqBdConsIdx;
504     kstat_named_t hwRxqConIdx;
505     kstat_named_t sgeBdTotal;
506     kstat_named_t sgeBdLeft;
507     kstat_named_t sgeBdPageCnt;
508     kstat_named_t sgeBdsPerPage;
509     kstat_named_t sgeBdSize;
510     kstat_named_t sgeBdsSkipEop;
511     kstat_named_t sgeBdProdIdx;
512     kstat_named_t sgeBdConsIdx;
513     kstat_named_t rcqBdTotal;
514     kstat_named_t rcqBdLeft;
515     kstat_named_t rcqBdPageCnt;
516     kstat_named_t rcqBdsPerPage;
517     kstat_named_t rcqBdSize;
518     kstat_named_t rcqBdsSkipEop;
519     kstat_named_t rcqBdProdIdx;
520     kstat_named_t rcqBdConsIdx;
521     kstat_named_t hwRcqConIdx;
522     kstat_named_t rxFreeDescs;
523     kstat_named_t rxActiveDescs;
524     kstat_named_t rxDoneDescs;
525     kstat_named_t rxWaitingDescs;
526     kstat_named_t rxCopied;
527     kstat_named_t rxDiscards;
528     kstat_named_t rxBufUpInStack;
529     kstat_named_t rxLowWater;
530     kstat_named_t inPollMode;
531     kstat_named_t pollCnt;
532     kstat_named_t intrDisableCnt;
533     kstat_named_t intrEnableCnt;
534     kstat_named_t genNumber;
535 } BnxeKstatRxq;
536 
537 #define BNXE_KSTAT_RXQ_SIZE (sizeof(BnxeKstatRxq) / sizeof(kstat_named_t))
538 
539 typedef struct _BnxeKstatTxq
540 {
541     kstat_named_t txBdTotal;
542     kstat_named_t txBdLeft;
543     kstat_named_t txBdPageCnt;
544     kstat_named_t txBdsPerPage;
545     kstat_named_t txBdSize;
546     kstat_named_t txBdsSkipEop;
547     kstat_named_t hwTxqConIdx;
548     kstat_named_t txPktIdx;
549     kstat_named_t txBdProdIdx;
550     kstat_named_t txBdConsIdx;
551     kstat_named_t txSentPkts;
552     kstat_named_t txFreeDesc;
553     kstat_named_t txWaitingPkts;
554     kstat_named_t txLowWater;
555     kstat_named_t txFailed;
556     kstat_named_t txDiscards;
557     kstat_named_t txRecycle;
558     kstat_named_t txCopied;
559     kstat_named_t txBlocked;
560     kstat_named_t txWait;
561 } BnxeKstatTxq;
562 
563 #define BNXE_KSTAT_TXQ_SIZE (sizeof(BnxeKstatTxq) / sizeof(kstat_named_t))
564 
565 
BnxeKstatUpdate(kstat_t * kstats,int rw)566 static int BnxeKstatUpdate(kstat_t * kstats,
567                            int       rw)
568 {
569     BnxeKstat *   pStats = (BnxeKstat *)kstats->ks_data;
570     um_device_t * pUM    = (um_device_t *)kstats->ks_private;
571     lm_device_t * pLM    = (lm_device_t *)pUM;
572     char buf[17]; /* 16 max for kstat string */
573 
574     if (rw == KSTAT_WRITE)
575     {
576         return EACCES;
577     }
578 
579     BNXE_LOCK_ENTER_STATS(pUM);
580 
581     snprintf(buf, sizeof(buf), "%p", (void *)pUM);
582     strncpy(pStats->umdev_hi.value.c, &buf[0], 8);
583     pStats->umdev_hi.value.c[8] = 0;
584     strncpy(pStats->umdev_lo.value.c, &buf[8], 8);
585     pStats->umdev_lo.value.c[8] = 0;
586 
587     strncpy(pStats->version.value.c,   pUM->version,   sizeof(pStats->version.value.c));
588     strncpy(pStats->versionFW.value.c, pUM->versionFW, sizeof(pStats->versionFW.value.c));
589     strncpy(pStats->versionBC.value.c, pUM->versionBC, sizeof(pStats->versionBC.value.c));
590 
591     strncpy(pStats->chipName.value.c, pUM->chipName, sizeof(pStats->chipName.value.c));
592     strncpy(pStats->chipID.value.c,   pUM->chipID,   sizeof(pStats->chipID.value.c));
593 
594     strncpy(pStats->devBDF.value.c, pUM->bus_dev_func,  sizeof(pStats->devBDF.value.c));
595     strncpy(pStats->devID.value.c,  pUM->vendor_device, sizeof(pStats->devID.value.c));
596 
597     strncpy(pStats->multiFunction.value.c,
598             ((pUM->lm_dev.params.mf_mode == SINGLE_FUNCTION)     ? "Single"  :
599              (pUM->lm_dev.params.mf_mode == MULTI_FUNCTION_SD)   ? "MF-SD"   :
600              (pUM->lm_dev.params.mf_mode == MULTI_FUNCTION_SI)   ? "MF-SI"   :
601              (pUM->lm_dev.params.mf_mode == MULTI_FUNCTION_AFEX) ? "MF-AFEX" :
602                                                                    "Unknown"),
603             sizeof(pStats->multiFunction.value.c));
604     pStats->multiFunctionVnics.value.ui64 = IS_MULTI_VNIC(&pUM->lm_dev) ? pLM->params.vnics_per_port : 0;
605 
606     snprintf(pStats->macAddr.value.c, 16, "%02x%02x%02x%02x%02x%02x",
607              pLM->params.mac_addr[0], pLM->params.mac_addr[1],
608              pLM->params.mac_addr[2], pLM->params.mac_addr[3],
609              pLM->params.mac_addr[4], pLM->params.mac_addr[5]);
610 
611     pStats->hwInitDone.value.ui64 = pUM->hwInitDone;
612 
613     snprintf(pStats->clientsHw.value.c, 16, BnxeClientsHw(pUM));
614     snprintf(pStats->clientsDevi.value.c, 16, BnxeClientsDevi(pUM));
615     snprintf(pStats->clientsBound.value.c, 16, BnxeClientsBound(pUM));
616 
617     pStats->txMsgPullUp.value.ui64 = pUM->txMsgPullUp;
618 
619     strncpy(pStats->intrAlloc.value.c, pUM->intrAlloc, sizeof(pStats->intrAlloc.value.c));
620     pStats->intrFired.value.ui64 = pUM->intrFired;
621 
622     pStats->timerFired.value.ui64          = pLM->vars.stats.stats_collect.timer_wakeup;
623     pStats->timerReply.value.ui64          = pLM->vars.stats.stats_collect.stats_fw.drv_counter;
624     pStats->timerNoReplyTotal.value.ui64   = pLM->vars.stats.stats_collect.stats_fw.timer_wakeup_no_completion_total;
625     pStats->timerNoReplyCurrent.value.ui64 = pLM->vars.stats.stats_collect.stats_fw.timer_wakeup_no_completion_current;
626     pStats->timerDone.value.ui64           = pLM->vars.stats.stats_collect.stats_fw.b_completion_done;
627 
628     pStats->workQueueInstCnt.value.ui64      = s_list_entry_cnt(&pUM->workqs.instq.workQueue);
629     pStats->workItemInstQueued.value.ui64    = pUM->workqs.instq.workItemQueued;
630     pStats->workItemInstError.value.ui64     = pUM->workqs.instq.workItemError;
631     pStats->workItemInstComplete.value.ui64  = pUM->workqs.instq.workItemComplete;
632     pStats->workItemInstHighWater.value.ui64 = pUM->workqs.instq.highWater;
633 
634     pStats->workQueueDelayCnt.value.ui64      = s_list_entry_cnt(&pUM->workqs.delayq.workQueue);
635     pStats->workItemDelayQueued.value.ui64    = pUM->workqs.delayq.workItemQueued;
636     pStats->workItemDelayError.value.ui64     = pUM->workqs.delayq.workItemError;
637     pStats->workItemDelayComplete.value.ui64  = pUM->workqs.delayq.workItemComplete;
638     pStats->workItemDelayHighWater.value.ui64 = pUM->workqs.delayq.highWater;
639 
640     pStats->memAllocBlocks.value.ui64 = d_list_entry_cnt(&pUM->memBlockList);
641     pStats->memAllocDMAs.value.ui64   = d_list_entry_cnt(&pUM->memDmaList);
642     pStats->memAllocBARs.value.ui64   = d_list_entry_cnt(&pUM->memRegionList);
643 
644     BNXE_LOCK_EXIT_STATS(pUM);
645 
646     return 0;
647 }
648 
649 
BnxeKstatLinkUpdate(kstat_t * kstats,int rw)650 static int BnxeKstatLinkUpdate(kstat_t * kstats,
651                                int       rw)
652 {
653     BnxeKstatLink * pStats = (BnxeKstatLink *)kstats->ks_data;
654     um_device_t *   pUM    = (um_device_t *)kstats->ks_private;
655     lm_device_t *   pLM    = (lm_device_t *)pUM;
656 
657     if (rw == KSTAT_WRITE)
658     {
659         return EACCES;
660     }
661 
662     BNXE_LOCK_ENTER_STATS(pUM);
663 
664     snprintf(pStats->clients.value.c, 16, BnxeClientsBound(pUM));
665     pStats->uptime.value.ui64  = (pUM->props.link_speed) ?
666                                      (ddi_get_time() - pUM->props.uptime) : 0;
667     pStats->mtuL2.value.ui64   = pUM->lm_dev.params.mtu[LM_CLI_IDX_NDIS];
668     pStats->mtuFCOE.value.ui64 = (BNXE_FCOE(pUM)) ?
669                                      pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE] :
670                                      0;
671     pStats->speed.value.ui64   = pUM->props.link_speed;
672     pStats->link.value.ui64    = (!pUM->props.link_speed) ? 0 : 1;
673     pStats->duplex.value.ui64  = pUM->props.link_duplex;
674     pStats->pauseRx.value.ui64 = pUM->props.link_rxpause;
675     pStats->pauseTx.value.ui64 = pUM->props.link_txpause;
676 
677     BNXE_LOCK_EXIT_STATS(pUM);
678 
679     return 0;
680 }
681 
682 
BnxeKstatIntrUpdate(kstat_t * kstats,int rw)683 static int BnxeKstatIntrUpdate(kstat_t * kstats,
684                                int       rw)
685 {
686     BnxeKstatIntr * pStats = (BnxeKstatIntr *)kstats->ks_data;
687     um_device_t *   pUM    = (um_device_t *)kstats->ks_private;
688     lm_device_t *   pLM    = (lm_device_t *)pUM;
689 
690     if (rw == KSTAT_WRITE)
691     {
692         return EACCES;
693     }
694 
695     BNXE_LOCK_ENTER_STATS(pUM);
696 
697     strncpy(pStats->intrAlloc.value.c, pUM->intrAlloc, sizeof(pStats->intrAlloc.value.c));
698     pStats->intrFired.value.ui64      = pUM->intrFired;
699     pStats->intrWrongState.value.ui64 = pLM->vars.dbg_intr_in_wrong_state;
700     pStats->intrInDisabled.value.ui64 = pLM->vars.dbg_intr_in_disabled;
701     pStats->intrZeroStatus.value.ui64 = pLM->vars.dbg_intr_zero_status;
702     pStats->sb_00.value.ui64          = pUM->intrSbCnt[0];
703     pStats->sb_01.value.ui64          = pUM->intrSbCnt[1];
704     pStats->sb_02.value.ui64          = pUM->intrSbCnt[2];
705     pStats->sb_03.value.ui64          = pUM->intrSbCnt[3];
706     pStats->sb_04.value.ui64          = pUM->intrSbCnt[4];
707     pStats->sb_05.value.ui64          = pUM->intrSbCnt[5];
708     pStats->sb_06.value.ui64          = pUM->intrSbCnt[6];
709     pStats->sb_07.value.ui64          = pUM->intrSbCnt[7];
710     pStats->sb_08.value.ui64          = pUM->intrSbCnt[8];
711     pStats->sb_09.value.ui64          = pUM->intrSbCnt[9];
712     pStats->sb_10.value.ui64          = pUM->intrSbCnt[10];
713     pStats->sb_11.value.ui64          = pUM->intrSbCnt[11];
714     pStats->sb_12.value.ui64          = pUM->intrSbCnt[12];
715     pStats->sb_13.value.ui64          = pUM->intrSbCnt[13];
716     pStats->sb_14.value.ui64          = pUM->intrSbCnt[14];
717     pStats->sb_15.value.ui64          = pUM->intrSbCnt[15];
718     pStats->sb_16.value.ui64          = pUM->intrSbCnt[16];
719     pStats->sb_nc_00.value.ui64       = pUM->intrSbNoChangeCnt[0];
720     pStats->sb_nc_01.value.ui64       = pUM->intrSbNoChangeCnt[1];
721     pStats->sb_nc_02.value.ui64       = pUM->intrSbNoChangeCnt[2];
722     pStats->sb_nc_03.value.ui64       = pUM->intrSbNoChangeCnt[3];
723     pStats->sb_nc_04.value.ui64       = pUM->intrSbNoChangeCnt[4];
724     pStats->sb_nc_05.value.ui64       = pUM->intrSbNoChangeCnt[5];
725     pStats->sb_nc_06.value.ui64       = pUM->intrSbNoChangeCnt[6];
726     pStats->sb_nc_07.value.ui64       = pUM->intrSbNoChangeCnt[7];
727     pStats->sb_nc_08.value.ui64       = pUM->intrSbNoChangeCnt[8];
728     pStats->sb_nc_09.value.ui64       = pUM->intrSbNoChangeCnt[9];
729     pStats->sb_nc_10.value.ui64       = pUM->intrSbNoChangeCnt[10];
730     pStats->sb_nc_11.value.ui64       = pUM->intrSbNoChangeCnt[11];
731     pStats->sb_nc_12.value.ui64       = pUM->intrSbNoChangeCnt[12];
732     pStats->sb_nc_13.value.ui64       = pUM->intrSbNoChangeCnt[13];
733     pStats->sb_nc_14.value.ui64       = pUM->intrSbNoChangeCnt[14];
734     pStats->sb_nc_15.value.ui64       = pUM->intrSbNoChangeCnt[15];
735     pStats->sb_nc_16.value.ui64       = pUM->intrSbNoChangeCnt[16];
736     pStats->sb_poll_00.value.ui64     = pUM->intrSbPollCnt[0];
737     pStats->sb_poll_01.value.ui64     = pUM->intrSbPollCnt[1];
738     pStats->sb_poll_02.value.ui64     = pUM->intrSbPollCnt[2];
739     pStats->sb_poll_03.value.ui64     = pUM->intrSbPollCnt[3];
740     pStats->sb_poll_04.value.ui64     = pUM->intrSbPollCnt[4];
741     pStats->sb_poll_05.value.ui64     = pUM->intrSbPollCnt[5];
742     pStats->sb_poll_06.value.ui64     = pUM->intrSbPollCnt[6];
743     pStats->sb_poll_07.value.ui64     = pUM->intrSbPollCnt[7];
744     pStats->sb_poll_08.value.ui64     = pUM->intrSbPollCnt[8];
745     pStats->sb_poll_09.value.ui64     = pUM->intrSbPollCnt[9];
746     pStats->sb_poll_10.value.ui64     = pUM->intrSbPollCnt[10];
747     pStats->sb_poll_11.value.ui64     = pUM->intrSbPollCnt[11];
748     pStats->sb_poll_12.value.ui64     = pUM->intrSbPollCnt[12];
749     pStats->sb_poll_13.value.ui64     = pUM->intrSbPollCnt[13];
750     pStats->sb_poll_14.value.ui64     = pUM->intrSbPollCnt[14];
751     pStats->sb_poll_15.value.ui64     = pUM->intrSbPollCnt[15];
752     pStats->sb_poll_16.value.ui64     = pUM->intrSbPollCnt[16];
753     pStats->sb_poll_nc_00.value.ui64  = pUM->intrSbPollNoChangeCnt[0];
754     pStats->sb_poll_nc_01.value.ui64  = pUM->intrSbPollNoChangeCnt[1];
755     pStats->sb_poll_nc_02.value.ui64  = pUM->intrSbPollNoChangeCnt[2];
756     pStats->sb_poll_nc_03.value.ui64  = pUM->intrSbPollNoChangeCnt[3];
757     pStats->sb_poll_nc_04.value.ui64  = pUM->intrSbPollNoChangeCnt[4];
758     pStats->sb_poll_nc_05.value.ui64  = pUM->intrSbPollNoChangeCnt[5];
759     pStats->sb_poll_nc_06.value.ui64  = pUM->intrSbPollNoChangeCnt[6];
760     pStats->sb_poll_nc_07.value.ui64  = pUM->intrSbPollNoChangeCnt[7];
761     pStats->sb_poll_nc_08.value.ui64  = pUM->intrSbPollNoChangeCnt[8];
762     pStats->sb_poll_nc_09.value.ui64  = pUM->intrSbPollNoChangeCnt[9];
763     pStats->sb_poll_nc_10.value.ui64  = pUM->intrSbPollNoChangeCnt[10];
764     pStats->sb_poll_nc_11.value.ui64  = pUM->intrSbPollNoChangeCnt[11];
765     pStats->sb_poll_nc_12.value.ui64  = pUM->intrSbPollNoChangeCnt[12];
766     pStats->sb_poll_nc_13.value.ui64  = pUM->intrSbPollNoChangeCnt[13];
767     pStats->sb_poll_nc_14.value.ui64  = pUM->intrSbPollNoChangeCnt[14];
768     pStats->sb_poll_nc_15.value.ui64  = pUM->intrSbPollNoChangeCnt[15];
769     pStats->sb_poll_nc_16.value.ui64  = pUM->intrSbPollNoChangeCnt[16];
770 
771     BNXE_LOCK_EXIT_STATS(pUM);
772 
773     return 0;
774 }
775 
776 
BnxeKstatL2ChipUpdate(kstat_t * kstats,int rw)777 static int BnxeKstatL2ChipUpdate(kstat_t * kstats,
778                                  int       rw)
779 {
780     BnxeKstatL2Chip * pStats = (BnxeKstatL2Chip *)kstats->ks_data;
781     um_device_t *     pUM    = (um_device_t *)kstats->ks_private;
782     lm_device_t *     pLM    = (lm_device_t *)pUM;
783     b10_l2_chip_statistics_t b10_l2_stats;
784 
785     if (rw == KSTAT_WRITE)
786     {
787         return EACCES;
788     }
789 
790     BNXE_LOCK_ENTER_STATS(pUM);
791 
792     lm_stats_get_l2_chip_stats(pLM, &b10_l2_stats,
793                                L2_CHIP_STATISTICS_VER_NUM_1);
794 
795     pStats->IfHCInOctets.value.ui64                       = b10_l2_stats.IfHCInOctets;
796     pStats->IfHCInBadOctets.value.ui64                    = b10_l2_stats.IfHCInBadOctets;
797     pStats->IfHCOutOctets.value.ui64                      = b10_l2_stats.IfHCOutOctets;
798     pStats->IfHCOutBadOctets.value.ui64                   = b10_l2_stats.IfHCOutBadOctets;
799     pStats->IfHCOutPkts.value.ui64                        = b10_l2_stats.IfHCOutPkts;
800     pStats->IfHCInPkts.value.ui64                         = b10_l2_stats.IfHCInPkts;
801     pStats->IfHCInUcastPkts.value.ui64                    = b10_l2_stats.IfHCInUcastPkts;
802     pStats->IfHCInMulticastPkts.value.ui64                = b10_l2_stats.IfHCInMulticastPkts;
803     pStats->IfHCInBroadcastPkts.value.ui64                = b10_l2_stats.IfHCInBroadcastPkts;
804     pStats->IfHCOutUcastPkts.value.ui64                   = b10_l2_stats.IfHCOutUcastPkts;
805     pStats->IfHCOutMulticastPkts.value.ui64               = b10_l2_stats.IfHCOutMulticastPkts;
806     pStats->IfHCOutBroadcastPkts.value.ui64               = b10_l2_stats.IfHCOutBroadcastPkts;
807     pStats->IfHCInUcastOctets.value.ui64                  = b10_l2_stats.IfHCInUcastOctets;
808     pStats->IfHCInMulticastOctets.value.ui64              = b10_l2_stats.IfHCInMulticastOctets;
809     pStats->IfHCInBroadcastOctets.value.ui64              = b10_l2_stats.IfHCInBroadcastOctets;
810     pStats->IfHCOutUcastOctets.value.ui64                 = b10_l2_stats.IfHCOutUcastOctets;
811     pStats->IfHCOutMulticastOctets.value.ui64             = b10_l2_stats.IfHCOutMulticastOctets;
812     pStats->IfHCOutBroadcastOctets.value.ui64             = b10_l2_stats.IfHCOutBroadcastOctets;
813     pStats->IfHCOutDiscards.value.ui64                    = b10_l2_stats.IfHCOutDiscards;
814     pStats->IfHCInFalseCarrierErrors.value.ui64           = b10_l2_stats.IfHCInFalseCarrierErrors;
815     pStats->Dot3StatsInternalMacTransmitErrors.value.ui64 = b10_l2_stats.Dot3StatsInternalMacTransmitErrors;
816     pStats->Dot3StatsCarrierSenseErrors.value.ui64        = b10_l2_stats.Dot3StatsCarrierSenseErrors;
817     pStats->Dot3StatsFCSErrors.value.ui64                 = b10_l2_stats.Dot3StatsFCSErrors;
818     pStats->Dot3StatsAlignmentErrors.value.ui64           = b10_l2_stats.Dot3StatsAlignmentErrors;
819     pStats->Dot3StatsSingleCollisionFrames.value.ui64     = b10_l2_stats.Dot3StatsSingleCollisionFrames;
820     pStats->Dot3StatsMultipleCollisionFrames.value.ui64   = b10_l2_stats.Dot3StatsMultipleCollisionFrames;
821     pStats->Dot3StatsDeferredTransmissions.value.ui64     = b10_l2_stats.Dot3StatsDeferredTransmissions;
822     pStats->Dot3StatsExcessiveCollisions.value.ui64       = b10_l2_stats.Dot3StatsExcessiveCollisions;
823     pStats->Dot3StatsLateCollisions.value.ui64            = b10_l2_stats.Dot3StatsLateCollisions;
824     pStats->EtherStatsCollisions.value.ui64               = b10_l2_stats.EtherStatsCollisions;
825     pStats->EtherStatsFragments.value.ui64                = b10_l2_stats.EtherStatsFragments;
826     pStats->EtherStatsJabbers.value.ui64                  = b10_l2_stats.EtherStatsJabbers;
827     pStats->EtherStatsUndersizePkts.value.ui64            = b10_l2_stats.EtherStatsUndersizePkts;
828     pStats->EtherStatsOverrsizePkts.value.ui64            = b10_l2_stats.EtherStatsOverrsizePkts;
829     pStats->EtherStatsTx64Octets.value.ui64               = b10_l2_stats.EtherStatsPktsTx64Octets;
830     pStats->EtherStatsTx65to127Octets.value.ui64          = b10_l2_stats.EtherStatsPktsTx65Octetsto127Octets;
831     pStats->EtherStatsTx128to255Octets.value.ui64         = b10_l2_stats.EtherStatsPktsTx128Octetsto255Octets;
832     pStats->EtherStatsTx256to511Octets.value.ui64         = b10_l2_stats.EtherStatsPktsTx256Octetsto511Octets;
833     pStats->EtherStatsTx512to1023Octets.value.ui64        = b10_l2_stats.EtherStatsPktsTx512Octetsto1023Octets;
834     pStats->EtherStatsTx1024to1522Octets.value.ui64       = b10_l2_stats.EtherStatsPktsTx1024Octetsto1522Octets;
835     pStats->EtherStatsTxOver1522Octets.value.ui64         = b10_l2_stats.EtherStatsPktsTxOver1522Octets;
836     pStats->XonPauseFramesReceived.value.ui64             = b10_l2_stats.XonPauseFramesReceived;
837     pStats->XoffPauseFramesReceived.value.ui64            = b10_l2_stats.XoffPauseFramesReceived;
838     pStats->OutXonSent.value.ui64                         = b10_l2_stats.OutXonSent;
839     pStats->OutXoffSent.value.ui64                        = b10_l2_stats.OutXoffSent;
840     pStats->FlowControlDone.value.ui64                    = b10_l2_stats.FlowControlDone;
841     pStats->MacControlFramesReceived.value.ui64           = b10_l2_stats.MacControlFramesReceived;
842     pStats->XoffStateEntered.value.ui64                   = b10_l2_stats.XoffStateEntered;
843     pStats->IfInFramesL2FilterDiscards.value.ui64         = b10_l2_stats.IfInFramesL2FilterDiscards;
844     pStats->IfInTTL0Discards.value.ui64                   = b10_l2_stats.IfInTTL0Discards;
845     pStats->IfInxxOverflowDiscards.value.ui64             = b10_l2_stats.IfInxxOverflowDiscards;
846     pStats->IfInMBUFDiscards.value.ui64                   = b10_l2_stats.IfInMBUFDiscards;
847     pStats->IfInErrors.value.ui64                         = b10_l2_stats.IfInErrors;
848     pStats->IfInErrorsOctets.value.ui64                   = b10_l2_stats.IfInErrorsOctets;
849     pStats->IfInNoBrbBuffer.value.ui64                    = b10_l2_stats.IfInNoBrbBuffer;
850     pStats->NigBrbPacket.value.ui64                       = b10_l2_stats.Nig_brb_packet;
851     pStats->NigBrbTruncate.value.ui64                     = b10_l2_stats.Nig_brb_truncate;
852     pStats->NigFlowCtrlDiscard.value.ui64                 = b10_l2_stats.Nig_flow_ctrl_discard;
853     pStats->NigFlowCtrlOctets.value.ui64                  = b10_l2_stats.Nig_flow_ctrl_octets;
854     pStats->NigFlowCtrlPacket.value.ui64                  = b10_l2_stats.Nig_flow_ctrl_packet;
855     pStats->NigMngDiscard.value.ui64                      = b10_l2_stats.Nig_mng_discard;
856     pStats->NigMngOctetInp.value.ui64                     = b10_l2_stats.Nig_mng_octet_inp;
857     pStats->NigMngOctetOut.value.ui64                     = b10_l2_stats.Nig_mng_octet_out;
858     pStats->NigMngPacketInp.value.ui64                    = b10_l2_stats.Nig_mng_packet_inp;
859     pStats->NigMngPacketOut.value.ui64                    = b10_l2_stats.Nig_mng_packet_out;
860     pStats->NigPbfOctets.value.ui64                       = b10_l2_stats.Nig_pbf_octets;
861     pStats->NigPbfPacket.value.ui64                       = b10_l2_stats.Nig_pbf_packet;
862     pStats->NigSafcInp.value.ui64                         = b10_l2_stats.Nig_safc_inp;
863 
864     BNXE_LOCK_EXIT_STATS(pUM);
865 
866     return 0;
867 }
868 
869 
BnxeKstatL2DriverUpdate(kstat_t * kstats,int rw)870 static int BnxeKstatL2DriverUpdate(kstat_t * kstats,
871                                    int       rw)
872 {
873     BnxeKstatL2Driver * pStats = (BnxeKstatL2Driver *)kstats->ks_data;
874     um_device_t *       pUM    = (um_device_t *)kstats->ks_private;
875     lm_device_t *       pLM    = (lm_device_t *)pUM;
876     b10_l2_driver_statistics_t b10_l2_stats;
877 
878     if (rw == KSTAT_WRITE)
879     {
880         return EACCES;
881     }
882 
883     BNXE_LOCK_ENTER_STATS(pUM);
884 
885     lm_stats_get_l2_driver_stats(pLM, &b10_l2_stats);
886 
887     pStats->RxIPv4FragCount.value.ui64    = b10_l2_stats.RxIPv4FragCount;
888     pStats->RxIpCsErrorCount.value.ui64   = b10_l2_stats.RxIpCsErrorCount;
889     pStats->RxTcpCsErrorCount.value.ui64  = b10_l2_stats.RxTcpCsErrorCount;
890     pStats->RxLlcSnapCount.value.ui64     = b10_l2_stats.RxLlcSnapCount;
891     pStats->RxPhyErrorCount.value.ui64    = b10_l2_stats.RxPhyErrorCount;
892     pStats->RxIpv6ExtCount.value.ui64     = b10_l2_stats.RxIpv6ExtCount;
893     pStats->TxNoL2Bd.value.ui64           = b10_l2_stats.TxNoL2Bd;
894     pStats->TxNoSqWqe.value.ui64          = b10_l2_stats.TxNoSqWqe;
895     pStats->TxL2AssemblyBufUse.value.ui64 = b10_l2_stats.TxL2AssemblyBufUse;
896 
897     BNXE_LOCK_EXIT_STATS(pUM);
898 
899     return 0;
900 }
901 
902 
BnxeKstatL2StatsUpdate(kstat_t * kstats,int rw)903 static int BnxeKstatL2StatsUpdate(kstat_t * kstats,
904                                   int       rw)
905 {
906     BnxeKstatEthStats * pStats = (BnxeKstatEthStats *)kstats->ks_data;
907     um_device_t *       pUM    = (um_device_t *)kstats->ks_private;
908     lm_device_t *       pLM    = (lm_device_t *)pUM;
909 
910     if (rw == KSTAT_WRITE)
911     {
912         return EACCES;
913     }
914 
915     BNXE_LOCK_ENTER_STATS(pUM);
916 
917     lm_get_stats(pLM, LM_STATS_FRAMES_XMITTED_OK,         (u64_t *)&pStats->txFramesOk.value.ui64);
918     lm_get_stats(pLM, LM_STATS_FRAMES_RECEIVED_OK,        (u64_t *)&pStats->rxFramesOk.value.ui64);
919     lm_get_stats(pLM, LM_STATS_ERRORED_TRANSMIT_CNT,      (u64_t *)&pStats->txErr.value.ui64);
920     lm_get_stats(pLM, LM_STATS_ERRORED_RECEIVE_CNT,       (u64_t *)&pStats->rxErr.value.ui64);
921     lm_get_stats(pLM, LM_STATS_RCV_CRC_ERROR,             (u64_t *)&pStats->rxCrcErr.value.ui64);
922     lm_get_stats(pLM, LM_STATS_ALIGNMENT_ERROR,           (u64_t *)&pStats->alignErr.value.ui64);
923     lm_get_stats(pLM, LM_STATS_SINGLE_COLLISION_FRAMES,   (u64_t *)&pStats->collisionsSingle.value.ui64);
924     lm_get_stats(pLM, LM_STATS_MULTIPLE_COLLISION_FRAMES, (u64_t *)&pStats->collisionsMultiple.value.ui64);
925     lm_get_stats(pLM, LM_STATS_FRAMES_DEFERRED,           (u64_t *)&pStats->framesDeferred.value.ui64);
926     lm_get_stats(pLM, LM_STATS_MAX_COLLISIONS,            (u64_t *)&pStats->collisonsMax.value.ui64);
927     lm_get_stats(pLM, LM_STATS_RCV_OVERRUN,               (u64_t *)&pStats->rxOverrun.value.ui64);
928     lm_get_stats(pLM, LM_STATS_XMIT_UNDERRUN,             (u64_t *)&pStats->txOverrun.value.ui64);
929     lm_get_stats(pLM, LM_STATS_UNICAST_FRAMES_XMIT,       (u64_t *)&pStats->txFramesUnicast.value.ui64);
930     lm_get_stats(pLM, LM_STATS_MULTICAST_FRAMES_XMIT,     (u64_t *)&pStats->txFramesMulticast.value.ui64);
931     lm_get_stats(pLM, LM_STATS_BROADCAST_FRAMES_XMIT,     (u64_t *)&pStats->txFramesBroadcast.value.ui64);
932     lm_get_stats(pLM, LM_STATS_UNICAST_FRAMES_RCV,        (u64_t *)&pStats->rxFramesUnicast.value.ui64);
933     lm_get_stats(pLM, LM_STATS_MULTICAST_FRAMES_RCV,      (u64_t *)&pStats->rxFramesMulticast.value.ui64);
934     lm_get_stats(pLM, LM_STATS_BROADCAST_FRAMES_RCV,      (u64_t *)&pStats->rxFramesBroadcast.value.ui64);
935     lm_get_stats(pLM, LM_STATS_RCV_NO_BUFFER_DROP,        (u64_t *)&pStats->rxNoBufferDrop.value.ui64);
936     lm_get_stats(pLM, LM_STATS_BYTES_RCV,                 (u64_t *)&pStats->rxBytes.value.ui64);
937     lm_get_stats(pLM, LM_STATS_BYTES_XMIT,                (u64_t *)&pStats->txBytes.value.ui64);
938     lm_get_stats(pLM, LM_STATS_IP4_OFFLOAD,               (u64_t *)&pStats->offloadIP4.value.ui64);
939     lm_get_stats(pLM, LM_STATS_TCP_OFFLOAD,               (u64_t *)&pStats->offloadTCP.value.ui64);
940     lm_get_stats(pLM, LM_STATS_IF_IN_DISCARDS,            (u64_t *)&pStats->ifInDiscards.value.ui64);
941     lm_get_stats(pLM, LM_STATS_IF_IN_ERRORS,              (u64_t *)&pStats->ifInErrors.value.ui64);
942     lm_get_stats(pLM, LM_STATS_IF_OUT_ERRORS,             (u64_t *)&pStats->ifOutErrors.value.ui64);
943     lm_get_stats(pLM, LM_STATS_IP6_OFFLOAD,               (u64_t *)&pStats->offloadIP6.value.ui64);
944     lm_get_stats(pLM, LM_STATS_TCP6_OFFLOAD,              (u64_t *)&pStats->offloadTCP6.value.ui64);
945     lm_get_stats(pLM, LM_STATS_XMIT_DISCARDS,             (u64_t *)&pStats->txDiscards.value.ui64);
946     lm_get_stats(pLM, LM_STATS_DIRECTED_BYTES_RCV,        (u64_t *)&pStats->rxBytesUnicast.value.ui64);
947     lm_get_stats(pLM, LM_STATS_MULTICAST_BYTES_RCV,       (u64_t *)&pStats->rxBytesMulticast.value.ui64);
948     lm_get_stats(pLM, LM_STATS_BROADCAST_BYTES_RCV,       (u64_t *)&pStats->rxBytesBroadcast.value.ui64);
949     lm_get_stats(pLM, LM_STATS_DIRECTED_BYTES_XMIT,       (u64_t *)&pStats->txBytesUnicast.value.ui64);
950     lm_get_stats(pLM, LM_STATS_MULTICAST_BYTES_XMIT,      (u64_t *)&pStats->txBytesMulticast.value.ui64);
951     lm_get_stats(pLM, LM_STATS_BROADCAST_BYTES_XMIT,      (u64_t *)&pStats->txBytesBroadcast.value.ui64);
952 
953     BNXE_LOCK_EXIT_STATS(pUM);
954 
955     return 0;
956 }
957 
958 
BnxeKstatFcoeUpdate(kstat_t * kstats,int rw)959 static int BnxeKstatFcoeUpdate(kstat_t * kstats,
960                                int       rw)
961 {
962     BnxeKstatFcoe * pStats = (BnxeKstatFcoe *)kstats->ks_data;
963     um_device_t * pUM      = (um_device_t *)kstats->ks_private;
964     lm_device_t * pLM      = (lm_device_t *)pUM;
965     char buf[17]; /* 16 max for kstat string */
966 
967     if (rw == KSTAT_WRITE)
968     {
969         return EACCES;
970     }
971 
972     BNXE_LOCK_ENTER_STATS(pUM);
973 
974     if (pUM->fcoe.pDev)
975     {
976         snprintf(buf, sizeof(buf), "%p", (void *)pUM->fcoe.pDev);
977         strncpy(pStats->pdev_hi.value.c, &buf[0], 8);
978         pStats->pdev_hi.value.c[8] = 0;
979         strncpy(pStats->pdev_lo.value.c, &buf[8], 8);
980         pStats->pdev_lo.value.c[8] = 0;
981 
982         snprintf(pStats->instance.value.c, 16, "bnxef%d",
983                  ddi_get_instance(pUM->fcoe.pDev));
984 
985         if ((pUM->fcoe.wwn.fcp_pwwn[0] == 0) &&
986             (pUM->fcoe.wwn.fcp_pwwn[1] == 0) &&
987             (pUM->fcoe.wwn.fcp_pwwn[2] == 0) &&
988             (pUM->fcoe.wwn.fcp_pwwn[3] == 0) &&
989             (pUM->fcoe.wwn.fcp_pwwn[4] == 0) &&
990             (pUM->fcoe.wwn.fcp_pwwn[5] == 0) &&
991             (pUM->fcoe.wwn.fcp_pwwn[6] == 0) &&
992             (pUM->fcoe.wwn.fcp_pwwn[7] == 0))
993         {
994             snprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x%02x%02x",
995                      0x20, 0x00,
996                      pLM->hw_info.fcoe_mac_addr[0],
997                      pLM->hw_info.fcoe_mac_addr[1],
998                      pLM->hw_info.fcoe_mac_addr[2],
999                      pLM->hw_info.fcoe_mac_addr[3],
1000                      pLM->hw_info.fcoe_mac_addr[4],
1001                      pLM->hw_info.fcoe_mac_addr[5]);
1002         }
1003         else
1004         {
1005             snprintf(buf, sizeof(buf), "%02x%02x%02x%02x%02x%02x%02x%02x",
1006                      pUM->fcoe.wwn.fcp_pwwn[0],
1007                      pUM->fcoe.wwn.fcp_pwwn[1],
1008                      pUM->fcoe.wwn.fcp_pwwn[2],
1009                      pUM->fcoe.wwn.fcp_pwwn[3],
1010                      pUM->fcoe.wwn.fcp_pwwn[4],
1011                      pUM->fcoe.wwn.fcp_pwwn[5],
1012                      pUM->fcoe.wwn.fcp_pwwn[7],
1013                      pUM->fcoe.wwn.fcp_pwwn[7]);
1014         }
1015         strncpy(pStats->pwwn_hi.value.c, &buf[0], 8);
1016         pStats->pwwn_hi.value.c[8] = 0;
1017         strncpy(pStats->pwwn_lo.value.c, &buf[8], 8);
1018         pStats->pwwn_lo.value.c[8] = 0;
1019     }
1020     else
1021     {
1022         strncpy(pStats->pdev_hi.value.c,  "none", sizeof(pStats->pdev_hi.value.c));
1023         strncpy(pStats->pdev_lo.value.c,  "none", sizeof(pStats->pdev_lo.value.c));
1024         strncpy(pStats->instance.value.c, "none", sizeof(pStats->instance.value.c));
1025         strncpy(pStats->pwwn_hi.value.c,  "none", sizeof(pStats->pwwn_hi.value.c));
1026         strncpy(pStats->pwwn_lo.value.c,  "none", sizeof(pStats->pwwn_lo.value.c));
1027     }
1028 
1029     snprintf(pStats->macAddr.value.c, 16, "%02x%02x%02x%02x%02x%02x",
1030              pLM->hw_info.fcoe_mac_addr[0], pLM->hw_info.fcoe_mac_addr[1],
1031              pLM->hw_info.fcoe_mac_addr[2], pLM->hw_info.fcoe_mac_addr[3],
1032              pLM->hw_info.fcoe_mac_addr[4], pLM->hw_info.fcoe_mac_addr[5]);
1033 
1034     pStats->mtu.value.ui64                 = pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE];
1035     pStats->initWqeTx.value.ui64           = pUM->fcoe.stats.initWqeTx;
1036     pStats->initWqeTxErr.value.ui64        = pUM->fcoe.stats.initWqeTxErr;
1037     pStats->initCqeRx.value.ui64           = pUM->fcoe.stats.initCqeRx;
1038     pStats->initCqeRxErr.value.ui64        = pUM->fcoe.stats.initCqeRxErr;
1039     pStats->offloadConnWqeTx.value.ui64    = pUM->fcoe.stats.offloadConnWqeTx;
1040     pStats->offloadConnWqeTxErr.value.ui64 = pUM->fcoe.stats.offloadConnWqeTxErr;
1041     pStats->offloadConnCqeRx.value.ui64    = pUM->fcoe.stats.offloadConnCqeRx;
1042     pStats->offloadConnCqeRxErr.value.ui64 = pUM->fcoe.stats.offloadConnCqeRxErr;
1043     pStats->enableConnWqeTx.value.ui64     = pUM->fcoe.stats.enableConnWqeTx;
1044     pStats->enableConnWqeTxErr.value.ui64  = pUM->fcoe.stats.enableConnWqeTxErr;
1045     pStats->enableConnCqeRx.value.ui64     = pUM->fcoe.stats.enableConnCqeRx;
1046     pStats->enableConnCqeRxErr.value.ui64  = pUM->fcoe.stats.enableConnCqeRxErr;
1047     pStats->disableConnWqeTx.value.ui64    = pUM->fcoe.stats.disableConnWqeTx;
1048     pStats->disableConnWqeTxErr.value.ui64 = pUM->fcoe.stats.disableConnWqeTxErr;
1049     pStats->disableConnCqeRx.value.ui64    = pUM->fcoe.stats.disableConnCqeRx;
1050     pStats->disableConnCqeRxErr.value.ui64 = pUM->fcoe.stats.disableConnCqeRxErr;
1051     pStats->destroyConnWqeTx.value.ui64    = pUM->fcoe.stats.destroyConnWqeTx;
1052     pStats->destroyConnWqeTxErr.value.ui64 = pUM->fcoe.stats.destroyConnWqeTxErr;
1053     pStats->destroyConnCqeRx.value.ui64    = pUM->fcoe.stats.destroyConnCqeRx;
1054     pStats->destroyConnCqeRxErr.value.ui64 = pUM->fcoe.stats.destroyConnCqeRxErr;
1055     pStats->destroyWqeTx.value.ui64        = pUM->fcoe.stats.destroyWqeTx;
1056     pStats->destroyWqeTxErr.value.ui64     = pUM->fcoe.stats.destroyWqeTxErr;
1057     pStats->destroyCqeRx.value.ui64        = pUM->fcoe.stats.destroyCqeRx;
1058     pStats->destroyCqeRxErr.value.ui64     = pUM->fcoe.stats.destroyCqeRxErr;
1059     pStats->compRequestCqeRx.value.ui64    = pUM->fcoe.stats.compRequestCqeRx;
1060     pStats->compRequestCqeRxErr.value.ui64 = pUM->fcoe.stats.compRequestCqeRxErr;
1061     pStats->statWqeTx.value.ui64           = pUM->fcoe.stats.statWqeTx;
1062     pStats->statWqeTxErr.value.ui64        = pUM->fcoe.stats.statWqeTxErr;
1063     pStats->statCqeRx.value.ui64           = pUM->fcoe.stats.statCqeRx;
1064     pStats->statCqeRxErr.value.ui64        = pUM->fcoe.stats.statCqeRxErr;
1065 
1066     BNXE_LOCK_EXIT_STATS(pUM);
1067 
1068     return 0;
1069 }
1070 
1071 
count_trailing_zeros(int number)1072 static int count_trailing_zeros(int number)
1073 {
1074     int x, y, z;
1075 
1076     x = y = z = 0;
1077 
1078     for (y = 7; y >= 0; y--)
1079     {
1080         x = number / (1 << y);
1081         number = number - x * (1 << y);
1082         z++;
1083 
1084         if (x == 1)
1085         {
1086             z = 0;
1087         }
1088     }
1089 
1090     /* Add fix for all zero value */
1091     if (z == 8)
1092     {
1093         z = 0;
1094     }
1095 
1096     return z;
1097 }
1098 
1099 
BnxeKstatDcbxUpdate(kstat_t * kstats,int rw)1100 static int BnxeKstatDcbxUpdate(kstat_t * kstats,
1101                                int       rw)
1102 {
1103     BnxeKstatDcbx * pStats = (BnxeKstatDcbx *)kstats->ks_data;
1104     um_device_t * pUM      = (um_device_t *)kstats->ks_private;
1105     lm_device_t * pLM      = (lm_device_t *)pUM;
1106     b10_lldp_params_get_t lldp_params;
1107     b10_dcbx_params_get_t dcbx_params;
1108     int fcoe_priority = -1;
1109     int iscsi_priority = -1;
1110     admin_priority_app_table_t * app_table;
1111     char buf[17]; /* 16 max for kstat string */
1112     int i;
1113 
1114     if (rw == KSTAT_WRITE)
1115     {
1116         return EACCES;
1117     }
1118 
1119     lm_dcbx_lldp_read_params(pLM, &lldp_params);
1120     lm_dcbx_read_params(pLM, &dcbx_params);
1121 
1122     BNXE_LOCK_ENTER_STATS(pUM);
1123 
1124     snprintf(pStats->dcbx_sync.value.c, 16, "%s",
1125              (!dcbx_params.config_dcbx_params.dcb_enable) ? "disabled" :
1126              (dcbx_params.dcb_current_oper_state_bitmap &
1127               DCBX_CURRENT_STATE_IS_SYNC) ? "IN SYNC" : "OUT OF SYNC");
1128 
1129     snprintf(pStats->dcbx_vers.value.c, 16, "%s",
1130              (dcbx_params.config_dcbx_params.admin_dcbx_version) ?
1131                  "IEEE" : "CEE");
1132 
1133     snprintf(pStats->overwrite_settings.value.c, 16, "%s",
1134              (dcbx_params.config_dcbx_params.overwrite_settings) ?
1135                  "yes" : "no");
1136 
1137     if (dcbx_params.dcb_current_oper_state_bitmap &
1138         PRIORITY_TAGGING_IS_CURRENTLY_OPERATIONAL)
1139     {
1140         snprintf(pStats->prio_tag.value.c, 16, "operational");
1141 
1142         app_table = dcbx_params.local_priority_app_table;
1143 
1144         for (i = 0; i <= 3; i++)
1145         {
1146             if (app_table[i].valid)
1147             {
1148                 if ((app_table[i].traffic_type == TRAFFIC_TYPE_ETH) &&
1149                     (app_table[i].app_id == 0x8906))
1150                 {
1151                     fcoe_priority = count_trailing_zeros(app_table[i].priority);
1152                 }
1153 
1154                 if ((app_table[i].traffic_type != TRAFFIC_TYPE_ETH) &&
1155                     (app_table[i].app_id == 3260))
1156                 {
1157                     iscsi_priority = count_trailing_zeros(app_table[i].priority);
1158                 }
1159             }
1160         }
1161 
1162         snprintf(pStats->prio_tag_fcoe.value.c,  16, "%d", fcoe_priority);
1163         snprintf(pStats->prio_tag_iscsi.value.c, 16, "%d", iscsi_priority);
1164         snprintf(pStats->prio_tag_net.value.c,   16, "%d",
1165                  dcbx_params.config_dcbx_params.admin_default_priority);
1166     }
1167     else
1168     {
1169         snprintf(pStats->prio_tag.value.c, 16, "not operational");
1170 
1171         snprintf(pStats->prio_tag_fcoe.value.c,  16, "-");
1172         snprintf(pStats->prio_tag_iscsi.value.c, 16, "-");
1173         snprintf(pStats->prio_tag_net.value.c,   16, "-");
1174     }
1175 
1176     if (dcbx_params.dcb_current_oper_state_bitmap &
1177         PFC_IS_CURRENTLY_OPERATIONAL)
1178     {
1179         snprintf(pStats->pfc.value.c, 16, "operational");
1180 
1181 #define GET_PFC_PRIO(f, p)                                     \
1182         snprintf(pStats->f.value.c, 16, "%s",                  \
1183                  ((dcbx_params.local_pfc_bitmap >> (p)) & 1) ? \
1184                      "enabled" : "disabled")
1185 
1186         GET_PFC_PRIO(pfc_prio_0, 0);
1187         GET_PFC_PRIO(pfc_prio_1, 1);
1188         GET_PFC_PRIO(pfc_prio_2, 2);
1189         GET_PFC_PRIO(pfc_prio_3, 3);
1190         GET_PFC_PRIO(pfc_prio_4, 4);
1191         GET_PFC_PRIO(pfc_prio_5, 5);
1192         GET_PFC_PRIO(pfc_prio_6, 6);
1193         GET_PFC_PRIO(pfc_prio_7, 7);
1194     }
1195     else
1196     {
1197         snprintf(pStats->pfc.value.c, 16, "not operational");
1198 
1199 #define NO_PFC_PRIO(f)                       \
1200         snprintf(pStats->f.value.c, 16, "-")
1201 
1202         NO_PFC_PRIO(pfc_prio_0);
1203         NO_PFC_PRIO(pfc_prio_1);
1204         NO_PFC_PRIO(pfc_prio_2);
1205         NO_PFC_PRIO(pfc_prio_3);
1206         NO_PFC_PRIO(pfc_prio_4);
1207         NO_PFC_PRIO(pfc_prio_5);
1208         NO_PFC_PRIO(pfc_prio_6);
1209         NO_PFC_PRIO(pfc_prio_7);
1210     }
1211 
1212     if (dcbx_params.dcb_current_oper_state_bitmap &
1213         ETS_IS_CURRENTLY_OPERATIONAL)
1214     {
1215         snprintf(pStats->ets.value.c, 16, "operational");
1216 
1217 #define GET_PRIO_PG(f, p)                                   \
1218         snprintf(pStats->f.value.c, 16, "%d",               \
1219                  dcbx_params.local_configuration_ets_pg[p])
1220 
1221         GET_PRIO_PG(ets_prio_0_pg, 0);
1222         GET_PRIO_PG(ets_prio_1_pg, 1);
1223         GET_PRIO_PG(ets_prio_2_pg, 2);
1224         GET_PRIO_PG(ets_prio_3_pg, 3);
1225         GET_PRIO_PG(ets_prio_4_pg, 4);
1226         GET_PRIO_PG(ets_prio_5_pg, 5);
1227         GET_PRIO_PG(ets_prio_6_pg, 6);
1228         GET_PRIO_PG(ets_prio_7_pg, 7);
1229 
1230 #define GET_PG_BW(f, p)                                            \
1231         snprintf(pStats->f.value.c, 16, "%d",                      \
1232                  dcbx_params.local_configuration_bw_percentage[p])
1233 
1234         GET_PG_BW(ets_pg_0_bw, 0);
1235         GET_PG_BW(ets_pg_1_bw, 1);
1236         GET_PG_BW(ets_pg_2_bw, 2);
1237         GET_PG_BW(ets_pg_3_bw, 3);
1238         GET_PG_BW(ets_pg_4_bw, 4);
1239         GET_PG_BW(ets_pg_5_bw, 5);
1240         GET_PG_BW(ets_pg_6_bw, 6);
1241         GET_PG_BW(ets_pg_7_bw, 7);
1242     }
1243     else
1244     {
1245         snprintf(pStats->ets.value.c, 16, "not operational");
1246 
1247 #define NO_PRIO_PG(f)                        \
1248         snprintf(pStats->f.value.c, 16, "-")
1249 
1250         NO_PRIO_PG(ets_prio_0_pg);
1251         NO_PRIO_PG(ets_prio_1_pg);
1252         NO_PRIO_PG(ets_prio_2_pg);
1253         NO_PRIO_PG(ets_prio_3_pg);
1254         NO_PRIO_PG(ets_prio_4_pg);
1255         NO_PRIO_PG(ets_prio_5_pg);
1256         NO_PRIO_PG(ets_prio_6_pg);
1257         NO_PRIO_PG(ets_prio_7_pg);
1258 
1259 #define NO_PG_BW(f)                          \
1260         snprintf(pStats->f.value.c, 16, "-")
1261 
1262         NO_PG_BW(ets_pg_0_bw);
1263         NO_PG_BW(ets_pg_1_bw);
1264         NO_PG_BW(ets_pg_2_bw);
1265         NO_PG_BW(ets_pg_3_bw);
1266         NO_PG_BW(ets_pg_4_bw);
1267         NO_PG_BW(ets_pg_5_bw);
1268         NO_PG_BW(ets_pg_6_bw);
1269         NO_PG_BW(ets_pg_7_bw);
1270     }
1271 
1272     if (lldp_params.admin_status && (lldp_params.admin_status != LLDP_DISABLED))
1273     {
1274         snprintf(pStats->lldp.value.c, 16, "%s",
1275                  (lldp_params.admin_status == LLDP_TX_ONLY)  ? "tx only"   :
1276                  (lldp_params.admin_status == LLDP_RX_ONLY)  ? "rx only"   :
1277                  (lldp_params.admin_status == LLDP_TX_RX)    ? "tx and rx" :
1278                                                                "unknown");
1279         snprintf(pStats->lldp_tx_interval.value.c, 16, "%d seconds",
1280                  lldp_params.config_lldp_params.msg_tx_interval);
1281         snprintf(pStats->lldp_tx_fast_interval.value.c, 16, "%d seconds",
1282                  lldp_params.config_lldp_params.msg_fast_tx);
1283     }
1284     else
1285     {
1286         snprintf(pStats->lldp.value.c, 16, "disabled");
1287         snprintf(pStats->lldp_tx_interval.value.c, 16, "-");
1288         snprintf(pStats->lldp_tx_fast_interval.value.c, 16, "-");
1289     }
1290 
1291     /* -------------------- ADMIN MIB -------------------- */
1292 
1293     snprintf(pStats->amib_apptlv_willing.value.c, 16, "%s",
1294              (dcbx_params.config_dcbx_params.admin_app_priority_willing) ?
1295                  "willing" : "not willing");
1296     snprintf(pStats->amib_apptlv_tx.value.c, 16, "%s",
1297              (dcbx_params.config_dcbx_params.admin_application_priority_tx_enable) ?
1298                  "enabled" : "disabled");
1299     snprintf(pStats->amib_apptlv_net_prio.value.c, 16, "%d",
1300              dcbx_params.config_dcbx_params.admin_default_priority);
1301 
1302 #define GET_PRIO_APP_TABLE(table, f1, f2)                   \
1303     if (table.valid)                                        \
1304     {                                                       \
1305         snprintf(pStats->f1.value.c, 16, "%d",              \
1306                  count_trailing_zeros(table.priority));     \
1307         snprintf(pStats->f2.value.c, 16,                    \
1308                  (table.traffic_type == TRAFFIC_TYPE_ETH) ? \
1309                      "ether=0x%x" : "port=%d",              \
1310                  table.app_id);                             \
1311     }                                                       \
1312     else                                                    \
1313     {                                                       \
1314         snprintf(pStats->f1.value.c, 16, "-");              \
1315         snprintf(pStats->f2.value.c, 16, "-");              \
1316     }
1317 
1318     GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params.
1319                        admin_priority_app_table[0],
1320                        amib_apptlv_tbl_0_prio,
1321                        amib_apptlv_tbl_0_appid);
1322     GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params.
1323                        admin_priority_app_table[1],
1324                        amib_apptlv_tbl_1_prio,
1325                        amib_apptlv_tbl_1_appid);
1326     GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params.
1327                        admin_priority_app_table[2],
1328                        amib_apptlv_tbl_2_prio,
1329                        amib_apptlv_tbl_2_appid);
1330     GET_PRIO_APP_TABLE(dcbx_params.config_dcbx_params.
1331                        admin_priority_app_table[3],
1332                        amib_apptlv_tbl_3_prio,
1333                        amib_apptlv_tbl_3_appid);
1334 
1335     snprintf(pStats->amib_pgtlv_willing.value.c, 16, "%s",
1336              (dcbx_params.config_dcbx_params.admin_ets_willing) ?
1337                  "willing" : "not willing");
1338     snprintf(pStats->amib_pgtlv_tx.value.c, 16, "%s",
1339              (dcbx_params.config_dcbx_params.admin_ets_configuration_tx_enable) ?
1340                  "enabled" : "disabled");
1341     snprintf(pStats->amib_pgtlv_tc_supported.value.c, 16, "%s",
1342              (dcbx_params.config_dcbx_params.admin_tc_supported_tx_enable) ?
1343                  "advertised" : "not advertised");
1344     snprintf(pStats->amib_pgtlv_ets.value.c, 16, "%s",
1345              (dcbx_params.config_dcbx_params.admin_ets_enable) ?
1346                  "enabled" : "disabled");
1347 
1348 #define AMIB_GET_PG_TLV_BW(f, p)                       \
1349         snprintf(pStats->f.value.c, 16, "%d",          \
1350                  dcbx_params.config_dcbx_params.       \
1351                  admin_configuration_bw_percentage[p])
1352 
1353     AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_0_bw, 0);
1354     AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_1_bw, 1);
1355     AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_2_bw, 2);
1356     AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_3_bw, 3);
1357     AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_4_bw, 4);
1358     AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_5_bw, 5);
1359     AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_6_bw, 6);
1360     AMIB_GET_PG_TLV_BW(amib_pgtlv_pg_7_bw, 7);
1361 
1362 #define AMIB_GET_PG_TLV_MAP(f, p)                \
1363         snprintf(pStats->f.value.c, 16, "%d",    \
1364                  dcbx_params.config_dcbx_params. \
1365                  admin_configuration_ets_pg[p])
1366 
1367     AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_0_map, 0);
1368     AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_1_map, 1);
1369     AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_2_map, 2);
1370     AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_3_map, 3);
1371     AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_4_map, 4);
1372     AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_5_map, 5);
1373     AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_6_map, 6);
1374     AMIB_GET_PG_TLV_MAP(amib_pgtlv_prio_7_map, 7);
1375 
1376     snprintf(pStats->amib_pfctlv_willing.value.c, 16, "%s",
1377              (dcbx_params.config_dcbx_params.admin_pfc_willing) ?
1378                  "willing" : "not willing");
1379     snprintf(pStats->amib_pfctlv_tx.value.c, 16, "%s",
1380              (dcbx_params.config_dcbx_params.admin_pfc_tx_enable) ?
1381                  "enabled" : "disabled");
1382 
1383     if (dcbx_params.config_dcbx_params.admin_pfc_enable)
1384     {
1385         snprintf(pStats->amib_pfctlv_pfc.value.c, 16, "enabled");
1386         snprintf(pStats->amib_pfctlv_pfc_map.value.c, 16, "%d%d%d%d%d%d%d%d",
1387                  (dcbx_params.config_dcbx_params.admin_pfc_bitmap         % 2),
1388                  ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /   2) % 2),
1389                  ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /   4) % 2),
1390                  ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /   8) % 2),
1391                  ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /  16) % 2),
1392                  ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /  32) % 2),
1393                  ((dcbx_params.config_dcbx_params.admin_pfc_bitmap /  64) % 2),
1394                  ((dcbx_params.config_dcbx_params.admin_pfc_bitmap / 128) % 2));
1395     }
1396     else
1397     {
1398         snprintf(pStats->amib_pfctlv_pfc.value.c, 16, "disabled");
1399         snprintf(pStats->amib_pfctlv_pfc_map.value.c, 16, "-");
1400     }
1401 
1402     /* -------------------- REMOTE MIB -------------------- */
1403 
1404     snprintf(pStats->rmib_apptlv_willing.value.c, 16, "%s",
1405              (dcbx_params.remote_app_priority_willing) ?
1406                  "willing" : "not willing");
1407 
1408     GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[0],
1409                        rmib_apptlv_tbl_0_prio,
1410                        rmib_apptlv_tbl_0_appid);
1411     GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[1],
1412                        rmib_apptlv_tbl_1_prio,
1413                        rmib_apptlv_tbl_1_appid);
1414     GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[2],
1415                        rmib_apptlv_tbl_2_prio,
1416                        rmib_apptlv_tbl_2_appid);
1417     GET_PRIO_APP_TABLE(dcbx_params.remote_priority_app_table[3],
1418                        rmib_apptlv_tbl_3_prio,
1419                        rmib_apptlv_tbl_3_appid);
1420 
1421     snprintf(pStats->rmib_pgtlv_willing.value.c, 16, "%s",
1422              (dcbx_params.remote_ets_willing) ?
1423                  "willing" : "not willing");
1424 
1425 #define RMIB_GET_PG_TLV_BW(f, p)                                    \
1426         snprintf(pStats->f.value.c, 16, "%d",                       \
1427                  dcbx_params.remote_configuration_bw_percentage[p])
1428 
1429     RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_0_bw, 0);
1430     RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_1_bw, 1);
1431     RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_2_bw, 2);
1432     RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_3_bw, 3);
1433     RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_4_bw, 4);
1434     RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_5_bw, 5);
1435     RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_6_bw, 6);
1436     RMIB_GET_PG_TLV_BW(rmib_pgtlv_pg_7_bw, 7);
1437 
1438 #define RMIB_GET_PG_TLV_MAP(f, p)                            \
1439         snprintf(pStats->f.value.c, 16, "%d",                \
1440                  dcbx_params.remote_configuration_ets_pg[p])
1441 
1442     RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_0_map, 0);
1443     RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_1_map, 1);
1444     RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_2_map, 2);
1445     RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_3_map, 3);
1446     RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_4_map, 4);
1447     RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_5_map, 5);
1448     RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_6_map, 6);
1449     RMIB_GET_PG_TLV_MAP(rmib_pgtlv_prio_7_map, 7);
1450 
1451     snprintf(pStats->rmib_pgtlv_tc_supported.value.c, 16, "%d",
1452              dcbx_params.remote_tc_supported);
1453 
1454     snprintf(pStats->rmib_pfctlv_willing.value.c, 16, "%s",
1455              (dcbx_params.remote_pfc_willing) ?
1456                  "willing" : "not willing");
1457 
1458     snprintf(pStats->rmib_pfctlv_pfc_map.value.c, 16, "%d%d%d%d%d%d%d%d",
1459              (dcbx_params.remote_pfc_bitmap         % 2),
1460              ((dcbx_params.remote_pfc_bitmap /   2) % 2),
1461              ((dcbx_params.remote_pfc_bitmap /   4) % 2),
1462              ((dcbx_params.remote_pfc_bitmap /   8) % 2),
1463              ((dcbx_params.remote_pfc_bitmap /  16) % 2),
1464              ((dcbx_params.remote_pfc_bitmap /  32) % 2),
1465              ((dcbx_params.remote_pfc_bitmap /  64) % 2),
1466              ((dcbx_params.remote_pfc_bitmap / 128) % 2));
1467 
1468     snprintf(pStats->rmib_pfctlv_capable.value.c, 16, "%d",
1469              dcbx_params.remote_pfc_cap);
1470 
1471     /* -------------------- LOCAL MIB -------------------- */
1472 
1473     GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[0],
1474                        lmib_apptlv_tbl_0_prio,
1475                        lmib_apptlv_tbl_0_appid);
1476     GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[1],
1477                        lmib_apptlv_tbl_1_prio,
1478                        lmib_apptlv_tbl_1_appid);
1479     GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[2],
1480                        lmib_apptlv_tbl_2_prio,
1481                        lmib_apptlv_tbl_2_appid);
1482     GET_PRIO_APP_TABLE(dcbx_params.local_priority_app_table[3],
1483                        lmib_apptlv_tbl_3_prio,
1484                        lmib_apptlv_tbl_3_appid);
1485 
1486     snprintf(pStats->lmib_apptlv_mismatch.value.c, 16, "%s",
1487              (dcbx_params.priority_app_mismatch) ? "yes" : "no");
1488 
1489     snprintf(pStats->lmib_pgtlv_ets.value.c, 16, "%s",
1490              (dcbx_params.local_ets_enable) ?
1491                  "enabled" : "disabled");
1492 
1493 #define LMIB_GET_PG_TLV_BW(f, p)                                   \
1494         snprintf(pStats->f.value.c, 16, "%d",                      \
1495                  dcbx_params.local_configuration_bw_percentage[p])
1496 
1497     LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_0_bw, 0);
1498     LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_1_bw, 1);
1499     LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_2_bw, 2);
1500     LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_3_bw, 3);
1501     LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_4_bw, 4);
1502     LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_5_bw, 5);
1503     LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_6_bw, 6);
1504     LMIB_GET_PG_TLV_BW(lmib_pgtlv_pg_7_bw, 7);
1505 
1506 #define LMIB_GET_PG_TLV_MAP(f, p)                            \
1507         snprintf(pStats->f.value.c, 16, "%d",                \
1508                  dcbx_params.local_configuration_ets_pg[p])
1509 
1510     LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_0_map, 0);
1511     LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_1_map, 1);
1512     LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_2_map, 2);
1513     LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_3_map, 3);
1514     LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_4_map, 4);
1515     LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_5_map, 5);
1516     LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_6_map, 6);
1517     LMIB_GET_PG_TLV_MAP(lmib_pgtlv_prio_7_map, 7);
1518 
1519     snprintf(pStats->lmib_pgtlv_tc_supported.value.c, 16, "%d",
1520              dcbx_params.local_tc_supported);
1521 
1522     if (dcbx_params.local_pfc_enable)
1523     {
1524         snprintf(pStats->lmib_pfctlv_pfc.value.c, 16, "enabled");
1525         snprintf(pStats->lmib_pfctlv_pfc_map.value.c, 16, "%d%d%d%d%d%d%d%d",
1526                  (dcbx_params.local_pfc_bitmap         % 2),
1527                  ((dcbx_params.local_pfc_bitmap /   2) % 2),
1528                  ((dcbx_params.local_pfc_bitmap /   4) % 2),
1529                  ((dcbx_params.local_pfc_bitmap /   8) % 2),
1530                  ((dcbx_params.local_pfc_bitmap /  16) % 2),
1531                  ((dcbx_params.local_pfc_bitmap /  32) % 2),
1532                  ((dcbx_params.local_pfc_bitmap /  64) % 2),
1533                  ((dcbx_params.local_pfc_bitmap / 128) % 2));
1534 
1535         snprintf(pStats->lmib_pfctlv_capable.value.c, 16, "%d",
1536                  dcbx_params.local_pfc_caps);
1537 
1538         snprintf(pStats->lmib_pfctlv_mismatch.value.c, 16, "%s",
1539                  (dcbx_params.pfc_mismatch) ? "yes" : "no");
1540     }
1541     else
1542     {
1543         snprintf(pStats->lmib_pfctlv_pfc.value.c, 16, "disabled");
1544         snprintf(pStats->lmib_pfctlv_pfc_map.value.c, 16, "-");
1545         snprintf(pStats->lmib_pfctlv_capable.value.c, 16, "-");
1546         snprintf(pStats->lmib_pfctlv_mismatch.value.c, 16, "-");
1547     }
1548 
1549     /* --------------------------------------------------- */
1550 
1551     pStats->dcbx_frames_rx.value.ui64 = dcbx_params.dcbx_frames_received;
1552     pStats->dcbx_frames_tx.value.ui64 = dcbx_params.dcbx_frames_sent;
1553     pStats->pfc_frames_rx.value.ui64  = dcbx_params.pfc_frames_received;
1554     pStats->pfc_frames_tx.value.ui64  = dcbx_params.pfc_frames_sent;
1555 
1556     BNXE_LOCK_EXIT_STATS(pUM);
1557 
1558     return 0;
1559 }
1560 
1561 
BnxeKstatRxRingUpdate(kstat_t * kstats,int rw)1562 static int BnxeKstatRxRingUpdate(kstat_t * kstats,
1563                                  int       rw)
1564 {
1565     BnxeKstatRxq *   pStats = (BnxeKstatRxq *)kstats->ks_data;
1566     KstatRingMap *   pMap   = (KstatRingMap *)kstats->ks_private;
1567     um_device_t *    pUM    = (um_device_t *)pMap->pUM;
1568     int              idx    = pMap->idx;
1569     lm_device_t *    pLM    = (lm_device_t *)pUM;
1570     lm_tx_chain_t *  pTxq   = &LM_TXQ(pLM, idx);
1571     lm_rx_chain_t *  pRxq   = &LM_RXQ(pLM, idx);
1572     lm_rcq_chain_t * pRcq   = &LM_RCQ(pLM, idx);
1573 
1574     if (rw == KSTAT_WRITE)
1575     {
1576         return EACCES;
1577     }
1578 
1579     BNXE_LOCK_ENTER_STATS(pUM);
1580 
1581     pStats->rxqBdTotal.value.ui64     = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].capacity;
1582     pStats->rxqBdLeft.value.ui64      = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bd_left;
1583     pStats->rxqBdPageCnt.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].page_cnt;
1584     pStats->rxqBdsPerPage.value.ui64  = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bds_per_page;
1585     pStats->rxqBdSize.value.ui64      = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bd_size;
1586     pStats->rxqBdsSkipEop.value.ui64  = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].bds_skip_eop;
1587     pStats->rxqBdProdIdx.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].prod_idx;
1588     pStats->rxqBdConsIdx.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_BD].cons_idx;
1589     pStats->hwRxqConIdx.value.ui64    =
1590         (pRxq->hw_con_idx_ptr != NULL) ?
1591             mm_le16_to_cpu(*pRxq->hw_con_idx_ptr) : 0;
1592     pStats->sgeBdTotal.value.ui64     = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].capacity;
1593     pStats->sgeBdLeft.value.ui64      = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bd_left;
1594     pStats->sgeBdPageCnt.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].page_cnt;
1595     pStats->sgeBdsPerPage.value.ui64  = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bds_per_page;
1596     pStats->sgeBdSize.value.ui64      = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bd_size;
1597     pStats->sgeBdsSkipEop.value.ui64  = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].bds_skip_eop;
1598     pStats->sgeBdProdIdx.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].prod_idx;
1599     pStats->sgeBdConsIdx.value.ui64   = pRxq->chain_arr[LM_RXQ_CHAIN_IDX_SGE].cons_idx;
1600     pStats->rcqBdTotal.value.ui64     = pRcq->bd_chain.capacity;
1601     pStats->rcqBdLeft.value.ui64      = pRcq->bd_chain.bd_left;
1602     pStats->rcqBdPageCnt.value.ui64   = pRcq->bd_chain.page_cnt;
1603     pStats->rcqBdsPerPage.value.ui64  = pRcq->bd_chain.bds_per_page;
1604     pStats->rcqBdSize.value.ui64      = pRcq->bd_chain.bd_size;
1605     pStats->rcqBdsSkipEop.value.ui64  = pRcq->bd_chain.bds_skip_eop;
1606     pStats->rcqBdProdIdx.value.ui64   = pRcq->bd_chain.prod_idx;
1607     pStats->rcqBdConsIdx.value.ui64   = pRcq->bd_chain.cons_idx;
1608     pStats->hwRcqConIdx.value.ui64    =
1609         (pRcq->hw_con_idx_ptr != NULL) ?
1610             mm_le16_to_cpu(*pRcq->hw_con_idx_ptr) : 0;
1611 
1612     pStats->rxFreeDescs.value.ui64    = s_list_entry_cnt(&LM_RXQ(pLM, idx).common.free_descq);
1613     pStats->rxActiveDescs.value.ui64  = s_list_entry_cnt(&LM_RXQ(pLM, idx).active_descq);
1614     pStats->rxDoneDescs.value.ui64    = s_list_entry_cnt(&pUM->rxq[idx].doneRxQ);
1615     pStats->rxWaitingDescs.value.ui64 = s_list_entry_cnt(&pUM->rxq[idx].waitRxQ);
1616     pStats->rxCopied.value.ui64       = pUM->rxq[idx].rxCopied;
1617     pStats->rxDiscards.value.ui64     = pUM->rxq[idx].rxDiscards;
1618     pStats->rxBufUpInStack.value.ui64 = pUM->rxq[idx].rxBufUpInStack;
1619     pStats->rxLowWater.value.ui64     = pUM->rxq[idx].rxLowWater;
1620     pStats->inPollMode.value.ui64     = pUM->rxq[idx].inPollMode;
1621     pStats->pollCnt.value.ui64        = pUM->rxq[idx].pollCnt;
1622     pStats->intrDisableCnt.value.ui64 = pUM->rxq[idx].intrDisableCnt;
1623     pStats->intrEnableCnt.value.ui64  = pUM->rxq[idx].intrEnableCnt;
1624     pStats->genNumber.value.ui64      = pUM->rxq[idx].genNumber;
1625 
1626     BNXE_LOCK_EXIT_STATS(pUM);
1627 
1628     return 0;
1629 }
1630 
1631 
BnxeKstatTxRingUpdate(kstat_t * kstats,int rw)1632 static int BnxeKstatTxRingUpdate(kstat_t * kstats,
1633                                  int       rw)
1634 {
1635     BnxeKstatTxq * pStats = (BnxeKstatTxq *)kstats->ks_data;
1636     KstatRingMap * pMap   = (KstatRingMap *)kstats->ks_private;
1637     um_device_t *  pUM    = (um_device_t *)pMap->pUM;
1638     int            idx    = pMap->idx;
1639     lm_device_t *  pLM    = (lm_device_t *)pUM;
1640 
1641     if (rw == KSTAT_WRITE)
1642     {
1643         return EACCES;
1644     }
1645 
1646     BNXE_LOCK_ENTER_STATS(pUM);
1647 
1648     pStats->txBdTotal.value.ui64     = LM_TXQ(pLM, idx).bd_chain.capacity;
1649     pStats->txBdLeft.value.ui64      = LM_TXQ(pLM, idx).bd_chain.bd_left;
1650     pStats->txBdPageCnt.value.ui64   = LM_TXQ(pLM, idx).bd_chain.page_cnt;
1651     pStats->txBdsPerPage.value.ui64  = LM_TXQ(pLM, idx).bd_chain.bds_per_page;
1652     pStats->txBdSize.value.ui64      = LM_TXQ(pLM, idx).bd_chain.bd_size;
1653     pStats->txBdsSkipEop.value.ui64  = LM_TXQ(pLM, idx).bd_chain.bds_skip_eop;
1654     pStats->hwTxqConIdx.value.ui64   =
1655         (LM_TXQ(pLM, idx).hw_con_idx_ptr != NULL) ?
1656             mm_le16_to_cpu(*LM_TXQ(pLM, idx).hw_con_idx_ptr) : 0;
1657     pStats->txPktIdx.value.ui64      = LM_TXQ(pLM, idx).pkt_idx;
1658     pStats->txBdProdIdx.value.ui64   = LM_TXQ(pLM, idx).bd_chain.prod_idx;
1659     pStats->txBdConsIdx.value.ui64   = LM_TXQ(pLM, idx).bd_chain.cons_idx;
1660     pStats->txSentPkts.value.ui64    = s_list_entry_cnt(&pUM->txq[idx].sentTxQ);
1661     pStats->txFreeDesc.value.ui64    = s_list_entry_cnt(&pUM->txq[idx].freeTxDescQ);
1662     pStats->txWaitingPkts.value.ui64 = s_list_entry_cnt(&pUM->txq[idx].waitTxDescQ);
1663     pStats->txLowWater.value.ui64    = pUM->txq[idx].txLowWater;
1664     pStats->txFailed.value.ui64      = pUM->txq[idx].txFailed;
1665     pStats->txDiscards.value.ui64    = pUM->txq[idx].txDiscards;
1666     pStats->txRecycle.value.ui64     = pUM->txq[idx].txRecycle;
1667     pStats->txCopied.value.ui64      = pUM->txq[idx].txCopied;
1668     pStats->txBlocked.value.ui64     = pUM->txq[idx].txBlocked;
1669     pStats->txWait.value.ui64        = pUM->txq[idx].txWait;
1670 
1671     BNXE_LOCK_EXIT_STATS(pUM);
1672 
1673     return 0;
1674 }
1675 
1676 
BnxeKstatInitRxQ(um_device_t * pUM,int idx)1677 boolean_t BnxeKstatInitRxQ(um_device_t * pUM,
1678                            int           idx)
1679 {
1680     char buf[32];
1681 
1682     BnxeKstatRxq * pStatsRxq;
1683 #define BNXE_KSTAT_RXQ(f, t)  kstat_named_init(&pStatsRxq->f, #f, t)
1684 
1685     snprintf(buf, sizeof(buf), "rxq%d", idx);
1686 
1687     if ((pUM->kstats_rxq[idx] = kstat_create("bnxe",
1688                                              pUM->instance,
1689                                              buf,
1690                                              "net",
1691                                              KSTAT_TYPE_NAMED,
1692                                              BNXE_KSTAT_RXQ_SIZE,
1693                                              0)) == NULL)
1694     {
1695         BnxeLogWarn(pUM, "Failed to create rxq%d kstat", idx);
1696         return B_FALSE;
1697     }
1698 
1699     pStatsRxq = (BnxeKstatRxq *)pUM->kstats_rxq[idx]->ks_data;
1700 
1701     BNXE_KSTAT_RXQ(rxqBdTotal,     KSTAT_DATA_UINT64);
1702     BNXE_KSTAT_RXQ(rxqBdLeft,      KSTAT_DATA_UINT64);
1703     BNXE_KSTAT_RXQ(rxqBdPageCnt,   KSTAT_DATA_UINT64);
1704     BNXE_KSTAT_RXQ(rxqBdsPerPage,  KSTAT_DATA_UINT64);
1705     BNXE_KSTAT_RXQ(rxqBdSize,      KSTAT_DATA_UINT64);
1706     BNXE_KSTAT_RXQ(rxqBdsSkipEop,  KSTAT_DATA_UINT64);
1707     BNXE_KSTAT_RXQ(rxqBdProdIdx,   KSTAT_DATA_UINT64);
1708     BNXE_KSTAT_RXQ(rxqBdConsIdx,   KSTAT_DATA_UINT64);
1709     BNXE_KSTAT_RXQ(hwRxqConIdx,    KSTAT_DATA_UINT64);
1710     BNXE_KSTAT_RXQ(sgeBdTotal,     KSTAT_DATA_UINT64);
1711     BNXE_KSTAT_RXQ(sgeBdLeft,      KSTAT_DATA_UINT64);
1712     BNXE_KSTAT_RXQ(sgeBdPageCnt,   KSTAT_DATA_UINT64);
1713     BNXE_KSTAT_RXQ(sgeBdsPerPage,  KSTAT_DATA_UINT64);
1714     BNXE_KSTAT_RXQ(sgeBdSize,      KSTAT_DATA_UINT64);
1715     BNXE_KSTAT_RXQ(sgeBdsSkipEop,  KSTAT_DATA_UINT64);
1716     BNXE_KSTAT_RXQ(sgeBdProdIdx,   KSTAT_DATA_UINT64);
1717     BNXE_KSTAT_RXQ(sgeBdConsIdx,   KSTAT_DATA_UINT64);
1718     BNXE_KSTAT_RXQ(rcqBdTotal,     KSTAT_DATA_UINT64);
1719     BNXE_KSTAT_RXQ(rcqBdLeft,      KSTAT_DATA_UINT64);
1720     BNXE_KSTAT_RXQ(rcqBdPageCnt,   KSTAT_DATA_UINT64);
1721     BNXE_KSTAT_RXQ(rcqBdsPerPage,  KSTAT_DATA_UINT64);
1722     BNXE_KSTAT_RXQ(rcqBdSize,      KSTAT_DATA_UINT64);
1723     BNXE_KSTAT_RXQ(rcqBdsSkipEop,  KSTAT_DATA_UINT64);
1724     BNXE_KSTAT_RXQ(rcqBdProdIdx,   KSTAT_DATA_UINT64);
1725     BNXE_KSTAT_RXQ(rcqBdConsIdx,   KSTAT_DATA_UINT64);
1726     BNXE_KSTAT_RXQ(hwRcqConIdx,    KSTAT_DATA_UINT64);
1727     BNXE_KSTAT_RXQ(rxFreeDescs,    KSTAT_DATA_UINT64);
1728     BNXE_KSTAT_RXQ(rxActiveDescs,  KSTAT_DATA_UINT64);
1729     BNXE_KSTAT_RXQ(rxDoneDescs,    KSTAT_DATA_UINT64);
1730     BNXE_KSTAT_RXQ(rxWaitingDescs, KSTAT_DATA_UINT64);
1731     BNXE_KSTAT_RXQ(rxCopied,       KSTAT_DATA_UINT64);
1732     BNXE_KSTAT_RXQ(rxDiscards,     KSTAT_DATA_UINT64);
1733     BNXE_KSTAT_RXQ(rxBufUpInStack, KSTAT_DATA_UINT64);
1734     BNXE_KSTAT_RXQ(rxLowWater,     KSTAT_DATA_UINT64);
1735     BNXE_KSTAT_RXQ(inPollMode,     KSTAT_DATA_UINT64);
1736     BNXE_KSTAT_RXQ(pollCnt,        KSTAT_DATA_UINT64);
1737     BNXE_KSTAT_RXQ(intrDisableCnt, KSTAT_DATA_UINT64);
1738     BNXE_KSTAT_RXQ(intrEnableCnt,  KSTAT_DATA_UINT64);
1739     BNXE_KSTAT_RXQ(genNumber,      KSTAT_DATA_UINT64);
1740 
1741     pUM->kstats_rxq_map[idx].idx = idx;
1742     pUM->kstats_rxq_map[idx].pUM = pUM;
1743 
1744     pUM->kstats_rxq[idx]->ks_update  = BnxeKstatRxRingUpdate;
1745     pUM->kstats_rxq[idx]->ks_private = (void *)&pUM->kstats_rxq_map[idx];
1746 
1747     kstat_install(pUM->kstats_rxq[idx]);
1748 
1749     return B_TRUE;
1750 }
1751 
1752 
BnxeKstatInitTxQ(um_device_t * pUM,int idx)1753 boolean_t BnxeKstatInitTxQ(um_device_t * pUM,
1754                            int           idx)
1755 {
1756     char buf[32];
1757 
1758     BnxeKstatTxq * pStatsTxq;
1759 #define BNXE_KSTAT_TXQ(f, t)  kstat_named_init(&pStatsTxq->f, #f, t)
1760 
1761     snprintf(buf, sizeof(buf), "txq%d", idx);
1762 
1763     if ((pUM->kstats_txq[idx] = kstat_create("bnxe",
1764                                              pUM->instance,
1765                                              buf,
1766                                              "net",
1767                                              KSTAT_TYPE_NAMED,
1768                                              BNXE_KSTAT_TXQ_SIZE,
1769                                              0)) == NULL)
1770     {
1771         BnxeLogWarn(pUM, "Failed to create txq%d kstat", idx);
1772         return B_FALSE;
1773     }
1774 
1775     pStatsTxq = (BnxeKstatTxq *)pUM->kstats_txq[idx]->ks_data;
1776 
1777     BNXE_KSTAT_TXQ(txBdTotal,     KSTAT_DATA_UINT64);
1778     BNXE_KSTAT_TXQ(txBdLeft,      KSTAT_DATA_UINT64);
1779     BNXE_KSTAT_TXQ(txBdPageCnt,   KSTAT_DATA_UINT64);
1780     BNXE_KSTAT_TXQ(txBdsPerPage,  KSTAT_DATA_UINT64);
1781     BNXE_KSTAT_TXQ(txBdSize,      KSTAT_DATA_UINT64);
1782     BNXE_KSTAT_TXQ(txBdsSkipEop,  KSTAT_DATA_UINT64);
1783     BNXE_KSTAT_TXQ(hwTxqConIdx,   KSTAT_DATA_UINT64);
1784     BNXE_KSTAT_TXQ(txPktIdx,      KSTAT_DATA_UINT64);
1785     BNXE_KSTAT_TXQ(txBdProdIdx,   KSTAT_DATA_UINT64);
1786     BNXE_KSTAT_TXQ(txBdConsIdx,   KSTAT_DATA_UINT64);
1787     BNXE_KSTAT_TXQ(txSentPkts,    KSTAT_DATA_UINT64);
1788     BNXE_KSTAT_TXQ(txFreeDesc,    KSTAT_DATA_UINT64);
1789     BNXE_KSTAT_TXQ(txWaitingPkts, KSTAT_DATA_UINT64);
1790     BNXE_KSTAT_TXQ(txLowWater,    KSTAT_DATA_UINT64);
1791     BNXE_KSTAT_TXQ(txFailed,      KSTAT_DATA_UINT64);
1792     BNXE_KSTAT_TXQ(txDiscards,    KSTAT_DATA_UINT64);
1793     BNXE_KSTAT_TXQ(txRecycle,     KSTAT_DATA_UINT64);
1794     BNXE_KSTAT_TXQ(txCopied,      KSTAT_DATA_UINT64);
1795     BNXE_KSTAT_TXQ(txBlocked,     KSTAT_DATA_UINT64);
1796     BNXE_KSTAT_TXQ(txWait,        KSTAT_DATA_UINT64);
1797 
1798     pUM->kstats_txq_map[idx].idx = idx;
1799     pUM->kstats_txq_map[idx].pUM = pUM;
1800 
1801     pUM->kstats_txq[idx]->ks_update  = BnxeKstatTxRingUpdate;
1802     pUM->kstats_txq[idx]->ks_private = (void *)&pUM->kstats_txq_map[idx];
1803 
1804     kstat_install(pUM->kstats_txq[idx]);
1805 
1806     return B_TRUE;
1807 }
1808 
1809 
BnxeKstatInit(um_device_t * pUM)1810 boolean_t BnxeKstatInit(um_device_t * pUM)
1811 {
1812     lm_device_t * pLM = (lm_device_t *)pUM;
1813     char buf[32];
1814     int idx;
1815 
1816     BnxeKstat *         pStats;
1817     BnxeKstatLink *     pStatsLink;
1818     BnxeKstatIntr *     pStatsIntr;
1819     BnxeKstatL2Chip *   pStatsL2Chip;
1820     BnxeKstatL2Driver * pStatsL2Driver;
1821     BnxeKstatEthStats * pStatsL2Stats;
1822     BnxeKstatFcoe *     pStatsFcoe;
1823     BnxeKstatDcbx *     pStatsDcbx;
1824 #define BNXE_KSTAT(f, t)            kstat_named_init(&pStats->f, #f, t)
1825 #define BNXE_KSTAT_LINK(f, t)       kstat_named_init(&pStatsLink->f, #f, t)
1826 #define BNXE_KSTAT_INTR(f, t)       kstat_named_init(&pStatsIntr->f, #f, t)
1827 #define BNXE_KSTAT_L2_CHIP(f, t)    kstat_named_init(&pStatsL2Chip->f, #f, t)
1828 #define BNXE_KSTAT_L2_DRIVER(f, t)  kstat_named_init(&pStatsL2Driver->f, #f, t)
1829 #define BNXE_KSTAT_L2_STATS(f, t)   kstat_named_init(&pStatsL2Stats->f, #f, t)
1830 #define BNXE_KSTAT_FCOE(f, t)       kstat_named_init(&pStatsFcoe->f, #f, t)
1831 #define BNXE_KSTAT_DCBX(f, t)       kstat_named_init(&pStatsDcbx->f, #f, t)
1832 
1833     /****************************************************************/
1834 
1835     if ((pUM->kstats = kstat_create("bnxe",
1836                                     pUM->instance,
1837                                     "stats",
1838                                     "net",
1839                                     KSTAT_TYPE_NAMED,
1840                                     BNXE_KSTAT_SIZE,
1841                                     0)) == NULL)
1842     {
1843         BnxeLogWarn(pUM, "Failed to create kstat");
1844         return B_FALSE;
1845     }
1846 
1847     pStats = (BnxeKstat *)pUM->kstats->ks_data;
1848 
1849     BNXE_KSTAT(umdev_hi,               KSTAT_DATA_CHAR);
1850     BNXE_KSTAT(umdev_lo,               KSTAT_DATA_CHAR);
1851     BNXE_KSTAT(version,                KSTAT_DATA_CHAR);
1852     BNXE_KSTAT(versionFW,              KSTAT_DATA_CHAR);
1853     BNXE_KSTAT(versionBC,              KSTAT_DATA_CHAR);
1854     BNXE_KSTAT(chipName,               KSTAT_DATA_CHAR);
1855     BNXE_KSTAT(chipID,                 KSTAT_DATA_CHAR);
1856     BNXE_KSTAT(devBDF,                 KSTAT_DATA_CHAR);
1857     BNXE_KSTAT(devID,                  KSTAT_DATA_CHAR);
1858     BNXE_KSTAT(multiFunction,          KSTAT_DATA_CHAR);
1859     BNXE_KSTAT(multiFunctionVnics,     KSTAT_DATA_UINT64);
1860     BNXE_KSTAT(macAddr,                KSTAT_DATA_CHAR);
1861     BNXE_KSTAT(hwInitDone,             KSTAT_DATA_UINT64);
1862     BNXE_KSTAT(clientsHw,              KSTAT_DATA_CHAR);
1863     BNXE_KSTAT(clientsDevi,            KSTAT_DATA_CHAR);
1864     BNXE_KSTAT(clientsBound,           KSTAT_DATA_CHAR);
1865     BNXE_KSTAT(txMsgPullUp,            KSTAT_DATA_UINT64);
1866     BNXE_KSTAT(intrAlloc,              KSTAT_DATA_CHAR);
1867     BNXE_KSTAT(intrFired,              KSTAT_DATA_UINT64);
1868     BNXE_KSTAT(timerFired,             KSTAT_DATA_UINT64);
1869     BNXE_KSTAT(timerReply,             KSTAT_DATA_UINT64);
1870     BNXE_KSTAT(timerNoReplyTotal,      KSTAT_DATA_UINT64);
1871     BNXE_KSTAT(timerNoReplyCurrent,    KSTAT_DATA_UINT64);
1872     BNXE_KSTAT(timerDone,              KSTAT_DATA_UINT64);
1873     BNXE_KSTAT(workQueueInstCnt,       KSTAT_DATA_UINT64);
1874     BNXE_KSTAT(workItemInstQueued,     KSTAT_DATA_UINT64);
1875     BNXE_KSTAT(workItemInstError,      KSTAT_DATA_UINT64);
1876     BNXE_KSTAT(workItemInstComplete,   KSTAT_DATA_UINT64);
1877     BNXE_KSTAT(workItemInstHighWater,  KSTAT_DATA_UINT64);
1878     BNXE_KSTAT(workQueueDelayCnt,      KSTAT_DATA_UINT64);
1879     BNXE_KSTAT(workItemDelayQueued,    KSTAT_DATA_UINT64);
1880     BNXE_KSTAT(workItemDelayError,     KSTAT_DATA_UINT64);
1881     BNXE_KSTAT(workItemDelayComplete,  KSTAT_DATA_UINT64);
1882     BNXE_KSTAT(workItemDelayHighWater, KSTAT_DATA_UINT64);
1883     BNXE_KSTAT(memAllocBlocks,         KSTAT_DATA_UINT64);
1884     BNXE_KSTAT(memAllocDMAs,           KSTAT_DATA_UINT64);
1885     BNXE_KSTAT(memAllocBARs,           KSTAT_DATA_UINT64);
1886 
1887     pUM->kstats->ks_update  = BnxeKstatUpdate;
1888     pUM->kstats->ks_private = (void *)pUM;
1889 
1890     kstat_install(pUM->kstats);
1891 
1892     /****************************************************************/
1893 
1894     if ((pUM->kstatsLink = kstat_create("bnxe",
1895                                         pUM->instance,
1896                                         "link",
1897                                         "net",
1898                                         KSTAT_TYPE_NAMED,
1899                                         BNXE_KSTAT_LINK_SIZE,
1900                                         0)) == NULL)
1901     {
1902         BnxeLogWarn(pUM, "Failed to create link kstat");
1903         return B_FALSE;
1904     }
1905 
1906     pStatsLink = (BnxeKstatLink *)pUM->kstatsLink->ks_data;
1907 
1908     BNXE_KSTAT_LINK(clients, KSTAT_DATA_CHAR);
1909     BNXE_KSTAT_LINK(uptime,  KSTAT_DATA_UINT64);
1910     BNXE_KSTAT_LINK(mtuL2,   KSTAT_DATA_UINT64);
1911     BNXE_KSTAT_LINK(mtuFCOE, KSTAT_DATA_UINT64);
1912     BNXE_KSTAT_LINK(speed,   KSTAT_DATA_UINT64);
1913     BNXE_KSTAT_LINK(link,    KSTAT_DATA_UINT64);
1914     BNXE_KSTAT_LINK(duplex,  KSTAT_DATA_UINT64);
1915     BNXE_KSTAT_LINK(pauseRx, KSTAT_DATA_UINT64);
1916     BNXE_KSTAT_LINK(pauseTx, KSTAT_DATA_UINT64);
1917 
1918     pUM->kstatsLink->ks_update  = BnxeKstatLinkUpdate;
1919     pUM->kstatsLink->ks_private = (void *)pUM;
1920 
1921     kstat_install(pUM->kstatsLink);
1922 
1923     /****************************************************************/
1924 
1925     if ((pUM->kstatsIntr = kstat_create("bnxe",
1926                                         pUM->instance,
1927                                         "intr",
1928                                         "net",
1929                                         KSTAT_TYPE_NAMED,
1930                                         BNXE_KSTAT_INTR_SIZE,
1931                                         0)) == NULL)
1932     {
1933         BnxeLogWarn(pUM, "Failed to create intr kstat");
1934         return B_FALSE;
1935     }
1936 
1937     pStatsIntr = (BnxeKstatIntr *)pUM->kstatsIntr->ks_data;
1938 
1939     BNXE_KSTAT_INTR(intrAlloc,      KSTAT_DATA_CHAR);
1940     BNXE_KSTAT_INTR(intrFired,      KSTAT_DATA_UINT64);
1941     BNXE_KSTAT_INTR(intrWrongState, KSTAT_DATA_UINT64);
1942     BNXE_KSTAT_INTR(intrInDisabled, KSTAT_DATA_UINT64);
1943     BNXE_KSTAT_INTR(intrZeroStatus, KSTAT_DATA_UINT64);
1944     BNXE_KSTAT_INTR(sb_00,          KSTAT_DATA_UINT64);
1945     BNXE_KSTAT_INTR(sb_01,          KSTAT_DATA_UINT64);
1946     BNXE_KSTAT_INTR(sb_02,          KSTAT_DATA_UINT64);
1947     BNXE_KSTAT_INTR(sb_03,          KSTAT_DATA_UINT64);
1948     BNXE_KSTAT_INTR(sb_04,          KSTAT_DATA_UINT64);
1949     BNXE_KSTAT_INTR(sb_05,          KSTAT_DATA_UINT64);
1950     BNXE_KSTAT_INTR(sb_06,          KSTAT_DATA_UINT64);
1951     BNXE_KSTAT_INTR(sb_07,          KSTAT_DATA_UINT64);
1952     BNXE_KSTAT_INTR(sb_08,          KSTAT_DATA_UINT64);
1953     BNXE_KSTAT_INTR(sb_09,          KSTAT_DATA_UINT64);
1954     BNXE_KSTAT_INTR(sb_10,          KSTAT_DATA_UINT64);
1955     BNXE_KSTAT_INTR(sb_11,          KSTAT_DATA_UINT64);
1956     BNXE_KSTAT_INTR(sb_12,          KSTAT_DATA_UINT64);
1957     BNXE_KSTAT_INTR(sb_13,          KSTAT_DATA_UINT64);
1958     BNXE_KSTAT_INTR(sb_14,          KSTAT_DATA_UINT64);
1959     BNXE_KSTAT_INTR(sb_15,          KSTAT_DATA_UINT64);
1960     BNXE_KSTAT_INTR(sb_16,          KSTAT_DATA_UINT64);
1961     BNXE_KSTAT_INTR(sb_nc_00,       KSTAT_DATA_UINT64);
1962     BNXE_KSTAT_INTR(sb_nc_01,       KSTAT_DATA_UINT64);
1963     BNXE_KSTAT_INTR(sb_nc_02,       KSTAT_DATA_UINT64);
1964     BNXE_KSTAT_INTR(sb_nc_03,       KSTAT_DATA_UINT64);
1965     BNXE_KSTAT_INTR(sb_nc_04,       KSTAT_DATA_UINT64);
1966     BNXE_KSTAT_INTR(sb_nc_05,       KSTAT_DATA_UINT64);
1967     BNXE_KSTAT_INTR(sb_nc_06,       KSTAT_DATA_UINT64);
1968     BNXE_KSTAT_INTR(sb_nc_07,       KSTAT_DATA_UINT64);
1969     BNXE_KSTAT_INTR(sb_nc_08,       KSTAT_DATA_UINT64);
1970     BNXE_KSTAT_INTR(sb_nc_09,       KSTAT_DATA_UINT64);
1971     BNXE_KSTAT_INTR(sb_nc_10,       KSTAT_DATA_UINT64);
1972     BNXE_KSTAT_INTR(sb_nc_11,       KSTAT_DATA_UINT64);
1973     BNXE_KSTAT_INTR(sb_nc_12,       KSTAT_DATA_UINT64);
1974     BNXE_KSTAT_INTR(sb_nc_13,       KSTAT_DATA_UINT64);
1975     BNXE_KSTAT_INTR(sb_nc_14,       KSTAT_DATA_UINT64);
1976     BNXE_KSTAT_INTR(sb_nc_15,       KSTAT_DATA_UINT64);
1977     BNXE_KSTAT_INTR(sb_nc_16,       KSTAT_DATA_UINT64);
1978     BNXE_KSTAT_INTR(sb_poll_00,     KSTAT_DATA_UINT64);
1979     BNXE_KSTAT_INTR(sb_poll_01,     KSTAT_DATA_UINT64);
1980     BNXE_KSTAT_INTR(sb_poll_02,     KSTAT_DATA_UINT64);
1981     BNXE_KSTAT_INTR(sb_poll_03,     KSTAT_DATA_UINT64);
1982     BNXE_KSTAT_INTR(sb_poll_04,     KSTAT_DATA_UINT64);
1983     BNXE_KSTAT_INTR(sb_poll_05,     KSTAT_DATA_UINT64);
1984     BNXE_KSTAT_INTR(sb_poll_06,     KSTAT_DATA_UINT64);
1985     BNXE_KSTAT_INTR(sb_poll_07,     KSTAT_DATA_UINT64);
1986     BNXE_KSTAT_INTR(sb_poll_08,     KSTAT_DATA_UINT64);
1987     BNXE_KSTAT_INTR(sb_poll_09,     KSTAT_DATA_UINT64);
1988     BNXE_KSTAT_INTR(sb_poll_10,     KSTAT_DATA_UINT64);
1989     BNXE_KSTAT_INTR(sb_poll_11,     KSTAT_DATA_UINT64);
1990     BNXE_KSTAT_INTR(sb_poll_12,     KSTAT_DATA_UINT64);
1991     BNXE_KSTAT_INTR(sb_poll_13,     KSTAT_DATA_UINT64);
1992     BNXE_KSTAT_INTR(sb_poll_14,     KSTAT_DATA_UINT64);
1993     BNXE_KSTAT_INTR(sb_poll_15,     KSTAT_DATA_UINT64);
1994     BNXE_KSTAT_INTR(sb_poll_16,     KSTAT_DATA_UINT64);
1995     BNXE_KSTAT_INTR(sb_poll_nc_00,  KSTAT_DATA_UINT64);
1996     BNXE_KSTAT_INTR(sb_poll_nc_01,  KSTAT_DATA_UINT64);
1997     BNXE_KSTAT_INTR(sb_poll_nc_02,  KSTAT_DATA_UINT64);
1998     BNXE_KSTAT_INTR(sb_poll_nc_03,  KSTAT_DATA_UINT64);
1999     BNXE_KSTAT_INTR(sb_poll_nc_04,  KSTAT_DATA_UINT64);
2000     BNXE_KSTAT_INTR(sb_poll_nc_05,  KSTAT_DATA_UINT64);
2001     BNXE_KSTAT_INTR(sb_poll_nc_06,  KSTAT_DATA_UINT64);
2002     BNXE_KSTAT_INTR(sb_poll_nc_07,  KSTAT_DATA_UINT64);
2003     BNXE_KSTAT_INTR(sb_poll_nc_08,  KSTAT_DATA_UINT64);
2004     BNXE_KSTAT_INTR(sb_poll_nc_09,  KSTAT_DATA_UINT64);
2005     BNXE_KSTAT_INTR(sb_poll_nc_10,  KSTAT_DATA_UINT64);
2006     BNXE_KSTAT_INTR(sb_poll_nc_11,  KSTAT_DATA_UINT64);
2007     BNXE_KSTAT_INTR(sb_poll_nc_12,  KSTAT_DATA_UINT64);
2008     BNXE_KSTAT_INTR(sb_poll_nc_13,  KSTAT_DATA_UINT64);
2009     BNXE_KSTAT_INTR(sb_poll_nc_14,  KSTAT_DATA_UINT64);
2010     BNXE_KSTAT_INTR(sb_poll_nc_15,  KSTAT_DATA_UINT64);
2011     BNXE_KSTAT_INTR(sb_poll_nc_16,  KSTAT_DATA_UINT64);
2012 
2013     pUM->kstatsIntr->ks_update  = BnxeKstatIntrUpdate;
2014     pUM->kstatsIntr->ks_private = (void *)pUM;
2015 
2016     kstat_install(pUM->kstatsIntr);
2017 
2018     /****************************************************************/
2019 
2020     if ((pUM->kstatsL2Chip = kstat_create("bnxe",
2021                                           pUM->instance,
2022                                           "l2chip",
2023                                           "net",
2024                                           KSTAT_TYPE_NAMED,
2025                                           BNXE_KSTAT_L2_CHIP_SIZE,
2026                                           0)) == NULL)
2027     {
2028         BnxeLogWarn(pUM, "Failed to create l2chip kstat");
2029         return B_FALSE;
2030     }
2031 
2032     pStatsL2Chip = (BnxeKstatL2Chip *)pUM->kstatsL2Chip->ks_data;
2033 
2034     BNXE_KSTAT_L2_CHIP(IfHCInOctets,                       KSTAT_DATA_UINT64);
2035     BNXE_KSTAT_L2_CHIP(IfHCInBadOctets,                    KSTAT_DATA_UINT64);
2036     BNXE_KSTAT_L2_CHIP(IfHCOutOctets,                      KSTAT_DATA_UINT64);
2037     BNXE_KSTAT_L2_CHIP(IfHCOutBadOctets,                   KSTAT_DATA_UINT64);
2038     BNXE_KSTAT_L2_CHIP(IfHCOutPkts,                        KSTAT_DATA_UINT64);
2039     BNXE_KSTAT_L2_CHIP(IfHCInPkts,                         KSTAT_DATA_UINT64);
2040     BNXE_KSTAT_L2_CHIP(IfHCInUcastPkts,                    KSTAT_DATA_UINT64);
2041     BNXE_KSTAT_L2_CHIP(IfHCInMulticastPkts,                KSTAT_DATA_UINT64);
2042     BNXE_KSTAT_L2_CHIP(IfHCInBroadcastPkts,                KSTAT_DATA_UINT64);
2043     BNXE_KSTAT_L2_CHIP(IfHCOutUcastPkts,                   KSTAT_DATA_UINT64);
2044     BNXE_KSTAT_L2_CHIP(IfHCOutMulticastPkts,               KSTAT_DATA_UINT64);
2045     BNXE_KSTAT_L2_CHIP(IfHCOutBroadcastPkts,               KSTAT_DATA_UINT64);
2046     BNXE_KSTAT_L2_CHIP(IfHCInUcastOctets,                  KSTAT_DATA_UINT64);
2047     BNXE_KSTAT_L2_CHIP(IfHCInMulticastOctets,              KSTAT_DATA_UINT64);
2048     BNXE_KSTAT_L2_CHIP(IfHCInBroadcastOctets,              KSTAT_DATA_UINT64);
2049     BNXE_KSTAT_L2_CHIP(IfHCOutUcastOctets,                 KSTAT_DATA_UINT64);
2050     BNXE_KSTAT_L2_CHIP(IfHCOutMulticastOctets,             KSTAT_DATA_UINT64);
2051     BNXE_KSTAT_L2_CHIP(IfHCOutBroadcastOctets,             KSTAT_DATA_UINT64);
2052     BNXE_KSTAT_L2_CHIP(IfHCOutDiscards,                    KSTAT_DATA_UINT64);
2053     BNXE_KSTAT_L2_CHIP(IfHCInFalseCarrierErrors,           KSTAT_DATA_UINT64);
2054     BNXE_KSTAT_L2_CHIP(Dot3StatsInternalMacTransmitErrors, KSTAT_DATA_UINT64);
2055     BNXE_KSTAT_L2_CHIP(Dot3StatsCarrierSenseErrors,        KSTAT_DATA_UINT64);
2056     BNXE_KSTAT_L2_CHIP(Dot3StatsFCSErrors,                 KSTAT_DATA_UINT64);
2057     BNXE_KSTAT_L2_CHIP(Dot3StatsAlignmentErrors,           KSTAT_DATA_UINT64);
2058     BNXE_KSTAT_L2_CHIP(Dot3StatsSingleCollisionFrames,     KSTAT_DATA_UINT64);
2059     BNXE_KSTAT_L2_CHIP(Dot3StatsMultipleCollisionFrames,   KSTAT_DATA_UINT64);
2060     BNXE_KSTAT_L2_CHIP(Dot3StatsDeferredTransmissions,     KSTAT_DATA_UINT64);
2061     BNXE_KSTAT_L2_CHIP(Dot3StatsExcessiveCollisions,       KSTAT_DATA_UINT64);
2062     BNXE_KSTAT_L2_CHIP(Dot3StatsLateCollisions,            KSTAT_DATA_UINT64);
2063     BNXE_KSTAT_L2_CHIP(EtherStatsCollisions,               KSTAT_DATA_UINT64);
2064     BNXE_KSTAT_L2_CHIP(EtherStatsFragments,                KSTAT_DATA_UINT64);
2065     BNXE_KSTAT_L2_CHIP(EtherStatsJabbers,                  KSTAT_DATA_UINT64);
2066     BNXE_KSTAT_L2_CHIP(EtherStatsUndersizePkts,            KSTAT_DATA_UINT64);
2067     BNXE_KSTAT_L2_CHIP(EtherStatsOverrsizePkts,            KSTAT_DATA_UINT64);
2068     BNXE_KSTAT_L2_CHIP(EtherStatsTx64Octets,               KSTAT_DATA_UINT64);
2069     BNXE_KSTAT_L2_CHIP(EtherStatsTx65to127Octets,          KSTAT_DATA_UINT64);
2070     BNXE_KSTAT_L2_CHIP(EtherStatsTx128to255Octets,         KSTAT_DATA_UINT64);
2071     BNXE_KSTAT_L2_CHIP(EtherStatsTx256to511Octets,         KSTAT_DATA_UINT64);
2072     BNXE_KSTAT_L2_CHIP(EtherStatsTx512to1023Octets,        KSTAT_DATA_UINT64);
2073     BNXE_KSTAT_L2_CHIP(EtherStatsTx1024to1522Octets,       KSTAT_DATA_UINT64);
2074     BNXE_KSTAT_L2_CHIP(EtherStatsTxOver1522Octets,         KSTAT_DATA_UINT64);
2075     BNXE_KSTAT_L2_CHIP(XonPauseFramesReceived,             KSTAT_DATA_UINT64);
2076     BNXE_KSTAT_L2_CHIP(XoffPauseFramesReceived,            KSTAT_DATA_UINT64);
2077     BNXE_KSTAT_L2_CHIP(OutXonSent,                         KSTAT_DATA_UINT64);
2078     BNXE_KSTAT_L2_CHIP(OutXoffSent,                        KSTAT_DATA_UINT64);
2079     BNXE_KSTAT_L2_CHIP(FlowControlDone,                    KSTAT_DATA_UINT64);
2080     BNXE_KSTAT_L2_CHIP(MacControlFramesReceived,           KSTAT_DATA_UINT64);
2081     BNXE_KSTAT_L2_CHIP(XoffStateEntered,                   KSTAT_DATA_UINT64);
2082     BNXE_KSTAT_L2_CHIP(IfInFramesL2FilterDiscards,         KSTAT_DATA_UINT64);
2083     BNXE_KSTAT_L2_CHIP(IfInTTL0Discards,                   KSTAT_DATA_UINT64);
2084     BNXE_KSTAT_L2_CHIP(IfInxxOverflowDiscards,             KSTAT_DATA_UINT64);
2085     BNXE_KSTAT_L2_CHIP(IfInMBUFDiscards,                   KSTAT_DATA_UINT64);
2086     BNXE_KSTAT_L2_CHIP(IfInErrors,                         KSTAT_DATA_UINT64);
2087     BNXE_KSTAT_L2_CHIP(IfInErrorsOctets,                   KSTAT_DATA_UINT64);
2088     BNXE_KSTAT_L2_CHIP(IfInNoBrbBuffer,                    KSTAT_DATA_UINT64);
2089     BNXE_KSTAT_L2_CHIP(NigBrbPacket,                       KSTAT_DATA_UINT64);
2090     BNXE_KSTAT_L2_CHIP(NigBrbTruncate,                     KSTAT_DATA_UINT64);
2091     BNXE_KSTAT_L2_CHIP(NigFlowCtrlDiscard,                 KSTAT_DATA_UINT64);
2092     BNXE_KSTAT_L2_CHIP(NigFlowCtrlOctets,                  KSTAT_DATA_UINT64);
2093     BNXE_KSTAT_L2_CHIP(NigFlowCtrlPacket,                  KSTAT_DATA_UINT64);
2094     BNXE_KSTAT_L2_CHIP(NigMngDiscard,                      KSTAT_DATA_UINT64);
2095     BNXE_KSTAT_L2_CHIP(NigMngOctetInp,                     KSTAT_DATA_UINT64);
2096     BNXE_KSTAT_L2_CHIP(NigMngOctetOut,                     KSTAT_DATA_UINT64);
2097     BNXE_KSTAT_L2_CHIP(NigMngPacketInp,                    KSTAT_DATA_UINT64);
2098     BNXE_KSTAT_L2_CHIP(NigMngPacketOut,                    KSTAT_DATA_UINT64);
2099     BNXE_KSTAT_L2_CHIP(NigPbfOctets,                       KSTAT_DATA_UINT64);
2100     BNXE_KSTAT_L2_CHIP(NigPbfPacket,                       KSTAT_DATA_UINT64);
2101     BNXE_KSTAT_L2_CHIP(NigSafcInp,                         KSTAT_DATA_UINT64);
2102 
2103     pUM->kstatsL2Chip->ks_update  = BnxeKstatL2ChipUpdate;
2104     pUM->kstatsL2Chip->ks_private = (void *)pUM;
2105 
2106     kstat_install(pUM->kstatsL2Chip);
2107 
2108     /****************************************************************/
2109 
2110     if ((pUM->kstatsL2Driver = kstat_create("bnxe",
2111                                             pUM->instance,
2112                                             "l2driver",
2113                                             "net",
2114                                             KSTAT_TYPE_NAMED,
2115                                             BNXE_KSTAT_L2_DRIVER_SIZE,
2116                                             0)) == NULL)
2117     {
2118         BnxeLogWarn(pUM, "Failed to create l2driver kstat");
2119         return B_FALSE;
2120     }
2121 
2122     pStatsL2Driver = (BnxeKstatL2Driver *)pUM->kstatsL2Driver->ks_data;
2123 
2124     BNXE_KSTAT_L2_DRIVER(RxIPv4FragCount,    KSTAT_DATA_UINT64);
2125     BNXE_KSTAT_L2_DRIVER(RxIpCsErrorCount,   KSTAT_DATA_UINT64);
2126     BNXE_KSTAT_L2_DRIVER(RxTcpCsErrorCount,  KSTAT_DATA_UINT64);
2127     BNXE_KSTAT_L2_DRIVER(RxLlcSnapCount,     KSTAT_DATA_UINT64);
2128     BNXE_KSTAT_L2_DRIVER(RxPhyErrorCount,    KSTAT_DATA_UINT64);
2129     BNXE_KSTAT_L2_DRIVER(RxIpv6ExtCount,     KSTAT_DATA_UINT64);
2130     BNXE_KSTAT_L2_DRIVER(TxNoL2Bd,           KSTAT_DATA_UINT64);
2131     BNXE_KSTAT_L2_DRIVER(TxNoSqWqe,          KSTAT_DATA_UINT64);
2132     BNXE_KSTAT_L2_DRIVER(TxL2AssemblyBufUse, KSTAT_DATA_UINT64);
2133 
2134     pUM->kstatsL2Driver->ks_update  = BnxeKstatL2DriverUpdate;
2135     pUM->kstatsL2Driver->ks_private = (void *)pUM;
2136 
2137     kstat_install(pUM->kstatsL2Driver);
2138 
2139     /****************************************************************/
2140 
2141     if ((pUM->kstatsL2Stats = kstat_create("bnxe",
2142                                            pUM->instance,
2143                                            "l2stats",
2144                                            "net",
2145                                            KSTAT_TYPE_NAMED,
2146                                            BNXE_KSTAT_ETH_STATS_SIZE,
2147                                            0)) == NULL)
2148     {
2149         BnxeLogWarn(pUM, "Failed to create l2stats kstat");
2150         return B_FALSE;
2151     }
2152 
2153     pStatsL2Stats = (BnxeKstatEthStats *)pUM->kstatsL2Stats->ks_data;
2154 
2155     BNXE_KSTAT_L2_STATS(txFramesOk,         KSTAT_DATA_UINT64);
2156     BNXE_KSTAT_L2_STATS(rxFramesOk,         KSTAT_DATA_UINT64);
2157     BNXE_KSTAT_L2_STATS(txErr,              KSTAT_DATA_UINT64);
2158     BNXE_KSTAT_L2_STATS(rxErr,              KSTAT_DATA_UINT64);
2159     BNXE_KSTAT_L2_STATS(rxCrcErr,           KSTAT_DATA_UINT64);
2160     BNXE_KSTAT_L2_STATS(alignErr,           KSTAT_DATA_UINT64);
2161     BNXE_KSTAT_L2_STATS(collisionsSingle,   KSTAT_DATA_UINT64);
2162     BNXE_KSTAT_L2_STATS(collisionsMultiple, KSTAT_DATA_UINT64);
2163     BNXE_KSTAT_L2_STATS(framesDeferred,     KSTAT_DATA_UINT64);
2164     BNXE_KSTAT_L2_STATS(collisonsMax,       KSTAT_DATA_UINT64);
2165     BNXE_KSTAT_L2_STATS(rxOverrun,          KSTAT_DATA_UINT64);
2166     BNXE_KSTAT_L2_STATS(txOverrun,          KSTAT_DATA_UINT64);
2167     BNXE_KSTAT_L2_STATS(txFramesUnicast,    KSTAT_DATA_UINT64);
2168     BNXE_KSTAT_L2_STATS(txFramesMulticast,  KSTAT_DATA_UINT64);
2169     BNXE_KSTAT_L2_STATS(txFramesBroadcast,  KSTAT_DATA_UINT64);
2170     BNXE_KSTAT_L2_STATS(rxFramesUnicast,    KSTAT_DATA_UINT64);
2171     BNXE_KSTAT_L2_STATS(rxFramesMulticast,  KSTAT_DATA_UINT64);
2172     BNXE_KSTAT_L2_STATS(rxFramesBroadcast,  KSTAT_DATA_UINT64);
2173     BNXE_KSTAT_L2_STATS(rxNoBufferDrop,     KSTAT_DATA_UINT64);
2174     BNXE_KSTAT_L2_STATS(rxBytes,            KSTAT_DATA_UINT64);
2175     BNXE_KSTAT_L2_STATS(txBytes,            KSTAT_DATA_UINT64);
2176     BNXE_KSTAT_L2_STATS(offloadIP4,         KSTAT_DATA_UINT64);
2177     BNXE_KSTAT_L2_STATS(offloadTCP,         KSTAT_DATA_UINT64);
2178     BNXE_KSTAT_L2_STATS(ifInDiscards,       KSTAT_DATA_UINT64);
2179     BNXE_KSTAT_L2_STATS(ifInErrors,         KSTAT_DATA_UINT64);
2180     BNXE_KSTAT_L2_STATS(ifOutErrors,        KSTAT_DATA_UINT64);
2181     BNXE_KSTAT_L2_STATS(offloadIP6,         KSTAT_DATA_UINT64);
2182     BNXE_KSTAT_L2_STATS(offloadTCP6,        KSTAT_DATA_UINT64);
2183     BNXE_KSTAT_L2_STATS(txDiscards,         KSTAT_DATA_UINT64);
2184     BNXE_KSTAT_L2_STATS(rxBytesUnicast,     KSTAT_DATA_UINT64);
2185     BNXE_KSTAT_L2_STATS(rxBytesMulticast,   KSTAT_DATA_UINT64);
2186     BNXE_KSTAT_L2_STATS(rxBytesBroadcast,   KSTAT_DATA_UINT64);
2187     BNXE_KSTAT_L2_STATS(txBytesUnicast,     KSTAT_DATA_UINT64);
2188     BNXE_KSTAT_L2_STATS(txBytesMulticast,   KSTAT_DATA_UINT64);
2189     BNXE_KSTAT_L2_STATS(txBytesBroadcast,   KSTAT_DATA_UINT64);
2190 
2191     pUM->kstatsL2Stats->ks_update  = BnxeKstatL2StatsUpdate;
2192     pUM->kstatsL2Stats->ks_private = (void *)pUM;
2193 
2194     kstat_install(pUM->kstatsL2Stats);
2195 
2196     /****************************************************************/
2197 
2198     if (BNXE_FCOE(pUM))
2199     {
2200         if ((pUM->kstatsFcoe = kstat_create("bnxe",
2201                                             pUM->instance,
2202                                             "fcoe",
2203                                             "net",
2204                                             KSTAT_TYPE_NAMED,
2205                                             BNXE_KSTAT_FCOE_SIZE,
2206                                             0)) == NULL)
2207         {
2208             BnxeLogWarn(pUM, "Failed to create fcoe kstat");
2209             BnxeKstatFini(pUM);
2210             return B_FALSE;
2211         }
2212 
2213         pStatsFcoe = (BnxeKstatFcoe *)pUM->kstatsFcoe->ks_data;
2214 
2215         BNXE_KSTAT_FCOE(pdev_hi,             KSTAT_DATA_CHAR);
2216         BNXE_KSTAT_FCOE(pdev_lo,             KSTAT_DATA_CHAR);
2217         BNXE_KSTAT_FCOE(instance,            KSTAT_DATA_CHAR);
2218         BNXE_KSTAT_FCOE(macAddr,             KSTAT_DATA_CHAR);
2219         BNXE_KSTAT_FCOE(pwwn_hi,             KSTAT_DATA_CHAR);
2220         BNXE_KSTAT_FCOE(pwwn_lo,             KSTAT_DATA_CHAR);
2221         BNXE_KSTAT_FCOE(mtu,                 KSTAT_DATA_UINT64);
2222         BNXE_KSTAT_FCOE(initWqeTx,           KSTAT_DATA_UINT64);
2223         BNXE_KSTAT_FCOE(initWqeTxErr,        KSTAT_DATA_UINT64);
2224         BNXE_KSTAT_FCOE(initCqeRx,           KSTAT_DATA_UINT64);
2225         BNXE_KSTAT_FCOE(initCqeRxErr,        KSTAT_DATA_UINT64);
2226         BNXE_KSTAT_FCOE(offloadConnWqeTx,    KSTAT_DATA_UINT64);
2227         BNXE_KSTAT_FCOE(offloadConnWqeTxErr, KSTAT_DATA_UINT64);
2228         BNXE_KSTAT_FCOE(offloadConnCqeRx,    KSTAT_DATA_UINT64);
2229         BNXE_KSTAT_FCOE(offloadConnCqeRxErr, KSTAT_DATA_UINT64);
2230         BNXE_KSTAT_FCOE(enableConnWqeTx,     KSTAT_DATA_UINT64);
2231         BNXE_KSTAT_FCOE(enableConnWqeTxErr,  KSTAT_DATA_UINT64);
2232         BNXE_KSTAT_FCOE(enableConnCqeRx,     KSTAT_DATA_UINT64);
2233         BNXE_KSTAT_FCOE(enableConnCqeRxErr,  KSTAT_DATA_UINT64);
2234         BNXE_KSTAT_FCOE(disableConnWqeTx,    KSTAT_DATA_UINT64);
2235         BNXE_KSTAT_FCOE(disableConnWqeTxErr, KSTAT_DATA_UINT64);
2236         BNXE_KSTAT_FCOE(disableConnCqeRx,    KSTAT_DATA_UINT64);
2237         BNXE_KSTAT_FCOE(disableConnCqeRxErr, KSTAT_DATA_UINT64);
2238         BNXE_KSTAT_FCOE(destroyConnWqeTx,    KSTAT_DATA_UINT64);
2239         BNXE_KSTAT_FCOE(destroyConnWqeTxErr, KSTAT_DATA_UINT64);
2240         BNXE_KSTAT_FCOE(destroyConnCqeRx,    KSTAT_DATA_UINT64);
2241         BNXE_KSTAT_FCOE(destroyConnCqeRxErr, KSTAT_DATA_UINT64);
2242         BNXE_KSTAT_FCOE(destroyWqeTx,        KSTAT_DATA_UINT64);
2243         BNXE_KSTAT_FCOE(destroyWqeTxErr,     KSTAT_DATA_UINT64);
2244         BNXE_KSTAT_FCOE(destroyCqeRx,        KSTAT_DATA_UINT64);
2245         BNXE_KSTAT_FCOE(destroyCqeRxErr,     KSTAT_DATA_UINT64);
2246         BNXE_KSTAT_FCOE(compRequestCqeRx,    KSTAT_DATA_UINT64);
2247         BNXE_KSTAT_FCOE(compRequestCqeRxErr, KSTAT_DATA_UINT64);
2248         BNXE_KSTAT_FCOE(statWqeTx,           KSTAT_DATA_UINT64);
2249         BNXE_KSTAT_FCOE(statWqeTxErr,        KSTAT_DATA_UINT64);
2250         BNXE_KSTAT_FCOE(statCqeRx,           KSTAT_DATA_UINT64);
2251         BNXE_KSTAT_FCOE(statCqeRxErr,        KSTAT_DATA_UINT64);
2252 
2253         pUM->kstatsFcoe->ks_update  = BnxeKstatFcoeUpdate;
2254         pUM->kstatsFcoe->ks_private = (void *)pUM;
2255 
2256         kstat_install(pUM->kstatsFcoe);
2257 
2258         if (!BnxeKstatInitRxQ(pUM, FCOE_CID(pLM)))
2259         {
2260             BnxeKstatFini(pUM);
2261             return B_FALSE;
2262         }
2263 
2264         if (!BnxeKstatInitTxQ(pUM, FCOE_CID(pLM)))
2265         {
2266             BnxeKstatFini(pUM);
2267             return B_FALSE;
2268         }
2269     }
2270 
2271     /****************************************************************/
2272 
2273     if (IS_DCB_SUPPORTED(pLM))
2274     {
2275         if ((pUM->kstatsDcbx = kstat_create("bnxe",
2276                                             pUM->instance,
2277                                             "dcbx",
2278                                             "net",
2279                                             KSTAT_TYPE_NAMED,
2280                                             BNXE_KSTAT_DCBX_SIZE,
2281                                             0)) == NULL)
2282         {
2283             BnxeLogWarn(pUM, "Failed to create dcbx kstat");
2284             BnxeKstatFini(pUM);
2285             return B_FALSE;
2286         }
2287 
2288         pStatsDcbx = (BnxeKstatDcbx *)pUM->kstatsDcbx->ks_data;
2289 
2290         BNXE_KSTAT_DCBX(dcbx_sync, KSTAT_DATA_CHAR);
2291         BNXE_KSTAT_DCBX(dcbx_vers, KSTAT_DATA_CHAR);
2292         BNXE_KSTAT_DCBX(overwrite_settings, KSTAT_DATA_CHAR);
2293         BNXE_KSTAT_DCBX(prio_tag, KSTAT_DATA_CHAR);
2294         BNXE_KSTAT_DCBX(prio_tag_fcoe, KSTAT_DATA_CHAR);
2295         BNXE_KSTAT_DCBX(prio_tag_iscsi, KSTAT_DATA_CHAR);
2296         BNXE_KSTAT_DCBX(prio_tag_net, KSTAT_DATA_CHAR);
2297         BNXE_KSTAT_DCBX(pfc, KSTAT_DATA_CHAR);
2298         BNXE_KSTAT_DCBX(pfc_prio_0, KSTAT_DATA_CHAR);
2299         BNXE_KSTAT_DCBX(pfc_prio_1, KSTAT_DATA_CHAR);
2300         BNXE_KSTAT_DCBX(pfc_prio_2, KSTAT_DATA_CHAR);
2301         BNXE_KSTAT_DCBX(pfc_prio_3, KSTAT_DATA_CHAR);
2302         BNXE_KSTAT_DCBX(pfc_prio_4, KSTAT_DATA_CHAR);
2303         BNXE_KSTAT_DCBX(pfc_prio_5, KSTAT_DATA_CHAR);
2304         BNXE_KSTAT_DCBX(pfc_prio_6, KSTAT_DATA_CHAR);
2305         BNXE_KSTAT_DCBX(pfc_prio_7, KSTAT_DATA_CHAR);
2306         BNXE_KSTAT_DCBX(ets, KSTAT_DATA_CHAR);
2307         BNXE_KSTAT_DCBX(ets_prio_0_pg, KSTAT_DATA_CHAR);
2308         BNXE_KSTAT_DCBX(ets_prio_1_pg, KSTAT_DATA_CHAR);
2309         BNXE_KSTAT_DCBX(ets_prio_2_pg, KSTAT_DATA_CHAR);
2310         BNXE_KSTAT_DCBX(ets_prio_3_pg, KSTAT_DATA_CHAR);
2311         BNXE_KSTAT_DCBX(ets_prio_4_pg, KSTAT_DATA_CHAR);
2312         BNXE_KSTAT_DCBX(ets_prio_5_pg, KSTAT_DATA_CHAR);
2313         BNXE_KSTAT_DCBX(ets_prio_6_pg, KSTAT_DATA_CHAR);
2314         BNXE_KSTAT_DCBX(ets_prio_7_pg, KSTAT_DATA_CHAR);
2315         BNXE_KSTAT_DCBX(ets_pg_0_bw, KSTAT_DATA_CHAR);
2316         BNXE_KSTAT_DCBX(ets_pg_1_bw, KSTAT_DATA_CHAR);
2317         BNXE_KSTAT_DCBX(ets_pg_2_bw, KSTAT_DATA_CHAR);
2318         BNXE_KSTAT_DCBX(ets_pg_3_bw, KSTAT_DATA_CHAR);
2319         BNXE_KSTAT_DCBX(ets_pg_4_bw, KSTAT_DATA_CHAR);
2320         BNXE_KSTAT_DCBX(ets_pg_5_bw, KSTAT_DATA_CHAR);
2321         BNXE_KSTAT_DCBX(ets_pg_6_bw, KSTAT_DATA_CHAR);
2322         BNXE_KSTAT_DCBX(ets_pg_7_bw, KSTAT_DATA_CHAR);
2323         BNXE_KSTAT_DCBX(lldp, KSTAT_DATA_CHAR);
2324         BNXE_KSTAT_DCBX(lldp_tx_interval, KSTAT_DATA_CHAR);
2325         BNXE_KSTAT_DCBX(lldp_tx_fast_interval, KSTAT_DATA_CHAR);
2326         BNXE_KSTAT_DCBX(amib_apptlv_willing, KSTAT_DATA_CHAR);
2327         BNXE_KSTAT_DCBX(amib_apptlv_tx, KSTAT_DATA_CHAR);
2328         BNXE_KSTAT_DCBX(amib_apptlv_net_prio, KSTAT_DATA_CHAR);
2329         BNXE_KSTAT_DCBX(amib_apptlv_tbl_0_prio, KSTAT_DATA_CHAR);
2330         BNXE_KSTAT_DCBX(amib_apptlv_tbl_0_appid, KSTAT_DATA_CHAR);
2331         BNXE_KSTAT_DCBX(amib_apptlv_tbl_1_prio, KSTAT_DATA_CHAR);
2332         BNXE_KSTAT_DCBX(amib_apptlv_tbl_1_appid, KSTAT_DATA_CHAR);
2333         BNXE_KSTAT_DCBX(amib_apptlv_tbl_2_prio, KSTAT_DATA_CHAR);
2334         BNXE_KSTAT_DCBX(amib_apptlv_tbl_2_appid, KSTAT_DATA_CHAR);
2335         BNXE_KSTAT_DCBX(amib_apptlv_tbl_3_prio, KSTAT_DATA_CHAR);
2336         BNXE_KSTAT_DCBX(amib_apptlv_tbl_3_appid, KSTAT_DATA_CHAR);
2337         BNXE_KSTAT_DCBX(amib_pgtlv_willing, KSTAT_DATA_CHAR);
2338         BNXE_KSTAT_DCBX(amib_pgtlv_tx, KSTAT_DATA_CHAR);
2339         BNXE_KSTAT_DCBX(amib_pgtlv_tc_supported, KSTAT_DATA_CHAR);
2340         BNXE_KSTAT_DCBX(amib_pgtlv_ets, KSTAT_DATA_CHAR);
2341         BNXE_KSTAT_DCBX(amib_pgtlv_pg_0_bw, KSTAT_DATA_CHAR);
2342         BNXE_KSTAT_DCBX(amib_pgtlv_pg_1_bw, KSTAT_DATA_CHAR);
2343         BNXE_KSTAT_DCBX(amib_pgtlv_pg_2_bw, KSTAT_DATA_CHAR);
2344         BNXE_KSTAT_DCBX(amib_pgtlv_pg_3_bw, KSTAT_DATA_CHAR);
2345         BNXE_KSTAT_DCBX(amib_pgtlv_pg_4_bw, KSTAT_DATA_CHAR);
2346         BNXE_KSTAT_DCBX(amib_pgtlv_pg_5_bw, KSTAT_DATA_CHAR);
2347         BNXE_KSTAT_DCBX(amib_pgtlv_pg_6_bw, KSTAT_DATA_CHAR);
2348         BNXE_KSTAT_DCBX(amib_pgtlv_pg_7_bw, KSTAT_DATA_CHAR);
2349         BNXE_KSTAT_DCBX(amib_pgtlv_prio_0_map, KSTAT_DATA_CHAR);
2350         BNXE_KSTAT_DCBX(amib_pgtlv_prio_1_map, KSTAT_DATA_CHAR);
2351         BNXE_KSTAT_DCBX(amib_pgtlv_prio_2_map, KSTAT_DATA_CHAR);
2352         BNXE_KSTAT_DCBX(amib_pgtlv_prio_3_map, KSTAT_DATA_CHAR);
2353         BNXE_KSTAT_DCBX(amib_pgtlv_prio_4_map, KSTAT_DATA_CHAR);
2354         BNXE_KSTAT_DCBX(amib_pgtlv_prio_5_map, KSTAT_DATA_CHAR);
2355         BNXE_KSTAT_DCBX(amib_pgtlv_prio_6_map, KSTAT_DATA_CHAR);
2356         BNXE_KSTAT_DCBX(amib_pgtlv_prio_7_map, KSTAT_DATA_CHAR);
2357         BNXE_KSTAT_DCBX(amib_pfctlv_willing, KSTAT_DATA_CHAR);
2358         BNXE_KSTAT_DCBX(amib_pfctlv_tx, KSTAT_DATA_CHAR);
2359         BNXE_KSTAT_DCBX(amib_pfctlv_pfc, KSTAT_DATA_CHAR);
2360         BNXE_KSTAT_DCBX(amib_pfctlv_pfc_map, KSTAT_DATA_CHAR);
2361         BNXE_KSTAT_DCBX(rmib_apptlv_willing, KSTAT_DATA_CHAR);
2362         BNXE_KSTAT_DCBX(rmib_apptlv_tbl_0_prio, KSTAT_DATA_CHAR);
2363         BNXE_KSTAT_DCBX(rmib_apptlv_tbl_0_appid, KSTAT_DATA_CHAR);
2364         BNXE_KSTAT_DCBX(rmib_apptlv_tbl_1_prio, KSTAT_DATA_CHAR);
2365         BNXE_KSTAT_DCBX(rmib_apptlv_tbl_1_appid, KSTAT_DATA_CHAR);
2366         BNXE_KSTAT_DCBX(rmib_apptlv_tbl_2_prio, KSTAT_DATA_CHAR);
2367         BNXE_KSTAT_DCBX(rmib_apptlv_tbl_2_appid, KSTAT_DATA_CHAR);
2368         BNXE_KSTAT_DCBX(rmib_apptlv_tbl_3_prio, KSTAT_DATA_CHAR);
2369         BNXE_KSTAT_DCBX(rmib_apptlv_tbl_3_appid, KSTAT_DATA_CHAR);
2370         BNXE_KSTAT_DCBX(rmib_pgtlv_willing, KSTAT_DATA_CHAR);
2371         BNXE_KSTAT_DCBX(rmib_pgtlv_tc_supported, KSTAT_DATA_CHAR);
2372         BNXE_KSTAT_DCBX(rmib_pgtlv_pg_0_bw, KSTAT_DATA_CHAR);
2373         BNXE_KSTAT_DCBX(rmib_pgtlv_pg_1_bw, KSTAT_DATA_CHAR);
2374         BNXE_KSTAT_DCBX(rmib_pgtlv_pg_2_bw, KSTAT_DATA_CHAR);
2375         BNXE_KSTAT_DCBX(rmib_pgtlv_pg_3_bw, KSTAT_DATA_CHAR);
2376         BNXE_KSTAT_DCBX(rmib_pgtlv_pg_4_bw, KSTAT_DATA_CHAR);
2377         BNXE_KSTAT_DCBX(rmib_pgtlv_pg_5_bw, KSTAT_DATA_CHAR);
2378         BNXE_KSTAT_DCBX(rmib_pgtlv_pg_6_bw, KSTAT_DATA_CHAR);
2379         BNXE_KSTAT_DCBX(rmib_pgtlv_pg_7_bw, KSTAT_DATA_CHAR);
2380         BNXE_KSTAT_DCBX(rmib_pgtlv_prio_0_map, KSTAT_DATA_CHAR);
2381         BNXE_KSTAT_DCBX(rmib_pgtlv_prio_1_map, KSTAT_DATA_CHAR);
2382         BNXE_KSTAT_DCBX(rmib_pgtlv_prio_2_map, KSTAT_DATA_CHAR);
2383         BNXE_KSTAT_DCBX(rmib_pgtlv_prio_3_map, KSTAT_DATA_CHAR);
2384         BNXE_KSTAT_DCBX(rmib_pgtlv_prio_4_map, KSTAT_DATA_CHAR);
2385         BNXE_KSTAT_DCBX(rmib_pgtlv_prio_5_map, KSTAT_DATA_CHAR);
2386         BNXE_KSTAT_DCBX(rmib_pgtlv_prio_6_map, KSTAT_DATA_CHAR);
2387         BNXE_KSTAT_DCBX(rmib_pgtlv_prio_7_map, KSTAT_DATA_CHAR);
2388         BNXE_KSTAT_DCBX(rmib_pfctlv_willing, KSTAT_DATA_CHAR);
2389         BNXE_KSTAT_DCBX(rmib_pfctlv_pfc_map, KSTAT_DATA_CHAR);
2390         BNXE_KSTAT_DCBX(rmib_pfctlv_capable, KSTAT_DATA_CHAR);
2391         BNXE_KSTAT_DCBX(lmib_apptlv_tbl_0_prio, KSTAT_DATA_CHAR);
2392         BNXE_KSTAT_DCBX(lmib_apptlv_tbl_0_appid, KSTAT_DATA_CHAR);
2393         BNXE_KSTAT_DCBX(lmib_apptlv_tbl_1_prio, KSTAT_DATA_CHAR);
2394         BNXE_KSTAT_DCBX(lmib_apptlv_tbl_1_appid, KSTAT_DATA_CHAR);
2395         BNXE_KSTAT_DCBX(lmib_apptlv_tbl_2_prio, KSTAT_DATA_CHAR);
2396         BNXE_KSTAT_DCBX(lmib_apptlv_tbl_2_appid, KSTAT_DATA_CHAR);
2397         BNXE_KSTAT_DCBX(lmib_apptlv_tbl_3_prio, KSTAT_DATA_CHAR);
2398         BNXE_KSTAT_DCBX(lmib_apptlv_tbl_3_appid, KSTAT_DATA_CHAR);
2399         BNXE_KSTAT_DCBX(lmib_apptlv_mismatch, KSTAT_DATA_CHAR);
2400         BNXE_KSTAT_DCBX(lmib_pgtlv_ets, KSTAT_DATA_CHAR);
2401         BNXE_KSTAT_DCBX(lmib_pgtlv_tc_supported, KSTAT_DATA_CHAR);
2402         BNXE_KSTAT_DCBX(lmib_pgtlv_pg_0_bw, KSTAT_DATA_CHAR);
2403         BNXE_KSTAT_DCBX(lmib_pgtlv_pg_1_bw, KSTAT_DATA_CHAR);
2404         BNXE_KSTAT_DCBX(lmib_pgtlv_pg_2_bw, KSTAT_DATA_CHAR);
2405         BNXE_KSTAT_DCBX(lmib_pgtlv_pg_3_bw, KSTAT_DATA_CHAR);
2406         BNXE_KSTAT_DCBX(lmib_pgtlv_pg_4_bw, KSTAT_DATA_CHAR);
2407         BNXE_KSTAT_DCBX(lmib_pgtlv_pg_5_bw, KSTAT_DATA_CHAR);
2408         BNXE_KSTAT_DCBX(lmib_pgtlv_pg_6_bw, KSTAT_DATA_CHAR);
2409         BNXE_KSTAT_DCBX(lmib_pgtlv_pg_7_bw, KSTAT_DATA_CHAR);
2410         BNXE_KSTAT_DCBX(lmib_pgtlv_prio_0_map, KSTAT_DATA_CHAR);
2411         BNXE_KSTAT_DCBX(lmib_pgtlv_prio_1_map, KSTAT_DATA_CHAR);
2412         BNXE_KSTAT_DCBX(lmib_pgtlv_prio_2_map, KSTAT_DATA_CHAR);
2413         BNXE_KSTAT_DCBX(lmib_pgtlv_prio_3_map, KSTAT_DATA_CHAR);
2414         BNXE_KSTAT_DCBX(lmib_pgtlv_prio_4_map, KSTAT_DATA_CHAR);
2415         BNXE_KSTAT_DCBX(lmib_pgtlv_prio_5_map, KSTAT_DATA_CHAR);
2416         BNXE_KSTAT_DCBX(lmib_pgtlv_prio_6_map, KSTAT_DATA_CHAR);
2417         BNXE_KSTAT_DCBX(lmib_pgtlv_prio_7_map, KSTAT_DATA_CHAR);
2418         BNXE_KSTAT_DCBX(lmib_pfctlv_pfc, KSTAT_DATA_CHAR);
2419         BNXE_KSTAT_DCBX(lmib_pfctlv_pfc_map, KSTAT_DATA_CHAR);
2420         BNXE_KSTAT_DCBX(lmib_pfctlv_capable, KSTAT_DATA_CHAR);
2421         BNXE_KSTAT_DCBX(lmib_pfctlv_mismatch, KSTAT_DATA_CHAR);
2422         BNXE_KSTAT_DCBX(dcbx_frames_rx, KSTAT_DATA_UINT64);
2423         BNXE_KSTAT_DCBX(dcbx_frames_tx, KSTAT_DATA_UINT64);
2424         BNXE_KSTAT_DCBX(pfc_frames_rx, KSTAT_DATA_UINT64);
2425         BNXE_KSTAT_DCBX(pfc_frames_tx, KSTAT_DATA_UINT64);
2426 
2427         pUM->kstatsDcbx->ks_update  = BnxeKstatDcbxUpdate;
2428         pUM->kstatsDcbx->ks_private = (void *)pUM;
2429 
2430         kstat_install(pUM->kstatsDcbx);
2431     }
2432 
2433     /****************************************************************/
2434 
2435     if (!BnxeProtoFcoeAfex(pUM))
2436     {
2437         LM_FOREACH_RSS_IDX(pLM, idx)
2438         {
2439             if (!BnxeKstatInitRxQ(pUM, idx))
2440             {
2441                 BnxeKstatFini(pUM);
2442                 return B_FALSE;
2443             }
2444         }
2445 
2446         LM_FOREACH_TSS_IDX(pLM, idx)
2447         {
2448             if (!BnxeKstatInitTxQ(pUM, idx))
2449             {
2450                 BnxeKstatFini(pUM);
2451                 return B_FALSE;
2452             }
2453         }
2454     }
2455 
2456     /****************************************************************/
2457 
2458     return B_TRUE;
2459 }
2460 
2461 
BnxeKstatFini(um_device_t * pUM)2462 void BnxeKstatFini(um_device_t * pUM)
2463 {
2464     lm_device_t * pLM = (lm_device_t *)pUM;
2465     int idx;
2466 
2467     if (pUM->kstats)
2468     {
2469         kstat_delete(pUM->kstats);
2470         pUM->kstats = NULL;
2471     }
2472 
2473     if (pUM->kstatsLink)
2474     {
2475         kstat_delete(pUM->kstatsLink);
2476         pUM->kstatsLink = NULL;
2477     }
2478 
2479     if (pUM->kstatsIntr)
2480     {
2481         kstat_delete(pUM->kstatsIntr);
2482         pUM->kstatsIntr = NULL;
2483     }
2484 
2485     if (pUM->kstatsL2Chip)
2486     {
2487         kstat_delete(pUM->kstatsL2Chip);
2488         pUM->kstatsL2Chip = NULL;
2489     }
2490 
2491     if (pUM->kstatsL2Driver)
2492     {
2493         kstat_delete(pUM->kstatsL2Driver);
2494         pUM->kstatsL2Driver = NULL;
2495     }
2496 
2497     if (pUM->kstatsL2Stats)
2498     {
2499         kstat_delete(pUM->kstatsL2Stats);
2500         pUM->kstatsL2Stats = NULL;
2501     }
2502 
2503     if (BNXE_FCOE(pUM))
2504     {
2505         if (pUM->kstatsFcoe)
2506         {
2507             kstat_delete(pUM->kstatsFcoe);
2508             pUM->kstatsFcoe = NULL;
2509         }
2510 
2511         idx = FCOE_CID(pLM);
2512 
2513         if (pUM->kstats_rxq[idx])
2514         {
2515             kstat_delete(pUM->kstats_rxq[idx]);
2516             pUM->kstats_rxq[idx] = NULL;
2517         }
2518 
2519         pUM->kstats_rxq_map[idx].idx = 0;
2520         pUM->kstats_rxq_map[idx].pUM = NULL;
2521 
2522         if (pUM->kstats_txq[idx])
2523         {
2524             kstat_delete(pUM->kstats_txq[idx]);
2525             pUM->kstats_txq[idx] = NULL;
2526         }
2527 
2528         pUM->kstats_txq_map[idx].idx = 0;
2529         pUM->kstats_txq_map[idx].pUM = NULL;
2530     }
2531 
2532     if (IS_DCB_SUPPORTED(pLM))
2533     {
2534         if (pUM->kstatsDcbx)
2535         {
2536             kstat_delete(pUM->kstatsDcbx);
2537             pUM->kstatsDcbx = NULL;
2538         }
2539     }
2540 
2541     if (!BnxeProtoFcoeAfex(pUM))
2542     {
2543         LM_FOREACH_RSS_IDX(pLM, idx)
2544         {
2545             if (pUM->kstats_rxq[idx])
2546             {
2547                 kstat_delete(pUM->kstats_rxq[idx]);
2548                 pUM->kstats_rxq[idx] = NULL;
2549             }
2550 
2551             pUM->kstats_rxq_map[idx].idx = 0;
2552             pUM->kstats_rxq_map[idx].pUM = NULL;
2553         }
2554 
2555         LM_FOREACH_TSS_IDX(pLM, idx)
2556         {
2557             if (pUM->kstats_txq[idx])
2558             {
2559                 kstat_delete(pUM->kstats_txq[idx]);
2560                 pUM->kstats_txq[idx] = NULL;
2561             }
2562 
2563             pUM->kstats_txq_map[idx].idx = 0;
2564             pUM->kstats_txq_map[idx].pUM = NULL;
2565         }
2566     }
2567 }
2568 
2569