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/arm/xscale/ixp425/if_npe.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) 2006-2008 Sam Leffler. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 23 */ 24 25 #include <sys/cdefs.h> 26 __FBSDID("$FreeBSD$"); 27 28 /* 29 * Intel XScale NPE Ethernet driver. 30 * 31 * This driver handles the two ports present on the IXP425. 32 * Packet processing is done by the Network Processing Engines 33 * (NPE's) that work together with a MAC and PHY. The MAC 34 * is also mapped to the XScale cpu; the PHY is accessed via 35 * the MAC. NPE-XScale communication happens through h/w 36 * queues managed by the Q Manager block. 37 * 38 * The code here replaces the ethAcc, ethMii, and ethDB classes 39 * in the Intel Access Library (IAL) and the OS-specific driver. 40 * 41 * XXX add vlan support 42 */ 43 #ifdef HAVE_KERNEL_OPTION_HEADERS 44 #include "opt_device_polling.h" 45 #endif 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/bus.h> 50 #include <sys/kernel.h> 51 #include <sys/mbuf.h> 52 #include <sys/malloc.h> 53 #include <sys/module.h> 54 #include <sys/rman.h> 55 #include <sys/socket.h> 56 #include <sys/sockio.h> 57 #include <sys/sysctl.h> 58 #include <sys/endian.h> 59 #include <machine/bus.h> 60 61 #include <net/ethernet.h> 62 #include <net/if.h> 63 #include <net/if_arp.h> 64 #include <net/if_dl.h> 65 #include <net/if_media.h> 66 #include <net/if_mib.h> 67 #include <net/if_types.h> 68 #include <net/if_var.h> 69 70 #ifdef INET 71 #include <netinet/in.h> 72 #include <netinet/in_systm.h> 73 #include <netinet/in_var.h> 74 #include <netinet/ip.h> 75 #endif 76 77 #include <net/bpf.h> 78 #include <net/bpfdesc.h> 79 80 #include <arm/xscale/ixp425/ixp425reg.h> 81 #include <arm/xscale/ixp425/ixp425var.h> 82 #include <arm/xscale/ixp425/ixp425_qmgr.h> 83 #include <arm/xscale/ixp425/ixp425_npevar.h> 84 85 #include <dev/mii/mii.h> 86 #include <dev/mii/miivar.h> 87 #include <arm/xscale/ixp425/if_npereg.h> 88 89 #include <machine/armreg.h> 90 91 #include "miibus_if.h" 92 93 /* 94 * XXX: For the main bus dma tag. Can go away if the new method to get the 95 * dma tag from the parent got MFC'd into RELENG_6. 96 */ 97 extern struct ixp425_softc *ixp425_softc; 98 99 struct npebuf { 100 struct npebuf *ix_next; /* chain to next buffer */ 101 void *ix_m; /* backpointer to mbuf */ 102 bus_dmamap_t ix_map; /* bus dma map for associated data */ 103 struct npehwbuf *ix_hw; /* associated h/w block */ 104 uint32_t ix_neaddr; /* phys address of ix_hw */ 105 }; 106 107 struct npedma { 108 const char* name; 109 int nbuf; /* # npebuf's allocated */ 110 bus_dma_tag_t mtag; /* bus dma tag for mbuf data */ 111 struct npehwbuf *hwbuf; /* NPE h/w buffers */ 112 bus_dma_tag_t buf_tag; /* tag+map for NPE buffers */ 113 bus_dmamap_t buf_map; 114 bus_addr_t buf_phys; /* phys addr of buffers */ 115 struct npebuf *buf; /* s/w buffers (1-1 w/ h/w) */ 116 }; 117 118 struct npe_softc { 119 /* XXX mii requires this be first; do not move! */ 120 struct ifnet *sc_ifp; /* ifnet pointer */ 121 struct mtx sc_mtx; /* basically a perimeter lock */ 122 device_t sc_dev; 123 bus_space_tag_t sc_iot; 124 bus_space_handle_t sc_ioh; /* MAC register window */ 125 device_t sc_mii; /* child miibus */ 126 bus_space_handle_t sc_miih; /* MII register window */ 127 int sc_npeid; 128 struct ixpnpe_softc *sc_npe; /* NPE support */ 129 int sc_debug; /* DPRINTF* control */ 130 int sc_tickinterval; 131 struct callout tick_ch; /* Tick callout */ 132 int npe_watchdog_timer; 133 struct npedma txdma; 134 struct npebuf *tx_free; /* list of free tx buffers */ 135 struct npedma rxdma; 136 bus_addr_t buf_phys; /* XXX for returning a value */ 137 int rx_qid; /* rx qid */ 138 int rx_freeqid; /* rx free buffers qid */ 139 int tx_qid; /* tx qid */ 140 int tx_doneqid; /* tx completed qid */ 141 struct ifmib_iso_8802_3 mibdata; 142 bus_dma_tag_t sc_stats_tag; /* bus dma tag for stats block */ 143 struct npestats *sc_stats; 144 bus_dmamap_t sc_stats_map; 145 bus_addr_t sc_stats_phys; /* phys addr of sc_stats */ 146 struct npestats sc_totals; /* accumulated sc_stats */ 147 }; 148 149 /* 150 * Static configuration for IXP425. The tx and 151 * rx free Q id's are fixed by the NPE microcode. The 152 * rx Q id's are programmed to be separate to simplify 153 * multi-port processing. It may be better to handle 154 * all traffic through one Q (as done by the Intel drivers). 155 * 156 * Note that the PHY's are accessible only from MAC B on the 157 * IXP425 and from MAC C on other devices. This and other 158 * platform-specific assumptions are handled with hints. 159 */ 160 static const struct { 161 uint32_t macbase; 162 uint32_t miibase; 163 int phy; /* phy id */ 164 uint8_t rx_qid; 165 uint8_t rx_freeqid; 166 uint8_t tx_qid; 167 uint8_t tx_doneqid; 168 } npeconfig[NPE_MAX] = { 169 [NPE_A] = { 170 .macbase = IXP435_MAC_A_HWBASE, 171 .miibase = IXP425_MAC_C_HWBASE, 172 .phy = 2, 173 .rx_qid = 4, 174 .rx_freeqid = 26, 175 .tx_qid = 23, 176 .tx_doneqid = 31 177 }, 178 [NPE_B] = { 179 .macbase = IXP425_MAC_B_HWBASE, 180 .miibase = IXP425_MAC_B_HWBASE, 181 .phy = 0, 182 .rx_qid = 4, 183 .rx_freeqid = 27, 184 .tx_qid = 24, 185 .tx_doneqid = 31 186 }, 187 [NPE_C] = { 188 .macbase = IXP425_MAC_C_HWBASE, 189 .miibase = IXP425_MAC_B_HWBASE, 190 .phy = 1, 191 .rx_qid = 12, 192 .rx_freeqid = 28, 193 .tx_qid = 25, 194 .tx_doneqid = 31 195 }, 196 }; 197 static struct npe_softc *npes[NPE_MAX]; /* NB: indexed by npeid */ 198 199 static __inline uint32_t 200 RD4(struct npe_softc *sc, bus_size_t off) 201 { 202 return bus_space_read_4(sc->sc_iot, sc->sc_ioh, off); 203 } 204 205 static __inline void 206 WR4(struct npe_softc *sc, bus_size_t off, uint32_t val) 207 { 208 bus_space_write_4(sc->sc_iot, sc->sc_ioh, off, val); 209 } 210 211 #define NPE_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx) 212 #define NPE_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx) 213 #define NPE_LOCK_INIT(_sc) \ 214 mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->sc_dev), \ 215 MTX_NETWORK_LOCK, MTX_DEF) 216 #define NPE_LOCK_DESTROY(_sc) mtx_destroy(&_sc->sc_mtx); 217 #define NPE_ASSERT_LOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_OWNED); 218 #define NPE_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_NOTOWNED); 219 220 static devclass_t npe_devclass; 221 222 static int override_npeid(device_t, const char *resname, int *val); 223 static int npe_activate(device_t dev); 224 static void npe_deactivate(device_t dev); 225 static int npe_ifmedia_update(struct ifnet *ifp); 226 static void npe_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr); 227 static void npe_setmac(struct npe_softc *sc, u_char *eaddr); 228 static void npe_getmac(struct npe_softc *sc, u_char *eaddr); 229 static void npe_txdone(int qid, void *arg); 230 static int npe_rxbuf_init(struct npe_softc *, struct npebuf *, 231 struct mbuf *); 232 static int npe_rxdone(int qid, void *arg); 233 static void npeinit(void *); 234 static void npestart_locked(struct ifnet *); 235 static void npestart(struct ifnet *); 236 static void npestop(struct npe_softc *); 237 static void npewatchdog(struct npe_softc *); 238 static int npeioctl(struct ifnet * ifp, u_long, caddr_t); 239 240 static int npe_setrxqosentry(struct npe_softc *, int classix, 241 int trafclass, int qid); 242 static int npe_setportaddress(struct npe_softc *, const uint8_t mac[]); 243 static int npe_setfirewallmode(struct npe_softc *, int onoff); 244 static int npe_updatestats(struct npe_softc *); 245 #if 0 246 static int npe_getstats(struct npe_softc *); 247 static uint32_t npe_getimageid(struct npe_softc *); 248 static int npe_setloopback(struct npe_softc *, int ena); 249 #endif 250 251 /* NB: all tx done processing goes through one queue */ 252 static int tx_doneqid = -1; 253 254 static SYSCTL_NODE(_hw, OID_AUTO, npe, CTLFLAG_RD, 0, 255 "IXP4XX NPE driver parameters"); 256 257 static int npe_debug = 0; 258 SYSCTL_INT(_hw_npe, OID_AUTO, debug, CTLFLAG_RWTUN, &npe_debug, 259 0, "IXP4XX NPE network interface debug msgs"); 260 #define DPRINTF(sc, fmt, ...) do { \ 261 if (sc->sc_debug) device_printf(sc->sc_dev, fmt, __VA_ARGS__); \ 262 } while (0) 263 #define DPRINTFn(n, sc, fmt, ...) do { \ 264 if (sc->sc_debug >= n) device_printf(sc->sc_dev, fmt, __VA_ARGS__);\ 265 } while (0) 266 static int npe_tickinterval = 3; /* npe_tick frequency (secs) */ 267 SYSCTL_INT(_hw_npe, OID_AUTO, tickinterval, CTLFLAG_RDTUN, &npe_tickinterval, 268 0, "periodic work interval (secs)"); 269 270 static int npe_rxbuf = 64; /* # rx buffers to allocate */ 271 SYSCTL_INT(_hw_npe, OID_AUTO, rxbuf, CTLFLAG_RDTUN, &npe_rxbuf, 272 0, "rx buffers allocated"); 273 static int npe_txbuf = 128; /* # tx buffers to allocate */ 274 SYSCTL_INT(_hw_npe, OID_AUTO, txbuf, CTLFLAG_RDTUN, &npe_txbuf, 275 0, "tx buffers allocated"); 276 277 static int 278 unit2npeid(int unit) 279 { 280 static const int npeidmap[2][3] = { 281 /* on 425 A is for HSS, B & C are for Ethernet */ 282 { NPE_B, NPE_C, -1 }, /* IXP425 */ 283 /* 435 only has A & C, order C then A */ 284 { NPE_C, NPE_A, -1 }, /* IXP435 */ 285 }; 286 /* XXX check feature register instead */ 287 return (unit < 3 ? npeidmap[ 288 (cpu_ident() & CPU_ID_CPU_MASK) == CPU_ID_IXP435][unit] : -1); 289 } 290 291 static int 292 npe_probe(device_t dev) 293 { 294 static const char *desc[NPE_MAX] = { 295 [NPE_A] = "IXP NPE-A", 296 [NPE_B] = "IXP NPE-B", 297 [NPE_C] = "IXP NPE-C" 298 }; 299 int unit = device_get_unit(dev); 300 int npeid; 301 302 if (unit > 2 || 303 (ixp4xx_read_feature_bits() & 304 (unit == 0 ? EXP_FCTRL_ETH0 : EXP_FCTRL_ETH1)) == 0) 305 return EINVAL; 306 307 npeid = -1; 308 if (!override_npeid(dev, "npeid", &npeid)) 309 npeid = unit2npeid(unit); 310 if (npeid == -1) { 311 device_printf(dev, "unit %d not supported\n", unit); 312 return EINVAL; 313 } 314 device_set_desc(dev, desc[npeid]); 315 return 0; 316 } 317 318 static int 319 npe_attach(device_t dev) 320 { 321 struct npe_softc *sc = device_get_softc(dev); 322 struct ixp425_softc *sa = device_get_softc(device_get_parent(dev)); 323 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev); 324 struct sysctl_oid *tree = device_get_sysctl_tree(dev); 325 struct ifnet *ifp; 326 int error; 327 u_char eaddr[6]; 328 329 sc->sc_dev = dev; 330 sc->sc_iot = sa->sc_iot; 331 NPE_LOCK_INIT(sc); 332 callout_init_mtx(&sc->tick_ch, &sc->sc_mtx, 0); 333 sc->sc_debug = npe_debug; 334 sc->sc_tickinterval = npe_tickinterval; 335 336 ifp = if_alloc(IFT_ETHER); 337 if (ifp == NULL) { 338 device_printf(dev, "cannot allocate ifnet\n"); 339 error = EIO; /* XXX */ 340 goto out; 341 } 342 /* NB: must be setup prior to invoking mii code */ 343 sc->sc_ifp = ifp; 344 345 error = npe_activate(dev); 346 if (error) { 347 device_printf(dev, "cannot activate npe\n"); 348 goto out; 349 } 350 351 npe_getmac(sc, eaddr); 352 353 ifp->if_softc = sc; 354 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 355 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 356 ifp->if_start = npestart; 357 ifp->if_ioctl = npeioctl; 358 ifp->if_init = npeinit; 359 IFQ_SET_MAXLEN(&ifp->if_snd, sc->txdma.nbuf - 1); 360 ifp->if_snd.ifq_drv_maxlen = ifqmaxlen; 361 IFQ_SET_READY(&ifp->if_snd); 362 ifp->if_linkmib = &sc->mibdata; 363 ifp->if_linkmiblen = sizeof(sc->mibdata); 364 sc->mibdata.dot3Compliance = DOT3COMPLIANCE_STATS; 365 /* device supports oversided vlan frames */ 366 ifp->if_capabilities |= IFCAP_VLAN_MTU; 367 ifp->if_capenable = ifp->if_capabilities; 368 #ifdef DEVICE_POLLING 369 ifp->if_capabilities |= IFCAP_POLLING; 370 #endif 371 372 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "debug", 373 CTLFLAG_RW, &sc->sc_debug, 0, "control debugging printfs"); 374 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "tickinterval", 375 CTLFLAG_RW, &sc->sc_tickinterval, 0, "periodic work frequency"); 376 SYSCTL_ADD_STRUCT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "stats", 377 CTLFLAG_RD, &sc->sc_totals, npestats, "onboard stats"); 378 379 ether_ifattach(ifp, eaddr); 380 return 0; 381 out: 382 if (ifp != NULL) 383 if_free(ifp); 384 NPE_LOCK_DESTROY(sc); 385 npe_deactivate(dev); 386 return error; 387 } 388 389 static int 390 npe_detach(device_t dev) 391 { 392 struct npe_softc *sc = device_get_softc(dev); 393 struct ifnet *ifp = sc->sc_ifp; 394 395 #ifdef DEVICE_POLLING 396 if (ifp->if_capenable & IFCAP_POLLING) 397 ether_poll_deregister(ifp); 398 #endif 399 npestop(sc); 400 if (ifp != NULL) { 401 ether_ifdetach(ifp); 402 if_free(ifp); 403 } 404 NPE_LOCK_DESTROY(sc); 405 npe_deactivate(dev); 406 return 0; 407 } 408 409 /* 410 * Compute and install the multicast filter. 411 */ 412 static void 413 npe_setmcast(struct npe_softc *sc) 414 { 415 struct ifnet *ifp = sc->sc_ifp; 416 uint8_t mask[ETHER_ADDR_LEN], addr[ETHER_ADDR_LEN]; 417 int i; 418 419 if (ifp->if_flags & IFF_PROMISC) { 420 memset(mask, 0, ETHER_ADDR_LEN); 421 memset(addr, 0, ETHER_ADDR_LEN); 422 } else if (ifp->if_flags & IFF_ALLMULTI) { 423 static const uint8_t allmulti[ETHER_ADDR_LEN] = 424 { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }; 425 memcpy(mask, allmulti, ETHER_ADDR_LEN); 426 memcpy(addr, allmulti, ETHER_ADDR_LEN); 427 } else { 428 uint8_t clr[ETHER_ADDR_LEN], set[ETHER_ADDR_LEN]; 429 struct ifmultiaddr *ifma; 430 const uint8_t *mac; 431 432 memset(clr, 0, ETHER_ADDR_LEN); 433 memset(set, 0xff, ETHER_ADDR_LEN); 434 435 if_maddr_rlock(ifp); 436 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 437 if (ifma->ifma_addr->sa_family != AF_LINK) 438 continue; 439 mac = LLADDR((struct sockaddr_dl *) ifma->ifma_addr); 440 for (i = 0; i < ETHER_ADDR_LEN; i++) { 441 clr[i] |= mac[i]; 442 set[i] &= mac[i]; 443 } 444 } 445 if_maddr_runlock(ifp); 446 447 for (i = 0; i < ETHER_ADDR_LEN; i++) { 448 mask[i] = set[i] | ~clr[i]; 449 addr[i] = set[i]; 450 } 451 } 452 453 /* 454 * Write the mask and address registers. 455 */ 456 for (i = 0; i < ETHER_ADDR_LEN; i++) { 457 WR4(sc, NPE_MAC_ADDR_MASK(i), mask[i]); 458 WR4(sc, NPE_MAC_ADDR(i), addr[i]); 459 } 460 } 461 462 static void 463 npe_getaddr(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 464 { 465 struct npe_softc *sc; 466 467 if (error != 0) 468 return; 469 sc = (struct npe_softc *)arg; 470 sc->buf_phys = segs[0].ds_addr; 471 } 472 473 static int 474 npe_dma_setup(struct npe_softc *sc, struct npedma *dma, 475 const char *name, int nbuf, int maxseg) 476 { 477 int error, i; 478 479 memset(dma, 0, sizeof(*dma)); 480 481 dma->name = name; 482 dma->nbuf = nbuf; 483 484 /* DMA tag for mapped mbufs */ 485 error = bus_dma_tag_create(ixp425_softc->sc_dmat, 1, 0, 486 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 487 MCLBYTES, maxseg, MCLBYTES, 0, 488 busdma_lock_mutex, &sc->sc_mtx, &dma->mtag); 489 if (error != 0) { 490 device_printf(sc->sc_dev, "unable to create %s mbuf dma tag, " 491 "error %u\n", dma->name, error); 492 return error; 493 } 494 495 /* DMA tag and map for the NPE buffers */ 496 error = bus_dma_tag_create(ixp425_softc->sc_dmat, sizeof(uint32_t), 0, 497 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 498 nbuf * sizeof(struct npehwbuf), 1, 499 nbuf * sizeof(struct npehwbuf), 0, 500 busdma_lock_mutex, &sc->sc_mtx, &dma->buf_tag); 501 if (error != 0) { 502 device_printf(sc->sc_dev, 503 "unable to create %s npebuf dma tag, error %u\n", 504 dma->name, error); 505 return error; 506 } 507 if (bus_dmamem_alloc(dma->buf_tag, (void **)&dma->hwbuf, 508 BUS_DMA_NOWAIT | BUS_DMA_ZERO | BUS_DMA_COHERENT, 509 &dma->buf_map) != 0) { 510 device_printf(sc->sc_dev, 511 "unable to allocate memory for %s h/w buffers, error %u\n", 512 dma->name, error); 513 return error; 514 } 515 /* XXX M_TEMP */ 516 dma->buf = malloc(nbuf * sizeof(struct npebuf), M_TEMP, M_NOWAIT | M_ZERO); 517 if (dma->buf == NULL) { 518 device_printf(sc->sc_dev, 519 "unable to allocate memory for %s s/w buffers\n", 520 dma->name); 521 return error; 522 } 523 if (bus_dmamap_load(dma->buf_tag, dma->buf_map, 524 dma->hwbuf, nbuf*sizeof(struct npehwbuf), npe_getaddr, sc, 0) != 0) { 525 device_printf(sc->sc_dev, 526 "unable to map memory for %s h/w buffers, error %u\n", 527 dma->name, error); 528 return error; 529 } 530 dma->buf_phys = sc->buf_phys; 531 for (i = 0; i < dma->nbuf; i++) { 532 struct npebuf *npe = &dma->buf[i]; 533 struct npehwbuf *hw = &dma->hwbuf[i]; 534 535 /* calculate offset to shared area */ 536 npe->ix_neaddr = dma->buf_phys + 537 ((uintptr_t)hw - (uintptr_t)dma->hwbuf); 538 KASSERT((npe->ix_neaddr & 0x1f) == 0, 539 ("ixpbuf misaligned, PA 0x%x", npe->ix_neaddr)); 540 error = bus_dmamap_create(dma->mtag, BUS_DMA_NOWAIT, 541 &npe->ix_map); 542 if (error != 0) { 543 device_printf(sc->sc_dev, 544 "unable to create dmamap for %s buffer %u, " 545 "error %u\n", dma->name, i, error); 546 return error; 547 } 548 npe->ix_hw = hw; 549 } 550 bus_dmamap_sync(dma->buf_tag, dma->buf_map, BUS_DMASYNC_PREWRITE); 551 return 0; 552 } 553 554 static void 555 npe_dma_destroy(struct npe_softc *sc, struct npedma *dma) 556 { 557 int i; 558 559 if (dma->hwbuf != NULL) { 560 for (i = 0; i < dma->nbuf; i++) { 561 struct npebuf *npe = &dma->buf[i]; 562 bus_dmamap_destroy(dma->mtag, npe->ix_map); 563 } 564 bus_dmamap_unload(dma->buf_tag, dma->buf_map); 565 bus_dmamem_free(dma->buf_tag, dma->hwbuf, dma->buf_map); 566 } 567 if (dma->buf != NULL) 568 free(dma->buf, M_TEMP); 569 if (dma->buf_tag) 570 bus_dma_tag_destroy(dma->buf_tag); 571 if (dma->mtag) 572 bus_dma_tag_destroy(dma->mtag); 573 memset(dma, 0, sizeof(*dma)); 574 } 575 576 static int 577 override_addr(device_t dev, const char *resname, int *base) 578 { 579 int unit = device_get_unit(dev); 580 const char *resval; 581 582 /* XXX warn for wrong hint type */ 583 if (resource_string_value("npe", unit, resname, &resval) != 0) 584 return 0; 585 switch (resval[0]) { 586 case 'A': 587 *base = IXP435_MAC_A_HWBASE; 588 break; 589 case 'B': 590 *base = IXP425_MAC_B_HWBASE; 591 break; 592 case 'C': 593 *base = IXP425_MAC_C_HWBASE; 594 break; 595 default: 596 device_printf(dev, "Warning, bad value %s for " 597 "npe.%d.%s ignored\n", resval, unit, resname); 598 return 0; 599 } 600 if (bootverbose) 601 device_printf(dev, "using npe.%d.%s=%s override\n", 602 unit, resname, resval); 603 return 1; 604 } 605 606 static int 607 override_npeid(device_t dev, const char *resname, int *npeid) 608 { 609 int unit = device_get_unit(dev); 610 const char *resval; 611 612 /* XXX warn for wrong hint type */ 613 if (resource_string_value("npe", unit, resname, &resval) != 0) 614 return 0; 615 switch (resval[0]) { 616 case 'A': *npeid = NPE_A; break; 617 case 'B': *npeid = NPE_B; break; 618 case 'C': *npeid = NPE_C; break; 619 default: 620 device_printf(dev, "Warning, bad value %s for " 621 "npe.%d.%s ignored\n", resval, unit, resname); 622 return 0; 623 } 624 if (bootverbose) 625 device_printf(dev, "using npe.%d.%s=%s override\n", 626 unit, resname, resval); 627 return 1; 628 } 629 630 static int 631 override_unit(device_t dev, const char *resname, int *val, int min, int max) 632 { 633 int unit = device_get_unit(dev); 634 int resval; 635 636 if (resource_int_value("npe", unit, resname, &resval) != 0) 637 return 0; 638 if (!(min <= resval && resval <= max)) { 639 device_printf(dev, "Warning, bad value %d for npe.%d.%s " 640 "ignored (value must be [%d-%d])\n", resval, unit, 641 resname, min, max); 642 return 0; 643 } 644 if (bootverbose) 645 device_printf(dev, "using npe.%d.%s=%d override\n", 646 unit, resname, resval); 647 *val = resval; 648 return 1; 649 } 650 651 static void 652 npe_mac_reset(struct npe_softc *sc) 653 { 654 /* 655 * Reset MAC core. 656 */ 657 WR4(sc, NPE_MAC_CORE_CNTRL, NPE_CORE_RESET); 658 DELAY(NPE_MAC_RESET_DELAY); 659 /* configure MAC to generate MDC clock */ 660 WR4(sc, NPE_MAC_CORE_CNTRL, NPE_CORE_MDC_EN); 661 } 662 663 static int 664 npe_activate(device_t dev) 665 { 666 struct npe_softc *sc = device_get_softc(dev); 667 int error, i, macbase, miibase, phy; 668 669 /* 670 * Setup NEP ID, MAC, and MII bindings. We allow override 671 * via hints to handle unexpected board configs. 672 */ 673 if (!override_npeid(dev, "npeid", &sc->sc_npeid)) 674 sc->sc_npeid = unit2npeid(device_get_unit(dev)); 675 sc->sc_npe = ixpnpe_attach(dev, sc->sc_npeid); 676 if (sc->sc_npe == NULL) { 677 device_printf(dev, "cannot attach ixpnpe\n"); 678 return EIO; /* XXX */ 679 } 680 681 /* MAC */ 682 if (!override_addr(dev, "mac", &macbase)) 683 macbase = npeconfig[sc->sc_npeid].macbase; 684 if (bootverbose) 685 device_printf(sc->sc_dev, "MAC at 0x%x\n", macbase); 686 if (bus_space_map(sc->sc_iot, macbase, IXP425_REG_SIZE, 0, &sc->sc_ioh)) { 687 device_printf(dev, "cannot map mac registers 0x%x:0x%x\n", 688 macbase, IXP425_REG_SIZE); 689 return ENOMEM; 690 } 691 692 /* PHY */ 693 if (!override_unit(dev, "phy", &phy, 0, MII_NPHY - 1)) 694 phy = npeconfig[sc->sc_npeid].phy; 695 if (!override_addr(dev, "mii", &miibase)) 696 miibase = npeconfig[sc->sc_npeid].miibase; 697 if (bootverbose) 698 device_printf(sc->sc_dev, "MII at 0x%x\n", miibase); 699 if (miibase != macbase) { 700 /* 701 * PHY is mapped through a different MAC, setup an 702 * additional mapping for frobbing the PHY registers. 703 */ 704 if (bus_space_map(sc->sc_iot, miibase, IXP425_REG_SIZE, 0, &sc->sc_miih)) { 705 device_printf(dev, 706 "cannot map MII registers 0x%x:0x%x\n", 707 miibase, IXP425_REG_SIZE); 708 return ENOMEM; 709 } 710 } else 711 sc->sc_miih = sc->sc_ioh; 712 713 /* 714 * Load NPE firmware and start it running. 715 */ 716 error = ixpnpe_init(sc->sc_npe); 717 if (error != 0) { 718 device_printf(dev, "cannot init NPE (error %d)\n", error); 719 return error; 720 } 721 722 /* attach PHY */ 723 error = mii_attach(dev, &sc->sc_mii, sc->sc_ifp, npe_ifmedia_update, 724 npe_ifmedia_status, BMSR_DEFCAPMASK, phy, MII_OFFSET_ANY, 0); 725 if (error != 0) { 726 device_printf(dev, "attaching PHYs failed\n"); 727 return error; 728 } 729 730 error = npe_dma_setup(sc, &sc->txdma, "tx", npe_txbuf, NPE_MAXSEG); 731 if (error != 0) 732 return error; 733 error = npe_dma_setup(sc, &sc->rxdma, "rx", npe_rxbuf, 1); 734 if (error != 0) 735 return error; 736 737 /* setup statistics block */ 738 error = bus_dma_tag_create(ixp425_softc->sc_dmat, sizeof(uint32_t), 0, 739 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 740 sizeof(struct npestats), 1, sizeof(struct npestats), 0, 741 busdma_lock_mutex, &sc->sc_mtx, &sc->sc_stats_tag); 742 if (error != 0) { 743 device_printf(sc->sc_dev, "unable to create stats tag, " 744 "error %u\n", error); 745 return error; 746 } 747 if (bus_dmamem_alloc(sc->sc_stats_tag, (void **)&sc->sc_stats, 748 BUS_DMA_NOWAIT, &sc->sc_stats_map) != 0) { 749 device_printf(sc->sc_dev, 750 "unable to allocate memory for stats block, error %u\n", 751 error); 752 return error; 753 } 754 if (bus_dmamap_load(sc->sc_stats_tag, sc->sc_stats_map, 755 sc->sc_stats, sizeof(struct npestats), npe_getaddr, sc, 0) != 0) { 756 device_printf(sc->sc_dev, 757 "unable to load memory for stats block, error %u\n", 758 error); 759 return error; 760 } 761 sc->sc_stats_phys = sc->buf_phys; 762 763 /* 764 * Setup h/w rx/tx queues. There are four q's: 765 * rx inbound q of rx'd frames 766 * rx_free pool of ixpbuf's for receiving frames 767 * tx outbound q of frames to send 768 * tx_done q of tx frames that have been processed 769 * 770 * The NPE handles the actual tx/rx process and the q manager 771 * handles the queues. The driver just writes entries to the 772 * q manager mailbox's and gets callbacks when there are rx'd 773 * frames to process or tx'd frames to reap. These callbacks 774 * are controlled by the q configurations; e.g. we get a 775 * callback when tx_done has 2 or more frames to process and 776 * when the rx q has at least one frame. These setings can 777 * changed at the time the q is configured. 778 */ 779 sc->rx_qid = npeconfig[sc->sc_npeid].rx_qid; 780 ixpqmgr_qconfig(sc->rx_qid, npe_rxbuf, 0, 1, 781 IX_QMGR_Q_SOURCE_ID_NOT_E, (qconfig_hand_t *)npe_rxdone, sc); 782 sc->rx_freeqid = npeconfig[sc->sc_npeid].rx_freeqid; 783 ixpqmgr_qconfig(sc->rx_freeqid, npe_rxbuf, 0, npe_rxbuf/2, 0, NULL, sc); 784 /* 785 * Setup the NPE to direct all traffic to rx_qid. 786 * When QoS is enabled in the firmware there are 787 * 8 traffic classes; otherwise just 4. 788 */ 789 for (i = 0; i < 8; i++) 790 npe_setrxqosentry(sc, i, 0, sc->rx_qid); 791 792 /* disable firewall mode just in case (should be off) */ 793 npe_setfirewallmode(sc, 0); 794 795 sc->tx_qid = npeconfig[sc->sc_npeid].tx_qid; 796 sc->tx_doneqid = npeconfig[sc->sc_npeid].tx_doneqid; 797 ixpqmgr_qconfig(sc->tx_qid, npe_txbuf, 0, npe_txbuf, 0, NULL, sc); 798 if (tx_doneqid == -1) { 799 ixpqmgr_qconfig(sc->tx_doneqid, npe_txbuf, 0, 2, 800 IX_QMGR_Q_SOURCE_ID_NOT_E, npe_txdone, sc); 801 tx_doneqid = sc->tx_doneqid; 802 } 803 804 KASSERT(npes[sc->sc_npeid] == NULL, 805 ("npe %u already setup", sc->sc_npeid)); 806 npes[sc->sc_npeid] = sc; 807 808 return 0; 809 } 810 811 static void 812 npe_deactivate(device_t dev) 813 { 814 struct npe_softc *sc = device_get_softc(dev); 815 816 npes[sc->sc_npeid] = NULL; 817 818 /* XXX disable q's */ 819 if (sc->sc_npe != NULL) { 820 ixpnpe_stop(sc->sc_npe); 821 ixpnpe_detach(sc->sc_npe); 822 } 823 if (sc->sc_stats != NULL) { 824 bus_dmamap_unload(sc->sc_stats_tag, sc->sc_stats_map); 825 bus_dmamem_free(sc->sc_stats_tag, sc->sc_stats, 826 sc->sc_stats_map); 827 } 828 if (sc->sc_stats_tag != NULL) 829 bus_dma_tag_destroy(sc->sc_stats_tag); 830 npe_dma_destroy(sc, &sc->txdma); 831 npe_dma_destroy(sc, &sc->rxdma); 832 bus_generic_detach(sc->sc_dev); 833 if (sc->sc_mii != NULL) 834 device_delete_child(sc->sc_dev, sc->sc_mii); 835 } 836 837 /* 838 * Change media according to request. 839 */ 840 static int 841 npe_ifmedia_update(struct ifnet *ifp) 842 { 843 struct npe_softc *sc = ifp->if_softc; 844 struct mii_data *mii; 845 846 mii = device_get_softc(sc->sc_mii); 847 NPE_LOCK(sc); 848 mii_mediachg(mii); 849 /* XXX push state ourself? */ 850 NPE_UNLOCK(sc); 851 return (0); 852 } 853 854 /* 855 * Notify the world which media we're using. 856 */ 857 static void 858 npe_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr) 859 { 860 struct npe_softc *sc = ifp->if_softc; 861 struct mii_data *mii; 862 863 mii = device_get_softc(sc->sc_mii); 864 NPE_LOCK(sc); 865 mii_pollstat(mii); 866 ifmr->ifm_active = mii->mii_media_active; 867 ifmr->ifm_status = mii->mii_media_status; 868 NPE_UNLOCK(sc); 869 } 870 871 static void 872 npe_addstats(struct npe_softc *sc) 873 { 874 #define NPEADD(x) sc->sc_totals.x += be32toh(ns->x) 875 #define MIBADD(x) do { sc->mibdata.x += be32toh(ns->x); NPEADD(x); } while (0) 876 struct ifnet *ifp = sc->sc_ifp; 877 struct npestats *ns = sc->sc_stats; 878 879 MIBADD(dot3StatsAlignmentErrors); 880 MIBADD(dot3StatsFCSErrors); 881 MIBADD(dot3StatsInternalMacReceiveErrors); 882 NPEADD(RxOverrunDiscards); 883 NPEADD(RxLearnedEntryDiscards); 884 NPEADD(RxLargeFramesDiscards); 885 NPEADD(RxSTPBlockedDiscards); 886 NPEADD(RxVLANTypeFilterDiscards); 887 NPEADD(RxVLANIdFilterDiscards); 888 NPEADD(RxInvalidSourceDiscards); 889 NPEADD(RxBlackListDiscards); 890 NPEADD(RxWhiteListDiscards); 891 NPEADD(RxUnderflowEntryDiscards); 892 MIBADD(dot3StatsSingleCollisionFrames); 893 MIBADD(dot3StatsMultipleCollisionFrames); 894 MIBADD(dot3StatsDeferredTransmissions); 895 MIBADD(dot3StatsLateCollisions); 896 MIBADD(dot3StatsExcessiveCollisions); 897 MIBADD(dot3StatsInternalMacTransmitErrors); 898 MIBADD(dot3StatsCarrierSenseErrors); 899 NPEADD(TxLargeFrameDiscards); 900 NPEADD(TxVLANIdFilterDiscards); 901 902 sc->mibdata.dot3StatsFrameTooLongs += 903 be32toh(ns->RxLargeFramesDiscards) 904 + be32toh(ns->TxLargeFrameDiscards); 905 sc->mibdata.dot3StatsMissedFrames += 906 be32toh(ns->RxOverrunDiscards) 907 + be32toh(ns->RxUnderflowEntryDiscards); 908 909 if_inc_counter(ifp, IFCOUNTER_OERRORS, 910 be32toh(ns->dot3StatsInternalMacTransmitErrors) + 911 be32toh(ns->dot3StatsCarrierSenseErrors) + 912 be32toh(ns->TxVLANIdFilterDiscards)); 913 if_inc_counter(ifp, IFCOUNTER_IERRORS, 914 be32toh(ns->dot3StatsFCSErrors) + 915 be32toh(ns->dot3StatsInternalMacReceiveErrors) + 916 be32toh(ns->RxOverrunDiscards) + 917 be32toh(ns->RxUnderflowEntryDiscards)); 918 if_inc_counter(ifp, IFCOUNTER_COLLISIONS, 919 be32toh(ns->dot3StatsSingleCollisionFrames) + 920 be32toh(ns->dot3StatsMultipleCollisionFrames)); 921 #undef NPEADD 922 #undef MIBADD 923 } 924 925 static void 926 npe_tick(void *xsc) 927 { 928 #define ACK (NPE_RESETSTATS << NPE_MAC_MSGID_SHL) 929 struct npe_softc *sc = xsc; 930 struct mii_data *mii = device_get_softc(sc->sc_mii); 931 uint32_t msg[2]; 932 933 NPE_ASSERT_LOCKED(sc); 934 935 /* 936 * NB: to avoid sleeping with the softc lock held we 937 * split the NPE msg processing into two parts. The 938 * request for statistics is sent w/o waiting for a 939 * reply and then on the next tick we retrieve the 940 * results. This works because npe_tick is the only 941 * code that talks via the mailbox's (except at setup). 942 * This likely can be handled better. 943 */ 944 if (ixpnpe_recvmsg_async(sc->sc_npe, msg) == 0 && msg[0] == ACK) { 945 bus_dmamap_sync(sc->sc_stats_tag, sc->sc_stats_map, 946 BUS_DMASYNC_POSTREAD); 947 npe_addstats(sc); 948 } 949 npe_updatestats(sc); 950 mii_tick(mii); 951 952 npewatchdog(sc); 953 954 /* schedule next poll */ 955 callout_reset(&sc->tick_ch, sc->sc_tickinterval * hz, npe_tick, sc); 956 #undef ACK 957 } 958 959 static void 960 npe_setmac(struct npe_softc *sc, u_char *eaddr) 961 { 962 WR4(sc, NPE_MAC_UNI_ADDR_1, eaddr[0]); 963 WR4(sc, NPE_MAC_UNI_ADDR_2, eaddr[1]); 964 WR4(sc, NPE_MAC_UNI_ADDR_3, eaddr[2]); 965 WR4(sc, NPE_MAC_UNI_ADDR_4, eaddr[3]); 966 WR4(sc, NPE_MAC_UNI_ADDR_5, eaddr[4]); 967 WR4(sc, NPE_MAC_UNI_ADDR_6, eaddr[5]); 968 } 969 970 static void 971 npe_getmac(struct npe_softc *sc, u_char *eaddr) 972 { 973 /* NB: the unicast address appears to be loaded from EEPROM on reset */ 974 eaddr[0] = RD4(sc, NPE_MAC_UNI_ADDR_1) & 0xff; 975 eaddr[1] = RD4(sc, NPE_MAC_UNI_ADDR_2) & 0xff; 976 eaddr[2] = RD4(sc, NPE_MAC_UNI_ADDR_3) & 0xff; 977 eaddr[3] = RD4(sc, NPE_MAC_UNI_ADDR_4) & 0xff; 978 eaddr[4] = RD4(sc, NPE_MAC_UNI_ADDR_5) & 0xff; 979 eaddr[5] = RD4(sc, NPE_MAC_UNI_ADDR_6) & 0xff; 980 } 981 982 struct txdone { 983 struct npebuf *head; 984 struct npebuf **tail; 985 int count; 986 }; 987 988 static __inline void 989 npe_txdone_finish(struct npe_softc *sc, const struct txdone *td) 990 { 991 struct ifnet *ifp = sc->sc_ifp; 992 993 NPE_LOCK(sc); 994 *td->tail = sc->tx_free; 995 sc->tx_free = td->head; 996 /* 997 * We're no longer busy, so clear the busy flag and call the 998 * start routine to xmit more packets. 999 */ 1000 if_inc_counter(ifp, IFCOUNTER_OPACKETS, td->count); 1001 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 1002 sc->npe_watchdog_timer = 0; 1003 npestart_locked(ifp); 1004 NPE_UNLOCK(sc); 1005 } 1006 1007 /* 1008 * Q manager callback on tx done queue. Reap mbufs 1009 * and return tx buffers to the free list. Finally 1010 * restart output. Note the microcode has only one 1011 * txdone q wired into it so we must use the NPE ID 1012 * returned with each npehwbuf to decide where to 1013 * send buffers. 1014 */ 1015 static void 1016 npe_txdone(int qid, void *arg) 1017 { 1018 #define P2V(a, dma) \ 1019 &(dma)->buf[((a) - (dma)->buf_phys) / sizeof(struct npehwbuf)] 1020 struct npe_softc *sc0 = arg; 1021 struct npe_softc *sc; 1022 struct npebuf *npe; 1023 struct txdone *td, q[NPE_MAX]; 1024 uint32_t entry; 1025 1026 q[NPE_A].tail = &q[NPE_A].head; q[NPE_A].count = 0; 1027 q[NPE_B].tail = &q[NPE_B].head; q[NPE_B].count = 0; 1028 q[NPE_C].tail = &q[NPE_C].head; q[NPE_C].count = 0; 1029 /* XXX max # at a time? */ 1030 while (ixpqmgr_qread(qid, &entry) == 0) { 1031 DPRINTF(sc0, "%s: entry 0x%x NPE %u port %u\n", 1032 __func__, entry, NPE_QM_Q_NPE(entry), NPE_QM_Q_PORT(entry)); 1033 1034 sc = npes[NPE_QM_Q_NPE(entry)]; 1035 npe = P2V(NPE_QM_Q_ADDR(entry), &sc->txdma); 1036 m_freem(npe->ix_m); 1037 npe->ix_m = NULL; 1038 1039 td = &q[NPE_QM_Q_NPE(entry)]; 1040 *td->tail = npe; 1041 td->tail = &npe->ix_next; 1042 td->count++; 1043 } 1044 1045 if (q[NPE_A].count) 1046 npe_txdone_finish(npes[NPE_A], &q[NPE_A]); 1047 if (q[NPE_B].count) 1048 npe_txdone_finish(npes[NPE_B], &q[NPE_B]); 1049 if (q[NPE_C].count) 1050 npe_txdone_finish(npes[NPE_C], &q[NPE_C]); 1051 #undef P2V 1052 } 1053 1054 static int 1055 npe_rxbuf_init(struct npe_softc *sc, struct npebuf *npe, struct mbuf *m) 1056 { 1057 bus_dma_segment_t segs[1]; 1058 struct npedma *dma = &sc->rxdma; 1059 struct npehwbuf *hw; 1060 int error, nseg; 1061 1062 if (m == NULL) { 1063 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); 1064 if (m == NULL) 1065 return ENOBUFS; 1066 } 1067 KASSERT(m->m_ext.ext_size >= 1536 + ETHER_ALIGN, 1068 ("ext_size %d", m->m_ext.ext_size)); 1069 m->m_pkthdr.len = m->m_len = 1536; 1070 /* backload payload and align ip hdr */ 1071 m->m_data = m->m_ext.ext_buf + (m->m_ext.ext_size - (1536+ETHER_ALIGN)); 1072 bus_dmamap_unload(dma->mtag, npe->ix_map); 1073 error = bus_dmamap_load_mbuf_sg(dma->mtag, npe->ix_map, m, 1074 segs, &nseg, 0); 1075 if (error != 0) { 1076 m_freem(m); 1077 return error; 1078 } 1079 hw = npe->ix_hw; 1080 hw->ix_ne[0].data = htobe32(segs[0].ds_addr); 1081 /* NB: NPE requires length be a multiple of 64 */ 1082 /* NB: buffer length is shifted in word */ 1083 hw->ix_ne[0].len = htobe32(segs[0].ds_len << 16); 1084 hw->ix_ne[0].next = 0; 1085 bus_dmamap_sync(dma->buf_tag, dma->buf_map, 1086 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 1087 npe->ix_m = m; 1088 /* Flush the memory in the mbuf */ 1089 bus_dmamap_sync(dma->mtag, npe->ix_map, BUS_DMASYNC_PREREAD); 1090 return 0; 1091 } 1092 1093 /* 1094 * RX q processing for a specific NPE. Claim entries 1095 * from the hardware queue and pass the frames up the 1096 * stack. Pass the rx buffers to the free list. 1097 */ 1098 static int 1099 npe_rxdone(int qid, void *arg) 1100 { 1101 #define P2V(a, dma) \ 1102 &(dma)->buf[((a) - (dma)->buf_phys) / sizeof(struct npehwbuf)] 1103 struct npe_softc *sc = arg; 1104 struct npedma *dma = &sc->rxdma; 1105 uint32_t entry; 1106 int rx_npkts = 0; 1107 1108 while (ixpqmgr_qread(qid, &entry) == 0) { 1109 struct npebuf *npe = P2V(NPE_QM_Q_ADDR(entry), dma); 1110 struct mbuf *m; 1111 1112 bus_dmamap_sync(dma->buf_tag, dma->buf_map, 1113 BUS_DMASYNC_POSTREAD); 1114 DPRINTF(sc, "%s: entry 0x%x neaddr 0x%x ne_len 0x%x\n", 1115 __func__, entry, npe->ix_neaddr, npe->ix_hw->ix_ne[0].len); 1116 /* 1117 * Allocate a new mbuf to replenish the rx buffer. 1118 * If doing so fails we drop the rx'd frame so we 1119 * can reuse the previous mbuf. When we're able to 1120 * allocate a new mbuf dispatch the mbuf w/ rx'd 1121 * data up the stack and replace it with the newly 1122 * allocated one. 1123 */ 1124 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); 1125 if (m != NULL) { 1126 struct mbuf *mrx = npe->ix_m; 1127 struct npehwbuf *hw = npe->ix_hw; 1128 struct ifnet *ifp = sc->sc_ifp; 1129 1130 /* Flush mbuf memory for rx'd data */ 1131 bus_dmamap_sync(dma->mtag, npe->ix_map, 1132 BUS_DMASYNC_POSTREAD); 1133 1134 /* set m_len etc. per rx frame size */ 1135 mrx->m_len = be32toh(hw->ix_ne[0].len) & 0xffff; 1136 mrx->m_pkthdr.len = mrx->m_len; 1137 mrx->m_pkthdr.rcvif = ifp; 1138 1139 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); 1140 ifp->if_input(ifp, mrx); 1141 rx_npkts++; 1142 } else { 1143 /* discard frame and re-use mbuf */ 1144 m = npe->ix_m; 1145 } 1146 if (npe_rxbuf_init(sc, npe, m) == 0) { 1147 /* return npe buf to rx free list */ 1148 ixpqmgr_qwrite(sc->rx_freeqid, npe->ix_neaddr); 1149 } else { 1150 /* XXX should not happen */ 1151 } 1152 } 1153 return rx_npkts; 1154 #undef P2V 1155 } 1156 1157 #ifdef DEVICE_POLLING 1158 static int 1159 npe_poll(struct ifnet *ifp, enum poll_cmd cmd, int count) 1160 { 1161 struct npe_softc *sc = ifp->if_softc; 1162 int rx_npkts = 0; 1163 1164 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 1165 rx_npkts = npe_rxdone(sc->rx_qid, sc); 1166 npe_txdone(sc->tx_doneqid, sc); /* XXX polls both NPE's */ 1167 } 1168 return rx_npkts; 1169 } 1170 #endif /* DEVICE_POLLING */ 1171 1172 static void 1173 npe_startxmit(struct npe_softc *sc) 1174 { 1175 struct npedma *dma = &sc->txdma; 1176 int i; 1177 1178 NPE_ASSERT_LOCKED(sc); 1179 sc->tx_free = NULL; 1180 for (i = 0; i < dma->nbuf; i++) { 1181 struct npebuf *npe = &dma->buf[i]; 1182 if (npe->ix_m != NULL) { 1183 /* NB: should not happen */ 1184 device_printf(sc->sc_dev, 1185 "%s: free mbuf at entry %u\n", __func__, i); 1186 m_freem(npe->ix_m); 1187 } 1188 npe->ix_m = NULL; 1189 npe->ix_next = sc->tx_free; 1190 sc->tx_free = npe; 1191 } 1192 } 1193 1194 static void 1195 npe_startrecv(struct npe_softc *sc) 1196 { 1197 struct npedma *dma = &sc->rxdma; 1198 struct npebuf *npe; 1199 int i; 1200 1201 NPE_ASSERT_LOCKED(sc); 1202 for (i = 0; i < dma->nbuf; i++) { 1203 npe = &dma->buf[i]; 1204 npe_rxbuf_init(sc, npe, npe->ix_m); 1205 /* set npe buf on rx free list */ 1206 ixpqmgr_qwrite(sc->rx_freeqid, npe->ix_neaddr); 1207 } 1208 } 1209 1210 /* 1211 * Reset and initialize the chip 1212 */ 1213 static void 1214 npeinit_locked(void *xsc) 1215 { 1216 struct npe_softc *sc = xsc; 1217 struct ifnet *ifp = sc->sc_ifp; 1218 1219 NPE_ASSERT_LOCKED(sc); 1220 if (ifp->if_drv_flags & IFF_DRV_RUNNING) return;/*XXX*/ 1221 1222 /* 1223 * Reset MAC core. 1224 */ 1225 npe_mac_reset(sc); 1226 1227 /* disable transmitter and reciver in the MAC */ 1228 WR4(sc, NPE_MAC_RX_CNTRL1, 1229 RD4(sc, NPE_MAC_RX_CNTRL1) &~ NPE_RX_CNTRL1_RX_EN); 1230 WR4(sc, NPE_MAC_TX_CNTRL1, 1231 RD4(sc, NPE_MAC_TX_CNTRL1) &~ NPE_TX_CNTRL1_TX_EN); 1232 1233 /* 1234 * Set the MAC core registers. 1235 */ 1236 WR4(sc, NPE_MAC_INT_CLK_THRESH, 0x1); /* clock ratio: for ipx4xx */ 1237 WR4(sc, NPE_MAC_TX_CNTRL2, 0xf); /* max retries */ 1238 WR4(sc, NPE_MAC_RANDOM_SEED, 0x8); /* LFSR back-off seed */ 1239 /* thresholds determined by NPE firmware FS */ 1240 WR4(sc, NPE_MAC_THRESH_P_EMPTY, 0x12); 1241 WR4(sc, NPE_MAC_THRESH_P_FULL, 0x30); 1242 WR4(sc, NPE_MAC_BUF_SIZE_TX, 0x8); /* tx fifo threshold (bytes) */ 1243 WR4(sc, NPE_MAC_TX_DEFER, 0x15); /* for single deferral */ 1244 WR4(sc, NPE_MAC_RX_DEFER, 0x16); /* deferral on inter-frame gap*/ 1245 WR4(sc, NPE_MAC_TX_TWO_DEFER_1, 0x8); /* for 2-part deferral */ 1246 WR4(sc, NPE_MAC_TX_TWO_DEFER_2, 0x7); /* for 2-part deferral */ 1247 WR4(sc, NPE_MAC_SLOT_TIME, 0x80); /* assumes MII mode */ 1248 1249 WR4(sc, NPE_MAC_TX_CNTRL1, 1250 NPE_TX_CNTRL1_RETRY /* retry failed xmits */ 1251 | NPE_TX_CNTRL1_FCS_EN /* append FCS */ 1252 | NPE_TX_CNTRL1_2DEFER /* 2-part deferal */ 1253 | NPE_TX_CNTRL1_PAD_EN); /* pad runt frames */ 1254 /* XXX pad strip? */ 1255 /* ena pause frame handling */ 1256 WR4(sc, NPE_MAC_RX_CNTRL1, NPE_RX_CNTRL1_PAUSE_EN); 1257 WR4(sc, NPE_MAC_RX_CNTRL2, 0); 1258 1259 npe_setmac(sc, IF_LLADDR(ifp)); 1260 npe_setportaddress(sc, IF_LLADDR(ifp)); 1261 npe_setmcast(sc); 1262 1263 npe_startxmit(sc); 1264 npe_startrecv(sc); 1265 1266 ifp->if_drv_flags |= IFF_DRV_RUNNING; 1267 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 1268 sc->npe_watchdog_timer = 0; /* just in case */ 1269 1270 /* enable transmitter and reciver in the MAC */ 1271 WR4(sc, NPE_MAC_RX_CNTRL1, 1272 RD4(sc, NPE_MAC_RX_CNTRL1) | NPE_RX_CNTRL1_RX_EN); 1273 WR4(sc, NPE_MAC_TX_CNTRL1, 1274 RD4(sc, NPE_MAC_TX_CNTRL1) | NPE_TX_CNTRL1_TX_EN); 1275 1276 callout_reset(&sc->tick_ch, sc->sc_tickinterval * hz, npe_tick, sc); 1277 } 1278 1279 static void 1280 npeinit(void *xsc) 1281 { 1282 struct npe_softc *sc = xsc; 1283 NPE_LOCK(sc); 1284 npeinit_locked(sc); 1285 NPE_UNLOCK(sc); 1286 } 1287 1288 /* 1289 * Dequeue packets and place on the h/w transmit queue. 1290 */ 1291 static void 1292 npestart_locked(struct ifnet *ifp) 1293 { 1294 struct npe_softc *sc = ifp->if_softc; 1295 struct npebuf *npe; 1296 struct npehwbuf *hw; 1297 struct mbuf *m, *n; 1298 struct npedma *dma = &sc->txdma; 1299 bus_dma_segment_t segs[NPE_MAXSEG]; 1300 int nseg, len, error, i; 1301 uint32_t next; 1302 1303 NPE_ASSERT_LOCKED(sc); 1304 /* XXX can this happen? */ 1305 if (ifp->if_drv_flags & IFF_DRV_OACTIVE) 1306 return; 1307 1308 while (sc->tx_free != NULL) { 1309 IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 1310 if (m == NULL) { 1311 /* XXX? */ 1312 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 1313 return; 1314 } 1315 npe = sc->tx_free; 1316 bus_dmamap_unload(dma->mtag, npe->ix_map); 1317 error = bus_dmamap_load_mbuf_sg(dma->mtag, npe->ix_map, 1318 m, segs, &nseg, 0); 1319 if (error == EFBIG) { 1320 n = m_collapse(m, M_NOWAIT, NPE_MAXSEG); 1321 if (n == NULL) { 1322 if_printf(ifp, "%s: too many fragments %u\n", 1323 __func__, nseg); 1324 m_freem(m); 1325 return; /* XXX? */ 1326 } 1327 m = n; 1328 error = bus_dmamap_load_mbuf_sg(dma->mtag, npe->ix_map, 1329 m, segs, &nseg, 0); 1330 } 1331 if (error != 0 || nseg == 0) { 1332 if_printf(ifp, "%s: error %u nseg %u\n", 1333 __func__, error, nseg); 1334 m_freem(m); 1335 return; /* XXX? */ 1336 } 1337 sc->tx_free = npe->ix_next; 1338 1339 bus_dmamap_sync(dma->mtag, npe->ix_map, BUS_DMASYNC_PREWRITE); 1340 1341 /* 1342 * Tap off here if there is a bpf listener. 1343 */ 1344 BPF_MTAP(ifp, m); 1345 1346 npe->ix_m = m; 1347 hw = npe->ix_hw; 1348 len = m->m_pkthdr.len; 1349 next = npe->ix_neaddr + sizeof(hw->ix_ne[0]); 1350 for (i = 0; i < nseg; i++) { 1351 hw->ix_ne[i].data = htobe32(segs[i].ds_addr); 1352 hw->ix_ne[i].len = htobe32((segs[i].ds_len<<16) | len); 1353 hw->ix_ne[i].next = htobe32(next); 1354 1355 len = 0; /* zero for segments > 1 */ 1356 next += sizeof(hw->ix_ne[0]); 1357 } 1358 hw->ix_ne[i-1].next = 0; /* zero last in chain */ 1359 bus_dmamap_sync(dma->buf_tag, dma->buf_map, 1360 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 1361 1362 DPRINTF(sc, "%s: qwrite(%u, 0x%x) ne_data %x ne_len 0x%x\n", 1363 __func__, sc->tx_qid, npe->ix_neaddr, 1364 hw->ix_ne[0].data, hw->ix_ne[0].len); 1365 /* stick it on the tx q */ 1366 /* XXX add vlan priority */ 1367 ixpqmgr_qwrite(sc->tx_qid, npe->ix_neaddr); 1368 1369 sc->npe_watchdog_timer = 5; 1370 } 1371 if (sc->tx_free == NULL) 1372 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 1373 } 1374 1375 void 1376 npestart(struct ifnet *ifp) 1377 { 1378 struct npe_softc *sc = ifp->if_softc; 1379 NPE_LOCK(sc); 1380 npestart_locked(ifp); 1381 NPE_UNLOCK(sc); 1382 } 1383 1384 static void 1385 npe_stopxmit(struct npe_softc *sc) 1386 { 1387 struct npedma *dma = &sc->txdma; 1388 int i; 1389 1390 NPE_ASSERT_LOCKED(sc); 1391 1392 /* XXX qmgr */ 1393 for (i = 0; i < dma->nbuf; i++) { 1394 struct npebuf *npe = &dma->buf[i]; 1395 1396 if (npe->ix_m != NULL) { 1397 bus_dmamap_unload(dma->mtag, npe->ix_map); 1398 m_freem(npe->ix_m); 1399 npe->ix_m = NULL; 1400 } 1401 } 1402 } 1403 1404 static void 1405 npe_stoprecv(struct npe_softc *sc) 1406 { 1407 struct npedma *dma = &sc->rxdma; 1408 int i; 1409 1410 NPE_ASSERT_LOCKED(sc); 1411 1412 /* XXX qmgr */ 1413 for (i = 0; i < dma->nbuf; i++) { 1414 struct npebuf *npe = &dma->buf[i]; 1415 1416 if (npe->ix_m != NULL) { 1417 bus_dmamap_unload(dma->mtag, npe->ix_map); 1418 m_freem(npe->ix_m); 1419 npe->ix_m = NULL; 1420 } 1421 } 1422 } 1423 1424 /* 1425 * Turn off interrupts, and stop the nic. 1426 */ 1427 void 1428 npestop(struct npe_softc *sc) 1429 { 1430 struct ifnet *ifp = sc->sc_ifp; 1431 1432 /* disable transmitter and reciver in the MAC */ 1433 WR4(sc, NPE_MAC_RX_CNTRL1, 1434 RD4(sc, NPE_MAC_RX_CNTRL1) &~ NPE_RX_CNTRL1_RX_EN); 1435 WR4(sc, NPE_MAC_TX_CNTRL1, 1436 RD4(sc, NPE_MAC_TX_CNTRL1) &~ NPE_TX_CNTRL1_TX_EN); 1437 1438 sc->npe_watchdog_timer = 0; 1439 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 1440 1441 callout_stop(&sc->tick_ch); 1442 1443 npe_stopxmit(sc); 1444 npe_stoprecv(sc); 1445 /* XXX go into loopback & drain q's? */ 1446 /* XXX but beware of disabling tx above */ 1447 1448 /* 1449 * The MAC core rx/tx disable may leave the MAC hardware in an 1450 * unpredictable state. A hw reset is executed before resetting 1451 * all the MAC parameters to a known value. 1452 */ 1453 WR4(sc, NPE_MAC_CORE_CNTRL, NPE_CORE_RESET); 1454 DELAY(NPE_MAC_RESET_DELAY); 1455 WR4(sc, NPE_MAC_INT_CLK_THRESH, NPE_MAC_INT_CLK_THRESH_DEFAULT); 1456 WR4(sc, NPE_MAC_CORE_CNTRL, NPE_CORE_MDC_EN); 1457 } 1458 1459 void 1460 npewatchdog(struct npe_softc *sc) 1461 { 1462 NPE_ASSERT_LOCKED(sc); 1463 1464 if (sc->npe_watchdog_timer == 0 || --sc->npe_watchdog_timer != 0) 1465 return; 1466 1467 device_printf(sc->sc_dev, "watchdog timeout\n"); 1468 if_inc_counter(sc->sc_ifp, IFCOUNTER_OERRORS, 1); 1469 1470 npeinit_locked(sc); 1471 } 1472 1473 static int 1474 npeioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 1475 { 1476 struct npe_softc *sc = ifp->if_softc; 1477 struct mii_data *mii; 1478 struct ifreq *ifr = (struct ifreq *)data; 1479 int error = 0; 1480 #ifdef DEVICE_POLLING 1481 int mask; 1482 #endif 1483 1484 switch (cmd) { 1485 case SIOCSIFFLAGS: 1486 NPE_LOCK(sc); 1487 if ((ifp->if_flags & IFF_UP) == 0 && 1488 ifp->if_drv_flags & IFF_DRV_RUNNING) { 1489 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 1490 npestop(sc); 1491 } else { 1492 /* reinitialize card on any parameter change */ 1493 npeinit_locked(sc); 1494 } 1495 NPE_UNLOCK(sc); 1496 break; 1497 1498 case SIOCADDMULTI: 1499 case SIOCDELMULTI: 1500 /* update multicast filter list. */ 1501 NPE_LOCK(sc); 1502 npe_setmcast(sc); 1503 NPE_UNLOCK(sc); 1504 error = 0; 1505 break; 1506 1507 case SIOCSIFMEDIA: 1508 case SIOCGIFMEDIA: 1509 mii = device_get_softc(sc->sc_mii); 1510 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd); 1511 break; 1512 1513 #ifdef DEVICE_POLLING 1514 case SIOCSIFCAP: 1515 mask = ifp->if_capenable ^ ifr->ifr_reqcap; 1516 if (mask & IFCAP_POLLING) { 1517 if (ifr->ifr_reqcap & IFCAP_POLLING) { 1518 error = ether_poll_register(npe_poll, ifp); 1519 if (error) 1520 return error; 1521 NPE_LOCK(sc); 1522 /* disable callbacks XXX txdone is shared */ 1523 ixpqmgr_notify_disable(sc->rx_qid); 1524 ixpqmgr_notify_disable(sc->tx_doneqid); 1525 ifp->if_capenable |= IFCAP_POLLING; 1526 NPE_UNLOCK(sc); 1527 } else { 1528 error = ether_poll_deregister(ifp); 1529 /* NB: always enable qmgr callbacks */ 1530 NPE_LOCK(sc); 1531 /* enable qmgr callbacks */ 1532 ixpqmgr_notify_enable(sc->rx_qid, 1533 IX_QMGR_Q_SOURCE_ID_NOT_E); 1534 ixpqmgr_notify_enable(sc->tx_doneqid, 1535 IX_QMGR_Q_SOURCE_ID_NOT_E); 1536 ifp->if_capenable &= ~IFCAP_POLLING; 1537 NPE_UNLOCK(sc); 1538 } 1539 } 1540 break; 1541 #endif 1542 default: 1543 error = ether_ioctl(ifp, cmd, data); 1544 break; 1545 } 1546 return error; 1547 } 1548 1549 /* 1550 * Setup a traffic class -> rx queue mapping. 1551 */ 1552 static int 1553 npe_setrxqosentry(struct npe_softc *sc, int classix, int trafclass, int qid) 1554 { 1555 uint32_t msg[2]; 1556 1557 msg[0] = (NPE_SETRXQOSENTRY << 24) | (sc->sc_npeid << 20) | classix; 1558 msg[1] = (trafclass << 24) | (1 << 23) | (qid << 16) | (qid << 4); 1559 return ixpnpe_sendandrecvmsg_sync(sc->sc_npe, msg, msg); 1560 } 1561 1562 static int 1563 npe_setportaddress(struct npe_softc *sc, const uint8_t mac[ETHER_ADDR_LEN]) 1564 { 1565 uint32_t msg[2]; 1566 1567 msg[0] = (NPE_SETPORTADDRESS << 24) 1568 | (sc->sc_npeid << 20) 1569 | (mac[0] << 8) 1570 | (mac[1] << 0); 1571 msg[1] = (mac[2] << 24) 1572 | (mac[3] << 16) 1573 | (mac[4] << 8) 1574 | (mac[5] << 0); 1575 return ixpnpe_sendandrecvmsg_sync(sc->sc_npe, msg, msg); 1576 } 1577 1578 static int 1579 npe_setfirewallmode(struct npe_softc *sc, int onoff) 1580 { 1581 uint32_t msg[2]; 1582 1583 /* XXX honor onoff */ 1584 msg[0] = (NPE_SETFIREWALLMODE << 24) | (sc->sc_npeid << 20); 1585 msg[1] = 0; 1586 return ixpnpe_sendandrecvmsg_sync(sc->sc_npe, msg, msg); 1587 } 1588 1589 /* 1590 * Update and reset the statistics in the NPE. 1591 */ 1592 static int 1593 npe_updatestats(struct npe_softc *sc) 1594 { 1595 uint32_t msg[2]; 1596 1597 msg[0] = NPE_RESETSTATS << NPE_MAC_MSGID_SHL; 1598 msg[1] = sc->sc_stats_phys; /* physical address of stat block */ 1599 return ixpnpe_sendmsg_async(sc->sc_npe, msg); 1600 } 1601 1602 #if 0 1603 /* 1604 * Get the current statistics block. 1605 */ 1606 static int 1607 npe_getstats(struct npe_softc *sc) 1608 { 1609 uint32_t msg[2]; 1610 1611 msg[0] = NPE_GETSTATS << NPE_MAC_MSGID_SHL; 1612 msg[1] = sc->sc_stats_phys; /* physical address of stat block */ 1613 return ixpnpe_sendandrecvmsg(sc->sc_npe, msg, msg); 1614 } 1615 1616 /* 1617 * Query the image id of the loaded firmware. 1618 */ 1619 static uint32_t 1620 npe_getimageid(struct npe_softc *sc) 1621 { 1622 uint32_t msg[2]; 1623 1624 msg[0] = NPE_GETSTATUS << NPE_MAC_MSGID_SHL; 1625 msg[1] = 0; 1626 return ixpnpe_sendandrecvmsg_sync(sc->sc_npe, msg, msg) == 0 ? msg[1] : 0; 1627 } 1628 1629 /* 1630 * Enable/disable loopback. 1631 */ 1632 static int 1633 npe_setloopback(struct npe_softc *sc, int ena) 1634 { 1635 uint32_t msg[2]; 1636 1637 msg[0] = (NPE_SETLOOPBACK << NPE_MAC_MSGID_SHL) | (ena != 0); 1638 msg[1] = 0; 1639 return ixpnpe_sendandrecvmsg_sync(sc->sc_npe, msg, msg); 1640 } 1641 #endif 1642 1643 static void 1644 npe_child_detached(device_t dev, device_t child) 1645 { 1646 struct npe_softc *sc; 1647 1648 sc = device_get_softc(dev); 1649 if (child == sc->sc_mii) 1650 sc->sc_mii = NULL; 1651 } 1652 1653 /* 1654 * MII bus support routines. 1655 */ 1656 #define MII_RD4(sc, reg) bus_space_read_4(sc->sc_iot, sc->sc_miih, reg) 1657 #define MII_WR4(sc, reg, v) \ 1658 bus_space_write_4(sc->sc_iot, sc->sc_miih, reg, v) 1659 1660 static uint32_t 1661 npe_mii_mdio_read(struct npe_softc *sc, int reg) 1662 { 1663 uint32_t v; 1664 1665 /* NB: registers are known to be sequential */ 1666 v = (MII_RD4(sc, reg+0) & 0xff) << 0; 1667 v |= (MII_RD4(sc, reg+4) & 0xff) << 8; 1668 v |= (MII_RD4(sc, reg+8) & 0xff) << 16; 1669 v |= (MII_RD4(sc, reg+12) & 0xff) << 24; 1670 return v; 1671 } 1672 1673 static void 1674 npe_mii_mdio_write(struct npe_softc *sc, int reg, uint32_t cmd) 1675 { 1676 /* NB: registers are known to be sequential */ 1677 MII_WR4(sc, reg+0, cmd & 0xff); 1678 MII_WR4(sc, reg+4, (cmd >> 8) & 0xff); 1679 MII_WR4(sc, reg+8, (cmd >> 16) & 0xff); 1680 MII_WR4(sc, reg+12, (cmd >> 24) & 0xff); 1681 } 1682 1683 static int 1684 npe_mii_mdio_wait(struct npe_softc *sc) 1685 { 1686 uint32_t v; 1687 int i; 1688 1689 /* NB: typically this takes 25-30 trips */ 1690 for (i = 0; i < 1000; i++) { 1691 v = npe_mii_mdio_read(sc, NPE_MAC_MDIO_CMD); 1692 if ((v & NPE_MII_GO) == 0) 1693 return 1; 1694 DELAY(1); 1695 } 1696 device_printf(sc->sc_dev, "%s: timeout after ~1ms, cmd 0x%x\n", 1697 __func__, v); 1698 return 0; /* NB: timeout */ 1699 } 1700 1701 static int 1702 npe_miibus_readreg(device_t dev, int phy, int reg) 1703 { 1704 struct npe_softc *sc = device_get_softc(dev); 1705 uint32_t v; 1706 1707 v = (phy << NPE_MII_ADDR_SHL) | (reg << NPE_MII_REG_SHL) | NPE_MII_GO; 1708 npe_mii_mdio_write(sc, NPE_MAC_MDIO_CMD, v); 1709 if (npe_mii_mdio_wait(sc)) 1710 v = npe_mii_mdio_read(sc, NPE_MAC_MDIO_STS); 1711 else 1712 v = 0xffff | NPE_MII_READ_FAIL; 1713 return (v & NPE_MII_READ_FAIL) ? 0xffff : (v & 0xffff); 1714 } 1715 1716 static int 1717 npe_miibus_writereg(device_t dev, int phy, int reg, int data) 1718 { 1719 struct npe_softc *sc = device_get_softc(dev); 1720 uint32_t v; 1721 1722 v = (phy << NPE_MII_ADDR_SHL) | (reg << NPE_MII_REG_SHL) 1723 | data | NPE_MII_WRITE 1724 | NPE_MII_GO; 1725 npe_mii_mdio_write(sc, NPE_MAC_MDIO_CMD, v); 1726 /* XXX complain about timeout */ 1727 (void) npe_mii_mdio_wait(sc); 1728 return (0); 1729 } 1730 1731 static void 1732 npe_miibus_statchg(device_t dev) 1733 { 1734 struct npe_softc *sc = device_get_softc(dev); 1735 struct mii_data *mii = device_get_softc(sc->sc_mii); 1736 uint32_t tx1, rx1; 1737 1738 /* sync MAC duplex state */ 1739 tx1 = RD4(sc, NPE_MAC_TX_CNTRL1); 1740 rx1 = RD4(sc, NPE_MAC_RX_CNTRL1); 1741 if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX) { 1742 tx1 &= ~NPE_TX_CNTRL1_DUPLEX; 1743 rx1 |= NPE_RX_CNTRL1_PAUSE_EN; 1744 } else { 1745 tx1 |= NPE_TX_CNTRL1_DUPLEX; 1746 rx1 &= ~NPE_RX_CNTRL1_PAUSE_EN; 1747 } 1748 WR4(sc, NPE_MAC_RX_CNTRL1, rx1); 1749 WR4(sc, NPE_MAC_TX_CNTRL1, tx1); 1750 } 1751 1752 static device_method_t npe_methods[] = { 1753 /* Device interface */ 1754 DEVMETHOD(device_probe, npe_probe), 1755 DEVMETHOD(device_attach, npe_attach), 1756 DEVMETHOD(device_detach, npe_detach), 1757 1758 /* Bus interface */ 1759 DEVMETHOD(bus_child_detached, npe_child_detached), 1760 1761 /* MII interface */ 1762 DEVMETHOD(miibus_readreg, npe_miibus_readreg), 1763 DEVMETHOD(miibus_writereg, npe_miibus_writereg), 1764 DEVMETHOD(miibus_statchg, npe_miibus_statchg), 1765 1766 { 0, 0 } 1767 }; 1768 1769 static driver_t npe_driver = { 1770 "npe", 1771 npe_methods, 1772 sizeof(struct npe_softc), 1773 }; 1774 1775 DRIVER_MODULE(npe, ixp, npe_driver, npe_devclass, 0, 0); 1776 DRIVER_MODULE(miibus, npe, miibus_driver, miibus_devclass, 0, 0); 1777 MODULE_DEPEND(npe, ixpqmgr, 1, 1, 1); 1778 MODULE_DEPEND(npe, miibus, 1, 1, 1); 1779 MODULE_DEPEND(npe, ether, 1, 1, 1);
Cache object: 064b46a6760f032d45cec5c7d2e96524
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]