xref: /freebsd/sys/dev/re/if_re.c (revision d2b677bb1ad8b7b83a1a54d988de291088d165a5)
1098ca2bdSWarner Losh /*-
2a94100faSBill Paul  * Copyright (c) 1997, 1998-2003
3a94100faSBill Paul  *	Bill Paul <wpaul@windriver.com>.  All rights reserved.
4a94100faSBill Paul  *
5a94100faSBill Paul  * Redistribution and use in source and binary forms, with or without
6a94100faSBill Paul  * modification, are permitted provided that the following conditions
7a94100faSBill Paul  * are met:
8a94100faSBill Paul  * 1. Redistributions of source code must retain the above copyright
9a94100faSBill Paul  *    notice, this list of conditions and the following disclaimer.
10a94100faSBill Paul  * 2. Redistributions in binary form must reproduce the above copyright
11a94100faSBill Paul  *    notice, this list of conditions and the following disclaimer in the
12a94100faSBill Paul  *    documentation and/or other materials provided with the distribution.
13a94100faSBill Paul  * 3. All advertising materials mentioning features or use of this software
14a94100faSBill Paul  *    must display the following acknowledgement:
15a94100faSBill Paul  *	This product includes software developed by Bill Paul.
16a94100faSBill Paul  * 4. Neither the name of the author nor the names of any co-contributors
17a94100faSBill Paul  *    may be used to endorse or promote products derived from this software
18a94100faSBill Paul  *    without specific prior written permission.
19a94100faSBill Paul  *
20a94100faSBill Paul  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21a94100faSBill Paul  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22a94100faSBill Paul  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23a94100faSBill Paul  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24a94100faSBill Paul  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25a94100faSBill Paul  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26a94100faSBill Paul  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27a94100faSBill Paul  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28a94100faSBill Paul  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29a94100faSBill Paul  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30a94100faSBill Paul  * THE POSSIBILITY OF SUCH DAMAGE.
31a94100faSBill Paul  */
32a94100faSBill Paul 
334dc52c32SDavid E. O'Brien #include <sys/cdefs.h>
344dc52c32SDavid E. O'Brien __FBSDID("$FreeBSD$");
354dc52c32SDavid E. O'Brien 
36a94100faSBill Paul /*
37a94100faSBill Paul  * RealTek 8139C+/8169/8169S/8110S PCI NIC driver
38a94100faSBill Paul  *
39a94100faSBill Paul  * Written by Bill Paul <wpaul@windriver.com>
40a94100faSBill Paul  * Senior Networking Software Engineer
41a94100faSBill Paul  * Wind River Systems
42a94100faSBill Paul  */
43a94100faSBill Paul 
44a94100faSBill Paul /*
45a94100faSBill Paul  * This driver is designed to support RealTek's next generation of
46a94100faSBill Paul  * 10/100 and 10/100/1000 PCI ethernet controllers. There are currently
47a94100faSBill Paul  * four devices in this family: the RTL8139C+, the RTL8169, the RTL8169S
48a94100faSBill Paul  * and the RTL8110S.
49a94100faSBill Paul  *
50a94100faSBill Paul  * The 8139C+ is a 10/100 ethernet chip. It is backwards compatible
51a94100faSBill Paul  * with the older 8139 family, however it also supports a special
52a94100faSBill Paul  * C+ mode of operation that provides several new performance enhancing
53a94100faSBill Paul  * features. These include:
54a94100faSBill Paul  *
55a94100faSBill Paul  *	o Descriptor based DMA mechanism. Each descriptor represents
56a94100faSBill Paul  *	  a single packet fragment. Data buffers may be aligned on
57a94100faSBill Paul  *	  any byte boundary.
58a94100faSBill Paul  *
59a94100faSBill Paul  *	o 64-bit DMA
60a94100faSBill Paul  *
61a94100faSBill Paul  *	o TCP/IP checksum offload for both RX and TX
62a94100faSBill Paul  *
63a94100faSBill Paul  *	o High and normal priority transmit DMA rings
64a94100faSBill Paul  *
65a94100faSBill Paul  *	o VLAN tag insertion and extraction
66a94100faSBill Paul  *
67a94100faSBill Paul  *	o TCP large send (segmentation offload)
68a94100faSBill Paul  *
69a94100faSBill Paul  * Like the 8139, the 8139C+ also has a built-in 10/100 PHY. The C+
70a94100faSBill Paul  * programming API is fairly straightforward. The RX filtering, EEPROM
71a94100faSBill Paul  * access and PHY access is the same as it is on the older 8139 series
72a94100faSBill Paul  * chips.
73a94100faSBill Paul  *
74a94100faSBill Paul  * The 8169 is a 64-bit 10/100/1000 gigabit ethernet MAC. It has almost the
75a94100faSBill Paul  * same programming API and feature set as the 8139C+ with the following
76a94100faSBill Paul  * differences and additions:
77a94100faSBill Paul  *
78a94100faSBill Paul  *	o 1000Mbps mode
79a94100faSBill Paul  *
80a94100faSBill Paul  *	o Jumbo frames
81a94100faSBill Paul  *
82a94100faSBill Paul  *	o GMII and TBI ports/registers for interfacing with copper
83a94100faSBill Paul  *	  or fiber PHYs
84a94100faSBill Paul  *
85a94100faSBill Paul  *	o RX and TX DMA rings can have up to 1024 descriptors
86a94100faSBill Paul  *	  (the 8139C+ allows a maximum of 64)
87a94100faSBill Paul  *
88a94100faSBill Paul  *	o Slight differences in register layout from the 8139C+
89a94100faSBill Paul  *
90a94100faSBill Paul  * The TX start and timer interrupt registers are at different locations
91a94100faSBill Paul  * on the 8169 than they are on the 8139C+. Also, the status word in the
92a94100faSBill Paul  * RX descriptor has a slightly different bit layout. The 8169 does not
93a94100faSBill Paul  * have a built-in PHY. Most reference boards use a Marvell 88E1000 'Alaska'
94a94100faSBill Paul  * copper gigE PHY.
95a94100faSBill Paul  *
96a94100faSBill Paul  * The 8169S/8110S 10/100/1000 devices have built-in copper gigE PHYs
97a94100faSBill Paul  * (the 'S' stands for 'single-chip'). These devices have the same
98a94100faSBill Paul  * programming API as the older 8169, but also have some vendor-specific
99a94100faSBill Paul  * registers for the on-board PHY. The 8110S is a LAN-on-motherboard
100a94100faSBill Paul  * part designed to be pin-compatible with the RealTek 8100 10/100 chip.
101a94100faSBill Paul  *
102a94100faSBill Paul  * This driver takes advantage of the RX and TX checksum offload and
103a94100faSBill Paul  * VLAN tag insertion/extraction features. It also implements TX
104a94100faSBill Paul  * interrupt moderation using the timer interrupt registers, which
105a94100faSBill Paul  * significantly reduces TX interrupt load. There is also support
106a94100faSBill Paul  * for jumbo frames, however the 8169/8169S/8110S can not transmit
10722a11c96SJohn-Mark Gurney  * jumbo frames larger than 7440, so the max MTU possible with this
10822a11c96SJohn-Mark Gurney  * driver is 7422 bytes.
109a94100faSBill Paul  */
110a94100faSBill Paul 
111a94100faSBill Paul #include <sys/param.h>
112a94100faSBill Paul #include <sys/endian.h>
113a94100faSBill Paul #include <sys/systm.h>
114a94100faSBill Paul #include <sys/sockio.h>
115a94100faSBill Paul #include <sys/mbuf.h>
116a94100faSBill Paul #include <sys/malloc.h>
117fe12f24bSPoul-Henning Kamp #include <sys/module.h>
118a94100faSBill Paul #include <sys/kernel.h>
119a94100faSBill Paul #include <sys/socket.h>
120a94100faSBill Paul 
121a94100faSBill Paul #include <net/if.h>
122a94100faSBill Paul #include <net/if_arp.h>
123a94100faSBill Paul #include <net/ethernet.h>
124a94100faSBill Paul #include <net/if_dl.h>
125a94100faSBill Paul #include <net/if_media.h>
126a94100faSBill Paul #include <net/if_vlan_var.h>
127a94100faSBill Paul 
128a94100faSBill Paul #include <net/bpf.h>
129a94100faSBill Paul 
130a94100faSBill Paul #include <machine/bus_pio.h>
131a94100faSBill Paul #include <machine/bus_memio.h>
132a94100faSBill Paul #include <machine/bus.h>
133a94100faSBill Paul #include <machine/resource.h>
134a94100faSBill Paul #include <sys/bus.h>
135a94100faSBill Paul #include <sys/rman.h>
136a94100faSBill Paul 
137a94100faSBill Paul #include <dev/mii/mii.h>
138a94100faSBill Paul #include <dev/mii/miivar.h>
139a94100faSBill Paul 
140a94100faSBill Paul #include <dev/pci/pcireg.h>
141a94100faSBill Paul #include <dev/pci/pcivar.h>
142a94100faSBill Paul 
143a94100faSBill Paul MODULE_DEPEND(re, pci, 1, 1, 1);
144a94100faSBill Paul MODULE_DEPEND(re, ether, 1, 1, 1);
145a94100faSBill Paul MODULE_DEPEND(re, miibus, 1, 1, 1);
146a94100faSBill Paul 
147a94100faSBill Paul /* "controller miibus0" required.  See GENERIC if you get errors here. */
148a94100faSBill Paul #include "miibus_if.h"
149a94100faSBill Paul 
150a94100faSBill Paul /*
151a94100faSBill Paul  * Default to using PIO access for this driver.
152a94100faSBill Paul  */
153a94100faSBill Paul #define RE_USEIOSPACE
154a94100faSBill Paul 
155a94100faSBill Paul #include <pci/if_rlreg.h>
156a94100faSBill Paul 
157a94100faSBill Paul #define RE_CSUM_FEATURES    (CSUM_IP | CSUM_TCP | CSUM_UDP)
158a94100faSBill Paul 
159a94100faSBill Paul /*
160a94100faSBill Paul  * Various supported device vendors/types and their names.
161a94100faSBill Paul  */
162a94100faSBill Paul static struct rl_type re_devs[] = {
163a94100faSBill Paul 	{ RT_VENDORID, RT_DEVICEID_8139, RL_HWREV_8139CPLUS,
164a94100faSBill Paul 		"RealTek 8139C+ 10/100BaseTX" },
165a94100faSBill Paul 	{ RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169,
166a94100faSBill Paul 		"RealTek 8169 Gigabit Ethernet" },
16769a6b7fbSBill Paul 	{ RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169S,
16869a6b7fbSBill Paul 		"RealTek 8169S Single-chip Gigabit Ethernet" },
1695fb99dcaSWarner Losh 	{ RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8169SB,
1705fb99dcaSWarner Losh 		"RealTek 8169SB Single-chip Gigabit Ethernet" },
17169a6b7fbSBill Paul 	{ RT_VENDORID, RT_DEVICEID_8169, RL_HWREV_8110S,
17269a6b7fbSBill Paul 		"RealTek 8110S Single-chip Gigabit Ethernet" },
173ea263191SMIHIRA Sanpei Yoshiro 	{ COREGA_VENDORID, COREGA_DEVICEID_CGLAPCIGT, RL_HWREV_8169S,
174ea263191SMIHIRA Sanpei Yoshiro 		"Corega CG-LAPCIGT (RTL8169S) Gigabit Ethernet" },
175a94100faSBill Paul 	{ 0, 0, 0, NULL }
176a94100faSBill Paul };
177a94100faSBill Paul 
178a94100faSBill Paul static struct rl_hwrev re_hwrevs[] = {
179a94100faSBill Paul 	{ RL_HWREV_8139, RL_8139,  "" },
180a94100faSBill Paul 	{ RL_HWREV_8139A, RL_8139, "A" },
181a94100faSBill Paul 	{ RL_HWREV_8139AG, RL_8139, "A-G" },
182a94100faSBill Paul 	{ RL_HWREV_8139B, RL_8139, "B" },
183a94100faSBill Paul 	{ RL_HWREV_8130, RL_8139, "8130" },
184a94100faSBill Paul 	{ RL_HWREV_8139C, RL_8139, "C" },
185a94100faSBill Paul 	{ RL_HWREV_8139D, RL_8139, "8139D/8100B/8100C" },
186a94100faSBill Paul 	{ RL_HWREV_8139CPLUS, RL_8139CPLUS, "C+"},
187a94100faSBill Paul 	{ RL_HWREV_8169, RL_8169, "8169"},
18869a6b7fbSBill Paul 	{ RL_HWREV_8169S, RL_8169, "8169S"},
1895fb99dcaSWarner Losh 	{ RL_HWREV_8169SB, RL_8169, "8169SB"},
19069a6b7fbSBill Paul 	{ RL_HWREV_8110S, RL_8169, "8110S"},
191a94100faSBill Paul 	{ RL_HWREV_8100, RL_8139, "8100"},
192a94100faSBill Paul 	{ RL_HWREV_8101, RL_8139, "8101"},
193a94100faSBill Paul 	{ 0, 0, NULL }
194a94100faSBill Paul };
195a94100faSBill Paul 
196a94100faSBill Paul static int re_probe		(device_t);
197a94100faSBill Paul static int re_attach		(device_t);
198a94100faSBill Paul static int re_detach		(device_t);
199a94100faSBill Paul 
20080a2a305SJohn-Mark Gurney static int re_encap		(struct rl_softc *, struct mbuf **, int *);
201a94100faSBill Paul 
202a94100faSBill Paul static void re_dma_map_addr	(void *, bus_dma_segment_t *, int, int);
203a94100faSBill Paul static void re_dma_map_desc	(void *, bus_dma_segment_t *, int,
204a94100faSBill Paul 				    bus_size_t, int);
205a94100faSBill Paul static int re_allocmem		(device_t, struct rl_softc *);
206a94100faSBill Paul static int re_newbuf		(struct rl_softc *, int, struct mbuf *);
207a94100faSBill Paul static int re_rx_list_init	(struct rl_softc *);
208a94100faSBill Paul static int re_tx_list_init	(struct rl_softc *);
20922a11c96SJohn-Mark Gurney #ifdef RE_FIXUP_RX
21022a11c96SJohn-Mark Gurney static __inline void re_fixup_rx
21122a11c96SJohn-Mark Gurney 				(struct mbuf *);
21222a11c96SJohn-Mark Gurney #endif
213a94100faSBill Paul static void re_rxeof		(struct rl_softc *);
214a94100faSBill Paul static void re_txeof		(struct rl_softc *);
21597b9d4baSJohn-Mark Gurney #ifdef DEVICE_POLLING
2160187838bSRuslan Ermilov static void re_poll		(struct ifnet *, enum poll_cmd, int);
2170187838bSRuslan Ermilov static void re_poll_locked	(struct ifnet *, enum poll_cmd, int);
21897b9d4baSJohn-Mark Gurney #endif
219a94100faSBill Paul static void re_intr		(void *);
220a94100faSBill Paul static void re_tick		(void *);
22197b9d4baSJohn-Mark Gurney static void re_tick_locked	(struct rl_softc *);
222a94100faSBill Paul static void re_start		(struct ifnet *);
22397b9d4baSJohn-Mark Gurney static void re_start_locked	(struct ifnet *);
224a94100faSBill Paul static int re_ioctl		(struct ifnet *, u_long, caddr_t);
225a94100faSBill Paul static void re_init		(void *);
22697b9d4baSJohn-Mark Gurney static void re_init_locked	(struct rl_softc *);
227a94100faSBill Paul static void re_stop		(struct rl_softc *);
228a94100faSBill Paul static void re_watchdog		(struct ifnet *);
229a94100faSBill Paul static int re_suspend		(device_t);
230a94100faSBill Paul static int re_resume		(device_t);
231a94100faSBill Paul static void re_shutdown		(device_t);
232a94100faSBill Paul static int re_ifmedia_upd	(struct ifnet *);
233a94100faSBill Paul static void re_ifmedia_sts	(struct ifnet *, struct ifmediareq *);
234a94100faSBill Paul 
235a94100faSBill Paul static void re_eeprom_putbyte	(struct rl_softc *, int);
236a94100faSBill Paul static void re_eeprom_getword	(struct rl_softc *, int, u_int16_t *);
237a94100faSBill Paul static void re_read_eeprom	(struct rl_softc *, caddr_t, int, int, int);
238a94100faSBill Paul static int re_gmii_readreg	(device_t, int, int);
239a94100faSBill Paul static int re_gmii_writereg	(device_t, int, int, int);
240a94100faSBill Paul 
241a94100faSBill Paul static int re_miibus_readreg	(device_t, int, int);
242a94100faSBill Paul static int re_miibus_writereg	(device_t, int, int, int);
243a94100faSBill Paul static void re_miibus_statchg	(device_t);
244a94100faSBill Paul 
245a94100faSBill Paul static void re_setmulti		(struct rl_softc *);
246a94100faSBill Paul static void re_reset		(struct rl_softc *);
247a94100faSBill Paul 
248a94100faSBill Paul static int re_diag		(struct rl_softc *);
249a94100faSBill Paul 
250a94100faSBill Paul #ifdef RE_USEIOSPACE
251a94100faSBill Paul #define RL_RES			SYS_RES_IOPORT
252a94100faSBill Paul #define RL_RID			RL_PCI_LOIO
253a94100faSBill Paul #else
254a94100faSBill Paul #define RL_RES			SYS_RES_MEMORY
255a94100faSBill Paul #define RL_RID			RL_PCI_LOMEM
256a94100faSBill Paul #endif
257a94100faSBill Paul 
258a94100faSBill Paul static device_method_t re_methods[] = {
259a94100faSBill Paul 	/* Device interface */
260a94100faSBill Paul 	DEVMETHOD(device_probe,		re_probe),
261a94100faSBill Paul 	DEVMETHOD(device_attach,	re_attach),
262a94100faSBill Paul 	DEVMETHOD(device_detach,	re_detach),
263a94100faSBill Paul 	DEVMETHOD(device_suspend,	re_suspend),
264a94100faSBill Paul 	DEVMETHOD(device_resume,	re_resume),
265a94100faSBill Paul 	DEVMETHOD(device_shutdown,	re_shutdown),
266a94100faSBill Paul 
267a94100faSBill Paul 	/* bus interface */
268a94100faSBill Paul 	DEVMETHOD(bus_print_child,	bus_generic_print_child),
269a94100faSBill Paul 	DEVMETHOD(bus_driver_added,	bus_generic_driver_added),
270a94100faSBill Paul 
271a94100faSBill Paul 	/* MII interface */
272a94100faSBill Paul 	DEVMETHOD(miibus_readreg,	re_miibus_readreg),
273a94100faSBill Paul 	DEVMETHOD(miibus_writereg,	re_miibus_writereg),
274a94100faSBill Paul 	DEVMETHOD(miibus_statchg,	re_miibus_statchg),
275a94100faSBill Paul 
276a94100faSBill Paul 	{ 0, 0 }
277a94100faSBill Paul };
278a94100faSBill Paul 
279a94100faSBill Paul static driver_t re_driver = {
280a94100faSBill Paul 	"re",
281a94100faSBill Paul 	re_methods,
282a94100faSBill Paul 	sizeof(struct rl_softc)
283a94100faSBill Paul };
284a94100faSBill Paul 
285a94100faSBill Paul static devclass_t re_devclass;
286a94100faSBill Paul 
287a94100faSBill Paul DRIVER_MODULE(re, pci, re_driver, re_devclass, 0, 0);
288347934faSWarner Losh DRIVER_MODULE(re, cardbus, re_driver, re_devclass, 0, 0);
289a94100faSBill Paul DRIVER_MODULE(miibus, re, miibus_driver, miibus_devclass, 0, 0);
290a94100faSBill Paul 
291a94100faSBill Paul #define EE_SET(x)					\
292a94100faSBill Paul 	CSR_WRITE_1(sc, RL_EECMD,			\
293a94100faSBill Paul 		CSR_READ_1(sc, RL_EECMD) | x)
294a94100faSBill Paul 
295a94100faSBill Paul #define EE_CLR(x)					\
296a94100faSBill Paul 	CSR_WRITE_1(sc, RL_EECMD,			\
297a94100faSBill Paul 		CSR_READ_1(sc, RL_EECMD) & ~x)
298a94100faSBill Paul 
299a94100faSBill Paul /*
300a94100faSBill Paul  * Send a read command and address to the EEPROM, check for ACK.
301a94100faSBill Paul  */
302a94100faSBill Paul static void
303a94100faSBill Paul re_eeprom_putbyte(sc, addr)
304a94100faSBill Paul 	struct rl_softc		*sc;
305a94100faSBill Paul 	int			addr;
306a94100faSBill Paul {
307a94100faSBill Paul 	register int		d, i;
308a94100faSBill Paul 
309a94100faSBill Paul 	d = addr | sc->rl_eecmd_read;
310a94100faSBill Paul 
311a94100faSBill Paul 	/*
312a94100faSBill Paul 	 * Feed in each bit and strobe the clock.
313a94100faSBill Paul 	 */
314a94100faSBill Paul 	for (i = 0x400; i; i >>= 1) {
315a94100faSBill Paul 		if (d & i) {
316a94100faSBill Paul 			EE_SET(RL_EE_DATAIN);
317a94100faSBill Paul 		} else {
318a94100faSBill Paul 			EE_CLR(RL_EE_DATAIN);
319a94100faSBill Paul 		}
320a94100faSBill Paul 		DELAY(100);
321a94100faSBill Paul 		EE_SET(RL_EE_CLK);
322a94100faSBill Paul 		DELAY(150);
323a94100faSBill Paul 		EE_CLR(RL_EE_CLK);
324a94100faSBill Paul 		DELAY(100);
325a94100faSBill Paul 	}
326a94100faSBill Paul }
327a94100faSBill Paul 
328a94100faSBill Paul /*
329a94100faSBill Paul  * Read a word of data stored in the EEPROM at address 'addr.'
330a94100faSBill Paul  */
331a94100faSBill Paul static void
332a94100faSBill Paul re_eeprom_getword(sc, addr, dest)
333a94100faSBill Paul 	struct rl_softc		*sc;
334a94100faSBill Paul 	int			addr;
335a94100faSBill Paul 	u_int16_t		*dest;
336a94100faSBill Paul {
337a94100faSBill Paul 	register int		i;
338a94100faSBill Paul 	u_int16_t		word = 0;
339a94100faSBill Paul 
340a94100faSBill Paul 	/* Enter EEPROM access mode. */
341a94100faSBill Paul 	CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_PROGRAM|RL_EE_SEL);
342a94100faSBill Paul 
343a94100faSBill Paul 	/*
344a94100faSBill Paul 	 * Send address of word we want to read.
345a94100faSBill Paul 	 */
346a94100faSBill Paul 	re_eeprom_putbyte(sc, addr);
347a94100faSBill Paul 
348a94100faSBill Paul 	CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_PROGRAM|RL_EE_SEL);
349a94100faSBill Paul 
350a94100faSBill Paul 	/*
351a94100faSBill Paul 	 * Start reading bits from EEPROM.
352a94100faSBill Paul 	 */
353a94100faSBill Paul 	for (i = 0x8000; i; i >>= 1) {
354a94100faSBill Paul 		EE_SET(RL_EE_CLK);
355a94100faSBill Paul 		DELAY(100);
356a94100faSBill Paul 		if (CSR_READ_1(sc, RL_EECMD) & RL_EE_DATAOUT)
357a94100faSBill Paul 			word |= i;
358a94100faSBill Paul 		EE_CLR(RL_EE_CLK);
359a94100faSBill Paul 		DELAY(100);
360a94100faSBill Paul 	}
361a94100faSBill Paul 
362a94100faSBill Paul 	/* Turn off EEPROM access mode. */
363a94100faSBill Paul 	CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
364a94100faSBill Paul 
365a94100faSBill Paul 	*dest = word;
366a94100faSBill Paul }
367a94100faSBill Paul 
368a94100faSBill Paul /*
369a94100faSBill Paul  * Read a sequence of words from the EEPROM.
370a94100faSBill Paul  */
371a94100faSBill Paul static void
372a94100faSBill Paul re_read_eeprom(sc, dest, off, cnt, swap)
373a94100faSBill Paul 	struct rl_softc		*sc;
374a94100faSBill Paul 	caddr_t			dest;
375a94100faSBill Paul 	int			off;
376a94100faSBill Paul 	int			cnt;
377a94100faSBill Paul 	int			swap;
378a94100faSBill Paul {
379a94100faSBill Paul 	int			i;
380a94100faSBill Paul 	u_int16_t		word = 0, *ptr;
381a94100faSBill Paul 
382a94100faSBill Paul 	for (i = 0; i < cnt; i++) {
383a94100faSBill Paul 		re_eeprom_getword(sc, off + i, &word);
384a94100faSBill Paul 		ptr = (u_int16_t *)(dest + (i * 2));
385a94100faSBill Paul 		if (swap)
386a94100faSBill Paul 			*ptr = ntohs(word);
387a94100faSBill Paul 		else
388a94100faSBill Paul 			*ptr = word;
389a94100faSBill Paul 	}
390a94100faSBill Paul }
391a94100faSBill Paul 
392a94100faSBill Paul static int
393a94100faSBill Paul re_gmii_readreg(dev, phy, reg)
394a94100faSBill Paul 	device_t		dev;
395a94100faSBill Paul 	int			phy, reg;
396a94100faSBill Paul {
397a94100faSBill Paul 	struct rl_softc		*sc;
398a94100faSBill Paul 	u_int32_t		rval;
399a94100faSBill Paul 	int			i;
400a94100faSBill Paul 
401a94100faSBill Paul 	if (phy != 1)
402a94100faSBill Paul 		return (0);
403a94100faSBill Paul 
404a94100faSBill Paul 	sc = device_get_softc(dev);
405a94100faSBill Paul 
4069bac70b8SBill Paul 	/* Let the rgephy driver read the GMEDIASTAT register */
4079bac70b8SBill Paul 
4089bac70b8SBill Paul 	if (reg == RL_GMEDIASTAT) {
4099bac70b8SBill Paul 		rval = CSR_READ_1(sc, RL_GMEDIASTAT);
4109bac70b8SBill Paul 		return (rval);
4119bac70b8SBill Paul 	}
4129bac70b8SBill Paul 
413a94100faSBill Paul 	CSR_WRITE_4(sc, RL_PHYAR, reg << 16);
414a94100faSBill Paul 	DELAY(1000);
415a94100faSBill Paul 
416a94100faSBill Paul 	for (i = 0; i < RL_TIMEOUT; i++) {
417a94100faSBill Paul 		rval = CSR_READ_4(sc, RL_PHYAR);
418a94100faSBill Paul 		if (rval & RL_PHYAR_BUSY)
419a94100faSBill Paul 			break;
420a94100faSBill Paul 		DELAY(100);
421a94100faSBill Paul 	}
422a94100faSBill Paul 
423a94100faSBill Paul 	if (i == RL_TIMEOUT) {
424a94100faSBill Paul 		printf ("re%d: PHY read failed\n", sc->rl_unit);
425a94100faSBill Paul 		return (0);
426a94100faSBill Paul 	}
427a94100faSBill Paul 
428a94100faSBill Paul 	return (rval & RL_PHYAR_PHYDATA);
429a94100faSBill Paul }
430a94100faSBill Paul 
431a94100faSBill Paul static int
432a94100faSBill Paul re_gmii_writereg(dev, phy, reg, data)
433a94100faSBill Paul 	device_t		dev;
434a94100faSBill Paul 	int			phy, reg, data;
435a94100faSBill Paul {
436a94100faSBill Paul 	struct rl_softc		*sc;
437a94100faSBill Paul 	u_int32_t		rval;
438a94100faSBill Paul 	int			i;
439a94100faSBill Paul 
440a94100faSBill Paul 	sc = device_get_softc(dev);
441a94100faSBill Paul 
442a94100faSBill Paul 	CSR_WRITE_4(sc, RL_PHYAR, (reg << 16) |
4439bac70b8SBill Paul 	    (data & RL_PHYAR_PHYDATA) | RL_PHYAR_BUSY);
444a94100faSBill Paul 	DELAY(1000);
445a94100faSBill Paul 
446a94100faSBill Paul 	for (i = 0; i < RL_TIMEOUT; i++) {
447a94100faSBill Paul 		rval = CSR_READ_4(sc, RL_PHYAR);
448a94100faSBill Paul 		if (!(rval & RL_PHYAR_BUSY))
449a94100faSBill Paul 			break;
450a94100faSBill Paul 		DELAY(100);
451a94100faSBill Paul 	}
452a94100faSBill Paul 
453a94100faSBill Paul 	if (i == RL_TIMEOUT) {
454a94100faSBill Paul 		printf ("re%d: PHY write failed\n", sc->rl_unit);
455a94100faSBill Paul 		return (0);
456a94100faSBill Paul 	}
457a94100faSBill Paul 
458a94100faSBill Paul 	return (0);
459a94100faSBill Paul }
460a94100faSBill Paul 
461a94100faSBill Paul static int
462a94100faSBill Paul re_miibus_readreg(dev, phy, reg)
463a94100faSBill Paul 	device_t		dev;
464a94100faSBill Paul 	int			phy, reg;
465a94100faSBill Paul {
466a94100faSBill Paul 	struct rl_softc		*sc;
467a94100faSBill Paul 	u_int16_t		rval = 0;
468a94100faSBill Paul 	u_int16_t		re8139_reg = 0;
469a94100faSBill Paul 
470a94100faSBill Paul 	sc = device_get_softc(dev);
471a94100faSBill Paul 
472a94100faSBill Paul 	if (sc->rl_type == RL_8169) {
473a94100faSBill Paul 		rval = re_gmii_readreg(dev, phy, reg);
474a94100faSBill Paul 		return (rval);
475a94100faSBill Paul 	}
476a94100faSBill Paul 
477a94100faSBill Paul 	/* Pretend the internal PHY is only at address 0 */
478a94100faSBill Paul 	if (phy) {
479a94100faSBill Paul 		return (0);
480a94100faSBill Paul 	}
481a94100faSBill Paul 	switch (reg) {
482a94100faSBill Paul 	case MII_BMCR:
483a94100faSBill Paul 		re8139_reg = RL_BMCR;
484a94100faSBill Paul 		break;
485a94100faSBill Paul 	case MII_BMSR:
486a94100faSBill Paul 		re8139_reg = RL_BMSR;
487a94100faSBill Paul 		break;
488a94100faSBill Paul 	case MII_ANAR:
489a94100faSBill Paul 		re8139_reg = RL_ANAR;
490a94100faSBill Paul 		break;
491a94100faSBill Paul 	case MII_ANER:
492a94100faSBill Paul 		re8139_reg = RL_ANER;
493a94100faSBill Paul 		break;
494a94100faSBill Paul 	case MII_ANLPAR:
495a94100faSBill Paul 		re8139_reg = RL_LPAR;
496a94100faSBill Paul 		break;
497a94100faSBill Paul 	case MII_PHYIDR1:
498a94100faSBill Paul 	case MII_PHYIDR2:
499a94100faSBill Paul 		return (0);
500a94100faSBill Paul 	/*
501a94100faSBill Paul 	 * Allow the rlphy driver to read the media status
502a94100faSBill Paul 	 * register. If we have a link partner which does not
503a94100faSBill Paul 	 * support NWAY, this is the register which will tell
504a94100faSBill Paul 	 * us the results of parallel detection.
505a94100faSBill Paul 	 */
506a94100faSBill Paul 	case RL_MEDIASTAT:
507a94100faSBill Paul 		rval = CSR_READ_1(sc, RL_MEDIASTAT);
508a94100faSBill Paul 		return (rval);
509a94100faSBill Paul 	default:
510a94100faSBill Paul 		printf("re%d: bad phy register\n", sc->rl_unit);
511a94100faSBill Paul 		return (0);
512a94100faSBill Paul 	}
513a94100faSBill Paul 	rval = CSR_READ_2(sc, re8139_reg);
514a94100faSBill Paul 	return (rval);
515a94100faSBill Paul }
516a94100faSBill Paul 
517a94100faSBill Paul static int
518a94100faSBill Paul re_miibus_writereg(dev, phy, reg, data)
519a94100faSBill Paul 	device_t		dev;
520a94100faSBill Paul 	int			phy, reg, data;
521a94100faSBill Paul {
522a94100faSBill Paul 	struct rl_softc		*sc;
523a94100faSBill Paul 	u_int16_t		re8139_reg = 0;
524a94100faSBill Paul 	int			rval = 0;
525a94100faSBill Paul 
526a94100faSBill Paul 	sc = device_get_softc(dev);
527a94100faSBill Paul 
528a94100faSBill Paul 	if (sc->rl_type == RL_8169) {
529a94100faSBill Paul 		rval = re_gmii_writereg(dev, phy, reg, data);
530a94100faSBill Paul 		return (rval);
531a94100faSBill Paul 	}
532a94100faSBill Paul 
533a94100faSBill Paul 	/* Pretend the internal PHY is only at address 0 */
53497b9d4baSJohn-Mark Gurney 	if (phy)
535a94100faSBill Paul 		return (0);
53697b9d4baSJohn-Mark Gurney 
537a94100faSBill Paul 	switch (reg) {
538a94100faSBill Paul 	case MII_BMCR:
539a94100faSBill Paul 		re8139_reg = RL_BMCR;
540a94100faSBill Paul 		break;
541a94100faSBill Paul 	case MII_BMSR:
542a94100faSBill Paul 		re8139_reg = RL_BMSR;
543a94100faSBill Paul 		break;
544a94100faSBill Paul 	case MII_ANAR:
545a94100faSBill Paul 		re8139_reg = RL_ANAR;
546a94100faSBill Paul 		break;
547a94100faSBill Paul 	case MII_ANER:
548a94100faSBill Paul 		re8139_reg = RL_ANER;
549a94100faSBill Paul 		break;
550a94100faSBill Paul 	case MII_ANLPAR:
551a94100faSBill Paul 		re8139_reg = RL_LPAR;
552a94100faSBill Paul 		break;
553a94100faSBill Paul 	case MII_PHYIDR1:
554a94100faSBill Paul 	case MII_PHYIDR2:
555a94100faSBill Paul 		return (0);
556a94100faSBill Paul 		break;
557a94100faSBill Paul 	default:
558a94100faSBill Paul 		printf("re%d: bad phy register\n", sc->rl_unit);
559a94100faSBill Paul 		return (0);
560a94100faSBill Paul 	}
561a94100faSBill Paul 	CSR_WRITE_2(sc, re8139_reg, data);
562a94100faSBill Paul 	return (0);
563a94100faSBill Paul }
564a94100faSBill Paul 
565a94100faSBill Paul static void
566a94100faSBill Paul re_miibus_statchg(dev)
567a94100faSBill Paul 	device_t		dev;
568a94100faSBill Paul {
569a11e2f18SBruce M Simpson 
570a94100faSBill Paul }
571a94100faSBill Paul 
572a94100faSBill Paul /*
573a94100faSBill Paul  * Program the 64-bit multicast hash filter.
574a94100faSBill Paul  */
575a94100faSBill Paul static void
576a94100faSBill Paul re_setmulti(sc)
577a94100faSBill Paul 	struct rl_softc		*sc;
578a94100faSBill Paul {
579a94100faSBill Paul 	struct ifnet		*ifp;
580a94100faSBill Paul 	int			h = 0;
581a94100faSBill Paul 	u_int32_t		hashes[2] = { 0, 0 };
582a94100faSBill Paul 	struct ifmultiaddr	*ifma;
583a94100faSBill Paul 	u_int32_t		rxfilt;
584a94100faSBill Paul 	int			mcnt = 0;
585a94100faSBill Paul 
58697b9d4baSJohn-Mark Gurney 	RL_LOCK_ASSERT(sc);
58797b9d4baSJohn-Mark Gurney 
588a94100faSBill Paul 	ifp = &sc->arpcom.ac_if;
589a94100faSBill Paul 
590a94100faSBill Paul 	rxfilt = CSR_READ_4(sc, RL_RXCFG);
591a94100faSBill Paul 
592a94100faSBill Paul 	if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
593a94100faSBill Paul 		rxfilt |= RL_RXCFG_RX_MULTI;
594a94100faSBill Paul 		CSR_WRITE_4(sc, RL_RXCFG, rxfilt);
595a94100faSBill Paul 		CSR_WRITE_4(sc, RL_MAR0, 0xFFFFFFFF);
596a94100faSBill Paul 		CSR_WRITE_4(sc, RL_MAR4, 0xFFFFFFFF);
597a94100faSBill Paul 		return;
598a94100faSBill Paul 	}
599a94100faSBill Paul 
600a94100faSBill Paul 	/* first, zot all the existing hash bits */
601a94100faSBill Paul 	CSR_WRITE_4(sc, RL_MAR0, 0);
602a94100faSBill Paul 	CSR_WRITE_4(sc, RL_MAR4, 0);
603a94100faSBill Paul 
604a94100faSBill Paul 	/* now program new ones */
605a94100faSBill Paul 	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
606a94100faSBill Paul 		if (ifma->ifma_addr->sa_family != AF_LINK)
607a94100faSBill Paul 			continue;
6080e939c0cSChristian Weisgerber 		h = ether_crc32_be(LLADDR((struct sockaddr_dl *)
6090e939c0cSChristian Weisgerber 		    ifma->ifma_addr), ETHER_ADDR_LEN) >> 26;
610a94100faSBill Paul 		if (h < 32)
611a94100faSBill Paul 			hashes[0] |= (1 << h);
612a94100faSBill Paul 		else
613a94100faSBill Paul 			hashes[1] |= (1 << (h - 32));
614a94100faSBill Paul 		mcnt++;
615a94100faSBill Paul 	}
616a94100faSBill Paul 
617a94100faSBill Paul 	if (mcnt)
618a94100faSBill Paul 		rxfilt |= RL_RXCFG_RX_MULTI;
619a94100faSBill Paul 	else
620a94100faSBill Paul 		rxfilt &= ~RL_RXCFG_RX_MULTI;
621a94100faSBill Paul 
622a94100faSBill Paul 	CSR_WRITE_4(sc, RL_RXCFG, rxfilt);
623a94100faSBill Paul 	CSR_WRITE_4(sc, RL_MAR0, hashes[0]);
624a94100faSBill Paul 	CSR_WRITE_4(sc, RL_MAR4, hashes[1]);
625a94100faSBill Paul }
626a94100faSBill Paul 
627a94100faSBill Paul static void
628a94100faSBill Paul re_reset(sc)
629a94100faSBill Paul 	struct rl_softc		*sc;
630a94100faSBill Paul {
631a94100faSBill Paul 	register int		i;
632a94100faSBill Paul 
63397b9d4baSJohn-Mark Gurney 	RL_LOCK_ASSERT(sc);
63497b9d4baSJohn-Mark Gurney 
635a94100faSBill Paul 	CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_RESET);
636a94100faSBill Paul 
637a94100faSBill Paul 	for (i = 0; i < RL_TIMEOUT; i++) {
638a94100faSBill Paul 		DELAY(10);
639a94100faSBill Paul 		if (!(CSR_READ_1(sc, RL_COMMAND) & RL_CMD_RESET))
640a94100faSBill Paul 			break;
641a94100faSBill Paul 	}
642a94100faSBill Paul 	if (i == RL_TIMEOUT)
643a94100faSBill Paul 		printf("re%d: reset never completed!\n", sc->rl_unit);
644a94100faSBill Paul 
645a94100faSBill Paul 	CSR_WRITE_1(sc, 0x82, 1);
646a94100faSBill Paul }
647a94100faSBill Paul 
648a94100faSBill Paul /*
649a94100faSBill Paul  * The following routine is designed to test for a defect on some
650a94100faSBill Paul  * 32-bit 8169 cards. Some of these NICs have the REQ64# and ACK64#
651a94100faSBill Paul  * lines connected to the bus, however for a 32-bit only card, they
652a94100faSBill Paul  * should be pulled high. The result of this defect is that the
653a94100faSBill Paul  * NIC will not work right if you plug it into a 64-bit slot: DMA
654a94100faSBill Paul  * operations will be done with 64-bit transfers, which will fail
655a94100faSBill Paul  * because the 64-bit data lines aren't connected.
656a94100faSBill Paul  *
657a94100faSBill Paul  * There's no way to work around this (short of talking a soldering
658a94100faSBill Paul  * iron to the board), however we can detect it. The method we use
659a94100faSBill Paul  * here is to put the NIC into digital loopback mode, set the receiver
660a94100faSBill Paul  * to promiscuous mode, and then try to send a frame. We then compare
661a94100faSBill Paul  * the frame data we sent to what was received. If the data matches,
662a94100faSBill Paul  * then the NIC is working correctly, otherwise we know the user has
663a94100faSBill Paul  * a defective NIC which has been mistakenly plugged into a 64-bit PCI
664a94100faSBill Paul  * slot. In the latter case, there's no way the NIC can work correctly,
665a94100faSBill Paul  * so we print out a message on the console and abort the device attach.
666a94100faSBill Paul  */
667a94100faSBill Paul 
668a94100faSBill Paul static int
669a94100faSBill Paul re_diag(sc)
670a94100faSBill Paul 	struct rl_softc		*sc;
671a94100faSBill Paul {
672a94100faSBill Paul 	struct ifnet		*ifp = &sc->arpcom.ac_if;
673a94100faSBill Paul 	struct mbuf		*m0;
674a94100faSBill Paul 	struct ether_header	*eh;
675a94100faSBill Paul 	struct rl_desc		*cur_rx;
676a94100faSBill Paul 	u_int16_t		status;
677a94100faSBill Paul 	u_int32_t		rxstat;
678a94100faSBill Paul 	int			total_len, i, error = 0;
679a94100faSBill Paul 	u_int8_t		dst[] = { 0x00, 'h', 'e', 'l', 'l', 'o' };
680a94100faSBill Paul 	u_int8_t		src[] = { 0x00, 'w', 'o', 'r', 'l', 'd' };
681a94100faSBill Paul 
682a94100faSBill Paul 	/* Allocate a single mbuf */
683a94100faSBill Paul 	MGETHDR(m0, M_DONTWAIT, MT_DATA);
684a94100faSBill Paul 	if (m0 == NULL)
685a94100faSBill Paul 		return (ENOBUFS);
686a94100faSBill Paul 
68797b9d4baSJohn-Mark Gurney 	RL_LOCK(sc);
68897b9d4baSJohn-Mark Gurney 
689a94100faSBill Paul 	/*
690a94100faSBill Paul 	 * Initialize the NIC in test mode. This sets the chip up
691a94100faSBill Paul 	 * so that it can send and receive frames, but performs the
692a94100faSBill Paul 	 * following special functions:
693a94100faSBill Paul 	 * - Puts receiver in promiscuous mode
694a94100faSBill Paul 	 * - Enables digital loopback mode
695a94100faSBill Paul 	 * - Leaves interrupts turned off
696a94100faSBill Paul 	 */
697a94100faSBill Paul 
698a94100faSBill Paul 	ifp->if_flags |= IFF_PROMISC;
699a94100faSBill Paul 	sc->rl_testmode = 1;
70097b9d4baSJohn-Mark Gurney 	re_init_locked(sc);
701804af9a1SBill Paul 	re_stop(sc);
702804af9a1SBill Paul 	DELAY(100000);
70397b9d4baSJohn-Mark Gurney 	re_init_locked(sc);
704a94100faSBill Paul 
705a94100faSBill Paul 	/* Put some data in the mbuf */
706a94100faSBill Paul 
707a94100faSBill Paul 	eh = mtod(m0, struct ether_header *);
708a94100faSBill Paul 	bcopy ((char *)&dst, eh->ether_dhost, ETHER_ADDR_LEN);
709a94100faSBill Paul 	bcopy ((char *)&src, eh->ether_shost, ETHER_ADDR_LEN);
710a94100faSBill Paul 	eh->ether_type = htons(ETHERTYPE_IP);
711a94100faSBill Paul 	m0->m_pkthdr.len = m0->m_len = ETHER_MIN_LEN - ETHER_CRC_LEN;
712a94100faSBill Paul 
7137cae6651SBill Paul 	/*
7147cae6651SBill Paul 	 * Queue the packet, start transmission.
7157cae6651SBill Paul 	 * Note: IF_HANDOFF() ultimately calls re_start() for us.
7167cae6651SBill Paul 	 */
717a94100faSBill Paul 
718abc8ff44SBill Paul 	CSR_WRITE_2(sc, RL_ISR, 0xFFFF);
71997b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
7207cae6651SBill Paul 	IF_HANDOFF(&ifp->if_snd, m0, ifp);
72197b9d4baSJohn-Mark Gurney 	RL_LOCK(sc);
722a94100faSBill Paul 	m0 = NULL;
723a94100faSBill Paul 
724a94100faSBill Paul 	/* Wait for it to propagate through the chip */
725a94100faSBill Paul 
726abc8ff44SBill Paul 	DELAY(100000);
727a94100faSBill Paul 	for (i = 0; i < RL_TIMEOUT; i++) {
728a94100faSBill Paul 		status = CSR_READ_2(sc, RL_ISR);
729abc8ff44SBill Paul 		if ((status & (RL_ISR_TIMEOUT_EXPIRED|RL_ISR_RX_OK)) ==
730abc8ff44SBill Paul 		    (RL_ISR_TIMEOUT_EXPIRED|RL_ISR_RX_OK))
731a94100faSBill Paul 			break;
732a94100faSBill Paul 		DELAY(10);
733a94100faSBill Paul 	}
734a94100faSBill Paul 
735a94100faSBill Paul 	if (i == RL_TIMEOUT) {
736a94100faSBill Paul 		printf("re%d: diagnostic failed, failed to receive packet "
737a94100faSBill Paul 		    "in loopback mode\n", sc->rl_unit);
738a94100faSBill Paul 		error = EIO;
739a94100faSBill Paul 		goto done;
740a94100faSBill Paul 	}
741a94100faSBill Paul 
742a94100faSBill Paul 	/*
743a94100faSBill Paul 	 * The packet should have been dumped into the first
744a94100faSBill Paul 	 * entry in the RX DMA ring. Grab it from there.
745a94100faSBill Paul 	 */
746a94100faSBill Paul 
747a94100faSBill Paul 	bus_dmamap_sync(sc->rl_ldata.rl_rx_list_tag,
748a94100faSBill Paul 	    sc->rl_ldata.rl_rx_list_map,
749a94100faSBill Paul 	    BUS_DMASYNC_POSTREAD);
750a94100faSBill Paul 	bus_dmamap_sync(sc->rl_ldata.rl_mtag,
751a94100faSBill Paul 	    sc->rl_ldata.rl_rx_dmamap[0],
752a94100faSBill Paul 	    BUS_DMASYNC_POSTWRITE);
753a94100faSBill Paul 	bus_dmamap_unload(sc->rl_ldata.rl_mtag,
754a94100faSBill Paul 	    sc->rl_ldata.rl_rx_dmamap[0]);
755a94100faSBill Paul 
756a94100faSBill Paul 	m0 = sc->rl_ldata.rl_rx_mbuf[0];
757a94100faSBill Paul 	sc->rl_ldata.rl_rx_mbuf[0] = NULL;
758a94100faSBill Paul 	eh = mtod(m0, struct ether_header *);
759a94100faSBill Paul 
760a94100faSBill Paul 	cur_rx = &sc->rl_ldata.rl_rx_list[0];
761a94100faSBill Paul 	total_len = RL_RXBYTES(cur_rx);
762a94100faSBill Paul 	rxstat = le32toh(cur_rx->rl_cmdstat);
763a94100faSBill Paul 
764a94100faSBill Paul 	if (total_len != ETHER_MIN_LEN) {
765a94100faSBill Paul 		printf("re%d: diagnostic failed, received short packet\n",
766a94100faSBill Paul 		    sc->rl_unit);
767a94100faSBill Paul 		error = EIO;
768a94100faSBill Paul 		goto done;
769a94100faSBill Paul 	}
770a94100faSBill Paul 
771a94100faSBill Paul 	/* Test that the received packet data matches what we sent. */
772a94100faSBill Paul 
773a94100faSBill Paul 	if (bcmp((char *)&eh->ether_dhost, (char *)&dst, ETHER_ADDR_LEN) ||
774a94100faSBill Paul 	    bcmp((char *)&eh->ether_shost, (char *)&src, ETHER_ADDR_LEN) ||
775a94100faSBill Paul 	    ntohs(eh->ether_type) != ETHERTYPE_IP) {
776a94100faSBill Paul 		printf("re%d: WARNING, DMA FAILURE!\n", sc->rl_unit);
777a94100faSBill Paul 		printf("re%d: expected TX data: %6D/%6D/0x%x\n", sc->rl_unit,
778a94100faSBill Paul 		    dst, ":", src, ":", ETHERTYPE_IP);
779a94100faSBill Paul 		printf("re%d: received RX data: %6D/%6D/0x%x\n", sc->rl_unit,
780a94100faSBill Paul 		    eh->ether_dhost, ":",  eh->ether_shost, ":",
781a94100faSBill Paul 		    ntohs(eh->ether_type));
782a94100faSBill Paul 		printf("re%d: You may have a defective 32-bit NIC plugged "
783a94100faSBill Paul 		    "into a 64-bit PCI slot.\n", sc->rl_unit);
784a94100faSBill Paul 		printf("re%d: Please re-install the NIC in a 32-bit slot "
785a94100faSBill Paul 		    "for proper operation.\n", sc->rl_unit);
786a94100faSBill Paul 		printf("re%d: Read the re(4) man page for more details.\n",
787a94100faSBill Paul 		    sc->rl_unit);
788a94100faSBill Paul 		error = EIO;
789a94100faSBill Paul 	}
790a94100faSBill Paul 
791a94100faSBill Paul done:
792a94100faSBill Paul 	/* Turn interface off, release resources */
793a94100faSBill Paul 
794a94100faSBill Paul 	sc->rl_testmode = 0;
795a94100faSBill Paul 	ifp->if_flags &= ~IFF_PROMISC;
796a94100faSBill Paul 	re_stop(sc);
797a94100faSBill Paul 	if (m0 != NULL)
798a94100faSBill Paul 		m_freem(m0);
799a94100faSBill Paul 
80097b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
80197b9d4baSJohn-Mark Gurney 
802a94100faSBill Paul 	return (error);
803a94100faSBill Paul }
804a94100faSBill Paul 
805a94100faSBill Paul /*
806a94100faSBill Paul  * Probe for a RealTek 8139C+/8169/8110 chip. Check the PCI vendor and device
807a94100faSBill Paul  * IDs against our list and return a device name if we find a match.
808a94100faSBill Paul  */
809a94100faSBill Paul static int
810a94100faSBill Paul re_probe(dev)
811a94100faSBill Paul 	device_t		dev;
812a94100faSBill Paul {
813a94100faSBill Paul 	struct rl_type		*t;
814a94100faSBill Paul 	struct rl_softc		*sc;
815a94100faSBill Paul 	int			rid;
816a94100faSBill Paul 	u_int32_t		hwrev;
817a94100faSBill Paul 
818a94100faSBill Paul 	t = re_devs;
819a94100faSBill Paul 	sc = device_get_softc(dev);
820a94100faSBill Paul 
821a94100faSBill Paul 	while (t->rl_name != NULL) {
822a94100faSBill Paul 		if ((pci_get_vendor(dev) == t->rl_vid) &&
823a94100faSBill Paul 		    (pci_get_device(dev) == t->rl_did)) {
824a94100faSBill Paul 
825a94100faSBill Paul 			/*
826a94100faSBill Paul 			 * Temporarily map the I/O space
827a94100faSBill Paul 			 * so we can read the chip ID register.
828a94100faSBill Paul 			 */
829a94100faSBill Paul 			rid = RL_RID;
8305f96beb9SNate Lawson 			sc->rl_res = bus_alloc_resource_any(dev, RL_RES, &rid,
8315f96beb9SNate Lawson 			    RF_ACTIVE);
832a94100faSBill Paul 			if (sc->rl_res == NULL) {
833a94100faSBill Paul 				device_printf(dev,
834a94100faSBill Paul 				    "couldn't map ports/memory\n");
835a94100faSBill Paul 				return (ENXIO);
836a94100faSBill Paul 			}
837a94100faSBill Paul 			sc->rl_btag = rman_get_bustag(sc->rl_res);
838a94100faSBill Paul 			sc->rl_bhandle = rman_get_bushandle(sc->rl_res);
839a94100faSBill Paul 			hwrev = CSR_READ_4(sc, RL_TXCFG) & RL_TXCFG_HWREV;
840a94100faSBill Paul 			bus_release_resource(dev, RL_RES,
841a94100faSBill Paul 			    RL_RID, sc->rl_res);
842a94100faSBill Paul 			if (t->rl_basetype == hwrev) {
843a94100faSBill Paul 				device_set_desc(dev, t->rl_name);
844d2b677bbSWarner Losh 				return (BUS_PROBE_DEFAULT);
845a94100faSBill Paul 			}
846a94100faSBill Paul 		}
847a94100faSBill Paul 		t++;
848a94100faSBill Paul 	}
849a94100faSBill Paul 
850a94100faSBill Paul 	return (ENXIO);
851a94100faSBill Paul }
852a94100faSBill Paul 
853a94100faSBill Paul /*
854a94100faSBill Paul  * This routine takes the segment list provided as the result of
855a94100faSBill Paul  * a bus_dma_map_load() operation and assigns the addresses/lengths
856a94100faSBill Paul  * to RealTek DMA descriptors. This can be called either by the RX
857a94100faSBill Paul  * code or the TX code. In the RX case, we'll probably wind up mapping
858a94100faSBill Paul  * at most one segment. For the TX case, there could be any number of
859a94100faSBill Paul  * segments since TX packets may span multiple mbufs. In either case,
860a94100faSBill Paul  * if the number of segments is larger than the rl_maxsegs limit
861a94100faSBill Paul  * specified by the caller, we abort the mapping operation. Sadly,
862a94100faSBill Paul  * whoever designed the buffer mapping API did not provide a way to
863a94100faSBill Paul  * return an error from here, so we have to fake it a bit.
864a94100faSBill Paul  */
865a94100faSBill Paul 
866a94100faSBill Paul static void
867a94100faSBill Paul re_dma_map_desc(arg, segs, nseg, mapsize, error)
868a94100faSBill Paul 	void			*arg;
869a94100faSBill Paul 	bus_dma_segment_t	*segs;
870a94100faSBill Paul 	int			nseg;
871a94100faSBill Paul 	bus_size_t		mapsize;
872a94100faSBill Paul 	int			error;
873a94100faSBill Paul {
874a94100faSBill Paul 	struct rl_dmaload_arg	*ctx;
875a94100faSBill Paul 	struct rl_desc		*d = NULL;
876a94100faSBill Paul 	int			i = 0, idx;
877a94100faSBill Paul 
878a94100faSBill Paul 	if (error)
879a94100faSBill Paul 		return;
880a94100faSBill Paul 
881a94100faSBill Paul 	ctx = arg;
882a94100faSBill Paul 
883a94100faSBill Paul 	/* Signal error to caller if there's too many segments */
884a94100faSBill Paul 	if (nseg > ctx->rl_maxsegs) {
885a94100faSBill Paul 		ctx->rl_maxsegs = 0;
886a94100faSBill Paul 		return;
887a94100faSBill Paul 	}
888a94100faSBill Paul 
889a94100faSBill Paul 	/*
890a94100faSBill Paul 	 * Map the segment array into descriptors. Note that we set the
891a94100faSBill Paul 	 * start-of-frame and end-of-frame markers for either TX or RX, but
892a94100faSBill Paul 	 * they really only have meaning in the TX case. (In the RX case,
893a94100faSBill Paul 	 * it's the chip that tells us where packets begin and end.)
894a94100faSBill Paul 	 * We also keep track of the end of the ring and set the
895a94100faSBill Paul 	 * end-of-ring bits as needed, and we set the ownership bits
896a94100faSBill Paul 	 * in all except the very first descriptor. (The caller will
897a94100faSBill Paul 	 * set this descriptor later when it start transmission or
898a94100faSBill Paul 	 * reception.)
899a94100faSBill Paul 	 */
900a94100faSBill Paul 	idx = ctx->rl_idx;
90159b5d934SBruce M Simpson 	for (;;) {
902a94100faSBill Paul 		u_int32_t		cmdstat;
903a94100faSBill Paul 		d = &ctx->rl_ring[idx];
904a94100faSBill Paul 		if (le32toh(d->rl_cmdstat) & RL_RDESC_STAT_OWN) {
905a94100faSBill Paul 			ctx->rl_maxsegs = 0;
906a94100faSBill Paul 			return;
907a94100faSBill Paul 		}
908a94100faSBill Paul 		cmdstat = segs[i].ds_len;
909a94100faSBill Paul 		d->rl_bufaddr_lo = htole32(RL_ADDR_LO(segs[i].ds_addr));
910a94100faSBill Paul 		d->rl_bufaddr_hi = htole32(RL_ADDR_HI(segs[i].ds_addr));
911a94100faSBill Paul 		if (i == 0)
912a94100faSBill Paul 			cmdstat |= RL_TDESC_CMD_SOF;
913a94100faSBill Paul 		else
914a94100faSBill Paul 			cmdstat |= RL_TDESC_CMD_OWN;
915a94100faSBill Paul 		if (idx == (RL_RX_DESC_CNT - 1))
916a94100faSBill Paul 			cmdstat |= RL_TDESC_CMD_EOR;
917a94100faSBill Paul 		d->rl_cmdstat = htole32(cmdstat | ctx->rl_flags);
918a94100faSBill Paul 		i++;
919a94100faSBill Paul 		if (i == nseg)
920a94100faSBill Paul 			break;
921a94100faSBill Paul 		RL_DESC_INC(idx);
922a94100faSBill Paul 	}
923a94100faSBill Paul 
924a94100faSBill Paul 	d->rl_cmdstat |= htole32(RL_TDESC_CMD_EOF);
925a94100faSBill Paul 	ctx->rl_maxsegs = nseg;
926a94100faSBill Paul 	ctx->rl_idx = idx;
927a94100faSBill Paul }
928a94100faSBill Paul 
929a94100faSBill Paul /*
930a94100faSBill Paul  * Map a single buffer address.
931a94100faSBill Paul  */
932a94100faSBill Paul 
933a94100faSBill Paul static void
934a94100faSBill Paul re_dma_map_addr(arg, segs, nseg, error)
935a94100faSBill Paul 	void			*arg;
936a94100faSBill Paul 	bus_dma_segment_t	*segs;
937a94100faSBill Paul 	int			nseg;
938a94100faSBill Paul 	int			error;
939a94100faSBill Paul {
940a94100faSBill Paul 	u_int32_t		*addr;
941a94100faSBill Paul 
942a94100faSBill Paul 	if (error)
943a94100faSBill Paul 		return;
944a94100faSBill Paul 
945a94100faSBill Paul 	KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg));
946a94100faSBill Paul 	addr = arg;
947a94100faSBill Paul 	*addr = segs->ds_addr;
948a94100faSBill Paul }
949a94100faSBill Paul 
950a94100faSBill Paul static int
951a94100faSBill Paul re_allocmem(dev, sc)
952a94100faSBill Paul 	device_t		dev;
953a94100faSBill Paul 	struct rl_softc		*sc;
954a94100faSBill Paul {
955a94100faSBill Paul 	int			error;
956a94100faSBill Paul 	int			nseg;
957a94100faSBill Paul 	int			i;
958a94100faSBill Paul 
959a94100faSBill Paul 	/*
960a94100faSBill Paul 	 * Allocate map for RX mbufs.
961a94100faSBill Paul 	 */
962a94100faSBill Paul 	nseg = 32;
963a94100faSBill Paul 	error = bus_dma_tag_create(sc->rl_parent_tag, ETHER_ALIGN, 0,
964a94100faSBill Paul 	    BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
9656110675fSBill Paul 	    NULL, MCLBYTES * nseg, nseg, MCLBYTES, BUS_DMA_ALLOCNOW,
966a94100faSBill Paul 	    NULL, NULL, &sc->rl_ldata.rl_mtag);
967a94100faSBill Paul 	if (error) {
968a94100faSBill Paul 		device_printf(dev, "could not allocate dma tag\n");
969a94100faSBill Paul 		return (ENOMEM);
970a94100faSBill Paul 	}
971a94100faSBill Paul 
972a94100faSBill Paul 	/*
973a94100faSBill Paul 	 * Allocate map for TX descriptor list.
974a94100faSBill Paul 	 */
975a94100faSBill Paul 	error = bus_dma_tag_create(sc->rl_parent_tag, RL_RING_ALIGN,
976a94100faSBill Paul 	    0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
977a94100faSBill Paul 	    NULL, RL_TX_LIST_SZ, 1, RL_TX_LIST_SZ, BUS_DMA_ALLOCNOW,
978a94100faSBill Paul 	    NULL, NULL, &sc->rl_ldata.rl_tx_list_tag);
979a94100faSBill Paul 	if (error) {
980a94100faSBill Paul 		device_printf(dev, "could not allocate dma tag\n");
981a94100faSBill Paul 		return (ENOMEM);
982a94100faSBill Paul 	}
983a94100faSBill Paul 
984a94100faSBill Paul 	/* Allocate DMA'able memory for the TX ring */
985a94100faSBill Paul 
986a94100faSBill Paul 	error = bus_dmamem_alloc(sc->rl_ldata.rl_tx_list_tag,
987a94100faSBill Paul 	    (void **)&sc->rl_ldata.rl_tx_list, BUS_DMA_NOWAIT | BUS_DMA_ZERO,
988a94100faSBill Paul 	    &sc->rl_ldata.rl_tx_list_map);
989a94100faSBill Paul 	if (error)
990a94100faSBill Paul 		return (ENOMEM);
991a94100faSBill Paul 
992a94100faSBill Paul 	/* Load the map for the TX ring. */
993a94100faSBill Paul 
994a94100faSBill Paul 	error = bus_dmamap_load(sc->rl_ldata.rl_tx_list_tag,
995a94100faSBill Paul 	     sc->rl_ldata.rl_tx_list_map, sc->rl_ldata.rl_tx_list,
996a94100faSBill Paul 	     RL_TX_LIST_SZ, re_dma_map_addr,
997a94100faSBill Paul 	     &sc->rl_ldata.rl_tx_list_addr, BUS_DMA_NOWAIT);
998a94100faSBill Paul 
999a94100faSBill Paul 	/* Create DMA maps for TX buffers */
1000a94100faSBill Paul 
1001a94100faSBill Paul 	for (i = 0; i < RL_TX_DESC_CNT; i++) {
1002a94100faSBill Paul 		error = bus_dmamap_create(sc->rl_ldata.rl_mtag, 0,
1003a94100faSBill Paul 			    &sc->rl_ldata.rl_tx_dmamap[i]);
1004a94100faSBill Paul 		if (error) {
1005a94100faSBill Paul 			device_printf(dev, "can't create DMA map for TX\n");
1006a94100faSBill Paul 			return (ENOMEM);
1007a94100faSBill Paul 		}
1008a94100faSBill Paul 	}
1009a94100faSBill Paul 
1010a94100faSBill Paul 	/*
1011a94100faSBill Paul 	 * Allocate map for RX descriptor list.
1012a94100faSBill Paul 	 */
1013a94100faSBill Paul 	error = bus_dma_tag_create(sc->rl_parent_tag, RL_RING_ALIGN,
1014a94100faSBill Paul 	    0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL,
101561021536SJohn-Mark Gurney 	    NULL, RL_RX_LIST_SZ, 1, RL_RX_LIST_SZ, BUS_DMA_ALLOCNOW,
1016a94100faSBill Paul 	    NULL, NULL, &sc->rl_ldata.rl_rx_list_tag);
1017a94100faSBill Paul 	if (error) {
1018a94100faSBill Paul 		device_printf(dev, "could not allocate dma tag\n");
1019a94100faSBill Paul 		return (ENOMEM);
1020a94100faSBill Paul 	}
1021a94100faSBill Paul 
1022a94100faSBill Paul 	/* Allocate DMA'able memory for the RX ring */
1023a94100faSBill Paul 
1024a94100faSBill Paul 	error = bus_dmamem_alloc(sc->rl_ldata.rl_rx_list_tag,
1025a94100faSBill Paul 	    (void **)&sc->rl_ldata.rl_rx_list, BUS_DMA_NOWAIT | BUS_DMA_ZERO,
1026a94100faSBill Paul 	    &sc->rl_ldata.rl_rx_list_map);
1027a94100faSBill Paul 	if (error)
1028a94100faSBill Paul 		return (ENOMEM);
1029a94100faSBill Paul 
1030a94100faSBill Paul 	/* Load the map for the RX ring. */
1031a94100faSBill Paul 
1032a94100faSBill Paul 	error = bus_dmamap_load(sc->rl_ldata.rl_rx_list_tag,
1033a94100faSBill Paul 	     sc->rl_ldata.rl_rx_list_map, sc->rl_ldata.rl_rx_list,
103461021536SJohn-Mark Gurney 	     RL_RX_LIST_SZ, re_dma_map_addr,
1035a94100faSBill Paul 	     &sc->rl_ldata.rl_rx_list_addr, BUS_DMA_NOWAIT);
1036a94100faSBill Paul 
1037a94100faSBill Paul 	/* Create DMA maps for RX buffers */
1038a94100faSBill Paul 
1039a94100faSBill Paul 	for (i = 0; i < RL_RX_DESC_CNT; i++) {
1040a94100faSBill Paul 		error = bus_dmamap_create(sc->rl_ldata.rl_mtag, 0,
1041a94100faSBill Paul 			    &sc->rl_ldata.rl_rx_dmamap[i]);
1042a94100faSBill Paul 		if (error) {
1043a94100faSBill Paul 			device_printf(dev, "can't create DMA map for RX\n");
1044a94100faSBill Paul 			return (ENOMEM);
1045a94100faSBill Paul 		}
1046a94100faSBill Paul 	}
1047a94100faSBill Paul 
1048a94100faSBill Paul 	return (0);
1049a94100faSBill Paul }
1050a94100faSBill Paul 
1051a94100faSBill Paul /*
1052a94100faSBill Paul  * Attach the interface. Allocate softc structures, do ifmedia
1053a94100faSBill Paul  * setup and ethernet/BPF attach.
1054a94100faSBill Paul  */
1055a94100faSBill Paul static int
1056a94100faSBill Paul re_attach(dev)
1057a94100faSBill Paul 	device_t		dev;
1058a94100faSBill Paul {
1059a94100faSBill Paul 	u_char			eaddr[ETHER_ADDR_LEN];
1060a94100faSBill Paul 	u_int16_t		as[3];
1061a94100faSBill Paul 	struct rl_softc		*sc;
1062a94100faSBill Paul 	struct ifnet		*ifp;
1063a94100faSBill Paul 	struct rl_hwrev		*hw_rev;
1064a94100faSBill Paul 	int			hwrev;
1065a94100faSBill Paul 	u_int16_t		re_did = 0;
1066a94100faSBill Paul 	int			unit, error = 0, rid, i;
1067a94100faSBill Paul 
1068a94100faSBill Paul 	sc = device_get_softc(dev);
1069a94100faSBill Paul 	unit = device_get_unit(dev);
1070a94100faSBill Paul 
1071a94100faSBill Paul 	mtx_init(&sc->rl_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
107297b9d4baSJohn-Mark Gurney 	    MTX_DEF);
1073a94100faSBill Paul 	/*
1074a94100faSBill Paul 	 * Map control/status registers.
1075a94100faSBill Paul 	 */
1076a94100faSBill Paul 	pci_enable_busmaster(dev);
1077a94100faSBill Paul 
1078a94100faSBill Paul 	rid = RL_RID;
10795f96beb9SNate Lawson 	sc->rl_res = bus_alloc_resource_any(dev, RL_RES, &rid,
10805f96beb9SNate Lawson 	    RF_ACTIVE);
1081a94100faSBill Paul 
1082a94100faSBill Paul 	if (sc->rl_res == NULL) {
1083a94100faSBill Paul 		printf ("re%d: couldn't map ports/memory\n", unit);
1084a94100faSBill Paul 		error = ENXIO;
1085a94100faSBill Paul 		goto fail;
1086a94100faSBill Paul 	}
1087a94100faSBill Paul 
1088a94100faSBill Paul 	sc->rl_btag = rman_get_bustag(sc->rl_res);
1089a94100faSBill Paul 	sc->rl_bhandle = rman_get_bushandle(sc->rl_res);
1090a94100faSBill Paul 
1091a94100faSBill Paul 	/* Allocate interrupt */
1092a94100faSBill Paul 	rid = 0;
10935f96beb9SNate Lawson 	sc->rl_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
1094a94100faSBill Paul 	    RF_SHAREABLE | RF_ACTIVE);
1095a94100faSBill Paul 
1096a94100faSBill Paul 	if (sc->rl_irq == NULL) {
1097a94100faSBill Paul 		printf("re%d: couldn't map interrupt\n", unit);
1098a94100faSBill Paul 		error = ENXIO;
1099a94100faSBill Paul 		goto fail;
1100a94100faSBill Paul 	}
1101a94100faSBill Paul 
1102a94100faSBill Paul 	/* Reset the adapter. */
110397b9d4baSJohn-Mark Gurney 	RL_LOCK(sc);
1104a94100faSBill Paul 	re_reset(sc);
110597b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
1106abc8ff44SBill Paul 
1107abc8ff44SBill Paul 	hw_rev = re_hwrevs;
1108abc8ff44SBill Paul 	hwrev = CSR_READ_4(sc, RL_TXCFG) & RL_TXCFG_HWREV;
1109abc8ff44SBill Paul 	while (hw_rev->rl_desc != NULL) {
1110abc8ff44SBill Paul 		if (hw_rev->rl_rev == hwrev) {
1111abc8ff44SBill Paul 			sc->rl_type = hw_rev->rl_type;
1112abc8ff44SBill Paul 			break;
1113abc8ff44SBill Paul 		}
1114abc8ff44SBill Paul 		hw_rev++;
1115abc8ff44SBill Paul 	}
1116abc8ff44SBill Paul 
1117abc8ff44SBill Paul 	if (sc->rl_type == RL_8169) {
1118abc8ff44SBill Paul 
1119abc8ff44SBill Paul 		/* Set RX length mask */
1120abc8ff44SBill Paul 
1121abc8ff44SBill Paul 		sc->rl_rxlenmask = RL_RDESC_STAT_GFRAGLEN;
1122abc8ff44SBill Paul 
1123abc8ff44SBill Paul 		/* Force station address autoload from the EEPROM */
1124abc8ff44SBill Paul 
1125abc8ff44SBill Paul 		CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_AUTOLOAD);
1126abc8ff44SBill Paul 		for (i = 0; i < RL_TIMEOUT; i++) {
1127abc8ff44SBill Paul 			if (!(CSR_READ_1(sc, RL_EECMD) & RL_EEMODE_AUTOLOAD))
1128abc8ff44SBill Paul 				break;
1129abc8ff44SBill Paul 			DELAY(100);
1130abc8ff44SBill Paul 		}
1131abc8ff44SBill Paul 		if (i == RL_TIMEOUT)
1132abc8ff44SBill Paul 			printf ("re%d: eeprom autoload timed out\n", unit);
1133abc8ff44SBill Paul 
1134abc8ff44SBill Paul 			for (i = 0; i < ETHER_ADDR_LEN; i++)
1135abc8ff44SBill Paul 				eaddr[i] = CSR_READ_1(sc, RL_IDR0 + i);
1136abc8ff44SBill Paul 	} else {
1137abc8ff44SBill Paul 
1138abc8ff44SBill Paul 		/* Set RX length mask */
1139abc8ff44SBill Paul 
1140abc8ff44SBill Paul 		sc->rl_rxlenmask = RL_RDESC_STAT_FRAGLEN;
1141abc8ff44SBill Paul 
1142a94100faSBill Paul 		sc->rl_eecmd_read = RL_EECMD_READ_6BIT;
1143a94100faSBill Paul 		re_read_eeprom(sc, (caddr_t)&re_did, 0, 1, 0);
1144a94100faSBill Paul 		if (re_did != 0x8129)
1145a94100faSBill Paul 			sc->rl_eecmd_read = RL_EECMD_READ_8BIT;
1146a94100faSBill Paul 
1147a94100faSBill Paul 		/*
1148a94100faSBill Paul 		 * Get station address from the EEPROM.
1149a94100faSBill Paul 		 */
1150a94100faSBill Paul 		re_read_eeprom(sc, (caddr_t)as, RL_EE_EADDR, 3, 0);
1151a94100faSBill Paul 		for (i = 0; i < 3; i++) {
1152a94100faSBill Paul 			eaddr[(i * 2) + 0] = as[i] & 0xff;
1153a94100faSBill Paul 			eaddr[(i * 2) + 1] = as[i] >> 8;
1154a94100faSBill Paul 		}
1155abc8ff44SBill Paul 	}
11569bac70b8SBill Paul 
1157a94100faSBill Paul 	sc->rl_unit = unit;
1158a94100faSBill Paul 	bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
1159a94100faSBill Paul 
1160a94100faSBill Paul 	/*
1161a94100faSBill Paul 	 * Allocate the parent bus DMA tag appropriate for PCI.
1162a94100faSBill Paul 	 */
1163a94100faSBill Paul #define RL_NSEG_NEW 32
1164a94100faSBill Paul 	error = bus_dma_tag_create(NULL,	/* parent */
1165a94100faSBill Paul 			1, 0,			/* alignment, boundary */
1166a94100faSBill Paul 			BUS_SPACE_MAXADDR_32BIT,/* lowaddr */
1167a94100faSBill Paul 			BUS_SPACE_MAXADDR,	/* highaddr */
1168a94100faSBill Paul 			NULL, NULL,		/* filter, filterarg */
1169a94100faSBill Paul 			MAXBSIZE, RL_NSEG_NEW,	/* maxsize, nsegments */
1170a94100faSBill Paul 			BUS_SPACE_MAXSIZE_32BIT,/* maxsegsize */
1171a94100faSBill Paul 			BUS_DMA_ALLOCNOW,	/* flags */
1172a94100faSBill Paul 			NULL, NULL,		/* lockfunc, lockarg */
1173a94100faSBill Paul 			&sc->rl_parent_tag);
1174a94100faSBill Paul 	if (error)
1175a94100faSBill Paul 		goto fail;
1176a94100faSBill Paul 
1177a94100faSBill Paul 	error = re_allocmem(dev, sc);
1178a94100faSBill Paul 
1179a94100faSBill Paul 	if (error)
1180a94100faSBill Paul 		goto fail;
1181a94100faSBill Paul 
1182a94100faSBill Paul 	/* Do MII setup */
1183a94100faSBill Paul 	if (mii_phy_probe(dev, &sc->rl_miibus,
1184a94100faSBill Paul 	    re_ifmedia_upd, re_ifmedia_sts)) {
1185a94100faSBill Paul 		printf("re%d: MII without any phy!\n", sc->rl_unit);
1186a94100faSBill Paul 		error = ENXIO;
1187a94100faSBill Paul 		goto fail;
1188a94100faSBill Paul 	}
1189a94100faSBill Paul 
1190a94100faSBill Paul 	ifp = &sc->arpcom.ac_if;
1191a94100faSBill Paul 	ifp->if_softc = sc;
11929bf40edeSBrooks Davis 	if_initname(ifp, device_get_name(dev), device_get_unit(dev));
1193a94100faSBill Paul 	ifp->if_mtu = ETHERMTU;
1194a94100faSBill Paul 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1195a94100faSBill Paul 	ifp->if_ioctl = re_ioctl;
1196a94100faSBill Paul 	ifp->if_capabilities = IFCAP_VLAN_MTU;
1197a94100faSBill Paul 	ifp->if_start = re_start;
1198328b4b87SOlivier Houchard 	ifp->if_hwassist = /*RE_CSUM_FEATURES*/0;
1199a94100faSBill Paul 	ifp->if_capabilities |= IFCAP_HWCSUM|IFCAP_VLAN_HWTAGGING;
1200f4ab22c9SRuslan Ermilov #ifdef DEVICE_POLLING
1201f4ab22c9SRuslan Ermilov 	ifp->if_capabilities |= IFCAP_POLLING;
1202f4ab22c9SRuslan Ermilov #endif
1203a94100faSBill Paul 	ifp->if_watchdog = re_watchdog;
1204a94100faSBill Paul 	ifp->if_init = re_init;
1205a94100faSBill Paul 	if (sc->rl_type == RL_8169)
1206a94100faSBill Paul 		ifp->if_baudrate = 1000000000;
1207a94100faSBill Paul 	else
1208a94100faSBill Paul 		ifp->if_baudrate = 100000000;
1209a94100faSBill Paul 	ifp->if_snd.ifq_maxlen = RL_IFQ_MAXLEN;
1210328b4b87SOlivier Houchard 	ifp->if_capenable = ifp->if_capabilities & ~IFCAP_HWCSUM;
1211a94100faSBill Paul 
1212a94100faSBill Paul 	callout_handle_init(&sc->rl_stat_ch);
1213a94100faSBill Paul 
1214a94100faSBill Paul 	/*
1215a94100faSBill Paul 	 * Call MI attach routine.
1216a94100faSBill Paul 	 */
1217a94100faSBill Paul 	ether_ifattach(ifp, eaddr);
1218a94100faSBill Paul 
1219a94100faSBill Paul 	/* Perform hardware diagnostic. */
1220a94100faSBill Paul 	error = re_diag(sc);
1221a94100faSBill Paul 
1222a94100faSBill Paul 	if (error) {
1223a94100faSBill Paul 		printf("re%d: attach aborted due to hardware diag failure\n",
1224a94100faSBill Paul 		    unit);
1225a94100faSBill Paul 		ether_ifdetach(ifp);
1226a94100faSBill Paul 		goto fail;
1227a94100faSBill Paul 	}
1228a94100faSBill Paul 
1229a94100faSBill Paul 	/* Hook interrupt last to avoid having to lock softc */
123097b9d4baSJohn-Mark Gurney 	error = bus_setup_intr(dev, sc->rl_irq, INTR_TYPE_NET | INTR_MPSAFE,
1231a94100faSBill Paul 	    re_intr, sc, &sc->rl_intrhand);
1232a94100faSBill Paul 	if (error) {
1233a94100faSBill Paul 		printf("re%d: couldn't set up irq\n", unit);
1234a94100faSBill Paul 		ether_ifdetach(ifp);
1235a94100faSBill Paul 	}
1236a94100faSBill Paul 
1237a94100faSBill Paul fail:
1238a94100faSBill Paul 	if (error)
1239a94100faSBill Paul 		re_detach(dev);
1240a94100faSBill Paul 
1241a94100faSBill Paul 	return (error);
1242a94100faSBill Paul }
1243a94100faSBill Paul 
1244a94100faSBill Paul /*
1245a94100faSBill Paul  * Shutdown hardware and free up resources. This can be called any
1246a94100faSBill Paul  * time after the mutex has been initialized. It is called in both
1247a94100faSBill Paul  * the error case in attach and the normal detach case so it needs
1248a94100faSBill Paul  * to be careful about only freeing resources that have actually been
1249a94100faSBill Paul  * allocated.
1250a94100faSBill Paul  */
1251a94100faSBill Paul static int
1252a94100faSBill Paul re_detach(dev)
1253a94100faSBill Paul 	device_t		dev;
1254a94100faSBill Paul {
1255a94100faSBill Paul 	struct rl_softc		*sc;
1256a94100faSBill Paul 	struct ifnet		*ifp;
1257a94100faSBill Paul 	int			i;
125897b9d4baSJohn-Mark Gurney 	int			attached;
1259a94100faSBill Paul 
1260a94100faSBill Paul 	sc = device_get_softc(dev);
1261a94100faSBill Paul 	ifp = &sc->arpcom.ac_if;
1262aedd16d9SJohn-Mark Gurney 	KASSERT(mtx_initialized(&sc->rl_mtx), ("re mutex not initialized"));
126397b9d4baSJohn-Mark Gurney 
126497b9d4baSJohn-Mark Gurney 	attached = device_is_attached(dev);
126597b9d4baSJohn-Mark Gurney 	/* These should only be active if attach succeeded */
126697b9d4baSJohn-Mark Gurney 	if (attached)
126797b9d4baSJohn-Mark Gurney 		ether_ifdetach(ifp);
126897b9d4baSJohn-Mark Gurney 
126997b9d4baSJohn-Mark Gurney 	RL_LOCK(sc);
127097b9d4baSJohn-Mark Gurney #if 0
127197b9d4baSJohn-Mark Gurney 	sc->suspended = 1;
127297b9d4baSJohn-Mark Gurney #endif
1273a94100faSBill Paul 
1274a94100faSBill Paul 	/* These should only be active if attach succeeded */
127597b9d4baSJohn-Mark Gurney 	if (attached) {
1276a94100faSBill Paul 		re_stop(sc);
1277a94100faSBill Paul 		/*
1278a94100faSBill Paul 		 * Force off the IFF_UP flag here, in case someone
1279a94100faSBill Paul 		 * still had a BPF descriptor attached to this
128097b9d4baSJohn-Mark Gurney 		 * interface. If they do, ether_ifdetach() will cause
1281a94100faSBill Paul 		 * the BPF code to try and clear the promisc mode
1282a94100faSBill Paul 		 * flag, which will bubble down to re_ioctl(),
1283a94100faSBill Paul 		 * which will try to call re_init() again. This will
1284a94100faSBill Paul 		 * turn the NIC back on and restart the MII ticker,
1285a94100faSBill Paul 		 * which will panic the system when the kernel tries
1286a94100faSBill Paul 		 * to invoke the re_tick() function that isn't there
1287a94100faSBill Paul 		 * anymore.
1288a94100faSBill Paul 		 */
1289a94100faSBill Paul 		ifp->if_flags &= ~IFF_UP;
1290a94100faSBill Paul 	}
1291a94100faSBill Paul 	if (sc->rl_miibus)
1292a94100faSBill Paul 		device_delete_child(dev, sc->rl_miibus);
1293a94100faSBill Paul 	bus_generic_detach(dev);
1294a94100faSBill Paul 
129597b9d4baSJohn-Mark Gurney 	/*
129697b9d4baSJohn-Mark Gurney 	 * The rest is resource deallocation, so we should already be
129797b9d4baSJohn-Mark Gurney 	 * stopped here.
129897b9d4baSJohn-Mark Gurney 	 */
129997b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
130097b9d4baSJohn-Mark Gurney 
1301a94100faSBill Paul 	if (sc->rl_intrhand)
1302a94100faSBill Paul 		bus_teardown_intr(dev, sc->rl_irq, sc->rl_intrhand);
1303a94100faSBill Paul 	if (sc->rl_irq)
1304a94100faSBill Paul 		bus_release_resource(dev, SYS_RES_IRQ, 0, sc->rl_irq);
1305a94100faSBill Paul 	if (sc->rl_res)
1306a94100faSBill Paul 		bus_release_resource(dev, RL_RES, RL_RID, sc->rl_res);
1307a94100faSBill Paul 
1308a94100faSBill Paul 
1309a94100faSBill Paul 	/* Unload and free the RX DMA ring memory and map */
1310a94100faSBill Paul 
1311a94100faSBill Paul 	if (sc->rl_ldata.rl_rx_list_tag) {
1312a94100faSBill Paul 		bus_dmamap_unload(sc->rl_ldata.rl_rx_list_tag,
1313a94100faSBill Paul 		    sc->rl_ldata.rl_rx_list_map);
1314a94100faSBill Paul 		bus_dmamem_free(sc->rl_ldata.rl_rx_list_tag,
1315a94100faSBill Paul 		    sc->rl_ldata.rl_rx_list,
1316a94100faSBill Paul 		    sc->rl_ldata.rl_rx_list_map);
1317a94100faSBill Paul 		bus_dma_tag_destroy(sc->rl_ldata.rl_rx_list_tag);
1318a94100faSBill Paul 	}
1319a94100faSBill Paul 
1320a94100faSBill Paul 	/* Unload and free the TX DMA ring memory and map */
1321a94100faSBill Paul 
1322a94100faSBill Paul 	if (sc->rl_ldata.rl_tx_list_tag) {
1323a94100faSBill Paul 		bus_dmamap_unload(sc->rl_ldata.rl_tx_list_tag,
1324a94100faSBill Paul 		    sc->rl_ldata.rl_tx_list_map);
1325a94100faSBill Paul 		bus_dmamem_free(sc->rl_ldata.rl_tx_list_tag,
1326a94100faSBill Paul 		    sc->rl_ldata.rl_tx_list,
1327a94100faSBill Paul 		    sc->rl_ldata.rl_tx_list_map);
1328a94100faSBill Paul 		bus_dma_tag_destroy(sc->rl_ldata.rl_tx_list_tag);
1329a94100faSBill Paul 	}
1330a94100faSBill Paul 
1331a94100faSBill Paul 	/* Destroy all the RX and TX buffer maps */
1332a94100faSBill Paul 
1333a94100faSBill Paul 	if (sc->rl_ldata.rl_mtag) {
1334a94100faSBill Paul 		for (i = 0; i < RL_TX_DESC_CNT; i++)
1335a94100faSBill Paul 			bus_dmamap_destroy(sc->rl_ldata.rl_mtag,
1336a94100faSBill Paul 			    sc->rl_ldata.rl_tx_dmamap[i]);
1337a94100faSBill Paul 		for (i = 0; i < RL_RX_DESC_CNT; i++)
1338a94100faSBill Paul 			bus_dmamap_destroy(sc->rl_ldata.rl_mtag,
1339a94100faSBill Paul 			    sc->rl_ldata.rl_rx_dmamap[i]);
1340a94100faSBill Paul 		bus_dma_tag_destroy(sc->rl_ldata.rl_mtag);
1341a94100faSBill Paul 	}
1342a94100faSBill Paul 
1343a94100faSBill Paul 	/* Unload and free the stats buffer and map */
1344a94100faSBill Paul 
1345a94100faSBill Paul 	if (sc->rl_ldata.rl_stag) {
1346a94100faSBill Paul 		bus_dmamap_unload(sc->rl_ldata.rl_stag,
1347a94100faSBill Paul 		    sc->rl_ldata.rl_rx_list_map);
1348a94100faSBill Paul 		bus_dmamem_free(sc->rl_ldata.rl_stag,
1349a94100faSBill Paul 		    sc->rl_ldata.rl_stats,
1350a94100faSBill Paul 		    sc->rl_ldata.rl_smap);
1351a94100faSBill Paul 		bus_dma_tag_destroy(sc->rl_ldata.rl_stag);
1352a94100faSBill Paul 	}
1353a94100faSBill Paul 
1354a94100faSBill Paul 	if (sc->rl_parent_tag)
1355a94100faSBill Paul 		bus_dma_tag_destroy(sc->rl_parent_tag);
1356a94100faSBill Paul 
1357a94100faSBill Paul 	mtx_destroy(&sc->rl_mtx);
1358a94100faSBill Paul 
1359a94100faSBill Paul 	return (0);
1360a94100faSBill Paul }
1361a94100faSBill Paul 
1362a94100faSBill Paul static int
1363a94100faSBill Paul re_newbuf(sc, idx, m)
1364a94100faSBill Paul 	struct rl_softc		*sc;
1365a94100faSBill Paul 	int			idx;
1366a94100faSBill Paul 	struct mbuf		*m;
1367a94100faSBill Paul {
1368a94100faSBill Paul 	struct rl_dmaload_arg	arg;
1369a94100faSBill Paul 	struct mbuf		*n = NULL;
1370a94100faSBill Paul 	int			error;
1371a94100faSBill Paul 
1372a94100faSBill Paul 	if (m == NULL) {
1373a94100faSBill Paul 		n = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
1374a94100faSBill Paul 		if (n == NULL)
1375a94100faSBill Paul 			return (ENOBUFS);
1376a94100faSBill Paul 		m = n;
1377a94100faSBill Paul 	} else
1378a94100faSBill Paul 		m->m_data = m->m_ext.ext_buf;
1379a94100faSBill Paul 
1380a94100faSBill Paul 	m->m_len = m->m_pkthdr.len = MCLBYTES;
138122a11c96SJohn-Mark Gurney #ifdef RE_FIXUP_RX
138222a11c96SJohn-Mark Gurney 	/*
138322a11c96SJohn-Mark Gurney 	 * This is part of an evil trick to deal with non-x86 platforms.
138422a11c96SJohn-Mark Gurney 	 * The RealTek chip requires RX buffers to be aligned on 64-bit
138522a11c96SJohn-Mark Gurney 	 * boundaries, but that will hose non-x86 machines. To get around
138622a11c96SJohn-Mark Gurney 	 * this, we leave some empty space at the start of each buffer
138722a11c96SJohn-Mark Gurney 	 * and for non-x86 hosts, we copy the buffer back six bytes
138822a11c96SJohn-Mark Gurney 	 * to achieve word alignment. This is slightly more efficient
138922a11c96SJohn-Mark Gurney 	 * than allocating a new buffer, copying the contents, and
139022a11c96SJohn-Mark Gurney 	 * discarding the old buffer.
139122a11c96SJohn-Mark Gurney 	 */
139222a11c96SJohn-Mark Gurney 	m_adj(m, RE_ETHER_ALIGN);
139322a11c96SJohn-Mark Gurney #endif
1394a94100faSBill Paul 	arg.sc = sc;
1395a94100faSBill Paul 	arg.rl_idx = idx;
1396a94100faSBill Paul 	arg.rl_maxsegs = 1;
1397a94100faSBill Paul 	arg.rl_flags = 0;
1398a94100faSBill Paul 	arg.rl_ring = sc->rl_ldata.rl_rx_list;
1399a94100faSBill Paul 
1400a94100faSBill Paul 	error = bus_dmamap_load_mbuf(sc->rl_ldata.rl_mtag,
1401a94100faSBill Paul 	    sc->rl_ldata.rl_rx_dmamap[idx], m, re_dma_map_desc,
1402a94100faSBill Paul 	    &arg, BUS_DMA_NOWAIT);
1403a94100faSBill Paul 	if (error || arg.rl_maxsegs != 1) {
1404a94100faSBill Paul 		if (n != NULL)
1405a94100faSBill Paul 			m_freem(n);
1406a94100faSBill Paul 		return (ENOMEM);
1407a94100faSBill Paul 	}
1408a94100faSBill Paul 
1409a94100faSBill Paul 	sc->rl_ldata.rl_rx_list[idx].rl_cmdstat |= htole32(RL_RDESC_CMD_OWN);
1410a94100faSBill Paul 	sc->rl_ldata.rl_rx_mbuf[idx] = m;
1411a94100faSBill Paul 
1412a94100faSBill Paul 	bus_dmamap_sync(sc->rl_ldata.rl_mtag,
1413a94100faSBill Paul 	    sc->rl_ldata.rl_rx_dmamap[idx],
1414a94100faSBill Paul 	    BUS_DMASYNC_PREREAD);
1415a94100faSBill Paul 
1416a94100faSBill Paul 	return (0);
1417a94100faSBill Paul }
1418a94100faSBill Paul 
141922a11c96SJohn-Mark Gurney #ifdef RE_FIXUP_RX
142022a11c96SJohn-Mark Gurney static __inline void
142122a11c96SJohn-Mark Gurney re_fixup_rx(m)
142222a11c96SJohn-Mark Gurney 	struct mbuf		*m;
142322a11c96SJohn-Mark Gurney {
142422a11c96SJohn-Mark Gurney 	int                     i;
142522a11c96SJohn-Mark Gurney 	uint16_t                *src, *dst;
142622a11c96SJohn-Mark Gurney 
142722a11c96SJohn-Mark Gurney 	src = mtod(m, uint16_t *);
142822a11c96SJohn-Mark Gurney 	dst = src - (RE_ETHER_ALIGN - ETHER_ALIGN) / sizeof *src;
142922a11c96SJohn-Mark Gurney 
143022a11c96SJohn-Mark Gurney 	for (i = 0; i < (m->m_len / sizeof(uint16_t) + 1); i++)
143122a11c96SJohn-Mark Gurney 		*dst++ = *src++;
143222a11c96SJohn-Mark Gurney 
143322a11c96SJohn-Mark Gurney 	m->m_data -= RE_ETHER_ALIGN - ETHER_ALIGN;
143422a11c96SJohn-Mark Gurney 
143522a11c96SJohn-Mark Gurney 	return;
143622a11c96SJohn-Mark Gurney }
143722a11c96SJohn-Mark Gurney #endif
143822a11c96SJohn-Mark Gurney 
1439a94100faSBill Paul static int
1440a94100faSBill Paul re_tx_list_init(sc)
1441a94100faSBill Paul 	struct rl_softc		*sc;
1442a94100faSBill Paul {
144397b9d4baSJohn-Mark Gurney 
144497b9d4baSJohn-Mark Gurney 	RL_LOCK_ASSERT(sc);
144597b9d4baSJohn-Mark Gurney 
1446a94100faSBill Paul 	bzero ((char *)sc->rl_ldata.rl_tx_list, RL_TX_LIST_SZ);
1447a94100faSBill Paul 	bzero ((char *)&sc->rl_ldata.rl_tx_mbuf,
1448a94100faSBill Paul 	    (RL_TX_DESC_CNT * sizeof(struct mbuf *)));
1449a94100faSBill Paul 
1450a94100faSBill Paul 	bus_dmamap_sync(sc->rl_ldata.rl_tx_list_tag,
1451a94100faSBill Paul 	    sc->rl_ldata.rl_tx_list_map, BUS_DMASYNC_PREWRITE);
1452a94100faSBill Paul 	sc->rl_ldata.rl_tx_prodidx = 0;
1453a94100faSBill Paul 	sc->rl_ldata.rl_tx_considx = 0;
1454a94100faSBill Paul 	sc->rl_ldata.rl_tx_free = RL_TX_DESC_CNT;
1455a94100faSBill Paul 
1456a94100faSBill Paul 	return (0);
1457a94100faSBill Paul }
1458a94100faSBill Paul 
1459a94100faSBill Paul static int
1460a94100faSBill Paul re_rx_list_init(sc)
1461a94100faSBill Paul 	struct rl_softc		*sc;
1462a94100faSBill Paul {
1463a94100faSBill Paul 	int			i;
1464a94100faSBill Paul 
1465a94100faSBill Paul 	bzero ((char *)sc->rl_ldata.rl_rx_list, RL_RX_LIST_SZ);
1466a94100faSBill Paul 	bzero ((char *)&sc->rl_ldata.rl_rx_mbuf,
1467a94100faSBill Paul 	    (RL_RX_DESC_CNT * sizeof(struct mbuf *)));
1468a94100faSBill Paul 
1469a94100faSBill Paul 	for (i = 0; i < RL_RX_DESC_CNT; i++) {
1470a94100faSBill Paul 		if (re_newbuf(sc, i, NULL) == ENOBUFS)
1471a94100faSBill Paul 			return (ENOBUFS);
1472a94100faSBill Paul 	}
1473a94100faSBill Paul 
1474a94100faSBill Paul 	/* Flush the RX descriptors */
1475a94100faSBill Paul 
1476a94100faSBill Paul 	bus_dmamap_sync(sc->rl_ldata.rl_rx_list_tag,
1477a94100faSBill Paul 	    sc->rl_ldata.rl_rx_list_map,
1478a94100faSBill Paul 	    BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
1479a94100faSBill Paul 
1480a94100faSBill Paul 	sc->rl_ldata.rl_rx_prodidx = 0;
1481a94100faSBill Paul 	sc->rl_head = sc->rl_tail = NULL;
1482a94100faSBill Paul 
1483a94100faSBill Paul 	return (0);
1484a94100faSBill Paul }
1485a94100faSBill Paul 
1486a94100faSBill Paul /*
1487a94100faSBill Paul  * RX handler for C+ and 8169. For the gigE chips, we support
1488a94100faSBill Paul  * the reception of jumbo frames that have been fragmented
1489a94100faSBill Paul  * across multiple 2K mbuf cluster buffers.
1490a94100faSBill Paul  */
1491a94100faSBill Paul static void
1492a94100faSBill Paul re_rxeof(sc)
1493a94100faSBill Paul 	struct rl_softc		*sc;
1494a94100faSBill Paul {
1495a94100faSBill Paul 	struct mbuf		*m;
1496a94100faSBill Paul 	struct ifnet		*ifp;
1497a94100faSBill Paul 	int			i, total_len;
1498a94100faSBill Paul 	struct rl_desc		*cur_rx;
1499a94100faSBill Paul 	u_int32_t		rxstat, rxvlan;
1500a94100faSBill Paul 
15015120abbfSSam Leffler 	RL_LOCK_ASSERT(sc);
15025120abbfSSam Leffler 
1503a94100faSBill Paul 	ifp = &sc->arpcom.ac_if;
1504a94100faSBill Paul 	i = sc->rl_ldata.rl_rx_prodidx;
1505a94100faSBill Paul 
1506a94100faSBill Paul 	/* Invalidate the descriptor memory */
1507a94100faSBill Paul 
1508a94100faSBill Paul 	bus_dmamap_sync(sc->rl_ldata.rl_rx_list_tag,
1509a94100faSBill Paul 	    sc->rl_ldata.rl_rx_list_map,
1510a94100faSBill Paul 	    BUS_DMASYNC_POSTREAD);
1511a94100faSBill Paul 
1512a94100faSBill Paul 	while (!RL_OWN(&sc->rl_ldata.rl_rx_list[i])) {
1513a94100faSBill Paul 		cur_rx = &sc->rl_ldata.rl_rx_list[i];
1514a94100faSBill Paul 		m = sc->rl_ldata.rl_rx_mbuf[i];
1515a94100faSBill Paul 		total_len = RL_RXBYTES(cur_rx);
1516a94100faSBill Paul 		rxstat = le32toh(cur_rx->rl_cmdstat);
1517a94100faSBill Paul 		rxvlan = le32toh(cur_rx->rl_vlanctl);
1518a94100faSBill Paul 
1519a94100faSBill Paul 		/* Invalidate the RX mbuf and unload its map */
1520a94100faSBill Paul 
1521a94100faSBill Paul 		bus_dmamap_sync(sc->rl_ldata.rl_mtag,
1522a94100faSBill Paul 		    sc->rl_ldata.rl_rx_dmamap[i],
1523a94100faSBill Paul 		    BUS_DMASYNC_POSTWRITE);
1524a94100faSBill Paul 		bus_dmamap_unload(sc->rl_ldata.rl_mtag,
1525a94100faSBill Paul 		    sc->rl_ldata.rl_rx_dmamap[i]);
1526a94100faSBill Paul 
1527a94100faSBill Paul 		if (!(rxstat & RL_RDESC_STAT_EOF)) {
152822a11c96SJohn-Mark Gurney 			m->m_len = RE_RX_DESC_BUFLEN;
1529a94100faSBill Paul 			if (sc->rl_head == NULL)
1530a94100faSBill Paul 				sc->rl_head = sc->rl_tail = m;
1531a94100faSBill Paul 			else {
1532a94100faSBill Paul 				m->m_flags &= ~M_PKTHDR;
1533a94100faSBill Paul 				sc->rl_tail->m_next = m;
1534a94100faSBill Paul 				sc->rl_tail = m;
1535a94100faSBill Paul 			}
1536a94100faSBill Paul 			re_newbuf(sc, i, NULL);
1537a94100faSBill Paul 			RL_DESC_INC(i);
1538a94100faSBill Paul 			continue;
1539a94100faSBill Paul 		}
1540a94100faSBill Paul 
1541a94100faSBill Paul 		/*
1542a94100faSBill Paul 		 * NOTE: for the 8139C+, the frame length field
1543a94100faSBill Paul 		 * is always 12 bits in size, but for the gigE chips,
1544a94100faSBill Paul 		 * it is 13 bits (since the max RX frame length is 16K).
1545a94100faSBill Paul 		 * Unfortunately, all 32 bits in the status word
1546a94100faSBill Paul 		 * were already used, so to make room for the extra
1547a94100faSBill Paul 		 * length bit, RealTek took out the 'frame alignment
1548a94100faSBill Paul 		 * error' bit and shifted the other status bits
1549a94100faSBill Paul 		 * over one slot. The OWN, EOR, FS and LS bits are
1550a94100faSBill Paul 		 * still in the same places. We have already extracted
1551a94100faSBill Paul 		 * the frame length and checked the OWN bit, so rather
1552a94100faSBill Paul 		 * than using an alternate bit mapping, we shift the
1553a94100faSBill Paul 		 * status bits one space to the right so we can evaluate
1554a94100faSBill Paul 		 * them using the 8169 status as though it was in the
1555a94100faSBill Paul 		 * same format as that of the 8139C+.
1556a94100faSBill Paul 		 */
1557a94100faSBill Paul 		if (sc->rl_type == RL_8169)
1558a94100faSBill Paul 			rxstat >>= 1;
1559a94100faSBill Paul 
156022a11c96SJohn-Mark Gurney 		/*
156122a11c96SJohn-Mark Gurney 		 * if total_len > 2^13-1, both _RXERRSUM and _GIANT will be
156222a11c96SJohn-Mark Gurney 		 * set, but if CRC is clear, it will still be a valid frame.
156322a11c96SJohn-Mark Gurney 		 */
156422a11c96SJohn-Mark Gurney 		if (rxstat & RL_RDESC_STAT_RXERRSUM && !(total_len > 8191 &&
156522a11c96SJohn-Mark Gurney 		    (rxstat & RL_RDESC_STAT_ERRS) == RL_RDESC_STAT_GIANT)) {
1566a94100faSBill Paul 			ifp->if_ierrors++;
1567a94100faSBill Paul 			/*
1568a94100faSBill Paul 			 * If this is part of a multi-fragment packet,
1569a94100faSBill Paul 			 * discard all the pieces.
1570a94100faSBill Paul 			 */
1571a94100faSBill Paul 			if (sc->rl_head != NULL) {
1572a94100faSBill Paul 				m_freem(sc->rl_head);
1573a94100faSBill Paul 				sc->rl_head = sc->rl_tail = NULL;
1574a94100faSBill Paul 			}
1575a94100faSBill Paul 			re_newbuf(sc, i, m);
1576a94100faSBill Paul 			RL_DESC_INC(i);
1577a94100faSBill Paul 			continue;
1578a94100faSBill Paul 		}
1579a94100faSBill Paul 
1580a94100faSBill Paul 		/*
1581a94100faSBill Paul 		 * If allocating a replacement mbuf fails,
1582a94100faSBill Paul 		 * reload the current one.
1583a94100faSBill Paul 		 */
1584a94100faSBill Paul 
1585a94100faSBill Paul 		if (re_newbuf(sc, i, NULL)) {
1586a94100faSBill Paul 			ifp->if_ierrors++;
1587a94100faSBill Paul 			if (sc->rl_head != NULL) {
1588a94100faSBill Paul 				m_freem(sc->rl_head);
1589a94100faSBill Paul 				sc->rl_head = sc->rl_tail = NULL;
1590a94100faSBill Paul 			}
1591a94100faSBill Paul 			re_newbuf(sc, i, m);
1592a94100faSBill Paul 			RL_DESC_INC(i);
1593a94100faSBill Paul 			continue;
1594a94100faSBill Paul 		}
1595a94100faSBill Paul 
1596a94100faSBill Paul 		RL_DESC_INC(i);
1597a94100faSBill Paul 
1598a94100faSBill Paul 		if (sc->rl_head != NULL) {
159922a11c96SJohn-Mark Gurney 			m->m_len = total_len % RE_RX_DESC_BUFLEN;
160022a11c96SJohn-Mark Gurney 			if (m->m_len == 0)
160122a11c96SJohn-Mark Gurney 				m->m_len = RE_RX_DESC_BUFLEN;
1602a94100faSBill Paul 			/*
1603a94100faSBill Paul 			 * Special case: if there's 4 bytes or less
1604a94100faSBill Paul 			 * in this buffer, the mbuf can be discarded:
1605a94100faSBill Paul 			 * the last 4 bytes is the CRC, which we don't
1606a94100faSBill Paul 			 * care about anyway.
1607a94100faSBill Paul 			 */
1608a94100faSBill Paul 			if (m->m_len <= ETHER_CRC_LEN) {
1609a94100faSBill Paul 				sc->rl_tail->m_len -=
1610a94100faSBill Paul 				    (ETHER_CRC_LEN - m->m_len);
1611a94100faSBill Paul 				m_freem(m);
1612a94100faSBill Paul 			} else {
1613a94100faSBill Paul 				m->m_len -= ETHER_CRC_LEN;
1614a94100faSBill Paul 				m->m_flags &= ~M_PKTHDR;
1615a94100faSBill Paul 				sc->rl_tail->m_next = m;
1616a94100faSBill Paul 			}
1617a94100faSBill Paul 			m = sc->rl_head;
1618a94100faSBill Paul 			sc->rl_head = sc->rl_tail = NULL;
1619a94100faSBill Paul 			m->m_pkthdr.len = total_len - ETHER_CRC_LEN;
1620a94100faSBill Paul 		} else
1621a94100faSBill Paul 			m->m_pkthdr.len = m->m_len =
1622a94100faSBill Paul 			    (total_len - ETHER_CRC_LEN);
1623a94100faSBill Paul 
162422a11c96SJohn-Mark Gurney #ifdef RE_FIXUP_RX
162522a11c96SJohn-Mark Gurney 		re_fixup_rx(m);
162622a11c96SJohn-Mark Gurney #endif
1627a94100faSBill Paul 		ifp->if_ipackets++;
1628a94100faSBill Paul 		m->m_pkthdr.rcvif = ifp;
1629a94100faSBill Paul 
1630a94100faSBill Paul 		/* Do RX checksumming if enabled */
1631a94100faSBill Paul 
1632a94100faSBill Paul 		if (ifp->if_capenable & IFCAP_RXCSUM) {
1633a94100faSBill Paul 
1634a94100faSBill Paul 			/* Check IP header checksum */
1635a94100faSBill Paul 			if (rxstat & RL_RDESC_STAT_PROTOID)
1636a94100faSBill Paul 				m->m_pkthdr.csum_flags |= CSUM_IP_CHECKED;
1637a94100faSBill Paul 			if (!(rxstat & RL_RDESC_STAT_IPSUMBAD))
1638a94100faSBill Paul 				m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
1639a94100faSBill Paul 
1640a94100faSBill Paul 			/* Check TCP/UDP checksum */
1641a94100faSBill Paul 			if ((RL_TCPPKT(rxstat) &&
1642a94100faSBill Paul 			    !(rxstat & RL_RDESC_STAT_TCPSUMBAD)) ||
1643a94100faSBill Paul 			    (RL_UDPPKT(rxstat) &&
1644a94100faSBill Paul 			    !(rxstat & RL_RDESC_STAT_UDPSUMBAD))) {
1645a94100faSBill Paul 				m->m_pkthdr.csum_flags |=
1646a94100faSBill Paul 				    CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
1647a94100faSBill Paul 				m->m_pkthdr.csum_data = 0xffff;
1648a94100faSBill Paul 			}
1649a94100faSBill Paul 		}
1650a94100faSBill Paul 
1651a94100faSBill Paul 		if (rxvlan & RL_RDESC_VLANCTL_TAG)
1652a94100faSBill Paul 			VLAN_INPUT_TAG(ifp, m,
1653a94100faSBill Paul 			    ntohs((rxvlan & RL_RDESC_VLANCTL_DATA)), continue);
16545120abbfSSam Leffler 		RL_UNLOCK(sc);
1655a94100faSBill Paul 		(*ifp->if_input)(ifp, m);
16565120abbfSSam Leffler 		RL_LOCK(sc);
1657a94100faSBill Paul 	}
1658a94100faSBill Paul 
1659a94100faSBill Paul 	/* Flush the RX DMA ring */
1660a94100faSBill Paul 
1661a94100faSBill Paul 	bus_dmamap_sync(sc->rl_ldata.rl_rx_list_tag,
1662a94100faSBill Paul 	    sc->rl_ldata.rl_rx_list_map,
1663a94100faSBill Paul 	    BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
1664a94100faSBill Paul 
1665a94100faSBill Paul 	sc->rl_ldata.rl_rx_prodidx = i;
1666a94100faSBill Paul }
1667a94100faSBill Paul 
1668a94100faSBill Paul static void
1669a94100faSBill Paul re_txeof(sc)
1670a94100faSBill Paul 	struct rl_softc		*sc;
1671a94100faSBill Paul {
1672a94100faSBill Paul 	struct ifnet		*ifp;
1673a94100faSBill Paul 	u_int32_t		txstat;
1674a94100faSBill Paul 	int			idx;
1675a94100faSBill Paul 
1676a94100faSBill Paul 	ifp = &sc->arpcom.ac_if;
1677a94100faSBill Paul 	idx = sc->rl_ldata.rl_tx_considx;
1678a94100faSBill Paul 
1679a94100faSBill Paul 	/* Invalidate the TX descriptor list */
1680a94100faSBill Paul 
1681a94100faSBill Paul 	bus_dmamap_sync(sc->rl_ldata.rl_tx_list_tag,
1682a94100faSBill Paul 	    sc->rl_ldata.rl_tx_list_map,
1683a94100faSBill Paul 	    BUS_DMASYNC_POSTREAD);
1684a94100faSBill Paul 
1685a94100faSBill Paul 	while (idx != sc->rl_ldata.rl_tx_prodidx) {
1686a94100faSBill Paul 
1687a94100faSBill Paul 		txstat = le32toh(sc->rl_ldata.rl_tx_list[idx].rl_cmdstat);
1688a94100faSBill Paul 		if (txstat & RL_TDESC_CMD_OWN)
1689a94100faSBill Paul 			break;
1690a94100faSBill Paul 
1691a94100faSBill Paul 		/*
1692a94100faSBill Paul 		 * We only stash mbufs in the last descriptor
1693a94100faSBill Paul 		 * in a fragment chain, which also happens to
1694a94100faSBill Paul 		 * be the only place where the TX status bits
1695a94100faSBill Paul 		 * are valid.
1696a94100faSBill Paul 		 */
1697a94100faSBill Paul 
1698a94100faSBill Paul 		if (txstat & RL_TDESC_CMD_EOF) {
1699a94100faSBill Paul 			m_freem(sc->rl_ldata.rl_tx_mbuf[idx]);
1700a94100faSBill Paul 			sc->rl_ldata.rl_tx_mbuf[idx] = NULL;
1701a94100faSBill Paul 			bus_dmamap_unload(sc->rl_ldata.rl_mtag,
1702a94100faSBill Paul 			    sc->rl_ldata.rl_tx_dmamap[idx]);
1703a94100faSBill Paul 			if (txstat & (RL_TDESC_STAT_EXCESSCOL|
1704a94100faSBill Paul 			    RL_TDESC_STAT_COLCNT))
1705a94100faSBill Paul 				ifp->if_collisions++;
1706a94100faSBill Paul 			if (txstat & RL_TDESC_STAT_TXERRSUM)
1707a94100faSBill Paul 				ifp->if_oerrors++;
1708a94100faSBill Paul 			else
1709a94100faSBill Paul 				ifp->if_opackets++;
1710a94100faSBill Paul 		}
1711a94100faSBill Paul 		sc->rl_ldata.rl_tx_free++;
1712a94100faSBill Paul 		RL_DESC_INC(idx);
1713a94100faSBill Paul 	}
1714a94100faSBill Paul 
1715a94100faSBill Paul 	/* No changes made to the TX ring, so no flush needed */
1716a94100faSBill Paul 
1717a94100faSBill Paul 	if (idx != sc->rl_ldata.rl_tx_considx) {
1718a94100faSBill Paul 		sc->rl_ldata.rl_tx_considx = idx;
1719a94100faSBill Paul 		ifp->if_flags &= ~IFF_OACTIVE;
1720a94100faSBill Paul 		ifp->if_timer = 0;
1721a94100faSBill Paul 	}
1722a94100faSBill Paul 
1723a94100faSBill Paul 	/*
1724a94100faSBill Paul 	 * If not all descriptors have been released reaped yet,
1725a94100faSBill Paul 	 * reload the timer so that we will eventually get another
1726a94100faSBill Paul 	 * interrupt that will cause us to re-enter this routine.
1727a94100faSBill Paul 	 * This is done in case the transmitter has gone idle.
1728a94100faSBill Paul 	 */
1729a94100faSBill Paul 	if (sc->rl_ldata.rl_tx_free != RL_TX_DESC_CNT)
1730a94100faSBill Paul 		CSR_WRITE_4(sc, RL_TIMERCNT, 1);
1731a94100faSBill Paul }
1732a94100faSBill Paul 
1733a94100faSBill Paul static void
1734a94100faSBill Paul re_tick(xsc)
1735a94100faSBill Paul 	void			*xsc;
1736a94100faSBill Paul {
1737a94100faSBill Paul 	struct rl_softc		*sc;
1738a94100faSBill Paul 
1739a94100faSBill Paul 	sc = xsc;
1740a94100faSBill Paul 	RL_LOCK(sc);
174197b9d4baSJohn-Mark Gurney 	re_tick_locked(sc);
174297b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
174397b9d4baSJohn-Mark Gurney }
174497b9d4baSJohn-Mark Gurney 
174597b9d4baSJohn-Mark Gurney static void
174697b9d4baSJohn-Mark Gurney re_tick_locked(sc)
174797b9d4baSJohn-Mark Gurney 	struct rl_softc		*sc;
174897b9d4baSJohn-Mark Gurney {
174997b9d4baSJohn-Mark Gurney 	struct mii_data		*mii;
175097b9d4baSJohn-Mark Gurney 
175197b9d4baSJohn-Mark Gurney 	RL_LOCK_ASSERT(sc);
175297b9d4baSJohn-Mark Gurney 
1753a94100faSBill Paul 	mii = device_get_softc(sc->rl_miibus);
1754a94100faSBill Paul 
1755a94100faSBill Paul 	mii_tick(mii);
1756a94100faSBill Paul 
1757a94100faSBill Paul 	sc->rl_stat_ch = timeout(re_tick, sc, hz);
1758a94100faSBill Paul }
1759a94100faSBill Paul 
1760a94100faSBill Paul #ifdef DEVICE_POLLING
1761a94100faSBill Paul static void
1762a94100faSBill Paul re_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
1763a94100faSBill Paul {
1764a94100faSBill Paul 	struct rl_softc *sc = ifp->if_softc;
1765a94100faSBill Paul 
1766a94100faSBill Paul 	RL_LOCK(sc);
176797b9d4baSJohn-Mark Gurney 	re_poll_locked(ifp, cmd, count);
176897b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
176997b9d4baSJohn-Mark Gurney }
177097b9d4baSJohn-Mark Gurney 
177197b9d4baSJohn-Mark Gurney static void
177297b9d4baSJohn-Mark Gurney re_poll_locked(struct ifnet *ifp, enum poll_cmd cmd, int count)
177397b9d4baSJohn-Mark Gurney {
177497b9d4baSJohn-Mark Gurney 	struct rl_softc *sc = ifp->if_softc;
177597b9d4baSJohn-Mark Gurney 
177697b9d4baSJohn-Mark Gurney 	RL_LOCK_ASSERT(sc);
177797b9d4baSJohn-Mark Gurney 
1778f4ab22c9SRuslan Ermilov 	if (!(ifp->if_capenable & IFCAP_POLLING)) {
1779f4ab22c9SRuslan Ermilov 		ether_poll_deregister(ifp);
1780f4ab22c9SRuslan Ermilov 		cmd = POLL_DEREGISTER;
1781f4ab22c9SRuslan Ermilov 	}
1782a94100faSBill Paul 	if (cmd == POLL_DEREGISTER) { /* final call, enable interrupts */
1783a94100faSBill Paul 		CSR_WRITE_2(sc, RL_IMR, RL_INTRS_CPLUS);
178497b9d4baSJohn-Mark Gurney 		return;
1785a94100faSBill Paul 	}
1786a94100faSBill Paul 
1787a94100faSBill Paul 	sc->rxcycles = count;
1788a94100faSBill Paul 	re_rxeof(sc);
1789a94100faSBill Paul 	re_txeof(sc);
1790a94100faSBill Paul 
1791a94100faSBill Paul 	if (ifp->if_snd.ifq_head != NULL)
179297b9d4baSJohn-Mark Gurney 		re_start_locked(ifp);
1793a94100faSBill Paul 
1794a94100faSBill Paul 	if (cmd == POLL_AND_CHECK_STATUS) { /* also check status register */
1795a94100faSBill Paul 		u_int16_t       status;
1796a94100faSBill Paul 
1797a94100faSBill Paul 		status = CSR_READ_2(sc, RL_ISR);
1798a94100faSBill Paul 		if (status == 0xffff)
179997b9d4baSJohn-Mark Gurney 			return;
1800a94100faSBill Paul 		if (status)
1801a94100faSBill Paul 			CSR_WRITE_2(sc, RL_ISR, status);
1802a94100faSBill Paul 
1803a94100faSBill Paul 		/*
1804a94100faSBill Paul 		 * XXX check behaviour on receiver stalls.
1805a94100faSBill Paul 		 */
1806a94100faSBill Paul 
1807a94100faSBill Paul 		if (status & RL_ISR_SYSTEM_ERR) {
1808a94100faSBill Paul 			re_reset(sc);
180997b9d4baSJohn-Mark Gurney 			re_init_locked(sc);
1810a94100faSBill Paul 		}
1811a94100faSBill Paul 	}
1812a94100faSBill Paul }
1813a94100faSBill Paul #endif /* DEVICE_POLLING */
1814a94100faSBill Paul 
1815a94100faSBill Paul static void
1816a94100faSBill Paul re_intr(arg)
1817a94100faSBill Paul 	void			*arg;
1818a94100faSBill Paul {
1819a94100faSBill Paul 	struct rl_softc		*sc;
1820a94100faSBill Paul 	struct ifnet		*ifp;
1821a94100faSBill Paul 	u_int16_t		status;
1822a94100faSBill Paul 
1823a94100faSBill Paul 	sc = arg;
1824a94100faSBill Paul 
1825a94100faSBill Paul 	RL_LOCK(sc);
182697b9d4baSJohn-Mark Gurney 
1827a94100faSBill Paul 	ifp = &sc->arpcom.ac_if;
1828a94100faSBill Paul 
182997b9d4baSJohn-Mark Gurney 	if (sc->suspended || !(ifp->if_flags & IFF_UP))
183097b9d4baSJohn-Mark Gurney 		goto done_locked;
18319bac70b8SBill Paul 
1832a94100faSBill Paul #ifdef DEVICE_POLLING
1833a94100faSBill Paul 	if  (ifp->if_flags & IFF_POLLING)
183497b9d4baSJohn-Mark Gurney 		goto done_locked;
1835f4ab22c9SRuslan Ermilov 	if ((ifp->if_capenable & IFCAP_POLLING) &&
1836f4ab22c9SRuslan Ermilov 	    ether_poll_register(re_poll, ifp)) { /* ok, disable interrupts */
1837a94100faSBill Paul 		CSR_WRITE_2(sc, RL_IMR, 0x0000);
183897b9d4baSJohn-Mark Gurney 		re_poll_locked(ifp, 0, 1);
183997b9d4baSJohn-Mark Gurney 		goto done_locked;
1840a94100faSBill Paul 	}
1841a94100faSBill Paul #endif /* DEVICE_POLLING */
1842a94100faSBill Paul 
1843a94100faSBill Paul 	for (;;) {
1844a94100faSBill Paul 
1845a94100faSBill Paul 		status = CSR_READ_2(sc, RL_ISR);
1846a94100faSBill Paul 		/* If the card has gone away the read returns 0xffff. */
1847a94100faSBill Paul 		if (status == 0xffff)
1848a94100faSBill Paul 			break;
1849a94100faSBill Paul 		if (status)
1850a94100faSBill Paul 			CSR_WRITE_2(sc, RL_ISR, status);
1851a94100faSBill Paul 
1852a94100faSBill Paul 		if ((status & RL_INTRS_CPLUS) == 0)
1853a94100faSBill Paul 			break;
1854a94100faSBill Paul 
185561021536SJohn-Mark Gurney 		if ((status & RL_ISR_RX_OK) ||
185661021536SJohn-Mark Gurney 		    (status & RL_ISR_RX_ERR))
1857a94100faSBill Paul 			re_rxeof(sc);
1858a94100faSBill Paul 
1859a94100faSBill Paul 		if ((status & RL_ISR_TIMEOUT_EXPIRED) ||
1860a94100faSBill Paul 		    (status & RL_ISR_TX_ERR) ||
1861a94100faSBill Paul 		    (status & RL_ISR_TX_DESC_UNAVAIL))
1862a94100faSBill Paul 			re_txeof(sc);
1863a94100faSBill Paul 
1864a94100faSBill Paul 		if (status & RL_ISR_SYSTEM_ERR) {
1865a94100faSBill Paul 			re_reset(sc);
186697b9d4baSJohn-Mark Gurney 			re_init_locked(sc);
1867a94100faSBill Paul 		}
1868a94100faSBill Paul 
1869a94100faSBill Paul 		if (status & RL_ISR_LINKCHG) {
1870a94100faSBill Paul 			untimeout(re_tick, sc, sc->rl_stat_ch);
187197b9d4baSJohn-Mark Gurney 			re_tick_locked(sc);
1872a94100faSBill Paul 		}
1873a94100faSBill Paul 	}
1874a94100faSBill Paul 
1875a94100faSBill Paul 	if (ifp->if_snd.ifq_head != NULL)
187697b9d4baSJohn-Mark Gurney 		re_start_locked(ifp);
1877a94100faSBill Paul 
187897b9d4baSJohn-Mark Gurney done_locked:
1879a94100faSBill Paul 	RL_UNLOCK(sc);
1880a94100faSBill Paul }
1881a94100faSBill Paul 
1882a94100faSBill Paul static int
1883a94100faSBill Paul re_encap(sc, m_head, idx)
1884a94100faSBill Paul 	struct rl_softc		*sc;
188580a2a305SJohn-Mark Gurney 	struct mbuf		**m_head;
1886a94100faSBill Paul 	int			*idx;
1887a94100faSBill Paul {
1888a94100faSBill Paul 	struct mbuf		*m_new = NULL;
1889a94100faSBill Paul 	struct rl_dmaload_arg	arg;
1890a94100faSBill Paul 	bus_dmamap_t		map;
1891a94100faSBill Paul 	int			error;
1892a94100faSBill Paul 	struct m_tag		*mtag;
1893a94100faSBill Paul 
189497b9d4baSJohn-Mark Gurney 	RL_LOCK_ASSERT(sc);
189597b9d4baSJohn-Mark Gurney 
18967cae6651SBill Paul 	if (sc->rl_ldata.rl_tx_free <= 4)
1897a94100faSBill Paul 		return (EFBIG);
1898a94100faSBill Paul 
1899a94100faSBill Paul 	/*
1900a94100faSBill Paul 	 * Set up checksum offload. Note: checksum offload bits must
1901a94100faSBill Paul 	 * appear in all descriptors of a multi-descriptor transmit
190222a11c96SJohn-Mark Gurney 	 * attempt. This is according to testing done with an 8169
190322a11c96SJohn-Mark Gurney 	 * chip. This is a requirement.
1904a94100faSBill Paul 	 */
1905a94100faSBill Paul 
1906a94100faSBill Paul 	arg.rl_flags = 0;
1907a94100faSBill Paul 
190880a2a305SJohn-Mark Gurney 	if ((*m_head)->m_pkthdr.csum_flags & CSUM_IP)
1909a94100faSBill Paul 		arg.rl_flags |= RL_TDESC_CMD_IPCSUM;
191080a2a305SJohn-Mark Gurney 	if ((*m_head)->m_pkthdr.csum_flags & CSUM_TCP)
1911a94100faSBill Paul 		arg.rl_flags |= RL_TDESC_CMD_TCPCSUM;
191280a2a305SJohn-Mark Gurney 	if ((*m_head)->m_pkthdr.csum_flags & CSUM_UDP)
1913a94100faSBill Paul 		arg.rl_flags |= RL_TDESC_CMD_UDPCSUM;
1914a94100faSBill Paul 
1915a94100faSBill Paul 	arg.sc = sc;
1916a94100faSBill Paul 	arg.rl_idx = *idx;
1917a94100faSBill Paul 	arg.rl_maxsegs = sc->rl_ldata.rl_tx_free;
19187cae6651SBill Paul 	if (arg.rl_maxsegs > 4)
19197cae6651SBill Paul 		arg.rl_maxsegs -= 4;
1920a94100faSBill Paul 	arg.rl_ring = sc->rl_ldata.rl_tx_list;
1921a94100faSBill Paul 
1922a94100faSBill Paul 	map = sc->rl_ldata.rl_tx_dmamap[*idx];
1923a94100faSBill Paul 	error = bus_dmamap_load_mbuf(sc->rl_ldata.rl_mtag, map,
192480a2a305SJohn-Mark Gurney 	    *m_head, re_dma_map_desc, &arg, BUS_DMA_NOWAIT);
1925a94100faSBill Paul 
1926a94100faSBill Paul 	if (error && error != EFBIG) {
1927a94100faSBill Paul 		printf("re%d: can't map mbuf (error %d)\n", sc->rl_unit, error);
1928a94100faSBill Paul 		return (ENOBUFS);
1929a94100faSBill Paul 	}
1930a94100faSBill Paul 
1931a94100faSBill Paul 	/* Too many segments to map, coalesce into a single mbuf */
1932a94100faSBill Paul 
1933a94100faSBill Paul 	if (error || arg.rl_maxsegs == 0) {
193480a2a305SJohn-Mark Gurney 		m_new = m_defrag(*m_head, M_DONTWAIT);
1935a94100faSBill Paul 		if (m_new == NULL)
193680a2a305SJohn-Mark Gurney 			return (ENOBUFS);
1937a94100faSBill Paul 		else
193880a2a305SJohn-Mark Gurney 			*m_head = m_new;
1939a94100faSBill Paul 
1940a94100faSBill Paul 		arg.sc = sc;
1941a94100faSBill Paul 		arg.rl_idx = *idx;
1942a94100faSBill Paul 		arg.rl_maxsegs = sc->rl_ldata.rl_tx_free;
1943a94100faSBill Paul 		arg.rl_ring = sc->rl_ldata.rl_tx_list;
1944a94100faSBill Paul 
1945a94100faSBill Paul 		error = bus_dmamap_load_mbuf(sc->rl_ldata.rl_mtag, map,
194680a2a305SJohn-Mark Gurney 		    *m_head, re_dma_map_desc, &arg, BUS_DMA_NOWAIT);
1947a94100faSBill Paul 		if (error) {
1948a94100faSBill Paul 			printf("re%d: can't map mbuf (error %d)\n",
1949a94100faSBill Paul 			    sc->rl_unit, error);
1950a94100faSBill Paul 			return (EFBIG);
1951a94100faSBill Paul 		}
1952a94100faSBill Paul 	}
1953a94100faSBill Paul 
1954a94100faSBill Paul 	/*
1955a94100faSBill Paul 	 * Insure that the map for this transmission
1956a94100faSBill Paul 	 * is placed at the array index of the last descriptor
195722a11c96SJohn-Mark Gurney 	 * in this chain.  (Swap last and first dmamaps.)
1958a94100faSBill Paul 	 */
1959a94100faSBill Paul 	sc->rl_ldata.rl_tx_dmamap[*idx] =
1960a94100faSBill Paul 	    sc->rl_ldata.rl_tx_dmamap[arg.rl_idx];
1961a94100faSBill Paul 	sc->rl_ldata.rl_tx_dmamap[arg.rl_idx] = map;
1962a94100faSBill Paul 
196380a2a305SJohn-Mark Gurney 	sc->rl_ldata.rl_tx_mbuf[arg.rl_idx] = *m_head;
1964a94100faSBill Paul 	sc->rl_ldata.rl_tx_free -= arg.rl_maxsegs;
1965a94100faSBill Paul 
1966a94100faSBill Paul 	/*
1967a94100faSBill Paul 	 * Set up hardware VLAN tagging. Note: vlan tag info must
1968a94100faSBill Paul 	 * appear in the first descriptor of a multi-descriptor
1969a94100faSBill Paul 	 * transmission attempt.
1970a94100faSBill Paul 	 */
1971a94100faSBill Paul 
197280a2a305SJohn-Mark Gurney 	mtag = VLAN_OUTPUT_TAG(&sc->arpcom.ac_if, *m_head);
1973a94100faSBill Paul 	if (mtag != NULL)
1974a94100faSBill Paul 		sc->rl_ldata.rl_tx_list[*idx].rl_vlanctl =
1975a94100faSBill Paul 		    htole32(htons(VLAN_TAG_VALUE(mtag)) | RL_TDESC_VLANCTL_TAG);
1976a94100faSBill Paul 
1977a94100faSBill Paul 	/* Transfer ownership of packet to the chip. */
1978a94100faSBill Paul 
1979a94100faSBill Paul 	sc->rl_ldata.rl_tx_list[arg.rl_idx].rl_cmdstat |=
1980a94100faSBill Paul 	    htole32(RL_TDESC_CMD_OWN);
1981a94100faSBill Paul 	if (*idx != arg.rl_idx)
1982a94100faSBill Paul 		sc->rl_ldata.rl_tx_list[*idx].rl_cmdstat |=
1983a94100faSBill Paul 		    htole32(RL_TDESC_CMD_OWN);
1984a94100faSBill Paul 
1985a94100faSBill Paul 	RL_DESC_INC(arg.rl_idx);
1986a94100faSBill Paul 	*idx = arg.rl_idx;
1987a94100faSBill Paul 
1988a94100faSBill Paul 	return (0);
1989a94100faSBill Paul }
1990a94100faSBill Paul 
199197b9d4baSJohn-Mark Gurney static void
199297b9d4baSJohn-Mark Gurney re_start(ifp)
199397b9d4baSJohn-Mark Gurney 	struct ifnet		*ifp;
199497b9d4baSJohn-Mark Gurney {
199597b9d4baSJohn-Mark Gurney 	struct rl_softc		*sc;
199697b9d4baSJohn-Mark Gurney 
199797b9d4baSJohn-Mark Gurney 	sc = ifp->if_softc;
199897b9d4baSJohn-Mark Gurney 	RL_LOCK(sc);
199997b9d4baSJohn-Mark Gurney 	re_start_locked(ifp);
200097b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
200197b9d4baSJohn-Mark Gurney }
200297b9d4baSJohn-Mark Gurney 
2003a94100faSBill Paul /*
2004a94100faSBill Paul  * Main transmit routine for C+ and gigE NICs.
2005a94100faSBill Paul  */
2006a94100faSBill Paul static void
200797b9d4baSJohn-Mark Gurney re_start_locked(ifp)
2008a94100faSBill Paul 	struct ifnet		*ifp;
2009a94100faSBill Paul {
2010a94100faSBill Paul 	struct rl_softc		*sc;
2011a94100faSBill Paul 	struct mbuf		*m_head = NULL;
2012a94100faSBill Paul 	int			idx;
2013a94100faSBill Paul 
2014a94100faSBill Paul 	sc = ifp->if_softc;
201597b9d4baSJohn-Mark Gurney 
201697b9d4baSJohn-Mark Gurney 	RL_LOCK_ASSERT(sc);
2017a94100faSBill Paul 
2018a94100faSBill Paul 	idx = sc->rl_ldata.rl_tx_prodidx;
2019a94100faSBill Paul 
2020a94100faSBill Paul 	while (sc->rl_ldata.rl_tx_mbuf[idx] == NULL) {
2021a94100faSBill Paul 		IF_DEQUEUE(&ifp->if_snd, m_head);
2022a94100faSBill Paul 		if (m_head == NULL)
2023a94100faSBill Paul 			break;
2024a94100faSBill Paul 
202580a2a305SJohn-Mark Gurney 		if (re_encap(sc, &m_head, &idx)) {
2026a94100faSBill Paul 			IF_PREPEND(&ifp->if_snd, m_head);
2027a94100faSBill Paul 			ifp->if_flags |= IFF_OACTIVE;
2028a94100faSBill Paul 			break;
2029a94100faSBill Paul 		}
2030a94100faSBill Paul 
2031a94100faSBill Paul 		/*
2032a94100faSBill Paul 		 * If there's a BPF listener, bounce a copy of this frame
2033a94100faSBill Paul 		 * to him.
2034a94100faSBill Paul 		 */
2035a94100faSBill Paul 		BPF_MTAP(ifp, m_head);
2036a94100faSBill Paul 	}
2037a94100faSBill Paul 
2038a94100faSBill Paul 	/* Flush the TX descriptors */
2039a94100faSBill Paul 
2040a94100faSBill Paul 	bus_dmamap_sync(sc->rl_ldata.rl_tx_list_tag,
2041a94100faSBill Paul 	    sc->rl_ldata.rl_tx_list_map,
2042a94100faSBill Paul 	    BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
2043a94100faSBill Paul 
2044a94100faSBill Paul 	sc->rl_ldata.rl_tx_prodidx = idx;
2045a94100faSBill Paul 
2046a94100faSBill Paul 	/*
2047a94100faSBill Paul 	 * RealTek put the TX poll request register in a different
2048a94100faSBill Paul 	 * location on the 8169 gigE chip. I don't know why.
2049a94100faSBill Paul 	 */
2050a94100faSBill Paul 
2051a94100faSBill Paul 	if (sc->rl_type == RL_8169)
2052a94100faSBill Paul 		CSR_WRITE_2(sc, RL_GTXSTART, RL_TXSTART_START);
2053a94100faSBill Paul 	else
2054a94100faSBill Paul 		CSR_WRITE_2(sc, RL_TXSTART, RL_TXSTART_START);
2055a94100faSBill Paul 
2056a94100faSBill Paul 	/*
2057a94100faSBill Paul 	 * Use the countdown timer for interrupt moderation.
2058a94100faSBill Paul 	 * 'TX done' interrupts are disabled. Instead, we reset the
2059a94100faSBill Paul 	 * countdown timer, which will begin counting until it hits
2060a94100faSBill Paul 	 * the value in the TIMERINT register, and then trigger an
2061a94100faSBill Paul 	 * interrupt. Each time we write to the TIMERCNT register,
2062a94100faSBill Paul 	 * the timer count is reset to 0.
2063a94100faSBill Paul 	 */
2064a94100faSBill Paul 	CSR_WRITE_4(sc, RL_TIMERCNT, 1);
2065a94100faSBill Paul 
2066a94100faSBill Paul 	/*
2067a94100faSBill Paul 	 * Set a timeout in case the chip goes out to lunch.
2068a94100faSBill Paul 	 */
2069a94100faSBill Paul 	ifp->if_timer = 5;
2070a94100faSBill Paul }
2071a94100faSBill Paul 
2072a94100faSBill Paul static void
2073a94100faSBill Paul re_init(xsc)
2074a94100faSBill Paul 	void			*xsc;
2075a94100faSBill Paul {
2076a94100faSBill Paul 	struct rl_softc		*sc = xsc;
207797b9d4baSJohn-Mark Gurney 
207897b9d4baSJohn-Mark Gurney 	RL_LOCK(sc);
207997b9d4baSJohn-Mark Gurney 	re_init_locked(sc);
208097b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
208197b9d4baSJohn-Mark Gurney }
208297b9d4baSJohn-Mark Gurney 
208397b9d4baSJohn-Mark Gurney static void
208497b9d4baSJohn-Mark Gurney re_init_locked(sc)
208597b9d4baSJohn-Mark Gurney 	struct rl_softc		*sc;
208697b9d4baSJohn-Mark Gurney {
2087a94100faSBill Paul 	struct ifnet		*ifp = &sc->arpcom.ac_if;
2088a94100faSBill Paul 	struct mii_data		*mii;
2089a94100faSBill Paul 	u_int32_t		rxcfg = 0;
2090a94100faSBill Paul 
209197b9d4baSJohn-Mark Gurney 	RL_LOCK_ASSERT(sc);
209297b9d4baSJohn-Mark Gurney 
2093a94100faSBill Paul 	mii = device_get_softc(sc->rl_miibus);
2094a94100faSBill Paul 
2095a94100faSBill Paul 	/*
2096a94100faSBill Paul 	 * Cancel pending I/O and free all RX/TX buffers.
2097a94100faSBill Paul 	 */
2098a94100faSBill Paul 	re_stop(sc);
2099a94100faSBill Paul 
2100a94100faSBill Paul 	/*
2101c2c6548bSBill Paul 	 * Enable C+ RX and TX mode, as well as VLAN stripping and
2102edd03374SBill Paul 	 * RX checksum offload. We must configure the C+ register
2103c2c6548bSBill Paul 	 * before all others.
2104c2c6548bSBill Paul 	 */
2105c2c6548bSBill Paul 	CSR_WRITE_2(sc, RL_CPLUS_CMD, RL_CPLUSCMD_RXENB|
2106c2c6548bSBill Paul 	    RL_CPLUSCMD_TXENB|RL_CPLUSCMD_PCI_MRW|
2107edd03374SBill Paul 	    RL_CPLUSCMD_VLANSTRIP|
2108c2c6548bSBill Paul 	    (ifp->if_capenable & IFCAP_RXCSUM ?
2109c2c6548bSBill Paul 	    RL_CPLUSCMD_RXCSUM_ENB : 0));
2110c2c6548bSBill Paul 
2111c2c6548bSBill Paul 	/*
2112a94100faSBill Paul 	 * Init our MAC address.  Even though the chipset
2113a94100faSBill Paul 	 * documentation doesn't mention it, we need to enter "Config
2114a94100faSBill Paul 	 * register write enable" mode to modify the ID registers.
2115a94100faSBill Paul 	 */
2116a94100faSBill Paul 	CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_WRITECFG);
2117a94100faSBill Paul 	CSR_WRITE_STREAM_4(sc, RL_IDR0,
2118a94100faSBill Paul 	    *(u_int32_t *)(&sc->arpcom.ac_enaddr[0]));
2119a94100faSBill Paul 	CSR_WRITE_STREAM_4(sc, RL_IDR4,
2120a94100faSBill Paul 	    *(u_int32_t *)(&sc->arpcom.ac_enaddr[4]));
2121a94100faSBill Paul 	CSR_WRITE_1(sc, RL_EECMD, RL_EEMODE_OFF);
2122a94100faSBill Paul 
2123a94100faSBill Paul 	/*
2124a94100faSBill Paul 	 * For C+ mode, initialize the RX descriptors and mbufs.
2125a94100faSBill Paul 	 */
2126a94100faSBill Paul 	re_rx_list_init(sc);
2127a94100faSBill Paul 	re_tx_list_init(sc);
2128a94100faSBill Paul 
2129a94100faSBill Paul 	/*
2130a94100faSBill Paul 	 * Enable transmit and receive.
2131a94100faSBill Paul 	 */
2132a94100faSBill Paul 	CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_TX_ENB|RL_CMD_RX_ENB);
2133a94100faSBill Paul 
2134a94100faSBill Paul 	/*
2135a94100faSBill Paul 	 * Set the initial TX and RX configuration.
2136a94100faSBill Paul 	 */
2137abc8ff44SBill Paul 	if (sc->rl_testmode) {
2138abc8ff44SBill Paul 		if (sc->rl_type == RL_8169)
2139abc8ff44SBill Paul 			CSR_WRITE_4(sc, RL_TXCFG,
2140abc8ff44SBill Paul 			    RL_TXCFG_CONFIG|RL_LOOPTEST_ON);
2141a94100faSBill Paul 		else
2142abc8ff44SBill Paul 			CSR_WRITE_4(sc, RL_TXCFG,
2143abc8ff44SBill Paul 			    RL_TXCFG_CONFIG|RL_LOOPTEST_ON_CPLUS);
2144abc8ff44SBill Paul 	} else
2145a94100faSBill Paul 		CSR_WRITE_4(sc, RL_TXCFG, RL_TXCFG_CONFIG);
2146a94100faSBill Paul 	CSR_WRITE_4(sc, RL_RXCFG, RL_RXCFG_CONFIG);
2147a94100faSBill Paul 
2148a94100faSBill Paul 	/* Set the individual bit to receive frames for this host only. */
2149a94100faSBill Paul 	rxcfg = CSR_READ_4(sc, RL_RXCFG);
2150a94100faSBill Paul 	rxcfg |= RL_RXCFG_RX_INDIV;
2151a94100faSBill Paul 
2152a94100faSBill Paul 	/* If we want promiscuous mode, set the allframes bit. */
215361021536SJohn-Mark Gurney 	if (ifp->if_flags & IFF_PROMISC)
2154a94100faSBill Paul 		rxcfg |= RL_RXCFG_RX_ALLPHYS;
215561021536SJohn-Mark Gurney 	else
2156a94100faSBill Paul 		rxcfg &= ~RL_RXCFG_RX_ALLPHYS;
2157a94100faSBill Paul 	CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
2158a94100faSBill Paul 
2159a94100faSBill Paul 	/*
2160a94100faSBill Paul 	 * Set capture broadcast bit to capture broadcast frames.
2161a94100faSBill Paul 	 */
216261021536SJohn-Mark Gurney 	if (ifp->if_flags & IFF_BROADCAST)
2163a94100faSBill Paul 		rxcfg |= RL_RXCFG_RX_BROAD;
216461021536SJohn-Mark Gurney 	else
2165a94100faSBill Paul 		rxcfg &= ~RL_RXCFG_RX_BROAD;
2166a94100faSBill Paul 	CSR_WRITE_4(sc, RL_RXCFG, rxcfg);
2167a94100faSBill Paul 
2168a94100faSBill Paul 	/*
2169a94100faSBill Paul 	 * Program the multicast filter, if necessary.
2170a94100faSBill Paul 	 */
2171a94100faSBill Paul 	re_setmulti(sc);
2172a94100faSBill Paul 
2173a94100faSBill Paul #ifdef DEVICE_POLLING
2174a94100faSBill Paul 	/*
2175a94100faSBill Paul 	 * Disable interrupts if we are polling.
2176a94100faSBill Paul 	 */
2177a94100faSBill Paul 	if (ifp->if_flags & IFF_POLLING)
2178a94100faSBill Paul 		CSR_WRITE_2(sc, RL_IMR, 0);
2179a94100faSBill Paul 	else	/* otherwise ... */
2180a94100faSBill Paul #endif /* DEVICE_POLLING */
2181a94100faSBill Paul 	/*
2182a94100faSBill Paul 	 * Enable interrupts.
2183a94100faSBill Paul 	 */
2184a94100faSBill Paul 	if (sc->rl_testmode)
2185a94100faSBill Paul 		CSR_WRITE_2(sc, RL_IMR, 0);
2186a94100faSBill Paul 	else
2187a94100faSBill Paul 		CSR_WRITE_2(sc, RL_IMR, RL_INTRS_CPLUS);
2188a94100faSBill Paul 
2189a94100faSBill Paul 	/* Set initial TX threshold */
2190a94100faSBill Paul 	sc->rl_txthresh = RL_TX_THRESH_INIT;
2191a94100faSBill Paul 
2192a94100faSBill Paul 	/* Start RX/TX process. */
2193a94100faSBill Paul 	CSR_WRITE_4(sc, RL_MISSEDPKT, 0);
2194a94100faSBill Paul #ifdef notdef
2195a94100faSBill Paul 	/* Enable receiver and transmitter. */
2196a94100faSBill Paul 	CSR_WRITE_1(sc, RL_COMMAND, RL_CMD_TX_ENB|RL_CMD_RX_ENB);
2197a94100faSBill Paul #endif
2198a94100faSBill Paul 	/*
2199c2c6548bSBill Paul 	 * Load the addresses of the RX and TX lists into the chip.
2200a94100faSBill Paul 	 */
2201a94100faSBill Paul 
2202a94100faSBill Paul 	CSR_WRITE_4(sc, RL_RXLIST_ADDR_HI,
2203a94100faSBill Paul 	    RL_ADDR_HI(sc->rl_ldata.rl_rx_list_addr));
2204a94100faSBill Paul 	CSR_WRITE_4(sc, RL_RXLIST_ADDR_LO,
2205a94100faSBill Paul 	    RL_ADDR_LO(sc->rl_ldata.rl_rx_list_addr));
2206a94100faSBill Paul 
2207a94100faSBill Paul 	CSR_WRITE_4(sc, RL_TXLIST_ADDR_HI,
2208a94100faSBill Paul 	    RL_ADDR_HI(sc->rl_ldata.rl_tx_list_addr));
2209a94100faSBill Paul 	CSR_WRITE_4(sc, RL_TXLIST_ADDR_LO,
2210a94100faSBill Paul 	    RL_ADDR_LO(sc->rl_ldata.rl_tx_list_addr));
2211a94100faSBill Paul 
2212a94100faSBill Paul 	CSR_WRITE_1(sc, RL_EARLY_TX_THRESH, 16);
2213a94100faSBill Paul 
2214a94100faSBill Paul 	/*
2215a94100faSBill Paul 	 * Initialize the timer interrupt register so that
2216a94100faSBill Paul 	 * a timer interrupt will be generated once the timer
2217a94100faSBill Paul 	 * reaches a certain number of ticks. The timer is
2218a94100faSBill Paul 	 * reloaded on each transmit. This gives us TX interrupt
2219a94100faSBill Paul 	 * moderation, which dramatically improves TX frame rate.
2220a94100faSBill Paul 	 */
2221a94100faSBill Paul 	if (sc->rl_type == RL_8169)
2222a94100faSBill Paul 		CSR_WRITE_4(sc, RL_TIMERINT_8169, 0x800);
2223a94100faSBill Paul 	else
2224a94100faSBill Paul 		CSR_WRITE_4(sc, RL_TIMERINT, 0x400);
2225a94100faSBill Paul 
2226a94100faSBill Paul 	/*
2227a94100faSBill Paul 	 * For 8169 gigE NICs, set the max allowed RX packet
2228a94100faSBill Paul 	 * size so we can receive jumbo frames.
2229a94100faSBill Paul 	 */
2230a94100faSBill Paul 	if (sc->rl_type == RL_8169)
2231a94100faSBill Paul 		CSR_WRITE_2(sc, RL_MAXRXPKTLEN, 16383);
2232a94100faSBill Paul 
223397b9d4baSJohn-Mark Gurney 	if (sc->rl_testmode)
2234a94100faSBill Paul 		return;
2235a94100faSBill Paul 
2236a94100faSBill Paul 	mii_mediachg(mii);
2237a94100faSBill Paul 
2238a94100faSBill Paul 	CSR_WRITE_1(sc, RL_CFG1, RL_CFG1_DRVLOAD|RL_CFG1_FULLDUPLEX);
2239a94100faSBill Paul 
2240a94100faSBill Paul 	ifp->if_flags |= IFF_RUNNING;
2241a94100faSBill Paul 	ifp->if_flags &= ~IFF_OACTIVE;
2242a94100faSBill Paul 
2243a94100faSBill Paul 	sc->rl_stat_ch = timeout(re_tick, sc, hz);
2244a94100faSBill Paul }
2245a94100faSBill Paul 
2246a94100faSBill Paul /*
2247a94100faSBill Paul  * Set media options.
2248a94100faSBill Paul  */
2249a94100faSBill Paul static int
2250a94100faSBill Paul re_ifmedia_upd(ifp)
2251a94100faSBill Paul 	struct ifnet		*ifp;
2252a94100faSBill Paul {
2253a94100faSBill Paul 	struct rl_softc		*sc;
2254a94100faSBill Paul 	struct mii_data		*mii;
2255a94100faSBill Paul 
2256a94100faSBill Paul 	sc = ifp->if_softc;
2257a94100faSBill Paul 	mii = device_get_softc(sc->rl_miibus);
2258a94100faSBill Paul 	mii_mediachg(mii);
2259a94100faSBill Paul 
2260a94100faSBill Paul 	return (0);
2261a94100faSBill Paul }
2262a94100faSBill Paul 
2263a94100faSBill Paul /*
2264a94100faSBill Paul  * Report current media status.
2265a94100faSBill Paul  */
2266a94100faSBill Paul static void
2267a94100faSBill Paul re_ifmedia_sts(ifp, ifmr)
2268a94100faSBill Paul 	struct ifnet		*ifp;
2269a94100faSBill Paul 	struct ifmediareq	*ifmr;
2270a94100faSBill Paul {
2271a94100faSBill Paul 	struct rl_softc		*sc;
2272a94100faSBill Paul 	struct mii_data		*mii;
2273a94100faSBill Paul 
2274a94100faSBill Paul 	sc = ifp->if_softc;
2275a94100faSBill Paul 	mii = device_get_softc(sc->rl_miibus);
2276a94100faSBill Paul 
2277a94100faSBill Paul 	mii_pollstat(mii);
2278a94100faSBill Paul 	ifmr->ifm_active = mii->mii_media_active;
2279a94100faSBill Paul 	ifmr->ifm_status = mii->mii_media_status;
2280a94100faSBill Paul }
2281a94100faSBill Paul 
2282a94100faSBill Paul static int
2283a94100faSBill Paul re_ioctl(ifp, command, data)
2284a94100faSBill Paul 	struct ifnet		*ifp;
2285a94100faSBill Paul 	u_long			command;
2286a94100faSBill Paul 	caddr_t			data;
2287a94100faSBill Paul {
2288a94100faSBill Paul 	struct rl_softc		*sc = ifp->if_softc;
2289a94100faSBill Paul 	struct ifreq		*ifr = (struct ifreq *) data;
2290a94100faSBill Paul 	struct mii_data		*mii;
2291a94100faSBill Paul 	int			error = 0;
2292a94100faSBill Paul 
2293a94100faSBill Paul 	switch (command) {
2294a94100faSBill Paul 	case SIOCSIFMTU:
2295a94100faSBill Paul 		if (ifr->ifr_mtu > RL_JUMBO_MTU)
2296a94100faSBill Paul 			error = EINVAL;
2297a94100faSBill Paul 		ifp->if_mtu = ifr->ifr_mtu;
2298a94100faSBill Paul 		break;
2299a94100faSBill Paul 	case SIOCSIFFLAGS:
230097b9d4baSJohn-Mark Gurney 		RL_LOCK(sc);
230197b9d4baSJohn-Mark Gurney 		if (ifp->if_flags & IFF_UP)
230297b9d4baSJohn-Mark Gurney 			re_init_locked(sc);
230397b9d4baSJohn-Mark Gurney 		else if (ifp->if_flags & IFF_RUNNING)
2304a94100faSBill Paul 			re_stop(sc);
230597b9d4baSJohn-Mark Gurney 		RL_UNLOCK(sc);
2306a94100faSBill Paul 		error = 0;
2307a94100faSBill Paul 		break;
2308a94100faSBill Paul 	case SIOCADDMULTI:
2309a94100faSBill Paul 	case SIOCDELMULTI:
231097b9d4baSJohn-Mark Gurney 		RL_LOCK(sc);
2311a94100faSBill Paul 		re_setmulti(sc);
231297b9d4baSJohn-Mark Gurney 		RL_UNLOCK(sc);
2313a94100faSBill Paul 		error = 0;
2314a94100faSBill Paul 		break;
2315a94100faSBill Paul 	case SIOCGIFMEDIA:
2316a94100faSBill Paul 	case SIOCSIFMEDIA:
2317a94100faSBill Paul 		mii = device_get_softc(sc->rl_miibus);
2318a94100faSBill Paul 		error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
2319a94100faSBill Paul 		break;
2320a94100faSBill Paul 	case SIOCSIFCAP:
232125fbb2c3SYaroslav Tykhiy 		ifp->if_capenable &= ~(IFCAP_HWCSUM | IFCAP_POLLING);
232225fbb2c3SYaroslav Tykhiy 		ifp->if_capenable |=
232325fbb2c3SYaroslav Tykhiy 		    ifr->ifr_reqcap & (IFCAP_HWCSUM | IFCAP_POLLING);
2324a94100faSBill Paul 		if (ifp->if_capenable & IFCAP_TXCSUM)
2325a94100faSBill Paul 			ifp->if_hwassist = RE_CSUM_FEATURES;
2326a94100faSBill Paul 		else
2327a94100faSBill Paul 			ifp->if_hwassist = 0;
2328a94100faSBill Paul 		if (ifp->if_flags & IFF_RUNNING)
2329a94100faSBill Paul 			re_init(sc);
2330a94100faSBill Paul 		break;
2331a94100faSBill Paul 	default:
2332a94100faSBill Paul 		error = ether_ioctl(ifp, command, data);
2333a94100faSBill Paul 		break;
2334a94100faSBill Paul 	}
2335a94100faSBill Paul 
2336a94100faSBill Paul 	return (error);
2337a94100faSBill Paul }
2338a94100faSBill Paul 
2339a94100faSBill Paul static void
2340a94100faSBill Paul re_watchdog(ifp)
2341a94100faSBill Paul 	struct ifnet		*ifp;
2342a94100faSBill Paul {
2343a94100faSBill Paul 	struct rl_softc		*sc;
2344a94100faSBill Paul 
2345a94100faSBill Paul 	sc = ifp->if_softc;
2346a94100faSBill Paul 	RL_LOCK(sc);
2347a94100faSBill Paul 	printf("re%d: watchdog timeout\n", sc->rl_unit);
2348a94100faSBill Paul 	ifp->if_oerrors++;
2349a94100faSBill Paul 
2350a94100faSBill Paul 	re_txeof(sc);
2351a94100faSBill Paul 	re_rxeof(sc);
235297b9d4baSJohn-Mark Gurney 	re_init_locked(sc);
2353a94100faSBill Paul 
2354a94100faSBill Paul 	RL_UNLOCK(sc);
2355a94100faSBill Paul }
2356a94100faSBill Paul 
2357a94100faSBill Paul /*
2358a94100faSBill Paul  * Stop the adapter and free any mbufs allocated to the
2359a94100faSBill Paul  * RX and TX lists.
2360a94100faSBill Paul  */
2361a94100faSBill Paul static void
2362a94100faSBill Paul re_stop(sc)
2363a94100faSBill Paul 	struct rl_softc		*sc;
2364a94100faSBill Paul {
2365a94100faSBill Paul 	register int		i;
2366a94100faSBill Paul 	struct ifnet		*ifp;
2367a94100faSBill Paul 
236897b9d4baSJohn-Mark Gurney 	RL_LOCK_ASSERT(sc);
236997b9d4baSJohn-Mark Gurney 
2370a94100faSBill Paul 	ifp = &sc->arpcom.ac_if;
2371a94100faSBill Paul 	ifp->if_timer = 0;
2372a94100faSBill Paul 
2373a94100faSBill Paul 	untimeout(re_tick, sc, sc->rl_stat_ch);
2374a94100faSBill Paul 	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2375a94100faSBill Paul #ifdef DEVICE_POLLING
2376a94100faSBill Paul 	ether_poll_deregister(ifp);
2377a94100faSBill Paul #endif /* DEVICE_POLLING */
2378a94100faSBill Paul 
2379a94100faSBill Paul 	CSR_WRITE_1(sc, RL_COMMAND, 0x00);
2380a94100faSBill Paul 	CSR_WRITE_2(sc, RL_IMR, 0x0000);
2381a94100faSBill Paul 
2382a94100faSBill Paul 	if (sc->rl_head != NULL) {
2383a94100faSBill Paul 		m_freem(sc->rl_head);
2384a94100faSBill Paul 		sc->rl_head = sc->rl_tail = NULL;
2385a94100faSBill Paul 	}
2386a94100faSBill Paul 
2387a94100faSBill Paul 	/* Free the TX list buffers. */
2388a94100faSBill Paul 
2389a94100faSBill Paul 	for (i = 0; i < RL_TX_DESC_CNT; i++) {
2390a94100faSBill Paul 		if (sc->rl_ldata.rl_tx_mbuf[i] != NULL) {
2391a94100faSBill Paul 			bus_dmamap_unload(sc->rl_ldata.rl_mtag,
2392a94100faSBill Paul 			    sc->rl_ldata.rl_tx_dmamap[i]);
2393a94100faSBill Paul 			m_freem(sc->rl_ldata.rl_tx_mbuf[i]);
2394a94100faSBill Paul 			sc->rl_ldata.rl_tx_mbuf[i] = NULL;
2395a94100faSBill Paul 		}
2396a94100faSBill Paul 	}
2397a94100faSBill Paul 
2398a94100faSBill Paul 	/* Free the RX list buffers. */
2399a94100faSBill Paul 
2400a94100faSBill Paul 	for (i = 0; i < RL_RX_DESC_CNT; i++) {
2401a94100faSBill Paul 		if (sc->rl_ldata.rl_rx_mbuf[i] != NULL) {
2402a94100faSBill Paul 			bus_dmamap_unload(sc->rl_ldata.rl_mtag,
2403a94100faSBill Paul 			    sc->rl_ldata.rl_rx_dmamap[i]);
2404a94100faSBill Paul 			m_freem(sc->rl_ldata.rl_rx_mbuf[i]);
2405a94100faSBill Paul 			sc->rl_ldata.rl_rx_mbuf[i] = NULL;
2406a94100faSBill Paul 		}
2407a94100faSBill Paul 	}
2408a94100faSBill Paul }
2409a94100faSBill Paul 
2410a94100faSBill Paul /*
2411a94100faSBill Paul  * Device suspend routine.  Stop the interface and save some PCI
2412a94100faSBill Paul  * settings in case the BIOS doesn't restore them properly on
2413a94100faSBill Paul  * resume.
2414a94100faSBill Paul  */
2415a94100faSBill Paul static int
2416a94100faSBill Paul re_suspend(dev)
2417a94100faSBill Paul 	device_t		dev;
2418a94100faSBill Paul {
2419a94100faSBill Paul 	struct rl_softc		*sc;
2420a94100faSBill Paul 
2421a94100faSBill Paul 	sc = device_get_softc(dev);
2422a94100faSBill Paul 
242397b9d4baSJohn-Mark Gurney 	RL_LOCK(sc);
2424a94100faSBill Paul 	re_stop(sc);
2425a94100faSBill Paul 	sc->suspended = 1;
242697b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
2427a94100faSBill Paul 
2428a94100faSBill Paul 	return (0);
2429a94100faSBill Paul }
2430a94100faSBill Paul 
2431a94100faSBill Paul /*
2432a94100faSBill Paul  * Device resume routine.  Restore some PCI settings in case the BIOS
2433a94100faSBill Paul  * doesn't, re-enable busmastering, and restart the interface if
2434a94100faSBill Paul  * appropriate.
2435a94100faSBill Paul  */
2436a94100faSBill Paul static int
2437a94100faSBill Paul re_resume(dev)
2438a94100faSBill Paul 	device_t		dev;
2439a94100faSBill Paul {
2440a94100faSBill Paul 	struct rl_softc		*sc;
2441a94100faSBill Paul 	struct ifnet		*ifp;
2442a94100faSBill Paul 
2443a94100faSBill Paul 	sc = device_get_softc(dev);
244497b9d4baSJohn-Mark Gurney 
244597b9d4baSJohn-Mark Gurney 	RL_LOCK(sc);
244697b9d4baSJohn-Mark Gurney 
2447a94100faSBill Paul 	ifp = &sc->arpcom.ac_if;
2448a94100faSBill Paul 
2449a94100faSBill Paul 	/* reinitialize interface if necessary */
2450a94100faSBill Paul 	if (ifp->if_flags & IFF_UP)
245197b9d4baSJohn-Mark Gurney 		re_init_locked(sc);
2452a94100faSBill Paul 
2453a94100faSBill Paul 	sc->suspended = 0;
245497b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
2455a94100faSBill Paul 
2456a94100faSBill Paul 	return (0);
2457a94100faSBill Paul }
2458a94100faSBill Paul 
2459a94100faSBill Paul /*
2460a94100faSBill Paul  * Stop all chip I/O so that the kernel's probe routines don't
2461a94100faSBill Paul  * get confused by errant DMAs when rebooting.
2462a94100faSBill Paul  */
2463a94100faSBill Paul static void
2464a94100faSBill Paul re_shutdown(dev)
2465a94100faSBill Paul 	device_t		dev;
2466a94100faSBill Paul {
2467a94100faSBill Paul 	struct rl_softc		*sc;
2468a94100faSBill Paul 
2469a94100faSBill Paul 	sc = device_get_softc(dev);
2470a94100faSBill Paul 
247197b9d4baSJohn-Mark Gurney 	RL_LOCK(sc);
2472a94100faSBill Paul 	re_stop(sc);
247397b9d4baSJohn-Mark Gurney 	RL_UNLOCK(sc);
2474a94100faSBill Paul }
2475