![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to autoconf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to autoconf.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * AutoConfig devices
5: *
6: * (c) 1995 Bernd Schmidt
7: * (c) 1996 Ed Hanway
8: */
9:
10: #include "sysconfig.h"
11: #include "sysdeps.h"
12:
13: #include "config.h"
14: #include "options.h"
15: #include "memory.h"
16: #include "custom.h"
17: #include "newcpu.h"
18: #include "disk.h"
19: #include "xwin.h"
20: #include "autoconf.h"
21:
22: static struct {
23: CPTR libbase;
24: TrapFunction functions[300]; /* I don't think any library has more than 300 functions */
25: } libpatches[20];
26: static int n_libpatches = 0;
27:
28: ULONG Call68k_retaddr(CPTR address, int saveregs, CPTR retaddr)
29: {
30: ULONG retval;
31: CPTR oldpc = m68k_getpc();
32:
33: struct regstruct backup_regs;
34: if (saveregs)
35: backup_regs = regs;
36: regs.a[7] -= 4;
37: put_long (regs.a[7], retaddr);
38: m68k_setpc(address);
39: m68k_go(0);
40: retval = regs.d[0];
41: if (saveregs)
42: regs = backup_regs;
43: m68k_setpc(oldpc);
44: return retval;
45: }
46:
47: ULONG Call68k(CPTR address, int saveregs)
48: {
49: return Call68k_retaddr(address, saveregs, 0xF0FFF0);
50: }
51:
52: ULONG CallLib(CPTR base, WORD offset)
53: {
54: int i;
55: CPTR olda6 = regs.a[6];
56: ULONG retval;
57:
58: for (i = 0; i < n_libpatches; i++) {
59: if (libpatches[i].libbase == base && libpatches[i].functions[-offset/6] != NULL)
60: return (*libpatches[i].functions[-offset/6])();
61: }
62:
63: regs.a[6] = base;
64: retval = Call68k(base + offset, 1);
65: regs.a[6] = olda6;
66: return retval;
67: }
68:
69: /* @$%&� compiler bugs */
70: static volatile int four = 4;
71:
72: CPTR libemu_InstallFunctionFlags(TrapFunction f, CPTR libbase, int offset,
73: int flags)
74: {
75: int i;
76: CPTR retval;
77: CPTR execbase = get_long(four);
78: ULONG addr = here();
79: calltrap2(deftrap2(f, flags));
80: dw(RTS);
81:
82: regs.a[1] = libbase;
83: regs.a[0] = offset;
84: regs.d[0] = addr;
85: retval = CallLib(execbase, -420);
86: for (i = 0; i < n_libpatches; i++) {
87: if (libpatches[i].libbase == libbase)
88: break;
89: }
90: if (i == n_libpatches) {
91: int j;
92: libpatches[i].libbase = libbase;
93: for (j = 0; j < 300; j++)
94: libpatches[i].functions[j] = NULL;
95: n_libpatches++;
96: }
97: libpatches[i].functions[-offset/6] = f;
98: return retval;
99: }
100:
101: CPTR libemu_InstallFunction(TrapFunction f, CPTR libbase, int offset)
102: {
103: return libemu_InstallFunctionFlags(f, libbase, offset, 0);
104: }
105:
106: /* Commonly used autoconfig strings */
107:
108: CPTR EXPANSION_explibname, EXPANSION_doslibname, EXPANSION_uaeversion;
109: CPTR EXPANSION_uaedevname, EXPANSION_explibbase = 0, EXPANSION_haveV36;
110: CPTR EXPANSION_bootcode;
111:
112: static int current_deviceno = 0;
113:
114: int get_new_device(char **devname, CPTR *devname_amiga)
115: {
116: char buffer[80];
117:
118: sprintf(buffer,"UAE%d", current_deviceno);
119:
120: *devname_amiga = ds(*devname = strdup(buffer));
121: return current_deviceno++;
122: }
123:
124: /* ROM tag area memory access */
125:
126: static UBYTE rtarea[65536];
127:
128: static ULONG rtarea_lget(CPTR) REGPARAM;
129: static UWORD rtarea_wget(CPTR) REGPARAM;
130: static UBYTE rtarea_bget(CPTR) REGPARAM;
131: static void rtarea_lput(CPTR, ULONG) REGPARAM;
132: static void rtarea_wput(CPTR, UWORD) REGPARAM;
133: static void rtarea_bput(CPTR, UBYTE) REGPARAM;
134: static UBYTE *rtarea_xlate(CPTR) REGPARAM;
135:
136: addrbank rtarea_bank = {
137: rtarea_lget, rtarea_wget,
138: rtarea_lget, rtarea_wget, rtarea_bget,
139: rtarea_lput, rtarea_wput, rtarea_bput,
140: rtarea_xlate, default_check
141: };
142:
143: UBYTE *rtarea_xlate(CPTR addr)
144: {
145: addr &= 0xFFFF;
146: return rtarea + addr;
147: }
148:
149: ULONG rtarea_lget(CPTR addr)
150: {
151: addr &= 0xFFFF;
152: return (ULONG)(rtarea_wget(addr) << 16) + rtarea_wget(addr+2);
153: }
154:
155: UWORD rtarea_wget(CPTR addr)
156: {
157: addr &= 0xFFFF;
158: return (rtarea[addr]<<8) + rtarea[addr+1];
159: }
160:
161: UBYTE rtarea_bget(CPTR addr)
162: {
163: UWORD data;
164: addr &= 0xFFFF;
165: return rtarea[addr];
166: }
167:
168: void rtarea_lput(CPTR addr, ULONG value) { }
169: void rtarea_bput(CPTR addr, UBYTE value) { }
170:
171: /* Don't start at 0 -- can get bogus writes there. */
172: static ULONG trap_base_addr = 0x00F00180;
173:
174: /* We'll need a lot of these. */
175: TrapFunction traps[16384];
176: char trapmode[16384];
177:
178: static int max_trap = 0;
179:
180: int lasttrap;
181:
182: void do_emultrap(int tr)
183: {
184: struct regstruct backup_regs;
185: ULONG retval;
186:
187: if ((trapmode[tr] & 1) == 0)
188: backup_regs = regs;
189: retval = (*traps[tr])();
190: if ((trapmode[tr] & 1) == 0)
191: regs = backup_regs;
192: if ((trapmode[tr] & 2) == 0)
193: regs.d[0] = retval;
194: }
195:
196: void rtarea_wput(CPTR addr, UWORD value)
197: {
198: /* Save all registers */
199: struct regstruct backup_regs;
200: ULONG retval = 0;
201: ULONG func = ((addr - trap_base_addr) & 0xFFFF) >> 1;
202:
203: if (func == 0) {
204: lasttrap = get_long(regs.a[7]);
205: regs.a[7] += 4;
206: regs.spcflags |= SPCFLAG_EMULTRAP;
207: return;
208: }
209:
210: backup_regs = regs;
211: if(func < max_trap) {
212: retval = (*traps[func])();
213: } else {
214: fprintf(stderr, "illegal emulator trap\n");
215: }
216: regs = backup_regs;
217: regs.d[0] = retval;
218: }
219:
220: /* some quick & dirty code to fill in the rt area and save me a lot of
221: * scratch paper
222: */
223:
224: static int rt_addr = 0;
225: static int rt_straddr = 0xFF00 - 2;
226:
227: ULONG addr(int ptr)
228: {
229: return (ULONG)ptr + 0x00F00000;
230: }
231:
232: void dw(UWORD data)
233: {
234: rtarea[rt_addr++] = data >> 8;
235: rtarea[rt_addr++] = data;
236: }
237:
238: void dl(ULONG data)
239: {
240: rtarea[rt_addr++] = data >> 24;
241: rtarea[rt_addr++] = data >> 16;
242: rtarea[rt_addr++] = data >> 8;
243: rtarea[rt_addr++] = data;
244: }
245:
246: /* store strings starting at the end of the rt area and working
247: * backward. store pointer at current address
248: */
249:
250: ULONG ds(char *str)
251: {
252: int len = strlen(str) + 1;
253:
254: rt_straddr -= len;
255: strcpy(rtarea + rt_straddr, str);
256:
257: return addr(rt_straddr);
258: }
259:
260: void calltrap2(ULONG n)
261: {
262: dw(0x4878); /* PEA.L n.w */
263: dw(n);
264: /* Call trap #0 is reserved for this */
265: dw(0x33C0); /* MOVE.W D0,abs32 */
266: dl(trap_base_addr);
267: }
268:
269: void calltrap(ULONG n)
270: {
271: #if 1
272: dw(0x33C0); /* MOVE.W D0,abs32 */
273: dl(n*2 + trap_base_addr);
274: #else
275: calltrap2(n);
276: #endif
277: }
278:
279: void org(ULONG a)
280: {
281: rt_addr = a - 0x00F00000;
282: }
283:
284: ULONG here(void)
285: {
286: return addr(rt_addr);
287: }
288:
289: int deftrap(TrapFunction func)
290: {
291: int num = max_trap++;
292: traps[num] = func;
293: trapmode[num] = 0;
294: return num;
295: }
296:
297: int deftrap2(TrapFunction func, int mode)
298: {
299: int num = max_trap++;
300: traps[num] = func;
301: trapmode[num] = mode;
302: return num;
303: }
304:
305: void align(int b)
306: {
307: rt_addr = (rt_addr + (b-1)) & ~(b-1);
308: }
309:
310: static ULONG bootcode(void)
311: {
312: regs.a[1] = EXPANSION_doslibname;
313: regs.d[0] = CallLib (regs.a[6], -96); /* FindResident() */
314: regs.a[0] = get_long(regs.d[0]+22); /* get dos.library rt_init */
315: return regs.a[0];
316: }
317:
318: void rtarea_init()
319: {
320: ULONG a;
321: char uaever[100];
322: sprintf(uaever, "uae-%d.%d.%d", (version / 100) % 10, (version / 10) % 10, (version / 1) % 10);
323:
324: EXPANSION_uaeversion = ds(uaever);
325: EXPANSION_explibname = ds("expansion.library");
326: EXPANSION_doslibname = ds("dos.library");
327: EXPANSION_uaedevname = ds("uae.device");
328:
329: deftrap(NULL); /* Generic emulator trap */
330: lasttrap = 0;
331:
332: align(4);
333: EXPANSION_bootcode = here();
334: calltrap2(deftrap2(bootcode, 1));
335: dw(0x2040); /* move.l d0,a0 */
336: dw(0x4e90); /* jsr (a0) */
337: dw(RTS);
338:
339: a = here();
340:
341: /* Idle task */
342: org(0xF0FFF0 - 4);
343: dw(0x4E72); dw (0x2000); /* STOP 0x2000 */
344:
345: /* Standard "return from 68k mode" trap */
346: /*org(0xF0FFF0); */
347: calltrap2(0);
348: dw(RTS);
349: org(a);
350: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.