1
0
mirror of https://github.com/hsoft/collapseos.git synced 2024-11-02 16:20:55 +11:00

Compare commits

..

3 Commits

Author SHA1 Message Date
Virgil Dupras
6acd22492c emul/hw/sms: WIP
VDP kinda works. Can see the Collapse OS prompt with SMS base recipe
if `STDIO_GETC` gets replaced with infinite loop (no input emul yet).
2020-01-08 22:06:50 -05:00
Virgil Dupras
d70c6d3b5f sms/vdp: improve comments 2020-01-08 18:38:55 -05:00
Clanmaster21
927d5f2392 Reworked parseHexadecimal and parseDecimal, other minor tweaks (#85)
I've tweaked nearly every function in this file, so I'll go through them one by one.
parseDecimal has been reworked a little so that `a` can be used instead of `b` for checking for overflow. I had originally intended to redo it to work like the old parseDecimal, but I think the current method (once reworked a little) is cleaner and smaller, and should be just as fast. 7 bytes and 27 cycles saved.
parseHexadecimal has been changed to load hex digits into `b` `d` `c` `e` from the right (so all the digits move along to the left so the new digit can be inserted on the right), and then only at the end is any shifting done, using the faster `add a, a` to do left shifts. 9 bytes saved and 78 cycles saved inside the loop, and then 49 cycles added after the loop. 
parseBinaryLiteral had a few instructions moved around, saving two bytes and 5 cycles inside the loop, and a further 15 cycles saved on error.
parseLiteral has been reworked slightly, the isDigit call has been replaced with an inline parseDecimalDigit, saving a byte and around 20-30 cycles, with around 16 more cycles saved if the number is a decimal. The .char routine has been reduced by a byte, and 6 cycles saved on success, but 5 cycles added on error.
isDigit has been reduced by 4 bytes and 10 cycles on success, with a few more cycles saved on fail (hard to estimate due to branching).
2020-01-08 16:12:40 -05:00
7 changed files with 398 additions and 61 deletions

View File

@ -21,7 +21,6 @@ parseHex:
add a, 10 ; C is clear, map back to 0xA-0xF
ret
; Parse string at (HL) as a decimal value and return value in DE.
; Reads as many digits as it can and stop when:
; 1 - A non-digit character is read
@ -44,10 +43,10 @@ parseDecimal:
; During this routine, we switch between HL and its shadow. On one side,
; we have HL the string pointer, and on the other side, we have HL the
; numerical result. We also use EXX to preserve BC, saving us a push.
parseDecimalSkip: ; enter here to skip parsing the first digit
exx ; HL as a result
ld h, 0
ld l, a ; load first digit in without multiplying
ld b, 0 ; We use B to detect overflow
.loop:
exx ; HL as a string pointer
@ -60,24 +59,22 @@ parseDecimal:
sub 0xff-9
jr c, .end
ld b, a ; we can now use a for overflow checking
add hl, hl ; x2
; We do this to detect overflow at each step
rl b
sbc a, a ; a=0 if no overflow, a=0xFF otherwise
ld d, h
ld e, l ; de is x2
add hl, hl ; x4
rl b
rla
add hl, hl ; x8
rl b
rla
add hl, de ; x10
rl b
ld d, 0
ld e, a
rla
ld d, a ; a is zero unless there's an overflow
ld e, b
add hl, de
rl b
adc a, a ; same as rla except affects Z
; Did we oveflow?
xor a
or b
jr z, .loop ; No? continue
; error, NZ already set
exx ; HL is now string pointer, restore BC
@ -106,33 +103,49 @@ parseDecimalC:
; Sets Z on success.
parseHexadecimal:
ld a, (hl)
call parseHex
jp c, unsetZ ; we need at least one char
call parseHex ; before "ret c" is "sub 0xfa" in parseHex
; so carry implies not zero
ret c ; we need at least one char
push bc
ld de, 0
ld b, 0
ld b, d
ld c, d
; The idea here is that the 4 hex digits of the result can be represented "bdce",
; where each register holds a single digit. Then the result is simply
; e = (c << 4) | e, d = (b << 4) | d
; However, the actual string may be of any length, so when loading in the most
; significant digit, we don't know which digit of the result it actually represents
; To solve this, after a digit is loaded into a (and is checked for validity),
; all digits are moved along, with e taking the latest digit.
.loop:
; we push to B to verify overflow
rl e \ rl d \ rl b
rl e \ rl d \ rl b
rl e \ rl d \ rl b
rl e \ rl d \ rl b
or e
dec b
inc b ; b should be 0, else we've overflowed
jr nz, .end ; Z already unset if overflow
ld b, d
ld d, c
ld c, e
ld e, a
; did we overflow?
ld a, b
or a
jr nz, .end ; overflow, NZ already set
; next char
inc hl
ld a, (hl)
call parseHex
jr nc, .loop
cp a ; ensure Z
ld a, b
add a, a \ add a, a \ add a, a \ add a, a
or d
ld d, a
ld a, c
add a, a \ add a, a \ add a, a \ add a, a
or e
ld e, a
xor a ; ensure z
.end:
pop bc
ret
; Parse string at (HL) as a binary value (010101) without the "0b" prefix and
; return value in E. D is always zero.
; HL is advanced to the character following the last successfully read char.
@ -144,10 +157,10 @@ parseBinaryLiteral:
add a, 0xff-'1'
sub 0xff-1
jr c, .end
rl e
rlc e ; sets carry if overflow, and affects Z
ret c ; Z unset if carry set, since bit 0 of e must be set
add a, e
ld e, a
jp c, unsetZ ; overflow
inc hl
jr .loop
.end:
@ -167,10 +180,13 @@ parseLiteral:
ld a, (hl)
cp 0x27 ; apostrophe
jr z, .char
call isDigit
ret nz
cp '0'
jp nz, parseDecimal
; inline parseDecimalDigit
add a, 0xc6 ; maps '0'-'9' onto 0xf6-0xff
sub 0xf6 ; maps to 0-9 and carries if not a digit
ret c
; a already parsed so skip first few instructions of parseDecimal
jp nz, parseDecimalSkip
; maybe hex, maybe binary
inc hl
ld a, (hl)
@ -195,14 +211,13 @@ parseLiteral:
ld e, (hl) ; our result
inc hl
cp (hl)
jr nz, .charError ; not ending with an apostrophe
; good char, advance HL and return
; advance HL and return if good char
inc hl
; Z already set
ret
.charError:
; In all error conditions, HL is advanced by 2. Rewind.
dec hl \ dec hl
ret z
; Z unset and there's an error
; In all error conditions, HL is advanced by 3. Rewind.
dec hl \ dec hl \ dec hl
; NZ already set
ret
@ -215,9 +230,9 @@ isLiteralPrefix:
; Returns whether A is a digit
isDigit:
cp '0'
jp c, unsetZ
cp '9'+1
jp nc, unsetZ
cp '0' ; carry implies not zero for cp
ret c
cp '9' ; zero unset for a > '9', but set for a='9'
ret nc
cp a ; ensure Z
ret

1
emul/hw/sms/.gitignore vendored Normal file
View File

@ -0,0 +1 @@
/sms

15
emul/hw/sms/Makefile Normal file
View File

@ -0,0 +1,15 @@
EXTOBJS = ../../emul.o ../../libz80/libz80.o
OBJS = sms.o vdp.o
TARGET = sms
CFLAGS += `pkg-config --cflags xcb`
.PHONY: all
all: $(TARGET)
$(TARGET): $(OBJS) $(EXTOBJS)
$(CC) `pkg-config --libs xcb` $(OBJS) $(EXTOBJS) -o $@
.PHONY: clean
clean:
rm -f $(TARGET) $(OBJS)

194
emul/hw/sms/sms.c Normal file
View File

@ -0,0 +1,194 @@
#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <xcb/xcb.h>
#include "../../emul.h"
#include "vdp.h"
#define RAMSTART 0xc000
#define VDP_CMD_PORT 0xbf
#define VDP_DATA_PORT 0xbe
#define MAX_ROMSIZE 0x8000
static xcb_connection_t *conn;
static xcb_screen_t *screen;
/* graphics contexts */
static xcb_gcontext_t fg;
/* win */
static xcb_drawable_t win;
// pixels to draw. We draw them in one shot.
static xcb_rectangle_t rectangles[VDP_SCREENW*VDP_SCREENH];
static Machine *m;
static VDP vdp;
static bool vdp_changed;
static uint8_t iord_vdp_cmd()
{
return vdp_cmd_rd(&vdp);
}
static uint8_t iord_vdp_data()
{
return vdp_data_rd(&vdp);
}
static void iowr_vdp_cmd(uint8_t val)
{
vdp_cmd_wr(&vdp, val);
}
static void iowr_vdp_data(uint8_t val)
{
vdp_changed = true;
vdp_data_wr(&vdp, val);
}
void create_window()
{
uint32_t mask;
uint32_t values[2];
/* Create the window */
win = xcb_generate_id(conn);
mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
values[0] = screen->white_pixel;
values[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS |
XCB_EVENT_MASK_KEY_RELEASE;
xcb_create_window(
conn,
screen->root_depth,
win,
screen->root,
0, 0,
150, 150,
10,
XCB_WINDOW_CLASS_INPUT_OUTPUT,
screen->root_visual,
mask, values);
fg = xcb_generate_id(conn);
mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES;
values[0] = screen->black_pixel;
values[1] = 0;
xcb_create_gc(conn, fg, screen->root, mask, values);
/* Map the window on the screen */
xcb_map_window(conn, win);
}
void draw_pixels()
{
xcb_get_geometry_reply_t *geom;
geom = xcb_get_geometry_reply(conn, xcb_get_geometry(conn, win), NULL);
xcb_clear_area(
conn, 0, win, 0, 0, geom->width, geom->height);
// Figure out inner size to maximize our screen's aspect ratio
int psize = geom->height / VDP_SCREENH;
if (geom->width / VDP_SCREENW < psize) {
// width is the constraint
psize = geom->width / VDP_SCREENW;
}
int innerw = psize * VDP_SCREENW;
int innerh = psize * VDP_SCREENH;
int innerx = (geom->width - innerw) / 2;
int innery = (geom->height - innerh) / 2;
int drawcnt = 0;
for (int i=0; i<VDP_SCREENW; i++) {
for (int j=0; j<VDP_SCREENH; j++) {
if (vdp_pixel(&vdp, i, j)) {
int x = innerx + (i*psize);
int y = innery + (j*psize);
rectangles[drawcnt].x = x;
rectangles[drawcnt].y = y;
rectangles[drawcnt].height = psize;
rectangles[drawcnt].width = psize;
drawcnt++;
}
}
}
if (drawcnt) {
xcb_poly_fill_rectangle(
conn, win, fg, drawcnt, rectangles);
}
vdp_changed = false;
xcb_flush(conn);
}
void event_loop()
{
while (1) {
emul_step();
if (vdp_changed) {
// To avoid overdrawing, we'll let the CPU run a bit to finish its
// drawing operation.
emul_steps(100);
draw_pixels();
}
xcb_generic_event_t *e = xcb_poll_for_event(conn);
if (!e) {
continue;
}
switch (e->response_type & ~0x80) {
/* ESC to exit */
case XCB_KEY_RELEASE:
case XCB_KEY_PRESS: {
xcb_key_press_event_t *ev = (xcb_key_press_event_t *)e;
if (ev->detail == 0x09) return;
break;
}
case XCB_EXPOSE: {
draw_pixels();
break;
}
default: {
break;
}
}
free(e);
}
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "Usage: ./sms /path/to/rom\n");
return 1;
}
FILE *fp = fopen(argv[1], "r");
if (fp == NULL) {
fprintf(stderr, "Can't open %s\n", argv[1]);
return 1;
}
m = emul_init();
m->ramstart = RAMSTART;
int i = 0;
int c;
while ((c = fgetc(fp)) != EOF && i < MAX_ROMSIZE) {
m->mem[i++] = c & 0xff;
}
pclose(fp);
if (c != EOF) {
fprintf(stderr, "ROM image too large.\n");
return 1;
}
vdp_init(&vdp);
vdp_changed = false;
m->iord[VDP_CMD_PORT] = iord_vdp_cmd;
m->iord[VDP_DATA_PORT] = iord_vdp_data;
m->iowr[VDP_CMD_PORT] = iowr_vdp_cmd;
m->iowr[VDP_DATA_PORT] = iowr_vdp_data;
conn = xcb_connect(NULL, NULL);
screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
create_window();
draw_pixels();
event_loop();
emul_printdebug();
return 0;
}

77
emul/hw/sms/vdp.c Normal file
View File

@ -0,0 +1,77 @@
#include <string.h>
#include "vdp.h"
void vdp_init(VDP *vdp)
{
memset(vdp->vram, 0, VDP_VRAM_SIZE);
memset(vdp->regs, 0, 0x10);
vdp->has_cmdlsb = false;
vdp->curaddr = 0;
}
uint8_t vdp_cmd_rd(VDP *vdp)
{
return 0;
}
void vdp_cmd_wr(VDP *vdp, uint8_t val)
{
if (!vdp->has_cmdlsb) {
vdp->cmdlsb = val;
vdp->has_cmdlsb = true;
return;
}
vdp->has_cmdlsb = false;
if ((val & 0xc0) == 0x80) {
// set register
vdp->regs[val&0xf] = vdp->cmdlsb;
} else if ((val & 0xc0) == 0xc0) {
// palette RAM
vdp->curaddr = 0x4000 + (vdp->cmdlsb&0x1f);
} else {
// VRAM
vdp->curaddr = ((val&0x3f) << 8) + vdp->cmdlsb;
}
}
uint8_t vdp_data_rd(VDP *vdp)
{
uint8_t res = vdp->vram[vdp->curaddr];
if (vdp->curaddr < VDP_VRAM_SIZE) {
vdp->curaddr++;
}
return res;
}
void vdp_data_wr(VDP *vdp, uint8_t val)
{
vdp->vram[vdp->curaddr] = val;
if (vdp->curaddr < VDP_VRAM_SIZE) {
vdp->curaddr++;
}
}
uint8_t vdp_pixel(VDP *vdp, uint16_t x, uint16_t y)
{
if (x >= VDP_SCREENW) {
return 0;
}
if (y >= VDP_SCREENH) {
return 0;
}
// name table offset
uint16_t offset = 0x3800 + ((y/8) << 6) + ((x/8) << 1);
uint16_t tableval = vdp->vram[offset] + (vdp->vram[offset+1] << 8);
uint16_t tilenum = tableval & 0x1ff;
// tile offset this time. Each tile is 0x20 bytes long.
offset = tilenum * 0x20;
// Each 4 byte is a row. Find row first.
offset += ((y%8) * 4);
uint8_t bitnum = 7 - (x%8);
// Now, let's compose the result by pushing the right bit of our 4 bytes
// into our result.
return ((vdp->vram[offset] >> bitnum) & 1) + \
(((vdp->vram[offset+1] >> bitnum) & 1) << 1) + \
(((vdp->vram[offset+2] >> bitnum) & 1) << 2) + \
(((vdp->vram[offset+3] >> bitnum) & 1) << 3);
}

26
emul/hw/sms/vdp.h Normal file
View File

@ -0,0 +1,26 @@
#include <stdint.h>
#include <stdbool.h>
#define VDP_VRAM_SIZE 0x4020
#define VDP_SCREENW (32*8)
#define VDP_SCREENH (24*8)
// Offset of the name table
#define VDP_NTABLE_OFFSET 0x3800
typedef struct {
// the last 0x20 is palette RAM
uint8_t vram[VDP_VRAM_SIZE];
uint8_t regs[0x10];
uint8_t cmdlsb;
bool has_cmdlsb;
uint16_t curaddr;
} VDP;
void vdp_init(VDP *vdp);
uint8_t vdp_cmd_rd(VDP *vdp);
void vdp_cmd_wr(VDP *vdp, uint8_t val);
uint8_t vdp_data_rd(VDP *vdp);
void vdp_data_wr(VDP *vdp, uint8_t val);
// result is a RGB value
uint8_t vdp_pixel(VDP *vdp, uint16_t x, uint16_t y);

View File

@ -38,6 +38,7 @@ vdpInit:
ld c, VDP_CTLPORT
otir
; Blank VRAM
xor a
out (VDP_CTLPORT), a
ld a, 0x40
@ -51,15 +52,17 @@ vdpInit:
or c
jr nz, .loop1
; Set palettes
xor a
out (VDP_CTLPORT), a
ld a, 0xc0
out (VDP_CTLPORT), a
ld hl, vdpPaletteData
ld b, vdpPaletteDataEnd-vdpPaletteData
ld c, VDP_DATAPORT
otir
xor a ; palette 0: black
out (VDP_DATAPORT), a
ld a, 0x3f ; palette 1: white
out (VDP_DATAPORT), a
; Define tiles
xor a
out (VDP_CTLPORT), a
ld a, 0x40
@ -97,6 +100,7 @@ vdpInit:
dec c
jr nz, .loop2
; Bit 7 = ?, Bit 6 = display enabled
ld a, 0b11000000
out (VDP_CTLPORT), a
ld a, 0x81
@ -129,7 +133,7 @@ vdpSpitC:
; two bits
out (VDP_CTLPORT), a
ld a, b ; 3 low bits set
or 0x78
or 0x78 ; 01 header + 0x3800
out (VDP_CTLPORT), a
pop bc
@ -279,11 +283,16 @@ vdpConv:
ld a, 0x5e
ret
vdpPaletteData:
.db 0x00,0x3f
vdpPaletteDataEnd:
; VDP initialisation data
vdpInitData:
.db 0x04,0x80,0x00,0x81,0xff,0x82,0xff,0x85,0xff,0x86,0xff,0x87,0x00,0x88,0x00,0x89,0xff,0x8a
; 0x8x == set register X
.db 0b00000100, 0x80 ; Bit 2: Select mode 4
.db 0b00000000, 0x81
.db 0b11111111, 0x82 ; Name table: 0x3800
.db 0b11111111, 0x85 ; Sprite table: 0x3f00
.db 0b11111111, 0x86 ; sprite use tiles from 0x2000
.db 0b11111111, 0x87 ; Border uses palette 0xf
.db 0b00000000, 0x88 ; BG X scroll
.db 0b00000000, 0x89 ; BG Y scroll
.db 0b11111111, 0x8a ; Line counter (why have this?)
vdpInitDataEnd: