![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uaelib.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 uaelib.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The U*nix Amiga Emulator
3: *
4: * UAE Library v0.1
5: *
6: * (c) 1996 Tauno Taipaleenmaki <[email protected]>
7: *
8: * Change UAE parameters and other stuff from inside the emulation. Creates
9: * a library called "uae.library" before the boot-up. To check if emulation
10: * is running we simply try to open the library.
11: *
12: * NOTE: The VERY FIRST attempt to open the library will actually create
13: * it, so you should always try to open it twice.
14: *
15: * Functions: Offset Purpose Arguments
16: * ----------
17: * D0 = GetVersion() -0x1E Returns UAE version -
18: * D0 = GetUaeConfig(A0) -0x24 Get UAE Configuration Pointer to memory
19: * block with the size
20: * of sizeof(UaeCfg)
21: *!D0 = SetUaeConfig(A0) -0x2A Sets UAE Configuration Pointer to struct
22: * UAE_CONFIG
23: *!D0 = HardReset() -0x30 Resets the Amiga -
24: *!D0 = Reset() -0x36 -- "" -- -
25: * D0 = EjectDisk(D0) -0x3C Ejects a disk D0 = Drive Number
26: * D0 = InsertDisk(A0,D0) -0x42 Inserts a disk D0 = drive number,
27: * A0 = ptr to name
28: * D0 = EnableSound() -0x48 Enables SOUND (if it was -
29: * compiled in)
30: * D0 = DisableSound() -0x4E Disables SOUND -
31: * D0 = EnableJoystick() -0x54 Enables FAKE_JOYSTICK -
32: * D0 = DisableJoystick() -0x5A Disables FAKE_JOYSTICK -
33: * D0 = SetFrameRate(D0) -0x60 Changes frame rate D0 = Framerate
34: *!D0 = ChgCMemSize(D0) -0x66 Changes ChipMemSize D0 = New Mem Size
35: * (DOES A HARD RESET!)
36: *!D0 = ChgSMemSize(D0) -0x6C Changes SlowMemSize D0 = New Mem Size
37: * (DOES A HARD RESET!)
38: *!D0 = ChgFMemSize(D0) -0x72 Changes FastmemSize D0 = New Mem Size
39: * (DOES A HARD RESET!)
40: * D0 = ChangeLanguage(D0)-0x78 Changes kbd lang. D0 = Language
41: * D0 = ExitEmu() -0x7E Exits the emulator -
42: * D0 = GetDisk(D0,A0) -0x84 Gets the disks name D0 = Drive
43: * A0 = Space for name
44: * D0 = Debug() -0x8A Enters internal debugger -
45: * ! means not implemented yet
46: */
47:
48: #include "sysconfig.h"
49: #include "sysdeps.h"
50:
51: #include <assert.h>
52: #include <string.h>
53:
54: #include "config.h"
55: #include "options.h"
56: #include "memory.h"
57: #include "custom.h"
58: #include "newcpu.h"
59: #include "xwin.h"
60: #include "autoconf.h"
61: #include "disk.h"
62: #include "os.h"
63:
64: extern int quit_program;
65:
66: static ULONG LibBase;
67:
68: static ULONG opencount=0;
69: static ULONG emulibname, functable,resname,resid, datatable;
70: static CPTR GetVersion,HardReset,Reset,EnableSound,DisableSound,
71: EnableJoystick,DisableJoystick,SetFrameRate,ChangeLanguage,
72: ChgCMemSize,ChgSMemSize,ChgFMemSize,EjectDisk,InsertDisk,
73: ExitEmu, GetUaeConfig, SetUaeConfig,Open,Close,Expunge,Null,
74: GetDisk,FakeInit,segList,DebugFunc;
75:
76: /*
77: * Library "open"
78: */
79: static ULONG emulib_Open(void)
80: {
81: opencount++;
82: put_word( LibBase + 32, get_word( LibBase + 32) + 1 );
83: return LibBase;
84: }
85:
86: static ULONG emulib_Close(void)
87: {
88: if (opencount <= 1)
89: return 0;
90: else {
91: opencount--;
92: put_word( LibBase + 32, get_word( LibBase + 32) - 1 );
93: return 0;
94: }
95: }
96: static ULONG emulib_Expunge(void)
97: {
98: return 0;
99: }
100:
101: static ULONG emulib_Null(void)
102: {
103: return 0;
104: }
105:
106: /*
107: * Returns UAE Version
108: */
109: static ULONG emulib_GetVersion(void)
110: {
111: return version;
112: }
113:
114: /*
115: * Resets your amiga
116: *
117: * DOES NOT WORK YET ! It obviously crashes when this routine returns().. ?
118: */
119: static ULONG emulib_HardReset(void)
120: {
121: m68k_reset();
122: return 0;
123: }
124:
125: static ULONG emulib_Reset(void)
126: {
127: m68k_reset();
128: return 0;
129: }
130:
131: /*
132: * Enables SOUND
133: */
134: static ULONG emulib_EnableSound(void)
135: {
136: if (!sound_available || produce_sound == 2)
137: return 0;
138:
139: produce_sound = 2;
140: return 1;
141: }
142:
143: /*
144: * Disables SOUND
145: */
146: static ULONG emulib_DisableSound(void)
147: {
148: produce_sound = 1;
149: return 1;
150: }
151:
152: /*
153: * Enables FAKE JOYSTICK
154: */
155: static ULONG emulib_EnableJoystick(void)
156: {
157: fake_joystick = 1;
158: return 1;
159: }
160:
161: /*
162: * Disables FAKE JOYSTICK
163: */
164: static ULONG emulib_DisableJoystick(void)
165: {
166: fake_joystick = 0;
167: return 1;
168: }
169:
170: /*
171: * Sets the framerate
172: */
173: static ULONG emulib_SetFrameRate(void)
174: {
175: if (regs.d[0] == 0)
176: return 0;
177: else if (regs.d[0] > 20)
178: return 0;
179: else {
180: framerate = regs.d[0];
181: return 1;
182: }
183: }
184:
185: /*
186: * Changes keyboard language settings
187: */
188: static ULONG emulib_ChangeLanguage(void)
189: {
190: if (regs.d[0] > 5)
191: return 0;
192: else {
193: switch( regs.d[0] ) {
194: case 0:
195: keyboard_lang = KBD_LANG_US;
196: break;
197: case 1:
198: keyboard_lang = KBD_LANG_DE;
199: break;
200: case 2:
201: keyboard_lang = KBD_LANG_SE;
202: break;
203: case 3:
204: keyboard_lang = KBD_LANG_FR;
205: break;
206: case 4:
207: keyboard_lang = KBD_LANG_IT;
208: break;
209: default:
210: break;
211: }
212: return 1;
213: }
214: }
215:
216: /*
217: * Changes CHIPMEMORY Size
218: * (reboots)
219: *
220: * DOES NOT WORK YET ! - The m68k_reset does not work from here
221: */
222: static ULONG emulib_ChgCMemSize(void)
223: {
224: ULONG memsize = regs.d[0];
225:
226: if (memsize != 0x80000 && memsize != 0x100000 &&
227: memsize != 0x200000) {
228: memsize = 0x200000;
229: fprintf(stderr, "Unsupported chipmem size!\n");
230: }
231: regs.d[0] = 0;
232:
233: chipmem_size = memsize;
234: m68k_reset();
235: return 1;
236: }
237:
238: /*
239: * Changes SLOWMEMORY Size
240: * (reboots)
241: *
242: * DOES NOT WORK YET! - the m68k_reset does not work from here
243: */
244: static ULONG emulib_ChgSMemSize(void)
245: {
246: ULONG memsize = regs.d[0];
247:
248: if (memsize != 0x80000 && memsize != 0x100000 &&
249: memsize != 0x180000 && memsize != 0x1C0000) {
250: memsize = 0;
251: fprintf(stderr, "Unsupported bogomem size!\n");
252: }
253:
254: regs.d[0] = 0;
255: bogomem_size = memsize;
256: m68k_reset();
257: return 1;
258: }
259:
260: /*
261: * Changes FASTMEMORY Size
262: * (reboots)
263: *
264: * DOES NOT WORK YET! - the m68k_reset() does not work from here
265: */
266: static ULONG emulib_ChgFMemSize(void)
267: {
268: ULONG memsize = regs.d[0];
269:
270: if (memsize != 0x100000 && memsize != 0x200000 &&
271: memsize != 0x400000 && memsize != 0x800000) {
272: memsize = 0;
273: fprintf(stderr, "Unsupported fastmem size!\n");
274: }
275: regs.d[0] = 0;
276: fastmem_size = memsize;
277: m68k_reset();
278: return 0;
279: }
280:
281: /*
282: * Ejects a disk
283: */
284: static ULONG emulib_EjectDisk(void)
285: {
286: ULONG drive = regs.d[0];
287:
288: if (drive > 3)
289: return 0;
290:
291: disk_eject( drive );
292: return 1;
293: }
294:
295: /*
296: * Inserts a disk
297: */
298: static ULONG emulib_InsertDisk(void)
299: {
300: int quit = 0,i=0,j;
301: char real_name[256];
302: UBYTE abyte;
303: ULONG drive = regs.d[0];
304: CPTR name = regs.a[0];
305: FILE *file;
306:
307: if (drive > 3)
308: return 0;
309:
310: if (!disk_empty( drive )) {
311: disk_eject( drive );
312: }
313:
314: while( quit == 0 ) {
315: abyte = get_byte(name + i);
316: if (abyte == '\0') {
317: real_name[i++] = '\0';
318: quit = 1;
319: } else {
320: real_name[i++] = abyte;
321: }
322: }
323: j = strlen( real_name );
324: if (j <= 0 || j > 255)
325: return 0;
326:
327: if (!(file = fopen(real_name, "r")))
328: return 0;
329:
330: fclose(file);
331: disk_insert(drive, real_name);
332: return 1;
333:
334: }
335:
336: /*
337: * Exits the emulator
338: */
339: static ULONG emulib_ExitEmu(void)
340: {
341: broken_in = 1;
342: regs.spcflags |= SPCFLAG_BRK;
343: quit_program = 1;
344: return 1;
345: }
346:
347: /*
348: * Gets UAE Configuration
349: */
350: static ULONG emulib_GetUaeConfig(void)
351: {
352: int i,j;
353: CPTR place = regs.a[0];
354:
355: put_long(place , version);
356: put_long(place + 4, chipmem_size);
357: put_long(place + 8, bogomem_size);
358: put_long(place + 12, fastmem_size);
359: put_long(place + 16, framerate);
360: put_long(place + 20, produce_sound);
361: put_long(place + 24, fake_joystick);
362: put_long(place + 28, keyboard_lang);
363: if (disk_empty(0))
364: put_byte(place + 32, 0);
365: else
366: put_byte(place + 32, 1);
367: if (disk_empty(1))
368: put_byte(place + 33, 0);
369: else
370: put_byte(place + 33, 1);
371: if (disk_empty(2))
372: put_byte(place + 34, 0);
373: else
374: put_byte(place + 34, 1);
375: if (disk_empty(3))
376: put_byte(place + 35, 0);
377: else
378: put_byte(place + 35, 1);
379:
380: for(i=0;i<256;i++) {
381: put_byte((place + 36 + i), df0[i]);
382: put_byte((place + 36 + i + 256), df1[i]);
383: put_byte((place + 36 + i + 512), df2[i]);
384: put_byte((place + 36 + i + 768), df3[i]);
385: }
386: return 1;
387: }
388:
389: /*
390: * Sets UAE Configuration
391: *
392: * NOT IMPLEMENTED YET
393: */
394: static ULONG emulib_SetUaeConfig(void)
395: {
396: return 1;
397: }
398:
399: /*
400: * Gets the name of the disk in the given drive
401: */
402: static ULONG emulib_GetDisk(void)
403: {
404: int i;
405: if (regs.d[0] > 3)
406: return 0;
407:
408: switch( regs.d[0] ) {
409: case 0:
410: for(i=0;i<256;i++) {
411: put_byte( regs.a[0] + i, df0[i] );
412: }
413: break;
414: case 1:
415: for(i=0;i<256;i++) {
416: put_byte( regs.a[0] + i, df1[i] );
417: }
418: break;
419: case 2:
420: for(i=0;i<256;i++) {
421: put_byte( regs.a[0] + i, df2[i] );
422: }
423: break;
424: case 3:
425: for(i=0;i<256;i++) {
426: put_byte( regs.a[0] + i, df3[i] );
427: }
428: break;
429: default:
430: break;
431: }
432: return 1;
433: }
434:
435: /*
436: * Enter debugging state
437: */
438: static ULONG emulib_Debug(void)
439: {
440: broken_in = 1;
441: regs.spcflags |= SPCFLAG_BRK;
442: return 1;
443: }
444:
445: static ULONG emulib_FakeInit(void)
446: {
447: segList = regs.a[0];
448: return regs.d[0];
449: }
450:
451: /*
452: * Creates the UAE.library in memory
453: */
454: static ULONG emulib_Init(void)
455: {
456: ULONG tmp1, quit,i;
457: UBYTE bitti;
458: ULONG dosbase;
459:
460: if (LibBase != 0)
461: return 0;
462:
463: regs.a[0] = functable;
464: regs.a[1] = datatable;
465: regs.a[2] = FakeInit;
466: regs.d[0] = 1024;
467: regs.d[1] = 0;
468: tmp1 = CallLib(regs.a[6], -0x54);
469: if (tmp1 == 0) {
470: fprintf(stderr, "Cannot create UAE.library! ");
471: return 0;
472: }
473: regs.a[1] = tmp1;
474: CallLib(regs.a[6], -0x18c);
475: LibBase = tmp1;
476: #if 0
477: regs.a[1] = ds("dos.library");
478: regs.d[0] = 0;
479: dosbase = CallLib(regs.a[6], -552);
480: printf("%08lx\n", dosbase);
481: #endif
482: regs.d[0] = 1;
483: return 0;
484: }
485:
486:
487: /*
488: * Installs the UAE LIBRARY
489: */
490: void emulib_install(void)
491: {
492: ULONG begin, end, inittable, initroutine;
493: ULONG jotain, func_place, data_place, init_place;
494:
495: resname = ds("uae.library");
496: resid = ds("UAE library 0.1");
497:
498: begin = here();
499: dw(0x4AFC);
500: dl(begin);
501: dl(0);
502: dw(0x8001);
503: dw(0x0988);
504: dl(resname);
505: dl(resid);
506: dl(here() + 4);
507:
508: dl(1024);
509: func_place = here();
510: dl(0);
511: data_place = here();
512: dl(0);
513: init_place = here();
514: dl(0);
515:
516: /* Code to set up our library */
517:
518: initroutine = here();
519: calltrap(deftrap(emulib_Init));
520: dw(RTS);
521:
522: /* Function table */
523: Open = here();
524: calltrap(deftrap(emulib_Open));
525: dw(RTS);
526:
527: Close = here();
528: calltrap(deftrap(emulib_Close));
529: dw(RTS);
530:
531: Expunge = here();
532: calltrap(deftrap(emulib_Expunge));
533: dw(RTS);
534:
535: Null = here();
536: dw(0x203c); dl(1);
537: dw(RTS);
538:
539: GetVersion = here();
540: calltrap(deftrap(emulib_GetVersion));
541: dw(RTS);
542:
543: GetUaeConfig = here();
544: calltrap(deftrap(emulib_GetUaeConfig));
545: dw(RTS);
546:
547: SetUaeConfig = here();
548: calltrap(deftrap(emulib_SetUaeConfig));
549: dw(RTS);
550:
551: HardReset = here();
552: calltrap(deftrap(emulib_HardReset));
553: dw(RTS);
554:
555: Reset = here();
556: calltrap(deftrap(emulib_Reset));
557: dw(RTS);
558:
559: EjectDisk = here();
560: calltrap(deftrap(emulib_EjectDisk));
561: dw(RTS);
562:
563: InsertDisk = here();
564: calltrap(deftrap(emulib_InsertDisk));
565: dw(RTS);
566:
567: EnableSound = here();
568: calltrap(deftrap(emulib_EnableSound));
569: dw(RTS);
570:
571: DisableSound = here();
572: calltrap(deftrap(emulib_DisableSound));
573: dw(RTS);
574:
575: EnableJoystick = here();
576: calltrap(deftrap(emulib_EnableJoystick));
577: dw(RTS);
578:
579: DisableJoystick = here();
580: calltrap(deftrap(emulib_DisableJoystick));
581: dw(RTS);
582:
583: SetFrameRate = here();
584: calltrap(deftrap(emulib_SetFrameRate));
585: dw(RTS);
586:
587: ChgCMemSize = here();
588: calltrap(deftrap(emulib_ChgCMemSize));
589: dw(RTS);
590:
591: ChgSMemSize = here();
592: calltrap(deftrap(emulib_ChgSMemSize));
593: dw(RTS);
594:
595: ChgFMemSize = here();
596: calltrap(deftrap(emulib_ChgFMemSize));
597: dw(RTS);
598:
599: ChangeLanguage = here();
600: calltrap(deftrap(emulib_ChangeLanguage));
601: dw(RTS);
602:
603: ExitEmu = here();
604: calltrap(deftrap(emulib_ExitEmu));
605: dw(RTS);
606:
607: GetDisk = here();
608: calltrap(deftrap(emulib_GetDisk));
609: dw(RTS);
610:
611: DebugFunc = here();
612: calltrap(deftrap(emulib_Debug));
613: dw(RTS);
614:
615: FakeInit = here();
616: calltrap(deftrap(emulib_FakeInit));
617: dw(RTS);
618:
619: functable = here();
620: dl(Open);
621: dl(Close);
622: dl(Expunge);
623: dl(Null);
624: dl(GetVersion);
625: dl(GetUaeConfig);
626: dl(SetUaeConfig);
627: dl(HardReset);
628: dl(Reset);
629: dl(EjectDisk);
630: dl(InsertDisk);
631: dl(EnableSound);
632: dl(DisableSound);
633: dl(EnableJoystick);
634: dl(DisableJoystick);
635: dl(SetFrameRate);
636: dl(ChgCMemSize);
637: dl(ChgSMemSize);
638: dl(ChgFMemSize);
639: dl(ChangeLanguage);
640: dl(ExitEmu);
641: dl(GetDisk);
642: dl(DebugFunc);
643: dl(0xFFFFFFFF);
644:
645: datatable = here();
646: dw(0xE000);
647: dw(0x0008);
648: dw(0x0900);
649: dw(0xC000);
650: dw(0x000A);
651: dl(resname);
652: dw(0xE000);
653: dw(0x000E);
654: dw(0x0600);
655: dw(0xD000);
656: dw(0x0014);
657: dw(0x0001);
658: dw(0xD000);
659: dw(0x0000);
660: dw(0x0000);
661: dw(0xC000);
662: dw(0x0018);
663: dl(resid);
664: dl(0x00000000);
665:
666: end = here();
667:
668: org(begin + 6); /* Load END value */
669: dl(end);
670:
671: org(data_place);
672: dl(datatable);
673:
674: org(func_place);
675: dl(functable);
676:
677: org(init_place);
678: dl(initroutine);
679:
680: org(end);
681: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.