if_ni.c revision 1.7.2.3
1 /* $NetBSD: if_ni.c,v 1.7.2.3 2000/11/22 16:03:08 bouyer Exp $ */ 2 /* 3 * Copyright (c) 2000 Ludd, University of Lule}, Sweden. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed at Ludd, University of 16 * Lule}, Sweden and its contributors. 17 * 4. The name of the author may not be used to endorse or promote products 18 * derived from this software without specific prior written permission 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Driver for DEBNA/DEBNT/DEBNK ethernet cards. 34 * Things that is still to do: 35 * Collect statistics. 36 */ 37 38 #include "opt_inet.h" 39 #include "bpfilter.h" 40 41 #include <sys/param.h> 42 #include <sys/mbuf.h> 43 #include <sys/socket.h> 44 #include <sys/device.h> 45 #include <sys/systm.h> 46 #include <sys/sockio.h> 47 48 #include <net/if.h> 49 #include <net/if_ether.h> 50 #include <net/if_dl.h> 51 52 #include <netinet/in.h> 53 #include <netinet/if_inarp.h> 54 55 #if NBPFILTER > 0 56 #include <net/bpf.h> 57 #include <net/bpfdesc.h> 58 #endif 59 60 #include <machine/bus.h> 61 #ifdef __vax__ 62 #include <machine/mtpr.h> 63 #include <machine/pte.h> 64 #endif 65 66 #include <dev/bi/bireg.h> 67 #include <dev/bi/bivar.h> 68 69 #include "ioconf.h" 70 #include "locators.h" 71 72 /* 73 * Tunable buffer parameters. Good idea to have them as power of 8; then 74 * they will fit into a logical VAX page. 75 */ 76 #define NMSGBUF 8 /* Message queue entries */ 77 #define NTXBUF 16 /* Transmit queue entries */ 78 #define NTXFRAGS 8 /* Number of transmit buffer fragments */ 79 #define NRXBUF 24 /* Receive queue entries */ 80 #define NBDESCS (NTXBUF * NTXFRAGS + NRXBUF) 81 #define NQUEUES 3 /* RX + TX + MSG */ 82 #define PKTHDR 18 /* Length of (control) packet header */ 83 #define RXADD 18 /* Additional length of receive datagram */ 84 #define TXADD (10+NTXFRAGS*8) /* "" transmit "" */ 85 #define MSGADD 134 /* "" message "" */ 86 87 #include <dev/bi/if_nireg.h> /* XXX include earlier */ 88 89 /* 90 * Macros for (most cases of) insqti/remqhi. 91 * Retry NRETRIES times to do the operation, if it still fails assume 92 * a lost lock and panic. 93 */ 94 #define NRETRIES 100 95 #define INSQTI(e, h) ({ \ 96 int ret, i; \ 97 for (i = 0; i < NRETRIES; i++) { \ 98 if ((ret = insqti(e, h)) != ILCK_FAILED) \ 99 break; \ 100 } \ 101 if (i == NRETRIES) \ 102 panic("ni: insqti failed at %d", __LINE__); \ 103 ret; \ 104 }) 105 #define REMQHI(h) ({ \ 106 int i;void *ret; \ 107 for (i = 0; i < NRETRIES; i++) { \ 108 if ((ret = remqhi(h)) != (void *)ILCK_FAILED) \ 109 break; \ 110 } \ 111 if (i == NRETRIES) \ 112 panic("ni: remqhi failed at %d", __LINE__); \ 113 ret; \ 114 }) 115 116 117 #define nipqb (&sc->sc_gvppqb->nc_pqb) 118 #define gvp sc->sc_gvppqb 119 #define fqb sc->sc_fqb 120 #define bbd sc->sc_bbd 121 122 struct ni_softc { 123 struct device sc_dev; /* Configuration common part */ 124 struct evcnt sc_intrcnt; /* Interrupt coounting */ 125 struct ethercom sc_ec; /* Ethernet common part */ 126 #define sc_if sc_ec.ec_if /* network-visible interface */ 127 bus_space_tag_t sc_iot; 128 bus_addr_t sc_ioh; 129 bus_dma_tag_t sc_dmat; 130 struct ni_gvppqb *sc_gvppqb; /* Port queue block */ 131 struct ni_gvppqb *sc_pgvppqb; /* Phys address of PQB */ 132 struct ni_fqb *sc_fqb; /* Free Queue block */ 133 struct ni_bbd *sc_bbd; /* Buffer descriptors */ 134 u_int8_t sc_enaddr[ETHER_ADDR_LEN]; 135 }; 136 137 static int nimatch __P((struct device *, struct cfdata *, void *)); 138 static void niattach __P((struct device *, struct device *, void *)); 139 static void niinit __P((struct ni_softc *)); 140 static void nistart __P((struct ifnet *)); 141 static void niintr __P((void *)); 142 static int niioctl __P((struct ifnet *, u_long, caddr_t)); 143 static int ni_add_rxbuf(struct ni_softc *, struct ni_dg *, int); 144 static void ni_setup __P((struct ni_softc *)); 145 static void nitimeout __P((struct ifnet *)); 146 static void ni_shutdown(void *); 147 static void ni_getpgs(struct ni_softc *sc, int size, caddr_t *v, paddr_t *p); 148 static int failtest(struct ni_softc *, int, int, int, char *); 149 150 volatile int endwait, retry; /* Used during autoconfig */ 151 152 struct cfattach ni_ca = { 153 sizeof(struct ni_softc), nimatch, niattach 154 }; 155 156 #define NI_WREG(csr, val) \ 157 bus_space_write_4(sc->sc_iot, sc->sc_ioh, csr, val) 158 #define NI_RREG(csr) \ 159 bus_space_read_4(sc->sc_iot, sc->sc_ioh, csr) 160 161 #define WAITREG(csr,val) while (NI_RREG(csr) & val); 162 /* 163 * Check for present device. 164 */ 165 int 166 nimatch(parent, cf, aux) 167 struct device *parent; 168 struct cfdata *cf; 169 void *aux; 170 { 171 struct bi_attach_args *ba = aux; 172 u_short type; 173 174 type = bus_space_read_2(ba->ba_iot, ba->ba_ioh, BIREG_DTYPE); 175 if (type != BIDT_DEBNA && type != BIDT_DEBNT && type != BIDT_DEBNK) 176 return 0; 177 178 if (cf->cf_loc[BICF_NODE] != BICF_NODE_DEFAULT && 179 cf->cf_loc[BICF_NODE] != ba->ba_nodenr) 180 return 0; 181 182 return 1; 183 } 184 185 /* 186 * Allocate a bunch of descriptor-safe memory. 187 * We need to get the structures from the beginning of its own pages. 188 */ 189 static void 190 ni_getpgs(struct ni_softc *sc, int size, caddr_t *v, paddr_t *p) 191 { 192 bus_dma_segment_t seg; 193 int nsegs, error; 194 195 if ((error = bus_dmamem_alloc(sc->sc_dmat, size, NBPG, 0, &seg, 1, 196 &nsegs, BUS_DMA_NOWAIT)) != 0) 197 panic(" unable to allocate memory: error %d", error); 198 199 if ((error = bus_dmamem_map(sc->sc_dmat, &seg, nsegs, size, v, 200 BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) != 0) 201 panic(" unable to map memory: error %d", error); 202 203 if (p) 204 *p = seg.ds_addr; 205 bzero(*v, size); 206 } 207 208 static int 209 failtest(struct ni_softc *sc, int reg, int mask, int test, char *str) 210 { 211 int i = 100; 212 213 do { 214 DELAY(100000); 215 } while (((NI_RREG(reg) & mask) != test) && --i); 216 217 if (i == 0) { 218 printf("%s: %s\n", sc->sc_dev.dv_xname, str); 219 return 1; 220 } 221 return 0; 222 } 223 224 225 /* 226 * Interface exists: make available by filling in network interface 227 * record. System will initialize the interface when it is ready 228 * to accept packets. 229 */ 230 void 231 niattach(parent, self, aux) 232 struct device *parent, *self; 233 void *aux; 234 { 235 struct bi_attach_args *ba = aux; 236 struct ni_softc *sc = (struct ni_softc *)self; 237 struct ifnet *ifp = (struct ifnet *)&sc->sc_if; 238 struct ni_msg *msg; 239 struct ni_ptdb *ptdb; 240 caddr_t va; 241 int i, j, s, res; 242 u_short type; 243 244 type = bus_space_read_2(ba->ba_iot, ba->ba_ioh, BIREG_DTYPE); 245 printf(": DEBN%c\n", type == BIDT_DEBNA ? 'A' : type == BIDT_DEBNT ? 246 'T' : 'K'); 247 sc->sc_iot = ba->ba_iot; 248 sc->sc_ioh = ba->ba_ioh; 249 sc->sc_dmat = ba->ba_dmat; 250 251 bi_intr_establish(ba->ba_icookie, ba->ba_ivec, 252 niintr, sc, &sc->sc_intrcnt); 253 evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL, 254 sc->sc_dev.dv_xname, "intr"); 255 256 ni_getpgs(sc, sizeof(struct ni_gvppqb), (caddr_t *)&sc->sc_gvppqb, 257 (paddr_t *)&sc->sc_pgvppqb); 258 ni_getpgs(sc, sizeof(struct ni_fqb), (caddr_t *)&sc->sc_fqb, 0); 259 ni_getpgs(sc, NBDESCS * sizeof(struct ni_bbd), 260 (caddr_t *)&sc->sc_bbd, 0); 261 /* 262 * Zero the newly allocated memory. 263 */ 264 265 nipqb->np_veclvl = (ba->ba_ivec << 2) + 2; 266 nipqb->np_node = ba->ba_intcpu; 267 nipqb->np_vpqb = (u_int32_t)gvp; 268 #ifdef __vax__ 269 nipqb->np_spt = nipqb->np_gpt = mfpr(PR_SBR); 270 nipqb->np_sptlen = nipqb->np_gptlen = mfpr(PR_SLR); 271 #else 272 #error Must fix support for non-vax. 273 #endif 274 nipqb->np_bvplvl = 1; 275 nipqb->np_vfqb = (u_int32_t)fqb; 276 nipqb->np_vbdt = (u_int32_t)bbd; 277 nipqb->np_nbdr = NBDESCS; 278 279 /* Free queue block */ 280 nipqb->np_freeq = NQUEUES; 281 fqb->nf_mlen = PKTHDR+MSGADD; 282 fqb->nf_dlen = PKTHDR+TXADD; 283 fqb->nf_rlen = PKTHDR+RXADD; 284 285 strcpy(ifp->if_xname, sc->sc_dev.dv_xname); 286 ifp->if_softc = sc; 287 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 288 ifp->if_start = nistart; 289 ifp->if_ioctl = niioctl; 290 ifp->if_watchdog = nitimeout; 291 292 /* 293 * Start init sequence. 294 */ 295 296 /* Reset the node */ 297 NI_WREG(BIREG_VAXBICSR, NI_RREG(BIREG_VAXBICSR) | BICSR_NRST); 298 DELAY(500000); 299 i = 20; 300 while ((NI_RREG(BIREG_VAXBICSR) & BICSR_BROKE) && --i) 301 DELAY(500000); 302 if (i == 0) { 303 printf("%s: BROKE bit set after reset\n", sc->sc_dev.dv_xname); 304 return; 305 } 306 307 /* Check state */ 308 if (failtest(sc, NI_PSR, PSR_STATE, PSR_UNDEF, "not undefined state")) 309 return; 310 311 /* Clear owner bits */ 312 NI_WREG(NI_PSR, NI_RREG(NI_PSR) & ~PSR_OWN); 313 NI_WREG(NI_PCR, NI_RREG(NI_PCR) & ~PCR_OWN); 314 315 /* kick off init */ 316 NI_WREG(NI_PCR, (u_int32_t)sc->sc_pgvppqb | PCR_INIT | PCR_OWN); 317 while (NI_RREG(NI_PCR) & PCR_OWN) 318 DELAY(100000); 319 320 /* Check state */ 321 if (failtest(sc, NI_PSR, PSR_INITED, PSR_INITED, "failed initialize")) 322 return; 323 324 NI_WREG(NI_PSR, NI_RREG(NI_PSR) & ~PSR_OWN); 325 326 WAITREG(NI_PCR, PCR_OWN); 327 NI_WREG(NI_PCR, PCR_OWN|PCR_ENABLE); 328 WAITREG(NI_PCR, PCR_OWN); 329 WAITREG(NI_PSR, PSR_OWN); 330 331 /* Check state */ 332 if (failtest(sc, NI_PSR, PSR_STATE, PSR_ENABLED, "failed enable")) 333 return; 334 335 NI_WREG(NI_PSR, NI_RREG(NI_PSR) & ~PSR_OWN); 336 337 /* 338 * The message queue packets must be located on the beginning 339 * of a page. A VAX page is 512 bytes, but it clusters 8 pages. 340 * This knowledge is used here when allocating pages. 341 * !!! How should this be done on MIPS and Alpha??? !!! 342 */ 343 #if NBPG < 4096 344 #error pagesize too small 345 #endif 346 s = splimp(); 347 /* Set up message free queue */ 348 ni_getpgs(sc, NMSGBUF * 512, &va, 0); 349 for (i = 0; i < NMSGBUF; i++) { 350 struct ni_msg *msg; 351 352 msg = (void *)(va + i * 512); 353 354 res = INSQTI(msg, &fqb->nf_mforw); 355 } 356 WAITREG(NI_PCR, PCR_OWN); 357 NI_WREG(NI_PCR, PCR_FREEQNE|PCR_MFREEQ|PCR_OWN); 358 WAITREG(NI_PCR, PCR_OWN); 359 360 /* Set up xmit queue */ 361 ni_getpgs(sc, NTXBUF * 512, &va, 0); 362 for (i = 0; i < NTXBUF; i++) { 363 struct ni_dg *data; 364 365 data = (void *)(va + i * 512); 366 data->nd_status = 0; 367 data->nd_len = TXADD; 368 data->nd_ptdbidx = 1; 369 data->nd_opcode = BVP_DGRAM; 370 for (j = 0; j < NTXFRAGS; j++) { 371 data->bufs[j]._offset = 0; 372 data->bufs[j]._key = 1; 373 bbd[i * NTXFRAGS + j].nb_key = 1; 374 bbd[i * NTXFRAGS + j].nb_status = 0; 375 data->bufs[j]._index = i * NTXFRAGS + j; 376 } 377 res = INSQTI(data, &fqb->nf_dforw); 378 } 379 WAITREG(NI_PCR, PCR_OWN); 380 NI_WREG(NI_PCR, PCR_FREEQNE|PCR_DFREEQ|PCR_OWN); 381 WAITREG(NI_PCR, PCR_OWN); 382 383 /* recv buffers */ 384 ni_getpgs(sc, NRXBUF * 512, &va, 0); 385 for (i = 0; i < NRXBUF; i++) { 386 struct ni_dg *data; 387 int idx; 388 389 data = (void *)(va + i * 512); 390 data->nd_len = RXADD; 391 data->nd_opcode = BVP_DGRAMRX; 392 data->nd_ptdbidx = 2; 393 data->bufs[0]._key = 1; 394 395 idx = NTXBUF * NTXFRAGS + i; 396 if (ni_add_rxbuf(sc, data, idx)) 397 panic("niattach: ni_add_rxbuf: out of mbufs"); 398 399 res = INSQTI(data, &fqb->nf_rforw); 400 } 401 WAITREG(NI_PCR, PCR_OWN); 402 NI_WREG(NI_PCR, PCR_FREEQNE|PCR_RFREEQ|PCR_OWN); 403 WAITREG(NI_PCR, PCR_OWN); 404 405 splx(s); 406 407 /* Set initial parameters */ 408 msg = REMQHI(&fqb->nf_mforw); 409 410 msg->nm_opcode = BVP_MSG; 411 msg->nm_status = 0; 412 msg->nm_len = sizeof(struct ni_param) + 6; 413 msg->nm_opcode2 = NI_WPARAM; 414 ((struct ni_param *)&msg->nm_text[0])->np_flags = NP_PAD; 415 416 endwait = retry = 0; 417 res = INSQTI(msg, &gvp->nc_forw0); 418 419 retry: WAITREG(NI_PCR, PCR_OWN); 420 NI_WREG(NI_PCR, PCR_CMDQNE|PCR_CMDQ0|PCR_OWN); 421 WAITREG(NI_PCR, PCR_OWN); 422 i = 1000; 423 while (endwait == 0 && --i) 424 DELAY(10000); 425 426 if (endwait == 0) { 427 if (++retry < 3) 428 goto retry; 429 printf("%s: no response to set params\n", sc->sc_dev.dv_xname); 430 return; 431 } 432 433 /* Clear counters */ 434 msg = REMQHI(&fqb->nf_mforw); 435 msg->nm_opcode = BVP_MSG; 436 msg->nm_status = 0; 437 msg->nm_len = sizeof(struct ni_param) + 6; 438 msg->nm_opcode2 = NI_RCCNTR; 439 440 res = INSQTI(msg, &gvp->nc_forw0); 441 442 WAITREG(NI_PCR, PCR_OWN); 443 NI_WREG(NI_PCR, PCR_CMDQNE|PCR_CMDQ0|PCR_OWN); 444 WAITREG(NI_PCR, PCR_OWN); 445 446 /* Enable transmit logic */ 447 msg = REMQHI(&fqb->nf_mforw); 448 449 msg->nm_opcode = BVP_MSG; 450 msg->nm_status = 0; 451 msg->nm_len = 18; 452 msg->nm_opcode2 = NI_STPTDB; 453 ptdb = (struct ni_ptdb *)&msg->nm_text[0]; 454 bzero(ptdb, sizeof(struct ni_ptdb)); 455 ptdb->np_index = 1; 456 ptdb->np_fque = 1; 457 458 res = INSQTI(msg, &gvp->nc_forw0); 459 460 WAITREG(NI_PCR, PCR_OWN); 461 NI_WREG(NI_PCR, PCR_CMDQNE|PCR_CMDQ0|PCR_OWN); 462 WAITREG(NI_PCR, PCR_OWN); 463 464 /* Wait for everything to finish */ 465 WAITREG(NI_PSR, PSR_OWN); 466 467 printf("%s: hardware address %s\n", sc->sc_dev.dv_xname, 468 ether_sprintf(sc->sc_enaddr)); 469 470 /* 471 * Attach the interface. 472 */ 473 if_attach(ifp); 474 ether_ifattach(ifp, sc->sc_enaddr); 475 if (shutdownhook_establish(ni_shutdown, sc) == 0) 476 printf("%s: WARNING: unable to establish shutdown hook\n", 477 sc->sc_dev.dv_xname); 478 } 479 480 /* 481 * Initialization of interface. 482 */ 483 void 484 niinit(sc) 485 struct ni_softc *sc; 486 { 487 struct ifnet *ifp = (struct ifnet *)&sc->sc_if; 488 489 /* 490 * Set flags (so ni_setup() do the right thing). 491 */ 492 ifp->if_flags |= IFF_RUNNING; 493 ifp->if_flags &= ~IFF_OACTIVE; 494 495 /* 496 * Send setup messages so that the rx/tx locic starts. 497 */ 498 ni_setup(sc); 499 500 } 501 502 /* 503 * Start output on interface. 504 */ 505 void 506 nistart(ifp) 507 struct ifnet *ifp; 508 { 509 struct ni_softc *sc = ifp->if_softc; 510 struct ni_dg *data; 511 struct ni_bbd *bdp; 512 struct mbuf *m, *m0; 513 int i, cnt, res, mlen; 514 515 if (ifp->if_flags & IFF_OACTIVE) 516 return; 517 #ifdef DEBUG 518 if (ifp->if_flags & IFF_DEBUG) 519 printf("%s: nistart\n", sc->sc_dev.dv_xname); 520 #endif 521 522 while (fqb->nf_dforw) { 523 IF_DEQUEUE(&sc->sc_if.if_snd, m); 524 if (m == 0) 525 break; 526 527 data = REMQHI(&fqb->nf_dforw); 528 if ((int)data == Q_EMPTY) { 529 IF_PREPEND(&sc->sc_if.if_snd, m); 530 ifp->if_flags |= IFF_OACTIVE; 531 break; 532 } 533 534 /* 535 * Count number of mbufs in chain. 536 * Always do DMA directly from mbufs, therefore the transmit 537 * ring is really big. 538 */ 539 for (m0 = m, cnt = 0; m0; m0 = m0->m_next) 540 if (m0->m_len) 541 cnt++; 542 if (cnt > NTXFRAGS) 543 panic("nistart"); /* XXX */ 544 545 #if NBPFILTER > 0 546 if (ifp->if_bpf) 547 bpf_mtap(ifp->if_bpf, m); 548 #endif 549 bdp = &bbd[(data->bufs[0]._index & 0x7fff)]; 550 for (m0 = m, i = 0, mlen = 0; m0; m0 = m0->m_next) { 551 if (m0->m_len == 0) 552 continue; 553 bdp->nb_status = (mtod(m0, u_int32_t) & NIBD_OFFSET) | 554 NIBD_VALID; 555 bdp->nb_pte = (u_int32_t)kvtopte(mtod(m0, void *)); 556 bdp->nb_len = m0->m_len; 557 data->bufs[i]._offset = 0; 558 data->bufs[i]._len = bdp->nb_len; 559 data->bufs[i]._index |= NIDG_CHAIN; 560 mlen += bdp->nb_len; 561 bdp++; 562 i++; 563 } 564 data->nd_opcode = BVP_DGRAM; 565 data->nd_pad3 = 1; 566 data->nd_ptdbidx = 1; 567 data->nd_len = 10 + i * 8; 568 data->bufs[i - 1]._index &= ~NIDG_CHAIN; 569 if (mlen < 64) 570 data->bufs[i - 1]._len = bdp[-1].nb_len += (64 - mlen); 571 data->nd_cmdref = (u_int32_t)m; 572 #ifdef DEBUG 573 if (ifp->if_flags & IFF_DEBUG) 574 printf("%s: sending %d bytes (%d segments)\n", 575 sc->sc_dev.dv_xname, mlen, i); 576 #endif 577 578 res = INSQTI(data, &gvp->nc_forw0); 579 if (res == Q_EMPTY) { 580 WAITREG(NI_PCR, PCR_OWN); 581 NI_WREG(NI_PCR, PCR_CMDQNE|PCR_CMDQ0|PCR_OWN); 582 } 583 } 584 } 585 586 void 587 niintr(void *arg) 588 { 589 struct ni_softc *sc = arg; 590 struct ni_dg *data; 591 struct ni_msg *msg; 592 struct ifnet *ifp = &sc->sc_if; 593 struct ni_bbd *bd; 594 struct mbuf *m; 595 int idx, res; 596 597 if ((NI_RREG(NI_PSR) & PSR_STATE) != PSR_ENABLED) 598 return; 599 600 if ((NI_RREG(NI_PSR) & PSR_ERR)) 601 printf("%s: PSR %x\n", sc->sc_dev.dv_xname, NI_RREG(NI_PSR)); 602 603 /* Got any response packets? */ 604 while ((NI_RREG(NI_PSR) & PSR_RSQ) && (data = REMQHI(&gvp->nc_forwr))) { 605 606 switch (data->nd_opcode) { 607 case BVP_DGRAMRX: /* Receive datagram */ 608 idx = data->bufs[0]._index; 609 bd = &bbd[idx]; 610 m = (void *)data->nd_cmdref; 611 m->m_pkthdr.len = m->m_len = data->bufs[0]._len; 612 m->m_pkthdr.rcvif = ifp; 613 if (ni_add_rxbuf(sc, data, idx)) { 614 bd->nb_len = (m->m_ext.ext_size - 2); 615 bd->nb_pte = 616 (long)kvtopte(m->m_ext.ext_buf); 617 bd->nb_status = 2 | NIBD_VALID; 618 bd->nb_key = 1; 619 } 620 data->nd_len = RXADD; 621 data->nd_status = 0; 622 res = INSQTI(data, &fqb->nf_rforw); 623 if (res == Q_EMPTY) { 624 WAITREG(NI_PCR, PCR_OWN); 625 NI_WREG(NI_PCR, PCR_FREEQNE|PCR_RFREEQ|PCR_OWN); 626 } 627 if (m == (void *)data->nd_cmdref) 628 break; /* Out of mbufs */ 629 630 #if NBPFILTER > 0 631 if (ifp->if_bpf) 632 bpf_mtap(ifp->if_bpf, m); 633 #endif 634 (*ifp->if_input)(ifp, m); 635 break; 636 637 case BVP_DGRAM: 638 m = (struct mbuf *)data->nd_cmdref; 639 ifp->if_flags &= ~IFF_OACTIVE; 640 m_freem(m); 641 res = INSQTI(data, &fqb->nf_dforw); 642 if (res == Q_EMPTY) { 643 WAITREG(NI_PCR, PCR_OWN); 644 NI_WREG(NI_PCR, PCR_FREEQNE|PCR_DFREEQ|PCR_OWN); 645 } 646 break; 647 648 case BVP_MSGRX: 649 msg = (struct ni_msg *)data; 650 switch (msg->nm_opcode2) { 651 case NI_WPARAM: 652 bcopy(((struct ni_param *)&msg->nm_text[0])->np_dpa, sc->sc_enaddr, ETHER_ADDR_LEN); 653 endwait = 1; 654 break; 655 656 case NI_RCCNTR: 657 case NI_CLPTDB: 658 case NI_STPTDB: 659 break; 660 661 default: 662 printf("Unkn resp %d\n", 663 msg->nm_opcode2); 664 break; 665 } 666 res = INSQTI(data, &fqb->nf_mforw); 667 if (res == Q_EMPTY) { 668 WAITREG(NI_PCR, PCR_OWN); 669 NI_WREG(NI_PCR, PCR_FREEQNE|PCR_MFREEQ|PCR_OWN); 670 } 671 break; 672 673 default: 674 printf("Unknown opcode %d\n", data->nd_opcode); 675 res = INSQTI(data, &fqb->nf_mforw); 676 if (res == Q_EMPTY) { 677 WAITREG(NI_PCR, PCR_OWN); 678 NI_WREG(NI_PCR, PCR_FREEQNE|PCR_MFREEQ|PCR_OWN); 679 } 680 } 681 } 682 683 /* Try to kick on the start routine again */ 684 nistart(ifp); 685 686 NI_WREG(NI_PSR, NI_RREG(NI_PSR) & ~(PSR_OWN|PSR_RSQ)); 687 } 688 689 /* 690 * Process an ioctl request. 691 */ 692 int 693 niioctl(ifp, cmd, data) 694 register struct ifnet *ifp; 695 u_long cmd; 696 caddr_t data; 697 { 698 struct ni_softc *sc = ifp->if_softc; 699 struct ifreq *ifr = (struct ifreq *)data; 700 struct ifaddr *ifa = (struct ifaddr *)data; 701 int s = splnet(), error = 0; 702 703 switch (cmd) { 704 705 case SIOCSIFADDR: 706 ifp->if_flags |= IFF_UP; 707 switch(ifa->ifa_addr->sa_family) { 708 #ifdef INET 709 case AF_INET: 710 niinit(sc); 711 arp_ifinit(ifp, ifa); 712 break; 713 #endif 714 } 715 break; 716 717 case SIOCSIFFLAGS: 718 if ((ifp->if_flags & IFF_UP) == 0 && 719 (ifp->if_flags & IFF_RUNNING) != 0) { 720 /* 721 * If interface is marked down and it is running, 722 * stop it. 723 */ 724 ifp->if_flags &= ~IFF_RUNNING; 725 ni_setup(sc); 726 } else if ((ifp->if_flags & IFF_UP) != 0 && 727 (ifp->if_flags & IFF_RUNNING) == 0) { 728 /* 729 * If interface it marked up and it is stopped, then 730 * start it. 731 */ 732 niinit(sc); 733 } else if ((ifp->if_flags & IFF_UP) != 0) { 734 /* 735 * Send a new setup packet to match any new changes. 736 * (Like IFF_PROMISC etc) 737 */ 738 ni_setup(sc); 739 } 740 break; 741 742 case SIOCADDMULTI: 743 case SIOCDELMULTI: 744 /* 745 * Update our multicast list. 746 */ 747 error = (cmd == SIOCADDMULTI) ? 748 ether_addmulti(ifr, &sc->sc_ec): 749 ether_delmulti(ifr, &sc->sc_ec); 750 751 if (error == ENETRESET) { 752 /* 753 * Multicast list has changed; set the hardware filter 754 * accordingly. 755 */ 756 ni_setup(sc); 757 error = 0; 758 } 759 break; 760 761 default: 762 error = EINVAL; 763 764 } 765 splx(s); 766 return (error); 767 } 768 769 /* 770 * Add a receive buffer to the indicated descriptor. 771 */ 772 int 773 ni_add_rxbuf(struct ni_softc *sc, struct ni_dg *data, int idx) 774 { 775 struct ni_bbd *bd = &bbd[idx]; 776 struct mbuf *m; 777 778 MGETHDR(m, M_DONTWAIT, MT_DATA); 779 if (m == NULL) 780 return (ENOBUFS); 781 782 MCLGET(m, M_DONTWAIT); 783 if ((m->m_flags & M_EXT) == 0) { 784 m_freem(m); 785 return (ENOBUFS); 786 } 787 788 m->m_data += 2; 789 bd->nb_len = (m->m_ext.ext_size - 2); 790 bd->nb_pte = (long)kvtopte(m->m_ext.ext_buf); 791 bd->nb_status = 2 | NIBD_VALID; 792 bd->nb_key = 1; 793 794 data->bufs[0]._offset = 0; 795 data->bufs[0]._len = bd->nb_len; 796 data->bufs[0]._index = idx; 797 data->nd_cmdref = (long)m; 798 799 return (0); 800 } 801 802 /* 803 * Create setup packet and put in queue for sending. 804 */ 805 void 806 ni_setup(struct ni_softc *sc) 807 { 808 struct ifnet *ifp = &sc->sc_if; 809 struct ni_msg *msg; 810 struct ni_ptdb *ptdb; 811 struct ether_multi *enm; 812 struct ether_multistep step; 813 int i, res; 814 815 msg = REMQHI(&fqb->nf_mforw); 816 if ((int)msg == Q_EMPTY) 817 return; /* What to do? */ 818 819 ptdb = (struct ni_ptdb *)&msg->nm_text[0]; 820 bzero(ptdb, sizeof(struct ni_ptdb)); 821 822 msg->nm_opcode = BVP_MSG; 823 msg->nm_len = 18; 824 ptdb->np_index = 2; /* definition type index */ 825 ptdb->np_fque = 2; /* Free queue */ 826 if (ifp->if_flags & IFF_RUNNING) { 827 msg->nm_opcode2 = NI_STPTDB; 828 ptdb->np_type = ETHERTYPE_IP; 829 ptdb->np_flags = PTDB_UNKN|PTDB_BDC; 830 if (ifp->if_flags & IFF_PROMISC) 831 ptdb->np_flags |= PTDB_PROMISC; 832 memset(ptdb->np_mcast[0], 0xff, ETHER_ADDR_LEN); /* Broadcast */ 833 ptdb->np_adrlen = 1; 834 msg->nm_len += 8; 835 ifp->if_flags &= ~IFF_ALLMULTI; 836 if ((ifp->if_flags & IFF_PROMISC) == 0) { 837 ETHER_FIRST_MULTI(step, &sc->sc_ec, enm); 838 i = 1; 839 while (enm != NULL) { 840 if (bcmp(enm->enm_addrlo, enm->enm_addrhi, 6)) { 841 ifp->if_flags |= IFF_ALLMULTI; 842 ptdb->np_flags |= PTDB_AMC; 843 break; 844 } 845 msg->nm_len += 8; 846 ptdb->np_adrlen++; 847 bcopy(enm->enm_addrlo, ptdb->np_mcast[i++], 848 ETHER_ADDR_LEN); 849 ETHER_NEXT_MULTI(step, enm); 850 } 851 } 852 } else 853 msg->nm_opcode2 = NI_CLPTDB; 854 855 res = INSQTI(msg, &gvp->nc_forw0); 856 if (res == Q_EMPTY) { 857 WAITREG(NI_PCR, PCR_OWN); 858 NI_WREG(NI_PCR, PCR_CMDQNE|PCR_CMDQ0|PCR_OWN); 859 } 860 } 861 862 /* 863 * Check for dead transmit logic. Not uncommon. 864 */ 865 void 866 nitimeout(ifp) 867 struct ifnet *ifp; 868 { 869 #if 0 870 struct ni_softc *sc = ifp->if_softc; 871 872 if (sc->sc_inq == 0) 873 return; 874 875 printf("%s: xmit logic died, resetting...\n", sc->sc_dev.dv_xname); 876 /* 877 * Do a reset of interface, to get it going again. 878 * Will it work by just restart the transmit logic? 879 */ 880 niinit(sc); 881 #endif 882 } 883 884 /* 885 * Shutdown hook. Make sure the interface is stopped at reboot. 886 */ 887 void 888 ni_shutdown(arg) 889 void *arg; 890 { 891 struct ni_softc *sc = arg; 892 893 WAITREG(NI_PCR, PCR_OWN); 894 NI_WREG(NI_PCR, PCR_OWN|PCR_SHUTDOWN); 895 WAITREG(NI_PCR, PCR_OWN); 896 WAITREG(NI_PSR, PSR_OWN); 897 898 } 899 900
Indexes created Wed Oct 15 16:09:53 GMT 2025