1/* $NetBSD: tulip.c,v 1.188 2016/07/11 11:31:50 msaitoh Exp $ */
2
3/*-
4 * Copyright (c) 1998, 1999, 2000, 2002 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 * NASA Ames Research Center; and by Charles M. Hannum.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
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 THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33/*
34 * Device driver for the Digital Semiconductor ``Tulip'' (21x4x)
35 * Ethernet controller family, and a variety of clone chips.
36 */
37
38#include <sys/cdefs.h>
39__KERNEL_RCSID(0, "$NetBSD: tulip.c,v 1.188 2016/07/11 11:31:50 msaitoh Exp $");
40
41
42#include <sys/param.h>
43#include <sys/systm.h>
44#include <sys/callout.h>
45#include <sys/mbuf.h>
46#include <sys/malloc.h>
47#include <sys/kernel.h>
48#include <sys/socket.h>
49#include <sys/ioctl.h>
50#include <sys/errno.h>
51#include <sys/device.h>
52
53#include <machine/endian.h>
54
55#include <net/if.h>
56#include <net/if_dl.h>
57#include <net/if_media.h>
58#include <net/if_ether.h>
59
60#include <net/bpf.h>
61
62#include <sys/bus.h>
63#include <sys/intr.h>
64
65#include <dev/mii/mii.h>
66#include <dev/mii/miivar.h>
67#include <dev/mii/mii_bitbang.h>
68
69#include <dev/ic/tulipreg.h>
70#include <dev/ic/tulipvar.h>
71
72static const char * const tlp_chip_names[] = TULIP_CHIP_NAMES;
73
74static const struct tulip_txthresh_tab tlp_10_txthresh_tab[] =
75 TLP_TXTHRESH_TAB_10;
76
77static const struct tulip_txthresh_tab tlp_10_100_txthresh_tab[] =
78 TLP_TXTHRESH_TAB_10_100;
79
80static const struct tulip_txthresh_tab tlp_dm9102_txthresh_tab[] =
81 TLP_TXTHRESH_TAB_DM9102;
82
83static void tlp_start(struct ifnet *);
84static void tlp_watchdog(struct ifnet *);
85static int tlp_ioctl(struct ifnet *, u_long, void *);
86static int tlp_init(struct ifnet *);
87static void tlp_stop(struct ifnet *, int);
88static int tlp_ifflags_cb(struct ethercom *);
89
90static void tlp_rxdrain(struct tulip_softc *);
91static int tlp_add_rxbuf(struct tulip_softc *, int);
92static void tlp_srom_idle(struct tulip_softc *);
93static int tlp_srom_size(struct tulip_softc *);
94
95static int tlp_enable(struct tulip_softc *);
96static void tlp_disable(struct tulip_softc *);
97
98static void tlp_filter_setup(struct tulip_softc *);
99static void tlp_winb_filter_setup(struct tulip_softc *);
100static void tlp_al981_filter_setup(struct tulip_softc *);
101static void tlp_asix_filter_setup(struct tulip_softc *);
102
103static void tlp_rxintr(struct tulip_softc *);
104static void tlp_txintr(struct tulip_softc *);
105
106static void tlp_mii_tick(void *);
107static void tlp_mii_statchg(struct ifnet *);
108static void tlp_winb_mii_statchg(struct ifnet *);
109static void tlp_dm9102_mii_statchg(struct ifnet *);
110
111static void tlp_mii_getmedia(struct tulip_softc *, struct ifmediareq *);
112static int tlp_mii_setmedia(struct tulip_softc *);
113
114static int tlp_bitbang_mii_readreg(device_t, int, int);
115static void tlp_bitbang_mii_writereg(device_t, int, int, int);
116
117static int tlp_pnic_mii_readreg(device_t, int, int);
118static void tlp_pnic_mii_writereg(device_t, int, int, int);
119
120static int tlp_al981_mii_readreg(device_t, int, int);
121static void tlp_al981_mii_writereg(device_t, int, int, int);
122
123static void tlp_2114x_preinit(struct tulip_softc *);
124static void tlp_2114x_mii_preinit(struct tulip_softc *);
125static void tlp_pnic_preinit(struct tulip_softc *);
126static void tlp_dm9102_preinit(struct tulip_softc *);
127static void tlp_asix_preinit(struct tulip_softc *);
128
129static void tlp_21140_reset(struct tulip_softc *);
130static void tlp_21142_reset(struct tulip_softc *);
131static void tlp_pmac_reset(struct tulip_softc *);
132#if 0
133static void tlp_dm9102_reset(struct tulip_softc *);
134#endif
135
136static void tlp_2114x_nway_tick(void *);
137
138#define tlp_mchash(addr, sz) \
139 (ether_crc32_le((addr), ETHER_ADDR_LEN) & ((sz) - 1))
140
141/*
142 * MII bit-bang glue.
143 */
144static uint32_t tlp_sio_mii_bitbang_read(device_t);
145static void tlp_sio_mii_bitbang_write(device_t, uint32_t);
146
147static const struct mii_bitbang_ops tlp_sio_mii_bitbang_ops = {
148 tlp_sio_mii_bitbang_read,
149 tlp_sio_mii_bitbang_write,
150 {
151 MIIROM_MDO, /* MII_BIT_MDO */
152 MIIROM_MDI, /* MII_BIT_MDI */
153 MIIROM_MDC, /* MII_BIT_MDC */
154 0, /* MII_BIT_DIR_HOST_PHY */
155 MIIROM_MIIDIR, /* MII_BIT_DIR_PHY_HOST */
156 }
157};
158
159#ifdef TLP_DEBUG
160#define DPRINTF(sc, x) if ((sc)->sc_ethercom.ec_if.if_flags & IFF_DEBUG) \
161 printf x
162#else
163#define DPRINTF(sc, x) /* nothing */
164#endif
165
166#ifdef TLP_STATS
167static void tlp_print_stats(struct tulip_softc *);
168#endif
169
170/*
171 * Can be used to debug the SROM-related things, including contents.
172 * Initialized so that it's patchable.
173 */
174int tlp_srom_debug = 0;
175
176/*
177 * tlp_attach:
178 *
179 * Attach a Tulip interface to the system.
180 */
181int
182tlp_attach(struct tulip_softc *sc, const uint8_t *enaddr)
183{
184 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
185 device_t self = sc->sc_dev;
186 int i, error;
187
188 callout_init(&sc->sc_nway_callout, 0);
189 callout_init(&sc->sc_tick_callout, 0);
190
191 /*
192 * NOTE: WE EXPECT THE FRONT-END TO INITIALIZE sc_regshift!
193 */
194
195 /*
196 * Setup the transmit threshold table.
197 */
198 switch (sc->sc_chip) {
199 case TULIP_CHIP_DE425:
200 case TULIP_CHIP_21040:
201 case TULIP_CHIP_21041:
202 sc->sc_txth = tlp_10_txthresh_tab;
203 break;
204
205 case TULIP_CHIP_DM9102:
206 case TULIP_CHIP_DM9102A:
207 sc->sc_txth = tlp_dm9102_txthresh_tab;
208 break;
209
210 default:
211 sc->sc_txth = tlp_10_100_txthresh_tab;
212 break;
213 }
214
215 /*
216 * Setup the filter setup function.
217 */
218 switch (sc->sc_chip) {
219 case TULIP_CHIP_WB89C840F:
220 sc->sc_filter_setup = tlp_winb_filter_setup;
221 break;
222
223 case TULIP_CHIP_AL981:
224 case TULIP_CHIP_AN983:
225 case TULIP_CHIP_AN985:
226 sc->sc_filter_setup = tlp_al981_filter_setup;
227 break;
228
229 case TULIP_CHIP_AX88140:
230 case TULIP_CHIP_AX88141:
231 sc->sc_filter_setup = tlp_asix_filter_setup;
232 break;
233
234 default:
235 sc->sc_filter_setup = tlp_filter_setup;
236 break;
237 }
238
239 /*
240 * Set up the media status change function.
241 */
242 switch (sc->sc_chip) {
243 case TULIP_CHIP_WB89C840F:
244 sc->sc_statchg = tlp_winb_mii_statchg;
245 break;
246
247 case TULIP_CHIP_DM9102:
248 case TULIP_CHIP_DM9102A:
249 sc->sc_statchg = tlp_dm9102_mii_statchg;
250 break;
251
252 default:
253 /*
254 * We may override this if we have special media
255 * handling requirements (e.g. flipping GPIO pins).
256 *
257 * The pure-MII statchg function covers the basics.
258 */
259 sc->sc_statchg = tlp_mii_statchg;
260 break;
261 }
262
263 /*
264 * Default to no FS|LS in setup packet descriptors. They're
265 * supposed to be zero according to the 21040 and 21143
266 * manuals, and some chips fall over badly if they're
267 * included. Yet, other chips seem to require them. Sigh.
268 */
269 switch (sc->sc_chip) {
270 case TULIP_CHIP_X3201_3:
271 sc->sc_setup_fsls = TDCTL_Tx_FS|TDCTL_Tx_LS;
272 break;
273
274 default:
275 sc->sc_setup_fsls = 0;
276 }
277
278 /*
279 * Set up various chip-specific quirks.
280 *
281 * Note that wherever we can, we use the "ring" option for
282 * transmit and receive descriptors. This is because some
283 * clone chips apparently have problems when using chaining,
284 * although some *only* support chaining.
285 *
286 * What we do is always program the "next" pointer, and then
287 * conditionally set the TDCTL_CH and TDCTL_ER bits in the
288 * appropriate places.
289 */
290 switch (sc->sc_chip) {
291 case TULIP_CHIP_21140:
292 case TULIP_CHIP_21140A:
293 case TULIP_CHIP_21142:
294 case TULIP_CHIP_21143:
295 case TULIP_CHIP_82C115: /* 21143-like */
296 case TULIP_CHIP_MX98713: /* 21140-like */
297 case TULIP_CHIP_MX98713A: /* 21143-like */
298 case TULIP_CHIP_MX98715: /* 21143-like */
299 case TULIP_CHIP_MX98715A: /* 21143-like */
300 case TULIP_CHIP_MX98715AEC_X: /* 21143-like */
301 case TULIP_CHIP_MX98725: /* 21143-like */
302 case TULIP_CHIP_RS7112: /* 21143-like */
303 /*
304 * Run these chips in ring mode.
305 */
306 sc->sc_tdctl_ch = 0;
307 sc->sc_tdctl_er = TDCTL_ER;
308 sc->sc_preinit = tlp_2114x_preinit;
309 break;
310
311 case TULIP_CHIP_82C168:
312 case TULIP_CHIP_82C169:
313 /*
314 * Run these chips in ring mode.
315 */
316 sc->sc_tdctl_ch = 0;
317 sc->sc_tdctl_er = TDCTL_ER;
318 sc->sc_preinit = tlp_pnic_preinit;
319
320 /*
321 * These chips seem to have busted DMA engines; just put them
322 * in Store-and-Forward mode from the get-go.
323 */
324 sc->sc_txthresh = TXTH_SF;
325 break;
326
327 case TULIP_CHIP_WB89C840F:
328 /*
329 * Run this chip in chained mode.
330 */
331 sc->sc_tdctl_ch = TDCTL_CH;
332 sc->sc_tdctl_er = 0;
333 sc->sc_flags |= TULIPF_IC_FS;
334 break;
335
336 case TULIP_CHIP_DM9102:
337 case TULIP_CHIP_DM9102A:
338 /*
339 * Run these chips in chained mode.
340 */
341 sc->sc_tdctl_ch = TDCTL_CH;
342 sc->sc_tdctl_er = 0;
343 sc->sc_preinit = tlp_dm9102_preinit;
344
345 /*
346 * These chips have a broken bus interface, so we
347 * can't use any optimized bus commands. For this
348 * reason, we tend to underrun pretty quickly, so
349 * just to Store-and-Forward mode from the get-go.
350 */
351 sc->sc_txthresh = TXTH_DM9102_SF;
352 break;
353
354 case TULIP_CHIP_AX88140:
355 case TULIP_CHIP_AX88141:
356 /*
357 * Run these chips in ring mode.
358 */
359 sc->sc_tdctl_ch = 0;
360 sc->sc_tdctl_er = TDCTL_ER;
361 sc->sc_preinit = tlp_asix_preinit;
362 break;
363
364 default:
365 /*
366 * Default to running in ring mode.
367 */
368 sc->sc_tdctl_ch = 0;
369 sc->sc_tdctl_er = TDCTL_ER;
370 }
371
372 /*
373 * Set up the MII bit-bang operations.
374 */
375 switch (sc->sc_chip) {
376 case TULIP_CHIP_WB89C840F: /* XXX direction bit different? */
377 sc->sc_bitbang_ops = &tlp_sio_mii_bitbang_ops;
378 break;
379
380 default:
381 sc->sc_bitbang_ops = &tlp_sio_mii_bitbang_ops;
382 }
383
384 SIMPLEQ_INIT(&sc->sc_txfreeq);
385 SIMPLEQ_INIT(&sc->sc_txdirtyq);
386
387 /*
388 * Allocate the control data structures, and create and load the
389 * DMA map for it.
390 */
391 if ((error = bus_dmamem_alloc(sc->sc_dmat,
392 sizeof(struct tulip_control_data), PAGE_SIZE, 0, &sc->sc_cdseg,
393 1, &sc->sc_cdnseg, 0)) != 0) {
394 aprint_error_dev(self,
395 "unable to allocate control data, error = %d\n", error);
396 goto fail_0;
397 }
398
399 if ((error = bus_dmamem_map(sc->sc_dmat, &sc->sc_cdseg, sc->sc_cdnseg,
400 sizeof(struct tulip_control_data), (void **)&sc->sc_control_data,
401 BUS_DMA_COHERENT)) != 0) {
402 aprint_error_dev(self,
403 "unable to map control data, error = %d\n", error);
404 goto fail_1;
405 }
406
407 if ((error = bus_dmamap_create(sc->sc_dmat,
408 sizeof(struct tulip_control_data), 1,
409 sizeof(struct tulip_control_data), 0, 0, &sc->sc_cddmamap)) != 0) {
410 sc->sc_cddmamap = NULL;
411 aprint_error_dev(self,
412 "unable to create control data DMA map, error = %d\n",
413 error);
414 goto fail_2;
415 }
416
417 if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_cddmamap,
418 sc->sc_control_data, sizeof(struct tulip_control_data), NULL,
419 0)) != 0) {
420 aprint_error_dev(self,
421 "unable to load control data DMA map, error = %d\n",
422 error);
423 goto fail_3;
424 }
425
426 /*
427 * Create the transmit buffer DMA maps.
428 *
429 * Note that on the Xircom clone, transmit buffers must be
430 * 4-byte aligned. We're almost guaranteed to have to copy
431 * the packet in that case, so we just limit ourselves to
432 * one segment.
433 *
434 * On the DM9102, the transmit logic can only handle one
435 * DMA segment.
436 */
437 switch (sc->sc_chip) {
438 case TULIP_CHIP_X3201_3:
439 case TULIP_CHIP_DM9102:
440 case TULIP_CHIP_DM9102A:
441 case TULIP_CHIP_AX88140:
442 case TULIP_CHIP_AX88141:
443 sc->sc_ntxsegs = 1;
444 break;
445
446 default:
447 sc->sc_ntxsegs = TULIP_NTXSEGS;
448 }
449 for (i = 0; i < TULIP_TXQUEUELEN; i++) {
450 if ((error = bus_dmamap_create(sc->sc_dmat, MCLBYTES,
451 sc->sc_ntxsegs, MCLBYTES, 0, 0,
452 &sc->sc_txsoft[i].txs_dmamap)) != 0) {
453 sc->sc_txsoft[i].txs_dmamap = NULL;
454 aprint_error_dev(self,
455 "unable to create tx DMA map %d, error = %d\n", i,
456 error);
457 goto fail_4;
458 }
459 }
460
461 /*
462 * Create the receive buffer DMA maps.
463 */
464 for (i = 0; i < TULIP_NRXDESC; i++) {
465 if ((error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1,
466 MCLBYTES, 0, 0, &sc->sc_rxsoft[i].rxs_dmamap)) != 0) {
467 sc->sc_rxsoft[i].rxs_dmamap = NULL;
468 aprint_error_dev(self,
469 "unable to create rx DMA map %d, error = %d\n", i,
470 error);
471 goto fail_5;
472 }
473 sc->sc_rxsoft[i].rxs_mbuf = NULL;
474 }
475
476 /*
477 * From this point forward, the attachment cannot fail. A failure
478 * before this point releases all resources that may have been
479 * allocated.
480 */
481 sc->sc_flags |= TULIPF_ATTACHED;
482
483 /*
484 * Reset the chip to a known state.
485 */
486 tlp_reset(sc);
487
488 /* Announce ourselves. */
489 aprint_normal_dev(self, "%s%sEthernet address %s\n",
490 sc->sc_name[0] != '\0' ? sc->sc_name : "",
491 sc->sc_name[0] != '\0' ? ", " : "",
492 ether_sprintf(enaddr));
493
494 /*
495 * Check to see if we're the simulated Ethernet on Connectix
496 * Virtual PC.
497 */
498 if (enaddr[0] == 0x00 && enaddr[1] == 0x03 && enaddr[2] == 0xff)
499 sc->sc_flags |= TULIPF_VPC;
500
501 /*
502 * Initialize our media structures. This may probe the MII, if
503 * present.
504 */
505 (*sc->sc_mediasw->tmsw_init)(sc);
506
507 strlcpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
508 ifp->if_softc = sc;
509 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
510 sc->sc_if_flags = ifp->if_flags;
511 ifp->if_ioctl = tlp_ioctl;
512 ifp->if_start = tlp_start;
513 ifp->if_watchdog = tlp_watchdog;
514 ifp->if_init = tlp_init;
515 ifp->if_stop = tlp_stop;
516 IFQ_SET_READY(&ifp->if_snd);
517
518 /*
519 * We can support 802.1Q VLAN-sized frames.
520 */
521 sc->sc_ethercom.ec_capabilities |= ETHERCAP_VLAN_MTU;
522
523 /*
524 * Attach the interface.
525 */
526 if_attach(ifp);
527 ether_ifattach(ifp, enaddr);
528 ether_set_ifflags_cb(&sc->sc_ethercom, tlp_ifflags_cb);
529
530 rnd_attach_source(&sc->sc_rnd_source, device_xname(self),
531 RND_TYPE_NET, RND_FLAG_DEFAULT);
532
533 if (pmf_device_register(self, NULL, NULL))
534 pmf_class_network_register(self, ifp);
535 else
536 aprint_error_dev(self, "couldn't establish power handler\n");
537
538 return 0;
539
540 /*
541 * Free any resources we've allocated during the failed attach
542 * attempt. Do this in reverse order and fall through.
543 */
544 fail_5:
545 for (i = 0; i < TULIP_NRXDESC; i++) {
546 if (sc->sc_rxsoft[i].rxs_dmamap != NULL)
547 bus_dmamap_destroy(sc->sc_dmat,
548 sc->sc_rxsoft[i].rxs_dmamap);
549 }
550 fail_4:
551 for (i = 0; i < TULIP_TXQUEUELEN; i++) {
552 if (sc->sc_txsoft[i].txs_dmamap != NULL)
553 bus_dmamap_destroy(sc->sc_dmat,
554 sc->sc_txsoft[i].txs_dmamap);
555 }
556 bus_dmamap_unload(sc->sc_dmat, sc->sc_cddmamap);
557 fail_3:
558 bus_dmamap_destroy(sc->sc_dmat, sc->sc_cddmamap);
559 fail_2:
560 bus_dmamem_unmap(sc->sc_dmat, (void *)sc->sc_control_data,
561 sizeof(struct tulip_control_data));
562 fail_1:
563 bus_dmamem_free(sc->sc_dmat, &sc->sc_cdseg, sc->sc_cdnseg);
564 fail_0:
565 return error;
566}
567
568/*
569 * tlp_activate:
570 *
571 * Handle device activation/deactivation requests.
572 */
573int
574tlp_activate(device_t self, enum devact act)
575{
576 struct tulip_softc *sc = device_private(self);
577
578 switch (act) {
579 case DVACT_DEACTIVATE:
580 if_deactivate(&sc->sc_ethercom.ec_if);
581 return 0;
582 default:
583 return EOPNOTSUPP;
584 }
585}
586
587/*
588 * tlp_detach:
589 *
590 * Detach a Tulip interface.
591 */
592int
593tlp_detach(struct tulip_softc *sc)
594{
595 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
596 struct tulip_rxsoft *rxs;
597 struct tulip_txsoft *txs;
598 device_t self = sc->sc_dev;
599 int i, s;
600
601 /*
602 * Succeed now if there isn't any work to do.
603 */
604 if ((sc->sc_flags & TULIPF_ATTACHED) == 0)
605 return (0);
606
607 s = splnet();
608 /* Stop the interface. Callouts are stopped in it. */
609 tlp_stop(ifp, 1);
610 splx(s);
611
612 /* Destroy our callouts. */
613 callout_destroy(&sc->sc_nway_callout);
614 callout_destroy(&sc->sc_tick_callout);
615
616 if (sc->sc_flags & TULIPF_HAS_MII) {
617 /* Detach all PHYs */
618 mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
619 }
620
621 /* Delete all remaining media. */
622 ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
623
624 rnd_detach_source(&sc->sc_rnd_source);
625
626 ether_ifdetach(ifp);
627 if_detach(ifp);
628
629 for (i = 0; i < TULIP_NRXDESC; i++) {
630 rxs = &sc->sc_rxsoft[i];
631 if (rxs->rxs_mbuf != NULL) {
632 bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
633 m_freem(rxs->rxs_mbuf);
634 rxs->rxs_mbuf = NULL;
635 }
636 bus_dmamap_destroy(sc->sc_dmat, rxs->rxs_dmamap);
637 }
638 for (i = 0; i < TULIP_TXQUEUELEN; i++) {
639 txs = &sc->sc_txsoft[i];
640 if (txs->txs_mbuf != NULL) {
641 bus_dmamap_unload(sc->sc_dmat, txs->txs_dmamap);
642 m_freem(txs->txs_mbuf);
643 txs->txs_mbuf = NULL;
644 }
645 bus_dmamap_destroy(sc->sc_dmat, txs->txs_dmamap);
646 }
647 bus_dmamap_unload(sc->sc_dmat, sc->sc_cddmamap);
648 bus_dmamap_destroy(sc->sc_dmat, sc->sc_cddmamap);
649 bus_dmamem_unmap(sc->sc_dmat, (void *)sc->sc_control_data,
650 sizeof(struct tulip_control_data));
651 bus_dmamem_free(sc->sc_dmat, &sc->sc_cdseg, sc->sc_cdnseg);
652
653 pmf_device_deregister(self);
654
655 if (sc->sc_srom)
656 free(sc->sc_srom, M_DEVBUF);
657
658 return (0);
659}
660
661/*
662 * tlp_start: [ifnet interface function]
663 *
664 * Start packet transmission on the interface.
665 */
666static void
667tlp_start(struct ifnet *ifp)
668{
669 struct tulip_softc *sc = ifp->if_softc;
670 struct mbuf *m0, *m;
671 struct tulip_txsoft *txs, *last_txs = NULL;
672 bus_dmamap_t dmamap;
673 int error, firsttx, nexttx, lasttx = 1, ofree, seg;
674 struct tulip_desc *txd;
675
676 DPRINTF(sc, ("%s: tlp_start: sc_flags 0x%08x, if_flags 0x%08x\n",
677 device_xname(sc->sc_dev), sc->sc_flags, ifp->if_flags));
678
679 /*
680 * If we want a filter setup, it means no more descriptors were
681 * available for the setup routine. Let it get a chance to wedge
682 * itself into the ring.
683 */
684 if (sc->sc_flags & TULIPF_WANT_SETUP)
685 ifp->if_flags |= IFF_OACTIVE;
686
687 if ((ifp->if_flags & (IFF_RUNNING|IFF_OACTIVE)) != IFF_RUNNING)
688 return;
689
690 if (sc->sc_tick == tlp_2114x_nway_tick &&
691 (sc->sc_flags & TULIPF_LINK_UP) == 0 && ifp->if_snd.ifq_len < 10)
692 return;
693
694 /*
695 * Remember the previous number of free descriptors and
696 * the first descriptor we'll use.
697 */
698 ofree = sc->sc_txfree;
699 firsttx = sc->sc_txnext;
700
701 DPRINTF(sc, ("%s: tlp_start: txfree %d, txnext %d\n",
702 device_xname(sc->sc_dev), ofree, firsttx));
703
704 /*
705 * Loop through the send queue, setting up transmit descriptors
706 * until we drain the queue, or use up all available transmit
707 * descriptors.
708 */
709 while ((txs = SIMPLEQ_FIRST(&sc->sc_txfreeq)) != NULL &&
710 sc->sc_txfree != 0) {
711 /*
712 * Grab a packet off the queue.
713 */
714 IFQ_POLL(&ifp->if_snd, m0);
715 if (m0 == NULL)
716 break;
717 m = NULL;
718
719 dmamap = txs->txs_dmamap;
720
721 /*
722 * Load the DMA map. If this fails, the packet either
723 * didn't fit in the alloted number of segments, or we were
724 * short on resources. In this case, we'll copy and try
725 * again.
726 *
727 * Note that if we're only allowed 1 Tx segment, we
728 * have an alignment restriction. Do this test before
729 * attempting to load the DMA map, because it's more
730 * likely we'll trip the alignment test than the
731 * more-than-one-segment test.
732 */
733 if ((sc->sc_ntxsegs == 1 && (mtod(m0, uintptr_t) & 3) != 0) ||
734 bus_dmamap_load_mbuf(sc->sc_dmat, dmamap, m0,
735 BUS_DMA_WRITE|BUS_DMA_NOWAIT) != 0) {
736 MGETHDR(m, M_DONTWAIT, MT_DATA);
737 if (m == NULL) {
738 aprint_error_dev(sc->sc_dev, "unable to allocate Tx mbuf\n");
739 break;
740 }
741 MCLAIM(m, &sc->sc_ethercom.ec_tx_mowner);
742 if (m0->m_pkthdr.len > MHLEN) {
743 MCLGET(m, M_DONTWAIT);
744 if ((m->m_flags & M_EXT) == 0) {
745 aprint_error_dev(sc->sc_dev,
746 "unable to allocate Tx cluster\n");
747 m_freem(m);
748 break;
749 }
750 }
751 m_copydata(m0, 0, m0->m_pkthdr.len, mtod(m, void *));
752 m->m_pkthdr.len = m->m_len = m0->m_pkthdr.len;
753 error = bus_dmamap_load_mbuf(sc->sc_dmat, dmamap,
754 m, BUS_DMA_WRITE|BUS_DMA_NOWAIT);
755 if (error) {
756 aprint_error_dev(sc->sc_dev,
757 "unable to load Tx buffer, error = %d",
758 error);
759 break;
760 }
761 }
762
763 /*
764 * Ensure we have enough descriptors free to describe
765 * the packet.
766 */
767 if (dmamap->dm_nsegs > sc->sc_txfree) {
768 /*
769 * Not enough free descriptors to transmit this
770 * packet. We haven't committed to anything yet,
771 * so just unload the DMA map, put the packet
772 * back on the queue, and punt. Notify the upper
773 * layer that there are no more slots left.
774 *
775 * XXX We could allocate an mbuf and copy, but
776 * XXX it is worth it?
777 */
778 ifp->if_flags |= IFF_OACTIVE;
779 bus_dmamap_unload(sc->sc_dmat, dmamap);
780 if (m != NULL)
781 m_freem(m);
782 break;
783 }
784
785 IFQ_DEQUEUE(&ifp->if_snd, m0);
786 if (m != NULL) {
787 m_freem(m0);
788 m0 = m;
789 }
790
791 /*
792 * WE ARE NOW COMMITTED TO TRANSMITTING THE PACKET.
793 */
794
795 /* Sync the DMA map. */
796 bus_dmamap_sync(sc->sc_dmat, dmamap, 0, dmamap->dm_mapsize,
797 BUS_DMASYNC_PREWRITE);
798
799 /*
800 * Initialize the transmit descriptors.
801 */
802 for (nexttx = sc->sc_txnext, seg = 0;
803 seg < dmamap->dm_nsegs;
804 seg++, nexttx = TULIP_NEXTTX(nexttx)) {
805 /*
806 * If this is the first descriptor we're
807 * enqueueing, don't set the OWN bit just
808 * yet. That could cause a race condition.
809 * We'll do it below.
810 */
811 txd = &sc->sc_txdescs[nexttx];
812 txd->td_status =
813 (nexttx == firsttx) ? 0 : htole32(TDSTAT_OWN);
814 txd->td_bufaddr1 =
815 htole32(dmamap->dm_segs[seg].ds_addr);
816 txd->td_ctl =
817 htole32((dmamap->dm_segs[seg].ds_len <<
818 TDCTL_SIZE1_SHIFT) | sc->sc_tdctl_ch |
819 (nexttx == (TULIP_NTXDESC - 1) ?
820 sc->sc_tdctl_er : 0));
821 lasttx = nexttx;
822 }
823
824 KASSERT(lasttx != -1);
825
826 /* Set `first segment' and `last segment' appropriately. */
827 sc->sc_txdescs[sc->sc_txnext].td_ctl |= htole32(TDCTL_Tx_FS);
828 sc->sc_txdescs[lasttx].td_ctl |= htole32(TDCTL_Tx_LS);
829
830#ifdef TLP_DEBUG
831 if (ifp->if_flags & IFF_DEBUG) {
832 printf(" txsoft %p transmit chain:\n", txs);
833 for (seg = sc->sc_txnext;; seg = TULIP_NEXTTX(seg)) {
834 txd = &sc->sc_txdescs[seg];
835 printf(" descriptor %d:\n", seg);
836 printf(" td_status: 0x%08x\n",
837 le32toh(txd->td_status));
838 printf(" td_ctl: 0x%08x\n",
839 le32toh(txd->td_ctl));
840 printf(" td_bufaddr1: 0x%08x\n",
841 le32toh(txd->td_bufaddr1));
842 printf(" td_bufaddr2: 0x%08x\n",
843 le32toh(txd->td_bufaddr2));
844 if (seg == lasttx)
845 break;
846 }
847 }
848#endif
849
850 /* Sync the descriptors we're using. */
851 TULIP_CDTXSYNC(sc, sc->sc_txnext, dmamap->dm_nsegs,
852 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
853
854 /*
855 * Store a pointer to the packet so we can free it later,
856 * and remember what txdirty will be once the packet is
857 * done.
858 */
859 txs->txs_mbuf = m0;
860 txs->txs_firstdesc = sc->sc_txnext;
861 txs->txs_lastdesc = lasttx;
862 txs->txs_ndescs = dmamap->dm_nsegs;
863
864 /* Advance the tx pointer. */
865 sc->sc_txfree -= dmamap->dm_nsegs;
866 sc->sc_txnext = nexttx;
867
868 SIMPLEQ_REMOVE_HEAD(&sc->sc_txfreeq, txs_q);
869 SIMPLEQ_INSERT_TAIL(&sc->sc_txdirtyq, txs, txs_q);
870
871 last_txs = txs;
872
873 /*
874 * Pass the packet to any BPF listeners.
875 */
876 bpf_mtap(ifp, m0);
877 }
878
879 if (txs == NULL || sc->sc_txfree == 0) {
880 /* No more slots left; notify upper layer. */
881 ifp->if_flags |= IFF_OACTIVE;
882 }
883
884 if (sc->sc_txfree != ofree) {
885 DPRINTF(sc, ("%s: packets enqueued, IC on %d, OWN on %d\n",
886 device_xname(sc->sc_dev), lasttx, firsttx));
887 /*
888 * Cause a transmit interrupt to happen on the
889 * last packet we enqueued.
890 */
891 sc->sc_txdescs[lasttx].td_ctl |= htole32(TDCTL_Tx_IC);
892 TULIP_CDTXSYNC(sc, lasttx, 1,
893 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
894
895 /*
896 * Some clone chips want IC on the *first* segment in
897 * the packet. Appease them.
898 */
899 KASSERT(last_txs != NULL);
900 if ((sc->sc_flags & TULIPF_IC_FS) != 0 &&
901 last_txs->txs_firstdesc != lasttx) {
902 sc->sc_txdescs[last_txs->txs_firstdesc].td_ctl |=
903 htole32(TDCTL_Tx_IC);
904 TULIP_CDTXSYNC(sc, last_txs->txs_firstdesc, 1,
905 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
906 }
907
908 /*
909 * The entire packet chain is set up. Give the
910 * first descriptor to the chip now.
911 */
912 sc->sc_txdescs[firsttx].td_status |= htole32(TDSTAT_OWN);
913 TULIP_CDTXSYNC(sc, firsttx, 1,
914 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
915
916 /* Wake up the transmitter. */
917 /* XXX USE AUTOPOLLING? */
918 TULIP_WRITE(sc, CSR_TXPOLL, TXPOLL_TPD);
919
920 /* Set a watchdog timer in case the chip flakes out. */
921 ifp->if_timer = 5;
922 }
923}
924
925/*
926 * tlp_watchdog: [ifnet interface function]
927 *
928 * Watchdog timer handler.
929 */
930static void
931tlp_watchdog(struct ifnet *ifp)
932{
933 struct tulip_softc *sc = ifp->if_softc;
934 int doing_setup, doing_transmit;
935
936 doing_setup = (sc->sc_flags & TULIPF_DOING_SETUP);
937 doing_transmit = (! SIMPLEQ_EMPTY(&sc->sc_txdirtyq));
938
939 if (doing_setup && doing_transmit) {
940 printf("%s: filter setup and transmit timeout\n",
941 device_xname(sc->sc_dev));
942 ifp->if_oerrors++;
943 } else if (doing_transmit) {
944 printf("%s: transmit timeout\n", device_xname(sc->sc_dev));
945 ifp->if_oerrors++;
946 } else if (doing_setup)
947 printf("%s: filter setup timeout\n", device_xname(sc->sc_dev));
948 else
949 printf("%s: spurious watchdog timeout\n",
950 device_xname(sc->sc_dev));
951
952 (void) tlp_init(ifp);
953
954 /* Try to get more packets going. */
955 tlp_start(ifp);
956}
957
958/* If the interface is up and running, only modify the receive
959 * filter when setting promiscuous or debug mode. Otherwise fall
960 * through to ether_ioctl, which will reset the chip.
961 */
962static int
963tlp_ifflags_cb(struct ethercom *ec)
964{
965 struct ifnet *ifp = &ec->ec_if;
966 struct tulip_softc *sc = ifp->if_softc;
967 int change = ifp->if_flags ^ sc->sc_if_flags;
968
969 if ((change & ~(IFF_CANTCHANGE|IFF_DEBUG)) != 0)
970 return ENETRESET;
971 if ((change & IFF_PROMISC) != 0)
972 (*sc->sc_filter_setup)(sc);
973 return 0;
974}
975
976/*
977 * tlp_ioctl: [ifnet interface function]
978 *
979 * Handle control requests from the operator.
980 */
981static int
982tlp_ioctl(struct ifnet *ifp, u_long cmd, void *data)
983{
984 struct tulip_softc *sc = ifp->if_softc;
985 struct ifreq *ifr = (struct ifreq *)data;
986 int s, error;
987
988 s = splnet();
989
990 switch (cmd) {
991 case SIOCSIFMEDIA:
992 case SIOCGIFMEDIA:
993 error = ifmedia_ioctl(ifp, ifr, &sc->sc_mii.mii_media, cmd);
994 break;
995 default:
996 error = ether_ioctl(ifp, cmd, data);
997 if (error == ENETRESET) {
998 if (ifp->if_flags & IFF_RUNNING) {
999 /*
1000 * Multicast list has changed. Set the
1001 * hardware filter accordingly.
1002 */
1003 (*sc->sc_filter_setup)(sc);
1004 }
1005 error = 0;
1006 }
1007 break;
1008 }
1009
1010 /* Try to get more packets going. */
1011 if (TULIP_IS_ENABLED(sc))
1012 tlp_start(ifp);
1013
1014 sc->sc_if_flags = ifp->if_flags;
1015 splx(s);
1016 return (error);
1017}
1018
1019/*
1020 * tlp_intr:
1021 *
1022 * Interrupt service routine.
1023 */
1024int
1025tlp_intr(void *arg)
1026{
1027 struct tulip_softc *sc = arg;
1028 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
1029 uint32_t status, rxstatus, txstatus;
1030 int handled = 0, txthresh;
1031
1032 DPRINTF(sc, ("%s: tlp_intr\n", device_xname(sc->sc_dev)));
1033
1034#ifdef DEBUG
1035 if (TULIP_IS_ENABLED(sc) == 0)
1036 panic("%s: tlp_intr: not enabled", device_xname(sc->sc_dev));
1037#endif
1038
1039 /*
1040 * If the interface isn't running, the interrupt couldn't
1041 * possibly have come from us.
1042 */
1043 if ((ifp->if_flags & IFF_RUNNING) == 0 ||
1044 !device_is_active(sc->sc_dev))
1045 return (0);
1046
1047 /* Disable interrupts on the DM9102 (interrupt edge bug). */
1048 switch (sc->sc_chip) {
1049 case TULIP_CHIP_DM9102:
1050 case TULIP_CHIP_DM9102A:
1051 TULIP_WRITE(sc, CSR_INTEN, 0);
1052 break;
1053
1054 default:
1055 /* Nothing. */
1056 break;
1057 }
1058
1059 for (;;) {
1060 status = TULIP_READ(sc, CSR_STATUS);
1061 if (status)
1062 TULIP_WRITE(sc, CSR_STATUS, status);
1063
1064 if ((status & sc->sc_inten) == 0)
1065 break;
1066
1067 handled = 1;
1068
1069 rxstatus = status & sc->sc_rxint_mask;
1070 txstatus = status & sc->sc_txint_mask;
1071
1072 if (rxstatus) {
1073 /* Grab new any new packets. */
1074 tlp_rxintr(sc);
1075
1076 if (rxstatus & STATUS_RWT)
1077 printf("%s: receive watchdog timeout\n",
1078 device_xname(sc->sc_dev));
1079
1080 if (rxstatus & STATUS_RU) {
1081 printf("%s: receive ring overrun\n",
1082 device_xname(sc->sc_dev));
1083 /* Get the receive process going again. */
1084 if (sc->sc_tdctl_er != TDCTL_ER) {
1085 tlp_idle(sc, OPMODE_SR);
1086 TULIP_WRITE(sc, CSR_RXLIST,
1087 TULIP_CDRXADDR(sc, sc->sc_rxptr));
1088 TULIP_WRITE(sc, CSR_OPMODE,
1089 sc->sc_opmode);
1090 }
1091 TULIP_WRITE(sc, CSR_RXPOLL, RXPOLL_RPD);
1092 break;
1093 }
1094 }
1095
1096 if (txstatus) {
1097 /* Sweep up transmit descriptors. */
1098 tlp_txintr(sc);
1099
1100 if (txstatus & STATUS_TJT)
1101 printf("%s: transmit jabber timeout\n",
1102 device_xname(sc->sc_dev));
1103
1104 if (txstatus & STATUS_UNF) {
1105 /*
1106 * Increase our transmit threshold if
1107 * another is available.
1108 */
1109 txthresh = sc->sc_txthresh + 1;
1110 if (sc->sc_txth[txthresh].txth_name != NULL) {
1111 /* Idle the transmit process. */
1112 tlp_idle(sc, OPMODE_ST);
1113
1114 sc->sc_txthresh = txthresh;
1115 sc->sc_opmode &= ~(OPMODE_TR|OPMODE_SF);
1116 sc->sc_opmode |=
1117 sc->sc_txth[txthresh].txth_opmode;
1118 printf("%s: transmit underrun; new "
1119 "threshold: %s\n",
1120 device_xname(sc->sc_dev),
1121 sc->sc_txth[txthresh].txth_name);
1122
1123 /*
1124 * Set the new threshold and restart
1125 * the transmit process.
1126 */
1127 TULIP_WRITE(sc, CSR_OPMODE,
1128 sc->sc_opmode);
1129 }
1130 /*
1131 * XXX Log every Nth underrun from
1132 * XXX now on?
1133 */
1134 }
1135 }
1136
1137 if (status & (STATUS_TPS|STATUS_RPS)) {
1138 if (status & STATUS_TPS)
1139 printf("%s: transmit process stopped\n",
1140 device_xname(sc->sc_dev));
1141 if (status & STATUS_RPS)
1142 printf("%s: receive process stopped\n",
1143 device_xname(sc->sc_dev));
1144 (void) tlp_init(ifp);
1145 break;
1146 }
1147
1148 if (status & STATUS_SE) {
1149 const char *str;
1150 switch (status & STATUS_EB) {
1151 case STATUS_EB_PARITY:
1152 str = "parity error";
1153 break;
1154
1155 case STATUS_EB_MABT:
1156 str = "master abort";
1157 break;
1158
1159 case STATUS_EB_TABT:
1160 str = "target abort";
1161 break;
1162
1163 default:
1164 str = "unknown error";
1165 break;
1166 }
1167 aprint_error_dev(sc->sc_dev,
1168 "fatal system error: %s\n", str);
1169 (void) tlp_init(ifp);
1170 break;
1171 }
1172
1173 /*
1174 * Not handled:
1175 *
1176 * Transmit buffer unavailable -- normal
1177 * condition, nothing to do, really.
1178 *
1179 * General purpose timer experied -- we don't
1180 * use the general purpose timer.
1181 *
1182 * Early receive interrupt -- not available on
1183 * all chips, we just use RI. We also only
1184 * use single-segment receive DMA, so this
1185 * is mostly useless.
1186 */
1187 }
1188
1189 /* Bring interrupts back up on the DM9102. */
1190 switch (sc->sc_chip) {
1191 case TULIP_CHIP_DM9102:
1192 case TULIP_CHIP_DM9102A:
1193 TULIP_WRITE(sc, CSR_INTEN, sc->sc_inten);
1194 break;
1195
1196 default:
1197 /* Nothing. */
1198 break;
1199 }
1200
1201 /* Try to get more packets going. */
1202 tlp_start(ifp);
1203
1204 if (handled)
1205 rnd_add_uint32(&sc->sc_rnd_source, status);
1206
1207 return (handled);
1208}
1209
1210/*
1211 * tlp_rxintr:
1212 *
1213 * Helper; handle receive interrupts.
1214 */
1215static void
1216tlp_rxintr(struct tulip_softc *sc)
1217{
1218 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
1219 struct ether_header *eh;
1220 struct tulip_rxsoft *rxs;
1221 struct mbuf *m;
1222 uint32_t rxstat, errors;
1223 int i, len;
1224
1225 for (i = sc->sc_rxptr;; i = TULIP_NEXTRX(i)) {
1226 rxs = &sc->sc_rxsoft[i];
1227
1228 TULIP_CDRXSYNC(sc, i,
1229 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
1230
1231 rxstat = le32toh(sc->sc_rxdescs[i].td_status);
1232
1233 if (rxstat & TDSTAT_OWN) {
1234 /*
1235 * We have processed all of the receive buffers.
1236 */
1237 break;
1238 }
1239
1240 /*
1241 * Make sure the packet fit in one buffer. This should
1242 * always be the case. But the Lite-On PNIC, rev 33
1243 * has an awful receive engine bug, which may require
1244 * a very icky work-around.
1245 */
1246 if ((rxstat & (TDSTAT_Rx_FS|TDSTAT_Rx_LS)) !=
1247 (TDSTAT_Rx_FS|TDSTAT_Rx_LS)) {
1248 printf("%s: incoming packet spilled, resetting\n",
1249 device_xname(sc->sc_dev));
1250 (void) tlp_init(ifp);
1251 return;
1252 }
1253
1254 /*
1255 * If any collisions were seen on the wire, count one.
1256 */
1257 if (rxstat & TDSTAT_Rx_CS)
1258 ifp->if_collisions++;
1259
1260 /*
1261 * If an error occurred, update stats, clear the status
1262 * word, and leave the packet buffer in place. It will
1263 * simply be reused the next time the ring comes around.
1264 */
1265 errors = TDSTAT_Rx_DE | TDSTAT_Rx_RF | TDSTAT_Rx_TL |
1266 TDSTAT_Rx_CS | TDSTAT_Rx_RE | TDSTAT_Rx_DB | TDSTAT_Rx_CE;
1267 /*
1268 * If 802.1Q VLAN MTU is enabled, ignore the Frame Too Long
1269 * error.
1270 */
1271 if ((sc->sc_ethercom.ec_capenable & ETHERCAP_VLAN_MTU) != 0)
1272 errors &= ~TDSTAT_Rx_TL;
1273 /*
1274 * If chip doesn't have MII, ignore the MII error bit.
1275 */
1276 if ((sc->sc_flags & TULIPF_HAS_MII) == 0)
1277 errors &= ~TDSTAT_Rx_RE;
1278
1279 if ((rxstat & TDSTAT_ES) != 0 &&
1280 (rxstat & errors) != 0) {
1281 rxstat &= errors;
1282#define PRINTERR(bit, str) \
1283 if (rxstat & (bit)) \
1284 aprint_error_dev(sc->sc_dev, \
1285 "receive error: %s\n", str)
1286 ifp->if_ierrors++;
1287 PRINTERR(TDSTAT_Rx_DE, "descriptor error");
1288 PRINTERR(TDSTAT_Rx_RF, "runt frame");
1289 PRINTERR(TDSTAT_Rx_TL, "frame too long");
1290 PRINTERR(TDSTAT_Rx_RE, "MII error");
1291 PRINTERR(TDSTAT_Rx_DB, "dribbling bit");
1292 PRINTERR(TDSTAT_Rx_CE, "CRC error");
1293#undef PRINTERR
1294 TULIP_INIT_RXDESC(sc, i);
1295 continue;
1296 }
1297
1298 bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
1299 rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_POSTREAD);
1300
1301 /*
1302 * No errors; receive the packet. Note the Tulip
1303 * includes the CRC with every packet.
1304 */
1305 len = TDSTAT_Rx_LENGTH(rxstat) - ETHER_CRC_LEN;
1306
1307#ifdef __NO_STRICT_ALIGNMENT
1308 /*
1309 * Allocate a new mbuf cluster. If that fails, we are
1310 * out of memory, and must drop the packet and recycle
1311 * the buffer that's already attached to this descriptor.
1312 */
1313 m = rxs->rxs_mbuf;
1314 if (tlp_add_rxbuf(sc, i) != 0) {
1315 ifp->if_ierrors++;
1316 TULIP_INIT_RXDESC(sc, i);
1317 bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
1318 rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
1319 continue;
1320 }
1321#else
1322 /*
1323 * The Tulip's receive buffers must be 4-byte aligned.
1324 * But this means that the data after the Ethernet header
1325 * is misaligned. We must allocate a new buffer and
1326 * copy the data, shifted forward 2 bytes.
1327 */
1328 MGETHDR(m, M_DONTWAIT, MT_DATA);
1329 if (m == NULL) {
1330 dropit:
1331 ifp->if_ierrors++;
1332 TULIP_INIT_RXDESC(sc, i);
1333 bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
1334 rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
1335 continue;
1336 }
1337 MCLAIM(m, &sc->sc_ethercom.ec_rx_mowner);
1338 if (len > (MHLEN - 2)) {
1339 MCLGET(m, M_DONTWAIT);
1340 if ((m->m_flags & M_EXT) == 0) {
1341 m_freem(m);
1342 goto dropit;
1343 }
1344 }
1345 m->m_data += 2;
1346
1347 /*
1348 * Note that we use clusters for incoming frames, so the
1349 * buffer is virtually contiguous.
1350 */
1351 memcpy(mtod(m, void *), mtod(rxs->rxs_mbuf, void *), len);
1352
1353 /* Allow the receive descriptor to continue using its mbuf. */
1354 TULIP_INIT_RXDESC(sc, i);
1355 bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
1356 rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
1357#endif /* __NO_STRICT_ALIGNMENT */
1358
1359 ifp->if_ipackets++;
1360 eh = mtod(m, struct ether_header *);
1361 m_set_rcvif(m, ifp);
1362 m->m_pkthdr.len = m->m_len = len;
1363
1364 /*
1365 * XXX Work-around for a weird problem with the emulated
1366 * 21041 on Connectix Virtual PC:
1367 *
1368 * When we receive a full-size TCP segment, we seem to get
1369 * a packet there the Rx status says 1522 bytes, yet we do
1370 * not get a frame-too-long error from the chip. The extra
1371 * bytes seem to always be zeros. Perhaps Virtual PC is
1372 * inserting 4 bytes of zeros after every packet. In any
1373 * case, let's try and detect this condition and truncate
1374 * the length so that it will pass up the stack.
1375 */
1376 if (__predict_false((sc->sc_flags & TULIPF_VPC) != 0)) {
1377 uint16_t etype = ntohs(eh->ether_type);
1378
1379 if (len > ETHER_MAX_FRAME(ifp, etype, 0))
1380 m->m_pkthdr.len = m->m_len = len =
1381 ETHER_MAX_FRAME(ifp, etype, 0);
1382 }
1383
1384 /*
1385 * Pass this up to any BPF listeners, but only
1386 * pass it up the stack if it's for us.
1387 */
1388 bpf_mtap(ifp, m);
1389
1390 /*
1391 * We sometimes have to run the 21140 in Hash-Only
1392 * mode. If we're in that mode, and not in promiscuous
1393 * mode, and we have a unicast packet that isn't for
1394 * us, then drop it.
1395 */
1396 if (sc->sc_filtmode == TDCTL_Tx_FT_HASHONLY &&
1397 (ifp->if_flags & IFF_PROMISC) == 0 &&
1398 ETHER_IS_MULTICAST(eh->ether_dhost) == 0 &&
1399 memcmp(CLLADDR(ifp->if_sadl), eh->ether_dhost,
1400 ETHER_ADDR_LEN) != 0) {
1401 m_freem(m);
1402 continue;
1403 }
1404
1405 /* Pass it on. */
1406 if_percpuq_enqueue(ifp->if_percpuq, m);
1407 }
1408
1409 /* Update the receive pointer. */
1410 sc->sc_rxptr = i;
1411}
1412
1413/*
1414 * tlp_txintr:
1415 *
1416 * Helper; handle transmit interrupts.
1417 */
1418static void
1419tlp_txintr(struct tulip_softc *sc)
1420{
1421 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
1422 struct tulip_txsoft *txs;
1423 uint32_t txstat;
1424
1425 DPRINTF(sc, ("%s: tlp_txintr: sc_flags 0x%08x\n",
1426 device_xname(sc->sc_dev), sc->sc_flags));
1427
1428 ifp->if_flags &= ~IFF_OACTIVE;
1429
1430 /*
1431 * Go through our Tx list and free mbufs for those
1432 * frames that have been transmitted.
1433 */
1434 while ((txs = SIMPLEQ_FIRST(&sc->sc_txdirtyq)) != NULL) {
1435 TULIP_CDTXSYNC(sc, txs->txs_lastdesc,
1436 txs->txs_ndescs,
1437 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
1438
1439#ifdef TLP_DEBUG
1440 if (ifp->if_flags & IFF_DEBUG) {
1441 int i;
1442 struct tulip_desc *txd;
1443 printf(" txsoft %p transmit chain:\n", txs);
1444 for (i = txs->txs_firstdesc;; i = TULIP_NEXTTX(i)) {
1445 txd = &sc->sc_txdescs[i];
1446 printf(" descriptor %d:\n", i);
1447 printf(" td_status: 0x%08x\n",
1448 le32toh(txd->td_status));
1449 printf(" td_ctl: 0x%08x\n",
1450 le32toh(txd->td_ctl));
1451 printf(" td_bufaddr1: 0x%08x\n",
1452 le32toh(txd->td_bufaddr1));
1453 printf(" td_bufaddr2: 0x%08x\n",
1454 le32toh(sc->sc_txdescs[i].td_bufaddr2));
1455 if (i == txs->txs_lastdesc)
1456 break;
1457 }
1458 }
1459#endif
1460
1461 txstat = le32toh(sc->sc_txdescs[txs->txs_lastdesc].td_status);
1462 if (txstat & TDSTAT_OWN)
1463 break;
1464
1465 SIMPLEQ_REMOVE_HEAD(&sc->sc_txdirtyq, txs_q);
1466
1467 sc->sc_txfree += txs->txs_ndescs;
1468
1469 if (txs->txs_mbuf == NULL) {
1470 /*
1471 * If we didn't have an mbuf, it was the setup
1472 * packet.
1473 */
1474#ifdef DIAGNOSTIC
1475 if ((sc->sc_flags & TULIPF_DOING_SETUP) == 0)
1476 panic("tlp_txintr: null mbuf, not doing setup");
1477#endif
1478 TULIP_CDSPSYNC(sc, BUS_DMASYNC_POSTWRITE);
1479 sc->sc_flags &= ~TULIPF_DOING_SETUP;
1480 SIMPLEQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
1481 continue;
1482 }
1483
1484 bus_dmamap_sync(sc->sc_dmat, txs->txs_dmamap,
1485 0, txs->txs_dmamap->dm_mapsize,
1486 BUS_DMASYNC_POSTWRITE);
1487 bus_dmamap_unload(sc->sc_dmat, txs->txs_dmamap);
1488 m_freem(txs->txs_mbuf);
1489 txs->txs_mbuf = NULL;
1490
1491 SIMPLEQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
1492
1493 /*
1494 * Check for errors and collisions.
1495 */
1496#ifdef TLP_STATS
1497 if (txstat & TDSTAT_Tx_UF)
1498 sc->sc_stats.ts_tx_uf++;
1499 if (txstat & TDSTAT_Tx_TO)
1500 sc->sc_stats.ts_tx_to++;
1501 if (txstat & TDSTAT_Tx_EC)
1502 sc->sc_stats.ts_tx_ec++;
1503 if (txstat & TDSTAT_Tx_LC)
1504 sc->sc_stats.ts_tx_lc++;
1505#endif
1506
1507 if (txstat & (TDSTAT_Tx_UF|TDSTAT_Tx_TO))
1508 ifp->if_oerrors++;
1509
1510 if (txstat & TDSTAT_Tx_EC)
1511 ifp->if_collisions += 16;
1512 else
1513 ifp->if_collisions += TDSTAT_Tx_COLLISIONS(txstat);
1514 if (txstat & TDSTAT_Tx_LC)
1515 ifp->if_collisions++;
1516
1517 ifp->if_opackets++;
1518 }
1519
1520 /*
1521 * If there are no more pending transmissions, cancel the watchdog
1522 * timer.
1523 */
1524 if (txs == NULL && (sc->sc_flags & TULIPF_DOING_SETUP) == 0)
1525 ifp->if_timer = 0;
1526
1527 /*
1528 * If we have a receive filter setup pending, do it now.
1529 */
1530 if (sc->sc_flags & TULIPF_WANT_SETUP)
1531 (*sc->sc_filter_setup)(sc);
1532}
1533
1534#ifdef TLP_STATS
1535void
1536tlp_print_stats(struct tulip_softc *sc)
1537{
1538
1539 printf("%s: tx_uf %lu, tx_to %lu, tx_ec %lu, tx_lc %lu\n",
1540 device_xname(sc->sc_dev),
1541 sc->sc_stats.ts_tx_uf, sc->sc_stats.ts_tx_to,
1542 sc->sc_stats.ts_tx_ec, sc->sc_stats.ts_tx_lc);
1543}
1544#endif
1545
1546/*
1547 * tlp_reset:
1548 *
1549 * Perform a soft reset on the Tulip.
1550 */
1551void
1552tlp_reset(struct tulip_softc *sc)
1553{
1554 int i;
1555
1556 TULIP_WRITE(sc, CSR_BUSMODE, BUSMODE_SWR);
1557
1558 /*
1559 * Xircom, ASIX and Conexant clones don't bring themselves
1560 * out of reset automatically.
1561 * Instead, we have to wait at least 50 PCI cycles, and then
1562 * clear SWR.
1563 */
1564 switch (sc->sc_chip) {
1565 case TULIP_CHIP_X3201_3:
1566 case TULIP_CHIP_AX88140:
1567 case TULIP_CHIP_AX88141:
1568 case TULIP_CHIP_RS7112:
1569 delay(10);
1570 TULIP_WRITE(sc, CSR_BUSMODE, 0);
1571 break;
1572 default:
1573 break;
1574 }
1575
1576 for (i = 0; i < 1000; i++) {
1577 /*
1578 * Wait at least 50 PCI cycles for the reset to
1579 * complete before peeking at the Tulip again.
1580 * 10 uSec is a bit longer than 50 PCI cycles
1581 * (at 33MHz), but it doesn't hurt have the extra
1582 * wait.
1583 */
1584 delay(10);
1585 if (TULIP_ISSET(sc, CSR_BUSMODE, BUSMODE_SWR) == 0)
1586 break;
1587 }
1588
1589 if (TULIP_ISSET(sc, CSR_BUSMODE, BUSMODE_SWR))
1590 aprint_error_dev(sc->sc_dev, "reset failed to complete\n");
1591
1592 delay(1000);
1593
1594 /*
1595 * If the board has any GPIO reset sequences to issue, do them now.
1596 */
1597 if (sc->sc_reset != NULL)
1598 (*sc->sc_reset)(sc);
1599}
1600
1601/*
1602 * tlp_init: [ ifnet interface function ]
1603 *
1604 * Initialize the interface. Must be called at splnet().
1605 */
1606static int
1607tlp_init(struct ifnet *ifp)
1608{
1609 struct tulip_softc *sc = ifp->if_softc;
1610 struct tulip_txsoft *txs;
1611 struct tulip_rxsoft *rxs;
1612 int i, error = 0;
1613
1614 if ((error = tlp_enable(sc)) != 0)
1615 goto out;
1616
1617 /*
1618 * Cancel any pending I/O.
1619 */
1620 tlp_stop(ifp, 0);
1621
1622 /*
1623 * Initialize `opmode' to 0, and call the pre-init routine, if
1624 * any. This is required because the 2114x and some of the
1625 * clones require that the media-related bits in `opmode' be
1626 * set before performing a soft-reset in order to get internal
1627 * chip pathways are correct. Yay!
1628 */
1629 sc->sc_opmode = 0;
1630 if (sc->sc_preinit != NULL)
1631 (*sc->sc_preinit)(sc);
1632
1633 /*
1634 * Reset the Tulip to a known state.
1635 */
1636 tlp_reset(sc);
1637
1638 /*
1639 * Initialize the BUSMODE register.
1640 */
1641 sc->sc_busmode = BUSMODE_BAR;
1642 switch (sc->sc_chip) {
1643 case TULIP_CHIP_21140:
1644 case TULIP_CHIP_21140A:
1645 case TULIP_CHIP_21142:
1646 case TULIP_CHIP_21143:
1647 case TULIP_CHIP_82C115:
1648 case TULIP_CHIP_MX98725:
1649 /*
1650 * If we're allowed to do so, use Memory Read Line
1651 * and Memory Read Multiple.
1652 *
1653 * XXX Should we use Memory Write and Invalidate?
1654 */
1655 if (sc->sc_flags & TULIPF_MRL)
1656 sc->sc_busmode |= BUSMODE_RLE;
1657 if (sc->sc_flags & TULIPF_MRM)
1658 sc->sc_busmode |= BUSMODE_RME;
1659#if 0
1660 if (sc->sc_flags & TULIPF_MWI)
1661 sc->sc_busmode |= BUSMODE_WLE;
1662#endif
1663 break;
1664
1665 case TULIP_CHIP_82C168:
1666 case TULIP_CHIP_82C169:
1667 sc->sc_busmode |= BUSMODE_PNIC_MBO;
1668 if (sc->sc_maxburst == 0)
1669 sc->sc_maxburst = 16;
1670 break;
1671
1672 case TULIP_CHIP_AX88140:
1673 case TULIP_CHIP_AX88141:
1674 if (sc->sc_maxburst == 0)
1675 sc->sc_maxburst = 16;
1676 break;
1677
1678 default:
1679 /* Nothing. */
1680 break;
1681 }
1682 switch (sc->sc_cacheline) {
1683 default:
1684 /*
1685 * Note: We must *always* set these bits; a cache
1686 * alignment of 0 is RESERVED.
1687 */
1688 case 8:
1689 sc->sc_busmode |= BUSMODE_CAL_8LW;
1690 break;
1691 case 16:
1692 sc->sc_busmode |= BUSMODE_CAL_16LW;
1693 break;
1694 case 32:
1695 sc->sc_busmode |= BUSMODE_CAL_32LW;
1696 break;
1697 }
1698 switch (sc->sc_maxburst) {
1699 case 1:
1700 sc->sc_busmode |= BUSMODE_PBL_1LW;
1701 break;
1702 case 2:
1703 sc->sc_busmode |= BUSMODE_PBL_2LW;
1704 break;
1705 case 4:
1706 sc->sc_busmode |= BUSMODE_PBL_4LW;
1707 break;
1708 case 8:
1709 sc->sc_busmode |= BUSMODE_PBL_8LW;
1710 break;
1711 case 16:
1712 sc->sc_busmode |= BUSMODE_PBL_16LW;
1713 break;
1714 case 32:
1715 sc->sc_busmode |= BUSMODE_PBL_32LW;
1716 break;
1717 default:
1718 sc->sc_busmode |= BUSMODE_PBL_DEFAULT;
1719 break;
1720 }
1721#if BYTE_ORDER == BIG_ENDIAN
1722 /*
1723 * Can't use BUSMODE_BLE or BUSMODE_DBO; not all chips
1724 * support them, and even on ones that do, it doesn't
1725 * always work. So we always access descriptors with
1726 * little endian via htole32/le32toh.
1727 */
1728#endif
1729 /*
1730 * Big-endian bus requires BUSMODE_BLE anyway.
1731 * Also, BUSMODE_DBO is needed because we assume
1732 * descriptors are little endian.
1733 */
1734 if (sc->sc_flags & TULIPF_BLE)
1735 sc->sc_busmode |= BUSMODE_BLE;
1736 if (sc->sc_flags & TULIPF_DBO)
1737 sc->sc_busmode |= BUSMODE_DBO;
1738
1739 /*
1740 * Some chips have a broken bus interface.
1741 */
1742 switch (sc->sc_chip) {
1743 case TULIP_CHIP_DM9102:
1744 case TULIP_CHIP_DM9102A:
1745 sc->sc_busmode = 0;
1746 break;
1747
1748 default:
1749 /* Nothing. */
1750 break;
1751 }
1752
1753 TULIP_WRITE(sc, CSR_BUSMODE, sc->sc_busmode);
1754
1755 /*
1756 * Initialize the OPMODE register. We don't write it until
1757 * we're ready to begin the transmit and receive processes.
1758 *
1759 * Media-related OPMODE bits are set in the media callbacks
1760 * for each specific chip/board.
1761 */
1762 sc->sc_opmode |= OPMODE_SR | OPMODE_ST |
1763 sc->sc_txth[sc->sc_txthresh].txth_opmode;
1764
1765 /*
1766 * Magical mystery initialization on the Macronix chips.
1767 * The MX98713 uses its own magic value, the rest share
1768 * a common one.
1769 */
1770 switch (sc->sc_chip) {
1771 case TULIP_CHIP_MX98713:
1772 TULIP_WRITE(sc, CSR_PMAC_TOR, PMAC_TOR_98713);
1773 break;
1774
1775 case TULIP_CHIP_MX98713A:
1776 case TULIP_CHIP_MX98715:
1777 case TULIP_CHIP_MX98715A:
1778 case TULIP_CHIP_MX98715AEC_X:
1779 case TULIP_CHIP_MX98725:
1780 TULIP_WRITE(sc, CSR_PMAC_TOR, PMAC_TOR_98715);
1781 break;
1782
1783 default:
1784 /* Nothing. */
1785 break;
1786 }
1787
1788 /*
1789 * Initialize the transmit descriptor ring.
1790 */
1791 memset(sc->sc_txdescs, 0, sizeof(sc->sc_txdescs));
1792 for (i = 0; i < TULIP_NTXDESC; i++) {
1793 struct tulip_desc *txd = &sc->sc_txdescs[i];
1794 txd->td_ctl = htole32(sc->sc_tdctl_ch);
1795 txd->td_bufaddr2 = htole32(TULIP_CDTXADDR(sc, TULIP_NEXTTX(i)));
1796 }
1797 sc->sc_txdescs[TULIP_NTXDESC - 1].td_ctl |= htole32(sc->sc_tdctl_er);
1798 TULIP_CDTXSYNC(sc, 0, TULIP_NTXDESC,
1799 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
1800 sc->sc_txfree = TULIP_NTXDESC;
1801 sc->sc_txnext = 0;
1802
1803 /*
1804 * Initialize the transmit job descriptors.
1805 */
1806 SIMPLEQ_INIT(&sc->sc_txfreeq);
1807 SIMPLEQ_INIT(&sc->sc_txdirtyq);
1808 for (i = 0; i < TULIP_TXQUEUELEN; i++) {
1809 txs = &sc->sc_txsoft[i];
1810 txs->txs_mbuf = NULL;
1811 SIMPLEQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
1812 }
1813
1814 /*
1815 * Initialize the receive descriptor and receive job
1816 * descriptor rings.
1817 */
1818 for (i = 0; i < TULIP_NRXDESC; i++) {
1819 rxs = &sc->sc_rxsoft[i];
1820 if (rxs->rxs_mbuf == NULL) {
1821 if ((error = tlp_add_rxbuf(sc, i)) != 0) {
1822 aprint_error_dev(sc->sc_dev,
1823 "unable to allocate or map rx "
1824 "buffer %d, error = %d\n", i, error);
1825 /*
1826 * XXX Should attempt to run with fewer receive
1827 * XXX buffers instead of just failing.
1828 */
1829 tlp_rxdrain(sc);
1830 goto out;
1831 }
1832 } else
1833 TULIP_INIT_RXDESC(sc, i);
1834 }
1835 sc->sc_rxptr = 0;
1836
1837 /*
1838 * Initialize the interrupt mask and enable interrupts.
1839 */
1840 /* normal interrupts */
1841 sc->sc_inten = STATUS_TI | STATUS_TU | STATUS_RI | STATUS_NIS;
1842
1843 /* abnormal interrupts */
1844 sc->sc_inten |= STATUS_TPS | STATUS_TJT | STATUS_UNF |
1845 STATUS_RU | STATUS_RPS | STATUS_RWT | STATUS_SE | STATUS_AIS;
1846
1847 sc->sc_rxint_mask = STATUS_RI|STATUS_RU|STATUS_RWT;
1848 sc->sc_txint_mask = STATUS_TI|STATUS_UNF|STATUS_TJT;
1849
1850 switch (sc->sc_chip) {
1851 case TULIP_CHIP_WB89C840F:
1852 /*
1853 * Clear bits that we don't want that happen to
1854 * overlap or don't exist.
1855 */
1856 sc->sc_inten &= ~(STATUS_WINB_REI|STATUS_RWT);
1857 break;
1858
1859 default:
1860 /* Nothing. */
1861 break;
1862 }
1863
1864 sc->sc_rxint_mask &= sc->sc_inten;
1865 sc->sc_txint_mask &= sc->sc_inten;
1866
1867 TULIP_WRITE(sc, CSR_INTEN, sc->sc_inten);
1868 TULIP_WRITE(sc, CSR_STATUS, 0xffffffff);
1869
1870 /*
1871 * Give the transmit and receive rings to the Tulip.
1872 */
1873 TULIP_WRITE(sc, CSR_TXLIST, TULIP_CDTXADDR(sc, sc->sc_txnext));
1874 TULIP_WRITE(sc, CSR_RXLIST, TULIP_CDRXADDR(sc, sc->sc_rxptr));
1875
1876 /*
1877 * On chips that do this differently, set the station address.
1878 */
1879 switch (sc->sc_chip) {
1880 case TULIP_CHIP_WB89C840F:
1881 {
1882 /* XXX Do this with stream writes? */
1883 bus_addr_t cpa = TULIP_CSR_OFFSET(sc, CSR_WINB_CPA0);
1884
1885 for (i = 0; i < ETHER_ADDR_LEN; i++) {
1886 bus_space_write_1(sc->sc_st, sc->sc_sh,
1887 cpa + i, CLLADDR(ifp->if_sadl)[i]);
1888 }
1889 break;
1890 }
1891
1892 case TULIP_CHIP_AL981:
1893 case TULIP_CHIP_AN983:
1894 case TULIP_CHIP_AN985:
1895 {
1896 uint32_t reg;
1897 const uint8_t *enaddr = CLLADDR(ifp->if_sadl);
1898
1899 reg = enaddr[0] |
1900 (enaddr[1] << 8) |
1901 (enaddr[2] << 16) |
1902 (enaddr[3] << 24);
1903 bus_space_write_4(sc->sc_st, sc->sc_sh, CSR_ADM_PAR0, reg);
1904
1905 reg = enaddr[4] |
1906 (enaddr[5] << 8);
1907 bus_space_write_4(sc->sc_st, sc->sc_sh, CSR_ADM_PAR1, reg);
1908 break;
1909 }
1910
1911 case TULIP_CHIP_AX88140:
1912 case TULIP_CHIP_AX88141:
1913 {
1914 uint32_t reg;
1915 const uint8_t *enaddr = CLLADDR(ifp->if_sadl);
1916
1917 reg = enaddr[0] |
1918 (enaddr[1] << 8) |
1919 (enaddr[2] << 16) |
1920 (enaddr[3] << 24);
1921 TULIP_WRITE(sc, CSR_AX_FILTIDX, AX_FILTIDX_PAR0);
1922 TULIP_WRITE(sc, CSR_AX_FILTDATA, reg);
1923
1924 reg = enaddr[4] | (enaddr[5] << 8);
1925 TULIP_WRITE(sc, CSR_AX_FILTIDX, AX_FILTIDX_PAR1);
1926 TULIP_WRITE(sc, CSR_AX_FILTDATA, reg);
1927 break;
1928 }
1929
1930 default:
1931 /* Nothing. */
1932 break;
1933 }
1934
1935 /*
1936 * Set the receive filter. This will start the transmit and
1937 * receive processes.
1938 */
1939 (*sc->sc_filter_setup)(sc);
1940
1941 /*
1942 * Set the current media.
1943 */
1944 (void) (*sc->sc_mediasw->tmsw_set)(sc);
1945
1946 /*
1947 * Start the receive process.
1948 */
1949 TULIP_WRITE(sc, CSR_RXPOLL, RXPOLL_RPD);
1950
1951 if (sc->sc_tick != NULL) {
1952 /* Start the one second clock. */
1953 callout_reset(&sc->sc_tick_callout, hz >> 3, sc->sc_tick, sc);
1954 }
1955
1956 /*
1957 * Note that the interface is now running.
1958 */
1959 ifp->if_flags |= IFF_RUNNING;
1960 ifp->if_flags &= ~IFF_OACTIVE;
1961 sc->sc_if_flags = ifp->if_flags;
1962
1963 out:
1964 if (error) {
1965 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1966 ifp->if_timer = 0;
1967 printf("%s: interface not running\n", device_xname(sc->sc_dev));
1968 }
1969 return (error);
1970}
1971
1972/*
1973 * tlp_enable:
1974 *
1975 * Enable the Tulip chip.
1976 */
1977static int
1978tlp_enable(struct tulip_softc *sc)
1979{
1980
1981 if (TULIP_IS_ENABLED(sc) == 0 && sc->sc_enable != NULL) {
1982 if ((*sc->sc_enable)(sc) != 0) {
1983 aprint_error_dev(sc->sc_dev, "device enable failed\n");
1984 return (EIO);
1985 }
1986 sc->sc_flags |= TULIPF_ENABLED;
1987 }
1988 return (0);
1989}
1990
1991/*
1992 * tlp_disable:
1993 *
1994 * Disable the Tulip chip.
1995 */
1996static void
1997tlp_disable(struct tulip_softc *sc)
1998{
1999
2000 if (TULIP_IS_ENABLED(sc) && sc->sc_disable != NULL) {
2001 (*sc->sc_disable)(sc);
2002 sc->sc_flags &= ~TULIPF_ENABLED;
2003 }
2004}
2005
2006/*
2007 * tlp_rxdrain:
2008 *
2009 * Drain the receive queue.
2010 */
2011static void
2012tlp_rxdrain(struct tulip_softc *sc)
2013{
2014 struct tulip_rxsoft *rxs;
2015 int i;
2016
2017 for (i = 0; i < TULIP_NRXDESC; i++) {
2018 rxs = &sc->sc_rxsoft[i];
2019 if (rxs->rxs_mbuf != NULL) {
2020 bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
2021 m_freem(rxs->rxs_mbuf);
2022 rxs->rxs_mbuf = NULL;
2023 }
2024 }
2025}
2026
2027/*
2028 * tlp_stop: [ ifnet interface function ]
2029 *
2030 * Stop transmission on the interface.
2031 */
2032static void
2033tlp_stop(struct ifnet *ifp, int disable)
2034{
2035 struct tulip_softc *sc = ifp->if_softc;
2036 struct tulip_txsoft *txs;
2037
2038 if (sc->sc_tick != NULL) {
2039 /* Stop the one second clock. */
2040 callout_stop(&sc->sc_tick_callout);
2041 }
2042
2043 if (sc->sc_flags & TULIPF_HAS_MII) {
2044 /* Down the MII. */
2045 mii_down(&sc->sc_mii);
2046 }
2047
2048 /* Disable interrupts. */
2049 TULIP_WRITE(sc, CSR_INTEN, 0);
2050
2051 /* Stop the transmit and receive processes. */
2052 sc->sc_opmode = 0;
2053 TULIP_WRITE(sc, CSR_OPMODE, 0);
2054 TULIP_WRITE(sc, CSR_RXLIST, 0);
2055 TULIP_WRITE(sc, CSR_TXLIST, 0);
2056
2057 /*
2058 * Release any queued transmit buffers.
2059 */
2060 while ((txs = SIMPLEQ_FIRST(&sc->sc_txdirtyq)) != NULL) {
2061 SIMPLEQ_REMOVE_HEAD(&sc->sc_txdirtyq, txs_q);
2062 if (txs->txs_mbuf != NULL) {
2063 bus_dmamap_unload(sc->sc_dmat, txs->txs_dmamap);
2064 m_freem(txs->txs_mbuf);
2065 txs->txs_mbuf = NULL;
2066 }
2067 SIMPLEQ_INSERT_TAIL(&sc->sc_txfreeq, txs, txs_q);
2068 }
2069
2070 sc->sc_flags &= ~(TULIPF_WANT_SETUP|TULIPF_DOING_SETUP);
2071
2072 /*
2073 * Mark the interface down and cancel the watchdog timer.
2074 */
2075 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2076 sc->sc_if_flags = ifp->if_flags;
2077 ifp->if_timer = 0;
2078
2079 /*
2080 * Reset the chip (needed on some flavors to actually disable it).
2081 */
2082 tlp_reset(sc);
2083
2084 if (disable) {
2085 tlp_rxdrain(sc);
2086 tlp_disable(sc);
2087 }
2088}
2089
2090#define SROM_EMIT(sc, x) \
2091do { \
2092 TULIP_WRITE((sc), CSR_MIIROM, (x)); \
2093 delay(2); \
2094} while (0)
2095
2096/*
2097 * tlp_srom_idle:
2098 *
2099 * Put the SROM in idle state.
2100 */
2101static void
2102tlp_srom_idle(struct tulip_softc *sc)
2103{
2104 uint32_t miirom;
2105 int i;
2106
2107 miirom = MIIROM_SR;
2108 SROM_EMIT(sc, miirom);
2109
2110 miirom |= MIIROM_RD;
2111 SROM_EMIT(sc, miirom);
2112
2113 miirom |= MIIROM_SROMCS;
2114 SROM_EMIT(sc, miirom);
2115
2116 SROM_EMIT(sc, miirom|MIIROM_SROMSK);
2117
2118 /* Strobe the clock 32 times. */
2119 for (i = 0; i < 32; i++) {
2120 SROM_EMIT(sc, miirom);
2121 SROM_EMIT(sc, miirom|MIIROM_SROMSK);
2122 }
2123
2124 SROM_EMIT(sc, miirom);
2125
2126 miirom &= ~MIIROM_SROMCS;
2127 SROM_EMIT(sc, miirom);
2128
2129 SROM_EMIT(sc, 0);
2130}
2131
2132/*
2133 * tlp_srom_size:
2134 *
2135 * Determine the number of address bits in the SROM.
2136 */
2137static int
2138tlp_srom_size(struct tulip_softc *sc)
2139{
2140 uint32_t miirom;
2141 int x;
2142
2143 /* Select the SROM. */
2144 miirom = MIIROM_SR;
2145 SROM_EMIT(sc, miirom);
2146
2147 miirom |= MIIROM_RD;
2148 SROM_EMIT(sc, miirom);
2149
2150 /* Send CHIP SELECT for one clock tick. */
2151 miirom |= MIIROM_SROMCS;
2152 SROM_EMIT(sc, miirom);
2153
2154 /* Shift in the READ opcode. */
2155 for (x = 3; x > 0; x--) {
2156 if (TULIP_SROM_OPC_READ & (1 << (x - 1)))
2157 miirom |= MIIROM_SROMDI;
2158 else
2159 miirom &= ~MIIROM_SROMDI;
2160 SROM_EMIT(sc, miirom);
2161 SROM_EMIT(sc, miirom|MIIROM_SROMSK);
2162 SROM_EMIT(sc, miirom);
2163 }
2164
2165 /* Shift in address and look for dummy 0 bit. */
2166 for (x = 1; x <= 12; x++) {
2167 miirom &= ~MIIROM_SROMDI;
2168 SROM_EMIT(sc, miirom);
2169 SROM_EMIT(sc, miirom|MIIROM_SROMSK);
2170 if (!TULIP_ISSET(sc, CSR_MIIROM, MIIROM_SROMDO))
2171 break;
2172 SROM_EMIT(sc, miirom);
2173 }
2174
2175 /* Clear CHIP SELECT. */
2176 miirom &= ~MIIROM_SROMCS;
2177 SROM_EMIT(sc, miirom);
2178
2179 /* Deselect the SROM. */
2180 SROM_EMIT(sc, 0);
2181
2182 if (x < 4 || x > 12) {
2183 aprint_debug_dev(sc->sc_dev, "broken MicroWire interface "
2184 "detected; setting SROM size to 1Kb\n");
2185 return (6);
2186 } else {
2187 if (tlp_srom_debug)
2188 printf("%s: SROM size is 2^%d*16 bits (%d bytes)\n",
2189 device_xname(sc->sc_dev), x, (1 << (x + 4)) >> 3);
2190 return (x);
2191 }
2192}
2193
2194/*
2195 * tlp_read_srom:
2196 *
2197 * Read the Tulip SROM.
2198 */
2199int
2200tlp_read_srom(struct tulip_softc *sc)
2201{
2202 int size;
2203 uint32_t miirom;
2204 uint16_t datain;
2205 int i, x;
2206
2207 tlp_srom_idle(sc);
2208
2209 sc->sc_srom_addrbits = tlp_srom_size(sc);
2210 if (sc->sc_srom_addrbits == 0)
2211 return (0);
2212 size = TULIP_ROM_SIZE(sc->sc_srom_addrbits);
2213 sc->sc_srom = malloc(size, M_DEVBUF, M_NOWAIT);
2214
2215 /* Select the SROM. */
2216 miirom = MIIROM_SR;
2217 SROM_EMIT(sc, miirom);
2218
2219 miirom |= MIIROM_RD;
2220 SROM_EMIT(sc, miirom);
2221
2222 for (i = 0; i < size; i += 2) {
2223 /* Send CHIP SELECT for one clock tick. */
2224 miirom |= MIIROM_SROMCS;
2225 SROM_EMIT(sc, miirom);
2226
2227 /* Shift in the READ opcode. */
2228 for (x = 3; x > 0; x--) {
2229 if (TULIP_SROM_OPC_READ & (1 << (x - 1)))
2230 miirom |= MIIROM_SROMDI;
2231 else
2232 miirom &= ~MIIROM_SROMDI;
2233 SROM_EMIT(sc, miirom);
2234 SROM_EMIT(sc, miirom|MIIROM_SROMSK);
2235 SROM_EMIT(sc, miirom);
2236 }
2237
2238 /* Shift in address. */
2239 for (x = sc->sc_srom_addrbits; x > 0; x--) {
2240 if (i & (1 << x))
2241 miirom |= MIIROM_SROMDI;
2242 else
2243 miirom &= ~MIIROM_SROMDI;
2244 SROM_EMIT(sc, miirom);
2245 SROM_EMIT(sc, miirom|MIIROM_SROMSK);
2246 SROM_EMIT(sc, miirom);
2247 }
2248
2249 /* Shift out data. */
2250 miirom &= ~MIIROM_SROMDI;
2251 datain = 0;
2252 for (x = 16; x > 0; x--) {
2253 SROM_EMIT(sc, miirom|MIIROM_SROMSK);
2254 if (TULIP_ISSET(sc, CSR_MIIROM, MIIROM_SROMDO))
2255 datain |= (1 << (x - 1));
2256 SROM_EMIT(sc, miirom);
2257 }
2258 sc->sc_srom[i] = datain & 0xff;
2259 sc->sc_srom[i + 1] = datain >> 8;
2260
2261 /* Clear CHIP SELECT. */
2262 miirom &= ~MIIROM_SROMCS;
2263 SROM_EMIT(sc, miirom);
2264 }
2265
2266 /* Deselect the SROM. */
2267 SROM_EMIT(sc, 0);
2268
2269 /* ...and idle it. */
2270 tlp_srom_idle(sc);
2271
2272 if (tlp_srom_debug) {
2273 printf("SROM CONTENTS:");
2274 for (i = 0; i < size; i++) {
2275 if ((i % 8) == 0)
2276 printf("\n\t");
2277 printf("0x%02x ", sc->sc_srom[i]);
2278 }
2279 printf("\n");
2280 }
2281
2282 return (1);
2283}
2284
2285#undef SROM_EMIT
2286
2287/*
2288 * tlp_add_rxbuf:
2289 *
2290 * Add a receive buffer to the indicated descriptor.
2291 */
2292static int
2293tlp_add_rxbuf(struct tulip_softc *sc, int idx)
2294{
2295 struct tulip_rxsoft *rxs = &sc->sc_rxsoft[idx];
2296 struct mbuf *m;
2297 int error;
2298
2299 MGETHDR(m, M_DONTWAIT, MT_DATA);
2300 if (m == NULL)
2301 return (ENOBUFS);
2302
2303 MCLAIM(m, &sc->sc_ethercom.ec_rx_mowner);
2304 MCLGET(m, M_DONTWAIT);
2305 if ((m->m_flags & M_EXT) == 0) {
2306 m_freem(m);
2307 return (ENOBUFS);
2308 }
2309
2310 if (rxs->rxs_mbuf != NULL)
2311 bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
2312
2313 rxs->rxs_mbuf = m;
2314
2315 error = bus_dmamap_load(sc->sc_dmat, rxs->rxs_dmamap,
2316 m->m_ext.ext_buf, m->m_ext.ext_size, NULL,
2317 BUS_DMA_READ|BUS_DMA_NOWAIT);
2318 if (error) {
2319 aprint_error_dev(sc->sc_dev,
2320 "can't load rx DMA map %d, error = %d\n", idx, error);
2321 panic("tlp_add_rxbuf"); /* XXX */
2322 }
2323
2324 bus_dmamap_sync(sc->sc_dmat, rxs->rxs_dmamap, 0,
2325 rxs->rxs_dmamap->dm_mapsize, BUS_DMASYNC_PREREAD);
2326
2327 TULIP_INIT_RXDESC(sc, idx);
2328
2329 return (0);
2330}
2331
2332/*
2333 * tlp_srom_crcok:
2334 *
2335 * Check the CRC of the Tulip SROM.
2336 */
2337int
2338tlp_srom_crcok(const uint8_t *romdata)
2339{
2340 uint32_t crc;
2341
2342 crc = ether_crc32_le(romdata, TULIP_ROM_CRC32_CHECKSUM);
2343 crc = (crc & 0xffff) ^ 0xffff;
2344 if (crc == TULIP_ROM_GETW(romdata, TULIP_ROM_CRC32_CHECKSUM))
2345 return (1);
2346
2347 /*
2348 * Try an alternate checksum.
2349 */
2350 crc = ether_crc32_le(romdata, TULIP_ROM_CRC32_CHECKSUM1);
2351 crc = (crc & 0xffff) ^ 0xffff;
2352 if (crc == TULIP_ROM_GETW(romdata, TULIP_ROM_CRC32_CHECKSUM1))
2353 return (1);
2354
2355 return (0);
2356}
2357
2358/*
2359 * tlp_isv_srom:
2360 *
2361 * Check to see if the SROM is in the new standardized format.
2362 */
2363int
2364tlp_isv_srom(const uint8_t *romdata)
2365{
2366 int i;
2367 uint16_t cksum;
2368
2369 if (tlp_srom_crcok(romdata)) {
2370 /*
2371 * SROM CRC checks out; must be in the new format.
2372 */
2373 return (1);
2374 }
2375
2376 cksum = TULIP_ROM_GETW(romdata, TULIP_ROM_CRC32_CHECKSUM);
2377 if (cksum == 0xffff || cksum == 0) {
2378 /*
2379 * No checksum present. Check the SROM ID; 18 bytes of 0
2380 * followed by 1 (version) followed by the number of
2381 * adapters which use this SROM (should be non-zero).
2382 */
2383 for (i = 0; i < TULIP_ROM_SROM_FORMAT_VERION; i++) {
2384 if (romdata[i] != 0)
2385 return (0);
2386 }
2387 if (romdata[TULIP_ROM_SROM_FORMAT_VERION] != 1)
2388 return (0);
2389 if (romdata[TULIP_ROM_CHIP_COUNT] == 0)
2390 return (0);
2391 return (1);
2392 }
2393
2394 return (0);
2395}
2396
2397/*
2398 * tlp_isv_srom_enaddr:
2399 *
2400 * Get the Ethernet address from an ISV SROM.
2401 */
2402int
2403tlp_isv_srom_enaddr(struct tulip_softc *sc, uint8_t *enaddr)
2404{
2405 int i, devcnt;
2406
2407 if (tlp_isv_srom(sc->sc_srom) == 0)
2408 return (0);
2409
2410 devcnt = sc->sc_srom[TULIP_ROM_CHIP_COUNT];
2411 for (i = 0; i < devcnt; i++) {
2412 if (sc->sc_srom[TULIP_ROM_CHIP_COUNT] == 1)
2413 break;
2414 if (sc->sc_srom[TULIP_ROM_CHIPn_DEVICE_NUMBER(i)] ==
2415 sc->sc_devno)
2416 break;
2417 }
2418
2419 if (i == devcnt)
2420 return (0);
2421
2422 memcpy(enaddr, &sc->sc_srom[TULIP_ROM_IEEE_NETWORK_ADDRESS],
2423 ETHER_ADDR_LEN);
2424 enaddr[5] += i;
2425
2426 return (1);
2427}
2428
2429/*
2430 * tlp_parse_old_srom:
2431 *
2432 * Parse old-format SROMs.
2433 *
2434 * This routine is largely lifted from Matt Thomas's `de' driver.
2435 */
2436int
2437tlp_parse_old_srom(struct tulip_softc *sc, uint8_t *enaddr)
2438{
2439 static const uint8_t testpat[] =
2440 { 0xff, 0, 0x55, 0xaa, 0xff, 0, 0x55, 0xaa };
2441 int i;
2442 uint32_t cksum;
2443
2444 if (memcmp(&sc->sc_srom[0], &sc->sc_srom[16], 8) != 0) {
2445 /*
2446 * Phobos G100 interfaces have the address at
2447 * offsets 0 and 20, but each pair of bytes is
2448 * swapped.
2449 */
2450 if (sc->sc_srom_addrbits == 6 &&
2451 sc->sc_srom[1] == 0x00 &&
2452 sc->sc_srom[0] == 0x60 &&
2453 sc->sc_srom[3] == 0xf5 &&
2454 memcmp(&sc->sc_srom[0], &sc->sc_srom[20], 6) == 0) {
2455 for (i = 0; i < 6; i += 2) {
2456 enaddr[i] = sc->sc_srom[i + 1];
2457 enaddr[i + 1] = sc->sc_srom[i];
2458 }
2459 return (1);
2460 }
2461
2462 /*
2463 * Phobos G130/G160 interfaces have the address at
2464 * offsets 20 and 84, but each pair of bytes is
2465 * swapped.
2466 */
2467 if (sc->sc_srom_addrbits == 6 &&
2468 sc->sc_srom[21] == 0x00 &&
2469 sc->sc_srom[20] == 0x60 &&
2470 sc->sc_srom[23] == 0xf5 &&
2471 memcmp(&sc->sc_srom[20], &sc->sc_srom[84], 6) == 0) {
2472 for (i = 0; i < 6; i += 2) {
2473 enaddr[i] = sc->sc_srom[20 + i + 1];
2474 enaddr[i + 1] = sc->sc_srom[20 + i];
2475 }
2476 return (1);
2477 }
2478
2479 /*
2480 * Cobalt Networks interfaces simply have the address
2481 * in the first six bytes. The rest is zeroed out
2482 * on some models, but others contain unknown data.
2483 */
2484 if (sc->sc_srom[0] == 0x00 &&
2485 sc->sc_srom[1] == 0x10 &&
2486 sc->sc_srom[2] == 0xe0) {
2487 memcpy(enaddr, sc->sc_srom, ETHER_ADDR_LEN);
2488 return (1);
2489 }
2490
2491 /*
2492 * Some vendors (e.g. ZNYX) don't use the standard
2493 * DEC Address ROM format, but rather just have an
2494 * Ethernet address in the first 6 bytes, maybe a
2495 * 2 byte checksum, and then all 0xff's.
2496 */
2497 for (i = 8; i < 32; i++) {
2498 if (sc->sc_srom[i] != 0xff &&
2499 sc->sc_srom[i] != 0)
2500 return (0);
2501 }
2502
2503 /*
2504 * Sanity check the Ethernet address:
2505 *
2506 * - Make sure it's not multicast or locally
2507 * assigned
2508 * - Make sure it has a non-0 OUI
2509 */
2510 if (sc->sc_srom[0] & 3)
2511 return (0);
2512 if (sc->sc_srom[0] == 0 && sc->sc_srom[1] == 0 &&
2513 sc->sc_srom[2] == 0)
2514 return (0);
2515
2516 memcpy(enaddr, sc->sc_srom, ETHER_ADDR_LEN);
2517 return (1);
2518 }
2519
2520 /*
2521 * Standard DEC Address ROM test.
2522 */
2523
2524 if (memcmp(&sc->sc_srom[24], testpat, 8) != 0)
2525 return (0);
2526
2527 for (i = 0; i < 8; i++) {
2528 if (sc->sc_srom[i] != sc->sc_srom[15 - i])
2529 return (0);
2530 }
2531
2532 memcpy(enaddr, sc->sc_srom, ETHER_ADDR_LEN);
2533
2534 cksum = *(uint16_t *) &enaddr[0];
2535
2536 cksum <<= 1;
2537 if (cksum > 0xffff)
2538 cksum -= 0xffff;
2539
2540 cksum += *(uint16_t *) &enaddr[2];
2541 if (cksum > 0xffff)
2542 cksum -= 0xffff;
2543
2544 cksum <<= 1;
2545 if (cksum > 0xffff)
2546 cksum -= 0xffff;
2547
2548 cksum += *(uint16_t *) &enaddr[4];
2549 if (cksum >= 0xffff)
2550 cksum -= 0xffff;
2551
2552 if (cksum != *(uint16_t *) &sc->sc_srom[6])
2553 return (0);
2554
2555 return (1);
2556}
2557
2558/*
2559 * tlp_filter_setup:
2560 *
2561 * Set the Tulip's receive filter.
2562 */
2563static void
2564tlp_filter_setup(struct tulip_softc *sc)
2565{
2566 struct ethercom *ec = &sc->sc_ethercom;
2567 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
2568 struct ether_multi *enm;
2569 struct ether_multistep step;
2570 volatile uint32_t *sp;
2571 struct tulip_txsoft *txs;
2572 struct tulip_desc *txd;
2573 uint8_t enaddr[ETHER_ADDR_LEN];
2574 uint32_t hash, hashsize;
2575 int cnt, nexttx;
2576
2577 DPRINTF(sc, ("%s: tlp_filter_setup: sc_flags 0x%08x\n",
2578 device_xname(sc->sc_dev), sc->sc_flags));
2579
2580 memcpy(enaddr, CLLADDR(ifp->if_sadl), ETHER_ADDR_LEN);
2581
2582 /*
2583 * If there are transmissions pending, wait until they have
2584 * completed.
2585 */
2586 if (! SIMPLEQ_EMPTY(&sc->sc_txdirtyq) ||
2587 (sc->sc_flags & TULIPF_DOING_SETUP) != 0) {
2588 sc->sc_flags |= TULIPF_WANT_SETUP;
2589 DPRINTF(sc, ("%s: tlp_filter_setup: deferring\n",
2590 device_xname(sc->sc_dev)));
2591 return;
2592 }
2593 sc->sc_flags &= ~TULIPF_WANT_SETUP;
2594
2595 switch (sc->sc_chip) {
2596 case TULIP_CHIP_82C115:
2597 hashsize = TULIP_PNICII_HASHSIZE;
2598 break;
2599
2600 default:
2601 hashsize = TULIP_MCHASHSIZE;
2602 }
2603
2604 /*
2605 * If we're running, idle the transmit and receive engines. If
2606 * we're NOT running, we're being called from tlp_init(), and our
2607 * writing OPMODE will start the transmit and receive processes
2608 * in motion.
2609 */
2610 if (ifp->if_flags & IFF_RUNNING)
2611 tlp_idle(sc, OPMODE_ST|OPMODE_SR);
2612
2613 sc->sc_opmode &= ~(OPMODE_PR|OPMODE_PM);
2614
2615 if (ifp->if_flags & IFF_PROMISC) {
2616 sc->sc_opmode |= OPMODE_PR;
2617 goto allmulti;
2618 }
2619
2620 /*
2621 * Try Perfect filtering first.
2622 */
2623
2624 sc->sc_filtmode = TDCTL_Tx_FT_PERFECT;
2625 sp = TULIP_CDSP(sc);
2626 memset(TULIP_CDSP(sc), 0, TULIP_SETUP_PACKET_LEN);
2627 cnt = 0;
2628 ETHER_FIRST_MULTI(step, ec, enm);
2629 while (enm != NULL) {
2630 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
2631 /*
2632 * We must listen to a range of multicast addresses.
2633 * For now, just accept all multicasts, rather than
2634 * trying to set only those filter bits needed to match
2635 * the range. (At this time, the only use of address
2636 * ranges is for IP multicast routing, for which the
2637 * range is big enough to require all bits set.)
2638 */
2639 goto allmulti;
2640 }
2641 if (cnt == (TULIP_MAXADDRS - 2)) {
2642 /*
2643 * We already have our multicast limit (still need
2644 * our station address and broadcast). Go to
2645 * Hash-Perfect mode.
2646 */
2647 goto hashperfect;
2648 }
2649 cnt++;
2650 *sp++ = htole32(TULIP_SP_FIELD(enm->enm_addrlo, 0));
2651 *sp++ = htole32(TULIP_SP_FIELD(enm->enm_addrlo, 1));
2652 *sp++ = htole32(TULIP_SP_FIELD(enm->enm_addrlo, 2));
2653 ETHER_NEXT_MULTI(step, enm);
2654 }
2655
2656 if (ifp->if_flags & IFF_BROADCAST) {
2657 /* ...and the broadcast address. */
2658 cnt++;
2659 *sp++ = htole32(TULIP_SP_FIELD_C(0xff, 0xff));
2660 *sp++ = htole32(TULIP_SP_FIELD_C(0xff, 0xff));
2661 *sp++ = htole32(TULIP_SP_FIELD_C(0xff, 0xff));
2662 }
2663
2664 /* Pad the rest with our station address. */
2665 for (; cnt < TULIP_MAXADDRS; cnt++) {
2666 *sp++ = htole32(TULIP_SP_FIELD(enaddr, 0));
2667 *sp++ = htole32(TULIP_SP_FIELD(enaddr, 1));
2668 *sp++ = htole32(TULIP_SP_FIELD(enaddr, 2));
2669 }
2670 ifp->if_flags &= ~IFF_ALLMULTI;
2671 goto setit;
2672
2673 hashperfect:
2674 /*
2675 * Try Hash-Perfect mode.
2676 */
2677
2678 /*
2679 * Some 21140 chips have broken Hash-Perfect modes. On these
2680 * chips, we simply use Hash-Only mode, and put our station
2681 * address into the filter.
2682 */
2683 if (sc->sc_chip == TULIP_CHIP_21140)
2684 sc->sc_filtmode = TDCTL_Tx_FT_HASHONLY;
2685 else
2686 sc->sc_filtmode = TDCTL_Tx_FT_HASH;
2687 sp = TULIP_CDSP(sc);
2688 memset(TULIP_CDSP(sc), 0, TULIP_SETUP_PACKET_LEN);
2689 ETHER_FIRST_MULTI(step, ec, enm);
2690 while (enm != NULL) {
2691 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
2692 /*
2693 * We must listen to a range of multicast addresses.
2694 * For now, just accept all multicasts, rather than
2695 * trying to set only those filter bits needed to match
2696 * the range. (At this time, the only use of address
2697 * ranges is for IP multicast routing, for which the
2698 * range is big enough to require all bits set.)
2699 */
2700 goto allmulti;
2701 }
2702 hash = tlp_mchash(enm->enm_addrlo, hashsize);
2703 sp[hash >> 4] |= htole32(1 << (hash & 0xf));
2704 ETHER_NEXT_MULTI(step, enm);
2705 }
2706
2707 if (ifp->if_flags & IFF_BROADCAST) {
2708 /* ...and the broadcast address. */
2709 hash = tlp_mchash(etherbroadcastaddr, hashsize);
2710 sp[hash >> 4] |= htole32(1 << (hash & 0xf));
2711 }
2712
2713 if (sc->sc_filtmode == TDCTL_Tx_FT_HASHONLY) {
2714 /* ...and our station address. */
2715 hash = tlp_mchash(enaddr, hashsize);
2716 sp[hash >> 4] |= htole32(1 << (hash & 0xf));
2717 } else {
2718 /*
2719 * Hash-Perfect mode; put our station address after
2720 * the hash table.
2721 */
2722 sp[39] = htole32(TULIP_SP_FIELD(enaddr, 0));
2723 sp[40] = htole32(TULIP_SP_FIELD(enaddr, 1));
2724 sp[41] = htole32(TULIP_SP_FIELD(enaddr, 2));
2725 }
2726 ifp->if_flags &= ~IFF_ALLMULTI;
2727 goto setit;
2728
2729 allmulti:
2730 /*
2731 * Use Perfect filter mode. First address is the broadcast address,
2732 * and pad the rest with our station address. We'll set Pass-all-
2733 * multicast in OPMODE below.
2734 */
2735 sc->sc_filtmode = TDCTL_Tx_FT_PERFECT;
2736 sp = TULIP_CDSP(sc);
2737 memset(TULIP_CDSP(sc), 0, TULIP_SETUP_PACKET_LEN);
2738 cnt = 0;
2739 if (ifp->if_flags & IFF_BROADCAST) {
2740 cnt++;
2741 *sp++ = htole32(TULIP_SP_FIELD_C(0xff, 0xff));
2742 *sp++ = htole32(TULIP_SP_FIELD_C(0xff, 0xff));
2743 *sp++ = htole32(TULIP_SP_FIELD_C(0xff, 0xff));
2744 }
2745 for (; cnt < TULIP_MAXADDRS; cnt++) {
2746 *sp++ = htole32(TULIP_SP_FIELD(enaddr, 0));
2747 *sp++ = htole32(TULIP_SP_FIELD(enaddr, 1));
2748 *sp++ = htole32(TULIP_SP_FIELD(enaddr, 2));
2749 }
2750 ifp->if_flags |= IFF_ALLMULTI;
2751
2752 setit:
2753 if (ifp->if_flags & IFF_ALLMULTI)
2754 sc->sc_opmode |= OPMODE_PM;
2755
2756 /* Sync the setup packet buffer. */
2757 TULIP_CDSPSYNC(sc, BUS_DMASYNC_PREWRITE);
2758
2759 /*
2760 * Fill in the setup packet descriptor.
2761 */
2762 txs = SIMPLEQ_FIRST(&sc->sc_txfreeq);
2763
2764 txs->txs_firstdesc = sc->sc_txnext;
2765 txs->txs_lastdesc = sc->sc_txnext;
2766 txs->txs_ndescs = 1;
2767 txs->txs_mbuf = NULL;
2768
2769 nexttx = sc->sc_txnext;
2770 txd = &sc->sc_txdescs[nexttx];
2771 txd->td_status = 0;
2772 txd->td_bufaddr1 = htole32(TULIP_CDSPADDR(sc));
2773 txd->td_ctl = htole32((TULIP_SETUP_PACKET_LEN << TDCTL_SIZE1_SHIFT) |
2774 sc->sc_filtmode | TDCTL_Tx_SET | sc->sc_setup_fsls |
2775 TDCTL_Tx_IC | sc->sc_tdctl_ch |
2776 (nexttx == (TULIP_NTXDESC - 1) ? sc->sc_tdctl_er : 0));
2777 TULIP_CDTXSYNC(sc, nexttx, 1,
2778 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
2779
2780#ifdef TLP_DEBUG
2781 if (ifp->if_flags & IFF_DEBUG) {
2782 printf(" filter_setup %p transmit chain:\n", txs);
2783 printf(" descriptor %d:\n", nexttx);
2784 printf(" td_status: 0x%08x\n", le32toh(txd->td_status));
2785 printf(" td_ctl: 0x%08x\n", le32toh(txd->td_ctl));
2786 printf(" td_bufaddr1: 0x%08x\n",
2787 le32toh(txd->td_bufaddr1));
2788 printf(" td_bufaddr2: 0x%08x\n",
2789 le32toh(txd->td_bufaddr2));
2790 }
2791#endif
2792
2793 txd->td_status = htole32(TDSTAT_OWN);
2794 TULIP_CDTXSYNC(sc, nexttx, 1,
2795 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
2796
2797 /* Advance the tx pointer. */
2798 sc->sc_txfree -= 1;
2799 sc->sc_txnext = TULIP_NEXTTX(nexttx);
2800
2801 SIMPLEQ_REMOVE_HEAD(&sc->sc_txfreeq, txs_q);
2802 SIMPLEQ_INSERT_TAIL(&sc->sc_txdirtyq, txs, txs_q);
2803
2804 /*
2805 * Set the OPMODE register. This will also resume the
2806 * transmit process we idled above.
2807 */
2808 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
2809
2810 sc->sc_flags |= TULIPF_DOING_SETUP;
2811
2812 /*
2813 * Kick the transmitter; this will cause the Tulip to
2814 * read the setup descriptor.
2815 */
2816 /* XXX USE AUTOPOLLING? */
2817 TULIP_WRITE(sc, CSR_TXPOLL, TXPOLL_TPD);
2818
2819 /* Set up a watchdog timer in case the chip flakes out. */
2820 ifp->if_timer = 5;
2821
2822 DPRINTF(sc, ("%s: tlp_filter_setup: returning\n",
2823 device_xname(sc->sc_dev)));
2824}
2825
2826/*
2827 * tlp_winb_filter_setup:
2828 *
2829 * Set the Winbond 89C840F's receive filter.
2830 */
2831static void
2832tlp_winb_filter_setup(struct tulip_softc *sc)
2833{
2834 struct ethercom *ec = &sc->sc_ethercom;
2835 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
2836 struct ether_multi *enm;
2837 struct ether_multistep step;
2838 uint32_t hash, mchash[2];
2839
2840 DPRINTF(sc, ("%s: tlp_winb_filter_setup: sc_flags 0x%08x\n",
2841 device_xname(sc->sc_dev), sc->sc_flags));
2842
2843 sc->sc_opmode &= ~(OPMODE_WINB_APP|OPMODE_WINB_AMP|OPMODE_WINB_ABP);
2844
2845 if (ifp->if_flags & IFF_MULTICAST)
2846 sc->sc_opmode |= OPMODE_WINB_AMP;
2847
2848 if (ifp->if_flags & IFF_BROADCAST)
2849 sc->sc_opmode |= OPMODE_WINB_ABP;
2850
2851 if (ifp->if_flags & IFF_PROMISC) {
2852 sc->sc_opmode |= OPMODE_WINB_APP;
2853 goto allmulti;
2854 }
2855
2856 mchash[0] = mchash[1] = 0;
2857
2858 ETHER_FIRST_MULTI(step, ec, enm);
2859 while (enm != NULL) {
2860 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
2861 /*
2862 * We must listen to a range of multicast addresses.
2863 * For now, just accept all multicasts, rather than
2864 * trying to set only those filter bits needed to match
2865 * the range. (At this time, the only use of address
2866 * ranges is for IP multicast routing, for which the
2867 * range is big enough to require all bits set.)
2868 */
2869 goto allmulti;
2870 }
2871
2872 /*
2873 * According to the FreeBSD `wb' driver, yes, you
2874 * really do invert the hash.
2875 */
2876 hash =
2877 (~(ether_crc32_le(enm->enm_addrlo, ETHER_ADDR_LEN) >> 26))
2878 & 0x3f;
2879 mchash[hash >> 5] |= 1 << (hash & 0x1f);
2880 ETHER_NEXT_MULTI(step, enm);
2881 }
2882 ifp->if_flags &= ~IFF_ALLMULTI;
2883 goto setit;
2884
2885 allmulti:
2886 ifp->if_flags |= IFF_ALLMULTI;
2887 mchash[0] = mchash[1] = 0xffffffff;
2888
2889 setit:
2890 TULIP_WRITE(sc, CSR_WINB_CMA0, mchash[0]);
2891 TULIP_WRITE(sc, CSR_WINB_CMA1, mchash[1]);
2892 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
2893 DPRINTF(sc, ("%s: tlp_winb_filter_setup: returning\n",
2894 device_xname(sc->sc_dev)));
2895}
2896
2897/*
2898 * tlp_al981_filter_setup:
2899 *
2900 * Set the ADMtek AL981's receive filter.
2901 */
2902static void
2903tlp_al981_filter_setup(struct tulip_softc *sc)
2904{
2905 struct ethercom *ec = &sc->sc_ethercom;
2906 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
2907 struct ether_multi *enm;
2908 struct ether_multistep step;
2909 uint32_t hash, mchash[2];
2910
2911 /*
2912 * If the chip is running, we need to reset the interface,
2913 * and will revisit here (with IFF_RUNNING) clear. The
2914 * chip seems to really not like to have its multicast
2915 * filter programmed without a reset.
2916 */
2917 if (ifp->if_flags & IFF_RUNNING) {
2918 (void) tlp_init(ifp);
2919 return;
2920 }
2921
2922 DPRINTF(sc, ("%s: tlp_al981_filter_setup: sc_flags 0x%08x\n",
2923 device_xname(sc->sc_dev), sc->sc_flags));
2924
2925 sc->sc_opmode &= ~(OPMODE_PR|OPMODE_PM);
2926
2927 if (ifp->if_flags & IFF_PROMISC) {
2928 sc->sc_opmode |= OPMODE_PR;
2929 goto allmulti;
2930 }
2931
2932 mchash[0] = mchash[1] = 0;
2933
2934 ETHER_FIRST_MULTI(step, ec, enm);
2935 while (enm != NULL) {
2936 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
2937 /*
2938 * We must listen to a range of multicast addresses.
2939 * For now, just accept all multicasts, rather than
2940 * trying to set only those filter bits needed to match
2941 * the range. (At this time, the only use of address
2942 * ranges is for IP multicast routing, for which the
2943 * range is big enough to require all bits set.)
2944 */
2945 goto allmulti;
2946 }
2947
2948 hash = ether_crc32_le(enm->enm_addrlo, ETHER_ADDR_LEN) & 0x3f;
2949 mchash[hash >> 5] |= 1 << (hash & 0x1f);
2950 ETHER_NEXT_MULTI(step, enm);
2951 }
2952 ifp->if_flags &= ~IFF_ALLMULTI;
2953 goto setit;
2954
2955 allmulti:
2956 ifp->if_flags |= IFF_ALLMULTI;
2957 mchash[0] = mchash[1] = 0xffffffff;
2958
2959 setit:
2960 bus_space_write_4(sc->sc_st, sc->sc_sh, CSR_ADM_MAR0, mchash[0]);
2961 bus_space_write_4(sc->sc_st, sc->sc_sh, CSR_ADM_MAR1, mchash[1]);
2962 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
2963 DPRINTF(sc, ("%s: tlp_al981_filter_setup: returning\n",
2964 device_xname(sc->sc_dev)));
2965}
2966
2967/*
2968 * tlp_asix_filter_setup:
2969 *
2970 * Set the ASIX AX8814x recieve filter.
2971 */
2972static void
2973tlp_asix_filter_setup(struct tulip_softc *sc)
2974{
2975 struct ethercom *ec = &sc->sc_ethercom;
2976 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
2977 struct ether_multi *enm;
2978 struct ether_multistep step;
2979 uint32_t hash, mchash[2];
2980
2981 DPRINTF(sc, ("%s: tlp_asix_filter_setup: sc_flags 0x%08x\n",
2982 device_xname(sc->sc_dev), sc->sc_flags));
2983
2984 sc->sc_opmode &= ~(OPMODE_PM|OPMODE_AX_RB|OPMODE_PR);
2985
2986 if (ifp->if_flags & IFF_MULTICAST)
2987 sc->sc_opmode |= OPMODE_PM;
2988
2989 if (ifp->if_flags & IFF_BROADCAST)
2990 sc->sc_opmode |= OPMODE_AX_RB;
2991
2992 if (ifp->if_flags & IFF_PROMISC) {
2993 sc->sc_opmode |= OPMODE_PR;
2994 goto allmulti;
2995 }
2996
2997 mchash[0] = mchash[1] = 0;
2998
2999 ETHER_FIRST_MULTI(step, ec, enm);
3000 while (enm != NULL) {
3001 if (memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
3002 /*
3003 * We must listen to a range of multicast addresses.
3004 * For now, just accept all multicasts, rather than
3005 * trying to set only those filter bits needed to match
3006 * the range. (At this time, the only use of address
3007 * ranges is for IP multicast routing, for which the
3008 * range is big enough to require all bits set.)
3009 */
3010 goto allmulti;
3011 }
3012 hash = (ether_crc32_be(enm->enm_addrlo, ETHER_ADDR_LEN) >> 26)
3013 & 0x3f;
3014 if (hash < 32)
3015 mchash[0] |= (1 << hash);
3016 else
3017 mchash[1] |= (1 << (hash - 32));
3018 ETHER_NEXT_MULTI(step, enm);
3019 }
3020 ifp->if_flags &= ~IFF_ALLMULTI;
3021 goto setit;
3022
3023allmulti:
3024 ifp->if_flags |= IFF_ALLMULTI;
3025 mchash[0] = mchash[1] = 0xffffffff;
3026
3027setit:
3028 TULIP_WRITE(sc, CSR_AX_FILTIDX, AX_FILTIDX_MAR0);
3029 TULIP_WRITE(sc, CSR_AX_FILTDATA, mchash[0]);
3030 TULIP_WRITE(sc, CSR_AX_FILTIDX, AX_FILTIDX_MAR1);
3031 TULIP_WRITE(sc, CSR_AX_FILTDATA, mchash[1]);
3032 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
3033 DPRINTF(sc, ("%s: tlp_asix_filter_setup: returning\n",
3034 device_xname(sc->sc_dev)));
3035}
3036
3037
3038/*
3039 * tlp_idle:
3040 *
3041 * Cause the transmit and/or receive processes to go idle.
3042 */
3043void
3044tlp_idle(struct tulip_softc *sc, uint32_t bits)
3045{
3046 static const char * const tlp_tx_state_names[] = {
3047 "STOPPED",
3048 "RUNNING - FETCH",
3049 "RUNNING - WAIT",
3050 "RUNNING - READING",
3051 "-- RESERVED --",
3052 "RUNNING - SETUP",
3053 "SUSPENDED",
3054 "RUNNING - CLOSE",
3055 };
3056 static const char * const tlp_rx_state_names[] = {
3057 "STOPPED",
3058 "RUNNING - FETCH",
3059 "RUNNING - CHECK",
3060 "RUNNING - WAIT",
3061 "SUSPENDED",
3062 "RUNNING - CLOSE",
3063 "RUNNING - FLUSH",
3064 "RUNNING - QUEUE",
3065 };
3066 static const char * const dm9102_tx_state_names[] = {
3067 "STOPPED",
3068 "RUNNING - FETCH",
3069 "RUNNING - SETUP",
3070 "RUNNING - READING",
3071 "RUNNING - CLOSE - CLEAR OWNER",
3072 "RUNNING - WAIT",
3073 "RUNNING - CLOSE - WRITE STATUS",
3074 "SUSPENDED",
3075 };
3076 static const char * const dm9102_rx_state_names[] = {
3077 "STOPPED",
3078 "RUNNING - FETCH",
3079 "RUNNING - WAIT",
3080 "RUNNING - QUEUE",
3081 "RUNNING - CLOSE - CLEAR OWNER",
3082 "RUNNING - CLOSE - WRITE STATUS",
3083 "SUSPENDED",
3084 "RUNNING - FLUSH",
3085 };
3086
3087 const char * const *tx_state_names, * const *rx_state_names;
3088 uint32_t csr, ackmask = 0;
3089 int i;
3090
3091 switch (sc->sc_chip) {
3092 case TULIP_CHIP_DM9102:
3093 case TULIP_CHIP_DM9102A:
3094 tx_state_names = dm9102_tx_state_names;
3095 rx_state_names = dm9102_rx_state_names;
3096 break;
3097
3098 default:
3099 tx_state_names = tlp_tx_state_names;
3100 rx_state_names = tlp_rx_state_names;
3101 break;
3102 }
3103
3104 if (bits & OPMODE_ST)
3105 ackmask |= STATUS_TPS;
3106
3107 if (bits & OPMODE_SR)
3108 ackmask |= STATUS_RPS;
3109
3110 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode & ~bits);
3111
3112 for (i = 0; i < 1000; i++) {
3113 if (TULIP_ISSET(sc, CSR_STATUS, ackmask) == ackmask)
3114 break;
3115 delay(10);
3116 }
3117
3118 csr = TULIP_READ(sc, CSR_STATUS);
3119 if ((csr & ackmask) != ackmask) {
3120 if ((bits & OPMODE_ST) != 0 && (csr & STATUS_TPS) == 0 &&
3121 (csr & STATUS_TS) != STATUS_TS_STOPPED) {
3122 switch (sc->sc_chip) {
3123 case TULIP_CHIP_AX88140:
3124 case TULIP_CHIP_AX88141:
3125 /*
3126 * Filter the message out on noisy chips.
3127 */
3128 break;
3129 default:
3130 printf("%s: transmit process failed to idle: "
3131 "state %s\n", device_xname(sc->sc_dev),
3132 tx_state_names[(csr & STATUS_TS) >> 20]);
3133 }
3134 }
3135 if ((bits & OPMODE_SR) != 0 && (csr & STATUS_RPS) == 0 &&
3136 (csr & STATUS_RS) != STATUS_RS_STOPPED) {
3137 switch (sc->sc_chip) {
3138 case TULIP_CHIP_AN983:
3139 case TULIP_CHIP_AN985:
3140 case TULIP_CHIP_DM9102A:
3141 case TULIP_CHIP_RS7112:
3142 /*
3143 * Filter the message out on noisy chips.
3144 */
3145 break;
3146 default:
3147 printf("%s: receive process failed to idle: "
3148 "state %s\n", device_xname(sc->sc_dev),
3149 rx_state_names[(csr & STATUS_RS) >> 17]);
3150 }
3151 }
3152 }
3153 TULIP_WRITE(sc, CSR_STATUS, ackmask);
3154}
3155
3156/*****************************************************************************
3157 * Generic media support functions.
3158 *****************************************************************************/
3159
3160/*
3161 * tlp_mediastatus: [ifmedia interface function]
3162 *
3163 * Query the current media.
3164 */
3165void
3166tlp_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
3167{
3168 struct tulip_softc *sc = ifp->if_softc;
3169
3170 if (TULIP_IS_ENABLED(sc) == 0) {
3171 ifmr->ifm_active = IFM_ETHER | IFM_NONE;
3172 ifmr->ifm_status = 0;
3173 return;
3174 }
3175
3176 (*sc->sc_mediasw->tmsw_get)(sc, ifmr);
3177}
3178
3179/*
3180 * tlp_mediachange: [ifmedia interface function]
3181 *
3182 * Update the current media.
3183 */
3184int
3185tlp_mediachange(struct ifnet *ifp)
3186{
3187 struct tulip_softc *sc = ifp->if_softc;
3188
3189 if ((ifp->if_flags & IFF_UP) == 0)
3190 return (0);
3191 return ((*sc->sc_mediasw->tmsw_set)(sc));
3192}
3193
3194/*****************************************************************************
3195 * Support functions for MII-attached media.
3196 *****************************************************************************/
3197
3198/*
3199 * tlp_mii_tick:
3200 *
3201 * One second timer, used to tick the MII.
3202 */
3203static void
3204tlp_mii_tick(void *arg)
3205{
3206 struct tulip_softc *sc = arg;
3207 int s;
3208
3209 if (!device_is_active(sc->sc_dev))
3210 return;
3211
3212 s = splnet();
3213 mii_tick(&sc->sc_mii);
3214 splx(s);
3215
3216 callout_reset(&sc->sc_tick_callout, hz, sc->sc_tick, sc);
3217}
3218
3219/*
3220 * tlp_mii_statchg: [mii interface function]
3221 *
3222 * Callback from PHY when media changes.
3223 */
3224static void
3225tlp_mii_statchg(struct ifnet *ifp)
3226{
3227 struct tulip_softc *sc = ifp->if_softc;
3228
3229 /* Idle the transmit and receive processes. */
3230 tlp_idle(sc, OPMODE_ST|OPMODE_SR);
3231
3232 sc->sc_opmode &= ~(OPMODE_TTM|OPMODE_FD|OPMODE_HBD);
3233
3234 if (IFM_SUBTYPE(sc->sc_mii.mii_media_active) == IFM_10_T)
3235 sc->sc_opmode |= OPMODE_TTM;
3236 else
3237 sc->sc_opmode |= OPMODE_HBD;
3238
3239 if (sc->sc_mii.mii_media_active & IFM_FDX)
3240 sc->sc_opmode |= OPMODE_FD|OPMODE_HBD;
3241
3242 /*
3243 * Write new OPMODE bits. This also restarts the transmit
3244 * and receive processes.
3245 */
3246 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
3247}
3248
3249/*
3250 * tlp_winb_mii_statchg: [mii interface function]
3251 *
3252 * Callback from PHY when media changes. This version is
3253 * for the Winbond 89C840F, which has different OPMODE bits.
3254 */
3255static void
3256tlp_winb_mii_statchg(struct ifnet *ifp)
3257{
3258 struct tulip_softc *sc = ifp->if_softc;
3259
3260 /* Idle the transmit and receive processes. */
3261 tlp_idle(sc, OPMODE_ST|OPMODE_SR);
3262
3263 sc->sc_opmode &= ~(OPMODE_WINB_FES|OPMODE_FD);
3264
3265 if (IFM_SUBTYPE(sc->sc_mii.mii_media_active) == IFM_100_TX)
3266 sc->sc_opmode |= OPMODE_WINB_FES;
3267
3268 if (sc->sc_mii.mii_media_active & IFM_FDX)
3269 sc->sc_opmode |= OPMODE_FD;
3270
3271 /*
3272 * Write new OPMODE bits. This also restarts the transmit
3273 * and receive processes.
3274 */
3275 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
3276}
3277
3278/*
3279 * tlp_dm9102_mii_statchg: [mii interface function]
3280 *
3281 * Callback from PHY when media changes. This version is
3282 * for the DM9102.
3283 */
3284static void
3285tlp_dm9102_mii_statchg(struct ifnet *ifp)
3286{
3287 struct tulip_softc *sc = ifp->if_softc;
3288
3289 /*
3290 * Don't idle the transmit and receive processes, here. It
3291 * seems to fail, and just causes excess noise.
3292 */
3293 sc->sc_opmode &= ~(OPMODE_TTM|OPMODE_FD);
3294
3295 if (IFM_SUBTYPE(sc->sc_mii.mii_media_active) != IFM_100_TX)
3296 sc->sc_opmode |= OPMODE_TTM;
3297
3298 if (sc->sc_mii.mii_media_active & IFM_FDX)
3299 sc->sc_opmode |= OPMODE_FD;
3300
3301 /*
3302 * Write new OPMODE bits.
3303 */
3304 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
3305}
3306
3307/*
3308 * tlp_mii_getmedia:
3309 *
3310 * Callback from ifmedia to request current media status.
3311 */
3312static void
3313tlp_mii_getmedia(struct tulip_softc *sc, struct ifmediareq *ifmr)
3314{
3315
3316 mii_pollstat(&sc->sc_mii);
3317 ifmr->ifm_status = sc->sc_mii.mii_media_status;
3318 ifmr->ifm_active = sc->sc_mii.mii_media_active;
3319}
3320
3321/*
3322 * tlp_mii_setmedia:
3323 *
3324 * Callback from ifmedia to request new media setting.
3325 */
3326static int
3327tlp_mii_setmedia(struct tulip_softc *sc)
3328{
3329 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
3330 int rc;
3331
3332 if ((ifp->if_flags & IFF_UP) == 0)
3333 return 0;
3334 switch (sc->sc_chip) {
3335 case TULIP_CHIP_21142:
3336 case TULIP_CHIP_21143:
3337 /* Disable the internal Nway engine. */
3338 TULIP_WRITE(sc, CSR_SIATXRX, 0);
3339 break;
3340
3341 default:
3342 /* Nothing. */
3343 break;
3344 }
3345 if ((rc = mii_mediachg(&sc->sc_mii)) == ENXIO)
3346 return 0;
3347 return rc;
3348}
3349
3350/*
3351 * tlp_bitbang_mii_readreg:
3352 *
3353 * Read a PHY register via bit-bang'ing the MII.
3354 */
3355static int
3356tlp_bitbang_mii_readreg(device_t self, int phy, int reg)
3357{
3358 struct tulip_softc *sc = device_private(self);
3359
3360 return (mii_bitbang_readreg(self, sc->sc_bitbang_ops, phy, reg));
3361}
3362
3363/*
3364 * tlp_bitbang_mii_writereg:
3365 *
3366 * Write a PHY register via bit-bang'ing the MII.
3367 */
3368static void
3369tlp_bitbang_mii_writereg(device_t self, int phy, int reg, int val)
3370{
3371 struct tulip_softc *sc = device_private(self);
3372
3373 mii_bitbang_writereg(self, sc->sc_bitbang_ops, phy, reg, val);
3374}
3375
3376/*
3377 * tlp_sio_mii_bitbang_read:
3378 *
3379 * Read the MII serial port for the MII bit-bang module.
3380 */
3381static uint32_t
3382tlp_sio_mii_bitbang_read(device_t self)
3383{
3384 struct tulip_softc *sc = device_private(self);
3385
3386 return (TULIP_READ(sc, CSR_MIIROM));
3387}
3388
3389/*
3390 * tlp_sio_mii_bitbang_write:
3391 *
3392 * Write the MII serial port for the MII bit-bang module.
3393 */
3394static void
3395tlp_sio_mii_bitbang_write(device_t self, uint32_t val)
3396{
3397 struct tulip_softc *sc = device_private(self);
3398
3399 TULIP_WRITE(sc, CSR_MIIROM, val);
3400}
3401
3402/*
3403 * tlp_pnic_mii_readreg:
3404 *
3405 * Read a PHY register on the Lite-On PNIC.
3406 */
3407static int
3408tlp_pnic_mii_readreg(device_t self, int phy, int reg)
3409{
3410 struct tulip_softc *sc = device_private(self);
3411 uint32_t val;
3412 int i;
3413
3414 TULIP_WRITE(sc, CSR_PNIC_MII,
3415 PNIC_MII_MBO | PNIC_MII_RESERVED |
3416 PNIC_MII_READ | (phy << PNIC_MII_PHYSHIFT) |
3417 (reg << PNIC_MII_REGSHIFT));
3418
3419 for (i = 0; i < 1000; i++) {
3420 delay(10);
3421 val = TULIP_READ(sc, CSR_PNIC_MII);
3422 if ((val & PNIC_MII_BUSY) == 0) {
3423 if ((val & PNIC_MII_DATA) == PNIC_MII_DATA)
3424 return (0);
3425 else
3426 return (val & PNIC_MII_DATA);
3427 }
3428 }
3429 printf("%s: MII read timed out\n", device_xname(sc->sc_dev));
3430 return (0);
3431}
3432
3433/*
3434 * tlp_pnic_mii_writereg:
3435 *
3436 * Write a PHY register on the Lite-On PNIC.
3437 */
3438static void
3439tlp_pnic_mii_writereg(device_t self, int phy, int reg, int val)
3440{
3441 struct tulip_softc *sc = device_private(self);
3442 int i;
3443
3444 TULIP_WRITE(sc, CSR_PNIC_MII,
3445 PNIC_MII_MBO | PNIC_MII_RESERVED |
3446 PNIC_MII_WRITE | (phy << PNIC_MII_PHYSHIFT) |
3447 (reg << PNIC_MII_REGSHIFT) | val);
3448
3449 for (i = 0; i < 1000; i++) {
3450 delay(10);
3451 if (TULIP_ISSET(sc, CSR_PNIC_MII, PNIC_MII_BUSY) == 0)
3452 return;
3453 }
3454 printf("%s: MII write timed out\n", device_xname(sc->sc_dev));
3455}
3456
3457static const bus_addr_t tlp_al981_phy_regmap[] = {
3458 CSR_ADM_BMCR,
3459 CSR_ADM_BMSR,
3460 CSR_ADM_PHYIDR1,
3461 CSR_ADM_PHYIDR2,
3462 CSR_ADM_ANAR,
3463 CSR_ADM_ANLPAR,
3464 CSR_ADM_ANER,
3465
3466 CSR_ADM_XMC,
3467 CSR_ADM_XCIIS,
3468 CSR_ADM_XIE,
3469 CSR_ADM_100CTR,
3470};
3471static const int tlp_al981_phy_regmap_size = sizeof(tlp_al981_phy_regmap) /
3472 sizeof(tlp_al981_phy_regmap[0]);
3473
3474/*
3475 * tlp_al981_mii_readreg:
3476 *
3477 * Read a PHY register on the ADMtek AL981.
3478 */
3479static int
3480tlp_al981_mii_readreg(device_t self, int phy, int reg)
3481{
3482 struct tulip_softc *sc = device_private(self);
3483
3484 /* AL981 only has an internal PHY. */
3485 if (phy != 0)
3486 return (0);
3487
3488 if (reg >= tlp_al981_phy_regmap_size)
3489 return (0);
3490
3491 return (bus_space_read_4(sc->sc_st, sc->sc_sh,
3492 tlp_al981_phy_regmap[reg]) & 0xffff);
3493}
3494
3495/*
3496 * tlp_al981_mii_writereg:
3497 *
3498 * Write a PHY register on the ADMtek AL981.
3499 */
3500static void
3501tlp_al981_mii_writereg(device_t self, int phy, int reg, int val)
3502{
3503 struct tulip_softc *sc = device_private(self);
3504
3505 /* AL981 only has an internal PHY. */
3506 if (phy != 0)
3507 return;
3508
3509 if (reg >= tlp_al981_phy_regmap_size)
3510 return;
3511
3512 bus_space_write_4(sc->sc_st, sc->sc_sh,
3513 tlp_al981_phy_regmap[reg], val);
3514}
3515
3516/*****************************************************************************
3517 * Chip-specific pre-init and reset functions.
3518 *****************************************************************************/
3519
3520/*
3521 * tlp_2114x_preinit:
3522 *
3523 * Pre-init function shared by DECchip 21140, 21140A, 21142, and 21143.
3524 */
3525static void
3526tlp_2114x_preinit(struct tulip_softc *sc)
3527{
3528 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
3529 struct tulip_21x4x_media *tm = ife->ifm_aux;
3530
3531 /*
3532 * Whether or not we're in MII or SIA/SYM mode, the media info
3533 * contains the appropriate OPMODE bits.
3534 *
3535 * Also, we always set the Must-Be-One bit.
3536 */
3537 sc->sc_opmode |= OPMODE_MBO | tm->tm_opmode;
3538
3539 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
3540}
3541
3542/*
3543 * tlp_2114x_mii_preinit:
3544 *
3545 * Pre-init function shared by DECchip 21140, 21140A, 21142, and 21143.
3546 * This version is used by boards which only have MII and don't have
3547 * an ISV SROM.
3548 */
3549static void
3550tlp_2114x_mii_preinit(struct tulip_softc *sc)
3551{
3552
3553 /*
3554 * Always set the Must-Be-One bit, and Port Select (to select MII).
3555 * We'll never be called during a media change.
3556 */
3557 sc->sc_opmode |= OPMODE_MBO|OPMODE_PS;
3558 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
3559}
3560
3561/*
3562 * tlp_pnic_preinit:
3563 *
3564 * Pre-init function for the Lite-On 82c168 and 82c169.
3565 */
3566static void
3567tlp_pnic_preinit(struct tulip_softc *sc)
3568{
3569
3570 if (sc->sc_flags & TULIPF_HAS_MII) {
3571 /*
3572 * MII case: just set the port-select bit; we will never
3573 * be called during a media change.
3574 */
3575 sc->sc_opmode |= OPMODE_PS;
3576 } else {
3577 /*
3578 * ENDEC/PCS/Nway mode; enable the Tx backoff counter.
3579 */
3580 sc->sc_opmode |= OPMODE_PNIC_TBEN;
3581 }
3582}
3583
3584/*
3585 * tlp_asix_preinit:
3586 *
3587 * Pre-init function for the ASIX chipsets.
3588 */
3589static void
3590tlp_asix_preinit(struct tulip_softc *sc)
3591{
3592
3593 switch (sc->sc_chip) {
3594 case TULIP_CHIP_AX88140:
3595 case TULIP_CHIP_AX88141:
3596 /* XXX Handle PHY. */
3597 sc->sc_opmode |= OPMODE_HBD|OPMODE_PS;
3598 break;
3599 default:
3600 /* Nothing */
3601 break;
3602 }
3603
3604 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
3605}
3606
3607/*
3608 * tlp_dm9102_preinit:
3609 *
3610 * Pre-init function for the Davicom DM9102.
3611 */
3612static void
3613tlp_dm9102_preinit(struct tulip_softc *sc)
3614{
3615
3616 switch (sc->sc_chip) {
3617 case TULIP_CHIP_DM9102:
3618 sc->sc_opmode |= OPMODE_MBO|OPMODE_HBD|OPMODE_PS;
3619 break;
3620
3621 case TULIP_CHIP_DM9102A:
3622 /*
3623 * XXX Figure out how to actually deal with the HomePNA
3624 * XXX portion of the DM9102A.
3625 */
3626 sc->sc_opmode |= OPMODE_MBO|OPMODE_HBD;
3627 break;
3628
3629 default:
3630 /* Nothing. */
3631 break;
3632 }
3633
3634 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
3635}
3636
3637/*
3638 * tlp_21140_reset:
3639 *
3640 * Issue a reset sequence on the 21140 via the GPIO facility.
3641 */
3642static void
3643tlp_21140_reset(struct tulip_softc *sc)
3644{
3645 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
3646 struct tulip_21x4x_media *tm = ife->ifm_aux;
3647 int i;
3648
3649 /* First, set the direction on the GPIO pins. */
3650 TULIP_WRITE(sc, CSR_GPP, GPP_GPC|sc->sc_gp_dir);
3651
3652 /* Now, issue the reset sequence. */
3653 for (i = 0; i < tm->tm_reset_length; i++) {
3654 delay(10);
3655 TULIP_WRITE(sc, CSR_GPP, sc->sc_srom[tm->tm_reset_offset + i]);
3656 }
3657
3658 /* Now, issue the selection sequence. */
3659 for (i = 0; i < tm->tm_gp_length; i++) {
3660 delay(10);
3661 TULIP_WRITE(sc, CSR_GPP, sc->sc_srom[tm->tm_gp_offset + i]);
3662 }
3663
3664 /* If there were no sequences, just lower the pins. */
3665 if (tm->tm_reset_length == 0 && tm->tm_gp_length == 0) {
3666 delay(10);
3667 TULIP_WRITE(sc, CSR_GPP, 0);
3668 }
3669}
3670
3671/*
3672 * tlp_21142_reset:
3673 *
3674 * Issue a reset sequence on the 21142 via the GPIO facility.
3675 */
3676static void
3677tlp_21142_reset(struct tulip_softc *sc)
3678{
3679 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
3680 struct tulip_21x4x_media *tm = ife->ifm_aux;
3681 const uint8_t *cp;
3682 int i;
3683
3684 cp = &sc->sc_srom[tm->tm_reset_offset];
3685 for (i = 0; i < tm->tm_reset_length; i++, cp += 2) {
3686 delay(10);
3687 TULIP_WRITE(sc, CSR_SIAGEN, TULIP_ROM_GETW(cp, 0) << 16);
3688 }
3689
3690 cp = &sc->sc_srom[tm->tm_gp_offset];
3691 for (i = 0; i < tm->tm_gp_length; i++, cp += 2) {
3692 delay(10);
3693 TULIP_WRITE(sc, CSR_SIAGEN, TULIP_ROM_GETW(cp, 0) << 16);
3694 }
3695
3696 /* If there were no sequences, just lower the pins. */
3697 if (tm->tm_reset_length == 0 && tm->tm_gp_length == 0) {
3698 delay(10);
3699 TULIP_WRITE(sc, CSR_SIAGEN, 0);
3700 }
3701}
3702
3703/*
3704 * tlp_pmac_reset:
3705 *
3706 * Reset routine for Macronix chips.
3707 */
3708static void
3709tlp_pmac_reset(struct tulip_softc *sc)
3710{
3711
3712 switch (sc->sc_chip) {
3713 case TULIP_CHIP_82C115:
3714 case TULIP_CHIP_MX98715:
3715 case TULIP_CHIP_MX98715A:
3716 case TULIP_CHIP_MX98725:
3717 /*
3718 * Set the LED operating mode. This information is located
3719 * in the EEPROM at byte offset 0x77, per the MX98715A and
3720 * MX98725 application notes.
3721 */
3722 TULIP_WRITE(sc, CSR_MIIROM, sc->sc_srom[0x77] << 24);
3723 break;
3724 case TULIP_CHIP_MX98715AEC_X:
3725 /*
3726 * Set the LED operating mode. This information is located
3727 * in the EEPROM at byte offset 0x76, per the MX98715AEC
3728 * application note.
3729 */
3730 TULIP_WRITE(sc, CSR_MIIROM, ((0xf & sc->sc_srom[0x76]) << 28)
3731 | ((0xf0 & sc->sc_srom[0x76]) << 20));
3732 break;
3733
3734 default:
3735 /* Nothing. */
3736 break;
3737 }
3738}
3739
3740#if 0
3741/*
3742 * tlp_dm9102_reset:
3743 *
3744 * Reset routine for the Davicom DM9102.
3745 */
3746static void
3747tlp_dm9102_reset(struct tulip_softc *sc)
3748{
3749
3750 TULIP_WRITE(sc, CSR_DM_PHYSTAT, DM_PHYSTAT_GEPC|DM_PHYSTAT_GPED);
3751 delay(100);
3752 TULIP_WRITE(sc, CSR_DM_PHYSTAT, 0);
3753}
3754#endif
3755
3756/*****************************************************************************
3757 * Chip/board-specific media switches. The ones here are ones that
3758 * are potentially common to multiple front-ends.
3759 *****************************************************************************/
3760
3761/*
3762 * This table is a common place for all sorts of media information,
3763 * keyed off of the SROM media code for that media.
3764 *
3765 * Note that we explicitly configure the 21142/21143 to always advertise
3766 * NWay capabilities when using the UTP port.
3767 * XXX Actually, we don't yet.
3768 */
3769static const struct tulip_srom_to_ifmedia tulip_srom_to_ifmedia_table[] = {
3770 { TULIP_ROM_MB_MEDIA_TP, IFM_10_T, 0,
3771 "10baseT",
3772 OPMODE_TTM,
3773 BMSR_10THDX,
3774 { SIACONN_21040_10BASET,
3775 SIATXRX_21040_10BASET,
3776 SIAGEN_21040_10BASET },
3777
3778 { SIACONN_21041_10BASET,
3779 SIATXRX_21041_10BASET,
3780 SIAGEN_21041_10BASET },
3781
3782 { SIACONN_21142_10BASET,
3783 SIATXRX_21142_10BASET,
3784 SIAGEN_21142_10BASET } },
3785
3786 { TULIP_ROM_MB_MEDIA_BNC, IFM_10_2, 0,
3787 "10base2",
3788 0,
3789 0,
3790 { 0,
3791 0,
3792 0 },
3793
3794 { SIACONN_21041_BNC,
3795 SIATXRX_21041_BNC,
3796 SIAGEN_21041_BNC },
3797
3798 { SIACONN_21142_BNC,
3799 SIATXRX_21142_BNC,
3800 SIAGEN_21142_BNC } },
3801
3802 { TULIP_ROM_MB_MEDIA_AUI, IFM_10_5, 0,
3803 "10base5",
3804 0,
3805 0,
3806 { SIACONN_21040_AUI,
3807 SIATXRX_21040_AUI,
3808 SIAGEN_21040_AUI },
3809
3810 { SIACONN_21041_AUI,
3811 SIATXRX_21041_AUI,
3812 SIAGEN_21041_AUI },
3813
3814 { SIACONN_21142_AUI,
3815 SIATXRX_21142_AUI,
3816 SIAGEN_21142_AUI } },
3817
3818 { TULIP_ROM_MB_MEDIA_100TX, IFM_100_TX, 0,
3819 "100baseTX",
3820 OPMODE_PS|OPMODE_PCS|OPMODE_SCR|OPMODE_HBD,
3821 BMSR_100TXHDX,
3822 { 0,
3823 0,
3824 0 },
3825
3826 { 0,
3827 0,
3828 0 },
3829
3830 { 0,
3831 0,
3832 SIAGEN_ABM } },
3833
3834 { TULIP_ROM_MB_MEDIA_TP_FDX, IFM_10_T, IFM_FDX,
3835 "10baseT-FDX",
3836 OPMODE_TTM|OPMODE_FD|OPMODE_HBD,
3837 BMSR_10TFDX,
3838 { SIACONN_21040_10BASET_FDX,
3839 SIATXRX_21040_10BASET_FDX,
3840 SIAGEN_21040_10BASET_FDX },
3841
3842 { SIACONN_21041_10BASET_FDX,
3843 SIATXRX_21041_10BASET_FDX,
3844 SIAGEN_21041_10BASET_FDX },
3845
3846 { SIACONN_21142_10BASET_FDX,
3847 SIATXRX_21142_10BASET_FDX,
3848 SIAGEN_21142_10BASET_FDX } },
3849
3850 { TULIP_ROM_MB_MEDIA_100TX_FDX, IFM_100_TX, IFM_FDX,
3851 "100baseTX-FDX",
3852 OPMODE_PS|OPMODE_PCS|OPMODE_SCR|OPMODE_FD|OPMODE_HBD,
3853 BMSR_100TXFDX,
3854 { 0,
3855 0,
3856 0 },
3857
3858 { 0,
3859 0,
3860 0 },
3861
3862 { 0,
3863 0,
3864 SIAGEN_ABM } },
3865
3866 { TULIP_ROM_MB_MEDIA_100T4, IFM_100_T4, 0,
3867 "100baseT4",
3868 OPMODE_PS|OPMODE_PCS|OPMODE_SCR|OPMODE_HBD,
3869 BMSR_100T4,
3870 { 0,
3871 0,
3872 0 },
3873
3874 { 0,
3875 0,
3876 0 },
3877
3878 { 0,
3879 0,
3880 SIAGEN_ABM } },
3881
3882 { TULIP_ROM_MB_MEDIA_100FX, IFM_100_FX, 0,
3883 "100baseFX",
3884 OPMODE_PS|OPMODE_PCS|OPMODE_HBD,
3885 0,
3886 { 0,
3887 0,
3888 0 },
3889
3890 { 0,
3891 0,
3892 0 },
3893
3894 { 0,
3895 0,
3896 SIAGEN_ABM } },
3897
3898 { TULIP_ROM_MB_MEDIA_100FX_FDX, IFM_100_FX, IFM_FDX,
3899 "100baseFX-FDX",
3900 OPMODE_PS|OPMODE_PCS|OPMODE_FD|OPMODE_HBD,
3901 0,
3902 { 0,
3903 0,
3904 0 },
3905
3906 { 0,
3907 0,
3908 0 },
3909
3910 { 0,
3911 0,
3912 SIAGEN_ABM } },
3913
3914 { 0, 0, 0,
3915 NULL,
3916 0,
3917 0,
3918 { 0,
3919 0,
3920 0 },
3921
3922 { 0,
3923 0,
3924 0 },
3925
3926 { 0,
3927 0,
3928 0 } },
3929};
3930
3931static const struct tulip_srom_to_ifmedia *tlp_srom_to_ifmedia(uint8_t);
3932static void tlp_srom_media_info(struct tulip_softc *,
3933 const struct tulip_srom_to_ifmedia *,
3934 struct tulip_21x4x_media *);
3935static void tlp_add_srom_media(struct tulip_softc *, int,
3936 void (*)(struct tulip_softc *, struct ifmediareq *),
3937 int (*)(struct tulip_softc *), const uint8_t *, int);
3938static void tlp_print_media(struct tulip_softc *);
3939static void tlp_nway_activate(struct tulip_softc *, int);
3940static void tlp_get_minst(struct tulip_softc *);
3941
3942static const struct tulip_srom_to_ifmedia *
3943tlp_srom_to_ifmedia(uint8_t sm)
3944{
3945 const struct tulip_srom_to_ifmedia *tsti;
3946
3947 for (tsti = tulip_srom_to_ifmedia_table;
3948 tsti->tsti_name != NULL; tsti++) {
3949 if (tsti->tsti_srom == sm)
3950 return (tsti);
3951 }
3952
3953 return (NULL);
3954}
3955
3956static void
3957tlp_srom_media_info(struct tulip_softc *sc,
3958 const struct tulip_srom_to_ifmedia *tsti, struct tulip_21x4x_media *tm)
3959{
3960
3961 tm->tm_name = tsti->tsti_name;
3962 tm->tm_opmode = tsti->tsti_opmode;
3963
3964 sc->sc_sia_cap |= tsti->tsti_sia_cap;
3965
3966 switch (sc->sc_chip) {
3967 case TULIP_CHIP_DE425:
3968 case TULIP_CHIP_21040:
3969 tm->tm_sia = tsti->tsti_21040; /* struct assignment */
3970 break;
3971
3972 case TULIP_CHIP_21041:
3973 tm->tm_sia = tsti->tsti_21041; /* struct assignment */
3974 break;
3975
3976 case TULIP_CHIP_21142:
3977 case TULIP_CHIP_21143:
3978 case TULIP_CHIP_82C115:
3979 case TULIP_CHIP_MX98715:
3980 case TULIP_CHIP_MX98715A:
3981 case TULIP_CHIP_MX98715AEC_X:
3982 case TULIP_CHIP_MX98725:
3983 tm->tm_sia = tsti->tsti_21142; /* struct assignment */
3984 break;
3985
3986 default:
3987 /* Nothing. */
3988 break;
3989 }
3990}
3991
3992static void
3993tlp_add_srom_media(struct tulip_softc *sc, int type,
3994 void (*get)(struct tulip_softc *, struct ifmediareq *),
3995 int (*set)(struct tulip_softc *), const uint8_t *list,
3996 int cnt)
3997{
3998 struct tulip_21x4x_media *tm;
3999 const struct tulip_srom_to_ifmedia *tsti;
4000 int i;
4001
4002 for (i = 0; i < cnt; i++) {
4003 tsti = tlp_srom_to_ifmedia(list[i]);
4004 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
4005 tlp_srom_media_info(sc, tsti, tm);
4006 tm->tm_type = type;
4007 tm->tm_get = get;
4008 tm->tm_set = set;
4009
4010 ifmedia_add(&sc->sc_mii.mii_media,
4011 IFM_MAKEWORD(IFM_ETHER, tsti->tsti_subtype,
4012 tsti->tsti_options, sc->sc_tlp_minst), 0, tm);
4013 }
4014}
4015
4016static void
4017tlp_print_media(struct tulip_softc *sc)
4018{
4019 struct ifmedia_entry *ife;
4020 struct tulip_21x4x_media *tm;
4021 const char *sep = "";
4022
4023#define PRINT(str) aprint_normal("%s%s", sep, str); sep = ", "
4024
4025 aprint_normal_dev(sc->sc_dev, "");
4026 TAILQ_FOREACH(ife, &sc->sc_mii.mii_media.ifm_list, ifm_list) {
4027 tm = ife->ifm_aux;
4028 if (tm == NULL) {
4029#ifdef DIAGNOSTIC
4030 if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
4031 panic("tlp_print_media");
4032#endif
4033 PRINT("auto");
4034 } else if (tm->tm_type != TULIP_ROM_MB_21140_MII &&
4035 tm->tm_type != TULIP_ROM_MB_21142_MII) {
4036 PRINT(tm->tm_name);
4037 }
4038 }
4039 aprint_normal("\n");
4040
4041#undef PRINT
4042}
4043
4044static void
4045tlp_nway_activate(struct tulip_softc *sc, int media)
4046{
4047 struct ifmedia_entry *ife;
4048
4049 ife = ifmedia_match(&sc->sc_mii.mii_media, media, 0);
4050#ifdef DIAGNOSTIC
4051 if (ife == NULL)
4052 panic("tlp_nway_activate");
4053#endif
4054 sc->sc_nway_active = ife;
4055}
4056
4057static void
4058tlp_get_minst(struct tulip_softc *sc)
4059{
4060
4061 if ((sc->sc_media_seen &
4062 ~((1 << TULIP_ROM_MB_21140_MII) |
4063 (1 << TULIP_ROM_MB_21142_MII))) == 0) {
4064 /*
4065 * We have not yet seen any SIA/SYM media (but are
4066 * about to; that's why we're called!), so assign
4067 * the current media instance to be the `internal media'
4068 * instance, and advance it so any MII media gets a
4069 * fresh one (used to selecting/isolating a PHY).
4070 */
4071 sc->sc_tlp_minst = sc->sc_mii.mii_instance++;
4072 }
4073}
4074
4075/*
4076 * SIA Utility functions.
4077 */
4078static void tlp_sia_update_link(struct tulip_softc *);
4079static void tlp_sia_get(struct tulip_softc *, struct ifmediareq *);
4080static int tlp_sia_set(struct tulip_softc *);
4081static int tlp_sia_media(struct tulip_softc *, struct ifmedia_entry *);
4082static void tlp_sia_fixup(struct tulip_softc *);
4083
4084static void
4085tlp_sia_update_link(struct tulip_softc *sc)
4086{
4087 struct ifmedia_entry *ife;
4088 struct tulip_21x4x_media *tm;
4089 uint32_t siastat;
4090
4091 ife = TULIP_CURRENT_MEDIA(sc);
4092 tm = ife->ifm_aux;
4093
4094 sc->sc_flags &= ~(TULIPF_LINK_UP|TULIPF_LINK_VALID);
4095
4096 siastat = TULIP_READ(sc, CSR_SIASTAT);
4097
4098 /*
4099 * Note that when we do SIA link tests, we are assuming that
4100 * the chip is really in the mode that the current media setting
4101 * reflects. If we're not, then the link tests will not be
4102 * accurate!
4103 */
4104 switch (IFM_SUBTYPE(ife->ifm_media)) {
4105 case IFM_10_T:
4106 sc->sc_flags |= TULIPF_LINK_VALID;
4107 if ((siastat & SIASTAT_LS10) == 0)
4108 sc->sc_flags |= TULIPF_LINK_UP;
4109 break;
4110
4111 case IFM_100_TX:
4112 case IFM_100_T4:
4113 sc->sc_flags |= TULIPF_LINK_VALID;
4114 if ((siastat & SIASTAT_LS100) == 0)
4115 sc->sc_flags |= TULIPF_LINK_UP;
4116 break;
4117 }
4118
4119 switch (sc->sc_chip) {
4120 case TULIP_CHIP_21142:
4121 case TULIP_CHIP_21143:
4122 /*
4123 * On these chips, we can tell more information about
4124 * AUI/BNC. Note that the AUI/BNC selection is made
4125 * in a different register; for our purpose, it's all
4126 * AUI.
4127 */
4128 switch (IFM_SUBTYPE(ife->ifm_media)) {
4129 case IFM_10_2:
4130 case IFM_10_5:
4131 sc->sc_flags |= TULIPF_LINK_VALID;
4132 if (siastat & SIASTAT_ARA) {
4133 TULIP_WRITE(sc, CSR_SIASTAT, SIASTAT_ARA);
4134 sc->sc_flags |= TULIPF_LINK_UP;
4135 }
4136 break;
4137
4138 default:
4139 /*
4140 * If we're SYM media and can detect the link
4141 * via the GPIO facility, prefer that status
4142 * over LS100.
4143 */
4144 if (tm->tm_type == TULIP_ROM_MB_21143_SYM &&
4145 tm->tm_actmask != 0) {
4146 sc->sc_flags = (sc->sc_flags &
4147 ~TULIPF_LINK_UP) | TULIPF_LINK_VALID;
4148 if (TULIP_ISSET(sc, CSR_SIAGEN,
4149 tm->tm_actmask) == tm->tm_actdata)
4150 sc->sc_flags |= TULIPF_LINK_UP;
4151 }
4152 }
4153 break;
4154
4155 default:
4156 /* Nothing. */
4157 break;
4158 }
4159}
4160
4161static void
4162tlp_sia_get(struct tulip_softc *sc, struct ifmediareq *ifmr)
4163{
4164 struct ifmedia_entry *ife;
4165
4166 ifmr->ifm_status = 0;
4167
4168 tlp_sia_update_link(sc);
4169
4170 ife = TULIP_CURRENT_MEDIA(sc);
4171
4172 if (sc->sc_flags & TULIPF_LINK_VALID)
4173 ifmr->ifm_status |= IFM_AVALID;
4174 if (sc->sc_flags & TULIPF_LINK_UP)
4175 ifmr->ifm_status |= IFM_ACTIVE;
4176 ifmr->ifm_active = ife->ifm_media;
4177}
4178
4179static void
4180tlp_sia_fixup(struct tulip_softc *sc)
4181{
4182 struct ifmedia_entry *ife;
4183 struct tulip_21x4x_media *tm;
4184 uint32_t siaconn, siatxrx, siagen;
4185
4186 switch (sc->sc_chip) {
4187 case TULIP_CHIP_82C115:
4188 case TULIP_CHIP_MX98713A:
4189 case TULIP_CHIP_MX98715:
4190 case TULIP_CHIP_MX98715A:
4191 case TULIP_CHIP_MX98715AEC_X:
4192 case TULIP_CHIP_MX98725:
4193 siaconn = PMAC_SIACONN_MASK;
4194 siatxrx = PMAC_SIATXRX_MASK;
4195 siagen = PMAC_SIAGEN_MASK;
4196 break;
4197
4198 default:
4199 /* No fixups required on any other chips. */
4200 return;
4201 }
4202
4203 TAILQ_FOREACH(ife, &sc->sc_mii.mii_media.ifm_list, ifm_list) {
4204 tm = ife->ifm_aux;
4205 if (tm == NULL)
4206 continue;
4207
4208 tm->tm_siaconn &= siaconn;
4209 tm->tm_siatxrx &= siatxrx;
4210 tm->tm_siagen &= siagen;
4211 }
4212}
4213
4214static int
4215tlp_sia_set(struct tulip_softc *sc)
4216{
4217
4218 return (tlp_sia_media(sc, TULIP_CURRENT_MEDIA(sc)));
4219}
4220
4221static int
4222tlp_sia_media(struct tulip_softc *sc, struct ifmedia_entry *ife)
4223{
4224 struct tulip_21x4x_media *tm;
4225
4226 tm = ife->ifm_aux;
4227
4228 /*
4229 * XXX This appears to be necessary on a bunch of the clone chips.
4230 */
4231 delay(20000);
4232
4233 /*
4234 * Idle the chip.
4235 */
4236 tlp_idle(sc, OPMODE_ST|OPMODE_SR);
4237
4238 /*
4239 * Program the SIA. It's important to write in this order,
4240 * resetting the SIA first.
4241 */
4242 TULIP_WRITE(sc, CSR_SIACONN, 0); /* SRL bit clear */
4243 delay(1000);
4244
4245 TULIP_WRITE(sc, CSR_SIATXRX, tm->tm_siatxrx);
4246
4247 switch (sc->sc_chip) {
4248 case TULIP_CHIP_21142:
4249 case TULIP_CHIP_21143:
4250 TULIP_WRITE(sc, CSR_SIAGEN, tm->tm_siagen | tm->tm_gpctl);
4251 TULIP_WRITE(sc, CSR_SIAGEN, tm->tm_siagen | tm->tm_gpdata);
4252 break;
4253 default:
4254 TULIP_WRITE(sc, CSR_SIAGEN, tm->tm_siagen);
4255 }
4256
4257 TULIP_WRITE(sc, CSR_SIACONN, tm->tm_siaconn);
4258
4259 /*
4260 * Set the OPMODE bits for this media and write OPMODE.
4261 * This will resume the transmit and receive processes.
4262 */
4263 sc->sc_opmode = (sc->sc_opmode & ~OPMODE_MEDIA_BITS) | tm->tm_opmode;
4264 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
4265
4266 return (0);
4267}
4268
4269/*
4270 * 21140 GPIO utility functions.
4271 */
4272static void tlp_21140_gpio_update_link(struct tulip_softc *);
4273
4274static void
4275tlp_21140_gpio_update_link(struct tulip_softc *sc)
4276{
4277 struct ifmedia_entry *ife;
4278 struct tulip_21x4x_media *tm;
4279
4280 ife = TULIP_CURRENT_MEDIA(sc);
4281 tm = ife->ifm_aux;
4282
4283 sc->sc_flags &= ~(TULIPF_LINK_UP|TULIPF_LINK_VALID);
4284
4285 if (tm->tm_actmask != 0) {
4286 sc->sc_flags |= TULIPF_LINK_VALID;
4287 if (TULIP_ISSET(sc, CSR_GPP, tm->tm_actmask) ==
4288 tm->tm_actdata)
4289 sc->sc_flags |= TULIPF_LINK_UP;
4290 }
4291}
4292
4293void
4294tlp_21140_gpio_get(struct tulip_softc *sc, struct ifmediareq *ifmr)
4295{
4296 struct ifmedia_entry *ife;
4297
4298 ifmr->ifm_status = 0;
4299
4300 tlp_21140_gpio_update_link(sc);
4301
4302 ife = TULIP_CURRENT_MEDIA(sc);
4303
4304 if (sc->sc_flags & TULIPF_LINK_VALID)
4305 ifmr->ifm_status |= IFM_AVALID;
4306 if (sc->sc_flags & TULIPF_LINK_UP)
4307 ifmr->ifm_status |= IFM_ACTIVE;
4308 ifmr->ifm_active = ife->ifm_media;
4309}
4310
4311int
4312tlp_21140_gpio_set(struct tulip_softc *sc)
4313{
4314 struct ifmedia_entry *ife;
4315 struct tulip_21x4x_media *tm;
4316
4317 ife = TULIP_CURRENT_MEDIA(sc);
4318 tm = ife->ifm_aux;
4319
4320 /*
4321 * Idle the chip.
4322 */
4323 tlp_idle(sc, OPMODE_ST|OPMODE_SR);
4324
4325 /*
4326 * Set the GPIO pins for this media, to flip any
4327 * relays, etc.
4328 */
4329 TULIP_WRITE(sc, CSR_GPP, GPP_GPC|sc->sc_gp_dir);
4330 delay(10);
4331 TULIP_WRITE(sc, CSR_GPP, tm->tm_gpdata);
4332
4333 /*
4334 * Set the OPMODE bits for this media and write OPMODE.
4335 * This will resume the transmit and receive processes.
4336 */
4337 sc->sc_opmode = (sc->sc_opmode & ~OPMODE_MEDIA_BITS) | tm->tm_opmode;
4338 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
4339
4340 return (0);
4341}
4342
4343/*
4344 * 21040 and 21041 media switches.
4345 */
4346static void tlp_21040_tmsw_init(struct tulip_softc *);
4347static void tlp_21040_tp_tmsw_init(struct tulip_softc *);
4348static void tlp_21040_auibnc_tmsw_init(struct tulip_softc *);
4349static void tlp_21041_tmsw_init(struct tulip_softc *);
4350
4351const struct tulip_mediasw tlp_21040_mediasw = {
4352 tlp_21040_tmsw_init, tlp_sia_get, tlp_sia_set
4353};
4354
4355const struct tulip_mediasw tlp_21040_tp_mediasw = {
4356 tlp_21040_tp_tmsw_init, tlp_sia_get, tlp_sia_set
4357};
4358
4359const struct tulip_mediasw tlp_21040_auibnc_mediasw = {
4360 tlp_21040_auibnc_tmsw_init, tlp_sia_get, tlp_sia_set
4361};
4362
4363const struct tulip_mediasw tlp_21041_mediasw = {
4364 tlp_21041_tmsw_init, tlp_sia_get, tlp_sia_set
4365};
4366
4367static void
4368tlp_21040_tmsw_init(struct tulip_softc *sc)
4369{
4370 static const uint8_t media[] = {
4371 TULIP_ROM_MB_MEDIA_TP,
4372 TULIP_ROM_MB_MEDIA_TP_FDX,
4373 TULIP_ROM_MB_MEDIA_AUI,
4374 };
4375 struct tulip_21x4x_media *tm;
4376
4377 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
4378 tlp_mediastatus);
4379
4380 tlp_add_srom_media(sc, 0, NULL, NULL, media, 3);
4381
4382 /*
4383 * No SROM type for External SIA.
4384 */
4385 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
4386 tm->tm_name = "manual";
4387 tm->tm_opmode = 0;
4388 tm->tm_siaconn = SIACONN_21040_EXTSIA;
4389 tm->tm_siatxrx = SIATXRX_21040_EXTSIA;
4390 tm->tm_siagen = SIAGEN_21040_EXTSIA;
4391 ifmedia_add(&sc->sc_mii.mii_media,
4392 IFM_MAKEWORD(IFM_ETHER, IFM_MANUAL, 0, sc->sc_tlp_minst), 0, tm);
4393
4394 /*
4395 * XXX Autosense not yet supported.
4396 */
4397
4398 /* XXX This should be auto-sense. */
4399 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_10_T);
4400
4401 tlp_print_media(sc);
4402}
4403
4404static void
4405tlp_21040_tp_tmsw_init(struct tulip_softc *sc)
4406{
4407 static const uint8_t media[] = {
4408 TULIP_ROM_MB_MEDIA_TP,
4409 TULIP_ROM_MB_MEDIA_TP_FDX,
4410 };
4411
4412 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
4413 tlp_mediastatus);
4414
4415 tlp_add_srom_media(sc, 0, NULL, NULL, media, 2);
4416
4417 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_10_T);
4418
4419 tlp_print_media(sc);
4420}
4421
4422static void
4423tlp_21040_auibnc_tmsw_init(struct tulip_softc *sc)
4424{
4425 static const uint8_t media[] = {
4426 TULIP_ROM_MB_MEDIA_AUI,
4427 };
4428
4429 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
4430 tlp_mediastatus);
4431
4432 tlp_add_srom_media(sc, 0, NULL, NULL, media, 1);
4433
4434 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_10_5);
4435
4436 tlp_print_media(sc);
4437}
4438
4439static void
4440tlp_21041_tmsw_init(struct tulip_softc *sc)
4441{
4442 static const uint8_t media[] = {
4443 TULIP_ROM_MB_MEDIA_TP,
4444 TULIP_ROM_MB_MEDIA_TP_FDX,
4445 TULIP_ROM_MB_MEDIA_BNC,
4446 TULIP_ROM_MB_MEDIA_AUI,
4447 };
4448 int i, defmedia, devcnt, leaf_offset, mb_offset, m_cnt;
4449 const struct tulip_srom_to_ifmedia *tsti;
4450 struct tulip_21x4x_media *tm;
4451 uint16_t romdef;
4452 uint8_t mb;
4453
4454 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
4455 tlp_mediastatus);
4456
4457 if (tlp_isv_srom(sc->sc_srom) == 0) {
4458 not_isv_srom:
4459 /*
4460 * If we have a board without the standard 21041 SROM format,
4461 * we just assume all media are present and try and pick a
4462 * reasonable default.
4463 */
4464 tlp_add_srom_media(sc, 0, NULL, NULL, media, 4);
4465
4466 /*
4467 * XXX Autosense not yet supported.
4468 */
4469
4470 /* XXX This should be auto-sense. */
4471 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_10_T);
4472
4473 tlp_print_media(sc);
4474 return;
4475 }
4476
4477 devcnt = sc->sc_srom[TULIP_ROM_CHIP_COUNT];
4478 for (i = 0; i < devcnt; i++) {
4479 if (sc->sc_srom[TULIP_ROM_CHIP_COUNT] == 1)
4480 break;
4481 if (sc->sc_srom[TULIP_ROM_CHIPn_DEVICE_NUMBER(i)] ==
4482 sc->sc_devno)
4483 break;
4484 }
4485
4486 if (i == devcnt)
4487 goto not_isv_srom;
4488
4489 leaf_offset = TULIP_ROM_GETW(sc->sc_srom,
4490 TULIP_ROM_CHIPn_INFO_LEAF_OFFSET(i));
4491 mb_offset = leaf_offset + TULIP_ROM_IL_MEDIAn_BLOCK_BASE;
4492 m_cnt = sc->sc_srom[leaf_offset + TULIP_ROM_IL_MEDIA_COUNT];
4493
4494 for (; m_cnt != 0;
4495 m_cnt--, mb_offset += TULIP_ROM_MB_SIZE(mb)) {
4496 mb = sc->sc_srom[mb_offset];
4497 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
4498 switch (mb & TULIP_ROM_MB_MEDIA_CODE) {
4499 case TULIP_ROM_MB_MEDIA_TP_FDX:
4500 case TULIP_ROM_MB_MEDIA_TP:
4501 case TULIP_ROM_MB_MEDIA_BNC:
4502 case TULIP_ROM_MB_MEDIA_AUI:
4503 tsti = tlp_srom_to_ifmedia(mb &
4504 TULIP_ROM_MB_MEDIA_CODE);
4505
4506 tlp_srom_media_info(sc, tsti, tm);
4507
4508 /*
4509 * Override our default SIA settings if the
4510 * SROM contains its own.
4511 */
4512 if (mb & TULIP_ROM_MB_EXT) {
4513 tm->tm_siaconn = TULIP_ROM_GETW(sc->sc_srom,
4514 mb_offset + TULIP_ROM_MB_CSR13);
4515 tm->tm_siatxrx = TULIP_ROM_GETW(sc->sc_srom,
4516 mb_offset + TULIP_ROM_MB_CSR14);
4517 tm->tm_siagen = TULIP_ROM_GETW(sc->sc_srom,
4518 mb_offset + TULIP_ROM_MB_CSR15);
4519 }
4520
4521 ifmedia_add(&sc->sc_mii.mii_media,
4522 IFM_MAKEWORD(IFM_ETHER, tsti->tsti_subtype,
4523 tsti->tsti_options, sc->sc_tlp_minst), 0, tm);
4524 break;
4525
4526 default:
4527 aprint_error_dev(sc->sc_dev,
4528 "unknown media code 0x%02x\n",
4529 mb & TULIP_ROM_MB_MEDIA_CODE);
4530 free(tm, M_DEVBUF);
4531 }
4532 }
4533
4534 /*
4535 * XXX Autosense not yet supported.
4536 */
4537
4538 romdef = TULIP_ROM_GETW(sc->sc_srom, leaf_offset +
4539 TULIP_ROM_IL_SELECT_CONN_TYPE);
4540 switch (romdef) {
4541 case SELECT_CONN_TYPE_TP:
4542 case SELECT_CONN_TYPE_TP_AUTONEG:
4543 case SELECT_CONN_TYPE_TP_NOLINKPASS:
4544 defmedia = IFM_ETHER|IFM_10_T;
4545 break;
4546
4547 case SELECT_CONN_TYPE_TP_FDX:
4548 defmedia = IFM_ETHER|IFM_10_T|IFM_FDX;
4549 break;
4550
4551 case SELECT_CONN_TYPE_BNC:
4552 defmedia = IFM_ETHER|IFM_10_2;
4553 break;
4554
4555 case SELECT_CONN_TYPE_AUI:
4556 defmedia = IFM_ETHER|IFM_10_5;
4557 break;
4558#if 0 /* XXX */
4559 case SELECT_CONN_TYPE_ASENSE:
4560 case SELECT_CONN_TYPE_ASENSE_AUTONEG:
4561 defmedia = IFM_ETHER|IFM_AUTO;
4562 break;
4563#endif
4564 default:
4565 defmedia = 0;
4566 }
4567
4568 if (defmedia == 0) {
4569 /*
4570 * XXX We should default to auto-sense.
4571 */
4572 defmedia = IFM_ETHER|IFM_10_T;
4573 }
4574
4575 ifmedia_set(&sc->sc_mii.mii_media, defmedia);
4576
4577 tlp_print_media(sc);
4578}
4579
4580/*
4581 * DECchip 2114x ISV media switch.
4582 */
4583static void tlp_2114x_isv_tmsw_init(struct tulip_softc *);
4584static void tlp_2114x_isv_tmsw_get(struct tulip_softc *,
4585 struct ifmediareq *);
4586static int tlp_2114x_isv_tmsw_set(struct tulip_softc *);
4587
4588const struct tulip_mediasw tlp_2114x_isv_mediasw = {
4589 tlp_2114x_isv_tmsw_init, tlp_2114x_isv_tmsw_get, tlp_2114x_isv_tmsw_set
4590};
4591
4592static void tlp_2114x_nway_get(struct tulip_softc *, struct ifmediareq *);
4593static int tlp_2114x_nway_set(struct tulip_softc *);
4594
4595static void tlp_2114x_nway_statchg(struct ifnet *);
4596static int tlp_2114x_nway_service(struct tulip_softc *, int);
4597static void tlp_2114x_nway_auto(struct tulip_softc *);
4598static void tlp_2114x_nway_status(struct tulip_softc *);
4599
4600static void
4601tlp_2114x_isv_tmsw_init(struct tulip_softc *sc)
4602{
4603 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
4604 struct ifmedia_entry *ife;
4605 struct mii_softc *phy;
4606 struct tulip_21x4x_media *tm;
4607 const struct tulip_srom_to_ifmedia *tsti;
4608 int i, devcnt, leaf_offset, m_cnt, type, length;
4609 int defmedia, miidef;
4610 uint16_t word;
4611 uint8_t *cp, *ncp;
4612
4613 defmedia = miidef = 0;
4614
4615 sc->sc_mii.mii_ifp = ifp;
4616 sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
4617 sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
4618 sc->sc_mii.mii_statchg = sc->sc_statchg;
4619
4620 /*
4621 * Ignore `instance'; we may get a mixture of SIA and MII
4622 * media, and `instance' is used to isolate or select the
4623 * PHY on the MII as appropriate. Note that duplicate media
4624 * are disallowed, so ignoring `instance' is safe.
4625 */
4626 ifmedia_init(&sc->sc_mii.mii_media, IFM_IMASK, tlp_mediachange,
4627 tlp_mediastatus);
4628
4629 devcnt = sc->sc_srom[TULIP_ROM_CHIP_COUNT];
4630 for (i = 0; i < devcnt; i++) {
4631 if (sc->sc_srom[TULIP_ROM_CHIP_COUNT] == 1)
4632 break;
4633 if (sc->sc_srom[TULIP_ROM_CHIPn_DEVICE_NUMBER(i)] ==
4634 sc->sc_devno)
4635 break;
4636 }
4637
4638 if (i == devcnt) {
4639 aprint_error_dev(sc->sc_dev,
4640 "unable to locate info leaf in SROM\n");
4641 return;
4642 }
4643
4644 leaf_offset = TULIP_ROM_GETW(sc->sc_srom,
4645 TULIP_ROM_CHIPn_INFO_LEAF_OFFSET(i));
4646
4647 /* XXX SELECT CONN TYPE */
4648
4649 cp = &sc->sc_srom[leaf_offset + TULIP_ROM_IL_MEDIA_COUNT];
4650
4651 /*
4652 * On some chips, the first thing in the Info Leaf is the
4653 * GPIO pin direction data.
4654 */
4655 switch (sc->sc_chip) {
4656 case TULIP_CHIP_21140:
4657 case TULIP_CHIP_21140A:
4658 case TULIP_CHIP_MX98713:
4659 case TULIP_CHIP_AX88140:
4660 case TULIP_CHIP_AX88141:
4661 sc->sc_gp_dir = *cp++;
4662 break;
4663
4664 default:
4665 /* Nothing. */
4666 break;
4667 }
4668
4669 /* Get the media count. */
4670 m_cnt = *cp++;
4671
4672 if (m_cnt == 0) {
4673 sc->sc_mediasw = &tlp_sio_mii_mediasw;
4674 (*sc->sc_mediasw->tmsw_init)(sc);
4675 return;
4676 }
4677
4678 for (; m_cnt != 0; cp = ncp, m_cnt--) {
4679 /*
4680 * Determine the type and length of this media block.
4681 * The 21143 is spec'd to always use extended format blocks,
4682 * but some cards don't set the bit to indicate this.
4683 * Hopefully there are no cards which really don't use
4684 * extended format blocks.
4685 */
4686 if ((*cp & 0x80) == 0 && sc->sc_chip != TULIP_CHIP_21143) {
4687 length = 4;
4688 type = TULIP_ROM_MB_21140_GPR;
4689 } else {
4690 length = (*cp++ & 0x7f) - 1;
4691 type = *cp++ & 0x3f;
4692 }
4693
4694 /* Compute the start of the next block. */
4695 ncp = cp + length;
4696
4697 /* Now, parse the block. */
4698 switch (type) {
4699 case TULIP_ROM_MB_21140_GPR:
4700 tlp_get_minst(sc);
4701 sc->sc_media_seen |= 1 << TULIP_ROM_MB_21140_GPR;
4702
4703 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
4704
4705 tm->tm_type = TULIP_ROM_MB_21140_GPR;
4706 tm->tm_get = tlp_21140_gpio_get;
4707 tm->tm_set = tlp_21140_gpio_set;
4708
4709 /* First is the media type code. */
4710 tsti = tlp_srom_to_ifmedia(cp[0] &
4711 TULIP_ROM_MB_MEDIA_CODE);
4712 if (tsti == NULL) {
4713 /* Invalid media code. */
4714 free(tm, M_DEVBUF);
4715 break;
4716 }
4717
4718 /* Get defaults. */
4719 tlp_srom_media_info(sc, tsti, tm);
4720
4721 /* Next is any GPIO info for this media. */
4722 tm->tm_gpdata = cp[1];
4723
4724 /*
4725 * Next is a word containing OPMODE information
4726 * and info on how to detect if this media is
4727 * active.
4728 */
4729 word = TULIP_ROM_GETW(cp, 2);
4730 tm->tm_opmode &= OPMODE_FD;
4731 tm->tm_opmode |= TULIP_ROM_MB_OPMODE(word);
4732 if ((word & TULIP_ROM_MB_NOINDICATOR) == 0) {
4733 tm->tm_actmask =
4734 TULIP_ROM_MB_BITPOS(word);
4735 tm->tm_actdata =
4736 (word & TULIP_ROM_MB_POLARITY) ?
4737 0 : tm->tm_actmask;
4738 }
4739
4740 ifmedia_add(&sc->sc_mii.mii_media,
4741 IFM_MAKEWORD(IFM_ETHER, tsti->tsti_subtype,
4742 tsti->tsti_options, sc->sc_tlp_minst), 0, tm);
4743 break;
4744
4745 case TULIP_ROM_MB_21140_MII:
4746 sc->sc_media_seen |= 1 << TULIP_ROM_MB_21140_MII;
4747
4748 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
4749
4750 tm->tm_type = TULIP_ROM_MB_21140_MII;
4751 tm->tm_get = tlp_mii_getmedia;
4752 tm->tm_set = tlp_mii_setmedia;
4753 tm->tm_opmode = OPMODE_PS;
4754
4755 if (sc->sc_reset == NULL)
4756 sc->sc_reset = tlp_21140_reset;
4757
4758 /* First is the PHY number. */
4759 tm->tm_phyno = *cp++;
4760
4761 /* Next is the MII select sequence length and offset. */
4762 tm->tm_gp_length = *cp++;
4763 tm->tm_gp_offset = cp - &sc->sc_srom[0];
4764 cp += tm->tm_gp_length;
4765
4766 /* Next is the MII reset sequence length and offset. */
4767 tm->tm_reset_length = *cp++;
4768 tm->tm_reset_offset = cp - &sc->sc_srom[0];
4769 cp += tm->tm_reset_length;
4770
4771 /*
4772 * The following items are left in the media block
4773 * that we don't particularly care about:
4774 *
4775 * capabilities W
4776 * advertisement W
4777 * full duplex W
4778 * tx threshold W
4779 *
4780 * These appear to be bits in the PHY registers,
4781 * which our MII code handles on its own.
4782 */
4783
4784 /*
4785 * Before we probe the MII bus, we need to reset
4786 * it and issue the selection sequence.
4787 */
4788
4789 /* Set the direction of the pins... */
4790 TULIP_WRITE(sc, CSR_GPP, GPP_GPC|sc->sc_gp_dir);
4791
4792 for (i = 0; i < tm->tm_reset_length; i++) {
4793 delay(10);
4794 TULIP_WRITE(sc, CSR_GPP,
4795 sc->sc_srom[tm->tm_reset_offset + i]);
4796 }
4797
4798 for (i = 0; i < tm->tm_gp_length; i++) {
4799 delay(10);
4800 TULIP_WRITE(sc, CSR_GPP,
4801 sc->sc_srom[tm->tm_gp_offset + i]);
4802 }
4803
4804 /* If there were no sequences, just lower the pins. */
4805 if (tm->tm_reset_length == 0 && tm->tm_gp_length == 0) {
4806 delay(10);
4807 TULIP_WRITE(sc, CSR_GPP, 0);
4808 }
4809
4810 /*
4811 * Now, probe the MII for the PHY. Note, we know
4812 * the location of the PHY on the bus, but we don't
4813 * particularly care; the MII code just likes to
4814 * search the whole thing anyhow.
4815 */
4816 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff,
4817 MII_PHY_ANY, tm->tm_phyno, 0);
4818
4819 /*
4820 * Now, search for the PHY we hopefully just
4821 * configured. If it's not configured into the
4822 * kernel, we lose. The PHY's default media always
4823 * takes priority.
4824 */
4825 LIST_FOREACH(phy, &sc->sc_mii.mii_phys, mii_list) {
4826 if (phy->mii_offset == tm->tm_phyno)
4827 break;
4828 }
4829 if (phy == NULL) {
4830 aprint_error_dev(sc->sc_dev,
4831 "unable to configure MII\n");
4832 break;
4833 }
4834
4835 sc->sc_flags |= TULIPF_HAS_MII;
4836 sc->sc_tick = tlp_mii_tick;
4837 miidef = IFM_MAKEWORD(IFM_ETHER, IFM_AUTO, 0,
4838 phy->mii_inst);
4839
4840 /*
4841 * Okay, now that we've found the PHY and the MII
4842 * layer has added all of the media associated
4843 * with that PHY, we need to traverse the media
4844 * list, and add our `tm' to each entry's `aux'
4845 * pointer.
4846 *
4847 * We do this by looking for media with our
4848 * PHY's `instance'.
4849 */
4850 TAILQ_FOREACH(ife, &sc->sc_mii.mii_media.ifm_list,
4851 ifm_list) {
4852 if (IFM_INST(ife->ifm_media) != phy->mii_inst)
4853 continue;
4854 ife->ifm_aux = tm;
4855 }
4856 break;
4857
4858 case TULIP_ROM_MB_21142_SIA:
4859 tlp_get_minst(sc);
4860 sc->sc_media_seen |= 1 << TULIP_ROM_MB_21142_SIA;
4861
4862 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
4863
4864 tm->tm_type = TULIP_ROM_MB_21142_SIA;
4865 tm->tm_get = tlp_sia_get;
4866 tm->tm_set = tlp_sia_set;
4867
4868 /* First is the media type code. */
4869 tsti = tlp_srom_to_ifmedia(cp[0] &
4870 TULIP_ROM_MB_MEDIA_CODE);
4871 if (tsti == NULL) {
4872 /* Invalid media code. */
4873 free(tm, M_DEVBUF);
4874 break;
4875 }
4876
4877 /* Get defaults. */
4878 tlp_srom_media_info(sc, tsti, tm);
4879
4880 /*
4881 * Override our default SIA settings if the
4882 * SROM contains its own.
4883 */
4884 if (cp[0] & 0x40) {
4885 tm->tm_siaconn = TULIP_ROM_GETW(cp, 1);
4886 tm->tm_siatxrx = TULIP_ROM_GETW(cp, 3);
4887 tm->tm_siagen = TULIP_ROM_GETW(cp, 5);
4888 cp += 7;
4889 } else
4890 cp++;
4891
4892 /* Next is GPIO control/data. */
4893 tm->tm_gpctl = TULIP_ROM_GETW(cp, 0) << 16;
4894 tm->tm_gpdata = TULIP_ROM_GETW(cp, 2) << 16;
4895
4896 ifmedia_add(&sc->sc_mii.mii_media,
4897 IFM_MAKEWORD(IFM_ETHER, tsti->tsti_subtype,
4898 tsti->tsti_options, sc->sc_tlp_minst), 0, tm);
4899 break;
4900
4901 case TULIP_ROM_MB_21142_MII:
4902 sc->sc_media_seen |= 1 << TULIP_ROM_MB_21142_MII;
4903
4904 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
4905
4906 tm->tm_type = TULIP_ROM_MB_21142_MII;
4907 tm->tm_get = tlp_mii_getmedia;
4908 tm->tm_set = tlp_mii_setmedia;
4909 tm->tm_opmode = OPMODE_PS;
4910
4911 if (sc->sc_reset == NULL)
4912 sc->sc_reset = tlp_21142_reset;
4913
4914 /* First is the PHY number. */
4915 tm->tm_phyno = *cp++;
4916
4917 /* Next is the MII select sequence length and offset. */
4918 tm->tm_gp_length = *cp++;
4919 tm->tm_gp_offset = cp - &sc->sc_srom[0];
4920 cp += tm->tm_gp_length * 2;
4921
4922 /* Next is the MII reset sequence length and offset. */
4923 tm->tm_reset_length = *cp++;
4924 tm->tm_reset_offset = cp - &sc->sc_srom[0];
4925 cp += tm->tm_reset_length * 2;
4926
4927 /*
4928 * The following items are left in the media block
4929 * that we don't particularly care about:
4930 *
4931 * capabilities W
4932 * advertisement W
4933 * full duplex W
4934 * tx threshold W
4935 * MII interrupt W
4936 *
4937 * These appear to be bits in the PHY registers,
4938 * which our MII code handles on its own.
4939 */
4940
4941 /*
4942 * Before we probe the MII bus, we need to reset
4943 * it and issue the selection sequence.
4944 */
4945
4946 cp = &sc->sc_srom[tm->tm_reset_offset];
4947 for (i = 0; i < tm->tm_reset_length; i++, cp += 2) {
4948 delay(10);
4949 TULIP_WRITE(sc, CSR_SIAGEN,
4950 TULIP_ROM_GETW(cp, 0) << 16);
4951 }
4952
4953 cp = &sc->sc_srom[tm->tm_gp_offset];
4954 for (i = 0; i < tm->tm_gp_length; i++, cp += 2) {
4955 delay(10);
4956 TULIP_WRITE(sc, CSR_SIAGEN,
4957 TULIP_ROM_GETW(cp, 0) << 16);
4958 }
4959
4960 /* If there were no sequences, just lower the pins. */
4961 if (tm->tm_reset_length == 0 && tm->tm_gp_length == 0) {
4962 delay(10);
4963 TULIP_WRITE(sc, CSR_SIAGEN, 0);
4964 }
4965
4966 /*
4967 * Now, probe the MII for the PHY. Note, we know
4968 * the location of the PHY on the bus, but we don't
4969 * particularly care; the MII code just likes to
4970 * search the whole thing anyhow.
4971 */
4972 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff,
4973 MII_PHY_ANY, tm->tm_phyno, 0);
4974
4975 /*
4976 * Now, search for the PHY we hopefully just
4977 * configured. If it's not configured into the
4978 * kernel, we lose. The PHY's default media always
4979 * takes priority.
4980 */
4981 LIST_FOREACH(phy, &sc->sc_mii.mii_phys, mii_list) {
4982 if (phy->mii_offset == tm->tm_phyno)
4983 break;
4984 }
4985 if (phy == NULL) {
4986 aprint_error_dev(sc->sc_dev,
4987 "unable to configure MII\n");
4988 break;
4989 }
4990
4991 sc->sc_flags |= TULIPF_HAS_MII;
4992 sc->sc_tick = tlp_mii_tick;
4993 miidef = IFM_MAKEWORD(IFM_ETHER, IFM_AUTO, 0,
4994 phy->mii_inst);
4995
4996 /*
4997 * Okay, now that we've found the PHY and the MII
4998 * layer has added all of the media associated
4999 * with that PHY, we need to traverse the media
5000 * list, and add our `tm' to each entry's `aux'
5001 * pointer.
5002 *
5003 * We do this by looking for media with our
5004 * PHY's `instance'.
5005 */
5006 TAILQ_FOREACH(ife, &sc->sc_mii.mii_media.ifm_list,
5007 ifm_list) {
5008 if (IFM_INST(ife->ifm_media) != phy->mii_inst)
5009 continue;
5010 ife->ifm_aux = tm;
5011 }
5012 break;
5013
5014 case TULIP_ROM_MB_21143_SYM:
5015 tlp_get_minst(sc);
5016 sc->sc_media_seen |= 1 << TULIP_ROM_MB_21143_SYM;
5017
5018 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
5019
5020 tm->tm_type = TULIP_ROM_MB_21143_SYM;
5021 tm->tm_get = tlp_sia_get;
5022 tm->tm_set = tlp_sia_set;
5023
5024 /* First is the media type code. */
5025 tsti = tlp_srom_to_ifmedia(cp[0] &
5026 TULIP_ROM_MB_MEDIA_CODE);
5027 if (tsti == NULL) {
5028 /* Invalid media code. */
5029 free(tm, M_DEVBUF);
5030 break;
5031 }
5032
5033 /* Get defaults. */
5034 tlp_srom_media_info(sc, tsti, tm);
5035
5036 /* Next is GPIO control/data. */
5037 tm->tm_gpctl = TULIP_ROM_GETW(cp, 1) << 16;
5038 tm->tm_gpdata = TULIP_ROM_GETW(cp, 3) << 16;
5039
5040 /*
5041 * Next is a word containing OPMODE information
5042 * and info on how to detect if this media is
5043 * active.
5044 */
5045 word = TULIP_ROM_GETW(cp, 5);
5046 tm->tm_opmode &= OPMODE_FD;
5047 tm->tm_opmode |= TULIP_ROM_MB_OPMODE(word);
5048 if ((word & TULIP_ROM_MB_NOINDICATOR) == 0) {
5049 tm->tm_actmask =
5050 TULIP_ROM_MB_BITPOS(word);
5051 tm->tm_actdata =
5052 (word & TULIP_ROM_MB_POLARITY) ?
5053 0 : tm->tm_actmask;
5054 }
5055
5056 ifmedia_add(&sc->sc_mii.mii_media,
5057 IFM_MAKEWORD(IFM_ETHER, tsti->tsti_subtype,
5058 tsti->tsti_options, sc->sc_tlp_minst), 0, tm);
5059 break;
5060
5061 case TULIP_ROM_MB_21143_RESET:
5062 aprint_normal_dev(sc->sc_dev, "21143 reset block\n");
5063 break;
5064
5065 default:
5066 aprint_error_dev(sc->sc_dev,
5067 "unknown ISV media block type 0x%02x\n", type);
5068 }
5069 }
5070
5071 /*
5072 * Deal with the case where no media is configured.
5073 */
5074 if (TAILQ_FIRST(&sc->sc_mii.mii_media.ifm_list) == NULL) {
5075 aprint_error_dev(sc->sc_dev, "no media found!\n");
5076 ifmedia_add(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE, 0, NULL);
5077 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE);
5078 return;
5079 }
5080
5081 /*
5082 * Pick the default media.
5083 */
5084 if (miidef != 0)
5085 defmedia = miidef;
5086 else {
5087 switch (sc->sc_chip) {
5088 case TULIP_CHIP_21140:
5089 case TULIP_CHIP_21140A:
5090 /* XXX should come from SROM */
5091 defmedia = IFM_MAKEWORD(IFM_ETHER, IFM_10_T, 0, 0);
5092 if (ifmedia_match(&sc->sc_mii.mii_media, defmedia,
5093 sc->sc_mii.mii_media.ifm_mask) == NULL) {
5094 /*
5095 * There is not a 10baseT media.
5096 * Fall back to the first found one.
5097 */
5098 ife = TAILQ_FIRST(&sc->sc_mii.mii_media.ifm_list);
5099 defmedia = ife->ifm_media;
5100 }
5101 break;
5102
5103 case TULIP_CHIP_21142:
5104 case TULIP_CHIP_21143:
5105 case TULIP_CHIP_MX98713A:
5106 case TULIP_CHIP_MX98715:
5107 case TULIP_CHIP_MX98715A:
5108 case TULIP_CHIP_MX98715AEC_X:
5109 case TULIP_CHIP_MX98725:
5110 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
5111 tm->tm_name = "auto";
5112 tm->tm_get = tlp_2114x_nway_get;
5113 tm->tm_set = tlp_2114x_nway_set;
5114
5115 defmedia = IFM_MAKEWORD(IFM_ETHER, IFM_AUTO, 0, 0);
5116 ifmedia_add(&sc->sc_mii.mii_media, defmedia, 0, tm);
5117
5118 sc->sc_statchg = tlp_2114x_nway_statchg;
5119 sc->sc_tick = tlp_2114x_nway_tick;
5120 break;
5121
5122 default:
5123 defmedia = IFM_MAKEWORD(IFM_ETHER, IFM_10_T, 0, 0);
5124 break;
5125 }
5126 }
5127
5128 ifmedia_set(&sc->sc_mii.mii_media, defmedia);
5129
5130 /*
5131 * Display any non-MII media we've located.
5132 */
5133 if (sc->sc_media_seen &
5134 ~((1 << TULIP_ROM_MB_21140_MII) | (1 << TULIP_ROM_MB_21142_MII)))
5135 tlp_print_media(sc);
5136
5137 tlp_sia_fixup(sc);
5138}
5139
5140static void
5141tlp_2114x_nway_get(struct tulip_softc *sc, struct ifmediareq *ifmr)
5142{
5143
5144 (void) tlp_2114x_nway_service(sc, MII_POLLSTAT);
5145 ifmr->ifm_status = sc->sc_mii.mii_media_status;
5146 ifmr->ifm_active = sc->sc_mii.mii_media_active;
5147}
5148
5149static int
5150tlp_2114x_nway_set(struct tulip_softc *sc)
5151{
5152
5153 return (tlp_2114x_nway_service(sc, MII_MEDIACHG));
5154}
5155
5156static void
5157tlp_2114x_nway_statchg(struct ifnet *ifp)
5158{
5159 struct tulip_softc *sc = ifp->if_softc;
5160 struct mii_data *mii = &sc->sc_mii;
5161 struct ifmedia_entry *ife;
5162
5163 if (IFM_SUBTYPE(mii->mii_media_active) == IFM_NONE)
5164 return;
5165
5166 if ((ife = ifmedia_match(&mii->mii_media, mii->mii_media_active,
5167 mii->mii_media.ifm_mask)) == NULL) {
5168 printf("tlp_2114x_nway_statchg: no match for media 0x%x/0x%x\n",
5169 mii->mii_media_active, ~mii->mii_media.ifm_mask);
5170 panic("tlp_2114x_nway_statchg");
5171 }
5172
5173 tlp_sia_media(sc, ife);
5174}
5175
5176static void
5177tlp_2114x_nway_tick(void *arg)
5178{
5179 struct tulip_softc *sc = arg;
5180 struct mii_data *mii = &sc->sc_mii;
5181 int s, ticks;
5182
5183 if (!device_is_active(sc->sc_dev))
5184 return;
5185
5186 s = splnet();
5187 tlp_2114x_nway_service(sc, MII_TICK);
5188 if ((sc->sc_flags & TULIPF_LINK_UP) == 0 &&
5189 (mii->mii_media_status & IFM_ACTIVE) != 0 &&
5190 IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
5191 sc->sc_flags |= TULIPF_LINK_UP;
5192 tlp_start(&sc->sc_ethercom.ec_if);
5193 } else if ((sc->sc_flags & TULIPF_LINK_UP) != 0 &&
5194 (mii->mii_media_status & IFM_ACTIVE) == 0) {
5195 sc->sc_flags &= ~TULIPF_LINK_UP;
5196 }
5197 splx(s);
5198
5199 if ((sc->sc_flags & TULIPF_LINK_UP) == 0)
5200 ticks = hz >> 3;
5201 else
5202 ticks = hz;
5203 callout_reset(&sc->sc_tick_callout, ticks, tlp_2114x_nway_tick, sc);
5204}
5205
5206/*
5207 * Support for the 2114X internal NWay block. This is constructed
5208 * somewhat like a PHY driver for simplicity.
5209 */
5210
5211static int
5212tlp_2114x_nway_service(struct tulip_softc *sc, int cmd)
5213{
5214 struct mii_data *mii = &sc->sc_mii;
5215 struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
5216
5217 if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
5218 return (0);
5219
5220 switch (cmd) {
5221 case MII_POLLSTAT:
5222 /* Nothing special to do here. */
5223 break;
5224
5225 case MII_MEDIACHG:
5226 switch (IFM_SUBTYPE(ife->ifm_media)) {
5227 case IFM_AUTO:
5228 goto restart;
5229 default:
5230 /* Manual setting doesn't go through here. */
5231 printf("tlp_2114x_nway_service: oops!\n");
5232 return (EINVAL);
5233 }
5234 break;
5235
5236 case MII_TICK:
5237 /*
5238 * Only used for autonegotiation.
5239 */
5240 if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
5241 break;
5242
5243 /*
5244 * Check to see if we have link. If we do, we don't
5245 * need to restart the autonegotiation process.
5246 */
5247#if 0
5248 if (mii->mii_media_status & IFM_ACTIVE)
5249#else
5250 if (sc->sc_flags & TULIPF_LINK_UP)
5251#endif
5252 break;
5253
5254 /*
5255 * Only retry autonegotiation every 5 seconds.
5256 */
5257 if (++sc->sc_nway_ticks != (5 << 3))
5258 break;
5259
5260 restart:
5261 sc->sc_nway_ticks = 0;
5262 ife->ifm_data = IFM_NONE;
5263 tlp_2114x_nway_auto(sc);
5264 break;
5265 }
5266
5267 /* Update the media status. */
5268 tlp_2114x_nway_status(sc);
5269
5270 /*
5271 * Callback if something changed. Manually configuration goes through
5272 * tlp_sia_set() anyway, so ignore that here.
5273 */
5274 if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO &&
5275 ife->ifm_data != mii->mii_media_active) {
5276 (*sc->sc_statchg)(mii->mii_ifp);
5277 ife->ifm_data = mii->mii_media_active;
5278 }
5279 return (0);
5280}
5281
5282static void
5283tlp_2114x_nway_auto(struct tulip_softc *sc)
5284{
5285 uint32_t siastat, siatxrx;
5286
5287 tlp_idle(sc, OPMODE_ST|OPMODE_SR);
5288
5289 sc->sc_opmode &= ~(OPMODE_PS|OPMODE_PCS|OPMODE_SCR|OPMODE_FD);
5290 sc->sc_opmode |= OPMODE_TTM|OPMODE_HBD;
5291 siatxrx = 0xffbf; /* XXX magic number */
5292
5293 /* Compute the link code word to advertise. */
5294 if (sc->sc_sia_cap & BMSR_100T4)
5295 siatxrx |= SIATXRX_T4;
5296 if (sc->sc_sia_cap & BMSR_100TXFDX)
5297 siatxrx |= SIATXRX_TXF;
5298 if (sc->sc_sia_cap & BMSR_100TXHDX)
5299 siatxrx |= SIATXRX_THX;
5300 if (sc->sc_sia_cap & BMSR_10TFDX)
5301 sc->sc_opmode |= OPMODE_FD;
5302 if (sc->sc_sia_cap & BMSR_10THDX)
5303 siatxrx |= SIATXRX_TH;
5304
5305 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
5306
5307 TULIP_WRITE(sc, CSR_SIACONN, 0);
5308 delay(1000);
5309 TULIP_WRITE(sc, CSR_SIATXRX, siatxrx);
5310 TULIP_WRITE(sc, CSR_SIACONN, SIACONN_SRL);
5311
5312 siastat = TULIP_READ(sc, CSR_SIASTAT);
5313 siastat &= ~(SIASTAT_ANS|SIASTAT_LPC|SIASTAT_TRA|SIASTAT_ARA|
5314 SIASTAT_LS100|SIASTAT_LS10|SIASTAT_MRA);
5315 siastat |= SIASTAT_ANS_TXDIS;
5316 TULIP_WRITE(sc, CSR_SIASTAT, siastat);
5317}
5318
5319static void
5320tlp_2114x_nway_status(struct tulip_softc *sc)
5321{
5322 struct mii_data *mii = &sc->sc_mii;
5323 uint32_t siatxrx, siastat, anlpar;
5324
5325 mii->mii_media_status = IFM_AVALID;
5326 mii->mii_media_active = IFM_ETHER;
5327
5328 if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
5329 return;
5330
5331 siastat = TULIP_READ(sc, CSR_SIASTAT);
5332 siatxrx = TULIP_READ(sc, CSR_SIATXRX);
5333
5334 if (siatxrx & SIATXRX_ANE) {
5335 if ((siastat & SIASTAT_ANS) != SIASTAT_ANS_FLPGOOD) {
5336 /* Erg, still trying, I guess... */
5337 mii->mii_media_active |= IFM_NONE;
5338 return;
5339 }
5340
5341 if (~siastat & (SIASTAT_LS10 | SIASTAT_LS100))
5342 mii->mii_media_status |= IFM_ACTIVE;
5343
5344 if (siastat & SIASTAT_LPN) {
5345 anlpar = SIASTAT_GETLPC(siastat);
5346 if (anlpar & ANLPAR_T4 &&
5347 sc->sc_sia_cap & BMSR_100T4)
5348 mii->mii_media_active |= IFM_100_T4;
5349 else if (anlpar & ANLPAR_TX_FD &&
5350 sc->sc_sia_cap & BMSR_100TXFDX)
5351 mii->mii_media_active |= IFM_100_TX|IFM_FDX;
5352 else if (anlpar & ANLPAR_TX &&
5353 sc->sc_sia_cap & BMSR_100TXHDX)
5354 mii->mii_media_active |= IFM_100_TX;
5355 else if (anlpar & ANLPAR_10_FD &&
5356 sc->sc_sia_cap & BMSR_10TFDX)
5357 mii->mii_media_active |= IFM_10_T|IFM_FDX;
5358 else if (anlpar & ANLPAR_10 &&
5359 sc->sc_sia_cap & BMSR_10THDX)
5360 mii->mii_media_active |= IFM_10_T;
5361 else
5362 mii->mii_media_active |= IFM_NONE;
5363 } else {
5364 /*
5365 * If the other side doesn't support NWAY, then the
5366 * best we can do is determine if we have a 10Mbps or
5367 * 100Mbps link. There's no way to know if the link
5368 * is full or half duplex, so we default to half duplex
5369 * and hope that the user is clever enough to manually
5370 * change the media settings if we're wrong.
5371 */
5372 if ((siastat & SIASTAT_LS100) == 0)
5373 mii->mii_media_active |= IFM_100_TX;
5374 else if ((siastat & SIASTAT_LS10) == 0)
5375 mii->mii_media_active |= IFM_10_T;
5376 else
5377 mii->mii_media_active |= IFM_NONE;
5378 }
5379 } else {
5380 if (~siastat & (SIASTAT_LS10 | SIASTAT_LS100))
5381 mii->mii_media_status |= IFM_ACTIVE;
5382
5383 if (sc->sc_opmode & OPMODE_TTM)
5384 mii->mii_media_active |= IFM_10_T;
5385 else
5386 mii->mii_media_active |= IFM_100_TX;
5387 if (sc->sc_opmode & OPMODE_FD)
5388 mii->mii_media_active |= IFM_FDX;
5389 }
5390}
5391
5392static void
5393tlp_2114x_isv_tmsw_get(struct tulip_softc *sc, struct ifmediareq *ifmr)
5394{
5395 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
5396 struct tulip_21x4x_media *tm = ife->ifm_aux;
5397
5398 (*tm->tm_get)(sc, ifmr);
5399}
5400
5401static int
5402tlp_2114x_isv_tmsw_set(struct tulip_softc *sc)
5403{
5404 struct ifmedia_entry *ife = sc->sc_mii.mii_media.ifm_cur;
5405 struct tulip_21x4x_media *tm = ife->ifm_aux;
5406
5407 /*
5408 * Check to see if we need to reset the chip, and do it. The
5409 * reset path will get the OPMODE register right the next
5410 * time through.
5411 */
5412 if (TULIP_MEDIA_NEEDSRESET(sc, tm->tm_opmode))
5413 return (tlp_init(&sc->sc_ethercom.ec_if));
5414
5415 return ((*tm->tm_set)(sc));
5416}
5417
5418/*
5419 * MII-on-SIO media switch. Handles only MII attached to the SIO.
5420 */
5421static void tlp_sio_mii_tmsw_init(struct tulip_softc *);
5422
5423const struct tulip_mediasw tlp_sio_mii_mediasw = {
5424 tlp_sio_mii_tmsw_init, tlp_mii_getmedia, tlp_mii_setmedia
5425};
5426
5427static void
5428tlp_sio_mii_tmsw_init(struct tulip_softc *sc)
5429{
5430 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
5431
5432 /*
5433 * We don't attach any media info structures to the ifmedia
5434 * entries, so if we're using a pre-init function that needs
5435 * that info, override it to one that doesn't.
5436 */
5437 if (sc->sc_preinit == tlp_2114x_preinit)
5438 sc->sc_preinit = tlp_2114x_mii_preinit;
5439
5440 sc->sc_mii.mii_ifp = ifp;
5441 sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
5442 sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
5443 sc->sc_mii.mii_statchg = sc->sc_statchg;
5444 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
5445 tlp_mediastatus);
5446 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, MII_PHY_ANY,
5447 MII_OFFSET_ANY, 0);
5448 if (LIST_FIRST(&sc->sc_mii.mii_phys) == NULL) {
5449 ifmedia_add(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE, 0, NULL);
5450 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE);
5451 } else {
5452 sc->sc_flags |= TULIPF_HAS_MII;
5453 sc->sc_tick = tlp_mii_tick;
5454 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_AUTO);
5455 }
5456}
5457
5458/*
5459 * Lite-On PNIC media switch. Must handle MII or internal NWAY.
5460 */
5461static void tlp_pnic_tmsw_init(struct tulip_softc *);
5462static void tlp_pnic_tmsw_get(struct tulip_softc *, struct ifmediareq *);
5463static int tlp_pnic_tmsw_set(struct tulip_softc *);
5464
5465const struct tulip_mediasw tlp_pnic_mediasw = {
5466 tlp_pnic_tmsw_init, tlp_pnic_tmsw_get, tlp_pnic_tmsw_set
5467};
5468
5469static void tlp_pnic_nway_statchg(struct ifnet *);
5470static void tlp_pnic_nway_tick(void *);
5471static int tlp_pnic_nway_service(struct tulip_softc *, int);
5472static void tlp_pnic_nway_reset(struct tulip_softc *);
5473static int tlp_pnic_nway_auto(struct tulip_softc *, int);
5474static void tlp_pnic_nway_auto_timeout(void *);
5475static void tlp_pnic_nway_status(struct tulip_softc *);
5476static void tlp_pnic_nway_acomp(struct tulip_softc *);
5477
5478static void
5479tlp_pnic_tmsw_init(struct tulip_softc *sc)
5480{
5481 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
5482 const char *sep = "";
5483
5484#define ADD(m, c) ifmedia_add(&sc->sc_mii.mii_media, (m), (c), NULL)
5485#define PRINT(str) aprint_normal("%s%s", sep, str); sep = ", "
5486
5487 sc->sc_mii.mii_ifp = ifp;
5488 sc->sc_mii.mii_readreg = tlp_pnic_mii_readreg;
5489 sc->sc_mii.mii_writereg = tlp_pnic_mii_writereg;
5490 sc->sc_mii.mii_statchg = sc->sc_statchg;
5491 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
5492 tlp_mediastatus);
5493 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, MII_PHY_ANY,
5494 MII_OFFSET_ANY, 0);
5495 if (LIST_FIRST(&sc->sc_mii.mii_phys) == NULL) {
5496 /* XXX What about AUI/BNC support? */
5497 aprint_normal_dev(sc->sc_dev, "");
5498
5499 tlp_pnic_nway_reset(sc);
5500
5501 ADD(IFM_MAKEWORD(IFM_ETHER, IFM_10_T, 0, 0),
5502 PNIC_NWAY_TW|PNIC_NWAY_CAP10T);
5503 PRINT("10baseT");
5504
5505 ADD(IFM_MAKEWORD(IFM_ETHER, IFM_10_T, IFM_FDX, 0),
5506 PNIC_NWAY_TW|PNIC_NWAY_FD|PNIC_NWAY_CAP10TFDX);
5507 PRINT("10baseT-FDX");
5508
5509 ADD(IFM_MAKEWORD(IFM_ETHER, IFM_100_TX, 0, 0),
5510 PNIC_NWAY_TW|PNIC_NWAY_100|PNIC_NWAY_CAP100TX);
5511 PRINT("100baseTX");
5512
5513 ADD(IFM_MAKEWORD(IFM_ETHER, IFM_100_TX, IFM_FDX, 0),
5514 PNIC_NWAY_TW|PNIC_NWAY_100|PNIC_NWAY_FD|
5515 PNIC_NWAY_CAP100TXFDX);
5516 PRINT("100baseTX-FDX");
5517
5518 ADD(IFM_MAKEWORD(IFM_ETHER, IFM_AUTO, 0, 0),
5519 PNIC_NWAY_TW|PNIC_NWAY_RN|PNIC_NWAY_NW|
5520 PNIC_NWAY_CAP10T|PNIC_NWAY_CAP10TFDX|
5521 PNIC_NWAY_CAP100TXFDX|PNIC_NWAY_CAP100TX);
5522 PRINT("auto");
5523
5524 aprint_normal("\n");
5525
5526 sc->sc_statchg = tlp_pnic_nway_statchg;
5527 sc->sc_tick = tlp_pnic_nway_tick;
5528 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_AUTO);
5529 } else {
5530 sc->sc_flags |= TULIPF_HAS_MII;
5531 sc->sc_tick = tlp_mii_tick;
5532 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_AUTO);
5533 }
5534
5535#undef ADD
5536#undef PRINT
5537}
5538
5539static void
5540tlp_pnic_tmsw_get(struct tulip_softc *sc, struct ifmediareq *ifmr)
5541{
5542 struct mii_data *mii = &sc->sc_mii;
5543
5544 if (sc->sc_flags & TULIPF_HAS_MII)
5545 tlp_mii_getmedia(sc, ifmr);
5546 else {
5547 mii->mii_media_status = 0;
5548 mii->mii_media_active = IFM_NONE;
5549 tlp_pnic_nway_service(sc, MII_POLLSTAT);
5550 ifmr->ifm_status = sc->sc_mii.mii_media_status;
5551 ifmr->ifm_active = sc->sc_mii.mii_media_active;
5552 }
5553}
5554
5555static int
5556tlp_pnic_tmsw_set(struct tulip_softc *sc)
5557{
5558 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
5559 struct mii_data *mii = &sc->sc_mii;
5560
5561 if (sc->sc_flags & TULIPF_HAS_MII) {
5562 /*
5563 * Make sure the built-in Tx jabber timer is disabled.
5564 */
5565 TULIP_WRITE(sc, CSR_PNIC_ENDEC, PNIC_ENDEC_JDIS);
5566
5567 return (tlp_mii_setmedia(sc));
5568 }
5569
5570 if (ifp->if_flags & IFF_UP) {
5571 mii->mii_media_status = 0;
5572 mii->mii_media_active = IFM_NONE;
5573 return (tlp_pnic_nway_service(sc, MII_MEDIACHG));
5574 }
5575
5576 return (0);
5577}
5578
5579static void
5580tlp_pnic_nway_statchg(struct ifnet *ifp)
5581{
5582 struct tulip_softc *sc = ifp->if_softc;
5583
5584 /* Idle the transmit and receive processes. */
5585 tlp_idle(sc, OPMODE_ST|OPMODE_SR);
5586
5587 sc->sc_opmode &= ~(OPMODE_TTM|OPMODE_FD|OPMODE_PS|OPMODE_PCS|
5588 OPMODE_SCR|OPMODE_HBD);
5589
5590 if (IFM_SUBTYPE(sc->sc_mii.mii_media_active) == IFM_10_T) {
5591 sc->sc_opmode |= OPMODE_TTM;
5592 TULIP_WRITE(sc, CSR_GPP,
5593 GPP_PNIC_OUT(GPP_PNIC_PIN_SPEED_RLY, 0) |
5594 GPP_PNIC_OUT(GPP_PNIC_PIN_100M_LPKB, 1));
5595 } else {
5596 sc->sc_opmode |= OPMODE_PS|OPMODE_PCS|OPMODE_SCR|OPMODE_HBD;
5597 TULIP_WRITE(sc, CSR_GPP,
5598 GPP_PNIC_OUT(GPP_PNIC_PIN_SPEED_RLY, 1) |
5599 GPP_PNIC_OUT(GPP_PNIC_PIN_100M_LPKB, 1));
5600 }
5601
5602 if (sc->sc_mii.mii_media_active & IFM_FDX)
5603 sc->sc_opmode |= OPMODE_FD|OPMODE_HBD;
5604
5605 /*
5606 * Write new OPMODE bits. This also restarts the transmit
5607 * and receive processes.
5608 */
5609 TULIP_WRITE(sc, CSR_OPMODE, sc->sc_opmode);
5610}
5611
5612static void
5613tlp_pnic_nway_tick(void *arg)
5614{
5615 struct tulip_softc *sc = arg;
5616 int s;
5617
5618 if (!device_is_active(sc->sc_dev))
5619 return;
5620
5621 s = splnet();
5622 tlp_pnic_nway_service(sc, MII_TICK);
5623 splx(s);
5624
5625 callout_reset(&sc->sc_tick_callout, hz, tlp_pnic_nway_tick, sc);
5626}
5627
5628/*
5629 * Support for the Lite-On PNIC internal NWay block. This is constructed
5630 * somewhat like a PHY driver for simplicity.
5631 */
5632
5633static int
5634tlp_pnic_nway_service(struct tulip_softc *sc, int cmd)
5635{
5636 struct mii_data *mii = &sc->sc_mii;
5637 struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
5638
5639 if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
5640 return (0);
5641
5642 switch (cmd) {
5643 case MII_POLLSTAT:
5644 /* Nothing special to do here. */
5645 break;
5646
5647 case MII_MEDIACHG:
5648 switch (IFM_SUBTYPE(ife->ifm_media)) {
5649 case IFM_AUTO:
5650 (void) tlp_pnic_nway_auto(sc, 1);
5651 break;
5652 case IFM_100_T4:
5653 /*
5654 * XXX Not supported as a manual setting right now.
5655 */
5656 return (EINVAL);
5657 default:
5658 /*
5659 * NWAY register data is stored in the ifmedia entry.
5660 */
5661 TULIP_WRITE(sc, CSR_PNIC_NWAY, ife->ifm_data);
5662 }
5663 break;
5664
5665 case MII_TICK:
5666 /*
5667 * Only used for autonegotiation.
5668 */
5669 if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
5670 return (0);
5671
5672 /*
5673 * Check to see if we have link. If we do, we don't
5674 * need to restart the autonegotiation process.
5675 */
5676 if (sc->sc_flags & TULIPF_LINK_UP)
5677 return (0);
5678
5679 /*
5680 * Only retry autonegotiation every 5 seconds.
5681 */
5682 if (++sc->sc_nway_ticks != 5)
5683 return (0);
5684
5685 sc->sc_nway_ticks = 0;
5686 tlp_pnic_nway_reset(sc);
5687 if (tlp_pnic_nway_auto(sc, 0) == EJUSTRETURN)
5688 return (0);
5689 break;
5690 }
5691
5692 /* Update the media status. */
5693 tlp_pnic_nway_status(sc);
5694
5695 /* Callback if something changed. */
5696 if ((sc->sc_nway_active == NULL ||
5697 sc->sc_nway_active->ifm_media != mii->mii_media_active) ||
5698 cmd == MII_MEDIACHG) {
5699 (*sc->sc_statchg)(mii->mii_ifp);
5700 tlp_nway_activate(sc, mii->mii_media_active);
5701 }
5702 return (0);
5703}
5704
5705static void
5706tlp_pnic_nway_reset(struct tulip_softc *sc)
5707{
5708
5709 TULIP_WRITE(sc, CSR_PNIC_NWAY, PNIC_NWAY_RS);
5710 delay(100);
5711 TULIP_WRITE(sc, CSR_PNIC_NWAY, 0);
5712}
5713
5714static int
5715tlp_pnic_nway_auto(struct tulip_softc *sc, int waitfor)
5716{
5717 struct mii_data *mii = &sc->sc_mii;
5718 struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
5719 uint32_t reg;
5720 int i;
5721
5722 if ((sc->sc_flags & TULIPF_DOINGAUTO) == 0)
5723 TULIP_WRITE(sc, CSR_PNIC_NWAY, ife->ifm_data);
5724
5725 if (waitfor) {
5726 /* Wait 500ms for it to complete. */
5727 for (i = 0; i < 500; i++) {
5728 reg = TULIP_READ(sc, CSR_PNIC_NWAY);
5729 if (reg & PNIC_NWAY_LPAR_MASK) {
5730 tlp_pnic_nway_acomp(sc);
5731 return (0);
5732 }
5733 delay(1000);
5734 }
5735#if 0
5736 if ((reg & PNIC_NWAY_LPAR_MASK) == 0)
5737 aprint_error_dev(sc->sc_dev,
5738 "autonegotiation failed to complete\n");
5739#endif
5740
5741 /*
5742 * Don't need to worry about clearing DOINGAUTO.
5743 * If that's set, a timeout is pending, and it will
5744 * clear the flag.
5745 */
5746 return (EIO);
5747 }
5748
5749 /*
5750 * Just let it finish asynchronously. This is for the benefit of
5751 * the tick handler driving autonegotiation. Don't want 500ms
5752 * delays all the time while the system is running!
5753 */
5754 if ((sc->sc_flags & TULIPF_DOINGAUTO) == 0) {
5755 sc->sc_flags |= TULIPF_DOINGAUTO;
5756 callout_reset(&sc->sc_nway_callout, hz >> 1,
5757 tlp_pnic_nway_auto_timeout, sc);
5758 }
5759 return (EJUSTRETURN);
5760}
5761
5762static void
5763tlp_pnic_nway_auto_timeout(void *arg)
5764{
5765 struct tulip_softc *sc = arg;
5766 /* uint32_t reg; */
5767 int s;
5768
5769 s = splnet();
5770 sc->sc_flags &= ~TULIPF_DOINGAUTO;
5771 /* reg = */
5772 TULIP_READ(sc, CSR_PNIC_NWAY);
5773#if 0
5774 if ((reg & PNIC_NWAY_LPAR_MASK) == 0)
5775 aprint_error_dev(sc->sc_dev,
5776 "autonegotiation failed to complete\n");
5777#endif
5778
5779 tlp_pnic_nway_acomp(sc);
5780
5781 /* Update the media status. */
5782 (void) tlp_pnic_nway_service(sc, MII_POLLSTAT);
5783 splx(s);
5784}
5785
5786static void
5787tlp_pnic_nway_status(struct tulip_softc *sc)
5788{
5789 struct mii_data *mii = &sc->sc_mii;
5790 uint32_t reg;
5791
5792 mii->mii_media_status = IFM_AVALID;
5793 mii->mii_media_active = IFM_ETHER;
5794
5795 reg = TULIP_READ(sc, CSR_PNIC_NWAY);
5796
5797 if (sc->sc_flags & TULIPF_LINK_UP)
5798 mii->mii_media_status |= IFM_ACTIVE;
5799
5800 if (reg & PNIC_NWAY_NW) {
5801 if ((reg & PNIC_NWAY_LPAR_MASK) == 0) {
5802 /* Erg, still trying, I guess... */
5803 mii->mii_media_active |= IFM_NONE;
5804 return;
5805 }
5806
5807#if 0
5808 if (reg & PNIC_NWAY_LPAR100T4)
5809 mii->mii_media_active |= IFM_100_T4;
5810 else
5811#endif
5812 if (reg & PNIC_NWAY_LPAR100TXFDX)
5813 mii->mii_media_active |= IFM_100_TX|IFM_FDX;
5814 else if (reg & PNIC_NWAY_LPAR100TX)
5815 mii->mii_media_active |= IFM_100_TX;
5816 else if (reg & PNIC_NWAY_LPAR10TFDX)
5817 mii->mii_media_active |= IFM_10_T|IFM_FDX;
5818 else if (reg & PNIC_NWAY_LPAR10T)
5819 mii->mii_media_active |= IFM_10_T;
5820 else
5821 mii->mii_media_active |= IFM_NONE;
5822 } else {
5823 if (reg & PNIC_NWAY_100)
5824 mii->mii_media_active |= IFM_100_TX;
5825 else
5826 mii->mii_media_active |= IFM_10_T;
5827 if (reg & PNIC_NWAY_FD)
5828 mii->mii_media_active |= IFM_FDX;
5829 }
5830}
5831
5832static void
5833tlp_pnic_nway_acomp(struct tulip_softc *sc)
5834{
5835 uint32_t reg;
5836
5837 reg = TULIP_READ(sc, CSR_PNIC_NWAY);
5838 reg &= ~(PNIC_NWAY_FD|PNIC_NWAY_100|PNIC_NWAY_RN);
5839
5840 if (reg & (PNIC_NWAY_LPAR100TXFDX|PNIC_NWAY_LPAR100TX))
5841 reg |= PNIC_NWAY_100;
5842 if (reg & (PNIC_NWAY_LPAR10TFDX|PNIC_NWAY_LPAR100TXFDX))
5843 reg |= PNIC_NWAY_FD;
5844
5845 TULIP_WRITE(sc, CSR_PNIC_NWAY, reg);
5846}
5847
5848/*
5849 * Macronix PMAC and Lite-On PNIC-II media switch:
5850 *
5851 * MX98713 and MX98713A 21140-like MII or GPIO media.
5852 *
5853 * MX98713A 21143-like MII or SIA/SYM media.
5854 *
5855 * MX98715, MX98715A, MX98725, 21143-like SIA/SYM media.
5856 * 82C115, MX98715AEC-C, -E
5857 *
5858 * So, what we do here is fake MII-on-SIO or ISV media info, and
5859 * use the ISV media switch get/set functions to handle the rest.
5860 */
5861
5862static void tlp_pmac_tmsw_init(struct tulip_softc *);
5863
5864const struct tulip_mediasw tlp_pmac_mediasw = {
5865 tlp_pmac_tmsw_init, tlp_2114x_isv_tmsw_get, tlp_2114x_isv_tmsw_set
5866};
5867
5868const struct tulip_mediasw tlp_pmac_mii_mediasw = {
5869 tlp_pmac_tmsw_init, tlp_mii_getmedia, tlp_mii_setmedia
5870};
5871
5872static void
5873tlp_pmac_tmsw_init(struct tulip_softc *sc)
5874{
5875 static const uint8_t media[] = {
5876 TULIP_ROM_MB_MEDIA_TP,
5877 TULIP_ROM_MB_MEDIA_TP_FDX,
5878 TULIP_ROM_MB_MEDIA_100TX,
5879 TULIP_ROM_MB_MEDIA_100TX_FDX,
5880 };
5881 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
5882 struct tulip_21x4x_media *tm;
5883
5884 sc->sc_mii.mii_ifp = ifp;
5885 sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
5886 sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
5887 sc->sc_mii.mii_statchg = sc->sc_statchg;
5888 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
5889 tlp_mediastatus);
5890 if (sc->sc_chip == TULIP_CHIP_MX98713 ||
5891 sc->sc_chip == TULIP_CHIP_MX98713A) {
5892 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff,
5893 MII_PHY_ANY, MII_OFFSET_ANY, 0);
5894 if (LIST_FIRST(&sc->sc_mii.mii_phys) != NULL) {
5895 sc->sc_flags |= TULIPF_HAS_MII;
5896 sc->sc_tick = tlp_mii_tick;
5897 sc->sc_preinit = tlp_2114x_mii_preinit;
5898 sc->sc_mediasw = &tlp_pmac_mii_mediasw;
5899 ifmedia_set(&sc->sc_mii.mii_media,
5900 IFM_ETHER|IFM_AUTO);
5901 return;
5902 }
5903 }
5904
5905 switch (sc->sc_chip) {
5906 case TULIP_CHIP_MX98713:
5907 tlp_add_srom_media(sc, TULIP_ROM_MB_21140_GPR,
5908 tlp_21140_gpio_get, tlp_21140_gpio_set, media, 4);
5909
5910 /*
5911 * XXX Should implement auto-sense for this someday,
5912 * XXX when we do the same for the 21140.
5913 */
5914 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_10_T);
5915 break;
5916
5917 default:
5918 tlp_add_srom_media(sc, TULIP_ROM_MB_21142_SIA,
5919 tlp_sia_get, tlp_sia_set, media, 2);
5920 tlp_add_srom_media(sc, TULIP_ROM_MB_21143_SYM,
5921 tlp_sia_get, tlp_sia_set, media + 2, 2);
5922
5923 tm = malloc(sizeof(*tm), M_DEVBUF, M_WAITOK|M_ZERO);
5924 tm->tm_name = "auto";
5925 tm->tm_get = tlp_2114x_nway_get;
5926 tm->tm_set = tlp_2114x_nway_set;
5927 ifmedia_add(&sc->sc_mii.mii_media,
5928 IFM_MAKEWORD(IFM_ETHER, IFM_AUTO, 0, 0), 0, tm);
5929
5930 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_AUTO);
5931 sc->sc_statchg = tlp_2114x_nway_statchg;
5932 sc->sc_tick = tlp_2114x_nway_tick;
5933 break;
5934 }
5935
5936 tlp_print_media(sc);
5937 tlp_sia_fixup(sc);
5938
5939 /* Set the LED modes. */
5940 tlp_pmac_reset(sc);
5941
5942 sc->sc_reset = tlp_pmac_reset;
5943}
5944
5945/*
5946 * ADMtek AL981 media switch. Only has internal PHY.
5947 */
5948static void tlp_al981_tmsw_init(struct tulip_softc *);
5949
5950const struct tulip_mediasw tlp_al981_mediasw = {
5951 tlp_al981_tmsw_init, tlp_mii_getmedia, tlp_mii_setmedia
5952};
5953
5954static void
5955tlp_al981_tmsw_init(struct tulip_softc *sc)
5956{
5957 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
5958
5959 sc->sc_mii.mii_ifp = ifp;
5960 sc->sc_mii.mii_readreg = tlp_al981_mii_readreg;
5961 sc->sc_mii.mii_writereg = tlp_al981_mii_writereg;
5962 sc->sc_mii.mii_statchg = sc->sc_statchg;
5963 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
5964 tlp_mediastatus);
5965 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, MII_PHY_ANY,
5966 MII_OFFSET_ANY, 0);
5967 if (LIST_FIRST(&sc->sc_mii.mii_phys) == NULL) {
5968 ifmedia_add(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE, 0, NULL);
5969 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE);
5970 } else {
5971 sc->sc_flags |= TULIPF_HAS_MII;
5972 sc->sc_tick = tlp_mii_tick;
5973 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_AUTO);
5974 }
5975}
5976
5977/*
5978 * ADMtek AN983/985 media switch. Only has internal PHY, but
5979 * on an SIO-like interface. Unfortunately, we can't use the
5980 * standard SIO media switch, because the AN985 "ghosts" the
5981 * singly PHY at every address.
5982 */
5983static void tlp_an985_tmsw_init(struct tulip_softc *);
5984
5985const struct tulip_mediasw tlp_an985_mediasw = {
5986 tlp_an985_tmsw_init, tlp_mii_getmedia, tlp_mii_setmedia
5987};
5988
5989static void
5990tlp_an985_tmsw_init(struct tulip_softc *sc)
5991{
5992 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
5993
5994 sc->sc_mii.mii_ifp = ifp;
5995 sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
5996 sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
5997 sc->sc_mii.mii_statchg = sc->sc_statchg;
5998 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
5999 tlp_mediastatus);
6000 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, 1,
6001 MII_OFFSET_ANY, 0);
6002 if (LIST_FIRST(&sc->sc_mii.mii_phys) == NULL) {
6003 ifmedia_add(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE, 0, NULL);
6004 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE);
6005 } else {
6006 sc->sc_flags |= TULIPF_HAS_MII;
6007 sc->sc_tick = tlp_mii_tick;
6008 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_AUTO);
6009 }
6010}
6011
6012/*
6013 * Davicom DM9102 media switch. Internal PHY and possibly HomePNA.
6014 */
6015static void tlp_dm9102_tmsw_init(struct tulip_softc *);
6016static void tlp_dm9102_tmsw_getmedia(struct tulip_softc *,
6017 struct ifmediareq *);
6018static int tlp_dm9102_tmsw_setmedia(struct tulip_softc *);
6019
6020const struct tulip_mediasw tlp_dm9102_mediasw = {
6021 tlp_dm9102_tmsw_init, tlp_dm9102_tmsw_getmedia,
6022 tlp_dm9102_tmsw_setmedia
6023};
6024
6025static void
6026tlp_dm9102_tmsw_init(struct tulip_softc *sc)
6027{
6028 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
6029 uint32_t opmode;
6030
6031 sc->sc_mii.mii_ifp = ifp;
6032 sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
6033 sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
6034 sc->sc_mii.mii_statchg = sc->sc_statchg;
6035 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
6036 tlp_mediastatus);
6037
6038 /* PHY block already reset via tlp_reset(). */
6039
6040 /*
6041 * Configure OPMODE properly for the internal MII interface.
6042 */
6043 switch (sc->sc_chip) {
6044 case TULIP_CHIP_DM9102:
6045 opmode = OPMODE_MBO|OPMODE_HBD|OPMODE_PS;
6046 break;
6047
6048 case TULIP_CHIP_DM9102A:
6049 opmode = OPMODE_MBO|OPMODE_HBD;
6050 break;
6051
6052 default:
6053 opmode = 0;
6054 break;
6055 }
6056
6057 TULIP_WRITE(sc, CSR_OPMODE, opmode);
6058
6059 /* Now, probe the internal MII for the internal PHY. */
6060 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, MII_PHY_ANY,
6061 MII_OFFSET_ANY, 0);
6062
6063 /*
6064 * XXX Figure out what to do about the HomePNA portion
6065 * XXX of the DM9102A.
6066 */
6067
6068 if (LIST_FIRST(&sc->sc_mii.mii_phys) == NULL) {
6069 ifmedia_add(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE, 0, NULL);
6070 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE);
6071 } else {
6072 sc->sc_flags |= TULIPF_HAS_MII;
6073 sc->sc_tick = tlp_mii_tick;
6074 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_AUTO);
6075 }
6076}
6077
6078static void
6079tlp_dm9102_tmsw_getmedia(struct tulip_softc *sc, struct ifmediareq *ifmr)
6080{
6081
6082 /* XXX HomePNA on DM9102A. */
6083 tlp_mii_getmedia(sc, ifmr);
6084}
6085
6086static int
6087tlp_dm9102_tmsw_setmedia(struct tulip_softc *sc)
6088{
6089
6090 /* XXX HomePNA on DM9102A. */
6091 return (tlp_mii_setmedia(sc));
6092}
6093
6094/*
6095 * ASIX AX88140A/AX88141 media switch. Internal PHY or MII.
6096 */
6097
6098static void tlp_asix_tmsw_init(struct tulip_softc *);
6099static void tlp_asix_tmsw_getmedia(struct tulip_softc *,
6100 struct ifmediareq *);
6101static int tlp_asix_tmsw_setmedia(struct tulip_softc *);
6102
6103const struct tulip_mediasw tlp_asix_mediasw = {
6104 tlp_asix_tmsw_init, tlp_asix_tmsw_getmedia,
6105 tlp_asix_tmsw_setmedia
6106};
6107
6108static void
6109tlp_asix_tmsw_init(struct tulip_softc *sc)
6110{
6111 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
6112 uint32_t opmode;
6113
6114 sc->sc_mii.mii_ifp = ifp;
6115 sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
6116 sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
6117 sc->sc_mii.mii_statchg = sc->sc_statchg;
6118 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
6119 tlp_mediastatus);
6120
6121 /*
6122 * Configure OPMODE properly for the internal MII interface.
6123 */
6124 switch (sc->sc_chip) {
6125 case TULIP_CHIP_AX88140:
6126 case TULIP_CHIP_AX88141:
6127 opmode = OPMODE_HBD|OPMODE_PS;
6128 break;
6129 default:
6130 opmode = 0;
6131 break;
6132 }
6133
6134 TULIP_WRITE(sc, CSR_OPMODE, opmode);
6135
6136 /* Now, probe the internal MII for the internal PHY. */
6137 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, MII_PHY_ANY,
6138 MII_OFFSET_ANY, 0);
6139
6140 /* XXX Figure how to handle the PHY. */
6141
6142 if (LIST_FIRST(&sc->sc_mii.mii_phys) == NULL) {
6143 ifmedia_add(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE, 0, NULL);
6144 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE);
6145 } else {
6146 sc->sc_flags |= TULIPF_HAS_MII;
6147 sc->sc_tick = tlp_mii_tick;
6148 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_AUTO);
6149 }
6150
6151
6152}
6153
6154static void
6155tlp_asix_tmsw_getmedia(struct tulip_softc *sc, struct ifmediareq *ifmr)
6156{
6157
6158 /* XXX PHY handling. */
6159 tlp_mii_getmedia(sc, ifmr);
6160}
6161
6162static int
6163tlp_asix_tmsw_setmedia(struct tulip_softc *sc)
6164{
6165
6166 /* XXX PHY handling. */
6167 return (tlp_mii_setmedia(sc));
6168}
6169
6170/*
6171 * RS7112 media switch. Handles only MII attached to the SIO.
6172 * We only have a PHY at 1.
6173 */
6174void tlp_rs7112_tmsw_init(struct tulip_softc *);
6175
6176const struct tulip_mediasw tlp_rs7112_mediasw = {
6177 tlp_rs7112_tmsw_init, tlp_mii_getmedia, tlp_mii_setmedia
6178};
6179
6180void
6181tlp_rs7112_tmsw_init(struct tulip_softc *sc)
6182{
6183 struct ifnet *ifp = &sc->sc_ethercom.ec_if;
6184
6185 /*
6186 * We don't attach any media info structures to the ifmedia
6187 * entries, so if we're using a pre-init function that needs
6188 * that info, override it to one that doesn't.
6189 */
6190 if (sc->sc_preinit == tlp_2114x_preinit)
6191 sc->sc_preinit = tlp_2114x_mii_preinit;
6192
6193 sc->sc_mii.mii_ifp = ifp;
6194 sc->sc_mii.mii_readreg = tlp_bitbang_mii_readreg;
6195 sc->sc_mii.mii_writereg = tlp_bitbang_mii_writereg;
6196 sc->sc_mii.mii_statchg = sc->sc_statchg;
6197 ifmedia_init(&sc->sc_mii.mii_media, 0, tlp_mediachange,
6198 tlp_mediastatus);
6199
6200 /*
6201 * The RS7112 reports a PHY at 0 (possibly HomePNA?)
6202 * and 1 (ethernet). We attach ethernet only.
6203 */
6204 mii_attach(sc->sc_dev, &sc->sc_mii, 0xffffffff, 1,
6205 MII_OFFSET_ANY, 0);
6206
6207 if (LIST_FIRST(&sc->sc_mii.mii_phys) == NULL) {
6208 ifmedia_add(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE, 0, NULL);
6209 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_NONE);
6210 } else {
6211 sc->sc_flags |= TULIPF_HAS_MII;
6212 sc->sc_tick = tlp_mii_tick;
6213 ifmedia_set(&sc->sc_mii.mii_media, IFM_ETHER|IFM_AUTO);
6214 }
6215}
6216
6217const char *
6218tlp_chip_name(tulip_chip_t t) {
6219 if ((int)t < 0 || (int)t >= __arraycount(tlp_chip_names)) {
6220 static char buf[256];
6221 (void)snprintf(buf, sizeof(buf), "[unknown 0x%x]", t);
6222 return buf;
6223 }
6224 return tlp_chip_names[t];
6225}
6226