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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 *
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
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 *
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
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
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
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
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
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
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
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
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 *
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
2943 _info(struct modinfo *modinfop)
2944 {
2945 return (mod_info(&atge_modlinkage, modinfop));
2946 }