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

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