Debian Codegraph @

fc/cartridge/chip/vrc6.cpp

raw
1 struct VRC6 : Chip {
2
3 uint8 prg_bank[2];
4 uint8 chr_bank[8];
5 uint2 mirror;
6 uint8 irq_latch;
7 bool irq_mode;
8 bool irq_enable;
9 bool irq_acknowledge;
10
11 uint8 irq_counter;
12 signed irq_scalar;
13 bool irq_line;
14
15 struct Pulse {
16 bool mode;
17 uint3 duty;
18 uint4 volume;
19 bool enable;
20 uint12 frequency;
21
22 uint12 divider;
23 uint4 cycle;
24 uint4 output;
25
26 void clock() {
27 if(--divider == 0) {
28 divider = frequency + 1;
29 cycle++;
30 output = (mode == 1 || cycle > duty) ? volume : (uint4)0;
31 }
32
33 if(enable == false) output = 0;
34 }
35
36 void serialize(serializer& s) {
37 s.integer(mode);
38 s.integer(duty);
39 s.integer(volume);
40 s.integer(enable);
41 s.integer(frequency);
42
43 s.integer(divider);
44 s.integer(cycle);
45 s.integer(output);
46 }
47 } pulse1, pulse2;
48
49 struct Sawtooth {
50 uint6 rate;
51 bool enable;
52 uint12 frequency;
53
54 uint12 divider;
55 uint1 phase;
56 uint3 stage;
57 uint8 accumulator;
58 uint5 output;
59
60 void clock() {
61 if(--divider == 0) {
62 divider = frequency + 1;
63 if(++phase == 0) {
64 accumulator += rate;
65 if(++stage == 7) {
66 stage = 0;
67 accumulator = 0;
68 }
69 }
70 }
71
72 output = accumulator >> 3;
73 if(enable == false) output = 0;
74 }
75
76 void serialize(serializer& s) {
77 s.integer(rate);
78 s.integer(enable);
79 s.integer(frequency);
80
81 s.integer(divider);
82 s.integer(phase);
83 s.integer(stage);
84 s.integer(accumulator);
85 s.integer(output);
86 }
87 } sawtooth;
88
89 void main() {
90 while(true) {
91 if(scheduler.sync == Scheduler::SynchronizeMode::All) {
92 scheduler.exit(Scheduler::ExitReason::SynchronizeEvent);
93 }
94
95 if(irq_enable) {
96 if(irq_mode == 0) {
97 irq_scalar -= 3;
98 if(irq_scalar <= 0) {
99 irq_scalar += 341;
100 if(irq_counter == 0xff) {
101 irq_counter = irq_latch;
102 irq_line = 1;
103 } else {
104 irq_counter++;
105 }
106 }
107 }
108
109 if(irq_mode == 1) {
110 if(irq_counter == 0xff) {
111 irq_counter = irq_latch;
112 irq_line = 1;
113 } else {
114 irq_counter++;
115 }
116 }
117 }
118 cpu.set_irq_line(irq_line);
119
120 pulse1.clock();
121 pulse2.clock();
122 sawtooth.clock();
123 signed output = (pulse1.output + pulse2.output + sawtooth.output) << 7;
124 apu.set_sample(-output);
125
126 tick();
127 }
128 }
129
130 unsigned prg_addr(unsigned addr) const {
131 if((addr & 0xc000) == 0x8000) return (prg_bank[0] << 14) | (addr & 0x3fff);
132 if((addr & 0xe000) == 0xc000) return (prg_bank[1] << 13) | (addr & 0x1fff);
133 if((addr & 0xe000) == 0xe000) return ( 0xff << 13) | (addr & 0x1fff);
134 }
135
136 unsigned chr_addr(unsigned addr) const {
137 unsigned bank = chr_bank[(addr >> 10) & 7];
138 return (bank << 10) | (addr & 0x03ff);
139 }
140
141 unsigned ciram_addr(unsigned addr) const {
142 switch(mirror) {
143 case 0: return ((addr & 0x0400) >> 0) | (addr & 0x03ff); //vertical mirroring
144 case 1: return ((addr & 0x0800) >> 1) | (addr & 0x03ff); //horizontal mirroring
145 case 2: return 0x0000 | (addr & 0x03ff); //one-screen mirroring (first)
146 case 3: return 0x0400 | (addr & 0x03ff); //one-screen mirroring (second)
147 }
148 }
149
150 uint8 ram_read(unsigned addr) {
151 return board.prgram.data[addr & 0x1fff];
152 }
153
154 void ram_write(unsigned addr, uint8 data) {
155 board.prgram.data[addr & 0x1fff] = data;
156 }
157
158 void reg_write(unsigned addr, uint8 data) {
159 switch(addr) {
160 case 0x8000: case 0x8001: case 0x8002: case 0x8003:
161 prg_bank[0] = data;
162 break;
163
164 case 0x9000:
165 pulse1.mode = data & 0x80;
166 pulse1.duty = (data & 0x70) >> 4;
167 pulse1.volume = data & 0x0f;
168 break;
169
170 case 0x9001:
171 pulse1.frequency = (pulse1.frequency & 0x0f00) | ((data & 0xff) << 0);
172 break;
173
174 case 0x9002:
175 pulse1.frequency = (pulse1.frequency & 0x00ff) | ((data & 0x0f) << 8);
176 pulse1.enable = data & 0x80;
177 break;
178
179 case 0xa000:
180 pulse2.mode = data & 0x80;
181 pulse2.duty = (data & 0x70) >> 4;
182 pulse2.volume = data & 0x0f;
183 break;
184
185 case 0xa001:
186 pulse2.frequency = (pulse2.frequency & 0x0f00) | ((data & 0xff) << 0);
187 break;
188
189 case 0xa002:
190 pulse2.frequency = (pulse2.frequency & 0x00ff) | ((data & 0x0f) << 8);
191 pulse2.enable = data & 0x80;
192 break;
193
194 case 0xb000:
195 sawtooth.rate = data & 0x3f;
196 break;
197
198 case 0xb001:
199 sawtooth.frequency = (sawtooth.frequency & 0x0f00) | ((data & 0xff) << 0);
200 break;
201
202 case 0xb002:
203 sawtooth.frequency = (sawtooth.frequency & 0x00ff) | ((data & 0x0f) << 8);
204 sawtooth.enable = data & 0x80;
205 break;
206
207 case 0xb003:
208 mirror = (data >> 2) & 3;
209 break;
210
211 case 0xc000: case 0xc001: case 0xc002: case 0xc003:
212 prg_bank[1] = data;
213 break;
214
215 case 0xd000: case 0xd001: case 0xd002: case 0xd003:
216 chr_bank[0 + (addr & 3)] = data;
217 break;
218
219 case 0xe000: case 0xe001: case 0xe002: case 0xe003:
220 chr_bank[4 + (addr & 3)] = data;
221 break;
222
223 case 0xf000:
224 irq_latch = data;
225 break;
226
227 case 0xf001:
228 irq_mode = data & 0x04;
229 irq_enable = data & 0x02;
230 irq_acknowledge = data & 0x01;
231 if(irq_enable) {
232 irq_counter = irq_latch;
233 irq_scalar = 341;
234 }
235 irq_line = 0;
236 break;
237
238 case 0xf002:
239 irq_enable = irq_acknowledge;
240 irq_line = 0;
241 break;
242 }
243 }
244
245 void power() {
246 }
247
248 void reset() {
249 prg_bank[0] = 0;
250 prg_bank[1] = 0;
251 chr_bank[0] = 0;
252 chr_bank[1] = 0;
253 chr_bank[2] = 0;
254 chr_bank[3] = 0;
255 chr_bank[4] = 0;
256 chr_bank[5] = 0;
257 chr_bank[6] = 0;
258 chr_bank[7] = 0;
259 mirror = 0;
260 irq_latch = 0;
261 irq_mode = 0;
262 irq_enable = 0;
263 irq_acknowledge = 0;
264
265 irq_counter = 0;
266 irq_scalar = 0;
267 irq_line = 0;
268
269 pulse1.mode = 0;
270 pulse1.duty = 0;
271 pulse1.volume = 0;
272 pulse1.enable = 0;
273 pulse1.frequency = 0;
274
275 pulse1.divider = 1;
276 pulse1.cycle = 0;
277 pulse1.output = 0;
278
279 pulse2.mode = 0;
280 pulse2.duty = 0;
281 pulse2.volume = 0;
282 pulse2.enable = 0;
283 pulse2.frequency = 0;
284
285 pulse2.divider = 1;
286 pulse2.cycle = 0;
287 pulse2.output = 0;
288
289 sawtooth.rate = 0;
290 sawtooth.enable = 0;
291 sawtooth.frequency = 0;
292
293 sawtooth.divider = 1;
294 sawtooth.phase = 0;
295 sawtooth.stage = 0;
296 sawtooth.accumulator = 0;
297 sawtooth.output = 0;
298 }
299
300 void serialize(serializer& s) {
301 pulse1.serialize(s);
302 pulse2.serialize(s);
303 sawtooth.serialize(s);
304
305 s.array(prg_bank);
306 s.array(chr_bank);
307 s.integer(mirror);
308 s.integer(irq_latch);
309 s.integer(irq_mode);
310 s.integer(irq_enable);
311 s.integer(irq_acknowledge);
312
313 s.integer(irq_counter);
314 s.integer(irq_scalar);
315 s.integer(irq_line);
316 }
317
318 VRC6(Board& board) : Chip(board) {
319 }
320
321 };