8e78b2dbe7f955a34562f86c229fa05d092c74a3
[dragonfly.git] / sys / dev / netif / le / if_le.c
1 /*-
2  * Copyright (c) 1994 Matt Thomas (thomas@lkg.dec.com)
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. The name of the author may not be used to endorse or promote products
11  *    derived from this software withough specific prior written permission
12  *
13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  *
24  * $FreeBSD: src/sys/i386/isa/if_le.c,v 1.56.2.4 2002/06/05 23:24:10 paul Exp $
25  * $DragonFly: src/sys/dev/netif/le/if_le.c,v 1.25 2005/06/14 15:11:23 joerg Exp $
26  */
27
28 /*
29  * DEC EtherWORKS 2 Ethernet Controllers
30  * DEC EtherWORKS 3 Ethernet Controllers
31  *
32  * Written by Matt Thomas
33  * BPF support code stolen directly from if_ec.c
34  *
35  *   This driver supports the DEPCA, DE100, DE101, DE200, DE201,
36  *   DE2002, DE203, DE204, DE205, and DE422 cards.
37  */
38
39 #include "use_le.h"
40 #include "opt_inet.h"
41 #include "opt_ipx.h"
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/conf.h>
46 #include <sys/mbuf.h>
47 #include <sys/socket.h>
48 #include <sys/sockio.h>
49 #include <sys/thread2.h>
50 #include <sys/malloc.h>
51 #include <sys/linker_set.h>
52 #include <sys/module.h>
53
54 #include <net/ethernet.h>
55 #include <net/if.h>
56 #include <net/ifq_var.h>
57 #include <net/if_types.h>
58 #include <net/if_dl.h>
59
60 #include <netinet/in.h>
61 #include <netinet/if_ether.h>
62
63 #include <bus/isa/i386/isa_device.h>
64 #include <i386/isa/icu.h>
65
66 #include <vm/vm.h>
67 #include <vm/pmap.h>
68
69 #include <net/bpf.h>
70
71 typedef u_short le_mcbits_t;
72 #define LE_MC_NBPW_LOG2         4
73 #define LE_MC_NBPW              (1 << LE_MC_NBPW_LOG2)
74
75 struct le_softc;
76
77 struct le_board {
78     int (*bd_probe)(struct le_softc *sc, const struct le_board *bd, int *msize);
79 };
80
81 /*
82  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
83  *
84  * Start of DEC EtherWORKS III (LEMAC) dependent structures
85  *
86  */
87 #include <i386/isa/ic/lemac.h>          /* Include LEMAC definitions */
88
89 DECLARE_DUMMY_MODULE(if_le);
90
91 static int lemac_probe(struct le_softc *sc, const struct le_board *bd, int *msize);
92
93 struct le_lemac_info {
94     u_int lemac__lastpage;              /* last 2K page */
95     u_int lemac__memmode;               /* Are we in 2K, 32K, or 64K mode */
96     u_int lemac__membase;               /* Physical address of start of RAM */
97     u_int lemac__txctl;                 /* Transmit Control Byte */
98     u_int lemac__txmax;                 /* Maximum # of outstanding transmits */
99     le_mcbits_t lemac__mctbl[LEMAC_MCTBL_SIZE/sizeof(le_mcbits_t)];
100                                         /* local copy of multicast table */
101     u_char lemac__eeprom[LEMAC_EEP_SIZE]; /* local copy eeprom */
102     char lemac__prodname[LEMAC_EEP_PRDNMSZ+1]; /* prodname name */
103 #define lemac_lastpage          le_un.un_lemac.lemac__lastpage
104 #define lemac_memmode           le_un.un_lemac.lemac__memmode
105 #define lemac_membase           le_un.un_lemac.lemac__membase
106 #define lemac_txctl             le_un.un_lemac.lemac__txctl
107 #define lemac_txmax             le_un.un_lemac.lemac__txmax
108 #define lemac_mctbl             le_un.un_lemac.lemac__mctbl
109 #define lemac_eeprom            le_un.un_lemac.lemac__eeprom
110 #define lemac_prodname          le_un.un_lemac.lemac__prodname
111 };
112
113 /*
114  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
115  *
116  * Start of DEC EtherWORKS II (LANCE) dependent structures
117  *
118  */
119
120 #include <i386/isa/ic/am7990.h>
121
122 #ifndef LN_DOSTATS
123 #define LN_DOSTATS      1
124 #endif
125
126 static int depca_probe(struct le_softc *sc, const struct le_board *bd, int *msize);
127
128 typedef struct lance_descinfo lance_descinfo_t;
129 typedef struct lance_ring lance_ring_t;
130
131 typedef unsigned lance_addr_t;
132
133 struct lance_descinfo {
134     caddr_t di_addr;                    /* address of descriptor */
135     lance_addr_t di_bufaddr;            /* LANCE address of buffer owned by descriptor */
136     unsigned di_buflen;                 /* size of buffer owned by descriptor */
137     struct mbuf *di_mbuf;               /* mbuf being transmitted/received */
138 };
139
140 struct lance_ring {
141     lance_descinfo_t *ri_first;         /* Pointer to first descriptor in ring */
142     lance_descinfo_t *ri_last;          /* Pointer to last + 1 descriptor in ring */
143     lance_descinfo_t *ri_nextin;        /* Pointer to next one to be given to HOST */
144     lance_descinfo_t *ri_nextout;       /* Pointer to next one to be given to LANCE */
145     unsigned ri_max;                    /* Size of Ring - 1 */
146     unsigned ri_free;                   /* Number of free rings entires (owned by HOST) */
147     lance_addr_t ri_heap;                       /* Start of RAM for this ring */
148     lance_addr_t ri_heapend;            /* End + 1 of RAM for this ring */
149     lance_addr_t ri_outptr;                     /* Pointer to first output byte */
150     unsigned ri_outsize;                /* Space remaining for output */
151 };
152
153 struct le_lance_info {
154     unsigned lance__csr1;               /* LANCE Address of init block (low 16) */
155     unsigned lance__csr2;               /* LANCE Address of init block (high 8) */
156     unsigned lance__csr3;               /* Copy of CSR3 */
157     unsigned lance__rap;                /* IO Port Offset of RAP */
158     unsigned lance__rdp;                /* IO Port Offset of RDP */
159     unsigned lance__ramoffset;          /* Offset to valid LANCE RAM */
160     unsigned lance__ramsize;            /* Amount of RAM shared by LANCE */
161     unsigned lance__rxbufsize;          /* Size of a receive buffer */
162     ln_initb_t lance__initb;            /* local copy of LANCE initblock */
163     ln_initb_t *lance__raminitb;        /* copy to board's LANCE initblock (debugging) */
164     ln_desc_t *lance__ramdesc;          /* copy to board's LANCE descriptors (debugging) */
165     lance_ring_t lance__rxinfo;         /* Receive ring information */
166     lance_ring_t lance__txinfo;         /* Transmit ring information */
167 #define lance_csr1              le_un.un_lance.lance__csr1
168 #define lance_csr2              le_un.un_lance.lance__csr2
169 #define lance_csr3              le_un.un_lance.lance__csr3
170 #define lance_rap               le_un.un_lance.lance__rap
171 #define lance_rdp               le_un.un_lance.lance__rdp
172 #define lance_ramoffset         le_un.un_lance.lance__ramoffset
173 #define lance_ramsize           le_un.un_lance.lance__ramsize
174 #define lance_rxbufsize         le_un.un_lance.lance__rxbufsize
175 #define lance_initb             le_un.un_lance.lance__initb
176 #define lance_raminitb          le_un.un_lance.lance__raminitb
177 #define lance_ramdesc           le_un.un_lance.lance__ramdesc
178 #define lance_rxinfo            le_un.un_lance.lance__rxinfo
179 #define lance_txinfo            le_un.un_lance.lance__txinfo
180 };
181
182 /*
183  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
184  *
185  * Start of Common Code
186  *
187  */
188
189 static void (*le_intrvec[NLE])(struct le_softc *sc);
190
191 /*
192  * Ethernet status, per interface.
193  */
194 struct le_softc {
195     struct arpcom le_ac;                /* Common Ethernet/ARP Structure */
196     void (*if_init) (void *);/* Interface init routine */
197     void (*if_reset) (struct le_softc*);/* Interface reset routine */
198     caddr_t le_membase;                 /* Starting memory address (virtual) */
199     unsigned le_iobase;                 /* Starting I/O base address */
200     unsigned le_irq;                    /* Interrupt Request Value */
201     unsigned le_flags;                  /* local copy of if_flags */
202 #define LE_BRDCSTONLY   0x01000000      /* If only broadcast is enabled */
203     u_int le_mcmask;                    /* bit mask for CRC-32 for multicast hash */
204     le_mcbits_t *le_mctbl;              /* pointer to multicast table */
205     const char *le_prodname;            /* product name DE20x-xx */
206     u_char le_hwaddr[6];                /* local copy of hwaddr */
207     union {
208         struct le_lemac_info un_lemac;  /* LEMAC specific information */
209         struct le_lance_info un_lance;  /* Am7990 specific information */
210     } le_un;
211 };
212 #define le_if           le_ac.ac_if
213
214
215 static int le_probe(struct isa_device *dvp);
216 static int le_attach(struct isa_device *dvp);
217 static ointhand2_t le_intr;
218 static int le_ioctl(struct ifnet *ifp, u_long command, caddr_t data,
219                     struct ucred *cr);
220 static void le_input(struct le_softc *sc, caddr_t seg1, size_t total_len,
221                      size_t len2, caddr_t seg2);
222 static void le_multi_filter(struct le_softc *sc);
223 static void le_multi_op(struct le_softc *sc, const u_char *mca, int oper_flg);
224 static int le_read_macaddr(struct le_softc *sc, int ioreg, int skippat);
225
226 static struct le_softc le_softc[NLE];
227
228 static const struct le_board le_boards[] = {
229     { lemac_probe },                    /* DE20[345] */
230     { depca_probe },                    /* DE{20[012],422} */
231     { NULL }                            /* Must Be Last! */
232 };
233
234 /*
235  * This tells the autoconf code how to set us up.
236  */
237 struct isa_driver ledriver = {
238     le_probe, le_attach, "le",
239 };
240
241 static unsigned le_intrs[NLE];
242
243 #define LE_INL(sc, reg)         inl((sc)->le_iobase + (reg))
244 #define LE_OUTL(sc, reg, data)  outl((sc)->le_iobase + (reg), data)
245 #define LE_INW(sc, reg)         inw((sc)->le_iobase + (reg))
246 #define LE_OUTW(sc, reg, data)  outw((sc)->le_iobase + (reg), data)
247 #define LE_INB(sc, reg)         inb((sc)->le_iobase + (reg))
248 #define LE_OUTB(sc, reg, data)  outb((sc)->le_iobase + (reg), data)
249
250 static int
251 le_probe(struct isa_device *dvp)
252 {
253     struct le_softc *sc = &le_softc[dvp->id_unit];
254     const struct le_board *bd;
255     int iospace;
256
257     if (dvp->id_unit >= NLE) {
258         printf("%s%d not configured -- too many devices\n",
259                ledriver.name, dvp->id_unit);
260         return 0;
261     }
262
263     sc->le_iobase = dvp->id_iobase;
264     sc->le_membase = (u_char *) dvp->id_maddr;
265     sc->le_irq = dvp->id_irq;
266     if_initname(&(sc->le_if), ledriver.name, dvp->id_unit);
267
268     /*
269      * Find and Initialize board..
270      */
271
272     sc->le_flags &= ~(IFF_UP|IFF_ALLMULTI);
273
274     for (bd = le_boards; bd->bd_probe != NULL; bd++) {
275         if ((iospace = (*bd->bd_probe)(sc, bd, &dvp->id_msize)) != 0) {
276             return iospace;
277         }
278     }
279
280     return 0;
281 }
282
283 static int
284 le_attach(struct isa_device *dvp)
285 {
286     struct le_softc *sc = &le_softc[dvp->id_unit];
287     struct ifnet *ifp = &sc->le_if;
288
289     dvp->id_ointr = le_intr;
290     ifp->if_softc = sc;
291     ifp->if_mtu = ETHERMTU;
292
293     ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
294     ifp->if_ioctl = le_ioctl;
295     ifp->if_type = IFT_ETHER;
296     ifp->if_addrlen = 6;
297     ifp->if_hdrlen = 14;
298     ifp->if_init = sc->if_init;
299     ifp->if_baudrate = 10000000;
300     ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
301     ifq_set_ready(&ifp->if_snd);
302
303     ether_ifattach(ifp, sc->le_ac.ac_enaddr);
304
305     return 1;
306 }
307
308 static void
309 le_intr(int unit)
310 {
311     le_intrs[unit]++;
312     (*le_intrvec[unit])(&le_softc[unit]);
313 }
314
315 #define LE_XTRA         0
316
317 static void
318 le_input(struct le_softc *sc, caddr_t seg1, size_t total_len,
319     size_t len1, caddr_t seg2)
320 {
321     struct ether_header eh;
322     struct mbuf *m;
323
324     if (total_len - sizeof(eh) > ETHERMTU
325             || total_len - sizeof(eh) < ETHERMIN) {
326         sc->le_if.if_ierrors++;
327         return;
328     }
329     bcopy(seg1, &eh, ETHER_HDR_LEN);
330
331     seg1 += ETHER_HDR_LEN;
332     total_len -= ETHER_HDR_LEN;
333     len1 -= ETHER_HDR_LEN;
334
335     MGETHDR(m, MB_DONTWAIT, MT_DATA);
336     if (m == NULL) {
337         sc->le_if.if_ierrors++;
338         return;
339     }
340     m->m_pkthdr.len = total_len;
341     m->m_pkthdr.rcvif = &sc->le_if;
342     if (total_len + LE_XTRA > MHLEN /* >= MINCLSIZE */) {
343         MCLGET(m, MB_DONTWAIT);
344         if ((m->m_flags & M_EXT) == 0) {
345             m_free(m);
346             sc->le_if.if_ierrors++;
347             return;
348         }
349     } else if (total_len + LE_XTRA > MHLEN && MINCLSIZE == (MHLEN+MLEN)) {
350         MGET(m->m_next, MB_DONTWAIT, MT_DATA);
351         if (m->m_next == NULL) {
352             m_free(m);
353             sc->le_if.if_ierrors++;
354             return;
355         }
356         m->m_next->m_len = total_len - MHLEN - LE_XTRA;
357         len1 = total_len = MHLEN - LE_XTRA;
358         bcopy(&seg1[MHLEN-LE_XTRA], mtod(m->m_next, caddr_t), m->m_next->m_len);
359     } else if (total_len + LE_XTRA > MHLEN) {
360         panic("le_input: pkt of unknown length");
361     }
362     m->m_data += LE_XTRA;
363     m->m_len = total_len;
364     bcopy(seg1, mtod(m, caddr_t), len1);
365     if (seg2 != NULL)
366         bcopy(seg2, mtod(m, caddr_t) + len1, total_len - len1);
367     ether_input(&sc->le_if, &eh, m);
368 }
369
370 static int
371 le_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
372 {
373     struct le_softc *sc = ifp->if_softc;
374     int error = 0;
375
376     if ((sc->le_flags & IFF_UP) == 0)
377         return EIO;
378
379     crit_enter();
380
381     switch (cmd) {
382         case SIOCSIFFLAGS: {
383             sc->if_init(sc);
384             break;
385         }
386
387         case SIOCADDMULTI:
388         case SIOCDELMULTI:
389             /*
390              * Update multicast listeners
391              */
392                 sc->if_init(sc);
393                 error = 0;
394                 break;
395
396         default:
397                 error = ether_ioctl(ifp, cmd, data);
398                 break;
399     }
400
401     crit_exit();
402
403     return error;
404 }
405
406 /*
407  *  This is the standard method of reading the DEC Address ROMS.
408  *  I don't understand it but it does work.
409  */
410 static int
411 le_read_macaddr(struct le_softc *sc, int ioreg, int skippat)
412 {
413     int cksum, rom_cksum;
414
415     if (!skippat) {
416         int idx, idx2, found, octet;
417         static u_char testpat[] = { 0xFF, 0, 0x55, 0xAA, 0xFF, 0, 0x55, 0xAA };
418         idx2 = found = 0;
419
420         for (idx = 0; idx < 32; idx++) {
421             octet = LE_INB(sc, ioreg);
422
423             if (octet == testpat[idx2]) {
424                 if (++idx2 == sizeof testpat) {
425                     ++found;
426                     break;
427                 }
428             } else {
429                 idx2 = 0;
430             }
431         }
432
433         if (!found)
434             return -1;
435     }
436
437     cksum = 0;
438     sc->le_hwaddr[0] = LE_INB(sc, ioreg);
439     sc->le_hwaddr[1] = LE_INB(sc, ioreg);
440
441     cksum = *(u_short *) &sc->le_hwaddr[0];
442
443     sc->le_hwaddr[2] = LE_INB(sc, ioreg);
444     sc->le_hwaddr[3] = LE_INB(sc, ioreg);
445     cksum *= 2;
446     if (cksum > 65535) cksum -= 65535;
447     cksum += *(u_short *) &sc->le_hwaddr[2];
448     if (cksum > 65535) cksum -= 65535;
449
450     sc->le_hwaddr[4] = LE_INB(sc, ioreg);
451     sc->le_hwaddr[5] = LE_INB(sc, ioreg);
452     cksum *= 2;
453     if (cksum > 65535) cksum -= 65535;
454     cksum += *(u_short *) &sc->le_hwaddr[4];
455     if (cksum >= 65535) cksum -= 65535;
456
457     rom_cksum = LE_INB(sc, ioreg);
458     rom_cksum |= LE_INB(sc, ioreg) << 8;
459
460     if (cksum != rom_cksum)
461         return -1;
462     return 0;
463 }
464
465 static void
466 le_multi_filter(struct le_softc *sc)
467 {
468     struct ifnet *ifp = &sc->le_ac.ac_if;
469     struct ifmultiaddr *ifma;
470
471     bzero(sc->le_mctbl, (sc->le_mcmask + 1) / 8);
472
473     if (sc->le_if.if_flags & IFF_ALLMULTI) {
474         sc->le_flags |= IFF_MULTICAST|IFF_ALLMULTI;
475         return;
476     }
477     sc->le_flags &= ~IFF_MULTICAST;
478     /* if (interface has had an address assigned) { */
479         le_multi_op(sc, ifp->if_broadcastaddr, TRUE);
480         sc->le_flags |= LE_BRDCSTONLY|IFF_MULTICAST;
481     /* } */
482
483     sc->le_flags |= IFF_MULTICAST;
484
485     for (ifma = ifp->if_multiaddrs.lh_first; ifma;
486          ifma = ifma->ifma_link.le_next) {
487             if (ifma->ifma_addr->sa_family != AF_LINK)
488                     continue;
489
490             le_multi_op(sc, LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 1);
491             sc->le_flags &= ~LE_BRDCSTONLY;
492     }
493 }
494
495 static void
496 le_multi_op(struct le_softc *sc, const u_char *mca, int enable)
497 {
498     uint32_t bit, idx, crc;
499
500     crc = ether_crc32_le(mca, ETHER_ADDR_LEN);
501
502     /*
503      * The following two line convert the N bit index into a longword index
504      * and a longword mask.
505      */
506     crc &= sc->le_mcmask;
507     bit = 1 << (crc & (LE_MC_NBPW -1));
508     idx = crc >> (LE_MC_NBPW_LOG2);
509
510     /*
511      * Set or clear hash filter bit in our table.
512      */
513     if (enable) {
514         sc->le_mctbl[idx] |= bit;               /* Set Bit */
515     } else {
516         sc->le_mctbl[idx] &= ~bit;              /* Clear Bit */
517     }
518 }
519
520 /*
521  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
522  *
523  * Start of DEC EtherWORKS III (LEMAC) dependent code
524  *
525  */
526
527 #define LEMAC_INTR_ENABLE(sc) \
528         LE_OUTB(sc, LEMAC_REG_IC, LE_INB(sc, LEMAC_REG_IC) | LEMAC_IC_ALL)
529
530 #define LEMAC_INTR_DISABLE(sc) \
531         LE_OUTB(sc, LEMAC_REG_IC, LE_INB(sc, LEMAC_REG_IC) & ~LEMAC_IC_ALL)
532
533 #define LEMAC_64K_MODE(mbase)   (((mbase) >= 0x0A) && ((mbase) <= 0x0F))
534 #define LEMAC_32K_MODE(mbase)   (((mbase) >= 0x14) && ((mbase) <= 0x1F))
535 #define LEMAC_2K_MODE(mbase)    ( (mbase) >= 0x40)
536
537 static void     lemac_init(void *xsc);
538 static void     lemac_start(struct ifnet *ifp);
539 static void     lemac_reset(struct le_softc *sc);
540 static void     lemac_intr(struct le_softc *sc);
541 static void     lemac_rne_intr(struct le_softc *sc);
542 static void     lemac_tne_intr(struct le_softc *sc);
543 static void     lemac_txd_intr(struct le_softc *sc, unsigned cs_value);
544 static void     lemac_rxd_intr(struct le_softc *sc, unsigned cs_value);
545 static int      lemac_read_eeprom(struct le_softc *sc);
546 static void     lemac_init_adapmem(struct le_softc *sc);
547
548 #define LE_MCBITS_ALL_1S        ((le_mcbits_t)~(le_mcbits_t)0)
549
550 static const le_mcbits_t lemac_allmulti_mctbl[16] =  {
551     LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S,
552     LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S,
553     LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S,
554     LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S, LE_MCBITS_ALL_1S,
555 };
556 /*
557  * An IRQ mapping table.  Less space than switch statement.
558  */
559 static const int lemac_irqs[] = { IRQ5, IRQ10, IRQ11, IRQ15 };
560
561 /*
562  * Some tuning/monitoring variables.
563  */
564 static unsigned lemac_deftxmax = 16;    /* see lemac_max above */
565 static unsigned lemac_txnospc = 0;      /* total # of tranmit starvations */
566
567 static unsigned lemac_tne_intrs = 0;    /* total # of tranmit done intrs */
568 static unsigned lemac_rne_intrs = 0;    /* total # of receive done intrs */
569 static unsigned lemac_txd_intrs = 0;    /* total # of tranmit error intrs */
570 static unsigned lemac_rxd_intrs = 0;    /* total # of receive error intrs */
571
572 static int
573 lemac_probe(struct le_softc *sc, const struct le_board *bd, int *msize)
574 {
575     int irq, portval;
576
577     LE_OUTB(sc, LEMAC_REG_IOP, LEMAC_IOP_EEINIT);
578     DELAY(LEMAC_EEP_DELAY);
579
580     /*
581      *  Read Ethernet address if card is present.
582      */
583     if (le_read_macaddr(sc, LEMAC_REG_APD, 0) < 0)
584         return 0;
585
586     bcopy(sc->le_hwaddr, sc->le_ac.ac_enaddr, ETHER_ADDR_LEN);
587     /*
588      *  Clear interrupts and set IRQ.
589      */
590
591     portval = LE_INB(sc, LEMAC_REG_IC) & LEMAC_IC_IRQMSK;
592     irq = lemac_irqs[portval >> 5];
593     LE_OUTB(sc, LEMAC_REG_IC, portval);
594
595     /*
596      *  Make sure settings match.
597      */
598
599     if (irq != sc->le_irq) {
600         if_printf(&sc->le_if, "lemac configuration error: expected IRQ 0x%x actual 0x%x\n",
601             sc->le_irq, irq);
602         return 0;
603     }
604
605     /*
606      * Try to reset the unit
607      */
608     sc->if_init = lemac_init;
609     sc->le_if.if_start = lemac_start;
610     sc->if_reset = lemac_reset;
611     sc->lemac_memmode = 2;
612     sc->if_reset(sc);
613     if ((sc->le_flags & IFF_UP) == 0)
614         return 0;
615
616     /*
617      *  Check for correct memory base configuration.
618      */
619     if (vtophys(sc->le_membase) != sc->lemac_membase) {
620         if_printf(&sc->le_if, "lemac configuration error: expected iomem 0x%llx actual 0x%x\n",
621                vtophys(sc->le_membase), sc->lemac_membase);
622         return 0;
623     }
624
625     sc->le_prodname = sc->lemac_prodname;
626     sc->le_mctbl = sc->lemac_mctbl;
627     sc->le_mcmask = (1 << LEMAC_MCTBL_BITS) - 1;
628     sc->lemac_txmax = lemac_deftxmax;
629     *msize = 2048;
630     le_intrvec[sc->le_if.if_dunit] = lemac_intr;
631
632     return LEMAC_IOSPACE;
633 }
634
635 /*
636  * Do a hard reset of the board;
637  */
638 static void
639 lemac_reset(struct le_softc *sc)
640 {
641     struct ifnet *ifp = &sc->le_if;
642     int portval, cksum;
643
644     /*
645      * Initialize board..
646      */
647
648     sc->le_flags &= IFF_UP;
649     ifp->if_flags &= ~IFF_OACTIVE;
650     LEMAC_INTR_DISABLE(sc);
651
652     LE_OUTB(sc, LEMAC_REG_IOP, LEMAC_IOP_EEINIT);
653     DELAY(LEMAC_EEP_DELAY);
654
655     /* Disable Interrupts */
656     /* LE_OUTB(sc, LEMAC_REG_IC, LE_INB(sc, LEMAC_REG_IC) & ICR_IRQ_SEL); */
657
658     /*
659      * Read EEPROM information.  NOTE - the placement of this function
660      * is important because functions hereafter may rely on information
661      * read from the EEPROM.
662      */
663     if ((cksum = lemac_read_eeprom(sc)) != LEMAC_EEP_CKSUM) {
664         if_printf(ifp, "reset: EEPROM checksum failed (0x%x)\n", cksum);
665         return;
666     }
667
668     /*
669      *  Force to 2K mode if not already configured.
670      */
671
672     portval = LE_INB(sc, LEMAC_REG_MBR);
673     if (!LEMAC_2K_MODE(portval)) {
674         if (LEMAC_64K_MODE(portval)) {
675             portval = (((portval * 2) & 0xF) << 4);
676             sc->lemac_memmode = 64;
677         } else if (LEMAC_32K_MODE(portval)) {
678             portval = ((portval & 0xF) << 4);
679             sc->lemac_memmode = 32;
680         }
681         LE_OUTB(sc, LEMAC_REG_MBR, portval);
682     }
683     sc->lemac_membase = portval * (2 * 1024) + (512 * 1024);
684
685     /*
686      *  Initialize Free Memory Queue, Init mcast table with broadcast.
687      */
688
689     lemac_init_adapmem(sc);
690     sc->le_flags |= IFF_UP;
691 }
692
693 static void
694 lemac_init(void *xsc)
695 {
696     struct le_softc *sc = (struct le_softc *)xsc;
697
698     if ((sc->le_flags & IFF_UP) == 0)
699         return;
700
701     crit_enter();
702
703     /*
704      * If the interface has the up flag
705      */
706     if (sc->le_if.if_flags & IFF_UP) {
707         int saved_cs = LE_INB(sc, LEMAC_REG_CS);
708         LE_OUTB(sc, LEMAC_REG_CS, saved_cs | (LEMAC_CS_TXD | LEMAC_CS_RXD));
709         LE_OUTB(sc, LEMAC_REG_PA0, sc->le_ac.ac_enaddr[0]);
710         LE_OUTB(sc, LEMAC_REG_PA1, sc->le_ac.ac_enaddr[1]);
711         LE_OUTB(sc, LEMAC_REG_PA2, sc->le_ac.ac_enaddr[2]);
712         LE_OUTB(sc, LEMAC_REG_PA3, sc->le_ac.ac_enaddr[3]);
713         LE_OUTB(sc, LEMAC_REG_PA4, sc->le_ac.ac_enaddr[4]);
714         LE_OUTB(sc, LEMAC_REG_PA5, sc->le_ac.ac_enaddr[5]);
715
716         LE_OUTB(sc, LEMAC_REG_IC, LE_INB(sc, LEMAC_REG_IC) | LEMAC_IC_IE);
717
718         if (sc->le_if.if_flags & IFF_PROMISC) {
719             LE_OUTB(sc, LEMAC_REG_CS, LEMAC_CS_MCE | LEMAC_CS_PME);
720         } else {
721             LEMAC_INTR_DISABLE(sc);
722             le_multi_filter(sc);
723             LE_OUTB(sc, LEMAC_REG_MPN, 0);
724             if ((sc->le_flags | sc->le_if.if_flags) & IFF_ALLMULTI) {
725                 bcopy(lemac_allmulti_mctbl, &sc->le_membase[LEMAC_MCTBL_OFF], sizeof(lemac_allmulti_mctbl));
726             } else {
727                 bcopy(sc->lemac_mctbl, &sc->le_membase[LEMAC_MCTBL_OFF], sizeof(sc->lemac_mctbl));
728             }
729             LE_OUTB(sc, LEMAC_REG_CS, LEMAC_CS_MCE);
730         }
731
732         LE_OUTB(sc, LEMAC_REG_CTL, LE_INB(sc, LEMAC_REG_CTL) ^ LEMAC_CTL_LED);
733
734         LEMAC_INTR_ENABLE(sc);
735         sc->le_if.if_flags |= IFF_RUNNING;
736     } else {
737         LE_OUTB(sc, LEMAC_REG_CS, LEMAC_CS_RXD|LEMAC_CS_TXD);
738
739         LEMAC_INTR_DISABLE(sc);
740         sc->le_if.if_flags &= ~IFF_RUNNING;
741     }
742
743     crit_exit();
744 }
745
746 /*
747  * What to do upon receipt of an interrupt.
748  */
749 static void
750 lemac_intr(struct le_softc *sc)
751 {
752     int cs_value;
753
754     LEMAC_INTR_DISABLE(sc);     /* Mask interrupts */
755
756     /*
757      * Determine cause of interrupt.  Receive events take
758      * priority over Transmit.
759      */
760
761     cs_value = LE_INB(sc, LEMAC_REG_CS);
762
763     /*
764      * Check for Receive Queue not being empty.
765      * Check for Transmit Done Queue not being empty.
766      */
767
768     if (cs_value & LEMAC_CS_RNE)
769         lemac_rne_intr(sc);
770     if (cs_value & LEMAC_CS_TNE)
771         lemac_tne_intr(sc);
772
773     /*
774      * Check for Transmitter Disabled.
775      * Check for Receiver Disabled.
776      */
777
778     if (cs_value & LEMAC_CS_TXD)
779         lemac_txd_intr(sc, cs_value);
780     if (cs_value & LEMAC_CS_RXD)
781         lemac_rxd_intr(sc, cs_value);
782
783     /*
784      * Toggle LED and unmask interrupts.
785      */
786
787     LE_OUTB(sc, LEMAC_REG_CTL, LE_INB(sc, LEMAC_REG_CTL) ^ LEMAC_CTL_LED);
788     LEMAC_INTR_ENABLE(sc);              /* Unmask interrupts */
789 }
790
791 static void
792 lemac_rne_intr(struct le_softc *sc)
793 {
794     int rxcount, rxlen, rxpg;
795     u_char *rxptr;
796
797     lemac_rne_intrs++;
798     rxcount = LE_INB(sc, LEMAC_REG_RQC);
799     while (rxcount--) {
800         rxpg = LE_INB(sc, LEMAC_REG_RQ);
801         LE_OUTB(sc, LEMAC_REG_MPN, rxpg);
802
803         rxptr = sc->le_membase;
804         sc->le_if.if_ipackets++;
805         if (*rxptr & LEMAC_RX_OK) {
806
807             /*
808              * Get receive length - subtract out checksum.
809              */
810
811             rxlen = ((*(u_int *)rxptr >> 8) & 0x7FF) - 4;
812             le_input(sc, rxptr + sizeof(u_int), rxlen, rxlen, NULL);
813         } else { /* end if (*rxptr & LEMAC_RX_OK) */
814             sc->le_if.if_ierrors++;
815         }
816         LE_OUTB(sc, LEMAC_REG_FMQ, rxpg);  /* Return this page to Free Memory Queue */
817     }  /* end while (recv_count--) */
818 }
819
820 static void
821 lemac_rxd_intr(struct le_softc *sc, unsigned cs_value)
822 {
823     /*
824      * Handle CS_RXD (Receiver disabled) here.
825      *
826      * Check Free Memory Queue Count. If not equal to zero
827      * then just turn Receiver back on. If it is equal to
828      * zero then check to see if transmitter is disabled.
829      * Process transmit TXD loop once more.  If all else
830      * fails then do software init (0xC0 to EEPROM Init)
831      * and rebuild Free Memory Queue.
832      */
833
834     lemac_rxd_intrs++;
835
836     /*
837      *  Re-enable Receiver.
838      */
839
840     cs_value &= ~LEMAC_CS_RXD;
841     LE_OUTB(sc, LEMAC_REG_CS, cs_value);
842
843     if (LE_INB(sc, LEMAC_REG_FMC) > 0)
844         return;
845
846     if (cs_value & LEMAC_CS_TXD)
847         lemac_txd_intr(sc, cs_value);
848
849     if ((LE_INB(sc, LEMAC_REG_CS) & LEMAC_CS_RXD) == 0)
850         return;
851
852     if_printf(&sc->le_if, "fatal RXD error, attempting recovery\n");
853
854     sc->if_reset(sc);
855     if (sc->le_flags & IFF_UP) {
856         lemac_init(sc);
857         return;
858     }
859
860     /*
861      *  Error during initializion.  Mark card as disabled.
862      */
863     if_printf(&sc->le_if, "recovery failed -- board disabled\n");
864 }
865
866 static void
867 lemac_start(struct ifnet *ifp)
868 {
869     struct le_softc *sc = (struct le_softc *) ifp;
870
871     if ((ifp->if_flags & IFF_RUNNING) == 0)
872         return;
873
874     LEMAC_INTR_DISABLE(sc);
875
876     while (!ifq_is_empty(&ifp->if_snd)) {
877         struct mbuf  *m;
878         int tx_pg;
879         u_int txhdr, txoff;
880
881         if (LE_INB(sc, LEMAC_REG_TQC) >= sc->lemac_txmax) {
882             ifp->if_flags |= IFF_OACTIVE;
883             break;
884         }
885
886         tx_pg = LE_INB(sc, LEMAC_REG_FMQ);      /* get free memory page */
887         /*
888          * Check for good transmit page.
889          */
890         if (tx_pg == 0 || tx_pg > sc->lemac_lastpage) {
891             lemac_txnospc++;
892             ifp->if_flags |= IFF_OACTIVE;
893             break;
894         }
895
896         m = ifq_dequeue(&ifp->if_snd);
897         LE_OUTB(sc, LEMAC_REG_MPN, tx_pg);      /* Shift 2K window. */
898
899         /*
900          * The first four bytes of each transmit buffer are for
901          * control information.  The first byte is the control
902          * byte, then the length (why not word aligned?), then
903          * the off to the buffer.
904          */
905
906         txoff = (mtod(m, u_int) & (sizeof(u_long) - 1)) + LEMAC_TX_HDRSZ;
907         txhdr = sc->lemac_txctl | (m->m_pkthdr.len << 8) | (txoff << 24);
908         *(u_int *) sc->le_membase = txhdr;
909
910         /*
911          * Copy the packet to the board
912          */
913
914         m_copydata(m, 0, m->m_pkthdr.len, sc->le_membase + txoff);
915
916         LE_OUTB(sc, LEMAC_REG_TQ, tx_pg);       /* tell chip to transmit this packet */
917
918         BPF_MTAP(ifp, m);
919
920         m_freem(m);                     /* free the mbuf */
921     }
922     LEMAC_INTR_ENABLE(sc);
923 }
924
925 static void
926 lemac_tne_intr(struct le_softc *sc)
927 {
928     int txsts, txcount = LE_INB(sc, LEMAC_REG_TDC);
929
930     lemac_tne_intrs++;
931     while (txcount--) {
932         txsts = LE_INB(sc, LEMAC_REG_TDQ);
933         sc->le_if.if_opackets++;                /* another one done */
934         if ((txsts & LEMAC_TDQ_COL) != LEMAC_TDQ_NOCOL)
935             sc->le_if.if_collisions++;
936     }
937     sc->le_if.if_flags &= ~IFF_OACTIVE;
938     lemac_start(&sc->le_if);
939 }
940
941 static void
942 lemac_txd_intr(struct le_softc *sc, unsigned cs_value)
943 {
944     /*
945      * Read transmit status, remove transmit buffer from
946      * transmit queue and place on free memory queue,
947      * then reset transmitter.
948      * Increment appropriate counters.
949      */
950
951     lemac_txd_intrs++;
952     sc->le_if.if_oerrors++;
953     if (LE_INB(sc, LEMAC_REG_TS) & LEMAC_TS_ECL)
954         sc->le_if.if_collisions++;
955     sc->le_if.if_flags &= ~IFF_OACTIVE;
956
957     LE_OUTB(sc, LEMAC_REG_FMQ, LE_INB(sc, LEMAC_REG_TQ));
958                                 /* Get Page number and write it back out */
959
960     LE_OUTB(sc, LEMAC_REG_CS, cs_value & ~LEMAC_CS_TXD);
961                                 /* Turn back on transmitter */
962 }
963
964 static int
965 lemac_read_eeprom(struct le_softc *sc)
966 {
967     int word_off, cksum;
968
969     u_char *ep;
970
971     cksum = 0;
972     ep = sc->lemac_eeprom;
973     for (word_off = 0; word_off < LEMAC_EEP_SIZE / 2; word_off++) {
974         LE_OUTB(sc, LEMAC_REG_PI1, word_off);
975         LE_OUTB(sc, LEMAC_REG_IOP, LEMAC_IOP_EEREAD);
976
977         DELAY(LEMAC_EEP_DELAY);
978
979         *ep = LE_INB(sc, LEMAC_REG_EE1);        cksum += *ep++;
980         *ep = LE_INB(sc, LEMAC_REG_EE2);        cksum += *ep++;
981     }
982
983     /*
984      *  Set up Transmit Control Byte for use later during transmit.
985      */
986
987     sc->lemac_txctl |= LEMAC_TX_FLAGS;
988
989     if ((sc->lemac_eeprom[LEMAC_EEP_SWFLAGS] & LEMAC_EEP_SW_SQE) == 0)
990         sc->lemac_txctl &= ~LEMAC_TX_SQE;
991
992     if (sc->lemac_eeprom[LEMAC_EEP_SWFLAGS] & LEMAC_EEP_SW_LAB)
993         sc->lemac_txctl |= LEMAC_TX_LAB;
994
995     bcopy(&sc->lemac_eeprom[LEMAC_EEP_PRDNM], sc->lemac_prodname, LEMAC_EEP_PRDNMSZ);
996     sc->lemac_prodname[LEMAC_EEP_PRDNMSZ] = '\0';
997
998     return cksum % 256;
999 }
1000
1001 static void
1002 lemac_init_adapmem(struct le_softc *sc)
1003 {
1004     int pg, conf;
1005
1006     conf = LE_INB(sc, LEMAC_REG_CNF);
1007
1008     if ((sc->lemac_eeprom[LEMAC_EEP_SETUP] & LEMAC_EEP_ST_DRAM) == 0) {
1009         sc->lemac_lastpage = 63;
1010         conf &= ~LEMAC_CNF_DRAM;
1011     } else {
1012         sc->lemac_lastpage = 127;
1013         conf |= LEMAC_CNF_DRAM;
1014     }
1015
1016     LE_OUTB(sc, LEMAC_REG_CNF, conf);
1017
1018     for (pg = 1; pg <= sc->lemac_lastpage; pg++)
1019         LE_OUTB(sc, LEMAC_REG_FMQ, pg);
1020
1021     return;
1022 }
1023
1024 /*
1025  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1026  *
1027  * Start of DEPCA (DE200/DE201/DE202/DE422 etal) support.
1028  *
1029  */
1030 static void depca_intr(struct le_softc *sc);
1031 static int  lance_init_adapmem(struct le_softc *sc);
1032 static int  lance_init_ring(struct le_softc *sc, ln_ring_t *rp, lance_ring_t *ri,
1033                             unsigned ndescs, unsigned bufoffset,
1034                             unsigned descoffset);
1035 static void lance_init(void *xsc);
1036 static void lance_reset(struct le_softc *sc);
1037 static void lance_intr(struct le_softc *sc);
1038 static int  lance_rx_intr(struct le_softc *sc);
1039 static void lance_start(struct ifnet *ifp);
1040 static int  lance_tx_intr(struct le_softc *sc);
1041
1042 #define LN_BUFSIZE              /* 380 */ 304   /* 1520 / 4 */
1043 #define LN_TXDESC_RATIO         2048
1044 #define LN_DESC_MAX             128
1045
1046 #if LN_DOSTATS
1047 static struct {
1048     unsigned lance_rx_misses;
1049     unsigned lance_rx_badcrc;
1050     unsigned lance_rx_badalign;
1051     unsigned lance_rx_badframe;
1052     unsigned lance_rx_buferror;
1053     unsigned lance_tx_deferred;
1054     unsigned lance_tx_single_collisions;
1055     unsigned lance_tx_multiple_collisions;
1056     unsigned lance_tx_excessive_collisions;
1057     unsigned lance_tx_late_collisions;
1058
1059     unsigned lance_memory_errors;
1060     unsigned lance_inits;
1061     unsigned lance_tx_intrs;
1062     unsigned lance_tx_nospc[2];
1063     unsigned lance_tx_drains[2];
1064     unsigned lance_tx_orphaned;
1065     unsigned lance_tx_adoptions;
1066     unsigned lance_tx_emptied;
1067     unsigned lance_tx_deftxint;
1068     unsigned lance_tx_buferror;
1069     unsigned lance_high_txoutptr;
1070     unsigned lance_low_txheapsize;
1071     unsigned lance_low_txfree;
1072     unsigned lance_tx_intr_hidescs;
1073     /* unsigned lance_tx_intr_descs[LN_DESC_MAX]; */
1074
1075     unsigned lance_rx_intrs;
1076     unsigned lance_rx_badsop;
1077     unsigned lance_rx_contig;
1078     unsigned lance_rx_noncontig;
1079     unsigned lance_rx_intr_hidescs;
1080     unsigned lance_rx_ndescs[4096 / LN_BUFSIZE];
1081     /* unsigned lance_rx_intr_descs[LN_DESC_MAX]; */
1082 } lance_stats;
1083
1084 #define LN_STAT(stat)   (lance_stats.lance_ ## stat)
1085 #define LN_MINSTAT(stat, val)   (LN_STAT(stat > (val)) ? LN_STAT(stat = (val)) : 0)
1086 #define LN_MAXSTAT(stat, val)   (LN_STAT(stat < (val)) ? LN_STAT(stat = (val)) : 0)
1087
1088 #else
1089 #define LN_STAT(stat)   0
1090 #define LN_MINSTAT(stat, val)   0
1091 #define LN_MAXSTAT(stat, val)   0
1092 #endif
1093
1094 #define LN_SELCSR(sc, csrno)            (LE_OUTW(sc, sc->lance_rap, csrno))
1095 #define LN_INQCSR(sc)                   (LE_INW(sc, sc->lance_rap))
1096
1097 #define LN_WRCSR(sc, val)               (LE_OUTW(sc, sc->lance_rdp, val))
1098 #define LN_RDCSR(sc)                    (LE_INW(sc, sc->lance_rdp))
1099
1100
1101 #define LN_ZERO(sc, vaddr, len)         bzero(vaddr, len)
1102 #define LN_COPYTO(sc, from, to, len)    bcopy(from, to, len)
1103
1104 #define LN_SETFLAG(sc, vaddr, val) \
1105         (((volatile u_char *) vaddr)[3] = (val))
1106
1107 #define LN_PUTDESC(sc, desc, vaddr) \
1108         (((volatile u_short *) vaddr)[0] = ((u_short *) desc)[0], \
1109          ((volatile u_short *) vaddr)[2] = ((u_short *) desc)[2], \
1110          ((volatile u_short *) vaddr)[1] = ((u_short *) desc)[1])
1111
1112 /*
1113  * Only get the descriptor flags and length/status.  All else
1114  * read-only.
1115  */
1116 #define LN_GETDESC(sc, desc, vaddr) \
1117         (((u_short *) desc)[1] = ((volatile u_short *) vaddr)[1], \
1118          ((u_short *) desc)[3] = ((volatile u_short *) vaddr)[3])
1119
1120 /*
1121  *  These definitions are specific to the DEC "DEPCA-style" NICs.
1122  *      (DEPCA, DE10x, DE20[012], DE422)
1123  *
1124  */
1125 #define DEPCA_REG_NICSR         0               /* (RW;16) NI Control / Status */
1126 #define DEPCA_REG_RDP           4               /* (RW:16) LANCE RDP (data) register */
1127 #define DEPCA_REG_RAP           6               /* (RW:16) LANCE RAP (address) register */
1128 #define DEPCA_REG_ADDRROM       12              /* (R : 8) DEPCA Ethernet Address ROM */
1129 #define DEPCA_IOSPACE           16              /* DEPCAs use 16 bytes of IO space */
1130
1131 #define DEPCA_NICSR_LED         0x0001          /* Light the LED on the back of the DEPCA */
1132 #define DEPCA_NICSR_ENABINTR    0x0002          /* Enable Interrupts */
1133 #define DEPCA_NICSR_MASKINTR    0x0004          /* Mask Interrupts */
1134 #define DEPCA_NICSR_AAC         0x0008          /* Address Counter Clear */
1135 #define DEPCA_NICSR_REMOTEBOOT  0x0010          /* Remote Boot Enabled (ignored) */
1136 #define DEPCA_NICSR_32KRAM      0x0020          /* DEPCA LANCE RAM size 64K (C) / 32K (S) */
1137 #define DEPCA_NICSR_LOW32K      0x0040          /* Bank Select (A15 = !This Bit) */
1138 #define DEPCA_NICSR_SHE         0x0080          /* Shared RAM Enabled (ie hide ROM) */
1139 #define DEPCA_NICSR_BOOTTMO     0x0100          /* Remote Boot Timeout (ignored) */
1140
1141 #define DEPCA_RDNICSR(sc)       (LE_INW(sc, DEPCA_REG_NICSR))
1142 #define DEPCA_WRNICSR(sc, val)  (LE_OUTW(sc, DEPCA_REG_NICSR, val))
1143
1144 #define DEPCA_IDSTR_OFFSET      0xC006          /* ID String Offset */
1145
1146 #define DEPCA_REG_EISAID        0x80
1147 #define DEPCA_EISAID_MASK       0xf0ffffff
1148 #define DEPCA_EISAID_DE422      0x2042A310
1149
1150 typedef enum {
1151     DEPCA_CLASSIC,
1152     DEPCA_DE100, DEPCA_DE101,
1153     DEPCA_EE100,
1154     DEPCA_DE200, DEPCA_DE201, DEPCA_DE202,
1155     DEPCA_DE422,
1156     DEPCA_UNKNOWN
1157 } depca_t;
1158
1159 static const char *depca_signatures[] = {
1160     "DEPCA",
1161     "DE100", "DE101",
1162     "EE100",
1163     "DE200", "DE201", "DE202",
1164     "DE422",
1165     NULL
1166 };
1167
1168 static int
1169 depca_probe(struct le_softc *sc, const struct le_board *bd, int *msize)
1170 {
1171     unsigned nicsr, idx, idstr_offset = DEPCA_IDSTR_OFFSET;
1172
1173     /*
1174      *  Find out how memory we are dealing with.  Adjust
1175      *  the ID string offset approriately if we are at
1176      *  32K.  Make sure the ROM is enabled.
1177      */
1178     nicsr = DEPCA_RDNICSR(sc);
1179     nicsr &= ~(DEPCA_NICSR_SHE|DEPCA_NICSR_LED|DEPCA_NICSR_ENABINTR);
1180
1181     if (nicsr & DEPCA_NICSR_32KRAM) {
1182         /*
1183          * Make we are going to read the upper
1184          * 32K so we do read the ROM.
1185          */
1186         sc->lance_ramsize = 32 * 1024;
1187         nicsr &= ~DEPCA_NICSR_LOW32K;
1188         sc->lance_ramoffset = 32 * 1024;
1189         idstr_offset -= sc->lance_ramsize;
1190     } else {
1191         sc->lance_ramsize = 64 * 1024;
1192         sc->lance_ramoffset = 0;
1193     }
1194     DEPCA_WRNICSR(sc, nicsr);
1195
1196     sc->le_prodname = NULL;
1197     for (idx = 0; depca_signatures[idx] != NULL; idx++) {
1198         if (bcmp(depca_signatures[idx], sc->le_membase + idstr_offset, 5) == 0) {
1199             sc->le_prodname = depca_signatures[idx];
1200             break;
1201         }
1202     }
1203
1204     if (sc->le_prodname == NULL) {
1205         /*
1206          * Try to get the EISA device if it's a DE422.
1207          */
1208         if (sc->le_iobase > 0x1000 && (sc->le_iobase & 0x0F00) == 0x0C00
1209             && (LE_INL(sc, DEPCA_REG_EISAID) & DEPCA_EISAID_MASK)
1210              == DEPCA_EISAID_DE422) {
1211             sc->le_prodname = "DE422";
1212         } else {
1213             return 0;
1214         }
1215     }
1216     if (idx == DEPCA_CLASSIC)
1217         sc->lance_ramsize -= 16384;     /* Can't use the ROM area on a DEPCA */
1218
1219     /*
1220      * Try to read the address ROM.
1221      *   Stop the LANCE, reset the Address ROM Counter (AAC),
1222      *   read the NICSR to "clock" in the reset, and then
1223      *   re-enable the Address ROM Counter.  Now read the
1224      *   address ROM.
1225      */
1226     sc->lance_rdp = DEPCA_REG_RDP;
1227     sc->lance_rap = DEPCA_REG_RAP;
1228     sc->lance_csr3 = LN_CSR3_ALE;
1229     sc->le_mctbl = sc->lance_initb.ln_multi_mask;
1230     sc->le_mcmask = LN_MC_MASK;
1231     LN_SELCSR(sc, LN_CSR0);
1232     LN_WRCSR(sc, LN_CSR0_STOP);
1233
1234     if (idx < DEPCA_DE200) {
1235         DEPCA_WRNICSR(sc, DEPCA_RDNICSR(sc) & ~DEPCA_NICSR_AAC);
1236         DEPCA_WRNICSR(sc, DEPCA_RDNICSR(sc) | DEPCA_NICSR_AAC);
1237     }
1238
1239     if (le_read_macaddr(sc, DEPCA_REG_ADDRROM, idx == DEPCA_CLASSIC) < 0)
1240         return 0;
1241
1242     bcopy(sc->le_hwaddr, sc->le_ac.ac_enaddr, ETHER_ADDR_LEN);
1243     /*
1244      * Renable shared RAM.
1245      */
1246     DEPCA_WRNICSR(sc, DEPCA_RDNICSR(sc) | DEPCA_NICSR_SHE);
1247
1248     le_intrvec[sc->le_if.if_dunit] = depca_intr;
1249     if (!lance_init_adapmem(sc))
1250         return 0;
1251
1252     sc->if_reset = lance_reset;
1253     sc->if_init = lance_init;
1254     sc->le_if.if_start = lance_start;
1255     DEPCA_WRNICSR(sc, DEPCA_NICSR_SHE | DEPCA_NICSR_ENABINTR);
1256     sc->if_reset(sc);
1257
1258     LN_STAT(low_txfree = sc->lance_txinfo.ri_max);
1259     LN_STAT(low_txheapsize = 0xFFFFFFFF);
1260     *msize = sc->lance_ramsize;
1261     return DEPCA_IOSPACE;
1262 }
1263
1264 static void
1265 depca_intr(struct le_softc *sc)
1266 {
1267     DEPCA_WRNICSR(sc, DEPCA_RDNICSR(sc) ^ DEPCA_NICSR_LED);
1268     lance_intr(sc);
1269 }
1270
1271 /*
1272  * Here's as good a place to describe our paritioning of the
1273  * LANCE shared RAM space.  (NOTE: this driver does not yet support
1274  * the concept of a LANCE being able to DMA).
1275  *
1276  * First is the 24 (00:23) bytes for LANCE Initialization Block
1277  * Next are the recieve descriptors.  The number is calculated from
1278  * how many LN_BUFSIZE buffers we can allocate (this number must
1279  * be a power of 2).  Next are the transmit descriptors.  The amount
1280  * of transmit descriptors is derived from the size of the RAM
1281  * divided by 1K.  Now come the receive buffers (one for each receive
1282  * descriptor).  Finally is the transmit heap.  (no fixed buffers are
1283  * allocated so as to make the most use of the limited space).
1284  */
1285 static int
1286 lance_init_adapmem(struct le_softc *sc)
1287 {
1288     lance_addr_t rxbufoffset;
1289     lance_addr_t rxdescoffset, txdescoffset;
1290     unsigned rxdescs, txdescs;
1291
1292     /*
1293      * First calculate how many descriptors we heap.
1294      * Note this assumes the ramsize is a power of two.
1295      */
1296     sc->lance_rxbufsize = LN_BUFSIZE;
1297     rxdescs = 1;
1298     while (rxdescs * sc->lance_rxbufsize < sc->lance_ramsize)
1299         rxdescs *= 2;
1300     rxdescs /= 2;
1301     if (rxdescs > LN_DESC_MAX) {
1302         sc->lance_rxbufsize *= rxdescs / LN_DESC_MAX;
1303         rxdescs = LN_DESC_MAX;
1304     }
1305     txdescs = sc->lance_ramsize / LN_TXDESC_RATIO;
1306     if (txdescs > LN_DESC_MAX)
1307         txdescs = LN_DESC_MAX;
1308
1309     /*
1310      * Now calculate where everything goes in memory
1311      */
1312     rxdescoffset = sizeof(ln_initb_t);
1313     txdescoffset = rxdescoffset + sizeof(ln_desc_t) * rxdescs;
1314     rxbufoffset  = txdescoffset + sizeof(ln_desc_t) * txdescs;
1315
1316     sc->le_mctbl = (le_mcbits_t *) sc->lance_initb.ln_multi_mask;
1317     /*
1318      * Remember these for debugging.
1319      */
1320     sc->lance_raminitb = (ln_initb_t *) sc->le_membase;
1321     sc->lance_ramdesc = (ln_desc_t *) (sc->le_membase + rxdescoffset);
1322
1323     /*
1324      * Initialize the rings.
1325      */
1326     if (!lance_init_ring(sc, &sc->lance_initb.ln_rxring, &sc->lance_rxinfo,
1327                    rxdescs, rxbufoffset, rxdescoffset))
1328         return 0;
1329     sc->lance_rxinfo.ri_heap = rxbufoffset;
1330     sc->lance_rxinfo.ri_heapend = rxbufoffset + sc->lance_rxbufsize * rxdescs;
1331
1332     if (!lance_init_ring(sc, &sc->lance_initb.ln_txring, &sc->lance_txinfo,
1333                    txdescs, 0, txdescoffset))
1334         return 0;
1335     sc->lance_txinfo.ri_heap = sc->lance_rxinfo.ri_heapend;
1336     sc->lance_txinfo.ri_heapend = sc->lance_ramsize;
1337
1338     /*
1339      * Set CSR1 and CSR2 to the address of the init block (which
1340      * for us is always 0.
1341      */
1342     sc->lance_csr1 = LN_ADDR_LO(0 + sc->lance_ramoffset);
1343     sc->lance_csr2 = LN_ADDR_HI(0 + sc->lance_ramoffset);
1344     return 1;
1345 }
1346
1347 static int
1348 lance_init_ring(struct le_softc *sc, ln_ring_t *rp, lance_ring_t *ri,
1349     unsigned ndescs, lance_addr_t bufoffset, lance_addr_t descoffset)
1350 {
1351     lance_descinfo_t *di;
1352
1353     /*
1354      * Initialize the ring pointer in the LANCE InitBlock
1355      */
1356     rp->r_addr_lo = LN_ADDR_LO(descoffset + sc->lance_ramoffset);
1357     rp->r_addr_hi = LN_ADDR_HI(descoffset + sc->lance_ramoffset);
1358     rp->r_log2_size = ffs(ndescs) - 1;
1359
1360     /*
1361      * Allocate the ring entry descriptors and initialize
1362      * our ring information data structure.  All these are
1363      * our copies and do not live in the LANCE RAM.
1364      */
1365     ri->ri_first = malloc(ndescs * sizeof(*di), M_DEVBUF, M_WAITOK);
1366     ri->ri_free = ri->ri_max = ndescs;
1367     ri->ri_last = ri->ri_first + ri->ri_max;
1368     for (di = ri->ri_first; di < ri->ri_last; di++) {
1369         di->di_addr = sc->le_membase + descoffset;
1370         di->di_mbuf = NULL;
1371         if (bufoffset) {
1372             di->di_bufaddr = bufoffset;
1373             di->di_buflen = sc->lance_rxbufsize;
1374             bufoffset += sc->lance_rxbufsize;
1375         }
1376         descoffset += sizeof(ln_desc_t);
1377     }
1378     return 1;
1379 }
1380
1381 static void
1382 lance_dumpcsrs(struct le_softc *sc, const char *id)
1383 {
1384     if_printf(&sc->le_if, "%s: nicsr=%04x", id, DEPCA_RDNICSR(sc));
1385     LN_SELCSR(sc, LN_CSR0);
1386     printf(" csr0=%04x", LN_RDCSR(sc));
1387     LN_SELCSR(sc, LN_CSR1);
1388     printf(" csr1=%04x", LN_RDCSR(sc));
1389     LN_SELCSR(sc, LN_CSR2);
1390     printf(" csr2=%04x", LN_RDCSR(sc));
1391     LN_SELCSR(sc, LN_CSR3);
1392     printf(" csr3=%04x\n", LN_RDCSR(sc));
1393     LN_SELCSR(sc, LN_CSR0);
1394 }
1395
1396 static void
1397 lance_reset(struct le_softc *sc)
1398 {
1399     int cnt, csr;
1400
1401     /* lance_dumpcsrs(sc, "lance_reset: start"); */
1402
1403     LN_WRCSR(sc, LN_RDCSR(sc) & ~LN_CSR0_ENABINTR);
1404     LN_WRCSR(sc, LN_CSR0_STOP);
1405     DELAY(100);
1406
1407     sc->le_flags &= ~IFF_UP;
1408     sc->le_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
1409
1410     le_multi_filter(sc);                /* initialize the multicast table */
1411     if ((sc->le_flags | sc->le_if.if_flags) & IFF_ALLMULTI) {
1412         sc->lance_initb.ln_multi_mask[0] = 0xFFFFU;
1413         sc->lance_initb.ln_multi_mask[1] = 0xFFFFU;
1414         sc->lance_initb.ln_multi_mask[2] = 0xFFFFU;
1415         sc->lance_initb.ln_multi_mask[3] = 0xFFFFU;
1416     }
1417     sc->lance_initb.ln_physaddr[0] = ((u_short *) sc->le_ac.ac_enaddr)[0];
1418     sc->lance_initb.ln_physaddr[1] = ((u_short *) sc->le_ac.ac_enaddr)[1];
1419     sc->lance_initb.ln_physaddr[2] = ((u_short *) sc->le_ac.ac_enaddr)[2];
1420     if (sc->le_if.if_flags & IFF_PROMISC) {
1421         sc->lance_initb.ln_mode |= LN_MODE_PROMISC;
1422     } else {
1423         sc->lance_initb.ln_mode &= ~LN_MODE_PROMISC;
1424     }
1425     /*
1426      * We force the init block to be at the start
1427      * of the LANCE's RAM buffer.
1428      */
1429     LN_COPYTO(sc, &sc->lance_initb, sc->le_membase, sizeof(sc->lance_initb));
1430     LN_SELCSR(sc, LN_CSR1); LN_WRCSR(sc, sc->lance_csr1);
1431     LN_SELCSR(sc, LN_CSR2); LN_WRCSR(sc, sc->lance_csr2);
1432     LN_SELCSR(sc, LN_CSR3); LN_WRCSR(sc, sc->lance_csr3);
1433
1434     /* lance_dumpcsrs(sc, "lance_reset: preinit"); */
1435
1436     /*
1437      * clear INITDONE and INIT the chip
1438      */
1439     LN_SELCSR(sc, LN_CSR0);
1440     LN_WRCSR(sc, LN_CSR0_INIT|LN_CSR0_INITDONE);
1441
1442     csr = 0;
1443     cnt = 100;
1444     while (cnt-- > 0) {
1445         if (((csr = LN_RDCSR(sc)) & LN_CSR0_INITDONE) != 0)
1446             break;
1447         DELAY(10000);
1448     }
1449
1450     if ((csr & LN_CSR0_INITDONE) == 0) {    /* make sure we got out okay */
1451         lance_dumpcsrs(sc, "lance_reset: reset failure");
1452     } else {
1453         /* lance_dumpcsrs(sc, "lance_reset: end"); */
1454         sc->le_if.if_flags |= IFF_UP;
1455         sc->le_flags |= IFF_UP;
1456     }
1457 }
1458
1459 static void
1460 lance_init(void *xsc)
1461 {
1462     struct le_softc *sc = (struct le_softc *)xsc;
1463     lance_ring_t *ri;
1464     lance_descinfo_t *di;
1465     ln_desc_t desc;
1466
1467     LN_STAT(inits++);
1468     if (sc->le_if.if_flags & IFF_RUNNING) {
1469         sc->if_reset(sc);
1470         lance_tx_intr(sc);
1471         /*
1472          * If we were running, abort any pending transmits.
1473          */
1474         ri = &sc->lance_txinfo;
1475         di = ri->ri_nextout;
1476         while (ri->ri_free < ri->ri_max) {
1477             if (--di == ri->ri_first)
1478                 di = ri->ri_nextout - 1;
1479             if (di->di_mbuf == NULL)
1480                 break;
1481             m_free(di->di_mbuf);
1482             di->di_mbuf = NULL;
1483             ri->ri_free++;
1484         }
1485     } else {
1486         sc->if_reset(sc);
1487     }
1488
1489     /*
1490      * Reset the transmit ring.  Make sure we own all the buffers.
1491      * Also reset the transmit heap.
1492      */
1493     sc->le_if.if_flags &= ~IFF_OACTIVE;
1494     ri = &sc->lance_txinfo;
1495     for (di = ri->ri_first; di < ri->ri_last; di++) {
1496         if (di->di_mbuf != NULL) {
1497             m_freem(di->di_mbuf);
1498             di->di_mbuf = NULL;
1499         }
1500         desc.d_flag = 0;
1501         desc.d_addr_lo = LN_ADDR_LO(ri->ri_heap + sc->lance_ramoffset);
1502         desc.d_addr_hi = LN_ADDR_HI(ri->ri_heap + sc->lance_ramoffset);
1503         desc.d_buflen = 0;
1504         LN_PUTDESC(sc, &desc, di->di_addr);
1505     }
1506     ri->ri_nextin = ri->ri_nextout = ri->ri_first;
1507     ri->ri_free = ri->ri_max;
1508     ri->ri_outptr = ri->ri_heap;
1509     ri->ri_outsize = ri->ri_heapend - ri->ri_heap;
1510
1511     ri = &sc->lance_rxinfo;
1512     desc.d_flag = LN_DFLAG_OWNER;
1513     desc.d_buflen = 0 - sc->lance_rxbufsize;
1514     for (di = ri->ri_first; di < ri->ri_last; di++) {
1515         desc.d_addr_lo = LN_ADDR_LO(di->di_bufaddr + sc->lance_ramoffset);
1516         desc.d_addr_hi = LN_ADDR_HI(di->di_bufaddr + sc->lance_ramoffset);
1517         LN_PUTDESC(sc, &desc, di->di_addr);
1518     }
1519     ri->ri_nextin = ri->ri_nextout = ri->ri_first;
1520     ri->ri_outptr = ri->ri_heap;
1521     ri->ri_outsize = ri->ri_heapend - ri->ri_heap;
1522     ri->ri_free = 0;
1523
1524     if (sc->le_if.if_flags & IFF_UP) {
1525         sc->le_if.if_flags |= IFF_RUNNING;
1526         LN_WRCSR(sc, LN_CSR0_START|LN_CSR0_INITDONE|LN_CSR0_ENABINTR);
1527         /* lance_dumpcsrs(sc, "lance_init: up"); */
1528         lance_start(&sc->le_if);
1529     } else {
1530         /* lance_dumpcsrs(sc, "lance_init: down"); */
1531         sc->le_if.if_flags &= ~IFF_RUNNING;
1532     }
1533 }
1534
1535 static void
1536 lance_intr(struct le_softc *sc)
1537 {
1538     unsigned oldcsr;
1539
1540     oldcsr = LN_RDCSR(sc);
1541     oldcsr &= ~LN_CSR0_ENABINTR;
1542     LN_WRCSR(sc, oldcsr);
1543     LN_WRCSR(sc, LN_CSR0_ENABINTR);
1544
1545     if (oldcsr & LN_CSR0_ERRSUM) {
1546         if (oldcsr & LN_CSR0_MISS) {
1547             /*
1548              *  LN_CSR0_MISS is signaled when the LANCE receiver
1549              *  loses a packet because it doesn't own a receive
1550              *  descriptor. Rev. D LANCE chips, which are no
1551              *  longer used, require a chip reset as described
1552              *  below.
1553              */
1554             LN_STAT(rx_misses++);
1555         }
1556         if (oldcsr & LN_CSR0_MEMERROR) {
1557             LN_STAT(memory_errors++);
1558             if (oldcsr & (LN_CSR0_RXON|LN_CSR0_TXON)) {
1559                 lance_init(sc);
1560                 return;
1561             }
1562         }
1563     }
1564
1565     if ((oldcsr & LN_CSR0_RXINT) && lance_rx_intr(sc)) {
1566         lance_init(sc);
1567         return;
1568     }
1569
1570     if (oldcsr & LN_CSR0_TXINT) {
1571         if (lance_tx_intr(sc))
1572             lance_start(&sc->le_if);
1573     }
1574
1575     if (oldcsr == (LN_CSR0_PENDINTR|LN_CSR0_RXON|LN_CSR0_TXON))
1576         if_printf(&sc->le_if, "lance_intr: stray interrupt\n");
1577 }
1578
1579 static int
1580 lance_rx_intr(struct le_softc *sc)
1581 {
1582     lance_ring_t *ri = &sc->lance_rxinfo;
1583     lance_descinfo_t *eop;
1584     ln_desc_t desc;
1585     int ndescs, total_len, rxdescs;
1586
1587     LN_STAT(rx_intrs++);
1588
1589     for (rxdescs = 0;;) {
1590         /*
1591          * Now to try to find the end of this packet chain.
1592          */
1593         for (ndescs = 1, eop = ri->ri_nextin;; ndescs++) {
1594             /*
1595              * If we don't own this descriptor, the packet ain't
1596              * all here so return because we are done.
1597              */
1598             LN_GETDESC(sc, &desc, eop->di_addr);
1599             if (desc.d_flag & LN_DFLAG_OWNER)
1600                 return 0;
1601             /*
1602              * In case we have missed a packet and gotten the
1603              * LANCE confused, make sure we are pointing at the
1604              * start of a packet. If we aren't, something is really
1605              * strange so reinit the LANCE.
1606              */
1607             if (desc.d_flag & LN_DFLAG_RxBUFERROR) {
1608                 LN_STAT(rx_buferror++);
1609                 return 1;
1610             }
1611             if ((desc.d_flag & LN_DFLAG_SOP) && eop != ri->ri_nextin) {
1612                 LN_STAT(rx_badsop++);
1613                 return 1;
1614             }
1615             if (desc.d_flag & LN_DFLAG_EOP)
1616                 break;
1617             if (++eop == ri->ri_last)
1618                 eop = ri->ri_first;
1619         }
1620
1621         total_len = (desc.d_status & LN_DSTS_RxLENMASK) - 4;
1622         if ((desc.d_flag & LN_DFLAG_RxERRSUM) == 0) {
1623             /*
1624              * Valid Packet -- If the SOP is less than or equal to the EOP
1625              * or the length is less than the receive buffer size, then the
1626              * packet is contiguous in memory and can be copied in one shot.
1627              * Otherwise we need to copy two segments to get the entire
1628              * packet.
1629              */
1630             if (ri->ri_nextin <= eop || total_len <= ri->ri_heapend - ri->ri_nextin->di_bufaddr) {
1631                 le_input(sc, sc->le_membase + ri->ri_nextin->di_bufaddr,
1632                          total_len, total_len, NULL);
1633                 LN_STAT(rx_contig++);
1634             } else {
1635                 le_input(sc, sc->le_membase + ri->ri_nextin->di_bufaddr,
1636                          total_len,
1637                          ri->ri_heapend - ri->ri_nextin->di_bufaddr,
1638                          sc->le_membase + ri->ri_first->di_bufaddr);
1639                 LN_STAT(rx_noncontig++);
1640             }
1641         } else {
1642             /*
1643              * If the packet is bad, increment the
1644              * counters.
1645              */
1646             sc->le_if.if_ierrors++;
1647             if (desc.d_flag & LN_DFLAG_RxBADCRC)
1648                 LN_STAT(rx_badcrc++);
1649             if (desc.d_flag & LN_DFLAG_RxOVERFLOW)
1650                 LN_STAT(rx_badalign++);
1651             if (desc.d_flag & LN_DFLAG_RxFRAMING)
1652                 LN_STAT(rx_badframe++);
1653         }
1654         sc->le_if.if_ipackets++;
1655         LN_STAT(rx_ndescs[ndescs-1]++);
1656         rxdescs += ndescs;
1657         while (ndescs-- > 0) {
1658             LN_SETFLAG(sc, ri->ri_nextin->di_addr, LN_DFLAG_OWNER);
1659             if (++ri->ri_nextin == ri->ri_last)
1660                 ri->ri_nextin = ri->ri_first;
1661         }
1662     }
1663     /* LN_STAT(rx_intr_descs[rxdescs]++); */
1664     LN_MAXSTAT(rx_intr_hidescs, rxdescs);
1665
1666     return 0;
1667 }
1668
1669 static void
1670 lance_start(struct ifnet *ifp)
1671 {
1672     struct le_softc *sc = (struct le_softc *) ifp;
1673     lance_ring_t *ri = &sc->lance_txinfo;
1674     lance_descinfo_t *di;
1675     ln_desc_t desc;
1676     unsigned len, slop;
1677     struct mbuf *m, *m0;
1678     caddr_t bp;
1679
1680     if ((ifp->if_flags & IFF_RUNNING) == 0)
1681         return;
1682
1683     for (;;) {
1684         m = ifq_poll(&ifp->if_snd);
1685         if (m == NULL)
1686             break;
1687
1688         /*
1689          * Make the packet meets the minimum size for Ethernet.
1690          * The slop is so that we also use an even number of longwards.
1691          */
1692         len = ETHERMIN + sizeof(struct ether_header);
1693         if (m->m_pkthdr.len > len)
1694             len = m->m_pkthdr.len;
1695
1696         slop = (8 - len) & 3;
1697         /*
1698          * If there are no free ring entries (there must be always
1699          * one owned by the host), or there's not enough space for
1700          * this packet, or this packet would wrap around the end
1701          * of LANCE RAM then wait for the transmits to empty for
1702          * space and ring entries to become available.
1703          */
1704         if (ri->ri_free == 1 || len + slop > ri->ri_outsize) {
1705             /*
1706              * Try to see if we can free up anything off the transit ring.
1707              */
1708             if (lance_tx_intr(sc) > 0) {
1709                 LN_STAT(tx_drains[0]++);
1710                 continue;
1711             }
1712             LN_STAT(tx_nospc[0]++);
1713             break;
1714         }
1715
1716         if (len + slop > ri->ri_heapend - ri->ri_outptr) {
1717             /*
1718              * Since the packet won't fit in the end of the transmit
1719              * heap, see if there is space at the beginning of the transmit
1720              * heap.  If not, try again when there is space.
1721              */
1722             LN_STAT(tx_orphaned++);
1723             slop += ri->ri_heapend - ri->ri_outptr;
1724             if (len + slop > ri->ri_outsize) {
1725                 LN_STAT(tx_nospc[1]++);
1726                 break;
1727             }
1728             /*
1729              * Point to the beginning of the heap
1730              */
1731             ri->ri_outptr = ri->ri_heap;
1732             LN_STAT(tx_adoptions++);
1733         }
1734
1735         /*
1736          * Initialize the descriptor (saving the buffer address,
1737          * buffer length, and mbuf) and write the packet out
1738          * to the board.
1739          */
1740         di = ri->ri_nextout;
1741         di->di_bufaddr = ri->ri_outptr;
1742         di->di_buflen = len + slop;
1743         di->di_mbuf = m;
1744         bp = sc->le_membase + di->di_bufaddr;
1745         for (m0 = m; m0 != NULL; m0 = m0->m_next) {
1746             LN_COPYTO(sc, mtod(m0, caddr_t), bp, m0->m_len);
1747             bp += m0->m_len;
1748         }
1749         /*
1750          * Zero out the remainder if needed (< ETHERMIN).
1751          */
1752         if (m->m_pkthdr.len < len)
1753             LN_ZERO(sc, bp, len - m->m_pkthdr.len);
1754
1755         m = ifq_dequeue(&ifp->if_snd);
1756
1757         /*
1758          * Finally, copy out the descriptor and tell the
1759          * LANCE to transmit!.
1760          */
1761         desc.d_buflen = 0 - len;
1762         desc.d_addr_lo = LN_ADDR_LO(di->di_bufaddr + sc->lance_ramoffset);
1763         desc.d_addr_hi = LN_ADDR_HI(di->di_bufaddr + sc->lance_ramoffset);
1764         desc.d_flag = LN_DFLAG_SOP|LN_DFLAG_EOP|LN_DFLAG_OWNER;
1765         LN_PUTDESC(sc, &desc, di->di_addr);
1766         LN_WRCSR(sc, LN_CSR0_TXDEMAND|LN_CSR0_ENABINTR);
1767
1768         /*
1769          * Do our bookkeeping with our transmit heap.
1770          * (if we wrap, point back to the beginning).
1771          */
1772         ri->ri_outptr += di->di_buflen;
1773         ri->ri_outsize -= di->di_buflen;
1774         LN_MAXSTAT(high_txoutptr, ri->ri_outptr);
1775         LN_MINSTAT(low_txheapsize, ri->ri_outsize);
1776
1777         if (ri->ri_outptr == ri->ri_heapend)
1778             ri->ri_outptr = ri->ri_heap;
1779
1780         ri->ri_free--;
1781         if (++ri->ri_nextout == ri->ri_last)
1782             ri->ri_nextout = ri->ri_first;
1783         LN_MINSTAT(low_txfree, ri->ri_free);
1784     }
1785     if (m != NULL)
1786         ifp->if_flags |= IFF_OACTIVE;
1787 }
1788
1789 static int
1790 lance_tx_intr(struct le_softc *sc)
1791 {
1792     lance_ring_t *ri = &sc->lance_txinfo;
1793     unsigned xmits;
1794
1795     LN_STAT(tx_intrs++);
1796     for (xmits = 0; ri->ri_free < ri->ri_max; ) {
1797         ln_desc_t desc;
1798
1799         LN_GETDESC(sc, &desc, ri->ri_nextin->di_addr);
1800         if (desc.d_flag & LN_DFLAG_OWNER)
1801             break;
1802
1803         if (desc.d_flag & (LN_DFLAG_TxONECOLL|LN_DFLAG_TxMULTCOLL))
1804             sc->le_if.if_collisions++;
1805         if (desc.d_flag & LN_DFLAG_TxDEFERRED)
1806             LN_STAT(tx_deferred++);
1807         if (desc.d_flag & LN_DFLAG_TxONECOLL)
1808             LN_STAT(tx_single_collisions++);
1809         if (desc.d_flag & LN_DFLAG_TxMULTCOLL)
1810             LN_STAT(tx_multiple_collisions++);
1811
1812         if (desc.d_flag & LN_DFLAG_TxERRSUM) {
1813             if (desc.d_status & (LN_DSTS_TxUNDERFLOW|LN_DSTS_TxBUFERROR|
1814                                  LN_DSTS_TxEXCCOLL|LN_DSTS_TxLATECOLL)) {
1815                 if (desc.d_status & LN_DSTS_TxEXCCOLL) {
1816                     unsigned tdr;
1817                     LN_STAT(tx_excessive_collisions++);
1818                     if ((tdr = (desc.d_status & LN_DSTS_TxTDRMASK)) > 0) {
1819                         tdr *= 100;
1820                         if_printf(&sc->le_if, "lance: warning: excessive collisions: TDR %dns (%d-%dm)\n",
1821                                tdr, (tdr*99)/1000, (tdr*117)/1000);
1822                     }
1823                 }
1824                 if (desc.d_status & LN_DSTS_TxBUFERROR)
1825                     LN_STAT(tx_buferror++);
1826                 sc->le_if.if_oerrors++;
1827                 if ((desc.d_status & LN_DSTS_TxLATECOLL) == 0) {
1828                     lance_init(sc);
1829                     return 0;
1830                 } else {
1831                     LN_STAT(tx_late_collisions++);
1832                 }
1833             }
1834         }
1835         m_freem(ri->ri_nextin->di_mbuf);
1836         ri->ri_nextin->di_mbuf = NULL;
1837         sc->le_if.if_opackets++;
1838         ri->ri_free++;
1839         ri->ri_outsize += ri->ri_nextin->di_buflen;
1840         if (++ri->ri_nextin == ri->ri_last)
1841             ri->ri_nextin = ri->ri_first;
1842         sc->le_if.if_flags &= ~IFF_OACTIVE;
1843         xmits++;
1844     }
1845     if (ri->ri_free == ri->ri_max)
1846         LN_STAT(tx_emptied++);
1847     /* LN_STAT(tx_intr_descs[xmits]++); */
1848     LN_MAXSTAT(tx_intr_hidescs, xmits);
1849     return xmits;
1850 }