drivers/gpu/rogue/generated/rgxcmp_bridge/server_rgxcmp_bridge.c

   1 /*************************************************************************/ /*!
   2 @File
   3 @Title          Server bridge for rgxcmp
   4 @Copyright      Copyright (c) Imagination Technologies Ltd. All Rights Reserved
   5 @Description    Implements the server side of the bridge for rgxcmp
   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 "rgxcompute.h"
  50
  51
  52 #include "common_rgxcmp_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 #if defined (SUPPORT_AUTH)
  63 #include "osauth.h"
  64 #endif
  65
  66 #include <linux/slab.h>
  67
  68 /* ***************************************************************************
  69  * Bridge proxy functions
  70  */
  71
  72 static PVRSRV_ERROR
  73 RGXDestroyComputeContextResManProxy(IMG_HANDLE hResmanItem)
  74 {
  75         PVRSRV_ERROR eError;
  76
  77         eError = ResManFreeResByPtr(hResmanItem);
  78
  79         /* Freeing a resource should never fail... */
  80         PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
  81
  82         return eError;
  83 }
  84
  85
  86
  87 /* ***************************************************************************
  88  * Server-side bridge entry points
  89  */
  90
  91 static IMG_INT
  92 PVRSRVBridgeRGXCreateComputeContext(IMG_UINT32 ui32BridgeID,
  93                                          PVRSRV_BRIDGE_IN_RGXCREATECOMPUTECONTEXT *psRGXCreateComputeContextIN,
  94                                          PVRSRV_BRIDGE_OUT_RGXCREATECOMPUTECONTEXT *psRGXCreateComputeContextOUT,
  95                                          CONNECTION_DATA *psConnection)
  96 {
  97         IMG_HANDLE hDevNodeInt = IMG_NULL;
  98         IMG_BYTE *psFrameworkCmdInt = IMG_NULL;
  99         IMG_HANDLE hPrivDataInt = IMG_NULL;
 100         RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
 101         IMG_HANDLE hComputeContextInt2 = IMG_NULL;
 102
 103         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXCREATECOMPUTECONTEXT);
 104
 105
 106
 107
 108         if (psRGXCreateComputeContextIN->ui32FrameworkCmdize != 0)
 109         {
 110                 psFrameworkCmdInt = OSAllocMem(psRGXCreateComputeContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE));
 111                 if (!psFrameworkCmdInt)
 112                 {
 113                         psRGXCreateComputeContextOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 114
 115                         goto RGXCreateComputeContext_exit;
 116                 }
 117         }
 118
 119                         /* Copy the data over */
 120                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXCreateComputeContextIN->psFrameworkCmd, psRGXCreateComputeContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE))
 121                                 || (OSCopyFromUser(NULL, psFrameworkCmdInt, psRGXCreateComputeContextIN->psFrameworkCmd,
 122                                 psRGXCreateComputeContextIN->ui32FrameworkCmdize * sizeof(IMG_BYTE)) != PVRSRV_OK) )
 123                         {
 124                                 psRGXCreateComputeContextOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 125
 126                                 goto RGXCreateComputeContext_exit;
 127                         }
 128
 129                                 {
 130                                         /* Look up the address from the handle */
 131                                         psRGXCreateComputeContextOUT->eError =
 132                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 133                                                                                         (IMG_HANDLE *) &hDevNodeInt,
 134                                                                                         psRGXCreateComputeContextIN->hDevNode,
 135                                                                                         PVRSRV_HANDLE_TYPE_DEV_NODE);
 136                                         if(psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
 137                                         {
 138                                                 goto RGXCreateComputeContext_exit;
 139                                         }
 140
 141                                 }
 142
 143                                 {
 144                                         /* Look up the address from the handle */
 145                                         psRGXCreateComputeContextOUT->eError =
 146                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 147                                                                                         (IMG_HANDLE *) &hPrivDataInt,
 148                                                                                         psRGXCreateComputeContextIN->hPrivData,
 149                                                                                         PVRSRV_HANDLE_TYPE_DEV_PRIV_DATA);
 150                                         if(psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
 151                                         {
 152                                                 goto RGXCreateComputeContext_exit;
 153                                         }
 154
 155                                 }
 156
 157         psRGXCreateComputeContextOUT->eError =
 158                 PVRSRVRGXCreateComputeContextKM(psConnection,
 159                                         hDevNodeInt,
 160                                         psRGXCreateComputeContextIN->ui32Priority,
 161                                         psRGXCreateComputeContextIN->sMCUFenceAddr,
 162                                         psRGXCreateComputeContextIN->ui32FrameworkCmdize,
 163                                         psFrameworkCmdInt,
 164                                         hPrivDataInt,
 165                                         &psComputeContextInt);
 166         /* Exit early if bridged call fails */
 167         if(psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
 168         {
 169                 goto RGXCreateComputeContext_exit;
 170         }
 171
 172         /* Create a resman item and overwrite the handle with it */
 173         hComputeContextInt2 = ResManRegisterRes(psConnection->hResManContext,
 174                                                                                                 RESMAN_TYPE_RGX_SERVER_COMPUTE_CONTEXT,
 175                                                                                                 psComputeContextInt,
 176                                                                                                 (RESMAN_FREE_FN)&PVRSRVRGXDestroyComputeContextKM);
 177         if (hComputeContextInt2 == IMG_NULL)
 178         {
 179                 psRGXCreateComputeContextOUT->eError = PVRSRV_ERROR_UNABLE_TO_REGISTER_RESOURCE;
 180                 goto RGXCreateComputeContext_exit;
 181         }
 182         psRGXCreateComputeContextOUT->eError = PVRSRVAllocHandle(psConnection->psHandleBase,
 183                                                         &psRGXCreateComputeContextOUT->hComputeContext,
 184                                                         (IMG_HANDLE) hComputeContextInt2,
 185                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT,
 186                                                         PVRSRV_HANDLE_ALLOC_FLAG_NONE
 187                                                         );
 188         if (psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
 189         {
 190                 goto RGXCreateComputeContext_exit;
 191         }
 192
 193
 194 RGXCreateComputeContext_exit:
 195         if (psRGXCreateComputeContextOUT->eError != PVRSRV_OK)
 196         {
 197                 /* If we have a valid resman item we should undo the bridge function by freeing the resman item */
 198                 if (hComputeContextInt2)
 199                 {
 200                         PVRSRV_ERROR eError = ResManFreeResByPtr(hComputeContextInt2);
 201
 202                         /* Freeing a resource should never fail... */
 203                         PVR_ASSERT((eError == PVRSRV_OK) || (eError == PVRSRV_ERROR_RETRY));
 204                 }
 205                 else if (psComputeContextInt)
 206                 {
 207                         PVRSRVRGXDestroyComputeContextKM(psComputeContextInt);
 208                 }
 209         }
 210
 211         if (psFrameworkCmdInt)
 212                 OSFreeMem(psFrameworkCmdInt);
 213
 214         return 0;
 215 }
 216
 217 static IMG_INT
 218 PVRSRVBridgeRGXDestroyComputeContext(IMG_UINT32 ui32BridgeID,
 219                                          PVRSRV_BRIDGE_IN_RGXDESTROYCOMPUTECONTEXT *psRGXDestroyComputeContextIN,
 220                                          PVRSRV_BRIDGE_OUT_RGXDESTROYCOMPUTECONTEXT *psRGXDestroyComputeContextOUT,
 221                                          CONNECTION_DATA *psConnection)
 222 {
 223         IMG_HANDLE hComputeContextInt2 = IMG_NULL;
 224
 225         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXDESTROYCOMPUTECONTEXT);
 226
 227
 228
 229
 230
 231                                 {
 232                                         /* Look up the address from the handle */
 233                                         psRGXDestroyComputeContextOUT->eError =
 234                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 235                                                                                         (IMG_HANDLE *) &hComputeContextInt2,
 236                                                                                         psRGXDestroyComputeContextIN->hComputeContext,
 237                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
 238                                         if(psRGXDestroyComputeContextOUT->eError != PVRSRV_OK)
 239                                         {
 240                                                 goto RGXDestroyComputeContext_exit;
 241                                         }
 242
 243                                 }
 244
 245         psRGXDestroyComputeContextOUT->eError = RGXDestroyComputeContextResManProxy(hComputeContextInt2);
 246         /* Exit early if bridged call fails */
 247         if(psRGXDestroyComputeContextOUT->eError != PVRSRV_OK)
 248         {
 249                 goto RGXDestroyComputeContext_exit;
 250         }
 251
 252         psRGXDestroyComputeContextOUT->eError =
 253                 PVRSRVReleaseHandle(psConnection->psHandleBase,
 254                                         (IMG_HANDLE) psRGXDestroyComputeContextIN->hComputeContext,
 255                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
 256
 257
 258 RGXDestroyComputeContext_exit:
 259
 260         return 0;
 261 }
 262
 263 static IMG_INT
 264 PVRSRVBridgeRGXKickCDM(IMG_UINT32 ui32BridgeID,
 265                                          PVRSRV_BRIDGE_IN_RGXKICKCDM *psRGXKickCDMIN,
 266                                          PVRSRV_BRIDGE_OUT_RGXKICKCDM *psRGXKickCDMOUT,
 267                                          CONNECTION_DATA *psConnection)
 268 {
 269         RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
 270         IMG_HANDLE hComputeContextInt2 = IMG_NULL;
 271         SYNC_PRIMITIVE_BLOCK * *psClientFenceUFOSyncPrimBlockInt = IMG_NULL;
 272         IMG_HANDLE *hClientFenceUFOSyncPrimBlockInt2 = IMG_NULL;
 273         IMG_UINT32 *ui32ClientFenceSyncOffsetInt = IMG_NULL;
 274         IMG_UINT32 *ui32ClientFenceValueInt = IMG_NULL;
 275         SYNC_PRIMITIVE_BLOCK * *psClientUpdateUFOSyncPrimBlockInt = IMG_NULL;
 276         IMG_HANDLE *hClientUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
 277         IMG_UINT32 *ui32ClientUpdateSyncOffsetInt = IMG_NULL;
 278         IMG_UINT32 *ui32ClientUpdateValueInt = IMG_NULL;
 279         IMG_UINT32 *ui32ServerSyncFlagsInt = IMG_NULL;
 280         SERVER_SYNC_PRIMITIVE * *psServerSyncsInt = IMG_NULL;
 281         IMG_HANDLE *hServerSyncsInt2 = IMG_NULL;
 282         IMG_BYTE *psDMCmdInt = IMG_NULL;
 283
 284         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXKICKCDM);
 285
 286
 287
 288
 289         if (psRGXKickCDMIN->ui32ClientFenceCount != 0)
 290         {
 291                 psClientFenceUFOSyncPrimBlockInt = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
 292                 if (!psClientFenceUFOSyncPrimBlockInt)
 293                 {
 294                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 295
 296                         goto RGXKickCDM_exit;
 297                 }
 298                 hClientFenceUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE));
 299                 if (!hClientFenceUFOSyncPrimBlockInt2)
 300                 {
 301                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 302
 303                         goto RGXKickCDM_exit;
 304                 }
 305         }
 306
 307                         /* Copy the data over */
 308                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->phClientFenceUFOSyncPrimBlock, psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE))
 309                                 || (OSCopyFromUser(NULL, hClientFenceUFOSyncPrimBlockInt2, psRGXKickCDMIN->phClientFenceUFOSyncPrimBlock,
 310                                 psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
 311                         {
 312                                 psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 313
 314                                 goto RGXKickCDM_exit;
 315                         }
 316         if (psRGXKickCDMIN->ui32ClientFenceCount != 0)
 317         {
 318                 ui32ClientFenceSyncOffsetInt = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32));
 319                 if (!ui32ClientFenceSyncOffsetInt)
 320                 {
 321                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 322
 323                         goto RGXKickCDM_exit;
 324                 }
 325         }
 326
 327                         /* Copy the data over */
 328                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ClientFenceSyncOffset, psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32))
 329                                 || (OSCopyFromUser(NULL, ui32ClientFenceSyncOffsetInt, psRGXKickCDMIN->pui32ClientFenceSyncOffset,
 330                                 psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 331                         {
 332                                 psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 333
 334                                 goto RGXKickCDM_exit;
 335                         }
 336         if (psRGXKickCDMIN->ui32ClientFenceCount != 0)
 337         {
 338                 ui32ClientFenceValueInt = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32));
 339                 if (!ui32ClientFenceValueInt)
 340                 {
 341                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 342
 343                         goto RGXKickCDM_exit;
 344                 }
 345         }
 346
 347                         /* Copy the data over */
 348                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ClientFenceValue, psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32))
 349                                 || (OSCopyFromUser(NULL, ui32ClientFenceValueInt, psRGXKickCDMIN->pui32ClientFenceValue,
 350                                 psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 351                         {
 352                                 psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 353
 354                                 goto RGXKickCDM_exit;
 355                         }
 356         if (psRGXKickCDMIN->ui32ClientUpdateCount != 0)
 357         {
 358                 psClientUpdateUFOSyncPrimBlockInt = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
 359                 if (!psClientUpdateUFOSyncPrimBlockInt)
 360                 {
 361                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 362
 363                         goto RGXKickCDM_exit;
 364                 }
 365                 hClientUpdateUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE));
 366                 if (!hClientUpdateUFOSyncPrimBlockInt2)
 367                 {
 368                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 369
 370                         goto RGXKickCDM_exit;
 371                 }
 372         }
 373
 374                         /* Copy the data over */
 375                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->phClientUpdateUFOSyncPrimBlock, psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE))
 376                                 || (OSCopyFromUser(NULL, hClientUpdateUFOSyncPrimBlockInt2, psRGXKickCDMIN->phClientUpdateUFOSyncPrimBlock,
 377                                 psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
 378                         {
 379                                 psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 380
 381                                 goto RGXKickCDM_exit;
 382                         }
 383         if (psRGXKickCDMIN->ui32ClientUpdateCount != 0)
 384         {
 385                 ui32ClientUpdateSyncOffsetInt = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32));
 386                 if (!ui32ClientUpdateSyncOffsetInt)
 387                 {
 388                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 389
 390                         goto RGXKickCDM_exit;
 391                 }
 392         }
 393
 394                         /* Copy the data over */
 395                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ClientUpdateSyncOffset, psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32))
 396                                 || (OSCopyFromUser(NULL, ui32ClientUpdateSyncOffsetInt, psRGXKickCDMIN->pui32ClientUpdateSyncOffset,
 397                                 psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 398                         {
 399                                 psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 400
 401                                 goto RGXKickCDM_exit;
 402                         }
 403         if (psRGXKickCDMIN->ui32ClientUpdateCount != 0)
 404         {
 405                 ui32ClientUpdateValueInt = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32));
 406                 if (!ui32ClientUpdateValueInt)
 407                 {
 408                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 409
 410                         goto RGXKickCDM_exit;
 411                 }
 412         }
 413
 414                         /* Copy the data over */
 415                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ClientUpdateValue, psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32))
 416                                 || (OSCopyFromUser(NULL, ui32ClientUpdateValueInt, psRGXKickCDMIN->pui32ClientUpdateValue,
 417                                 psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 418                         {
 419                                 psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 420
 421                                 goto RGXKickCDM_exit;
 422                         }
 423         if (psRGXKickCDMIN->ui32ServerSyncCount != 0)
 424         {
 425                 ui32ServerSyncFlagsInt = OSAllocMem(psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32));
 426                 if (!ui32ServerSyncFlagsInt)
 427                 {
 428                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 429
 430                         goto RGXKickCDM_exit;
 431                 }
 432         }
 433
 434                         /* Copy the data over */
 435                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ServerSyncFlags, psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32))
 436                                 || (OSCopyFromUser(NULL, ui32ServerSyncFlagsInt, psRGXKickCDMIN->pui32ServerSyncFlags,
 437                                 psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 438                         {
 439                                 psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 440
 441                                 goto RGXKickCDM_exit;
 442                         }
 443         if (psRGXKickCDMIN->ui32ServerSyncCount != 0)
 444         {
 445                 psServerSyncsInt = OSAllocMem(psRGXKickCDMIN->ui32ServerSyncCount * sizeof(SERVER_SYNC_PRIMITIVE *));
 446                 if (!psServerSyncsInt)
 447                 {
 448                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 449
 450                         goto RGXKickCDM_exit;
 451                 }
 452                 hServerSyncsInt2 = OSAllocMem(psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE));
 453                 if (!hServerSyncsInt2)
 454                 {
 455                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 456
 457                         goto RGXKickCDM_exit;
 458                 }
 459         }
 460
 461                         /* Copy the data over */
 462                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->phServerSyncs, psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE))
 463                                 || (OSCopyFromUser(NULL, hServerSyncsInt2, psRGXKickCDMIN->phServerSyncs,
 464                                 psRGXKickCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
 465                         {
 466                                 psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 467
 468                                 goto RGXKickCDM_exit;
 469                         }
 470         if (psRGXKickCDMIN->ui32CmdSize != 0)
 471         {
 472                 psDMCmdInt = OSAllocMem(psRGXKickCDMIN->ui32CmdSize * sizeof(IMG_BYTE));
 473                 if (!psDMCmdInt)
 474                 {
 475                         psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 476
 477                         goto RGXKickCDM_exit;
 478                 }
 479         }
 480
 481                         /* Copy the data over */
 482                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->psDMCmd, psRGXKickCDMIN->ui32CmdSize * sizeof(IMG_BYTE))
 483                                 || (OSCopyFromUser(NULL, psDMCmdInt, psRGXKickCDMIN->psDMCmd,
 484                                 psRGXKickCDMIN->ui32CmdSize * sizeof(IMG_BYTE)) != PVRSRV_OK) )
 485                         {
 486                                 psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 487
 488                                 goto RGXKickCDM_exit;
 489                         }
 490
 491                                 {
 492                                         /* Look up the address from the handle */
 493                                         psRGXKickCDMOUT->eError =
 494                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 495                                                                                         (IMG_HANDLE *) &hComputeContextInt2,
 496                                                                                         psRGXKickCDMIN->hComputeContext,
 497                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
 498                                         if(psRGXKickCDMOUT->eError != PVRSRV_OK)
 499                                         {
 500                                                 goto RGXKickCDM_exit;
 501                                         }
 502
 503                                         /* Look up the data from the resman address */
 504                                         psRGXKickCDMOUT->eError = ResManFindPrivateDataByPtr(hComputeContextInt2, (IMG_VOID **) &psComputeContextInt);
 505
 506                                         if(psRGXKickCDMOUT->eError != PVRSRV_OK)
 507                                         {
 508                                                 goto RGXKickCDM_exit;
 509                                         }
 510                                 }
 511
 512         {
 513                 IMG_UINT32 i;
 514
 515                 for (i=0;i<psRGXKickCDMIN->ui32ClientFenceCount;i++)
 516                 {
 517                                 {
 518                                         /* Look up the address from the handle */
 519                                         psRGXKickCDMOUT->eError =
 520                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 521                                                                                         (IMG_HANDLE *) &hClientFenceUFOSyncPrimBlockInt2[i],
 522                                                                                         hClientFenceUFOSyncPrimBlockInt2[i],
 523                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
 524                                         if(psRGXKickCDMOUT->eError != PVRSRV_OK)
 525                                         {
 526                                                 goto RGXKickCDM_exit;
 527                                         }
 528
 529                                         /* Look up the data from the resman address */
 530                                         psRGXKickCDMOUT->eError = ResManFindPrivateDataByPtr(hClientFenceUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientFenceUFOSyncPrimBlockInt[i]);
 531
 532                                         if(psRGXKickCDMOUT->eError != PVRSRV_OK)
 533                                         {
 534                                                 goto RGXKickCDM_exit;
 535                                         }
 536                                 }
 537                 }
 538         }
 539
 540         {
 541                 IMG_UINT32 i;
 542
 543                 for (i=0;i<psRGXKickCDMIN->ui32ClientUpdateCount;i++)
 544                 {
 545                                 {
 546                                         /* Look up the address from the handle */
 547                                         psRGXKickCDMOUT->eError =
 548                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 549                                                                                         (IMG_HANDLE *) &hClientUpdateUFOSyncPrimBlockInt2[i],
 550                                                                                         hClientUpdateUFOSyncPrimBlockInt2[i],
 551                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
 552                                         if(psRGXKickCDMOUT->eError != PVRSRV_OK)
 553                                         {
 554                                                 goto RGXKickCDM_exit;
 555                                         }
 556
 557                                         /* Look up the data from the resman address */
 558                                         psRGXKickCDMOUT->eError = ResManFindPrivateDataByPtr(hClientUpdateUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientUpdateUFOSyncPrimBlockInt[i]);
 559
 560                                         if(psRGXKickCDMOUT->eError != PVRSRV_OK)
 561                                         {
 562                                                 goto RGXKickCDM_exit;
 563                                         }
 564                                 }
 565                 }
 566         }
 567
 568         {
 569                 IMG_UINT32 i;
 570
 571                 for (i=0;i<psRGXKickCDMIN->ui32ServerSyncCount;i++)
 572                 {
 573                                 {
 574                                         /* Look up the address from the handle */
 575                                         psRGXKickCDMOUT->eError =
 576                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 577                                                                                         (IMG_HANDLE *) &hServerSyncsInt2[i],
 578                                                                                         hServerSyncsInt2[i],
 579                                                                                         PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
 580                                         if(psRGXKickCDMOUT->eError != PVRSRV_OK)
 581                                         {
 582                                                 goto RGXKickCDM_exit;
 583                                         }
 584
 585                                         /* Look up the data from the resman address */
 586                                         psRGXKickCDMOUT->eError = ResManFindPrivateDataByPtr(hServerSyncsInt2[i], (IMG_VOID **) &psServerSyncsInt[i]);
 587
 588                                         if(psRGXKickCDMOUT->eError != PVRSRV_OK)
 589                                         {
 590                                                 goto RGXKickCDM_exit;
 591                                         }
 592                                 }
 593                 }
 594         }
 595
 596         psRGXKickCDMOUT->eError =
 597                 PVRSRVRGXKickCDMKM(
 598                                         psComputeContextInt,
 599                                         psRGXKickCDMIN->ui32ClientFenceCount,
 600                                         psClientFenceUFOSyncPrimBlockInt,
 601                                         ui32ClientFenceSyncOffsetInt,
 602                                         ui32ClientFenceValueInt,
 603                                         psRGXKickCDMIN->ui32ClientUpdateCount,
 604                                         psClientUpdateUFOSyncPrimBlockInt,
 605                                         ui32ClientUpdateSyncOffsetInt,
 606                                         ui32ClientUpdateValueInt,
 607                                         psRGXKickCDMIN->ui32ServerSyncCount,
 608                                         ui32ServerSyncFlagsInt,
 609                                         psServerSyncsInt,
 610                                         psRGXKickCDMIN->ui32CmdSize,
 611                                         psDMCmdInt,
 612                                         psRGXKickCDMIN->bbPDumpContinuous,
 613                                         psRGXKickCDMIN->ui32ExternalJobReference,
 614                                         psRGXKickCDMIN->ui32InternalJobReference);
 615
 616
 617
 618 RGXKickCDM_exit:
 619         if (psClientFenceUFOSyncPrimBlockInt)
 620                 OSFreeMem(psClientFenceUFOSyncPrimBlockInt);
 621         if (hClientFenceUFOSyncPrimBlockInt2)
 622                 OSFreeMem(hClientFenceUFOSyncPrimBlockInt2);
 623         if (ui32ClientFenceSyncOffsetInt)
 624                 OSFreeMem(ui32ClientFenceSyncOffsetInt);
 625         if (ui32ClientFenceValueInt)
 626                 OSFreeMem(ui32ClientFenceValueInt);
 627         if (psClientUpdateUFOSyncPrimBlockInt)
 628                 OSFreeMem(psClientUpdateUFOSyncPrimBlockInt);
 629         if (hClientUpdateUFOSyncPrimBlockInt2)
 630                 OSFreeMem(hClientUpdateUFOSyncPrimBlockInt2);
 631         if (ui32ClientUpdateSyncOffsetInt)
 632                 OSFreeMem(ui32ClientUpdateSyncOffsetInt);
 633         if (ui32ClientUpdateValueInt)
 634                 OSFreeMem(ui32ClientUpdateValueInt);
 635         if (ui32ServerSyncFlagsInt)
 636                 OSFreeMem(ui32ServerSyncFlagsInt);
 637         if (psServerSyncsInt)
 638                 OSFreeMem(psServerSyncsInt);
 639         if (hServerSyncsInt2)
 640                 OSFreeMem(hServerSyncsInt2);
 641         if (psDMCmdInt)
 642                 OSFreeMem(psDMCmdInt);
 643
 644         return 0;
 645 }
 646
 647 static IMG_INT
 648 PVRSRVBridgeRGXFlushComputeData(IMG_UINT32 ui32BridgeID,
 649                                          PVRSRV_BRIDGE_IN_RGXFLUSHCOMPUTEDATA *psRGXFlushComputeDataIN,
 650                                          PVRSRV_BRIDGE_OUT_RGXFLUSHCOMPUTEDATA *psRGXFlushComputeDataOUT,
 651                                          CONNECTION_DATA *psConnection)
 652 {
 653         RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
 654         IMG_HANDLE hComputeContextInt2 = IMG_NULL;
 655
 656         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXFLUSHCOMPUTEDATA);
 657
 658
 659
 660
 661
 662                                 {
 663                                         /* Look up the address from the handle */
 664                                         psRGXFlushComputeDataOUT->eError =
 665                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 666                                                                                         (IMG_HANDLE *) &hComputeContextInt2,
 667                                                                                         psRGXFlushComputeDataIN->hComputeContext,
 668                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
 669                                         if(psRGXFlushComputeDataOUT->eError != PVRSRV_OK)
 670                                         {
 671                                                 goto RGXFlushComputeData_exit;
 672                                         }
 673
 674                                         /* Look up the data from the resman address */
 675                                         psRGXFlushComputeDataOUT->eError = ResManFindPrivateDataByPtr(hComputeContextInt2, (IMG_VOID **) &psComputeContextInt);
 676
 677                                         if(psRGXFlushComputeDataOUT->eError != PVRSRV_OK)
 678                                         {
 679                                                 goto RGXFlushComputeData_exit;
 680                                         }
 681                                 }
 682
 683         psRGXFlushComputeDataOUT->eError =
 684                 PVRSRVRGXFlushComputeDataKM(
 685                                         psComputeContextInt);
 686
 687
 688
 689 RGXFlushComputeData_exit:
 690
 691         return 0;
 692 }
 693
 694 static IMG_INT
 695 PVRSRVBridgeRGXSetComputeContextPriority(IMG_UINT32 ui32BridgeID,
 696                                          PVRSRV_BRIDGE_IN_RGXSETCOMPUTECONTEXTPRIORITY *psRGXSetComputeContextPriorityIN,
 697                                          PVRSRV_BRIDGE_OUT_RGXSETCOMPUTECONTEXTPRIORITY *psRGXSetComputeContextPriorityOUT,
 698                                          CONNECTION_DATA *psConnection)
 699 {
 700         RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
 701         IMG_HANDLE hComputeContextInt2 = IMG_NULL;
 702
 703         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXSETCOMPUTECONTEXTPRIORITY);
 704
 705
 706
 707
 708
 709                                 {
 710                                         /* Look up the address from the handle */
 711                                         psRGXSetComputeContextPriorityOUT->eError =
 712                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 713                                                                                         (IMG_HANDLE *) &hComputeContextInt2,
 714                                                                                         psRGXSetComputeContextPriorityIN->hComputeContext,
 715                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
 716                                         if(psRGXSetComputeContextPriorityOUT->eError != PVRSRV_OK)
 717                                         {
 718                                                 goto RGXSetComputeContextPriority_exit;
 719                                         }
 720
 721                                         /* Look up the data from the resman address */
 722                                         psRGXSetComputeContextPriorityOUT->eError = ResManFindPrivateDataByPtr(hComputeContextInt2, (IMG_VOID **) &psComputeContextInt);
 723
 724                                         if(psRGXSetComputeContextPriorityOUT->eError != PVRSRV_OK)
 725                                         {
 726                                                 goto RGXSetComputeContextPriority_exit;
 727                                         }
 728                                 }
 729
 730         psRGXSetComputeContextPriorityOUT->eError =
 731                 PVRSRVRGXSetComputeContextPriorityKM(psConnection,
 732                                         psComputeContextInt,
 733                                         psRGXSetComputeContextPriorityIN->ui32Priority);
 734
 735
 736
 737 RGXSetComputeContextPriority_exit:
 738
 739         return 0;
 740 }
 741
 742 static IMG_INT
 743 PVRSRVBridgeRGXKickSyncCDM(IMG_UINT32 ui32BridgeID,
 744                                          PVRSRV_BRIDGE_IN_RGXKICKSYNCCDM *psRGXKickSyncCDMIN,
 745                                          PVRSRV_BRIDGE_OUT_RGXKICKSYNCCDM *psRGXKickSyncCDMOUT,
 746                                          CONNECTION_DATA *psConnection)
 747 {
 748         RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
 749         IMG_HANDLE hComputeContextInt2 = IMG_NULL;
 750         SYNC_PRIMITIVE_BLOCK * *psClientFenceUFOSyncPrimBlockInt = IMG_NULL;
 751         IMG_HANDLE *hClientFenceUFOSyncPrimBlockInt2 = IMG_NULL;
 752         IMG_UINT32 *ui32ClientFenceSyncOffsetInt = IMG_NULL;
 753         IMG_UINT32 *ui32ClientFenceValueInt = IMG_NULL;
 754         SYNC_PRIMITIVE_BLOCK * *psClientUpdateUFOSyncPrimBlockInt = IMG_NULL;
 755         IMG_HANDLE *hClientUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
 756         IMG_UINT32 *ui32ClientUpdateSyncOffsetInt = IMG_NULL;
 757         IMG_UINT32 *ui32ClientUpdateValueInt = IMG_NULL;
 758         IMG_UINT32 *ui32ServerSyncFlagsInt = IMG_NULL;
 759         SERVER_SYNC_PRIMITIVE * *psServerSyncsInt = IMG_NULL;
 760         IMG_HANDLE *hServerSyncsInt2 = IMG_NULL;
 761         IMG_INT32 *i32FenceFDsInt = IMG_NULL;
 762
 763         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RGXCMP_RGXKICKSYNCCDM);
 764
 765
 766
 767
 768         if (psRGXKickSyncCDMIN->ui32ClientFenceCount != 0)
 769         {
 770                 psClientFenceUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
 771                 if (!psClientFenceUFOSyncPrimBlockInt)
 772                 {
 773                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 774
 775                         goto RGXKickSyncCDM_exit;
 776                 }
 777                 hClientFenceUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE));
 778                 if (!hClientFenceUFOSyncPrimBlockInt2)
 779                 {
 780                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 781
 782                         goto RGXKickSyncCDM_exit;
 783                 }
 784         }
 785
 786                         /* Copy the data over */
 787                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->phClientFenceUFOSyncPrimBlock, psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE))
 788                                 || (OSCopyFromUser(NULL, hClientFenceUFOSyncPrimBlockInt2, psRGXKickSyncCDMIN->phClientFenceUFOSyncPrimBlock,
 789                                 psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
 790                         {
 791                                 psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 792
 793                                 goto RGXKickSyncCDM_exit;
 794                         }
 795         if (psRGXKickSyncCDMIN->ui32ClientFenceCount != 0)
 796         {
 797                 ui32ClientFenceSyncOffsetInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32));
 798                 if (!ui32ClientFenceSyncOffsetInt)
 799                 {
 800                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 801
 802                         goto RGXKickSyncCDM_exit;
 803                 }
 804         }
 805
 806                         /* Copy the data over */
 807                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->pui32ClientFenceSyncOffset, psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32))
 808                                 || (OSCopyFromUser(NULL, ui32ClientFenceSyncOffsetInt, psRGXKickSyncCDMIN->pui32ClientFenceSyncOffset,
 809                                 psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 810                         {
 811                                 psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 812
 813                                 goto RGXKickSyncCDM_exit;
 814                         }
 815         if (psRGXKickSyncCDMIN->ui32ClientFenceCount != 0)
 816         {
 817                 ui32ClientFenceValueInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32));
 818                 if (!ui32ClientFenceValueInt)
 819                 {
 820                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 821
 822                         goto RGXKickSyncCDM_exit;
 823                 }
 824         }
 825
 826                         /* Copy the data over */
 827                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->pui32ClientFenceValue, psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32))
 828                                 || (OSCopyFromUser(NULL, ui32ClientFenceValueInt, psRGXKickSyncCDMIN->pui32ClientFenceValue,
 829                                 psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 830                         {
 831                                 psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 832
 833                                 goto RGXKickSyncCDM_exit;
 834                         }
 835         if (psRGXKickSyncCDMIN->ui32ClientUpdateCount != 0)
 836         {
 837                 psClientUpdateUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
 838                 if (!psClientUpdateUFOSyncPrimBlockInt)
 839                 {
 840                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 841
 842                         goto RGXKickSyncCDM_exit;
 843                 }
 844                 hClientUpdateUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE));
 845                 if (!hClientUpdateUFOSyncPrimBlockInt2)
 846                 {
 847                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 848
 849                         goto RGXKickSyncCDM_exit;
 850                 }
 851         }
 852
 853                         /* Copy the data over */
 854                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->phClientUpdateUFOSyncPrimBlock, psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE))
 855                                 || (OSCopyFromUser(NULL, hClientUpdateUFOSyncPrimBlockInt2, psRGXKickSyncCDMIN->phClientUpdateUFOSyncPrimBlock,
 856                                 psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
 857                         {
 858                                 psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 859
 860                                 goto RGXKickSyncCDM_exit;
 861                         }
 862         if (psRGXKickSyncCDMIN->ui32ClientUpdateCount != 0)
 863         {
 864                 ui32ClientUpdateSyncOffsetInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32));
 865                 if (!ui32ClientUpdateSyncOffsetInt)
 866                 {
 867                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 868
 869                         goto RGXKickSyncCDM_exit;
 870                 }
 871         }
 872
 873                         /* Copy the data over */
 874                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->pui32ClientUpdateSyncOffset, psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32))
 875                                 || (OSCopyFromUser(NULL, ui32ClientUpdateSyncOffsetInt, psRGXKickSyncCDMIN->pui32ClientUpdateSyncOffset,
 876                                 psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 877                         {
 878                                 psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 879
 880                                 goto RGXKickSyncCDM_exit;
 881                         }
 882         if (psRGXKickSyncCDMIN->ui32ClientUpdateCount != 0)
 883         {
 884                 ui32ClientUpdateValueInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32));
 885                 if (!ui32ClientUpdateValueInt)
 886                 {
 887                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 888
 889                         goto RGXKickSyncCDM_exit;
 890                 }
 891         }
 892
 893                         /* Copy the data over */
 894                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->pui32ClientUpdateValue, psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32))
 895                                 || (OSCopyFromUser(NULL, ui32ClientUpdateValueInt, psRGXKickSyncCDMIN->pui32ClientUpdateValue,
 896                                 psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 897                         {
 898                                 psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 899
 900                                 goto RGXKickSyncCDM_exit;
 901                         }
 902         if (psRGXKickSyncCDMIN->ui32ServerSyncCount != 0)
 903         {
 904                 ui32ServerSyncFlagsInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32));
 905                 if (!ui32ServerSyncFlagsInt)
 906                 {
 907                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 908
 909                         goto RGXKickSyncCDM_exit;
 910                 }
 911         }
 912
 913                         /* Copy the data over */
 914                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->pui32ServerSyncFlags, psRGXKickSyncCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32))
 915                                 || (OSCopyFromUser(NULL, ui32ServerSyncFlagsInt, psRGXKickSyncCDMIN->pui32ServerSyncFlags,
 916                                 psRGXKickSyncCDMIN->ui32ServerSyncCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
 917                         {
 918                                 psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 919
 920                                 goto RGXKickSyncCDM_exit;
 921                         }
 922         if (psRGXKickSyncCDMIN->ui32ServerSyncCount != 0)
 923         {
 924                 psServerSyncsInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ServerSyncCount * sizeof(SERVER_SYNC_PRIMITIVE *));
 925                 if (!psServerSyncsInt)
 926                 {
 927                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 928
 929                         goto RGXKickSyncCDM_exit;
 930                 }
 931                 hServerSyncsInt2 = OSAllocMem(psRGXKickSyncCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE));
 932                 if (!hServerSyncsInt2)
 933                 {
 934                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 935
 936                         goto RGXKickSyncCDM_exit;
 937                 }
 938         }
 939
 940                         /* Copy the data over */
 941                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->phServerSyncs, psRGXKickSyncCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE))
 942                                 || (OSCopyFromUser(NULL, hServerSyncsInt2, psRGXKickSyncCDMIN->phServerSyncs,
 943                                 psRGXKickSyncCDMIN->ui32ServerSyncCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
 944                         {
 945                                 psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 946
 947                                 goto RGXKickSyncCDM_exit;
 948                         }
 949         if (psRGXKickSyncCDMIN->ui32NumFenceFDs != 0)
 950         {
 951                 i32FenceFDsInt = OSAllocMem(psRGXKickSyncCDMIN->ui32NumFenceFDs * sizeof(IMG_INT32));
 952                 if (!i32FenceFDsInt)
 953                 {
 954                         psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 955
 956                         goto RGXKickSyncCDM_exit;
 957                 }
 958         }
 959
 960                         /* Copy the data over */
 961                         if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->pi32FenceFDs, psRGXKickSyncCDMIN->ui32NumFenceFDs * sizeof(IMG_INT32))
 962                                 || (OSCopyFromUser(NULL, i32FenceFDsInt, psRGXKickSyncCDMIN->pi32FenceFDs,
 963                                 psRGXKickSyncCDMIN->ui32NumFenceFDs * sizeof(IMG_INT32)) != PVRSRV_OK) )
 964                         {
 965                                 psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
 966
 967                                 goto RGXKickSyncCDM_exit;
 968                         }
 969
 970                                 {
 971                                         /* Look up the address from the handle */
 972                                         psRGXKickSyncCDMOUT->eError =
 973                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
 974                                                                                         (IMG_HANDLE *) &hComputeContextInt2,
 975                                                                                         psRGXKickSyncCDMIN->hComputeContext,
 976                                                                                         PVRSRV_HANDLE_TYPE_RGX_SERVER_COMPUTE_CONTEXT);
 977                                         if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
 978                                         {
 979                                                 goto RGXKickSyncCDM_exit;
 980                                         }
 981
 982                                         /* Look up the data from the resman address */
 983                                         psRGXKickSyncCDMOUT->eError = ResManFindPrivateDataByPtr(hComputeContextInt2, (IMG_VOID **) &psComputeContextInt);
 984
 985                                         if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
 986                                         {
 987                                                 goto RGXKickSyncCDM_exit;
 988                                         }
 989                                 }
 990
 991         {
 992                 IMG_UINT32 i;
 993
 994                 for (i=0;i<psRGXKickSyncCDMIN->ui32ClientFenceCount;i++)
 995                 {
 996                                 {
 997                                         /* Look up the address from the handle */
 998                                         psRGXKickSyncCDMOUT->eError =
 999                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
1000                                                                                         (IMG_HANDLE *) &hClientFenceUFOSyncPrimBlockInt2[i],
1001                                                                                         hClientFenceUFOSyncPrimBlockInt2[i],
1002                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
1003                                         if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
1004                                         {
1005                                                 goto RGXKickSyncCDM_exit;
1006                                         }
1007
1008                                         /* Look up the data from the resman address */
1009                                         psRGXKickSyncCDMOUT->eError = ResManFindPrivateDataByPtr(hClientFenceUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientFenceUFOSyncPrimBlockInt[i]);
1010
1011                                         if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
1012                                         {
1013                                                 goto RGXKickSyncCDM_exit;
1014                                         }
1015                                 }
1016                 }
1017         }
1018
1019         {
1020                 IMG_UINT32 i;
1021
1022                 for (i=0;i<psRGXKickSyncCDMIN->ui32ClientUpdateCount;i++)
1023                 {
1024                                 {
1025                                         /* Look up the address from the handle */
1026                                         psRGXKickSyncCDMOUT->eError =
1027                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
1028                                                                                         (IMG_HANDLE *) &hClientUpdateUFOSyncPrimBlockInt2[i],
1029                                                                                         hClientUpdateUFOSyncPrimBlockInt2[i],
1030                                                                                         PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
1031                                         if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
1032                                         {
1033                                                 goto RGXKickSyncCDM_exit;
1034                                         }
1035
1036                                         /* Look up the data from the resman address */
1037                                         psRGXKickSyncCDMOUT->eError = ResManFindPrivateDataByPtr(hClientUpdateUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientUpdateUFOSyncPrimBlockInt[i]);
1038
1039                                         if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
1040                                         {
1041                                                 goto RGXKickSyncCDM_exit;
1042                                         }
1043                                 }
1044                 }
1045         }
1046
1047         {
1048                 IMG_UINT32 i;
1049
1050                 for (i=0;i<psRGXKickSyncCDMIN->ui32ServerSyncCount;i++)
1051                 {
1052                                 {
1053                                         /* Look up the address from the handle */
1054                                         psRGXKickSyncCDMOUT->eError =
1055                                                 PVRSRVLookupHandle(psConnection->psHandleBase,
1056                                                                                         (IMG_HANDLE *) &hServerSyncsInt2[i],
1057                                                                                         hServerSyncsInt2[i],
1058                                                                                         PVRSRV_HANDLE_TYPE_SERVER_SYNC_PRIMITIVE);
1059                                         if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
1060                                         {
1061                                                 goto RGXKickSyncCDM_exit;
1062                                         }
1063
1064                                         /* Look up the data from the resman address */
1065                                         psRGXKickSyncCDMOUT->eError = ResManFindPrivateDataByPtr(hServerSyncsInt2[i], (IMG_VOID **) &psServerSyncsInt[i]);
1066
1067                                         if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
1068                                         {
1069                                                 goto RGXKickSyncCDM_exit;
1070                                         }
1071                                 }
1072                 }
1073         }
1074
1075         psRGXKickSyncCDMOUT->eError =
1076                 PVRSRVRGXKickSyncCDMKM(
1077                                         psComputeContextInt,
1078                                         psRGXKickSyncCDMIN->ui32ClientFenceCount,
1079                                         psClientFenceUFOSyncPrimBlockInt,
1080                                         ui32ClientFenceSyncOffsetInt,
1081                                         ui32ClientFenceValueInt,
1082                                         psRGXKickSyncCDMIN->ui32ClientUpdateCount,
1083                                         psClientUpdateUFOSyncPrimBlockInt,
1084                                         ui32ClientUpdateSyncOffsetInt,
1085                                         ui32ClientUpdateValueInt,
1086                                         psRGXKickSyncCDMIN->ui32ServerSyncCount,
1087                                         ui32ServerSyncFlagsInt,
1088                                         psServerSyncsInt,
1089                                         psRGXKickSyncCDMIN->ui32NumFenceFDs,
1090                                         i32FenceFDsInt,
1091                                         psRGXKickSyncCDMIN->bbPDumpContinuous);
1092
1093
1094
1095 RGXKickSyncCDM_exit:
1096         if (psClientFenceUFOSyncPrimBlockInt)
1097                 OSFreeMem(psClientFenceUFOSyncPrimBlockInt);
1098         if (hClientFenceUFOSyncPrimBlockInt2)
1099                 OSFreeMem(hClientFenceUFOSyncPrimBlockInt2);
1100         if (ui32ClientFenceSyncOffsetInt)
1101                 OSFreeMem(ui32ClientFenceSyncOffsetInt);
1102         if (ui32ClientFenceValueInt)
1103                 OSFreeMem(ui32ClientFenceValueInt);
1104         if (psClientUpdateUFOSyncPrimBlockInt)
1105                 OSFreeMem(psClientUpdateUFOSyncPrimBlockInt);
1106         if (hClientUpdateUFOSyncPrimBlockInt2)
1107                 OSFreeMem(hClientUpdateUFOSyncPrimBlockInt2);
1108         if (ui32ClientUpdateSyncOffsetInt)
1109                 OSFreeMem(ui32ClientUpdateSyncOffsetInt);
1110         if (ui32ClientUpdateValueInt)
1111                 OSFreeMem(ui32ClientUpdateValueInt);
1112         if (ui32ServerSyncFlagsInt)
1113                 OSFreeMem(ui32ServerSyncFlagsInt);
1114         if (psServerSyncsInt)
1115                 OSFreeMem(psServerSyncsInt);
1116         if (hServerSyncsInt2)
1117                 OSFreeMem(hServerSyncsInt2);
1118         if (i32FenceFDsInt)
1119                 OSFreeMem(i32FenceFDsInt);
1120
1121         return 0;
1122 }
1123
1124
1125
1126 /* ***************************************************************************
1127  * Server bridge dispatch related glue
1128  */
1129
1130 PVRSRV_ERROR RegisterRGXCMPFunctions(IMG_VOID);
1131 IMG_VOID UnregisterRGXCMPFunctions(IMG_VOID);
1132
1133 /*
1134  * Register all RGXCMP functions with services
1135  */
1136 PVRSRV_ERROR RegisterRGXCMPFunctions(IMG_VOID)
1137 {
1138         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXCMP_RGXCREATECOMPUTECONTEXT, PVRSRVBridgeRGXCreateComputeContext);
1139         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXCMP_RGXDESTROYCOMPUTECONTEXT, PVRSRVBridgeRGXDestroyComputeContext);
1140         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXCMP_RGXKICKCDM, PVRSRVBridgeRGXKickCDM);
1141         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXCMP_RGXFLUSHCOMPUTEDATA, PVRSRVBridgeRGXFlushComputeData);
1142         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXCMP_RGXSETCOMPUTECONTEXTPRIORITY, PVRSRVBridgeRGXSetComputeContextPriority);
1143         SetDispatchTableEntry(PVRSRV_BRIDGE_RGXCMP_RGXKICKSYNCCDM, PVRSRVBridgeRGXKickSyncCDM);
1144
1145         return PVRSRV_OK;
1146 }
1147
1148 /*
1149  * Unregister all rgxcmp functions with services
1150  */
1151 IMG_VOID UnregisterRGXCMPFunctions(IMG_VOID)
1152 {
1153 }