xref: /titanic_41/usr/src/uts/common/io/e1000g/e1000g_stat.c (revision 2449e17f82f6097fd2c665b64723e31ceecbeca6)
1 /*
2  * This file is provided under a CDDLv1 license.  When using or
3  * redistributing this file, you may do so under this license.
4  * In redistributing this file this license must be included
5  * and no other modification of this header file is permitted.
6  *
7  * CDDL LICENSE SUMMARY
8  *
9  * Copyright(c) 1999 - 2007 Intel Corporation. All rights reserved.
10  *
11  * The contents of this file are subject to the terms of Version
12  * 1.0 of the Common Development and Distribution License (the "License").
13  *
14  * You should have received a copy of the License with this software.
15  * You can obtain a copy of the License at
16  *	http://www.opensolaris.org/os/licensing.
17  * See the License for the specific language governing permissions
18  * and limitations under the License.
19  */
20 
21 /*
22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms of the CDDLv1.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 /*
29  * **********************************************************************
30  *									*
31  * Module Name:  e1000g_stat.c						*
32  *									*
33  * Abstract:     Functions for displaying statistics			*
34  *									*
35  * **********************************************************************
36  */
37 #include "e1000g_sw.h"
38 #include "e1000g_debug.h"
39 
40 static int UpdateStatsCounters(kstat_t *ksp, int rw);
41 
42 /*
43  * **********************************************************************
44  *									*
45  * Name:	    AdjustTbiAcceptedStats				*
46  *									*
47  * Description:     Adjusts statistic counters when a frame is accepted	*
48  *		  under the TBI workaround. This function has been	*
49  *		  adapted for Solaris from shared code.			*
50  *									*
51  * Author:	  Bill Campbell						*
52  *									*
53  * Born on Date:    4/12/2001						*
54  *									*
55  * Arguments:								*
56  *      Adapter     - Ptr to this card's adapter data structure.	*
57  *      FrameLength - Length as reported from Hardware			*
58  *      MacAddress  - Pointer to MAC address field in frame.		*
59  *									*
60  * Returns:								*
61  *      VOID								*
62  *									*
63  * **********************************************************************
64  */
65 void
66 AdjustTbiAcceptedStats(struct e1000g *Adapter,
67     UINT32 FrameLength, PUCHAR MacAddress)
68 {
69 	UINT32 CarryBit;
70 	e1000gstat *e1000g_ksp;
71 
72 	e1000g_ksp = (e1000gstat *)Adapter->e1000g_ksp->ks_data;
73 
74 	/*
75 	 * First adjust the frame length.
76 	 */
77 	FrameLength--;
78 	/*
79 	 * We need to adjust the statistics counters, since the hardware
80 	 * counters overcount this packet as a CRC error and undercount
81 	 * the packet as a good packet
82 	 */
83 
84 	/*
85 	 * This packet should not be counted as a CRC error.
86 	 */
87 	e1000g_ksp->Crcerrs.value.ul--;
88 	/*
89 	 * This packet does count as a Good Packet Received.
90 	 */
91 	e1000g_ksp->Gprc.value.ul++;
92 
93 	/*
94 	 * Adjust the Good Octets received counters
95 	 */
96 	CarryBit = 0x80000000 & e1000g_ksp->Gorl.value.ul;
97 	e1000g_ksp->Gorl.value.ul += FrameLength;
98 	/*
99 	 * If the high bit of Gorcl (the low 32 bits of the Good Octets
100 	 * Received Count) was one before the addition,
101 	 * AND it is zero after, then we lost the carry out,
102 	 * need to add one to Gorch (Good Octets Received Count High).
103 	 * This could be simplified if all environments supported
104 	 * 64-bit integers.
105 	 */
106 	if (CarryBit && ((e1000g_ksp->Gorl.value.ul & 0x80000000) == 0)) {
107 		e1000g_ksp->Gorh.value.ul++;
108 	}
109 	/*
110 	 * Is this a broadcast or multicast?  Check broadcast first,
111 	 * since the test for a multicast frame will test positive on
112 	 * a broadcast frame.
113 	 */
114 	if ((MacAddress[0] == (UCHAR) 0xff) &&
115 	    (MacAddress[1] == (UCHAR) 0xff)) {
116 		/*
117 		 * Broadcast packet
118 		 */
119 		e1000g_ksp->Bprc.value.ul++;
120 	} else if (*MacAddress & 0x01) {
121 		/*
122 		 * Multicast packet
123 		 */
124 		e1000g_ksp->Mprc.value.ul++;
125 	}
126 	if (FrameLength == Adapter->Shared.max_frame_size) {
127 		/*
128 		 * In this case, the hardware has overcounted the number of
129 		 * oversize frames.
130 		 */
131 		if (e1000g_ksp->Roc.value.ul > 0)
132 			e1000g_ksp->Roc.value.ul--;
133 	}
134 
135 	/*
136 	 * Adjust the bin counters when the extra byte put the frame in the
137 	 * wrong bin. Remember that the FrameLength was adjusted above.
138 	 */
139 	if (FrameLength == 64) {
140 		e1000g_ksp->Prc64.value.ul++;
141 		e1000g_ksp->Prc127.value.ul--;
142 	} else if (FrameLength == 127) {
143 		e1000g_ksp->Prc127.value.ul++;
144 		e1000g_ksp->Prc255.value.ul--;
145 	} else if (FrameLength == 255) {
146 		e1000g_ksp->Prc255.value.ul++;
147 		e1000g_ksp->Prc511.value.ul--;
148 	} else if (FrameLength == 511) {
149 		e1000g_ksp->Prc511.value.ul++;
150 		e1000g_ksp->Prc1023.value.ul--;
151 	} else if (FrameLength == 1023) {
152 		e1000g_ksp->Prc1023.value.ul++;
153 		e1000g_ksp->Prc1522.value.ul--;
154 	} else if (FrameLength == 1522) {
155 		e1000g_ksp->Prc1522.value.ul++;
156 	}
157 }
158 
159 
160 /*
161  * **********************************************************************
162  * Name:	UpdateStatsCounters					*
163  *									*
164  * Description: This routine will dump and reset the 1000's internal	*
165  *	      Statistics counters.  The current stats dump values will	*
166  *	      be sent to the kernel status area.			*
167  *									*
168  * Author:      Phil Cayton						*
169  *									*
170  * Born on Date:    7/13/98						*
171  *									*
172  * Arguments:								*
173  *     *ksp - A kernel stat pointer					*
174  *     rw   - Read/Write flag						*
175  *									*
176  * Returns:								*
177  *      (EACCES) If an attempt is made to write stats to the hw		*
178  *      (0) On successful read of statistics to kernel stats.		*
179  *									*
180  * File: e1000g_stat.c							*
181  *									*
182  * Modification log:							*
183  * Date      Who  Description						*
184  * --------  ---  ------------------------------------------------------*
185  * Sept 10,99 Vinay New Counters for Livengood have been added.		*
186  * **********************************************************************
187  */
188 static int
189 UpdateStatsCounters(IN kstat_t *ksp, int rw)
190 {
191 	uint16_t LineSpeed, Duplex;
192 	struct e1000g *Adapter;
193 	e1000gstat *e1000g_ksp;
194 	uint64_t val;
195 	uint32_t low_val, high_val;
196 
197 	if (rw == KSTAT_WRITE)
198 		return (EACCES);
199 
200 	Adapter = (struct e1000g *)ksp->ks_private;
201 	ASSERT(Adapter != NULL);
202 	e1000g_ksp = (e1000gstat *)ksp->ks_data;
203 	ASSERT(e1000g_ksp != NULL);
204 
205 	e1000g_ksp->link_speed.value.ul = Adapter->link_speed;
206 	e1000g_ksp->rx_none.value.ul = Adapter->rx_none;
207 	e1000g_ksp->rx_error.value.ul = Adapter->rx_error;
208 	e1000g_ksp->rx_no_freepkt.value.ul = Adapter->rx_no_freepkt;
209 	e1000g_ksp->rx_esballoc_fail.value.ul = Adapter->rx_esballoc_fail;
210 	e1000g_ksp->rx_exceed_pkt.value.ul = Adapter->rx_exceed_pkt;
211 	e1000g_ksp->rx_multi_desc.value.ul = Adapter->rx_multi_desc;
212 	e1000g_ksp->rx_allocb_fail.value.ul = Adapter->rx_allocb_fail;
213 	e1000g_ksp->rx_avail_freepkt.value.ul = Adapter->rx_avail_freepkt;
214 	e1000g_ksp->rx_seq_intr.value.ul = Adapter->rx_seq_intr;
215 	e1000g_ksp->tx_no_desc.value.ul = Adapter->tx_no_desc;
216 	e1000g_ksp->tx_no_swpkt.value.ul = Adapter->tx_no_swpkt;
217 	e1000g_ksp->tx_lack_desc.value.ul = Adapter->tx_lack_desc;
218 	e1000g_ksp->tx_send_fail.value.ul = Adapter->tx_send_fail;
219 	e1000g_ksp->tx_multi_cookie.value.ul = Adapter->tx_multi_cookie;
220 	e1000g_ksp->tx_over_size.value.ul = Adapter->tx_over_size;
221 	e1000g_ksp->tx_under_size.value.ul = Adapter->tx_under_size;
222 	e1000g_ksp->tx_copy.value.ul = Adapter->tx_copy;
223 	e1000g_ksp->tx_bind.value.ul = Adapter->tx_bind;
224 	e1000g_ksp->tx_multi_copy.value.ul = Adapter->tx_multi_copy;
225 	e1000g_ksp->tx_reschedule.value.ul = Adapter->tx_reschedule;
226 	e1000g_ksp->tx_empty_frags.value.ul = Adapter->tx_empty_frags;
227 	e1000g_ksp->tx_exceed_frags.value.ul = Adapter->tx_exceed_frags;
228 	e1000g_ksp->tx_recycle.value.ul = Adapter->tx_recycle;
229 	e1000g_ksp->tx_recycle_retry.value.ul = Adapter->tx_recycle_retry;
230 	e1000g_ksp->tx_recycle_intr.value.ul = Adapter->tx_recycle_intr;
231 	e1000g_ksp->tx_recycle_none.value.ul = Adapter->tx_recycle_none;
232 	e1000g_ksp->StallWatchdog.value.ul = Adapter->StallWatchdog;
233 	e1000g_ksp->reset_count.value.ul = Adapter->reset_count;
234 	e1000g_ksp->JumboTx_4K.value.ul = Adapter->JumboTx_4K;
235 	e1000g_ksp->JumboRx_4K.value.ul = Adapter->JumboRx_4K;
236 	e1000g_ksp->JumboTx_8K.value.ul = Adapter->JumboTx_8K;
237 	e1000g_ksp->JumboRx_8K.value.ul = Adapter->JumboRx_8K;
238 	e1000g_ksp->JumboTx_16K.value.ul = Adapter->JumboTx_16K;
239 	e1000g_ksp->JumboRx_16K.value.ul = Adapter->JumboRx_16K;
240 	e1000g_ksp->intr_type.value.ul = Adapter->intr_type;
241 
242 	/*
243 	 * Mutex required if in TBI mode
244 	 */
245 	if (Adapter->Shared.tbi_compatibility_on == 1) {
246 		mutex_enter(&Adapter->TbiCntrMutex);
247 	}
248 
249 	/*
250 	 * Standard Stats
251 	 */
252 	e1000g_ksp->Mpc.value.ul +=
253 	    E1000_READ_REG(&Adapter->Shared, MPC);
254 
255 	e1000g_ksp->Symerrs.value.ul +=
256 	    E1000_READ_REG(&Adapter->Shared, SYMERRS);
257 
258 	e1000g_ksp->Rlec.value.ul +=
259 	    E1000_READ_REG(&Adapter->Shared, RLEC);
260 
261 	e1000g_ksp->Xonrxc.value.ul +=
262 	    E1000_READ_REG(&Adapter->Shared, XONRXC);
263 
264 	e1000g_ksp->Xontxc.value.ul +=
265 	    E1000_READ_REG(&Adapter->Shared, XONTXC);
266 
267 	e1000g_ksp->Xoffrxc.value.ul +=
268 	    E1000_READ_REG(&Adapter->Shared, XOFFRXC);
269 
270 	e1000g_ksp->Xofftxc.value.ul +=
271 	    E1000_READ_REG(&Adapter->Shared, XOFFTXC);
272 
273 	e1000g_ksp->Fcruc.value.ul +=
274 	    E1000_READ_REG(&Adapter->Shared, FCRUC);
275 
276 	e1000g_ksp->Prc64.value.ul +=
277 	    E1000_READ_REG(&Adapter->Shared, PRC64);
278 
279 	e1000g_ksp->Prc127.value.ul +=
280 	    E1000_READ_REG(&Adapter->Shared, PRC127);
281 
282 	e1000g_ksp->Prc255.value.ul +=
283 	    E1000_READ_REG(&Adapter->Shared, PRC255);
284 
285 	e1000g_ksp->Prc511.value.ul +=
286 	    E1000_READ_REG(&Adapter->Shared, PRC511);
287 
288 	e1000g_ksp->Prc1023.value.ul +=
289 	    E1000_READ_REG(&Adapter->Shared, PRC1023);
290 
291 	e1000g_ksp->Prc1522.value.ul +=
292 	    E1000_READ_REG(&Adapter->Shared, PRC1522);
293 
294 	e1000g_ksp->Gprc.value.ul +=
295 	    E1000_READ_REG(&Adapter->Shared, GPRC);
296 
297 	e1000g_ksp->Gptc.value.ul +=
298 	    E1000_READ_REG(&Adapter->Shared, GPTC);
299 
300 	/*
301 	 * The 64-bit register will reset whenever the upper
302 	 * 32 bits are read. So we need to read the lower
303 	 * 32 bits first, then read the upper 32 bits.
304 	 */
305 	low_val = E1000_READ_REG(&Adapter->Shared, GORCL);
306 	high_val = E1000_READ_REG(&Adapter->Shared, GORCH);
307 	val = (uint64_t)e1000g_ksp->Gorh.value.ul << 32 |
308 	    (uint64_t)e1000g_ksp->Gorl.value.ul;
309 	val += (uint64_t)high_val << 32 | (uint64_t)low_val;
310 	e1000g_ksp->Gorl.value.ul = (uint32_t)val;
311 	e1000g_ksp->Gorh.value.ul = (uint32_t)(val >> 32);
312 
313 	low_val = E1000_READ_REG(&Adapter->Shared, GOTCL);
314 	high_val = E1000_READ_REG(&Adapter->Shared, GOTCH);
315 	val = (uint64_t)e1000g_ksp->Goth.value.ul << 32 |
316 	    (uint64_t)e1000g_ksp->Gotl.value.ul;
317 	val += (uint64_t)high_val << 32 | (uint64_t)low_val;
318 	e1000g_ksp->Gotl.value.ul = (uint32_t)val;
319 	e1000g_ksp->Goth.value.ul = (uint32_t)(val >> 32);
320 
321 	e1000g_ksp->Ruc.value.ul +=
322 	    E1000_READ_REG(&Adapter->Shared, RUC);
323 
324 	e1000g_ksp->Rfc.value.ul +=
325 	    E1000_READ_REG(&Adapter->Shared, RFC);
326 
327 	e1000g_ksp->Roc.value.ul +=
328 	    E1000_READ_REG(&Adapter->Shared, ROC);
329 
330 	e1000g_ksp->Rjc.value.ul +=
331 	    E1000_READ_REG(&Adapter->Shared, RJC);
332 
333 	low_val = E1000_READ_REG(&Adapter->Shared, TORL);
334 	high_val = E1000_READ_REG(&Adapter->Shared, TORH);
335 	val = (uint64_t)e1000g_ksp->Torh.value.ul << 32 |
336 	    (uint64_t)e1000g_ksp->Torl.value.ul;
337 	val += (uint64_t)high_val << 32 | (uint64_t)low_val;
338 	e1000g_ksp->Torl.value.ul = (uint32_t)val;
339 	e1000g_ksp->Torh.value.ul = (uint32_t)(val >> 32);
340 
341 	low_val = E1000_READ_REG(&Adapter->Shared, TOTL);
342 	high_val = E1000_READ_REG(&Adapter->Shared, TOTH);
343 	val = (uint64_t)e1000g_ksp->Toth.value.ul << 32 |
344 	    (uint64_t)e1000g_ksp->Totl.value.ul;
345 	val += (uint64_t)high_val << 32 | (uint64_t)low_val;
346 	e1000g_ksp->Totl.value.ul = (uint32_t)val;
347 	e1000g_ksp->Toth.value.ul = (uint32_t)(val >> 32);
348 
349 	e1000g_ksp->Tpr.value.ul +=
350 	    E1000_READ_REG(&Adapter->Shared, TPR);
351 
352 	/*
353 	 * Adaptive Calculations
354 	 */
355 	Adapter->Shared.tx_packet_delta =
356 	    E1000_READ_REG(&Adapter->Shared, TPT);
357 	e1000g_ksp->Tpt.value.ul +=
358 	    Adapter->Shared.tx_packet_delta;
359 
360 	e1000g_ksp->Ptc64.value.ul +=
361 	    E1000_READ_REG(&Adapter->Shared, PTC64);
362 
363 	e1000g_ksp->Ptc127.value.ul +=
364 	    E1000_READ_REG(&Adapter->Shared, PTC127);
365 
366 	e1000g_ksp->Ptc255.value.ul +=
367 	    E1000_READ_REG(&Adapter->Shared, PTC255);
368 
369 	e1000g_ksp->Ptc511.value.ul +=
370 	    E1000_READ_REG(&Adapter->Shared, PTC511);
371 
372 	e1000g_ksp->Ptc1023.value.ul +=
373 	    E1000_READ_REG(&Adapter->Shared, PTC1023);
374 
375 	e1000g_ksp->Ptc1522.value.ul +=
376 	    E1000_READ_REG(&Adapter->Shared, PTC1522);
377 
378 	/*
379 	 * Livengood Counters
380 	 */
381 	e1000g_ksp->Tncrs.value.ul +=
382 	    E1000_READ_REG(&Adapter->Shared, TNCRS);
383 
384 	e1000g_ksp->Tsctc.value.ul +=
385 	    E1000_READ_REG(&Adapter->Shared, TSCTC);
386 
387 	e1000g_ksp->Tsctfc.value.ul +=
388 	    E1000_READ_REG(&Adapter->Shared, TSCTFC);
389 
390 	/*
391 	 * Mutex required if in TBI mode
392 	 */
393 	if (Adapter->Shared.tbi_compatibility_on == 1) {
394 		mutex_exit(&Adapter->TbiCntrMutex);
395 	}
396 
397 	return (0);
398 }
399 
400 int
401 e1000g_m_stat(void *arg, uint_t stat, uint64_t *val)
402 {
403 	struct e1000g *Adapter = (struct e1000g *)arg;
404 	e1000gstat *e1000g_ksp;
405 	uint32_t low_val, high_val;
406 	uint16_t phy_reg, phy_reg_2;
407 
408 	e1000g_ksp = (e1000gstat *)Adapter->e1000g_ksp->ks_data;
409 
410 	switch (stat) {
411 	case MAC_STAT_IFSPEED:
412 		*val = Adapter->link_speed * 1000000ull;
413 		break;
414 
415 	case MAC_STAT_MULTIRCV:
416 		e1000g_ksp->Mprc.value.ul +=
417 		    E1000_READ_REG(&Adapter->Shared, MPRC);
418 		*val = e1000g_ksp->Mprc.value.ul;
419 		break;
420 
421 	case MAC_STAT_BRDCSTRCV:
422 		e1000g_ksp->Bprc.value.ul +=
423 		    E1000_READ_REG(&Adapter->Shared, BPRC);
424 		*val = e1000g_ksp->Bprc.value.ul;
425 		break;
426 
427 	case MAC_STAT_MULTIXMT:
428 		e1000g_ksp->Mptc.value.ul +=
429 		    E1000_READ_REG(&Adapter->Shared, MPTC);
430 		*val = e1000g_ksp->Mptc.value.ul;
431 		break;
432 
433 	case MAC_STAT_BRDCSTXMT:
434 		e1000g_ksp->Bptc.value.ul +=
435 		    E1000_READ_REG(&Adapter->Shared, BPTC);
436 		*val = e1000g_ksp->Bptc.value.ul;
437 		break;
438 
439 	case MAC_STAT_NORCVBUF:
440 		e1000g_ksp->Rnbc.value.ul +=
441 		    E1000_READ_REG(&Adapter->Shared, RNBC);
442 		*val = e1000g_ksp->Rnbc.value.ul;
443 		break;
444 
445 	case MAC_STAT_IERRORS:
446 		e1000g_ksp->Rxerrc.value.ul +=
447 		    E1000_READ_REG(&Adapter->Shared, RXERRC);
448 		e1000g_ksp->Algnerrc.value.ul +=
449 		    E1000_READ_REG(&Adapter->Shared, ALGNERRC);
450 		e1000g_ksp->Rlec.value.ul +=
451 		    E1000_READ_REG(&Adapter->Shared, RLEC);
452 		e1000g_ksp->Crcerrs.value.ul +=
453 		    E1000_READ_REG(&Adapter->Shared, CRCERRS);
454 		e1000g_ksp->Cexterr.value.ul +=
455 		    E1000_READ_REG(&Adapter->Shared, CEXTERR);
456 		*val = e1000g_ksp->Rxerrc.value.ul +
457 		    e1000g_ksp->Algnerrc.value.ul +
458 		    e1000g_ksp->Rlec.value.ul +
459 		    e1000g_ksp->Crcerrs.value.ul +
460 		    e1000g_ksp->Cexterr.value.ul;
461 		break;
462 
463 	case MAC_STAT_NOXMTBUF:
464 		*val = Adapter->tx_no_desc;
465 		break;
466 
467 	case MAC_STAT_OERRORS:
468 		e1000g_ksp->Ecol.value.ul +=
469 		    E1000_READ_REG(&Adapter->Shared, ECOL);
470 		*val = e1000g_ksp->Ecol.value.ul;
471 		break;
472 
473 	case MAC_STAT_COLLISIONS:
474 		e1000g_ksp->Colc.value.ul +=
475 		    E1000_READ_REG(&Adapter->Shared, COLC);
476 		*val = e1000g_ksp->Colc.value.ul;
477 		break;
478 
479 	case MAC_STAT_RBYTES:
480 		/*
481 		 * The 64-bit register will reset whenever the upper
482 		 * 32 bits are read. So we need to read the lower
483 		 * 32 bits first, then read the upper 32 bits.
484 		 */
485 		low_val = E1000_READ_REG(&Adapter->Shared, TORL);
486 		high_val = E1000_READ_REG(&Adapter->Shared, TORH);
487 		*val = (uint64_t)e1000g_ksp->Torh.value.ul << 32 |
488 		    (uint64_t)e1000g_ksp->Torl.value.ul;
489 		*val += (uint64_t)high_val << 32 | (uint64_t)low_val;
490 
491 		e1000g_ksp->Torl.value.ul = (uint32_t)*val;
492 		e1000g_ksp->Torh.value.ul = (uint32_t)(*val >> 32);
493 		break;
494 
495 	case MAC_STAT_IPACKETS:
496 		e1000g_ksp->Tpr.value.ul +=
497 		    E1000_READ_REG(&Adapter->Shared, TPR);
498 		*val = e1000g_ksp->Tpr.value.ul;
499 		break;
500 
501 	case MAC_STAT_OBYTES:
502 		/*
503 		 * The 64-bit register will reset whenever the upper
504 		 * 32 bits are read. So we need to read the lower
505 		 * 32 bits first, then read the upper 32 bits.
506 		 */
507 		low_val = E1000_READ_REG(&Adapter->Shared, TOTL);
508 		high_val = E1000_READ_REG(&Adapter->Shared, TOTH);
509 		*val = (uint64_t)e1000g_ksp->Toth.value.ul << 32 |
510 		    (uint64_t)e1000g_ksp->Totl.value.ul;
511 		*val += (uint64_t)high_val << 32 | (uint64_t)low_val;
512 
513 		e1000g_ksp->Totl.value.ul = (uint32_t)*val;
514 		e1000g_ksp->Toth.value.ul = (uint32_t)(*val >> 32);
515 		break;
516 
517 	case MAC_STAT_OPACKETS:
518 		e1000g_ksp->Tpt.value.ul +=
519 		    E1000_READ_REG(&Adapter->Shared, TPT);
520 		*val = e1000g_ksp->Tpt.value.ul;
521 		break;
522 
523 	case ETHER_STAT_ALIGN_ERRORS:
524 		e1000g_ksp->Algnerrc.value.ul +=
525 		    E1000_READ_REG(&Adapter->Shared, ALGNERRC);
526 		*val = e1000g_ksp->Algnerrc.value.ul;
527 		break;
528 
529 	case ETHER_STAT_FCS_ERRORS:
530 		e1000g_ksp->Crcerrs.value.ul +=
531 		    E1000_READ_REG(&Adapter->Shared, CRCERRS);
532 		*val = e1000g_ksp->Crcerrs.value.ul;
533 		break;
534 
535 	case ETHER_STAT_SQE_ERRORS:
536 		e1000g_ksp->Sec.value.ul +=
537 		    E1000_READ_REG(&Adapter->Shared, SEC);
538 		*val = e1000g_ksp->Sec.value.ul;
539 		break;
540 
541 	case ETHER_STAT_CARRIER_ERRORS:
542 		e1000g_ksp->Cexterr.value.ul +=
543 		    E1000_READ_REG(&Adapter->Shared, CEXTERR);
544 		*val = e1000g_ksp->Cexterr.value.ul;
545 		break;
546 
547 	case ETHER_STAT_EX_COLLISIONS:
548 		e1000g_ksp->Ecol.value.ul +=
549 		    E1000_READ_REG(&Adapter->Shared, ECOL);
550 		*val = e1000g_ksp->Ecol.value.ul;
551 		break;
552 
553 	case ETHER_STAT_TX_LATE_COLLISIONS:
554 		e1000g_ksp->Latecol.value.ul +=
555 		    E1000_READ_REG(&Adapter->Shared, LATECOL);
556 		*val = e1000g_ksp->Latecol.value.ul;
557 		break;
558 
559 	case ETHER_STAT_DEFER_XMTS:
560 		e1000g_ksp->Dc.value.ul +=
561 		    E1000_READ_REG(&Adapter->Shared, DC);
562 		*val = e1000g_ksp->Dc.value.ul;
563 		break;
564 
565 	case ETHER_STAT_FIRST_COLLISIONS:
566 		e1000g_ksp->Scc.value.ul +=
567 		    E1000_READ_REG(&Adapter->Shared, SCC);
568 		*val = e1000g_ksp->Scc.value.ul;
569 		break;
570 
571 	case ETHER_STAT_MULTI_COLLISIONS:
572 		e1000g_ksp->Mcc.value.ul +=
573 		    E1000_READ_REG(&Adapter->Shared, MCC);
574 		*val = e1000g_ksp->Mcc.value.ul;
575 		break;
576 
577 	case ETHER_STAT_MACRCV_ERRORS:
578 		e1000g_ksp->Rxerrc.value.ul +=
579 		    E1000_READ_REG(&Adapter->Shared, RXERRC);
580 		*val = e1000g_ksp->Rxerrc.value.ul;
581 		break;
582 
583 	case ETHER_STAT_MACXMT_ERRORS:
584 		e1000g_ksp->Ecol.value.ul +=
585 		    E1000_READ_REG(&Adapter->Shared, ECOL);
586 		*val = e1000g_ksp->Ecol.value.ul;
587 		break;
588 
589 	case ETHER_STAT_TOOLONG_ERRORS:
590 		e1000g_ksp->Roc.value.ul +=
591 		    E1000_READ_REG(&Adapter->Shared, ROC);
592 		*val = e1000g_ksp->Roc.value.ul;
593 		break;
594 
595 	case ETHER_STAT_XCVR_ADDR:
596 		/* The Internal PHY's MDI address for each MAC is 1 */
597 		*val = 1;
598 		break;
599 
600 	case ETHER_STAT_XCVR_ID:
601 		e1000_read_phy_reg(&Adapter->Shared, PHY_ID1, &phy_reg);
602 		e1000_read_phy_reg(&Adapter->Shared, PHY_ID2, &phy_reg_2);
603 		*val = (uint32_t)((phy_reg << 16) | phy_reg_2);
604 		break;
605 
606 	case ETHER_STAT_XCVR_INUSE:
607 		e1000_read_phy_reg(&Adapter->Shared, PHY_STATUS, &phy_reg);
608 		switch (Adapter->link_speed) {
609 		case SPEED_1000:
610 			*val =
611 			    (Adapter->Shared.media_type ==
612 			    e1000_media_type_copper) ? XCVR_1000T :
613 			    XCVR_1000X;
614 			break;
615 		case SPEED_100:
616 			*val =
617 			    (Adapter->Shared.media_type ==
618 			    e1000_media_type_copper) ? (phy_reg &
619 			    MII_SR_100T4_CAPS) ? XCVR_100T4 : XCVR_100T2 :
620 			    XCVR_100X;
621 			break;
622 		case SPEED_10:
623 			*val = XCVR_10;
624 			break;
625 		default:
626 			*val = XCVR_NONE;
627 			break;
628 		}
629 		break;
630 
631 	case ETHER_STAT_CAP_1000FDX:
632 		e1000_read_phy_reg(&Adapter->Shared, PHY_EXT_STATUS,
633 		    &phy_reg);
634 		*val = ((phy_reg & IEEE_ESR_1000T_FD_CAPS) ||
635 		    (phy_reg & IEEE_ESR_1000X_FD_CAPS)) ? 1 : 0;
636 		break;
637 
638 	case ETHER_STAT_CAP_1000HDX:
639 		e1000_read_phy_reg(&Adapter->Shared, PHY_EXT_STATUS,
640 		    &phy_reg);
641 		*val = ((phy_reg & IEEE_ESR_1000T_HD_CAPS) ||
642 		    (phy_reg & IEEE_ESR_1000X_HD_CAPS)) ? 1 : 0;
643 		break;
644 
645 	case ETHER_STAT_CAP_100FDX:
646 		e1000_read_phy_reg(&Adapter->Shared, PHY_STATUS, &phy_reg);
647 		*val = ((phy_reg & MII_SR_100X_FD_CAPS) ||
648 		    (phy_reg & MII_SR_100T2_FD_CAPS)) ? 1 : 0;
649 		break;
650 
651 	case ETHER_STAT_CAP_100HDX:
652 		e1000_read_phy_reg(&Adapter->Shared, PHY_STATUS, &phy_reg);
653 		*val = ((phy_reg & MII_SR_100X_HD_CAPS) ||
654 		    (phy_reg & MII_SR_100T2_HD_CAPS)) ? 1 : 0;
655 		break;
656 
657 	case ETHER_STAT_CAP_10FDX:
658 		e1000_read_phy_reg(&Adapter->Shared, PHY_STATUS, &phy_reg);
659 		*val = (phy_reg & MII_SR_10T_FD_CAPS) ? 1 : 0;
660 		break;
661 
662 	case ETHER_STAT_CAP_10HDX:
663 		e1000_read_phy_reg(&Adapter->Shared, PHY_STATUS, &phy_reg);
664 		*val = (phy_reg & MII_SR_10T_HD_CAPS) ? 1 : 0;
665 		break;
666 
667 	case ETHER_STAT_CAP_ASMPAUSE:
668 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
669 		    &phy_reg);
670 		*val = (phy_reg & NWAY_AR_ASM_DIR) ? 1 : 0;
671 		break;
672 
673 	case ETHER_STAT_CAP_PAUSE:
674 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
675 		    &phy_reg);
676 		*val = (phy_reg & NWAY_AR_PAUSE) ? 1 : 0;
677 		break;
678 
679 	case ETHER_STAT_CAP_AUTONEG:
680 		e1000_read_phy_reg(&Adapter->Shared, PHY_STATUS, &phy_reg);
681 		*val = (phy_reg & MII_SR_AUTONEG_CAPS) ? 1 : 0;
682 		break;
683 
684 	case ETHER_STAT_ADV_CAP_1000FDX:
685 		e1000_read_phy_reg(&Adapter->Shared, PHY_1000T_CTRL,
686 		    &phy_reg);
687 		*val = (phy_reg & CR_1000T_FD_CAPS) ? 1 : 0;
688 		break;
689 
690 	case ETHER_STAT_ADV_CAP_1000HDX:
691 		e1000_read_phy_reg(&Adapter->Shared, PHY_1000T_CTRL,
692 		    &phy_reg);
693 		*val = (phy_reg & CR_1000T_HD_CAPS) ? 1 : 0;
694 		break;
695 
696 	case ETHER_STAT_ADV_CAP_100FDX:
697 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
698 		    &phy_reg);
699 		*val = (phy_reg & NWAY_AR_100TX_FD_CAPS) ? 1 : 0;
700 		break;
701 
702 	case ETHER_STAT_ADV_CAP_100HDX:
703 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
704 		    &phy_reg);
705 		*val = (phy_reg & NWAY_AR_100TX_HD_CAPS) ? 1 : 0;
706 		break;
707 
708 	case ETHER_STAT_ADV_CAP_10FDX:
709 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
710 		    &phy_reg);
711 		*val = (phy_reg & NWAY_AR_10T_FD_CAPS) ? 1 : 0;
712 		break;
713 
714 	case ETHER_STAT_ADV_CAP_10HDX:
715 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
716 		    &phy_reg);
717 		*val = (phy_reg & NWAY_AR_10T_HD_CAPS) ? 1 : 0;
718 		break;
719 
720 	case ETHER_STAT_ADV_CAP_ASMPAUSE:
721 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
722 		    &phy_reg);
723 		*val = (phy_reg & NWAY_AR_ASM_DIR) ? 1 : 0;
724 		break;
725 
726 	case ETHER_STAT_ADV_CAP_PAUSE:
727 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
728 		    &phy_reg);
729 		*val = (phy_reg & NWAY_AR_PAUSE) ? 1 : 0;
730 		break;
731 
732 	case ETHER_STAT_ADV_CAP_AUTONEG:
733 		*val = Adapter->Shared.autoneg;
734 		break;
735 
736 	case ETHER_STAT_LP_CAP_1000FDX:
737 		e1000_read_phy_reg(&Adapter->Shared, PHY_1000T_STATUS,
738 		    &phy_reg);
739 		*val = (phy_reg & SR_1000T_LP_FD_CAPS) ? 1 : 0;
740 		break;
741 
742 	case ETHER_STAT_LP_CAP_1000HDX:
743 		e1000_read_phy_reg(&Adapter->Shared, PHY_1000T_STATUS,
744 		    &phy_reg);
745 		*val = (phy_reg & SR_1000T_LP_HD_CAPS) ? 1 : 0;
746 		break;
747 
748 	case ETHER_STAT_LP_CAP_100FDX:
749 		e1000_read_phy_reg(&Adapter->Shared, PHY_LP_ABILITY,
750 		    &phy_reg);
751 		*val = (phy_reg & NWAY_LPAR_100TX_FD_CAPS) ? 1 : 0;
752 		break;
753 
754 	case ETHER_STAT_LP_CAP_100HDX:
755 		e1000_read_phy_reg(&Adapter->Shared, PHY_LP_ABILITY,
756 		    &phy_reg);
757 		*val = (phy_reg & NWAY_LPAR_100TX_HD_CAPS) ? 1 : 0;
758 		break;
759 
760 	case ETHER_STAT_LP_CAP_10FDX:
761 		e1000_read_phy_reg(&Adapter->Shared, PHY_LP_ABILITY,
762 		    &phy_reg);
763 		*val = (phy_reg & NWAY_LPAR_10T_FD_CAPS) ? 1 : 0;
764 		break;
765 
766 	case ETHER_STAT_LP_CAP_10HDX:
767 		e1000_read_phy_reg(&Adapter->Shared, PHY_LP_ABILITY,
768 		    &phy_reg);
769 		*val = (phy_reg & NWAY_LPAR_10T_HD_CAPS) ? 1 : 0;
770 		break;
771 
772 	case ETHER_STAT_LP_CAP_ASMPAUSE:
773 		e1000_read_phy_reg(&Adapter->Shared, PHY_LP_ABILITY,
774 		    &phy_reg);
775 		*val = (phy_reg & NWAY_LPAR_ASM_DIR) ? 1 : 0;
776 		break;
777 
778 	case ETHER_STAT_LP_CAP_PAUSE:
779 		e1000_read_phy_reg(&Adapter->Shared, PHY_LP_ABILITY,
780 		    &phy_reg);
781 		*val = (phy_reg & NWAY_LPAR_PAUSE) ? 1 : 0;
782 		break;
783 
784 	case ETHER_STAT_LP_CAP_AUTONEG:
785 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_EXP,
786 		    &phy_reg);
787 		*val = (phy_reg & NWAY_ER_LP_NWAY_CAPS) ? 1 : 0;
788 		break;
789 
790 	case ETHER_STAT_LINK_ASMPAUSE:
791 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
792 		    &phy_reg);
793 		*val = (phy_reg & NWAY_AR_ASM_DIR) ? 1 : 0;
794 		break;
795 
796 	case ETHER_STAT_LINK_PAUSE:
797 		e1000_read_phy_reg(&Adapter->Shared, PHY_AUTONEG_ADV,
798 		    &phy_reg);
799 		*val = (phy_reg & NWAY_AR_PAUSE) ? 1 : 0;
800 		break;
801 
802 	case ETHER_STAT_LINK_AUTONEG:
803 		e1000_read_phy_reg(&Adapter->Shared, PHY_CTRL, &phy_reg);
804 		*val = (phy_reg & MII_CR_AUTO_NEG_EN) ? 1 : 0;
805 		break;
806 
807 	case ETHER_STAT_LINK_DUPLEX:
808 		*val = (Adapter->link_duplex == FULL_DUPLEX) ?
809 		    LINK_DUPLEX_FULL : LINK_DUPLEX_HALF;
810 		break;
811 
812 	default:
813 		return (ENOTSUP);
814 	}
815 
816 	return (0);
817 }
818 
819 /*
820  * **********************************************************************
821  * Name:	InitStatsCounters					*
822  *									*
823  * Description: This routine will create and initialize the kernel	*
824  *	       statistics counters.					*
825  *									*
826  * Author:      Phil Cayton						*
827  *									*
828  * Born on Date:    7/13/98						*
829  *									*
830  * Arguments:								*
831  *      Adapter - A pointer to our context sensitive "Adapter"		*
832  *		structure.						*
833  *									*
834  * Returns:								*
835  *      '0' if unable to create kernel statistics structure.		*
836  *      '1' if creation and initialization successful			*
837  *									*
838  * File: e1000g_stat.c							*
839  *									*
840  * Modification log:							*
841  * Date      Who  Description						*
842  * --------  ---  ------------------------------------------------------*
843  *									*
844  * **********************************************************************
845  */
846 int
847 InitStatsCounters(IN struct e1000g *Adapter)
848 {
849 	kstat_t *ksp;
850 	e1000gstat *e1000g_ksp;
851 
852 	/*
853 	 * Create and init kstat
854 	 */
855 	ksp = kstat_create(WSNAME, ddi_get_instance(Adapter->dip),
856 	    "statistics", "net", KSTAT_TYPE_NAMED,
857 	    sizeof (e1000gstat) / sizeof (kstat_named_t), 0);
858 
859 	if (ksp == NULL) {
860 		e1000g_log(Adapter, CE_WARN,
861 		    "Could not create kernel statistics\n");
862 		return (DDI_FAILURE);
863 	}
864 
865 	Adapter->e1000g_ksp = ksp;	/* Fill in the Adapters ksp */
866 
867 	e1000g_ksp = (e1000gstat *) ksp->ks_data;
868 
869 	/*
870 	 * Initialize all the statistics
871 	 */
872 	kstat_named_init(&e1000g_ksp->link_speed, "link_speed",
873 	    KSTAT_DATA_ULONG);
874 
875 	kstat_named_init(&e1000g_ksp->rx_none, "Rx No Data",
876 	    KSTAT_DATA_ULONG);
877 
878 	kstat_named_init(&e1000g_ksp->rx_error, "Rx Error",
879 	    KSTAT_DATA_ULONG);
880 
881 	kstat_named_init(&e1000g_ksp->rx_no_freepkt, "Rx Freelist Empty",
882 	    KSTAT_DATA_ULONG);
883 
884 	kstat_named_init(&e1000g_ksp->rx_avail_freepkt, "Rx Freelist Avail",
885 	    KSTAT_DATA_ULONG);
886 
887 	kstat_named_init(&e1000g_ksp->rx_esballoc_fail, "Rx Desballoc Failure",
888 	    KSTAT_DATA_ULONG);
889 
890 	kstat_named_init(&e1000g_ksp->rx_exceed_pkt, "Rx Exceed Max Pkt Count",
891 	    KSTAT_DATA_ULONG);
892 
893 	kstat_named_init(&e1000g_ksp->rx_multi_desc, "Rx Span Multi Desc",
894 	    KSTAT_DATA_ULONG);
895 
896 	kstat_named_init(&e1000g_ksp->rx_allocb_fail, "Rx Allocb Failure",
897 	    KSTAT_DATA_ULONG);
898 
899 	kstat_named_init(&e1000g_ksp->rx_seq_intr, "Rx Seq Err Intr",
900 	    KSTAT_DATA_ULONG);
901 
902 	kstat_named_init(&e1000g_ksp->tx_no_desc, "Tx No Desc",
903 	    KSTAT_DATA_ULONG);
904 
905 	kstat_named_init(&e1000g_ksp->tx_no_swpkt, "Tx No Buffer",
906 	    KSTAT_DATA_ULONG);
907 
908 	kstat_named_init(&e1000g_ksp->tx_lack_desc, "Tx Desc Insufficient",
909 	    KSTAT_DATA_ULONG);
910 
911 	kstat_named_init(&e1000g_ksp->tx_send_fail,
912 	    "Tx Send Failure", KSTAT_DATA_ULONG);
913 
914 	kstat_named_init(&e1000g_ksp->tx_multi_cookie,
915 	    "Tx Bind Multi Cookies", KSTAT_DATA_ULONG);
916 
917 	kstat_named_init(&e1000g_ksp->tx_over_size, "Tx Pkt Over Size",
918 	    KSTAT_DATA_ULONG);
919 
920 	kstat_named_init(&e1000g_ksp->tx_under_size, "Tx Pkt Under Size",
921 	    KSTAT_DATA_ULONG);
922 
923 	kstat_named_init(&e1000g_ksp->tx_copy, "Tx Send Copy",
924 	    KSTAT_DATA_ULONG);
925 
926 	kstat_named_init(&e1000g_ksp->tx_bind, "Tx Send Bind",
927 	    KSTAT_DATA_ULONG);
928 
929 	kstat_named_init(&e1000g_ksp->tx_multi_copy, "Tx Copy Multi Frags",
930 	    KSTAT_DATA_ULONG);
931 
932 	kstat_named_init(&e1000g_ksp->tx_reschedule, "Tx Reschedule",
933 	    KSTAT_DATA_ULONG);
934 
935 	kstat_named_init(&e1000g_ksp->tx_empty_frags, "Tx Empty Frags",
936 	    KSTAT_DATA_ULONG);
937 
938 	kstat_named_init(&e1000g_ksp->tx_exceed_frags, "Tx Exceed Max Frags",
939 	    KSTAT_DATA_ULONG);
940 
941 	kstat_named_init(&e1000g_ksp->tx_recycle,
942 	    "Tx Desc Recycle", KSTAT_DATA_ULONG);
943 
944 	kstat_named_init(&e1000g_ksp->tx_recycle_retry,
945 	    "Tx Desc Recycle Retry", KSTAT_DATA_ULONG);
946 
947 	kstat_named_init(&e1000g_ksp->tx_recycle_intr,
948 	    "Tx Desc Recycle Intr", KSTAT_DATA_ULONG);
949 
950 	kstat_named_init(&e1000g_ksp->tx_recycle_none,
951 	    "Tx Desc Recycled None", KSTAT_DATA_ULONG);
952 
953 	kstat_named_init(&e1000g_ksp->StallWatchdog,
954 	    "Tx Stall Watchdog", KSTAT_DATA_ULONG);
955 
956 	kstat_named_init(&e1000g_ksp->reset_count,
957 	    "Reset Count", KSTAT_DATA_ULONG);
958 
959 	kstat_named_init(&e1000g_ksp->intr_type,
960 	    "Interrupt Type", KSTAT_DATA_ULONG);
961 
962 	kstat_named_init(&e1000g_ksp->Mpc, "Recv_Missed_Packets",
963 	    KSTAT_DATA_ULONG);
964 
965 	kstat_named_init(&e1000g_ksp->Symerrs, "Recv_Symbol_Errors",
966 	    KSTAT_DATA_ULONG);
967 
968 	kstat_named_init(&e1000g_ksp->Rlec, "Recv_Length_Errors",
969 	    KSTAT_DATA_ULONG);
970 
971 	kstat_named_init(&e1000g_ksp->Xonrxc, "XONs_Recvd",
972 	    KSTAT_DATA_ULONG);
973 
974 	kstat_named_init(&e1000g_ksp->Xontxc, "XONs_Xmitd",
975 	    KSTAT_DATA_ULONG);
976 
977 	kstat_named_init(&e1000g_ksp->Xoffrxc, "XOFFs_Recvd",
978 	    KSTAT_DATA_ULONG);
979 
980 	kstat_named_init(&e1000g_ksp->Xofftxc, "XOFFs_Xmitd",
981 	    KSTAT_DATA_ULONG);
982 
983 	kstat_named_init(&e1000g_ksp->Fcruc, "Recv_Unsupport_FC_Pkts",
984 	    KSTAT_DATA_ULONG);
985 
986 	kstat_named_init(&e1000g_ksp->Prc64, "Pkts_Recvd_(  64b)",
987 	    KSTAT_DATA_ULONG);
988 
989 	kstat_named_init(&e1000g_ksp->Prc127, "Pkts_Recvd_(  65- 127b)",
990 	    KSTAT_DATA_ULONG);
991 
992 	kstat_named_init(&e1000g_ksp->Prc255, "Pkts_Recvd_( 127- 255b)",
993 	    KSTAT_DATA_ULONG);
994 
995 	kstat_named_init(&e1000g_ksp->Prc511, "Pkts_Recvd_( 256- 511b)",
996 	    KSTAT_DATA_ULONG);
997 
998 	kstat_named_init(&e1000g_ksp->Prc1023, "Pkts_Recvd_( 511-1023b)",
999 	    KSTAT_DATA_ULONG);
1000 
1001 	kstat_named_init(&e1000g_ksp->Prc1522, "Pkts_Recvd_(1024-1522b)",
1002 	    KSTAT_DATA_ULONG);
1003 
1004 	kstat_named_init(&e1000g_ksp->Gprc, "Good_Pkts_Recvd",
1005 	    KSTAT_DATA_ULONG);
1006 
1007 	kstat_named_init(&e1000g_ksp->Gptc, "Good_Pkts_Xmitd",
1008 	    KSTAT_DATA_ULONG);
1009 
1010 	kstat_named_init(&e1000g_ksp->Gorl, "Good_Octets_Recvd_Lo",
1011 	    KSTAT_DATA_ULONG);
1012 
1013 	kstat_named_init(&e1000g_ksp->Gorh, "Good_Octets_Recvd_Hi",
1014 	    KSTAT_DATA_ULONG);
1015 
1016 	kstat_named_init(&e1000g_ksp->Gotl, "Good_Octets_Xmitd_Lo",
1017 	    KSTAT_DATA_ULONG);
1018 
1019 	kstat_named_init(&e1000g_ksp->Goth, "Good_Octets_Xmitd_Hi",
1020 	    KSTAT_DATA_ULONG);
1021 
1022 	kstat_named_init(&e1000g_ksp->Ruc, "Recv_Undersize",
1023 	    KSTAT_DATA_ULONG);
1024 
1025 	kstat_named_init(&e1000g_ksp->Rfc, "Recv_Frag",
1026 	    KSTAT_DATA_ULONG);
1027 
1028 	kstat_named_init(&e1000g_ksp->Roc, "Recv_Oversize",
1029 	    KSTAT_DATA_ULONG);
1030 
1031 	kstat_named_init(&e1000g_ksp->Rjc, "Recv_Jabber",
1032 	    KSTAT_DATA_ULONG);
1033 
1034 	kstat_named_init(&e1000g_ksp->Torl, "Total_Octets_Recvd_Lo",
1035 	    KSTAT_DATA_ULONG);
1036 
1037 	kstat_named_init(&e1000g_ksp->Torh, "Total_Octets_Recvd_Hi",
1038 	    KSTAT_DATA_ULONG);
1039 
1040 	kstat_named_init(&e1000g_ksp->Totl, "Total_Octets_Xmitd_Lo",
1041 	    KSTAT_DATA_ULONG);
1042 
1043 	kstat_named_init(&e1000g_ksp->Toth, "Total_Octets_Xmitd_Hi",
1044 	    KSTAT_DATA_ULONG);
1045 
1046 	kstat_named_init(&e1000g_ksp->Tpr, "Total_Packets_Recvd",
1047 	    KSTAT_DATA_ULONG);
1048 
1049 	kstat_named_init(&e1000g_ksp->Tpt, "Total_Packets_Xmitd",
1050 	    KSTAT_DATA_ULONG);
1051 
1052 	kstat_named_init(&e1000g_ksp->Ptc64, "Pkts_Xmitd_(  64b)",
1053 	    KSTAT_DATA_ULONG);
1054 
1055 	kstat_named_init(&e1000g_ksp->Ptc127, "Pkts_Xmitd_(  65- 127b)",
1056 	    KSTAT_DATA_ULONG);
1057 
1058 	kstat_named_init(&e1000g_ksp->Ptc255, "Pkts_Xmitd_( 128- 255b)",
1059 	    KSTAT_DATA_ULONG);
1060 
1061 	kstat_named_init(&e1000g_ksp->Ptc511, "Pkts_Xmitd_( 255- 511b)",
1062 	    KSTAT_DATA_ULONG);
1063 
1064 	kstat_named_init(&e1000g_ksp->Ptc1023, "Pkts_Xmitd_( 512-1023b)",
1065 	    KSTAT_DATA_ULONG);
1066 
1067 	kstat_named_init(&e1000g_ksp->Ptc1522, "Pkts_Xmitd_(1024-1522b)",
1068 	    KSTAT_DATA_ULONG);
1069 
1070 	/*
1071 	 * Livengood Initializations
1072 	 */
1073 	kstat_named_init(&e1000g_ksp->Tncrs, "Xmit_with_No_CRS",
1074 	    KSTAT_DATA_ULONG);
1075 
1076 	kstat_named_init(&e1000g_ksp->Tsctc, "Xmit_TCP_Seg_Contexts",
1077 	    KSTAT_DATA_ULONG);
1078 
1079 	kstat_named_init(&e1000g_ksp->Tsctfc, "Xmit_TCP_Seg_Contexts_Fail",
1080 	    KSTAT_DATA_ULONG);
1081 
1082 	/*
1083 	 * Jumbo Frame Counters
1084 	 */
1085 	kstat_named_init(&e1000g_ksp->JumboTx_4K, "Jumbo Tx Frame  4K",
1086 	    KSTAT_DATA_ULONG);
1087 
1088 	kstat_named_init(&e1000g_ksp->JumboRx_4K, "Jumbo Rx Frame  4K",
1089 	    KSTAT_DATA_ULONG);
1090 
1091 	kstat_named_init(&e1000g_ksp->JumboTx_8K, "Jumbo Tx Frame  8K",
1092 	    KSTAT_DATA_ULONG);
1093 
1094 	kstat_named_init(&e1000g_ksp->JumboRx_8K, "Jumbo Rx Frame  8K",
1095 	    KSTAT_DATA_ULONG);
1096 
1097 	kstat_named_init(&e1000g_ksp->JumboTx_16K, "Jumbo Tx Frame 16K",
1098 	    KSTAT_DATA_ULONG);
1099 
1100 	kstat_named_init(&e1000g_ksp->JumboRx_16K, "Jumbo Rx Frame 16K",
1101 	    KSTAT_DATA_ULONG);
1102 
1103 	/*
1104 	 * Function to provide kernel stat update on demand
1105 	 */
1106 	ksp->ks_update = UpdateStatsCounters;
1107 
1108 	/*
1109 	 * Pointer into provider's raw statistics
1110 	 */
1111 	ksp->ks_private = (void *)Adapter;
1112 
1113 	/*
1114 	 * Add kstat to systems kstat chain
1115 	 */
1116 	kstat_install(ksp);
1117 
1118 	return (DDI_SUCCESS);
1119 }
1120