2 * Copyright (c) 1994-2000
3 * Paul Richards. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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
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. The name Paul Richards may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
18 * THIS SOFTWARE IS PROVIDED BY PAUL RICHARDS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL PAUL RICHARDS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39 * This driver will need bounce buffer support when dma'ing to mbufs above the
42 * Check all the XXX comments -- some of them are just things I've left
43 * unfinished rather than "difficult" problems that were hacked around.
47 * Check how all the arpcom flags get set and used.
49 * Re-inline and re-static all routines after debugging.
51 * Remember to assign iobase in SHMEM probe routines.
53 * Replace all occurences of LANCE-controller-card etc in prints by the name
54 * strings of the appropriate type -- nifty window dressing
56 * Add DEPCA support -- mostly done.
65 /* Some defines that should really be in generic locations */
67 #define MULTICAST_FILTER_LEN 8
69 #include <sys/param.h>
70 #include <sys/systm.h>
72 #include <sys/sockio.h>
73 #include <sys/malloc.h>
75 #include <sys/socket.h>
76 #include <sys/syslog.h>
78 #include <net/ethernet.h>
80 #include <net/if_dl.h>
81 #include <net/if_types.h>
83 #include <netinet/in.h>
84 #include <netinet/if_ether.h>
90 #include <net/bridge.h>
94 #include <machine/clock.h>
96 #include <machine/md_var.h>
98 #include <i386/isa/isa_device.h>
99 #include <i386/isa/if_lnc.h>
102 struct arpcom arpcom; /* see ../../net/if_arp.h */
103 struct nic_info nic; /* NIC specific info */
105 struct host_ring_entry *recv_ring; /* start of alloc'd mem */
108 struct host_ring_entry *trans_ring;
110 struct init_block *init_block; /* Initialisation block */
111 int pending_transmits; /* No. of transmit descriptors in use */
125 static struct lnc_softc lnc_softc[NLNC];
127 static char const * const nic_ident[] = {
132 "CNET98S", /* PC-98 */
135 static char const * const ic_ident[] = {
150 static void lnc_setladrf __P((struct lnc_softc *sc));
151 static void lnc_stop __P((struct lnc_softc *sc));
152 static void lnc_reset __P((struct lnc_softc *sc));
153 static void lnc_free_mbufs __P((struct lnc_softc *sc));
154 static __inline int alloc_mbuf_cluster __P((struct lnc_softc *sc,
155 struct host_ring_entry *desc));
156 static __inline struct mbuf *chain_mbufs __P((struct lnc_softc *sc,
159 static __inline struct mbuf *mbuf_packet __P((struct lnc_softc *sc,
162 static __inline void lnc_rint __P((struct lnc_softc *sc));
163 static __inline void lnc_tint __P((struct lnc_softc *sc));
164 static int lnc_probe __P((struct isa_device *isa_dev));
166 static int cnet98s_probe __P((struct lnc_softc *sc, unsigned iobase));
168 static int ne2100_probe __P((struct lnc_softc *sc, unsigned iobase));
169 static int bicc_probe __P((struct lnc_softc *sc, unsigned iobase));
170 static int dec_macaddr_extract __P((u_char ring[], struct lnc_softc *sc));
171 static int depca_probe __P((struct lnc_softc *sc, unsigned iobase));
172 static int lance_probe __P((struct lnc_softc *sc));
173 static int pcnet_probe __P((struct lnc_softc *sc));
174 static int lnc_attach_sc __P((struct lnc_softc *sc, int unit));
175 static int lnc_attach __P((struct isa_device *isa_dev));
176 static void lnc_init __P((void *));
177 static ointhand2_t lncintr;
178 static __inline int mbuf_to_buffer __P((struct mbuf *m, char *buffer));
179 static __inline struct mbuf *chain_to_cluster __P((struct mbuf *m));
180 static void lnc_start __P((struct ifnet *ifp));
181 static int lnc_ioctl __P((struct ifnet *ifp, u_long command, caddr_t data));
182 static void lnc_watchdog __P((struct ifnet *ifp));
184 void lnc_dump_state __P((struct lnc_softc *sc));
185 void mbuf_dump_chain __P((struct mbuf *m));
189 void *lnc_attach_ne2100_pci __P((int unit, unsigned iobase));
191 void lncintr_sc __P((struct lnc_softc *sc));
193 struct isa_driver lncdriver = {lnc_probe, lnc_attach, "lnc"};
196 write_csr(struct lnc_softc *sc, u_short port, u_short val)
202 static __inline u_short
203 read_csr(struct lnc_softc *sc, u_short port)
206 return (inw(sc->rdp));
210 write_bcr(struct lnc_softc *sc, u_short port, u_short val)
216 static __inline u_short
217 read_bcr(struct lnc_softc *sc, u_short port)
220 return (inw(sc->bdp));
223 static __inline u_long
224 ether_crc(const u_char *ether_addr)
226 #define POLYNOMIAL 0xEDB88320UL
228 u_int crc = 0xFFFFFFFFUL;
230 for (i = 0; i < ETHER_ADDR_LEN; i++) {
231 addr = *ether_addr++;
232 for (j = 0; j < MULTICAST_FILTER_LEN; j++) {
233 crc = (crc >> 1) ^ (((crc ^ addr) & 1) ? POLYNOMIAL : 0);
242 * Set up the logical address filter for multicast packets
245 lnc_setladrf(struct lnc_softc *sc)
247 struct ifnet *ifp = &sc->arpcom.ac_if;
248 struct ifmultiaddr *ifma;
252 if (sc->flags & IFF_ALLMULTI) {
253 for (i=0; i < MULTICAST_FILTER_LEN; i++)
254 sc->init_block->ladrf[i] = 0xFF;
259 * For each multicast address, calculate a crc for that address and
260 * then use the high order 6 bits of the crc as a hash code where
261 * bits 3-5 select the byte of the address filter and bits 0-2 select
262 * the bit within that byte.
265 bzero(sc->init_block->ladrf, MULTICAST_FILTER_LEN);
266 for (ifma = ifp->if_multiaddrs.lh_first; ifma;
267 ifma = ifma->ifma_link.le_next) {
268 if (ifma->ifma_addr->sa_family != AF_LINK)
271 index = ether_crc(LLADDR((struct sockaddr_dl *)ifma->ifma_addr))
273 sc->init_block->ladrf[index >> 3] |= 1 << (index & 7);
278 lnc_stop(struct lnc_softc *sc)
280 write_csr(sc, CSR0, STOP);
284 lnc_reset(struct lnc_softc *sc)
290 lnc_free_mbufs(struct lnc_softc *sc)
295 * We rely on other routines to keep the buff.mbuf field valid. If
296 * it's not NULL then we assume it points to an allocated mbuf.
299 for (i = 0; i < NDESC(sc->nrdre); i++)
300 if ((sc->recv_ring + i)->buff.mbuf)
301 m_free((sc->recv_ring + i)->buff.mbuf);
303 for (i = 0; i < NDESC(sc->ntdre); i++)
304 if ((sc->trans_ring + i)->buff.mbuf)
305 m_free((sc->trans_ring + i)->buff.mbuf);
312 alloc_mbuf_cluster(struct lnc_softc *sc, struct host_ring_entry *desc)
314 register struct mds *md = desc->md;
318 /* Try and get cluster off local cache */
319 if (sc->mbuf_count) {
322 sc->mbufs = m->m_next;
323 /* XXX m->m_data = m->m_ext.ext_buf;*/
325 MGET(m, M_DONTWAIT, MT_DATA);
328 MCLGET(m, M_DONTWAIT);
329 if (!m->m_ext.ext_buf) {
336 addr = kvtop(m->m_data);
338 md->md1= ((addr >> 16) & 0xff) | OWN;
339 md->md2 = -(short)(MCLBYTES - sizeof(struct pkthdr));
344 static __inline struct mbuf *
345 chain_mbufs(struct lnc_softc *sc, int start_of_packet, int pkt_len)
347 struct mbuf *head, *m;
348 struct host_ring_entry *desc;
351 * Turn head into a pkthdr mbuf --
352 * assumes a pkthdr type mbuf was
353 * allocated to the descriptor
357 desc = sc->recv_ring + start_of_packet;
359 head = desc->buff.mbuf;
360 head->m_flags |= M_PKTHDR;
365 m->m_len = min((MCLBYTES - sizeof(struct pkthdr)), pkt_len);
367 if (alloc_mbuf_cluster(sc, desc))
368 return((struct mbuf *)NULL);
369 INC_MD_PTR(start_of_packet, sc->nrdre)
370 desc = sc->recv_ring + start_of_packet;
371 m->m_next = desc->buff.mbuf;
372 } while (start_of_packet != sc->recv_next);
378 static __inline struct mbuf *
379 mbuf_packet(struct lnc_softc *sc, int start_of_packet, int pkt_len)
382 struct host_ring_entry *start;
383 struct mbuf *head,*m,*m_prev;
384 char *data,*mbuf_data;
388 /* Get a pkthdr mbuf for the start of packet */
389 MGETHDR(head, M_DONTWAIT, MT_DATA);
391 LNCSTATS(drop_packet)
397 start = sc->recv_ring + start_of_packet;
398 /*blen = -(start->md->md2);*/
399 blen = RECVBUFSIZE; /* XXX More PCnet-32 crap */
400 data = start->buff.data;
401 mbuf_data = m->m_data;
403 while (start_of_packet != sc->recv_next) {
405 * If the data left fits in a single buffer then set
406 * blen to the size of the data left.
412 * amount is least of data in current ring buffer and
413 * amount of space left in current mbuf.
415 amount = min(blen, M_TRAILINGSPACE(m));
417 /* mbuf must be empty */
419 MGET(m, M_DONTWAIT, MT_DATA);
424 if (pkt_len >= MINCLSIZE)
425 MCLGET(m, M_DONTWAIT);
428 amount = min(blen, M_TRAILINGSPACE(m));
429 mbuf_data = m->m_data;
431 bcopy(data, mbuf_data, amount);
439 start->md->md1 &= HADR;
440 start->md->md1 |= OWN;
441 start->md->md2 = -RECVBUFSIZE; /* XXX - shouldn't be necessary */
442 INC_MD_PTR(start_of_packet, sc->nrdre)
443 start = sc->recv_ring + start_of_packet;
444 data = start->buff.data;
445 /*blen = -(start->md->md2);*/
446 blen = RECVBUFSIZE; /* XXX More PCnet-32 crap */
454 lnc_rint(struct lnc_softc *sc)
456 struct host_ring_entry *next, *start;
459 struct ether_header *eh;
465 * The LANCE will issue a RINT interrupt when the ownership of the
466 * last buffer of a receive packet has been relinquished by the LANCE.
467 * Therefore, it can be assumed that a complete packet can be found
468 * before hitting buffers that are still owned by the LANCE, if not
469 * then there is a bug in the driver that is causing the descriptors
470 * to get out of sync.
474 if ((sc->recv_ring + sc->recv_next)->md->md1 & OWN) {
475 int unit = sc->arpcom.ac_if.if_unit;
476 log(LOG_ERR, "lnc%d: Receive interrupt with buffer still owned by controller -- Resetting\n", unit);
480 if (!((sc->recv_ring + sc->recv_next)->md->md1 & STP)) {
481 int unit = sc->arpcom.ac_if.if_unit;
482 log(LOG_ERR, "lnc%d: Receive interrupt but not start of packet -- Resetting\n", unit);
489 next = sc->recv_ring + sc->recv_next;
490 while ((flags = next->md->md1) & STP) {
492 /* Make a note of the start of the packet */
493 start_of_packet = sc->recv_next;
496 * Find the end of the packet. Even if not data chaining,
497 * jabber packets can overrun into a second descriptor.
498 * If there is no error, then the ENP flag is set in the last
499 * descriptor of the packet. If there is an error then the ERR
500 * flag will be set in the descriptor where the error occured.
501 * Therefore, to find the last buffer of a packet we search for
505 if (!(flags & (ENP | MDERR))) {
507 INC_MD_PTR(sc->recv_next, sc->nrdre)
508 next = sc->recv_ring + sc->recv_next;
509 flags = next->md->md1;
510 } while (!(flags & (STP | OWN | ENP | MDERR)));
513 int unit = sc->arpcom.ac_if.if_unit;
514 log(LOG_ERR, "lnc%d: Start of packet found before end of previous in receive ring -- Resetting\n", unit);
521 * Looked ahead into a packet still
524 sc->recv_next = start_of_packet;
527 int unit = sc->arpcom.ac_if.if_unit;
528 log(LOG_ERR, "lnc%d: End of received packet not found-- Resetting\n", unit);
535 pkt_len = (next->md->md3 & MCNT) - FCS_LEN;
537 /* Move pointer onto start of next packet */
538 INC_MD_PTR(sc->recv_next, sc->nrdre)
539 next = sc->recv_ring + sc->recv_next;
542 int unit = sc->arpcom.ac_if.if_unit;
545 log(LOG_ERR, "lnc%d: Receive buffer error\n", unit);
548 /* OFLO only valid if ENP is not set */
549 if (!(flags & ENP)) {
551 log(LOG_ERR, "lnc%d: Receive overflow error \n", unit);
553 } else if (flags & ENP) {
554 if ((sc->arpcom.ac_if.if_flags & IFF_PROMISC)==0) {
556 * FRAM and CRC are valid only if ENP
557 * is set and OFLO is not.
561 log(LOG_ERR, "lnc%d: Framing error\n", unit);
563 * FRAM is only set if there's a CRC
564 * error so avoid multiple messages
566 } else if (flags & CRC) {
568 log(LOG_ERR, "lnc%d: Receive CRC error\n", unit);
575 sc->arpcom.ac_if.if_ierrors++;
576 while (start_of_packet != sc->recv_next) {
577 start = sc->recv_ring + start_of_packet;
578 start->md->md2 = -RECVBUFSIZE; /* XXX - shouldn't be necessary */
579 start->md->md1 &= HADR;
580 start->md->md1 |= OWN;
581 INC_MD_PTR(start_of_packet, sc->nrdre)
583 } else { /* Valid packet */
585 sc->arpcom.ac_if.if_ipackets++;
588 if (sc->nic.mem_mode == DMA_MBUF)
589 head = chain_mbufs(sc, start_of_packet, pkt_len);
591 head = mbuf_packet(sc, start_of_packet, pkt_len);
595 * First mbuf in packet holds the
596 * ethernet and packet headers
598 head->m_pkthdr.rcvif = &sc->arpcom.ac_if;
599 head->m_pkthdr.len = pkt_len ;
602 * BPF expects the ether header to be in the first
603 * mbuf of the chain so point eh at the right place
604 * but don't increment the mbuf pointers before
608 eh = (struct ether_header *) head->m_data;
610 if (sc->arpcom.ac_if.if_bpf)
611 bpf_mtap(&sc->arpcom.ac_if, head);
614 struct ifnet *bdg_ifp ;
616 bdg_ifp = bridge_in(head);
617 if (bdg_ifp == BDG_DROP)
620 if (bdg_ifp != BDG_LOCAL)
621 bdg_forward(&head, bdg_ifp);
622 if ( bdg_ifp == BDG_LOCAL ||
623 bdg_ifp == BDG_BCAST ||
624 bdg_ifp == BDG_MCAST )
631 /* Check this packet is really for us */
633 if ((sc->arpcom.ac_if.if_flags & IFF_PROMISC) &&
634 !(eh->ether_dhost[0] & 1) && /* Broadcast and multicast */
635 (bcmp(eh->ether_dhost, sc->arpcom.ac_enaddr,
636 sizeof(eh->ether_dhost))))
643 /* Skip over the ether header */
644 head->m_data += sizeof *eh;
645 head->m_len -= sizeof *eh;
646 head->m_pkthdr.len -= sizeof *eh;
648 ether_input(&sc->arpcom.ac_if, eh, head);
652 int unit = sc->arpcom.ac_if.if_unit;
653 log(LOG_ERR,"lnc%d: Packet dropped, no mbufs\n",unit);
654 LNCSTATS(drop_packet)
662 * At this point all completely received packets have been processed
663 * so clear RINT since any packets that have arrived while we were in
664 * here have been dealt with.
667 outw(sc->rdp, RINT | INEA);
671 lnc_tint(struct lnc_softc *sc)
673 struct host_ring_entry *next, *start;
678 * If the driver is reset in this routine then we return immediately to
679 * the interrupt driver routine. Any interrupts that have occured
680 * since the reset will be dealt with there. sc->trans_next
681 * should point to the start of the first packet that was awaiting
682 * transmission after the last transmit interrupt was dealt with. The
683 * LANCE should have relinquished ownership of that descriptor before
684 * the interrupt. Therefore, sc->trans_next should point to a
685 * descriptor with STP set and OWN cleared. If not then the driver's
686 * pointers are out of sync with the LANCE, which signifies a bug in
687 * the driver. Therefore, the following two checks are really
688 * diagnostic, since if the driver is working correctly they should
693 if ((sc->trans_ring + sc->trans_next)->md->md1 & OWN) {
694 int unit = sc->arpcom.ac_if.if_unit;
695 log(LOG_ERR, "lnc%d: Transmit interrupt with buffer still owned by controller -- Resetting\n", unit);
703 * The LANCE will write the status information for the packet it just
704 * tried to transmit in one of two places. If the packet was
705 * transmitted successfully then the status will be written into the
706 * last descriptor of the packet. If the transmit failed then the
707 * status will be written into the descriptor that was being accessed
708 * when the error occured and all subsequent descriptors in that
709 * packet will have been relinquished by the LANCE.
711 * At this point we know that sc->trans_next points to the start
712 * of a packet that the LANCE has just finished trying to transmit.
713 * We now search for a buffer with either ENP or ERR set.
719 start_of_packet = sc->trans_next;
720 next = sc->trans_ring + sc->trans_next;
723 if (!(next->md->md1 & STP)) {
724 int unit = sc->arpcom.ac_if.if_unit;
725 log(LOG_ERR, "lnc%d: Transmit interrupt but not start of packet -- Resetting\n", unit);
732 * Find end of packet.
735 if (!(next->md->md1 & (ENP | MDERR))) {
737 INC_MD_PTR(sc->trans_next, sc->ntdre)
738 next = sc->trans_ring + sc->trans_next;
739 } while (!(next->md->md1 & (STP | OWN | ENP | MDERR)));
741 if (next->md->md1 & STP) {
742 int unit = sc->arpcom.ac_if.if_unit;
743 log(LOG_ERR, "lnc%d: Start of packet found before end of previous in transmit ring -- Resetting\n", unit);
747 if (next->md->md1 & OWN) {
750 * Looked ahead into a packet still
753 sc->trans_next = start_of_packet;
756 int unit = sc->arpcom.ac_if.if_unit;
757 log(LOG_ERR, "lnc%d: End of transmitted packet not found -- Resetting\n", unit);
764 * Check for ERR first since other flags are irrelevant if an
767 if (next->md->md1 & MDERR) {
769 int unit = sc->arpcom.ac_if.if_unit;
772 sc->arpcom.ac_if.if_oerrors++;
774 if (next->md->md3 & LCOL) {
776 log(LOG_ERR, "lnc%d: Transmit late collision -- Net error?\n", unit);
777 sc->arpcom.ac_if.if_collisions++;
779 * Clear TBUFF since it's not valid when LCOL
782 next->md->md3 &= ~TBUFF;
784 if (next->md->md3 & LCAR) {
786 log(LOG_ERR, "lnc%d: Loss of carrier during transmit -- Net error?\n", unit);
788 if (next->md->md3 & RTRY) {
790 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));
791 sc->arpcom.ac_if.if_collisions += 16;
793 * Clear TBUFF since it's not valid when RTRY
796 next->md->md3 &= ~TBUFF;
799 * TBUFF is only valid if neither LCOL nor RTRY are set.
800 * We need to check UFLO after LCOL and RTRY so that we
801 * know whether or not TBUFF is valid. If either are
802 * set then TBUFF will have been cleared above. A
803 * UFLO error will turn off the transmitter so we
808 if (next->md->md3 & UFLO) {
811 * If an UFLO has occured it's possibly due
814 if (next->md->md3 & TBUFF) {
816 log(LOG_ERR, "lnc%d: Transmit buffer error -- Resetting\n", unit);
818 log(LOG_ERR, "lnc%d: Transmit underflow error -- Resetting\n", unit);
823 INC_MD_PTR(sc->trans_next, sc->ntdre)
824 next = sc->trans_ring + sc->trans_next;
825 } while (!(next->md->md1 & STP) && (sc->trans_next != sc->next_to_send));
829 * Since we check for ERR first then if we get here
830 * the packet was transmitted correctly. There may
831 * still have been non-fatal errors though.
832 * Don't bother checking for DEF, waste of time.
835 sc->arpcom.ac_if.if_opackets++;
837 if (next->md->md1 & MORE) {
839 sc->arpcom.ac_if.if_collisions += 2;
843 * ONE is invalid if LCOL is set. If LCOL was set then
844 * ERR would have also been set and we would have
845 * returned from lnc_tint above. Therefore we can
846 * assume if we arrive here that ONE is valid.
850 if (next->md->md1 & ONE) {
852 sc->arpcom.ac_if.if_collisions++;
854 INC_MD_PTR(sc->trans_next, sc->ntdre)
855 next = sc->trans_ring + sc->trans_next;
859 * Clear descriptors and free any mbufs.
863 start = sc->trans_ring + start_of_packet;
864 start->md->md1 &= HADR;
865 if (sc->nic.mem_mode == DMA_MBUF) {
866 /* Cache clusters on a local queue */
867 if ((start->buff.mbuf->m_flags & M_EXT) && (sc->mbuf_count < MBUF_CACHE_LIMIT)) {
868 if (sc->mbuf_count) {
869 start->buff.mbuf->m_next = sc->mbufs;
870 sc->mbufs = start->buff.mbuf;
872 sc->mbufs = start->buff.mbuf;
874 start->buff.mbuf = 0;
877 MFREE(start->buff.mbuf, junk);
878 start->buff.mbuf = 0;
881 sc->pending_transmits--;
882 INC_MD_PTR(start_of_packet, sc->ntdre)
883 }while (start_of_packet != sc->trans_next);
886 * There's now at least one free descriptor
887 * in the ring so indicate that we can accept
888 * more packets again.
891 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
895 } while (sc->pending_transmits && !(next->md->md1 & OWN));
898 * Clear TINT since we've dealt with all
899 * the completed transmissions.
902 outw(sc->rdp, TINT | INEA);
904 /* XXX only while doing if_is comparisons */
905 if (!(sc->arpcom.ac_if.if_flags & IFF_OACTIVE))
906 lnc_start(&sc->arpcom.ac_if);
911 lnc_probe(struct isa_device * isa_dev)
914 int unit = isa_dev->id_unit;
915 struct lnc_softc *sc = &lnc_softc[unit];
916 unsigned iobase = isa_dev->id_iobase;
920 vsw = inw(isa_dev->id_iobase + PCNET_VSW);
921 printf("Vendor Specific Word = %x\n", vsw);
924 nports = bicc_probe(sc, iobase);
926 nports = ne2100_probe(sc, iobase);
928 nports = depca_probe(sc, iobase);
931 nports = cnet98s_probe(sc, iobase);
937 /* ISA Bus Configuration Registers */
938 /* XXX - Should be in ic/Am7990.h */
939 #define MSRDA 0x0000 /* ISACSR0: Master Mode Read Activity */
940 #define MSWRA 0x0001 /* ISACSR1: Master Mode Write Activity */
941 #define MC 0x0002 /* ISACSR2: Miscellaneous Configuration */
943 #define LED1 0x0005 /* ISACSR5: LED1 Status */
944 #define LED2 0x0006 /* ISACSR6: LED2 Status */
945 #define LED3 0x0007 /* ISACSR7: LED3 Status */
947 #define LED_PSE 0x0080 /* Pulse Stretcher */
948 #define LED_XMTE 0x0010 /* Transmit Status */
949 #define LED_RVPOLE 0x0008 /* Receive Polarity */
950 #define LED_RCVE 0x0004 /* Receive Status */
951 #define LED_JABE 0x0002 /* Jabber */
952 #define LED_COLE 0x0001 /* Collision */
955 cnet98s_probe(struct lnc_softc *sc, unsigned iobase)
960 sc->rap = iobase + CNET98S_RAP;
961 sc->rdp = iobase + CNET98S_RDP;
964 tmp = inw(iobase + CNET98S_RESET);
965 outw(iobase + CNET98S_RESET, tmp);
968 sc->nic.ic = pcnet_probe(sc);
969 if ((sc->nic.ic == UNKNOWN) || (sc->nic.ic > PCnet_32)) {
973 sc->nic.ident = CNET98S;
974 sc->nic.mem_mode = DMA_FIXED;
976 /* XXX - For now just use the defines */
980 /* Extract MAC address from PROM */
981 for (i = 0; i < ETHER_ADDR_LEN; i++) {
982 sc->arpcom.ac_enaddr[i] = inb(iobase + (i * 2));
988 * XXX - Following parameters are Contec C-NET(98)S only.
989 * So, check the Ethernet address here.
991 * Contec uses 00 80 4c ?? ?? ??
993 if (sc->arpcom.ac_enaddr[0] == (u_char)0x00
994 && sc->arpcom.ac_enaddr[1] == (u_char)0x80
995 && sc->arpcom.ac_enaddr[2] == (u_char)0x4c) {
996 outw(sc->rap, MSRDA);
997 outw(iobase + CNET98S_IDP, 0x0006);
998 outw(sc->rap, MSWRA);
999 outw(iobase + CNET98S_IDP, 0x0006);
1002 printf("ISACSR2 = %x\n", inw(iobase + CNET98S_IDP));
1004 outw(sc->rap, LED1);
1005 outw(iobase + CNET98S_IDP, LED_PSE | LED_XMTE);
1006 outw(sc->rap, LED2);
1007 outw(iobase + CNET98S_IDP, LED_PSE | LED_RCVE);
1008 outw(sc->rap, LED3);
1009 outw(iobase + CNET98S_IDP, LED_PSE | LED_COLE);
1012 return (CNET98S_IOSIZE);
1017 ne2100_probe(struct lnc_softc *sc, unsigned iobase)
1021 sc->rap = iobase + PCNET_RAP;
1022 sc->rdp = iobase + PCNET_RDP;
1024 sc->nic.ic = pcnet_probe(sc);
1025 if ((sc->nic.ic > 0) && (sc->nic.ic < PCnet_PCI)) {
1026 sc->nic.ident = NE2100;
1027 sc->nic.mem_mode = DMA_FIXED;
1029 /* XXX - For now just use the defines */
1033 /* Extract MAC address from PROM */
1034 for (i = 0; i < ETHER_ADDR_LEN; i++)
1035 sc->arpcom.ac_enaddr[i] = inb(iobase + i);
1036 return (NE2100_IOSIZE);
1043 bicc_probe(struct lnc_softc *sc, unsigned iobase)
1048 * There isn't any way to determine if a NIC is a BICC. Basically, if
1049 * the lance probe succeeds using the i/o addresses of the BICC then
1050 * we assume it's a BICC.
1054 sc->rap = iobase + BICC_RAP;
1055 sc->rdp = iobase + BICC_RDP;
1057 /* I think all these cards us the Am7990 */
1059 if ((sc->nic.ic = lance_probe(sc))) {
1060 sc->nic.ident = BICC;
1061 sc->nic.mem_mode = DMA_FIXED;
1063 /* XXX - For now just use the defines */
1067 /* Extract MAC address from PROM */
1068 for (i = 0; i < ETHER_ADDR_LEN; i++)
1069 sc->arpcom.ac_enaddr[i] = inb(iobase + (i * 2));
1071 return (BICC_IOSIZE);
1078 * I don't have data sheets for the dec cards but it looks like the mac
1079 * address is contained in a 32 byte ring. Each time you read from the port
1080 * you get the next byte in the ring. The mac address is stored after a
1081 * signature so keep searching for the signature first.
1084 dec_macaddr_extract(u_char ring[], struct lnc_softc * sc)
1086 const unsigned char signature[] = {0xff, 0x00, 0x55, 0xaa, 0xff, 0x00, 0x55, 0xaa};
1090 for (i = 0; i < sizeof ring; i++) {
1091 for (j = 0, rindex = i; j < sizeof signature; j++) {
1092 if (ring[rindex] != signature[j])
1094 if (++rindex > sizeof ring)
1097 if (j == sizeof signature) {
1098 for (j = 0, rindex = i; j < ETHER_ADDR_LEN; j++) {
1099 sc->arpcom.ac_enaddr[j] = ring[rindex];
1100 if (++rindex > sizeof ring)
1110 depca_probe(struct lnc_softc *sc, unsigned iobase)
1113 unsigned char maddr_ring[DEPCA_ADDR_ROM_SIZE];
1115 sc->rap = iobase + DEPCA_RAP;
1116 sc->rdp = iobase + DEPCA_RDP;
1118 if ((sc->nic.ic = lance_probe(sc))) {
1119 sc->nic.ident = DEPCA;
1120 sc->nic.mem_mode = SHMEM;
1122 /* Extract MAC address from PROM */
1123 for (i = 0; i < DEPCA_ADDR_ROM_SIZE; i++)
1124 maddr_ring[i] = inb(iobase + DEPCA_ADP);
1125 if (dec_macaddr_extract(maddr_ring, sc)) {
1126 return (DEPCA_IOSIZE);
1133 lance_probe(struct lnc_softc *sc)
1135 write_csr(sc, CSR0, STOP);
1137 if ((inw(sc->rdp) & STOP) && !(read_csr(sc, CSR3))) {
1139 * Check to see if it's a C-LANCE. For the LANCE the INEA bit
1140 * cannot be set while the STOP bit is. This restriction is
1141 * removed for the C-LANCE.
1143 write_csr(sc, CSR0, INEA);
1144 if (read_csr(sc, CSR0) & INEA)
1153 pcnet_probe(struct lnc_softc *sc)
1159 * The PCnet family don't reset the RAP register on reset so we'll
1160 * have to write during the probe :-) It does have an ID register
1161 * though so the probe is just a matter of reading it.
1164 if ((type = lance_probe(sc))) {
1165 chip_id = read_csr(sc, CSR89);
1167 chip_id |= read_csr(sc, CSR88);
1168 if (chip_id & AMD_MASK) {
1170 switch (chip_id & PART_MASK) {
1174 return (PCnet_ISAplus);
1176 return (PCnet_ISA_II);
1182 return (PCnet_PCI_II);
1184 return (PCnet_FAST);
1186 return (PCnet_FASTplus);
1188 return (PCnet_Home);
1198 lnc_attach_sc(struct lnc_softc *sc, int unit)
1203 * Allocate memory for use by the controller.
1205 * XXX -- the Am7990 and Am79C960 only have 24 address lines and so can
1206 * only access the lower 16Mb of physical memory. For the moment we
1207 * assume that malloc will allocate memory within the lower 16Mb
1208 * range. This is not a very valid assumption but there's nothing
1209 * that can be done about it yet. For shared memory NICs this isn't
1214 lnc_mem_size = ((NDESC(sc->nrdre) + NDESC(sc->ntdre)) *
1215 sizeof(struct host_ring_entry));
1217 if (sc->nic.mem_mode != SHMEM)
1218 lnc_mem_size += sizeof(struct init_block) + (sizeof(struct mds) *
1219 (NDESC(sc->nrdre) + NDESC(sc->ntdre))) +
1222 /* If using DMA to fixed host buffers then allocate memory for them */
1224 if (sc->nic.mem_mode == DMA_FIXED)
1225 lnc_mem_size += (NDESC(sc->nrdre) * RECVBUFSIZE) + (NDESC(sc->ntdre) * TRANSBUFSIZE);
1227 if (sc->nic.mem_mode != SHMEM) {
1228 if (sc->nic.ic < PCnet_32) {
1229 /* ISA based cards */
1230 sc->recv_ring = contigmalloc(lnc_mem_size, M_DEVBUF, M_NOWAIT,
1231 0ul, 0xfffffful, 4ul, 0x1000000);
1233 /* Non-ISA based cards, 32 bit capable */
1236 * For the 32 bit driver we're not fussed where we DMA to
1237 * though it'll still need to be contiguous
1239 sc->recv_ring = malloc(lnc_mem_size, M_DEVBUF, M_NOWAIT);
1242 * For now it still needs to be below 16MB because the
1243 * descriptor's can only hold 16 bit addresses.
1245 sc->recv_ring = contigmalloc(lnc_mem_size, M_DEVBUF, M_NOWAIT,
1246 0ul, 0xfffffful, 4ul, 0x1000000);
1251 if (!sc->recv_ring) {
1252 log(LOG_ERR, "lnc%d: Couldn't allocate memory for NIC\n", unit);
1253 return (0); /* XXX -- attach failed -- not tested in
1254 * calling routines */
1257 /* Set default mode */
1258 sc->nic.mode = NORMAL;
1260 /* Fill in arpcom structure entries */
1262 sc->arpcom.ac_if.if_softc = sc;
1263 sc->arpcom.ac_if.if_name = lncdriver.name;
1264 sc->arpcom.ac_if.if_unit = unit;
1265 sc->arpcom.ac_if.if_mtu = ETHERMTU;
1266 sc->arpcom.ac_if.if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1267 sc->arpcom.ac_if.if_timer = 0;
1268 sc->arpcom.ac_if.if_output = ether_output;
1269 sc->arpcom.ac_if.if_start = lnc_start;
1270 sc->arpcom.ac_if.if_ioctl = lnc_ioctl;
1271 sc->arpcom.ac_if.if_watchdog = lnc_watchdog;
1272 sc->arpcom.ac_if.if_init = lnc_init;
1273 sc->arpcom.ac_if.if_type = IFT_ETHER;
1274 sc->arpcom.ac_if.if_addrlen = ETHER_ADDR_LEN;
1275 sc->arpcom.ac_if.if_hdrlen = ETHER_HDR_LEN;
1276 sc->arpcom.ac_if.if_snd.ifq_maxlen = IFQ_MAXLEN;
1279 * XXX -- should check return status of if_attach
1282 if_attach(&sc->arpcom.ac_if);
1283 ether_ifattach(&sc->arpcom.ac_if);
1285 printf("lnc%d: ", unit);
1286 if (sc->nic.ic == LANCE || sc->nic.ic == C_LANCE)
1288 nic_ident[sc->nic.ident], ic_ident[sc->nic.ic]);
1290 printf("%s", ic_ident[sc->nic.ic]);
1291 printf(" address %6D\n", sc->arpcom.ac_enaddr, ":");
1293 bpfattach(&sc->arpcom.ac_if, DLT_EN10MB, sizeof(struct ether_header));
1299 lnc_attach(struct isa_device * isa_dev)
1301 int unit = isa_dev->id_unit;
1302 struct lnc_softc *sc = &lnc_softc[unit];
1305 isa_dev->id_ointr = lncintr;
1306 result = lnc_attach_sc (sc, unit);
1312 * XXX - is it safe to call isa_dmacascade() after if_attach()
1313 * and ether_ifattach() have been called in lnc_attach() ???
1315 if ((sc->nic.mem_mode != SHMEM) &&
1316 (sc->nic.ic < PCnet_32))
1317 isa_dmacascade(isa_dev->id_drq);
1325 lnc_attach_ne2100_pci(int unit, unsigned iobase)
1328 struct lnc_softc *sc = malloc(sizeof *sc, M_DEVBUF, M_NOWAIT);
1331 bzero (sc, sizeof *sc);
1333 sc->rap = iobase + PCNET_RAP;
1334 sc->rdp = iobase + PCNET_RDP;
1335 sc->bdp = iobase + PCNET_BDP;
1337 sc->nic.ic = pcnet_probe(sc);
1338 if (sc->nic.ic >= PCnet_32) {
1339 sc->nic.ident = NE2100;
1340 sc->nic.mem_mode = DMA_FIXED;
1342 /* XXX - For now just use the defines */
1346 /* Extract MAC address from PROM */
1347 for (i = 0; i < ETHER_ADDR_LEN; i++)
1348 sc->arpcom.ac_enaddr[i] = inb(iobase + i);
1350 if (lnc_attach_sc(sc, unit) == 0) {
1368 struct lnc_softc *sc = xsc;
1372 /* Check that interface has valid address */
1374 if (TAILQ_EMPTY(&sc->arpcom.ac_if.if_addrhead)) /* XXX unlikely */
1377 /* Shut down interface */
1381 sc->arpcom.ac_if.if_flags |= IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; /* XXX??? */
1384 * This sets up the memory area for the controller. Memory is set up for
1385 * the initialisation block (12 words of contiguous memory starting
1386 * on a word boundary),the transmit and receive ring structures (each
1387 * entry is 4 words long and must start on a quadword boundary) and
1390 * The alignment tests are particularly paranoid.
1396 sc->trans_ring = sc->recv_ring + NDESC(sc->nrdre);
1399 if (sc->nic.mem_mode == SHMEM)
1400 lnc_mem = (char *) sc->nic.iobase;
1402 lnc_mem = (char *) (sc->trans_ring + NDESC(sc->ntdre));
1404 lnc_mem = (char *)(((int)lnc_mem + 1) & ~1);
1405 sc->init_block = (struct init_block *) ((int) lnc_mem & ~1);
1406 lnc_mem = (char *) (sc->init_block + 1);
1407 lnc_mem = (char *)(((int)lnc_mem + 7) & ~7);
1409 /* Initialise pointers to descriptor entries */
1410 for (i = 0; i < NDESC(sc->nrdre); i++) {
1411 (sc->recv_ring + i)->md = (struct mds *) lnc_mem;
1412 lnc_mem += sizeof(struct mds);
1414 for (i = 0; i < NDESC(sc->ntdre); i++) {
1415 (sc->trans_ring + i)->md = (struct mds *) lnc_mem;
1416 lnc_mem += sizeof(struct mds);
1419 /* Initialise the remaining ring entries */
1421 if (sc->nic.mem_mode == DMA_MBUF) {
1426 /* Free previously allocated mbufs */
1427 if (sc->flags & LNC_INITIALISED)
1431 for (i = 0; i < NDESC(sc->nrdre); i++) {
1432 if (alloc_mbuf_cluster(sc, sc->recv_ring+i)) {
1433 log(LOG_ERR, "Initialisation failed -- no mbufs\n");
1439 for (i = 0; i < NDESC(sc->ntdre); i++) {
1440 (sc->trans_ring + i)->buff.mbuf = 0;
1441 (sc->trans_ring + i)->md->md0 = 0;
1442 (sc->trans_ring + i)->md->md1 = 0;
1443 (sc->trans_ring + i)->md->md2 = 0;
1444 (sc->trans_ring + i)->md->md3 = 0;
1447 for (i = 0; i < NDESC(sc->nrdre); i++) {
1448 (sc->recv_ring + i)->md->md0 = kvtop(lnc_mem);
1449 (sc->recv_ring + i)->md->md1 = ((kvtop(lnc_mem) >> 16) & 0xff) | OWN;
1450 (sc->recv_ring + i)->md->md2 = -RECVBUFSIZE;
1451 (sc->recv_ring + i)->md->md3 = 0;
1452 (sc->recv_ring + i)->buff.data = lnc_mem;
1453 lnc_mem += RECVBUFSIZE;
1455 for (i = 0; i < NDESC(sc->ntdre); i++) {
1456 (sc->trans_ring + i)->md->md0 = kvtop(lnc_mem);
1457 (sc->trans_ring + i)->md->md1 = ((kvtop(lnc_mem) >> 16) & 0xff);
1458 (sc->trans_ring + i)->md->md2 = 0;
1459 (sc->trans_ring + i)->md->md3 = 0;
1460 (sc->trans_ring + i)->buff.data = lnc_mem;
1461 lnc_mem += TRANSBUFSIZE;
1465 sc->next_to_send = 0;
1467 /* Set up initialisation block */
1469 sc->init_block->mode = sc->nic.mode;
1471 for (i = 0; i < ETHER_ADDR_LEN; i++)
1472 sc->init_block->padr[i] = sc->arpcom.ac_enaddr[i];
1476 sc->init_block->rdra = kvtop(sc->recv_ring->md);
1477 sc->init_block->rlen = ((kvtop(sc->recv_ring->md) >> 16) & 0xff) | (sc->nrdre << 13);
1478 sc->init_block->tdra = kvtop(sc->trans_ring->md);
1479 sc->init_block->tlen = ((kvtop(sc->trans_ring->md) >> 16) & 0xff) | (sc->ntdre << 13);
1482 /* Set flags to show that the memory area is valid */
1483 sc->flags |= LNC_INITIALISED;
1485 sc->pending_transmits = 0;
1487 /* Give the LANCE the physical address of the initialisation block */
1489 if (sc->nic.ic == PCnet_Home) {
1491 /* Set PHY_SEL to HomeRun */
1492 media = read_bcr(sc, BCR49);
1495 write_bcr(sc, BCR49, media);
1498 write_csr(sc, CSR1, kvtop(sc->init_block));
1499 write_csr(sc, CSR2, (kvtop(sc->init_block) >> 16) & 0xff);
1502 * Depending on which controller this is, CSR3 has different meanings.
1503 * For the Am7990 it controls DMA operations, for the Am79C960 it
1504 * controls interrupt masks and transmitter algorithms. In either
1505 * case, none of the flags are set.
1509 write_csr(sc, CSR3, 0);
1511 /* Let's see if it starts */
1513 write_csr(sc, CSR0, INIT);
1514 for (i = 0; i < 1000; i++)
1515 if (read_csr(sc, CSR0) & IDON)
1519 * Now that the initialisation is complete there's no reason to
1520 * access anything except CSR0, so we leave RAP pointing there
1521 * so we can just access RDP from now on, saving an outw each
1525 if (read_csr(sc, CSR0) & IDON) {
1527 * Enable interrupts, start the LANCE, mark the interface as
1528 * running and transmit any pending packets.
1530 write_csr(sc, CSR0, STRT | INEA);
1531 sc->arpcom.ac_if.if_flags |= IFF_RUNNING;
1532 sc->arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
1533 lnc_start(&sc->arpcom.ac_if);
1535 log(LOG_ERR, "lnc%d: Initialisation failed\n",
1536 sc->arpcom.ac_if.if_unit);
1542 * The interrupt flag (INTR) will be set and provided that the interrupt enable
1543 * flag (INEA) is also set, the interrupt pin will be driven low when any of
1544 * the following occur:
1546 * 1) Completion of the initialisation routine (IDON). 2) The reception of a
1547 * packet (RINT). 3) The transmission of a packet (TINT). 4) A transmitter
1548 * timeout error (BABL). 5) A missed packet (MISS). 6) A memory error (MERR).
1550 * The interrupt flag is cleared when all of the above conditions are cleared.
1552 * If the driver is reset from this routine then it first checks to see if any
1553 * interrupts have ocurred since the reset and handles them before returning.
1554 * This is because the NIC may signify a pending interrupt in CSR0 using the
1555 * INTR flag even if a hardware interrupt is currently inhibited (at least I
1556 * think it does from reading the data sheets). We may as well deal with
1557 * these pending interrupts now rather than get the overhead of another
1558 * hardware interrupt immediately upon returning from the interrupt handler.
1563 lncintr_sc(struct lnc_softc *sc)
1565 int unit = sc->arpcom.ac_if.if_unit;
1569 * INEA is the only bit that can be cleared by writing a 0 to it so
1570 * we have to include it in any writes that clear other flags.
1573 while ((csr0 = inw(sc->rdp)) & INTR) {
1576 * Clear interrupt flags early to avoid race conditions. The
1577 * controller can still set these flags even while we're in
1578 * this interrupt routine. If the flag is still set from the
1579 * event that caused this interrupt any new events will
1583 /* outw(sc->rdp, IDON | CERR | BABL | MISS | MERR | RINT | TINT | INEA); */
1584 outw(sc->rdp, csr0);
1586 /* We don't do anything with the IDON flag */
1590 log(LOG_ERR, "lnc%d: Heartbeat error -- SQE test failed\n", unit);
1594 log(LOG_ERR, "lnc%d: Babble error - more than 1519 bytes transmitted\n", unit);
1596 sc->arpcom.ac_if.if_oerrors++;
1599 log(LOG_ERR, "lnc%d: Missed packet -- no receive buffer\n", unit);
1601 sc->arpcom.ac_if.if_ierrors++;
1604 log(LOG_ERR, "lnc%d: Memory error -- Resetting\n", unit);
1616 sc->arpcom.ac_if.if_timer = 0;
1621 * If there's room in the transmit descriptor ring then queue
1622 * some more transmit packets.
1625 if (!(sc->arpcom.ac_if.if_flags & IFF_OACTIVE))
1626 lnc_start(&sc->arpcom.ac_if);
1633 struct lnc_softc *sc = &lnc_softc[unit];
1638 mbuf_to_buffer(struct mbuf *m, char *buffer)
1643 for( ; m; m = m->m_next) {
1644 bcopy(mtod(m, caddr_t), buffer, m->m_len);
1652 static __inline struct mbuf *
1653 chain_to_cluster(struct mbuf *m)
1657 MGET(new, M_DONTWAIT, MT_DATA);
1659 MCLGET(new, M_DONTWAIT);
1660 if (new->m_ext.ext_buf) {
1661 new->m_len = mbuf_to_buffer(m, new->m_data);
1671 * IFF_OACTIVE and IFF_RUNNING are checked in ether_output so it's redundant
1672 * to check them again since we wouldn't have got here if they were not
1673 * appropriately set. This is also called from lnc_init and lncintr but the
1674 * flags should be ok at those points too.
1678 lnc_start(struct ifnet *ifp)
1681 struct lnc_softc *sc = ifp->if_softc;
1682 struct host_ring_entry *desc;
1685 struct mbuf *head, *m;
1688 int no_entries_needed;
1692 IF_DEQUEUE(&sc->arpcom.ac_if.if_snd, head);
1696 if (sc->nic.mem_mode == DMA_MBUF) {
1698 no_entries_needed = 0;
1699 for (m=head; m; m = m->m_next)
1700 no_entries_needed++;
1703 * We try and avoid bcopy as much as possible
1704 * but there are two cases when we use it.
1706 * 1) If there are not enough free entries in the ring
1707 * to hold each mbuf in the chain then compact the
1708 * chain into a single cluster.
1710 * 2) The Am7990 and Am79C90 must not have less than
1711 * 100 bytes in the first descriptor of a chained
1712 * packet so it's necessary to shuffle the mbuf
1713 * contents to ensure this.
1717 if (no_entries_needed > (NDESC(sc->ntdre) - sc->pending_transmits)) {
1718 if (!(head = chain_to_cluster(head))) {
1719 log(LOG_ERR, "lnc%d: Couldn't get mbuf for transmit packet -- Resetting \n ",ifp->if_unit);
1723 } else if ((sc->nic.ic == LANCE) || (sc->nic.ic == C_LANCE)) {
1724 if ((head->m_len < 100) && (head->m_next)) {
1725 len = 100 - head->m_len;
1726 if (M_TRAILINGSPACE(head) < len) {
1728 * Move data to start of data
1729 * area. We assume the first
1730 * mbuf has a packet header
1731 * and is not a cluster.
1733 bcopy((caddr_t)head->m_data, (caddr_t)head->m_pktdat, head->m_len);
1734 head->m_data = head->m_pktdat;
1737 while (m && (len > 0)) {
1738 chunk = min(len, m->m_len);
1739 bcopy(mtod(m, caddr_t), mtod(head, caddr_t) + head->m_len, chunk);
1741 head->m_len += chunk;
1744 if (m->m_len <= 0) {
1745 MFREE(m, head->m_next);
1752 tmp = sc->next_to_send;
1755 * On entering this loop we know that tmp points to a
1756 * descriptor with a clear OWN bit.
1759 desc = sc->trans_ring + tmp;
1760 len = ETHER_MIN_LEN;
1761 for (m = head; m; m = m->m_next) {
1762 desc->buff.mbuf = m;
1763 addr = kvtop(m->m_data);
1764 desc->md->md0 = addr;
1765 desc->md->md1 = ((addr >> 16) & 0xff);
1767 desc->md->md2 = -m->m_len;
1768 sc->pending_transmits++;
1771 INC_MD_PTR(tmp, sc->ntdre)
1772 desc = sc->trans_ring + tmp;
1775 end_of_packet = tmp;
1776 DEC_MD_PTR(tmp, sc->ntdre)
1777 desc = sc->trans_ring + tmp;
1778 desc->md->md1 |= ENP;
1781 desc->md->md2 -= len;
1784 * Set OWN bits in reverse order, otherwise the Lance
1785 * could start sending the packet before all the
1786 * buffers have been relinquished by the host.
1789 while (tmp != sc->next_to_send) {
1790 desc->md->md1 |= OWN;
1791 DEC_MD_PTR(tmp, sc->ntdre)
1792 desc = sc->trans_ring + tmp;
1794 sc->next_to_send = end_of_packet;
1795 desc->md->md1 |= STP | OWN;
1797 sc->pending_transmits++;
1798 desc = sc->trans_ring + sc->next_to_send;
1799 len = mbuf_to_buffer(head, desc->buff.data);
1801 desc->md->md2 = -max(len, ETHER_MIN_LEN - ETHER_CRC_LEN);
1802 desc->md->md1 |= OWN | STP | ENP;
1803 INC_MD_PTR(sc->next_to_send, sc->ntdre)
1806 /* Force an immediate poll of the transmit ring */
1807 outw(sc->rdp, TDMD | INEA);
1810 * Set a timer so if the buggy Am7990.h shuts
1811 * down we can wake it up.
1816 if (sc->arpcom.ac_if.if_bpf)
1817 bpf_mtap(&sc->arpcom.ac_if, head);
1819 if (sc->nic.mem_mode != DMA_MBUF)
1822 } while (sc->pending_transmits < NDESC(sc->ntdre));
1825 * Transmit ring is full so set IFF_OACTIVE
1826 * since we can't buffer any more packets.
1829 sc->arpcom.ac_if.if_flags |= IFF_OACTIVE;
1830 LNCSTATS(trans_ring_full)
1834 lnc_ioctl(struct ifnet * ifp, u_long command, caddr_t data)
1837 struct lnc_softc *sc = ifp->if_softc;
1846 error = ether_ioctl(ifp, command, data);
1851 if (ifp->if_flags & IFF_DEBUG)
1856 if (ifp->if_flags & IFF_PROMISC) {
1857 if (!(sc->nic.mode & PROM)) {
1858 sc->nic.mode |= PROM;
1861 } else if (sc->nic.mode & PROM) {
1862 sc->nic.mode &= ~PROM;
1866 if ((ifp->if_flags & IFF_ALLMULTI) &&
1867 !(sc->flags & LNC_ALLMULTI)) {
1868 sc->flags |= LNC_ALLMULTI;
1870 } else if (!(ifp->if_flags & IFF_ALLMULTI) &&
1871 (sc->flags & LNC_ALLMULTI)) {
1872 sc->flags &= ~LNC_ALLMULTI;
1876 if ((ifp->if_flags & IFF_UP) == 0 &&
1877 (ifp->if_flags & IFF_RUNNING) != 0) {
1879 * If interface is marked down and it is running,
1883 ifp->if_flags &= ~IFF_RUNNING;
1884 } else if ((ifp->if_flags & IFF_UP) != 0 &&
1885 (ifp->if_flags & IFF_RUNNING) == 0) {
1887 * If interface is marked up and it is stopped, then
1906 lnc_watchdog(struct ifnet *ifp)
1908 log(LOG_ERR, "lnc%d: Device timeout -- Resetting\n", ifp->if_unit);
1910 lnc_reset(ifp->if_softc);
1915 lnc_dump_state(struct lnc_softc *sc)
1919 printf("\nDriver/NIC [%d] state dump\n", sc->arpcom.ac_if.if_unit);
1920 printf("Memory access mode: %b\n", sc->nic.mem_mode, MEM_MODES);
1921 printf("Host memory\n");
1922 printf("-----------\n");
1924 printf("Receive ring: base = %p, next = %p\n",
1925 (void *)sc->recv_ring, (void *)(sc->recv_ring + sc->recv_next));
1926 for (i = 0; i < NDESC(sc->nrdre); i++)
1927 printf("\t%d:%p md = %p buff = %p\n",
1928 i, (void *)(sc->recv_ring + i),
1929 (void *)(sc->recv_ring + i)->md,
1930 (void *)(sc->recv_ring + i)->buff.data);
1932 printf("Transmit ring: base = %p, next = %p\n",
1933 (void *)sc->trans_ring, (void *)(sc->trans_ring + sc->trans_next));
1934 for (i = 0; i < NDESC(sc->ntdre); i++)
1935 printf("\t%d:%p md = %p buff = %p\n",
1936 i, (void *)(sc->trans_ring + i),
1937 (void *)(sc->trans_ring + i)->md,
1938 (void *)(sc->trans_ring + i)->buff.data);
1939 printf("Lance memory (may be on host(DMA) or card(SHMEM))\n");
1940 printf("Init block = %p\n", (void *)sc->init_block);
1941 printf("\tmode = %b rlen:rdra = %x:%x tlen:tdra = %x:%x\n",
1942 sc->init_block->mode, INIT_MODE, sc->init_block->rlen,
1943 sc->init_block->rdra, sc->init_block->tlen, sc->init_block->tdra);
1944 printf("Receive descriptor ring\n");
1945 for (i = 0; i < NDESC(sc->nrdre); i++)
1946 printf("\t%d buffer = 0x%x%x, BCNT = %d,\tMCNT = %u,\tflags = %b\n",
1947 i, ((sc->recv_ring + i)->md->md1 & HADR),
1948 (sc->recv_ring + i)->md->md0,
1949 -(short) (sc->recv_ring + i)->md->md2,
1950 (sc->recv_ring + i)->md->md3,
1951 (((sc->recv_ring + i)->md->md1 & ~HADR) >> 8), RECV_MD1);
1952 printf("Transmit descriptor ring\n");
1953 for (i = 0; i < NDESC(sc->ntdre); i++)
1954 printf("\t%d buffer = 0x%x%x, BCNT = %d,\tflags = %b %b\n",
1955 i, ((sc->trans_ring + i)->md->md1 & HADR),
1956 (sc->trans_ring + i)->md->md0,
1957 -(short) (sc->trans_ring + i)->md->md2,
1958 ((sc->trans_ring + i)->md->md1 >> 8), TRANS_MD1,
1959 ((sc->trans_ring + i)->md->md3 >> 10), TRANS_MD3);
1960 printf("\nnext_to_send = %x\n", sc->next_to_send);
1961 printf("\n CSR0 = %b CSR1 = %x CSR2 = %x CSR3 = %x\n\n",
1962 read_csr(sc, CSR0), CSR0_FLAGS, read_csr(sc, CSR1),
1963 read_csr(sc, CSR2), read_csr(sc, CSR3));
1965 /* Set RAP back to CSR0 */
1966 outw(sc->rap, CSR0);
1970 mbuf_dump_chain(struct mbuf * m)
1973 #define MBUF_FLAGS \
1974 "\20\1M_EXT\2M_PKTHDR\3M_EOR\4UNKNOWN\5M_BCAST\6M_MCAST"
1977 log(LOG_DEBUG, "m == NULL\n");
1979 log(LOG_DEBUG, "m = %p\n", (void *)m);
1980 log(LOG_DEBUG, "m_hdr.mh_next = %p\n",
1981 (void *)m->m_hdr.mh_next);
1982 log(LOG_DEBUG, "m_hdr.mh_nextpkt = %p\n",
1983 (void *)m->m_hdr.mh_nextpkt);
1984 log(LOG_DEBUG, "m_hdr.mh_len = %d\n", m->m_hdr.mh_len);
1985 log(LOG_DEBUG, "m_hdr.mh_data = %p\n",
1986 (void *)m->m_hdr.mh_data);
1987 log(LOG_DEBUG, "m_hdr.mh_type = %d\n", m->m_hdr.mh_type);
1988 log(LOG_DEBUG, "m_hdr.mh_flags = %b\n", m->m_hdr.mh_flags,
1990 if (!(m->m_hdr.mh_flags & (M_PKTHDR | M_EXT)))
1991 log(LOG_DEBUG, "M_dat.M_databuf = %p\n",
1992 (void *)m->M_dat.M_databuf);
1994 if (m->m_hdr.mh_flags & M_PKTHDR) {
1995 log(LOG_DEBUG, "M_dat.MH.MH_pkthdr.len = %d\n",
1996 m->M_dat.MH.MH_pkthdr.len);
1998 "M_dat.MH.MH_pkthdr.rcvif = %p\n",
1999 (void *)m->M_dat.MH.MH_pkthdr.rcvif);
2000 if (!(m->m_hdr.mh_flags & M_EXT))
2002 "M_dat.MH.MH_dat.MH_databuf = %p\n",
2003 (void *)m->M_dat.MH.MH_dat.MH_databuf);
2005 if (m->m_hdr.mh_flags & M_EXT) {
2007 "M_dat.MH.MH_dat.MH_ext.ext_buff %p\n",
2008 (void *)m->M_dat.MH.MH_dat.MH_ext.ext_buf);
2010 "M_dat.MH.MH_dat.MH_ext.ext_free %p\n",
2011 (void *)m->M_dat.MH.MH_dat.MH_ext.ext_free);
2013 "M_dat.MH.MH_dat.MH_ext.ext_size %d\n",
2014 m->M_dat.MH.MH_dat.MH_ext.ext_size);
2017 } while ((m = m->m_next) != NULL);