sys/dev/netif/fe/if_fe.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  * $FreeBSD: src/sys/dev/fe/if_fe.c,v 1.65.2.1 2000/09/22 10:01:47 nyan Exp $
  25  *
  26  * Device driver for Fujitsu MB86960A/MB86965A based Ethernet cards.
  27  * Contributed by M. Sekiguchi. <seki@sysrap.cs.fujitsu.co.jp>
  28  *
  29  * This version is intended to be a generic template for various
  30  * MB86960A/MB86965A based Ethernet cards.  It currently supports
  31  * Fujitsu FMV-180 series for ISA and Allied-Telesis AT1700/RE2000
  32  * series for ISA, as well as Fujitsu MBH10302 PC card.
  33  * There are some currently-
  34  * unused hooks embedded, which are primarily intended to support
  35  * other types of Ethernet cards, but the author is not sure whether
  36  * they are useful.
  37  *
  38  * This version also includes some alignments to support RE1000,
  39  * C-NET(98)P2 and so on. These cards are not for AT-compatibles,
  40  * but for NEC PC-98 bus -- a proprietary bus architecture available
  41  * only in Japan. Confusingly, it is different from the Microsoft's
  42  * PC98 architecture. :-{
  43  * Further work for PC-98 version will be available as a part of
  44  * FreeBSD(98) project.
  45  *
  46  * This software is a derivative work of if_ed.c version 1.56 by David
  47  * Greenman available as a part of FreeBSD 2.0 RELEASE source distribution.
  48  *
  49  * The following lines are retained from the original if_ed.c:
  50  *
  51  * Copyright (C) 1993, David Greenman. This software may be used, modified,
  52  *   copied, distributed, and sold, in both source and binary form provided
  53  *   that the above copyright and these terms are retained. Under no
  54  *   circumstances is the author responsible for the proper functioning
  55  *   of this software, nor does the author assume any responsibility
  56  *   for damages incurred with its use.
  57  */
  58
  59 /*
  60  * TODO:
  61  *  o   To support ISA PnP auto configuration for FMV-183/184.
  62  *  o   To support REX-9886/87(PC-98 only).
  63  *  o   To reconsider mbuf usage.
  64  *  o   To reconsider transmission buffer usage, including
  65  *      transmission buffer size (currently 4KB x 2) and pros-and-
  66  *      cons of multiple frame transmission.
  67  *  o   To test IPX codes.
  68  *  o   To test new-bus frontend.
  69  */
  70
  71 #include "opt_fe.h"
  72 #include "opt_inet.h"
  73 #include "opt_ipx.h"
  74
  75 #include <sys/param.h>
  76 #include <sys/systm.h>
  77 #include <sys/socket.h>
  78 #include <sys/sockio.h>
  79 #include <sys/mbuf.h>
  80 #include <sys/interrupt.h>
  81 #include <sys/linker_set.h>
  82 #include <sys/module.h>
  83 #include <sys/bus.h>
  84 #include <sys/rman.h>
  85 #include <sys/thread2.h>
  86
  87 #include <net/ethernet.h>
  88 #include <net/if.h>
  89 #include <net/ifq_var.h>
  90 #include <net/if_dl.h>
  91 #include <net/if_mib.h>
  92 #include <net/if_media.h>
  93
  94 #include <netinet/in.h>
  95 #include <netinet/if_ether.h>
  96
  97 #include <net/bpf.h>
  98
  99 #include <machine_base/isa/ic/mb86960.h>
 100 #include "if_fereg.h"
 101 #include "if_fevar.h"
 102
 103 /*
 104  * Transmit just one packet per a "send" command to 86960.
 105  * This option is intended for performance test.  An EXPERIMENTAL option.
 106  */
 107 #ifndef FE_SINGLE_TRANSMISSION
 108 #define FE_SINGLE_TRANSMISSION 0
 109 #endif
 110
 111 /*
 112  * Maximum loops when interrupt.
 113  * This option prevents an infinite loop due to hardware failure.
 114  * (Some laptops make an infinite loop after PC-Card is ejected.)
 115  */
 116 #ifndef FE_MAX_LOOP
 117 #define FE_MAX_LOOP 0x800
 118 #endif
 119
 120 /*
 121  * If you define this option, 8-bit cards are also supported.
 122  */
 123 /*#define FE_8BIT_SUPPORT*/
 124
 125 /*
 126  * Device configuration flags.
 127  */
 128
 129 /* DLCR6 settings.  */
 130 #define FE_FLAGS_DLCR6_VALUE    0x007F
 131
 132 /* Force DLCR6 override.  */
 133 #define FE_FLAGS_OVERRIDE_DLCR6 0x0080
 134
 135
 136 devclass_t fe_devclass;
 137
 138 /*
 139  * Special filter values.
 140  */
 141 static struct fe_filter const fe_filter_nothing = { FE_FILTER_NOTHING };
 142 static struct fe_filter const fe_filter_all     = { FE_FILTER_ALL };
 143
 144 /* Standard driver entry points.  These can be static.  */
 145 static void             fe_init         (void *);
 146 static void             fe_intr         (void *);
 147 static int              fe_ioctl        (struct ifnet *, u_long, caddr_t,
 148                                          struct ucred *);
 149 static void             fe_start        (struct ifnet *,
 150                                          struct ifaltq_subque *);
 151 static void             fe_watchdog     (struct ifnet *);
 152 static int              fe_medchange    (struct ifnet *);
 153 static void             fe_medstat      (struct ifnet *, struct ifmediareq *);
 154
 155 /* Local functions.  Order of declaration is confused.  FIXME.  */
 156 static int      fe_get_packet   ( struct fe_softc *, u_short );
 157 static void     fe_tint         ( struct fe_softc *, u_char );
 158 static void     fe_rint         ( struct fe_softc *, u_char );
 159 static void     fe_xmit         ( struct fe_softc * );
 160 static void     fe_write_mbufs  ( struct fe_softc *, struct mbuf * );
 161 static void     fe_setmode      ( struct fe_softc * );
 162 static void     fe_loadmar      ( struct fe_softc * );
 163
 164 #ifdef DIAGNOSTIC
 165 static void     fe_emptybuffer  ( struct fe_softc * );
 166 #endif
 167
 168 DECLARE_DUMMY_MODULE(if_fe);
 169
 170 /*
 171  * Fe driver specific constants which relate to 86960/86965.
 172  */
 173
 174 /* Interrupt masks  */
 175 #define FE_TMASK ( FE_D2_COLL16 | FE_D2_TXDONE )
 176 #define FE_RMASK ( FE_D3_OVRFLO | FE_D3_CRCERR \
 177                  | FE_D3_ALGERR | FE_D3_SRTPKT | FE_D3_PKTRDY )
 178
 179 /* Maximum number of iterations for a receive interrupt.  */
 180 #define FE_MAX_RECV_COUNT ( ( 65536 - 2048 * 2 ) / 64 )
 181         /*
 182          * Maximum size of SRAM is 65536,
 183          * minimum size of transmission buffer in fe is 2x2KB,
 184          * and minimum amount of received packet including headers
 185          * added by the chip is 64 bytes.
 186          * Hence FE_MAX_RECV_COUNT is the upper limit for number
 187          * of packets in the receive buffer.
 188          */
 189
 190 /*
 191  * Miscellaneous definitions not directly related to hardware.
 192  */
 193
 194 /* The following line must be delete when "net/if_media.h" support it.  */
 195 #ifndef IFM_10_FL
 196 #define IFM_10_FL       /* 13 */ IFM_10_5
 197 #endif
 198
 199 #if 0
 200 /* Mapping between media bitmap (in fe_softc.mbitmap) and ifm_media.  */
 201 static int const bit2media [] = {
 202                         IFM_HDX | IFM_ETHER | IFM_AUTO,
 203                         IFM_HDX | IFM_ETHER | IFM_MANUAL,
 204                         IFM_HDX | IFM_ETHER | IFM_10_T,
 205                         IFM_HDX | IFM_ETHER | IFM_10_2,
 206                         IFM_HDX | IFM_ETHER | IFM_10_5,
 207                         IFM_HDX | IFM_ETHER | IFM_10_FL,
 208                         IFM_FDX | IFM_ETHER | IFM_10_T,
 209         /* More can be come here... */
 210                         0
 211 };
 212 #else
 213 /* Mapping between media bitmap (in fe_softc.mbitmap) and ifm_media.  */
 214 static int const bit2media [] = {
 215                         IFM_ETHER | IFM_AUTO,
 216                         IFM_ETHER | IFM_MANUAL,
 217                         IFM_ETHER | IFM_10_T,
 218                         IFM_ETHER | IFM_10_2,
 219                         IFM_ETHER | IFM_10_5,
 220                         IFM_ETHER | IFM_10_FL,
 221                         IFM_ETHER | IFM_10_T,
 222         /* More can be come here... */
 223                         0
 224 };
 225 #endif
 226
 227 /*
 228  * Check for specific bits in specific registers have specific values.
 229  * A common utility function called from various sub-probe routines.
 230  */
 231 int
 232 fe_simple_probe (struct fe_softc const * sc,
 233                  struct fe_simple_probe_struct const * sp)
 234 {
 235         struct fe_simple_probe_struct const *p;
 236
 237         for (p  = sp; p->mask != 0; p++) {
 238                 if ((fe_inb(sc, p->port) & p->mask) != p->bits)
 239                         return 0;
 240         }
 241         return 1;
 242 }
 243
 244 /* Test if a given 6 byte value is a valid Ethernet station (MAC)
 245    address.  "Vendor" is an expected vendor code (first three bytes,)
 246    or a zero when nothing expected.  */
 247 int
 248 valid_Ether_p (u_char const * addr, unsigned vendor)
 249 {
 250 #ifdef FE_DEBUG
 251         char ethstr[ETHER_ADDRSTRLEN + 1];
 252         kprintf("fe?: validating %s against %06x\n", kether_ntoa(addr, ethstr),
 253             vendor);
 254 #endif
 255
 256         /* All zero is not allowed as a vendor code.  */
 257         if (addr[0] == 0 && addr[1] == 0 && addr[2] == 0) return 0;
 258
 259         switch (vendor) {
 260             case 0x000000:
 261                 /* Legal Ethernet address (stored in ROM) must have
 262                    its Group and Local bits cleared.  */
 263                 if ((addr[0] & 0x03) != 0) return 0;
 264                 break;
 265             case 0x020000:
 266                 /* Same as above, but a local address is allowed in
 267                    this context.  */
 268                 if ((addr[0] & 0x01) != 0) return 0;
 269                 break;
 270             default:
 271                 /* Make sure the vendor part matches if one is given.  */
 272                 if (   addr[0] != ((vendor >> 16) & 0xFF)
 273                     || addr[1] != ((vendor >>  8) & 0xFF)
 274                     || addr[2] != ((vendor      ) & 0xFF)) return 0;
 275                 break;
 276         }
 277
 278         /* Host part must not be all-zeros nor all-ones.  */
 279         if (addr[3] == 0xFF && addr[4] == 0xFF && addr[5] == 0xFF) return 0;
 280         if (addr[3] == 0x00 && addr[4] == 0x00 && addr[5] == 0x00) return 0;
 281
 282         /* Given addr looks like an Ethernet address.  */
 283         return 1;
 284 }
 285
 286 /* Fill our softc struct with default value.  */
 287 void
 288 fe_softc_defaults (struct fe_softc *sc)
 289 {
 290         /* Prepare for typical register prototypes.  We assume a
 291            "typical" board has <32KB> of <fast> SRAM connected with a
 292            <byte-wide> data lines.  */
 293         sc->proto_dlcr4 = FE_D4_LBC_DISABLE | FE_D4_CNTRL;
 294         sc->proto_dlcr5 = 0;
 295         sc->proto_dlcr6 = FE_D6_BUFSIZ_32KB | FE_D6_TXBSIZ_2x4KB
 296                 | FE_D6_BBW_BYTE | FE_D6_SBW_WORD | FE_D6_SRAM_100ns;
 297         sc->proto_dlcr7 = FE_D7_BYTSWP_LH;
 298         sc->proto_bmpr13 = 0;
 299
 300         /* Assume the probe process (to be done later) is stable.  */
 301         sc->stability = 0;
 302
 303         /* A typical board needs no hooks.  */
 304         sc->init = NULL;
 305         sc->stop = NULL;
 306
 307         /* Assume the board has no software-controllable media selection.  */
 308         sc->mbitmap = MB_HM;
 309         sc->defmedia = MB_HM;
 310         sc->msel = NULL;
 311 }
 312
 313 /* Common error reporting routine used in probe routines for
 314    "soft configured IRQ"-type boards.  */
 315 void
 316 fe_irq_failure (char const *name, int unit, int irq, char const *list)
 317 {
 318         kprintf("fe%d: %s board is detected, but %s IRQ was given\n",
 319                unit, name, (irq == NO_IRQ ? "no" : "invalid"));
 320         if (list != NULL) {
 321                 kprintf("fe%d: specify an IRQ from %s in kernel config\n",
 322                        unit, list);
 323         }
 324 }
 325
 326 /*
 327  * Hardware (vendor) specific hooks.
 328  */
 329
 330 /*
 331  * Generic media selection scheme for MB86965 based boards.
 332  */
 333 void
 334 fe_msel_965 (struct fe_softc *sc)
 335 {
 336         u_char b13;
 337
 338         /* Find the appropriate bits for BMPR13 tranceiver control.  */
 339         switch (IFM_SUBTYPE(sc->media.ifm_media)) {
 340             case IFM_AUTO: b13 = FE_B13_PORT_AUTO | FE_B13_TPTYPE_UTP; break;
 341             case IFM_10_T: b13 = FE_B13_PORT_TP   | FE_B13_TPTYPE_UTP; break;
 342             default:       b13 = FE_B13_PORT_AUI;  break;
 343         }
 344
 345         /* Write it into the register.  It takes effect immediately.  */
 346         fe_outb(sc, FE_BMPR13, sc->proto_bmpr13 | b13);
 347 }
 348
 349
 350 /*
 351  * Fujitsu MB86965 JLI mode support routines.
 352  */
 353
 354 /*
 355  * Routines to read all bytes from the config EEPROM through MB86965A.
 356  * It is a MicroWire (3-wire) serial EEPROM with 6-bit address.
 357  * (93C06 or 93C46.)
 358  */
 359 static void
 360 fe_strobe_eeprom_jli (struct fe_softc *sc, u_short bmpr16)
 361 {
 362         /*
 363          * We must guarantee 1us (or more) interval to access slow
 364          * EEPROMs.  The following redundant code provides enough
 365          * delay with ISA timing.  (Even if the bus clock is "tuned.")
 366          * Some modification will be needed on faster busses.
 367          */
 368         fe_outb(sc, bmpr16, FE_B16_SELECT);
 369         fe_outb(sc, bmpr16, FE_B16_SELECT | FE_B16_CLOCK);
 370         fe_outb(sc, bmpr16, FE_B16_SELECT | FE_B16_CLOCK);
 371         fe_outb(sc, bmpr16, FE_B16_SELECT);
 372 }
 373
 374 void
 375 fe_read_eeprom_jli (struct fe_softc * sc, u_char * data)
 376 {
 377         u_char n, val, bit;
 378         u_char save16, save17;
 379
 380         /* Save the current value of the EEPROM interface registers.  */
 381         save16 = fe_inb(sc, FE_BMPR16);
 382         save17 = fe_inb(sc, FE_BMPR17);
 383
 384         /* Read bytes from EEPROM; two bytes per an iteration.  */
 385         for (n = 0; n < JLI_EEPROM_SIZE / 2; n++) {
 386
 387                 /* Reset the EEPROM interface.  */
 388                 fe_outb(sc, FE_BMPR16, 0x00);
 389                 fe_outb(sc, FE_BMPR17, 0x00);
 390
 391                 /* Start EEPROM access.  */
 392                 fe_outb(sc, FE_BMPR16, FE_B16_SELECT);
 393                 fe_outb(sc, FE_BMPR17, FE_B17_DATA);
 394                 fe_strobe_eeprom_jli(sc, FE_BMPR16);
 395
 396                 /* Pass the iteration count as well as a READ command.  */
 397                 val = 0x80 | n;
 398                 for (bit = 0x80; bit != 0x00; bit >>= 1) {
 399                         fe_outb(sc, FE_BMPR17, (val & bit) ? FE_B17_DATA : 0);
 400                         fe_strobe_eeprom_jli(sc, FE_BMPR16);
 401                 }
 402                 fe_outb(sc, FE_BMPR17, 0x00);
 403
 404                 /* Read a byte.  */
 405                 val = 0;
 406                 for (bit = 0x80; bit != 0x00; bit >>= 1) {
 407                         fe_strobe_eeprom_jli(sc, FE_BMPR16);
 408                         if (fe_inb(sc, FE_BMPR17) & FE_B17_DATA)
 409                                 val |= bit;
 410                 }
 411                 *data++ = val;
 412
 413                 /* Read one more byte.  */
 414                 val = 0;
 415                 for (bit = 0x80; bit != 0x00; bit >>= 1) {
 416                         fe_strobe_eeprom_jli(sc, FE_BMPR16);
 417                         if (fe_inb(sc, FE_BMPR17) & FE_B17_DATA)
 418                                 val |= bit;
 419                 }
 420                 *data++ = val;
 421         }
 422
 423 #if 0
 424         /* Reset the EEPROM interface, again.  */
 425         fe_outb(sc, FE_BMPR16, 0x00);
 426         fe_outb(sc, FE_BMPR17, 0x00);
 427 #else
 428         /* Make sure to restore the original value of EEPROM interface
 429            registers, since we are not yet sure we have MB86965A on
 430            the address.  */
 431         fe_outb(sc, FE_BMPR17, save17);
 432         fe_outb(sc, FE_BMPR16, save16);
 433 #endif
 434
 435 #if 1
 436         /* Report what we got.  */
 437         if (bootverbose) {
 438                 int i;
 439                 data -= JLI_EEPROM_SIZE;
 440                 for (i = 0; i < JLI_EEPROM_SIZE; i += 16) {
 441                         kprintf("fe%d: EEPROM(JLI):%3x: %16D\n",
 442                                sc->sc_unit, i, data + i, " ");
 443                 }
 444         }
 445 #endif
 446 }
 447
 448 void
 449 fe_init_jli (struct fe_softc * sc)
 450 {
 451         /* "Reset" by writing into a magic location.  */
 452         DELAY(200);
 453         fe_outb(sc, 0x1E, fe_inb(sc, 0x1E));
 454         DELAY(300);
 455 }
 456
 457
 458 /*
 459  * SSi 78Q8377A support routines.
 460  */
 461
 462 /*
 463  * Routines to read all bytes from the config EEPROM through 78Q8377A.
 464  * It is a MicroWire (3-wire) serial EEPROM with 8-bit address.  (I.e.,
 465  * 93C56 or 93C66.)
 466  *
 467  * As I don't have SSi manuals, (hmm, an old song again!) I'm not exactly
 468  * sure the following code is correct...  It is just stolen from the
 469  * C-NET(98)P2 support routine in FreeBSD(98).
 470  */
 471
 472 void
 473 fe_read_eeprom_ssi (struct fe_softc *sc, u_char *data)
 474 {
 475         u_char val, bit;
 476         int n;
 477         u_char save6, save7, save12;
 478
 479         /* Save the current value for the DLCR registers we are about
 480            to destroy.  */
 481         save6 = fe_inb(sc, FE_DLCR6);
 482         save7 = fe_inb(sc, FE_DLCR7);
 483
 484         /* Put the 78Q8377A into a state that we can access the EEPROM.  */
 485         fe_outb(sc, FE_DLCR6,
 486             FE_D6_BBW_WORD | FE_D6_SBW_WORD | FE_D6_DLC_DISABLE);
 487         fe_outb(sc, FE_DLCR7,
 488             FE_D7_BYTSWP_LH | FE_D7_RBS_BMPR | FE_D7_RDYPNS | FE_D7_POWER_UP);
 489
 490         /* Save the current value for the BMPR12 register, too.  */
 491         save12 = fe_inb(sc, FE_DLCR12);
 492
 493         /* Read bytes from EEPROM; two bytes per an iteration.  */
 494         for (n = 0; n < SSI_EEPROM_SIZE / 2; n++) {
 495
 496                 /* Start EEPROM access  */
 497                 fe_outb(sc, FE_DLCR12, SSI_EEP);
 498                 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL);
 499
 500                 /* Send the following four bits to the EEPROM in the
 501                    specified order: a dummy bit, a start bit, and
 502                    command bits (10) for READ.  */
 503                 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL                    );
 504                 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL | SSI_CLK          );  /* 0 */
 505                 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL           | SSI_DAT);
 506                 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL | SSI_CLK | SSI_DAT);  /* 1 */
 507                 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL           | SSI_DAT);
 508                 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL | SSI_CLK | SSI_DAT);  /* 1 */
 509                 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL                    );
 510                 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL | SSI_CLK          );  /* 0 */
 511
 512                 /* Pass the iteration count to the chip.  */
 513                 for (bit = 0x80; bit != 0x00; bit >>= 1) {
 514                     val = ( n & bit ) ? SSI_DAT : 0;
 515                     fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL           | val);
 516                     fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL | SSI_CLK | val);
 517                 }
 518
 519                 /* Read a byte.  */
 520                 val = 0;
 521                 for (bit = 0x80; bit != 0x00; bit >>= 1) {
 522                     fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL);
 523                     fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL | SSI_CLK);
 524                     if (fe_inb(sc, FE_DLCR12) & SSI_DIN)
 525                         val |= bit;
 526                 }
 527                 *data++ = val;
 528
 529                 /* Read one more byte.  */
 530                 val = 0;
 531                 for (bit = 0x80; bit != 0x00; bit >>= 1) {
 532                     fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL);
 533                     fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL | SSI_CLK);
 534                     if (fe_inb(sc, FE_DLCR12) & SSI_DIN)
 535                         val |= bit;
 536                 }
 537                 *data++ = val;
 538
 539                 fe_outb(sc, FE_DLCR12, SSI_EEP);
 540         }
 541
 542         /* Reset the EEPROM interface.  (For now.)  */
 543         fe_outb(sc, FE_DLCR12, 0x00);
 544
 545         /* Restore the saved register values, for the case that we
 546            didn't have 78Q8377A at the given address.  */
 547         fe_outb(sc, FE_DLCR12, save12);
 548         fe_outb(sc, FE_DLCR7, save7);
 549         fe_outb(sc, FE_DLCR6, save6);
 550
 551 #if 1
 552         /* Report what we got.  */
 553         if (bootverbose) {
 554                 int i;
 555                 data -= SSI_EEPROM_SIZE;
 556                 for (i = 0; i < SSI_EEPROM_SIZE; i += 16) {
 557                         kprintf("fe%d: EEPROM(SSI):%3x: %16D\n",
 558                                sc->sc_unit, i, data + i, " ");
 559                 }
 560         }
 561 #endif
 562 }
 563
 564 /*
 565  * TDK/LANX boards support routines.
 566  */
 567
 568 /* It is assumed that the CLK line is low and SDA is high (float) upon entry.  */
 569 #define LNX_PH(D,K,N) \
 570         ((LNX_SDA_##D | LNX_CLK_##K) << N)
 571 #define LNX_CYCLE(D1,D2,D3,D4,K1,K2,K3,K4) \
 572         (LNX_PH(D1,K1,0)|LNX_PH(D2,K2,8)|LNX_PH(D3,K3,16)|LNX_PH(D4,K4,24))
 573
 574 #define LNX_CYCLE_START LNX_CYCLE(HI,LO,LO,HI, HI,HI,LO,LO)
 575 #define LNX_CYCLE_STOP  LNX_CYCLE(LO,LO,HI,HI, LO,HI,HI,LO)
 576 #define LNX_CYCLE_HI    LNX_CYCLE(HI,HI,HI,HI, LO,HI,LO,LO)
 577 #define LNX_CYCLE_LO    LNX_CYCLE(LO,LO,LO,HI, LO,HI,LO,LO)
 578 #define LNX_CYCLE_INIT  LNX_CYCLE(LO,HI,HI,HI, LO,LO,LO,LO)
 579
 580 static void
 581 fe_eeprom_cycle_lnx (struct fe_softc *sc, u_short reg20, u_long cycle)
 582 {
 583         fe_outb(sc, reg20, (cycle      ) & 0xFF);
 584         DELAY(15);
 585         fe_outb(sc, reg20, (cycle >>  8) & 0xFF);
 586         DELAY(15);
 587         fe_outb(sc, reg20, (cycle >> 16) & 0xFF);
 588         DELAY(15);
 589         fe_outb(sc, reg20, (cycle >> 24) & 0xFF);
 590         DELAY(15);
 591 }
 592
 593 static u_char
 594 fe_eeprom_receive_lnx (struct fe_softc *sc, u_short reg20)
 595 {
 596         u_char dat;
 597
 598         fe_outb(sc, reg20, LNX_CLK_HI | LNX_SDA_FL);
 599         DELAY(15);
 600         dat = fe_inb(sc, reg20);
 601         fe_outb(sc, reg20, LNX_CLK_LO | LNX_SDA_FL);
 602         DELAY(15);
 603         return (dat & LNX_SDA_IN);
 604 }
 605
 606 void
 607 fe_read_eeprom_lnx (struct fe_softc *sc, u_char *data)
 608 {
 609         int i;
 610         u_char n, bit, val;
 611         u_char save20;
 612         u_short reg20 = 0x14;
 613
 614         save20 = fe_inb(sc, reg20);
 615
 616         /* NOTE: DELAY() timing constants are approximately three
 617            times longer (slower) than the required minimum.  This is
 618            to guarantee a reliable operation under some tough
 619            conditions...  Fortunately, this routine is only called
 620            during the boot phase, so the speed is less important than
 621            stability.  */
 622
 623 #if 1
 624         /* Reset the X24C01's internal state machine and put it into
 625            the IDLE state.  We usually don't need this, but *if*
 626            someone (e.g., probe routine of other driver) write some
 627            garbage into the register at 0x14, synchronization will be
 628            lost, and the normal EEPROM access protocol won't work.
 629            Moreover, as there are no easy way to reset, we need a
 630            _manoeuvre_ here.  (It even lacks a reset pin, so pushing
 631            the RESET button on the PC doesn't help!)  */
 632         fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_INIT);
 633         for (i = 0; i < 10; i++)
 634                 fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_START);
 635         fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_STOP);
 636         DELAY(10000);
 637 #endif
 638
 639         /* Issue a start condition.  */
 640         fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_START);
 641
 642         /* Send seven bits of the starting address (zero, in this
 643            case) and a command bit for READ.  */
 644         val = 0x01;
 645         for (bit = 0x80; bit != 0x00; bit >>= 1) {
 646                 if (val & bit) {
 647                         fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_HI);
 648                 } else {
 649                         fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_LO);
 650                 }
 651         }
 652
 653         /* Receive an ACK bit.  */
 654         if (fe_eeprom_receive_lnx(sc, reg20)) {
 655                 /* ACK was not received.  EEPROM is not present (i.e.,
 656                    this board was not a TDK/LANX) or not working
 657                    properly.  */
 658                 if (bootverbose) {
 659                         kprintf("fe%d: no ACK received from EEPROM(LNX)\n",
 660                                sc->sc_unit);
 661                 }
 662                 /* Clear the given buffer to indicate we could not get
 663                    any info. and return.  */
 664                 bzero(data, LNX_EEPROM_SIZE);
 665                 goto RET;
 666         }
 667
 668         /* Read bytes from EEPROM.  */
 669         for (n = 0; n < LNX_EEPROM_SIZE; n++) {
 670
 671                 /* Read a byte and store it into the buffer.  */
 672                 val = 0x00;
 673                 for (bit = 0x80; bit != 0x00; bit >>= 1) {
 674                         if (fe_eeprom_receive_lnx(sc, reg20))
 675                                 val |= bit;
 676                 }
 677                 *data++ = val;
 678
 679                 /* Acknowledge if we have to read more.  */
 680                 if (n < LNX_EEPROM_SIZE - 1) {
 681                         fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_LO);
 682                 }
 683         }
 684
 685         /* Issue a STOP condition, de-activating the clock line.
 686            It will be safer to keep the clock line low than to leave
 687            it high.  */
 688         fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_STOP);
 689
 690     RET:
 691         fe_outb(sc, reg20, save20);
 692
 693 #if 1
 694         /* Report what we got.  */
 695         if (bootverbose) {
 696                 data -= LNX_EEPROM_SIZE;
 697                 for (i = 0; i < LNX_EEPROM_SIZE; i += 16) {
 698                         kprintf("fe%d: EEPROM(LNX):%3x: %16D\n",
 699                                sc->sc_unit, i, data + i, " ");
 700                 }
 701         }
 702 #endif
 703 }
 704
 705 void
 706 fe_init_lnx (struct fe_softc * sc)
 707 {
 708         /* Reset the 86960.  Do we need this?  FIXME.  */
 709         fe_outb(sc, 0x12, 0x06);
 710         DELAY(100);
 711         fe_outb(sc, 0x12, 0x07);
 712         DELAY(100);
 713
 714         /* Setup IRQ control register on the ASIC.  */
 715         fe_outb(sc, 0x14, sc->priv_info);
 716 }
 717
 718
 719 /*
 720  * Ungermann-Bass boards support routine.
 721  */
 722 void
 723 fe_init_ubn (struct fe_softc * sc)
 724 {
 725         /* Do we need this?  FIXME.  */
 726         fe_outb(sc, FE_DLCR7,
 727                 sc->proto_dlcr7 | FE_D7_RBS_BMPR | FE_D7_POWER_UP);
 728         fe_outb(sc, 0x18, 0x00);
 729         DELAY(200);
 730
 731         /* Setup IRQ control register on the ASIC.  */
 732         fe_outb(sc, 0x14, sc->priv_info);
 733 }
 734
 735
 736 /*
 737  * Install interface into kernel networking data structures
 738  */
 739 int
 740 fe_attach (device_t dev)
 741 {
 742         struct fe_softc *sc = device_get_softc(dev);
 743         int flags = device_get_flags(dev);
 744         int b, error;
 745
 746         /*
 747          * Initialize ifnet structure
 748          */
 749         sc->sc_if.if_softc    = sc;
 750         if_initname(&(sc->sc_if), "fe", sc->sc_unit);
 751         sc->sc_if.if_start    = fe_start;
 752         sc->sc_if.if_ioctl    = fe_ioctl;
 753         sc->sc_if.if_watchdog = fe_watchdog;
 754         sc->sc_if.if_init     = fe_init;
 755         sc->sc_if.if_linkmib  = &sc->mibdata;
 756         sc->sc_if.if_linkmiblen = sizeof (sc->mibdata);
 757
 758 #if 0 /* I'm not sure... */
 759         sc->mibdata.dot3Compliance = DOT3COMPLIANCE_COLLS;
 760 #endif
 761
 762         /*
 763          * Set fixed interface flags.
 764          */
 765         sc->sc_if.if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 766         ifq_set_maxlen(&sc->sc_if.if_snd, IFQ_MAXLEN);
 767         ifq_set_ready(&sc->sc_if.if_snd);
 768
 769 #if FE_SINGLE_TRANSMISSION
 770         /* Override txb config to allocate minimum.  */
 771         sc->proto_dlcr6 &= ~FE_D6_TXBSIZ
 772         sc->proto_dlcr6 |=  FE_D6_TXBSIZ_2x2KB;
 773 #endif
 774
 775         /* Modify hardware config if it is requested.  */
 776         if (flags & FE_FLAGS_OVERRIDE_DLCR6)
 777                 sc->proto_dlcr6 = flags & FE_FLAGS_DLCR6_VALUE;
 778
 779         /* Find TX buffer size, based on the hardware dependent proto.  */
 780         switch (sc->proto_dlcr6 & FE_D6_TXBSIZ) {
 781           case FE_D6_TXBSIZ_2x2KB: sc->txb_size = 2048; break;
 782           case FE_D6_TXBSIZ_2x4KB: sc->txb_size = 4096; break;
 783           case FE_D6_TXBSIZ_2x8KB: sc->txb_size = 8192; break;
 784           default:
 785                 /* Oops, we can't work with single buffer configuration.  */
 786                 if (bootverbose) {
 787                         kprintf("fe%d: strange TXBSIZ config; fixing\n",
 788                                sc->sc_unit);
 789                 }
 790                 sc->proto_dlcr6 &= ~FE_D6_TXBSIZ;
 791                 sc->proto_dlcr6 |=  FE_D6_TXBSIZ_2x2KB;
 792                 sc->txb_size = 2048;
 793                 break;
 794         }
 795
 796         /* Initialize the if_media interface.  */
 797         ifmedia_init(&sc->media, 0, fe_medchange, fe_medstat);
 798         for (b = 0; bit2media[b] != 0; b++) {
 799                 if (sc->mbitmap & (1 << b)) {
 800                         ifmedia_add(&sc->media, bit2media[b], 0, NULL);
 801                 }
 802         }
 803         for (b = 0; bit2media[b] != 0; b++) {
 804                 if (sc->defmedia & (1 << b)) {
 805                         ifmedia_set(&sc->media, bit2media[b]);
 806                         break;
 807                 }
 808         }
 809 #if 0   /* Turned off; this is called later, when the interface UPs.  */
 810         fe_medchange(sc);
 811 #endif
 812
 813         /* Attach and stop the interface. */
 814         ether_ifattach(&sc->sc_if, sc->sc_enaddr, NULL);
 815         fe_stop(sc);
 816
 817         error = bus_setup_intr(dev, sc->irq_res, INTR_MPSAFE,
 818                                fe_intr, sc, &sc->irq_handle,
 819                                sc->sc_if.if_serializer);
 820         if (error) {
 821                 if_detach(&sc->sc_if);
 822                 fe_release_resource(dev);
 823                 return ENXIO;
 824         }
 825
 826         ifq_set_cpuid(&sc->sc_if.if_snd, rman_get_cpuid(sc->irq_res));
 827
 828         /* Print additional info when attached.  */
 829         device_printf(dev, "type %s%s\n", sc->typestr,
 830                       (sc->proto_dlcr4 & FE_D4_DSC) ? ", full duplex" : "");
 831         if (bootverbose) {
 832                 int buf, txb, bbw, sbw, ram;
 833
 834                 buf = txb = bbw = sbw = ram = -1;
 835                 switch ( sc->proto_dlcr6 & FE_D6_BUFSIZ ) {
 836                   case FE_D6_BUFSIZ_8KB:  buf =  8; break;
 837                   case FE_D6_BUFSIZ_16KB: buf = 16; break;
 838                   case FE_D6_BUFSIZ_32KB: buf = 32; break;
 839                   case FE_D6_BUFSIZ_64KB: buf = 64; break;
 840                 }
 841                 switch ( sc->proto_dlcr6 & FE_D6_TXBSIZ ) {
 842                   case FE_D6_TXBSIZ_2x2KB: txb = 2; break;
 843                   case FE_D6_TXBSIZ_2x4KB: txb = 4; break;
 844                   case FE_D6_TXBSIZ_2x8KB: txb = 8; break;
 845                 }
 846                 switch ( sc->proto_dlcr6 & FE_D6_BBW ) {
 847                   case FE_D6_BBW_BYTE: bbw =  8; break;
 848                   case FE_D6_BBW_WORD: bbw = 16; break;
 849                 }
 850                 switch ( sc->proto_dlcr6 & FE_D6_SBW ) {
 851                   case FE_D6_SBW_BYTE: sbw =  8; break;
 852                   case FE_D6_SBW_WORD: sbw = 16; break;
 853                 }
 854                 switch ( sc->proto_dlcr6 & FE_D6_SRAM ) {
 855                   case FE_D6_SRAM_100ns: ram = 100; break;
 856                   case FE_D6_SRAM_150ns: ram = 150; break;
 857                 }
 858                 device_printf(dev, "SRAM %dKB %dbit %dns, TXB %dKBx2, %dbit I/O\n",
 859                               buf, bbw, ram, txb, sbw);
 860         }
 861         if (sc->stability & UNSTABLE_IRQ)
 862                 device_printf(dev, "warning: IRQ number may be incorrect\n");
 863         if (sc->stability & UNSTABLE_MAC)
 864                 device_printf(dev, "warning: above MAC address may be incorrect\n");
 865         if (sc->stability & UNSTABLE_TYPE)
 866                 device_printf(dev, "warning: hardware type was not validated\n");
 867
 868         return 0;
 869 }
 870
 871 int
 872 fe_alloc_port(device_t dev, int size)
 873 {
 874         struct fe_softc *sc = device_get_softc(dev);
 875         struct resource *res;
 876         int rid;
 877
 878         rid = 0;
 879         res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
 880                                  0ul, ~0ul, size, RF_ACTIVE);
 881         if (res) {
 882                 sc->port_used = size;
 883                 sc->port_res = res;
 884                 sc->iot = rman_get_bustag(res);
 885                 sc->ioh = rman_get_bushandle(res);
 886                 return (0);
 887         }
 888
 889         return (ENOENT);
 890 }
 891
 892 int
 893 fe_alloc_irq(device_t dev, int flags)
 894 {
 895         struct fe_softc *sc = device_get_softc(dev);
 896         struct resource *res;
 897         int rid;
 898
 899         rid = 0;
 900         res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | flags);
 901         if (res) {
 902                 sc->irq_res = res;
 903                 return (0);
 904         }
 905
 906         return (ENOENT);
 907 }
 908
 909 void
 910 fe_release_resource(device_t dev)
 911 {
 912         struct fe_softc *sc = device_get_softc(dev);
 913
 914         if (sc->port_res) {
 915                 bus_release_resource(dev, SYS_RES_IOPORT, 0, sc->port_res);
 916                 sc->port_res = NULL;
 917         }
 918         if (sc->irq_res) {
 919                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res);
 920                 sc->irq_res = NULL;
 921         }
 922 }
 923
 924 /*
 925  * Reset interface, after some (hardware) trouble is deteced.
 926  */
 927 static void
 928 fe_reset (struct fe_softc *sc)
 929 {
 930         /* Record how many packets are lost by this accident.  */
 931         sc->sc_if.if_oerrors += sc->txb_sched + sc->txb_count;
 932         sc->mibdata.dot3StatsInternalMacTransmitErrors++;
 933
 934         /* Put the interface into known initial state.  */
 935         fe_stop(sc);
 936         if (sc->sc_if.if_flags & IFF_UP)
 937                 fe_init(sc);
 938 }
 939
 940 /*
 941  * Stop everything on the interface.
 942  *
 943  * All buffered packets, both transmitting and receiving,
 944  * if any, will be lost by stopping the interface.
 945  */
 946 void
 947 fe_stop (struct fe_softc *sc)
 948 {
 949         /* Disable interrupts.  */
 950         fe_outb(sc, FE_DLCR2, 0x00);
 951         fe_outb(sc, FE_DLCR3, 0x00);
 952
 953         /* Stop interface hardware.  */
 954         DELAY(200);
 955         fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
 956         DELAY(200);
 957
 958         /* Clear all interrupt status.  */
 959         fe_outb(sc, FE_DLCR0, 0xFF);
 960         fe_outb(sc, FE_DLCR1, 0xFF);
 961
 962         /* Put the chip in stand-by mode.  */
 963         DELAY(200);
 964         fe_outb(sc, FE_DLCR7, sc->proto_dlcr7 | FE_D7_POWER_DOWN);
 965         DELAY(200);
 966
 967         /* Reset transmitter variables and interface flags.  */
 968         sc->sc_if.if_flags &= ~IFF_RUNNING;
 969         ifq_clr_oactive(&sc->sc_if.if_snd);
 970         sc->sc_if.if_timer = 0;
 971         sc->txb_free = sc->txb_size;
 972         sc->txb_count = 0;
 973         sc->txb_sched = 0;
 974
 975         /* MAR loading can be delayed.  */
 976         sc->filter_change = 0;
 977
 978         /* Call a device-specific hook.  */
 979         if (sc->stop)
 980                 sc->stop(sc);
 981 }
 982
 983 /*
 984  * Device timeout/watchdog routine. Entered if the device neglects to
 985  * generate an interrupt after a transmit has been started on it.
 986  */
 987 static void
 988 fe_watchdog ( struct ifnet *ifp )
 989 {
 990         struct fe_softc *sc = (struct fe_softc *)ifp;
 991
 992         /* A "debug" message.  */
 993         kprintf("%s: transmission timeout (%d+%d)%s\n",
 994                ifp->if_xname, sc->txb_sched, sc->txb_count,
 995                (ifp->if_flags & IFF_UP) ? "" : " when down");
 996         if (sc->sc_if.if_opackets == 0 && sc->sc_if.if_ipackets == 0)
 997                 kprintf("%s: wrong IRQ setting in config?\n", ifp->if_xname);
 998         fe_reset(sc);
 999 }
1000
1001 /*
1002  * Initialize device.
1003  */
1004 static void
1005 fe_init (void * xsc)
1006 {
1007         struct fe_softc *sc = xsc;
1008
1009         /* Start initializing 86960.  */
1010         /* Call a hook before we start initializing the chip.  */
1011         if (sc->init)
1012                 sc->init(sc);
1013
1014         /*
1015          * Make sure to disable the chip, also.
1016          * This may also help re-programming the chip after
1017          * hot insertion of PCMCIAs.
1018          */
1019         DELAY(200);
1020         fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
1021         DELAY(200);
1022
1023         /* Power up the chip and select register bank for DLCRs.  */
1024         DELAY(200);
1025         fe_outb(sc, FE_DLCR7,
1026                 sc->proto_dlcr7 | FE_D7_RBS_DLCR | FE_D7_POWER_UP);
1027         DELAY(200);
1028
1029         /* Feed the station address.  */
1030         fe_outblk(sc, FE_DLCR8, sc->sc_enaddr, ETHER_ADDR_LEN);
1031
1032         /* Clear multicast address filter to receive nothing.  */
1033         fe_outb(sc, FE_DLCR7,
1034                 sc->proto_dlcr7 | FE_D7_RBS_MAR | FE_D7_POWER_UP);
1035         fe_outblk(sc, FE_MAR8, fe_filter_nothing.data, FE_FILTER_LEN);
1036
1037         /* Select the BMPR bank for runtime register access.  */
1038         fe_outb(sc, FE_DLCR7,
1039                 sc->proto_dlcr7 | FE_D7_RBS_BMPR | FE_D7_POWER_UP);
1040
1041         /* Initialize registers.  */
1042         fe_outb(sc, FE_DLCR0, 0xFF);    /* Clear all bits.  */
1043         fe_outb(sc, FE_DLCR1, 0xFF);    /* ditto.  */
1044         fe_outb(sc, FE_DLCR2, 0x00);
1045         fe_outb(sc, FE_DLCR3, 0x00);
1046         fe_outb(sc, FE_DLCR4, sc->proto_dlcr4);
1047         fe_outb(sc, FE_DLCR5, sc->proto_dlcr5);
1048         fe_outb(sc, FE_BMPR10, 0x00);
1049         fe_outb(sc, FE_BMPR11, FE_B11_CTRL_SKIP | FE_B11_MODE1);
1050         fe_outb(sc, FE_BMPR12, 0x00);
1051         fe_outb(sc, FE_BMPR13, sc->proto_bmpr13);
1052         fe_outb(sc, FE_BMPR14, 0x00);
1053         fe_outb(sc, FE_BMPR15, 0x00);
1054
1055         /* Enable interrupts.  */
1056         fe_outb(sc, FE_DLCR2, FE_TMASK);
1057         fe_outb(sc, FE_DLCR3, FE_RMASK);
1058
1059         /* Select requested media, just before enabling DLC.  */
1060         if (sc->msel)
1061                 sc->msel(sc);
1062
1063         /* Enable transmitter and receiver.  */
1064         DELAY(200);
1065         fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_ENABLE);
1066         DELAY(200);
1067
1068 #ifdef DIAGNOSTIC
1069         /*
1070          * Make sure to empty the receive buffer.
1071          *
1072          * This may be redundant, but *if* the receive buffer were full
1073          * at this point, then the driver would hang.  I have experienced
1074          * some strange hang-up just after UP.  I hope the following
1075          * code solve the problem.
1076          *
1077          * I have changed the order of hardware initialization.
1078          * I think the receive buffer cannot have any packets at this
1079          * point in this version.  The following code *must* be
1080          * redundant now.  FIXME.
1081          *
1082          * I've heard a rumore that on some PC card implementation of
1083          * 8696x, the receive buffer can have some data at this point.
1084          * The following message helps discovering the fact.  FIXME.
1085          */
1086         if (!(fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)) {
1087                 kprintf("fe%d: receive buffer has some data after reset\n",
1088                        sc->sc_unit);
1089                 fe_emptybuffer(sc);
1090         }
1091
1092         /* Do we need this here?  Actually, no.  I must be paranoia.  */
1093         fe_outb(sc, FE_DLCR0, 0xFF);    /* Clear all bits.  */
1094         fe_outb(sc, FE_DLCR1, 0xFF);    /* ditto.  */
1095 #endif
1096
1097         /* Set 'running' flag, because we are now running.   */
1098         sc->sc_if.if_flags |= IFF_RUNNING;
1099
1100         /*
1101          * At this point, the interface is running properly,
1102          * except that it receives *no* packets.  we then call
1103          * fe_setmode() to tell the chip what packets to be
1104          * received, based on the if_flags and multicast group
1105          * list.  It completes the initialization process.
1106          */
1107         fe_setmode(sc);
1108
1109 #if 0
1110         /* ...and attempt to start output queued packets.  */
1111         /* TURNED OFF, because the semi-auto media prober wants to UP
1112            the interface keeping it idle.  The upper layer will soon
1113            start the interface anyway, and there are no significant
1114            delay.  */
1115         if_devstart(&sc->sc_if);
1116 #endif
1117 }
1118
1119 /*
1120  * This routine actually starts the transmission on the interface
1121  */
1122 static void
1123 fe_xmit (struct fe_softc *sc)
1124 {
1125         /*
1126          * Set a timer just in case we never hear from the board again.
1127          * We use longer timeout for multiple packet transmission.
1128          * I'm not sure this timer value is appropriate.  FIXME.
1129          */
1130         sc->sc_if.if_timer = 1 + sc->txb_count;
1131
1132         /* Update txb variables.  */
1133         sc->txb_sched = sc->txb_count;
1134         sc->txb_count = 0;
1135         sc->txb_free = sc->txb_size;
1136         sc->tx_excolls = 0;
1137
1138         /* Start transmitter, passing packets in TX buffer.  */
1139         fe_outb(sc, FE_BMPR10, sc->txb_sched | FE_B10_START);
1140 }
1141
1142 /*
1143  * Start output on interface.
1144  * We make two assumptions here:
1145  *  1) that the current priority is set to splimp _before_ this code
1146  *     is called *and* is returned to the appropriate priority after
1147  *     return
1148  *  2) that the OACTIVE flag is checked before this code is called
1149  *     (i.e. that the output part of the interface is idle)
1150  */
1151 void
1152 fe_start (struct ifnet *ifp, struct ifaltq_subque *ifsq)
1153 {
1154         struct fe_softc *sc = ifp->if_softc;
1155         struct mbuf *m;
1156
1157         ASSERT_ALTQ_SQ_DEFAULT(ifp, ifsq);
1158
1159 #ifdef DIAGNOSTIC
1160         /* Just a sanity check.  */
1161         if ((sc->txb_count == 0) != (sc->txb_free == sc->txb_size)) {
1162                 /*
1163                  * Txb_count and txb_free co-works to manage the
1164                  * transmission buffer.  Txb_count keeps track of the
1165                  * used potion of the buffer, while txb_free does unused
1166                  * potion.  So, as long as the driver runs properly,
1167                  * txb_count is zero if and only if txb_free is same
1168                  * as txb_size (which represents whole buffer.)
1169                  */
1170                 kprintf("fe%d: inconsistent txb variables (%d, %d)\n",
1171                         sc->sc_unit, sc->txb_count, sc->txb_free);
1172                 /*
1173                  * So, what should I do, then?
1174                  *
1175                  * We now know txb_count and txb_free contradicts.  We
1176                  * cannot, however, tell which is wrong.  More
1177                  * over, we cannot peek 86960 transmission buffer or
1178                  * reset the transmission buffer.  (In fact, we can
1179                  * reset the entire interface.  I don't want to do it.)
1180                  *
1181                  * If txb_count is incorrect, leaving it as-is will cause
1182                  * sending of garbage after next interrupt.  We have to
1183                  * avoid it.  Hence, we reset the txb_count here.  If
1184                  * txb_free was incorrect, resetting txb_count just loose
1185                  * some packets.  We can live with it.
1186                  */
1187                 sc->txb_count = 0;
1188         }
1189 #endif
1190
1191         /*
1192          * First, see if there are buffered packets and an idle
1193          * transmitter - should never happen at this point.
1194          */
1195         if ((sc->txb_count > 0) && (sc->txb_sched == 0)) {
1196                 kprintf("fe%d: transmitter idle with %d buffered packets\n",
1197                        sc->sc_unit, sc->txb_count);
1198                 fe_xmit(sc);
1199         }
1200
1201         /*
1202          * Stop accepting more transmission packets temporarily, when
1203          * a filter change request is delayed.  Updating the MARs on
1204          * 86960 flushes the transmission buffer, so it is delayed
1205          * until all buffered transmission packets have been sent
1206          * out.
1207          */
1208         if (sc->filter_change) {
1209                 /*
1210                  * Filter change request is delayed only when the DLC is
1211                  * working.  DLC soon raise an interrupt after finishing
1212                  * the work.
1213                  */
1214                 goto indicate_active;
1215         }
1216
1217         for (;;) {
1218
1219                 /*
1220                  * See if there is room to put another packet in the buffer.
1221                  * We *could* do better job by peeking the send queue to
1222                  * know the length of the next packet.  Current version just
1223                  * tests against the worst case (i.e., longest packet).  FIXME.
1224                  *
1225                  * When adding the packet-peek feature, don't forget adding a
1226                  * test on txb_count against QUEUEING_MAX.
1227                  * There is a little chance the packet count exceeds
1228                  * the limit.  Assume transmission buffer is 8KB (2x8KB
1229                  * configuration) and an application sends a bunch of small
1230                  * (i.e., minimum packet sized) packets rapidly.  An 8KB
1231                  * buffer can hold 130 blocks of 62 bytes long...
1232                  */
1233                 if (sc->txb_free
1234                     < ETHER_MAX_LEN - ETHER_CRC_LEN + FE_DATA_LEN_LEN) {
1235                         /* No room.  */
1236                         goto indicate_active;
1237                 }
1238
1239 #if FE_SINGLE_TRANSMISSION
1240                 if (sc->txb_count > 0) {
1241                         /* Just one packet per a transmission buffer.  */
1242                         goto indicate_active;
1243                 }
1244 #endif
1245
1246                 /*
1247                  * Get the next mbuf chain for a packet to send.
1248                  */
1249                 m = ifq_dequeue(&sc->sc_if.if_snd, NULL);
1250                 if (m == NULL) {
1251                         /* No more packets to send.  */
1252                         goto indicate_inactive;
1253                 }
1254
1255                 /*
1256                  * Copy the mbuf chain into the transmission buffer.
1257                  * txb_* variables are updated as necessary.
1258                  */
1259                 fe_write_mbufs(sc, m);
1260
1261                 /* Start transmitter if it's idle.  */
1262                 if ((sc->txb_count > 0) && (sc->txb_sched == 0))
1263                         fe_xmit(sc);
1264
1265                 /*
1266                  * Tap off here if there is a bpf listener,
1267                  * and the device is *not* in promiscuous mode.
1268                  * (86960 receives self-generated packets if
1269                  * and only if it is in "receive everything"
1270                  * mode.)
1271                  */
1272                 if ((sc->sc_if.if_flags & IFF_PROMISC) == 0)
1273                         BPF_MTAP(&sc->sc_if, m);
1274
1275                 m_freem(m);
1276         }
1277
1278   indicate_inactive:
1279         /*
1280          * We are using the !OACTIVE flag to indicate to
1281          * the outside world that we can accept an
1282          * additional packet rather than that the
1283          * transmitter is _actually_ active.  Indeed, the
1284          * transmitter may be active, but if we haven't
1285          * filled all the buffers with data then we still
1286          * want to accept more.
1287          */
1288         ifq_clr_oactive(&sc->sc_if.if_snd);
1289         return;
1290
1291   indicate_active:
1292         /*
1293          * The transmitter is active, and there are no room for
1294          * more outgoing packets in the transmission buffer.
1295          */
1296         ifq_set_oactive(&sc->sc_if.if_snd);
1297         return;
1298 }
1299
1300 /*
1301  * Drop (skip) a packet from receive buffer in 86960 memory.
1302  */
1303 static void
1304 fe_droppacket (struct fe_softc * sc, int len)
1305 {
1306         int i;
1307
1308         /*
1309          * 86960 manual says that we have to read 8 bytes from the buffer
1310          * before skip the packets and that there must be more than 8 bytes
1311          * remaining in the buffer when issue a skip command.
1312          * Remember, we have already read 4 bytes before come here.
1313          */
1314         if (len > 12) {
1315                 /* Read 4 more bytes, and skip the rest of the packet.  */
1316 #ifdef FE_8BIT_SUPPORT
1317                 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1318                 {
1319                         fe_inb(sc, FE_BMPR8);
1320                         fe_inb(sc, FE_BMPR8);
1321                         fe_inb(sc, FE_BMPR8);
1322                         fe_inb(sc, FE_BMPR8);
1323                 }
1324                 else
1325 #endif
1326                 {
1327                         fe_inw(sc, FE_BMPR8);
1328                         fe_inw(sc, FE_BMPR8);
1329                 }
1330                 fe_outb(sc, FE_BMPR14, FE_B14_SKIP);
1331         } else {
1332                 /* We should not come here unless receiving RUNTs.  */
1333 #ifdef FE_8BIT_SUPPORT
1334                 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1335                 {
1336                         for (i = 0; i < len; i++)
1337                                 fe_inb(sc, FE_BMPR8);
1338                 }
1339                 else
1340 #endif
1341                 {
1342                         for (i = 0; i < len; i += 2)
1343                                 fe_inw(sc, FE_BMPR8);
1344                 }
1345         }
1346 }
1347
1348 #ifdef DIAGNOSTIC
1349 /*
1350  * Empty receiving buffer.
1351  */
1352 static void
1353 fe_emptybuffer (struct fe_softc * sc)
1354 {
1355         int i;
1356         u_char saved_dlcr5;
1357
1358 #ifdef FE_DEBUG
1359         kprintf("fe%d: emptying receive buffer\n", sc->sc_unit);
1360 #endif
1361
1362         /*
1363          * Stop receiving packets, temporarily.
1364          */
1365         saved_dlcr5 = fe_inb(sc, FE_DLCR5);
1366         fe_outb(sc, FE_DLCR5, sc->proto_dlcr5);
1367         DELAY(1300);
1368
1369         /*
1370          * When we come here, the receive buffer management may
1371          * have been broken.  So, we cannot use skip operation.
1372          * Just discard everything in the buffer.
1373          */
1374 #ifdef FE_8BIT_SUPPORT
1375         if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1376         {
1377                 for (i = 0; i < 65536; i++) {
1378                         if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)
1379                                 break;
1380                         fe_inb(sc, FE_BMPR8);
1381                 }
1382         }
1383         else
1384 #endif
1385         {
1386                 for (i = 0; i < 65536; i += 2) {
1387                         if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)
1388                                 break;
1389                         fe_inw(sc, FE_BMPR8);
1390                 }
1391         }
1392
1393         /*
1394          * Double check.
1395          */
1396         if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP) {
1397                 kprintf("fe%d: could not empty receive buffer\n", sc->sc_unit);
1398                 /* Hmm.  What should I do if this happens?  FIXME.  */
1399         }
1400
1401         /*
1402          * Restart receiving packets.
1403          */
1404         fe_outb(sc, FE_DLCR5, saved_dlcr5);
1405 }
1406 #endif
1407
1408 /*
1409  * Transmission interrupt handler
1410  * The control flow of this function looks silly.  FIXME.
1411  */
1412 static void
1413 fe_tint (struct fe_softc * sc, u_char tstat)
1414 {
1415         int left;
1416         int col;
1417
1418         /*
1419          * Handle "excessive collision" interrupt.
1420          */
1421         if (tstat & FE_D0_COLL16) {
1422
1423                 /*
1424                  * Find how many packets (including this collided one)
1425                  * are left unsent in transmission buffer.
1426                  */
1427                 left = fe_inb(sc, FE_BMPR10);
1428                 kprintf("fe%d: excessive collision (%d/%d)\n",
1429                        sc->sc_unit, left, sc->txb_sched);
1430
1431                 /*
1432                  * Clear the collision flag (in 86960) here
1433                  * to avoid confusing statistics.
1434                  */
1435                 fe_outb(sc, FE_DLCR0, FE_D0_COLLID);
1436
1437                 /*
1438                  * Restart transmitter, skipping the
1439                  * collided packet.
1440                  *
1441                  * We *must* skip the packet to keep network running
1442                  * properly.  Excessive collision error is an
1443                  * indication of the network overload.  If we
1444                  * tried sending the same packet after excessive
1445                  * collision, the network would be filled with
1446                  * out-of-time packets.  Packets belonging
1447                  * to reliable transport (such as TCP) are resent
1448                  * by some upper layer.
1449                  */
1450                 fe_outb(sc, FE_BMPR11, FE_B11_CTRL_SKIP | FE_B11_MODE1);
1451
1452                 /* Update statistics.  */
1453                 sc->tx_excolls++;
1454         }
1455
1456         /*
1457          * Handle "transmission complete" interrupt.
1458          */
1459         if (tstat & FE_D0_TXDONE) {
1460
1461                 /*
1462                  * Add in total number of collisions on last
1463                  * transmission.  We also clear "collision occurred" flag
1464                  * here.
1465                  *
1466                  * 86960 has a design flaw on collision count on multiple
1467                  * packet transmission.  When we send two or more packets
1468                  * with one start command (that's what we do when the
1469                  * transmission queue is crowded), 86960 informs us number
1470                  * of collisions occurred on the last packet on the
1471                  * transmission only.  Number of collisions on previous
1472                  * packets are lost.  I have told that the fact is clearly
1473                  * stated in the Fujitsu document.
1474                  *
1475                  * I considered not to mind it seriously.  Collision
1476                  * count is not so important, anyway.  Any comments?  FIXME.
1477                  */
1478
1479                 if (fe_inb(sc, FE_DLCR0) & FE_D0_COLLID) {
1480
1481                         /* Clear collision flag.  */
1482                         fe_outb(sc, FE_DLCR0, FE_D0_COLLID);
1483
1484                         /* Extract collision count from 86960.  */
1485                         col = fe_inb(sc, FE_DLCR4);
1486                         col = (col & FE_D4_COL) >> FE_D4_COL_SHIFT;
1487                         if (col == 0) {
1488                                 /*
1489                                  * Status register indicates collisions,
1490                                  * while the collision count is zero.
1491                                  * This can happen after multiple packet
1492                                  * transmission, indicating that one or more
1493                                  * previous packet(s) had been collided.
1494                                  *
1495                                  * Since the accurate number of collisions
1496                                  * has been lost, we just guess it as 1;
1497                                  * Am I too optimistic?  FIXME.
1498                                  */
1499                                 col = 1;
1500                         }
1501                         sc->sc_if.if_collisions += col;
1502                         if (col == 1)
1503                                 sc->mibdata.dot3StatsSingleCollisionFrames++;
1504                         else
1505                                 sc->mibdata.dot3StatsMultipleCollisionFrames++;
1506                         sc->mibdata.dot3StatsCollFrequencies[col-1]++;
1507                 }
1508
1509                 /*
1510                  * Update transmission statistics.
1511                  * Be sure to reflect number of excessive collisions.
1512                  */
1513                 col = sc->tx_excolls;
1514                 sc->sc_if.if_opackets += sc->txb_sched - col;
1515                 sc->sc_if.if_oerrors += col;
1516                 sc->sc_if.if_collisions += col * 16;
1517                 sc->mibdata.dot3StatsExcessiveCollisions += col;
1518                 sc->mibdata.dot3StatsCollFrequencies[15] += col;
1519                 sc->txb_sched = 0;
1520
1521                 /*
1522                  * The transmitter is no more active.
1523                  * Reset output active flag and watchdog timer.
1524                  */
1525                 ifq_clr_oactive(&sc->sc_if.if_snd);
1526                 sc->sc_if.if_timer = 0;
1527
1528                 /*
1529                  * If more data is ready to transmit in the buffer, start
1530                  * transmitting them.  Otherwise keep transmitter idle,
1531                  * even if more data is queued.  This gives receive
1532                  * process a slight priority.
1533                  */
1534                 if (sc->txb_count > 0)
1535                         fe_xmit(sc);
1536         }
1537 }
1538
1539 /*
1540  * Ethernet interface receiver interrupt.
1541  */
1542 static void
1543 fe_rint (struct fe_softc * sc, u_char rstat)
1544 {
1545         u_short len;
1546         u_char status;
1547         int i;
1548
1549         /*
1550          * Update statistics if this interrupt is caused by an error.
1551          * Note that, when the system was not sufficiently fast, the
1552          * receive interrupt might not be acknowledged immediately.  If
1553          * one or more errornous frames were received before this routine
1554          * was scheduled, they are ignored, and the following error stats
1555          * give less than real values.
1556          */
1557         if (rstat & (FE_D1_OVRFLO | FE_D1_CRCERR | FE_D1_ALGERR | FE_D1_SRTPKT)) {
1558                 if (rstat & FE_D1_OVRFLO)
1559                         sc->mibdata.dot3StatsInternalMacReceiveErrors++;
1560                 if (rstat & FE_D1_CRCERR)
1561                         sc->mibdata.dot3StatsFCSErrors++;
1562                 if (rstat & FE_D1_ALGERR)
1563                         sc->mibdata.dot3StatsAlignmentErrors++;
1564 #if 0
1565                 /* The reference MAC receiver defined in 802.3
1566                    silently ignores short frames (RUNTs) without
1567                    notifying upper layer.  RFC 1650 (dot3 MIB) is
1568                    based on the 802.3, and it has no stats entry for
1569                    RUNTs...  */
1570                 if (rstat & FE_D1_SRTPKT)
1571                         sc->mibdata.dot3StatsFrameTooShorts++; /* :-) */
1572 #endif
1573                 sc->sc_if.if_ierrors++;
1574         }
1575
1576         /*
1577          * MB86960 has a flag indicating "receive queue empty."
1578          * We just loop, checking the flag, to pull out all received
1579          * packets.
1580          *
1581          * We limit the number of iterations to avoid infinite-loop.
1582          * The upper bound is set to unrealistic high value.
1583          */
1584         for (i = 0; i < FE_MAX_RECV_COUNT * 2; i++) {
1585
1586                 /* Stop the iteration if 86960 indicates no packets.  */
1587                 if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)
1588                         return;
1589
1590                 /*
1591                  * Extract a receive status byte.
1592                  * As our 86960 is in 16 bit bus access mode, we have to
1593                  * use inw() to get the status byte.  The significant
1594                  * value is returned in lower 8 bits.
1595                  */
1596 #ifdef FE_8BIT_SUPPORT
1597                 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1598                 {
1599                         status = fe_inb(sc, FE_BMPR8);
1600                         fe_inb(sc, FE_BMPR8);
1601                 }
1602                 else
1603 #endif
1604                 {
1605                         status = (u_char) fe_inw(sc, FE_BMPR8);
1606                 }
1607
1608                 /*
1609                  * Extract the packet length.
1610                  * It is a sum of a header (14 bytes) and a payload.
1611                  * CRC has been stripped off by the 86960.
1612                  */
1613 #ifdef FE_8BIT_SUPPORT
1614                 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1615                 {
1616                         len  =  fe_inb(sc, FE_BMPR8);
1617                         len |= (fe_inb(sc, FE_BMPR8) << 8);
1618                 }
1619                 else
1620 #endif
1621                 {
1622                         len = fe_inw(sc, FE_BMPR8);
1623                 }
1624
1625                 /*
1626                  * AS our 86960 is programed to ignore errored frame,
1627                  * we must not see any error indication in the
1628                  * receive buffer.  So, any error condition is a
1629                  * serious error, e.g., out-of-sync of the receive
1630                  * buffer pointers.
1631                  */
1632                 if ((status & 0xF0) != 0x20 ||
1633                     len > ETHER_MAX_LEN - ETHER_CRC_LEN ||
1634                     len < ETHER_MIN_LEN - ETHER_CRC_LEN) {
1635                         kprintf("fe%d: RX buffer out-of-sync\n", sc->sc_unit);
1636                         sc->sc_if.if_ierrors++;
1637                         sc->mibdata.dot3StatsInternalMacReceiveErrors++;
1638                         fe_reset(sc);
1639                         return;
1640                 }
1641
1642                 /*
1643                  * Go get a packet.
1644                  */
1645                 if (fe_get_packet(sc, len) < 0) {
1646                         /*
1647                          * Negative return from fe_get_packet()
1648                          * indicates no available mbuf.  We stop
1649                          * receiving packets, even if there are more
1650                          * in the buffer.  We hope we can get more
1651                          * mbuf next time.
1652                          */
1653                         sc->sc_if.if_ierrors++;
1654                         sc->mibdata.dot3StatsMissedFrames++;
1655                         fe_droppacket(sc, len);
1656                         return;
1657                 }
1658
1659                 /* Successfully received a packet.  Update stat.  */
1660                 sc->sc_if.if_ipackets++;
1661         }
1662
1663         /* Maximum number of frames has been received.  Something
1664            strange is happening here... */
1665         kprintf("fe%d: unusual receive flood\n", sc->sc_unit);
1666         sc->mibdata.dot3StatsInternalMacReceiveErrors++;
1667         fe_reset(sc);
1668 }
1669
1670 /*
1671  * Ethernet interface interrupt processor
1672  */
1673 static void
1674 fe_intr (void *arg)
1675 {
1676         struct fe_softc *sc = arg;
1677         u_char tstat, rstat;
1678         int loop_count = FE_MAX_LOOP;
1679
1680         /* Loop until there are no more new interrupt conditions.  */
1681         while (loop_count-- > 0) {
1682                 /*
1683                  * Get interrupt conditions, masking unneeded flags.
1684                  */
1685                 tstat = fe_inb(sc, FE_DLCR0) & FE_TMASK;
1686                 rstat = fe_inb(sc, FE_DLCR1) & FE_RMASK;
1687                 if (tstat == 0 && rstat == 0)
1688                         return;
1689
1690                 /*
1691                  * Reset the conditions we are acknowledging.
1692                  */
1693                 fe_outb(sc, FE_DLCR0, tstat);
1694                 fe_outb(sc, FE_DLCR1, rstat);
1695
1696                 /*
1697                  * Handle transmitter interrupts.
1698                  */
1699                 if (tstat)
1700                         fe_tint(sc, tstat);
1701
1702                 /*
1703                  * Handle receiver interrupts
1704                  */
1705                 if (rstat)
1706                         fe_rint(sc, rstat);
1707
1708                 /*
1709                  * Update the multicast address filter if it is
1710                  * needed and possible.  We do it now, because
1711                  * we can make sure the transmission buffer is empty,
1712                  * and there is a good chance that the receive queue
1713                  * is empty.  It will minimize the possibility of
1714                  * packet loss.
1715                  */
1716                 if (sc->filter_change &&
1717                     sc->txb_count == 0 && sc->txb_sched == 0) {
1718                         fe_loadmar(sc);
1719                         ifq_clr_oactive(&sc->sc_if.if_snd);
1720                 }
1721
1722                 /*
1723                  * If it looks like the transmitter can take more data,
1724                  * attempt to start output on the interface. This is done
1725                  * after handling the receiver interrupt to give the
1726                  * receive operation priority.
1727                  *
1728                  * BTW, I'm not sure in what case the OACTIVE is on at
1729                  * this point.  Is the following test redundant?
1730                  *
1731                  * No.  This routine polls for both transmitter and
1732                  * receiver interrupts.  86960 can raise a receiver
1733                  * interrupt when the transmission buffer is full.
1734                  */
1735                 if (!ifq_is_oactive(&sc->sc_if.if_snd))
1736                         if_devstart(&sc->sc_if);
1737         }
1738
1739         kprintf("fe%d: too many loops\n", sc->sc_unit);
1740 }
1741
1742 /*
1743  * Process an ioctl request. This code needs some work - it looks
1744  * pretty ugly.
1745  */
1746 static int
1747 fe_ioctl (struct ifnet * ifp, u_long command, caddr_t data, struct ucred *cr)
1748 {
1749         struct fe_softc *sc = ifp->if_softc;
1750         struct ifreq *ifr = (struct ifreq *)data;
1751         int error = 0;
1752
1753         switch (command) {
1754           case SIOCSIFFLAGS:
1755                 /*
1756                  * Switch interface state between "running" and
1757                  * "stopped", reflecting the UP flag.
1758                  */
1759                 if (sc->sc_if.if_flags & IFF_UP) {
1760                         if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
1761                                 fe_init(sc);
1762                 } else {
1763                         if ((sc->sc_if.if_flags & IFF_RUNNING) != 0)
1764                                 fe_stop(sc);
1765                 }
1766
1767                 /*
1768                  * Promiscuous and/or multicast flags may have changed,
1769                  * so reprogram the multicast filter and/or receive mode.
1770                  */
1771                 fe_setmode(sc);
1772
1773                 /* Done.  */
1774                 break;
1775
1776           case SIOCADDMULTI:
1777           case SIOCDELMULTI:
1778                 /*
1779                  * Multicast list has changed; set the hardware filter
1780                  * accordingly.
1781                  */
1782                 fe_setmode(sc);
1783                 break;
1784
1785           case SIOCSIFMEDIA:
1786           case SIOCGIFMEDIA:
1787                 /* Let if_media to handle these commands and to call
1788                    us back.  */
1789                 error = ifmedia_ioctl(ifp, ifr, &sc->media, command);
1790                 break;
1791
1792           default:
1793                 error = ether_ioctl(ifp, command, data);
1794                 break;
1795         }
1796         return (error);
1797 }
1798
1799 /*
1800  * Retrieve packet from receive buffer and send to the next level up via
1801  * ether_input().
1802  * Returns 0 if success, -1 if error (i.e., mbuf allocation failure).
1803  */
1804 static int
1805 fe_get_packet (struct fe_softc * sc, u_short len)
1806 {
1807         struct ether_header *eh;
1808         struct mbuf *m;
1809
1810         /*
1811          * NFS wants the data be aligned to the word (4 byte)
1812          * boundary.  Ethernet header has 14 bytes.  There is a
1813          * 2-byte gap.
1814          */
1815 #define NFS_MAGIC_OFFSET 2
1816
1817         /*
1818          * This function assumes that an Ethernet packet fits in an
1819          * mbuf (with a cluster attached when necessary.)  On FreeBSD
1820          * 2.0 for x86, which is the primary target of this driver, an
1821          * mbuf cluster has 4096 bytes, and we are happy.  On ancient
1822          * BSDs, such as vanilla 4.3 for 386, a cluster size was 1024,
1823          * however.  If the following #error message were printed upon
1824          * compile, you need to rewrite this function.
1825          */
1826 #if ( MCLBYTES < ETHER_MAX_LEN - ETHER_CRC_LEN + NFS_MAGIC_OFFSET )
1827 #error "Too small MCLBYTES to use fe driver."
1828 #endif
1829
1830         /*
1831          * Our strategy has one more problem.  There is a policy on
1832          * mbuf cluster allocation.  It says that we must have at
1833          * least MINCLSIZE (208 bytes on FreeBSD 2.0 for x86) to
1834          * allocate a cluster.  For a packet of a size between
1835          * (MHLEN - 2) to (MINCLSIZE - 2), our code violates the rule...
1836          * On the other hand, the current code is short, simple,
1837          * and fast, however.  It does no harmful thing, just waists
1838          * some memory.  Any comments?  FIXME.
1839          */
1840
1841         /* Allocate an mbuf with packet header info.  */
1842         MGETHDR(m, MB_DONTWAIT, MT_DATA);
1843         if (m == NULL)
1844                 return -1;
1845
1846         /* Attach a cluster if this packet doesn't fit in a normal mbuf.  */
1847         if (len > MHLEN - NFS_MAGIC_OFFSET) {
1848                 MCLGET(m, MB_DONTWAIT);
1849                 if (!(m->m_flags & M_EXT)) {
1850                         m_freem(m);
1851                         return -1;
1852                 }
1853         }
1854
1855         /* Initialize packet header info.  */
1856         m->m_pkthdr.rcvif = &sc->sc_if;
1857         m->m_pkthdr.len = len;
1858
1859         /* Set the length of this packet.  */
1860         m->m_len = len;
1861
1862         /* The following silliness is to make NFS happy */
1863         m->m_data += NFS_MAGIC_OFFSET;
1864
1865         /* Get (actually just point to) the header part.  */
1866         eh = mtod(m, struct ether_header *);
1867
1868         /* Get a packet.  */
1869 #ifdef FE_8BIT_SUPPORT
1870         if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1871         {
1872                 fe_insb(sc, FE_BMPR8, (u_int8_t *)eh, len);
1873         }
1874         else
1875 #endif
1876         {
1877                 fe_insw(sc, FE_BMPR8, (u_int16_t *)eh, (len + 1) >> 1);
1878         }
1879
1880         /* Feed the packet to upper layer.  */
1881         sc->sc_if.if_input(&sc->sc_if, m);
1882         return 0;
1883 }
1884
1885 /*
1886  * Write an mbuf chain to the transmission buffer memory using 16 bit PIO.
1887  * Returns number of bytes actually written, including length word.
1888  *
1889  * If an mbuf chain is too long for an Ethernet frame, it is not sent.
1890  * Packets shorter than Ethernet minimum are legal, and we pad them
1891  * before sending out.  An exception is "partial" packets which are
1892  * shorter than mandatory Ethernet header.
1893  */
1894 static void
1895 fe_write_mbufs (struct fe_softc *sc, struct mbuf *m)
1896 {
1897         u_short length, len;
1898         struct mbuf *mp;
1899         u_char *data;
1900         u_short savebyte;       /* WARNING: Architecture dependent!  */
1901 #define NO_PENDING_BYTE 0xFFFF
1902
1903         static u_char padding [ETHER_MIN_LEN - ETHER_CRC_LEN - ETHER_HDR_LEN];
1904
1905 #ifdef DIAGNOSTIC
1906         /* First, count up the total number of bytes to copy */
1907         length = 0;
1908         for (mp = m; mp != NULL; mp = mp->m_next)
1909                 length += mp->m_len;
1910
1911         /* Check if this matches the one in the packet header.  */
1912         if (length != m->m_pkthdr.len) {
1913                 kprintf("fe%d: packet length mismatch? (%d/%d)\n", sc->sc_unit,
1914                        length, m->m_pkthdr.len);
1915         }
1916 #else
1917         /* Just use the length value in the packet header.  */
1918         length = m->m_pkthdr.len;
1919 #endif
1920
1921 #ifdef DIAGNOSTIC
1922         /*
1923          * Should never send big packets.  If such a packet is passed,
1924          * it should be a bug of upper layer.  We just ignore it.
1925          * ... Partial (too short) packets, neither.
1926          */
1927         if (length < ETHER_HDR_LEN ||
1928             length > ETHER_MAX_LEN - ETHER_CRC_LEN) {
1929                 kprintf("fe%d: got an out-of-spec packet (%u bytes) to send\n",
1930                         sc->sc_unit, length);
1931                 sc->sc_if.if_oerrors++;
1932                 sc->mibdata.dot3StatsInternalMacTransmitErrors++;
1933                 return;
1934         }
1935 #endif
1936
1937         /*
1938          * Put the length word for this frame.
1939          * Does 86960 accept odd length?  -- Yes.
1940          * Do we need to pad the length to minimum size by ourselves?
1941          * -- Generally yes.  But for (or will be) the last
1942          * packet in the transmission buffer, we can skip the
1943          * padding process.  It may gain performance slightly.  FIXME.
1944          */
1945 #ifdef FE_8BIT_SUPPORT
1946         if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1947         {
1948                 len = max(length, ETHER_MIN_LEN - ETHER_CRC_LEN);
1949                 fe_outb(sc, FE_BMPR8,  len & 0x00ff);
1950                 fe_outb(sc, FE_BMPR8, (len & 0xff00) >> 8);
1951         }
1952         else
1953 #endif
1954         {
1955                 fe_outw(sc, FE_BMPR8,
1956                         max(length, ETHER_MIN_LEN - ETHER_CRC_LEN));
1957         }
1958
1959         /*
1960          * Update buffer status now.
1961          * Truncate the length up to an even number, since we use outw().
1962          */
1963 #ifdef FE_8BIT_SUPPORT
1964         if ((sc->proto_dlcr6 & FE_D6_SBW) != FE_D6_SBW_BYTE)
1965 #endif
1966         {
1967                 length = (length + 1) & ~1;
1968         }
1969         sc->txb_free -= FE_DATA_LEN_LEN +
1970             max(length, ETHER_MIN_LEN - ETHER_CRC_LEN);
1971         sc->txb_count++;
1972
1973         /*
1974          * Transfer the data from mbuf chain to the transmission buffer.
1975          * MB86960 seems to require that data be transferred as words, and
1976          * only words.  So that we require some extra code to patch
1977          * over odd-length mbufs.
1978          */
1979 #ifdef FE_8BIT_SUPPORT
1980         if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1981         {
1982                 /* 8-bit cards are easy.  */
1983                 for (mp = m; mp != NULL; mp = mp->m_next) {
1984                         if (mp->m_len)
1985                                 fe_outsb(sc, FE_BMPR8, mtod(mp, caddr_t),
1986                                          mp->m_len);
1987                 }
1988         }
1989         else
1990 #endif
1991         {
1992                 /* 16-bit cards are a pain.  */
1993                 savebyte = NO_PENDING_BYTE;
1994                 for (mp = m; mp != NULL; mp = mp->m_next) {
1995
1996                         /* Ignore empty mbuf.  */
1997                         len = mp->m_len;
1998                         if (len == 0)
1999                                 continue;
2000
2001                         /* Find the actual data to send.  */
2002                         data = mtod(mp, caddr_t);
2003
2004                         /* Finish the last byte.  */
2005                         if (savebyte != NO_PENDING_BYTE) {
2006                                 fe_outw(sc, FE_BMPR8, savebyte | (*data << 8));
2007                                 data++;
2008                                 len--;
2009                                 savebyte = NO_PENDING_BYTE;
2010                         }
2011
2012                         /* output contiguous words */
2013                         if (len > 1) {
2014                                 fe_outsw(sc, FE_BMPR8, (u_int16_t *)data,
2015                                          len >> 1);
2016                                 data += len & ~1;
2017                                 len &= 1;
2018                         }
2019
2020                         /* Save a remaining byte, if there is one.  */
2021                         if (len > 0)
2022                                 savebyte = *data;
2023                 }
2024
2025                 /* Spit the last byte, if the length is odd.  */
2026                 if (savebyte != NO_PENDING_BYTE)
2027                         fe_outw(sc, FE_BMPR8, savebyte);
2028         }
2029
2030         /* Pad to the Ethernet minimum length, if the packet is too short.  */
2031         if (length < ETHER_MIN_LEN - ETHER_CRC_LEN) {
2032 #ifdef FE_8BIT_SUPPORT
2033                 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
2034                 {
2035                         fe_outsb(sc, FE_BMPR8, padding,
2036                                  ETHER_MIN_LEN - ETHER_CRC_LEN - length);
2037                 }
2038                 else
2039 #endif
2040                 {
2041                         fe_outsw(sc, FE_BMPR8, (u_int16_t *)padding,
2042                                  (ETHER_MIN_LEN - ETHER_CRC_LEN - length) >> 1);
2043                 }
2044         }
2045 }
2046
2047 /*
2048  * Compute hash value for an Ethernet address
2049  */
2050 static int
2051 fe_hash ( u_char * ep )
2052 {
2053 #define FE_HASH_MAGIC_NUMBER 0xEDB88320L
2054
2055         u_long hash = 0xFFFFFFFFL;
2056         int i, j;
2057         u_char b;
2058         u_long m;
2059
2060         for ( i = ETHER_ADDR_LEN; --i >= 0; ) {
2061                 b = *ep++;
2062                 for ( j = 8; --j >= 0; ) {
2063                         m = hash;
2064                         hash >>= 1;
2065                         if ( ( m ^ b ) & 1 ) hash ^= FE_HASH_MAGIC_NUMBER;
2066                         b >>= 1;
2067                 }
2068         }
2069         return ( ( int )( hash >> 26 ) );
2070 }
2071
2072 /*
2073  * Compute the multicast address filter from the
2074  * list of multicast addresses we need to listen to.
2075  */
2076 static struct fe_filter
2077 fe_mcaf ( struct fe_softc *sc )
2078 {
2079         int index;
2080         struct fe_filter filter;
2081         struct ifmultiaddr *ifma;
2082 #ifdef FE_DEBUG
2083         char ethstr[ETHER_ADDRSTRLEN + 1];
2084 #endif
2085         filter = fe_filter_nothing;
2086         TAILQ_FOREACH(ifma, &sc->arpcom.ac_if.if_multiaddrs, ifma_link) {
2087                 if (ifma->ifma_addr->sa_family != AF_LINK)
2088                         continue;
2089                 index = fe_hash(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
2090 #ifdef FE_DEBUG
2091                 kprintf("fe%d: hash(%s) == %d\n",
2092                     sc->sc_unit, kether_ntoa(enm->enm_addrlo, ethstr), index);
2093 #endif
2094
2095                 filter.data[index >> 3] |= 1 << (index & 7);
2096         }
2097         return ( filter );
2098 }
2099
2100 /*
2101  * Calculate a new "multicast packet filter" and put the 86960
2102  * receiver in appropriate mode.
2103  */
2104 static void
2105 fe_setmode (struct fe_softc *sc)
2106 {
2107         int flags = sc->sc_if.if_flags;
2108
2109         /*
2110          * If the interface is not running, we postpone the update
2111          * process for receive modes and multicast address filter
2112          * until the interface is restarted.  It reduces some
2113          * complicated job on maintaining chip states.  (Earlier versions
2114          * of this driver had a bug on that point...)
2115          *
2116          * To complete the trick, fe_init() calls fe_setmode() after
2117          * restarting the interface.
2118          */
2119         if (!(flags & IFF_RUNNING))
2120                 return;
2121
2122         /*
2123          * Promiscuous mode is handled separately.
2124          */
2125         if (flags & IFF_PROMISC) {
2126                 /*
2127                  * Program 86960 to receive all packets on the segment
2128                  * including those directed to other stations.
2129                  * Multicast filter stored in MARs are ignored
2130                  * under this setting, so we don't need to update it.
2131                  *
2132                  * Promiscuous mode in FreeBSD 2 is used solely by
2133                  * BPF, and BPF only listens to valid (no error) packets.
2134                  * So, we ignore erroneous ones even in this mode.
2135                  * (Older versions of fe driver mistook the point.)
2136                  */
2137                 fe_outb(sc, FE_DLCR5,
2138                         sc->proto_dlcr5 | FE_D5_AFM0 | FE_D5_AFM1);
2139                 sc->filter_change = 0;
2140                 return;
2141         }
2142
2143         /*
2144          * Turn the chip to the normal (non-promiscuous) mode.
2145          */
2146         fe_outb(sc, FE_DLCR5, sc->proto_dlcr5 | FE_D5_AFM1);
2147
2148         /*
2149          * Find the new multicast filter value.
2150          */
2151         if (flags & IFF_ALLMULTI)
2152                 sc->filter = fe_filter_all;
2153         else
2154                 sc->filter = fe_mcaf(sc);
2155         sc->filter_change = 1;
2156
2157         /*
2158          * We have to update the multicast filter in the 86960, A.S.A.P.
2159          *
2160          * Note that the DLC (Data Link Control unit, i.e. transmitter
2161          * and receiver) must be stopped when feeding the filter, and
2162          * DLC trashes all packets in both transmission and receive
2163          * buffers when stopped.
2164          *
2165          * To reduce the packet loss, we delay the filter update
2166          * process until buffers are empty.
2167          */
2168         if (sc->txb_sched == 0 && sc->txb_count == 0 &&
2169             !(fe_inb(sc, FE_DLCR1) & FE_D1_PKTRDY)) {
2170                 /*
2171                  * Buffers are (apparently) empty.  Load
2172                  * the new filter value into MARs now.
2173                  */
2174                 fe_loadmar(sc);
2175         } else {
2176                 /*
2177                  * Buffers are not empty.  Mark that we have to update
2178                  * the MARs.  The new filter will be loaded by feintr()
2179                  * later.
2180                  */
2181         }
2182 }
2183
2184 /*
2185  * Load a new multicast address filter into MARs.
2186  *
2187  * The caller must have splimp'ed before fe_loadmar.
2188  * This function starts the DLC upon return.  So it can be called only
2189  * when the chip is working, i.e., from the driver's point of view, when
2190  * a device is RUNNING.  (I mistook the point in previous versions.)
2191  */
2192 static void
2193 fe_loadmar (struct fe_softc * sc)
2194 {
2195         /* Stop the DLC (transmitter and receiver).  */
2196         DELAY(200);
2197         fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
2198         DELAY(200);
2199
2200         /* Select register bank 1 for MARs.  */
2201         fe_outb(sc, FE_DLCR7, sc->proto_dlcr7 | FE_D7_RBS_MAR | FE_D7_POWER_UP);
2202
2203         /* Copy filter value into the registers.  */
2204         fe_outblk(sc, FE_MAR8, sc->filter.data, FE_FILTER_LEN);
2205
2206         /* Restore the bank selection for BMPRs (i.e., runtime registers).  */
2207         fe_outb(sc, FE_DLCR7,
2208                 sc->proto_dlcr7 | FE_D7_RBS_BMPR | FE_D7_POWER_UP);
2209
2210         /* Restart the DLC.  */
2211         DELAY(200);
2212         fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_ENABLE);
2213         DELAY(200);
2214
2215         /* We have just updated the filter.  */
2216         sc->filter_change = 0;
2217 }
2218
2219 /* Change the media selection.  */
2220 static int
2221 fe_medchange (struct ifnet *ifp)
2222 {
2223         struct fe_softc *sc = (struct fe_softc *)ifp->if_softc;
2224
2225 #ifdef DIAGNOSTIC
2226         /* If_media should not pass any request for a media which this
2227            interface doesn't support.  */
2228         int b;
2229
2230         for (b = 0; bit2media[b] != 0; b++) {
2231                 if (bit2media[b] == sc->media.ifm_media) break;
2232         }
2233         if (((1 << b) & sc->mbitmap) == 0) {
2234                 kprintf("fe%d: got an unsupported media request (0x%x)\n",
2235                        sc->sc_unit, sc->media.ifm_media);
2236                 return EINVAL;
2237         }
2238 #endif
2239
2240         /* We don't actually change media when the interface is down.
2241            fe_init() will do the job, instead.  Should we also wait
2242            until the transmission buffer being empty?  Changing the
2243            media when we are sending a frame will cause two garbages
2244            on wires, one on old media and another on new.  FIXME */
2245         if (sc->sc_if.if_flags & IFF_UP) {
2246                 if (sc->msel) sc->msel(sc);
2247         }
2248
2249         return 0;
2250 }
2251
2252 /* I don't know how I can support media status callback... FIXME.  */
2253 static void
2254 fe_medstat (struct ifnet *ifp __unused, struct ifmediareq *ifmr __unused)
2255 {
2256 }