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
22 * $FreeBSD: src/sys/dev/fe/if_fe_isa.c,v 1.2.2.1 2000/09/22 10:01:47 nyan Exp $
23 * $DragonFly: src/sys/dev/netif/fe/if_fe_isa.c,v 1.3 2003/08/07 21:17:02 dillon Exp $
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
33 #include <sys/socket.h>
34 #include <sys/module.h>
35 #include <machine/clock.h>
38 #include <machine/bus.h>
39 #include <machine/resource.h>
41 #include <net/ethernet.h>
43 #include <net/if_mib.h>
44 #include <net/if_media.h>
46 #include <netinet/in.h>
47 #include <netinet/if_ether.h>
49 #include <i386/isa/ic/mb86960.h>
53 #include <bus/isa/isavar.h>
58 static int fe_isa_probe(device_t);
59 static int fe_isa_attach(device_t);
61 static device_method_t fe_isa_methods[] = {
62 /* Device interface */
63 DEVMETHOD(device_probe, fe_isa_probe),
64 DEVMETHOD(device_attach, fe_isa_attach),
69 static driver_t fe_isa_driver = {
72 sizeof (struct fe_softc)
75 DRIVER_MODULE(fe, isa, fe_isa_driver, fe_devclass, 0, 0);
78 static int fe_probe_ssi(device_t);
79 static int fe_probe_jli(device_t);
80 static int fe_probe_fmv(device_t);
81 static int fe_probe_lnx(device_t);
82 static int fe_probe_gwy(device_t);
83 static int fe_probe_ubn(device_t);
86 * Determine if the device is present at a specified I/O address. The
87 * main entry to the driver.
90 fe_isa_probe(device_t dev)
95 /* Check isapnp ids */
96 if (isa_get_vendorid(dev))
99 /* Prepare for the softc struct. */
100 sc = device_get_softc(dev);
101 sc->sc_unit = device_get_unit(dev);
103 /* Probe for supported boards. */
104 if ((error = fe_probe_ssi(dev)) == 0)
106 fe_release_resource(dev);
108 if ((error = fe_probe_jli(dev)) == 0)
110 fe_release_resource(dev);
112 if ((error = fe_probe_fmv(dev)) == 0)
114 fe_release_resource(dev);
116 if ((error = fe_probe_lnx(dev)) == 0)
118 fe_release_resource(dev);
120 if ((error = fe_probe_ubn(dev)) == 0)
122 fe_release_resource(dev);
124 if ((error = fe_probe_gwy(dev)) == 0)
126 fe_release_resource(dev);
130 error = fe_alloc_irq(dev, 0);
132 fe_release_resource(dev);
137 fe_isa_attach(device_t dev)
139 struct fe_softc *sc = device_get_softc(dev);
142 fe_alloc_port(dev, sc->port_used);
143 fe_alloc_irq(dev, 0);
145 return fe_attach(dev);
150 * Probe and initialization for Fujitsu FMV-180 series boards
154 fe_init_fmv(struct fe_softc *sc)
156 /* Initialize ASIC. */
157 fe_outb(sc, FE_FMV3, 0);
158 fe_outb(sc, FE_FMV10, 0);
161 /* "Refresh" hardware configuration. FIXME. */
162 fe_outb(sc, FE_FMV2, fe_inb(sc, FE_FMV2));
165 /* Turn the "master interrupt control" flag of ASIC on. */
166 fe_outb(sc, FE_FMV3, FE_FMV3_IRQENB);
170 fe_msel_fmv184(struct fe_softc *sc)
174 /* FMV-184 has a special "register" to switch between AUI/BNC.
175 Determine the value to write into the register, based on the
176 user-specified media selection. */
177 port = (IFM_SUBTYPE(sc->media.ifm_media) == IFM_10_2) ? 0x00 : 0x01;
179 /* The register is #5 on exntesion register bank...
180 (Details of the register layout is not yet discovered.) */
181 fe_outb(sc, 0x1B, 0x46); /* ??? */
182 fe_outb(sc, 0x1E, 0x04); /* select ex-reg #4. */
183 fe_outb(sc, 0x1F, 0xC8); /* ??? */
184 fe_outb(sc, 0x1E, 0x05); /* select ex-reg #5. */
185 fe_outb(sc, 0x1F, port); /* Switch the media. */
186 fe_outb(sc, 0x1E, 0x04); /* select ex-reg #4. */
187 fe_outb(sc, 0x1F, 0x00); /* ??? */
188 fe_outb(sc, 0x1B, 0x00); /* ??? */
190 /* Make sure to select "external tranceiver" on MB86964. */
191 fe_outb(sc, FE_BMPR13, sc->proto_bmpr13 | FE_B13_PORT_AUI);
195 fe_probe_fmv(device_t dev)
197 struct fe_softc *sc = device_get_softc(dev);
201 static u_short const irqmap [ 4 ] = { 3, 7, 10, 15 };
203 static struct fe_simple_probe_struct const probe_table [] = {
204 { FE_DLCR2, 0x71, 0x00 },
205 { FE_DLCR4, 0x08, 0x00 },
207 { FE_FMV0, 0x78, 0x50 }, /* ERRDY+PRRDY */
208 { FE_FMV1, 0xB0, 0x00 }, /* FMV-183/4 has 0x48 bits. */
209 { FE_FMV3, 0x7F, 0x00 },
214 /* Board subtypes; it lists known FMV-180 variants. */
221 static struct subtype const typelist [] = {
222 { 0x0005, MB_HA|MB_HT|MB_H5, MB_HA, "FMV-181" },
223 { 0x0105, MB_HA|MB_HT|MB_H5, MB_HA, "FMV-181A" },
224 { 0x0003, MB_HM, MB_HM, "FMV-182" },
225 { 0x0103, MB_HM, MB_HM, "FMV-182A" },
226 { 0x0804, MB_HT, MB_HT, "FMV-183" },
227 { 0x0C04, MB_HT, MB_HT, "FMV-183 (on-board)" },
228 { 0x0803, MB_H2|MB_H5, MB_H2, "FMV-184" },
229 { 0, MB_HA, MB_HA, "unknown FMV-180 (?)" },
231 struct subtype const * type;
233 /* Media indicator and "Hardware revision ID" */
236 /* See if the specified address is possible for FMV-180
237 series. 220, 240, 260, 280, 2A0, 2C0, 300, and 340 are
238 allowed for all boards, and 200, 2E0, 320, 360, 380, 3A0,
239 3C0, and 3E0 for PnP boards. */
240 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
242 if ((iobase & ~0x1E0) != 0x200)
245 /* FMV-180 occupies 32 I/O addresses. */
246 if (fe_alloc_port(dev, 32))
249 /* Setup an I/O address mapping table and some others. */
250 fe_softc_defaults(sc);
253 if (!fe_simple_probe(sc, probe_table))
256 /* Get our station address from EEPROM, and make sure it is
258 fe_inblk(sc, FE_FMV4, sc->sc_enaddr, ETHER_ADDR_LEN);
259 if (!valid_Ether_p(sc->sc_enaddr, 0x00000E))
262 /* Find the supported media and "hardware revision" to know
263 the model identification. */
264 mcode = (fe_inb(sc, FE_FMV0) & FE_FMV0_MEDIA)
265 | ((fe_inb(sc, FE_FMV1) & FE_FMV1_REV) << 8);
267 /* Determine the card type. */
268 for (type = typelist; type->mcode != 0; type++) {
269 if (type->mcode == mcode)
272 if (type->mcode == 0) {
273 /* Unknown card type... Hope the driver works. */
274 sc->stability |= UNSTABLE_TYPE;
276 device_printf(dev, "unknown config: %x-%x-%x-%x\n",
280 fe_inb(sc, FE_FMV3));
284 /* Setup the board type and media information. */
285 sc->type = FE_TYPE_FMV;
286 sc->typestr = type->str;
287 sc->mbitmap = type->mbitmap;
288 sc->defmedia = type->defmedia;
289 sc->msel = fe_msel_965;
291 if (type->mbitmap == (MB_H2 | MB_H5)) {
292 /* FMV184 requires a special media selection procedure. */
293 sc->msel = fe_msel_fmv184;
297 * An FMV-180 has been probed.
298 * Determine which IRQ to be used.
300 * In this version, we give a priority to the kernel config file.
301 * If the EEPROM and config don't match, say it to the user for
304 n = (fe_inb(sc, FE_FMV2) & FE_FMV2_IRS) >> FE_FMV2_IRS_SHIFT;
307 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
309 /* Just use the probed value. */
310 bus_set_resource(dev, SYS_RES_IRQ, 0, irqmap[n], 1);
311 } else if (irq != irqmap[n]) {
313 sc->stability |= UNSTABLE_IRQ;
316 /* We need an init hook to initialize ASIC before we start. */
317 sc->init = fe_init_fmv;
323 * Fujitsu MB86965 JLI mode probe routines.
325 * 86965 has a special operating mode called JLI (mode 0), under which
326 * the chip interfaces with ISA bus with a software-programmable
327 * configuration. (The Fujitsu document calls the feature "Plug and
328 * play," but it is not compatible with the ISA-PnP spec. designed by
329 * Intel and Microsoft.) Ethernet cards designed to use JLI are
330 * almost same, but there are two things which require board-specific
331 * probe routines: EEPROM layout and IRQ pin connection.
333 * JLI provides a handy way to access EEPROM which should contains the
334 * chip configuration information (such as I/O port address) as well
335 * as Ethernet station (MAC) address. The chip configuration info. is
336 * stored on a fixed location. However, the station address can be
337 * located anywhere in the EEPROM; it is up to the board designer to
338 * determine the location. (The manual just says "somewhere in the
339 * EEPROM.") The fe driver must somehow find out the correct
342 * Another problem resides in the IRQ pin connection. JLI provides a
343 * user to choose an IRQ from up to four predefined IRQs. The 86965
344 * chip has a register to select one out of the four possibilities.
345 * However, the selection is against the four IRQ pins on the chip.
346 * (So-called IRQ-A, -B, -C and -D.) It is (again) up to the board
347 * designer to determine which pin to connect which IRQ line on the
348 * ISA bus. We need a vendor (or model, for some vendor) specific IRQ
351 * The routine fe_probe_jli() provides all probe and initialization
352 * processes which are common to all JLI implementation, and sub-probe
353 * routines supply board-specific actions.
355 * JLI sub-probe routine has the following template:
357 * u_short const * func (struct fe_softc * sc, u_char const * eeprom);
359 * where eeprom is a pointer to an array of 32 byte data read from the
360 * config EEPROM on the board. It retuns an IRQ mapping table for the
361 * board, when the corresponding implementation is detected. It
362 * returns a NULL otherwise.
364 * Primary purpose of the functin is to analize the config EEPROM,
365 * determine if it matches with the pattern of that of supported card,
366 * and extract necessary information from it. One of the information
367 * expected to be extracted from EEPROM is the Ethernet station (MAC)
368 * address, which must be set to the softc table of the interface by
369 * the board-specific routine.
372 /* JLI sub-probe for Allied-Telesyn/Allied-Telesis AT1700/RE2000 series. */
373 static u_short const *
374 fe_probe_jli_ati(struct fe_softc * sc, u_char const * eeprom)
377 static u_short const irqmaps_ati [4][4] =
385 /* Make sure the EEPROM contains Allied-Telesis/Allied-Telesyn
387 if (eeprom[1] != 0x00) return NULL;
388 for (i = 2; i < 8; i++) if (eeprom[i] != 0xFF) return NULL;
389 for (i = 14; i < 24; i++) if (eeprom[i] != 0xFF) return NULL;
391 /* Get our station address from EEPROM, and make sure the
392 EEPROM contains ATI's address. */
393 bcopy(eeprom + 8, sc->sc_enaddr, ETHER_ADDR_LEN);
394 if (!valid_Ether_p(sc->sc_enaddr, 0x0000F4))
398 * The following model identification codes are stolen
399 * from the NetBSD port of the fe driver. My reviewers
400 * suggested minor revision.
403 /* Determine the card type. */
404 switch (eeprom[FE_ATI_EEP_MODEL]) {
405 case FE_ATI_MODEL_AT1700T:
406 sc->typestr = "AT-1700T/RE2001";
408 sc->defmedia = MB_HT;
410 case FE_ATI_MODEL_AT1700BT:
411 sc->typestr = "AT-1700BT/RE2003";
412 sc->mbitmap = MB_HA | MB_HT | MB_H2;
414 case FE_ATI_MODEL_AT1700FT:
415 sc->typestr = "AT-1700FT/RE2009";
416 sc->mbitmap = MB_HA | MB_HT | MB_HF;
418 case FE_ATI_MODEL_AT1700AT:
419 sc->typestr = "AT-1700AT/RE2005";
420 sc->mbitmap = MB_HA | MB_HT | MB_H5;
423 sc->typestr = "unknown AT-1700/RE2000";
424 sc->stability |= UNSTABLE_TYPE | UNSTABLE_IRQ;
427 sc->type = FE_TYPE_JLI;
430 /* Should we extract default media from eeprom? Linux driver
431 for AT1700 does it, although previous releases of FreeBSD
433 /* Determine the default media selection from the config
434 EEPROM. The byte at offset EEP_MEDIA is believed to
435 contain BMPR13 value to be set. We just ignore STP bit or
436 squelch bit, since we don't support those. (It is
438 switch (eeprom[FE_ATI_EEP_MEDIA] & FE_B13_PORT) {
440 sc->defmedia = MB_HA;
443 sc->defmedia = MB_HT;
446 sc->defmedia = sc->mbitmap & (MB_H2|MB_H5|MB_H5); /*XXX*/
449 sc->defmedia = MB_HA;
453 /* Make sure the default media is compatible with the supported
455 if ((sc->defmedia & sc->mbitmap) == 0) {
456 if (sc->defmedia == MB_HA) {
457 sc->defmedia = MB_HT;
459 sc->defmedia = MB_HA;
465 * Try to determine IRQ settings.
466 * Different models use different ranges of IRQs.
468 switch ((eeprom[FE_ATI_EEP_REVISION] & 0xf0)
469 |(eeprom[FE_ATI_EEP_MAGIC] & 0x04)) {
470 case 0x30: case 0x34: return irqmaps_ati[3];
471 case 0x10: case 0x14:
472 case 0x50: case 0x54: return irqmaps_ati[2];
473 case 0x44: case 0x64: return irqmaps_ati[1];
474 default: return irqmaps_ati[0];
478 /* JLI sub-probe and msel hook for ICL Ethernet. */
480 fe_msel_icl(struct fe_softc *sc)
484 /* Switch between UTP and "external tranceiver" as always. */
487 /* The board needs one more bit (on DLCR4) be set appropriately. */
488 if (IFM_SUBTYPE(sc->media.ifm_media) == IFM_10_5) {
489 d4 = sc->proto_dlcr4 | FE_D4_CNTRL;
491 d4 = sc->proto_dlcr4 & ~FE_D4_CNTRL;
493 fe_outb(sc, FE_DLCR4, d4);
496 static u_short const *
497 fe_probe_jli_icl(struct fe_softc * sc, u_char const * eeprom)
502 static u_short const irqmap_icl [4] = { 9, 10, 5, 15 };
504 /* Make sure the EEPROM contains ICL bit pattern. */
505 for (i = 24; i < 39; i++) {
506 if (eeprom[i] != 0x20 && (eeprom[i] & 0xF0) != 0x30) return NULL;
508 for (i = 112; i < 122; i++) {
509 if (eeprom[i] != 0x20 && (eeprom[i] & 0xF0) != 0x30) return NULL;
512 /* Make sure the EEPROM contains ICL's permanent station
513 address. If it isn't, probably this board is not an
515 if (!valid_Ether_p(eeprom+122, 0x00004B))
518 /* Check if the "configured" Ethernet address in the EEPROM is
519 valid. Use it if it is, or use the "permanent" address instead. */
520 if (valid_Ether_p(eeprom+4, 0x020000)) {
521 /* The configured address is valid. Use it. */
522 bcopy(eeprom+4, sc->sc_enaddr, ETHER_ADDR_LEN);
524 /* The configured address is invalid. Use permanent. */
525 bcopy(eeprom+122, sc->sc_enaddr, ETHER_ADDR_LEN);
528 /* Determine model and supported media. */
529 switch (eeprom[0x5E]) {
531 sc->typestr = "EtherTeam16i/COMBO";
532 sc->mbitmap = MB_HA | MB_HT | MB_H5 | MB_H2;
535 sc->typestr = "EtherTeam16i/TP";
539 sc->typestr = "EtherTeam16i/ErgoPro";
540 sc->mbitmap = MB_HA | MB_HT | MB_H5;
543 sc->typestr = "EtherTeam16i/DUO";
544 sc->mbitmap = MB_HA | MB_HT | MB_H2;
547 sc->typestr = "EtherTeam16i";
548 sc->stability |= UNSTABLE_TYPE;
550 printf("fe%d: unknown model code %02x for EtherTeam16i\n",
551 sc->sc_unit, eeprom[0x5E]);
555 sc->type = FE_TYPE_JLI;
557 /* I'm not sure the following msel hook is required by all
558 models or COMBO only... FIXME. */
559 sc->msel = fe_msel_icl;
561 /* Make the configured media selection the default media. */
562 switch (eeprom[0x28]) {
563 case 0: defmedia = MB_HA; break;
564 case 1: defmedia = MB_H5; break;
565 case 2: defmedia = MB_HT; break;
566 case 3: defmedia = MB_H2; break;
569 printf("fe%d: unknown default media: %02x\n",
570 sc->sc_unit, eeprom[0x28]);
576 /* Make sure the default media is compatible with the
578 if ((defmedia & sc->mbitmap) == 0) {
580 printf("fe%d: default media adjusted\n", sc->sc_unit);
582 defmedia = sc->mbitmap;
585 /* Keep the determined default media. */
586 sc->defmedia = defmedia;
588 /* ICL has "fat" models. We have to program 86965 to properly
589 reflect the hardware. */
590 d6 = sc->proto_dlcr6 & ~(FE_D6_BUFSIZ | FE_D6_BBW);
591 switch ((eeprom[0x61] << 8) | eeprom[0x60]) {
592 case 0x2008: d6 |= FE_D6_BUFSIZ_32KB | FE_D6_BBW_BYTE; break;
593 case 0x4010: d6 |= FE_D6_BUFSIZ_64KB | FE_D6_BBW_WORD; break;
595 /* We can't support it, since we don't know which bits
597 printf("fe%d: unknown SRAM config for ICL\n", sc->sc_unit);
600 sc->proto_dlcr6 = d6;
602 /* Returns the IRQ table for the ICL board. */
606 /* JLI sub-probe for RATOC REX-5586/5587. */
607 static u_short const *
608 fe_probe_jli_rex(struct fe_softc * sc, u_char const * eeprom)
611 static u_short const irqmap_rex [4] = { 3, 4, 5, NO_IRQ };
613 /* Make sure the EEPROM contains RATOC's config pattern. */
614 if (eeprom[1] != eeprom[0]) return NULL;
615 for (i = 8; i < 32; i++) if (eeprom[i] != 0xFF) return NULL;
617 /* Get our station address from EEPROM. Note that RATOC
618 stores it "byte-swapped" in each word. (I don't know why.)
619 So, we just can't use bcopy().*/
620 sc->sc_enaddr[0] = eeprom[3];
621 sc->sc_enaddr[1] = eeprom[2];
622 sc->sc_enaddr[2] = eeprom[5];
623 sc->sc_enaddr[3] = eeprom[4];
624 sc->sc_enaddr[4] = eeprom[7];
625 sc->sc_enaddr[5] = eeprom[6];
627 /* Make sure the EEPROM contains RATOC's station address. */
628 if (!valid_Ether_p(sc->sc_enaddr, 0x00C0D0))
631 /* I don't know any sub-model identification. */
632 sc->type = FE_TYPE_JLI;
633 sc->typestr = "REX-5586/5587";
635 /* Returns the IRQ for the RATOC board. */
639 /* JLI sub-probe for Unknown board. */
640 static u_short const *
641 fe_probe_jli_unk(struct fe_softc * sc, u_char const * eeprom)
644 static u_short const irqmap [4] = { NO_IRQ, NO_IRQ, NO_IRQ, NO_IRQ };
646 /* The generic JLI probe considered this board has an 86965
647 in JLI mode, but any other board-specific routines could
648 not find the matching implementation. So, we "guess" the
649 location by looking for a bit pattern which looks like a
652 /* Determine how large the EEPROM is. */
653 for (romsize = JLI_EEPROM_SIZE/2; romsize > 16; romsize >>= 1) {
654 for (i = 0; i < romsize; i++) {
655 if (eeprom[i] != eeprom[i+romsize])
663 /* Look for a bit pattern which looks like a MAC address. */
664 for (n = 2; n <= romsize - ETHER_ADDR_LEN; n += 2) {
665 if (!valid_Ether_p(eeprom + n, 0x000000))
669 /* If no reasonable address was found, we can't go further. */
670 if (n > romsize - ETHER_ADDR_LEN)
673 /* Extract our (guessed) station address. */
674 bcopy(eeprom+n, sc->sc_enaddr, ETHER_ADDR_LEN);
676 /* We are not sure what type of board it is... */
677 sc->type = FE_TYPE_JLI;
678 sc->typestr = "(unknown JLI)";
679 sc->stability |= UNSTABLE_TYPE | UNSTABLE_MAC;
681 /* Returns the totally unknown IRQ mapping table. */
686 * Probe and initialization for all JLI implementations.
690 fe_probe_jli(device_t dev)
692 struct fe_softc *sc = device_get_softc(dev);
693 int i, n, error, xirq;
695 u_char eeprom [JLI_EEPROM_SIZE];
696 u_short const * irqmap;
698 static u_short const baseaddr [8] =
699 { 0x260, 0x280, 0x2A0, 0x240, 0x340, 0x320, 0x380, 0x300 };
700 static struct fe_simple_probe_struct const probe_table [] = {
701 { FE_DLCR1, 0x20, 0x00 },
702 { FE_DLCR2, 0x50, 0x00 },
703 { FE_DLCR4, 0x08, 0x00 },
704 { FE_DLCR5, 0x80, 0x00 },
706 { FE_BMPR16, 0x1B, 0x00 },
707 { FE_BMPR17, 0x7F, 0x00 },
713 * See if the specified address is possible for MB86965A JLI mode.
715 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
717 for (i = 0; i < 8; i++) {
718 if (baseaddr[i] == iobase)
724 /* 86965 JLI occupies 32 I/O addresses. */
725 if (fe_alloc_port(dev, 32))
728 /* Fill the softc struct with reasonable default. */
729 fe_softc_defaults(sc);
732 * We should test if MB86965A is on the base address now.
733 * Unfortunately, it is very hard to probe it reliably, since
734 * we have no way to reset the chip under software control.
735 * On cold boot, we could check the "signature" bit patterns
736 * described in the Fujitsu document. On warm boot, however,
737 * we can predict almost nothing about register values.
739 if (!fe_simple_probe(sc, probe_table))
742 /* Check if our I/O address matches config info on 86965. */
743 n = (fe_inb(sc, FE_BMPR19) & FE_B19_ADDR) >> FE_B19_ADDR_SHIFT;
744 if (baseaddr[n] != iobase)
748 * We are now almost sure we have an MB86965 at the given
749 * address. So, read EEPROM through it. We have to write
750 * into LSI registers to read from EEPROM. I want to avoid it
751 * at this stage, but I cannot test the presence of the chip
752 * any further without reading EEPROM. FIXME.
754 fe_read_eeprom_jli(sc, eeprom);
756 /* Make sure that config info in EEPROM and 86965 agree. */
757 if (eeprom[FE_EEPROM_CONF] != fe_inb(sc, FE_BMPR19))
760 /* Use 86965 media selection scheme, unless othewise
761 specified. It is "AUTO always" and "select with BMPR13."
762 This behaviour covers most of the 86965 based board (as
763 minimum requirements.) It is backward compatible with
764 previous versions, also. */
766 sc->defmedia = MB_HA;
767 sc->msel = fe_msel_965;
769 /* Perform board-specific probe, one by one. Note that the
770 order of probe is important and should not be changed
772 if ((irqmap = fe_probe_jli_ati(sc, eeprom)) == NULL
773 && (irqmap = fe_probe_jli_rex(sc, eeprom)) == NULL
774 && (irqmap = fe_probe_jli_icl(sc, eeprom)) == NULL
775 && (irqmap = fe_probe_jli_unk(sc, eeprom)) == NULL)
778 /* Find the IRQ read from EEPROM. */
779 n = (fe_inb(sc, FE_BMPR19) & FE_B19_IRQ) >> FE_B19_IRQ_SHIFT;
782 /* Try to determine IRQ setting. */
783 error = bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
784 if (error && xirq == NO_IRQ) {
785 /* The device must be configured with an explicit IRQ. */
786 device_printf(dev, "IRQ auto-detection does not work\n");
788 } else if (error && xirq != NO_IRQ) {
789 /* Just use the probed IRQ value. */
790 bus_set_resource(dev, SYS_RES_IRQ, 0, xirq, 1);
791 } else if (!error && xirq == NO_IRQ) {
792 /* No problem. Go ahead. */
793 } else if (irq == xirq) {
794 /* Good. Go ahead. */
796 /* User must be warned in this case. */
797 sc->stability |= UNSTABLE_IRQ;
800 /* Setup a hook, which resets te 86965 when the driver is being
801 initialized. This may solve a nasty bug. FIXME. */
802 sc->init = fe_init_jli;
807 /* Probe for TDK LAK-AX031, which is an SSi 78Q8377A based board. */
809 fe_probe_ssi(device_t dev)
811 struct fe_softc *sc = device_get_softc(dev);
814 u_char eeprom [SSI_EEPROM_SIZE];
815 static struct fe_simple_probe_struct probe_table [] = {
816 { FE_DLCR2, 0x08, 0x00 },
817 { FE_DLCR4, 0x08, 0x00 },
821 /* See if the specified I/O address is possible for 78Q8377A. */
822 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
824 if ((iobase & ~0x3F0) != 0x000)
827 /* We have 16 registers. */
828 if (fe_alloc_port(dev, 16))
831 /* Fill the softc struct with default values. */
832 fe_softc_defaults(sc);
834 /* See if the card is on its address. */
835 if (!fe_simple_probe(sc, probe_table))
838 /* We now have to read the config EEPROM. We should be very
839 careful, since doing so destroys a register. (Remember, we
840 are not yet sure we have a LAK-AX031 board here.) Don't
841 remember to select BMPRs bofore reading EEPROM, since other
842 register bank may be selected before the probe() is called. */
843 fe_read_eeprom_ssi(sc, eeprom);
845 /* Make sure the Ethernet (MAC) station address is of TDK's. */
846 if (!valid_Ether_p(eeprom+FE_SSI_EEP_ADDR, 0x008098))
848 bcopy(eeprom + FE_SSI_EEP_ADDR, sc->sc_enaddr, ETHER_ADDR_LEN);
850 /* This looks like a TDK-AX031 board. It requires an explicit
851 IRQ setting in config, since we currently don't know how we
852 can find the IRQ value assigned by ISA PnP manager. */
853 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0) {
854 fe_irq_failure("LAK-AX031", sc->sc_unit, NO_IRQ, NULL);
858 /* Fill softc struct accordingly. */
859 sc->type = FE_TYPE_SSI;
860 sc->typestr = "LAK-AX031";
862 sc->defmedia = MB_HT;
868 * Probe and initialization for TDK/LANX LAC-AX012/013 boards.
871 fe_probe_lnx(device_t dev)
873 struct fe_softc *sc = device_get_softc(dev);
876 u_char eeprom [LNX_EEPROM_SIZE];
877 static struct fe_simple_probe_struct probe_table [] = {
878 { FE_DLCR2, 0x58, 0x00 },
879 { FE_DLCR4, 0x08, 0x00 },
883 /* See if the specified I/O address is possible for TDK/LANX boards. */
884 /* 300, 320, 340, and 360 are allowed. */
885 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
887 if ((iobase & ~0x060) != 0x300)
890 /* We have 32 registers. */
891 if (fe_alloc_port(dev, 32))
894 /* Fill the softc struct with default values. */
895 fe_softc_defaults(sc);
897 /* See if the card is on its address. */
898 if (!fe_simple_probe(sc, probe_table))
901 /* We now have to read the config EEPROM. We should be very
902 careful, since doing so destroys a register. (Remember, we
903 are not yet sure we have a LAC-AX012/AX013 board here.) */
904 fe_read_eeprom_lnx(sc, eeprom);
906 /* Make sure the Ethernet (MAC) station address is of TDK/LANX's. */
907 if (!valid_Ether_p(eeprom, 0x008098))
909 bcopy(eeprom, sc->sc_enaddr, ETHER_ADDR_LEN);
911 /* This looks like a TDK/LANX board. It requires an
912 explicit IRQ setting in config. Make sure we have one,
913 determining an appropriate value for the IRQ control
916 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
918 case 3: sc->priv_info = 0x40 | LNX_CLK_LO | LNX_SDA_HI; break;
919 case 4: sc->priv_info = 0x20 | LNX_CLK_LO | LNX_SDA_HI; break;
920 case 5: sc->priv_info = 0x10 | LNX_CLK_LO | LNX_SDA_HI; break;
921 case 9: sc->priv_info = 0x80 | LNX_CLK_LO | LNX_SDA_HI; break;
923 fe_irq_failure("LAC-AX012/AX013", sc->sc_unit, irq, "3/4/5/9");
927 /* Fill softc struct accordingly. */
928 sc->type = FE_TYPE_LNX;
929 sc->typestr = "LAC-AX012/AX013";
930 sc->init = fe_init_lnx;
936 * Probe and initialization for Gateway Communications' old cards.
939 fe_probe_gwy(device_t dev)
941 struct fe_softc *sc = device_get_softc(dev);
944 static struct fe_simple_probe_struct probe_table [] = {
945 /* { FE_DLCR2, 0x70, 0x00 }, */
946 { FE_DLCR2, 0x58, 0x00 },
947 { FE_DLCR4, 0x08, 0x00 },
951 /* See if the specified I/O address is possible for Gateway boards. */
952 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
954 if ((iobase & ~0x1E0) != 0x200)
957 /* That's all. The card occupies 32 I/O addresses, as always. */
958 if (fe_alloc_port(dev, 32))
961 /* Setup an I/O address mapping table and some others. */
962 fe_softc_defaults(sc);
964 /* See if the card is on its address. */
965 if (!fe_simple_probe(sc, probe_table))
968 /* Get our station address from EEPROM. */
969 fe_inblk(sc, 0x18, sc->sc_enaddr, ETHER_ADDR_LEN);
971 /* Make sure it is Gateway Communication's. */
972 if (!valid_Ether_p(sc->sc_enaddr, 0x000061))
975 /* Gateway's board requires an explicit IRQ to work, since it
976 is not possible to probe the setting of jumpers. */
977 if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0) {
978 fe_irq_failure("Gateway Ethernet", sc->sc_unit, NO_IRQ, NULL);
982 /* Fill softc struct accordingly. */
983 sc->type = FE_TYPE_GWY;
984 sc->typestr = "Gateway Ethernet (Fujitsu chipset)";
989 /* Probe and initialization for Ungermann-Bass Network
990 K.K. "Access/PC" boards. */
992 fe_probe_ubn(device_t dev)
994 struct fe_softc *sc = device_get_softc(dev);
999 static struct fe_simple_probe_struct const probe_table [] = {
1000 { FE_DLCR2, 0x58, 0x00 },
1001 { FE_DLCR4, 0x08, 0x00 },
1005 /* See if the specified I/O address is possible for AccessPC/ISA. */
1006 if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
1008 if ((iobase & ~0x0E0) != 0x300)
1011 /* We have 32 registers. */
1012 if (fe_alloc_port(dev, 32))
1015 /* Setup an I/O address mapping table and some others. */
1016 fe_softc_defaults(sc);
1019 if (!fe_simple_probe(sc, probe_table))
1022 /* Get our station address form ID ROM and make sure it is UBN's. */
1023 fe_inblk(sc, 0x18, sc->sc_enaddr, ETHER_ADDR_LEN);
1024 if (!valid_Ether_p(sc->sc_enaddr, 0x00DD01))
1027 /* Calculate checksum. */
1028 sum = fe_inb(sc, 0x1e);
1029 for (i = 0; i < ETHER_ADDR_LEN; i++) {
1030 sum ^= sc->sc_enaddr[i];
1035 /* This looks like an AccessPC/ISA board. It requires an
1036 explicit IRQ setting in config. Make sure we have one,
1037 determining an appropriate value for the IRQ control
1040 bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
1042 case 3: sc->priv_info = 0x02; break;
1043 case 4: sc->priv_info = 0x04; break;
1044 case 5: sc->priv_info = 0x08; break;
1045 case 10: sc->priv_info = 0x10; break;
1047 fe_irq_failure("Access/PC", sc->sc_unit, irq, "3/4/5/10");
1051 /* Fill softc struct accordingly. */
1052 sc->type = FE_TYPE_UBN;
1053 sc->typestr = "Access/PC";
1054 sc->init = fe_init_ubn;