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