![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fakedma.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / i386|
Return to fakedma.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / i386 |
1.1 root 1: /*
2: * these routines are written in C until the 386 compiler/assembler
3: * are available
4: *
5: * Copyright (c) Ciaran O'Donnell, Bievres (FRANCE), 1991
6: */
7:
8: #include <sys/debug.h>
9: #include <kernel/reg.h>
10:
11: #include <sys/coherent.h>
12: #include <sys/clist.h>
13: #include <sys/errno.h>
14: #include <sys/inode.h>
15: #include <sys/proc.h>
16: #include <sys/seg.h>
17: #include <signal.h>
18: #include <sys/uproc.h>
19: #include <sys/buf.h>
20:
21: #define min(a, b) ((a) < (b) ? (a) : (b))
22:
23: /*
24: * dmacopy()
25: *
26: * Copy "npage" 4 kbyte pages from phys addr "from" to phys addr "to".
27: */
28:
29: dmacopy(npage, from, to)
30: long npage;
31: cseg_t *from, *to;
32: {
33: int work = workAlloc (); /* Get a virtual click pair. */
34:
35: ASSERT (npage > 0);
36:
37: for (;;) {
38: ptable1_v [work] = * from ++ | SEG_SRW;
39: ptable1_v [work + 1] = * to ++ | SEG_SRW;
40: memcpy (ctob (work + 1), ctob (work), NBPC);
41:
42: if (-- npage == 0)
43: break;
44:
45: mmuupd (); /* flush paging TLB */
46: }
47:
48: workFree(work);
49: }
50:
51: /*
52: * dmaclear()
53: *
54: * Given a byte count, and a system global address, zero-fill the memory.
55: */
56:
57: void
58: dmaclear (nbytes, to)
59: long nbytes;
60: paddr_t to;
61: {
62: unsigned off;
63: int n;
64: cseg_t *base;
65: int work = workAlloc (); /* Get a virtual click pair. */
66:
67: off = to & (NBPC - 1);
68: base = & sysmem.u.pbase [btocrd (to)];
69: n = min (nbytes, NBPC - off);
70: ptable1_v [work] = * base ++ | SEG_SRW;
71:
72: memset (ctob (work) + off, 0, n);
73: nbytes -= n;
74:
75: while (nbytes > 0) {
76: n = min (nbytes, NBPC);
77: ptable1_v [work] = * base ++ | SEG_SRW;
78: mmuupd ();
79:
80: memset (ctob (work), 0, n);
81: nbytes -= n;
82: }
83:
84: workFree(work);
85: }
86:
87: /*
88: * dmain()
89: *
90: * Copy in "nbytes" from system global address "to" to kernel address
91: * "vaddr".
92: */
93: dmain(nbytes, to, vaddr)
94: long nbytes;
95: paddr_t to;
96: caddr_t vaddr;
97: {
98: unsigned off;
99: unsigned n, n1;
100: cseg_t* base;
101: int work = workAlloc (); /* Get a virtual click pair. */
102:
103: off = to & (NBPC - 1);
104: base = & sysmem.u.pbase [btocrd (to)];
105:
106: n = min (nbytes, NBPC - off);
107: ptable1_v [work] = * base ++ | SEG_SRW;
108:
109: memcpy (vaddr, ctob (work) + off, n);
110: vaddr += n;
111: nbytes -= n;
112:
113: while (nbytes > 0) {
114: n = min (nbytes, NBPC);
115: ptable1_v [work] = * base ++ | SEG_SRW;
116: mmuupd ();
117:
118: memcpy (vaddr, ctob (work), n);
119: vaddr += n;
120: nbytes -= n;
121: }
122:
123: workFree (work);
124: }
125:
126: /*
127: * dmaout()
128: *
129: * Copy out "nbytes" from kernel address "vaddr" to system global address
130: * "to".
131: */
132: dmaout(nbytes, to, vaddr)
133: long nbytes;
134: paddr_t to;
135: caddr_t vaddr;
136: {
137: unsigned off;
138: unsigned n, n1;
139: cseg_t *base;
140: int work = workAlloc (); /* Get a virtual click pair. */
141:
142: off = to & (NBPC - 1);
143: base = & sysmem.u.pbase [btocrd (to)];
144:
145: n = min (nbytes, NBPC - off);
146: ptable1_v [work] = * base ++ | SEG_SRW;
147:
148: memcpy (ctob (work) + off, vaddr, n);
149: vaddr += n;
150: nbytes -= n;
151:
152: while (nbytes > 0) {
153: n = min (nbytes, NBPC);
154: ptable1_v [work] = * base ++ | SEG_SRW;
155: mmuupd ();
156:
157: memcpy (ctob (work), vaddr, n);
158: vaddr += n;
159: nbytes -= n;
160: }
161:
162: workFree(work);
163: }
164:
165: /*
166: * dmaio2()
167: *
168: * Copy in "nbytes" from an I/O port "port" to the system global address
169: * "to".
170: */
171: dmaio2(nbytes, to, port)
172: long nbytes, port;
173: paddr_t to;
174: {
175: unsigned off;
176: int n;
177: cseg_t *base;
178: int work = workAlloc (); /* Get a virtual click pair. */
179:
180: off = to & (NBPC - 1);
181: base = & sysmem.u.pbase [btocrd (to)];
182:
183: n = min (nbytes, NBPC - off);
184: ptable1_v [work] = * base ++ | SEG_SRW;
185:
186: io2seg (n, ctob (work) + off, port);
187: nbytes -= n;
188:
189: while (nbytes > 0) {
190: n = min (nbytes, NBPC);
191: ptable1_v [work] = * base ++ | SEG_SRW;
192: mmuupd ();
193: io2seg(n, ctob (work), port);
194: nbytes -= n;
195: }
196:
197: workFree(work);
198: }
199:
200: /*
201: * dma2io()
202: *
203: * Copy out "nbytes" from the system global address "from" to an I/O port
204: * "port".
205: */
206: dma2io(nbytes, to, port)
207: long nbytes, port;
208: paddr_t to;
209: {
210: unsigned off;
211: int n;
212: cseg_t *base;
213: int work = workAlloc (); /* Get a virtual click pair. */
214:
215: off = to & (NBPC - 1);
216: base = & sysmem.u.pbase [btocrd (to)];
217:
218: n = min (nbytes, NBPC - off);
219: ptable1_v [work] = * base ++ | SEG_SRW;
220:
221: seg2io (n, ctob (work) + off, port);
222: nbytes -= n;
223:
224: while (nbytes > 0) {
225: n = min (nbytes, NBPC);
226: ptable1_v [work] = * base ++ | SEG_SRW;
227: mmuupd ();
228: seg2io (n, ctob (work), port);
229: nbytes -= n;
230: }
231:
232: workFree(work);
233: }
234:
235: /*
236: * pxcopy()
237: *
238: * copy "n" bytes of data at kernel address "v" from address "uo" in:
239: * system global address space (space & SEG_VIRT)
240: * physical memory ! (space & SEG_VIRT)
241: * Rights are determined by (space & ~ SEG_VIRT):
242: * "v" can be anywhere in kernel address space SEG_386_KD
243: * "v" must be an address accessible to the user SEG_386_UD
244: * Up to one click of data can be copied. No alignment restrictions
245: * on "uo" apply.
246: */
247: pxcopy(uo, v, n, space)
248: unsigned uo;
249: char *v;
250: register int n;
251: {
252: cseg_t * base;
253: int save;
254: int err;
255: int work;
256:
257: if (n > NBPC)
258: return 0;
259:
260: work = workAlloc ();
261:
262: if (space & SEG_VIRT) {
263: space &= ~ SEG_VIRT;
264: base = & sysmem.u.pbase [btocrd (uo)];
265: ptable1_v [work] = * base ++ | SEG_SRW;
266: ptable1_v [work + 1] = * base ++ | SEG_SRW;
267: } else {
268: ptable1_v [work] = (uo & ~ (NBPC - 1)) + SEG_SRW;
269: ptable1_v [work + 1] = (uo & ~ (NBPC - 1)) + NBPC + SEG_SRW;
270: }
271:
272: save = setspace (space);
273: err = kucopy (ctob (work) + (uo & (NBPC - 1)), v, n);
274: setspace (save);
275:
276: workFree (work);
277: return err;
278: }
279:
280:
281: /*
282: * xpcopy()
283: *
284: * copy "n" bytes of data from kernel address "v" to address "uo" in:
285: * system global address space (space&SEG_VIRT)
286: * physical memory !(space&SEG_VIRT)
287: * Rights are determined by (space&~SEG_VIRT):
288: * "v" can be anywhere in kernel address space SEG_386_KD
289: * "v" must be an address accessible to the user SEG_386_UD
290: * Up to one click of data can be copied. No alignment restrictions on "uo"
291: * apply.
292: */
293:
294: xpcopy(v, uo, n, space)
295: char *v;
296: unsigned uo;
297: register int n;
298: {
299: cseg_t * base;
300: int save;
301: int err;
302: int work;
303:
304: if (n > NBPC)
305: return 0;
306:
307: work = workAlloc ();
308:
309: if (space & SEG_VIRT) {
310: space &= ~ SEG_VIRT;
311: base = & sysmem.u.pbase [btocrd (uo)];
312: ptable1_v [work] = * base ++ | SEG_SRW;
313: ptable1_v [work + 1] = * base ++ | SEG_SRW;
314: } else {
315: ptable1_v [work] = (uo & ~ (NBPC - 1)) + SEG_SRW;
316: ptable1_v [work + 1] = (uo & ~ (NBPC - 1)) + NBPC + SEG_SRW;
317: }
318:
319: save = setspace (space);
320: err = ukcopy (v, ctob (work) + (uo & (NBPC - 1)), n);
321: setspace (save);
322:
323: workFree (work);
324: return err;
325: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.