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