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