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

   1 /****************************************************************************
   2 *
   3 *    Copyright (C) 2005 - 2013 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_h_
  23 #define __gc_hal_h_
  24
  25 #include "gc_hal_rename.h"
  26 #include "gc_hal_types.h"
  27 #include "gc_hal_enum.h"
  28 #include "gc_hal_base.h"
  29 #include "gc_hal_profiler.h"
  30 #include "gc_hal_driver.h"
  31 #ifndef VIVANTE_NO_3D
  32 #include "gc_hal_statistics.h"
  33 #endif
  34
  35 #ifdef __cplusplus
  36 extern "C" {
  37 #endif
  38
  39 /******************************************************************************\
  40 ******************************* Alignment Macros *******************************
  41 \******************************************************************************/
  42
  43 #define gcmALIGN(n, align) \
  44 ( \
  45     ((n) + ((align) - 1)) & ~((align) - 1) \
  46 )
  47
  48 #define gcmALIGN_BASE(n, align) \
  49 ( \
  50     ((n) & ~((align) - 1)) \
  51 )
  52
  53 /******************************************************************************\
  54 ***************************** Element Count Macro *****************************
  55 \******************************************************************************/
  56
  57 #define gcmSIZEOF(a) \
  58 ( \
  59     (gctSIZE_T) (sizeof(a)) \
  60 )
  61
  62 #define gcmCOUNTOF(a) \
  63 ( \
  64     sizeof(a) / sizeof(a[0]) \
  65 )
  66
  67 /******************************************************************************\
  68 ********************************* Cast Macro **********************************
  69 \******************************************************************************/
  70 #define gcmNAME_TO_PTR(na) \
  71         gckKERNEL_QueryPointerFromName(kernel, gcmALL_TO_UINT32(na))
  72
  73 #define gcmPTR_TO_NAME(ptr) \
  74         gckKERNEL_AllocateNameFromPointer(kernel, ptr)
  75
  76 #define gcmRELEASE_NAME(na) \
  77         gckKERNEL_DeleteName(kernel, gcmALL_TO_UINT32(na))
  78
  79 #ifdef __LP64__
  80
  81 #define gcmALL_TO_UINT32(t) \
  82 ( \
  83     (gctUINT32) (gctUINTPTR_T) (t)\
  84 )
  85
  86 #define gcmPTR_TO_UINT64(p) \
  87 ( \
  88     (gctUINT64) (p)\
  89 )
  90
  91 #define gcmUINT64_TO_PTR(u) \
  92 ( \
  93     (gctPOINTER) (u)\
  94 )
  95
  96 #else /* 32 bit */
  97
  98 #define gcmALL_TO_UINT32(t) \
  99 ( \
 100     (gctUINT32) (t)\
 101 )
 102
 103 #define gcmPTR_TO_UINT64(p) \
 104 ( \
 105     (gctUINT64) (gctUINTPTR_T) (p)\
 106 )
 107
 108 #define gcmUINT64_TO_PTR(u) \
 109 ( \
 110     (gctPOINTER) (gctUINTPTR_T) (u)\
 111 )
 112
 113 #endif
 114
 115 #define gcmUINT64_TO_TYPE(u, t) \
 116 ( \
 117     (t) (gctUINTPTR_T) (u)\
 118 )
 119
 120 /******************************************************************************\
 121 ******************************** Useful Macro *********************************
 122 \******************************************************************************/
 123
 124 #define gcvINVALID_ADDRESS          ~0U
 125
 126 /******************************************************************************\
 127 ******************************** gcsOBJECT Object *******************************
 128 \******************************************************************************/
 129
 130 /* Type of objects. */
 131 typedef enum _gceOBJECT_TYPE
 132 {
 133     gcvOBJ_UNKNOWN              = 0,
 134     gcvOBJ_2D                   = gcmCC('2','D',' ',' '),
 135     gcvOBJ_3D                   = gcmCC('3','D',' ',' '),
 136     gcvOBJ_ATTRIBUTE            = gcmCC('A','T','T','R'),
 137     gcvOBJ_BRUSHCACHE           = gcmCC('B','R','U','$'),
 138     gcvOBJ_BRUSHNODE            = gcmCC('B','R','U','n'),
 139     gcvOBJ_BRUSH                = gcmCC('B','R','U','o'),
 140     gcvOBJ_BUFFER               = gcmCC('B','U','F','R'),
 141     gcvOBJ_COMMAND              = gcmCC('C','M','D',' '),
 142     gcvOBJ_COMMANDBUFFER        = gcmCC('C','M','D','B'),
 143     gcvOBJ_CONTEXT              = gcmCC('C','T','X','T'),
 144     gcvOBJ_DEVICE               = gcmCC('D','E','V',' '),
 145     gcvOBJ_DUMP                 = gcmCC('D','U','M','P'),
 146     gcvOBJ_EVENT                = gcmCC('E','V','N','T'),
 147     gcvOBJ_FUNCTION             = gcmCC('F','U','N','C'),
 148     gcvOBJ_HAL                  = gcmCC('H','A','L',' '),
 149     gcvOBJ_HARDWARE             = gcmCC('H','A','R','D'),
 150     gcvOBJ_HEAP                 = gcmCC('H','E','A','P'),
 151     gcvOBJ_INDEX                = gcmCC('I','N','D','X'),
 152     gcvOBJ_INTERRUPT            = gcmCC('I','N','T','R'),
 153     gcvOBJ_KERNEL               = gcmCC('K','E','R','N'),
 154     gcvOBJ_KERNEL_FUNCTION      = gcmCC('K','F','C','N'),
 155     gcvOBJ_MEMORYBUFFER         = gcmCC('M','E','M','B'),
 156     gcvOBJ_MMU                  = gcmCC('M','M','U',' '),
 157     gcvOBJ_OS                   = gcmCC('O','S',' ',' '),
 158     gcvOBJ_OUTPUT               = gcmCC('O','U','T','P'),
 159     gcvOBJ_PAINT                = gcmCC('P','N','T',' '),
 160     gcvOBJ_PATH                 = gcmCC('P','A','T','H'),
 161     gcvOBJ_QUEUE                = gcmCC('Q','U','E',' '),
 162     gcvOBJ_SAMPLER              = gcmCC('S','A','M','P'),
 163     gcvOBJ_SHADER               = gcmCC('S','H','D','R'),
 164     gcvOBJ_STREAM               = gcmCC('S','T','R','M'),
 165     gcvOBJ_SURF                 = gcmCC('S','U','R','F'),
 166     gcvOBJ_TEXTURE              = gcmCC('T','X','T','R'),
 167     gcvOBJ_UNIFORM              = gcmCC('U','N','I','F'),
 168     gcvOBJ_VARIABLE             = gcmCC('V','A','R','I'),
 169     gcvOBJ_VERTEX               = gcmCC('V','R','T','X'),
 170     gcvOBJ_VIDMEM               = gcmCC('V','M','E','M'),
 171     gcvOBJ_VG                   = gcmCC('V','G',' ',' '),
 172 }
 173 gceOBJECT_TYPE;
 174
 175 /* gcsOBJECT object defintinon. */
 176 typedef struct _gcsOBJECT
 177 {
 178     /* Type of an object. */
 179     gceOBJECT_TYPE              type;
 180 }
 181 gcsOBJECT;
 182
 183 typedef struct _gckHARDWARE *       gckHARDWARE;
 184
 185 /* CORE flags. */
 186 typedef enum _gceCORE
 187 {
 188     gcvCORE_MAJOR       = 0x0,
 189     gcvCORE_2D          = 0x1,
 190     gcvCORE_VG          = 0x2
 191 }
 192 gceCORE;
 193
 194 #define gcdMAX_GPU_COUNT               3
 195
 196 /*******************************************************************************
 197 **
 198 **  gcmVERIFY_OBJECT
 199 **
 200 **      Assert if an object is invalid or is not of the specified type.  If the
 201 **      object is invalid or not of the specified type, gcvSTATUS_INVALID_OBJECT
 202 **      will be returned from the current function.  In retail mode this macro
 203 **      does nothing.
 204 **
 205 **  ARGUMENTS:
 206 **
 207 **      obj     Object to test.
 208 **      t       Expected type of the object.
 209 */
 210 #if gcmIS_DEBUG(gcdDEBUG_TRACE)
 211 #define _gcmVERIFY_OBJECT(prefix, obj, t) \
 212     if ((obj) == gcvNULL) \
 213     { \
 214         prefix##TRACE(gcvLEVEL_ERROR, \
 215                       #prefix "VERIFY_OBJECT failed: NULL"); \
 216         prefix##TRACE(gcvLEVEL_ERROR, "  expected: %c%c%c%c", \
 217                       gcmCC_PRINT(t)); \
 218         prefix##ASSERT((obj) != gcvNULL); \
 219         prefix##FOOTER_ARG("status=%d", gcvSTATUS_INVALID_OBJECT); \
 220         return gcvSTATUS_INVALID_OBJECT; \
 221     } \
 222     else if (((gcsOBJECT*) (obj))->type != t) \
 223     { \
 224         prefix##TRACE(gcvLEVEL_ERROR, \
 225                       #prefix "VERIFY_OBJECT failed: %c%c%c%c", \
 226                       gcmCC_PRINT(((gcsOBJECT*) (obj))->type)); \
 227         prefix##TRACE(gcvLEVEL_ERROR, "  expected: %c%c%c%c", \
 228                       gcmCC_PRINT(t)); \
 229         prefix##ASSERT(((gcsOBJECT*)(obj))->type == t); \
 230         prefix##FOOTER_ARG("status=%d", gcvSTATUS_INVALID_OBJECT); \
 231         return gcvSTATUS_INVALID_OBJECT; \
 232     }
 233
 234 #   define gcmVERIFY_OBJECT(obj, t)     _gcmVERIFY_OBJECT(gcm, obj, t)
 235 #   define gcmkVERIFY_OBJECT(obj, t)    _gcmVERIFY_OBJECT(gcmk, obj, t)
 236 #else
 237 #   define gcmVERIFY_OBJECT(obj, t)     do {} while (gcvFALSE)
 238 #   define gcmkVERIFY_OBJECT(obj, t)    do {} while (gcvFALSE)
 239 #endif
 240
 241 /******************************************************************************/
 242 /*VERIFY_OBJECT if special return expected*/
 243 /******************************************************************************/
 244 #ifndef EGL_API_ANDROID
 245 #   define _gcmVERIFY_OBJECT_RETURN(prefix, obj, t, retVal) \
 246         do \
 247         { \
 248             if ((obj) == gcvNULL) \
 249             { \
 250                 prefix##PRINT_VERSION(); \
 251                 prefix##TRACE(gcvLEVEL_ERROR, \
 252                               #prefix "VERIFY_OBJECT_RETURN failed: NULL"); \
 253                 prefix##TRACE(gcvLEVEL_ERROR, "  expected: %c%c%c%c", \
 254                               gcmCC_PRINT(t)); \
 255                 prefix##ASSERT((obj) != gcvNULL); \
 256                 prefix##FOOTER_ARG("retVal=%d", retVal); \
 257                 return retVal; \
 258             } \
 259             else if (((gcsOBJECT*) (obj))->type != t) \
 260             { \
 261                 prefix##PRINT_VERSION(); \
 262                 prefix##TRACE(gcvLEVEL_ERROR, \
 263                               #prefix "VERIFY_OBJECT_RETURN failed: %c%c%c%c", \
 264                               gcmCC_PRINT(((gcsOBJECT*) (obj))->type)); \
 265                 prefix##TRACE(gcvLEVEL_ERROR, "  expected: %c%c%c%c", \
 266                               gcmCC_PRINT(t)); \
 267                 prefix##ASSERT(((gcsOBJECT*)(obj))->type == t); \
 268                 prefix##FOOTER_ARG("retVal=%d", retVal); \
 269                 return retVal; \
 270             } \
 271         } \
 272         while (gcvFALSE)
 273 #   define gcmVERIFY_OBJECT_RETURN(obj, t, retVal) \
 274                             _gcmVERIFY_OBJECT_RETURN(gcm, obj, t, retVal)
 275 #   define gcmkVERIFY_OBJECT_RETURN(obj, t, retVal) \
 276                             _gcmVERIFY_OBJECT_RETURN(gcmk, obj, t, retVal)
 277 #else
 278 #   define gcmVERIFY_OBJECT_RETURN(obj, t)     do {} while (gcvFALSE)
 279 #   define gcmVERIFY_OBJECT_RETURN(obj, t)    do {} while (gcvFALSE)
 280 #endif
 281
 282 /******************************************************************************\
 283 ********************************** gckOS Object *********************************
 284 \******************************************************************************/
 285
 286 /* Construct a new gckOS object. */
 287 gceSTATUS
 288 gckOS_Construct(
 289     IN gctPOINTER Context,
 290     OUT gckOS * Os
 291     );
 292
 293 /* Destroy an gckOS object. */
 294 gceSTATUS
 295 gckOS_Destroy(
 296     IN gckOS Os
 297     );
 298
 299 /* Query the video memory. */
 300 gceSTATUS
 301 gckOS_QueryVideoMemory(
 302     IN gckOS Os,
 303     OUT gctPHYS_ADDR * InternalAddress,
 304     OUT gctSIZE_T * InternalSize,
 305     OUT gctPHYS_ADDR * ExternalAddress,
 306     OUT gctSIZE_T * ExternalSize,
 307     OUT gctPHYS_ADDR * ContiguousAddress,
 308     OUT gctSIZE_T * ContiguousSize
 309     );
 310
 311 /* Allocate memory from the heap. */
 312 gceSTATUS
 313 gckOS_Allocate(
 314     IN gckOS Os,
 315     IN gctSIZE_T Bytes,
 316     OUT gctPOINTER * Memory
 317     );
 318
 319 /* Free allocated memory. */
 320 gceSTATUS
 321 gckOS_Free(
 322     IN gckOS Os,
 323     IN gctPOINTER Memory
 324     );
 325
 326 /* Wrapper for allocation memory.. */
 327 gceSTATUS
 328 gckOS_AllocateMemory(
 329     IN gckOS Os,
 330     IN gctSIZE_T Bytes,
 331     OUT gctPOINTER * Memory
 332     );
 333
 334 /* Wrapper for freeing memory. */
 335 gceSTATUS
 336 gckOS_FreeMemory(
 337     IN gckOS Os,
 338     IN gctPOINTER Memory
 339     );
 340
 341 /* Allocate paged memory. */
 342 gceSTATUS
 343 gckOS_AllocatePagedMemory(
 344     IN gckOS Os,
 345     IN gctSIZE_T Bytes,
 346     OUT gctPHYS_ADDR * Physical
 347     );
 348
 349 /* Allocate paged memory. */
 350 gceSTATUS
 351 gckOS_AllocatePagedMemoryEx(
 352     IN gckOS Os,
 353     IN gctBOOL Contiguous,
 354     IN gctSIZE_T Bytes,
 355     OUT gctPHYS_ADDR * Physical
 356     );
 357
 358 /* Lock pages. */
 359 gceSTATUS
 360 gckOS_LockPages(
 361     IN gckOS Os,
 362     IN gctPHYS_ADDR Physical,
 363     IN gctSIZE_T Bytes,
 364     IN gctBOOL Cacheable,
 365     OUT gctPOINTER * Logical,
 366     OUT gctSIZE_T * PageCount
 367     );
 368
 369 /* Map pages. */
 370 gceSTATUS
 371 gckOS_MapPages(
 372     IN gckOS Os,
 373     IN gctPHYS_ADDR Physical,
 374 #ifdef __QNXNTO__
 375     IN gctPOINTER Logical,
 376 #endif
 377     IN gctSIZE_T PageCount,
 378     IN gctPOINTER PageTable
 379     );
 380
 381 /* Map pages. */
 382 gceSTATUS
 383 gckOS_MapPagesEx(
 384     IN gckOS Os,
 385     IN gceCORE Core,
 386     IN gctPHYS_ADDR Physical,
 387 #ifdef __QNXNTO__
 388     IN gctPOINTER Logical,
 389 #endif
 390     IN gctSIZE_T PageCount,
 391     IN gctPOINTER PageTable
 392     );
 393
 394 /* Unlock pages. */
 395 gceSTATUS
 396 gckOS_UnlockPages(
 397     IN gckOS Os,
 398     IN gctPHYS_ADDR Physical,
 399     IN gctSIZE_T Bytes,
 400     IN gctPOINTER Logical
 401     );
 402
 403 /* Free paged memory. */
 404 gceSTATUS
 405 gckOS_FreePagedMemory(
 406     IN gckOS Os,
 407     IN gctPHYS_ADDR Physical,
 408     IN gctSIZE_T Bytes
 409     );
 410
 411 /* Allocate non-paged memory. */
 412 gceSTATUS
 413 gckOS_AllocateNonPagedMemory(
 414     IN gckOS Os,
 415     IN gctBOOL InUserSpace,
 416     IN OUT gctSIZE_T * Bytes,
 417     OUT gctPHYS_ADDR * Physical,
 418     OUT gctPOINTER * Logical
 419     );
 420
 421 /* Free non-paged memory. */
 422 gceSTATUS
 423 gckOS_FreeNonPagedMemory(
 424     IN gckOS Os,
 425     IN gctSIZE_T Bytes,
 426     IN gctPHYS_ADDR Physical,
 427     IN gctPOINTER Logical
 428     );
 429
 430 /* Allocate contiguous memory. */
 431 gceSTATUS
 432 gckOS_AllocateContiguous(
 433     IN gckOS Os,
 434     IN gctBOOL InUserSpace,
 435     IN OUT gctSIZE_T * Bytes,
 436     OUT gctPHYS_ADDR * Physical,
 437     OUT gctPOINTER * Logical
 438     );
 439
 440 /* Free contiguous memory. */
 441 gceSTATUS
 442 gckOS_FreeContiguous(
 443     IN gckOS Os,
 444     IN gctPHYS_ADDR Physical,
 445     IN gctPOINTER Logical,
 446     IN gctSIZE_T Bytes
 447     );
 448
 449 /* Get the number fo bytes per page. */
 450 gceSTATUS
 451 gckOS_GetPageSize(
 452     IN gckOS Os,
 453     OUT gctSIZE_T * PageSize
 454     );
 455
 456 /* Get the physical address of a corresponding logical address. */
 457 gceSTATUS
 458 gckOS_GetPhysicalAddress(
 459     IN gckOS Os,
 460     IN gctPOINTER Logical,
 461     OUT gctUINT32 * Address
 462     );
 463
 464 /* Get the physical address of a corresponding logical address. */
 465 gceSTATUS
 466 gckOS_GetPhysicalAddressProcess(
 467     IN gckOS Os,
 468     IN gctPOINTER Logical,
 469     IN gctUINT32 ProcessID,
 470     OUT gctUINT32 * Address
 471     );
 472
 473 /* Map physical memory. */
 474 gceSTATUS
 475 gckOS_MapPhysical(
 476     IN gckOS Os,
 477     IN gctUINT32 Physical,
 478     IN gctSIZE_T Bytes,
 479     OUT gctPOINTER * Logical
 480     );
 481
 482 /* Unmap previously mapped physical memory. */
 483 gceSTATUS
 484 gckOS_UnmapPhysical(
 485     IN gckOS Os,
 486     IN gctPOINTER Logical,
 487     IN gctSIZE_T Bytes
 488     );
 489
 490 /* Read data from a hardware register. */
 491 gceSTATUS
 492 gckOS_ReadRegister(
 493     IN gckOS Os,
 494     IN gctUINT32 Address,
 495     OUT gctUINT32 * Data
 496     );
 497
 498 /* Read data from a hardware register. */
 499 gceSTATUS
 500 gckOS_ReadRegisterEx(
 501     IN gckOS Os,
 502     IN gceCORE Core,
 503     IN gctUINT32 Address,
 504     OUT gctUINT32 * Data
 505     );
 506
 507 /* Write data to a hardware register. */
 508 gceSTATUS
 509 gckOS_WriteRegister(
 510     IN gckOS Os,
 511     IN gctUINT32 Address,
 512     IN gctUINT32 Data
 513     );
 514
 515 /* Write data to a hardware register. */
 516 gceSTATUS
 517 gckOS_WriteRegisterEx(
 518     IN gckOS Os,
 519     IN gceCORE Core,
 520     IN gctUINT32 Address,
 521     IN gctUINT32 Data
 522     );
 523
 524 /* Write data to a 32-bit memory location. */
 525 gceSTATUS
 526 gckOS_WriteMemory(
 527     IN gckOS Os,
 528     IN gctPOINTER Address,
 529     IN gctUINT32 Data
 530     );
 531
 532 /* Map physical memory into the process space. */
 533 gceSTATUS
 534 gckOS_MapMemory(
 535     IN gckOS Os,
 536     IN gctPHYS_ADDR Physical,
 537     IN gctSIZE_T Bytes,
 538     OUT gctPOINTER * Logical
 539     );
 540
 541 /* Unmap physical memory from the specified process space. */
 542 gceSTATUS
 543 gckOS_UnmapMemoryEx(
 544     IN gckOS Os,
 545     IN gctPHYS_ADDR Physical,
 546     IN gctSIZE_T Bytes,
 547     IN gctPOINTER Logical,
 548     IN gctUINT32 PID
 549     );
 550
 551 /* Unmap physical memory from the process space. */
 552 gceSTATUS
 553 gckOS_UnmapMemory(
 554     IN gckOS Os,
 555     IN gctPHYS_ADDR Physical,
 556     IN gctSIZE_T Bytes,
 557     IN gctPOINTER Logical
 558     );
 559
 560 /* Unmap user logical memory out of physical memory.
 561  * This function is only supported in Linux currently.
 562  */
 563 gceSTATUS
 564 gckOS_UnmapUserLogical(
 565     IN gckOS Os,
 566     IN gctPHYS_ADDR Physical,
 567     IN gctSIZE_T Bytes,
 568     IN gctPOINTER Logical
 569     );
 570
 571 /* Create a new mutex. */
 572 gceSTATUS
 573 gckOS_CreateMutex(
 574     IN gckOS Os,
 575     OUT gctPOINTER * Mutex
 576     );
 577
 578 /* Delete a mutex. */
 579 gceSTATUS
 580 gckOS_DeleteMutex(
 581     IN gckOS Os,
 582     IN gctPOINTER Mutex
 583     );
 584
 585 /* Acquire a mutex. */
 586 gceSTATUS
 587 gckOS_AcquireMutex(
 588     IN gckOS Os,
 589     IN gctPOINTER Mutex,
 590     IN gctUINT32 Timeout
 591     );
 592
 593 /* Release a mutex. */
 594 gceSTATUS
 595 gckOS_ReleaseMutex(
 596     IN gckOS Os,
 597     IN gctPOINTER Mutex
 598     );
 599
 600 /* Atomically exchange a pair of 32-bit values. */
 601 gceSTATUS
 602 gckOS_AtomicExchange(
 603     IN gckOS Os,
 604     IN OUT gctUINT32_PTR Target,
 605     IN gctUINT32 NewValue,
 606     OUT gctUINT32_PTR OldValue
 607     );
 608
 609 /* Atomically exchange a pair of pointers. */
 610 gceSTATUS
 611 gckOS_AtomicExchangePtr(
 612     IN gckOS Os,
 613     IN OUT gctPOINTER * Target,
 614     IN gctPOINTER NewValue,
 615     OUT gctPOINTER * OldValue
 616     );
 617
 618 #if gcdSMP
 619 gceSTATUS
 620 gckOS_AtomSetMask(
 621     IN gctPOINTER Atom,
 622     IN gctUINT32 Mask
 623     );
 624
 625 gceSTATUS
 626 gckOS_AtomClearMask(
 627     IN gctPOINTER Atom,
 628     IN gctUINT32 Mask
 629     );
 630 #endif
 631
 632 gceSTATUS
 633 gckOS_DumpCallStack(
 634     IN gckOS Os
 635     );
 636
 637 gceSTATUS
 638 gckOS_GetProcessNameByPid(
 639     IN gctINT Pid,
 640     IN gctSIZE_T Length,
 641     OUT gctUINT8_PTR String
 642     );
 643
 644
 645
 646 /*******************************************************************************
 647 **
 648 **  gckOS_AtomConstruct
 649 **
 650 **  Create an atom.
 651 **
 652 **  INPUT:
 653 **
 654 **      gckOS Os
 655 **          Pointer to a gckOS object.
 656 **
 657 **  OUTPUT:
 658 **
 659 **      gctPOINTER * Atom
 660 **          Pointer to a variable receiving the constructed atom.
 661 */
 662 gceSTATUS
 663 gckOS_AtomConstruct(
 664     IN gckOS Os,
 665     OUT gctPOINTER * Atom
 666     );
 667
 668 /*******************************************************************************
 669 **
 670 **  gckOS_AtomDestroy
 671 **
 672 **  Destroy an atom.
 673 **
 674 **  INPUT:
 675 **
 676 **      gckOS Os
 677 **          Pointer to a gckOS object.
 678 **
 679 **      gctPOINTER Atom
 680 **          Pointer to the atom to destroy.
 681 **
 682 **  OUTPUT:
 683 **
 684 **      Nothing.
 685 */
 686 gceSTATUS
 687 gckOS_AtomDestroy(
 688     IN gckOS Os,
 689     OUT gctPOINTER Atom
 690     );
 691
 692 /*******************************************************************************
 693 **
 694 **  gckOS_AtomGet
 695 **
 696 **  Get the 32-bit value protected by an atom.
 697 **
 698 **  INPUT:
 699 **
 700 **      gckOS Os
 701 **          Pointer to a gckOS object.
 702 **
 703 **      gctPOINTER Atom
 704 **          Pointer to the atom.
 705 **
 706 **  OUTPUT:
 707 **
 708 **      gctINT32_PTR Value
 709 **          Pointer to a variable the receives the value of the atom.
 710 */
 711 gceSTATUS
 712 gckOS_AtomGet(
 713     IN gckOS Os,
 714     IN gctPOINTER Atom,
 715     OUT gctINT32_PTR Value
 716     );
 717
 718 /*******************************************************************************
 719 **
 720 **  gckOS_AtomSet
 721 **
 722 **  Set the 32-bit value protected by an atom.
 723 **
 724 **  INPUT:
 725 **
 726 **      gckOS Os
 727 **          Pointer to a gckOS object.
 728 **
 729 **      gctPOINTER Atom
 730 **          Pointer to the atom.
 731 **
 732 **      gctINT32 Value
 733 **          The value of the atom.
 734 **
 735 **  OUTPUT:
 736 **
 737 **      Nothing.
 738 */
 739 gceSTATUS
 740 gckOS_AtomSet(
 741     IN gckOS Os,
 742     IN gctPOINTER Atom,
 743     IN gctINT32 Value
 744     );
 745
 746 /*******************************************************************************
 747 **
 748 **  gckOS_AtomIncrement
 749 **
 750 **  Atomically increment the 32-bit integer value inside an atom.
 751 **
 752 **  INPUT:
 753 **
 754 **      gckOS Os
 755 **          Pointer to a gckOS object.
 756 **
 757 **      gctPOINTER Atom
 758 **          Pointer to the atom.
 759 **
 760 **  OUTPUT:
 761 **
 762 **      gctINT32_PTR Value
 763 **          Pointer to a variable the receives the original value of the atom.
 764 */
 765 gceSTATUS
 766 gckOS_AtomIncrement(
 767     IN gckOS Os,
 768     IN gctPOINTER Atom,
 769     OUT gctINT32_PTR Value
 770     );
 771
 772 /*******************************************************************************
 773 **
 774 **  gckOS_AtomDecrement
 775 **
 776 **  Atomically decrement the 32-bit integer value inside an atom.
 777 **
 778 **  INPUT:
 779 **
 780 **      gckOS Os
 781 **          Pointer to a gckOS object.
 782 **
 783 **      gctPOINTER Atom
 784 **          Pointer to the atom.
 785 **
 786 **  OUTPUT:
 787 **
 788 **      gctINT32_PTR Value
 789 **          Pointer to a variable the receives the original value of the atom.
 790 */
 791 gceSTATUS
 792 gckOS_AtomDecrement(
 793     IN gckOS Os,
 794     IN gctPOINTER Atom,
 795     OUT gctINT32_PTR Value
 796     );
 797
 798 /* Delay a number of microseconds. */
 799 gceSTATUS
 800 gckOS_Delay(
 801     IN gckOS Os,
 802     IN gctUINT32 Delay
 803     );
 804
 805 /* Get time in milliseconds. */
 806 gceSTATUS
 807 gckOS_GetTicks(
 808     OUT gctUINT32_PTR Time
 809     );
 810
 811 /* Compare time value. */
 812 gceSTATUS
 813 gckOS_TicksAfter(
 814     IN gctUINT32 Time1,
 815     IN gctUINT32 Time2,
 816     OUT gctBOOL_PTR IsAfter
 817     );
 818
 819 /* Get time in microseconds. */
 820 gceSTATUS
 821 gckOS_GetTime(
 822     OUT gctUINT64_PTR Time
 823     );
 824
 825 /* Memory barrier. */
 826 gceSTATUS
 827 gckOS_MemoryBarrier(
 828     IN gckOS Os,
 829     IN gctPOINTER Address
 830     );
 831
 832 /* Map user pointer. */
 833 gceSTATUS
 834 gckOS_MapUserPointer(
 835     IN gckOS Os,
 836     IN gctPOINTER Pointer,
 837     IN gctSIZE_T Size,
 838     OUT gctPOINTER * KernelPointer
 839     );
 840
 841 /* Unmap user pointer. */
 842 gceSTATUS
 843 gckOS_UnmapUserPointer(
 844     IN gckOS Os,
 845     IN gctPOINTER Pointer,
 846     IN gctSIZE_T Size,
 847     IN gctPOINTER KernelPointer
 848     );
 849
 850 /*******************************************************************************
 851 **
 852 **  gckOS_QueryNeedCopy
 853 **
 854 **  Query whether the memory can be accessed or mapped directly or it has to be
 855 **  copied.
 856 **
 857 **  INPUT:
 858 **
 859 **      gckOS Os
 860 **          Pointer to an gckOS object.
 861 **
 862 **      gctUINT32 ProcessID
 863 **          Process ID of the current process.
 864 **
 865 **  OUTPUT:
 866 **
 867 **      gctBOOL_PTR NeedCopy
 868 **          Pointer to a boolean receiving gcvTRUE if the memory needs a copy or
 869 **          gcvFALSE if the memory can be accessed or mapped dircetly.
 870 */
 871 gceSTATUS
 872 gckOS_QueryNeedCopy(
 873     IN gckOS Os,
 874     IN gctUINT32 ProcessID,
 875     OUT gctBOOL_PTR NeedCopy
 876     );
 877
 878 /*******************************************************************************
 879 **
 880 **  gckOS_CopyFromUserData
 881 **
 882 **  Copy data from user to kernel memory.
 883 **
 884 **  INPUT:
 885 **
 886 **      gckOS Os
 887 **          Pointer to an gckOS object.
 888 **
 889 **      gctPOINTER KernelPointer
 890 **          Pointer to kernel memory.
 891 **
 892 **      gctPOINTER Pointer
 893 **          Pointer to user memory.
 894 **
 895 **      gctSIZE_T Size
 896 **          Number of bytes to copy.
 897 **
 898 **  OUTPUT:
 899 **
 900 **      Nothing.
 901 */
 902 gceSTATUS
 903 gckOS_CopyFromUserData(
 904     IN gckOS Os,
 905     IN gctPOINTER KernelPointer,
 906     IN gctPOINTER Pointer,
 907     IN gctSIZE_T Size
 908     );
 909
 910 /*******************************************************************************
 911 **
 912 **  gckOS_CopyToUserData
 913 **
 914 **  Copy data from kernel to user memory.
 915 **
 916 **  INPUT:
 917 **
 918 **      gckOS Os
 919 **          Pointer to an gckOS object.
 920 **
 921 **      gctPOINTER KernelPointer
 922 **          Pointer to kernel memory.
 923 **
 924 **      gctPOINTER Pointer
 925 **          Pointer to user memory.
 926 **
 927 **      gctSIZE_T Size
 928 **          Number of bytes to copy.
 929 **
 930 **  OUTPUT:
 931 **
 932 **      Nothing.
 933 */
 934 gceSTATUS
 935 gckOS_CopyToUserData(
 936     IN gckOS Os,
 937     IN gctPOINTER KernelPointer,
 938     IN gctPOINTER Pointer,
 939     IN gctSIZE_T Size
 940     );
 941
 942 #ifdef __QNXNTO__
 943 /* Map user physical address. */
 944 gceSTATUS
 945 gckOS_MapUserPhysical(
 946     IN gckOS Os,
 947     IN gctPHYS_ADDR Phys,
 948     OUT gctPOINTER * KernelPointer
 949     );
 950 #endif
 951
 952 gceSTATUS
 953 gckOS_SuspendInterrupt(
 954     IN gckOS Os
 955     );
 956
 957 gceSTATUS
 958 gckOS_SuspendInterruptEx(
 959     IN gckOS Os,
 960     IN gceCORE Core
 961     );
 962
 963 gceSTATUS
 964 gckOS_ResumeInterrupt(
 965     IN gckOS Os
 966     );
 967
 968 gceSTATUS
 969 gckOS_ResumeInterruptEx(
 970     IN gckOS Os,
 971     IN gceCORE Core
 972     );
 973
 974 /* Get the base address for the physical memory. */
 975 gceSTATUS
 976 gckOS_GetBaseAddress(
 977     IN gckOS Os,
 978     OUT gctUINT32_PTR BaseAddress
 979     );
 980
 981 /* Perform a memory copy. */
 982 gceSTATUS
 983 gckOS_MemCopy(
 984     IN gctPOINTER Destination,
 985     IN gctCONST_POINTER Source,
 986     IN gctSIZE_T Bytes
 987     );
 988
 989 /* Zero memory. */
 990 gceSTATUS
 991 gckOS_ZeroMemory(
 992     IN gctPOINTER Memory,
 993     IN gctSIZE_T Bytes
 994     );
 995
 996 /* Device I/O control to the kernel HAL layer. */
 997 gceSTATUS
 998 gckOS_DeviceControl(
 999     IN gckOS Os,
1000     IN gctBOOL FromUser,
1001     IN gctUINT32 IoControlCode,
1002     IN gctPOINTER InputBuffer,
1003     IN gctSIZE_T InputBufferSize,
1004     OUT gctPOINTER OutputBuffer,
1005     IN gctSIZE_T OutputBufferSize
1006     );
1007
1008 /*******************************************************************************
1009 **
1010 **  gckOS_GetProcessID
1011 **
1012 **  Get current process ID.
1013 **
1014 **  INPUT:
1015 **
1016 **      Nothing.
1017 **
1018 **  OUTPUT:
1019 **
1020 **      gctUINT32_PTR ProcessID
1021 **          Pointer to the variable that receives the process ID.
1022 */
1023 gceSTATUS
1024 gckOS_GetProcessID(
1025     OUT gctUINT32_PTR ProcessID
1026     );
1027
1028 gceSTATUS
1029 gckOS_GetCurrentProcessID(
1030     OUT gctUINT32_PTR ProcessID
1031     );
1032
1033 /*******************************************************************************
1034 **
1035 **  gckOS_GetThreadID
1036 **
1037 **  Get current thread ID.
1038 **
1039 **  INPUT:
1040 **
1041 **      Nothing.
1042 **
1043 **  OUTPUT:
1044 **
1045 **      gctUINT32_PTR ThreadID
1046 **          Pointer to the variable that receives the thread ID.
1047 */
1048 gceSTATUS
1049 gckOS_GetThreadID(
1050     OUT gctUINT32_PTR ThreadID
1051     );
1052
1053 /******************************************************************************\
1054 ********************************** Signal Object *********************************
1055 \******************************************************************************/
1056
1057 /* Create a signal. */
1058 gceSTATUS
1059 gckOS_CreateSignal(
1060     IN gckOS Os,
1061     IN gctBOOL ManualReset,
1062     OUT gctSIGNAL * Signal
1063     );
1064
1065 /* Destroy a signal. */
1066 gceSTATUS
1067 gckOS_DestroySignal(
1068     IN gckOS Os,
1069     IN gctSIGNAL Signal
1070     );
1071
1072 /* Signal a signal. */
1073 gceSTATUS
1074 gckOS_Signal(
1075     IN gckOS Os,
1076     IN gctSIGNAL Signal,
1077     IN gctBOOL State
1078     );
1079
1080 /* Wait for a signal. */
1081 gceSTATUS
1082 gckOS_WaitSignal(
1083     IN gckOS Os,
1084     IN gctSIGNAL Signal,
1085     IN gctUINT32 Wait
1086     );
1087
1088 /* Map a user signal to the kernel space. */
1089 gceSTATUS
1090 gckOS_MapSignal(
1091     IN gckOS Os,
1092     IN gctSIGNAL Signal,
1093     IN gctHANDLE Process,
1094     OUT gctSIGNAL * MappedSignal
1095     );
1096
1097 /* Unmap a user signal */
1098 gceSTATUS
1099 gckOS_UnmapSignal(
1100     IN gckOS Os,
1101     IN gctSIGNAL Signal
1102     );
1103
1104 /* Map user memory. */
1105 gceSTATUS
1106 gckOS_MapUserMemory(
1107     IN gckOS Os,
1108     IN gceCORE Core,
1109     IN gctPOINTER Memory,
1110     IN gctUINT32 Physical,
1111     IN gctSIZE_T Size,
1112     OUT gctPOINTER * Info,
1113     OUT gctUINT32_PTR Address
1114     );
1115
1116 /* Unmap user memory. */
1117 gceSTATUS
1118 gckOS_UnmapUserMemory(
1119     IN gckOS Os,
1120     IN gceCORE Core,
1121     IN gctPOINTER Memory,
1122     IN gctSIZE_T Size,
1123     IN gctPOINTER Info,
1124     IN gctUINT32 Address
1125     );
1126
1127 #if !USE_NEW_LINUX_SIGNAL
1128 /* Create signal to be used in the user space. */
1129 gceSTATUS
1130 gckOS_CreateUserSignal(
1131     IN gckOS Os,
1132     IN gctBOOL ManualReset,
1133     OUT gctINT * SignalID
1134     );
1135
1136 /* Destroy signal used in the user space. */
1137 gceSTATUS
1138 gckOS_DestroyUserSignal(
1139     IN gckOS Os,
1140     IN gctINT SignalID
1141     );
1142
1143 /* Wait for signal used in the user space. */
1144 gceSTATUS
1145 gckOS_WaitUserSignal(
1146     IN gckOS Os,
1147     IN gctINT SignalID,
1148     IN gctUINT32 Wait
1149     );
1150
1151 /* Signal a signal used in the user space. */
1152 gceSTATUS
1153 gckOS_SignalUserSignal(
1154     IN gckOS Os,
1155     IN gctINT SignalID,
1156     IN gctBOOL State
1157     );
1158 #endif /* USE_NEW_LINUX_SIGNAL */
1159
1160 /* Set a signal owned by a process. */
1161 #if defined(__QNXNTO__)
1162 gceSTATUS
1163 gckOS_UserSignal(
1164     IN gckOS Os,
1165     IN gctSIGNAL Signal,
1166     IN gctINT Recvid,
1167     IN gctINT Coid
1168     );
1169 #else
1170 gceSTATUS
1171 gckOS_UserSignal(
1172     IN gckOS Os,
1173     IN gctSIGNAL Signal,
1174     IN gctHANDLE Process
1175     );
1176 #endif
1177
1178 /******************************************************************************\
1179 ** Cache Support
1180 */
1181
1182 gceSTATUS
1183 gckOS_CacheClean(
1184     gckOS Os,
1185     gctUINT32 ProcessID,
1186     gctPHYS_ADDR Handle,
1187     gctPOINTER Physical,
1188     gctPOINTER Logical,
1189     gctSIZE_T Bytes
1190     );
1191
1192 gceSTATUS
1193 gckOS_CacheFlush(
1194     gckOS Os,
1195     gctUINT32 ProcessID,
1196     gctPHYS_ADDR Handle,
1197     gctPOINTER Physical,
1198     gctPOINTER Logical,
1199     gctSIZE_T Bytes
1200     );
1201
1202 gceSTATUS
1203 gckOS_CacheInvalidate(
1204     gckOS Os,
1205     gctUINT32 ProcessID,
1206     gctPHYS_ADDR Handle,
1207     gctPOINTER Physical,
1208     gctPOINTER Logical,
1209     gctSIZE_T Bytes
1210     );
1211
1212 /******************************************************************************\
1213 ** Debug Support
1214 */
1215
1216 void
1217 gckOS_SetDebugLevel(
1218     IN gctUINT32 Level
1219     );
1220
1221 void
1222 gckOS_SetDebugZone(
1223     IN gctUINT32 Zone
1224     );
1225
1226 void
1227 gckOS_SetDebugLevelZone(
1228     IN gctUINT32 Level,
1229     IN gctUINT32 Zone
1230     );
1231
1232 void
1233 gckOS_SetDebugZones(
1234     IN gctUINT32 Zones,
1235     IN gctBOOL Enable
1236     );
1237
1238 void
1239 gckOS_SetDebugFile(
1240     IN gctCONST_STRING FileName
1241     );
1242
1243 /*******************************************************************************
1244 ** Broadcast interface.
1245 */
1246
1247 typedef enum _gceBROADCAST
1248 {
1249     /* GPU might be idle. */
1250     gcvBROADCAST_GPU_IDLE,
1251
1252     /* A commit is going to happen. */
1253     gcvBROADCAST_GPU_COMMIT,
1254
1255     /* GPU seems to be stuck. */
1256     gcvBROADCAST_GPU_STUCK,
1257
1258     /* First process gets attached. */
1259     gcvBROADCAST_FIRST_PROCESS,
1260
1261     /* Last process gets detached. */
1262     gcvBROADCAST_LAST_PROCESS,
1263
1264     /* AXI bus error. */
1265     gcvBROADCAST_AXI_BUS_ERROR,
1266 }
1267 gceBROADCAST;
1268
1269 gceSTATUS
1270 gckOS_Broadcast(
1271     IN gckOS Os,
1272     IN gckHARDWARE Hardware,
1273     IN gceBROADCAST Reason
1274     );
1275
1276 gceSTATUS
1277 gckOS_BroadcastHurry(
1278     IN gckOS Os,
1279     IN gckHARDWARE Hardware,
1280     IN gctUINT Urgency
1281     );
1282
1283 gceSTATUS
1284 gckOS_BroadcastCalibrateSpeed(
1285     IN gckOS Os,
1286     IN gckHARDWARE Hardware,
1287     IN gctUINT Idle,
1288     IN gctUINT Time
1289     );
1290
1291 /*******************************************************************************
1292 **
1293 **  gckOS_SetGPUPower
1294 **
1295 **  Set the power of the GPU on or off.
1296 **
1297 **  INPUT:
1298 **
1299 **      gckOS Os
1300 **          Pointer to a gckOS object.ß
1301 **
1302 **      gckCORE Core
1303 **          GPU whose power is set.
1304 **
1305 **      gctBOOL Clock
1306 **          gcvTRUE to turn on the clock, or gcvFALSE to turn off the clock.
1307 **
1308 **      gctBOOL Power
1309 **          gcvTRUE to turn on the power, or gcvFALSE to turn off the power.
1310 **
1311 **  OUTPUT:
1312 **
1313 **      Nothing.
1314 */
1315 gceSTATUS
1316 gckOS_SetGPUPower(
1317     IN gckOS Os,
1318     IN gceCORE Core,
1319     IN gctBOOL Clock,
1320     IN gctBOOL Power
1321     );
1322
1323 gceSTATUS
1324 gckOS_ResetGPU(
1325     IN gckOS Os,
1326     IN gceCORE Core
1327     );
1328
1329 gceSTATUS
1330 gckOS_PrepareGPUFrequency(
1331     IN gckOS Os,
1332     IN gceCORE Core
1333     );
1334
1335 gceSTATUS
1336 gckOS_FinishGPUFrequency(
1337     IN gckOS Os,
1338     IN gceCORE Core
1339     );
1340
1341 gceSTATUS
1342 gckOS_QueryGPUFrequency(
1343     IN gckOS Os,
1344     IN gceCORE Core,
1345     OUT gctUINT32 * Frequency,
1346     OUT gctUINT8 * Scale
1347     );
1348
1349 gceSTATUS
1350 gckOS_SetGPUFrequency(
1351     IN gckOS Os,
1352     IN gceCORE Core,
1353     IN gctUINT8 Scale
1354     );
1355
1356 /*******************************************************************************
1357 ** Semaphores.
1358 */
1359
1360 /* Create a new semaphore. */
1361 gceSTATUS
1362 gckOS_CreateSemaphore(
1363     IN gckOS Os,
1364     OUT gctPOINTER * Semaphore
1365     );
1366
1367 #if gcdENABLE_VG
1368 gceSTATUS
1369 gckOS_CreateSemaphoreVG(
1370     IN gckOS Os,
1371     OUT gctPOINTER * Semaphore
1372     );
1373 #endif
1374
1375 /* Delete a semahore. */
1376 gceSTATUS
1377 gckOS_DestroySemaphore(
1378     IN gckOS Os,
1379     IN gctPOINTER Semaphore
1380     );
1381
1382 /* Acquire a semahore. */
1383 gceSTATUS
1384 gckOS_AcquireSemaphore(
1385     IN gckOS Os,
1386     IN gctPOINTER Semaphore
1387     );
1388
1389 /* Try to acquire a semahore. */
1390 gceSTATUS
1391 gckOS_TryAcquireSemaphore(
1392     IN gckOS Os,
1393     IN gctPOINTER Semaphore
1394     );
1395
1396 /* Release a semahore. */
1397 gceSTATUS
1398 gckOS_ReleaseSemaphore(
1399     IN gckOS Os,
1400     IN gctPOINTER Semaphore
1401     );
1402
1403 /*******************************************************************************
1404 ** Timer API.
1405 */
1406
1407 typedef void (*gctTIMERFUNCTION)(gctPOINTER);
1408
1409 /* Create a timer. */
1410 gceSTATUS
1411 gckOS_CreateTimer(
1412     IN gckOS Os,
1413     IN gctTIMERFUNCTION Function,
1414     IN gctPOINTER Data,
1415     OUT gctPOINTER * Timer
1416     );
1417
1418 /* Destory a timer. */
1419 gceSTATUS
1420 gckOS_DestroyTimer(
1421     IN gckOS Os,
1422     IN gctPOINTER Timer
1423     );
1424
1425 /* Start a timer. */
1426 gceSTATUS
1427 gckOS_StartTimer(
1428     IN gckOS Os,
1429     IN gctPOINTER Timer,
1430     IN gctUINT32 Delay
1431     );
1432
1433 /* Stop a timer. */
1434 gceSTATUS
1435 gckOS_StopTimer(
1436     IN gckOS Os,
1437     IN gctPOINTER Timer
1438     );
1439
1440 /******************************************************************************\
1441 ********************************* gckHEAP Object ********************************
1442 \******************************************************************************/
1443
1444 typedef struct _gckHEAP *       gckHEAP;
1445
1446 /* Construct a new gckHEAP object. */
1447 gceSTATUS
1448 gckHEAP_Construct(
1449     IN gckOS Os,
1450     IN gctSIZE_T AllocationSize,
1451     OUT gckHEAP * Heap
1452     );
1453
1454 /* Destroy an gckHEAP object. */
1455 gceSTATUS
1456 gckHEAP_Destroy(
1457     IN gckHEAP Heap
1458     );
1459
1460 /* Allocate memory. */
1461 gceSTATUS
1462 gckHEAP_Allocate(
1463     IN gckHEAP Heap,
1464     IN gctSIZE_T Bytes,
1465     OUT gctPOINTER * Node
1466     );
1467
1468 /* Free memory. */
1469 gceSTATUS
1470 gckHEAP_Free(
1471     IN gckHEAP Heap,
1472     IN gctPOINTER Node
1473     );
1474
1475 /* Profile the heap. */
1476 gceSTATUS
1477 gckHEAP_ProfileStart(
1478     IN gckHEAP Heap
1479     );
1480
1481 gceSTATUS
1482 gckHEAP_ProfileEnd(
1483     IN gckHEAP Heap,
1484     IN gctCONST_STRING Title
1485     );
1486
1487
1488 /******************************************************************************\
1489 ******************************** gckVIDMEM Object ******************************
1490 \******************************************************************************/
1491
1492 typedef struct _gckVIDMEM *         gckVIDMEM;
1493 typedef struct _gckKERNEL *         gckKERNEL;
1494 typedef struct _gckDB *             gckDB;
1495 typedef struct _gckDVFS *           gckDVFS;
1496
1497 /* Construct a new gckVIDMEM object. */
1498 gceSTATUS
1499 gckVIDMEM_Construct(
1500     IN gckOS Os,
1501     IN gctUINT32 BaseAddress,
1502     IN gctSIZE_T Bytes,
1503     IN gctSIZE_T Threshold,
1504     IN gctSIZE_T Banking,
1505     OUT gckVIDMEM * Memory
1506     );
1507
1508 /* Destroy an gckVDIMEM object. */
1509 gceSTATUS
1510 gckVIDMEM_Destroy(
1511     IN gckVIDMEM Memory
1512     );
1513
1514 /* Allocate rectangular memory. */
1515 gceSTATUS
1516 gckVIDMEM_Allocate(
1517     IN gckVIDMEM Memory,
1518     IN gctUINT Width,
1519     IN gctUINT Height,
1520     IN gctUINT Depth,
1521     IN gctUINT BytesPerPixel,
1522     IN gctUINT32 Alignment,
1523     IN gceSURF_TYPE Type,
1524     OUT gcuVIDMEM_NODE_PTR * Node
1525     );
1526
1527 /* Allocate linear memory. */
1528 gceSTATUS
1529 gckVIDMEM_AllocateLinear(
1530     IN gckVIDMEM Memory,
1531     IN gctSIZE_T Bytes,
1532     IN gctUINT32 Alignment,
1533     IN gceSURF_TYPE Type,
1534     OUT gcuVIDMEM_NODE_PTR * Node
1535     );
1536
1537 /* Free memory. */
1538 gceSTATUS
1539 gckVIDMEM_Free(
1540     IN gcuVIDMEM_NODE_PTR Node
1541     );
1542
1543 /* Lock memory. */
1544 gceSTATUS
1545 gckVIDMEM_Lock(
1546     IN gckKERNEL Kernel,
1547     IN gcuVIDMEM_NODE_PTR Node,
1548     IN gctBOOL Cacheable,
1549     OUT gctUINT32 * Address
1550     );
1551
1552 /* Unlock memory. */
1553 gceSTATUS
1554 gckVIDMEM_Unlock(
1555     IN gckKERNEL Kernel,
1556     IN gcuVIDMEM_NODE_PTR Node,
1557     IN gceSURF_TYPE Type,
1558     IN OUT gctBOOL * Asynchroneous
1559     );
1560
1561 /* Construct a gcuVIDMEM_NODE union for virtual memory. */
1562 gceSTATUS
1563 gckVIDMEM_ConstructVirtual(
1564     IN gckKERNEL Kernel,
1565     IN gctBOOL Contiguous,
1566     IN gctSIZE_T Bytes,
1567     OUT gcuVIDMEM_NODE_PTR * Node
1568     );
1569
1570 /* Destroy a gcuVIDMEM_NODE union for virtual memory. */
1571 gceSTATUS
1572 gckVIDMEM_DestroyVirtual(
1573     IN gcuVIDMEM_NODE_PTR Node
1574     );
1575
1576 /******************************************************************************\
1577 ******************************** gckKERNEL Object ******************************
1578 \******************************************************************************/
1579
1580 struct _gcsHAL_INTERFACE;
1581
1582 /* Notifications. */
1583 typedef enum _gceNOTIFY
1584 {
1585     gcvNOTIFY_INTERRUPT,
1586     gcvNOTIFY_COMMAND_QUEUE,
1587 }
1588 gceNOTIFY;
1589
1590 /* Flush flags. */
1591 typedef enum _gceKERNEL_FLUSH
1592 {
1593     gcvFLUSH_COLOR              = 0x01,
1594     gcvFLUSH_DEPTH              = 0x02,
1595     gcvFLUSH_TEXTURE            = 0x04,
1596     gcvFLUSH_2D                 = 0x08,
1597     gcvFLUSH_ALL                = gcvFLUSH_COLOR
1598                                 | gcvFLUSH_DEPTH
1599                                 | gcvFLUSH_TEXTURE
1600                                 | gcvFLUSH_2D,
1601 }
1602 gceKERNEL_FLUSH;
1603
1604 /* Construct a new gckKERNEL object. */
1605 gceSTATUS
1606 gckKERNEL_Construct(
1607     IN gckOS Os,
1608     IN gceCORE Core,
1609     IN gctPOINTER Context,
1610     IN gckDB SharedDB,
1611     OUT gckKERNEL * Kernel
1612     );
1613
1614 /* Destroy an gckKERNEL object. */
1615 gceSTATUS
1616 gckKERNEL_Destroy(
1617     IN gckKERNEL Kernel
1618     );
1619
1620 /* Dispatch a user-level command. */
1621 gceSTATUS
1622 gckKERNEL_Dispatch(
1623     IN gckKERNEL Kernel,
1624     IN gctBOOL FromUser,
1625     IN OUT struct _gcsHAL_INTERFACE * Interface
1626     );
1627
1628 /* Query the video memory. */
1629 gceSTATUS
1630 gckKERNEL_QueryVideoMemory(
1631     IN gckKERNEL Kernel,
1632     OUT struct _gcsHAL_INTERFACE * Interface
1633     );
1634
1635 /* Lookup the gckVIDMEM object for a pool. */
1636 gceSTATUS
1637 gckKERNEL_GetVideoMemoryPool(
1638     IN gckKERNEL Kernel,
1639     IN gcePOOL Pool,
1640     OUT gckVIDMEM * VideoMemory
1641     );
1642
1643 #if gcdUSE_VIDMEM_PER_PID
1644 gceSTATUS
1645 gckKERNEL_GetVideoMemoryPoolPid(
1646     IN gckKERNEL Kernel,
1647     IN gcePOOL Pool,
1648     IN gctUINT32 Pid,
1649     OUT gckVIDMEM * VideoMemory
1650     );
1651
1652 gceSTATUS
1653 gckKERNEL_CreateVideoMemoryPoolPid(
1654     IN gckKERNEL Kernel,
1655     IN gcePOOL Pool,
1656     IN gctUINT32 Pid,
1657     OUT gckVIDMEM * VideoMemory
1658     );
1659
1660 gceSTATUS
1661 gckKERNEL_RemoveVideoMemoryPoolPid(
1662     IN gckKERNEL Kernel,
1663     IN gckVIDMEM VideoMemory
1664     );
1665 #endif
1666
1667 /* Map video memory. */
1668 gceSTATUS
1669 gckKERNEL_MapVideoMemory(
1670     IN gckKERNEL Kernel,
1671     IN gctBOOL InUserSpace,
1672     IN gctUINT32 Address,
1673 #ifdef __QNXNTO__
1674     IN gctUINT32 Pid,
1675     IN gctUINT32 Bytes,
1676 #endif
1677     OUT gctPOINTER * Logical
1678     );
1679
1680 /* Map video memory. */
1681 gceSTATUS
1682 gckKERNEL_MapVideoMemoryEx(
1683     IN gckKERNEL Kernel,
1684     IN gceCORE Core,
1685     IN gctBOOL InUserSpace,
1686     IN gctUINT32 Address,
1687 #ifdef __QNXNTO__
1688     IN gctUINT32 Pid,
1689     IN gctUINT32 Bytes,
1690 #endif
1691     OUT gctPOINTER * Logical
1692     );
1693
1694 #ifdef __QNXNTO__
1695 /* Unmap video memory. */
1696 gceSTATUS
1697 gckKERNEL_UnmapVideoMemory(
1698     IN gckKERNEL Kernel,
1699     IN gctPOINTER Logical,
1700     IN gctUINT32 Pid,
1701     IN gctUINT32 Bytes
1702     );
1703 #endif
1704
1705 /* Map memory. */
1706 gceSTATUS
1707 gckKERNEL_MapMemory(
1708     IN gckKERNEL Kernel,
1709     IN gctPHYS_ADDR Physical,
1710     IN gctSIZE_T Bytes,
1711     OUT gctPOINTER * Logical
1712     );
1713
1714 /* Unmap memory. */
1715 gceSTATUS
1716 gckKERNEL_UnmapMemory(
1717     IN gckKERNEL Kernel,
1718     IN gctPHYS_ADDR Physical,
1719     IN gctSIZE_T Bytes,
1720     IN gctPOINTER Logical
1721     );
1722
1723 /* Notification of events. */
1724 gceSTATUS
1725 gckKERNEL_Notify(
1726     IN gckKERNEL Kernel,
1727     IN gceNOTIFY Notifcation,
1728     IN gctBOOL Data
1729     );
1730
1731 gceSTATUS
1732 gckKERNEL_QuerySettings(
1733     IN gckKERNEL Kernel,
1734     OUT gcsKERNEL_SETTINGS * Settings
1735     );
1736
1737 /*******************************************************************************
1738 **
1739 **  gckKERNEL_Recovery
1740 **
1741 **  Try to recover the GPU from a fatal error.
1742 **
1743 **  INPUT:
1744 **
1745 **      gckKERNEL Kernel
1746 **          Pointer to an gckKERNEL object.
1747 **
1748 **  OUTPUT:
1749 **
1750 **      Nothing.
1751 */
1752 gceSTATUS
1753 gckKERNEL_Recovery(
1754     IN gckKERNEL Kernel
1755     );
1756
1757 /* Set the value of timeout on HW operation. */
1758 void
1759 gckKERNEL_SetTimeOut(
1760     IN gckKERNEL Kernel,
1761         IN gctUINT32 timeOut
1762     );
1763
1764 /* Get access to the user data. */
1765 gceSTATUS
1766 gckKERNEL_OpenUserData(
1767     IN gckKERNEL Kernel,
1768     IN gctBOOL NeedCopy,
1769     IN gctPOINTER StaticStorage,
1770     IN gctPOINTER UserPointer,
1771     IN gctSIZE_T Size,
1772     OUT gctPOINTER * KernelPointer
1773     );
1774
1775 /* Release resources associated with the user data connection. */
1776 gceSTATUS
1777 gckKERNEL_CloseUserData(
1778     IN gckKERNEL Kernel,
1779     IN gctBOOL NeedCopy,
1780     IN gctBOOL FlushData,
1781     IN gctPOINTER UserPointer,
1782     IN gctSIZE_T Size,
1783     OUT gctPOINTER * KernelPointer
1784     );
1785
1786 gceSTATUS
1787 gckDVFS_Construct(
1788     IN gckHARDWARE Hardware,
1789     OUT gckDVFS * Frequency
1790     );
1791
1792 gceSTATUS
1793 gckDVFS_Destroy(
1794     IN gckDVFS Dvfs
1795     );
1796
1797 gceSTATUS
1798 gckDVFS_Start(
1799     IN gckDVFS Dvfs
1800     );
1801
1802 gceSTATUS
1803 gckDVFS_Stop(
1804     IN gckDVFS Dvfs
1805     );
1806
1807 /******************************************************************************\
1808 ******************************* gckHARDWARE Object *****************************
1809 \******************************************************************************/
1810
1811 /* Construct a new gckHARDWARE object. */
1812 gceSTATUS
1813 gckHARDWARE_Construct(
1814     IN gckOS Os,
1815     IN gceCORE Core,
1816     OUT gckHARDWARE * Hardware
1817     );
1818
1819 /* Destroy an gckHARDWARE object. */
1820 gceSTATUS
1821 gckHARDWARE_Destroy(
1822     IN gckHARDWARE Hardware
1823     );
1824
1825 /* Get hardware type. */
1826 gceSTATUS
1827 gckHARDWARE_GetType(
1828     IN gckHARDWARE Hardware,
1829     OUT gceHARDWARE_TYPE * Type
1830     );
1831
1832 /* Query system memory requirements. */
1833 gceSTATUS
1834 gckHARDWARE_QuerySystemMemory(
1835     IN gckHARDWARE Hardware,
1836     OUT gctSIZE_T * SystemSize,
1837     OUT gctUINT32 * SystemBaseAddress
1838     );
1839
1840 /* Build virtual address. */
1841 gceSTATUS
1842 gckHARDWARE_BuildVirtualAddress(
1843     IN gckHARDWARE Hardware,
1844     IN gctUINT32 Index,
1845     IN gctUINT32 Offset,
1846     OUT gctUINT32 * Address
1847     );
1848
1849 /* Query command buffer requirements. */
1850 gceSTATUS
1851 gckHARDWARE_QueryCommandBuffer(
1852     IN gckHARDWARE Hardware,
1853     OUT gctSIZE_T * Alignment,
1854     OUT gctSIZE_T * ReservedHead,
1855     OUT gctSIZE_T * ReservedTail
1856     );
1857
1858 /* Add a WAIT/LINK pair in the command queue. */
1859 gceSTATUS
1860 gckHARDWARE_WaitLink(
1861     IN gckHARDWARE Hardware,
1862     IN gctPOINTER Logical,
1863     IN gctUINT32 Offset,
1864     IN OUT gctSIZE_T * Bytes,
1865     OUT gctUINT32 * WaitOffset,
1866     OUT gctSIZE_T * WaitBytes
1867     );
1868
1869 /* Kickstart the command processor. */
1870 gceSTATUS
1871 gckHARDWARE_Execute(
1872     IN gckHARDWARE Hardware,
1873     IN gctPOINTER Logical,
1874 #ifdef __QNXNTO__
1875     IN gctPOINTER Physical,
1876     IN gctBOOL PhysicalAddresses,
1877 #endif
1878     IN gctSIZE_T Bytes
1879     );
1880
1881 /* Add an END command in the command queue. */
1882 gceSTATUS
1883 gckHARDWARE_End(
1884     IN gckHARDWARE Hardware,
1885     IN gctPOINTER Logical,
1886     IN OUT gctSIZE_T * Bytes
1887     );
1888
1889 /* Add a NOP command in the command queue. */
1890 gceSTATUS
1891 gckHARDWARE_Nop(
1892     IN gckHARDWARE Hardware,
1893     IN gctPOINTER Logical,
1894     IN OUT gctSIZE_T * Bytes
1895     );
1896
1897 /* Add a WAIT command in the command queue. */
1898 gceSTATUS
1899 gckHARDWARE_Wait(
1900     IN gckHARDWARE Hardware,
1901     IN gctPOINTER Logical,
1902     IN gctUINT32 Count,
1903     IN OUT gctSIZE_T * Bytes
1904     );
1905
1906 /* Add a PIPESELECT command in the command queue. */
1907 gceSTATUS
1908 gckHARDWARE_PipeSelect(
1909     IN gckHARDWARE Hardware,
1910     IN gctPOINTER Logical,
1911     IN gcePIPE_SELECT Pipe,
1912     IN OUT gctSIZE_T * Bytes
1913     );
1914
1915 /* Add a LINK command in the command queue. */
1916 gceSTATUS
1917 gckHARDWARE_Link(
1918     IN gckHARDWARE Hardware,
1919     IN gctPOINTER Logical,
1920     IN gctPOINTER FetchAddress,
1921     IN gctSIZE_T FetchSize,
1922     IN OUT gctSIZE_T * Bytes
1923     );
1924
1925 /* Add an EVENT command in the command queue. */
1926 gceSTATUS
1927 gckHARDWARE_Event(
1928     IN gckHARDWARE Hardware,
1929     IN gctPOINTER Logical,
1930     IN gctUINT8 Event,
1931     IN gceKERNEL_WHERE FromWhere,
1932     IN OUT gctSIZE_T * Bytes
1933     );
1934
1935 /* Query the available memory. */
1936 gceSTATUS
1937 gckHARDWARE_QueryMemory(
1938     IN gckHARDWARE Hardware,
1939     OUT gctSIZE_T * InternalSize,
1940     OUT gctUINT32 * InternalBaseAddress,
1941     OUT gctUINT32 * InternalAlignment,
1942     OUT gctSIZE_T * ExternalSize,
1943     OUT gctUINT32 * ExternalBaseAddress,
1944     OUT gctUINT32 * ExternalAlignment,
1945     OUT gctUINT32 * HorizontalTileSize,
1946     OUT gctUINT32 * VerticalTileSize
1947     );
1948
1949 /* Query the identity of the hardware. */
1950 gceSTATUS
1951 gckHARDWARE_QueryChipIdentity(
1952     IN gckHARDWARE Hardware,
1953     OUT gcsHAL_QUERY_CHIP_IDENTITY_PTR Identity
1954     );
1955
1956 /* Query the shader support. */
1957 gceSTATUS
1958 gckHARDWARE_QueryShaderCaps(
1959     IN gckHARDWARE Hardware,
1960     OUT gctUINT * VertexUniforms,
1961     OUT gctUINT * FragmentUniforms,
1962     OUT gctUINT * Varyings
1963     );
1964
1965 /* Split a harwdare specific address into API stuff. */
1966 gceSTATUS
1967 gckHARDWARE_SplitMemory(
1968     IN gckHARDWARE Hardware,
1969     IN gctUINT32 Address,
1970     OUT gcePOOL * Pool,
1971     OUT gctUINT32 * Offset
1972     );
1973
1974 /* Update command queue tail pointer. */
1975 gceSTATUS
1976 gckHARDWARE_UpdateQueueTail(
1977     IN gckHARDWARE Hardware,
1978     IN gctPOINTER Logical,
1979     IN gctUINT32 Offset
1980     );
1981
1982 /* Convert logical address to hardware specific address. */
1983 gceSTATUS
1984 gckHARDWARE_ConvertLogical(
1985     IN gckHARDWARE Hardware,
1986     IN gctPOINTER Logical,
1987     OUT gctUINT32 * Address
1988     );
1989
1990 #ifdef __QNXNTO__
1991 /* Convert physical address to hardware specific address. */
1992 gceSTATUS
1993 gckHARDWARE_ConvertPhysical(
1994     IN gckHARDWARE Hardware,
1995     IN gctPHYS_ADDR Physical,
1996     OUT gctUINT32 * Address
1997     );
1998 #endif
1999
2000 /* Interrupt manager. */
2001 gceSTATUS
2002 gckHARDWARE_Interrupt(
2003     IN gckHARDWARE Hardware,
2004     IN gctBOOL InterruptValid
2005     );
2006
2007 /* Program MMU. */
2008 gceSTATUS
2009 gckHARDWARE_SetMMU(
2010     IN gckHARDWARE Hardware,
2011     IN gctPOINTER Logical
2012     );
2013
2014 /* Flush the MMU. */
2015 gceSTATUS
2016 gckHARDWARE_FlushMMU(
2017     IN gckHARDWARE Hardware
2018     );
2019
2020 /* Set the page table base address. */
2021 gceSTATUS
2022 gckHARDWARE_SetMMUv2(
2023     IN gckHARDWARE Hardware,
2024     IN gctBOOL Enable,
2025     IN gctPOINTER MtlbAddress,
2026     IN gceMMU_MODE Mode,
2027     IN gctPOINTER SafeAddress,
2028     IN gctBOOL FromPower
2029     );
2030
2031 /* Get idle register. */
2032 gceSTATUS
2033 gckHARDWARE_GetIdle(
2034     IN gckHARDWARE Hardware,
2035     IN gctBOOL Wait,
2036     OUT gctUINT32 * Data
2037     );
2038
2039 /* Flush the caches. */
2040 gceSTATUS
2041 gckHARDWARE_Flush(
2042     IN gckHARDWARE Hardware,
2043     IN gceKERNEL_FLUSH Flush,
2044     IN gctPOINTER Logical,
2045     IN OUT gctSIZE_T * Bytes
2046     );
2047
2048 /* Enable/disable fast clear. */
2049 gceSTATUS
2050 gckHARDWARE_SetFastClear(
2051     IN gckHARDWARE Hardware,
2052     IN gctINT Enable,
2053     IN gctINT Compression
2054     );
2055
2056 gceSTATUS
2057 gckHARDWARE_ReadInterrupt(
2058     IN gckHARDWARE Hardware,
2059     OUT gctUINT32_PTR IDs
2060     );
2061
2062 /* Power management. */
2063 gceSTATUS
2064 gckHARDWARE_SetPowerManagementState(
2065     IN gckHARDWARE Hardware,
2066     IN gceCHIPPOWERSTATE State
2067     );
2068
2069 gceSTATUS
2070 gckHARDWARE_QueryPowerManagementState(
2071     IN gckHARDWARE Hardware,
2072     OUT gceCHIPPOWERSTATE* State
2073     );
2074
2075 gceSTATUS
2076 gckHARDWARE_SetPowerManagement(
2077     IN gckHARDWARE Hardware,
2078     IN gctBOOL PowerManagement
2079     );
2080
2081 #if gcdENABLE_FSCALE_VAL_ADJUST
2082 gceSTATUS
2083 gckHARDWARE_SetFscaleValue(
2084     IN gckHARDWARE Hardware,
2085     IN gctUINT32   FscaleValue
2086     );
2087
2088 gceSTATUS
2089 gckHARDWARE_GetFscaleValue(
2090     IN gckHARDWARE Hardware,
2091     IN gctUINT * FscaleValue,
2092     IN gctUINT * MinFscaleValue,
2093     IN gctUINT * MaxFscaleValue
2094     );
2095 #endif
2096
2097 #if gcdPOWEROFF_TIMEOUT
2098 gceSTATUS
2099 gckHARDWARE_SetPowerOffTimeout(
2100     IN gckHARDWARE  Hardware,
2101     IN gctUINT32    Timeout
2102 );
2103
2104 gceSTATUS
2105 gckHARDWARE_QueryPowerOffTimeout(
2106     IN gckHARDWARE  Hardware,
2107     OUT gctUINT32*  Timeout
2108 );
2109 #endif
2110
2111 /* Profile 2D Engine. */
2112 gceSTATUS
2113 gckHARDWARE_ProfileEngine2D(
2114     IN gckHARDWARE Hardware,
2115     OUT gcs2D_PROFILE_PTR Profile
2116     );
2117
2118 gceSTATUS
2119 gckHARDWARE_InitializeHardware(
2120     IN gckHARDWARE Hardware
2121     );
2122
2123 gceSTATUS
2124 gckHARDWARE_Reset(
2125     IN gckHARDWARE Hardware
2126     );
2127
2128 typedef gceSTATUS (*gctISRMANAGERFUNC)(gctPOINTER Context);
2129
2130 gceSTATUS
2131 gckHARDWARE_SetIsrManager(
2132     IN gckHARDWARE Hardware,
2133     IN gctISRMANAGERFUNC StartIsr,
2134     IN gctISRMANAGERFUNC StopIsr,
2135     IN gctPOINTER Context
2136     );
2137
2138 /* Start a composition. */
2139 gceSTATUS
2140 gckHARDWARE_Compose(
2141     IN gckHARDWARE Hardware,
2142     IN gctUINT32 ProcessID,
2143     IN gctPHYS_ADDR Physical,
2144     IN gctPOINTER Logical,
2145     IN gctSIZE_T Offset,
2146     IN gctSIZE_T Size,
2147     IN gctUINT8 EventID
2148     );
2149
2150 /* Check for Hardware features. */
2151 gceSTATUS
2152 gckHARDWARE_IsFeatureAvailable(
2153     IN gckHARDWARE Hardware,
2154     IN gceFEATURE Feature
2155     );
2156
2157 gceSTATUS
2158 gckHARDWARE_DumpMMUException(
2159     IN gckHARDWARE Hardware
2160     );
2161
2162 gceSTATUS
2163 gckHARDWARE_DumpGPUState(
2164     IN gckHARDWARE Hardware
2165     );
2166
2167 gceSTATUS
2168 gckHARDWARE_InitDVFS(
2169     IN gckHARDWARE Hardware
2170     );
2171
2172 gceSTATUS
2173 gckHARDWARE_QueryLoad(
2174     IN gckHARDWARE Hardware,
2175     OUT gctUINT32 * Load
2176     );
2177
2178 gceSTATUS
2179 gckHARDWARE_SetDVFSPeroid(
2180     IN gckHARDWARE Hardware,
2181     IN gctUINT32 Frequency
2182     );
2183
2184 #if !gcdENABLE_VG
2185 /******************************************************************************\
2186 ***************************** gckINTERRUPT Object ******************************
2187 \******************************************************************************/
2188
2189 typedef struct _gckINTERRUPT *  gckINTERRUPT;
2190
2191 typedef gceSTATUS (* gctINTERRUPT_HANDLER)(
2192     IN gckKERNEL Kernel
2193     );
2194
2195 gceSTATUS
2196 gckINTERRUPT_Construct(
2197     IN gckKERNEL Kernel,
2198     OUT gckINTERRUPT * Interrupt
2199     );
2200
2201 gceSTATUS
2202 gckINTERRUPT_Destroy(
2203     IN gckINTERRUPT Interrupt
2204     );
2205
2206 gceSTATUS
2207 gckINTERRUPT_SetHandler(
2208     IN gckINTERRUPT Interrupt,
2209     IN OUT gctINT32_PTR Id,
2210     IN gctINTERRUPT_HANDLER Handler
2211     );
2212
2213 gceSTATUS
2214 gckINTERRUPT_Notify(
2215     IN gckINTERRUPT Interrupt,
2216     IN gctBOOL Valid
2217     );
2218 #endif
2219 /******************************************************************************\
2220 ******************************** gckEVENT Object *******************************
2221 \******************************************************************************/
2222
2223 typedef struct _gckEVENT *      gckEVENT;
2224
2225 /* Construct a new gckEVENT object. */
2226 gceSTATUS
2227 gckEVENT_Construct(
2228     IN gckKERNEL Kernel,
2229     OUT gckEVENT * Event
2230     );
2231
2232 /* Destroy an gckEVENT object. */
2233 gceSTATUS
2234 gckEVENT_Destroy(
2235     IN gckEVENT Event
2236     );
2237
2238 /* Reserve the next available hardware event. */
2239 gceSTATUS
2240 gckEVENT_GetEvent(
2241     IN gckEVENT Event,
2242     IN gctBOOL Wait,
2243     OUT gctUINT8 * EventID,
2244     IN gceKERNEL_WHERE Source
2245    );
2246
2247 /* Add a new event to the list of events. */
2248 gceSTATUS
2249 gckEVENT_AddList(
2250     IN gckEVENT Event,
2251     IN gcsHAL_INTERFACE_PTR Interface,
2252     IN gceKERNEL_WHERE FromWhere,
2253     IN gctBOOL AllocateAllowed,
2254     IN gctBOOL FromKernel
2255     );
2256
2257 /* Schedule a FreeNonPagedMemory event. */
2258 gceSTATUS
2259 gckEVENT_FreeNonPagedMemory(
2260     IN gckEVENT Event,
2261     IN gctSIZE_T Bytes,
2262     IN gctPHYS_ADDR Physical,
2263     IN gctPOINTER Logical,
2264     IN gceKERNEL_WHERE FromWhere
2265     );
2266
2267 /* Schedule a FreeContiguousMemory event. */
2268 gceSTATUS
2269 gckEVENT_FreeContiguousMemory(
2270     IN gckEVENT Event,
2271     IN gctSIZE_T Bytes,
2272     IN gctPHYS_ADDR Physical,
2273     IN gctPOINTER Logical,
2274     IN gceKERNEL_WHERE FromWhere
2275     );
2276
2277 /* Schedule a FreeVideoMemory event. */
2278 gceSTATUS
2279 gckEVENT_FreeVideoMemory(
2280     IN gckEVENT Event,
2281     IN gcuVIDMEM_NODE_PTR VideoMemory,
2282     IN gceKERNEL_WHERE FromWhere
2283     );
2284
2285 /* Schedule a signal event. */
2286 gceSTATUS
2287 gckEVENT_Signal(
2288     IN gckEVENT Event,
2289     IN gctSIGNAL Signal,
2290     IN gceKERNEL_WHERE FromWhere
2291     );
2292
2293 /* Schedule an Unlock event. */
2294 gceSTATUS
2295 gckEVENT_Unlock(
2296     IN gckEVENT Event,
2297     IN gceKERNEL_WHERE FromWhere,
2298     IN gcuVIDMEM_NODE_PTR Node,
2299     IN gceSURF_TYPE Type
2300     );
2301
2302 gceSTATUS
2303 gckEVENT_CommitDone(
2304     IN gckEVENT Event,
2305     IN gceKERNEL_WHERE FromWhere
2306     );
2307
2308 #if gcdVIRTUAL_COMMAND_BUFFER
2309 /* Schedule a FreeVirtualCommandBuffer event. */
2310 gceSTATUS
2311 gckEVENT_DestroyVirtualCommandBuffer(
2312     IN gckEVENT Event,
2313     IN gctSIZE_T Bytes,
2314     IN gctPHYS_ADDR Physical,
2315     IN gctPOINTER Logical,
2316     IN gceKERNEL_WHERE FromWhere
2317     );
2318 #endif
2319
2320 gceSTATUS
2321 gckEVENT_Submit(
2322     IN gckEVENT Event,
2323     IN gctBOOL Wait,
2324     IN gctBOOL FromPower
2325     );
2326
2327 /* Commit an event queue. */
2328 gceSTATUS
2329 gckEVENT_Commit(
2330     IN gckEVENT Event,
2331     IN gcsQUEUE_PTR Queue
2332     );
2333
2334 /* Schedule a composition event. */
2335 gceSTATUS
2336 gckEVENT_Compose(
2337     IN gckEVENT Event,
2338     IN gcsHAL_COMPOSE_PTR Info
2339     );
2340
2341 /* Event callback routine. */
2342 gceSTATUS
2343 gckEVENT_Notify(
2344     IN gckEVENT Event,
2345     IN gctUINT32 IDs
2346     );
2347
2348 /* Event callback routine. */
2349 gceSTATUS
2350 gckEVENT_Interrupt(
2351     IN gckEVENT Event,
2352     IN gctUINT32 IDs
2353     );
2354
2355 gceSTATUS
2356 gckEVENT_Dump(
2357     IN gckEVENT Event
2358     );
2359 /******************************************************************************\
2360 ******************************* gckCOMMAND Object ******************************
2361 \******************************************************************************/
2362
2363 typedef struct _gckCOMMAND *        gckCOMMAND;
2364
2365 /* Construct a new gckCOMMAND object. */
2366 gceSTATUS
2367 gckCOMMAND_Construct(
2368     IN gckKERNEL Kernel,
2369     OUT gckCOMMAND * Command
2370     );
2371
2372 /* Destroy an gckCOMMAND object. */
2373 gceSTATUS
2374 gckCOMMAND_Destroy(
2375     IN gckCOMMAND Command
2376     );
2377
2378 /* Acquire command queue synchronization objects. */
2379 gceSTATUS
2380 gckCOMMAND_EnterCommit(
2381     IN gckCOMMAND Command,
2382     IN gctBOOL FromPower
2383     );
2384
2385 /* Release command queue synchronization objects. */
2386 gceSTATUS
2387 gckCOMMAND_ExitCommit(
2388     IN gckCOMMAND Command,
2389     IN gctBOOL FromPower
2390     );
2391
2392 /* Start the command queue. */
2393 gceSTATUS
2394 gckCOMMAND_Start(
2395     IN gckCOMMAND Command
2396     );
2397
2398 /* Stop the command queue. */
2399 gceSTATUS
2400 gckCOMMAND_Stop(
2401     IN gckCOMMAND Command,
2402     IN gctBOOL FromRecovery
2403     );
2404
2405 /* Commit a buffer to the command queue. */
2406 gceSTATUS
2407 gckCOMMAND_Commit(
2408     IN gckCOMMAND Command,
2409     IN gckCONTEXT Context,
2410     IN gcoCMDBUF CommandBuffer,
2411     IN gcsSTATE_DELTA_PTR StateDelta,
2412     IN gcsQUEUE_PTR EventQueue,
2413     IN gctUINT32 ProcessID
2414     );
2415
2416 /* Reserve space in the command buffer. */
2417 gceSTATUS
2418 gckCOMMAND_Reserve(
2419     IN gckCOMMAND Command,
2420     IN gctSIZE_T RequestedBytes,
2421     OUT gctPOINTER * Buffer,
2422     OUT gctSIZE_T * BufferSize
2423     );
2424
2425 /* Execute reserved space in the command buffer. */
2426 gceSTATUS
2427 gckCOMMAND_Execute(
2428     IN gckCOMMAND Command,
2429     IN gctSIZE_T RequstedBytes
2430     );
2431
2432 /* Stall the command queue. */
2433 gceSTATUS
2434 gckCOMMAND_Stall(
2435     IN gckCOMMAND Command,
2436     IN gctBOOL FromPower
2437     );
2438
2439 /* Attach user process. */
2440 gceSTATUS
2441 gckCOMMAND_Attach(
2442     IN gckCOMMAND Command,
2443     OUT gckCONTEXT * Context,
2444     OUT gctSIZE_T * StateCount,
2445     IN gctUINT32 ProcessID
2446     );
2447
2448 /* Detach user process. */
2449 gceSTATUS
2450 gckCOMMAND_Detach(
2451     IN gckCOMMAND Command,
2452     IN gckCONTEXT Context
2453     );
2454
2455 #if gcdVIRTUAL_COMMAND_BUFFER
2456 gceSTATUS
2457 gckCOMMAND_DumpExecutingBuffer(
2458     IN gckCOMMAND Command
2459     );
2460 #endif
2461
2462 /******************************************************************************\
2463 ********************************* gckMMU Object ********************************
2464 \******************************************************************************/
2465
2466 typedef struct _gckMMU *            gckMMU;
2467
2468 /* Construct a new gckMMU object. */
2469 gceSTATUS
2470 gckMMU_Construct(
2471     IN gckKERNEL Kernel,
2472     IN gctSIZE_T MmuSize,
2473     OUT gckMMU * Mmu
2474     );
2475
2476 /* Destroy an gckMMU object. */
2477 gceSTATUS
2478 gckMMU_Destroy(
2479     IN gckMMU Mmu
2480     );
2481
2482 /* Enable the MMU. */
2483 gceSTATUS
2484 gckMMU_Enable(
2485     IN gckMMU Mmu,
2486     IN gctUINT32 PhysBaseAddr,
2487     IN gctUINT32 PhysSize
2488     );
2489
2490 /* Allocate pages inside the MMU. */
2491 gceSTATUS
2492 gckMMU_AllocatePages(
2493     IN gckMMU Mmu,
2494     IN gctSIZE_T PageCount,
2495     OUT gctPOINTER * PageTable,
2496     OUT gctUINT32 * Address
2497     );
2498
2499 /* Remove a page table from the MMU. */
2500 gceSTATUS
2501 gckMMU_FreePages(
2502     IN gckMMU Mmu,
2503     IN gctPOINTER PageTable,
2504     IN gctSIZE_T PageCount
2505     );
2506
2507 /* Set the MMU page with info. */
2508 gceSTATUS
2509 gckMMU_SetPage(
2510    IN gckMMU Mmu,
2511    IN gctUINT32 PageAddress,
2512    IN gctUINT32 *PageEntry
2513    );
2514
2515 #ifdef __QNXNTO__
2516 gceSTATUS
2517 gckMMU_InsertNode(
2518     IN gckMMU Mmu,
2519     IN gcuVIDMEM_NODE_PTR Node);
2520
2521 gceSTATUS
2522 gckMMU_RemoveNode(
2523     IN gckMMU Mmu,
2524     IN gcuVIDMEM_NODE_PTR Node);
2525 #endif
2526
2527 #ifdef __QNXNTO__
2528 gceSTATUS
2529 gckMMU_FreeHandleMemory(
2530     IN gckKERNEL Kernel,
2531     IN gckMMU Mmu,
2532     IN gctUINT32 Pid
2533     );
2534 #endif
2535
2536 gceSTATUS
2537 gckMMU_Flush(
2538     IN gckMMU Mmu
2539     );
2540
2541 gceSTATUS
2542 gckMMU_DumpPageTableEntry(
2543     IN gckMMU Mmu,
2544     IN gctUINT32 Address
2545     );
2546
2547
2548 #if VIVANTE_PROFILER
2549 gceSTATUS
2550 gckHARDWARE_QueryProfileRegisters(
2551     IN gckHARDWARE Hardware,
2552     IN gctBOOL   Clear,
2553     OUT gcsPROFILER_COUNTERS * Counters
2554     );
2555 #endif
2556
2557 gceSTATUS
2558 gckOS_SignalQueryHardware(
2559     IN gckOS Os,
2560     IN gctSIGNAL Signal,
2561     OUT gckHARDWARE * Hardware
2562     );
2563
2564 gceSTATUS
2565 gckOS_SignalSetHardware(
2566     IN gckOS Os,
2567     IN gctSIGNAL Signal,
2568     gckHARDWARE Hardware
2569     );
2570
2571 #ifdef __cplusplus
2572 }
2573 #endif
2574
2575 #if gcdENABLE_VG
2576 #include "gc_hal_vg.h"
2577 #endif
2578
2579 #endif /* __gc_hal_h_ */