Mercurial > repos > blastem
comparison romdb.c @ 767:ea525f600b1d
SRAM detection from ROM header is no working correctly again
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Mon, 06 Jul 2015 19:46:46 -0700 |
parents | 1b2f8280ba81 |
children | 2f48a3c187c6 |
comparison
equal
deleted
inserted
replaced
766:1b2f8280ba81 | 767:ea525f600b1d |
---|---|
18 | 18 |
19 uint16_t read_sram_w(uint32_t address, m68k_context * context) | 19 uint16_t read_sram_w(uint32_t address, m68k_context * context) |
20 { | 20 { |
21 genesis_context * gen = context->system; | 21 genesis_context * gen = context->system; |
22 address &= gen->save_ram_mask; | 22 address &= gen->save_ram_mask; |
23 switch(gen->save_flags) | 23 switch(gen->save_type) |
24 { | 24 { |
25 case RAM_FLAG_BOTH: | 25 case RAM_FLAG_BOTH: |
26 return gen->save_ram[address] << 8 | gen->save_ram[address+1]; | 26 return gen->save_storage[address] << 8 | gen->save_storage[address+1]; |
27 case RAM_FLAG_EVEN: | 27 case RAM_FLAG_EVEN: |
28 return gen->save_ram[address >> 1] << 8 | 0xFF; | 28 return gen->save_storage[address >> 1] << 8 | 0xFF; |
29 case RAM_FLAG_ODD: | 29 case RAM_FLAG_ODD: |
30 return gen->save_ram[address >> 1] | 0xFF00; | 30 return gen->save_storage[address >> 1] | 0xFF00; |
31 } | 31 } |
32 return 0xFFFF;//We should never get here | 32 return 0xFFFF;//We should never get here |
33 } | 33 } |
34 | 34 |
35 uint8_t read_sram_b(uint32_t address, m68k_context * context) | 35 uint8_t read_sram_b(uint32_t address, m68k_context * context) |
36 { | 36 { |
37 genesis_context * gen = context->system; | 37 genesis_context * gen = context->system; |
38 address &= gen->save_ram_mask; | 38 address &= gen->save_ram_mask; |
39 switch(gen->save_flags) | 39 switch(gen->save_type) |
40 { | 40 { |
41 case RAM_FLAG_BOTH: | 41 case RAM_FLAG_BOTH: |
42 return gen->save_ram[address]; | 42 return gen->save_storage[address]; |
43 case RAM_FLAG_EVEN: | 43 case RAM_FLAG_EVEN: |
44 if (address & 1) { | 44 if (address & 1) { |
45 return 0xFF; | 45 return 0xFF; |
46 } else { | 46 } else { |
47 return gen->save_ram[address >> 1]; | 47 return gen->save_storage[address >> 1]; |
48 } | 48 } |
49 case RAM_FLAG_ODD: | 49 case RAM_FLAG_ODD: |
50 if (address & 1) { | 50 if (address & 1) { |
51 return gen->save_ram[address >> 1]; | 51 return gen->save_storage[address >> 1]; |
52 } else { | 52 } else { |
53 return 0xFF; | 53 return 0xFF; |
54 } | 54 } |
55 } | 55 } |
56 return 0xFF;//We should never get here | 56 return 0xFF;//We should never get here |
59 m68k_context * write_sram_area_w(uint32_t address, m68k_context * context, uint16_t value) | 59 m68k_context * write_sram_area_w(uint32_t address, m68k_context * context, uint16_t value) |
60 { | 60 { |
61 genesis_context * gen = context->system; | 61 genesis_context * gen = context->system; |
62 if ((gen->bank_regs[0] & 0x3) == 1) { | 62 if ((gen->bank_regs[0] & 0x3) == 1) { |
63 address &= gen->save_ram_mask; | 63 address &= gen->save_ram_mask; |
64 switch(gen->save_flags) | 64 switch(gen->save_type) |
65 { | 65 { |
66 case RAM_FLAG_BOTH: | 66 case RAM_FLAG_BOTH: |
67 gen->save_ram[address] = value >> 8; | 67 gen->save_storage[address] = value >> 8; |
68 gen->save_ram[address+1] = value; | 68 gen->save_storage[address+1] = value; |
69 break; | 69 break; |
70 case RAM_FLAG_EVEN: | 70 case RAM_FLAG_EVEN: |
71 gen->save_ram[address >> 1] = value >> 8; | 71 gen->save_storage[address >> 1] = value >> 8; |
72 break; | 72 break; |
73 case RAM_FLAG_ODD: | 73 case RAM_FLAG_ODD: |
74 gen->save_ram[address >> 1] = value; | 74 gen->save_storage[address >> 1] = value; |
75 break; | 75 break; |
76 } | 76 } |
77 } | 77 } |
78 return context; | 78 return context; |
79 } | 79 } |
81 m68k_context * write_sram_area_b(uint32_t address, m68k_context * context, uint8_t value) | 81 m68k_context * write_sram_area_b(uint32_t address, m68k_context * context, uint8_t value) |
82 { | 82 { |
83 genesis_context * gen = context->system; | 83 genesis_context * gen = context->system; |
84 if ((gen->bank_regs[0] & 0x3) == 1) { | 84 if ((gen->bank_regs[0] & 0x3) == 1) { |
85 address &= gen->save_ram_mask; | 85 address &= gen->save_ram_mask; |
86 switch(gen->save_flags) | 86 switch(gen->save_type) |
87 { | 87 { |
88 case RAM_FLAG_BOTH: | 88 case RAM_FLAG_BOTH: |
89 gen->save_ram[address] = value; | 89 gen->save_storage[address] = value; |
90 break; | 90 break; |
91 case RAM_FLAG_EVEN: | 91 case RAM_FLAG_EVEN: |
92 if (!(address & 1)) { | 92 if (!(address & 1)) { |
93 gen->save_ram[address >> 1] = value; | 93 gen->save_storage[address >> 1] = value; |
94 } | 94 } |
95 break; | 95 break; |
96 case RAM_FLAG_ODD: | 96 case RAM_FLAG_ODD: |
97 if (address & 1) { | 97 if (address & 1) { |
98 gen->save_ram[address >> 1] = value; | 98 gen->save_storage[address >> 1] = value; |
99 } | 99 } |
100 break; | 100 break; |
101 } | 101 } |
102 } | 102 } |
103 return context; | 103 return context; |
216 uint32_t ram_start = get_u32be(rom + RAM_START); | 216 uint32_t ram_start = get_u32be(rom + RAM_START); |
217 uint32_t ram_end = get_u32be(rom + RAM_END); | 217 uint32_t ram_end = get_u32be(rom + RAM_END); |
218 uint32_t ram_flags = info->save_type = rom[RAM_FLAGS] & RAM_FLAG_MASK; | 218 uint32_t ram_flags = info->save_type = rom[RAM_FLAGS] & RAM_FLAG_MASK; |
219 ram_start &= 0xFFFFFE; | 219 ram_start &= 0xFFFFFE; |
220 ram_end |= 1; | 220 ram_end |= 1; |
221 info->save_mask = ram_end - ram_start; | |
222 uint32_t size = info->save_mask + 1; | |
223 if (ram_flags != RAM_FLAG_BOTH) { | |
224 size /= 2; | |
225 } | |
226 info->save_size = size; | |
227 info->save_buffer = malloc(size); | |
221 | 228 |
222 info->map_chunks = base_chunks + (ram_start >= rom_end ? 2 : 3); | 229 info->map_chunks = base_chunks + (ram_start >= rom_end ? 2 : 3); |
223 info->map = malloc(sizeof(memmap_chunk) * info->map_chunks); | 230 info->map = malloc(sizeof(memmap_chunk) * info->map_chunks); |
224 memset(info->map, 0, sizeof(memmap_chunk)*2); | 231 memset(info->map, 0, sizeof(memmap_chunk)*2); |
225 memcpy(info->map+2, base_map, sizeof(memmap_chunk) * base_chunks); | 232 memcpy(info->map+2, base_map, sizeof(memmap_chunk) * base_chunks); |
230 info->map[0].mask = 0xFFFFFF; | 237 info->map[0].mask = 0xFFFFFF; |
231 info->map[0].flags = MMAP_READ; | 238 info->map[0].flags = MMAP_READ; |
232 info->map[0].buffer = rom; | 239 info->map[0].buffer = rom; |
233 | 240 |
234 info->map[1].start = ram_start; | 241 info->map[1].start = ram_start; |
235 info->map[1].mask = ram_end - ram_start; | 242 info->map[1].mask = info->save_mask; |
236 info->map[1].end = ram_end + 1; | 243 info->map[1].end = ram_end + 1; |
237 info->map[1].flags = MMAP_READ | MMAP_WRITE; | 244 info->map[1].flags = MMAP_READ | MMAP_WRITE; |
238 uint32_t size = info->map[1].mask + 1; | 245 |
239 if (ram_flags == RAM_FLAG_ODD) { | 246 if (ram_flags == RAM_FLAG_ODD) { |
240 info->map[1].flags |= MMAP_ONLY_ODD; | 247 info->map[1].flags |= MMAP_ONLY_ODD; |
241 size /= 2; | |
242 } else if (ram_flags == RAM_FLAG_EVEN) { | 248 } else if (ram_flags == RAM_FLAG_EVEN) { |
243 info->map[1].flags |= MMAP_ONLY_EVEN; | 249 info->map[1].flags |= MMAP_ONLY_EVEN; |
244 size /= 2; | 250 } |
245 } | 251 info->map[1].buffer = info->save_buffer; |
246 info->map[1].buffer = malloc(size); | |
247 } else { | 252 } else { |
248 //Assume the standard Sega mapper | 253 //Assume the standard Sega mapper |
249 info->map[0].end = 0x200000; | 254 info->map[0].end = 0x200000; |
250 info->map[0].mask = 0xFFFFFF; | 255 info->map[0].mask = 0xFFFFFF; |
251 info->map[0].flags = MMAP_READ; | 256 info->map[0].flags = MMAP_READ; |