Mercurial > illumos > illumos-gate

comparison usr/src/uts/common/io/atge/atge_main.c @ 13768:ed21ea5d20cf

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
212 Atheros AR8132 / L1c Gigabit Ethernet Adapter Reviewed by: Garrett D'Amore <garrett@damore.org> Reviewed by: Milan Jurik <milan.jurik@xylab.cz> Approved by: Dan McDonald <danmcd@nexenta.com>
author Gary Mills <gary_mills@fastmail.fm>
date Fri, 10 Aug 2012 10:52:49 -0400
parents d1a36c3701ab
children
comparison
equal deleted inserted replaced
13767:8c906b14afbd 13768:ed21ea5d20cf
18 * 18 *
19 * CDDL HEADER END 19 * CDDL HEADER END
20 */ 20 */
21 21
22 /* 22 /*
23 * Copyright (c) 2012 Gary Mills
24 *
23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 25 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
26 */
27 /*
28 * Copyright (c) 2009, Pyun YongHyeon <yongari@FreeBSD.org>
29 * All rights reserved.
30 *
31 * Redistribution and use in source and binary forms, with or without
32 * modification, are permitted provided that the following conditions
33 * are met:
34 * 1. Redistributions of source code must retain the above copyright
35 * notice unmodified, this list of conditions, and the following
36 * disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 *
41 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
24 */ 52 */
25 53
26 #include <sys/types.h> 54 #include <sys/types.h>
27 #include <sys/stream.h> 55 #include <sys/stream.h>
28 #include <sys/strsun.h> 56 #include <sys/strsun.h>
51 #include <sys/pci.h> 79 #include <sys/pci.h>
52 #include <sys/pci_cap.h> 80 #include <sys/pci_cap.h>
53 81
54 #include "atge.h" 82 #include "atge.h"
55 #include "atge_cmn_reg.h" 83 #include "atge_cmn_reg.h"
84 #include "atge_l1c_reg.h"
56 #include "atge_l1e_reg.h" 85 #include "atge_l1e_reg.h"
57 #include "atge_l1_reg.h" 86 #include "atge_l1_reg.h"
58 87
59 88
60 /* 89 /*
61 * Atheros/Attansic Ethernet chips are of three types - L1, L2 and L1E. 90 * Atheros/Attansic Ethernet chips are of four types - L1, L2, L1E and L1C.
62 * This driver is for L1E/L1 but can be extended to support other chips. 91 * This driver is for L1E/L1/L1C but can be extended to support other chips.
63 * L1E comes in 1Gigabit and Fast Ethernet flavors. L1 comes in 1Gigabit 92 * L1E comes in 1Gigabit and Fast Ethernet flavors. L1 comes in 1Gigabit
64 * flavors only. 93 * flavors only. L1C comes in both flavours.
65 * 94 *
66 * Atheros/Attansic Ethernet controllers have descriptor based TX and RX 95 * 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. 96 * 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 97 * The L1E's RX uses pages (not to be confused with MMU pages) for
69 * receiving pkts. The header has four fields : 98 * receiving pkts. The header has four fields :
150 179
151 /* 180 /*
152 * L1 specific functions. 181 * L1 specific functions.
153 */ 182 */
154 int atge_l1_alloc_dma(atge_t *); 183 int atge_l1_alloc_dma(atge_t *);
184 void atge_l1_free_dma(atge_t *);
155 void atge_l1_init_tx_ring(atge_t *); 185 void atge_l1_init_tx_ring(atge_t *);
156 void atge_l1_init_rx_ring(atge_t *); 186 void atge_l1_init_rx_ring(atge_t *);
157 void atge_l1_init_rr_ring(atge_t *); 187 void atge_l1_init_rr_ring(atge_t *);
158 void atge_l1_init_cmb(atge_t *); 188 void atge_l1_init_cmb(atge_t *);
159 void atge_l1_init_smb(atge_t *); 189 void atge_l1_init_smb(atge_t *);
161 void atge_l1_stop_tx_mac(atge_t *); 191 void atge_l1_stop_tx_mac(atge_t *);
162 void atge_l1_stop_rx_mac(atge_t *); 192 void atge_l1_stop_rx_mac(atge_t *);
163 uint_t atge_l1_interrupt(caddr_t, caddr_t); 193 uint_t atge_l1_interrupt(caddr_t, caddr_t);
164 void atge_l1_send_packet(atge_ring_t *); 194 void atge_l1_send_packet(atge_ring_t *);
165 195
196 /*
197 * L1C specific functions.
198 */
199 int atge_l1c_alloc_dma(atge_t *);
200 void atge_l1c_free_dma(atge_t *);
201 void atge_l1c_init_tx_ring(atge_t *);
202 void atge_l1c_init_rx_ring(atge_t *);
203 void atge_l1c_init_rr_ring(atge_t *);
204 void atge_l1c_init_cmb(atge_t *);
205 void atge_l1c_init_smb(atge_t *);
206 void atge_l1c_program_dma(atge_t *);
207 void atge_l1c_stop_tx_mac(atge_t *);
208 void atge_l1c_stop_rx_mac(atge_t *);
209 uint_t atge_l1c_interrupt(caddr_t, caddr_t);
210 void atge_l1c_send_packet(atge_ring_t *);
211 void atge_l1c_gather_stats(atge_t *);
212 void atge_l1c_clear_stats(atge_t *);
166 213
167 /* 214 /*
168 * Function prototyps for MII operations. 215 * Function prototyps for MII operations.
169 */ 216 */
170 uint16_t atge_mii_read(void *, uint8_t, uint8_t); 217 uint16_t atge_mii_read(void *, uint8_t, uint8_t);
171 void atge_mii_write(void *, uint8_t, uint8_t, uint16_t); 218 void atge_mii_write(void *, uint8_t, uint8_t, uint16_t);
219 uint16_t atge_l1c_mii_read(void *, uint8_t, uint8_t);
220 void atge_l1c_mii_write(void *, uint8_t, uint8_t, uint16_t);
172 void atge_l1e_mii_reset(void *); 221 void atge_l1e_mii_reset(void *);
173 void atge_l1_mii_reset(void *); 222 void atge_l1_mii_reset(void *);
223 void atge_l1c_mii_reset(void *);
174 static void atge_mii_notify(void *, link_state_t); 224 static void atge_mii_notify(void *, link_state_t);
175 void atge_tx_reclaim(atge_t *atgep, int cons); 225 void atge_tx_reclaim(atge_t *atgep, int cons);
176 226
177 /* 227 /*
178 * L1E/L2E chip. 228 * L1E/L2E chip.
192 MII_OPS_VERSION, 242 MII_OPS_VERSION,
193 atge_mii_read, 243 atge_mii_read,
194 atge_mii_write, 244 atge_mii_write,
195 atge_mii_notify, 245 atge_mii_notify,
196 atge_l1_mii_reset 246 atge_l1_mii_reset
247 };
248
249 /*
250 * L1C chip.
251 */
252 static mii_ops_t atge_l1c_mii_ops = {
253 MII_OPS_VERSION,
254 atge_l1c_mii_read,
255 atge_l1c_mii_write,
256 atge_mii_notify,
257 NULL
197 }; 258 };
198 259
199 /* 260 /*
200 * Function Prototypes for MAC callbacks. 261 * Function Prototypes for MAC callbacks.
201 */ 262 */
270 331
271 /* 332 /*
272 * Table of supported devices. 333 * Table of supported devices.
273 */ 334 */
274 #define ATGE_VENDOR_ID 0x1969 335 #define ATGE_VENDOR_ID 0x1969
336 #define ATGE_L1_STR "Attansic L1"
337 #define ATGE_L1CG_STR "Atheros AR8131 Gigabit Ethernet"
338 #define ATGE_L1CF_STR "Atheros AR8132 Fast Ethernet"
275 #define ATGE_L1E_STR "Atheros AR8121/8113/8114" 339 #define ATGE_L1E_STR "Atheros AR8121/8113/8114"
340 #define ATGE_AR8151V1_STR "Atheros AR8151 v1.0 Gigabit Ethernet"
341 #define ATGE_AR8151V2_STR "Atheros AR8151 v2.0 Gigabit Ethernet"
342 #define ATGE_AR8152V1_STR "Atheros AR8152 v1.1 Fast Ethernet"
343 #define ATGE_AR8152V2_STR "Atheros AR8152 v2.0 Fast Ethernet"
276 344
277 static atge_cards_t atge_cards[] = { 345 static atge_cards_t atge_cards[] = {
346 {ATGE_VENDOR_ID, ATGE_CHIP_AR8151V2_DEV_ID, ATGE_AR8151V2_STR,
347 ATGE_CHIP_L1C},
348 {ATGE_VENDOR_ID, ATGE_CHIP_AR8151V1_DEV_ID, ATGE_AR8151V1_STR,
349 ATGE_CHIP_L1C},
350 {ATGE_VENDOR_ID, ATGE_CHIP_AR8152V2_DEV_ID, ATGE_AR8152V2_STR,
351 ATGE_CHIP_L1C},
352 {ATGE_VENDOR_ID, ATGE_CHIP_AR8152V1_DEV_ID, ATGE_AR8152V1_STR,
353 ATGE_CHIP_L1C},
354 {ATGE_VENDOR_ID, ATGE_CHIP_L1CG_DEV_ID, ATGE_L1CG_STR, ATGE_CHIP_L1C},
355 {ATGE_VENDOR_ID, ATGE_CHIP_L1CF_DEV_ID, ATGE_L1CF_STR, ATGE_CHIP_L1C},
278 {ATGE_VENDOR_ID, ATGE_CHIP_L1E_DEV_ID, ATGE_L1E_STR, ATGE_CHIP_L1E}, 356 {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}, 357 {ATGE_VENDOR_ID, ATGE_CHIP_L1_DEV_ID, ATGE_L1_STR, ATGE_CHIP_L1},
280 }; 358 };
281 359
282 /* 360 /*
283 * Global Debugging flag. Developer level debugging is done only in DEBUG mode. 361 * Global Debugging flag. Developer level debugging is done only in DEBUG mode.
284 */ 362 */
298 va_end(ap); 376 va_end(ap);
299 377
300 DTRACE_PROBE1(atge__debug, char *, buf); 378 DTRACE_PROBE1(atge__debug, char *, buf);
301 } 379 }
302 380
381 static
382 void
383 atge_message(dev_info_t *dip, int level, char *fmt, va_list ap)
384 {
385 char buf[256];
386 char *p = "!%s%d: %s";
387 char *q = "!atge: %s";
388
389 (void) vsnprintf(buf, sizeof (buf), fmt, ap);
390
391 if (level != CE_NOTE) {
392 p++;
393 q++;
394 }
395
396 if (dip) {
397 cmn_err(level, p,
398 ddi_driver_name(dip), ddi_get_instance(dip), buf);
399 } else {
400 cmn_err(level, q, buf);
401 }
402 }
403
404 void
405 atge_notice(dev_info_t *dip, char *fmt, ...)
406 {
407 va_list ap;
408
409 va_start(ap, fmt);
410 (void) atge_message(dip, CE_NOTE, fmt, ap);
411 va_end(ap);
412 }
413
303 void 414 void
304 atge_error(dev_info_t *dip, char *fmt, ...) 415 atge_error(dev_info_t *dip, char *fmt, ...)
305 { 416 {
306 va_list ap; 417 va_list ap;
307 char buf[256];
308 418
309 va_start(ap, fmt); 419 va_start(ap, fmt);
310 (void) vsnprintf(buf, sizeof (buf), fmt, ap); 420 (void) atge_message(dip, CE_WARN, fmt, ap);
311 va_end(ap); 421 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 } 422 }
320 423
321 void 424 void
322 atge_mac_config(atge_t *atgep) 425 atge_mac_config(atge_t *atgep)
323 { 426 {
324 uint32_t reg; 427 uint32_t reg;
325 int speed; 428 int speed;
326 link_duplex_t ld; 429 link_duplex_t ld;
327 430
431 /* Re-enable TX/RX MACs */
328 reg = INL(atgep, ATGE_MAC_CFG); 432 reg = INL(atgep, ATGE_MAC_CFG);
329 reg &= ~(ATGE_CFG_FULL_DUPLEX | ATGE_CFG_TX_FC | ATGE_CFG_RX_FC | 433 reg &= ~(ATGE_CFG_FULL_DUPLEX | ATGE_CFG_TX_FC | ATGE_CFG_RX_FC |
330 ATGE_CFG_SPEED_MASK); 434 ATGE_CFG_SPEED_MASK);
435
436 switch (ATGE_MODEL(atgep)) {
437 case ATGE_CHIP_L1C:
438 switch (ATGE_DID(atgep)) {
439 case ATGE_CHIP_AR8151V2_DEV_ID:
440 case ATGE_CHIP_AR8151V1_DEV_ID:
441 case ATGE_CHIP_AR8152V2_DEV_ID:
442 reg |= ATGE_CFG_HASH_ALG_CRC32 | ATGE_CFG_SPEED_MODE_SW;
443 break;
444 }
445 break;
446 }
331 447
332 speed = mii_get_speed(atgep->atge_mii); 448 speed = mii_get_speed(atgep->atge_mii);
333 switch (speed) { 449 switch (speed) {
334 case 10: 450 case 10:
335 case 100: 451 case 100:
343 ld = mii_get_duplex(atgep->atge_mii); 459 ld = mii_get_duplex(atgep->atge_mii);
344 if (ld == LINK_DUPLEX_FULL) 460 if (ld == LINK_DUPLEX_FULL)
345 reg |= ATGE_CFG_FULL_DUPLEX; 461 reg |= ATGE_CFG_FULL_DUPLEX;
346 462
347 /* Re-enable TX/RX MACs */ 463 /* Re-enable TX/RX MACs */
348 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 464 switch (ATGE_MODEL(atgep)) {
465 case ATGE_CHIP_L1E:
349 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB | ATGE_CFG_RX_FC; 466 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB | ATGE_CFG_RX_FC;
350 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 467 break;
468 case ATGE_CHIP_L1:
469 case ATGE_CHIP_L1C:
351 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB; 470 reg |= ATGE_CFG_TX_ENB | ATGE_CFG_RX_ENB;
471 break;
352 } 472 }
353 473
354 OUTL(atgep, ATGE_MAC_CFG, reg); 474 OUTL(atgep, ATGE_MAC_CFG, reg);
355 475
356 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 476 switch (ATGE_MODEL(atgep)) {
477 case ATGE_CHIP_L1E:
357 reg = ATGE_USECS(ATGE_IM_RX_TIMER_DEFAULT) << IM_TIMER_RX_SHIFT; 478 reg = ATGE_USECS(ATGE_IM_RX_TIMER_DEFAULT) << IM_TIMER_RX_SHIFT;
358 reg |= ATGE_USECS(ATGE_IM_TX_TIMER_DEFAULT) << 479 reg |= ATGE_USECS(ATGE_IM_TX_TIMER_DEFAULT) <<
359 IM_TIMER_TX_SHIFT; 480 IM_TIMER_TX_SHIFT;
360 OUTL(atgep, ATGE_IM_TIMER, reg); 481 OUTL(atgep, ATGE_IM_TIMER, reg);
482 break;
483 case ATGE_CHIP_L1:
484 break;
485 case ATGE_CHIP_L1C:
486 /* Configure interrupt moderation timer. */
487 reg = ATGE_USECS(atgep->atge_int_rx_mod) << IM_TIMER_RX_SHIFT;
488 reg |= ATGE_USECS(atgep->atge_int_tx_mod) << IM_TIMER_TX_SHIFT;
489 OUTL(atgep, ATGE_IM_TIMER, reg);
490 /*
491 * We don't want to automatic interrupt clear as task queue
492 * for the interrupt should know interrupt status.
493 */
494 reg = 0;
495 if (ATGE_USECS(atgep->atge_int_rx_mod) != 0)
496 reg |= MASTER_IM_RX_TIMER_ENB;
497 if (ATGE_USECS(atgep->atge_int_tx_mod) != 0)
498 reg |= MASTER_IM_TX_TIMER_ENB;
499 OUTL(atgep, ATGE_MASTER_CFG, reg);
500 break;
361 } 501 }
362 502
363 ATGE_DB(("%s: %s() mac_cfg is : %x", 503 ATGE_DB(("%s: %s() mac_cfg is : %x",
364 atgep->atge_name, __func__, INL(atgep, ATGE_MAC_CFG))); 504 atgep->atge_name, __func__, INL(atgep, ATGE_MAC_CFG)));
365 } 505 }
521 661
522 /* 662 /*
523 * Add interrupt handler now. 663 * Add interrupt handler now.
524 */ 664 */
525 for (i = 0; i < atgep->atge_intr_cnt; i++) { 665 for (i = 0; i < atgep->atge_intr_cnt; i++) {
526 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 666 switch (ATGE_MODEL(atgep)) {
667 case ATGE_CHIP_L1E:
527 err = ddi_intr_add_handler(atgep->atge_intr_handle[i], 668 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
528 atge_l1e_interrupt, atgep, (caddr_t)(uintptr_t)i); 669 atge_l1e_interrupt, atgep, (caddr_t)(uintptr_t)i);
529 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 670 break;
671 case ATGE_CHIP_L1:
530 err = ddi_intr_add_handler(atgep->atge_intr_handle[i], 672 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
531 atge_l1_interrupt, atgep, (caddr_t)(uintptr_t)i); 673 atge_l1_interrupt, atgep, (caddr_t)(uintptr_t)i);
674 break;
675 case ATGE_CHIP_L1C:
676 err = ddi_intr_add_handler(atgep->atge_intr_handle[i],
677 atge_l1c_interrupt, atgep, (caddr_t)(uintptr_t)i);
678 break;
532 } 679 }
533 680
534 if (err != DDI_SUCCESS) { 681 if (err != DDI_SUCCESS) {
535 atge_error(atgep->atge_dip, 682 atge_error(atgep->atge_dip,
536 "ddi_intr_add_handler failed : %d", err); 683 "ddi_intr_add_handler failed : %d", err);
707 atgep->atge_model = 0; 854 atgep->atge_model = 0;
708 for (i = 0; i < (sizeof (atge_cards) / sizeof (atge_cards_t)); i++) { 855 for (i = 0; i < (sizeof (atge_cards) / sizeof (atge_cards_t)); i++) {
709 if (atge_cards[i].vendor_id == vid && 856 if (atge_cards[i].vendor_id == vid &&
710 atge_cards[i].device_id == did) { 857 atge_cards[i].device_id == did) {
711 atgep->atge_model = atge_cards[i].model; 858 atgep->atge_model = atge_cards[i].model;
859 atgep->atge_vid = vid;
860 atgep->atge_did = did;
712 atgep->atge_revid = 861 atgep->atge_revid =
713 pci_config_get8(atgep->atge_conf_handle, 862 pci_config_get8(atgep->atge_conf_handle,
714 PCI_CONF_REVID); 863 PCI_CONF_REVID);
864 atge_notice(atgep->atge_dip, "PCI-ID pci%x,%x,%x: %s",
865 vid, did, atgep->atge_revid,
866 atge_cards[i].cardname);
715 ATGE_DB(("%s: %s : PCI-ID pci%x,%x and model : %d", 867 ATGE_DB(("%s: %s : PCI-ID pci%x,%x and model : %d",
716 atgep->atge_name, __func__, vid, did, 868 atgep->atge_name, __func__, vid, did,
717 atgep->atge_model)); 869 atgep->atge_model));
718 870
719 return (DDI_SUCCESS); 871 return (DDI_SUCCESS);
720 } 872 }
721 } 873 }
722 874
723 atge_error(atgep->atge_dip, "atge driver is attaching to unknown" 875 atge_error(atgep->atge_dip, "atge driver is attaching to unknown"
724 " pci%d,%d vendor/device-id card", vid, did); 876 " pci%x,%x vendor/device-id card", vid, did);
725 877
726 /* 878 /*
727 * Assume it's L1 chip. 879 * Assume it's L1C chip.
728 */ 880 */
729 atgep->atge_model = ATGE_CHIP_L1; 881 atgep->atge_model = ATGE_CHIP_L1C;
882 atgep->atge_vid = vid;
883 atgep->atge_did = did;
730 atgep->atge_revid = pci_config_get8(atgep->atge_conf_handle, 884 atgep->atge_revid = pci_config_get8(atgep->atge_conf_handle,
731 PCI_CONF_REVID); 885 PCI_CONF_REVID);
732 886
733 /* 887 /*
734 * We will leave the decision to caller. 888 * We will leave the decision to caller.
772 926
773 return (DDI_SUCCESS); 927 return (DDI_SUCCESS);
774 } 928 }
775 929
776 /* 930 /*
777 * Reset functionality for L1 and L1E. It's same. 931 * Reset functionality for L1, L1E, and L1C. It's same.
778 */ 932 */
779 static void 933 static void
780 atge_device_reset(atge_t *atgep) 934 atge_device_reset(atge_t *atgep)
781 { 935 {
782 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E || 936 switch (ATGE_MODEL(atgep)) {
783 ATGE_MODEL(atgep) == ATGE_CHIP_L1) 937 case ATGE_CHIP_L1E:
938 case ATGE_CHIP_L1:
939 case ATGE_CHIP_L1C:
784 atge_device_reset_l1_l1e(atgep); 940 atge_device_reset_l1_l1e(atgep);
941 break;
942 }
785 } 943 }
786 944
787 void 945 void
788 atge_device_reset_l1_l1e(atge_t *atgep) 946 atge_device_reset_l1_l1e(atge_t *atgep)
789 { 947 {
790 uint32_t reg; 948 uint32_t reg;
791 int t; 949 int t;
792 950 switch (ATGE_MODEL(atgep)) {
793 OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET); 951 case ATGE_CHIP_L1C:
952 OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET | 0x40);
953 break;
954 default:
955 OUTL(atgep, ATGE_MASTER_CFG, MASTER_RESET);
956 break;
957 }
794 reg = INL(atgep, ATGE_MASTER_CFG); 958 reg = INL(atgep, ATGE_MASTER_CFG);
795 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) { 959 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
796 drv_usecwait(10); 960 drv_usecwait(10);
797 reg = INL(atgep, ATGE_MASTER_CFG); 961 reg = INL(atgep, ATGE_MASTER_CFG);
798 if ((reg & MASTER_RESET) == 0) 962 if ((reg & MASTER_RESET) == 0)
814 if (t == 0) { 978 if (t == 0) {
815 atge_error(atgep->atge_dip, "device reset timeout reg : %x", 979 atge_error(atgep->atge_dip, "device reset timeout reg : %x",
816 reg); 980 reg);
817 } 981 }
818 982
819 /* 983 switch (ATGE_MODEL(atgep)) {
820 * Initialize PCIe module. These values came from FreeBSD and 984 case ATGE_CHIP_L1E:
821 * we don't know the meaning of it. 985 case ATGE_CHIP_L1:
822 */ 986 /*
823 OUTL(atgep, 0x12FC, 0x6500); 987 * Initialize PCIe module. These values came from FreeBSD and
824 reg = INL(atgep, 0x1008) | 0x8000; 988 * we don't know the meaning of it.
825 OUTL(atgep, 0x1008, reg); 989 */
990 OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
991 reg = INL(atgep, 0x1008) | 0x8000;
992 OUTL(atgep, 0x1008, reg);
993 break;
994 case ATGE_CHIP_L1C:
995 break;
996 }
826 997
827 /* 998 /*
828 * Get chip revision. 999 * Get chip revision.
829 */ 1000 */
830 atgep->atge_chip_rev = INL(atgep, ATGE_MASTER_CFG) >> 1001 atgep->atge_chip_rev = INL(atgep, ATGE_MASTER_CFG) >>
841 static int 1012 static int
842 atge_alloc_dma(atge_t *atgep) 1013 atge_alloc_dma(atge_t *atgep)
843 { 1014 {
844 int err = DDI_FAILURE; 1015 int err = DDI_FAILURE;
845 1016
846 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 1017 switch (ATGE_MODEL(atgep)) {
1018 case ATGE_CHIP_L1E:
847 err = atge_l1e_alloc_dma(atgep); 1019 err = atge_l1e_alloc_dma(atgep);
848 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 1020 break;
1021 case ATGE_CHIP_L1:
849 err = atge_l1_alloc_dma(atgep); 1022 err = atge_l1_alloc_dma(atgep);
1023 break;
1024 case ATGE_CHIP_L1C:
1025 err = atge_l1c_alloc_dma(atgep);
1026 break;
850 } 1027 }
851 1028
852 return (err); 1029 return (err);
853 } 1030 }
854 1031
855 static void 1032 static void
856 atge_free_dma(atge_t *atgep) 1033 atge_free_dma(atge_t *atgep)
857 { 1034 {
858 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 1035 switch (ATGE_MODEL(atgep)) {
1036 case ATGE_CHIP_L1E:
859 atge_l1e_free_dma(atgep); 1037 atge_l1e_free_dma(atgep);
1038 break;
1039 case ATGE_CHIP_L1:
1040 atge_l1_free_dma(atgep);
1041 break;
1042 case ATGE_CHIP_L1C:
1043 atge_l1c_free_dma(atgep);
1044 break;
860 } 1045 }
861 } 1046 }
862 1047
863 /* 1048 /*
864 * Attach entry point in the driver. 1049 * Attach entry point in the driver.
875 mii_ops_t *mii_ops; 1060 mii_ops_t *mii_ops;
876 1061
877 instance = ddi_get_instance(devinfo); 1062 instance = ddi_get_instance(devinfo);
878 1063
879 switch (cmd) { 1064 switch (cmd) {
1065 case DDI_RESUME:
1066 return (atge_resume(devinfo));
1067
1068 case DDI_ATTACH:
1069 ddi_set_driver_private(devinfo, NULL);
1070 break;
880 default: 1071 default:
881 return (DDI_FAILURE); 1072 return (DDI_FAILURE);
882 1073
883 case DDI_RESUME:
884 return (atge_resume(devinfo));
885
886 case DDI_ATTACH:
887 ddi_set_driver_private(devinfo, NULL);
888 break;
889 } 1074 }
890 1075
891 atgep = kmem_zalloc(sizeof (atge_t), KM_SLEEP); 1076 atgep = kmem_zalloc(sizeof (atge_t), KM_SLEEP);
892 ddi_set_driver_private(devinfo, atgep); 1077 ddi_set_driver_private(devinfo, atgep);
893 atgep->atge_dip = devinfo; 1078 atgep->atge_dip = devinfo;
949 DDI_INTR_PRI(atgep->atge_intr_pri)); 1134 DDI_INTR_PRI(atgep->atge_intr_pri));
950 1135
951 atgep->atge_link_state = LINK_STATE_DOWN; 1136 atgep->atge_link_state = LINK_STATE_DOWN;
952 atgep->atge_mtu = ETHERMTU; 1137 atgep->atge_mtu = ETHERMTU;
953 1138
954 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 1139 switch (ATGE_MODEL(atgep)) {
1140 case ATGE_CHIP_L1E:
955 if (atgep->atge_revid > 0xF0) { 1141 if (atgep->atge_revid > 0xF0) {
956 /* L2E Rev. B. AR8114 */ 1142 /* L2E Rev. B. AR8114 */
957 atgep->atge_flags |= ATGE_FLAG_FASTETHER; 1143 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
958 } else { 1144 } else {
959 if ((INL(atgep, L1E_PHY_STATUS) & 1145 if ((INL(atgep, L1E_PHY_STATUS) &
963 } else { 1149 } else {
964 /* L2E Rev. A. AR8113 */ 1150 /* L2E Rev. A. AR8113 */
965 atgep->atge_flags |= ATGE_FLAG_FASTETHER; 1151 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
966 } 1152 }
967 } 1153 }
1154 break;
1155 case ATGE_CHIP_L1:
1156 break;
1157 case ATGE_CHIP_L1C:
1158 /*
1159 * One odd thing is AR8132 uses the same PHY hardware(F1
1160 * gigabit PHY) of AR8131. So atphy(4) of AR8132 reports
1161 * the PHY supports 1000Mbps but that's not true. The PHY
1162 * used in AR8132 can't establish gigabit link even if it
1163 * shows the same PHY model/revision number of AR8131.
1164 *
1165 * It seems that AR813x/AR815x has silicon bug for SMB. In
1166 * addition, Atheros said that enabling SMB wouldn't improve
1167 * performance. However I think it's bad to access lots of
1168 * registers to extract MAC statistics.
1169 *
1170 * Don't use Tx CMB. It is known to have silicon bug.
1171 */
1172 switch (ATGE_DID(atgep)) {
1173 case ATGE_CHIP_AR8152V2_DEV_ID:
1174 case ATGE_CHIP_AR8152V1_DEV_ID:
1175 atgep->atge_flags |= ATGE_FLAG_APS |
1176 ATGE_FLAG_FASTETHER |
1177 ATGE_FLAG_ASPM_MON | ATGE_FLAG_JUMBO |
1178 ATGE_FLAG_SMB_BUG | ATGE_FLAG_CMB_BUG;
1179 break;
1180 case ATGE_CHIP_AR8151V2_DEV_ID:
1181 case ATGE_CHIP_AR8151V1_DEV_ID:
1182 atgep->atge_flags |= ATGE_FLAG_APS |
1183 ATGE_FLAG_ASPM_MON | ATGE_FLAG_JUMBO |
1184 ATGE_FLAG_SMB_BUG | ATGE_FLAG_CMB_BUG;
1185 break;
1186 case ATGE_CHIP_L1CF_DEV_ID:
1187 atgep->atge_flags |= ATGE_FLAG_FASTETHER;
1188 break;
1189 case ATGE_CHIP_L1CG_DEV_ID:
1190 break;
1191 }
1192 break;
968 } 1193 }
969 1194
970 /* 1195 /*
971 * Get DMA parameters from PCIe device control register. 1196 * Get DMA parameters from PCIe device control register.
972 */ 1197 */
997 atgep->atge_name, __func__, 1222 atgep->atge_name, __func__,
998 (128 << ((burst >> 12) & 0x07)), 1223 (128 << ((burst >> 12) & 0x07)),
999 (128 << ((burst >> 5) & 0x07)))); 1224 (128 << ((burst >> 5) & 0x07))));
1000 } 1225 }
1001 1226
1227 /* Clear data link and flow-control protocol error. */
1228 switch (ATGE_MODEL(atgep)) {
1229 case ATGE_CHIP_L1E:
1230 break;
1231 case ATGE_CHIP_L1:
1232 break;
1233 case ATGE_CHIP_L1C:
1234 OUTL_AND(atgep, ATGE_PEX_UNC_ERR_SEV,
1235 ~(PEX_UNC_ERR_SEV_UC | PEX_UNC_ERR_SEV_FCP));
1236 OUTL_AND(atgep, ATGE_LTSSM_ID_CFG, ~LTSSM_ID_WRO_ENB);
1237 OUTL_OR(atgep, ATGE_PCIE_PHYMISC, PCIE_PHYMISC_FORCE_RCV_DET);
1238 break;
1239 }
1240
1002 /* 1241 /*
1003 * Allocate DMA resources. 1242 * Allocate DMA resources.
1004 */ 1243 */
1005 err = atge_alloc_dma(atgep); 1244 err = atge_alloc_dma(atgep);
1006 if (err != DDI_SUCCESS) { 1245 if (err != DDI_SUCCESS) {
1014 (void) atge_get_macaddr(atgep); 1253 (void) atge_get_macaddr(atgep);
1015 1254
1016 /* 1255 /*
1017 * Setup MII. 1256 * Setup MII.
1018 */ 1257 */
1019 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 1258 switch (ATGE_MODEL(atgep)) {
1259 case ATGE_CHIP_L1E:
1020 mii_ops = &atge_l1e_mii_ops; 1260 mii_ops = &atge_l1e_mii_ops;
1021 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 1261 break;
1262 case ATGE_CHIP_L1:
1022 mii_ops = &atge_l1_mii_ops; 1263 mii_ops = &atge_l1_mii_ops;
1264 break;
1265 case ATGE_CHIP_L1C:
1266 mii_ops = &atge_l1c_mii_ops;
1267 break;
1023 } 1268 }
1024 1269
1025 if ((atgep->atge_mii = mii_alloc(atgep, devinfo, 1270 if ((atgep->atge_mii = mii_alloc(atgep, devinfo,
1026 mii_ops)) == NULL) { 1271 mii_ops)) == NULL) {
1027 atge_error(devinfo, "mii_alloc() failed"); 1272 atge_error(devinfo, "mii_alloc() failed");
1070 } 1315 }
1071 1316
1072 /* 1317 /*
1073 * Reset the PHY before starting. 1318 * Reset the PHY before starting.
1074 */ 1319 */
1075 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 1320 switch (ATGE_MODEL(atgep)) {
1321 case ATGE_CHIP_L1E:
1076 atge_l1e_mii_reset(atgep); 1322 atge_l1e_mii_reset(atgep);
1077 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 1323 break;
1324 case ATGE_CHIP_L1:
1078 atge_l1_mii_reset(atgep); 1325 atge_l1_mii_reset(atgep);
1326 break;
1327 case ATGE_CHIP_L1C:
1328 atge_l1c_mii_reset(atgep);
1329 break;
1079 } 1330 }
1080 1331
1081 /* 1332 /*
1082 * Let the PHY run. 1333 * Let the PHY run.
1083 */ 1334 */
1360 mutex_exit(&atgep->atge_intr_lock); 1611 mutex_exit(&atgep->atge_intr_lock);
1361 1612
1362 /* 1613 /*
1363 * Reset the PHY before resuming MII. 1614 * Reset the PHY before resuming MII.
1364 */ 1615 */
1365 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 1616 switch (ATGE_MODEL(atgep)) {
1617 case ATGE_CHIP_L1E:
1366 atge_l1e_mii_reset(atgep); 1618 atge_l1e_mii_reset(atgep);
1619 break;
1620 case ATGE_CHIP_L1:
1621 break;
1622 case ATGE_CHIP_L1C:
1623 break;
1367 } 1624 }
1368 1625
1369 mii_resume(atgep->atge_mii); 1626 mii_resume(atgep->atge_mii);
1370 1627
1371 /* kick-off downstream */ 1628 /* kick-off downstream */
1795 /* 2052 /*
1796 * Reprogram the Station address. 2053 * Reprogram the Station address.
1797 */ 2054 */
1798 atge_program_ether(atgep); 2055 atge_program_ether(atgep);
1799 2056
1800 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 2057 switch (ATGE_MODEL(atgep)) {
2058 case ATGE_CHIP_L1E:
1801 atge_l1e_program_dma(atgep); 2059 atge_l1e_program_dma(atgep);
1802 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 2060 break;
2061 case ATGE_CHIP_L1:
1803 atge_l1_program_dma(atgep); 2062 atge_l1_program_dma(atgep);
2063 break;
2064 case ATGE_CHIP_L1C:
2065 atge_l1c_program_dma(atgep);
2066 break;
1804 } 2067 }
1805 2068
1806 ATGE_DB(("%s: %s() dma, counters programmed ", atgep->atge_name, 2069 ATGE_DB(("%s: %s() dma, counters programmed ", atgep->atge_name,
1807 __func__)); 2070 __func__));
1808 2071
1809 OUTW(atgep, ATGE_INTR_CLR_TIMER, 1*1000/2); 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 }
1810 2096
1811 /* 2097 /*
1812 * Set Maximum frame size but don't let MTU be less than ETHER_MTU. 2098 * Set Maximum frame size but don't let MTU be less than ETHER_MTU.
1813 */ 2099 */
1814 if (atgep->atge_mtu < ETHERMTU) 2100 if (atgep->atge_mtu < ETHERMTU)
1818 2104
1819 atgep->atge_max_frame_size += sizeof (struct ether_header) + 2105 atgep->atge_max_frame_size += sizeof (struct ether_header) +
1820 VLAN_TAGSZ + ETHERFCSL; 2106 VLAN_TAGSZ + ETHERFCSL;
1821 OUTL(atgep, ATGE_FRAME_SIZE, atgep->atge_max_frame_size); 2107 OUTL(atgep, ATGE_FRAME_SIZE, atgep->atge_max_frame_size);
1822 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 }
1823 2119
1824 /* 2120 /*
1825 * Configure IPG/IFG parameters. 2121 * Configure IPG/IFG parameters.
1826 */ 2122 */
1827 OUTL(atgep, ATGE_IPG_IFG_CFG, 2123 OUTL(atgep, ATGE_IPG_IFG_CFG,
1844 HDPX_CFG_JAMIPG_MASK)); 2140 HDPX_CFG_JAMIPG_MASK));
1845 2141
1846 /* 2142 /*
1847 * Configure jumbo frame. 2143 * Configure jumbo frame.
1848 */ 2144 */
1849 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 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:
1850 fsize = ROUNDUP(atgep->atge_max_frame_size, sizeof (uint64_t)); 2162 fsize = ROUNDUP(atgep->atge_max_frame_size, sizeof (uint64_t));
1851 OUTL(atgep, ATGE_RXQ_JUMBO_CFG, 2163 OUTL(atgep, ATGE_RXQ_JUMBO_CFG,
1852 (((fsize / sizeof (uint64_t)) << 2164 (((fsize / sizeof (uint64_t)) <<
1853 RXQ_JUMBO_CFG_SZ_THRESH_SHIFT) & 2165 RXQ_JUMBO_CFG_SZ_THRESH_SHIFT) &
1854 RXQ_JUMBO_CFG_SZ_THRESH_MASK) | 2166 RXQ_JUMBO_CFG_SZ_THRESH_MASK) |
1855 ((RXQ_JUMBO_CFG_LKAH_DEFAULT << 2167 ((RXQ_JUMBO_CFG_LKAH_DEFAULT <<
1856 RXQ_JUMBO_CFG_LKAH_SHIFT) & RXQ_JUMBO_CFG_LKAH_MASK) | 2168 RXQ_JUMBO_CFG_LKAH_SHIFT) & RXQ_JUMBO_CFG_LKAH_MASK) |
1857 ((ATGE_USECS(8) << RXQ_JUMBO_CFG_RRD_TIMER_SHIFT) & 2169 ((ATGE_USECS(8) << RXQ_JUMBO_CFG_RRD_TIMER_SHIFT) &
1858 RXQ_JUMBO_CFG_RRD_TIMER_MASK)); 2170 RXQ_JUMBO_CFG_RRD_TIMER_MASK));
1859 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E && 2171 break;
1860 atgep->atge_flags & ATGE_FLAG_JUMBO) { 2172 case ATGE_CHIP_L1C:
1861 2173 break;
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 } 2174 }
1873 2175
1874 /* 2176 /*
1875 * Configure flow-control parameters. 2177 * Configure flow-control parameters.
1876 */ 2178 */
1877 if ((atgep->atge_flags & ATGE_FLAG_PCIE) != 0) { 2179 switch (ATGE_MODEL(atgep)) {
2180 case ATGE_CHIP_L1E:
2181 case ATGE_CHIP_L1:
2182 if ((atgep->atge_flags & ATGE_FLAG_PCIE) != 0) {
1878 /* 2183 /*
1879 * Some hardware version require this magic. 2184 * Some hardware version require this magic.
1880 */ 2185 */
1881 OUTL(atgep, 0x12FC, 0x6500); 2186 OUTL(atgep, ATGE_LTSSM_ID_CFG, 0x6500);
1882 reg = INL(atgep, 0x1008); 2187 reg = INL(atgep, 0x1008);
1883 OUTL(atgep, 0x1008, reg | 0x8000); 2188 OUTL(atgep, 0x1008, reg | 0x8000);
2189 }
2190 break;
2191 case ATGE_CHIP_L1C:
2192 break;
1884 } 2193 }
1885 2194
1886 /* 2195 /*
1887 * These are all magic parameters which came from FreeBSD. 2196 * These are all magic parameters which came from FreeBSD.
1888 */ 2197 */
1889 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 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:
1890 switch (atgep->atge_chip_rev) { 2211 switch (atgep->atge_chip_rev) {
1891 case 0x8001: 2212 case 0x8001:
1892 case 0x9001: 2213 case 0x9001:
1893 case 0x9002: 2214 case 0x9002:
1894 case 0x9003: 2215 case 0x9003:
1924 OUTL(atgep, L1_RXQ_RRD_PAUSE_THRESH, 2245 OUTL(atgep, L1_RXQ_RRD_PAUSE_THRESH,
1925 ((rrd_lo << RXQ_RRD_PAUSE_THRESH_LO_SHIFT) & 2246 ((rrd_lo << RXQ_RRD_PAUSE_THRESH_LO_SHIFT) &
1926 RXQ_RRD_PAUSE_THRESH_LO_MASK) | 2247 RXQ_RRD_PAUSE_THRESH_LO_MASK) |
1927 ((rrd_hi << RXQ_RRD_PAUSE_THRESH_HI_SHIFT) & 2248 ((rrd_hi << RXQ_RRD_PAUSE_THRESH_HI_SHIFT) &
1928 RXQ_RRD_PAUSE_THRESH_HI_MASK)); 2249 RXQ_RRD_PAUSE_THRESH_HI_MASK));
1929 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 2250 break;
1930 reg = INL(atgep, L1E_SRAM_RX_FIFO_LEN); 2251 case ATGE_CHIP_L1C:
1931 rxf_hi = (reg * 4) / 5; 2252 switch (ATGE_DID(atgep)) {
1932 rxf_lo = reg/ 5; 2253 case ATGE_CHIP_AR8151V2_DEV_ID:
1933 2254 case ATGE_CHIP_AR8152V1_DEV_ID:
1934 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH, 2255 OUTL(atgep, ATGE_SERDES_LOCK,
1935 ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) & 2256 INL(atgep, ATGE_SERDES_LOCK) |
1936 RXQ_FIFO_PAUSE_THRESH_LO_MASK) | 2257 SERDES_MAC_CLK_SLOWDOWN |
1937 ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) & 2258 SERDES_PHY_CLK_SLOWDOWN);
1938 RXQ_FIFO_PAUSE_THRESH_HI_MASK)); 2259 break;
1939 } 2260 case ATGE_CHIP_L1CG_DEV_ID:
1940 2261 case ATGE_CHIP_L1CF_DEV_ID:
1941 /* Configure RxQ. */ 2262 /*
1942 reg = 0; 2263 * Configure flow control parameters.
1943 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 2264 * XON : 80% of Rx FIFO
1944 reg = 2265 * XOFF : 30% of Rx FIFO
1945 ((RXQ_CFG_RD_BURST_DEFAULT << RXQ_CFG_RD_BURST_SHIFT) & 2266 */
1946 RXQ_CFG_RD_BURST_MASK) | 2267 reg = INL(atgep, L1C_SRAM_RX_FIFO_LEN);
1947 ((RXQ_CFG_RRD_BURST_THRESH_DEFAULT << 2268 rxf_hi = (reg * 8) / 10;
1948 RXQ_CFG_RRD_BURST_THRESH_SHIFT) & 2269 rxf_lo = (reg * 3) / 10;
1949 RXQ_CFG_RRD_BURST_THRESH_MASK) | 2270
1950 ((RXQ_CFG_RD_PREF_MIN_IPG_DEFAULT << 2271 OUTL(atgep, ATGE_RXQ_FIFO_PAUSE_THRESH,
1951 RXQ_CFG_RD_PREF_MIN_IPG_SHIFT) & 2272 ((rxf_lo << RXQ_FIFO_PAUSE_THRESH_LO_SHIFT) &
1952 RXQ_CFG_RD_PREF_MIN_IPG_MASK) | 2273 RXQ_FIFO_PAUSE_THRESH_LO_MASK) |
1953 RXQ_CFG_CUT_THROUGH_ENB | RXQ_CFG_ENB; 2274 ((rxf_hi << RXQ_FIFO_PAUSE_THRESH_HI_SHIFT) &
1954 OUTL(atgep, ATGE_RXQ_CFG, reg); 2275 RXQ_FIFO_PAUSE_THRESH_HI_MASK));
1955 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 2276 break;
2277 }
2278 break;
2279 }
2280
2281 switch (ATGE_MODEL(atgep)) {
2282 case ATGE_CHIP_L1E:
2283 /* Configure RxQ. */
1956 reg = RXQ_CFG_ALIGN_32 | RXQ_CFG_CUT_THROUGH_ENB | 2284 reg = RXQ_CFG_ALIGN_32 | RXQ_CFG_CUT_THROUGH_ENB |
1957 RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB; 2285 RXQ_CFG_IPV6_CSUM_VERIFY | RXQ_CFG_ENB;
1958 OUTL(atgep, ATGE_RXQ_CFG, reg); 2286 OUTL(atgep, ATGE_RXQ_CFG, reg);
1959 } 2287 /*
1960 2288 * Configure TxQ.
1961 /* 2289 */
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 << 2290 reg = (128 <<
1978 (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) << 2291 (atgep->atge_dma_rd_burst >> DMA_CFG_RD_BURST_SHIFT)) <<
1979 TXQ_CFG_TX_FIFO_BURST_SHIFT; 2292 TXQ_CFG_TX_FIFO_BURST_SHIFT;
1980 2293
1981 reg |= (TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) & 2294 reg |= (TXQ_CFG_TPD_BURST_DEFAULT << TXQ_CFG_TPD_BURST_SHIFT) &
1982 TXQ_CFG_TPD_BURST_MASK; 2295 TXQ_CFG_TPD_BURST_MASK;
1983 2296
1984 reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB; 2297 reg |= TXQ_CFG_ENHANCED_MODE | TXQ_CFG_ENB;
1985 2298
1986 OUTL(atgep, ATGE_TXQ_CFG, reg); 2299 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. */ 2300 /* Disable RSS. */
1999 OUTL(atgep, L1E_RSS_IDT_TABLE0, 0); 2301 OUTL(atgep, L1E_RSS_IDT_TABLE0, 0);
2000 OUTL(atgep, L1E_RSS_CPU, 0); 2302 OUTL(atgep, L1E_RSS_CPU, 0);
2001 } 2303 /*
2002 2304 * Configure DMA parameters.
2003 /* 2305 */
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 /* 2306 /*
2020 * Don't use Tx CMB. It is known to cause RRS update failure 2307 * Don't use Tx CMB. It is known to cause RRS update failure
2021 * under certain circumstances. Typical phenomenon of the 2308 * under certain circumstances. Typical phenomenon of the
2022 * issue would be unexpected sequence number encountered in 2309 * issue would be unexpected sequence number encountered in
2023 * Rx handler. Hence we don't set DMA_CFG_TXCMB_ENB. 2310 * Rx handler. Hence we don't set DMA_CFG_TXCMB_ENB.
2028 DMA_CFG_RXCMB_ENB | 2315 DMA_CFG_RXCMB_ENB |
2029 ((DMA_CFG_RD_DELAY_CNT_DEFAULT << 2316 ((DMA_CFG_RD_DELAY_CNT_DEFAULT <<
2030 DMA_CFG_RD_DELAY_CNT_SHIFT) & DMA_CFG_RD_DELAY_CNT_MASK) | 2317 DMA_CFG_RD_DELAY_CNT_SHIFT) & DMA_CFG_RD_DELAY_CNT_MASK) |
2031 ((DMA_CFG_WR_DELAY_CNT_DEFAULT << 2318 ((DMA_CFG_WR_DELAY_CNT_DEFAULT <<
2032 DMA_CFG_WR_DELAY_CNT_SHIFT) & DMA_CFG_WR_DELAY_CNT_MASK)); 2319 DMA_CFG_WR_DELAY_CNT_SHIFT) & DMA_CFG_WR_DELAY_CNT_MASK));
2033 } 2320 /*
2034 2321 * Enable CMB/SMB timer.
2035 /* 2322 */
2036 * Enable CMB/SMB timer. 2323 OUTL(atgep, L1E_SMB_STAT_TIMER, 100000);
2037 */ 2324 atge_l1e_clear_stats(atgep);
2038 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 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 */
2039 /* Set CMB/SMB timer and enable them. */ 2376 /* Set CMB/SMB timer and enable them. */
2040 OUTL(atgep, L1_CMB_WR_TIMER, 2377 OUTL(atgep, L1_CMB_WR_TIMER,
2041 ((ATGE_USECS(2) << CMB_WR_TIMER_TX_SHIFT) & 2378 ((ATGE_USECS(2) << CMB_WR_TIMER_TX_SHIFT) &
2042 CMB_WR_TIMER_TX_MASK) | 2379 CMB_WR_TIMER_TX_MASK) |
2043 ((ATGE_USECS(2) << CMB_WR_TIMER_RX_SHIFT) & 2380 ((ATGE_USECS(2) << CMB_WR_TIMER_RX_SHIFT) &
2045 2382
2046 /* Request SMB updates for every seconds. */ 2383 /* Request SMB updates for every seconds. */
2047 OUTL(atgep, L1_SMB_TIMER, ATGE_USECS(1000 * 1000)); 2384 OUTL(atgep, L1_SMB_TIMER, ATGE_USECS(1000 * 1000));
2048 OUTL(atgep, L1_CSMB_CTRL, 2385 OUTL(atgep, L1_CSMB_CTRL,
2049 CSMB_CTRL_SMB_ENB | CSMB_CTRL_CMB_ENB); 2386 CSMB_CTRL_SMB_ENB | CSMB_CTRL_CMB_ENB);
2050 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 2387 break;
2051 OUTL(atgep, L1E_SMB_STAT_TIMER, 100000); 2388 case ATGE_CHIP_L1C:
2052 atge_l1e_clear_stats(atgep); 2389 /* Configure RxQ. */
2053 } 2390 reg =
2054 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 }
2055 2434
2056 /* 2435 /*
2057 * Disable all WOL bits as WOL can interfere normal Rx 2436 * Disable all WOL bits as WOL can interfere normal Rx
2058 * operation. 2437 * operation.
2059 */ 2438 */
2070 reg = (ATGE_CFG_TX_CRC_ENB | ATGE_CFG_TX_AUTO_PAD | 2449 reg = (ATGE_CFG_TX_CRC_ENB | ATGE_CFG_TX_AUTO_PAD |
2071 ATGE_CFG_FULL_DUPLEX | 2450 ATGE_CFG_FULL_DUPLEX |
2072 ((ATGE_CFG_PREAMBLE_DEFAULT << ATGE_CFG_PREAMBLE_SHIFT) & 2451 ((ATGE_CFG_PREAMBLE_DEFAULT << ATGE_CFG_PREAMBLE_SHIFT) &
2073 ATGE_CFG_PREAMBLE_MASK)); 2452 ATGE_CFG_PREAMBLE_MASK));
2074 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
2075 if ((atgep->atge_flags & ATGE_FLAG_FASTETHER) != 0) { 2470 if ((atgep->atge_flags & ATGE_FLAG_FASTETHER) != 0) {
2076 reg |= ATGE_CFG_SPEED_10_100; 2471 reg |= ATGE_CFG_SPEED_10_100;
2077 ATGE_DB(("%s: %s() Fast Ethernet", atgep->atge_name, __func__)); 2472 ATGE_DB(("%s: %s() Fast Ethernet", atgep->atge_name, __func__));
2078 } else { 2473 } else {
2079 reg |= ATGE_CFG_SPEED_1000; 2474 reg |= ATGE_CFG_SPEED_1000;
2080 ATGE_DB(("%s: %s() 1G speed", atgep->atge_name, __func__)); 2475 ATGE_DB(("%s: %s() 1G speed", atgep->atge_name, __func__));
2081 } 2476 }
2477 switch (ATGE_MODEL(atgep)) {
2478 case ATGE_CHIP_L1C:
2479 reg |= L1C_CFG_SINGLE_PAUSE_ENB;
2480 break;
2481 }
2082 2482
2083 OUTL(atgep, ATGE_MAC_CFG, reg); 2483 OUTL(atgep, ATGE_MAC_CFG, reg);
2084 2484
2085 atgep->atge_chip_state |= ATGE_CHIP_RUNNING; 2485 atgep->atge_chip_state |= ATGE_CHIP_RUNNING;
2086 2486
2090 atge_rxfilter(atgep); 2490 atge_rxfilter(atgep);
2091 2491
2092 /* 2492 /*
2093 * Acknowledge all pending interrupts and clear it. 2493 * Acknowledge all pending interrupts and clear it.
2094 */ 2494 */
2095 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 2495 switch (ATGE_MODEL(atgep)) {
2096 OUTL(atgep, ATGE_INTR_STATUS, 0); 2496 case ATGE_CHIP_L1E:
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); 2497 OUTL(atgep, ATGE_INTR_MASK, L1E_INTRS);
2100 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF); 2498 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF);
2101 OUTL(atgep, ATGE_INTR_STATUS, 0); 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;
2102 } 2506 }
2103 2507
2104 atge_mac_config(atgep); 2508 atge_mac_config(atgep);
2105 2509
2106 ATGE_DB(("%s: %s() device started", atgep->atge_name, __func__)); 2510 ATGE_DB(("%s: %s() device started", atgep->atge_name, __func__));
2192 } 2596 }
2193 2597
2194 /* 2598 /*
2195 * Collect stats for L1E. L1 chip's stats are collected by interrupt. 2599 * Collect stats for L1E. L1 chip's stats are collected by interrupt.
2196 */ 2600 */
2197 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 2601 switch (ATGE_MODEL(atgep)) {
2602 case ATGE_CHIP_L1E:
2198 atge_l1e_gather_stats(atgep); 2603 atge_l1e_gather_stats(atgep);
2604 break;
2605 case ATGE_CHIP_L1:
2606 case ATGE_CHIP_L1C:
2607 break;
2199 } 2608 }
2200 2609
2201 /* 2610 /*
2202 * Disable interrupts. 2611 * Disable interrupts.
2203 */ 2612 */
2204 atge_disable_intrs(atgep); 2613 atge_disable_intrs(atgep);
2205 2614
2206 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) 2615 switch (ATGE_MODEL(atgep)) {
2207 OUTL(atgep, L1_CSMB_CTRL, 0); 2616 case ATGE_CHIP_L1E:
2208 2617 /* Clear CTRL not required. */
2209 /* Stop DMA Engine */ 2618 /* Stop DMA Engine not required. */
2210 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 2619 /*
2211 atge_l1_stop_tx_mac(atgep); 2620 * Disable queue processing.
2212 atge_l1_stop_rx_mac(atgep); 2621 */
2213 2622 /* Stop TxQ */
2214 reg = INL(atgep, ATGE_DMA_CFG); 2623 reg = INL(atgep, ATGE_TXQ_CFG);
2215 reg &= ~(DMA_CFG_RD_ENB | DMA_CFG_WR_ENB); 2624 reg = reg & ~TXQ_CFG_ENB;
2216 OUTL(atgep, ATGE_DMA_CFG, reg); 2625 OUTL(atgep, ATGE_TXQ_CFG, reg);
2217 2626 /* Stop RxQ */
2218 } 2627 reg = INL(atgep, ATGE_RXQ_CFG);
2219 2628 reg = reg & ~RXQ_CFG_ENB;
2220 /* 2629 OUTL(atgep, ATGE_RXQ_CFG, reg);
2221 * Disable queue processing. 2630 /* Stop DMA */
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); 2631 reg = INL(atgep, ATGE_DMA_CFG);
2235 reg = reg & ~(DMA_CFG_TXCMB_ENB | DMA_CFG_RXCMB_ENB); 2632 reg = reg & ~(DMA_CFG_TXCMB_ENB | DMA_CFG_RXCMB_ENB);
2236 OUTL(atgep, ATGE_DMA_CFG, reg); 2633 OUTL(atgep, ATGE_DMA_CFG, reg);
2237 drv_usecwait(1000); 2634 drv_usecwait(1000);
2238 atge_l1e_stop_mac(atgep); 2635 atge_l1e_stop_mac(atgep);
2239 OUTL(atgep, ATGE_INTR_STATUS, 0xFFFFFFFF); 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;
2240 } 2679 }
2241 2680
2242 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) { 2681 for (t = ATGE_RESET_TIMEOUT; t > 0; t--) {
2243 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0) 2682 if ((reg = INL(atgep, ATGE_IDLE_STATUS)) == 0)
2244 break; 2683 break;
2259 } 2698 }
2260 2699
2261 void 2700 void
2262 atge_device_init(atge_t *atgep) 2701 atge_device_init(atge_t *atgep)
2263 { 2702 {
2264 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 2703 switch (ATGE_MODEL(atgep)) {
2704 case ATGE_CHIP_L1E:
2265 atgep->atge_intrs = L1E_INTRS; 2705 atgep->atge_intrs = L1E_INTRS;
2266 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT; 2706 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2267 2707
2268 atge_l1e_init_tx_ring(atgep); 2708 atge_l1e_init_tx_ring(atgep);
2269 atge_l1e_init_rx_pages(atgep); 2709 atge_l1e_init_rx_pages(atgep);
2270 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 2710 break;
2711 case ATGE_CHIP_L1:
2271 atgep->atge_intrs = L1_INTRS | INTR_GPHY | INTR_PHY_LINK_DOWN | 2712 atgep->atge_intrs = L1_INTRS | INTR_GPHY | INTR_PHY_LINK_DOWN |
2272 INTR_LINK_CHG; 2713 INTR_LINK_CHG;
2273 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT; 2714 atgep->atge_int_mod = ATGE_IM_TIMER_DEFAULT;
2274 2715
2275 atge_l1_init_tx_ring(atgep); 2716 atge_l1_init_tx_ring(atgep);
2276 atge_l1_init_rx_ring(atgep); 2717 atge_l1_init_rx_ring(atgep);
2277 atge_l1_init_rr_ring(atgep); 2718 atge_l1_init_rr_ring(atgep);
2278 atge_l1_init_cmb(atgep); 2719 atge_l1_init_cmb(atgep);
2279 atge_l1_init_smb(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;
2280 } 2737 }
2281 } 2738 }
2282 2739
2283 void 2740 void
2284 atge_device_restart(atge_t *atgep) 2741 atge_device_restart(atge_t *atgep)
2309 } 2766 }
2310 2767
2311 static int 2768 static int
2312 atge_send_a_packet(atge_t *atgep, mblk_t *mp) 2769 atge_send_a_packet(atge_t *atgep, mblk_t *mp)
2313 { 2770 {
2314 atge_tx_desc_t *txd;
2315 uchar_t *c; 2771 uchar_t *c;
2316 uint32_t cflags = 0; 2772 uint32_t cflags = 0;
2317 atge_ring_t *r; 2773 atge_ring_t *r;
2318 size_t pktlen; 2774 size_t pktlen;
2319 uchar_t *buf; 2775 uchar_t *buf;
2359 mcopymsg(mp, buf); 2815 mcopymsg(mp, buf);
2360 2816
2361 r->r_avail_desc--; 2817 r->r_avail_desc--;
2362 2818
2363 c = (uchar_t *)r->r_desc_ring->addr; 2819 c = (uchar_t *)r->r_desc_ring->addr;
2364 c += (sizeof (atge_tx_desc_t) * start); 2820 switch (ATGE_MODEL(atgep)) {
2365 txd = (atge_tx_desc_t *)c; 2821 case ATGE_CHIP_L1C:
2366 2822 {
2367 ATGE_PUT64(r->r_desc_ring, &txd->addr, 2823 l1c_tx_desc_t *txd;
2368 r->r_buf_tbl[start]->cookie.dmac_laddress); 2824
2369 2825 c += (sizeof (l1c_tx_desc_t) * start);
2370 ATGE_PUT32(r->r_desc_ring, &txd->len, ATGE_TX_BYTES(pktlen)); 2826 txd = (l1c_tx_desc_t *)c;
2371 2827
2372 cflags |= ATGE_TD_EOP; 2828 ATGE_PUT64(r->r_desc_ring, &txd->addr,
2373 ATGE_PUT32(r->r_desc_ring, &txd->flags, cflags); 2829 r->r_buf_tbl[start]->cookie.dmac_laddress);
2374 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 }
2375 /* 2854 /*
2376 * Sync buffer first. 2855 * Sync buffer first.
2377 */ 2856 */
2378 DMA_SYNC(r->r_buf_tbl[start], 0, pktlen, DDI_DMA_SYNC_FORDEV); 2857 DMA_SYNC(r->r_buf_tbl[start], 0, pktlen, DDI_DMA_SYNC_FORDEV);
2379 2858
2388 DMA_SYNC(r->r_desc_ring, 0, ATGE_TX_RING_SZ, DDI_DMA_SYNC_FORDEV); 2867 DMA_SYNC(r->r_desc_ring, 0, ATGE_TX_RING_SZ, DDI_DMA_SYNC_FORDEV);
2389 2868
2390 /* 2869 /*
2391 * Program TX descriptor to send a packet. 2870 * Program TX descriptor to send a packet.
2392 */ 2871 */
2393 if (ATGE_MODEL(atgep) == ATGE_CHIP_L1E) { 2872 switch (ATGE_MODEL(atgep)) {
2873 case ATGE_CHIP_L1E:
2394 atge_l1e_send_packet(r); 2874 atge_l1e_send_packet(r);
2395 } else if (ATGE_MODEL(atgep) == ATGE_CHIP_L1) { 2875 break;
2876 case ATGE_CHIP_L1:
2396 atge_l1_send_packet(r); 2877 atge_l1_send_packet(r);
2878 break;
2879 case ATGE_CHIP_L1C:
2880 atge_l1c_send_packet(r);
2881 break;
2397 } 2882 }
2398 2883
2399 r->r_atge->atge_opackets++; 2884 r->r_atge->atge_opackets++;
2400 r->r_atge->atge_obytes += pktlen; 2885 r->r_atge->atge_obytes += pktlen;
2401 2886