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

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