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