GEOS 64 launches from the TR+ with the USB mouse, no disk drive

.gitattributes

@@ -4,3 +4,6 @@
 # Generated by tools/build-c64.mjs with LF endings; check them out as LF too so a
 # rebuild on Windows (core.autocrlf=true) doesn't flag unchanged headers as modified
 Source/Teensy/TRMenuFiles/ROMs/*.h text eol=lf
+
+# Generated by tools/geos/trmouse.py --c-header with LF endings, kept LF for the same reason
+Source/Teensy/GEOS/TRMouse128.h text eol=lf

Source/C64/MainMenuCRT/source/Menu_Regs.i

@@ -394,6 +394,7 @@
    rtBinC128 = 18
    rtFileREU = 19
    rtFileTRH = 20
+   rtGEOS = 21
 
 ;63 max: rRegItemTypePlusIOH uses bit 7 (assigned IOH) and bit 6 (/VMS claim),
 ;and TblItemType's mult by 4 limits it to 63 as well

Source/C64/MainMenuCRT/source/StringsMsgs.s

@@ -177,3 +177,4 @@ TblItemType: ;must match regItemTypes (rtNone, rtBin16k, etc) order!
    !tx 0, "128"  ; rtBinC128     = 18 
    !tx 0, "REU"  ; rtFileREU     = 19 
    !tx 0, "TRH"  ; rtFileTRH     = 20
+   !tx 0, "GEO"  ; rtGEOS        = 21

Source/Teensy/BlockDevice/TRBlock.h

@@ -0,0 +1,161 @@
+// SPDX-License-Identifier: MIT
+// The register side of the TR block device, free of Arduino so a host test can drive it.
+// The contract is docs/TR_Block_Device.md; offsets here are from the base that doc names.
+#pragma once
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#define TRBLOCK_SIZE         256
+#define TRBLOCK_WINDOW_SIZE  64
+#define TRBLOCK_INFO_SIZE    5
+
+enum TRBlockOffset
+{
+   TRBlockCmd    = 0x08,
+   TRBlockAddr0  = 0x09,
+   TRBlockAddr1  = 0x0a,
+   TRBlockPage   = 0x0b,
+   TRBlockToken  = 0x0c,
+   TRBlockStatus = 0x0d,
+   TRBlockEcho   = 0x0e,
+   TRBlockId     = 0x10,
+   TRBlockWindow = 0x40,
+};
+
+enum TRBlockCommand
+{
+   TRBlockRead  = 1,
+   TRBlockWrite = 2,
+   TRBlockFlush = 3,
+   TRBlockInfo  = 4,
+};
+
+enum TRBlockStatusValue
+{
+   TRBlockNeverRun   = 0x00,
+   TRBlockBusy       = 0x80,
+   TRBlockDone       = 0x5a,
+   TRBlockNoImage    = 0xe1,
+   TRBlockBadAddress = 0xe2,
+   TRBlockReadFailed = 0xe3,
+   TRBlockWriteFailed = 0xe4,
+   TRBlockReadOnly   = 0xe5,
+   TRBlockBadCommand = 0xe6,
+};
+
+static const char TRBlockIdText[] = "TRB";
+#define TRBLOCK_ID_SIZE (sizeof TRBlockIdText - 1)
+
+// Where the ISR and the main loop meet: the ISR only fills registers and the window and starts a
+// job, the main loop does the card's work.
+struct TRBlock
+{
+   uint8_t Buffer[TRBLOCK_SIZE];
+   uint8_t *Window;   // the page of Buffer the window shows, kept by page writes so a read does no arithmetic
+   uint8_t Addr0, Addr1, Token;
+   uint8_t JobCmd, JobAddr0, JobAddr1, JobToken;
+   volatile uint8_t Status, Echo;
+   volatile bool Pending;
+};
+
+struct TRBlockBackend
+{
+   void *Context;
+   uint8_t (*Transfer)(void *Context, bool Write, uint8_t Addr0, uint8_t Addr1, uint8_t *Block);
+   uint8_t (*Info)(void *Context, uint8_t *Out);   // TRBLOCK_INFO_SIZE bytes
+   uint8_t (*Flush)(void *Context);
+};
+
+// ISR and main loop run on one core, so only the compiler's ordering matters
+#define TRBLOCK_ORDER() __atomic_signal_fence(__ATOMIC_SEQ_CST)
+
+static inline void TRBlockReset(struct TRBlock *Dev)
+{
+   memset((void *)Dev, 0, sizeof *Dev);
+   Dev->Window = Dev->Buffer;
+}
+
+#define TRBLOCK_UNSERVED (-1)
+
+// The IO ISR's side: a read answers from the window or a register, else TRBLOCK_UNSERVED
+static inline int TRBlockReadAt(const struct TRBlock *Dev, uint8_t Offset)
+{
+   if (Offset >= TRBlockWindow)
+   {
+      if (Offset >= TRBlockWindow + TRBLOCK_WINDOW_SIZE) return TRBLOCK_UNSERVED;
+      return Dev->Window[Offset - TRBlockWindow];
+   }
+   if (Offset == TRBlockStatus) return Dev->Status;
+   if (Offset == TRBlockEcho) return Dev->Echo;
+   if ((uint8_t)(Offset - TRBlockId) < TRBLOCK_ID_SIZE) return (uint8_t)TRBlockIdText[Offset - TRBlockId];
+   return TRBLOCK_UNSERVED;
+}
+
+// ...and writes go to registers or the window. The caller reads the data byte only when this says
+// the offset takes one.
+static inline bool TRBlockTakes(uint8_t Offset)
+{
+   return (Offset >= TRBlockCmd && Offset <= TRBlockToken) ||
+          (Offset >= TRBlockWindow && Offset < TRBlockWindow + TRBLOCK_WINDOW_SIZE);
+}
+
+static inline void TRBlockWriteAt(struct TRBlock *Dev, uint8_t Offset, uint8_t Data)
+{
+   bool Busy = Dev->Status == TRBlockBusy;
+
+   if (Offset >= TRBlockWindow)
+   {
+      if (Offset < TRBlockWindow + TRBLOCK_WINDOW_SIZE && !Busy) Dev->Window[Offset - TRBlockWindow] = Data;
+      return;
+   }
+   if (Offset == TRBlockAddr0) Dev->Addr0 = Data;
+   else if (Offset == TRBlockAddr1) Dev->Addr1 = Data;
+   else if (Offset == TRBlockPage) Dev->Window = Dev->Buffer + (Data & 3) * TRBLOCK_WINDOW_SIZE;
+   else if (Offset == TRBlockToken) Dev->Token = Data;
+   else if (Offset == TRBlockCmd && !Busy)
+   {
+      Dev->JobCmd = Data;
+      Dev->JobAddr0 = Dev->Addr0;
+      Dev->JobAddr1 = Dev->Addr1;
+      Dev->JobToken = Dev->Token;
+      TRBLOCK_ORDER();
+      Dev->Status = TRBlockBusy;
+      TRBLOCK_ORDER();
+      Dev->Pending = true;
+   }
+}
+
+static uint8_t TRBlockRun(struct TRBlock *Dev, const struct TRBlockBackend *Backend)
+{
+   if (!Backend || !Backend->Context) return TRBlockNoImage;
+   switch (Dev->JobCmd)
+   {
+      case TRBlockRead:
+         return Backend->Transfer(Backend->Context, false, Dev->JobAddr0, Dev->JobAddr1, Dev->Buffer);
+      case TRBlockWrite:
+         return Backend->Transfer(Backend->Context, true, Dev->JobAddr0, Dev->JobAddr1, Dev->Buffer);
+      case TRBlockFlush:
+         return Backend->Flush(Backend->Context);
+      case TRBlockInfo:
+         return Backend->Info(Backend->Context, Dev->Buffer);
+   }
+   return TRBlockBadCommand;
+}
+
+// The main loop's side: runs a started command, true if there was one. The echo is published
+// before the status, so a status that is not busy always comes with its token.
+static inline bool TRBlockService(struct TRBlock *Dev, const struct TRBlockBackend *Backend)
+{
+   uint8_t Result;
+
+   if (!Dev->Pending) return false;
+   TRBLOCK_ORDER();
+   Result = TRBlockRun(Dev, Backend);
+   Dev->Pending = false;
+   TRBLOCK_ORDER();
+   Dev->Echo = Dev->JobToken;
+   TRBLOCK_ORDER();
+   Dev->Status = Result;
+   return true;
+}

Source/Teensy/BlockDevice/TRBlockImage.h

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+// A CBM disk image (D64, D71, D81) as the block device's backend: the track and sector the driver
+// sends become an offset in the image file.
+#pragma once
+#include "../GEOS/GeosDiskPatch.h"
+#include "TRBlock.h"
+
+#define TRBLOCK_IMAGE_WRITABLE 0x01
+
+struct TRBlockImage
+{
+   const struct GeosFormat *Format;
+   bool Writable;
+   void *Context;
+   bool (*Read)(void *Context, uint32_t Offset, uint8_t *Block);
+   bool (*Write)(void *Context, uint32_t Offset, const uint8_t *Block);
+   bool (*Flush)(void *Context);
+};
+
+static inline bool TRBlockImageHasSector(const struct GeosFormat *Format, uint8_t Track, uint8_t Sector)
+{
+   return Track >= 1 && Track <= Format->Tracks && Sector < GeosSectorsOnTrack(Format, Track);
+}
+
+FLASHMEM static uint8_t TRBlockImageTransfer(void *Context, bool Write, uint8_t Track, uint8_t Sector, uint8_t *Block)
+{
+   struct TRBlockImage *Image = (struct TRBlockImage *)Context;
+   uint32_t Offset;
+
+   if (!Image->Format) return TRBlockNoImage;
+   if (!TRBlockImageHasSector(Image->Format, Track, Sector)) return TRBlockBadAddress;
+   Offset = GeosOffset(Image->Format, Track, Sector);
+   if (!Write) return Image->Read(Image->Context, Offset, Block) ? TRBlockDone : TRBlockReadFailed;
+   if (!Image->Writable) return TRBlockReadOnly;
+   return Image->Write(Image->Context, Offset, Block) ? TRBlockDone : TRBlockWriteFailed;
+}
+
+FLASHMEM static uint8_t TRBlockImageInfo(void *Context, uint8_t *Out)
+{
+   struct TRBlockImage *Image = (struct TRBlockImage *)Context;
+   uint32_t Blocks;
+
+   if (!Image->Format) return TRBlockNoImage;
+   Blocks = Image->Format->Size / GEOS_SECTOR_SIZE;
+
+   Out[0] = (uint8_t)(Image->Format - GeosFormats + 1);
+   Out[1] = Image->Writable ? TRBLOCK_IMAGE_WRITABLE : 0;
+   Out[2] = (uint8_t)Blocks;
+   Out[3] = (uint8_t)(Blocks >> 8);
+   Out[4] = (uint8_t)(Blocks >> 16);
+   return TRBlockDone;
+}
+
+FLASHMEM static uint8_t TRBlockImageFlush(void *Context)
+{
+   struct TRBlockImage *Image = (struct TRBlockImage *)Context;
+
+   if (!Image->Format) return TRBlockNoImage;
+   return Image->Flush(Image->Context) ? TRBlockDone : TRBlockWriteFailed;
+}
+
+static inline struct TRBlockBackend TRBlockImageBackend(struct TRBlockImage *Image)
+{
+   return (struct TRBlockBackend){ Image, TRBlockImageTransfer, TRBlockImageInfo, TRBlockImageFlush };
+}

Source/Teensy/DriveDirLoad.ino

@@ -270,6 +270,11 @@ FLASHMEM void HandleExecution()
             return;
          }
 
+         if (MenuSelCpy.ItemType == rtGEOS)
+         {
+            if (!LaunchGeos((const struct GeosLauncher*)MenuSelCpy.Code_Image, &MenuSelCpy)) return;
+         }
+
          SendMsgPrintfln("%s", MenuSelCpy.Name);
          if (MenuSelCpy.ItemType == rtFileCrt)
          {  //load the CRT into RAM
@@ -322,7 +327,7 @@ FLASHMEM void HandleExecution()
 
          else
          {  //non-CRT: copy the whole thing from flash into the RAM1 buffer
-            memcpy(RAM_Image, MenuSelCpy.Code_Image, MenuSelCpy.Size);
+            if (MenuSelCpy.Code_Image != RAM_Image) memcpy(RAM_Image, MenuSelCpy.Code_Image, MenuSelCpy.Size);
             MenuSelCpy.Code_Image = RAM_Image;   
          }            
          SendMsgPrintfln("Copied to RAM");