1/*- 2 * All Rights Reserved, Copyright (C) Fujitsu Limited 1995 3 * 4 * This software may be used, modified, copied, distributed, and sold, in 5 * both source and binary form provided that the above copyright, these 6 * terms and the following disclaimer are retained. The name of the author 7 * and/or the contributor may not be used to endorse or promote products 8 * derived from this software without specific prior written permission. 9 * 10 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND THE CONTRIBUTOR ``AS IS'' AND 11 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 12 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 13 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR THE CONTRIBUTOR BE LIABLE 14 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 15 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 16 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION. 17 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 18 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 19 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 20 * SUCH DAMAGE. 21 * 22 */ 23 24#include <sys/cdefs.h> 25__FBSDID("$FreeBSD$"); 26 27#include <sys/param.h> 28#include <sys/systm.h> 29#include <sys/kernel.h> 30#include <sys/socket.h> 31#include <sys/module.h> 32 33#include <sys/bus.h> 34#include <machine/bus.h> 35#include <sys/rman.h> 36 37#include <net/ethernet.h> 38#include <net/if.h> 39#include <net/if_mib.h> 40#include <net/if_media.h> 41 42#include <netinet/in.h> 43#include <netinet/if_ether.h> 44 45#include <dev/fe/mb86960.h> 46#include <dev/fe/if_fereg.h> 47#include <dev/fe/if_fevar.h> 48 49#include <isa/isavar.h> 50 51/* 52 * Cbus specific code. 53 */ 54static int fe_isa_probe(device_t); 55static int fe_isa_attach(device_t); 56 57static struct isa_pnp_id fe_ids[] = { 58 { 0x101ee0d, NULL }, /* CON0101 - Contec C-NET(98)P2-T */ 59 { 0, NULL } 60}; 61 62static device_method_t fe_isa_methods[] = { 63 /* Device interface */ 64 DEVMETHOD(device_probe, fe_isa_probe), 65 DEVMETHOD(device_attach, fe_isa_attach), 66 67 { 0, 0 } 68}; 69 70static driver_t fe_isa_driver = { 71 "fe", 72 fe_isa_methods, 73 sizeof (struct fe_softc) 74}; 75 76DRIVER_MODULE(fe, isa, fe_isa_driver, fe_devclass, 0, 0); 77 78 79static int fe98_alloc_port(device_t, int); 80 81static int fe_probe_re1000(device_t); 82static int fe_probe_cnet9ne(device_t); 83static int fe_probe_rex(device_t); 84static int fe_probe_ssi(device_t); 85static int fe_probe_jli(device_t); 86static int fe_probe_lnx(device_t); 87static int fe_probe_gwy(device_t); 88static int fe_probe_ubn(device_t); 89 90/* 91 * Determine if the device is present at a specified I/O address. The 92 * main entry to the driver. 93 */ 94static int 95fe_isa_probe(device_t dev) 96{ 97 struct fe_softc *sc; 98 int error; 99 100 /* Prepare for the softc struct. */ 101 sc = device_get_softc(dev); 102 sc->sc_unit = device_get_unit(dev); 103 104 /* Check isapnp ids */ 105 error = ISA_PNP_PROBE(device_get_parent(dev), dev, fe_ids); 106 107 /* If the card had a PnP ID that didn't match any we know about */ 108 if (error == ENXIO) 109 goto end; 110 111 /* If we had some other problem. */ 112 if (!(error == 0 || error == ENOENT)) 113 goto end; 114 115 /* Probe for supported boards. */ 116 if ((error = fe_probe_re1000(dev)) == 0) 117 goto end; 118 fe_release_resource(dev); 119 120 if ((error = fe_probe_cnet9ne(dev)) == 0) 121 goto end; 122 fe_release_resource(dev); 123 124 if ((error = fe_probe_rex(dev)) == 0) 125 goto end; 126 fe_release_resource(dev); 127 128 if ((error = fe_probe_ssi(dev)) == 0) 129 goto end; 130 fe_release_resource(dev); 131 132 if ((error = fe_probe_jli(dev)) == 0) 133 goto end; 134 fe_release_resource(dev); 135 136 if ((error = fe_probe_lnx(dev)) == 0) 137 goto end; 138 fe_release_resource(dev); 139 140 if ((error = fe_probe_ubn(dev)) == 0) 141 goto end; 142 fe_release_resource(dev); 143 144 if ((error = fe_probe_gwy(dev)) == 0) 145 goto end; 146 fe_release_resource(dev); 147 148end: 149 if (error == 0) 150 error = fe_alloc_irq(dev, 0); 151 152 fe_release_resource(dev); 153 return (error); 154} 155 156static int 157fe_isa_attach(device_t dev) 158{ 159 struct fe_softc *sc = device_get_softc(dev); 160 161 if (sc->port_used) 162 fe98_alloc_port(dev, sc->type); 163 fe_alloc_irq(dev, 0); 164 165 return fe_attach(dev); 166} 167 168 169/* Generic I/O address table */ 170static bus_addr_t ioaddr_generic[MAXREGISTERS] = { 171 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007, 172 0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f, 173 0x010, 0x011, 0x012, 0x013, 0x014, 0x015, 0x016, 0x017, 174 0x018, 0x019, 0x01a, 0x01b, 0x01c, 0x01d, 0x01e, 0x01f, 175}; 176 177/* I/O address table for RE1000/1000Plus */ 178static bus_addr_t ioaddr_re1000[MAXREGISTERS] = { 179 0x0000, 0x0001, 0x0200, 0x0201, 0x0400, 0x0401, 0x0600, 0x0601, 180 0x0800, 0x0801, 0x0a00, 0x0a01, 0x0c00, 0x0c01, 0x0e00, 0x0e01, 181 0x1000, 0x1200, 0x1400, 0x1600, 0x1800, 0x1a00, 0x1c00, 0x1e00, 182 0x1001, 0x1201, 0x1401, 0x1601, 0x1801, 0x1a01, 0x1c01, 0x1e01, 183}; 184 185/* I/O address table for CNET9NE */ 186static bus_addr_t ioaddr_cnet9ne[MAXREGISTERS] = { 187 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007, 188 0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f, 189 0x400, 0x402, 0x404, 0x406, 0x408, 0x40a, 0x40c, 0x40e, 190 0x401, 0x403, 0x405, 0x407, 0x409, 0x40b, 0x40d, 0x40f, 191}; 192 193/* I/O address table for LAC-98 */ 194static bus_addr_t ioaddr_lnx[MAXREGISTERS] = { 195 0x000, 0x002, 0x004, 0x006, 0x008, 0x00a, 0x00c, 0x00e, 196 0x100, 0x102, 0x104, 0x106, 0x108, 0x10a, 0x10c, 0x10e, 197 0x200, 0x202, 0x204, 0x206, 0x208, 0x20a, 0x20c, 0x20e, 198 0x300, 0x302, 0x304, 0x306, 0x308, 0x30a, 0x30c, 0x30e, 199}; 200 201/* I/O address table for Access/PC N98C+ */ 202static bus_addr_t ioaddr_ubn[MAXREGISTERS] = { 203 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007, 204 0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f, 205 0x200, 0x201, 0x202, 0x203, 0x204, 0x205, 0x206, 0x207, 206 0x208, 0x209, 0x20a, 0x20b, 0x20c, 0x20d, 0x20e, 0x20f, 207}; 208 209/* I/O address table for REX-9880 */ 210static bus_addr_t ioaddr_rex[MAXREGISTERS] = { 211 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007, 212 0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f, 213 0x100, 0x101, 0x102, 0x103, 0x104, 0x105, 0x106, 0x107, 214 0x108, 0x109, 0x10a, 0x10b, 0x10c, 0x10d, 0x10e, 0x10f, 215}; 216 217static int 218fe98_alloc_port(device_t dev, int type) 219{ 220 struct fe_softc *sc = device_get_softc(dev); 221 struct resource *res; 222 bus_addr_t *iat; 223 int size, rid; 224 225 switch (type) { 226 case FE_TYPE_RE1000: 227 iat = ioaddr_re1000; 228 size = MAXREGISTERS; 229 break; 230 case FE_TYPE_CNET9NE: 231 iat = ioaddr_cnet9ne; 232 size = MAXREGISTERS; 233 break; 234 case FE_TYPE_SSI: 235 iat = ioaddr_generic; 236 size = MAXREGISTERS; 237 break; 238 case FE_TYPE_LNX: 239 iat = ioaddr_lnx; 240 size = MAXREGISTERS; 241 break; 242 case FE_TYPE_GWY: 243 iat = ioaddr_generic; 244 size = MAXREGISTERS; 245 break; 246 case FE_TYPE_UBN: 247 iat = ioaddr_ubn; 248 size = MAXREGISTERS; 249 break; 250 case FE_TYPE_REX: 251 iat = ioaddr_rex; 252 size = MAXREGISTERS; 253 break; 254 default: 255 iat = ioaddr_generic; 256 size = MAXREGISTERS; 257 break; 258 } 259 260 rid = 0; 261 res = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &rid, 262 iat, size, RF_ACTIVE); 263 if (res == NULL) 264 return ENOENT; 265 266 isa_load_resourcev(res, iat, size); 267 268 sc->type = type; 269 sc->port_used = size; 270 sc->port_res = res; 271 return (0); 272} 273 274 275/* 276 * Probe and initialization for Allied-Telesis RE1000 series. 277 */ 278static void 279fe_init_re1000(struct fe_softc *sc) 280{ 281 /* Setup IRQ control register on the ASIC. */ 282 fe_outb(sc, FE_RE1000_IRQCONF, sc->priv_info); 283} 284 285static int 286fe_probe_re1000(device_t dev) 287{ 288 struct fe_softc *sc = device_get_softc(dev); 289 int i, n; 290 u_long iobase, irq; 291 u_char sum; 292 293 static struct fe_simple_probe_struct probe_table [] = { 294 { FE_DLCR2, 0x58, 0x00 }, 295 { FE_DLCR4, 0x08, 0x00 }, 296 { 0 } 297 }; 298 299 /* See if the specified I/O address is possible for RE1000. */ 300 /* [01]D[02468ACE] are allowed. */ 301 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0) 302 return ENXIO; 303 if ((iobase & ~0x10E) != 0xD0) 304 return ENXIO; 305 306 if (fe98_alloc_port(dev, FE_TYPE_RE1000)) 307 return ENXIO; 308 309 /* Fill the softc struct with default values. */ 310 fe_softc_defaults(sc); 311 312 /* See if the card is on its address. */ 313 if (!fe_simple_probe(sc, probe_table)) 314 return ENXIO; 315 316 /* Get our station address from EEPROM. */ 317 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN); 318 319 /* Make sure it is Allied-Telesis's. */ 320 if (!fe_valid_Ether_p(sc->enaddr, 0x0000F4)) 321 return ENXIO; 322#if 1 323 /* Calculate checksum. */ 324 sum = fe_inb(sc, 0x1e); 325 for (i = 0; i < ETHER_ADDR_LEN; i++) 326 sum ^= sc->enaddr[i]; 327 if (sum != 0) 328 return ENXIO; 329#endif 330 /* Setup the board type. */ 331 sc->typestr = "RE1000"; 332 333 /* This looks like an RE1000 board. It requires an 334 explicit IRQ setting in config. Make sure we have one, 335 determining an appropriate value for the IRQ control 336 register. */ 337 irq = 0; 338 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL); 339 switch (irq) { 340 case 3: n = 0x10; break; 341 case 5: n = 0x20; break; 342 case 6: n = 0x40; break; 343 case 12: n = 0x80; break; 344 default: 345 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12"); 346 return ENXIO; 347 } 348 sc->priv_info = (fe_inb(sc, FE_RE1000_IRQCONF) & 0x0f) | n; 349 350 /* Setup hooks. We need a special initialization procedure. */ 351 sc->init = fe_init_re1000; 352 353 return 0; 354} 355 356/* JLI sub-probe for Allied-Telesis RE1000Plus/ME1500 series. */ 357static u_short const * 358fe_probe_jli_re1000p(struct fe_softc * sc, u_char const * eeprom) 359{ 360 int i; 361 static u_short const irqmaps_re1000p [4] = { 3, 5, 6, 12 }; 362 363 /* Make sure the EEPROM contains Allied-Telesis bit pattern. */ 364 if (eeprom[1] != 0xFF) return NULL; 365 for (i = 2; i < 8; i++) if (eeprom[i] != 0xFF) return NULL; 366 for (i = 14; i < 24; i++) if (eeprom[i] != 0xFF) return NULL; 367 368 /* Get our station address from EEPROM, and make sure the 369 EEPROM contains Allied-Telesis's address. */ 370 bcopy(eeprom + 8, sc->enaddr, ETHER_ADDR_LEN); 371 if (!fe_valid_Ether_p(sc->enaddr, 0x0000F4)) 372 return NULL; 373 374 /* I don't know any sub-model identification. */ 375 sc->typestr = "RE1000Plus/ME1500"; 376 377 /* Returns the IRQ table for the RE1000Plus. */ 378 return irqmaps_re1000p; 379} 380 381 382/* 383 * Probe for Allied-Telesis RE1000Plus/ME1500 series. 384 */ 385static int 386fe_probe_jli(device_t dev) 387{ 388 struct fe_softc *sc = device_get_softc(dev); 389 int i, n, xirq, error; 390 u_long iobase, irq; 391 u_char eeprom [JLI_EEPROM_SIZE]; 392 u_short const * irqmap; 393 394 static u_short const baseaddr [8] = 395 { 0x1D6, 0x1D8, 0x1DA, 0x1D4, 0x0D4, 0x0D2, 0x0D8, 0x0D0 }; 396 static struct fe_simple_probe_struct const probe_table [] = { 397 /* { FE_DLCR1, 0x20, 0x00 }, Doesn't work. */ 398 { FE_DLCR2, 0x50, 0x00 }, 399 { FE_DLCR4, 0x08, 0x00 }, 400 /* { FE_DLCR5, 0x80, 0x00 }, Doesn't work. */ 401#if 0 402 { FE_BMPR16, 0x1B, 0x00 }, 403 { FE_BMPR17, 0x7F, 0x00 }, 404#endif 405 { 0 } 406 }; 407 408 /* 409 * See if the specified address is possible for MB86965A JLI mode. 410 */ 411 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0) 412 return ENXIO; 413 for (i = 0; i < 8; i++) { 414 if (baseaddr[i] == iobase) 415 break; 416 } 417 if (i == 8) 418 return ENXIO; 419 420 if (fe98_alloc_port(dev, FE_TYPE_RE1000)) 421 return ENXIO; 422 423 /* Fill the softc struct with default values. */ 424 fe_softc_defaults(sc); 425 426 /* 427 * We should test if MB86965A is on the base address now. 428 * Unfortunately, it is very hard to probe it reliably, since 429 * we have no way to reset the chip under software control. 430 * On cold boot, we could check the "signature" bit patterns 431 * described in the Fujitsu document. On warm boot, however, 432 * we can predict almost nothing about register values. 433 */ 434 if (!fe_simple_probe(sc, probe_table)) 435 return ENXIO; 436 437 /* Check if our I/O address matches config info on 86965. */ 438 n = (fe_inb(sc, FE_BMPR19) & FE_B19_ADDR) >> FE_B19_ADDR_SHIFT; 439 if (baseaddr[n] != iobase) 440 return ENXIO; 441 442 /* 443 * We are now almost sure we have an MB86965 at the given 444 * address. So, read EEPROM through it. We have to write 445 * into LSI registers to read from EEPROM. I want to avoid it 446 * at this stage, but I cannot test the presence of the chip 447 * any further without reading EEPROM. FIXME. 448 */ 449 fe_read_eeprom_jli(sc, eeprom); 450 451 /* Make sure that config info in EEPROM and 86965 agree. */ 452 if (eeprom[FE_EEPROM_CONF] != fe_inb(sc, FE_BMPR19)) 453 return ENXIO; 454 455 /* Use 86965 media selection scheme, unless othewise 456 specified. It is "AUTO always" and "select with BMPR13". 457 This behaviour covers most of the 86965 based board (as 458 minimum requirements.) It is backward compatible with 459 previous versions, also. */ 460 sc->mbitmap = MB_HA; 461 sc->defmedia = MB_HA; 462 sc->msel = fe_msel_965; 463 464 /* Perform board-specific probe. */ 465 if ((irqmap = fe_probe_jli_re1000p(sc, eeprom)) == NULL) 466 return ENXIO; 467 468 /* Find the IRQ read from EEPROM. */ 469 n = (fe_inb(sc, FE_BMPR19) & FE_B19_IRQ) >> FE_B19_IRQ_SHIFT; 470 xirq = irqmap[n]; 471 472 /* Try to determine IRQ setting. */ 473 error = bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL); 474 if (error && xirq == NO_IRQ) { 475 /* The device must be configured with an explicit IRQ. */ 476 device_printf(dev, "IRQ auto-detection does not work\n"); 477 return ENXIO; 478 } else if (error && xirq != NO_IRQ) { 479 /* Just use the probed IRQ value. */ 480 bus_set_resource(dev, SYS_RES_IRQ, 0, xirq, 1); 481 } else if (!error && xirq == NO_IRQ) { 482 /* No problem. Go ahead. */ 483 } else if (irq == xirq) { 484 /* Good. Go ahead. */ 485 } else { 486 /* User must be warned in this case. */ 487 sc->stability |= UNSTABLE_IRQ; 488 } 489 490 /* Setup a hook, which resets te 86965 when the driver is being 491 initialized. This may solve a nasty bug. FIXME. */ 492 sc->init = fe_init_jli; 493 494 return 0; 495} 496 497 498/* 499 * Probe and initialization for Contec C-NET(9N)E series. 500 */ 501 502/* TODO: Should be in "if_fereg.h" */ 503#define FE_CNET9NE_INTR 0x10 /* Interrupt Mask? */ 504 505static void 506fe_init_cnet9ne(struct fe_softc *sc) 507{ 508 /* Enable interrupt? FIXME. */ 509 fe_outb(sc, FE_CNET9NE_INTR, 0x10); 510} 511 512static int 513fe_probe_cnet9ne (device_t dev) 514{ 515 struct fe_softc *sc = device_get_softc(dev); 516 u_long iobase, irq; 517 518 static struct fe_simple_probe_struct probe_table [] = { 519 { FE_DLCR2, 0x58, 0x00 }, 520 { FE_DLCR4, 0x08, 0x00 }, 521 { 0 } 522 }; 523 524 /* See if the specified I/O address is possible for C-NET(9N)E. */ 525 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0) 526 return ENXIO; 527 if (iobase != 0x73D0) 528 return ENXIO; 529 530 if (fe98_alloc_port(dev, FE_TYPE_CNET9NE)) 531 return ENXIO; 532 533 /* Fill the softc struct with default values. */ 534 fe_softc_defaults(sc); 535 536 /* See if the card is on its address. */ 537 if (!fe_simple_probe(sc, probe_table)) 538 return ENXIO; 539 540 /* Get our station address from EEPROM. */ 541 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN); 542 543 /* Make sure it is Contec's. */ 544 if (!fe_valid_Ether_p(sc->enaddr, 0x00804C)) 545 return ENXIO; 546 547 /* Determine the card type. */ 548 if (sc->enaddr[3] == 0x06) { 549 sc->typestr = "C-NET(9N)C"; 550 551 /* We seems to need our own IDENT bits... FIXME. */ 552 sc->proto_dlcr7 = FE_D7_BYTSWP_LH | FE_D7_IDENT_NICE; 553 554 /* C-NET(9N)C requires an explicit IRQ to work. */ 555 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0) { 556 fe_irq_failure(sc->typestr, sc->sc_unit, NO_IRQ, NULL); 557 return ENXIO; 558 } 559 } else { 560 sc->typestr = "C-NET(9N)E"; 561 562 /* C-NET(9N)E works only IRQ5. */ 563 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0) 564 return ENXIO; 565 if (irq != 5) { 566 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "5"); 567 return ENXIO; 568 } 569 570 /* We need an init hook to initialize ASIC before we start. */ 571 sc->init = fe_init_cnet9ne; 572 } 573 574 /* C-NET(9N)E has 64KB SRAM. */ 575 sc->proto_dlcr6 = FE_D6_BUFSIZ_64KB | FE_D6_TXBSIZ_2x4KB 576 | FE_D6_BBW_WORD | FE_D6_SBW_WORD | FE_D6_SRAM; 577 578 return 0; 579} 580 581 582/* 583 * Probe for Contec C-NET(98)P2 series. 584 * (Logitec LAN-98TP/LAN-98T25P - parhaps) 585 */ 586static int 587fe_probe_ssi(device_t dev) 588{ 589 struct fe_softc *sc = device_get_softc(dev); 590 u_long iobase, irq; 591 592 u_char eeprom [SSI_EEPROM_SIZE]; 593 static struct fe_simple_probe_struct probe_table [] = { 594 { FE_DLCR2, 0x08, 0x00 }, 595 { FE_DLCR4, 0x08, 0x00 }, 596 { 0 } 597 }; 598 static u_short const irqmap[] = { 599 /* INT0 INT1 INT2 */ 600 NO_IRQ, NO_IRQ, NO_IRQ, 3, NO_IRQ, 5, 6, NO_IRQ, 601 NO_IRQ, 9, 10, NO_IRQ, 12, 13, NO_IRQ, NO_IRQ, 602 /* INT3 INT41 INT5 INT6 */ 603 }; 604 605 /* See if the specified I/O address is possible for 78Q8377A. */ 606 /* [0-D]3D0 are allowed. */ 607 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0) 608 return ENXIO; 609 if ((iobase & 0xFFF) != 0x3D0) 610 return ENXIO; 611 612 if (fe98_alloc_port(dev, FE_TYPE_SSI)) 613 return ENXIO; 614 615 /* Fill the softc struct with default values. */ 616 fe_softc_defaults(sc); 617 618 /* See if the card is on its address. */ 619 if (!fe_simple_probe(sc, probe_table)) 620 return ENXIO; 621 622 /* We now have to read the config EEPROM. We should be very 623 careful, since doing so destroys a register. (Remember, we 624 are not yet sure we have a C-NET(98)P2 board here.) Don't 625 remember to select BMPRs bofore reading EEPROM, since other 626 register bank may be selected before the probe() is called. */ 627 fe_read_eeprom_ssi(sc, eeprom); 628 629 /* Make sure the Ethernet (MAC) station address is of Contec's. */ 630 if (!fe_valid_Ether_p(eeprom + FE_SSI_EEP_ADDR, 0x00804C)) 631 return ENXIO; 632 bcopy(eeprom + FE_SSI_EEP_ADDR, sc->enaddr, ETHER_ADDR_LEN); 633 634 /* Setup the board type. */ 635 sc->typestr = "C-NET(98)P2"; 636 637 /* Non-PnP mode, set static resource from eeprom. */ 638 if (!isa_get_vendorid(dev)) { 639 /* Get IRQ configuration from EEPROM. */ 640 irq = irqmap[eeprom[FE_SSI_EEP_IRQ]]; 641 if (irq == NO_IRQ) { 642 fe_irq_failure(sc->typestr, sc->sc_unit, irq, 643 "3/5/6/9/10/12/13"); 644 return ENXIO; 645 } 646 bus_set_resource(dev, SYS_RES_IRQ, 0, irq, 1); 647 } 648 649 /* Get Duplex-mode configuration from EEPROM. */ 650 sc->proto_dlcr4 |= (eeprom[FE_SSI_EEP_DUPLEX] & FE_D4_DSC); 651 652 /* Fill softc struct accordingly. */ 653 sc->mbitmap = MB_HT; 654 sc->defmedia = MB_HT; 655 656 return 0; 657} 658 659 660/* 661 * Probe for TDK LAC-98012/013/025/9N011 - parhaps. 662 */ 663static int 664fe_probe_lnx(device_t dev) 665{ 666 struct fe_softc *sc = device_get_softc(dev); 667 668 u_long iobase, irq; 669 u_char eeprom [LNX_EEPROM_SIZE]; 670 671 static struct fe_simple_probe_struct probe_table [] = { 672 { FE_DLCR2, 0x58, 0x00 }, 673 { FE_DLCR4, 0x08, 0x00 }, 674 { 0 } 675 }; 676 677 /* See if the specified I/O address is possible for TDK/LANX boards. */ 678 /* 0D0, 4D0, 8D0, and CD0 are allowed. */ 679 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0) 680 return ENXIO; 681 if ((iobase & ~0xC00) != 0xD0) 682 return ENXIO; 683 684 if (fe98_alloc_port(dev, FE_TYPE_LNX)) 685 return ENXIO; 686 687 /* Fill the softc struct with default values. */ 688 fe_softc_defaults(sc); 689 690 /* See if the card is on its address. */ 691 if (!fe_simple_probe(sc, probe_table)) 692 return ENXIO; 693 694 /* We now have to read the config EEPROM. We should be very 695 careful, since doing so destroys a register. (Remember, we 696 are not yet sure we have a LAC-98012/98013 board here.) */ 697 fe_read_eeprom_lnx(sc, eeprom); 698 699 /* Make sure the Ethernet (MAC) station address is of TDK/LANX's. */ 700 if (!fe_valid_Ether_p(eeprom, 0x008098)) 701 return ENXIO; 702 bcopy(eeprom, sc->enaddr, ETHER_ADDR_LEN); 703 704 /* Setup the board type. */ 705 sc->typestr = "LAC-98012/98013"; 706 707 /* This looks like a TDK/LANX board. It requires an 708 explicit IRQ setting in config. Make sure we have one, 709 determining an appropriate value for the IRQ control 710 register. */ 711 irq = 0; 712 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0) 713 return ENXIO; 714 switch (irq) { 715 case 3 : sc->priv_info = 0x10 | LNX_CLK_LO | LNX_SDA_HI; break; 716 case 5 : sc->priv_info = 0x20 | LNX_CLK_LO | LNX_SDA_HI; break; 717 case 6 : sc->priv_info = 0x40 | LNX_CLK_LO | LNX_SDA_HI; break; 718 case 12: sc->priv_info = 0x80 | LNX_CLK_LO | LNX_SDA_HI; break; 719 default: 720 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12"); 721 return ENXIO; 722 } 723 724 /* LAC-98's system bus width is 8-bit. */ 725 sc->proto_dlcr6 = FE_D6_BUFSIZ_32KB | FE_D6_TXBSIZ_2x2KB 726 | FE_D6_BBW_BYTE | FE_D6_SBW_BYTE | FE_D6_SRAM_150ns; 727 728 /* Setup hooks. We need a special initialization procedure. */ 729 sc->init = fe_init_lnx; 730 731 return 0; 732} 733 734 735/* 736 * Probe for Gateway Communications' old cards. 737 * (both as Generic MB86960 probe routine) 738 */ 739static int 740fe_probe_gwy(device_t dev) 741{ 742 struct fe_softc *sc = device_get_softc(dev); 743 744 static struct fe_simple_probe_struct probe_table [] = { 745 /* { FE_DLCR2, 0x70, 0x00 }, */ 746 { FE_DLCR2, 0x58, 0x00 }, 747 { FE_DLCR4, 0x08, 0x00 }, 748 { 0 } 749 }; 750 751 /* 752 * XXX 753 * I'm not sure which address is possible, so accepts any. 754 */ 755 756 if (fe98_alloc_port(dev, FE_TYPE_GWY)) 757 return ENXIO; 758 759 /* Fill the softc struct with default values. */ 760 fe_softc_defaults(sc); 761 762 /* See if the card is on its address. */ 763 if (!fe_simple_probe(sc, probe_table)) 764 return ENXIO; 765 766 /* Get our station address from EEPROM. */ 767 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN); 768 if (!fe_valid_Ether_p(sc->enaddr, 0x000000)) 769 return ENXIO; 770 771 /* Determine the card type. */ 772 sc->typestr = "Generic MB86960 Ethernet"; 773 if (fe_valid_Ether_p(sc->enaddr, 0x000061)) 774 sc->typestr = "Gateway Ethernet (Fujitsu chipset)"; 775 776 /* Gateway's board requires an explicit IRQ to work, since it 777 is not possible to probe the setting of jumpers. */ 778 if (bus_get_resource(dev, SYS_RES_IRQ, 0, NULL, NULL) != 0) { 779 fe_irq_failure(sc->typestr, sc->sc_unit, NO_IRQ, NULL); 780 return ENXIO; 781 } 782 783 return 0; 784} 785 786 787/* 788 * Probe for Ungermann-Bass Access/PC N98C+(Model 85152). 789 */ 790static int 791fe_probe_ubn(device_t dev) 792{ 793 struct fe_softc *sc = device_get_softc(dev); 794 795 u_char sum, save7; 796 u_long iobase, irq; 797 int i; 798 static struct fe_simple_probe_struct const probe_table [] = { 799 { FE_DLCR2, 0x58, 0x00 }, 800 { FE_DLCR4, 0x08, 0x00 }, 801 { 0 } 802 }; 803 804 /* See if the specified I/O address is possible for Access/PC. */ 805 /* [01][048C]D0 are allowed. */ 806 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0) 807 return ENXIO; 808 if ((iobase & ~0x1C00) != 0xD0) 809 return ENXIO; 810 811 if (fe98_alloc_port(dev, FE_TYPE_UBN)) 812 return ENXIO; 813 814 /* Fill the softc struct with default values. */ 815 fe_softc_defaults(sc); 816 817 /* Simple probe. */ 818 if (!fe_simple_probe(sc, probe_table)) 819 return ENXIO; 820 821 /* NOTE: Access/NOTE N98 sometimes freeze when reading station 822 address. In case of using it togather with C-NET(9N)C, 823 this problem usually happens. 824 Writing DLCR7 prevents freezing, but I don't know why. FIXME. */ 825 826 /* Save the current value for the DLCR7 register we are about 827 to destroy. */ 828 save7 = fe_inb(sc, FE_DLCR7); 829 fe_outb(sc, FE_DLCR7, 830 sc->proto_dlcr7 | FE_D7_RBS_BMPR | FE_D7_POWER_UP); 831 832 /* Get our station address form ID ROM and make sure it is UBN's. */ 833 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN); 834 if (!fe_valid_Ether_p(sc->enaddr, 0x00DD01)) 835 goto fail_ubn; 836#if 1 837 /* Calculate checksum. */ 838 sum = fe_inb(sc, 0x1e); 839 for (i = 0; i < ETHER_ADDR_LEN; i++) 840 sum ^= sc->enaddr[i]; 841 if (sum != 0) 842 goto fail_ubn; 843#endif 844 845 /* Setup the board type. */ 846 sc->typestr = "Access/PC"; 847 848 /* This looks like an AccessPC/N98C+ board. It requires an 849 explicit IRQ setting in config. Make sure we have one, 850 determining an appropriate value for the IRQ control 851 register. */ 852 irq = 0; 853 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL); 854 switch (irq) { 855 case 3: sc->priv_info = 0x01; break; 856 case 5: sc->priv_info = 0x02; break; 857 case 6: sc->priv_info = 0x04; break; 858 case 12: sc->priv_info = 0x08; break; 859 default: 860 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12"); 861 goto fail_ubn; 862 } 863 864 /* Setup hooks. We need a special initialization procedure. */ 865 sc->init = fe_init_ubn; 866 867 return 0; 868 869fail_ubn: 870 fe_outb(sc, FE_DLCR7, save7); 871 return ENXIO; 872} 873 874 875/* 876 * REX boards(non-JLI type) support routine. 877 */ 878 879#define REX_EEPROM_SIZE 32 880#define REX_DAT 0x01 881 882static void 883fe_read_eeprom_rex(struct fe_softc *sc, u_char *data) 884{ 885 int i; 886 u_char bit, val; 887 u_char save16; 888 889 save16 = fe_inb(sc, 0x10); 890 891 /* Issue a start condition. */ 892 val = fe_inb(sc, 0x10) & 0xf0; 893 fe_outb(sc, 0x10, val); 894 895 (void) fe_inb(sc, 0x10); 896 (void) fe_inb(sc, 0x10); 897 (void) fe_inb(sc, 0x10); 898 (void) fe_inb(sc, 0x10); 899 900 /* Read bytes from EEPROM. */ 901 for (i = 0; i < REX_EEPROM_SIZE; i++) { 902 /* Read a byte and store it into the buffer. */ 903 val = 0x00; 904 for (bit = 0x01; bit != 0x00; bit <<= 1) 905 if (fe_inb(sc, 0x10) & REX_DAT) 906 val |= bit; 907 *data++ = val; 908 } 909 910 fe_outb(sc, 0x10, save16); 911 912#if 1 913 /* Report what we got. */ 914 if (bootverbose) { 915 data -= REX_EEPROM_SIZE; 916 for (i = 0; i < REX_EEPROM_SIZE; i += 16) { 917 printf("fe%d: EEPROM(REX):%3x: %16D\n", 918 sc->sc_unit, i, data + i, " "); 919 } 920 } 921#endif 922} 923 924 925static void 926fe_init_rex(struct fe_softc *sc) 927{ 928 /* Setup IRQ control register on the ASIC. */ 929 fe_outb(sc, 0x10, sc->priv_info); 930} 931 932/* 933 * Probe for RATOC REX-9880/81/82/83 series. 934 */ 935static int 936fe_probe_rex(device_t dev) 937{ 938 struct fe_softc *sc = device_get_softc(dev); 939 940 int i; 941 u_long iobase, irq; 942 u_char eeprom [REX_EEPROM_SIZE]; 943 944 static struct fe_simple_probe_struct probe_table [] = { 945 { FE_DLCR2, 0x58, 0x00 }, 946 { FE_DLCR4, 0x08, 0x00 }, 947 { 0 } 948 }; 949 950 /* See if the specified I/O address is possible for REX-9880. */ 951 /* 6[46CE]D0 are allowed. */ 952 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0) 953 return ENXIO; 954 if ((iobase & ~0xA00) != 0x64D0) 955 return ENXIO; 956 957 if (fe98_alloc_port(dev, FE_TYPE_REX)) 958 return ENXIO; 959 960 /* Fill the softc struct with default values. */ 961 fe_softc_defaults(sc); 962 963 /* See if the card is on its address. */ 964 if (!fe_simple_probe(sc, probe_table)) 965 return ENXIO; 966 967 /* We now have to read the config EEPROM. We should be very 968 careful, since doing so destroys a register. (Remember, we 969 are not yet sure we have a REX-9880 board here.) */ 970 fe_read_eeprom_rex(sc, eeprom); 971 for (i = 0; i < ETHER_ADDR_LEN; i++) 972 sc->enaddr[i] = eeprom[7 - i]; 973 974 /* Make sure it is RATOC's. */ 975 if (!fe_valid_Ether_p(sc->enaddr, 0x00C0D0) && 976 !fe_valid_Ether_p(sc->enaddr, 0x00803D)) 977 return 0; 978 979 /* Setup the board type. */ 980 sc->typestr = "REX-9880/9883"; 981 982 /* This looks like a REX-9880 board. It requires an 983 explicit IRQ setting in config. Make sure we have one, 984 determining an appropriate value for the IRQ control 985 register. */ 986 irq = 0; 987 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL); 988 switch (irq) { 989 case 3: sc->priv_info = 0x10; break; 990 case 5: sc->priv_info = 0x20; break; 991 case 6: sc->priv_info = 0x40; break; 992 case 12: sc->priv_info = 0x80; break; 993 default: 994 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12"); 995 return ENXIO; 996 } 997 998 /* Setup hooks. We need a special initialization procedure. */ 999 sc->init = fe_init_rex; 1000 1001 /* REX-9880 has 64KB SRAM. */ 1002 sc->proto_dlcr6 = FE_D6_BUFSIZ_64KB | FE_D6_TXBSIZ_2x4KB 1003 | FE_D6_BBW_WORD | FE_D6_SBW_WORD | FE_D6_SRAM; 1004#if 1 1005 sc->proto_dlcr7 |= FE_D7_EOPPOL; /* XXX */ 1006#endif 1007 1008 return 0; 1009} 1010