xref: /illumos-gate/usr/src/uts/common/io/atge/atge_main.c (revision 80e3e2368f7911a78a5f2f1a961052b37f3a76d0)
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 (c) 2012 Gary Mills
24  *
25  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
26  *
27  * Copyright (c) 2018, Joyent, Inc.
28  */
29 /*
30  * Copyright (c) 2009, Pyun YongHyeon <yongari@FreeBSD.org>
31  * All rights reserved.
32  *
33  * Redistribution and use in source and binary forms, with or without
34  * modification, are permitted provided that the following conditions
35  * are met:
36  * 1. Redistributions of source code must retain the above copyright
37  *    notice unmodified, this list of conditions, and the following
38  *    disclaimer.
39  * 2. Redistributions in binary form must reproduce the above copyright
40  *    notice, this list of conditions and the following disclaimer in the
41  *    documentation and/or other materials provided with the distribution.
42  *
43  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53  * SUCH DAMAGE.
54  */
55 
56 #include <sys/types.h>
57 #include <sys/stream.h>
58 #include <sys/strsun.h>
59 #include <sys/stat.h>
60 #include <sys/modctl.h>
61 #include <sys/kstat.h>
62 #include <sys/ethernet.h>
63 #include <sys/devops.h>
64 #include <sys/debug.h>
65 #include <sys/conf.h>
66 #include <sys/mii.h>
67 #include <sys/miiregs.h>
68 #include <sys/mac.h>
69 #include <sys/mac_provider.h>
70 #include <sys/mac_ether.h>
71 #include <sys/sysmacros.h>
72 #include <sys/dditypes.h>
73 #include <sys/ddi.h>
74 #include <sys/sunddi.h>
75 #include <sys/byteorder.h>
76 #include <sys/note.h>
77 #include <sys/vlan.h>
78 #include <sys/strsubr.h>
79 #include <sys/crc32.h>
80 #include <sys/sdt.h>
81 #include <sys/pci.h>
82 #include <sys/pci_cap.h>
83 
84 #include "atge.h"
85 #include "atge_cmn_reg.h"
86 #include "atge_l1c_reg.h"
87 #include "atge_l1e_reg.h"
88 #include "atge_l1_reg.h"
89 
90 
91 /*
92  * Atheros/Attansic Ethernet chips are of four types - L1, L2, L1E and L1C.
93  * This driver is for L1E/L1/L1C but can be extended to support other chips.
94  * L1E comes in 1Gigabit and Fast Ethernet flavors. L1 comes in 1Gigabit
95  * flavors only.  L1C comes in both flavours.
96  *
97  * Atheros/Attansic Ethernet controllers have descriptor based TX and RX
98  * with an exception of L1E. L1E's RX side is not descriptor based ring.
99  * The L1E's RX uses pages (not to be confused with MMU pages) for
100  * receiving pkts. The header has four fields :
101  *
102  *        uint32_t seqno;    Sequence number of the frame.
103  *        uint32_t length;   Length of the frame.
104  *        uint32_t flags;    Flags
105  *        uint32_t vtag;     We don't use hardware VTAG.
106  *
107  * We use only one queue for RX (each queue can have two pages) and each
108  * page is L1E_RX_PAGE_SZ large in bytes. That's the reason we don't
109  * use zero-copy RX because we are limited to two pages and each page
110  * accomodates large number of pkts.
111  *
112  * The TX side on all three chips is descriptor based ring; and all the
113  * more reason to have one driver for these chips.
114  *
115  * We use two locks - atge_intr_lock and atge_tx_lock. Both the locks
116  * should be held if the operation has impact on the driver instance.
117  *
118  * All the three chips have hash-based multicast filter.
119  *
120  * We use CMB (Coalescing Message Block) for RX but not for TX as there
121  * are some issues with TX. RX CMB is used to get the last descriptor
122  * posted by the chip. Each CMB is for a RX page (one queue can have two
123  * pages) and are uint32_t (4 bytes) long.
124  *
125  * The descriptor table should have 32-bit physical address limit due to
126  * the limitation of having same high address for TX/RX/SMB/CMB. The
127  * TX/RX buffers can be 64-bit.
128  *
129  * Every DMA memory in atge is represented by atge_dma_t be it TX/RX Buffers
130  * or TX/RX descriptor table or SMB/CMB. To keep the code simple, we have
131  * kept sgl as 1 so that we get contingous pages from root complex.
132  *
133  * L1 chip (0x1048) uses descriptor based TX and RX ring. Most of registers are
134  * common with L1E chip (0x1026).
135  */
136 
137 /*
138  * Function Prototypes for debugging.
139  */
140 void	atge_error(dev_info_t *, char *, ...);
141 void	atge_debug_func(char *, ...);
142 
143 /*
144  * Function Prototypes for driver operations.
145  */
146 static int	atge_resume(dev_info_t *);
147 static int	atge_add_intr(atge_t *);
148 static int	atge_alloc_dma(atge_t *);
149 static void	atge_remove_intr(atge_t *);
150 static void	atge_free_dma(atge_t *);
151 static void	atge_device_reset(atge_t *);
152 static void	atge_device_init(atge_t *);
153 static void	atge_device_start(atge_t *);
154 static void	atge_disable_intrs(atge_t *);
155 atge_dma_t *atge_alloc_a_dma_blk(atge_t *, ddi_dma_attr_t *, int, int);
156 void	atge_free_a_dma_blk(atge_dma_t *);
157 static void	atge_rxfilter(atge_t *);
158 static void	atge_device_reset_l1_l1e(atge_t *);
159 void	atge_program_ether(atge_t *atgep);
160 void	atge_device_restart(atge_t *);
161 void	atge_device_stop(atge_t *);
162 static int	atge_send_a_packet(atge_t *, mblk_t *);
163 static uint32_t	atge_ether_crc(const uint8_t *, int);
164 
165 
166 /*
167  * L1E/L2E specific functions.
168  */
169 void	atge_l1e_device_reset(atge_t *);
170 void	atge_l1e_stop_mac(atge_t *);
171 int	atge_l1e_alloc_dma(atge_t *);
172 void	atge_l1e_free_dma(atge_t *);
173 void	atge_l1e_init_tx_ring(atge_t *);
174 void	atge_l1e_init_rx_pages(atge_t *);
175 void	atge_l1e_program_dma(atge_t *);
176 void	atge_l1e_send_packet(atge_ring_t *);
177 mblk_t	*atge_l1e_receive(atge_t *);
178 uint_t	atge_l1e_interrupt(caddr_t, caddr_t);
179 void	atge_l1e_gather_stats(atge_t *);
180 void	atge_l1e_clear_stats(atge_t *);
181 
182 /*
183  * L1 specific functions.
184  */
185 int	atge_l1_alloc_dma(atge_t *);
186 void	atge_l1_free_dma(atge_t *);
187 void	atge_l1_init_tx_ring(atge_t *);
188 void	atge_l1_init_rx_ring(atge_t *);
189 void	atge_l1_init_rr_ring(atge_t *);
190 void	atge_l1_init_cmb(atge_t *);
191 void	atge_l1_init_smb(atge_t *);
192 void	atge_l1_program_dma(atge_t *);
193 void	atge_l1_stop_tx_mac(atge_t *);
194 void	atge_l1_stop_rx_mac(atge_t *);
195 uint_t	atge_l1_interrupt(caddr_t, caddr_t);
196 void	atge_l1_send_packet(atge_ring_t *);
197 
198 /*
199  * L1C specific functions.
200  */
201 int	atge_l1c_alloc_dma(atge_t *);
202 void	atge_l1c_free_dma(atge_t *);
203 void	atge_l1c_init_tx_ring(atge_t *);
204 void	atge_l1c_init_rx_ring(atge_t *);
205 void	atge_l1c_init_rr_ring(atge_t *);
206 void	atge_l1c_init_cmb(atge_t *);
207 void	atge_l1c_init_smb(atge_t *);
208 void	atge_l1c_program_dma(atge_t *);
209 void	atge_l1c_stop_tx_mac(atge_t *);
210 void	atge_l1c_stop_rx_mac(atge_t *);
211 uint_t	atge_l1c_interrupt(caddr_t, caddr_t);
212 void	atge_l1c_send_packet(atge_ring_t *);
213 void	atge_l1c_gather_stats(atge_t *);
214 void	atge_l1c_clear_stats(atge_t *);
215 
216 /*
217  * Function prototyps for MII operations.
218  */
219 uint16_t	atge_mii_read(void *, uint8_t, uint8_t);
220 void	atge_mii_write(void *, uint8_t, uint8_t, uint16_t);
221 uint16_t	atge_l1c_mii_read(void *, uint8_t, uint8_t);
222 void	atge_l1c_mii_write(void *, uint8_t, uint8_t, uint16_t);
223 void	atge_l1e_mii_reset(void *);
224 void	atge_l1_mii_reset(void *);
225 void	atge_l1c_mii_reset(void *);
226 static void	atge_mii_notify(void *, link_state_t);
227 void	atge_tx_reclaim(atge_t *atgep, int cons);
228 
229 /*
230  * L1E/L2E chip.
231  */
232 static	mii_ops_t atge_l1e_mii_ops = {
233 	MII_OPS_VERSION,
234 	atge_mii_read,
235 	atge_mii_write,
236 	atge_mii_notify,
237 	atge_l1e_mii_reset
238 };
239 
240 /*
241  * L1 chip.
242  */
243 static	mii_ops_t atge_l1_mii_ops = {
244 	MII_OPS_VERSION,
245 	atge_mii_read,
246 	atge_mii_write,
247 	atge_mii_notify,
248 	atge_l1_mii_reset
249 };
250 
251 /*
252  * L1C chip.
253  */
254 static	mii_ops_t atge_l1c_mii_ops = {
255 	MII_OPS_VERSION,
256 	atge_l1c_mii_read,
257 	atge_l1c_mii_write,
258 	atge_mii_notify,
259 	NULL
260 };
261 
262 /*
263  * Function Prototypes for MAC callbacks.
264  */
265 static int	atge_m_stat(void *, uint_t, uint64_t *);
266 static int	atge_m_start(void *);
267 static void	atge_m_stop(void *);
268 static int	atge_m_getprop(void *, const char *, mac_prop_id_t, uint_t,
269     void *);
270 static int	atge_m_setprop(void *, const char *, mac_prop_id_t, uint_t,
271     const void *);
272 static void	atge_m_propinfo(void *, const char *, mac_prop_id_t,
273     mac_prop_info_handle_t);
274 static int	atge_m_unicst(void *, const uint8_t *);
275 static int	atge_m_multicst(void *, boolean_t, const uint8_t *);
276 static int	atge_m_promisc(void *, boolean_t);
277 static mblk_t	*atge_m_tx(void *, mblk_t *);
278 
279 static	mac_callbacks_t	atge_m_callbacks = {
280 	MC_SETPROP | MC_GETPROP | MC_PROPINFO,
281 	atge_m_stat,
282 	atge_m_start,
283 	atge_m_stop,
284 	atge_m_promisc,
285 	atge_m_multicst,
286 	atge_m_unicst,
287 	atge_m_tx,
288 	NULL,		/* mc_reserved */
289 	NULL,		/* mc_ioctl */
290 	NULL,		/* mc_getcapab */
291 	NULL,		/* mc_open */
292 	NULL,		/* mc_close */
293 	atge_m_setprop,
294 	atge_m_getprop,
295 	atge_m_propinfo
296 };
297 
298 /*
299  * DMA Data access requirements.
300  */
301 static struct ddi_device_acc_attr atge_dev_attr = {
302 	DDI_DEVICE_ATTR_V0,
303 	DDI_STRUCTURE_LE_ACC,
304 	DDI_STRICTORDER_ACC
305 };
306 
307 /*
308  * Buffers should be native endianness.
309  */
310 static struct ddi_device_acc_attr atge_buf_attr = {
311 	DDI_DEVICE_ATTR_V0,
312 	DDI_NEVERSWAP_ACC,	/* native endianness */
313 	DDI_STRICTORDER_ACC
314 };
315 
316 /*
317  * DMA device attributes. Buffer can be 64-bit.
318  */
319 static ddi_dma_attr_t atge_dma_attr_buf = {
320 	DMA_ATTR_V0,		/* dma_attr_version */
321 	0,			/* dma_attr_addr_lo */
322 	0x00ffffffffffull,	/* dma_attr_addr_hi */
323 	0x000000003fffull,	/* dma_attr_count_max */
324 	8,			/* dma_attr_align */
325 	0x00003ffc,		/* dma_attr_burstsizes */
326 	1,			/* dma_attr_minxfer */
327 	0x0000000027ffull,	/* dma_attr_maxxfer */
328 	0x0000ffffffffull,	/* dma_attr_seg */
329 	1,			/* dma_attr_sgllen */
330 	1,			/* dma_attr_granular */
331 	0			/* dma_attr_flags */
332 };
333 
334 /*
335  * Table of supported devices.
336  */
337 #define	ATGE_VENDOR_ID	0x1969
338 #define	ATGE_L1_STR	"Attansic L1"
339 #define	ATGE_L1CG_STR	"Atheros AR8131 Gigabit Ethernet"
340 #define	ATGE_L1CF_STR	"Atheros AR8132 Fast Ethernet"
341 #define	ATGE_L1E_STR	"Atheros AR8121/8113/8114"
342 #define	ATGE_AR8151V1_STR	"Atheros AR8151 v1.0 Gigabit Ethernet"
343 #define	ATGE_AR8151V2_STR	"Atheros AR8151 v2.0 Gigabit Ethernet"
344 #define	ATGE_AR8152V1_STR	"Atheros AR8152 v1.1 Fast Ethernet"
345 #define	ATGE_AR8152V2_STR	"Atheros AR8152 v2.0 Fast Ethernet"
346 
347 static atge_cards_t atge_cards[] = {
348 	{ATGE_VENDOR_ID, ATGE_CHIP_AR8151V2_DEV_ID, ATGE_AR8151V2_STR,
349 	    ATGE_CHIP_L1C},
350 	{ATGE_VENDOR_ID, ATGE_CHIP_AR8151V1_DEV_ID, ATGE_AR8151V1_STR,
351 	    ATGE_CHIP_L1C},
352 	{ATGE_VENDOR_ID, ATGE_CHIP_AR8152V2_DEV_ID, ATGE_AR8152V2_STR,
353 	    ATGE_CHIP_L1C},
354 	{ATGE_VENDOR_ID, ATGE_CHIP_AR8152V1_DEV_ID, ATGE_AR8152V1_STR,
355 	    ATGE_CHIP_L1C},
356 	{ATGE_VENDOR_ID, ATGE_CHIP_L1CG_DEV_ID, ATGE_L1CG_STR, ATGE_CHIP_L1C},
357 	{ATGE_VENDOR_ID, ATGE_CHIP_L1CF_DEV_ID, ATGE_L1CF_STR, ATGE_CHIP_L1C},
358 	{ATGE_VENDOR_ID, ATGE_CHIP_L1E_DEV_ID, ATGE_L1E_STR, ATGE_CHIP_L1E},
359 	{ATGE_VENDOR_ID, ATGE_CHIP_L1_DEV_ID, ATGE_L1_STR, ATGE_CHIP_L1},
360 };
361 
362 /*
363  * Global Debugging flag. Developer level debugging is done only in DEBUG mode.
364  */
365 int	atge_debug = 1;
366 
367 /*
368  * Debugging and error reporting.
369  */
370 void
atge_debug_func(char * fmt,...)371 atge_debug_func(char *fmt, ...)
372 {
373 	va_list	ap;
374 	char	buf[256];
375 
376 	va_start(ap, fmt);
377 	(void) vsnprintf(buf, sizeof (buf), fmt, ap);
378 	va_end(ap);
379 
380 	DTRACE_PROBE1(atge__debug, char *, buf);
381 }
382 
383 static
384 void
atge_message(dev_info_t * dip,int level,char * fmt,va_list ap)385 atge_message(dev_info_t *dip, int level, char *fmt, va_list ap)
386 {
387 	char	buf[256];
388 	char	*p = "!%s%d: %s";
389 	char	*q = "!atge: %s";
390 
391 	(void) vsnprintf(buf, sizeof (buf), fmt, ap);
392 
393 	if (level != CE_NOTE) {
394 		p++;
395 		q++;
396 	}
397 
398 	if (dip) {
399 		cmn_err(level, p,
400 		    ddi_driver_name(dip), ddi_get_instance(dip), buf);
401 	} else {
402 		cmn_err(level, q, buf);
403 	}
404 }
405 
406 void
atge_notice(dev_info_t * dip,char * fmt,...)407 atge_notice(dev_info_t *dip, char *fmt, ...)
408 {
409 	va_list	ap;
410 
411 	va_start(ap, fmt);
412 	(void) atge_message(dip, CE_NOTE, fmt, ap);
413 	va_end(ap);
414 }
415 
416 void
atge_error(dev_info_t * dip,char * fmt,...)417 atge_error(dev_info_t *dip, char *fmt, ...)
418 {
419 	va_list	ap;
420 
421 	va_start(ap, fmt);
422 	(void) atge_message(dip, CE_WARN, fmt, ap);
423 	va_end(ap);
424 }
425 
426 void
atge_mac_config(atge_t * atgep)427 atge_mac_config(atge_t *atgep)
428 {
429 	uint32_t reg;
430 	int speed;
431 	link_duplex_t ld;
432 
433 	/* Re-enable TX/RX MACs */
434 	reg = INL(atgep, ATGE_MAC_CFG);
435 	reg &= ~(ATGE_CFG_FULL_DUPLEX | ATGE_CFG_TX_FC | ATGE_CFG_RX_FC |
436 	    ATGE_CFG_SPEED_MASK);
437 
438 	switch (ATGE_MODEL(atgep)) {
439 	case ATGE_CHIP_L1C:
440 		switch (ATGE_DID(atgep)) {
441 		case ATGE_CHIP_AR8151V2_DEV_ID:
442 		case ATGE_CHIP_AR8151V1_DEV_ID:
443 		case ATGE_CHIP_AR8152V2_DEV_ID:
444 			reg |= ATGE_CFG_HASH_ALG_CRC32 | ATGE_CFG_SPEED_MODE_SW;
445 			break;
446 		}
447 		break;
448 	}
449 
450 	speed = mii_get_speed(atgep->atge_mii);
451 	switch (speed) {
452 	case 10:
453 	case 100:
454 		reg |= ATGE_CFG_SPEED_10_100;
455 		break;
456 	case 1000:
457 		reg |= ATGE_CFG_SPEED_1000;
458 		break;
459 	}
460 
461 	ld = mii_get_duplex(atgep->atge_mii);
462 	if (ld == LINK_DUPLEX_FULL)
463 		reg |= ATGE_CFG_FULL_DUPLEX;
464 
465 	/* Re-enable TX/RX MACs */
466 	switch (ATGE_MODEL(atgep)) {
467 	case ATGE_CHIP_L1E:
468 		reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB | ATGE_CFG_RX_FC;
469 		break;
470 	case ATGE_CHIP_L1:
471 	case ATGE_CHIP_L1C:
472 		reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB;
473 		break;
474 	}
475 
476 	OUTL(atgep, ATGE_MAC_CFG, reg);
477 
478 	switch (ATGE_MODEL(atgep)) {
479 	case ATGE_CHIP_L1E:
480 		reg = ATGE_USECS(ATGE_IM_RX_TIMER_DEFAULT) << IM_TIMER_RX_SHIFT;
481 		reg |= ATGE_USECS(ATGE_IM_TX_TIMER_DEFAULT) <<
482 		    IM_TIMER_TX_SHIFT;
483 		OUTL(atgep, ATGE_IM_TIMER, reg);
484 		break;
485 	case ATGE_CHIP_L1:
486 		break;
487 	case ATGE_CHIP_L1C:
488 		/* Configure interrupt moderation timer. */
489 		reg = ATGE_USECS(atgep->atge_int_rx_mod) << IM_TIMER_RX_SHIFT;
490 		reg |= ATGE_USECS(atgep->atge_int_tx_mod) << IM_TIMER_TX_SHIFT;
491 		OUTL(atgep, ATGE_IM_TIMER, reg);
492 		/*
493 		 * We don't want to automatic interrupt clear as task queue
494 		 * for the interrupt should know interrupt status.
495 		 */
496 		reg = 0;
497 		if (ATGE_USECS(atgep->atge_int_rx_mod) != 0)
498 			reg |= MASTER_IM_RX_TIMER_ENB;
499 		if (ATGE_USECS(atgep->atge_int_tx_mod) != 0)
500 			reg |= MASTER_IM_TX_TIMER_ENB;
501 		OUTL(atgep, ATGE_MASTER_CFG, reg);
502 		break;
503 	}
504 
505 	ATGE_DB(("%s: %s() mac_cfg is : %x",
506 	    atgep->atge_name, __func__, INL(atgep, ATGE_MAC_CFG)));
507 }
508 
509 static void
atge_mii_notify(void * arg,link_state_t link)510 atge_mii_notify(void *arg, link_state_t link)
511 {
512 	atge_t *atgep = arg;
513 
514 	ATGE_DB(("%s: %s() LINK STATUS CHANGED from %x -> %x",
515 	    atgep->atge_name, __func__, atgep->atge_link_state, link));
516 
517 	mac_link_update(atgep->atge_mh, link);
518 
519 	/*
520 	 * Reconfigure MAC if link status is UP now.
521 	 */
522 	mutex_enter(&atgep->atge_tx_lock);
523 	if (link == LINK_STATE_UP) {
524 		atgep->atge_link_state = LINK_STATE_UP;
525 		atge_mac_config(atgep);
526 		atgep->atge_tx_resched = 0;
527 	} else {
528 		atgep->atge_link_state = LINK_STATE_DOWN;
529 		atgep->atge_flags |= ATGE_MII_CHECK;
530 	}
531 
532 	mutex_exit(&atgep->atge_tx_lock);
533 
534 	if (link == LINK_STATE_UP)
535 		mac_tx_update(atgep->atge_mh);
536 }
537 
538 void
atge_tx_reclaim(atge_t * atgep,int end)539 atge_tx_reclaim(atge_t *atgep, int end)
540 {
541 	atge_tx_desc_t  *txd;
542 	atge_ring_t *r = atgep->atge_tx_ring;
543 	uchar_t *c;
544 	int start;
545 
546 	ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
547 	ASSERT(r != NULL);
548 
549 	start = r->r_consumer;
550 
551 	if (start == end)
552 		return;
553 
554 	while (start != end) {
555 		r->r_avail_desc++;
556 		if (r->r_avail_desc > ATGE_TX_RING_CNT) {
557 
558 			atge_error(atgep->atge_dip,
559 			    "Reclaim : TX descriptor error");
560 
561 			if (r->r_avail_desc > (ATGE_TX_RING_CNT + 5)) {
562 				atge_device_stop(atgep);
563 				break;
564 			}
565 		}
566 
567 		c = (uchar_t *)r->r_desc_ring->addr;
568 		c += (sizeof (atge_tx_desc_t) * start);
569 		txd = (atge_tx_desc_t *)c;
570 
571 		/*
572 		 * Clearing TX descriptor helps in debugging some strange
573 		 * problems.
574 		 */
575 		txd->addr = 0;
576 		txd->len = 0;
577 		txd->flags = 0;
578 
579 		ATGE_INC_SLOT(start, ATGE_TX_RING_CNT);
580 	}
581 
582 	atgep->atge_tx_ring->r_consumer = start;
583 
584 	DMA_SYNC(r->r_desc_ring, 0, ATGE_TX_RING_SZ, DDI_DMA_SYNC_FORDEV);
585 }
586 
587 /*
588  * Adds interrupt handler depending upon the type of interrupt supported by
589  * the chip.
590  */
591 static int
atge_add_intr_handler(atge_t * atgep,int intr_type)592 atge_add_intr_handler(atge_t *atgep, int intr_type)
593 {
594 	int err;
595 	int count = 0;
596 	int avail = 0;
597 	int i;
598 	int flag;
599 
600 	if (intr_type != DDI_INTR_TYPE_FIXED) {
601 		err = ddi_intr_get_nintrs(atgep->atge_dip, intr_type, &count);
602 		if (err != DDI_SUCCESS) {
603 			atge_error(atgep->atge_dip,
604 			    "ddi_intr_get_nintrs failed : %d", err);
605 			return (DDI_FAILURE);
606 		}
607 
608 		ATGE_DB(("%s: %s() count : %d",
609 		    atgep->atge_name, __func__, count));
610 
611 		err = ddi_intr_get_navail(atgep->atge_dip, intr_type, &avail);
612 		if (err != DDI_SUCCESS) {
613 			atge_error(atgep->atge_dip,
614 			    "ddi_intr_get_navail failed : %d", err);
615 			return (DDI_FAILURE);
616 		}
617 
618 		if (avail < count) {
619 			atge_error(atgep->atge_dip, "count :%d,"
620 			    " avail : %d", count, avail);
621 		}
622 
623 		flag = DDI_INTR_ALLOC_STRICT;
624 	} else {
625 		/*
626 		 * DDI_INTR_TYPE_FIXED case.
627 		 */
628 		count = 1;
629 		avail = 1;
630 		flag = DDI_INTR_ALLOC_NORMAL;
631 	}
632 
633 	atgep->atge_intr_size = avail * sizeof (ddi_intr_handle_t);
634 	atgep->atge_intr_handle = kmem_zalloc(atgep->atge_intr_size, KM_SLEEP);
635 
636 	ATGE_DB(("%s: %s() avail:%d, count : %d, type : %d",
637 	    atgep->atge_name, __func__, avail, count,
638 	    intr_type));
639 
640 	err = ddi_intr_alloc(atgep->atge_dip, atgep->atge_intr_handle,
641 	    intr_type, 0, avail, &atgep->atge_intr_cnt, flag);
642 
643 	if (err != DDI_SUCCESS) {
644 		atge_error(atgep->atge_dip, "ddi_intr_alloc failed : %d", err);
645 		kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
646 		return (DDI_FAILURE);
647 	}
648 
649 	ATGE_DB(("%s: atge_add_intr_handler() after alloc count"
650 	    " :%d, avail : %d", atgep->atge_name, count, avail));
651 
652 	err = ddi_intr_get_pri(atgep->atge_intr_handle[0],
653 	    &atgep->atge_intr_pri);
654 	if (err != DDI_SUCCESS) {
655 		atge_error(atgep->atge_dip, "ddi_intr_get_pri failed:%d", err);
656 		for (i = 0; i < atgep->atge_intr_cnt; i++) {
657 			(void) ddi_intr_free(atgep->atge_intr_handle[i]);
658 		}
659 		kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
660 
661 		return (DDI_FAILURE);
662 	}
663 
664 	/*
665 	 * Add interrupt handler now.
666 	 */
667 	for (i = 0; i < atgep->atge_intr_cnt; i++) {
668 		switch (ATGE_MODEL(atgep)) {
669 		case ATGE_CHIP_L1E:
670 			err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
671 			    atge_l1e_interrupt, atgep, (caddr_t)(uintptr_t)i);
672 			break;
673 		case ATGE_CHIP_L1:
674 			err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
675 			    atge_l1_interrupt, atgep, (caddr_t)(uintptr_t)i);
676 			break;
677 		case ATGE_CHIP_L1C:
678 			err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
679 			    atge_l1c_interrupt, atgep, (caddr_t)(uintptr_t)i);
680 			break;
681 		}
682 
683 		if (err != DDI_SUCCESS) {
684 			atge_error(atgep->atge_dip,
685 			    "ddi_intr_add_handler failed : %d", err);
686 
687 			(void) ddi_intr_free(atgep->atge_intr_handle[i]);
688 			while (--i >= 0) {
689 				(void) ddi_intr_remove_handler(
690 				    atgep->atge_intr_handle[i]);
691 				(void) ddi_intr_free(
692 				    atgep->atge_intr_handle[i]);
693 			}
694 
695 			kmem_free(atgep->atge_intr_handle,
696 			    atgep->atge_intr_size);
697 
698 			return (DDI_FAILURE);
699 		}
700 	}
701 
702 	err = ddi_intr_get_cap(atgep->atge_intr_handle[0],
703 	    &atgep->atge_intr_cap);
704 
705 	if (err != DDI_SUCCESS) {
706 		atge_error(atgep->atge_dip,
707 		    "ddi_intr_get_cap failed : %d", err);
708 		atge_remove_intr(atgep);
709 		return (DDI_FAILURE);
710 	}
711 
712 	if (intr_type == DDI_INTR_TYPE_FIXED)
713 		atgep->atge_flags |= ATGE_FIXED_TYPE;
714 	else if (intr_type == DDI_INTR_TYPE_MSI)
715 		atgep->atge_flags |= ATGE_MSI_TYPE;
716 	else if (intr_type == DDI_INTR_TYPE_MSIX)
717 		atgep->atge_flags |= ATGE_MSIX_TYPE;
718 
719 	return (DDI_SUCCESS);
720 }
721 
722 void
atge_remove_intr(atge_t * atgep)723 atge_remove_intr(atge_t *atgep)
724 {
725 	int i;
726 	int cap = 0;
727 
728 	if (atgep->atge_intr_handle == NULL)
729 		return;
730 
731 	if (atgep->atge_intr_cap & DDI_INTR_FLAG_BLOCK) {
732 		(void) ddi_intr_block_disable(atgep->atge_intr_handle,
733 		    atgep->atge_intr_cnt);
734 
735 		cap = 1;
736 	}
737 
738 	for (i = 0; i < atgep->atge_intr_cnt; i++) {
739 		if (cap == 0)
740 			(void) ddi_intr_disable(atgep->atge_intr_handle[i]);
741 
742 		(void) ddi_intr_remove_handler(atgep->atge_intr_handle[i]);
743 		(void) ddi_intr_free(atgep->atge_intr_handle[i]);
744 	}
745 
746 	kmem_free(atgep->atge_intr_handle, atgep->atge_intr_size);
747 }
748 
749 int
atge_enable_intrs(atge_t * atgep)750 atge_enable_intrs(atge_t *atgep)
751 {
752 	int err;
753 	int i;
754 
755 	if (atgep->atge_intr_cap & DDI_INTR_FLAG_BLOCK) {
756 		/*
757 		 * Do block enable.
758 		 */
759 		err = ddi_intr_block_enable(atgep->atge_intr_handle,
760 		    atgep->atge_intr_cnt);
761 
762 		if (err != DDI_SUCCESS) {
763 			atge_error(atgep->atge_dip,
764 			    "Failed to block enable intrs %d", err);
765 			err = DDI_FAILURE;
766 		} else {
767 			err = DDI_SUCCESS;
768 		}
769 	} else {
770 		/*
771 		 * Call ddi_intr_enable() for MSI non-block enable.
772 		 */
773 		for (i = 0; i < atgep->atge_intr_cnt; i++) {
774 			err = ddi_intr_enable(atgep->atge_intr_handle[i]);
775 			if (err != DDI_SUCCESS) {
776 				atge_error(atgep->atge_dip,
777 				    "Failed to enable intrs on %d with : %d",
778 				    i, err);
779 				break;
780 			}
781 		}
782 
783 		if (err == DDI_SUCCESS)
784 			err = DDI_SUCCESS;
785 		else
786 			err = DDI_FAILURE;
787 	}
788 
789 	return (err);
790 }
791 
792 /*
793  * Adds interrupt handler depending on the supported interrupt type by the
794  * chip.
795  */
796 static int
atge_add_intr(atge_t * atgep)797 atge_add_intr(atge_t *atgep)
798 {
799 	int	err;
800 
801 	/*
802 	 * Get the supported interrupt types.
803 	 */
804 	err = ddi_intr_get_supported_types(atgep->atge_dip,
805 	    &atgep->atge_intr_types);
806 	if (err != DDI_SUCCESS) {
807 		atge_error(atgep->atge_dip,
808 		    "ddi_intr_get_supported_types failed : %d", err);
809 		return (DDI_FAILURE);
810 	}
811 
812 	ATGE_DB(("%s: ddi_intr_get_supported_types() returned : %d",
813 	    atgep->atge_name, atgep->atge_intr_types));
814 
815 
816 	if (atgep->atge_intr_types & DDI_INTR_TYPE_MSIX) {
817 		err = atge_add_intr_handler(atgep, DDI_INTR_TYPE_MSIX);
818 		if (err == DDI_SUCCESS) {
819 			ATGE_DB(("%s: Using MSIx for interrupt",
820 			    atgep->atge_name));
821 			return (err);
822 		}
823 	}
824 
825 	if (atgep->atge_intr_types & DDI_INTR_TYPE_MSI) {
826 		err = atge_add_intr_handler(atgep, DDI_INTR_TYPE_MSI);
827 		if (err == DDI_SUCCESS) {
828 			ATGE_DB(("%s: Using MSI for interrupt",
829 			    atgep->atge_name));
830 			return (err);
831 		}
832 	}
833 
834 	err = DDI_FAILURE;
835 	if (atgep->atge_intr_types & DDI_INTR_TYPE_FIXED) {
836 		err = atge_add_intr_handler(atgep, DDI_INTR_TYPE_FIXED);
837 		if (err == DDI_SUCCESS) {
838 			ATGE_DB(("%s: Using FIXED type for interrupt",
839 			    atgep->atge_name));
840 			return (err);
841 		}
842 	}
843 
844 	return (err);
845 }
846 
847 int
atge_identify_hardware(atge_t * atgep)848 atge_identify_hardware(atge_t *atgep)
849 {
850 	uint16_t vid, did;
851 	int i;
852 
853 	vid = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_VENID);
854 	did = pci_config_get16(atgep->atge_conf_handle, PCI_CONF_DEVID);
855 
856 	atgep->atge_model = 0;
857 	for (i = 0; i < (sizeof (atge_cards) / sizeof (atge_cards_t)); i++) {
858 		if (atge_cards[i].vendor_id == vid &&
859 		    atge_cards[i].device_id == did) {
860 			atgep->atge_model = atge_cards[i].model;
861 			atgep->atge_vid = vid;
862 			atgep->atge_did = did;
863 			atgep->atge_revid =
864 			    pci_config_get8(atgep->atge_conf_handle,
865 			    PCI_CONF_REVID);
866 			atge_notice(atgep->atge_dip, "PCI-ID pci%x,%x,%x: %s",
867 			    vid, did, atgep->atge_revid,
868 			    atge_cards[i].cardname);
869 			ATGE_DB(("%s: %s : PCI-ID pci%x,%x and model : %d",
870 			    atgep->atge_name, __func__, vid, did,
871 			    atgep->atge_model));
872 
873 			return (DDI_SUCCESS);
874 		}
875 	}
876 
877 	atge_error(atgep->atge_dip, "atge driver is attaching to unknown"
878 	    " pci%x,%x vendor/device-id card", vid, did);
879 
880 	/*
881 	 * Assume it's L1C chip.
882 	 */
883 	atgep->atge_model = ATGE_CHIP_L1C;
884 	atgep->atge_vid = vid;
885 	atgep->atge_did = did;
886 	atgep->atge_revid = pci_config_get8(atgep->atge_conf_handle,
887 	    PCI_CONF_REVID);
888 
889 	/*
890 	 * We will leave the decision to caller.
891 	 */
892 	return (DDI_FAILURE);
893 }
894 
895 int
atge_get_macaddr(atge_t * atgep)896 atge_get_macaddr(atge_t *atgep)
897 {
898 	uint32_t reg;
899 
900 	reg = INL(atgep, ATGE_SPI_CTRL);
901 	if ((reg & SPI_VPD_ENB) != 0) {
902 		/*
903 		 * Get VPD stored in TWSI EEPROM.
904 		 */
905 		reg &= ~SPI_VPD_ENB;
906 		OUTL(atgep, ATGE_SPI_CTRL, reg);
907 
908 		ATGE_DB(("%s: %s called Get VPD", atgep->atge_name, __func__));
909 	}
910 
911 	atgep->atge_ether_addr[5] = INB(atgep, ATGE_PAR0 + 0);
912 	atgep->atge_ether_addr[4] = INB(atgep, ATGE_PAR0 + 1);
913 	atgep->atge_ether_addr[3] = INB(atgep, ATGE_PAR0 + 2);
914 	atgep->atge_ether_addr[2] = INB(atgep, ATGE_PAR0 + 3);
915 	atgep->atge_ether_addr[1] = INB(atgep, ATGE_PAR1 + 0);
916 	atgep->atge_ether_addr[0] = INB(atgep, ATGE_PAR1 + 1);
917 
918 	ATGE_DB(("%s: %s() Station Address - %x:%x:%x:%x:%x:%x",
919 	    atgep->atge_name, __func__,
920 	    atgep->atge_ether_addr[0],
921 	    atgep->atge_ether_addr[1],
922 	    atgep->atge_ether_addr[2],
923 	    atgep->atge_ether_addr[3],
924 	    atgep->atge_ether_addr[4],
925 	    atgep->atge_ether_addr[5]));
926 
927 	bcopy(atgep->atge_ether_addr, atgep->atge_dev_addr, ETHERADDRL);
928 
929 	return (DDI_SUCCESS);
930 }
931 
932 /*
933  * Reset functionality for L1, L1E, and L1C. It's same.
934  */
935 static void
atge_device_reset(atge_t * atgep)936 atge_device_reset(atge_t *atgep)
937 {
938 	switch (ATGE_MODEL(atgep)) {
939 	case ATGE_CHIP_L1E:
940 	case ATGE_CHIP_L1:
941 	case ATGE_CHIP_L1C:
942 		atge_device_reset_l1_l1e(atgep);
943 		break;
944 	}
945 }
946 
947 void
atge_device_reset_l1_l1e(atge_t * atgep)948 atge_device_reset_l1_l1e(atge_t *atgep)
949 {
950 	uint32_t reg;
951 	int t;
952 	switch (ATGE_MODEL(atgep)) {
953 	case ATGE_CHIP_L1C:
954 		OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET | 0x40);
955 		break;
956 	default:
957 		OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET);
958 		break;
959 	}
960 	reg = INL(atgep, ATGE_MASTER_CFG);
961 	for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
962 		drv_usecwait(10);
963 		reg = INL(atgep, ATGE_MASTER_CFG);
964 		if ((reg & MASTER_RESET) == 0)
965 			break;
966 	}
967 
968 	if (t == 0) {
969 		atge_error(atgep->atge_dip, " master reset timeout reg : %x",
970 		    reg);
971 	}
972 
973 	for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
974 		if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
975 			break;
976 
977 		drv_usecwait(10);
978 	}
979 
980 	if (t == 0) {
981 		atge_error(atgep->atge_dip, "device reset timeout reg : %x",
982 		    reg);
983 	}
984 
985 	switch (ATGE_MODEL(atgep)) {
986 	case ATGE_CHIP_L1E:
987 	case ATGE_CHIP_L1:
988 		/*
989 		 * Initialize PCIe module. These values came from FreeBSD and
990 		 * we don't know the meaning of it.
991 		 */
992 		OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
993 		reg = INL(atgep, 0x1008) | 0x8000;
994 		OUTL(atgep, 0x1008, reg);
995 		break;
996 	case ATGE_CHIP_L1C:
997 		break;
998 	}
999 
1000 	/*
1001 	 * Get chip revision.
1002 	 */
1003 	atgep->atge_chip_rev = INL(atgep, ATGE_MASTER_CFG) >>
1004 	    MASTER_CHIP_REV_SHIFT;
1005 
1006 	ATGE_DB(("%s: %s reset successfully rev : %x", atgep->atge_name,
1007 	    __func__, atgep->atge_chip_rev));
1008 }
1009 
1010 /*
1011  * DMA allocation for L1 and L1E is bit different since L1E uses RX pages
1012  * instead of descriptor based RX model.
1013  */
1014 static int
atge_alloc_dma(atge_t * atgep)1015 atge_alloc_dma(atge_t *atgep)
1016 {
1017 	int err = DDI_FAILURE;
1018 
1019 	switch (ATGE_MODEL(atgep)) {
1020 	case ATGE_CHIP_L1E:
1021 		err = atge_l1e_alloc_dma(atgep);
1022 		break;
1023 	case ATGE_CHIP_L1:
1024 		err = atge_l1_alloc_dma(atgep);
1025 		break;
1026 	case ATGE_CHIP_L1C:
1027 		err = atge_l1c_alloc_dma(atgep);
1028 		break;
1029 	}
1030 
1031 	return (err);
1032 }
1033 
1034 static void
atge_free_dma(atge_t * atgep)1035 atge_free_dma(atge_t *atgep)
1036 {
1037 	switch (ATGE_MODEL(atgep)) {
1038 	case ATGE_CHIP_L1E:
1039 		atge_l1e_free_dma(atgep);
1040 		break;
1041 	case ATGE_CHIP_L1:
1042 		atge_l1_free_dma(atgep);
1043 		break;
1044 	case ATGE_CHIP_L1C:
1045 		atge_l1c_free_dma(atgep);
1046 		break;
1047 	}
1048 }
1049 
1050 /*
1051  * Attach entry point in the driver.
1052  */
1053 static int
atge_attach(dev_info_t * devinfo,ddi_attach_cmd_t cmd)1054 atge_attach(dev_info_t *devinfo, ddi_attach_cmd_t cmd)
1055 {
1056 	atge_t	*atgep;
1057 	mac_register_t	*macreg;
1058 	int	instance;
1059 	uint16_t cap_ptr;
1060 	uint16_t burst;
1061 	int err;
1062 	mii_ops_t *mii_ops;
1063 
1064 	instance =  ddi_get_instance(devinfo);
1065 
1066 	switch (cmd) {
1067 	case DDI_RESUME:
1068 		return (atge_resume(devinfo));
1069 
1070 	case DDI_ATTACH:
1071 		ddi_set_driver_private(devinfo, NULL);
1072 		break;
1073 	default:
1074 		return (DDI_FAILURE);
1075 
1076 	}
1077 
1078 	atgep = kmem_zalloc(sizeof (atge_t), KM_SLEEP);
1079 	ddi_set_driver_private(devinfo, atgep);
1080 	atgep->atge_dip = devinfo;
1081 
1082 	/*
1083 	 * Setup name and instance number to be used for debugging and
1084 	 * error reporting.
1085 	 */
1086 	(void) snprintf(atgep->atge_name, sizeof (atgep->atge_name), "%s%d",
1087 	    "atge", instance);
1088 
1089 
1090 	/*
1091 	 * Map PCI config space.
1092 	 */
1093 	err = pci_config_setup(devinfo, &atgep->atge_conf_handle);
1094 	if (err != DDI_SUCCESS) {
1095 		atge_error(devinfo, "pci_config_setup() failed");
1096 		goto fail1;
1097 	}
1098 
1099 	(void) atge_identify_hardware(atgep);
1100 
1101 	/*
1102 	 * Map Device registers.
1103 	 */
1104 	err = ddi_regs_map_setup(devinfo, ATGE_PCI_REG_NUMBER,
1105 	    &atgep->atge_io_regs, 0, 0, &atge_dev_attr, &atgep->atge_io_handle);
1106 	if (err != DDI_SUCCESS) {
1107 		atge_error(devinfo, "ddi_regs_map_setup() failed");
1108 		goto fail2;
1109 	}
1110 
1111 	/*
1112 	 * Add interrupt and its associated handler.
1113 	 */
1114 	err = atge_add_intr(atgep);
1115 	if (err != DDI_SUCCESS) {
1116 		atge_error(devinfo, "Failed to add interrupt handler");
1117 		goto fail3;
1118 	}
1119 
1120 	mutex_init(&atgep->atge_intr_lock, NULL, MUTEX_DRIVER,
1121 	    DDI_INTR_PRI(atgep->atge_intr_pri));
1122 
1123 	mutex_init(&atgep->atge_tx_lock, NULL, MUTEX_DRIVER,
1124 	    DDI_INTR_PRI(atgep->atge_intr_pri));
1125 
1126 	mutex_init(&atgep->atge_rx_lock, NULL, MUTEX_DRIVER,
1127 	    DDI_INTR_PRI(atgep->atge_intr_pri));
1128 
1129 	mutex_init(&atgep->atge_mii_lock, NULL, MUTEX_DRIVER, NULL);
1130 
1131 	/*
1132 	 * Used to lock down MBOX register on L1 chip since RX consumer,
1133 	 * TX producer and RX return ring consumer are shared.
1134 	 */
1135 	mutex_init(&atgep->atge_mbox_lock, NULL, MUTEX_DRIVER,
1136 	    DDI_INTR_PRI(atgep->atge_intr_pri));
1137 
1138 	atgep->atge_link_state = LINK_STATE_DOWN;
1139 	atgep->atge_mtu = ETHERMTU;
1140 
1141 	switch (ATGE_MODEL(atgep)) {
1142 	case ATGE_CHIP_L1E:
1143 		if (atgep->atge_revid > 0xF0) {
1144 			/* L2E Rev. B. AR8114 */
1145 			atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1146 		} else {
1147 			if ((INL(atgep, L1E_PHY_STATUS) &
1148 			    PHY_STATUS_100M) != 0) {
1149 				/* L1E AR8121 */
1150 				atgep->atge_flags |= ATGE_FLAG_JUMBO;
1151 			} else {
1152 				/* L2E Rev. A. AR8113 */
1153 				atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1154 			}
1155 		}
1156 		break;
1157 	case ATGE_CHIP_L1:
1158 		break;
1159 	case ATGE_CHIP_L1C:
1160 		/*
1161 		 * One odd thing is AR8132 uses the same PHY hardware(F1
1162 		 * gigabit PHY) of AR8131. So atphy(4) of AR8132 reports
1163 		 * the PHY supports 1000Mbps but that's not true. The PHY
1164 		 * used in AR8132 can't establish gigabit link even if it
1165 		 * shows the same PHY model/revision number of AR8131.
1166 		 *
1167 		 * It seems that AR813x/AR815x has silicon bug for SMB. In
1168 		 * addition, Atheros said that enabling SMB wouldn't improve
1169 		 * performance. However I think it's bad to access lots of
1170 		 * registers to extract MAC statistics.
1171 		 *
1172 		 * Don't use Tx CMB. It is known to have silicon bug.
1173 		 */
1174 		switch (ATGE_DID(atgep)) {
1175 		case ATGE_CHIP_AR8152V2_DEV_ID:
1176 		case ATGE_CHIP_AR8152V1_DEV_ID:
1177 			atgep->atge_flags |= ATGE_FLAG_APS |
1178 			    ATGE_FLAG_FASTETHER |
1179 			    ATGE_FLAG_ASPM_MON | ATGE_FLAG_JUMBO |
1180 			    ATGE_FLAG_SMB_BUG | ATGE_FLAG_CMB_BUG;
1181 			break;
1182 		case ATGE_CHIP_AR8151V2_DEV_ID:
1183 		case ATGE_CHIP_AR8151V1_DEV_ID:
1184 			atgep->atge_flags |= ATGE_FLAG_APS |
1185 			    ATGE_FLAG_ASPM_MON | ATGE_FLAG_JUMBO |
1186 			    ATGE_FLAG_SMB_BUG | ATGE_FLAG_CMB_BUG;
1187 			break;
1188 		case ATGE_CHIP_L1CF_DEV_ID:
1189 			atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1190 			break;
1191 		case ATGE_CHIP_L1CG_DEV_ID:
1192 			break;
1193 		}
1194 		break;
1195 	}
1196 
1197 	/*
1198 	 * Get DMA parameters from PCIe device control register.
1199 	 */
1200 	err = PCI_CAP_LOCATE(atgep->atge_conf_handle, PCI_CAP_ID_PCI_E,
1201 	    &cap_ptr);
1202 
1203 	if (err == DDI_FAILURE) {
1204 		atgep->atge_dma_rd_burst = DMA_CFG_RD_BURST_128;
1205 		atgep->atge_dma_wr_burst = DMA_CFG_WR_BURST_128;
1206 	} else {
1207 		atgep->atge_flags |= ATGE_FLAG_PCIE;
1208 		burst = pci_config_get16(atgep->atge_conf_handle,
1209 		    cap_ptr + 0x08);
1210 
1211 		/*
1212 		 * Max read request size.
1213 		 */
1214 		atgep->atge_dma_rd_burst = ((burst >> 12) & 0x07) <<
1215 		    DMA_CFG_RD_BURST_SHIFT;
1216 
1217 		/*
1218 		 * Max Payload Size.
1219 		 */
1220 		atgep->atge_dma_wr_burst = ((burst >> 5) & 0x07) <<
1221 		    DMA_CFG_WR_BURST_SHIFT;
1222 
1223 		ATGE_DB(("%s: %s() MRR : %d, MPS : %d",
1224 		    atgep->atge_name, __func__,
1225 		    (128 << ((burst >> 12) & 0x07)),
1226 		    (128 << ((burst >> 5) & 0x07))));
1227 	}
1228 
1229 	/* Clear data link and flow-control protocol error. */
1230 	switch (ATGE_MODEL(atgep)) {
1231 	case ATGE_CHIP_L1E:
1232 		break;
1233 	case ATGE_CHIP_L1:
1234 		break;
1235 	case ATGE_CHIP_L1C:
1236 		OUTL_AND(atgep, ATGE_PEX_UNC_ERR_SEV,
1237 		    ~(PEX_UNC_ERR_SEV_UC | PEX_UNC_ERR_SEV_FCP));
1238 		OUTL_AND(atgep, ATGE_LTSSM_ID_CFG, ~LTSSM_ID_WRO_ENB);
1239 		OUTL_OR(atgep, ATGE_PCIE_PHYMISC, PCIE_PHYMISC_FORCE_RCV_DET);
1240 		break;
1241 	}
1242 
1243 	/*
1244 	 * Allocate DMA resources.
1245 	 */
1246 	err = atge_alloc_dma(atgep);
1247 	if (err != DDI_SUCCESS) {
1248 		atge_error(devinfo, "Failed to allocate DMA resources");
1249 		goto fail4;
1250 	}
1251 
1252 	/*
1253 	 * Get station address.
1254 	 */
1255 	(void) atge_get_macaddr(atgep);
1256 
1257 	/*
1258 	 * Setup MII.
1259 	 */
1260 	switch (ATGE_MODEL(atgep)) {
1261 	case ATGE_CHIP_L1E:
1262 		mii_ops = &atge_l1e_mii_ops;
1263 		break;
1264 	case ATGE_CHIP_L1:
1265 		mii_ops = &atge_l1_mii_ops;
1266 		break;
1267 	case ATGE_CHIP_L1C:
1268 		mii_ops = &atge_l1c_mii_ops;
1269 		break;
1270 	}
1271 
1272 	if ((atgep->atge_mii = mii_alloc(atgep, devinfo,
1273 	    mii_ops)) == NULL) {
1274 		atge_error(devinfo, "mii_alloc() failed");
1275 		goto fail4;
1276 	}
1277 
1278 	/*
1279 	 * Register with MAC layer.
1280 	 */
1281 	if ((macreg = mac_alloc(MAC_VERSION)) == NULL) {
1282 		atge_error(devinfo, "mac_alloc() failed due to version");
1283 		goto fail4;
1284 	}
1285 
1286 	macreg->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
1287 	macreg->m_driver = atgep;
1288 	macreg->m_dip = devinfo;
1289 	macreg->m_instance = instance;
1290 	macreg->m_src_addr = atgep->atge_ether_addr;
1291 	macreg->m_callbacks = &atge_m_callbacks;
1292 	macreg->m_min_sdu = 0;
1293 	macreg->m_max_sdu = atgep->atge_mtu;
1294 	macreg->m_margin = VLAN_TAGSZ;
1295 
1296 	if ((err = mac_register(macreg, &atgep->atge_mh)) != 0) {
1297 		atge_error(devinfo, "mac_register() failed with :%d", err);
1298 		mac_free(macreg);
1299 		goto fail4;
1300 	}
1301 
1302 	mac_free(macreg);
1303 
1304 	ATGE_DB(("%s: %s() driver attached successfully",
1305 	    atgep->atge_name, __func__));
1306 
1307 	atge_device_reset(atgep);
1308 
1309 	atgep->atge_chip_state = ATGE_CHIP_INITIALIZED;
1310 
1311 	/*
1312 	 * At last - enable interrupts.
1313 	 */
1314 	err = atge_enable_intrs(atgep);
1315 	if (err == DDI_FAILURE) {
1316 		goto fail5;
1317 	}
1318 
1319 	/*
1320 	 * Reset the PHY before starting.
1321 	 */
1322 	switch (ATGE_MODEL(atgep)) {
1323 	case ATGE_CHIP_L1E:
1324 		atge_l1e_mii_reset(atgep);
1325 		break;
1326 	case ATGE_CHIP_L1:
1327 		atge_l1_mii_reset(atgep);
1328 		break;
1329 	case ATGE_CHIP_L1C:
1330 		atge_l1c_mii_reset(atgep);
1331 		break;
1332 	}
1333 
1334 	/*
1335 	 * Let the PHY run.
1336 	 */
1337 	mii_start(atgep->atge_mii);
1338 
1339 	return (DDI_SUCCESS);
1340 
1341 fail5:
1342 	(void) mac_unregister(atgep->atge_mh);
1343 	atge_device_stop(atgep);
1344 	mii_stop(atgep->atge_mii);
1345 	mii_free(atgep->atge_mii);
1346 fail4:
1347 	atge_free_dma(atgep);
1348 	mutex_destroy(&atgep->atge_intr_lock);
1349 	mutex_destroy(&atgep->atge_tx_lock);
1350 	mutex_destroy(&atgep->atge_rx_lock);
1351 	atge_remove_intr(atgep);
1352 fail3:
1353 	ddi_regs_map_free(&atgep->atge_io_handle);
1354 fail2:
1355 	pci_config_teardown(&atgep->atge_conf_handle);
1356 fail1:
1357 	kmem_free(atgep, sizeof (atge_t));
1358 	return (DDI_FAILURE);
1359 }
1360 
1361 static int
atge_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)1362 atge_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1363 {
1364 	atge_t	*atgep;
1365 
1366 	atgep = ddi_get_driver_private(dip);
1367 	if (atgep == NULL) {
1368 		atge_error(dip, "No soft state in detach");
1369 		return (DDI_FAILURE);
1370 	}
1371 
1372 	switch (cmd) {
1373 	case DDI_DETACH:
1374 
1375 		/*
1376 		 * First unregister with MAC layer before stopping DMA
1377 		 */
1378 		if (mac_disable(atgep->atge_mh) != DDI_SUCCESS)
1379 			return (DDI_FAILURE);
1380 
1381 		mii_stop(atgep->atge_mii);
1382 
1383 		mutex_enter(&atgep->atge_intr_lock);
1384 		mutex_enter(&atgep->atge_tx_lock);
1385 		atge_device_stop(atgep);
1386 		mutex_exit(&atgep->atge_tx_lock);
1387 		mutex_exit(&atgep->atge_intr_lock);
1388 
1389 		mii_free(atgep->atge_mii);
1390 		atge_free_dma(atgep);
1391 
1392 		ddi_regs_map_free(&atgep->atge_io_handle);
1393 		atge_remove_intr(atgep);
1394 		pci_config_teardown(&atgep->atge_conf_handle);
1395 
1396 		(void) mac_unregister(atgep->atge_mh);
1397 		mutex_destroy(&atgep->atge_intr_lock);
1398 		mutex_destroy(&atgep->atge_tx_lock);
1399 		mutex_destroy(&atgep->atge_rx_lock);
1400 		kmem_free(atgep, sizeof (atge_t));
1401 		ddi_set_driver_private(dip, NULL);
1402 
1403 		return (DDI_SUCCESS);
1404 
1405 	case DDI_SUSPEND:
1406 		ATGE_DB(("%s: %s() is being suspended",
1407 		    atgep->atge_name, __func__));
1408 
1409 		/*
1410 		 * Suspend monitoring MII.
1411 		 */
1412 		mii_suspend(atgep->atge_mii);
1413 
1414 		mutex_enter(&atgep->atge_intr_lock);
1415 		mutex_enter(&atgep->atge_tx_lock);
1416 		atgep->atge_chip_state |= ATGE_CHIP_SUSPENDED;
1417 		atge_device_stop(atgep);
1418 		mutex_exit(&atgep->atge_tx_lock);
1419 		mutex_exit(&atgep->atge_intr_lock);
1420 
1421 		return (DDI_SUCCESS);
1422 
1423 	default:
1424 		return (DDI_FAILURE);
1425 	}
1426 }
1427 
1428 int
atge_alloc_buffers(atge_ring_t * r,size_t rcnt,size_t buflen,int f)1429 atge_alloc_buffers(atge_ring_t *r, size_t rcnt, size_t buflen, int f)
1430 {
1431 	atge_dma_t *dma;
1432 	atge_dma_t **tbl;
1433 	int err = DDI_SUCCESS;
1434 	int i;
1435 
1436 	tbl = kmem_zalloc(rcnt * sizeof (atge_dma_t *), KM_SLEEP);
1437 	r->r_buf_tbl = tbl;
1438 
1439 	for (i = 0; i < rcnt; i++) {
1440 		dma = atge_buf_alloc(r->r_atge, buflen, f);
1441 		if (dma == NULL) {
1442 			err = DDI_FAILURE;
1443 			break;
1444 		}
1445 
1446 		tbl[i] = dma;
1447 	}
1448 
1449 	return (err);
1450 }
1451 
1452 void
atge_free_buffers(atge_ring_t * r,size_t rcnt)1453 atge_free_buffers(atge_ring_t *r, size_t rcnt)
1454 {
1455 	atge_dma_t **tbl;
1456 	int i;
1457 
1458 	if (r == NULL || r->r_buf_tbl == NULL)
1459 		return;
1460 
1461 	tbl = r->r_buf_tbl;
1462 	for (i = 0; i < rcnt; i++)  {
1463 		if (tbl[i] != NULL) {
1464 			atge_buf_free(tbl[i]);
1465 		}
1466 	}
1467 
1468 	kmem_free(tbl, rcnt * sizeof (atge_dma_t *));
1469 }
1470 
1471 atge_dma_t *
atge_alloc_a_dma_blk(atge_t * atgep,ddi_dma_attr_t * attr,int size,int d)1472 atge_alloc_a_dma_blk(atge_t *atgep, ddi_dma_attr_t *attr, int size, int d)
1473 {
1474 	int err;
1475 	atge_dma_t *dma;
1476 
1477 	dma = kmem_zalloc(sizeof (atge_dma_t), KM_SLEEP);
1478 
1479 	err = ddi_dma_alloc_handle(atgep->atge_dip, attr,
1480 	    DDI_DMA_SLEEP, NULL, &dma->hdl);
1481 
1482 	if (err != DDI_SUCCESS) {
1483 		atge_error(atgep->atge_dip, "%s() : failed"
1484 		    " in ddi_dma_alloc_handle() : %d", __func__, err);
1485 		goto fail;
1486 	}
1487 
1488 	err = ddi_dma_mem_alloc(dma->hdl,
1489 	    size, &atge_buf_attr, DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL,
1490 	    &dma->addr, &dma->len, &dma->acchdl);
1491 
1492 	if (err != DDI_SUCCESS) {
1493 		atge_error(atgep->atge_dip, "%s() : failed"
1494 		    " in ddi_dma_mem_alloc() : %d", __func__, err);
1495 		ddi_dma_free_handle(&dma->hdl);
1496 		goto fail;
1497 	}
1498 
1499 	err = ddi_dma_addr_bind_handle(dma->hdl, NULL, dma->addr,
1500 	    dma->len, d | DDI_DMA_CONSISTENT, DDI_DMA_SLEEP,
1501 	    NULL, &dma->cookie, &dma->count);
1502 
1503 	if (err != DDI_SUCCESS) {
1504 		atge_error(atgep->atge_dip, "%s() : failed"
1505 		    " in ddi_dma_addr_bind_handle() : %d", __func__, err);
1506 		ddi_dma_mem_free(&dma->acchdl);
1507 		ddi_dma_free_handle(&dma->hdl);
1508 		goto fail;
1509 	}
1510 
1511 	return (dma);
1512 fail:
1513 	kmem_free(dma, sizeof (atge_dma_t));
1514 	return (NULL);
1515 }
1516 
1517 void
atge_free_a_dma_blk(atge_dma_t * dma)1518 atge_free_a_dma_blk(atge_dma_t *dma)
1519 {
1520 	if (dma != NULL) {
1521 		(void) ddi_dma_unbind_handle(dma->hdl);
1522 		ddi_dma_mem_free(&dma->acchdl);
1523 		ddi_dma_free_handle(&dma->hdl);
1524 		kmem_free(dma, sizeof (atge_dma_t));
1525 	}
1526 }
1527 
1528 atge_dma_t *
atge_buf_alloc(atge_t * atgep,size_t len,int f)1529 atge_buf_alloc(atge_t *atgep, size_t len, int f)
1530 {
1531 	atge_dma_t *dma = NULL;
1532 	int err;
1533 
1534 	dma = kmem_zalloc(sizeof (atge_dma_t), KM_SLEEP);
1535 
1536 	err = ddi_dma_alloc_handle(atgep->atge_dip, &atge_dma_attr_buf,
1537 	    DDI_DMA_SLEEP, NULL, &dma->hdl);
1538 
1539 	if (err != DDI_SUCCESS) {
1540 		atge_error(atgep->atge_dip, "%s() : failed"
1541 		    " in %s() : %d", __func__, err);
1542 		goto fail;
1543 	}
1544 
1545 	err = ddi_dma_mem_alloc(dma->hdl, len, &atge_buf_attr,
1546 	    DDI_DMA_STREAMING, DDI_DMA_SLEEP, NULL, &dma->addr,
1547 	    &dma->len, &dma->acchdl);
1548 
1549 	if (err != DDI_SUCCESS) {
1550 		atge_error(atgep->atge_dip, "%s() : failed"
1551 		    " in %s() : %d", __func__, err);
1552 		ddi_dma_free_handle(&dma->hdl);
1553 		goto fail;
1554 	}
1555 
1556 	err = ddi_dma_addr_bind_handle(dma->hdl, NULL, dma->addr, dma->len,
1557 	    (f | DDI_DMA_CONSISTENT), DDI_DMA_SLEEP, NULL, &dma->cookie,
1558 	    &dma->count);
1559 
1560 	if (err != DDI_SUCCESS) {
1561 		atge_error(atgep->atge_dip, "%s() : failed"
1562 		    " in %s() : %d", __func__, err);
1563 		ddi_dma_mem_free(&dma->acchdl);
1564 		ddi_dma_free_handle(&dma->hdl);
1565 		goto fail;
1566 	}
1567 
1568 	/*
1569 	 * Number of return'ed cookie should be one.
1570 	 */
1571 	ASSERT(dma->count == 1);
1572 
1573 	return (dma);
1574 fail:
1575 	kmem_free(dma, sizeof (atge_dma_t));
1576 	return (NULL);
1577 }
1578 
1579 void
atge_buf_free(atge_dma_t * dma)1580 atge_buf_free(atge_dma_t *dma)
1581 {
1582 	ASSERT(dma != NULL);
1583 
1584 	(void) ddi_dma_unbind_handle(dma->hdl);
1585 	ddi_dma_mem_free(&dma->acchdl);
1586 	ddi_dma_free_handle(&dma->hdl);
1587 	kmem_free(dma, sizeof (atge_dma_t));
1588 }
1589 
1590 static int
atge_resume(dev_info_t * dip)1591 atge_resume(dev_info_t *dip)
1592 {
1593 	atge_t	*atgep;
1594 
1595 	if ((atgep = ddi_get_driver_private(dip)) == NULL) {
1596 		return (DDI_FAILURE);
1597 	}
1598 
1599 	mutex_enter(&atgep->atge_intr_lock);
1600 	mutex_enter(&atgep->atge_tx_lock);
1601 
1602 	atgep->atge_chip_state &= ~ATGE_CHIP_SUSPENDED;
1603 
1604 	if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
1605 		atge_device_restart(atgep);
1606 	} else {
1607 		atge_device_reset(atgep);
1608 	}
1609 
1610 	mutex_exit(&atgep->atge_tx_lock);
1611 	mutex_exit(&atgep->atge_intr_lock);
1612 
1613 	/*
1614 	 * Reset the PHY before resuming MII.
1615 	 */
1616 	switch (ATGE_MODEL(atgep)) {
1617 	case ATGE_CHIP_L1E:
1618 		atge_l1e_mii_reset(atgep);
1619 		break;
1620 	case ATGE_CHIP_L1:
1621 		break;
1622 	case ATGE_CHIP_L1C:
1623 		break;
1624 	}
1625 
1626 	mii_resume(atgep->atge_mii);
1627 
1628 	/* kick-off downstream */
1629 	mac_tx_update(atgep->atge_mh);
1630 
1631 	return (DDI_SUCCESS);
1632 }
1633 
1634 static int
atge_quiesce(dev_info_t * dip)1635 atge_quiesce(dev_info_t *dip)
1636 {
1637 	atge_t	*atgep;
1638 
1639 	if ((atgep = ddi_get_driver_private(dip)) == NULL) {
1640 		return (DDI_FAILURE);
1641 	}
1642 
1643 	atge_device_stop(atgep);
1644 
1645 	return (DDI_SUCCESS);
1646 }
1647 
1648 void
atge_add_multicst(atge_t * atgep,uint8_t * macaddr)1649 atge_add_multicst(atge_t *atgep, uint8_t *macaddr)
1650 {
1651 	uint32_t crc;
1652 	int bit;
1653 
1654 	ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
1655 	ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
1656 
1657 	ATGE_DB(("%s: %s() %x:%x:%x:%x:%x:%x",
1658 	    atgep->atge_name, __func__, macaddr[0], macaddr[1], macaddr[2],
1659 	    macaddr[3], macaddr[4], macaddr[5]));
1660 
1661 	crc = atge_ether_crc(macaddr, ETHERADDRL);
1662 	bit = (crc >> 26);
1663 	atgep->atge_mchash_ref_cnt[bit]++;
1664 	atgep->atge_mchash |= (1ULL << (crc >> 26));
1665 
1666 	ATGE_DB(("%s: %s() mchash :%llx, bit : %d,"
1667 	    " atge_mchash_ref_cnt[bit] :%d",
1668 	    atgep->atge_name, __func__, atgep->atge_mchash, bit,
1669 	    atgep->atge_mchash_ref_cnt[bit]));
1670 }
1671 
1672 void
atge_remove_multicst(atge_t * atgep,uint8_t * macaddr)1673 atge_remove_multicst(atge_t *atgep, uint8_t *macaddr)
1674 {
1675 	uint32_t crc;
1676 	int bit;
1677 
1678 	ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
1679 	ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
1680 
1681 	ATGE_DB(("%s: %s() %x:%x:%x:%x:%x:%x",
1682 	    atgep->atge_name, __func__, macaddr[0], macaddr[1], macaddr[2],
1683 	    macaddr[3], macaddr[4], macaddr[5]));
1684 
1685 	crc = atge_ether_crc(macaddr, ETHERADDRL);
1686 	bit = (crc >> 26);
1687 	atgep->atge_mchash_ref_cnt[bit]--;
1688 	if (atgep->atge_mchash_ref_cnt[bit] == 0)
1689 		atgep->atge_mchash &= ~(1ULL << (crc >> 26));
1690 
1691 	ATGE_DB(("%s: %s() mchash :%llx, bit : %d,"
1692 	    " atge_mchash_ref_cnt[bit] :%d",
1693 	    atgep->atge_name, __func__, atgep->atge_mchash, bit,
1694 	    atgep->atge_mchash_ref_cnt[bit]));
1695 }
1696 
1697 int
atge_m_multicst(void * arg,boolean_t add,const uint8_t * macaddr)1698 atge_m_multicst(void *arg, boolean_t add, const uint8_t *macaddr)
1699 {
1700 	atge_t *atgep = arg;
1701 
1702 	mutex_enter(&atgep->atge_intr_lock);
1703 	mutex_enter(&atgep->atge_tx_lock);
1704 
1705 	if (add) {
1706 		atge_add_multicst(atgep, (uint8_t *)macaddr);
1707 	} else {
1708 		atge_remove_multicst(atgep, (uint8_t *)macaddr);
1709 	}
1710 
1711 	atge_rxfilter(atgep);
1712 
1713 	mutex_exit(&atgep->atge_tx_lock);
1714 	mutex_exit(&atgep->atge_intr_lock);
1715 
1716 	return (0);
1717 }
1718 
1719 int
atge_m_promisc(void * arg,boolean_t on)1720 atge_m_promisc(void *arg, boolean_t on)
1721 {
1722 	atge_t *atgep = arg;
1723 
1724 	mutex_enter(&atgep->atge_intr_lock);
1725 	mutex_enter(&atgep->atge_tx_lock);
1726 
1727 	if (on) {
1728 		atgep->atge_filter_flags |= ATGE_PROMISC;
1729 	} else {
1730 		atgep->atge_filter_flags &= ~ATGE_PROMISC;
1731 	}
1732 
1733 	if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
1734 		atge_rxfilter(atgep);
1735 	}
1736 
1737 	mutex_exit(&atgep->atge_tx_lock);
1738 	mutex_exit(&atgep->atge_intr_lock);
1739 
1740 	return (0);
1741 }
1742 
1743 int
atge_m_unicst(void * arg,const uint8_t * macaddr)1744 atge_m_unicst(void *arg, const uint8_t *macaddr)
1745 {
1746 	atge_t *atgep = arg;
1747 
1748 	mutex_enter(&atgep->atge_intr_lock);
1749 	mutex_enter(&atgep->atge_tx_lock);
1750 	bcopy(macaddr, atgep->atge_ether_addr, ETHERADDRL);
1751 	atge_program_ether(atgep);
1752 	atge_rxfilter(atgep);
1753 	mutex_exit(&atgep->atge_tx_lock);
1754 	mutex_exit(&atgep->atge_intr_lock);
1755 
1756 	return (0);
1757 }
1758 
1759 mblk_t *
atge_m_tx(void * arg,mblk_t * mp)1760 atge_m_tx(void *arg, mblk_t *mp)
1761 {
1762 	atge_t *atgep = arg;
1763 	mblk_t	*nmp;
1764 
1765 	mutex_enter(&atgep->atge_tx_lock);
1766 
1767 	/*
1768 	 * This NIC does not like us to send pkt when link is down.
1769 	 */
1770 	if (!(atgep->atge_link_state & LINK_STATE_UP)) {
1771 		atgep->atge_tx_resched = 1;
1772 
1773 		mutex_exit(&atgep->atge_tx_lock);
1774 		return (mp);
1775 	}
1776 
1777 	/*
1778 	 * Don't send a pkt if chip isn't running or in suspended state.
1779 	 */
1780 	if ((atgep->atge_chip_state & ATGE_CHIP_RUNNING) == 0 ||
1781 	    atgep->atge_chip_state & ATGE_CHIP_SUSPENDED) {
1782 		atgep->atge_carrier_errors++;
1783 		atgep->atge_tx_resched = 1;
1784 
1785 		mutex_exit(&atgep->atge_tx_lock);
1786 		return (mp);
1787 	}
1788 
1789 	while (mp != NULL) {
1790 		nmp = mp->b_next;
1791 		mp->b_next = NULL;
1792 
1793 		if (atge_send_a_packet(atgep, mp) == DDI_FAILURE) {
1794 			mp->b_next = nmp;
1795 			break;
1796 		}
1797 
1798 		mp = nmp;
1799 	}
1800 
1801 	mutex_exit(&atgep->atge_tx_lock);
1802 	return (mp);
1803 }
1804 
1805 int
atge_m_start(void * arg)1806 atge_m_start(void *arg)
1807 {
1808 	atge_t *atgep = arg;
1809 	int started = 0;
1810 
1811 	ASSERT(atgep != NULL);
1812 
1813 
1814 	mii_stop(atgep->atge_mii);
1815 
1816 	mutex_enter(&atgep->atge_intr_lock);
1817 	mutex_enter(&atgep->atge_tx_lock);
1818 
1819 	if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED)) {
1820 		atge_device_restart(atgep);
1821 		started = 1;
1822 	}
1823 
1824 	mutex_exit(&atgep->atge_tx_lock);
1825 	mutex_exit(&atgep->atge_intr_lock);
1826 
1827 	mii_start(atgep->atge_mii);
1828 
1829 	/* kick-off downstream */
1830 	if (started)
1831 		mac_tx_update(atgep->atge_mh);
1832 
1833 	return (0);
1834 }
1835 
1836 void
atge_m_stop(void * arg)1837 atge_m_stop(void *arg)
1838 {
1839 	atge_t *atgep = arg;
1840 
1841 	mii_stop(atgep->atge_mii);
1842 
1843 	/*
1844 	 * Cancel any pending I/O.
1845 	 */
1846 	mutex_enter(&atgep->atge_intr_lock);
1847 	atgep->atge_chip_state &= ~ATGE_CHIP_RUNNING;
1848 	if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED))
1849 		atge_device_stop(atgep);
1850 	mutex_exit(&atgep->atge_intr_lock);
1851 }
1852 
1853 int
atge_m_stat(void * arg,uint_t stat,uint64_t * val)1854 atge_m_stat(void *arg, uint_t stat, uint64_t *val)
1855 {
1856 	atge_t *atgep = arg;
1857 
1858 	if (mii_m_getstat(atgep->atge_mii, stat, val) == 0) {
1859 		return (0);
1860 	}
1861 
1862 	switch (stat) {
1863 	case MAC_STAT_MULTIRCV:
1864 		*val = atgep->atge_multircv;
1865 		break;
1866 
1867 	case MAC_STAT_BRDCSTRCV:
1868 		*val = atgep->atge_brdcstrcv;
1869 		break;
1870 
1871 	case MAC_STAT_MULTIXMT:
1872 		*val = atgep->atge_multixmt;
1873 		break;
1874 
1875 	case MAC_STAT_BRDCSTXMT:
1876 		*val = atgep->atge_brdcstxmt;
1877 		break;
1878 
1879 	case MAC_STAT_IPACKETS:
1880 		*val = atgep->atge_ipackets;
1881 		break;
1882 
1883 	case MAC_STAT_RBYTES:
1884 		*val = atgep->atge_rbytes;
1885 		break;
1886 
1887 	case MAC_STAT_OPACKETS:
1888 		*val = atgep->atge_opackets;
1889 		break;
1890 
1891 	case MAC_STAT_OBYTES:
1892 		*val = atgep->atge_obytes;
1893 		break;
1894 
1895 	case MAC_STAT_NORCVBUF:
1896 		*val = atgep->atge_norcvbuf;
1897 		break;
1898 
1899 	case MAC_STAT_NOXMTBUF:
1900 		*val = 0;
1901 		break;
1902 
1903 	case MAC_STAT_COLLISIONS:
1904 		*val = atgep->atge_collisions;
1905 		break;
1906 
1907 	case MAC_STAT_IERRORS:
1908 		*val = atgep->atge_errrcv;
1909 		break;
1910 
1911 	case MAC_STAT_OERRORS:
1912 		*val = atgep->atge_errxmt;
1913 		break;
1914 
1915 	case ETHER_STAT_ALIGN_ERRORS:
1916 		*val = atgep->atge_align_errors;
1917 		break;
1918 
1919 	case ETHER_STAT_FCS_ERRORS:
1920 		*val = atgep->atge_fcs_errors;
1921 		break;
1922 
1923 	case ETHER_STAT_SQE_ERRORS:
1924 		*val = atgep->atge_sqe_errors;
1925 		break;
1926 
1927 	case ETHER_STAT_DEFER_XMTS:
1928 		*val = atgep->atge_defer_xmts;
1929 		break;
1930 
1931 	case ETHER_STAT_FIRST_COLLISIONS:
1932 		*val = atgep->atge_first_collisions;
1933 		break;
1934 
1935 	case ETHER_STAT_MULTI_COLLISIONS:
1936 		*val = atgep->atge_multi_collisions;
1937 		break;
1938 
1939 	case ETHER_STAT_TX_LATE_COLLISIONS:
1940 		*val = atgep->atge_tx_late_collisions;
1941 		break;
1942 
1943 	case ETHER_STAT_EX_COLLISIONS:
1944 		*val = atgep->atge_ex_collisions;
1945 		break;
1946 
1947 	case ETHER_STAT_MACXMT_ERRORS:
1948 		*val = atgep->atge_macxmt_errors;
1949 		break;
1950 
1951 	case ETHER_STAT_CARRIER_ERRORS:
1952 		*val = atgep->atge_carrier_errors;
1953 		break;
1954 
1955 	case ETHER_STAT_TOOLONG_ERRORS:
1956 		*val = atgep->atge_toolong_errors;
1957 		break;
1958 
1959 	case ETHER_STAT_MACRCV_ERRORS:
1960 		*val = atgep->atge_macrcv_errors;
1961 		break;
1962 
1963 	case MAC_STAT_OVERFLOWS:
1964 		*val = atgep->atge_overflow;
1965 		break;
1966 
1967 	case MAC_STAT_UNDERFLOWS:
1968 		*val = atgep->atge_underflow;
1969 		break;
1970 
1971 	case ETHER_STAT_TOOSHORT_ERRORS:
1972 		*val = atgep->atge_runt;
1973 		break;
1974 
1975 	case ETHER_STAT_JABBER_ERRORS:
1976 		*val = atgep->atge_jabber;
1977 		break;
1978 
1979 	default:
1980 		return (ENOTSUP);
1981 	}
1982 
1983 	return (0);
1984 }
1985 
1986 int
atge_m_getprop(void * arg,const char * name,mac_prop_id_t num,uint_t sz,void * val)1987 atge_m_getprop(void *arg, const char *name, mac_prop_id_t num, uint_t sz,
1988     void *val)
1989 {
1990 	atge_t *atgep = arg;
1991 
1992 	return (mii_m_getprop(atgep->atge_mii, name, num, sz, val));
1993 }
1994 
1995 int
atge_m_setprop(void * arg,const char * name,mac_prop_id_t num,uint_t sz,const void * val)1996 atge_m_setprop(void *arg, const char *name, mac_prop_id_t num, uint_t sz,
1997     const void *val)
1998 {
1999 	atge_t *atgep = arg;
2000 	int r;
2001 
2002 	r = mii_m_setprop(atgep->atge_mii, name, num, sz, val);
2003 
2004 	if (r == 0) {
2005 		mutex_enter(&atgep->atge_intr_lock);
2006 		mutex_enter(&atgep->atge_tx_lock);
2007 
2008 		if (atgep->atge_chip_state & ATGE_CHIP_RUNNING) {
2009 			atge_device_restart(atgep);
2010 		}
2011 
2012 		mutex_exit(&atgep->atge_tx_lock);
2013 		mutex_exit(&atgep->atge_intr_lock);
2014 	}
2015 
2016 	return (r);
2017 }
2018 
2019 static void
atge_m_propinfo(void * arg,const char * name,mac_prop_id_t num,mac_prop_info_handle_t prh)2020 atge_m_propinfo(void *arg, const char *name, mac_prop_id_t num,
2021     mac_prop_info_handle_t prh)
2022 {
2023 	atge_t *atgep = arg;
2024 
2025 	mii_m_propinfo(atgep->atge_mii, name, num, prh);
2026 }
2027 
2028 void
atge_program_ether(atge_t * atgep)2029 atge_program_ether(atge_t *atgep)
2030 {
2031 	ether_addr_t e;
2032 
2033 	/*
2034 	 * Reprogram the Station address.
2035 	 */
2036 	bcopy(atgep->atge_ether_addr, e, ETHERADDRL);
2037 	OUTL(atgep, ATGE_PAR0,
2038 	    ((e[2] << 24) | (e[3] << 16) | (e[4] << 8) | e[5]));
2039 	OUTL(atgep, ATGE_PAR1, (e[0] << 8) | e[1]);
2040 }
2041 
2042 /*
2043  * Device specific operations.
2044  */
2045 void
atge_device_start(atge_t * atgep)2046 atge_device_start(atge_t *atgep)
2047 {
2048 	uint32_t rxf_hi, rxf_lo, rrd_hi, rrd_lo;
2049 	uint32_t reg;
2050 	uint32_t fsize;
2051 
2052 	/*
2053 	 * Reprogram the Station address.
2054 	 */
2055 	atge_program_ether(atgep);
2056 
2057 	switch (ATGE_MODEL(atgep)) {
2058 	case ATGE_CHIP_L1E:
2059 		atge_l1e_program_dma(atgep);
2060 		break;
2061 	case ATGE_CHIP_L1:
2062 		atge_l1_program_dma(atgep);
2063 		break;
2064 	case ATGE_CHIP_L1C:
2065 		atge_l1c_program_dma(atgep);
2066 		break;
2067 	}
2068 
2069 	ATGE_DB(("%s: %s() dma, counters programmed ", atgep->atge_name,
2070 	    __func__));
2071 
2072 	switch (ATGE_MODEL(atgep)) {
2073 	case ATGE_CHIP_L1E:
2074 	case ATGE_CHIP_L1:
2075 		OUTW(atgep, ATGE_INTR_CLR_TIMER, 1*1000/2);
2076 		break;
2077 	case ATGE_CHIP_L1C:
2078 		/*
2079 		 * Disable interrupt re-trigger timer. We don't want automatic
2080 		 * re-triggering of un-ACKed interrupts.
2081 		 */
2082 		OUTL(atgep, ATGE_INTR_RETRIG_TIMER, ATGE_USECS(0));
2083 		/* Configure CMB. */
2084 		OUTL(atgep, ATGE_CMB_TX_TIMER, ATGE_USECS(0));
2085 		/*
2086 		 * Hardware can be configured to issue SMB interrupt based
2087 		 * on programmed interval. Since there is a callout that is
2088 		 * invoked for every hz in driver we use that instead of
2089 		 * relying on periodic SMB interrupt.
2090 		 */
2091 		OUTL(atgep, ATGE_SMB_STAT_TIMER, ATGE_USECS(0));
2092 		/* Clear MAC statistics. */
2093 		atge_l1c_clear_stats(atgep);
2094 		break;
2095 	}
2096 
2097 	/*
2098 	 * Set Maximum frame size but don't let MTU be less than ETHER_MTU.
2099 	 */
2100 	if (atgep->atge_mtu < ETHERMTU)
2101 		atgep->atge_max_frame_size = ETHERMTU;
2102 	else
2103 		atgep->atge_max_frame_size = atgep->atge_mtu;
2104 
2105 	atgep->atge_max_frame_size += sizeof (struct ether_header) +
2106 	    VLAN_TAGSZ + ETHERFCSL;
2107 	OUTL(atgep, ATGE_FRAME_SIZE, atgep->atge_max_frame_size);
2108 
2109 	switch (ATGE_MODEL(atgep)) {
2110 	case ATGE_CHIP_L1E:
2111 		break;
2112 	case ATGE_CHIP_L1:
2113 		break;
2114 	case ATGE_CHIP_L1C:
2115 		/* Disable header split(?) */
2116 		OUTL(atgep, ATGE_HDS_CFG, 0);
2117 		break;
2118 	}
2119 
2120 	/*
2121 	 * Configure IPG/IFG parameters.
2122 	 */
2123 	OUTL(atgep, ATGE_IPG_IFG_CFG,
2124 	    ((IPG_IFG_IPG2_DEFAULT << IPG_IFG_IPG2_SHIFT) & IPG_IFG_IPG2_MASK) |
2125 	    ((IPG_IFG_IPG1_DEFAULT << IPG_IFG_IPG1_SHIFT) & IPG_IFG_IPG1_MASK) |
2126 	    ((IPG_IFG_MIFG_DEFAULT << IPG_IFG_MIFG_SHIFT) & IPG_IFG_MIFG_MASK) |
2127 	    ((IPG_IFG_IPGT_DEFAULT << IPG_IFG_IPGT_SHIFT) & IPG_IFG_IPGT_MASK));
2128 
2129 	/*
2130 	 * Set parameters for half-duplex media.
2131 	 */
2132 	OUTL(atgep, ATGE_HDPX_CFG,
2133 	    ((HDPX_CFG_LCOL_DEFAULT << HDPX_CFG_LCOL_SHIFT) &
2134 	    HDPX_CFG_LCOL_MASK) |
2135 	    ((HDPX_CFG_RETRY_DEFAULT << HDPX_CFG_RETRY_SHIFT) &
2136 	    HDPX_CFG_RETRY_MASK) | HDPX_CFG_EXC_DEF_EN |
2137 	    ((HDPX_CFG_ABEBT_DEFAULT << HDPX_CFG_ABEBT_SHIFT) &
2138 	    HDPX_CFG_ABEBT_MASK) |
2139 	    ((HDPX_CFG_JAMIPG_DEFAULT << HDPX_CFG_JAMIPG_SHIFT) &
2140 	    HDPX_CFG_JAMIPG_MASK));
2141 
2142 	/*
2143 	 * Configure jumbo frame.
2144 	 */
2145 	switch (ATGE_MODEL(atgep)) {
2146 	case ATGE_CHIP_L1E:
2147 		if (atgep->atge_flags & ATGE_FLAG_JUMBO) {
2148 
2149 			if (atgep->atge_mtu < ETHERMTU)
2150 				reg = atgep->atge_max_frame_size;
2151 			else if (atgep->atge_mtu < 6 * 1024)
2152 				reg = (atgep->atge_max_frame_size * 2) / 3;
2153 			else
2154 				reg = atgep->atge_max_frame_size / 2;
2155 
2156 			OUTL(atgep, L1E_TX_JUMBO_THRESH,
2157 			    ROUNDUP(reg, TX_JUMBO_THRESH_UNIT) >>
2158 			    TX_JUMBO_THRESH_UNIT_SHIFT);
2159 		}
2160 		break;
2161 	case ATGE_CHIP_L1:
2162 		fsize = ROUNDUP(atgep->atge_max_frame_size, sizeof (uint64_t));
2163 		OUTL(atgep, ATGE_RXQ_JUMBO_CFG,
2164 		    (((fsize / sizeof (uint64_t)) <<
2165 		    RXQ_JUMBO_CFG_SZ_THRESH_SHIFT) &
2166 		    RXQ_JUMBO_CFG_SZ_THRESH_MASK) |
2167 		    ((RXQ_JUMBO_CFG_LKAH_DEFAULT <<
2168 		    RXQ_JUMBO_CFG_LKAH_SHIFT) & RXQ_JUMBO_CFG_LKAH_MASK) |
2169 		    ((ATGE_USECS(8) << RXQ_JUMBO_CFG_RRD_TIMER_SHIFT) &
2170 		    RXQ_JUMBO_CFG_RRD_TIMER_MASK));
2171 		break;
2172 	case ATGE_CHIP_L1C:
2173 		break;
2174 	}
2175 
2176 	/*
2177 	 * Configure flow-control parameters.
2178 	 */
2179 	switch (ATGE_MODEL(atgep)) {
2180 	case ATGE_CHIP_L1E:
2181 	case ATGE_CHIP_L1:
2182 		if ((atgep->atge_flags & ATGE_FLAG_PCIE) != 0) {
2183 		/*
2184 		 * Some hardware version require this magic.
2185 		 */
2186 		OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
2187 		reg = INL(atgep, 0x1008);
2188 		OUTL(atgep, 0x1008, reg | 0x8000);
2189 		}
2190 		break;
2191 	case ATGE_CHIP_L1C:
2192 		break;
2193 	}
2194 
2195 	/*
2196 	 * These are all magic parameters which came from FreeBSD.
2197 	 */
2198 	switch (ATGE_MODEL(atgep)) {
2199 	case ATGE_CHIP_L1E:
2200 		reg = INL(atgep, L1E_SRAM_RX_FIFO_LEN);
2201 		rxf_hi = (reg * 4) / 5;
2202 		rxf_lo = reg/ 5;
2203 
2204 		OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2205 		    ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
2206 		    RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
2207 		    ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
2208 		    RXQ_FIFO_PAUSE_THRESH_HI_MASK));
2209 		break;
2210 	case ATGE_CHIP_L1:
2211 		switch (atgep->atge_chip_rev) {
2212 		case 0x8001:
2213 		case 0x9001:
2214 		case 0x9002:
2215 		case 0x9003:
2216 			rxf_hi = L1_RX_RING_CNT / 16;
2217 			rxf_lo = (L1_RX_RING_CNT * 7) / 8;
2218 			rrd_hi = (L1_RR_RING_CNT * 7) / 8;
2219 			rrd_lo = L1_RR_RING_CNT / 16;
2220 			break;
2221 		default:
2222 			reg = INL(atgep, L1_SRAM_RX_FIFO_LEN);
2223 			rxf_lo = reg / 16;
2224 			if (rxf_lo > 192)
2225 				rxf_lo = 192;
2226 			rxf_hi = (reg * 7) / 8;
2227 			if (rxf_hi < rxf_lo)
2228 				rxf_hi = rxf_lo + 16;
2229 			reg = INL(atgep, L1_SRAM_RRD_LEN);
2230 			rrd_lo = reg / 8;
2231 			rrd_hi = (reg * 7) / 8;
2232 			if (rrd_lo > 2)
2233 				rrd_lo = 2;
2234 			if (rrd_hi < rrd_lo)
2235 				rrd_hi = rrd_lo + 3;
2236 			break;
2237 		}
2238 
2239 		OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2240 		    ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
2241 		    RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
2242 		    ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
2243 		    RXQ_FIFO_PAUSE_THRESH_HI_MASK));
2244 
2245 		OUTL(atgep, L1_RXQ_RRD_PAUSE_THRESH,
2246 		    ((rrd_lo << RXQ_RRD_PAUSE_THRESH_LO_SHIFT) &
2247 		    RXQ_RRD_PAUSE_THRESH_LO_MASK) |
2248 		    ((rrd_hi << RXQ_RRD_PAUSE_THRESH_HI_SHIFT) &
2249 		    RXQ_RRD_PAUSE_THRESH_HI_MASK));
2250 		break;
2251 	case ATGE_CHIP_L1C:
2252 		switch (ATGE_DID(atgep)) {
2253 		case ATGE_CHIP_AR8151V2_DEV_ID:
2254 		case ATGE_CHIP_AR8152V1_DEV_ID:
2255 			OUTL(atgep, ATGE_SERDES_LOCK,
2256 			    INL(atgep, ATGE_SERDES_LOCK) |
2257 			    SERDES_MAC_CLK_SLOWDOWN |
2258 			    SERDES_PHY_CLK_SLOWDOWN);
2259 			break;
2260 		case ATGE_CHIP_L1CG_DEV_ID:
2261 		case ATGE_CHIP_L1CF_DEV_ID:
2262 			/*
2263 			 * Configure flow control parameters.
2264 			 * XON	: 80% of Rx FIFO
2265 			 * XOFF : 30% of Rx FIFO
2266 			 */
2267 			reg = INL(atgep, L1C_SRAM_RX_FIFO_LEN);
2268 			rxf_hi = (reg * 8) / 10;
2269 			rxf_lo = (reg * 3) / 10;
2270 
2271 			OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
2272 			    ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
2273 			    RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
2274 			    ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
2275 			    RXQ_FIFO_PAUSE_THRESH_HI_MASK));
2276 			break;
2277 		}
2278 		break;
2279 	}
2280 
2281 	switch (ATGE_MODEL(atgep)) {
2282 	case ATGE_CHIP_L1E:
2283 		/* Configure RxQ. */
2284 		reg = RXQ_CFG_ALIGN_32 | RXQ_CFG_CUT_THROUGH_ENB |
2285 		    RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB;
2286 		OUTL(atgep, ATGE_RXQ_CFG, reg);
2287 		/*
2288 		 * Configure TxQ.
2289 		 */
2290 		reg = (128 <<
2291 		    (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
2292 		    TXQ_CFG_TX_FIFO_BURST_SHIFT;
2293 
2294 		reg |= (TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
2295 		    TXQ_CFG_TPD_BURST_MASK;
2296 
2297 		reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB;
2298 
2299 		OUTL(atgep, ATGE_TXQ_CFG, reg);
2300 		/* Disable RSS. */
2301 		OUTL(atgep, L1E_RSS_IDT_TABLE0, 0);
2302 		OUTL(atgep, L1E_RSS_CPU, 0);
2303 		/*
2304 		 * Configure DMA parameters.
2305 		 */
2306 		/*
2307 		 * Don't use Tx CMB. It is known to cause RRS update failure
2308 		 * under certain circumstances. Typical phenomenon of the
2309 		 * issue would be unexpected sequence number encountered in
2310 		 * Rx handler. Hence we don't set DMA_CFG_TXCMB_ENB.
2311 		 */
2312 		OUTL(atgep, ATGE_DMA_CFG,
2313 		    DMA_CFG_OUT_ORDER | DMA_CFG_RD_REQ_PRI | DMA_CFG_RCB_64 |
2314 		    atgep->atge_dma_rd_burst | atgep->atge_dma_wr_burst |
2315 		    DMA_CFG_RXCMB_ENB |
2316 		    ((DMA_CFG_RD_DELAY_CNT_DEFAULT <<
2317 		    DMA_CFG_RD_DELAY_CNT_SHIFT) & DMA_CFG_RD_DELAY_CNT_MASK) |
2318 		    ((DMA_CFG_WR_DELAY_CNT_DEFAULT <<
2319 		    DMA_CFG_WR_DELAY_CNT_SHIFT) & DMA_CFG_WR_DELAY_CNT_MASK));
2320 		/*
2321 		 * Enable CMB/SMB timer.
2322 		 */
2323 		OUTL(atgep, L1E_SMB_STAT_TIMER, 100000);
2324 		atge_l1e_clear_stats(atgep);
2325 		break;
2326 	case ATGE_CHIP_L1:
2327 		/* Configure RxQ. */
2328 		reg =
2329 		    ((RXQ_CFG_RD_BURST_DEFAULT << RXQ_CFG_RD_BURST_SHIFT) &
2330 		    RXQ_CFG_RD_BURST_MASK) |
2331 		    ((RXQ_CFG_RRD_BURST_THRESH_DEFAULT <<
2332 		    RXQ_CFG_RRD_BURST_THRESH_SHIFT) &
2333 		    RXQ_CFG_RRD_BURST_THRESH_MASK) |
2334 		    ((RXQ_CFG_RD_PREF_MIN_IPG_DEFAULT <<
2335 		    RXQ_CFG_RD_PREF_MIN_IPG_SHIFT) &
2336 		    RXQ_CFG_RD_PREF_MIN_IPG_MASK) |
2337 		    RXQ_CFG_CUT_THROUGH_ENB | RXQ_CFG_ENB;
2338 		OUTL(atgep, ATGE_RXQ_CFG, reg);
2339 		/*
2340 		 * Configure TxQ.
2341 		 */
2342 		reg =
2343 		    (((TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
2344 		    TXQ_CFG_TPD_BURST_MASK) |
2345 		    ((TXQ_CFG_TX_FIFO_BURST_DEFAULT <<
2346 		    TXQ_CFG_TX_FIFO_BURST_SHIFT) &
2347 		    TXQ_CFG_TX_FIFO_BURST_MASK) |
2348 		    ((TXQ_CFG_TPD_FETCH_DEFAULT <<
2349 		    TXQ_CFG_TPD_FETCH_THRESH_SHIFT) &
2350 		    TXQ_CFG_TPD_FETCH_THRESH_MASK) |
2351 		    TXQ_CFG_ENB);
2352 		OUTL(atgep, ATGE_TXQ_CFG, reg);
2353 		/* Jumbo frames */
2354 		OUTL(atgep, L1_TX_JUMBO_TPD_TH_IPG,
2355 		    (((fsize / sizeof (uint64_t) << TX_JUMBO_TPD_TH_SHIFT)) &
2356 		    TX_JUMBO_TPD_TH_MASK) |
2357 		    ((TX_JUMBO_TPD_IPG_DEFAULT << TX_JUMBO_TPD_IPG_SHIFT) &
2358 		    TX_JUMBO_TPD_IPG_MASK));
2359 		/*
2360 		 * Configure DMA parameters.
2361 		 */
2362 		OUTL(atgep, ATGE_DMA_CFG,
2363 		    DMA_CFG_ENH_ORDER | DMA_CFG_RCB_64 |
2364 		    atgep->atge_dma_rd_burst | DMA_CFG_RD_ENB |
2365 		    atgep->atge_dma_wr_burst | DMA_CFG_WR_ENB);
2366 
2367 		/* Configure CMB DMA write threshold. */
2368 		OUTL(atgep, L1_CMB_WR_THRESH,
2369 		    ((CMB_WR_THRESH_RRD_DEFAULT << CMB_WR_THRESH_RRD_SHIFT) &
2370 		    CMB_WR_THRESH_RRD_MASK) |
2371 		    ((CMB_WR_THRESH_TPD_DEFAULT << CMB_WR_THRESH_TPD_SHIFT) &
2372 		    CMB_WR_THRESH_TPD_MASK));
2373 		/*
2374 		 * Enable CMB/SMB timer.
2375 		 */
2376 		/* Set CMB/SMB timer and enable them. */
2377 		OUTL(atgep, L1_CMB_WR_TIMER,
2378 		    ((ATGE_USECS(2) << CMB_WR_TIMER_TX_SHIFT) &
2379 		    CMB_WR_TIMER_TX_MASK) |
2380 		    ((ATGE_USECS(2) << CMB_WR_TIMER_RX_SHIFT) &
2381 		    CMB_WR_TIMER_RX_MASK));
2382 
2383 		/* Request SMB updates for every seconds. */
2384 		OUTL(atgep, L1_SMB_TIMER, ATGE_USECS(1000 * 1000));
2385 		OUTL(atgep, L1_CSMB_CTRL,
2386 		    CSMB_CTRL_SMB_ENB | CSMB_CTRL_CMB_ENB);
2387 		break;
2388 	case ATGE_CHIP_L1C:
2389 		/* Configure RxQ. */
2390 		reg =
2391 		    RXQ_CFG_RD_BURST_DEFAULT << L1C_RXQ_CFG_RD_BURST_SHIFT |
2392 		    RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB;
2393 		if ((atgep->atge_flags & ATGE_FLAG_ASPM_MON) != 0)
2394 			reg |= RXQ_CFG_ASPM_THROUGHPUT_LIMIT_1M;
2395 		OUTL(atgep, ATGE_RXQ_CFG, reg);
2396 		/*
2397 		 * Configure TxQ.
2398 		 */
2399 		reg = (128 <<
2400 		    (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
2401 		    TXQ_CFG_TX_FIFO_BURST_SHIFT;
2402 
2403 		switch (ATGE_DID(atgep)) {
2404 		case ATGE_CHIP_AR8152V2_DEV_ID:
2405 		case ATGE_CHIP_AR8152V1_DEV_ID:
2406 			reg >>= 1;
2407 			break;
2408 		}
2409 
2410 		reg |= (L1C_TXQ_CFG_TPD_BURST_DEFAULT <<
2411 		    TXQ_CFG_TPD_BURST_SHIFT) & TXQ_CFG_TPD_BURST_MASK;
2412 
2413 		reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB;
2414 
2415 		OUTL(atgep, L1C_TXQ_CFG, reg);
2416 		/* Disable RSS until I understand L1C/L2C's RSS logic. */
2417 		OUTL(atgep, L1C_RSS_IDT_TABLE0, 0xe4e4e4e4);
2418 		OUTL(atgep, L1C_RSS_CPU, 0);
2419 		/*
2420 		 * Configure DMA parameters.
2421 		 */
2422 		OUTL(atgep, ATGE_DMA_CFG,
2423 		    DMA_CFG_SMB_DIS |
2424 		    DMA_CFG_OUT_ORDER | DMA_CFG_RD_REQ_PRI | DMA_CFG_RCB_64 |
2425 		    DMA_CFG_RD_DELAY_CNT_DEFAULT << DMA_CFG_RD_DELAY_CNT_SHIFT |
2426 		    DMA_CFG_WR_DELAY_CNT_DEFAULT << DMA_CFG_WR_DELAY_CNT_SHIFT |
2427 
2428 		    atgep->atge_dma_rd_burst | DMA_CFG_RD_ENB |
2429 		    atgep->atge_dma_wr_burst | DMA_CFG_WR_ENB);
2430 		/* Configure CMB DMA write threshold not required. */
2431 		/* Set CMB/SMB timer and enable them not required. */
2432 		break;
2433 	}
2434 
2435 	/*
2436 	 * Disable all WOL bits as WOL can interfere normal Rx
2437 	 * operation.
2438 	 */
2439 	OUTL(atgep, ATGE_WOL_CFG, 0);
2440 
2441 	/*
2442 	 * Configure Tx/Rx MACs.
2443 	 *  - Auto-padding for short frames.
2444 	 *  - Enable CRC generation.
2445 	 *
2446 	 *  Start with full-duplex/1000Mbps media. Actual reconfiguration
2447 	 *  of MAC is followed after link establishment.
2448 	 */
2449 	reg = (ATGE_CFG_TX_CRC_ENB | ATGE_CFG_TX_AUTO_PAD |
2450 	    ATGE_CFG_FULL_DUPLEX |
2451 	    ((ATGE_CFG_PREAMBLE_DEFAULT << ATGE_CFG_PREAMBLE_SHIFT) &
2452 	    ATGE_CFG_PREAMBLE_MASK));
2453 
2454 	/*
2455 	 *  AR813x/AR815x always does checksum computation regardless
2456 	 *  of MAC_CFG_RXCSUM_ENB bit. Also the controller is known to
2457 	 *  have bug in protocol field in Rx return structure so
2458 	 *  these controllers can't handle fragmented frames. Disable
2459 	 *  Rx checksum offloading until there is a newer controller
2460 	 *  that has sane implementation.
2461 	 */
2462 	switch (ATGE_DID(atgep)) {
2463 	case ATGE_CHIP_AR8151V2_DEV_ID:
2464 	case ATGE_CHIP_AR8151V1_DEV_ID:
2465 	case ATGE_CHIP_AR8152V2_DEV_ID:
2466 		reg |= ATGE_CFG_HASH_ALG_CRC32 | ATGE_CFG_SPEED_MODE_SW;
2467 		break;
2468 	}
2469 
2470 	if ((atgep->atge_flags & ATGE_FLAG_FASTETHER) != 0) {
2471 		reg |= ATGE_CFG_SPEED_10_100;
2472 		ATGE_DB(("%s: %s() Fast Ethernet", atgep->atge_name, __func__));
2473 	} else {
2474 		reg |= ATGE_CFG_SPEED_1000;
2475 		ATGE_DB(("%s: %s() 1G speed", atgep->atge_name, __func__));
2476 	}
2477 	switch (ATGE_MODEL(atgep)) {
2478 	case ATGE_CHIP_L1C:
2479 		reg |= L1C_CFG_SINGLE_PAUSE_ENB;
2480 		break;
2481 	}
2482 
2483 	OUTL(atgep, ATGE_MAC_CFG, reg);
2484 
2485 	atgep->atge_chip_state |= ATGE_CHIP_RUNNING;
2486 
2487 	/*
2488 	 * Set up the receive filter.
2489 	 */
2490 	atge_rxfilter(atgep);
2491 
2492 	/*
2493 	 * Acknowledge all pending interrupts and clear it.
2494 	 */
2495 	switch (ATGE_MODEL(atgep)) {
2496 	case ATGE_CHIP_L1E:
2497 		OUTL(atgep, ATGE_INTR_MASK, L1E_INTRS);
2498 		OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2499 		OUTL(atgep, ATGE_INTR_STATUS, 0);
2500 		break;
2501 	case ATGE_CHIP_L1:
2502 	case ATGE_CHIP_L1C:
2503 		OUTL(atgep, ATGE_INTR_STATUS, 0);
2504 		OUTL(atgep, ATGE_INTR_MASK, atgep->atge_intrs);
2505 		break;
2506 	}
2507 
2508 	atge_mac_config(atgep);
2509 
2510 	ATGE_DB(("%s: %s() device started", atgep->atge_name, __func__));
2511 }
2512 
2513 /*
2514  * Generic functions.
2515  */
2516 
2517 #define	CRC32_POLY_BE   0x04c11db7
2518 uint32_t
atge_ether_crc(const uint8_t * addr,int len)2519 atge_ether_crc(const uint8_t *addr, int len)
2520 {
2521 	int idx;
2522 	int bit;
2523 	uint_t data;
2524 	uint32_t crc;
2525 
2526 	crc = 0xffffffff;
2527 	for (idx = 0; idx < len; idx++) {
2528 		for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1) {
2529 			crc = (crc << 1)
2530 			    ^ ((((crc >> 31) ^ data) & 1) ? CRC32_POLY_BE : 0);
2531 		}
2532 	}
2533 
2534 	return (crc);
2535 }
2536 
2537 
2538 /*
2539  * Programs RX filter. We use a link-list to keep track of all multicast
2540  * addressess.
2541  */
2542 void
atge_rxfilter(atge_t * atgep)2543 atge_rxfilter(atge_t *atgep)
2544 {
2545 	uint32_t rxcfg;
2546 	uint64_t mchash;
2547 
2548 	rxcfg = INL(atgep, ATGE_MAC_CFG);
2549 	rxcfg &= ~(ATGE_CFG_ALLMULTI | ATGE_CFG_PROMISC);
2550 
2551 	/*
2552 	 * Accept broadcast frames.
2553 	 */
2554 	rxcfg |= ATGE_CFG_BCAST;
2555 
2556 	/*
2557 	 * We don't use Hardware VLAN tagging.
2558 	 */
2559 	rxcfg &= ~ATGE_CFG_VLAN_TAG_STRIP;
2560 
2561 	if (atgep->atge_filter_flags & (ATGE_PROMISC | ATGE_ALL_MULTICST)) {
2562 		mchash = ~0ULL;
2563 
2564 		if (atgep->atge_filter_flags & ATGE_PROMISC)
2565 			rxcfg |= ATGE_CFG_PROMISC;
2566 
2567 		if (atgep->atge_filter_flags & ATGE_ALL_MULTICST)
2568 			rxcfg |= ATGE_CFG_ALLMULTI;
2569 	} else {
2570 		mchash = atgep->atge_mchash;
2571 	}
2572 
2573 	atge_program_ether(atgep);
2574 
2575 	OUTL(atgep, ATGE_MAR0, (uint32_t)mchash);
2576 	OUTL(atgep, ATGE_MAR1, (uint32_t)(mchash >> 32));
2577 	OUTL(atgep, ATGE_MAC_CFG, rxcfg);
2578 
2579 	ATGE_DB(("%s: %s() mac_cfg is : %x, mchash : %llx",
2580 	    atgep->atge_name, __func__, rxcfg, mchash));
2581 }
2582 
2583 void
atge_device_stop(atge_t * atgep)2584 atge_device_stop(atge_t *atgep)
2585 {
2586 	uint32_t reg;
2587 	int t;
2588 
2589 	/*
2590 	 * If the chip is being suspended, then don't touch the state. Caller
2591 	 * will take care of setting the correct state.
2592 	 */
2593 	if (!(atgep->atge_chip_state & ATGE_CHIP_SUSPENDED)) {
2594 		atgep->atge_chip_state |= ATGE_CHIP_STOPPED;
2595 		atgep->atge_chip_state &= ~ATGE_CHIP_RUNNING;
2596 	}
2597 
2598 	/*
2599 	 * Collect stats for L1E. L1 chip's stats are collected by interrupt.
2600 	 */
2601 	switch (ATGE_MODEL(atgep)) {
2602 	case ATGE_CHIP_L1E:
2603 		atge_l1e_gather_stats(atgep);
2604 		break;
2605 	case ATGE_CHIP_L1:
2606 	case ATGE_CHIP_L1C:
2607 		break;
2608 	}
2609 
2610 	/*
2611 	 * Disable interrupts.
2612 	 */
2613 	atge_disable_intrs(atgep);
2614 
2615 	switch (ATGE_MODEL(atgep)) {
2616 	case ATGE_CHIP_L1E:
2617 		/* Clear CTRL not required. */
2618 		/* Stop DMA Engine not required. */
2619 		/*
2620 		 * Disable queue processing.
2621 		 */
2622 		/* Stop TxQ */
2623 		reg = INL(atgep, ATGE_TXQ_CFG);
2624 		reg = reg & ~TXQ_CFG_ENB;
2625 		OUTL(atgep, ATGE_TXQ_CFG, reg);
2626 		/* Stop RxQ */
2627 		reg = INL(atgep, ATGE_RXQ_CFG);
2628 		reg = reg & ~RXQ_CFG_ENB;
2629 		OUTL(atgep, ATGE_RXQ_CFG, reg);
2630 		/* Stop DMA */
2631 		reg = INL(atgep, ATGE_DMA_CFG);
2632 		reg = reg & ~(DMA_CFG_TXCMB_ENB | DMA_CFG_RXCMB_ENB);
2633 		OUTL(atgep, ATGE_DMA_CFG, reg);
2634 		drv_usecwait(1000);
2635 		atge_l1e_stop_mac(atgep);
2636 		OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2637 		break;
2638 	case ATGE_CHIP_L1:
2639 		/* Clear CTRL. */
2640 		OUTL(atgep, L1_CSMB_CTRL, 0);
2641 		/* Stop DMA Engine */
2642 		atge_l1_stop_tx_mac(atgep);
2643 		atge_l1_stop_rx_mac(atgep);
2644 		reg = INL(atgep, ATGE_DMA_CFG);
2645 		reg &= ~(DMA_CFG_RD_ENB | DMA_CFG_WR_ENB);
2646 		OUTL(atgep, ATGE_DMA_CFG, reg);
2647 		/*
2648 		 * Disable queue processing.
2649 		 */
2650 		/* Stop TxQ */
2651 		reg = INL(atgep, ATGE_TXQ_CFG);
2652 		reg = reg & ~TXQ_CFG_ENB;
2653 		OUTL(atgep, ATGE_TXQ_CFG, reg);
2654 		/* Stop RxQ */
2655 		reg = INL(atgep, ATGE_RXQ_CFG);
2656 		reg = reg & ~RXQ_CFG_ENB;
2657 		OUTL(atgep, ATGE_RXQ_CFG, reg);
2658 		break;
2659 	case ATGE_CHIP_L1C:
2660 		/* Clear CTRL not required. */
2661 		/* Stop DMA Engine */
2662 		atge_l1c_stop_tx_mac(atgep);
2663 		atge_l1c_stop_rx_mac(atgep);
2664 		reg = INL(atgep, ATGE_DMA_CFG);
2665 		reg &= ~(DMA_CFG_RD_ENB | DMA_CFG_WR_ENB);
2666 		OUTL(atgep, ATGE_DMA_CFG, reg);
2667 		/*
2668 		 * Disable queue processing.
2669 		 */
2670 		/* Stop TxQ */
2671 		reg = INL(atgep, L1C_TXQ_CFG);
2672 		reg = reg & ~TXQ_CFG_ENB;
2673 		OUTL(atgep, L1C_TXQ_CFG, reg);
2674 		/* Stop RxQ */
2675 		reg = INL(atgep, ATGE_RXQ_CFG);
2676 		reg = reg & ~RXQ_CFG_ENB;
2677 		OUTL(atgep, ATGE_RXQ_CFG, reg);
2678 		break;
2679 	}
2680 
2681 	for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
2682 		if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
2683 			break;
2684 		drv_usecwait(10);
2685 	}
2686 
2687 	if (t == 0) {
2688 		atge_error(atgep->atge_dip, "%s() stopping TX/RX MAC timeout",
2689 		    __func__);
2690 	}
2691 }
2692 
2693 void
atge_disable_intrs(atge_t * atgep)2694 atge_disable_intrs(atge_t *atgep)
2695 {
2696 	OUTL(atgep, ATGE_INTR_MASK, 0);
2697 	OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2698 }
2699 
2700 void
atge_device_init(atge_t * atgep)2701 atge_device_init(atge_t *atgep)
2702 {
2703 	switch (ATGE_MODEL(atgep)) {
2704 	case ATGE_CHIP_L1E:
2705 		atgep->atge_intrs = L1E_INTRS;
2706 		atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2707 
2708 		atge_l1e_init_tx_ring(atgep);
2709 		atge_l1e_init_rx_pages(atgep);
2710 		break;
2711 	case ATGE_CHIP_L1:
2712 		atgep->atge_intrs = L1_INTRS | INTR_GPHY | INTR_PHY_LINK_DOWN |
2713 		    INTR_LINK_CHG;
2714 		atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2715 
2716 		atge_l1_init_tx_ring(atgep);
2717 		atge_l1_init_rx_ring(atgep);
2718 		atge_l1_init_rr_ring(atgep);
2719 		atge_l1_init_cmb(atgep);
2720 		atge_l1_init_smb(atgep);
2721 		break;
2722 	case ATGE_CHIP_L1C:
2723 		atgep->atge_intrs = L1C_INTRS | L1C_INTR_GPHY |
2724 		    L1C_INTR_PHY_LINK_DOWN;
2725 		atgep->atge_int_rx_mod = 400/2;
2726 		atgep->atge_int_tx_mod = 2000/1;
2727 
2728 		atge_l1c_init_tx_ring(atgep);
2729 		atge_l1c_init_rx_ring(atgep);
2730 		atge_l1c_init_rr_ring(atgep);
2731 		atge_l1c_init_cmb(atgep);
2732 		atge_l1c_init_smb(atgep);
2733 
2734 		/* Enable all clocks. */
2735 		OUTL(atgep, ATGE_CLK_GATING_CFG, 0);
2736 		break;
2737 	}
2738 }
2739 
2740 void
atge_device_restart(atge_t * atgep)2741 atge_device_restart(atge_t *atgep)
2742 {
2743 	ASSERT(MUTEX_HELD(&atgep->atge_intr_lock));
2744 	ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2745 
2746 	/*
2747 	 * Cancel any pending I/O.
2748 	 */
2749 	atge_device_stop(atgep);
2750 
2751 	/*
2752 	 * Reset the chip to a known state.
2753 	 */
2754 	atge_device_reset(atgep);
2755 
2756 	/*
2757 	 * Initialize the ring and other descriptor like CMB/SMB/Rx return.
2758 	 */
2759 	atge_device_init(atgep);
2760 
2761 	/*
2762 	 * Start the chip.
2763 	 */
2764 	atge_device_start(atgep);
2765 
2766 }
2767 
2768 static int
atge_send_a_packet(atge_t * atgep,mblk_t * mp)2769 atge_send_a_packet(atge_t *atgep, mblk_t *mp)
2770 {
2771 	uchar_t *c;
2772 	uint32_t cflags = 0;
2773 	atge_ring_t *r;
2774 	size_t pktlen;
2775 	uchar_t *buf;
2776 	int	start;
2777 
2778 	ASSERT(MUTEX_HELD(&atgep->atge_tx_lock));
2779 	ASSERT(mp != NULL);
2780 
2781 	pktlen = msgsize(mp);
2782 	if (pktlen > atgep->atge_tx_buf_len) {
2783 		atgep->atge_macxmt_errors++;
2784 
2785 		ATGE_DB(("%s: %s() pktlen (%d) > rx_buf_len (%d)",
2786 		    atgep->atge_name, __func__,
2787 		    pktlen, atgep->atge_rx_buf_len));
2788 
2789 		freemsg(mp);
2790 		return (DDI_SUCCESS);
2791 	}
2792 
2793 	r = atgep->atge_tx_ring;
2794 
2795 	if (r->r_avail_desc <= 1) {
2796 		atgep->atge_noxmtbuf++;
2797 		atgep->atge_tx_resched = 1;
2798 
2799 		ATGE_DB(("%s: %s() No transmit buf",
2800 		    atgep->atge_name, __func__));
2801 
2802 		return (DDI_FAILURE);
2803 	}
2804 
2805 	start = r->r_producer;
2806 
2807 	/*
2808 	 * Get the DMA buffer to hold a packet.
2809 	 */
2810 	buf = (uchar_t *)r->r_buf_tbl[start]->addr;
2811 
2812 	/*
2813 	 * Copy the msg and free mp
2814 	 */
2815 	mcopymsg(mp, buf);
2816 
2817 	r->r_avail_desc--;
2818 
2819 	c = (uchar_t *)r->r_desc_ring->addr;
2820 	switch (ATGE_MODEL(atgep)) {
2821 	case ATGE_CHIP_L1C:
2822 		{
2823 		l1c_tx_desc_t	*txd;
2824 
2825 		c += (sizeof (l1c_tx_desc_t) * start);
2826 		txd = (l1c_tx_desc_t *)c;
2827 
2828 		ATGE_PUT64(r->r_desc_ring, &txd->addr,
2829 		    r->r_buf_tbl[start]->cookie.dmac_laddress);
2830 
2831 		ATGE_PUT32(r->r_desc_ring, &txd->len, L1C_TX_BYTES(pktlen));
2832 
2833 		cflags |= L1C_TD_EOP;
2834 		ATGE_PUT32(r->r_desc_ring, &txd->flags, cflags);
2835 		break;
2836 		}
2837 	default:
2838 		{
2839 		atge_tx_desc_t	*txd;
2840 
2841 		c += (sizeof (atge_tx_desc_t) * start);
2842 		txd = (atge_tx_desc_t *)c;
2843 
2844 		ATGE_PUT64(r->r_desc_ring, &txd->addr,
2845 		    r->r_buf_tbl[start]->cookie.dmac_laddress);
2846 
2847 		ATGE_PUT32(r->r_desc_ring, &txd->len, ATGE_TX_BYTES(pktlen));
2848 
2849 		cflags |= ATGE_TD_EOP;
2850 		ATGE_PUT32(r->r_desc_ring, &txd->flags, cflags);
2851 		break;
2852 		}
2853 	}
2854 	/*
2855 	 * Sync buffer first.
2856 	 */
2857 	DMA_SYNC(r->r_buf_tbl[start], 0, pktlen, DDI_DMA_SYNC_FORDEV);
2858 
2859 	/*
2860 	 * Increment TX producer count by one.
2861 	 */
2862 	ATGE_INC_SLOT(r->r_producer, ATGE_TX_RING_CNT);
2863 
2864 	/*
2865 	 * Sync descriptor table.
2866 	 */
2867 	DMA_SYNC(r->r_desc_ring, 0, ATGE_TX_RING_SZ, DDI_DMA_SYNC_FORDEV);
2868 
2869 	/*
2870 	 * Program TX descriptor to send a packet.
2871 	 */
2872 	switch (ATGE_MODEL(atgep)) {
2873 	case ATGE_CHIP_L1E:
2874 		atge_l1e_send_packet(r);
2875 		break;
2876 	case ATGE_CHIP_L1:
2877 		atge_l1_send_packet(r);
2878 		break;
2879 	case ATGE_CHIP_L1C:
2880 		atge_l1c_send_packet(r);
2881 		break;
2882 	}
2883 
2884 	r->r_atge->atge_opackets++;
2885 	r->r_atge->atge_obytes += pktlen;
2886 
2887 	ATGE_DB(("%s: %s() pktlen : %d, avail_desc : %d, producer  :%d, "
2888 	    "consumer : %d", atgep->atge_name, __func__, pktlen,
2889 	    r->r_avail_desc, r->r_producer, r->r_consumer));
2890 
2891 	return (DDI_SUCCESS);
2892 }
2893 
2894 /*
2895  * Stream Information.
2896  */
2897 DDI_DEFINE_STREAM_OPS(atge_devops, nulldev, nulldev, atge_attach, atge_detach,
2898     nodev, NULL, D_MP, NULL, atge_quiesce);
2899 
2900 /*
2901  * Module linkage information.
2902  */
2903 static	struct	modldrv	atge_modldrv = {
2904 	&mod_driverops,				/* Type of Module */
2905 	"Atheros/Attansic Gb Ethernet",		/* Description */
2906 	&atge_devops				/* drv_dev_ops */
2907 };
2908 
2909 static	struct	modlinkage atge_modlinkage = {
2910 	MODREV_1,			/* ml_rev */
2911 	(void *)&atge_modldrv,
2912 	NULL
2913 };
2914 
2915 /*
2916  * DDI Entry points.
2917  */
2918 int
_init(void)2919 _init(void)
2920 {
2921 	int	r;
2922 	mac_init_ops(&atge_devops, "atge");
2923 	if ((r = mod_install(&atge_modlinkage)) != DDI_SUCCESS) {
2924 		mac_fini_ops(&atge_devops);
2925 	}
2926 
2927 	return (r);
2928 }
2929 
2930 int
_fini(void)2931 _fini(void)
2932 {
2933 	int	r;
2934 
2935 	if ((r = mod_remove(&atge_modlinkage)) == DDI_SUCCESS) {
2936 		mac_fini_ops(&atge_devops);
2937 	}
2938 
2939 	return (r);
2940 }
2941 
2942 int
_info(struct modinfo * modinfop)2943 _info(struct modinfo *modinfop)
2944 {
2945 	return (mod_info(&atge_modlinkage, modinfop));
2946 }
2947