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