FreeBSD/Linux Kernel Cross Reference
sys/i386/isa/if_lnc.c
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
|