cff531af |
1 | /* |
2 | * PicoDrive |
a7f82a77 |
3 | * (C) notaz, 2009,2010,2013 |
cff531af |
4 | * |
5 | * This work is licensed under the terms of MAME license. |
6 | * See COPYING file in the top-level directory. |
7 | */ |
db1d3564 |
8 | #include "../pico_int.h" |
9 | |
db1d3564 |
10 | static int pwm_cycles; |
11 | static int pwm_mult; |
12 | static int pwm_ptr; |
df63f1a6 |
13 | static int pwm_irq_reload; |
8ad1d2ad |
14 | static int pwm_doing_fifo; |
db1d3564 |
15 | |
045a4c52 |
16 | void p32x_pwm_ctl_changed(void) |
db1d3564 |
17 | { |
df63f1a6 |
18 | int control = Pico32x.regs[0x30 / 2]; |
db1d3564 |
19 | int cycles = Pico32x.regs[0x32 / 2]; |
db1d3564 |
20 | |
21 | cycles = (cycles - 1) & 0x0fff; |
db1d3564 |
22 | pwm_cycles = cycles; |
23 | pwm_mult = 0x10000 / cycles; |
1d7a28a7 |
24 | |
df63f1a6 |
25 | pwm_irq_reload = (control & 0x0f00) >> 8; |
26 | pwm_irq_reload = ((pwm_irq_reload - 1) & 0x0f) + 1; |
27 | |
28 | if (Pico32x.pwm_irq_cnt == 0) |
29 | Pico32x.pwm_irq_cnt = pwm_irq_reload; |
db1d3564 |
30 | } |
31 | |
c1931173 |
32 | static void do_pwm_irq(SH2 *sh2, unsigned int m68k_cycles) |
df63f1a6 |
33 | { |
9e1fa0a6 |
34 | p32x_trigger_irq(sh2, m68k_cycles, P32XI_PWM); |
df63f1a6 |
35 | |
36 | if (Pico32x.regs[0x30 / 2] & P32XP_RTP) { |
37 | p32x_event_schedule(m68k_cycles, P32X_EVENT_PWM, pwm_cycles / 3 + 1); |
38 | // note: might recurse |
39 | p32x_dreq1_trigger(); |
40 | } |
41 | } |
42 | |
c1931173 |
43 | #define consume_fifo(sh2, m68k_cycles) { \ |
df63f1a6 |
44 | int cycles_diff = ((m68k_cycles) * 3) - Pico32x.pwm_cycle_p; \ |
a7f82a77 |
45 | if (cycles_diff >= pwm_cycles) \ |
c1931173 |
46 | consume_fifo_do(sh2, m68k_cycles, cycles_diff); \ |
a7f82a77 |
47 | } |
48 | |
c1931173 |
49 | static void consume_fifo_do(SH2 *sh2, unsigned int m68k_cycles, |
50 | int sh2_cycles_diff) |
db1d3564 |
51 | { |
8ad1d2ad |
52 | if (pwm_cycles == 0 || pwm_doing_fifo) |
a7f82a77 |
53 | return; |
54 | |
55 | elprintf(EL_PWM, "pwm: %u: consume %d/%d, %d,%d ptr %d", |
df63f1a6 |
56 | m68k_cycles, sh2_cycles_diff, sh2_cycles_diff / pwm_cycles, |
a7f82a77 |
57 | Pico32x.pwm_p[0], Pico32x.pwm_p[1], pwm_ptr); |
58 | |
8ad1d2ad |
59 | // this is for recursion from dreq1 writes |
60 | pwm_doing_fifo = 1; |
07e5dbab |
61 | |
df63f1a6 |
62 | while (sh2_cycles_diff >= pwm_cycles) { |
a7f82a77 |
63 | struct Pico32xMem *mem = Pico32xMem; |
64 | short *fifo_l = mem->pwm_fifo[0]; |
65 | short *fifo_r = mem->pwm_fifo[1]; |
1d7a28a7 |
66 | |
a7f82a77 |
67 | if (Pico32x.pwm_p[0] > 0) { |
68 | fifo_l[0] = fifo_l[1]; |
69 | fifo_l[1] = fifo_l[2]; |
70 | fifo_l[2] = fifo_l[3]; |
71 | Pico32x.pwm_p[0]--; |
bc3aea8e |
72 | } |
a7f82a77 |
73 | if (Pico32x.pwm_p[1] > 0) { |
74 | fifo_r[0] = fifo_r[1]; |
75 | fifo_r[1] = fifo_r[2]; |
76 | fifo_r[2] = fifo_r[3]; |
77 | Pico32x.pwm_p[1]--; |
78 | } |
79 | |
80 | mem->pwm[pwm_ptr * 2 ] = fifo_l[0]; |
81 | mem->pwm[pwm_ptr * 2 + 1] = fifo_r[0]; |
82 | pwm_ptr = (pwm_ptr + 1) & (PWM_BUFF_LEN - 1); |
df63f1a6 |
83 | |
84 | sh2_cycles_diff -= pwm_cycles; |
85 | |
86 | if (--Pico32x.pwm_irq_cnt == 0) { |
87 | Pico32x.pwm_irq_cnt = pwm_irq_reload; |
8ad1d2ad |
88 | do_pwm_irq(sh2, m68k_cycles); |
df63f1a6 |
89 | } |
a8fd6e37 |
90 | } |
df63f1a6 |
91 | Pico32x.pwm_cycle_p = m68k_cycles * 3 - sh2_cycles_diff; |
8ad1d2ad |
92 | pwm_doing_fifo = 0; |
a7f82a77 |
93 | } |
94 | |
c1931173 |
95 | static int p32x_pwm_schedule_(SH2 *sh2, unsigned int m68k_now) |
a8fd6e37 |
96 | { |
df63f1a6 |
97 | unsigned int sh2_now = m68k_now * 3; |
98 | int cycles_diff_sh2; |
99 | |
100 | if (pwm_cycles == 0) |
101 | return 0; |
102 | |
103 | cycles_diff_sh2 = sh2_now - Pico32x.pwm_cycle_p; |
104 | if (cycles_diff_sh2 >= pwm_cycles) |
c1931173 |
105 | consume_fifo_do(sh2, m68k_now, cycles_diff_sh2); |
a8fd6e37 |
106 | |
a8fd6e37 |
107 | if (!((Pico32x.sh2irq_mask[0] | Pico32x.sh2irq_mask[1]) & 1)) |
19886062 |
108 | return 0; // masked by everyone |
a8fd6e37 |
109 | |
df63f1a6 |
110 | cycles_diff_sh2 = sh2_now - Pico32x.pwm_cycle_p; |
111 | return (Pico32x.pwm_irq_cnt * pwm_cycles |
112 | - cycles_diff_sh2) / 3 + 1; |
19886062 |
113 | } |
114 | |
df63f1a6 |
115 | void p32x_pwm_schedule(unsigned int m68k_now) |
19886062 |
116 | { |
c1931173 |
117 | int after = p32x_pwm_schedule_(NULL, m68k_now); |
19886062 |
118 | if (after != 0) |
df63f1a6 |
119 | p32x_event_schedule(m68k_now, P32X_EVENT_PWM, after); |
19886062 |
120 | } |
121 | |
122 | void p32x_pwm_schedule_sh2(SH2 *sh2) |
123 | { |
c1931173 |
124 | int after = p32x_pwm_schedule_(sh2, sh2_cycles_done_m68k(sh2)); |
19886062 |
125 | if (after != 0) |
126 | p32x_event_schedule_sh2(sh2, P32X_EVENT_PWM, after); |
a8fd6e37 |
127 | } |
128 | |
9e1fa0a6 |
129 | void p32x_pwm_sync_to_sh2(SH2 *sh2) |
130 | { |
131 | int m68k_cycles = sh2_cycles_done_m68k(sh2); |
132 | consume_fifo(sh2, m68k_cycles); |
133 | } |
134 | |
df63f1a6 |
135 | void p32x_pwm_irq_event(unsigned int m68k_now) |
136 | { |
137 | p32x_pwm_schedule(m68k_now); |
138 | } |
139 | |
c1931173 |
140 | unsigned int p32x_pwm_read16(unsigned int a, SH2 *sh2, |
141 | unsigned int m68k_cycles) |
db1d3564 |
142 | { |
143 | unsigned int d = 0; |
a7f82a77 |
144 | |
c1931173 |
145 | consume_fifo(sh2, m68k_cycles); |
db1d3564 |
146 | |
147 | a &= 0x0e; |
148 | switch (a) { |
149 | case 0: // control |
150 | case 2: // cycle |
a7f82a77 |
151 | d = Pico32x.regs[(0x30 + a) / 2]; |
152 | break; |
db1d3564 |
153 | |
154 | case 4: // L ch |
a7f82a77 |
155 | if (Pico32x.pwm_p[0] == 3) |
156 | d |= P32XP_FULL; |
157 | else if (Pico32x.pwm_p[0] == 0) |
158 | d |= P32XP_EMPTY; |
159 | break; |
160 | |
db1d3564 |
161 | case 6: // R ch |
162 | case 8: // MONO |
a7f82a77 |
163 | if (Pico32x.pwm_p[1] == 3) |
db1d3564 |
164 | d |= P32XP_FULL; |
a7f82a77 |
165 | else if (Pico32x.pwm_p[1] == 0) |
db1d3564 |
166 | d |= P32XP_EMPTY; |
167 | break; |
168 | } |
169 | |
df63f1a6 |
170 | elprintf(EL_PWM, "pwm: %u: r16 %02x %04x (p %d %d)", |
171 | m68k_cycles, a, d, Pico32x.pwm_p[0], Pico32x.pwm_p[1]); |
db1d3564 |
172 | return d; |
173 | } |
174 | |
df63f1a6 |
175 | void p32x_pwm_write16(unsigned int a, unsigned int d, |
c1931173 |
176 | SH2 *sh2, unsigned int m68k_cycles) |
db1d3564 |
177 | { |
df63f1a6 |
178 | elprintf(EL_PWM, "pwm: %u: w16 %02x %04x (p %d %d)", |
179 | m68k_cycles, a & 0x0e, d, Pico32x.pwm_p[0], Pico32x.pwm_p[1]); |
180 | |
c1931173 |
181 | consume_fifo(sh2, m68k_cycles); |
a7f82a77 |
182 | |
db1d3564 |
183 | a &= 0x0e; |
a7f82a77 |
184 | if (a == 0) { // control |
185 | // supposedly we should stop FIFO when xMd is 0, |
186 | // but mars test disagrees |
db1d3564 |
187 | Pico32x.regs[0x30 / 2] = d; |
045a4c52 |
188 | p32x_pwm_ctl_changed(); |
df63f1a6 |
189 | Pico32x.pwm_irq_cnt = pwm_irq_reload; // ? |
a7f82a77 |
190 | } |
db1d3564 |
191 | else if (a == 2) { // cycle |
192 | Pico32x.regs[0x32 / 2] = d & 0x0fff; |
045a4c52 |
193 | p32x_pwm_ctl_changed(); |
db1d3564 |
194 | } |
195 | else if (a <= 8) { |
a7f82a77 |
196 | d = (d - 1) & 0x0fff; |
db1d3564 |
197 | if (d > pwm_cycles) |
198 | d = pwm_cycles; |
199 | d = (d - pwm_cycles / 2) * pwm_mult; |
200 | |
a7f82a77 |
201 | if (a == 4 || a == 8) { // L ch or MONO |
202 | short *fifo = Pico32xMem->pwm_fifo[0]; |
203 | if (Pico32x.pwm_p[0] < 3) |
204 | Pico32x.pwm_p[0]++; |
205 | else { |
206 | fifo[1] = fifo[2]; |
207 | fifo[2] = fifo[3]; |
208 | } |
209 | fifo[Pico32x.pwm_p[0]] = d; |
210 | } |
211 | if (a == 6 || a == 8) { // R ch or MONO |
212 | short *fifo = Pico32xMem->pwm_fifo[1]; |
213 | if (Pico32x.pwm_p[1] < 3) |
214 | Pico32x.pwm_p[1]++; |
215 | else { |
216 | fifo[1] = fifo[2]; |
217 | fifo[2] = fifo[3]; |
218 | } |
219 | fifo[Pico32x.pwm_p[1]] = d; |
db1d3564 |
220 | } |
221 | } |
222 | } |
223 | |
224 | void p32x_pwm_update(int *buf32, int length, int stereo) |
225 | { |
db1d3564 |
226 | short *pwmb; |
227 | int step; |
228 | int p = 0; |
a7f82a77 |
229 | int xmd; |
db1d3564 |
230 | |
8ad1d2ad |
231 | consume_fifo(NULL, SekCyclesDoneT2()); |
232 | |
a7f82a77 |
233 | xmd = Pico32x.regs[0x30 / 2] & 0x0f; |
8ad1d2ad |
234 | if (xmd == 0 || xmd == 0x06 || xmd == 0x09 || xmd == 0x0f) |
235 | goto out; // invalid? |
db1d3564 |
236 | |
8ad1d2ad |
237 | step = (pwm_ptr << 16) / length; |
db1d3564 |
238 | pwmb = Pico32xMem->pwm; |
239 | |
240 | if (stereo) |
241 | { |
8ad1d2ad |
242 | if (xmd == 0x05) { |
243 | // normal |
244 | while (length-- > 0) { |
245 | *buf32++ += pwmb[0]; |
246 | *buf32++ += pwmb[1]; |
247 | |
248 | p += step; |
249 | pwmb += (p >> 16) * 2; |
250 | p &= 0xffff; |
251 | } |
252 | } |
253 | else if (xmd == 0x0a) { |
a7f82a77 |
254 | // channel swap |
255 | while (length-- > 0) { |
256 | *buf32++ += pwmb[1]; |
257 | *buf32++ += pwmb[0]; |
db1d3564 |
258 | |
a7f82a77 |
259 | p += step; |
260 | pwmb += (p >> 16) * 2; |
261 | p &= 0xffff; |
262 | } |
263 | } |
264 | else { |
8ad1d2ad |
265 | // mono - LMD, RMD specify dst |
266 | if (xmd & 0x06) // src is R |
267 | pwmb++; |
268 | if (xmd & 0x0c) // dst is R |
269 | buf32++; |
a7f82a77 |
270 | while (length-- > 0) { |
8ad1d2ad |
271 | *buf32 += *pwmb; |
a7f82a77 |
272 | |
273 | p += step; |
274 | pwmb += (p >> 16) * 2; |
275 | p &= 0xffff; |
8ad1d2ad |
276 | buf32 += 2; |
a7f82a77 |
277 | } |
db1d3564 |
278 | } |
279 | } |
280 | else |
281 | { |
8ad1d2ad |
282 | // mostly unused |
db1d3564 |
283 | while (length-- > 0) { |
284 | *buf32++ += pwmb[0]; |
285 | |
286 | p += step; |
287 | pwmb += (p >> 16) * 2; |
288 | p &= 0xffff; |
289 | } |
290 | } |
291 | |
1b3f5844 |
292 | elprintf(EL_PWM, "pwm_update: pwm_ptr %d, len %d, step %04x, done %d", |
db1d3564 |
293 | pwm_ptr, length, step, (pwmb - Pico32xMem->pwm) / 2); |
294 | |
a7f82a77 |
295 | out: |
db1d3564 |
296 | pwm_ptr = 0; |
297 | } |
298 | |
df63f1a6 |
299 | void p32x_pwm_state_loaded(void) |
300 | { |
301 | int cycles_diff_sh2; |
302 | |
045a4c52 |
303 | p32x_pwm_ctl_changed(); |
df63f1a6 |
304 | |
305 | // for old savestates |
306 | cycles_diff_sh2 = SekCycleCntT * 3 - Pico32x.pwm_cycle_p; |
307 | if (cycles_diff_sh2 >= pwm_cycles || cycles_diff_sh2 < 0) { |
308 | Pico32x.pwm_irq_cnt = pwm_irq_reload; |
309 | Pico32x.pwm_cycle_p = SekCycleCntT * 3; |
310 | p32x_pwm_schedule(SekCycleCntT); |
311 | } |
312 | } |
313 | |
a8fd6e37 |
314 | // vim:shiftwidth=2:ts=2:expandtab |