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