Debian Codegraph @

fc/cartridge/chip/mmc5.cpp

raw
1 struct MMC5 : Chip {
2
3 enum class Revision : unsigned {
4 MMC5,
5 MMC5B,
6 } revision;
7
8 uint8 exram[1024];
9
10 //programmable registers
11
12 uint2 prg_mode; //$5100
13 uint2 chr_mode; //$5101
14
15 uint2 prgram_write_protect[2]; //$5102,$5103
16
17 uint2 exram_mode; //$5104
18 uint2 nametable_mode[4]; //$5105
19 uint8 fillmode_tile; //$5106
20 uint8 fillmode_color; //$5107
21
22 bool ram_select; //$5113
23 uint2 ram_bank; //$5113
24 uint8 prg_bank[4]; //$5114-5117
25 uint10 chr_sprite_bank[8]; //$5120-5127
26 uint10 chr_bg_bank[4]; //$5128-512b
27 uint2 chr_bank_hi; //$5130
28
29 bool vs_enable; //$5200
30 bool vs_side; //$5200
31 uint5 vs_tile; //$5200
32 uint8 vs_scroll; //$5201
33 uint8 vs_bank; //$5202
34
35 uint8 irq_line; //$5203
36 bool irq_enable; //$5204
37
38 uint8 multiplicand; //$5205
39 uint8 multiplier; //$5206
40
41 //status registers
42
43 unsigned cpu_cycle_counter;
44 unsigned irq_counter;
45 bool irq_pending;
46 bool in_frame;
47
48 unsigned vcounter;
49 unsigned hcounter;
50 uint16 chr_access[4];
51 bool chr_active;
52 bool sprite_8x16;
53
54 uint8 exbank;
55 uint8 exattr;
56
57 bool vs_fetch;
58 uint8 vs_vpos;
59 uint8 vs_hpos;
60
61 void main() {
62 while(true) {
63 if(scheduler.sync == Scheduler::SynchronizeMode::All) {
64 scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
65 }
66
67 //scanline() resets this; if no scanlines detected, enter video blanking period
68 if(++cpu_cycle_counter >= 200) blank(); //113-114 normal; ~2500 across Vblank period
69
70 cpu.set_irq_line(irq_enable && irq_pending);
71 tick();
72 }
73 }
74
75 void scanline(unsigned y) {
76 //used for testing only, to verify MMC5 scanline detection is accurate:
77 //if(y != vcounter && y <= 240) print(y, " vs ", vcounter, "\n");
78 }
79
80 uint8 prg_access(bool write, unsigned addr, uint8 data = 0x00) {
81 unsigned bank;
82
83 if((addr & 0xe000) == 0x6000) {
84 bank = (ram_select << 2) | ram_bank;
85 addr &= 0x1fff;
86 } else if(prg_mode == 0) {
87 bank = prg_bank[3] & ~3;
88 addr &= 0x7fff;
89 } else if(prg_mode == 1) {
90 if((addr & 0xc000) == 0x8000) bank = (prg_bank[1] & ~1);
91 if((addr & 0xe000) == 0xc000) bank = (prg_bank[3] & ~1);
92 addr &= 0x3fff;
93 } else if(prg_mode == 2) {
94 if((addr & 0xe000) == 0x8000) bank = (prg_bank[1] & ~1) | 0;
95 if((addr & 0xe000) == 0xa000) bank = (prg_bank[1] & ~1) | 1;
96 if((addr & 0xe000) == 0xc000) bank = (prg_bank[2]);
97 if((addr & 0xe000) == 0xe000) bank = (prg_bank[3]);
98 addr &= 0x1fff;
99 } else if(prg_mode == 3) {
100 if((addr & 0xe000) == 0x8000) bank = prg_bank[0];
101 if((addr & 0xe000) == 0xa000) bank = prg_bank[1];
102 if((addr & 0xe000) == 0xc000) bank = prg_bank[2];
103 if((addr & 0xe000) == 0xe000) bank = prg_bank[3];
104 addr &= 0x1fff;
105 }
106
107 bool rom = bank & 0x80;
108 bank &= 0x7f;
109
110 if(write == false) {
111 if(rom) {
112 return board.prgrom.read((bank << 13) | addr);
113 } else {
114 return board.prgram.read((bank << 13) | addr);
115 }
116 } else {
117 if(rom) {
118 board.prgrom.write((bank << 13) | addr, data);
119 } else {
120 if(prgram_write_protect[0] == 2 && prgram_write_protect[1] == 1) {
121 board.prgram.write((bank << 13) | addr, data);
122 }
123 }
124 return 0x00;
125 }
126 }
127
128 uint8 prg_read(unsigned addr) {
129 if((addr & 0xfc00) == 0x5c00) {
130 if(exram_mode >= 2) return exram[addr & 0x03ff];
131 return cpu.mdr();
132 }
133
134 if(addr >= 0x6000) {
135 return prg_access(0, addr);
136 }
137
138 switch(addr) {
139 case 0x5204: {
140 uint8 result = (irq_pending << 7) | (in_frame << 6);
141 irq_pending = false;
142 return result;
143 }
144 case 0x5205: return (multiplier * multiplicand) >> 0;
145 case 0x5206: return (multiplier * multiplicand) >> 8;
146 }
147 }
148
149 void prg_write(unsigned addr, uint8 data) {
150 if((addr & 0xfc00) == 0x5c00) {
151 //writes 0x00 *during* Vblank (not during screen rendering ...)
152 if(exram_mode == 0 || exram_mode == 1) exram[addr & 0x03ff] = in_frame ? data : 0x00;
153 if(exram_mode == 2) exram[addr & 0x03ff] = data;
154 return;
155 }
156
157 if(addr >= 0x6000) {
158 prg_access(1, addr, data);
159 return;
160 }
161
162 switch(addr) {
163 case 0x2000:
164 sprite_8x16 = data & 0x20;
165 break;
166
167 case 0x2001:
168 //if BG+sprites are disabled; enter video blanking period
169 if((data & 0x18) == 0) blank();
170 break;
171
172 case 0x5100: prg_mode = data & 3; break;
173 case 0x5101: chr_mode = data & 3; break;
174
175 case 0x5102: prgram_write_protect[0] = data & 3; break;
176 case 0x5103: prgram_write_protect[1] = data & 3; break;
177
178 case 0x5104:
179 exram_mode = data & 3;
180 break;
181
182 case 0x5105:
183 nametable_mode[0] = (data & 0x03) >> 0;
184 nametable_mode[1] = (data & 0x0c) >> 2;
185 nametable_mode[2] = (data & 0x30) >> 4;
186 nametable_mode[3] = (data & 0xc0) >> 6;
187 break;
188
189 case 0x5106:
190 fillmode_tile = data;
191 break;
192
193 case 0x5107:
194 fillmode_color = data & 3;
195 fillmode_color |= fillmode_color << 2;
196 fillmode_color |= fillmode_color << 4;
197 break;
198
199 case 0x5113:
200 ram_select = data & 0x04;
201 ram_bank = data & 0x03;
202 break;
203
204 case 0x5114: prg_bank[0] = data; break;
205 case 0x5115: prg_bank[1] = data; break;
206 case 0x5116: prg_bank[2] = data; break;
207 case 0x5117: prg_bank[3] = data | 0x80; break;
208
209 case 0x5120: chr_sprite_bank[0] = (chr_bank_hi << 8) | data; chr_active = 0; break;
210 case 0x5121: chr_sprite_bank[1] = (chr_bank_hi << 8) | data; chr_active = 0; break;
211 case 0x5122: chr_sprite_bank[2] = (chr_bank_hi << 8) | data; chr_active = 0; break;
212 case 0x5123: chr_sprite_bank[3] = (chr_bank_hi << 8) | data; chr_active = 0; break;
213 case 0x5124: chr_sprite_bank[4] = (chr_bank_hi << 8) | data; chr_active = 0; break;
214 case 0x5125: chr_sprite_bank[5] = (chr_bank_hi << 8) | data; chr_active = 0; break;
215 case 0x5126: chr_sprite_bank[6] = (chr_bank_hi << 8) | data; chr_active = 0; break;
216 case 0x5127: chr_sprite_bank[7] = (chr_bank_hi << 8) | data; chr_active = 0; break;
217
218 case 0x5128: chr_bg_bank[0] = (chr_bank_hi << 8) | data; chr_active = 1; break;
219 case 0x5129: chr_bg_bank[1] = (chr_bank_hi << 8) | data; chr_active = 1; break;
220 case 0x512a: chr_bg_bank[2] = (chr_bank_hi << 8) | data; chr_active = 1; break;
221 case 0x512b: chr_bg_bank[3] = (chr_bank_hi << 8) | data; chr_active = 1; break;
222
223 case 0x5130:
224 chr_bank_hi = data & 3;
225 break;
226
227 case 0x5200:
228 vs_enable = data & 0x80;
229 vs_side = data & 0x40;
230 vs_tile = data & 0x1f;
231 break;
232
233 case 0x5201:
234 vs_scroll = data;
235 break;
236
237 case 0x5202:
238 vs_bank = data;
239 break;
240
241 case 0x5203:
242 irq_line = data;
243 break;
244
245 case 0x5204:
246 irq_enable = data & 0x80;
247 break;
248
249 case 0x5205:
250 multiplicand = data;
251 break;
252
253 case 0x5206:
254 multiplier = data;
255 break;
256 }
257 }
258
259 unsigned chr_sprite_addr(unsigned addr) {
260 if(chr_mode == 0) {
261 auto bank = chr_sprite_bank[7];
262 return (bank * 0x2000) + (addr & 0x1fff);
263 }
264
265 if(chr_mode == 1) {
266 auto bank = chr_sprite_bank[(addr / 0x1000) * 4 + 3];
267 return (bank * 0x1000) + (addr & 0x0fff);
268 }
269
270 if(chr_mode == 2) {
271 auto bank = chr_sprite_bank[(addr / 0x0800) * 2 + 1];
272 return (bank * 0x0800) + (addr & 0x07ff);
273 }
274
275 if(chr_mode == 3) {
276 auto bank = chr_sprite_bank[(addr / 0x0400)];
277 return (bank * 0x0400) + (addr & 0x03ff);
278 }
279 }
280
281 unsigned chr_bg_addr(unsigned addr) {
282 addr &= 0x0fff;
283
284 if(chr_mode == 0) {
285 auto bank = chr_bg_bank[3];
286 return (bank * 0x2000) + (addr & 0x0fff);
287 }
288
289 if(chr_mode == 1) {
290 auto bank = chr_bg_bank[3];
291 return (bank * 0x1000) + (addr & 0x0fff);
292 }
293
294 if(chr_mode == 2) {
295 auto bank = chr_bg_bank[(addr / 0x0800) * 2 + 1];
296 return (bank * 0x0800) + (addr & 0x07ff);
297 }
298
299 if(chr_mode == 3) {
300 auto bank = chr_bg_bank[(addr / 0x0400)];
301 return (bank * 0x0400) + (addr & 0x03ff);
302 }
303 }
304
305 unsigned chr_vs_addr(unsigned addr) {
306 return (vs_bank * 0x1000) + (addr & 0x0ff8) + (vs_vpos & 7);
307 }
308
309 void blank() {
310 in_frame = false;
311 }
312
313 void scanline() {
314 hcounter = 0;
315
316 if(in_frame == false) {
317 in_frame = true;
318 irq_pending = false;
319 vcounter = 0;
320 } else {
321 if(vcounter == irq_line) irq_pending = true;
322 vcounter++;
323 }
324
325 cpu_cycle_counter = 0;
326 }
327
328 uint8 ciram_read(unsigned addr) {
329 if(vs_fetch && (hcounter & 2) == 0) return exram[vs_vpos / 8 * 32 + vs_hpos / 8];
330 if(vs_fetch && (hcounter & 2) != 0) return exram[vs_vpos / 32 * 8 + vs_hpos / 32 + 0x03c0];
331
332 switch(nametable_mode[(addr >> 10) & 3]) {
333 case 0: return ppu.ciram_read(0x0000 | (addr & 0x03ff));
334 case 1: return ppu.ciram_read(0x0400 | (addr & 0x03ff));
335 case 2: return exram_mode < 2 ? exram[addr & 0x03ff] : 0x00;
336 case 3: return (hcounter & 2) == 0 ? fillmode_tile : fillmode_color;
337 }
338 }
339
340 uint8 chr_read(unsigned addr) {
341 chr_access[0] = chr_access[1];
342 chr_access[1] = chr_access[2];
343 chr_access[2] = chr_access[3];
344 chr_access[3] = addr;
345
346 //detect two unused nametable fetches at end of each scanline
347 if((chr_access[0] & 0x2000) == 0
348 && (chr_access[1] & 0x2000)
349 && (chr_access[2] & 0x2000)
350 && (chr_access[3] & 0x2000)) scanline();
351
352 if(in_frame == false) {
353 vs_fetch = false;
354 if(addr & 0x2000) return ciram_read(addr);
355 return board.chrrom.read(chr_active ? chr_bg_addr(addr) : chr_sprite_addr(addr));
356 }
357
358 bool bg_fetch = (hcounter < 256 || hcounter >= 320);
359 uint8 result = 0x00;
360
361 if((hcounter & 7) == 0) {
362 vs_hpos = hcounter >= 320 ? hcounter - 320 : hcounter + 16;
363 vs_vpos = vcounter + vs_scroll;
364 vs_fetch = vs_enable && bg_fetch && exram_mode < 2
365 && (vs_side ? vs_hpos / 8 >= vs_tile : vs_hpos / 8 < vs_tile);
366 if(vs_vpos >= 240) vs_vpos -= 240;
367
368 result = ciram_read(addr);
369
370 exbank = (chr_bank_hi << 6) | (exram[addr & 0x03ff] & 0x3f);
371 exattr = exram[addr & 0x03ff] >> 6;
372 exattr |= exattr << 2;
373 exattr |= exattr << 4;
374 } else if((hcounter & 7) == 2) {
375 result = ciram_read(addr);
376 if(bg_fetch && exram_mode == 1) result = exattr;
377 } else {
378 if(vs_fetch) result = board.chrrom.read(chr_vs_addr(addr));
379 else if(sprite_8x16 ? bg_fetch : chr_active) result = board.chrrom.read(chr_bg_addr(addr));
380 else result = board.chrrom.read(chr_sprite_addr(addr));
381 if(bg_fetch && exram_mode == 1) result = board.chrrom.read(exbank * 0x1000 + (addr & 0x0fff));
382 }
383
384 hcounter += 2;
385 return result;
386 }
387
388 void chr_write(unsigned addr, uint8 data) {
389 if(addr & 0x2000) {
390 switch(nametable_mode[(addr >> 10) & 3]) {
391 case 0: return ppu.ciram_write(0x0000 | (addr & 0x03ff), data);
392 case 1: return ppu.ciram_write(0x0400 | (addr & 0x03ff), data);
393 case 2: exram[addr & 0x03ff] = data; break;
394 }
395 }
396 }
397
398 void power() {
399 }
400
401 void reset() {
402 for(auto& n : exram) n = 0xff;
403
404 prg_mode = 3;
405 chr_mode = 0;
406 for(auto& n : prgram_write_protect) n = 0;
407 exram_mode = 0;
408 for(auto& n : nametable_mode) n = 0;
409 fillmode_tile = 0;
410 fillmode_color = 0;
411 ram_select = 0;
412 ram_bank = 0;
413 prg_bank[0] = 0x00;
414 prg_bank[1] = 0x00;
415 prg_bank[2] = 0x00;
416 prg_bank[3] = 0xff;
417 for(auto& n : chr_sprite_bank) n = 0;
418 for(auto& n : chr_bg_bank) n = 0;
419 chr_bank_hi = 0;
420 vs_enable = 0;
421 vs_side = 0;
422 vs_tile = 0;
423 vs_scroll = 0;
424 vs_bank = 0;
425 irq_line = 0;
426 irq_enable = 0;
427 multiplicand = 0;
428 multiplier = 0;
429
430 cpu_cycle_counter = 0;
431 irq_counter = 0;
432 irq_pending = 0;
433 in_frame = 0;
434 vcounter = 0;
435 hcounter = 0;
436 for(auto& n : chr_access) n = 0;
437 chr_active = 0;
438 sprite_8x16 = 0;
439
440 exbank = 0;
441 exattr = 0;
442
443 vs_fetch = 0;
444 vs_vpos = 0;
445 vs_hpos = 0;
446 }
447
448 void serialize(serializer& s) {
449 s.array(exram);
450
451 s.integer(prg_mode);
452 s.integer(chr_mode);
453 for(auto& n : prgram_write_protect) s.integer(n);
454 s.integer(exram_mode);
455 for(auto& n : nametable_mode) s.integer(n);
456 s.integer(fillmode_tile);
457 s.integer(fillmode_color);
458 s.integer(ram_select);
459 s.integer(ram_bank);
460 for(auto& n : prg_bank) s.integer(n);
461 for(auto& n : chr_sprite_bank) s.integer(n);
462 for(auto& n : chr_bg_bank) s.integer(n);
463 s.integer(chr_bank_hi);
464 s.integer(vs_enable);
465 s.integer(vs_side);
466 s.integer(vs_tile);
467 s.integer(vs_scroll);
468 s.integer(vs_bank);
469 s.integer(irq_line);
470 s.integer(irq_enable);
471 s.integer(multiplicand);
472 s.integer(multiplier);
473
474 s.integer(cpu_cycle_counter);
475 s.integer(irq_counter);
476 s.integer(irq_pending);
477 s.integer(in_frame);
478
479 s.integer(vcounter);
480 s.integer(hcounter);
481 for(auto& n : chr_access) s.integer(n);
482 s.integer(chr_active);
483 s.integer(sprite_8x16);
484
485 s.integer(exbank);
486 s.integer(exattr);
487
488 s.integer(vs_fetch);
489 s.integer(vs_vpos);
490 s.integer(vs_hpos);
491 }
492
493 MMC5(Board& board) : Chip(board) {
494 revision = Revision::MMC5;
495 }
496
497 };