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