Use firmware XSTACK

Author: smokku

src/chips/ria816.c

@@ -3,6 +3,7 @@
 #undef CHIPS_IMPL
 
 #include "ria816.h"
+#include "sys/mem.h"
 
 #include <string.h>
 #include <stdlib.h>
@@ -26,7 +27,6 @@ void ria816_init(ria816_t* c, const ria816_desc_t* desc) {
 
     c->ticks_per_ms = desc->tick_hz * RIA816_FIXEDPOINT_SCALE / 1000000;
 
-    rb_init(&c->api_stack);
     c->api_cb = desc->api_cb;
     c->user_data = desc->user_data;
 
@@ -40,7 +40,6 @@ void ria816_reset(ria816_t* c) {
     c->us = 0;
     rb_init(&c->uart_rx);
     rb_init(&c->uart_tx);
-    rb_init(&c->api_stack);
     m6526_reset(&c->cia);
 }
 
@@ -108,7 +107,10 @@ uint8_t ria816_reg_read(ria816_t* c, uint8_t addr) {
         case RIA816_IRQ_ENABLE: data = c->irq_enable; break;
         case RIA816_IRQ_STATUS: data = ~(c->int_status); break;
 
-        case RIA816_API_STACK: rb_get(&c->api_stack, &data); break;
+        case RIA816_API_STACK:
+            data = xstack[xstack_ptr];
+            if (xstack_ptr < XSTACK_SIZE) ++xstack_ptr;
+            break;
 
         default: data = c->reg[addr];
     }
@@ -122,7 +124,9 @@ void ria816_reg_write(ria816_t* c, uint8_t addr, uint8_t data) {
         case RIA816_IRQ_STATUS: break;
         case RIA816_IRQ_ENABLE: c->irq_enable = (data && 0x01); break;
 
-        case RIA816_API_STACK: rb_put(&c->api_stack, data); break;
+        case RIA816_API_STACK:
+            if (xstack_ptr) xstack[--xstack_ptr] = data;
+            break;
         case RIA816_API_OP_RET:
             if (c->api_cb) c->api_cb(data, c->user_data);
             break;

src/chips/ria816.h

@@ -190,7 +190,6 @@ typedef struct {
     int ticks_per_ms;
     int ticks_counter;
     uint64_t pins;
-    ring_buffer_t api_stack;
     // API callback
     ria816_api_call_t api_cb;
     // optional user-data for the API callback

src/systems/x65.c

@@ -576,47 +576,38 @@ bool x65_load_snapshot(x65_t* sys, uint32_t version, x65_t* src) {
 #include "sys/cpu.h"
 #include "term/font.h"
 
-volatile uint8_t __regs[0x40];
+volatile uint8_t regs[0x40];
 uint8_t xstack[XSTACK_SIZE + 1];
 size_t volatile xstack_ptr;
 
-static bool api_stack_pop_uint16(x65_t* sys, uint16_t* value) {
-    return rb_get(&sys->ria.api_stack, &((uint8_t*)value)[0]) && rb_get(&sys->ria.api_stack, &((uint8_t*)value)[1]);
-}
-static bool api_stack_push_uint16(x65_t* sys, uint16_t value) {
-    return rb_put(&sys->ria.api_stack, ((uint8_t*)&value)[1]) && rb_put(&sys->ria.api_stack, ((uint8_t*)&value)[0]);
-}
-
 void _x65_api_call(uint8_t data, void* user_data) {
     x65_t* sys = (x65_t*)user_data;
 
     // sync RIA regs
-    memcpy(__regs, sys->ria.reg, sizeof(__regs));
+    memcpy(regs, sys->ria.reg, sizeof(regs));
 
     switch (data) {
         case API_OP_ZXSTACK: {
-            rb_init(&sys->ria.api_stack);
+            xstack_ptr = XSTACK_SIZE;
+            api_return_ax(0);
         } break;
         case API_OP_PHI2: {
-            api_stack_push_uint16(sys, CPU_PHI2_DEFAULT);
+            const uint16_t phi2 = CPU_PHI2_DEFAULT;
+            api_push_uint16(&phi2);
+            api_return_ax(0);
         } break;
         case API_OP_OEM_GET_CHARGEN: {
-            uint8_t value;
-            if (!rb_get(&sys->ria.api_stack, &value)) break;
-            uint32_t mem_addr = (uint32_t)value;
-            if (!rb_get(&sys->ria.api_stack, &value)) break;
-            mem_addr |= (uint32_t)value << 8;
-            if (!rb_get(&sys->ria.api_stack, &value)) break;
-            mem_addr |= (uint32_t)value << 16;
-            if (!rb_get(&sys->ria.api_stack, &value)) break;
-            uint16_t code_page = (uint16_t)value;
-            if (!rb_get(&sys->ria.api_stack, &value)) break;
-            code_page |= (uint16_t)value << 8;
-
-            // copy chargen to memory
-            printf("Loading font page %02X to $%06X\n", code_page, mem_addr);
-            for (size_t i = 0; i < 256 * 8; ++i) {
-                mem_ram_write(sys, mem_addr++, font_get_byte(i, code_page));
+            uint16_t chargen_cp;
+            uint32_t chargen_addr;
+            if (!api_pop_uint16(&chargen_cp) || !api_pop_uint16(&((uint16_t*)(&chargen_addr))[0])
+                || !api_pop_uint8(&((uint8_t*)(&chargen_addr))[2]))
+                api_return_errno(API_EINVAL);
+            else {
+                // blit chargen to memory
+                for (size_t i = 0; i < 256 * 8; ++i) {
+                    mem_ram_write(sys, chargen_addr++, font_get_byte(i, chargen_cp));
+                }
+                api_return_ax(0);
             }
         } break;
         case API_OP_HALT:  // STOP CPU
@@ -626,7 +617,7 @@ void _x65_api_call(uint8_t data, void* user_data) {
     }
 
     // sync RIA regs back
-    memcpy(sys->ria.reg, __regs, sizeof(__regs));
+    memcpy(sys->ria.reg, regs, sizeof(regs));
 }
 
 #define RP6502_CODE_PAGE 0