![[BACK]](/icons/back.gif){kind=icon}
Return to be.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / dev|
Return to be.c CVS log | Up to [local] / sys / arch / sparc / dev |
1.1 nbrk 1: /* $OpenBSD: be.c,v 1.40 2006/05/27 23:59:07 jason Exp $ */
2:
3: /*
4: * Copyright (c) 1998 Theo de Raadt and Jason L. Wright.
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19: * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26: */
27:
28: #include <sys/param.h>
29: #include <sys/systm.h>
30: #include <sys/kernel.h>
31: #include <sys/errno.h>
32: #include <sys/ioctl.h>
33: #include <sys/mbuf.h>
34: #include <sys/socket.h>
35: #include <sys/syslog.h>
36: #include <sys/device.h>
37: #include <sys/malloc.h>
38: #include <sys/timeout.h>
39:
40: #include <net/if.h>
41: #include <net/if_dl.h>
42: #include <net/if_types.h>
43: #include <net/netisr.h>
44: #include <net/if_media.h>
45:
46: #ifdef INET
47: #include <netinet/in.h>
48: #include <netinet/in_systm.h>
49: #include <netinet/in_var.h>
50: #include <netinet/ip.h>
51: #include <netinet/if_ether.h>
52: #endif
53:
54: #include "bpfilter.h"
55: #if NBPFILTER > 0
56: #include <net/bpf.h>
57: #include <net/bpfdesc.h>
58: #endif
59:
60: #include <machine/autoconf.h>
61: #include <machine/cpu.h>
62:
63: #include <sparc/dev/sbusvar.h>
64: #include <sparc/dev/dmareg.h>
65: #include <sparc/dev/dmavar.h>
66:
67: #include <sparc/dev/qecvar.h>
68: #include <sparc/dev/qecreg.h>
69: #include <sparc/dev/bereg.h>
70: #include <sparc/dev/bevar.h>
71:
72: int bematch(struct device *, void *, void *);
73: void beattach(struct device *, struct device *, void *);
74:
75: void beinit(struct besoftc *);
76: void bestart(struct ifnet *);
77: void bestop(struct besoftc *);
78: void bewatchdog(struct ifnet *);
79: int beioctl(struct ifnet *, u_long, caddr_t);
80: void bereset(struct besoftc *);
81:
82: int beintr(void *);
83: int berint(struct besoftc *);
84: int betint(struct besoftc *);
85: int beqint(struct besoftc *, u_int32_t);
86: int beeint(struct besoftc *, u_int32_t);
87: void be_read(struct besoftc *, int, int);
88:
89: void be_tcvr_idle(struct besoftc *);
90: void be_tcvr_init(struct besoftc *);
91: void be_tcvr_write(struct besoftc *, u_int8_t, u_int16_t);
92: void be_tcvr_write_bit(struct besoftc *, int);
93: int be_tcvr_read_bit1(struct besoftc *);
94: int be_tcvr_read_bit2(struct besoftc *);
95: int be_tcvr_read(struct besoftc *, u_int8_t);
96: void be_ifmedia_sts(struct ifnet *, struct ifmediareq *);
97: int be_ifmedia_upd(struct ifnet *);
98: void be_mcreset(struct besoftc *);
99: void betick(void *);
100: void be_tx_harvest(struct besoftc *);
101:
102: struct cfdriver be_cd = {
103: NULL, "be", DV_IFNET
104: };
105:
106: struct cfattach be_ca = {
107: sizeof(struct besoftc), bematch, beattach
108: };
109:
110: int
111: bematch(parent, vcf, aux)
112: struct device *parent;
113: void *vcf, *aux;
114: {
115: struct cfdata *cf = vcf;
116: struct confargs *ca = aux;
117: register struct romaux *ra = &ca->ca_ra;
118:
119: if (strcmp(cf->cf_driver->cd_name, ra->ra_name))
120: return (0);
121: return (1);
122: }
123:
124: void
125: beattach(parent, self, aux)
126: struct device *parent, *self;
127: void *aux;
128: {
129: struct qec_softc *qec = (struct qec_softc *)parent;
130: struct besoftc *sc = (struct besoftc *)self;
131: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
132: struct confargs *ca = aux;
133: struct bootpath *bp;
134: extern void myetheraddr(u_char *);
135: int pri, bmsr;
136:
137: if (ca->ca_ra.ra_nintr != 1) {
138: printf(": expected 1 interrupt, got %d\n", ca->ca_ra.ra_nintr);
139: return;
140: }
141: pri = ca->ca_ra.ra_intr[0].int_pri;
142: sc->sc_rev = getpropint(ca->ca_ra.ra_node, "board-version", -1);
143:
144: timeout_set(&sc->sc_tick, betick, sc);
145:
146: sc->sc_cr = mapiodev(&ca->ca_ra.ra_reg[0], 0, sizeof(struct be_cregs));
147: sc->sc_br = mapiodev(&ca->ca_ra.ra_reg[1], 0, sizeof(struct be_bregs));
148: sc->sc_tr = mapiodev(&ca->ca_ra.ra_reg[2], 0, sizeof(struct be_tregs));
149: sc->sc_qec = qec;
150: sc->sc_qr = qec->sc_regs;
151: bestop(sc);
152:
153: sc->sc_channel = getpropint(ca->ca_ra.ra_node, "channel#", -1);
154: if (sc->sc_channel == -1)
155: sc->sc_channel = 0;
156:
157: sc->sc_burst = getpropint(ca->ca_ra.ra_node, "burst-sizes", -1);
158: if (sc->sc_burst == -1)
159: sc->sc_burst = qec->sc_burst;
160:
161: /* Clamp at parent's burst sizes */
162: sc->sc_burst &= qec->sc_burst;
163:
164: sc->sc_ih.ih_fun = beintr;
165: sc->sc_ih.ih_arg = sc;
166: intr_establish(pri, &sc->sc_ih, IPL_NET, sc->sc_dev.dv_xname);
167:
168: myetheraddr(sc->sc_arpcom.ac_enaddr);
169:
170: be_tcvr_init(sc);
171:
172: ifmedia_init(&sc->sc_ifmedia, 0, be_ifmedia_upd, be_ifmedia_sts);
173: bmsr = be_tcvr_read(sc, PHY_BMSR);
174: if (bmsr == BE_TCVR_READ_INVALID)
175: return;
176:
177: if (bmsr & PHY_BMSR_10BASET_HALF) {
178: ifmedia_add(&sc->sc_ifmedia, IFM_ETHER | IFM_10_T, 0, NULL);
179: ifmedia_add(&sc->sc_ifmedia,
180: IFM_ETHER | IFM_10_T | IFM_HDX, 0, NULL);
181: sc->sc_ifmedia.ifm_media = IFM_ETHER | IFM_10_T | IFM_HDX;
182: }
183:
184: if (bmsr & PHY_BMSR_10BASET_FULL) {
185: ifmedia_add(&sc->sc_ifmedia,
186: IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL);
187: sc->sc_ifmedia.ifm_media = IFM_ETHER | IFM_10_T | IFM_FDX;
188: }
189:
190: if (bmsr & PHY_BMSR_100BASETX_HALF) {
191: ifmedia_add(&sc->sc_ifmedia, IFM_ETHER | IFM_100_TX, 0, NULL);
192: ifmedia_add(&sc->sc_ifmedia,
193: IFM_ETHER | IFM_100_TX | IFM_HDX, 0, NULL);
194: sc->sc_ifmedia.ifm_media = IFM_ETHER | IFM_100_TX | IFM_HDX;
195: }
196:
197: if (bmsr & PHY_BMSR_100BASETX_FULL) {
198: ifmedia_add(&sc->sc_ifmedia,
199: IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL);
200: sc->sc_ifmedia.ifm_media = IFM_ETHER | IFM_100_TX | IFM_FDX;
201: }
202:
203: if (bmsr & PHY_BMSR_100BASET4) {
204: ifmedia_add(&sc->sc_ifmedia,
205: IFM_ETHER | IFM_100_T4, 0, NULL);
206: sc->sc_ifmedia.ifm_media = IFM_ETHER | IFM_100_T4;
207: }
208:
209: if (bmsr & PHY_BMSR_ANC) {
210: ifmedia_add(&sc->sc_ifmedia,
211: IFM_ETHER | IFM_AUTO, 0, NULL);
212: sc->sc_ifmedia.ifm_media = IFM_ETHER | IFM_AUTO;
213: }
214:
215: ifmedia_set(&sc->sc_ifmedia, sc->sc_ifmedia.ifm_media);
216:
217: bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
218: ifp->if_softc = sc;
219: ifp->if_start = bestart;
220: ifp->if_ioctl = beioctl;
221: ifp->if_watchdog = bewatchdog;
222: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS |
223: IFF_MULTICAST;
224:
225: IFQ_SET_MAXLEN(&ifp->if_snd, BE_TX_RING_SIZE);
226: IFQ_SET_READY(&ifp->if_snd);
227:
228: /* Attach the interface. */
229: if_attach(ifp);
230: ether_ifattach(ifp);
231:
232: printf(" pri %d: rev %x address %s\n", pri, sc->sc_rev,
233: ether_sprintf(sc->sc_arpcom.ac_enaddr));
234:
235: bp = ca->ca_ra.ra_bp;
236: if (bp != NULL && strcmp(bp->name, "be") == 0 &&
237: sc->sc_dev.dv_unit == bp->val[1])
238: bp->dev = &sc->sc_dev;
239: }
240:
241: /*
242: * Start output on interface.
243: * We make two assumptions here:
244: * 1) that the current priority is set to splnet _before_ this code
245: * is called *and* is returned to the appropriate priority after
246: * return
247: * 2) that the IFF_OACTIVE flag is checked before this code is called
248: * (i.e. that the output part of the interface is idle)
249: */
250: void
251: bestart(ifp)
252: struct ifnet *ifp;
253: {
254: struct besoftc *sc = (struct besoftc *)ifp->if_softc;
255: struct mbuf *m;
256: int bix, len, cnt;
257:
258: if (sc->sc_no_td > 0) {
259: /* Try to free previous stuff */
260: be_tx_harvest(sc);
261: }
262:
263: if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
264: return;
265:
266: bix = sc->sc_last_td;
267: cnt = sc->sc_no_td;
268:
269: for (;;) {
270: IFQ_POLL(&ifp->if_snd, m);
271: if (m == NULL)
272: break;
273:
274: IFQ_DEQUEUE(&ifp->if_snd, m);
275:
276: #if NBPFILTER > 0
277: /*
278: * If BPF is listening on this interface, let it see the
279: * packet before we commit it to the wire.
280: */
281: if (ifp->if_bpf)
282: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
283: #endif
284:
285: /*
286: * Copy the mbuf chain into the transmit buffer.
287: */
288: len = qec_put(sc->sc_bufs->tx_buf[bix & BE_TX_RING_MASK], m);
289:
290: /*
291: * Initialize transmit registers and start transmission
292: */
293: sc->sc_desc->be_txd[bix].tx_flags =
294: BE_TXD_OWN | BE_TXD_SOP | BE_TXD_EOP |
295: (len & BE_TXD_LENGTH);
296: sc->sc_cr->ctrl = BE_CR_CTRL_TWAKEUP;
297:
298: if (++bix == BE_TX_RING_MAXSIZE)
299: bix = 0;
300:
301: if (++cnt == BE_TX_RING_SIZE) {
302: ifp->if_flags |= IFF_OACTIVE;
303: break;
304: }
305: }
306:
307: if (cnt > BE_TX_HIGH_WATER) {
308: /* turn on interrupt */
309: sc->sc_tx_intr = 1;
310: sc->sc_cr->timask = 0;
311: }
312:
313: if (cnt != sc->sc_no_td) {
314: ifp->if_timer = 5;
315: sc->sc_last_td = bix;
316: sc->sc_no_td = cnt;
317: }
318: }
319:
320: void
321: bestop(sc)
322: struct besoftc *sc;
323: {
324: int tries;
325:
326: sc->sc_arpcom.ac_if.if_timer = 0;
327: if (timeout_pending(&sc->sc_tick))
328: timeout_del(&sc->sc_tick);
329:
330: tries = 32;
331: sc->sc_br->tx_cfg = 0;
332: while (sc->sc_br->tx_cfg != 0 && --tries)
333: DELAY(20);
334:
335: tries = 32;
336: sc->sc_br->rx_cfg = 0;
337: while (sc->sc_br->rx_cfg != 0 && --tries)
338: DELAY(20);
339: }
340:
341: /*
342: * Reset interface.
343: */
344: void
345: bereset(sc)
346: struct besoftc *sc;
347: {
348: int s;
349:
350: s = splnet();
351: bestop(sc);
352: beinit(sc);
353: splx(s);
354: }
355:
356: void
357: bewatchdog(ifp)
358: struct ifnet *ifp;
359: {
360: struct besoftc *sc = ifp->if_softc;
361:
362: log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
363: ++sc->sc_arpcom.ac_if.if_oerrors;
364:
365: bereset(sc);
366: }
367:
368: int
369: beintr(v)
370: void *v;
371: {
372: struct besoftc *sc = (struct besoftc *)v;
373: u_int32_t whyq, whyb, whyc;
374: int r = 0;
375:
376: whyq = sc->sc_qr->stat; /* qec status */
377: whyc = sc->sc_cr->stat; /* be channel status */
378: whyb = sc->sc_br->stat; /* be status */
379:
380: if (whyq & QEC_STAT_BM)
381: r |= beeint(sc, whyb);
382:
383: if (whyq & QEC_STAT_ER)
384: r |= beqint(sc, whyc);
385:
386: if (sc->sc_tx_intr && (whyq & QEC_STAT_TX) && (whyc & BE_CR_STAT_TXIRQ))
387: r |= betint(sc);
388:
389: if (whyq & QEC_STAT_RX && whyc & BE_CR_STAT_RXIRQ)
390: r |= berint(sc);
391:
392: return (r);
393: }
394:
395: /*
396: * QEC Interrupt.
397: */
398: int
399: beqint(sc, why)
400: struct besoftc *sc;
401: u_int32_t why;
402: {
403: int r = 0, rst = 0;
404:
405: if (why & BE_CR_STAT_TXIRQ)
406: r |= 1;
407: if (why & BE_CR_STAT_RXIRQ)
408: r |= 1;
409:
410: if (why & BE_CR_STAT_ERRORS) {
411: r |= 1;
412: rst = 1;
413: }
414:
415: if (rst || r == 0) {
416: printf("%s:%s qstat=%b\n", sc->sc_dev.dv_xname,
417: (r) ? "" : " unexpected",
418: why, BE_CR_STAT_BITS);
419: printf("%s: resetting\n", sc->sc_dev.dv_xname);
420: bereset(sc);
421: }
422:
423: return r;
424: }
425:
426: /*
427: * Error interrupt.
428: */
429: int
430: beeint(sc, why)
431: struct besoftc *sc;
432: u_int32_t why;
433: {
434: int r = 0;
435:
436: if (why & (BE_BR_STAT_RFIFOVF | BE_BR_STAT_TFIFO_UND |
437: BE_BR_STAT_MAXPKTERR)) {
438: r |= 1;
439: }
440:
441: printf("%s:%s stat=%b\n", sc->sc_dev.dv_xname,
442: (r) ? "" : " unexpected", why, BE_BR_STAT_BITS);
443:
444: printf("%s: resetting\n", sc->sc_dev.dv_xname);
445: bereset(sc);
446:
447: return r;
448: }
449:
450: void
451: be_tx_harvest(sc)
452: struct besoftc *sc;
453: {
454: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
455: int bix, cnt;
456: struct be_txd txd;
457:
458: bix = sc->sc_first_td;
459: cnt = sc->sc_no_td;
460:
461: for (;;) {
462: if (cnt <= 0)
463: break;
464:
465: txd.tx_flags = sc->sc_desc->be_txd[bix].tx_flags;
466:
467: if (txd.tx_flags & BE_TXD_OWN)
468: break;
469:
470: ifp->if_opackets++;
471:
472: if (++bix == BE_TX_RING_MAXSIZE)
473: bix = 0;
474:
475: --cnt;
476: }
477:
478: if (cnt <= 0)
479: ifp->if_timer = 0;
480:
481: if (sc->sc_no_td != cnt) {
482: sc->sc_first_td = bix;
483: sc->sc_no_td = cnt;
484: ifp->if_flags &= ~IFF_OACTIVE;
485: }
486:
487: if (sc->sc_no_td < BE_TX_LOW_WATER) {
488: /* turn off interrupt */
489: sc->sc_tx_intr = 0;
490: sc->sc_cr->timask = 0xffffffff;
491: }
492: }
493:
494: /*
495: * Transmit interrupt.
496: */
497: int
498: betint(sc)
499: struct besoftc *sc;
500: {
501: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
502:
503: bestart(ifp);
504: return (1);
505: }
506:
507: /*
508: * Receive interrupt.
509: */
510: int
511: berint(sc)
512: struct besoftc *sc;
513: {
514: int bix, len;
515:
516: bix = sc->sc_last_rd;
517:
518: /*
519: * Process all buffers with valid data.
520: */
521: for (;;) {
522: if (sc->sc_desc->be_rxd[bix].rx_flags & BE_RXD_OWN)
523: break;
524:
525: len = sc->sc_desc->be_rxd[bix].rx_flags & BE_RXD_LENGTH;
526: be_read(sc, bix, len);
527:
528: sc->sc_desc->be_rxd[(bix + BE_RX_RING_SIZE) & BE_RX_RING_MAXMASK].rx_flags =
529: BE_RXD_OWN | (BE_PKT_BUF_SZ & BE_RXD_LENGTH);
530:
531: if (++bix == BE_RX_RING_MAXSIZE)
532: bix = 0;
533: }
534:
535: sc->sc_last_rd = bix;
536:
537: return 1;
538: }
539:
540: void
541: betick(vsc)
542: void *vsc;
543: {
544: struct besoftc *sc = vsc;
545: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
546: struct be_bregs *br = sc->sc_br;
547: int s;
548:
549: s = splnet();
550: /*
551: * Get collision counters
552: */
553: ifp->if_collisions += br->nc_ctr + br->fc_ctr + br->ex_ctr + br->lt_ctr;
554: br->nc_ctr = 0;
555: br->fc_ctr = 0;
556: br->ex_ctr = 0;
557: br->lt_ctr = 0;
558: bestart(ifp);
559: splx(s);
560: timeout_add(&sc->sc_tick, hz);
561: }
562:
563: int
564: beioctl(ifp, cmd, data)
565: struct ifnet *ifp;
566: u_long cmd;
567: caddr_t data;
568: {
569: struct besoftc *sc = ifp->if_softc;
570: struct ifaddr *ifa = (struct ifaddr *)data;
571: struct ifreq *ifr = (struct ifreq *)data;
572: int s, error = 0;
573:
574: s = splnet();
575:
576: switch (cmd) {
577: case SIOCSIFADDR:
578: ifp->if_flags |= IFF_UP;
579: switch (ifa->ifa_addr->sa_family) {
580: #ifdef INET
581: case AF_INET:
582: beinit(sc);
583: arp_ifinit(&sc->sc_arpcom, ifa);
584: break;
585: #endif /* INET */
586: default:
587: beinit(sc);
588: break;
589: }
590: break;
591:
592: case SIOCSIFFLAGS:
593: if ((ifp->if_flags & IFF_UP) == 0 &&
594: (ifp->if_flags & IFF_RUNNING) != 0) {
595: /*
596: * If interface is marked down and it is running, then
597: * stop it.
598: */
599: bestop(sc);
600: ifp->if_flags &= ~IFF_RUNNING;
601: } else if ((ifp->if_flags & IFF_UP) != 0 &&
602: (ifp->if_flags & IFF_RUNNING) == 0) {
603: /*
604: * If interface is marked up and it is stopped, then
605: * start it.
606: */
607: beinit(sc);
608: } else {
609: /*
610: * Reset the interface to pick up changes in any other
611: * flags that affect hardware registers.
612: */
613: bestop(sc);
614: beinit(sc);
615: }
616: break;
617:
618: case SIOCADDMULTI:
619: case SIOCDELMULTI:
620: error = (cmd == SIOCADDMULTI) ?
621: ether_addmulti(ifr, &sc->sc_arpcom):
622: ether_delmulti(ifr, &sc->sc_arpcom);
623:
624: if (error == ENETRESET) {
625: /*
626: * Multicast list has changed; set the hardware filter
627: * accordingly.
628: */
629: if (ifp->if_flags & IFF_RUNNING)
630: be_mcreset(sc);
631: error = 0;
632: }
633: break;
634: case SIOCGIFMEDIA:
635: case SIOCSIFMEDIA:
636: error = ifmedia_ioctl(ifp, ifr, &sc->sc_ifmedia, cmd);
637: break;
638: default:
639: if ((error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data)) > 0) {
640: splx(s);
641: return error;
642: }
643: error = ENOTTY;
644: break;
645: }
646: splx(s);
647: return error;
648: }
649:
650: void
651: beinit(sc)
652: struct besoftc *sc;
653: {
654: struct be_bregs *br = sc->sc_br;
655: struct be_cregs *cr = sc->sc_cr;
656: struct qec_softc *qec = sc->sc_qec;
657: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
658: int s = splnet();
659: int i;
660:
661: /*
662: * Allocate descriptor ring and buffers, if not already done
663: */
664: if (sc->sc_desc == NULL)
665: sc->sc_desc_dva = (struct be_desc *) dvma_malloc(
666: sizeof(struct be_desc), &sc->sc_desc, M_NOWAIT);
667: if (sc->sc_bufs == NULL)
668: sc->sc_bufs_dva = (struct be_bufs *) dvma_malloc(
669: sizeof(struct be_bufs), &sc->sc_bufs, M_NOWAIT);
670:
671: for (i = 0; i < BE_TX_RING_MAXSIZE; i++) {
672: sc->sc_desc->be_txd[i].tx_addr =
673: (u_int32_t)sc->sc_bufs_dva->tx_buf[i & BE_TX_RING_MASK];
674: sc->sc_desc->be_txd[i].tx_flags = 0;
675: }
676: for (i = 0; i < BE_RX_RING_MAXSIZE; i++) {
677: sc->sc_desc->be_rxd[i].rx_addr =
678: (u_int32_t)sc->sc_bufs_dva->rx_buf[i & BE_RX_RING_MASK];
679: if (i < BE_RX_RING_SIZE)
680: sc->sc_desc->be_rxd[i].rx_flags =
681: BE_RXD_OWN | (BE_PKT_BUF_SZ & BE_RXD_LENGTH);
682: else
683: sc->sc_desc->be_rxd[i].rx_flags = 0;
684: }
685:
686: sc->sc_first_td = sc->sc_last_td = sc->sc_no_td = 0;
687: sc->sc_last_rd = 0;
688:
689: be_tcvr_init(sc);
690:
691: be_ifmedia_upd(ifp);
692:
693: bestop(sc);
694:
695: br->mac_addr2 = (sc->sc_arpcom.ac_enaddr[4] << 8) |
696: sc->sc_arpcom.ac_enaddr[5];
697: br->mac_addr1 = (sc->sc_arpcom.ac_enaddr[2] << 8) |
698: sc->sc_arpcom.ac_enaddr[3];
699: br->mac_addr0 = (sc->sc_arpcom.ac_enaddr[0] << 8) |
700: sc->sc_arpcom.ac_enaddr[1];
701:
702: br->rx_cfg = BE_BR_RXCFG_HENABLE | BE_BR_RXCFG_FIFO;
703:
704: be_mcreset(sc);
705:
706: DELAY(20);
707:
708: br->tx_cfg = BE_BR_TXCFG_FIFO;
709: br->rand_seed = 0xbd;
710:
711: br->xif_cfg = BE_BR_XCFG_ODENABLE | BE_BR_XCFG_RESV;
712:
713: cr->rxds = (u_int32_t)sc->sc_desc_dva->be_rxd;
714: cr->txds = (u_int32_t)sc->sc_desc_dva->be_txd;
715:
716: cr->rxwbufptr = cr->rxrbufptr = sc->sc_channel * qec->sc_msize;
717: cr->txwbufptr = cr->txrbufptr = cr->rxrbufptr + qec->sc_rsize;
718:
719: /*
720: * Turn off counter expiration interrupts as well as
721: * 'gotframe' and 'sentframe'
722: */
723: br->imask = BE_BR_IMASK_GOTFRAME |
724: BE_BR_IMASK_RCNTEXP |
725: BE_BR_IMASK_ACNTEXP |
726: BE_BR_IMASK_CCNTEXP |
727: BE_BR_IMASK_LCNTEXP |
728: BE_BR_IMASK_CVCNTEXP |
729: BE_BR_IMASK_SENTFRAME |
730: BE_BR_IMASK_NCNTEXP |
731: BE_BR_IMASK_ECNTEXP |
732: BE_BR_IMASK_LCCNTEXP |
733: BE_BR_IMASK_FCNTEXP |
734: BE_BR_IMASK_DTIMEXP;
735:
736: cr->rimask = 0;
737:
738: /* disable tx interrupts initially */
739: cr->timask = 0xffffffff;
740: sc->sc_tx_intr = 0;
741:
742: cr->qmask = 0;
743: cr->bmask = 0;
744:
745: br->jsize = 4;
746:
747: cr->ccnt = 0;
748:
749: br->tx_cfg |= BE_BR_TXCFG_ENABLE;
750: br->rx_cfg |= BE_BR_RXCFG_ENABLE;
751:
752: ifp->if_flags |= IFF_RUNNING;
753: ifp->if_flags &= ~IFF_OACTIVE;
754: splx(s);
755:
756: timeout_add(&sc->sc_tick, hz);
757: bestart(ifp);
758: }
759:
760: /*
761: * Set the tcvr to an idle state
762: */
763: void
764: be_tcvr_idle(sc)
765: struct besoftc *sc;
766: {
767: struct be_tregs *tr = sc->sc_tr;
768: volatile u_int32_t x;
769: int i = 20;
770:
771: while (i--) {
772: tr->mgmt_pal = MGMT_PAL_INT_MDIO | MGMT_PAL_EXT_MDIO |
773: MGMT_PAL_OENAB;
774: x = tr->mgmt_pal;
775: tr->mgmt_pal = MGMT_PAL_INT_MDIO | MGMT_PAL_EXT_MDIO |
776: MGMT_PAL_OENAB | MGMT_PAL_DCLOCK;
777: x = tr->mgmt_pal;
778: }
779: }
780:
781: /*
782: * Initialize the transceiver and figure out whether we're using the
783: * external or internal one.
784: */
785: void
786: be_tcvr_init(sc)
787: struct besoftc *sc;
788: {
789: volatile u_int32_t x;
790: struct be_tregs *tr = sc->sc_tr;
791:
792: be_tcvr_idle(sc);
793:
794: if (sc->sc_rev != 1) {
795: printf("%s: rev %d PAL not supported.\n",
796: sc->sc_dev.dv_xname,
797: sc->sc_rev);
798: return;
799: }
800:
801: tr->mgmt_pal = MGMT_PAL_INT_MDIO | MGMT_PAL_EXT_MDIO | MGMT_PAL_DCLOCK;
802: x = tr->mgmt_pal;
803:
804: tr->mgmt_pal = MGMT_PAL_INT_MDIO | MGMT_PAL_EXT_MDIO;
805: x = tr->mgmt_pal;
806: DELAY(200);
807:
808: if (tr->mgmt_pal & MGMT_PAL_EXT_MDIO) {
809: sc->sc_tcvr_type = BE_TCVR_EXTERNAL;
810: tr->tcvr_pal = ~(TCVR_PAL_EXTLBACK | TCVR_PAL_MSENSE |
811: TCVR_PAL_LTENABLE);
812: x = tr->tcvr_pal;
813: }
814: else if (tr->mgmt_pal & MGMT_PAL_INT_MDIO) {
815: sc->sc_tcvr_type = BE_TCVR_INTERNAL;
816: tr->tcvr_pal = ~(TCVR_PAL_EXTLBACK | TCVR_PAL_MSENSE |
817: TCVR_PAL_LTENABLE | TCVR_PAL_SERIAL);
818: x = tr->tcvr_pal;
819: }
820: else {
821: printf("%s: no internal or external transceiver found.\n",
822: sc->sc_dev.dv_xname);
823: }
824: }
825:
826: int
827: be_tcvr_read(sc, reg)
828: struct besoftc *sc;
829: u_int8_t reg;
830: {
831: int phy, i;
832: u_int32_t ret = 0;
833:
834: if (sc->sc_tcvr_type == BE_TCVR_INTERNAL)
835: phy = BE_PHY_INTERNAL;
836: else if (sc->sc_tcvr_type == BE_TCVR_EXTERNAL)
837: phy = BE_PHY_EXTERNAL;
838: else {
839: printf("%s: invalid tcvr type\n", sc->sc_dev.dv_xname);
840: return BE_TCVR_READ_INVALID;
841: }
842:
843: be_tcvr_idle(sc);
844:
845: be_tcvr_write_bit(sc, 0);
846: be_tcvr_write_bit(sc, 1);
847: be_tcvr_write_bit(sc, 1);
848: be_tcvr_write_bit(sc, 0);
849:
850: for (i = 4; i >= 0; i--)
851: be_tcvr_write_bit(sc, (phy >> i) & 1);
852:
853: for (i = 4; i >= 0; i--)
854: be_tcvr_write_bit(sc, (reg >> i) & 1);
855:
856: if (sc->sc_tcvr_type == BE_TCVR_EXTERNAL) {
857: (void) be_tcvr_read_bit2(sc);
858: (void) be_tcvr_read_bit2(sc);
859:
860: for (i = 15; i >= 0; i--) {
861: int b;
862:
863: b = be_tcvr_read_bit2(sc);
864: ret |= (b & 1) << i;
865: }
866:
867: (void) be_tcvr_read_bit2(sc);
868: (void) be_tcvr_read_bit2(sc);
869: (void) be_tcvr_read_bit2(sc);
870: }
871: else {
872: (void) be_tcvr_read_bit1(sc);
873: (void) be_tcvr_read_bit1(sc);
874:
875: for (i = 15; i >= 0; i--) {
876: int b;
877:
878: b = be_tcvr_read_bit1(sc);
879: ret |= (b & 1) << i;
880: }
881:
882: (void) be_tcvr_read_bit1(sc);
883: (void) be_tcvr_read_bit1(sc);
884: (void) be_tcvr_read_bit1(sc);
885: }
886: return ret;
887: }
888:
889: int
890: be_tcvr_read_bit1(sc)
891: struct besoftc *sc;
892: {
893: volatile u_int32_t x;
894: struct be_tregs *tr = sc->sc_tr;
895: int ret = 0;
896:
897: if (sc->sc_tcvr_type == BE_TCVR_INTERNAL) {
898: tr->mgmt_pal = MGMT_PAL_EXT_MDIO;
899: x = tr->mgmt_pal;
900: tr->mgmt_pal = MGMT_PAL_EXT_MDIO | MGMT_PAL_DCLOCK;
901: x = tr->mgmt_pal;
902: DELAY(20);
903: ret = (tr->mgmt_pal & MGMT_PAL_INT_MDIO) >> 3;
904: } else if (sc->sc_tcvr_type == BE_TCVR_EXTERNAL) {
905: tr->mgmt_pal = MGMT_PAL_INT_MDIO;
906: x = tr->mgmt_pal;
907: tr->mgmt_pal = MGMT_PAL_INT_MDIO | MGMT_PAL_DCLOCK;
908: x = tr->mgmt_pal;
909: DELAY(20);
910: ret = (tr->mgmt_pal & MGMT_PAL_EXT_MDIO) >> 2;
911: } else {
912: printf("%s: invalid tcvr type\n", sc->sc_dev.dv_xname);
913: }
914: return (ret & 1);
915: }
916:
917: int
918: be_tcvr_read_bit2(sc)
919: struct besoftc *sc;
920: {
921: volatile u_int32_t x;
922: struct be_tregs *tr = sc->sc_tr;
923: int ret = 0;
924:
925: if (sc->sc_tcvr_type == BE_TCVR_INTERNAL) {
926: tr->mgmt_pal = MGMT_PAL_EXT_MDIO;
927: x = tr->mgmt_pal;
928: DELAY(20);
929: ret = (tr->mgmt_pal & MGMT_PAL_INT_MDIO) >> 3;
930: tr->mgmt_pal = MGMT_PAL_EXT_MDIO | MGMT_PAL_DCLOCK;
931: x = tr->mgmt_pal;
932: } else if (sc->sc_tcvr_type == BE_TCVR_EXTERNAL) {
933: tr->mgmt_pal = MGMT_PAL_INT_MDIO;
934: x = tr->mgmt_pal;
935: DELAY(20);
936: ret = (tr->mgmt_pal & MGMT_PAL_EXT_MDIO) >> 2;
937: tr->mgmt_pal = MGMT_PAL_INT_MDIO | MGMT_PAL_DCLOCK;
938: x = tr->mgmt_pal;
939: } else {
940: printf("%s: invalid tcvr type\n", sc->sc_dev.dv_xname);
941: }
942: return ret;
943: }
944:
945: void
946: be_tcvr_write(sc, reg, val)
947: struct besoftc *sc;
948: u_int8_t reg;
949: u_int16_t val;
950: {
951: int phy, i;
952:
953: if (sc->sc_tcvr_type == BE_TCVR_INTERNAL)
954: phy = BE_PHY_INTERNAL;
955: else if (sc->sc_tcvr_type == BE_TCVR_EXTERNAL)
956: phy = BE_PHY_EXTERNAL;
957: else {
958: printf("%s: invalid tcvr type\n", sc->sc_dev.dv_xname);
959: return;
960: }
961:
962: be_tcvr_idle(sc);
963:
964: be_tcvr_write_bit(sc, 0);
965: be_tcvr_write_bit(sc, 1);
966: be_tcvr_write_bit(sc, 0);
967: be_tcvr_write_bit(sc, 1);
968:
969: for (i = 4; i >= 0; i--)
970: be_tcvr_write_bit(sc, (phy >> i) & 1);
971:
972: for (i = 4; i >= 0; i--)
973: be_tcvr_write_bit(sc, (reg >> i) & 1);
974:
975: be_tcvr_write_bit(sc, 1);
976: be_tcvr_write_bit(sc, 0);
977:
978: for (i = 15; i >= 0; i--)
979: be_tcvr_write_bit(sc, (val >> i) & 1);
980: }
981:
982: void
983: be_tcvr_write_bit(sc, bit)
984: struct besoftc *sc;
985: int bit;
986: {
987: volatile u_int32_t x;
988:
989: if (sc->sc_tcvr_type == BE_TCVR_INTERNAL) {
990: bit = ((bit & 1) << 3) | MGMT_PAL_OENAB | MGMT_PAL_EXT_MDIO;
991: sc->sc_tr->mgmt_pal = bit;
992: x = sc->sc_tr->mgmt_pal;
993: sc->sc_tr->mgmt_pal = bit | MGMT_PAL_DCLOCK;
994: x = sc->sc_tr->mgmt_pal;
995: } else {
996: bit = ((bit & 1) << 2) | MGMT_PAL_OENAB | MGMT_PAL_INT_MDIO;
997: sc->sc_tr->mgmt_pal = bit;
998: x = sc->sc_tr->mgmt_pal;
999: sc->sc_tr->mgmt_pal = bit | MGMT_PAL_DCLOCK;
1000: x = sc->sc_tr->mgmt_pal;
1001: }
1002: }
1003:
1004: /*
1005: * Pass a packet to the higher levels.
1006: */
1007: void
1008: be_read(sc, idx, len)
1009: struct besoftc *sc;
1010: int idx, len;
1011: {
1012: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
1013: struct mbuf *m;
1014:
1015: if (len <= sizeof(struct ether_header) ||
1016: len > ETHERMTU + sizeof(struct ether_header)) {
1017:
1018: printf("%s: invalid packet size %d; dropping\n",
1019: ifp->if_xname, len);
1020:
1021: ifp->if_ierrors++;
1022: return;
1023: }
1024:
1025: /*
1026: * Pull packet off interface.
1027: */
1028: m = qec_get(ifp, sc->sc_bufs->rx_buf[idx & BE_RX_RING_MASK], len);
1029: if (m == NULL) {
1030: ifp->if_ierrors++;
1031: return;
1032: }
1033: ifp->if_ipackets++;
1034:
1035:
1036: #if NBPFILTER > 0
1037: /*
1038: * Check if there's a BPF listener on this interface.
1039: * If so, hand off the raw packet to BPF.
1040: */
1041: if (ifp->if_bpf)
1042: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
1043: #endif
1044: /* Pass the packet up. */
1045: ether_input_mbuf(ifp, m);
1046: }
1047:
1048: /*
1049: * Get current media settings.
1050: */
1051: void
1052: be_ifmedia_sts(ifp, ifmr)
1053: struct ifnet *ifp;
1054: struct ifmediareq *ifmr;
1055: {
1056: struct besoftc *sc = ifp->if_softc;
1057: int bmcr, bmsr;
1058:
1059: bmcr = be_tcvr_read(sc, PHY_BMCR);
1060:
1061: switch (bmcr & (PHY_BMCR_SPEED | PHY_BMCR_DUPLEX)) {
1062: case (PHY_BMCR_SPEED | PHY_BMCR_DUPLEX):
1063: ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_FDX;
1064: break;
1065: case PHY_BMCR_SPEED:
1066: ifmr->ifm_active = IFM_ETHER | IFM_100_TX | IFM_HDX;
1067: break;
1068: case PHY_BMCR_DUPLEX:
1069: ifmr->ifm_active = IFM_ETHER | IFM_10_T | IFM_FDX;
1070: break;
1071: case 0:
1072: ifmr->ifm_active = IFM_ETHER | IFM_10_T | IFM_HDX;
1073: break;
1074: }
1075:
1076: bmsr = be_tcvr_read(sc, PHY_BMSR);
1077: if (bmsr & PHY_BMSR_LINKSTATUS)
1078: ifmr->ifm_status |= IFM_AVALID | IFM_ACTIVE;
1079: else {
1080: ifmr->ifm_status |= IFM_AVALID;
1081: ifmr->ifm_status &= ~IFM_ACTIVE;
1082: }
1083: }
1084:
1085: /*
1086: * Set media options.
1087: */
1088: int
1089: be_ifmedia_upd(ifp)
1090: struct ifnet *ifp;
1091: {
1092: struct besoftc *sc = ifp->if_softc;
1093: struct ifmedia *ifm = &sc->sc_ifmedia;
1094: int bmcr, tries;
1095:
1096: if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
1097: return (EINVAL);
1098:
1099: be_tcvr_write(sc, PHY_BMCR,
1100: PHY_BMCR_LOOPBACK | PHY_BMCR_PDOWN | PHY_BMCR_ISOLATE);
1101: be_tcvr_write(sc, PHY_BMCR, PHY_BMCR_RESET);
1102:
1103: for (tries = 16; tries >= 0; tries--) {
1104: bmcr = be_tcvr_read(sc, PHY_BMCR);
1105: if ((bmcr & PHY_BMCR_RESET) == 0)
1106: break;
1107: DELAY(20);
1108: }
1109: if (tries == 0) {
1110: printf("%s: bmcr reset failed\n", sc->sc_dev.dv_xname);
1111: return (EIO);
1112: }
1113:
1114: bmcr = be_tcvr_read(sc, PHY_BMCR);
1115:
1116: if (IFM_SUBTYPE(ifm->ifm_media) == IFM_100_T4) {
1117: bmcr |= PHY_BMCR_SPEED;
1118: bmcr &= ~PHY_BMCR_DUPLEX;
1119: }
1120:
1121: if (IFM_SUBTYPE(ifm->ifm_media) == IFM_100_TX) {
1122: bmcr |= PHY_BMCR_SPEED;
1123: }
1124:
1125: if (IFM_SUBTYPE(ifm->ifm_media) == IFM_10_T) {
1126: bmcr &= ~PHY_BMCR_SPEED;
1127: }
1128:
1129: if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) {
1130: bmcr |= PHY_BMCR_DUPLEX;
1131: sc->sc_br->tx_cfg |= BE_BR_TXCFG_FULLDPLX;
1132: }
1133: else {
1134: bmcr &= ~PHY_BMCR_DUPLEX;
1135: sc->sc_br->tx_cfg &= ~BE_BR_TXCFG_FULLDPLX;
1136: }
1137:
1138: be_tcvr_write(sc, PHY_BMCR, bmcr & (~PHY_BMCR_ISOLATE));
1139:
1140: for (tries = 32; tries >= 0; tries--) {
1141: bmcr = be_tcvr_read(sc, PHY_BMCR);
1142: if ((bmcr & PHY_BMCR_ISOLATE) == 0)
1143: break;
1144: DELAY(20);
1145: }
1146: if (tries == 0) {
1147: printf("%s: bmcr unisolate failed\n", sc->sc_dev.dv_xname);
1148: return (EIO);
1149: }
1150:
1151: return (0);
1152: }
1153:
1154: void
1155: be_mcreset(sc)
1156: struct besoftc *sc;
1157: {
1158: struct arpcom *ac = &sc->sc_arpcom;
1159: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
1160: struct be_bregs *br = sc->sc_br;
1161: u_int32_t crc;
1162: u_int16_t hash[4];
1163: u_int8_t octet;
1164: int i, j;
1165: struct ether_multi *enm;
1166: struct ether_multistep step;
1167:
1168: if (ifp->if_flags & IFF_PROMISC) {
1169: br->rx_cfg |= BE_BR_RXCFG_PMISC;
1170: return;
1171: }
1172: else
1173: br->rx_cfg &= ~BE_BR_RXCFG_PMISC;
1174:
1175: if (ifp->if_flags & IFF_ALLMULTI) {
1176: br->htable3 = 0xffff;
1177: br->htable2 = 0xffff;
1178: br->htable1 = 0xffff;
1179: br->htable0 = 0xffff;
1180: return;
1181: }
1182:
1183: hash[3] = hash[2] = hash[1] = hash[0] = 0;
1184:
1185: ETHER_FIRST_MULTI(step, ac, enm);
1186: while (enm != NULL) {
1187: if (bcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
1188: /*
1189: * We must listen to a range of multicast
1190: * addresses. For now, just accept all
1191: * multicasts, rather than trying to set only
1192: * those filter bits needed to match the range.
1193: * (At this time, the only use of address
1194: * ranges is for IP multicast routing, for
1195: * which the range is big enough to require
1196: * all bits set.)
1197: */
1198: br->htable3 = 0xffff;
1199: br->htable2 = 0xffff;
1200: br->htable1 = 0xffff;
1201: br->htable0 = 0xffff;
1202: ifp->if_flags |= IFF_ALLMULTI;
1203: return;
1204: }
1205:
1206: crc = 0xffffffff;
1207:
1208: for (i = 0; i < ETHER_ADDR_LEN; i++) {
1209: octet = enm->enm_addrlo[i];
1210:
1211: for (j = 0; j < 8; j++) {
1212: if ((crc & 1) ^ (octet & 1)) {
1213: crc >>= 1;
1214: crc ^= MC_POLY_LE;
1215: }
1216: else
1217: crc >>= 1;
1218: octet >>= 1;
1219: }
1220: }
1221:
1222: crc >>= 26;
1223: hash[crc >> 4] |= 1 << (crc & 0xf);
1224: ETHER_NEXT_MULTI(step, enm);
1225: }
1226:
1227: br->htable3 = hash[3];
1228: br->htable2 = hash[2];
1229: br->htable1 = hash[1];
1230: br->htable0 = hash[0];
1231: ifp->if_flags &= ~IFF_ALLMULTI;
1232: }