![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vba.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / tahoe / vba|
Return to vba.c CVS log | Up to [Net/2] / Net2 / arch / tahoe / vba |
1.1 root 1: /*
2: * Copyright (c) 1987, 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)vba.c 7.6 (Berkeley) 12/16/90
34: */
35:
36: /*
37: * Tahoe VERSAbus adapator support routines.
38: */
39:
40: #include "sys/param.h"
41: #include "sys/buf.h"
42: #include "sys/cmap.h"
43: #include "sys/conf.h"
44: #include "dk.h"
45: #include "sys/map.h"
46: #include "sys/systm.h"
47: #include "sys/user.h"
48: #include "sys/vmparam.h"
49: #include "sys/vmmac.h"
50: #include "sys/proc.h"
51: #include "sys/syslog.h"
52: #include "sys/malloc.h"
53:
54: #include "../include/mtpr.h"
55: #include "../include/pte.h"
56:
57: #include "../vba/vbavar.h"
58:
59: /*
60: * Allocate private page map and intermediate buffer
61: * for a VERSAbus device, large enough for maximum transfer size.
62: * Intermediate buffer
63: * Make intermediate buffer uncacheable.
64: */
65: vbainit(vb, xsize, flags)
66: register struct vb_buf *vb;
67: int xsize, flags;
68: {
69: register struct pte *pte;
70: register n;
71:
72: vb->vb_flags = flags;
73: if (vbmapalloc((int)btoc(xsize) + 1, &vb->vb_map, &vb->vb_utl) == 0) {
74: printf("vbmap exhausted\n");
75: return (0);
76: }
77: n = roundup(xsize, NBPG);
78: vb->vb_bufsize = n;
79: if (vb->vb_rawbuf == 0)
80: vb->vb_rawbuf = (caddr_t)malloc((u_long)n, M_DEVBUF, M_NOWAIT);
81: if (vb->vb_rawbuf == 0) {
82: printf("no memory for device buffer\n");
83: return (0);
84: }
85: if ((int)vb->vb_rawbuf & PGOFSET)
86: panic("vbinit pgoff");
87: vb->vb_physbuf = (u_long)kvtophys(vb->vb_rawbuf);
88: if (flags & VB_20BIT)
89: vb->vb_maxphys = btoc(VB_MAXADDR20);
90: else if (flags & VB_24BIT)
91: vb->vb_maxphys = btoc(VB_MAXADDR24);
92: else
93: vb->vb_maxphys = btoc(VB_MAXADDR32);
94: if (btoc(vb->vb_physbuf + n) > vb->vb_maxphys)
95: panic("vbinit physbuf");
96:
97: /*
98: * Make raw buffer pages uncacheable.
99: */
100: pte = kvtopte(vb->vb_rawbuf);
101: for (n = btoc(n); n--; pte++)
102: pte->pg_nc = 1;
103: mtpr(TBIA, 0);
104: return (1);
105: }
106:
107: /*
108: * Due to unknown hardware or software errors, some sites have problems
109: * with strange crashes or corruption of text images when DMA is attempted
110: * to kernel addresses spanning a page boundary, or to user addresses
111: * (even if the buffer is physically contiguous). To avoid this behavior,
112: * the following toggles inhibit such transfers when set.
113: * vba_copyk: copy transfers to kernel address that span a page boundary
114: * vba_copyu: copy transfers to user addresses
115: */
116: #ifndef VBA_TRICKY
117: int vba_copyk = 1;
118: int vba_copyu = 1;
119: #else
120: int vba_copyk = 0;
121: int vba_copyu = 0;
122: #endif
123:
124: /*
125: * Check a transfer to see whether it can be done directly
126: * to the destination buffer, or whether it must be copied.
127: * On Tahoe, the lack of a bus I/O map forces data to be copied
128: * to a physically-contiguous buffer whenever one of the following is true:
129: * 1) The data length is not a multiple of sector size.
130: * (The swapping code does this, unfortunately.)
131: * 2) The buffer is not physically contiguous and the controller
132: * does not support scatter-gather operations.
133: * 3) The physical address for I/O is higher than addressible
134: * by the device.
135: * This routine is called by the start routine.
136: * If copying is necessary, the intermediate buffer is mapped;
137: * if the operation is a write, the data is copied into the buffer.
138: * It returns the physical address of the first byte for DMA, to
139: * be presented to the controller.
140: */
141: u_long
142: vbasetup(bp, vb, sectsize)
143: register struct buf *bp;
144: register struct vb_buf *vb;
145: int sectsize;
146: {
147: register struct pte *spte, *dpte;
148: register int p, i;
149: int npf, o, v;
150:
151: o = (int)bp->b_un.b_addr & PGOFSET;
152: npf = btoc(bp->b_bcount + o);
153: vb->vb_iskernel = (((int)bp->b_un.b_addr & KERNBASE) == KERNBASE);
154: if (vb->vb_iskernel) {
155: spte = kvtopte(bp->b_un.b_addr);
156: if (vba_copyk && (o != 0 || npf > 1)) goto copy;
157: } else {
158: spte = vtopte((bp->b_flags&B_DIRTY) ? &proc[2] : bp->b_proc,
159: btop(bp->b_un.b_addr));
160: if (vba_copyu) goto copy;
161: }
162: if (bp->b_bcount % sectsize != 0 || (o & (sizeof(long) - 1)) != 0)
163: goto copy;
164: else if ((vb->vb_flags & VB_SCATTER) == 0 ||
165: vb->vb_maxphys != btoc(VB_MAXADDR32)) {
166: dpte = spte;
167: p = (dpte++)->pg_pfnum;
168: for (i = npf; --i > 0; dpte++) {
169: if ((v = dpte->pg_pfnum) != p + CLSIZE &&
170: (vb->vb_flags & VB_SCATTER) == 0)
171: goto copy;
172: if (p >= vb->vb_maxphys)
173: goto copy;
174: p = v;
175: }
176: if (p >= vb->vb_maxphys)
177: goto copy;
178: }
179: vb->vb_copy = 0;
180: if (vb->vb_iskernel)
181: vbastat.k_raw++;
182: else
183: vbastat.u_raw++;
184: return ((spte->pg_pfnum << PGSHIFT) + o);
185:
186: copy:
187: vb->vb_copy = 1;
188: if (bp->b_bcount > vb->vb_bufsize)
189: panic("vba xfer too large");
190: if (vb->vb_iskernel) {
191: if ((bp->b_flags & B_READ) == 0)
192: bcopy(bp->b_un.b_addr, vb->vb_rawbuf,
193: (unsigned)bp->b_bcount);
194: vbastat.k_copy++;
195: } else {
196: dpte = vb->vb_map;
197: for (i = npf, p = (int)vb->vb_utl; i--; p += NBPG) {
198: *(int *)dpte++ = (spte++)->pg_pfnum |
199: PG_V | PG_KW | PG_N;
200: mtpr(TBIS, p);
201: }
202: if ((bp->b_flags & B_READ) == 0)
203: bcopy(vb->vb_utl + o, vb->vb_rawbuf,
204: (unsigned)bp->b_bcount);
205: vbastat.u_copy++;
206: }
207: return (vb->vb_physbuf);
208: }
209:
210: /*
211: * Called by the driver's interrupt routine, after DMA is completed.
212: * If the operation was a read, copy data to final buffer if necessary
213: * or invalidate data cache for cacheable direct buffers.
214: * Similar to the vbastart routine, but in the reverse direction.
215: */
216: vbadone(bp, vb)
217: register struct buf *bp;
218: register struct vb_buf *vb;
219: {
220: register npf;
221: register caddr_t v;
222: int o;
223:
224: if (bp->b_flags & B_READ) {
225: o = (int)bp->b_un.b_addr & PGOFSET;
226: if (vb->vb_copy) {
227: if (vb->vb_iskernel)
228: bcopy(vb->vb_rawbuf, bp->b_un.b_addr,
229: (unsigned)(bp->b_bcount - bp->b_resid));
230: else {
231: bcopy(vb->vb_rawbuf, vb->vb_utl + o,
232: (unsigned)(bp->b_bcount - bp->b_resid));
233: dkeyinval(bp->b_proc);
234: }
235: } else {
236: if (vb->vb_iskernel) {
237: npf = btoc(bp->b_bcount + o);
238: for (v = bp->b_un.b_addr; npf--; v += NBPG)
239: mtpr(P1DC, (int)v);
240: } else
241: dkeyinval(bp->b_proc);
242: }
243: }
244: }
245:
246: /*
247: * Set up a scatter-gather operation for SMD/E controller.
248: * This code belongs half-way between {hd,vd}.c and this file.
249: */
250:
251: #include "dk.h"
252: #if NVD > 0
253: #include "vdreg.h"
254:
255: vd_sgsetup(bp, vb, sg)
256: register struct buf *bp;
257: struct vb_buf *vb;
258: struct trsg *sg;
259: {
260: register struct pte *spte;
261: register struct addr_chain *adr;
262: register int i;
263: int o;
264:
265: vb->vb_iskernel = (((int)bp->b_un.b_addr & KERNBASE) == KERNBASE);
266: vb->vb_copy = 0;
267: if (vb->vb_iskernel) {
268: spte = kvtopte(bp->b_un.b_addr);
269: vbastat.k_sg++;
270: } else {
271: spte = vtopte((bp->b_flags&B_DIRTY) ? &proc[2] : bp->b_proc,
272: btop(bp->b_un.b_addr));
273: vbastat.u_sg++;
274: }
275:
276: o = (int)bp->b_un.b_addr & PGOFSET;
277: i = min(NBPG - o, bp->b_bcount);
278: sg->start_addr.wcount = i >> 1;
279: sg->start_addr.memadr = ((spte++)->pg_pfnum << PGSHIFT) + o;
280: i = bp->b_bcount - i;
281: if (i > VDMAXPAGES * NBPG)
282: panic("vba xfer too large");
283: i = i >> 1;
284: for (adr = sg->addr_chain; i > 0; adr++, i -= NBPG / 2) {
285: adr->nxt_addr = (spte++)->pg_pfnum << PGSHIFT;
286: adr->nxt_len = imin(i, NBPG / 2);
287: }
288: adr->nxt_addr = 0;
289: adr++->nxt_len = 0;
290: return ((adr - sg->addr_chain) * sizeof(*adr) / sizeof(long));
291: }
292: #endif
293:
294: #include "hd.h"
295: #if NHD > 0
296: #include "hdreg.h"
297:
298: hd_sgsetup(bp, vb, sg)
299: register struct buf *bp;
300: struct vb_buf *vb;
301: struct chain *sg;
302: {
303: register struct pte *spte;
304: register struct addr_chain *adr;
305: register int i, cnt;
306: int o;
307:
308: if (bp->b_bcount > HDC_MAXBC ||
309: bp->b_bcount % sizeof(long) - 1 ||
310: (u_int)bp->b_un.b_addr % sizeof(long) - 1)
311: return(0);
312:
313: vb->vb_iskernel = (((int)bp->b_un.b_addr & KERNBASE) == KERNBASE);
314: vb->vb_copy = 0;
315: if (vb->vb_iskernel) {
316: spte = kvtopte(bp->b_un.b_addr);
317: vbastat.k_sg++;
318: } else {
319: spte = vtopte((bp->b_flags&B_DIRTY) ? &proc[2] : bp->b_proc,
320: btop(bp->b_un.b_addr));
321: vbastat.u_sg++;
322: }
323:
324: o = (int)bp->b_un.b_addr & PGOFSET;
325: i = min(NBPG - o, bp->b_bcount);
326: sg->wcount = i >> 2;
327: sg->memadr = ((spte++)->pg_pfnum << PGSHIFT) + o;
328: cnt = 0;
329: for (i = (bp->b_bcount - i) >> 2; i > 0; i -= NBPG / sizeof(long)) {
330: if (++cnt == HDC_MAXCHAIN)
331: return(0);
332: sg->wcount |= LWC_DATA_CHAIN;
333: ++sg;
334: sg->wcount = imin(i, NBPG / sizeof(long));
335: sg->memadr = (spte++)->pg_pfnum << PGSHIFT;
336: }
337: return(1);
338: }
339: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.