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 <stdio.h>
  17 #include "boardinfo.h"
  18
  19 #define WRITESHORT(cmd, val) *(unsigned short *)((unsigned long)(b->RegisterBase)+cmd) = val;
  20 #define WRITELONG(cmd, val) *(unsigned long *)((unsigned long)(b->RegisterBase)+cmd) = val;
  21 #define WRITEBYTE(cmd, val) *(unsigned char *)((unsigned long)(b->RegisterBase)+cmd) = val;
  22
  23 #define CARD_OFFSET  0x70000000
  24 #define CARD_REGSIZE 0x00010000
  25 // 32MB "VRAM"
  26 #define CARD_MEMSIZE 0x02000000
  27
  28 // "Register" offsets for sending data to the RTG.
  29 enum pi_regs {
  30   RTG_COMMAND = 0x00,
  31   RTG_X1      = 0x02,
  32   RTG_X2      = 0x04,
  33   RTG_X3      = 0x06,
  34   RTG_Y1      = 0x08,
  35   RTG_Y2      = 0x0A,
  36   RTG_Y3      = 0x0C,
  37   RTG_FORMAT  = 0x0E,
  38   RTG_RGB1    = 0x10,
  39   RTG_RGB2    = 0x14,
  40   RTG_ADDR1   = 0x18,
  41   RTG_ADDR2   = 0x1C,
  42   RTG_U81     = 0x20,
  43   RTG_U82     = 0x21,
  44   RTG_U83     = 0x22,
  45   RTG_U84     = 0x23,
  46   RTG_X4      = 0x24,
  47   RTG_X5      = 0x26,
  48   RTG_Y4      = 0x28,
  49   RTG_Y5      = 0x2A,
  50   RTG_U1      = 0x2C,
  51   RTG_U2      = 0x2E,
  52 };
  53
  54 enum rtg_cmds {
  55   RTGCMD_SETGC,
  56   RTGCMD_SETPAN,
  57   RTGCMD_SETCLUT,
  58   RTGCMD_ENABLE,
  59   RTGCMD_SETDISPLAY,
  60   RTGCMD_SETSWITCH,
  61   RTGCMD_FILLRECT,
  62   RTGCMD_BLITRECT,
  63 };
  64
  65 enum rtg_formats {
  66   RTGFMT_8BIT,
  67   RTGFMT_RBG565,
  68   RTGFMT_RGB32,
  69   RTGFMT_RGB555,
  70 };
  71
  72 const unsigned short rgbf_to_rtg[16] = {
  73   RTGFMT_8BIT,      // 0x00
  74   RTGFMT_8BIT,      // 0x01
  75   0,                // 0x02
  76   0,                // 0x03
  77   0,                // 0x04
  78   RTGFMT_RGB555,    // 0x05
  79   0,                // 0x06
  80   0,                // 0x07
  81   RTGFMT_RGB32,     // 0x08
  82   RTGFMT_RGB32,     // 0x09
  83   RTGFMT_RBG565,    // 0x0A
  84   RTGFMT_RGB555,    // 0x0B
  85   0,                // 0x0C
  86   RTGFMT_RGB555,    // 0x0D
  87   0,                // 0x0E
  88   0,                // 0x0F
  89 };
  90
  91 struct GFXBase {
  92   struct Library libNode;
  93   BPTR segList;
  94   struct ExecBase* sysBase;
  95   struct ExpansionBase* expansionBase;
  96 };
  97
  98 int FindCard(__REGA0(struct BoardInfo* b));
  99 int InitCard(__REGA0(struct BoardInfo* b));
 100
 101 void SetDAC (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format));
 102 void SetGC (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(BOOL border));
 103 void SetColorArray (__REGA0(struct BoardInfo *b), __REGD0(UWORD start), __REGD1(UWORD num));
 104 void SetPanning (__REGA0(struct BoardInfo *b), __REGA1(UBYTE *addr), __REGD0(UWORD width), __REGD1(WORD x_offset), __REGD2(WORD y_offset), __REGD7(RGBFTYPE format));
 105 UWORD SetSwitch (__REGA0(struct BoardInfo *b), __REGD0(UWORD enabled));
 106 UWORD SetDisplay (__REGA0(struct BoardInfo *b), __REGD0(UWORD enabled));
 107
 108 UWORD CalculateBytesPerRow (__REGA0(struct BoardInfo *b), __REGD0(UWORD width), __REGD7(RGBFTYPE format));
 109 APTR CalculateMemory (__REGA0(struct BoardInfo *b), __REGA1(unsigned long addr), __REGD7(RGBFTYPE format));
 110 ULONG GetCompatibleFormats (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format));
 111
 112 LONG ResolvePixelClock (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(ULONG pixel_clock), __REGD7(RGBFTYPE format));
 113 ULONG GetPixelClock (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(ULONG index), __REGD7(RGBFTYPE format));
 114 void SetClock (__REGA0(struct BoardInfo *b));
 115
 116 void SetMemoryMode (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format));
 117 void SetWriteMask (__REGA0(struct BoardInfo *b), __REGD0(UBYTE mask));
 118 void SetClearMask (__REGA0(struct BoardInfo *b), __REGD0(UBYTE mask));
 119 void SetReadPlane (__REGA0(struct BoardInfo *b), __REGD0(UBYTE plane));
 120
 121 void WaitVerticalSync (__REGA0(struct BoardInfo *b), __REGD0(BOOL toggle));
 122
 123 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));
 124 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));
 125
 126 static ULONG LibStart(void) {
 127   return(-1);
 128 }
 129
 130 static const char LibraryName[] = "PiRTG.card";
 131 static const char LibraryID[]   = "$VER: PiRTG.card 0.01\r\n";
 132
 133 __saveds struct GFXBase* OpenLib(__REGA6(struct GFXBase *gfxbase));
 134 BPTR __saveds CloseLib(__REGA6(struct GFXBase *gfxbase));
 135 BPTR __saveds ExpungeLib(__REGA6(struct GFXBase *exb));
 136 ULONG ExtFuncLib(void);
 137 __saveds struct GFXBase* InitLib(__REGA6(struct ExecBase *sysbase),
 138                                  __REGA0(BPTR seglist),
 139                                  __REGD0(struct GFXBase *exb));
 140
 141 static const APTR FuncTab[] = {
 142   (APTR)OpenLib,
 143   (APTR)CloseLib,
 144   (APTR)ExpungeLib,
 145   (APTR)ExtFuncLib,
 146
 147   (APTR)FindCard,
 148   (APTR)InitCard,
 149   (APTR)((LONG)-1)
 150 };
 151
 152 struct InitTable
 153 {
 154   ULONG LibBaseSize;
 155   APTR  FunctionTable;
 156   APTR  DataTable;
 157   APTR  InitLibTable;
 158 };
 159
 160 static struct InitTable InitTab = {
 161   (ULONG) sizeof(struct GFXBase),
 162   (APTR) FuncTab,
 163   (APTR) NULL,
 164   (APTR) InitLib
 165 };
 166
 167 static const struct Resident ROMTag = {
 168         RTC_MATCHWORD,
 169   &ROMTag,
 170   &ROMTag + 1,
 171   RTF_AUTOINIT,
 172         83,
 173   NT_LIBRARY,
 174   0,
 175   (char *)LibraryName,
 176   (char *)LibraryID,
 177   (APTR)&InitTab
 178 };
 179
 180 #define CLOCK_HZ 100000000
 181
 182 static struct GFXBase *_gfxbase;
 183 const char *gfxname = "PiStorm RTG";
 184 char dummies[128];
 185
 186 __saveds struct GFXBase* InitLib(__REGA6(struct ExecBase *sysbase),
 187                                           __REGA0(BPTR seglist),
 188                                           __REGD0(struct GFXBase *exb))
 189 {
 190   _gfxbase = exb;
 191   return _gfxbase;
 192 }
 193
 194 __saveds struct GFXBase* OpenLib(__REGA6(struct GFXBase *gfxbase))
 195 {
 196   gfxbase->libNode.lib_OpenCnt++;
 197   gfxbase->libNode.lib_Flags &= ~LIBF_DELEXP;
 198
 199   return gfxbase;
 200 }
 201
 202 BPTR __saveds CloseLib(__REGA6(struct GFXBase *gfxbase))
 203 {
 204   gfxbase->libNode.lib_OpenCnt--;
 205
 206   if (!gfxbase->libNode.lib_OpenCnt) {
 207     if (gfxbase->libNode.lib_Flags & LIBF_DELEXP) {
 208       return (ExpungeLib(gfxbase));
 209     }
 210   }
 211   return 0;
 212 }
 213
 214 BPTR __saveds ExpungeLib(__REGA6(struct GFXBase *exb))
 215 {
 216   BPTR seglist;
 217   struct ExecBase *SysBase = *(struct ExecBase **)4L;
 218
 219   if(!exb->libNode.lib_OpenCnt) {
 220     ULONG negsize, possize, fullsize;
 221     UBYTE *negptr = (UBYTE *)exb;
 222
 223     seglist = exb->segList;
 224
 225     Remove((struct Node *)exb);
 226
 227     negsize  = exb->libNode.lib_NegSize;
 228     possize  = exb->libNode.lib_PosSize;
 229     fullsize = negsize + possize;
 230     negptr  -= negsize;
 231
 232     FreeMem(negptr, fullsize);
 233     return(seglist);
 234   }
 235
 236   exb->libNode.lib_Flags |= LIBF_DELEXP;
 237   return 0;
 238 }
 239
 240 ULONG ExtFuncLib(void)
 241 {
 242   return 0;
 243 }
 244
 245 static LONG zorro_version = 0;
 246
 247 static struct GFXData *gfxdata;
 248 //MNTZZ9KRegs* registers;
 249
 250 #define LOADLIB(a, b) if ((a = (struct a*)OpenLibrary(b,0L))==NULL) { \
 251     KPrintF("Failed to load %s.\n", b); \
 252     return 0; \
 253   } \
 254
 255 static BYTE card_already_found;
 256 static BYTE card_initialized;
 257
 258 int FindCard(__REGA0(struct BoardInfo* b)) {
 259   //if (card_already_found)
 260 //    return 1;
 261   struct ConfigDev* cd = NULL;
 262   struct ExpansionBase *ExpansionBase = NULL;
 263   struct DOSBase *DOSBase = NULL;
 264   struct IntuitionBase *IntuitionBase = NULL;
 265   struct ExecBase *SysBase = *(struct ExecBase **)4L;
 266
 267   LOADLIB(ExpansionBase, "expansion.library");
 268   LOADLIB(DOSBase, "dos.library");
 269   LOADLIB(IntuitionBase, "intuition.library");
 270
 271   b->MemorySize = CARD_MEMSIZE;
 272   b->RegisterBase = (void *)CARD_OFFSET;
 273   b->MemoryBase = (void *)(CARD_OFFSET + CARD_REGSIZE);
 274
 275   return 1;
 276 }
 277
 278 #define HWSPRITE 1
 279 #define VGASPLIT (1 << 6)
 280 #define FLICKERFIXER (1 << 12)
 281 #define INDISPLAYCHAIN (1 << 20)
 282 #define DIRECTACCESS (1 << 26)
 283
 284 int InitCard(__REGA0(struct BoardInfo* b)) {
 285   //if (!card_initialized)
 286 //    card_initialized = 1;
 287 //  else
 288     //return 1;
 289
 290   int max, i;
 291   struct ExecBase *SysBase = *(struct ExecBase **)4L;
 292
 293   b->CardBase = (struct CardBase *)_gfxbase;
 294   b->ExecBase = SysBase;
 295   b->BoardName = "PiStorm RTG";
 296   b->BoardType = BT_MNT_ZZ9000;
 297   b->PaletteChipType = PCT_MNT_ZZ9000;
 298   b->GraphicsControllerType = GCT_MNT_ZZ9000;
 299
 300   b->Flags = BIF_INDISPLAYCHAIN | BIF_GRANTDIRECTACCESS;
 301   b->RGBFormats = 1 | 2 | 512 | 1024 | 2048;
 302   b->SoftSpriteFlags = 0;
 303   b->BitsPerCannon = 8;
 304
 305   for(i = 0; i < MAXMODES; i++) {
 306     b->MaxHorValue[i] = 1920;
 307     b->MaxVerValue[i] = 1080;
 308     b->MaxHorResolution[i] = 1920;
 309     b->MaxVerResolution[i] = 1080;
 310     b->PixelClockCount[i] = 1;
 311   }
 312
 313   b->MemoryClock = CLOCK_HZ;
 314
 315   //b->AllocCardMem = (void *)NULL;
 316   //b->FreeCardMem = (void *)NULL;
 317   b->SetSwitch = (void *)SetSwitch;
 318   b->SetColorArray = (void *)SetColorArray;
 319   b->SetDAC = (void *)SetDAC;
 320   b->SetGC = (void *)SetGC;
 321   b->SetPanning = (void *)SetPanning;
 322   b->CalculateBytesPerRow = (void *)CalculateBytesPerRow;
 323   b->CalculateMemory = (void *)CalculateMemory;
 324   b->GetCompatibleFormats = (void *)GetCompatibleFormats;
 325   b->SetDisplay = (void *)SetDisplay;
 326
 327   b->ResolvePixelClock = (void *)ResolvePixelClock;
 328   b->GetPixelClock = (void *)GetPixelClock;
 329   b->SetClock = (void *)SetClock;
 330
 331   b->SetMemoryMode = (void *)SetMemoryMode;
 332   b->SetWriteMask = (void *)SetWriteMask;
 333   b->SetClearMask = (void *)SetClearMask;
 334   b->SetReadPlane = (void *)SetReadPlane;
 335
 336   b->WaitVerticalSync = (void *)WaitVerticalSync;
 337   //b->SetInterrupt = (void *)NULL;
 338
 339   //b->WaitBlitter = (void *)NULL;
 340
 341   //b->ScrollPlanar = (void *)NULL;
 342   //b->UpdatePlanar = (void *)NULL;
 343
 344   //b->BlitPlanar2Chunky = (void *)NULL;
 345   //b->BlitPlanar2Direct = (void *)NULL;
 346
 347   b->FillRect = (void *)FillRect;
 348   //b->InvertRect = (void *)NULL;
 349   b->BlitRect = (void *)BlitRect;
 350   //b->BlitTemplate = (void *)NULL;
 351   //b->BlitPattern = (void *)NULL;
 352   //b->DrawLine = (void *)NULL;
 353   //b->BlitRectNoMaskComplete = (void *)NULL;
 354   //b->EnableSoftSprite = (void *)NULL;
 355
 356   //b->AllocCardMemAbs = (void *)NULL;
 357   //b->SetSplitPosition = (void *)NULL;
 358   //b->ReInitMemory = (void *)NULL;
 359   //b->WriteYUVRect = (void *)NULL;
 360   //b->GetVSyncState = (void *)NULL;
 361   //b->GetVBeamPos = (void *)NULL;
 362   //b->SetDPMSLevel = (void *)NULL;
 363   //b->ResetChip = (void *)NULL;
 364   //b->GetFeatureAttrs = (void *)NULL;
 365   //b->AllocBitMap = (void *)NULL;
 366   //b->FreeBitMap = (void *)NULL;
 367   //b->GetBitMapAttr = (void *)NULL;
 368
 369   //b->SetSprite = (void *)NULL;
 370   //b->SetSpritePosition = (void *)NULL;
 371   //b->SetSpriteImage = (void *)NULL;
 372   //b->SetSpriteColor = (void *)NULL;
 373
 374   //b->CreateFeature = (void *)NULL;
 375   //b->SetFeatureAttrs = (void *)NULL;
 376   //b->DeleteFeature = (void *)NULL;
 377
 378   return 1;
 379 }
 380
 381 void SetDAC (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format)) {
 382   // Used to set the color format of the video card's RAMDAC.
 383   // This needs no handling, since the PiStorm doesn't really have a RAMDAC or a video card chipset.
 384 }
 385
 386 void SetGC (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(BOOL border)) {
 387   b->ModeInfo = mode_info;
 388   // Send width, height and format to the RaspberryPi Targetable Graphics.
 389   WRITESHORT(RTG_X1, mode_info->Width);
 390   WRITESHORT(RTG_Y1, mode_info->Height);
 391   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[b->RGBFormat]);
 392   WRITESHORT(RTG_COMMAND, RTGCMD_SETGC);
 393 }
 394
 395 int setswitch = -1;
 396 UWORD SetSwitch (__REGA0(struct BoardInfo *b), __REGD0(UWORD enabled)) {
 397   if (setswitch != enabled) {
 398     setswitch = enabled;
 399   }
 400
 401   WRITEBYTE(RTG_U81, setswitch);
 402   WRITESHORT(RTG_X1, setswitch);
 403   WRITESHORT(RTG_COMMAND, RTGCMD_SETSWITCH);
 404
 405   return 1 - enabled;
 406 }
 407
 408 void SetPanning (__REGA0(struct BoardInfo *b), __REGA1(UBYTE *addr), __REGD0(UWORD width), __REGD1(WORD x_offset), __REGD2(WORD y_offset), __REGD7(RGBFTYPE format)) {
 409   // Set the panning offset, or the offset used for the current display area on the Pi.
 410   // The address needs to have CARD_BASE subtracted from it to be used as an offset on the Pi side.
 411   if (!b)
 412     return;
 413
 414   b->XOffset = x_offset;
 415   b->YOffset = y_offset;
 416
 417   WRITELONG(RTG_ADDR1, (unsigned long)addr);
 418   WRITESHORT(RTG_X1, width);
 419   WRITESHORT(RTG_X2, b->XOffset);
 420   WRITESHORT(RTG_Y2, b->YOffset);
 421   WRITESHORT(RTG_COMMAND, RTGCMD_SETPAN);
 422 }
 423
 424 void SetColorArray (__REGA0(struct BoardInfo *b), __REGD0(UWORD start), __REGD1(UWORD num)) {
 425   // Sets the color components of X color components for 8-bit paletted display modes.
 426   if (!b->CLUT)
 427     return;
 428
 429   int j = start + num;
 430
 431   for(int i = start; i < j; i++) {
 432     //WRITEBYTE(RTG_U82, (unsigned char)b->CLUT[i].Red);
 433     //WRITEBYTE(RTG_U83, (unsigned char)b->CLUT[i].Green);
 434     //WRITEBYTE(RTG_U84, (unsigned char)b->CLUT[i].Blue);
 435     unsigned long xrgb = 0 | (b->CLUT[i].Red << 16) | (b->CLUT[i].Green << 8) | (b->CLUT[i].Blue);
 436     WRITEBYTE(RTG_U81, (unsigned char)i);
 437     WRITELONG(RTG_RGB1, xrgb);
 438     WRITESHORT(RTG_COMMAND, RTGCMD_SETCLUT);
 439   }
 440 }
 441
 442 UWORD CalculateBytesPerRow (__REGA0(struct BoardInfo *b), __REGD0(UWORD width), __REGD7(RGBFTYPE format)) {
 443   if (!b)
 444     return 0;
 445
 446   UWORD pitch = width;
 447
 448   switch(format) {
 449     default:
 450       return pitch;
 451     case 0x05: case 0x0A: case 0x0B: case 0x0D:
 452       return (width * 2);
 453     case 0x08: case 0x09:
 454       return (width * 4);
 455   }
 456 }
 457
 458 APTR CalculateMemory (__REGA0(struct BoardInfo *b), __REGA1(unsigned long addr), __REGD7(RGBFTYPE format)) {
 459   /*if (!b)
 460     return (APTR)addr;
 461
 462   if (addr > (unsigned int)b->MemoryBase && addr < (((unsigned int)b->MemoryBase) + b->MemorySize)) {
 463     addr = ((addr + 0x1000) & 0xFFFFF000);
 464   }*/
 465
 466   return (APTR)addr;
 467 }
 468
 469 ULONG GetCompatibleFormats (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format)) {
 470   // It is of course compatible with all the formats ever.
 471   return 0xFFFFFFFF;
 472 }
 473
 474 static int display_enabled = 0;
 475 UWORD SetDisplay (__REGA0(struct BoardInfo *b), __REGD0(UWORD enabled)) {
 476   // Enables or disables the display.
 477   WRITEBYTE(RTG_U82, (unsigned char)enabled);
 478   WRITESHORT(RTG_COMMAND, RTGCMD_SETDISPLAY);
 479
 480   return 1;
 481 }
 482
 483 LONG ResolvePixelClock (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(ULONG pixel_clock), __REGD7(RGBFTYPE format)) {
 484   mode_info->PixelClock = CLOCK_HZ;
 485   mode_info->pll1.Clock = 0;
 486   mode_info->pll2.ClockDivide = 1;
 487
 488   return 0;
 489 }
 490
 491 ULONG GetPixelClock (__REGA0(struct BoardInfo *b), __REGA1(struct ModeInfo *mode_info), __REGD0(ULONG index), __REGD7(RGBFTYPE format)) {
 492   // Just return 100MHz.
 493   return CLOCK_HZ;
 494 }
 495
 496 // None of these five really have to do anything.
 497 void SetClock (__REGA0(struct BoardInfo *b)) {
 498 }
 499
 500 void SetMemoryMode (__REGA0(struct BoardInfo *b), __REGD7(RGBFTYPE format)) {
 501 }
 502
 503 void SetWriteMask (__REGA0(struct BoardInfo *b), __REGD0(UBYTE mask)) {
 504 }
 505
 506 void SetClearMask (__REGA0(struct BoardInfo *b), __REGD0(UBYTE mask)) {
 507 }
 508
 509 void SetReadPlane (__REGA0(struct BoardInfo *b), __REGD0(UBYTE plane)) {
 510 }
 511
 512 void WaitVerticalSync (__REGA0(struct BoardInfo *b), __REGD0(BOOL toggle)) {
 513   // I don't know why this one has a bool in D0, but it isn't used for anything.
 514 }
 515
 516 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)) {
 517   if (!r)
 518     return;
 519   if (mask != 0xFF)
 520     b->FillRectDefault(b, r, x, y, w, h, color, mask, format);
 521
 522   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
 523   WRITESHORT(RTG_X1, x);
 524   WRITESHORT(RTG_X2, w);
 525   WRITESHORT(RTG_Y1, y);
 526   WRITESHORT(RTG_Y2, h);
 527   WRITELONG(RTG_RGB1, color);
 528   WRITESHORT(RTG_X3, r->BytesPerRow);
 529   WRITESHORT(RTG_COMMAND, RTGCMD_FILLRECT);
 530 }
 531
 532 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)) {
 533   if (!r)
 534     return;
 535   if (mask != 0xFF)
 536     b->BlitRectDefault(b, r, x, y, dx, dy, w, h, mask, format);
 537
 538   WRITESHORT(RTG_FORMAT, rgbf_to_rtg[format]);
 539   WRITESHORT(RTG_X1, x);
 540   WRITESHORT(RTG_X2, dx);
 541   WRITESHORT(RTG_X3, w);
 542   WRITESHORT(RTG_Y1, y);
 543   WRITESHORT(RTG_Y2, dy);
 544   WRITESHORT(RTG_Y3, h);
 545   WRITESHORT(RTG_X4, r->BytesPerRow);
 546   WRITESHORT(RTG_COMMAND, RTGCMD_BLITRECT);
 547 }