Use queue(3) macros for if_multiaddrs.
[dragonfly.git] / sys / dev / netif / fe / if_fe.c
CommitLineData
984263bc
MD
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 $
03df8a20 25 * $DragonFly: src/sys/dev/netif/fe/if_fe.c,v 1.19 2005/06/20 15:10:40 joerg Exp $
984263bc
MD
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>
e38b98c0 81#include <sys/interrupt.h>
32832096
MD
82#include <sys/linker_set.h>
83#include <sys/module.h>
012eaeb1 84#include <sys/thread2.h>
984263bc
MD
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>
eb643486 93#include <net/ifq_var.h>
984263bc
MD
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>
1f2de5d4
MD
104#include "if_fereg.h"
105#include "if_fevar.h"
984263bc
MD
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
140devclass_t fe_devclass;
141
142/*
143 * Special filter values.
144 */
145static struct fe_filter const fe_filter_nothing = { FE_FILTER_NOTHING };
146static struct fe_filter const fe_filter_all = { FE_FILTER_ALL };
147
148/* Standard driver entry points. These can be static. */
149static void fe_init (void *);
150static inthand2_t fe_intr;
bd4539cc
JH
151static int fe_ioctl (struct ifnet *, u_long, caddr_t,
152 struct ucred *);
984263bc
MD
153static void fe_start (struct ifnet *);
154static void fe_watchdog (struct ifnet *);
155static int fe_medchange (struct ifnet *);
156static void fe_medstat (struct ifnet *, struct ifmediareq *);
157
158/* Local functions. Order of declaration is confused. FIXME. */
159static int fe_get_packet ( struct fe_softc *, u_short );
160static void fe_tint ( struct fe_softc *, u_char );
161static void fe_rint ( struct fe_softc *, u_char );
162static void fe_xmit ( struct fe_softc * );
163static void fe_write_mbufs ( struct fe_softc *, struct mbuf * );
164static void fe_setmode ( struct fe_softc * );
165static void fe_loadmar ( struct fe_softc * );
166
167#ifdef DIAGNOSTIC
168static void fe_emptybuffer ( struct fe_softc * );
169#endif
170
32832096
MD
171DECLARE_DUMMY_MODULE(if_fe);
172
984263bc
MD
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. */
204static 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. */
217static 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 */
234int
235fe_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. */
250int
251valid_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. */
288void
289fe_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. */
316void
317fe_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 */
334void
335fe_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 */
360static void
361fe_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
375void
376fe_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
449void
450fe_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
473void
474fe_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
581static void
582fe_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
594static u_char
595fe_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
607void
608fe_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
706void
707fe_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 */
723void
724fe_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 */
740int
741fe_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,
e9cb6d99 748 fe_intr, sc, &sc->irq_handle, NULL);
984263bc
MD
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;
cdb7d804 758 if_initname(&(sc->sc_if), "fe", sc->sc_unit);
984263bc
MD
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;
eb643486
JS
774 ifq_set_maxlen(&sc->sc_if.if_snd, IFQ_MAXLEN);
775 ifq_set_ready(&sc->sc_if.if_snd);
984263bc
MD
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. */
0a8b5977 822 ether_ifattach(&sc->sc_if, sc->sc_enaddr);
984263bc
MD
823 fe_stop(sc);
824
825 /* Print additional info when attached. */
267caeeb 826 device_printf(dev, "type %s%s\n", sc->typestr,
984263bc
MD
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
868int
869fe_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
889int
890fe_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;
4e6d744d 897 res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | flags);
984263bc
MD
898 if (res) {
899 sc->irq_res = res;
900 return (0);
901 }
902
903 return (ENOENT);
904}
905
906void
907fe_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 */
924static void
925fe_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 */
943void
944fe_stop (struct fe_softc *sc)
945{
012eaeb1 946 crit_enter();
984263bc
MD
947
948 /* Disable interrupts. */
949 fe_outb(sc, FE_DLCR2, 0x00);
950 fe_outb(sc, FE_DLCR3, 0x00);
951
952 /* Stop interface hardware. */
953 DELAY(200);
954 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
955 DELAY(200);
956
957 /* Clear all interrupt status. */
958 fe_outb(sc, FE_DLCR0, 0xFF);
959 fe_outb(sc, FE_DLCR1, 0xFF);
960
961 /* Put the chip in stand-by mode. */
962 DELAY(200);
963 fe_outb(sc, FE_DLCR7, sc->proto_dlcr7 | FE_D7_POWER_DOWN);
964 DELAY(200);
965
966 /* Reset transmitter variables and interface flags. */
967 sc->sc_if.if_flags &= ~(IFF_OACTIVE | IFF_RUNNING);
968 sc->sc_if.if_timer = 0;
969 sc->txb_free = sc->txb_size;
970 sc->txb_count = 0;
971 sc->txb_sched = 0;
972
973 /* MAR loading can be delayed. */
974 sc->filter_change = 0;
975
976 /* Call a device-specific hook. */
977 if (sc->stop)
978 sc->stop(sc);
979
012eaeb1 980 crit_exit();
984263bc
MD
981}
982
983/*
984 * Device timeout/watchdog routine. Entered if the device neglects to
985 * generate an interrupt after a transmit has been started on it.
986 */
987static void
988fe_watchdog ( struct ifnet *ifp )
989{
990 struct fe_softc *sc = (struct fe_softc *)ifp;
991
992 /* A "debug" message. */
cdb7d804
MD
993 printf("%s: transmission timeout (%d+%d)%s\n",
994 ifp->if_xname, sc->txb_sched, sc->txb_count,
984263bc
MD
995 (ifp->if_flags & IFF_UP) ? "" : " when down");
996 if (sc->sc_if.if_opackets == 0 && sc->sc_if.if_ipackets == 0)
cdb7d804 997 printf("%s: wrong IRQ setting in config?\n", ifp->if_xname);
984263bc
MD
998 fe_reset(sc);
999}
1000
1001/*
1002 * Initialize device.
1003 */
1004static void
1005fe_init (void * xsc)
1006{
1007 struct fe_softc *sc = xsc;
984263bc 1008
984263bc 1009 /* Start initializing 86960. */
012eaeb1 1010 crit_enter();
984263bc
MD
1011
1012 /* Call a hook before we start initializing the chip. */
1013 if (sc->init)
1014 sc->init(sc);
1015
1016 /*
1017 * Make sure to disable the chip, also.
1018 * This may also help re-programming the chip after
1019 * hot insertion of PCMCIAs.
1020 */
1021 DELAY(200);
1022 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
1023 DELAY(200);
1024
1025 /* Power up the chip and select register bank for DLCRs. */
1026 DELAY(200);
1027 fe_outb(sc, FE_DLCR7,
1028 sc->proto_dlcr7 | FE_D7_RBS_DLCR | FE_D7_POWER_UP);
1029 DELAY(200);
1030
1031 /* Feed the station address. */
1032 fe_outblk(sc, FE_DLCR8, sc->sc_enaddr, ETHER_ADDR_LEN);
1033
1034 /* Clear multicast address filter to receive nothing. */
1035 fe_outb(sc, FE_DLCR7,
1036 sc->proto_dlcr7 | FE_D7_RBS_MAR | FE_D7_POWER_UP);
1037 fe_outblk(sc, FE_MAR8, fe_filter_nothing.data, FE_FILTER_LEN);
1038
1039 /* Select the BMPR bank for runtime register access. */
1040 fe_outb(sc, FE_DLCR7,
1041 sc->proto_dlcr7 | FE_D7_RBS_BMPR | FE_D7_POWER_UP);
1042
1043 /* Initialize registers. */
1044 fe_outb(sc, FE_DLCR0, 0xFF); /* Clear all bits. */
1045 fe_outb(sc, FE_DLCR1, 0xFF); /* ditto. */
1046 fe_outb(sc, FE_DLCR2, 0x00);
1047 fe_outb(sc, FE_DLCR3, 0x00);
1048 fe_outb(sc, FE_DLCR4, sc->proto_dlcr4);
1049 fe_outb(sc, FE_DLCR5, sc->proto_dlcr5);
1050 fe_outb(sc, FE_BMPR10, 0x00);
1051 fe_outb(sc, FE_BMPR11, FE_B11_CTRL_SKIP | FE_B11_MODE1);
1052 fe_outb(sc, FE_BMPR12, 0x00);
1053 fe_outb(sc, FE_BMPR13, sc->proto_bmpr13);
1054 fe_outb(sc, FE_BMPR14, 0x00);
1055 fe_outb(sc, FE_BMPR15, 0x00);
1056
1057 /* Enable interrupts. */
1058 fe_outb(sc, FE_DLCR2, FE_TMASK);
1059 fe_outb(sc, FE_DLCR3, FE_RMASK);
1060
1061 /* Select requested media, just before enabling DLC. */
1062 if (sc->msel)
1063 sc->msel(sc);
1064
1065 /* Enable transmitter and receiver. */
1066 DELAY(200);
1067 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_ENABLE);
1068 DELAY(200);
1069
1070#ifdef DIAGNOSTIC
1071 /*
1072 * Make sure to empty the receive buffer.
1073 *
1074 * This may be redundant, but *if* the receive buffer were full
1075 * at this point, then the driver would hang. I have experienced
1076 * some strange hang-up just after UP. I hope the following
1077 * code solve the problem.
1078 *
1079 * I have changed the order of hardware initialization.
1080 * I think the receive buffer cannot have any packets at this
1081 * point in this version. The following code *must* be
1082 * redundant now. FIXME.
1083 *
1084 * I've heard a rumore that on some PC card implementation of
1085 * 8696x, the receive buffer can have some data at this point.
1086 * The following message helps discovering the fact. FIXME.
1087 */
1088 if (!(fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)) {
1089 printf("fe%d: receive buffer has some data after reset\n",
1090 sc->sc_unit);
1091 fe_emptybuffer(sc);
1092 }
1093
1094 /* Do we need this here? Actually, no. I must be paranoia. */
1095 fe_outb(sc, FE_DLCR0, 0xFF); /* Clear all bits. */
1096 fe_outb(sc, FE_DLCR1, 0xFF); /* ditto. */
1097#endif
1098
1099 /* Set 'running' flag, because we are now running. */
1100 sc->sc_if.if_flags |= IFF_RUNNING;
1101
1102 /*
1103 * At this point, the interface is running properly,
1104 * except that it receives *no* packets. we then call
1105 * fe_setmode() to tell the chip what packets to be
1106 * received, based on the if_flags and multicast group
1107 * list. It completes the initialization process.
1108 */
1109 fe_setmode(sc);
1110
1111#if 0
1112 /* ...and attempt to start output queued packets. */
1113 /* TURNED OFF, because the semi-auto media prober wants to UP
1114 the interface keeping it idle. The upper layer will soon
1115 start the interface anyway, and there are no significant
1116 delay. */
1117 fe_start(&sc->sc_if);
1118#endif
1119
012eaeb1 1120 crit_exit();
984263bc
MD
1121}
1122
1123/*
1124 * This routine actually starts the transmission on the interface
1125 */
1126static void
1127fe_xmit (struct fe_softc *sc)
1128{
1129 /*
1130 * Set a timer just in case we never hear from the board again.
1131 * We use longer timeout for multiple packet transmission.
1132 * I'm not sure this timer value is appropriate. FIXME.
1133 */
1134 sc->sc_if.if_timer = 1 + sc->txb_count;
1135
1136 /* Update txb variables. */
1137 sc->txb_sched = sc->txb_count;
1138 sc->txb_count = 0;
1139 sc->txb_free = sc->txb_size;
1140 sc->tx_excolls = 0;
1141
1142 /* Start transmitter, passing packets in TX buffer. */
1143 fe_outb(sc, FE_BMPR10, sc->txb_sched | FE_B10_START);
1144}
1145
1146/*
1147 * Start output on interface.
1148 * We make two assumptions here:
1149 * 1) that the current priority is set to splimp _before_ this code
1150 * is called *and* is returned to the appropriate priority after
1151 * return
1152 * 2) that the IFF_OACTIVE flag is checked before this code is called
1153 * (i.e. that the output part of the interface is idle)
1154 */
1155void
1156fe_start (struct ifnet *ifp)
1157{
1158 struct fe_softc *sc = ifp->if_softc;
1159 struct mbuf *m;
1160
1161#ifdef DIAGNOSTIC
1162 /* Just a sanity check. */
1163 if ((sc->txb_count == 0) != (sc->txb_free == sc->txb_size)) {
1164 /*
1165 * Txb_count and txb_free co-works to manage the
1166 * transmission buffer. Txb_count keeps track of the
1167 * used potion of the buffer, while txb_free does unused
1168 * potion. So, as long as the driver runs properly,
1169 * txb_count is zero if and only if txb_free is same
1170 * as txb_size (which represents whole buffer.)
1171 */
1172 printf("fe%d: inconsistent txb variables (%d, %d)\n",
1173 sc->sc_unit, sc->txb_count, sc->txb_free);
1174 /*
1175 * So, what should I do, then?
1176 *
1177 * We now know txb_count and txb_free contradicts. We
1178 * cannot, however, tell which is wrong. More
1179 * over, we cannot peek 86960 transmission buffer or
1180 * reset the transmission buffer. (In fact, we can
1181 * reset the entire interface. I don't want to do it.)
1182 *
1183 * If txb_count is incorrect, leaving it as-is will cause
1184 * sending of garbage after next interrupt. We have to
1185 * avoid it. Hence, we reset the txb_count here. If
1186 * txb_free was incorrect, resetting txb_count just loose
1187 * some packets. We can live with it.
1188 */
1189 sc->txb_count = 0;
1190 }
1191#endif
1192
1193 /*
1194 * First, see if there are buffered packets and an idle
1195 * transmitter - should never happen at this point.
1196 */
1197 if ((sc->txb_count > 0) && (sc->txb_sched == 0)) {
1198 printf("fe%d: transmitter idle with %d buffered packets\n",
1199 sc->sc_unit, sc->txb_count);
1200 fe_xmit(sc);
1201 }
1202
1203 /*
1204 * Stop accepting more transmission packets temporarily, when
1205 * a filter change request is delayed. Updating the MARs on
1206 * 86960 flushes the transmission buffer, so it is delayed
1207 * until all buffered transmission packets have been sent
1208 * out.
1209 */
1210 if (sc->filter_change) {
1211 /*
1212 * Filter change request is delayed only when the DLC is
1213 * working. DLC soon raise an interrupt after finishing
1214 * the work.
1215 */
1216 goto indicate_active;
1217 }
1218
1219 for (;;) {
1220
1221 /*
1222 * See if there is room to put another packet in the buffer.
1223 * We *could* do better job by peeking the send queue to
1224 * know the length of the next packet. Current version just
1225 * tests against the worst case (i.e., longest packet). FIXME.
1226 *
1227 * When adding the packet-peek feature, don't forget adding a
1228 * test on txb_count against QUEUEING_MAX.
1229 * There is a little chance the packet count exceeds
1230 * the limit. Assume transmission buffer is 8KB (2x8KB
1231 * configuration) and an application sends a bunch of small
1232 * (i.e., minimum packet sized) packets rapidly. An 8KB
1233 * buffer can hold 130 blocks of 62 bytes long...
1234 */
1235 if (sc->txb_free
1236 < ETHER_MAX_LEN - ETHER_CRC_LEN + FE_DATA_LEN_LEN) {
1237 /* No room. */
1238 goto indicate_active;
1239 }
1240
1241#if FE_SINGLE_TRANSMISSION
1242 if (sc->txb_count > 0) {
1243 /* Just one packet per a transmission buffer. */
1244 goto indicate_active;
1245 }
1246#endif
1247
1248 /*
1249 * Get the next mbuf chain for a packet to send.
1250 */
eb643486 1251 m = ifq_dequeue(&sc->sc_if.if_snd);
984263bc
MD
1252 if (m == NULL) {
1253 /* No more packets to send. */
1254 goto indicate_inactive;
1255 }
1256
1257 /*
1258 * Copy the mbuf chain into the transmission buffer.
1259 * txb_* variables are updated as necessary.
1260 */
1261 fe_write_mbufs(sc, m);
1262
1263 /* Start transmitter if it's idle. */
1264 if ((sc->txb_count > 0) && (sc->txb_sched == 0))
1265 fe_xmit(sc);
1266
1267 /*
1268 * Tap off here if there is a bpf listener,
1269 * and the device is *not* in promiscuous mode.
1270 * (86960 receives self-generated packets if
1271 * and only if it is in "receive everything"
1272 * mode.)
1273 */
7600679e
JS
1274 if ((sc->sc_if.if_flags & IFF_PROMISC) == 0)
1275 BPF_MTAP(&sc->sc_if, m);
984263bc
MD
1276
1277 m_freem(m);
1278 }
1279
1280 indicate_inactive:
1281 /*
1282 * We are using the !OACTIVE flag to indicate to
1283 * the outside world that we can accept an
1284 * additional packet rather than that the
1285 * transmitter is _actually_ active. Indeed, the
1286 * transmitter may be active, but if we haven't
1287 * filled all the buffers with data then we still
1288 * want to accept more.
1289 */
1290 sc->sc_if.if_flags &= ~IFF_OACTIVE;
1291 return;
1292
1293 indicate_active:
1294 /*
1295 * The transmitter is active, and there are no room for
1296 * more outgoing packets in the transmission buffer.
1297 */
1298 sc->sc_if.if_flags |= IFF_OACTIVE;
1299 return;
1300}
1301
1302/*
1303 * Drop (skip) a packet from receive buffer in 86960 memory.
1304 */
1305static void
1306fe_droppacket (struct fe_softc * sc, int len)
1307{
1308 int i;
1309
1310 /*
1311 * 86960 manual says that we have to read 8 bytes from the buffer
1312 * before skip the packets and that there must be more than 8 bytes
1313 * remaining in the buffer when issue a skip command.
1314 * Remember, we have already read 4 bytes before come here.
1315 */
1316 if (len > 12) {
1317 /* Read 4 more bytes, and skip the rest of the packet. */
1318#ifdef FE_8BIT_SUPPORT
1319 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1320 {
1321 (void) fe_inb(sc, FE_BMPR8);
1322 (void) fe_inb(sc, FE_BMPR8);
1323 (void) fe_inb(sc, FE_BMPR8);
1324 (void) fe_inb(sc, FE_BMPR8);
1325 }
1326 else
1327#endif
1328 {
1329 (void) fe_inw(sc, FE_BMPR8);
1330 (void) fe_inw(sc, FE_BMPR8);
1331 }
1332 fe_outb(sc, FE_BMPR14, FE_B14_SKIP);
1333 } else {
1334 /* We should not come here unless receiving RUNTs. */
1335#ifdef FE_8BIT_SUPPORT
1336 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1337 {
1338 for (i = 0; i < len; i++)
1339 (void) fe_inb(sc, FE_BMPR8);
1340 }
1341 else
1342#endif
1343 {
1344 for (i = 0; i < len; i += 2)
1345 (void) fe_inw(sc, FE_BMPR8);
1346 }
1347 }
1348}
1349
1350#ifdef DIAGNOSTIC
1351/*
1352 * Empty receiving buffer.
1353 */
1354static void
1355fe_emptybuffer (struct fe_softc * sc)
1356{
1357 int i;
1358 u_char saved_dlcr5;
1359
1360#ifdef FE_DEBUG
1361 printf("fe%d: emptying receive buffer\n", sc->sc_unit);
1362#endif
1363
1364 /*
1365 * Stop receiving packets, temporarily.
1366 */
1367 saved_dlcr5 = fe_inb(sc, FE_DLCR5);
1368 fe_outb(sc, FE_DLCR5, sc->proto_dlcr5);
1369 DELAY(1300);
1370
1371 /*
1372 * When we come here, the receive buffer management may
1373 * have been broken. So, we cannot use skip operation.
1374 * Just discard everything in the buffer.
1375 */
1376#ifdef FE_8BIT_SUPPORT
1377 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1378 {
1379 for (i = 0; i < 65536; i++) {
1380 if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)
1381 break;
1382 (void) fe_inb(sc, FE_BMPR8);
1383 }
1384 }
1385 else
1386#endif
1387 {
1388 for (i = 0; i < 65536; i += 2) {
1389 if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)
1390 break;
1391 (void) fe_inw(sc, FE_BMPR8);
1392 }
1393 }
1394
1395 /*
1396 * Double check.
1397 */
1398 if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP) {
1399 printf("fe%d: could not empty receive buffer\n", sc->sc_unit);
1400 /* Hmm. What should I do if this happens? FIXME. */
1401 }
1402
1403 /*
1404 * Restart receiving packets.
1405 */
1406 fe_outb(sc, FE_DLCR5, saved_dlcr5);
1407}
1408#endif
1409
1410/*
1411 * Transmission interrupt handler
1412 * The control flow of this function looks silly. FIXME.
1413 */
1414static void
1415fe_tint (struct fe_softc * sc, u_char tstat)
1416{
1417 int left;
1418 int col;
1419
1420 /*
1421 * Handle "excessive collision" interrupt.
1422 */
1423 if (tstat & FE_D0_COLL16) {
1424
1425 /*
1426 * Find how many packets (including this collided one)
1427 * are left unsent in transmission buffer.
1428 */
1429 left = fe_inb(sc, FE_BMPR10);
1430 printf("fe%d: excessive collision (%d/%d)\n",
1431 sc->sc_unit, left, sc->txb_sched);
1432
1433 /*
1434 * Clear the collision flag (in 86960) here
1435 * to avoid confusing statistics.
1436 */
1437 fe_outb(sc, FE_DLCR0, FE_D0_COLLID);
1438
1439 /*
1440 * Restart transmitter, skipping the
1441 * collided packet.
1442 *
1443 * We *must* skip the packet to keep network running
1444 * properly. Excessive collision error is an
1445 * indication of the network overload. If we
1446 * tried sending the same packet after excessive
1447 * collision, the network would be filled with
1448 * out-of-time packets. Packets belonging
1449 * to reliable transport (such as TCP) are resent
1450 * by some upper layer.
1451 */
1452 fe_outb(sc, FE_BMPR11, FE_B11_CTRL_SKIP | FE_B11_MODE1);
1453
1454 /* Update statistics. */
1455 sc->tx_excolls++;
1456 }
1457
1458 /*
1459 * Handle "transmission complete" interrupt.
1460 */
1461 if (tstat & FE_D0_TXDONE) {
1462
1463 /*
1464 * Add in total number of collisions on last
1465 * transmission. We also clear "collision occurred" flag
1466 * here.
1467 *
1468 * 86960 has a design flaw on collision count on multiple
1469 * packet transmission. When we send two or more packets
1470 * with one start command (that's what we do when the
1471 * transmission queue is crowded), 86960 informs us number
1472 * of collisions occurred on the last packet on the
1473 * transmission only. Number of collisions on previous
1474 * packets are lost. I have told that the fact is clearly
1475 * stated in the Fujitsu document.
1476 *
1477 * I considered not to mind it seriously. Collision
1478 * count is not so important, anyway. Any comments? FIXME.
1479 */
1480
1481 if (fe_inb(sc, FE_DLCR0) & FE_D0_COLLID) {
1482
1483 /* Clear collision flag. */
1484 fe_outb(sc, FE_DLCR0, FE_D0_COLLID);
1485
1486 /* Extract collision count from 86960. */
1487 col = fe_inb(sc, FE_DLCR4);
1488 col = (col & FE_D4_COL) >> FE_D4_COL_SHIFT;
1489 if (col == 0) {
1490 /*
1491 * Status register indicates collisions,
1492 * while the collision count is zero.
1493 * This can happen after multiple packet
1494 * transmission, indicating that one or more
1495 * previous packet(s) had been collided.
1496 *
1497 * Since the accurate number of collisions
1498 * has been lost, we just guess it as 1;
1499 * Am I too optimistic? FIXME.
1500 */
1501 col = 1;
1502 }
1503 sc->sc_if.if_collisions += col;
1504 if (col == 1)
1505 sc->mibdata.dot3StatsSingleCollisionFrames++;
1506 else
1507 sc->mibdata.dot3StatsMultipleCollisionFrames++;
1508 sc->mibdata.dot3StatsCollFrequencies[col-1]++;
1509 }
1510
1511 /*
1512 * Update transmission statistics.
1513 * Be sure to reflect number of excessive collisions.
1514 */
1515 col = sc->tx_excolls;
1516 sc->sc_if.if_opackets += sc->txb_sched - col;
1517 sc->sc_if.if_oerrors += col;
1518 sc->sc_if.if_collisions += col * 16;
1519 sc->mibdata.dot3StatsExcessiveCollisions += col;
1520 sc->mibdata.dot3StatsCollFrequencies[15] += col;
1521 sc->txb_sched = 0;
1522
1523 /*
1524 * The transmitter is no more active.
1525 * Reset output active flag and watchdog timer.
1526 */
1527 sc->sc_if.if_flags &= ~IFF_OACTIVE;
1528 sc->sc_if.if_timer = 0;
1529
1530 /*
1531 * If more data is ready to transmit in the buffer, start
1532 * transmitting them. Otherwise keep transmitter idle,
1533 * even if more data is queued. This gives receive
1534 * process a slight priority.
1535 */
1536 if (sc->txb_count > 0)
1537 fe_xmit(sc);
1538 }
1539}
1540
1541/*
1542 * Ethernet interface receiver interrupt.
1543 */
1544static void
1545fe_rint (struct fe_softc * sc, u_char rstat)
1546{
1547 u_short len;
1548 u_char status;
1549 int i;
1550
1551 /*
1552 * Update statistics if this interrupt is caused by an error.
1553 * Note that, when the system was not sufficiently fast, the
1554 * receive interrupt might not be acknowledged immediately. If
1555 * one or more errornous frames were received before this routine
1556 * was scheduled, they are ignored, and the following error stats
1557 * give less than real values.
1558 */
1559 if (rstat & (FE_D1_OVRFLO | FE_D1_CRCERR | FE_D1_ALGERR | FE_D1_SRTPKT)) {
1560 if (rstat & FE_D1_OVRFLO)
1561 sc->mibdata.dot3StatsInternalMacReceiveErrors++;
1562 if (rstat & FE_D1_CRCERR)
1563 sc->mibdata.dot3StatsFCSErrors++;
1564 if (rstat & FE_D1_ALGERR)
1565 sc->mibdata.dot3StatsAlignmentErrors++;
1566#if 0
1567 /* The reference MAC receiver defined in 802.3
1568 silently ignores short frames (RUNTs) without
1569 notifying upper layer. RFC 1650 (dot3 MIB) is
1570 based on the 802.3, and it has no stats entry for
1571 RUNTs... */
1572 if (rstat & FE_D1_SRTPKT)
1573 sc->mibdata.dot3StatsFrameTooShorts++; /* :-) */
1574#endif
1575 sc->sc_if.if_ierrors++;
1576 }
1577
1578 /*
1579 * MB86960 has a flag indicating "receive queue empty."
1580 * We just loop, checking the flag, to pull out all received
1581 * packets.
1582 *
1583 * We limit the number of iterations to avoid infinite-loop.
1584 * The upper bound is set to unrealistic high value.
1585 */
1586 for (i = 0; i < FE_MAX_RECV_COUNT * 2; i++) {
1587
1588 /* Stop the iteration if 86960 indicates no packets. */
1589 if (fe_inb(sc, FE_DLCR5) & FE_D5_BUFEMP)
1590 return;
1591
1592 /*
1593 * Extract a receive status byte.
1594 * As our 86960 is in 16 bit bus access mode, we have to
1595 * use inw() to get the status byte. The significant
1596 * value is returned in lower 8 bits.
1597 */
1598#ifdef FE_8BIT_SUPPORT
1599 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1600 {
1601 status = fe_inb(sc, FE_BMPR8);
1602 (void) fe_inb(sc, FE_BMPR8);
1603 }
1604 else
1605#endif
1606 {
1607 status = (u_char) fe_inw(sc, FE_BMPR8);
1608 }
1609
1610 /*
1611 * Extract the packet length.
1612 * It is a sum of a header (14 bytes) and a payload.
1613 * CRC has been stripped off by the 86960.
1614 */
1615#ifdef FE_8BIT_SUPPORT
1616 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1617 {
1618 len = fe_inb(sc, FE_BMPR8);
1619 len |= (fe_inb(sc, FE_BMPR8) << 8);
1620 }
1621 else
1622#endif
1623 {
1624 len = fe_inw(sc, FE_BMPR8);
1625 }
1626
1627 /*
1628 * AS our 86960 is programed to ignore errored frame,
1629 * we must not see any error indication in the
1630 * receive buffer. So, any error condition is a
1631 * serious error, e.g., out-of-sync of the receive
1632 * buffer pointers.
1633 */
1634 if ((status & 0xF0) != 0x20 ||
1635 len > ETHER_MAX_LEN - ETHER_CRC_LEN ||
1636 len < ETHER_MIN_LEN - ETHER_CRC_LEN) {
1637 printf("fe%d: RX buffer out-of-sync\n", sc->sc_unit);
1638 sc->sc_if.if_ierrors++;
1639 sc->mibdata.dot3StatsInternalMacReceiveErrors++;
1640 fe_reset(sc);
1641 return;
1642 }
1643
1644 /*
1645 * Go get a packet.
1646 */
1647 if (fe_get_packet(sc, len) < 0) {
1648 /*
1649 * Negative return from fe_get_packet()
1650 * indicates no available mbuf. We stop
1651 * receiving packets, even if there are more
1652 * in the buffer. We hope we can get more
1653 * mbuf next time.
1654 */
1655 sc->sc_if.if_ierrors++;
1656 sc->mibdata.dot3StatsMissedFrames++;
1657 fe_droppacket(sc, len);
1658 return;
1659 }
1660
1661 /* Successfully received a packet. Update stat. */
1662 sc->sc_if.if_ipackets++;
1663 }
1664
1665 /* Maximum number of frames has been received. Something
1666 strange is happening here... */
1667 printf("fe%d: unusual receive flood\n", sc->sc_unit);
1668 sc->mibdata.dot3StatsInternalMacReceiveErrors++;
1669 fe_reset(sc);
1670}
1671
1672/*
1673 * Ethernet interface interrupt processor
1674 */
1675static void
1676fe_intr (void *arg)
1677{
1678 struct fe_softc *sc = arg;
1679 u_char tstat, rstat;
1680 int loop_count = FE_MAX_LOOP;
1681
1682 /* Loop until there are no more new interrupt conditions. */
1683 while (loop_count-- > 0) {
1684 /*
1685 * Get interrupt conditions, masking unneeded flags.
1686 */
1687 tstat = fe_inb(sc, FE_DLCR0) & FE_TMASK;
1688 rstat = fe_inb(sc, FE_DLCR1) & FE_RMASK;
1689 if (tstat == 0 && rstat == 0)
1690 return;
1691
1692 /*
1693 * Reset the conditions we are acknowledging.
1694 */
1695 fe_outb(sc, FE_DLCR0, tstat);
1696 fe_outb(sc, FE_DLCR1, rstat);
1697
1698 /*
1699 * Handle transmitter interrupts.
1700 */
1701 if (tstat)
1702 fe_tint(sc, tstat);
1703
1704 /*
1705 * Handle receiver interrupts
1706 */
1707 if (rstat)
1708 fe_rint(sc, rstat);
1709
1710 /*
1711 * Update the multicast address filter if it is
1712 * needed and possible. We do it now, because
1713 * we can make sure the transmission buffer is empty,
1714 * and there is a good chance that the receive queue
1715 * is empty. It will minimize the possibility of
1716 * packet loss.
1717 */
1718 if (sc->filter_change &&
1719 sc->txb_count == 0 && sc->txb_sched == 0) {
1720 fe_loadmar(sc);
1721 sc->sc_if.if_flags &= ~IFF_OACTIVE;
1722 }
1723
1724 /*
1725 * If it looks like the transmitter can take more data,
1726 * attempt to start output on the interface. This is done
1727 * after handling the receiver interrupt to give the
1728 * receive operation priority.
1729 *
1730 * BTW, I'm not sure in what case the OACTIVE is on at
1731 * this point. Is the following test redundant?
1732 *
1733 * No. This routine polls for both transmitter and
1734 * receiver interrupts. 86960 can raise a receiver
1735 * interrupt when the transmission buffer is full.
1736 */
1737 if ((sc->sc_if.if_flags & IFF_OACTIVE) == 0)
1738 fe_start(&sc->sc_if);
1739 }
1740
1741 printf("fe%d: too many loops\n", sc->sc_unit);
1742}
1743
1744/*
1745 * Process an ioctl request. This code needs some work - it looks
1746 * pretty ugly.
1747 */
1748static int
bd4539cc 1749fe_ioctl (struct ifnet * ifp, u_long command, caddr_t data, struct ucred *cr)
984263bc
MD
1750{
1751 struct fe_softc *sc = ifp->if_softc;
1752 struct ifreq *ifr = (struct ifreq *)data;
012eaeb1 1753 int error = 0;
984263bc 1754
012eaeb1 1755 crit_enter();
984263bc
MD
1756
1757 switch (command) {
984263bc
MD
1758 case SIOCSIFFLAGS:
1759 /*
1760 * Switch interface state between "running" and
1761 * "stopped", reflecting the UP flag.
1762 */
1763 if (sc->sc_if.if_flags & IFF_UP) {
1764 if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
1765 fe_init(sc);
1766 } else {
1767 if ((sc->sc_if.if_flags & IFF_RUNNING) != 0)
1768 fe_stop(sc);
1769 }
1770
1771 /*
1772 * Promiscuous and/or multicast flags may have changed,
1773 * so reprogram the multicast filter and/or receive mode.
1774 */
1775 fe_setmode(sc);
1776
1777 /* Done. */
1778 break;
1779
1780 case SIOCADDMULTI:
1781 case SIOCDELMULTI:
1782 /*
1783 * Multicast list has changed; set the hardware filter
1784 * accordingly.
1785 */
1786 fe_setmode(sc);
1787 break;
1788
1789 case SIOCSIFMEDIA:
1790 case SIOCGIFMEDIA:
1791 /* Let if_media to handle these commands and to call
1792 us back. */
1793 error = ifmedia_ioctl(ifp, ifr, &sc->media, command);
1794 break;
1795
1796 default:
4cde4dd5 1797 error = ether_ioctl(ifp, command, data);
984263bc
MD
1798 break;
1799 }
1800
012eaeb1
JS
1801 crit_exit();
1802
984263bc
MD
1803 return (error);
1804}
1805
1806/*
1807 * Retrieve packet from receive buffer and send to the next level up via
1808 * ether_input().
1809 * Returns 0 if success, -1 if error (i.e., mbuf allocation failure).
1810 */
1811static int
1812fe_get_packet (struct fe_softc * sc, u_short len)
1813{
1814 struct ether_header *eh;
1815 struct mbuf *m;
1816
1817 /*
1818 * NFS wants the data be aligned to the word (4 byte)
1819 * boundary. Ethernet header has 14 bytes. There is a
1820 * 2-byte gap.
1821 */
1822#define NFS_MAGIC_OFFSET 2
1823
1824 /*
1825 * This function assumes that an Ethernet packet fits in an
1826 * mbuf (with a cluster attached when necessary.) On FreeBSD
1827 * 2.0 for x86, which is the primary target of this driver, an
1828 * mbuf cluster has 4096 bytes, and we are happy. On ancient
1829 * BSDs, such as vanilla 4.3 for 386, a cluster size was 1024,
1830 * however. If the following #error message were printed upon
1831 * compile, you need to rewrite this function.
1832 */
1833#if ( MCLBYTES < ETHER_MAX_LEN - ETHER_CRC_LEN + NFS_MAGIC_OFFSET )
1834#error "Too small MCLBYTES to use fe driver."
1835#endif
1836
1837 /*
1838 * Our strategy has one more problem. There is a policy on
1839 * mbuf cluster allocation. It says that we must have at
1840 * least MINCLSIZE (208 bytes on FreeBSD 2.0 for x86) to
1841 * allocate a cluster. For a packet of a size between
1842 * (MHLEN - 2) to (MINCLSIZE - 2), our code violates the rule...
1843 * On the other hand, the current code is short, simple,
1844 * and fast, however. It does no harmful thing, just waists
1845 * some memory. Any comments? FIXME.
1846 */
1847
1848 /* Allocate an mbuf with packet header info. */
74f1caca 1849 MGETHDR(m, MB_DONTWAIT, MT_DATA);
984263bc
MD
1850 if (m == NULL)
1851 return -1;
1852
1853 /* Attach a cluster if this packet doesn't fit in a normal mbuf. */
1854 if (len > MHLEN - NFS_MAGIC_OFFSET) {
74f1caca 1855 MCLGET(m, MB_DONTWAIT);
984263bc
MD
1856 if (!(m->m_flags & M_EXT)) {
1857 m_freem(m);
1858 return -1;
1859 }
1860 }
1861
1862 /* Initialize packet header info. */
1863 m->m_pkthdr.rcvif = &sc->sc_if;
1864 m->m_pkthdr.len = len;
1865
1866 /* Set the length of this packet. */
1867 m->m_len = len;
1868
1869 /* The following silliness is to make NFS happy */
1870 m->m_data += NFS_MAGIC_OFFSET;
1871
1872 /* Get (actually just point to) the header part. */
1873 eh = mtod(m, struct ether_header *);
1874
1875 /* Get a packet. */
1876#ifdef FE_8BIT_SUPPORT
1877 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1878 {
1879 fe_insb(sc, FE_BMPR8, (u_int8_t *)eh, len);
1880 }
1881 else
1882#endif
1883 {
1884 fe_insw(sc, FE_BMPR8, (u_int16_t *)eh, (len + 1) >> 1);
1885 }
1886
984263bc 1887 /* Feed the packet to upper layer. */
3013ac0e 1888 (*sc->sc_if.if_input)(&sc->sc_if, m);
984263bc
MD
1889 return 0;
1890}
1891
1892/*
1893 * Write an mbuf chain to the transmission buffer memory using 16 bit PIO.
1894 * Returns number of bytes actually written, including length word.
1895 *
1896 * If an mbuf chain is too long for an Ethernet frame, it is not sent.
1897 * Packets shorter than Ethernet minimum are legal, and we pad them
1898 * before sending out. An exception is "partial" packets which are
1899 * shorter than mandatory Ethernet header.
1900 */
1901static void
1902fe_write_mbufs (struct fe_softc *sc, struct mbuf *m)
1903{
1904 u_short length, len;
1905 struct mbuf *mp;
1906 u_char *data;
1907 u_short savebyte; /* WARNING: Architecture dependent! */
1908#define NO_PENDING_BYTE 0xFFFF
1909
1910 static u_char padding [ETHER_MIN_LEN - ETHER_CRC_LEN - ETHER_HDR_LEN];
1911
1912#ifdef DIAGNOSTIC
1913 /* First, count up the total number of bytes to copy */
1914 length = 0;
1915 for (mp = m; mp != NULL; mp = mp->m_next)
1916 length += mp->m_len;
1917
1918 /* Check if this matches the one in the packet header. */
1919 if (length != m->m_pkthdr.len) {
1920 printf("fe%d: packet length mismatch? (%d/%d)\n", sc->sc_unit,
1921 length, m->m_pkthdr.len);
1922 }
1923#else
1924 /* Just use the length value in the packet header. */
1925 length = m->m_pkthdr.len;
1926#endif
1927
1928#ifdef DIAGNOSTIC
1929 /*
1930 * Should never send big packets. If such a packet is passed,
1931 * it should be a bug of upper layer. We just ignore it.
1932 * ... Partial (too short) packets, neither.
1933 */
1934 if (length < ETHER_HDR_LEN ||
1935 length > ETHER_MAX_LEN - ETHER_CRC_LEN) {
1936 printf("fe%d: got an out-of-spec packet (%u bytes) to send\n",
1937 sc->sc_unit, length);
1938 sc->sc_if.if_oerrors++;
1939 sc->mibdata.dot3StatsInternalMacTransmitErrors++;
1940 return;
1941 }
1942#endif
1943
1944 /*
1945 * Put the length word for this frame.
1946 * Does 86960 accept odd length? -- Yes.
1947 * Do we need to pad the length to minimum size by ourselves?
1948 * -- Generally yes. But for (or will be) the last
1949 * packet in the transmission buffer, we can skip the
1950 * padding process. It may gain performance slightly. FIXME.
1951 */
1952#ifdef FE_8BIT_SUPPORT
1953 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1954 {
1955 len = max(length, ETHER_MIN_LEN - ETHER_CRC_LEN);
1956 fe_outb(sc, FE_BMPR8, len & 0x00ff);
1957 fe_outb(sc, FE_BMPR8, (len & 0xff00) >> 8);
1958 }
1959 else
1960#endif
1961 {
1962 fe_outw(sc, FE_BMPR8,
1963 max(length, ETHER_MIN_LEN - ETHER_CRC_LEN));
1964 }
1965
1966 /*
1967 * Update buffer status now.
1968 * Truncate the length up to an even number, since we use outw().
1969 */
1970#ifdef FE_8BIT_SUPPORT
1971 if ((sc->proto_dlcr6 & FE_D6_SBW) != FE_D6_SBW_BYTE)
1972#endif
1973 {
1974 length = (length + 1) & ~1;
1975 }
1976 sc->txb_free -= FE_DATA_LEN_LEN +
1977 max(length, ETHER_MIN_LEN - ETHER_CRC_LEN);
1978 sc->txb_count++;
1979
1980 /*
1981 * Transfer the data from mbuf chain to the transmission buffer.
1982 * MB86960 seems to require that data be transferred as words, and
1983 * only words. So that we require some extra code to patch
1984 * over odd-length mbufs.
1985 */
1986#ifdef FE_8BIT_SUPPORT
1987 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
1988 {
1989 /* 8-bit cards are easy. */
1990 for (mp = m; mp != 0; mp = mp->m_next) {
1991 if (mp->m_len)
1992 fe_outsb(sc, FE_BMPR8, mtod(mp, caddr_t),
1993 mp->m_len);
1994 }
1995 }
1996 else
1997#endif
1998 {
1999 /* 16-bit cards are a pain. */
2000 savebyte = NO_PENDING_BYTE;
2001 for (mp = m; mp != 0; mp = mp->m_next) {
2002
2003 /* Ignore empty mbuf. */
2004 len = mp->m_len;
2005 if (len == 0)
2006 continue;
2007
2008 /* Find the actual data to send. */
2009 data = mtod(mp, caddr_t);
2010
2011 /* Finish the last byte. */
2012 if (savebyte != NO_PENDING_BYTE) {
2013 fe_outw(sc, FE_BMPR8, savebyte | (*data << 8));
2014 data++;
2015 len--;
2016 savebyte = NO_PENDING_BYTE;
2017 }
2018
2019 /* output contiguous words */
2020 if (len > 1) {
2021 fe_outsw(sc, FE_BMPR8, (u_int16_t *)data,
2022 len >> 1);
2023 data += len & ~1;
2024 len &= 1;
2025 }
2026
2027 /* Save a remaining byte, if there is one. */
2028 if (len > 0)
2029 savebyte = *data;
2030 }
2031
2032 /* Spit the last byte, if the length is odd. */
2033 if (savebyte != NO_PENDING_BYTE)
2034 fe_outw(sc, FE_BMPR8, savebyte);
2035 }
2036
2037 /* Pad to the Ethernet minimum length, if the packet is too short. */
2038 if (length < ETHER_MIN_LEN - ETHER_CRC_LEN) {
2039#ifdef FE_8BIT_SUPPORT
2040 if ((sc->proto_dlcr6 & FE_D6_SBW) == FE_D6_SBW_BYTE)
2041 {
2042 fe_outsb(sc, FE_BMPR8, padding,
2043 ETHER_MIN_LEN - ETHER_CRC_LEN - length);
2044 }
2045 else
2046#endif
2047 {
2048 fe_outsw(sc, FE_BMPR8, (u_int16_t *)padding,
2049 (ETHER_MIN_LEN - ETHER_CRC_LEN - length) >> 1);
2050 }
2051 }
2052}
2053
2054/*
2055 * Compute hash value for an Ethernet address
2056 */
2057static int
2058fe_hash ( u_char * ep )
2059{
2060#define FE_HASH_MAGIC_NUMBER 0xEDB88320L
2061
2062 u_long hash = 0xFFFFFFFFL;
2063 int i, j;
2064 u_char b;
2065 u_long m;
2066
2067 for ( i = ETHER_ADDR_LEN; --i >= 0; ) {
2068 b = *ep++;
2069 for ( j = 8; --j >= 0; ) {
2070 m = hash;
2071 hash >>= 1;
2072 if ( ( m ^ b ) & 1 ) hash ^= FE_HASH_MAGIC_NUMBER;
2073 b >>= 1;
2074 }
2075 }
2076 return ( ( int )( hash >> 26 ) );
2077}
2078
2079/*
2080 * Compute the multicast address filter from the
2081 * list of multicast addresses we need to listen to.
2082 */
2083static struct fe_filter
2084fe_mcaf ( struct fe_softc *sc )
2085{
2086 int index;
2087 struct fe_filter filter;
2088 struct ifmultiaddr *ifma;
2089
2090 filter = fe_filter_nothing;
03df8a20 2091 LIST_FOREACH(ifma, &sc->arpcom.ac_if.if_multiaddrs, ifma_link) {
984263bc
MD
2092 if (ifma->ifma_addr->sa_family != AF_LINK)
2093 continue;
2094 index = fe_hash(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
2095#ifdef FE_DEBUG
2096 printf("fe%d: hash(%6D) == %d\n",
2097 sc->sc_unit, enm->enm_addrlo , ":", index);
2098#endif
2099
2100 filter.data[index >> 3] |= 1 << (index & 7);
2101 }
2102 return ( filter );
2103}
2104
2105/*
2106 * Calculate a new "multicast packet filter" and put the 86960
2107 * receiver in appropriate mode.
2108 */
2109static void
2110fe_setmode (struct fe_softc *sc)
2111{
2112 int flags = sc->sc_if.if_flags;
2113
2114 /*
2115 * If the interface is not running, we postpone the update
2116 * process for receive modes and multicast address filter
2117 * until the interface is restarted. It reduces some
2118 * complicated job on maintaining chip states. (Earlier versions
2119 * of this driver had a bug on that point...)
2120 *
2121 * To complete the trick, fe_init() calls fe_setmode() after
2122 * restarting the interface.
2123 */
2124 if (!(flags & IFF_RUNNING))
2125 return;
2126
2127 /*
2128 * Promiscuous mode is handled separately.
2129 */
2130 if (flags & IFF_PROMISC) {
2131 /*
2132 * Program 86960 to receive all packets on the segment
2133 * including those directed to other stations.
2134 * Multicast filter stored in MARs are ignored
2135 * under this setting, so we don't need to update it.
2136 *
2137 * Promiscuous mode in FreeBSD 2 is used solely by
2138 * BPF, and BPF only listens to valid (no error) packets.
2139 * So, we ignore erroneous ones even in this mode.
2140 * (Older versions of fe driver mistook the point.)
2141 */
2142 fe_outb(sc, FE_DLCR5,
2143 sc->proto_dlcr5 | FE_D5_AFM0 | FE_D5_AFM1);
2144 sc->filter_change = 0;
2145 return;
2146 }
2147
2148 /*
2149 * Turn the chip to the normal (non-promiscuous) mode.
2150 */
2151 fe_outb(sc, FE_DLCR5, sc->proto_dlcr5 | FE_D5_AFM1);
2152
2153 /*
2154 * Find the new multicast filter value.
2155 */
2156 if (flags & IFF_ALLMULTI)
2157 sc->filter = fe_filter_all;
2158 else
2159 sc->filter = fe_mcaf(sc);
2160 sc->filter_change = 1;
2161
2162 /*
2163 * We have to update the multicast filter in the 86960, A.S.A.P.
2164 *
2165 * Note that the DLC (Data Link Control unit, i.e. transmitter
2166 * and receiver) must be stopped when feeding the filter, and
2167 * DLC trashes all packets in both transmission and receive
2168 * buffers when stopped.
2169 *
2170 * To reduce the packet loss, we delay the filter update
2171 * process until buffers are empty.
2172 */
2173 if (sc->txb_sched == 0 && sc->txb_count == 0 &&
2174 !(fe_inb(sc, FE_DLCR1) & FE_D1_PKTRDY)) {
2175 /*
2176 * Buffers are (apparently) empty. Load
2177 * the new filter value into MARs now.
2178 */
2179 fe_loadmar(sc);
2180 } else {
2181 /*
2182 * Buffers are not empty. Mark that we have to update
2183 * the MARs. The new filter will be loaded by feintr()
2184 * later.
2185 */
2186 }
2187}
2188
2189/*
2190 * Load a new multicast address filter into MARs.
2191 *
2192 * The caller must have splimp'ed before fe_loadmar.
2193 * This function starts the DLC upon return. So it can be called only
2194 * when the chip is working, i.e., from the driver's point of view, when
2195 * a device is RUNNING. (I mistook the point in previous versions.)
2196 */
2197static void
2198fe_loadmar (struct fe_softc * sc)
2199{
2200 /* Stop the DLC (transmitter and receiver). */
2201 DELAY(200);
2202 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_DISABLE);
2203 DELAY(200);
2204
2205 /* Select register bank 1 for MARs. */
2206 fe_outb(sc, FE_DLCR7, sc->proto_dlcr7 | FE_D7_RBS_MAR | FE_D7_POWER_UP);
2207
2208 /* Copy filter value into the registers. */
2209 fe_outblk(sc, FE_MAR8, sc->filter.data, FE_FILTER_LEN);
2210
2211 /* Restore the bank selection for BMPRs (i.e., runtime registers). */
2212 fe_outb(sc, FE_DLCR7,
2213 sc->proto_dlcr7 | FE_D7_RBS_BMPR | FE_D7_POWER_UP);
2214
2215 /* Restart the DLC. */
2216 DELAY(200);
2217 fe_outb(sc, FE_DLCR6, sc->proto_dlcr6 | FE_D6_DLC_ENABLE);
2218 DELAY(200);
2219
2220 /* We have just updated the filter. */
2221 sc->filter_change = 0;
2222}
2223
2224/* Change the media selection. */
2225static int
2226fe_medchange (struct ifnet *ifp)
2227{
2228 struct fe_softc *sc = (struct fe_softc *)ifp->if_softc;
2229
2230#ifdef DIAGNOSTIC
2231 /* If_media should not pass any request for a media which this
2232 interface doesn't support. */
2233 int b;
2234
2235 for (b = 0; bit2media[b] != 0; b++) {
2236 if (bit2media[b] == sc->media.ifm_media) break;
2237 }
2238 if (((1 << b) & sc->mbitmap) == 0) {
2239 printf("fe%d: got an unsupported media request (0x%x)\n",
2240 sc->sc_unit, sc->media.ifm_media);
2241 return EINVAL;
2242 }
2243#endif
2244
2245 /* We don't actually change media when the interface is down.
2246 fe_init() will do the job, instead. Should we also wait
2247 until the transmission buffer being empty? Changing the
2248 media when we are sending a frame will cause two garbages
2249 on wires, one on old media and another on new. FIXME */
2250 if (sc->sc_if.if_flags & IFF_UP) {
2251 if (sc->msel) sc->msel(sc);
2252 }
2253
2254 return 0;
2255}
2256
2257/* I don't know how I can support media status callback... FIXME. */
2258static void
2259fe_medstat (struct ifnet *ifp, struct ifmediareq *ifmr)
2260{
2261 (void)ifp;
2262 (void)ifmr;
2263}