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>
36 #include <machine/resource.h>
38 #include <net/ethernet.h>
40 #include <net/if_mib.h>
41 #include <net/if_media.h>
43 #include <netinet/in.h>
44 #include <netinet/if_ether.h>
46 #include <dev/fe/mb86960.h>
47 #include <dev/fe/if_fereg.h>
48 #include <dev/fe/if_fevar.h>
50 #include <isa/isavar.h>
55 static int fe_isa_probe(device_t);
56 static int fe_isa_attach(device_t);
58 static struct isa_pnp_id fe_ids[] = {
59 { 0x101ee0d, NULL }, /* CON0101 - Contec C-NET(98)P2-T */
63 static device_method_t fe_isa_methods[] = {
64 /* Device interface */
65 DEVMETHOD(device_probe, fe_isa_probe),
66 DEVMETHOD(device_attach, fe_isa_attach),
71 static driver_t fe_isa_driver = {
74 sizeof (struct fe_softc)
77 DRIVER_MODULE(fe, isa, fe_isa_driver, fe_devclass, 0, 0);
80 static int fe98_alloc_port(device_t, int);
82 static int fe_probe_re1000(device_t);
83 static int fe_probe_cnet9ne(device_t);
84 static int fe_probe_rex(device_t);
85 static int fe_probe_ssi(device_t);
86 static int fe_probe_jli(device_t);
87 static int fe_probe_lnx(device_t);
88 static int fe_probe_gwy(device_t);
89 static int fe_probe_ubn(device_t);
92 * Determine if the device is present at a specified I/O address. The
93 * main entry to the driver.
96 fe_isa_probe(device_t dev)
101 /* Prepare for the softc struct. */
102 sc = device_get_softc(dev);
103 sc->sc_unit = device_get_unit(dev);
105 /* Check isapnp ids */
106 error = ISA_PNP_PROBE(device_get_parent(dev), dev, fe_ids);
108 /* If the card had a PnP ID that didn't match any we know about */
112 /* If we had some other problem. */
113 if (!(error == 0 || error == ENOENT))
116 /* Probe for supported boards. */
117 if ((error = fe_probe_re1000(dev)) == 0)
119 fe_release_resource(dev);
121 if ((error = fe_probe_cnet9ne(dev)) == 0)
123 fe_release_resource(dev);
125 if ((error = fe_probe_rex(dev)) == 0)
127 fe_release_resource(dev);
129 if ((error = fe_probe_ssi(dev)) == 0)
131 fe_release_resource(dev);
133 if ((error = fe_probe_jli(dev)) == 0)
135 fe_release_resource(dev);
137 if ((error = fe_probe_lnx(dev)) == 0)
139 fe_release_resource(dev);
141 if ((error = fe_probe_ubn(dev)) == 0)
143 fe_release_resource(dev);
145 if ((error = fe_probe_gwy(dev)) == 0)
147 fe_release_resource(dev);
151 error = fe_alloc_irq(dev, 0);
153 fe_release_resource(dev);
158 fe_isa_attach(device_t dev)
160 struct fe_softc *sc = device_get_softc(dev);
163 fe98_alloc_port(dev, sc->type);
164 fe_alloc_irq(dev, 0);
166 return fe_attach(dev);
170 /* Generic I/O address table */
171 static bus_addr_t ioaddr_generic[MAXREGISTERS] = {
172 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007,
173 0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f,
174 0x010, 0x011, 0x012, 0x013, 0x014, 0x015, 0x016, 0x017,
175 0x018, 0x019, 0x01a, 0x01b, 0x01c, 0x01d, 0x01e, 0x01f,
178 /* I/O address table for RE1000/1000Plus */
179 static bus_addr_t ioaddr_re1000[MAXREGISTERS] = {
180 0x0000, 0x0001, 0x0200, 0x0201, 0x0400, 0x0401, 0x0600, 0x0601,
181 0x0800, 0x0801, 0x0a00, 0x0a01, 0x0c00, 0x0c01, 0x0e00, 0x0e01,
182 0x1000, 0x1200, 0x1400, 0x1600, 0x1800, 0x1a00, 0x1c00, 0x1e00,
183 0x1001, 0x1201, 0x1401, 0x1601, 0x1801, 0x1a01, 0x1c01, 0x1e01,
186 /* I/O address table for CNET9NE */
187 static bus_addr_t ioaddr_cnet9ne[MAXREGISTERS] = {
188 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007,
189 0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f,
190 0x400, 0x402, 0x404, 0x406, 0x408, 0x40a, 0x40c, 0x40e,
191 0x401, 0x403, 0x405, 0x407, 0x409, 0x40b, 0x40d, 0x40f,
194 /* I/O address table for LAC-98 */
195 static bus_addr_t ioaddr_lnx[MAXREGISTERS] = {
196 0x000, 0x002, 0x004, 0x006, 0x008, 0x00a, 0x00c, 0x00e,
197 0x100, 0x102, 0x104, 0x106, 0x108, 0x10a, 0x10c, 0x10e,
198 0x200, 0x202, 0x204, 0x206, 0x208, 0x20a, 0x20c, 0x20e,
199 0x300, 0x302, 0x304, 0x306, 0x308, 0x30a, 0x30c, 0x30e,
202 /* I/O address table for Access/PC N98C+ */
203 static bus_addr_t ioaddr_ubn[MAXREGISTERS] = {
204 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007,
205 0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f,
206 0x200, 0x201, 0x202, 0x203, 0x204, 0x205, 0x206, 0x207,
207 0x208, 0x209, 0x20a, 0x20b, 0x20c, 0x20d, 0x20e, 0x20f,
210 /* I/O address table for REX-9880 */
211 static bus_addr_t ioaddr_rex[MAXREGISTERS] = {
212 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007,
213 0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f,
214 0x100, 0x101, 0x102, 0x103, 0x104, 0x105, 0x106, 0x107,
215 0x108, 0x109, 0x10a, 0x10b, 0x10c, 0x10d, 0x10e, 0x10f,
219 fe98_alloc_port(device_t dev, int type)
221 struct fe_softc *sc = device_get_softc(dev);
222 struct resource *res;
231 case FE_TYPE_CNET9NE:
232 iat = ioaddr_cnet9ne;
236 iat = ioaddr_generic;
244 iat = ioaddr_generic;
256 iat = ioaddr_generic;
262 res = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &rid,
263 iat, size, RF_ACTIVE);
267 isa_load_resourcev(res, iat, size);
270 sc->port_used = size;
272 sc->iot = rman_get_bustag(res);
273 sc->ioh = rman_get_bushandle(res);
279 * Probe and initialization for Allied-Telesis RE1000 series.
282 fe_init_re1000(struct fe_softc *sc)
284 /* Setup IRQ control register on the ASIC. */
285 fe_outb(sc, FE_RE1000_IRQCONF, sc->priv_info);
289 fe_probe_re1000(device_t dev)
291 struct fe_softc *sc = device_get_softc(dev);
296 static struct fe_simple_probe_struct probe_table [] = {
297 { FE_DLCR2, 0x58, 0x00 },
298 { FE_DLCR4, 0x08, 0x00 },
302 /* See if the specified I/O address is possible for RE1000. */
303 /* [01]D[02468ACE] are allowed. */
304 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
306 if ((iobase & ~0x10E) != 0xD0)
309 if (fe98_alloc_port(dev, FE_TYPE_RE1000))
312 /* Fill the softc struct with default values. */
313 fe_softc_defaults(sc);
315 /* See if the card is on its address. */
316 if (!fe_simple_probe(sc, probe_table))
319 /* Get our station address from EEPROM. */
320 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN);
322 /* Make sure it is Allied-Telesis's. */
323 if (!fe_valid_Ether_p(sc->enaddr, 0x0000F4))
326 /* Calculate checksum. */
327 sum = fe_inb(sc, 0x1e);
328 for (i = 0; i < ETHER_ADDR_LEN; i++)
329 sum ^= sc->enaddr[i];
333 /* Setup the board type. */
334 sc->typestr = "RE1000";
336 /* This looks like an RE1000 board. It requires an
337 explicit IRQ setting in config. Make sure we have one,
338 determining an appropriate value for the IRQ control
341 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
343 case 3: n = 0x10; break;
344 case 5: n = 0x20; break;
345 case 6: n = 0x40; break;
346 case 12: n = 0x80; break;
348 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12");
351 sc->priv_info = (fe_inb(sc, FE_RE1000_IRQCONF) & 0x0f) | n;
353 /* Setup hooks. We need a special initialization procedure. */
354 sc->init = fe_init_re1000;
359 /* JLI sub-probe for Allied-Telesis RE1000Plus/ME1500 series. */
360 static u_short const *
361 fe_probe_jli_re1000p(struct fe_softc * sc, u_char const * eeprom)
364 static u_short const irqmaps_re1000p [4] = { 3, 5, 6, 12 };
366 /* Make sure the EEPROM contains Allied-Telesis bit pattern. */
367 if (eeprom[1] != 0xFF) return NULL;
368 for (i = 2; i < 8; i++) if (eeprom[i] != 0xFF) return NULL;
369 for (i = 14; i < 24; i++) if (eeprom[i] != 0xFF) return NULL;
371 /* Get our station address from EEPROM, and make sure the
372 EEPROM contains Allied-Telesis's address. */
373 bcopy(eeprom + 8, sc->enaddr, ETHER_ADDR_LEN);
374 if (!fe_valid_Ether_p(sc->enaddr, 0x0000F4))
377 /* I don't know any sub-model identification. */
378 sc->typestr = "RE1000Plus/ME1500";
380 /* Returns the IRQ table for the RE1000Plus. */
381 return irqmaps_re1000p;
386 * Probe for Allied-Telesis RE1000Plus/ME1500 series.
389 fe_probe_jli(device_t dev)
391 struct fe_softc *sc = device_get_softc(dev);
392 int i, n, xirq, error;
394 u_char eeprom [JLI_EEPROM_SIZE];
395 u_short const * irqmap;
397 static u_short const baseaddr [8] =
398 { 0x1D6, 0x1D8, 0x1DA, 0x1D4, 0x0D4, 0x0D2, 0x0D8, 0x0D0 };
399 static struct fe_simple_probe_struct const probe_table [] = {
400 /* { FE_DLCR1, 0x20, 0x00 }, Doesn't work. */
401 { FE_DLCR2, 0x50, 0x00 },
402 { FE_DLCR4, 0x08, 0x00 },
403 /* { FE_DLCR5, 0x80, 0x00 }, Doesn't work. */
405 { FE_BMPR16, 0x1B, 0x00 },
406 { FE_BMPR17, 0x7F, 0x00 },
412 * See if the specified address is possible for MB86965A JLI mode.
414 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
416 for (i = 0; i < 8; i++) {
417 if (baseaddr[i] == iobase)
423 if (fe98_alloc_port(dev, FE_TYPE_RE1000))
426 /* Fill the softc struct with default values. */
427 fe_softc_defaults(sc);
430 * We should test if MB86965A is on the base address now.
431 * Unfortunately, it is very hard to probe it reliably, since
432 * we have no way to reset the chip under software control.
433 * On cold boot, we could check the "signature" bit patterns
434 * described in the Fujitsu document. On warm boot, however,
435 * we can predict almost nothing about register values.
437 if (!fe_simple_probe(sc, probe_table))
440 /* Check if our I/O address matches config info on 86965. */
441 n = (fe_inb(sc, FE_BMPR19) & FE_B19_ADDR) >> FE_B19_ADDR_SHIFT;
442 if (baseaddr[n] != iobase)
446 * We are now almost sure we have an MB86965 at the given
447 * address. So, read EEPROM through it. We have to write
448 * into LSI registers to read from EEPROM. I want to avoid it
449 * at this stage, but I cannot test the presence of the chip
450 * any further without reading EEPROM. FIXME.
452 fe_read_eeprom_jli(sc, eeprom);
454 /* Make sure that config info in EEPROM and 86965 agree. */
455 if (eeprom[FE_EEPROM_CONF] != fe_inb(sc, FE_BMPR19))
458 /* Use 86965 media selection scheme, unless othewise
459 specified. It is "AUTO always" and "select with BMPR13".
460 This behaviour covers most of the 86965 based board (as
461 minimum requirements.) It is backward compatible with
462 previous versions, also. */
464 sc->defmedia = MB_HA;
465 sc->msel = fe_msel_965;
467 /* Perform board-specific probe. */
468 if ((irqmap = fe_probe_jli_re1000p(sc, eeprom)) == NULL)
471 /* Find the IRQ read from EEPROM. */
472 n = (fe_inb(sc, FE_BMPR19) & FE_B19_IRQ) >> FE_B19_IRQ_SHIFT;
475 /* Try to determine IRQ setting. */
476 error = bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
477 if (error && xirq == NO_IRQ) {
478 /* The device must be configured with an explicit IRQ. */
479 device_printf(dev, "IRQ auto-detection does not work\n");
481 } else if (error && xirq != NO_IRQ) {
482 /* Just use the probed IRQ value. */
483 bus_set_resource(dev, SYS_RES_IRQ, 0, xirq, 1);
484 } else if (!error && xirq == NO_IRQ) {
485 /* No problem. Go ahead. */
486 } else if (irq == xirq) {
487 /* Good. Go ahead. */
489 /* User must be warned in this case. */
490 sc->stability |= UNSTABLE_IRQ;
493 /* Setup a hook, which resets te 86965 when the driver is being
494 initialized. This may solve a nasty bug. FIXME. */
495 sc->init = fe_init_jli;
502 * Probe and initialization for Contec C-NET(9N)E series.
505 /* TODO: Should be in "if_fereg.h" */
506 #define FE_CNET9NE_INTR 0x10 /* Interrupt Mask? */
509 fe_init_cnet9ne(struct fe_softc *sc)
511 /* Enable interrupt? FIXME. */
512 fe_outb(sc, FE_CNET9NE_INTR, 0x10);
516 fe_probe_cnet9ne (device_t dev)
518 struct fe_softc *sc = device_get_softc(dev);
521 static struct fe_simple_probe_struct probe_table [] = {
522 { FE_DLCR2, 0x58, 0x00 },
523 { FE_DLCR4, 0x08, 0x00 },
527 /* See if the specified I/O address is possible for C-NET(9N)E. */
528 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
530 if (iobase != 0x73D0)
533 if (fe98_alloc_port(dev, FE_TYPE_CNET9NE))
536 /* Fill the softc struct with default values. */
537 fe_softc_defaults(sc);
539 /* See if the card is on its address. */
540 if (!fe_simple_probe(sc, probe_table))
543 /* Get our station address from EEPROM. */
544 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN);
546 /* Make sure it is Contec's. */
547 if (!fe_valid_Ether_p(sc->enaddr, 0x00804C))
550 /* Determine the card type. */
551 if (sc->enaddr[3] == 0x06) {
552 sc->typestr = "C-NET(9N)C";
554 /* We seems to need our own IDENT bits... FIXME. */
555 sc->proto_dlcr7 = FE_D7_BYTSWP_LH | FE_D7_IDENT_NICE;
557 /* C-NET(9N)C requires an explicit IRQ to work. */
558 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0) {
559 fe_irq_failure(sc->typestr, sc->sc_unit, NO_IRQ, NULL);
563 sc->typestr = "C-NET(9N)E";
565 /* C-NET(9N)E works only IRQ5. */
566 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0)
569 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "5");
573 /* We need an init hook to initialize ASIC before we start. */
574 sc->init = fe_init_cnet9ne;
577 /* C-NET(9N)E has 64KB SRAM. */
578 sc->proto_dlcr6 = FE_D6_BUFSIZ_64KB | FE_D6_TXBSIZ_2x4KB
579 | FE_D6_BBW_WORD | FE_D6_SBW_WORD | FE_D6_SRAM;
586 * Probe for Contec C-NET(98)P2 series.
587 * (Logitec LAN-98TP/LAN-98T25P - parhaps)
590 fe_probe_ssi(device_t dev)
592 struct fe_softc *sc = device_get_softc(dev);
595 u_char eeprom [SSI_EEPROM_SIZE];
596 static struct fe_simple_probe_struct probe_table [] = {
597 { FE_DLCR2, 0x08, 0x00 },
598 { FE_DLCR4, 0x08, 0x00 },
601 static u_short const irqmap[] = {
603 NO_IRQ, NO_IRQ, NO_IRQ, 3, NO_IRQ, 5, 6, NO_IRQ,
604 NO_IRQ, 9, 10, NO_IRQ, 12, 13, NO_IRQ, NO_IRQ,
605 /* INT3 INT41 INT5 INT6 */
608 /* See if the specified I/O address is possible for 78Q8377A. */
609 /* [0-D]3D0 are allowed. */
610 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
612 if ((iobase & 0xFFF) != 0x3D0)
615 if (fe98_alloc_port(dev, FE_TYPE_SSI))
618 /* Fill the softc struct with default values. */
619 fe_softc_defaults(sc);
621 /* See if the card is on its address. */
622 if (!fe_simple_probe(sc, probe_table))
625 /* We now have to read the config EEPROM. We should be very
626 careful, since doing so destroys a register. (Remember, we
627 are not yet sure we have a C-NET(98)P2 board here.) Don't
628 remember to select BMPRs bofore reading EEPROM, since other
629 register bank may be selected before the probe() is called. */
630 fe_read_eeprom_ssi(sc, eeprom);
632 /* Make sure the Ethernet (MAC) station address is of Contec's. */
633 if (!fe_valid_Ether_p(eeprom + FE_SSI_EEP_ADDR, 0x00804C))
635 bcopy(eeprom + FE_SSI_EEP_ADDR, sc->enaddr, ETHER_ADDR_LEN);
637 /* Setup the board type. */
638 sc->typestr = "C-NET(98)P2";
640 /* Non-PnP mode, set static resource from eeprom. */
641 if (!isa_get_vendorid(dev)) {
642 /* Get IRQ configuration from EEPROM. */
643 irq = irqmap[eeprom[FE_SSI_EEP_IRQ]];
645 fe_irq_failure(sc->typestr, sc->sc_unit, irq,
649 bus_set_resource(dev, SYS_RES_IRQ, 0, irq, 1);
652 /* Get Duplex-mode configuration from EEPROM. */
653 sc->proto_dlcr4 |= (eeprom[FE_SSI_EEP_DUPLEX] & FE_D4_DSC);
655 /* Fill softc struct accordingly. */
657 sc->defmedia = MB_HT;
664 * Probe for TDK LAC-98012/013/025/9N011 - parhaps.
667 fe_probe_lnx(device_t dev)
669 struct fe_softc *sc = device_get_softc(dev);
672 u_char eeprom [LNX_EEPROM_SIZE];
674 static struct fe_simple_probe_struct probe_table [] = {
675 { FE_DLCR2, 0x58, 0x00 },
676 { FE_DLCR4, 0x08, 0x00 },
680 /* See if the specified I/O address is possible for TDK/LANX boards. */
681 /* 0D0, 4D0, 8D0, and CD0 are allowed. */
682 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
684 if ((iobase & ~0xC00) != 0xD0)
687 if (fe98_alloc_port(dev, FE_TYPE_LNX))
690 /* Fill the softc struct with default values. */
691 fe_softc_defaults(sc);
693 /* See if the card is on its address. */
694 if (!fe_simple_probe(sc, probe_table))
697 /* We now have to read the config EEPROM. We should be very
698 careful, since doing so destroys a register. (Remember, we
699 are not yet sure we have a LAC-98012/98013 board here.) */
700 fe_read_eeprom_lnx(sc, eeprom);
702 /* Make sure the Ethernet (MAC) station address is of TDK/LANX's. */
703 if (!fe_valid_Ether_p(eeprom, 0x008098))
705 bcopy(eeprom, sc->enaddr, ETHER_ADDR_LEN);
707 /* Setup the board type. */
708 sc->typestr = "LAC-98012/98013";
710 /* This looks like a TDK/LANX board. It requires an
711 explicit IRQ setting in config. Make sure we have one,
712 determining an appropriate value for the IRQ control
715 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0)
718 case 3 : sc->priv_info = 0x10 | LNX_CLK_LO | LNX_SDA_HI; break;
719 case 5 : sc->priv_info = 0x20 | LNX_CLK_LO | LNX_SDA_HI; break;
720 case 6 : sc->priv_info = 0x40 | LNX_CLK_LO | LNX_SDA_HI; break;
721 case 12: sc->priv_info = 0x80 | LNX_CLK_LO | LNX_SDA_HI; break;
723 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12");
727 /* LAC-98's system bus width is 8-bit. */
728 sc->proto_dlcr6 = FE_D6_BUFSIZ_32KB | FE_D6_TXBSIZ_2x2KB
729 | FE_D6_BBW_BYTE | FE_D6_SBW_BYTE | FE_D6_SRAM_150ns;
731 /* Setup hooks. We need a special initialization procedure. */
732 sc->init = fe_init_lnx;
739 * Probe for Gateway Communications' old cards.
740 * (both as Generic MB86960 probe routine)
743 fe_probe_gwy(device_t dev)
745 struct fe_softc *sc = device_get_softc(dev);
747 static struct fe_simple_probe_struct probe_table [] = {
748 /* { FE_DLCR2, 0x70, 0x00 }, */
749 { FE_DLCR2, 0x58, 0x00 },
750 { FE_DLCR4, 0x08, 0x00 },
756 * I'm not sure which address is possible, so accepts any.
759 if (fe98_alloc_port(dev, FE_TYPE_GWY))
762 /* Fill the softc struct with default values. */
763 fe_softc_defaults(sc);
765 /* See if the card is on its address. */
766 if (!fe_simple_probe(sc, probe_table))
769 /* Get our station address from EEPROM. */
770 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN);
771 if (!fe_valid_Ether_p(sc->enaddr, 0x000000))
774 /* Determine the card type. */
775 sc->typestr = "Generic MB86960 Ethernet";
776 if (fe_valid_Ether_p(sc->enaddr, 0x000061))
777 sc->typestr = "Gateway Ethernet (Fujitsu chipset)";
779 /* Gateway's board requires an explicit IRQ to work, since it
780 is not possible to probe the setting of jumpers. */
781 if (bus_get_resource(dev, SYS_RES_IRQ, 0, NULL, NULL) != 0) {
782 fe_irq_failure(sc->typestr, sc->sc_unit, NO_IRQ, NULL);
791 * Probe for Ungermann-Bass Access/PC N98C+(Model 85152).
794 fe_probe_ubn(device_t dev)
796 struct fe_softc *sc = device_get_softc(dev);
801 static struct fe_simple_probe_struct const probe_table [] = {
802 { FE_DLCR2, 0x58, 0x00 },
803 { FE_DLCR4, 0x08, 0x00 },
807 /* See if the specified I/O address is possible for Access/PC. */
808 /* [01][048C]D0 are allowed. */
809 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
811 if ((iobase & ~0x1C00) != 0xD0)
814 if (fe98_alloc_port(dev, FE_TYPE_UBN))
817 /* Fill the softc struct with default values. */
818 fe_softc_defaults(sc);
821 if (!fe_simple_probe(sc, probe_table))
824 /* NOTE: Access/NOTE N98 sometimes freeze when reading station
825 address. In case of using it togather with C-NET(9N)C,
826 this problem usually happens.
827 Writing DLCR7 prevents freezing, but I don't know why. FIXME. */
829 /* Save the current value for the DLCR7 register we are about
831 save7 = fe_inb(sc, FE_DLCR7);
832 fe_outb(sc, FE_DLCR7,
833 sc->proto_dlcr7 | FE_D7_RBS_BMPR | FE_D7_POWER_UP);
835 /* Get our station address form ID ROM and make sure it is UBN's. */
836 fe_inblk(sc, 0x18, sc->enaddr, ETHER_ADDR_LEN);
837 if (!fe_valid_Ether_p(sc->enaddr, 0x00DD01))
840 /* Calculate checksum. */
841 sum = fe_inb(sc, 0x1e);
842 for (i = 0; i < ETHER_ADDR_LEN; i++)
843 sum ^= sc->enaddr[i];
848 /* Setup the board type. */
849 sc->typestr = "Access/PC";
851 /* This looks like an AccessPC/N98C+ board. It requires an
852 explicit IRQ setting in config. Make sure we have one,
853 determining an appropriate value for the IRQ control
856 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
858 case 3: sc->priv_info = 0x01; break;
859 case 5: sc->priv_info = 0x02; break;
860 case 6: sc->priv_info = 0x04; break;
861 case 12: sc->priv_info = 0x08; break;
863 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12");
867 /* Setup hooks. We need a special initialization procedure. */
868 sc->init = fe_init_ubn;
873 fe_outb(sc, FE_DLCR7, save7);
879 * REX boards(non-JLI type) support routine.
882 #define REX_EEPROM_SIZE 32
886 fe_read_eeprom_rex(struct fe_softc *sc, u_char *data)
892 save16 = fe_inb(sc, 0x10);
894 /* Issue a start condition. */
895 val = fe_inb(sc, 0x10) & 0xf0;
896 fe_outb(sc, 0x10, val);
898 (void) fe_inb(sc, 0x10);
899 (void) fe_inb(sc, 0x10);
900 (void) fe_inb(sc, 0x10);
901 (void) fe_inb(sc, 0x10);
903 /* Read bytes from EEPROM. */
904 for (i = 0; i < REX_EEPROM_SIZE; i++) {
905 /* Read a byte and store it into the buffer. */
907 for (bit = 0x01; bit != 0x00; bit <<= 1)
908 if (fe_inb(sc, 0x10) & REX_DAT)
913 fe_outb(sc, 0x10, save16);
916 /* Report what we got. */
918 data -= REX_EEPROM_SIZE;
919 for (i = 0; i < REX_EEPROM_SIZE; i += 16) {
920 printf("fe%d: EEPROM(REX):%3x: %16D\n",
921 sc->sc_unit, i, data + i, " ");
929 fe_init_rex(struct fe_softc *sc)
931 /* Setup IRQ control register on the ASIC. */
932 fe_outb(sc, 0x10, sc->priv_info);
936 * Probe for RATOC REX-9880/81/82/83 series.
939 fe_probe_rex(device_t dev)
941 struct fe_softc *sc = device_get_softc(dev);
945 u_char eeprom [REX_EEPROM_SIZE];
947 static struct fe_simple_probe_struct probe_table [] = {
948 { FE_DLCR2, 0x58, 0x00 },
949 { FE_DLCR4, 0x08, 0x00 },
953 /* See if the specified I/O address is possible for REX-9880. */
954 /* 6[46CE]D0 are allowed. */
955 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
957 if ((iobase & ~0xA00) != 0x64D0)
960 if (fe98_alloc_port(dev, FE_TYPE_REX))
963 /* Fill the softc struct with default values. */
964 fe_softc_defaults(sc);
966 /* See if the card is on its address. */
967 if (!fe_simple_probe(sc, probe_table))
970 /* We now have to read the config EEPROM. We should be very
971 careful, since doing so destroys a register. (Remember, we
972 are not yet sure we have a REX-9880 board here.) */
973 fe_read_eeprom_rex(sc, eeprom);
974 for (i = 0; i < ETHER_ADDR_LEN; i++)
975 sc->enaddr[i] = eeprom[7 - i];
977 /* Make sure it is RATOC's. */
978 if (!fe_valid_Ether_p(sc->enaddr, 0x00C0D0) &&
979 !fe_valid_Ether_p(sc->enaddr, 0x00803D))
982 /* Setup the board type. */
983 sc->typestr = "REX-9880/9883";
985 /* This looks like a REX-9880 board. It requires an
986 explicit IRQ setting in config. Make sure we have one,
987 determining an appropriate value for the IRQ control
990 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
992 case 3: sc->priv_info = 0x10; break;
993 case 5: sc->priv_info = 0x20; break;
994 case 6: sc->priv_info = 0x40; break;
995 case 12: sc->priv_info = 0x80; break;
997 fe_irq_failure(sc->typestr, sc->sc_unit, irq, "3/5/6/12");
1001 /* Setup hooks. We need a special initialization procedure. */
1002 sc->init = fe_init_rex;
1004 /* REX-9880 has 64KB SRAM. */
1005 sc->proto_dlcr6 = FE_D6_BUFSIZ_64KB | FE_D6_TXBSIZ_2x4KB
1006 | FE_D6_BBW_WORD | FE_D6_SBW_WORD | FE_D6_SRAM;
1008 sc->proto_dlcr7 |= FE_D7_EOPPOL; /* XXX */