drivers/staging/imgtec/rogue/generated/rgxta3d_bridge/server_rgxta3d_bridge.c

   1 /*************************************************************************/ /*!
   2 @File
   3 @Title          Server bridge for rgxta3d
   4 @Copyright      Copyright (c) Imagination Technologies Ltd. All Rights Reserved
   5 @Description    Implements the server side of the bridge for rgxta3d
   6 @License        Dual MIT/GPLv2
   7
   8 The contents of this file are subject to the MIT license as set out below.
   9
  10 Permission is hereby granted, free of charge, to any person obtaining a copy
  11 of this software and associated documentation files (the "Software"), to deal
  12 in the Software without restriction, including without limitation the rights
  13 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14 copies of the Software, and to permit persons to whom the Software is
  15 furnished to do so, subject to the following conditions:
  16
  17 The above copyright notice and this permission notice shall be included in
  18 all copies or substantial portions of the Software.
  19
  20 Alternatively, the contents of this file may be used under the terms of
  21 the GNU General Public License Version 2 ("GPL") in which case the provisions
  22 of GPL are applicable instead of those above.
  23
  24 If you wish to allow use of your version of this file only under the terms of
  25 GPL, and not to allow others to use your version of this file under the terms
  26 of the MIT license, indicate your decision by deleting the provisions above
  27 and replace them with the notice and other provisions required by GPL as set
  28 out in the file called "GPL-COPYING" included in this distribution. If you do
  29 not delete the provisions above, a recipient may use your version of this file
  30 under the terms of either the MIT license or GPL.
  31
  32 This License is also included in this distribution in the file called
  33 "MIT-COPYING".
  34
  35 EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) THE SOFTWARE IS
  36 PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
  37 BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  38 PURPOSE AND NONINFRINGEMENT; AND (B) IN NO EVENT SHALL THE AUTHORS OR
  39 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  40 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  41 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  42 */ /**************************************************************************/
  43
  44 #include <stddef.h>
  45 #include <asm/uaccess.h>
  46
  47 #include "img_defs.h"
  48
  49 #include "rgxta3d.h"
  50
  51
  52 #include "common_rgxta3d_bridge.h"
  53
  54 #include "allocmem.h"
  55 #include "pvr_debug.h"
  56 #include "connection_server.h"
  57 #include "pvr_bridge.h"
  58 #include "rgx_bridge.h"
  59 #include "srvcore.h"
  60 #include "handle.h"
  61
  62 #include <linux/slab.h>
  63
  64
  65
  66
  67
  68
  69 /* ***************************************************************************
  70  * Server-side bridge entry points
  71  */
  72
  73 static IMG_INT
  74 PVRSRVBridgeRGXCreateHWRTData(IMG_UINT32 ui32DispatchTableEntry,
  75                                           PVRSRV_BRIDGE_IN_RGXCREATEHWRTDATA *psRGXCreateHWRTDataIN,
  76                                           PVRSRV_BRIDGE_OUT_RGXCREATEHWRTDATA *psRGXCreateHWRTDataOUT,
  77                                          CONNECTION_DATA *psConnection)
  78 {
  79         RGX_FREELIST * *psapsFreeListsInt = NULL;
  80         IMG_HANDLE *hapsFreeListsInt2 = NULL;
  81         RGX_RTDATA_CLEANUP_DATA * psCleanupCookieInt = NULL;
  82         DEVMEM_MEMDESC * psRTACtlMemDescInt = NULL;
  83         DEVMEM_MEMDESC * pssHWRTDataMemDescInt = NULL;
  84
  85         IMG_UINT32 ui32NextOffset = 0;
  86         IMG_BYTE   *pArrayArgsBuffer = NULL;
  87 #if !defined(INTEGRITY_OS)
  88         IMG_BOOL bHaveEnoughSpace = IMG_FALSE;
  89 #endif
  90
  91         IMG_UINT32 ui32BufferSize =
  92                         (RGXFW_MAX_FREELISTS * sizeof(RGX_FREELIST *)) +
  93                         (RGXFW_MAX_FREELISTS * sizeof(IMG_HANDLE)) +
  94                         0;
  95
  96
  97
  98
  99         psRGXCreateHWRTDataOUT->hCleanupCookie = NULL;
 100
 101         if (ui32BufferSize != 0)
 102         {
 103 #if !defined(INTEGRITY_OS)
 104                 /* Try to use remainder of input buffer for copies if possible, word-aligned for safety. */
 105                 IMG_UINT32 ui32InBufferOffset = PVR_ALIGN(sizeof(*psRGXCreateHWRTDataIN), sizeof(unsigned long));
 106                 IMG_UINT32 ui32InBufferExcessSize = ui32InBufferOffset >= PVRSRV_MAX_BRIDGE_IN_SIZE ? 0 :
 107                         PVRSRV_MAX_BRIDGE_IN_SIZE - ui32InBufferOffset;
 108
 109                 bHaveEnoughSpace = ui32BufferSize <= ui32InBufferExcessSize;
 110                 if (bHaveEnoughSpace)
 111                 {
 112                         IMG_BYTE *pInputBuffer = (IMG_BYTE *)psRGXCreateHWRTDataIN;
 113
 114                         pArrayArgsBuffer = &pInputBuffer[ui32InBufferOffset];           }
 115                 else
 116 #endif
 117                 {
 118                         pArrayArgsBuffer = OSAllocMemNoStats(ui32BufferSize);
 119
 120                         if(!pArrayArgsBuffer)
 121                         {
 122                                 psRGXCreateHWRTDataOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 123                                 goto RGXCreateHWRTData_exit;
 124                         }
 125                 }
 126         }
 127
 128
 129         {
 130                 psapsFreeListsInt = (RGX_FREELIST **)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
 131                 ui32NextOffset += RGXFW_MAX_FREELISTS * sizeof(RGX_FREELIST *);
 132                 hapsFreeListsInt2 = (IMG_HANDLE *)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
 133                 ui32NextOffset += RGXFW_MAX_FREELISTS * sizeof(IMG_HANDLE);
 134         }
 135
 136                         /* Copy the data over */
 137                         if (RGXFW_MAX_FREELISTS * sizeof(IMG_HANDLE) > 0)
 138                         {
 139                                 if ( OSCopyFromUser(NULL, hapsFreeListsInt2, psRGXCreateHWRTDataIN->phapsFreeLists, RGXFW_MAX_FREELISTS * sizeof(IMG_HANDLE)) != PVRSRV_OK )
 140                                 {
 141                                         psRGXCreateHWRTDataOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 142
 143                                         goto RGXCreateHWRTData_exit;
 144                                 }
 145                         }
 146
 147         /* Lock over handle lookup. */
 148         LockHandle();
 149
 150
 151
 152
 153
 154         {
 155                 IMG_UINT32 i;
 156
 157                 for (i=0;i<RGXFW_MAX_FREELISTS;i++)
 158                 {
 159                                 {
 160                                         /* Look up the address from the handle */
 161                                         psRGXCreateHWRTDataOUT->eError =
 162                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
 163                                                                                         (void **) &psapsFreeListsInt[i],
 164                                                                                         hapsFreeListsInt2[i],
 165                                                                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST,
 166                                                                                         IMG_TRUE);
 167                                         if(psRGXCreateHWRTDataOUT->eError != PVRSRV_OK)
 168                                         {
 169                                                 UnlockHandle();
 170                                                 goto RGXCreateHWRTData_exit;
 171                                         }
 172                                 }
 173                 }
 174         }
 175         /* Release now we have looked up handles. */
 176         UnlockHandle();
 177
 178         psRGXCreateHWRTDataOUT->eError =
 179                 RGXCreateHWRTData(psConnection, OSGetDevData(psConnection),
 180                                         psRGXCreateHWRTDataIN->ui32RenderTarget,
 181                                         psRGXCreateHWRTDataIN->sPMMlistDevVAddr,
 182                                         psRGXCreateHWRTDataIN->sVFPPageTableAddr,
 183                                         psapsFreeListsInt,
 184                                         &psCleanupCookieInt,
 185                                         &psRTACtlMemDescInt,
 186                                         psRGXCreateHWRTDataIN->ui32PPPScreen,
 187                                         psRGXCreateHWRTDataIN->ui32PPPGridOffset,
 188                                         psRGXCreateHWRTDataIN->ui64PPPMultiSampleCtl,
 189                                         psRGXCreateHWRTDataIN->ui32TPCStride,
 190                                         psRGXCreateHWRTDataIN->sTailPtrsDevVAddr,
 191                                         psRGXCreateHWRTDataIN->ui32TPCSize,
 192                                         psRGXCreateHWRTDataIN->ui32TEScreen,
 193                                         psRGXCreateHWRTDataIN->ui32TEAA,
 194                                         psRGXCreateHWRTDataIN->ui32TEMTILE1,
 195                                         psRGXCreateHWRTDataIN->ui32TEMTILE2,
 196                                         psRGXCreateHWRTDataIN->ui32MTileStride,
 197                                         psRGXCreateHWRTDataIN->ui32ui32ISPMergeLowerX,
 198                                         psRGXCreateHWRTDataIN->ui32ui32ISPMergeLowerY,
 199                                         psRGXCreateHWRTDataIN->ui32ui32ISPMergeUpperX,
 200                                         psRGXCreateHWRTDataIN->ui32ui32ISPMergeUpperY,
 201                                         psRGXCreateHWRTDataIN->ui32ui32ISPMergeScaleX,
 202                                         psRGXCreateHWRTDataIN->ui32ui32ISPMergeScaleY,
 203                                         psRGXCreateHWRTDataIN->ui16MaxRTs,
 204                                         &pssHWRTDataMemDescInt,
 205                                         &psRGXCreateHWRTDataOUT->ui32FWHWRTData);
 206         /* Exit early if bridged call fails */
 207         if(psRGXCreateHWRTDataOUT->eError != PVRSRV_OK)
 208         {
 209                 goto RGXCreateHWRTData_exit;
 210         }
 211
 212         /* Lock over handle creation. */
 213         LockHandle();
 214
 215
 216
 217
 218
 219         psRGXCreateHWRTDataOUT->eError = PVRSRVAllocHandleUnlocked(psConnection->psHandleBase,
 220
 221                                                         &psRGXCreateHWRTDataOUT->hCleanupCookie,
 222                                                         (void *) psCleanupCookieInt,
 223                                                         PVRSRV_HANDLE_TYPE_RGX_RTDATA_CLEANUP,
 224                                                         PVRSRV_HANDLE_ALLOC_FLAG_MULTI
 225                                                         ,(PFN_HANDLE_RELEASE)&RGXDestroyHWRTData);
 226         if (psRGXCreateHWRTDataOUT->eError != PVRSRV_OK)
 227         {
 228                 UnlockHandle();
 229                 goto RGXCreateHWRTData_exit;
 230         }
 231
 232
 233
 234
 235
 236
 237         psRGXCreateHWRTDataOUT->eError = PVRSRVAllocSubHandleUnlocked(psConnection->psHandleBase,
 238
 239                                                         &psRGXCreateHWRTDataOUT->hRTACtlMemDesc,
 240                                                         (void *) psRTACtlMemDescInt,
 241                                                         PVRSRV_HANDLE_TYPE_RGX_FW_MEMDESC,
 242                                                         PVRSRV_HANDLE_ALLOC_FLAG_NONE
 243                                                         ,psRGXCreateHWRTDataOUT->hCleanupCookie);
 244         if (psRGXCreateHWRTDataOUT->eError != PVRSRV_OK)
 245         {
 246                 UnlockHandle();
 247                 goto RGXCreateHWRTData_exit;
 248         }
 249
 250
 251
 252
 253
 254
 255         psRGXCreateHWRTDataOUT->eError = PVRSRVAllocSubHandleUnlocked(psConnection->psHandleBase,
 256
 257                                                         &psRGXCreateHWRTDataOUT->hsHWRTDataMemDesc,
 258                                                         (void *) pssHWRTDataMemDescInt,
 259                                                         PVRSRV_HANDLE_TYPE_RGX_FW_MEMDESC,
 260                                                         PVRSRV_HANDLE_ALLOC_FLAG_NONE
 261                                                         ,psRGXCreateHWRTDataOUT->hCleanupCookie);
 262         if (psRGXCreateHWRTDataOUT->eError != PVRSRV_OK)
 263         {
 264                 UnlockHandle();
 265                 goto RGXCreateHWRTData_exit;
 266         }
 267
 268         /* Release now we have created handles. */
 269         UnlockHandle();
 270
 271
 272
 273 RGXCreateHWRTData_exit:
 274
 275         /* Lock over handle lookup cleanup. */
 276         LockHandle();
 277
 278
 279
 280
 281
 282
 283         {
 284                 IMG_UINT32 i;
 285
 286                 for (i=0;i<RGXFW_MAX_FREELISTS;i++)
 287                 {
 288                                 {
 289                                         /* Unreference the previously looked up handle */
 290                                                 if(psapsFreeListsInt[i])
 291                                                 {
 292                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
 293                                                                                         hapsFreeListsInt2[i],
 294                                                                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST);
 295                                                 }
 296                                 }
 297                 }
 298         }
 299         /* Release now we have cleaned up look up handles. */
 300         UnlockHandle();
 301
 302         if (psRGXCreateHWRTDataOUT->eError != PVRSRV_OK)
 303         {
 304                 /* Lock over handle creation cleanup. */
 305                 LockHandle();
 306                 if (psRGXCreateHWRTDataOUT->hCleanupCookie)
 307                 {
 308
 309
 310                         PVRSRV_ERROR eError = PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
 311                                                 (IMG_HANDLE) psRGXCreateHWRTDataOUT->hCleanupCookie,
 312                                                 PVRSRV_HANDLE_TYPE_RGX_RTDATA_CLEANUP);
 313                         if ((eError != PVRSRV_OK) && (eError != PVRSRV_ERROR_RETRY))
 314                         {
 315                                 PVR_DPF((PVR_DBG_ERROR,
 316                                         "PVRSRVBridgeRGXCreateHWRTData: %s",
 317                                         PVRSRVGetErrorStringKM(eError)));
 318                         }
 319                         /* Releasing the handle should free/destroy/release the resource.
 320                          * This should never fail... */
 321                         PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
 322
 323                         /* Avoid freeing/destroying/releasing the resource a second time below */
 324                         psCleanupCookieInt = NULL;
 325                 }
 326
 327
 328                 /* Release now we have cleaned up creation handles. */
 329                 UnlockHandle();
 330                 if (psCleanupCookieInt)
 331                 {
 332                         RGXDestroyHWRTData(psCleanupCookieInt);
 333                 }
 334         }
 335
 336         /* Allocated space should be equal to the last updated offset */
 337         PVR_ASSERT(ui32BufferSize == ui32NextOffset);
 338
 339 #if defined(INTEGRITY_OS)
 340         if(pArrayArgsBuffer)
 341 #else
 342         if(!bHaveEnoughSpace && pArrayArgsBuffer)
 343 #endif
 344                 OSFreeMemNoStats(pArrayArgsBuffer);
 345
 346
 347         return 0;
 348 }
 349
 350
 351 static IMG_INT
 352 PVRSRVBridgeRGXDestroyHWRTData(IMG_UINT32 ui32DispatchTableEntry,
 353                                           PVRSRV_BRIDGE_IN_RGXDESTROYHWRTDATA *psRGXDestroyHWRTDataIN,
 354                                           PVRSRV_BRIDGE_OUT_RGXDESTROYHWRTDATA *psRGXDestroyHWRTDataOUT,
 355                                          CONNECTION_DATA *psConnection)
 356 {
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366         /* Lock over handle destruction. */
 367         LockHandle();
 368
 369
 370
 371
 372
 373         psRGXDestroyHWRTDataOUT->eError =
 374                 PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
 375                                         (IMG_HANDLE) psRGXDestroyHWRTDataIN->hCleanupCookie,
 376                                         PVRSRV_HANDLE_TYPE_RGX_RTDATA_CLEANUP);
 377         if ((psRGXDestroyHWRTDataOUT->eError != PVRSRV_OK) &&
 378             (psRGXDestroyHWRTDataOUT->eError != PVRSRV_ERROR_RETRY))
 379         {
 380                 PVR_DPF((PVR_DBG_ERROR,
 381                         "PVRSRVBridgeRGXDestroyHWRTData: %s",
 382                         PVRSRVGetErrorStringKM(psRGXDestroyHWRTDataOUT->eError)));
 383                 PVR_ASSERT(0);
 384                 UnlockHandle();
 385                 goto RGXDestroyHWRTData_exit;
 386         }
 387
 388         /* Release now we have destroyed handles. */
 389         UnlockHandle();
 390
 391
 392
 393 RGXDestroyHWRTData_exit:
 394
 395
 396
 397
 398         return 0;
 399 }
 400
 401
 402 static IMG_INT
 403 PVRSRVBridgeRGXCreateRenderTarget(IMG_UINT32 ui32DispatchTableEntry,
 404                                           PVRSRV_BRIDGE_IN_RGXCREATERENDERTARGET *psRGXCreateRenderTargetIN,
 405                                           PVRSRV_BRIDGE_OUT_RGXCREATERENDERTARGET *psRGXCreateRenderTargetOUT,
 406                                          CONNECTION_DATA *psConnection)
 407 {
 408         RGX_RT_CLEANUP_DATA * pssRenderTargetMemDescInt = NULL;
 409
 410
 411
 412
 413
 414
 415
 416
 417         psRGXCreateRenderTargetOUT->eError =
 418                 RGXCreateRenderTarget(psConnection, OSGetDevData(psConnection),
 419                                         psRGXCreateRenderTargetIN->spsVHeapTableDevVAddr,
 420                                         &pssRenderTargetMemDescInt,
 421                                         &psRGXCreateRenderTargetOUT->ui32sRenderTargetFWDevVAddr);
 422         /* Exit early if bridged call fails */
 423         if(psRGXCreateRenderTargetOUT->eError != PVRSRV_OK)
 424         {
 425                 goto RGXCreateRenderTarget_exit;
 426         }
 427
 428         /* Lock over handle creation. */
 429         LockHandle();
 430
 431
 432
 433
 434
 435         psRGXCreateRenderTargetOUT->eError = PVRSRVAllocHandleUnlocked(psConnection->psHandleBase,
 436
 437                                                         &psRGXCreateRenderTargetOUT->hsRenderTargetMemDesc,
 438                                                         (void *) pssRenderTargetMemDescInt,
 439                                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_RENDERTARGET,
 440                                                         PVRSRV_HANDLE_ALLOC_FLAG_MULTI
 441                                                         ,(PFN_HANDLE_RELEASE)&RGXDestroyRenderTarget);
 442         if (psRGXCreateRenderTargetOUT->eError != PVRSRV_OK)
 443         {
 444                 UnlockHandle();
 445                 goto RGXCreateRenderTarget_exit;
 446         }
 447
 448         /* Release now we have created handles. */
 449         UnlockHandle();
 450
 451
 452
 453 RGXCreateRenderTarget_exit:
 454
 455
 456
 457         if (psRGXCreateRenderTargetOUT->eError != PVRSRV_OK)
 458         {
 459                 if (pssRenderTargetMemDescInt)
 460                 {
 461                         RGXDestroyRenderTarget(pssRenderTargetMemDescInt);
 462                 }
 463         }
 464
 465
 466         return 0;
 467 }
 468
 469
 470 static IMG_INT
 471 PVRSRVBridgeRGXDestroyRenderTarget(IMG_UINT32 ui32DispatchTableEntry,
 472                                           PVRSRV_BRIDGE_IN_RGXDESTROYRENDERTARGET *psRGXDestroyRenderTargetIN,
 473                                           PVRSRV_BRIDGE_OUT_RGXDESTROYRENDERTARGET *psRGXDestroyRenderTargetOUT,
 474                                          CONNECTION_DATA *psConnection)
 475 {
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485         /* Lock over handle destruction. */
 486         LockHandle();
 487
 488
 489
 490
 491
 492         psRGXDestroyRenderTargetOUT->eError =
 493                 PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
 494                                         (IMG_HANDLE) psRGXDestroyRenderTargetIN->hsRenderTargetMemDesc,
 495                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_RENDERTARGET);
 496         if ((psRGXDestroyRenderTargetOUT->eError != PVRSRV_OK) &&
 497             (psRGXDestroyRenderTargetOUT->eError != PVRSRV_ERROR_RETRY))
 498         {
 499                 PVR_DPF((PVR_DBG_ERROR,
 500                         "PVRSRVBridgeRGXDestroyRenderTarget: %s",
 501                         PVRSRVGetErrorStringKM(psRGXDestroyRenderTargetOUT->eError)));
 502                 PVR_ASSERT(0);
 503                 UnlockHandle();
 504                 goto RGXDestroyRenderTarget_exit;
 505         }
 506
 507         /* Release now we have destroyed handles. */
 508         UnlockHandle();
 509
 510
 511
 512 RGXDestroyRenderTarget_exit:
 513
 514
 515
 516
 517         return 0;
 518 }
 519
 520
 521 static IMG_INT
 522 PVRSRVBridgeRGXCreateZSBuffer(IMG_UINT32 ui32DispatchTableEntry,
 523                                           PVRSRV_BRIDGE_IN_RGXCREATEZSBUFFER *psRGXCreateZSBufferIN,
 524                                           PVRSRV_BRIDGE_OUT_RGXCREATEZSBUFFER *psRGXCreateZSBufferOUT,
 525                                          CONNECTION_DATA *psConnection)
 526 {
 527         IMG_HANDLE hReservation = psRGXCreateZSBufferIN->hReservation;
 528         DEVMEMINT_RESERVATION * psReservationInt = NULL;
 529         IMG_HANDLE hPMR = psRGXCreateZSBufferIN->hPMR;
 530         PMR * psPMRInt = NULL;
 531         RGX_ZSBUFFER_DATA * pssZSBufferKMInt = NULL;
 532
 533
 534
 535
 536
 537
 538
 539         /* Lock over handle lookup. */
 540         LockHandle();
 541
 542
 543
 544
 545
 546                                 {
 547                                         /* Look up the address from the handle */
 548                                         psRGXCreateZSBufferOUT->eError =
 549                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
 550                                                                                         (void **) &psReservationInt,
 551                                                                                         hReservation,
 552                                                                                         PVRSRV_HANDLE_TYPE_DEVMEMINT_RESERVATION,
 553                                                                                         IMG_TRUE);
 554                                         if(psRGXCreateZSBufferOUT->eError != PVRSRV_OK)
 555                                         {
 556                                                 UnlockHandle();
 557                                                 goto RGXCreateZSBuffer_exit;
 558                                         }
 559                                 }
 560
 561
 562
 563
 564
 565                                 {
 566                                         /* Look up the address from the handle */
 567                                         psRGXCreateZSBufferOUT->eError =
 568                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
 569                                                                                         (void **) &psPMRInt,
 570                                                                                         hPMR,
 571                                                                                         PVRSRV_HANDLE_TYPE_PHYSMEM_PMR,
 572                                                                                         IMG_TRUE);
 573                                         if(psRGXCreateZSBufferOUT->eError != PVRSRV_OK)
 574                                         {
 575                                                 UnlockHandle();
 576                                                 goto RGXCreateZSBuffer_exit;
 577                                         }
 578                                 }
 579         /* Release now we have looked up handles. */
 580         UnlockHandle();
 581
 582         psRGXCreateZSBufferOUT->eError =
 583                 RGXCreateZSBufferKM(psConnection, OSGetDevData(psConnection),
 584                                         psReservationInt,
 585                                         psPMRInt,
 586                                         psRGXCreateZSBufferIN->uiMapFlags,
 587                                         &pssZSBufferKMInt,
 588                                         &psRGXCreateZSBufferOUT->ui32sZSBufferFWDevVAddr);
 589         /* Exit early if bridged call fails */
 590         if(psRGXCreateZSBufferOUT->eError != PVRSRV_OK)
 591         {
 592                 goto RGXCreateZSBuffer_exit;
 593         }
 594
 595         /* Lock over handle creation. */
 596         LockHandle();
 597
 598
 599
 600
 601
 602         psRGXCreateZSBufferOUT->eError = PVRSRVAllocHandleUnlocked(psConnection->psHandleBase,
 603
 604                                                         &psRGXCreateZSBufferOUT->hsZSBufferKM,
 605                                                         (void *) pssZSBufferKMInt,
 606                                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_ZSBUFFER,
 607                                                         PVRSRV_HANDLE_ALLOC_FLAG_MULTI
 608                                                         ,(PFN_HANDLE_RELEASE)&RGXDestroyZSBufferKM);
 609         if (psRGXCreateZSBufferOUT->eError != PVRSRV_OK)
 610         {
 611                 UnlockHandle();
 612                 goto RGXCreateZSBuffer_exit;
 613         }
 614
 615         /* Release now we have created handles. */
 616         UnlockHandle();
 617
 618
 619
 620 RGXCreateZSBuffer_exit:
 621
 622         /* Lock over handle lookup cleanup. */
 623         LockHandle();
 624
 625
 626
 627
 628
 629
 630                                 {
 631                                         /* Unreference the previously looked up handle */
 632                                                 if(psReservationInt)
 633                                                 {
 634                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
 635                                                                                         hReservation,
 636                                                                                         PVRSRV_HANDLE_TYPE_DEVMEMINT_RESERVATION);
 637                                                 }
 638                                 }
 639
 640
 641
 642
 643
 644                                 {
 645                                         /* Unreference the previously looked up handle */
 646                                                 if(psPMRInt)
 647                                                 {
 648                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
 649                                                                                         hPMR,
 650                                                                                         PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
 651                                                 }
 652                                 }
 653         /* Release now we have cleaned up look up handles. */
 654         UnlockHandle();
 655
 656         if (psRGXCreateZSBufferOUT->eError != PVRSRV_OK)
 657         {
 658                 if (pssZSBufferKMInt)
 659                 {
 660                         RGXDestroyZSBufferKM(pssZSBufferKMInt);
 661                 }
 662         }
 663
 664
 665         return 0;
 666 }
 667
 668
 669 static IMG_INT
 670 PVRSRVBridgeRGXDestroyZSBuffer(IMG_UINT32 ui32DispatchTableEntry,
 671                                           PVRSRV_BRIDGE_IN_RGXDESTROYZSBUFFER *psRGXDestroyZSBufferIN,
 672                                           PVRSRV_BRIDGE_OUT_RGXDESTROYZSBUFFER *psRGXDestroyZSBufferOUT,
 673                                          CONNECTION_DATA *psConnection)
 674 {
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684         /* Lock over handle destruction. */
 685         LockHandle();
 686
 687
 688
 689
 690
 691         psRGXDestroyZSBufferOUT->eError =
 692                 PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
 693                                         (IMG_HANDLE) psRGXDestroyZSBufferIN->hsZSBufferMemDesc,
 694                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_ZSBUFFER);
 695         if ((psRGXDestroyZSBufferOUT->eError != PVRSRV_OK) &&
 696             (psRGXDestroyZSBufferOUT->eError != PVRSRV_ERROR_RETRY))
 697         {
 698                 PVR_DPF((PVR_DBG_ERROR,
 699                         "PVRSRVBridgeRGXDestroyZSBuffer: %s",
 700                         PVRSRVGetErrorStringKM(psRGXDestroyZSBufferOUT->eError)));
 701                 PVR_ASSERT(0);
 702                 UnlockHandle();
 703                 goto RGXDestroyZSBuffer_exit;
 704         }
 705
 706         /* Release now we have destroyed handles. */
 707         UnlockHandle();
 708
 709
 710
 711 RGXDestroyZSBuffer_exit:
 712
 713
 714
 715
 716         return 0;
 717 }
 718
 719
 720 static IMG_INT
 721 PVRSRVBridgeRGXPopulateZSBuffer(IMG_UINT32 ui32DispatchTableEntry,
 722                                           PVRSRV_BRIDGE_IN_RGXPOPULATEZSBUFFER *psRGXPopulateZSBufferIN,
 723                                           PVRSRV_BRIDGE_OUT_RGXPOPULATEZSBUFFER *psRGXPopulateZSBufferOUT,
 724                                          CONNECTION_DATA *psConnection)
 725 {
 726         IMG_HANDLE hsZSBufferKM = psRGXPopulateZSBufferIN->hsZSBufferKM;
 727         RGX_ZSBUFFER_DATA * pssZSBufferKMInt = NULL;
 728         RGX_POPULATION * pssPopulationInt = NULL;
 729
 730
 731
 732
 733
 734
 735
 736         /* Lock over handle lookup. */
 737         LockHandle();
 738
 739
 740
 741
 742
 743                                 {
 744                                         /* Look up the address from the handle */
 745                                         psRGXPopulateZSBufferOUT->eError =
 746                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
 747                                                                                         (void **) &pssZSBufferKMInt,
 748                                                                                         hsZSBufferKM,
 749                                                                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_ZSBUFFER,
 750                                                                                         IMG_TRUE);
 751                                         if(psRGXPopulateZSBufferOUT->eError != PVRSRV_OK)
 752                                         {
 753                                                 UnlockHandle();
 754                                                 goto RGXPopulateZSBuffer_exit;
 755                                         }
 756                                 }
 757         /* Release now we have looked up handles. */
 758         UnlockHandle();
 759
 760         psRGXPopulateZSBufferOUT->eError =
 761                 RGXPopulateZSBufferKM(
 762                                         pssZSBufferKMInt,
 763                                         &pssPopulationInt);
 764         /* Exit early if bridged call fails */
 765         if(psRGXPopulateZSBufferOUT->eError != PVRSRV_OK)
 766         {
 767                 goto RGXPopulateZSBuffer_exit;
 768         }
 769
 770         /* Lock over handle creation. */
 771         LockHandle();
 772
 773
 774
 775
 776
 777         psRGXPopulateZSBufferOUT->eError = PVRSRVAllocHandleUnlocked(psConnection->psHandleBase,
 778
 779                                                         &psRGXPopulateZSBufferOUT->hsPopulation,
 780                                                         (void *) pssPopulationInt,
 781                                                         PVRSRV_HANDLE_TYPE_RGX_POPULATION,
 782                                                         PVRSRV_HANDLE_ALLOC_FLAG_MULTI
 783                                                         ,(PFN_HANDLE_RELEASE)&RGXUnpopulateZSBufferKM);
 784         if (psRGXPopulateZSBufferOUT->eError != PVRSRV_OK)
 785         {
 786                 UnlockHandle();
 787                 goto RGXPopulateZSBuffer_exit;
 788         }
 789
 790         /* Release now we have created handles. */
 791         UnlockHandle();
 792
 793
 794
 795 RGXPopulateZSBuffer_exit:
 796
 797         /* Lock over handle lookup cleanup. */
 798         LockHandle();
 799
 800
 801
 802
 803
 804
 805                                 {
 806                                         /* Unreference the previously looked up handle */
 807                                                 if(pssZSBufferKMInt)
 808                                                 {
 809                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
 810                                                                                         hsZSBufferKM,
 811                                                                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_ZSBUFFER);
 812                                                 }
 813                                 }
 814         /* Release now we have cleaned up look up handles. */
 815         UnlockHandle();
 816
 817         if (psRGXPopulateZSBufferOUT->eError != PVRSRV_OK)
 818         {
 819                 if (pssPopulationInt)
 820                 {
 821                         RGXUnpopulateZSBufferKM(pssPopulationInt);
 822                 }
 823         }
 824
 825
 826         return 0;
 827 }
 828
 829
 830 static IMG_INT
 831 PVRSRVBridgeRGXUnpopulateZSBuffer(IMG_UINT32 ui32DispatchTableEntry,
 832                                           PVRSRV_BRIDGE_IN_RGXUNPOPULATEZSBUFFER *psRGXUnpopulateZSBufferIN,
 833                                           PVRSRV_BRIDGE_OUT_RGXUNPOPULATEZSBUFFER *psRGXUnpopulateZSBufferOUT,
 834                                          CONNECTION_DATA *psConnection)
 835 {
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845         /* Lock over handle destruction. */
 846         LockHandle();
 847
 848
 849
 850
 851
 852         psRGXUnpopulateZSBufferOUT->eError =
 853                 PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
 854                                         (IMG_HANDLE) psRGXUnpopulateZSBufferIN->hsPopulation,
 855                                         PVRSRV_HANDLE_TYPE_RGX_POPULATION);
 856         if ((psRGXUnpopulateZSBufferOUT->eError != PVRSRV_OK) &&
 857             (psRGXUnpopulateZSBufferOUT->eError != PVRSRV_ERROR_RETRY))
 858         {
 859                 PVR_DPF((PVR_DBG_ERROR,
 860                         "PVRSRVBridgeRGXUnpopulateZSBuffer: %s",
 861                         PVRSRVGetErrorStringKM(psRGXUnpopulateZSBufferOUT->eError)));
 862                 PVR_ASSERT(0);
 863                 UnlockHandle();
 864                 goto RGXUnpopulateZSBuffer_exit;
 865         }
 866
 867         /* Release now we have destroyed handles. */
 868         UnlockHandle();
 869
 870
 871
 872 RGXUnpopulateZSBuffer_exit:
 873
 874
 875
 876
 877         return 0;
 878 }
 879
 880
 881 static IMG_INT
 882 PVRSRVBridgeRGXCreateFreeList(IMG_UINT32 ui32DispatchTableEntry,
 883                                           PVRSRV_BRIDGE_IN_RGXCREATEFREELIST *psRGXCreateFreeListIN,
 884                                           PVRSRV_BRIDGE_OUT_RGXCREATEFREELIST *psRGXCreateFreeListOUT,
 885                                          CONNECTION_DATA *psConnection)
 886 {
 887         IMG_HANDLE hsGlobalFreeList = psRGXCreateFreeListIN->hsGlobalFreeList;
 888         RGX_FREELIST * pssGlobalFreeListInt = NULL;
 889         IMG_HANDLE hsFreeListPMR = psRGXCreateFreeListIN->hsFreeListPMR;
 890         PMR * pssFreeListPMRInt = NULL;
 891         RGX_FREELIST * psCleanupCookieInt = NULL;
 892
 893
 894
 895
 896
 897
 898
 899         /* Lock over handle lookup. */
 900         LockHandle();
 901
 902
 903
 904
 905
 906                                 if (psRGXCreateFreeListIN->hsGlobalFreeList)
 907                                 {
 908                                         /* Look up the address from the handle */
 909                                         psRGXCreateFreeListOUT->eError =
 910                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
 911                                                                                         (void **) &pssGlobalFreeListInt,
 912                                                                                         hsGlobalFreeList,
 913                                                                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST,
 914                                                                                         IMG_TRUE);
 915                                         if(psRGXCreateFreeListOUT->eError != PVRSRV_OK)
 916                                         {
 917                                                 UnlockHandle();
 918                                                 goto RGXCreateFreeList_exit;
 919                                         }
 920                                 }
 921
 922
 923
 924
 925
 926                                 {
 927                                         /* Look up the address from the handle */
 928                                         psRGXCreateFreeListOUT->eError =
 929                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
 930                                                                                         (void **) &pssFreeListPMRInt,
 931                                                                                         hsFreeListPMR,
 932                                                                                         PVRSRV_HANDLE_TYPE_PHYSMEM_PMR,
 933                                                                                         IMG_TRUE);
 934                                         if(psRGXCreateFreeListOUT->eError != PVRSRV_OK)
 935                                         {
 936                                                 UnlockHandle();
 937                                                 goto RGXCreateFreeList_exit;
 938                                         }
 939                                 }
 940         /* Release now we have looked up handles. */
 941         UnlockHandle();
 942
 943         psRGXCreateFreeListOUT->eError =
 944                 RGXCreateFreeList(psConnection, OSGetDevData(psConnection),
 945                                         psRGXCreateFreeListIN->ui32ui32MaxFLPages,
 946                                         psRGXCreateFreeListIN->ui32ui32InitFLPages,
 947                                         psRGXCreateFreeListIN->ui32ui32GrowFLPages,
 948                                         pssGlobalFreeListInt,
 949                                         psRGXCreateFreeListIN->bbFreeListCheck,
 950                                         psRGXCreateFreeListIN->spsFreeListDevVAddr,
 951                                         pssFreeListPMRInt,
 952                                         psRGXCreateFreeListIN->uiPMROffset,
 953                                         &psCleanupCookieInt);
 954         /* Exit early if bridged call fails */
 955         if(psRGXCreateFreeListOUT->eError != PVRSRV_OK)
 956         {
 957                 goto RGXCreateFreeList_exit;
 958         }
 959
 960         /* Lock over handle creation. */
 961         LockHandle();
 962
 963
 964
 965
 966
 967         psRGXCreateFreeListOUT->eError = PVRSRVAllocHandleUnlocked(psConnection->psHandleBase,
 968
 969                                                         &psRGXCreateFreeListOUT->hCleanupCookie,
 970                                                         (void *) psCleanupCookieInt,
 971                                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST,
 972                                                         PVRSRV_HANDLE_ALLOC_FLAG_MULTI
 973                                                         ,(PFN_HANDLE_RELEASE)&RGXDestroyFreeList);
 974         if (psRGXCreateFreeListOUT->eError != PVRSRV_OK)
 975         {
 976                 UnlockHandle();
 977                 goto RGXCreateFreeList_exit;
 978         }
 979
 980         /* Release now we have created handles. */
 981         UnlockHandle();
 982
 983
 984
 985 RGXCreateFreeList_exit:
 986
 987         /* Lock over handle lookup cleanup. */
 988         LockHandle();
 989
 990
 991
 992
 993
 994
 995                                 if (psRGXCreateFreeListIN->hsGlobalFreeList)
 996                                 {
 997                                         /* Unreference the previously looked up handle */
 998                                                 if(pssGlobalFreeListInt)
 999                                                 {
1000                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
1001                                                                                         hsGlobalFreeList,
1002                                                                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST);
1003                                                 }
1004                                 }
1005
1006
1007
1008
1009
1010                                 {
1011                                         /* Unreference the previously looked up handle */
1012                                                 if(pssFreeListPMRInt)
1013                                                 {
1014                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
1015                                                                                         hsFreeListPMR,
1016                                                                                         PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
1017                                                 }
1018                                 }
1019         /* Release now we have cleaned up look up handles. */
1020         UnlockHandle();
1021
1022         if (psRGXCreateFreeListOUT->eError != PVRSRV_OK)
1023         {
1024                 if (psCleanupCookieInt)
1025                 {
1026                         RGXDestroyFreeList(psCleanupCookieInt);
1027                 }
1028         }
1029
1030
1031         return 0;
1032 }
1033
1034
1035 static IMG_INT
1036 PVRSRVBridgeRGXDestroyFreeList(IMG_UINT32 ui32DispatchTableEntry,
1037                                           PVRSRV_BRIDGE_IN_RGXDESTROYFREELIST *psRGXDestroyFreeListIN,
1038                                           PVRSRV_BRIDGE_OUT_RGXDESTROYFREELIST *psRGXDestroyFreeListOUT,
1039                                          CONNECTION_DATA *psConnection)
1040 {
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050         /* Lock over handle destruction. */
1051         LockHandle();
1052
1053
1054
1055
1056
1057         psRGXDestroyFreeListOUT->eError =
1058                 PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
1059                                         (IMG_HANDLE) psRGXDestroyFreeListIN->hCleanupCookie,
1060                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST);
1061         if ((psRGXDestroyFreeListOUT->eError != PVRSRV_OK) &&
1062             (psRGXDestroyFreeListOUT->eError != PVRSRV_ERROR_RETRY))
1063         {
1064                 PVR_DPF((PVR_DBG_ERROR,
1065                         "PVRSRVBridgeRGXDestroyFreeList: %s",
1066                         PVRSRVGetErrorStringKM(psRGXDestroyFreeListOUT->eError)));
1067                 PVR_ASSERT(0);
1068                 UnlockHandle();
1069                 goto RGXDestroyFreeList_exit;
1070         }
1071
1072         /* Release now we have destroyed handles. */
1073         UnlockHandle();
1074
1075
1076
1077 RGXDestroyFreeList_exit:
1078
1079
1080
1081
1082         return 0;
1083 }
1084
1085
1086 static IMG_INT
1087 PVRSRVBridgeRGXAddBlockToFreeList(IMG_UINT32 ui32DispatchTableEntry,
1088                                           PVRSRV_BRIDGE_IN_RGXADDBLOCKTOFREELIST *psRGXAddBlockToFreeListIN,
1089                                           PVRSRV_BRIDGE_OUT_RGXADDBLOCKTOFREELIST *psRGXAddBlockToFreeListOUT,
1090                                          CONNECTION_DATA *psConnection)
1091 {
1092         IMG_HANDLE hsFreeList = psRGXAddBlockToFreeListIN->hsFreeList;
1093         RGX_FREELIST * pssFreeListInt = NULL;
1094
1095
1096
1097
1098
1099
1100
1101         /* Lock over handle lookup. */
1102         LockHandle();
1103
1104
1105
1106
1107
1108                                 {
1109                                         /* Look up the address from the handle */
1110                                         psRGXAddBlockToFreeListOUT->eError =
1111                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
1112                                                                                         (void **) &pssFreeListInt,
1113                                                                                         hsFreeList,
1114                                                                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST,
1115                                                                                         IMG_TRUE);
1116                                         if(psRGXAddBlockToFreeListOUT->eError != PVRSRV_OK)
1117                                         {
1118                                                 UnlockHandle();
1119                                                 goto RGXAddBlockToFreeList_exit;
1120                                         }
1121                                 }
1122         /* Release now we have looked up handles. */
1123         UnlockHandle();
1124
1125         psRGXAddBlockToFreeListOUT->eError =
1126                 RGXAddBlockToFreeListKM(
1127                                         pssFreeListInt,
1128                                         psRGXAddBlockToFreeListIN->ui3232NumPages);
1129
1130
1131
1132
1133 RGXAddBlockToFreeList_exit:
1134
1135         /* Lock over handle lookup cleanup. */
1136         LockHandle();
1137
1138
1139
1140
1141
1142
1143                                 {
1144                                         /* Unreference the previously looked up handle */
1145                                                 if(pssFreeListInt)
1146                                                 {
1147                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
1148                                                                                         hsFreeList,
1149                                                                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST);
1150                                                 }
1151                                 }
1152         /* Release now we have cleaned up look up handles. */
1153         UnlockHandle();
1154
1155
1156         return 0;
1157 }
1158
1159
1160 static IMG_INT
1161 PVRSRVBridgeRGXRemoveBlockFromFreeList(IMG_UINT32 ui32DispatchTableEntry,
1162                                           PVRSRV_BRIDGE_IN_RGXREMOVEBLOCKFROMFREELIST *psRGXRemoveBlockFromFreeListIN,
1163                                           PVRSRV_BRIDGE_OUT_RGXREMOVEBLOCKFROMFREELIST *psRGXRemoveBlockFromFreeListOUT,
1164                                          CONNECTION_DATA *psConnection)
1165 {
1166         IMG_HANDLE hsFreeList = psRGXRemoveBlockFromFreeListIN->hsFreeList;
1167         RGX_FREELIST * pssFreeListInt = NULL;
1168
1169
1170
1171
1172
1173
1174
1175         /* Lock over handle lookup. */
1176         LockHandle();
1177
1178
1179
1180
1181
1182                                 {
1183                                         /* Look up the address from the handle */
1184                                         psRGXRemoveBlockFromFreeListOUT->eError =
1185                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
1186                                                                                         (void **) &pssFreeListInt,
1187                                                                                         hsFreeList,
1188                                                                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST,
1189                                                                                         IMG_TRUE);
1190                                         if(psRGXRemoveBlockFromFreeListOUT->eError != PVRSRV_OK)
1191                                         {
1192                                                 UnlockHandle();
1193                                                 goto RGXRemoveBlockFromFreeList_exit;
1194                                         }
1195                                 }
1196         /* Release now we have looked up handles. */
1197         UnlockHandle();
1198
1199         psRGXRemoveBlockFromFreeListOUT->eError =
1200                 RGXRemoveBlockFromFreeListKM(
1201                                         pssFreeListInt);
1202
1203
1204
1205
1206 RGXRemoveBlockFromFreeList_exit:
1207
1208         /* Lock over handle lookup cleanup. */
1209         LockHandle();
1210
1211
1212
1213
1214
1215
1216                                 {
1217                                         /* Unreference the previously looked up handle */
1218                                                 if(pssFreeListInt)
1219                                                 {
1220                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
1221                                                                                         hsFreeList,
1222                                                                                         PVRSRV_HANDLE_TYPE_RGX_FREELIST);
1223                                                 }
1224                                 }
1225         /* Release now we have cleaned up look up handles. */
1226         UnlockHandle();
1227
1228
1229         return 0;
1230 }
1231
1232
1233 static IMG_INT
1234 PVRSRVBridgeRGXCreateRenderContext(IMG_UINT32 ui32DispatchTableEntry,
1235                                           PVRSRV_BRIDGE_IN_RGXCREATERENDERCONTEXT *psRGXCreateRenderContextIN,
1236                                           PVRSRV_BRIDGE_OUT_RGXCREATERENDERCONTEXT *psRGXCreateRenderContextOUT,
1237                                          CONNECTION_DATA *psConnection)
1238 {
1239         IMG_BYTE *psFrameworkCmdInt = NULL;
1240         IMG_HANDLE hPrivData = psRGXCreateRenderContextIN->hPrivData;
1241         IMG_HANDLE hPrivDataInt = NULL;
1242         RGX_SERVER_RENDER_CONTEXT * psRenderContextInt = NULL;
1243
1244         IMG_UINT32 ui32NextOffset = 0;
1245         IMG_BYTE   *pArrayArgsBuffer = NULL;
1246 #if !defined(INTEGRITY_OS)
1247         IMG_BOOL bHaveEnoughSpace = IMG_FALSE;
1248 #endif
1249
1250         IMG_UINT32 ui32BufferSize =
1251                         (psRGXCreateRenderContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE)) +
1252                         0;
1253
1254
1255
1256
1257
1258         if (ui32BufferSize != 0)
1259         {
1260 #if !defined(INTEGRITY_OS)
1261                 /* Try to use remainder of input buffer for copies if possible, word-aligned for safety. */
1262                 IMG_UINT32 ui32InBufferOffset = PVR_ALIGN(sizeof(*psRGXCreateRenderContextIN), sizeof(unsigned long));
1263                 IMG_UINT32 ui32InBufferExcessSize = ui32InBufferOffset >= PVRSRV_MAX_BRIDGE_IN_SIZE ? 0 :
1264                         PVRSRV_MAX_BRIDGE_IN_SIZE - ui32InBufferOffset;
1265
1266                 bHaveEnoughSpace = ui32BufferSize <= ui32InBufferExcessSize;
1267                 if (bHaveEnoughSpace)
1268                 {
1269                         IMG_BYTE *pInputBuffer = (IMG_BYTE *)psRGXCreateRenderContextIN;
1270
1271                         pArrayArgsBuffer = &pInputBuffer[ui32InBufferOffset];           }
1272                 else
1273 #endif
1274                 {
1275                         pArrayArgsBuffer = OSAllocMemNoStats(ui32BufferSize);
1276
1277                         if(!pArrayArgsBuffer)
1278                         {
1279                                 psRGXCreateRenderContextOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
1280                                 goto RGXCreateRenderContext_exit;
1281                         }
1282                 }
1283         }
1284
1285         if (psRGXCreateRenderContextIN->ui32FrameworkCmdize != 0)
1286         {
1287                 psFrameworkCmdInt = (IMG_BYTE*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1288                 ui32NextOffset += psRGXCreateRenderContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE);
1289         }
1290
1291                         /* Copy the data over */
1292                         if (psRGXCreateRenderContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE) > 0)
1293                         {
1294                                 if ( OSCopyFromUser(NULL, psFrameworkCmdInt, psRGXCreateRenderContextIN->psFrameworkCmd, psRGXCreateRenderContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE)) != PVRSRV_OK )
1295                                 {
1296                                         psRGXCreateRenderContextOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1297
1298                                         goto RGXCreateRenderContext_exit;
1299                                 }
1300                         }
1301
1302         /* Lock over handle lookup. */
1303         LockHandle();
1304
1305
1306
1307
1308
1309                                 {
1310                                         /* Look up the address from the handle */
1311                                         psRGXCreateRenderContextOUT->eError =
1312                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
1313                                                                                         (void **) &hPrivDataInt,
1314                                                                                         hPrivData,
1315                                                                                         PVRSRV_HANDLE_TYPE_DEV_PRIV_DATA,
1316                                                                                         IMG_TRUE);
1317                                         if(psRGXCreateRenderContextOUT->eError != PVRSRV_OK)
1318                                         {
1319                                                 UnlockHandle();
1320                                                 goto RGXCreateRenderContext_exit;
1321                                         }
1322                                 }
1323         /* Release now we have looked up handles. */
1324         UnlockHandle();
1325
1326         psRGXCreateRenderContextOUT->eError =
1327                 PVRSRVRGXCreateRenderContextKM(psConnection, OSGetDevData(psConnection),
1328                                         psRGXCreateRenderContextIN->ui32Priority,
1329                                         psRGXCreateRenderContextIN->sMCUFenceAddr,
1330                                         psRGXCreateRenderContextIN->sVDMCallStackAddr,
1331                                         psRGXCreateRenderContextIN->ui32FrameworkCmdize,
1332                                         psFrameworkCmdInt,
1333                                         hPrivDataInt,
1334                                         &psRenderContextInt);
1335         /* Exit early if bridged call fails */
1336         if(psRGXCreateRenderContextOUT->eError != PVRSRV_OK)
1337         {
1338                 goto RGXCreateRenderContext_exit;
1339         }
1340
1341         /* Lock over handle creation. */
1342         LockHandle();
1343
1344
1345
1346
1347
1348         psRGXCreateRenderContextOUT->eError = PVRSRVAllocHandleUnlocked(psConnection->psHandleBase,
1349
1350                                                         &psRGXCreateRenderContextOUT->hRenderContext,
1351                                                         (void *) psRenderContextInt,
1352                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_RENDER_CONTEXT,
1353                                                         PVRSRV_HANDLE_ALLOC_FLAG_MULTI
1354                                                         ,(PFN_HANDLE_RELEASE)&PVRSRVRGXDestroyRenderContextKM);
1355         if (psRGXCreateRenderContextOUT->eError != PVRSRV_OK)
1356         {
1357                 UnlockHandle();
1358                 goto RGXCreateRenderContext_exit;
1359         }
1360
1361         /* Release now we have created handles. */
1362         UnlockHandle();
1363
1364
1365
1366 RGXCreateRenderContext_exit:
1367
1368         /* Lock over handle lookup cleanup. */
1369         LockHandle();
1370
1371
1372
1373
1374
1375
1376                                 {
1377                                         /* Unreference the previously looked up handle */
1378                                                 if(hPrivDataInt)
1379                                                 {
1380                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
1381                                                                                         hPrivData,
1382                                                                                         PVRSRV_HANDLE_TYPE_DEV_PRIV_DATA);
1383                                                 }
1384                                 }
1385         /* Release now we have cleaned up look up handles. */
1386         UnlockHandle();
1387
1388         if (psRGXCreateRenderContextOUT->eError != PVRSRV_OK)
1389         {
1390                 if (psRenderContextInt)
1391                 {
1392                         PVRSRVRGXDestroyRenderContextKM(psRenderContextInt);
1393                 }
1394         }
1395
1396         /* Allocated space should be equal to the last updated offset */
1397         PVR_ASSERT(ui32BufferSize == ui32NextOffset);
1398
1399 #if defined(INTEGRITY_OS)
1400         if(pArrayArgsBuffer)
1401 #else
1402         if(!bHaveEnoughSpace && pArrayArgsBuffer)
1403 #endif
1404                 OSFreeMemNoStats(pArrayArgsBuffer);
1405
1406
1407         return 0;
1408 }
1409
1410
1411 static IMG_INT
1412 PVRSRVBridgeRGXDestroyRenderContext(IMG_UINT32 ui32DispatchTableEntry,
1413                                           PVRSRV_BRIDGE_IN_RGXDESTROYRENDERCONTEXT *psRGXDestroyRenderContextIN,
1414                                           PVRSRV_BRIDGE_OUT_RGXDESTROYRENDERCONTEXT *psRGXDestroyRenderContextOUT,
1415                                          CONNECTION_DATA *psConnection)
1416 {
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426         /* Lock over handle destruction. */
1427         LockHandle();
1428
1429
1430
1431
1432
1433         psRGXDestroyRenderContextOUT->eError =
1434                 PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
1435                                         (IMG_HANDLE) psRGXDestroyRenderContextIN->hCleanupCookie,
1436                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_RENDER_CONTEXT);
1437         if ((psRGXDestroyRenderContextOUT->eError != PVRSRV_OK) &&
1438             (psRGXDestroyRenderContextOUT->eError != PVRSRV_ERROR_RETRY))
1439         {
1440                 PVR_DPF((PVR_DBG_ERROR,
1441                         "PVRSRVBridgeRGXDestroyRenderContext: %s",
1442                         PVRSRVGetErrorStringKM(psRGXDestroyRenderContextOUT->eError)));
1443                 PVR_ASSERT(0);
1444                 UnlockHandle();
1445                 goto RGXDestroyRenderContext_exit;
1446         }
1447
1448         /* Release now we have destroyed handles. */
1449         UnlockHandle();
1450
1451
1452
1453 RGXDestroyRenderContext_exit:
1454
1455
1456
1457
1458         return 0;
1459 }
1460
1461
1462 static IMG_INT
1463 PVRSRVBridgeRGXKickTA3D(IMG_UINT32 ui32DispatchTableEntry,
1464                                           PVRSRV_BRIDGE_IN_RGXKICKTA3D *psRGXKickTA3DIN,
1465                                           PVRSRV_BRIDGE_OUT_RGXKICKTA3D *psRGXKickTA3DOUT,
1466                                          CONNECTION_DATA *psConnection)
1467 {
1468         IMG_HANDLE hRenderContext = psRGXKickTA3DIN->hRenderContext;
1469         RGX_SERVER_RENDER_CONTEXT * psRenderContextInt = NULL;
1470         SYNC_PRIMITIVE_BLOCK * *psClientTAFenceSyncPrimBlockInt = NULL;
1471         IMG_HANDLE *hClientTAFenceSyncPrimBlockInt2 = NULL;
1472         IMG_UINT32 *ui32ClientTAFenceSyncOffsetInt = NULL;
1473         IMG_UINT32 *ui32ClientTAFenceValueInt = NULL;
1474         SYNC_PRIMITIVE_BLOCK * *psClientTAUpdateSyncPrimBlockInt = NULL;
1475         IMG_HANDLE *hClientTAUpdateSyncPrimBlockInt2 = NULL;
1476         IMG_UINT32 *ui32ClientTAUpdateSyncOffsetInt = NULL;
1477         IMG_UINT32 *ui32ClientTAUpdateValueInt = NULL;
1478         IMG_UINT32 *ui32ServerTASyncFlagsInt = NULL;
1479         SERVER_SYNC_PRIMITIVE * *psServerTASyncsInt = NULL;
1480         IMG_HANDLE *hServerTASyncsInt2 = NULL;
1481         SYNC_PRIMITIVE_BLOCK * *psClient3DFenceSyncPrimBlockInt = NULL;
1482         IMG_HANDLE *hClient3DFenceSyncPrimBlockInt2 = NULL;
1483         IMG_UINT32 *ui32Client3DFenceSyncOffsetInt = NULL;
1484         IMG_UINT32 *ui32Client3DFenceValueInt = NULL;
1485         SYNC_PRIMITIVE_BLOCK * *psClient3DUpdateSyncPrimBlockInt = NULL;
1486         IMG_HANDLE *hClient3DUpdateSyncPrimBlockInt2 = NULL;
1487         IMG_UINT32 *ui32Client3DUpdateSyncOffsetInt = NULL;
1488         IMG_UINT32 *ui32Client3DUpdateValueInt = NULL;
1489         IMG_UINT32 *ui32Server3DSyncFlagsInt = NULL;
1490         SERVER_SYNC_PRIMITIVE * *psServer3DSyncsInt = NULL;
1491         IMG_HANDLE *hServer3DSyncsInt2 = NULL;
1492         IMG_HANDLE hPRFenceUFOSyncPrimBlock = psRGXKickTA3DIN->hPRFenceUFOSyncPrimBlock;
1493         SYNC_PRIMITIVE_BLOCK * psPRFenceUFOSyncPrimBlockInt = NULL;
1494         IMG_CHAR *uiUpdateFenceNameInt = NULL;
1495         IMG_BYTE *psTACmdInt = NULL;
1496         IMG_BYTE *ps3DPRCmdInt = NULL;
1497         IMG_BYTE *ps3DCmdInt = NULL;
1498         IMG_HANDLE hRTDataCleanup = psRGXKickTA3DIN->hRTDataCleanup;
1499         RGX_RTDATA_CLEANUP_DATA * psRTDataCleanupInt = NULL;
1500         IMG_HANDLE hZBuffer = psRGXKickTA3DIN->hZBuffer;
1501         RGX_ZSBUFFER_DATA * psZBufferInt = NULL;
1502         IMG_HANDLE hSBuffer = psRGXKickTA3DIN->hSBuffer;
1503         RGX_ZSBUFFER_DATA * psSBufferInt = NULL;
1504         IMG_UINT32 *ui32SyncPMRFlagsInt = NULL;
1505         PMR * *psSyncPMRsInt = NULL;
1506         IMG_HANDLE *hSyncPMRsInt2 = NULL;
1507
1508         IMG_UINT32 ui32NextOffset = 0;
1509         IMG_BYTE   *pArrayArgsBuffer = NULL;
1510 #if !defined(INTEGRITY_OS)
1511         IMG_BOOL bHaveEnoughSpace = IMG_FALSE;
1512 #endif
1513
1514         IMG_UINT32 ui32BufferSize =
1515                         (psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *)) +
1516                         (psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE)) +
1517                         (psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32)) +
1518                         (psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32)) +
1519                         (psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *)) +
1520                         (psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE)) +
1521                         (psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32)) +
1522                         (psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32)) +
1523                         (psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(IMG_UINT32)) +
1524                         (psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(SERVER_SYNC_PRIMITIVE *)) +
1525                         (psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(IMG_HANDLE)) +
1526                         (psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *)) +
1527                         (psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE)) +
1528                         (psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32)) +
1529                         (psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32)) +
1530                         (psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *)) +
1531                         (psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE)) +
1532                         (psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32)) +
1533                         (psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32)) +
1534                         (psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(IMG_UINT32)) +
1535                         (psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(SERVER_SYNC_PRIMITIVE *)) +
1536                         (psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(IMG_HANDLE)) +
1537                         (32 * sizeof(IMG_CHAR)) +
1538                         (psRGXKickTA3DIN->ui32TACmdSize * sizeof(IMG_BYTE)) +
1539                         (psRGXKickTA3DIN->ui323DPRCmdSize * sizeof(IMG_BYTE)) +
1540                         (psRGXKickTA3DIN->ui323DCmdSize * sizeof(IMG_BYTE)) +
1541                         (psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(IMG_UINT32)) +
1542                         (psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(PMR *)) +
1543                         (psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(IMG_HANDLE)) +
1544                         0;
1545
1546
1547
1548
1549
1550         if (ui32BufferSize != 0)
1551         {
1552 #if !defined(INTEGRITY_OS)
1553                 /* Try to use remainder of input buffer for copies if possible, word-aligned for safety. */
1554                 IMG_UINT32 ui32InBufferOffset = PVR_ALIGN(sizeof(*psRGXKickTA3DIN), sizeof(unsigned long));
1555                 IMG_UINT32 ui32InBufferExcessSize = ui32InBufferOffset >= PVRSRV_MAX_BRIDGE_IN_SIZE ? 0 :
1556                         PVRSRV_MAX_BRIDGE_IN_SIZE - ui32InBufferOffset;
1557
1558                 bHaveEnoughSpace = ui32BufferSize <= ui32InBufferExcessSize;
1559                 if (bHaveEnoughSpace)
1560                 {
1561                         IMG_BYTE *pInputBuffer = (IMG_BYTE *)psRGXKickTA3DIN;
1562
1563                         pArrayArgsBuffer = &pInputBuffer[ui32InBufferOffset];           }
1564                 else
1565 #endif
1566                 {
1567                         pArrayArgsBuffer = OSAllocMemNoStats(ui32BufferSize);
1568
1569                         if(!pArrayArgsBuffer)
1570                         {
1571                                 psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
1572                                 goto RGXKickTA3D_exit;
1573                         }
1574                 }
1575         }
1576
1577         if (psRGXKickTA3DIN->ui32ClientTAFenceCount != 0)
1578         {
1579                 psClientTAFenceSyncPrimBlockInt = (SYNC_PRIMITIVE_BLOCK **)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1580                 ui32NextOffset += psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *);
1581                 hClientTAFenceSyncPrimBlockInt2 = (IMG_HANDLE *)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1582                 ui32NextOffset += psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE);
1583         }
1584
1585                         /* Copy the data over */
1586                         if (psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE) > 0)
1587                         {
1588                                 if ( OSCopyFromUser(NULL, hClientTAFenceSyncPrimBlockInt2, psRGXKickTA3DIN->phClientTAFenceSyncPrimBlock, psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK )
1589                                 {
1590                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1591
1592                                         goto RGXKickTA3D_exit;
1593                                 }
1594                         }
1595         if (psRGXKickTA3DIN->ui32ClientTAFenceCount != 0)
1596         {
1597                 ui32ClientTAFenceSyncOffsetInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1598                 ui32NextOffset += psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32);
1599         }
1600
1601                         /* Copy the data over */
1602                         if (psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32) > 0)
1603                         {
1604                                 if ( OSCopyFromUser(NULL, ui32ClientTAFenceSyncOffsetInt, psRGXKickTA3DIN->pui32ClientTAFenceSyncOffset, psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK )
1605                                 {
1606                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1607
1608                                         goto RGXKickTA3D_exit;
1609                                 }
1610                         }
1611         if (psRGXKickTA3DIN->ui32ClientTAFenceCount != 0)
1612         {
1613                 ui32ClientTAFenceValueInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1614                 ui32NextOffset += psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32);
1615         }
1616
1617                         /* Copy the data over */
1618                         if (psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32) > 0)
1619                         {
1620                                 if ( OSCopyFromUser(NULL, ui32ClientTAFenceValueInt, psRGXKickTA3DIN->pui32ClientTAFenceValue, psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK )
1621                                 {
1622                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1623
1624                                         goto RGXKickTA3D_exit;
1625                                 }
1626                         }
1627         if (psRGXKickTA3DIN->ui32ClientTAUpdateCount != 0)
1628         {
1629                 psClientTAUpdateSyncPrimBlockInt = (SYNC_PRIMITIVE_BLOCK **)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1630                 ui32NextOffset += psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *);
1631                 hClientTAUpdateSyncPrimBlockInt2 = (IMG_HANDLE *)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1632                 ui32NextOffset += psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE);
1633         }
1634
1635                         /* Copy the data over */
1636                         if (psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE) > 0)
1637                         {
1638                                 if ( OSCopyFromUser(NULL, hClientTAUpdateSyncPrimBlockInt2, psRGXKickTA3DIN->phClientTAUpdateSyncPrimBlock, psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK )
1639                                 {
1640                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1641
1642                                         goto RGXKickTA3D_exit;
1643                                 }
1644                         }
1645         if (psRGXKickTA3DIN->ui32ClientTAUpdateCount != 0)
1646         {
1647                 ui32ClientTAUpdateSyncOffsetInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1648                 ui32NextOffset += psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32);
1649         }
1650
1651                         /* Copy the data over */
1652                         if (psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32) > 0)
1653                         {
1654                                 if ( OSCopyFromUser(NULL, ui32ClientTAUpdateSyncOffsetInt, psRGXKickTA3DIN->pui32ClientTAUpdateSyncOffset, psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK )
1655                                 {
1656                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1657
1658                                         goto RGXKickTA3D_exit;
1659                                 }
1660                         }
1661         if (psRGXKickTA3DIN->ui32ClientTAUpdateCount != 0)
1662         {
1663                 ui32ClientTAUpdateValueInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1664                 ui32NextOffset += psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32);
1665         }
1666
1667                         /* Copy the data over */
1668                         if (psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32) > 0)
1669                         {
1670                                 if ( OSCopyFromUser(NULL, ui32ClientTAUpdateValueInt, psRGXKickTA3DIN->pui32ClientTAUpdateValue, psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK )
1671                                 {
1672                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1673
1674                                         goto RGXKickTA3D_exit;
1675                                 }
1676                         }
1677         if (psRGXKickTA3DIN->ui32ServerTASyncPrims != 0)
1678         {
1679                 ui32ServerTASyncFlagsInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1680                 ui32NextOffset += psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(IMG_UINT32);
1681         }
1682
1683                         /* Copy the data over */
1684                         if (psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(IMG_UINT32) > 0)
1685                         {
1686                                 if ( OSCopyFromUser(NULL, ui32ServerTASyncFlagsInt, psRGXKickTA3DIN->pui32ServerTASyncFlags, psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(IMG_UINT32)) != PVRSRV_OK )
1687                                 {
1688                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1689
1690                                         goto RGXKickTA3D_exit;
1691                                 }
1692                         }
1693         if (psRGXKickTA3DIN->ui32ServerTASyncPrims != 0)
1694         {
1695                 psServerTASyncsInt = (SERVER_SYNC_PRIMITIVE **)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1696                 ui32NextOffset += psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(SERVER_SYNC_PRIMITIVE *);
1697                 hServerTASyncsInt2 = (IMG_HANDLE *)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1698                 ui32NextOffset += psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(IMG_HANDLE);
1699         }
1700
1701                         /* Copy the data over */
1702                         if (psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(IMG_HANDLE) > 0)
1703                         {
1704                                 if ( OSCopyFromUser(NULL, hServerTASyncsInt2, psRGXKickTA3DIN->phServerTASyncs, psRGXKickTA3DIN->ui32ServerTASyncPrims * sizeof(IMG_HANDLE)) != PVRSRV_OK )
1705                                 {
1706                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1707
1708                                         goto RGXKickTA3D_exit;
1709                                 }
1710                         }
1711         if (psRGXKickTA3DIN->ui32Client3DFenceCount != 0)
1712         {
1713                 psClient3DFenceSyncPrimBlockInt = (SYNC_PRIMITIVE_BLOCK **)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1714                 ui32NextOffset += psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *);
1715                 hClient3DFenceSyncPrimBlockInt2 = (IMG_HANDLE *)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1716                 ui32NextOffset += psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE);
1717         }
1718
1719                         /* Copy the data over */
1720                         if (psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE) > 0)
1721                         {
1722                                 if ( OSCopyFromUser(NULL, hClient3DFenceSyncPrimBlockInt2, psRGXKickTA3DIN->phClient3DFenceSyncPrimBlock, psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK )
1723                                 {
1724                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1725
1726                                         goto RGXKickTA3D_exit;
1727                                 }
1728                         }
1729         if (psRGXKickTA3DIN->ui32Client3DFenceCount != 0)
1730         {
1731                 ui32Client3DFenceSyncOffsetInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1732                 ui32NextOffset += psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32);
1733         }
1734
1735                         /* Copy the data over */
1736                         if (psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32) > 0)
1737                         {
1738                                 if ( OSCopyFromUser(NULL, ui32Client3DFenceSyncOffsetInt, psRGXKickTA3DIN->pui32Client3DFenceSyncOffset, psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK )
1739                                 {
1740                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1741
1742                                         goto RGXKickTA3D_exit;
1743                                 }
1744                         }
1745         if (psRGXKickTA3DIN->ui32Client3DFenceCount != 0)
1746         {
1747                 ui32Client3DFenceValueInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1748                 ui32NextOffset += psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32);
1749         }
1750
1751                         /* Copy the data over */
1752                         if (psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32) > 0)
1753                         {
1754                                 if ( OSCopyFromUser(NULL, ui32Client3DFenceValueInt, psRGXKickTA3DIN->pui32Client3DFenceValue, psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK )
1755                                 {
1756                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1757
1758                                         goto RGXKickTA3D_exit;
1759                                 }
1760                         }
1761         if (psRGXKickTA3DIN->ui32Client3DUpdateCount != 0)
1762         {
1763                 psClient3DUpdateSyncPrimBlockInt = (SYNC_PRIMITIVE_BLOCK **)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1764                 ui32NextOffset += psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *);
1765                 hClient3DUpdateSyncPrimBlockInt2 = (IMG_HANDLE *)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1766                 ui32NextOffset += psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE);
1767         }
1768
1769                         /* Copy the data over */
1770                         if (psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE) > 0)
1771                         {
1772                                 if ( OSCopyFromUser(NULL, hClient3DUpdateSyncPrimBlockInt2, psRGXKickTA3DIN->phClient3DUpdateSyncPrimBlock, psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK )
1773                                 {
1774                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1775
1776                                         goto RGXKickTA3D_exit;
1777                                 }
1778                         }
1779         if (psRGXKickTA3DIN->ui32Client3DUpdateCount != 0)
1780         {
1781                 ui32Client3DUpdateSyncOffsetInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1782                 ui32NextOffset += psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32);
1783         }
1784
1785                         /* Copy the data over */
1786                         if (psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32) > 0)
1787                         {
1788                                 if ( OSCopyFromUser(NULL, ui32Client3DUpdateSyncOffsetInt, psRGXKickTA3DIN->pui32Client3DUpdateSyncOffset, psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK )
1789                                 {
1790                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1791
1792                                         goto RGXKickTA3D_exit;
1793                                 }
1794                         }
1795         if (psRGXKickTA3DIN->ui32Client3DUpdateCount != 0)
1796         {
1797                 ui32Client3DUpdateValueInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1798                 ui32NextOffset += psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32);
1799         }
1800
1801                         /* Copy the data over */
1802                         if (psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32) > 0)
1803                         {
1804                                 if ( OSCopyFromUser(NULL, ui32Client3DUpdateValueInt, psRGXKickTA3DIN->pui32Client3DUpdateValue, psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK )
1805                                 {
1806                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1807
1808                                         goto RGXKickTA3D_exit;
1809                                 }
1810                         }
1811         if (psRGXKickTA3DIN->ui32Server3DSyncPrims != 0)
1812         {
1813                 ui32Server3DSyncFlagsInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1814                 ui32NextOffset += psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(IMG_UINT32);
1815         }
1816
1817                         /* Copy the data over */
1818                         if (psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(IMG_UINT32) > 0)
1819                         {
1820                                 if ( OSCopyFromUser(NULL, ui32Server3DSyncFlagsInt, psRGXKickTA3DIN->pui32Server3DSyncFlags, psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(IMG_UINT32)) != PVRSRV_OK )
1821                                 {
1822                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1823
1824                                         goto RGXKickTA3D_exit;
1825                                 }
1826                         }
1827         if (psRGXKickTA3DIN->ui32Server3DSyncPrims != 0)
1828         {
1829                 psServer3DSyncsInt = (SERVER_SYNC_PRIMITIVE **)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1830                 ui32NextOffset += psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(SERVER_SYNC_PRIMITIVE *);
1831                 hServer3DSyncsInt2 = (IMG_HANDLE *)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1832                 ui32NextOffset += psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(IMG_HANDLE);
1833         }
1834
1835                         /* Copy the data over */
1836                         if (psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(IMG_HANDLE) > 0)
1837                         {
1838                                 if ( OSCopyFromUser(NULL, hServer3DSyncsInt2, psRGXKickTA3DIN->phServer3DSyncs, psRGXKickTA3DIN->ui32Server3DSyncPrims * sizeof(IMG_HANDLE)) != PVRSRV_OK )
1839                                 {
1840                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1841
1842                                         goto RGXKickTA3D_exit;
1843                                 }
1844                         }
1845
1846         {
1847                 uiUpdateFenceNameInt = (IMG_CHAR*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1848                 ui32NextOffset += 32 * sizeof(IMG_CHAR);
1849         }
1850
1851                         /* Copy the data over */
1852                         if (32 * sizeof(IMG_CHAR) > 0)
1853                         {
1854                                 if ( OSCopyFromUser(NULL, uiUpdateFenceNameInt, psRGXKickTA3DIN->puiUpdateFenceName, 32 * sizeof(IMG_CHAR)) != PVRSRV_OK )
1855                                 {
1856                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1857
1858                                         goto RGXKickTA3D_exit;
1859                                 }
1860                         }
1861         if (psRGXKickTA3DIN->ui32TACmdSize != 0)
1862         {
1863                 psTACmdInt = (IMG_BYTE*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1864                 ui32NextOffset += psRGXKickTA3DIN->ui32TACmdSize * sizeof(IMG_BYTE);
1865         }
1866
1867                         /* Copy the data over */
1868                         if (psRGXKickTA3DIN->ui32TACmdSize * sizeof(IMG_BYTE) > 0)
1869                         {
1870                                 if ( OSCopyFromUser(NULL, psTACmdInt, psRGXKickTA3DIN->psTACmd, psRGXKickTA3DIN->ui32TACmdSize * sizeof(IMG_BYTE)) != PVRSRV_OK )
1871                                 {
1872                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1873
1874                                         goto RGXKickTA3D_exit;
1875                                 }
1876                         }
1877         if (psRGXKickTA3DIN->ui323DPRCmdSize != 0)
1878         {
1879                 ps3DPRCmdInt = (IMG_BYTE*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1880                 ui32NextOffset += psRGXKickTA3DIN->ui323DPRCmdSize * sizeof(IMG_BYTE);
1881         }
1882
1883                         /* Copy the data over */
1884                         if (psRGXKickTA3DIN->ui323DPRCmdSize * sizeof(IMG_BYTE) > 0)
1885                         {
1886                                 if ( OSCopyFromUser(NULL, ps3DPRCmdInt, psRGXKickTA3DIN->ps3DPRCmd, psRGXKickTA3DIN->ui323DPRCmdSize * sizeof(IMG_BYTE)) != PVRSRV_OK )
1887                                 {
1888                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1889
1890                                         goto RGXKickTA3D_exit;
1891                                 }
1892                         }
1893         if (psRGXKickTA3DIN->ui323DCmdSize != 0)
1894         {
1895                 ps3DCmdInt = (IMG_BYTE*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1896                 ui32NextOffset += psRGXKickTA3DIN->ui323DCmdSize * sizeof(IMG_BYTE);
1897         }
1898
1899                         /* Copy the data over */
1900                         if (psRGXKickTA3DIN->ui323DCmdSize * sizeof(IMG_BYTE) > 0)
1901                         {
1902                                 if ( OSCopyFromUser(NULL, ps3DCmdInt, psRGXKickTA3DIN->ps3DCmd, psRGXKickTA3DIN->ui323DCmdSize * sizeof(IMG_BYTE)) != PVRSRV_OK )
1903                                 {
1904                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1905
1906                                         goto RGXKickTA3D_exit;
1907                                 }
1908                         }
1909         if (psRGXKickTA3DIN->ui32SyncPMRCount != 0)
1910         {
1911                 ui32SyncPMRFlagsInt = (IMG_UINT32*)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1912                 ui32NextOffset += psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(IMG_UINT32);
1913         }
1914
1915                         /* Copy the data over */
1916                         if (psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(IMG_UINT32) > 0)
1917                         {
1918                                 if ( OSCopyFromUser(NULL, ui32SyncPMRFlagsInt, psRGXKickTA3DIN->pui32SyncPMRFlags, psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(IMG_UINT32)) != PVRSRV_OK )
1919                                 {
1920                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1921
1922                                         goto RGXKickTA3D_exit;
1923                                 }
1924                         }
1925         if (psRGXKickTA3DIN->ui32SyncPMRCount != 0)
1926         {
1927                 psSyncPMRsInt = (PMR **)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1928                 ui32NextOffset += psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(PMR *);
1929                 hSyncPMRsInt2 = (IMG_HANDLE *)(((IMG_UINT8 *)pArrayArgsBuffer) + ui32NextOffset);
1930                 ui32NextOffset += psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(IMG_HANDLE);
1931         }
1932
1933                         /* Copy the data over */
1934                         if (psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(IMG_HANDLE) > 0)
1935                         {
1936                                 if ( OSCopyFromUser(NULL, hSyncPMRsInt2, psRGXKickTA3DIN->phSyncPMRs, psRGXKickTA3DIN->ui32SyncPMRCount * sizeof(IMG_HANDLE)) != PVRSRV_OK )
1937                                 {
1938                                         psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1939
1940                                         goto RGXKickTA3D_exit;
1941                                 }
1942                         }
1943
1944         /* Lock over handle lookup. */
1945         LockHandle();
1946
1947
1948
1949
1950
1951                                 {
1952                                         /* Look up the address from the handle */
1953                                         psRGXKickTA3DOUT->eError =
1954                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
1955                                                                                         (void **) &psRenderContextInt,
1956                                                                                         hRenderContext,
1957                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_RENDER_CONTEXT,
1958                                                                                         IMG_TRUE);
1959                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
1960                                         {
1961                                                 UnlockHandle();
1962                                                 goto RGXKickTA3D_exit;
1963                                         }
1964                                 }
1965
1966
1967
1968
1969
1970         {
1971                 IMG_UINT32 i;
1972
1973                 for (i=0;i<psRGXKickTA3DIN->ui32ClientTAFenceCount;i++)
1974                 {
1975                                 {
1976                                         /* Look up the address from the handle */
1977                                         psRGXKickTA3DOUT->eError =
1978                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
1979                                                                                         (void **) &psClientTAFenceSyncPrimBlockInt[i],
1980                                                                                         hClientTAFenceSyncPrimBlockInt2[i],
1981                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK,
1982                                                                                         IMG_TRUE);
1983                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
1984                                         {
1985                                                 UnlockHandle();
1986                                                 goto RGXKickTA3D_exit;
1987                                         }
1988                                 }
1989                 }
1990         }
1991
1992
1993
1994
1995
1996         {
1997                 IMG_UINT32 i;
1998
1999                 for (i=0;i<psRGXKickTA3DIN->ui32ClientTAUpdateCount;i++)
2000                 {
2001                                 {
2002                                         /* Look up the address from the handle */
2003                                         psRGXKickTA3DOUT->eError =
2004                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2005                                                                                         (void **) &psClientTAUpdateSyncPrimBlockInt[i],
2006                                                                                         hClientTAUpdateSyncPrimBlockInt2[i],
2007                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK,
2008                                                                                         IMG_TRUE);
2009                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2010                                         {
2011                                                 UnlockHandle();
2012                                                 goto RGXKickTA3D_exit;
2013                                         }
2014                                 }
2015                 }
2016         }
2017
2018
2019
2020
2021
2022         {
2023                 IMG_UINT32 i;
2024
2025                 for (i=0;i<psRGXKickTA3DIN->ui32ServerTASyncPrims;i++)
2026                 {
2027                                 {
2028                                         /* Look up the address from the handle */
2029                                         psRGXKickTA3DOUT->eError =
2030                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2031                                                                                         (void **) &psServerTASyncsInt[i],
2032                                                                                         hServerTASyncsInt2[i],
2033                                                                                         PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE,
2034                                                                                         IMG_TRUE);
2035                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2036                                         {
2037                                                 UnlockHandle();
2038                                                 goto RGXKickTA3D_exit;
2039                                         }
2040                                 }
2041                 }
2042         }
2043
2044
2045
2046
2047
2048         {
2049                 IMG_UINT32 i;
2050
2051                 for (i=0;i<psRGXKickTA3DIN->ui32Client3DFenceCount;i++)
2052                 {
2053                                 {
2054                                         /* Look up the address from the handle */
2055                                         psRGXKickTA3DOUT->eError =
2056                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2057                                                                                         (void **) &psClient3DFenceSyncPrimBlockInt[i],
2058                                                                                         hClient3DFenceSyncPrimBlockInt2[i],
2059                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK,
2060                                                                                         IMG_TRUE);
2061                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2062                                         {
2063                                                 UnlockHandle();
2064                                                 goto RGXKickTA3D_exit;
2065                                         }
2066                                 }
2067                 }
2068         }
2069
2070
2071
2072
2073
2074         {
2075                 IMG_UINT32 i;
2076
2077                 for (i=0;i<psRGXKickTA3DIN->ui32Client3DUpdateCount;i++)
2078                 {
2079                                 {
2080                                         /* Look up the address from the handle */
2081                                         psRGXKickTA3DOUT->eError =
2082                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2083                                                                                         (void **) &psClient3DUpdateSyncPrimBlockInt[i],
2084                                                                                         hClient3DUpdateSyncPrimBlockInt2[i],
2085                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK,
2086                                                                                         IMG_TRUE);
2087                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2088                                         {
2089                                                 UnlockHandle();
2090                                                 goto RGXKickTA3D_exit;
2091                                         }
2092                                 }
2093                 }
2094         }
2095
2096
2097
2098
2099
2100         {
2101                 IMG_UINT32 i;
2102
2103                 for (i=0;i<psRGXKickTA3DIN->ui32Server3DSyncPrims;i++)
2104                 {
2105                                 {
2106                                         /* Look up the address from the handle */
2107                                         psRGXKickTA3DOUT->eError =
2108                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2109                                                                                         (void **) &psServer3DSyncsInt[i],
2110                                                                                         hServer3DSyncsInt2[i],
2111                                                                                         PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE,
2112                                                                                         IMG_TRUE);
2113                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2114                                         {
2115                                                 UnlockHandle();
2116                                                 goto RGXKickTA3D_exit;
2117                                         }
2118                                 }
2119                 }
2120         }
2121
2122
2123
2124
2125
2126                                 {
2127                                         /* Look up the address from the handle */
2128                                         psRGXKickTA3DOUT->eError =
2129                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2130                                                                                         (void **) &psPRFenceUFOSyncPrimBlockInt,
2131                                                                                         hPRFenceUFOSyncPrimBlock,
2132                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK,
2133                                                                                         IMG_TRUE);
2134                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2135                                         {
2136                                                 UnlockHandle();
2137                                                 goto RGXKickTA3D_exit;
2138                                         }
2139                                 }
2140
2141
2142
2143
2144
2145                                 if (psRGXKickTA3DIN->hRTDataCleanup)
2146                                 {
2147                                         /* Look up the address from the handle */
2148                                         psRGXKickTA3DOUT->eError =
2149                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2150                                                                                         (void **) &psRTDataCleanupInt,
2151                                                                                         hRTDataCleanup,
2152                                                                                         PVRSRV_HANDLE_TYPE_RGX_RTDATA_CLEANUP,
2153                                                                                         IMG_TRUE);
2154                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2155                                         {
2156                                                 UnlockHandle();
2157                                                 goto RGXKickTA3D_exit;
2158                                         }
2159                                 }
2160
2161
2162
2163
2164
2165                                 if (psRGXKickTA3DIN->hZBuffer)
2166                                 {
2167                                         /* Look up the address from the handle */
2168                                         psRGXKickTA3DOUT->eError =
2169                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2170                                                                                         (void **) &psZBufferInt,
2171                                                                                         hZBuffer,
2172                                                                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_ZSBUFFER,
2173                                                                                         IMG_TRUE);
2174                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2175                                         {
2176                                                 UnlockHandle();
2177                                                 goto RGXKickTA3D_exit;
2178                                         }
2179                                 }
2180
2181
2182
2183
2184
2185                                 if (psRGXKickTA3DIN->hSBuffer)
2186                                 {
2187                                         /* Look up the address from the handle */
2188                                         psRGXKickTA3DOUT->eError =
2189                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2190                                                                                         (void **) &psSBufferInt,
2191                                                                                         hSBuffer,
2192                                                                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_ZSBUFFER,
2193                                                                                         IMG_TRUE);
2194                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2195                                         {
2196                                                 UnlockHandle();
2197                                                 goto RGXKickTA3D_exit;
2198                                         }
2199                                 }
2200
2201
2202
2203
2204
2205         {
2206                 IMG_UINT32 i;
2207
2208                 for (i=0;i<psRGXKickTA3DIN->ui32SyncPMRCount;i++)
2209                 {
2210                                 {
2211                                         /* Look up the address from the handle */
2212                                         psRGXKickTA3DOUT->eError =
2213                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2214                                                                                         (void **) &psSyncPMRsInt[i],
2215                                                                                         hSyncPMRsInt2[i],
2216                                                                                         PVRSRV_HANDLE_TYPE_PHYSMEM_PMR,
2217                                                                                         IMG_TRUE);
2218                                         if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
2219                                         {
2220                                                 UnlockHandle();
2221                                                 goto RGXKickTA3D_exit;
2222                                         }
2223                                 }
2224                 }
2225         }
2226         /* Release now we have looked up handles. */
2227         UnlockHandle();
2228
2229         psRGXKickTA3DOUT->eError =
2230                 PVRSRVRGXKickTA3DKM(
2231                                         psRenderContextInt,
2232                                         psRGXKickTA3DIN->ui32ClientCacheOpSeqNum,
2233                                         psRGXKickTA3DIN->ui32ClientTAFenceCount,
2234                                         psClientTAFenceSyncPrimBlockInt,
2235                                         ui32ClientTAFenceSyncOffsetInt,
2236                                         ui32ClientTAFenceValueInt,
2237                                         psRGXKickTA3DIN->ui32ClientTAUpdateCount,
2238                                         psClientTAUpdateSyncPrimBlockInt,
2239                                         ui32ClientTAUpdateSyncOffsetInt,
2240                                         ui32ClientTAUpdateValueInt,
2241                                         psRGXKickTA3DIN->ui32ServerTASyncPrims,
2242                                         ui32ServerTASyncFlagsInt,
2243                                         psServerTASyncsInt,
2244                                         psRGXKickTA3DIN->ui32Client3DFenceCount,
2245                                         psClient3DFenceSyncPrimBlockInt,
2246                                         ui32Client3DFenceSyncOffsetInt,
2247                                         ui32Client3DFenceValueInt,
2248                                         psRGXKickTA3DIN->ui32Client3DUpdateCount,
2249                                         psClient3DUpdateSyncPrimBlockInt,
2250                                         ui32Client3DUpdateSyncOffsetInt,
2251                                         ui32Client3DUpdateValueInt,
2252                                         psRGXKickTA3DIN->ui32Server3DSyncPrims,
2253                                         ui32Server3DSyncFlagsInt,
2254                                         psServer3DSyncsInt,
2255                                         psPRFenceUFOSyncPrimBlockInt,
2256                                         psRGXKickTA3DIN->ui32FRFenceUFOSyncOffset,
2257                                         psRGXKickTA3DIN->ui32FRFenceValue,
2258                                         psRGXKickTA3DIN->i32CheckFenceFD,
2259                                         psRGXKickTA3DIN->i32UpdateTimelineFD,
2260                                         &psRGXKickTA3DOUT->i32UpdateFenceFD,
2261                                         uiUpdateFenceNameInt,
2262                                         psRGXKickTA3DIN->ui32TACmdSize,
2263                                         psTACmdInt,
2264                                         psRGXKickTA3DIN->ui323DPRCmdSize,
2265                                         ps3DPRCmdInt,
2266                                         psRGXKickTA3DIN->ui323DCmdSize,
2267                                         ps3DCmdInt,
2268                                         psRGXKickTA3DIN->ui32ExtJobRef,
2269                                         psRGXKickTA3DIN->bbLastTAInScene,
2270                                         psRGXKickTA3DIN->bbKickTA,
2271                                         psRGXKickTA3DIN->bbKickPR,
2272                                         psRGXKickTA3DIN->bbKick3D,
2273                                         psRGXKickTA3DIN->bbAbort,
2274                                         psRGXKickTA3DIN->ui32PDumpFlags,
2275                                         psRTDataCleanupInt,
2276                                         psZBufferInt,
2277                                         psSBufferInt,
2278                                         psRGXKickTA3DIN->bbCommitRefCountsTA,
2279                                         psRGXKickTA3DIN->bbCommitRefCounts3D,
2280                                         &psRGXKickTA3DOUT->bbCommittedRefCountsTA,
2281                                         &psRGXKickTA3DOUT->bbCommittedRefCounts3D,
2282                                         psRGXKickTA3DIN->ui32SyncPMRCount,
2283                                         ui32SyncPMRFlagsInt,
2284                                         psSyncPMRsInt,
2285                                         psRGXKickTA3DIN->ui32RenderTargetSize,
2286                                         psRGXKickTA3DIN->ui32NumberOfDrawCalls,
2287                                         psRGXKickTA3DIN->ui32NumberOfIndices,
2288                                         psRGXKickTA3DIN->ui32NumberOfMRTs,
2289                                         psRGXKickTA3DIN->ui64Deadline);
2290
2291
2292
2293
2294 RGXKickTA3D_exit:
2295
2296         /* Lock over handle lookup cleanup. */
2297         LockHandle();
2298
2299
2300
2301
2302
2303
2304                                 {
2305                                         /* Unreference the previously looked up handle */
2306                                                 if(psRenderContextInt)
2307                                                 {
2308                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2309                                                                                         hRenderContext,
2310                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_RENDER_CONTEXT);
2311                                                 }
2312                                 }
2313
2314
2315
2316
2317
2318         {
2319                 IMG_UINT32 i;
2320
2321                 for (i=0;i<psRGXKickTA3DIN->ui32ClientTAFenceCount;i++)
2322                 {
2323                                 {
2324                                         /* Unreference the previously looked up handle */
2325                                                 if(psClientTAFenceSyncPrimBlockInt[i])
2326                                                 {
2327                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2328                                                                                         hClientTAFenceSyncPrimBlockInt2[i],
2329                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
2330                                                 }
2331                                 }
2332                 }
2333         }
2334
2335
2336
2337
2338
2339         {
2340                 IMG_UINT32 i;
2341
2342                 for (i=0;i<psRGXKickTA3DIN->ui32ClientTAUpdateCount;i++)
2343                 {
2344                                 {
2345                                         /* Unreference the previously looked up handle */
2346                                                 if(psClientTAUpdateSyncPrimBlockInt[i])
2347                                                 {
2348                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2349                                                                                         hClientTAUpdateSyncPrimBlockInt2[i],
2350                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
2351                                                 }
2352                                 }
2353                 }
2354         }
2355
2356
2357
2358
2359
2360         {
2361                 IMG_UINT32 i;
2362
2363                 for (i=0;i<psRGXKickTA3DIN->ui32ServerTASyncPrims;i++)
2364                 {
2365                                 {
2366                                         /* Unreference the previously looked up handle */
2367                                                 if(psServerTASyncsInt[i])
2368                                                 {
2369                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2370                                                                                         hServerTASyncsInt2[i],
2371                                                                                         PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
2372                                                 }
2373                                 }
2374                 }
2375         }
2376
2377
2378
2379
2380
2381         {
2382                 IMG_UINT32 i;
2383
2384                 for (i=0;i<psRGXKickTA3DIN->ui32Client3DFenceCount;i++)
2385                 {
2386                                 {
2387                                         /* Unreference the previously looked up handle */
2388                                                 if(psClient3DFenceSyncPrimBlockInt[i])
2389                                                 {
2390                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2391                                                                                         hClient3DFenceSyncPrimBlockInt2[i],
2392                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
2393                                                 }
2394                                 }
2395                 }
2396         }
2397
2398
2399
2400
2401
2402         {
2403                 IMG_UINT32 i;
2404
2405                 for (i=0;i<psRGXKickTA3DIN->ui32Client3DUpdateCount;i++)
2406                 {
2407                                 {
2408                                         /* Unreference the previously looked up handle */
2409                                                 if(psClient3DUpdateSyncPrimBlockInt[i])
2410                                                 {
2411                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2412                                                                                         hClient3DUpdateSyncPrimBlockInt2[i],
2413                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
2414                                                 }
2415                                 }
2416                 }
2417         }
2418
2419
2420
2421
2422
2423         {
2424                 IMG_UINT32 i;
2425
2426                 for (i=0;i<psRGXKickTA3DIN->ui32Server3DSyncPrims;i++)
2427                 {
2428                                 {
2429                                         /* Unreference the previously looked up handle */
2430                                                 if(psServer3DSyncsInt[i])
2431                                                 {
2432                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2433                                                                                         hServer3DSyncsInt2[i],
2434                                                                                         PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
2435                                                 }
2436                                 }
2437                 }
2438         }
2439
2440
2441
2442
2443
2444                                 {
2445                                         /* Unreference the previously looked up handle */
2446                                                 if(psPRFenceUFOSyncPrimBlockInt)
2447                                                 {
2448                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2449                                                                                         hPRFenceUFOSyncPrimBlock,
2450                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
2451                                                 }
2452                                 }
2453
2454
2455
2456
2457
2458                                 if (psRGXKickTA3DIN->hRTDataCleanup)
2459                                 {
2460                                         /* Unreference the previously looked up handle */
2461                                                 if(psRTDataCleanupInt)
2462                                                 {
2463                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2464                                                                                         hRTDataCleanup,
2465                                                                                         PVRSRV_HANDLE_TYPE_RGX_RTDATA_CLEANUP);
2466                                                 }
2467                                 }
2468
2469
2470
2471
2472
2473                                 if (psRGXKickTA3DIN->hZBuffer)
2474                                 {
2475                                         /* Unreference the previously looked up handle */
2476                                                 if(psZBufferInt)
2477                                                 {
2478                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2479                                                                                         hZBuffer,
2480                                                                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_ZSBUFFER);
2481                                                 }
2482                                 }
2483
2484
2485
2486
2487
2488                                 if (psRGXKickTA3DIN->hSBuffer)
2489                                 {
2490                                         /* Unreference the previously looked up handle */
2491                                                 if(psSBufferInt)
2492                                                 {
2493                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2494                                                                                         hSBuffer,
2495                                                                                         PVRSRV_HANDLE_TYPE_RGX_FWIF_ZSBUFFER);
2496                                                 }
2497                                 }
2498
2499
2500
2501
2502
2503         {
2504                 IMG_UINT32 i;
2505
2506                 for (i=0;i<psRGXKickTA3DIN->ui32SyncPMRCount;i++)
2507                 {
2508                                 {
2509                                         /* Unreference the previously looked up handle */
2510                                                 if(psSyncPMRsInt[i])
2511                                                 {
2512                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2513                                                                                         hSyncPMRsInt2[i],
2514                                                                                         PVRSRV_HANDLE_TYPE_PHYSMEM_PMR);
2515                                                 }
2516                                 }
2517                 }
2518         }
2519         /* Release now we have cleaned up look up handles. */
2520         UnlockHandle();
2521
2522         /* Allocated space should be equal to the last updated offset */
2523         PVR_ASSERT(ui32BufferSize == ui32NextOffset);
2524
2525 #if defined(INTEGRITY_OS)
2526         if(pArrayArgsBuffer)
2527 #else
2528         if(!bHaveEnoughSpace && pArrayArgsBuffer)
2529 #endif
2530                 OSFreeMemNoStats(pArrayArgsBuffer);
2531
2532
2533         return 0;
2534 }
2535
2536
2537 static IMG_INT
2538 PVRSRVBridgeRGXSetRenderContextPriority(IMG_UINT32 ui32DispatchTableEntry,
2539                                           PVRSRV_BRIDGE_IN_RGXSETRENDERCONTEXTPRIORITY *psRGXSetRenderContextPriorityIN,
2540                                           PVRSRV_BRIDGE_OUT_RGXSETRENDERCONTEXTPRIORITY *psRGXSetRenderContextPriorityOUT,
2541                                          CONNECTION_DATA *psConnection)
2542 {
2543         IMG_HANDLE hRenderContext = psRGXSetRenderContextPriorityIN->hRenderContext;
2544         RGX_SERVER_RENDER_CONTEXT * psRenderContextInt = NULL;
2545
2546
2547
2548
2549
2550
2551
2552         /* Lock over handle lookup. */
2553         LockHandle();
2554
2555
2556
2557
2558
2559                                 {
2560                                         /* Look up the address from the handle */
2561                                         psRGXSetRenderContextPriorityOUT->eError =
2562                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2563                                                                                         (void **) &psRenderContextInt,
2564                                                                                         hRenderContext,
2565                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_RENDER_CONTEXT,
2566                                                                                         IMG_TRUE);
2567                                         if(psRGXSetRenderContextPriorityOUT->eError != PVRSRV_OK)
2568                                         {
2569                                                 UnlockHandle();
2570                                                 goto RGXSetRenderContextPriority_exit;
2571                                         }
2572                                 }
2573         /* Release now we have looked up handles. */
2574         UnlockHandle();
2575
2576         psRGXSetRenderContextPriorityOUT->eError =
2577                 PVRSRVRGXSetRenderContextPriorityKM(psConnection, OSGetDevData(psConnection),
2578                                         psRenderContextInt,
2579                                         psRGXSetRenderContextPriorityIN->ui32Priority);
2580
2581
2582
2583
2584 RGXSetRenderContextPriority_exit:
2585
2586         /* Lock over handle lookup cleanup. */
2587         LockHandle();
2588
2589
2590
2591
2592
2593
2594                                 {
2595                                         /* Unreference the previously looked up handle */
2596                                                 if(psRenderContextInt)
2597                                                 {
2598                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2599                                                                                         hRenderContext,
2600                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_RENDER_CONTEXT);
2601                                                 }
2602                                 }
2603         /* Release now we have cleaned up look up handles. */
2604         UnlockHandle();
2605
2606
2607         return 0;
2608 }
2609
2610
2611 static IMG_INT
2612 PVRSRVBridgeRGXGetLastRenderContextResetReason(IMG_UINT32 ui32DispatchTableEntry,
2613                                           PVRSRV_BRIDGE_IN_RGXGETLASTRENDERCONTEXTRESETREASON *psRGXGetLastRenderContextResetReasonIN,
2614                                           PVRSRV_BRIDGE_OUT_RGXGETLASTRENDERCONTEXTRESETREASON *psRGXGetLastRenderContextResetReasonOUT,
2615                                          CONNECTION_DATA *psConnection)
2616 {
2617         IMG_HANDLE hRenderContext = psRGXGetLastRenderContextResetReasonIN->hRenderContext;
2618         RGX_SERVER_RENDER_CONTEXT * psRenderContextInt = NULL;
2619
2620
2621
2622
2623
2624
2625
2626         /* Lock over handle lookup. */
2627         LockHandle();
2628
2629
2630
2631
2632
2633                                 {
2634                                         /* Look up the address from the handle */
2635                                         psRGXGetLastRenderContextResetReasonOUT->eError =
2636                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2637                                                                                         (void **) &psRenderContextInt,
2638                                                                                         hRenderContext,
2639                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_RENDER_CONTEXT,
2640                                                                                         IMG_TRUE);
2641                                         if(psRGXGetLastRenderContextResetReasonOUT->eError != PVRSRV_OK)
2642                                         {
2643                                                 UnlockHandle();
2644                                                 goto RGXGetLastRenderContextResetReason_exit;
2645                                         }
2646                                 }
2647         /* Release now we have looked up handles. */
2648         UnlockHandle();
2649
2650         psRGXGetLastRenderContextResetReasonOUT->eError =
2651                 PVRSRVRGXGetLastRenderContextResetReasonKM(
2652                                         psRenderContextInt,
2653                                         &psRGXGetLastRenderContextResetReasonOUT->ui32LastResetReason,
2654                                         &psRGXGetLastRenderContextResetReasonOUT->ui32LastResetJobRef);
2655
2656
2657
2658
2659 RGXGetLastRenderContextResetReason_exit:
2660
2661         /* Lock over handle lookup cleanup. */
2662         LockHandle();
2663
2664
2665
2666
2667
2668
2669                                 {
2670                                         /* Unreference the previously looked up handle */
2671                                                 if(psRenderContextInt)
2672                                                 {
2673                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2674                                                                                         hRenderContext,
2675                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_RENDER_CONTEXT);
2676                                                 }
2677                                 }
2678         /* Release now we have cleaned up look up handles. */
2679         UnlockHandle();
2680
2681
2682         return 0;
2683 }
2684
2685
2686 static IMG_INT
2687 PVRSRVBridgeRGXGetPartialRenderCount(IMG_UINT32 ui32DispatchTableEntry,
2688                                           PVRSRV_BRIDGE_IN_RGXGETPARTIALRENDERCOUNT *psRGXGetPartialRenderCountIN,
2689                                           PVRSRV_BRIDGE_OUT_RGXGETPARTIALRENDERCOUNT *psRGXGetPartialRenderCountOUT,
2690                                          CONNECTION_DATA *psConnection)
2691 {
2692         IMG_HANDLE hHWRTDataMemDesc = psRGXGetPartialRenderCountIN->hHWRTDataMemDesc;
2693         DEVMEM_MEMDESC * psHWRTDataMemDescInt = NULL;
2694
2695
2696
2697
2698
2699
2700
2701         /* Lock over handle lookup. */
2702         LockHandle();
2703
2704
2705
2706
2707
2708                                 {
2709                                         /* Look up the address from the handle */
2710                                         psRGXGetPartialRenderCountOUT->eError =
2711                                                 PVRSRVLookupHandleUnlocked(psConnection->psHandleBase,
2712                                                                                         (void **) &psHWRTDataMemDescInt,
2713                                                                                         hHWRTDataMemDesc,
2714                                                                                         PVRSRV_HANDLE_TYPE_RGX_FW_MEMDESC,
2715                                                                                         IMG_TRUE);
2716                                         if(psRGXGetPartialRenderCountOUT->eError != PVRSRV_OK)
2717                                         {
2718                                                 UnlockHandle();
2719                                                 goto RGXGetPartialRenderCount_exit;
2720                                         }
2721                                 }
2722         /* Release now we have looked up handles. */
2723         UnlockHandle();
2724
2725         psRGXGetPartialRenderCountOUT->eError =
2726                 PVRSRVRGXGetPartialRenderCountKM(
2727                                         psHWRTDataMemDescInt,
2728                                         &psRGXGetPartialRenderCountOUT->ui32NumPartialRenders);
2729
2730
2731
2732
2733 RGXGetPartialRenderCount_exit:
2734
2735         /* Lock over handle lookup cleanup. */
2736         LockHandle();
2737
2738
2739
2740
2741
2742
2743                                 {
2744                                         /* Unreference the previously looked up handle */
2745                                                 if(psHWRTDataMemDescInt)
2746                                                 {
2747                                                         PVRSRVReleaseHandleUnlocked(psConnection->psHandleBase,
2748                                                                                         hHWRTDataMemDesc,
2749                                                                                         PVRSRV_HANDLE_TYPE_RGX_FW_MEMDESC);
2750                                                 }
2751                                 }
2752         /* Release now we have cleaned up look up handles. */
2753         UnlockHandle();
2754
2755
2756         return 0;
2757 }
2758
2759
2760
2761
2762 /* ***************************************************************************
2763  * Server bridge dispatch related glue
2764  */
2765
2766 static IMG_BOOL bUseLock = IMG_TRUE;
2767
2768 PVRSRV_ERROR InitRGXTA3DBridge(void);
2769 PVRSRV_ERROR DeinitRGXTA3DBridge(void);
2770
2771 /*
2772  * Register all RGXTA3D functions with services
2773  */
2774 PVRSRV_ERROR InitRGXTA3DBridge(void)
2775 {
2776
2777         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXCREATEHWRTDATA, PVRSRVBridgeRGXCreateHWRTData,
2778                                         NULL, bUseLock);
2779
2780         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXDESTROYHWRTDATA, PVRSRVBridgeRGXDestroyHWRTData,
2781                                         NULL, bUseLock);
2782
2783         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXCREATERENDERTARGET, PVRSRVBridgeRGXCreateRenderTarget,
2784                                         NULL, bUseLock);
2785
2786         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXDESTROYRENDERTARGET, PVRSRVBridgeRGXDestroyRenderTarget,
2787                                         NULL, bUseLock);
2788
2789         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXCREATEZSBUFFER, PVRSRVBridgeRGXCreateZSBuffer,
2790                                         NULL, bUseLock);
2791
2792         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXDESTROYZSBUFFER, PVRSRVBridgeRGXDestroyZSBuffer,
2793                                         NULL, bUseLock);
2794
2795         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXPOPULATEZSBUFFER, PVRSRVBridgeRGXPopulateZSBuffer,
2796                                         NULL, bUseLock);
2797
2798         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXUNPOPULATEZSBUFFER, PVRSRVBridgeRGXUnpopulateZSBuffer,
2799                                         NULL, bUseLock);
2800
2801         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXCREATEFREELIST, PVRSRVBridgeRGXCreateFreeList,
2802                                         NULL, bUseLock);
2803
2804         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXDESTROYFREELIST, PVRSRVBridgeRGXDestroyFreeList,
2805                                         NULL, bUseLock);
2806
2807         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXADDBLOCKTOFREELIST, PVRSRVBridgeRGXAddBlockToFreeList,
2808                                         NULL, bUseLock);
2809
2810         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXREMOVEBLOCKFROMFREELIST, PVRSRVBridgeRGXRemoveBlockFromFreeList,
2811                                         NULL, bUseLock);
2812
2813         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXCREATERENDERCONTEXT, PVRSRVBridgeRGXCreateRenderContext,
2814                                         NULL, bUseLock);
2815
2816         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXDESTROYRENDERCONTEXT, PVRSRVBridgeRGXDestroyRenderContext,
2817                                         NULL, bUseLock);
2818
2819         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXKICKTA3D, PVRSRVBridgeRGXKickTA3D,
2820                                         NULL, bUseLock);
2821
2822         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXSETRENDERCONTEXTPRIORITY, PVRSRVBridgeRGXSetRenderContextPriority,
2823                                         NULL, bUseLock);
2824
2825         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXGETLASTRENDERCONTEXTRESETREASON, PVRSRVBridgeRGXGetLastRenderContextResetReason,
2826                                         NULL, bUseLock);
2827
2828         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXTA3D, PVRSRV_BRIDGE_RGXTA3D_RGXGETPARTIALRENDERCOUNT, PVRSRVBridgeRGXGetPartialRenderCount,
2829                                         NULL, bUseLock);
2830
2831
2832         return PVRSRV_OK;
2833 }
2834
2835 /*
2836  * Unregister all rgxta3d functions with services
2837  */
2838 PVRSRV_ERROR DeinitRGXTA3DBridge(void)
2839 {
2840         return PVRSRV_OK;
2841 }