Register keyword removal
[dragonfly.git] / sys / dev / netif / sk / if_sk.c
1 /*
2  * Copyright (c) 1997, 1998, 1999, 2000
3  *      Bill Paul <wpaul@ctr.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_sk.c,v 1.19.2.9 2003/03/05 18:42:34 njl Exp $
33  * $DragonFly: src/sys/dev/netif/sk/if_sk.c,v 1.3 2003/07/26 21:56:10 rob Exp $
34  *
35  * $FreeBSD: src/sys/pci/if_sk.c,v 1.19.2.9 2003/03/05 18:42:34 njl Exp $
36  */
37
38 /*
39  * SysKonnect SK-NET gigabit ethernet driver for FreeBSD. Supports
40  * the SK-984x series adapters, both single port and dual port.
41  * References:
42  *      The XaQti XMAC II datasheet,
43  *  http://www.freebsd.org/~wpaul/SysKonnect/xmacii_datasheet_rev_c_9-29.pdf
44  *      The SysKonnect GEnesis manual, http://www.syskonnect.com
45  *
46  * Note: XaQti has been aquired by Vitesse, and Vitesse does not have the
47  * XMAC II datasheet online. I have put my copy at people.freebsd.org as a
48  * convenience to others until Vitesse corrects this problem:
49  *
50  * http://people.freebsd.org/~wpaul/SysKonnect/xmacii_datasheet_rev_c_9-29.pdf
51  *
52  * Written by Bill Paul <wpaul@ee.columbia.edu>
53  * Department of Electrical Engineering
54  * Columbia University, New York City
55  */
56
57 /*
58  * The SysKonnect gigabit ethernet adapters consist of two main
59  * components: the SysKonnect GEnesis controller chip and the XaQti Corp.
60  * XMAC II gigabit ethernet MAC. The XMAC provides all of the MAC
61  * components and a PHY while the GEnesis controller provides a PCI
62  * interface with DMA support. Each card may have between 512K and
63  * 2MB of SRAM on board depending on the configuration.
64  *
65  * The SysKonnect GEnesis controller can have either one or two XMAC
66  * chips connected to it, allowing single or dual port NIC configurations.
67  * SysKonnect has the distinction of being the only vendor on the market
68  * with a dual port gigabit ethernet NIC. The GEnesis provides dual FIFOs,
69  * dual DMA queues, packet/MAC/transmit arbiters and direct access to the
70  * XMAC registers. This driver takes advantage of these features to allow
71  * both XMACs to operate as independent interfaces.
72  */
73  
74 #include <sys/param.h>
75 #include <sys/systm.h>
76 #include <sys/sockio.h>
77 #include <sys/mbuf.h>
78 #include <sys/malloc.h>
79 #include <sys/kernel.h>
80 #include <sys/socket.h>
81 #include <sys/queue.h>
82
83 #include <net/if.h>
84 #include <net/if_arp.h>
85 #include <net/ethernet.h>
86 #include <net/if_dl.h>
87 #include <net/if_media.h>
88
89 #include <net/bpf.h>
90
91 #include <vm/vm.h>              /* for vtophys */
92 #include <vm/pmap.h>            /* for vtophys */
93 #include <machine/clock.h>      /* for DELAY */
94 #include <machine/bus_pio.h>
95 #include <machine/bus_memio.h>
96 #include <machine/bus.h>
97 #include <machine/resource.h>
98 #include <sys/bus.h>
99 #include <sys/rman.h>
100
101 #include <dev/mii/mii.h>
102 #include <dev/mii/miivar.h>
103 #include <dev/mii/brgphyreg.h>
104
105 #include <pci/pcireg.h>
106 #include <pci/pcivar.h>
107
108 #define SK_USEIOSPACE
109
110 #include <pci/if_skreg.h>
111 #include <pci/xmaciireg.h>
112
113 /* "controller miibus0" required.  See GENERIC if you get errors here. */
114 #include "miibus_if.h"
115
116 static struct sk_type sk_devs[] = {
117         { SK_VENDORID, SK_DEVICEID_GE, "SysKonnect Gigabit Ethernet" },
118         { 0, 0, NULL }
119 };
120
121 static int sk_probe             __P((device_t));
122 static int sk_attach            __P((device_t));
123 static int sk_detach            __P((device_t));
124 static int sk_detach_xmac       __P((device_t));
125 static int sk_probe_xmac        __P((device_t));
126 static int sk_attach_xmac       __P((device_t));
127 static void sk_tick             __P((void *));
128 static void sk_intr             __P((void *));
129 static void sk_intr_xmac        __P((struct sk_if_softc *));
130 static void sk_intr_bcom        __P((struct sk_if_softc *));
131 static void sk_rxeof            __P((struct sk_if_softc *));
132 static void sk_txeof            __P((struct sk_if_softc *));
133 static int sk_encap             __P((struct sk_if_softc *, struct mbuf *,
134                                         u_int32_t *));
135 static void sk_start            __P((struct ifnet *));
136 static int sk_ioctl             __P((struct ifnet *, u_long, caddr_t));
137 static void sk_init             __P((void *));
138 static void sk_init_xmac        __P((struct sk_if_softc *));
139 static void sk_stop             __P((struct sk_if_softc *));
140 static void sk_watchdog         __P((struct ifnet *));
141 static void sk_shutdown         __P((device_t));
142 static int sk_ifmedia_upd       __P((struct ifnet *));
143 static void sk_ifmedia_sts      __P((struct ifnet *, struct ifmediareq *));
144 static void sk_reset            __P((struct sk_softc *));
145 static int sk_newbuf            __P((struct sk_if_softc *,
146                                         struct sk_chain *, struct mbuf *));
147 static int sk_alloc_jumbo_mem   __P((struct sk_if_softc *));
148 static void *sk_jalloc          __P((struct sk_if_softc *));
149 static void sk_jfree            __P((caddr_t, u_int));
150 static void sk_jref             __P((caddr_t, u_int));
151 static int sk_init_rx_ring      __P((struct sk_if_softc *));
152 static void sk_init_tx_ring     __P((struct sk_if_softc *));
153 static u_int32_t sk_win_read_4  __P((struct sk_softc *, int));
154 static u_int16_t sk_win_read_2  __P((struct sk_softc *, int));
155 static u_int8_t sk_win_read_1   __P((struct sk_softc *, int));
156 static void sk_win_write_4      __P((struct sk_softc *, int, u_int32_t));
157 static void sk_win_write_2      __P((struct sk_softc *, int, u_int32_t));
158 static void sk_win_write_1      __P((struct sk_softc *, int, u_int32_t));
159 static u_int8_t sk_vpd_readbyte __P((struct sk_softc *, int));
160 static void sk_vpd_read_res     __P((struct sk_softc *,
161                                         struct vpd_res *, int));
162 static void sk_vpd_read         __P((struct sk_softc *));
163
164 static int sk_miibus_readreg    __P((device_t, int, int));
165 static int sk_miibus_writereg   __P((device_t, int, int, int));
166 static void sk_miibus_statchg   __P((device_t));
167
168 static u_int32_t sk_calchash    __P((caddr_t));
169 static void sk_setfilt          __P((struct sk_if_softc *, caddr_t, int));
170 static void sk_setmulti         __P((struct sk_if_softc *));
171
172 #ifdef SK_USEIOSPACE
173 #define SK_RES          SYS_RES_IOPORT
174 #define SK_RID          SK_PCI_LOIO
175 #else
176 #define SK_RES          SYS_RES_MEMORY
177 #define SK_RID          SK_PCI_LOMEM
178 #endif
179
180 /*
181  * Note that we have newbus methods for both the GEnesis controller
182  * itself and the XMAC(s). The XMACs are children of the GEnesis, and
183  * the miibus code is a child of the XMACs. We need to do it this way
184  * so that the miibus drivers can access the PHY registers on the
185  * right PHY. It's not quite what I had in mind, but it's the only
186  * design that achieves the desired effect.
187  */
188 static device_method_t skc_methods[] = {
189         /* Device interface */
190         DEVMETHOD(device_probe,         sk_probe),
191         DEVMETHOD(device_attach,        sk_attach),
192         DEVMETHOD(device_detach,        sk_detach),
193         DEVMETHOD(device_shutdown,      sk_shutdown),
194
195         /* bus interface */
196         DEVMETHOD(bus_print_child,      bus_generic_print_child),
197         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
198
199         { 0, 0 }
200 };
201
202 static driver_t skc_driver = {
203         "skc",
204         skc_methods,
205         sizeof(struct sk_softc)
206 };
207
208 static devclass_t skc_devclass;
209
210 static device_method_t sk_methods[] = {
211         /* Device interface */
212         DEVMETHOD(device_probe,         sk_probe_xmac),
213         DEVMETHOD(device_attach,        sk_attach_xmac),
214         DEVMETHOD(device_detach,        sk_detach_xmac),
215         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
216
217         /* bus interface */
218         DEVMETHOD(bus_print_child,      bus_generic_print_child),
219         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
220
221         /* MII interface */
222         DEVMETHOD(miibus_readreg,       sk_miibus_readreg),
223         DEVMETHOD(miibus_writereg,      sk_miibus_writereg),
224         DEVMETHOD(miibus_statchg,       sk_miibus_statchg),
225
226         { 0, 0 }
227 };
228
229 static driver_t sk_driver = {
230         "sk",
231         sk_methods,
232         sizeof(struct sk_if_softc)
233 };
234
235 static devclass_t sk_devclass;
236
237 DRIVER_MODULE(if_sk, pci, skc_driver, skc_devclass, 0, 0);
238 DRIVER_MODULE(sk, skc, sk_driver, sk_devclass, 0, 0);
239 DRIVER_MODULE(miibus, sk, miibus_driver, miibus_devclass, 0, 0);
240
241 #define SK_SETBIT(sc, reg, x)           \
242         CSR_WRITE_4(sc, reg, CSR_READ_4(sc, reg) | x)
243
244 #define SK_CLRBIT(sc, reg, x)           \
245         CSR_WRITE_4(sc, reg, CSR_READ_4(sc, reg) & ~x)
246
247 #define SK_WIN_SETBIT_4(sc, reg, x)     \
248         sk_win_write_4(sc, reg, sk_win_read_4(sc, reg) | x)
249
250 #define SK_WIN_CLRBIT_4(sc, reg, x)     \
251         sk_win_write_4(sc, reg, sk_win_read_4(sc, reg) & ~x)
252
253 #define SK_WIN_SETBIT_2(sc, reg, x)     \
254         sk_win_write_2(sc, reg, sk_win_read_2(sc, reg) | x)
255
256 #define SK_WIN_CLRBIT_2(sc, reg, x)     \
257         sk_win_write_2(sc, reg, sk_win_read_2(sc, reg) & ~x)
258
259 static u_int32_t sk_win_read_4(sc, reg)
260         struct sk_softc         *sc;
261         int                     reg;
262 {
263         CSR_WRITE_4(sc, SK_RAP, SK_WIN(reg));
264         return(CSR_READ_4(sc, SK_WIN_BASE + SK_REG(reg)));
265 }
266
267 static u_int16_t sk_win_read_2(sc, reg)
268         struct sk_softc         *sc;
269         int                     reg;
270 {
271         CSR_WRITE_4(sc, SK_RAP, SK_WIN(reg));
272         return(CSR_READ_2(sc, SK_WIN_BASE + SK_REG(reg)));
273 }
274
275 static u_int8_t sk_win_read_1(sc, reg)
276         struct sk_softc         *sc;
277         int                     reg;
278 {
279         CSR_WRITE_4(sc, SK_RAP, SK_WIN(reg));
280         return(CSR_READ_1(sc, SK_WIN_BASE + SK_REG(reg)));
281 }
282
283 static void sk_win_write_4(sc, reg, val)
284         struct sk_softc         *sc;
285         int                     reg;
286         u_int32_t               val;
287 {
288         CSR_WRITE_4(sc, SK_RAP, SK_WIN(reg));
289         CSR_WRITE_4(sc, SK_WIN_BASE + SK_REG(reg), val);
290         return;
291 }
292
293 static void sk_win_write_2(sc, reg, val)
294         struct sk_softc         *sc;
295         int                     reg;
296         u_int32_t               val;
297 {
298         CSR_WRITE_4(sc, SK_RAP, SK_WIN(reg));
299         CSR_WRITE_2(sc, SK_WIN_BASE + SK_REG(reg), (u_int32_t)val);
300         return;
301 }
302
303 static void sk_win_write_1(sc, reg, val)
304         struct sk_softc         *sc;
305         int                     reg;
306         u_int32_t               val;
307 {
308         CSR_WRITE_4(sc, SK_RAP, SK_WIN(reg));
309         CSR_WRITE_1(sc, SK_WIN_BASE + SK_REG(reg), val);
310         return;
311 }
312
313 /*
314  * The VPD EEPROM contains Vital Product Data, as suggested in
315  * the PCI 2.1 specification. The VPD data is separared into areas
316  * denoted by resource IDs. The SysKonnect VPD contains an ID string
317  * resource (the name of the adapter), a read-only area resource
318  * containing various key/data fields and a read/write area which
319  * can be used to store asset management information or log messages.
320  * We read the ID string and read-only into buffers attached to
321  * the controller softc structure for later use. At the moment,
322  * we only use the ID string during sk_attach().
323  */
324 static u_int8_t sk_vpd_readbyte(sc, addr)
325         struct sk_softc         *sc;
326         int                     addr;
327 {
328         int                     i;
329
330         sk_win_write_2(sc, SK_PCI_REG(SK_PCI_VPD_ADDR), addr);
331         for (i = 0; i < SK_TIMEOUT; i++) {
332                 DELAY(1);
333                 if (sk_win_read_2(sc,
334                     SK_PCI_REG(SK_PCI_VPD_ADDR)) & SK_VPD_FLAG)
335                         break;
336         }
337
338         if (i == SK_TIMEOUT)
339                 return(0);
340
341         return(sk_win_read_1(sc, SK_PCI_REG(SK_PCI_VPD_DATA)));
342 }
343
344 static void sk_vpd_read_res(sc, res, addr)
345         struct sk_softc         *sc;
346         struct vpd_res          *res;
347         int                     addr;
348 {
349         int                     i;
350         u_int8_t                *ptr;
351
352         ptr = (u_int8_t *)res;
353         for (i = 0; i < sizeof(struct vpd_res); i++)
354                 ptr[i] = sk_vpd_readbyte(sc, i + addr);
355
356         return;
357 }
358
359 static void sk_vpd_read(sc)
360         struct sk_softc         *sc;
361 {
362         int                     pos = 0, i;
363         struct vpd_res          res;
364
365         if (sc->sk_vpd_prodname != NULL)
366                 free(sc->sk_vpd_prodname, M_DEVBUF);
367         if (sc->sk_vpd_readonly != NULL)
368                 free(sc->sk_vpd_readonly, M_DEVBUF);
369         sc->sk_vpd_prodname = NULL;
370         sc->sk_vpd_readonly = NULL;
371
372         sk_vpd_read_res(sc, &res, pos);
373
374         if (res.vr_id != VPD_RES_ID) {
375                 printf("skc%d: bad VPD resource id: expected %x got %x\n",
376                     sc->sk_unit, VPD_RES_ID, res.vr_id);
377                 return;
378         }
379
380         pos += sizeof(res);
381         sc->sk_vpd_prodname = malloc(res.vr_len + 1, M_DEVBUF, M_NOWAIT);
382         for (i = 0; i < res.vr_len; i++)
383                 sc->sk_vpd_prodname[i] = sk_vpd_readbyte(sc, i + pos);
384         sc->sk_vpd_prodname[i] = '\0';
385         pos += i;
386
387         sk_vpd_read_res(sc, &res, pos);
388
389         if (res.vr_id != VPD_RES_READ) {
390                 printf("skc%d: bad VPD resource id: expected %x got %x\n",
391                     sc->sk_unit, VPD_RES_READ, res.vr_id);
392                 return;
393         }
394
395         pos += sizeof(res);
396         sc->sk_vpd_readonly = malloc(res.vr_len, M_DEVBUF, M_NOWAIT);
397         for (i = 0; i < res.vr_len + 1; i++)
398                 sc->sk_vpd_readonly[i] = sk_vpd_readbyte(sc, i + pos);
399
400         return;
401 }
402
403 static int sk_miibus_readreg(dev, phy, reg)
404         device_t                dev;
405         int                     phy, reg;
406 {
407         struct sk_if_softc      *sc_if;
408         int                     i;
409
410         sc_if = device_get_softc(dev);
411
412         if (sc_if->sk_phytype == SK_PHYTYPE_XMAC && phy != 0)
413                 return(0);
414
415         SK_XM_WRITE_2(sc_if, XM_PHY_ADDR, reg|(phy << 8));
416         SK_XM_READ_2(sc_if, XM_PHY_DATA);
417         if (sc_if->sk_phytype != SK_PHYTYPE_XMAC) {
418                 for (i = 0; i < SK_TIMEOUT; i++) {
419                         DELAY(1);
420                         if (SK_XM_READ_2(sc_if, XM_MMUCMD) &
421                             XM_MMUCMD_PHYDATARDY)
422                                 break;
423                 }
424
425                 if (i == SK_TIMEOUT) {
426                         printf("sk%d: phy failed to come ready\n",
427                             sc_if->sk_unit);
428                         return(0);
429                 }
430         }
431         DELAY(1);
432         return(SK_XM_READ_2(sc_if, XM_PHY_DATA));
433 }
434
435 static int sk_miibus_writereg(dev, phy, reg, val)
436         device_t                dev;
437         int                     phy, reg, val;
438 {
439         struct sk_if_softc      *sc_if;
440         int                     i;
441
442         sc_if = device_get_softc(dev);
443
444         SK_XM_WRITE_2(sc_if, XM_PHY_ADDR, reg|(phy << 8));
445         for (i = 0; i < SK_TIMEOUT; i++) {
446                 if (!(SK_XM_READ_2(sc_if, XM_MMUCMD) & XM_MMUCMD_PHYBUSY))
447                         break;
448         }
449
450         if (i == SK_TIMEOUT) {
451                 printf("sk%d: phy failed to come ready\n", sc_if->sk_unit);
452                 return(ETIMEDOUT);
453         }
454
455         SK_XM_WRITE_2(sc_if, XM_PHY_DATA, val);
456         for (i = 0; i < SK_TIMEOUT; i++) {
457                 DELAY(1);
458                 if (!(SK_XM_READ_2(sc_if, XM_MMUCMD) & XM_MMUCMD_PHYBUSY))
459                         break;
460         }
461
462         if (i == SK_TIMEOUT)
463                 printf("sk%d: phy write timed out\n", sc_if->sk_unit);
464
465         return(0);
466 }
467
468 static void sk_miibus_statchg(dev)
469         device_t                dev;
470 {
471         struct sk_if_softc      *sc_if;
472         struct mii_data         *mii;
473
474         sc_if = device_get_softc(dev);
475         mii = device_get_softc(sc_if->sk_miibus);
476
477         /*
478          * If this is a GMII PHY, manually set the XMAC's
479          * duplex mode accordingly.
480          */
481         if (sc_if->sk_phytype != SK_PHYTYPE_XMAC) {
482                 if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX) {
483                         SK_XM_SETBIT_2(sc_if, XM_MMUCMD, XM_MMUCMD_GMIIFDX);
484                 } else {
485                         SK_XM_CLRBIT_2(sc_if, XM_MMUCMD, XM_MMUCMD_GMIIFDX);
486                 }
487         }
488
489         return;
490 }
491
492 #define SK_POLY         0xEDB88320
493 #define SK_BITS         6
494
495 static u_int32_t sk_calchash(addr)
496         caddr_t                 addr;
497 {
498         u_int32_t               idx, bit, data, crc;
499
500         /* Compute CRC for the address value. */
501         crc = 0xFFFFFFFF; /* initial value */
502
503         for (idx = 0; idx < 6; idx++) {
504                 for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1)
505                         crc = (crc >> 1) ^ (((crc ^ data) & 1) ? SK_POLY : 0);
506         }
507
508         return (~crc & ((1 << SK_BITS) - 1));
509 }
510
511 static void sk_setfilt(sc_if, addr, slot)
512         struct sk_if_softc      *sc_if;
513         caddr_t                 addr;
514         int                     slot;
515 {
516         int                     base;
517
518         base = XM_RXFILT_ENTRY(slot);
519
520         SK_XM_WRITE_2(sc_if, base, *(u_int16_t *)(&addr[0]));
521         SK_XM_WRITE_2(sc_if, base + 2, *(u_int16_t *)(&addr[2]));
522         SK_XM_WRITE_2(sc_if, base + 4, *(u_int16_t *)(&addr[4]));
523
524         return;
525 }
526
527 static void sk_setmulti(sc_if)
528         struct sk_if_softc      *sc_if;
529 {
530         struct ifnet            *ifp;
531         u_int32_t               hashes[2] = { 0, 0 };
532         int                     h, i;
533         struct ifmultiaddr      *ifma;
534         u_int8_t                dummy[] = { 0, 0, 0, 0, 0 ,0 };
535
536         ifp = &sc_if->arpcom.ac_if;
537
538         /* First, zot all the existing filters. */
539         for (i = 1; i < XM_RXFILT_MAX; i++)
540                 sk_setfilt(sc_if, (caddr_t)&dummy, i);
541         SK_XM_WRITE_4(sc_if, XM_MAR0, 0);
542         SK_XM_WRITE_4(sc_if, XM_MAR2, 0);
543
544         /* Now program new ones. */
545         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
546                 hashes[0] = 0xFFFFFFFF;
547                 hashes[1] = 0xFFFFFFFF;
548         } else {
549                 i = 1;
550                 /* First find the tail of the list. */
551                 for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
552                                         ifma = ifma->ifma_link.le_next) {
553                         if (ifma->ifma_link.le_next == NULL)
554                                 break;
555                 }
556                 /* Now traverse the list backwards. */
557                 for (; ifma != NULL && ifma != (void *)&ifp->if_multiaddrs;
558                         ifma = (struct ifmultiaddr *)ifma->ifma_link.le_prev) {
559                         if (ifma->ifma_addr->sa_family != AF_LINK)
560                                 continue;
561                         /*
562                          * Program the first XM_RXFILT_MAX multicast groups
563                          * into the perfect filter. For all others,
564                          * use the hash table.
565                          */
566                         if (i < XM_RXFILT_MAX) {
567                                 sk_setfilt(sc_if,
568                         LLADDR((struct sockaddr_dl *)ifma->ifma_addr), i);
569                                 i++;
570                                 continue;
571                         }
572
573                         h = sk_calchash(
574                                 LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
575                         if (h < 32)
576                                 hashes[0] |= (1 << h);
577                         else
578                                 hashes[1] |= (1 << (h - 32));
579                 }
580         }
581
582         SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_USE_HASH|
583             XM_MODE_RX_USE_PERFECT);
584         SK_XM_WRITE_4(sc_if, XM_MAR0, hashes[0]);
585         SK_XM_WRITE_4(sc_if, XM_MAR2, hashes[1]);
586
587         return;
588 }
589
590 static int sk_init_rx_ring(sc_if)
591         struct sk_if_softc      *sc_if;
592 {
593         struct sk_chain_data    *cd;
594         struct sk_ring_data     *rd;
595         int                     i;
596
597         cd = &sc_if->sk_cdata;
598         rd = sc_if->sk_rdata;
599
600         bzero((char *)rd->sk_rx_ring,
601             sizeof(struct sk_rx_desc) * SK_RX_RING_CNT);
602
603         for (i = 0; i < SK_RX_RING_CNT; i++) {
604                 cd->sk_rx_chain[i].sk_desc = &rd->sk_rx_ring[i];
605                 if (sk_newbuf(sc_if, &cd->sk_rx_chain[i], NULL) == ENOBUFS)
606                         return(ENOBUFS);
607                 if (i == (SK_RX_RING_CNT - 1)) {
608                         cd->sk_rx_chain[i].sk_next =
609                             &cd->sk_rx_chain[0];
610                         rd->sk_rx_ring[i].sk_next = 
611                             vtophys(&rd->sk_rx_ring[0]);
612                 } else {
613                         cd->sk_rx_chain[i].sk_next =
614                             &cd->sk_rx_chain[i + 1];
615                         rd->sk_rx_ring[i].sk_next = 
616                             vtophys(&rd->sk_rx_ring[i + 1]);
617                 }
618         }
619
620         sc_if->sk_cdata.sk_rx_prod = 0;
621         sc_if->sk_cdata.sk_rx_cons = 0;
622
623         return(0);
624 }
625
626 static void sk_init_tx_ring(sc_if)
627         struct sk_if_softc      *sc_if;
628 {
629         struct sk_chain_data    *cd;
630         struct sk_ring_data     *rd;
631         int                     i;
632
633         cd = &sc_if->sk_cdata;
634         rd = sc_if->sk_rdata;
635
636         bzero((char *)sc_if->sk_rdata->sk_tx_ring,
637             sizeof(struct sk_tx_desc) * SK_TX_RING_CNT);
638
639         for (i = 0; i < SK_TX_RING_CNT; i++) {
640                 cd->sk_tx_chain[i].sk_desc = &rd->sk_tx_ring[i];
641                 if (i == (SK_TX_RING_CNT - 1)) {
642                         cd->sk_tx_chain[i].sk_next =
643                             &cd->sk_tx_chain[0];
644                         rd->sk_tx_ring[i].sk_next = 
645                             vtophys(&rd->sk_tx_ring[0]);
646                 } else {
647                         cd->sk_tx_chain[i].sk_next =
648                             &cd->sk_tx_chain[i + 1];
649                         rd->sk_tx_ring[i].sk_next = 
650                             vtophys(&rd->sk_tx_ring[i + 1]);
651                 }
652         }
653
654         sc_if->sk_cdata.sk_tx_prod = 0;
655         sc_if->sk_cdata.sk_tx_cons = 0;
656         sc_if->sk_cdata.sk_tx_cnt = 0;
657
658         return;
659 }
660
661 static int sk_newbuf(sc_if, c, m)
662         struct sk_if_softc      *sc_if;
663         struct sk_chain         *c;
664         struct mbuf             *m;
665 {
666         struct mbuf             *m_new = NULL;
667         struct sk_rx_desc       *r;
668
669         if (m == NULL) {
670                 caddr_t                 *buf = NULL;
671
672                 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
673                 if (m_new == NULL)
674                         return(ENOBUFS);
675
676                 /* Allocate the jumbo buffer */
677                 buf = sk_jalloc(sc_if);
678                 if (buf == NULL) {
679                         m_freem(m_new);
680 #ifdef SK_VERBOSE
681                         printf("sk%d: jumbo allocation failed "
682                             "-- packet dropped!\n", sc_if->sk_unit);
683 #endif
684                         return(ENOBUFS);
685                 }
686
687                 /* Attach the buffer to the mbuf */
688                 m_new->m_data = m_new->m_ext.ext_buf = (void *)buf;
689                 m_new->m_flags |= M_EXT;
690                 m_new->m_ext.ext_size = m_new->m_pkthdr.len =
691                     m_new->m_len = SK_MCLBYTES;
692                 m_new->m_ext.ext_free = sk_jfree;
693                 m_new->m_ext.ext_ref = sk_jref;
694         } else {
695                 /*
696                  * We're re-using a previously allocated mbuf;
697                  * be sure to re-init pointers and lengths to
698                  * default values.
699                  */
700                 m_new = m;
701                 m_new->m_len = m_new->m_pkthdr.len = SK_MCLBYTES;
702                 m_new->m_data = m_new->m_ext.ext_buf;
703         }
704
705         /*
706          * Adjust alignment so packet payload begins on a
707          * longword boundary. Mandatory for Alpha, useful on
708          * x86 too.
709          */
710         m_adj(m_new, ETHER_ALIGN);
711
712         r = c->sk_desc;
713         c->sk_mbuf = m_new;
714         r->sk_data_lo = vtophys(mtod(m_new, caddr_t));
715         r->sk_ctl = m_new->m_len | SK_RXSTAT;
716
717         return(0);
718 }
719
720 /*
721  * Allocate jumbo buffer storage. The SysKonnect adapters support
722  * "jumbograms" (9K frames), although SysKonnect doesn't currently
723  * use them in their drivers. In order for us to use them, we need
724  * large 9K receive buffers, however standard mbuf clusters are only
725  * 2048 bytes in size. Consequently, we need to allocate and manage
726  * our own jumbo buffer pool. Fortunately, this does not require an
727  * excessive amount of additional code.
728  */
729 static int sk_alloc_jumbo_mem(sc_if)
730         struct sk_if_softc      *sc_if;
731 {
732         caddr_t                 ptr;
733         int             i;
734         struct sk_jpool_entry   *entry;
735
736         /* Grab a big chunk o' storage. */
737         sc_if->sk_cdata.sk_jumbo_buf = contigmalloc(SK_JMEM, M_DEVBUF,
738             M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);
739
740         if (sc_if->sk_cdata.sk_jumbo_buf == NULL) {
741                 printf("sk%d: no memory for jumbo buffers!\n", sc_if->sk_unit);
742                 return(ENOBUFS);
743         }
744
745         SLIST_INIT(&sc_if->sk_jfree_listhead);
746         SLIST_INIT(&sc_if->sk_jinuse_listhead);
747
748         /*
749          * Now divide it up into 9K pieces and save the addresses
750          * in an array. Note that we play an evil trick here by using
751          * the first few bytes in the buffer to hold the the address
752          * of the softc structure for this interface. This is because
753          * sk_jfree() needs it, but it is called by the mbuf management
754          * code which will not pass it to us explicitly.
755          */
756         ptr = sc_if->sk_cdata.sk_jumbo_buf;
757         for (i = 0; i < SK_JSLOTS; i++) {
758                 u_int64_t               **aptr;
759                 aptr = (u_int64_t **)ptr;
760                 aptr[0] = (u_int64_t *)sc_if;
761                 ptr += sizeof(u_int64_t);
762                 sc_if->sk_cdata.sk_jslots[i].sk_buf = ptr;
763                 sc_if->sk_cdata.sk_jslots[i].sk_inuse = 0;
764                 ptr += SK_MCLBYTES;
765                 entry = malloc(sizeof(struct sk_jpool_entry), 
766                     M_DEVBUF, M_NOWAIT);
767                 if (entry == NULL) {
768                         free(sc_if->sk_cdata.sk_jumbo_buf, M_DEVBUF);
769                         sc_if->sk_cdata.sk_jumbo_buf = NULL;
770                         printf("sk%d: no memory for jumbo "
771                             "buffer queue!\n", sc_if->sk_unit);
772                         return(ENOBUFS);
773                 }
774                 entry->slot = i;
775                 SLIST_INSERT_HEAD(&sc_if->sk_jfree_listhead,
776                     entry, jpool_entries);
777         }
778
779         return(0);
780 }
781
782 /*
783  * Allocate a jumbo buffer.
784  */
785 static void *sk_jalloc(sc_if)
786         struct sk_if_softc      *sc_if;
787 {
788         struct sk_jpool_entry   *entry;
789         
790         entry = SLIST_FIRST(&sc_if->sk_jfree_listhead);
791         
792         if (entry == NULL) {
793 #ifdef SK_VERBOSE
794                 printf("sk%d: no free jumbo buffers\n", sc_if->sk_unit);
795 #endif
796                 return(NULL);
797         }
798
799         SLIST_REMOVE_HEAD(&sc_if->sk_jfree_listhead, jpool_entries);
800         SLIST_INSERT_HEAD(&sc_if->sk_jinuse_listhead, entry, jpool_entries);
801         sc_if->sk_cdata.sk_jslots[entry->slot].sk_inuse = 1;
802         return(sc_if->sk_cdata.sk_jslots[entry->slot].sk_buf);
803 }
804
805 /*
806  * Adjust usage count on a jumbo buffer. In general this doesn't
807  * get used much because our jumbo buffers don't get passed around
808  * a lot, but it's implemented for correctness.
809  */
810 static void sk_jref(buf, size)
811         caddr_t                 buf;
812         u_int                   size;
813 {
814         struct sk_if_softc      *sc_if;
815         u_int64_t               **aptr;
816         int             i;
817
818         /* Extract the softc struct pointer. */
819         aptr = (u_int64_t **)(buf - sizeof(u_int64_t));
820         sc_if = (struct sk_if_softc *)(aptr[0]);
821
822         if (sc_if == NULL)
823                 panic("sk_jref: can't find softc pointer!");
824
825         if (size != SK_MCLBYTES)
826                 panic("sk_jref: adjusting refcount of buf of wrong size!");
827
828         /* calculate the slot this buffer belongs to */
829
830         i = ((vm_offset_t)aptr 
831              - (vm_offset_t)sc_if->sk_cdata.sk_jumbo_buf) / SK_JLEN;
832
833         if ((i < 0) || (i >= SK_JSLOTS))
834                 panic("sk_jref: asked to reference buffer "
835                     "that we don't manage!");
836         else if (sc_if->sk_cdata.sk_jslots[i].sk_inuse == 0)
837                 panic("sk_jref: buffer already free!");
838         else
839                 sc_if->sk_cdata.sk_jslots[i].sk_inuse++;
840
841         return;
842 }
843
844 /*
845  * Release a jumbo buffer.
846  */
847 static void sk_jfree(buf, size)
848         caddr_t                 buf;
849         u_int                   size;
850 {
851         struct sk_if_softc      *sc_if;
852         u_int64_t               **aptr;
853         int                     i;
854         struct sk_jpool_entry   *entry;
855
856         /* Extract the softc struct pointer. */
857         aptr = (u_int64_t **)(buf - sizeof(u_int64_t));
858         sc_if = (struct sk_if_softc *)(aptr[0]);
859
860         if (sc_if == NULL)
861                 panic("sk_jfree: can't find softc pointer!");
862
863         if (size != SK_MCLBYTES)
864                 panic("sk_jfree: freeing buffer of wrong size!");
865
866         /* calculate the slot this buffer belongs to */
867
868         i = ((vm_offset_t)aptr 
869              - (vm_offset_t)sc_if->sk_cdata.sk_jumbo_buf) / SK_JLEN;
870
871         if ((i < 0) || (i >= SK_JSLOTS))
872                 panic("sk_jfree: asked to free buffer that we don't manage!");
873         else if (sc_if->sk_cdata.sk_jslots[i].sk_inuse == 0)
874                 panic("sk_jfree: buffer already free!");
875         else {
876                 sc_if->sk_cdata.sk_jslots[i].sk_inuse--;
877                 if(sc_if->sk_cdata.sk_jslots[i].sk_inuse == 0) {
878                         entry = SLIST_FIRST(&sc_if->sk_jinuse_listhead);
879                         if (entry == NULL)
880                                 panic("sk_jfree: buffer not in use!");
881                         entry->slot = i;
882                         SLIST_REMOVE_HEAD(&sc_if->sk_jinuse_listhead, 
883                                           jpool_entries);
884                         SLIST_INSERT_HEAD(&sc_if->sk_jfree_listhead, 
885                                           entry, jpool_entries);
886                 }
887         }
888
889         return;
890 }
891
892 /*
893  * Set media options.
894  */
895 static int sk_ifmedia_upd(ifp)
896         struct ifnet            *ifp;
897 {
898         struct sk_if_softc      *sc_if;
899         struct mii_data         *mii;
900
901         sc_if = ifp->if_softc;
902         mii = device_get_softc(sc_if->sk_miibus);
903         sk_init(sc_if);
904         mii_mediachg(mii);
905
906         return(0);
907 }
908
909 /*
910  * Report current media status.
911  */
912 static void sk_ifmedia_sts(ifp, ifmr)
913         struct ifnet            *ifp;
914         struct ifmediareq       *ifmr;
915 {
916         struct sk_if_softc      *sc_if;
917         struct mii_data         *mii;
918
919         sc_if = ifp->if_softc;
920         mii = device_get_softc(sc_if->sk_miibus);
921
922         mii_pollstat(mii);
923         ifmr->ifm_active = mii->mii_media_active;
924         ifmr->ifm_status = mii->mii_media_status;
925
926         return;
927 }
928
929 static int sk_ioctl(ifp, command, data)
930         struct ifnet            *ifp;
931         u_long                  command;
932         caddr_t                 data;
933 {
934         struct sk_if_softc      *sc_if = ifp->if_softc;
935         struct ifreq            *ifr = (struct ifreq *) data;
936         int                     s, error = 0;
937         struct mii_data         *mii;
938
939         s = splimp();
940
941         switch(command) {
942         case SIOCSIFADDR:
943         case SIOCGIFADDR:
944                 error = ether_ioctl(ifp, command, data);
945                 break;
946         case SIOCSIFMTU:
947                 if (ifr->ifr_mtu > SK_JUMBO_MTU)
948                         error = EINVAL;
949                 else {
950                         ifp->if_mtu = ifr->ifr_mtu;
951                         sk_init(sc_if);
952                 }
953                 break;
954         case SIOCSIFFLAGS:
955                 if (ifp->if_flags & IFF_UP) {
956                         if (ifp->if_flags & IFF_RUNNING &&
957                             ifp->if_flags & IFF_PROMISC &&
958                             !(sc_if->sk_if_flags & IFF_PROMISC)) {
959                                 SK_XM_SETBIT_4(sc_if, XM_MODE,
960                                     XM_MODE_RX_PROMISC);
961                                 sk_setmulti(sc_if);
962                         } else if (ifp->if_flags & IFF_RUNNING &&
963                             !(ifp->if_flags & IFF_PROMISC) &&
964                             sc_if->sk_if_flags & IFF_PROMISC) {
965                                 SK_XM_CLRBIT_4(sc_if, XM_MODE,
966                                     XM_MODE_RX_PROMISC);
967                                 sk_setmulti(sc_if);
968                         } else
969                                 sk_init(sc_if);
970                 } else {
971                         if (ifp->if_flags & IFF_RUNNING)
972                                 sk_stop(sc_if);
973                 }
974                 sc_if->sk_if_flags = ifp->if_flags;
975                 error = 0;
976                 break;
977         case SIOCADDMULTI:
978         case SIOCDELMULTI:
979                 sk_setmulti(sc_if);
980                 error = 0;
981                 break;
982         case SIOCGIFMEDIA:
983         case SIOCSIFMEDIA:
984                 mii = device_get_softc(sc_if->sk_miibus);
985                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
986                 break;
987         default:
988                 error = EINVAL;
989                 break;
990         }
991
992         (void)splx(s);
993
994         return(error);
995 }
996
997 /*
998  * Probe for a SysKonnect GEnesis chip. Check the PCI vendor and device
999  * IDs against our list and return a device name if we find a match.
1000  */
1001 static int sk_probe(dev)
1002         device_t                dev;
1003 {
1004         struct sk_type          *t;
1005
1006         t = sk_devs;
1007
1008         while(t->sk_name != NULL) {
1009                 if ((pci_get_vendor(dev) == t->sk_vid) &&
1010                     (pci_get_device(dev) == t->sk_did)) {
1011                         device_set_desc(dev, t->sk_name);
1012                         return(0);
1013                 }
1014                 t++;
1015         }
1016
1017         return(ENXIO);
1018 }
1019
1020 /*
1021  * Force the GEnesis into reset, then bring it out of reset.
1022  */
1023 static void sk_reset(sc)
1024         struct sk_softc         *sc;
1025 {
1026         CSR_WRITE_4(sc, SK_CSR, SK_CSR_SW_RESET);
1027         CSR_WRITE_4(sc, SK_CSR, SK_CSR_MASTER_RESET);
1028         DELAY(1000);
1029         CSR_WRITE_4(sc, SK_CSR, SK_CSR_SW_UNRESET);
1030         CSR_WRITE_4(sc, SK_CSR, SK_CSR_MASTER_UNRESET);
1031
1032         /* Configure packet arbiter */
1033         sk_win_write_2(sc, SK_PKTARB_CTL, SK_PKTARBCTL_UNRESET);
1034         sk_win_write_2(sc, SK_RXPA1_TINIT, SK_PKTARB_TIMEOUT);
1035         sk_win_write_2(sc, SK_TXPA1_TINIT, SK_PKTARB_TIMEOUT);
1036         sk_win_write_2(sc, SK_RXPA2_TINIT, SK_PKTARB_TIMEOUT);
1037         sk_win_write_2(sc, SK_TXPA2_TINIT, SK_PKTARB_TIMEOUT);
1038
1039         /* Enable RAM interface */
1040         sk_win_write_4(sc, SK_RAMCTL, SK_RAMCTL_UNRESET);
1041
1042         /*
1043          * Configure interrupt moderation. The moderation timer
1044          * defers interrupts specified in the interrupt moderation
1045          * timer mask based on the timeout specified in the interrupt
1046          * moderation timer init register. Each bit in the timer
1047          * register represents 18.825ns, so to specify a timeout in
1048          * microseconds, we have to multiply by 54.
1049          */
1050         sk_win_write_4(sc, SK_IMTIMERINIT, SK_IM_USECS(200));
1051         sk_win_write_4(sc, SK_IMMR, SK_ISR_TX1_S_EOF|SK_ISR_TX2_S_EOF|
1052             SK_ISR_RX1_EOF|SK_ISR_RX2_EOF);
1053         sk_win_write_1(sc, SK_IMTIMERCTL, SK_IMCTL_START);
1054
1055         return;
1056 }
1057
1058 static int sk_probe_xmac(dev)
1059         device_t                dev;
1060 {
1061         /*
1062          * Not much to do here. We always know there will be
1063          * at least one XMAC present, and if there are two,
1064          * sk_attach() will create a second device instance
1065          * for us.
1066          */
1067         device_set_desc(dev, "XaQti Corp. XMAC II");
1068
1069         return(0);
1070 }
1071
1072 /*
1073  * Each XMAC chip is attached as a separate logical IP interface.
1074  * Single port cards will have only one logical interface of course.
1075  */
1076 static int sk_attach_xmac(dev)
1077         device_t                dev;
1078 {
1079         struct sk_softc         *sc;
1080         struct sk_if_softc      *sc_if;
1081         struct ifnet            *ifp;
1082         int                     i, port;
1083
1084         if (dev == NULL)
1085                 return(EINVAL);
1086
1087         sc_if = device_get_softc(dev);
1088         sc = device_get_softc(device_get_parent(dev));
1089         port = *(int *)device_get_ivars(dev);
1090         free(device_get_ivars(dev), M_DEVBUF);
1091         device_set_ivars(dev, NULL);
1092         sc_if->sk_dev = dev;
1093
1094         bzero((char *)sc_if, sizeof(struct sk_if_softc));
1095
1096         sc_if->sk_dev = dev;
1097         sc_if->sk_unit = device_get_unit(dev);
1098         sc_if->sk_port = port;
1099         sc_if->sk_softc = sc;
1100         sc->sk_if[port] = sc_if;
1101         if (port == SK_PORT_A)
1102                 sc_if->sk_tx_bmu = SK_BMU_TXS_CSR0;
1103         if (port == SK_PORT_B)
1104                 sc_if->sk_tx_bmu = SK_BMU_TXS_CSR1;
1105         
1106         /*
1107          * Get station address for this interface. Note that
1108          * dual port cards actually come with three station
1109          * addresses: one for each port, plus an extra. The
1110          * extra one is used by the SysKonnect driver software
1111          * as a 'virtual' station address for when both ports
1112          * are operating in failover mode. Currently we don't
1113          * use this extra address.
1114          */
1115         for (i = 0; i < ETHER_ADDR_LEN; i++)
1116                 sc_if->arpcom.ac_enaddr[i] =
1117                     sk_win_read_1(sc, SK_MAC0_0 + (port * 8) + i);
1118
1119         printf("sk%d: Ethernet address: %6D\n",
1120             sc_if->sk_unit, sc_if->arpcom.ac_enaddr, ":");
1121
1122         /*
1123          * Set up RAM buffer addresses. The NIC will have a certain
1124          * amount of SRAM on it, somewhere between 512K and 2MB. We
1125          * need to divide this up a) between the transmitter and
1126          * receiver and b) between the two XMACs, if this is a
1127          * dual port NIC. Our algotithm is to divide up the memory
1128          * evenly so that everyone gets a fair share.
1129          */
1130         if (sk_win_read_1(sc, SK_CONFIG) & SK_CONFIG_SINGLEMAC) {
1131                 u_int32_t               chunk, val;
1132
1133                 chunk = sc->sk_ramsize / 2;
1134                 val = sc->sk_rboff / sizeof(u_int64_t);
1135                 sc_if->sk_rx_ramstart = val;
1136                 val += (chunk / sizeof(u_int64_t));
1137                 sc_if->sk_rx_ramend = val - 1;
1138                 sc_if->sk_tx_ramstart = val;
1139                 val += (chunk / sizeof(u_int64_t));
1140                 sc_if->sk_tx_ramend = val - 1;
1141         } else {
1142                 u_int32_t               chunk, val;
1143
1144                 chunk = sc->sk_ramsize / 4;
1145                 val = (sc->sk_rboff + (chunk * 2 * sc_if->sk_port)) /
1146                     sizeof(u_int64_t);
1147                 sc_if->sk_rx_ramstart = val;
1148                 val += (chunk / sizeof(u_int64_t));
1149                 sc_if->sk_rx_ramend = val - 1;
1150                 sc_if->sk_tx_ramstart = val;
1151                 val += (chunk / sizeof(u_int64_t));
1152                 sc_if->sk_tx_ramend = val - 1;
1153         }
1154
1155         /* Read and save PHY type and set PHY address */
1156         sc_if->sk_phytype = sk_win_read_1(sc, SK_EPROM1) & 0xF;
1157         switch(sc_if->sk_phytype) {
1158         case SK_PHYTYPE_XMAC:
1159                 sc_if->sk_phyaddr = SK_PHYADDR_XMAC;
1160                 break;
1161         case SK_PHYTYPE_BCOM:
1162                 sc_if->sk_phyaddr = SK_PHYADDR_BCOM;
1163                 break;
1164         default:
1165                 printf("skc%d: unsupported PHY type: %d\n",
1166                     sc->sk_unit, sc_if->sk_phytype);
1167                 return(ENODEV);
1168         }
1169
1170         /* Allocate the descriptor queues. */
1171         sc_if->sk_rdata = contigmalloc(sizeof(struct sk_ring_data), M_DEVBUF,
1172             M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);
1173
1174         if (sc_if->sk_rdata == NULL) {
1175                 printf("sk%d: no memory for list buffers!\n", sc_if->sk_unit);
1176                 sc->sk_if[port] = NULL;
1177                 return(ENOMEM);
1178         }
1179
1180         bzero(sc_if->sk_rdata, sizeof(struct sk_ring_data));
1181
1182         /* Try to allocate memory for jumbo buffers. */
1183         if (sk_alloc_jumbo_mem(sc_if)) {
1184                 printf("sk%d: jumbo buffer allocation failed\n",
1185                     sc_if->sk_unit);
1186                 contigfree(sc_if->sk_rdata,
1187                     sizeof(struct sk_ring_data), M_DEVBUF);
1188                 sc->sk_if[port] = NULL;
1189                 return(ENOMEM);
1190         }
1191
1192         ifp = &sc_if->arpcom.ac_if;
1193         ifp->if_softc = sc_if;
1194         ifp->if_unit = sc_if->sk_unit; 
1195         ifp->if_name = "sk";
1196         ifp->if_mtu = ETHERMTU;
1197         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1198         ifp->if_ioctl = sk_ioctl;
1199         ifp->if_output = ether_output;
1200         ifp->if_start = sk_start;
1201         ifp->if_watchdog = sk_watchdog;
1202         ifp->if_init = sk_init;
1203         ifp->if_baudrate = 1000000000;
1204         ifp->if_snd.ifq_maxlen = SK_TX_RING_CNT - 1;
1205
1206         /*
1207          * Do miibus setup.
1208          */
1209         sk_init_xmac(sc_if);
1210         if (mii_phy_probe(dev, &sc_if->sk_miibus,
1211             sk_ifmedia_upd, sk_ifmedia_sts)) {
1212                 printf("skc%d: no PHY found!\n", sc_if->sk_unit);
1213                 contigfree(sc_if->sk_cdata.sk_jumbo_buf, SK_JMEM,
1214                     M_DEVBUF);
1215                 contigfree(sc_if->sk_rdata,
1216                     sizeof(struct sk_ring_data), M_DEVBUF);
1217                 return(ENXIO);
1218         }
1219
1220         /*
1221          * Call MI attach routine.
1222          */
1223         ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
1224         callout_handle_init(&sc_if->sk_tick_ch);
1225
1226         return(0);
1227 }
1228
1229 /*
1230  * Attach the interface. Allocate softc structures, do ifmedia
1231  * setup and ethernet/BPF attach.
1232  */
1233 static int sk_attach(dev)
1234         device_t                dev;
1235 {
1236         int                     s;
1237         u_int32_t               command;
1238         struct sk_softc         *sc;
1239         int                     unit, error = 0, rid, *port;
1240
1241         s = splimp();
1242
1243         sc = device_get_softc(dev);
1244         unit = device_get_unit(dev);
1245         bzero(sc, sizeof(struct sk_softc));
1246
1247         /*
1248          * Handle power management nonsense.
1249          */
1250         command = pci_read_config(dev, SK_PCI_CAPID, 4) & 0x000000FF;
1251         if (command == 0x01) {
1252
1253                 command = pci_read_config(dev, SK_PCI_PWRMGMTCTRL, 4);
1254                 if (command & SK_PSTATE_MASK) {
1255                         u_int32_t               iobase, membase, irq;
1256
1257                         /* Save important PCI config data. */
1258                         iobase = pci_read_config(dev, SK_PCI_LOIO, 4);
1259                         membase = pci_read_config(dev, SK_PCI_LOMEM, 4);
1260                         irq = pci_read_config(dev, SK_PCI_INTLINE, 4);
1261
1262                         /* Reset the power state. */
1263                         printf("skc%d: chip is in D%d power mode "
1264                         "-- setting to D0\n", unit, command & SK_PSTATE_MASK);
1265                         command &= 0xFFFFFFFC;
1266                         pci_write_config(dev, SK_PCI_PWRMGMTCTRL, command, 4);
1267
1268                         /* Restore PCI config data. */
1269                         pci_write_config(dev, SK_PCI_LOIO, iobase, 4);
1270                         pci_write_config(dev, SK_PCI_LOMEM, membase, 4);
1271                         pci_write_config(dev, SK_PCI_INTLINE, irq, 4);
1272                 }
1273         }
1274
1275         /*
1276          * Map control/status registers.
1277          */
1278         command = pci_read_config(dev, PCIR_COMMAND, 4);
1279         command |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
1280         pci_write_config(dev, PCIR_COMMAND, command, 4);
1281         command = pci_read_config(dev, PCIR_COMMAND, 4);
1282
1283 #ifdef SK_USEIOSPACE
1284         if (!(command & PCIM_CMD_PORTEN)) {
1285                 printf("skc%d: failed to enable I/O ports!\n", unit);
1286                 error = ENXIO;
1287                 goto fail;
1288         }
1289 #else
1290         if (!(command & PCIM_CMD_MEMEN)) {
1291                 printf("skc%d: failed to enable memory mapping!\n", unit);
1292                 error = ENXIO;
1293                 goto fail;
1294         }
1295 #endif
1296
1297         rid = SK_RID;
1298         sc->sk_res = bus_alloc_resource(dev, SK_RES, &rid,
1299             0, ~0, 1, RF_ACTIVE);
1300
1301         if (sc->sk_res == NULL) {
1302                 printf("sk%d: couldn't map ports/memory\n", unit);
1303                 error = ENXIO;
1304                 goto fail;
1305         }
1306
1307         sc->sk_btag = rman_get_bustag(sc->sk_res);
1308         sc->sk_bhandle = rman_get_bushandle(sc->sk_res);
1309
1310         /* Allocate interrupt */
1311         rid = 0;
1312         sc->sk_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
1313             RF_SHAREABLE | RF_ACTIVE);
1314
1315         if (sc->sk_irq == NULL) {
1316                 printf("skc%d: couldn't map interrupt\n", unit);
1317                 bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1318                 error = ENXIO;
1319                 goto fail;
1320         }
1321
1322         error = bus_setup_intr(dev, sc->sk_irq, INTR_TYPE_NET,
1323             sk_intr, sc, &sc->sk_intrhand);
1324
1325         if (error) {
1326                 printf("skc%d: couldn't set up irq\n", unit);
1327                 bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1328                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sk_irq);
1329                 goto fail;
1330         }
1331
1332         /* Reset the adapter. */
1333         sk_reset(sc);
1334
1335         sc->sk_unit = unit;
1336
1337         /* Read and save vital product data from EEPROM. */
1338         sk_vpd_read(sc);
1339
1340         /* Read and save RAM size and RAMbuffer offset */
1341         switch(sk_win_read_1(sc, SK_EPROM0)) {
1342         case SK_RAMSIZE_512K_64:
1343                 sc->sk_ramsize = 0x80000;
1344                 sc->sk_rboff = SK_RBOFF_0;
1345                 break;
1346         case SK_RAMSIZE_1024K_64:
1347                 sc->sk_ramsize = 0x100000;
1348                 sc->sk_rboff = SK_RBOFF_80000;
1349                 break;
1350         case SK_RAMSIZE_1024K_128:
1351                 sc->sk_ramsize = 0x100000;
1352                 sc->sk_rboff = SK_RBOFF_0;
1353                 break;
1354         case SK_RAMSIZE_2048K_128:
1355                 sc->sk_ramsize = 0x200000;
1356                 sc->sk_rboff = SK_RBOFF_0;
1357                 break;
1358         default:
1359                 printf("skc%d: unknown ram size: %d\n",
1360                     sc->sk_unit, sk_win_read_1(sc, SK_EPROM0));
1361                 bus_teardown_intr(dev, sc->sk_irq, sc->sk_intrhand);
1362                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sk_irq);
1363                 bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1364                 error = ENXIO;
1365                 goto fail;
1366                 break;
1367         }
1368
1369         /* Read and save physical media type */
1370         switch(sk_win_read_1(sc, SK_PMDTYPE)) {
1371         case SK_PMD_1000BASESX:
1372                 sc->sk_pmd = IFM_1000_SX;
1373                 break;
1374         case SK_PMD_1000BASELX:
1375                 sc->sk_pmd = IFM_1000_LX;
1376                 break;
1377         case SK_PMD_1000BASECX:
1378                 sc->sk_pmd = IFM_1000_CX;
1379                 break;
1380         case SK_PMD_1000BASETX:
1381                 sc->sk_pmd = IFM_1000_TX;
1382                 break;
1383         default:
1384                 printf("skc%d: unknown media type: 0x%x\n",
1385                     sc->sk_unit, sk_win_read_1(sc, SK_PMDTYPE));
1386                 bus_teardown_intr(dev, sc->sk_irq, sc->sk_intrhand);
1387                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sk_irq);
1388                 bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1389                 error = ENXIO;
1390                 goto fail;
1391         }
1392
1393         /* Announce the product name. */
1394         printf("skc%d: %s\n", sc->sk_unit, sc->sk_vpd_prodname);
1395         sc->sk_devs[SK_PORT_A] = device_add_child(dev, "sk", -1);
1396         port = malloc(sizeof(int), M_DEVBUF, M_NOWAIT);
1397         *port = SK_PORT_A;
1398         device_set_ivars(sc->sk_devs[SK_PORT_A], port);
1399
1400         if (!(sk_win_read_1(sc, SK_CONFIG) & SK_CONFIG_SINGLEMAC)) {
1401                 sc->sk_devs[SK_PORT_B] = device_add_child(dev, "sk", -1);
1402                 port = malloc(sizeof(int), M_DEVBUF, M_NOWAIT);
1403                 *port = SK_PORT_B;
1404                 device_set_ivars(sc->sk_devs[SK_PORT_B], port);
1405         }
1406
1407         /* Turn on the 'driver is loaded' LED. */
1408         CSR_WRITE_2(sc, SK_LED, SK_LED_GREEN_ON);
1409
1410         bus_generic_attach(dev);
1411
1412 fail:
1413         splx(s);
1414         return(error);
1415 }
1416
1417 static int sk_detach_xmac(dev)
1418         device_t                dev;
1419 {
1420         struct sk_softc         *sc;
1421         struct sk_if_softc      *sc_if;
1422         struct ifnet            *ifp;
1423         int                     s;
1424
1425         s = splimp();
1426
1427         sc = device_get_softc(device_get_parent(dev));
1428         sc_if = device_get_softc(dev);
1429         ifp = &sc_if->arpcom.ac_if;
1430         sk_stop(sc_if);
1431         ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
1432         bus_generic_detach(dev);
1433         if (sc_if->sk_miibus != NULL)
1434                 device_delete_child(dev, sc_if->sk_miibus);
1435         contigfree(sc_if->sk_cdata.sk_jumbo_buf, SK_JMEM, M_DEVBUF);
1436         contigfree(sc_if->sk_rdata, sizeof(struct sk_ring_data), M_DEVBUF);
1437
1438         return(0);
1439 }
1440
1441 static int sk_detach(dev)
1442         device_t                dev;
1443 {
1444         struct sk_softc         *sc;
1445         int                     s;
1446
1447         s = splimp();
1448
1449         sc = device_get_softc(dev);
1450
1451         bus_generic_detach(dev);
1452         if (sc->sk_devs[SK_PORT_A] != NULL)
1453                 device_delete_child(dev, sc->sk_devs[SK_PORT_A]);
1454         if (sc->sk_devs[SK_PORT_B] != NULL)
1455                 device_delete_child(dev, sc->sk_devs[SK_PORT_B]);
1456
1457         bus_teardown_intr(dev, sc->sk_irq, sc->sk_intrhand);
1458         bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sk_irq);
1459         bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1460
1461         splx(s);
1462
1463         return(0);
1464 }
1465
1466 static int sk_encap(sc_if, m_head, txidx)
1467         struct sk_if_softc      *sc_if;
1468         struct mbuf             *m_head;
1469         u_int32_t               *txidx;
1470 {
1471         struct sk_tx_desc       *f = NULL;
1472         struct mbuf             *m;
1473         u_int32_t               frag, cur, cnt = 0;
1474
1475         m = m_head;
1476         cur = frag = *txidx;
1477
1478         /*
1479          * Start packing the mbufs in this chain into
1480          * the fragment pointers. Stop when we run out
1481          * of fragments or hit the end of the mbuf chain.
1482          */
1483         for (m = m_head; m != NULL; m = m->m_next) {
1484                 if (m->m_len != 0) {
1485                         if ((SK_TX_RING_CNT -
1486                             (sc_if->sk_cdata.sk_tx_cnt + cnt)) < 2)
1487                                 return(ENOBUFS);
1488                         f = &sc_if->sk_rdata->sk_tx_ring[frag];
1489                         f->sk_data_lo = vtophys(mtod(m, vm_offset_t));
1490                         f->sk_ctl = m->m_len | SK_OPCODE_DEFAULT;
1491                         if (cnt == 0)
1492                                 f->sk_ctl |= SK_TXCTL_FIRSTFRAG;
1493                         else
1494                                 f->sk_ctl |= SK_TXCTL_OWN;
1495                         cur = frag;
1496                         SK_INC(frag, SK_TX_RING_CNT);
1497                         cnt++;
1498                 }
1499         }
1500
1501         if (m != NULL)
1502                 return(ENOBUFS);
1503
1504         sc_if->sk_rdata->sk_tx_ring[cur].sk_ctl |=
1505                 SK_TXCTL_LASTFRAG|SK_TXCTL_EOF_INTR;
1506         sc_if->sk_cdata.sk_tx_chain[cur].sk_mbuf = m_head;
1507         sc_if->sk_rdata->sk_tx_ring[*txidx].sk_ctl |= SK_TXCTL_OWN;
1508         sc_if->sk_cdata.sk_tx_cnt += cnt;
1509
1510         *txidx = frag;
1511
1512         return(0);
1513 }
1514
1515 static void sk_start(ifp)
1516         struct ifnet            *ifp;
1517 {
1518         struct sk_softc         *sc;
1519         struct sk_if_softc      *sc_if;
1520         struct mbuf             *m_head = NULL;
1521         u_int32_t               idx;
1522
1523         sc_if = ifp->if_softc;
1524         sc = sc_if->sk_softc;
1525
1526         idx = sc_if->sk_cdata.sk_tx_prod;
1527
1528         while(sc_if->sk_cdata.sk_tx_chain[idx].sk_mbuf == NULL) {
1529                 IF_DEQUEUE(&ifp->if_snd, m_head);
1530                 if (m_head == NULL)
1531                         break;
1532
1533                 /*
1534                  * Pack the data into the transmit ring. If we
1535                  * don't have room, set the OACTIVE flag and wait
1536                  * for the NIC to drain the ring.
1537                  */
1538                 if (sk_encap(sc_if, m_head, &idx)) {
1539                         IF_PREPEND(&ifp->if_snd, m_head);
1540                         ifp->if_flags |= IFF_OACTIVE;
1541                         break;
1542                 }
1543
1544                 /*
1545                  * If there's a BPF listener, bounce a copy of this frame
1546                  * to him.
1547                  */
1548                 if (ifp->if_bpf)
1549                         bpf_mtap(ifp, m_head);
1550         }
1551
1552         /* Transmit */
1553         sc_if->sk_cdata.sk_tx_prod = idx;
1554         CSR_WRITE_4(sc, sc_if->sk_tx_bmu, SK_TXBMU_TX_START);
1555
1556         /* Set a timeout in case the chip goes out to lunch. */
1557         ifp->if_timer = 5;
1558
1559         return;
1560 }
1561
1562
1563 static void sk_watchdog(ifp)
1564         struct ifnet            *ifp;
1565 {
1566         struct sk_if_softc      *sc_if;
1567
1568         sc_if = ifp->if_softc;
1569
1570         printf("sk%d: watchdog timeout\n", sc_if->sk_unit);
1571         sk_init(sc_if);
1572
1573         return;
1574 }
1575
1576 static void sk_shutdown(dev)
1577         device_t                dev;
1578 {
1579         struct sk_softc         *sc;
1580
1581         sc = device_get_softc(dev);
1582
1583         /* Turn off the 'driver is loaded' LED. */
1584         CSR_WRITE_2(sc, SK_LED, SK_LED_GREEN_OFF);
1585
1586         /*
1587          * Reset the GEnesis controller. Doing this should also
1588          * assert the resets on the attached XMAC(s).
1589          */
1590         sk_reset(sc);
1591
1592         return;
1593 }
1594
1595 static void sk_rxeof(sc_if)
1596         struct sk_if_softc      *sc_if;
1597 {
1598         struct ether_header     *eh;
1599         struct mbuf             *m;
1600         struct ifnet            *ifp;
1601         struct sk_chain         *cur_rx;
1602         int                     total_len = 0;
1603         int                     i;
1604         u_int32_t               rxstat;
1605
1606         ifp = &sc_if->arpcom.ac_if;
1607         i = sc_if->sk_cdata.sk_rx_prod;
1608         cur_rx = &sc_if->sk_cdata.sk_rx_chain[i];
1609
1610         while(!(sc_if->sk_rdata->sk_rx_ring[i].sk_ctl & SK_RXCTL_OWN)) {
1611
1612                 cur_rx = &sc_if->sk_cdata.sk_rx_chain[i];
1613                 rxstat = sc_if->sk_rdata->sk_rx_ring[i].sk_xmac_rxstat;
1614                 m = cur_rx->sk_mbuf;
1615                 cur_rx->sk_mbuf = NULL;
1616                 total_len = SK_RXBYTES(sc_if->sk_rdata->sk_rx_ring[i].sk_ctl);
1617                 SK_INC(i, SK_RX_RING_CNT);
1618
1619                 if (rxstat & XM_RXSTAT_ERRFRAME) {
1620                         ifp->if_ierrors++;
1621                         sk_newbuf(sc_if, cur_rx, m);
1622                         continue;
1623                 }
1624
1625                 /*
1626                  * Try to allocate a new jumbo buffer. If that
1627                  * fails, copy the packet to mbufs and put the
1628                  * jumbo buffer back in the ring so it can be
1629                  * re-used. If allocating mbufs fails, then we
1630                  * have to drop the packet.
1631                  */
1632                 if (sk_newbuf(sc_if, cur_rx, NULL) == ENOBUFS) {
1633                         struct mbuf             *m0;
1634                         m0 = m_devget(mtod(m, char *) - ETHER_ALIGN,
1635                             total_len + ETHER_ALIGN, 0, ifp, NULL);
1636                         sk_newbuf(sc_if, cur_rx, m);
1637                         if (m0 == NULL) {
1638                                 printf("sk%d: no receive buffers "
1639                                     "available -- packet dropped!\n",
1640                                     sc_if->sk_unit);
1641                                 ifp->if_ierrors++;
1642                                 continue;
1643                         }
1644                         m_adj(m0, ETHER_ALIGN);
1645                         m = m0;
1646                 } else {
1647                         m->m_pkthdr.rcvif = ifp;
1648                         m->m_pkthdr.len = m->m_len = total_len;
1649                 }
1650
1651                 ifp->if_ipackets++;
1652                 eh = mtod(m, struct ether_header *);
1653
1654                 /* Remove header from mbuf and pass it on. */
1655                 m_adj(m, sizeof(struct ether_header));
1656                 ether_input(ifp, eh, m);
1657         }
1658
1659         sc_if->sk_cdata.sk_rx_prod = i;
1660
1661         return;
1662 }
1663
1664 static void sk_txeof(sc_if)
1665         struct sk_if_softc      *sc_if;
1666 {
1667         struct sk_tx_desc       *cur_tx = NULL;
1668         struct ifnet            *ifp;
1669         u_int32_t               idx;
1670
1671         ifp = &sc_if->arpcom.ac_if;
1672
1673         /*
1674          * Go through our tx ring and free mbufs for those
1675          * frames that have been sent.
1676          */
1677         idx = sc_if->sk_cdata.sk_tx_cons;
1678         while(idx != sc_if->sk_cdata.sk_tx_prod) {
1679                 cur_tx = &sc_if->sk_rdata->sk_tx_ring[idx];
1680                 if (cur_tx->sk_ctl & SK_TXCTL_OWN)
1681                         break;
1682                 if (cur_tx->sk_ctl & SK_TXCTL_LASTFRAG)
1683                         ifp->if_opackets++;
1684                 if (sc_if->sk_cdata.sk_tx_chain[idx].sk_mbuf != NULL) {
1685                         m_freem(sc_if->sk_cdata.sk_tx_chain[idx].sk_mbuf);
1686                         sc_if->sk_cdata.sk_tx_chain[idx].sk_mbuf = NULL;
1687                 }
1688                 sc_if->sk_cdata.sk_tx_cnt--;
1689                 SK_INC(idx, SK_TX_RING_CNT);
1690                 ifp->if_timer = 0;
1691         }
1692
1693         sc_if->sk_cdata.sk_tx_cons = idx;
1694
1695         if (cur_tx != NULL)
1696                 ifp->if_flags &= ~IFF_OACTIVE;
1697
1698         return;
1699 }
1700
1701 static void sk_tick(xsc_if)
1702         void                    *xsc_if;
1703 {
1704         struct sk_if_softc      *sc_if;
1705         struct mii_data         *mii;
1706         struct ifnet            *ifp;
1707         int                     i;
1708
1709         sc_if = xsc_if;
1710         ifp = &sc_if->arpcom.ac_if;
1711         mii = device_get_softc(sc_if->sk_miibus);
1712
1713         if (!(ifp->if_flags & IFF_UP))
1714                 return;
1715
1716         if (sc_if->sk_phytype == SK_PHYTYPE_BCOM) {
1717                 sk_intr_bcom(sc_if);
1718                 return;
1719         }
1720
1721         /*
1722          * According to SysKonnect, the correct way to verify that
1723          * the link has come back up is to poll bit 0 of the GPIO
1724          * register three times. This pin has the signal from the
1725          * link_sync pin connected to it; if we read the same link
1726          * state 3 times in a row, we know the link is up.
1727          */
1728         for (i = 0; i < 3; i++) {
1729                 if (SK_XM_READ_2(sc_if, XM_GPIO) & XM_GPIO_GP0_SET)
1730                         break;
1731         }
1732
1733         if (i != 3) {
1734                 sc_if->sk_tick_ch = timeout(sk_tick, sc_if, hz);
1735                 return;
1736         }
1737
1738         /* Turn the GP0 interrupt back on. */
1739         SK_XM_CLRBIT_2(sc_if, XM_IMR, XM_IMR_GP0_SET);
1740         SK_XM_READ_2(sc_if, XM_ISR);
1741         mii_tick(mii);
1742         mii_pollstat(mii);
1743         untimeout(sk_tick, sc_if, sc_if->sk_tick_ch);
1744
1745         return;
1746 }
1747
1748 static void sk_intr_bcom(sc_if)
1749         struct sk_if_softc      *sc_if;
1750 {
1751         struct sk_softc         *sc;
1752         struct mii_data         *mii;
1753         struct ifnet            *ifp;
1754         int                     status;
1755
1756         sc = sc_if->sk_softc;
1757         mii = device_get_softc(sc_if->sk_miibus);
1758         ifp = &sc_if->arpcom.ac_if;
1759
1760         SK_XM_CLRBIT_2(sc_if, XM_MMUCMD, XM_MMUCMD_TX_ENB|XM_MMUCMD_RX_ENB);
1761
1762         /*
1763          * Read the PHY interrupt register to make sure
1764          * we clear any pending interrupts.
1765          */
1766         status = sk_miibus_readreg(sc_if->sk_dev,
1767             SK_PHYADDR_BCOM, BRGPHY_MII_ISR);
1768
1769         if (!(ifp->if_flags & IFF_RUNNING)) {
1770                 sk_init_xmac(sc_if);
1771                 return;
1772         }
1773
1774         if (status & (BRGPHY_ISR_LNK_CHG|BRGPHY_ISR_AN_PR)) {
1775                 int                     lstat;
1776                 lstat = sk_miibus_readreg(sc_if->sk_dev,
1777                     SK_PHYADDR_BCOM, BRGPHY_MII_AUXSTS);
1778
1779                 if (!(lstat & BRGPHY_AUXSTS_LINK) && sc_if->sk_link) {
1780                         mii_mediachg(mii);
1781                         /* Turn off the link LED. */
1782                         SK_IF_WRITE_1(sc_if, 0,
1783                             SK_LINKLED1_CTL, SK_LINKLED_OFF);
1784                         sc_if->sk_link = 0;
1785                 } else if (status & BRGPHY_ISR_LNK_CHG) {
1786                         sk_miibus_writereg(sc_if->sk_dev, SK_PHYADDR_BCOM,
1787                             BRGPHY_MII_IMR, 0xFF00);
1788                         mii_tick(mii);
1789                         sc_if->sk_link = 1;
1790                         /* Turn on the link LED. */
1791                         SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL,
1792                             SK_LINKLED_ON|SK_LINKLED_LINKSYNC_OFF|
1793                             SK_LINKLED_BLINK_OFF);
1794                         mii_pollstat(mii);
1795                 } else {
1796                         mii_tick(mii);
1797                         sc_if->sk_tick_ch = timeout(sk_tick, sc_if, hz);
1798                 }
1799         }
1800
1801         SK_XM_SETBIT_2(sc_if, XM_MMUCMD, XM_MMUCMD_TX_ENB|XM_MMUCMD_RX_ENB);
1802
1803         return;
1804 }
1805
1806 static void sk_intr_xmac(sc_if)
1807         struct sk_if_softc      *sc_if;
1808 {
1809         struct sk_softc         *sc;
1810         u_int16_t               status;
1811         struct mii_data         *mii;
1812
1813         sc = sc_if->sk_softc;
1814         mii = device_get_softc(sc_if->sk_miibus);
1815         status = SK_XM_READ_2(sc_if, XM_ISR);
1816
1817         /*
1818          * Link has gone down. Start MII tick timeout to
1819          * watch for link resync.
1820          */
1821         if (sc_if->sk_phytype == SK_PHYTYPE_XMAC) {
1822                 if (status & XM_ISR_GP0_SET) {
1823                         SK_XM_SETBIT_2(sc_if, XM_IMR, XM_IMR_GP0_SET);
1824                         sc_if->sk_tick_ch = timeout(sk_tick, sc_if, hz);
1825                 }
1826
1827                 if (status & XM_ISR_AUTONEG_DONE) {
1828                         sc_if->sk_tick_ch = timeout(sk_tick, sc_if, hz);
1829                 }
1830         }
1831
1832         if (status & XM_IMR_TX_UNDERRUN)
1833                 SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_FLUSH_TXFIFO);
1834
1835         if (status & XM_IMR_RX_OVERRUN)
1836                 SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_FLUSH_RXFIFO);
1837
1838         status = SK_XM_READ_2(sc_if, XM_ISR);
1839
1840         return;
1841 }
1842
1843 static void sk_intr(xsc)
1844         void                    *xsc;
1845 {
1846         struct sk_softc         *sc = xsc;
1847         struct sk_if_softc      *sc_if0 = NULL, *sc_if1 = NULL;
1848         struct ifnet            *ifp0 = NULL, *ifp1 = NULL;
1849         u_int32_t               status;
1850
1851         sc_if0 = sc->sk_if[SK_PORT_A];
1852         sc_if1 = sc->sk_if[SK_PORT_B];
1853
1854         if (sc_if0 != NULL)
1855                 ifp0 = &sc_if0->arpcom.ac_if;
1856         if (sc_if1 != NULL)
1857                 ifp1 = &sc_if1->arpcom.ac_if;
1858
1859         for (;;) {
1860                 status = CSR_READ_4(sc, SK_ISSR);
1861                 if (!(status & sc->sk_intrmask))
1862                         break;
1863
1864                 /* Handle receive interrupts first. */
1865                 if (status & SK_ISR_RX1_EOF) {
1866                         sk_rxeof(sc_if0);
1867                         CSR_WRITE_4(sc, SK_BMU_RX_CSR0,
1868                             SK_RXBMU_CLR_IRQ_EOF|SK_RXBMU_RX_START);
1869                 }
1870                 if (status & SK_ISR_RX2_EOF) {
1871                         sk_rxeof(sc_if1);
1872                         CSR_WRITE_4(sc, SK_BMU_RX_CSR1,
1873                             SK_RXBMU_CLR_IRQ_EOF|SK_RXBMU_RX_START);
1874                 }
1875
1876                 /* Then transmit interrupts. */
1877                 if (status & SK_ISR_TX1_S_EOF) {
1878                         sk_txeof(sc_if0);
1879                         CSR_WRITE_4(sc, SK_BMU_TXS_CSR0,
1880                             SK_TXBMU_CLR_IRQ_EOF);
1881                 }
1882                 if (status & SK_ISR_TX2_S_EOF) {
1883                         sk_txeof(sc_if1);
1884                         CSR_WRITE_4(sc, SK_BMU_TXS_CSR1,
1885                             SK_TXBMU_CLR_IRQ_EOF);
1886                 }
1887
1888                 /* Then MAC interrupts. */
1889                 if (status & SK_ISR_MAC1 &&
1890                     ifp0->if_flags & IFF_RUNNING)
1891                         sk_intr_xmac(sc_if0);
1892
1893                 if (status & SK_ISR_MAC2 &&
1894                     ifp1->if_flags & IFF_RUNNING)
1895                         sk_intr_xmac(sc_if1);
1896
1897                 if (status & SK_ISR_EXTERNAL_REG) {
1898                         if (ifp0 != NULL)
1899                                 sk_intr_bcom(sc_if0);
1900                         if (ifp1 != NULL)
1901                                 sk_intr_bcom(sc_if1);
1902                 }
1903         }
1904
1905         CSR_WRITE_4(sc, SK_IMR, sc->sk_intrmask);
1906
1907         if (ifp0 != NULL && ifp0->if_snd.ifq_head != NULL)
1908                 sk_start(ifp0);
1909         if (ifp1 != NULL && ifp1->if_snd.ifq_head != NULL)
1910                 sk_start(ifp1);
1911
1912         return;
1913 }
1914
1915 static void sk_init_xmac(sc_if)
1916         struct sk_if_softc      *sc_if;
1917 {
1918         struct sk_softc         *sc;
1919         struct ifnet            *ifp;
1920         struct sk_bcom_hack     bhack[] = {
1921         { 0x18, 0x0c20 }, { 0x17, 0x0012 }, { 0x15, 0x1104 }, { 0x17, 0x0013 },
1922         { 0x15, 0x0404 }, { 0x17, 0x8006 }, { 0x15, 0x0132 }, { 0x17, 0x8006 },
1923         { 0x15, 0x0232 }, { 0x17, 0x800D }, { 0x15, 0x000F }, { 0x18, 0x0420 },
1924         { 0, 0 } };
1925
1926         sc = sc_if->sk_softc;
1927         ifp = &sc_if->arpcom.ac_if;
1928
1929         /* Unreset the XMAC. */
1930         SK_IF_WRITE_2(sc_if, 0, SK_TXF1_MACCTL, SK_TXMACCTL_XMAC_UNRESET);
1931         DELAY(1000);
1932
1933         /* Reset the XMAC's internal state. */
1934         SK_XM_SETBIT_2(sc_if, XM_GPIO, XM_GPIO_RESETMAC);
1935
1936         /* Save the XMAC II revision */
1937         sc_if->sk_xmac_rev = XM_XMAC_REV(SK_XM_READ_4(sc_if, XM_DEVID));
1938
1939         /*
1940          * Perform additional initialization for external PHYs,
1941          * namely for the 1000baseTX cards that use the XMAC's
1942          * GMII mode.
1943          */
1944         if (sc_if->sk_phytype == SK_PHYTYPE_BCOM) {
1945                 int                     i = 0;
1946                 u_int32_t               val;
1947
1948                 /* Take PHY out of reset. */
1949                 val = sk_win_read_4(sc, SK_GPIO);
1950                 if (sc_if->sk_port == SK_PORT_A)
1951                         val |= SK_GPIO_DIR0|SK_GPIO_DAT0;
1952                 else
1953                         val |= SK_GPIO_DIR2|SK_GPIO_DAT2;
1954                 sk_win_write_4(sc, SK_GPIO, val);
1955
1956                 /* Enable GMII mode on the XMAC. */
1957                 SK_XM_SETBIT_2(sc_if, XM_HWCFG, XM_HWCFG_GMIIMODE);
1958
1959                 sk_miibus_writereg(sc_if->sk_dev, SK_PHYADDR_BCOM,
1960                     BRGPHY_MII_BMCR, BRGPHY_BMCR_RESET);
1961                 DELAY(10000);
1962                 sk_miibus_writereg(sc_if->sk_dev, SK_PHYADDR_BCOM,
1963                     BRGPHY_MII_IMR, 0xFFF0);
1964
1965                 /*
1966                  * Early versions of the BCM5400 apparently have
1967                  * a bug that requires them to have their reserved
1968                  * registers initialized to some magic values. I don't
1969                  * know what the numbers do, I'm just the messenger.
1970                  */
1971                 if (sk_miibus_readreg(sc_if->sk_dev,
1972                     SK_PHYADDR_BCOM, 0x03) == 0x6041) {
1973                         while(bhack[i].reg) {
1974                                 sk_miibus_writereg(sc_if->sk_dev,
1975                                     SK_PHYADDR_BCOM, bhack[i].reg,
1976                                     bhack[i].val);
1977                                 i++;
1978                         }
1979                 }
1980         }
1981
1982         /* Set station address */
1983         SK_XM_WRITE_2(sc_if, XM_PAR0,
1984             *(u_int16_t *)(&sc_if->arpcom.ac_enaddr[0]));
1985         SK_XM_WRITE_2(sc_if, XM_PAR1,
1986             *(u_int16_t *)(&sc_if->arpcom.ac_enaddr[2]));
1987         SK_XM_WRITE_2(sc_if, XM_PAR2,
1988             *(u_int16_t *)(&sc_if->arpcom.ac_enaddr[4]));
1989         SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_USE_STATION);
1990
1991         if (ifp->if_flags & IFF_PROMISC) {
1992                 SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_PROMISC);
1993         } else {
1994                 SK_XM_CLRBIT_4(sc_if, XM_MODE, XM_MODE_RX_PROMISC);
1995         }
1996
1997         if (ifp->if_flags & IFF_BROADCAST) {
1998                 SK_XM_CLRBIT_4(sc_if, XM_MODE, XM_MODE_RX_NOBROAD);
1999         } else {
2000                 SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_NOBROAD);
2001         }
2002
2003         /* We don't need the FCS appended to the packet. */
2004         SK_XM_SETBIT_2(sc_if, XM_RXCMD, XM_RXCMD_STRIPFCS);
2005
2006         /* We want short frames padded to 60 bytes. */
2007         SK_XM_SETBIT_2(sc_if, XM_TXCMD, XM_TXCMD_AUTOPAD);
2008
2009         /*
2010          * Enable the reception of all error frames. This is is
2011          * a necessary evil due to the design of the XMAC. The
2012          * XMAC's receive FIFO is only 8K in size, however jumbo
2013          * frames can be up to 9000 bytes in length. When bad
2014          * frame filtering is enabled, the XMAC's RX FIFO operates
2015          * in 'store and forward' mode. For this to work, the
2016          * entire frame has to fit into the FIFO, but that means
2017          * that jumbo frames larger than 8192 bytes will be
2018          * truncated. Disabling all bad frame filtering causes
2019          * the RX FIFO to operate in streaming mode, in which
2020          * case the XMAC will start transfering frames out of the
2021          * RX FIFO as soon as the FIFO threshold is reached.
2022          */
2023         SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_BADFRAMES|
2024             XM_MODE_RX_GIANTS|XM_MODE_RX_RUNTS|XM_MODE_RX_CRCERRS|
2025             XM_MODE_RX_INRANGELEN);
2026
2027         if (ifp->if_mtu > (ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN))
2028                 SK_XM_SETBIT_2(sc_if, XM_RXCMD, XM_RXCMD_BIGPKTOK);
2029         else
2030                 SK_XM_CLRBIT_2(sc_if, XM_RXCMD, XM_RXCMD_BIGPKTOK);
2031
2032         /*
2033          * Bump up the transmit threshold. This helps hold off transmit
2034          * underruns when we're blasting traffic from both ports at once.
2035          */
2036         SK_XM_WRITE_2(sc_if, XM_TX_REQTHRESH, SK_XM_TX_FIFOTHRESH);
2037
2038         /* Set multicast filter */
2039         sk_setmulti(sc_if);
2040
2041         /* Clear and enable interrupts */
2042         SK_XM_READ_2(sc_if, XM_ISR);
2043         if (sc_if->sk_phytype == SK_PHYTYPE_XMAC)
2044                 SK_XM_WRITE_2(sc_if, XM_IMR, XM_INTRS);
2045         else
2046                 SK_XM_WRITE_2(sc_if, XM_IMR, 0xFFFF);
2047
2048         /* Configure MAC arbiter */
2049         switch(sc_if->sk_xmac_rev) {
2050         case XM_XMAC_REV_B2:
2051                 sk_win_write_1(sc, SK_RCINIT_RX1, SK_RCINIT_XMAC_B2);
2052                 sk_win_write_1(sc, SK_RCINIT_TX1, SK_RCINIT_XMAC_B2);
2053                 sk_win_write_1(sc, SK_RCINIT_RX2, SK_RCINIT_XMAC_B2);
2054                 sk_win_write_1(sc, SK_RCINIT_TX2, SK_RCINIT_XMAC_B2);
2055                 sk_win_write_1(sc, SK_MINIT_RX1, SK_MINIT_XMAC_B2);
2056                 sk_win_write_1(sc, SK_MINIT_TX1, SK_MINIT_XMAC_B2);
2057                 sk_win_write_1(sc, SK_MINIT_RX2, SK_MINIT_XMAC_B2);
2058                 sk_win_write_1(sc, SK_MINIT_TX2, SK_MINIT_XMAC_B2);
2059                 sk_win_write_1(sc, SK_RECOVERY_CTL, SK_RECOVERY_XMAC_B2);
2060                 break;
2061         case XM_XMAC_REV_C1:
2062                 sk_win_write_1(sc, SK_RCINIT_RX1, SK_RCINIT_XMAC_C1);
2063                 sk_win_write_1(sc, SK_RCINIT_TX1, SK_RCINIT_XMAC_C1);
2064                 sk_win_write_1(sc, SK_RCINIT_RX2, SK_RCINIT_XMAC_C1);
2065                 sk_win_write_1(sc, SK_RCINIT_TX2, SK_RCINIT_XMAC_C1);
2066                 sk_win_write_1(sc, SK_MINIT_RX1, SK_MINIT_XMAC_C1);
2067                 sk_win_write_1(sc, SK_MINIT_TX1, SK_MINIT_XMAC_C1);
2068                 sk_win_write_1(sc, SK_MINIT_RX2, SK_MINIT_XMAC_C1);
2069                 sk_win_write_1(sc, SK_MINIT_TX2, SK_MINIT_XMAC_C1);
2070                 sk_win_write_1(sc, SK_RECOVERY_CTL, SK_RECOVERY_XMAC_B2);
2071                 break;
2072         default:
2073                 break;
2074         }
2075         sk_win_write_2(sc, SK_MACARB_CTL,
2076             SK_MACARBCTL_UNRESET|SK_MACARBCTL_FASTOE_OFF);
2077
2078         sc_if->sk_link = 1;
2079
2080         return;
2081 }
2082
2083 /*
2084  * Note that to properly initialize any part of the GEnesis chip,
2085  * you first have to take it out of reset mode.
2086  */
2087 static void sk_init(xsc)
2088         void                    *xsc;
2089 {
2090         struct sk_if_softc      *sc_if = xsc;
2091         struct sk_softc         *sc;
2092         struct ifnet            *ifp;
2093         struct mii_data         *mii;
2094         int                     s;
2095
2096         s = splimp();
2097
2098         ifp = &sc_if->arpcom.ac_if;
2099         sc = sc_if->sk_softc;
2100         mii = device_get_softc(sc_if->sk_miibus);
2101
2102         /* Cancel pending I/O and free all RX/TX buffers. */
2103         sk_stop(sc_if);
2104
2105         /* Configure LINK_SYNC LED */
2106         SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL, SK_LINKLED_ON);
2107         SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL, SK_LINKLED_LINKSYNC_ON);
2108
2109         /* Configure RX LED */
2110         SK_IF_WRITE_1(sc_if, 0, SK_RXLED1_CTL, SK_RXLEDCTL_COUNTER_START);
2111
2112         /* Configure TX LED */
2113         SK_IF_WRITE_1(sc_if, 0, SK_TXLED1_CTL, SK_TXLEDCTL_COUNTER_START);
2114
2115         /* Configure I2C registers */
2116
2117         /* Configure XMAC(s) */
2118         sk_init_xmac(sc_if);
2119         mii_mediachg(mii);
2120
2121         /* Configure MAC FIFOs */
2122         SK_IF_WRITE_4(sc_if, 0, SK_RXF1_CTL, SK_FIFO_UNRESET);
2123         SK_IF_WRITE_4(sc_if, 0, SK_RXF1_END, SK_FIFO_END);
2124         SK_IF_WRITE_4(sc_if, 0, SK_RXF1_CTL, SK_FIFO_ON);
2125
2126         SK_IF_WRITE_4(sc_if, 0, SK_TXF1_CTL, SK_FIFO_UNRESET);
2127         SK_IF_WRITE_4(sc_if, 0, SK_TXF1_END, SK_FIFO_END);
2128         SK_IF_WRITE_4(sc_if, 0, SK_TXF1_CTL, SK_FIFO_ON);
2129
2130         /* Configure transmit arbiter(s) */
2131         SK_IF_WRITE_1(sc_if, 0, SK_TXAR1_COUNTERCTL,
2132             SK_TXARCTL_ON|SK_TXARCTL_FSYNC_ON);
2133
2134         /* Configure RAMbuffers */
2135         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_CTLTST, SK_RBCTL_UNRESET);
2136         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_START, sc_if->sk_rx_ramstart);
2137         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_WR_PTR, sc_if->sk_rx_ramstart);
2138         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_RD_PTR, sc_if->sk_rx_ramstart);
2139         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_END, sc_if->sk_rx_ramend);
2140         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_CTLTST, SK_RBCTL_ON);
2141
2142         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_CTLTST, SK_RBCTL_UNRESET);
2143         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_CTLTST, SK_RBCTL_STORENFWD_ON);
2144         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_START, sc_if->sk_tx_ramstart);
2145         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_WR_PTR, sc_if->sk_tx_ramstart);
2146         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_RD_PTR, sc_if->sk_tx_ramstart);
2147         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_END, sc_if->sk_tx_ramend);
2148         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_CTLTST, SK_RBCTL_ON);
2149
2150         /* Configure BMUs */
2151         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_BMU_CSR, SK_RXBMU_ONLINE);
2152         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_CURADDR_LO,
2153             vtophys(&sc_if->sk_rdata->sk_rx_ring[0]));
2154         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_CURADDR_HI, 0);
2155
2156         SK_IF_WRITE_4(sc_if, 1, SK_TXQS1_BMU_CSR, SK_TXBMU_ONLINE);
2157         SK_IF_WRITE_4(sc_if, 1, SK_TXQS1_CURADDR_LO,
2158             vtophys(&sc_if->sk_rdata->sk_tx_ring[0]));
2159         SK_IF_WRITE_4(sc_if, 1, SK_TXQS1_CURADDR_HI, 0);
2160
2161         /* Init descriptors */
2162         if (sk_init_rx_ring(sc_if) == ENOBUFS) {
2163                 printf("sk%d: initialization failed: no "
2164                     "memory for rx buffers\n", sc_if->sk_unit);
2165                 sk_stop(sc_if);
2166                 (void)splx(s);
2167                 return;
2168         }
2169         sk_init_tx_ring(sc_if);
2170
2171         /* Configure interrupt handling */
2172         CSR_READ_4(sc, SK_ISSR);
2173         if (sc_if->sk_port == SK_PORT_A)
2174                 sc->sk_intrmask |= SK_INTRS1;
2175         else
2176                 sc->sk_intrmask |= SK_INTRS2;
2177
2178         sc->sk_intrmask |= SK_ISR_EXTERNAL_REG;
2179
2180         CSR_WRITE_4(sc, SK_IMR, sc->sk_intrmask);
2181
2182         /* Start BMUs. */
2183         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_BMU_CSR, SK_RXBMU_RX_START);
2184
2185         /* Enable XMACs TX and RX state machines */
2186         SK_XM_CLRBIT_2(sc_if, XM_MMUCMD, XM_MMUCMD_IGNPAUSE);
2187         SK_XM_SETBIT_2(sc_if, XM_MMUCMD, XM_MMUCMD_TX_ENB|XM_MMUCMD_RX_ENB);
2188
2189         ifp->if_flags |= IFF_RUNNING;
2190         ifp->if_flags &= ~IFF_OACTIVE;
2191
2192         splx(s);
2193
2194         return;
2195 }
2196
2197 static void sk_stop(sc_if)
2198         struct sk_if_softc      *sc_if;
2199 {
2200         int                     i;
2201         struct sk_softc         *sc;
2202         struct ifnet            *ifp;
2203
2204         sc = sc_if->sk_softc;
2205         ifp = &sc_if->arpcom.ac_if;
2206
2207         untimeout(sk_tick, sc_if, sc_if->sk_tick_ch);
2208
2209         if (sc_if->sk_phytype == SK_PHYTYPE_BCOM) {
2210                 u_int32_t               val;
2211
2212                 /* Put PHY back into reset. */
2213                 val = sk_win_read_4(sc, SK_GPIO);
2214                 if (sc_if->sk_port == SK_PORT_A) {
2215                         val |= SK_GPIO_DIR0;
2216                         val &= ~SK_GPIO_DAT0;
2217                 } else {
2218                         val |= SK_GPIO_DIR2;
2219                         val &= ~SK_GPIO_DAT2;
2220                 }
2221                 sk_win_write_4(sc, SK_GPIO, val);
2222         }
2223
2224         /* Turn off various components of this interface. */
2225         SK_XM_SETBIT_2(sc_if, XM_GPIO, XM_GPIO_RESETMAC);
2226         SK_IF_WRITE_2(sc_if, 0, SK_TXF1_MACCTL, SK_TXMACCTL_XMAC_RESET);
2227         SK_IF_WRITE_4(sc_if, 0, SK_RXF1_CTL, SK_FIFO_RESET);
2228         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_BMU_CSR, SK_RXBMU_OFFLINE);
2229         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_CTLTST, SK_RBCTL_RESET|SK_RBCTL_OFF);
2230         SK_IF_WRITE_4(sc_if, 1, SK_TXQS1_BMU_CSR, SK_TXBMU_OFFLINE);
2231         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_CTLTST, SK_RBCTL_RESET|SK_RBCTL_OFF);
2232         SK_IF_WRITE_1(sc_if, 0, SK_TXAR1_COUNTERCTL, SK_TXARCTL_OFF);
2233         SK_IF_WRITE_1(sc_if, 0, SK_RXLED1_CTL, SK_RXLEDCTL_COUNTER_STOP);
2234         SK_IF_WRITE_1(sc_if, 0, SK_TXLED1_CTL, SK_RXLEDCTL_COUNTER_STOP);
2235         SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL, SK_LINKLED_OFF);
2236         SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL, SK_LINKLED_LINKSYNC_OFF);
2237
2238         /* Disable interrupts */
2239         if (sc_if->sk_port == SK_PORT_A)
2240                 sc->sk_intrmask &= ~SK_INTRS1;
2241         else
2242                 sc->sk_intrmask &= ~SK_INTRS2;
2243         CSR_WRITE_4(sc, SK_IMR, sc->sk_intrmask);
2244
2245         SK_XM_READ_2(sc_if, XM_ISR);
2246         SK_XM_WRITE_2(sc_if, XM_IMR, 0xFFFF);
2247
2248         /* Free RX and TX mbufs still in the queues. */
2249         for (i = 0; i < SK_RX_RING_CNT; i++) {
2250                 if (sc_if->sk_cdata.sk_rx_chain[i].sk_mbuf != NULL) {
2251                         m_freem(sc_if->sk_cdata.sk_rx_chain[i].sk_mbuf);
2252                         sc_if->sk_cdata.sk_rx_chain[i].sk_mbuf = NULL;
2253                 }
2254         }
2255
2256         for (i = 0; i < SK_TX_RING_CNT; i++) {
2257                 if (sc_if->sk_cdata.sk_tx_chain[i].sk_mbuf != NULL) {
2258                         m_freem(sc_if->sk_cdata.sk_tx_chain[i].sk_mbuf);
2259                         sc_if->sk_cdata.sk_tx_chain[i].sk_mbuf = NULL;
2260                 }
2261         }
2262
2263         ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE);
2264
2265         return;
2266 }