1 /*
2 * Code for communication with ARM940 and control of it.
3 * (C) notaz, 2006-2009
4 *
5 * This work is licensed under the terms of MAME license.
6 * See COPYING file in the top-level directory.
7 */
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <unistd.h>
13 #include <sys/mman.h>
14 #include <sys/ioctl.h>
15 #include <fcntl.h>
16 #include <errno.h>
17
18 #include "../libpicofe/input.h"
19 #include "../libpicofe/gp2x/soc_mmsp2.h"
20 #include "../libpicofe/gp2x/soc.h"
21 #include "../common/mp3.h"
22 #include "../common/arm_utils.h"
23 #include "../common/menu_pico.h"
24 #include "../common/emu.h"
25 #include "../../pico/pico_int.h"
26 #include "../../pico/sound/ym2612.h"
27 #include "../../pico/sound/mix.h"
28 #include "code940/940shared.h"
29 #include "plat.h"
30 #include "940ctl.h"
31
32 static unsigned char *shared_mem = 0;
33 static _940_data_t *shared_data = 0;
34 _940_ctl_t *shared_ctl = 0;
35 unsigned char *mp3_mem = 0;
36
37 #define MP3_SIZE_MAX (0x400000 + 0x800000) // 12M
38 #define CODE940_FILE "pico940_v3.bin"
39
40 int crashed_940 = 0;
41
42 static FILE *loaded_mp3 = 0;
43
44 /***********************************************************/
45
46 #define MAXOUT (+32767)
47 #define MINOUT (-32768)
48
49 /* limitter */
50 #define Limit(val, max,min) { \
51 if ( val > max ) val = max; \
52 else if ( val < min ) val = min; \
53 }
54
55 /* these will be managed locally on our side */
56 static UINT8 ST_address; /* address register */
57 static INT32 addr_A1; /* address line A1 */
58
59 static int writebuff_ptr = 0;
60
61
62 /* YM2612 write */
63 /* a = address */
64 /* v = value */
65 /* returns 1 if sample affecting state changed */
YM2612Write_940(unsigned int a,unsigned int v,int scanline)66 int YM2612Write_940(unsigned int a, unsigned int v, int scanline)
67 {
68 int upd = 1; /* the write affects sample generation */
69
70 a &= 3;
71
72 //printf("%05i:%03i: ym w ([%i] %02x)\n", Pico.m.frame_count, Pico.m.scanline, a, v);
73
74 switch (a)
75 {
76 case 0: /* address port 0 */
77 if (addr_A1 == 0 && ST_address == v)
78 return 0; /* address already selected, don't send this command to 940 */
79 ST_address = v;
80 addr_A1 = 0;
81 /* don't send DAC or timer related address changes to 940 */
82 if (v == 0x24 || v == 0x25 || v == 0x26 || v == 0x2a)
83 return 0;
84 upd = 0;
85 break;
86
87 case 2: /* address port 1 */
88 if (addr_A1 == 1 && ST_address == v)
89 return 0;
90 ST_address = v;
91 addr_A1 = 1;
92 upd = 0;
93 break;
94 }
95
96 //printf("ym pass\n");
97
98 if (currentConfig.EmuOpt & 4)
99 {
100 UINT16 *writebuff = shared_ctl->writebuffsel ? shared_ctl->writebuff0 : shared_ctl->writebuff1;
101
102 /* detect rapid ym updates */
103 if (upd && !(writebuff_ptr & 0x80000000) && scanline < 224)
104 {
105 int mid = Pico.m.pal ? 68 : 93;
106 if (scanline > mid) {
107 //printf("%05i:%03i: rapid ym\n", Pico.m.frame_count, scanline);
108 writebuff[writebuff_ptr++ & 0xffff] = 0xfffe;
109 writebuff_ptr |= 0x80000000;
110 //printf("%05i:%03i: ym w ([%02x] %02x, upd=%i)\n", Pico.m.frame_count, scanline, addr, v, upd);
111 }
112 }
113
114 /* queue this write for 940 */
115 if ((writebuff_ptr&0xffff) < 2047) {
116 writebuff[writebuff_ptr++ & 0xffff] = (a<<8)|v;
117 } else {
118 printf("warning: writebuff_ptr > 2047 ([%i] %02x)\n", a, v);
119 }
120 }
121
122 return 0; // cause the engine to do updates once per frame only
123 }
124
125
126 #define CHECK_BUSY(job) \
127 (memregs[0x3b46>>1] & (1<<(job-1)))
128
wait_busy_940(int job)129 static void wait_busy_940(int job)
130 {
131 int i;
132
133 job--;
134 for (i = 0; (memregs[0x3b46>>1] & (1<<job)) && i < 0x10000; i++)
135 spend_cycles(8*1024); // tested to be best for mp3 dec
136 if (i < 0x10000) return;
137
138 /* 940 crashed */
139 printf("940 crashed (cnt: %i, ve: ", shared_ctl->loopc);
140 for (i = 0; i < 8; i++)
141 printf("%i ", shared_ctl->vstarts[i]);
142 printf(")\n");
143 printf("irq pending flags: DUALCPU %04x, SRCPND %08x (see 26), INTPND %08x\n",
144 memregs[0x3b46>>1], memregl[0x4500>>2], memregl[0x4510>>2]);
145 printf("last lr: %08x, lastjob: %i\n", shared_ctl->last_lr, shared_ctl->lastjob);
146 printf("trying to interrupt..\n");
147 memregs[0x3B3E>>1] = 0xffff;
148 for (i = 0; memregs[0x3b46>>1] && i < 0x10000; i++)
149 spend_cycles(8*1024);
150 printf("i = 0x%x\n", i);
151 printf("irq pending flags: DUALCPU %04x, SRCPND %08x (see 26), INTPND %08x\n",
152 memregs[0x3b46>>1], memregl[0x4500>>2], memregl[0x4510>>2]);
153 printf("last lr: %08x, lastjob: %i\n", shared_ctl->last_lr, shared_ctl->lastjob);
154
155 menu_update_msg("940 crashed, too much overclock?");
156 engineState = PGS_Menu;
157 crashed_940 = 1;
158 }
159
160
add_job_940(int job)161 static void add_job_940(int job)
162 {
163 if (job <= 0 || job > 16) {
164 printf("add_job_940: bad job: %i\n", job);
165 return;
166 }
167
168 // generate interrupt for this job
169 job--;
170 memregs[(0x3B20+job*2)>>1] = 1;
171
172 // printf("added %i, pending %04x\n", job+1, memregs[0x3b46>>1]);
173 }
174
175
YM2612PicoStateLoad_940(void)176 void YM2612PicoStateLoad_940(void)
177 {
178 UINT8 *REGS = YM2612GetRegs();
179
180 /* make sure JOB940_PICOSTATELOAD gets done before next JOB940_YM2612UPDATEONE */
181 add_job_940(JOB940_PICOSTATELOAD);
182 if (CHECK_BUSY(JOB940_PICOSTATELOAD)) wait_busy_940(JOB940_PICOSTATELOAD);
183
184 writebuff_ptr = 0;
185 addr_A1 = *(INT32 *) (REGS + 0x200);
186 }
187
YM2612PicoStateSave2_940(int tat,int tbt)188 void YM2612PicoStateSave2_940(int tat, int tbt)
189 {
190 UINT8 *ym_remote_regs, *ym_local_regs;
191 add_job_940(JOB940_PICOSTATESAVE2);
192 if (CHECK_BUSY(JOB940_PICOSTATESAVE2)) wait_busy_940(JOB940_PICOSTATESAVE2);
193
194 ym_remote_regs = (UINT8 *) shared_ctl->writebuff0;
195 ym_local_regs = YM2612GetRegs();
196 if (*(UINT32 *)(ym_remote_regs + 0x100) != 0x41534d59) {
197 printf("code940 didn't return valid save data\n");
198 return;
199 }
200
201 /* copy addin data only */
202 memcpy(ym_local_regs, ym_remote_regs, 0x20);
203 memcpy(ym_local_regs + 0x100, ym_remote_regs + 0x100, 0x30);
204 memcpy(ym_local_regs + 0x0b8, ym_remote_regs + 0x0b8, 0x48);
205 memcpy(ym_local_regs + 0x1b8, ym_remote_regs + 0x1b8, 0x48);
206 *(INT32 *)(ym_local_regs + 0x108) = tat;
207 *(INT32 *)(ym_local_regs + 0x10c) = tbt;
208 }
209
YM2612PicoStateLoad2_940(int * tat,int * tbt)210 int YM2612PicoStateLoad2_940(int *tat, int *tbt)
211 {
212 UINT8 *ym_remote_regs, *ym_local_regs;
213 ym_local_regs = YM2612GetRegs();
214 ym_remote_regs = (UINT8 *) shared_ctl->writebuff0;
215
216 if (*(UINT32 *)(ym_local_regs + 0x100) != 0x41534d59)
217 return -1;
218
219 *tat = *(INT32 *)(ym_local_regs + 0x108);
220 *tbt = *(INT32 *)(ym_local_regs + 0x10c);
221
222 if (CHECK_BUSY(JOB940_YM2612UPDATEONE)) wait_busy_940(JOB940_YM2612UPDATEONE);
223
224 /* flush writes */
225 if (shared_ctl->writebuffsel == 1) {
226 shared_ctl->writebuff0[writebuff_ptr & 0xffff] = 0xffff;
227 } else {
228 shared_ctl->writebuff1[writebuff_ptr & 0xffff] = 0xffff;
229 }
230 shared_ctl->writebuffsel ^= 1;
231 writebuff_ptr = 0;
232 add_job_940(JOB940_PICOSTATELOAD2_PREP);
233 if (CHECK_BUSY(JOB940_PICOSTATELOAD2_PREP)) wait_busy_940(JOB940_PICOSTATELOAD2_PREP);
234
235 memcpy(ym_remote_regs, ym_local_regs, 0x200);
236
237 add_job_940(JOB940_PICOSTATELOAD2);
238 if (CHECK_BUSY(JOB940_PICOSTATELOAD2)) wait_busy_940(JOB940_PICOSTATELOAD2);
239
240 return 0;
241 }
242
243
internal_reset(void)244 static void internal_reset(void)
245 {
246 writebuff_ptr = 0;
247 ST_address = addr_A1 = -1;
248 }
249
250
251 /* this must be called after mmu hack, the allocated regions must not get cached */
sharedmem940_init(void)252 void sharedmem940_init(void)
253 {
254 if (shared_mem != NULL) return;
255
256 shared_mem = (unsigned char *) mmap(0, 0x210000, PROT_READ|PROT_WRITE, MAP_SHARED, memdev, 0x2000000);
257 if (shared_mem == MAP_FAILED)
258 {
259 printf("mmap(shared_data) failed with %i\n", errno);
260 exit(1);
261 }
262 shared_data = (_940_data_t *) (shared_mem+0x100000);
263 /* this area must not get buffered on either side */
264 shared_ctl = (_940_ctl_t *) (shared_mem+0x200000);
265 mp3_mem = (unsigned char *) mmap(0, MP3_SIZE_MAX, PROT_READ|PROT_WRITE, MAP_SHARED, memdev, 0x2400000);
266 if (mp3_mem == MAP_FAILED)
267 {
268 printf("mmap(mp3_mem) failed with %i\n", errno);
269 exit(1);
270 }
271 crashed_940 = 1;
272 }
273
274
sharedmem940_finish(void)275 void sharedmem940_finish(void)
276 {
277 munmap(shared_mem, 0x210000);
278 munmap(mp3_mem, MP3_SIZE_MAX);
279 shared_mem = mp3_mem = NULL;
280 shared_data = NULL;
281 shared_ctl = NULL;
282 }
283
284
YM2612Init_940(int baseclock,int rate)285 void YM2612Init_940(int baseclock, int rate)
286 {
287 static int oldrate;
288
289 // HACK
290 if (Pico.m.frame_count > 0 && !crashed_940 && rate == oldrate)
291 return;
292
293 printf("YM2612Init_940()\n");
294 printf("Mem usage: shared_data: %i, shared_ctl: %i\n", sizeof(*shared_data), sizeof(*shared_ctl));
295
296 reset940(1, 2);
297 pause940(1);
298
299 memregs[0x3B40>>1] = 0; // disable DUALCPU interrupts for 920
300 memregs[0x3B42>>1] = 1; // enable DUALCPU interrupts for 940
301
302 memregl[0x4504>>2] = 0; // make sure no FIQs will be generated
303 memregl[0x4508>>2] = ~(1<<26); // unmask DUALCPU ints in the undocumented 940's interrupt controller
304
305
306 if (crashed_940)
307 {
308 unsigned char ucData[1024];
309 int nRead, nLen = 0;
310 char binpath[512];
311 FILE *fp;
312
313 emu_make_path(binpath, CODE940_FILE, sizeof(binpath));
314 fp = fopen(binpath, "rb");
315 if(!fp)
316 {
317 memset(g_screen_ptr, 0, 320*240*2);
318 text_out16(10, 100, "failed to open required file:");
319 text_out16(10, 110, CODE940_FILE);
320 gp2x_video_flip2();
321 in_menu_wait(PBTN_MOK|PBTN_MBACK, NULL, 100);
322 printf("failed to open %s\n", binpath);
323 exit(1);
324 }
325
326 while(1)
327 {
328 nRead = fread(ucData, 1, 1024, fp);
329 if(nRead <= 0)
330 break;
331 memcpy(shared_mem + nLen, ucData, nRead);
332 nLen += nRead;
333 }
334 fclose(fp);
335 crashed_940 = 0;
336 }
337
338 memset(shared_data, 0, sizeof(*shared_data));
339 memset(shared_ctl, 0, sizeof(*shared_ctl));
340
341 /* cause local ym2612 to init REGS */
342 YM2612Init_(baseclock, rate);
343
344 internal_reset();
345
346 loaded_mp3 = NULL;
347
348 memregs[0x3B46>>1] = 0xffff; // clear pending DUALCPU interrupts for 940
349 memregl[0x4500>>2] = 0xffffffff; // clear pending IRQs in SRCPND
350 memregl[0x4510>>2] = 0xffffffff; // clear pending IRQs in INTPND
351
352 /* start the 940 */
353 reset940(0, 2);
354 pause940(0);
355
356 // YM2612ResetChip_940(); // will be done on JOB940_YM2612INIT
357
358 /* now cause 940 to init it's ym2612 stuff */
359 shared_ctl->baseclock = baseclock;
360 shared_ctl->rate = rate;
361 add_job_940(JOB940_INITALL);
362
363 oldrate = rate;
364 }
365
366
YM2612ResetChip_940(void)367 void YM2612ResetChip_940(void)
368 {
369 //printf("YM2612ResetChip_940()\n");
370 if (shared_data == NULL) {
371 printf("YM2612ResetChip_940: reset before init?\n");
372 return;
373 }
374
375 YM2612ResetChip_();
376 internal_reset();
377
378 add_job_940(JOB940_YM2612RESETCHIP);
379 }
380
381
YM2612UpdateOne_940(int * buffer,int length,int stereo,int is_buf_empty)382 int YM2612UpdateOne_940(int *buffer, int length, int stereo, int is_buf_empty)
383 {
384 int *ym_buf = shared_data->ym_buffer;
385 int ym_active_chs;
386
387 //printf("YM2612UpdateOne_940()\n");
388
389 if (CHECK_BUSY(JOB940_YM2612UPDATEONE)) wait_busy_940(JOB940_YM2612UPDATEONE);
390
391 ym_active_chs = shared_ctl->ym_active_chs;
392
393 // mix in ym buffer. is_buf_empty means nobody mixed there anything yet and it may contain trash
394 if (is_buf_empty && ym_active_chs) memcpy(buffer, ym_buf, length << (stereo + 2));
395 else memset32(buffer, 0, length<<stereo);
396
397 if (shared_ctl->writebuffsel == 1) {
398 shared_ctl->writebuff0[writebuff_ptr & 0xffff] = 0xffff;
399 } else {
400 shared_ctl->writebuff1[writebuff_ptr & 0xffff] = 0xffff;
401 }
402 writebuff_ptr = 0;
403
404 /* predict sample counter for next frame */
405 if (Pico.snd.len_e_add) {
406 length = Pico.snd.len;
407 if (Pico.snd.len_e_cnt + Pico.snd.len_e_add >= 0x10000) length++;
408 }
409
410 /* give 940 ym job */
411 shared_ctl->writebuffsel ^= 1;
412 shared_ctl->length = length;
413 shared_ctl->stereo = stereo;
414
415 add_job_940(JOB940_YM2612UPDATEONE);
416
417 return ym_active_chs;
418 }
419
420
421 /***********************************************************/
422
423 // FIXME: double buffering no longer used..
424
mp3dec_decode(FILE * f,int * file_pos,int file_len)425 int mp3dec_decode(FILE *f, int *file_pos, int file_len)
426 {
427 if (!(PicoIn.opt & POPT_EXT_FM)) {
428 //mp3_update_local(buffer, length, stereo);
429 return 0;
430 }
431
432 // check if playback was started, track not ended
433 if (loaded_mp3 == NULL || shared_ctl->mp3_offs >= shared_ctl->mp3_len) {
434 *file_pos = file_len;
435 return 1;
436 }
437
438 /* do we have to wait? */
439 if (CHECK_BUSY(JOB940_MP3DECODE))
440 wait_busy_940(JOB940_MP3DECODE);
441
442 memcpy(cdda_out_buffer,
443 shared_data->mp3_buffer[shared_ctl->mp3_buffsel],
444 sizeof(cdda_out_buffer));
445
446 *file_pos = shared_ctl->mp3_offs;
447
448 if (shared_ctl->mp3_offs < shared_ctl->mp3_len) {
449 // ask to decode more
450 //shared_ctl->mp3_buffsel ^= 1;
451 add_job_940(JOB940_MP3DECODE);
452 }
453
454 return 0;
455 }
456
mp3dec_start(FILE * f,int fpos_start)457 int mp3dec_start(FILE *f, int fpos_start)
458 {
459 if (!(PicoIn.opt & POPT_EXT_FM)) {
460 //mp3_start_play_local(f, pos);
461 return -1;
462 }
463
464 if (loaded_mp3 != f)
465 {
466 if (PicoIn.osdMessage != NULL)
467 {
468 fseek(f, 0, SEEK_END);
469 if (ftell(f) > 2*1024*1024)
470 PicoIn.osdMessage("Loading MP3...");
471 }
472 fseek(f, 0, SEEK_SET);
473 fread(mp3_mem, 1, MP3_SIZE_MAX, f);
474 if (!feof(f))
475 printf("Warning: mp3 was too large, not all data loaded.\n");
476 shared_ctl->mp3_len = ftell(f);
477 loaded_mp3 = f;
478
479 // as we are going to change 940's cacheable area,
480 // we must invalidate it's cache..
481 if (CHECK_BUSY(JOB940_MP3DECODE))
482 wait_busy_940(JOB940_MP3DECODE);
483 add_job_940(JOB940_INVALIDATE_DCACHE);
484 reset_timing = 1;
485 }
486
487 shared_ctl->mp3_offs = fpos_start;
488 shared_ctl->mp3_buffsel = 0;
489
490 add_job_940(JOB940_MP3RESET);
491 if (CHECK_BUSY(JOB940_MP3RESET))
492 wait_busy_940(JOB940_MP3RESET);
493
494 // because we decode ahea, need to start now
495 if (shared_ctl->mp3_offs < shared_ctl->mp3_len) {
496 add_job_940(JOB940_MP3DECODE);
497 }
498
499 return 0;
500 }
501
502