Return to ersatz.c CVS log

Up to [UNIX Amiga Emulator] / uae

Annotation of uae/ersatz.c, revision 1.1

1.1     ! root        1:  /* 
        !             2:   * UAE - The Un*x Amiga Emulator
        !             3:   * 
        !             4:   * A "replacement" for a missing Kickstart
        !             5:   * Warning! Q&D
        !             6:   *
        !             7:   * (c) 1995 Bernd Schmidt
        !             8:   */
        !             9: 
        !            10: #include <stdio.h>
        !            11: #include <stdlib.h>
        !            12: 
        !            13: #include "config.h"
        !            14: #include "amiga.h"
        !            15: #include "options.h"
        !            16: #include "memory.h"
        !            17: #include "custom.h"
        !            18: #include "newcpu.h"
        !            19: #include "cia.h"
        !            20: #include "disk.h"
        !            21: #include "ersatz.h"
        !            22: 
        !            23: #define EOP_INIT     0
        !            24: #define EOP_NIMP     1
        !            25: #define EOP_SERVEINT 2
        !            26: #define EOP_DOIO     3
        !            27: #define EOP_OPENLIB  4
        !            28: #define EOP_AVAILMEM 5
        !            29: #define EOP_ALLOCMEM 6
        !            30: #define EOP_ALLOCABS 7
        !            31: 
        !            32: void init_ersatz_rom (UWORD *data)
        !            33: {
        !            34:     fprintf(stderr, "Trying to use Kickstart replacement.\n");
        !            35:     *data++ = 0x0008; /* initial SP */
        !            36:     *data++ = 0;
        !            37:     *data++ = 0x00F8; /* initial PC */
        !            38:     *data++ = 0x0008;
        !            39: 
        !            40:     *data++ = 0xF00D;
        !            41:     *data++ = EOP_INIT;
        !            42:     *data++ = 0xF00D;
        !            43:     *data++ = EOP_NIMP;
        !            44:     
        !            45:     *data++ = 0xF00D;
        !            46:     *data++ = EOP_DOIO;
        !            47:     *data++ = 0x4E75;
        !            48:     *data++ = 0xF00D;
        !            49:     
        !            50:     *data++ = EOP_SERVEINT;
        !            51:     *data++ = 0x4E73;
        !            52:     *data++ = 0xF00D;
        !            53:     *data++ = EOP_AVAILMEM;
        !            54:     
        !            55:     *data++ = 0x4E75;
        !            56:     *data++ = 0xF00D;
        !            57:     *data++ = EOP_ALLOCMEM;    
        !            58:     *data++ = 0x4E75;
        !            59: 
        !            60:     *data++ = 0xF00D;
        !            61:     *data++ = EOP_ALLOCABS;
        !            62:     *data++ = 0x4E75;
        !            63: }
        !            64: 
        !            65: static void ersatz_doio (void)
        !            66: {
        !            67:     CPTR request = regs.a[1];
        !            68:     switch (get_word (request + 0x1C)) {
        !            69:      case 9: /* TD_MOTOR is harmless */
        !            70:      case 2: case 0x8002: /* READ commands */
        !            71:        break;
        !            72:        
        !            73:      default:
        !            74:        fprintf(stderr, "Only CMD_READ supported in DoIO()\n");
        !            75:        abort();
        !            76:     }
        !            77:     {
        !            78:        CPTR dest = get_long (request + 0x28);
        !            79:        int start = get_long (request + 0x2C) / 512;
        !            80:        int nsecs = get_long (request + 0x24) / 512;
        !            81:        int tr = start / 11;
        !            82:        int sec = start % 11;
        !            83:        while (nsecs--) {
        !            84:            DISK_ersatz_read (tr, sec, dest);
        !            85:            dest += 512;
        !            86:            if (++sec == 11)
        !            87:                sec = 0, tr++;
        !            88:        }
        !            89:     }
        !            90: }
        !            91: 
        !            92: static void ersatz_init (void)
        !            93: {
        !            94:     int f;
        !            95:     CPTR request;
        !            96:     CPTR a;
        !            97:     
        !            98:     regs.s = 0;
        !            99:     /* Set some interrupt vectors */
        !           100:     for (a = 8; a < 0xC0; a += 4) {
        !           101:        put_long (a, 0xF80016);
        !           102:     }
        !           103:     regs.usp = 0x80000;
        !           104:     regs.a[7] = 0x7F000;
        !           105:     regs.intmask = 0;
        !           106:     
        !           107:     /* Build a dummy execbase */
        !           108:     put_long (4, regs.a[6] = 0x676);
        !           109:     put_byte (0x676 + 0x129, 0);    
        !           110:     for (f = 1; f < 105; f++) {        
        !           111:        put_word (0x676 - 6*f, 0x4EF9);
        !           112:        put_long (0x676 - 6*f + 2, 0xF8000C);
        !           113:     }
        !           114:     /* Some "supported" functions */
        !           115:     put_long (0x676 - 456 + 2, 0xF80010);
        !           116:     put_long (0x676 - 216 + 2, 0xF8001C);
        !           117:     put_long (0x676 - 198 + 2, 0xF80022);
        !           118:     put_long (0x676 - 204 + 2, 0xF80028);
        !           119:     put_long (0x676 - 210 + 2, 0xF80026);
        !           120:     
        !           121:     /* Build an IORequest */
        !           122:     request = 0x800;
        !           123:     put_word (request + 0x1C, 2);
        !           124:     put_long (request + 0x28, 0x4000);
        !           125:     put_long (request + 0x2C, 0);
        !           126:     put_long (request + 0x24, 0x200 * 4);
        !           127:     regs.a[1] = request;
        !           128:     ersatz_doio ();
        !           129:     m68k_setpc (0x400C);
        !           130: 
        !           131:     /* Init the hardware */
        !           132:     put_long (0x3000, 0xFFFFFFFE);
        !           133:     put_long (0xDFF080, 0x3000);
        !           134:     put_word (0xDFF088, 0);
        !           135:     put_word (0xDFF096, 0xE390);
        !           136:     put_word (0xDFF09A, 0xE02C);
        !           137:     put_word (0xDFF092, 0x0038);
        !           138:     put_word (0xDFF094, 0x00D0);
        !           139:     put_word (0xDFF08E, 0x2C81);
        !           140:     put_word (0xDFF090, 0xF4C1);
        !           141: }
        !           142: 
        !           143: void ersatz_perform (UWORD what)
        !           144: {
        !           145:     switch (what) {
        !           146:      case EOP_INIT:
        !           147:        ersatz_init ();
        !           148:        break;
        !           149:        
        !           150:      case EOP_SERVEINT:
        !           151:        /* Just reset all the interrupt request bits */
        !           152:        put_word (0xDFF09C, get_word (0xDFF01E) & 0x3FFF);
        !           153:        break;
        !           154:        
        !           155:      case EOP_DOIO:
        !           156:        ersatz_doio ();
        !           157:        break;
        !           158:        
        !           159:      case EOP_AVAILMEM:
        !           160:        regs.d[0] = regs.d[1] & 4 ? 0 : 0x70000;
        !           161:        break;
        !           162:        
        !           163:      case EOP_ALLOCMEM:
        !           164:        regs.d[0] = regs.d[1] & 4 ? 0 : 0x0F000;
        !           165:        break;
        !           166: 
        !           167:      case EOP_ALLOCABS:
        !           168:        regs.d[0] = regs.a[1];
        !           169:        break;
        !           170: 
        !           171:      case EOP_NIMP:
        !           172:        fprintf(stderr, "Unimplemented Kickstart function called\n");
        !           173:        abort ();
        !           174:      case EOP_OPENLIB: 
        !           175:      default:
        !           176:        fprintf(stderr, "Internal error. Giving up.\n");
        !           177:        abort ();
        !           178:     }
        !           179: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.