Annotation of sys/arch/vax/if/if_de.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_de.c,v 1.19 2006/04/16 00:46:32 pascoe Exp $ */
2: /* $NetBSD: if_de.c,v 1.27 1997/04/19 15:02:29 ragge Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the University nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: *
32: * @(#)if_de.c 7.12 (Berkeley) 12/16/90
33: */
34:
35: /*
36: * DEC DEUNA interface
37: *
38: * Lou Salkind
39: * New York University
40: *
41: * TODO:
42: * timeout routine (get statistics)
43: */
44:
45: #include <sys/param.h>
46: #include <sys/systm.h>
47: #include <sys/mbuf.h>
48: #include <sys/buf.h>
49: #include <sys/protosw.h>
50: #include <sys/socket.h>
51: #include <sys/ioctl.h>
52: #include <sys/errno.h>
53: #include <sys/syslog.h>
54: #include <sys/device.h>
55:
56: #include <machine/pte.h>
57: #include <machine/sid.h>
58:
59: #include <net/if.h>
60: #include <net/if_dl.h>
61:
62: #ifdef INET
63: #include <netinet/in.h>
64: #include <netinet/in_systm.h>
65: #include <netinet/in_var.h>
66: #include <netinet/ip.h>
67: #include <netinet/if_ether.h>
68: #endif
69:
70: #include <machine/cpu.h>
71: #include <machine/mtpr.h>
72:
73: #include <vax/if/if_dereg.h>
74: #include <vax/if/if_uba.h>
75: #include <vax/uba/ubareg.h>
76: #include <vax/uba/ubavar.h>
77:
78: #define NXMT 3 /* number of transmit buffers */
79: #define NRCV 7 /* number of receive buffers (must be > 1) */
80:
81: int dedebug = 0;
82:
83: /*
84: * Ethernet software status per interface.
85: *
86: * Each interface is referenced by a network interface structure,
87: * ds_if, which the routing code uses to locate the interface.
88: * This structure contains the output queue for the interface, its address, ...
89: * We also have, for each interface, a UBA interface structure, which
90: * contains information about the UNIBUS resources held by the interface:
91: * map registers, buffered data paths, etc. Information is cached in this
92: * structure for use by the if_uba.c routines in running the interface
93: * efficiently.
94: */
95: struct de_softc {
96: struct device ds_dev; /* Configuration common part */
97: struct arpcom ds_ac; /* Ethernet common part */
98: struct dedevice *ds_vaddr; /* Virtual address of this interface */
99: #define ds_if ds_ac.ac_if /* network-visible interface */
100: int ds_flags;
101: #define DSF_RUNNING 2 /* board is enabled */
102: #define DSF_SETADDR 4 /* physical address is changed */
103: int ds_ubaddr; /* map info for incore structs */
104: struct ifubinfo ds_deuba; /* unibus resource structure */
105: struct ifrw ds_ifr[NRCV]; /* unibus receive maps */
106: struct ifxmt ds_ifw[NXMT]; /* unibus xmt maps */
107: /* the following structures are always mapped in */
108: struct de_pcbb ds_pcbb; /* port control block */
109: struct de_ring ds_xrent[NXMT]; /* transmit ring entries */
110: struct de_ring ds_rrent[NRCV]; /* receive ring entries */
111: struct de_udbbuf ds_udbbuf; /* UNIBUS data buffer */
112: /* end mapped area */
113: #define INCORE_BASE(p) ((char *)&(p)->ds_pcbb)
114: #define RVAL_OFF(s,n) ((char *)&(s)->n - INCORE_BASE(s))
115: #define LVAL_OFF(s,n) ((char *)(s)->n - INCORE_BASE(s))
116: #define PCBB_OFFSET(s) RVAL_OFF(s,ds_pcbb)
117: #define XRENT_OFFSET(s) LVAL_OFF(s,ds_xrent)
118: #define RRENT_OFFSET(s) LVAL_OFF(s,ds_rrent)
119: #define UDBBUF_OFFSET(s) RVAL_OFF(s,ds_udbbuf)
120: #define INCORE_SIZE(s) RVAL_OFF(s, ds_xindex)
121: int ds_xindex; /* UNA index into transmit chain */
122: int ds_rindex; /* UNA index into receive chain */
123: int ds_xfree; /* index for next transmit buffer */
124: int ds_nxmit; /* # of transmits in progress */
125: };
126:
127: int dematch(struct device *, void *, void *);
128: void deattach(struct device *, struct device *, void *);
129: int dewait(struct de_softc *, char *);
130: void deinit(struct de_softc *);
131: int deioctl(struct ifnet *, u_long, caddr_t);
132: void dereset(int);
133: void destart(struct ifnet *);
134: void deread(struct de_softc *, struct ifrw *, int);
135: void derecv(int);
136: void de_setaddr(u_char *, struct de_softc *);
137: void deintr(int);
138:
139:
140: struct cfdriver de_cd = {
141: NULL, "de", DV_IFNET
142: };
143:
144: struct cfattach de_ca = {
145: sizeof(struct de_softc), dematch, deattach
146: };
147: /*
148: * Interface exists: make available by filling in network interface
149: * record. System will initialize the interface when it is ready
150: * to accept packets. We get the ethernet address here.
151: */
152: void
153: deattach(parent, self, aux)
154: struct device *parent, *self;
155: void *aux;
156: {
157: struct uba_attach_args *ua = aux;
158: struct de_softc *ds = (struct de_softc *)self;
159: struct ifnet *ifp = &ds->ds_if;
160: struct dedevice *addr;
161: char *c;
162: int csr1;
163: u_int8_t myaddr[ETHER_ADDR_LEN];
164:
165: addr = (struct dedevice *)ua->ua_addr;
166: ds->ds_vaddr = addr;
167: bcopy(ds->ds_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
168: ifp->if_softc = ds;
169: ifp->if_flags = IFF_BROADCAST | IFF_NOTRAILERS;
170:
171: /*
172: * What kind of a board is this?
173: * The error bits 4-6 in pcsr1 are a device id as long as
174: * the high byte is zero.
175: */
176: csr1 = addr->pcsr1;
177: if (csr1 & 0xff60)
178: c = "broken";
179: else if (csr1 & 0x10)
180: c = "delua";
181: else
182: c = "deuna";
183:
184: printf("\n%s: %s\n", ds->ds_dev.dv_xname, c);
185: /*
186: * Reset the board and temporarily map
187: * the pcbb buffer onto the Unibus.
188: */
189: addr->pcsr0 = 0; /* reset INTE */
190: DELAY(100);
191: addr->pcsr0 = PCSR0_RSET;
192: (void)dewait(ds, "reset");
193:
194: ds->ds_ubaddr = uballoc((void *)ds->ds_dev.dv_parent,
195: (char *)&ds->ds_pcbb, sizeof (struct de_pcbb), 0);
196: addr->pcsr2 = ds->ds_ubaddr & 0xffff;
197: addr->pcsr3 = (ds->ds_ubaddr >> 16) & 0x3;
198: addr->pclow = CMD_GETPCBB;
199: (void)dewait(ds, "pcbb");
200:
201: ds->ds_pcbb.pcbb0 = FC_RDPHYAD;
202: addr->pclow = CMD_GETCMD;
203: (void)dewait(ds, "read addr ");
204:
205: ubarelse((void *)ds->ds_dev.dv_parent, &ds->ds_ubaddr);
206: bcopy((caddr_t)&ds->ds_pcbb.pcbb2, myaddr, sizeof (myaddr));
207: printf("%s: address %s\n", ds->ds_dev.dv_xname,
208: ether_sprintf(myaddr));
209: ifp->if_ioctl = deioctl;
210: ifp->if_start = destart;
211: ds->ds_deuba.iff_flags = UBA_CANTWAIT;
212: #ifdef notdef
213: /* CAN WE USE BDP's ??? */
214: ds->ds_deuba.iff_flags |= UBA_NEEDBDP;
215: #endif
216: if_attach(ifp);
217: ether_ifattach(ifp);
218: }
219:
220: /*
221: * Reset of interface after UNIBUS reset.
222: */
223: void
224: dereset(unit)
225: int unit;
226: {
227: struct de_softc *sc = de_cd.cd_devs[unit];
228: volatile struct dedevice *addr = sc->ds_vaddr;
229:
230: printf(" de%d", unit);
231: sc->ds_if.if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
232: sc->ds_flags &= ~DSF_RUNNING;
233: addr->pcsr0 = PCSR0_RSET;
234: (void)dewait(sc, "reset");
235: deinit(sc);
236: }
237:
238: /*
239: * Initialization of interface; clear recorded pending
240: * operations, and reinitialize UNIBUS usage.
241: */
242: void
243: deinit(ds)
244: struct de_softc *ds;
245: {
246: volatile struct dedevice *addr;
247: struct ifnet *ifp = &ds->ds_if;
248: struct ifrw *ifrw;
249: struct ifxmt *ifxp;
250: struct de_ring *rp;
251: int s,incaddr;
252:
253: /* not yet, if address still unknown */
254: if (TAILQ_EMPTY(&ifp->if_addrlist))
255: return;
256:
257: if (ds->ds_flags & DSF_RUNNING)
258: return;
259: if ((ifp->if_flags & IFF_RUNNING) == 0) {
260: if (if_ubaminit(&ds->ds_deuba, (void *)ds->ds_dev.dv_parent,
261: sizeof (struct ether_header), (int)vax_btoc(ETHERMTU),
262: ds->ds_ifr, NRCV, ds->ds_ifw, NXMT) == 0) {
263: printf("%s: can't initialize\n", ds->ds_dev.dv_xname);
264: ds->ds_if.if_flags &= ~IFF_UP;
265: return;
266: }
267: ds->ds_ubaddr = uballoc((void *)ds->ds_dev.dv_parent,
268: INCORE_BASE(ds), INCORE_SIZE(ds), 0);
269: }
270: addr = ds->ds_vaddr;
271:
272: /* set the pcbb block address */
273: incaddr = ds->ds_ubaddr + PCBB_OFFSET(ds);
274: addr->pcsr2 = incaddr & 0xffff;
275: addr->pcsr3 = (incaddr >> 16) & 0x3;
276: addr->pclow = 0; /* reset INTE */
277: DELAY(500);
278: addr->pclow = CMD_GETPCBB;
279: (void)dewait(ds, "pcbb");
280:
281: /* set the transmit and receive ring header addresses */
282: incaddr = ds->ds_ubaddr + UDBBUF_OFFSET(ds);
283: ds->ds_pcbb.pcbb0 = FC_WTRING;
284: ds->ds_pcbb.pcbb2 = incaddr & 0xffff;
285: ds->ds_pcbb.pcbb4 = (incaddr >> 16) & 0x3;
286:
287: incaddr = ds->ds_ubaddr + XRENT_OFFSET(ds);
288: ds->ds_udbbuf.b_tdrbl = incaddr & 0xffff;
289: ds->ds_udbbuf.b_tdrbh = (incaddr >> 16) & 0x3;
290: ds->ds_udbbuf.b_telen = sizeof (struct de_ring) / sizeof (short);
291: ds->ds_udbbuf.b_trlen = NXMT;
292: incaddr = ds->ds_ubaddr + RRENT_OFFSET(ds);
293: ds->ds_udbbuf.b_rdrbl = incaddr & 0xffff;
294: ds->ds_udbbuf.b_rdrbh = (incaddr >> 16) & 0x3;
295: ds->ds_udbbuf.b_relen = sizeof (struct de_ring) / sizeof (short);
296: ds->ds_udbbuf.b_rrlen = NRCV;
297:
298: addr->pclow = CMD_GETCMD;
299: (void)dewait(ds, "wtring");
300:
301: /* initialize the mode - enable hardware padding */
302: ds->ds_pcbb.pcbb0 = FC_WTMODE;
303: /* let hardware do padding - set MTCH bit on broadcast */
304: ds->ds_pcbb.pcbb2 = MOD_TPAD|MOD_HDX;
305: addr->pclow = CMD_GETCMD;
306: (void)dewait(ds, "wtmode");
307:
308: /* set up the receive and transmit ring entries */
309: ifxp = &ds->ds_ifw[0];
310: for (rp = &ds->ds_xrent[0]; rp < &ds->ds_xrent[NXMT]; rp++) {
311: rp->r_segbl = ifxp->ifw_info & 0xffff;
312: rp->r_segbh = (ifxp->ifw_info >> 16) & 0x3;
313: rp->r_flags = 0;
314: ifxp++;
315: }
316: ifrw = &ds->ds_ifr[0];
317: for (rp = &ds->ds_rrent[0]; rp < &ds->ds_rrent[NRCV]; rp++) {
318: rp->r_slen = sizeof (struct de_buf);
319: rp->r_segbl = ifrw->ifrw_info & 0xffff;
320: rp->r_segbh = (ifrw->ifrw_info >> 16) & 0x3;
321: rp->r_flags = RFLG_OWN; /* hang receive */
322: ifrw++;
323: }
324:
325: /* start up the board (rah rah) */
326: s = splnet();
327: ds->ds_rindex = ds->ds_xindex = ds->ds_xfree = ds->ds_nxmit = 0;
328: ds->ds_if.if_flags |= IFF_RUNNING;
329: addr->pclow = PCSR0_INTE; /* avoid interlock */
330: destart(&ds->ds_if); /* queue output packets */
331: ds->ds_flags |= DSF_RUNNING; /* need before de_setaddr */
332: if (ds->ds_flags & DSF_SETADDR)
333: de_setaddr(ds->ds_ac.ac_enaddr, ds);
334: addr->pclow = CMD_START | PCSR0_INTE;
335: splx(s);
336: }
337:
338: /*
339: * Setup output on interface.
340: * Get another datagram to send off of the interface queue,
341: * and map it to the interface before starting the output.
342: * Must be called from ipl >= our interrupt level.
343: */
344: void
345: destart(ifp)
346: struct ifnet *ifp;
347: {
348: int len;
349: register struct de_softc *ds = ifp->if_softc;
350: volatile struct dedevice *addr = ds->ds_vaddr;
351: register struct de_ring *rp;
352: struct mbuf *m;
353: register int nxmit;
354:
355: /*
356: * the following test is necessary, since
357: * the code is not reentrant and we have
358: * multiple transmission buffers.
359: */
360: if (ds->ds_if.if_flags & IFF_OACTIVE)
361: return;
362: for (nxmit = ds->ds_nxmit; nxmit < NXMT; nxmit++) {
363: IF_DEQUEUE(&ds->ds_if.if_snd, m);
364: if (m == 0)
365: break;
366: rp = &ds->ds_xrent[ds->ds_xfree];
367: if (rp->r_flags & XFLG_OWN)
368: panic("deuna xmit in progress");
369: len = if_ubaput(&ds->ds_deuba, &ds->ds_ifw[ds->ds_xfree], m);
370: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP) {
371: struct uba_softc *uh = (void *)ds->ds_dev.dv_parent;
372:
373: if (uh->uh_ubapurge)
374: (*uh->uh_ubapurge)
375: (uh, ds->ds_ifw[ds->ds_xfree].ifw_bdp);
376: }
377: rp->r_slen = len;
378: rp->r_tdrerr = 0;
379: rp->r_flags = XFLG_STP|XFLG_ENP|XFLG_OWN;
380:
381: ds->ds_xfree++;
382: if (ds->ds_xfree == NXMT)
383: ds->ds_xfree = 0;
384: }
385: if (ds->ds_nxmit != nxmit) {
386: ds->ds_nxmit = nxmit;
387: if (ds->ds_flags & DSF_RUNNING)
388: addr->pclow = PCSR0_INTE|CMD_PDMD;
389: }
390: }
391:
392: /*
393: * Command done interrupt.
394: */
395: void
396: deintr(unit)
397: int unit;
398: {
399: volatile struct dedevice *addr;
400: register struct de_softc *ds;
401: register struct de_ring *rp;
402: register struct ifxmt *ifxp;
403: short csr0;
404:
405: ds = de_cd.cd_devs[unit];
406: addr = ds->ds_vaddr;
407:
408:
409: /* save flags right away - clear out interrupt bits */
410: csr0 = addr->pcsr0;
411: addr->pchigh = csr0 >> 8;
412:
413:
414: ds->ds_if.if_flags |= IFF_OACTIVE; /* prevent entering destart */
415: /*
416: * if receive, put receive buffer on mbuf
417: * and hang the request again
418: */
419: derecv(unit);
420:
421: /*
422: * Poll transmit ring and check status.
423: * Be careful about loopback requests.
424: * Then free buffer space and check for
425: * more transmit requests.
426: */
427: for ( ; ds->ds_nxmit > 0; ds->ds_nxmit--) {
428: rp = &ds->ds_xrent[ds->ds_xindex];
429: if (rp->r_flags & XFLG_OWN)
430: break;
431: ds->ds_if.if_opackets++;
432: ifxp = &ds->ds_ifw[ds->ds_xindex];
433: /* check for unusual conditions */
434: if (rp->r_flags & (XFLG_ERRS|XFLG_MTCH|XFLG_ONE|XFLG_MORE)) {
435: if (rp->r_flags & XFLG_ERRS) {
436: /* output error */
437: ds->ds_if.if_oerrors++;
438: if (dedebug) {
439: printf("de%d: oerror, flags=%b ",
440: unit, rp->r_flags, XFLG_BITS);
441: printf("tdrerr=%b\n",
442: rp->r_tdrerr, XERR_BITS);
443: }
444: } else if (rp->r_flags & XFLG_ONE) {
445: /* one collision */
446: ds->ds_if.if_collisions++;
447: } else if (rp->r_flags & XFLG_MORE) {
448: /* more than one collision */
449: ds->ds_if.if_collisions += 2; /* guess */
450: } else if (rp->r_flags & XFLG_MTCH) {
451: /* received our own packet */
452: ds->ds_if.if_ipackets++;
453: deread(ds, &ifxp->ifrw,
454: rp->r_slen - sizeof (struct ether_header));
455: }
456: }
457: if (ifxp->ifw_xtofree) {
458: m_freem(ifxp->ifw_xtofree);
459: ifxp->ifw_xtofree = 0;
460: }
461: /* check if next transmit buffer also finished */
462: ds->ds_xindex++;
463: if (ds->ds_xindex == NXMT)
464: ds->ds_xindex = 0;
465: }
466: ds->ds_if.if_flags &= ~IFF_OACTIVE;
467: destart(&ds->ds_if);
468:
469: if (csr0 & PCSR0_RCBI) {
470: if (dedebug)
471: log(LOG_WARNING, "de%d: buffer unavailable\n", unit);
472: addr->pclow = PCSR0_INTE|CMD_PDMD;
473: }
474: }
475:
476: /*
477: * Ethernet interface receiver interface.
478: * If input error just drop packet.
479: * Otherwise purge input buffered data path and examine
480: * packet to determine type. If can't determine length
481: * from type, then have to drop packet. Othewise decapsulate
482: * packet based on type and pass to type specific higher-level
483: * input routine.
484: */
485: void
486: derecv(unit)
487: int unit;
488: {
489: register struct de_softc *ds = de_cd.cd_devs[unit];
490: register struct de_ring *rp;
491: int len;
492:
493: rp = &ds->ds_rrent[ds->ds_rindex];
494: while ((rp->r_flags & RFLG_OWN) == 0) {
495: ds->ds_if.if_ipackets++;
496: if (ds->ds_deuba.iff_flags & UBA_NEEDBDP) {
497: struct uba_softc *uh = (void *)ds->ds_dev.dv_parent;
498:
499: if (uh->uh_ubapurge)
500: (*uh->uh_ubapurge)
501: (uh,ds->ds_ifr[ds->ds_rindex].ifrw_bdp);
502: }
503: len = (rp->r_lenerr&RERR_MLEN) - sizeof (struct ether_header)
504: - 4; /* don't forget checksum! */
505: /* check for errors */
506: if ((rp->r_flags & (RFLG_ERRS|RFLG_FRAM|RFLG_OFLO|RFLG_CRC)) ||
507: (rp->r_flags&(RFLG_STP|RFLG_ENP)) != (RFLG_STP|RFLG_ENP) ||
508: (rp->r_lenerr & (RERR_BUFL|RERR_UBTO|RERR_NCHN)) ||
509: len < ETHERMIN || len > ETHERMTU) {
510: ds->ds_if.if_ierrors++;
511: if (dedebug) {
512: printf("de%d: ierror, flags=%b ",
513: unit, rp->r_flags, RFLG_BITS);
514: printf("lenerr=%b (len=%d)\n",
515: rp->r_lenerr, RERR_BITS, len);
516: }
517: } else
518: deread(ds, &ds->ds_ifr[ds->ds_rindex], len);
519:
520: /* hang the receive buffer again */
521: rp->r_lenerr = 0;
522: rp->r_flags = RFLG_OWN;
523:
524: /* check next receive buffer */
525: ds->ds_rindex++;
526: if (ds->ds_rindex == NRCV)
527: ds->ds_rindex = 0;
528: rp = &ds->ds_rrent[ds->ds_rindex];
529: }
530: }
531:
532: /*
533: * Pass a packet to the higher levels.
534: * We deal with the trailer protocol here.
535: */
536: void
537: deread(ds, ifrw, len)
538: register struct de_softc *ds;
539: struct ifrw *ifrw;
540: int len;
541: {
542: struct ether_header *eh;
543: struct mbuf *m;
544:
545: eh = (struct ether_header *)ifrw->ifrw_addr;
546: if (len == 0)
547: return;
548:
549: /*
550: * Pull packet off interface. Off is nonzero if packet
551: * has trailing header; if_ubaget will then force this header
552: * information to be at the front.
553: */
554: m = if_ubaget(&ds->ds_deuba, ifrw, len, &ds->ds_if);
555: if (m) {
556: /*
557: * XXX not exactly sure what if_ubaget does. Manually
558: * add the ethernet header to the start of the mbuf chain.
559: */
560: M_PREPEND(m, sizeof(*eh), M_DONTWAIT);
561: if (m) {
562: *mtod(m, struct ether_header *) = *eh;
563: ether_input_mbuf(&ds->ds_if, m);
564: }
565: }
566: }
567: /*
568: * Process an ioctl request.
569: */
570: int
571: deioctl(ifp, cmd, data)
572: register struct ifnet *ifp;
573: u_long cmd;
574: caddr_t data;
575: {
576: register struct ifaddr *ifa = (struct ifaddr *)data;
577: register struct de_softc *ds = ifp->if_softc;
578: int s = splnet(), error = 0;
579:
580: switch (cmd) {
581:
582: case SIOCSIFADDR:
583: ifp->if_flags |= IFF_UP;
584: deinit(ds);
585:
586: switch (ifa->ifa_addr->sa_family) {
587: #ifdef INET
588: case AF_INET:
589: arp_ifinit(&ds->ds_ac, ifa);
590: break;
591: #endif
592: }
593: break;
594:
595: case SIOCSIFFLAGS:
596: if ((ifp->if_flags & IFF_UP) == 0 &&
597: ds->ds_flags & DSF_RUNNING) {
598: ds->ds_vaddr->pclow = 0;
599: DELAY(5000);
600: ds->ds_vaddr->pclow = PCSR0_RSET;
601: ds->ds_flags &= ~DSF_RUNNING;
602: ds->ds_if.if_flags &= ~IFF_OACTIVE;
603: } else if (ifp->if_flags & IFF_UP &&
604: (ds->ds_flags & DSF_RUNNING) == 0)
605: deinit(ds);
606: break;
607:
608: default:
609: error = EINVAL;
610: }
611: splx(s);
612: return (error);
613: }
614:
615: /*
616: * set ethernet address for unit
617: */
618: void
619: de_setaddr(physaddr, ds)
620: u_char *physaddr;
621: struct de_softc *ds;
622: {
623: volatile struct dedevice *addr= ds->ds_vaddr;
624:
625: if (! (ds->ds_flags & DSF_RUNNING))
626: return;
627:
628: bcopy((caddr_t) physaddr, (caddr_t) &ds->ds_pcbb.pcbb2, 6);
629: ds->ds_pcbb.pcbb0 = FC_WTPHYAD;
630: addr->pclow = PCSR0_INTE|CMD_GETCMD;
631: if (dewait(ds, "address change") == 0) {
632: ds->ds_flags |= DSF_SETADDR;
633: bcopy((caddr_t) physaddr, ds->ds_ac.ac_enaddr, 6);
634: }
635: }
636:
637: /*
638: * Await completion of the named function
639: * and check for errors.
640: */
641: int
642: dewait(ds, fn)
643: register struct de_softc *ds;
644: char *fn;
645: {
646: volatile struct dedevice *addr = ds->ds_vaddr;
647: register int csr0;
648:
649: while ((addr->pcsr0 & PCSR0_INTR) == 0)
650: ;
651: csr0 = addr->pcsr0;
652: addr->pchigh = csr0 >> 8;
653: if (csr0 & PCSR0_PCEI) {
654: printf("de%d: %s failed, csr0=%b ", ds->ds_dev.dv_unit, fn,
655: csr0, PCSR0_BITS);
656: printf("csr1=%b\n", addr->pcsr1, PCSR1_BITS);
657: }
658: return (csr0 & PCSR0_PCEI);
659: }
660:
661: int
662: dematch(parent, cf, aux)
663: struct device *parent;
664: void *cf, *aux;
665: {
666: struct uba_attach_args *ua = aux;
667: volatile struct dedevice *addr = (struct dedevice *)ua->ua_addr;
668: int i;
669:
670: /*
671: * Make sure self-test is finished before we screw with the board.
672: * Self-test on a DELUA can take 15 seconds (argh).
673: */
674: for (i = 0;
675: i < 160 &&
676: (addr->pcsr0 & PCSR0_FATI) == 0 &&
677: (addr->pcsr1 & PCSR1_STMASK) == STAT_RESET;
678: ++i)
679: DELAY(50000);
680: if (((addr->pcsr0 & PCSR0_FATI) != 0) ||
681: (((addr->pcsr1 & PCSR1_STMASK) != STAT_READY) &&
682: ((addr->pcsr1 & PCSR1_STMASK) != STAT_RUN)))
683: return(0);
684:
685: addr->pcsr0 = 0;
686: DELAY(5000);
687: addr->pcsr0 = PCSR0_RSET;
688: while ((addr->pcsr0 & PCSR0_INTR) == 0)
689: ;
690: /* make board interrupt by executing a GETPCBB command */
691: addr->pcsr0 = PCSR0_INTE;
692: addr->pcsr2 = 0;
693: addr->pcsr3 = 0;
694: addr->pcsr0 = PCSR0_INTE|CMD_GETPCBB;
695: DELAY(50000);
696:
697: ua->ua_ivec = deintr;
698: ua->ua_reset = dereset; /* Wish to be called after ubareset */
699:
700: return 1;
701: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_de.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / if