if_xge.c revision 1.8
1 /* $NetBSD: if_xge.c,v 1.8 2008/02/07 01:21:58 dyoung Exp $ */ 2 3 /* 4 * Copyright (c) 2004, SUNET, Swedish University Computer Network. 5 * All rights reserved. 6 * 7 * Written by Anders Magnusson for SUNET, Swedish University Computer Network. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed for the NetBSD Project by 20 * SUNET, Swedish University Computer Network. 21 * 4. The name of SUNET may not be used to endorse or promote products 22 * derived from this software without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY SUNET ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 26 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 27 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SUNET 28 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 /* 38 * Device driver for the S2io Xframe Ten Gigabit Ethernet controller. 39 * 40 * TODO (in no specific order): 41 * HW VLAN support. 42 * IPv6 HW cksum. 43 */ 44 45 #include <sys/cdefs.h> 46 __KERNEL_RCSID(0, "$NetBSD: if_xge.c,v 1.8 2008/02/07 01:21:58 dyoung Exp $"); 47 48 #include "bpfilter.h" 49 #include "rnd.h" 50 51 #include <sys/param.h> 52 #include <sys/systm.h> 53 #include <sys/mbuf.h> 54 #include <sys/malloc.h> 55 #include <sys/kernel.h> 56 #include <sys/socket.h> 57 #include <sys/device.h> 58 59 #if NRND > 0 60 #include <sys/rnd.h> 61 #endif 62 63 #include <net/if.h> 64 #include <net/if_dl.h> 65 #include <net/if_media.h> 66 #include <net/if_ether.h> 67 68 #if NBPFILTER > 0 69 #include <net/bpf.h> 70 #endif 71 72 #include <sys/bus.h> 73 #include <sys/intr.h> 74 #include <machine/endian.h> 75 76 #include <dev/mii/mii.h> 77 #include <dev/mii/miivar.h> 78 79 #include <dev/pci/pcivar.h> 80 #include <dev/pci/pcireg.h> 81 #include <dev/pci/pcidevs.h> 82 83 #include <sys/proc.h> 84 85 #include <dev/pci/if_xgereg.h> 86 87 /* 88 * Some tunable constants, tune with care! 89 */ 90 #define RX_MODE RX_MODE_1 /* Receive mode (buffer usage, see below) */ 91 #define NRXDESCS 1016 /* # of receive descriptors (requested) */ 92 #define NTXDESCS 8192 /* Number of transmit descriptors */ 93 #define NTXFRAGS 100 /* Max fragments per packet */ 94 #define XGE_EVENT_COUNTERS /* Instrumentation */ 95 96 /* 97 * Receive buffer modes; 1, 3 or 5 buffers. 98 */ 99 #define RX_MODE_1 1 100 #define RX_MODE_3 3 101 #define RX_MODE_5 5 102 103 /* 104 * Use clever macros to avoid a bunch of #ifdef's. 105 */ 106 #define XCONCAT3(x,y,z) x ## y ## z 107 #define CONCAT3(x,y,z) XCONCAT3(x,y,z) 108 #define NDESC_BUFMODE CONCAT3(NDESC_,RX_MODE,BUFMODE) 109 #define rxd_4k CONCAT3(rxd,RX_MODE,_4k) 110 #define rxdesc ___CONCAT(rxd,RX_MODE) 111 112 #define NEXTTX(x) (((x)+1) % NTXDESCS) 113 #define NRXFRAGS RX_MODE /* hardware imposed frags */ 114 #define NRXPAGES ((NRXDESCS/NDESC_BUFMODE)+1) 115 #define NRXREAL (NRXPAGES*NDESC_BUFMODE) 116 #define RXMAPSZ (NRXPAGES*PAGE_SIZE) 117 118 #ifdef XGE_EVENT_COUNTERS 119 #define XGE_EVCNT_INCR(ev) (ev)->ev_count++ 120 #else 121 #define XGE_EVCNT_INCR(ev) /* nothing */ 122 #endif 123 124 /* 125 * Magics to fix a bug when the mac address can't be read correctly. 126 * Comes from the Linux driver. 127 */ 128 static uint64_t fix_mac[] = { 129 0x0060000000000000ULL, 0x0060600000000000ULL, 130 0x0040600000000000ULL, 0x0000600000000000ULL, 131 0x0020600000000000ULL, 0x0060600000000000ULL, 132 0x0020600000000000ULL, 0x0060600000000000ULL, 133 0x0020600000000000ULL, 0x0060600000000000ULL, 134 0x0020600000000000ULL, 0x0060600000000000ULL, 135 0x0020600000000000ULL, 0x0060600000000000ULL, 136 0x0020600000000000ULL, 0x0060600000000000ULL, 137 0x0020600000000000ULL, 0x0060600000000000ULL, 138 0x0020600000000000ULL, 0x0060600000000000ULL, 139 0x0020600000000000ULL, 0x0060600000000000ULL, 140 0x0020600000000000ULL, 0x0060600000000000ULL, 141 0x0020600000000000ULL, 0x0000600000000000ULL, 142 0x0040600000000000ULL, 0x0060600000000000ULL, 143 }; 144 145 146 struct xge_softc { 147 struct device sc_dev; 148 struct ethercom sc_ethercom; 149 #define sc_if sc_ethercom.ec_if 150 bus_dma_tag_t sc_dmat; 151 bus_space_tag_t sc_st; 152 bus_space_handle_t sc_sh; 153 bus_space_tag_t sc_txt; 154 bus_space_handle_t sc_txh; 155 void *sc_ih; 156 157 struct ifmedia xena_media; 158 pcireg_t sc_pciregs[16]; 159 160 /* Transmit structures */ 161 struct txd *sc_txd[NTXDESCS]; /* transmit frags array */ 162 bus_addr_t sc_txdp[NTXDESCS]; /* bus address of transmit frags */ 163 bus_dmamap_t sc_txm[NTXDESCS]; /* transmit frags map */ 164 struct mbuf *sc_txb[NTXDESCS]; /* transmit mbuf pointer */ 165 int sc_nexttx, sc_lasttx; 166 bus_dmamap_t sc_txmap; /* transmit descriptor map */ 167 168 /* Receive data */ 169 bus_dmamap_t sc_rxmap; /* receive descriptor map */ 170 struct rxd_4k *sc_rxd_4k[NRXPAGES]; /* receive desc pages */ 171 bus_dmamap_t sc_rxm[NRXREAL]; /* receive buffer map */ 172 struct mbuf *sc_rxb[NRXREAL]; /* mbufs on receive descriptors */ 173 int sc_nextrx; /* next descriptor to check */ 174 175 #ifdef XGE_EVENT_COUNTERS 176 struct evcnt sc_intr; /* # of interrupts */ 177 struct evcnt sc_txintr; /* # of transmit interrupts */ 178 struct evcnt sc_rxintr; /* # of receive interrupts */ 179 struct evcnt sc_txqe; /* # of xmit intrs when board queue empty */ 180 #endif 181 }; 182 183 static int xge_match(struct device *parent, struct cfdata *cf, void *aux); 184 static void xge_attach(struct device *parent, struct device *self, void *aux); 185 static int xge_alloc_txmem(struct xge_softc *); 186 static int xge_alloc_rxmem(struct xge_softc *); 187 static void xge_start(struct ifnet *); 188 static void xge_stop(struct ifnet *, int); 189 static int xge_add_rxbuf(struct xge_softc *, int); 190 static void xge_mcast_filter(struct xge_softc *sc); 191 static int xge_setup_xgxs(struct xge_softc *sc); 192 static int xge_ioctl(struct ifnet *ifp, u_long cmd, void *data); 193 static int xge_init(struct ifnet *ifp); 194 static void xge_ifmedia_status(struct ifnet *, struct ifmediareq *); 195 static int xge_xgmii_mediachange(struct ifnet *); 196 static int xge_intr(void *); 197 198 /* 199 * Helpers to address registers. 200 */ 201 #define PIF_WCSR(csr, val) pif_wcsr(sc, csr, val) 202 #define PIF_RCSR(csr) pif_rcsr(sc, csr) 203 #define TXP_WCSR(csr, val) txp_wcsr(sc, csr, val) 204 #define PIF_WKEY(csr, val) pif_wkey(sc, csr, val) 205 206 static inline void 207 pif_wcsr(struct xge_softc *sc, bus_size_t csr, uint64_t val) 208 { 209 uint32_t lval, hval; 210 211 lval = val&0xffffffff; 212 hval = val>>32; 213 bus_space_write_4(sc->sc_st, sc->sc_sh, csr, lval); 214 bus_space_write_4(sc->sc_st, sc->sc_sh, csr+4, hval); 215 } 216 217 static inline uint64_t 218 pif_rcsr(struct xge_softc *sc, bus_size_t csr) 219 { 220 uint64_t val, val2; 221 val = bus_space_read_4(sc->sc_st, sc->sc_sh, csr); 222 val2 = bus_space_read_4(sc->sc_st, sc->sc_sh, csr+4); 223 val |= (val2 << 32); 224 return val; 225 } 226 227 static inline void 228 txp_wcsr(struct xge_softc *sc, bus_size_t csr, uint64_t val) 229 { 230 uint32_t lval, hval; 231 232 lval = val&0xffffffff; 233 hval = val>>32; 234 bus_space_write_4(sc->sc_txt, sc->sc_txh, csr, lval); 235 bus_space_write_4(sc->sc_txt, sc->sc_txh, csr+4, hval); 236 } 237 238 239 static inline void 240 pif_wkey(struct xge_softc *sc, bus_size_t csr, uint64_t val) 241 { 242 uint32_t lval, hval; 243 244 lval = val&0xffffffff; 245 hval = val>>32; 246 PIF_WCSR(RMAC_CFG_KEY, RMAC_KEY_VALUE); 247 bus_space_write_4(sc->sc_st, sc->sc_sh, csr, lval); 248 PIF_WCSR(RMAC_CFG_KEY, RMAC_KEY_VALUE); 249 bus_space_write_4(sc->sc_st, sc->sc_sh, csr+4, hval); 250 } 251 252 253 CFATTACH_DECL(xge, sizeof(struct xge_softc), 254 xge_match, xge_attach, NULL, NULL); 255 256 #define XNAME sc->sc_dev.dv_xname 257 258 #define XGE_RXSYNC(desc, what) \ 259 bus_dmamap_sync(sc->sc_dmat, sc->sc_rxmap, \ 260 (desc/NDESC_BUFMODE) * XGE_PAGE + sizeof(struct rxdesc) * \ 261 (desc%NDESC_BUFMODE), sizeof(struct rxdesc), what) 262 #define XGE_RXD(desc) &sc->sc_rxd_4k[desc/NDESC_BUFMODE]-> \ 263 r4_rxd[desc%NDESC_BUFMODE] 264 265 /* 266 * Non-tunable constants. 267 */ 268 #define XGE_MAX_MTU 9600 269 #define XGE_IP_MAXPACKET 65535 /* same as IP_MAXPACKET */ 270 271 static int 272 xge_match(struct device *parent, struct cfdata *cf, void *aux) 273 { 274 struct pci_attach_args *pa = aux; 275 276 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_S2IO && 277 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_S2IO_XFRAME) 278 return (1); 279 280 return (0); 281 } 282 283 void 284 xge_attach(struct device *parent, struct device *self, void *aux) 285 { 286 struct pci_attach_args *pa = aux; 287 struct xge_softc *sc; 288 struct ifnet *ifp; 289 pcireg_t memtype; 290 pci_intr_handle_t ih; 291 const char *intrstr = NULL; 292 pci_chipset_tag_t pc = pa->pa_pc; 293 uint8_t enaddr[ETHER_ADDR_LEN]; 294 uint64_t val; 295 int i; 296 297 sc = (struct xge_softc *)self; 298 299 sc->sc_dmat = pa->pa_dmat; 300 301 /* Get BAR0 address */ 302 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, XGE_PIF_BAR); 303 if (pci_mapreg_map(pa, XGE_PIF_BAR, memtype, 0, 304 &sc->sc_st, &sc->sc_sh, 0, 0)) { 305 aprint_error("%s: unable to map PIF BAR registers\n", XNAME); 306 return; 307 } 308 309 memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, XGE_TXP_BAR); 310 if (pci_mapreg_map(pa, XGE_TXP_BAR, memtype, 0, 311 &sc->sc_txt, &sc->sc_txh, 0, 0)) { 312 aprint_error("%s: unable to map TXP BAR registers\n", XNAME); 313 return; 314 } 315 316 /* Save PCI config space */ 317 for (i = 0; i < 64; i += 4) 318 sc->sc_pciregs[i/4] = pci_conf_read(pa->pa_pc, pa->pa_tag, i); 319 320 #if BYTE_ORDER == LITTLE_ENDIAN 321 val = (uint64_t)0xFFFFFFFFFFFFFFFFULL; 322 val &= ~(TxF_R_SE|RxF_W_SE); 323 PIF_WCSR(SWAPPER_CTRL, val); 324 PIF_WCSR(SWAPPER_CTRL, val); 325 #elif BYTE_ORDER == BIG_ENDIAN 326 /* do nothing */ 327 #else 328 #error bad endianness! 329 #endif 330 331 if ((val = PIF_RCSR(PIF_RD_SWAPPER_Fb)) != SWAPPER_MAGIC) 332 return printf("%s: failed configuring endian, %llx != %llx!\n", 333 XNAME, (unsigned long long)val, SWAPPER_MAGIC); 334 335 /* 336 * The MAC addr may be all FF's, which is not good. 337 * Resolve it by writing some magics to GPIO_CONTROL and 338 * force a chip reset to read in the serial eeprom again. 339 */ 340 for (i = 0; i < sizeof(fix_mac)/sizeof(fix_mac[0]); i++) { 341 PIF_WCSR(GPIO_CONTROL, fix_mac[i]); 342 PIF_RCSR(GPIO_CONTROL); 343 } 344 345 /* 346 * Reset the chip and restore the PCI registers. 347 */ 348 PIF_WCSR(SW_RESET, 0xa5a5a50000000000ULL); 349 DELAY(500000); 350 for (i = 0; i < 64; i += 4) 351 pci_conf_write(pa->pa_pc, pa->pa_tag, i, sc->sc_pciregs[i/4]); 352 353 /* 354 * Restore the byte order registers. 355 */ 356 #if BYTE_ORDER == LITTLE_ENDIAN 357 val = (uint64_t)0xFFFFFFFFFFFFFFFFULL; 358 val &= ~(TxF_R_SE|RxF_W_SE); 359 PIF_WCSR(SWAPPER_CTRL, val); 360 PIF_WCSR(SWAPPER_CTRL, val); 361 #elif BYTE_ORDER == BIG_ENDIAN 362 /* do nothing */ 363 #else 364 #error bad endianness! 365 #endif 366 367 if ((val = PIF_RCSR(PIF_RD_SWAPPER_Fb)) != SWAPPER_MAGIC) 368 return printf("%s: failed configuring endian2, %llx != %llx!\n", 369 XNAME, (unsigned long long)val, SWAPPER_MAGIC); 370 371 /* 372 * XGXS initialization. 373 */ 374 /* 29, reset */ 375 PIF_WCSR(SW_RESET, 0); 376 DELAY(500000); 377 378 /* 30, configure XGXS transceiver */ 379 xge_setup_xgxs(sc); 380 381 /* 33, program MAC address (not needed here) */ 382 /* Get ethernet address */ 383 PIF_WCSR(RMAC_ADDR_CMD_MEM, 384 RMAC_ADDR_CMD_MEM_STR|RMAC_ADDR_CMD_MEM_OFF(0)); 385 while (PIF_RCSR(RMAC_ADDR_CMD_MEM) & RMAC_ADDR_CMD_MEM_STR) 386 ; 387 val = PIF_RCSR(RMAC_ADDR_DATA0_MEM); 388 for (i = 0; i < ETHER_ADDR_LEN; i++) 389 enaddr[i] = (uint8_t)(val >> (56 - (8*i))); 390 391 /* 392 * Get memory for transmit descriptor lists. 393 */ 394 if (xge_alloc_txmem(sc)) 395 return printf("%s: failed allocating txmem.\n", XNAME); 396 397 /* 9 and 10 - set FIFO number/prio */ 398 PIF_WCSR(TX_FIFO_P0, TX_FIFO_LEN0(NTXDESCS)); 399 PIF_WCSR(TX_FIFO_P1, 0ULL); 400 PIF_WCSR(TX_FIFO_P2, 0ULL); 401 PIF_WCSR(TX_FIFO_P3, 0ULL); 402 403 /* 11, XXX set round-robin prio? */ 404 405 /* 12, enable transmit FIFO */ 406 val = PIF_RCSR(TX_FIFO_P0); 407 val |= TX_FIFO_ENABLE; 408 PIF_WCSR(TX_FIFO_P0, val); 409 410 /* 13, disable some error checks */ 411 PIF_WCSR(TX_PA_CFG, 412 TX_PA_CFG_IFR|TX_PA_CFG_ISO|TX_PA_CFG_ILC|TX_PA_CFG_ILE); 413 414 /* 415 * Create transmit DMA maps. 416 * Make them large for TSO. 417 */ 418 for (i = 0; i < NTXDESCS; i++) { 419 if (bus_dmamap_create(sc->sc_dmat, XGE_IP_MAXPACKET, 420 NTXFRAGS, MCLBYTES, 0, 0, &sc->sc_txm[i])) 421 return printf("%s: cannot create TX DMA maps\n", XNAME); 422 } 423 424 sc->sc_lasttx = NTXDESCS-1; 425 426 /* 427 * RxDMA initialization. 428 * Only use one out of 8 possible receive queues. 429 */ 430 if (xge_alloc_rxmem(sc)) /* allocate rx descriptor memory */ 431 return printf("%s: failed allocating rxmem\n", XNAME); 432 433 /* Create receive buffer DMA maps */ 434 for (i = 0; i < NRXREAL; i++) { 435 if (bus_dmamap_create(sc->sc_dmat, XGE_MAX_MTU, 436 NRXFRAGS, MCLBYTES, 0, 0, &sc->sc_rxm[i])) 437 return printf("%s: cannot create RX DMA maps\n", XNAME); 438 } 439 440 /* allocate mbufs to receive descriptors */ 441 for (i = 0; i < NRXREAL; i++) 442 if (xge_add_rxbuf(sc, i)) 443 panic("out of mbufs too early"); 444 445 /* 14, setup receive ring priority */ 446 PIF_WCSR(RX_QUEUE_PRIORITY, 0ULL); /* only use one ring */ 447 448 /* 15, setup receive ring round-robin calendar */ 449 PIF_WCSR(RX_W_ROUND_ROBIN_0, 0ULL); /* only use one ring */ 450 PIF_WCSR(RX_W_ROUND_ROBIN_1, 0ULL); 451 PIF_WCSR(RX_W_ROUND_ROBIN_2, 0ULL); 452 PIF_WCSR(RX_W_ROUND_ROBIN_3, 0ULL); 453 PIF_WCSR(RX_W_ROUND_ROBIN_4, 0ULL); 454 455 /* 16, write receive ring start address */ 456 PIF_WCSR(PRC_RXD0_0, (uint64_t)sc->sc_rxmap->dm_segs[0].ds_addr); 457 /* PRC_RXD0_[1-7] are not used */ 458 459 /* 17, Setup alarm registers */ 460 PIF_WCSR(PRC_ALARM_ACTION, 0ULL); /* Default everything to retry */ 461 462 /* 18, init receive ring controller */ 463 #if RX_MODE == RX_MODE_1 464 val = RING_MODE_1; 465 #elif RX_MODE == RX_MODE_3 466 val = RING_MODE_3; 467 #else /* RX_MODE == RX_MODE_5 */ 468 val = RING_MODE_5; 469 #endif 470 PIF_WCSR(PRC_CTRL_0, RC_IN_SVC|val); 471 /* leave 1-7 disabled */ 472 /* XXXX snoop configuration? */ 473 474 /* 19, set chip memory assigned to the queue */ 475 PIF_WCSR(RX_QUEUE_CFG, MC_QUEUE(0, 64)); /* all 64M to queue 0 */ 476 477 /* 20, setup RLDRAM parameters */ 478 /* do not touch it for now */ 479 480 /* 21, setup pause frame thresholds */ 481 /* so not touch the defaults */ 482 /* XXX - must 0xff be written as stated in the manual? */ 483 484 /* 22, configure RED */ 485 /* we do not want to drop packets, so ignore */ 486 487 /* 23, initiate RLDRAM */ 488 val = PIF_RCSR(MC_RLDRAM_MRS); 489 val |= MC_QUEUE_SIZE_ENABLE|MC_RLDRAM_MRS_ENABLE; 490 PIF_WCSR(MC_RLDRAM_MRS, val); 491 DELAY(1000); 492 493 /* 494 * Setup interrupt policies. 495 */ 496 /* 40, Transmit interrupts */ 497 PIF_WCSR(TTI_DATA1_MEM, TX_TIMER_VAL(0x1ff) | TX_TIMER_AC | 498 TX_URNG_A(5) | TX_URNG_B(20) | TX_URNG_C(48)); 499 PIF_WCSR(TTI_DATA2_MEM, 500 TX_UFC_A(25) | TX_UFC_B(64) | TX_UFC_C(128) | TX_UFC_D(512)); 501 PIF_WCSR(TTI_COMMAND_MEM, TTI_CMD_MEM_WE | TTI_CMD_MEM_STROBE); 502 while (PIF_RCSR(TTI_COMMAND_MEM) & TTI_CMD_MEM_STROBE) 503 ; 504 505 /* 41, Receive interrupts */ 506 PIF_WCSR(RTI_DATA1_MEM, RX_TIMER_VAL(0x800) | RX_TIMER_AC | 507 RX_URNG_A(5) | RX_URNG_B(20) | RX_URNG_C(50)); 508 PIF_WCSR(RTI_DATA2_MEM, 509 RX_UFC_A(64) | RX_UFC_B(128) | RX_UFC_C(256) | RX_UFC_D(512)); 510 PIF_WCSR(RTI_COMMAND_MEM, RTI_CMD_MEM_WE | RTI_CMD_MEM_STROBE); 511 while (PIF_RCSR(RTI_COMMAND_MEM) & RTI_CMD_MEM_STROBE) 512 ; 513 514 /* 515 * Setup media stuff. 516 */ 517 ifmedia_init(&sc->xena_media, IFM_IMASK, xge_xgmii_mediachange, 518 xge_ifmedia_status); 519 ifmedia_add(&sc->xena_media, IFM_ETHER|IFM_10G_LR, 0, NULL); 520 ifmedia_set(&sc->xena_media, IFM_ETHER|IFM_10G_LR); 521 522 aprint_normal("%s: Ethernet address %s\n", XNAME, 523 ether_sprintf(enaddr)); 524 525 ifp = &sc->sc_ethercom.ec_if; 526 strcpy(ifp->if_xname, sc->sc_dev.dv_xname); 527 ifp->if_baudrate = 10000000000LL; 528 ifp->if_init = xge_init; 529 ifp->if_stop = xge_stop; 530 ifp->if_softc = sc; 531 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 532 ifp->if_ioctl = xge_ioctl; 533 ifp->if_start = xge_start; 534 IFQ_SET_MAXLEN(&ifp->if_snd, max(NTXDESCS - 1, IFQ_MAXLEN)); 535 IFQ_SET_READY(&ifp->if_snd); 536 537 /* 538 * Offloading capabilities. 539 */ 540 sc->sc_ethercom.ec_capabilities |= 541 ETHERCAP_JUMBO_MTU | ETHERCAP_VLAN_MTU; 542 ifp->if_capabilities |= 543 IFCAP_CSUM_IPv4_Rx | IFCAP_CSUM_IPv4_Tx | 544 IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv4_Tx | 545 IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv4_Tx | IFCAP_TSOv4; 546 547 /* 548 * Attach the interface. 549 */ 550 if_attach(ifp); 551 ether_ifattach(ifp, enaddr); 552 553 /* 554 * Setup interrupt vector before initializing. 555 */ 556 if (pci_intr_map(pa, &ih)) 557 return aprint_error("%s: unable to map interrupt\n", 558 sc->sc_dev.dv_xname); 559 intrstr = pci_intr_string(pc, ih); 560 if ((sc->sc_ih = 561 pci_intr_establish(pc, ih, IPL_NET, xge_intr, sc)) == NULL) 562 return aprint_error("%s: unable to establish interrupt at %s\n", 563 sc->sc_dev.dv_xname, intrstr ? intrstr : "<unknown>"); 564 aprint_normal("%s: interrupting at %s\n", sc->sc_dev.dv_xname, intrstr); 565 566 #ifdef XGE_EVENT_COUNTERS 567 evcnt_attach_dynamic(&sc->sc_intr, EVCNT_TYPE_MISC, 568 NULL, XNAME, "intr"); 569 evcnt_attach_dynamic(&sc->sc_txintr, EVCNT_TYPE_MISC, 570 NULL, XNAME, "txintr"); 571 evcnt_attach_dynamic(&sc->sc_rxintr, EVCNT_TYPE_MISC, 572 NULL, XNAME, "rxintr"); 573 evcnt_attach_dynamic(&sc->sc_txqe, EVCNT_TYPE_MISC, 574 NULL, XNAME, "txqe"); 575 #endif 576 } 577 578 void 579 xge_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr) 580 { 581 struct xge_softc *sc = ifp->if_softc; 582 uint64_t reg; 583 584 ifmr->ifm_status = IFM_AVALID; 585 ifmr->ifm_active = IFM_ETHER|IFM_10G_LR; 586 587 reg = PIF_RCSR(ADAPTER_STATUS); 588 if ((reg & (RMAC_REMOTE_FAULT|RMAC_LOCAL_FAULT)) == 0) 589 ifmr->ifm_status |= IFM_ACTIVE; 590 } 591 592 int 593 xge_xgmii_mediachange(struct ifnet *ifp) 594 { 595 return 0; 596 } 597 598 static void 599 xge_enable(struct xge_softc *sc) 600 { 601 uint64_t val; 602 603 /* 2, enable adapter */ 604 val = PIF_RCSR(ADAPTER_CONTROL); 605 val |= ADAPTER_EN; 606 PIF_WCSR(ADAPTER_CONTROL, val); 607 608 /* 3, light the card enable led */ 609 val = PIF_RCSR(ADAPTER_CONTROL); 610 val |= LED_ON; 611 PIF_WCSR(ADAPTER_CONTROL, val); 612 printf("%s: link up\n", XNAME); 613 614 } 615 616 int 617 xge_init(struct ifnet *ifp) 618 { 619 struct xge_softc *sc = ifp->if_softc; 620 uint64_t val; 621 622 if (ifp->if_flags & IFF_RUNNING) 623 return 0; 624 625 /* 31+32, setup MAC config */ 626 PIF_WKEY(MAC_CFG, TMAC_EN|RMAC_EN|TMAC_APPEND_PAD|RMAC_STRIP_FCS| 627 RMAC_BCAST_EN|RMAC_DISCARD_PFRM|RMAC_PROM_EN); 628 629 DELAY(1000); 630 631 /* 54, ensure that the adapter is 'quiescent' */ 632 val = PIF_RCSR(ADAPTER_STATUS); 633 if ((val & QUIESCENT) != QUIESCENT) { 634 char buf[200]; 635 printf("%s: adapter not quiescent, aborting\n", XNAME); 636 val = (val & QUIESCENT) ^ QUIESCENT; 637 bitmask_snprintf(val, QUIESCENT_BMSK, buf, sizeof buf); 638 printf("%s: ADAPTER_STATUS missing bits %s\n", XNAME, buf); 639 return 1; 640 } 641 642 /* 56, enable the transmit laser */ 643 val = PIF_RCSR(ADAPTER_CONTROL); 644 val |= EOI_TX_ON; 645 PIF_WCSR(ADAPTER_CONTROL, val); 646 647 xge_enable(sc); 648 /* 649 * Enable all interrupts 650 */ 651 PIF_WCSR(TX_TRAFFIC_MASK, 0); 652 PIF_WCSR(RX_TRAFFIC_MASK, 0); 653 PIF_WCSR(GENERAL_INT_MASK, 0); 654 PIF_WCSR(TXPIC_INT_MASK, 0); 655 PIF_WCSR(RXPIC_INT_MASK, 0); 656 PIF_WCSR(MAC_INT_MASK, MAC_TMAC_INT); /* only from RMAC */ 657 PIF_WCSR(MAC_RMAC_ERR_MASK, ~RMAC_LINK_STATE_CHANGE_INT); 658 659 660 /* Done... */ 661 ifp->if_flags |= IFF_RUNNING; 662 ifp->if_flags &= ~IFF_OACTIVE; 663 664 return 0; 665 } 666 667 static void 668 xge_stop(struct ifnet *ifp, int disable) 669 { 670 struct xge_softc *sc = ifp->if_softc; 671 uint64_t val; 672 673 val = PIF_RCSR(ADAPTER_CONTROL); 674 val &= ~ADAPTER_EN; 675 PIF_WCSR(ADAPTER_CONTROL, val); 676 677 while ((PIF_RCSR(ADAPTER_STATUS) & QUIESCENT) != QUIESCENT) 678 ; 679 } 680 681 int 682 xge_intr(void *pv) 683 { 684 struct xge_softc *sc = pv; 685 struct txd *txd; 686 struct ifnet *ifp = &sc->sc_if; 687 bus_dmamap_t dmp; 688 uint64_t val; 689 int i, lasttx, plen; 690 691 val = PIF_RCSR(GENERAL_INT_STATUS); 692 if (val == 0) 693 return 0; /* no interrupt here */ 694 695 XGE_EVCNT_INCR(&sc->sc_intr); 696 697 PIF_WCSR(GENERAL_INT_STATUS, val); 698 699 if ((val = PIF_RCSR(MAC_RMAC_ERR_REG)) & RMAC_LINK_STATE_CHANGE_INT) { 700 /* Wait for quiescence */ 701 printf("%s: link down\n", XNAME); 702 while ((PIF_RCSR(ADAPTER_STATUS) & QUIESCENT) != QUIESCENT) 703 ; 704 PIF_WCSR(MAC_RMAC_ERR_REG, RMAC_LINK_STATE_CHANGE_INT); 705 706 val = PIF_RCSR(ADAPTER_STATUS); 707 if ((val & (RMAC_REMOTE_FAULT|RMAC_LOCAL_FAULT)) == 0) 708 xge_enable(sc); /* Only if link restored */ 709 } 710 711 if ((val = PIF_RCSR(TX_TRAFFIC_INT))) { 712 XGE_EVCNT_INCR(&sc->sc_txintr); 713 PIF_WCSR(TX_TRAFFIC_INT, val); /* clear interrupt bits */ 714 } 715 /* 716 * Collect sent packets. 717 */ 718 lasttx = sc->sc_lasttx; 719 while ((i = NEXTTX(sc->sc_lasttx)) != sc->sc_nexttx) { 720 txd = sc->sc_txd[i]; 721 dmp = sc->sc_txm[i]; 722 723 bus_dmamap_sync(sc->sc_dmat, dmp, 0, 724 dmp->dm_mapsize, 725 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); 726 727 if (txd->txd_control1 & TXD_CTL1_OWN) { 728 bus_dmamap_sync(sc->sc_dmat, dmp, 0, 729 dmp->dm_mapsize, BUS_DMASYNC_PREREAD); 730 break; 731 } 732 bus_dmamap_unload(sc->sc_dmat, dmp); 733 m_freem(sc->sc_txb[i]); 734 ifp->if_opackets++; 735 sc->sc_lasttx = i; 736 } 737 if (i == sc->sc_nexttx) { 738 XGE_EVCNT_INCR(&sc->sc_txqe); 739 } 740 741 if (sc->sc_lasttx != lasttx) 742 ifp->if_flags &= ~IFF_OACTIVE; 743 744 xge_start(ifp); /* Try to get more packets on the wire */ 745 746 if ((val = PIF_RCSR(RX_TRAFFIC_INT))) { 747 XGE_EVCNT_INCR(&sc->sc_rxintr); 748 PIF_WCSR(RX_TRAFFIC_INT, val); /* clear interrupt bits */ 749 } 750 751 for (;;) { 752 struct rxdesc *rxd; 753 struct mbuf *m; 754 755 XGE_RXSYNC(sc->sc_nextrx, 756 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); 757 758 rxd = XGE_RXD(sc->sc_nextrx); 759 if (rxd->rxd_control1 & RXD_CTL1_OWN) { 760 XGE_RXSYNC(sc->sc_nextrx, BUS_DMASYNC_PREREAD); 761 break; 762 } 763 764 /* got a packet */ 765 m = sc->sc_rxb[sc->sc_nextrx]; 766 #if RX_MODE == RX_MODE_1 767 plen = m->m_len = RXD_CTL2_BUF0SIZ(rxd->rxd_control2); 768 #elif RX_MODE == RX_MODE_3 769 #error Fix rxmodes in xge_intr 770 #elif RX_MODE == RX_MODE_5 771 plen = m->m_len = RXD_CTL2_BUF0SIZ(rxd->rxd_control2); 772 plen += m->m_next->m_len = RXD_CTL2_BUF1SIZ(rxd->rxd_control2); 773 plen += m->m_next->m_next->m_len = 774 RXD_CTL2_BUF2SIZ(rxd->rxd_control2); 775 plen += m->m_next->m_next->m_next->m_len = 776 RXD_CTL3_BUF3SIZ(rxd->rxd_control3); 777 plen += m->m_next->m_next->m_next->m_next->m_len = 778 RXD_CTL3_BUF4SIZ(rxd->rxd_control3); 779 #endif 780 m->m_pkthdr.rcvif = ifp; 781 m->m_pkthdr.len = plen; 782 783 val = rxd->rxd_control1; 784 785 if (xge_add_rxbuf(sc, sc->sc_nextrx)) { 786 /* Failed, recycle this mbuf */ 787 #if RX_MODE == RX_MODE_1 788 rxd->rxd_control2 = RXD_MKCTL2(MCLBYTES, 0, 0); 789 rxd->rxd_control1 = RXD_CTL1_OWN; 790 #elif RX_MODE == RX_MODE_3 791 #elif RX_MODE == RX_MODE_5 792 #endif 793 XGE_RXSYNC(sc->sc_nextrx, 794 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 795 ifp->if_ierrors++; 796 break; 797 } 798 799 ifp->if_ipackets++; 800 801 if (RXD_CTL1_PROTOS(val) & (RXD_CTL1_P_IPv4|RXD_CTL1_P_IPv6)) { 802 m->m_pkthdr.csum_flags |= M_CSUM_IPv4; 803 if (RXD_CTL1_L3CSUM(val) != 0xffff) 804 m->m_pkthdr.csum_flags |= M_CSUM_IPv4_BAD; 805 } 806 if (RXD_CTL1_PROTOS(val) & RXD_CTL1_P_TCP) { 807 m->m_pkthdr.csum_flags |= M_CSUM_TCPv4|M_CSUM_TCPv6; 808 if (RXD_CTL1_L4CSUM(val) != 0xffff) 809 m->m_pkthdr.csum_flags |= M_CSUM_TCP_UDP_BAD; 810 } 811 if (RXD_CTL1_PROTOS(val) & RXD_CTL1_P_UDP) { 812 m->m_pkthdr.csum_flags |= M_CSUM_UDPv4|M_CSUM_UDPv6; 813 if (RXD_CTL1_L4CSUM(val) != 0xffff) 814 m->m_pkthdr.csum_flags |= M_CSUM_TCP_UDP_BAD; 815 } 816 817 #if NBPFILTER > 0 818 if (ifp->if_bpf) 819 bpf_mtap(ifp->if_bpf, m); 820 #endif /* NBPFILTER > 0 */ 821 822 (*ifp->if_input)(ifp, m); 823 824 if (++sc->sc_nextrx == NRXREAL) 825 sc->sc_nextrx = 0; 826 827 } 828 829 return 0; 830 } 831 832 int 833 xge_ioctl(struct ifnet *ifp, u_long cmd, void *data) 834 { 835 struct xge_softc *sc = ifp->if_softc; 836 struct ifreq *ifr = (struct ifreq *) data; 837 int s, error = 0; 838 839 s = splnet(); 840 841 switch (cmd) { 842 case SIOCSIFMTU: 843 if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > XGE_MAX_MTU) 844 error = EINVAL; 845 else if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET){ 846 PIF_WCSR(RMAC_MAX_PYLD_LEN, 847 RMAC_PYLD_LEN(ifr->ifr_mtu)); 848 error = 0; 849 } 850 break; 851 852 case SIOCGIFMEDIA: 853 case SIOCSIFMEDIA: 854 error = ifmedia_ioctl(ifp, ifr, &sc->xena_media, cmd); 855 break; 856 857 default: 858 if ((error = ether_ioctl(ifp, cmd, data)) != ENETRESET) 859 break; 860 861 error = 0; 862 863 if (cmd != SIOCADDMULTI && cmd != SIOCDELMULTI) 864 ; 865 else if (ifp->if_flags & IFF_RUNNING) { 866 /* Change multicast list */ 867 xge_mcast_filter(sc); 868 } 869 break; 870 } 871 872 splx(s); 873 return(error); 874 } 875 876 void 877 xge_mcast_filter(struct xge_softc *sc) 878 { 879 struct ifnet *ifp = &sc->sc_ethercom.ec_if; 880 struct ethercom *ec = &sc->sc_ethercom; 881 struct ether_multi *enm; 882 struct ether_multistep step; 883 int i, numaddr = 1; /* first slot used for card unicast address */ 884 uint64_t val; 885 886 ETHER_FIRST_MULTI(step, ec, enm); 887 while (enm != NULL) { 888 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) { 889 /* Skip ranges */ 890 goto allmulti; 891 } 892 if (numaddr == MAX_MCAST_ADDR) 893 goto allmulti; 894 for (val = 0, i = 0; i < ETHER_ADDR_LEN; i++) { 895 val <<= 8; 896 val |= enm->enm_addrlo[i]; 897 } 898 PIF_WCSR(RMAC_ADDR_DATA0_MEM, val << 16); 899 PIF_WCSR(RMAC_ADDR_DATA1_MEM, 0xFFFFFFFFFFFFFFFFULL); 900 PIF_WCSR(RMAC_ADDR_CMD_MEM, RMAC_ADDR_CMD_MEM_WE| 901 RMAC_ADDR_CMD_MEM_STR|RMAC_ADDR_CMD_MEM_OFF(numaddr)); 902 while (PIF_RCSR(RMAC_ADDR_CMD_MEM) & RMAC_ADDR_CMD_MEM_STR) 903 ; 904 numaddr++; 905 ETHER_NEXT_MULTI(step, enm); 906 } 907 /* set the remaining entries to the broadcast address */ 908 for (i = numaddr; i < MAX_MCAST_ADDR; i++) { 909 PIF_WCSR(RMAC_ADDR_DATA0_MEM, 0xffffffffffff0000ULL); 910 PIF_WCSR(RMAC_ADDR_DATA1_MEM, 0xFFFFFFFFFFFFFFFFULL); 911 PIF_WCSR(RMAC_ADDR_CMD_MEM, RMAC_ADDR_CMD_MEM_WE| 912 RMAC_ADDR_CMD_MEM_STR|RMAC_ADDR_CMD_MEM_OFF(i)); 913 while (PIF_RCSR(RMAC_ADDR_CMD_MEM) & RMAC_ADDR_CMD_MEM_STR) 914 ; 915 } 916 ifp->if_flags &= ~IFF_ALLMULTI; 917 return; 918 919 allmulti: 920 /* Just receive everything with the multicast bit set */ 921 ifp->if_flags |= IFF_ALLMULTI; 922 PIF_WCSR(RMAC_ADDR_DATA0_MEM, 0x8000000000000000ULL); 923 PIF_WCSR(RMAC_ADDR_DATA1_MEM, 0xF000000000000000ULL); 924 PIF_WCSR(RMAC_ADDR_CMD_MEM, RMAC_ADDR_CMD_MEM_WE| 925 RMAC_ADDR_CMD_MEM_STR|RMAC_ADDR_CMD_MEM_OFF(1)); 926 while (PIF_RCSR(RMAC_ADDR_CMD_MEM) & RMAC_ADDR_CMD_MEM_STR) 927 ; 928 } 929 930 void 931 xge_start(struct ifnet *ifp) 932 { 933 struct xge_softc *sc = ifp->if_softc; 934 struct txd *txd = NULL; /* XXX - gcc */ 935 bus_dmamap_t dmp; 936 struct mbuf *m; 937 uint64_t par, lcr; 938 int nexttx = 0, ntxd, error, i; 939 940 if ((ifp->if_flags & (IFF_RUNNING|IFF_OACTIVE)) != IFF_RUNNING) 941 return; 942 943 par = lcr = 0; 944 for (;;) { 945 IFQ_POLL(&ifp->if_snd, m); 946 if (m == NULL) 947 break; /* out of packets */ 948 949 if (sc->sc_nexttx == sc->sc_lasttx) 950 break; /* No more space */ 951 952 nexttx = sc->sc_nexttx; 953 dmp = sc->sc_txm[nexttx]; 954 955 if ((error = bus_dmamap_load_mbuf(sc->sc_dmat, dmp, m, 956 BUS_DMA_WRITE|BUS_DMA_NOWAIT)) != 0) { 957 printf("%s: bus_dmamap_load_mbuf error %d\n", 958 XNAME, error); 959 break; 960 } 961 IFQ_DEQUEUE(&ifp->if_snd, m); 962 963 bus_dmamap_sync(sc->sc_dmat, dmp, 0, dmp->dm_mapsize, 964 BUS_DMASYNC_PREWRITE); 965 966 txd = sc->sc_txd[nexttx]; 967 sc->sc_txb[nexttx] = m; 968 for (i = 0; i < dmp->dm_nsegs; i++) { 969 if (dmp->dm_segs[i].ds_len == 0) 970 continue; 971 txd->txd_control1 = dmp->dm_segs[i].ds_len; 972 txd->txd_control2 = 0; 973 txd->txd_bufaddr = dmp->dm_segs[i].ds_addr; 974 txd++; 975 } 976 ntxd = txd - sc->sc_txd[nexttx] - 1; 977 txd = sc->sc_txd[nexttx]; 978 txd->txd_control1 |= TXD_CTL1_OWN|TXD_CTL1_GCF; 979 txd->txd_control2 = TXD_CTL2_UTIL; 980 if (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) { 981 txd->txd_control1 |= TXD_CTL1_MSS(m->m_pkthdr.segsz); 982 txd->txd_control1 |= TXD_CTL1_LSO; 983 } 984 985 if (m->m_pkthdr.csum_flags & M_CSUM_IPv4) 986 txd->txd_control2 |= TXD_CTL2_CIPv4; 987 if (m->m_pkthdr.csum_flags & M_CSUM_TCPv4) 988 txd->txd_control2 |= TXD_CTL2_CTCP; 989 if (m->m_pkthdr.csum_flags & M_CSUM_UDPv4) 990 txd->txd_control2 |= TXD_CTL2_CUDP; 991 txd[ntxd].txd_control1 |= TXD_CTL1_GCL; 992 993 bus_dmamap_sync(sc->sc_dmat, dmp, 0, dmp->dm_mapsize, 994 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 995 996 par = sc->sc_txdp[nexttx]; 997 lcr = TXDL_NUMTXD(ntxd) | TXDL_LGC_FIRST | TXDL_LGC_LAST; 998 if (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) 999 lcr |= TXDL_SFF; 1000 TXP_WCSR(TXDL_PAR, par); 1001 TXP_WCSR(TXDL_LCR, lcr); 1002 1003 #if NBPFILTER > 0 1004 if (ifp->if_bpf) 1005 bpf_mtap(ifp->if_bpf, m); 1006 #endif /* NBPFILTER > 0 */ 1007 1008 sc->sc_nexttx = NEXTTX(nexttx); 1009 } 1010 } 1011 1012 /* 1013 * Allocate DMA memory for transmit descriptor fragments. 1014 * Only one map is used for all descriptors. 1015 */ 1016 int 1017 xge_alloc_txmem(struct xge_softc *sc) 1018 { 1019 struct txd *txp; 1020 bus_dma_segment_t seg; 1021 bus_addr_t txdp; 1022 void *kva; 1023 int i, rseg, state; 1024 1025 #define TXMAPSZ (NTXDESCS*NTXFRAGS*sizeof(struct txd)) 1026 state = 0; 1027 if (bus_dmamem_alloc(sc->sc_dmat, TXMAPSZ, PAGE_SIZE, 0, 1028 &seg, 1, &rseg, BUS_DMA_NOWAIT)) 1029 goto err; 1030 state++; 1031 if (bus_dmamem_map(sc->sc_dmat, &seg, rseg, TXMAPSZ, &kva, 1032 BUS_DMA_NOWAIT)) 1033 goto err; 1034 1035 state++; 1036 if (bus_dmamap_create(sc->sc_dmat, TXMAPSZ, 1, TXMAPSZ, 0, 1037 BUS_DMA_NOWAIT, &sc->sc_txmap)) 1038 goto err; 1039 state++; 1040 if (bus_dmamap_load(sc->sc_dmat, sc->sc_txmap, 1041 kva, TXMAPSZ, NULL, BUS_DMA_NOWAIT)) 1042 goto err; 1043 1044 /* setup transmit array pointers */ 1045 txp = (struct txd *)kva; 1046 txdp = seg.ds_addr; 1047 for (txp = (struct txd *)kva, i = 0; i < NTXDESCS; i++) { 1048 sc->sc_txd[i] = txp; 1049 sc->sc_txdp[i] = txdp; 1050 txp += NTXFRAGS; 1051 txdp += (NTXFRAGS * sizeof(struct txd)); 1052 } 1053 1054 return 0; 1055 1056 err: 1057 if (state > 2) 1058 bus_dmamap_destroy(sc->sc_dmat, sc->sc_txmap); 1059 if (state > 1) 1060 bus_dmamem_unmap(sc->sc_dmat, kva, TXMAPSZ); 1061 if (state > 0) 1062 bus_dmamem_free(sc->sc_dmat, &seg, rseg); 1063 return ENOBUFS; 1064 } 1065 1066 /* 1067 * Allocate DMA memory for receive descriptor, 1068 * only one map is used for all descriptors. 1069 * link receive descriptor pages together. 1070 */ 1071 int 1072 xge_alloc_rxmem(struct xge_softc *sc) 1073 { 1074 struct rxd_4k *rxpp; 1075 bus_dma_segment_t seg; 1076 void *kva; 1077 int i, rseg, state; 1078 1079 /* sanity check */ 1080 if (sizeof(struct rxd_4k) != XGE_PAGE) { 1081 printf("bad compiler struct alignment, %d != %d\n", 1082 (int)sizeof(struct rxd_4k), XGE_PAGE); 1083 return EINVAL; 1084 } 1085 1086 state = 0; 1087 if (bus_dmamem_alloc(sc->sc_dmat, RXMAPSZ, PAGE_SIZE, 0, 1088 &seg, 1, &rseg, BUS_DMA_NOWAIT)) 1089 goto err; 1090 state++; 1091 if (bus_dmamem_map(sc->sc_dmat, &seg, rseg, RXMAPSZ, &kva, 1092 BUS_DMA_NOWAIT)) 1093 goto err; 1094 1095 state++; 1096 if (bus_dmamap_create(sc->sc_dmat, RXMAPSZ, 1, RXMAPSZ, 0, 1097 BUS_DMA_NOWAIT, &sc->sc_rxmap)) 1098 goto err; 1099 state++; 1100 if (bus_dmamap_load(sc->sc_dmat, sc->sc_rxmap, 1101 kva, RXMAPSZ, NULL, BUS_DMA_NOWAIT)) 1102 goto err; 1103 1104 /* setup receive page link pointers */ 1105 for (rxpp = (struct rxd_4k *)kva, i = 0; i < NRXPAGES; i++, rxpp++) { 1106 sc->sc_rxd_4k[i] = rxpp; 1107 rxpp->r4_next = (uint64_t)sc->sc_rxmap->dm_segs[0].ds_addr + 1108 (i*sizeof(struct rxd_4k)) + sizeof(struct rxd_4k); 1109 } 1110 sc->sc_rxd_4k[NRXPAGES-1]->r4_next = 1111 (uint64_t)sc->sc_rxmap->dm_segs[0].ds_addr; 1112 1113 return 0; 1114 1115 err: 1116 if (state > 2) 1117 bus_dmamap_destroy(sc->sc_dmat, sc->sc_txmap); 1118 if (state > 1) 1119 bus_dmamem_unmap(sc->sc_dmat, kva, TXMAPSZ); 1120 if (state > 0) 1121 bus_dmamem_free(sc->sc_dmat, &seg, rseg); 1122 return ENOBUFS; 1123 } 1124 1125 1126 /* 1127 * Add a new mbuf chain to descriptor id. 1128 */ 1129 int 1130 xge_add_rxbuf(struct xge_softc *sc, int id) 1131 { 1132 struct rxdesc *rxd; 1133 struct mbuf *m[5]; 1134 int page, desc, error; 1135 #if RX_MODE == RX_MODE_5 1136 int i; 1137 #endif 1138 1139 page = id/NDESC_BUFMODE; 1140 desc = id%NDESC_BUFMODE; 1141 1142 rxd = &sc->sc_rxd_4k[page]->r4_rxd[desc]; 1143 1144 /* 1145 * Allocate mbufs. 1146 * Currently five mbufs and two clusters are used, 1147 * the hardware will put (ethernet, ip, tcp/udp) headers in 1148 * their own buffer and the clusters are only used for data. 1149 */ 1150 #if RX_MODE == RX_MODE_1 1151 MGETHDR(m[0], M_DONTWAIT, MT_DATA); 1152 if (m[0] == NULL) 1153 return ENOBUFS; 1154 MCLGET(m[0], M_DONTWAIT); 1155 if ((m[0]->m_flags & M_EXT) == 0) { 1156 m_freem(m[0]); 1157 return ENOBUFS; 1158 } 1159 m[0]->m_len = m[0]->m_pkthdr.len = m[0]->m_ext.ext_size; 1160 #elif RX_MODE == RX_MODE_3 1161 #error missing rxmode 3. 1162 #elif RX_MODE == RX_MODE_5 1163 MGETHDR(m[0], M_DONTWAIT, MT_DATA); 1164 for (i = 1; i < 5; i++) { 1165 MGET(m[i], M_DONTWAIT, MT_DATA); 1166 } 1167 if (m[3]) 1168 MCLGET(m[3], M_DONTWAIT); 1169 if (m[4]) 1170 MCLGET(m[4], M_DONTWAIT); 1171 if (!m[0] || !m[1] || !m[2] || !m[3] || !m[4] || 1172 ((m[3]->m_flags & M_EXT) == 0) || ((m[4]->m_flags & M_EXT) == 0)) { 1173 /* Out of something */ 1174 for (i = 0; i < 5; i++) 1175 if (m[i] != NULL) 1176 m_free(m[i]); 1177 return ENOBUFS; 1178 } 1179 /* Link'em together */ 1180 m[0]->m_next = m[1]; 1181 m[1]->m_next = m[2]; 1182 m[2]->m_next = m[3]; 1183 m[3]->m_next = m[4]; 1184 #else 1185 #error bad mode RX_MODE 1186 #endif 1187 1188 if (sc->sc_rxb[id]) 1189 bus_dmamap_unload(sc->sc_dmat, sc->sc_rxm[id]); 1190 sc->sc_rxb[id] = m[0]; 1191 1192 error = bus_dmamap_load_mbuf(sc->sc_dmat, sc->sc_rxm[id], m[0], 1193 BUS_DMA_READ|BUS_DMA_NOWAIT); 1194 if (error) 1195 return error; 1196 bus_dmamap_sync(sc->sc_dmat, sc->sc_rxm[id], 0, 1197 sc->sc_rxm[id]->dm_mapsize, BUS_DMASYNC_PREREAD); 1198 1199 #if RX_MODE == RX_MODE_1 1200 rxd->rxd_control2 = RXD_MKCTL2(m[0]->m_len, 0, 0); 1201 rxd->rxd_buf0 = (uint64_t)sc->sc_rxm[id]->dm_segs[0].ds_addr; 1202 rxd->rxd_control1 = RXD_CTL1_OWN; 1203 #elif RX_MODE == RX_MODE_3 1204 #elif RX_MODE == RX_MODE_5 1205 rxd->rxd_control3 = RXD_MKCTL3(0, m[3]->m_len, m[4]->m_len); 1206 rxd->rxd_control2 = RXD_MKCTL2(m[0]->m_len, m[1]->m_len, m[2]->m_len); 1207 rxd->rxd_buf0 = (uint64_t)sc->sc_rxm[id]->dm_segs[0].ds_addr; 1208 rxd->rxd_buf1 = (uint64_t)sc->sc_rxm[id]->dm_segs[1].ds_addr; 1209 rxd->rxd_buf2 = (uint64_t)sc->sc_rxm[id]->dm_segs[2].ds_addr; 1210 rxd->rxd_buf3 = (uint64_t)sc->sc_rxm[id]->dm_segs[3].ds_addr; 1211 rxd->rxd_buf4 = (uint64_t)sc->sc_rxm[id]->dm_segs[4].ds_addr; 1212 rxd->rxd_control1 = RXD_CTL1_OWN; 1213 #endif 1214 1215 XGE_RXSYNC(id, BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE); 1216 return 0; 1217 } 1218 1219 /* 1220 * These magics comes from the FreeBSD driver. 1221 */ 1222 int 1223 xge_setup_xgxs(struct xge_softc *sc) 1224 { 1225 /* The magic numbers are described in the users guide */ 1226 1227 /* Writing to MDIO 0x8000 (Global Config 0) */ 1228 PIF_WCSR(DTX_CONTROL, 0x8000051500000000ULL); DELAY(50); 1229 PIF_WCSR(DTX_CONTROL, 0x80000515000000E0ULL); DELAY(50); 1230 PIF_WCSR(DTX_CONTROL, 0x80000515D93500E4ULL); DELAY(50); 1231 1232 /* Writing to MDIO 0x8000 (Global Config 1) */ 1233 PIF_WCSR(DTX_CONTROL, 0x8001051500000000ULL); DELAY(50); 1234 PIF_WCSR(DTX_CONTROL, 0x80010515000000e0ULL); DELAY(50); 1235 PIF_WCSR(DTX_CONTROL, 0x80010515001e00e4ULL); DELAY(50); 1236 1237 /* Reset the Gigablaze */ 1238 PIF_WCSR(DTX_CONTROL, 0x8002051500000000ULL); DELAY(50); 1239 PIF_WCSR(DTX_CONTROL, 0x80020515000000E0ULL); DELAY(50); 1240 PIF_WCSR(DTX_CONTROL, 0x80020515F21000E4ULL); DELAY(50); 1241 1242 /* read the pole settings */ 1243 PIF_WCSR(DTX_CONTROL, 0x8000051500000000ULL); DELAY(50); 1244 PIF_WCSR(DTX_CONTROL, 0x80000515000000e0ULL); DELAY(50); 1245 PIF_WCSR(DTX_CONTROL, 0x80000515000000ecULL); DELAY(50); 1246 1247 PIF_WCSR(DTX_CONTROL, 0x8001051500000000ULL); DELAY(50); 1248 PIF_WCSR(DTX_CONTROL, 0x80010515000000e0ULL); DELAY(50); 1249 PIF_WCSR(DTX_CONTROL, 0x80010515000000ecULL); DELAY(50); 1250 1251 PIF_WCSR(DTX_CONTROL, 0x8002051500000000ULL); DELAY(50); 1252 PIF_WCSR(DTX_CONTROL, 0x80020515000000e0ULL); DELAY(50); 1253 PIF_WCSR(DTX_CONTROL, 0x80020515000000ecULL); DELAY(50); 1254 1255 /* Workaround for TX Lane XAUI initialization error. 1256 Read Xpak PHY register 24 for XAUI lane status */ 1257 PIF_WCSR(DTX_CONTROL, 0x0018040000000000ULL); DELAY(50); 1258 PIF_WCSR(DTX_CONTROL, 0x00180400000000e0ULL); DELAY(50); 1259 PIF_WCSR(DTX_CONTROL, 0x00180400000000ecULL); DELAY(50); 1260 1261 /* 1262 * Reading the MDIO control with value 0x1804001c0F001c 1263 * means the TxLanes were already in sync 1264 * Reading the MDIO control with value 0x1804000c0x001c 1265 * means some TxLanes are not in sync where x is a 4-bit 1266 * value representing each lanes 1267 */ 1268 #if 0 1269 val = PIF_RCSR(MDIO_CONTROL); 1270 if (val != 0x1804001c0F001cULL) { 1271 printf("%s: MDIO_CONTROL: %llx != %llx\n", 1272 XNAME, val, 0x1804001c0F001cULL); 1273 return 1; 1274 } 1275 #endif 1276 1277 /* Set and remove the DTE XS INTLoopBackN */ 1278 PIF_WCSR(DTX_CONTROL, 0x0000051500000000ULL); DELAY(50); 1279 PIF_WCSR(DTX_CONTROL, 0x00000515604000e0ULL); DELAY(50); 1280 PIF_WCSR(DTX_CONTROL, 0x00000515604000e4ULL); DELAY(50); 1281 PIF_WCSR(DTX_CONTROL, 0x00000515204000e4ULL); DELAY(50); 1282 PIF_WCSR(DTX_CONTROL, 0x00000515204000ecULL); DELAY(50); 1283 1284 #if 0 1285 /* Reading the DTX control register Should be 0x5152040001c */ 1286 val = PIF_RCSR(DTX_CONTROL); 1287 if (val != 0x5152040001cULL) { 1288 printf("%s: DTX_CONTROL: %llx != %llx\n", 1289 XNAME, val, 0x5152040001cULL); 1290 return 1; 1291 } 1292 #endif 1293 1294 PIF_WCSR(MDIO_CONTROL, 0x0018040000000000ULL); DELAY(50); 1295 PIF_WCSR(MDIO_CONTROL, 0x00180400000000e0ULL); DELAY(50); 1296 PIF_WCSR(MDIO_CONTROL, 0x00180400000000ecULL); DELAY(50); 1297 1298 #if 0 1299 /* Reading the MIOD control should be 0x1804001c0f001c */ 1300 val = PIF_RCSR(MDIO_CONTROL); 1301 if (val != 0x1804001c0f001cULL) { 1302 printf("%s: MDIO_CONTROL2: %llx != %llx\n", 1303 XNAME, val, 0x1804001c0f001cULL); 1304 return 1; 1305 } 1306 #endif 1307 return 0; 1308 } 1309
Indexes created Tue Oct 14 21:09:58 GMT 2025