![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to memory.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 memory.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * Memory management
5: *
6: * (c) 1995 Bernd Schmidt
7: */
8:
9: #include "sysconfig.h"
10: #include "sysdeps.h"
11:
12: #include "config.h"
13: #include "options.h"
14: #include "memory.h"
15: #include "custom.h"
16: #include "cia.h"
17: #include "ersatz.h"
18: #include "zfile.h"
19: #include "events.h"
20: #include "newcpu.h"
21: #include "compiler.h"
22:
23: #ifdef USE_COMPILER
24: #include <sys/mman.h>
25: #endif
26:
27: int ersatzkickfile = 0;
28:
29: int buserr;
30: addrbank membanks[65536];
31:
32: /* Default memory access functions */
33:
34: int default_check(CPTR a, ULONG b)
35: {
36: return 0;
37: }
38:
39: UBYTE *default_xlate(CPTR a)
40: {
41: fprintf(stderr, "Your Amiga program just did something terribly stupid\n");
42: return 0;
43: }
44:
45: UWORD default_awget(CPTR addr)
46: {
47: default_xlate(addr);
48: return 0;
49: }
50:
51: ULONG default_alget(CPTR addr)
52: {
53: default_xlate(addr);
54: return 0;
55: }
56:
57: /* A dummy bank that only contains zeros */
58:
59: static ULONG dummy_lget(CPTR) REGPARAM;
60: static UWORD dummy_wget(CPTR) REGPARAM;
61: static UBYTE dummy_bget(CPTR) REGPARAM;
62: static void dummy_lput(CPTR, ULONG) REGPARAM;
63: static void dummy_wput(CPTR, UWORD) REGPARAM;
64: static void dummy_bput(CPTR, UBYTE) REGPARAM;
65: static int dummy_check(CPTR addr, ULONG size) REGPARAM;
66:
67: ULONG dummy_lget(CPTR addr)
68: {
69: if (illegal_mem) printf("Illegal lget at %08lx pc=%08lx\n",addr,m68k_getpc());
70: return 0;
71: }
72:
73: UWORD dummy_wget(CPTR addr)
74: {
75: if (illegal_mem) printf("Illegal wget at %08lx pc=%08lx\n",addr,m68k_getpc());
76: return 0;
77: }
78:
79: UBYTE dummy_bget(CPTR addr)
80: {
81: if (illegal_mem) printf("Illegal bget at %08lx pc=%08lx\n",addr,m68k_getpc());
82: return 0;
83: }
84:
85: void dummy_lput(CPTR addr, ULONG l)
86: {
87: if (illegal_mem) printf("Illegal lput at %08lx pc=%08lx\n",addr,m68k_getpc());
88: }
89: void dummy_wput(CPTR addr, UWORD w)
90: {
91: if (illegal_mem) printf("Illegal wput at %08lx pc=%08lx\n",addr,m68k_getpc());
92: }
93: void dummy_bput(CPTR addr, UBYTE b)
94: {
95: if (illegal_mem) printf("Illegal bput at %08lx pc=%08lx\n",addr,m68k_getpc());
96: }
97:
98: int dummy_check(CPTR addr, ULONG size)
99: {
100: if (illegal_mem) printf("Illegal check at %08lx pc=%08lx\n",addr,m68k_getpc());
101: return 0;
102: }
103:
104: /* Chip memory */
105:
106: ULONG chipmem_mask,kickmem_mask,bogomem_mask;
107:
108: UBYTE *chipmemory;
109:
110: static ULONG chipmem_alget(CPTR) REGPARAM;
111: static UWORD chipmem_awget(CPTR) REGPARAM;
112:
113: static ULONG chipmem_lget(CPTR) REGPARAM;
114: static UWORD chipmem_wget(CPTR) REGPARAM;
115: static UBYTE chipmem_bget(CPTR) REGPARAM;
116: static void chipmem_lput(CPTR, ULONG) REGPARAM;
117: static void chipmem_wput(CPTR, UWORD) REGPARAM;
118: static void chipmem_bput(CPTR, UBYTE) REGPARAM;
119:
120: static int chipmem_check(CPTR addr, ULONG size) REGPARAM;
121: static UBYTE *chipmem_xlate(CPTR addr) REGPARAM;
122:
123: ULONG chipmem_alget(CPTR addr)
124: {
125: UBYTE *m;
126: addr -= chipmem_start & chipmem_mask;
127: addr &= chipmem_size-1;
128: m = chipmemory + addr;
129: return (((ULONG)m[0] << 24) + ((ULONG)m[1] << 16)
130: + ((ULONG)m[2] << 8) + ((ULONG)m[3]));
131: }
132:
133: UWORD chipmem_awget(CPTR addr)
134: {
135: UBYTE *m;
136: addr -= chipmem_start & chipmem_mask;
137: addr &= chipmem_size-1;
138: m = chipmemory + addr;
139: return ((UWORD)m[0] << 8) + m[1];
140: }
141:
142: ULONG chipmem_lget(CPTR addr)
143: {
144: UBYTE *m;
145: addr -= chipmem_start & chipmem_mask;
146: addr &= chipmem_size-1;
147: m = chipmemory + addr;
148: return (((ULONG)m[0] << 24) + ((ULONG)m[1] << 16)
149: + ((ULONG)m[2] << 8) + ((ULONG)m[3]));
150: }
151:
152: UWORD chipmem_wget(CPTR addr)
153: {
154: UBYTE *m;
155: addr -= chipmem_start & chipmem_mask;
156: addr &= chipmem_size-1;
157: m = chipmemory + addr;
158: return ((UWORD)m[0] << 8) + m[1];
159: }
160:
161: UBYTE chipmem_bget(CPTR addr)
162: {
163: addr -= chipmem_start & chipmem_mask;
164: addr &= chipmem_size-1;
165: return chipmemory[addr];
166: }
167:
168: void chipmem_lput(CPTR addr, ULONG l)
169: {
170: UBYTE *m;
171: addr -= chipmem_start & chipmem_mask;
172: addr &= chipmem_size-1;
173: m = chipmemory + addr;
174: m[0] = l >> 24;
175: m[1] = l >> 16;
176: m[2] = l >> 8;
177: m[3] = l;
178: }
179:
180: void chipmem_wput(CPTR addr, UWORD w)
181: {
182: UBYTE *m;
183: addr -= chipmem_start & chipmem_mask;
184: addr &= chipmem_size-1;
185: m = chipmemory + addr;
186: m[0] = w >> 8;
187: m[1] = w;
188: }
189:
190: void chipmem_bput(CPTR addr, UBYTE b)
191: {
192: addr -= chipmem_start & chipmem_mask;
193: addr &= chipmem_size-1;
194: chipmemory[addr] = b;
195: }
196:
197: int chipmem_check(CPTR addr, ULONG size)
198: {
199: addr -= chipmem_start & chipmem_mask;
200: addr &= chipmem_size-1;
201: return (addr + size) < chipmem_size;
202: }
203:
204: UBYTE *chipmem_xlate(CPTR addr)
205: {
206: addr -= chipmem_start & chipmem_mask;
207: addr &= chipmem_size-1;
208: return chipmemory + addr;
209: }
210:
211: /* Slow memory */
212:
213: static UBYTE *bogomemory;
214:
215: static ULONG bogomem_alget(CPTR) REGPARAM;
216: static UWORD bogomem_awget(CPTR) REGPARAM;
217: static ULONG bogomem_lget(CPTR) REGPARAM;
218: static UWORD bogomem_wget(CPTR) REGPARAM;
219: static UBYTE bogomem_bget(CPTR) REGPARAM;
220: static void bogomem_lput(CPTR, ULONG) REGPARAM;
221: static void bogomem_wput(CPTR, UWORD) REGPARAM;
222: static void bogomem_bput(CPTR, UBYTE) REGPARAM;
223: static int bogomem_check(CPTR addr, ULONG size) REGPARAM;
224: static UBYTE *bogomem_xlate(CPTR addr) REGPARAM;
225:
226: ULONG bogomem_alget(CPTR addr)
227: {
228: UBYTE *m;
229: addr -= bogomem_start & bogomem_mask;
230: addr &= bogomem_size-1;
231: m = bogomemory + addr;
232: return (((ULONG)m[0] << 24) + ((ULONG)m[1] << 16)
233: + ((ULONG)m[2] << 8) + ((ULONG)m[3]));
234: }
235:
236: UWORD bogomem_awget(CPTR addr)
237: {
238: UBYTE *m;
239: addr -= bogomem_start & bogomem_mask;
240: addr &= bogomem_size-1;
241: m = bogomemory + addr;
242: return ((UWORD)m[0] << 8) + m[1];
243: }
244:
245: ULONG bogomem_lget(CPTR addr)
246: {
247: UBYTE *m;
248: addr -= bogomem_start & bogomem_mask;
249: addr &= bogomem_size-1;
250: m = bogomemory + addr;
251: return (((ULONG)m[0] << 24) + ((ULONG)m[1] << 16)
252: + ((ULONG)m[2] << 8) + ((ULONG)m[3]));
253: }
254:
255: UWORD bogomem_wget(CPTR addr)
256: {
257: UBYTE *m;
258: addr -= bogomem_start & bogomem_mask;
259: addr &= bogomem_size-1;
260: m = bogomemory + addr;
261: return ((UWORD)m[0] << 8) + m[1];
262: }
263:
264: UBYTE bogomem_bget(CPTR addr)
265: {
266: addr -= bogomem_start & bogomem_mask;
267: addr &= bogomem_size-1;
268: return bogomemory[addr];
269: }
270:
271: void bogomem_lput(CPTR addr, ULONG l)
272: {
273: UBYTE *m;
274: addr -= bogomem_start & bogomem_mask;
275: addr &= bogomem_size-1;
276: m = bogomemory + addr;
277: m[0] = l >> 24;
278: m[1] = l >> 16;
279: m[2] = l >> 8;
280: m[3] = l;
281: }
282:
283: void bogomem_wput(CPTR addr, UWORD w)
284: {
285: UBYTE *m;
286: addr -= bogomem_start & bogomem_mask;
287: addr &= bogomem_size-1;
288: m = bogomemory + addr;
289: m[0] = w >> 8;
290: m[1] = w;
291: }
292:
293: void bogomem_bput(CPTR addr, UBYTE b)
294: {
295: addr -= bogomem_start & bogomem_mask;
296: addr &= bogomem_size-1;
297: bogomemory[addr] = b;
298: }
299:
300: int bogomem_check(CPTR addr, ULONG size)
301: {
302: addr -= bogomem_start & (bogomem_size-1);
303: addr &= bogomem_size-1;
304: return (addr + size) < bogomem_size;
305: }
306:
307: UBYTE *bogomem_xlate(CPTR addr)
308: {
309: addr -= bogomem_start & (bogomem_size-1);
310: addr &= bogomem_size-1;
311: return bogomemory + addr;
312: }
313:
314: /* Kick memory */
315:
316: static int zkickfile = 0;
317: UBYTE *kickmemory;
318:
319: static ULONG kickmem_alget(CPTR) REGPARAM;
320: static UWORD kickmem_awget(CPTR) REGPARAM;
321: static ULONG kickmem_lget(CPTR) REGPARAM;
322: static UWORD kickmem_wget(CPTR) REGPARAM;
323: static UBYTE kickmem_bget(CPTR) REGPARAM;
324: static void kickmem_lput(CPTR, ULONG) REGPARAM;
325: static void kickmem_wput(CPTR, UWORD) REGPARAM;
326: static void kickmem_bput(CPTR, UBYTE) REGPARAM;
327: static int kickmem_check(CPTR addr, ULONG size) REGPARAM;
328: static UBYTE *kickmem_xlate(CPTR addr) REGPARAM;
329:
330: ULONG kickmem_alget(CPTR addr)
331: {
332: UBYTE *m;
333: addr -= kickmem_start & kickmem_mask;
334: addr &= kickmem_size-1;
335: m = kickmemory + addr;
336: return (((ULONG)m[0] << 24) + ((ULONG)m[1] << 16)
337: + ((ULONG)m[2] << 8) + ((ULONG)m[3]));
338: }
339:
340: UWORD kickmem_awget(CPTR addr)
341: {
342: UBYTE *m;
343: addr -= kickmem_start & kickmem_mask;
344: addr &= kickmem_size-1;
345: m = kickmemory + addr;
346: return ((UWORD)m[0] << 8) + m[1];
347: }
348:
349: ULONG kickmem_lget(CPTR addr)
350: {
351: UBYTE *m;
352: addr -= kickmem_start & kickmem_mask;
353: addr &= kickmem_size-1;
354: m = kickmemory + addr;
355: return (((ULONG)m[0] << 24) + ((ULONG)m[1] << 16)
356: + ((ULONG)m[2] << 8) + ((ULONG)m[3]));
357: }
358:
359: UWORD kickmem_wget(CPTR addr)
360: {
361: UBYTE *m;
362: addr -= kickmem_start & kickmem_mask;
363: addr &= kickmem_size-1;
364: m = kickmemory + addr;
365: return ((UWORD)m[0] << 8) + m[1];
366: }
367:
368: UBYTE kickmem_bget(CPTR addr)
369: {
370: addr -= kickmem_start & kickmem_mask;
371: addr &= kickmem_size-1;
372: return kickmemory[addr];
373: }
374:
375: void kickmem_lput(CPTR addr, ULONG b)
376: {
377: if (illegal_mem) printf("Illegal kickmem lput at %08lx pc=%08lx\n",addr,m68k_getpc());
378: }
379:
380: void kickmem_wput(CPTR addr, UWORD b)
381: {
382: if (illegal_mem) printf("Illegal kickmem wput at %08lx pc=%08lx\n",addr,m68k_getpc());
383: }
384:
385: void kickmem_bput(CPTR addr, UBYTE b)
386: {
387: if (illegal_mem) printf("Illegal kickmem lput at %08lx pc=%08lx\n",addr,m68k_getpc());
388: }
389:
390: int kickmem_check(CPTR addr, ULONG size)
391: {
392: addr -= kickmem_start & (kickmem_size-1);
393: addr &= kickmem_size-1;
394: return (addr + size) < kickmem_size;
395: }
396:
397: UBYTE *kickmem_xlate(CPTR addr)
398: {
399: addr -= kickmem_start & (kickmem_size-1);
400: addr &= kickmem_size-1;
401: return kickmemory + addr;
402: }
403:
404: static int load_kickstart(void)
405: {
406: int i;
407: ULONG cksum = 0, prevck = 0;
408: unsigned char buffer[8];
409:
410: FILE *f = zfile_open(romfile, "rb");
411:
412: if (f == NULL) {
413: fprintf(stderr, "No Kickstart ROM found.\n");
414: return 0;
415: }
416:
417: fread(buffer, 1, 8, f);
418: if (buffer[4] == 0 && buffer[5] == 8 && buffer[6] == 0 && buffer[7] == 0) {
419: fprintf(stderr, "You seem to have a ZKick file there... You probably lose.\n");
420: zkickfile = 1;
421: } else
422: fseek(f, 0, SEEK_SET);
423:
424: i = fread(kickmemory, 1, kickmem_size, f);
425: if (i == kickmem_size/2) {
426: fprintf(stderr, "Warning: Kickstart is only 256K.\n");
427: memcpy (kickmemory + kickmem_size/2, kickmemory, kickmem_size/2);
428: } else if (i != kickmem_size) {
429: fprintf(stderr, "Error while reading Kickstart.\n");
430: return 0;
431: }
432: zfile_close (f);
433:
434: for (i = 0; i < kickmem_size; i+=4) {
435: ULONG data = kickmemory[i]*65536*256 + kickmemory[i+1]*65536 + kickmemory[i+2]*256 + kickmemory[i+3];
436: cksum += data;
437: if (cksum < prevck)
438: cksum++;
439: prevck = cksum;
440: }
441: if (cksum != 0xFFFFFFFF) {
442: fprintf(stderr, "Warning: Kickstart checksum incorrect. You probably have a corrupted ROM image.\n");
443: }
444: return 1;
445: }
446:
447: /* Address banks */
448:
449: addrbank dummy_bank = {
450: default_alget, default_awget,
451: dummy_lget, dummy_wget, dummy_bget,
452: dummy_lput, dummy_wput, dummy_bput,
453: default_xlate, dummy_check
454: };
455:
456: addrbank chipmem_bank = {
457: chipmem_alget, chipmem_awget,
458: chipmem_lget, chipmem_wget, chipmem_bget,
459: chipmem_lput, chipmem_wput, chipmem_bput,
460: chipmem_xlate, chipmem_check
461: };
462:
463: addrbank bogomem_bank = {
464: bogomem_alget, bogomem_awget,
465: bogomem_lget, bogomem_wget, bogomem_bget,
466: bogomem_lput, bogomem_wput, bogomem_bput,
467: bogomem_xlate, bogomem_check
468: };
469:
470: addrbank kickmem_bank = {
471: kickmem_alget, kickmem_awget,
472: kickmem_lget, kickmem_wget, kickmem_bget,
473: kickmem_lput, kickmem_wput, kickmem_bput,
474: kickmem_xlate, kickmem_check
475: };
476:
477: char *address_space, *good_address_map;
478: int good_address_fd;
479:
480: void memory_init(void)
481: {
482: char buffer[4096];
483: char *nam;
484: int i, fd;
485: buserr = 0;
486:
487: chipmem_mask = chipmem_size - 1;
488: kickmem_mask = kickmem_size - 1;
489: bogomem_mask = bogomem_size - 1;
490:
491: #ifdef USE_COMPILER
492: fd = open("/dev/zero", O_RDWR);
493: good_address_map = mmap(NULL, 1 << 24, PROT_READ, MAP_PRIVATE, fd, 0);
494: address_space = mmap(NULL, 1 << 24, PROT_READ, MAP_PRIVATE, fd, 0);
495: chipmemory = mmap(address_space, 0x200000, PROT_READ|PROT_WRITE, MAP_PRIVATE | MAP_FIXED, fd, 0);
496: kickmemory = mmap(address_space + 0xF80000, 0x80000, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, fd, 0);
497:
498: close(fd);
499:
500: good_address_fd = open(nam = tmpnam(NULL), O_CREAT|O_RDWR, 0600);
501: memset(buffer,1,sizeof(buffer));
502: write(good_address_fd, buffer,sizeof(buffer));
503: unlink(nam);
504:
505: for (i = 0; i < chipmem_size; i += 4096)
506: mmap(good_address_map + i, 4096, PROT_READ, MAP_FIXED | MAP_PRIVATE,
507: good_address_fd, 0);
508: for (i = 0; i < kickmem_size; i += 4096)
509: mmap(good_address_map + i + 0x1000000 - kickmem_size, 4096, PROT_READ,
510: MAP_FIXED | MAP_PRIVATE, good_address_fd, 0);
511: #else
512: chipmemory = (UBYTE *)malloc(chipmem_size);
513: kickmemory = (UBYTE *)malloc(kickmem_size);
514: #endif
515:
516: for(i = 0; i < 65536; i++)
517: membanks[i] = dummy_bank;
518:
519: /* Map the chipmem into all of the lower 16MB */
520: map_banks(&chipmem_bank, 0x00, 256);
521: map_banks(&custom_bank, 0xC0, 0x20);
522: map_banks(&cia_bank, 0xA0, 32);
523: map_banks(&clock_bank, 0xDC, 1);
524:
525: if (bogomem_size > 0) {
526: bogomemory = (UBYTE *)malloc(bogomem_size);
527: map_banks(&bogomem_bank, 0xC0, bogomem_size >> 16);
528: }
529:
530: map_banks(&rtarea_bank, 0xF0, 1);
531: if (!load_kickstart()) {
532: init_ersatz_rom(kickmemory);
533: ersatzkickfile = 1;
534: }
535: if (zkickfile)
536: map_banks(&kickmem_bank, 0x20, 8);
537:
538: map_banks(&kickmem_bank, 0xF8, 8);
539: if (!zkickfile)
540: map_banks(&expamem_bank, 0xE8, 1);
541: }
542:
543: void map_banks(addrbank *bank, int start, int size)
544: {
545: int bnr;
546: int hioffs = 0;
547: #if 0 && CPU_LEVEL < 2
548: for (hioffs = 0; hioffs < 256; hioffs++)
549: #endif
550: for (bnr = start; bnr < start+size; bnr++)
551: membanks[bnr + hioffs * 256] = *bank;
552: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.