if_tlp_pci.c revision 1.39.2.4
1 /* $NetBSD: if_tlp_pci.c,v 1.39.2.4 2000/07/16 20:29:08 tron Exp $ */ 2 3 /*- 4 * Copyright (c) 1998, 1999, 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * PCI bus front-end for the Digital Semiconductor ``Tulip'' (21x4x) 42 * Ethernet controller family driver. 43 */ 44 45 #include "opt_inet.h" 46 #include "opt_ns.h" 47 #include "bpfilter.h" 48 #include "opt_tlp.h" 49 50 #include <sys/param.h> 51 #include <sys/systm.h> 52 #include <sys/mbuf.h> 53 #include <sys/malloc.h> 54 #include <sys/kernel.h> 55 #include <sys/socket.h> 56 #include <sys/ioctl.h> 57 #include <sys/errno.h> 58 #include <sys/device.h> 59 60 #include <machine/endian.h> 61 62 #include <net/if.h> 63 #include <net/if_dl.h> 64 #include <net/if_media.h> 65 #include <net/if_ether.h> 66 67 #if NBPFILTER > 0 68 #include <net/bpf.h> 69 #endif 70 71 #ifdef INET 72 #include <netinet/in.h> 73 #include <netinet/if_inarp.h> 74 #endif 75 76 #ifdef NS 77 #include <netns/ns.h> 78 #include <netns/ns_if.h> 79 #endif 80 81 #include <machine/bus.h> 82 #include <machine/intr.h> 83 84 #include <dev/mii/miivar.h> 85 #include <dev/mii/mii_bitbang.h> 86 87 #include <dev/ic/tulipreg.h> 88 #include <dev/ic/tulipvar.h> 89 90 #include <dev/pci/pcivar.h> 91 #include <dev/pci/pcireg.h> 92 #include <dev/pci/pcidevs.h> 93 94 /* 95 * PCI configuration space registers used by the Tulip. 96 */ 97 #define TULIP_PCI_IOBA 0x10 /* i/o mapped base */ 98 #define TULIP_PCI_MMBA 0x14 /* memory mapped base */ 99 #define TULIP_PCI_CFDA 0x40 /* configuration driver area */ 100 101 #define CFDA_SLEEP 0x80000000 /* sleep mode */ 102 #define CFDA_SNOOZE 0x40000000 /* snooze mode */ 103 104 struct tulip_pci_softc { 105 struct tulip_softc sc_tulip; /* real Tulip softc */ 106 107 /* PCI-specific goo. */ 108 void *sc_ih; /* interrupt handle */ 109 110 pci_chipset_tag_t sc_pc; /* our PCI chipset */ 111 pcitag_t sc_pcitag; /* our PCI tag */ 112 113 int sc_flags; /* flags; see below */ 114 115 LIST_HEAD(, tulip_pci_softc) sc_intrslaves; 116 LIST_ENTRY(tulip_pci_softc) sc_intrq; 117 118 /* Our {ROM,interrupt} master. */ 119 struct tulip_pci_softc *sc_master; 120 }; 121 122 /* sc_flags */ 123 #define TULIP_PCI_SHAREDINTR 0x01 /* interrupt is shared */ 124 #define TULIP_PCI_SLAVEINTR 0x02 /* interrupt is slave */ 125 #define TULIP_PCI_SHAREDROM 0x04 /* ROM is shared */ 126 #define TULIP_PCI_SLAVEROM 0x08 /* slave of shared ROM */ 127 128 int tlp_pci_match __P((struct device *, struct cfdata *, void *)); 129 void tlp_pci_attach __P((struct device *, struct device *, void *)); 130 131 struct cfattach tlp_pci_ca = { 132 sizeof(struct tulip_pci_softc), tlp_pci_match, tlp_pci_attach, 133 }; 134 135 const struct tulip_pci_product { 136 u_int32_t tpp_vendor; /* PCI vendor ID */ 137 u_int32_t tpp_product; /* PCI product ID */ 138 tulip_chip_t tpp_chip; /* base Tulip chip type */ 139 } tlp_pci_products[] = { 140 #ifdef TLP_MATCH_21040 141 { PCI_VENDOR_DEC, PCI_PRODUCT_DEC_21040, 142 TULIP_CHIP_21040 }, 143 #endif 144 #ifdef TLP_MATCH_21041 145 { PCI_VENDOR_DEC, PCI_PRODUCT_DEC_21041, 146 TULIP_CHIP_21041 }, 147 #endif 148 #ifdef TLP_MATCH_21140 149 { PCI_VENDOR_DEC, PCI_PRODUCT_DEC_21140, 150 TULIP_CHIP_21140 }, 151 #endif 152 #ifdef TLP_MATCH_21142 153 { PCI_VENDOR_DEC, PCI_PRODUCT_DEC_21142, 154 TULIP_CHIP_21142 }, 155 #endif 156 157 { PCI_VENDOR_LITEON, PCI_PRODUCT_LITEON_82C168, 158 TULIP_CHIP_82C168 }, 159 160 /* 161 * Note: This is like a MX98725 with Wake-On-LAN and a 162 * 128-bit multicast hash table. 163 */ 164 { PCI_VENDOR_LITEON, PCI_PRODUCT_LITEON_82C115, 165 TULIP_CHIP_82C115 }, 166 167 { PCI_VENDOR_MACRONIX, PCI_PRODUCT_MACRONIX_MX98713, 168 TULIP_CHIP_MX98713 }, 169 { PCI_VENDOR_MACRONIX, PCI_PRODUCT_MACRONIX_MX987x5, 170 TULIP_CHIP_MX98715 }, 171 172 { PCI_VENDOR_COMPEX, PCI_PRODUCT_COMPEX_RL100TX, 173 TULIP_CHIP_MX98713 }, 174 175 { PCI_VENDOR_WINBOND, PCI_PRODUCT_WINBOND_W89C840F, 176 TULIP_CHIP_WB89C840F }, 177 { PCI_VENDOR_COMPEX, PCI_PRODUCT_COMPEX_RL100ATX, 178 TULIP_CHIP_WB89C840F }, 179 180 { PCI_VENDOR_DAVICOM, PCI_PRODUCT_DAVICOM_DM9102, 181 TULIP_CHIP_DM9102 }, 182 183 { PCI_VENDOR_ADMTEK, PCI_PRODUCT_ADMTEK_AL981, 184 TULIP_CHIP_AL981 }, 185 186 #if 0 187 { PCI_VENDOR_ASIX, PCI_PRODUCT_ASIX_AX88140A, 188 TULIP_CHIP_AX88140 }, 189 #endif 190 191 { 0, 0, 192 TULIP_CHIP_INVALID }, 193 }; 194 195 struct tlp_pci_quirks { 196 void (*tpq_func) __P((struct tulip_pci_softc *, 197 const u_int8_t *)); 198 u_int8_t tpq_oui[3]; 199 }; 200 201 void tlp_pci_dec_quirks __P((struct tulip_pci_softc *, 202 const u_int8_t *)); 203 204 void tlp_pci_znyx_21040_quirks __P((struct tulip_pci_softc *, 205 const u_int8_t *)); 206 void tlp_pci_smc_21040_quirks __P((struct tulip_pci_softc *, 207 const u_int8_t *)); 208 void tlp_pci_cogent_21040_quirks __P((struct tulip_pci_softc *, 209 const u_int8_t *)); 210 void tlp_pci_accton_21040_quirks __P((struct tulip_pci_softc *, 211 const u_int8_t *)); 212 213 void tlp_pci_cobalt_21142_quirks __P((struct tulip_pci_softc *, 214 const u_int8_t *)); 215 216 const struct tlp_pci_quirks tlp_pci_21040_quirks[] = { 217 { tlp_pci_znyx_21040_quirks, { 0x00, 0xc0, 0x95 } }, 218 { tlp_pci_smc_21040_quirks, { 0x00, 0x00, 0xc0 } }, 219 { tlp_pci_cogent_21040_quirks, { 0x00, 0x00, 0x92 } }, 220 { tlp_pci_accton_21040_quirks, { 0x00, 0x00, 0xe8 } }, 221 { NULL, { 0, 0, 0 } } 222 }; 223 224 const struct tlp_pci_quirks tlp_pci_21041_quirks[] = { 225 { tlp_pci_dec_quirks, { 0x08, 0x00, 0x2b } }, 226 { tlp_pci_dec_quirks, { 0x00, 0x00, 0xf8 } }, 227 { NULL, { 0, 0, 0 } } 228 }; 229 230 void tlp_pci_asante_21140_quirks __P((struct tulip_pci_softc *, 231 const u_int8_t *)); 232 233 const struct tlp_pci_quirks tlp_pci_21140_quirks[] = { 234 { tlp_pci_dec_quirks, { 0x08, 0x00, 0x2b } }, 235 { tlp_pci_dec_quirks, { 0x00, 0x00, 0xf8 } }, 236 { tlp_pci_asante_21140_quirks, { 0x00, 0x00, 0x94 } }, 237 { NULL, { 0, 0, 0 } } 238 }; 239 240 const struct tlp_pci_quirks tlp_pci_21142_quirks[] = { 241 { tlp_pci_dec_quirks, { 0x08, 0x00, 0x2b } }, 242 { tlp_pci_dec_quirks, { 0x00, 0x00, 0xf8 } }, 243 { tlp_pci_cobalt_21142_quirks, { 0x00, 0x10, 0xe0 } }, 244 { NULL, { 0, 0, 0 } } 245 }; 246 247 int tlp_pci_shared_intr __P((void *)); 248 249 const struct tulip_pci_product *tlp_pci_lookup 250 __P((const struct pci_attach_args *)); 251 void tlp_pci_get_quirks __P((struct tulip_pci_softc *, const u_int8_t *, 252 const struct tlp_pci_quirks *)); 253 void tlp_pci_check_slaved __P((struct tulip_pci_softc *, int, int)); 254 255 const struct tulip_pci_product * 256 tlp_pci_lookup(pa) 257 const struct pci_attach_args *pa; 258 { 259 const struct tulip_pci_product *tpp; 260 261 for (tpp = tlp_pci_products; 262 tlp_chip_names[tpp->tpp_chip] != NULL; 263 tpp++) { 264 if (PCI_VENDOR(pa->pa_id) == tpp->tpp_vendor && 265 PCI_PRODUCT(pa->pa_id) == tpp->tpp_product) 266 return (tpp); 267 } 268 return (NULL); 269 } 270 271 void 272 tlp_pci_get_quirks(psc, enaddr, tpq) 273 struct tulip_pci_softc *psc; 274 const u_int8_t *enaddr; 275 const struct tlp_pci_quirks *tpq; 276 { 277 278 for (; tpq->tpq_func != NULL; tpq++) { 279 if (tpq->tpq_oui[0] == enaddr[0] && 280 tpq->tpq_oui[1] == enaddr[1] && 281 tpq->tpq_oui[2] == enaddr[2]) { 282 (*tpq->tpq_func)(psc, enaddr); 283 return; 284 } 285 } 286 } 287 288 void 289 tlp_pci_check_slaved(psc, shared, slaved) 290 struct tulip_pci_softc *psc; 291 int shared, slaved; 292 { 293 extern struct cfdriver tlp_cd; 294 struct tulip_pci_softc *cur, *best = NULL; 295 struct tulip_softc *sc = &psc->sc_tulip; 296 int i; 297 298 /* 299 * First of all, find the lowest pcidev numbered device on our 300 * bus marked as shared. That should be our master. 301 */ 302 for (i = 0; i < tlp_cd.cd_ndevs; i++) { 303 if ((cur = tlp_cd.cd_devs[i]) == NULL) 304 continue; 305 if (cur->sc_tulip.sc_dev.dv_parent != sc->sc_dev.dv_parent) 306 continue; 307 if ((cur->sc_flags & shared) == 0) 308 continue; 309 if (cur == psc) 310 continue; 311 if (best == NULL || 312 best->sc_tulip.sc_devno > cur->sc_tulip.sc_devno) 313 best = cur; 314 } 315 316 if (best != NULL) { 317 psc->sc_master = best; 318 psc->sc_flags |= (shared | slaved); 319 } 320 } 321 322 int 323 tlp_pci_match(parent, match, aux) 324 struct device *parent; 325 struct cfdata *match; 326 void *aux; 327 { 328 struct pci_attach_args *pa = aux; 329 330 if (tlp_pci_lookup(pa) != NULL) 331 return (10); /* beat if_de.c */ 332 333 return (0); 334 } 335 336 void 337 tlp_pci_attach(parent, self, aux) 338 struct device *parent, *self; 339 void *aux; 340 { 341 struct tulip_pci_softc *psc = (void *) self; 342 struct tulip_softc *sc = &psc->sc_tulip; 343 struct pci_attach_args *pa = aux; 344 pci_chipset_tag_t pc = pa->pa_pc; 345 pci_intr_handle_t ih; 346 const char *intrstr = NULL; 347 bus_space_tag_t iot, memt; 348 bus_space_handle_t ioh, memh; 349 int ioh_valid, memh_valid, i, j; 350 const struct tulip_pci_product *tpp; 351 u_int8_t enaddr[ETHER_ADDR_LEN]; 352 u_int32_t val; 353 pcireg_t reg; 354 int pmreg; 355 356 sc->sc_devno = pa->pa_device; 357 psc->sc_pc = pa->pa_pc; 358 psc->sc_pcitag = pa->pa_tag; 359 360 LIST_INIT(&psc->sc_intrslaves); 361 362 tpp = tlp_pci_lookup(pa); 363 if (tpp == NULL) { 364 printf("\n"); 365 panic("tlp_pci_attach: impossible"); 366 } 367 sc->sc_chip = tpp->tpp_chip; 368 369 /* 370 * By default, Tulip registers are 8 bytes long (4 bytes 371 * followed by a 4 byte pad). 372 */ 373 sc->sc_regshift = 3; 374 375 /* 376 * No power management hooks. 377 * XXX Maybe we should add some! 378 */ 379 sc->sc_flags |= TULIPF_ENABLED; 380 381 /* 382 * Get revision info, and set some chip-specific variables. 383 */ 384 sc->sc_rev = PCI_REVISION(pa->pa_class); 385 switch (sc->sc_chip) { 386 case TULIP_CHIP_21140: 387 if (sc->sc_rev >= 0x20) 388 sc->sc_chip = TULIP_CHIP_21140A; 389 break; 390 391 case TULIP_CHIP_21142: 392 if (sc->sc_rev >= 0x20) 393 sc->sc_chip = TULIP_CHIP_21143; 394 break; 395 396 case TULIP_CHIP_82C168: 397 if (sc->sc_rev >= 0x20) 398 sc->sc_chip = TULIP_CHIP_82C169; 399 break; 400 401 case TULIP_CHIP_MX98713: 402 if (sc->sc_rev >= 0x10) 403 sc->sc_chip = TULIP_CHIP_MX98713A; 404 break; 405 406 case TULIP_CHIP_MX98715: 407 if (sc->sc_rev >= 0x20) 408 sc->sc_chip = TULIP_CHIP_MX98715A; 409 if (sc->sc_rev >= 0x30) 410 sc->sc_chip = TULIP_CHIP_MX98725; 411 break; 412 413 case TULIP_CHIP_WB89C840F: 414 sc->sc_regshift = 2; 415 break; 416 417 case TULIP_CHIP_AX88140: 418 if (sc->sc_rev >= 0x10) 419 sc->sc_chip = TULIP_CHIP_AX88141; 420 break; 421 422 case TULIP_CHIP_DM9102: 423 if (sc->sc_rev >= 0x30) 424 sc->sc_chip = TULIP_CHIP_DM9102A; 425 break; 426 427 default: 428 /* Nothing. */ 429 } 430 431 printf(": %s Ethernet, pass %d.%d\n", 432 tlp_chip_names[sc->sc_chip], 433 (sc->sc_rev >> 4) & 0xf, sc->sc_rev & 0xf); 434 435 switch (sc->sc_chip) { 436 case TULIP_CHIP_21040: 437 if (sc->sc_rev < 0x20) { 438 printf("%s: 21040 must be at least pass 2.0\n", 439 sc->sc_dev.dv_xname); 440 return; 441 } 442 break; 443 444 case TULIP_CHIP_21140: 445 if (sc->sc_rev < 0x11) { 446 printf("%s: 21140 must be at least pass 1.1\n", 447 sc->sc_dev.dv_xname); 448 return; 449 } 450 break; 451 452 default: 453 /* Nothing. */ 454 } 455 456 /* 457 * Check to see if the device is in power-save mode, and 458 * being it out if necessary. 459 */ 460 switch (sc->sc_chip) { 461 case TULIP_CHIP_21140: 462 case TULIP_CHIP_21140A: 463 case TULIP_CHIP_21142: 464 case TULIP_CHIP_21143: 465 case TULIP_CHIP_MX98713A: 466 case TULIP_CHIP_MX98715: 467 case TULIP_CHIP_MX98715A: 468 case TULIP_CHIP_MX98725: 469 case TULIP_CHIP_DM9102: 470 case TULIP_CHIP_DM9102A: 471 /* 472 * Clear the "sleep mode" bit in the CFDA register. 473 */ 474 reg = pci_conf_read(pc, pa->pa_tag, TULIP_PCI_CFDA); 475 if (reg & (CFDA_SLEEP|CFDA_SNOOZE)) 476 pci_conf_write(pc, pa->pa_tag, TULIP_PCI_CFDA, 477 reg & ~(CFDA_SLEEP|CFDA_SNOOZE)); 478 break; 479 480 default: 481 /* Nothing. */ 482 } 483 484 if (pci_get_capability(pc, pa->pa_tag, PCI_CAP_PWRMGMT, &pmreg, 0)) { 485 reg = pci_conf_read(pc, pa->pa_tag, pmreg + 4); 486 switch (reg & PCI_PMCSR_STATE_MASK) { 487 case PCI_PMCSR_STATE_D1: 488 case PCI_PMCSR_STATE_D2: 489 printf(": waking up from power state D%d\n%s", 490 reg & PCI_PMCSR_STATE_MASK, sc->sc_dev.dv_xname); 491 pci_conf_write(pc, pa->pa_tag, pmreg + 4, 0); 492 break; 493 case PCI_PMCSR_STATE_D3: 494 /* 495 * The card has lost all configuration data in 496 * this state, so punt. 497 */ 498 printf(": unable to wake up from power state D3, " 499 "reboot required.\n"); 500 pci_conf_write(pc, pa->pa_tag, pmreg + 4, 0); 501 return; 502 } 503 } 504 505 /* 506 * Map the device. 507 */ 508 ioh_valid = (pci_mapreg_map(pa, TULIP_PCI_IOBA, 509 PCI_MAPREG_TYPE_IO, 0, 510 &iot, &ioh, NULL, NULL) == 0); 511 memh_valid = (pci_mapreg_map(pa, TULIP_PCI_MMBA, 512 PCI_MAPREG_TYPE_MEM|PCI_MAPREG_MEM_TYPE_32BIT, 0, 513 &memt, &memh, NULL, NULL) == 0); 514 515 if (memh_valid) { 516 sc->sc_st = memt; 517 sc->sc_sh = memh; 518 } else if (ioh_valid) { 519 sc->sc_st = iot; 520 sc->sc_sh = ioh; 521 } else { 522 printf(": unable to map device registers\n"); 523 return; 524 } 525 526 sc->sc_dmat = pa->pa_dmat; 527 528 /* 529 * Make sure bus mastering is enabled. 530 */ 531 pci_conf_write(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 532 pci_conf_read(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG) | 533 PCI_COMMAND_MASTER_ENABLE); 534 535 /* 536 * Get the cacheline size. 537 */ 538 sc->sc_cacheline = PCI_CACHELINE(pci_conf_read(pc, pa->pa_tag, 539 PCI_BHLC_REG)); 540 541 /* 542 * Get PCI data moving command info. 543 */ 544 if (pa->pa_flags & PCI_FLAGS_MRL_OKAY) 545 sc->sc_flags |= TULIPF_MRL; 546 if (pa->pa_flags & PCI_FLAGS_MRM_OKAY) 547 sc->sc_flags |= TULIPF_MRM; 548 if (pa->pa_flags & PCI_FLAGS_MWI_OKAY) 549 sc->sc_flags |= TULIPF_MWI; 550 551 /* 552 * Read the contents of the Ethernet Address ROM/SROM. 553 */ 554 switch (sc->sc_chip) { 555 case TULIP_CHIP_21040: 556 sc->sc_srom_addrbits = 6; 557 sc->sc_srom = malloc(TULIP_ROM_SIZE(6), M_DEVBUF, M_NOWAIT); 558 TULIP_WRITE(sc, CSR_MIIROM, MIIROM_SROMCS); 559 for (i = 0; i < TULIP_ROM_SIZE(6); i++) { 560 for (j = 0; j < 10000; j++) { 561 val = TULIP_READ(sc, CSR_MIIROM); 562 if ((val & MIIROM_DN) == 0) 563 break; 564 } 565 sc->sc_srom[i] = val & MIIROM_DATA; 566 } 567 break; 568 569 case TULIP_CHIP_82C168: 570 case TULIP_CHIP_82C169: 571 { 572 sc->sc_srom_addrbits = 2; 573 sc->sc_srom = malloc(TULIP_ROM_SIZE(2), M_DEVBUF, M_NOWAIT); 574 575 /* 576 * The Lite-On PNIC stores the Ethernet address in 577 * the first 3 words of the EEPROM. EEPROM access 578 * is not like the other Tulip chips. 579 */ 580 for (i = 0; i < 6; i += 2) { 581 TULIP_WRITE(sc, CSR_PNIC_SROMCTL, 582 PNIC_SROMCTL_READ | (i >> 1)); 583 for (j = 0; j < 500; j++) { 584 delay(2); 585 val = TULIP_READ(sc, CSR_MIIROM); 586 if ((val & PNIC_MIIROM_BUSY) == 0) 587 break; 588 } 589 if (val & PNIC_MIIROM_BUSY) { 590 printf("%s: EEPROM timed out\n", 591 sc->sc_dev.dv_xname); 592 return; 593 } 594 val &= PNIC_MIIROM_DATA; 595 sc->sc_srom[i] = val >> 8; 596 sc->sc_srom[i + 1] = val & 0xff; 597 } 598 break; 599 } 600 601 default: 602 if (tlp_read_srom(sc) == 0) 603 goto cant_cope; 604 break; 605 } 606 607 /* 608 * Deal with chip/board quirks. This includes setting up 609 * the mediasw, and extracting the Ethernet address from 610 * the rombuf. 611 */ 612 switch (sc->sc_chip) { 613 case TULIP_CHIP_21040: 614 /* Check for a slaved ROM on a multi-port board. */ 615 tlp_pci_check_slaved(psc, TULIP_PCI_SHAREDROM, 616 TULIP_PCI_SLAVEROM); 617 if (psc->sc_flags & TULIP_PCI_SLAVEROM) 618 memcpy(sc->sc_srom, psc->sc_master->sc_tulip.sc_srom, 619 sizeof(sc->sc_srom)); 620 621 /* 622 * Parse the Ethernet Address ROM. 623 */ 624 if (tlp_parse_old_srom(sc, enaddr) == 0) 625 goto cant_cope; 626 627 /* 628 * If we have a slaved ROM, adjust the Ethernet address. 629 */ 630 if (psc->sc_flags & TULIP_PCI_SLAVEROM) 631 enaddr[5] += 632 sc->sc_devno - psc->sc_master->sc_tulip.sc_devno; 633 634 /* 635 * All 21040 boards start out with the same 636 * media switch. 637 */ 638 sc->sc_mediasw = &tlp_21040_mediasw; 639 640 /* 641 * Deal with any quirks this board might have. 642 */ 643 tlp_pci_get_quirks(psc, enaddr, tlp_pci_21040_quirks); 644 break; 645 646 case TULIP_CHIP_21041: 647 /* Check for a slaved ROM on a multi-port board. */ 648 tlp_pci_check_slaved(psc, TULIP_PCI_SHAREDROM, 649 TULIP_PCI_SLAVEROM); 650 if (psc->sc_flags & TULIP_PCI_SLAVEROM) 651 memcpy(sc->sc_srom, psc->sc_master->sc_tulip.sc_srom, 652 sizeof(sc->sc_srom)); 653 654 /* Check for new format SROM. */ 655 if (tlp_isv_srom_enaddr(sc, enaddr) == 0) { 656 /* 657 * Not an ISV SROM; try the old DEC Ethernet Address 658 * ROM format. 659 */ 660 if (tlp_parse_old_srom(sc, enaddr) == 0) 661 goto cant_cope; 662 } 663 664 /* 665 * All 21041 boards use the same media switch; they all 666 * work basically the same! Yippee! 667 */ 668 sc->sc_mediasw = &tlp_21041_mediasw; 669 670 /* 671 * Deal with any quirks this board might have. 672 */ 673 tlp_pci_get_quirks(psc, enaddr, tlp_pci_21041_quirks); 674 break; 675 676 case TULIP_CHIP_21140: 677 case TULIP_CHIP_21140A: 678 /* Check for new format SROM. */ 679 if (tlp_isv_srom_enaddr(sc, enaddr) == 0) { 680 /* 681 * Not an ISV SROM; try the old DEC Ethernet Address 682 * ROM format. 683 */ 684 if (tlp_parse_old_srom(sc, enaddr) == 0) 685 goto cant_cope; 686 } else { 687 /* 688 * We start out with the 2114x ISV media switch. 689 * When we search for quirks, we may change to 690 * a different switch. 691 */ 692 sc->sc_mediasw = &tlp_2114x_isv_mediasw; 693 } 694 695 /* 696 * Deal with any quirks this board might have. 697 */ 698 tlp_pci_get_quirks(psc, enaddr, tlp_pci_21140_quirks); 699 700 /* 701 * Bail out now if we can't deal with this board. 702 */ 703 if (sc->sc_mediasw == NULL) 704 goto cant_cope; 705 break; 706 707 case TULIP_CHIP_21142: 708 case TULIP_CHIP_21143: 709 /* Check for new format SROM. */ 710 if (tlp_isv_srom_enaddr(sc, enaddr) == 0) { 711 /* 712 * Not an ISV SROM; try the old DEC Ethernet Address 713 * ROM format. 714 */ 715 if (tlp_parse_old_srom(sc, enaddr) == 0) 716 goto cant_cope; 717 } else { 718 /* 719 * We start out with the 2114x ISV media switch. 720 * When we search for quirks, we may change to 721 * a different switch. 722 */ 723 sc->sc_mediasw = &tlp_2114x_isv_mediasw; 724 } 725 726 /* 727 * Deal with any quirks this board might have. 728 */ 729 tlp_pci_get_quirks(psc, enaddr, tlp_pci_21142_quirks); 730 731 /* 732 * Bail out now if we can't deal with this board. 733 */ 734 if (sc->sc_mediasw == NULL) 735 goto cant_cope; 736 break; 737 738 case TULIP_CHIP_82C168: 739 case TULIP_CHIP_82C169: 740 /* 741 * Lite-On PNIC's Ethernet address is the first 6 742 * bytes of its EEPROM. 743 */ 744 memcpy(enaddr, sc->sc_srom, ETHER_ADDR_LEN); 745 746 /* 747 * Lite-On PNICs always use the same mediasw; we 748 * select MII vs. internal NWAY automatically. 749 */ 750 sc->sc_mediasw = &tlp_pnic_mediasw; 751 break; 752 753 case TULIP_CHIP_MX98713: 754 /* 755 * The Macronix MX98713 has an MII and GPIO, but no 756 * internal Nway block. This chip is basically a 757 * perfect 21140A clone, with the exception of the 758 * a magic register frobbing in order to make the 759 * interface function. 760 */ 761 if (tlp_isv_srom_enaddr(sc, enaddr)) { 762 sc->sc_mediasw = &tlp_2114x_isv_mediasw; 763 break; 764 } 765 /* FALLTHROUGH */ 766 767 case TULIP_CHIP_82C115: 768 /* 769 * Yippee! The Lite-On 82C115 is a clone of 770 * the MX98725 (the data sheet even says `MXIC' 771 * on it)! Imagine that, a clone of a clone. 772 * 773 * The differences are really minimal: 774 * 775 * - Wake-On-LAN support 776 * - 128-bit multicast hash table, rather than 777 * the standard 512-bit hash table 778 */ 779 /* FALLTHROUGH */ 780 781 case TULIP_CHIP_MX98713A: 782 case TULIP_CHIP_MX98715A: 783 case TULIP_CHIP_MX98725: 784 /* 785 * The MX98713A has an MII as well as an internal Nway block, 786 * but no GPIO. The MX98715 and MX98725 have an internal 787 * Nway block only. 788 * 789 * The internal Nway block, unlike the Lite-On PNIC's, does 790 * just that - performs Nway. Once autonegotiation completes, 791 * we must program the GPR media information into the chip. 792 * 793 * The byte offset of the Ethernet address is stored at 794 * offset 0x70. 795 */ 796 memcpy(enaddr, &sc->sc_srom[sc->sc_srom[0x70]], ETHER_ADDR_LEN); 797 sc->sc_mediasw = &tlp_pmac_mediasw; 798 break; 799 800 case TULIP_CHIP_WB89C840F: 801 /* 802 * Winbond 89C840F's Ethernet address is the first 803 * 6 bytes of its EEPROM. 804 */ 805 memcpy(enaddr, sc->sc_srom, ETHER_ADDR_LEN); 806 807 /* 808 * Winbond 89C840F has an MII attached to the SIO. 809 */ 810 sc->sc_mediasw = &tlp_sio_mii_mediasw; 811 break; 812 813 case TULIP_CHIP_AL981: 814 /* 815 * The ADMtek AL981's Ethernet address is located 816 * at offset 8 of its EEPROM. 817 */ 818 memcpy(enaddr, &sc->sc_srom[8], ETHER_ADDR_LEN); 819 820 /* 821 * ADMtek AL981 has a built-in PHY accessed through 822 * special registers. 823 */ 824 sc->sc_mediasw = &tlp_al981_mediasw; 825 break; 826 827 case TULIP_CHIP_DM9102: 828 case TULIP_CHIP_DM9102A: 829 /* 830 * Some boards with the Davicom chip have an ISV 831 * SROM (mostly DM9102A boards -- trying to describe 832 * the HomePNA PHY, probably) although the data in 833 * them is generally wrong. Check for ISV format 834 * and grab the Ethernet address that way, and if 835 * that fails, fall back on grabbing it from an 836 * observed offset of 20 (which is where it would 837 * be in an ISV SROM anyhow, tho ISV can cope with 838 * multi-port boards). 839 */ 840 if (tlp_isv_srom_enaddr(sc, enaddr)) 841 memcpy(enaddr, &sc->sc_srom[20], ETHER_ADDR_LEN); 842 843 /* 844 * Davicom chips all have an internal MII interface 845 * and a built-in PHY. DM9102A also has a an external 846 * MII interface, usually with a HomePNA PHY attached 847 * to it. 848 */ 849 sc->sc_mediasw = &tlp_dm9102_mediasw; 850 break; 851 852 default: 853 cant_cope: 854 printf("%s: sorry, unable to handle your board\n", 855 sc->sc_dev.dv_xname); 856 return; 857 } 858 859 /* 860 * Handle shared interrupts. 861 */ 862 if (psc->sc_flags & TULIP_PCI_SHAREDINTR) { 863 if (psc->sc_master) 864 psc->sc_flags |= TULIP_PCI_SLAVEINTR; 865 else { 866 tlp_pci_check_slaved(psc, TULIP_PCI_SHAREDINTR, 867 TULIP_PCI_SLAVEINTR); 868 if (psc->sc_master == NULL) 869 psc->sc_master = psc; 870 } 871 LIST_INSERT_HEAD(&psc->sc_master->sc_intrslaves, 872 psc, sc_intrq); 873 } 874 875 if (psc->sc_flags & TULIP_PCI_SLAVEINTR) { 876 printf("%s: sharing interrupt with %s\n", 877 sc->sc_dev.dv_xname, 878 psc->sc_master->sc_tulip.sc_dev.dv_xname); 879 } else { 880 /* 881 * Map and establish our interrupt. 882 */ 883 if (pci_intr_map(pc, pa->pa_intrtag, pa->pa_intrpin, 884 pa->pa_intrline, &ih)) { 885 printf("%s: unable to map interrupt\n", 886 sc->sc_dev.dv_xname); 887 return; 888 } 889 intrstr = pci_intr_string(pc, ih); 890 psc->sc_ih = pci_intr_establish(pc, ih, IPL_NET, 891 (psc->sc_flags & TULIP_PCI_SHAREDINTR) ? 892 tlp_pci_shared_intr : tlp_intr, sc); 893 if (psc->sc_ih == NULL) { 894 printf("%s: unable to establish interrupt", 895 sc->sc_dev.dv_xname); 896 if (intrstr != NULL) 897 printf(" at %s", intrstr); 898 printf("\n"); 899 return; 900 } 901 printf("%s: interrupting at %s\n", sc->sc_dev.dv_xname, 902 intrstr); 903 } 904 905 /* 906 * Finish off the attach. 907 */ 908 tlp_attach(sc, enaddr); 909 } 910 911 int 912 tlp_pci_shared_intr(arg) 913 void *arg; 914 { 915 struct tulip_pci_softc *master = arg, *slave; 916 int rv = 0; 917 918 for (slave = LIST_FIRST(&master->sc_intrslaves); 919 slave != NULL; 920 slave = LIST_NEXT(slave, sc_intrq)) 921 rv |= tlp_intr(&slave->sc_tulip); 922 923 return (rv); 924 } 925 926 void 927 tlp_pci_dec_quirks(psc, enaddr) 928 struct tulip_pci_softc *psc; 929 const u_int8_t *enaddr; 930 { 931 struct tulip_softc *sc = &psc->sc_tulip; 932 933 /* 934 * This isn't really a quirk-gathering device, really. We 935 * just want to get the spiffy DEC board name from the SROM. 936 */ 937 strcpy(sc->sc_name, "DEC "); 938 939 if (memcmp(&sc->sc_srom[29], "DE500", 5) == 0 || 940 memcmp(&sc->sc_srom[29], "DE450", 5) == 0) 941 memcpy(&sc->sc_name[4], &sc->sc_srom[29], 8); 942 } 943 944 void 945 tlp_pci_znyx_21040_quirks(psc, enaddr) 946 struct tulip_pci_softc *psc; 947 const u_int8_t *enaddr; 948 { 949 struct tulip_softc *sc = &psc->sc_tulip; 950 u_int16_t id = 0; 951 952 /* 953 * If we have a slaved ROM, just copy the bits from the master. 954 * This is in case we fail the ROM ID check (older boards) and 955 * need to fall back on Ethernet address model checking; that 956 * will fail for slave chips. 957 */ 958 if (psc->sc_flags & TULIP_PCI_SLAVEROM) { 959 strcpy(sc->sc_name, psc->sc_master->sc_tulip.sc_name); 960 sc->sc_mediasw = psc->sc_master->sc_tulip.sc_mediasw; 961 psc->sc_flags |= 962 psc->sc_master->sc_flags & TULIP_PCI_SHAREDINTR; 963 return; 964 } 965 966 if (sc->sc_srom[32] == 0x4a && sc->sc_srom[33] == 0x52) { 967 id = sc->sc_srom[37] | (sc->sc_srom[36] << 8); 968 switch (id) { 969 zx312: 970 case 0x0602: /* ZX312 */ 971 strcpy(sc->sc_name, "ZNYX ZX312"); 972 return; 973 974 case 0x0622: /* ZX312T */ 975 strcpy(sc->sc_name, "ZNYX ZX312T"); 976 sc->sc_mediasw = &tlp_21040_tp_mediasw; 977 return; 978 979 zx314_inta: 980 case 0x0701: /* ZX314 INTA */ 981 psc->sc_flags |= TULIP_PCI_SHAREDINTR; 982 /* FALLTHROUGH */ 983 case 0x0711: /* ZX314 */ 984 strcpy(sc->sc_name, "ZNYX ZX314"); 985 psc->sc_flags |= TULIP_PCI_SHAREDROM; 986 sc->sc_mediasw = &tlp_21040_tp_mediasw; 987 return; 988 989 zx315_inta: 990 case 0x0801: /* ZX315 INTA */ 991 psc->sc_flags |= TULIP_PCI_SHAREDINTR; 992 /* FALLTHROUGH */ 993 case 0x0811: /* ZX315 */ 994 strcpy(sc->sc_name, "ZNYX ZX315"); 995 psc->sc_flags |= TULIP_PCI_SHAREDROM; 996 return; 997 998 default: 999 id = 0; 1000 } 1001 } 1002 1003 /* 1004 * Deal with boards that have broken ROMs. 1005 */ 1006 if (id == 0) { 1007 if ((enaddr[3] & ~3) == 0xf0 && (enaddr[5] & 3) == 0x00) 1008 goto zx314_inta; 1009 if ((enaddr[3] & ~3) == 0xf4 && (enaddr[5] & 1) == 0x00) 1010 goto zx315_inta; 1011 if ((enaddr[3] & ~3) == 0xec) 1012 goto zx312; 1013 } 1014 1015 strcpy(sc->sc_name, "ZNYX ZX31x"); 1016 } 1017 1018 void 1019 tlp_pci_smc_21040_quirks(psc, enaddr) 1020 struct tulip_pci_softc *psc; 1021 const u_int8_t *enaddr; 1022 { 1023 struct tulip_softc *sc = &psc->sc_tulip; 1024 u_int16_t id1, id2, ei; 1025 int auibnc = 0, utp = 0; 1026 char *cp; 1027 1028 id1 = sc->sc_srom[0x60] | (sc->sc_srom[0x61] << 8); 1029 id2 = sc->sc_srom[0x62] | (sc->sc_srom[0x63] << 8); 1030 ei = sc->sc_srom[0x66] | (sc->sc_srom[0x67] << 8); 1031 1032 strcpy(sc->sc_name, "SMC 8432"); 1033 cp = &sc->sc_name[8]; 1034 1035 if ((id1 & 1) == 0) { 1036 *cp++ = 'B'; 1037 auibnc = 1; 1038 } 1039 if ((id1 & 0xff) > 0x32) { 1040 *cp++ = 'T'; 1041 utp = 1; 1042 } 1043 if ((id1 & 0x4000) == 0) { 1044 *cp++ = 'A'; 1045 auibnc = 1; 1046 } 1047 if (id2 == 0x15) { 1048 sc->sc_name[7] = '4'; 1049 *cp++ = '-'; 1050 *cp++ = 'C'; 1051 *cp++ = 'H'; 1052 *cp++ = ei ? '2' : '1'; 1053 } 1054 *cp = '\0'; 1055 1056 if (utp != 0 && auibnc == 0) 1057 sc->sc_mediasw = &tlp_21040_tp_mediasw; 1058 else if (utp == 0 && auibnc != 0) 1059 sc->sc_mediasw = &tlp_21040_auibnc_mediasw; 1060 } 1061 1062 void 1063 tlp_pci_cogent_21040_quirks(psc, enaddr) 1064 struct tulip_pci_softc *psc; 1065 const u_int8_t *enaddr; 1066 { 1067 1068 strcpy(psc->sc_tulip.sc_name, "Cogent multi-port"); 1069 psc->sc_flags |= TULIP_PCI_SHAREDINTR|TULIP_PCI_SHAREDROM; 1070 } 1071 1072 void 1073 tlp_pci_accton_21040_quirks(psc, enaddr) 1074 struct tulip_pci_softc *psc; 1075 const u_int8_t *enaddr; 1076 { 1077 1078 strcpy(psc->sc_tulip.sc_name, "ACCTON EN1203"); 1079 } 1080 1081 void tlp_pci_asante_21140_reset __P((struct tulip_softc *)); 1082 1083 void 1084 tlp_pci_asante_21140_quirks(psc, enaddr) 1085 struct tulip_pci_softc *psc; 1086 const u_int8_t *enaddr; 1087 { 1088 struct tulip_softc *sc = &psc->sc_tulip; 1089 1090 /* 1091 * Some Asante boards don't use the ISV SROM format. For 1092 * those that don't, we initialize the GPIO direction bits, 1093 * and provide our own reset hook, which resets the MII. 1094 * 1095 * All of these boards use SIO-attached-MII media. 1096 */ 1097 if (sc->sc_mediasw == &tlp_2114x_isv_mediasw) 1098 return; 1099 1100 strcpy(sc->sc_name, "Asante"); 1101 1102 sc->sc_gp_dir = 0xbf; 1103 sc->sc_reset = tlp_pci_asante_21140_reset; 1104 sc->sc_mediasw = &tlp_sio_mii_mediasw; 1105 } 1106 1107 void 1108 tlp_pci_asante_21140_reset(sc) 1109 struct tulip_softc *sc; 1110 { 1111 1112 TULIP_WRITE(sc, CSR_GPP, GPP_GPC | sc->sc_gp_dir); 1113 TULIP_WRITE(sc, CSR_GPP, 0x8); 1114 delay(100); 1115 TULIP_WRITE(sc, CSR_GPP, 0); 1116 } 1117 1118 void tlp_pci_cobalt_21142_reset __P((struct tulip_softc *)); 1119 1120 void 1121 tlp_pci_cobalt_21142_quirks(psc, enaddr) 1122 struct tulip_pci_softc *psc; 1123 const u_int8_t *enaddr; 1124 { 1125 struct tulip_softc *sc = &psc->sc_tulip; 1126 1127 /* 1128 * Cobalt Networks interfaces are just MII-on-SIO. 1129 */ 1130 sc->sc_reset = tlp_pci_cobalt_21142_reset; 1131 sc->sc_mediasw = &tlp_sio_mii_mediasw; 1132 1133 /* 1134 * The Cobalt systems tend to fall back to store-and-forward 1135 * pretty quickly, so we select that from the beginning to 1136 * avoid initial timeouts. 1137 */ 1138 sc->sc_txthresh = TXTH_SF; 1139 } 1140 1141 void 1142 tlp_pci_cobalt_21142_reset(sc) 1143 struct tulip_softc *sc; 1144 { 1145 /* 1146 * Reset PHY. 1147 */ 1148 TULIP_WRITE(sc, CSR_SIAGEN, SIAGEN_CWE | (1 << 16)); 1149 delay(10); 1150 TULIP_WRITE(sc, CSR_SIAGEN, SIAGEN_CWE); 1151 delay(10); 1152 } 1153
Indexes created Tue Sep 30 20:09:53 GMT 2025