web-a2e 1.0.0

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

@@ -0,0 +1,120 @@
+/*
+ * smartport_card.hpp - SmartPort expansion card for ProDOS block devices
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#pragma once
+
+#include "../expansion_card.hpp"
+#include "block_device.hpp"
+#include <cstdint>
+#include <functional>
+#include <array>
+
+namespace a2e {
+
+class SmartPortCard : public ExpansionCard {
+public:
+    static constexpr int MAX_DEVICES = 2;
+
+    using MemReadCallback = std::function<uint8_t(uint16_t)>;
+    using MemWriteCallback = std::function<void(uint16_t, uint8_t)>;
+    using RegGetCallback8 = std::function<uint8_t()>;
+    using RegSetCallback8 = std::function<void(uint8_t)>;
+    using RegGetCallback16 = std::function<uint16_t()>;
+    using RegSetCallback16 = std::function<void(uint16_t)>;
+
+    SmartPortCard();
+    ~SmartPortCard() override = default;
+
+    // ExpansionCard interface
+    uint8_t readIO(uint8_t offset) override;
+    void writeIO(uint8_t offset, uint8_t value) override;
+    uint8_t peekIO(uint8_t offset) const override { return 0xFF; }
+
+    uint8_t readROM(uint8_t offset) override;
+    bool hasROM() const override { return hasAnyDevice(); }
+
+    void reset() override;
+    const char* getName() const override { return "SmartPort"; }
+    uint8_t getPreferredSlot() const override { return 7; }
+
+    // State serialization
+    size_t getStateSize() const override;
+    size_t serialize(uint8_t* buffer, size_t maxSize) const override;
+    size_t deserialize(const uint8_t* buffer, size_t size) override;
+
+    // Slot configuration
+    void setSlotNumber(uint8_t slot);
+    uint8_t getSlotNumber() const { return slotNum_; }
+
+    // Device management
+    bool insertImage(int device, const uint8_t* data, size_t size, const std::string& filename);
+    void ejectImage(int device);
+    bool isImageInserted(int device) const;
+    const std::string& getImageFilename(int device) const;
+    bool isImageModified(int device) const;
+    const uint8_t* exportImageData(int device, size_t* size) const;
+    const uint8_t* getBlockData(int device, size_t* size) const;
+    BlockDevice* getDevice(int device);
+    const BlockDevice* getDevice(int device) const;
+
+    // Callbacks for memory and CPU access
+    void setMemReadCallback(MemReadCallback cb) { memRead_ = cb; }
+    void setMemWriteCallback(MemWriteCallback cb) { memWrite_ = cb; }
+    void setGetA(RegGetCallback8 cb) { getA_ = cb; }
+    void setSetA(RegSetCallback8 cb) { setA_ = cb; }
+    void setGetP(RegGetCallback8 cb) { getP_ = cb; }
+    void setSetP(RegSetCallback8 cb) { setP_ = cb; }
+    void setGetSP(RegGetCallback8 cb) { getSP_ = cb; }
+    void setSetSP(RegSetCallback8 cb) { setSP_ = cb; }
+    void setGetPC(RegGetCallback16 cb) { getPC_ = cb; }
+    void setSetPC(RegSetCallback16 cb) { setPC_ = cb; }
+    void setSetX(RegSetCallback8 cb) { setX_ = cb; }
+    void setSetY(RegSetCallback8 cb) { setY_ = cb; }
+
+    // Activity tracking for UI
+    bool hasActivity() const { return activity_; }
+    bool isActivityWrite() const { return activityWrite_; }
+    void clearActivity() { activity_ = false; }
+
+private:
+    void buildROM();
+    bool hasAnyDevice() const;
+    bool handleBoot();
+    void handleProDOSBlock();
+    void handleSmartPort();
+    void setErrorResult(uint8_t errorCode);
+
+    uint8_t slotNum_ = 7;
+    std::array<uint8_t, 256> rom_;
+    std::array<BlockDevice, MAX_DEVICES> devices_;
+
+    // Boot state: false until first boot completes, then ProDOS calls are handled
+    bool booted_ = false;
+
+    // Activity LED state
+    bool activity_ = false;
+    bool activityWrite_ = false;
+
+    // Static empty string for when no device is loaded
+    static const std::string emptyString_;
+
+    // Callbacks
+    MemReadCallback memRead_;
+    MemWriteCallback memWrite_;
+    RegGetCallback8 getA_;
+    RegSetCallback8 setA_;
+    RegGetCallback8 getP_;
+    RegSetCallback8 setP_;
+    RegGetCallback8 getSP_;
+    RegSetCallback8 setSP_;
+    RegGetCallback16 getPC_;
+    RegSetCallback16 setPC_;
+    RegSetCallback8 setX_;
+    RegSetCallback8 setY_;
+};
+
+} // namespace a2e

package/src/core/cards/thunderclock_card.cpp

@@ -0,0 +1,237 @@
+/*
+ * thunderclock_card.cpp - Thunderclock Plus real-time clock card implementation
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#include "thunderclock_card.hpp"
+#include "roms.cpp" // For embedded ROM data
+#include <ctime>
+#include <cstring>
+
+namespace a2e {
+
+// I/O offsets (masked with 0x8F)
+static constexpr uint8_t LOC_CONTROL = 0x00;  // $C0n0 - Control register
+static constexpr uint8_t LOC_AUX = 0x08;      // $C0n8 - Aux register (unused)
+
+// Control register flags
+static constexpr uint8_t FLAG_CLOCK = 0x02;   // Clock signal
+static constexpr uint8_t FLAG_STROBE = 0x04;  // Strobe signal
+
+// Commands (bits 3-5 of control register, directly from uPD1990C C0-C2 pins)
+// uPD1990C command encoding:
+//   000 = Register Hold
+//   001 = Register Shift
+//   010 = Time Set
+//   011 = Time Read
+//   100 = TP 64Hz
+//   101 = TP 256Hz
+//   110 = TP 2048Hz
+//   111 = Test Mode
+static constexpr uint8_t CMD_REGHOLD = 0x00;   // 000 - Hold register
+static constexpr uint8_t CMD_REGSHIFT = 0x01;  // 001 - Shift register
+static constexpr uint8_t CMD_TIMESET = 0x02;   // 010 - Time set
+static constexpr uint8_t CMD_TIMEREAD = 0x03;  // 011 - Time read
+
+ThunderclockCard::ThunderclockCard()
+    : rom_(roms::ROM_THUNDERCLOCK)
+    , romSize_(roms::ROM_THUNDERCLOCK_SIZE)
+{
+    latches_.fill(0);
+    reset();
+}
+
+void ThunderclockCard::updateLatches() {
+    // Get current time
+    std::time_t now = std::time(nullptr);
+    std::tm* tm = std::localtime(&now);
+
+    if (!tm) {
+        // Fallback if time unavailable
+        latches_.fill(0);
+        return;
+    }
+
+    int month = tm->tm_mon + 1;       // 1-12 (convert from 0-11)
+    int dayOfWeek = tm->tm_wday;      // 0-6 (Sunday=0)
+    int dayOfMonth = tm->tm_mday;     // 1-31
+    int hour = tm->tm_hour;           // 0-23
+    int minute = tm->tm_min;          // 0-59
+    int second = tm->tm_sec;          // 0-59
+
+    // Clear bits array
+    bitIndex_ = 0;
+
+    // Thunderclock Plus format (from AppleWin):
+    // 10 BCD nibbles, LSB-first within each nibble
+    // Order: sec_ones, sec_tens, min_ones, min_tens, hr_ones, hr_tens, day_ones, day_tens, dow, month
+    auto shiftNibbleLSB = [this](int value) {
+        for (int i = 0; i < 4; i++) {
+            if (bitIndex_ < 64) {
+                bits_[bitIndex_++] = (value >> i) & 1;
+            }
+        }
+    };
+
+    shiftNibbleLSB(second % 10);            // Nibble 0: Second ones
+    shiftNibbleLSB(second / 10);            // Nibble 1: Second tens
+    shiftNibbleLSB(minute % 10);            // Nibble 2: Minute ones
+    shiftNibbleLSB(minute / 10);            // Nibble 3: Minute tens
+    shiftNibbleLSB(hour % 10);              // Nibble 4: Hour ones
+    shiftNibbleLSB(hour / 10);              // Nibble 5: Hour tens
+    shiftNibbleLSB(dayOfMonth % 10);        // Nibble 6: Day ones
+    shiftNibbleLSB(dayOfMonth / 10);        // Nibble 7: Day tens
+    shiftNibbleLSB(dayOfWeek);              // Nibble 8: Day of week (0-6)
+    shiftNibbleLSB(month);                  // Nibble 9: Month (1-12)
+
+    // Total: 10 * 4 = 40 bits
+    currentBitIndex_ = 0;
+}
+
+uint8_t ThunderclockCard::readIO(uint8_t offset) {
+    // The Thunderclock uses offset 0 ($C0n0) for the control/data register
+    // All 16 I/O addresses appear to return the same register value
+    (void)offset;
+
+    // Return current register value
+    // Bit 7 contains the current data bit
+    return register_;
+}
+
+void ThunderclockCard::writeIO(uint8_t offset, uint8_t value) {
+    // The Thunderclock uses offset 0 ($C0n0) for the control register
+    // All 16 I/O addresses appear to access the same register
+    (void)offset;
+
+    // Extract control signals
+    bool strobe = (value & FLAG_STROBE) != 0;
+    bool clock = (value & FLAG_CLOCK) != 0;
+
+    // Check for strobe rising edge
+    if (strobe && !strobe_) {
+        // Capture command from bits 3-5 (C0, C1, C2 of uPD1990C)
+        command_ = (value >> 3) & 0x07;
+
+        if (command_ == CMD_TIMEREAD) {
+            // Time read command - refresh the bit stream
+            updateLatches();
+            // First bit should be immediately available on DATA OUT after load
+            if (bitIndex_ > 0) {
+                register_ = bits_[0] ? 0x80 : 0x00;
+            }
+        }
+    }
+
+    // Check for clock rising edge
+    if (clock && !clock_) {
+        // Shift out next bit - increment FIRST, then read
+        // This is because bit 0 is already presented after strobe/load
+        if (command_ == CMD_REGSHIFT || command_ == CMD_TIMEREAD) {
+            currentBitIndex_++;  // Advance to next bit position
+            if (currentBitIndex_ < bitIndex_) {
+                // Set bit 7 of register based on current bit
+                if (bits_[currentBitIndex_]) {
+                    register_ |= 0x80;
+                } else {
+                    register_ &= ~0x80;
+                }
+            } else {
+                register_ &= ~0x80;
+            }
+        }
+    }
+
+    // Save current state
+    strobe_ = strobe;
+    clock_ = clock;
+}
+
+uint8_t ThunderclockCard::peekIO(uint8_t offset) const {
+    (void)offset;
+    return register_;
+}
+
+uint8_t ThunderclockCard::readROM(uint8_t offset) {
+    // Slot ROM is the first 256 bytes
+    if (rom_ && romSize_ >= 256) {
+        return rom_[offset];
+    }
+    return 0xFF;
+}
+
+uint8_t ThunderclockCard::readExpansionROM(uint16_t offset) {
+    // Expansion ROM maps the ENTIRE 2KB ROM at $C800-$CFFF
+    // On real Thunderclock Plus hardware, the same 2KB ROM chip is used for both:
+    // - Slot ROM ($Cn00-$CnFF): reads bytes 0-255
+    // - Expansion ROM ($C800-$CFFF): reads bytes 0-2047 (full ROM)
+    if (rom_ && offset < romSize_) {
+        return rom_[offset];
+    }
+    return 0xFF;
+}
+
+void ThunderclockCard::reset() {
+    // Reset all state
+    strobe_ = false;
+    clock_ = false;
+    command_ = 0;
+    register_ = 0;
+    bitIndex_ = 0;
+    currentBitIndex_ = 0;
+
+    // Initialize time data
+    updateLatches();
+}
+
+size_t ThunderclockCard::serialize(uint8_t* buffer, size_t maxSize) const {
+    if (maxSize < STATE_SIZE) return 0;
+
+    size_t offset = 0;
+
+    // Control state
+    buffer[offset++] = strobe_ ? 1 : 0;
+    buffer[offset++] = clock_ ? 1 : 0;
+    buffer[offset++] = command_;
+    buffer[offset++] = register_;
+    buffer[offset++] = static_cast<uint8_t>(bitIndex_);
+    buffer[offset++] = static_cast<uint8_t>(currentBitIndex_);
+
+    // Bit stream data (64 bytes)
+    for (int i = 0; i < 64; i++) {
+        buffer[offset++] = bits_[i];
+    }
+
+    // Reserved (2 bytes for future use)
+    buffer[offset++] = 0;
+    buffer[offset++] = 0;
+
+    return offset;  // Should be 72 bytes
+}
+
+size_t ThunderclockCard::deserialize(const uint8_t* buffer, size_t size) {
+    if (size < STATE_SIZE) return 0;
+
+    size_t offset = 0;
+
+    // Control state
+    strobe_ = buffer[offset++] != 0;
+    clock_ = buffer[offset++] != 0;
+    command_ = buffer[offset++];
+    register_ = buffer[offset++];
+    bitIndex_ = buffer[offset++];
+    currentBitIndex_ = buffer[offset++];
+
+    // Bit stream data (64 bytes)
+    for (int i = 0; i < 64; i++) {
+        bits_[i] = buffer[offset++];
+    }
+
+    // Skip reserved bytes
+    offset += 2;
+
+    return offset;  // Should be 72 bytes
+}
+
+} // namespace a2e

package/src/core/cards/thunderclock_card.hpp

@@ -0,0 +1,122 @@
+/*
+ * thunderclock_card.hpp - Thunderclock Plus real-time clock card
+ *
+ * Written by
+ *  Mike Daley <michael_daley@icloud.com>
+ */
+
+#pragma once
+
+#include "expansion_card.hpp"
+#include <array>
+#include <cstdint>
+
+namespace a2e {
+
+/**
+ * ThunderclockCard - ProDOS-compatible clock card
+ *
+ * Implements the Thunderclock Plus clock card that provides automatic
+ * date/time stamping for ProDOS applications. This eliminates the
+ * "Enter today's date" prompts and enables proper file timestamps.
+ *
+ * ProDOS Detection:
+ * ProDOS scans slots looking for specific ROM signature bytes:
+ * - $Cn00: $08 (PHP instruction)
+ * - $Cn02: $28 (signature byte)
+ * - $Cn04: $58 (signature byte)
+ * - $Cn06: $70 (signature byte)
+ *
+ * When ProDOS finds these bytes, it:
+ * 1. Sets bit 0 of MACHID ($BF98) to indicate clock present
+ * 2. Patches the clock driver address at $BF07-$BF08
+ * 3. Changes $BF06 from $60 (RTS) to $4C (JMP)
+ *
+ * Hardware Interface:
+ * The Thunderclock Plus uses a serial interface via the control register
+ * at $C0n0 (where n = slot + 8). Time data is shifted out bit by bit.
+ *
+ * Control Register ($C0n0):
+ * - Bit 2 (STROBE): Rising edge triggers command execution
+ * - Bit 1 (CLOCK): Rising edge shifts next data bit
+ * - Bits 3-5: Command (from uPD1990C C0-C2 pins)
+ *
+ * Time Data Format (40 bits, 10 BCD nibbles, LSB-first within each nibble):
+ * - Second ones, Second tens (8 bits)
+ * - Minute ones, Minute tens (8 bits)
+ * - Hour ones, Hour tens (8 bits)
+ * - Day ones, Day tens (8 bits)
+ * - Day of week (4 bits, 0-6)
+ * - Month (4 bits, 1-12)
+ *
+ * ROM Space:
+ * - Slot ROM ($Cn00-$CnFF): 256 bytes - contains ProDOS driver
+ * - Expansion ROM ($C800-$CFFF): 1792 bytes - contains utility routines
+ *
+ * Typically installed in Slot 5 or Slot 7.
+ */
+class ThunderclockCard : public ExpansionCard {
+public:
+    ThunderclockCard();
+    ~ThunderclockCard() override = default;
+
+    // Delete copy
+    ThunderclockCard(const ThunderclockCard&) = delete;
+    ThunderclockCard& operator=(const ThunderclockCard&) = delete;
+
+    // Allow move
+    ThunderclockCard(ThunderclockCard&&) = default;
+    ThunderclockCard& operator=(ThunderclockCard&&) = 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; }
+
+    // Expansion ROM ($C800-$CFFF)
+    bool hasExpansionROM() const override { return true; }
+    uint8_t readExpansionROM(uint16_t offset) override;
+
+    void reset() override;
+
+    const char* getName() const override { return "Thunderclock"; }
+    uint8_t getPreferredSlot() const override { return 5; }
+
+    // State serialization
+    static constexpr size_t STATE_SIZE = 72;  // 6 bytes state + 64 bytes bits + 2 reserved
+    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;
+
+private:
+    // ROM data is loaded from embedded ROM file
+    const uint8_t* rom_;       // Pointer to embedded ROM data
+    size_t romSize_;           // Size of ROM (should be 2048)
+
+    // Serial interface state
+    bool strobe_ = false;      // Previous strobe state
+    bool clock_ = false;       // Previous clock state
+    uint8_t command_ = 0;      // Current command
+    uint8_t register_ = 0;     // Output register (bit 7 is data out)
+
+    // Time data as bit stream
+    std::array<uint8_t, 64> bits_;  // Bit buffer
+    int bitIndex_ = 0;              // Number of valid bits
+    int currentBitIndex_ = 0;       // Current bit being read
+
+    // Unused but kept for API compatibility
+    std::array<uint8_t, 16> latches_;
+
+    /**
+     * Update the bit stream with current system time
+     */
+    void updateLatches();
+};
+
+} // namespace a2e