web-a2e 1.0.0

package/src/core/cards/mouse_card.hpp

@@ -0,0 +1,190 @@
+/*
+ * mouse_card.hpp - Apple Mouse Interface card
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#pragma once
+
+#include "expansion_card.hpp"
+#include <cstdint>
+
+namespace a2e {
+
+/**
+ * MouseCard - Apple Mouse Interface Card emulation
+ *
+ * Emulates the Apple Mouse Interface Card (342-0270-C ROM) using the
+ * AppleWin-style PIA command protocol. The real ROM firmware executes
+ * as native 6502 code on the CPU while our C++ code emulates the
+ * "MCU side" of the MC6821 PIA — receiving commands and providing
+ * response data through Port A/B transitions.
+ *
+ * Protocol overview:
+ *   6502 CPU <-> ROM firmware (runs natively) <-> MC6821 PIA <-> Our "MCU" code
+ *
+ * The firmware writes command bytes to PIA Port A and toggles Port B
+ * control signals. Our code detects Port B transitions, buffers the
+ * command/data, and places response data on Port A input pins for the
+ * firmware to read back.
+ *
+ * Mouse state is communicated through "screen holes" by the firmware
+ * itself — we only provide position/status data via the PIA when asked.
+ *
+ * The 6821 PIA provides 4 registers at I/O offsets 0-3 and the
+ * real ROM is served for card identification and firmware execution.
+ * Port B bits 1-3 select the 256-byte ROM page (2KB total).
+ *
+ * VBL (Vertical Blank) interrupt generation:
+ * When the mouse mode has bit 3 set (VBL interrupt enable), an IRQ
+ * is generated at the start of each vertical blanking period.
+ *
+ * Available in slots 2, 4, and 7.
+ */
+class MouseCard : public ExpansionCard {
+public:
+    MouseCard();
+    ~MouseCard() override = default;
+
+    // Delete copy
+    MouseCard(const MouseCard&) = delete;
+    MouseCard& operator=(const MouseCard&) = delete;
+
+    // Allow move
+    MouseCard(MouseCard&&) = default;
+    MouseCard& operator=(MouseCard&&) = default;
+
+    // ===== ExpansionCard Interface =====
+
+    // I/O space ($C0n0-$C0nF)
+    uint8_t readIO(uint8_t offset) override;
+    void writeIO(uint8_t offset, uint8_t value) override;
+    uint8_t peekIO(uint8_t offset) const override;
+
+    // ROM space ($Cn00-$CnFF)
+    uint8_t readROM(uint8_t offset) override;
+    bool hasROM() const override { return true; }
+
+    // No expansion ROM - the mouse card uses banked slot ROM instead
+    bool hasExpansionROM() const override { return false; }
+    uint8_t readExpansionROM(uint16_t offset) override;
+
+    void reset() override;
+    void update(int cycles) override;
+
+    const char* getName() const override { return "Mouse"; }
+    uint8_t getPreferredSlot() const override { return 4; }
+
+    // IRQ support
+    void setIRQCallback(IRQCallback callback) override { irqCallback_ = callback; }
+    void setCycleCallback(CycleCallback callback) override { cycleCallback_ = callback; }
+    bool isIRQActive() const override { return irqActive_; }
+
+    // State serialization
+    static constexpr size_t STATE_SIZE = 36;
+    size_t getStateSize() const override { return STATE_SIZE; }
+    size_t serialize(uint8_t* buffer, size_t maxSize) const override;
+    size_t deserialize(const uint8_t* buffer, size_t size) override;
+
+    // Mouse input from browser
+    void setSlotNumber(uint8_t slot) { slotNum_ = slot; }
+    void addDelta(int dx, int dy);
+    void setMouseButton(bool pressed);
+
+    // Debug accessors
+    uint8_t getSlotNumber() const { return slotNum_; }
+    int16_t getMouseX() const { return mouseX_; }
+    int16_t getMouseY() const { return mouseY_; }
+    bool getMouseButton() const { return mouseButton_; }
+    bool getMoved() const { return moved_; }
+    bool getButtonChanged() const { return buttonChanged_; }
+    int16_t getClampMinX() const { return clampMinX_; }
+    int16_t getClampMaxX() const { return clampMaxX_; }
+    int16_t getClampMinY() const { return clampMinY_; }
+    int16_t getClampMaxY() const { return clampMaxY_; }
+    uint8_t getDDRA() const { return ddra_; }
+    uint8_t getDDRB() const { return ddrb_; }
+    uint8_t getORA() const { return ora_; }
+    uint8_t getORB() const { return orb_; }
+    uint8_t getIRA() const { return ira_; }
+    uint8_t getIRB() const { return irb_; }
+    uint8_t getCRA() const { return cra_; }
+    uint8_t getCRB() const { return crb_; }
+    bool getVBLInterruptPending() const { return vblInterruptPending_; }
+    bool getMoveInterruptPending() const { return moveInterruptPending_; }
+    bool getButtonInterruptPending() const { return buttonInterruptPending_; }
+    uint8_t getLastCommand() const { return lastCommand_; }
+    uint8_t getResponseState() const { return byState_; }
+    bool getWasInVBL() const { return wasInVBL_; }
+    uint8_t getMode() const { return mode_; }
+
+private:
+    // ROM data
+    const uint8_t* rom_;
+    size_t romSize_;
+
+    // Slot number (needed for screen hole addressing)
+    uint8_t slotNum_ = 4;
+
+    // 6821 PIA registers
+    uint8_t ddra_ = 0;     // Data Direction Register A (1=output, 0=input)
+    uint8_t ddrb_ = 0;     // Data Direction Register B
+    uint8_t ora_ = 0;      // Output Register A
+    uint8_t orb_ = 0;      // Output Register B
+    uint8_t ira_ = 0;      // Input Register A (peripheral side)
+    uint8_t irb_ = 0;      // Input Register B (peripheral side)
+    uint8_t cra_ = 0;      // Control Register A
+    uint8_t crb_ = 0;      // Control Register B
+
+    // Mouse state
+    int16_t mouseX_ = 0;
+    int16_t mouseY_ = 0;
+    bool mouseButton_ = false;
+    bool lastButton_ = false;
+    bool moved_ = false;
+    bool buttonChanged_ = false;
+
+    // Mouse mode (set by SetMouse command)
+    uint8_t mode_ = 0;
+
+    // Mouse clamping
+    int16_t clampMinX_ = 0;
+    int16_t clampMaxX_ = 1023;
+    int16_t clampMinY_ = 0;
+    int16_t clampMaxY_ = 1023;
+
+    // Interrupt state
+    bool irqActive_ = false;
+    bool vblInterruptPending_ = false;
+    bool moveInterruptPending_ = false;
+    bool buttonInterruptPending_ = false;
+
+    // VBL tracking
+    bool wasInVBL_ = false;
+
+    // IRQ/cycle callbacks
+    IRQCallback irqCallback_;
+    CycleCallback cycleCallback_;
+
+    // PIA command protocol state machine (AppleWin-style)
+    uint8_t byState_ = 0;       // Protocol state (0=idle, 1=writing, 2=reading)
+    uint8_t byBuff_[8] = {};    // Command/response data buffer
+    uint8_t nBuffPos_ = 0;      // Current buffer position
+    uint8_t nDataLen_ = 0;      // Expected data length for current operation
+    uint8_t by6821B_ = 0;       // Previous Port B value for transition detection
+    uint8_t lastCommand_ = 0;   // Last command byte (for debug display)
+
+    // Position snapshot (set on ReadMouse, served to firmware)
+    int16_t snapX_ = 0;
+    int16_t snapY_ = 0;
+
+    void updateIRQState();
+
+    // PIA command protocol handlers
+    void on6821_B(uint8_t byData);  // Port B transition handler
+    void onCommand();               // Command dispatch
+    void onWrite();                 // Multi-byte write dispatch
+};
+
+} // namespace a2e

package/src/core/cards/smartport/block_device.cpp

@@ -0,0 +1,202 @@
+/*
+ * block_device.cpp - Block-oriented storage device for SmartPort
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#include "block_device.hpp"
+#include <cstring>
+#include <algorithm>
+
+namespace a2e {
+
+bool BlockDevice::load(const uint8_t* data, size_t size, const std::string& filename) {
+    if (!data || size == 0) return false;
+
+    filename_ = filename;
+    modified_ = false;
+    writeProtected_ = false;
+    dataOffset_ = 0;
+
+    // Check for 2IMG format (64-byte header with "2IMG" magic)
+    if (size > 64 && data[0] == '2' && data[1] == 'I' && data[2] == 'M' && data[3] == 'G') {
+        // Parse 2IMG header
+        uint32_t headerSize = data[8] | (data[9] << 8) | (data[10] << 16) | (data[11] << 24);
+        uint32_t dataOffset = data[24] | (data[25] << 8) | (data[26] << 16) | (data[27] << 24);
+        uint32_t dataLength = data[28] | (data[29] << 8) | (data[30] << 16) | (data[31] << 24);
+        uint32_t flags = data[16] | (data[17] << 8) | (data[18] << 16) | (data[19] << 24);
+
+        // Validate
+        if (headerSize < 64 || dataOffset >= size) return false;
+        if (dataOffset + dataLength > size) return false;
+
+        // Image format in header byte 12: 0=DOS order, 1=ProDOS order, 2=nibble
+        uint32_t imageFormat = data[12] | (data[13] << 8) | (data[14] << 16) | (data[15] << 24);
+        if (imageFormat == 2) return false; // nibble format not supported as block device
+
+        writeProtected_ = (flags & 0x80000000) != 0;
+
+        // Block count from header
+        uint32_t blockCount = data[20] | (data[21] << 8) | (data[22] << 16) | (data[23] << 24);
+        if (blockCount == 0 && dataLength > 0) {
+            blockCount = dataLength / BLOCK_SIZE;
+        }
+        if (blockCount > MAX_BLOCKS) blockCount = MAX_BLOCKS;
+
+        dataOffset_ = dataOffset;
+        totalBlocks_ = static_cast<uint16_t>(blockCount);
+
+        // Store the entire file (header + data) so we can export it back
+        data_.assign(data, data + size);
+        return true;
+    }
+
+    // Raw ProDOS order (.hdv, .po) - just raw blocks
+    if (size < BLOCK_SIZE) return false;
+
+    uint32_t blockCount = size / BLOCK_SIZE;
+    if (blockCount > MAX_BLOCKS) blockCount = MAX_BLOCKS;
+
+    totalBlocks_ = static_cast<uint16_t>(blockCount);
+    dataOffset_ = 0;
+    data_.assign(data, data + size);
+    return true;
+}
+
+bool BlockDevice::readBlock(uint16_t blockNum, uint8_t* buffer) const {
+    if (!buffer || blockNum >= totalBlocks_) return false;
+
+    size_t offset = dataOffset_ + static_cast<size_t>(blockNum) * BLOCK_SIZE;
+    if (offset + BLOCK_SIZE > data_.size()) return false;
+
+    std::memcpy(buffer, data_.data() + offset, BLOCK_SIZE);
+    return true;
+}
+
+bool BlockDevice::writeBlock(uint16_t blockNum, const uint8_t* buffer) {
+    if (!buffer || blockNum >= totalBlocks_ || writeProtected_) return false;
+
+    size_t offset = dataOffset_ + static_cast<size_t>(blockNum) * BLOCK_SIZE;
+    if (offset + BLOCK_SIZE > data_.size()) return false;
+
+    std::memcpy(data_.data() + offset, buffer, BLOCK_SIZE);
+    modified_ = true;
+    return true;
+}
+
+const uint8_t* BlockDevice::exportData(size_t* size) const {
+    if (data_.empty()) {
+        if (size) *size = 0;
+        return nullptr;
+    }
+    if (size) *size = data_.size();
+    return data_.data();
+}
+
+const uint8_t* BlockDevice::getBlockData(size_t* size) const {
+    if (data_.empty()) {
+        if (size) *size = 0;
+        return nullptr;
+    }
+    if (size) *size = data_.size() - dataOffset_;
+    return data_.data() + dataOffset_;
+}
+
+size_t BlockDevice::getStateSize() const {
+    // flags(1) + totalBlocks(2) + dataOffset(4) + filenameLen(2) + filename + dataSize(4) + data
+    return 1 + 2 + 4 + 2 + filename_.size() + 4 + data_.size();
+}
+
+size_t BlockDevice::serialize(uint8_t* buffer, size_t maxSize) const {
+    size_t needed = getStateSize();
+    if (maxSize < needed) return 0;
+
+    size_t offset = 0;
+
+    // Flags: bit 0 = loaded, bit 1 = writeProtected, bit 2 = modified
+    uint8_t flags = 0;
+    if (!data_.empty()) flags |= 0x01;
+    if (writeProtected_) flags |= 0x02;
+    if (modified_) flags |= 0x04;
+    buffer[offset++] = flags;
+
+    // Total blocks (LE16)
+    buffer[offset++] = totalBlocks_ & 0xFF;
+    buffer[offset++] = (totalBlocks_ >> 8) & 0xFF;
+
+    // Data offset (LE32)
+    uint32_t doff = static_cast<uint32_t>(dataOffset_);
+    buffer[offset++] = doff & 0xFF;
+    buffer[offset++] = (doff >> 8) & 0xFF;
+    buffer[offset++] = (doff >> 16) & 0xFF;
+    buffer[offset++] = (doff >> 24) & 0xFF;
+
+    // Filename
+    uint16_t fnLen = static_cast<uint16_t>(filename_.size());
+    buffer[offset++] = fnLen & 0xFF;
+    buffer[offset++] = (fnLen >> 8) & 0xFF;
+    if (fnLen > 0) {
+        std::memcpy(buffer + offset, filename_.data(), fnLen);
+        offset += fnLen;
+    }
+
+    // Data
+    uint32_t dataSize = static_cast<uint32_t>(data_.size());
+    buffer[offset++] = dataSize & 0xFF;
+    buffer[offset++] = (dataSize >> 8) & 0xFF;
+    buffer[offset++] = (dataSize >> 16) & 0xFF;
+    buffer[offset++] = (dataSize >> 24) & 0xFF;
+    if (dataSize > 0) {
+        std::memcpy(buffer + offset, data_.data(), dataSize);
+        offset += dataSize;
+    }
+
+    return offset;
+}
+
+size_t BlockDevice::deserialize(const uint8_t* buffer, size_t size) {
+    if (size < 13) return 0; // minimum: flags + blocks + offset + fnLen + dataSize
+
+    size_t offset = 0;
+
+    uint8_t flags = buffer[offset++];
+    bool loaded = (flags & 0x01) != 0;
+    writeProtected_ = (flags & 0x02) != 0;
+    modified_ = (flags & 0x04) != 0;
+
+    totalBlocks_ = buffer[offset] | (buffer[offset + 1] << 8);
+    offset += 2;
+
+    dataOffset_ = buffer[offset] | (buffer[offset + 1] << 8) |
+                  (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24);
+    offset += 4;
+
+    uint16_t fnLen = buffer[offset] | (buffer[offset + 1] << 8);
+    offset += 2;
+    if (offset + fnLen > size) return 0;
+    if (fnLen > 0) {
+        filename_.assign(reinterpret_cast<const char*>(buffer + offset), fnLen);
+        offset += fnLen;
+    } else {
+        filename_.clear();
+    }
+
+    if (offset + 4 > size) return 0;
+    uint32_t dataSize = buffer[offset] | (buffer[offset + 1] << 8) |
+                        (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24);
+    offset += 4;
+
+    if (loaded && dataSize > 0) {
+        if (offset + dataSize > size) return 0;
+        data_.assign(buffer + offset, buffer + offset + dataSize);
+        offset += dataSize;
+    } else {
+        data_.clear();
+        totalBlocks_ = 0;
+    }
+
+    return offset;
+}
+
+} // namespace a2e

package/src/core/cards/smartport/block_device.hpp

@@ -0,0 +1,60 @@
+/*
+ * block_device.hpp - Block-oriented storage device for SmartPort
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace a2e {
+
+class BlockDevice {
+public:
+    static constexpr size_t BLOCK_SIZE = 512;
+    static constexpr size_t MAX_BLOCKS = 65535;
+
+    BlockDevice() = default;
+    ~BlockDevice() = default;
+
+    bool load(const uint8_t* data, size_t size, const std::string& filename);
+    bool readBlock(uint16_t blockNum, uint8_t* buffer) const;
+    bool writeBlock(uint16_t blockNum, const uint8_t* buffer);
+
+    uint16_t getTotalBlocks() const { return totalBlocks_; }
+    bool isWriteProtected() const { return writeProtected_; }
+    bool isModified() const { return modified_; }
+    bool isLoaded() const { return !data_.empty(); }
+    const std::string& getFilename() const { return filename_; }
+
+    const uint8_t* exportData(size_t* size) const;
+    const uint8_t* getBlockData(size_t* size) const;
+
+    size_t getStateSize() const;
+    size_t serialize(uint8_t* buffer, size_t maxSize) const;
+    size_t deserialize(const uint8_t* buffer, size_t size);
+
+    void eject() {
+        data_.clear();
+        totalBlocks_ = 0;
+        modified_ = false;
+        writeProtected_ = false;
+        filename_.clear();
+        dataOffset_ = 0;
+    }
+
+private:
+    std::vector<uint8_t> data_;
+    uint16_t totalBlocks_ = 0;
+    bool writeProtected_ = false;
+    bool modified_ = false;
+    std::string filename_;
+    size_t dataOffset_ = 0; // offset to block data (non-zero for 2IMG)
+};
+
+} // namespace a2e