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/ep/if_ep.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 * Copyright (c) 1994 Herb Peyerl <hpeyerl@novatel.ca> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by Herb Peyerl. 16 * 4. The name of Herb Peyerl may not be used to endorse or promote products 17 * derived from this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD: releng/6.4/sys/dev/ep/if_ep.c 164865 2006-12-04 00:51:14Z mlaier $"); 33 34 /* 35 * Modified from the FreeBSD 1.1.5.1 version by: 36 * Andres Vega Garcia 37 * INRIA - Sophia Antipolis, France 38 * avega@sophia.inria.fr 39 */ 40 41 /* 42 * Promiscuous mode added and interrupt logic slightly changed 43 * to reduce the number of adapter failures. Transceiver select 44 * logic changed to use value from EEPROM. Autoconfiguration 45 * features added. 46 * Done by: 47 * Serge Babkin 48 * Chelindbank (Chelyabinsk, Russia) 49 * babkin@hq.icb.chel.su 50 */ 51 52 /* 53 * Pccard support for 3C589 by: 54 * HAMADA Naoki 55 * nao@tom-yam.or.jp 56 */ 57 58 /* 59 * MAINTAINER: Matthew N. Dodd <winter@jurai.net> 60 * <mdodd@FreeBSD.org> 61 */ 62 63 #include <sys/param.h> 64 #include <sys/systm.h> 65 #include <sys/mbuf.h> 66 #include <sys/socket.h> 67 #include <sys/sockio.h> 68 #include <sys/bus.h> 69 70 #include <machine/bus.h> 71 #include <machine/resource.h> 72 #include <sys/rman.h> 73 74 #include <net/if.h> 75 #include <net/if_arp.h> 76 #include <net/if_media.h> 77 #include <net/if_types.h> 78 #include <net/ethernet.h> 79 #include <net/bpf.h> 80 81 #include <dev/ep/if_epreg.h> 82 #include <dev/ep/if_epvar.h> 83 84 /* Exported variables */ 85 devclass_t ep_devclass; 86 87 static int ep_media2if_media[] = 88 {IFM_10_T, IFM_10_5, IFM_NONE, IFM_10_2, IFM_NONE}; 89 90 /* if functions */ 91 static void epinit(void *); 92 static int epioctl(struct ifnet *, u_long, caddr_t); 93 static void epstart(struct ifnet *); 94 static void epwatchdog(struct ifnet *); 95 96 static void epstart_locked(struct ifnet *); 97 static void epinit_locked(struct ep_softc *); 98 99 /* if_media functions */ 100 static int ep_ifmedia_upd(struct ifnet *); 101 static void ep_ifmedia_sts(struct ifnet *, struct ifmediareq *); 102 103 static void epstop(struct ep_softc *); 104 static void epread(struct ep_softc *); 105 static int eeprom_rdy(struct ep_softc *); 106 107 #define EP_FTST(sc, f) (sc->stat & (f)) 108 #define EP_FSET(sc, f) (sc->stat |= (f)) 109 #define EP_FRST(sc, f) (sc->stat &= ~(f)) 110 111 static int 112 eeprom_rdy(struct ep_softc *sc) 113 { 114 int i; 115 116 for (i = 0; is_eeprom_busy(sc) && i < MAX_EEPROMBUSY; i++) 117 DELAY(100); 118 119 if (i >= MAX_EEPROMBUSY) { 120 device_printf(sc->dev, "eeprom failed to come ready.\n"); 121 return (ENXIO); 122 } 123 124 return (0); 125 } 126 127 /* 128 * get_e: gets a 16 bits word from the EEPROM. we must have set the window 129 * before 130 */ 131 int 132 ep_get_e(struct ep_softc *sc, uint16_t offset, uint16_t *result) 133 { 134 135 if (eeprom_rdy(sc)) 136 return (ENXIO); 137 138 CSR_WRITE_2(sc, EP_W0_EEPROM_COMMAND, 139 (EEPROM_CMD_RD << sc->epb.cmd_off) | offset); 140 141 if (eeprom_rdy(sc)) 142 return (ENXIO); 143 144 (*result) = CSR_READ_2(sc, EP_W0_EEPROM_DATA); 145 146 return (0); 147 } 148 149 static int 150 ep_get_macaddr(struct ep_softc *sc, u_char *addr) 151 { 152 int i; 153 uint16_t result; 154 int error; 155 uint16_t *macaddr; 156 157 macaddr = (uint16_t *) addr; 158 159 GO_WINDOW(sc, 0); 160 for (i = EEPROM_NODE_ADDR_0; i <= EEPROM_NODE_ADDR_2; i++) { 161 error = ep_get_e(sc, i, &result); 162 if (error) 163 return (error); 164 macaddr[i] = htons(result); 165 } 166 return (0); 167 } 168 169 int 170 ep_alloc(device_t dev) 171 { 172 struct ep_softc *sc = device_get_softc(dev); 173 int rid; 174 int error = 0; 175 uint16_t result; 176 177 rid = 0; 178 sc->iobase = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid, 179 RF_ACTIVE); 180 if (!sc->iobase) { 181 device_printf(dev, "No I/O space?!\n"); 182 error = ENXIO; 183 goto bad; 184 } 185 rid = 0; 186 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE); 187 if (!sc->irq) { 188 device_printf(dev, "No irq?!\n"); 189 error = ENXIO; 190 goto bad; 191 } 192 sc->dev = dev; 193 sc->stat = 0; /* 16 bit access */ 194 195 sc->bst = rman_get_bustag(sc->iobase); 196 sc->bsh = rman_get_bushandle(sc->iobase); 197 198 sc->ep_connectors = 0; 199 sc->ep_connector = 0; 200 201 GO_WINDOW(sc, 0); 202 203 error = ep_get_e(sc, EEPROM_PROD_ID, &result); 204 if (error) 205 goto bad; 206 sc->epb.prod_id = result; 207 208 error = ep_get_e(sc, EEPROM_RESOURCE_CFG, &result); 209 if (error) 210 goto bad; 211 sc->epb.res_cfg = result; 212 213 bad: 214 if (error != 0) 215 ep_free(dev); 216 return (error); 217 } 218 219 void 220 ep_get_media(struct ep_softc *sc) 221 { 222 uint16_t config; 223 224 GO_WINDOW(sc, 0); 225 config = CSR_READ_2(sc, EP_W0_CONFIG_CTRL); 226 if (config & IS_AUI) 227 sc->ep_connectors |= AUI; 228 if (config & IS_BNC) 229 sc->ep_connectors |= BNC; 230 if (config & IS_UTP) 231 sc->ep_connectors |= UTP; 232 233 if (!(sc->ep_connectors & 7)) 234 if (bootverbose) 235 device_printf(sc->dev, "no connectors!\n"); 236 237 /* 238 * This works for most of the cards so we'll do it here. 239 * The cards that require something different can override 240 * this later on. 241 */ 242 sc->ep_connector = CSR_READ_2(sc, EP_W0_ADDRESS_CFG) >> ACF_CONNECTOR_BITS; 243 } 244 245 void 246 ep_free(device_t dev) 247 { 248 struct ep_softc *sc = device_get_softc(dev); 249 250 if (sc->ep_intrhand) 251 bus_teardown_intr(dev, sc->irq, sc->ep_intrhand); 252 if (sc->iobase) 253 bus_release_resource(dev, SYS_RES_IOPORT, 0, sc->iobase); 254 if (sc->irq) 255 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq); 256 sc->ep_intrhand = 0; 257 sc->iobase = 0; 258 sc->irq = 0; 259 } 260 261 static void 262 ep_setup_station(struct ep_softc *sc, u_char *enaddr) 263 { 264 int i; 265 266 /* 267 * Setup the station address 268 */ 269 GO_WINDOW(sc, 2); 270 for (i = 0; i < ETHER_ADDR_LEN; i++) 271 CSR_WRITE_1(sc, EP_W2_ADDR_0 + i, enaddr[i]); 272 } 273 274 int 275 ep_attach(struct ep_softc *sc) 276 { 277 struct ifnet *ifp = NULL; 278 struct ifmedia *ifm = NULL; 279 int error; 280 281 sc->gone = 0; 282 EP_LOCK_INIT(sc); 283 if (! (sc->stat & F_ENADDR_SKIP)) { 284 error = ep_get_macaddr(sc, sc->eaddr); 285 if (error) { 286 device_printf(sc->dev, "Unable to get MAC address!\n"); 287 EP_LOCK_DESTROY(sc); 288 return (ENXIO); 289 } 290 } 291 ep_setup_station(sc, sc->eaddr); 292 ifp = sc->ifp = if_alloc(IFT_ETHER); 293 if (ifp == NULL) { 294 device_printf(sc->dev, "if_alloc() failed\n"); 295 EP_LOCK_DESTROY(sc); 296 return (ENOSPC); 297 } 298 299 ifp->if_softc = sc; 300 if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev)); 301 ifp->if_mtu = ETHERMTU; 302 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 303 ifp->if_start = epstart; 304 ifp->if_ioctl = epioctl; 305 ifp->if_watchdog = epwatchdog; 306 ifp->if_init = epinit; 307 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); 308 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN; 309 IFQ_SET_READY(&ifp->if_snd); 310 311 if (!sc->epb.mii_trans) { 312 ifmedia_init(&sc->ifmedia, 0, ep_ifmedia_upd, ep_ifmedia_sts); 313 314 if (sc->ep_connectors & AUI) 315 ifmedia_add(&sc->ifmedia, 316 IFM_ETHER | IFM_10_5, 0, NULL); 317 if (sc->ep_connectors & UTP) 318 ifmedia_add(&sc->ifmedia, 319 IFM_ETHER | IFM_10_T, 0, NULL); 320 if (sc->ep_connectors & BNC) 321 ifmedia_add(&sc->ifmedia, 322 IFM_ETHER | IFM_10_2, 0, NULL); 323 if (!sc->ep_connectors) 324 ifmedia_add(&sc->ifmedia, 325 IFM_ETHER | IFM_NONE, 0, NULL); 326 327 ifmedia_set(&sc->ifmedia, 328 IFM_ETHER | ep_media2if_media[sc->ep_connector]); 329 330 ifm = &sc->ifmedia; 331 ifm->ifm_media = ifm->ifm_cur->ifm_media; 332 ep_ifmedia_upd(ifp); 333 } 334 ether_ifattach(ifp, sc->eaddr); 335 336 #ifdef EP_LOCAL_STATS 337 sc->rx_no_first = sc->rx_no_mbuf = sc->rx_bpf_disc = 338 sc->rx_overrunf = sc->rx_overrunl = sc->tx_underrun = 0; 339 #endif 340 EP_FSET(sc, F_RX_FIRST); 341 sc->top = sc->mcur = 0; 342 343 epstop(sc); 344 345 return (0); 346 } 347 348 int 349 ep_detach(device_t dev) 350 { 351 struct ep_softc *sc; 352 struct ifnet *ifp; 353 354 sc = device_get_softc(dev); 355 EP_ASSERT_UNLOCKED(sc); 356 ifp = sc->ifp; 357 358 if (sc->gone) 359 return (0); 360 if (bus_child_present(dev)) 361 epstop(sc); 362 363 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 364 ether_ifdetach(ifp); 365 if_free(ifp); 366 367 sc->gone = 1; 368 ep_free(dev); 369 EP_LOCK_DESTROY(sc); 370 371 return (0); 372 } 373 374 static void 375 epinit(void *xsc) 376 { 377 struct ep_softc *sc = xsc; 378 EP_LOCK(sc); 379 epinit_locked(sc); 380 EP_UNLOCK(sc); 381 } 382 383 /* 384 * The order in here seems important. Otherwise we may not receive 385 * interrupts. ?! 386 */ 387 static void 388 epinit_locked(struct ep_softc *sc) 389 { 390 struct ifnet *ifp = sc->ifp; 391 int i; 392 393 if (sc->gone) 394 return; 395 396 EP_ASSERT_LOCKED(sc); 397 EP_BUSY_WAIT(sc); 398 399 GO_WINDOW(sc, 0); 400 CSR_WRITE_2(sc, EP_COMMAND, STOP_TRANSCEIVER); 401 GO_WINDOW(sc, 4); 402 CSR_WRITE_2(sc, EP_W4_MEDIA_TYPE, DISABLE_UTP); 403 GO_WINDOW(sc, 0); 404 405 /* Disable the card */ 406 CSR_WRITE_2(sc, EP_W0_CONFIG_CTRL, 0); 407 408 /* Enable the card */ 409 CSR_WRITE_2(sc, EP_W0_CONFIG_CTRL, ENABLE_DRQ_IRQ); 410 411 GO_WINDOW(sc, 2); 412 /* Reload the ether_addr. */ 413 ep_setup_station(sc, IFP2ENADDR(sc->ifp)); 414 415 CSR_WRITE_2(sc, EP_COMMAND, RX_RESET); 416 CSR_WRITE_2(sc, EP_COMMAND, TX_RESET); 417 EP_BUSY_WAIT(sc); 418 419 /* Window 1 is operating window */ 420 GO_WINDOW(sc, 1); 421 for (i = 0; i < 31; i++) 422 CSR_READ_1(sc, EP_W1_TX_STATUS); 423 424 /* get rid of stray intr's */ 425 CSR_WRITE_2(sc, EP_COMMAND, ACK_INTR | 0xff); 426 427 CSR_WRITE_2(sc, EP_COMMAND, SET_RD_0_MASK | S_5_INTS); 428 CSR_WRITE_2(sc, EP_COMMAND, SET_INTR_MASK | S_5_INTS); 429 430 if (ifp->if_flags & IFF_PROMISC) 431 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_FILTER | FIL_INDIVIDUAL | 432 FIL_MULTICAST | FIL_BRDCST | FIL_PROMISC); 433 else 434 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_FILTER | FIL_INDIVIDUAL | 435 FIL_MULTICAST | FIL_BRDCST); 436 437 if (!sc->epb.mii_trans) 438 ep_ifmedia_upd(ifp); 439 440 CSR_WRITE_2(sc, EP_COMMAND, RX_ENABLE); 441 CSR_WRITE_2(sc, EP_COMMAND, TX_ENABLE); 442 443 ifp->if_drv_flags |= IFF_DRV_RUNNING; 444 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; /* just in case */ 445 446 #ifdef EP_LOCAL_STATS 447 sc->rx_no_first = sc->rx_no_mbuf = 448 sc->rx_overrunf = sc->rx_overrunl = sc->tx_underrun = 0; 449 #endif 450 EP_FSET(sc, F_RX_FIRST); 451 if (sc->top) { 452 m_freem(sc->top); 453 sc->top = sc->mcur = 0; 454 } 455 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH); 456 CSR_WRITE_2(sc, EP_COMMAND, SET_TX_START_THRESH | 16); 457 458 GO_WINDOW(sc, 1); 459 epstart_locked(ifp); 460 } 461 462 static void 463 epstart(struct ifnet *ifp) 464 { 465 struct ep_softc *sc; 466 sc = ifp->if_softc; 467 EP_LOCK(sc); 468 epstart_locked(ifp); 469 EP_UNLOCK(sc); 470 } 471 472 static void 473 epstart_locked(struct ifnet *ifp) 474 { 475 struct ep_softc *sc; 476 u_int len; 477 struct mbuf *m, *m0; 478 int pad; 479 480 sc = ifp->if_softc; 481 if (sc->gone) 482 return; 483 EP_ASSERT_LOCKED(sc); 484 EP_BUSY_WAIT(sc); 485 if (ifp->if_drv_flags & IFF_DRV_OACTIVE) 486 return; 487 startagain: 488 /* Sneak a peek at the next packet */ 489 IFQ_DRV_DEQUEUE(&ifp->if_snd, m0); 490 if (m0 == NULL) 491 return; 492 for (len = 0, m = m0; m != NULL; m = m->m_next) 493 len += m->m_len; 494 495 pad = (4 - len) & 3; 496 497 /* 498 * The 3c509 automatically pads short packets to minimum 499 * ethernet length, but we drop packets that are too large. 500 * Perhaps we should truncate them instead? 501 */ 502 if (len + pad > ETHER_MAX_LEN) { 503 /* packet is obviously too large: toss it */ 504 ifp->if_oerrors++; 505 m_freem(m0); 506 goto readcheck; 507 } 508 if (CSR_READ_2(sc, EP_W1_FREE_TX) < len + pad + 4) { 509 /* no room in FIFO */ 510 CSR_WRITE_2(sc, EP_COMMAND, SET_TX_AVAIL_THRESH | (len + pad + 4)); 511 /* make sure */ 512 if (CSR_READ_2(sc, EP_W1_FREE_TX) < len + pad + 4) { 513 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 514 IFQ_DRV_PREPEND(&ifp->if_snd, m0); 515 goto done; 516 } 517 } else 518 CSR_WRITE_2(sc, EP_COMMAND, 519 SET_TX_AVAIL_THRESH | EP_THRESH_DISABLE); 520 521 /* XXX 4.x and earlier would splhigh here */ 522 523 CSR_WRITE_2(sc, EP_W1_TX_PIO_WR_1, len); 524 /* Second dword meaningless */ 525 CSR_WRITE_2(sc, EP_W1_TX_PIO_WR_1, 0x0); 526 527 if (EP_FTST(sc, F_ACCESS_32_BITS)) { 528 for (m = m0; m != NULL; m = m->m_next) { 529 if (m->m_len > 3) 530 CSR_WRITE_MULTI_4(sc, EP_W1_TX_PIO_WR_1, 531 mtod(m, uint32_t *), m->m_len / 4); 532 if (m->m_len & 3) 533 CSR_WRITE_MULTI_1(sc, EP_W1_TX_PIO_WR_1, 534 mtod(m, uint8_t *)+(m->m_len & (~3)), 535 m->m_len & 3); 536 } 537 } else { 538 for (m = m0; m != NULL; m = m->m_next) { 539 if (m->m_len > 1) 540 CSR_WRITE_MULTI_2(sc, EP_W1_TX_PIO_WR_1, 541 mtod(m, uint16_t *), m->m_len / 2); 542 if (m->m_len & 1) 543 CSR_WRITE_1(sc, EP_W1_TX_PIO_WR_1, 544 *(mtod(m, uint8_t *)+m->m_len - 1)); 545 } 546 } 547 548 while (pad--) 549 CSR_WRITE_1(sc, EP_W1_TX_PIO_WR_1, 0); /* Padding */ 550 551 /* XXX and drop splhigh here */ 552 553 BPF_MTAP(ifp, m0); 554 555 ifp->if_timer = 2; 556 ifp->if_opackets++; 557 m_freem(m0); 558 559 /* 560 * Is another packet coming in? We don't want to overflow 561 * the tiny RX fifo. 562 */ 563 readcheck: 564 if (CSR_READ_2(sc, EP_W1_RX_STATUS) & RX_BYTES_MASK) { 565 /* 566 * we check if we have packets left, in that case 567 * we prepare to come back later 568 */ 569 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) 570 CSR_WRITE_2(sc, EP_COMMAND, SET_TX_AVAIL_THRESH | 8); 571 goto done; 572 } 573 goto startagain; 574 done:; 575 return; 576 } 577 578 void 579 ep_intr(void *arg) 580 { 581 struct ep_softc *sc; 582 int status; 583 struct ifnet *ifp; 584 585 sc = (struct ep_softc *) arg; 586 EP_LOCK(sc); 587 /* XXX 4.x splbio'd here to reduce interruptability */ 588 589 /* 590 * quick fix: Try to detect an interrupt when the card goes away. 591 */ 592 if (sc->gone || CSR_READ_2(sc, EP_STATUS) == 0xffff) { 593 EP_UNLOCK(sc); 594 return; 595 } 596 ifp = sc->ifp; 597 598 CSR_WRITE_2(sc, EP_COMMAND, SET_INTR_MASK); /* disable all Ints */ 599 600 rescan: 601 602 while ((status = CSR_READ_2(sc, EP_STATUS)) & S_5_INTS) { 603 604 /* first acknowledge all interrupt sources */ 605 CSR_WRITE_2(sc, EP_COMMAND, ACK_INTR | (status & S_MASK)); 606 607 if (status & (S_RX_COMPLETE | S_RX_EARLY)) 608 epread(sc); 609 if (status & S_TX_AVAIL) { 610 /* we need ACK */ 611 ifp->if_timer = 0; 612 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 613 GO_WINDOW(sc, 1); 614 CSR_READ_2(sc, EP_W1_FREE_TX); 615 epstart_locked(ifp); 616 } 617 if (status & S_CARD_FAILURE) { 618 ifp->if_timer = 0; 619 #ifdef EP_LOCAL_STATS 620 device_printf(sc->dev, "\n\tStatus: %x\n", status); 621 GO_WINDOW(sc, 4); 622 printf("\tFIFO Diagnostic: %x\n", 623 CSR_READ_2(sc, EP_W4_FIFO_DIAG)); 624 printf("\tStat: %x\n", sc->stat); 625 printf("\tIpackets=%d, Opackets=%d\n", 626 ifp->if_ipackets, ifp->if_opackets); 627 printf("\tNOF=%d, NOMB=%d, RXOF=%d, RXOL=%d, TXU=%d\n", 628 sc->rx_no_first, sc->rx_no_mbuf, sc->rx_overrunf, 629 sc->rx_overrunl, sc->tx_underrun); 630 #else 631 632 #ifdef DIAGNOSTIC 633 device_printf(sc->dev, 634 "Status: %x (input buffer overflow)\n", status); 635 #else 636 ++ifp->if_ierrors; 637 #endif 638 639 #endif 640 epinit_locked(sc); 641 EP_UNLOCK(sc); 642 return; 643 } 644 if (status & S_TX_COMPLETE) { 645 ifp->if_timer = 0; 646 /* 647 * We need ACK. We do it at the end. 648 * 649 * We need to read TX_STATUS until we get a 650 * 0 status in order to turn off the interrupt flag. 651 */ 652 while ((status = CSR_READ_1(sc, EP_W1_TX_STATUS)) & 653 TXS_COMPLETE) { 654 if (status & TXS_SUCCES_INTR_REQ) 655 ; /* nothing */ 656 else if (status & 657 (TXS_UNDERRUN | TXS_JABBER | 658 TXS_MAX_COLLISION)) { 659 CSR_WRITE_2(sc, EP_COMMAND, TX_RESET); 660 if (status & TXS_UNDERRUN) { 661 #ifdef EP_LOCAL_STATS 662 sc->tx_underrun++; 663 #endif 664 } else { 665 if (status & TXS_JABBER); 666 else 667 ++ifp->if_collisions; 668 /* TXS_MAX_COLLISION 669 * we shouldn't get 670 * here 671 */ 672 } 673 ++ifp->if_oerrors; 674 CSR_WRITE_2(sc, EP_COMMAND, TX_ENABLE); 675 /* 676 * To have a tx_avail_int but giving 677 * the chance to the Reception 678 */ 679 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) 680 CSR_WRITE_2(sc, EP_COMMAND, 681 SET_TX_AVAIL_THRESH | 8); 682 } 683 /* pops up the next status */ 684 CSR_WRITE_1(sc, EP_W1_TX_STATUS, 0x0); 685 } /* while */ 686 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 687 GO_WINDOW(sc, 1); 688 CSR_READ_2(sc, EP_W1_FREE_TX); 689 epstart_locked(ifp); 690 } /* end TX_COMPLETE */ 691 } 692 693 CSR_WRITE_2(sc, EP_COMMAND, C_INTR_LATCH); /* ACK int Latch */ 694 695 if ((status = CSR_READ_2(sc, EP_STATUS)) & S_5_INTS) 696 goto rescan; 697 698 /* re-enable Ints */ 699 CSR_WRITE_2(sc, EP_COMMAND, SET_INTR_MASK | S_5_INTS); 700 EP_UNLOCK(sc); 701 } 702 703 static void 704 epread(struct ep_softc *sc) 705 { 706 struct mbuf *top, *mcur, *m; 707 struct ifnet *ifp; 708 int lenthisone; 709 short rx_fifo2, status; 710 short rx_fifo; 711 712 /* XXX Must be called with sc locked */ 713 714 ifp = sc->ifp; 715 status = CSR_READ_2(sc, EP_W1_RX_STATUS); 716 717 read_again: 718 719 if (status & ERR_RX) { 720 ++ifp->if_ierrors; 721 if (status & ERR_RX_OVERRUN) { 722 /* 723 * We can think the rx latency is actually 724 * greather than we expect 725 */ 726 #ifdef EP_LOCAL_STATS 727 if (EP_FTST(sc, F_RX_FIRST)) 728 sc->rx_overrunf++; 729 else 730 sc->rx_overrunl++; 731 #endif 732 } 733 goto out; 734 } 735 rx_fifo = rx_fifo2 = status & RX_BYTES_MASK; 736 737 if (EP_FTST(sc, F_RX_FIRST)) { 738 MGETHDR(m, M_DONTWAIT, MT_DATA); 739 if (!m) 740 goto out; 741 if (rx_fifo >= MINCLSIZE) 742 MCLGET(m, M_DONTWAIT); 743 sc->top = sc->mcur = top = m; 744 #define EROUND ((sizeof(struct ether_header) + 3) & ~3) 745 #define EOFF (EROUND - sizeof(struct ether_header)) 746 top->m_data += EOFF; 747 748 /* Read what should be the header. */ 749 CSR_READ_MULTI_2(sc, EP_W1_RX_PIO_RD_1, 750 mtod(top, uint16_t *), sizeof(struct ether_header) / 2); 751 top->m_len = sizeof(struct ether_header); 752 rx_fifo -= sizeof(struct ether_header); 753 sc->cur_len = rx_fifo2; 754 } else { 755 /* come here if we didn't have a complete packet last time */ 756 top = sc->top; 757 m = sc->mcur; 758 sc->cur_len += rx_fifo2; 759 } 760 761 /* Reads what is left in the RX FIFO */ 762 while (rx_fifo > 0) { 763 lenthisone = min(rx_fifo, M_TRAILINGSPACE(m)); 764 if (lenthisone == 0) { /* no room in this one */ 765 mcur = m; 766 MGET(m, M_DONTWAIT, MT_DATA); 767 if (!m) 768 goto out; 769 if (rx_fifo >= MINCLSIZE) 770 MCLGET(m, M_DONTWAIT); 771 m->m_len = 0; 772 mcur->m_next = m; 773 lenthisone = min(rx_fifo, M_TRAILINGSPACE(m)); 774 } 775 if (EP_FTST(sc, F_ACCESS_32_BITS)) { 776 /* default for EISA configured cards */ 777 CSR_READ_MULTI_4(sc, EP_W1_RX_PIO_RD_1, 778 (uint32_t *)(mtod(m, caddr_t)+m->m_len), 779 lenthisone / 4); 780 m->m_len += (lenthisone & ~3); 781 if (lenthisone & 3) 782 CSR_READ_MULTI_1(sc, EP_W1_RX_PIO_RD_1, 783 mtod(m, caddr_t)+m->m_len, lenthisone & 3); 784 m->m_len += (lenthisone & 3); 785 } else { 786 CSR_READ_MULTI_2(sc, EP_W1_RX_PIO_RD_1, 787 (uint16_t *)(mtod(m, caddr_t)+m->m_len), 788 lenthisone / 2); 789 m->m_len += lenthisone; 790 if (lenthisone & 1) 791 *(mtod(m, caddr_t)+m->m_len - 1) = 792 CSR_READ_1(sc, EP_W1_RX_PIO_RD_1); 793 } 794 rx_fifo -= lenthisone; 795 } 796 797 if (status & ERR_RX_INCOMPLETE) { 798 /* we haven't received the complete packet */ 799 sc->mcur = m; 800 #ifdef EP_LOCAL_STATS 801 /* to know how often we come here */ 802 sc->rx_no_first++; 803 #endif 804 EP_FRST(sc, F_RX_FIRST); 805 status = CSR_READ_2(sc, EP_W1_RX_STATUS); 806 if (!status & ERR_RX_INCOMPLETE) { 807 /* 808 * We see if by now, the packet has completly 809 * arrived 810 */ 811 goto read_again; 812 } 813 CSR_WRITE_2(sc, EP_COMMAND, 814 SET_RX_EARLY_THRESH | RX_NEXT_EARLY_THRESH); 815 return; 816 } 817 CSR_WRITE_2(sc, EP_COMMAND, RX_DISCARD_TOP_PACK); 818 ++ifp->if_ipackets; 819 EP_FSET(sc, F_RX_FIRST); 820 top->m_pkthdr.rcvif = sc->ifp; 821 top->m_pkthdr.len = sc->cur_len; 822 823 /* 824 * Drop locks before calling if_input() since it may re-enter 825 * ep_start() in the netisr case. This would result in a 826 * lock reversal. Better performance might be obtained by 827 * chaining all packets received, dropping the lock, and then 828 * calling if_input() on each one. 829 */ 830 EP_UNLOCK(sc); 831 (*ifp->if_input) (ifp, top); 832 EP_LOCK(sc); 833 sc->top = 0; 834 EP_BUSY_WAIT(sc); 835 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH); 836 return; 837 838 out: 839 CSR_WRITE_2(sc, EP_COMMAND, RX_DISCARD_TOP_PACK); 840 if (sc->top) { 841 m_freem(sc->top); 842 sc->top = 0; 843 #ifdef EP_LOCAL_STATS 844 sc->rx_no_mbuf++; 845 #endif 846 } 847 EP_FSET(sc, F_RX_FIRST); 848 EP_BUSY_WAIT(sc); 849 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_EARLY_THRESH | RX_INIT_EARLY_THRESH); 850 } 851 852 static int 853 ep_ifmedia_upd(struct ifnet *ifp) 854 { 855 struct ep_softc *sc = ifp->if_softc; 856 int i = 0, j; 857 858 GO_WINDOW(sc, 0); 859 CSR_WRITE_2(sc, EP_COMMAND, STOP_TRANSCEIVER); 860 GO_WINDOW(sc, 4); 861 CSR_WRITE_2(sc, EP_W4_MEDIA_TYPE, DISABLE_UTP); 862 GO_WINDOW(sc, 0); 863 864 switch (IFM_SUBTYPE(sc->ifmedia.ifm_media)) { 865 case IFM_10_T: 866 if (sc->ep_connectors & UTP) { 867 i = ACF_CONNECTOR_UTP; 868 GO_WINDOW(sc, 4); 869 CSR_WRITE_2(sc, EP_W4_MEDIA_TYPE, ENABLE_UTP); 870 } 871 break; 872 case IFM_10_2: 873 if (sc->ep_connectors & BNC) { 874 i = ACF_CONNECTOR_BNC; 875 CSR_WRITE_2(sc, EP_COMMAND, START_TRANSCEIVER); 876 DELAY(DELAY_MULTIPLE * 1000); 877 } 878 break; 879 case IFM_10_5: 880 if (sc->ep_connectors & AUI) 881 i = ACF_CONNECTOR_AUI; 882 break; 883 default: 884 i = sc->ep_connector; 885 device_printf(sc->dev, 886 "strange connector type in EEPROM: assuming AUI\n"); 887 } 888 889 GO_WINDOW(sc, 0); 890 j = CSR_READ_2(sc, EP_W0_ADDRESS_CFG) & 0x3fff; 891 CSR_WRITE_2(sc, EP_W0_ADDRESS_CFG, j | (i << ACF_CONNECTOR_BITS)); 892 893 return (0); 894 } 895 896 static void 897 ep_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr) 898 { 899 struct ep_softc *sc = ifp->if_softc; 900 901 ifmr->ifm_active = sc->ifmedia.ifm_media; 902 } 903 904 static int 905 epioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 906 { 907 struct ep_softc *sc = ifp->if_softc; 908 struct ifreq *ifr = (struct ifreq *) data; 909 int error = 0; 910 911 switch (cmd) { 912 case SIOCSIFFLAGS: 913 EP_LOCK(sc); 914 if (((ifp->if_flags & IFF_UP) == 0) && 915 (ifp->if_drv_flags & IFF_DRV_RUNNING)) { 916 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 917 epstop(sc); 918 } else 919 /* reinitialize card on any parameter change */ 920 epinit_locked(sc); 921 EP_UNLOCK(sc); 922 break; 923 #ifdef notdef 924 case SIOCGHWADDR: 925 bcopy((caddr_t)sc->sc_addr, (caddr_t)&ifr->ifr_data, 926 sizeof(sc->sc_addr)); 927 break; 928 #endif 929 case SIOCADDMULTI: 930 case SIOCDELMULTI: 931 /* 932 * The Etherlink III has no programmable multicast 933 * filter. We always initialize the card to be 934 * promiscuous to multicast, since we're always a 935 * member of the ALL-SYSTEMS group, so there's no 936 * need to process SIOC*MULTI requests. 937 */ 938 error = 0; 939 break; 940 case SIOCSIFMEDIA: 941 case SIOCGIFMEDIA: 942 if (!sc->epb.mii_trans) 943 error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, cmd); 944 else 945 error = EINVAL; 946 break; 947 default: 948 error = ether_ioctl(ifp, cmd, data); 949 break; 950 } 951 return (error); 952 } 953 954 static void 955 epwatchdog(struct ifnet *ifp) 956 { 957 struct ep_softc *sc = ifp->if_softc; 958 959 if (sc->gone) 960 return; 961 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 962 epstart(ifp); 963 ep_intr(ifp->if_softc); 964 } 965 966 static void 967 epstop(struct ep_softc *sc) 968 { 969 if (sc->gone) 970 return; 971 CSR_WRITE_2(sc, EP_COMMAND, RX_DISABLE); 972 CSR_WRITE_2(sc, EP_COMMAND, RX_DISCARD_TOP_PACK); 973 EP_BUSY_WAIT(sc); 974 975 CSR_WRITE_2(sc, EP_COMMAND, TX_DISABLE); 976 CSR_WRITE_2(sc, EP_COMMAND, STOP_TRANSCEIVER); 977 DELAY(800); 978 979 CSR_WRITE_2(sc, EP_COMMAND, RX_RESET); 980 EP_BUSY_WAIT(sc); 981 CSR_WRITE_2(sc, EP_COMMAND, TX_RESET); 982 EP_BUSY_WAIT(sc); 983 984 CSR_WRITE_2(sc, EP_COMMAND, C_INTR_LATCH); 985 CSR_WRITE_2(sc, EP_COMMAND, SET_RD_0_MASK); 986 CSR_WRITE_2(sc, EP_COMMAND, SET_INTR_MASK); 987 CSR_WRITE_2(sc, EP_COMMAND, SET_RX_FILTER); 988 }
Cache object: a34cbc3374dc31325512ec777f871fe6
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]