![[BACK]](/icons/back.gif){kind=icon}
Return to if_sn.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mac68k / dev|
Return to if_sn.c CVS log | Up to [local] / sys / arch / mac68k / dev |
1.1 nbrk 1: /* $OpenBSD: if_sn.c,v 1.46 2007/01/12 16:31:21 martin Exp $ */
2: /* $NetBSD: if_sn.c,v 1.13 1997/04/25 03:40:10 briggs Exp $ */
3:
4: /*
5: * National Semiconductor DP8393X SONIC Driver
6: * Copyright (c) 1991 Algorithmics Ltd (http://www.algor.co.uk)
7: * You may use, copy, and modify this program so long as you retain the
8: * copyright line.
9: *
10: * This driver has been substantially modified since Algorithmics donated
11: * it.
12: *
13: * Denton Gentry <denny1@home.com>
14: * and also
15: * Yanagisawa Takeshi <yanagisw@aa.ap.titech.ac.jp>
16: * did the work to get this running on the Macintosh.
17: */
18:
19: #include <sys/param.h>
20: #include <sys/systm.h>
21: #include <sys/mbuf.h>
22: #include <sys/buf.h>
23: #include <sys/protosw.h>
24: #include <sys/socket.h>
25: #include <sys/syslog.h>
26: #include <sys/ioctl.h>
27: #include <sys/errno.h>
28: #include <sys/device.h>
29:
30: #include <net/if.h>
31: #include <net/if_dl.h>
32: #include <net/netisr.h>
33:
34: #ifdef INET
35: #include <netinet/in.h>
36: #include <netinet/in_systm.h>
37: #include <netinet/in_var.h>
38: #include <netinet/ip.h>
39: #include <netinet/if_ether.h>
40: #endif
41:
42: #include <uvm/uvm_extern.h>
43:
44: #include "bpfilter.h"
45: #if NBPFILTER > 0
46: #include <net/bpf.h>
47: #include <net/bpfdesc.h>
48: #endif
49:
50: #include <machine/bus.h>
51: #include <machine/cpu.h>
52: /* #include <machine/viareg.h> */
53: #include <mac68k/dev/if_snreg.h>
54: #include <mac68k/dev/if_snvar.h>
55:
56: static void snwatchdog(struct ifnet *);
57: static int sninit(struct sn_softc *);
58: static int snstop(struct sn_softc *);
59: static int snioctl(struct ifnet *, u_long, caddr_t);
60: static void snstart(struct ifnet *);
61: static void snreset(struct sn_softc *);
62:
63: static void caminitialise(struct sn_softc *);
64: static void camentry(struct sn_softc *, int, u_char *);
65: static void camprogram(struct sn_softc *);
66: static void initialise_tda(struct sn_softc *);
67: static void initialise_rda(struct sn_softc *);
68: static void initialise_rra(struct sn_softc *);
69: #ifdef SNDEBUG
70: static void camdump(struct sn_softc *);
71: #endif
72:
73: static void sonictxint(struct sn_softc *);
74: static void sonicrxint(struct sn_softc *);
75:
76: static __inline__ int sonicput(struct sn_softc *, struct mbuf *,
77: int);
78: static __inline__ int sonic_read(struct sn_softc *, caddr_t, int);
79: static __inline__ struct mbuf *sonic_get(struct sn_softc *, caddr_t, int);
80:
81: struct cfdriver sn_cd = {
82: NULL, "sn", DV_IFNET
83: };
84:
85: /*
86: * SONIC buffers need to be aligned 16 or 32 bit aligned.
87: * These macros calculate and verify alignment.
88: */
89: #define ROUNDUP(p, N) (((int) p + N - 1) & ~(N - 1))
90:
91: #define SOALIGN(m, array) (m ? (ROUNDUP(array, 4)) : (ROUNDUP(array, 2)))
92:
93: #define LOWER(x) ((unsigned)(x) & 0xffff)
94: #define UPPER(x) ((unsigned)(x) >> 16)
95:
96: /*
97: * Interface exists: make available by filling in network interface
98: * record. System will initialize the interface when it is ready
99: * to accept packets.
100: */
101: int
102: snsetup(struct sn_softc *sc, u_int8_t *lladdr)
103: {
104: struct ifnet *ifp = &sc->sc_if;
105: struct pglist pglist;
106: vm_page_t pg;
107: paddr_t phys;
108: vaddr_t p, pp;
109: int i, offset, error;
110:
111: /*
112: * XXX if_sn.c is intended to be MI. Should it allocate memory
113: * for its descriptor areas, or expect the MD attach code
114: * to do that?
115: */
116: TAILQ_INIT(&pglist);
117: error = uvm_pglistalloc(SN_NPAGES * PAGE_SIZE, 0, -PAGE_SIZE,
118: PAGE_SIZE, 0, &pglist, 1, 0);
119: if (error != 0) {
120: printf(": could not allocate descriptor memory\n");
121: return (error);
122: }
123:
124: /*
125: * Map the pages uncached.
126: */
127: sc->space = uvm_km_valloc(kernel_map, SN_NPAGES * PAGE_SIZE);
128: if (sc->space == NULL) {
129: printf(": could not map descriptor memory\n");
130: uvm_pglistfree(&pglist);
131: return (ENOMEM);
132: }
133:
134: phys = VM_PAGE_TO_PHYS(TAILQ_FIRST(&pglist));
135: p = pp = sc->space;
136: TAILQ_FOREACH(pg, &pglist, pageq) {
137: pmap_enter_cache(pmap_kernel(), p, VM_PAGE_TO_PHYS(pg),
138: UVM_PROT_RW, UVM_PROT_RW | PMAP_WIRED, PG_CI);
139: p += PAGE_SIZE;
140: }
141: pmap_update(pmap_kernel());
142: p = pp;
143:
144: /*
145: * Put the pup in reset mode (sninit() will fix it later),
146: * stop the timer, disable all interrupts and clear any interrupts.
147: */
148: NIC_PUT(sc, SNR_CR, CR_STP);
149: wbflush();
150: NIC_PUT(sc, SNR_CR, CR_RST);
151: wbflush();
152: NIC_PUT(sc, SNR_IMR, 0);
153: wbflush();
154: NIC_PUT(sc, SNR_ISR, ISR_ALL);
155: wbflush();
156:
157: for (i = 0; i < NRRA; i++) {
158: sc->p_rra[i] = (void *)p;
159: sc->v_rra[i] = (p - sc->space) + phys;
160: p += RXRSRC_SIZE(sc);
161: }
162: sc->v_rea = (p - sc->space) + phys;
163:
164: p = SOALIGN(sc, p);
165:
166: sc->p_cda = (void *)(p);
167: sc->v_cda = (p - sc->space) + phys;
168: p += CDA_SIZE(sc);
169:
170: p = SOALIGN(sc, p);
171:
172: for (i = 0; i < NTDA; i++) {
173: struct mtd *mtdp = &sc->mtda[i];
174: mtdp->mtd_txp = (void *)p;
175: mtdp->mtd_vtxp = (p - sc->space) + phys;
176: p += TXP_SIZE(sc);
177: }
178:
179: p = SOALIGN(sc, p);
180:
181: #ifdef DIAGNOSTIC
182: if ((p - pp) > PAGE_SIZE) {
183: printf (": sizeof RRA (%ld) + CDA (%ld) +"
184: "TDA (%ld) > PAGE_SIZE (%d). Punt!\n",
185: (ulong)sc->p_cda - (ulong)sc->p_rra[0],
186: (ulong)sc->mtda[0].mtd_txp - (ulong)sc->p_cda,
187: (ulong)p - (ulong)sc->mtda[0].mtd_txp,
188: PAGE_SIZE);
189: return (EINVAL);
190: }
191: #endif
192:
193: p = pp + PAGE_SIZE;
194: pp = p;
195:
196: sc->sc_nrda = PAGE_SIZE / RXPKT_SIZE(sc);
197: sc->p_rda = (caddr_t)p;
198: sc->v_rda = (p - sc->space) + phys;
199:
200: p = pp + PAGE_SIZE;
201:
202: for (i = 0; i < NRBA; i++) {
203: sc->rbuf[i] = (caddr_t)p;
204: sc->rbuf_phys[i] = (p - sc->space) + phys;
205: p += PAGE_SIZE;
206: }
207:
208: pp = p;
209: offset = 0;
210: for (i = 0; i < NTDA; i++) {
211: struct mtd *mtdp = &sc->mtda[i];
212:
213: mtdp->mtd_buf = (caddr_t)p;
214: mtdp->mtd_vbuf = (p - sc->space) + phys;
215: offset += TXBSIZE;
216: if (offset < PAGE_SIZE - TXBSIZE) {
217: p += TXBSIZE;
218: } else {
219: p = pp + PAGE_SIZE;
220: pp = p;
221: offset = 0;
222: }
223: }
224:
225: #ifdef SNDEBUG
226: camdump(sc);
227: #endif
228: printf("address %s\n", ether_sprintf(lladdr));
229:
230: #ifdef SNDEBUG
231: printf("%s: buffers: rra=%p cda=%p rda=%p tda=%p\n",
232: sc->sc_dev.dv_xname, sc->p_rra[0], sc->p_cda,
233: sc->p_rda, sc->mtda[0].mtd_txp);
234: #endif
235:
236: bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
237: bcopy(lladdr, sc->sc_enaddr, ETHER_ADDR_LEN);
238:
239: ifp->if_softc = sc;
240: ifp->if_ioctl = snioctl;
241: ifp->if_start = snstart;
242: ifp->if_flags =
243: IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS | IFF_MULTICAST;
244: ifp->if_watchdog = snwatchdog;
245: if_attach(ifp);
246: ether_ifattach(ifp);
247:
248: return (0);
249: }
250:
251: static int
252: snioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
253: {
254: struct ifaddr *ifa;
255: struct ifreq *ifr;
256: struct sn_softc *sc = ifp->if_softc;
257: int s = splnet(), err = 0;
258:
259: switch (cmd) {
260:
261: case SIOCSIFADDR:
262: ifa = (struct ifaddr *)data;
263: ifp->if_flags |= IFF_UP;
264: switch (ifa->ifa_addr->sa_family) {
265: #ifdef INET
266: case AF_INET:
267: (void)sninit(sc);
268: arp_ifinit(&sc->sc_arpcom, ifa);
269: break;
270: #endif
271: default:
272: (void)sninit(sc);
273: break;
274: }
275: break;
276:
277: case SIOCSIFFLAGS:
278: if ((ifp->if_flags & IFF_UP) == 0 &&
279: (ifp->if_flags & IFF_RUNNING) != 0) {
280: /*
281: * If interface is marked down and it is running,
282: * then stop it.
283: */
284: snstop(sc);
285: ifp->if_flags &= ~IFF_RUNNING;
286: } else if ((ifp->if_flags & IFF_UP) != 0 &&
287: (ifp->if_flags & IFF_RUNNING) == 0) {
288: /*
289: * If interface is marked up and it is stopped,
290: * then start it.
291: */
292: (void)sninit(sc);
293: } else {
294: /*
295: * reset the interface to pick up any other changes
296: * in flags
297: */
298: snreset(sc);
299: snstart(ifp);
300: }
301: break;
302:
303: case SIOCADDMULTI:
304: case SIOCDELMULTI:
305: ifr = (struct ifreq *) data;
306: if (cmd == SIOCADDMULTI)
307: err = ether_addmulti(ifr, &sc->sc_arpcom);
308: else
309: err = ether_delmulti(ifr, &sc->sc_arpcom);
310:
311: if (err == ENETRESET) {
312: /*
313: * Multicast list has changed; set the hardware
314: * filter accordingly. But remember UP flag!
315: */
316: if (ifp->if_flags & IFF_RUNNING)
317: snreset(sc);
318: err = 0;
319: }
320: break;
321: default:
322: err = EINVAL;
323: }
324: splx(s);
325: return (err);
326: }
327:
328: /*
329: * Encapsulate a packet of type family for the local net.
330: */
331: static void
332: snstart(struct ifnet *ifp)
333: {
334: struct sn_softc *sc = ifp->if_softc;
335: struct mbuf *m;
336: int mtd_next;
337:
338: if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
339: return;
340:
341: outloop:
342: /* Check for room in the xmit buffer. */
343: if ((mtd_next = (sc->mtd_free + 1)) == NTDA)
344: mtd_next = 0;
345:
346: if (mtd_next == sc->mtd_hw) {
347: ifp->if_flags |= IFF_OACTIVE;
348: return;
349: }
350:
351: IF_DEQUEUE(&ifp->if_snd, m);
352: if (m == NULL)
353: return;
354:
355: /* We need the header for m_pkthdr.len. */
356: if ((m->m_flags & M_PKTHDR) == 0)
357: panic("%s: snstart: no header mbuf", sc->sc_dev.dv_xname);
358:
359: #if NBPFILTER > 0
360: /*
361: * If bpf is listening on this interface, let it
362: * see the packet before we commit it to the wire.
363: */
364: if (ifp->if_bpf)
365: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_OUT);
366: #endif
367:
368: /*
369: * If there is nothing in the o/p queue, and there is room in
370: * the Tx ring, then send the packet directly. Otherwise append
371: * it to the o/p queue.
372: */
373: if ((sonicput(sc, m, mtd_next)) > 0) {
374: } else {
375: IF_PREPEND(&ifp->if_snd, m);
376: return;
377: }
378:
379: sc->mtd_prev = sc->mtd_free;
380: sc->mtd_free = mtd_next;
381:
382: ifp->if_opackets++; /* # of pkts */
383:
384: /* Jump back for possibly more punishment. */
385: goto outloop;
386: }
387:
388: /*
389: * reset and restart the SONIC. Called in case of fatal
390: * hardware/software errors.
391: */
392: static void
393: snreset(struct sn_softc *sc)
394: {
395: snstop(sc);
396: sninit(sc);
397: }
398:
399: static int
400: sninit(struct sn_softc *sc)
401: {
402: u_long s_rcr;
403: int s;
404:
405: if (sc->sc_if.if_flags & IFF_RUNNING)
406: /* already running */
407: return (0);
408:
409: s = splnet();
410:
411: NIC_PUT(sc, SNR_CR, CR_RST); /* DCR only accessible in reset mode! */
412:
413: /* config it */
414: NIC_PUT(sc, SNR_DCR, (sc->snr_dcr |
415: (sc->bitmode ? DCR_DW32 : DCR_DW16)));
416: NIC_PUT(sc, SNR_DCR2, sc->snr_dcr2);
417:
418: s_rcr = RCR_BRD | RCR_LBNONE;
419: if (sc->sc_if.if_flags & IFF_PROMISC)
420: s_rcr |= RCR_PRO;
421: if (sc->sc_if.if_flags & IFF_ALLMULTI)
422: s_rcr |= RCR_AMC;
423: NIC_PUT(sc, SNR_RCR, s_rcr);
424:
425: NIC_PUT(sc, SNR_IMR, (IMR_PRXEN | IMR_PTXEN | IMR_TXEREN | IMR_LCDEN));
426:
427: /* clear pending interrupts */
428: NIC_PUT(sc, SNR_ISR, ISR_ALL);
429:
430: /* clear tally counters */
431: NIC_PUT(sc, SNR_CRCT, -1);
432: NIC_PUT(sc, SNR_FAET, -1);
433: NIC_PUT(sc, SNR_MPT, -1);
434:
435: initialise_tda(sc);
436: initialise_rda(sc);
437: initialise_rra(sc);
438:
439: /* enable the chip */
440: NIC_PUT(sc, SNR_CR, 0);
441: wbflush();
442:
443: /* program the CAM */
444: camprogram(sc);
445:
446: /* get it to read resource descriptors */
447: NIC_PUT(sc, SNR_CR, CR_RRRA);
448: wbflush();
449: while ((NIC_GET(sc, SNR_CR)) & CR_RRRA)
450: continue;
451:
452: /* enable rx */
453: NIC_PUT(sc, SNR_CR, CR_RXEN);
454: wbflush();
455:
456: /* flag interface as "running" */
457: sc->sc_if.if_flags |= IFF_RUNNING;
458: sc->sc_if.if_flags &= ~IFF_OACTIVE;
459:
460: splx(s);
461: return (0);
462: }
463:
464: /*
465: * close down an interface and free its buffers
466: * Called on final close of device, or if sninit() fails
467: * part way through.
468: */
469: static int
470: snstop(struct sn_softc *sc)
471: {
472: struct mtd *mtd;
473: int s = splnet();
474:
475: /* stick chip in reset */
476: NIC_PUT(sc, SNR_CR, CR_RST);
477: wbflush();
478:
479: /* free all receive buffers (currently static so nothing to do) */
480:
481: /* free all pending transmit mbufs */
482: while (sc->mtd_hw != sc->mtd_free) {
483: mtd = &sc->mtda[sc->mtd_hw];
484: if (mtd->mtd_mbuf)
485: m_freem(mtd->mtd_mbuf);
486: if (++sc->mtd_hw == NTDA) sc->mtd_hw = 0;
487: }
488:
489: sc->sc_if.if_timer = 0;
490: sc->sc_if.if_flags &= ~IFF_RUNNING;
491:
492: splx(s);
493: return (0);
494: }
495:
496: /*
497: * Called if any Tx packets remain unsent after 5 seconds,
498: * In all cases we just reset the chip, and any retransmission
499: * will be handled by higher level protocol timeouts.
500: */
501: static void
502: snwatchdog(struct ifnet *ifp)
503: {
504: struct sn_softc *sc = ifp->if_softc;
505: struct mtd *mtd;
506:
507: if (sc->mtd_hw != sc->mtd_free) {
508: /* something still pending for transmit */
509: mtd = &sc->mtda[sc->mtd_hw];
510: if (SRO(sc->bitmode, mtd->mtd_txp, TXP_STATUS) == 0)
511: log(LOG_ERR, "%s: Tx - timeout\n",
512: sc->sc_dev.dv_xname);
513: else
514: log(LOG_ERR, "%s: Tx - lost interrupt\n",
515: sc->sc_dev.dv_xname);
516: snreset(sc);
517: }
518: }
519:
520: /*
521: * stuff packet into sonic (at splnet)
522: */
523: static __inline__ int
524: sonicput(struct sn_softc *sc, struct mbuf *m0, int mtd_next)
525: {
526: struct mtd *mtdp;
527: struct mbuf *m;
528: u_char *buff;
529: void *txp;
530: u_int len = 0;
531: u_int totlen = 0;
532:
533: /* grab the replacement mtd */
534: mtdp = &sc->mtda[sc->mtd_free];
535:
536: buff = mtdp->mtd_buf;
537:
538: /* this packet goes to mtdnext fill in the TDA */
539: mtdp->mtd_mbuf = m0;
540: txp = mtdp->mtd_txp;
541:
542: /* Write to the config word. Every (NTDA/2)+1 packets we set an intr */
543: if (sc->mtd_pint == 0) {
544: sc->mtd_pint = NTDA/2;
545: SWO(sc->bitmode, txp, TXP_CONFIG, TCR_PINT);
546: } else {
547: sc->mtd_pint--;
548: SWO(sc->bitmode, txp, TXP_CONFIG, 0);
549: }
550:
551: for (m = m0; m; m = m->m_next) {
552: u_char *data = mtod(m, u_char *);
553: len = m->m_len;
554: totlen += len;
555: bcopy(data, buff, len);
556: buff += len;
557: }
558: if (totlen >= TXBSIZE) {
559: panic("%s: sonicput: packet overflow", sc->sc_dev.dv_xname);
560: }
561:
562: SWO(sc->bitmode, txp, TXP_FRAGOFF + (0 * TXP_FRAGSIZE) + TXP_FPTRLO,
563: LOWER(mtdp->mtd_vbuf));
564: SWO(sc->bitmode, txp, TXP_FRAGOFF + (0 * TXP_FRAGSIZE) + TXP_FPTRHI,
565: UPPER(mtdp->mtd_vbuf));
566:
567: if (totlen < ETHERMIN + ETHER_HDR_LEN) {
568: int pad = ETHERMIN + ETHER_HDR_LEN - totlen;
569: bzero(mtdp->mtd_buf + totlen, pad);
570: totlen = ETHERMIN + ETHER_HDR_LEN;
571: }
572:
573: SWO(sc->bitmode, txp, TXP_FRAGOFF + (0 * TXP_FRAGSIZE) + TXP_FSIZE,
574: totlen);
575: SWO(sc->bitmode, txp, TXP_FRAGCNT, 1);
576: SWO(sc->bitmode, txp, TXP_PKTSIZE, totlen);
577:
578: /* link onto the next mtd that will be used */
579: SWO(sc->bitmode, txp, TXP_FRAGOFF + (1 * TXP_FRAGSIZE) + TXP_FPTRLO,
580: LOWER(sc->mtda[mtd_next].mtd_vtxp) | EOL);
581:
582: /*
583: * The previous txp.tlink currently contains a pointer to
584: * our txp | EOL. Want to clear the EOL, so write our
585: * pointer to the previous txp.
586: */
587: SWO(sc->bitmode, sc->mtda[sc->mtd_prev].mtd_txp, sc->mtd_tlinko,
588: LOWER(mtdp->mtd_vtxp));
589:
590: /* make sure chip is running */
591: wbflush();
592: NIC_PUT(sc, SNR_CR, CR_TXP);
593: wbflush();
594: sc->sc_if.if_timer = 5; /* 5 seconds to watch for failing to transmit */
595:
596: return (totlen);
597: }
598:
599: /*
600: * These are called from sonicioctl() when /etc/ifconfig is run to set
601: * the address or switch the i/f on.
602: */
603: /*
604: * CAM support
605: */
606: static void
607: caminitialise(struct sn_softc *sc)
608: {
609: void *p_cda = sc->p_cda;
610: int i;
611: int bitmode = sc->bitmode;
612: int camoffset;
613:
614: for (i = 0; i < MAXCAM; i++) {
615: camoffset = i * CDA_CAMDESC;
616: SWO(bitmode, p_cda, (camoffset + CDA_CAMEP), i);
617: SWO(bitmode, p_cda, (camoffset + CDA_CAMAP2), 0);
618: SWO(bitmode, p_cda, (camoffset + CDA_CAMAP1), 0);
619: SWO(bitmode, p_cda, (camoffset + CDA_CAMAP0), 0);
620: }
621: SWO(bitmode, p_cda, CDA_ENABLE, 0);
622: }
623:
624: static void
625: camentry(struct sn_softc *sc, int entry, u_char *ea)
626: {
627: void *p_cda = sc->p_cda;
628: int bitmode = sc->bitmode;
629: int camoffset = entry * CDA_CAMDESC;
630:
631: SWO(bitmode, p_cda, camoffset + CDA_CAMEP, entry);
632: SWO(bitmode, p_cda, camoffset + CDA_CAMAP2, (ea[5] << 8) | ea[4]);
633: SWO(bitmode, p_cda, camoffset + CDA_CAMAP1, (ea[3] << 8) | ea[2]);
634: SWO(bitmode, p_cda, camoffset + CDA_CAMAP0, (ea[1] << 8) | ea[0]);
635: SWO(bitmode, p_cda, CDA_ENABLE,
636: (SRO(bitmode, p_cda, CDA_ENABLE) | (1 << entry)));
637: }
638:
639: static void
640: camprogram(struct sn_softc *sc)
641: {
642: struct ether_multistep step;
643: struct ether_multi *enm;
644: struct ifnet *ifp;
645: int timeout;
646: int mcount = 0;
647:
648: caminitialise(sc);
649:
650: ifp = &sc->sc_if;
651:
652: /* Always load our own address first. */
653: camentry (sc, mcount, sc->sc_enaddr);
654: mcount++;
655:
656: /* Assume we won't need allmulti bit. */
657: ifp->if_flags &= ~IFF_ALLMULTI;
658:
659: /* Loop through multicast addresses */
660: ETHER_FIRST_MULTI(step, &sc->sc_arpcom, enm);
661: while (enm != NULL) {
662: if (mcount == MAXCAM) {
663: ifp->if_flags |= IFF_ALLMULTI;
664: break;
665: }
666:
667: if (bcmp(enm->enm_addrlo, enm->enm_addrhi,
668: sizeof(enm->enm_addrlo)) != 0) {
669: /*
670: * SONIC's CAM is programmed with specific
671: * addresses. It has no way to specify a range.
672: * (Well, thats not exactly true. If the
673: * range is small one could program each addr
674: * within the range as a separate CAM entry)
675: */
676: ifp->if_flags |= IFF_ALLMULTI;
677: break;
678: }
679:
680: /* program the CAM with the specified entry */
681: camentry(sc, mcount, enm->enm_addrlo);
682: mcount++;
683:
684: ETHER_NEXT_MULTI(step, enm);
685: }
686:
687: NIC_PUT(sc, SNR_CDP, LOWER(sc->v_cda));
688: NIC_PUT(sc, SNR_CDC, MAXCAM);
689: NIC_PUT(sc, SNR_CR, CR_LCAM);
690: wbflush();
691:
692: timeout = 10000;
693: while ((NIC_GET(sc, SNR_CR) & CR_LCAM) && timeout--)
694: continue;
695: if (timeout == 0) {
696: /* XXX */
697: panic("%s: CAM initialisation failed", sc->sc_dev.dv_xname);
698: }
699: timeout = 10000;
700: while (((NIC_GET(sc, SNR_ISR) & ISR_LCD) == 0) && timeout--)
701: continue;
702:
703: if (NIC_GET(sc, SNR_ISR) & ISR_LCD)
704: NIC_PUT(sc, SNR_ISR, ISR_LCD);
705: else
706: printf("%s: CAM initialisation without interrupt\n",
707: sc->sc_dev.dv_xname);
708: }
709:
710: #ifdef SNDEBUG
711: static void
712: camdump(struct sn_softc *sc)
713: {
714: int i;
715:
716: printf("CAM entries:\n");
717: NIC_PUT(sc, SNR_CR, CR_RST);
718: wbflush();
719:
720: for (i = 0; i < 16; i++) {
721: ushort ap2, ap1, ap0;
722: NIC_PUT(sc, SNR_CEP, i);
723: wbflush();
724: ap2 = NIC_GET(sc, SNR_CAP2);
725: ap1 = NIC_GET(sc, SNR_CAP1);
726: ap0 = NIC_GET(sc, SNR_CAP0);
727: printf("%d: ap2=0x%x ap1=0x%x ap0=0x%x\n", i, ap2, ap1, ap0);
728: }
729: printf("CAM enable 0x%x\n", NIC_GET(sc, SNR_CEP));
730:
731: NIC_PUT(sc, SNR_CR, 0);
732: wbflush();
733: }
734: #endif
735:
736: static void
737: initialise_tda(struct sn_softc *sc)
738: {
739: struct mtd *mtd;
740: int i;
741:
742: for (i = 0; i < NTDA; i++) {
743: mtd = &sc->mtda[i];
744: mtd->mtd_mbuf = 0;
745: }
746:
747: sc->mtd_hw = 0;
748: sc->mtd_prev = NTDA - 1;
749: sc->mtd_free = 0;
750: sc->mtd_tlinko = TXP_FRAGOFF + 1*TXP_FRAGSIZE + TXP_FPTRLO;
751: sc->mtd_pint = NTDA/2;
752:
753: NIC_PUT(sc, SNR_UTDA, UPPER(sc->mtda[0].mtd_vtxp));
754: NIC_PUT(sc, SNR_CTDA, LOWER(sc->mtda[0].mtd_vtxp));
755: }
756:
757: static void
758: initialise_rda(struct sn_softc *sc)
759: {
760: int bitmode = sc->bitmode;
761: int i;
762: caddr_t p_rda = 0;
763: u_int32_t v_rda = 0;
764:
765: /* link the RDA's together into a circular list */
766: for (i = 0; i < (sc->sc_nrda - 1); i++) {
767: p_rda = sc->p_rda + (i * RXPKT_SIZE(sc));
768: v_rda = sc->v_rda + ((i+1) * RXPKT_SIZE(sc));
769: SWO(bitmode, p_rda, RXPKT_RLINK, LOWER(v_rda));
770: SWO(bitmode, p_rda, RXPKT_INUSE, 1);
771: }
772: p_rda = sc->p_rda + ((sc->sc_nrda - 1) * RXPKT_SIZE(sc));
773: SWO(bitmode, p_rda, RXPKT_RLINK, LOWER(sc->v_rda) | EOL);
774: SWO(bitmode, p_rda, RXPKT_INUSE, 1);
775:
776: /* mark end of receive descriptor list */
777: sc->sc_rdamark = sc->sc_nrda - 1;
778:
779: sc->sc_rxmark = 0;
780:
781: NIC_PUT(sc, SNR_URDA, UPPER(sc->v_rda));
782: NIC_PUT(sc, SNR_CRDA, LOWER(sc->v_rda));
783: wbflush();
784: }
785:
786: static void
787: initialise_rra(struct sn_softc *sc)
788: {
789: int i;
790: u_int v;
791: int bitmode = sc->bitmode;
792:
793: if (bitmode)
794: NIC_PUT(sc, SNR_EOBC, RBASIZE(sc) / 2 - 2);
795: else
796: NIC_PUT(sc, SNR_EOBC, RBASIZE(sc) / 2 - 1);
797:
798: NIC_PUT(sc, SNR_URRA, UPPER(sc->v_rra[0]));
799: NIC_PUT(sc, SNR_RSA, LOWER(sc->v_rra[0]));
800: /* rea must point just past the end of the rra space */
801: NIC_PUT(sc, SNR_REA, LOWER(sc->v_rea));
802: NIC_PUT(sc, SNR_RRP, LOWER(sc->v_rra[0]));
803: NIC_PUT(sc, SNR_RSC, 0);
804:
805: /* fill up SOME of the rra with buffers */
806: for (i = 0; i < NRBA; i++) {
807: v = sc->rbuf_phys[i];
808: SWO(bitmode, sc->p_rra[i], RXRSRC_PTRHI, UPPER(v));
809: SWO(bitmode, sc->p_rra[i], RXRSRC_PTRLO, LOWER(v));
810: SWO(bitmode, sc->p_rra[i], RXRSRC_WCHI, UPPER(PAGE_SIZE/2));
811: SWO(bitmode, sc->p_rra[i], RXRSRC_WCLO, LOWER(PAGE_SIZE/2));
812: }
813: sc->sc_rramark = NRBA;
814: NIC_PUT(sc, SNR_RWP, LOWER(sc->v_rra[sc->sc_rramark]));
815: wbflush();
816: }
817:
818: int
819: snintr(void *arg)
820: {
821: struct sn_softc *sc = (struct sn_softc *)arg;
822: int isr;
823: int rv = 0;
824:
825: while ((isr = (NIC_GET(sc, SNR_ISR) & ISR_ALL)) != 0) {
826: rv = 1;
827: /* scrub the interrupts that we are going to service */
828: NIC_PUT(sc, SNR_ISR, isr);
829: wbflush();
830:
831: if (isr & (ISR_BR | ISR_LCD | ISR_TC))
832: printf("%s: unexpected interrupt status 0x%x\n",
833: sc->sc_dev.dv_xname, isr);
834:
835: if (isr & (ISR_TXDN | ISR_TXER | ISR_PINT))
836: sonictxint(sc);
837:
838: if (isr & ISR_PKTRX)
839: sonicrxint(sc);
840:
841: if (isr & (ISR_HBL | ISR_RDE | ISR_RBE | ISR_RBAE | ISR_RFO)) {
842: if (isr & ISR_HBL)
843: /*
844: * The repeater is not providing a heartbeat.
845: * In itself this isn't harmful, lots of the
846: * cheap repeater hubs don't supply a heartbeat.
847: * So ignore the lack of heartbeat. Its only
848: * if we can't detect a carrier that we have a
849: * problem.
850: */
851: ;
852: if (isr & ISR_RDE)
853: printf("%s: receive descriptors exhausted\n",
854: sc->sc_dev.dv_xname);
855: if (isr & ISR_RBE)
856: printf("%s: receive buffers exhausted\n",
857: sc->sc_dev.dv_xname);
858: if (isr & ISR_RBAE)
859: printf("%s: receive buffer area exhausted\n",
860: sc->sc_dev.dv_xname);
861: if (isr & ISR_RFO)
862: printf("%s: receive FIFO overrun\n",
863: sc->sc_dev.dv_xname);
864: }
865: if (isr & (ISR_CRC | ISR_FAE | ISR_MP)) {
866: #ifdef notdef
867: if (isr & ISR_CRC)
868: sc->sc_crctally++;
869: if (isr & ISR_FAE)
870: sc->sc_faetally++;
871: if (isr & ISR_MP)
872: sc->sc_mptally++;
873: #endif
874: }
875: snstart(&sc->sc_if);
876: }
877:
878: return (rv);
879: }
880:
881: /*
882: * Transmit interrupt routine
883: */
884: static void
885: sonictxint(struct sn_softc *sc)
886: {
887: struct mtd *mtd;
888: void *txp;
889: unsigned short txp_status;
890: int mtd_hw;
891: struct ifnet *ifp = &sc->sc_if;
892:
893: mtd_hw = sc->mtd_hw;
894:
895: if (mtd_hw == sc->mtd_free)
896: return;
897:
898: while (mtd_hw != sc->mtd_free) {
899: mtd = &sc->mtda[mtd_hw];
900:
901: txp = mtd->mtd_txp;
902:
903: if (SRO(sc->bitmode, txp, TXP_STATUS) == 0) {
904: break; /* it hasn't really gone yet */
905: }
906:
907: #ifdef SNDEBUG
908: {
909: struct ether_header *eh;
910:
911: eh = (struct ether_header *) mtd->mtd_buf;
912: printf("%s: xmit status=0x%x len=%d type=0x%x from %s",
913: sc->sc_dev.dv_xname,
914: SRO(sc->bitmode, txp, TXP_STATUS),
915: SRO(sc->bitmode, txp, TXP_PKTSIZE),
916: htons(eh->ether_type),
917: ether_sprintf(eh->ether_shost));
918: printf(" (to %s)\n", ether_sprintf(eh->ether_dhost));
919: }
920: #endif /* SNDEBUG */
921:
922: ifp->if_flags &= ~IFF_OACTIVE;
923:
924: if (mtd->mtd_mbuf != 0) {
925: m_freem(mtd->mtd_mbuf);
926: mtd->mtd_mbuf = 0;
927: }
928: if (++mtd_hw == NTDA) mtd_hw = 0;
929:
930: txp_status = SRO(sc->bitmode, txp, TXP_STATUS);
931:
932: ifp->if_collisions += (txp_status & TCR_EXC) ? 16 :
933: ((txp_status & TCR_NC) >> 12);
934:
935: if ((txp_status & TCR_PTX) == 0) {
936: ifp->if_oerrors++;
937:
938: /* XXX - DG This looks bogus */
939: if (mtd_hw != sc->mtd_free) {
940: mtd = &sc->mtda[mtd_hw];
941: NIC_PUT(sc, SNR_CTDA, LOWER(mtd->mtd_vtxp));
942: NIC_PUT(sc, SNR_CR, CR_TXP);
943: wbflush();
944: break;
945: }
946: }
947: }
948:
949: sc->mtd_hw = mtd_hw;
950: return;
951: }
952:
953: /*
954: * Receive interrupt routine
955: */
956: static void
957: sonicrxint(struct sn_softc *sc)
958: {
959: caddr_t rda;
960: int orra;
961: int len;
962: int rramark;
963: int rdamark;
964: int bitmode = sc->bitmode;
965: u_int16_t rxpkt_ptr;
966:
967: rda = sc->p_rda + (sc->sc_rxmark * RXPKT_SIZE(sc));
968:
969: while (SRO(bitmode, rda, RXPKT_INUSE) == 0) {
970: u_int status = SRO(bitmode, rda, RXPKT_STATUS);
971:
972: orra = RBASEQ(SRO(bitmode, rda, RXPKT_SEQNO)) & RRAMASK;
973: rxpkt_ptr = SRO(bitmode, rda, RXPKT_PTRLO);
974: len = SRO(bitmode, rda, RXPKT_BYTEC) - FCSSIZE;
975: if (status & RCR_PRX) {
976: caddr_t pkt = sc->rbuf[orra & RBAMASK] +
977: m68k_page_offset(rxpkt_ptr);
978: if (sonic_read(sc, pkt, len))
979: sc->sc_if.if_ipackets++;
980: else
981: sc->sc_if.if_ierrors++;
982: } else
983: sc->sc_if.if_ierrors++;
984:
985: /*
986: * give receive buffer area back to chip.
987: *
988: * If this was the last packet in the RRA, give the RRA to
989: * the chip again.
990: * If sonic read didnt copy it out then we would have to
991: * wait !!
992: * (dont bother add it back in again straight away)
993: *
994: * Really, we're doing p_rra[rramark] = p_rra[orra] but
995: * we have to use the macros because SONIC might be in
996: * 16 or 32 bit mode.
997: */
998: if (status & RCR_LPKT) {
999: void *tmp1, *tmp2;
1000:
1001: rramark = sc->sc_rramark;
1002: tmp1 = sc->p_rra[rramark];
1003: tmp2 = sc->p_rra[orra];
1004: SWO(bitmode, tmp1, RXRSRC_PTRLO,
1005: SRO(bitmode, tmp2, RXRSRC_PTRLO));
1006: SWO(bitmode, tmp1, RXRSRC_PTRHI,
1007: SRO(bitmode, tmp2, RXRSRC_PTRHI));
1008: SWO(bitmode, tmp1, RXRSRC_WCLO,
1009: SRO(bitmode, tmp2, RXRSRC_WCLO));
1010: SWO(bitmode, tmp1, RXRSRC_WCHI,
1011: SRO(bitmode, tmp2, RXRSRC_WCHI));
1012:
1013: /* zap old rra for fun */
1014: SWO(bitmode, tmp2, RXRSRC_WCHI, 0);
1015: SWO(bitmode, tmp2, RXRSRC_WCLO, 0);
1016:
1017: sc->sc_rramark = (++rramark) & RRAMASK;
1018: NIC_PUT(sc, SNR_RWP, LOWER(sc->v_rra[rramark]));
1019: wbflush();
1020: }
1021:
1022: /*
1023: * give receive descriptor back to chip simple
1024: * list is circular
1025: */
1026: rdamark = sc->sc_rdamark;
1027: SWO(bitmode, rda, RXPKT_INUSE, 1);
1028: SWO(bitmode, rda, RXPKT_RLINK,
1029: SRO(bitmode, rda, RXPKT_RLINK) | EOL);
1030: SWO(bitmode, (sc->p_rda + (rdamark * RXPKT_SIZE(sc))), RXPKT_RLINK,
1031: SRO(bitmode, (sc->p_rda + (rdamark * RXPKT_SIZE(sc))),
1032: RXPKT_RLINK) & ~EOL);
1033: sc->sc_rdamark = sc->sc_rxmark;
1034:
1035: if (++sc->sc_rxmark >= sc->sc_nrda)
1036: sc->sc_rxmark = 0;
1037: rda = sc->p_rda + (sc->sc_rxmark * RXPKT_SIZE(sc));
1038: }
1039: }
1040:
1041: /*
1042: * sonic_read -- pull packet off interface and forward to
1043: * appropriate protocol handler
1044: */
1045: static __inline__ int
1046: sonic_read(struct sn_softc *sc, caddr_t pkt, int len)
1047: {
1048: struct ifnet *ifp = &sc->sc_if;
1049: #ifdef SNDEBUG
1050: struct ether_header *et;
1051: #endif
1052: struct mbuf *m;
1053:
1054: #ifdef SNDEBUG
1055: /*
1056: * Get pointer to ethernet header (in input buffer).
1057: */
1058: et = (struct ether_header *)pkt;
1059:
1060: printf("%s: rcvd %p len=%d type=0x%x from %s",
1061: sc->sc_dev.dv_xname, et, len, htons(et->ether_type),
1062: ether_sprintf(et->ether_shost));
1063: printf(" (to %s)\n", ether_sprintf(et->ether_dhost));
1064: #endif /* SNDEBUG */
1065:
1066: if (len < (ETHER_MIN_LEN - ETHER_CRC_LEN) ||
1067: len > (ETHER_MAX_LEN - ETHER_CRC_LEN)) {
1068: printf("%s: invalid packet length %d bytes\n",
1069: sc->sc_dev.dv_xname, len);
1070: return (0);
1071: }
1072:
1073: m = sonic_get(sc, pkt, len);
1074: if (m == NULL)
1075: return (0);
1076: #if NBPFILTER > 0
1077: /* Pass this up to any BPF listeners. */
1078: if (ifp->if_bpf)
1079: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
1080: #endif
1081: ether_input_mbuf(ifp, m);
1082: return (1);
1083: }
1084:
1085: /*
1086: * munge the received packet into an mbuf chain
1087: */
1088: static __inline__ struct mbuf *
1089: sonic_get(struct sn_softc *sc, caddr_t pkt, int datalen)
1090: {
1091: struct mbuf *m, *top, **mp;
1092: int len;
1093:
1094: MGETHDR(m, M_DONTWAIT, MT_DATA);
1095: if (m == NULL)
1096: return (NULL);
1097:
1098: m->m_pkthdr.rcvif = &sc->sc_if;
1099: m->m_pkthdr.len = datalen;
1100: len = MHLEN;
1101: top = 0;
1102: mp = ⊤
1103:
1104: while (datalen > 0) {
1105: if (top) {
1106: MGET(m, M_DONTWAIT, MT_DATA);
1107: if (m == NULL) {
1108: m_freem(top);
1109: return (NULL);
1110: }
1111: len = MLEN;
1112: }
1113: if (datalen >= MINCLSIZE) {
1114: MCLGET(m, M_DONTWAIT);
1115: if ((m->m_flags & M_EXT) == 0) {
1116: if (top)
1117: m_freem(top);
1118: return (NULL);
1119: }
1120: len = MCLBYTES;
1121: }
1122: m->m_len = len = min(datalen, len);
1123:
1124: bcopy(pkt, mtod(m, caddr_t), (unsigned) len);
1125: pkt += len;
1126: datalen -= len;
1127: *mp = m;
1128: mp = &m->m_next;
1129: }
1130:
1131: return (top);
1132: }
1133:
1134: static u_char bbr4[] = {0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15};
1135: #define bbr(v) ((bbr4[(v)&0xf] << 4) | bbr4[((v)>>4) & 0xf])
1136:
1137: void
1138: sn_get_enaddr(bus_space_tag_t t, bus_space_handle_t h, bus_addr_t o,
1139: u_char *dst)
1140: {
1141: int i, do_bbr;
1142: u_char b;
1143:
1144: /*
1145: * For reasons known only to Apple, MAC addresses in the ethernet
1146: * PROM are stored in Token Ring (IEEE 802.5) format, that is
1147: * with all of the bits in each byte reversed (canonical bit format).
1148: * When the address is read out it must be reversed to ethernet format
1149: * before use.
1150: *
1151: * Apple has been assigned OUI's 08:00:07 and 00:a0:40. All onboard
1152: * ethernet addresses on 68K machines should be in one of these
1153: * two ranges.
1154: *
1155: * Here is where it gets complicated.
1156: *
1157: * The PMac 7200, 7500, 8500, and 9500 accidentally had the PROM
1158: * written in standard ethernet format. The MacOS accounted for this
1159: * in these systems, and did not reverse the bytes. Some other
1160: * networking utilities were not so forgiving, and got confused.
1161: * "Some" of Apple's Nubus ethernet cards also had their bits
1162: * burned in ethernet format.
1163: *
1164: * Apple petitioned the IEEE and was granted the 00:05:02 (bit reversal
1165: * of 00:a0:40) as well. As of OpenTransport 1.1.1, Apple removed
1166: * their workaround and now reverses the bits regardless of
1167: * what kind of machine it is. So PMac systems and the affected
1168: * Nubus cards now use 00:05:02, instead of the 00:a0:40 for which they
1169: * were intended.
1170: *
1171: * See Apple Techinfo article TECHINFO-0020552, "OpenTransport 1.1.1
1172: * and MacOS System 7.5.3 FAQ (10/96)" for more details.
1173: */
1174: do_bbr = 0;
1175: b = bus_space_read_1(t, h, o);
1176: if (b == 0x10)
1177: do_bbr = 1;
1178: dst[0] = (do_bbr) ? bbr(b) : b;
1179:
1180: for (i = 1 ; i < ETHER_ADDR_LEN ; i++) {
1181: b = bus_space_read_1(t, h, o+i);
1182: dst[i] = (do_bbr) ? bbr(b) : b;
1183: }
1184: }