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

   1 /****************************************************************************
   2 *
   3 *    Copyright (C) 2005 - 2014 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 #ifndef __gc_hal_types_h_
  23 #define __gc_hal_types_h_
  24
  25 #include "gc_hal_version.h"
  26 #include "gc_hal_options.h"
  27
  28 #if !defined(VIV_KMD)
  29 #if defined(__KERNEL__)
  30 #include "linux/version.h"
  31 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
  32     typedef unsigned long uintptr_t;
  33 #   endif
  34 #   include "linux/types.h"
  35 #elif defined(UNDER_CE)
  36 #include <crtdefs.h>
  37 #elif defined(_MSC_VER) && (_MSC_VER <= 1500)
  38 #include <crtdefs.h>
  39 #include "vadefs.h"
  40 #elif defined(__QNXNTO__)
  41 #define _QNX_SOURCE
  42 #include <stdint.h>
  43 #include <stddef.h>
  44 #else
  45 #include <stdlib.h>
  46 #include <stddef.h>
  47 #include <stdint.h>
  48 #endif
  49 #endif
  50
  51 #ifdef _WIN32
  52 #pragma warning(disable:4127)   /* Conditional expression is constant (do { }
  53                                 ** while(0)). */
  54 #pragma warning(disable:4100)   /* Unreferenced formal parameter. */
  55 #pragma warning(disable:4204)   /* Non-constant aggregate initializer (C99). */
  56 #pragma warning(disable:4131)   /* Uses old-style declarator (for Bison and
  57                                 ** Flex generated files). */
  58 #pragma warning(disable:4206)   /* Translation unit is empty. */
  59 #pragma warning(disable:4214)   /* Nonstandard extension used :
  60                                 ** bit field types other than int. */
  61 #endif
  62
  63 #ifdef __cplusplus
  64 extern "C" {
  65 #endif
  66
  67 /******************************************************************************\
  68 **  Platform macros.
  69 */
  70
  71 #if defined(__GNUC__)
  72 #   define gcdHAS_ELLIPSIS      1       /* GCC always has it. */
  73 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
  74 #   define gcdHAS_ELLIPSIS      1       /* C99 has it. */
  75 #elif defined(_MSC_VER) && (_MSC_VER >= 1500)
  76 #   define gcdHAS_ELLIPSIS      1       /* MSVC 2007+ has it. */
  77 #elif defined(UNDER_CE)
  78 #if UNDER_CE >= 600
  79 #       define gcdHAS_ELLIPSIS  1
  80 #   else
  81 #       define gcdHAS_ELLIPSIS  0
  82 #   endif
  83 #else
  84 #   error "gcdHAS_ELLIPSIS: Platform could not be determined"
  85 #endif
  86
  87 /******************************************************************************\
  88 ************************************ Keyword ***********************************
  89 \******************************************************************************/
  90 #if defined(ANDROID) && defined(__BIONIC_FORTIFY)
  91 #   define gcmINLINE            __inline__ __attribute__ ((always_inline)) __attribute__ ((gnu_inline)) __attribute__ ((artificial))
  92 #elif ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || defined(__APPLE__))
  93 #   define gcmINLINE            inline      /* C99 keyword. */
  94 #elif defined(__GNUC__)
  95 #   define gcmINLINE            __inline__  /* GNU keyword. */
  96 #elif defined(_MSC_VER) || defined(UNDER_CE)
  97 #   define gcmINLINE            __inline    /* Internal keyword. */
  98 #else
  99 #   error "gcmINLINE: Platform could not be determined"
 100 #endif
 101
 102 /* Possible debug flags. */
 103 #define gcdDEBUG_NONE           0
 104 #define gcdDEBUG_ALL            (1 << 0)
 105 #define gcdDEBUG_FATAL          (1 << 1)
 106 #define gcdDEBUG_TRACE          (1 << 2)
 107 #define gcdDEBUG_BREAK          (1 << 3)
 108 #define gcdDEBUG_ASSERT         (1 << 4)
 109 #define gcdDEBUG_CODE           (1 << 5)
 110 #define gcdDEBUG_STACK          (1 << 6)
 111
 112 #define gcmIS_DEBUG(flag)       ( gcdDEBUG & (flag | gcdDEBUG_ALL) )
 113
 114 #ifndef gcdDEBUG
 115 #if (defined(DBG) && DBG) || defined(DEBUG) || defined(_DEBUG)
 116 #       define gcdDEBUG         gcdDEBUG_ALL
 117 #   else
 118 #       define gcdDEBUG         gcdDEBUG_NONE
 119 #   endif
 120 #endif
 121
 122 #ifdef _USRDLL
 123 #ifdef _MSC_VER
 124 #ifdef HAL_EXPORTS
 125 #           define HALAPI       __declspec(dllexport)
 126 #       else
 127 #           define HALAPI       __declspec(dllimport)
 128 #       endif
 129 #       define HALDECL          __cdecl
 130 #   else
 131 #ifdef HAL_EXPORTS
 132 #           define HALAPI
 133 #       else
 134 #           define HALAPI       extern
 135 #       endif
 136 #   endif
 137 #else
 138 #   define HALAPI
 139 #   define HALDECL
 140 #endif
 141
 142 /******************************************************************************\
 143 ********************************** Common Types ********************************
 144 \******************************************************************************/
 145
 146 #define gcvFALSE                0
 147 #define gcvTRUE                 1
 148
 149 #define gcvINFINITE             ((gctUINT32) ~0U)
 150
 151 #define gcvINVALID_HANDLE       ((gctHANDLE) ~0U)
 152
 153 typedef int                     gctBOOL;
 154 typedef gctBOOL *               gctBOOL_PTR;
 155
 156 typedef int                     gctINT;
 157 typedef signed char             gctINT8;
 158 typedef signed short            gctINT16;
 159 typedef signed int              gctINT32;
 160 typedef signed long long        gctINT64;
 161
 162 typedef gctINT *                gctINT_PTR;
 163 typedef gctINT8 *               gctINT8_PTR;
 164 typedef gctINT16 *              gctINT16_PTR;
 165 typedef gctINT32 *              gctINT32_PTR;
 166 typedef gctINT64 *              gctINT64_PTR;
 167
 168 typedef unsigned int            gctUINT;
 169 typedef unsigned char           gctUINT8;
 170 typedef unsigned short          gctUINT16;
 171 typedef unsigned int            gctUINT32;
 172 typedef unsigned long long      gctUINT64;
 173 typedef uintptr_t               gctUINTPTR_T;
 174
 175 typedef gctUINT *               gctUINT_PTR;
 176 typedef gctUINT8 *              gctUINT8_PTR;
 177 typedef gctUINT16 *             gctUINT16_PTR;
 178 typedef gctUINT32 *             gctUINT32_PTR;
 179 typedef gctUINT64 *             gctUINT64_PTR;
 180
 181 typedef size_t                  gctSIZE_T;
 182 typedef gctSIZE_T *             gctSIZE_T_PTR;
 183 typedef gctUINT32               gctTRACE;
 184
 185 #ifdef __cplusplus
 186 #   define gcvNULL              0
 187 #else
 188 #   define gcvNULL              ((void *) 0)
 189 #endif
 190
 191 #define gcvMAXINT8              0x7f
 192 #define gcvMININT8              0x80
 193 #define gcvMAXINT16             0x7fff
 194 #define gcvMININT16             0x8000
 195 #define gcvMAXINT32             0x7fffffff
 196 #define gcvMININT32             0x80000000
 197 #define gcvMAXINT64             0x7fffffffffffffff
 198 #define gcvMININT64             0x8000000000000000
 199 #define gcvMAXUINT8             0xff
 200 #define gcvMINUINT8             0x0
 201 #define gcvMAXUINT16            0xffff
 202 #define gcvMINUINT16            0x8000
 203 #define gcvMAXUINT32            0xffffffff
 204 #define gcvMINUINT32            0x80000000
 205 #define gcvMAXUINT64            0xffffffffffffffff
 206 #define gcvMINUINT64            0x8000000000000000
 207 #define gcvMAXUINTPTR_T         (~(gctUINTPTR_T)0)
 208
 209 typedef float                   gctFLOAT;
 210 typedef signed int              gctFIXED_POINT;
 211 typedef float *                 gctFLOAT_PTR;
 212
 213 typedef void *                  gctPHYS_ADDR;
 214 typedef void *                  gctHANDLE;
 215 typedef void *                  gctFILE;
 216 typedef void *                  gctSIGNAL;
 217 typedef void *                  gctWINDOW;
 218 typedef void *                  gctIMAGE;
 219 typedef void *                  gctSYNC_POINT;
 220 typedef void *                  gctSHBUF;
 221
 222 typedef void *                  gctSEMAPHORE;
 223
 224 typedef void *                  gctPOINTER;
 225 typedef const void *            gctCONST_POINTER;
 226
 227 typedef char                    gctCHAR;
 228 typedef char *                  gctSTRING;
 229 typedef const char *            gctCONST_STRING;
 230
 231 typedef struct _gcsCOUNT_STRING
 232 {
 233     gctSIZE_T                   Length;
 234     gctCONST_STRING             String;
 235 }
 236 gcsCOUNT_STRING;
 237
 238 typedef union _gcuFLOAT_UINT32
 239 {
 240     gctFLOAT    f;
 241     gctUINT32   u;
 242 }
 243 gcuFLOAT_UINT32;
 244
 245 /* Fixed point constants. */
 246 #define gcvZERO_X               ((gctFIXED_POINT) 0x00000000)
 247 #define gcvHALF_X               ((gctFIXED_POINT) 0x00008000)
 248 #define gcvONE_X                ((gctFIXED_POINT) 0x00010000)
 249 #define gcvNEGONE_X             ((gctFIXED_POINT) 0xFFFF0000)
 250 #define gcvTWO_X                ((gctFIXED_POINT) 0x00020000)
 251
 252
 253
 254 #define gcmFIXEDCLAMP_NEG1_TO_1(_x) \
 255     (((_x) < gcvNEGONE_X) \
 256         ? gcvNEGONE_X \
 257         : (((_x) > gcvONE_X) \
 258             ? gcvONE_X \
 259             : (_x)))
 260
 261 #define gcmFLOATCLAMP_NEG1_TO_1(_f) \
 262     (((_f) < -1.0f) \
 263         ? -1.0f \
 264         : (((_f) > 1.0f) \
 265             ? 1.0f \
 266             : (_f)))
 267
 268
 269 #define gcmFIXEDCLAMP_0_TO_1(_x) \
 270     (((_x) < 0) \
 271         ? 0 \
 272         : (((_x) > gcvONE_X) \
 273             ? gcvONE_X \
 274             : (_x)))
 275
 276 #define gcmFLOATCLAMP_0_TO_1(_f) \
 277     (((_f) < 0.0f) \
 278         ? 0.0f \
 279         : (((_f) > 1.0f) \
 280             ? 1.0f \
 281             : (_f)))
 282
 283
 284 /******************************************************************************\
 285 ******************************* Multicast Values *******************************
 286 \******************************************************************************/
 287
 288 /* Value types. */
 289 typedef enum _gceVALUE_TYPE
 290 {
 291     gcvVALUE_UINT = 0x0,
 292     gcvVALUE_FIXED,
 293     gcvVALUE_FLOAT,
 294     gcvVALUE_INT,
 295
 296     /*
 297     ** The value need be unsigned denormalized. clamp (0.0-1.0) should be done first.
 298     */
 299     gcvVALUE_FLAG_UNSIGNED_DENORM = 0x00010000,
 300
 301     /*
 302     ** The value need be signed denormalized. clamp (-1.0-1.0) should be done first.
 303     */
 304     gcvVALUE_FLAG_SIGNED_DENORM   = 0x00020000,
 305
 306     /*
 307     ** The value need to gammar
 308     */
 309     gcvVALUE_FLAG_GAMMAR          = 0x00040000,
 310
 311     /*
 312     ** The value need to convert from float to float16
 313     */
 314     gcvVALUE_FLAG_FLOAT_TO_FLOAT16 = 0x0080000,
 315
 316     /*
 317     ** Mask for flag field.
 318     */
 319     gcvVALUE_FLAG_MASK            = 0xFFFF0000,
 320 }
 321 gceVALUE_TYPE;
 322
 323 /* Value unions. */
 324 typedef union _gcuVALUE
 325 {
 326     gctUINT                     uintValue;
 327     gctFIXED_POINT              fixedValue;
 328     gctFLOAT                    floatValue;
 329     gctINT                      intValue;
 330 }
 331 gcuVALUE;
 332
 333
 334
 335
 336 /* Stringizing macro. */
 337 #define gcmSTRING(Value)        #Value
 338
 339 /******************************************************************************\
 340 ******************************* Fixed Point Math *******************************
 341 \******************************************************************************/
 342
 343 #define gcmXMultiply(x1, x2)            gcoMATH_MultiplyFixed(x1, x2)
 344 #define gcmXDivide(x1, x2)              gcoMATH_DivideFixed(x1, x2)
 345 #define gcmXMultiplyDivide(x1, x2, x3)  gcoMATH_MultiplyDivideFixed(x1, x2, x3)
 346
 347 /* 2D Engine profile. */
 348 typedef struct _gcs2D_PROFILE
 349 {
 350     /* Cycle count.
 351        32bit counter incremented every 2D clock cycle.
 352        Wraps back to 0 when the counter overflows.
 353     */
 354     gctUINT32 cycleCount;
 355
 356     /* Pixels rendered by the 2D engine.
 357        Resets to 0 every time it is read. */
 358     gctUINT32 pixelsRendered;
 359 }
 360 gcs2D_PROFILE;
 361
 362 /* Macro to combine four characters into a Charcater Code. */
 363 #define gcmCC(c1, c2, c3, c4) \
 364 ( \
 365     (char) (c1) \
 366     | \
 367     ((char) (c2) <<  8) \
 368     | \
 369     ((char) (c3) << 16) \
 370     | \
 371     ((char) (c4) << 24) \
 372 )
 373
 374 #define gcmPRINTABLE(c)         ((((c) >= ' ') && ((c) <= '}')) ? ((c) != '%' ?  (c) : ' ') : ' ')
 375
 376 #define gcmCC_PRINT(cc) \
 377     gcmPRINTABLE((char) ( (cc)        & 0xFF)), \
 378     gcmPRINTABLE((char) (((cc) >>  8) & 0xFF)), \
 379     gcmPRINTABLE((char) (((cc) >> 16) & 0xFF)), \
 380     gcmPRINTABLE((char) (((cc) >> 24) & 0xFF))
 381
 382 /******************************************************************************\
 383 ****************************** Function Parameters *****************************
 384 \******************************************************************************/
 385
 386 #define IN
 387 #define OUT
 388 #define INOUT
 389 #define OPTIONAL
 390
 391 /******************************************************************************\
 392 ********************************* Status Codes *********************************
 393 \******************************************************************************/
 394
 395 typedef enum _gceSTATUS
 396 {
 397     gcvSTATUS_OK                    =   0,
 398     gcvSTATUS_FALSE                 =   0,
 399     gcvSTATUS_TRUE                  =   1,
 400     gcvSTATUS_NO_MORE_DATA          =   2,
 401     gcvSTATUS_CACHED                =   3,
 402     gcvSTATUS_MIPMAP_TOO_LARGE      =   4,
 403     gcvSTATUS_NAME_NOT_FOUND        =   5,
 404     gcvSTATUS_NOT_OUR_INTERRUPT     =   6,
 405     gcvSTATUS_MISMATCH              =   7,
 406     gcvSTATUS_MIPMAP_TOO_SMALL      =   8,
 407     gcvSTATUS_LARGER                =   9,
 408     gcvSTATUS_SMALLER               =   10,
 409     gcvSTATUS_CHIP_NOT_READY        =   11,
 410     gcvSTATUS_NEED_CONVERSION       =   12,
 411     gcvSTATUS_SKIP                  =   13,
 412     gcvSTATUS_DATA_TOO_LARGE        =   14,
 413     gcvSTATUS_INVALID_CONFIG        =   15,
 414     gcvSTATUS_CHANGED               =   16,
 415     gcvSTATUS_NOT_SUPPORT_DITHER    =   17,
 416     gcvSTATUS_EXECUTED              =   18,
 417     gcvSTATUS_TERMINATE             =   19,
 418
 419     gcvSTATUS_INVALID_ARGUMENT      =   -1,
 420     gcvSTATUS_INVALID_OBJECT        =   -2,
 421     gcvSTATUS_OUT_OF_MEMORY         =   -3,
 422     gcvSTATUS_MEMORY_LOCKED         =   -4,
 423     gcvSTATUS_MEMORY_UNLOCKED       =   -5,
 424     gcvSTATUS_HEAP_CORRUPTED        =   -6,
 425     gcvSTATUS_GENERIC_IO            =   -7,
 426     gcvSTATUS_INVALID_ADDRESS       =   -8,
 427     gcvSTATUS_CONTEXT_LOSSED        =   -9,
 428     gcvSTATUS_TOO_COMPLEX           =   -10,
 429     gcvSTATUS_BUFFER_TOO_SMALL      =   -11,
 430     gcvSTATUS_INTERFACE_ERROR       =   -12,
 431     gcvSTATUS_NOT_SUPPORTED         =   -13,
 432     gcvSTATUS_MORE_DATA             =   -14,
 433     gcvSTATUS_TIMEOUT               =   -15,
 434     gcvSTATUS_OUT_OF_RESOURCES      =   -16,
 435     gcvSTATUS_INVALID_DATA          =   -17,
 436     gcvSTATUS_INVALID_MIPMAP        =   -18,
 437     gcvSTATUS_NOT_FOUND             =   -19,
 438     gcvSTATUS_NOT_ALIGNED           =   -20,
 439     gcvSTATUS_INVALID_REQUEST       =   -21,
 440     gcvSTATUS_GPU_NOT_RESPONDING    =   -22,
 441     gcvSTATUS_TIMER_OVERFLOW        =   -23,
 442     gcvSTATUS_VERSION_MISMATCH      =   -24,
 443     gcvSTATUS_LOCKED                =   -25,
 444     gcvSTATUS_INTERRUPTED           =   -26,
 445     gcvSTATUS_DEVICE                =   -27,
 446     gcvSTATUS_NOT_MULTI_PIPE_ALIGNED =   -28,
 447
 448     /* Linker errors. */
 449     gcvSTATUS_GLOBAL_TYPE_MISMATCH              =   -1000,
 450     gcvSTATUS_TOO_MANY_ATTRIBUTES               =   -1001,
 451     gcvSTATUS_TOO_MANY_UNIFORMS                 =   -1002,
 452     gcvSTATUS_TOO_MANY_VARYINGS                 =   -1003,
 453     gcvSTATUS_UNDECLARED_VARYING                =   -1004,
 454     gcvSTATUS_VARYING_TYPE_MISMATCH             =   -1005,
 455     gcvSTATUS_MISSING_MAIN                      =   -1006,
 456     gcvSTATUS_NAME_MISMATCH                     =   -1007,
 457     gcvSTATUS_INVALID_INDEX                     =   -1008,
 458     gcvSTATUS_UNIFORM_MISMATCH                  =   -1009,
 459     gcvSTATUS_UNSAT_LIB_SYMBOL                  =   -1010,
 460     gcvSTATUS_TOO_MANY_SHADERS                  =   -1011,
 461     gcvSTATUS_LINK_INVALID_SHADERS              =   -1012,
 462     gcvSTATUS_CS_NO_WORKGROUP_SIZE              =   -1013,
 463     gcvSTATUS_LINK_LIB_ERROR                    =   -1014,
 464     gcvSTATUS_SHADER_VERSION_MISMATCH           =   -1015,
 465     gcvSTATUS_TOO_MANY_INSTRUCTION              =   -1016,
 466     gcvSTATUS_SSBO_MISMATCH                     =   -1017,
 467     gcvSTATUS_TOO_MANY_OUTPUT                   =   -1018,
 468     gcvSTATUS_TOO_MANY_INPUT                    =   -1019,
 469     gcvSTATUS_NOT_SUPPORT_CL                    =   -1020,
 470     gcvSTATUS_NOT_SUPPORT_INTEGER               =   -1021,
 471     gcvSTATUS_UNIFORM_TYPE_MISMATCH             =   -1022,
 472     gcvSTATUS_TOO_MANY_SAMPLER                  =   -1023,
 473
 474     /* Compiler errors. */
 475     gcvSTATUS_COMPILER_FE_PREPROCESSOR_ERROR    =   -2000,
 476     gcvSTATUS_COMPILER_FE_PARSER_ERROR          =   -2001,
 477
 478     /* Recompilation Errors */
 479     gcvSTATUS_RECOMPILER_CONVERT_UNIMPLEMENTED  =   -3000,
 480 }
 481 gceSTATUS;
 482
 483 /******************************************************************************\
 484 ********************************* Status Macros ********************************
 485 \******************************************************************************/
 486
 487 #define gcmIS_ERROR(status)         (status < 0)
 488 #define gcmNO_ERROR(status)         (status >= 0)
 489 #define gcmIS_SUCCESS(status)       (status == gcvSTATUS_OK)
 490
 491 /******************************************************************************\
 492 ********************************* Field Macros *********************************
 493 \******************************************************************************/
 494
 495 #define __gcmSTART(reg_field) \
 496     (0 ? reg_field)
 497
 498 #define __gcmEND(reg_field) \
 499     (1 ? reg_field)
 500
 501 #define __gcmGETSIZE(reg_field) \
 502     (__gcmEND(reg_field) - __gcmSTART(reg_field) + 1)
 503
 504 #define __gcmALIGN(data, reg_field) \
 505     (((gctUINT32) (data)) << __gcmSTART(reg_field))
 506
 507 #define __gcmMASK(reg_field) \
 508     ((gctUINT32) ((__gcmGETSIZE(reg_field) == 32) \
 509         ?  ~0 \
 510         : (~(~0 << __gcmGETSIZE(reg_field)))))
 511
 512 /*******************************************************************************
 513 **
 514 **  gcmFIELDMASK
 515 **
 516 **      Get aligned field mask.
 517 **
 518 **  ARGUMENTS:
 519 **
 520 **      reg     Name of register.
 521 **      field   Name of field within register.
 522 */
 523 #define gcmFIELDMASK(reg, field) \
 524 ( \
 525     __gcmALIGN(__gcmMASK(reg##_##field), reg##_##field) \
 526 )
 527
 528 /*******************************************************************************
 529 **
 530 **  gcmGETFIELD
 531 **
 532 **      Extract the value of a field from specified data.
 533 **
 534 **  ARGUMENTS:
 535 **
 536 **      data    Data value.
 537 **      reg     Name of register.
 538 **      field   Name of field within register.
 539 */
 540 #define gcmGETFIELD(data, reg, field) \
 541 ( \
 542     ((((gctUINT32) (data)) >> __gcmSTART(reg##_##field)) \
 543         & __gcmMASK(reg##_##field)) \
 544 )
 545
 546 /*******************************************************************************
 547 **
 548 **  gcmSETFIELD
 549 **
 550 **      Set the value of a field within specified data.
 551 **
 552 **  ARGUMENTS:
 553 **
 554 **      data    Data value.
 555 **      reg     Name of register.
 556 **      field   Name of field within register.
 557 **      value   Value for field.
 558 */
 559 #define gcmSETFIELD(data, reg, field, value) \
 560 ( \
 561     (((gctUINT32) (data)) \
 562         & ~__gcmALIGN(__gcmMASK(reg##_##field), reg##_##field)) \
 563         |  __gcmALIGN((gctUINT32) (value) \
 564             & __gcmMASK(reg##_##field), reg##_##field) \
 565 )
 566
 567 /*******************************************************************************
 568 **
 569 **  gcmSETFIELDVALUE
 570 **
 571 **      Set the value of a field within specified data with a
 572 **      predefined value.
 573 **
 574 **  ARGUMENTS:
 575 **
 576 **      data    Data value.
 577 **      reg     Name of register.
 578 **      field   Name of field within register.
 579 **      value   Name of the value within the field.
 580 */
 581 #define gcmSETFIELDVALUE(data, reg, field, value) \
 582 ( \
 583     (((gctUINT32) (data)) \
 584         & ~__gcmALIGN(__gcmMASK(reg##_##field), reg##_##field)) \
 585         |  __gcmALIGN(reg##_##field##_##value \
 586             & __gcmMASK(reg##_##field), reg##_##field) \
 587 )
 588
 589 /*******************************************************************************
 590 **
 591 **  gcmGETMASKEDFIELDMASK
 592 **
 593 **      Determine field mask of a masked field.
 594 **
 595 **  ARGUMENTS:
 596 **
 597 **      reg     Name of register.
 598 **      field   Name of field within register.
 599 */
 600 #define gcmGETMASKEDFIELDMASK(reg, field) \
 601 ( \
 602     gcmSETFIELD(0, reg,          field, ~0) | \
 603     gcmSETFIELD(0, reg, MASK_ ## field, ~0)   \
 604 )
 605
 606 /*******************************************************************************
 607 **
 608 **  gcmSETMASKEDFIELD
 609 **
 610 **      Set the value of a masked field with specified data.
 611 **
 612 **  ARGUMENTS:
 613 **
 614 **      reg     Name of register.
 615 **      field   Name of field within register.
 616 **      value   Value for field.
 617 */
 618 #define gcmSETMASKEDFIELD(reg, field, value) \
 619 ( \
 620     gcmSETFIELD     (~0, reg,          field, value) & \
 621     gcmSETFIELDVALUE(~0, reg, MASK_ ## field, ENABLED) \
 622 )
 623
 624 /*******************************************************************************
 625 **
 626 **  gcmSETMASKEDFIELDVALUE
 627 **
 628 **      Set the value of a masked field with specified data.
 629 **
 630 **  ARGUMENTS:
 631 **
 632 **      reg     Name of register.
 633 **      field   Name of field within register.
 634 **      value   Value for field.
 635 */
 636 #define gcmSETMASKEDFIELDVALUE(reg, field, value) \
 637 ( \
 638     gcmSETFIELDVALUE(~0, reg,          field, value) & \
 639     gcmSETFIELDVALUE(~0, reg, MASK_ ## field, ENABLED) \
 640 )
 641
 642 /*******************************************************************************
 643 **
 644 **  gcmVERIFYFIELDVALUE
 645 **
 646 **      Verify if the value of a field within specified data equals a
 647 **      predefined value.
 648 **
 649 **  ARGUMENTS:
 650 **
 651 **      data    Data value.
 652 **      reg     Name of register.
 653 **      field   Name of field within register.
 654 **      value   Name of the value within the field.
 655 */
 656 #define gcmVERIFYFIELDVALUE(data, reg, field, value) \
 657 ( \
 658     (((gctUINT32) (data)) >> __gcmSTART(reg##_##field) & \
 659                              __gcmMASK(reg##_##field)) \
 660         == \
 661     (reg##_##field##_##value & __gcmMASK(reg##_##field)) \
 662 )
 663
 664 /*******************************************************************************
 665 **  Bit field macros.
 666 */
 667
 668 #define __gcmSTARTBIT(Field) \
 669     ( 1 ? Field )
 670
 671 #define __gcmBITSIZE(Field) \
 672     ( 0 ? Field )
 673
 674 #define __gcmBITMASK(Field) \
 675 ( \
 676     (1 << __gcmBITSIZE(Field)) - 1 \
 677 )
 678
 679 #define gcmGETBITS(Value, Type, Field) \
 680 ( \
 681     ( ((Type) (Value)) >> __gcmSTARTBIT(Field) ) \
 682     & \
 683     __gcmBITMASK(Field) \
 684 )
 685
 686 #define gcmSETBITS(Value, Type, Field, NewValue) \
 687 ( \
 688     ( ((Type) (Value)) \
 689     & ~(__gcmBITMASK(Field) << __gcmSTARTBIT(Field)) \
 690     ) \
 691     | \
 692     ( ( ((Type) (NewValue)) \
 693       & __gcmBITMASK(Field) \
 694       ) << __gcmSTARTBIT(Field) \
 695     ) \
 696 )
 697
 698 /*******************************************************************************
 699 **
 700 **  gcmISINREGRANGE
 701 **
 702 **      Verify whether the specified address is in the register range.
 703 **
 704 **  ARGUMENTS:
 705 **
 706 **      Address Address to be verified.
 707 **      Name    Name of a register.
 708 */
 709
 710 #define gcmISINREGRANGE(Address, Name) \
 711 ( \
 712     ((Address & (~0U << Name ## _LSB)) == (Name ## _Address >> 2)) \
 713 )
 714
 715 /******************************************************************************\
 716 ******************************** Ceiling Macro ********************************
 717 \******************************************************************************/
 718 #define gcmCEIL(x) ((x - (gctUINT32)x) == 0 ? (gctUINT32)x : (gctUINT32)x + 1)
 719
 720 /******************************************************************************\
 721 ******************************** Min/Max Macros ********************************
 722 \******************************************************************************/
 723
 724 #define gcmMIN(x, y)            (((x) <= (y)) ?  (x) :  (y))
 725 #define gcmMAX(x, y)            (((x) >= (y)) ?  (x) :  (y))
 726 #define gcmCLAMP(x, min, max)   (((x) < (min)) ? (min) : \
 727                                  ((x) > (max)) ? (max) : (x))
 728 #define gcmABS(x)               (((x) < 0)    ? -(x) :  (x))
 729 #define gcmNEG(x)               (((x) < 0)    ?  (x) : -(x))
 730
 731 /******************************************************************************\
 732 ******************************** Bit Macro ********************************
 733 \******************************************************************************/
 734 #define gcmBITSET(x, y)         ((x) & (y))
 735 /*******************************************************************************
 736 **
 737 **  gcmPTR2INT
 738 **
 739 **      Convert a pointer to an integer value.
 740 **
 741 **  ARGUMENTS:
 742 **
 743 **      p       Pointer value.
 744 */
 745 #define gcmPTR2INT(p) \
 746 ( \
 747     (gctUINTPTR_T) (p) \
 748 )
 749
 750 #define gcmPTR2INT32(p) \
 751 ( \
 752     (gctUINT32)(gctUINTPTR_T) (p) \
 753 )
 754
 755 /*******************************************************************************
 756 **
 757 **  gcmINT2PTR
 758 **
 759 **      Convert an integer value into a pointer.
 760 **
 761 **  ARGUMENTS:
 762 **
 763 **      v       Integer value.
 764 */
 765
 766 #define gcmINT2PTR(i) \
 767 ( \
 768     (gctPOINTER) (gctUINTPTR_T)(i) \
 769 )
 770
 771 /*******************************************************************************
 772 **
 773 **  gcmOFFSETOF
 774 **
 775 **      Compute the byte offset of a field inside a structure.
 776 **
 777 **  ARGUMENTS:
 778 **
 779 **      s       Structure name.
 780 **      field   Field name.
 781 */
 782 #define gcmOFFSETOF(s, field) \
 783 ( \
 784     gcmPTR2INT32(& (((struct s *) 0)->field)) \
 785 )
 786
 787 /*******************************************************************************
 788 **
 789 ** gcmSWAB32
 790 **
 791 **      Return a value with all bytes in the 32 bit argument swapped.
 792 */
 793 #define gcmSWAB32(x) ((gctUINT32)( \
 794         (((gctUINT32)(x) & (gctUINT32)0x000000FFUL) << 24) | \
 795         (((gctUINT32)(x) & (gctUINT32)0x0000FF00UL) << 8)  | \
 796         (((gctUINT32)(x) & (gctUINT32)0x00FF0000UL) >> 8)  | \
 797         (((gctUINT32)(x) & (gctUINT32)0xFF000000UL) >> 24)))
 798
 799 /*******************************************************************************
 800 ***** Database ****************************************************************/
 801
 802 typedef struct _gcsDATABASE_COUNTERS
 803 {
 804     /* Number of currently allocated bytes. */
 805     gctUINT64                   bytes;
 806
 807     /* Maximum number of bytes allocated (memory footprint). */
 808     gctUINT64                   maxBytes;
 809
 810     /* Total number of bytes allocated. */
 811     gctUINT64                   totalBytes;
 812 }
 813 gcsDATABASE_COUNTERS;
 814
 815 typedef struct _gcuDATABASE_INFO
 816 {
 817     /* Counters. */
 818     gcsDATABASE_COUNTERS        counters;
 819
 820     /* Time value. */
 821     gctUINT64                   time;
 822 }
 823 gcuDATABASE_INFO;
 824
 825 /*******************************************************************************
 826 ***** Frame database **********************************************************/
 827
 828 /* gcsHAL_FRAME_INFO */
 829 typedef struct _gcsHAL_FRAME_INFO
 830 {
 831     /* Current timer tick. */
 832     OUT gctUINT64               ticks;
 833
 834     /* Bandwidth counters. */
 835     OUT gctUINT                 readBytes8[8];
 836     OUT gctUINT                 writeBytes8[8];
 837
 838     /* Counters. */
 839     OUT gctUINT                 cycles[8];
 840     OUT gctUINT                 idleCycles[8];
 841     OUT gctUINT                 mcCycles[8];
 842     OUT gctUINT                 readRequests[8];
 843     OUT gctUINT                 writeRequests[8];
 844
 845     /* 3D counters. */
 846     OUT gctUINT                 vertexCount;
 847     OUT gctUINT                 primitiveCount;
 848     OUT gctUINT                 rejectedPrimitives;
 849     OUT gctUINT                 culledPrimitives;
 850     OUT gctUINT                 clippedPrimitives;
 851     OUT gctUINT                 outPrimitives;
 852     OUT gctUINT                 inPrimitives;
 853     OUT gctUINT                 culledQuadCount;
 854     OUT gctUINT                 totalQuadCount;
 855     OUT gctUINT                 quadCount;
 856     OUT gctUINT                 totalPixelCount;
 857
 858     /* PE counters. */
 859     OUT gctUINT                 colorKilled[8];
 860     OUT gctUINT                 colorDrawn[8];
 861     OUT gctUINT                 depthKilled[8];
 862     OUT gctUINT                 depthDrawn[8];
 863
 864     /* Shader counters. */
 865     OUT gctUINT                 shaderCycles;
 866     OUT gctUINT                 vsInstructionCount;
 867     OUT gctUINT                 vsTextureCount;
 868     OUT gctUINT                 psInstructionCount;
 869     OUT gctUINT                 psTextureCount;
 870
 871     /* Texture counters. */
 872     OUT gctUINT                 bilinearRequests;
 873     OUT gctUINT                 trilinearRequests;
 874     OUT gctUINT                 txBytes8;
 875     OUT gctUINT                 txHitCount;
 876     OUT gctUINT                 txMissCount;
 877 }
 878 gcsHAL_FRAME_INFO;
 879
 880 #if gcdLINK_QUEUE_SIZE
 881 typedef struct _gckLINKDATA * gckLINKDATA;
 882 struct _gckLINKDATA
 883 {
 884     gctUINT32                   start;
 885     gctUINT32                   end;
 886     gctUINT32                   pid;
 887 };
 888
 889 typedef struct _gckLINKQUEUE * gckLINKQUEUE;
 890 struct _gckLINKQUEUE
 891 {
 892     struct _gckLINKDATA         data[gcdLINK_QUEUE_SIZE];
 893     gctUINT32                   rear;
 894     gctUINT32                   front;
 895     gctUINT32                   count;
 896 };
 897 #endif
 898
 899 #define gcdENTRY_QUEUE_SIZE 256
 900 typedef struct _gckENTRYDATA * gckENTRYDATA;
 901 struct _gckENTRYDATA
 902 {
 903     gctUINT32                   physical;
 904     gctUINT32                   bytes;
 905 };
 906
 907 typedef struct _gckENTRYQUEUE * gckENTRYQUEUE;
 908 struct _gckENTRYQUEUE
 909 {
 910     struct _gckENTRYDATA        data[gcdENTRY_QUEUE_SIZE];
 911     gctUINT32                   rear;
 912     gctUINT32                   front;
 913     gctUINT32                   count;
 914 };
 915
 916 typedef enum _gceTRACEMODE
 917 {
 918     gcvTRACEMODE_NONE     = 0,
 919     gcvTRACEMODE_FULL     = 1,
 920     gcvTRACEMODE_LOGGER   = 2,
 921     gcvTRACEMODE_PRE      = 3,
 922     gcvTRACEMODE_POST     = 4,
 923     gcvTRACEMODE_SYSTRACE = 5,
 924
 925 } gceTRACEMODE;
 926
 927
 928 #ifdef __cplusplus
 929 }
 930 #endif
 931
 932 #endif /* __gc_hal_types_h_ */