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