megaed-stop-md/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
   8 #define u8      unsigned char
   9 #define u16     unsigned short
  10 #define u32     unsigned int
  11
  12 #define GFX_DATA_PORT    0xC00000
  13 #define GFX_CTRL_PORT    0xC00004
  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 read8(a) \
  28     *((volatile u8 *) (a))
  29 #define read16(a) \
  30     *((volatile u16 *) (a))
  31 #define read32(a) \
  32     *((volatile u32 *) (a))
  33 #define write16(a, d) \
  34     *((volatile u16 *) (a)) = (d)
  35 #define write32(a, d) \
  36     *((volatile u32 *) (a)) = (d)
  37
  38 #define GFX_WRITE_VRAM_ADDR(adr) \
  39     (((0x4000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x00)
  40 #define GFX_WRITE_VSRAM_ADDR(adr) \
  41     (((0x4000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x10)
  42 #define GFX_WRITE_CRAM_ADDR(adr) \
  43     (((0xC000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x00)
  44
  45 #define VDP_setReg(r, v) \
  46     write16(GFX_CTRL_PORT, 0x8000 | ((r) << 8) | (v))
  47
  48 enum {
  49     VDP_MODE1 = 0x00,
  50     VDP_MODE2 = 0x01,
  51     VDP_NT_SCROLLA = 0x02,
  52     VDP_NT_WIN = 0x03,
  53     VDP_NT_SCROLLB = 0x04,
  54     VDP_SAT_BASE = 0x05,
  55     VDP_BACKDROP = 0x07,
  56     VDP_MODE3 = 0x0b,
  57     VDP_MODE4 = 0x0c,
  58     VDP_HSCROLL = 0x0d,
  59     VDP_AUTOINC = 0x0f,
  60     VDP_SCROLLSZ = 0x10,
  61 };
  62
  63 /* cell counts */
  64 #define LEFT_BORDER 1   /* lame TV */
  65 #define PLANE_W 64
  66 #define PLANE_H 32
  67 #define CSCREEN_H 28
  68
  69 static void VDP_drawTextML(const char *str, u16 plane_base,
  70     u16 x, u16 y)
  71 {
  72     const u8 *src = (const u8 *)str;
  73     u16 basetile = 0;
  74     int max_len = 40 - LEFT_BORDER;
  75     int len;
  76     u32 addr;
  77
  78     x += LEFT_BORDER;
  79
  80     for (len = 0; str[len] && len < max_len; len++)
  81         ;
  82     if (len > (PLANE_W - x))
  83         len = PLANE_W - x;
  84
  85     addr = plane_base + ((x + (PLANE_W * y)) << 1);
  86     write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(addr));
  87
  88     while (len-- > 0) {
  89         write16(GFX_DATA_PORT,
  90             basetile | ((*src++) - 32 + TILE_FONT_BASE / 32));
  91     }
  92 }
  93
  94 static int printf_ypos;
  95
  96 static void printf_line(int x, const char *buf)
  97 {
  98     u32 addr;
  99     int i;
 100
 101     VDP_drawTextML(buf, APLANE, x, printf_ypos++ & (PLANE_H - 1));
 102
 103     if (printf_ypos >= CSCREEN_H) {
 104         /* clear next line */
 105         addr = APLANE;
 106         addr += (PLANE_W * (printf_ypos & (PLANE_H - 1))) << 1;
 107         write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(addr));
 108         for (i = 0; i < 40 / 2; i++)
 109             write32(GFX_DATA_PORT, 0);
 110
 111         /* scroll plane */
 112         write32(GFX_CTRL_PORT, GFX_WRITE_VSRAM_ADDR(0));
 113         write16(GFX_DATA_PORT, (printf_ypos - CSCREEN_H + 1) * 8);
 114     }
 115 }
 116
 117 #define PRINTF_LEN 40
 118
 119 static int printf(const char *fmt, ...)
 120 {
 121     static const char hexchars[] = "0123456789abcdef";
 122     static int printf_xpos;
 123     char c, buf[PRINTF_LEN + 11 + 1];
 124     const char *s;
 125     va_list ap;
 126     int ival;
 127     u32 uval;
 128     int d = 0;
 129     int i, j;
 130
 131     va_start(ap, fmt);
 132     for (d = 0; *fmt; ) {
 133         int prefix0 = 0;
 134         int fwidth = 0;
 135
 136         c = *fmt++;
 137         if (d < PRINTF_LEN)
 138             buf[d] = c;
 139
 140         if (c != '%') {
 141             if (c == '\n') {
 142                 buf[d] = 0;
 143                 printf_line(printf_xpos, buf);
 144                 d = 0;
 145                 printf_xpos = 0;
 146                 continue;
 147             }
 148             d++;
 149             continue;
 150         }
 151         if (d >= PRINTF_LEN)
 152             continue;
 153
 154         if (*fmt == '0') {
 155             prefix0 = 1;
 156             fmt++;
 157         }
 158
 159         while ('1' <= *fmt && *fmt <= '9') {
 160             fwidth = fwidth * 10 + *fmt - '0';
 161             fmt++;
 162         }
 163
 164         switch (*fmt++) {
 165         case '%':
 166             d++;
 167             break;
 168         case 'd':
 169         case 'i':
 170             ival = va_arg(ap, int);
 171             if (ival < 0) {
 172                 buf[d++] = '-';
 173                 ival = -ival;
 174             }
 175             for (i = 1000000000; i >= 10; i /= 10)
 176                 if (ival >= i)
 177                     break;
 178             for (; i >= 10; i /= 10) {
 179                 buf[d++] = '0' + ival / i;
 180                 ival %= i;
 181             }
 182             buf[d++] = '0' + ival;
 183             break;
 184         case 'x':
 185             uval = va_arg(ap, int);
 186             while (fwidth > 1 && uval < (1 << (fwidth - 1) * 4)) {
 187                 buf[d++] = prefix0 ? '0' : ' ';
 188                 fwidth--;
 189             }
 190             for (j = 1; j < 8 && uval >= (1 << j * 4); j++)
 191                 ;
 192             for (j--; j >= 0; j--)
 193                 buf[d++] = hexchars[(uval >> j * 4) & 0x0f];
 194             break;
 195         case 's':
 196             s = va_arg(ap, char *);
 197             while (*s && d < PRINTF_LEN)
 198                 buf[d++] = *s++;
 199             break;
 200         default:
 201             // don't handle, for now
 202             d++;
 203             va_arg(ap, void *);
 204             break;
 205         }
 206     }
 207     buf[d] = 0;
 208     va_end(ap);
 209
 210     if (d != 0) {
 211         // line without \n
 212         VDP_drawTextML(buf, APLANE, printf_xpos,
 213             printf_ypos & (PLANE_H - 1));
 214         printf_xpos += d;
 215     }
 216
 217     return d; // wrong..
 218 }
 219
 220 extern u32 font_base[];
 221 extern u8 test_data[];
 222 extern u8 test_data_end[];
 223
 224 int main()
 225 {
 226     volatile u32 *vptr;
 227     u32 old;
 228     u8 bad = 0;
 229     u8 *p, val;
 230     int i, t, len;
 231
 232     /* z80 */
 233     write16(0xa11100, 0x100);
 234     write16(0xa11200, 0);
 235
 236     /* setup VDP */
 237     while (read16(GFX_CTRL_PORT) & 2)
 238         ;
 239
 240     VDP_setReg(VDP_MODE1, 0x04);
 241     VDP_setReg(VDP_MODE2, 0x64);
 242     VDP_setReg(VDP_MODE3, 0x00);
 243     VDP_setReg(VDP_MODE4, 0x81);
 244     VDP_setReg(VDP_NT_SCROLLA, APLANE >> 10);
 245     VDP_setReg(VDP_NT_SCROLLB, BPLANE >> 13);
 246     VDP_setReg(VDP_SAT_BASE, SLIST >> 9);
 247     VDP_setReg(VDP_HSCROLL, HSCRL >> 10);
 248     VDP_setReg(VDP_AUTOINC, 2);
 249     VDP_setReg(VDP_SCROLLSZ, 0x01);
 250     VDP_setReg(VDP_BACKDROP, 0);
 251
 252     /* clear name tables */
 253     write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(APLANE));
 254     for (i = 0; i < PLANE_W * PLANE_H / 2; i++)
 255         write32(GFX_DATA_PORT, 0);
 256
 257     write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(BPLANE));
 258     for (i = 0; i < PLANE_W * PLANE_H / 2; i++)
 259         write32(GFX_DATA_PORT, 0);
 260
 261     /* SAT, h. scroll */
 262     write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(SLIST));
 263     write32(GFX_DATA_PORT, 0);
 264
 265     write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(HSCRL));
 266     write32(GFX_DATA_PORT, 0);
 267
 268     /* scroll plane vscroll */
 269     write32(GFX_CTRL_PORT, GFX_WRITE_VSRAM_ADDR(0));
 270     write32(GFX_DATA_PORT, 0);
 271     printf_ypos = 0;
 272
 273     /* load font */
 274     write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(TILE_FONT_BASE));
 275     for (i = 0; i < FONT_LEN * 32 / 4; i++)
 276         write32(GFX_DATA_PORT, font_base[i]);
 277
 278     /* set colors */
 279     write32(GFX_CTRL_PORT, GFX_WRITE_CRAM_ADDR(0));
 280     write32(GFX_DATA_PORT, 0);
 281     write32(GFX_CTRL_PORT, GFX_WRITE_CRAM_ADDR(15 * 2)); // font
 282     write16(GFX_DATA_PORT, 0xeee);
 283
 284     printf("\n");
 285     printf("MD version: %02x\n", read8(0xa10001));
 286     printf("ROM writable? ");
 287
 288     vptr = (void *)0x120;
 289     old = *vptr;
 290     *vptr ^= ~0;
 291     printf(*vptr == old ? "no" : "yes");
 292     printf("\n\n");
 293
 294     p = test_data;
 295     len = test_data_end - test_data;
 296
 297     for (t = 1; ; t++) {
 298         printf("executing stop.. ");
 299         for (i = 0; i < 5 * 60; i++)
 300             asm volatile("stop #0x2000" ::: "cc");
 301         printf("done\n");
 302
 303         printf("checking memory..\n");
 304
 305         val = 0;
 306         for (i = 0; i < len; i++) {
 307             if (p[i] != val) {
 308                 printf("bad: %06x: got %02x, expected %02x\n",
 309                        &p[i], p[i], val);
 310                 bad = 1;
 311             }
 312             val++;
 313         }
 314
 315         printf("done. Try %d: test ", t);
 316         if (bad) {
 317             printf("FAILED\n");
 318             break;
 319         }
 320         printf("PASSED\n");
 321     }
 322
 323     write32(GFX_CTRL_PORT, GFX_WRITE_CRAM_ADDR(0));
 324     write16(GFX_DATA_PORT, 0x008);
 325
 326     /* there are not enough STOP opcodes in this world :D */
 327     while (1)
 328         asm volatile("stop #0x2000" ::: "cc");
 329
 330     return 0;
 331 }
 332
 333 // vim:ts=4:sw=4:expandtab