![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xbios.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Atari MiNT] / MiNT / src|
Return to xbios.c CVS log | Up to [Atari MiNT] / MiNT / src |
1.1 root 1: /*
2:
3: Copyright 1990,1991,1992 Eric R. Smith. All rights reserved.
4:
5: */
6:
7:
8:
9: /*
10:
11: * XBIOS replacement routines
12:
13: */
14:
15:
16:
17: #include "mint.h"
18:
19:
20:
21: extern int tosvers; /* from main.c */
22:
23:
24:
25: #define XBIOS_MAX 0x80
26:
27:
28:
29: Func xbios_tab[XBIOS_MAX]; /* initially all zeros */
30:
31: short xbios_max = XBIOS_MAX;
32:
33:
34:
35: /* NOTE: has_bconmap is initialized in main.c */
36:
37:
38:
39: int has_bconmap; /* flag: set if running under a version
40:
41: * of TOS which supports Bconmap
42:
43: */
44:
45:
46:
47: /*
48:
49: * Supexec() presents a lot of problems for us: for example, the user
50:
51: * may be calling the kernel, or may be changing interrupt vectors
52:
53: * unexpectedly. So we play some dirty tricks here: the function
54:
55: * call is treated like a signal handler, and we take advantage
56:
57: * of the fact that no context switches will take place while
58:
59: * in supervisor mode. ASSUMPTION: the user will not choose to
60:
61: * switch back to user mode, or if s/he does it will be as part
62:
63: * of a longjmp().
64:
65: *
66:
67: * BUG: if the user function switches to user mode, then back to
68:
69: * supervisor mode and returns, then the returned value may be
70:
71: * inaccurate (this happens if two programs make Supexec calls
72:
73: * at the same time).
74:
75: */
76:
77:
78:
79: static long (*usrcall) P_((long,long,long,long,long));
80:
81: static long usrret;
82:
83: static long usrarg1, usrarg2, usrarg3, usrarg4, usrarg5;
84:
85:
86:
87: static void do_usrcall P_((void));
88:
89:
90:
91: static void
92:
93: do_usrcall()
94:
95: {
96:
97: usrret = (*usrcall)(usrarg1, usrarg2, usrarg3, usrarg4, usrarg5);
98:
99: }
100:
101:
102:
103: long
104:
105: supexec(funcptr, arg1, arg2, arg3, arg4, arg5)
106:
107: Func funcptr;
108:
109: long arg1, arg2, arg3, arg4, arg5;
110:
111: {
112:
113: short savesr;
114:
115: CONTEXT *syscall = &curproc->ctxt[SYSCALL];
116:
117:
118:
119: /* set things up so that "signal 0" will be handled by calling the user's
120:
121: * function.
122:
123: */
124:
125:
126:
127: usrcall = funcptr;
128:
129: usrarg1 = arg1;
130:
131: usrarg2 = arg2;
132:
133: usrarg3 = arg3;
134:
135: usrarg4 = arg4;
136:
137: usrarg5 = arg5;
138:
139: curproc->sighandle[0] = (long)do_usrcall;
140:
141: savesr = syscall->sr; /* save old super/user mode flag */
142:
143: syscall->sr |= 0x2000; /* set supervisor mode */
144:
145: handle_sig(0); /* actually call out to the user function */
146:
147: syscall->sr = savesr;
148:
149:
150:
151: /* do_usrcall saves the user's return value in usrret */
152:
153: return usrret;
154:
155: }
156:
157:
158:
159:
160:
161: /*
162:
163: * midiws: we have to replace this, because it's possible that the process'
164:
165: * view of what the MIDI port is has been changed by Fforce or Fmidipipe
166:
167: */
168:
169:
170:
171: long
172:
173: midiws(cnt, buf)
174:
175: int cnt;
176:
177: const char *buf;
178:
179: {
180:
181: FILEPTR *f;
182:
183: long towrite = cnt+1;
184:
185:
186:
187: f = curproc->handle[-5]; /* MIDI output handle */
188:
189: if (!f) return EIHNDL;
190:
191:
192:
193: if (is_terminal(f)) {
194:
195: while (cnt >= 0) {
196:
197: tty_putchar(f, (long)*buf, RAW);
198:
199: buf++; cnt--;
200:
201: }
202:
203: return towrite;
204:
205: }
206:
207: return (*f->dev->write)(f, buf, towrite);
208:
209: }
210:
211:
212:
213: /*
214:
215: * Modem control things: these are replaced because we handle
216:
217: * Bconmap ourselves
218:
219: */
220:
221:
222:
223: /* mapin: utility routine, does a Bconmap and keeps track
224:
225: * so we call the kernel only when necessary; call this
226:
227: * only if has_bconmap is "true".
228:
229: * Returns: 0 on failure, 1 on success.
230:
231: */
232:
233: int curbconmap;
234:
235:
236:
237: int
238:
239: mapin(dev)
240:
241: int dev;
242:
243: {
244:
245: int r;
246:
247:
248:
249: if (dev == curbconmap)
250:
251: return 1;
252:
253: r = Bconmap(dev);
254:
255: if (r) {
256:
257: curbconmap = dev;
258:
259: return 1;
260:
261: }
262:
263: return 0;
264:
265: }
266:
267:
268:
269: long
270:
271: uiorec(dev)
272:
273: int dev;
274:
275: {
276:
277: TRACE("Iorec(%d)", dev);
278:
279: if (dev == 0 && has_bconmap)
280:
281: mapin(curproc->bconmap);
282:
283: return (long)Iorec(dev);
284:
285: }
286:
287:
288:
289: long
290:
291: rsconf(baud, flow, uc, rs, ts, sc)
292:
293: int baud, flow, uc, rs, ts, sc;
294:
295: {
296:
297: TRACE("Rsconf(%d,%d,%d,%d,%d,%d)", baud, flow,
298:
299: uc, rs, ts, sc);
300:
301:
302:
303: if (has_bconmap)
304:
305: mapin(curproc->bconmap);
306:
307: return Rsconf(baud, flow, uc, rs, ts, sc);
308:
309: }
310:
311:
312:
313: long
314:
315: bconmap(dev)
316:
317: int dev;
318:
319: {
320:
321: int old = curproc->bconmap;
322:
323:
324:
325: TRACE("Bconmap(%d)", dev);
326:
327:
328:
329: if (has_bconmap) {
330:
331: if (dev == -1) return old;
332:
333: if (dev == -2) return Bconmap(-2);
334:
335: if (mapin(dev) == 0) {
336:
337: DEBUG("Bconmap: mapin failed");
338:
339: return 0;
340:
341: }
342:
343: if (set_auxhandle(curproc, dev) == 0) {
344:
345: DEBUG("Bconmap: Couldn't change AUX:");
346:
347: return 0;
348:
349: }
350:
351: curproc->bconmap = dev;
352:
353: return old;
354:
355: }
356:
357: return EINVFN; /* no Bconmap available */
358:
359: }
360:
361:
362:
363: void
364:
365: init_xbios()
366:
367: {
368:
369: curbconmap = (has_bconmap) ? Bconmap(-1) : 1;
370:
371:
372:
373: xbios_tab[0x0c] = midiws;
374:
375: xbios_tab[0x0e] = uiorec;
376:
377: xbios_tab[0x0f] = rsconf;
378:
379: xbios_tab[0x26] = supexec;
380:
381: xbios_tab[0x2c] = bconmap;
382:
383: }
384:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.