git.sesse.net Git - pistorm/blob - platforms/amiga/rtg/rtg_driver_amiga/pigfx.c

   1 // SPDX-License-Identifier: MIT
   2
   3 // PiStorm RTG driver, VBCC edition.
   4 // Based in part on the ZZ9000 RTG driver.
   5
   6 #include <proto/exec.h>
   7 #include <proto/expansion.h>
   8 #include <proto/dos.h>
   9 #include <proto/intuition.h>
  10 #include <exec/types.h>
  11 #include <exec/memory.h>
  12 #include <exec/libraries.h>
  13 #include <exec/execbase.h>
  14 #include <exec/resident.h>
  15 #include <exec/initializers.h>
  16 #include <clib/debug_protos.h>
  17 #include <string.h>
  18 #include <stdint.h>
  19 #include "boardinfo.h"
  20 #include "rtg_enums.h"
  21
  22 #define WRITESHORT(cmd, val) *(unsigned short *)((unsigned long)(b->RegisterBase)+cmd) = val;
  23 #define WRITELONG(cmd, val) *(unsigned long *)((unsigned long)(b->RegisterBase)+cmd) = val;
  24 #define WRITEBYTE(cmd, val) *(unsigned char *)((unsigned long)(b->RegisterBase)+cmd) = val;
  25
  26 #define CHECKRTG *((unsigned short *)(CARD_OFFSET))
  27
  28 #define CARD_OFFSET   0x70000000
  29 #define CARD_REGSIZE  0x00010000
  30 #define CARD_MEMSIZE  0x02000000 // 32MB "VRAM"
  31 #define CARD_SCRATCH  0x72010000
  32
  33 #define CHIP_RAM_SIZE 0x00200000 // Chip RAM offset, 2MB
  34
  35 const unsigned short rgbf_to_rtg[16] = {
  36   RTGFMT_8BIT,      // 0x00
  37   RTGFMT_8BIT,      // 0x01
  38   0,                // 0x02
  39   0,                // 0x03
  40   0,                // 0x04
  41   RTGFMT_RGB555,    // 0x05
  42   0,                // 0x06
  43   0,                // 0x07
  44   RTGFMT_RGB32,     // 0x08
  45   RTGFMT_RGB32,     // 0x09
  46   RTGFMT_RBG565,    // 0x0A
  47   RTGFMT_RGB555,    // 0x0B
  48   0,                // 0x0C
  49   RTGFMT_RGB555,    // 0x0D
  50   0,                // 0x0E
  51   0,                // 0x0F
  52 };
  53
  54 struct GFXBase {
  55   struct Library libNode;
  56   BPTR segList;
  57   struct ExecBase* sysBase;
  58   struct ExpansionBase* expansionBase;
  59 };
  60
  61 int FindCard(__REGA0(struct BoardInfo* b));
  62 int InitCard(__REGA0(struct BoardInfo* b));
  63
  64 void SetDAC (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format));
  65 void SetGC (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(BOOL border));
  66 void SetColorArray (__REGA0(struct BoardInfo *b), __REGD0(UWORD start), __REGD1(UWORD num));
  67 void SetPanning (__REGA0(struct BoardInfo *b), __REGA1(UBYTE *addr), __REGD0(UWORD width), __REGD1(WORD x_offset), __REGD2(WORD y_offset), __REGD7(RGBFTYPE format));
  68 UWORD SetSwitch (__REGA0(struct BoardInfo *b), __REGD0(UWORD enabled));
  69 UWORD SetDisplay (__REGA0(struct BoardInfo *b), __REGD0(UWORD enabled));
  70
  71 UWORD CalculateBytesPerRow (__REGA0(struct BoardInfo *b), __REGD0(UWORD width), __REGD7(RGBFTYPE format));
  72 APTR CalculateMemory (__REGA0(struct BoardInfo *b), __REGA1(unsigned long addr), __REGD7(RGBFTYPE format));
  73 ULONG GetCompatibleFormats (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format));
  74
  75 LONG ResolvePixelClock (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(ULONG pixel_clock), __REGD7(RGBFTYPE format));
  76 ULONG GetPixelClock (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(ULONG index), __REGD7(RGBFTYPE format));
  77 void SetClock (__REGA0(struct BoardInfo *b));
  78
  79 void SetMemoryMode (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format));
  80 void SetWriteMask (__REGA0(struct BoardInfo *b), __REGD0(UBYTE mask));
  81 void SetClearMask (__REGA0(struct BoardInfo *b), __REGD0(UBYTE mask));
  82 void SetReadPlane (__REGA0(struct BoardInfo *b), __REGD0(UBYTE plane));
  83
  84 void WaitVerticalSync (__REGA0(struct BoardInfo *b), __REGD0(BOOL toggle));
  85
  86 void FillRect (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD w), __REGD3(WORD h), __REGD4(ULONG color), __REGD5(UBYTE mask), __REGD7(RGBFTYPE format));
  87 void InvertRect (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD w), __REGD3(WORD h), __REGD4(UBYTE mask), __REGD7(RGBFTYPE format));
  88 void BlitRect (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD dx), __REGD3(WORD dy), __REGD4(WORD w), __REGD5(WORD h), __REGD6(UBYTE mask), __REGD7(RGBFTYPE format));
  89 void BlitRectNoMaskComplete (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *rs), __REGA2(struct RenderInfo *rt), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD dx), __REGD3(WORD dy), __REGD4(WORD w), __REGD5(WORD h), __REGD6(UBYTE minterm), __REGD7(RGBFTYPE format));
  90 void BlitTemplate (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGA2(struct Template *t), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD w), __REGD3(WORD h), __REGD4(UBYTE mask), __REGD7(RGBFTYPE format));
  91 void BlitPattern (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGA2(struct Pattern *p), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD w), __REGD3(WORD h), __REGD4(UBYTE mask), __REGD7(RGBFTYPE format));
  92 void DrawLine (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGA2(struct Line *l), __REGD0(UBYTE mask), __REGD7(RGBFTYPE format));
  93
  94 void BlitPlanar2Chunky (__REGA0(struct BoardInfo *b), __REGA1(struct BitMap *bm), __REGA2(struct RenderInfo *r), __REGD0(SHORT x), __REGD1(SHORT y), __REGD2(SHORT dx), __REGD3(SHORT dy), __REGD4(SHORT w), __REGD5(SHORT h), __REGD6(UBYTE minterm), __REGD7(UBYTE mask));
  95 void BlitPlanar2Direct (__REGA0(struct BoardInfo *b), __REGA1(struct BitMap *bmp), __REGA2(struct RenderInfo *r), __REGA3(struct ColorIndexMapping *clut), __REGD0(SHORT x), __REGD1(SHORT y), __REGD2(SHORT dx), __REGD3(SHORT dy), __REGD4(SHORT w), __REGD5(SHORT h), __REGD6(UBYTE minterm), __REGD7(UBYTE mask));
  96
  97 void SetSprite (__REGA0(struct BoardInfo *b), __REGD0(BOOL what), __REGD7(RGBFTYPE format));
  98 void SetSpritePosition (__REGA0(struct BoardInfo *b), __REGD0(WORD x), __REGD1(WORD y), __REGD7(RGBFTYPE format));
  99 void SetSpriteImage (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format));
 100 void SetSpriteColor (__REGA0(struct BoardInfo *b), __REGD0(UBYTE idx), __REGD1(UBYTE R), __REGD2(UBYTE G), __REGD3(UBYTE B), __REGD7(RGBFTYPE format));
 101
 102
 103 static ULONG LibStart(void) {
 104   return(-1);
 105 }
 106
 107 static const char LibraryName[] = "PiRTG.card";
 108 static const char LibraryID[]   = "$VER: PiRTG.card 0.01\r\n";
 109
 110 __saveds struct GFXBase* OpenLib(__REGA6(struct GFXBase *gfxbase));
 111 BPTR __saveds CloseLib(__REGA6(struct GFXBase *gfxbase));
 112 BPTR __saveds ExpungeLib(__REGA6(struct GFXBase *exb));
 113 ULONG ExtFuncLib(void);
 114 __saveds struct GFXBase* InitLib(__REGA6(struct ExecBase *sysbase),
 115                                  __REGA0(BPTR seglist),
 116                                  __REGD0(struct GFXBase *exb));
 117
 118 static const APTR FuncTab[] = {
 119   (APTR)OpenLib,
 120   (APTR)CloseLib,
 121   (APTR)ExpungeLib,
 122   (APTR)ExtFuncLib,
 123
 124   (APTR)FindCard,
 125   (APTR)InitCard,
 126   (APTR)((LONG)-1)
 127 };
 128
 129 struct InitTable
 130 {
 131   ULONG LibBaseSize;
 132   APTR  FunctionTable;
 133   APTR  DataTable;
 134   APTR  InitLibTable;
 135 };
 136
 137 static struct InitTable InitTab = {
 138   (ULONG) sizeof(struct GFXBase),
 139   (APTR) FuncTab,
 140   (APTR) NULL,
 141   (APTR) InitLib
 142 };
 143
 144 static const struct Resident ROMTag = {
 145         RTC_MATCHWORD,
 146   &ROMTag,
 147   &ROMTag + 1,
 148   RTF_AUTOINIT,
 149         83,
 150   NT_LIBRARY,
 151   0,
 152   (char *)LibraryName,
 153   (char *)LibraryID,
 154   (APTR)&InitTab
 155 };
 156
 157 #define CLOCK_HZ 100000000
 158
 159 static struct GFXBase *_gfxbase;
 160 const char *gfxname = "PiStorm RTG";
 161 char dummies[128];
 162
 163 __saveds struct GFXBase* InitLib(__REGA6(struct ExecBase *sysbase),
 164                                           __REGA0(BPTR seglist),
 165                                           __REGD0(struct GFXBase *exb))
 166 {
 167   _gfxbase = exb;
 168   return _gfxbase;
 169 }
 170
 171 __saveds struct GFXBase* OpenLib(__REGA6(struct GFXBase *gfxbase))
 172 {
 173   gfxbase->libNode.lib_OpenCnt++;
 174   gfxbase->libNode.lib_Flags &= ~LIBF_DELEXP;
 175
 176   return gfxbase;
 177 }
 178
 179 BPTR __saveds CloseLib(__REGA6(struct GFXBase *gfxbase))
 180 {
 181   gfxbase->libNode.lib_OpenCnt--;
 182
 183   if (!gfxbase->libNode.lib_OpenCnt) {
 184     if (gfxbase->libNode.lib_Flags & LIBF_DELEXP) {
 185       return (ExpungeLib(gfxbase));
 186     }
 187   }
 188   return 0;
 189 }
 190
 191 BPTR __saveds ExpungeLib(__REGA6(struct GFXBase *exb))
 192 {
 193   BPTR seglist;
 194   struct ExecBase *SysBase = *(struct ExecBase **)4L;
 195
 196   if(!exb->libNode.lib_OpenCnt) {
 197     ULONG negsize, possize, fullsize;
 198     UBYTE *negptr = (UBYTE *)exb;
 199
 200     seglist = exb->segList;
 201
 202     Remove((struct Node *)exb);
 203
 204     negsize  = exb->libNode.lib_NegSize;
 205     possize  = exb->libNode.lib_PosSize;
 206     fullsize = negsize + possize;
 207     negptr  -= negsize;
 208
 209     FreeMem(negptr, fullsize);
 210     return(seglist);
 211   }
 212
 213   exb->libNode.lib_Flags |= LIBF_DELEXP;
 214   return 0;
 215 }
 216
 217 ULONG ExtFuncLib(void)
 218 {
 219   return 0;
 220 }
 221
 222 static LONG zorro_version = 0;
 223
 224 static struct GFXData *gfxdata;
 225 //MNTZZ9KRegs* registers;
 226
 227 #define LOADLIB(a, b) if ((a = (struct a*)OpenLibrary(b,0L))==NULL) { \
 228     KPrintF("Failed to load %s.\n", b); \
 229     return 0; \
 230   } \
 231
 232 static BYTE card_already_found;
 233 static BYTE card_initialized;
 234
 235 int FindCard(__REGA0(struct BoardInfo* b)) {
 236   //if (card_already_found)
 237 //    return 1;
 238   uint16_t card_check = CHECKRTG;
 239   if (card_check != 0xFFCF) {
 240     // RTG not enabled
 241     return 0;
 242   }
 243
 244   struct ConfigDev* cd = NULL;
 245   struct ExpansionBase *ExpansionBase = NULL;
 246   struct DOSBase *DOSBase = NULL;
 247   struct IntuitionBase *IntuitionBase = NULL;
 248   struct ExecBase *SysBase = *(struct ExecBase **)4L;
 249
 250   LOADLIB(ExpansionBase, "expansion.library");
 251   LOADLIB(DOSBase, "dos.library");
 252   LOADLIB(IntuitionBase, "intuition.library");
 253
 254   b->MemorySize = CARD_MEMSIZE;
 255   b->RegisterBase = (void *)CARD_OFFSET;
 256   b->MemoryBase = (void *)(CARD_OFFSET + CARD_REGSIZE);
 257
 258   return 1;
 259 }
 260
 261 #define HWSPRITE 1
 262 #define VGASPLIT (1 << 6)
 263 #define FLICKERFIXER (1 << 12)
 264 #define INDISPLAYCHAIN (1 << 20)
 265 #define DIRECTACCESS (1 << 26)
 266
 267 int InitCard(__REGA0(struct BoardInfo* b)) {
 268   //if (!card_initialized)
 269 //    card_initialized = 1;
 270 //  else
 271     //return 1;
 272
 273   int max, i;
 274   struct ExecBase *SysBase = *(struct ExecBase **)4L;
 275
 276   b->CardBase = (struct CardBase *)_gfxbase;
 277   b->ExecBase = SysBase;
 278   b->BoardName = "PiStorm RTG";
 279   b->BoardType = BT_MNT_ZZ9000;
 280   b->PaletteChipType = PCT_MNT_ZZ9000;
 281   b->GraphicsControllerType = GCT_MNT_ZZ9000;
 282
 283   b->Flags = BIF_INDISPLAYCHAIN | BIF_GRANTDIRECTACCESS | BIF_HARDWARESPRITE;
 284   b->RGBFormats = 1 | 2 | 512 | 1024 | 2048;
 285   b->SoftSpriteFlags = 0;
 286   b->BitsPerCannon = 8;
 287
 288   for(i = 0; i < MAXMODES; i++) {
 289     b->MaxHorValue[i] = 8192;
 290     b->MaxVerValue[i] = 8192;
 291     b->MaxHorResolution[i] = 8192;
 292     b->MaxVerResolution[i] = 8192;
 293     b->PixelClockCount[i] = 1;
 294   }
 295
 296   b->MemoryClock = CLOCK_HZ;
 297
 298   //b->AllocCardMem = (void *)NULL;
 299   //b->FreeCardMem = (void *)NULL;
 300   b->SetSwitch = (void *)SetSwitch;
 301   b->SetColorArray = (void *)SetColorArray;
 302   b->SetDAC = (void *)SetDAC;
 303   b->SetGC = (void *)SetGC;
 304   b->SetPanning = (void *)SetPanning;
 305   b->CalculateBytesPerRow = (void *)CalculateBytesPerRow;
 306   b->CalculateMemory = (void *)CalculateMemory;
 307   b->GetCompatibleFormats = (void *)GetCompatibleFormats;
 308   b->SetDisplay = (void *)SetDisplay;
 309
 310   b->ResolvePixelClock = (void *)ResolvePixelClock;
 311   b->GetPixelClock = (void *)GetPixelClock;
 312   b->SetClock = (void *)SetClock;
 313
 314   b->SetMemoryMode = (void *)SetMemoryMode;
 315   b->SetWriteMask = (void *)SetWriteMask;
 316   b->SetClearMask = (void *)SetClearMask;
 317   b->SetReadPlane = (void *)SetReadPlane;
 318
 319   b->WaitVerticalSync = (void *)WaitVerticalSync;
 320   //b->SetInterrupt = (void *)NULL;
 321
 322   //b->WaitBlitter = (void *)NULL;
 323
 324   //b->ScrollPlanar = (void *)NULL;
 325   //b->UpdatePlanar = (void *)NULL;
 326
 327   b->BlitPlanar2Chunky = (void *)BlitPlanar2Chunky;
 328   b->BlitPlanar2Direct = (void *)BlitPlanar2Direct;
 329
 330   b->FillRect = (void *)FillRect;
 331   b->InvertRect = (void *)InvertRect;
 332   b->BlitRect = (void *)BlitRect;
 333   b->BlitTemplate = (void *)BlitTemplate;
 334   b->BlitPattern = (void *)BlitPattern;
 335   b->DrawLine = (void *)DrawLine;
 336   b->BlitRectNoMaskComplete = (void *)BlitRectNoMaskComplete;
 337   //b->EnableSoftSprite = (void *)NULL;
 338
 339   //b->AllocCardMemAbs = (void *)NULL;
 340   //b->SetSplitPosition = (void *)NULL;
 341   //b->ReInitMemory = (void *)NULL;
 342   //b->WriteYUVRect = (void *)NULL;
 343   //b->GetVSyncState = (void *)NULL;
 344   //b->GetVBeamPos = (void *)NULL;
 345   //b->SetDPMSLevel = (void *)NULL;
 346   //b->ResetChip = (void *)NULL;
 347   //b->GetFeatureAttrs = (void *)NULL;
 348   //b->AllocBitMap = (void *)NULL;
 349   //b->FreeBitMap = (void *)NULL;
 350   //b->GetBitMapAttr = (void *)NULL;
 351
 352   b->SetSprite = (void *)SetSprite;
 353   b->SetSpritePosition = (void *)SetSpritePosition;
 354   b->SetSpriteImage = (void *)SetSpriteImage;
 355   b->SetSpriteColor = (void *)SetSpriteColor;
 356
 357   //b->CreateFeature = (void *)NULL;
 358   //b->SetFeatureAttrs = (void *)NULL;
 359   //b->DeleteFeature = (void *)NULL;
 360
 361   return 1;
 362 }
 363
 364 void SetDAC (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format)) {
 365   // Used to set the color format of the video card's RAMDAC.
 366   // This needs no handling, since the PiStorm doesn't really have a RAMDAC or a video card chipset.
 367 }
 368
 369 void SetGC (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(BOOL border)) {
 370   b->ModeInfo = mode_info;
 371   // Send width, height and format to the RaspberryPi Targetable Graphics.
 372   WRITESHORT(RTG_X1, mode_info->Width);
 373   WRITESHORT(RTG_Y1, mode_info->Height);
 374   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[b->RGBFormat]);
 375   WRITESHORT(RTG_COMMAND, RTGCMD_SETGC);
 376 }
 377
 378 int setswitch = -1;
 379 UWORD SetSwitch (__REGA0(struct BoardInfo *b), __REGD0(UWORD enabled)) {
 380   if (setswitch != enabled) {
 381     setswitch = enabled;
 382   }
 383
 384   WRITEBYTE(RTG_U81, setswitch);
 385   WRITESHORT(RTG_X1, setswitch);
 386   WRITESHORT(RTG_COMMAND, RTGCMD_SETSWITCH);
 387
 388   return 1 - enabled;
 389 }
 390
 391 void SetPanning (__REGA0(struct BoardInfo *b), __REGA1(UBYTE *addr), __REGD0(UWORD width), __REGD1(WORD x_offset), __REGD2(WORD y_offset), __REGD7(RGBFTYPE format)) {
 392   // Set the panning offset, or the offset used for the current display area on the Pi.
 393   // The address needs to have CARD_BASE subtracted from it to be used as an offset on the Pi side.
 394   if (!b)
 395     return;
 396
 397   b->XOffset = x_offset;
 398   b->YOffset = y_offset;
 399
 400   WRITELONG(RTG_ADDR1, (unsigned long)addr);
 401   WRITESHORT(RTG_X1, width);
 402   WRITESHORT(RTG_X2, b->XOffset);
 403   WRITESHORT(RTG_Y2, b->YOffset);
 404   WRITESHORT(RTG_COMMAND, RTGCMD_SETPAN);
 405 }
 406
 407 void SetColorArray (__REGA0(struct BoardInfo *b), __REGD0(UWORD start), __REGD1(UWORD num)) {
 408   // Sets the color components of X color components for 8-bit paletted display modes.
 409   if (!b->CLUT)
 410     return;
 411
 412   int j = start + num;
 413
 414   for(int i = start; i < j; i++) {
 415     //WRITEBYTE(RTG_U82, (unsigned char)b->CLUT[i].Red);
 416     //WRITEBYTE(RTG_U83, (unsigned char)b->CLUT[i].Green);
 417     //WRITEBYTE(RTG_U84, (unsigned char)b->CLUT[i].Blue);
 418     unsigned long xrgb = 0 | (b->CLUT[i].Red << 16) | (b->CLUT[i].Green << 8) | (b->CLUT[i].Blue);
 419     WRITEBYTE(RTG_U81, (unsigned char)i);
 420     WRITELONG(RTG_RGB1, xrgb);
 421     WRITESHORT(RTG_COMMAND, RTGCMD_SETCLUT);
 422   }
 423 }
 424
 425 UWORD CalculateBytesPerRow (__REGA0(struct BoardInfo *b), __REGD0(UWORD width), __REGD7(RGBFTYPE format)) {
 426   if (!b)
 427     return 0;
 428
 429   UWORD pitch = width;
 430
 431   switch(format) {
 432     default:
 433       return pitch;
 434     case 0x05: case 0x0A: case 0x0B: case 0x0D:
 435       return (width * 2);
 436     case 0x08: case 0x09:
 437       return (width * 4);
 438   }
 439 }
 440
 441 APTR CalculateMemory (__REGA0(struct BoardInfo *b), __REGA1(unsigned long addr), __REGD7(RGBFTYPE format)) {
 442   /*if (!b)
 443     return (APTR)addr;
 444
 445   if (addr > (unsigned int)b->MemoryBase && addr < (((unsigned int)b->MemoryBase) + b->MemorySize)) {
 446     addr = ((addr + 0x1000) & 0xFFFFF000);
 447   }*/
 448
 449   return (APTR)addr;
 450 }
 451
 452 ULONG GetCompatibleFormats (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format)) {
 453   // It is of course compatible with all the formats ever.
 454   return 0xFFFFFFFF;
 455 }
 456
 457 static int display_enabled = 0;
 458 UWORD SetDisplay (__REGA0(struct BoardInfo *b), __REGD0(UWORD enabled)) {
 459   // Enables or disables the display.
 460   WRITEBYTE(RTG_U82, (unsigned char)enabled);
 461   WRITESHORT(RTG_COMMAND, RTGCMD_SETDISPLAY);
 462
 463   return 1;
 464 }
 465
 466 LONG ResolvePixelClock (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(ULONG pixel_clock), __REGD7(RGBFTYPE format)) {
 467   mode_info->PixelClock = CLOCK_HZ;
 468   mode_info->pll1.Clock = 0;
 469   mode_info->pll2.ClockDivide = 1;
 470
 471   return 0;
 472 }
 473
 474 ULONG GetPixelClock (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(ULONG index), __REGD7(RGBFTYPE format)) {
 475   // Just return 100MHz.
 476   return CLOCK_HZ;
 477 }
 478
 479 // None of these five really have to do anything.
 480 void SetClock (__REGA0(struct BoardInfo *b)) {
 481 }
 482
 483 void SetMemoryMode (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format)) {
 484 }
 485
 486 void SetWriteMask (__REGA0(struct BoardInfo *b), __REGD0(UBYTE mask)) {
 487 }
 488
 489 void SetClearMask (__REGA0(struct BoardInfo *b), __REGD0(UBYTE mask)) {
 490 }
 491
 492 void SetReadPlane (__REGA0(struct BoardInfo *b), __REGD0(UBYTE plane)) {
 493 }
 494
 495 void WaitVerticalSync (__REGA0(struct BoardInfo *b), __REGD0(BOOL toggle)) {
 496   // I don't know why this one has a bool in D0, but it isn't used for anything.
 497 }
 498
 499 void FillRect (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD w), __REGD3(WORD h), __REGD4(ULONG color), __REGD5(UBYTE mask), __REGD7(RGBFTYPE format)) {
 500   if (!r)
 501     return;
 502
 503   WRITELONG(RTG_ADDR1, (unsigned long)r->Memory);
 504
 505   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
 506   WRITESHORT(RTG_X1, x);
 507   WRITESHORT(RTG_X2, w);
 508   WRITESHORT(RTG_Y1, y);
 509   WRITESHORT(RTG_Y2, h);
 510   WRITELONG(RTG_RGB1, color);
 511   WRITESHORT(RTG_X3, r->BytesPerRow);
 512   WRITEBYTE(RTG_U81, mask);
 513   WRITESHORT(RTG_COMMAND, RTGCMD_FILLRECT);
 514 }
 515
 516 void InvertRect (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD w), __REGD3(WORD h), __REGD4(UBYTE mask), __REGD7(RGBFTYPE format)) {
 517   if (!r)
 518     return;
 519
 520   if (mask != 0xFF) {
 521     b->InvertRectDefault(b, r, x, y, w, h, mask, format);
 522     return;
 523   }
 524
 525   WRITELONG(RTG_ADDR1, (unsigned long)r->Memory);
 526
 527   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
 528   WRITESHORT(RTG_X1, x);
 529   WRITESHORT(RTG_X2, w);
 530   WRITESHORT(RTG_Y1, y);
 531   WRITESHORT(RTG_Y2, h);
 532   WRITESHORT(RTG_X3, r->BytesPerRow);
 533   WRITEBYTE(RTG_U81, mask);
 534   WRITESHORT(RTG_COMMAND, RTGCMD_INVERTRECT);
 535 }
 536
 537 void BlitRect (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD dx), __REGD3(WORD dy), __REGD4(WORD w), __REGD5(WORD h), __REGD6(UBYTE mask), __REGD7(RGBFTYPE format)) {
 538   if (!r)
 539     return;
 540
 541   WRITELONG(RTG_ADDR1, (unsigned long)r->Memory);
 542
 543   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
 544   WRITESHORT(RTG_X1, x);
 545   WRITESHORT(RTG_X2, dx);
 546   WRITESHORT(RTG_X3, w);
 547   WRITESHORT(RTG_Y1, y);
 548   WRITESHORT(RTG_Y2, dy);
 549   WRITESHORT(RTG_Y3, h);
 550   WRITESHORT(RTG_X4, r->BytesPerRow);
 551   WRITEBYTE(RTG_U81, mask);
 552   WRITESHORT(RTG_COMMAND, RTGCMD_BLITRECT);
 553 }
 554
 555 void BlitRectNoMaskComplete (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *rs), __REGA2(struct RenderInfo *rt), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD dx), __REGD3(WORD dy), __REGD4(WORD w), __REGD5(WORD h), __REGD6(UBYTE minterm), __REGD7(RGBFTYPE format)) {
 556   if (!rs || !rt)
 557     return;
 558
 559   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
 560   WRITELONG(RTG_ADDR1, (unsigned long)rs->Memory);
 561   WRITELONG(RTG_ADDR2, (unsigned long)rt->Memory);
 562   WRITESHORT(RTG_X1, x);
 563   WRITESHORT(RTG_X2, dx);
 564   WRITESHORT(RTG_X3, w);
 565   WRITESHORT(RTG_Y1, y);
 566   WRITESHORT(RTG_Y2, dy);
 567   WRITESHORT(RTG_Y3, h);
 568   WRITESHORT(RTG_X4, rs->BytesPerRow);
 569   WRITESHORT(RTG_X5, rt->BytesPerRow);
 570   WRITEBYTE(RTG_U81, minterm);
 571   WRITESHORT(RTG_COMMAND, RTGCMD_BLITRECT_NOMASK_COMPLETE);
 572 }
 573
 574 void BlitTemplate (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGA2(struct Template *t), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD w), __REGD3(WORD h), __REGD4(UBYTE mask), __REGD7(RGBFTYPE format)) {
 575   if (!r || !t) return;
 576   if (w < 1 || h < 1) return;
 577
 578   WRITELONG(RTG_ADDR2, (unsigned long)r->Memory);
 579
 580   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
 581   WRITESHORT(RTG_X1, x);
 582   WRITESHORT(RTG_X2, w);
 583   WRITESHORT(RTG_X3, t->XOffset);
 584   WRITESHORT(RTG_Y1, y);
 585   WRITESHORT(RTG_Y2, h);
 586   WRITESHORT(RTG_Y3, 0);
 587
 588   if ((unsigned long)t->Memory > CHIP_RAM_SIZE) {
 589     WRITELONG(RTG_ADDR1, (unsigned long)t->Memory);
 590   }
 591   else {
 592     unsigned long dest = CARD_SCRATCH;
 593     memcpy((unsigned char *)dest, t->Memory, (t->BytesPerRow * h));
 594     WRITELONG(RTG_ADDR1, (unsigned long)dest);
 595     WRITELONG(RTG_ADDR3, (unsigned long)t->Memory);
 596   }
 597
 598   WRITELONG(RTG_RGB1, t->FgPen);
 599   WRITELONG(RTG_RGB2, t->BgPen);
 600
 601   WRITESHORT(RTG_X4, r->BytesPerRow);
 602   WRITESHORT(RTG_X5, t->BytesPerRow);
 603
 604   WRITEBYTE(RTG_U81, mask);
 605   WRITEBYTE(RTG_U82, t->DrawMode);
 606   WRITESHORT(RTG_COMMAND, RTGCMD_BLITTEMPLATE);
 607 }
 608
 609 void BlitPattern (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGA2(struct Pattern *p), __REGD0(WORD x), __REGD1(WORD y), __REGD2(WORD w), __REGD3(WORD h), __REGD4(UBYTE mask), __REGD7(RGBFTYPE format)) {
 610   if (!r || !p) return;
 611   if (w < 1 || h < 1) return;
 612
 613   WRITELONG(RTG_ADDR2, (unsigned long)r->Memory);
 614
 615   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
 616   WRITESHORT(RTG_X1, x);
 617   WRITESHORT(RTG_X2, w);
 618   WRITESHORT(RTG_X3, p->XOffset);
 619   WRITESHORT(RTG_Y1, y);
 620   WRITESHORT(RTG_Y2, h);
 621   WRITESHORT(RTG_Y3, p->YOffset);
 622
 623   if ((unsigned long)p->Memory > CHIP_RAM_SIZE) {
 624     WRITELONG(RTG_ADDR1, (unsigned long)p->Memory);
 625   }
 626   else {
 627     unsigned long dest = CARD_SCRATCH;
 628     memcpy((unsigned char *)dest, p->Memory, (2 * (1 << p->Size)));
 629     WRITELONG(RTG_ADDR1, (unsigned long)dest);
 630   }
 631
 632   WRITELONG(RTG_RGB1, p->FgPen);
 633   WRITELONG(RTG_RGB2, p->BgPen);
 634
 635   WRITESHORT(RTG_X4, r->BytesPerRow);
 636   WRITESHORT(RTG_X5, (1 << p->Size));
 637
 638   WRITEBYTE(RTG_U81, mask);
 639   WRITEBYTE(RTG_U82, p->DrawMode);
 640   WRITEBYTE(RTG_U83, (1 << p->Size));
 641   WRITESHORT(RTG_COMMAND, RTGCMD_BLITPATTERN);
 642 }
 643
 644 void DrawLine (__REGA0(struct BoardInfo *b), __REGA1(struct RenderInfo *r), __REGA2(struct Line *l), __REGD0(UBYTE mask), __REGD7(RGBFTYPE format)) {
 645   if (!r || !b) return;
 646
 647   WRITELONG(RTG_ADDR1, (unsigned long)r->Memory);
 648
 649   WRITELONG(RTG_RGB1, l->FgPen);
 650   WRITELONG(RTG_RGB2, l->BgPen);
 651
 652   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
 653
 654   WRITESHORT(RTG_X1, l->X);
 655   WRITESHORT(RTG_X2, l->dX);
 656   WRITESHORT(RTG_Y1, l->Y);
 657   WRITESHORT(RTG_Y2, l->dY);
 658
 659   WRITESHORT(RTG_X3, l->Length);
 660   WRITESHORT(RTG_Y3, l->LinePtrn);
 661
 662   WRITESHORT(RTG_X4, r->BytesPerRow);
 663   WRITESHORT(RTG_X5, l->PatternShift);
 664
 665   WRITEBYTE(RTG_U81, mask);
 666   WRITEBYTE(RTG_U82, l->DrawMode);
 667   WRITEBYTE(RTG_U83, l->pad);
 668
 669   WRITESHORT(RTG_COMMAND, RTGCMD_DRAWLINE);
 670 }
 671
 672 void BlitPlanar2Chunky (__REGA0(struct BoardInfo *b), __REGA1(struct BitMap *bm), __REGA2(struct RenderInfo *r), __REGD0(SHORT x), __REGD1(SHORT y), __REGD2(SHORT dx), __REGD3(SHORT dy), __REGD4(SHORT w), __REGD5(SHORT h), __REGD6(UBYTE minterm), __REGD7(UBYTE mask)) {
 673   if (!b || !r)
 674     return;
 675
 676   uint32_t plane_size = bm->BytesPerRow * bm->Rows;
 677
 678   uint32_t template_addr = CARD_SCRATCH;
 679
 680   uint16_t plane_mask = mask;
 681   uint8_t ff_mask = 0x00;
 682   uint8_t cur_plane = 0x01;
 683
 684   uint16_t line_size = (w >> 3) + 2;
 685   uint32_t output_plane_size = line_size * h;
 686   uint16_t x_offset = (x >> 3);
 687
 688   WRITELONG(RTG_ADDR1, (unsigned long)r->Memory);
 689   WRITELONG(RTG_ADDR2, template_addr);
 690   WRITESHORT(RTG_X4, r->BytesPerRow);
 691   WRITESHORT(RTG_X5, line_size);
 692   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[r->RGBFormat]);
 693
 694   WRITEBYTE(RTG_U81, mask);
 695   WRITEBYTE(RTG_U82, minterm);
 696
 697   for (int16_t i = 0; i < bm->Depth; i++) {
 698     uint16_t x_offset = (x >> 3);
 699     if ((uint32_t)bm->Planes[i] == 0xFFFFFFFF) {
 700       uint8_t* dest = (uint8_t*)((uint32_t)template_addr);
 701       memset(dest, 0xFF, output_plane_size);
 702     }
 703     else if (bm->Planes[i] != NULL) {
 704       uint8_t* bmp_mem = (uint8_t*)bm->Planes[i] + (y * bm->BytesPerRow) + x_offset;
 705       uint8_t* dest = (uint8_t*)((uint32_t)template_addr);
 706       for (int16_t y_line = 0; y_line < h; y_line++) {
 707         memcpy(dest, bmp_mem, line_size);
 708         dest += line_size;
 709         bmp_mem += bm->BytesPerRow;
 710       }
 711     }
 712     else {
 713       plane_mask &= (cur_plane ^ 0xFF);
 714     }
 715     cur_plane <<= 1;
 716     template_addr += output_plane_size;
 717   }
 718
 719   WRITESHORT(RTG_X1, (x & 0x07));
 720   WRITESHORT(RTG_X2, dx);
 721   WRITESHORT(RTG_X3, w);
 722   WRITESHORT(RTG_Y1, 0);
 723   WRITESHORT(RTG_Y2, dy);
 724   WRITESHORT(RTG_Y3, h);
 725
 726   WRITESHORT(RTG_U1, (plane_mask << 8 | ff_mask));
 727   WRITEBYTE(RTG_U83, bm->Depth);
 728
 729   WRITESHORT(RTG_COMMAND, RTGCMD_P2C);
 730 }
 731
 732 void BlitPlanar2Direct (__REGA0(struct BoardInfo *b), __REGA1(struct BitMap *bm), __REGA2(struct RenderInfo *r), __REGA3(struct ColorIndexMapping *clut), __REGD0(SHORT x), __REGD1(SHORT y), __REGD2(SHORT dx), __REGD3(SHORT dy), __REGD4(SHORT w), __REGD5(SHORT h), __REGD6(UBYTE minterm), __REGD7(UBYTE mask)) {
 733   if (!b || !r)
 734     return;
 735
 736   uint32_t plane_size = bm->BytesPerRow * bm->Rows;
 737
 738   uint32_t template_addr = CARD_SCRATCH;
 739
 740   uint16_t plane_mask = mask;
 741   uint8_t ff_mask = 0x00;
 742   uint8_t cur_plane = 0x01;
 743
 744   uint16_t line_size = (w >> 3) + 2;
 745   uint32_t output_plane_size = line_size * h;
 746   uint16_t x_offset = (x >> 3);
 747
 748   WRITELONG(RTG_ADDR1, (unsigned long)r->Memory);
 749   WRITELONG(RTG_ADDR2, template_addr);
 750   WRITESHORT(RTG_X4, r->BytesPerRow);
 751   WRITESHORT(RTG_X5, line_size);
 752   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[r->RGBFormat]);
 753
 754   WRITEBYTE(RTG_U81, mask);
 755   WRITEBYTE(RTG_U82, minterm);
 756
 757   memcpy((uint8_t*)((uint32_t)template_addr), clut->Colors, (256 << 2));
 758   template_addr += (256 << 2);
 759
 760   for (int16_t i = 0; i < bm->Depth; i++) {
 761     uint16_t x_offset = (x >> 3);
 762     if ((uint32_t)bm->Planes[i] == 0xFFFFFFFF) {
 763       uint8_t* dest = (uint8_t*)((uint32_t)template_addr);
 764       memset(dest, 0xFF, output_plane_size);
 765     }
 766     else if (bm->Planes[i] != NULL) {
 767       uint8_t* bmp_mem = (uint8_t*)bm->Planes[i] + (y * bm->BytesPerRow) + x_offset;
 768       uint8_t* dest = (uint8_t*)((uint32_t)template_addr);
 769       for (int16_t y_line = 0; y_line < h; y_line++) {
 770         memcpy(dest, bmp_mem, line_size);
 771         dest += line_size;
 772         bmp_mem += bm->BytesPerRow;
 773       }
 774     }
 775     else {
 776       plane_mask &= (cur_plane ^ 0xFF);
 777     }
 778     cur_plane <<= 1;
 779     template_addr += output_plane_size;
 780   }
 781
 782   WRITESHORT(RTG_X1, (x & 0x07));
 783   WRITESHORT(RTG_X2, dx);
 784   WRITESHORT(RTG_X3, w);
 785   WRITESHORT(RTG_Y1, 0);
 786   WRITESHORT(RTG_Y2, dy);
 787   WRITESHORT(RTG_Y3, h);
 788
 789   WRITESHORT(RTG_U1, (plane_mask << 8 | ff_mask));
 790   WRITEBYTE(RTG_U83, bm->Depth);
 791
 792   WRITESHORT(RTG_COMMAND, RTGCMD_P2D);
 793 }
 794
 795 void SetSprite (__REGA0(struct BoardInfo *b), __REGD0(BOOL what), __REGD7(RGBFTYPE format)) {
 796   WRITESHORT(RTG_COMMAND, RTGCMD_SETSPRITE);
 797 }
 798
 799 void SetSpritePosition (__REGA0(struct BoardInfo *b), __REGD0(WORD x), __REGD1(WORD y), __REGD7(RGBFTYPE format)) {
 800   WRITESHORT(RTG_X1, x);
 801   WRITESHORT(RTG_Y1, y);
 802
 803   WRITESHORT(RTG_COMMAND, RTGCMD_SETSPRITEPOS);
 804 }
 805
 806 void SetSpriteImage (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format)) {
 807   WRITESHORT(RTG_X1, b->XOffset);
 808   WRITESHORT(RTG_Y1, b->YOffset);
 809   WRITEBYTE(RTG_U81, b->MouseWidth);
 810   WRITEBYTE(RTG_U82, b->MouseHeight);
 811
 812   uint8_t* dest = (uint8_t*)((uint32_t)CARD_SCRATCH);
 813   uint8_t* src = (uint8_t *)b->MouseImage;
 814   uint16_t data_size = ((b->MouseWidth >> 3) * 2) * (b->MouseHeight);
 815
 816   if (b->MouseWidth > 16) src += 8;
 817   else src += 4;
 818
 819   memcpy(dest, src, data_size);
 820
 821   WRITELONG(RTG_ADDR2, CARD_SCRATCH);
 822
 823   WRITESHORT(RTG_COMMAND, RTGCMD_SETSPRITEIMAGE);
 824 }
 825
 826 void SetSpriteColor (__REGA0(struct BoardInfo *b), __REGD0(UBYTE idx), __REGD1(UBYTE R), __REGD2(UBYTE G), __REGD3(UBYTE B), __REGD7(RGBFTYPE format)) {
 827   WRITEBYTE(RTG_U81, R);
 828   WRITEBYTE(RTG_U82, G);
 829   WRITEBYTE(RTG_U83, B);
 830   WRITEBYTE(RTG_U84, idx);
 831
 832   WRITESHORT(RTG_COMMAND, RTGCMD_SETSPRITECOLOR);
 833 }