Initial checkin of first cut of OTF

.gitignore

@@ -2,3 +2,4 @@
 .vscode
 .DS_Store
 video/build
+video.ino.cpp

platformio.ini

@@ -30,3 +30,4 @@ build_flags =
 monitor_filters = esp32_exception_decoder
 monitor_speed = 115200
 upload_speed = 600000
+build_type = debug

video/agon.h

@@ -60,6 +60,7 @@
 #define VDP_CONTROLKEYS			0x98	// Control keys on/off
 #define VDP_BUFFERED			0xA0	// Buffered commands
 #define VDP_UPDATER				0xA1	// Update VDP
+#define VDP_BDPP				0xA2	// Enable BDPP
 #define VDP_LOGICALCOORDS		0xC0	// Switch BBC Micro style logical coords on and off
 #define VDP_LEGACYMODES			0xC1	// Switch VDP 1.03 compatible modes on and off
 #define VDP_SWITCHBUFFER		0xC3	// Double buffering control
@@ -212,6 +213,9 @@ enum AudioState : uint8_t {	// Audio channel state
 #define BUFFERED_REVERSE				0x18	// Reverse the order of data in a buffer
 #define BUFFERED_COPY_REF				0x19	// Copy references to blocks from multiple buffers into one buffer
 #define BUFFERED_COPY_AND_CONSOLIDATE	0x1A	// Copy blocks from multiple buffers into one buffer and consolidate them
+#define BUFFERED_GET_DATA_BYTES			0x1B	// Get data bytes and return them in a BDPP packet
+#define BUFFERED_COMPRESS				0x1C	// Compress blocks from multiple buffers into one buffer
+#define BUFFERED_DECOMPRESS				0x1D	// Decompress blocks from multiple buffers into one buffer
 
 #define BUFFERED_DEBUG_INFO				0x20	// Get debug info about a buffer
 

video/bdpp/bdp_protocol.cpp

@@ -0,0 +1,111 @@
+//
+// Title:			Agon Video BIOS
+// Author:			Dean Belfield
+// Subtitle:		Bidirectional Packet Protocol
+// Author:			Curtis Whitley
+// Contributors:	
+// Created:			29/01/2024
+// Last Updated:	29/01/2024
+//
+
+#include "bdp_protocol.h"
+#include <HardwareSerial.h>
+#include <string.h>
+#include <queue>
+#include "soc/uhci_struct.h"
+#include "soc/uart_struct.h"
+#include "soc/uart_periph.h"
+#include "driver/uart.h"
+#include "uhci_driver.h"
+#include "uhci_hal.h"
+
+#define UHCI_NUM  UHCI_NUM_0
+#define UART_NUM  UART_NUM_2
+#define DEBUG_BDPP 0
+
+#if DEBUG_BDPP
+extern void debug_log(const char* fmt, ...);
+#endif
+
+bool bdpp_initialized; // Whether the driver has been initialized
+std::queue<Packet*> bdpp_tx_queue; // Transmit (TX) packet queue
+std::queue<UhciPacket*> bdpp_rx_queue[BDPP_MAX_STREAMS]; // Receive (RX) packet queue
+
+//--------------------------------------------------
+
+// Get whether the driver has been initialized.
+bool bdpp_is_initialized() {
+	return bdpp_initialized;
+}
+
+// Initialize the BDPP driver.
+//
+void bdpp_initialize_driver() {
+#if DEBUG_BDPP
+	debug_log("Activating BDPP.\n");
+#endif
+
+	Serial2.end(); // stop existing communication
+
+    uart_config_t uart_config = {
+        .baud_rate = 1152000,
+        .data_bits = UART_DATA_8_BITS,
+        .parity = UART_PARITY_DISABLE,
+        .stop_bits = UART_STOP_BITS_1,
+        .flow_ctrl = UART_HW_FLOWCTRL_CTS_RTS,
+        .rx_flow_ctrl_thresh = 64,
+		.source_clk = UART_SCLK_APB
+    };
+
+    uhci_driver_install(UHCI_NUM, 0);
+    uhci_attach_uart_port(UHCI_NUM, UART_NUM, &uart_config);
+	uart_dma_read();
+	bdpp_initialized = true;
+}
+
+// Queue a packet for transmission to the EZ80.
+// The packet is expected to be full (to contain all data that
+// VDP wants to place into it) when this function is called.
+void bdpp_queue_tx_packet(Packet* packet) {
+	auto uhci_packet = packet->get_uhci_packet();
+	auto act_size = packet->get_uhci_packet()->get_actual_data_size();
+
+#if DEBUG_BDPP
+	{
+		debug_log("Queue TX pkt: %02hX %02hX %02hX (%hu):",
+		uhci_packet->get_flags(),
+		uhci_packet->indexes,
+		uhci_packet->act_size, act_size);
+	auto data = uhci_packet->get_data();
+	for (uint16_t i = 0; i < act_size; i++) {
+		debug_log(" %02hX", data[i]);
+	}
+	debug_log("\n");
+	}
+#endif
+	auto old_int = uhci_disable_interrupts();
+	bdpp_tx_queue.push(packet);
+	uhci_enable_interrupts(old_int);
+	uart_dma_start_transmitter();
+}
+
+// Check for a received packet being available.
+bool bdpp_rx_packet_available(uint8_t stream_index) {
+	auto old_int = uhci_disable_interrupts();
+	bool available = !bdpp_rx_queue[stream_index].empty();
+	uhci_enable_interrupts(old_int);
+	return available;
+}
+
+// Get a received packet.
+UhciPacket* bdpp_get_rx_packet(uint8_t stream_index) {
+	UhciPacket* packet = NULL;
+	auto old_int = uhci_disable_interrupts();
+	auto queue = &bdpp_rx_queue[stream_index];
+	if (!queue->empty()) {
+		packet = queue->front();
+		queue->pop();
+	}
+	uhci_enable_interrupts(old_int);
+	return packet;
+}

video/bdpp/bdp_protocol.h

@@ -0,0 +1,37 @@
+//
+// Title:			Agon Video BIOS
+// Author:			Dean Belfield
+// Subtitle:		Bidirectional Packet Protocol
+// Author:			Curtis Whitley
+// Contributors:	
+// Created:			29/01/2024
+// Last Updated:	29/01/2024
+//
+
+#ifndef BDPP_PROTOCOL_H
+#define BDPP_PROTOCOL_H
+
+#include "packet.h"
+
+typedef uint8_t bool_t;	// To match what the EZ80 is using for this
+
+#define ESP32_COMM_PROTOCOL_VERSION		0x04	// Range is 0x04 to 0x0F, for future enhancements
+
+// Initialize the BDPP driver.
+void bdpp_initialize_driver();
+
+// Get whether the driver has been initialized.
+bool bdpp_is_initialized();
+
+// Queue a packet for transmission to the EZ80.
+// The packet is expected to be full (to contain all data that
+// VDP wants to place into it) when this function is called.
+void bdpp_queue_tx_packet(Packet* packet);
+
+// Check for a received packet being available.
+bool bdpp_rx_packet_available(uint8_t stream_index);
+
+// Get a received packet.
+UhciPacket* bdpp_get_rx_packet(uint8_t stream_index);
+
+#endif // BDPP_PROTOCOL_H

video/bdpp/bdp_stream.h

@@ -0,0 +1,200 @@
+//
+// Title:			Agon Video BIOS
+// Author:			Dean Belfield
+// Subtitle:		Bidirectional Packet Protocol
+// Author:			Curtis Whitley
+// Contributors:	
+// Created:			13/02/2024
+// Last Updated:	13/02/2024
+//
+
+#pragma once
+#include <Stream.h>
+#include "bdpp/bdp_protocol.h"
+
+#define DEBUG_BDPP 0
+
+#if DEBUG_BDPP
+extern void debug_log(const char* f, ...);
+#endif
+
+// This class represents a stream of data coming from BDPP.
+//
+class BdppStream : public Stream {
+    public:
+    // Construct a stream
+    //
+    // This defaults to stream #0, and is intended for creating
+    // an array of streams. To set the proper stream index, use
+    // the set_stream_index() function, below.
+    //
+    BdppStream() {
+        packet_index = 0;
+        stream_index = 0;
+        rx_packet = NULL;
+        tx_packet = NULL;
+        data_index = 0;
+    }
+
+    // Destroy the stream.
+    //
+    virtual ~BdppStream() {
+        if (rx_packet) {
+            delete rx_packet;
+        }
+        if (tx_packet) {
+            delete tx_packet;
+        }
+    }
+
+    // Set the stream index for this stream.
+    //
+    void set_stream_index(uint8_t stream_index) {
+        this->stream_index = stream_index;
+    }
+
+
+#if DEBUG_BDPP
+void show_rx_packet(UhciPacket* packet) {
+    auto act_size = packet->get_actual_data_size();
+    auto data = packet->get_data();
+    debug_log("RX pkt: %02hX %02hX %02hX (%u): ",
+        packet->get_flags(),
+        packet->indexes,
+        packet->act_size, act_size);
+    for (uint16_t i = 0; i < act_size; i++) {
+        auto ch = data[i];
+        if (ch == 0x20) {
+            debug_log("-");
+        } else if (ch > 0x20 && ch < 0x7E) {
+            debug_log("%c", ch);
+        } else {
+            debug_log("[%02hX]", ch);
+        }
+    }
+    debug_log("\n");
+}
+#endif
+
+    // Check for available data
+    //
+    // Data is available if we have a current packet where
+    // not all data bytes have been consumed (we discard
+    // packets that have a zero actual data size).
+    //
+    // If there is no current packet, but we can pull one from
+    // the packet queue, and the packet has a non-zero size,
+    // then data is available.
+    //
+    virtual int available() {
+        while (true) {
+            if (rx_packet) {
+                return rx_packet->get_actual_data_size() - data_index;
+            }
+            if (bdpp_rx_packet_available(stream_index)) {
+                rx_packet = bdpp_get_rx_packet(stream_index);
+#if DEBUG_BDPP
+                show_rx_packet(rx_packet);
+#endif
+                auto act_size = rx_packet->get_actual_data_size();
+                if (act_size) {
+                    data_index = 0;
+                    return act_size;
+                }
+                // ignore empty packet
+                rx_packet = NULL;
+            } else {
+                return 0; // no data available
+            }
+        }
+    }
+
+    // Read data from the current packet, if any.
+    //
+    // After reading a data byte, if the current packet has no more
+    // data left in it, we delete that packet (trusting that the
+    // "available()" function will grab another one from the queue later).
+    //
+    virtual int read() {
+        if (available()) {
+            auto result = (int)(uint)(rx_packet->get_data()[data_index++]);
+            if (data_index >= rx_packet->get_actual_data_size()) {
+                rx_packet = NULL;
+            }
+            return result;
+        } else {
+            return -1;
+        }
+    }
+
+    // Peek at available data, if any exists.
+    //
+    // This will return an available data byte, but will not remove
+    // that byte from the current packet.
+    //
+    virtual int peek() {
+        if (available()) {
+            return (int)(uint)(rx_packet->get_data()[data_index]);
+        } else {
+            return -1;
+        }
+    }
+
+    // Write data to the stream.
+    //
+    // This builds an outgoing (TX) packet, and sends it when full.
+    //
+    virtual size_t write(uint8_t data_byte) {
+        if (!tx_packet) {
+            tx_packet = Packet::create_driver_tx_packet(
+                BDPP_PKT_FLAG_PRINT | BDPP_PKT_FLAG_MIDDLE,
+                packet_index++, stream_index);
+            if (packet_index >= BDPP_MAX_DRIVER_PACKETS) {
+                packet_index = 0;
+            }
+        }
+        tx_packet->get_uhci_packet()->append_data(data_byte);
+        if (tx_packet->is_full()) {
+            bdpp_queue_tx_packet(tx_packet);
+            tx_packet = NULL;
+        }
+        return 1;
+    }
+
+    // Make available for writing.
+    //
+    virtual int availableForWrite() {
+        return true;
+    }
+
+    // Flush the stream.
+    //
+    // This will flush any packet currently being built.
+    //
+    virtual void flush() {
+        if (tx_packet) {
+            bdpp_queue_tx_packet(tx_packet);
+            tx_packet = NULL;
+        }
+    }
+
+    // Start an app-owned packet
+    //
+    // This will flush any existing TX packet, and start a new one,
+    // intended for a particular app-owned packet index at the EZ80.
+    //
+    Packet* start_app_response_packet(uint8_t packet_index) {
+        flush();
+        tx_packet = Packet::create_app_tx_packet(
+            BDPP_PKT_FLAG_PRINT | BDPP_PKT_FLAG_FIRST | BDPP_PKT_FLAG_RESPONSE,
+            packet_index, stream_index);
+        return tx_packet;
+    }
+
+    protected:
+    uint8_t     packet_index; // index of an outgoing packet
+    uint8_t     stream_index; // index of this string (0..BDPP_MAX_STREAMS-1)
+    uint16_t    data_index; // index into data portion of current packet
+    UhciPacket* rx_packet; // current packet used to extract data
+    Packet*     tx_packet; // current packet used to output data
+};