2 * Copyright (c) 1994 Matt Thomas (thomas@lkg.dec.com)
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 * 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
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.
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.37 2006/12/23 00:26:20 swildner Exp $
29 * DEC EtherWORKS 2 Ethernet Controllers
30 * DEC EtherWORKS 3 Ethernet Controllers
32 * Written by Matt Thomas
33 * BPF support code stolen directly from if_ec.c
35 * This driver supports the DEPCA, DE100, DE101, DE200, DE201,
36 * DE2002, DE203, DE204, DE205, and DE422 cards.
43 #include <sys/param.h>
44 #include <sys/systm.h>
47 #include <sys/socket.h>
48 #include <sys/sockio.h>
49 #include <sys/malloc.h>
50 #include <sys/linker_set.h>
51 #include <sys/module.h>
52 #include <sys/serialize.h>
54 #include <sys/thread2.h>
56 #include <net/ethernet.h>
58 #include <net/ifq_var.h>
59 #include <net/if_types.h>
60 #include <net/if_dl.h>
62 #include <netinet/in.h>
63 #include <netinet/if_ether.h>
65 #include <bus/isa/i386/isa_device.h>
66 #include <machine_base/icu/icu.h>
73 typedef u_short le_mcbits_t
;
74 #define LE_MC_NBPW_LOG2 4
75 #define LE_MC_NBPW (1 << LE_MC_NBPW_LOG2)
80 int (*bd_probe
)(struct le_softc
*sc
, const struct le_board
*bd
, int *msize
);
84 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
86 * Start of DEC EtherWORKS III (LEMAC) dependent structures
89 #include <machine_base/isa/ic/lemac.h> /* Include LEMAC definitions */
91 DECLARE_DUMMY_MODULE(if_le
);
93 static int lemac_probe(struct le_softc
*sc
, const struct le_board
*bd
, int *msize
);
95 struct le_lemac_info
{
96 u_int lemac__lastpage
; /* last 2K page */
97 u_int lemac__memmode
; /* Are we in 2K, 32K, or 64K mode */
98 u_int lemac__membase
; /* Physical address of start of RAM */
99 u_int lemac__txctl
; /* Transmit Control Byte */
100 u_int lemac__txmax
; /* Maximum # of outstanding transmits */
101 le_mcbits_t lemac__mctbl
[LEMAC_MCTBL_SIZE
/sizeof(le_mcbits_t
)];
102 /* local copy of multicast table */
103 u_char lemac__eeprom
[LEMAC_EEP_SIZE
]; /* local copy eeprom */
104 char lemac__prodname
[LEMAC_EEP_PRDNMSZ
+1]; /* prodname name */
105 #define lemac_lastpage le_un.un_lemac.lemac__lastpage
106 #define lemac_memmode le_un.un_lemac.lemac__memmode
107 #define lemac_membase le_un.un_lemac.lemac__membase
108 #define lemac_txctl le_un.un_lemac.lemac__txctl
109 #define lemac_txmax le_un.un_lemac.lemac__txmax
110 #define lemac_mctbl le_un.un_lemac.lemac__mctbl
111 #define lemac_eeprom le_un.un_lemac.lemac__eeprom
112 #define lemac_prodname le_un.un_lemac.lemac__prodname
116 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
118 * Start of DEC EtherWORKS II (LANCE) dependent structures
122 #include <machine_base/isa/ic/am7990.h>
128 static int depca_probe(struct le_softc
*sc
, const struct le_board
*bd
, int *msize
);
130 typedef struct lance_descinfo lance_descinfo_t
;
131 typedef struct lance_ring lance_ring_t
;
133 typedef unsigned lance_addr_t
;
135 struct lance_descinfo
{
136 caddr_t di_addr
; /* address of descriptor */
137 lance_addr_t di_bufaddr
; /* LANCE address of buffer owned by descriptor */
138 unsigned di_buflen
; /* size of buffer owned by descriptor */
139 struct mbuf
*di_mbuf
; /* mbuf being transmitted/received */
143 lance_descinfo_t
*ri_first
; /* Pointer to first descriptor in ring */
144 lance_descinfo_t
*ri_last
; /* Pointer to last + 1 descriptor in ring */
145 lance_descinfo_t
*ri_nextin
; /* Pointer to next one to be given to HOST */
146 lance_descinfo_t
*ri_nextout
; /* Pointer to next one to be given to LANCE */
147 unsigned ri_max
; /* Size of Ring - 1 */
148 unsigned ri_free
; /* Number of free rings entires (owned by HOST) */
149 lance_addr_t ri_heap
; /* Start of RAM for this ring */
150 lance_addr_t ri_heapend
; /* End + 1 of RAM for this ring */
151 lance_addr_t ri_outptr
; /* Pointer to first output byte */
152 unsigned ri_outsize
; /* Space remaining for output */
155 struct le_lance_info
{
156 unsigned lance__csr1
; /* LANCE Address of init block (low 16) */
157 unsigned lance__csr2
; /* LANCE Address of init block (high 8) */
158 unsigned lance__csr3
; /* Copy of CSR3 */
159 unsigned lance__rap
; /* IO Port Offset of RAP */
160 unsigned lance__rdp
; /* IO Port Offset of RDP */
161 unsigned lance__ramoffset
; /* Offset to valid LANCE RAM */
162 unsigned lance__ramsize
; /* Amount of RAM shared by LANCE */
163 unsigned lance__rxbufsize
; /* Size of a receive buffer */
164 ln_initb_t lance__initb
; /* local copy of LANCE initblock */
165 ln_initb_t
*lance__raminitb
; /* copy to board's LANCE initblock (debugging) */
166 ln_desc_t
*lance__ramdesc
; /* copy to board's LANCE descriptors (debugging) */
167 lance_ring_t lance__rxinfo
; /* Receive ring information */
168 lance_ring_t lance__txinfo
; /* Transmit ring information */
169 #define lance_csr1 le_un.un_lance.lance__csr1
170 #define lance_csr2 le_un.un_lance.lance__csr2
171 #define lance_csr3 le_un.un_lance.lance__csr3
172 #define lance_rap le_un.un_lance.lance__rap
173 #define lance_rdp le_un.un_lance.lance__rdp
174 #define lance_ramoffset le_un.un_lance.lance__ramoffset
175 #define lance_ramsize le_un.un_lance.lance__ramsize
176 #define lance_rxbufsize le_un.un_lance.lance__rxbufsize
177 #define lance_initb le_un.un_lance.lance__initb
178 #define lance_raminitb le_un.un_lance.lance__raminitb
179 #define lance_ramdesc le_un.un_lance.lance__ramdesc
180 #define lance_rxinfo le_un.un_lance.lance__rxinfo
181 #define lance_txinfo le_un.un_lance.lance__txinfo
185 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
187 * Start of Common Code
191 static void (*le_intrvec
[NLE
])(struct le_softc
*sc
);
194 * Ethernet status, per interface.
197 struct arpcom le_ac
; /* Common Ethernet/ARP Structure */
198 void (*if_init
) (void *);/* Interface init routine */
199 void (*if_reset
) (struct le_softc
*);/* Interface reset routine */
200 caddr_t le_membase
; /* Starting memory address (virtual) */
201 unsigned le_iobase
; /* Starting I/O base address */
202 unsigned le_irq
; /* Interrupt Request Value */
203 unsigned le_flags
; /* local copy of if_flags */
204 #define LE_BRDCSTONLY 0x01000000 /* If only broadcast is enabled */
205 u_int le_mcmask
; /* bit mask for CRC-32 for multicast hash */
206 le_mcbits_t
*le_mctbl
; /* pointer to multicast table */
207 const char *le_prodname
; /* product name DE20x-xx */
208 u_char le_hwaddr
[6]; /* local copy of hwaddr */
210 struct le_lemac_info un_lemac
; /* LEMAC specific information */
211 struct le_lance_info un_lance
; /* Am7990 specific information */
214 #define le_if le_ac.ac_if
217 static int le_probe(struct isa_device
*dvp
);
218 static int le_attach(struct isa_device
*dvp
);
219 static void le_intr(void *);
220 static int le_ioctl(struct ifnet
*ifp
, u_long command
, caddr_t data
,
222 static void le_input(struct le_softc
*sc
, caddr_t seg1
, size_t total_len
,
223 size_t len2
, caddr_t seg2
);
224 static void le_multi_filter(struct le_softc
*sc
);
225 static void le_multi_op(struct le_softc
*sc
, const u_char
*mca
, int oper_flg
);
226 static int le_read_macaddr(struct le_softc
*sc
, int ioreg
, int skippat
);
228 static struct le_softc le_softc
[NLE
];
230 static const struct le_board le_boards
[] = {
231 { lemac_probe
}, /* DE20[345] */
232 { depca_probe
}, /* DE{20[012],422} */
233 { NULL
} /* Must Be Last! */
236 static struct lwkt_serialize le_serialize
;
239 * This tells the autoconf code how to set us up.
241 struct isa_driver ledriver
= {
242 le_probe
, le_attach
, "le",
245 static unsigned le_intrs
[NLE
];
247 #define LE_INL(sc, reg) inl((sc)->le_iobase + (reg))
248 #define LE_OUTL(sc, reg, data) outl((sc)->le_iobase + (reg), data)
249 #define LE_INW(sc, reg) inw((sc)->le_iobase + (reg))
250 #define LE_OUTW(sc, reg, data) outw((sc)->le_iobase + (reg), data)
251 #define LE_INB(sc, reg) inb((sc)->le_iobase + (reg))
252 #define LE_OUTB(sc, reg, data) outb((sc)->le_iobase + (reg), data)
255 le_probe(struct isa_device
*dvp
)
257 struct le_softc
*sc
= &le_softc
[dvp
->id_unit
];
258 const struct le_board
*bd
;
261 lwkt_serialize_init(&le_serialize
);
263 if (dvp
->id_unit
>= NLE
) {
264 kprintf("%s%d not configured -- too many devices\n",
265 ledriver
.name
, dvp
->id_unit
);
269 sc
->le_iobase
= dvp
->id_iobase
;
270 sc
->le_membase
= (u_char
*) dvp
->id_maddr
;
271 sc
->le_irq
= dvp
->id_irq
;
272 if_initname(&(sc
->le_if
), ledriver
.name
, dvp
->id_unit
);
275 * Find and Initialize board..
278 sc
->le_flags
&= ~(IFF_UP
|IFF_ALLMULTI
);
280 for (bd
= le_boards
; bd
->bd_probe
!= NULL
; bd
++) {
281 if ((iospace
= (*bd
->bd_probe
)(sc
, bd
, &dvp
->id_msize
)) != 0) {
290 le_attach(struct isa_device
*dvp
)
292 struct le_softc
*sc
= &le_softc
[dvp
->id_unit
];
293 struct ifnet
*ifp
= &sc
->le_if
;
295 dvp
->id_intr
= (inthand2_t
*)le_intr
;
297 ifp
->if_mtu
= ETHERMTU
;
299 ifp
->if_flags
= IFF_BROADCAST
| IFF_SIMPLEX
| IFF_MULTICAST
;
300 ifp
->if_ioctl
= le_ioctl
;
301 ifp
->if_type
= IFT_ETHER
;
304 ifp
->if_init
= sc
->if_init
;
305 ifp
->if_baudrate
= 10000000;
306 ifq_set_maxlen(&ifp
->if_snd
, IFQ_MAXLEN
);
307 ifq_set_ready(&ifp
->if_snd
);
309 ether_ifattach(ifp
, sc
->le_ac
.ac_enaddr
, &le_serialize
);
319 lwkt_serialize_enter(&le_serialize
);
321 (*le_intrvec
[unit
])(&le_softc
[unit
]);
322 lwkt_serialize_exit(&le_serialize
);
328 le_input(struct le_softc
*sc
, caddr_t seg1
, size_t total_len
,
329 size_t len1
, caddr_t seg2
)
333 m
= m_getl(total_len
+ LE_XTRA
, MB_DONTWAIT
, MT_DATA
, M_PKTHDR
, NULL
);
335 sc
->le_if
.if_ierrors
++;
338 m
->m_data
+= LE_XTRA
;
339 m
->m_len
= m
->m_pkthdr
.len
= total_len
;
341 bcopy(seg1
, mtod(m
, caddr_t
), len1
);
343 bcopy(seg2
, mtod(m
, caddr_t
) + len1
, total_len
- len1
);
344 sc
->le_if
.if_input(&sc
->le_if
, m
);
348 le_ioctl(struct ifnet
*ifp
, u_long cmd
, caddr_t data
, struct ucred
*cr
)
350 struct le_softc
*sc
= ifp
->if_softc
;
353 if ((sc
->le_flags
& IFF_UP
) == 0)
365 * Update multicast listeners
372 error
= ether_ioctl(ifp
, cmd
, data
);
379 * This is the standard method of reading the DEC Address ROMS.
380 * I don't understand it but it does work.
383 le_read_macaddr(struct le_softc
*sc
, int ioreg
, int skippat
)
385 int cksum
, rom_cksum
;
388 int idx
, idx2
, found
, octet
;
389 static u_char testpat
[] = { 0xFF, 0, 0x55, 0xAA, 0xFF, 0, 0x55, 0xAA };
392 for (idx
= 0; idx
< 32; idx
++) {
393 octet
= LE_INB(sc
, ioreg
);
395 if (octet
== testpat
[idx2
]) {
396 if (++idx2
== sizeof testpat
) {
410 sc
->le_hwaddr
[0] = LE_INB(sc
, ioreg
);
411 sc
->le_hwaddr
[1] = LE_INB(sc
, ioreg
);
413 cksum
= *(u_short
*) &sc
->le_hwaddr
[0];
415 sc
->le_hwaddr
[2] = LE_INB(sc
, ioreg
);
416 sc
->le_hwaddr
[3] = LE_INB(sc
, ioreg
);
418 if (cksum
> 65535) cksum
-= 65535;
419 cksum
+= *(u_short
*) &sc
->le_hwaddr
[2];
420 if (cksum
> 65535) cksum
-= 65535;
422 sc
->le_hwaddr
[4] = LE_INB(sc
, ioreg
);
423 sc
->le_hwaddr
[5] = LE_INB(sc
, ioreg
);
425 if (cksum
> 65535) cksum
-= 65535;
426 cksum
+= *(u_short
*) &sc
->le_hwaddr
[4];
427 if (cksum
>= 65535) cksum
-= 65535;
429 rom_cksum
= LE_INB(sc
, ioreg
);
430 rom_cksum
|= LE_INB(sc
, ioreg
) << 8;
432 if (cksum
!= rom_cksum
)
438 le_multi_filter(struct le_softc
*sc
)
440 struct ifnet
*ifp
= &sc
->le_ac
.ac_if
;
441 struct ifmultiaddr
*ifma
;
443 bzero(sc
->le_mctbl
, (sc
->le_mcmask
+ 1) / 8);
445 if (sc
->le_if
.if_flags
& IFF_ALLMULTI
) {
446 sc
->le_flags
|= IFF_MULTICAST
|IFF_ALLMULTI
;
449 sc
->le_flags
&= ~IFF_MULTICAST
;
450 /* if (interface has had an address assigned) { */
451 le_multi_op(sc
, ifp
->if_broadcastaddr
, TRUE
);
452 sc
->le_flags
|= LE_BRDCSTONLY
|IFF_MULTICAST
;
455 sc
->le_flags
|= IFF_MULTICAST
;
457 LIST_FOREACH(ifma
, &ifp
->if_multiaddrs
, ifma_link
) {
458 if (ifma
->ifma_addr
->sa_family
!= AF_LINK
)
461 le_multi_op(sc
, LLADDR((struct sockaddr_dl
*)ifma
->ifma_addr
), 1);
462 sc
->le_flags
&= ~LE_BRDCSTONLY
;
467 le_multi_op(struct le_softc
*sc
, const u_char
*mca
, int enable
)
469 uint32_t bit
, idx
, crc
;
471 crc
= ether_crc32_le(mca
, ETHER_ADDR_LEN
);
474 * The following two line convert the N bit index into a longword index
475 * and a longword mask.
477 crc
&= sc
->le_mcmask
;
478 bit
= 1 << (crc
& (LE_MC_NBPW
-1));
479 idx
= crc
>> (LE_MC_NBPW_LOG2
);
482 * Set or clear hash filter bit in our table.
485 sc
->le_mctbl
[idx
] |= bit
; /* Set Bit */
487 sc
->le_mctbl
[idx
] &= ~bit
; /* Clear Bit */
492 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
494 * Start of DEC EtherWORKS III (LEMAC) dependent code
498 #define LEMAC_INTR_ENABLE(sc) \
499 LE_OUTB(sc, LEMAC_REG_IC, LE_INB(sc, LEMAC_REG_IC) | LEMAC_IC_ALL)
501 #define LEMAC_INTR_DISABLE(sc) \
502 LE_OUTB(sc, LEMAC_REG_IC, LE_INB(sc, LEMAC_REG_IC) & ~LEMAC_IC_ALL)
504 #define LEMAC_64K_MODE(mbase) (((mbase) >= 0x0A) && ((mbase) <= 0x0F))
505 #define LEMAC_32K_MODE(mbase) (((mbase) >= 0x14) && ((mbase) <= 0x1F))
506 #define LEMAC_2K_MODE(mbase) ( (mbase) >= 0x40)
508 static void lemac_init(void *xsc
);
509 static void lemac_start(struct ifnet
*ifp
);
510 static void lemac_reset(struct le_softc
*sc
);
511 static void lemac_intr(struct le_softc
*sc
);
512 static void lemac_rne_intr(struct le_softc
*sc
);
513 static void lemac_tne_intr(struct le_softc
*sc
);
514 static void lemac_txd_intr(struct le_softc
*sc
, unsigned cs_value
);
515 static void lemac_rxd_intr(struct le_softc
*sc
, unsigned cs_value
);
516 static int lemac_read_eeprom(struct le_softc
*sc
);
517 static void lemac_init_adapmem(struct le_softc
*sc
);
519 #define LE_MCBITS_ALL_1S ((le_mcbits_t)~(le_mcbits_t)0)
521 static const le_mcbits_t lemac_allmulti_mctbl
[16] = {
522 LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
,
523 LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
,
524 LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
,
525 LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
, LE_MCBITS_ALL_1S
,
528 * An IRQ mapping table. Less space than switch statement.
530 static const int lemac_irqs
[] = { ICU_IRQ5
, ICU_IRQ10
, ICU_IRQ11
, ICU_IRQ15
};
533 * Some tuning/monitoring variables.
535 static unsigned lemac_deftxmax
= 16; /* see lemac_max above */
536 static unsigned lemac_txnospc
= 0; /* total # of tranmit starvations */
538 static unsigned lemac_tne_intrs
= 0; /* total # of tranmit done intrs */
539 static unsigned lemac_rne_intrs
= 0; /* total # of receive done intrs */
540 static unsigned lemac_txd_intrs
= 0; /* total # of tranmit error intrs */
541 static unsigned lemac_rxd_intrs
= 0; /* total # of receive error intrs */
544 lemac_probe(struct le_softc
*sc
, const struct le_board
*bd
, int *msize
)
548 LE_OUTB(sc
, LEMAC_REG_IOP
, LEMAC_IOP_EEINIT
);
549 DELAY(LEMAC_EEP_DELAY
);
552 * Read Ethernet address if card is present.
554 if (le_read_macaddr(sc
, LEMAC_REG_APD
, 0) < 0)
557 bcopy(sc
->le_hwaddr
, sc
->le_ac
.ac_enaddr
, ETHER_ADDR_LEN
);
559 * Clear interrupts and set IRQ.
562 portval
= LE_INB(sc
, LEMAC_REG_IC
) & LEMAC_IC_IRQMSK
;
563 irq
= lemac_irqs
[portval
>> 5];
564 LE_OUTB(sc
, LEMAC_REG_IC
, portval
);
567 * Make sure settings match.
570 if (irq
!= sc
->le_irq
) {
571 if_printf(&sc
->le_if
, "lemac configuration error: expected IRQ 0x%x actual 0x%x\n",
577 * Try to reset the unit
579 sc
->if_init
= lemac_init
;
580 sc
->le_if
.if_start
= lemac_start
;
581 sc
->if_reset
= lemac_reset
;
582 sc
->lemac_memmode
= 2;
584 if ((sc
->le_flags
& IFF_UP
) == 0)
588 * Check for correct memory base configuration.
590 if (vtophys(sc
->le_membase
) != sc
->lemac_membase
) {
591 if_printf(&sc
->le_if
, "lemac configuration error: expected iomem 0x%llx actual 0x%x\n",
592 vtophys(sc
->le_membase
), sc
->lemac_membase
);
596 sc
->le_prodname
= sc
->lemac_prodname
;
597 sc
->le_mctbl
= sc
->lemac_mctbl
;
598 sc
->le_mcmask
= (1 << LEMAC_MCTBL_BITS
) - 1;
599 sc
->lemac_txmax
= lemac_deftxmax
;
601 le_intrvec
[sc
->le_if
.if_dunit
] = lemac_intr
;
603 return LEMAC_IOSPACE
;
607 * Do a hard reset of the board;
610 lemac_reset(struct le_softc
*sc
)
612 struct ifnet
*ifp
= &sc
->le_if
;
619 sc
->le_flags
&= IFF_UP
;
620 ifp
->if_flags
&= ~IFF_OACTIVE
;
621 LEMAC_INTR_DISABLE(sc
);
623 LE_OUTB(sc
, LEMAC_REG_IOP
, LEMAC_IOP_EEINIT
);
624 DELAY(LEMAC_EEP_DELAY
);
626 /* Disable Interrupts */
627 /* LE_OUTB(sc, LEMAC_REG_IC, LE_INB(sc, LEMAC_REG_IC) & ICR_IRQ_SEL); */
630 * Read EEPROM information. NOTE - the placement of this function
631 * is important because functions hereafter may rely on information
632 * read from the EEPROM.
634 if ((cksum
= lemac_read_eeprom(sc
)) != LEMAC_EEP_CKSUM
) {
635 if_printf(ifp
, "reset: EEPROM checksum failed (0x%x)\n", cksum
);
640 * Force to 2K mode if not already configured.
643 portval
= LE_INB(sc
, LEMAC_REG_MBR
);
644 if (!LEMAC_2K_MODE(portval
)) {
645 if (LEMAC_64K_MODE(portval
)) {
646 portval
= (((portval
* 2) & 0xF) << 4);
647 sc
->lemac_memmode
= 64;
648 } else if (LEMAC_32K_MODE(portval
)) {
649 portval
= ((portval
& 0xF) << 4);
650 sc
->lemac_memmode
= 32;
652 LE_OUTB(sc
, LEMAC_REG_MBR
, portval
);
654 sc
->lemac_membase
= portval
* (2 * 1024) + (512 * 1024);
657 * Initialize Free Memory Queue, Init mcast table with broadcast.
660 lemac_init_adapmem(sc
);
661 sc
->le_flags
|= IFF_UP
;
665 lemac_init(void *xsc
)
667 struct le_softc
*sc
= (struct le_softc
*)xsc
;
669 if ((sc
->le_flags
& IFF_UP
) == 0)
673 * If the interface has the up flag
675 if (sc
->le_if
.if_flags
& IFF_UP
) {
676 int saved_cs
= LE_INB(sc
, LEMAC_REG_CS
);
677 LE_OUTB(sc
, LEMAC_REG_CS
, saved_cs
| (LEMAC_CS_TXD
| LEMAC_CS_RXD
));
678 LE_OUTB(sc
, LEMAC_REG_PA0
, sc
->le_ac
.ac_enaddr
[0]);
679 LE_OUTB(sc
, LEMAC_REG_PA1
, sc
->le_ac
.ac_enaddr
[1]);
680 LE_OUTB(sc
, LEMAC_REG_PA2
, sc
->le_ac
.ac_enaddr
[2]);
681 LE_OUTB(sc
, LEMAC_REG_PA3
, sc
->le_ac
.ac_enaddr
[3]);
682 LE_OUTB(sc
, LEMAC_REG_PA4
, sc
->le_ac
.ac_enaddr
[4]);
683 LE_OUTB(sc
, LEMAC_REG_PA5
, sc
->le_ac
.ac_enaddr
[5]);
685 LE_OUTB(sc
, LEMAC_REG_IC
, LE_INB(sc
, LEMAC_REG_IC
) | LEMAC_IC_IE
);
687 if (sc
->le_if
.if_flags
& IFF_PROMISC
) {
688 LE_OUTB(sc
, LEMAC_REG_CS
, LEMAC_CS_MCE
| LEMAC_CS_PME
);
690 LEMAC_INTR_DISABLE(sc
);
692 LE_OUTB(sc
, LEMAC_REG_MPN
, 0);
693 if ((sc
->le_flags
| sc
->le_if
.if_flags
) & IFF_ALLMULTI
) {
694 bcopy(lemac_allmulti_mctbl
, &sc
->le_membase
[LEMAC_MCTBL_OFF
], sizeof(lemac_allmulti_mctbl
));
696 bcopy(sc
->lemac_mctbl
, &sc
->le_membase
[LEMAC_MCTBL_OFF
], sizeof(sc
->lemac_mctbl
));
698 LE_OUTB(sc
, LEMAC_REG_CS
, LEMAC_CS_MCE
);
701 LE_OUTB(sc
, LEMAC_REG_CTL
, LE_INB(sc
, LEMAC_REG_CTL
) ^ LEMAC_CTL_LED
);
703 LEMAC_INTR_ENABLE(sc
);
704 sc
->le_if
.if_flags
|= IFF_RUNNING
;
706 LE_OUTB(sc
, LEMAC_REG_CS
, LEMAC_CS_RXD
|LEMAC_CS_TXD
);
708 LEMAC_INTR_DISABLE(sc
);
709 sc
->le_if
.if_flags
&= ~IFF_RUNNING
;
714 * What to do upon receipt of an interrupt.
717 lemac_intr(struct le_softc
*sc
)
721 LEMAC_INTR_DISABLE(sc
); /* Mask interrupts */
724 * Determine cause of interrupt. Receive events take
725 * priority over Transmit.
728 cs_value
= LE_INB(sc
, LEMAC_REG_CS
);
731 * Check for Receive Queue not being empty.
732 * Check for Transmit Done Queue not being empty.
735 if (cs_value
& LEMAC_CS_RNE
)
737 if (cs_value
& LEMAC_CS_TNE
)
741 * Check for Transmitter Disabled.
742 * Check for Receiver Disabled.
745 if (cs_value
& LEMAC_CS_TXD
)
746 lemac_txd_intr(sc
, cs_value
);
747 if (cs_value
& LEMAC_CS_RXD
)
748 lemac_rxd_intr(sc
, cs_value
);
751 * Toggle LED and unmask interrupts.
754 LE_OUTB(sc
, LEMAC_REG_CTL
, LE_INB(sc
, LEMAC_REG_CTL
) ^ LEMAC_CTL_LED
);
755 LEMAC_INTR_ENABLE(sc
); /* Unmask interrupts */
759 lemac_rne_intr(struct le_softc
*sc
)
761 int rxcount
, rxlen
, rxpg
;
765 rxcount
= LE_INB(sc
, LEMAC_REG_RQC
);
767 rxpg
= LE_INB(sc
, LEMAC_REG_RQ
);
768 LE_OUTB(sc
, LEMAC_REG_MPN
, rxpg
);
770 rxptr
= sc
->le_membase
;
771 sc
->le_if
.if_ipackets
++;
772 if (*rxptr
& LEMAC_RX_OK
) {
775 * Get receive length - subtract out checksum.
778 rxlen
= ((*(u_int
*)rxptr
>> 8) & 0x7FF) - 4;
779 le_input(sc
, rxptr
+ sizeof(u_int
), rxlen
, rxlen
, NULL
);
780 } else { /* end if (*rxptr & LEMAC_RX_OK) */
781 sc
->le_if
.if_ierrors
++;
783 LE_OUTB(sc
, LEMAC_REG_FMQ
, rxpg
); /* Return this page to Free Memory Queue */
784 } /* end while (recv_count--) */
788 lemac_rxd_intr(struct le_softc
*sc
, unsigned cs_value
)
791 * Handle CS_RXD (Receiver disabled) here.
793 * Check Free Memory Queue Count. If not equal to zero
794 * then just turn Receiver back on. If it is equal to
795 * zero then check to see if transmitter is disabled.
796 * Process transmit TXD loop once more. If all else
797 * fails then do software init (0xC0 to EEPROM Init)
798 * and rebuild Free Memory Queue.
804 * Re-enable Receiver.
807 cs_value
&= ~LEMAC_CS_RXD
;
808 LE_OUTB(sc
, LEMAC_REG_CS
, cs_value
);
810 if (LE_INB(sc
, LEMAC_REG_FMC
) > 0)
813 if (cs_value
& LEMAC_CS_TXD
)
814 lemac_txd_intr(sc
, cs_value
);
816 if ((LE_INB(sc
, LEMAC_REG_CS
) & LEMAC_CS_RXD
) == 0)
819 if_printf(&sc
->le_if
, "fatal RXD error, attempting recovery\n");
822 if (sc
->le_flags
& IFF_UP
) {
828 * Error during initializion. Mark card as disabled.
830 if_printf(&sc
->le_if
, "recovery failed -- board disabled\n");
834 lemac_start(struct ifnet
*ifp
)
836 struct le_softc
*sc
= (struct le_softc
*) ifp
;
838 if ((ifp
->if_flags
& IFF_RUNNING
) == 0)
841 LEMAC_INTR_DISABLE(sc
);
843 while (!ifq_is_empty(&ifp
->if_snd
)) {
848 if (LE_INB(sc
, LEMAC_REG_TQC
) >= sc
->lemac_txmax
) {
849 ifp
->if_flags
|= IFF_OACTIVE
;
853 tx_pg
= LE_INB(sc
, LEMAC_REG_FMQ
); /* get free memory page */
855 * Check for good transmit page.
857 if (tx_pg
== 0 || tx_pg
> sc
->lemac_lastpage
) {
859 ifp
->if_flags
|= IFF_OACTIVE
;
863 m
= ifq_dequeue(&ifp
->if_snd
, NULL
);
864 LE_OUTB(sc
, LEMAC_REG_MPN
, tx_pg
); /* Shift 2K window. */
867 * The first four bytes of each transmit buffer are for
868 * control information. The first byte is the control
869 * byte, then the length (why not word aligned?), then
870 * the off to the buffer.
873 txoff
= (mtod(m
, u_int
) & (sizeof(u_long
) - 1)) + LEMAC_TX_HDRSZ
;
874 txhdr
= sc
->lemac_txctl
| (m
->m_pkthdr
.len
<< 8) | (txoff
<< 24);
875 *(u_int
*) sc
->le_membase
= txhdr
;
878 * Copy the packet to the board
881 m_copydata(m
, 0, m
->m_pkthdr
.len
, sc
->le_membase
+ txoff
);
883 LE_OUTB(sc
, LEMAC_REG_TQ
, tx_pg
); /* tell chip to transmit this packet */
887 m_freem(m
); /* free the mbuf */
889 LEMAC_INTR_ENABLE(sc
);
893 lemac_tne_intr(struct le_softc
*sc
)
895 int txsts
, txcount
= LE_INB(sc
, LEMAC_REG_TDC
);
899 txsts
= LE_INB(sc
, LEMAC_REG_TDQ
);
900 sc
->le_if
.if_opackets
++; /* another one done */
901 if ((txsts
& LEMAC_TDQ_COL
) != LEMAC_TDQ_NOCOL
)
902 sc
->le_if
.if_collisions
++;
904 sc
->le_if
.if_flags
&= ~IFF_OACTIVE
;
905 lemac_start(&sc
->le_if
);
909 lemac_txd_intr(struct le_softc
*sc
, unsigned cs_value
)
912 * Read transmit status, remove transmit buffer from
913 * transmit queue and place on free memory queue,
914 * then reset transmitter.
915 * Increment appropriate counters.
919 sc
->le_if
.if_oerrors
++;
920 if (LE_INB(sc
, LEMAC_REG_TS
) & LEMAC_TS_ECL
)
921 sc
->le_if
.if_collisions
++;
922 sc
->le_if
.if_flags
&= ~IFF_OACTIVE
;
924 LE_OUTB(sc
, LEMAC_REG_FMQ
, LE_INB(sc
, LEMAC_REG_TQ
));
925 /* Get Page number and write it back out */
927 LE_OUTB(sc
, LEMAC_REG_CS
, cs_value
& ~LEMAC_CS_TXD
);
928 /* Turn back on transmitter */
932 lemac_read_eeprom(struct le_softc
*sc
)
939 ep
= sc
->lemac_eeprom
;
940 for (word_off
= 0; word_off
< LEMAC_EEP_SIZE
/ 2; word_off
++) {
941 LE_OUTB(sc
, LEMAC_REG_PI1
, word_off
);
942 LE_OUTB(sc
, LEMAC_REG_IOP
, LEMAC_IOP_EEREAD
);
944 DELAY(LEMAC_EEP_DELAY
);
946 *ep
= LE_INB(sc
, LEMAC_REG_EE1
); cksum
+= *ep
++;
947 *ep
= LE_INB(sc
, LEMAC_REG_EE2
); cksum
+= *ep
++;
951 * Set up Transmit Control Byte for use later during transmit.
954 sc
->lemac_txctl
|= LEMAC_TX_FLAGS
;
956 if ((sc
->lemac_eeprom
[LEMAC_EEP_SWFLAGS
] & LEMAC_EEP_SW_SQE
) == 0)
957 sc
->lemac_txctl
&= ~LEMAC_TX_SQE
;
959 if (sc
->lemac_eeprom
[LEMAC_EEP_SWFLAGS
] & LEMAC_EEP_SW_LAB
)
960 sc
->lemac_txctl
|= LEMAC_TX_LAB
;
962 bcopy(&sc
->lemac_eeprom
[LEMAC_EEP_PRDNM
], sc
->lemac_prodname
, LEMAC_EEP_PRDNMSZ
);
963 sc
->lemac_prodname
[LEMAC_EEP_PRDNMSZ
] = '\0';
969 lemac_init_adapmem(struct le_softc
*sc
)
973 conf
= LE_INB(sc
, LEMAC_REG_CNF
);
975 if ((sc
->lemac_eeprom
[LEMAC_EEP_SETUP
] & LEMAC_EEP_ST_DRAM
) == 0) {
976 sc
->lemac_lastpage
= 63;
977 conf
&= ~LEMAC_CNF_DRAM
;
979 sc
->lemac_lastpage
= 127;
980 conf
|= LEMAC_CNF_DRAM
;
983 LE_OUTB(sc
, LEMAC_REG_CNF
, conf
);
985 for (pg
= 1; pg
<= sc
->lemac_lastpage
; pg
++)
986 LE_OUTB(sc
, LEMAC_REG_FMQ
, pg
);
992 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
994 * Start of DEPCA (DE200/DE201/DE202/DE422 etal) support.
997 static void depca_intr(struct le_softc
*sc
);
998 static int lance_init_adapmem(struct le_softc
*sc
);
999 static int lance_init_ring(struct le_softc
*sc
, ln_ring_t
*rp
, lance_ring_t
*ri
,
1000 unsigned ndescs
, unsigned bufoffset
,
1001 unsigned descoffset
);
1002 static void lance_init(void *xsc
);
1003 static void lance_reset(struct le_softc
*sc
);
1004 static void lance_intr(struct le_softc
*sc
);
1005 static int lance_rx_intr(struct le_softc
*sc
);
1006 static void lance_start(struct ifnet
*ifp
);
1007 static int lance_tx_intr(struct le_softc
*sc
);
1009 #define LN_BUFSIZE /* 380 */ 304 /* 1520 / 4 */
1010 #define LN_TXDESC_RATIO 2048
1011 #define LN_DESC_MAX 128
1015 unsigned lance_rx_misses
;
1016 unsigned lance_rx_badcrc
;
1017 unsigned lance_rx_badalign
;
1018 unsigned lance_rx_badframe
;
1019 unsigned lance_rx_buferror
;
1020 unsigned lance_tx_deferred
;
1021 unsigned lance_tx_single_collisions
;
1022 unsigned lance_tx_multiple_collisions
;
1023 unsigned lance_tx_excessive_collisions
;
1024 unsigned lance_tx_late_collisions
;
1026 unsigned lance_memory_errors
;
1027 unsigned lance_inits
;
1028 unsigned lance_tx_intrs
;
1029 unsigned lance_tx_nospc
[2];
1030 unsigned lance_tx_drains
[2];
1031 unsigned lance_tx_orphaned
;
1032 unsigned lance_tx_adoptions
;
1033 unsigned lance_tx_emptied
;
1034 unsigned lance_tx_deftxint
;
1035 unsigned lance_tx_buferror
;
1036 unsigned lance_high_txoutptr
;
1037 unsigned lance_low_txheapsize
;
1038 unsigned lance_low_txfree
;
1039 unsigned lance_tx_intr_hidescs
;
1040 /* unsigned lance_tx_intr_descs[LN_DESC_MAX]; */
1042 unsigned lance_rx_intrs
;
1043 unsigned lance_rx_badsop
;
1044 unsigned lance_rx_contig
;
1045 unsigned lance_rx_noncontig
;
1046 unsigned lance_rx_intr_hidescs
;
1047 unsigned lance_rx_ndescs
[4096 / LN_BUFSIZE
];
1048 /* unsigned lance_rx_intr_descs[LN_DESC_MAX]; */
1051 #define LN_STAT(stat) (lance_stats.lance_ ## stat)
1052 #define LN_MINSTAT(stat, val) (LN_STAT(stat > (val)) ? LN_STAT(stat = (val)) : 0)
1053 #define LN_MAXSTAT(stat, val) (LN_STAT(stat < (val)) ? LN_STAT(stat = (val)) : 0)
1056 #define LN_STAT(stat) 0
1057 #define LN_MINSTAT(stat, val) 0
1058 #define LN_MAXSTAT(stat, val) 0
1061 #define LN_SELCSR(sc, csrno) (LE_OUTW(sc, sc->lance_rap, csrno))
1062 #define LN_INQCSR(sc) (LE_INW(sc, sc->lance_rap))
1064 #define LN_WRCSR(sc, val) (LE_OUTW(sc, sc->lance_rdp, val))
1065 #define LN_RDCSR(sc) (LE_INW(sc, sc->lance_rdp))
1068 #define LN_ZERO(sc, vaddr, len) bzero(vaddr, len)
1069 #define LN_COPYTO(sc, from, to, len) bcopy(from, to, len)
1071 #define LN_SETFLAG(sc, vaddr, val) \
1072 (((volatile u_char *) vaddr)[3] = (val))
1074 #define LN_PUTDESC(sc, desc, vaddr) \
1075 (((volatile u_short *) vaddr)[0] = ((u_short *) desc)[0], \
1076 ((volatile u_short *) vaddr)[2] = ((u_short *) desc)[2], \
1077 ((volatile u_short *) vaddr)[1] = ((u_short *) desc)[1])
1080 * Only get the descriptor flags and length/status. All else
1083 #define LN_GETDESC(sc, desc, vaddr) \
1084 (((u_short *) desc)[1] = ((volatile u_short *) vaddr)[1], \
1085 ((u_short *) desc)[3] = ((volatile u_short *) vaddr)[3])
1088 * These definitions are specific to the DEC "DEPCA-style" NICs.
1089 * (DEPCA, DE10x, DE20[012], DE422)
1092 #define DEPCA_REG_NICSR 0 /* (RW;16) NI Control / Status */
1093 #define DEPCA_REG_RDP 4 /* (RW:16) LANCE RDP (data) register */
1094 #define DEPCA_REG_RAP 6 /* (RW:16) LANCE RAP (address) register */
1095 #define DEPCA_REG_ADDRROM 12 /* (R : 8) DEPCA Ethernet Address ROM */
1096 #define DEPCA_IOSPACE 16 /* DEPCAs use 16 bytes of IO space */
1098 #define DEPCA_NICSR_LED 0x0001 /* Light the LED on the back of the DEPCA */
1099 #define DEPCA_NICSR_ENABINTR 0x0002 /* Enable Interrupts */
1100 #define DEPCA_NICSR_MASKINTR 0x0004 /* Mask Interrupts */
1101 #define DEPCA_NICSR_AAC 0x0008 /* Address Counter Clear */
1102 #define DEPCA_NICSR_REMOTEBOOT 0x0010 /* Remote Boot Enabled (ignored) */
1103 #define DEPCA_NICSR_32KRAM 0x0020 /* DEPCA LANCE RAM size 64K (C) / 32K (S) */
1104 #define DEPCA_NICSR_LOW32K 0x0040 /* Bank Select (A15 = !This Bit) */
1105 #define DEPCA_NICSR_SHE 0x0080 /* Shared RAM Enabled (ie hide ROM) */
1106 #define DEPCA_NICSR_BOOTTMO 0x0100 /* Remote Boot Timeout (ignored) */
1108 #define DEPCA_RDNICSR(sc) (LE_INW(sc, DEPCA_REG_NICSR))
1109 #define DEPCA_WRNICSR(sc, val) (LE_OUTW(sc, DEPCA_REG_NICSR, val))
1111 #define DEPCA_IDSTR_OFFSET 0xC006 /* ID String Offset */
1113 #define DEPCA_REG_EISAID 0x80
1114 #define DEPCA_EISAID_MASK 0xf0ffffff
1115 #define DEPCA_EISAID_DE422 0x2042A310
1119 DEPCA_DE100
, DEPCA_DE101
,
1121 DEPCA_DE200
, DEPCA_DE201
, DEPCA_DE202
,
1126 static const char *depca_signatures
[] = {
1130 "DE200", "DE201", "DE202",
1136 depca_probe(struct le_softc
*sc
, const struct le_board
*bd
, int *msize
)
1138 unsigned nicsr
, idx
, idstr_offset
= DEPCA_IDSTR_OFFSET
;
1141 * Find out how memory we are dealing with. Adjust
1142 * the ID string offset approriately if we are at
1143 * 32K. Make sure the ROM is enabled.
1145 nicsr
= DEPCA_RDNICSR(sc
);
1146 nicsr
&= ~(DEPCA_NICSR_SHE
|DEPCA_NICSR_LED
|DEPCA_NICSR_ENABINTR
);
1148 if (nicsr
& DEPCA_NICSR_32KRAM
) {
1150 * Make we are going to read the upper
1151 * 32K so we do read the ROM.
1153 sc
->lance_ramsize
= 32 * 1024;
1154 nicsr
&= ~DEPCA_NICSR_LOW32K
;
1155 sc
->lance_ramoffset
= 32 * 1024;
1156 idstr_offset
-= sc
->lance_ramsize
;
1158 sc
->lance_ramsize
= 64 * 1024;
1159 sc
->lance_ramoffset
= 0;
1161 DEPCA_WRNICSR(sc
, nicsr
);
1163 sc
->le_prodname
= NULL
;
1164 for (idx
= 0; depca_signatures
[idx
] != NULL
; idx
++) {
1165 if (bcmp(depca_signatures
[idx
], sc
->le_membase
+ idstr_offset
, 5) == 0) {
1166 sc
->le_prodname
= depca_signatures
[idx
];
1171 if (sc
->le_prodname
== NULL
) {
1173 * Try to get the EISA device if it's a DE422.
1175 if (sc
->le_iobase
> 0x1000 && (sc
->le_iobase
& 0x0F00) == 0x0C00
1176 && (LE_INL(sc
, DEPCA_REG_EISAID
) & DEPCA_EISAID_MASK
)
1177 == DEPCA_EISAID_DE422
) {
1178 sc
->le_prodname
= "DE422";
1183 if (idx
== DEPCA_CLASSIC
)
1184 sc
->lance_ramsize
-= 16384; /* Can't use the ROM area on a DEPCA */
1187 * Try to read the address ROM.
1188 * Stop the LANCE, reset the Address ROM Counter (AAC),
1189 * read the NICSR to "clock" in the reset, and then
1190 * re-enable the Address ROM Counter. Now read the
1193 sc
->lance_rdp
= DEPCA_REG_RDP
;
1194 sc
->lance_rap
= DEPCA_REG_RAP
;
1195 sc
->lance_csr3
= LN_CSR3_ALE
;
1196 sc
->le_mctbl
= sc
->lance_initb
.ln_multi_mask
;
1197 sc
->le_mcmask
= LN_MC_MASK
;
1198 LN_SELCSR(sc
, LN_CSR0
);
1199 LN_WRCSR(sc
, LN_CSR0_STOP
);
1201 if (idx
< DEPCA_DE200
) {
1202 DEPCA_WRNICSR(sc
, DEPCA_RDNICSR(sc
) & ~DEPCA_NICSR_AAC
);
1203 DEPCA_WRNICSR(sc
, DEPCA_RDNICSR(sc
) | DEPCA_NICSR_AAC
);
1206 if (le_read_macaddr(sc
, DEPCA_REG_ADDRROM
, idx
== DEPCA_CLASSIC
) < 0)
1209 bcopy(sc
->le_hwaddr
, sc
->le_ac
.ac_enaddr
, ETHER_ADDR_LEN
);
1211 * Renable shared RAM.
1213 DEPCA_WRNICSR(sc
, DEPCA_RDNICSR(sc
) | DEPCA_NICSR_SHE
);
1215 le_intrvec
[sc
->le_if
.if_dunit
] = depca_intr
;
1216 if (!lance_init_adapmem(sc
))
1219 sc
->if_reset
= lance_reset
;
1220 sc
->if_init
= lance_init
;
1221 sc
->le_if
.if_start
= lance_start
;
1222 DEPCA_WRNICSR(sc
, DEPCA_NICSR_SHE
| DEPCA_NICSR_ENABINTR
);
1225 LN_STAT(low_txfree
= sc
->lance_txinfo
.ri_max
);
1226 LN_STAT(low_txheapsize
= 0xFFFFFFFF);
1227 *msize
= sc
->lance_ramsize
;
1228 return DEPCA_IOSPACE
;
1232 depca_intr(struct le_softc
*sc
)
1234 DEPCA_WRNICSR(sc
, DEPCA_RDNICSR(sc
) ^ DEPCA_NICSR_LED
);
1239 * Here's as good a place to describe our paritioning of the
1240 * LANCE shared RAM space. (NOTE: this driver does not yet support
1241 * the concept of a LANCE being able to DMA).
1243 * First is the 24 (00:23) bytes for LANCE Initialization Block
1244 * Next are the recieve descriptors. The number is calculated from
1245 * how many LN_BUFSIZE buffers we can allocate (this number must
1246 * be a power of 2). Next are the transmit descriptors. The amount
1247 * of transmit descriptors is derived from the size of the RAM
1248 * divided by 1K. Now come the receive buffers (one for each receive
1249 * descriptor). Finally is the transmit heap. (no fixed buffers are
1250 * allocated so as to make the most use of the limited space).
1253 lance_init_adapmem(struct le_softc
*sc
)
1255 lance_addr_t rxbufoffset
;
1256 lance_addr_t rxdescoffset
, txdescoffset
;
1257 unsigned rxdescs
, txdescs
;
1260 * First calculate how many descriptors we heap.
1261 * Note this assumes the ramsize is a power of two.
1263 sc
->lance_rxbufsize
= LN_BUFSIZE
;
1265 while (rxdescs
* sc
->lance_rxbufsize
< sc
->lance_ramsize
)
1268 if (rxdescs
> LN_DESC_MAX
) {
1269 sc
->lance_rxbufsize
*= rxdescs
/ LN_DESC_MAX
;
1270 rxdescs
= LN_DESC_MAX
;
1272 txdescs
= sc
->lance_ramsize
/ LN_TXDESC_RATIO
;
1273 if (txdescs
> LN_DESC_MAX
)
1274 txdescs
= LN_DESC_MAX
;
1277 * Now calculate where everything goes in memory
1279 rxdescoffset
= sizeof(ln_initb_t
);
1280 txdescoffset
= rxdescoffset
+ sizeof(ln_desc_t
) * rxdescs
;
1281 rxbufoffset
= txdescoffset
+ sizeof(ln_desc_t
) * txdescs
;
1283 sc
->le_mctbl
= (le_mcbits_t
*) sc
->lance_initb
.ln_multi_mask
;
1285 * Remember these for debugging.
1287 sc
->lance_raminitb
= (ln_initb_t
*) sc
->le_membase
;
1288 sc
->lance_ramdesc
= (ln_desc_t
*) (sc
->le_membase
+ rxdescoffset
);
1291 * Initialize the rings.
1293 if (!lance_init_ring(sc
, &sc
->lance_initb
.ln_rxring
, &sc
->lance_rxinfo
,
1294 rxdescs
, rxbufoffset
, rxdescoffset
))
1296 sc
->lance_rxinfo
.ri_heap
= rxbufoffset
;
1297 sc
->lance_rxinfo
.ri_heapend
= rxbufoffset
+ sc
->lance_rxbufsize
* rxdescs
;
1299 if (!lance_init_ring(sc
, &sc
->lance_initb
.ln_txring
, &sc
->lance_txinfo
,
1300 txdescs
, 0, txdescoffset
))
1302 sc
->lance_txinfo
.ri_heap
= sc
->lance_rxinfo
.ri_heapend
;
1303 sc
->lance_txinfo
.ri_heapend
= sc
->lance_ramsize
;
1306 * Set CSR1 and CSR2 to the address of the init block (which
1307 * for us is always 0.
1309 sc
->lance_csr1
= LN_ADDR_LO(0 + sc
->lance_ramoffset
);
1310 sc
->lance_csr2
= LN_ADDR_HI(0 + sc
->lance_ramoffset
);
1315 lance_init_ring(struct le_softc
*sc
, ln_ring_t
*rp
, lance_ring_t
*ri
,
1316 unsigned ndescs
, lance_addr_t bufoffset
, lance_addr_t descoffset
)
1318 lance_descinfo_t
*di
;
1321 * Initialize the ring pointer in the LANCE InitBlock
1323 rp
->r_addr_lo
= LN_ADDR_LO(descoffset
+ sc
->lance_ramoffset
);
1324 rp
->r_addr_hi
= LN_ADDR_HI(descoffset
+ sc
->lance_ramoffset
);
1325 rp
->r_log2_size
= ffs(ndescs
) - 1;
1328 * Allocate the ring entry descriptors and initialize
1329 * our ring information data structure. All these are
1330 * our copies and do not live in the LANCE RAM.
1332 ri
->ri_first
= kmalloc(ndescs
* sizeof(*di
), M_DEVBUF
, M_WAITOK
);
1333 ri
->ri_free
= ri
->ri_max
= ndescs
;
1334 ri
->ri_last
= ri
->ri_first
+ ri
->ri_max
;
1335 for (di
= ri
->ri_first
; di
< ri
->ri_last
; di
++) {
1336 di
->di_addr
= sc
->le_membase
+ descoffset
;
1339 di
->di_bufaddr
= bufoffset
;
1340 di
->di_buflen
= sc
->lance_rxbufsize
;
1341 bufoffset
+= sc
->lance_rxbufsize
;
1343 descoffset
+= sizeof(ln_desc_t
);
1349 lance_dumpcsrs(struct le_softc
*sc
, const char *id
)
1351 if_printf(&sc
->le_if
, "%s: nicsr=%04x", id
, DEPCA_RDNICSR(sc
));
1352 LN_SELCSR(sc
, LN_CSR0
);
1353 kprintf(" csr0=%04x", LN_RDCSR(sc
));
1354 LN_SELCSR(sc
, LN_CSR1
);
1355 kprintf(" csr1=%04x", LN_RDCSR(sc
));
1356 LN_SELCSR(sc
, LN_CSR2
);
1357 kprintf(" csr2=%04x", LN_RDCSR(sc
));
1358 LN_SELCSR(sc
, LN_CSR3
);
1359 kprintf(" csr3=%04x\n", LN_RDCSR(sc
));
1360 LN_SELCSR(sc
, LN_CSR0
);
1364 lance_reset(struct le_softc
*sc
)
1368 /* lance_dumpcsrs(sc, "lance_reset: start"); */
1370 LN_WRCSR(sc
, LN_RDCSR(sc
) & ~LN_CSR0_ENABINTR
);
1371 LN_WRCSR(sc
, LN_CSR0_STOP
);
1374 sc
->le_flags
&= ~IFF_UP
;
1375 sc
->le_if
.if_flags
&= ~(IFF_UP
|IFF_RUNNING
);
1377 le_multi_filter(sc
); /* initialize the multicast table */
1378 if ((sc
->le_flags
| sc
->le_if
.if_flags
) & IFF_ALLMULTI
) {
1379 sc
->lance_initb
.ln_multi_mask
[0] = 0xFFFFU
;
1380 sc
->lance_initb
.ln_multi_mask
[1] = 0xFFFFU
;
1381 sc
->lance_initb
.ln_multi_mask
[2] = 0xFFFFU
;
1382 sc
->lance_initb
.ln_multi_mask
[3] = 0xFFFFU
;
1384 sc
->lance_initb
.ln_physaddr
[0] = ((u_short
*) sc
->le_ac
.ac_enaddr
)[0];
1385 sc
->lance_initb
.ln_physaddr
[1] = ((u_short
*) sc
->le_ac
.ac_enaddr
)[1];
1386 sc
->lance_initb
.ln_physaddr
[2] = ((u_short
*) sc
->le_ac
.ac_enaddr
)[2];
1387 if (sc
->le_if
.if_flags
& IFF_PROMISC
) {
1388 sc
->lance_initb
.ln_mode
|= LN_MODE_PROMISC
;
1390 sc
->lance_initb
.ln_mode
&= ~LN_MODE_PROMISC
;
1393 * We force the init block to be at the start
1394 * of the LANCE's RAM buffer.
1396 LN_COPYTO(sc
, &sc
->lance_initb
, sc
->le_membase
, sizeof(sc
->lance_initb
));
1397 LN_SELCSR(sc
, LN_CSR1
); LN_WRCSR(sc
, sc
->lance_csr1
);
1398 LN_SELCSR(sc
, LN_CSR2
); LN_WRCSR(sc
, sc
->lance_csr2
);
1399 LN_SELCSR(sc
, LN_CSR3
); LN_WRCSR(sc
, sc
->lance_csr3
);
1401 /* lance_dumpcsrs(sc, "lance_reset: preinit"); */
1404 * clear INITDONE and INIT the chip
1406 LN_SELCSR(sc
, LN_CSR0
);
1407 LN_WRCSR(sc
, LN_CSR0_INIT
|LN_CSR0_INITDONE
);
1412 if (((csr
= LN_RDCSR(sc
)) & LN_CSR0_INITDONE
) != 0)
1417 if ((csr
& LN_CSR0_INITDONE
) == 0) { /* make sure we got out okay */
1418 lance_dumpcsrs(sc
, "lance_reset: reset failure");
1420 /* lance_dumpcsrs(sc, "lance_reset: end"); */
1421 sc
->le_if
.if_flags
|= IFF_UP
;
1422 sc
->le_flags
|= IFF_UP
;
1427 lance_init(void *xsc
)
1429 struct le_softc
*sc
= (struct le_softc
*)xsc
;
1431 lance_descinfo_t
*di
;
1435 if (sc
->le_if
.if_flags
& IFF_RUNNING
) {
1439 * If we were running, abort any pending transmits.
1441 ri
= &sc
->lance_txinfo
;
1442 di
= ri
->ri_nextout
;
1443 while (ri
->ri_free
< ri
->ri_max
) {
1444 if (--di
== ri
->ri_first
)
1445 di
= ri
->ri_nextout
- 1;
1446 if (di
->di_mbuf
== NULL
)
1448 m_free(di
->di_mbuf
);
1457 * Reset the transmit ring. Make sure we own all the buffers.
1458 * Also reset the transmit heap.
1460 sc
->le_if
.if_flags
&= ~IFF_OACTIVE
;
1461 ri
= &sc
->lance_txinfo
;
1462 for (di
= ri
->ri_first
; di
< ri
->ri_last
; di
++) {
1463 if (di
->di_mbuf
!= NULL
) {
1464 m_freem(di
->di_mbuf
);
1468 desc
.d_addr_lo
= LN_ADDR_LO(ri
->ri_heap
+ sc
->lance_ramoffset
);
1469 desc
.d_addr_hi
= LN_ADDR_HI(ri
->ri_heap
+ sc
->lance_ramoffset
);
1471 LN_PUTDESC(sc
, &desc
, di
->di_addr
);
1473 ri
->ri_nextin
= ri
->ri_nextout
= ri
->ri_first
;
1474 ri
->ri_free
= ri
->ri_max
;
1475 ri
->ri_outptr
= ri
->ri_heap
;
1476 ri
->ri_outsize
= ri
->ri_heapend
- ri
->ri_heap
;
1478 ri
= &sc
->lance_rxinfo
;
1479 desc
.d_flag
= LN_DFLAG_OWNER
;
1480 desc
.d_buflen
= 0 - sc
->lance_rxbufsize
;
1481 for (di
= ri
->ri_first
; di
< ri
->ri_last
; di
++) {
1482 desc
.d_addr_lo
= LN_ADDR_LO(di
->di_bufaddr
+ sc
->lance_ramoffset
);
1483 desc
.d_addr_hi
= LN_ADDR_HI(di
->di_bufaddr
+ sc
->lance_ramoffset
);
1484 LN_PUTDESC(sc
, &desc
, di
->di_addr
);
1486 ri
->ri_nextin
= ri
->ri_nextout
= ri
->ri_first
;
1487 ri
->ri_outptr
= ri
->ri_heap
;
1488 ri
->ri_outsize
= ri
->ri_heapend
- ri
->ri_heap
;
1491 if (sc
->le_if
.if_flags
& IFF_UP
) {
1492 sc
->le_if
.if_flags
|= IFF_RUNNING
;
1493 LN_WRCSR(sc
, LN_CSR0_START
|LN_CSR0_INITDONE
|LN_CSR0_ENABINTR
);
1494 /* lance_dumpcsrs(sc, "lance_init: up"); */
1495 lance_start(&sc
->le_if
);
1497 /* lance_dumpcsrs(sc, "lance_init: down"); */
1498 sc
->le_if
.if_flags
&= ~IFF_RUNNING
;
1503 lance_intr(struct le_softc
*sc
)
1507 oldcsr
= LN_RDCSR(sc
);
1508 oldcsr
&= ~LN_CSR0_ENABINTR
;
1509 LN_WRCSR(sc
, oldcsr
);
1510 LN_WRCSR(sc
, LN_CSR0_ENABINTR
);
1512 if (oldcsr
& LN_CSR0_ERRSUM
) {
1513 if (oldcsr
& LN_CSR0_MISS
) {
1515 * LN_CSR0_MISS is signaled when the LANCE receiver
1516 * loses a packet because it doesn't own a receive
1517 * descriptor. Rev. D LANCE chips, which are no
1518 * longer used, require a chip reset as described
1521 LN_STAT(rx_misses
++);
1523 if (oldcsr
& LN_CSR0_MEMERROR
) {
1524 LN_STAT(memory_errors
++);
1525 if (oldcsr
& (LN_CSR0_RXON
|LN_CSR0_TXON
)) {
1532 if ((oldcsr
& LN_CSR0_RXINT
) && lance_rx_intr(sc
)) {
1537 if (oldcsr
& LN_CSR0_TXINT
) {
1538 if (lance_tx_intr(sc
))
1539 lance_start(&sc
->le_if
);
1542 if (oldcsr
== (LN_CSR0_PENDINTR
|LN_CSR0_RXON
|LN_CSR0_TXON
))
1543 if_printf(&sc
->le_if
, "lance_intr: stray interrupt\n");
1547 lance_rx_intr(struct le_softc
*sc
)
1549 lance_ring_t
*ri
= &sc
->lance_rxinfo
;
1550 lance_descinfo_t
*eop
;
1552 int ndescs
, total_len
, rxdescs
;
1554 LN_STAT(rx_intrs
++);
1556 for (rxdescs
= 0;;) {
1558 * Now to try to find the end of this packet chain.
1560 for (ndescs
= 1, eop
= ri
->ri_nextin
;; ndescs
++) {
1562 * If we don't own this descriptor, the packet ain't
1563 * all here so return because we are done.
1565 LN_GETDESC(sc
, &desc
, eop
->di_addr
);
1566 if (desc
.d_flag
& LN_DFLAG_OWNER
)
1569 * In case we have missed a packet and gotten the
1570 * LANCE confused, make sure we are pointing at the
1571 * start of a packet. If we aren't, something is really
1572 * strange so reinit the LANCE.
1574 if (desc
.d_flag
& LN_DFLAG_RxBUFERROR
) {
1575 LN_STAT(rx_buferror
++);
1578 if ((desc
.d_flag
& LN_DFLAG_SOP
) && eop
!= ri
->ri_nextin
) {
1579 LN_STAT(rx_badsop
++);
1582 if (desc
.d_flag
& LN_DFLAG_EOP
)
1584 if (++eop
== ri
->ri_last
)
1588 total_len
= (desc
.d_status
& LN_DSTS_RxLENMASK
) - 4;
1589 if ((desc
.d_flag
& LN_DFLAG_RxERRSUM
) == 0) {
1591 * Valid Packet -- If the SOP is less than or equal to the EOP
1592 * or the length is less than the receive buffer size, then the
1593 * packet is contiguous in memory and can be copied in one shot.
1594 * Otherwise we need to copy two segments to get the entire
1597 if (ri
->ri_nextin
<= eop
|| total_len
<= ri
->ri_heapend
- ri
->ri_nextin
->di_bufaddr
) {
1598 le_input(sc
, sc
->le_membase
+ ri
->ri_nextin
->di_bufaddr
,
1599 total_len
, total_len
, NULL
);
1600 LN_STAT(rx_contig
++);
1602 le_input(sc
, sc
->le_membase
+ ri
->ri_nextin
->di_bufaddr
,
1604 ri
->ri_heapend
- ri
->ri_nextin
->di_bufaddr
,
1605 sc
->le_membase
+ ri
->ri_first
->di_bufaddr
);
1606 LN_STAT(rx_noncontig
++);
1610 * If the packet is bad, increment the
1613 sc
->le_if
.if_ierrors
++;
1614 if (desc
.d_flag
& LN_DFLAG_RxBADCRC
)
1615 LN_STAT(rx_badcrc
++);
1616 if (desc
.d_flag
& LN_DFLAG_RxOVERFLOW
)
1617 LN_STAT(rx_badalign
++);
1618 if (desc
.d_flag
& LN_DFLAG_RxFRAMING
)
1619 LN_STAT(rx_badframe
++);
1621 sc
->le_if
.if_ipackets
++;
1622 LN_STAT(rx_ndescs
[ndescs
-1]++);
1624 while (ndescs
-- > 0) {
1625 LN_SETFLAG(sc
, ri
->ri_nextin
->di_addr
, LN_DFLAG_OWNER
);
1626 if (++ri
->ri_nextin
== ri
->ri_last
)
1627 ri
->ri_nextin
= ri
->ri_first
;
1630 /* LN_STAT(rx_intr_descs[rxdescs]++); */
1631 LN_MAXSTAT(rx_intr_hidescs
, rxdescs
);
1637 lance_start(struct ifnet
*ifp
)
1639 struct le_softc
*sc
= (struct le_softc
*) ifp
;
1640 lance_ring_t
*ri
= &sc
->lance_txinfo
;
1641 lance_descinfo_t
*di
;
1644 struct mbuf
*m
, *m0
;
1647 if ((ifp
->if_flags
& IFF_RUNNING
) == 0)
1651 m
= ifq_poll(&ifp
->if_snd
);
1656 * Make the packet meets the minimum size for Ethernet.
1657 * The slop is so that we also use an even number of longwards.
1659 len
= ETHERMIN
+ sizeof(struct ether_header
);
1660 if (m
->m_pkthdr
.len
> len
)
1661 len
= m
->m_pkthdr
.len
;
1663 slop
= (8 - len
) & 3;
1665 * If there are no free ring entries (there must be always
1666 * one owned by the host), or there's not enough space for
1667 * this packet, or this packet would wrap around the end
1668 * of LANCE RAM then wait for the transmits to empty for
1669 * space and ring entries to become available.
1671 if (ri
->ri_free
== 1 || len
+ slop
> ri
->ri_outsize
) {
1673 * Try to see if we can free up anything off the transit ring.
1675 if (lance_tx_intr(sc
) > 0) {
1676 LN_STAT(tx_drains
[0]++);
1679 LN_STAT(tx_nospc
[0]++);
1683 if (len
+ slop
> ri
->ri_heapend
- ri
->ri_outptr
) {
1685 * Since the packet won't fit in the end of the transmit
1686 * heap, see if there is space at the beginning of the transmit
1687 * heap. If not, try again when there is space.
1689 LN_STAT(tx_orphaned
++);
1690 slop
+= ri
->ri_heapend
- ri
->ri_outptr
;
1691 if (len
+ slop
> ri
->ri_outsize
) {
1692 LN_STAT(tx_nospc
[1]++);
1696 * Point to the beginning of the heap
1698 ri
->ri_outptr
= ri
->ri_heap
;
1699 LN_STAT(tx_adoptions
++);
1703 * Initialize the descriptor (saving the buffer address,
1704 * buffer length, and mbuf) and write the packet out
1707 di
= ri
->ri_nextout
;
1708 di
->di_bufaddr
= ri
->ri_outptr
;
1709 di
->di_buflen
= len
+ slop
;
1711 bp
= sc
->le_membase
+ di
->di_bufaddr
;
1712 for (m0
= m
; m0
!= NULL
; m0
= m0
->m_next
) {
1713 LN_COPYTO(sc
, mtod(m0
, caddr_t
), bp
, m0
->m_len
);
1717 * Zero out the remainder if needed (< ETHERMIN).
1719 if (m
->m_pkthdr
.len
< len
)
1720 LN_ZERO(sc
, bp
, len
- m
->m_pkthdr
.len
);
1722 ifq_dequeue(&ifp
->if_snd
, m
);
1725 * Finally, copy out the descriptor and tell the
1726 * LANCE to transmit!.
1728 desc
.d_buflen
= 0 - len
;
1729 desc
.d_addr_lo
= LN_ADDR_LO(di
->di_bufaddr
+ sc
->lance_ramoffset
);
1730 desc
.d_addr_hi
= LN_ADDR_HI(di
->di_bufaddr
+ sc
->lance_ramoffset
);
1731 desc
.d_flag
= LN_DFLAG_SOP
|LN_DFLAG_EOP
|LN_DFLAG_OWNER
;
1732 LN_PUTDESC(sc
, &desc
, di
->di_addr
);
1733 LN_WRCSR(sc
, LN_CSR0_TXDEMAND
|LN_CSR0_ENABINTR
);
1736 * Do our bookkeeping with our transmit heap.
1737 * (if we wrap, point back to the beginning).
1739 ri
->ri_outptr
+= di
->di_buflen
;
1740 ri
->ri_outsize
-= di
->di_buflen
;
1741 LN_MAXSTAT(high_txoutptr
, ri
->ri_outptr
);
1742 LN_MINSTAT(low_txheapsize
, ri
->ri_outsize
);
1744 if (ri
->ri_outptr
== ri
->ri_heapend
)
1745 ri
->ri_outptr
= ri
->ri_heap
;
1748 if (++ri
->ri_nextout
== ri
->ri_last
)
1749 ri
->ri_nextout
= ri
->ri_first
;
1750 LN_MINSTAT(low_txfree
, ri
->ri_free
);
1753 ifp
->if_flags
|= IFF_OACTIVE
;
1757 lance_tx_intr(struct le_softc
*sc
)
1759 lance_ring_t
*ri
= &sc
->lance_txinfo
;
1762 LN_STAT(tx_intrs
++);
1763 for (xmits
= 0; ri
->ri_free
< ri
->ri_max
; ) {
1766 LN_GETDESC(sc
, &desc
, ri
->ri_nextin
->di_addr
);
1767 if (desc
.d_flag
& LN_DFLAG_OWNER
)
1770 if (desc
.d_flag
& (LN_DFLAG_TxONECOLL
|LN_DFLAG_TxMULTCOLL
))
1771 sc
->le_if
.if_collisions
++;
1772 if (desc
.d_flag
& LN_DFLAG_TxDEFERRED
)
1773 LN_STAT(tx_deferred
++);
1774 if (desc
.d_flag
& LN_DFLAG_TxONECOLL
)
1775 LN_STAT(tx_single_collisions
++);
1776 if (desc
.d_flag
& LN_DFLAG_TxMULTCOLL
)
1777 LN_STAT(tx_multiple_collisions
++);
1779 if (desc
.d_flag
& LN_DFLAG_TxERRSUM
) {
1780 if (desc
.d_status
& (LN_DSTS_TxUNDERFLOW
|LN_DSTS_TxBUFERROR
|
1781 LN_DSTS_TxEXCCOLL
|LN_DSTS_TxLATECOLL
)) {
1782 if (desc
.d_status
& LN_DSTS_TxEXCCOLL
) {
1784 LN_STAT(tx_excessive_collisions
++);
1785 if ((tdr
= (desc
.d_status
& LN_DSTS_TxTDRMASK
)) > 0) {
1787 if_printf(&sc
->le_if
, "lance: warning: excessive collisions: TDR %dns (%d-%dm)\n",
1788 tdr
, (tdr
*99)/1000, (tdr
*117)/1000);
1791 if (desc
.d_status
& LN_DSTS_TxBUFERROR
)
1792 LN_STAT(tx_buferror
++);
1793 sc
->le_if
.if_oerrors
++;
1794 if ((desc
.d_status
& LN_DSTS_TxLATECOLL
) == 0) {
1798 LN_STAT(tx_late_collisions
++);
1802 m_freem(ri
->ri_nextin
->di_mbuf
);
1803 ri
->ri_nextin
->di_mbuf
= NULL
;
1804 sc
->le_if
.if_opackets
++;
1806 ri
->ri_outsize
+= ri
->ri_nextin
->di_buflen
;
1807 if (++ri
->ri_nextin
== ri
->ri_last
)
1808 ri
->ri_nextin
= ri
->ri_first
;
1809 sc
->le_if
.if_flags
&= ~IFF_OACTIVE
;
1812 if (ri
->ri_free
== ri
->ri_max
)
1813 LN_STAT(tx_emptied
++);
1814 /* LN_STAT(tx_intr_descs[xmits]++); */
1815 LN_MAXSTAT(tx_intr_hidescs
, xmits
);