2 * All Rights Reserved, Copyright (C) Fujitsu Limited 1995
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.
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
24 #include <sys/cdefs.h>
25 __FBSDID("$FreeBSD$");
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>
34 #include <machine/bus.h>
37 #include <net/ethernet.h>
39 #include <net/if_mib.h>
40 #include <net/if_media.h>
42 #include <netinet/in.h>
43 #include <netinet/if_ether.h>
45 #include <dev/fe/mb86960.h>
46 #include <dev/fe/if_fereg.h>
47 #include <dev/fe/if_fevar.h>
49 #include <isa/isavar.h>
54 static int fe_isa_probe(device_t);
55 static int fe_isa_attach(device_t);
57 static struct isa_pnp_id fe_ids[] = {
58 { 0x101ee0d, NULL }, /* CON0101 - Contec C-NET(98)P2-T */
62 static device_method_t fe_isa_methods[] = {
63 /* Device interface */
64 DEVMETHOD(device_probe, fe_isa_probe),
65 DEVMETHOD(device_attach, fe_isa_attach),
70 static driver_t fe_isa_driver = {
73 sizeof (struct fe_softc)
76 DRIVER_MODULE(fe, isa, fe_isa_driver, fe_devclass, 0, 0);
79 static int fe98_alloc_port(device_t, int);
81 static int fe_probe_re1000(device_t);
82 static int fe_probe_cnet9ne(device_t);
83 static int fe_probe_rex(device_t);
84 static int fe_probe_ssi(device_t);
85 static int fe_probe_jli(device_t);
86 static int fe_probe_lnx(device_t);
87 static int fe_probe_gwy(device_t);
88 static int fe_probe_ubn(device_t);
91 * Determine if the device is present at a specified I/O address. The
92 * main entry to the driver.
95 fe_isa_probe(device_t dev)
100 /* Prepare for the softc struct. */
101 sc = device_get_softc(dev);
102 sc->sc_unit = device_get_unit(dev);
104 /* Check isapnp ids */
105 error = ISA_PNP_PROBE(device_get_parent(dev), dev, fe_ids);
107 /* If the card had a PnP ID that didn't match any we know about */
111 /* If we had some other problem. */
112 if (!(error == 0 || error == ENOENT))
115 /* Probe for supported boards. */
116 if ((error = fe_probe_re1000(dev)) == 0)
118 fe_release_resource(dev);
120 if ((error = fe_probe_cnet9ne(dev)) == 0)
122 fe_release_resource(dev);
124 if ((error = fe_probe_rex(dev)) == 0)
126 fe_release_resource(dev);
128 if ((error = fe_probe_ssi(dev)) == 0)
130 fe_release_resource(dev);
132 if ((error = fe_probe_jli(dev)) == 0)
134 fe_release_resource(dev);
136 if ((error = fe_probe_lnx(dev)) == 0)
138 fe_release_resource(dev);
140 if ((error = fe_probe_ubn(dev)) == 0)
142 fe_release_resource(dev);
144 if ((error = fe_probe_gwy(dev)) == 0)
146 fe_release_resource(dev);
150 error = fe_alloc_irq(dev, 0);
152 fe_release_resource(dev);
157 fe_isa_attach(device_t dev)
159 struct fe_softc *sc = device_get_softc(dev);
162 fe98_alloc_port(dev, sc->type);
163 fe_alloc_irq(dev, 0);
165 return fe_attach(dev);
169 /* Generic I/O address table */
170 static 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,
177 /* I/O address table for RE1000/1000Plus */
178 static 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,
185 /* I/O address table for CNET9NE */
186 static 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,
193 /* I/O address table for LAC-98 */
194 static 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,
201 /* I/O address table for Access/PC N98C+ */
202 static 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,
209 /* I/O address table for REX-9880 */
210 static 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,
218 fe98_alloc_port(device_t dev, int type)
220 struct fe_softc *sc = device_get_softc(dev);
221 struct resource *res;
230 case FE_TYPE_CNET9NE:
231 iat = ioaddr_cnet9ne;
235 iat = ioaddr_generic;
243 iat = ioaddr_generic;
255 iat = ioaddr_generic;
261 res = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &rid,
262 iat, size, RF_ACTIVE);
266 isa_load_resourcev(res, iat, size);
269 sc->port_used = size;
276 * Probe and initialization for Allied-Telesis RE1000 series.
279 fe_init_re1000(struct fe_softc *sc)
281 /* Setup IRQ control register on the ASIC. */
282 fe_outb(sc, FE_RE1000_IRQCONF, sc->priv_info);
286 fe_probe_re1000(device_t dev)
288 struct fe_softc *sc = device_get_softc(dev);
293 static struct fe_simple_probe_struct probe_table [] = {
294 { FE_DLCR2, 0x58, 0x00 },
295 { FE_DLCR4, 0x08, 0x00 },
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)
303 if ((iobase & ~0x10E) != 0xD0)
306 if (fe98_alloc_port(dev, FE_TYPE_RE1000))
309 /* Fill the softc struct with default values. */
310 fe_softc_defaults(sc);
312 /* See if the card is on its address. */
313 if (!fe_simple_probe(sc, probe_table))
316 /* Get our station address from EEPROM. */
317 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN);
319 /* Make sure it is Allied-Telesis's. */
320 if (!fe_valid_Ether_p(sc->enaddr, 0x0000F4))
323 /* Calculate checksum. */
324 sum = fe_inb(sc, 0x1e);
325 for (i = 0; i < ETHER_ADDR_LEN; i++)
326 sum ^= sc->enaddr[i];
330 /* Setup the board type. */
331 sc->typestr = "RE1000";
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
338 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
340 case 3: n = 0x10; break;
341 case 5: n = 0x20; break;
342 case 6: n = 0x40; break;
343 case 12: n = 0x80; break;
345 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12");
348 sc->priv_info = (fe_inb(sc, FE_RE1000_IRQCONF) & 0x0f) | n;
350 /* Setup hooks. We need a special initialization procedure. */
351 sc->init = fe_init_re1000;
356 /* JLI sub-probe for Allied-Telesis RE1000Plus/ME1500 series. */
357 static u_short const *
358 fe_probe_jli_re1000p(struct fe_softc * sc, u_char const * eeprom)
361 static u_short const irqmaps_re1000p [4] = { 3, 5, 6, 12 };
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;
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))
374 /* I don't know any sub-model identification. */
375 sc->typestr = "RE1000Plus/ME1500";
377 /* Returns the IRQ table for the RE1000Plus. */
378 return irqmaps_re1000p;
383 * Probe for Allied-Telesis RE1000Plus/ME1500 series.
386 fe_probe_jli(device_t dev)
388 struct fe_softc *sc = device_get_softc(dev);
389 int i, n, xirq, error;
391 u_char eeprom [JLI_EEPROM_SIZE];
392 u_short const * irqmap;
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. */
402 { FE_BMPR16, 0x1B, 0x00 },
403 { FE_BMPR17, 0x7F, 0x00 },
409 * See if the specified address is possible for MB86965A JLI mode.
411 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
413 for (i = 0; i < 8; i++) {
414 if (baseaddr[i] == iobase)
420 if (fe98_alloc_port(dev, FE_TYPE_RE1000))
423 /* Fill the softc struct with default values. */
424 fe_softc_defaults(sc);
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.
434 if (!fe_simple_probe(sc, probe_table))
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)
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.
449 fe_read_eeprom_jli(sc, eeprom);
451 /* Make sure that config info in EEPROM and 86965 agree. */
452 if (eeprom[FE_EEPROM_CONF] != fe_inb(sc, FE_BMPR19))
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. */
461 sc->defmedia = MB_HA;
462 sc->msel = fe_msel_965;
464 /* Perform board-specific probe. */
465 if ((irqmap = fe_probe_jli_re1000p(sc, eeprom)) == NULL)
468 /* Find the IRQ read from EEPROM. */
469 n = (fe_inb(sc, FE_BMPR19) & FE_B19_IRQ) >> FE_B19_IRQ_SHIFT;
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");
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. */
486 /* User must be warned in this case. */
487 sc->stability |= UNSTABLE_IRQ;
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;
499 * Probe and initialization for Contec C-NET(9N)E series.
502 /* TODO: Should be in "if_fereg.h" */
503 #define FE_CNET9NE_INTR 0x10 /* Interrupt Mask? */
506 fe_init_cnet9ne(struct fe_softc *sc)
508 /* Enable interrupt? FIXME. */
509 fe_outb(sc, FE_CNET9NE_INTR, 0x10);
513 fe_probe_cnet9ne (device_t dev)
515 struct fe_softc *sc = device_get_softc(dev);
518 static struct fe_simple_probe_struct probe_table [] = {
519 { FE_DLCR2, 0x58, 0x00 },
520 { FE_DLCR4, 0x08, 0x00 },
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)
527 if (iobase != 0x73D0)
530 if (fe98_alloc_port(dev, FE_TYPE_CNET9NE))
533 /* Fill the softc struct with default values. */
534 fe_softc_defaults(sc);
536 /* See if the card is on its address. */
537 if (!fe_simple_probe(sc, probe_table))
540 /* Get our station address from EEPROM. */
541 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN);
543 /* Make sure it is Contec's. */
544 if (!fe_valid_Ether_p(sc->enaddr, 0x00804C))
547 /* Determine the card type. */
548 if (sc->enaddr[3] == 0x06) {
549 sc->typestr = "C-NET(9N)C";
551 /* We seems to need our own IDENT bits... FIXME. */
552 sc->proto_dlcr7 = FE_D7_BYTSWP_LH | FE_D7_IDENT_NICE;
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);
560 sc->typestr = "C-NET(9N)E";
562 /* C-NET(9N)E works only IRQ5. */
563 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0)
566 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "5");
570 /* We need an init hook to initialize ASIC before we start. */
571 sc->init = fe_init_cnet9ne;
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;
583 * Probe for Contec C-NET(98)P2 series.
584 * (Logitec LAN-98TP/LAN-98T25P - parhaps)
587 fe_probe_ssi(device_t dev)
589 struct fe_softc *sc = device_get_softc(dev);
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 },
598 static u_short const irqmap[] = {
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 */
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)
609 if ((iobase & 0xFFF) != 0x3D0)
612 if (fe98_alloc_port(dev, FE_TYPE_SSI))
615 /* Fill the softc struct with default values. */
616 fe_softc_defaults(sc);
618 /* See if the card is on its address. */
619 if (!fe_simple_probe(sc, probe_table))
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);
629 /* Make sure the Ethernet (MAC) station address is of Contec's. */
630 if (!fe_valid_Ether_p(eeprom + FE_SSI_EEP_ADDR, 0x00804C))
632 bcopy(eeprom + FE_SSI_EEP_ADDR, sc->enaddr, ETHER_ADDR_LEN);
634 /* Setup the board type. */
635 sc->typestr = "C-NET(98)P2";
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]];
642 fe_irq_failure(sc->typestr, sc->sc_unit, irq,
646 bus_set_resource(dev, SYS_RES_IRQ, 0, irq, 1);
649 /* Get Duplex-mode configuration from EEPROM. */
650 sc->proto_dlcr4 |= (eeprom[FE_SSI_EEP_DUPLEX] & FE_D4_DSC);
652 /* Fill softc struct accordingly. */
654 sc->defmedia = MB_HT;
661 * Probe for TDK LAC-98012/013/025/9N011 - parhaps.
664 fe_probe_lnx(device_t dev)
666 struct fe_softc *sc = device_get_softc(dev);
669 u_char eeprom [LNX_EEPROM_SIZE];
671 static struct fe_simple_probe_struct probe_table [] = {
672 { FE_DLCR2, 0x58, 0x00 },
673 { FE_DLCR4, 0x08, 0x00 },
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)
681 if ((iobase & ~0xC00) != 0xD0)
684 if (fe98_alloc_port(dev, FE_TYPE_LNX))
687 /* Fill the softc struct with default values. */
688 fe_softc_defaults(sc);
690 /* See if the card is on its address. */
691 if (!fe_simple_probe(sc, probe_table))
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);
699 /* Make sure the Ethernet (MAC) station address is of TDK/LANX's. */
700 if (!fe_valid_Ether_p(eeprom, 0x008098))
702 bcopy(eeprom, sc->enaddr, ETHER_ADDR_LEN);
704 /* Setup the board type. */
705 sc->typestr = "LAC-98012/98013";
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
712 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0)
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;
720 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12");
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;
728 /* Setup hooks. We need a special initialization procedure. */
729 sc->init = fe_init_lnx;
736 * Probe for Gateway Communications' old cards.
737 * (both as Generic MB86960 probe routine)
740 fe_probe_gwy(device_t dev)
742 struct fe_softc *sc = device_get_softc(dev);
744 static struct fe_simple_probe_struct probe_table [] = {
745 /* { FE_DLCR2, 0x70, 0x00 }, */
746 { FE_DLCR2, 0x58, 0x00 },
747 { FE_DLCR4, 0x08, 0x00 },
753 * I'm not sure which address is possible, so accepts any.
756 if (fe98_alloc_port(dev, FE_TYPE_GWY))
759 /* Fill the softc struct with default values. */
760 fe_softc_defaults(sc);
762 /* See if the card is on its address. */
763 if (!fe_simple_probe(sc, probe_table))
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))
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)";
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);
788 * Probe for Ungermann-Bass Access/PC N98C+(Model 85152).
791 fe_probe_ubn(device_t dev)
793 struct fe_softc *sc = device_get_softc(dev);
798 static struct fe_simple_probe_struct const probe_table [] = {
799 { FE_DLCR2, 0x58, 0x00 },
800 { FE_DLCR4, 0x08, 0x00 },
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)
808 if ((iobase & ~0x1C00) != 0xD0)
811 if (fe98_alloc_port(dev, FE_TYPE_UBN))
814 /* Fill the softc struct with default values. */
815 fe_softc_defaults(sc);
818 if (!fe_simple_probe(sc, probe_table))
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. */
826 /* Save the current value for the DLCR7 register we are about
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);
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))
837 /* Calculate checksum. */
838 sum = fe_inb(sc, 0x1e);
839 for (i = 0; i < ETHER_ADDR_LEN; i++)
840 sum ^= sc->enaddr[i];
845 /* Setup the board type. */
846 sc->typestr = "Access/PC";
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
853 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
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;
860 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12");
864 /* Setup hooks. We need a special initialization procedure. */
865 sc->init = fe_init_ubn;
870 fe_outb(sc, FE_DLCR7, save7);
876 * REX boards(non-JLI type) support routine.
879 #define REX_EEPROM_SIZE 32
883 fe_read_eeprom_rex(struct fe_softc *sc, u_char *data)
889 save16 = fe_inb(sc, 0x10);
891 /* Issue a start condition. */
892 val = fe_inb(sc, 0x10) & 0xf0;
893 fe_outb(sc, 0x10, val);
895 (void) fe_inb(sc, 0x10);
896 (void) fe_inb(sc, 0x10);
897 (void) fe_inb(sc, 0x10);
898 (void) fe_inb(sc, 0x10);
900 /* Read bytes from EEPROM. */
901 for (i = 0; i < REX_EEPROM_SIZE; i++) {
902 /* Read a byte and store it into the buffer. */
904 for (bit = 0x01; bit != 0x00; bit <<= 1)
905 if (fe_inb(sc, 0x10) & REX_DAT)
910 fe_outb(sc, 0x10, save16);
913 /* Report what we got. */
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, " ");
926 fe_init_rex(struct fe_softc *sc)
928 /* Setup IRQ control register on the ASIC. */
929 fe_outb(sc, 0x10, sc->priv_info);
933 * Probe for RATOC REX-9880/81/82/83 series.
936 fe_probe_rex(device_t dev)
938 struct fe_softc *sc = device_get_softc(dev);
942 u_char eeprom [REX_EEPROM_SIZE];
944 static struct fe_simple_probe_struct probe_table [] = {
945 { FE_DLCR2, 0x58, 0x00 },
946 { FE_DLCR4, 0x08, 0x00 },
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)
954 if ((iobase & ~0xA00) != 0x64D0)
957 if (fe98_alloc_port(dev, FE_TYPE_REX))
960 /* Fill the softc struct with default values. */
961 fe_softc_defaults(sc);
963 /* See if the card is on its address. */
964 if (!fe_simple_probe(sc, probe_table))
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];
974 /* Make sure it is RATOC's. */
975 if (!fe_valid_Ether_p(sc->enaddr, 0x00C0D0) &&
976 !fe_valid_Ether_p(sc->enaddr, 0x00803D))
979 /* Setup the board type. */
980 sc->typestr = "REX-9880/9883";
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
987 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
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;
994 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12");
998 /* Setup hooks. We need a special initialization procedure. */
999 sc->init = fe_init_rex;
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;
1005 sc->proto_dlcr7 |= FE_D7_EOPPOL; /* XXX */