drivers/mxc/gpu-viv/hal/kernel/inc/gc_hal_types.h

   1 /****************************************************************************
   2 *
   3 *    Copyright (C) 2005 - 2011 by Vivante Corp.
   4 *
   5 *    This program is free software; you can redistribute it and/or modify
   6 *    it under the terms of the GNU General Public License as published by
   7 *    the Free Software Foundation; either version 2 of the license, or
   8 *    (at your option) any later version.
   9 *
  10 *    This program is distributed in the hope that it will be useful,
  11 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13 *    GNU General Public License for more details.
  14 *
  15 *    You should have received a copy of the GNU General Public License
  16 *    along with this program; if not write to the Free Software
  17 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 *
  19 *****************************************************************************/
  20
  21
  22
  23
  24 #ifndef __gc_hal_types_h_
  25 #define __gc_hal_types_h_
  26
  27 #include "gc_hal_version.h"
  28 #include "gc_hal_options.h"
  29
  30 #ifdef _WIN32
  31 #pragma warning(disable:4127)   /* Conditional expression is constant (do { }
  32                                 ** while(0)). */
  33 #pragma warning(disable:4100)   /* Unreferenced formal parameter. */
  34 #pragma warning(disable:4204)   /* Non-constant aggregate initializer (C99). */
  35 #pragma warning(disable:4131)   /* Uses old-style declarator (for Bison and
  36                                 ** Flex generated files). */
  37 #pragma warning(disable:4206)   /* Translation unit is empty. */
  38 #endif
  39
  40 #ifdef __cplusplus
  41 extern "C" {
  42 #endif
  43
  44 /******************************************************************************\
  45 **  Platform macros.
  46 */
  47
  48 #if defined(__GNUC__)
  49 #   define gcdHAS_ELLIPSES      1       /* GCC always has it. */
  50 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
  51 #   define gcdHAS_ELLIPSES      1       /* C99 has it. */
  52 #elif defined(_MSC_VER) && (_MSC_VER >= 1500)
  53 #   define gcdHAS_ELLIPSES      1       /* MSVC 2007+ has it. */
  54 #elif defined(UNDER_CE)
  55 #if UNDER_CE >= 600
  56 #       define gcdHAS_ELLIPSES  1
  57 #   else
  58 #       define gcdHAS_ELLIPSES  0
  59 #   endif
  60 #else
  61 #   error "gcdHAS_ELLIPSES: Platform could not be determined"
  62 #endif
  63
  64 /******************************************************************************\
  65 ************************************ Keyword ***********************************
  66 \******************************************************************************/
  67
  68 #if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))
  69 #   define gcmINLINE            inline      /* C99 keyword. */
  70 #elif defined(__GNUC__)
  71 #   define gcmINLINE            __inline__  /* GNU keyword. */
  72 #elif defined(_MSC_VER) || defined(UNDER_CE)
  73 #   define gcmINLINE            __inline    /* Internal keyword. */
  74 #else
  75 #   error "gcmINLINE: Platform could not be determined"
  76 #endif
  77
  78 /* Possible debug flags. */
  79 #define gcdDEBUG_NONE           0
  80 #define gcdDEBUG_ALL            (1 << 0)
  81 #define gcdDEBUG_FATAL          (1 << 1)
  82 #define gcdDEBUG_TRACE          (1 << 2)
  83 #define gcdDEBUG_BREAK          (1 << 3)
  84 #define gcdDEBUG_ASSERT         (1 << 4)
  85 #define gcdDEBUG_CODE           (1 << 5)
  86 #define gcdDEBUG_STACK          (1 << 6)
  87
  88 #define gcmIS_DEBUG(flag)       ( gcdDEBUG & (flag | gcdDEBUG_ALL) )
  89
  90 #ifndef gcdDEBUG
  91 #if (defined(DBG) && DBG) || defined(DEBUG) || defined(_DEBUG)
  92 #       define gcdDEBUG         gcdDEBUG_ALL
  93 #   else
  94 #       define gcdDEBUG         gcdDEBUG_NONE
  95 #   endif
  96 #endif
  97
  98 #ifdef _USRDLL
  99 #ifdef _MSC_VER
 100 #ifdef HAL_EXPORTS
 101 #           define HALAPI       __declspec(dllexport)
 102 #       else
 103 #           define HALAPI       __declspec(dllimport)
 104 #       endif
 105 #       define HALDECL          __cdecl
 106 #   else
 107 #ifdef HAL_EXPORTS
 108 #           define HALAPI
 109 #       else
 110 #           define HALAPI       extern
 111 #       endif
 112 #   endif
 113 #else
 114 #   define HALAPI
 115 #   define HALDECL
 116 #endif
 117
 118 /******************************************************************************\
 119 ********************************** Common Types ********************************
 120 \******************************************************************************/
 121
 122 #define gcvFALSE                0
 123 #define gcvTRUE                 1
 124
 125 #define gcvINFINITE             ((gctUINT32) ~0U)
 126
 127 #define gcvINVALID_HANDLE       ((gctHANDLE) ~0U)
 128
 129 typedef int                     gctBOOL;
 130 typedef gctBOOL *               gctBOOL_PTR;
 131
 132 typedef int                     gctINT;
 133 typedef signed char             gctINT8;
 134 typedef signed short            gctINT16;
 135 typedef signed int              gctINT32;
 136 typedef signed long long        gctINT64;
 137
 138 typedef gctINT *                gctINT_PTR;
 139 typedef gctINT8 *               gctINT8_PTR;
 140 typedef gctINT16 *              gctINT16_PTR;
 141 typedef gctINT32 *              gctINT32_PTR;
 142 typedef gctINT64 *              gctINT64_PTR;
 143
 144 typedef unsigned int            gctUINT;
 145 typedef unsigned char           gctUINT8;
 146 typedef unsigned short          gctUINT16;
 147 typedef unsigned int            gctUINT32;
 148 typedef unsigned long long      gctUINT64;
 149
 150 typedef gctUINT *               gctUINT_PTR;
 151 typedef gctUINT8 *              gctUINT8_PTR;
 152 typedef gctUINT16 *             gctUINT16_PTR;
 153 typedef gctUINT32 *             gctUINT32_PTR;
 154 typedef gctUINT64 *             gctUINT64_PTR;
 155
 156 typedef unsigned long           gctSIZE_T;
 157 typedef gctSIZE_T *             gctSIZE_T_PTR;
 158
 159 #ifdef __cplusplus
 160 #   define gcvNULL              0
 161 #else
 162 #   define gcvNULL              ((void *) 0)
 163 #endif
 164
 165 typedef float                   gctFLOAT;
 166 typedef signed int              gctFIXED_POINT;
 167 typedef float *                 gctFLOAT_PTR;
 168
 169 typedef void *                  gctPHYS_ADDR;
 170 typedef void *                  gctHANDLE;
 171 typedef void *                  gctFILE;
 172 typedef void *                  gctSIGNAL;
 173 typedef void *                  gctWINDOW;
 174 typedef void *                  gctIMAGE;
 175
 176 typedef void *                                  gctSEMAPHORE;
 177
 178 typedef void *                  gctPOINTER;
 179 typedef const void *            gctCONST_POINTER;
 180
 181 typedef char                    gctCHAR;
 182 typedef char *                  gctSTRING;
 183 typedef const char *            gctCONST_STRING;
 184
 185 typedef struct _gcsCOUNT_STRING
 186 {
 187     gctSIZE_T                   Length;
 188     gctCONST_STRING             String;
 189 }
 190 gcsCOUNT_STRING;
 191
 192 typedef union _gcuFLOAT_UINT32
 193 {
 194     gctFLOAT    f;
 195     gctUINT32   u;
 196 }
 197 gcuFLOAT_UINT32;
 198
 199 /* Fixed point constants. */
 200 #define gcvZERO_X               ((gctFIXED_POINT) 0x00000000)
 201 #define gcvHALF_X               ((gctFIXED_POINT) 0x00008000)
 202 #define gcvONE_X                ((gctFIXED_POINT) 0x00010000)
 203 #define gcvNEGONE_X             ((gctFIXED_POINT) 0xFFFF0000)
 204 #define gcvTWO_X                ((gctFIXED_POINT) 0x00020000)
 205
 206 /* Stringizing macro. */
 207 #define gcmSTRING(Value)        #Value
 208
 209 /******************************************************************************\
 210 ******************************* Fixed Point Math *******************************
 211 \******************************************************************************/
 212
 213 #define gcmXMultiply(x1, x2)            gcoMATH_MultiplyFixed(x1, x2)
 214 #define gcmXDivide(x1, x2)              gcoMATH_DivideFixed(x1, x2)
 215 #define gcmXMultiplyDivide(x1, x2, x3)  gcoMATH_MultiplyDivideFixed(x1, x2, x3)
 216
 217 /* 2D Engine profile. */
 218 typedef struct _gcs2D_PROFILE
 219 {
 220     /* Cycle count.
 221        32bit counter incremented every 2D clock cycle.
 222        Wraps back to 0 when the counter overflows.
 223     */
 224     gctUINT32 cycleCount;
 225
 226     /* Pixels rendered by the 2D engine.
 227        Resets to 0 every time it is read. */
 228     gctUINT32 pixelsRendered;
 229 }
 230 gcs2D_PROFILE;
 231
 232 /* Macro to combine four characters into a Charcater Code. */
 233 #define gcmCC(c1, c2, c3, c4) \
 234 ( \
 235     (char) (c1) \
 236     | \
 237     ((char) (c2) <<  8) \
 238     | \
 239     ((char) (c3) << 16) \
 240     | \
 241     ((char) (c4) << 24) \
 242 )
 243
 244 #define gcmPRINTABLE(c)         ((((c) >= ' ') && ((c) <= '}')) ? ((c) != '%' ?  (c) : ' ') : ' ')
 245
 246 #define gcmCC_PRINT(cc) \
 247     gcmPRINTABLE((char) ( (cc)        & 0xFF)), \
 248     gcmPRINTABLE((char) (((cc) >>  8) & 0xFF)), \
 249     gcmPRINTABLE((char) (((cc) >> 16) & 0xFF)), \
 250     gcmPRINTABLE((char) (((cc) >> 24) & 0xFF))
 251
 252 /******************************************************************************\
 253 ****************************** Function Parameters *****************************
 254 \******************************************************************************/
 255
 256 #define IN
 257 #define OUT
 258 #define OPTIONAL
 259
 260 /******************************************************************************\
 261 ********************************* Status Codes *********************************
 262 \******************************************************************************/
 263
 264 typedef enum _gceSTATUS
 265 {
 266     gcvSTATUS_OK                    =   0,
 267     gcvSTATUS_FALSE                 =   0,
 268     gcvSTATUS_TRUE                  =   1,
 269     gcvSTATUS_NO_MORE_DATA          =   2,
 270     gcvSTATUS_CACHED                =   3,
 271     gcvSTATUS_MIPMAP_TOO_LARGE      =   4,
 272     gcvSTATUS_NAME_NOT_FOUND        =   5,
 273     gcvSTATUS_NOT_OUR_INTERRUPT     =   6,
 274     gcvSTATUS_MISMATCH              =   7,
 275     gcvSTATUS_MIPMAP_TOO_SMALL      =   8,
 276     gcvSTATUS_LARGER                =   9,
 277     gcvSTATUS_SMALLER               =   10,
 278     gcvSTATUS_CHIP_NOT_READY        =   11,
 279     gcvSTATUS_NEED_CONVERSION       =   12,
 280     gcvSTATUS_SKIP                  =   13,
 281     gcvSTATUS_DATA_TOO_LARGE        =   14,
 282     gcvSTATUS_INVALID_CONFIG        =   15,
 283     gcvSTATUS_CHANGED               =   16,
 284     gcvSTATUS_NOT_SUPPORT_DITHER    =   17,
 285         gcvSTATUS_EXECUTED                              =       18,
 286     gcvSTATUS_TERMINATE             =   19,
 287
 288     gcvSTATUS_INVALID_ARGUMENT      =   -1,
 289     gcvSTATUS_INVALID_OBJECT        =   -2,
 290     gcvSTATUS_OUT_OF_MEMORY         =   -3,
 291     gcvSTATUS_MEMORY_LOCKED         =   -4,
 292     gcvSTATUS_MEMORY_UNLOCKED       =   -5,
 293     gcvSTATUS_HEAP_CORRUPTED        =   -6,
 294     gcvSTATUS_GENERIC_IO            =   -7,
 295     gcvSTATUS_INVALID_ADDRESS       =   -8,
 296     gcvSTATUS_CONTEXT_LOSSED        =   -9,
 297     gcvSTATUS_TOO_COMPLEX           =   -10,
 298     gcvSTATUS_BUFFER_TOO_SMALL      =   -11,
 299     gcvSTATUS_INTERFACE_ERROR       =   -12,
 300     gcvSTATUS_NOT_SUPPORTED         =   -13,
 301     gcvSTATUS_MORE_DATA             =   -14,
 302     gcvSTATUS_TIMEOUT               =   -15,
 303     gcvSTATUS_OUT_OF_RESOURCES      =   -16,
 304     gcvSTATUS_INVALID_DATA          =   -17,
 305     gcvSTATUS_INVALID_MIPMAP        =   -18,
 306     gcvSTATUS_NOT_FOUND             =   -19,
 307     gcvSTATUS_NOT_ALIGNED           =   -20,
 308     gcvSTATUS_INVALID_REQUEST       =   -21,
 309     gcvSTATUS_GPU_NOT_RESPONDING    =   -22,
 310     gcvSTATUS_TIMER_OVERFLOW        =   -23,
 311     gcvSTATUS_VERSION_MISMATCH      =   -24,
 312     gcvSTATUS_LOCKED                =   -25,
 313     gcvSTATUS_INTERRUPTED           =   -26,
 314     gcvSTATUS_DEVICE                =   -27,
 315
 316     /* Linker errors. */
 317     gcvSTATUS_GLOBAL_TYPE_MISMATCH  =   -1000,
 318     gcvSTATUS_TOO_MANY_ATTRIBUTES   =   -1001,
 319     gcvSTATUS_TOO_MANY_UNIFORMS     =   -1002,
 320     gcvSTATUS_TOO_MANY_VARYINGS     =   -1003,
 321     gcvSTATUS_UNDECLARED_VARYING    =   -1004,
 322     gcvSTATUS_VARYING_TYPE_MISMATCH =   -1005,
 323     gcvSTATUS_MISSING_MAIN          =   -1006,
 324     gcvSTATUS_NAME_MISMATCH         =   -1007,
 325     gcvSTATUS_INVALID_INDEX         =   -1008,
 326 }
 327 gceSTATUS;
 328
 329 /******************************************************************************\
 330 ********************************* Status Macros ********************************
 331 \******************************************************************************/
 332
 333 #define gcmIS_ERROR(status)         (status < 0)
 334 #define gcmNO_ERROR(status)         (status >= 0)
 335 #define gcmIS_SUCCESS(status)       (status == gcvSTATUS_OK)
 336
 337 /******************************************************************************\
 338 ********************************* Field Macros *********************************
 339 \******************************************************************************/
 340
 341 #define __gcmSTART(reg_field) \
 342     (0 ? reg_field)
 343
 344 #define __gcmEND(reg_field) \
 345     (1 ? reg_field)
 346
 347 #define __gcmGETSIZE(reg_field) \
 348     (__gcmEND(reg_field) - __gcmSTART(reg_field) + 1)
 349
 350 #define __gcmALIGN(data, reg_field) \
 351     (((gctUINT32) (data)) << __gcmSTART(reg_field))
 352
 353 #define __gcmMASK(reg_field) \
 354     ((gctUINT32) ((__gcmGETSIZE(reg_field) == 32) \
 355         ?  ~0 \
 356         : (~(~0 << __gcmGETSIZE(reg_field)))))
 357
 358 /*******************************************************************************
 359 **
 360 **  gcmFIELDMASK
 361 **
 362 **      Get aligned field mask.
 363 **
 364 **  ARGUMENTS:
 365 **
 366 **      reg     Name of register.
 367 **      field   Name of field within register.
 368 */
 369 #define gcmFIELDMASK(reg, field) \
 370 ( \
 371     __gcmALIGN(__gcmMASK(reg##_##field), reg##_##field) \
 372 )
 373
 374 /*******************************************************************************
 375 **
 376 **  gcmGETFIELD
 377 **
 378 **      Extract the value of a field from specified data.
 379 **
 380 **  ARGUMENTS:
 381 **
 382 **      data    Data value.
 383 **      reg     Name of register.
 384 **      field   Name of field within register.
 385 */
 386 #define gcmGETFIELD(data, reg, field) \
 387 ( \
 388     ((((gctUINT32) (data)) >> __gcmSTART(reg##_##field)) \
 389         & __gcmMASK(reg##_##field)) \
 390 )
 391
 392 /*******************************************************************************
 393 **
 394 **  gcmSETFIELD
 395 **
 396 **      Set the value of a field within specified data.
 397 **
 398 **  ARGUMENTS:
 399 **
 400 **      data    Data value.
 401 **      reg     Name of register.
 402 **      field   Name of field within register.
 403 **      value   Value for field.
 404 */
 405 #define gcmSETFIELD(data, reg, field, value) \
 406 ( \
 407     (((gctUINT32) (data)) \
 408         & ~__gcmALIGN(__gcmMASK(reg##_##field), reg##_##field)) \
 409         |  __gcmALIGN((gctUINT32) (value) \
 410             & __gcmMASK(reg##_##field), reg##_##field) \
 411 )
 412
 413 /*******************************************************************************
 414 **
 415 **  gcmSETFIELDVALUE
 416 **
 417 **      Set the value of a field within specified data with a
 418 **      predefined value.
 419 **
 420 **  ARGUMENTS:
 421 **
 422 **      data    Data value.
 423 **      reg     Name of register.
 424 **      field   Name of field within register.
 425 **      value   Name of the value within the field.
 426 */
 427 #define gcmSETFIELDVALUE(data, reg, field, value) \
 428 ( \
 429     (((gctUINT32) (data)) \
 430         & ~__gcmALIGN(__gcmMASK(reg##_##field), reg##_##field)) \
 431         |  __gcmALIGN(reg##_##field##_##value \
 432             & __gcmMASK(reg##_##field), reg##_##field) \
 433 )
 434
 435 /*******************************************************************************
 436 **
 437 **  gcmGETMASKEDFIELDMASK
 438 **
 439 **      Determine field mask of a masked field.
 440 **
 441 **  ARGUMENTS:
 442 **
 443 **      reg     Name of register.
 444 **      field   Name of field within register.
 445 */
 446 #define gcmGETMASKEDFIELDMASK(reg, field) \
 447 ( \
 448     gcmSETFIELD(0, reg,          field, ~0) | \
 449     gcmSETFIELD(0, reg, MASK_ ## field, ~0)   \
 450 )
 451
 452 /*******************************************************************************
 453 **
 454 **  gcmSETMASKEDFIELD
 455 **
 456 **      Set the value of a masked field with specified data.
 457 **
 458 **  ARGUMENTS:
 459 **
 460 **      reg     Name of register.
 461 **      field   Name of field within register.
 462 **      value   Value for field.
 463 */
 464 #define gcmSETMASKEDFIELD(reg, field, value) \
 465 ( \
 466     gcmSETFIELD     (~0, reg,          field, value) & \
 467     gcmSETFIELDVALUE(~0, reg, MASK_ ## field, ENABLED) \
 468 )
 469
 470 /*******************************************************************************
 471 **
 472 **  gcmSETMASKEDFIELDVALUE
 473 **
 474 **      Set the value of a masked field with specified data.
 475 **
 476 **  ARGUMENTS:
 477 **
 478 **      reg     Name of register.
 479 **      field   Name of field within register.
 480 **      value   Value for field.
 481 */
 482 #define gcmSETMASKEDFIELDVALUE(reg, field, value) \
 483 ( \
 484     gcmSETFIELDVALUE(~0, reg,          field, value) & \
 485     gcmSETFIELDVALUE(~0, reg, MASK_ ## field, ENABLED) \
 486 )
 487
 488 /*******************************************************************************
 489 **
 490 **  gcmVERIFYFIELDVALUE
 491 **
 492 **      Verify if the value of a field within specified data equals a
 493 **      predefined value.
 494 **
 495 **  ARGUMENTS:
 496 **
 497 **      data    Data value.
 498 **      reg     Name of register.
 499 **      field   Name of field within register.
 500 **      value   Name of the value within the field.
 501 */
 502 #define gcmVERIFYFIELDVALUE(data, reg, field, value) \
 503 ( \
 504     (((gctUINT32) (data)) >> __gcmSTART(reg##_##field) & \
 505                              __gcmMASK(reg##_##field)) \
 506         == \
 507     (reg##_##field##_##value & __gcmMASK(reg##_##field)) \
 508 )
 509
 510 /*******************************************************************************
 511 **  Bit field macros.
 512 */
 513
 514 #define __gcmSTARTBIT(Field) \
 515     ( 1 ? Field )
 516
 517 #define __gcmBITSIZE(Field) \
 518     ( 0 ? Field )
 519
 520 #define __gcmBITMASK(Field) \
 521 ( \
 522     (1 << __gcmBITSIZE(Field)) - 1 \
 523 )
 524
 525 #define gcmGETBITS(Value, Type, Field) \
 526 ( \
 527     ( ((Type) (Value)) >> __gcmSTARTBIT(Field) ) \
 528     & \
 529     __gcmBITMASK(Field) \
 530 )
 531
 532 #define gcmSETBITS(Value, Type, Field, NewValue) \
 533 ( \
 534     ( ((Type) (Value)) \
 535     & ~(__gcmBITMASK(Field) << __gcmSTARTBIT(Field)) \
 536     ) \
 537     | \
 538     ( ( ((Type) (NewValue)) \
 539       & __gcmBITMASK(Field) \
 540       ) << __gcmSTARTBIT(Field) \
 541     ) \
 542 )
 543
 544 /*******************************************************************************
 545 **
 546 **  gcmISINREGRANGE
 547 **
 548 **      Verify whether the specified address is in the register range.
 549 **
 550 **  ARGUMENTS:
 551 **
 552 **      Address Address to be verified.
 553 **      Name    Name of a register.
 554 */
 555
 556 #define gcmISINREGRANGE(Address, Name) \
 557 ( \
 558     ((Address & (~0U << Name ## _LSB)) == (Name ## _Address >> 2)) \
 559 )
 560
 561 /*******************************************************************************
 562 **
 563 **  A set of macros to aid state loading.
 564 **
 565 **  ARGUMENTS:
 566 **
 567 **      CommandBuffer   Pointer to a gcoCMDBUF object.
 568 **      StateDelta      Pointer to a gcsSTATE_DELTA state delta structure.
 569 **      Memory          Destination memory pointer of gctUINT32_PTR type.
 570 **      PartOfContext   Whether or not the state is a part of the context.
 571 **      FixedPoint      Whether or not the state is of the fixed point format.
 572 **      Count           Number of consecutive states to be loaded.
 573 **      Address         State address.
 574 **      Data            Data to be set to the state.
 575 */
 576
 577 /*----------------------------------------------------------------------------*/
 578
 579 #if gcmIS_DEBUG(gcdDEBUG_CODE)
 580
 581 #   define gcmSTORELOADSTATE(CommandBuffer, Memory, Address, Count) \
 582         CommandBuffer->lastLoadStatePtr     = Memory; \
 583         CommandBuffer->lastLoadStateAddress = Address; \
 584         CommandBuffer->lastLoadStateCount   = Count
 585
 586 #   define gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address) \
 587         gcmASSERT( \
 588             (gctUINT) (Memory  - CommandBuffer->lastLoadStatePtr - 1) \
 589             == \
 590             (gctUINT) (Address - CommandBuffer->lastLoadStateAddress) \
 591             ); \
 592         \
 593         gcmASSERT(CommandBuffer->lastLoadStateCount > 0); \
 594         \
 595         CommandBuffer->lastLoadStateCount -= 1
 596
 597 #   define gcmVERIFYLOADSTATEDONE(CommandBuffer) \
 598         gcmASSERT(CommandBuffer->lastLoadStateCount == 0)
 599
 600 #else
 601
 602 #   define gcmSTORELOADSTATE(CommandBuffer, Memory, Address, Count)
 603 #   define gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address)
 604 #   define gcmVERIFYLOADSTATEDONE(CommandBuffer)
 605
 606 #endif
 607
 608 #if gcdSECURE_USER
 609
 610 #   define gcmDEFINESECUREUSER() \
 611         gctUINT         __secure_user_offset__; \
 612         gctUINT32_PTR   __secure_user_hintArray__;
 613
 614 #   define gcmBEGINSECUREUSER() \
 615         __secure_user_offset__ = reserve->lastOffset; \
 616         \
 617         __secure_user_hintArray__ = reserve->hintArrayTail
 618
 619 #   define gcmENDSECUREUSER() \
 620         reserve->hintArrayTail = __secure_user_hintArray__
 621
 622 #   define gcmSKIPSECUREUSER() \
 623         __secure_user_offset__ += gcmSIZEOF(gctUINT32)
 624
 625 #   define gcmUPDATESECUREUSER() \
 626         *__secure_user_hintArray__ = __secure_user_offset__; \
 627         \
 628         __secure_user_offset__    += gcmSIZEOF(gctUINT32); \
 629         __secure_user_hintArray__ += 1
 630
 631 #else
 632
 633 #   define gcmDEFINESECUREUSER()
 634 #   define gcmBEGINSECUREUSER()
 635 #   define gcmENDSECUREUSER()
 636 #   define gcmSKIPSECUREUSER()
 637 #   define gcmUPDATESECUREUSER()
 638
 639 #endif
 640
 641 /*----------------------------------------------------------------------------*/
 642
 643 #if gcdDUMP
 644 #   define gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, Data) \
 645         if (FixedPoint) \
 646         { \
 647             gcmDUMP(StateDelta->os, "@[state.x 0x%04X 0x%08X]", \
 648                 Address, Data \
 649                 ); \
 650         } \
 651         else \
 652         { \
 653             gcmDUMP(StateDelta->os, "@[state 0x%04X 0x%08X]", \
 654                 Address, Data \
 655                 ); \
 656         }
 657 #else
 658 #   define gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, Data)
 659 #endif
 660
 661 /*----------------------------------------------------------------------------*/
 662
 663 #define gcmDEFINESTATEBUFFER(CommandBuffer, StateDelta, Memory, ReserveSize) \
 664     gcmDEFINESECUREUSER() \
 665     gctSIZE_T ReserveSize; \
 666     gcoCMDBUF CommandBuffer; \
 667     gctUINT32_PTR Memory; \
 668     gcsSTATE_DELTA_PTR StateDelta
 669
 670 #define gcmBEGINSTATEBUFFER(Hardware, CommandBuffer, StateDelta, Memory, ReserveSize) \
 671 { \
 672     gcmONERROR(gcoBUFFER_Reserve( \
 673         Hardware->buffer, ReserveSize, gcvTRUE, &CommandBuffer \
 674         )); \
 675     \
 676     Memory = (gctUINT32_PTR) CommandBuffer->lastReserve; \
 677     \
 678     StateDelta = Hardware->delta; \
 679     \
 680     gcmBEGINSECUREUSER(); \
 681 }
 682
 683 #define gcmENDSTATEBUFFER(CommandBuffer, Memory, ReserveSize) \
 684 { \
 685     gcmENDSECUREUSER(); \
 686     \
 687     gcmASSERT( \
 688         ((gctUINT8_PTR) CommandBuffer->lastReserve) + ReserveSize \
 689         == \
 690          (gctUINT8_PTR) Memory \
 691         ); \
 692 }
 693
 694 /*----------------------------------------------------------------------------*/
 695
 696 #define gcmBEGINSTATEBATCH(CommandBuffer, Memory, FixedPoint, Address, Count) \
 697 { \
 698     gcmASSERT(((Memory - (gctUINT32_PTR) CommandBuffer->lastReserve) & 1) == 0); \
 699     \
 700     gcmVERIFYLOADSTATEDONE(CommandBuffer); \
 701     \
 702     gcmSTORELOADSTATE(CommandBuffer, Memory, Address, Count); \
 703     \
 704     *Memory++ \
 705         = gcmSETFIELDVALUE(0, AQ_COMMAND_LOAD_STATE_COMMAND, OPCODE,  LOAD_STATE) \
 706         | gcmSETFIELD     (0, AQ_COMMAND_LOAD_STATE_COMMAND, FLOAT,   FixedPoint) \
 707         | gcmSETFIELD     (0, AQ_COMMAND_LOAD_STATE_COMMAND, COUNT,   Count) \
 708         | gcmSETFIELD     (0, AQ_COMMAND_LOAD_STATE_COMMAND, ADDRESS, Address); \
 709     \
 710     gcmSKIPSECUREUSER(); \
 711 }
 712
 713 #define gcmENDSTATEBATCH(CommandBuffer, Memory) \
 714 { \
 715     gcmVERIFYLOADSTATEDONE(CommandBuffer); \
 716     \
 717     gcmASSERT(((Memory - (gctUINT32_PTR) CommandBuffer->lastReserve) & 1) == 0); \
 718 }
 719
 720 /*----------------------------------------------------------------------------*/
 721
 722 #define gcmSETSTATEDATA(StateDelta, CommandBuffer, Memory, FixedPoint, \
 723                         Address, Data) \
 724 { \
 725     gctUINT32 __temp_data32__; \
 726     \
 727     gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address); \
 728     \
 729     __temp_data32__ = Data; \
 730     \
 731     *Memory++ = __temp_data32__; \
 732     \
 733     gcoHARDWARE_UpdateDelta( \
 734         StateDelta, FixedPoint, Address, 0, __temp_data32__ \
 735         ); \
 736     \
 737     gcmDUMPSTATEDATA(StateDelta, FixedPoint, Address, __temp_data32__); \
 738     \
 739     gcmUPDATESECUREUSER(); \
 740 }
 741
 742 #define gcmSETCTRLSTATE(StateDelta, CommandBuffer, Memory, Address, Data) \
 743 { \
 744     gctUINT32 __temp_data32__; \
 745     \
 746     gcmVERIFYLOADSTATE(CommandBuffer, Memory, Address); \
 747     \
 748     __temp_data32__ = Data; \
 749     \
 750     *Memory++ = __temp_data32__; \
 751     \
 752     gcmDUMPSTATEDATA(StateDelta, gcvFALSE, Address, __temp_data32__); \
 753     \
 754     gcmSKIPSECUREUSER(); \
 755 }
 756
 757 #define gcmSETFILLER(CommandBuffer, Memory) \
 758 { \
 759     gcmVERIFYLOADSTATEDONE(CommandBuffer); \
 760     \
 761     Memory += 1; \
 762     \
 763     gcmSKIPSECUREUSER(); \
 764 }
 765
 766 /*----------------------------------------------------------------------------*/
 767
 768 #define gcmSETSINGLESTATE(StateDelta, CommandBuffer, Memory, FixedPoint, \
 769                           Address, Data) \
 770 { \
 771     gcmBEGINSTATEBATCH(CommandBuffer, Memory, FixedPoint, Address, 1); \
 772     gcmSETSTATEDATA(StateDelta, CommandBuffer, Memory, FixedPoint, \
 773                     Address, Data); \
 774     gcmENDSTATEBATCH(CommandBuffer, Memory); \
 775 }
 776
 777 #define gcmSETSINGLECTRLSTATE(StateDelta, CommandBuffer, Memory, FixedPoint, \
 778                               Address, Data) \
 779 { \
 780     gcmBEGINSTATEBATCH(CommandBuffer, Memory, FixedPoint, Address, 1); \
 781     gcmSETCTRLSTATE(StateDelta, CommandBuffer, Memory, Address, Data); \
 782     gcmENDSTATEBATCH(CommandBuffer, Memory); \
 783 }
 784
 785
 786 /*******************************************************************************
 787 **
 788 **  gcmSETSTARTDECOMMAND
 789 **
 790 **      Form a START_DE command.
 791 **
 792 **  ARGUMENTS:
 793 **
 794 **      Memory          Destination memory pointer of gctUINT32_PTR type.
 795 **      Count           Number of the rectangles.
 796 */
 797
 798 #define gcmSETSTARTDECOMMAND(Memory, Count) \
 799 { \
 800     *Memory++ \
 801         = gcmSETFIELDVALUE(0, AQ_COMMAND_START_DE_COMMAND, OPCODE,     START_DE) \
 802         | gcmSETFIELD     (0, AQ_COMMAND_START_DE_COMMAND, COUNT,      Count) \
 803         | gcmSETFIELD     (0, AQ_COMMAND_START_DE_COMMAND, DATA_COUNT, 0); \
 804     \
 805     *Memory++ = 0xDEADDEED; \
 806 }
 807
 808 /******************************************************************************\
 809 ******************************** Ceiling Macro ********************************
 810 \******************************************************************************/
 811 #define gcmCEIL(x) ((x - (gctUINT32)x) == 0 ? (gctUINT32)x : (gctUINT32)x + 1)
 812
 813 /******************************************************************************\
 814 ******************************** Min/Max Macros ********************************
 815 \******************************************************************************/
 816
 817 #define gcmMIN(x, y)            (((x) <= (y)) ?  (x) :  (y))
 818 #define gcmMAX(x, y)            (((x) >= (y)) ?  (x) :  (y))
 819 #define gcmCLAMP(x, min, max)   (((x) < (min)) ? (min) : \
 820                                  ((x) > (max)) ? (max) : (x))
 821 #define gcmABS(x)               (((x) < 0)    ? -(x) :  (x))
 822 #define gcmNEG(x)               (((x) < 0)    ?  (x) : -(x))
 823
 824 /*******************************************************************************
 825 **
 826 **  gcmPTR2INT
 827 **
 828 **      Convert a pointer to an integer value.
 829 **
 830 **  ARGUMENTS:
 831 **
 832 **      p       Pointer value.
 833 */
 834 #if defined(_WIN32) || (defined(__LP64__) && __LP64__)
 835 #   define gcmPTR2INT(p) \
 836     ( \
 837         (gctUINT32) (gctUINT64) (p) \
 838     )
 839 #else
 840 #   define gcmPTR2INT(p) \
 841     ( \
 842         (gctUINT32) (p) \
 843     )
 844 #endif
 845
 846 /*******************************************************************************
 847 **
 848 **  gcmINT2PTR
 849 **
 850 **      Convert an integer value into a pointer.
 851 **
 852 **  ARGUMENTS:
 853 **
 854 **      v       Integer value.
 855 */
 856 #ifdef __LP64__
 857 #   define gcmINT2PTR(i) \
 858     ( \
 859         (gctPOINTER) (gctINT64) (i) \
 860     )
 861 #else
 862 #   define gcmINT2PTR(i) \
 863     ( \
 864         (gctPOINTER) (i) \
 865     )
 866 #endif
 867
 868 /*******************************************************************************
 869 **
 870 **  gcmOFFSETOF
 871 **
 872 **      Compute the byte offset of a field inside a structure.
 873 **
 874 **  ARGUMENTS:
 875 **
 876 **      s       Structure name.
 877 **      field   Field name.
 878 */
 879 #define gcmOFFSETOF(s, field) \
 880 ( \
 881     gcmPTR2INT(& (((struct s *) 0)->field)) \
 882 )
 883
 884 /*******************************************************************************
 885 ***** Database ****************************************************************/
 886
 887 typedef struct _gcsDATABASE_COUNTERS
 888 {
 889     /* Number of currently allocated bytes. */
 890     gctSIZE_T                   bytes;
 891
 892     /* Maximum number of bytes allocated (memory footprint). */
 893     gctSIZE_T                   maxBytes;
 894
 895     /* Total number of bytes allocated. */
 896     gctSIZE_T                   totalBytes;
 897 }
 898 gcsDATABASE_COUNTERS;
 899
 900 typedef struct _gcuDATABASE_INFO
 901 {
 902     /* Counters. */
 903     gcsDATABASE_COUNTERS        counters;
 904
 905     /* Time value. */
 906     gctUINT64                   time;
 907 }
 908 gcuDATABASE_INFO;
 909
 910 /*******************************************************************************
 911 ***** Frame database **********************************************************/
 912
 913 /* gcsHAL_FRAME_INFO */
 914 typedef struct _gcsHAL_FRAME_INFO
 915 {
 916     /* Current timer tick. */
 917     OUT gctUINT64               ticks;
 918
 919     /* Bandwidth counters. */
 920     OUT gctUINT                 readBytes8[8];
 921     OUT gctUINT                 writeBytes8[8];
 922
 923     /* Counters. */
 924     OUT gctUINT                 cycles[8];
 925     OUT gctUINT                 idleCycles[8];
 926     OUT gctUINT                 mcCycles[8];
 927     OUT gctUINT                 readRequests[8];
 928     OUT gctUINT                 writeRequests[8];
 929
 930     /* 3D counters. */
 931     OUT gctUINT                 vertexCount;
 932     OUT gctUINT                 primitiveCount;
 933     OUT gctUINT                 rejectedPrimitives;
 934     OUT gctUINT                 culledPrimitives;
 935     OUT gctUINT                 clippedPrimitives;
 936     OUT gctUINT                 outPrimitives;
 937     OUT gctUINT                 inPrimitives;
 938     OUT gctUINT                 culledQuadCount;
 939     OUT gctUINT                 totalQuadCount;
 940     OUT gctUINT                 quadCount;
 941     OUT gctUINT                 totalPixelCount;
 942
 943     /* PE counters. */
 944     OUT gctUINT                 colorKilled[8];
 945     OUT gctUINT                 colorDrawn[8];
 946     OUT gctUINT                 depthKilled[8];
 947     OUT gctUINT                 depthDrawn[8];
 948
 949     /* Shader counters. */
 950     OUT gctUINT                 shaderCycles;
 951     OUT gctUINT                 vsInstructionCount;
 952     OUT gctUINT                 vsTextureCount;
 953     OUT gctUINT                 psInstructionCount;
 954     OUT gctUINT                 psTextureCount;
 955
 956     /* Texture counters. */
 957     OUT gctUINT                 bilinearRequests;
 958     OUT gctUINT                 trilinearRequests;
 959     OUT gctUINT                 txBytes8;
 960     OUT gctUINT                 txHitCount;
 961     OUT gctUINT                 txMissCount;
 962 }
 963 gcsHAL_FRAME_INFO;
 964
 965 #ifdef __cplusplus
 966 }
 967 #endif
 968
 969 #endif /* __gc_hal_types_h_ */