2 * All Rights Reserved, Copyright (C) Fujitsu Limited 1995
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.
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
24 * $FreeBSD: src/sys/dev/fe/if_fe.c,v 1.65.2.1 2000/09/22 10:01:47 nyan Exp $
26 * Device driver for Fujitsu MB86960A/MB86965A based Ethernet cards.
27 * Contributed by M. Sekiguchi. <seki@sysrap.cs.fujitsu.co.jp>
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
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.
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.
49 * The following lines are retained from the original if_ed.c:
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.
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.
75 #include <sys/param.h>
76 #include <sys/systm.h>
77 #include <sys/socket.h>
78 #include <sys/sockio.h>
80 #include <sys/interrupt.h>
81 #include <sys/linker_set.h>
82 #include <sys/module.h>
85 #include <sys/thread2.h>
87 #include <net/ethernet.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>
94 #include <netinet/in.h>
95 #include <netinet/if_ether.h>
99 #include <machine_base/isa/ic/mb86960.h>
100 #include "if_fereg.h"
101 #include "if_fevar.h"
104 * Transmit just one packet per a "send" command to 86960.
105 * This option is intended for performance test. An EXPERIMENTAL option.
107 #ifndef FE_SINGLE_TRANSMISSION
108 #define FE_SINGLE_TRANSMISSION 0
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.)
117 #define FE_MAX_LOOP 0x800
121 * If you define this option, 8-bit cards are also supported.
123 /*#define FE_8BIT_SUPPORT*/
126 * Device configuration flags.
129 /* DLCR6 settings. */
130 #define FE_FLAGS_DLCR6_VALUE 0x007F
132 /* Force DLCR6 override. */
133 #define FE_FLAGS_OVERRIDE_DLCR6 0x0080
136 devclass_t fe_devclass;
139 * Special filter values.
141 static struct fe_filter const fe_filter_nothing = { FE_FILTER_NOTHING };
142 static struct fe_filter const fe_filter_all = { FE_FILTER_ALL };
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,
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 *);
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 * );
165 static void fe_emptybuffer ( struct fe_softc * );
168 DECLARE_DUMMY_MODULE(if_fe);
171 * Fe driver specific constants which relate to 86960/86965.
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 )
179 /* Maximum number of iterations for a receive interrupt. */
180 #define FE_MAX_RECV_COUNT ( ( 65536 - 2048 * 2 ) / 64 )
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.
191 * Miscellaneous definitions not directly related to hardware.
194 /* The following line must be delete when "net/if_media.h" support it. */
196 #define IFM_10_FL /* 13 */ IFM_10_5
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... */
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... */
228 * Check for specific bits in specific registers have specific values.
229 * A common utility function called from various sub-probe routines.
232 fe_simple_probe (struct fe_softc const * sc,
233 struct fe_simple_probe_struct const * sp)
235 struct fe_simple_probe_struct const *p;
237 for (p = sp; p->mask != 0; p++) {
238 if ((fe_inb(sc, p->port) & p->mask) != p->bits)
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. */
248 valid_Ether_p (u_char const * addr, unsigned vendor)
251 kprintf("fe?: validating %6D against %06x\n", addr, ":", vendor);
254 /* All zero is not allowed as a vendor code. */
255 if (addr[0] == 0 && addr[1] == 0 && addr[2] == 0) return 0;
259 /* Legal Ethernet address (stored in ROM) must have
260 its Group and Local bits cleared. */
261 if ((addr[0] & 0x03) != 0) return 0;
264 /* Same as above, but a local address is allowed in
266 if ((addr[0] & 0x01) != 0) return 0;
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;
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;
280 /* Given addr looks like an Ethernet address. */
284 /* Fill our softc struct with default value. */
286 fe_softc_defaults (struct fe_softc *sc)
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;
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;
298 /* Assume the probe process (to be done later) is stable. */
301 /* A typical board needs no hooks. */
305 /* Assume the board has no software-controllable media selection. */
307 sc->defmedia = MB_HM;
311 /* Common error reporting routine used in probe routines for
312 "soft configured IRQ"-type boards. */
314 fe_irq_failure (char const *name, int unit, int irq, char const *list)
316 kprintf("fe%d: %s board is detected, but %s IRQ was given\n",
317 unit, name, (irq == NO_IRQ ? "no" : "invalid"));
319 kprintf("fe%d: specify an IRQ from %s in kernel config\n",
325 * Hardware (vendor) specific hooks.
329 * Generic media selection scheme for MB86965 based boards.
332 fe_msel_965 (struct fe_softc *sc)
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;
343 /* Write it into the register. It takes effect immediately. */
344 fe_outb(sc, FE_BMPR13, sc->proto_bmpr13 | b13);
349 * Fujitsu MB86965 JLI mode support routines.
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.
358 fe_strobe_eeprom_jli (struct fe_softc *sc, u_short bmpr16)
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.
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);
373 fe_read_eeprom_jli (struct fe_softc * sc, u_char * data)
376 u_char save16, save17;
378 /* Save the current value of the EEPROM interface registers. */
379 save16 = fe_inb(sc, FE_BMPR16);
380 save17 = fe_inb(sc, FE_BMPR17);
382 /* Read bytes from EEPROM; two bytes per an iteration. */
383 for (n = 0; n < JLI_EEPROM_SIZE / 2; n++) {
385 /* Reset the EEPROM interface. */
386 fe_outb(sc, FE_BMPR16, 0x00);
387 fe_outb(sc, FE_BMPR17, 0x00);
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);
394 /* Pass the iteration count as well as a READ command. */
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);
400 fe_outb(sc, FE_BMPR17, 0x00);
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)
411 /* Read one more byte. */
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)
422 /* Reset the EEPROM interface, again. */
423 fe_outb(sc, FE_BMPR16, 0x00);
424 fe_outb(sc, FE_BMPR17, 0x00);
426 /* Make sure to restore the original value of EEPROM interface
427 registers, since we are not yet sure we have MB86965A on
429 fe_outb(sc, FE_BMPR17, save17);
430 fe_outb(sc, FE_BMPR16, save16);
434 /* Report what we got. */
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, " ");
447 fe_init_jli (struct fe_softc * sc)
449 /* "Reset" by writing into a magic location. */
451 fe_outb(sc, 0x1E, fe_inb(sc, 0x1E));
457 * SSi 78Q8377A support routines.
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.,
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).
471 fe_read_eeprom_ssi (struct fe_softc *sc, u_char *data)
475 u_char save6, save7, save12;
477 /* Save the current value for the DLCR registers we are about
479 save6 = fe_inb(sc, FE_DLCR6);
480 save7 = fe_inb(sc, FE_DLCR7);
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);
488 /* Save the current value for the BMPR12 register, too. */
489 save12 = fe_inb(sc, FE_DLCR12);
491 /* Read bytes from EEPROM; two bytes per an iteration. */
492 for (n = 0; n < SSI_EEPROM_SIZE / 2; n++) {
494 /* Start EEPROM access */
495 fe_outb(sc, FE_DLCR12, SSI_EEP);
496 fe_outb(sc, FE_DLCR12, SSI_EEP | SSI_CSL);
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 */
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);
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)
527 /* Read one more byte. */
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)
537 fe_outb(sc, FE_DLCR12, SSI_EEP);
540 /* Reset the EEPROM interface. (For now.) */
541 fe_outb(sc, FE_DLCR12, 0x00);
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);
550 /* Report what we got. */
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, " ");
563 * TDK/LANX boards support routines.
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))
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)
579 fe_eeprom_cycle_lnx (struct fe_softc *sc, u_short reg20, u_long cycle)
581 fe_outb(sc, reg20, (cycle ) & 0xFF);
583 fe_outb(sc, reg20, (cycle >> 8) & 0xFF);
585 fe_outb(sc, reg20, (cycle >> 16) & 0xFF);
587 fe_outb(sc, reg20, (cycle >> 24) & 0xFF);
592 fe_eeprom_receive_lnx (struct fe_softc *sc, u_short reg20)
596 fe_outb(sc, reg20, LNX_CLK_HI | LNX_SDA_FL);
598 dat = fe_inb(sc, reg20);
599 fe_outb(sc, reg20, LNX_CLK_LO | LNX_SDA_FL);
601 return (dat & LNX_SDA_IN);
605 fe_read_eeprom_lnx (struct fe_softc *sc, u_char *data)
610 u_short reg20 = 0x14;
612 save20 = fe_inb(sc, reg20);
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
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);
637 /* Issue a start condition. */
638 fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_START);
640 /* Send seven bits of the starting address (zero, in this
641 case) and a command bit for READ. */
643 for (bit = 0x80; bit != 0x00; bit >>= 1) {
645 fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_HI);
647 fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_LO);
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
657 kprintf("fe%d: no ACK received from EEPROM(LNX)\n",
660 /* Clear the given buffer to indicate we could not get
661 any info. and return. */
662 bzero(data, LNX_EEPROM_SIZE);
666 /* Read bytes from EEPROM. */
667 for (n = 0; n < LNX_EEPROM_SIZE; n++) {
669 /* Read a byte and store it into the buffer. */
671 for (bit = 0x80; bit != 0x00; bit >>= 1) {
672 if (fe_eeprom_receive_lnx(sc, reg20))
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);
683 /* Issue a STOP condition, de-activating the clock line.
684 It will be safer to keep the clock line low than to leave
686 fe_eeprom_cycle_lnx(sc, reg20, LNX_CYCLE_STOP);
689 fe_outb(sc, reg20, save20);
692 /* Report what we got. */
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, " ");
704 fe_init_lnx (struct fe_softc * sc)
706 /* Reset the 86960. Do we need this? FIXME. */
707 fe_outb(sc, 0x12, 0x06);
709 fe_outb(sc, 0x12, 0x07);
712 /* Setup IRQ control register on the ASIC. */
713 fe_outb(sc, 0x14, sc->priv_info);
718 * Ungermann-Bass boards support routine.
721 fe_init_ubn (struct fe_softc * sc)
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);
729 /* Setup IRQ control register on the ASIC. */
730 fe_outb(sc, 0x14, sc->priv_info);
735 * Install interface into kernel networking data structures
738 fe_attach (device_t dev)
740 struct fe_softc *sc = device_get_softc(dev);
741 int flags = device_get_flags(dev);
745 * Initialize ifnet structure
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);
756 #if 0 /* I'm not sure... */
757 sc->mibdata.dot3Compliance = DOT3COMPLIANCE_COLLS;
761 * Set fixed interface flags.
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);
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;
773 /* Modify hardware config if it is requested. */
774 if (flags & FE_FLAGS_OVERRIDE_DLCR6)
775 sc->proto_dlcr6 = flags & FE_FLAGS_DLCR6_VALUE;
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;
783 /* Oops, we can't work with single buffer configuration. */
785 kprintf("fe%d: strange TXBSIZ config; fixing\n",
788 sc->proto_dlcr6 &= ~FE_D6_TXBSIZ;
789 sc->proto_dlcr6 |= FE_D6_TXBSIZ_2x2KB;
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);
801 for (b = 0; bit2media[b] != 0; b++) {
802 if (sc->defmedia & (1 << b)) {
803 ifmedia_set(&sc->media, bit2media[b]);
807 #if 0 /* Turned off; this is called later, when the interface UPs. */
811 /* Attach and stop the interface. */
812 ether_ifattach(&sc->sc_if, sc->sc_enaddr, NULL);
815 error = bus_setup_intr(dev, sc->irq_res, INTR_MPSAFE,
816 fe_intr, sc, &sc->irq_handle,
817 sc->sc_if.if_serializer);
819 if_detach(&sc->sc_if);
820 fe_release_resource(dev);
824 ifq_set_cpuid(&sc->sc_if.if_snd, rman_get_cpuid(sc->irq_res));
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" : "");
830 int buf, txb, bbw, sbw, ram;
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;
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;
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;
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;
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;
856 device_printf(dev, "SRAM %dKB %dbit %dns, TXB %dKBx2, %dbit I/O\n",
857 buf, bbw, ram, txb, sbw);
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");
870 fe_alloc_port(device_t dev, int size)
872 struct fe_softc *sc = device_get_softc(dev);
873 struct resource *res;
877 res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
878 0ul, ~0ul, size, RF_ACTIVE);
880 sc->port_used = size;
882 sc->iot = rman_get_bustag(res);
883 sc->ioh = rman_get_bushandle(res);
891 fe_alloc_irq(device_t dev, int flags)
893 struct fe_softc *sc = device_get_softc(dev);
894 struct resource *res;
898 res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | flags);
908 fe_release_resource(device_t dev)
910 struct fe_softc *sc = device_get_softc(dev);
913 bus_release_resource(dev, SYS_RES_IOPORT, 0, sc->port_res);
917 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res);
923 * Reset interface, after some (hardware) trouble is deteced.
926 fe_reset (struct fe_softc *sc)
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++;
932 /* Put the interface into known initial state. */
934 if (sc->sc_if.if_flags & IFF_UP)
939 * Stop everything on the interface.
941 * All buffered packets, both transmitting and receiving,
942 * if any, will be lost by stopping the interface.
945 fe_stop (struct fe_softc *sc)
947 /* Disable interrupts. */
948 fe_outb(sc, FE_DLCR2, 0x00);
949 fe_outb(sc, FE_DLCR3, 0x00);
951 /* Stop interface hardware. */
953 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
956 /* Clear all interrupt status. */
957 fe_outb(sc, FE_DLCR0, 0xFF);
958 fe_outb(sc, FE_DLCR1, 0xFF);
960 /* Put the chip in stand-by mode. */
962 fe_outb(sc, FE_DLCR7, sc->proto_dlcr7 | FE_D7_POWER_DOWN);
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;
973 /* MAR loading can be delayed. */
974 sc->filter_change = 0;
976 /* Call a device-specific hook. */
982 * Device timeout/watchdog routine. Entered if the device neglects to
983 * generate an interrupt after a transmit has been started on it.
986 fe_watchdog ( struct ifnet *ifp )
988 struct fe_softc *sc = (struct fe_softc *)ifp;
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);
1000 * Initialize device.
1003 fe_init (void * xsc)
1005 struct fe_softc *sc = xsc;
1007 /* Start initializing 86960. */
1008 /* Call a hook before we start initializing the chip. */
1013 * Make sure to disable the chip, also.
1014 * This may also help re-programming the chip after
1015 * hot insertion of PCMCIAs.
1018 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
1021 /* Power up the chip and select register bank for DLCRs. */
1023 fe_outb(sc, FE_DLCR7,
1024 sc->proto_dlcr7 | FE_D7_RBS_DLCR | FE_D7_POWER_UP);
1027 /* Feed the station address. */
1028 fe_outblk(sc, FE_DLCR8, sc->sc_enaddr, ETHER_ADDR_LEN);
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);
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);
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);
1053 /* Enable interrupts. */
1054 fe_outb(sc, FE_DLCR2, FE_TMASK);
1055 fe_outb(sc, FE_DLCR3, FE_RMASK);
1057 /* Select requested media, just before enabling DLC. */
1061 /* Enable transmitter and receiver. */
1063 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_ENABLE);
1068 * Make sure to empty the receive buffer.
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.
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.
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.
1084 if (!(fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)) {
1085 kprintf("fe%d: receive buffer has some data after reset\n",
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. */
1095 /* Set 'running' flag, because we are now running. */
1096 sc->sc_if.if_flags |= IFF_RUNNING;
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.
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
1113 if_devstart(&sc->sc_if);
1118 * This routine actually starts the transmission on the interface
1121 fe_xmit (struct fe_softc *sc)
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.
1128 sc->sc_if.if_timer = 1 + sc->txb_count;
1130 /* Update txb variables. */
1131 sc->txb_sched = sc->txb_count;
1133 sc->txb_free = sc->txb_size;
1136 /* Start transmitter, passing packets in TX buffer. */
1137 fe_outb(sc, FE_BMPR10, sc->txb_sched | FE_B10_START);
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
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)
1150 fe_start (struct ifnet *ifp, struct ifaltq_subque *ifsq)
1152 struct fe_softc *sc = ifp->if_softc;
1155 ASSERT_ALTQ_SQ_DEFAULT(ifp, ifsq);
1158 /* Just a sanity check. */
1159 if ((sc->txb_count == 0) != (sc->txb_free == sc->txb_size)) {
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.)
1168 kprintf("fe%d: inconsistent txb variables (%d, %d)\n",
1169 sc->sc_unit, sc->txb_count, sc->txb_free);
1171 * So, what should I do, then?
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.)
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.
1190 * First, see if there are buffered packets and an idle
1191 * transmitter - should never happen at this point.
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);
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
1206 if (sc->filter_change) {
1208 * Filter change request is delayed only when the DLC is
1209 * working. DLC soon raise an interrupt after finishing
1212 goto indicate_active;
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.
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...
1232 < ETHER_MAX_LEN - ETHER_CRC_LEN + FE_DATA_LEN_LEN) {
1234 goto indicate_active;
1237 #if FE_SINGLE_TRANSMISSION
1238 if (sc->txb_count > 0) {
1239 /* Just one packet per a transmission buffer. */
1240 goto indicate_active;
1245 * Get the next mbuf chain for a packet to send.
1247 m = ifq_dequeue(&sc->sc_if.if_snd, NULL);
1249 /* No more packets to send. */
1250 goto indicate_inactive;
1254 * Copy the mbuf chain into the transmission buffer.
1255 * txb_* variables are updated as necessary.
1257 fe_write_mbufs(sc, m);
1259 /* Start transmitter if it's idle. */
1260 if ((sc->txb_count > 0) && (sc->txb_sched == 0))
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"
1270 if ((sc->sc_if.if_flags & IFF_PROMISC) == 0)
1271 BPF_MTAP(&sc->sc_if, m);
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.
1286 ifq_clr_oactive(&sc->sc_if.if_snd);
1291 * The transmitter is active, and there are no room for
1292 * more outgoing packets in the transmission buffer.
1294 ifq_set_oactive(&sc->sc_if.if_snd);
1299 * Drop (skip) a packet from receive buffer in 86960 memory.
1302 fe_droppacket (struct fe_softc * sc, int len)
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.
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)
1317 fe_inb(sc, FE_BMPR8);
1318 fe_inb(sc, FE_BMPR8);
1319 fe_inb(sc, FE_BMPR8);
1320 fe_inb(sc, FE_BMPR8);
1325 fe_inw(sc, FE_BMPR8);
1326 fe_inw(sc, FE_BMPR8);
1328 fe_outb(sc, FE_BMPR14, FE_B14_SKIP);
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)
1334 for (i = 0; i < len; i++)
1335 fe_inb(sc, FE_BMPR8);
1340 for (i = 0; i < len; i += 2)
1341 fe_inw(sc, FE_BMPR8);
1348 * Empty receiving buffer.
1351 fe_emptybuffer (struct fe_softc * sc)
1357 kprintf("fe%d: emptying receive buffer\n", sc->sc_unit);
1361 * Stop receiving packets, temporarily.
1363 saved_dlcr5 = fe_inb(sc, FE_DLCR5);
1364 fe_outb(sc, FE_DLCR5, sc->proto_dlcr5);
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.
1372 #ifdef FE_8BIT_SUPPORT
1373 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1375 for (i = 0; i < 65536; i++) {
1376 if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)
1378 fe_inb(sc, FE_BMPR8);
1384 for (i = 0; i < 65536; i += 2) {
1385 if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)
1387 fe_inw(sc, FE_BMPR8);
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. */
1400 * Restart receiving packets.
1402 fe_outb(sc, FE_DLCR5, saved_dlcr5);
1407 * Transmission interrupt handler
1408 * The control flow of this function looks silly. FIXME.
1411 fe_tint (struct fe_softc * sc, u_char tstat)
1417 * Handle "excessive collision" interrupt.
1419 if (tstat & FE_D0_COLL16) {
1422 * Find how many packets (including this collided one)
1423 * are left unsent in transmission buffer.
1425 left = fe_inb(sc, FE_BMPR10);
1426 kprintf("fe%d: excessive collision (%d/%d)\n",
1427 sc->sc_unit, left, sc->txb_sched);
1430 * Clear the collision flag (in 86960) here
1431 * to avoid confusing statistics.
1433 fe_outb(sc, FE_DLCR0, FE_D0_COLLID);
1436 * Restart transmitter, skipping the
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.
1448 fe_outb(sc, FE_BMPR11, FE_B11_CTRL_SKIP | FE_B11_MODE1);
1450 /* Update statistics. */
1455 * Handle "transmission complete" interrupt.
1457 if (tstat & FE_D0_TXDONE) {
1460 * Add in total number of collisions on last
1461 * transmission. We also clear "collision occurred" flag
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.
1473 * I considered not to mind it seriously. Collision
1474 * count is not so important, anyway. Any comments? FIXME.
1477 if (fe_inb(sc, FE_DLCR0) & FE_D0_COLLID) {
1479 /* Clear collision flag. */
1480 fe_outb(sc, FE_DLCR0, FE_D0_COLLID);
1482 /* Extract collision count from 86960. */
1483 col = fe_inb(sc, FE_DLCR4);
1484 col = (col & FE_D4_COL) >> FE_D4_COL_SHIFT;
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.
1493 * Since the accurate number of collisions
1494 * has been lost, we just guess it as 1;
1495 * Am I too optimistic? FIXME.
1499 sc->sc_if.if_collisions += col;
1501 sc->mibdata.dot3StatsSingleCollisionFrames++;
1503 sc->mibdata.dot3StatsMultipleCollisionFrames++;
1504 sc->mibdata.dot3StatsCollFrequencies[col-1]++;
1508 * Update transmission statistics.
1509 * Be sure to reflect number of excessive collisions.
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;
1520 * The transmitter is no more active.
1521 * Reset output active flag and watchdog timer.
1523 ifq_clr_oactive(&sc->sc_if.if_snd);
1524 sc->sc_if.if_timer = 0;
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.
1532 if (sc->txb_count > 0)
1538 * Ethernet interface receiver interrupt.
1541 fe_rint (struct fe_softc * sc, u_char rstat)
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.
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++;
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
1568 if (rstat & FE_D1_SRTPKT)
1569 sc->mibdata.dot3StatsFrameTooShorts++; /* :-) */
1571 sc->sc_if.if_ierrors++;
1575 * MB86960 has a flag indicating "receive queue empty."
1576 * We just loop, checking the flag, to pull out all received
1579 * We limit the number of iterations to avoid infinite-loop.
1580 * The upper bound is set to unrealistic high value.
1582 for (i = 0; i < FE_MAX_RECV_COUNT * 2; i++) {
1584 /* Stop the iteration if 86960 indicates no packets. */
1585 if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)
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.
1594 #ifdef FE_8BIT_SUPPORT
1595 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1597 status = fe_inb(sc, FE_BMPR8);
1598 fe_inb(sc, FE_BMPR8);
1603 status = (u_char) fe_inw(sc, FE_BMPR8);
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.
1611 #ifdef FE_8BIT_SUPPORT
1612 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1614 len = fe_inb(sc, FE_BMPR8);
1615 len |= (fe_inb(sc, FE_BMPR8) << 8);
1620 len = fe_inw(sc, FE_BMPR8);
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
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++;
1643 if (fe_get_packet(sc, len) < 0) {
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
1651 sc->sc_if.if_ierrors++;
1652 sc->mibdata.dot3StatsMissedFrames++;
1653 fe_droppacket(sc, len);
1657 /* Successfully received a packet. Update stat. */
1658 sc->sc_if.if_ipackets++;
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++;
1669 * Ethernet interface interrupt processor
1674 struct fe_softc *sc = arg;
1675 u_char tstat, rstat;
1676 int loop_count = FE_MAX_LOOP;
1678 /* Loop until there are no more new interrupt conditions. */
1679 while (loop_count-- > 0) {
1681 * Get interrupt conditions, masking unneeded flags.
1683 tstat = fe_inb(sc, FE_DLCR0) & FE_TMASK;
1684 rstat = fe_inb(sc, FE_DLCR1) & FE_RMASK;
1685 if (tstat == 0 && rstat == 0)
1689 * Reset the conditions we are acknowledging.
1691 fe_outb(sc, FE_DLCR0, tstat);
1692 fe_outb(sc, FE_DLCR1, rstat);
1695 * Handle transmitter interrupts.
1701 * Handle receiver interrupts
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
1714 if (sc->filter_change &&
1715 sc->txb_count == 0 && sc->txb_sched == 0) {
1717 ifq_clr_oactive(&sc->sc_if.if_snd);
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.
1726 * BTW, I'm not sure in what case the OACTIVE is on at
1727 * this point. Is the following test redundant?
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.
1733 if (!ifq_is_oactive(&sc->sc_if.if_snd))
1734 if_devstart(&sc->sc_if);
1737 kprintf("fe%d: too many loops\n", sc->sc_unit);
1741 * Process an ioctl request. This code needs some work - it looks
1745 fe_ioctl (struct ifnet * ifp, u_long command, caddr_t data, struct ucred *cr)
1747 struct fe_softc *sc = ifp->if_softc;
1748 struct ifreq *ifr = (struct ifreq *)data;
1754 * Switch interface state between "running" and
1755 * "stopped", reflecting the UP flag.
1757 if (sc->sc_if.if_flags & IFF_UP) {
1758 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
1761 if ((sc->sc_if.if_flags & IFF_RUNNING) != 0)
1766 * Promiscuous and/or multicast flags may have changed,
1767 * so reprogram the multicast filter and/or receive mode.
1777 * Multicast list has changed; set the hardware filter
1785 /* Let if_media to handle these commands and to call
1787 error = ifmedia_ioctl(ifp, ifr, &sc->media, command);
1791 error = ether_ioctl(ifp, command, data);
1798 * Retrieve packet from receive buffer and send to the next level up via
1800 * Returns 0 if success, -1 if error (i.e., mbuf allocation failure).
1803 fe_get_packet (struct fe_softc * sc, u_short len)
1805 struct ether_header *eh;
1809 * NFS wants the data be aligned to the word (4 byte)
1810 * boundary. Ethernet header has 14 bytes. There is a
1813 #define NFS_MAGIC_OFFSET 2
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.
1824 #if ( MCLBYTES < ETHER_MAX_LEN - ETHER_CRC_LEN + NFS_MAGIC_OFFSET )
1825 #error "Too small MCLBYTES to use fe driver."
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.
1839 /* Allocate an mbuf with packet header info. */
1840 MGETHDR(m, MB_DONTWAIT, MT_DATA);
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)) {
1853 /* Initialize packet header info. */
1854 m->m_pkthdr.rcvif = &sc->sc_if;
1855 m->m_pkthdr.len = len;
1857 /* Set the length of this packet. */
1860 /* The following silliness is to make NFS happy */
1861 m->m_data += NFS_MAGIC_OFFSET;
1863 /* Get (actually just point to) the header part. */
1864 eh = mtod(m, struct ether_header *);
1867 #ifdef FE_8BIT_SUPPORT
1868 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1870 fe_insb(sc, FE_BMPR8, (u_int8_t *)eh, len);
1875 fe_insw(sc, FE_BMPR8, (u_int16_t *)eh, (len + 1) >> 1);
1878 /* Feed the packet to upper layer. */
1879 sc->sc_if.if_input(&sc->sc_if, m);
1884 * Write an mbuf chain to the transmission buffer memory using 16 bit PIO.
1885 * Returns number of bytes actually written, including length word.
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.
1893 fe_write_mbufs (struct fe_softc *sc, struct mbuf *m)
1895 u_short length, len;
1898 u_short savebyte; /* WARNING: Architecture dependent! */
1899 #define NO_PENDING_BYTE 0xFFFF
1901 static u_char padding [ETHER_MIN_LEN - ETHER_CRC_LEN - ETHER_HDR_LEN];
1904 /* First, count up the total number of bytes to copy */
1906 for (mp = m; mp != NULL; mp = mp->m_next)
1907 length += mp->m_len;
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);
1915 /* Just use the length value in the packet header. */
1916 length = m->m_pkthdr.len;
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.
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++;
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.
1943 #ifdef FE_8BIT_SUPPORT
1944 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
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);
1953 fe_outw(sc, FE_BMPR8,
1954 max(length, ETHER_MIN_LEN - ETHER_CRC_LEN));
1958 * Update buffer status now.
1959 * Truncate the length up to an even number, since we use outw().
1961 #ifdef FE_8BIT_SUPPORT
1962 if ((sc->proto_dlcr6 & FE_D6_SBW) != FE_D6_SBW_BYTE)
1965 length = (length + 1) & ~1;
1967 sc->txb_free -= FE_DATA_LEN_LEN +
1968 max(length, ETHER_MIN_LEN - ETHER_CRC_LEN);
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.
1977 #ifdef FE_8BIT_SUPPORT
1978 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1980 /* 8-bit cards are easy. */
1981 for (mp = m; mp != NULL; mp = mp->m_next) {
1983 fe_outsb(sc, FE_BMPR8, mtod(mp, caddr_t),
1990 /* 16-bit cards are a pain. */
1991 savebyte = NO_PENDING_BYTE;
1992 for (mp = m; mp != NULL; mp = mp->m_next) {
1994 /* Ignore empty mbuf. */
1999 /* Find the actual data to send. */
2000 data = mtod(mp, caddr_t);
2002 /* Finish the last byte. */
2003 if (savebyte != NO_PENDING_BYTE) {
2004 fe_outw(sc, FE_BMPR8, savebyte | (*data << 8));
2007 savebyte = NO_PENDING_BYTE;
2010 /* output contiguous words */
2012 fe_outsw(sc, FE_BMPR8, (u_int16_t *)data,
2018 /* Save a remaining byte, if there is one. */
2023 /* Spit the last byte, if the length is odd. */
2024 if (savebyte != NO_PENDING_BYTE)
2025 fe_outw(sc, FE_BMPR8, savebyte);
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)
2033 fe_outsb(sc, FE_BMPR8, padding,
2034 ETHER_MIN_LEN - ETHER_CRC_LEN - length);
2039 fe_outsw(sc, FE_BMPR8, (u_int16_t *)padding,
2040 (ETHER_MIN_LEN - ETHER_CRC_LEN - length) >> 1);
2046 * Compute hash value for an Ethernet address
2049 fe_hash ( u_char * ep )
2051 #define FE_HASH_MAGIC_NUMBER 0xEDB88320L
2053 u_long hash = 0xFFFFFFFFL;
2058 for ( i = ETHER_ADDR_LEN; --i >= 0; ) {
2060 for ( j = 8; --j >= 0; ) {
2063 if ( ( m ^ b ) & 1 ) hash ^= FE_HASH_MAGIC_NUMBER;
2067 return ( ( int )( hash >> 26 ) );
2071 * Compute the multicast address filter from the
2072 * list of multicast addresses we need to listen to.
2074 static struct fe_filter
2075 fe_mcaf ( struct fe_softc *sc )
2078 struct fe_filter filter;
2079 struct ifmultiaddr *ifma;
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)
2085 index = fe_hash(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
2087 kprintf("fe%d: hash(%6D) == %d\n",
2088 sc->sc_unit, enm->enm_addrlo , ":", index);
2091 filter.data[index >> 3] |= 1 << (index & 7);
2097 * Calculate a new "multicast packet filter" and put the 86960
2098 * receiver in appropriate mode.
2101 fe_setmode (struct fe_softc *sc)
2103 int flags = sc->sc_if.if_flags;
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...)
2112 * To complete the trick, fe_init() calls fe_setmode() after
2113 * restarting the interface.
2115 if (!(flags & IFF_RUNNING))
2119 * Promiscuous mode is handled separately.
2121 if (flags & IFF_PROMISC) {
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.
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.)
2133 fe_outb(sc, FE_DLCR5,
2134 sc->proto_dlcr5 | FE_D5_AFM0 | FE_D5_AFM1);
2135 sc->filter_change = 0;
2140 * Turn the chip to the normal (non-promiscuous) mode.
2142 fe_outb(sc, FE_DLCR5, sc->proto_dlcr5 | FE_D5_AFM1);
2145 * Find the new multicast filter value.
2147 if (flags & IFF_ALLMULTI)
2148 sc->filter = fe_filter_all;
2150 sc->filter = fe_mcaf(sc);
2151 sc->filter_change = 1;
2154 * We have to update the multicast filter in the 86960, A.S.A.P.
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.
2161 * To reduce the packet loss, we delay the filter update
2162 * process until buffers are empty.
2164 if (sc->txb_sched == 0 && sc->txb_count == 0 &&
2165 !(fe_inb(sc, FE_DLCR1) & FE_D1_PKTRDY)) {
2167 * Buffers are (apparently) empty. Load
2168 * the new filter value into MARs now.
2173 * Buffers are not empty. Mark that we have to update
2174 * the MARs. The new filter will be loaded by feintr()
2181 * Load a new multicast address filter into MARs.
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.)
2189 fe_loadmar (struct fe_softc * sc)
2191 /* Stop the DLC (transmitter and receiver). */
2193 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
2196 /* Select register bank 1 for MARs. */
2197 fe_outb(sc, FE_DLCR7, sc->proto_dlcr7 | FE_D7_RBS_MAR | FE_D7_POWER_UP);
2199 /* Copy filter value into the registers. */
2200 fe_outblk(sc, FE_MAR8, sc->filter.data, FE_FILTER_LEN);
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);
2206 /* Restart the DLC. */
2208 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_ENABLE);
2211 /* We have just updated the filter. */
2212 sc->filter_change = 0;
2215 /* Change the media selection. */
2217 fe_medchange (struct ifnet *ifp)
2219 struct fe_softc *sc = (struct fe_softc *)ifp->if_softc;
2222 /* If_media should not pass any request for a media which this
2223 interface doesn't support. */
2226 for (b = 0; bit2media[b] != 0; b++) {
2227 if (bit2media[b] == sc->media.ifm_media) break;
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);
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);
2248 /* I don't know how I can support media status callback... FIXME. */
2250 fe_medstat (struct ifnet *ifp __unused, struct ifmediareq *ifmr __unused)