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