[megadrive.git] / megaed-stop-md / main.c

/*
 * This software is released into the public domain.
 * See UNLICENSE file in top level directory.
 */
#include <stdlib.h>
#include <stdarg.h>

#define u8      unsigned char
#define u16     unsigned short
#define u32     unsigned int

#define GFX_DATA_PORT    0xC00000
#define GFX_CTRL_PORT    0xC00004

#define TILE_MEM_END     0xB000

#define FONT_LEN         128
#define TILE_FONT_BASE   (TILE_MEM_END - FONT_LEN * 32)

/* note: using ED menu's layout here.. */
#define WPLANE           (TILE_MEM_END + 0x0000)
#define HSCRL            (TILE_MEM_END + 0x0800)
#define SLIST            (TILE_MEM_END + 0x0C00)
#define APLANE           (TILE_MEM_END + 0x1000)
#define BPLANE           (TILE_MEM_END + 0x3000)

#define read8(a) \
    *((volatile u8 *) (a))
#define read16(a) \
    *((volatile u16 *) (a))
#define read32(a) \
    *((volatile u32 *) (a))
#define write16(a, d) \
    *((volatile u16 *) (a)) = (d)
#define write32(a, d) \
    *((volatile u32 *) (a)) = (d)

#define GFX_WRITE_VRAM_ADDR(adr) \
    (((0x4000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x00)
#define GFX_WRITE_VSRAM_ADDR(adr) \
    (((0x4000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x10)
#define GFX_WRITE_CRAM_ADDR(adr) \
    (((0xC000 | ((adr) & 0x3FFF)) << 16) | ((adr) >> 14) | 0x00)

#define VDP_setReg(r, v) \
    write16(GFX_CTRL_PORT, 0x8000 | ((r) << 8) | (v))

enum {
    VDP_MODE1 = 0x00,
    VDP_MODE2 = 0x01,
    VDP_NT_SCROLLA = 0x02,
    VDP_NT_WIN = 0x03,
    VDP_NT_SCROLLB = 0x04,
    VDP_SAT_BASE = 0x05,
    VDP_BACKDROP = 0x07,
    VDP_MODE3 = 0x0b,
    VDP_MODE4 = 0x0c,
    VDP_HSCROLL = 0x0d,
    VDP_AUTOINC = 0x0f,
    VDP_SCROLLSZ = 0x10,
};

/* cell counts */
#define LEFT_BORDER 1   /* lame TV */
#define PLANE_W 64
#define PLANE_H 32
#define CSCREEN_H 28

static void VDP_drawTextML(const char *str, u16 plane_base,
    u16 x, u16 y)
{
    const u8 *src = (const u8 *)str;
    u16 basetile = 0;
    int max_len = 40 - LEFT_BORDER;
    int len;
    u32 addr;

    x += LEFT_BORDER;

    for (len = 0; str[len] && len < max_len; len++)
        ;
    if (len > (PLANE_W - x))
        len = PLANE_W - x;

    addr = plane_base + ((x + (PLANE_W * y)) << 1);
    write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(addr));

    while (len-- > 0) {
        write16(GFX_DATA_PORT,
            basetile | ((*src++) - 32 + TILE_FONT_BASE / 32));
    }
}

static int printf_ypos;

static void printf_line(int x, const char *buf)
{
    u32 addr;
    int i;

    VDP_drawTextML(buf, APLANE, x, printf_ypos++ & (PLANE_H - 1));

    if (printf_ypos >= CSCREEN_H) {
        /* clear next line */
        addr = APLANE;
        addr += (PLANE_W * (printf_ypos & (PLANE_H - 1))) << 1;
        write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(addr));
        for (i = 0; i < 40 / 2; i++)
            write32(GFX_DATA_PORT, 0);

        /* scroll plane */
        write32(GFX_CTRL_PORT, GFX_WRITE_VSRAM_ADDR(0));
        write16(GFX_DATA_PORT, (printf_ypos - CSCREEN_H + 1) * 8);
    }
}

#define PRINTF_LEN 40

static int printf(const char *fmt, ...)
{
    static const char hexchars[] = "0123456789abcdef";
    static int printf_xpos;
    char c, buf[PRINTF_LEN + 11 + 1];
    const char *s;
    va_list ap;
    int ival;
    u32 uval;
    int d = 0;
    int i, j;

    va_start(ap, fmt);
    for (d = 0; *fmt; ) {
        int prefix0 = 0;
        int fwidth = 0;

        c = *fmt++;
        if (d < PRINTF_LEN)
            buf[d] = c;

        if (c != '%') {
            if (c == '\n') {
                buf[d] = 0;
                printf_line(printf_xpos, buf);
                d = 0;
                printf_xpos = 0;
                continue;
            }
            d++;
            continue;
        }
        if (d >= PRINTF_LEN)
            continue;

        if (*fmt == '0') {
            prefix0 = 1;
            fmt++;
        }

        while ('1' <= *fmt && *fmt <= '9') {
            fwidth = fwidth * 10 + *fmt - '0';
            fmt++;
        }

        switch (*fmt++) {
        case '%':
            d++;
            break;
        case 'd':
        case 'i':
            ival = va_arg(ap, int);
            if (ival < 0) {
                buf[d++] = '-';
                ival = -ival;
            }
            for (i = 1000000000; i >= 10; i /= 10)
                if (ival >= i)
                    break;
            for (; i >= 10; i /= 10) {
                buf[d++] = '0' + ival / i;
                ival %= i;
            }
            buf[d++] = '0' + ival;
            break;
        case 'x':
            uval = va_arg(ap, int);
            while (fwidth > 1 && uval < (1 << (fwidth - 1) * 4)) {
                buf[d++] = prefix0 ? '0' : ' ';
                fwidth--;
            }
            for (j = 1; j < 8 && uval >= (1 << j * 4); j++)
                ;
            for (j--; j >= 0; j--)
                buf[d++] = hexchars[(uval >> j * 4) & 0x0f];
            break;
        case 's':
            s = va_arg(ap, char *);
            while (*s && d < PRINTF_LEN)
                buf[d++] = *s++;
            break;
        default:
            // don't handle, for now
            d++;
            va_arg(ap, void *);
            break;
        }
    }
    buf[d] = 0;
    va_end(ap);

    if (d != 0) {
        // line without \n
        VDP_drawTextML(buf, APLANE, printf_xpos,
            printf_ypos & (PLANE_H - 1));
        printf_xpos += d;
    }

    return d; // wrong..
}

extern u32 font_base[];
extern u8 test_data[];
extern u8 test_data_end[];

int main()
{
    volatile u32 *vptr;
    u32 old;
    u8 bad = 0;
    u8 *p, val;
    int i, t, len;

    /* z80 */
    write16(0xa11100, 0x100);
    write16(0xa11200, 0);

    /* setup VDP */
    while (read16(GFX_CTRL_PORT) & 2)
        ;

    VDP_setReg(VDP_MODE1, 0x04); 
    VDP_setReg(VDP_MODE2, 0x64); 
    VDP_setReg(VDP_MODE3, 0x00); 
    VDP_setReg(VDP_MODE4, 0x81); 
    VDP_setReg(VDP_NT_SCROLLA, APLANE >> 10); 
    VDP_setReg(VDP_NT_SCROLLB, BPLANE >> 13); 
    VDP_setReg(VDP_SAT_BASE, SLIST >> 9); 
    VDP_setReg(VDP_HSCROLL, HSCRL >> 10); 
    VDP_setReg(VDP_AUTOINC, 2); 
    VDP_setReg(VDP_SCROLLSZ, 0x01); 
    VDP_setReg(VDP_BACKDROP, 0); 

    /* clear name tables */
    write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(APLANE));
    for (i = 0; i < PLANE_W * PLANE_H / 2; i++)
        write32(GFX_DATA_PORT, 0);

    write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(BPLANE));
    for (i = 0; i < PLANE_W * PLANE_H / 2; i++)
        write32(GFX_DATA_PORT, 0);

    /* SAT, h. scroll */
    write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(SLIST));
    write32(GFX_DATA_PORT, 0);

    write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(HSCRL));
    write32(GFX_DATA_PORT, 0);

    /* scroll plane vscroll */
    write32(GFX_CTRL_PORT, GFX_WRITE_VSRAM_ADDR(0));
    write32(GFX_DATA_PORT, 0);
    printf_ypos = 0;

    /* load font */
    write32(GFX_CTRL_PORT, GFX_WRITE_VRAM_ADDR(TILE_FONT_BASE));
    for (i = 0; i < FONT_LEN * 32 / 4; i++)
        write32(GFX_DATA_PORT, font_base[i]);

    /* set colors */
    write32(GFX_CTRL_PORT, GFX_WRITE_CRAM_ADDR(0));
    write32(GFX_DATA_PORT, 0);
    write32(GFX_CTRL_PORT, GFX_WRITE_CRAM_ADDR(15 * 2)); // font
    write16(GFX_DATA_PORT, 0xeee);

    printf("\n");
    printf("MD version: %02x\n", read8(0xa10001));
    printf("ROM writable? ");

    vptr = (void *)0x120;
    old = *vptr;
    *vptr ^= ~0;
    printf(*vptr == old ? "no" : "yes");
    printf("\n\n");

    p = test_data;
    len = test_data_end - test_data;

    for (t = 1; ; t++) {
        printf("executing stop.. ");
        for (i = 0; i < 5 * 60; i++)
            asm volatile("stop #0x2000" ::: "cc");
        printf("done\n");

        printf("checking memory..\n");

        val = 0;
        for (i = 0; i < len; i++) {
            if (p[i] != val) {
                printf("bad: %06x: got %02x, expected %02x\n",
                       &p[i], p[i], val);
                bad = 1;
            }
            val++;
        }

        printf("done. Try %d: test ", t);
        if (bad) {
            printf("FAILED\n");
            break;
        }
        printf("PASSED\n");
    }

    write32(GFX_CTRL_PORT, GFX_WRITE_CRAM_ADDR(0));
    write16(GFX_DATA_PORT, 0x008);

    /* there are not enough STOP opcodes in this world :D */
    while (1)
        asm volatile("stop #0x2000" ::: "cc");

    return 0;
}

// vim:ts=4:sw=4:expandtab
Commit	Line	Data
25055eb3	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));
3ee911dc	286	printf("ROM writable? ");
25055eb3	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