ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/rom_patches.cpp
(Generate patch)

Comparing BasiliskII/src/rom_patches.cpp (file contents):
Revision 1.1 by cebix, 1999-10-03T14:16:25Z vs.
Revision 1.13 by cebix, 2000-04-10T18:52:26Z

# Line 1 | Line 1
1   /*
2   *  rom_patches.cpp - ROM patches
3   *
4 < *  Basilisk II (C) 1997-1999 Christian Bauer
4 > *  Basilisk II (C) 1997-2000 Christian Bauer
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 30 | Line 30
30   #include "disk.h"
31   #include "cdrom.h"
32   #include "video.h"
33 + #include "extfs.h"
34   #include "prefs.h"
35   #include "rom_patches.h"
36  
# Line 37 | Line 38
38   #include "debug.h"
39  
40  
40 // Breakpoint
41 //#define M68K_BREAKPOINT 0x2310        // CritError
42 //#define M68K_BREAKPOINT 0x1d10        // BootMe
43
41   // Global variables
42 < uint32 UniversalInfo;   // ROM offset of UniversalInfo
43 < uint32 PutScrapPatch;   // Mac address of PutScrap() patch
44 <
45 < static uint32 sony_offset;              // ROM offset of .Sony driver
46 < static uint32 serd_offset;              // ROM offset of SERD resource (serial drivers)
47 < static uint32 microseconds_offset;      // ROM offset of Microseconds() replacement routine
48 < static uint32 memory_dispatch_offset;   // ROM offset of MemoryDispatch() replacement routine
42 > uint32 UniversalInfo;           // ROM offset of UniversalInfo
43 > uint32 PutScrapPatch;           // Mac address of PutScrap() patch
44 > uint32 ROMBreakpoint = 0;       // ROM offset of breakpoint (0 = disabled, 0x2310 = CritError)
45 > bool PrintROMInfo = false;      // Flag: print ROM information in PatchROM()
46 >
47 > static uint32 sony_offset;                              // ROM offset of .Sony driver
48 > static uint32 serd_offset;                              // ROM offset of SERD resource (serial drivers)
49 > static uint32 microseconds_offset;              // ROM offset of Microseconds() replacement routine
50  
51   // Prototypes
52   uint16 ROMVersion;
# Line 83 | Line 81 | static uint32 find_rom_resource(uint32 s
81  
82          if (!cont)
83                  rsrc_ptr = x;
84 +        else
85 +                rsrc_ptr = ReadMacInt32(ROMBaseMac + rsrc_ptr + 8);
86  
87          for (;;) {
88                  lp = ROMBaseMac + rsrc_ptr;
# Line 141 | Line 141 | again:
141  
142  
143   /*
144 + *  Print ROM information to stream,
145 + */
146 +
147 + static void list_rom_resources(void)
148 + {
149 +        printf("ROM Resources:\n");
150 +        printf("Offset\t Type\tID\tSize\tName\n");
151 +        printf("------------------------------------------------\n");
152 +
153 +        uint32 lp = ROMBaseMac + ReadMacInt32(ROMBaseMac + 0x1a);
154 +        uint32 rsrc_ptr = ReadMacInt32(lp);
155 +
156 +        for (;;) {
157 +                lp = ROMBaseMac + rsrc_ptr;
158 +                uint32 data = ReadMacInt32(lp + 12);
159 +
160 +                char name[32];
161 +                int name_len = ReadMacInt8(lp + 23), i;
162 +                for (i=0; i<name_len; i++)
163 +                        name[i] = ReadMacInt8(lp + 24 + i);
164 +                name[i] = 0;
165 +
166 +                printf("%08x %c%c%c%c\t%d\t%d\t%s\n", data, ReadMacInt8(lp + 16), ReadMacInt8(lp + 17), ReadMacInt8(lp + 18), ReadMacInt8(lp + 19), ReadMacInt16(lp + 20), ReadMacInt32(ROMBaseMac + data - 8), name);
167 +
168 +                rsrc_ptr = ReadMacInt32(lp + 8);
169 +                if (!rsrc_ptr)
170 +                        break;
171 +        }
172 +        printf("\n");
173 + }
174 +
175 + // Mapping of Model IDs to Model names
176 + struct mac_desc {
177 +        char *name;
178 +        int32 id;
179 + };
180 +
181 + static mac_desc MacDesc[] = {
182 +        {"Classic"                              , 1},
183 +        {"Mac XL"                               , 2},
184 +        {"Mac 512KE"                    , 3},
185 +        {"Mac Plus"                             , 4},
186 +        {"Mac SE"                               , 5},
187 +        {"Mac II"                               , 6},
188 +        {"Mac IIx"                              , 7},
189 +        {"Mac IIcx"                             , 8},
190 +        {"Mac SE/030"                   , 9},
191 +        {"Mac Portable"                 , 10},
192 +        {"Mac IIci"                             , 11},
193 +        {"Mac IIfx"                             , 13},
194 +        {"Mac Classic"                  , 17},
195 +        {"Mac IIsi"                             , 18},
196 +        {"Mac LC"                               , 19},
197 +        {"Quadra 900"                   , 20},
198 +        {"PowerBook 170"                , 21},
199 +        {"Quadra 700"                   , 22},
200 +        {"Classic II"                   , 23},
201 +        {"PowerBook 100"                , 24},
202 +        {"PowerBook 140"                , 25},
203 +        {"Quadra 950"                   , 26},
204 +        {"Mac LCIII/Performa 450", 27},
205 +        {"PowerBook Duo 210"    , 29},
206 +        {"Centris 650"                  , 30},
207 +        {"PowerBook Duo 230"    , 32},
208 +        {"PowerBook 180"                , 33},
209 +        {"PowerBook 160"                , 34},
210 +        {"Quadra 800"                   , 35},
211 +        {"Quadra 650"                   , 36},
212 +        {"Mac LCII"                             , 37},
213 +        {"PowerBook Duo 250"    , 38},
214 +        {"Mac IIvi"                             , 44},
215 +        {"Mac IIvm/Performa 600", 45},
216 +        {"Mac IIvx"                             , 48},
217 +        {"Color Classic/Performa 250", 49},
218 +        {"PowerBook 165c"               , 50},
219 +        {"Centris 610"                  , 52},
220 +        {"Quadra 610"                   , 53},
221 +        {"PowerBook 145"                , 54},
222 +        {"Mac LC520"                    , 56},
223 +        {"Quadra/Centris 660AV" , 60},
224 +        {"Performa 46x"                 , 62},
225 +        {"PowerBook 180c"               , 71},
226 +        {"PowerBook 520/520c/540/540c", 72},
227 +        {"PowerBook Duo 270c"   , 77},
228 +        {"Quadra 840AV"                 , 78},
229 +        {"Performa 550"                 , 80},
230 +        {"PowerBook 165"                , 84},
231 +        {"PowerBook 190"                , 85},
232 +        {"Mac TV"                               , 88},
233 +        {"Mac LC475/Performa 47x", 89},
234 +        {"Mac LC575"                    , 92},
235 +        {"Quadra 605"                   , 94},
236 +        {"Quadra 630"                   , 98},
237 +        {"Mac LC580"                    , 99},
238 +        {"PowerBook Duo 280"    , 102},
239 +        {"PowerBook Duo 280c"   , 103},
240 +        {"PowerBook 150"                , 115},
241 +        {"unknown", -1}
242 + };
243 +
244 + static void print_universal_info(uint32 info)
245 + {
246 +        uint8 id = ReadMacInt8(info + 18);
247 +        uint16 hwcfg = ReadMacInt16(info + 16);
248 +        uint16 rom85 = ReadMacInt16(info + 20);
249 +
250 +        // Find model name
251 +        char *name = "unknown";
252 +        for (int i=0; MacDesc[i].id >= 0; i++)
253 +                if (MacDesc[i].id == id + 6) {
254 +                        name = MacDesc[i].name;
255 +                        break;
256 +                }
257 +
258 +        printf("%08x %02x\t%04x\t%04x\t%s\n", info - ROMBaseMac, id, hwcfg, rom85, name);
259 + }
260 +
261 + static void list_universal_infos(void)
262 + {
263 +        uint32 ofs = 0x3000;
264 +        for (int i=0; i<0x2000; i+=2, ofs+=2)
265 +                if (ReadMacInt32(ROMBaseMac + ofs) == 0xdc000505) {
266 +                        ofs -= 16;
267 +                        uint32 q;
268 +                        for (q=ofs; q > 0 && ReadMacInt32(ROMBaseMac + q) != ofs - q; q-=4) ;
269 +                        if (q > 0) {
270 +                                printf("Universal Table at %08x:\n", q);
271 +                                printf("Offset\t ID\tHWCfg\tROM85\tModel\n");
272 +                                printf("------------------------------------------------\n");
273 +                                while (ofs = ReadMacInt32(ROMBaseMac + q)) {
274 +                                        print_universal_info(ROMBaseMac + ofs + q);
275 +                                        q += 4;
276 +                                }
277 +                        }
278 +                        break;
279 +                }
280 +        printf("\n");
281 + }
282 +
283 + static void print_rom_info(void)
284 + {
285 +        printf("\nROM Info:\n");
286 +        printf("Checksum    : %08x\n", ReadMacInt32(ROMBaseMac));
287 +        printf("Version     : %04x\n", ROMVersion);
288 +        printf("Sub Version : %04x\n", ReadMacInt16(ROMBaseMac + 18));
289 +        printf("Resource Map: %08x\n", ReadMacInt32(ROMBaseMac + 26));
290 +        printf("Trap Tables : %08x\n\n", ReadMacInt32(ROMBaseMac + 34));
291 +        if (ROMVersion == ROM_VERSION_32) {
292 +                list_rom_resources();
293 +                list_universal_infos();
294 +        }
295 + }
296 +
297 +
298 + /*
299   *  Driver stubs
300   */
301  
302   static const uint8 sony_driver[] = {    // Replacement for .Sony driver
303          // Driver header
304 <        SonyDriverFlags >> 8, SonyDriverFlags & 0xff, SonyDriverDelay >> 8, SonyDriverDelay & 0xff, 0x00, 0x00, 0x00, 0x00,
304 >        SonyDriverFlags >> 8, SonyDriverFlags & 0xff, 0, 0, 0, 0, 0, 0,
305          0x00, 0x18,                                                     // Open() offset
306          0x00, 0x1c,                                                     // Prime() offset
307          0x00, 0x20,                                                     // Control() offset
# Line 194 | Line 349 | static const uint8 sony_driver[] = {   //
349  
350   static const uint8 disk_driver[] = {    // Generic disk driver
351          // Driver header
352 <        DiskDriverFlags >> 8, DiskDriverFlags & 0xff, DiskDriverDelay >> 8, DiskDriverDelay & 0xff, 0x00, 0x00, 0x00, 0x00,
352 >        DiskDriverFlags >> 8, DiskDriverFlags & 0xff, 0, 0, 0, 0, 0, 0,
353          0x00, 0x18,                                                     // Open() offset
354          0x00, 0x1c,                                                     // Prime() offset
355          0x00, 0x20,                                                     // Control() offset
# Line 242 | Line 397 | static const uint8 disk_driver[] = {   //
397  
398   static const uint8 cdrom_driver[] = {   // CD-ROM driver
399          // Driver header
400 <        CDROMDriverFlags >> 8, CDROMDriverFlags & 0xff, CDROMDriverDelay >> 8, CDROMDriverDelay & 0xff, 0x00, 0x00, 0x00, 0x00,
400 >        CDROMDriverFlags >> 8, CDROMDriverFlags & 0xff, 0, 0, 0, 0, 0, 0,
401          0x00, 0x1c,                                                     // Open() offset
402          0x00, 0x20,                                                     // Prime() offset
403          0x00, 0x24,                                                     // Control() offset
# Line 555 | Line 710 | void InstallDrivers(uint32 pb)
710          uint32 dce = ReadMacInt32(r.a[0]);
711          WriteMacInt32(dce + dCtlDriver, ROMBaseMac + sony_offset + 0x100);
712          WriteMacInt16(dce + dCtlFlags, DiskDriverFlags);
558        WriteMacInt16(dce + dCtlDelay, DiskDriverDelay);
713  
714          // Open disk driver
715          WriteMacInt32(pb + ioNamePtr, ROMBaseMac + sony_offset + 0x112);
# Line 574 | Line 728 | void InstallDrivers(uint32 pb)
728                  dce = ReadMacInt32(r.a[0]);
729                  WriteMacInt32(dce + dCtlDriver, ROMBaseMac + sony_offset + 0x200);
730                  WriteMacInt16(dce + dCtlFlags, CDROMDriverFlags);
577                WriteMacInt16(dce + dCtlDelay, CDROMDriverDelay);
731  
732                  // Open CD-ROM driver
733                  WriteMacInt32(pb + ioNamePtr, ROMBaseMac + sony_offset + 0x212);
# Line 643 | Line 796 | void InstallSERD(void)
796  
797   void PatchAfterStartup(void)
798   {
799 <        // Install MemoryDispatch() replacement routine
800 <        M68kRegisters r;
801 <        r.a[0] = ROMBaseMac + memory_dispatch_offset;
802 <        r.d[0] = 0xa05c;
650 <        Execute68kTrap(0xa247, &r);             // SetOSTrapAddress()
799 > #if SUPPORTS_EXTFS
800 >        // Install external file system
801 >        InstallExtFS();
802 > #endif
803   }
804  
805  
# Line 664 | Line 816 | bool CheckROM(void)
816          // Real addressing mode requires a 32-bit clean ROM
817          return ROMVersion == ROM_VERSION_32;
818   #else
819 <        // Virtual addressing mode works with 32-bit clean Mac II ROMs and Classic ROMs (experimental)
819 >        // Virtual addressing mode works with 32-bit clean Mac II ROMs and Classic ROMs
820          return (ROMVersion == ROM_VERSION_CLASSIC) || (ROMVersion == ROM_VERSION_32);
821   #endif
822   }
# Line 1153 | Line 1305 | static bool patch_rom_32(void)
1305          *wp++ = htons(M68K_NOP);
1306          *wp = htons(M68K_NOP);
1307  
1308 <        // Fix logical/physical RAM size (CompBootStack) (must be done after InitMemMgr!)
1309 <        static const uint8 fix_memsize_dat[] = {0x4e, 0x75};
1310 <        if ((base = find_rom_data(0x490, 0x4b0, fix_memsize_dat, sizeof(fix_memsize_dat))) == 0) return false;
1311 <        D(bug("fix_memsize %08lx\n", base));
1312 <        wp = (uint16 *)(ROMBaseHost + base);
1308 >        // Compute boot stack pointer and fix logical/physical RAM size (CompBootStack) (must be done after InitMemMgr!)
1309 >        wp = (uint16 *)(ROMBaseHost + 0x490);
1310 >        *wp++ = htons(0x2038);  // move.l       $10c,d0
1311 >        *wp++ = htons(0x010c);
1312 >        *wp++ = htons(0xd0b8);  // add.l        $2a6,d0
1313 >        *wp++ = htons(0x02a6);
1314 >        *wp++ = htons(0xe288);  // lsr.l        #1,d0
1315 >        *wp++ = htons(0x0880);  // bclr         #0,d0
1316 >        *wp++ = htons(0x0000);
1317 >        *wp++ = htons(0x0440);  // subi.w       #$400,d0
1318 >        *wp++ = htons(0x0400);
1319 >        *wp++ = htons(0x2040);  // move.l       d0,a0
1320          *wp++ = htons(M68K_EMUL_OP_FIX_MEMSIZE);
1321 <        *wp = htons(M68K_RTS);
1321 >        *wp++ = htons(M68K_RTS);
1322  
1323          static const uint8 fix_memsize2_dat[] = {0x22, 0x30, 0x81, 0xe2, 0x0d, 0xdc, 0xff, 0xba, 0xd2, 0xb0, 0x81, 0xe2, 0x0d, 0xdc, 0xff, 0xec, 0x21, 0xc1, 0x1e, 0xf8};
1324          base = find_rom_data(0x4c000, 0x4c080, fix_memsize2_dat, sizeof(fix_memsize2_dat));
# Line 1292 | Line 1451 | static bool patch_rom_32(void)
1451                  }
1452          }
1453  
1454 +        // Don't set MemoryDispatch() to unimplemented trap
1455 +        static const uint8 memdisp_dat[] = {0x30, 0x3c, 0xa8, 0x9f, 0xa7, 0x46, 0x30, 0x3c, 0xa0, 0x5c, 0xa2, 0x47};
1456 +        base = find_rom_data(0x4f100, 0x4f180, memdisp_dat, sizeof(memdisp_dat));
1457 +        D(bug("memdisp %08lx\n", base));
1458 +        if (base) {     // ROM15/22/23/26/27/32
1459 +                wp = (uint16 *)(ROMBaseHost + base + 10);
1460 +                *wp = htons(M68K_NOP);
1461 +        }
1462 +
1463          // Patch .EDisk driver (don't scan for EDisks in the area ROMBase..0xe00000)
1464          uint32 edisk_offset = find_rom_resource('DRVR', 51);
1465          if (edisk_offset) {
# Line 1393 | Line 1561 | static bool patch_rom_32(void)
1561          *wp++ = htons(base >> 16);
1562          *wp = htons(base & 0xffff);
1563  
1564 <        // Install MemoryDispatch() replacement routine (activated in PatchAfterStartup())
1565 <        memory_dispatch_offset = sony_offset + 0xc20;
1566 <        wp = (uint16 *)(ROMBaseHost + memory_dispatch_offset);
1567 <        *wp++ = htons(M68K_EMUL_OP_MEMORY_DISPATCH);
1564 > #if EMULATED_68K
1565 >        // Replace BlockMove()
1566 >        wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa02e));   // BlockMove()
1567 >        *wp++ = htons(M68K_EMUL_OP_BLOCK_MOVE);
1568 >        *wp++ = htons(0x7000);
1569          *wp = htons(M68K_RTS);
1570 + #endif
1571 +
1572 +        // Look for double PACK 4 resources
1573 +        if ((base = find_rom_resource('PACK', 4)) == 0) return false;
1574 +        if ((base = find_rom_resource('PACK', 4, true)) == 0 && FPUType == 0)
1575 +                printf("WARNING: This ROM seems to require an FPU\n");
1576  
1577          // Patch VIA interrupt handler
1578          wp = (uint16 *)(ROMBaseHost + 0x9bc4);  // Level 1 handler
# Line 1416 | Line 1591 | static bool patch_rom_32(void)
1591  
1592   bool PatchROM(void)
1593   {
1594 <        // Print ROM info
1595 <        D(bug("ROM Info:\n"));
1596 <        D(bug("Checksum: %08lx\n", ReadMacInt32(ROMBaseMac)));
1422 <        D(bug("Version: %04x\n", ROMVersion));
1423 <        D(bug("Sub Version: %04x\n", ReadMacInt16(ROMBaseMac + 18)));
1594 >        // Print some information about the ROM
1595 >        if (PrintROMInfo)
1596 >                print_rom_info();
1597  
1598          // Patch ROM depending on version
1599          switch (ROMVersion) {
# Line 1436 | Line 1609 | bool PatchROM(void)
1609                          return false;
1610          }
1611  
1439 #ifdef M68K_BREAKPOINT
1612          // Install breakpoint
1613 <        uint16 *wp = (uint16 *)(ROMBaseHost + M68K_BREAKPOINT);
1614 <        *wp = htons(M68K_EMUL_BREAK);
1615 < #endif
1613 >        if (ROMBreakpoint) {
1614 >                uint16 *wp = (uint16 *)(ROMBaseHost + ROMBreakpoint);
1615 >                *wp = htons(M68K_EMUL_BREAK);
1616 >        }
1617  
1618          // Clear caches as we loaded and patched code
1619          FlushCodeCache(ROMBaseHost, ROMSize);

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines