Add workarounds for working hardware RPI4

For now we need to disable compiler optimizations, since they seem to
mess up the mempoke16 memory access.

4 files changed, 52 insertions, 14 deletions

diff --git a/Makefile b/Makefile
index 96c1b74..1fced4f 100644
--- a/Makefile
+++ b/Makefile
@@ -2,6 +2,8 @@
 .SUFFIXES:
 .PHONY: clean run
 
+RPI_VERSION ?= 3
+
 # Compiler.
 AS      := aarch64-elf-as
 CC      := aarch64-elf-gcc
@@ -21,7 +23,8 @@ OBJ_START = $(BUILD_DIR)/start.o
 OBJ_MAIN = $(BUILD_DIR)/main.o
 SRC_LINK = $(SRC_DIR)/linker.ld
 
-CFLAGS := -Wall -ffreestanding -O2 -nostdlib -lgcc -mgeneral-regs-only -fstack-protector
+CFLAGS := -Wall -ffreestanding -O1 -nostdlib -lgcc -mgeneral-regs-only -fstack-protector
+CFLAGS += -DRPI_VERSION=$(RPI_VERSION)
 AFLAGS :=
 LDFLAGS :=
 
diff --git a/src/common.h b/src/common.h
index b983ca5..94e499e 100644
--- a/src/common.h
+++ b/src/common.h
@@ -3,6 +3,16 @@
 
 // Header definitions for memory mapped IO and common utilities.
 
+// Setup the right base memory address for different types of RPI.
+#if RPI_VERSION == 3
+#define MEM_BASE 0x3F000000
+#elif RPI_VERSION == 4
+#define MEM_BASE 0xFE000000
+#else
+#define MEM_BASE 0
+#error RPI_VERSION NOT DEFINED
+#endif
+
 #include "shorthand.h"
 
 //
@@ -15,8 +25,6 @@ void delay(u64 ticks);
 // Clear N bytes at the given address. Implemented in start.s.
 void memzero(u64 src, u32 n);
 
-#define MEM_BASE 0x3F000000
-
 //
 // GPIO Registers.
 //
@@ -112,8 +120,14 @@ uart_init() {
     AUX->mu_lcr = 3;
     AUX->mu_mcr = 0;
 
+#if RPI_VERSION == 3
     AUX->mu_baud_rate = 270; // RPI3: 115200 @ 250 MHz
-    // AUX->mu_baud_rate = 541; // RPI4: 115200 @ 500 MHz
+#endif
+
+#if RPI_VERSION == 4
+    AUX->mu_baud_rate = 541; // RPI4: 115200 @ 500 MHz
+#endif
+
     AUX->mu_control = 3;
     return;
 }
diff --git a/src/main.c b/src/main.c
index 624d3c8..7ac7037 100644
--- a/src/main.c
+++ b/src/main.c
@@ -39,7 +39,16 @@ docolors(Device *d) {
         u8 r = ((d->dat[0x8 + i / 2] >> (!(i % 2) << 2)) & 0x0f) * 0x11;
         u8 g = ((d->dat[0xa + i / 2] >> (!(i % 2) << 2)) & 0x0f) * 0x11;
         u8 b = ((d->dat[0xc + i / 2] >> (!(i % 2) << 2)) & 0x0f) * 0x11;
+
+        // NOTE: This is a bit of a hack. We probably want to check the RGB byte
+        // order on the mailbox request.
+#if RPI_VERSION == 3
         palette[i] = (b << 16) | (g << 8) | r;
+#endif
+
+#if RPI_VERSION == 4
+        palette[i] = (r << 16) | (g << 8) | b;
+#endif
     }
     for(size_t i = 4; i < 16; ++i) {
         palette[i] = palette[i / 4];
@@ -124,6 +133,13 @@ init_uxn() {
     uart_init();
 
     uart_puts("Initializing UXN.\n");
+
+    // Clear UXN memory.
+    u8 * uxnptr = (u8*)&u;
+    for (size_t i = 0; i < sizeof(Uxn); i++) {
+        uxnptr[i] = 0;
+    }
+
     ppu_init(&ppu, SCREEN_WIDTH / 8,  SCREEN_HEIGHT / 8);
 
     // Copy rom to VM.
diff --git a/src/ppu.c b/src/ppu.c
index 85245b2..e153c4d 100644
--- a/src/ppu.c
+++ b/src/ppu.c
@@ -20,9 +20,9 @@ WITH REGARD TO THIS SOFTWARE.
 
 static u32 *framebuffer = 0;
 
-static u32 palette[16] = {0};
-static u8 pixels_buf[SCREEN_WIDTH * SCREEN_HEIGHT] = {0};
-static u8 dirty_lines[SCREEN_HEIGHT] = {0};
+static u32 palette[16];
+static u8 pixels_buf[SCREEN_WIDTH * SCREEN_HEIGHT];
+static u8 dirty_lines[SCREEN_HEIGHT];
 static u8 reqdraw = 0;
 
 static Uint8 blending[5][16] = {
@@ -80,7 +80,7 @@ ppu_2bpp(Ppu *p, Uint8 layer, Uint16 x, Uint16 y, Uint8 *sprite, Uint8 color, Ui
 void
 redraw_screen(void) {
     for (size_t j = 0; j < SCREEN_HEIGHT; j++) {
-        dirty_lines[j] |= 1;
+        dirty_lines[j] = 1;
     }
 }
 
@@ -139,10 +139,15 @@ ppu_init(Ppu *p, Uint8 hor, Uint8 ver) {
     p->pixels = pixels_buf;
 
     // Initialize default palette.
-    palette[0] = 0x00444444;
-    palette[1] = 0x00ffffff;
-    palette[2] = 0x007777ff;
-    palette[3] = 0x00ff7777;
+    palette[0] = 0x444444;
+    palette[1] = 0xffffff;
+    palette[2] = 0x7777ff;
+    palette[3] = 0xff7777;
+
+    // Clear pixel buffer memory.
+    for (size_t i = 0; i < sizeof(pixels_buf); i++) {
+        p->pixels[i] = 0;
+    }
 
     // Make sure we perform an initial screen drawing.
     reqdraw = 1;
@@ -157,10 +162,10 @@ blit_framebuffer(Ppu *p) {
         return;
     }
     for (size_t j = 0; j < SCREEN_HEIGHT; j++) {
-        if (dirty_lines[j] == 1) {
+        if (dirty_lines[j] != 0) {
             for (size_t i = 0; i < SCREEN_WIDTH; i++) {
                 size_t idx = i + j * SCREEN_WIDTH;
-                framebuffer[idx] = palette[p->pixels[idx]];
+                framebuffer[idx] = palette[p->pixels[idx] % 16];
             }
         }
         dirty_lines[j] = 0;