Debian Codegraph @

fc/cartridge/board/sunsoft-5b.cpp

raw
1 //SUNSOFT-5B
2
3 struct Sunsoft5B : Board {
4
5 uint4 mmu_port;
6 uint4 apu_port;
7
8 uint8 prg_bank[4];
9 uint8 chr_bank[8];
10 uint2 mirror;
11 bool irq_enable;
12 bool irq_counter_enable;
13 uint16 irq_counter;
14
15 int16 dac[16];
16
17 struct Pulse {
18 bool disable;
19 uint12 frequency;
20 uint4 volume;
21
22 uint16 counter; //12-bit countdown + 4-bit phase
23 uint1 duty;
24 uint4 output;
25
26 void clock() {
27 if(--counter == 0) {
28 counter = frequency << 4;
29 duty ^= 1;
30 }
31 output = duty ? volume : (uint4)0;
32 if(disable) output = 0;
33 }
34
35 void reset() {
36 disable = 1;
37 frequency = 1;
38 volume = 0;
39
40 counter = 0;
41 duty = 0;
42 output = 0;
43 }
44
45 void serialize(serializer& s) {
46 s.integer(disable);
47 s.integer(frequency);
48 s.integer(volume);
49
50 s.integer(counter);
51 s.integer(duty);
52 s.integer(output);
53 }
54 } pulse[3];
55
56 void main() {
57 while(true) {
58 if(scheduler.sync == Scheduler::SynchronizeMode::All) {
59 scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
60 }
61
62 if(irq_counter_enable) {
63 if(--irq_counter == 0xffff) {
64 cpu.set_irq_line(irq_enable);
65 }
66 }
67
68 pulse[0].clock();
69 pulse[1].clock();
70 pulse[2].clock();
71 int16 output = dac[pulse[0].output] + dac[pulse[1].output] + dac[pulse[2].output];
72 apu.set_sample(-output);
73
74 tick();
75 }
76 }
77
78 uint8 prg_read(unsigned addr) {
79 if(addr < 0x6000) return cpu.mdr();
80
81 uint8 bank = 0x3f; //((addr & 0xe000) == 0xe000
82 if((addr & 0xe000) == 0x6000) bank = prg_bank[0];
83 if((addr & 0xe000) == 0x8000) bank = prg_bank[1];
84 if((addr & 0xe000) == 0xa000) bank = prg_bank[2];
85 if((addr & 0xe000) == 0xc000) bank = prg_bank[3];
86
87 bool ram_enable = bank & 0x80;
88 bool ram_select = bank & 0x40;
89 bank &= 0x3f;
90
91 if(ram_select) {
92 if(ram_enable == false) return cpu.mdr();
93 return prgram.data[addr & 0x1fff];
94 }
95
96 addr = (bank << 13) | (addr & 0x1fff);
97 return prgrom.read(addr);
98 }
99
100 void prg_write(unsigned addr, uint8 data) {
101 if((addr & 0xe000) == 0x6000) {
102 prgram.data[addr & 0x1fff] = data;
103 }
104
105 if(addr == 0x8000) {
106 mmu_port = data & 0x0f;
107 }
108
109 if(addr == 0xa000) {
110 switch(mmu_port) {
111 case 0: chr_bank[0] = data; break;
112 case 1: chr_bank[1] = data; break;
113 case 2: chr_bank[2] = data; break;
114 case 3: chr_bank[3] = data; break;
115 case 4: chr_bank[4] = data; break;
116 case 5: chr_bank[5] = data; break;
117 case 6: chr_bank[6] = data; break;
118 case 7: chr_bank[7] = data; break;
119 case 8: prg_bank[0] = data; break;
120 case 9: prg_bank[1] = data; break;
121 case 10: prg_bank[2] = data; break;
122 case 11: prg_bank[3] = data; break;
123 case 12: mirror = data & 3; break;
124 case 13:
125 irq_enable = data & 0x80;
126 irq_counter_enable = data & 0x01;
127 if(irq_enable == 0) cpu.set_irq_line(0);
128 break;
129 case 14: irq_counter = (irq_counter & 0xff00) | (data << 0); break;
130 case 15: irq_counter = (irq_counter & 0x00ff) | (data << 8); break;
131 }
132 }
133
134 if(addr == 0xc000) {
135 apu_port = data & 0x0f;
136 }
137
138 if(addr == 0xe000) {
139 switch(apu_port) {
140 case 0: pulse[0].frequency = (pulse[0].frequency & 0xff00) | (data << 0); break;
141 case 1: pulse[0].frequency = (pulse[0].frequency & 0x00ff) | (data << 8); break;
142 case 2: pulse[1].frequency = (pulse[1].frequency & 0xff00) | (data << 0); break;
143 case 3: pulse[1].frequency = (pulse[1].frequency & 0x00ff) | (data << 8); break;
144 case 4: pulse[2].frequency = (pulse[2].frequency & 0xff00) | (data << 0); break;
145 case 5: pulse[2].frequency = (pulse[2].frequency & 0x00ff) | (data << 8); break;
146 case 7:
147 pulse[0].disable = data & 0x01;
148 pulse[1].disable = data & 0x02;
149 pulse[2].disable = data & 0x04;
150 break;
151 case 8: pulse[0].volume = data & 0x0f; break;
152 case 9: pulse[1].volume = data & 0x0f; break;
153 case 10: pulse[2].volume = data & 0x0f; break;
154 }
155 }
156 }
157
158 unsigned chr_addr(unsigned addr) {
159 uint8 bank = (addr >> 10) & 7;
160 return (chr_bank[bank] << 10) | (addr & 0x03ff);
161 }
162
163 unsigned ciram_addr(unsigned addr) {
164 switch(mirror) {
165 case 0: return ((addr & 0x0400) >> 0) | (addr & 0x03ff); //vertical
166 case 1: return ((addr & 0x0800) >> 1) | (addr & 0x03ff); //horizontal
167 case 2: return 0x0000 | (addr & 0x03ff); //first
168 case 3: return 0x0400 | (addr & 0x03ff); //second
169 }
170 }
171
172 uint8 chr_read(unsigned addr) {
173 if(addr & 0x2000) return ppu.ciram_read(ciram_addr(addr));
174 return Board::chr_read(chr_addr(addr));
175 }
176
177 void chr_write(unsigned addr, uint8 data) {
178 if(addr & 0x2000) return ppu.ciram_write(ciram_addr(addr), data);
179 return Board::chr_write(chr_addr(addr), data);
180 }
181
182 void power() {
183 for(signed n = 0; n < 16; n++) {
184 double volume = 1.0 / pow(2, 1.0 / 2 * (15 - n));
185 dac[n] = volume * 8192.0;
186 }
187 }
188
189 void reset() {
190 mmu_port = 0;
191 apu_port = 0;
192
193 for(auto& n : prg_bank) n = 0;
194 for(auto& n : chr_bank) n = 0;
195 mirror = 0;
196 irq_enable = 0;
197 irq_counter_enable = 0;
198 irq_counter = 0;
199
200 pulse[0].reset();
201 pulse[1].reset();
202 pulse[2].reset();
203 }
204
205 void serialize(serializer& s) {
206 Board::serialize(s);
207
208 s.integer(mmu_port);
209 s.integer(apu_port);
210
211 s.array(prg_bank);
212 s.array(chr_bank);
213 s.integer(mirror);
214 s.integer(irq_enable);
215 s.integer(irq_counter_enable);
216 s.integer(irq_counter);
217
218 pulse[0].serialize(s);
219 pulse[1].serialize(s);
220 pulse[2].serialize(s);
221 }
222
223 Sunsoft5B(Markup::Node& document) : Board(document) {
224 }
225
226 };