Add comment that Rev.3 Linksys EG1032 is handled by re(4)
[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.47 2006/10/16 14:22:38 sephe 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                 kfree(sc->sk_vpd_prodname, M_DEVBUF);
404         if (sc->sk_vpd_readonly != NULL)
405                 kfree(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 = kmalloc(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 = kmalloc(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
618 sk_setfilt(struct sk_if_softc *sc_if, caddr_t addr, int slot)
619 {
620         int base;
621
622         base = XM_RXFILT_ENTRY(slot);
623
624         SK_XM_WRITE_2(sc_if, base, *(uint16_t *)(&addr[0]));
625         SK_XM_WRITE_2(sc_if, base + 2, *(uint16_t *)(&addr[2]));
626         SK_XM_WRITE_2(sc_if, base + 4, *(uint16_t *)(&addr[4]));
627 }
628
629 static void
630 sk_setmulti(struct sk_if_softc *sc_if)
631 {
632         struct sk_softc *sc = sc_if->sk_softc;
633         struct ifnet *ifp = &sc_if->arpcom.ac_if;
634         uint32_t hashes[2] = { 0, 0 };
635         int h, i;
636         struct ifmultiaddr *ifma;
637         uint8_t dummy[] = { 0, 0, 0, 0, 0 ,0 };
638
639         /* First, zot all the existing filters. */
640         switch(sc->sk_type) {
641         case SK_GENESIS:
642                 for (i = 1; i < XM_RXFILT_MAX; i++)
643                         sk_setfilt(sc_if, (caddr_t)&dummy, i);
644
645                 SK_XM_WRITE_4(sc_if, XM_MAR0, 0);
646                 SK_XM_WRITE_4(sc_if, XM_MAR2, 0);
647                 break;
648         case SK_YUKON:
649                 SK_YU_WRITE_2(sc_if, YUKON_MCAH1, 0);
650                 SK_YU_WRITE_2(sc_if, YUKON_MCAH2, 0);
651                 SK_YU_WRITE_2(sc_if, YUKON_MCAH3, 0);
652                 SK_YU_WRITE_2(sc_if, YUKON_MCAH4, 0);
653                 break;
654         }
655
656         /* Now program new ones. */
657         if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
658                 hashes[0] = 0xFFFFFFFF;
659                 hashes[1] = 0xFFFFFFFF;
660         } else {
661                 i = 1;
662                 /* First find the tail of the list. */
663                 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
664                         if (ifma->ifma_link.le_next == NULL)
665                                 break;
666                 }
667                 /* Now traverse the list backwards. */
668                 for (; ifma != NULL && ifma != (void *)&ifp->if_multiaddrs;
669                         ifma = (struct ifmultiaddr *)ifma->ifma_link.le_prev) {
670                         if (ifma->ifma_addr->sa_family != AF_LINK)
671                                 continue;
672                         /*
673                          * Program the first XM_RXFILT_MAX multicast groups
674                          * into the perfect filter. For all others,
675                          * use the hash table.
676                          */
677                         if (sc->sk_type == SK_GENESIS && i < XM_RXFILT_MAX) {
678                                 sk_setfilt(sc_if,
679                         LLADDR((struct sockaddr_dl *)ifma->ifma_addr), i);
680                                 i++;
681                                 continue;
682                         }
683
684                         switch(sc->sk_type) {
685                         case SK_GENESIS:
686                             h = ~ether_crc32_le(LLADDR((struct sockaddr_dl *)
687                                 ifma->ifma_addr), ETHER_ADDR_LEN) &
688                                 ((1 << HASH_BITS) -1 );
689                             if (h < 32)
690                                 hashes[0] |= (1 << h);
691                             else
692                                 hashes[1] |= (1 << (h - 32));
693                             break;
694
695                         case SK_YUKON:
696                             h = ether_crc32_be(LLADDR((struct sockaddr_dl *)
697                                 ifma->ifma_addr), ETHER_ADDR_LEN) &
698                                 ((1 << HASH_BITS) -1 );
699                             if (h < 32)
700                                 hashes[0] |= (1 << h);
701                             else
702                                 hashes[1] |= (1 << (h - 32));
703                             break;
704                         }
705                 }
706         }
707
708         switch(sc->sk_type) {
709         case SK_GENESIS:
710                 SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_USE_HASH|
711                                XM_MODE_RX_USE_PERFECT);
712                 SK_XM_WRITE_4(sc_if, XM_MAR0, hashes[0]);
713                 SK_XM_WRITE_4(sc_if, XM_MAR2, hashes[1]);
714                 break;
715         case SK_YUKON:
716                 SK_YU_WRITE_2(sc_if, YUKON_MCAH1, hashes[0] & 0xffff);
717                 SK_YU_WRITE_2(sc_if, YUKON_MCAH2, (hashes[0] >> 16) & 0xffff);
718                 SK_YU_WRITE_2(sc_if, YUKON_MCAH3, hashes[1] & 0xffff);
719                 SK_YU_WRITE_2(sc_if, YUKON_MCAH4, (hashes[1] >> 16) & 0xffff);
720                 break;
721         }
722 }
723
724 static void
725 sk_setpromisc(struct sk_if_softc *sc_if)
726 {
727         struct sk_softc *sc = sc_if->sk_softc;
728         struct ifnet *ifp = &sc_if->arpcom.ac_if;
729
730         switch(sc->sk_type) {
731         case SK_GENESIS:
732                 if (ifp->if_flags & IFF_PROMISC) {
733                         SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_PROMISC);
734                 } else {
735                         SK_XM_CLRBIT_4(sc_if, XM_MODE, XM_MODE_RX_PROMISC);
736                 }
737                 break;
738         case SK_YUKON:
739                 if (ifp->if_flags & IFF_PROMISC) {
740                         SK_YU_CLRBIT_2(sc_if, YUKON_RCR,
741                             YU_RCR_UFLEN | YU_RCR_MUFLEN);
742                 } else {
743                         SK_YU_SETBIT_2(sc_if, YUKON_RCR,
744                             YU_RCR_UFLEN | YU_RCR_MUFLEN);
745                 }
746                 break;
747         }
748 }
749
750 static int
751 sk_init_rx_ring(struct sk_if_softc *sc_if)
752 {
753         struct sk_chain_data *cd = &sc_if->sk_cdata;
754         struct sk_ring_data *rd = sc_if->sk_rdata;
755         int i;
756
757         bzero(rd->sk_rx_ring, sizeof(struct sk_rx_desc) * SK_RX_RING_CNT);
758
759         for (i = 0; i < SK_RX_RING_CNT; i++) {
760                 cd->sk_rx_chain[i].sk_desc = &rd->sk_rx_ring[i];
761                 if (sk_newbuf(sc_if, &cd->sk_rx_chain[i], NULL) == ENOBUFS)
762                         return(ENOBUFS);
763                 if (i == (SK_RX_RING_CNT - 1)) {
764                         cd->sk_rx_chain[i].sk_next =
765                             &cd->sk_rx_chain[0];
766                         rd->sk_rx_ring[i].sk_next = 
767                             vtophys(&rd->sk_rx_ring[0]);
768                 } else {
769                         cd->sk_rx_chain[i].sk_next =
770                             &cd->sk_rx_chain[i + 1];
771                         rd->sk_rx_ring[i].sk_next = 
772                             vtophys(&rd->sk_rx_ring[i + 1]);
773                 }
774         }
775
776         sc_if->sk_cdata.sk_rx_prod = 0;
777         sc_if->sk_cdata.sk_rx_cons = 0;
778
779         return(0);
780 }
781
782 static void
783 sk_init_tx_ring(struct sk_if_softc *sc_if)
784 {
785         struct sk_chain_data *cd = &sc_if->sk_cdata;
786         struct sk_ring_data *rd = sc_if->sk_rdata;
787         int i, nexti;
788
789         bzero(sc_if->sk_rdata->sk_tx_ring,
790               sizeof(struct sk_tx_desc) * SK_TX_RING_CNT);
791
792         for (i = 0; i < SK_TX_RING_CNT; i++) {
793                 nexti = (i == (SK_TX_RING_CNT - 1)) ? 0 : i + 1;
794                 cd->sk_tx_chain[i].sk_desc = &rd->sk_tx_ring[i];
795                 cd->sk_tx_chain[i].sk_next = &cd->sk_tx_chain[nexti];
796                 rd->sk_tx_ring[i].sk_next = vtophys(&rd->sk_tx_ring[nexti]);
797         }
798
799         sc_if->sk_cdata.sk_tx_prod = 0;
800         sc_if->sk_cdata.sk_tx_cons = 0;
801         sc_if->sk_cdata.sk_tx_cnt = 0;
802 }
803
804 static int
805 sk_newbuf(struct sk_if_softc *sc_if, struct sk_chain *c, struct mbuf *m)
806 {
807         struct mbuf *m_new = NULL;
808         struct sk_rx_desc *r;
809         struct sk_jslot *buf;
810
811         if (m == NULL) {
812                 MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
813                 if (m_new == NULL)
814                         return(ENOBUFS);
815
816                 /* Allocate the jumbo buffer */
817                 buf = sk_jalloc(sc_if);
818                 if (buf == NULL) {
819                         m_freem(m_new);
820 #ifdef SK_VERBOSE
821                         printf("sk%d: jumbo allocation failed "
822                             "-- packet dropped!\n", sc_if->sk_unit);
823 #endif
824                         return(ENOBUFS);
825                 }
826
827                 /* Attach the buffer to the mbuf */
828                 m_new->m_ext.ext_arg = buf;
829                 m_new->m_ext.ext_buf = buf->sk_buf;
830                 m_new->m_ext.ext_free = sk_jfree;
831                 m_new->m_ext.ext_ref = sk_jref;
832                 m_new->m_ext.ext_size = SK_JUMBO_FRAMELEN;
833
834                 m_new->m_data = m_new->m_ext.ext_buf;
835                 m_new->m_flags |= M_EXT;
836                 m_new->m_len = m_new->m_pkthdr.len = m_new->m_ext.ext_size;
837         } else {
838                 /*
839                  * We're re-using a previously allocated mbuf;
840                  * be sure to re-init pointers and lengths to
841                  * default values.
842                  */
843                 m_new = m;
844                 m_new->m_len = m_new->m_pkthdr.len = SK_JLEN;
845                 m_new->m_data = m_new->m_ext.ext_buf;
846         }
847
848         /*
849          * Adjust alignment so packet payload begins on a
850          * longword boundary. Mandatory for Alpha, useful on
851          * x86 too.
852          */
853         m_adj(m_new, ETHER_ALIGN);
854
855         r = c->sk_desc;
856         c->sk_mbuf = m_new;
857         r->sk_data_lo = vtophys(mtod(m_new, caddr_t));
858         r->sk_ctl = m_new->m_len | SK_RXSTAT;
859
860         return(0);
861 }
862
863 /*
864  * Allocate jumbo buffer storage. The SysKonnect adapters support
865  * "jumbograms" (9K frames), although SysKonnect doesn't currently
866  * use them in their drivers. In order for us to use them, we need
867  * large 9K receive buffers, however standard mbuf clusters are only
868  * 2048 bytes in size. Consequently, we need to allocate and manage
869  * our own jumbo buffer pool. Fortunately, this does not require an
870  * excessive amount of additional code.
871  */
872 static int
873 sk_alloc_jumbo_mem(struct sk_if_softc *sc_if)
874 {
875         caddr_t ptr;
876         int i;
877         struct sk_jslot *entry;
878
879         /* Grab a big chunk o' storage. */
880         sc_if->sk_cdata.sk_jumbo_buf = contigmalloc(SK_JMEM, M_DEVBUF,
881             M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);
882
883         if (sc_if->sk_cdata.sk_jumbo_buf == NULL) {
884                 printf("sk%d: no memory for jumbo buffers!\n", sc_if->sk_unit);
885                 return(ENOBUFS);
886         }
887
888         SLIST_INIT(&sc_if->sk_jfree_listhead);
889
890         /*
891          * Now divide it up into 9K pieces and save the addresses
892          * in an array. Note that we play an evil trick here by using
893          * the first few bytes in the buffer to hold the the address
894          * of the softc structure for this interface. This is because
895          * sk_jfree() needs it, but it is called by the mbuf management
896          * code which will not pass it to us explicitly.
897          */
898         ptr = sc_if->sk_cdata.sk_jumbo_buf;
899         for (i = 0; i < SK_JSLOTS; i++) {
900                 entry = &sc_if->sk_cdata.sk_jslots[i];
901                 entry->sk_sc = sc_if;
902                 entry->sk_buf = ptr;
903                 entry->sk_inuse = 0;
904                 entry->sk_slot = i;
905                 SLIST_INSERT_HEAD(&sc_if->sk_jfree_listhead, entry, jslot_link);
906                 ptr += SK_JLEN;
907         }
908
909         return(0);
910 }
911
912 /*
913  * Allocate a jumbo buffer.
914  */
915 static struct sk_jslot *
916 sk_jalloc(struct sk_if_softc *sc_if)
917 {
918         struct sk_jslot *entry;
919
920         lwkt_serialize_enter(&sc_if->sk_jslot_serializer);
921         entry = SLIST_FIRST(&sc_if->sk_jfree_listhead);
922         if (entry) {
923                 SLIST_REMOVE_HEAD(&sc_if->sk_jfree_listhead, jslot_link);
924                 entry->sk_inuse = 1;
925         } else {
926 #ifdef SK_VERBOSE
927                 printf("sk%d: no free jumbo buffers\n", sc_if->sk_unit);
928 #endif
929         }
930         lwkt_serialize_exit(&sc_if->sk_jslot_serializer);
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         atomic_add_int(&entry->sk_inuse, 1);
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         lwkt_serialize_enter(&sc->sk_jslot_serializer);
974         atomic_subtract_int(&entry->sk_inuse, 1);
975         if (entry->sk_inuse == 0)
976                 SLIST_INSERT_HEAD(&sc->sk_jfree_listhead, entry, jslot_link);
977         lwkt_serialize_exit(&sc->sk_jslot_serializer);
978 }
979
980 /*
981  * Set media options.
982  */
983 static int
984 sk_ifmedia_upd(struct ifnet *ifp)
985 {
986         struct sk_if_softc *sc_if = ifp->if_softc;
987         struct mii_data *mii;
988
989         mii = device_get_softc(sc_if->sk_miibus);
990         sk_init(sc_if);
991         mii_mediachg(mii);
992
993         return(0);
994 }
995
996 /*
997  * Report current media status.
998  */
999 static void
1000 sk_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
1001 {
1002         struct sk_if_softc *sc_if;
1003         struct mii_data *mii;
1004
1005         sc_if = ifp->if_softc;
1006         mii = device_get_softc(sc_if->sk_miibus);
1007
1008         mii_pollstat(mii);
1009         ifmr->ifm_active = mii->mii_media_active;
1010         ifmr->ifm_status = mii->mii_media_status;
1011 }
1012
1013 static int
1014 sk_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr)
1015 {
1016         struct sk_if_softc *sc_if = ifp->if_softc;
1017         struct ifreq *ifr = (struct ifreq *)data;
1018         struct mii_data *mii;
1019         int error = 0;
1020
1021         crit_enter();
1022
1023         switch(command) {
1024         case SIOCSIFMTU:
1025                 if (ifr->ifr_mtu > SK_JUMBO_MTU)
1026                         error = EINVAL;
1027                 else {
1028                         ifp->if_mtu = ifr->ifr_mtu;
1029                         ifp->if_flags &= ~IFF_RUNNING;
1030                         sk_init(sc_if);
1031                 }
1032                 break;
1033         case SIOCSIFFLAGS:
1034                 if (ifp->if_flags & IFF_UP) {
1035                         if (ifp->if_flags & IFF_RUNNING) {
1036                                 if ((ifp->if_flags ^ sc_if->sk_if_flags)
1037                                     & IFF_PROMISC) {
1038                                         sk_setpromisc(sc_if);
1039                                         sk_setmulti(sc_if);
1040                                 }
1041                         } else
1042                                 sk_init(sc_if);
1043                 } else {
1044                         if (ifp->if_flags & IFF_RUNNING)
1045                                 sk_stop(sc_if);
1046                 }
1047                 sc_if->sk_if_flags = ifp->if_flags;
1048                 error = 0;
1049                 break;
1050         case SIOCADDMULTI:
1051         case SIOCDELMULTI:
1052                 sk_setmulti(sc_if);
1053                 error = 0;
1054                 break;
1055         case SIOCGIFMEDIA:
1056         case SIOCSIFMEDIA:
1057                 mii = device_get_softc(sc_if->sk_miibus);
1058                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
1059                 break;
1060         default:
1061                 error = ether_ioctl(ifp, command, data);
1062                 break;
1063         }
1064
1065         crit_exit();
1066
1067         return(error);
1068 }
1069
1070 /*
1071  * Probe for a SysKonnect GEnesis chip. Check the PCI vendor and device
1072  * IDs against our list and return a device name if we find a match.
1073  */
1074 static int
1075 skc_probe(device_t dev)
1076 {
1077         struct sk_type *t;
1078         uint16_t vendor, product;
1079
1080         lwkt_serialize_init(&sk_serializer);
1081         vendor = pci_get_vendor(dev);
1082         product = pci_get_device(dev);
1083
1084         /*
1085          * Only attach to rev.2 of the Linksys EG1032 adapter.
1086          * Rev.3 is supported by re(4).
1087          */
1088         if (vendor == VENDORID_LINKSYS &&
1089             product == DEVICEID_LINKSYS_EG1032 &&
1090             pci_get_subdevice(dev) != SUBDEVICEID_LINKSYS_EG1032_REV2)
1091                 return (ENXIO);
1092
1093         for (t = sk_devs; t->sk_name != NULL; t++) {
1094                 if (vendor == t->sk_vid && product == t->sk_did) {
1095                         device_set_desc(dev, t->sk_name);
1096                         return(0);
1097                 }
1098         }
1099
1100         return(ENXIO);
1101 }
1102
1103 /*
1104  * Force the GEnesis into reset, then bring it out of reset.
1105  */
1106 static void
1107 sk_reset(struct sk_softc *sc)
1108 {
1109         CSR_WRITE_2(sc, SK_CSR, SK_CSR_SW_RESET);
1110         CSR_WRITE_2(sc, SK_CSR, SK_CSR_MASTER_RESET);
1111         if (sc->sk_type == SK_YUKON)
1112                 CSR_WRITE_2(sc, SK_LINK_CTRL, SK_LINK_RESET_SET);
1113
1114         DELAY(1000);
1115         CSR_WRITE_2(sc, SK_CSR, SK_CSR_SW_UNRESET);
1116         DELAY(2);
1117         CSR_WRITE_2(sc, SK_CSR, SK_CSR_MASTER_UNRESET);
1118         if (sc->sk_type == SK_YUKON)
1119                 CSR_WRITE_2(sc, SK_LINK_CTRL, SK_LINK_RESET_CLEAR);
1120
1121         if (sc->sk_type == SK_GENESIS) {
1122                 /* Configure packet arbiter */
1123                 sk_win_write_2(sc, SK_PKTARB_CTL, SK_PKTARBCTL_UNRESET);
1124                 sk_win_write_2(sc, SK_RXPA1_TINIT, SK_PKTARB_TIMEOUT);
1125                 sk_win_write_2(sc, SK_TXPA1_TINIT, SK_PKTARB_TIMEOUT);
1126                 sk_win_write_2(sc, SK_RXPA2_TINIT, SK_PKTARB_TIMEOUT);
1127                 sk_win_write_2(sc, SK_TXPA2_TINIT, SK_PKTARB_TIMEOUT);
1128         }
1129
1130         /* Enable RAM interface */
1131         sk_win_write_4(sc, SK_RAMCTL, SK_RAMCTL_UNRESET);
1132
1133         /*
1134          * Configure interrupt moderation. The moderation timer
1135          * defers interrupts specified in the interrupt moderation
1136          * timer mask based on the timeout specified in the interrupt
1137          * moderation timer init register. Each bit in the timer
1138          * register represents 18.825ns, so to specify a timeout in
1139          * microseconds, we have to multiply by 54.
1140          */
1141         sk_win_write_4(sc, SK_IMTIMERINIT, SK_IM_USECS(200));
1142         sk_win_write_4(sc, SK_IMMR, SK_ISR_TX1_S_EOF|SK_ISR_TX2_S_EOF|
1143             SK_ISR_RX1_EOF|SK_ISR_RX2_EOF);
1144         sk_win_write_1(sc, SK_IMTIMERCTL, SK_IMCTL_START);
1145 }
1146
1147 static int
1148 sk_probe(device_t dev)
1149 {
1150         struct sk_softc *sc = device_get_softc(device_get_parent(dev));
1151
1152         /*
1153          * Not much to do here. We always know there will be
1154          * at least one XMAC present, and if there are two,
1155          * skc_attach() will create a second device instance
1156          * for us.
1157          */
1158         switch (sc->sk_type) {
1159         case SK_GENESIS:
1160                 device_set_desc(dev, "XaQti Corp. XMAC II");
1161                 break;
1162         case SK_YUKON:
1163                 device_set_desc(dev, "Marvell Semiconductor, Inc. Yukon");
1164                 break;
1165         }
1166
1167         return(0);
1168 }
1169
1170 /*
1171  * Each XMAC chip is attached as a separate logical IP interface.
1172  * Single port cards will have only one logical interface of course.
1173  */
1174 static int
1175 sk_attach(device_t dev)
1176 {
1177         struct sk_softc *sc = device_get_softc(device_get_parent(dev));
1178         struct sk_if_softc *sc_if = device_get_softc(dev);
1179         struct ifnet *ifp;
1180         int i, port;
1181
1182         port = *(int *)device_get_ivars(dev);
1183         kfree(device_get_ivars(dev), M_DEVBUF);
1184         device_set_ivars(dev, NULL);
1185         sc_if->sk_dev = dev;
1186         callout_init(&sc_if->sk_tick_timer);
1187         lwkt_serialize_init(&sc_if->sk_jslot_serializer);
1188
1189         sc_if->sk_dev = dev;
1190         sc_if->sk_unit = device_get_unit(dev);
1191         sc_if->sk_port = port;
1192         sc_if->sk_softc = sc;
1193         sc->sk_if[port] = sc_if;
1194         if (port == SK_PORT_A)
1195                 sc_if->sk_tx_bmu = SK_BMU_TXS_CSR0;
1196         if (port == SK_PORT_B)
1197                 sc_if->sk_tx_bmu = SK_BMU_TXS_CSR1;
1198
1199         /*
1200          * Get station address for this interface. Note that
1201          * dual port cards actually come with three station
1202          * addresses: one for each port, plus an extra. The
1203          * extra one is used by the SysKonnect driver software
1204          * as a 'virtual' station address for when both ports
1205          * are operating in failover mode. Currently we don't
1206          * use this extra address.
1207          */
1208         for (i = 0; i < ETHER_ADDR_LEN; i++)
1209                 sc_if->arpcom.ac_enaddr[i] =
1210                     sk_win_read_1(sc, SK_MAC0_0 + (port * 8) + i);
1211
1212         /*
1213          * Set up RAM buffer addresses. The NIC will have a certain
1214          * amount of SRAM on it, somewhere between 512K and 2MB. We
1215          * need to divide this up a) between the transmitter and
1216          * receiver and b) between the two XMACs, if this is a
1217          * dual port NIC. Our algotithm is to divide up the memory
1218          * evenly so that everyone gets a fair share.
1219          */
1220         if (sk_win_read_1(sc, SK_CONFIG) & SK_CONFIG_SINGLEMAC) {
1221                 uint32_t chunk, val;
1222
1223                 chunk = sc->sk_ramsize / 2;
1224                 val = sc->sk_rboff / sizeof(uint64_t);
1225                 sc_if->sk_rx_ramstart = val;
1226                 val += (chunk / sizeof(uint64_t));
1227                 sc_if->sk_rx_ramend = val - 1;
1228                 sc_if->sk_tx_ramstart = val;
1229                 val += (chunk / sizeof(uint64_t));
1230                 sc_if->sk_tx_ramend = val - 1;
1231         } else {
1232                 uint32_t chunk, val;
1233
1234                 chunk = sc->sk_ramsize / 4;
1235                 val = (sc->sk_rboff + (chunk * 2 * sc_if->sk_port)) /
1236                     sizeof(uint64_t);
1237                 sc_if->sk_rx_ramstart = val;
1238                 val += (chunk / sizeof(uint64_t));
1239                 sc_if->sk_rx_ramend = val - 1;
1240                 sc_if->sk_tx_ramstart = val;
1241                 val += (chunk / sizeof(uint64_t));
1242                 sc_if->sk_tx_ramend = val - 1;
1243         }
1244
1245         /* Read and save PHY type and set PHY address */
1246         sc_if->sk_phytype = sk_win_read_1(sc, SK_EPROM1) & 0xF;
1247         switch(sc_if->sk_phytype) {
1248         case SK_PHYTYPE_XMAC:
1249                 sc_if->sk_phyaddr = SK_PHYADDR_XMAC;
1250                 break;
1251         case SK_PHYTYPE_BCOM:
1252                 sc_if->sk_phyaddr = SK_PHYADDR_BCOM;
1253                 break;
1254         case SK_PHYTYPE_MARV_COPPER:
1255                 sc_if->sk_phyaddr = SK_PHYADDR_MARV;
1256                 break;
1257         default:
1258                 printf("skc%d: unsupported PHY type: %d\n",
1259                     sc->sk_unit, sc_if->sk_phytype);
1260                 sc->sk_if[port] = NULL;
1261                 return(ENODEV);
1262         }
1263
1264         /* Allocate the descriptor queues. */
1265         sc_if->sk_rdata = contigmalloc(sizeof(struct sk_ring_data), M_DEVBUF,
1266             M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);
1267
1268         if (sc_if->sk_rdata == NULL) {
1269                 printf("sk%d: no memory for list buffers!\n", sc_if->sk_unit);
1270                 sc->sk_if[port] = NULL;
1271                 return(ENOMEM);
1272         }
1273
1274         bzero(sc_if->sk_rdata, sizeof(struct sk_ring_data));
1275
1276         /* Try to allocate memory for jumbo buffers. */
1277         if (sk_alloc_jumbo_mem(sc_if)) {
1278                 printf("sk%d: jumbo buffer allocation failed\n",
1279                     sc_if->sk_unit);
1280                 contigfree(sc_if->sk_rdata,
1281                     sizeof(struct sk_ring_data), M_DEVBUF);
1282                 sc->sk_if[port] = NULL;
1283                 return(ENOMEM);
1284         }
1285
1286         ifp = &sc_if->arpcom.ac_if;
1287         ifp->if_softc = sc_if;
1288         if_initname(ifp, "sk", sc_if->sk_unit);
1289         ifp->if_mtu = ETHERMTU;
1290         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1291         ifp->if_ioctl = sk_ioctl;
1292         ifp->if_start = sk_start;
1293         ifp->if_watchdog = sk_watchdog;
1294         ifp->if_init = sk_init;
1295         ifp->if_baudrate = 1000000000;
1296         ifq_set_maxlen(&ifp->if_snd, SK_TX_RING_CNT - 1);
1297         ifq_set_ready(&ifp->if_snd);
1298
1299         /*
1300          * Do miibus setup.
1301          */
1302         switch (sc->sk_type) {
1303         case SK_GENESIS:
1304                 sk_init_xmac(sc_if);
1305                 break;
1306         case SK_YUKON:
1307                 sk_init_yukon(sc_if);
1308                 break;
1309         }
1310
1311         if (mii_phy_probe(dev, &sc_if->sk_miibus,
1312             sk_ifmedia_upd, sk_ifmedia_sts)) {
1313                 printf("skc%d: no PHY found!\n", sc_if->sk_unit);
1314                 contigfree(sc_if->sk_cdata.sk_jumbo_buf, SK_JMEM,
1315                     M_DEVBUF);
1316                 contigfree(sc_if->sk_rdata,
1317                     sizeof(struct sk_ring_data), M_DEVBUF);
1318                 sc->sk_if[port] = NULL;
1319                 return(ENXIO);
1320         }
1321
1322         /*
1323          * Call MI attach routine.
1324          */
1325         ether_ifattach(ifp, sc_if->arpcom.ac_enaddr, &sk_serializer);
1326         callout_init(&sc_if->sk_tick_timer);
1327
1328         return(0);
1329 }
1330
1331 /*
1332  * Attach the interface. Allocate softc structures, do ifmedia
1333  * setup and ethernet/BPF attach.
1334  */
1335 static int
1336 skc_attach(device_t dev)
1337 {
1338         struct sk_softc *sc;
1339         int error = 0, *port, rid, unit;
1340         uint32_t command;
1341         uint8_t skrs;
1342
1343         crit_enter();
1344
1345         sc = device_get_softc(dev);
1346         unit = device_get_unit(dev);
1347         switch (pci_get_device(dev)) {
1348         case DEVICEID_SK_V1:
1349                 sc->sk_type = SK_GENESIS;
1350                 break;
1351         case DEVICEID_SK_V2:
1352         case DEVICEID_3COM_3C940:
1353         case DEVICEID_LINKSYS_EG1032:
1354         case DEVICEID_DLINK_DGE530T:
1355                 sc->sk_type = SK_YUKON;
1356                 break;
1357         }
1358
1359         /*
1360          * Handle power management nonsense.
1361          */
1362         command = pci_read_config(dev, SK_PCI_CAPID, 4) & 0x000000FF;
1363         if (command == 0x01) {
1364                 command = pci_read_config(dev, SK_PCI_PWRMGMTCTRL, 4);
1365                 if (command & SK_PSTATE_MASK) {
1366                         uint32_t iobase, membase, irq;
1367
1368                         /* Save important PCI config data. */
1369                         iobase = pci_read_config(dev, SK_PCI_LOIO, 4);
1370                         membase = pci_read_config(dev, SK_PCI_LOMEM, 4);
1371                         irq = pci_read_config(dev, SK_PCI_INTLINE, 4);
1372
1373                         /* Reset the power state. */
1374                         printf("skc%d: chip is in D%d power mode "
1375                         "-- setting to D0\n", unit, command & SK_PSTATE_MASK);
1376                         command &= 0xFFFFFFFC;
1377                         pci_write_config(dev, SK_PCI_PWRMGMTCTRL, command, 4);
1378
1379                         /* Restore PCI config data. */
1380                         pci_write_config(dev, SK_PCI_LOIO, iobase, 4);
1381                         pci_write_config(dev, SK_PCI_LOMEM, membase, 4);
1382                         pci_write_config(dev, SK_PCI_INTLINE, irq, 4);
1383                 }
1384         }
1385
1386         /*
1387          * Map control/status registers.
1388          */
1389         command = pci_read_config(dev, PCIR_COMMAND, 4);
1390         command |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
1391         pci_write_config(dev, PCIR_COMMAND, command, 4);
1392         command = pci_read_config(dev, PCIR_COMMAND, 4);
1393
1394 #ifdef SK_USEIOSPACE
1395         if ((command & PCIM_CMD_PORTEN) == 0) {
1396                 printf("skc%d: failed to enable I/O ports!\n", unit);
1397                 error = ENXIO;
1398                 goto fail;
1399         }
1400 #else
1401         if ((command & PCIM_CMD_MEMEN) == 0) {
1402                 printf("skc%d: failed to enable memory mapping!\n", unit);
1403                 error = ENXIO;
1404                 goto fail;
1405         }
1406 #endif
1407
1408         rid = SK_RID;
1409         sc->sk_res = bus_alloc_resource_any(dev, SK_RES, &rid, RF_ACTIVE);
1410
1411         if (sc->sk_res == NULL) {
1412                 printf("sk%d: couldn't map ports/memory\n", unit);
1413                 error = ENXIO;
1414                 goto fail;
1415         }
1416
1417         sc->sk_btag = rman_get_bustag(sc->sk_res);
1418         sc->sk_bhandle = rman_get_bushandle(sc->sk_res);
1419
1420         /* Allocate interrupt */
1421         rid = 0;
1422         sc->sk_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
1423             RF_SHAREABLE | RF_ACTIVE);
1424
1425         if (sc->sk_irq == NULL) {
1426                 printf("skc%d: couldn't map interrupt\n", unit);
1427                 bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1428                 error = ENXIO;
1429                 goto fail;
1430         }
1431
1432         error = bus_setup_intr(dev, sc->sk_irq, INTR_NETSAFE,
1433                                sk_intr, sc,
1434                                &sc->sk_intrhand, &sk_serializer);
1435
1436         if (error) {
1437                 printf("skc%d: couldn't set up irq\n", unit);
1438                 bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1439                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sk_irq);
1440                 goto fail;
1441         }
1442
1443         /* Reset the adapter. */
1444         sk_reset(sc);
1445
1446         sc->sk_unit = unit;
1447
1448         /* Read and save vital product data from EEPROM. */
1449         sk_vpd_read(sc);
1450
1451         skrs = sk_win_read_1(sc, SK_EPROM0);
1452         if (sc->sk_type == SK_GENESIS) {
1453                 /* Read and save RAM size and RAMbuffer offset */
1454                 switch(skrs) {
1455                 case SK_RAMSIZE_512K_64:
1456                         sc->sk_ramsize = 0x80000;
1457                         sc->sk_rboff = SK_RBOFF_0;
1458                         break;
1459                 case SK_RAMSIZE_1024K_64:
1460                         sc->sk_ramsize = 0x100000;
1461                         sc->sk_rboff = SK_RBOFF_80000;
1462                         break;
1463                 case SK_RAMSIZE_1024K_128:
1464                         sc->sk_ramsize = 0x100000;
1465                         sc->sk_rboff = SK_RBOFF_0;
1466                         break;
1467                 case SK_RAMSIZE_2048K_128:
1468                         sc->sk_ramsize = 0x200000;
1469                         sc->sk_rboff = SK_RBOFF_0;
1470                         break;
1471                 default:
1472                         printf("skc%d: unknown ram size: %d\n",
1473                             sc->sk_unit, sk_win_read_1(sc, SK_EPROM0));
1474                         bus_teardown_intr(dev, sc->sk_irq, sc->sk_intrhand);
1475                         bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sk_irq);
1476                         bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1477                         error = ENXIO;
1478                         goto fail;
1479                         break;
1480                 }
1481         } else { /* SK_YUKON */
1482                 if (skrs == 0x00) {
1483                         sc->sk_ramsize = 0x20000;
1484                 } else {
1485                         sc->sk_ramsize = skrs * (1<<12);
1486                 }
1487                 sc->sk_rboff = SK_RBOFF_0;
1488         }
1489
1490         /* Read and save physical media type */
1491         switch(sk_win_read_1(sc, SK_PMDTYPE)) {
1492         case SK_PMD_1000BASESX:
1493                 sc->sk_pmd = IFM_1000_SX;
1494                 break;
1495         case SK_PMD_1000BASELX:
1496                 sc->sk_pmd = IFM_1000_LX;
1497                 break;
1498         case SK_PMD_1000BASECX:
1499                 sc->sk_pmd = IFM_1000_CX;
1500                 break;
1501         case SK_PMD_1000BASETX:
1502                 sc->sk_pmd = IFM_1000_T;
1503                 break;
1504         default:
1505                 printf("skc%d: unknown media type: 0x%x\n",
1506                     sc->sk_unit, sk_win_read_1(sc, SK_PMDTYPE));
1507                 bus_teardown_intr(dev, sc->sk_irq, sc->sk_intrhand);
1508                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sk_irq);
1509                 bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1510                 error = ENXIO;
1511                 goto fail;
1512         }
1513
1514         /* Announce the product name. */
1515         printf("skc%d: %s\n", sc->sk_unit, sc->sk_vpd_prodname);
1516         sc->sk_devs[SK_PORT_A] = device_add_child(dev, "sk", -1);
1517         port = kmalloc(sizeof(int), M_DEVBUF, M_WAITOK);
1518         *port = SK_PORT_A;
1519         device_set_ivars(sc->sk_devs[SK_PORT_A], port);
1520
1521         if (!(sk_win_read_1(sc, SK_CONFIG) & SK_CONFIG_SINGLEMAC)) {
1522                 sc->sk_devs[SK_PORT_B] = device_add_child(dev, "sk", -1);
1523                 port = kmalloc(sizeof(int), M_DEVBUF, M_WAITOK);
1524                 *port = SK_PORT_B;
1525                 device_set_ivars(sc->sk_devs[SK_PORT_B], port);
1526         }
1527
1528         /* Turn on the 'driver is loaded' LED. */
1529         CSR_WRITE_2(sc, SK_LED, SK_LED_GREEN_ON);
1530
1531         bus_generic_attach(dev);
1532
1533 fail:
1534         crit_exit();
1535         return(error);
1536 }
1537
1538 static int
1539 sk_detach(device_t dev)
1540 {
1541         struct sk_if_softc *sc_if = device_get_softc(dev);
1542         struct ifnet *ifp = &sc_if->arpcom.ac_if;
1543
1544         ether_ifdetach(ifp);
1545         bus_generic_detach(dev);
1546         if (sc_if->sk_miibus != NULL)
1547                 device_delete_child(dev, sc_if->sk_miibus);
1548         contigfree(sc_if->sk_cdata.sk_jumbo_buf, SK_JMEM, M_DEVBUF);
1549         contigfree(sc_if->sk_rdata, sizeof(struct sk_ring_data), M_DEVBUF);
1550
1551         return(0);
1552 }
1553
1554 static int
1555 skc_detach(device_t dev)
1556 {
1557         struct sk_softc *sc;
1558
1559         sc = device_get_softc(dev);
1560
1561         lwkt_serialize_enter(&sk_serializer);
1562
1563         if (sc->sk_if[SK_PORT_A] != NULL)
1564                 sk_stop(sc->sk_if[SK_PORT_A]);
1565         if (sc->sk_if[SK_PORT_B] != NULL)
1566                 sk_stop(sc->sk_if[SK_PORT_B]);
1567
1568         bus_teardown_intr(dev, sc->sk_irq, sc->sk_intrhand);
1569
1570         lwkt_serialize_exit(&sk_serializer);
1571
1572         /*
1573          * recursed from sk_detach ?  don't need serializer
1574          */
1575         bus_generic_detach(dev);
1576         if (sc->sk_devs[SK_PORT_A] != NULL)
1577                 device_delete_child(dev, sc->sk_devs[SK_PORT_A]);
1578         if (sc->sk_devs[SK_PORT_B] != NULL)
1579                 device_delete_child(dev, sc->sk_devs[SK_PORT_B]);
1580
1581         bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sk_irq);
1582         bus_release_resource(dev, SK_RES, SK_RID, sc->sk_res);
1583
1584         return(0);
1585 }
1586
1587 static int
1588 sk_encap(struct sk_if_softc *sc_if, struct mbuf *m_head, uint32_t *txidx)
1589 {
1590         struct sk_tx_desc *f = NULL;
1591         struct mbuf *m;
1592         uint32_t cnt = 0, cur, frag;
1593
1594         m = m_head;
1595         cur = frag = *txidx;
1596
1597         /*
1598          * Start packing the mbufs in this chain into
1599          * the fragment pointers. Stop when we run out
1600          * of fragments or hit the end of the mbuf chain.
1601          */
1602         for (m = m_head; m != NULL; m = m->m_next) {
1603                 if (m->m_len != 0) {
1604                         if ((SK_TX_RING_CNT -
1605                             (sc_if->sk_cdata.sk_tx_cnt + cnt)) < 2)
1606                                 return(ENOBUFS);
1607                         f = &sc_if->sk_rdata->sk_tx_ring[frag];
1608                         f->sk_data_lo = vtophys(mtod(m, vm_offset_t));
1609                         f->sk_ctl = m->m_len | SK_OPCODE_DEFAULT;
1610                         if (cnt == 0)
1611                                 f->sk_ctl |= SK_TXCTL_FIRSTFRAG;
1612                         else
1613                                 f->sk_ctl |= SK_TXCTL_OWN;
1614                         cur = frag;
1615                         SK_INC(frag, SK_TX_RING_CNT);
1616                         cnt++;
1617                 }
1618         }
1619
1620         if (m != NULL)
1621                 return(ENOBUFS);
1622
1623         sc_if->sk_rdata->sk_tx_ring[cur].sk_ctl |=
1624                 SK_TXCTL_LASTFRAG|SK_TXCTL_EOF_INTR;
1625         sc_if->sk_cdata.sk_tx_chain[cur].sk_mbuf = m_head;
1626         sc_if->sk_rdata->sk_tx_ring[*txidx].sk_ctl |= SK_TXCTL_OWN;
1627         sc_if->sk_cdata.sk_tx_cnt += cnt;
1628
1629         *txidx = frag;
1630
1631         return(0);
1632 }
1633
1634 static void
1635 sk_start(struct ifnet *ifp)
1636 {
1637         struct sk_if_softc *sc_if = ifp->if_softc;
1638         struct sk_softc *sc = sc_if->sk_softc;
1639         struct mbuf *m_head = NULL;
1640         uint32_t idx;
1641         int need_trans;
1642
1643         idx = sc_if->sk_cdata.sk_tx_prod;
1644
1645         need_trans = 0;
1646         while(sc_if->sk_cdata.sk_tx_chain[idx].sk_mbuf == NULL) {
1647                 m_head = ifq_poll(&ifp->if_snd);
1648                 if (m_head == NULL)
1649                         break;
1650
1651                 /*
1652                  * Pack the data into the transmit ring. If we
1653                  * don't have room, set the OACTIVE flag and wait
1654                  * for the NIC to drain the ring.
1655                  */
1656                 if (sk_encap(sc_if, m_head, &idx)) {
1657                         ifp->if_flags |= IFF_OACTIVE;
1658                         break;
1659                 }
1660                 ifq_dequeue(&ifp->if_snd, m_head);
1661                 need_trans = 1;
1662
1663                 BPF_MTAP(ifp, m_head);
1664         }
1665
1666         if (!need_trans)
1667                 return;
1668
1669         /* Transmit */
1670         sc_if->sk_cdata.sk_tx_prod = idx;
1671         CSR_WRITE_4(sc, sc_if->sk_tx_bmu, SK_TXBMU_TX_START);
1672
1673         /* Set a timeout in case the chip goes out to lunch. */
1674         ifp->if_timer = 5;
1675 }
1676
1677
1678 static void
1679 sk_watchdog(struct ifnet *ifp)
1680 {
1681         struct sk_if_softc *sc_if;
1682
1683         sc_if = ifp->if_softc;
1684
1685         printf("sk%d: watchdog timeout\n", sc_if->sk_unit);
1686         ifp->if_flags &= ~IFF_RUNNING;
1687         sk_init(sc_if);
1688
1689         if (!ifq_is_empty(&ifp->if_snd))
1690                 ifp->if_start(ifp);
1691 }
1692
1693 static void
1694 skc_shutdown(device_t dev)
1695 {
1696         struct sk_softc *sc = device_get_softc(dev);
1697
1698         lwkt_serialize_enter(&sk_serializer);
1699
1700         /* Turn off the 'driver is loaded' LED. */
1701         CSR_WRITE_2(sc, SK_LED, SK_LED_GREEN_OFF);
1702
1703         /*
1704          * Reset the GEnesis controller. Doing this should also
1705          * assert the resets on the attached XMAC(s).
1706          */
1707         sk_reset(sc);
1708         lwkt_serialize_exit(&sk_serializer);
1709 }
1710
1711 static void
1712 sk_rxeof(struct sk_if_softc *sc_if)
1713 {
1714         struct ifnet *ifp = &sc_if->arpcom.ac_if;
1715         struct mbuf *m;
1716         struct sk_chain *cur_rx;
1717         int i, total_len = 0;
1718         uint32_t rxstat;
1719
1720         i = sc_if->sk_cdata.sk_rx_prod;
1721         cur_rx = &sc_if->sk_cdata.sk_rx_chain[i];
1722
1723         while(!(sc_if->sk_rdata->sk_rx_ring[i].sk_ctl & SK_RXCTL_OWN)) {
1724                 cur_rx = &sc_if->sk_cdata.sk_rx_chain[i];
1725                 rxstat = sc_if->sk_rdata->sk_rx_ring[i].sk_xmac_rxstat;
1726                 m = cur_rx->sk_mbuf;
1727                 cur_rx->sk_mbuf = NULL;
1728                 total_len = SK_RXBYTES(sc_if->sk_rdata->sk_rx_ring[i].sk_ctl);
1729                 SK_INC(i, SK_RX_RING_CNT);
1730
1731                 if (rxstat & XM_RXSTAT_ERRFRAME) {
1732                         ifp->if_ierrors++;
1733                         sk_newbuf(sc_if, cur_rx, m);
1734                         continue;
1735                 }
1736
1737                 /*
1738                  * Try to allocate a new jumbo buffer. If that
1739                  * fails, copy the packet to mbufs and put the
1740                  * jumbo buffer back in the ring so it can be
1741                  * re-used. If allocating mbufs fails, then we
1742                  * have to drop the packet.
1743                  */
1744                 if (sk_newbuf(sc_if, cur_rx, NULL) == ENOBUFS) {
1745                         struct mbuf *m0;
1746                         m0 = m_devget(mtod(m, char *) - ETHER_ALIGN,
1747                             total_len + ETHER_ALIGN, 0, ifp, NULL);
1748                         sk_newbuf(sc_if, cur_rx, m);
1749                         if (m0 == NULL) {
1750                                 printf("sk%d: no receive buffers "
1751                                     "available -- packet dropped!\n",
1752                                     sc_if->sk_unit);
1753                                 ifp->if_ierrors++;
1754                                 continue;
1755                         }
1756                         m_adj(m0, ETHER_ALIGN);
1757                         m = m0;
1758                 } else {
1759                         m->m_pkthdr.rcvif = ifp;
1760                         m->m_pkthdr.len = m->m_len = total_len;
1761                 }
1762
1763                 ifp->if_ipackets++;
1764                 ifp->if_input(ifp, m);
1765         }
1766
1767         sc_if->sk_cdata.sk_rx_prod = i;
1768 }
1769
1770 static void
1771 sk_txeof(struct sk_if_softc *sc_if)
1772 {
1773         struct ifnet *ifp = &sc_if->arpcom.ac_if;
1774         struct sk_tx_desc *cur_tx = NULL;
1775         uint32_t idx;
1776
1777         /*
1778          * Go through our tx ring and free mbufs for those
1779          * frames that have been sent.
1780          */
1781         idx = sc_if->sk_cdata.sk_tx_cons;
1782         while(idx != sc_if->sk_cdata.sk_tx_prod) {
1783                 cur_tx = &sc_if->sk_rdata->sk_tx_ring[idx];
1784                 if (cur_tx->sk_ctl & SK_TXCTL_OWN)
1785                         break;
1786                 if (cur_tx->sk_ctl & SK_TXCTL_LASTFRAG)
1787                         ifp->if_opackets++;
1788                 if (sc_if->sk_cdata.sk_tx_chain[idx].sk_mbuf != NULL) {
1789                         m_freem(sc_if->sk_cdata.sk_tx_chain[idx].sk_mbuf);
1790                         sc_if->sk_cdata.sk_tx_chain[idx].sk_mbuf = NULL;
1791                 }
1792                 sc_if->sk_cdata.sk_tx_cnt--;
1793                 SK_INC(idx, SK_TX_RING_CNT);
1794                 ifp->if_timer = 0;
1795         }
1796
1797         sc_if->sk_cdata.sk_tx_cons = idx;
1798
1799         if (cur_tx != NULL)
1800                 ifp->if_flags &= ~IFF_OACTIVE;
1801 }
1802
1803 static void
1804 sk_tick(void *xsc_if)
1805 {
1806         struct sk_if_softc *sc_if = xsc_if;
1807         struct ifnet *ifp = &sc_if->arpcom.ac_if;
1808         struct mii_data *mii = device_get_softc(sc_if->sk_miibus);
1809         int i;
1810
1811         lwkt_serialize_enter(&sk_serializer);
1812
1813         if ((ifp->if_flags & IFF_UP) == 0) {
1814                 lwkt_serialize_exit(&sk_serializer);
1815                 return;
1816         }
1817
1818         if (sc_if->sk_phytype == SK_PHYTYPE_BCOM) {
1819                 sk_intr_bcom(sc_if);
1820                 lwkt_serialize_exit(&sk_serializer);
1821                 return;
1822         }
1823
1824         /*
1825          * According to SysKonnect, the correct way to verify that
1826          * the link has come back up is to poll bit 0 of the GPIO
1827          * register three times. This pin has the signal from the
1828          * link_sync pin connected to it; if we read the same link
1829          * state 3 times in a row, we know the link is up.
1830          */
1831         for (i = 0; i < 3; i++) {
1832                 if (SK_XM_READ_2(sc_if, XM_GPIO) & XM_GPIO_GP0_SET)
1833                         break;
1834         }
1835
1836         if (i != 3) {
1837                 callout_reset(&sc_if->sk_tick_timer, hz, sk_tick, sc_if);
1838                 lwkt_serialize_exit(&sk_serializer);
1839                 return;
1840         }
1841
1842         /* Turn the GP0 interrupt back on. */
1843         SK_XM_CLRBIT_2(sc_if, XM_IMR, XM_IMR_GP0_SET);
1844         SK_XM_READ_2(sc_if, XM_ISR);
1845         mii_tick(mii);
1846         mii_pollstat(mii);
1847         callout_stop(&sc_if->sk_tick_timer);
1848         lwkt_serialize_exit(&sk_serializer);
1849 }
1850
1851 static void
1852 sk_intr_bcom(struct sk_if_softc *sc_if)
1853 {
1854         struct ifnet *ifp = &sc_if->arpcom.ac_if;
1855         struct mii_data *mii = device_get_softc(sc_if->sk_miibus);
1856         int status;
1857
1858         SK_XM_CLRBIT_2(sc_if, XM_MMUCMD, XM_MMUCMD_TX_ENB|XM_MMUCMD_RX_ENB);
1859
1860         /*
1861          * Read the PHY interrupt register to make sure
1862          * we clear any pending interrupts.
1863          */
1864         status = sk_xmac_miibus_readreg(sc_if, SK_PHYADDR_BCOM, BRGPHY_MII_ISR);
1865
1866         if ((ifp->if_flags & IFF_RUNNING) == 0) {
1867                 sk_init_xmac(sc_if);
1868                 return;
1869         }
1870
1871         if (status & (BRGPHY_ISR_LNK_CHG|BRGPHY_ISR_AN_PR)) {
1872                 int lstat;
1873                 lstat = sk_xmac_miibus_readreg(sc_if, SK_PHYADDR_BCOM,
1874                     BRGPHY_MII_AUXSTS);
1875
1876                 if (!(lstat & BRGPHY_AUXSTS_LINK) && sc_if->sk_link) {
1877                         mii_mediachg(mii);
1878                         /* Turn off the link LED. */
1879                         SK_IF_WRITE_1(sc_if, 0,
1880                             SK_LINKLED1_CTL, SK_LINKLED_OFF);
1881                         sc_if->sk_link = 0;
1882                 } else if (status & BRGPHY_ISR_LNK_CHG) {
1883                         sk_xmac_miibus_writereg(sc_if, SK_PHYADDR_BCOM,
1884                             BRGPHY_MII_IMR, 0xFF00);
1885                         mii_tick(mii);
1886                         sc_if->sk_link = 1;
1887                         /* Turn on the link LED. */
1888                         SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL,
1889                             SK_LINKLED_ON|SK_LINKLED_LINKSYNC_OFF|
1890                             SK_LINKLED_BLINK_OFF);
1891                         mii_pollstat(mii);
1892                 } else {
1893                         mii_tick(mii);
1894                         callout_reset(&sc_if->sk_tick_timer, hz,
1895                                       sk_tick, sc_if);
1896                 }
1897         }
1898
1899         SK_XM_SETBIT_2(sc_if, XM_MMUCMD, XM_MMUCMD_TX_ENB|XM_MMUCMD_RX_ENB);
1900 }
1901
1902 static void
1903 sk_intr_xmac(struct sk_if_softc *sc_if)
1904 {
1905         uint16_t status;
1906
1907         status = SK_XM_READ_2(sc_if, XM_ISR);
1908
1909         /*
1910          * Link has gone down. Start MII tick timeout to
1911          * watch for link resync.
1912          */
1913         if (sc_if->sk_phytype == SK_PHYTYPE_XMAC) {
1914                 if (status & XM_ISR_GP0_SET) {
1915                         SK_XM_SETBIT_2(sc_if, XM_IMR, XM_IMR_GP0_SET);
1916                         callout_reset(&sc_if->sk_tick_timer, hz,
1917                                       sk_tick, sc_if);
1918                 }
1919
1920                 if (status & XM_ISR_AUTONEG_DONE) {
1921                         callout_reset(&sc_if->sk_tick_timer, hz,
1922                                       sk_tick, sc_if);
1923                 }
1924         }
1925
1926         if (status & XM_IMR_TX_UNDERRUN)
1927                 SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_FLUSH_TXFIFO);
1928
1929         if (status & XM_IMR_RX_OVERRUN)
1930                 SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_FLUSH_RXFIFO);
1931
1932         status = SK_XM_READ_2(sc_if, XM_ISR);
1933 }
1934
1935 static void
1936 sk_intr_yukon(struct sk_if_softc *sc_if)
1937 {
1938         int status;
1939
1940         status = SK_IF_READ_2(sc_if, 0, SK_GMAC_ISR);
1941 }
1942
1943 static void
1944 sk_intr(void *xsc)
1945 {
1946         struct sk_softc *sc = xsc;
1947         struct sk_if_softc *sc_if0 = sc->sk_if[SK_PORT_A];
1948         struct sk_if_softc *sc_if1 = sc->sk_if[SK_PORT_A];
1949         struct ifnet *ifp0 = NULL, *ifp1 = NULL;
1950         uint32_t status;
1951
1952         if (sc_if0 != NULL)
1953                 ifp0 = &sc_if0->arpcom.ac_if;
1954         if (sc_if1 != NULL)
1955                 ifp1 = &sc_if1->arpcom.ac_if;
1956
1957         for (;;) {
1958                 status = CSR_READ_4(sc, SK_ISSR);
1959                 if ((status & sc->sk_intrmask) == 0)
1960                         break;
1961
1962                 /* Handle receive interrupts first. */
1963                 if (status & SK_ISR_RX1_EOF) {
1964                         sk_rxeof(sc_if0);
1965                         CSR_WRITE_4(sc, SK_BMU_RX_CSR0,
1966                             SK_RXBMU_CLR_IRQ_EOF|SK_RXBMU_RX_START);
1967                 }
1968                 if (status & SK_ISR_RX2_EOF) {
1969                         sk_rxeof(sc_if1);
1970                         CSR_WRITE_4(sc, SK_BMU_RX_CSR1,
1971                             SK_RXBMU_CLR_IRQ_EOF|SK_RXBMU_RX_START);
1972                 }
1973
1974                 /* Then transmit interrupts. */
1975                 if (status & SK_ISR_TX1_S_EOF) {
1976                         sk_txeof(sc_if0);
1977                         CSR_WRITE_4(sc, SK_BMU_TXS_CSR0,
1978                             SK_TXBMU_CLR_IRQ_EOF);
1979                 }
1980                 if (status & SK_ISR_TX2_S_EOF) {
1981                         sk_txeof(sc_if1);
1982                         CSR_WRITE_4(sc, SK_BMU_TXS_CSR1,
1983                             SK_TXBMU_CLR_IRQ_EOF);
1984                 }
1985
1986                 /* Then MAC interrupts. */
1987                 if (status & SK_ISR_MAC1 && ifp0->if_flags & IFF_RUNNING) {
1988                         if (sc->sk_type == SK_GENESIS)
1989                                 sk_intr_xmac(sc_if0);
1990                         else
1991                                 sk_intr_yukon(sc_if0);
1992                 }
1993
1994                 if (status & SK_ISR_MAC2 && ifp1->if_flags & IFF_RUNNING) {
1995                         if (sc->sk_type == SK_GENESIS)
1996                                 sk_intr_xmac(sc_if1);
1997                         else
1998                                 sk_intr_yukon(sc_if0);
1999                 }
2000
2001                 if (status & SK_ISR_EXTERNAL_REG) {
2002                         if (ifp0 != NULL &&
2003                             sc_if0->sk_phytype == SK_PHYTYPE_BCOM)
2004                                 sk_intr_bcom(sc_if0);
2005                         if (ifp1 != NULL &&
2006                             sc_if1->sk_phytype == SK_PHYTYPE_BCOM)
2007                                 sk_intr_bcom(sc_if1);
2008                 }
2009         }
2010
2011         CSR_WRITE_4(sc, SK_IMR, sc->sk_intrmask);
2012
2013         if (ifp0 != NULL && !ifq_is_empty(&ifp0->if_snd))
2014                 sk_start(ifp0);
2015         if (ifp1 != NULL && !ifq_is_empty(&ifp0->if_snd))
2016                 sk_start(ifp1);
2017 }
2018
2019 static void
2020 sk_init_xmac(struct sk_if_softc *sc_if)
2021 {
2022         struct sk_softc *sc = sc_if->sk_softc;
2023         struct ifnet *ifp = &sc_if->arpcom.ac_if;
2024         struct sk_bcom_hack bhack[] = {
2025         { 0x18, 0x0c20 }, { 0x17, 0x0012 }, { 0x15, 0x1104 }, { 0x17, 0x0013 },
2026         { 0x15, 0x0404 }, { 0x17, 0x8006 }, { 0x15, 0x0132 }, { 0x17, 0x8006 },
2027         { 0x15, 0x0232 }, { 0x17, 0x800D }, { 0x15, 0x000F }, { 0x18, 0x0420 },
2028         { 0, 0 } };
2029
2030         /* Unreset the XMAC. */
2031         SK_IF_WRITE_2(sc_if, 0, SK_TXF1_MACCTL, SK_TXMACCTL_XMAC_UNRESET);
2032         DELAY(1000);
2033
2034         /* Reset the XMAC's internal state. */
2035         SK_XM_SETBIT_2(sc_if, XM_GPIO, XM_GPIO_RESETMAC);
2036
2037         /* Save the XMAC II revision */
2038         sc_if->sk_xmac_rev = XM_XMAC_REV(SK_XM_READ_4(sc_if, XM_DEVID));
2039
2040         /*
2041          * Perform additional initialization for external PHYs,
2042          * namely for the 1000baseTX cards that use the XMAC's
2043          * GMII mode.
2044          */
2045         if (sc_if->sk_phytype == SK_PHYTYPE_BCOM) {
2046                 int i = 0;
2047                 uint32_t val;
2048
2049                 /* Take PHY out of reset. */
2050                 val = sk_win_read_4(sc, SK_GPIO);
2051                 if (sc_if->sk_port == SK_PORT_A)
2052                         val |= SK_GPIO_DIR0|SK_GPIO_DAT0;
2053                 else
2054                         val |= SK_GPIO_DIR2|SK_GPIO_DAT2;
2055                 sk_win_write_4(sc, SK_GPIO, val);
2056
2057                 /* Enable GMII mode on the XMAC. */
2058                 SK_XM_SETBIT_2(sc_if, XM_HWCFG, XM_HWCFG_GMIIMODE);
2059
2060                 sk_xmac_miibus_writereg(sc_if, SK_PHYADDR_BCOM,
2061                     BRGPHY_MII_BMCR, BRGPHY_BMCR_RESET);
2062                 DELAY(10000);
2063                 sk_xmac_miibus_writereg(sc_if, SK_PHYADDR_BCOM,
2064                     BRGPHY_MII_IMR, 0xFFF0);
2065
2066                 /*
2067                  * Early versions of the BCM5400 apparently have
2068                  * a bug that requires them to have their reserved
2069                  * registers initialized to some magic values. I don't
2070                  * know what the numbers do, I'm just the messenger.
2071                  */
2072                 if (sk_xmac_miibus_readreg(sc_if, SK_PHYADDR_BCOM, 0x03)
2073                     == 0x6041) {
2074                         while(bhack[i].reg) {
2075                                 sk_xmac_miibus_writereg(sc_if, SK_PHYADDR_BCOM,
2076                                     bhack[i].reg, bhack[i].val);
2077                                 i++;
2078                         }
2079                 }
2080         }
2081
2082         /* Set station address */
2083         SK_XM_WRITE_2(sc_if, XM_PAR0,
2084             *(uint16_t *)(&sc_if->arpcom.ac_enaddr[0]));
2085         SK_XM_WRITE_2(sc_if, XM_PAR1,
2086             *(uint16_t *)(&sc_if->arpcom.ac_enaddr[2]));
2087         SK_XM_WRITE_2(sc_if, XM_PAR2,
2088             *(uint16_t *)(&sc_if->arpcom.ac_enaddr[4]));
2089         SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_USE_STATION);
2090
2091         if (ifp->if_flags & IFF_BROADCAST)
2092                 SK_XM_CLRBIT_4(sc_if, XM_MODE, XM_MODE_RX_NOBROAD);
2093         else
2094                 SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_NOBROAD);
2095
2096         /* We don't need the FCS appended to the packet. */
2097         SK_XM_SETBIT_2(sc_if, XM_RXCMD, XM_RXCMD_STRIPFCS);
2098
2099         /* We want short frames padded to 60 bytes. */
2100         SK_XM_SETBIT_2(sc_if, XM_TXCMD, XM_TXCMD_AUTOPAD);
2101
2102         /*
2103          * Enable the reception of all error frames. This is is
2104          * a necessary evil due to the design of the XMAC. The
2105          * XMAC's receive FIFO is only 8K in size, however jumbo
2106          * frames can be up to 9000 bytes in length. When bad
2107          * frame filtering is enabled, the XMAC's RX FIFO operates
2108          * in 'store and forward' mode. For this to work, the
2109          * entire frame has to fit into the FIFO, but that means
2110          * that jumbo frames larger than 8192 bytes will be
2111          * truncated. Disabling all bad frame filtering causes
2112          * the RX FIFO to operate in streaming mode, in which
2113          * case the XMAC will start transfering frames out of the
2114          * RX FIFO as soon as the FIFO threshold is reached.
2115          */
2116         SK_XM_SETBIT_4(sc_if, XM_MODE, XM_MODE_RX_BADFRAMES|
2117             XM_MODE_RX_GIANTS|XM_MODE_RX_RUNTS|XM_MODE_RX_CRCERRS|
2118             XM_MODE_RX_INRANGELEN);
2119
2120         if (ifp->if_mtu > (ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN))
2121                 SK_XM_SETBIT_2(sc_if, XM_RXCMD, XM_RXCMD_BIGPKTOK);
2122         else
2123                 SK_XM_CLRBIT_2(sc_if, XM_RXCMD, XM_RXCMD_BIGPKTOK);
2124
2125         /*
2126          * Bump up the transmit threshold. This helps hold off transmit
2127          * underruns when we're blasting traffic from both ports at once.
2128          */
2129         SK_XM_WRITE_2(sc_if, XM_TX_REQTHRESH, SK_XM_TX_FIFOTHRESH);
2130
2131         /* Set promiscuous mode */
2132         sk_setpromisc(sc_if);
2133
2134         /* Set multicast filter */
2135         sk_setmulti(sc_if);
2136
2137         /* Clear and enable interrupts */
2138         SK_XM_READ_2(sc_if, XM_ISR);
2139         if (sc_if->sk_phytype == SK_PHYTYPE_XMAC)
2140                 SK_XM_WRITE_2(sc_if, XM_IMR, XM_INTRS);
2141         else
2142                 SK_XM_WRITE_2(sc_if, XM_IMR, 0xFFFF);
2143
2144         /* Configure MAC arbiter */
2145         switch(sc_if->sk_xmac_rev) {
2146         case XM_XMAC_REV_B2:
2147                 sk_win_write_1(sc, SK_RCINIT_RX1, SK_RCINIT_XMAC_B2);
2148                 sk_win_write_1(sc, SK_RCINIT_TX1, SK_RCINIT_XMAC_B2);
2149                 sk_win_write_1(sc, SK_RCINIT_RX2, SK_RCINIT_XMAC_B2);
2150                 sk_win_write_1(sc, SK_RCINIT_TX2, SK_RCINIT_XMAC_B2);
2151                 sk_win_write_1(sc, SK_MINIT_RX1, SK_MINIT_XMAC_B2);
2152                 sk_win_write_1(sc, SK_MINIT_TX1, SK_MINIT_XMAC_B2);
2153                 sk_win_write_1(sc, SK_MINIT_RX2, SK_MINIT_XMAC_B2);
2154                 sk_win_write_1(sc, SK_MINIT_TX2, SK_MINIT_XMAC_B2);
2155                 sk_win_write_1(sc, SK_RECOVERY_CTL, SK_RECOVERY_XMAC_B2);
2156                 break;
2157         case XM_XMAC_REV_C1:
2158                 sk_win_write_1(sc, SK_RCINIT_RX1, SK_RCINIT_XMAC_C1);
2159                 sk_win_write_1(sc, SK_RCINIT_TX1, SK_RCINIT_XMAC_C1);
2160                 sk_win_write_1(sc, SK_RCINIT_RX2, SK_RCINIT_XMAC_C1);
2161                 sk_win_write_1(sc, SK_RCINIT_TX2, SK_RCINIT_XMAC_C1);
2162                 sk_win_write_1(sc, SK_MINIT_RX1, SK_MINIT_XMAC_C1);
2163                 sk_win_write_1(sc, SK_MINIT_TX1, SK_MINIT_XMAC_C1);
2164                 sk_win_write_1(sc, SK_MINIT_RX2, SK_MINIT_XMAC_C1);
2165                 sk_win_write_1(sc, SK_MINIT_TX2, SK_MINIT_XMAC_C1);
2166                 sk_win_write_1(sc, SK_RECOVERY_CTL, SK_RECOVERY_XMAC_B2);
2167                 break;
2168         default:
2169                 break;
2170         }
2171         sk_win_write_2(sc, SK_MACARB_CTL,
2172             SK_MACARBCTL_UNRESET|SK_MACARBCTL_FASTOE_OFF);
2173
2174         sc_if->sk_link = 1;
2175 }
2176
2177 static void
2178 sk_init_yukon(struct sk_if_softc *sc_if)
2179 {
2180         struct ifnet *ifp = &sc_if->arpcom.ac_if;
2181         uint32_t phy;
2182         uint16_t reg;
2183         int i;
2184
2185         /* GMAC and GPHY Reset */
2186         SK_IF_WRITE_4(sc_if, 0, SK_GPHY_CTRL, SK_GPHY_RESET_SET);
2187         SK_IF_WRITE_4(sc_if, 0, SK_GMAC_CTRL, SK_GMAC_RESET_SET);
2188         DELAY(1000);
2189         SK_IF_WRITE_4(sc_if, 0, SK_GMAC_CTRL, SK_GMAC_RESET_CLEAR);
2190         SK_IF_WRITE_4(sc_if, 0, SK_GMAC_CTRL, SK_GMAC_RESET_SET);
2191         DELAY(1000);
2192
2193         phy = SK_GPHY_INT_POL_HI | SK_GPHY_DIS_FC | SK_GPHY_DIS_SLEEP |
2194                 SK_GPHY_ENA_XC | SK_GPHY_ANEG_ALL | SK_GPHY_ENA_PAUSE;
2195
2196         switch(sc_if->sk_softc->sk_pmd) {
2197         case IFM_1000_SX:
2198         case IFM_1000_LX:
2199                 phy |= SK_GPHY_FIBER;
2200                 break;
2201
2202         case IFM_1000_CX:
2203         case IFM_1000_T:
2204                 phy |= SK_GPHY_COPPER;
2205                 break;
2206         }
2207
2208         SK_IF_WRITE_4(sc_if, 0, SK_GPHY_CTRL, phy | SK_GPHY_RESET_SET);
2209         DELAY(1000);
2210         SK_IF_WRITE_4(sc_if, 0, SK_GPHY_CTRL, phy | SK_GPHY_RESET_CLEAR);
2211         SK_IF_WRITE_4(sc_if, 0, SK_GMAC_CTRL, SK_GMAC_LOOP_OFF |
2212                       SK_GMAC_PAUSE_ON | SK_GMAC_RESET_CLEAR);
2213
2214         /* unused read of the interrupt source register */
2215         SK_IF_READ_2(sc_if, 0, SK_GMAC_ISR);
2216
2217         reg = SK_YU_READ_2(sc_if, YUKON_PAR);
2218
2219         /* MIB Counter Clear Mode set */
2220         reg |= YU_PAR_MIB_CLR;
2221         SK_YU_WRITE_2(sc_if, YUKON_PAR, reg);
2222
2223         /* MIB Counter Clear Mode clear */
2224         reg &= ~YU_PAR_MIB_CLR;
2225         SK_YU_WRITE_2(sc_if, YUKON_PAR, reg);
2226
2227         /* receive control reg */
2228         SK_YU_WRITE_2(sc_if, YUKON_RCR, YU_RCR_CRCR);
2229
2230         /* transmit parameter register */
2231         SK_YU_WRITE_2(sc_if, YUKON_TPR, YU_TPR_JAM_LEN(0x3) |
2232                       YU_TPR_JAM_IPG(0xb) | YU_TPR_JAM2DATA_IPG(0x1a) );
2233
2234         /* serial mode register */
2235         reg = YU_SMR_DATA_BLIND(0x1c) | YU_SMR_MFL_VLAN | YU_SMR_IPG_DATA(0x1e);
2236         if (ifp->if_mtu > (ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN))
2237                 reg |= YU_SMR_MFL_JUMBO;
2238         SK_YU_WRITE_2(sc_if, YUKON_SMR, reg);
2239
2240         /* Setup Yukon's address */
2241         for (i = 0; i < 3; i++) {
2242                 /* Write Source Address 1 (unicast filter) */
2243                 SK_YU_WRITE_2(sc_if, YUKON_SAL1 + i * 4, 
2244                               sc_if->arpcom.ac_enaddr[i * 2] |
2245                               sc_if->arpcom.ac_enaddr[i * 2 + 1] << 8);
2246         }
2247
2248         for (i = 0; i < 3; i++) {
2249                 reg = sk_win_read_2(sc_if->sk_softc,
2250                                     SK_MAC1_0 + i * 2 + sc_if->sk_port * 8);
2251                 SK_YU_WRITE_2(sc_if, YUKON_SAL2 + i * 4, reg);
2252         }
2253
2254         /* Set promiscuous mode */
2255         sk_setpromisc(sc_if);
2256
2257         /* Set multicast filter */
2258         sk_setmulti(sc_if);
2259
2260         /* enable interrupt mask for counter overflows */
2261         SK_YU_WRITE_2(sc_if, YUKON_TIMR, 0);
2262         SK_YU_WRITE_2(sc_if, YUKON_RIMR, 0);
2263         SK_YU_WRITE_2(sc_if, YUKON_TRIMR, 0);
2264
2265         /* Configure RX MAC FIFO */
2266         SK_IF_WRITE_1(sc_if, 0, SK_RXMF1_CTRL_TEST, SK_RFCTL_RESET_CLEAR);
2267         SK_IF_WRITE_4(sc_if, 0, SK_RXMF1_CTRL_TEST, SK_RFCTL_OPERATION_ON);
2268
2269         /* Configure TX MAC FIFO */
2270         SK_IF_WRITE_1(sc_if, 0, SK_TXMF1_CTRL_TEST, SK_TFCTL_RESET_CLEAR);
2271         SK_IF_WRITE_4(sc_if, 0, SK_TXMF1_CTRL_TEST, SK_TFCTL_OPERATION_ON);
2272 }
2273
2274 /*
2275  * Note that to properly initialize any part of the GEnesis chip,
2276  * you first have to take it out of reset mode.
2277  */
2278 static void
2279 sk_init(void *xsc)
2280 {
2281         struct sk_if_softc *sc_if = xsc;
2282         struct sk_softc *sc = sc_if->sk_softc;
2283         struct ifnet *ifp = &sc_if->arpcom.ac_if;
2284         struct mii_data *mii = device_get_softc(sc_if->sk_miibus);
2285         uint16_t reg;
2286
2287         crit_enter();
2288
2289         if (ifp->if_flags & IFF_RUNNING) {
2290                 crit_exit();
2291                 return;
2292         }
2293
2294         /* Cancel pending I/O and free all RX/TX buffers. */
2295         sk_stop(sc_if);
2296
2297         if (sc->sk_type == SK_GENESIS) {
2298                 /* Configure LINK_SYNC LED */
2299                 SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL, SK_LINKLED_ON);
2300                 SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL,
2301                         SK_LINKLED_LINKSYNC_ON);
2302
2303                 /* Configure RX LED */
2304                 SK_IF_WRITE_1(sc_if, 0, SK_RXLED1_CTL,  
2305                         SK_RXLEDCTL_COUNTER_START);
2306
2307                 /* Configure TX LED */
2308                 SK_IF_WRITE_1(sc_if, 0, SK_TXLED1_CTL,
2309                         SK_TXLEDCTL_COUNTER_START);
2310         }
2311
2312         /* Configure I2C registers */
2313
2314         /* Configure XMAC(s) */
2315         switch (sc->sk_type) {
2316         case SK_GENESIS:
2317                 sk_init_xmac(sc_if);
2318                 break;
2319         case SK_YUKON:
2320                 sk_init_yukon(sc_if);
2321                 break;
2322         }
2323         mii_mediachg(mii);
2324
2325         if (sc->sk_type == SK_GENESIS) {
2326                 /* Configure MAC FIFOs */
2327                 SK_IF_WRITE_4(sc_if, 0, SK_RXF1_CTL, SK_FIFO_UNRESET);
2328                 SK_IF_WRITE_4(sc_if, 0, SK_RXF1_END, SK_FIFO_END);
2329                 SK_IF_WRITE_4(sc_if, 0, SK_RXF1_CTL, SK_FIFO_ON);
2330
2331                 SK_IF_WRITE_4(sc_if, 0, SK_TXF1_CTL, SK_FIFO_UNRESET);
2332                 SK_IF_WRITE_4(sc_if, 0, SK_TXF1_END, SK_FIFO_END);
2333                 SK_IF_WRITE_4(sc_if, 0, SK_TXF1_CTL, SK_FIFO_ON);
2334         }
2335
2336         /* Configure transmit arbiter(s) */
2337         SK_IF_WRITE_1(sc_if, 0, SK_TXAR1_COUNTERCTL,
2338             SK_TXARCTL_ON | SK_TXARCTL_FSYNC_ON);
2339
2340         /* Configure RAMbuffers */
2341         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_CTLTST, SK_RBCTL_UNRESET);
2342         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_START, sc_if->sk_rx_ramstart);
2343         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_WR_PTR, sc_if->sk_rx_ramstart);
2344         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_RD_PTR, sc_if->sk_rx_ramstart);
2345         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_END, sc_if->sk_rx_ramend);
2346         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_CTLTST, SK_RBCTL_ON);
2347
2348         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_CTLTST, SK_RBCTL_UNRESET);
2349         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_CTLTST, SK_RBCTL_STORENFWD_ON);
2350         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_START, sc_if->sk_tx_ramstart);
2351         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_WR_PTR, sc_if->sk_tx_ramstart);
2352         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_RD_PTR, sc_if->sk_tx_ramstart);
2353         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_END, sc_if->sk_tx_ramend);
2354         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_CTLTST, SK_RBCTL_ON);
2355
2356         /* Configure BMUs */
2357         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_BMU_CSR, SK_RXBMU_ONLINE);
2358         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_CURADDR_LO,
2359             vtophys(&sc_if->sk_rdata->sk_rx_ring[0]));
2360         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_CURADDR_HI, 0);
2361
2362         SK_IF_WRITE_4(sc_if, 1, SK_TXQS1_BMU_CSR, SK_TXBMU_ONLINE);
2363         SK_IF_WRITE_4(sc_if, 1, SK_TXQS1_CURADDR_LO,
2364             vtophys(&sc_if->sk_rdata->sk_tx_ring[0]));
2365         SK_IF_WRITE_4(sc_if, 1, SK_TXQS1_CURADDR_HI, 0);
2366
2367         /* Init descriptors */
2368         if (sk_init_rx_ring(sc_if) == ENOBUFS) {
2369                 printf("sk%d: initialization failed: no "
2370                     "memory for rx buffers\n", sc_if->sk_unit);
2371                 sk_stop(sc_if);
2372                 crit_exit();
2373                 return;
2374         }
2375         sk_init_tx_ring(sc_if);
2376
2377         /* Configure interrupt handling */
2378         CSR_READ_4(sc, SK_ISSR);
2379         if (sc_if->sk_port == SK_PORT_A)
2380                 sc->sk_intrmask |= SK_INTRS1;
2381         else
2382                 sc->sk_intrmask |= SK_INTRS2;
2383
2384         sc->sk_intrmask |= SK_ISR_EXTERNAL_REG;
2385
2386         CSR_WRITE_4(sc, SK_IMR, sc->sk_intrmask);
2387
2388         /* Start BMUs. */
2389         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_BMU_CSR, SK_RXBMU_RX_START);
2390
2391         switch(sc->sk_type) {
2392         case SK_GENESIS:
2393                 /* Enable XMACs TX and RX state machines */
2394                 SK_XM_CLRBIT_2(sc_if, XM_MMUCMD, XM_MMUCMD_IGNPAUSE);
2395                 SK_XM_SETBIT_2(sc_if, XM_MMUCMD,
2396                     XM_MMUCMD_TX_ENB | XM_MMUCMD_RX_ENB);
2397                 break;
2398         case SK_YUKON:
2399                 reg = SK_YU_READ_2(sc_if, YUKON_GPCR);
2400                 reg |= YU_GPCR_TXEN | YU_GPCR_RXEN;
2401                 reg &= ~(YU_GPCR_SPEED_EN | YU_GPCR_DPLX_EN);
2402                 SK_YU_WRITE_2(sc_if, YUKON_GPCR, reg);
2403         }
2404
2405         ifp->if_flags |= IFF_RUNNING;
2406         ifp->if_flags &= ~IFF_OACTIVE;
2407
2408         crit_exit();
2409 }
2410
2411 static void
2412 sk_stop(struct sk_if_softc *sc_if)
2413 {
2414         int i;
2415         struct sk_softc *sc = sc_if->sk_softc;
2416         struct ifnet *ifp = &sc_if->arpcom.ac_if;
2417
2418         callout_stop(&sc_if->sk_tick_timer);
2419
2420         if (sc_if->sk_phytype == SK_PHYTYPE_BCOM) {
2421                 uint32_t val;
2422
2423                 /* Put PHY back into reset. */
2424                 val = sk_win_read_4(sc, SK_GPIO);
2425                 if (sc_if->sk_port == SK_PORT_A) {
2426                         val |= SK_GPIO_DIR0;
2427                         val &= ~SK_GPIO_DAT0;
2428                 } else {
2429                         val |= SK_GPIO_DIR2;
2430                         val &= ~SK_GPIO_DAT2;
2431                 }
2432                 sk_win_write_4(sc, SK_GPIO, val);
2433         }
2434
2435         /* Turn off various components of this interface. */
2436         SK_XM_SETBIT_2(sc_if, XM_GPIO, XM_GPIO_RESETMAC);
2437         switch (sc->sk_type) {
2438         case SK_GENESIS:
2439                 SK_IF_WRITE_2(sc_if, 0, SK_TXF1_MACCTL, SK_TXMACCTL_XMAC_RESET);
2440                 SK_IF_WRITE_4(sc_if, 0, SK_RXF1_CTL, SK_FIFO_RESET);
2441                 break;
2442         case SK_YUKON:
2443                 SK_IF_WRITE_1(sc_if,0, SK_RXMF1_CTRL_TEST, SK_RFCTL_RESET_SET);
2444                 SK_IF_WRITE_1(sc_if,0, SK_TXMF1_CTRL_TEST, SK_TFCTL_RESET_SET);
2445                 break;
2446         }
2447         SK_IF_WRITE_4(sc_if, 0, SK_RXQ1_BMU_CSR, SK_RXBMU_OFFLINE);
2448         SK_IF_WRITE_4(sc_if, 0, SK_RXRB1_CTLTST, SK_RBCTL_RESET | SK_RBCTL_OFF);
2449         SK_IF_WRITE_4(sc_if, 1, SK_TXQS1_BMU_CSR, SK_TXBMU_OFFLINE);
2450         SK_IF_WRITE_4(sc_if, 1, SK_TXRBS1_CTLTST,
2451             SK_RBCTL_RESET | SK_RBCTL_OFF);
2452         SK_IF_WRITE_1(sc_if, 0, SK_TXAR1_COUNTERCTL, SK_TXARCTL_OFF);
2453         SK_IF_WRITE_1(sc_if, 0, SK_RXLED1_CTL, SK_RXLEDCTL_COUNTER_STOP);
2454         SK_IF_WRITE_1(sc_if, 0, SK_TXLED1_CTL, SK_RXLEDCTL_COUNTER_STOP);
2455         SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL, SK_LINKLED_OFF);
2456         SK_IF_WRITE_1(sc_if, 0, SK_LINKLED1_CTL, SK_LINKLED_LINKSYNC_OFF);
2457
2458         /* Disable interrupts */
2459         if (sc_if->sk_port == SK_PORT_A)
2460                 sc->sk_intrmask &= ~SK_INTRS1;
2461         else
2462                 sc->sk_intrmask &= ~SK_INTRS2;
2463         CSR_WRITE_4(sc, SK_IMR, sc->sk_intrmask);
2464
2465         SK_XM_READ_2(sc_if, XM_ISR);
2466         SK_XM_WRITE_2(sc_if, XM_IMR, 0xFFFF);
2467
2468         /* Free RX and TX mbufs still in the queues. */
2469         for (i = 0; i < SK_RX_RING_CNT; i++) {
2470                 if (sc_if->sk_cdata.sk_rx_chain[i].sk_mbuf != NULL) {
2471                         m_freem(sc_if->sk_cdata.sk_rx_chain[i].sk_mbuf);
2472                         sc_if->sk_cdata.sk_rx_chain[i].sk_mbuf = NULL;
2473                 }
2474         }
2475
2476         for (i = 0; i < SK_TX_RING_CNT; i++) {
2477                 if (sc_if->sk_cdata.sk_tx_chain[i].sk_mbuf != NULL) {
2478                         m_freem(sc_if->sk_cdata.sk_tx_chain[i].sk_mbuf);
2479                         sc_if->sk_cdata.sk_tx_chain[i].sk_mbuf = NULL;
2480                 }
2481         }
2482
2483         ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE);
2484 }