if_printf / device_printf.
[dragonfly.git] / sys / dev / netif / dc / if_dc.c
1 /*
2  * Copyright (c) 1997, 1998, 1999
3  *      Bill Paul <wpaul@ee.columbia.edu>.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by Bill Paul.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30  * THE POSSIBILITY OF SUCH DAMAGE.
31  *
32  * $FreeBSD: src/sys/pci/if_dc.c,v 1.9.2.45 2003/06/08 14:31:53 mux Exp $
33  * $DragonFly: src/sys/dev/netif/dc/if_dc.c,v 1.29 2005/05/31 07:46:17 joerg Exp $
34  */
35
36 /*
37  * DEC "tulip" clone ethernet driver. Supports the DEC/Intel 21143
38  * series chips and several workalikes including the following:
39  *
40  * Macronix 98713/98715/98725/98727/98732 PMAC (www.macronix.com)
41  * Macronix/Lite-On 82c115 PNIC II (www.macronix.com)
42  * Lite-On 82c168/82c169 PNIC (www.litecom.com)
43  * ASIX Electronics AX88140A (www.asix.com.tw)
44  * ASIX Electronics AX88141 (www.asix.com.tw)
45  * ADMtek AL981 (www.admtek.com.tw)
46  * ADMtek AN985 (www.admtek.com.tw)
47  * Davicom DM9100, DM9102, DM9102A (www.davicom8.com)
48  * Accton EN1217 (www.accton.com)
49  * Conexant LANfinity (www.conexant.com)
50  *
51  * Datasheets for the 21143 are available at developer.intel.com.
52  * Datasheets for the clone parts can be found at their respective sites.
53  * (Except for the PNIC; see www.freebsd.org/~wpaul/PNIC/pnic.ps.gz.)
54  * The PNIC II is essentially a Macronix 98715A chip; the only difference
55  * worth noting is that its multicast hash table is only 128 bits wide
56  * instead of 512.
57  *
58  * Written by Bill Paul <wpaul@ee.columbia.edu>
59  * Electrical Engineering Department
60  * Columbia University, New York City
61  */
62
63 /*
64  * The Intel 21143 is the successor to the DEC 21140. It is basically
65  * the same as the 21140 but with a few new features. The 21143 supports
66  * three kinds of media attachments:
67  *
68  * o MII port, for 10Mbps and 100Mbps support and NWAY
69  *   autonegotiation provided by an external PHY.
70  * o SYM port, for symbol mode 100Mbps support.
71  * o 10baseT port.
72  * o AUI/BNC port.
73  *
74  * The 100Mbps SYM port and 10baseT port can be used together in
75  * combination with the internal NWAY support to create a 10/100
76  * autosensing configuration.
77  *
78  * Note that not all tulip workalikes are handled in this driver: we only
79  * deal with those which are relatively well behaved. The Winbond is
80  * handled separately due to its different register offsets and the
81  * special handling needed for its various bugs. The PNIC is handled
82  * here, but I'm not thrilled about it.
83  *
84  * All of the workalike chips use some form of MII transceiver support
85  * with the exception of the Macronix chips, which also have a SYM port.
86  * The ASIX AX88140A is also documented to have a SYM port, but all
87  * the cards I've seen use an MII transceiver, probably because the
88  * AX88140A doesn't support internal NWAY.
89  */
90
91 #include <sys/param.h>
92 #include <sys/systm.h>
93 #include <sys/sockio.h>
94 #include <sys/mbuf.h>
95 #include <sys/malloc.h>
96 #include <sys/kernel.h>
97 #include <sys/socket.h>
98 #include <sys/sysctl.h>
99
100 #include <net/if.h>
101 #include <net/ifq_var.h>
102 #include <net/if_arp.h>
103 #include <net/ethernet.h>
104 #include <net/if_dl.h>
105 #include <net/if_media.h>
106 #include <net/if_types.h>
107 #include <net/vlan/if_vlan_var.h>
108
109 #include <net/bpf.h>
110
111 #include <vm/vm.h>              /* for vtophys */
112 #include <vm/pmap.h>            /* for vtophys */
113 #include <machine/clock.h>      /* for DELAY */
114 #include <machine/bus_pio.h>
115 #include <machine/bus_memio.h>
116 #include <machine/bus.h>
117 #include <machine/resource.h>
118 #include <sys/bus.h>
119 #include <sys/rman.h>
120
121 #include "../mii_layer/mii.h"
122 #include "../mii_layer/miivar.h"
123
124 #include <bus/pci/pcireg.h>
125 #include <bus/pci/pcivar.h>
126
127 #define DC_USEIOSPACE
128
129 #include "if_dcreg.h"
130
131 /* "controller miibus0" required.  See GENERIC if you get errors here. */
132 #include "miibus_if.h"
133
134 /*
135  * Various supported device vendors/types and their names.
136  */
137 static struct dc_type dc_devs[] = {
138         { DC_VENDORID_DEC, DC_DEVICEID_21143,
139                 "Intel 21143 10/100BaseTX" },
140         { DC_VENDORID_DAVICOM, DC_DEVICEID_DM9009,
141                 "Davicom DM9009 10/100BaseTX" },
142         { DC_VENDORID_DAVICOM, DC_DEVICEID_DM9100,
143                 "Davicom DM9100 10/100BaseTX" },
144         { DC_VENDORID_DAVICOM, DC_DEVICEID_DM9102,
145                 "Davicom DM9102 10/100BaseTX" },
146         { DC_VENDORID_DAVICOM, DC_DEVICEID_DM9102,
147                 "Davicom DM9102A 10/100BaseTX" },
148         { DC_VENDORID_ADMTEK, DC_DEVICEID_AL981,
149                 "ADMtek AL981 10/100BaseTX" },
150         { DC_VENDORID_ADMTEK, DC_DEVICEID_AN985,
151                 "ADMtek AN985 10/100BaseTX" },
152         { DC_VENDORID_ASIX, DC_DEVICEID_AX88140A,
153                 "ASIX AX88140A 10/100BaseTX" },
154         { DC_VENDORID_ASIX, DC_DEVICEID_AX88140A,
155                 "ASIX AX88141 10/100BaseTX" },
156         { DC_VENDORID_MX, DC_DEVICEID_98713,
157                 "Macronix 98713 10/100BaseTX" },
158         { DC_VENDORID_MX, DC_DEVICEID_98713,
159                 "Macronix 98713A 10/100BaseTX" },
160         { DC_VENDORID_CP, DC_DEVICEID_98713_CP,
161                 "Compex RL100-TX 10/100BaseTX" },
162         { DC_VENDORID_CP, DC_DEVICEID_98713_CP,
163                 "Compex RL100-TX 10/100BaseTX" },
164         { DC_VENDORID_MX, DC_DEVICEID_987x5,
165                 "Macronix 98715/98715A 10/100BaseTX" },
166         { DC_VENDORID_MX, DC_DEVICEID_987x5,
167                 "Macronix 98715AEC-C 10/100BaseTX" },
168         { DC_VENDORID_MX, DC_DEVICEID_987x5,
169                 "Macronix 98725 10/100BaseTX" },
170         { DC_VENDORID_MX, DC_DEVICEID_98727,
171                 "Macronix 98727/98732 10/100BaseTX" },
172         { DC_VENDORID_LO, DC_DEVICEID_82C115,
173                 "LC82C115 PNIC II 10/100BaseTX" },
174         { DC_VENDORID_LO, DC_DEVICEID_82C168,
175                 "82c168 PNIC 10/100BaseTX" },
176         { DC_VENDORID_LO, DC_DEVICEID_82C168,
177                 "82c169 PNIC 10/100BaseTX" },
178         { DC_VENDORID_ACCTON, DC_DEVICEID_EN1217,
179                 "Accton EN1217 10/100BaseTX" },
180         { DC_VENDORID_ACCTON, DC_DEVICEID_EN2242,
181                 "Accton EN2242 MiniPCI 10/100BaseTX" },
182         { DC_VENDORID_CONEXANT, DC_DEVICEID_RS7112,
183                 "Conexant LANfinity MiniPCI 10/100BaseTX" },
184         { DC_VENDORID_3COM, DC_DEVICEID_3CSOHOB,
185                 "3Com OfficeConnect 10/100B" },
186         { 0, 0, NULL }
187 };
188
189 static int dc_probe             (device_t);
190 static int dc_attach            (device_t);
191 static int dc_detach            (device_t);
192 static int dc_suspend           (device_t);
193 static int dc_resume            (device_t);
194 static void dc_acpi             (device_t);
195 static struct dc_type *dc_devtype       (device_t);
196 static int dc_newbuf            (struct dc_softc *, int, struct mbuf *);
197 static int dc_encap             (struct dc_softc *, struct mbuf *,
198                                         u_int32_t *);
199 static void dc_pnic_rx_bug_war  (struct dc_softc *, int);
200 static int dc_rx_resync         (struct dc_softc *);
201 static void dc_rxeof            (struct dc_softc *);
202 static void dc_txeof            (struct dc_softc *);
203 static void dc_tick             (void *);
204 static void dc_tx_underrun      (struct dc_softc *);
205 static void dc_intr             (void *);
206 static void dc_start            (struct ifnet *);
207 static int dc_ioctl             (struct ifnet *, u_long, caddr_t,
208                                         struct ucred *);
209 #ifdef DEVICE_POLLING
210 static void dc_poll             (struct ifnet *ifp, enum poll_cmd cmd, 
211                                         int count);
212 #endif
213 static void dc_init             (void *);
214 static void dc_stop             (struct dc_softc *);
215 static void dc_watchdog         (struct ifnet *);
216 static void dc_shutdown         (device_t);
217 static int dc_ifmedia_upd       (struct ifnet *);
218 static void dc_ifmedia_sts      (struct ifnet *, struct ifmediareq *);
219
220 static void dc_delay            (struct dc_softc *);
221 static void dc_eeprom_idle      (struct dc_softc *);
222 static void dc_eeprom_putbyte   (struct dc_softc *, int);
223 static void dc_eeprom_getword   (struct dc_softc *, int, u_int16_t *);
224 static void dc_eeprom_getword_pnic
225                                 (struct dc_softc *, int, u_int16_t *);
226 static void dc_eeprom_width     (struct dc_softc *);
227 static void dc_read_eeprom      (struct dc_softc *, caddr_t, int,
228                                                         int, int);
229
230 static void dc_mii_writebit     (struct dc_softc *, int);
231 static int dc_mii_readbit       (struct dc_softc *);
232 static void dc_mii_sync         (struct dc_softc *);
233 static void dc_mii_send         (struct dc_softc *, u_int32_t, int);
234 static int dc_mii_readreg       (struct dc_softc *, struct dc_mii_frame *);
235 static int dc_mii_writereg      (struct dc_softc *, struct dc_mii_frame *);
236 static int dc_miibus_readreg    (device_t, int, int);
237 static int dc_miibus_writereg   (device_t, int, int, int);
238 static void dc_miibus_statchg   (device_t);
239 static void dc_miibus_mediainit (device_t);
240
241 static void dc_setcfg           (struct dc_softc *, int);
242 static u_int32_t dc_crc_le      (struct dc_softc *, c_caddr_t);
243 static u_int32_t dc_crc_be      (caddr_t);
244 static void dc_setfilt_21143    (struct dc_softc *);
245 static void dc_setfilt_asix     (struct dc_softc *);
246 static void dc_setfilt_admtek   (struct dc_softc *);
247
248 static void dc_setfilt          (struct dc_softc *);
249
250 static void dc_reset            (struct dc_softc *);
251 static int dc_list_rx_init      (struct dc_softc *);
252 static int dc_list_tx_init      (struct dc_softc *);
253
254 static void dc_read_srom        (struct dc_softc *, int);
255 static void dc_parse_21143_srom (struct dc_softc *);
256 static void dc_decode_leaf_sia  (struct dc_softc *,
257                                     struct dc_eblock_sia *);
258 static void dc_decode_leaf_mii  (struct dc_softc *,
259                                     struct dc_eblock_mii *);
260 static void dc_decode_leaf_sym  (struct dc_softc *,
261                                     struct dc_eblock_sym *);
262 static void dc_apply_fixup      (struct dc_softc *, int);
263
264 #ifdef DC_USEIOSPACE
265 #define DC_RES                  SYS_RES_IOPORT
266 #define DC_RID                  DC_PCI_CFBIO
267 #else
268 #define DC_RES                  SYS_RES_MEMORY
269 #define DC_RID                  DC_PCI_CFBMA
270 #endif
271
272 static device_method_t dc_methods[] = {
273         /* Device interface */
274         DEVMETHOD(device_probe,         dc_probe),
275         DEVMETHOD(device_attach,        dc_attach),
276         DEVMETHOD(device_detach,        dc_detach),
277         DEVMETHOD(device_suspend,       dc_suspend),
278         DEVMETHOD(device_resume,        dc_resume),
279         DEVMETHOD(device_shutdown,      dc_shutdown),
280
281         /* bus interface */
282         DEVMETHOD(bus_print_child,      bus_generic_print_child),
283         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
284
285         /* MII interface */
286         DEVMETHOD(miibus_readreg,       dc_miibus_readreg),
287         DEVMETHOD(miibus_writereg,      dc_miibus_writereg),
288         DEVMETHOD(miibus_statchg,       dc_miibus_statchg),
289         DEVMETHOD(miibus_mediainit,     dc_miibus_mediainit),
290
291         { 0, 0 }
292 };
293
294 static driver_t dc_driver = {
295         "dc",
296         dc_methods,
297         sizeof(struct dc_softc)
298 };
299
300 static devclass_t dc_devclass;
301
302 #ifdef __i386__
303 static int dc_quick=1;
304 SYSCTL_INT(_hw, OID_AUTO, dc_quick, CTLFLAG_RW,
305         &dc_quick,0,"do not mdevget in dc driver");
306 #endif
307
308 DECLARE_DUMMY_MODULE(if_dc);
309 DRIVER_MODULE(if_dc, pci, dc_driver, dc_devclass, 0, 0);
310 DRIVER_MODULE(miibus, dc, miibus_driver, miibus_devclass, 0, 0);
311
312 #define DC_SETBIT(sc, reg, x)                           \
313         CSR_WRITE_4(sc, reg, CSR_READ_4(sc, reg) | (x))
314
315 #define DC_CLRBIT(sc, reg, x)                           \
316         CSR_WRITE_4(sc, reg, CSR_READ_4(sc, reg) & ~(x))
317
318 #define SIO_SET(x)      DC_SETBIT(sc, DC_SIO, (x))
319 #define SIO_CLR(x)      DC_CLRBIT(sc, DC_SIO, (x))
320
321 static void dc_delay(sc)
322         struct dc_softc         *sc;
323 {
324         int                     idx;
325
326         for (idx = (300 / 33) + 1; idx > 0; idx--)
327                 CSR_READ_4(sc, DC_BUSCTL);
328 }
329
330 static void dc_eeprom_width(sc)
331         struct dc_softc         *sc;
332 {
333         int i;
334
335         /* Force EEPROM to idle state. */
336         dc_eeprom_idle(sc);
337
338         /* Enter EEPROM access mode. */
339         CSR_WRITE_4(sc, DC_SIO, DC_SIO_EESEL);
340         dc_delay(sc);
341         DC_SETBIT(sc, DC_SIO, DC_SIO_ROMCTL_READ);
342         dc_delay(sc);
343         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
344         dc_delay(sc);
345         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CS);
346         dc_delay(sc);
347
348         for (i = 3; i--;) {
349                 if (6 & (1 << i))
350                         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_DATAIN);
351                 else
352                         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_DATAIN);
353                 dc_delay(sc);
354                 DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CLK);
355                 dc_delay(sc);
356                 DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
357                 dc_delay(sc);
358         }
359
360         for (i = 1; i <= 12; i++) {
361                 DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CLK);
362                 dc_delay(sc);
363                 if (!(CSR_READ_4(sc, DC_SIO) & DC_SIO_EE_DATAOUT)) {
364                         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
365                         dc_delay(sc);
366                         break;
367                 }
368                 DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
369                 dc_delay(sc);
370         }
371
372         /* Turn off EEPROM access mode. */
373         dc_eeprom_idle(sc);
374
375         if (i < 4 || i > 12)
376                 sc->dc_romwidth = 6;
377         else
378                 sc->dc_romwidth = i;
379
380         /* Enter EEPROM access mode. */
381         CSR_WRITE_4(sc, DC_SIO, DC_SIO_EESEL);
382         dc_delay(sc);
383         DC_SETBIT(sc, DC_SIO, DC_SIO_ROMCTL_READ);
384         dc_delay(sc);
385         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
386         dc_delay(sc);
387         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CS);
388         dc_delay(sc);
389
390         /* Turn off EEPROM access mode. */
391         dc_eeprom_idle(sc);
392 }
393
394 static void dc_eeprom_idle(sc)
395         struct dc_softc         *sc;
396 {
397         int             i;
398
399         CSR_WRITE_4(sc, DC_SIO, DC_SIO_EESEL);
400         dc_delay(sc);
401         DC_SETBIT(sc, DC_SIO, DC_SIO_ROMCTL_READ);
402         dc_delay(sc);
403         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
404         dc_delay(sc);
405         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CS);
406         dc_delay(sc);
407
408         for (i = 0; i < 25; i++) {
409                 DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
410                 dc_delay(sc);
411                 DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CLK);
412                 dc_delay(sc);
413         }
414
415         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
416         dc_delay(sc);
417         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CS);
418         dc_delay(sc);
419         CSR_WRITE_4(sc, DC_SIO, 0x00000000);
420
421         return;
422 }
423
424 /*
425  * Send a read command and address to the EEPROM, check for ACK.
426  */
427 static void dc_eeprom_putbyte(sc, addr)
428         struct dc_softc         *sc;
429         int                     addr;
430 {
431         int             d, i;
432
433         d = DC_EECMD_READ >> 6;
434         for (i = 3; i--; ) {
435                 if (d & (1 << i))
436                         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_DATAIN);
437                 else
438                         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_DATAIN);
439                 dc_delay(sc);
440                 DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CLK);
441                 dc_delay(sc);
442                 DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
443                 dc_delay(sc);
444         }
445
446         /*
447          * Feed in each bit and strobe the clock.
448          */
449         for (i = sc->dc_romwidth; i--;) {
450                 if (addr & (1 << i)) {
451                         SIO_SET(DC_SIO_EE_DATAIN);
452                 } else {
453                         SIO_CLR(DC_SIO_EE_DATAIN);
454                 }
455                 dc_delay(sc);
456                 SIO_SET(DC_SIO_EE_CLK);
457                 dc_delay(sc);
458                 SIO_CLR(DC_SIO_EE_CLK);
459                 dc_delay(sc);
460         }
461
462         return;
463 }
464
465 /*
466  * Read a word of data stored in the EEPROM at address 'addr.'
467  * The PNIC 82c168/82c169 has its own non-standard way to read
468  * the EEPROM.
469  */
470 static void dc_eeprom_getword_pnic(sc, addr, dest)
471         struct dc_softc         *sc;
472         int                     addr;
473         u_int16_t               *dest;
474 {
475         int             i;
476         u_int32_t               r;
477
478         CSR_WRITE_4(sc, DC_PN_SIOCTL, DC_PN_EEOPCODE_READ|addr);
479
480         for (i = 0; i < DC_TIMEOUT; i++) {
481                 DELAY(1);
482                 r = CSR_READ_4(sc, DC_SIO);
483                 if (!(r & DC_PN_SIOCTL_BUSY)) {
484                         *dest = (u_int16_t)(r & 0xFFFF);
485                         return;
486                 }
487         }
488
489         return;
490 }
491
492 /*
493  * Read a word of data stored in the EEPROM at address 'addr.'
494  */
495 static void dc_eeprom_getword(sc, addr, dest)
496         struct dc_softc         *sc;
497         int                     addr;
498         u_int16_t               *dest;
499 {
500         int             i;
501         u_int16_t               word = 0;
502
503         /* Force EEPROM to idle state. */
504         dc_eeprom_idle(sc);
505
506         /* Enter EEPROM access mode. */
507         CSR_WRITE_4(sc, DC_SIO, DC_SIO_EESEL);
508         dc_delay(sc);
509         DC_SETBIT(sc, DC_SIO,  DC_SIO_ROMCTL_READ);
510         dc_delay(sc);
511         DC_CLRBIT(sc, DC_SIO, DC_SIO_EE_CLK);
512         dc_delay(sc);
513         DC_SETBIT(sc, DC_SIO, DC_SIO_EE_CS);
514         dc_delay(sc);
515
516         /*
517          * Send address of word we want to read.
518          */
519         dc_eeprom_putbyte(sc, addr);
520
521         /*
522          * Start reading bits from EEPROM.
523          */
524         for (i = 0x8000; i; i >>= 1) {
525                 SIO_SET(DC_SIO_EE_CLK);
526                 dc_delay(sc);
527                 if (CSR_READ_4(sc, DC_SIO) & DC_SIO_EE_DATAOUT)
528                         word |= i;
529                 dc_delay(sc);
530                 SIO_CLR(DC_SIO_EE_CLK);
531                 dc_delay(sc);
532         }
533
534         /* Turn off EEPROM access mode. */
535         dc_eeprom_idle(sc);
536
537         *dest = word;
538
539         return;
540 }
541
542 /*
543  * Read a sequence of words from the EEPROM.
544  */
545 static void dc_read_eeprom(sc, dest, off, cnt, swap)
546         struct dc_softc         *sc;
547         caddr_t                 dest;
548         int                     off;
549         int                     cnt;
550         int                     swap;
551 {
552         int                     i;
553         u_int16_t               word = 0, *ptr;
554
555         for (i = 0; i < cnt; i++) {
556                 if (DC_IS_PNIC(sc))
557                         dc_eeprom_getword_pnic(sc, off + i, &word);
558                 else
559                         dc_eeprom_getword(sc, off + i, &word);
560                 ptr = (u_int16_t *)(dest + (i * 2));
561                 if (swap)
562                         *ptr = ntohs(word);
563                 else
564                         *ptr = word;
565         }
566
567         return;
568 }
569
570 /*
571  * The following two routines are taken from the Macronix 98713
572  * Application Notes pp.19-21.
573  */
574 /*
575  * Write a bit to the MII bus.
576  */
577 static void dc_mii_writebit(sc, bit)
578         struct dc_softc         *sc;
579         int                     bit;
580 {
581         if (bit)
582                 CSR_WRITE_4(sc, DC_SIO,
583                     DC_SIO_ROMCTL_WRITE|DC_SIO_MII_DATAOUT);
584         else
585                 CSR_WRITE_4(sc, DC_SIO, DC_SIO_ROMCTL_WRITE);
586
587         DC_SETBIT(sc, DC_SIO, DC_SIO_MII_CLK);
588         DC_CLRBIT(sc, DC_SIO, DC_SIO_MII_CLK);
589
590         return;
591 }
592
593 /*
594  * Read a bit from the MII bus.
595  */
596 static int dc_mii_readbit(sc)
597         struct dc_softc         *sc;
598 {
599         CSR_WRITE_4(sc, DC_SIO, DC_SIO_ROMCTL_READ|DC_SIO_MII_DIR);
600         CSR_READ_4(sc, DC_SIO);
601         DC_SETBIT(sc, DC_SIO, DC_SIO_MII_CLK);
602         DC_CLRBIT(sc, DC_SIO, DC_SIO_MII_CLK);
603         if (CSR_READ_4(sc, DC_SIO) & DC_SIO_MII_DATAIN)
604                 return(1);
605
606         return(0);
607 }
608
609 /*
610  * Sync the PHYs by setting data bit and strobing the clock 32 times.
611  */
612 static void dc_mii_sync(sc)
613         struct dc_softc         *sc;
614 {
615         int             i;
616
617         CSR_WRITE_4(sc, DC_SIO, DC_SIO_ROMCTL_WRITE);
618
619         for (i = 0; i < 32; i++)
620                 dc_mii_writebit(sc, 1);
621
622         return;
623 }
624
625 /*
626  * Clock a series of bits through the MII.
627  */
628 static void dc_mii_send(sc, bits, cnt)
629         struct dc_softc         *sc;
630         u_int32_t               bits;
631         int                     cnt;
632 {
633         int                     i;
634
635         for (i = (0x1 << (cnt - 1)); i; i >>= 1)
636                 dc_mii_writebit(sc, bits & i);
637 }
638
639 /*
640  * Read an PHY register through the MII.
641  */
642 static int dc_mii_readreg(sc, frame)
643         struct dc_softc         *sc;
644         struct dc_mii_frame     *frame;
645         
646 {
647         int                     i, ack, s;
648
649         s = splimp();
650
651         /*
652          * Set up frame for RX.
653          */
654         frame->mii_stdelim = DC_MII_STARTDELIM;
655         frame->mii_opcode = DC_MII_READOP;
656         frame->mii_turnaround = 0;
657         frame->mii_data = 0;
658         
659         /*
660          * Sync the PHYs.
661          */
662         dc_mii_sync(sc);
663
664         /*
665          * Send command/address info.
666          */
667         dc_mii_send(sc, frame->mii_stdelim, 2);
668         dc_mii_send(sc, frame->mii_opcode, 2);
669         dc_mii_send(sc, frame->mii_phyaddr, 5);
670         dc_mii_send(sc, frame->mii_regaddr, 5);
671
672 #ifdef notdef
673         /* Idle bit */
674         dc_mii_writebit(sc, 1);
675         dc_mii_writebit(sc, 0);
676 #endif
677
678         /* Check for ack */
679         ack = dc_mii_readbit(sc);
680
681         /*
682          * Now try reading data bits. If the ack failed, we still
683          * need to clock through 16 cycles to keep the PHY(s) in sync.
684          */
685         if (ack) {
686                 for(i = 0; i < 16; i++) {
687                         dc_mii_readbit(sc);
688                 }
689                 goto fail;
690         }
691
692         for (i = 0x8000; i; i >>= 1) {
693                 if (!ack) {
694                         if (dc_mii_readbit(sc))
695                                 frame->mii_data |= i;
696                 }
697         }
698
699 fail:
700
701         dc_mii_writebit(sc, 0);
702         dc_mii_writebit(sc, 0);
703
704         splx(s);
705
706         if (ack)
707                 return(1);
708         return(0);
709 }
710
711 /*
712  * Write to a PHY register through the MII.
713  */
714 static int dc_mii_writereg(sc, frame)
715         struct dc_softc         *sc;
716         struct dc_mii_frame     *frame;
717         
718 {
719         int                     s;
720
721         s = splimp();
722         /*
723          * Set up frame for TX.
724          */
725
726         frame->mii_stdelim = DC_MII_STARTDELIM;
727         frame->mii_opcode = DC_MII_WRITEOP;
728         frame->mii_turnaround = DC_MII_TURNAROUND;
729
730         /*
731          * Sync the PHYs.
732          */     
733         dc_mii_sync(sc);
734
735         dc_mii_send(sc, frame->mii_stdelim, 2);
736         dc_mii_send(sc, frame->mii_opcode, 2);
737         dc_mii_send(sc, frame->mii_phyaddr, 5);
738         dc_mii_send(sc, frame->mii_regaddr, 5);
739         dc_mii_send(sc, frame->mii_turnaround, 2);
740         dc_mii_send(sc, frame->mii_data, 16);
741
742         /* Idle bit. */
743         dc_mii_writebit(sc, 0);
744         dc_mii_writebit(sc, 0);
745
746         splx(s);
747
748         return(0);
749 }
750
751 static int dc_miibus_readreg(dev, phy, reg)
752         device_t                dev;
753         int                     phy, reg;
754 {
755         struct dc_mii_frame     frame;
756         struct dc_softc         *sc;
757         int                     i, rval, phy_reg = 0;
758
759         sc = device_get_softc(dev);
760         bzero((char *)&frame, sizeof(frame));
761
762         /*
763          * Note: both the AL981 and AN985 have internal PHYs,
764          * however the AL981 provides direct access to the PHY
765          * registers while the AN985 uses a serial MII interface.
766          * The AN985's MII interface is also buggy in that you
767          * can read from any MII address (0 to 31), but only address 1
768          * behaves normally. To deal with both cases, we pretend
769          * that the PHY is at MII address 1.
770          */
771         if (DC_IS_ADMTEK(sc) && phy != DC_ADMTEK_PHYADDR)
772                 return(0);
773
774         /*
775          * Note: the ukphy probes of the RS7112 report a PHY at
776          * MII address 0 (possibly HomePNA?) and 1 (ethernet)
777          * so we only respond to correct one.
778          */
779         if (DC_IS_CONEXANT(sc) && phy != DC_CONEXANT_PHYADDR)
780                 return(0);
781
782         if (sc->dc_pmode != DC_PMODE_MII) {
783                 if (phy == (MII_NPHY - 1)) {
784                         switch(reg) {
785                         case MII_BMSR:
786                         /*
787                          * Fake something to make the probe
788                          * code think there's a PHY here.
789                          */
790                                 return(BMSR_MEDIAMASK);
791                                 break;
792                         case MII_PHYIDR1:
793                                 if (DC_IS_PNIC(sc))
794                                         return(DC_VENDORID_LO);
795                                 return(DC_VENDORID_DEC);
796                                 break;
797                         case MII_PHYIDR2:
798                                 if (DC_IS_PNIC(sc))
799                                         return(DC_DEVICEID_82C168);
800                                 return(DC_DEVICEID_21143);
801                                 break;
802                         default:
803                                 return(0);
804                                 break;
805                         }
806                 } else
807                         return(0);
808         }
809
810         if (DC_IS_PNIC(sc)) {
811                 CSR_WRITE_4(sc, DC_PN_MII, DC_PN_MIIOPCODE_READ |
812                     (phy << 23) | (reg << 18));
813                 for (i = 0; i < DC_TIMEOUT; i++) {
814                         DELAY(1);
815                         rval = CSR_READ_4(sc, DC_PN_MII);
816                         if (!(rval & DC_PN_MII_BUSY)) {
817                                 rval &= 0xFFFF;
818                                 return(rval == 0xFFFF ? 0 : rval);
819                         }
820                 }
821                 return(0);
822         }
823
824         if (DC_IS_COMET(sc)) {
825                 switch(reg) {
826                 case MII_BMCR:
827                         phy_reg = DC_AL_BMCR;
828                         break;
829                 case MII_BMSR:
830                         phy_reg = DC_AL_BMSR;
831                         break;
832                 case MII_PHYIDR1:
833                         phy_reg = DC_AL_VENID;
834                         break;
835                 case MII_PHYIDR2:
836                         phy_reg = DC_AL_DEVID;
837                         break;
838                 case MII_ANAR:
839                         phy_reg = DC_AL_ANAR;
840                         break;
841                 case MII_ANLPAR:
842                         phy_reg = DC_AL_LPAR;
843                         break;
844                 case MII_ANER:
845                         phy_reg = DC_AL_ANER;
846                         break;
847                 default:
848                         if_printf(&sc->arpcom.ac_if,
849                                   "phy_read: bad phy register %x\n", reg);
850                         return(0);
851                         break;
852                 }
853
854                 rval = CSR_READ_4(sc, phy_reg) & 0x0000FFFF;
855
856                 if (rval == 0xFFFF)
857                         return(0);
858                 return(rval);
859         }
860
861         frame.mii_phyaddr = phy;
862         frame.mii_regaddr = reg;
863         if (sc->dc_type == DC_TYPE_98713) {
864                 phy_reg = CSR_READ_4(sc, DC_NETCFG);
865                 CSR_WRITE_4(sc, DC_NETCFG, phy_reg & ~DC_NETCFG_PORTSEL);
866         }
867         dc_mii_readreg(sc, &frame);
868         if (sc->dc_type == DC_TYPE_98713)
869                 CSR_WRITE_4(sc, DC_NETCFG, phy_reg);
870
871         return(frame.mii_data);
872 }
873
874 static int dc_miibus_writereg(dev, phy, reg, data)
875         device_t                dev;
876         int                     phy, reg, data;
877 {
878         struct dc_softc         *sc;
879         struct dc_mii_frame     frame;
880         int                     i, phy_reg = 0;
881
882         sc = device_get_softc(dev);
883         bzero((char *)&frame, sizeof(frame));
884
885         if (DC_IS_ADMTEK(sc) && phy != DC_ADMTEK_PHYADDR)
886                 return(0);
887
888         if (DC_IS_CONEXANT(sc) && phy != DC_CONEXANT_PHYADDR)
889                 return(0);
890
891         if (DC_IS_PNIC(sc)) {
892                 CSR_WRITE_4(sc, DC_PN_MII, DC_PN_MIIOPCODE_WRITE |
893                     (phy << 23) | (reg << 10) | data);
894                 for (i = 0; i < DC_TIMEOUT; i++) {
895                         if (!(CSR_READ_4(sc, DC_PN_MII) & DC_PN_MII_BUSY))
896                                 break;
897                 }
898                 return(0);
899         }
900
901         if (DC_IS_COMET(sc)) {
902                 switch(reg) {
903                 case MII_BMCR:
904                         phy_reg = DC_AL_BMCR;
905                         break;
906                 case MII_BMSR:
907                         phy_reg = DC_AL_BMSR;
908                         break;
909                 case MII_PHYIDR1:
910                         phy_reg = DC_AL_VENID;
911                         break;
912                 case MII_PHYIDR2:
913                         phy_reg = DC_AL_DEVID;
914                         break;
915                 case MII_ANAR:
916                         phy_reg = DC_AL_ANAR;
917                         break;
918                 case MII_ANLPAR:
919                         phy_reg = DC_AL_LPAR;
920                         break;
921                 case MII_ANER:
922                         phy_reg = DC_AL_ANER;
923                         break;
924                 default:
925                         if_printf(&sc->arpcom.ac_if,
926                                   "phy_write: bad phy register %x\n", reg);
927                         return(0);
928                         break;
929                 }
930
931                 CSR_WRITE_4(sc, phy_reg, data);
932                 return(0);
933         }
934
935         frame.mii_phyaddr = phy;
936         frame.mii_regaddr = reg;
937         frame.mii_data = data;
938
939         if (sc->dc_type == DC_TYPE_98713) {
940                 phy_reg = CSR_READ_4(sc, DC_NETCFG);
941                 CSR_WRITE_4(sc, DC_NETCFG, phy_reg & ~DC_NETCFG_PORTSEL);
942         }
943         dc_mii_writereg(sc, &frame);
944         if (sc->dc_type == DC_TYPE_98713)
945                 CSR_WRITE_4(sc, DC_NETCFG, phy_reg);
946
947         return(0);
948 }
949
950 static void dc_miibus_statchg(dev)
951         device_t                dev;
952 {
953         struct dc_softc         *sc;
954         struct mii_data         *mii;
955         struct ifmedia          *ifm;
956
957         sc = device_get_softc(dev);
958         if (DC_IS_ADMTEK(sc))
959                 return;
960
961         mii = device_get_softc(sc->dc_miibus);
962         ifm = &mii->mii_media;
963         if (DC_IS_DAVICOM(sc) &&
964             IFM_SUBTYPE(ifm->ifm_media) == IFM_HPNA_1) {
965                 dc_setcfg(sc, ifm->ifm_media);
966                 sc->dc_if_media = ifm->ifm_media;
967         } else {
968                 dc_setcfg(sc, mii->mii_media_active);
969                 sc->dc_if_media = mii->mii_media_active;
970         }
971
972         return;
973 }
974
975 /*
976  * Special support for DM9102A cards with HomePNA PHYs. Note:
977  * with the Davicom DM9102A/DM9801 eval board that I have, it seems
978  * to be impossible to talk to the management interface of the DM9801
979  * PHY (its MDIO pin is not connected to anything). Consequently,
980  * the driver has to just 'know' about the additional mode and deal
981  * with it itself. *sigh*
982  */
983 static void dc_miibus_mediainit(dev)
984         device_t                dev;
985 {
986         struct dc_softc         *sc;
987         struct mii_data         *mii;
988         struct ifmedia          *ifm;
989         int                     rev;
990
991         rev = pci_read_config(dev, DC_PCI_CFRV, 4) & 0xFF;
992
993         sc = device_get_softc(dev);
994         mii = device_get_softc(sc->dc_miibus);
995         ifm = &mii->mii_media;
996
997         if (DC_IS_DAVICOM(sc) && rev >= DC_REVISION_DM9102A)
998                 ifmedia_add(ifm, IFM_ETHER | IFM_HPNA_1, 0, NULL);
999
1000         return;
1001 }
1002
1003 #define DC_POLY         0xEDB88320
1004 #define DC_BITS_512     9
1005 #define DC_BITS_128     7
1006 #define DC_BITS_64      6
1007
1008 static u_int32_t dc_crc_le(sc, addr)
1009         struct dc_softc         *sc;
1010         c_caddr_t               addr;
1011 {
1012         u_int32_t               idx, bit, data, crc;
1013
1014         /* Compute CRC for the address value. */
1015         crc = 0xFFFFFFFF; /* initial value */
1016
1017         for (idx = 0; idx < 6; idx++) {
1018                 for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1)
1019                         crc = (crc >> 1) ^ (((crc ^ data) & 1) ? DC_POLY : 0);
1020         }
1021
1022         /*
1023          * The hash table on the PNIC II and the MX98715AEC-C/D/E
1024          * chips is only 128 bits wide.
1025          */
1026         if (sc->dc_flags & DC_128BIT_HASH)
1027                 return (crc & ((1 << DC_BITS_128) - 1));
1028
1029         /* The hash table on the MX98715BEC is only 64 bits wide. */
1030         if (sc->dc_flags & DC_64BIT_HASH)
1031                 return (crc & ((1 << DC_BITS_64) - 1));
1032
1033         return (crc & ((1 << DC_BITS_512) - 1));
1034 }
1035
1036 /*
1037  * Calculate CRC of a multicast group address, return the lower 6 bits.
1038  */
1039 static u_int32_t dc_crc_be(addr)
1040         caddr_t                 addr;
1041 {
1042         u_int32_t               crc, carry;
1043         int                     i, j;
1044         u_int8_t                c;
1045
1046         /* Compute CRC for the address value. */
1047         crc = 0xFFFFFFFF; /* initial value */
1048
1049         for (i = 0; i < 6; i++) {
1050                 c = *(addr + i);
1051                 for (j = 0; j < 8; j++) {
1052                         carry = ((crc & 0x80000000) ? 1 : 0) ^ (c & 0x01);
1053                         crc <<= 1;
1054                         c >>= 1;
1055                         if (carry)
1056                                 crc = (crc ^ 0x04c11db6) | carry;
1057                 }
1058         }
1059
1060         /* return the filter bit position */
1061         return((crc >> 26) & 0x0000003F);
1062 }
1063
1064 /*
1065  * 21143-style RX filter setup routine. Filter programming is done by
1066  * downloading a special setup frame into the TX engine. 21143, Macronix,
1067  * PNIC, PNIC II and Davicom chips are programmed this way.
1068  *
1069  * We always program the chip using 'hash perfect' mode, i.e. one perfect
1070  * address (our node address) and a 512-bit hash filter for multicast
1071  * frames. We also sneak the broadcast address into the hash filter since
1072  * we need that too.
1073  */
1074 void dc_setfilt_21143(sc)
1075         struct dc_softc         *sc;
1076 {
1077         struct dc_desc          *sframe;
1078         u_int32_t               h, *sp;
1079         struct ifmultiaddr      *ifma;
1080         struct ifnet            *ifp;
1081         int                     i;
1082
1083         ifp = &sc->arpcom.ac_if;
1084
1085         i = sc->dc_cdata.dc_tx_prod;
1086         DC_INC(sc->dc_cdata.dc_tx_prod, DC_TX_LIST_CNT);
1087         sc->dc_cdata.dc_tx_cnt++;
1088         sframe = &sc->dc_ldata->dc_tx_list[i];
1089         sp = (u_int32_t *)&sc->dc_cdata.dc_sbuf;
1090         bzero((char *)sp, DC_SFRAME_LEN);
1091
1092         sframe->dc_data = vtophys(&sc->dc_cdata.dc_sbuf);
1093         sframe->dc_ctl = DC_SFRAME_LEN | DC_TXCTL_SETUP | DC_TXCTL_TLINK |
1094             DC_FILTER_HASHPERF | DC_TXCTL_FINT;
1095
1096         sc->dc_cdata.dc_tx_chain[i] = (struct mbuf *)&sc->dc_cdata.dc_sbuf;
1097
1098         /* If we want promiscuous mode, set the allframes bit. */
1099         if (ifp->if_flags & IFF_PROMISC)
1100                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1101         else
1102                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1103
1104         if (ifp->if_flags & IFF_ALLMULTI)
1105                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1106         else
1107                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1108
1109         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
1110             ifma = ifma->ifma_link.le_next) {
1111                 if (ifma->ifma_addr->sa_family != AF_LINK)
1112                         continue;
1113                 h = dc_crc_le(sc,
1114                     LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1115                 sp[h >> 4] |= 1 << (h & 0xF);
1116         }
1117
1118         if (ifp->if_flags & IFF_BROADCAST) {
1119                 h = dc_crc_le(sc, ifp->if_broadcastaddr);
1120                 sp[h >> 4] |= 1 << (h & 0xF);
1121         }
1122
1123         /* Set our MAC address */
1124         sp[39] = ((u_int16_t *)sc->arpcom.ac_enaddr)[0];
1125         sp[40] = ((u_int16_t *)sc->arpcom.ac_enaddr)[1];
1126         sp[41] = ((u_int16_t *)sc->arpcom.ac_enaddr)[2];
1127
1128         sframe->dc_status = DC_TXSTAT_OWN;
1129         CSR_WRITE_4(sc, DC_TXSTART, 0xFFFFFFFF);
1130
1131         /*
1132          * The PNIC takes an exceedingly long time to process its
1133          * setup frame; wait 10ms after posting the setup frame
1134          * before proceeding, just so it has time to swallow its
1135          * medicine.
1136          */
1137         DELAY(10000);
1138
1139         ifp->if_timer = 5;
1140
1141         return;
1142 }
1143
1144 void dc_setfilt_admtek(sc)
1145         struct dc_softc         *sc;
1146 {
1147         struct ifnet            *ifp;
1148         int                     h = 0;
1149         u_int32_t               hashes[2] = { 0, 0 };
1150         struct ifmultiaddr      *ifma;
1151
1152         ifp = &sc->arpcom.ac_if;
1153
1154         /* Init our MAC address */
1155         CSR_WRITE_4(sc, DC_AL_PAR0, *(u_int32_t *)(&sc->arpcom.ac_enaddr[0]));
1156         CSR_WRITE_4(sc, DC_AL_PAR1, *(u_int32_t *)(&sc->arpcom.ac_enaddr[4]));
1157
1158         /* If we want promiscuous mode, set the allframes bit. */
1159         if (ifp->if_flags & IFF_PROMISC)
1160                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1161         else
1162                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1163
1164         if (ifp->if_flags & IFF_ALLMULTI)
1165                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1166         else
1167                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1168
1169         /* first, zot all the existing hash bits */
1170         CSR_WRITE_4(sc, DC_AL_MAR0, 0);
1171         CSR_WRITE_4(sc, DC_AL_MAR1, 0);
1172
1173         /*
1174          * If we're already in promisc or allmulti mode, we
1175          * don't have to bother programming the multicast filter.
1176          */
1177         if (ifp->if_flags & (IFF_PROMISC|IFF_ALLMULTI))
1178                 return;
1179
1180         /* now program new ones */
1181         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
1182             ifma = ifma->ifma_link.le_next) {
1183                 if (ifma->ifma_addr->sa_family != AF_LINK)
1184                         continue;
1185                 if (DC_IS_CENTAUR(sc))
1186                         h = dc_crc_le(sc, LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1187                 else
1188                         h = dc_crc_be(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1189                 if (h < 32)
1190                         hashes[0] |= (1 << h);
1191                 else
1192                         hashes[1] |= (1 << (h - 32));
1193         }
1194
1195         CSR_WRITE_4(sc, DC_AL_MAR0, hashes[0]);
1196         CSR_WRITE_4(sc, DC_AL_MAR1, hashes[1]);
1197
1198         return;
1199 }
1200
1201 void dc_setfilt_asix(sc)
1202         struct dc_softc         *sc;
1203 {
1204         struct ifnet            *ifp;
1205         int                     h = 0;
1206         u_int32_t               hashes[2] = { 0, 0 };
1207         struct ifmultiaddr      *ifma;
1208
1209         ifp = &sc->arpcom.ac_if;
1210
1211         /* Init our MAC address */
1212         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_PAR0);
1213         CSR_WRITE_4(sc, DC_AX_FILTDATA,
1214             *(u_int32_t *)(&sc->arpcom.ac_enaddr[0]));
1215         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_PAR1);
1216         CSR_WRITE_4(sc, DC_AX_FILTDATA,
1217             *(u_int32_t *)(&sc->arpcom.ac_enaddr[4]));
1218
1219         /* If we want promiscuous mode, set the allframes bit. */
1220         if (ifp->if_flags & IFF_PROMISC)
1221                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1222         else
1223                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_PROMISC);
1224
1225         if (ifp->if_flags & IFF_ALLMULTI)
1226                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1227         else
1228                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_RX_ALLMULTI);
1229
1230         /*
1231          * The ASIX chip has a special bit to enable reception
1232          * of broadcast frames.
1233          */
1234         if (ifp->if_flags & IFF_BROADCAST)
1235                 DC_SETBIT(sc, DC_NETCFG, DC_AX_NETCFG_RX_BROAD);
1236         else
1237                 DC_CLRBIT(sc, DC_NETCFG, DC_AX_NETCFG_RX_BROAD);
1238
1239         /* first, zot all the existing hash bits */
1240         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_MAR0);
1241         CSR_WRITE_4(sc, DC_AX_FILTDATA, 0);
1242         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_MAR1);
1243         CSR_WRITE_4(sc, DC_AX_FILTDATA, 0);
1244
1245         /*
1246          * If we're already in promisc or allmulti mode, we
1247          * don't have to bother programming the multicast filter.
1248          */
1249         if (ifp->if_flags & (IFF_PROMISC|IFF_ALLMULTI))
1250                 return;
1251
1252         /* now program new ones */
1253         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
1254             ifma = ifma->ifma_link.le_next) {
1255                 if (ifma->ifma_addr->sa_family != AF_LINK)
1256                         continue;
1257                 h = dc_crc_be(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
1258                 if (h < 32)
1259                         hashes[0] |= (1 << h);
1260                 else
1261                         hashes[1] |= (1 << (h - 32));
1262         }
1263
1264         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_MAR0);
1265         CSR_WRITE_4(sc, DC_AX_FILTDATA, hashes[0]);
1266         CSR_WRITE_4(sc, DC_AX_FILTIDX, DC_AX_FILTIDX_MAR1);
1267         CSR_WRITE_4(sc, DC_AX_FILTDATA, hashes[1]);
1268
1269         return;
1270 }
1271
1272 static void dc_setfilt(sc)
1273         struct dc_softc         *sc;
1274 {
1275         if (DC_IS_INTEL(sc) || DC_IS_MACRONIX(sc) || DC_IS_PNIC(sc) ||
1276             DC_IS_PNICII(sc) || DC_IS_DAVICOM(sc) || DC_IS_CONEXANT(sc))
1277                 dc_setfilt_21143(sc);
1278
1279         if (DC_IS_ASIX(sc))
1280                 dc_setfilt_asix(sc);
1281
1282         if (DC_IS_ADMTEK(sc))
1283                 dc_setfilt_admtek(sc);
1284
1285         return;
1286 }
1287
1288 /*
1289  * In order to fiddle with the
1290  * 'full-duplex' and '100Mbps' bits in the netconfig register, we
1291  * first have to put the transmit and/or receive logic in the idle state.
1292  */
1293 static void dc_setcfg(sc, media)
1294         struct dc_softc         *sc;
1295         int                     media;
1296 {
1297         int                     i, restart = 0;
1298         u_int32_t               isr;
1299
1300         if (IFM_SUBTYPE(media) == IFM_NONE)
1301                 return;
1302
1303         if (CSR_READ_4(sc, DC_NETCFG) & (DC_NETCFG_TX_ON|DC_NETCFG_RX_ON)) {
1304                 restart = 1;
1305                 DC_CLRBIT(sc, DC_NETCFG, (DC_NETCFG_TX_ON|DC_NETCFG_RX_ON));
1306
1307                 for (i = 0; i < DC_TIMEOUT; i++) {
1308                         isr = CSR_READ_4(sc, DC_ISR);
1309                         if (isr & DC_ISR_TX_IDLE ||
1310                             (isr & DC_ISR_RX_STATE) == DC_RXSTATE_STOPPED)
1311                                 break;
1312                         DELAY(10);
1313                 }
1314
1315                 if (i == DC_TIMEOUT) {
1316                         if_printf(&sc->arpcom.ac_if, 
1317                             "failed to force tx and rx to idle state\n");
1318                 }
1319         }
1320
1321         if (IFM_SUBTYPE(media) == IFM_100_TX) {
1322                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_SPEEDSEL);
1323                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_HEARTBEAT);
1324                 if (sc->dc_pmode == DC_PMODE_MII) {
1325                         int     watchdogreg;
1326
1327                         if (DC_IS_INTEL(sc)) {
1328                         /* there's a write enable bit here that reads as 1 */
1329                                 watchdogreg = CSR_READ_4(sc, DC_WATCHDOG);
1330                                 watchdogreg &= ~DC_WDOG_CTLWREN;
1331                                 watchdogreg |= DC_WDOG_JABBERDIS;
1332                                 CSR_WRITE_4(sc, DC_WATCHDOG, watchdogreg);
1333                         } else {
1334                                 DC_SETBIT(sc, DC_WATCHDOG, DC_WDOG_JABBERDIS);
1335                         }
1336                         DC_CLRBIT(sc, DC_NETCFG, (DC_NETCFG_PCS|
1337                             DC_NETCFG_PORTSEL|DC_NETCFG_SCRAMBLER));
1338                         if (sc->dc_type == DC_TYPE_98713)
1339                                 DC_SETBIT(sc, DC_NETCFG, (DC_NETCFG_PCS|
1340                                     DC_NETCFG_SCRAMBLER));
1341                         if (!DC_IS_DAVICOM(sc))
1342                                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1343                         DC_CLRBIT(sc, DC_10BTCTRL, 0xFFFF);
1344                         if (DC_IS_INTEL(sc))
1345                                 dc_apply_fixup(sc, IFM_AUTO);
1346                 } else {
1347                         if (DC_IS_PNIC(sc)) {
1348                                 DC_PN_GPIO_SETBIT(sc, DC_PN_GPIO_SPEEDSEL);
1349                                 DC_PN_GPIO_SETBIT(sc, DC_PN_GPIO_100TX_LOOP);
1350                                 DC_SETBIT(sc, DC_PN_NWAY, DC_PN_NWAY_SPEEDSEL);
1351                         }
1352                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1353                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PCS);
1354                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_SCRAMBLER);
1355                         if (DC_IS_INTEL(sc))
1356                                 dc_apply_fixup(sc,
1357                                     (media & IFM_GMASK) == IFM_FDX ?
1358                                     IFM_100_TX|IFM_FDX : IFM_100_TX);
1359                 }
1360         }
1361
1362         if (IFM_SUBTYPE(media) == IFM_10_T) {
1363                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_SPEEDSEL);
1364                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_HEARTBEAT);
1365                 if (sc->dc_pmode == DC_PMODE_MII) {
1366                         int     watchdogreg;
1367
1368                         /* there's a write enable bit here that reads as 1 */
1369                         if (DC_IS_INTEL(sc)) {
1370                                 watchdogreg = CSR_READ_4(sc, DC_WATCHDOG);
1371                                 watchdogreg &= ~DC_WDOG_CTLWREN;
1372                                 watchdogreg |= DC_WDOG_JABBERDIS;
1373                                 CSR_WRITE_4(sc, DC_WATCHDOG, watchdogreg);
1374                         } else {
1375                                 DC_SETBIT(sc, DC_WATCHDOG, DC_WDOG_JABBERDIS);
1376                         }
1377                         DC_CLRBIT(sc, DC_NETCFG, (DC_NETCFG_PCS|
1378                             DC_NETCFG_PORTSEL|DC_NETCFG_SCRAMBLER));
1379                         if (sc->dc_type == DC_TYPE_98713)
1380                                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PCS);
1381                         if (!DC_IS_DAVICOM(sc))
1382                                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1383                         DC_CLRBIT(sc, DC_10BTCTRL, 0xFFFF);
1384                         if (DC_IS_INTEL(sc))
1385                                 dc_apply_fixup(sc, IFM_AUTO);
1386                 } else {
1387                         if (DC_IS_PNIC(sc)) {
1388                                 DC_PN_GPIO_CLRBIT(sc, DC_PN_GPIO_SPEEDSEL);
1389                                 DC_PN_GPIO_SETBIT(sc, DC_PN_GPIO_100TX_LOOP);
1390                                 DC_CLRBIT(sc, DC_PN_NWAY, DC_PN_NWAY_SPEEDSEL);
1391                         }
1392                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1393                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_PCS);
1394                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_SCRAMBLER);
1395                         if (DC_IS_INTEL(sc)) {
1396                                 DC_CLRBIT(sc, DC_SIARESET, DC_SIA_RESET);
1397                                 DC_CLRBIT(sc, DC_10BTCTRL, 0xFFFF);
1398                                 if ((media & IFM_GMASK) == IFM_FDX)
1399                                         DC_SETBIT(sc, DC_10BTCTRL, 0x7F3D);
1400                                 else
1401                                         DC_SETBIT(sc, DC_10BTCTRL, 0x7F3F);
1402                                 DC_SETBIT(sc, DC_SIARESET, DC_SIA_RESET);
1403                                 DC_CLRBIT(sc, DC_10BTCTRL,
1404                                     DC_TCTL_AUTONEGENBL);
1405                                 dc_apply_fixup(sc,
1406                                     (media & IFM_GMASK) == IFM_FDX ?
1407                                     IFM_10_T|IFM_FDX : IFM_10_T);
1408                                 DELAY(20000);
1409                         }
1410                 }
1411         }
1412
1413         /*
1414          * If this is a Davicom DM9102A card with a DM9801 HomePNA
1415          * PHY and we want HomePNA mode, set the portsel bit to turn
1416          * on the external MII port.
1417          */
1418         if (DC_IS_DAVICOM(sc)) {
1419                 if (IFM_SUBTYPE(media) == IFM_HPNA_1) {
1420                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1421                         sc->dc_link = 1;
1422                 } else {
1423                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_PORTSEL);
1424                 }
1425         }
1426
1427         if ((media & IFM_GMASK) == IFM_FDX) {
1428                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_FULLDUPLEX);
1429                 if (sc->dc_pmode == DC_PMODE_SYM && DC_IS_PNIC(sc))
1430                         DC_SETBIT(sc, DC_PN_NWAY, DC_PN_NWAY_DUPLEX);
1431         } else {
1432                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_FULLDUPLEX);
1433                 if (sc->dc_pmode == DC_PMODE_SYM && DC_IS_PNIC(sc))
1434                         DC_CLRBIT(sc, DC_PN_NWAY, DC_PN_NWAY_DUPLEX);
1435         }
1436
1437         if (restart)
1438                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON|DC_NETCFG_RX_ON);
1439
1440         return;
1441 }
1442
1443 static void dc_reset(sc)
1444         struct dc_softc         *sc;
1445 {
1446         int             i;
1447
1448         DC_SETBIT(sc, DC_BUSCTL, DC_BUSCTL_RESET);
1449
1450         for (i = 0; i < DC_TIMEOUT; i++) {
1451                 DELAY(10);
1452                 if (!(CSR_READ_4(sc, DC_BUSCTL) & DC_BUSCTL_RESET))
1453                         break;
1454         }
1455
1456         if (DC_IS_ASIX(sc) || DC_IS_ADMTEK(sc) || DC_IS_CONEXANT(sc)) {
1457                 DELAY(10000);
1458                 DC_CLRBIT(sc, DC_BUSCTL, DC_BUSCTL_RESET);
1459                 i = 0;
1460         }
1461
1462         if (i == DC_TIMEOUT)
1463                 if_printf(&sc->arpcom.ac_if, "reset never completed!\n");
1464
1465         /* Wait a little while for the chip to get its brains in order. */
1466         DELAY(1000);
1467
1468         CSR_WRITE_4(sc, DC_IMR, 0x00000000);
1469         CSR_WRITE_4(sc, DC_BUSCTL, 0x00000000);
1470         CSR_WRITE_4(sc, DC_NETCFG, 0x00000000);
1471
1472         /*
1473          * Bring the SIA out of reset. In some cases, it looks
1474          * like failing to unreset the SIA soon enough gets it
1475          * into a state where it will never come out of reset
1476          * until we reset the whole chip again.
1477          */
1478         if (DC_IS_INTEL(sc)) {
1479                 DC_SETBIT(sc, DC_SIARESET, DC_SIA_RESET);
1480                 CSR_WRITE_4(sc, DC_10BTCTRL, 0);
1481                 CSR_WRITE_4(sc, DC_WATCHDOG, 0);
1482         }
1483
1484         return;
1485 }
1486
1487 static struct dc_type *dc_devtype(dev)
1488         device_t                dev;
1489 {
1490         struct dc_type          *t;
1491         u_int32_t               rev;
1492
1493         t = dc_devs;
1494
1495         while(t->dc_name != NULL) {
1496                 if ((pci_get_vendor(dev) == t->dc_vid) &&
1497                     (pci_get_device(dev) == t->dc_did)) {
1498                         /* Check the PCI revision */
1499                         rev = pci_read_config(dev, DC_PCI_CFRV, 4) & 0xFF;
1500                         if (t->dc_did == DC_DEVICEID_98713 &&
1501                             rev >= DC_REVISION_98713A)
1502                                 t++;
1503                         if (t->dc_did == DC_DEVICEID_98713_CP &&
1504                             rev >= DC_REVISION_98713A)
1505                                 t++;
1506                         if (t->dc_did == DC_DEVICEID_987x5 &&
1507                             rev >= DC_REVISION_98715AEC_C)
1508                                 t++;
1509                         if (t->dc_did == DC_DEVICEID_987x5 &&
1510                             rev >= DC_REVISION_98725)
1511                                 t++;
1512                         if (t->dc_did == DC_DEVICEID_AX88140A &&
1513                             rev >= DC_REVISION_88141)
1514                                 t++;
1515                         if (t->dc_did == DC_DEVICEID_82C168 &&
1516                             rev >= DC_REVISION_82C169)
1517                                 t++;
1518                         if (t->dc_did == DC_DEVICEID_DM9102 &&
1519                             rev >= DC_REVISION_DM9102A)
1520                                 t++;
1521                         return(t);
1522                 }
1523                 t++;
1524         }
1525
1526         return(NULL);
1527 }
1528
1529 /*
1530  * Probe for a 21143 or clone chip. Check the PCI vendor and device
1531  * IDs against our list and return a device name if we find a match.
1532  * We do a little bit of extra work to identify the exact type of
1533  * chip. The MX98713 and MX98713A have the same PCI vendor/device ID,
1534  * but different revision IDs. The same is true for 98715/98715A
1535  * chips and the 98725, as well as the ASIX and ADMtek chips. In some
1536  * cases, the exact chip revision affects driver behavior.
1537  */
1538 static int dc_probe(dev)
1539         device_t                dev;
1540 {
1541         struct dc_type          *t;
1542
1543         t = dc_devtype(dev);
1544
1545         if (t != NULL) {
1546                 device_set_desc(dev, t->dc_name);
1547                 return(0);
1548         }
1549
1550         return(ENXIO);
1551 }
1552
1553 static void dc_acpi(dev)
1554         device_t                dev;
1555 {
1556         u_int32_t               r, cptr;
1557
1558         /* Find the location of the capabilities block */
1559         cptr = pci_read_config(dev, DC_PCI_CCAP, 4) & 0xFF;
1560
1561         r = pci_read_config(dev, cptr, 4) & 0xFF;
1562         if (r == 0x01) {
1563
1564                 r = pci_read_config(dev, cptr + 4, 4);
1565                 if (r & DC_PSTATE_D3) {
1566                         u_int32_t               iobase, membase, irq;
1567                         struct dc_softc         *sc;
1568
1569                         /* Save important PCI config data. */
1570                         iobase = pci_read_config(dev, DC_PCI_CFBIO, 4);
1571                         membase = pci_read_config(dev, DC_PCI_CFBMA, 4);
1572                         irq = pci_read_config(dev, DC_PCI_CFIT, 4);
1573
1574                         sc = device_get_softc(dev);
1575                         /* Reset the power state. */
1576                         if_printf(&sc->arpcom.ac_if,
1577                                   "chip is in D%d power mode "
1578                                   "-- setting to D0\n", r & DC_PSTATE_D3);
1579                         r &= 0xFFFFFFFC;
1580                         pci_write_config(dev, cptr + 4, r, 4);
1581
1582                         /* Restore PCI config data. */
1583                         pci_write_config(dev, DC_PCI_CFBIO, iobase, 4);
1584                         pci_write_config(dev, DC_PCI_CFBMA, membase, 4);
1585                         pci_write_config(dev, DC_PCI_CFIT, irq, 4);
1586                 }
1587         }
1588 }
1589
1590 static void dc_apply_fixup(sc, media)
1591         struct dc_softc         *sc;
1592         int                     media;
1593 {
1594         struct dc_mediainfo     *m;
1595         u_int8_t                *p;
1596         int                     i;
1597         u_int32_t               reg;
1598
1599         m = sc->dc_mi;
1600
1601         while (m != NULL) {
1602                 if (m->dc_media == media)
1603                         break;
1604                 m = m->dc_next;
1605         }
1606
1607         if (m == NULL)
1608                 return;
1609
1610         for (i = 0, p = m->dc_reset_ptr; i < m->dc_reset_len; i++, p += 2) {
1611                 reg = (p[0] | (p[1] << 8)) << 16;
1612                 CSR_WRITE_4(sc, DC_WATCHDOG, reg);
1613         }
1614
1615         for (i = 0, p = m->dc_gp_ptr; i < m->dc_gp_len; i++, p += 2) {
1616                 reg = (p[0] | (p[1] << 8)) << 16;
1617                 CSR_WRITE_4(sc, DC_WATCHDOG, reg);
1618         }
1619
1620         return;
1621 }
1622
1623 static void dc_decode_leaf_sia(sc, l)
1624         struct dc_softc         *sc;
1625         struct dc_eblock_sia    *l;
1626 {
1627         struct dc_mediainfo     *m;
1628
1629         m = malloc(sizeof(struct dc_mediainfo), M_DEVBUF, M_INTWAIT | M_ZERO);
1630         if (l->dc_sia_code == DC_SIA_CODE_10BT)
1631                 m->dc_media = IFM_10_T;
1632
1633         if (l->dc_sia_code == DC_SIA_CODE_10BT_FDX)
1634                 m->dc_media = IFM_10_T|IFM_FDX;
1635
1636         if (l->dc_sia_code == DC_SIA_CODE_10B2)
1637                 m->dc_media = IFM_10_2;
1638
1639         if (l->dc_sia_code == DC_SIA_CODE_10B5)
1640                 m->dc_media = IFM_10_5;
1641
1642         m->dc_gp_len = 2;
1643         m->dc_gp_ptr = (u_int8_t *)&l->dc_sia_gpio_ctl;
1644
1645         m->dc_next = sc->dc_mi;
1646         sc->dc_mi = m;
1647
1648         sc->dc_pmode = DC_PMODE_SIA;
1649
1650         return;
1651 }
1652
1653 static void dc_decode_leaf_sym(sc, l)
1654         struct dc_softc         *sc;
1655         struct dc_eblock_sym    *l;
1656 {
1657         struct dc_mediainfo     *m;
1658
1659         m = malloc(sizeof(struct dc_mediainfo), M_DEVBUF, M_INTWAIT | M_ZERO);
1660         if (l->dc_sym_code == DC_SYM_CODE_100BT)
1661                 m->dc_media = IFM_100_TX;
1662
1663         if (l->dc_sym_code == DC_SYM_CODE_100BT_FDX)
1664                 m->dc_media = IFM_100_TX|IFM_FDX;
1665
1666         m->dc_gp_len = 2;
1667         m->dc_gp_ptr = (u_int8_t *)&l->dc_sym_gpio_ctl;
1668
1669         m->dc_next = sc->dc_mi;
1670         sc->dc_mi = m;
1671
1672         sc->dc_pmode = DC_PMODE_SYM;
1673
1674         return;
1675 }
1676
1677 static void dc_decode_leaf_mii(sc, l)
1678         struct dc_softc         *sc;
1679         struct dc_eblock_mii    *l;
1680 {
1681         u_int8_t                *p;
1682         struct dc_mediainfo     *m;
1683
1684         m = malloc(sizeof(struct dc_mediainfo), M_DEVBUF, M_INTWAIT | M_ZERO);
1685         /* We abuse IFM_AUTO to represent MII. */
1686         m->dc_media = IFM_AUTO;
1687         m->dc_gp_len = l->dc_gpr_len;
1688
1689         p = (u_int8_t *)l;
1690         p += sizeof(struct dc_eblock_mii);
1691         m->dc_gp_ptr = p;
1692         p += 2 * l->dc_gpr_len;
1693         m->dc_reset_len = *p;
1694         p++;
1695         m->dc_reset_ptr = p;
1696
1697         m->dc_next = sc->dc_mi;
1698         sc->dc_mi = m;
1699
1700         return;
1701 }
1702
1703 static void dc_read_srom(sc, bits)
1704         struct dc_softc         *sc;
1705         int                     bits;
1706 {
1707         int size;
1708
1709         size = 2 << bits;
1710         sc->dc_srom = malloc(size, M_DEVBUF, M_INTWAIT);
1711         dc_read_eeprom(sc, (caddr_t)sc->dc_srom, 0, (size / 2), 0);
1712 }
1713
1714 static void dc_parse_21143_srom(sc)
1715         struct dc_softc         *sc;
1716 {
1717         struct dc_leaf_hdr      *lhdr;
1718         struct dc_eblock_hdr    *hdr;
1719         int                     i, loff;
1720         char                    *ptr;
1721         int                     have_mii;
1722
1723         have_mii = 0;
1724         loff = sc->dc_srom[27];
1725         lhdr = (struct dc_leaf_hdr *)&(sc->dc_srom[loff]);
1726
1727         ptr = (char *)lhdr;
1728         ptr += sizeof(struct dc_leaf_hdr) - 1;
1729         /*
1730          * Look if we got a MII media block.
1731          */
1732         for (i = 0; i < lhdr->dc_mcnt; i++) {
1733                 hdr = (struct dc_eblock_hdr *)ptr;
1734                 if (hdr->dc_type == DC_EBLOCK_MII)
1735                     have_mii++;
1736
1737                 ptr += (hdr->dc_len & 0x7F);
1738                 ptr++;
1739         }
1740
1741         /*
1742          * Do the same thing again. Only use SIA and SYM media
1743          * blocks if no MII media block is available.
1744          */
1745         ptr = (char *)lhdr;
1746         ptr += sizeof(struct dc_leaf_hdr) - 1;
1747         for (i = 0; i < lhdr->dc_mcnt; i++) {
1748                 hdr = (struct dc_eblock_hdr *)ptr;
1749                 switch(hdr->dc_type) {
1750                 case DC_EBLOCK_MII:
1751                         dc_decode_leaf_mii(sc, (struct dc_eblock_mii *)hdr);
1752                         break;
1753                 case DC_EBLOCK_SIA:
1754                         if (! have_mii)
1755                                 dc_decode_leaf_sia(sc,
1756                                     (struct dc_eblock_sia *)hdr);
1757                         break;
1758                 case DC_EBLOCK_SYM:
1759                         if (! have_mii)
1760                                 dc_decode_leaf_sym(sc,
1761                                     (struct dc_eblock_sym *)hdr);
1762                         break;
1763                 default:
1764                         /* Don't care. Yet. */
1765                         break;
1766                 }
1767                 ptr += (hdr->dc_len & 0x7F);
1768                 ptr++;
1769         }
1770
1771         return;
1772 }
1773
1774 /*
1775  * Attach the interface. Allocate softc structures, do ifmedia
1776  * setup and ethernet/BPF attach.
1777  */
1778 static int dc_attach(dev)
1779         device_t                dev;
1780 {
1781         int                     s, tmp = 0;
1782         u_char                  eaddr[ETHER_ADDR_LEN];
1783         u_int32_t               command;
1784         struct dc_softc         *sc;
1785         struct ifnet            *ifp;
1786         u_int32_t               revision;
1787         int                     error = 0, rid, mac_offset;
1788
1789         s = splimp();
1790
1791         sc = device_get_softc(dev);
1792         bzero(sc, sizeof(struct dc_softc));
1793         callout_init(&sc->dc_stat_timer);
1794
1795         ifp = &sc->arpcom.ac_if;
1796         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
1797
1798         /*
1799          * Handle power management nonsense.
1800          */
1801         dc_acpi(dev);
1802
1803         /*
1804          * Map control/status registers.
1805          */
1806         command = pci_read_config(dev, PCIR_COMMAND, 4);
1807         command |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
1808         pci_write_config(dev, PCIR_COMMAND, command, 4);
1809         command = pci_read_config(dev, PCIR_COMMAND, 4);
1810
1811 #ifdef DC_USEIOSPACE
1812         if (!(command & PCIM_CMD_PORTEN)) {
1813                 device_printf(dev, "failed to enable I/O ports!\n");
1814                 error = ENXIO;
1815                 goto fail;
1816         }
1817 #else
1818         if (!(command & PCIM_CMD_MEMEN)) {
1819                 device_printf(dev, "failed to enable memory mapping!\n");
1820                 error = ENXIO;
1821                 goto fail;
1822         }
1823 #endif
1824
1825         rid = DC_RID;
1826         sc->dc_res = bus_alloc_resource_any(dev, DC_RES, &rid, RF_ACTIVE);
1827
1828         if (sc->dc_res == NULL) {
1829                 device_printf(dev, "couldn't map ports/memory\n");
1830                 error = ENXIO;
1831                 goto fail;
1832         }
1833
1834         sc->dc_btag = rman_get_bustag(sc->dc_res);
1835         sc->dc_bhandle = rman_get_bushandle(sc->dc_res);
1836
1837         /* Allocate interrupt */
1838         rid = 0;
1839         sc->dc_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
1840             RF_SHAREABLE | RF_ACTIVE);
1841
1842         if (sc->dc_irq == NULL) {
1843                 device_printf(dev, "couldn't map interrupt\n");
1844                 bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
1845                 error = ENXIO;
1846                 goto fail;
1847         }
1848
1849         error = bus_setup_intr(dev, sc->dc_irq, INTR_TYPE_NET,
1850                                dc_intr, sc, &sc->dc_intrhand, NULL);
1851
1852         if (error) {
1853                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->dc_irq);
1854                 bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
1855                 device_printf(dev, "couldn't set up irq\n");
1856                 goto fail;
1857         }
1858         
1859         /* Need this info to decide on a chip type. */
1860         sc->dc_info = dc_devtype(dev);
1861         revision = pci_read_config(dev, DC_PCI_CFRV, 4) & 0x000000FF;
1862
1863         /* Get the eeprom width, but PNIC has diff eeprom */
1864         if (sc->dc_info->dc_did != DC_DEVICEID_82C168)
1865                 dc_eeprom_width(sc);
1866
1867         switch(sc->dc_info->dc_did) {
1868         case DC_DEVICEID_21143:
1869                 sc->dc_type = DC_TYPE_21143;
1870                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR;
1871                 sc->dc_flags |= DC_REDUCED_MII_POLL;
1872                 /* Save EEPROM contents so we can parse them later. */
1873                 dc_read_srom(sc, sc->dc_romwidth);
1874                 break;
1875         case DC_DEVICEID_DM9009:
1876         case DC_DEVICEID_DM9100:
1877         case DC_DEVICEID_DM9102:
1878                 sc->dc_type = DC_TYPE_DM9102;
1879                 sc->dc_flags |= DC_TX_COALESCE|DC_TX_INTR_ALWAYS;
1880                 sc->dc_flags |= DC_REDUCED_MII_POLL|DC_TX_STORENFWD;
1881                 sc->dc_pmode = DC_PMODE_MII;
1882                 /* Increase the latency timer value. */
1883                 command = pci_read_config(dev, DC_PCI_CFLT, 4);
1884                 command &= 0xFFFF00FF;
1885                 command |= 0x00008000;
1886                 pci_write_config(dev, DC_PCI_CFLT, command, 4);
1887                 break;
1888         case DC_DEVICEID_AL981:
1889                 sc->dc_type = DC_TYPE_AL981;
1890                 sc->dc_flags |= DC_TX_USE_TX_INTR;
1891                 sc->dc_flags |= DC_TX_ADMTEK_WAR;
1892                 sc->dc_pmode = DC_PMODE_MII;
1893                 dc_read_srom(sc, sc->dc_romwidth);
1894                 break;
1895         case DC_DEVICEID_AN985:
1896         case DC_DEVICEID_EN2242:
1897         case DC_DEVICEID_3CSOHOB:
1898                 sc->dc_type = DC_TYPE_AN985;
1899                 sc->dc_flags |= DC_64BIT_HASH;
1900                 sc->dc_flags |= DC_TX_USE_TX_INTR;
1901                 sc->dc_flags |= DC_TX_ADMTEK_WAR;
1902                 sc->dc_pmode = DC_PMODE_MII;
1903                 dc_read_srom(sc, sc->dc_romwidth);
1904                 break;
1905         case DC_DEVICEID_98713:
1906         case DC_DEVICEID_98713_CP:
1907                 if (revision < DC_REVISION_98713A) {
1908                         sc->dc_type = DC_TYPE_98713;
1909                 }
1910                 if (revision >= DC_REVISION_98713A) {
1911                         sc->dc_type = DC_TYPE_98713A;
1912                         sc->dc_flags |= DC_21143_NWAY;
1913                 }
1914                 sc->dc_flags |= DC_REDUCED_MII_POLL;
1915                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR;
1916                 break;
1917         case DC_DEVICEID_987x5:
1918         case DC_DEVICEID_EN1217:
1919                 /*
1920                  * Macronix MX98715AEC-C/D/E parts have only a
1921                  * 128-bit hash table. We need to deal with these
1922                  * in the same manner as the PNIC II so that we
1923                  * get the right number of bits out of the
1924                  * CRC routine.
1925                  */
1926                 if (revision >= DC_REVISION_98715AEC_C &&
1927                     revision < DC_REVISION_98725)
1928                         sc->dc_flags |= DC_128BIT_HASH;
1929                 sc->dc_type = DC_TYPE_987x5;
1930                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR;
1931                 sc->dc_flags |= DC_REDUCED_MII_POLL|DC_21143_NWAY;
1932                 break;
1933         case DC_DEVICEID_98727:
1934                 sc->dc_type = DC_TYPE_987x5;
1935                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR;
1936                 sc->dc_flags |= DC_REDUCED_MII_POLL|DC_21143_NWAY;
1937                 break;
1938         case DC_DEVICEID_82C115:
1939                 sc->dc_type = DC_TYPE_PNICII;
1940                 sc->dc_flags |= DC_TX_POLL|DC_TX_USE_TX_INTR|DC_128BIT_HASH;
1941                 sc->dc_flags |= DC_REDUCED_MII_POLL|DC_21143_NWAY;
1942                 break;
1943         case DC_DEVICEID_82C168:
1944                 sc->dc_type = DC_TYPE_PNIC;
1945                 sc->dc_flags |= DC_TX_STORENFWD|DC_TX_INTR_ALWAYS;
1946                 sc->dc_flags |= DC_PNIC_RX_BUG_WAR;
1947                 sc->dc_pnic_rx_buf = malloc(DC_RXLEN * 5, M_DEVBUF, M_WAITOK);
1948                 if (revision < DC_REVISION_82C169)
1949                         sc->dc_pmode = DC_PMODE_SYM;
1950                 break;
1951         case DC_DEVICEID_AX88140A:
1952                 sc->dc_type = DC_TYPE_ASIX;
1953                 sc->dc_flags |= DC_TX_USE_TX_INTR|DC_TX_INTR_FIRSTFRAG;
1954                 sc->dc_flags |= DC_REDUCED_MII_POLL;
1955                 sc->dc_pmode = DC_PMODE_MII;
1956                 break;
1957         case DC_DEVICEID_RS7112:
1958                 sc->dc_type = DC_TYPE_CONEXANT;
1959                 sc->dc_flags |= DC_TX_INTR_ALWAYS;
1960                 sc->dc_flags |= DC_REDUCED_MII_POLL;
1961                 sc->dc_pmode = DC_PMODE_MII;
1962                 dc_read_srom(sc, sc->dc_romwidth);
1963                 break;
1964         default:
1965                 device_printf(dev, "unknown device: %x\n", sc->dc_info->dc_did);
1966                 break;
1967         }
1968
1969         /* Save the cache line size. */
1970         if (DC_IS_DAVICOM(sc))
1971                 sc->dc_cachesize = 0;
1972         else
1973                 sc->dc_cachesize = pci_read_config(dev,
1974                     DC_PCI_CFLT, 4) & 0xFF;
1975
1976         /* Reset the adapter. */
1977         dc_reset(sc);
1978
1979         /* Take 21143 out of snooze mode */
1980         if (DC_IS_INTEL(sc)) {
1981                 command = pci_read_config(dev, DC_PCI_CFDD, 4);
1982                 command &= ~(DC_CFDD_SNOOZE_MODE|DC_CFDD_SLEEP_MODE);
1983                 pci_write_config(dev, DC_PCI_CFDD, command, 4);
1984         }
1985
1986         /*
1987          * Try to learn something about the supported media.
1988          * We know that ASIX and ADMtek and Davicom devices
1989          * will *always* be using MII media, so that's a no-brainer.
1990          * The tricky ones are the Macronix/PNIC II and the
1991          * Intel 21143.
1992          */
1993         if (DC_IS_INTEL(sc))
1994                 dc_parse_21143_srom(sc);
1995         else if (DC_IS_MACRONIX(sc) || DC_IS_PNICII(sc)) {
1996                 if (sc->dc_type == DC_TYPE_98713)
1997                         sc->dc_pmode = DC_PMODE_MII;
1998                 else
1999                         sc->dc_pmode = DC_PMODE_SYM;
2000         } else if (!sc->dc_pmode)
2001                 sc->dc_pmode = DC_PMODE_MII;
2002
2003         /*
2004          * Get station address from the EEPROM.
2005          */
2006         switch(sc->dc_type) {
2007         case DC_TYPE_98713:
2008         case DC_TYPE_98713A:
2009         case DC_TYPE_987x5:
2010         case DC_TYPE_PNICII:
2011                 dc_read_eeprom(sc, (caddr_t)&mac_offset,
2012                     (DC_EE_NODEADDR_OFFSET / 2), 1, 0);
2013                 dc_read_eeprom(sc, (caddr_t)&eaddr, (mac_offset / 2), 3, 0);
2014                 break;
2015         case DC_TYPE_PNIC:
2016                 dc_read_eeprom(sc, (caddr_t)&eaddr, 0, 3, 1);
2017                 break;
2018         case DC_TYPE_DM9102:
2019         case DC_TYPE_21143:
2020         case DC_TYPE_ASIX:
2021                 dc_read_eeprom(sc, (caddr_t)&eaddr, DC_EE_NODEADDR, 3, 0);
2022                 break;
2023         case DC_TYPE_AL981:
2024         case DC_TYPE_AN985:
2025                 bcopy(&sc->dc_srom[DC_AL_EE_NODEADDR], (caddr_t)&eaddr,
2026                     ETHER_ADDR_LEN);
2027                 dc_read_eeprom(sc, (caddr_t)&eaddr, DC_AL_EE_NODEADDR, 3, 0);
2028                 break;
2029         case DC_TYPE_CONEXANT:
2030                 bcopy(sc->dc_srom + DC_CONEXANT_EE_NODEADDR, &eaddr, 6);
2031                 break;
2032         default:
2033                 dc_read_eeprom(sc, (caddr_t)&eaddr, DC_EE_NODEADDR, 3, 0);
2034                 break;
2035         }
2036
2037         sc->dc_ldata = contigmalloc(sizeof(struct dc_list_data), M_DEVBUF,
2038             M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);
2039
2040         if (sc->dc_ldata == NULL) {
2041                 device_printf(dev, "no memory for list buffers!\n");
2042                 if (sc->dc_pnic_rx_buf != NULL)
2043                         free(sc->dc_pnic_rx_buf, M_DEVBUF);
2044                 bus_teardown_intr(dev, sc->dc_irq, sc->dc_intrhand);
2045                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->dc_irq);
2046                 bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
2047                 error = ENXIO;
2048                 goto fail;
2049         }
2050
2051         bzero(sc->dc_ldata, sizeof(struct dc_list_data));
2052
2053         ifp->if_softc = sc;
2054         ifp->if_mtu = ETHERMTU;
2055         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
2056         ifp->if_ioctl = dc_ioctl;
2057         ifp->if_start = dc_start;
2058 #ifdef DEVICE_POLLING
2059         ifp->if_poll = dc_poll;
2060 #endif
2061         ifp->if_watchdog = dc_watchdog;
2062         ifp->if_init = dc_init;
2063         ifp->if_baudrate = 10000000;
2064         ifq_set_maxlen(&ifp->if_snd, DC_TX_LIST_CNT - 1);
2065         ifq_set_ready(&ifp->if_snd);
2066
2067         /*
2068          * Do MII setup. If this is a 21143, check for a PHY on the
2069          * MII bus after applying any necessary fixups to twiddle the
2070          * GPIO bits. If we don't end up finding a PHY, restore the
2071          * old selection (SIA only or SIA/SYM) and attach the dcphy
2072          * driver instead.
2073          */
2074         if (DC_IS_INTEL(sc)) {
2075                 dc_apply_fixup(sc, IFM_AUTO);
2076                 tmp = sc->dc_pmode;
2077                 sc->dc_pmode = DC_PMODE_MII;
2078         }
2079
2080         error = mii_phy_probe(dev, &sc->dc_miibus,
2081             dc_ifmedia_upd, dc_ifmedia_sts);
2082
2083         if (error && DC_IS_INTEL(sc)) {
2084                 sc->dc_pmode = tmp;
2085                 if (sc->dc_pmode != DC_PMODE_SIA)
2086                         sc->dc_pmode = DC_PMODE_SYM;
2087                 sc->dc_flags |= DC_21143_NWAY;
2088                 mii_phy_probe(dev, &sc->dc_miibus,
2089                     dc_ifmedia_upd, dc_ifmedia_sts);
2090                 /*
2091                  * For non-MII cards, we need to have the 21143
2092                  * drive the LEDs. Except there are some systems
2093                  * like the NEC VersaPro NoteBook PC which have no
2094                  * LEDs, and twiddling these bits has adverse effects
2095                  * on them. (I.e. you suddenly can't get a link.)
2096                  */
2097                 if (pci_read_config(dev, DC_PCI_CSID, 4) != 0x80281033)
2098                         sc->dc_flags |= DC_TULIP_LEDS;
2099                 error = 0;
2100         }
2101
2102         if (error) {
2103                 device_printf(dev, "MII without any PHY!\n");
2104                 contigfree(sc->dc_ldata, sizeof(struct dc_list_data),
2105                     M_DEVBUF);
2106                 if (sc->dc_pnic_rx_buf != NULL)
2107                         free(sc->dc_pnic_rx_buf, M_DEVBUF);
2108                 bus_teardown_intr(dev, sc->dc_irq, sc->dc_intrhand);
2109                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->dc_irq);
2110                 bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
2111                 error = ENXIO;
2112                 goto fail;
2113         }
2114
2115         /*
2116          * Call MI attach routine.
2117          */
2118         ether_ifattach(ifp, eaddr);
2119
2120         if (DC_IS_ADMTEK(sc)) {
2121                 /*
2122                  * Set automatic TX underrun recovery for the ADMtek chips
2123                  */
2124                 DC_SETBIT(sc, DC_AL_CR, DC_AL_CR_ATUR);
2125         }
2126
2127         /*
2128          * Tell the upper layer(s) we support long frames.
2129          */
2130         ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
2131
2132 fail:
2133         splx(s);
2134
2135         return(error);
2136 }
2137
2138 static int dc_detach(dev)
2139         device_t                dev;
2140 {
2141         struct dc_softc         *sc;
2142         struct ifnet            *ifp;
2143         int                     s;
2144         struct dc_mediainfo     *m;
2145
2146         s = splimp();
2147
2148         sc = device_get_softc(dev);
2149         ifp = &sc->arpcom.ac_if;
2150
2151         dc_stop(sc);
2152         ether_ifdetach(ifp);
2153
2154         bus_generic_detach(dev);
2155         device_delete_child(dev, sc->dc_miibus);
2156
2157         bus_teardown_intr(dev, sc->dc_irq, sc->dc_intrhand);
2158         bus_release_resource(dev, SYS_RES_IRQ, 0, sc->dc_irq);
2159         bus_release_resource(dev, DC_RES, DC_RID, sc->dc_res);
2160
2161         contigfree(sc->dc_ldata, sizeof(struct dc_list_data), M_DEVBUF);
2162         if (sc->dc_pnic_rx_buf != NULL)
2163                 free(sc->dc_pnic_rx_buf, M_DEVBUF);
2164
2165         while(sc->dc_mi != NULL) {
2166                 m = sc->dc_mi->dc_next;
2167                 free(sc->dc_mi, M_DEVBUF);
2168                 sc->dc_mi = m;
2169         }
2170         free(sc->dc_srom, M_DEVBUF);
2171
2172         splx(s);
2173
2174         return(0);
2175 }
2176
2177 /*
2178  * Initialize the transmit descriptors.
2179  */
2180 static int dc_list_tx_init(sc)
2181         struct dc_softc         *sc;
2182 {
2183         struct dc_chain_data    *cd;
2184         struct dc_list_data     *ld;
2185         int                     i;
2186
2187         cd = &sc->dc_cdata;
2188         ld = sc->dc_ldata;
2189         for (i = 0; i < DC_TX_LIST_CNT; i++) {
2190                 if (i == (DC_TX_LIST_CNT - 1)) {
2191                         ld->dc_tx_list[i].dc_next =
2192                             vtophys(&ld->dc_tx_list[0]);
2193                 } else {
2194                         ld->dc_tx_list[i].dc_next =
2195                             vtophys(&ld->dc_tx_list[i + 1]);
2196                 }
2197                 cd->dc_tx_chain[i] = NULL;
2198                 ld->dc_tx_list[i].dc_data = 0;
2199                 ld->dc_tx_list[i].dc_ctl = 0;
2200         }
2201
2202         cd->dc_tx_prod = cd->dc_tx_cons = cd->dc_tx_cnt = 0;
2203
2204         return(0);
2205 }
2206
2207
2208 /*
2209  * Initialize the RX descriptors and allocate mbufs for them. Note that
2210  * we arrange the descriptors in a closed ring, so that the last descriptor
2211  * points back to the first.
2212  */
2213 static int dc_list_rx_init(sc)
2214         struct dc_softc         *sc;
2215 {
2216         struct dc_chain_data    *cd;
2217         struct dc_list_data     *ld;
2218         int                     i;
2219
2220         cd = &sc->dc_cdata;
2221         ld = sc->dc_ldata;
2222
2223         for (i = 0; i < DC_RX_LIST_CNT; i++) {
2224                 if (dc_newbuf(sc, i, NULL) == ENOBUFS)
2225                         return(ENOBUFS);
2226                 if (i == (DC_RX_LIST_CNT - 1)) {
2227                         ld->dc_rx_list[i].dc_next =
2228                             vtophys(&ld->dc_rx_list[0]);
2229                 } else {
2230                         ld->dc_rx_list[i].dc_next =
2231                             vtophys(&ld->dc_rx_list[i + 1]);
2232                 }
2233         }
2234
2235         cd->dc_rx_prod = 0;
2236
2237         return(0);
2238 }
2239
2240 /*
2241  * Initialize an RX descriptor and attach an MBUF cluster.
2242  */
2243 static int dc_newbuf(sc, i, m)
2244         struct dc_softc         *sc;
2245         int                     i;
2246         struct mbuf             *m;
2247 {
2248         struct mbuf             *m_new = NULL;
2249         struct dc_desc          *c;
2250
2251         c = &sc->dc_ldata->dc_rx_list[i];
2252
2253         if (m == NULL) {
2254                 MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
2255                 if (m_new == NULL)
2256                         return(ENOBUFS);
2257
2258                 MCLGET(m_new, MB_DONTWAIT);
2259                 if (!(m_new->m_flags & M_EXT)) {
2260                         m_freem(m_new);
2261                         return(ENOBUFS);
2262                 }
2263                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
2264         } else {
2265                 m_new = m;
2266                 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
2267                 m_new->m_data = m_new->m_ext.ext_buf;
2268         }
2269
2270         m_adj(m_new, sizeof(u_int64_t));
2271
2272         /*
2273          * If this is a PNIC chip, zero the buffer. This is part
2274          * of the workaround for the receive bug in the 82c168 and
2275          * 82c169 chips.
2276          */
2277         if (sc->dc_flags & DC_PNIC_RX_BUG_WAR)
2278                 bzero((char *)mtod(m_new, char *), m_new->m_len);
2279
2280         sc->dc_cdata.dc_rx_chain[i] = m_new;
2281         c->dc_data = vtophys(mtod(m_new, caddr_t));
2282         c->dc_ctl = DC_RXCTL_RLINK | DC_RXLEN;
2283         c->dc_status = DC_RXSTAT_OWN;
2284
2285         return(0);
2286 }
2287
2288 /*
2289  * Grrrrr.
2290  * The PNIC chip has a terrible bug in it that manifests itself during
2291  * periods of heavy activity. The exact mode of failure if difficult to
2292  * pinpoint: sometimes it only happens in promiscuous mode, sometimes it
2293  * will happen on slow machines. The bug is that sometimes instead of
2294  * uploading one complete frame during reception, it uploads what looks
2295  * like the entire contents of its FIFO memory. The frame we want is at
2296  * the end of the whole mess, but we never know exactly how much data has
2297  * been uploaded, so salvaging the frame is hard.
2298  *
2299  * There is only one way to do it reliably, and it's disgusting.
2300  * Here's what we know:
2301  *
2302  * - We know there will always be somewhere between one and three extra
2303  *   descriptors uploaded.
2304  *
2305  * - We know the desired received frame will always be at the end of the
2306  *   total data upload.
2307  *
2308  * - We know the size of the desired received frame because it will be
2309  *   provided in the length field of the status word in the last descriptor.
2310  *
2311  * Here's what we do:
2312  *
2313  * - When we allocate buffers for the receive ring, we bzero() them.
2314  *   This means that we know that the buffer contents should be all
2315  *   zeros, except for data uploaded by the chip.
2316  *
2317  * - We also force the PNIC chip to upload frames that include the
2318  *   ethernet CRC at the end.
2319  *
2320  * - We gather all of the bogus frame data into a single buffer.
2321  *
2322  * - We then position a pointer at the end of this buffer and scan
2323  *   backwards until we encounter the first non-zero byte of data.
2324  *   This is the end of the received frame. We know we will encounter
2325  *   some data at the end of the frame because the CRC will always be
2326  *   there, so even if the sender transmits a packet of all zeros,
2327  *   we won't be fooled.
2328  *
2329  * - We know the size of the actual received frame, so we subtract
2330  *   that value from the current pointer location. This brings us
2331  *   to the start of the actual received packet.
2332  *
2333  * - We copy this into an mbuf and pass it on, along with the actual
2334  *   frame length.
2335  *
2336  * The performance hit is tremendous, but it beats dropping frames all
2337  * the time.
2338  */
2339
2340 #define DC_WHOLEFRAME   (DC_RXSTAT_FIRSTFRAG|DC_RXSTAT_LASTFRAG)
2341 static void dc_pnic_rx_bug_war(sc, idx)
2342         struct dc_softc         *sc;
2343         int                     idx;
2344 {
2345         struct dc_desc          *cur_rx;
2346         struct dc_desc          *c = NULL;
2347         struct mbuf             *m = NULL;
2348         unsigned char           *ptr;
2349         int                     i, total_len;
2350         u_int32_t               rxstat = 0;
2351
2352         i = sc->dc_pnic_rx_bug_save;
2353         cur_rx = &sc->dc_ldata->dc_rx_list[idx];
2354         ptr = sc->dc_pnic_rx_buf;
2355         bzero(ptr, DC_RXLEN * 5);
2356
2357         /* Copy all the bytes from the bogus buffers. */
2358         while (1) {
2359                 c = &sc->dc_ldata->dc_rx_list[i];
2360                 rxstat = c->dc_status;
2361                 m = sc->dc_cdata.dc_rx_chain[i];
2362                 bcopy(mtod(m, char *), ptr, DC_RXLEN);
2363                 ptr += DC_RXLEN;
2364                 /* If this is the last buffer, break out. */
2365                 if (i == idx || rxstat & DC_RXSTAT_LASTFRAG)
2366                         break;
2367                 dc_newbuf(sc, i, m);
2368                 DC_INC(i, DC_RX_LIST_CNT);
2369         }
2370
2371         /* Find the length of the actual receive frame. */
2372         total_len = DC_RXBYTES(rxstat);
2373
2374         /* Scan backwards until we hit a non-zero byte. */
2375         while(*ptr == 0x00)
2376                 ptr--;
2377
2378         /* Round off. */
2379         if ((uintptr_t)(ptr) & 0x3)
2380                 ptr -= 1;
2381
2382         /* Now find the start of the frame. */
2383         ptr -= total_len;
2384         if (ptr < sc->dc_pnic_rx_buf)
2385                 ptr = sc->dc_pnic_rx_buf;
2386
2387         /*
2388          * Now copy the salvaged frame to the last mbuf and fake up
2389          * the status word to make it look like a successful
2390          * frame reception.
2391          */
2392         dc_newbuf(sc, i, m);
2393         bcopy(ptr, mtod(m, char *), total_len); 
2394         cur_rx->dc_status = rxstat | DC_RXSTAT_FIRSTFRAG;
2395
2396         return;
2397 }
2398
2399 /*
2400  * This routine searches the RX ring for dirty descriptors in the
2401  * event that the rxeof routine falls out of sync with the chip's
2402  * current descriptor pointer. This may happen sometimes as a result
2403  * of a "no RX buffer available" condition that happens when the chip
2404  * consumes all of the RX buffers before the driver has a chance to
2405  * process the RX ring. This routine may need to be called more than
2406  * once to bring the driver back in sync with the chip, however we
2407  * should still be getting RX DONE interrupts to drive the search
2408  * for new packets in the RX ring, so we should catch up eventually.
2409  */
2410 static int dc_rx_resync(sc)
2411         struct dc_softc         *sc;
2412 {
2413         int                     i, pos;
2414         struct dc_desc          *cur_rx;
2415
2416         pos = sc->dc_cdata.dc_rx_prod;
2417
2418         for (i = 0; i < DC_RX_LIST_CNT; i++) {
2419                 cur_rx = &sc->dc_ldata->dc_rx_list[pos];
2420                 if (!(cur_rx->dc_status & DC_RXSTAT_OWN))
2421                         break;
2422                 DC_INC(pos, DC_RX_LIST_CNT);
2423         }
2424
2425         /* If the ring really is empty, then just return. */
2426         if (i == DC_RX_LIST_CNT)
2427                 return(0);
2428
2429         /* We've fallen behing the chip: catch it. */
2430         sc->dc_cdata.dc_rx_prod = pos;
2431
2432         return(EAGAIN);
2433 }
2434
2435 /*
2436  * A frame has been uploaded: pass the resulting mbuf chain up to
2437  * the higher level protocols.
2438  */
2439 static void dc_rxeof(sc)
2440         struct dc_softc         *sc;
2441 {
2442         struct mbuf             *m;
2443         struct ifnet            *ifp;
2444         struct dc_desc          *cur_rx;
2445         int                     i, total_len = 0;
2446         u_int32_t               rxstat;
2447
2448         ifp = &sc->arpcom.ac_if;
2449         i = sc->dc_cdata.dc_rx_prod;
2450
2451         while(!(sc->dc_ldata->dc_rx_list[i].dc_status & DC_RXSTAT_OWN)) {
2452
2453 #ifdef DEVICE_POLLING
2454                 if (ifp->if_flags & IFF_POLLING) {
2455                         if (sc->rxcycles <= 0)
2456                                 break;
2457                         sc->rxcycles--;
2458                 }
2459 #endif /* DEVICE_POLLING */
2460                 cur_rx = &sc->dc_ldata->dc_rx_list[i];
2461                 rxstat = cur_rx->dc_status;
2462                 m = sc->dc_cdata.dc_rx_chain[i];
2463                 total_len = DC_RXBYTES(rxstat);
2464
2465                 if (sc->dc_flags & DC_PNIC_RX_BUG_WAR) {
2466                         if ((rxstat & DC_WHOLEFRAME) != DC_WHOLEFRAME) {
2467                                 if (rxstat & DC_RXSTAT_FIRSTFRAG)
2468                                         sc->dc_pnic_rx_bug_save = i;
2469                                 if ((rxstat & DC_RXSTAT_LASTFRAG) == 0) {
2470                                         DC_INC(i, DC_RX_LIST_CNT);
2471                                         continue;
2472                                 }
2473                                 dc_pnic_rx_bug_war(sc, i);
2474                                 rxstat = cur_rx->dc_status;
2475                                 total_len = DC_RXBYTES(rxstat);
2476                         }
2477                 }
2478
2479                 sc->dc_cdata.dc_rx_chain[i] = NULL;
2480
2481                 /*
2482                  * If an error occurs, update stats, clear the
2483                  * status word and leave the mbuf cluster in place:
2484                  * it should simply get re-used next time this descriptor
2485                  * comes up in the ring.  However, don't report long
2486                  * frames as errors since they could be vlans
2487                  */
2488                 if ((rxstat & DC_RXSTAT_RXERR)){ 
2489                         if (!(rxstat & DC_RXSTAT_GIANT) ||
2490                             (rxstat & (DC_RXSTAT_CRCERR | DC_RXSTAT_DRIBBLE |
2491                                        DC_RXSTAT_MIIERE | DC_RXSTAT_COLLSEEN |
2492                                        DC_RXSTAT_RUNT   | DC_RXSTAT_DE))) {
2493                                 ifp->if_ierrors++;
2494                                 if (rxstat & DC_RXSTAT_COLLSEEN)
2495                                         ifp->if_collisions++;
2496                                 dc_newbuf(sc, i, m);
2497                                 if (rxstat & DC_RXSTAT_CRCERR) {
2498                                         DC_INC(i, DC_RX_LIST_CNT);
2499                                         continue;
2500                                 } else {
2501                                         dc_init(sc);
2502                                         return;
2503                                 }
2504                         }
2505                 }
2506
2507                 /* No errors; receive the packet. */    
2508                 total_len -= ETHER_CRC_LEN;
2509
2510 #ifdef __i386__
2511                 /*
2512                  * On the x86 we do not have alignment problems, so try to
2513                  * allocate a new buffer for the receive ring, and pass up
2514                  * the one where the packet is already, saving the expensive
2515                  * copy done in m_devget().
2516                  * If we are on an architecture with alignment problems, or
2517                  * if the allocation fails, then use m_devget and leave the
2518                  * existing buffer in the receive ring.
2519                  */
2520                 if (dc_quick && dc_newbuf(sc, i, NULL) == 0) {
2521                         m->m_pkthdr.rcvif = ifp;
2522                         m->m_pkthdr.len = m->m_len = total_len;
2523                         DC_INC(i, DC_RX_LIST_CNT);
2524                 } else
2525 #endif
2526                 {
2527                         struct mbuf *m0;
2528
2529                         m0 = m_devget(mtod(m, char *) - ETHER_ALIGN,
2530                             total_len + ETHER_ALIGN, 0, ifp, NULL);
2531                         dc_newbuf(sc, i, m);
2532                         DC_INC(i, DC_RX_LIST_CNT);
2533                         if (m0 == NULL) {
2534                                 ifp->if_ierrors++;
2535                                 continue;
2536                         }
2537                         m_adj(m0, ETHER_ALIGN);
2538                         m = m0;
2539                 }
2540
2541                 ifp->if_ipackets++;
2542                 (*ifp->if_input)(ifp, m);
2543         }
2544
2545         sc->dc_cdata.dc_rx_prod = i;
2546 }
2547
2548 /*
2549  * A frame was downloaded to the chip. It's safe for us to clean up
2550  * the list buffers.
2551  */
2552
2553 static void
2554 dc_txeof(sc)
2555         struct dc_softc         *sc;
2556 {
2557         struct dc_desc          *cur_tx = NULL;
2558         struct ifnet            *ifp;
2559         int                     idx;
2560
2561         ifp = &sc->arpcom.ac_if;
2562
2563         /*
2564          * Go through our tx list and free mbufs for those
2565          * frames that have been transmitted.
2566          */
2567         idx = sc->dc_cdata.dc_tx_cons;
2568         while(idx != sc->dc_cdata.dc_tx_prod) {
2569                 u_int32_t               txstat;
2570
2571                 cur_tx = &sc->dc_ldata->dc_tx_list[idx];
2572                 txstat = cur_tx->dc_status;
2573
2574                 if (txstat & DC_TXSTAT_OWN)
2575                         break;
2576
2577                 if (!(cur_tx->dc_ctl & DC_TXCTL_LASTFRAG) ||
2578                     cur_tx->dc_ctl & DC_TXCTL_SETUP) {
2579                         if (cur_tx->dc_ctl & DC_TXCTL_SETUP) {
2580                                 /*
2581                                  * Yes, the PNIC is so brain damaged
2582                                  * that it will sometimes generate a TX
2583                                  * underrun error while DMAing the RX
2584                                  * filter setup frame. If we detect this,
2585                                  * we have to send the setup frame again,
2586                                  * or else the filter won't be programmed
2587                                  * correctly.
2588                                  */
2589                                 if (DC_IS_PNIC(sc)) {
2590                                         if (txstat & DC_TXSTAT_ERRSUM)
2591                                                 dc_setfilt(sc);
2592                                 }
2593                                 sc->dc_cdata.dc_tx_chain[idx] = NULL;
2594                         }
2595                         sc->dc_cdata.dc_tx_cnt--;
2596                         DC_INC(idx, DC_TX_LIST_CNT);
2597                         continue;
2598                 }
2599
2600                 if (DC_IS_CONEXANT(sc)) {
2601                         /*
2602                          * For some reason Conexant chips like
2603                          * setting the CARRLOST flag even when
2604                          * the carrier is there. In CURRENT we
2605                          * have the same problem for Xircom
2606                          * cards !
2607                          */
2608                         if (/*sc->dc_type == DC_TYPE_21143 &&*/
2609                             sc->dc_pmode == DC_PMODE_MII &&
2610                             ((txstat & 0xFFFF) & ~(DC_TXSTAT_ERRSUM|
2611                             DC_TXSTAT_NOCARRIER)))
2612                                 txstat &= ~DC_TXSTAT_ERRSUM;
2613                 } else {
2614                         if (/*sc->dc_type == DC_TYPE_21143 &&*/
2615                             sc->dc_pmode == DC_PMODE_MII &&
2616                             ((txstat & 0xFFFF) & ~(DC_TXSTAT_ERRSUM|
2617                             DC_TXSTAT_NOCARRIER|DC_TXSTAT_CARRLOST)))
2618                                 txstat &= ~DC_TXSTAT_ERRSUM;
2619                 }
2620
2621                 if (txstat & DC_TXSTAT_ERRSUM) {
2622                         ifp->if_oerrors++;
2623                         if (txstat & DC_TXSTAT_EXCESSCOLL)
2624                                 ifp->if_collisions++;
2625                         if (txstat & DC_TXSTAT_LATECOLL)
2626                                 ifp->if_collisions++;
2627                         if (!(txstat & DC_TXSTAT_UNDERRUN)) {
2628                                 dc_init(sc);
2629                                 return;
2630                         }
2631                 }
2632
2633                 ifp->if_collisions += (txstat & DC_TXSTAT_COLLCNT) >> 3;
2634
2635                 ifp->if_opackets++;
2636                 if (sc->dc_cdata.dc_tx_chain[idx] != NULL) {
2637                         m_freem(sc->dc_cdata.dc_tx_chain[idx]);
2638                         sc->dc_cdata.dc_tx_chain[idx] = NULL;
2639                 }
2640
2641                 sc->dc_cdata.dc_tx_cnt--;
2642                 DC_INC(idx, DC_TX_LIST_CNT);
2643         }
2644
2645         if (idx != sc->dc_cdata.dc_tx_cons) {
2646                 /* some buffers have been freed */
2647                 sc->dc_cdata.dc_tx_cons = idx;
2648                 ifp->if_flags &= ~IFF_OACTIVE;
2649         }
2650         ifp->if_timer = (sc->dc_cdata.dc_tx_cnt == 0) ? 0 : 5;
2651
2652         return;
2653 }
2654
2655 static void dc_tick(xsc)
2656         void                    *xsc;
2657 {
2658         struct dc_softc         *sc;
2659         struct mii_data         *mii;
2660         struct ifnet            *ifp;
2661         int                     s;
2662         u_int32_t               r;
2663
2664         s = splimp();
2665
2666         sc = xsc;
2667         ifp = &sc->arpcom.ac_if;
2668         mii = device_get_softc(sc->dc_miibus);
2669
2670         if (sc->dc_flags & DC_REDUCED_MII_POLL) {
2671                 if (sc->dc_flags & DC_21143_NWAY) {
2672                         r = CSR_READ_4(sc, DC_10BTSTAT);
2673                         if (IFM_SUBTYPE(mii->mii_media_active) ==
2674                             IFM_100_TX && (r & DC_TSTAT_LS100)) {
2675                                 sc->dc_link = 0;
2676                                 mii_mediachg(mii);
2677                         }
2678                         if (IFM_SUBTYPE(mii->mii_media_active) ==
2679                             IFM_10_T && (r & DC_TSTAT_LS10)) {
2680                                 sc->dc_link = 0;
2681                                 mii_mediachg(mii);
2682                         }
2683                         if (sc->dc_link == 0)
2684                                 mii_tick(mii);
2685                 } else {
2686                         r = CSR_READ_4(sc, DC_ISR);
2687                         if ((r & DC_ISR_RX_STATE) == DC_RXSTATE_WAIT &&
2688                             sc->dc_cdata.dc_tx_cnt == 0)
2689                                 mii_tick(mii);
2690                                 if (!(mii->mii_media_status & IFM_ACTIVE))
2691                                         sc->dc_link = 0;
2692                 }
2693         } else
2694                 mii_tick(mii);
2695
2696         /*
2697          * When the init routine completes, we expect to be able to send
2698          * packets right away, and in fact the network code will send a
2699          * gratuitous ARP the moment the init routine marks the interface
2700          * as running. However, even though the MAC may have been initialized,
2701          * there may be a delay of a few seconds before the PHY completes
2702          * autonegotiation and the link is brought up. Any transmissions
2703          * made during that delay will be lost. Dealing with this is tricky:
2704          * we can't just pause in the init routine while waiting for the
2705          * PHY to come ready since that would bring the whole system to
2706          * a screeching halt for several seconds.
2707          *
2708          * What we do here is prevent the TX start routine from sending
2709          * any packets until a link has been established. After the
2710          * interface has been initialized, the tick routine will poll
2711          * the state of the PHY until the IFM_ACTIVE flag is set. Until
2712          * that time, packets will stay in the send queue, and once the
2713          * link comes up, they will be flushed out to the wire.
2714          */
2715         if (!sc->dc_link) {
2716                 mii_pollstat(mii);
2717                 if (mii->mii_media_status & IFM_ACTIVE &&
2718                     IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
2719                         sc->dc_link++;
2720                         if (!ifq_is_empty(&ifp->if_snd))
2721                                 dc_start(ifp);
2722                 }
2723         }
2724
2725         if (sc->dc_flags & DC_21143_NWAY && !sc->dc_link)
2726                 callout_reset(&sc->dc_stat_timer, hz / 10, dc_tick, sc);
2727         else
2728                 callout_reset(&sc->dc_stat_timer, hz, dc_tick, sc);
2729
2730         splx(s);
2731
2732         return;
2733 }
2734
2735 /*
2736  * A transmit underrun has occurred.  Back off the transmit threshold,
2737  * or switch to store and forward mode if we have to.
2738  */
2739 static void dc_tx_underrun(sc)
2740         struct dc_softc         *sc;
2741 {
2742         u_int32_t               isr;
2743         int                     i;
2744
2745         if (DC_IS_DAVICOM(sc))
2746                 dc_init(sc);
2747
2748         if (DC_IS_INTEL(sc)) {
2749                 /*
2750                  * The real 21143 requires that the transmitter be idle
2751                  * in order to change the transmit threshold or store
2752                  * and forward state.
2753                  */
2754                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON);
2755
2756                 for (i = 0; i < DC_TIMEOUT; i++) {
2757                         isr = CSR_READ_4(sc, DC_ISR);
2758                         if (isr & DC_ISR_TX_IDLE)
2759                                 break;
2760                         DELAY(10);
2761                 }
2762                 if (i == DC_TIMEOUT) {
2763                         if_printf(&sc->arpcom.ac_if,
2764                                   "failed to force tx to idle state\n");
2765                         dc_init(sc);
2766                 }
2767         }
2768
2769         if_printf(&sc->arpcom.ac_if, "TX underrun -- ");
2770         sc->dc_txthresh += DC_TXTHRESH_INC;
2771         if (sc->dc_txthresh > DC_TXTHRESH_MAX) {
2772                 printf("using store and forward mode\n");
2773                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_STORENFWD);
2774         } else {
2775                 printf("increasing TX threshold\n");
2776                 DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_TX_THRESH);
2777                 DC_SETBIT(sc, DC_NETCFG, sc->dc_txthresh);
2778         }
2779
2780         if (DC_IS_INTEL(sc))
2781                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON);
2782
2783         return;
2784 }
2785
2786 #ifdef DEVICE_POLLING
2787
2788 static void
2789 dc_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
2790 {
2791         struct  dc_softc *sc = ifp->if_softc;
2792         u_int32_t status;
2793
2794         switch(cmd) {
2795         case POLL_REGISTER:
2796                 /* Disable interrupts */
2797                 CSR_WRITE_4(sc, DC_IMR, 0x00000000);
2798                 break;
2799         case POLL_DEREGISTER:
2800                 /* Re-enable interrupts. */
2801                 CSR_WRITE_4(sc, DC_IMR, DC_INTRS);
2802                 break;
2803         case POLL_ONLY:
2804                 sc->rxcycles = count;
2805                 dc_rxeof(sc);
2806                 dc_txeof(sc);
2807                 if ((ifp->if_flags & IFF_OACTIVE) == 0 && !ifq_is_empty(&ifp->if_snd))
2808                         dc_start(ifp);
2809                 break;
2810         case POLL_AND_CHECK_STATUS:
2811                 sc->rxcycles = count;
2812                 dc_rxeof(sc);
2813                 dc_txeof(sc);
2814                 if ((ifp->if_flags & IFF_OACTIVE) == 0 && !ifq_is_empty(&ifp->if_snd))
2815                         dc_start(ifp);
2816                 status = CSR_READ_4(sc, DC_ISR);
2817                 status &= (DC_ISR_RX_WATDOGTIMEO|DC_ISR_RX_NOBUF|
2818                         DC_ISR_TX_NOBUF|DC_ISR_TX_IDLE|DC_ISR_TX_UNDERRUN|
2819                         DC_ISR_BUS_ERR);
2820                 if (!status)
2821                         break;
2822                 /* ack what we have */
2823                 CSR_WRITE_4(sc, DC_ISR, status);
2824
2825                 if (status & (DC_ISR_RX_WATDOGTIMEO|DC_ISR_RX_NOBUF) ) {
2826                         u_int32_t r = CSR_READ_4(sc, DC_FRAMESDISCARDED);
2827                         ifp->if_ierrors += (r & 0xffff) + ((r >> 17) & 0x7ff);
2828
2829                         if (dc_rx_resync(sc))
2830                                 dc_rxeof(sc);
2831                 }
2832                 /* restart transmit unit if necessary */
2833                 if (status & DC_ISR_TX_IDLE && sc->dc_cdata.dc_tx_cnt)
2834                         CSR_WRITE_4(sc, DC_TXSTART, 0xFFFFFFFF);
2835
2836                 if (status & DC_ISR_TX_UNDERRUN)
2837                         dc_tx_underrun(sc);
2838
2839                 if (status & DC_ISR_BUS_ERR) {
2840                         if_printf(ifp, "dc_poll: bus error\n");
2841                         dc_reset(sc);
2842                         dc_init(sc);
2843                 }
2844                 break;
2845         }
2846 }
2847 #endif /* DEVICE_POLLING */
2848
2849 static void dc_intr(arg)
2850         void                    *arg;
2851 {
2852         struct dc_softc         *sc;
2853         struct ifnet            *ifp;
2854         u_int32_t               status;
2855
2856         sc = arg;
2857
2858         if (sc->suspended) {
2859                 return;
2860         }
2861
2862         ifp = &sc->arpcom.ac_if;
2863
2864         if ( (CSR_READ_4(sc, DC_ISR) & DC_INTRS) == 0)
2865                 return ;
2866
2867         /* Suppress unwanted interrupts */
2868         if (!(ifp->if_flags & IFF_UP)) {
2869                 if (CSR_READ_4(sc, DC_ISR) & DC_INTRS)
2870                         dc_stop(sc);
2871                 return;
2872         }
2873
2874         /* Disable interrupts. */
2875         CSR_WRITE_4(sc, DC_IMR, 0x00000000);
2876
2877         while((status = CSR_READ_4(sc, DC_ISR)) & DC_INTRS) {
2878
2879                 CSR_WRITE_4(sc, DC_ISR, status);
2880
2881                 if (status & DC_ISR_RX_OK) {
2882                         int             curpkts;
2883                         curpkts = ifp->if_ipackets;
2884                         dc_rxeof(sc);
2885                         if (curpkts == ifp->if_ipackets) {
2886                                 while(dc_rx_resync(sc))
2887                                         dc_rxeof(sc);
2888                         }
2889                 }
2890
2891                 if (status & (DC_ISR_TX_OK|DC_ISR_TX_NOBUF))
2892                         dc_txeof(sc);
2893
2894                 if (status & DC_ISR_TX_IDLE) {
2895                         dc_txeof(sc);
2896                         if (sc->dc_cdata.dc_tx_cnt) {
2897                                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON);
2898                                 CSR_WRITE_4(sc, DC_TXSTART, 0xFFFFFFFF);
2899                         }
2900                 }
2901
2902                 if (status & DC_ISR_TX_UNDERRUN)
2903                         dc_tx_underrun(sc);
2904
2905                 if ((status & DC_ISR_RX_WATDOGTIMEO)
2906                     || (status & DC_ISR_RX_NOBUF)) {
2907                         int             curpkts;
2908                         curpkts = ifp->if_ipackets;
2909                         dc_rxeof(sc);
2910                         if (curpkts == ifp->if_ipackets) {
2911                                 while(dc_rx_resync(sc))
2912                                         dc_rxeof(sc);
2913                         }
2914                 }
2915
2916                 if (status & DC_ISR_BUS_ERR) {
2917                         dc_reset(sc);
2918                         dc_init(sc);
2919                 }
2920         }
2921
2922         /* Re-enable interrupts. */
2923         CSR_WRITE_4(sc, DC_IMR, DC_INTRS);
2924
2925         if (!ifq_is_empty(&ifp->if_snd))
2926                 dc_start(ifp);
2927
2928         return;
2929 }
2930
2931 /*
2932  * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
2933  * pointers to the fragment pointers.
2934  */
2935 static int dc_encap(sc, m_head, txidx)
2936         struct dc_softc         *sc;
2937         struct mbuf             *m_head;
2938         u_int32_t               *txidx;
2939 {
2940         struct dc_desc          *f = NULL;
2941         struct mbuf             *m;
2942         int                     frag, cur, cnt = 0;
2943
2944         /*
2945          * Start packing the mbufs in this chain into
2946          * the fragment pointers. Stop when we run out
2947          * of fragments or hit the end of the mbuf chain.
2948          */
2949         m = m_head;
2950         cur = frag = *txidx;
2951
2952         for (m = m_head; m != NULL; m = m->m_next) {
2953                 if (m->m_len != 0) {
2954                         if (sc->dc_flags & DC_TX_ADMTEK_WAR) {
2955                                 if (*txidx != sc->dc_cdata.dc_tx_prod &&
2956                                     frag == (DC_TX_LIST_CNT - 1))
2957                                         return(ENOBUFS);
2958                         }
2959                         if ((DC_TX_LIST_CNT -
2960                             (sc->dc_cdata.dc_tx_cnt + cnt)) < 5)
2961                                 return(ENOBUFS);
2962
2963                         f = &sc->dc_ldata->dc_tx_list[frag];
2964                         f->dc_ctl = DC_TXCTL_TLINK | m->m_len;
2965                         if (cnt == 0) {
2966                                 f->dc_status = 0;
2967                                 f->dc_ctl |= DC_TXCTL_FIRSTFRAG;
2968                         } else
2969                                 f->dc_status = DC_TXSTAT_OWN;
2970                         f->dc_data = vtophys(mtod(m, vm_offset_t));
2971                         cur = frag;
2972                         DC_INC(frag, DC_TX_LIST_CNT);
2973                         cnt++;
2974                 }
2975         }
2976
2977         if (m != NULL)
2978                 return(ENOBUFS);
2979
2980         sc->dc_cdata.dc_tx_cnt += cnt;
2981         sc->dc_cdata.dc_tx_chain[cur] = m_head;
2982         sc->dc_ldata->dc_tx_list[cur].dc_ctl |= DC_TXCTL_LASTFRAG;
2983         if (sc->dc_flags & DC_TX_INTR_FIRSTFRAG)
2984                 sc->dc_ldata->dc_tx_list[*txidx].dc_ctl |= DC_TXCTL_FINT;
2985         if (sc->dc_flags & DC_TX_INTR_ALWAYS)
2986                 sc->dc_ldata->dc_tx_list[cur].dc_ctl |= DC_TXCTL_FINT;
2987         if (sc->dc_flags & DC_TX_USE_TX_INTR && sc->dc_cdata.dc_tx_cnt > 64)
2988                 sc->dc_ldata->dc_tx_list[cur].dc_ctl |= DC_TXCTL_FINT;
2989         sc->dc_ldata->dc_tx_list[*txidx].dc_status = DC_TXSTAT_OWN;
2990         *txidx = frag;
2991
2992         return(0);
2993 }
2994
2995 /*
2996  * Main transmit routine. To avoid having to do mbuf copies, we put pointers
2997  * to the mbuf data regions directly in the transmit lists. We also save a
2998  * copy of the pointers since the transmit list fragment pointers are
2999  * physical addresses.
3000  */
3001
3002 static void dc_start(ifp)
3003         struct ifnet            *ifp;
3004 {
3005         struct dc_softc         *sc;
3006         struct mbuf *m_head = NULL, *m_new;
3007         int did_defrag, idx;
3008
3009         sc = ifp->if_softc;
3010
3011         if (!sc->dc_link)
3012                 return;
3013
3014         if (ifp->if_flags & IFF_OACTIVE)
3015                 return;
3016
3017         idx = sc->dc_cdata.dc_tx_prod;
3018
3019         while(sc->dc_cdata.dc_tx_chain[idx] == NULL) {
3020                 did_defrag = 0;
3021                 m_head = ifq_poll(&ifp->if_snd);
3022                 if (m_head == NULL)
3023                         break;
3024
3025                 if (sc->dc_flags & DC_TX_COALESCE &&
3026                     m_head->m_next != NULL) {
3027                         /*
3028                          * Check first if coalescing allows us to queue
3029                          * the packet. We don't want to loose it if
3030                          * the TX queue is full.
3031                          */ 
3032                         if ((sc->dc_flags & DC_TX_ADMTEK_WAR) &&
3033                             idx != sc->dc_cdata.dc_tx_prod &&
3034                             idx == (DC_TX_LIST_CNT - 1)) {
3035                                 ifp->if_flags |= IFF_OACTIVE;
3036                                 break;
3037                         }
3038                         if ((DC_TX_LIST_CNT - sc->dc_cdata.dc_tx_cnt) < 5) {
3039                                 ifp->if_flags |= IFF_OACTIVE;
3040                                 break;
3041                         }
3042
3043                         /* only coalesce if have >1 mbufs */
3044                         m_new = m_defrag_nofree(m_head, MB_DONTWAIT);
3045                         if (m_new == NULL) {
3046                                 ifp->if_flags |= IFF_OACTIVE;
3047                                 break;
3048                         }
3049                         m_freem(m_head);
3050                         m_head = m_new;
3051                         did_defrag = 1;
3052                 }
3053
3054                 if (dc_encap(sc, m_head, &idx)) {
3055                         if (did_defrag) {
3056                                 m_freem(m_head);
3057                                 m_new = ifq_dequeue(&ifp->if_snd);
3058                                 m_freem(m_new);
3059                         }
3060                         ifp->if_flags |= IFF_OACTIVE;
3061                         break;
3062                 }
3063
3064                 m_new = ifq_dequeue(&ifp->if_snd);
3065                 if (did_defrag)
3066                         m_freem(m_new);
3067
3068                 /*
3069                  * If there's a BPF listener, bounce a copy of this frame
3070                  * to him.
3071                  */
3072                 BPF_MTAP(ifp, m_head);
3073
3074                 if (sc->dc_flags & DC_TX_ONE) {
3075                         ifp->if_flags |= IFF_OACTIVE;
3076                         break;
3077                 }
3078         }
3079
3080         /* Transmit */
3081         sc->dc_cdata.dc_tx_prod = idx;
3082         if (!(sc->dc_flags & DC_TX_POLL))
3083                 CSR_WRITE_4(sc, DC_TXSTART, 0xFFFFFFFF);
3084
3085         /*
3086          * Set a timeout in case the chip goes out to lunch.
3087          */
3088         ifp->if_timer = 5;
3089
3090         return;
3091 }
3092
3093 static void dc_init(xsc)
3094         void                    *xsc;
3095 {
3096         struct dc_softc         *sc = xsc;
3097         struct ifnet            *ifp = &sc->arpcom.ac_if;
3098         struct mii_data         *mii;
3099         int                     s;
3100
3101         s = splimp();
3102
3103         mii = device_get_softc(sc->dc_miibus);
3104
3105         /*
3106          * Cancel pending I/O and free all RX/TX buffers.
3107          */
3108         dc_stop(sc);
3109         dc_reset(sc);
3110
3111         /*
3112          * Set cache alignment and burst length.
3113          */
3114         if (DC_IS_ASIX(sc) || DC_IS_DAVICOM(sc))
3115                 CSR_WRITE_4(sc, DC_BUSCTL, 0);
3116         else
3117                 CSR_WRITE_4(sc, DC_BUSCTL, DC_BUSCTL_MRME|DC_BUSCTL_MRLE);
3118         /*
3119          * Evenly share the bus between receive and transmit process.
3120          */
3121         if (DC_IS_INTEL(sc))
3122                 DC_SETBIT(sc, DC_BUSCTL, DC_BUSCTL_ARBITRATION);
3123         if (DC_IS_DAVICOM(sc) || DC_IS_INTEL(sc)) {
3124                 DC_SETBIT(sc, DC_BUSCTL, DC_BURSTLEN_USECA);
3125         } else {
3126                 DC_SETBIT(sc, DC_BUSCTL, DC_BURSTLEN_16LONG);
3127         }
3128         if (sc->dc_flags & DC_TX_POLL)
3129                 DC_SETBIT(sc, DC_BUSCTL, DC_TXPOLL_1);
3130         switch(sc->dc_cachesize) {
3131         case 32:
3132                 DC_SETBIT(sc, DC_BUSCTL, DC_CACHEALIGN_32LONG);
3133                 break;
3134         case 16:
3135                 DC_SETBIT(sc, DC_BUSCTL, DC_CACHEALIGN_16LONG);
3136                 break; 
3137         case 8:
3138                 DC_SETBIT(sc, DC_BUSCTL, DC_CACHEALIGN_8LONG);
3139                 break;  
3140         case 0:
3141         default:
3142                 DC_SETBIT(sc, DC_BUSCTL, DC_CACHEALIGN_NONE);
3143                 break;
3144         }
3145
3146         if (sc->dc_flags & DC_TX_STORENFWD)
3147                 DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_STORENFWD);
3148         else {
3149                 if (sc->dc_txthresh > DC_TXTHRESH_MAX) {
3150                         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_STORENFWD);
3151                 } else {
3152                         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_STORENFWD);
3153                         DC_SETBIT(sc, DC_NETCFG, sc->dc_txthresh);
3154                 }
3155         }
3156
3157         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_NO_RXCRC);
3158         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_TX_BACKOFF);
3159
3160         if (DC_IS_MACRONIX(sc) || DC_IS_PNICII(sc)) {
3161                 /*
3162                  * The app notes for the 98713 and 98715A say that
3163                  * in order to have the chips operate properly, a magic
3164                  * number must be written to CSR16. Macronix does not
3165                  * document the meaning of these bits so there's no way
3166                  * to know exactly what they do. The 98713 has a magic
3167                  * number all its own; the rest all use a different one.
3168                  */
3169                 DC_CLRBIT(sc, DC_MX_MAGICPACKET, 0xFFFF0000);
3170                 if (sc->dc_type == DC_TYPE_98713)
3171                         DC_SETBIT(sc, DC_MX_MAGICPACKET, DC_MX_MAGIC_98713);
3172                 else
3173                         DC_SETBIT(sc, DC_MX_MAGICPACKET, DC_MX_MAGIC_98715);
3174         }
3175
3176         DC_CLRBIT(sc, DC_NETCFG, DC_NETCFG_TX_THRESH);
3177         DC_SETBIT(sc, DC_NETCFG, DC_TXTHRESH_MIN);
3178
3179         /* Init circular RX list. */
3180         if (dc_list_rx_init(sc) == ENOBUFS) {
3181                 if_printf(ifp, "initialization failed: no "
3182                           "memory for rx buffers\n");
3183                 dc_stop(sc);
3184                 (void)splx(s);
3185                 return;
3186         }
3187
3188         /*
3189          * Init tx descriptors.
3190          */
3191         dc_list_tx_init(sc);
3192
3193         /*
3194          * Load the address of the RX list.
3195          */
3196         CSR_WRITE_4(sc, DC_RXADDR, vtophys(&sc->dc_ldata->dc_rx_list[0]));
3197         CSR_WRITE_4(sc, DC_TXADDR, vtophys(&sc->dc_ldata->dc_tx_list[0]));
3198
3199         /*
3200          * Enable interrupts.
3201          */
3202 #ifdef DEVICE_POLLING
3203         /*
3204          * ... but only if we are not polling, and make sure they are off in
3205          * the case of polling. Some cards (e.g. fxp) turn interrupts on
3206          * after a reset.
3207          */
3208         if (ifp->if_flags & IFF_POLLING)
3209                 CSR_WRITE_4(sc, DC_IMR, 0x00000000);
3210         else
3211 #endif
3212         CSR_WRITE_4(sc, DC_IMR, DC_INTRS);
3213         CSR_WRITE_4(sc, DC_ISR, 0xFFFFFFFF);
3214
3215         /* Enable transmitter. */
3216         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_TX_ON);
3217
3218         /*
3219          * If this is an Intel 21143 and we're not using the
3220          * MII port, program the LED control pins so we get
3221          * link and activity indications.
3222          */
3223         if (sc->dc_flags & DC_TULIP_LEDS) {
3224                 CSR_WRITE_4(sc, DC_WATCHDOG,
3225                     DC_WDOG_CTLWREN|DC_WDOG_LINK|DC_WDOG_ACTIVITY);   
3226                 CSR_WRITE_4(sc, DC_WATCHDOG, 0);
3227         }
3228
3229         /*
3230          * Load the RX/multicast filter. We do this sort of late
3231          * because the filter programming scheme on the 21143 and
3232          * some clones requires DMAing a setup frame via the TX
3233          * engine, and we need the transmitter enabled for that.
3234          */
3235         dc_setfilt(sc);
3236
3237         /* Enable receiver. */
3238         DC_SETBIT(sc, DC_NETCFG, DC_NETCFG_RX_ON);
3239         CSR_WRITE_4(sc, DC_RXSTART, 0xFFFFFFFF);
3240
3241         mii_mediachg(mii);
3242         dc_setcfg(sc, sc->dc_if_media);
3243
3244         ifp->if_flags |= IFF_RUNNING;
3245         ifp->if_flags &= ~IFF_OACTIVE;
3246
3247         (void)splx(s);
3248
3249         /* Don't start the ticker if this is a homePNA link. */
3250         if (IFM_SUBTYPE(mii->mii_media.ifm_media) == IFM_HPNA_1)
3251                 sc->dc_link = 1;
3252         else {
3253                 if (sc->dc_flags & DC_21143_NWAY)
3254                         callout_reset(&sc->dc_stat_timer, hz/10, dc_tick, sc);
3255                 else
3256                         callout_reset(&sc->dc_stat_timer, hz, dc_tick, sc);
3257         }
3258
3259         return;
3260 }
3261
3262 /*
3263  * Set media options.
3264  */
3265 static int dc_ifmedia_upd(ifp)
3266         struct ifnet            *ifp;
3267 {
3268         struct dc_softc         *sc;
3269         struct mii_data         *mii;
3270         struct ifmedia          *ifm;
3271
3272         sc = ifp->if_softc;
3273         mii = device_get_softc(sc->dc_miibus);
3274         mii_mediachg(mii);
3275         ifm = &mii->mii_media;
3276
3277         if (DC_IS_DAVICOM(sc) &&
3278             IFM_SUBTYPE(ifm->ifm_media) == IFM_HPNA_1)
3279                 dc_setcfg(sc, ifm->ifm_media);
3280         else
3281                 sc->dc_link = 0;
3282
3283         return(0);
3284 }
3285
3286 /*
3287  * Report current media status.
3288  */
3289 static void dc_ifmedia_sts(ifp, ifmr)
3290         struct ifnet            *ifp;
3291         struct ifmediareq       *ifmr;
3292 {
3293         struct dc_softc         *sc;
3294         struct mii_data         *mii;
3295         struct ifmedia          *ifm;
3296
3297         sc = ifp->if_softc;
3298         mii = device_get_softc(sc->dc_miibus);
3299         mii_pollstat(mii);
3300         ifm = &mii->mii_media;
3301         if (DC_IS_DAVICOM(sc)) {
3302                 if (IFM_SUBTYPE(ifm->ifm_media) == IFM_HPNA_1) {
3303                         ifmr->ifm_active = ifm->ifm_media;
3304                         ifmr->ifm_status = 0;
3305                         return;
3306                 }
3307         }
3308         ifmr->ifm_active = mii->mii_media_active;
3309         ifmr->ifm_status = mii->mii_media_status;
3310
3311         return;
3312 }
3313
3314 static int dc_ioctl(ifp, command, data, cr)
3315         struct ifnet            *ifp;
3316         u_long                  command;
3317         caddr_t                 data;
3318         struct ucred            *cr;
3319 {
3320         struct dc_softc         *sc = ifp->if_softc;
3321         struct ifreq            *ifr = (struct ifreq *) data;
3322         struct mii_data         *mii;
3323         int                     s, error = 0;
3324
3325         s = splimp();
3326
3327         switch(command) {
3328         case SIOCSIFFLAGS:
3329                 if (ifp->if_flags & IFF_UP) {
3330                         int need_setfilt = (ifp->if_flags ^ sc->dc_if_flags) &
3331                                 (IFF_PROMISC | IFF_ALLMULTI);
3332                         if (ifp->if_flags & IFF_RUNNING) {
3333                                 if (need_setfilt)
3334                                         dc_setfilt(sc);
3335                         } else {
3336                                 sc->dc_txthresh = 0;
3337                                 dc_init(sc);
3338                         }
3339                 } else {
3340                         if (ifp->if_flags & IFF_RUNNING)
3341                                 dc_stop(sc);
3342                 }
3343                 sc->dc_if_flags = ifp->if_flags;
3344                 error = 0;
3345                 break;
3346         case SIOCADDMULTI:
3347         case SIOCDELMULTI:
3348                 dc_setfilt(sc);
3349                 error = 0;
3350                 break;
3351         case SIOCGIFMEDIA:
3352         case SIOCSIFMEDIA:
3353                 mii = device_get_softc(sc->dc_miibus);
3354                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
3355                 break;
3356         default:
3357                 error = ether_ioctl(ifp, command, data);
3358                 break;
3359         }
3360
3361         (void)splx(s);
3362
3363         return(error);
3364 }
3365
3366 static void dc_watchdog(ifp)
3367         struct ifnet            *ifp;
3368 {
3369         struct dc_softc         *sc;
3370
3371         sc = ifp->if_softc;
3372
3373         ifp->if_oerrors++;
3374         if_printf(ifp, "watchdog timeout\n");
3375
3376         dc_stop(sc);
3377         dc_reset(sc);
3378         dc_init(sc);
3379
3380         if (!ifq_is_empty(&ifp->if_snd))
3381                 dc_start(ifp);
3382
3383         return;
3384 }
3385
3386 /*
3387  * Stop the adapter and free any mbufs allocated to the
3388  * RX and TX lists.
3389  */
3390 static void dc_stop(sc)
3391         struct dc_softc         *sc;
3392 {
3393         int             i;
3394         struct ifnet            *ifp;
3395
3396         ifp = &sc->arpcom.ac_if;
3397         ifp->if_timer = 0;
3398
3399         callout_stop(&sc->dc_stat_timer);
3400
3401         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
3402
3403         DC_CLRBIT(sc, DC_NETCFG, (DC_NETCFG_RX_ON|DC_NETCFG_TX_ON));
3404         CSR_WRITE_4(sc, DC_IMR, 0x00000000);
3405         CSR_WRITE_4(sc, DC_TXADDR, 0x00000000);
3406         CSR_WRITE_4(sc, DC_RXADDR, 0x00000000);
3407         sc->dc_link = 0;
3408
3409         /*
3410          * Free data in the RX lists.
3411          */
3412         for (i = 0; i < DC_RX_LIST_CNT; i++) {
3413                 if (sc->dc_cdata.dc_rx_chain[i] != NULL) {
3414                         m_freem(sc->dc_cdata.dc_rx_chain[i]);
3415                         sc->dc_cdata.dc_rx_chain[i] = NULL;
3416                 }
3417         }
3418         bzero((char *)&sc->dc_ldata->dc_rx_list,
3419                 sizeof(sc->dc_ldata->dc_rx_list));
3420
3421         /*
3422          * Free the TX list buffers.
3423          */
3424         for (i = 0; i < DC_TX_LIST_CNT; i++) {
3425                 if (sc->dc_cdata.dc_tx_chain[i] != NULL) {
3426                         if ((sc->dc_ldata->dc_tx_list[i].dc_ctl &
3427                             DC_TXCTL_SETUP) ||
3428                             !(sc->dc_ldata->dc_tx_list[i].dc_ctl &
3429                             DC_TXCTL_LASTFRAG)) {
3430                                 sc->dc_cdata.dc_tx_chain[i] = NULL;
3431                                 continue;
3432                         }
3433                         m_freem(sc->dc_cdata.dc_tx_chain[i]);
3434                         sc->dc_cdata.dc_tx_chain[i] = NULL;
3435                 }
3436         }
3437
3438         bzero((char *)&sc->dc_ldata->dc_tx_list,
3439                 sizeof(sc->dc_ldata->dc_tx_list));
3440
3441         return;
3442 }
3443
3444 /*
3445  * Stop all chip I/O so that the kernel's probe routines don't
3446  * get confused by errant DMAs when rebooting.
3447  */
3448 static void dc_shutdown(dev)
3449         device_t                dev;
3450 {
3451         struct dc_softc         *sc;
3452
3453         sc = device_get_softc(dev);
3454
3455         dc_stop(sc);
3456
3457         return;
3458 }
3459
3460 /*
3461  * Device suspend routine.  Stop the interface and save some PCI
3462  * settings in case the BIOS doesn't restore them properly on
3463  * resume.
3464  */
3465 static int dc_suspend(dev)
3466         device_t                dev;
3467 {
3468         int             i;
3469         int                     s;
3470         struct dc_softc         *sc;
3471
3472         s = splimp();
3473
3474         sc = device_get_softc(dev);
3475
3476         dc_stop(sc);
3477
3478         for (i = 0; i < 5; i++)
3479                 sc->saved_maps[i] = pci_read_config(dev, PCIR_MAPS + i * 4, 4);
3480         sc->saved_biosaddr = pci_read_config(dev, PCIR_BIOS, 4);
3481         sc->saved_intline = pci_read_config(dev, PCIR_INTLINE, 1);
3482         sc->saved_cachelnsz = pci_read_config(dev, PCIR_CACHELNSZ, 1);
3483         sc->saved_lattimer = pci_read_config(dev, PCIR_LATTIMER, 1);
3484
3485         sc->suspended = 1;
3486
3487         splx(s);
3488         return (0);
3489 }
3490
3491 /*
3492  * Device resume routine.  Restore some PCI settings in case the BIOS
3493  * doesn't, re-enable busmastering, and restart the interface if
3494  * appropriate.
3495  */
3496 static int dc_resume(dev)
3497         device_t                dev;
3498 {
3499         int             i;
3500         int                     s;
3501         struct dc_softc         *sc;
3502         struct ifnet            *ifp;
3503
3504         s = splimp();
3505
3506         sc = device_get_softc(dev);
3507         ifp = &sc->arpcom.ac_if;
3508
3509         dc_acpi(dev);
3510
3511         /* better way to do this? */
3512         for (i = 0; i < 5; i++)
3513                 pci_write_config(dev, PCIR_MAPS + i * 4, sc->saved_maps[i], 4);
3514         pci_write_config(dev, PCIR_BIOS, sc->saved_biosaddr, 4);
3515         pci_write_config(dev, PCIR_INTLINE, sc->saved_intline, 1);
3516         pci_write_config(dev, PCIR_CACHELNSZ, sc->saved_cachelnsz, 1);
3517         pci_write_config(dev, PCIR_LATTIMER, sc->saved_lattimer, 1);
3518
3519         /* reenable busmastering */
3520         pci_enable_busmaster(dev);
3521         pci_enable_io(dev, DC_RES);
3522
3523         /* reinitialize interface if necessary */
3524         if (ifp->if_flags & IFF_UP)
3525                 dc_init(sc);
3526
3527         sc->suspended = 0;
3528
3529         splx(s);
3530         return (0);
3531 }