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/i386/isa/if_lnc.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 1994-1998 3 * Paul Richards. 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 * verbatim and that no modifications are made prior to this 11 * point in the file. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Paul Richards. 18 * 4. The name Paul Richards may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY PAUL RICHARDS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL PAUL RICHARDS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * $FreeBSD$ 34 */ 35 36 /* 37 #define DIAGNOSTIC 38 #define DEBUG 39 * 40 * TODO ---- 41 * 42 * This driver will need bounce buffer support when dma'ing to mbufs above the 43 * 16Mb mark. 44 * 45 * Check all the XXX comments -- some of them are just things I've left 46 * unfinished rather than "difficult" problems that were hacked around. 47 * 48 * Check log settings. 49 * 50 * Check how all the arpcom flags get set and used. 51 * 52 * Re-inline and re-static all routines after debugging. 53 * 54 * Remember to assign iobase in SHMEM probe routines. 55 * 56 * Replace all occurences of LANCE-controller-card etc in prints by the name 57 * strings of the appropriate type -- nifty window dressing 58 * 59 * Add DEPCA support -- mostly done. 60 * 61 */ 62 63 #include "pci.h" 64 #include "lnc.h" 65 66 #include "opt_inet.h" 67 68 /* Some defines that should really be in generic locations */ 69 #define FCS_LEN 4 70 #define MULTICAST_FILTER_LEN 8 71 72 #include <sys/param.h> 73 #include <sys/systm.h> 74 #include <sys/conf.h> 75 #include <sys/sockio.h> 76 #include <sys/malloc.h> 77 #include <sys/mbuf.h> 78 #include <sys/socket.h> 79 #include <sys/syslog.h> 80 81 #include <net/ethernet.h> 82 #include <net/if.h> 83 #include <net/if_dl.h> 84 #include <net/if_types.h> 85 86 #include <netinet/in.h> 87 #include <netinet/if_ether.h> 88 89 #include <net/bpf.h> 90 91 #ifdef PC98 92 #include <machine/clock.h> 93 #endif 94 #include <machine/md_var.h> 95 96 #include <i386/isa/isa_device.h> 97 #include <i386/isa/if_lnc.h> 98 99 struct lnc_softc { 100 struct arpcom arpcom; /* see ../../net/if_arp.h */ 101 struct nic_info nic; /* NIC specific info */ 102 int nrdre; 103 struct host_ring_entry *recv_ring; /* start of alloc'd mem */ 104 int recv_next; 105 int ntdre; 106 struct host_ring_entry *trans_ring; 107 int trans_next; 108 struct init_block *init_block; /* Initialisation block */ 109 int pending_transmits; /* No. of transmit descriptors in use */ 110 int next_to_send; 111 struct mbuf *mbufs; 112 int mbuf_count; 113 int flags; 114 int rap; 115 int rdp; 116 int bdp; 117 int reset; 118 #ifdef DEBUG 119 int lnc_debug; 120 #endif 121 LNCSTATS_STRUCT 122 }; 123 124 static struct lnc_softc lnc_softc[NLNC]; 125 126 static char const * const nic_ident[] = { 127 "Unknown", 128 "BICC", 129 "NE2100", 130 "DEPCA", 131 "CNET98S", /* PC-98 */ 132 }; 133 134 static char const * const ic_ident[] = { 135 "Unknown", 136 "LANCE", 137 "C-LANCE", 138 "PCnet-ISA", 139 "PCnet-ISA+", 140 "PCnet-ISA II", 141 "PCnet-32 VL-Bus", 142 "PCnet-PCI", 143 "PCnet-PCI II", 144 "PCnet-FAST", 145 "PCnet-FAST+", 146 "PCnet-Home", 147 }; 148 149 static void lnc_setladrf __P((struct lnc_softc *sc)); 150 static void lnc_stop __P((struct lnc_softc *sc)); 151 static void lnc_reset __P((struct lnc_softc *sc)); 152 static void lnc_free_mbufs __P((struct lnc_softc *sc)); 153 static __inline int alloc_mbuf_cluster __P((struct lnc_softc *sc, 154 struct host_ring_entry *desc)); 155 static __inline struct mbuf *chain_mbufs __P((struct lnc_softc *sc, 156 int start_of_packet, 157 int pkt_len)); 158 static __inline struct mbuf *mbuf_packet __P((struct lnc_softc *sc, 159 int start_of_packet, 160 int pkt_len)); 161 static __inline void lnc_rint __P((struct lnc_softc *sc)); 162 static __inline void lnc_tint __P((struct lnc_softc *sc)); 163 static int lnc_probe __P((struct isa_device *isa_dev)); 164 #ifdef PC98 165 static int cnet98s_probe __P((struct lnc_softc *sc, unsigned iobase)); 166 #endif 167 static int ne2100_probe __P((struct lnc_softc *sc, unsigned iobase)); 168 static int bicc_probe __P((struct lnc_softc *sc, unsigned iobase)); 169 static int dec_macaddr_extract __P((u_char ring[], struct lnc_softc *sc)); 170 static int depca_probe __P((struct lnc_softc *sc, unsigned iobase)); 171 static int lance_probe __P((struct lnc_softc *sc)); 172 static int pcnet_probe __P((struct lnc_softc *sc)); 173 static int lnc_attach_sc __P((struct lnc_softc *sc, int unit)); 174 static int lnc_attach __P((struct isa_device *isa_dev)); 175 static void lnc_init __P((void *)); 176 static ointhand2_t lncintr; 177 static __inline int mbuf_to_buffer __P((struct mbuf *m, char *buffer)); 178 static __inline struct mbuf *chain_to_cluster __P((struct mbuf *m)); 179 static void lnc_start __P((struct ifnet *ifp)); 180 static int lnc_ioctl __P((struct ifnet *ifp, u_long command, caddr_t data)); 181 static void lnc_watchdog __P((struct ifnet *ifp)); 182 #ifdef DEBUG 183 void lnc_dump_state __P((struct lnc_softc *sc)); 184 void mbuf_dump_chain __P((struct mbuf *m)); 185 #endif 186 187 #if NPCI > 0 188 void *lnc_attach_ne2100_pci __P((int unit, unsigned iobase)); 189 #endif 190 void lncintr_sc __P((struct lnc_softc *sc)); 191 192 struct isa_driver lncdriver = {lnc_probe, lnc_attach, "lnc"}; 193 194 static __inline void 195 write_csr(struct lnc_softc *sc, u_short port, u_short val) 196 { 197 outw(sc->rap, port); 198 outw(sc->rdp, val); 199 } 200 201 static __inline u_short 202 read_csr(struct lnc_softc *sc, u_short port) 203 { 204 outw(sc->rap, port); 205 return (inw(sc->rdp)); 206 } 207 208 static __inline void 209 write_bcr(struct lnc_softc *sc, u_short port, u_short val) 210 { 211 outw(sc->rap, port); 212 outw(sc->bdp, val); 213 } 214 215 static __inline u_short 216 read_bcr(struct lnc_softc *sc, u_short port) 217 { 218 outw(sc->rap, port); 219 return (inw(sc->bdp)); 220 } 221 222 static __inline u_long 223 ether_crc(const u_char *ether_addr) 224 { 225 #define POLYNOMIAL 0xEDB88320UL 226 u_char i, j, addr; 227 u_int crc = 0xFFFFFFFFUL; 228 229 for (i = 0; i < ETHER_ADDR_LEN; i++) { 230 addr = *ether_addr++; 231 for (j = 0; j < MULTICAST_FILTER_LEN; j++) { 232 crc = (crc >> 1) ^ (((crc ^ addr) & 1) ? POLYNOMIAL : 0); 233 addr >>= 1; 234 } 235 } 236 return crc; 237 #undef POLYNOMIAL 238 } 239 240 /* 241 * Set up the logical address filter for multicast packets 242 */ 243 static __inline void 244 lnc_setladrf(struct lnc_softc *sc) 245 { 246 struct ifnet *ifp = &sc->arpcom.ac_if; 247 struct ifmultiaddr *ifma; 248 u_long index; 249 int i; 250 251 if (sc->flags & IFF_ALLMULTI) { 252 for (i=0; i < MULTICAST_FILTER_LEN; i++) 253 sc->init_block->ladrf[i] = 0xFF; 254 return; 255 } 256 257 /* 258 * For each multicast address, calculate a crc for that address and 259 * then use the high order 6 bits of the crc as a hash code where 260 * bits 3-5 select the byte of the address filter and bits 0-2 select 261 * the bit within that byte. 262 */ 263 264 bzero(sc->init_block->ladrf, MULTICAST_FILTER_LEN); 265 for (ifma = ifp->if_multiaddrs.lh_first; ifma; 266 ifma = ifma->ifma_link.le_next) { 267 if (ifma->ifma_addr->sa_family != AF_LINK) 268 continue; 269 270 index = ether_crc(LLADDR((struct sockaddr_dl *)ifma->ifma_addr)) 271 >> 26; 272 sc->init_block->ladrf[index >> 3] |= 1 << (index & 7); 273 } 274 } 275 276 static void 277 lnc_stop(struct lnc_softc *sc) 278 { 279 write_csr(sc, CSR0, STOP); 280 } 281 282 static void 283 lnc_reset(struct lnc_softc *sc) 284 { 285 lnc_init(sc); 286 } 287 288 static void 289 lnc_free_mbufs(struct lnc_softc *sc) 290 { 291 int i; 292 293 /* 294 * We rely on other routines to keep the buff.mbuf field valid. If 295 * it's not NULL then we assume it points to an allocated mbuf. 296 */ 297 298 for (i = 0; i < NDESC(sc->nrdre); i++) 299 if ((sc->recv_ring + i)->buff.mbuf) 300 m_free((sc->recv_ring + i)->buff.mbuf); 301 302 for (i = 0; i < NDESC(sc->ntdre); i++) 303 if ((sc->trans_ring + i)->buff.mbuf) 304 m_free((sc->trans_ring + i)->buff.mbuf); 305 306 if (sc->mbuf_count) 307 m_freem(sc->mbufs); 308 } 309 310 static __inline int 311 alloc_mbuf_cluster(struct lnc_softc *sc, struct host_ring_entry *desc) 312 { 313 register struct mds *md = desc->md; 314 struct mbuf *m=0; 315 int addr; 316 317 /* Try and get cluster off local cache */ 318 if (sc->mbuf_count) { 319 sc->mbuf_count--; 320 m = sc->mbufs; 321 sc->mbufs = m->m_next; 322 /* XXX m->m_data = m->m_ext.ext_buf;*/ 323 } else { 324 MGET(m, M_DONTWAIT, MT_DATA); 325 if (!m) 326 return(1); 327 MCLGET(m, M_DONTWAIT); 328 if (!m->m_ext.ext_buf) { 329 m_free(m); 330 return(1); 331 } 332 } 333 334 desc->buff.mbuf = m; 335 addr = kvtop(m->m_data); 336 md->md0 = addr; 337 md->md1= ((addr >> 16) & 0xff) | OWN; 338 md->md2 = -(short)(MCLBYTES - sizeof(struct pkthdr)); 339 md->md3 = 0; 340 return(0); 341 } 342 343 static __inline struct mbuf * 344 chain_mbufs(struct lnc_softc *sc, int start_of_packet, int pkt_len) 345 { 346 struct mbuf *head, *m; 347 struct host_ring_entry *desc; 348 349 /* 350 * Turn head into a pkthdr mbuf -- 351 * assumes a pkthdr type mbuf was 352 * allocated to the descriptor 353 * originally. 354 */ 355 356 desc = sc->recv_ring + start_of_packet; 357 358 head = desc->buff.mbuf; 359 head->m_flags |= M_PKTHDR; 360 361 m = head; 362 do { 363 m = desc->buff.mbuf; 364 m->m_len = min((MCLBYTES - sizeof(struct pkthdr)), pkt_len); 365 pkt_len -= m->m_len; 366 if (alloc_mbuf_cluster(sc, desc)) 367 return((struct mbuf *)NULL); 368 INC_MD_PTR(start_of_packet, sc->nrdre) 369 desc = sc->recv_ring + start_of_packet; 370 m->m_next = desc->buff.mbuf; 371 } while (start_of_packet != sc->recv_next); 372 373 m->m_next = 0; 374 return(head); 375 } 376 377 static __inline struct mbuf * 378 mbuf_packet(struct lnc_softc *sc, int start_of_packet, int pkt_len) 379 { 380 381 struct host_ring_entry *start; 382 struct mbuf *head,*m,*m_prev; 383 char *data,*mbuf_data; 384 short blen; 385 int amount; 386 387 /* Get a pkthdr mbuf for the start of packet */ 388 MGETHDR(head, M_DONTWAIT, MT_DATA); 389 if (!head) { 390 LNCSTATS(drop_packet) 391 return(0); 392 } 393 394 m = head; 395 m->m_len = 0; 396 start = sc->recv_ring + start_of_packet; 397 /*blen = -(start->md->md2);*/ 398 blen = RECVBUFSIZE; /* XXX More PCnet-32 crap */ 399 data = start->buff.data; 400 mbuf_data = m->m_data; 401 402 while (start_of_packet != sc->recv_next) { 403 /* 404 * If the data left fits in a single buffer then set 405 * blen to the size of the data left. 406 */ 407 if (pkt_len < blen) 408 blen = pkt_len; 409 410 /* 411 * amount is least of data in current ring buffer and 412 * amount of space left in current mbuf. 413 */ 414 amount = min(blen, M_TRAILINGSPACE(m)); 415 if (amount == 0) { 416 /* mbuf must be empty */ 417 m_prev = m; 418 MGET(m, M_DONTWAIT, MT_DATA); 419 if (!m) { 420 m_freem(head); 421 return(0); 422 } 423 if (pkt_len >= MINCLSIZE) 424 MCLGET(m, M_DONTWAIT); 425 m->m_len = 0; 426 m_prev->m_next = m; 427 amount = min(blen, M_TRAILINGSPACE(m)); 428 mbuf_data = m->m_data; 429 } 430 bcopy(data, mbuf_data, amount); 431 blen -= amount; 432 pkt_len -= amount; 433 m->m_len += amount; 434 data += amount; 435 mbuf_data += amount; 436 437 if (blen == 0) { 438 start->md->md1 &= HADR; 439 start->md->md1 |= OWN; 440 start->md->md2 = -RECVBUFSIZE; /* XXX - shouldn't be necessary */ 441 INC_MD_PTR(start_of_packet, sc->nrdre) 442 start = sc->recv_ring + start_of_packet; 443 data = start->buff.data; 444 /*blen = -(start->md->md2);*/ 445 blen = RECVBUFSIZE; /* XXX More PCnet-32 crap */ 446 } 447 } 448 return(head); 449 } 450 451 452 static __inline void 453 lnc_rint(struct lnc_softc *sc) 454 { 455 struct host_ring_entry *next, *start; 456 int start_of_packet; 457 struct mbuf *head; 458 struct ether_header *eh; 459 int lookahead; 460 int flags; 461 int pkt_len; 462 463 /* 464 * The LANCE will issue a RINT interrupt when the ownership of the 465 * last buffer of a receive packet has been relinquished by the LANCE. 466 * Therefore, it can be assumed that a complete packet can be found 467 * before hitting buffers that are still owned by the LANCE, if not 468 * then there is a bug in the driver that is causing the descriptors 469 * to get out of sync. 470 */ 471 472 #ifdef DIAGNOSTIC 473 if ((sc->recv_ring + sc->recv_next)->md->md1 & OWN) { 474 int unit = sc->arpcom.ac_if.if_unit; 475 log(LOG_ERR, "lnc%d: Receive interrupt with buffer still owned by controller -- Resetting\n", unit); 476 lnc_reset(sc); 477 return; 478 } 479 if (!((sc->recv_ring + sc->recv_next)->md->md1 & STP)) { 480 int unit = sc->arpcom.ac_if.if_unit; 481 log(LOG_ERR, "lnc%d: Receive interrupt but not start of packet -- Resetting\n", unit); 482 lnc_reset(sc); 483 return; 484 } 485 #endif 486 487 lookahead = 0; 488 next = sc->recv_ring + sc->recv_next; 489 while ((flags = next->md->md1) & STP) { 490 491 /* Make a note of the start of the packet */ 492 start_of_packet = sc->recv_next; 493 494 /* 495 * Find the end of the packet. Even if not data chaining, 496 * jabber packets can overrun into a second descriptor. 497 * If there is no error, then the ENP flag is set in the last 498 * descriptor of the packet. If there is an error then the ERR 499 * flag will be set in the descriptor where the error occured. 500 * Therefore, to find the last buffer of a packet we search for 501 * either ERR or ENP. 502 */ 503 504 if (!(flags & (ENP | MDERR))) { 505 do { 506 INC_MD_PTR(sc->recv_next, sc->nrdre) 507 next = sc->recv_ring + sc->recv_next; 508 flags = next->md->md1; 509 } while (!(flags & (STP | OWN | ENP | MDERR))); 510 511 if (flags & STP) { 512 int unit = sc->arpcom.ac_if.if_unit; 513 log(LOG_ERR, "lnc%d: Start of packet found before end of previous in receive ring -- Resetting\n", unit); 514 lnc_reset(sc); 515 return; 516 } 517 if (flags & OWN) { 518 if (lookahead) { 519 /* 520 * Looked ahead into a packet still 521 * being received 522 */ 523 sc->recv_next = start_of_packet; 524 break; 525 } else { 526 int unit = sc->arpcom.ac_if.if_unit; 527 log(LOG_ERR, "lnc%d: End of received packet not found-- Resetting\n", unit); 528 lnc_reset(sc); 529 return; 530 } 531 } 532 } 533 534 pkt_len = (next->md->md3 & MCNT) - FCS_LEN; 535 536 /* Move pointer onto start of next packet */ 537 INC_MD_PTR(sc->recv_next, sc->nrdre) 538 next = sc->recv_ring + sc->recv_next; 539 540 if (flags & MDERR) { 541 int unit = sc->arpcom.ac_if.if_unit; 542 if (flags & RBUFF) { 543 LNCSTATS(rbuff) 544 log(LOG_ERR, "lnc%d: Receive buffer error\n", unit); 545 } 546 if (flags & OFLO) { 547 /* OFLO only valid if ENP is not set */ 548 if (!(flags & ENP)) { 549 LNCSTATS(oflo) 550 log(LOG_ERR, "lnc%d: Receive overflow error \n", unit); 551 } 552 } else if (flags & ENP) { 553 if ((sc->arpcom.ac_if.if_flags & IFF_PROMISC)==0) { 554 /* 555 * FRAM and CRC are valid only if ENP 556 * is set and OFLO is not. 557 */ 558 if (flags & FRAM) { 559 LNCSTATS(fram) 560 log(LOG_ERR, "lnc%d: Framing error\n", unit); 561 /* 562 * FRAM is only set if there's a CRC 563 * error so avoid multiple messages 564 */ 565 } else if (flags & CRC) { 566 LNCSTATS(crc) 567 log(LOG_ERR, "lnc%d: Receive CRC error\n", unit); 568 } 569 } 570 } 571 572 /* Drop packet */ 573 LNCSTATS(rerr) 574 sc->arpcom.ac_if.if_ierrors++; 575 while (start_of_packet != sc->recv_next) { 576 start = sc->recv_ring + start_of_packet; 577 start->md->md2 = -RECVBUFSIZE; /* XXX - shouldn't be necessary */ 578 start->md->md1 &= HADR; 579 start->md->md1 |= OWN; 580 INC_MD_PTR(start_of_packet, sc->nrdre) 581 } 582 } else { /* Valid packet */ 583 584 sc->arpcom.ac_if.if_ipackets++; 585 586 587 if (sc->nic.mem_mode == DMA_MBUF) 588 head = chain_mbufs(sc, start_of_packet, pkt_len); 589 else 590 head = mbuf_packet(sc, start_of_packet, pkt_len); 591 592 if (head) { 593 /* 594 * First mbuf in packet holds the 595 * ethernet and packet headers 596 */ 597 head->m_pkthdr.rcvif = &sc->arpcom.ac_if; 598 head->m_pkthdr.len = pkt_len ; 599 eh = (struct ether_header *) head->m_data; 600 601 /* 602 * vmware ethernet hardware emulation loops 603 * packets back to itself, violates IFF_SIMPLEX. 604 * drop it if it is from myself. 605 */ 606 if (bcmp(eh->ether_shost, 607 sc->arpcom.ac_enaddr, ETHER_ADDR_LEN) == 0) { 608 m_freem(head); 609 } else { 610 /* Skip over the ether header */ 611 head->m_data += sizeof *eh; 612 head->m_len -= sizeof *eh; 613 head->m_pkthdr.len -= sizeof *eh; 614 615 ether_input(&sc->arpcom.ac_if, eh, head); 616 } 617 618 } else { 619 int unit = sc->arpcom.ac_if.if_unit; 620 log(LOG_ERR,"lnc%d: Packet dropped, no mbufs\n",unit); 621 LNCSTATS(drop_packet) 622 } 623 } 624 625 lookahead++; 626 } 627 628 /* 629 * At this point all completely received packets have been processed 630 * so clear RINT since any packets that have arrived while we were in 631 * here have been dealt with. 632 */ 633 634 outw(sc->rdp, RINT | INEA); 635 } 636 637 static __inline void 638 lnc_tint(struct lnc_softc *sc) 639 { 640 struct host_ring_entry *next, *start; 641 int start_of_packet; 642 int lookahead; 643 644 /* 645 * If the driver is reset in this routine then we return immediately to 646 * the interrupt driver routine. Any interrupts that have occured 647 * since the reset will be dealt with there. sc->trans_next 648 * should point to the start of the first packet that was awaiting 649 * transmission after the last transmit interrupt was dealt with. The 650 * LANCE should have relinquished ownership of that descriptor before 651 * the interrupt. Therefore, sc->trans_next should point to a 652 * descriptor with STP set and OWN cleared. If not then the driver's 653 * pointers are out of sync with the LANCE, which signifies a bug in 654 * the driver. Therefore, the following two checks are really 655 * diagnostic, since if the driver is working correctly they should 656 * never happen. 657 */ 658 659 #ifdef DIAGNOSTIC 660 if ((sc->trans_ring + sc->trans_next)->md->md1 & OWN) { 661 int unit = sc->arpcom.ac_if.if_unit; 662 log(LOG_ERR, "lnc%d: Transmit interrupt with buffer still owned by controller -- Resetting\n", unit); 663 lnc_reset(sc); 664 return; 665 } 666 #endif 667 668 669 /* 670 * The LANCE will write the status information for the packet it just 671 * tried to transmit in one of two places. If the packet was 672 * transmitted successfully then the status will be written into the 673 * last descriptor of the packet. If the transmit failed then the 674 * status will be written into the descriptor that was being accessed 675 * when the error occured and all subsequent descriptors in that 676 * packet will have been relinquished by the LANCE. 677 * 678 * At this point we know that sc->trans_next points to the start 679 * of a packet that the LANCE has just finished trying to transmit. 680 * We now search for a buffer with either ENP or ERR set. 681 */ 682 683 lookahead = 0; 684 685 do { 686 start_of_packet = sc->trans_next; 687 next = sc->trans_ring + sc->trans_next; 688 689 #ifdef DIAGNOSTIC 690 if (!(next->md->md1 & STP)) { 691 int unit = sc->arpcom.ac_if.if_unit; 692 log(LOG_ERR, "lnc%d: Transmit interrupt but not start of packet -- Resetting\n", unit); 693 lnc_reset(sc); 694 return; 695 } 696 #endif 697 698 /* 699 * Find end of packet. 700 */ 701 702 if (!(next->md->md1 & (ENP | MDERR))) { 703 do { 704 INC_MD_PTR(sc->trans_next, sc->ntdre) 705 next = sc->trans_ring + sc->trans_next; 706 } while (!(next->md->md1 & (STP | OWN | ENP | MDERR))); 707 708 if (next->md->md1 & STP) { 709 int unit = sc->arpcom.ac_if.if_unit; 710 log(LOG_ERR, "lnc%d: Start of packet found before end of previous in transmit ring -- Resetting\n", unit); 711 lnc_reset(sc); 712 return; 713 } 714 if (next->md->md1 & OWN) { 715 if (lookahead) { 716 /* 717 * Looked ahead into a packet still 718 * being transmitted 719 */ 720 sc->trans_next = start_of_packet; 721 break; 722 } else { 723 int unit = sc->arpcom.ac_if.if_unit; 724 log(LOG_ERR, "lnc%d: End of transmitted packet not found -- Resetting\n", unit); 725 lnc_reset(sc); 726 return; 727 } 728 } 729 } 730 /* 731 * Check for ERR first since other flags are irrelevant if an 732 * error occurred. 733 */ 734 if (next->md->md1 & MDERR) { 735 736 int unit = sc->arpcom.ac_if.if_unit; 737 738 LNCSTATS(terr) 739 sc->arpcom.ac_if.if_oerrors++; 740 741 if (next->md->md3 & LCOL) { 742 LNCSTATS(lcol) 743 log(LOG_ERR, "lnc%d: Transmit late collision -- Net error?\n", unit); 744 sc->arpcom.ac_if.if_collisions++; 745 /* 746 * Clear TBUFF since it's not valid when LCOL 747 * set 748 */ 749 next->md->md3 &= ~TBUFF; 750 } 751 if (next->md->md3 & LCAR) { 752 LNCSTATS(lcar) 753 log(LOG_ERR, "lnc%d: Loss of carrier during transmit -- Net error?\n", unit); 754 } 755 if (next->md->md3 & RTRY) { 756 LNCSTATS(rtry) 757 log(LOG_ERR, "lnc%d: Transmit of packet failed after 16 attempts -- TDR = %d\n", unit, ((sc->trans_ring + sc->trans_next)->md->md3 & TDR)); 758 sc->arpcom.ac_if.if_collisions += 16; 759 /* 760 * Clear TBUFF since it's not valid when RTRY 761 * set 762 */ 763 next->md->md3 &= ~TBUFF; 764 } 765 /* 766 * TBUFF is only valid if neither LCOL nor RTRY are set. 767 * We need to check UFLO after LCOL and RTRY so that we 768 * know whether or not TBUFF is valid. If either are 769 * set then TBUFF will have been cleared above. A 770 * UFLO error will turn off the transmitter so we 771 * have to reset. 772 * 773 */ 774 775 if (next->md->md3 & UFLO) { 776 LNCSTATS(uflo) 777 /* 778 * If an UFLO has occured it's possibly due 779 * to a TBUFF error 780 */ 781 if (next->md->md3 & TBUFF) { 782 LNCSTATS(tbuff) 783 log(LOG_ERR, "lnc%d: Transmit buffer error -- Resetting\n", unit); 784 } else 785 log(LOG_ERR, "lnc%d: Transmit underflow error -- Resetting\n", unit); 786 lnc_reset(sc); 787 return; 788 } 789 do { 790 INC_MD_PTR(sc->trans_next, sc->ntdre) 791 next = sc->trans_ring + sc->trans_next; 792 } while (!(next->md->md1 & STP) && (sc->trans_next != sc->next_to_send)); 793 794 } else { 795 /* 796 * Since we check for ERR first then if we get here 797 * the packet was transmitted correctly. There may 798 * still have been non-fatal errors though. 799 * Don't bother checking for DEF, waste of time. 800 */ 801 802 sc->arpcom.ac_if.if_opackets++; 803 804 if (next->md->md1 & MORE) { 805 LNCSTATS(more) 806 sc->arpcom.ac_if.if_collisions += 2; 807 } 808 809 /* 810 * ONE is invalid if LCOL is set. If LCOL was set then 811 * ERR would have also been set and we would have 812 * returned from lnc_tint above. Therefore we can 813 * assume if we arrive here that ONE is valid. 814 * 815 */ 816 817 if (next->md->md1 & ONE) { 818 LNCSTATS(one) 819 sc->arpcom.ac_if.if_collisions++; 820 } 821 INC_MD_PTR(sc->trans_next, sc->ntdre) 822 next = sc->trans_ring + sc->trans_next; 823 } 824 825 /* 826 * Clear descriptors and free any mbufs. 827 */ 828 829 do { 830 start = sc->trans_ring + start_of_packet; 831 start->md->md1 &= HADR; 832 if (sc->nic.mem_mode == DMA_MBUF) { 833 /* Cache clusters on a local queue */ 834 if ((start->buff.mbuf->m_flags & M_EXT) && (sc->mbuf_count < MBUF_CACHE_LIMIT)) { 835 if (sc->mbuf_count) { 836 start->buff.mbuf->m_next = sc->mbufs; 837 sc->mbufs = start->buff.mbuf; 838 } else 839 sc->mbufs = start->buff.mbuf; 840 sc->mbuf_count++; 841 start->buff.mbuf = 0; 842 } else { 843 /* XXX shouldn't this be m_freem ?? */ 844 m_free(start->buff.mbuf); 845 start->buff.mbuf = NULL; 846 } 847 } 848 sc->pending_transmits--; 849 INC_MD_PTR(start_of_packet, sc->ntdre) 850 }while (start_of_packet != sc->trans_next); 851 852 /* 853 * There's now at least one free descriptor 854 * in the ring so indicate that we can accept 855 * more packets again. 856 */ 857 858 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE; 859 860 lookahead++; 861 862 } while (sc->pending_transmits && !(next->md->md1 & OWN)); 863 864 /* 865 * Clear TINT since we've dealt with all 866 * the completed transmissions. 867 */ 868 869 outw(sc->rdp, TINT | INEA); 870 871 /* XXX only while doing if_is comparisons */ 872 if (!(sc->arpcom.ac_if.if_flags & IFF_OACTIVE)) 873 lnc_start(&sc->arpcom.ac_if); 874 875 } 876 877 static int 878 lnc_probe(struct isa_device * isa_dev) 879 { 880 int nports; 881 int unit = isa_dev->id_unit; 882 struct lnc_softc *sc = &lnc_softc[unit]; 883 unsigned iobase = isa_dev->id_iobase; 884 885 #ifdef DIAGNOSTIC 886 int vsw; 887 vsw = inw(isa_dev->id_iobase + PCNET_VSW); 888 printf("Vendor Specific Word = %x\n", vsw); 889 #endif 890 891 nports = bicc_probe(sc, iobase); 892 if (nports == 0) 893 nports = ne2100_probe(sc, iobase); 894 if (nports == 0) 895 nports = depca_probe(sc, iobase); 896 #ifdef PC98 897 if (nports == 0) 898 nports = cnet98s_probe(sc, iobase); 899 #endif 900 return (nports); 901 } 902 903 #ifdef PC98 904 /* ISA Bus Configuration Registers */ 905 /* XXX - Should be in ic/Am7990.h */ 906 #define MSRDA 0x0000 /* ISACSR0: Master Mode Read Activity */ 907 #define MSWRA 0x0001 /* ISACSR1: Master Mode Write Activity */ 908 #define MC 0x0002 /* ISACSR2: Miscellaneous Configuration */ 909 910 #define LED1 0x0005 /* ISACSR5: LED1 Status */ 911 #define LED2 0x0006 /* ISACSR6: LED2 Status */ 912 #define LED3 0x0007 /* ISACSR7: LED3 Status */ 913 914 #define LED_PSE 0x0080 /* Pulse Stretcher */ 915 #define LED_XMTE 0x0010 /* Transmit Status */ 916 #define LED_RVPOLE 0x0008 /* Receive Polarity */ 917 #define LED_RCVE 0x0004 /* Receive Status */ 918 #define LED_JABE 0x0002 /* Jabber */ 919 #define LED_COLE 0x0001 /* Collision */ 920 921 static int 922 cnet98s_probe(struct lnc_softc *sc, unsigned iobase) 923 { 924 int i; 925 ushort tmp; 926 927 sc->rap = iobase + CNET98S_RAP; 928 sc->rdp = iobase + CNET98S_RDP; 929 930 /* Reset */ 931 tmp = inw(iobase + CNET98S_RESET); 932 outw(iobase + CNET98S_RESET, tmp); 933 DELAY(500); 934 935 sc->nic.ic = pcnet_probe(sc); 936 if ((sc->nic.ic == UNKNOWN) || (sc->nic.ic > PCnet_32)) { 937 return (0); 938 } 939 940 sc->nic.ident = CNET98S; 941 sc->nic.mem_mode = DMA_FIXED; 942 943 /* XXX - For now just use the defines */ 944 sc->nrdre = NRDRE; 945 sc->ntdre = NTDRE; 946 947 /* Extract MAC address from PROM */ 948 for (i = 0; i < ETHER_ADDR_LEN; i++) { 949 sc->arpcom.ac_enaddr[i] = inb(iobase + (i * 2)); 950 } 951 952 /* 953 * ISA Configuration 954 * 955 * XXX - Following parameters are Contec C-NET(98)S only. 956 * So, check the Ethernet address here. 957 * 958 * Contec uses 00 80 4c ?? ?? ?? 959 */ 960 if (sc->arpcom.ac_enaddr[0] == (u_char)0x00 961 && sc->arpcom.ac_enaddr[1] == (u_char)0x80 962 && sc->arpcom.ac_enaddr[2] == (u_char)0x4c) { 963 outw(sc->rap, MSRDA); 964 outw(iobase + CNET98S_IDP, 0x0006); 965 outw(sc->rap, MSWRA); 966 outw(iobase + CNET98S_IDP, 0x0006); 967 #ifdef DIAGNOSTIC 968 outw(sc->rap, MC); 969 printf("ISACSR2 = %x\n", inw(iobase + CNET98S_IDP)); 970 #endif 971 outw(sc->rap, LED1); 972 outw(iobase + CNET98S_IDP, LED_PSE | LED_XMTE); 973 outw(sc->rap, LED2); 974 outw(iobase + CNET98S_IDP, LED_PSE | LED_RCVE); 975 outw(sc->rap, LED3); 976 outw(iobase + CNET98S_IDP, LED_PSE | LED_COLE); 977 } 978 979 return (CNET98S_IOSIZE); 980 } 981 #endif 982 983 static int 984 ne2100_probe(struct lnc_softc *sc, unsigned iobase) 985 { 986 int i; 987 988 sc->rap = iobase + PCNET_RAP; 989 sc->rdp = iobase + PCNET_RDP; 990 991 sc->nic.ic = pcnet_probe(sc); 992 if ((sc->nic.ic > 0) && (sc->nic.ic < PCnet_PCI)) { 993 sc->nic.ident = NE2100; 994 sc->nic.mem_mode = DMA_FIXED; 995 996 /* XXX - For now just use the defines */ 997 sc->nrdre = NRDRE; 998 sc->ntdre = NTDRE; 999 1000 /* Extract MAC address from PROM */ 1001 for (i = 0; i < ETHER_ADDR_LEN; i++) 1002 sc->arpcom.ac_enaddr[i] = inb(iobase + i); 1003 return (NE2100_IOSIZE); 1004 } else { 1005 return (0); 1006 } 1007 } 1008 1009 static int 1010 bicc_probe(struct lnc_softc *sc, unsigned iobase) 1011 { 1012 int i; 1013 1014 /* 1015 * There isn't any way to determine if a NIC is a BICC. Basically, if 1016 * the lance probe succeeds using the i/o addresses of the BICC then 1017 * we assume it's a BICC. 1018 * 1019 */ 1020 1021 sc->rap = iobase + BICC_RAP; 1022 sc->rdp = iobase + BICC_RDP; 1023 1024 /* I think all these cards us the Am7990 */ 1025 1026 if ((sc->nic.ic = lance_probe(sc))) { 1027 sc->nic.ident = BICC; 1028 sc->nic.mem_mode = DMA_FIXED; 1029 1030 /* XXX - For now just use the defines */ 1031 sc->nrdre = NRDRE; 1032 sc->ntdre = NTDRE; 1033 1034 /* Extract MAC address from PROM */ 1035 for (i = 0; i < ETHER_ADDR_LEN; i++) 1036 sc->arpcom.ac_enaddr[i] = inb(iobase + (i * 2)); 1037 1038 return (BICC_IOSIZE); 1039 } else { 1040 return (0); 1041 } 1042 } 1043 1044 /* 1045 * I don't have data sheets for the dec cards but it looks like the mac 1046 * address is contained in a 32 byte ring. Each time you read from the port 1047 * you get the next byte in the ring. The mac address is stored after a 1048 * signature so keep searching for the signature first. 1049 */ 1050 static int 1051 dec_macaddr_extract(u_char ring[], struct lnc_softc * sc) 1052 { 1053 const unsigned char signature[] = {0xff, 0x00, 0x55, 0xaa, 0xff, 0x00, 0x55, 0xaa}; 1054 1055 int i, j, rindex; 1056 1057 for (i = 0; i < sizeof ring; i++) { 1058 for (j = 0, rindex = i; j < sizeof signature; j++) { 1059 if (ring[rindex] != signature[j]) 1060 break; 1061 if (++rindex > sizeof ring) 1062 rindex = 0; 1063 } 1064 if (j == sizeof signature) { 1065 for (j = 0, rindex = i; j < ETHER_ADDR_LEN; j++) { 1066 sc->arpcom.ac_enaddr[j] = ring[rindex]; 1067 if (++rindex > sizeof ring) 1068 rindex = 0; 1069 } 1070 return (1); 1071 } 1072 } 1073 return (0); 1074 } 1075 1076 static int 1077 depca_probe(struct lnc_softc *sc, unsigned iobase) 1078 { 1079 int i; 1080 unsigned char maddr_ring[DEPCA_ADDR_ROM_SIZE]; 1081 1082 sc->rap = iobase + DEPCA_RAP; 1083 sc->rdp = iobase + DEPCA_RDP; 1084 1085 if ((sc->nic.ic = lance_probe(sc))) { 1086 sc->nic.ident = DEPCA; 1087 sc->nic.mem_mode = SHMEM; 1088 1089 /* Extract MAC address from PROM */ 1090 for (i = 0; i < DEPCA_ADDR_ROM_SIZE; i++) 1091 maddr_ring[i] = inb(iobase + DEPCA_ADP); 1092 if (dec_macaddr_extract(maddr_ring, sc)) { 1093 return (DEPCA_IOSIZE); 1094 } 1095 } 1096 return (0); 1097 } 1098 1099 static int 1100 lance_probe(struct lnc_softc *sc) 1101 { 1102 write_csr(sc, CSR0, STOP); 1103 1104 if ((inw(sc->rdp) & STOP) && !(read_csr(sc, CSR3))) { 1105 /* 1106 * Check to see if it's a C-LANCE. For the LANCE the INEA bit 1107 * cannot be set while the STOP bit is. This restriction is 1108 * removed for the C-LANCE. 1109 */ 1110 write_csr(sc, CSR0, INEA); 1111 if (read_csr(sc, CSR0) & INEA) 1112 return (C_LANCE); 1113 else 1114 return (LANCE); 1115 } else 1116 return (UNKNOWN); 1117 } 1118 1119 static int 1120 pcnet_probe(struct lnc_softc *sc) 1121 { 1122 u_long chip_id; 1123 int type; 1124 int reset_val; 1125 1126 /* 1127 * The PCnet family don't reset the RAP register on reset so we'll 1128 * have to write during the probe :-) It does have an ID register 1129 * though so the probe is just a matter of reading it. 1130 */ 1131 1132 reset_val = inw(sc->reset); 1133 outw(reset_val, sc->reset); 1134 if ((type = lance_probe(sc))) { 1135 chip_id = read_csr(sc, CSR89); 1136 chip_id <<= 16; 1137 chip_id |= read_csr(sc, CSR88); 1138 if (chip_id & AMD_MASK) { 1139 chip_id >>= 12; 1140 switch (chip_id & PART_MASK) { 1141 case Am79C960: 1142 return (PCnet_ISA); 1143 case Am79C961: 1144 return (PCnet_ISAplus); 1145 case Am79C961A: 1146 return (PCnet_ISA_II); 1147 case Am79C965: 1148 return (PCnet_32); 1149 case Am79C970: 1150 return (PCnet_PCI); 1151 case Am79C970A: 1152 return (PCnet_PCI_II); 1153 case Am79C971: 1154 return (PCnet_FAST); 1155 case Am79C972: 1156 case Am79C973: 1157 return (PCnet_FASTplus); 1158 case Am79C978: 1159 return (PCnet_Home); 1160 default: 1161 break; 1162 } 1163 } 1164 } 1165 return (type); 1166 } 1167 1168 static int 1169 lnc_attach_sc(struct lnc_softc *sc, int unit) 1170 { 1171 int lnc_mem_size; 1172 1173 /* 1174 * Allocate memory for use by the controller. 1175 * 1176 * XXX -- the Am7990 and Am79C960 only have 24 address lines and so can 1177 * only access the lower 16Mb of physical memory. For the moment we 1178 * assume that malloc will allocate memory within the lower 16Mb 1179 * range. This is not a very valid assumption but there's nothing 1180 * that can be done about it yet. For shared memory NICs this isn't 1181 * relevant. 1182 * 1183 */ 1184 1185 lnc_mem_size = ((NDESC(sc->nrdre) + NDESC(sc->ntdre)) * 1186 sizeof(struct host_ring_entry)); 1187 1188 if (sc->nic.mem_mode != SHMEM) 1189 lnc_mem_size += sizeof(struct init_block) + (sizeof(struct mds) * 1190 (NDESC(sc->nrdre) + NDESC(sc->ntdre))) + 1191 MEM_SLEW; 1192 1193 /* If using DMA to fixed host buffers then allocate memory for them */ 1194 1195 if (sc->nic.mem_mode == DMA_FIXED) 1196 lnc_mem_size += (NDESC(sc->nrdre) * RECVBUFSIZE) + (NDESC(sc->ntdre) * TRANSBUFSIZE); 1197 1198 if (sc->nic.mem_mode != SHMEM) { 1199 if (sc->nic.ic < PCnet_32) { 1200 /* ISA based cards */ 1201 sc->recv_ring = contigmalloc(lnc_mem_size, M_DEVBUF, M_NOWAIT, 1202 0ul, 0xfffffful, 4ul, 0x1000000); 1203 } else { 1204 /* Non-ISA based cards, 32 bit capable */ 1205 #ifdef notyet 1206 /* 1207 * For the 32 bit driver we're not fussed where we DMA to 1208 * though it'll still need to be contiguous 1209 */ 1210 sc->recv_ring = malloc(lnc_mem_size, M_DEVBUF, M_NOWAIT); 1211 #else 1212 /* 1213 * For now it still needs to be below 16MB because the 1214 * descriptor's can only hold 16 bit addresses. 1215 */ 1216 sc->recv_ring = contigmalloc(lnc_mem_size, M_DEVBUF, M_NOWAIT, 1217 0ul, 0xfffffful, 4ul, 0x1000000); 1218 #endif 1219 } 1220 } 1221 1222 if (!sc->recv_ring) { 1223 log(LOG_ERR, "lnc%d: Couldn't allocate memory for NIC\n", unit); 1224 return (0); /* XXX -- attach failed -- not tested in 1225 * calling routines */ 1226 } 1227 1228 /* Set default mode */ 1229 sc->nic.mode = NORMAL; 1230 1231 /* Fill in arpcom structure entries */ 1232 1233 sc->arpcom.ac_if.if_softc = sc; 1234 sc->arpcom.ac_if.if_name = lncdriver.name; 1235 sc->arpcom.ac_if.if_unit = unit; 1236 sc->arpcom.ac_if.if_mtu = ETHERMTU; 1237 sc->arpcom.ac_if.if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1238 sc->arpcom.ac_if.if_timer = 0; 1239 sc->arpcom.ac_if.if_output = ether_output; 1240 sc->arpcom.ac_if.if_start = lnc_start; 1241 sc->arpcom.ac_if.if_ioctl = lnc_ioctl; 1242 sc->arpcom.ac_if.if_watchdog = lnc_watchdog; 1243 sc->arpcom.ac_if.if_init = lnc_init; 1244 sc->arpcom.ac_if.if_type = IFT_ETHER; 1245 sc->arpcom.ac_if.if_addrlen = ETHER_ADDR_LEN; 1246 sc->arpcom.ac_if.if_hdrlen = ETHER_HDR_LEN; 1247 sc->arpcom.ac_if.if_snd.ifq_maxlen = IFQ_MAXLEN; 1248 1249 ether_ifattach(&sc->arpcom.ac_if, ETHER_BPF_SUPPORTED); 1250 1251 printf("lnc%d: ", unit); 1252 if (sc->nic.ic == LANCE || sc->nic.ic == C_LANCE) 1253 printf("%s (%s)", 1254 nic_ident[sc->nic.ident], ic_ident[sc->nic.ic]); 1255 else 1256 printf("%s", ic_ident[sc->nic.ic]); 1257 printf(" address %6D\n", sc->arpcom.ac_enaddr, ":"); 1258 1259 return (1); 1260 } 1261 1262 static int 1263 lnc_attach(struct isa_device * isa_dev) 1264 { 1265 int unit = isa_dev->id_unit; 1266 struct lnc_softc *sc = &lnc_softc[unit]; 1267 int result; 1268 1269 isa_dev->id_ointr = lncintr; 1270 result = lnc_attach_sc (sc, unit); 1271 if (result == 0) 1272 return (0); 1273 1274 #ifndef PC98 1275 /* 1276 * XXX - is it safe to call isa_dmacascade() after if_attach() 1277 * and ether_ifattach() have been called in lnc_attach() ??? 1278 */ 1279 if ((sc->nic.mem_mode != SHMEM) && 1280 (sc->nic.ic < PCnet_32)) 1281 isa_dmacascade(isa_dev->id_drq); 1282 #endif 1283 1284 return result; 1285 } 1286 1287 #if NPCI > 0 1288 void * 1289 lnc_attach_ne2100_pci(int unit, unsigned iobase) 1290 { 1291 int i; 1292 struct lnc_softc *sc = malloc(sizeof *sc, M_DEVBUF, M_NOWAIT); 1293 1294 if (sc) { 1295 bzero (sc, sizeof *sc); 1296 1297 sc->rap = iobase + PCNET_RAP; 1298 sc->rdp = iobase + PCNET_RDP; 1299 sc->bdp = iobase + PCNET_BDP; 1300 sc->reset = iobase + PCNET_RESET; 1301 1302 sc->nic.ic = pcnet_probe(sc); 1303 if (sc->nic.ic >= PCnet_32) { 1304 sc->nic.ident = NE2100; 1305 sc->nic.mem_mode = DMA_FIXED; 1306 1307 /* XXX - For now just use the defines */ 1308 sc->nrdre = NRDRE; 1309 sc->ntdre = NTDRE; 1310 1311 /* Extract MAC address from PROM */ 1312 for (i = 0; i < ETHER_ADDR_LEN; i++) 1313 sc->arpcom.ac_enaddr[i] = inb(iobase + i); 1314 1315 if (lnc_attach_sc(sc, unit) == 0) { 1316 free(sc, M_DEVBUF); 1317 sc = NULL; 1318 } 1319 } 1320 else { 1321 free(sc, M_DEVBUF); 1322 sc = NULL; 1323 } 1324 } 1325 return sc; 1326 } 1327 #endif 1328 1329 static void 1330 lnc_init(xsc) 1331 void *xsc; 1332 { 1333 struct lnc_softc *sc = xsc; 1334 int s, i; 1335 char *lnc_mem; 1336 1337 /* Check that interface has valid address */ 1338 1339 if (TAILQ_EMPTY(&sc->arpcom.ac_if.if_addrhead)) /* XXX unlikely */ 1340 return; 1341 1342 /* Shut down interface */ 1343 1344 s = splimp(); 1345 lnc_stop(sc); 1346 sc->arpcom.ac_if.if_flags |= IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; /* XXX??? */ 1347 1348 /* 1349 * This sets up the memory area for the controller. Memory is set up for 1350 * the initialisation block (12 words of contiguous memory starting 1351 * on a word boundary),the transmit and receive ring structures (each 1352 * entry is 4 words long and must start on a quadword boundary) and 1353 * the data buffers. 1354 * 1355 * The alignment tests are particularly paranoid. 1356 */ 1357 1358 1359 1360 sc->recv_next = 0; 1361 sc->trans_ring = sc->recv_ring + NDESC(sc->nrdre); 1362 sc->trans_next = 0; 1363 1364 if (sc->nic.mem_mode == SHMEM) 1365 lnc_mem = (char *) sc->nic.iobase; 1366 else 1367 lnc_mem = (char *) (sc->trans_ring + NDESC(sc->ntdre)); 1368 1369 lnc_mem = (char *)(((int)lnc_mem + 1) & ~1); 1370 sc->init_block = (struct init_block *) ((int) lnc_mem & ~1); 1371 lnc_mem = (char *) (sc->init_block + 1); 1372 lnc_mem = (char *)(((int)lnc_mem + 7) & ~7); 1373 1374 /* Initialise pointers to descriptor entries */ 1375 for (i = 0; i < NDESC(sc->nrdre); i++) { 1376 (sc->recv_ring + i)->md = (struct mds *) lnc_mem; 1377 lnc_mem += sizeof(struct mds); 1378 } 1379 for (i = 0; i < NDESC(sc->ntdre); i++) { 1380 (sc->trans_ring + i)->md = (struct mds *) lnc_mem; 1381 lnc_mem += sizeof(struct mds); 1382 } 1383 1384 /* Initialise the remaining ring entries */ 1385 1386 if (sc->nic.mem_mode == DMA_MBUF) { 1387 1388 sc->mbufs = 0; 1389 sc->mbuf_count = 0; 1390 1391 /* Free previously allocated mbufs */ 1392 if (sc->flags & LNC_INITIALISED) 1393 lnc_free_mbufs(sc); 1394 1395 1396 for (i = 0; i < NDESC(sc->nrdre); i++) { 1397 if (alloc_mbuf_cluster(sc, sc->recv_ring+i)) { 1398 log(LOG_ERR, "Initialisation failed -- no mbufs\n"); 1399 splx(s); 1400 return; 1401 } 1402 } 1403 1404 for (i = 0; i < NDESC(sc->ntdre); i++) { 1405 (sc->trans_ring + i)->buff.mbuf = 0; 1406 (sc->trans_ring + i)->md->md0 = 0; 1407 (sc->trans_ring + i)->md->md1 = 0; 1408 (sc->trans_ring + i)->md->md2 = 0; 1409 (sc->trans_ring + i)->md->md3 = 0; 1410 } 1411 } else { 1412 for (i = 0; i < NDESC(sc->nrdre); i++) { 1413 (sc->recv_ring + i)->md->md0 = kvtop(lnc_mem); 1414 (sc->recv_ring + i)->md->md1 = ((kvtop(lnc_mem) >> 16) & 0xff) | OWN; 1415 (sc->recv_ring + i)->md->md2 = -RECVBUFSIZE; 1416 (sc->recv_ring + i)->md->md3 = 0; 1417 (sc->recv_ring + i)->buff.data = lnc_mem; 1418 lnc_mem += RECVBUFSIZE; 1419 } 1420 for (i = 0; i < NDESC(sc->ntdre); i++) { 1421 (sc->trans_ring + i)->md->md0 = kvtop(lnc_mem); 1422 (sc->trans_ring + i)->md->md1 = ((kvtop(lnc_mem) >> 16) & 0xff); 1423 (sc->trans_ring + i)->md->md2 = 0; 1424 (sc->trans_ring + i)->md->md3 = 0; 1425 (sc->trans_ring + i)->buff.data = lnc_mem; 1426 lnc_mem += TRANSBUFSIZE; 1427 } 1428 } 1429 1430 sc->next_to_send = 0; 1431 1432 /* Set up initialisation block */ 1433 1434 sc->init_block->mode = sc->nic.mode; 1435 1436 for (i = 0; i < ETHER_ADDR_LEN; i++) 1437 sc->init_block->padr[i] = sc->arpcom.ac_enaddr[i]; 1438 1439 lnc_setladrf(sc); 1440 1441 sc->init_block->rdra = kvtop(sc->recv_ring->md); 1442 sc->init_block->rlen = ((kvtop(sc->recv_ring->md) >> 16) & 0xff) | (sc->nrdre << 13); 1443 sc->init_block->tdra = kvtop(sc->trans_ring->md); 1444 sc->init_block->tlen = ((kvtop(sc->trans_ring->md) >> 16) & 0xff) | (sc->ntdre << 13); 1445 1446 1447 /* Set flags to show that the memory area is valid */ 1448 sc->flags |= LNC_INITIALISED; 1449 1450 sc->pending_transmits = 0; 1451 1452 /* Give the LANCE the physical address of the initialisation block */ 1453 1454 if (sc->nic.ic == PCnet_Home) { 1455 u_short media; 1456 /* Set PHY_SEL to HomeRun */ 1457 media = read_bcr(sc, BCR49); 1458 media &= ~3; 1459 media |= 1; 1460 write_bcr(sc, BCR49, media); 1461 } 1462 1463 write_csr(sc, CSR1, kvtop(sc->init_block)); 1464 write_csr(sc, CSR2, (kvtop(sc->init_block) >> 16) & 0xff); 1465 1466 /* 1467 * Depending on which controller this is, CSR3 has different meanings. 1468 * For the Am7990 it controls DMA operations, for the Am79C960 it 1469 * controls interrupt masks and transmitter algorithms. In either 1470 * case, none of the flags are set. 1471 * 1472 */ 1473 1474 write_csr(sc, CSR3, 0); 1475 1476 /* Let's see if it starts */ 1477 1478 write_csr(sc, CSR0, INIT); 1479 for (i = 0; i < 1000; i++) 1480 if (read_csr(sc, CSR0) & IDON) 1481 break; 1482 1483 /* 1484 * Now that the initialisation is complete there's no reason to 1485 * access anything except CSR0, so we leave RAP pointing there 1486 * so we can just access RDP from now on, saving an outw each 1487 * time. 1488 */ 1489 1490 if (read_csr(sc, CSR0) & IDON) { 1491 /* 1492 * Enable interrupts, start the LANCE, mark the interface as 1493 * running and transmit any pending packets. 1494 */ 1495 write_csr(sc, CSR0, STRT | INEA); 1496 sc->arpcom.ac_if.if_flags |= IFF_RUNNING; 1497 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE; 1498 lnc_start(&sc->arpcom.ac_if); 1499 } else 1500 log(LOG_ERR, "lnc%d: Initialisation failed\n", 1501 sc->arpcom.ac_if.if_unit); 1502 1503 splx(s); 1504 } 1505 1506 /* 1507 * The interrupt flag (INTR) will be set and provided that the interrupt enable 1508 * flag (INEA) is also set, the interrupt pin will be driven low when any of 1509 * the following occur: 1510 * 1511 * 1) Completion of the initialisation routine (IDON). 2) The reception of a 1512 * packet (RINT). 3) The transmission of a packet (TINT). 4) A transmitter 1513 * timeout error (BABL). 5) A missed packet (MISS). 6) A memory error (MERR). 1514 * 1515 * The interrupt flag is cleared when all of the above conditions are cleared. 1516 * 1517 * If the driver is reset from this routine then it first checks to see if any 1518 * interrupts have ocurred since the reset and handles them before returning. 1519 * This is because the NIC may signify a pending interrupt in CSR0 using the 1520 * INTR flag even if a hardware interrupt is currently inhibited (at least I 1521 * think it does from reading the data sheets). We may as well deal with 1522 * these pending interrupts now rather than get the overhead of another 1523 * hardware interrupt immediately upon returning from the interrupt handler. 1524 * 1525 */ 1526 1527 void 1528 lncintr_sc(struct lnc_softc *sc) 1529 { 1530 int unit = sc->arpcom.ac_if.if_unit; 1531 u_short csr0; 1532 1533 /* 1534 * INEA is the only bit that can be cleared by writing a 0 to it so 1535 * we have to include it in any writes that clear other flags. 1536 */ 1537 1538 while ((csr0 = inw(sc->rdp)) & INTR) { 1539 1540 /* 1541 * Clear interrupt flags early to avoid race conditions. The 1542 * controller can still set these flags even while we're in 1543 * this interrupt routine. If the flag is still set from the 1544 * event that caused this interrupt any new events will 1545 * be missed. 1546 */ 1547 1548 /* outw(sc->rdp, IDON | CERR | BABL | MISS | MERR | RINT | TINT | INEA); */ 1549 outw(sc->rdp, csr0); 1550 1551 /* We don't do anything with the IDON flag */ 1552 1553 if (csr0 & ERR) { 1554 if (csr0 & CERR) { 1555 log(LOG_ERR, "lnc%d: Heartbeat error -- SQE test failed\n", unit); 1556 LNCSTATS(cerr) 1557 } 1558 if (csr0 & BABL) { 1559 log(LOG_ERR, "lnc%d: Babble error - more than 1519 bytes transmitted\n", unit); 1560 LNCSTATS(babl) 1561 sc->arpcom.ac_if.if_oerrors++; 1562 } 1563 if (csr0 & MISS) { 1564 log(LOG_ERR, "lnc%d: Missed packet -- no receive buffer\n", unit); 1565 LNCSTATS(miss) 1566 sc->arpcom.ac_if.if_ierrors++; 1567 } 1568 if (csr0 & MERR) { 1569 log(LOG_ERR, "lnc%d: Memory error -- Resetting\n", unit); 1570 LNCSTATS(merr) 1571 lnc_reset(sc); 1572 continue; 1573 } 1574 } 1575 if (csr0 & RINT) { 1576 LNCSTATS(rint) 1577 lnc_rint(sc); 1578 } 1579 if (csr0 & TINT) { 1580 LNCSTATS(tint) 1581 sc->arpcom.ac_if.if_timer = 0; 1582 lnc_tint(sc); 1583 } 1584 1585 /* 1586 * If there's room in the transmit descriptor ring then queue 1587 * some more transmit packets. 1588 */ 1589 1590 if (!(sc->arpcom.ac_if.if_flags & IFF_OACTIVE)) 1591 lnc_start(&sc->arpcom.ac_if); 1592 } 1593 } 1594 1595 static void 1596 lncintr(int unit) 1597 { 1598 struct lnc_softc *sc = &lnc_softc[unit]; 1599 lncintr_sc (sc); 1600 } 1601 1602 static __inline int 1603 mbuf_to_buffer(struct mbuf *m, char *buffer) 1604 { 1605 1606 int len=0; 1607 1608 for( ; m; m = m->m_next) { 1609 bcopy(mtod(m, caddr_t), buffer, m->m_len); 1610 buffer += m->m_len; 1611 len += m->m_len; 1612 } 1613 1614 return(len); 1615 } 1616 1617 static __inline struct mbuf * 1618 chain_to_cluster(struct mbuf *m) 1619 { 1620 struct mbuf *new; 1621 1622 MGET(new, M_DONTWAIT, MT_DATA); 1623 if (new) { 1624 MCLGET(new, M_DONTWAIT); 1625 if (new->m_ext.ext_buf) { 1626 new->m_len = mbuf_to_buffer(m, new->m_data); 1627 m_freem(m); 1628 return(new); 1629 } else 1630 m_free(new); 1631 } 1632 return(0); 1633 } 1634 1635 /* 1636 * IFF_OACTIVE and IFF_RUNNING are checked in ether_output so it's redundant 1637 * to check them again since we wouldn't have got here if they were not 1638 * appropriately set. This is also called from lnc_init and lncintr but the 1639 * flags should be ok at those points too. 1640 */ 1641 1642 static void 1643 lnc_start(struct ifnet *ifp) 1644 { 1645 1646 struct lnc_softc *sc = ifp->if_softc; 1647 struct host_ring_entry *desc; 1648 int tmp; 1649 int end_of_packet; 1650 struct mbuf *head, *m; 1651 int len, chunk; 1652 int addr; 1653 int no_entries_needed; 1654 1655 do { 1656 1657 IF_DEQUEUE(&sc->arpcom.ac_if.if_snd, head); 1658 if (!head) 1659 return; 1660 1661 if (sc->nic.mem_mode == DMA_MBUF) { 1662 1663 no_entries_needed = 0; 1664 for (m=head; m; m = m->m_next) 1665 no_entries_needed++; 1666 1667 /* 1668 * We try and avoid bcopy as much as possible 1669 * but there are two cases when we use it. 1670 * 1671 * 1) If there are not enough free entries in the ring 1672 * to hold each mbuf in the chain then compact the 1673 * chain into a single cluster. 1674 * 1675 * 2) The Am7990 and Am79C90 must not have less than 1676 * 100 bytes in the first descriptor of a chained 1677 * packet so it's necessary to shuffle the mbuf 1678 * contents to ensure this. 1679 */ 1680 1681 1682 if (no_entries_needed > (NDESC(sc->ntdre) - sc->pending_transmits)) { 1683 if (!(head = chain_to_cluster(head))) { 1684 log(LOG_ERR, "lnc%d: Couldn't get mbuf for transmit packet -- Resetting \n ",ifp->if_unit); 1685 lnc_reset(sc); 1686 return; 1687 } 1688 } else if ((sc->nic.ic == LANCE) || (sc->nic.ic == C_LANCE)) { 1689 if ((head->m_len < 100) && (head->m_next)) { 1690 len = 100 - head->m_len; 1691 if (M_TRAILINGSPACE(head) < len) { 1692 /* 1693 * Move data to start of data 1694 * area. We assume the first 1695 * mbuf has a packet header 1696 * and is not a cluster. 1697 */ 1698 bcopy((caddr_t)head->m_data, (caddr_t)head->m_pktdat, head->m_len); 1699 head->m_data = head->m_pktdat; 1700 } 1701 m = head->m_next; 1702 while (m && (len > 0)) { 1703 chunk = min(len, m->m_len); 1704 bcopy(mtod(m, caddr_t), mtod(head, caddr_t) + head->m_len, chunk); 1705 len -= chunk; 1706 head->m_len += chunk; 1707 m->m_len -= chunk; 1708 m->m_data += chunk; 1709 if (m->m_len <= 0) { 1710 m = m_free(m); 1711 head->m_next = m; 1712 } 1713 } 1714 } 1715 } 1716 1717 tmp = sc->next_to_send; 1718 1719 /* 1720 * On entering this loop we know that tmp points to a 1721 * descriptor with a clear OWN bit. 1722 */ 1723 1724 desc = sc->trans_ring + tmp; 1725 len = ETHER_MIN_LEN; 1726 for (m = head; m; m = m->m_next) { 1727 desc->buff.mbuf = m; 1728 addr = kvtop(m->m_data); 1729 desc->md->md0 = addr; 1730 desc->md->md1 = ((addr >> 16) & 0xff); 1731 desc->md->md3 = 0; 1732 desc->md->md2 = -m->m_len; 1733 sc->pending_transmits++; 1734 len -= m->m_len; 1735 1736 INC_MD_PTR(tmp, sc->ntdre) 1737 desc = sc->trans_ring + tmp; 1738 } 1739 1740 end_of_packet = tmp; 1741 DEC_MD_PTR(tmp, sc->ntdre) 1742 desc = sc->trans_ring + tmp; 1743 desc->md->md1 |= ENP; 1744 1745 if (len > 0) 1746 desc->md->md2 -= len; 1747 1748 /* 1749 * Set OWN bits in reverse order, otherwise the Lance 1750 * could start sending the packet before all the 1751 * buffers have been relinquished by the host. 1752 */ 1753 1754 while (tmp != sc->next_to_send) { 1755 desc->md->md1 |= OWN; 1756 DEC_MD_PTR(tmp, sc->ntdre) 1757 desc = sc->trans_ring + tmp; 1758 } 1759 sc->next_to_send = end_of_packet; 1760 desc->md->md1 |= STP | OWN; 1761 } else { 1762 sc->pending_transmits++; 1763 desc = sc->trans_ring + sc->next_to_send; 1764 len = mbuf_to_buffer(head, desc->buff.data); 1765 desc->md->md3 = 0; 1766 desc->md->md2 = -max(len, ETHER_MIN_LEN - ETHER_CRC_LEN); 1767 desc->md->md1 |= OWN | STP | ENP; 1768 INC_MD_PTR(sc->next_to_send, sc->ntdre) 1769 } 1770 1771 /* Force an immediate poll of the transmit ring */ 1772 outw(sc->rdp, TDMD | INEA); 1773 1774 /* 1775 * Set a timer so if the buggy Am7990.h shuts 1776 * down we can wake it up. 1777 */ 1778 1779 ifp->if_timer = 2; 1780 1781 if (sc->arpcom.ac_if.if_bpf) 1782 bpf_mtap(&sc->arpcom.ac_if, head); 1783 1784 if (sc->nic.mem_mode != DMA_MBUF) 1785 m_freem(head); 1786 1787 } while (sc->pending_transmits < NDESC(sc->ntdre)); 1788 1789 /* 1790 * Transmit ring is full so set IFF_OACTIVE 1791 * since we can't buffer any more packets. 1792 */ 1793 1794 sc->arpcom.ac_if.if_flags |= IFF_OACTIVE; 1795 LNCSTATS(trans_ring_full) 1796 } 1797 1798 static int 1799 lnc_ioctl(struct ifnet * ifp, u_long command, caddr_t data) 1800 { 1801 1802 struct lnc_softc *sc = ifp->if_softc; 1803 int s, error = 0; 1804 1805 s = splimp(); 1806 1807 switch (command) { 1808 case SIOCSIFADDR: 1809 case SIOCGIFADDR: 1810 case SIOCSIFMTU: 1811 error = ether_ioctl(ifp, command, data); 1812 break; 1813 1814 case SIOCSIFFLAGS: 1815 #ifdef DEBUG 1816 if (ifp->if_flags & IFF_DEBUG) 1817 sc->lnc_debug = 1; 1818 else 1819 sc->lnc_debug = 0; 1820 #endif 1821 if (ifp->if_flags & IFF_PROMISC) { 1822 if (!(sc->nic.mode & PROM)) { 1823 sc->nic.mode |= PROM; 1824 lnc_init(sc); 1825 } 1826 } else if (sc->nic.mode & PROM) { 1827 sc->nic.mode &= ~PROM; 1828 lnc_init(sc); 1829 } 1830 1831 if ((ifp->if_flags & IFF_ALLMULTI) && 1832 !(sc->flags & LNC_ALLMULTI)) { 1833 sc->flags |= LNC_ALLMULTI; 1834 lnc_init(sc); 1835 } else if (!(ifp->if_flags & IFF_ALLMULTI) && 1836 (sc->flags & LNC_ALLMULTI)) { 1837 sc->flags &= ~LNC_ALLMULTI; 1838 lnc_init(sc); 1839 } 1840 1841 if ((ifp->if_flags & IFF_UP) == 0 && 1842 (ifp->if_flags & IFF_RUNNING) != 0) { 1843 /* 1844 * If interface is marked down and it is running, 1845 * then stop it. 1846 */ 1847 lnc_stop(sc); 1848 ifp->if_flags &= ~IFF_RUNNING; 1849 } else if ((ifp->if_flags & IFF_UP) != 0 && 1850 (ifp->if_flags & IFF_RUNNING) == 0) { 1851 /* 1852 * If interface is marked up and it is stopped, then 1853 * start it. 1854 */ 1855 lnc_init(sc); 1856 } 1857 break; 1858 case SIOCADDMULTI: 1859 case SIOCDELMULTI: 1860 lnc_init(sc); 1861 error = 0; 1862 break; 1863 default: 1864 error = EINVAL; 1865 } 1866 (void) splx(s); 1867 return error; 1868 } 1869 1870 static void 1871 lnc_watchdog(struct ifnet *ifp) 1872 { 1873 log(LOG_ERR, "lnc%d: Device timeout -- Resetting\n", ifp->if_unit); 1874 ifp->if_oerrors++; 1875 lnc_reset(ifp->if_softc); 1876 } 1877 1878 #ifdef DEBUG 1879 void 1880 lnc_dump_state(struct lnc_softc *sc) 1881 { 1882 int i; 1883 1884 printf("\nDriver/NIC [%d] state dump\n", sc->arpcom.ac_if.if_unit); 1885 printf("Memory access mode: %b\n", sc->nic.mem_mode, MEM_MODES); 1886 printf("Host memory\n"); 1887 printf("-----------\n"); 1888 1889 printf("Receive ring: base = %p, next = %p\n", 1890 (void *)sc->recv_ring, (void *)(sc->recv_ring + sc->recv_next)); 1891 for (i = 0; i < NDESC(sc->nrdre); i++) 1892 printf("\t%d:%p md = %p buff = %p\n", 1893 i, (void *)(sc->recv_ring + i), 1894 (void *)(sc->recv_ring + i)->md, 1895 (void *)(sc->recv_ring + i)->buff.data); 1896 1897 printf("Transmit ring: base = %p, next = %p\n", 1898 (void *)sc->trans_ring, (void *)(sc->trans_ring + sc->trans_next)); 1899 for (i = 0; i < NDESC(sc->ntdre); i++) 1900 printf("\t%d:%p md = %p buff = %p\n", 1901 i, (void *)(sc->trans_ring + i), 1902 (void *)(sc->trans_ring + i)->md, 1903 (void *)(sc->trans_ring + i)->buff.data); 1904 printf("Lance memory (may be on host(DMA) or card(SHMEM))\n"); 1905 printf("Init block = %p\n", (void *)sc->init_block); 1906 printf("\tmode = %b rlen:rdra = %x:%x tlen:tdra = %x:%x\n", 1907 sc->init_block->mode, INIT_MODE, sc->init_block->rlen, 1908 sc->init_block->rdra, sc->init_block->tlen, sc->init_block->tdra); 1909 printf("Receive descriptor ring\n"); 1910 for (i = 0; i < NDESC(sc->nrdre); i++) 1911 printf("\t%d buffer = 0x%x%x, BCNT = %d,\tMCNT = %u,\tflags = %b\n", 1912 i, ((sc->recv_ring + i)->md->md1 & HADR), 1913 (sc->recv_ring + i)->md->md0, 1914 -(short) (sc->recv_ring + i)->md->md2, 1915 (sc->recv_ring + i)->md->md3, 1916 (((sc->recv_ring + i)->md->md1 & ~HADR) >> 8), RECV_MD1); 1917 printf("Transmit descriptor ring\n"); 1918 for (i = 0; i < NDESC(sc->ntdre); i++) 1919 printf("\t%d buffer = 0x%x%x, BCNT = %d,\tflags = %b %b\n", 1920 i, ((sc->trans_ring + i)->md->md1 & HADR), 1921 (sc->trans_ring + i)->md->md0, 1922 -(short) (sc->trans_ring + i)->md->md2, 1923 ((sc->trans_ring + i)->md->md1 >> 8), TRANS_MD1, 1924 ((sc->trans_ring + i)->md->md3 >> 10), TRANS_MD3); 1925 printf("\nnext_to_send = %x\n", sc->next_to_send); 1926 printf("\n CSR0 = %b CSR1 = %x CSR2 = %x CSR3 = %x\n\n", 1927 read_csr(sc, CSR0), CSR0_FLAGS, read_csr(sc, CSR1), 1928 read_csr(sc, CSR2), read_csr(sc, CSR3)); 1929 1930 /* Set RAP back to CSR0 */ 1931 outw(sc->rap, CSR0); 1932 } 1933 1934 void 1935 mbuf_dump_chain(struct mbuf * m) 1936 { 1937 1938 #define MBUF_FLAGS \ 1939 "\2\1M_EXT\2M_PKTHDR\3M_EOR\4UNKNOWN\5M_BCAST\6M_MCAST" 1940 1941 if (!m) 1942 log(LOG_DEBUG, "m == NULL\n"); 1943 do { 1944 log(LOG_DEBUG, "m = %p\n", (void *)m); 1945 log(LOG_DEBUG, "m_hdr.mh_next = %p\n", 1946 (void *)m->m_hdr.mh_next); 1947 log(LOG_DEBUG, "m_hdr.mh_nextpkt = %p\n", 1948 (void *)m->m_hdr.mh_nextpkt); 1949 log(LOG_DEBUG, "m_hdr.mh_len = %d\n", m->m_hdr.mh_len); 1950 log(LOG_DEBUG, "m_hdr.mh_data = %p\n", 1951 (void *)m->m_hdr.mh_data); 1952 log(LOG_DEBUG, "m_hdr.mh_type = %d\n", m->m_hdr.mh_type); 1953 log(LOG_DEBUG, "m_hdr.mh_flags = %b\n", m->m_hdr.mh_flags, 1954 MBUF_FLAGS); 1955 if (!(m->m_hdr.mh_flags & (M_PKTHDR | M_EXT))) 1956 log(LOG_DEBUG, "M_dat.M_databuf = %p\n", 1957 (void *)m->M_dat.M_databuf); 1958 else { 1959 if (m->m_hdr.mh_flags & M_PKTHDR) { 1960 log(LOG_DEBUG, "M_dat.MH.MH_pkthdr.len = %d\n", 1961 m->M_dat.MH.MH_pkthdr.len); 1962 log(LOG_DEBUG, 1963 "M_dat.MH.MH_pkthdr.rcvif = %p\n", 1964 (void *)m->M_dat.MH.MH_pkthdr.rcvif); 1965 if (!(m->m_hdr.mh_flags & M_EXT)) 1966 log(LOG_DEBUG, 1967 "M_dat.MH.MH_dat.MH_databuf = %p\n", 1968 (void *)m->M_dat.MH.MH_dat.MH_databuf); 1969 } 1970 if (m->m_hdr.mh_flags & M_EXT) { 1971 log(LOG_DEBUG, 1972 "M_dat.MH.MH_dat.MH_ext.ext_buff %p\n", 1973 (void *)m->M_dat.MH.MH_dat.MH_ext.ext_buf); 1974 log(LOG_DEBUG, 1975 "M_dat.MH.MH_dat.MH_ext.ext_free %p\n", 1976 (void *)m->M_dat.MH.MH_dat.MH_ext.ext_free); 1977 log(LOG_DEBUG, 1978 "M_dat.MH.MH_dat.MH_ext.ext_size %d\n", 1979 m->M_dat.MH.MH_dat.MH_ext.ext_size); 1980 } 1981 } 1982 } while ((m = m->m_next) != NULL); 1983 } 1984 #endif
Cache object: ba5f24ad54d59fd03a41bea7e75ffd7e
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]