workbench/hidds/nvidia/nv.h

   1 #ifndef _NV_H
   2 #define _NV_H
   3 /*
   4     Copyright © 2004-2017, The AROS Development Team. All rights reserved.
   5     $Id$
   6
   7     Desc: private header file
   8     Lang: English
   9 */
  10
  11 #include <exec/types.h>
  12 #include <exec/libraries.h>
  13 #include <exec/semaphores.h>
  14 #include <exec/nodes.h>
  15 #include <exec/execbase.h>
  16 #include <exec/memory.h>
  17
  18 #include <dos/bptr.h>
  19
  20 #include <oop/oop.h>
  21
  22 #include <hidd/pci.h>
  23 #include <hidd/gfx.h>
  24
  25 #include "nv_local.h"
  26 #include "riva_hw.h"
  27
  28 #define IID_Hidd_Gfx_nVidia     "hidd.gfx.nv"
  29 #define CLID_Hidd_Gfx_nVidia    "hidd.gfx.nv"
  30
  31 #define IID_Hidd_nvBitMap       "hidd.bitmap.nv"
  32
  33 enum {
  34     aoHidd_nvBitMap_Drawable,
  35
  36     num_Hidd_nvBitMap_Attrs
  37 };
  38
  39 #define aHidd_nvBitMap_Drawable (HiddNVidiaBitMapAttrBase + aoHidd_nvBitMap_Drawable)
  40
  41 #define IS_BM_ATTR(attr, idx) (((idx)=(attr)-HiddBitMapAttrBase) < num_Hidd_BitMap_Attrs)
  42 #define IS_NVBM_ATTR(attr, idx) (((idx)=(attr)-HiddNVidiaBitMapAttrBase) < num_Hidd_nvBitMap_Attrs)
  43
  44 typedef enum {
  45     NV04 = 0,   NV05,   NV05M64,    NV06,   NV10,
  46     NV11,       NV11M,  NV15,       NV17,   NV17M,
  47     NV18,       NV18M,  NV20,       NV25,   NV28,
  48     NV30,       NV31,   NV34,       NV35,   NV36,
  49     NV43,
  50
  51     CardType_Sizeof
  52 } CardType;
  53
  54 typedef struct _sync {
  55     ULONG pixelc;
  56     ULONG flags;
  57     ULONG HDisplay, HSyncStart, HSyncEnd, HTotal;
  58     ULONG VDisplay, VSyncStart, VSyncEnd, VTotal;
  59 } Sync;
  60
  61 typedef struct CardState {
  62     ULONG   bpp;
  63     ULONG   bitsPerPixel;
  64     ULONG   width;
  65     ULONG   height;
  66     ULONG   interlace;
  67     ULONG   repaint0;
  68     ULONG   repaint1;
  69     ULONG   screen;
  70     ULONG   scale;
  71     ULONG   dither;
  72     ULONG   extra;
  73     ULONG   fifo;
  74     ULONG   pixel;
  75     ULONG   horiz;
  76     ULONG   arbitration0;
  77     ULONG   arbitration1;
  78     ULONG   vpll;
  79     ULONG   vpll2;
  80     ULONG   vpllB;
  81     ULONG   vpll2B;
  82     ULONG   pllsel;
  83     ULONG   general;
  84     ULONG   crtcOwner;
  85     ULONG   head;
  86     ULONG   head2;
  87     ULONG   config;
  88     ULONG   cursorConfig;
  89     ULONG   cursor0;
  90     ULONG   cursor1;
  91     ULONG   cursor2;
  92     ULONG   offset;
  93     ULONG   pitch;
  94     ULONG   pll;
  95     ULONG   pllB;
  96     ULONG   timingH;
  97     ULONG   timingV;
  98     ULONG   displayV;
  99     struct {
 100         UBYTE   attr[0x15];
 101         UBYTE   crtc[0x41];
 102         UBYTE   gra[0x09];
 103         UBYTE   seq[0x05];
 104         UBYTE   dac[256*3];
 105         UBYTE   misc;
 106     } Regs;
 107 } RIVA_HW_STATE;
 108
 109 struct staticdata;
 110
 111 typedef struct Card {
 112     UWORD           VendorID;
 113     UWORD           ProductID;
 114     APTR            FbAddress;
 115     UBYTE           *FrameBuffer;
 116     ULONG           FrameBufferSize;
 117     ULONG           FbUsableSize;
 118     APTR            Registers;
 119     CardType        Type;
 120     BOOL            FlatPanel;
 121     BOOL            paletteEnabled;
 122
 123     UWORD           Architecture;
 124     UWORD           Chipset;        /* == ProductID */
 125     ULONG           CrystalFreqKHz;
 126     ULONG           RamAmountKBytes;
 127     ULONG           MaxVClockFreqKHz;
 128     ULONG           MinVClockFreqKHz;
 129     ULONG           RamBandwidthKBytesPerSec;
 130     ULONG           EnableIRQ;
 131     ULONG           IO;
 132     ULONG           VBlankBit;
 133     ULONG           FifoFreeCount;
 134     ULONG           FifoEmptyCount;
 135     ULONG           CursorStart;
 136     ULONG           flatPanel;
 137     ULONG           CRTCnumber;
 138     ULONG           Television;
 139     ULONG           fpWidth;
 140     ULONG           fpHeight;
 141     BOOL            twoHeads;
 142     BOOL            twoStagePLL;
 143     BOOL            fpScaler;
 144     BOOL            alphaCursor;
 145     ULONG           cursorVisible;
 146
 147     ULONG           dmaPut;
 148     ULONG           dmaCurrent;
 149     ULONG           dmaFree;
 150     ULONG           dmaMax;
 151     ULONG           *dmaBase;
 152
 153     ULONG           currentROP;
 154
 155     volatile ULONG      *PCRTC0;
 156     volatile ULONG      *PCRTC;
 157     volatile ULONG      *PRAMDAC0;
 158     volatile ULONG      *PFB;
 159     volatile ULONG      *PFIFO;
 160     volatile ULONG      *PGRAPH;
 161     volatile ULONG      *PEXTDEV;
 162     volatile ULONG      *PTIMER;
 163     volatile ULONG      *PMC;
 164     volatile ULONG      *PRAMIN;
 165     volatile ULONG      *FIFO;
 166     volatile ULONG      *CURSOR;
 167     volatile UBYTE      *PCIO0;
 168     volatile UBYTE      *PCIO;
 169     volatile UBYTE      *PVIO;
 170     volatile UBYTE      *PDIO0;
 171     volatile UBYTE      *PDIO;
 172     volatile ULONG      *PRAMDAC;
 173
 174     struct CardState    *CurrentState;
 175
 176     void        (*DMAKickoffCallback)(struct staticdata *sd);
 177 } RIVA_HW_INST, *NVPtr;
 178
 179 struct staticdata {
 180     struct MemHeader        *CardMem;
 181
 182     struct SignalSemaphore  HWLock;         /* Hardware exclusive semaphore */
 183     struct SignalSemaphore  MultiBMLock;    /* To lock more than one bitmap at a time */
 184     APTR                    memPool;
 185
 186     OOP_Class               *basebm;            /* baseclass for CreateObject */
 187
 188     OOP_Class               *nvclass;
 189     OOP_Class               *onbmclass;
 190     OOP_Class               *offbmclass;
 191     OOP_Class               *planarbmclass;
 192
 193     OOP_Object              *pci;
 194     OOP_Object              *Device;
 195     OOP_Object              *nvobject;
 196     OOP_Object              *pcidriver;
 197
 198     OOP_AttrBase            pciAttrBase;
 199     OOP_AttrBase            bitMapAttrBase;
 200     OOP_AttrBase            nvBitMapAttrBase;
 201     OOP_AttrBase            pixFmtAttrBase;
 202     OOP_AttrBase            gfxAttrBase;
 203     OOP_AttrBase            syncAttrBase;
 204     OOP_AttrBase            planarAttrBase;
 205
 206     HIDDT_DPMSLevel         dpms;
 207
 208     struct CardState        *poweron_state;
 209
 210     struct Card             Card;
 211
 212     UWORD                   src_pitch, dst_pitch;
 213     ULONG                   src_offset, dst_offset;
 214     ULONG                   surface_format;
 215     ULONG                   pattern_format;
 216     ULONG                   rect_format;
 217     ULONG                   line_format;
 218
 219     OOP_MethodID            mid_ReadLong;
 220     OOP_MethodID            mid_CopyMemBox8;
 221     OOP_MethodID            mid_CopyMemBox16;
 222     OOP_MethodID            mid_CopyMemBox32;
 223     OOP_MethodID            mid_PutMem32Image8;
 224     OOP_MethodID            mid_PutMem32Image16;
 225     OOP_MethodID            mid_GetMem32Image8;
 226     OOP_MethodID            mid_GetMem32Image16;
 227     OOP_MethodID            mid_GetImage;
 228     OOP_MethodID            mid_Clear;
 229     OOP_MethodID            mid_PutMemTemplate8;
 230     OOP_MethodID            mid_PutMemTemplate16;
 231     OOP_MethodID            mid_PutMemTemplate32;
 232     OOP_MethodID            mid_PutMemPattern8;
 233     OOP_MethodID            mid_PutMemPattern16;
 234     OOP_MethodID            mid_PutMemPattern32;
 235     OOP_MethodID            mid_CopyLUTMemBox16;
 236     OOP_MethodID            mid_CopyLUTMemBox32;
 237
 238     BOOL                    gpu_busy;
 239
 240     IPTR                    scratch_buffer;
 241 };
 242
 243 typedef struct __bm {
 244     struct SignalSemaphore bmLock;
 245
 246     OOP_Object  *BitMap;        // BitMap OOP Object
 247     IPTR        framebuffer;    // Points to pixel data
 248     ULONG       width;          // Bitmap width
 249     ULONG       height;         // Bitmap height
 250     ULONG       pitch;          // BytesPerRow aligned
 251     UBYTE       depth;          // Bitmap depth
 252     UBYTE       bpp;            // BytesPerPixel
 253     UBYTE       onbm;           // is onbitmap?
 254     UBYTE       fbgfx;          // is framebuffer in gfx memory
 255     ULONG       usecount;       // counts BitMap accesses
 256
 257     ULONG       surface_format;
 258     ULONG       pattern_format;
 259     ULONG       rect_format;
 260     ULONG       line_format;
 261
 262     struct CardState *state;
 263 } nvBitMap;
 264
 265 struct planarbm_data
 266 {
 267     UBYTE   **planes;
 268     ULONG   planebuf_size;
 269     ULONG   bytesperrow;
 270     ULONG   rows;
 271     UBYTE   depth;
 272     BOOL    planes_alloced;
 273 };
 274
 275 #define LOCK_HW              { ObtainSemaphore(&_sd->HWLock); }
 276 #define UNLOCK_HW            { ReleaseSemaphore(&_sd->HWLock); }
 277
 278 #define LOCK_BITMAP          { ObtainSemaphore(&bm->bmLock); }
 279 #define UNLOCK_BITMAP        { ReleaseSemaphore(&bm->bmLock); }
 280
 281 #define LOCK_BITMAP_BM(bm)   { ObtainSemaphore(&(bm)->bmLock); }
 282 #define UNLOCK_BITMAP_BM(bm) { ReleaseSemaphore(&(bm)->bmLock); }
 283
 284 #define LOCK_MULTI_BITMAP    { ObtainSemaphore(&_sd->MultiBMLock); }
 285 #define UNLOCK_MULTI_BITMAP  { ReleaseSemaphore(&_sd->MultiBMLock); }
 286
 287 #include LC_LIBDEFS_FILE
 288
 289 LIBBASETYPE {
 290     struct Library      LibNode;
 291     APTR                memPool;
 292     struct staticdata   sd;
 293     struct MemHeader    mh;
 294 };
 295
 296 #define V_DBLSCAN   0x01
 297 #define V_LACE      0x02
 298
 299 void LoadState(struct staticdata *, struct CardState *);
 300 void SaveState(struct staticdata *, struct CardState *);
 301 void DPMS(struct staticdata *, HIDDT_DPMSLevel);
 302 void InitMode(struct staticdata *sd, struct CardState *,
 303     ULONG width, ULONG height, UBYTE bpp, ULONG pixelc, ULONG base,
 304     ULONG HDisplay, ULONG VDisplay,
 305     ULONG HSyncStart, ULONG HSyncEnd, ULONG HTotal,
 306     ULONG VSyncStart, ULONG VSyncEnd, ULONG VTotal);
 307 void acc_test(struct staticdata *);
 308
 309
 310 void NVLockUnlock(struct staticdata *, UBYTE);
 311 int NVShowHideCursor (struct staticdata *, UBYTE);
 312 void NVDmaKickoff(struct Card *);
 313 void NVDmaWait(struct Card *, int);
 314 void NVSync(struct staticdata *);
 315 void NVDMAKickoffCallback(struct staticdata *);
 316 void NVSetPattern(struct staticdata *, ULONG, ULONG, ULONG, ULONG);
 317 void NVSetRopSolid(struct staticdata *, ULONG, ULONG);
 318 void NVSelectHead(struct staticdata *sd, UBYTE head);
 319 BOOL NVIsConnected (struct staticdata *sd, UBYTE output);
 320
 321 void nv4GetConfig(struct staticdata *);
 322 void nv10GetConfig(struct staticdata *);
 323 IPTR AllocBitmapArea(struct staticdata *, ULONG, ULONG, ULONG, BOOL);
 324 VOID FreeBitmapArea(struct staticdata *, IPTR, ULONG, ULONG, ULONG);
 325
 326 #define NVDmaNext(pNv, data) \
 327      (pNv)->dmaBase[(pNv)->dmaCurrent++] = (data)
 328
 329 #define NVDmaStart(pNv, tag, size) {          \
 330      if((pNv)->dmaFree <= (size))             \
 331         NVDmaWait(pNv, size);                 \
 332      NVDmaNext(pNv, ((size) << 18) | (tag));  \
 333      (pNv)->dmaFree -= ((size) + 1);          \
 334 }
 335
 336 //#if defined(__i386__)
 337 //#define _NV_FENCE() asm volatile ("outb %0,%w1"::"a"(0),"Nd"(0x3d0));
 338 //#else
 339 #define _NV_FENCE() /* eps */
 340 //#endif
 341
 342 #define WRITE_PUT(pNv, data) {       \
 343   volatile UBYTE scratch;            \
 344   _NV_FENCE()                        \
 345   scratch = (pNv)->FrameBuffer[0];       \
 346   (void)scratch; /* unused */        \
 347   (pNv)->FIFO[0x0010] = (data) << 2; \
 348   mem_barrier();                     \
 349 }
 350
 351 #define READ_GET(pNv) ((pNv)->FIFO[0x0011] >> 2)
 352
 353 #endif // _NV_H
 354