git.oblomov.eu Git - nouveau/blob - src/riva_hw.h

   1 /***************************************************************************\
   2 |*                                                                           *|
   3 |*       Copyright 1993-1999 NVIDIA, Corporation.  All rights reserved.      *|
   4 |*                                                                           *|
   5 |*     NOTICE TO USER:   The source code  is copyrighted under  U.S. and     *|
   6 |*     international laws.  Users and possessors of this source code are     *|
   7 |*     hereby granted a nonexclusive,  royalty-free copyright license to     *|
   8 |*     use this code in individual and commercial software.                  *|
   9 |*                                                                           *|
  10 |*     Any use of this source code must include,  in the user documenta-     *|
  11 |*     tion and  internal comments to the code,  notices to the end user     *|
  12 |*     as follows:                                                           *|
  13 |*                                                                           *|
  14 |*       Copyright 1993-1999 NVIDIA, Corporation.  All rights reserved.      *|
  15 |*                                                                           *|
  16 |*     NVIDIA, CORPORATION MAKES NO REPRESENTATION ABOUT THE SUITABILITY     *|
  17 |*     OF  THIS SOURCE  CODE  FOR ANY PURPOSE.  IT IS  PROVIDED  "AS IS"     *|
  18 |*     WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.  NVIDIA, CORPOR-     *|
  19 |*     ATION DISCLAIMS ALL WARRANTIES  WITH REGARD  TO THIS SOURCE CODE,     *|
  20 |*     INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGE-     *|
  21 |*     MENT,  AND FITNESS  FOR A PARTICULAR PURPOSE.   IN NO EVENT SHALL     *|
  22 |*     NVIDIA, CORPORATION  BE LIABLE FOR ANY SPECIAL,  INDIRECT,  INCI-     *|
  23 |*     DENTAL, OR CONSEQUENTIAL DAMAGES,  OR ANY DAMAGES  WHATSOEVER RE-     *|
  24 |*     SULTING FROM LOSS OF USE,  DATA OR PROFITS,  WHETHER IN AN ACTION     *|
  25 |*     OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  ARISING OUT OF     *|
  26 |*     OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOURCE CODE.     *|
  27 |*                                                                           *|
  28 |*     U.S. Government  End  Users.   This source code  is a "commercial     *|
  29 |*     item,"  as that  term is  defined at  48 C.F.R. 2.101 (OCT 1995),     *|
  30 |*     consisting  of "commercial  computer  software"  and  "commercial     *|
  31 |*     computer  software  documentation,"  as such  terms  are  used in     *|
  32 |*     48 C.F.R. 12.212 (SEPT 1995)  and is provided to the U.S. Govern-     *|
  33 |*     ment only as  a commercial end item.   Consistent with  48 C.F.R.     *|
  34 |*     12.212 and  48 C.F.R. 227.7202-1 through  227.7202-4 (JUNE 1995),     *|
  35 |*     all U.S. Government End Users  acquire the source code  with only     *|
  36 |*     those rights set forth herein.                                        *|
  37 |*                                                                           *|
  38 \***************************************************************************/
  39 /* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/nv/riva_hw.h,v 1.26 2003/07/31 20:24:31 mvojkovi Exp $ */
  40 #ifndef __RIVA_HW_H__
  41 #define __RIVA_HW_H__
  42
  43 /*
  44  * Define supported architectures.
  45  */
  46 /***************************************************************************\
  47 *                                                                           *
  48 *                             FIFO registers.                               *
  49 *                                                                           *
  50 \***************************************************************************/
  51
  52 /*
  53  * Raster OPeration. Windows style ROP3.
  54  */
  55 typedef volatile struct
  56 {
  57     CARD32 reserved00[4];
  58     CARD16 FifoFree;
  59     CARD16 Nop;
  60     CARD32 reserved01[0x0BB];
  61     CARD32 Rop3;
  62 } RivaRop;
  63 /*
  64  * 8X8 Monochrome pattern.
  65  */
  66 typedef volatile struct
  67 {
  68     CARD32 reserved00[4];
  69     CARD16 FifoFree;
  70     CARD16 Nop;
  71     CARD32 reserved01[0x0BD];
  72     CARD32 Shape;
  73     CARD32 reserved03[0x001];
  74     CARD32 Color0;
  75     CARD32 Color1;
  76     CARD32 Monochrome[2];
  77 } RivaPattern;
  78 /*
  79  * Scissor clip rectangle.
  80  */
  81 typedef volatile struct
  82 {
  83     CARD32 reserved00[4];
  84     CARD16 FifoFree;
  85     CARD16 Nop;
  86     CARD32 reserved01[0x0BB];
  87     CARD32 TopLeft;
  88     CARD32 WidthHeight;
  89 } RivaClip;
  90 /*
  91  * 2D filled rectangle.
  92  */
  93 typedef volatile struct
  94 {
  95     CARD32 reserved00[4];
  96     CARD16 FifoFree;
  97     CARD16 Nop[1];
  98     CARD32 reserved01[0x0BC];
  99     CARD32 Color;
 100     CARD32 reserved03[0x03E];
 101     CARD32 TopLeft;
 102     CARD32 WidthHeight;
 103 } RivaRectangle;
 104 /*
 105  * 2D screen-screen BLT.
 106  */
 107 typedef volatile struct
 108 {
 109     CARD32 reserved00[4];
 110     CARD16 FifoFree;
 111     CARD16 Nop;
 112     CARD32 reserved01[0x0BB];
 113     CARD32 TopLeftSrc;
 114     CARD32 TopLeftDst;
 115     CARD32 WidthHeight;
 116 } RivaScreenBlt;
 117 /*
 118  * 2D pixel BLT.
 119  */
 120 typedef volatile struct
 121 {
 122     CARD32 reserved00[4];
 123     CARD16 FifoFree;
 124     CARD16 Nop[1];
 125     CARD32 reserved01[0x0BC];
 126     CARD32 TopLeft;
 127     CARD32 WidthHeight;
 128     CARD32 WidthHeightIn;
 129     CARD32 reserved02[0x03C];
 130     CARD32 Pixels;
 131 } RivaPixmap;
 132 /*
 133  * Filled rectangle combined with monochrome expand.  Useful for glyphs.
 134  */
 135 typedef volatile struct
 136 {
 137     CARD32 reserved00[4];
 138     CARD16 FifoFree;
 139     CARD16 Nop;
 140     CARD32 reserved01[0x0BB];
 141     CARD32 reserved03[(0x040)-1];
 142     CARD32 Color1A;
 143     struct
 144     {
 145         CARD32 TopLeft;
 146         CARD32 WidthHeight;
 147     } UnclippedRectangle[64];
 148     CARD32 reserved04[(0x080)-3];
 149     struct
 150     {
 151         CARD32 TopLeft;
 152         CARD32 BottomRight;
 153     } ClipB;
 154     CARD32 Color1B;
 155     struct
 156     {
 157         CARD32 TopLeft;
 158         CARD32 BottomRight;
 159     } ClippedRectangle[64];
 160     CARD32 reserved05[(0x080)-5];
 161     struct
 162     {
 163         CARD32 TopLeft;
 164         CARD32 BottomRight;
 165     } ClipC;
 166     CARD32 Color1C;
 167     CARD32 WidthHeightC;
 168     CARD32 PointC;
 169     CARD32 MonochromeData1C;
 170     CARD32 reserved06[(0x080)+121];
 171     struct
 172     {
 173         CARD32 TopLeft;
 174         CARD32 BottomRight;
 175     } ClipD;
 176     CARD32 Color1D;
 177     CARD32 WidthHeightInD;
 178     CARD32 WidthHeightOutD;
 179     CARD32 PointD;
 180     CARD32 MonochromeData1D;
 181     CARD32 reserved07[(0x080)+120];
 182     struct
 183     {
 184         CARD32 TopLeft;
 185         CARD32 BottomRight;
 186     } ClipE;
 187     CARD32 Color0E;
 188     CARD32 Color1E;
 189     CARD32 WidthHeightInE;
 190     CARD32 WidthHeightOutE;
 191     CARD32 PointE;
 192     CARD32 MonochromeData01E;
 193 } RivaBitmap;
 194 /*
 195  * 2D line.
 196  */
 197 typedef volatile struct
 198 {
 199     CARD32 reserved00[4];
 200     CARD16 FifoFree;
 201     CARD16 Nop[1];
 202     CARD32 reserved01[0x0BC];
 203     CARD32 Color;             /* source color               0304-0307*/
 204     CARD32 Reserved02[0x03e];
 205     struct {                /* start aliased methods in array   0400-    */
 206         CARD32 point0;        /* y_x S16_S16 in pixels            0-   3*/
 207         CARD32 point1;        /* y_x S16_S16 in pixels            4-   7*/
 208     } Lin[16];              /* end of aliased methods in array      -047f*/
 209     struct {                /* start aliased methods in array   0480-    */
 210         CARD32 point0X;       /* in pixels, 0 at left                0-   3*/
 211         CARD32 point0Y;       /* in pixels, 0 at top                 4-   7*/
 212         CARD32 point1X;       /* in pixels, 0 at left                8-   b*/
 213         CARD32 point1Y;       /* in pixels, 0 at top                 c-   f*/
 214     } Lin32[8];             /* end of aliased methods in array      -04ff*/
 215     CARD32 PolyLin[32];       /* y_x S16_S16 in pixels         0500-057f*/
 216     struct {                /* start aliased methods in array   0580-    */
 217         CARD32 x;             /* in pixels, 0 at left                0-   3*/
 218         CARD32 y;             /* in pixels, 0 at top                 4-   7*/
 219     } PolyLin32[16];        /* end of aliased methods in array      -05ff*/
 220     struct {                /* start aliased methods in array   0600-    */
 221         CARD32 color;         /* source color                     0-   3*/
 222         CARD32 point;         /* y_x S16_S16 in pixels            4-   7*/
 223     } ColorPolyLin[16];     /* end of aliased methods in array      -067f*/
 224 } RivaLine;
 225 /*
 226  * 2D/3D surfaces
 227  */
 228 typedef volatile struct
 229 {
 230     CARD32 reserved00[4];
 231     CARD16 FifoFree;
 232     CARD16 Nop;
 233     CARD32 reserved01[0x0BE];
 234     CARD32 Offset;
 235 } RivaSurface;
 236 typedef volatile struct
 237 {
 238     CARD32 reserved00[4];
 239     CARD16 FifoFree;
 240     CARD16 Nop;
 241     CARD32 reserved01[0x0BD];
 242     CARD32 Pitch;
 243     CARD32 RenderBufferOffset;
 244     CARD32 ZBufferOffset;
 245 } RivaSurface3D;
 246
 247 /***************************************************************************\
 248 *                                                                           *
 249 *                        Virtualized RIVA H/W interface.                    *
 250 *                                                                           *
 251 \***************************************************************************/
 252
 253 #define FP_ENABLE  1
 254 #define FP_DITHER  2
 255
 256 struct _riva_hw_inst;
 257 struct _riva_hw_state;
 258 /*
 259  * Virtialized chip interface. Makes RIVA 128 and TNT look alike.
 260  */
 261 typedef struct _riva_hw_inst
 262 {
 263     /*
 264      * Chip specific settings.
 265      */
 266     CARD32 CrystalFreqKHz;
 267     CARD32 RamAmountKBytes;
 268     CARD32 MaxVClockFreqKHz;
 269     CARD32 RamBandwidthKBytesPerSec;
 270     CARD32 EnableIRQ;
 271     CARD32 IO;
 272     CARD32 VBlankBit;
 273     CARD32 FifoFreeCount;
 274     CARD32 FifoEmptyCount;
 275     CARD32 CursorStart;
 276     /*
 277      * Non-FIFO registers.
 278      */
 279     volatile CARD32 *PCRTC;
 280     volatile CARD32 *PFB;
 281     volatile CARD32 *PFIFO;
 282     volatile CARD32 *PGRAPH;
 283     volatile CARD32 *PEXTDEV;
 284     volatile CARD32 *PTIMER;
 285     volatile CARD32 *PMC;
 286     volatile CARD32 *PRAMIN;
 287     volatile CARD32 *FIFO;
 288     volatile CARD32 *CURSOR;
 289     volatile CARD8 *PCIO;
 290     volatile CARD8 *PVIO;
 291     volatile CARD8 *PDIO;
 292     volatile CARD32 *PRAMDAC;
 293     /*
 294      * Common chip functions.
 295      */
 296     int  (*Busy)(struct _riva_hw_inst *);
 297     void (*CalcStateExt)(struct _riva_hw_inst *,struct _riva_hw_state *,int,int,int,int,int,int);
 298     void (*LoadStateExt)(struct _riva_hw_inst *,struct _riva_hw_state *);
 299     void (*UnloadStateExt)(struct _riva_hw_inst *,struct _riva_hw_state *);
 300     void (*SetStartAddress)(struct _riva_hw_inst *,CARD32);
 301     int  (*ShowHideCursor)(struct _riva_hw_inst *,int);
 302     void (*LockUnlock)(struct _riva_hw_inst *, int);
 303     /*
 304      * Current extended mode settings.
 305      */
 306     struct _riva_hw_state *CurrentState;
 307     /*
 308      * FIFO registers.
 309      */
 310     RivaRop                 *Rop;
 311     RivaPattern             *Patt;
 312     RivaClip                *Clip;
 313     RivaPixmap              *Pixmap;
 314     RivaScreenBlt           *Blt;
 315     RivaBitmap              *Bitmap;
 316     RivaLine                *Line;
 317 } RIVA_HW_INST;
 318 /*
 319  * Extended mode state information.
 320  */
 321 typedef struct _riva_hw_state
 322 {
 323     CARD32 bpp;
 324     CARD32 width;
 325     CARD32 height;
 326     CARD32 interlace;
 327     CARD32 repaint0;
 328     CARD32 repaint1;
 329     CARD32 screen;
 330     CARD32 extra;
 331     CARD32 pixel;
 332     CARD32 horiz;
 333     CARD32 arbitration0;
 334     CARD32 arbitration1;
 335     CARD32 vpll;
 336     CARD32 pllsel;
 337     CARD32 general;
 338     CARD32 config;
 339     CARD32 cursorConfig;
 340     CARD32 cursor0;
 341     CARD32 cursor1;
 342     CARD32 cursor2;
 343     CARD32 offset;
 344     CARD32 pitch;
 345 } RIVA_HW_STATE;
 346
 347 /*
 348  * FIFO Free Count. Should attempt to yield processor if RIVA is busy.
 349  */
 350
 351 #define RIVA_FIFO_FREE(hwinst,hwptr,cnt)                           \
 352 {                                                                  \
 353    while ((hwinst).FifoFreeCount < (cnt)) {                          \
 354         mem_barrier(); \
 355         mem_barrier(); \
 356         (hwinst).FifoFreeCount = (hwinst).hwptr->FifoFree >> 2;        \
 357    } \
 358    (hwinst).FifoFreeCount -= (cnt);                                \
 359 }
 360 #define RIVA_BUSY(hwinst) \
 361 { \
 362    mem_barrier(); \
 363    while ((hwinst).Busy(&(hwinst))); \
 364 }
 365 #endif /* __RIVA_HW_H__ */
 366