testpico: check busy after dma
[megadrive.git] / testpico / main.c
1 /*
2  * This software is released into the public domain.
3  * See UNLICENSE file in top level directory.
4  */
5 #include <stdlib.h>
6 #include <stdarg.h>
7 #include "common.h"
8 #include "asmtools.h"
9 //#pragma GCC diagnostic ignored "-Wunused-function"
10
11 #define VDP_DATA_PORT    0xC00000
12 #define VDP_CTRL_PORT    0xC00004
13 #define VDP_HV_COUNTER   0xC00008
14
15 #define TILE_MEM_END     0xB000
16
17 #define FONT_LEN         128
18 #define TILE_FONT_BASE   (TILE_MEM_END - FONT_LEN * 32)
19
20 /* note: using ED menu's layout here.. */
21 #define WPLANE           (TILE_MEM_END + 0x0000)
22 #define HSCRL            (TILE_MEM_END + 0x0800)
23 #define SLIST            (TILE_MEM_END + 0x0C00)
24 #define APLANE           (TILE_MEM_END + 0x1000)
25 #define BPLANE           (TILE_MEM_END + 0x3000)
26
27 #define write16_z80le(a, d) \
28     ((volatile u8 *)(a))[0] = (u8)(d), \
29     ((volatile u8 *)(a))[1] = ((d) >> 8)
30
31 static inline u16 read16_z80le(const void *a_)
32 {
33     volatile const u8 *a = (volatile const u8 *)a_;
34     return a[0] | ((u16)a[1] << 8);
35 }
36
37 #define CTL_WRITE_VRAM(adr) \
38     (((0x4000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x00)
39 #define CTL_WRITE_VSRAM(adr) \
40     (((0x4000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x10)
41 #define CTL_WRITE_CRAM(adr) \
42     (((0xC000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x00)
43 #define CTL_READ_VRAM(adr) \
44     (((0x0000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x00)
45 #define CTL_READ_VSRAM(adr) \
46     (((0x0000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x10)
47 #define CTL_READ_CRAM(adr) \
48     (((0x0000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x20)
49
50 #define CTL_WRITE_DMA 0x80
51
52 #define VDP_setReg(r, v) \
53     write16(VDP_CTRL_PORT, 0x8000 | ((r) << 8) | ((v) & 0xff))
54
55 enum {
56     VDP_MODE1 = 0x00,
57     VDP_MODE2 = 0x01,
58     VDP_NT_SCROLLA = 0x02,
59     VDP_NT_WIN = 0x03,
60     VDP_NT_SCROLLB = 0x04,
61     VDP_SAT_BASE = 0x05,
62     VDP_BACKDROP = 0x07,
63     VDP_MODE3 = 0x0b,
64     VDP_MODE4 = 0x0c,
65     VDP_HSCROLL = 0x0d,
66     VDP_AUTOINC = 0x0f,
67     VDP_SCROLLSZ = 0x10,
68     VDP_DMA_LEN0 = 0x13,
69     VDP_DMA_LEN1 = 0x14,
70     VDP_DMA_SRC0 = 0x15,
71     VDP_DMA_SRC1 = 0x16,
72     VDP_DMA_SRC2 = 0x17,
73 };
74
75 #define VDP_MODE1_PS   0x04
76 #define VDP_MODE1_IE1  0x10 // h int
77 #define VDP_MODE2_MD   0x04
78 #define VDP_MODE2_PAL  0x08 // 30 col
79 #define VDP_MODE2_DMA  0x10
80 #define VDP_MODE2_IE0  0x20 // v int
81 #define VDP_MODE2_DISP 0x40
82 #define VDP_MODE2_128K 0x80
83
84 #define SR_PAL        (1 << 0)
85 #define SR_DMA        (1 << 1)
86 #define SR_HB         (1 << 2)
87 #define SR_VB         (1 << 3)
88 #define SR_ODD        (1 << 4)
89 #define SR_C          (1 << 5)
90 #define SR_SOVR       (1 << 6)
91 #define SR_F          (1 << 7)
92 #define SR_FULL       (1 << 8)
93 #define SR_EMPT       (1 << 9)
94
95 /* cell counts */
96 #define LEFT_BORDER 1   /* lame TV */
97 #define PLANE_W 64
98 #define PLANE_H 32
99 #define CSCREEN_H 28
100
101 /* data.s */
102 extern const u32 font_base[];
103 extern const u8 z80_test[];
104 extern const u8 z80_test_end[];
105
106 static int text_pal;
107
108 static noinline void VDP_drawTextML(const char *str, u16 plane_base,
109     u16 x, u16 y)
110 {
111     const u8 *src = (const u8 *)str;
112     u16 basetile = text_pal << 13;
113     int max_len = 40 - LEFT_BORDER;
114     int len;
115     u32 addr;
116
117     x += LEFT_BORDER;
118
119     for (len = 0; str[len] && len < max_len; len++)
120         ;
121     if (len > (PLANE_W - x))
122         len = PLANE_W - x;
123
124     addr = plane_base + ((x + (PLANE_W * y)) << 1);
125     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(addr));
126
127     while (len-- > 0) {
128         write16(VDP_DATA_PORT,
129             basetile | ((*src++) - 32 + TILE_FONT_BASE / 32));
130     }
131 }
132
133 static int printf_ypos;
134
135 static void printf_line(int x, const char *buf)
136 {
137     u32 addr;
138     int i;
139
140     VDP_drawTextML(buf, APLANE, x, printf_ypos++ & (PLANE_H - 1));
141
142     if (printf_ypos >= CSCREEN_H) {
143         /* clear next line */
144         addr = APLANE;
145         addr += (PLANE_W * (printf_ypos & (PLANE_H - 1))) << 1;
146         write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(addr));
147         for (i = 0; i < 40 / 2; i++)
148             write32(VDP_DATA_PORT, 0);
149
150         /* scroll plane */
151         write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(0));
152         write16(VDP_DATA_PORT, (printf_ypos - CSCREEN_H + 1) * 8);
153     }
154 }
155
156 #define PRINTF_LEN 40
157
158 static int printf_xpos;
159
160 static noinline int printf(const char *fmt, ...)
161 {
162     static const char hexchars[] = "0123456789abcdef";
163     char c, buf[PRINTF_LEN + 11 + 1];
164     const char *s;
165     va_list ap;
166     int ival;
167     u32 uval;
168     int d = 0;
169     int i, j;
170
171     va_start(ap, fmt);
172     for (d = 0; *fmt; ) {
173         int prefix0 = 0;
174         int fwidth = 0;
175
176         c = *fmt++;
177         if (d < PRINTF_LEN)
178             buf[d] = c;
179
180         if (c != '%') {
181             if (c == '\n') {
182                 buf[d] = 0;
183                 printf_line(printf_xpos, buf);
184                 d = 0;
185                 printf_xpos = 0;
186                 continue;
187             }
188             d++;
189             continue;
190         }
191         if (d >= PRINTF_LEN)
192             continue;
193
194         if (*fmt == '0') {
195             prefix0 = 1;
196             fmt++;
197         }
198
199         while ('1' <= *fmt && *fmt <= '9') {
200             fwidth = fwidth * 10 + *fmt - '0';
201             fmt++;
202         }
203
204         switch (*fmt++) {
205         case '%':
206             d++;
207             break;
208         case 'd':
209         case 'i':
210             ival = va_arg(ap, int);
211             if (ival < 0) {
212                 buf[d++] = '-';
213                 ival = -ival;
214             }
215             for (i = 1000000000; i >= 10; i /= 10)
216                 if (ival >= i)
217                     break;
218             for (; i >= 10; i /= 10) {
219                 buf[d++] = '0' + ival / i;
220                 ival %= i;
221             }
222             buf[d++] = '0' + ival;
223             break;
224         case 'x':
225             uval = va_arg(ap, int);
226             while (fwidth > 1 && uval < (1 << (fwidth - 1) * 4)) {
227                 buf[d++] = prefix0 ? '0' : ' ';
228                 fwidth--;
229             }
230             for (j = 1; j < 8 && uval >= (1 << j * 4); j++)
231                 ;
232             for (j--; j >= 0; j--)
233                 buf[d++] = hexchars[(uval >> j * 4) & 0x0f];
234             break;
235         case 'c':
236             buf[d++] = va_arg(ap, int);
237             break;
238         case 's':
239             s = va_arg(ap, char *);
240             while (*s && d < PRINTF_LEN)
241                 buf[d++] = *s++;
242             break;
243         default:
244             // don't handle, for now
245             d++;
246             va_arg(ap, void *);
247             break;
248         }
249     }
250     buf[d] = 0;
251     va_end(ap);
252
253     if (d != 0) {
254         // line without \n
255         VDP_drawTextML(buf, APLANE, printf_xpos,
256             printf_ypos & (PLANE_H - 1));
257         printf_xpos += d;
258     }
259
260     return d; // wrong..
261 }
262
263 static const char *exc_names[] = {
264     NULL,
265     NULL,
266     "Bus Error",
267     "Address Error",
268     "Illegal Instruction",
269     "Zero Divide",
270     "CHK Instruction",
271     "TRAPV Instruction",
272     "Privilege Violation",  /*  8  8 */
273     "Trace",
274     "Line 1010 Emulator",
275     "Line 1111 Emulator",
276     NULL,
277     NULL,
278     NULL,
279     "Uninitialized Interrupt",
280     NULL,                   /* 10 16 */
281     NULL,
282     NULL,
283     NULL,
284     NULL,
285     NULL,
286     NULL,
287     NULL,
288     "Spurious Interrupt",   /* 18 24 */
289     "l1 irq",
290     "l2 irq",
291     "l3 irq",
292     "l4 irq",
293     "l5 irq",
294     "l6 irq",
295     "l7 irq",
296 };
297
298 struct exc_frame {
299     u32 dr[8];
300     u32 ar[8];
301     u16 ecxnum; // from handler
302     union {
303         struct {
304             u16 sr;
305             u32 pc;
306         } g _packed;
307         struct {
308             u16 fc;
309             u32 addr;
310             u16 ir;
311             u16 sr;
312             u32 pc;
313         } bae _packed; // bus/address error frame
314     };
315 } _packed;
316
317 void exception(const struct exc_frame *f)
318 {
319     u32 *sp, sp_add;
320     int i;
321
322     while (read16(VDP_CTRL_PORT) & 2)
323         ;
324     VDP_setReg(VDP_MODE1, VDP_MODE1_PS);
325     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DISP);
326     /* adjust scroll */
327     write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(0));
328     write16(VDP_DATA_PORT,
329       printf_ypos >= CSCREEN_H ?
330         (printf_ypos - CSCREEN_H + 1) * 8 : 0);
331
332     printf("exception %i ", f->ecxnum);
333     if (f->ecxnum < ARRAY_SIZE(exc_names) && exc_names[f->ecxnum] != NULL)
334         printf("(%s)", exc_names[f->ecxnum]);
335     if (f->ecxnum < 4)
336         printf(" (%s)", (f->bae.fc & 0x10) ? "r" : "w");
337     printf("    \n");
338
339     if (f->ecxnum < 4) {
340         printf("  PC: %08x SR: %04x            \n", f->bae.pc, f->bae.sr);
341         printf("addr: %08x IR: %04x FC: %02x   \n",
342                f->bae.addr, f->bae.ir, f->bae.fc);
343         sp_add = 14;
344     }
345     else {
346         printf("  PC: %08x SR: %04x            \n", f->g.pc, f->g.sr);
347         sp_add = 6;
348     }
349     sp = (u32 *)(f->ar[7] + sp_add);
350     for (i = 0; i < 7; i++)
351         printf("  D%d: %08x A%d: %08x    \n", i, f->dr[i], i, f->ar[i]);
352     printf("  D%d: %08x SP: %08x    \n", i, f->dr[i], (u32)sp);
353     printf("                               \n");
354     printf(" %08x %08x %08x %08x\n", sp[0], sp[1], sp[2], sp[3]);
355     printf(" %08x %08x %08x %08x\n", sp[4], sp[5], sp[6], sp[7]);
356 }
357
358 // ---
359
360 static void setup_default_palette(void)
361 {
362     write32(VDP_CTRL_PORT, CTL_WRITE_CRAM(0));
363     write32(VDP_DATA_PORT, 0);
364     write32(VDP_CTRL_PORT, CTL_WRITE_CRAM(15 * 2)); // font normal
365     write16(VDP_DATA_PORT, 0xeee);
366     write32(VDP_CTRL_PORT, CTL_WRITE_CRAM(31 * 2)); // green
367     write16(VDP_DATA_PORT, 0x0e0);
368     write32(VDP_CTRL_PORT, CTL_WRITE_CRAM(47 * 2)); // red
369     write16(VDP_DATA_PORT, 0x00e);
370 }
371
372 static void do_setup_dma(const void *src_, u16 words)
373 {
374     u32 src = (u32)src_;
375     // VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA);
376     VDP_setReg(VDP_DMA_LEN0, words);
377     VDP_setReg(VDP_DMA_LEN1, words >> 8);
378     VDP_setReg(VDP_DMA_SRC0, src >> 1);
379     VDP_setReg(VDP_DMA_SRC1, src >> 9);
380     VDP_setReg(VDP_DMA_SRC2, src >> 17);
381     // write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(addr) | CTL_WRITE_DMA);
382 }
383
384 static void vdp_wait_for_fifo_empty(void)
385 {
386     while (!(read16(VDP_CTRL_PORT) & 0x200))
387         /* fifo not empty */;
388 }
389
390 static void vdp_wait_for_dma_idle(void)
391 {
392     while (read16(VDP_CTRL_PORT) & 2)
393         /* dma busy */;
394 }
395
396 static void vdp_wait_for_line_0(void)
397 {
398     // in PAL vcounter reports 0 twice in a frame,
399     // so wait for vblank to clear first
400     while (!(read16(VDP_CTRL_PORT) & 8))
401         /* not blanking */;
402     while (read16(VDP_CTRL_PORT) & 8)
403         /* blanking */;
404     while (read8(VDP_HV_COUNTER) != 0)
405         ;
406 }
407
408 static void wait_next_vsync(void)
409 {
410     while (read16(VDP_CTRL_PORT) & SR_VB)
411         /* blanking */;
412     while (!(read16(VDP_CTRL_PORT) & SR_VB))
413         /* not blanking */;
414 }
415
416 static void t_dma_zero_wrap_early(void)
417 {
418     const u32 *src = (const u32 *)0x3c0000;
419     u32 *ram = (u32 *)0xff0000;
420
421     do_setup_dma(src + 4, 2);
422     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0) | CTL_WRITE_DMA);
423     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0) | CTL_WRITE_DMA);
424
425     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0));
426     ram[0] = read32(VDP_DATA_PORT);
427     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0xfffc));
428     ram[1] = read32(VDP_DATA_PORT);
429 }
430
431 static void t_dma_zero_fill_early(void)
432 {
433     u32 *ram = (u32 *)0xff0000;
434
435     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0));
436     write32(VDP_DATA_PORT, 0);
437     write32(VDP_DATA_PORT, 0);
438     write32(VDP_DATA_PORT, 0);
439     write32(VDP_DATA_PORT, 0);
440
441     VDP_setReg(VDP_AUTOINC, 1);
442     VDP_setReg(VDP_DMA_SRC2, 0x80);
443     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(1) | CTL_WRITE_DMA);
444     write16(VDP_DATA_PORT, 0x1122);
445     ram[2] = read16(VDP_CTRL_PORT);
446     vdp_wait_for_dma_idle();
447
448     VDP_setReg(VDP_AUTOINC, 2);
449     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0));
450     ram[3] = read32(VDP_DATA_PORT);
451 }
452
453 #define R_SKIP 0x5a5a
454
455 #define expect(ok_, v0_, v1_) \
456 do { if ((v0_) != (v1_)) { \
457     printf("%s: %08x %08x\n", #v0_, v0_, v1_); \
458     ok_ = 0; \
459 }} while (0)
460
461 #define expect_sh2(ok_, sh2_, v0_, v1_) \
462 do { if ((v0_) != (v1_)) { \
463     printf("%csh2: %08x %08x\n", sh2_ ? 's' : 'm', v0_, v1_); \
464     ok_ = 0; \
465 }} while (0)
466
467 #define expect_range(ok_, v0_, vmin_, vmax_) \
468 do { if ((v0_) < (vmin_) || (v0_) > (vmax_)) { \
469     printf("%s: %02x /%02x-%02x\n", #v0_, v0_, vmin_, vmax_); \
470     ok_ = 0; \
471 }} while (0)
472
473 #define expect_bits(ok_, v0_, val_, mask_) \
474 do { if (((v0_) & (mask_)) != (val_)) { \
475     printf("%s: %04x & %04x != %04x\n", #v0_, v0_, mask_, val_); \
476     ok_ = 0; \
477 }} while (0)
478
479 static int t_dma_zero_wrap(void)
480 {
481     const u32 *src = (const u32 *)0x3c0000;
482     const u32 *ram = (const u32 *)0xff0000;
483     int ok = 1;
484
485     expect(ok, ram[0], src[5 + 0x10000/4]);
486     expect(ok, ram[1], src[4]);
487     return ok;
488 }
489
490 static int t_dma_zero_fill(void)
491 {
492     const u32 *ram = (const u32 *)0xff0000;
493     u32 v0 = ram[2] & 2;
494     int ok = 1;
495
496     expect(ok, v0, 2);
497     expect(ok, ram[3], 0x11111111);
498     return ok;
499 }
500
501 static int t_dma_ram_wrap(void)
502 {
503     u32 *ram = (u32 *)0xff0000;
504     u32 saved, v0, v1;
505     int ok = 1;
506
507     saved = read32(&ram[0x10000/4 - 1]);
508     ram[0x10000/4 - 1] = 0x01020304;
509     ram[0] = 0x05060708;
510     do_setup_dma(&ram[0x10000/4 - 1], 4);
511     mem_barrier();
512     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) | CTL_WRITE_DMA);
513
514     mem_barrier();
515     write32(&ram[0x10000/4 - 1], saved);
516
517     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x100));
518     v0 = read32(VDP_DATA_PORT);
519     v1 = read32(VDP_DATA_PORT);
520
521     expect(ok, v0, 0x01020304);
522     expect(ok, v1, 0x05060708);
523     return ok;
524 }
525
526 // test no src reprogram, only len0
527 static int t_dma_multi(void)
528 {
529     const u32 *src = (const u32 *)0x3c0000;
530     u32 v0, v1;
531     int ok = 1;
532
533     do_setup_dma(src, 2);
534     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) | CTL_WRITE_DMA);
535     VDP_setReg(VDP_DMA_LEN0, 2);
536     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x104) | CTL_WRITE_DMA);
537
538     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x100));
539     v0 = read32(VDP_DATA_PORT);
540     v1 = read32(VDP_DATA_PORT);
541
542     expect(ok, v0, src[0]);
543     expect(ok, v1, src[1]);
544     return ok;
545 }
546
547 static int t_dma_cram_wrap(void)
548 {
549     u32 *ram = (u32 *)0xff0000;
550     u32 v0, v1;
551     int ok = 1;
552
553     write32(VDP_CTRL_PORT, CTL_WRITE_CRAM(0));
554     write32(VDP_DATA_PORT, 0);
555
556     ram[0] = 0x0ec20ec4;
557     ram[1] = 0x0ec60ec8;
558     mem_barrier();
559     do_setup_dma(ram, 4);
560     write32(VDP_CTRL_PORT, CTL_WRITE_CRAM(0x7c | 0xff81) | CTL_WRITE_DMA);
561
562     write32(VDP_CTRL_PORT, CTL_READ_CRAM(0x7c));
563     v0 = read32(VDP_DATA_PORT) & 0x0eee0eee;
564     write32(VDP_CTRL_PORT, CTL_READ_CRAM(0));
565     v1 = read32(VDP_DATA_PORT) & 0x0eee0eee;
566
567     setup_default_palette();
568
569     expect(ok, v0, ram[0]);
570     expect(ok, v1, ram[1]);
571     return ok;
572 }
573
574 static int t_dma_vsram_wrap(void)
575 {
576     u32 *ram32 = (u32 *)0xff0000;
577     u16 *ram16 = (u16 *)0xff0000;
578     u32 v0, v1;
579     int ok = 1;
580     int i;
581
582     write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(0));
583     write32(VDP_DATA_PORT, 0);
584
585     for (i = 0; i < 0x48/2; i++)
586         ram16[i] = i + 1;
587     mem_barrier();
588     do_setup_dma(ram16, 0x48/2);
589     write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(0x3c | 0xff81) | CTL_WRITE_DMA);
590
591     write32(VDP_CTRL_PORT, CTL_READ_VSRAM(0x3c));
592     v0 = read32(VDP_DATA_PORT) & 0x03ff03ff;
593     write32(VDP_CTRL_PORT, CTL_READ_VSRAM(0));
594     v1 = read32(VDP_DATA_PORT) & 0x03ff03ff;
595
596     write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(0));
597     write32(VDP_DATA_PORT, 0);
598
599     expect(ok, v0, ram32[0]);
600     expect(ok, v1, ram32[0x48/4 - 1]);
601     return ok;
602 }
603
604 static int t_dma_and_data(void)
605 {
606     const u32 *src = (const u32 *)0x3c0000;
607     u32 v0, v1;
608     int ok = 1;
609
610     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
611     write32(VDP_DATA_PORT, 0);
612
613     do_setup_dma(src, 2);
614     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0xfc) | CTL_WRITE_DMA);
615     write32(VDP_DATA_PORT, 0x5ec8a248);
616
617     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0xfc));
618     v0 = read32(VDP_DATA_PORT);
619     v1 = read32(VDP_DATA_PORT);
620
621     expect(ok, v0, src[0]);
622     expect(ok, v1, 0x5ec8a248);
623     return ok;
624 }
625
626 static int t_dma_short_cmd(void)
627 {
628     const u32 *src = (const u32 *)0x3c0000;
629     u32 v0, v1, v2;
630     int ok = 1;
631
632     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x3ff4));
633     write32(VDP_DATA_PORT, 0x10111213);
634     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0xfff0));
635     write32(VDP_DATA_PORT, 0x20212223);
636     write32(VDP_DATA_PORT, 0x30313233);
637     vdp_wait_for_fifo_empty();
638
639     do_setup_dma(src, 2);
640     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0xfff0) | CTL_WRITE_DMA);
641     write16(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x3ff4) >> 16);
642     write32(VDP_DATA_PORT, 0x40414243);
643
644     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x3ff4));
645     v0 = read32(VDP_DATA_PORT);
646     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0xfff0));
647     v1 = read32(VDP_DATA_PORT);
648     v2 = read32(VDP_DATA_PORT);
649
650     expect(ok, v0, 0x10111213);
651     expect(ok, v1, src[0]);
652     expect(ok, v2, 0x40414243);
653     return ok;
654 }
655
656 static int t_dma_fill3_odd(void)
657 {
658     u32 v0, v1, v2;
659     int ok = 1;
660
661     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
662     write32(VDP_DATA_PORT, 0);
663     write32(VDP_DATA_PORT, 0);
664     write32(VDP_DATA_PORT, 0);
665     vdp_wait_for_fifo_empty();
666
667     VDP_setReg(VDP_AUTOINC, 3);
668     VDP_setReg(VDP_DMA_LEN0, 3);
669     VDP_setReg(VDP_DMA_SRC2, 0x80);
670     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x101) | CTL_WRITE_DMA);
671     write16(VDP_DATA_PORT, 0x1122);
672     vdp_wait_for_dma_idle();
673
674     VDP_setReg(VDP_AUTOINC, 2);
675     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x100));
676     v0 = read32(VDP_DATA_PORT);
677     v1 = read32(VDP_DATA_PORT);
678     v2 = read32(VDP_DATA_PORT);
679
680     expect(ok, v0, 0x22110000);
681     expect(ok, v1, 0x00111100);
682     expect(ok, v2, 0x00000011);
683     return ok;
684 }
685
686 static int t_dma_fill3_even(void)
687 {
688     u32 v0, v1, v2;
689     int ok = 1;
690
691     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
692     write32(VDP_DATA_PORT, 0);
693     write32(VDP_DATA_PORT, 0);
694     write32(VDP_DATA_PORT, 0);
695     vdp_wait_for_fifo_empty();
696
697     VDP_setReg(VDP_AUTOINC, 3);
698     VDP_setReg(VDP_DMA_LEN0, 3);
699     VDP_setReg(VDP_DMA_SRC2, 0x80);
700     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) | CTL_WRITE_DMA);
701     write16(VDP_DATA_PORT, 0x1122);
702     vdp_wait_for_dma_idle();
703
704     VDP_setReg(VDP_AUTOINC, 2);
705     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x100));
706     v0 = read32(VDP_DATA_PORT);
707     v1 = read32(VDP_DATA_PORT);
708     v2 = read32(VDP_DATA_PORT);
709
710     expect(ok, v0, 0x11221100);
711     expect(ok, v1, 0x00000011);
712     expect(ok, v2, 0x11000000);
713     return ok;
714 }
715
716 static unused int t_dma_fill3_vsram(void)
717 {
718     u32 v0, v1, v2;
719     int ok = 1;
720
721     write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(0));
722     write32(VDP_DATA_PORT, 0);
723     write32(VDP_DATA_PORT, 0);
724     write32(VDP_DATA_PORT, 0);
725
726     write16(VDP_DATA_PORT, 0x0111);
727     write16(VDP_DATA_PORT, 0x0222);
728     write16(VDP_DATA_PORT, 0x0333);
729     vdp_wait_for_fifo_empty();
730
731     VDP_setReg(VDP_AUTOINC, 3);
732     VDP_setReg(VDP_DMA_LEN0, 3);
733     VDP_setReg(VDP_DMA_SRC2, 0x80);
734     write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(1) | CTL_WRITE_DMA);
735     write16(VDP_DATA_PORT, 0x0102);
736     vdp_wait_for_dma_idle();
737
738     VDP_setReg(VDP_AUTOINC, 2);
739     write32(VDP_CTRL_PORT, CTL_READ_VSRAM(0));
740     v0 = read32(VDP_DATA_PORT);
741     v1 = read32(VDP_DATA_PORT);
742     v2 = read32(VDP_DATA_PORT);
743
744     write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(0));
745     write32(VDP_DATA_PORT, 0);
746
747     expect(ok, v0, 0x01020000);
748     expect(ok, v1, 0x01110111);
749     expect(ok, v2, 0x00000111);
750     return ok;
751 }
752
753 static int t_dma_fill_dis(void)
754 {
755     u32 v0, v1;
756     int ok = 1;
757
758     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
759     write32(VDP_DATA_PORT, 0);
760     write32(VDP_DATA_PORT, 0);
761
762     VDP_setReg(VDP_DMA_LEN0, 1);
763     VDP_setReg(VDP_DMA_SRC2, 0x80);
764     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) | CTL_WRITE_DMA);
765     VDP_setReg(VDP_MODE2, VDP_MODE2_MD);
766     write16(VDP_DATA_PORT, 0x1122);
767     vdp_wait_for_dma_idle();
768
769     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
770     write16(VDP_DATA_PORT, 0x3344);
771     vdp_wait_for_dma_idle();
772
773     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x100));
774     v0 = read32(VDP_DATA_PORT);
775     v1 = read32(VDP_DATA_PORT);
776
777     expect(ok, v0, 0);
778     expect(ok, v1, 0);
779     return ok;
780 }
781
782 static int t_dma_fill_src(void)
783 {
784     const u32 *src = (const u32 *)0x3c0000;
785     u32 v0, v1;
786     int ok = 1;
787
788     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
789     write32(VDP_DATA_PORT, 0);
790
791     // do_setup_dma(src, 2); // hang, can't write src2 twice
792     VDP_setReg(VDP_DMA_LEN0, 2);
793     VDP_setReg(VDP_DMA_SRC0, (u32)src >> 1);
794     VDP_setReg(VDP_DMA_SRC1, (u32)src >> 9);
795     VDP_setReg(VDP_DMA_SRC2, 0x80);
796     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) | CTL_WRITE_DMA);
797     write16(VDP_DATA_PORT, 0x1122);
798     vdp_wait_for_dma_idle();
799
800     VDP_setReg(VDP_DMA_LEN0, 2);
801     VDP_setReg(VDP_DMA_SRC2, (u32)src >> 17);
802     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x104) | CTL_WRITE_DMA);
803
804     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x100));
805     v0 = read32(VDP_DATA_PORT);
806     v1 = read32(VDP_DATA_PORT);
807
808     expect(ok, v0, 0x11220011);
809     expect(ok, v1, src[1]);
810     return ok;
811 }
812
813 // should not see the busy flag
814 static int t_dma_busy_vram(void)
815 {
816     const u32 *src = (const u32 *)0x3c0000;
817     u16 sr[3];
818     int ok = 1;
819
820     vdp_wait_for_line_0();
821
822     do_setup_dma(src, 1);
823     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) | CTL_WRITE_DMA);
824     sr[0] = read16(VDP_CTRL_PORT);
825
826     do_setup_dma(src, 4);
827     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) | CTL_WRITE_DMA);
828     sr[1] = read16(VDP_CTRL_PORT);
829
830     VDP_setReg(VDP_DMA_LEN0, 8);
831     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) | CTL_WRITE_DMA);
832     sr[2] = read16(VDP_CTRL_PORT);
833
834     expect_bits(ok, sr[0], 0, SR_DMA);
835     expect_bits(ok, sr[1], 0, SR_DMA);
836     expect_bits(ok, sr[2], 0, SR_DMA);
837     return ok;
838 }
839
840 // (((a & 2) >> 1) ^ 1) | ((a & $400) >> 9) | (a & $3FC) | ((a & $1F800) >> 1)
841 static int t_dma_128k(void)
842 {
843     u16 *ram = (u16 *)0xff0000;
844     u32 v0, v1;
845     int ok = 1;
846
847     ram[0] = 0x5a11;
848     ram[1] = 0x5a22;
849     ram[2] = 0x5a33;
850
851     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
852     write32(VDP_DATA_PORT, 0x01020304);
853     write32(VDP_DATA_PORT, 0x05060708);
854     vdp_wait_for_fifo_empty();
855
856     mem_barrier();
857     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_128K);
858     do_setup_dma(ram, 3);
859     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) | CTL_WRITE_DMA);
860     vdp_wait_for_fifo_empty();
861
862     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
863     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x100));
864     v0 = read32(VDP_DATA_PORT);
865     v1 = read32(VDP_DATA_PORT);
866
867     expect(ok, v0, 0x22110304);
868     expect(ok, v1, 0x05330708);
869     return ok;
870 }
871
872 static int t_vdp_128k_b16(void)
873 {
874     u32 v0, v1;
875     int ok = 1;
876
877     VDP_setReg(VDP_AUTOINC, 0);
878     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x8100));
879     write32(VDP_DATA_PORT, 0x01020304);
880     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x10100));
881     write32(VDP_DATA_PORT, 0x05060708);
882     vdp_wait_for_fifo_empty();
883
884     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_128K);
885     write16(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100) >> 16); // note: upper cmd
886     write32(VDP_DATA_PORT, 0x11223344);
887     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x10102));
888     write32(VDP_DATA_PORT, 0x55667788);
889     vdp_wait_for_fifo_empty();
890
891     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
892     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x8100));
893     v0 = read16(VDP_DATA_PORT);
894     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x0100));
895     v1 = read16(VDP_DATA_PORT);
896
897     VDP_setReg(VDP_AUTOINC, 2);
898
899     expect(ok, v0, 0x8844);
900     expect(ok, v1, 0x0708);
901     return ok;
902 }
903
904 static unused int t_vdp_128k_b16_inc(void)
905 {
906     u32 v0, v1;
907     int ok = 1;
908
909     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0));
910     write32(VDP_DATA_PORT, 0x01020304);
911     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x8000));
912     write32(VDP_DATA_PORT, 0x05060708);
913     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0xfffe));
914     write32(VDP_DATA_PORT, 0x090a0b0c);
915     vdp_wait_for_fifo_empty();
916
917     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_128K);
918     write16(VDP_CTRL_PORT, CTL_WRITE_VRAM(0) >> 16); // note: upper cmd
919     write16(VDP_DATA_PORT, 0x1122);
920     vdp_wait_for_fifo_empty();
921
922     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
923     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0));
924     v0 = read32(VDP_DATA_PORT);
925     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x8000));
926     v1 = read32(VDP_DATA_PORT);
927     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0));
928     write32(VDP_DATA_PORT, 0);
929     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x8000));
930     write32(VDP_DATA_PORT, 0);
931
932     expect(ok, v0, 0x0b0c0304); // XXX: no 22 anywhere?
933     expect(ok, v1, 0x05060708);
934     return ok;
935 }
936
937 static int t_vdp_reg_cmd(void)
938 {
939     u32 v0;
940     int ok = 1;
941
942     VDP_setReg(VDP_AUTOINC, 0);
943     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
944     write32(VDP_DATA_PORT, 0x01020304);
945     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
946     write32(VDP_DATA_PORT, 0x05060708);
947
948     VDP_setReg(VDP_AUTOINC, 2);
949     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x0100));
950     v0 = read16(VDP_DATA_PORT);
951
952     expect(ok, v0, 0x0304);
953     return ok;
954 }
955
956 static int t_vdp_sr_vb(void)
957 {
958     u16 sr[4];
959     int ok = 1;
960
961     while (read8(VDP_HV_COUNTER) != 242)
962         ;
963     sr[0] = read16(VDP_CTRL_PORT);
964     VDP_setReg(VDP_MODE2, VDP_MODE2_MD);
965     sr[1] = read16(VDP_CTRL_PORT);
966     while (read8(VDP_HV_COUNTER) != 4)
967         ;
968     sr[2] = read16(VDP_CTRL_PORT);
969     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
970     sr[3] = read16(VDP_CTRL_PORT);
971
972     expect_bits(ok, sr[0], SR_VB, SR_VB);
973     expect_bits(ok, sr[1], SR_VB, SR_VB);
974     expect_bits(ok, sr[2], SR_VB, SR_VB);
975     expect_bits(ok, sr[3], 0, SR_VB);
976     return ok;
977 }
978
979 /* z80 tests assume busreq state */
980 static int t_z80mem_long_mirror(void)
981 {
982     u8 *zram = (u8 *)0xa00000;
983     int ok = 1;
984
985     write8(&zram[0x1100], 0x11);
986     write8(&zram[0x1101], 0x22);
987     write8(&zram[0x1102], 0x33);
988     write8(&zram[0x1103], 0x44);
989     mem_barrier();
990     write32(&zram[0x3100], 0x55667788);
991     mem_barrier();
992
993     expect(ok, zram[0x1100], 0x55);
994     expect(ok, zram[0x1101], 0x22);
995     expect(ok, zram[0x1102], 0x77);
996     expect(ok, zram[0x1103], 0x44);
997     return ok;
998 }
999
1000 static int t_z80mem_noreq_w(void)
1001 {
1002     u8 *zram = (u8 *)0xa00000;
1003     int ok = 1;
1004
1005     write8(&zram[0x1100], 0x11);
1006     mem_barrier();
1007     write16(0xa11100, 0x000);
1008     write8(&zram[0x1100], 0x22);
1009     mem_barrier();
1010
1011     write16(0xa11100, 0x100);
1012     while (read16(0xa11100) & 0x100)
1013         ;
1014
1015     expect(ok, zram[0x1100], 0x11);
1016     return ok;
1017 }
1018
1019 #define Z80_C_DISPATCH 113  // see z80_test.s80
1020 #define Z80_C_END       17
1021 #define Z80_C_END_VCNT  67
1022
1023 #define Z80_CYLES_TEST1(b) (Z80_C_DISPATCH + ((b) - 1) * 21 + 26 + Z80_C_END)
1024
1025 static int t_z80mem_vdp_r(void)
1026 {
1027     u8 *zram = (u8 *)0xa00000;
1028     int ok = 1;
1029
1030     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
1031     write32(VDP_DATA_PORT, 0x11223344);
1032     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x100));
1033
1034     zram[0x1000] = 1; // cp
1035     write16_z80le(&zram[0x1002], 0x7f00); // src
1036     write16_z80le(&zram[0x1004], 0x1100); // dst
1037     write16_z80le(&zram[0x1006], 2); // len
1038     zram[0x1100] = zram[0x1101] = zram[0x1102] = 0x5a;
1039     mem_barrier();
1040     write16(0xa11100, 0x000);
1041     burn10(Z80_CYLES_TEST1(2) * 15 / 7 / 10);
1042
1043     write16(0xa11100, 0x100);
1044     while (read16(0xa11100) & 0x100)
1045         ;
1046
1047     expect(ok, zram[0x1000], 0);
1048     expect(ok, zram[0x1100], 0x11);
1049     expect(ok, zram[0x1101], 0x44);
1050     expect(ok, zram[0x1102], 0x5a);
1051     return ok;
1052 }
1053
1054 static unused int t_z80mem_vdp_w(void)
1055 {
1056     u8 *zram = (u8 *)0xa00000;
1057     u32 v0;
1058     int ok = 1;
1059
1060     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
1061     write32(VDP_DATA_PORT, 0x11223344);
1062     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
1063     vdp_wait_for_fifo_empty();
1064
1065     zram[0x1000] = 1; // cp
1066     write16_z80le(&zram[0x1002], 0x1100); // src
1067     write16_z80le(&zram[0x1004], 0x7f00); // dst
1068     write16_z80le(&zram[0x1006], 2); // len
1069     zram[0x1100] = 0x55;
1070     zram[0x1101] = 0x66;
1071     mem_barrier();
1072     write16(0xa11100, 0x000);
1073     burn10(Z80_CYLES_TEST1(2) * 15 / 7 / 10);
1074
1075     write16(0xa11100, 0x100);
1076     while (read16(0xa11100) & 0x100)
1077         ;
1078
1079     write32(VDP_CTRL_PORT, CTL_READ_VRAM(0x100));
1080     v0 = read32(VDP_DATA_PORT);
1081
1082     expect(ok, zram[0x1000], 0);
1083     expect(ok, v0, 0x55556666);
1084     return ok;
1085 }
1086
1087 static int t_tim_loop(void)
1088 {
1089     u8 vcnt;
1090     int ok = 1;
1091
1092     vdp_wait_for_line_0();
1093     burn10(488*220/10);
1094     vcnt = read8(VDP_HV_COUNTER);
1095     mem_barrier();
1096
1097     //expect_range(ok, vcnt, 0x80, 0x80);
1098     expect(ok, vcnt, 223);
1099     return ok;
1100 }
1101
1102 static int t_tim_z80_loop(void)
1103 {
1104     u8 pal = read8(0xa10001) & 0x40;
1105     u8 *zram = (u8 *)0xa00000;
1106     u16 z80_loops  = pal ? 3420*(313*2+1)/15/100 : 3420*(262*2+1)/15/100; // 2fr + 1ln
1107     u16 _68k_loops = pal ? 3420*(313*2+1)/7/10   : 3420*(262*2+1)/7/10;
1108     int ok = 1;
1109
1110     zram[0x1000] = 3; // idle loop, save vcnt
1111     write16_z80le(&zram[0x1002], 0); // src (unused)
1112     write16_z80le(&zram[0x1004], 0x1100); // vcnt dst
1113     write16_z80le(&zram[0x1006], z80_loops); // x100 cycles
1114     zram[0x1100] = 0;
1115     mem_barrier();
1116
1117     vdp_wait_for_line_0();
1118     write16(0xa11100, 0x000);
1119     burn10(_68k_loops + (Z80_C_DISPATCH + Z80_C_END_VCNT) * 15 / 7 / 10);
1120
1121     write16(0xa11100, 0x100);
1122     while (read16(0xa11100) & 0x100)
1123         ;
1124     expect(ok, zram[0x1000], 0);
1125     expect(ok, zram[0x1100], 1);
1126     return ok;
1127 }
1128
1129 #define Z80_CYCLES_TEST2(b) (Z80_C_DISPATCH + (b) * 38 + Z80_C_END_VCNT)
1130
1131 // 80 80 91 95-96
1132 static void z80_read_loop(u8 *zram, u16 src)
1133 {
1134     const int pairs = 512 + 256;
1135
1136     zram[0x1000] = 2; // read loop, save vcnt
1137     write16_z80le(&zram[0x1002], src); // src
1138     write16_z80le(&zram[0x1004], 0x1100); // vcnt dst
1139     write16_z80le(&zram[0x1006], pairs); // reads/2
1140     zram[0x1100] = 0;
1141     mem_barrier();
1142
1143     vdp_wait_for_line_0();
1144     write16(0xa11100, 0x000);
1145     burn10(Z80_CYCLES_TEST2(pairs) * 15 / 7 * 2 / 10);
1146
1147     write16(0xa11100, 0x100);
1148     while (read16(0xa11100) & 0x100)
1149         ;
1150 }
1151
1152 static int t_tim_z80_ram(void)
1153 {
1154     u8 *zram = (u8 *)0xa00000;
1155     int ok = 1;
1156
1157     z80_read_loop(zram, 0);
1158
1159     expect(ok, zram[0x1000], 0);
1160     expect_range(ok, zram[0x1100], 0x80, 0x80);
1161     return ok;
1162 }
1163
1164 static int t_tim_z80_ym(void)
1165 {
1166     u8 *zram = (u8 *)0xa00000;
1167     int ok = 1;
1168
1169     z80_read_loop(zram, 0x4000);
1170
1171     expect(ok, zram[0x1000], 0);
1172     expect_range(ok, zram[0x1100], 0x80, 0x80);
1173     return ok;
1174 }
1175
1176 static int t_tim_z80_vdp(void)
1177 {
1178     u8 *zram = (u8 *)0xa00000;
1179     int ok = 1;
1180
1181     z80_read_loop(zram, 0x7f08);
1182
1183     expect(ok, zram[0x1000], 0);
1184     expect_range(ok, zram[0x1100], 0x91, 0x91);
1185     return ok;
1186 }
1187
1188 static int t_tim_z80_bank_rom(void)
1189 {
1190     u8 *zram = (u8 *)0xa00000;
1191     int i, ok = 1;
1192
1193     for (i = 0; i < 17; i++)
1194         write8(0xa06000, 0); // bank 0
1195
1196     z80_read_loop(zram, 0x8000);
1197
1198     expect(ok, zram[0x1000], 0);
1199     expect_range(ok, zram[0x1100], 0x95, 0x96);
1200     return ok;
1201 }
1202
1203 /* borderline too slow */
1204 #if 0
1205 static void test_vcnt_vb(void)
1206 {
1207     const u32 *srhv = (u32 *)0xc00006; // to read SR and HV counter
1208     u32 *ram = (u32 *)0xff0000;
1209     u16 vcnt, vcnt_expect = 0;
1210     u16 sr, count = 0;
1211     u32 val, old;
1212
1213     vdp_wait_for_line_0();
1214     old = read32(srhv);
1215     *ram++ = old;
1216     for (;;) {
1217         val = read32(srhv);
1218         vcnt = val & 0xff00;
1219         if (vcnt == vcnt_expect)
1220             continue;
1221         sr = val >> 16;
1222         if (vcnt == 0 && !(sr & SR_VB)) // not VB
1223             break; // wrapped to start of frame
1224 //        count++;
1225         vcnt_expect += 0x100;
1226         if (vcnt == vcnt_expect && !((sr ^ (old >> 16)) & SR_VB)) {
1227             old = val;
1228             continue;
1229         }
1230         // should have a vcnt jump here
1231         *ram++ = old;
1232         *ram++ = val;
1233         vcnt_expect = vcnt;
1234         old = val;
1235     }
1236     *ram++ = val;
1237     *ram = count;
1238     mem_barrier();
1239 }
1240 #endif
1241
1242 static int t_tim_vcnt(void)
1243 {
1244     const u32 *ram32 = (u32 *)0xff0000;
1245     const u8 *ram = (u8 *)0xff0000;
1246     u8 pal = read8(0xa10001) & 0x40;
1247     u8 vc_jmp_b = pal ? 0x02 : 0xea;
1248     u8 vc_jmp_a = pal ? 0xca : 0xe5;
1249     u16 lines = pal ? 313 : 262;
1250     int ok = 1;
1251
1252     test_vcnt_vb();
1253     expect(ok, ram[0*4+2], 0); // line 0
1254     expect_bits(ok, ram[0*4+1], 0, SR_VB);
1255     expect(ok, ram[1*4+2], 223); // last no blank
1256     expect_bits(ok, ram[1*4+1], 0, SR_VB);
1257     expect(ok, ram[2*4+2], 224); // 1st blank
1258     expect_bits(ok, ram[2*4+1], SR_VB, SR_VB);
1259     expect(ok, ram[3*4+2], vc_jmp_b); // before jump
1260     expect_bits(ok, ram[3*4+1], SR_VB, SR_VB);
1261     expect(ok, ram[4*4+2], vc_jmp_a); // after jump
1262     expect_bits(ok, ram[4*4+1], SR_VB, SR_VB);
1263     expect(ok, ram[5*4+2], 0xfe); // before vb clear
1264     expect_bits(ok, ram[5*4+1], SR_VB, SR_VB);
1265     expect(ok, ram[6*4+2], 0xff); // after vb clear
1266     expect_bits(ok, ram[6*4+1], 0, SR_VB);
1267     expect(ok, ram[7*4+2], 0); // next line 0
1268     expect_bits(ok, ram[7*4+1], 0, SR_VB);
1269     expect(ok, ram32[8], lines - 1);
1270     return ok;
1271 }
1272
1273 static int t_tim_vcnt_loops(void)
1274 {
1275     const u16 *ram16 = (u16 *)0xfff004;
1276     u8 pal = read8(0xa10001) & 0x40;
1277     u16 i, lines = pal ? 313 : 262;
1278     int ok = 1;
1279
1280     test_vcnt_loops();
1281     expect(ok, ram16[-1*2+0], 0xff);
1282     expect_range(ok, ram16[-1*2+1], 21, 22);
1283     for (i = 0; i < lines; i++)
1284         expect_range(ok, ram16[i*2+1], 19, 21);
1285     expect(ok, ram16[lines*2+0], 0);
1286     expect_range(ok, ram16[lines*2+1], 19, 21);
1287     return ok;
1288 }
1289
1290 static int t_tim_hblank_h40(void)
1291 {
1292     const u8 *r = (u8 *)0xff0000;
1293     int ok = 1;
1294
1295     test_hb();
1296
1297     // set: 0-2
1298     expect_bits(ok, r[2], SR_HB, SR_HB);
1299     expect_bits(ok, r[5], SR_HB, SR_HB);
1300     // <wait>
1301     expect_bits(ok, r[7], SR_HB, SR_HB);
1302     // clear: 8-11
1303     expect_bits(ok, r[12], 0, SR_HB);
1304     return ok;
1305 }
1306
1307 static int t_tim_hblank_h32(void)
1308 {
1309     const u8 *r = (u8 *)0xff0000;
1310     int ok = 1;
1311
1312     VDP_setReg(VDP_MODE4, 0x00);
1313     test_hb();
1314     VDP_setReg(VDP_MODE4, 0x81);
1315
1316     expect_bits(ok, r[0], 0, SR_HB);
1317     // set: 1-4
1318     expect_bits(ok, r[4], SR_HB, SR_HB);
1319     expect_bits(ok, r[5], SR_HB, SR_HB);
1320     // <wait>
1321     expect_bits(ok, r[8], SR_HB, SR_HB);
1322     // clear: 9-11
1323     expect_bits(ok, r[12], 0, SR_HB);
1324     return ok;
1325 }
1326
1327 static int t_tim_vdp_as_vram_w(void)
1328 {
1329     int ok = 1;
1330     u8 vcnt;
1331
1332     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0x100));
1333     vdp_wait_for_line_0();
1334     write16_x16(VDP_DATA_PORT, 112*18 / 16, 0);
1335     vcnt = read8(VDP_HV_COUNTER);
1336     mem_barrier();
1337
1338     expect(ok, vcnt, 112*2-1);
1339     return ok;
1340 }
1341
1342 static int t_tim_vdp_as_cram_w(void)
1343 {
1344     int ok = 1;
1345     u8 vcnt;
1346
1347     write32(VDP_CTRL_PORT, CTL_WRITE_CRAM(0));
1348     vdp_wait_for_line_0();
1349     write16_x16(VDP_DATA_PORT, 112*18 / 16, 0);
1350     vcnt = read8(VDP_HV_COUNTER);
1351     mem_barrier();
1352
1353     setup_default_palette();
1354
1355     expect(ok, vcnt, 112);
1356     return ok;
1357 }
1358
1359 static const u8 hcnt2tm[] =
1360 {
1361     0x0a, 0x1d, 0x31, 0x44, 0x58, 0x6b, 0x7f, 0x92,
1362     0xa6, 0xb9, 0xcc, 0x00, 0x00, 0x00, 0xe2, 0xf6
1363 };
1364
1365 static int t_tim_ym_timer_z80(int is_b)
1366 {
1367     u8 pal = read8(0xa10001) & 0x40;
1368     u8 *zram = (u8 *)0xa00000;
1369     u8 *z80 = zram;
1370     u16 _68k_loops = 3420*(302+5+1)/7/10; // ~ (72*1024*2)/(3420./7)
1371     u16 start, end, diff;
1372     int ok = 1;
1373
1374     zram[0x1000] = 4 + is_b; // ym2612 timer a/b test
1375     zram[0x1100] = zram[0x1101] = zram[0x1102] = zram[0x1103] = 0;
1376     mem_barrier();
1377
1378     vdp_wait_for_line_0();
1379     write16(0xa11100, 0x000);
1380
1381     burn10(_68k_loops + (Z80_C_DISPATCH + Z80_C_END_VCNT) * 15 / 7 / 10);
1382
1383     write16(0xa11100, 0x100);
1384     while (read16(0xa11100) & 0x100)
1385         ;
1386     mem_barrier();
1387     expect(ok, zram[0x1000], 0);
1388     (void)hcnt2tm;
1389     //start = ((u16)zram[0x1102] << 8) | hcnt2tm[zram[0x1103] >> 4];
1390     //end   = ((u16)zram[0x1100] << 8) | hcnt2tm[zram[0x1101] >> 4];
1391     start = zram[0x1102];
1392     end   = zram[0x1100];
1393     diff = end - start;
1394     if (pal)
1395       expect_range(ok, diff, 0xf4, 0xf6);
1396     else
1397       expect_range(ok, diff, 0x27, 0x29);
1398     write8(&z80[0x4001], 0); // stop, but should keep the flag
1399     mem_barrier();
1400     burn10(32*6/10); // busy bit, 32 FM ticks (M/7/6)
1401     if (is_b) {
1402       expect(ok, z80[0x4000], 2);
1403       write8(&z80[0x4001], 0x20); // reset flag (reg 0x27, set up by z80)
1404     }
1405     else {
1406       expect(ok, z80[0x4000], 1);
1407       write8(&z80[0x4001], 0x10);
1408     }
1409     mem_barrier();
1410     burn10(32*6/10);
1411     expect(ok, z80[0x4000], 0);
1412     return ok;
1413 }
1414
1415 static int t_tim_ym_timera_z80(void)
1416 {
1417     return t_tim_ym_timer_z80(0);
1418 }
1419
1420 static int t_tim_ym_timerb_z80(void)
1421 {
1422     return t_tim_ym_timer_z80(1);
1423 }
1424
1425 static int t_tim_ym_timerb_stop(void)
1426 {
1427     const struct {
1428         //u8 vcnt_start;
1429         //u8 hcnt_start;
1430         u16 vcnt_start;
1431         u16 stat0;
1432         //u8 vcnt_end;
1433         //u8 hcnt_end;
1434         u16 vcnt_end;
1435         u16 stat1;
1436     } *t = (void *)0xfff000;
1437     u8 *z80 = (u8 *)0xa00000;
1438     u16 diff;
1439     int ok = 1;
1440     write16(0xa11100, 0x100);
1441     while (read16(0xa11100) & 0x100)
1442         ;
1443     test_ym_stopped_tick();
1444     mem_barrier();
1445     //start = ((u16)t->vcnt_start << 8) | hcnt2tm[t->hcnt_start >> 4];
1446     //end   = ((u16)t->vcnt_end   << 8) | hcnt2tm[t->hcnt_end   >> 4];
1447     //diff = end - start;
1448     diff = t->vcnt_end - t->vcnt_start;
1449     //expect_range(ok, diff, 0x492, 0x5c2); // why so much variation?
1450     expect_range(ok, diff, 4, 5);
1451     expect(ok, t->stat0, 0);
1452     expect(ok, t->stat1, 2);
1453     expect(ok, z80[0x4000], 2);
1454     write8(&z80[0x4001], 0x30);
1455     return ok;
1456 }
1457
1458 static int t_tim_ym_timer_ab_sync(void)
1459 {
1460     u16 v1, v2, v3, v4, v5, ln0, ln1, ln2;
1461     int ok = 1;
1462
1463     vdp_wait_for_line_0();
1464     v1 = test_ym_ab_sync();
1465
1466     ln0 = get_line();
1467     burn10(3420*15/7/10);     // ~15 scanlines
1468     write8(0xa04001, 0x3f);   // clear, no reload
1469     burn10(12);               // wait for busy to clear
1470     v2 = read8(0xa04000);
1471     v3 = test_ym_ab_sync2();
1472
1473     ln1 = get_line();
1474     burn10(3420*15/7/10);     // ~15 scanlines
1475     v4 = test_ym_ab_sync2();
1476
1477     ln2 = get_line();
1478     burn10(3420*30/7/10);     // ~35 scanlines
1479     v5 = read8(0xa04000);
1480
1481     expect(ok, v1, 3);
1482     expect(ok, v2, 0);
1483     expect(ok, v3, 3);
1484     expect(ok, v4, 2);
1485     expect(ok, v5, 0);
1486     expect_range(ok, ln1-ln0, 18, 19);
1487     expect_range(ok, ln2-ln1, 32, 34); // almost always 33
1488     return ok;
1489 }
1490
1491 struct irq_test {
1492     u16 cnt;
1493     union {
1494         u16 hv;
1495         u8 v;
1496     } first, last;
1497     u16 pad;
1498 };
1499
1500 // broken on fresh boot due to uknown reasons
1501 static int t_irq_hint(void)
1502 {
1503     struct irq_test *it = (void *)0xfff000;
1504     struct irq_test *itv = it + 1;
1505     int ok = 1;
1506
1507     memset_(it, 0, sizeof(*it) * 2);
1508     memcpy_((void *)0xff0100, test_hint, test_hint_end - test_hint);
1509     memcpy_((void *)0xff0140, test_vint, test_vint_end - test_vint);
1510
1511     // without this, tests fail after cold boot
1512     while (!(read16(VDP_CTRL_PORT) & 8))
1513         /* not blanking */;
1514
1515     // for more fun, disable the display
1516     VDP_setReg(VDP_MODE2, VDP_MODE2_MD);
1517
1518     VDP_setReg(10, 0);
1519     while (read8(VDP_HV_COUNTER) != 100)
1520         ;
1521     while (read8(VDP_HV_COUNTER) != 229)
1522         ;
1523     // take the pending irq
1524     VDP_setReg(VDP_MODE1, VDP_MODE1_PS | VDP_MODE1_IE1);
1525     move_sr(0x2000);
1526     burn10(488 * 2 / 10);
1527     move_sr(0x2700);
1528     expect(ok, it->first.v, 229);      // pending irq trigger
1529     expect(ok, it->cnt, 1);
1530     expect(ok, itv->cnt, 0);
1531
1532     // count irqs
1533     it->cnt = it->first.hv = it->last.hv = 0;
1534     move_sr(0x2000);
1535     while (read8(VDP_HV_COUNTER) != 4)
1536         ;
1537     while (read8(VDP_HV_COUNTER) != 228)
1538         ;
1539     move_sr(0x2700);
1540     expect(ok, it->cnt, 225);
1541     expect(ok, it->first.v, 0);
1542     expect(ok, it->last.v, 224);
1543
1544     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
1545
1546     // detect reload line
1547     it->cnt = it->first.hv = it->last.hv = 0;
1548     VDP_setReg(10, 17);
1549     move_sr(0x2000);
1550     while (read16(VDP_CTRL_PORT) & 8)
1551         /* blanking */;
1552     VDP_setReg(10, 255);
1553     while (read8(VDP_HV_COUNTER) != 228)
1554         ;
1555     move_sr(0x2700);
1556     expect(ok, it->cnt, 1);
1557     expect(ok, it->first.v, 17);
1558     expect(ok, it->last.v, 17);
1559
1560     VDP_setReg(VDP_MODE1, VDP_MODE1_PS);
1561
1562     return ok;
1563 }
1564
1565 static int t_irq_both_cpu_unmask(void)
1566 {
1567     struct irq_test *ith = (void *)0xfff000;
1568     struct irq_test *itv = ith + 1;
1569     u16 s0, s1;
1570     int ok = 1;
1571
1572     memset_(ith, 0, sizeof(*ith) * 2);
1573     memcpy_((void *)0xff0100, test_hint, test_hint_end - test_hint);
1574     memcpy_((void *)0xff0140, test_vint, test_vint_end - test_vint);
1575     VDP_setReg(10, 0);
1576     while (read8(VDP_HV_COUNTER) != 100)
1577         ;
1578     while (read8(VDP_HV_COUNTER) != 226)
1579         ;
1580     VDP_setReg(10, 99);
1581     VDP_setReg(VDP_MODE1, VDP_MODE1_PS | VDP_MODE1_IE1);
1582     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_IE0 | VDP_MODE2_DISP);
1583     /* go to active display line 100 */
1584     while (read8(VDP_HV_COUNTER) != 100)
1585         ;
1586     s0 = read16(VDP_CTRL_PORT);
1587     s1 = move_sr_and_read(0x2000, VDP_CTRL_PORT);
1588     move_sr(0x2700);
1589     VDP_setReg(VDP_MODE1, VDP_MODE1_PS);
1590     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
1591
1592     expect(ok, itv->cnt, 1);       // vint count
1593     expect(ok, itv->first.v, 100); // vint line
1594     expect(ok, ith->cnt, 1);       // hint count
1595     expect(ok, ith->first.v, 100); // hint line
1596     expect_bits(ok, s0, SR_F, SR_F);
1597     expect_bits(ok, s1, 0, SR_F);
1598     return ok;
1599 }
1600
1601 static int t_irq_ack_v_h(void)
1602 {
1603     struct irq_test *ith = (void *)0xfff000;
1604     struct irq_test *itv = ith + 1;
1605     u16 s0, s1, s2;
1606     int ok = 1;
1607
1608     memset_(ith, 0, sizeof(*ith) * 2);
1609     memcpy_((void *)0xff0100, test_hint, test_hint_end - test_hint);
1610     memcpy_((void *)0xff0140, test_vint, test_vint_end - test_vint);
1611     VDP_setReg(10, 0);
1612     /* ensure hcnt reload */
1613     while (!(read16(VDP_CTRL_PORT) & 8))
1614         /* not blanking */;
1615     while (read16(VDP_CTRL_PORT) & 8)
1616         /* blanking */;
1617     VDP_setReg(VDP_MODE1, VDP_MODE1_PS | VDP_MODE1_IE1);
1618     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_IE0);
1619     while (read8(VDP_HV_COUNTER) != 100)
1620         ;
1621     while (read8(VDP_HV_COUNTER) != 226)
1622         ;
1623     s0 = read16(VDP_CTRL_PORT);
1624     s1 = move_sr_and_read(0x2500, VDP_CTRL_PORT);
1625     burn10(666 / 10);
1626     s2 = move_sr_and_read(0x2000, VDP_CTRL_PORT);
1627     burn10(488 / 10);
1628     move_sr(0x2700);
1629     VDP_setReg(VDP_MODE1, VDP_MODE1_PS);
1630     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
1631
1632     expect(ok, itv->cnt, 1);       // vint count
1633     expect(ok, itv->first.v, 226); // vint line
1634     expect(ok, ith->cnt, 1);       // hint count
1635     expect(ok, ith->first.v, 228); // hint line
1636     expect_bits(ok, s0, SR_F, SR_F);
1637     expect_bits(ok, s1, 0, SR_F);
1638     expect_bits(ok, s2, 0, SR_F);
1639     return ok;
1640 }
1641
1642 static int t_irq_ack_v_h_2(void)
1643 {
1644     struct irq_test *ith = (void *)0xfff000;
1645     struct irq_test *itv = ith + 1;
1646     u16 s0, s1;
1647     int ok = 1;
1648
1649     memset_(ith, 0, sizeof(*ith) * 2);
1650     memcpy_((void *)0xff0100, test_hint, test_hint_end - test_hint);
1651     memcpy_((void *)0xff0140, test_vint, test_vint_end - test_vint);
1652     VDP_setReg(10, 0);
1653     while (read8(VDP_HV_COUNTER) != 100)
1654         ;
1655     while (read8(VDP_HV_COUNTER) != 226)
1656         ;
1657     s0 = read16(VDP_CTRL_PORT);
1658     test_v_h_2();
1659     s1 = read16(VDP_CTRL_PORT);
1660     VDP_setReg(VDP_MODE1, VDP_MODE1_PS);
1661     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
1662
1663     expect(ok, itv->cnt, 2);       // vint count
1664     expect(ok, itv->first.v, 226); // vint line
1665     expect(ok, ith->cnt, 1);       // hint count
1666     expect(ok, ith->first.v, 227); // hint line
1667     expect_bits(ok, s0, SR_F, SR_F);
1668     expect_bits(ok, s1, 0, SR_F);
1669     return ok;
1670 }
1671
1672 static int t_irq_ack_h_v(void)
1673 {
1674     u16 *ram = (u16 *)0xfff000;
1675     u8 *ram8 = (u8 *)0xfff000;
1676     u16 s0, s1, s[4];
1677     int ok = 1;
1678
1679     ram[0] = ram[1] = ram[2] =
1680     ram[4] = ram[5] = ram[6] = 0;
1681     memcpy_((void *)0xff0100, test_hint, test_hint_end - test_hint);
1682     memcpy_((void *)0xff0140, test_vint, test_vint_end - test_vint);
1683     VDP_setReg(10, 0);
1684     while (read8(VDP_HV_COUNTER) != 100)
1685         ;
1686     while (read8(VDP_HV_COUNTER) != 226)
1687         ;
1688     s0 = read16(VDP_CTRL_PORT);
1689     VDP_setReg(VDP_MODE1, VDP_MODE1_PS | VDP_MODE1_IE1);
1690     move_sr(0x2000);
1691     burn10(666 / 10);
1692     s1 = read16(VDP_CTRL_PORT);
1693     write_and_read1(VDP_CTRL_PORT, 0x8000 | (VDP_MODE2 << 8)
1694                      | VDP_MODE2_MD | VDP_MODE2_IE0, s);
1695     move_sr(0x2700);
1696     VDP_setReg(VDP_MODE1, VDP_MODE1_PS);
1697     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
1698
1699     expect(ok, ram[0], 1);     // hint count
1700     expect(ok, ram8[2], 226);  // hint line
1701     expect(ok, ram[4], 1);     // vint count
1702     expect(ok, ram8[10], 228); // vint line
1703     expect_bits(ok, s0, SR_F, SR_F);
1704     expect_bits(ok, s1, SR_F, SR_F);
1705     expect_bits(ok, s[0], SR_F, SR_F);
1706     expect_bits(ok, s[1], SR_F, SR_F);
1707     expect_bits(ok, s[2], 0, SR_F);
1708     expect_bits(ok, s[3], 0, SR_F);
1709     return ok;
1710 }
1711
1712 static int t_irq_ack_h_v_2(void)
1713 {
1714     u16 *ram = (u16 *)0xfff000;
1715     u8 *ram8 = (u8 *)0xfff000;
1716     u16 s0, s1;
1717     int ok = 1;
1718
1719     ram[0] = ram[1] = ram[2] =
1720     ram[4] = ram[5] = ram[6] = 0;
1721     memcpy_((void *)0xff0100, test_hint, test_hint_end - test_hint);
1722     memcpy_((void *)0xff0140, test_vint, test_vint_end - test_vint);
1723     VDP_setReg(10, 0);
1724     while (read8(VDP_HV_COUNTER) != 100)
1725         ;
1726     while (read8(VDP_HV_COUNTER) != 226)
1727         ;
1728     s0 = read16(VDP_CTRL_PORT);
1729     test_h_v_2();
1730     s1 = read16(VDP_CTRL_PORT);
1731     VDP_setReg(VDP_MODE1, VDP_MODE1_PS);
1732     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
1733
1734     expect(ok, ram[0], 2);     // hint count
1735     expect(ok, ram8[2], 226);  // hint first line
1736     expect(ok, ram8[4], 226);  // hint last line
1737     expect(ok, ram[4], 0);     // vint count
1738     expect(ok, ram8[10], 0);   // vint line
1739     expect_bits(ok, s0, SR_F, SR_F);
1740     expect_bits(ok, s1, 0, SR_F);
1741     return ok;
1742 }
1743
1744 static void t_irq_f_flag(void)
1745 {
1746     memcpy_((void *)0xff0140, test_f_vint, test_f_vint_end - test_f_vint);
1747     memset_((void *)0xff0000, 0, 10);
1748     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_IE0 | VDP_MODE2_DISP);
1749     test_f();
1750     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
1751 }
1752
1753 static int t_irq_f_flag_h40(void)
1754 {
1755     u8 f, *r = (u8 *)0xff0000;
1756     int ok = 1;
1757
1758     t_irq_f_flag();
1759
1760     expect_bits(ok, r[0], 0, SR_F);
1761     expect_bits(ok, r[1], 0, SR_F);
1762     expect_bits(ok, r[2], 0, SR_F);
1763     // hits 1-3 times in range 3-9, usually ~5
1764     f = r[3] | r[4] | r[5] | r[6] | r[7];
1765
1766     expect_bits(ok, r[10], 0, SR_F);
1767     expect_bits(ok, r[11], 0, SR_F);
1768     expect_bits(ok, f, SR_F, SR_F);
1769     return ok;
1770 }
1771
1772 static int t_irq_f_flag_h32(void)
1773 {
1774     u8 f, *r = (u8 *)0xff0000;
1775     int ok = 1;
1776
1777     VDP_setReg(VDP_MODE4, 0x00);
1778     t_irq_f_flag();
1779     VDP_setReg(VDP_MODE4, 0x81);
1780
1781     expect_bits(ok, r[0], 0, SR_F);
1782     expect_bits(ok, r[1], 0, SR_F);
1783     // hits 1-3 times in range 2-7, usually 3
1784     f = r[2] | r[3] | r[4] | r[5] | r[6] | r[7];
1785
1786     expect_bits(ok, r[8], 0, SR_F);
1787     expect_bits(ok, r[9], 0, SR_F);
1788     expect_bits(ok, r[10], 0, SR_F);
1789     expect_bits(ok, r[11], 0, SR_F);
1790     expect_bits(ok, f, SR_F, SR_F);
1791     return ok;
1792 }
1793
1794 // 32X
1795
1796 #define IRQ_CNT_FB_BASE 0x1ff00
1797
1798 // see do_cmd()
1799 static void x32_cmd(enum x32x_cmd cmd, u32 a0, u32 a1, u16 is_slave)
1800 {
1801     u16 v, *r = (u16 *)0xa15120;
1802     u8 *r8 = (u8 *)r;
1803     u16 cmd_s = cmd | (is_slave << 15);
1804     int i;
1805
1806     write32(&r[4/2], a0);
1807     write32(&r[8/2], a1);
1808     mem_barrier();
1809     write16(r, cmd_s);
1810     mem_barrier();
1811     for (i = 0; i < 10000 && (v = read16(r)) == cmd_s; i++)
1812         burn10(1);
1813     if (v != 0) {
1814         printf("cmd clr: %x\n", v);
1815         mem_barrier();
1816         printf("exc m s: %02x %02x\n", r8[0x0e], r8[0x0f]);
1817         write16(r, 0);
1818     }
1819     v = read16(&r[1]);
1820     if (v != 0) {
1821         printf("cmd err: %x\n", v);
1822         write16(&r[1], 0);
1823     }
1824 }
1825
1826 static int t_32x_reset_btn(void)
1827 {
1828     void (*do_32x_disable)(void) = (void *)0xff0040;
1829     u32 *fbl_icnt = (u32 *)(0x840000 + IRQ_CNT_FB_BASE);
1830     u16 *m_icnt = (u16 *)fbl_icnt;
1831     u16 *s_icnt = m_icnt + 8;
1832     u32 *r32 = (u32 *)0xa15100;
1833     u16 *r16 = (u16 *)r32, i, s;
1834     u8 *r8 = (u8 *)r32;
1835     u32 *rl = (u32 *)0;
1836     int ok = 1;
1837
1838     if (!(read16(r16) & 1))
1839         return R_SKIP;
1840
1841     expect(ok, r16[0x00/2], 0x8083);
1842
1843     write8(r8, 0x00); // FM=0
1844     mem_barrier();
1845     expect(ok, r16[0x00/2], 0x83);
1846     expect(ok, r16[0x02/2], 0);
1847     expect(ok, r16[0x04/2], 3);
1848     expect(ok, r16[0x06/2], 1); // RV (set in sega_gcc.s reset handler)
1849     expect(ok, r32[0x08/4], 0x5a5a08);
1850     expect(ok, r32[0x0c/4], 0x5a5a0c);
1851     expect(ok, r16[0x10/2], 0x5a10);
1852     expect(ok, r32[0x14/4], 0);
1853     expect(ok, r32[0x18/4], 0);
1854     expect(ok, r32[0x1c/4], 0);
1855     expect(ok, r32[0x20/4], 0x00005a20);
1856     expect(ok, r32[0x24/4], 0x5a5a5a24);
1857     expect(ok, r32[0x28/4], 0x5a5a5a28);
1858     expect(ok, r32[0x2c/4], 0x075a5a2c); // 7 - last_irq_vec
1859     if (!(r16[0x00/2] & 0x8000)) {
1860         expect(ok, r8 [0x81], 1);
1861         expect(ok, r16[0x82/2], 1);
1862         expect(ok, r16[0x84/2], 0xff);
1863         expect(ok, r16[0x86/2], 0xffff);
1864         expect(ok, r16[0x88/2], 0);
1865         expect(ok, r8 [0x8b] & ~2, 0); // FEN toggles periodically?
1866         expect(ok, r16[0x8c/2], 0);
1867         expect(ok, r16[0x8e/2], 0);
1868         // setup vdp for t_32x_init
1869         r8 [0x81] = 0;
1870         r16[0x82/2] = r16[0x84/2] = r16[0x86/2] = 0;
1871     }
1872     r32[0x20/4] = r32[0x24/4] = r32[0x28/4] = r32[0x2c/4] = 0;
1873     for (s = 0; s < 2; s++)
1874     {
1875         x32_cmd(CMD_READ32, 0x20004000, 0, s); // not cleared by hw
1876         expect_sh2(ok, s, r32[0x24/4], 0x02020000); // ADEN | cmd
1877         // t_32x_sh_defaults will test the other bits
1878     }
1879     // setup for t_32x_sh_defaults
1880     x32_cmd(CMD_WRITE8, 0x20004001, 0, 0);
1881     x32_cmd(CMD_WRITE8, 0x20004001, 0, 1);
1882
1883     for (i = 0; i < 7; i++) {
1884         expect(ok, m_icnt[i], 0x100);
1885         expect(ok, s_icnt[i], 0x100);
1886     }
1887     expect(ok, m_icnt[7], 0x101); // VRES happened
1888     expect(ok, s_icnt[7], 0x100); // masked on slave
1889
1890     x32_cmd(CMD_GETSR, 0, 0, 1);
1891     expect_sh2(ok, 1, r32[0x24/4] & ~1, 0xf0); // still masked
1892     x32_cmd(CMD_SETSR, 0x10, 0, 1);
1893     expect(ok, r16[0x00/2], 0x8083);
1894     write8(r8, 0x00); // FM=0
1895     mem_barrier();
1896     expect(ok, m_icnt[7], 0x101);
1897     expect(ok, s_icnt[7], 0x101);
1898     expect(ok, r32[0x2c/4], 0x00070000); // 7 - last_irq_vec
1899     r32[0x2c/4] = 0;
1900
1901     memcpy_(do_32x_disable, x32x_disable,
1902             x32x_disable_end - x32x_disable);
1903     do_32x_disable();
1904
1905     expect(ok, r16[0x00/2], 0x82);
1906     expect(ok, r16[0x02/2], 0);
1907     expect(ok, r16[0x04/2], 3);
1908     expect(ok, r16[0x06/2], 0); // RV cleared by x32x_disable
1909     expect(ok, r32[0x08/4], 0x5a5a08);
1910     expect(ok, r32[0x0c/4], 0x5a5a0c);
1911     expect(ok, r16[0x10/2], 0x5a10);
1912     expect(ok, rl[0x04/4], 0x000800);
1913
1914     // setup for t_32x_init, t_32x_sh_defaults
1915     r16[0x04/2] = 0;
1916     r16[0x10/2] = 0x1234; // warm reset indicator
1917     mem_barrier();
1918     expect(ok, r16[0x06/2], 0); // RV
1919     return ok;
1920 }
1921
1922 static int t_32x_init(void)
1923 {
1924     void (*do_32x_enable)(void) = (void *)0xff0040;
1925     u32 M_OK = MKLONG('M','_','O','K');
1926     u32 S_OK = MKLONG('S','_','O','K');
1927     u32 *r32 = (u32 *)0xa15100;
1928     u16 *r16 = (u16 *)r32;
1929     u8 *r8 = (u8 *)r32;
1930     int i, ok = 1;
1931
1932     //v1070 = read32(0x1070);
1933
1934     /* what does REN mean exactly?
1935      * Seems to be sometimes clear after reset */
1936     for (i = 0; i < 1000000; i++)
1937         if (read16(r16) & 0x80)
1938             break;
1939     expect(ok, r16[0x00/2], 0x82);
1940     expect(ok, r16[0x02/2], 0);
1941     expect(ok, r16[0x04/2], 0);
1942     expect(ok, r16[0x06/2], 0);
1943     expect(ok, r8 [0x08], 0);
1944     //expect(ok, r32[0x08/4], 0); // garbage 24bit
1945     expect(ok, r8 [0x0c], 0);
1946     //expect(ok, r32[0x0c/4], 0); // garbage 24bit
1947     if (r16[0x10/2] != 0x1234)    // warm reset
1948         expect(ok, r16[0x10/2], 0xffff);
1949     expect(ok, r16[0x12/2], 0);
1950     expect(ok, r32[0x14/4], 0);
1951     expect(ok, r32[0x18/4], 0);
1952     expect(ok, r32[0x1c/4], 0);
1953     //expect(ok, r8 [0x81], 0); // VDP; hangs without ADEN
1954     r32[0x20/4] = 0; // master resp
1955     r32[0x24/4] = 0; // slave resp
1956     r32[0x28/4] = 0;
1957     r32[0x2c/4] = 0;
1958
1959     // check writable bits without ADEN
1960     // 08,0c have garbage or old values (survive MD's power cycle)
1961     write16(&r16[0x00/2], 0);
1962     mem_barrier();
1963     expect(ok, r16[0x00/2], 0x80);
1964     write16(&r16[0x00/2], 0xfffe);
1965     mem_barrier();
1966     expect(ok, r16[0x00/2], 0x8082);
1967     r16[0x00/2] = 0x82;
1968     r16[0x02/2] = 0xffff;
1969     r32[0x04/4] = 0xffffffff;
1970     r32[0x08/4] = 0xffffffff;
1971     r32[0x0c/4] = 0xffffffff;
1972     r16[0x10/2] = 0xffff;
1973     r32[0x14/4] = 0xffffffff;
1974     r32[0x18/4] = 0xffffffff;
1975     r32[0x1c/4] = 0xffffffff;
1976     mem_barrier();
1977     expect(ok, r16[0x00/2], 0x82);
1978     expect(ok, r16[0x02/2], 0x03);
1979     expect(ok, r16[0x04/2], 0x03);
1980     expect(ok, r16[0x06/2], 0x07);
1981     expect(ok, r32[0x08/4], 0x00fffffe);
1982     expect(ok, r32[0x0c/4], 0x00ffffff);
1983     expect(ok, r16[0x10/2], 0xfffc);
1984     expect(ok, r32[0x14/4], 0);
1985     expect(ok, r16[0x18/2], 0);
1986     expect(ok, r16[0x1a/2], 0x0101);
1987     expect(ok, r32[0x1c/4], 0);
1988     r16[0x02/2] = 0;
1989     r32[0x04/4] = 0;
1990     r32[0x08/4] = 0;
1991     r32[0x0c/4] = 0;
1992     r16[0x1a/2] = 0;
1993
1994     // could just set RV, but BIOS reads ROM, so can't
1995     memcpy_(do_32x_enable, x32x_enable,
1996             x32x_enable_end - x32x_enable);
1997     do_32x_enable();
1998
1999     expect(ok, r16[0x00/2], 0x83);
2000     expect(ok, r16[0x02/2], 0);
2001     expect(ok, r16[0x04/2], 0);
2002     expect(ok, r16[0x06/2], 1); // RV
2003     expect(ok, r32[0x14/4], 0);
2004     expect(ok, r32[0x18/4], 0);
2005     expect(ok, r32[0x1c/4], 0);
2006     expect(ok, r32[0x20/4], M_OK);
2007     while (!read16(&r16[0x24/2]))
2008         ;
2009     expect(ok, r32[0x24/4], S_OK);
2010     write32(&r32[0x20/4], 0);
2011     if (!(r16[0x00/2] & 0x8000)) {
2012         expect(ok, r8 [0x81], 0);
2013         expect(ok, r16[0x82/2], 0);
2014         expect(ok, r16[0x84/2], 0);
2015         expect(ok, r16[0x86/2], 0);
2016         //expect(ok, r16[0x88/2], 0); // triggers fill?
2017         expect(ok, r8 [0x8b] & ~2, 0);
2018         expect(ok, r16[0x8c/2], 0);
2019         expect(ok, r16[0x8e/2], 0);
2020     }
2021     return ok;
2022 }
2023
2024 static int t_32x_echo(void)
2025 {
2026     u16 *r16 = (u16 *)0xa15100;
2027     int ok = 1;
2028
2029     r16[0x2c/2] = r16[0x2e/2] = 0;
2030     x32_cmd(CMD_ECHO, 0x12340000, 0, 0);
2031     expect_sh2(ok, 0, r16[0x26/2], 0x1234);
2032     x32_cmd(CMD_ECHO, 0x23450000, 0, 1);
2033     expect_sh2(ok, 1, r16[0x26/2], 0xa345);
2034     expect(ok, r16[0x2c/2], 0); // no last_irq_vec
2035     expect(ok, r16[0x2e/2], 0); // no exception_index
2036     return ok;
2037 }
2038
2039 static int t_32x_sh_defaults(void)
2040 {
2041     u32 *r32 = (u32 *)0xa15120;
2042     int ok = 1, s;
2043
2044     for (s = 0; s < 2; s++)
2045     {
2046         x32_cmd(CMD_READ32, 0x20004000, 0, s);
2047         expect_sh2(ok, s, r32[0x04/4], 0x02000000); // ADEN
2048         x32_cmd(CMD_READ32, 0x20004004, 0, s);
2049         expect_sh2(ok, s, r32[0x04/4], 0x00004001); // Empty Rv
2050         x32_cmd(CMD_READ32, 0x20004008, 0, s);
2051         expect_sh2(ok, s, r32[0x04/4], 0);
2052         x32_cmd(CMD_READ32, 0x2000400c, 0, s);
2053         expect_sh2(ok, s, r32[0x04/4], 0);
2054         x32_cmd(CMD_GETGBR, 0, 0, s);
2055         expect_sh2(ok, s, r32[0x04/4], 0x20004000);
2056     }
2057     return ok;
2058 }
2059
2060 static int t_32x_md_bios(void)
2061 {
2062     void (*do_call_c0)(int a, int d) = (void *)0xff0040;
2063     u8 *rmb = (u8 *)0xff0000;
2064     u32 *rl = (u32 *)0;
2065     int ok = 1;
2066
2067     memcpy_(do_call_c0, test_32x_b_c0,
2068             test_32x_b_c0_end - test_32x_b_c0);
2069     write8(rmb, 0);
2070     do_call_c0(0xff0000, 0x5a);
2071
2072     expect(ok, rmb[0], 0x5a);
2073     expect(ok, rl[0x04/4], 0x880200);
2074     expect(ok, rl[0x10/4], 0x880212);
2075     expect(ok, rl[0x94/4], 0x8802d8);
2076     return ok;
2077 }
2078
2079 static int t_32x_md_rom(void)
2080 {
2081     u32 *rl = (u32 *)0;
2082     int ok = 1;
2083
2084     expect(ok, rl[0x004/4], 0x880200);
2085     expect(ok, rl[0x100/4], 0x53454741);
2086     expect(ok, rl[0x70/4], 0);
2087     write32(&rl[0x70/4], 0xa5123456);
2088     write32(&rl[0x78/4], ~0);
2089     mem_barrier();
2090     expect(ok, rl[0x78/4], 0x8802ae);
2091     expect(ok, rl[0x70/4], 0xa5123456);
2092     //expect(ok, rl[0x1070/4], v1070);
2093     write32(&rl[0x70/4], 0);
2094     // with RV 0x880000/0x900000 hangs, can't test
2095     return ok;
2096 }
2097
2098 static int t_32x_md_fb(void)
2099 {
2100     u8  *fbb = (u8 *)0x840000;
2101     u16 *fbw = (u16 *)fbb;
2102     u32 *fbl = (u32 *)fbb;
2103     u8  *fob = (u8 *)0x860000;
2104     u16 *fow = (u16 *)fob;
2105     u32 *fol = (u32 *)fob;
2106     int ok = 1;
2107
2108     fbl[0] = 0x12345678;
2109     fol[1] = 0x89abcdef;
2110     mem_barrier();
2111     expect(ok, fbw[1], 0x5678);
2112     expect(ok, fow[2], 0x89ab);
2113     fbb[0] = 0;
2114     fob[1] = 0;
2115     fbw[1] = 0;
2116     fow[2] = 0;
2117     fow[3] = 1;
2118     mem_barrier();
2119     fow[3] = 0x200;
2120     mem_barrier();
2121     expect(ok, fol[0], 0x12340000);
2122     expect(ok, fbl[1], 0x89ab0201);
2123     return ok;
2124 }
2125
2126 static int t_32x_sh_fb(void)
2127 {
2128     u32 *fbl = (u32 *)0x840000;
2129     u8 *r8 = (u8 *)0xa15100;
2130     int ok = 1;
2131
2132     if (read8(r8) & 0x80)
2133         write8(r8, 0x00); // FM=0
2134     fbl[0] = 0x12345678;
2135     fbl[1] = 0x89abcdef;
2136     mem_barrier();
2137     write8(r8, 0x80);     // FM=1
2138     x32_cmd(CMD_WRITE8,  0x24000000, 0, 0); // should ignore
2139     x32_cmd(CMD_WRITE8,  0x24020001, 0, 0); // ignore
2140     x32_cmd(CMD_WRITE16, 0x24000002, 0, 0); // ok
2141     x32_cmd(CMD_WRITE16, 0x24020000, 0, 0); // ignore
2142     x32_cmd(CMD_WRITE32, 0x24020004, 0x5a0000a5, 1);
2143     write8(r8, 0x00);     // FM=0
2144     mem_barrier();
2145     expect(ok, fbl[0], 0x12340000);
2146     expect(ok, fbl[1], 0x5aabcda5);
2147     return ok;
2148 }
2149
2150 static int t_32x_irq(void)
2151 {
2152     u32 *fbl_icnt = (u32 *)(0x840000 + IRQ_CNT_FB_BASE);
2153     u16 *m_icnt = (u16 *)fbl_icnt;
2154     u16 *s_icnt = m_icnt + 8;
2155     u32 *r = (u32 *)0xa15100;
2156     u16 *r16 = (u16 *)r;
2157     u8 *r8 = (u8 *)r;
2158     int ok = 1, i;
2159
2160     write8(r, 0x00); // FM=0
2161     r[0x2c/4] = 0;
2162     mem_barrier();
2163     for (i = 0; i < 8; i++)
2164         write32(&fbl_icnt[i], 0);
2165     mem_barrier();
2166     write16(&r16[0x02/2], 0xfffd); // INTM+unused_bits
2167     mem_barrier();
2168     expect(ok, r16[0x02/2], 1);
2169     x32_cmd(CMD_WRITE8, 0x20004001, 2, 0); // unmask cmd
2170     x32_cmd(CMD_WRITE8, 0x20004001, 2, 1); // unmask cmd slave
2171     burn10(10);
2172     write8(r, 0x00); // FM=0 (hangs without)
2173     mem_barrier();
2174     expect(ok, r16[0x02/2], 0);
2175     expect(ok, r8 [0x2c], 4);
2176     expect(ok, r8 [0x2d], 0);
2177     expect(ok, r16[0x2e/2], 0); // no exception_index
2178     expect(ok, m_icnt[4], 1);
2179     expect(ok, s_icnt[4], 0);
2180     write16(&r16[0x02/2], 0xaaaa); // INTS+unused_bits
2181     mem_barrier();
2182     expect(ok, r16[0x02/2], 2);
2183     burn10(10);
2184     mem_barrier();
2185     expect(ok, r16[0x02/2], 0);
2186     expect(ok, r8 [0x2c], 4);
2187     expect(ok, r8 [0x2d], 4);
2188     expect(ok, r16[0x2e/2], 0); // no exception_index
2189     write8(r, 0x00); // FM=0
2190     mem_barrier();
2191     expect(ok, m_icnt[4], 1);
2192     expect(ok, s_icnt[4], 1);
2193     for (i = 0; i < 8; i++) {
2194         if (i == 4)
2195             continue;
2196         expect(ok, m_icnt[i], 0);
2197         expect(ok, s_icnt[i], 0);
2198     }
2199     return ok;
2200 }
2201
2202 static int t_32x_reg_w(void)
2203 {
2204     u32 *r32 = (u32 *)0xa15100;
2205     u16 *r16 = (u16 *)r32, old;
2206     int ok = 1;
2207
2208     r32[0x08/4] = ~0;
2209     r32[0x0c/4] = ~0;
2210     r16[0x10/2] = ~0;
2211     mem_barrier();
2212     expect(ok, r32[0x08/4], 0xfffffe);
2213     expect(ok, r32[0x0c/4], 0xffffff);
2214     expect(ok, r16[0x10/2], 0xfffc);
2215     mem_barrier();
2216     r32[0x08/4] = r32[0x0c/4] = 0;
2217     r16[0x10/2] = 0;
2218     old = r16[0x06/2];
2219     x32_cmd(CMD_WRITE16, 0x20004006, ~old, 0);
2220     expect(ok, r16[0x06/2], old);
2221     return ok;
2222 }
2223
2224 // prepare for reset btn press tests
2225 static int t_32x_reset_prep(void)
2226 {
2227     u32 *fbl = (u32 *)0x840000;
2228     u32 *fbl_icnt = fbl + IRQ_CNT_FB_BASE / 4;
2229     u32 *r32 = (u32 *)0xa15100;
2230     u16 *r16 = (u16 *)r32;
2231     u8 *r8 = (u8 *)r32;
2232     int ok = 1, i;
2233
2234     expect(ok, r16[0x00/2], 0x83);
2235     write8(r8, 0x00); // FM=0
2236     r32[0x2c/4] = 0;
2237     mem_barrier();
2238     expect(ok, r8[0x8b] & ~2, 0);
2239     for (i = 0; i < 8; i++)
2240         write32(&fbl_icnt[i], 0x01000100);
2241     x32_cmd(CMD_WRITE8, 0x20004001, 0x02, 0); // unmask cmd
2242     x32_cmd(CMD_WRITE8, 0x20004001, 0x02, 1); // unmask slave
2243     x32_cmd(CMD_SETSR, 0xf0, 0, 1);           // mask slave irqs (on the cpu)
2244     burn10(10);
2245     write8(r8, 0x00); // FM=0
2246     expect(ok, r32[0x2c/4], 0);
2247     mem_barrier();
2248     for (i = 0; i < 8; i++)
2249         expect(ok, fbl_icnt[i], 0x01000100);
2250
2251     r16[0x04/2] = 0xffff;
2252     r32[0x08/4] = 0x5a5a5a08;
2253     r32[0x0c/4] = 0x5a5a5a0c;
2254     r16[0x10/2] = 0x5a10;
2255     r32[0x20/4] = 0x00005a20; // no x32_cmd
2256     r32[0x24/4] = 0x5a5a5a24;
2257     r32[0x28/4] = 0x5a5a5a28;
2258     r32[0x2c/4] = 0x5a5a5a2c;
2259     if (!(r16[0x00/2] & 0x8000)) {
2260         wait_next_vsync();
2261         r16[0x8a/2] = 0x0001;
2262         mem_barrier();
2263         for (i = 0; i < 220/2; i++)
2264             write32(&fbl[i], 0);
2265         r8 [0x81] = 1;
2266         r16[0x82/2] = 0xffff;
2267         r16[0x84/2] = 0xffff;
2268         r16[0x86/2] = 0xffff;
2269         r16[0x8a/2] = 0x0000;
2270         r16[0x8c/2] = 0xffff;
2271         r16[0x8e/2] = 0xffff;
2272         r16[0x100/2] = 0;
2273     }
2274     return ok;
2275 }
2276
2277 enum {
2278     T_MD = 0,
2279     T_32 = 1, // 32X
2280 };
2281
2282 static const struct {
2283     u8 type;
2284     int (*test)(void);
2285     const char *name;
2286 } g_tests[] = {
2287     // this must be first to disable the 32x and restore the 68k vector table
2288     { T_32, t_32x_reset_btn,       "32x resetbtn" },
2289
2290     { T_MD, t_dma_zero_wrap,       "dma zero len + wrap" },
2291     { T_MD, t_dma_zero_fill,       "dma zero len + fill" },
2292     { T_MD, t_dma_ram_wrap,        "dma ram wrap" },
2293     { T_MD, t_dma_multi,           "dma multi" },
2294     { T_MD, t_dma_cram_wrap,       "dma cram wrap" },
2295     { T_MD, t_dma_vsram_wrap,      "dma vsram wrap" },
2296     { T_MD, t_dma_and_data,        "dma and data" },
2297     { T_MD, t_dma_short_cmd,       "dma short cmd" },
2298     { T_MD, t_dma_fill3_odd,       "dma fill3 odd" },
2299     { T_MD, t_dma_fill3_even,      "dma fill3 even" },
2300     { T_MD, t_dma_fill3_vsram,     "dma fill3 vsram" },
2301     { T_MD, t_dma_fill_dis,        "dma fill disabled" },
2302     { T_MD, t_dma_fill_src,        "dma fill src incr" },
2303     { T_MD, t_dma_busy_vram,       "dma no busy" },
2304     { T_MD, t_dma_128k,            "dma 128k mode" },
2305     { T_MD, t_vdp_128k_b16,        "vdp 128k addr bit16" },
2306     // { t_vdp_128k_b16_inc,    "vdp 128k bit16 inc" }, // mystery
2307     { T_MD, t_vdp_reg_cmd,         "vdp reg w cmd reset" },
2308     { T_MD, t_vdp_sr_vb,           "vdp status reg vb" },
2309     { T_MD, t_z80mem_long_mirror,  "z80 ram long mirror" },
2310     { T_MD, t_z80mem_noreq_w,      "z80 ram noreq write" },
2311     { T_MD, t_z80mem_vdp_r,        "z80 vdp read" },
2312     // { t_z80mem_vdp_w,        "z80 vdp write" }, // hang
2313     { T_MD, t_tim_loop,            "time loop" },
2314     { T_MD, t_tim_z80_loop,        "time z80 loop" },
2315     { T_MD, t_tim_z80_ram,         "time z80 ram" },
2316     { T_MD, t_tim_z80_ym,          "time z80 ym2612" },
2317     { T_MD, t_tim_z80_vdp,         "time z80 vdp" },
2318     { T_MD, t_tim_z80_bank_rom,    "time z80 bank rom" },
2319     { T_MD, t_tim_vcnt,            "time V counter" },
2320     { T_MD, t_tim_vcnt_loops,      "time vcnt loops" },
2321     { T_MD, t_tim_hblank_h40,      "time hblank h40" },
2322     { T_MD, t_tim_hblank_h32,      "time hblank h32" },
2323     { T_MD, t_tim_vdp_as_vram_w,   "time vdp vram w" },
2324     { T_MD, t_tim_vdp_as_cram_w,   "time vdp cram w" },
2325     { T_MD, t_tim_ym_timera_z80,   "time timer a z80" },
2326     { T_MD, t_tim_ym_timerb_z80,   "time timer b z80" },
2327     { T_MD, t_tim_ym_timerb_stop,  "timer b stop" },
2328     { T_MD, t_tim_ym_timer_ab_sync,"timer ab sync" },
2329     { T_MD, t_irq_hint,            "irq4 / line" },
2330     { T_MD, t_irq_both_cpu_unmask, "irq both umask" },
2331     { T_MD, t_irq_ack_v_h,         "irq ack v-h" },
2332     { T_MD, t_irq_ack_v_h_2,       "irq ack v-h 2" },
2333     { T_MD, t_irq_ack_h_v,         "irq ack h-v" },
2334     { T_MD, t_irq_ack_h_v_2,       "irq ack h-v 2" },
2335     { T_MD, t_irq_f_flag_h40,      "irq f flag h40" },
2336     { T_MD, t_irq_f_flag_h32,      "irq f flag h32" },
2337
2338     // the first one enables 32X, so must be kept
2339     // all tests assume RV=1 FM=0
2340     { T_32, t_32x_init,            "32x init" },
2341     { T_32, t_32x_echo,            "32x echo" },
2342     { T_32, t_32x_sh_defaults,     "32x sh def" },
2343     { T_32, t_32x_md_bios,         "32x md bios" },
2344     { T_32, t_32x_md_rom,          "32x md rom" },
2345     { T_32, t_32x_md_fb,           "32x md fb" },
2346     { T_32, t_32x_sh_fb,           "32x sh fb" },
2347     { T_32, t_32x_irq,             "32x irq" },
2348     { T_32, t_32x_reg_w,           "32x reg w" },
2349     { T_32, t_32x_reset_prep,      "32x rstprep" }, // must be last 32x
2350 };
2351
2352 static void setup_z80(void)
2353 {
2354     u8 *zram = (u8 *)0xa00000;
2355     int i, len;
2356
2357     /* z80 */
2358     write16(0xa11100, 0x100);
2359     write16(0xa11200, 0x100);
2360
2361     while (read16(0xa11100) & 0x100)
2362         ;
2363
2364     // load the default test program, clear it's data
2365     len = z80_test_end - z80_test;
2366     for (i = 0; i < len; i++)
2367         write8(&zram[i], z80_test[i]);
2368     for (i = 0x1000; i < 0x1007; i++)
2369         write8(&zram[i], 0);
2370
2371     // reset
2372     write16(0xa11200, 0x000);
2373     write16(0xa11100, 0x000);
2374     burn10(1);
2375     write16(0xa11200, 0x100);
2376
2377     burn10(50 * 15 / 7 / 10);  // see z80_test.s80
2378
2379     // take back the bus
2380     write16(0xa11100, 0x100);
2381     while (read16(0xa11100) & 0x100)
2382         ;
2383 }
2384
2385 static unused int hexinc(char *c)
2386 {
2387     (*c)++;
2388     if (*c > 'f') {
2389         *c = '0';
2390         return 1;
2391     }
2392     if (*c == '9' + 1)
2393         *c = 'a';
2394     return 0;
2395 }
2396
2397 int main()
2398 {
2399     void (*px32x_switch_rv)(short rv);
2400     short (*pget_input)(void) = get_input;
2401     int passed = 0;
2402     int skipped = 0;
2403     int have_32x;
2404     int en_32x;
2405     int ret;
2406     u8 v8;
2407     int i;
2408
2409     setup_z80();
2410
2411     /* io */
2412     write8(0xa10009, 0x40);
2413
2414     /* setup VDP */
2415     while (read16(VDP_CTRL_PORT) & 2)
2416         ;
2417
2418     VDP_setReg(VDP_MODE1, VDP_MODE1_PS);
2419     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA);
2420     VDP_setReg(VDP_MODE3, 0x00);
2421     VDP_setReg(VDP_MODE4, 0x81);
2422     VDP_setReg(VDP_NT_SCROLLA, APLANE >> 10);
2423     VDP_setReg(VDP_NT_SCROLLB, BPLANE >> 13);
2424     VDP_setReg(VDP_SAT_BASE, SLIST >> 9);
2425     VDP_setReg(VDP_HSCROLL, HSCRL >> 10);
2426     VDP_setReg(VDP_AUTOINC, 2);
2427     VDP_setReg(VDP_SCROLLSZ, 0x01);
2428     VDP_setReg(VDP_BACKDROP, 0);
2429
2430     // early tests
2431     t_dma_zero_wrap_early();
2432     t_dma_zero_fill_early();
2433
2434     /* pattern 0 */
2435     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(0));
2436     for (i = 0; i < 32 / 4; i++)
2437         write32(VDP_DATA_PORT, 0);
2438
2439     /* clear name tables */
2440     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(APLANE));
2441     for (i = 0; i < PLANE_W * PLANE_H / 2; i++)
2442         write32(VDP_DATA_PORT, 0);
2443
2444     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(BPLANE));
2445     for (i = 0; i < PLANE_W * PLANE_H / 2; i++)
2446         write32(VDP_DATA_PORT, 0);
2447
2448     /* SAT, h. scroll */
2449     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(SLIST));
2450     write32(VDP_DATA_PORT, 0);
2451
2452     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(HSCRL));
2453     write32(VDP_DATA_PORT, 0);
2454
2455     /* scroll plane vscroll */
2456     write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(0));
2457     write32(VDP_DATA_PORT, 0);
2458     printf_ypos = 1;
2459
2460     /* load font */
2461     write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(TILE_FONT_BASE));
2462     for (i = 0; i < FONT_LEN * 32 / 4; i++)
2463         write32(VDP_DATA_PORT, font_base[i]);
2464
2465     /* set colors */
2466     setup_default_palette();
2467
2468     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
2469
2470     have_32x = read32(0xa130ec) == MKLONG('M','A','R','S');
2471     en_32x = have_32x && (read16(0xa15100) & 1);
2472     v8 = read8(0xa10001);
2473     printf("MD version: %02x %s %s %s%s\n", v8,
2474         (v8 & 0x80) ? "world" : "jap",
2475         (v8 & 0x40) ? "pal" : "ntsc",
2476         have_32x ? "32X" : "",
2477         en_32x ? "+" : "");
2478     printf("reset hvc %04x->%04x\n", read16(-4), read16(-2));
2479
2480     // sanity check
2481     extern u32 sh2_test[];
2482     if (sh2_test[0] != read32(0x3e0) || sh2_test[0x200/4] != read32(0x3e4))
2483         printf("bad 0x3c0 tab\n");
2484
2485     for (i = 0; i < ARRAY_SIZE(g_tests); i++) {
2486         // print test number if we haven't scrolled away
2487         if (printf_ypos < CSCREEN_H) {
2488             int old_ypos = printf_ypos;
2489             printf_ypos = 0;
2490             printf("%02d/%02d", i, ARRAY_SIZE(g_tests));
2491             printf_ypos = old_ypos;
2492             printf_xpos = 0;
2493         }
2494         if ((g_tests[i].type & T_32) && !have_32x) {
2495             skipped++;
2496             continue;
2497         }
2498         ret = g_tests[i].test();
2499         if (ret == R_SKIP) {
2500             skipped++;
2501             continue;
2502         }
2503         if (ret != 1) {
2504             text_pal = 2;
2505             printf("failed %d: %s\n", i, g_tests[i].name);
2506             text_pal = 0;
2507         }
2508         else
2509             passed++;
2510     }
2511
2512     text_pal = 0;
2513     printf("%d/%d passed, %d skipped.\n",
2514            passed, ARRAY_SIZE(g_tests), skipped);
2515
2516     printf_ypos = 0;
2517     printf("     ");
2518
2519     if (have_32x && (read16(0xa15100) & 1)) {
2520         u8 *p = (u8 *)0xff0040;
2521         u32 len = x32x_switch_rv_end - x32x_switch_rv;
2522         px32x_switch_rv = (void *)p; p += len;
2523         memcpy_(px32x_switch_rv, x32x_switch_rv, len);
2524
2525         len = get_input_end - get_input_s;
2526         pget_input = (void *)p; p += len;
2527         memcpy_(pget_input, get_input_s, len);
2528
2529         // prepare for reset - run from 880xxx as the reset vector points there
2530         // todo: broken printf
2531         px32x_switch_rv(0);
2532     }
2533     for (i = 0; i < 60*60 && !(pget_input() & BTNM_A); i++) {
2534         while (read16(VDP_CTRL_PORT) & SR_VB)
2535             write16(-4, read16(VDP_HV_COUNTER)); /* blanking */
2536         while (!(read16(VDP_CTRL_PORT) & SR_VB))
2537             write16(-4, read16(VDP_HV_COUNTER)); /* not blanking */;
2538     }
2539 #ifndef PICO
2540     // blank due to my lame tv being burn-in prone
2541     VDP_setReg(VDP_MODE2, VDP_MODE2_MD);
2542 #endif
2543     while (!(pget_input() & BTNM_A))
2544         write16(-4, read16(VDP_HV_COUNTER));
2545     VDP_setReg(VDP_MODE2, VDP_MODE2_MD | VDP_MODE2_DMA | VDP_MODE2_DISP);
2546
2547
2548     {
2549         char c[3] = { '0', '0', '0' };
2550         short hscroll = 0, vscroll = 0;
2551         short hsz = 1, vsz = 0;
2552         short cellmode = 0;
2553
2554         write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(APLANE));
2555
2556 #if 0
2557         for (i = 0, c[0] = 'a'; i < 8 * 1024 / 2; i++) {
2558             write16(VDP_DATA_PORT, (u16)c[0] - 32 + TILE_FONT_BASE / 32);
2559             c[0]++;
2560             if (c[0] == 'z' + 1)
2561                 c[0] = 'a';
2562         }
2563 #else
2564         for (i = 0; i < 8 * 1024 / 2 / 4; i++) {
2565             write16(VDP_DATA_PORT, (u16)'.'  - 32 + TILE_FONT_BASE / 32);
2566             write16(VDP_DATA_PORT, (u16)c[2] - 32 + TILE_FONT_BASE / 32);
2567             write16(VDP_DATA_PORT, (u16)c[1] - 32 + TILE_FONT_BASE / 32);
2568             write16(VDP_DATA_PORT, (u16)c[0] - 32 + TILE_FONT_BASE / 32);
2569             if (hexinc(&c[0]))
2570                 if (hexinc(&c[1]))
2571                     hexinc(&c[2]);
2572         }
2573 #endif
2574         while (pget_input() & BTNM_A)
2575             wait_next_vsync();
2576
2577         wait_next_vsync();
2578         for (;;) {
2579             int b = pget_input();
2580
2581             if (b & BTNM_C) {
2582                 hscroll = 1, vscroll = -1;
2583                 do {
2584                     wait_next_vsync();
2585                 } while (pget_input() & BTNM_C);
2586                 cellmode ^= 1;
2587             }
2588             if (b & (BTNM_L | BTNM_R | BTNM_C)) {
2589                 hscroll += (b & BTNM_L) ? 1 : -1;
2590                 write32(VDP_CTRL_PORT, CTL_WRITE_VRAM(HSCRL));
2591                 write16(VDP_DATA_PORT, hscroll);
2592             }
2593             if (b & (BTNM_U | BTNM_D | BTNM_C)) {
2594                 vscroll += (b & BTNM_U) ? -1 : 1;
2595                 write32(VDP_CTRL_PORT, CTL_WRITE_VSRAM(0));
2596                 if (cellmode) {
2597                     int end = (int)vscroll + 21;
2598                     for (i = vscroll; i < end; i++)
2599                         write32(VDP_DATA_PORT, i << 17);
2600                     VDP_setReg(VDP_MODE3, 0x04);
2601                 }
2602                 else {
2603                     write16(VDP_DATA_PORT, vscroll);
2604                     VDP_setReg(VDP_MODE3, 0x00);
2605                 }
2606             }
2607             if (b & BTNM_A) {
2608                 hsz = (hsz + 1) & 3;
2609                 do {
2610                     wait_next_vsync();
2611                 } while (pget_input() & BTNM_A);
2612             }
2613             if (b & BTNM_B) {
2614                 vsz = (vsz + 1) & 3;
2615                 do {
2616                     wait_next_vsync();
2617                 } while (pget_input() & BTNM_B);
2618             }
2619             VDP_setReg(VDP_SCROLLSZ, (vsz << 4) | hsz);
2620
2621             printf_xpos = 1;
2622             printf_ypos = 0;
2623             text_pal = 1;
2624             printf(" %d %d ", hsz, vsz);
2625
2626             wait_next_vsync();
2627         }
2628     }
2629
2630     for (;;)
2631         ;
2632
2633     return 0;
2634 }
2635
2636 // vim:ts=4:sw=4:expandtab