sys/dev/netif/fe/if_fe_isa.c

   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  * $FreeBSD: src/sys/dev/fe/if_fe_isa.c,v 1.2.2.1 2000/09/22 10:01:47 nyan Exp $
  23  */
  24
  25 #include "opt_fe.h"
  26 #include "opt_inet.h"
  27 #include "opt_ipx.h"
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/kernel.h>
  32 #include <sys/socket.h>
  33 #include <sys/module.h>
  34 #include <sys/bus.h>
  35 #include <sys/machintr.h>
  36
  37 #include <machine/clock.h>
  38
  39 #include <net/ethernet.h>
  40 #include <net/if.h>
  41 #include <net/if_mib.h>
  42 #include <net/if_media.h>
  43
  44 #include <netinet/in.h>
  45 #include <netinet/if_ether.h>
  46
  47 #include <machine_base/isa/ic/mb86960.h>
  48 #include "if_fereg.h"
  49 #include "if_fevar.h"
  50
  51 #include <bus/isa/isavar.h>
  52
  53 /*
  54  *      ISA specific code.
  55  */
  56 static int fe_isa_probe(device_t);
  57 static int fe_isa_attach(device_t);
  58
  59 static device_method_t fe_isa_methods[] = {
  60         /* Device interface */
  61         DEVMETHOD(device_probe,         fe_isa_probe),
  62         DEVMETHOD(device_attach,        fe_isa_attach),
  63
  64         { 0, 0 }
  65 };
  66
  67 static driver_t fe_isa_driver = {
  68         "fe",
  69         fe_isa_methods,
  70         sizeof (struct fe_softc)
  71 };
  72
  73 DRIVER_MODULE(if_fe, isa, fe_isa_driver, fe_devclass, NULL, NULL);
  74
  75
  76 static int fe_probe_ssi(device_t);
  77 static int fe_probe_jli(device_t);
  78 static int fe_probe_fmv(device_t);
  79 static int fe_probe_lnx(device_t);
  80 static int fe_probe_gwy(device_t);
  81 static int fe_probe_ubn(device_t);
  82
  83 /*
  84  * Determine if the device is present at a specified I/O address.  The
  85  * main entry to the driver.
  86  */
  87 static int
  88 fe_isa_probe(device_t dev)
  89 {
  90         struct fe_softc *sc;
  91         int error;
  92
  93         /* Check isapnp ids */
  94         if (isa_get_vendorid(dev))
  95                 return (ENXIO);
  96
  97         /* Prepare for the softc struct.  */
  98         sc = device_get_softc(dev);
  99         sc->sc_unit = device_get_unit(dev);
 100
 101         /* Probe for supported boards.  */
 102         if ((error = fe_probe_ssi(dev)) == 0)
 103                 goto end;
 104         fe_release_resource(dev);
 105
 106         if ((error = fe_probe_jli(dev)) == 0)
 107                 goto end;
 108         fe_release_resource(dev);
 109
 110         if ((error = fe_probe_fmv(dev)) == 0)
 111                 goto end;
 112         fe_release_resource(dev);
 113
 114         if ((error = fe_probe_lnx(dev)) == 0)
 115                 goto end;
 116         fe_release_resource(dev);
 117
 118         if ((error = fe_probe_ubn(dev)) == 0)
 119                 goto end;
 120         fe_release_resource(dev);
 121
 122         if ((error = fe_probe_gwy(dev)) == 0)
 123                 goto end;
 124         fe_release_resource(dev);
 125
 126 end:
 127         if (error == 0)
 128                 error = fe_alloc_irq(dev, 0);
 129
 130         fe_release_resource(dev);
 131         return (error);
 132 }
 133
 134 static int
 135 fe_isa_attach(device_t dev)
 136 {
 137         struct fe_softc *sc = device_get_softc(dev);
 138
 139         if (sc->port_used)
 140                 fe_alloc_port(dev, sc->port_used);
 141         fe_alloc_irq(dev, 0);
 142
 143         return fe_attach(dev);
 144 }
 145
 146
 147 /*
 148  * Probe and initialization for Fujitsu FMV-180 series boards
 149  */
 150
 151 static void
 152 fe_init_fmv(struct fe_softc *sc)
 153 {
 154         /* Initialize ASIC.  */
 155         fe_outb(sc, FE_FMV3, 0);
 156         fe_outb(sc, FE_FMV10, 0);
 157
 158 #if 0
 159         /* "Refresh" hardware configuration.  FIXME.  */
 160         fe_outb(sc, FE_FMV2, fe_inb(sc, FE_FMV2));
 161 #endif
 162
 163         /* Turn the "master interrupt control" flag of ASIC on.  */
 164         fe_outb(sc, FE_FMV3, FE_FMV3_IRQENB);
 165 }
 166
 167 static void
 168 fe_msel_fmv184(struct fe_softc *sc)
 169 {
 170         u_char port;
 171
 172         /* FMV-184 has a special "register" to switch between AUI/BNC.
 173            Determine the value to write into the register, based on the
 174            user-specified media selection.  */
 175         port = (IFM_SUBTYPE(sc->media.ifm_media) == IFM_10_2) ? 0x00 : 0x01;
 176
 177         /* The register is #5 on exntesion register bank...
 178            (Details of the register layout is not yet discovered.)  */
 179         fe_outb(sc, 0x1B, 0x46);        /* ??? */
 180         fe_outb(sc, 0x1E, 0x04);        /* select ex-reg #4.  */
 181         fe_outb(sc, 0x1F, 0xC8);        /* ??? */
 182         fe_outb(sc, 0x1E, 0x05);        /* select ex-reg #5.  */
 183         fe_outb(sc, 0x1F, port);        /* Switch the media.  */
 184         fe_outb(sc, 0x1E, 0x04);        /* select ex-reg #4.  */
 185         fe_outb(sc, 0x1F, 0x00);        /* ??? */
 186         fe_outb(sc, 0x1B, 0x00);        /* ??? */
 187
 188         /* Make sure to select "external tranceiver" on MB86964.  */
 189         fe_outb(sc, FE_BMPR13, sc->proto_bmpr13 | FE_B13_PORT_AUI);
 190 }
 191
 192 static int
 193 fe_probe_fmv(device_t dev)
 194 {
 195         struct fe_softc *sc = device_get_softc(dev);
 196         int n;
 197         u_long iobase, irq;
 198
 199         static u_short const irqmap [ 4 ] = { 3, 7, 10, 15 };
 200
 201         static struct fe_simple_probe_struct const probe_table [] = {
 202                 { FE_DLCR2, 0x71, 0x00 },
 203                 { FE_DLCR4, 0x08, 0x00 },
 204
 205                 { FE_FMV0, 0x78, 0x50 },        /* ERRDY+PRRDY */
 206                 { FE_FMV1, 0xB0, 0x00 },        /* FMV-183/4 has 0x48 bits. */
 207                 { FE_FMV3, 0x7F, 0x00 },
 208
 209                 { 0 }
 210         };
 211
 212         /* Board subtypes; it lists known FMV-180 variants.  */
 213         struct subtype {
 214                 u_short mcode;
 215                 u_short mbitmap;
 216                 u_short defmedia;
 217                 char const * str;
 218         };
 219         static struct subtype const typelist [] = {
 220             { 0x0005, MB_HA|MB_HT|MB_H5, MB_HA, "FMV-181"               },
 221             { 0x0105, MB_HA|MB_HT|MB_H5, MB_HA, "FMV-181A"              },
 222             { 0x0003, MB_HM,             MB_HM, "FMV-182"               },
 223             { 0x0103, MB_HM,             MB_HM, "FMV-182A"              },
 224             { 0x0804, MB_HT,             MB_HT, "FMV-183"               },
 225             { 0x0C04, MB_HT,             MB_HT, "FMV-183 (on-board)"    },
 226             { 0x0803, MB_H2|MB_H5,       MB_H2, "FMV-184"               },
 227             { 0,      MB_HA,             MB_HA, "unknown FMV-180 (?)"   },
 228         };
 229         struct subtype const * type;
 230
 231         /* Media indicator and "Hardware revision ID"  */
 232         u_short mcode;
 233
 234         /* See if the specified address is possible for FMV-180
 235            series.  220, 240, 260, 280, 2A0, 2C0, 300, and 340 are
 236            allowed for all boards, and 200, 2E0, 320, 360, 380, 3A0,
 237            3C0, and 3E0 for PnP boards.  */
 238         if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
 239                 return ENXIO;
 240         if ((iobase & ~0x1E0) != 0x200)
 241                 return ENXIO;
 242
 243         /* FMV-180 occupies 32 I/O addresses. */
 244         if (fe_alloc_port(dev, 32))
 245                 return ENXIO;
 246
 247         /* Setup an I/O address mapping table and some others.  */
 248         fe_softc_defaults(sc);
 249
 250         /* Simple probe.  */
 251         if (!fe_simple_probe(sc, probe_table))
 252                 return ENXIO;
 253
 254         /* Get our station address from EEPROM, and make sure it is
 255            Fujitsu's.  */
 256         fe_inblk(sc, FE_FMV4, sc->sc_enaddr, ETHER_ADDR_LEN);
 257         if (!valid_Ether_p(sc->sc_enaddr, 0x00000E))
 258                 return ENXIO;
 259
 260         /* Find the supported media and "hardware revision" to know
 261            the model identification.  */
 262         mcode = (fe_inb(sc, FE_FMV0) & FE_FMV0_MEDIA)
 263              | ((fe_inb(sc, FE_FMV1) & FE_FMV1_REV) << 8);
 264
 265         /* Determine the card type.  */
 266         for (type = typelist; type->mcode != 0; type++) {
 267                 if (type->mcode == mcode)
 268                         break;
 269         }
 270         if (type->mcode == 0) {
 271                 /* Unknown card type...  Hope the driver works.  */
 272                 sc->stability |= UNSTABLE_TYPE;
 273                 if (bootverbose) {
 274                         device_printf(dev, "unknown config: %x-%x-%x-%x\n",
 275                                       fe_inb(sc, FE_FMV0),
 276                                       fe_inb(sc, FE_FMV1),
 277                                       fe_inb(sc, FE_FMV2),
 278                                       fe_inb(sc, FE_FMV3));
 279                 }
 280         }
 281
 282         /* Setup the board type and media information.  */
 283         sc->type = FE_TYPE_FMV;
 284         sc->typestr = type->str;
 285         sc->mbitmap = type->mbitmap;
 286         sc->defmedia = type->defmedia;
 287         sc->msel = fe_msel_965;
 288
 289         if (type->mbitmap == (MB_H2 | MB_H5)) {
 290                 /* FMV184 requires a special media selection procedure.  */
 291                 sc->msel = fe_msel_fmv184;
 292         }
 293
 294         /*
 295          * An FMV-180 has been probed.
 296          * Determine which IRQ to be used.
 297          *
 298          * In this version, we give a priority to the kernel config file.
 299          * If the EEPROM and config don't match, say it to the user for
 300          * an attention.
 301          */
 302         n = (fe_inb(sc, FE_FMV2) & FE_FMV2_IRS) >> FE_FMV2_IRS_SHIFT;
 303
 304         irq = 0;
 305         bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
 306         if (irq == NO_IRQ) {
 307                 int intr = irqmap[n];
 308
 309                 /* Just use the probed value.  */
 310                 bus_set_resource(dev, SYS_RES_IRQ, 0, intr, 1,
 311                     machintr_legacy_intr_cpuid(intr));
 312         } else if (irq != irqmap[n]) {
 313                 /* Don't match.  */
 314                 sc->stability |= UNSTABLE_IRQ;
 315         }
 316
 317         /* We need an init hook to initialize ASIC before we start.  */
 318         sc->init = fe_init_fmv;
 319
 320         return 0;
 321 }
 322
 323 /*
 324  * Fujitsu MB86965 JLI mode probe routines.
 325  *
 326  * 86965 has a special operating mode called JLI (mode 0), under which
 327  * the chip interfaces with ISA bus with a software-programmable
 328  * configuration.  (The Fujitsu document calls the feature "Plug and
 329  * play," but it is not compatible with the ISA-PnP spec. designed by
 330  * Intel and Microsoft.)  Ethernet cards designed to use JLI are
 331  * almost same, but there are two things which require board-specific
 332  * probe routines: EEPROM layout and IRQ pin connection.
 333  *
 334  * JLI provides a handy way to access EEPROM which should contains the
 335  * chip configuration information (such as I/O port address) as well
 336  * as Ethernet station (MAC) address.  The chip configuration info. is
 337  * stored on a fixed location.  However, the station address can be
 338  * located anywhere in the EEPROM; it is up to the board designer to
 339  * determine the location.  (The manual just says "somewhere in the
 340  * EEPROM.")  The fe driver must somehow find out the correct
 341  * location.
 342  *
 343  * Another problem resides in the IRQ pin connection.  JLI provides a
 344  * user to choose an IRQ from up to four predefined IRQs.  The 86965
 345  * chip has a register to select one out of the four possibilities.
 346  * However, the selection is against the four IRQ pins on the chip.
 347  * (So-called IRQ-A, -B, -C and -D.)  It is (again) up to the board
 348  * designer to determine which pin to connect which IRQ line on the
 349  * ISA bus.  We need a vendor (or model, for some vendor) specific IRQ
 350  * mapping table.
 351  *
 352  * The routine fe_probe_jli() provides all probe and initialization
 353  * processes which are common to all JLI implementation, and sub-probe
 354  * routines supply board-specific actions.
 355  *
 356  * JLI sub-probe routine has the following template:
 357  *
 358  *      u_short const * func (struct fe_softc * sc, u_char const * eeprom);
 359  *
 360  * where eeprom is a pointer to an array of 32 byte data read from the
 361  * config EEPROM on the board.  It retuns an IRQ mapping table for the
 362  * board, when the corresponding implementation is detected.  It
 363  * returns a NULL otherwise.
 364  *
 365  * Primary purpose of the functin is to analize the config EEPROM,
 366  * determine if it matches with the pattern of that of supported card,
 367  * and extract necessary information from it.  One of the information
 368  * expected to be extracted from EEPROM is the Ethernet station (MAC)
 369  * address, which must be set to the softc table of the interface by
 370  * the board-specific routine.
 371  */
 372
 373 /* JLI sub-probe for Allied-Telesyn/Allied-Telesis AT1700/RE2000 series.  */
 374 static u_short const *
 375 fe_probe_jli_ati(struct fe_softc * sc, u_char const * eeprom)
 376 {
 377         int i;
 378         static u_short const irqmaps_ati [4][4] =
 379         {
 380                 {  3,  4,  5,  9 },
 381                 { 10, 11, 12, 15 },
 382                 {  3, 11,  5, 15 },
 383                 { 10, 11, 14, 15 },
 384         };
 385
 386         /* Make sure the EEPROM contains Allied-Telesis/Allied-Telesyn
 387            bit pattern.  */
 388         if (eeprom[1] != 0x00) return NULL;
 389         for (i =  2; i <  8; i++) if (eeprom[i] != 0xFF) return NULL;
 390         for (i = 14; i < 24; i++) if (eeprom[i] != 0xFF) return NULL;
 391
 392         /* Get our station address from EEPROM, and make sure the
 393            EEPROM contains ATI's address.  */
 394         bcopy(eeprom + 8, sc->sc_enaddr, ETHER_ADDR_LEN);
 395         if (!valid_Ether_p(sc->sc_enaddr, 0x0000F4))
 396                 return NULL;
 397
 398         /*
 399          * The following model identification codes are stolen
 400          * from the NetBSD port of the fe driver.  My reviewers
 401          * suggested minor revision.
 402          */
 403
 404         /* Determine the card type.  */
 405         switch (eeprom[FE_ATI_EEP_MODEL]) {
 406           case FE_ATI_MODEL_AT1700T:
 407                 sc->typestr = "AT-1700T/RE2001";
 408                 sc->mbitmap = MB_HT;
 409                 sc->defmedia = MB_HT;
 410                 break;
 411           case FE_ATI_MODEL_AT1700BT:
 412                 sc->typestr = "AT-1700BT/RE2003";
 413                 sc->mbitmap = MB_HA | MB_HT | MB_H2;
 414                 break;
 415           case FE_ATI_MODEL_AT1700FT:
 416                 sc->typestr = "AT-1700FT/RE2009";
 417                 sc->mbitmap = MB_HA | MB_HT | MB_HF;
 418                 break;
 419           case FE_ATI_MODEL_AT1700AT:
 420                 sc->typestr = "AT-1700AT/RE2005";
 421                 sc->mbitmap = MB_HA | MB_HT | MB_H5;
 422                 break;
 423           default:
 424                 sc->typestr = "unknown AT-1700/RE2000";
 425                 sc->stability |= UNSTABLE_TYPE | UNSTABLE_IRQ;
 426                 break;
 427         }
 428         sc->type = FE_TYPE_JLI;
 429
 430 #if 0
 431         /* Should we extract default media from eeprom?  Linux driver
 432            for AT1700 does it, although previous releases of FreeBSD
 433            don't.  FIXME.  */
 434         /* Determine the default media selection from the config
 435            EEPROM.  The byte at offset EEP_MEDIA is believed to
 436            contain BMPR13 value to be set.  We just ignore STP bit or
 437            squelch bit, since we don't support those.  (It is
 438            intentional.)  */
 439         switch (eeprom[FE_ATI_EEP_MEDIA] & FE_B13_PORT) {
 440             case FE_B13_AUTO:
 441                 sc->defmedia = MB_HA;
 442                 break;
 443             case FE_B13_TP:
 444                 sc->defmedia = MB_HT;
 445                 break;
 446             case FE_B13_AUI:
 447                 sc->defmedia = sc->mbitmap & (MB_H2|MB_H5|MB_H5); /*XXX*/
 448                 break;
 449             default:
 450                 sc->defmedia = MB_HA;
 451                 break;
 452         }
 453
 454         /* Make sure the default media is compatible with the supported
 455            ones.  */
 456         if ((sc->defmedia & sc->mbitmap) == 0) {
 457                 if (sc->defmedia == MB_HA) {
 458                         sc->defmedia = MB_HT;
 459                 } else {
 460                         sc->defmedia = MB_HA;
 461                 }
 462         }
 463 #endif
 464
 465         /*
 466          * Try to determine IRQ settings.
 467          * Different models use different ranges of IRQs.
 468          */
 469         switch ((eeprom[FE_ATI_EEP_REVISION] & 0xf0)
 470                |(eeprom[FE_ATI_EEP_MAGIC]    & 0x04)) {
 471             case 0x30: case 0x34: return irqmaps_ati[3];
 472             case 0x10: case 0x14:
 473             case 0x50: case 0x54: return irqmaps_ati[2];
 474             case 0x44: case 0x64: return irqmaps_ati[1];
 475             default:              return irqmaps_ati[0];
 476         }
 477 }
 478
 479 /* JLI sub-probe and msel hook for ICL Ethernet.  */
 480 static void
 481 fe_msel_icl(struct fe_softc *sc)
 482 {
 483         u_char d4;
 484
 485         /* Switch between UTP and "external tranceiver" as always.  */
 486         fe_msel_965(sc);
 487
 488         /* The board needs one more bit (on DLCR4) be set appropriately.  */
 489         if (IFM_SUBTYPE(sc->media.ifm_media) == IFM_10_5) {
 490                 d4 = sc->proto_dlcr4 | FE_D4_CNTRL;
 491         } else {
 492                 d4 = sc->proto_dlcr4 & ~FE_D4_CNTRL;
 493         }
 494         fe_outb(sc, FE_DLCR4, d4);
 495 }
 496
 497 static u_short const *
 498 fe_probe_jli_icl(struct fe_softc * sc, u_char const * eeprom)
 499 {
 500         int i;
 501         u_short defmedia;
 502         u_char d6;
 503         static u_short const irqmap_icl [4] = { 9, 10, 5, 15 };
 504
 505         /* Make sure the EEPROM contains ICL bit pattern.  */
 506         for (i = 24; i < 39; i++) {
 507             if (eeprom[i] != 0x20 && (eeprom[i] & 0xF0) != 0x30) return NULL;
 508         }
 509         for (i = 112; i < 122; i++) {
 510             if (eeprom[i] != 0x20 && (eeprom[i] & 0xF0) != 0x30) return NULL;
 511         }
 512
 513         /* Make sure the EEPROM contains ICL's permanent station
 514            address.  If it isn't, probably this board is not an
 515            ICL's.  */
 516         if (!valid_Ether_p(eeprom+122, 0x00004B))
 517                 return NULL;
 518
 519         /* Check if the "configured" Ethernet address in the EEPROM is
 520            valid.  Use it if it is, or use the "permanent" address instead.  */
 521         if (valid_Ether_p(eeprom+4, 0x020000)) {
 522                 /* The configured address is valid.  Use it.  */
 523                 bcopy(eeprom+4, sc->sc_enaddr, ETHER_ADDR_LEN);
 524         } else {
 525                 /* The configured address is invalid.  Use permanent.  */
 526                 bcopy(eeprom+122, sc->sc_enaddr, ETHER_ADDR_LEN);
 527         }
 528
 529         /* Determine model and supported media.  */
 530         switch (eeprom[0x5E]) {
 531             case 0:
 532                 sc->typestr = "EtherTeam16i/COMBO";
 533                 sc->mbitmap = MB_HA | MB_HT | MB_H5 | MB_H2;
 534                 break;
 535             case 1:
 536                 sc->typestr = "EtherTeam16i/TP";
 537                 sc->mbitmap = MB_HT;
 538                 break;
 539             case 2:
 540                 sc->typestr = "EtherTeam16i/ErgoPro";
 541                 sc->mbitmap = MB_HA | MB_HT | MB_H5;
 542                 break;
 543             case 4:
 544                 sc->typestr = "EtherTeam16i/DUO";
 545                 sc->mbitmap = MB_HA | MB_HT | MB_H2;
 546                 break;
 547             default:
 548                 sc->typestr = "EtherTeam16i";
 549                 sc->stability |= UNSTABLE_TYPE;
 550                 if (bootverbose) {
 551                     kprintf("fe%d: unknown model code %02x for EtherTeam16i\n",
 552                            sc->sc_unit, eeprom[0x5E]);
 553                 }
 554                 break;
 555         }
 556         sc->type = FE_TYPE_JLI;
 557
 558         /* I'm not sure the following msel hook is required by all
 559            models or COMBO only...  FIXME.  */
 560         sc->msel = fe_msel_icl;
 561
 562         /* Make the configured media selection the default media.  */
 563         switch (eeprom[0x28]) {
 564             case 0: defmedia = MB_HA; break;
 565             case 1: defmedia = MB_H5; break;
 566             case 2: defmedia = MB_HT; break;
 567             case 3: defmedia = MB_H2; break;
 568             default:
 569                 if (bootverbose) {
 570                         kprintf("fe%d: unknown default media: %02x\n",
 571                                sc->sc_unit, eeprom[0x28]);
 572                 }
 573                 defmedia = MB_HA;
 574                 break;
 575         }
 576
 577         /* Make sure the default media is compatible with the
 578            supported media.  */
 579         if ((defmedia & sc->mbitmap) == 0) {
 580                 if (bootverbose) {
 581                         kprintf("fe%d: default media adjusted\n", sc->sc_unit);
 582                 }
 583                 defmedia = sc->mbitmap;
 584         }
 585
 586         /* Keep the determined default media.  */
 587         sc->defmedia = defmedia;
 588
 589         /* ICL has "fat" models.  We have to program 86965 to properly
 590            reflect the hardware.  */
 591         d6 = sc->proto_dlcr6 & ~(FE_D6_BUFSIZ | FE_D6_BBW);
 592         switch ((eeprom[0x61] << 8) | eeprom[0x60]) {
 593             case 0x2008: d6 |= FE_D6_BUFSIZ_32KB | FE_D6_BBW_BYTE; break;
 594             case 0x4010: d6 |= FE_D6_BUFSIZ_64KB | FE_D6_BBW_WORD; break;
 595             default:
 596                 /* We can't support it, since we don't know which bits
 597                    to set in DLCR6.  */
 598                 kprintf("fe%d: unknown SRAM config for ICL\n", sc->sc_unit);
 599                 return NULL;
 600         }
 601         sc->proto_dlcr6 = d6;
 602
 603         /* Returns the IRQ table for the ICL board.  */
 604         return irqmap_icl;
 605 }
 606
 607 /* JLI sub-probe for RATOC REX-5586/5587.  */
 608 static u_short const *
 609 fe_probe_jli_rex(struct fe_softc * sc, u_char const * eeprom)
 610 {
 611         int i;
 612         static u_short const irqmap_rex [4] = { 3, 4, 5, NO_IRQ };
 613
 614         /* Make sure the EEPROM contains RATOC's config pattern.  */
 615         if (eeprom[1] != eeprom[0]) return NULL;
 616         for (i = 8; i < 32; i++) if (eeprom[i] != 0xFF) return NULL;
 617
 618         /* Get our station address from EEPROM.  Note that RATOC
 619            stores it "byte-swapped" in each word.  (I don't know why.)
 620            So, we just can't use bcopy().*/
 621         sc->sc_enaddr[0] = eeprom[3];
 622         sc->sc_enaddr[1] = eeprom[2];
 623         sc->sc_enaddr[2] = eeprom[5];
 624         sc->sc_enaddr[3] = eeprom[4];
 625         sc->sc_enaddr[4] = eeprom[7];
 626         sc->sc_enaddr[5] = eeprom[6];
 627
 628         /* Make sure the EEPROM contains RATOC's station address.  */
 629         if (!valid_Ether_p(sc->sc_enaddr, 0x00C0D0))
 630                 return NULL;
 631
 632         /* I don't know any sub-model identification.  */
 633         sc->type = FE_TYPE_JLI;
 634         sc->typestr = "REX-5586/5587";
 635
 636         /* Returns the IRQ for the RATOC board.  */
 637         return irqmap_rex;
 638 }
 639
 640 /* JLI sub-probe for Unknown board.  */
 641 static u_short const *
 642 fe_probe_jli_unk(struct fe_softc * sc, u_char const * eeprom)
 643 {
 644         int i, n, romsize;
 645         static u_short const irqmap [4] = { NO_IRQ, NO_IRQ, NO_IRQ, NO_IRQ };
 646
 647         /* The generic JLI probe considered this board has an 86965
 648            in JLI mode, but any other board-specific routines could
 649            not find the matching implementation.  So, we "guess" the
 650            location by looking for a bit pattern which looks like a
 651            MAC address.  */
 652
 653         /* Determine how large the EEPROM is.  */
 654         for (romsize = JLI_EEPROM_SIZE/2; romsize > 16; romsize >>= 1) {
 655                 for (i = 0; i < romsize; i++) {
 656                         if (eeprom[i] != eeprom[i+romsize])
 657                                 break;
 658                 }
 659                 if (i < romsize)
 660                         break;
 661         }
 662         romsize <<= 1;
 663
 664         /* Look for a bit pattern which looks like a MAC address.  */
 665         for (n = 2; n <= romsize - ETHER_ADDR_LEN; n += 2) {
 666                 if (!valid_Ether_p(eeprom + n, 0x000000))
 667                         continue;
 668         }
 669
 670         /* If no reasonable address was found, we can't go further.  */
 671         if (n > romsize - ETHER_ADDR_LEN)
 672                 return NULL;
 673
 674         /* Extract our (guessed) station address.  */
 675         bcopy(eeprom+n, sc->sc_enaddr, ETHER_ADDR_LEN);
 676
 677         /* We are not sure what type of board it is... */
 678         sc->type = FE_TYPE_JLI;
 679         sc->typestr = "(unknown JLI)";
 680         sc->stability |= UNSTABLE_TYPE | UNSTABLE_MAC;
 681
 682         /* Returns the totally unknown IRQ mapping table.  */
 683         return irqmap;
 684 }
 685
 686 /*
 687  * Probe and initialization for all JLI implementations.
 688  */
 689
 690 static int
 691 fe_probe_jli(device_t dev)
 692 {
 693         struct fe_softc *sc = device_get_softc(dev);
 694         int i, n, error, xirq;
 695         u_long iobase, irq;
 696         u_char eeprom [JLI_EEPROM_SIZE];
 697         u_short const * irqmap;
 698
 699         static u_short const baseaddr [8] =
 700                 { 0x260, 0x280, 0x2A0, 0x240, 0x340, 0x320, 0x380, 0x300 };
 701         static struct fe_simple_probe_struct const probe_table [] = {
 702                 { FE_DLCR1,  0x20, 0x00 },
 703                 { FE_DLCR2,  0x50, 0x00 },
 704                 { FE_DLCR4,  0x08, 0x00 },
 705                 { FE_DLCR5,  0x80, 0x00 },
 706 #if 0
 707                 { FE_BMPR16, 0x1B, 0x00 },
 708                 { FE_BMPR17, 0x7F, 0x00 },
 709 #endif
 710                 { 0 }
 711         };
 712
 713         /*
 714          * See if the specified address is possible for MB86965A JLI mode.
 715          */
 716         if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
 717                 return ENXIO;
 718         for (i = 0; i < 8; i++) {
 719                 if (baseaddr[i] == iobase)
 720                         break;
 721         }
 722         if (i == 8)
 723                 return ENXIO;
 724
 725         /* 86965 JLI occupies 32 I/O addresses. */
 726         if (fe_alloc_port(dev, 32))
 727                 return ENXIO;
 728
 729         /* Fill the softc struct with reasonable default.  */
 730         fe_softc_defaults(sc);
 731
 732         /*
 733          * We should test if MB86965A is on the base address now.
 734          * Unfortunately, it is very hard to probe it reliably, since
 735          * we have no way to reset the chip under software control.
 736          * On cold boot, we could check the "signature" bit patterns
 737          * described in the Fujitsu document.  On warm boot, however,
 738          * we can predict almost nothing about register values.
 739          */
 740         if (!fe_simple_probe(sc, probe_table))
 741                 return ENXIO;
 742
 743         /* Check if our I/O address matches config info on 86965.  */
 744         n = (fe_inb(sc, FE_BMPR19) & FE_B19_ADDR) >> FE_B19_ADDR_SHIFT;
 745         if (baseaddr[n] != iobase)
 746                 return ENXIO;
 747
 748         /*
 749          * We are now almost sure we have an MB86965 at the given
 750          * address.  So, read EEPROM through it.  We have to write
 751          * into LSI registers to read from EEPROM.  I want to avoid it
 752          * at this stage, but I cannot test the presence of the chip
 753          * any further without reading EEPROM.  FIXME.
 754          */
 755         fe_read_eeprom_jli(sc, eeprom);
 756
 757         /* Make sure that config info in EEPROM and 86965 agree.  */
 758         if (eeprom[FE_EEPROM_CONF] != fe_inb(sc, FE_BMPR19))
 759                 return ENXIO;
 760
 761         /* Use 86965 media selection scheme, unless othewise
 762            specified.  It is "AUTO always" and "select with BMPR13."
 763            This behaviour covers most of the 86965 based board (as
 764            minimum requirements.)  It is backward compatible with
 765            previous versions, also.  */
 766         sc->mbitmap = MB_HA;
 767         sc->defmedia = MB_HA;
 768         sc->msel = fe_msel_965;
 769
 770         /* Perform board-specific probe, one by one.  Note that the
 771            order of probe is important and should not be changed
 772            arbitrarily.  */
 773         if ((irqmap = fe_probe_jli_ati(sc, eeprom)) == NULL
 774          && (irqmap = fe_probe_jli_rex(sc, eeprom)) == NULL
 775          && (irqmap = fe_probe_jli_icl(sc, eeprom)) == NULL
 776          && (irqmap = fe_probe_jli_unk(sc, eeprom)) == NULL)
 777                 return ENXIO;
 778
 779         /* Find the IRQ read from EEPROM.  */
 780         n = (fe_inb(sc, FE_BMPR19) & FE_B19_IRQ) >> FE_B19_IRQ_SHIFT;
 781         xirq = irqmap[n];
 782
 783         /* Try to determine IRQ setting.  */
 784         error = bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
 785         if (error && xirq == NO_IRQ) {
 786                 /* The device must be configured with an explicit IRQ.  */
 787                 device_printf(dev, "IRQ auto-detection does not work\n");
 788                 return ENXIO;
 789         } else if (error && xirq != NO_IRQ) {
 790                 /* Just use the probed IRQ value.  */
 791                 bus_set_resource(dev, SYS_RES_IRQ, 0, xirq, 1,
 792                     machintr_legacy_intr_cpuid(xirq));
 793         } else if (!error && xirq == NO_IRQ) {
 794                 /* No problem.  Go ahead.  */
 795         } else if (irq == xirq) {
 796                 /* Good.  Go ahead.  */
 797         } else {
 798                 /* User must be warned in this case.  */
 799                 sc->stability |= UNSTABLE_IRQ;
 800         }
 801
 802         /* Setup a hook, which resets te 86965 when the driver is being
 803            initialized.  This may solve a nasty bug.  FIXME.  */
 804         sc->init = fe_init_jli;
 805
 806         return 0;
 807 }
 808
 809 /* Probe for TDK LAK-AX031, which is an SSi 78Q8377A based board.  */
 810 static int
 811 fe_probe_ssi(device_t dev)
 812 {
 813         struct fe_softc *sc = device_get_softc(dev);
 814         u_long iobase, irq;
 815
 816         u_char eeprom [SSI_EEPROM_SIZE];
 817         static struct fe_simple_probe_struct probe_table [] = {
 818                 { FE_DLCR2, 0x08, 0x00 },
 819                 { FE_DLCR4, 0x08, 0x00 },
 820                 { 0 }
 821         };
 822
 823         /* See if the specified I/O address is possible for 78Q8377A.  */
 824         if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
 825                 return ENXIO;
 826         if ((iobase & ~0x3F0) != 0x000)
 827                 return ENXIO;
 828
 829         /* We have 16 registers.  */
 830         if (fe_alloc_port(dev, 16))
 831                 return ENXIO;
 832
 833         /* Fill the softc struct with default values.  */
 834         fe_softc_defaults(sc);
 835
 836         /* See if the card is on its address.  */
 837         if (!fe_simple_probe(sc, probe_table))
 838                 return ENXIO;
 839
 840         /* We now have to read the config EEPROM.  We should be very
 841            careful, since doing so destroys a register.  (Remember, we
 842            are not yet sure we have a LAK-AX031 board here.)  Don't
 843            remember to select BMPRs bofore reading EEPROM, since other
 844            register bank may be selected before the probe() is called.  */
 845         fe_read_eeprom_ssi(sc, eeprom);
 846
 847         /* Make sure the Ethernet (MAC) station address is of TDK's.  */
 848         if (!valid_Ether_p(eeprom+FE_SSI_EEP_ADDR, 0x008098))
 849                 return ENXIO;
 850         bcopy(eeprom + FE_SSI_EEP_ADDR, sc->sc_enaddr, ETHER_ADDR_LEN);
 851
 852         /* This looks like a TDK-AX031 board.  It requires an explicit
 853            IRQ setting in config, since we currently don't know how we
 854            can find the IRQ value assigned by ISA PnP manager.  */
 855         if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0) {
 856                 fe_irq_failure("LAK-AX031", sc->sc_unit, NO_IRQ, NULL);
 857                 return ENXIO;
 858         }
 859
 860         /* Fill softc struct accordingly.  */
 861         sc->type = FE_TYPE_SSI;
 862         sc->typestr = "LAK-AX031";
 863         sc->mbitmap = MB_HT;
 864         sc->defmedia = MB_HT;
 865
 866         return 0;
 867 }
 868
 869 /*
 870  * Probe and initialization for TDK/LANX LAC-AX012/013 boards.
 871  */
 872 static int
 873 fe_probe_lnx(device_t dev)
 874 {
 875         struct fe_softc *sc = device_get_softc(dev);
 876         u_long iobase, irq;
 877
 878         u_char eeprom [LNX_EEPROM_SIZE];
 879         static struct fe_simple_probe_struct probe_table [] = {
 880                 { FE_DLCR2, 0x58, 0x00 },
 881                 { FE_DLCR4, 0x08, 0x00 },
 882                 { 0 }
 883         };
 884
 885         /* See if the specified I/O address is possible for TDK/LANX boards. */
 886         /* 300, 320, 340, and 360 are allowed.  */
 887         if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
 888                 return ENXIO;
 889         if ((iobase & ~0x060) != 0x300)
 890                 return ENXIO;
 891
 892         /* We have 32 registers.  */
 893         if (fe_alloc_port(dev, 32))
 894                 return ENXIO;
 895
 896         /* Fill the softc struct with default values.  */
 897         fe_softc_defaults(sc);
 898
 899         /* See if the card is on its address.  */
 900         if (!fe_simple_probe(sc, probe_table))
 901                 return ENXIO;
 902
 903         /* We now have to read the config EEPROM.  We should be very
 904            careful, since doing so destroys a register.  (Remember, we
 905            are not yet sure we have a LAC-AX012/AX013 board here.)  */
 906         fe_read_eeprom_lnx(sc, eeprom);
 907
 908         /* Make sure the Ethernet (MAC) station address is of TDK/LANX's.  */
 909         if (!valid_Ether_p(eeprom, 0x008098))
 910                 return ENXIO;
 911         bcopy(eeprom, sc->sc_enaddr, ETHER_ADDR_LEN);
 912
 913         /* This looks like a TDK/LANX board.  It requires an
 914            explicit IRQ setting in config.  Make sure we have one,
 915            determining an appropriate value for the IRQ control
 916            register.  */
 917         irq = 0;
 918         bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
 919         switch (irq) {
 920         case 3: sc->priv_info = 0x40 | LNX_CLK_LO | LNX_SDA_HI; break;
 921         case 4: sc->priv_info = 0x20 | LNX_CLK_LO | LNX_SDA_HI; break;
 922         case 5: sc->priv_info = 0x10 | LNX_CLK_LO | LNX_SDA_HI; break;
 923         case 9: sc->priv_info = 0x80 | LNX_CLK_LO | LNX_SDA_HI; break;
 924         default:
 925                 fe_irq_failure("LAC-AX012/AX013", sc->sc_unit, irq, "3/4/5/9");
 926                 return ENXIO;
 927         }
 928
 929         /* Fill softc struct accordingly.  */
 930         sc->type = FE_TYPE_LNX;
 931         sc->typestr = "LAC-AX012/AX013";
 932         sc->init = fe_init_lnx;
 933
 934         return 0;
 935 }
 936
 937 /*
 938  * Probe and initialization for Gateway Communications' old cards.
 939  */
 940 static int
 941 fe_probe_gwy(device_t dev)
 942 {
 943         struct fe_softc *sc = device_get_softc(dev);
 944         u_long iobase, irq;
 945
 946         static struct fe_simple_probe_struct probe_table [] = {
 947             /*  { FE_DLCR2, 0x70, 0x00 }, */
 948                 { FE_DLCR2, 0x58, 0x00 },
 949                 { FE_DLCR4, 0x08, 0x00 },
 950                 { 0 }
 951         };
 952
 953         /* See if the specified I/O address is possible for Gateway boards.  */
 954         if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
 955                 return ENXIO;
 956         if ((iobase & ~0x1E0) != 0x200)
 957                 return ENXIO;
 958
 959         /* That's all.  The card occupies 32 I/O addresses, as always.  */
 960         if (fe_alloc_port(dev, 32))
 961                 return ENXIO;
 962
 963         /* Setup an I/O address mapping table and some others.  */
 964         fe_softc_defaults(sc);
 965
 966         /* See if the card is on its address.  */
 967         if (!fe_simple_probe(sc, probe_table))
 968                 return ENXIO;
 969
 970         /* Get our station address from EEPROM. */
 971         fe_inblk(sc, 0x18, sc->sc_enaddr, ETHER_ADDR_LEN);
 972
 973         /* Make sure it is Gateway Communication's.  */
 974         if (!valid_Ether_p(sc->sc_enaddr, 0x000061))
 975                 return ENXIO;
 976
 977         /* Gateway's board requires an explicit IRQ to work, since it
 978            is not possible to probe the setting of jumpers.  */
 979         if (bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL) != 0) {
 980                 fe_irq_failure("Gateway Ethernet", sc->sc_unit, NO_IRQ, NULL);
 981                 return ENXIO;
 982         }
 983
 984         /* Fill softc struct accordingly.  */
 985         sc->type = FE_TYPE_GWY;
 986         sc->typestr = "Gateway Ethernet (Fujitsu chipset)";
 987
 988         return 0;
 989 }
 990
 991 /* Probe and initialization for Ungermann-Bass Network
 992    K.K. "Access/PC" boards.  */
 993 static int
 994 fe_probe_ubn(device_t dev)
 995 {
 996         struct fe_softc *sc = device_get_softc(dev);
 997         u_long iobase, irq;
 998 #if 0
 999         u_char sum;
1000 #endif
1001         static struct fe_simple_probe_struct const probe_table [] = {
1002                 { FE_DLCR2, 0x58, 0x00 },
1003                 { FE_DLCR4, 0x08, 0x00 },
1004                 { 0 }
1005         };
1006
1007         /* See if the specified I/O address is possible for AccessPC/ISA.  */
1008         if (bus_get_resource(dev, SYS_RES_IOPORT, 0, &iobase, NULL) != 0)
1009                 return ENXIO;
1010         if ((iobase & ~0x0E0) != 0x300)
1011                 return ENXIO;
1012
1013         /* We have 32 registers.  */
1014         if (fe_alloc_port(dev, 32))
1015                 return ENXIO;
1016
1017         /* Setup an I/O address mapping table and some others.  */
1018         fe_softc_defaults(sc);
1019
1020         /* Simple probe.  */
1021         if (!fe_simple_probe(sc, probe_table))
1022                 return ENXIO;
1023
1024         /* Get our station address form ID ROM and make sure it is UBN's.  */
1025         fe_inblk(sc, 0x18, sc->sc_enaddr, ETHER_ADDR_LEN);
1026         if (!valid_Ether_p(sc->sc_enaddr, 0x00DD01))
1027                 return ENXIO;
1028 #if 0
1029         /* Calculate checksum.  */
1030         sum = fe_inb(sc, 0x1e);
1031         for (i = 0; i < ETHER_ADDR_LEN; i++) {
1032                 sum ^= sc->sc_enaddr[i];
1033         }
1034         if (sum != 0)
1035                 return ENXIO;
1036 #endif
1037         /* This looks like an AccessPC/ISA board.  It requires an
1038            explicit IRQ setting in config.  Make sure we have one,
1039            determining an appropriate value for the IRQ control
1040            register.  */
1041         irq = 0;
1042         bus_get_resource(dev, SYS_RES_IRQ, 0, &irq, NULL);
1043         switch (irq) {
1044         case 3:  sc->priv_info = 0x02; break;
1045         case 4:  sc->priv_info = 0x04; break;
1046         case 5:  sc->priv_info = 0x08; break;
1047         case 10: sc->priv_info = 0x10; break;
1048         default:
1049                 fe_irq_failure("Access/PC", sc->sc_unit, irq, "3/4/5/10");
1050                 return ENXIO;
1051         }
1052
1053         /* Fill softc struct accordingly.  */
1054         sc->type = FE_TYPE_UBN;
1055         sc->typestr = "Access/PC";
1056         sc->init = fe_init_ubn;
1057
1058         return 0;
1059 }