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