Annotation of sys/arch/vax/if/if_uba.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_uba.c,v 1.11 2003/11/10 21:05:04 miod Exp $ */
2: /* $NetBSD: if_uba.c,v 1.15 1999/01/01 21:43:18 ragge Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1988 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_uba.c 7.16 (Berkeley) 12/16/90
33: */
34:
35:
36: #include <sys/param.h>
37: #include <sys/systm.h>
38: #include <sys/malloc.h>
39: #include <sys/mbuf.h>
40: #include <sys/buf.h>
41: #include <sys/socket.h>
42: #include <sys/syslog.h>
43:
44: #include <net/if.h>
45:
46: #include <machine/pte.h>
47: #include <machine/mtpr.h>
48: #include <machine/vmparam.h>
49: #include <machine/cpu.h>
50:
51: #include <vax/if/if_uba.h>
52: #include <vax/uba/ubareg.h>
53: #include <vax/uba/ubavar.h>
54:
55: static int if_ubaalloc(struct ifubinfo *, struct ifrw *, int);
56: static void rcv_xmtbuf(struct ifxmt *);
57: static void restor_xmtbuf(struct ifxmt *);
58:
59: /*
60: * Routines supporting UNIBUS network interfaces.
61: *
62: * TODO:
63: * Support interfaces using only one BDP statically.
64: */
65:
66: /*
67: * Init UNIBUS for interface whose headers of size hlen are to
68: * end on a page boundary. We allocate a UNIBUS map register for the page
69: * with the header, and nmr more UNIBUS map registers for i/o on the adapter,
70: * doing this once for each read and once for each write buffer. We also
71: * allocate page frames in the mbuffer pool for these pages.
72: */
73: int
74: if_ubaminit(ifu, uh, hlen, nmr, ifr, nr, ifw, nw)
75: register struct ifubinfo *ifu;
76: struct uba_softc *uh;
77: int hlen, nmr, nr, nw;
78: register struct ifrw *ifr;
79: register struct ifxmt *ifw;
80: {
81: register caddr_t p;
82: caddr_t cp;
83: int i, nclbytes, off;
84:
85: if (hlen)
86: off = MCLBYTES - hlen;
87: else
88: off = 0;
89: nclbytes = roundup(nmr * VAX_NBPG, MCLBYTES);
90: if (hlen)
91: nclbytes += MCLBYTES;
92: if (ifr[0].ifrw_addr)
93: cp = ifr[0].ifrw_addr - off;
94: else {
95: cp = (caddr_t)malloc((u_long)((nr + nw) * nclbytes), M_DEVBUF,
96: M_NOWAIT);
97: if (cp == 0)
98: return (0);
99: p = cp;
100: for (i = 0; i < nr; i++) {
101: ifr[i].ifrw_addr = p + off;
102: p += nclbytes;
103: }
104: for (i = 0; i < nw; i++) {
105: ifw[i].ifw_base = p;
106: ifw[i].ifw_addr = p + off;
107: p += nclbytes;
108: }
109: ifu->iff_hlen = hlen;
110: ifu->iff_softc = uh;
111: ifu->iff_uba = uh->uh_uba;
112: ifu->iff_ubamr = uh->uh_mr;
113: }
114: for (i = 0; i < nr; i++)
115: if (if_ubaalloc(ifu, &ifr[i], nmr) == 0) {
116: nr = i;
117: nw = 0;
118: goto bad;
119: }
120: for (i = 0; i < nw; i++)
121: if (if_ubaalloc(ifu, &ifw[i].ifrw, nmr) == 0) {
122: nw = i;
123: goto bad;
124: }
125: while (--nw >= 0) {
126: for (i = 0; i < nmr; i++)
127: ifw[nw].ifw_wmap[i] = ifw[nw].ifw_mr[i];
128: ifw[nw].ifw_xswapd = 0;
129: ifw[nw].ifw_flags = IFRW_W;
130: ifw[nw].ifw_nmr = nmr;
131: }
132: return (1);
133: bad:
134: while (--nw >= 0)
135: ubarelse(ifu->iff_softc, &ifw[nw].ifw_info);
136: while (--nr >= 0)
137: ubarelse(ifu->iff_softc, &ifr[nr].ifrw_info);
138: free(cp, M_DEVBUF);
139: ifr[0].ifrw_addr = 0;
140: return (0);
141: }
142:
143: /*
144: * Setup an ifrw structure by allocating UNIBUS map registers,
145: * possibly a buffered data path, and initializing the fields of
146: * the ifrw structure to minimize run-time overhead.
147: */
148: static int
149: if_ubaalloc(ifu, ifrw, nmr)
150: struct ifubinfo *ifu;
151: register struct ifrw *ifrw;
152: int nmr;
153: {
154: register int info;
155:
156: info =
157: uballoc(ifu->iff_softc, ifrw->ifrw_addr, nmr*VAX_NBPG + ifu->iff_hlen,
158: ifu->iff_flags);
159: if (info == 0)
160: return (0);
161: ifrw->ifrw_info = info;
162: ifrw->ifrw_bdp = UBAI_BDP(info);
163: ifrw->ifrw_proto = UBAMR_MRV | (UBAI_BDP(info) << UBAMR_DPSHIFT);
164: ifrw->ifrw_mr = &ifu->iff_ubamr[UBAI_MR(info) + (ifu->iff_hlen? 1 : 0)];
165: return (1);
166: }
167:
168: /*
169: * Pull read data off a interface.
170: * Totlen is length of data, with local net header stripped.
171: * When full cluster sized units are present
172: * on the interface on cluster boundaries we can get them more
173: * easily by remapping, and take advantage of this here.
174: * Save a pointer to the interface structure and the total length,
175: * so that protocols can determine where incoming packets arrived.
176: * Note: we may be called to receive from a transmit buffer by some
177: * devices. In that case, we must force normal mapping of the buffer,
178: * so that the correct data will appear (only unibus maps are
179: * changed when remapping the transmit buffers).
180: */
181: struct mbuf *
182: if_ubaget(ifu, ifr, totlen, ifp)
183: struct ifubinfo *ifu;
184: register struct ifrw *ifr;
185: register int totlen;
186: struct ifnet *ifp;
187: {
188: struct mbuf *top, **mp;
189: register struct mbuf *m;
190: register caddr_t cp = ifr->ifrw_addr + ifu->iff_hlen, pp;
191: register int len;
192: top = 0;
193: mp = ⊤
194: MGETHDR(m, M_DONTWAIT, MT_DATA);
195: if (m == 0){
196: return ((struct mbuf *)NULL);
197: }
198: m->m_pkthdr.rcvif = ifp;
199: m->m_pkthdr.len = totlen;
200: m->m_len = MHLEN;
201:
202: if (ifr->ifrw_flags & IFRW_W){
203: rcv_xmtbuf((struct ifxmt *)ifr);
204: }
205: while (totlen > 0) {
206: if (top) {
207: MGET(m, M_DONTWAIT, MT_DATA);
208: if (m == 0) {
209: m_freem(top);
210: top = 0;
211: goto out;
212: }
213: m->m_len = MLEN;
214: }
215: len = totlen;
216: if (len >= MINCLSIZE) {
217: pt_entry_t *cpte, *ppte;
218: int x, *ip, i;
219:
220: MCLGET(m, M_DONTWAIT);
221: if ((m->m_flags & M_EXT) == 0){
222: goto nopage;
223: }
224: len = min(len, MCLBYTES);
225: m->m_len = len;
226: if (((vaddr_t)cp & PAGE_MASK) != 0) {
227: goto copy;
228: }
229: /*
230: * Switch pages mapped to UNIBUS with new page pp,
231: * as quick form of copy. Remap UNIBUS and invalidate.
232: */
233: pp = mtod(m, char *);
234: cpte = kvtopte(cp);
235: ppte = kvtopte(pp);
236: x = vax_btop(cp - ifr->ifrw_addr);
237: ip = (int *)&ifr->ifrw_mr[x];
238: for (i = 0; i < MCLBYTES/VAX_NBPG; i++) {
239: pt_entry_t t;
240: t = *ppte; *ppte++ = *cpte; *cpte = t;
241: *ip++ = (*cpte++ & PG_FRAME) | ifr->ifrw_proto;
242: mtpr(cp,PR_TBIS);
243: cp += VAX_NBPG;
244: mtpr((caddr_t)pp,PR_TBIS);
245: pp += VAX_NBPG;
246: }
247: goto nocopy;
248: }
249: nopage:
250: if (len < m->m_len) {
251: /*
252: * Place initial small packet/header at end of mbuf.
253: */
254: if (top == 0 && len + max_linkhdr <= m->m_len)
255: m->m_data += max_linkhdr;
256: m->m_len = len;
257: } else
258: len = m->m_len;
259: copy:
260: bcopy(cp, mtod(m, caddr_t), (unsigned)len);
261: cp += len;
262: nocopy:
263: *mp = m;
264: mp = &m->m_next;
265: totlen -= len;
266: }
267: out:
268: if (ifr->ifrw_flags & IFRW_W){
269: restor_xmtbuf((struct ifxmt *)ifr);
270: }
271: return (top);
272: }
273:
274: /*
275: * Change the mapping on a transmit buffer so that if_ubaget may
276: * receive from that buffer. Copy data from any pages mapped to Unibus
277: * into the pages mapped to normal kernel virtual memory, so that
278: * they can be accessed and swapped as usual. We take advantage
279: * of the fact that clusters are placed on the xtofree list
280: * in inverse order, finding the last one.
281: */
282: static void
283: rcv_xmtbuf(ifw)
284: register struct ifxmt *ifw;
285: {
286: register struct mbuf *m;
287: struct mbuf **mprev;
288: register int i;
289: char *cp;
290:
291: while ((i = ffs((long)ifw->ifw_xswapd)) != 0) {
292: cp = ifw->ifw_base + i * MCLBYTES;
293: i--;
294: ifw->ifw_xswapd &= ~(1<<i);
295: mprev = &ifw->ifw_xtofree;
296: for (m = ifw->ifw_xtofree; m && m->m_next; m = m->m_next)
297: mprev = &m->m_next;
298: if (m == NULL)
299: break;
300: bcopy(mtod(m, caddr_t), cp, MCLBYTES);
301: (void) m_free(m);
302: *mprev = NULL;
303: }
304: ifw->ifw_xswapd = 0;
305: for (i = 0; i < ifw->ifw_nmr; i++)
306: ifw->ifw_mr[i] = ifw->ifw_wmap[i];
307: }
308:
309: /*
310: * Put a transmit buffer back together after doing an if_ubaget on it,
311: * which may have swapped pages.
312: */
313: static void
314: restor_xmtbuf(ifw)
315: register struct ifxmt *ifw;
316: {
317: register int i;
318:
319: for (i = 0; i < ifw->ifw_nmr; i++)
320: ifw->ifw_wmap[i] = ifw->ifw_mr[i];
321: }
322:
323: /*
324: * Map a chain of mbufs onto a network interface
325: * in preparation for an i/o operation.
326: * The argument chain of mbufs includes the local network
327: * header which is copied to be in the mapped, aligned
328: * i/o space.
329: */
330: int
331: if_ubaput(ifu, ifw, m)
332: struct ifubinfo *ifu;
333: register struct ifxmt *ifw;
334: register struct mbuf *m;
335: {
336: register struct mbuf *mp;
337: register caddr_t cp, dp;
338: register int i;
339: int xswapd = 0;
340: int x, cc, t;
341:
342: cp = ifw->ifw_addr;
343: while (m) {
344: dp = mtod(m, char *);
345: if (((vaddr_t)cp & PAGE_MASK) == 0 &&
346: ((vaddr_t)dp & PAGE_MASK) == 0 &&
347: (m->m_len == MCLBYTES || m->m_next == (struct mbuf *)0)) {
348: pt_entry_t *pte;
349: int *ip;
350:
351: pte = kvtopte(dp);
352: x = vax_btop(cp - ifw->ifw_addr);
353: ip = (int *)&ifw->ifw_mr[x];
354: for (i = 0; i < MCLBYTES/VAX_NBPG; i++)
355: *ip++ = ifw->ifw_proto | (*pte++ & PG_FRAME);
356: xswapd |= 1 << (x>>(MCLSHIFT-VAX_PGSHIFT));
357: mp = m->m_next;
358: m->m_next = ifw->ifw_xtofree;
359: ifw->ifw_xtofree = m;
360: cp += m->m_len;
361: } else {
362: bcopy(mtod(m, caddr_t), cp, (unsigned)m->m_len);
363: cp += m->m_len;
364: MFREE(m, mp);
365: }
366: m = mp;
367: }
368:
369: /*
370: * Xswapd is the set of clusters we just mapped out. Ifu->iff_xswapd
371: * is the set of clusters mapped out from before. We compute
372: * the number of clusters involved in this operation in x.
373: * Clusters mapped out before and involved in this operation
374: * should be unmapped so original pages will be accessed by the device.
375: */
376: cc = cp - ifw->ifw_addr;
377: x = ((cc - ifu->iff_hlen) + MCLBYTES - 1) >> MCLSHIFT;
378: ifw->ifw_xswapd &= ~xswapd;
379: while ((i = ffs((long)ifw->ifw_xswapd)) != 0) {
380: i--;
381: if (i >= x)
382: break;
383: ifw->ifw_xswapd &= ~(1<<i);
384: i *= MCLBYTES/VAX_NBPG;
385: for (t = 0; t < MCLBYTES/VAX_NBPG; t++) {
386: ifw->ifw_mr[i] = ifw->ifw_wmap[i];
387: i++;
388: }
389: }
390: ifw->ifw_xswapd |= xswapd;
391: return (cc);
392: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_uba.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / if