pvr/bridged_pvr_bridge.c

   1 /**********************************************************************
   2  *
   3  * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful but, except
  10  * as otherwise stated in writing, without any warranty; without even the
  11  * implied warranty of merchantability or fitness for a particular purpose.
  12  * See the GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  17  *
  18  * The full GNU General Public License is included in this distribution in
  19  * the file called "COPYING".
  20  *
  21  * Contact Information:
  22  * Imagination Technologies Ltd. <gpl-support@imgtec.com>
  23  * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
  24  *
  25  ******************************************************************************/
  26
  27 #include <stddef.h>
  28
  29 #include "img_defs.h"
  30 #include "services.h"
  31 #include "pvr_bridge_km.h"
  32 #include "pvr_debug.h"
  33 #include "ra.h"
  34 #include "pvr_bridge.h"
  35 #include "sgx_bridge.h"
  36 #include "perproc.h"
  37 #include "device.h"
  38 #include "buffer_manager.h"
  39
  40 #include "pvr_pdump.h"
  41 #include "syscommon.h"
  42
  43 #include "bridged_pvr_bridge.h"
  44 #include "bridged_sgx_bridge.h"
  45 #include "env_data.h"
  46
  47 #include "mmap.h"
  48
  49 #include <linux/kernel.h>
  50 #include <linux/pagemap.h>      /* for cache flush */
  51 #include <linux/mm.h>
  52 #include <linux/sched.h>
  53
  54 struct PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY
  55     g_BridgeDispatchTable[BRIDGE_DISPATCH_TABLE_ENTRY_COUNT];
  56
  57 #if defined(DEBUG_BRIDGE_KM)
  58 struct PVRSRV_BRIDGE_GLOBAL_STATS g_BridgeGlobalStats;
  59 #endif
  60
  61 static IMG_BOOL abSharedDeviceMemHeap[PVRSRV_MAX_CLIENT_HEAPS];
  62 static IMG_BOOL *pbSharedDeviceMemHeap = abSharedDeviceMemHeap;
  63
  64 #if defined(DEBUG_BRIDGE_KM)
  65 enum PVRSRV_ERROR
  66 CopyFromUserWrapper(struct PVRSRV_PER_PROCESS_DATA *pProcData,
  67                     u32 ui32BridgeID, void *pvDest, void __user *pvSrc,
  68                     u32 ui32Size)
  69 {
  70         g_BridgeDispatchTable[ui32BridgeID].ui32CopyFromUserTotalBytes +=
  71             ui32Size;
  72         g_BridgeGlobalStats.ui32TotalCopyFromUserBytes += ui32Size;
  73         return OSCopyFromUser(pProcData, pvDest, pvSrc, ui32Size);
  74 }
  75
  76 enum PVRSRV_ERROR CopyToUserWrapper(struct PVRSRV_PER_PROCESS_DATA *pProcData,
  77                   u32 ui32BridgeID, void __user *pvDest, void *pvSrc,
  78                   u32 ui32Size)
  79 {
  80         g_BridgeDispatchTable[ui32BridgeID].ui32CopyToUserTotalBytes +=
  81             ui32Size;
  82         g_BridgeGlobalStats.ui32TotalCopyToUserBytes += ui32Size;
  83         return OSCopyToUser(pProcData, pvDest, pvSrc, ui32Size);
  84 }
  85 #endif
  86
  87 static int PVRSRVEnumerateDevicesBW(u32 ui32BridgeID, void *psBridgeIn,
  88                          struct PVRSRV_BRIDGE_OUT_ENUMDEVICE *psEnumDeviceOUT,
  89                          struct PVRSRV_PER_PROCESS_DATA *psPerProc)
  90 {
  91         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_DEVICES);
  92
  93         PVR_UNREFERENCED_PARAMETER(psPerProc);
  94         PVR_UNREFERENCED_PARAMETER(psBridgeIn);
  95
  96         psEnumDeviceOUT->eError =
  97             PVRSRVEnumerateDevicesKM(&psEnumDeviceOUT->ui32NumDevices,
  98                                      psEnumDeviceOUT->asDeviceIdentifier);
  99
 100         return 0;
 101 }
 102
 103 static int PVRSRVAcquireDeviceDataBW(u32 ui32BridgeID,
 104         struct PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO *psAcquireDevInfoIN,
 105         struct PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO *psAcquireDevInfoOUT,
 106         struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 107 {
 108         void *hDevCookieInt;
 109
 110         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
 111                                  PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO);
 112
 113         psAcquireDevInfoOUT->eError =
 114             PVRSRVAcquireDeviceDataKM(psAcquireDevInfoIN->uiDevIndex,
 115                                       psAcquireDevInfoIN->eDeviceType,
 116                                       &hDevCookieInt);
 117         if (psAcquireDevInfoOUT->eError != PVRSRV_OK)
 118                 return 0;
 119
 120         psAcquireDevInfoOUT->eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
 121                                               &psAcquireDevInfoOUT->hDevCookie,
 122                                               hDevCookieInt,
 123                                               PVRSRV_HANDLE_TYPE_DEV_NODE,
 124                                               PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
 125
 126         return 0;
 127 }
 128
 129 static int PVRSRVCreateDeviceMemContextBW(u32 ui32BridgeID,
 130        struct PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT *psCreateDevMemContextIN,
 131        struct PVRSRV_BRIDGE_OUT_CREATE_DEVMEMCONTEXT *psCreateDevMemContextOUT,
 132        struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 133 {
 134         void *hDevCookieInt;
 135         void *hDevMemContextInt;
 136         u32 i;
 137         IMG_BOOL bCreated;
 138
 139         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
 140                         PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT);
 141
 142         NEW_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError, psPerProc,
 143                         PVRSRV_MAX_CLIENT_HEAPS + 1);
 144
 145         psCreateDevMemContextOUT->eError = PVRSRVLookupHandle(
 146                                 psPerProc->psHandleBase, &hDevCookieInt,
 147                                 psCreateDevMemContextIN->hDevCookie,
 148                                 PVRSRV_HANDLE_TYPE_DEV_NODE);
 149
 150         if (psCreateDevMemContextOUT->eError != PVRSRV_OK)
 151                 return 0;
 152
 153         psCreateDevMemContextOUT->eError = PVRSRVCreateDeviceMemContextKM(
 154                                 hDevCookieInt, psPerProc,
 155                                 &hDevMemContextInt,
 156                                 &psCreateDevMemContextOUT->ui32ClientHeapCount,
 157                                 &psCreateDevMemContextOUT->sHeapInfo[0],
 158                                 &bCreated, pbSharedDeviceMemHeap);
 159
 160         if (psCreateDevMemContextOUT->eError != PVRSRV_OK)
 161                 return 0;
 162
 163         if (bCreated) {
 164                 PVRSRVAllocHandleNR(psPerProc->psHandleBase,
 165                                 &psCreateDevMemContextOUT->hDevMemContext,
 166                                 hDevMemContextInt,
 167                                 PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT,
 168                                 PVRSRV_HANDLE_ALLOC_FLAG_NONE);
 169         } else {
 170                 psCreateDevMemContextOUT->eError =
 171                         PVRSRVFindHandle(psPerProc->psHandleBase,
 172                                 &psCreateDevMemContextOUT->hDevMemContext,
 173                                 hDevMemContextInt,
 174                                 PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
 175                 if (psCreateDevMemContextOUT->eError != PVRSRV_OK)
 176                         return 0;
 177         }
 178
 179         for (i = 0; i < psCreateDevMemContextOUT->ui32ClientHeapCount; i++) {
 180                 void *hDevMemHeapExt;
 181
 182                 if (abSharedDeviceMemHeap[i]) {
 183                         PVRSRVAllocHandleNR(psPerProc->psHandleBase,
 184                                         &hDevMemHeapExt,
 185                                         psCreateDevMemContextOUT->
 186                                         sHeapInfo[i].hDevMemHeap,
 187                                         PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
 188                                         PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
 189                 } else {
 190                         if (bCreated) {
 191                                 PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
 192                                         &hDevMemHeapExt,
 193                                         psCreateDevMemContextOUT->sHeapInfo[i].
 194                                                                 hDevMemHeap,
 195                                         PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
 196                                         PVRSRV_HANDLE_ALLOC_FLAG_NONE,
 197                                         psCreateDevMemContextOUT->
 198                                                                 hDevMemContext);
 199                         } else {
 200                                 psCreateDevMemContextOUT->eError =
 201                                         PVRSRVFindHandle(
 202                                             psPerProc->psHandleBase,
 203                                             &hDevMemHeapExt,
 204                                             psCreateDevMemContextOUT->
 205                                             sHeapInfo[i].hDevMemHeap,
 206                                             PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
 207                                 if (psCreateDevMemContextOUT->eError !=
 208                                                 PVRSRV_OK)
 209                                         return 0;
 210                         }
 211                 }
 212                 psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap =
 213                                                                 hDevMemHeapExt;
 214         }
 215
 216         COMMIT_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError,
 217                                                                 psPerProc);
 218
 219         return 0;
 220 }
 221
 222 static int PVRSRVDestroyDeviceMemContextBW(u32 ui32BridgeID,
 223         struct PVRSRV_BRIDGE_IN_DESTROY_DEVMEMCONTEXT *psDestroyDevMemContextIN,
 224         struct PVRSRV_BRIDGE_RETURN *psRetOUT,
 225         struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 226 {
 227         void *hDevCookieInt;
 228         void *hDevMemContextInt;
 229         IMG_BOOL bDestroyed;
 230
 231         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
 232                         PVRSRV_BRIDGE_DESTROY_DEVMEMCONTEXT);
 233
 234         psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
 235                                 &hDevCookieInt,
 236                                 psDestroyDevMemContextIN->hDevCookie,
 237                                 PVRSRV_HANDLE_TYPE_DEV_NODE);
 238
 239         if (psRetOUT->eError != PVRSRV_OK)
 240                 return 0;
 241
 242         psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
 243                                 &hDevMemContextInt,
 244                                 psDestroyDevMemContextIN->hDevMemContext,
 245                                 PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
 246
 247         if (psRetOUT->eError != PVRSRV_OK)
 248                 return 0;
 249
 250         psRetOUT->eError = PVRSRVDestroyDeviceMemContextKM(hDevCookieInt,
 251                                                 hDevMemContextInt, &bDestroyed);
 252
 253         if (psRetOUT->eError != PVRSRV_OK)
 254                 return 0;
 255
 256         if (bDestroyed)
 257                 psRetOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
 258                                         psDestroyDevMemContextIN->
 259                                         hDevMemContext,
 260                                         PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
 261
 262         return 0;
 263 }
 264
 265 static int PVRSRVGetDeviceMemHeapInfoBW(u32 ui32BridgeID,
 266            struct PVRSRV_BRIDGE_IN_GET_DEVMEM_HEAPINFO *psGetDevMemHeapInfoIN,
 267            struct PVRSRV_BRIDGE_OUT_GET_DEVMEM_HEAPINFO *psGetDevMemHeapInfoOUT,
 268            struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 269 {
 270         void *hDevCookieInt;
 271         void *hDevMemContextInt;
 272         u32 i;
 273
 274         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
 275                                  PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO);
 276
 277         NEW_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc,
 278                                   PVRSRV_MAX_CLIENT_HEAPS);
 279
 280         psGetDevMemHeapInfoOUT->eError =
 281             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
 282                                psGetDevMemHeapInfoIN->hDevCookie,
 283                                PVRSRV_HANDLE_TYPE_DEV_NODE);
 284
 285         if (psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
 286                 return 0;
 287
 288         psGetDevMemHeapInfoOUT->eError =
 289             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
 290                                psGetDevMemHeapInfoIN->hDevMemContext,
 291                                PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
 292
 293         if (psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
 294                 return 0;
 295
 296         psGetDevMemHeapInfoOUT->eError =
 297             PVRSRVGetDeviceMemHeapInfoKM(hDevCookieInt,
 298                                  hDevMemContextInt,
 299                                  &psGetDevMemHeapInfoOUT->ui32ClientHeapCount,
 300                                  &psGetDevMemHeapInfoOUT->sHeapInfo[0],
 301                                          pbSharedDeviceMemHeap);
 302
 303         if (psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
 304                 return 0;
 305
 306         for (i = 0; i < psGetDevMemHeapInfoOUT->ui32ClientHeapCount; i++) {
 307                 void *hDevMemHeapExt;
 308                 if (abSharedDeviceMemHeap[i]) {
 309                         PVRSRVAllocHandleNR(psPerProc->psHandleBase,
 310                                &hDevMemHeapExt,
 311                                psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap,
 312                                PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
 313                                PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
 314                 } else {
 315                         psGetDevMemHeapInfoOUT->eError =
 316                             PVRSRVFindHandle(psPerProc->psHandleBase,
 317                                              &hDevMemHeapExt,
 318                                              psGetDevMemHeapInfoOUT->
 319                                              sHeapInfo[i].hDevMemHeap,
 320                                              PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
 321                         if (psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
 322                                 return 0;
 323                 }
 324                 psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap =
 325                     hDevMemHeapExt;
 326         }
 327
 328         COMMIT_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc);
 329
 330         return 0;
 331 }
 332
 333 static int PVRSRVAllocDeviceMemBW(u32 ui32BridgeID,
 334                struct PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM *psAllocDeviceMemIN,
 335                struct PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM *psAllocDeviceMemOUT,
 336                struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 337 {
 338         struct PVRSRV_KERNEL_MEM_INFO *psMemInfo;
 339         void *hDevCookieInt;
 340         void *hDevMemHeapInt;
 341
 342         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ALLOC_DEVICEMEM);
 343
 344         NEW_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc, 2);
 345
 346         psAllocDeviceMemOUT->eError =
 347             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
 348                                psAllocDeviceMemIN->hDevCookie,
 349                                PVRSRV_HANDLE_TYPE_DEV_NODE);
 350
 351         if (psAllocDeviceMemOUT->eError != PVRSRV_OK)
 352                 return 0;
 353
 354         psAllocDeviceMemOUT->eError =
 355             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemHeapInt,
 356                                psAllocDeviceMemIN->hDevMemHeap,
 357                                PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
 358
 359         if (psAllocDeviceMemOUT->eError != PVRSRV_OK)
 360                 return 0;
 361
 362         psAllocDeviceMemOUT->eError =
 363             PVRSRVAllocDeviceMemKM(hDevCookieInt, psPerProc, hDevMemHeapInt,
 364                                    psAllocDeviceMemIN->ui32Attribs,
 365                                    psAllocDeviceMemIN->ui32Size,
 366                                    psAllocDeviceMemIN->ui32Alignment,
 367                                    &psMemInfo);
 368
 369         if (psAllocDeviceMemOUT->eError != PVRSRV_OK)
 370                 return 0;
 371
 372         OSMemSet(&psAllocDeviceMemOUT->sClientMemInfo, 0,
 373                  sizeof(psAllocDeviceMemOUT->sClientMemInfo));
 374
 375         psAllocDeviceMemOUT->sClientMemInfo.pvLinAddrKM =
 376                     psMemInfo->pvLinAddrKM;
 377
 378         psAllocDeviceMemOUT->sClientMemInfo.pvLinAddr = NULL;
 379         psAllocDeviceMemOUT->sClientMemInfo.sDevVAddr = psMemInfo->sDevVAddr;
 380         psAllocDeviceMemOUT->sClientMemInfo.ui32Flags = psMemInfo->ui32Flags;
 381         psAllocDeviceMemOUT->sClientMemInfo.ui32AllocSize =
 382                                                     psMemInfo->ui32AllocSize;
 383         psAllocDeviceMemOUT->sClientMemInfo.hMappingInfo =
 384                                             psMemInfo->sMemBlk.hOSMemHandle;
 385
 386         PVRSRVAllocHandleNR(psPerProc->psHandleBase,
 387                             &psAllocDeviceMemOUT->sClientMemInfo.hKernelMemInfo,
 388                             psMemInfo,
 389                             PVRSRV_HANDLE_TYPE_MEM_INFO,
 390                             PVRSRV_HANDLE_ALLOC_FLAG_NONE);
 391
 392         if (psAllocDeviceMemIN->ui32Attribs & PVRSRV_MEM_NO_SYNCOBJ) {
 393                 OSMemSet(&psAllocDeviceMemOUT->sClientSyncInfo, 0,
 394                          sizeof(struct PVRSRV_CLIENT_SYNC_INFO));
 395                 psAllocDeviceMemOUT->sClientMemInfo.psClientSyncInfo = NULL;
 396                 psAllocDeviceMemOUT->psKernelSyncInfo = NULL;
 397         } else {
 398
 399                 psAllocDeviceMemOUT->psKernelSyncInfo =
 400                                             psMemInfo->psKernelSyncInfo;
 401
 402                 psAllocDeviceMemOUT->sClientSyncInfo.psSyncData =
 403                     psMemInfo->psKernelSyncInfo->psSyncData;
 404                 psAllocDeviceMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
 405                     psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
 406                 psAllocDeviceMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
 407                     psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
 408
 409                 psAllocDeviceMemOUT->sClientSyncInfo.hMappingInfo =
 410                     psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.
 411                                                                 hOSMemHandle;
 412
 413                 PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
 414                                        &psAllocDeviceMemOUT->sClientSyncInfo.
 415                                        hKernelSyncInfo,
 416                                        psMemInfo->psKernelSyncInfo,
 417                                        PVRSRV_HANDLE_TYPE_SYNC_INFO,
 418                                        PVRSRV_HANDLE_ALLOC_FLAG_NONE,
 419                                        psAllocDeviceMemOUT->sClientMemInfo.
 420                                        hKernelMemInfo);
 421
 422                 psAllocDeviceMemOUT->sClientMemInfo.psClientSyncInfo =
 423                     &psAllocDeviceMemOUT->sClientSyncInfo;
 424
 425         }
 426
 427         COMMIT_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc);
 428
 429         return 0;
 430 }
 431
 432
 433 static int PVRSRVFreeDeviceMemBW(u32 ui32BridgeID,
 434                       struct PVRSRV_BRIDGE_IN_FREEDEVICEMEM *psFreeDeviceMemIN,
 435                       struct PVRSRV_BRIDGE_RETURN *psRetOUT,
 436                       struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 437 {
 438         void *hDevCookieInt;
 439         void *pvKernelMemInfo;
 440         struct PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
 441
 442         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_FREE_DEVICEMEM);
 443
 444         psRetOUT->eError =
 445             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
 446                                psFreeDeviceMemIN->hDevCookie,
 447                                PVRSRV_HANDLE_TYPE_DEV_NODE);
 448
 449         if (psRetOUT->eError != PVRSRV_OK)
 450                 return 0;
 451
 452         psRetOUT->eError =
 453             PVRSRVLookupHandle(psPerProc->psHandleBase, &pvKernelMemInfo,
 454                                psFreeDeviceMemIN->psKernelMemInfo,
 455                                PVRSRV_HANDLE_TYPE_MEM_INFO);
 456
 457         if (psRetOUT->eError != PVRSRV_OK)
 458                 return 0;
 459
 460         psKernelMemInfo = (struct PVRSRV_KERNEL_MEM_INFO *)pvKernelMemInfo;
 461         if (psKernelMemInfo->ui32RefCount != 1) {
 462                 PVR_DPF(PVR_DBG_ERROR, "PVRSRVFreeDeviceMemBW: "
 463                                         "mappings are open in other processes");
 464                 psRetOUT->eError = PVRSRV_ERROR_GENERIC;
 465                 return 0;
 466         }
 467
 468         psRetOUT->eError = PVRSRVFreeDeviceMemKM(hDevCookieInt,
 469                                                  pvKernelMemInfo);
 470
 471         if (psRetOUT->eError != PVRSRV_OK)
 472                 return 0;
 473
 474         psRetOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
 475                                         psFreeDeviceMemIN->psKernelMemInfo,
 476                                         PVRSRV_HANDLE_TYPE_MEM_INFO);
 477
 478         return 0;
 479 }
 480
 481 static int PVRSRVExportDeviceMemBW(u32 ui32BridgeID,
 482            struct PVRSRV_BRIDGE_IN_EXPORTDEVICEMEM *psExportDeviceMemIN,
 483            struct PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *psExportDeviceMemOUT,
 484            struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 485 {
 486         void *hDevCookieInt;
 487         struct PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
 488
 489         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EXPORT_DEVICEMEM);
 490
 491         psExportDeviceMemOUT->eError =
 492             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
 493                                psExportDeviceMemIN->hDevCookie,
 494                                PVRSRV_HANDLE_TYPE_DEV_NODE);
 495
 496         if (psExportDeviceMemOUT->eError != PVRSRV_OK) {
 497                 PVR_DPF(PVR_DBG_ERROR,
 498                          "PVRSRVExportDeviceMemBW: can't find devcookie");
 499                 return 0;
 500         }
 501
 502         psExportDeviceMemOUT->eError =
 503             PVRSRVLookupHandle(psPerProc->psHandleBase,
 504                                (void **)&psKernelMemInfo,
 505                                psExportDeviceMemIN->psKernelMemInfo,
 506                                PVRSRV_HANDLE_TYPE_MEM_INFO);
 507
 508         if (psExportDeviceMemOUT->eError != PVRSRV_OK) {
 509                 PVR_DPF(PVR_DBG_ERROR,
 510                          "PVRSRVExportDeviceMemBW: can't find kernel meminfo");
 511                 return 0;
 512         }
 513
 514         psExportDeviceMemOUT->eError =
 515             PVRSRVFindHandle(KERNEL_HANDLE_BASE,
 516                              &psExportDeviceMemOUT->hMemInfo,
 517                              psKernelMemInfo, PVRSRV_HANDLE_TYPE_MEM_INFO);
 518         if (psExportDeviceMemOUT->eError == PVRSRV_OK) {
 519                 PVR_DPF(PVR_DBG_MESSAGE, "PVRSRVExportDeviceMemBW: "
 520                                           "allocation is already exported");
 521                 return 0;
 522         }
 523
 524         psExportDeviceMemOUT->eError = PVRSRVAllocHandle(KERNEL_HANDLE_BASE,
 525                                          &psExportDeviceMemOUT->hMemInfo,
 526                                          psKernelMemInfo,
 527                                          PVRSRV_HANDLE_TYPE_MEM_INFO,
 528                                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
 529         if (psExportDeviceMemOUT->eError != PVRSRV_OK) {
 530                 PVR_DPF(PVR_DBG_ERROR, "PVRSRVExportDeviceMemBW: "
 531                         "failed to allocate handle from global handle list");
 532                 return 0;
 533         }
 534
 535         psKernelMemInfo->ui32Flags |= PVRSRV_MEM_EXPORTED;
 536
 537         return 0;
 538 }
 539
 540 static int PVRSRVMapDeviceMemoryBW(u32 ui32BridgeID,
 541                         struct PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *psMapDevMemIN,
 542                         struct PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *psMapDevMemOUT,
 543                         struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 544 {
 545         struct PVRSRV_KERNEL_MEM_INFO *psSrcKernelMemInfo = NULL;
 546         struct PVRSRV_KERNEL_MEM_INFO *psDstKernelMemInfo = NULL;
 547         void *hDstDevMemHeap = NULL;
 548
 549         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_DEV_MEMORY);
 550
 551         NEW_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc, 2);
 552
 553         psMapDevMemOUT->eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
 554                                             (void **)&psSrcKernelMemInfo,
 555                                             psMapDevMemIN->hKernelMemInfo,
 556                                             PVRSRV_HANDLE_TYPE_MEM_INFO);
 557         if (psMapDevMemOUT->eError != PVRSRV_OK)
 558                 return 0;
 559
 560         psMapDevMemOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
 561                                             &hDstDevMemHeap,
 562                                             psMapDevMemIN->hDstDevMemHeap,
 563                                             PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
 564         if (psMapDevMemOUT->eError != PVRSRV_OK)
 565                 return 0;
 566
 567         psMapDevMemOUT->eError = PVRSRVMapDeviceMemoryKM(psPerProc,
 568                                                          psSrcKernelMemInfo,
 569                                                          hDstDevMemHeap,
 570                                                          &psDstKernelMemInfo);
 571         if (psMapDevMemOUT->eError != PVRSRV_OK)
 572                 return 0;
 573
 574         OSMemSet(&psMapDevMemOUT->sDstClientMemInfo, 0,
 575                  sizeof(psMapDevMemOUT->sDstClientMemInfo));
 576         OSMemSet(&psMapDevMemOUT->sDstClientSyncInfo, 0,
 577                  sizeof(psMapDevMemOUT->sDstClientSyncInfo));
 578
 579         psMapDevMemOUT->sDstClientMemInfo.pvLinAddrKM =
 580                                     psDstKernelMemInfo->pvLinAddrKM;
 581
 582         psMapDevMemOUT->sDstClientMemInfo.pvLinAddr = NULL;
 583         psMapDevMemOUT->sDstClientMemInfo.sDevVAddr =
 584                                     psDstKernelMemInfo->sDevVAddr;
 585         psMapDevMemOUT->sDstClientMemInfo.ui32Flags =
 586                                     psDstKernelMemInfo->ui32Flags;
 587         psMapDevMemOUT->sDstClientMemInfo.ui32AllocSize =
 588                                     psDstKernelMemInfo->ui32AllocSize;
 589         psMapDevMemOUT->sDstClientMemInfo.hMappingInfo =
 590                                     psDstKernelMemInfo->sMemBlk.hOSMemHandle;
 591
 592         PVRSRVAllocHandleNR(psPerProc->psHandleBase,
 593                             &psMapDevMemOUT->sDstClientMemInfo.hKernelMemInfo,
 594                             psDstKernelMemInfo,
 595                             PVRSRV_HANDLE_TYPE_MEM_INFO,
 596                             PVRSRV_HANDLE_ALLOC_FLAG_NONE);
 597         psMapDevMemOUT->sDstClientSyncInfo.hKernelSyncInfo = NULL;
 598         psMapDevMemOUT->psDstKernelSyncInfo = NULL;
 599
 600         if (psDstKernelMemInfo->psKernelSyncInfo) {
 601                 psMapDevMemOUT->psDstKernelSyncInfo =
 602                     psDstKernelMemInfo->psKernelSyncInfo;
 603
 604                 psMapDevMemOUT->sDstClientSyncInfo.psSyncData =
 605                     psDstKernelMemInfo->psKernelSyncInfo->psSyncData;
 606                 psMapDevMemOUT->sDstClientSyncInfo.sWriteOpsCompleteDevVAddr =
 607                     psDstKernelMemInfo->psKernelSyncInfo->
 608                                                     sWriteOpsCompleteDevVAddr;
 609                 psMapDevMemOUT->sDstClientSyncInfo.sReadOpsCompleteDevVAddr =
 610                     psDstKernelMemInfo->psKernelSyncInfo->
 611                                                     sReadOpsCompleteDevVAddr;
 612
 613                 psMapDevMemOUT->sDstClientSyncInfo.hMappingInfo =
 614                     psDstKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->
 615                                                     sMemBlk.hOSMemHandle;
 616
 617                 psMapDevMemOUT->sDstClientMemInfo.psClientSyncInfo =
 618                     &psMapDevMemOUT->sDstClientSyncInfo;
 619
 620                 PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
 621                                        &psMapDevMemOUT->sDstClientSyncInfo.
 622                                                                 hKernelSyncInfo,
 623                                        psDstKernelMemInfo->psKernelSyncInfo,
 624                                        PVRSRV_HANDLE_TYPE_SYNC_INFO,
 625                                        PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
 626                                        psMapDevMemOUT->sDstClientMemInfo.
 627                                                                hKernelMemInfo);
 628         }
 629
 630         COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc);
 631
 632         return 0;
 633 }
 634
 635 static int PVRSRVUnmapDeviceMemoryBW(u32 ui32BridgeID,
 636                   struct PVRSRV_BRIDGE_IN_UNMAP_DEV_MEMORY *psUnmapDevMemIN,
 637                   struct PVRSRV_BRIDGE_RETURN *psRetOUT,
 638                   struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 639 {
 640         struct PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = NULL;
 641
 642         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_UNMAP_DEV_MEMORY);
 643
 644         psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
 645                                               (void **) &psKernelMemInfo,
 646                                               psUnmapDevMemIN->psKernelMemInfo,
 647                                               PVRSRV_HANDLE_TYPE_MEM_INFO);
 648         if (psRetOUT->eError != PVRSRV_OK)
 649                 return 0;
 650
 651         psRetOUT->eError = PVRSRVUnmapDeviceMemoryKM(psKernelMemInfo);
 652         if (psRetOUT->eError != PVRSRV_OK)
 653                 return 0;
 654
 655         psRetOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
 656                                                psUnmapDevMemIN->psKernelMemInfo,
 657                                                PVRSRV_HANDLE_TYPE_MEM_INFO);
 658
 659         return 0;
 660 }
 661
 662 static int FlushCacheDRI(u32 ui32Type, u32 ui32Virt, u32 ui32Length)
 663 {
 664         switch (ui32Type) {
 665         case DRM_PVR2D_CFLUSH_FROM_GPU:
 666                 PVR_DPF(PVR_DBG_MESSAGE,
 667                          "DRM_PVR2D_CFLUSH_FROM_GPU 0x%08x, length 0x%08x\n",
 668                          ui32Virt, ui32Length);
 669 #ifdef CONFIG_ARM
 670                 dmac_map_area((const void *)ui32Virt, ui32Length, DMA_FROM_DEVICE);
 671 #endif
 672                 return 0;
 673         case DRM_PVR2D_CFLUSH_TO_GPU:
 674                 PVR_DPF(PVR_DBG_MESSAGE,
 675                          "DRM_PVR2D_CFLUSH_TO_GPU 0x%08x, length 0x%08x\n",
 676                          ui32Virt, ui32Length);
 677 #ifdef CONFIG_ARM
 678                 dmac_map_area((const void *)ui32Virt, ui32Length, DMA_TO_DEVICE);
 679 #endif
 680                 return 0;
 681         default:
 682                 PVR_DPF(PVR_DBG_ERROR, "Invalid cflush type 0x%x\n",
 683                          ui32Type);
 684                 return -EINVAL;
 685         }
 686
 687         return 0;
 688 }
 689
 690 static int PVRSRVCacheFlushDRIBW(u32 ui32BridgeID,
 691               struct PVRSRV_BRIDGE_IN_CACHEFLUSHDRMFROMUSER *psCacheFlushIN,
 692               struct PVRSRV_BRIDGE_RETURN *psRetOUT,
 693               struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 694 {
 695         struct vm_area_struct *vma;
 696         unsigned long start;
 697         size_t len;
 698         int type;
 699         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CACHE_FLUSH_DRM);
 700
 701         start = psCacheFlushIN->ui32Virt;
 702         len = psCacheFlushIN->ui32Length;
 703         type = psCacheFlushIN->ui32Type;
 704
 705         down_read(&current->mm->mmap_sem);
 706         vma = find_vma(current->mm, start);
 707         if (vma == NULL || vma->vm_start > start ||
 708             vma->vm_end < start + len)
 709                 pr_err("PVR: %s: invalid address %08lx %zu %c\n",
 710                                 __func__, start, len,
 711                                 type == DRM_PVR2D_CFLUSH_TO_GPU ? 'c' :
 712                                 type == DRM_PVR2D_CFLUSH_FROM_GPU ? 'i' :
 713                                 '?');
 714         else
 715                 psRetOUT->eError = FlushCacheDRI(type, start, len);
 716
 717         up_read(&current->mm->mmap_sem);
 718
 719         return 0;
 720 }
 721
 722 static int PVRSRVMapDeviceClassMemoryBW(u32 ui32BridgeID,
 723            struct PVRSRV_BRIDGE_IN_MAP_DEVICECLASS_MEMORY *psMapDevClassMemIN,
 724            struct PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *psMapDevClassMemOUT,
 725            struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 726 {
 727         struct PVRSRV_KERNEL_MEM_INFO *psMemInfo;
 728         void *hOSMapInfo;
 729         void *hDeviceClassBufferInt;
 730         void *hDevMemContextInt;
 731         enum PVRSRV_HANDLE_TYPE eHandleType;
 732
 733         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
 734                         PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY);
 735
 736         NEW_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc, 2);
 737
 738         psMapDevClassMemOUT->eError =
 739                 PVRSRVLookupHandleAnyType(psPerProc->psHandleBase,
 740                                 &hDeviceClassBufferInt, &eHandleType,
 741                                 psMapDevClassMemIN->hDeviceClassBuffer);
 742
 743         if (psMapDevClassMemOUT->eError != PVRSRV_OK)
 744                 return 0;
 745
 746         psMapDevClassMemOUT->eError =
 747             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
 748                                psMapDevClassMemIN->hDevMemContext,
 749                                PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
 750
 751         if (psMapDevClassMemOUT->eError != PVRSRV_OK)
 752                 return 0;
 753
 754         switch (eHandleType) {
 755         case PVRSRV_HANDLE_TYPE_DISP_BUFFER:
 756         case PVRSRV_HANDLE_TYPE_BUF_BUFFER:
 757                 break;
 758         default:
 759                 psMapDevClassMemOUT->eError = PVRSRV_ERROR_GENERIC;
 760                 return 0;
 761         }
 762
 763         psMapDevClassMemOUT->eError =
 764                 PVRSRVMapDeviceClassMemoryKM(psPerProc, hDevMemContextInt,
 765                                 hDeviceClassBufferInt, &psMemInfo, &hOSMapInfo);
 766
 767         if (psMapDevClassMemOUT->eError != PVRSRV_OK)
 768                 return 0;
 769
 770         OSMemSet(&psMapDevClassMemOUT->sClientMemInfo, 0,
 771                  sizeof(psMapDevClassMemOUT->sClientMemInfo));
 772         OSMemSet(&psMapDevClassMemOUT->sClientSyncInfo, 0,
 773                  sizeof(psMapDevClassMemOUT->sClientSyncInfo));
 774
 775         psMapDevClassMemOUT->sClientMemInfo.pvLinAddrKM =
 776                                                 psMemInfo->pvLinAddrKM;
 777
 778         psMapDevClassMemOUT->sClientMemInfo.pvLinAddr = NULL;
 779         psMapDevClassMemOUT->sClientMemInfo.sDevVAddr = psMemInfo->sDevVAddr;
 780         psMapDevClassMemOUT->sClientMemInfo.ui32Flags = psMemInfo->ui32Flags;
 781         psMapDevClassMemOUT->sClientMemInfo.ui32AllocSize =
 782                                                 psMemInfo->ui32AllocSize;
 783         psMapDevClassMemOUT->sClientMemInfo.hMappingInfo =
 784                                                 psMemInfo->sMemBlk.hOSMemHandle;
 785
 786         PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
 787                         &psMapDevClassMemOUT->sClientMemInfo.hKernelMemInfo,
 788                         psMemInfo,
 789                         PVRSRV_HANDLE_TYPE_MEM_INFO,
 790                         PVRSRV_HANDLE_ALLOC_FLAG_NONE,
 791                         psMapDevClassMemIN->hDeviceClassBuffer);
 792
 793         psMapDevClassMemOUT->sClientSyncInfo.hKernelSyncInfo = NULL;
 794         psMapDevClassMemOUT->psKernelSyncInfo = NULL;
 795
 796         if (psMemInfo->psKernelSyncInfo) {
 797                 psMapDevClassMemOUT->psKernelSyncInfo =
 798                         psMemInfo->psKernelSyncInfo;
 799
 800                 psMapDevClassMemOUT->sClientSyncInfo.psSyncData =
 801                         psMemInfo->psKernelSyncInfo->psSyncData;
 802                 psMapDevClassMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
 803                         psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
 804                 psMapDevClassMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
 805                         psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
 806
 807                 psMapDevClassMemOUT->sClientSyncInfo.hMappingInfo =
 808                                 psMemInfo->psKernelSyncInfo->
 809                                      psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
 810
 811                 psMapDevClassMemOUT->sClientMemInfo.psClientSyncInfo =
 812                         &psMapDevClassMemOUT->sClientSyncInfo;
 813
 814                 PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
 815                                 &psMapDevClassMemOUT->sClientSyncInfo.
 816                                                                 hKernelSyncInfo,
 817                                 psMemInfo->psKernelSyncInfo,
 818                                 PVRSRV_HANDLE_TYPE_SYNC_INFO,
 819                                 PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
 820                                 psMapDevClassMemOUT->sClientMemInfo.
 821                                                                 hKernelMemInfo);
 822         }
 823
 824         COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc);
 825
 826         return 0;
 827 }
 828
 829 static int PVRSRVUnmapDeviceClassMemoryBW(u32 ui32BridgeID,
 830          struct PVRSRV_BRIDGE_IN_UNMAP_DEVICECLASS_MEMORY *psUnmapDevClassMemIN,
 831          struct PVRSRV_BRIDGE_RETURN *psRetOUT,
 832          struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 833 {
 834         void *pvKernelMemInfo;
 835
 836         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
 837                                  PVRSRV_BRIDGE_UNMAP_DEVICECLASS_MEMORY);
 838
 839         psRetOUT->eError =
 840             PVRSRVLookupHandle(psPerProc->psHandleBase, &pvKernelMemInfo,
 841                                psUnmapDevClassMemIN->psKernelMemInfo,
 842                                PVRSRV_HANDLE_TYPE_MEM_INFO);
 843         if (psRetOUT->eError != PVRSRV_OK)
 844                 return 0;
 845
 846         psRetOUT->eError = PVRSRVUnmapDeviceClassMemoryKM(pvKernelMemInfo);
 847
 848         if (psRetOUT->eError != PVRSRV_OK)
 849                 return 0;
 850
 851         psRetOUT->eError =
 852             PVRSRVReleaseHandle(psPerProc->psHandleBase,
 853                                 psUnmapDevClassMemIN->psKernelMemInfo,
 854                                 PVRSRV_HANDLE_TYPE_MEM_INFO);
 855
 856         return 0;
 857 }
 858
 859 static int PVRSRVWrapExtMemoryBW(u32 ui32BridgeID,
 860                       struct PVRSRV_BRIDGE_IN_WRAP_EXT_MEMORY *psWrapExtMemIN,
 861                       struct PVRSRV_BRIDGE_OUT_WRAP_EXT_MEMORY *psWrapExtMemOUT,
 862                       struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 863 {
 864         void *hDevCookieInt;
 865         void *hDevMemContextInt;
 866         struct PVRSRV_KERNEL_MEM_INFO *psMemInfo;
 867         u32 ui32PageTableSize = 0;
 868         struct IMG_SYS_PHYADDR *psSysPAddr = NULL;
 869
 870         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_WRAP_EXT_MEMORY);
 871
 872         NEW_HANDLE_BATCH_OR_ERROR(psWrapExtMemOUT->eError, psPerProc, 2);
 873
 874         psWrapExtMemOUT->eError =
 875             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
 876                                psWrapExtMemIN->hDevCookie,
 877                                PVRSRV_HANDLE_TYPE_DEV_NODE);
 878         if (psWrapExtMemOUT->eError != PVRSRV_OK)
 879                 return 0;
 880
 881         psWrapExtMemOUT->eError =
 882             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
 883                                psWrapExtMemIN->hDevMemContext,
 884                                PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
 885
 886         if (psWrapExtMemOUT->eError != PVRSRV_OK)
 887                 return 0;
 888
 889         if (psWrapExtMemIN->ui32NumPageTableEntries) {
 890                 ui32PageTableSize = psWrapExtMemIN->ui32NumPageTableEntries
 891                     * sizeof(struct IMG_SYS_PHYADDR);
 892
 893                 ASSIGN_AND_EXIT_ON_ERROR(psWrapExtMemOUT->eError,
 894                                          OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
 895                                                    ui32PageTableSize,
 896                                                    (void **)&psSysPAddr, NULL));
 897
 898                 if (CopyFromUserWrapper(psPerProc, ui32BridgeID, psSysPAddr,
 899                                         psWrapExtMemIN->psSysPAddr,
 900                                         ui32PageTableSize) != PVRSRV_OK) {
 901                         OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32PageTableSize,
 902                                   (void *) psSysPAddr, NULL);
 903                         return -EFAULT;
 904                 }
 905         }
 906
 907         psWrapExtMemOUT->eError = PVRSRVWrapExtMemoryKM(hDevCookieInt,
 908                                   psPerProc, hDevMemContextInt,
 909                                   psWrapExtMemIN->ui32ByteSize,
 910                                   psWrapExtMemIN->ui32PageOffset,
 911                                   psWrapExtMemIN->bPhysContig,
 912                                   psSysPAddr, psWrapExtMemIN->pvLinAddr,
 913                                   &psMemInfo);
 914         if (psWrapExtMemIN->ui32NumPageTableEntries)
 915                 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, ui32PageTableSize,
 916                           (void *)psSysPAddr, NULL);
 917         if (psWrapExtMemOUT->eError != PVRSRV_OK)
 918                 return 0;
 919
 920         psWrapExtMemOUT->sClientMemInfo.pvLinAddrKM = psMemInfo->pvLinAddrKM;
 921
 922         psWrapExtMemOUT->sClientMemInfo.pvLinAddr = NULL;
 923         psWrapExtMemOUT->sClientMemInfo.sDevVAddr = psMemInfo->sDevVAddr;
 924         psWrapExtMemOUT->sClientMemInfo.ui32Flags = psMemInfo->ui32Flags;
 925         psWrapExtMemOUT->sClientMemInfo.ui32AllocSize =
 926                                                     psMemInfo->ui32AllocSize;
 927         psWrapExtMemOUT->sClientMemInfo.hMappingInfo =
 928                                             psMemInfo->sMemBlk.hOSMemHandle;
 929
 930         PVRSRVAllocHandleNR(psPerProc->psHandleBase,
 931                             &psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo,
 932                             psMemInfo, PVRSRV_HANDLE_TYPE_MEM_INFO,
 933                             PVRSRV_HANDLE_ALLOC_FLAG_NONE);
 934
 935         psWrapExtMemOUT->sClientSyncInfo.psSyncData =
 936             psMemInfo->psKernelSyncInfo->psSyncData;
 937         psWrapExtMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
 938             psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
 939         psWrapExtMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
 940             psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
 941
 942         psWrapExtMemOUT->sClientSyncInfo.hMappingInfo =
 943             psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.
 944                                                             hOSMemHandle;
 945
 946         psWrapExtMemOUT->sClientMemInfo.psClientSyncInfo =
 947             &psWrapExtMemOUT->sClientSyncInfo;
 948
 949         PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
 950                                &psWrapExtMemOUT->sClientSyncInfo.
 951                                                                hKernelSyncInfo,
 952                                (void *)psMemInfo->psKernelSyncInfo,
 953                                PVRSRV_HANDLE_TYPE_SYNC_INFO,
 954                                PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
 955                                psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo);
 956
 957         COMMIT_HANDLE_BATCH_OR_ERROR(psWrapExtMemOUT->eError, psPerProc);
 958
 959         return 0;
 960 }
 961
 962 static int PVRSRVUnwrapExtMemoryBW(u32 ui32BridgeID,
 963                 struct PVRSRV_BRIDGE_IN_UNWRAP_EXT_MEMORY *psUnwrapExtMemIN,
 964                 struct PVRSRV_BRIDGE_RETURN *psRetOUT,
 965                 struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 966 {
 967         void *pvMemInfo;
 968
 969         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_UNWRAP_EXT_MEMORY);
 970
 971         psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
 972                                &pvMemInfo, psUnwrapExtMemIN->hKernelMemInfo,
 973                                PVRSRV_HANDLE_TYPE_MEM_INFO);
 974         if (psRetOUT->eError != PVRSRV_OK)
 975                 return 0;
 976
 977         psRetOUT->eError =
 978             PVRSRVUnwrapExtMemoryKM((struct PVRSRV_KERNEL_MEM_INFO *)pvMemInfo);
 979         if (psRetOUT->eError != PVRSRV_OK)
 980                 return 0;
 981
 982         psRetOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
 983                                 psUnwrapExtMemIN->hKernelMemInfo,
 984                                 PVRSRV_HANDLE_TYPE_MEM_INFO);
 985
 986         return 0;
 987 }
 988
 989 static int PVRSRVGetFreeDeviceMemBW(u32 ui32BridgeID,
 990          struct PVRSRV_BRIDGE_IN_GETFREEDEVICEMEM *psGetFreeDeviceMemIN,
 991          struct PVRSRV_BRIDGE_OUT_GETFREEDEVICEMEM *psGetFreeDeviceMemOUT,
 992          struct PVRSRV_PER_PROCESS_DATA *psPerProc)
 993 {
 994         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GETFREE_DEVICEMEM);
 995
 996         PVR_UNREFERENCED_PARAMETER(psPerProc);
 997
 998         psGetFreeDeviceMemOUT->eError =
 999             PVRSRVGetFreeDeviceMemKM(psGetFreeDeviceMemIN->ui32Flags,
1000                                      &psGetFreeDeviceMemOUT->ui32Total,
1001                                      &psGetFreeDeviceMemOUT->ui32Free,
1002                                      &psGetFreeDeviceMemOUT->ui32LargestBlock);
1003
1004         return 0;
1005 }
1006
1007 static int PVRMMapOSMemHandleToMMapDataBW(u32 ui32BridgeID,
1008           struct PVRSRV_BRIDGE_IN_MHANDLE_TO_MMAP_DATA *psMMapDataIN,
1009           struct PVRSRV_BRIDGE_OUT_MHANDLE_TO_MMAP_DATA *psMMapDataOUT,
1010           struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1011 {
1012         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1013                                  PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA);
1014
1015         psMMapDataOUT->eError =
1016             PVRMMapOSMemHandleToMMapData(psPerProc, psMMapDataIN->hMHandle,
1017                                          &psMMapDataOUT->ui32MMapOffset,
1018                                          &psMMapDataOUT->ui32ByteOffset,
1019                                          &psMMapDataOUT->ui32RealByteSize,
1020                                          &psMMapDataOUT->ui32UserVAddr);
1021         return 0;
1022 }
1023
1024 static int PVRMMapReleaseMMapDataBW(u32 ui32BridgeID,
1025                     struct PVRSRV_BRIDGE_IN_RELEASE_MMAP_DATA *psMMapDataIN,
1026                     struct PVRSRV_BRIDGE_OUT_RELEASE_MMAP_DATA *psMMapDataOUT,
1027                     struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1028 {
1029         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RELEASE_MMAP_DATA);
1030
1031         psMMapDataOUT->eError = PVRMMapReleaseMMapData(psPerProc,
1032                                            psMMapDataIN->hMHandle,
1033                                            &psMMapDataOUT->bMUnmap,
1034                                            &psMMapDataOUT->ui32RealByteSize,
1035                                            &psMMapDataOUT->ui32UserVAddr);
1036         return 0;
1037 }
1038
1039 #ifdef PDUMP
1040 static int PDumpIsCaptureFrameBW(u32 ui32BridgeID, void *psBridgeIn,
1041               struct PVRSRV_BRIDGE_OUT_PDUMP_ISCAPTURING *psPDumpIsCapturingOUT,
1042               struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1043 {
1044         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_ISCAPTURING);
1045         PVR_UNREFERENCED_PARAMETER(psBridgeIn);
1046         PVR_UNREFERENCED_PARAMETER(psPerProc);
1047
1048         psPDumpIsCapturingOUT->bIsCapturing = PDumpIsCaptureFrameKM();
1049         psPDumpIsCapturingOUT->eError = PVRSRV_OK;
1050
1051         return 0;
1052 }
1053
1054 static int PDumpCommentBW(u32 ui32BridgeID,
1055                struct PVRSRV_BRIDGE_IN_PDUMP_COMMENT *psPDumpCommentIN,
1056                struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1057                struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1058 {
1059         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_COMMENT);
1060         PVR_UNREFERENCED_PARAMETER(psPerProc);
1061
1062         PDumpCommentKM(&psPDumpCommentIN->szComment[0],
1063                        psPDumpCommentIN->ui32Flags);
1064
1065         psRetOUT->eError = PVRSRV_OK;
1066
1067         return 0;
1068 }
1069
1070 static int PDumpSetFrameBW(u32 ui32BridgeID,
1071                 struct PVRSRV_BRIDGE_IN_PDUMP_SETFRAME *psPDumpSetFrameIN,
1072                 struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1073                 struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1074 {
1075         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_SETFRAME);
1076         PVR_UNREFERENCED_PARAMETER(psPerProc);
1077
1078         PDumpSetFrameKM(psPDumpSetFrameIN->ui32Frame);
1079
1080         psRetOUT->eError = PVRSRV_OK;
1081
1082         return 0;
1083 }
1084
1085 static int PDumpRegWithFlagsBW(u32 ui32BridgeID,
1086                     struct PVRSRV_BRIDGE_IN_PDUMP_DUMPREG *psPDumpRegDumpIN,
1087                     struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1088                     struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1089 {
1090         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_REG);
1091         PVR_UNREFERENCED_PARAMETER(psPerProc);
1092
1093         PDumpRegWithFlagsKM(psPDumpRegDumpIN->sHWReg.ui32RegAddr,
1094                             psPDumpRegDumpIN->sHWReg.ui32RegVal,
1095                             psPDumpRegDumpIN->ui32Flags);
1096
1097         psRetOUT->eError = PVRSRV_OK;
1098
1099         return 0;
1100 }
1101
1102 static int PDumpRegPolBW(u32 ui32BridgeID,
1103               struct PVRSRV_BRIDGE_IN_PDUMP_REGPOL *psPDumpRegPolIN,
1104               struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1105               struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1106 {
1107         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_REGPOL);
1108         PVR_UNREFERENCED_PARAMETER(psPerProc);
1109
1110         PDumpRegPolWithFlagsKM(psPDumpRegPolIN->sHWReg.ui32RegAddr,
1111                                psPDumpRegPolIN->sHWReg.ui32RegVal,
1112                                psPDumpRegPolIN->ui32Mask,
1113                                psPDumpRegPolIN->ui32Flags);
1114
1115         psRetOUT->eError = PVRSRV_OK;
1116
1117         return 0;
1118 }
1119
1120 static int PDumpMemPolBW(u32 ui32BridgeID,
1121               struct PVRSRV_BRIDGE_IN_PDUMP_MEMPOL *psPDumpMemPolIN,
1122               struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1123               struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1124 {
1125         void *pvMemInfo;
1126
1127         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_MEMPOL);
1128
1129         psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
1130                                               &pvMemInfo,
1131                                               psPDumpMemPolIN->psKernelMemInfo,
1132                                               PVRSRV_HANDLE_TYPE_MEM_INFO);
1133         if (psRetOUT->eError != PVRSRV_OK)
1134                 return 0;
1135
1136         PDumpMemPolKM(((struct PVRSRV_KERNEL_MEM_INFO *)pvMemInfo),
1137                       psPDumpMemPolIN->ui32Offset,
1138                       psPDumpMemPolIN->ui32Value,
1139                       psPDumpMemPolIN->ui32Mask,
1140                       PDUMP_POLL_OPERATOR_EQUAL,
1141                       MAKEUNIQUETAG(pvMemInfo));
1142
1143         return 0;
1144 }
1145
1146 static int PDumpMemBW(u32 ui32BridgeID,
1147            struct PVRSRV_BRIDGE_IN_PDUMP_DUMPMEM *psPDumpMemDumpIN,
1148            struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1149            struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1150 {
1151         void *pvMemInfo;
1152
1153         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPMEM);
1154
1155         psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
1156                                         &pvMemInfo,
1157                                         psPDumpMemDumpIN->psKernelMemInfo,
1158                                         PVRSRV_HANDLE_TYPE_MEM_INFO);
1159         if (psRetOUT->eError != PVRSRV_OK)
1160                 return 0;
1161
1162         psRetOUT->eError = PDumpMemUM(psPDumpMemDumpIN->pvAltLinAddr,
1163                                       psPDumpMemDumpIN->pvLinAddr,
1164                                       pvMemInfo, psPDumpMemDumpIN->ui32Offset,
1165                                       psPDumpMemDumpIN->ui32Bytes,
1166                                       psPDumpMemDumpIN->ui32Flags,
1167                                       MAKEUNIQUETAG(pvMemInfo));
1168
1169         return 0;
1170 }
1171
1172 static int PDumpBitmapBW(u32 ui32BridgeID,
1173               struct PVRSRV_BRIDGE_IN_PDUMP_BITMAP *psPDumpBitmapIN,
1174               struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1175               struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1176 {
1177         PVR_UNREFERENCED_PARAMETER(psPerProc);
1178         PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
1179
1180         PDumpBitmapKM(&psPDumpBitmapIN->szFileName[0],
1181                       psPDumpBitmapIN->ui32FileOffset,
1182                       psPDumpBitmapIN->ui32Width,
1183                       psPDumpBitmapIN->ui32Height,
1184                       psPDumpBitmapIN->ui32StrideInBytes,
1185                       psPDumpBitmapIN->sDevBaseAddr,
1186                       psPDumpBitmapIN->ui32Size,
1187                       psPDumpBitmapIN->ePixelFormat,
1188                       psPDumpBitmapIN->eMemFormat,
1189                       psPDumpBitmapIN->ui32Flags);
1190
1191         psRetOUT->eError = PVRSRV_OK;
1192
1193         return 0;
1194 }
1195
1196 static int PDumpSyncDumpBW(u32 ui32BridgeID,
1197                 struct PVRSRV_BRIDGE_IN_PDUMP_DUMPSYNC *psPDumpSyncDumpIN,
1198                 struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1199                 struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1200 {
1201         u32 ui32Bytes = psPDumpSyncDumpIN->ui32Bytes;
1202         void *pvSyncInfo;
1203
1204         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPSYNC);
1205
1206         psRetOUT->eError =
1207             PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSyncInfo,
1208                                psPDumpSyncDumpIN->psKernelSyncInfo,
1209                                PVRSRV_HANDLE_TYPE_SYNC_INFO);
1210         if (psRetOUT->eError != PVRSRV_OK)
1211                 return 0;
1212
1213         psRetOUT->eError =
1214                 PDumpMemUM(psPDumpSyncDumpIN->pvAltLinAddr, NULL,
1215                            ((struct PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->
1216                            psSyncDataMemInfoKM,
1217                            psPDumpSyncDumpIN->ui32Offset, ui32Bytes, 0,
1218                            MAKEUNIQUETAG(((struct PVRSRV_KERNEL_SYNC_INFO *)
1219                                           pvSyncInfo)->psSyncDataMemInfoKM));
1220
1221         return 0;
1222 }
1223
1224 static int PDumpSyncPolBW(u32 ui32BridgeID,
1225                struct PVRSRV_BRIDGE_IN_PDUMP_SYNCPOL *psPDumpSyncPolIN,
1226                struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1227                struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1228 {
1229         u32 ui32Offset;
1230         void *pvSyncInfo;
1231
1232         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_SYNCPOL);
1233
1234         psRetOUT->eError =
1235             PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSyncInfo,
1236                                psPDumpSyncPolIN->psKernelSyncInfo,
1237                                PVRSRV_HANDLE_TYPE_SYNC_INFO);
1238         if (psRetOUT->eError != PVRSRV_OK)
1239                 return 0;
1240
1241         if (psPDumpSyncPolIN->bIsRead)
1242                 ui32Offset = offsetof(struct PVRSRV_SYNC_DATA,
1243                                       ui32ReadOpsComplete);
1244         else
1245                 ui32Offset = offsetof(struct PVRSRV_SYNC_DATA,
1246                                       ui32WriteOpsComplete);
1247
1248         PDumpMemPolKM(((struct PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->
1249                       psSyncDataMemInfoKM, ui32Offset,
1250                       psPDumpSyncPolIN->ui32Value,
1251                       psPDumpSyncPolIN->ui32Mask, PDUMP_POLL_OPERATOR_EQUAL,
1252                       MAKEUNIQUETAG(((struct PVRSRV_KERNEL_SYNC_INFO *)
1253                                      pvSyncInfo)->psSyncDataMemInfoKM));
1254
1255         return 0;
1256 }
1257
1258 static int PDumpPDRegBW(u32 ui32BridgeID,
1259              struct PVRSRV_BRIDGE_IN_PDUMP_DUMPPDREG *psPDumpPDRegDumpIN,
1260              struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1261              struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1262 {
1263         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_PDREG);
1264         PVR_UNREFERENCED_PARAMETER(psPerProc);
1265
1266         PDumpPDReg(psPDumpPDRegDumpIN->sHWReg.ui32RegAddr,
1267                    psPDumpPDRegDumpIN->sHWReg.ui32RegVal);
1268
1269         psRetOUT->eError = PVRSRV_OK;
1270         return 0;
1271 }
1272
1273 static int PDumpCycleCountRegReadBW(u32 ui32BridgeID,
1274                 struct PVRSRV_BRIDGE_IN_PDUMP_CYCLE_COUNT_REG_READ
1275                                         *psPDumpCycleCountRegReadIN,
1276                 struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1277                 struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1278 {
1279         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1280                                  PVRSRV_BRIDGE_PDUMP_CYCLE_COUNT_REG_READ);
1281         PVR_UNREFERENCED_PARAMETER(psPerProc);
1282
1283         PDumpCycleCountRegRead(psPDumpCycleCountRegReadIN->ui32RegOffset);
1284
1285         psRetOUT->eError = PVRSRV_OK;
1286
1287         return 0;
1288 }
1289
1290 static int PDumpPDDevPAddrBW(u32 ui32BridgeID,
1291           struct PVRSRV_BRIDGE_IN_PDUMP_DUMPPDDEVPADDR *psPDumpPDDevPAddrIN,
1292           struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1293           struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1294 {
1295         void *pvMemInfo;
1296
1297         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1298                                  PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR);
1299
1300         psRetOUT->eError =
1301             PVRSRVLookupHandle(psPerProc->psHandleBase, &pvMemInfo,
1302                                psPDumpPDDevPAddrIN->hKernelMemInfo,
1303                                PVRSRV_HANDLE_TYPE_MEM_INFO);
1304         if (psRetOUT->eError != PVRSRV_OK)
1305                 return 0;
1306
1307         PDumpPDDevPAddrKM((struct PVRSRV_KERNEL_MEM_INFO *)pvMemInfo,
1308                           psPDumpPDDevPAddrIN->ui32Offset,
1309                           psPDumpPDDevPAddrIN->sPDDevPAddr,
1310                           MAKEUNIQUETAG(pvMemInfo), PDUMP_PD_UNIQUETAG);
1311
1312         return 0;
1313 }
1314
1315 #endif
1316
1317 static int PVRSRVGetMiscInfoBW(u32 ui32BridgeID,
1318                     struct PVRSRV_BRIDGE_IN_GET_MISC_INFO *psGetMiscInfoIN,
1319                     struct PVRSRV_BRIDGE_OUT_GET_MISC_INFO *psGetMiscInfoOUT,
1320                     struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1321 {
1322         enum PVRSRV_ERROR eError;
1323
1324         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_MISC_INFO);
1325
1326         OSMemCopy(&psGetMiscInfoOUT->sMiscInfo, &psGetMiscInfoIN->sMiscInfo,
1327                   sizeof(struct PVRSRV_MISC_INFO));
1328
1329         if (((psGetMiscInfoIN->sMiscInfo.ui32StateRequest &
1330                 PVRSRV_MISC_INFO_MEMSTATS_PRESENT) != 0) &&
1331             ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest &
1332                 PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0)) {
1333
1334                 psGetMiscInfoOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
1335                 return 0;
1336         }
1337
1338         if (((psGetMiscInfoIN->sMiscInfo.ui32StateRequest &
1339                 PVRSRV_MISC_INFO_MEMSTATS_PRESENT) != 0) ||
1340             ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest &
1341                 PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0)) {
1342
1343                 ASSIGN_AND_EXIT_ON_ERROR(
1344                         psGetMiscInfoOUT->eError,
1345                         OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
1346                            psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen,
1347                            (void **)&psGetMiscInfoOUT->sMiscInfo.pszMemoryStr,
1348                            NULL));
1349
1350                 psGetMiscInfoOUT->eError =
1351                     PVRSRVGetMiscInfoKM(&psGetMiscInfoOUT->sMiscInfo);
1352
1353                 eError = CopyToUserWrapper(psPerProc, ui32BridgeID,
1354                                 (void __force __user *)
1355                                         psGetMiscInfoIN->sMiscInfo.pszMemoryStr,
1356                                 psGetMiscInfoOUT->sMiscInfo.pszMemoryStr,
1357                                 psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen);
1358
1359                 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
1360                           psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen,
1361                           (void *)psGetMiscInfoOUT->sMiscInfo.pszMemoryStr,
1362                           NULL);
1363
1364                 psGetMiscInfoOUT->sMiscInfo.pszMemoryStr =
1365                                         psGetMiscInfoIN->sMiscInfo.pszMemoryStr;
1366
1367                 if (eError != PVRSRV_OK) {
1368                         PVR_DPF(PVR_DBG_ERROR,
1369                                  "PVRSRVGetMiscInfoBW Error copy to user");
1370                         return -EFAULT;
1371                 }
1372         } else {
1373                 psGetMiscInfoOUT->eError =
1374                             PVRSRVGetMiscInfoKM(&psGetMiscInfoOUT->sMiscInfo);
1375         }
1376
1377         if (psGetMiscInfoOUT->eError != PVRSRV_OK)
1378                 return 0;
1379
1380         if (psGetMiscInfoIN->sMiscInfo.ui32StateRequest &
1381             PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT) {
1382                 psGetMiscInfoOUT->eError =
1383                     PVRSRVAllocHandle(psPerProc->psHandleBase,
1384                                       &psGetMiscInfoOUT->sMiscInfo.
1385                                               sGlobalEventObject.hOSEventKM,
1386                                       psGetMiscInfoOUT->sMiscInfo.
1387                                               sGlobalEventObject.hOSEventKM,
1388                                       PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT,
1389                                       PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
1390
1391                 if (psGetMiscInfoOUT->eError != PVRSRV_OK)
1392                         return 0;
1393         }
1394
1395         if (psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle) {
1396                 psGetMiscInfoOUT->eError =
1397                     PVRSRVAllocHandle(psPerProc->psHandleBase,
1398                                       &psGetMiscInfoOUT->sMiscInfo.
1399                                               hSOCTimerRegisterOSMemHandle,
1400                                       psGetMiscInfoOUT->sMiscInfo.
1401                                               hSOCTimerRegisterOSMemHandle,
1402                                       PVRSRV_HANDLE_TYPE_SOC_TIMER,
1403                                       PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
1404
1405                 if (psGetMiscInfoOUT->eError != PVRSRV_OK)
1406                         return 0;
1407         }
1408
1409         return 0;
1410 }
1411
1412 static int PVRSRVConnectBW(u32 ui32BridgeID, void *psBridgeIn,
1413                 struct PVRSRV_BRIDGE_OUT_CONNECT_SERVICES *psConnectServicesOUT,
1414                 struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1415 {
1416         PVR_UNREFERENCED_PARAMETER(psBridgeIn);
1417
1418         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CONNECT_SERVICES);
1419
1420         psConnectServicesOUT->hKernelServices = psPerProc->hPerProcData;
1421         psConnectServicesOUT->eError = PVRSRV_OK;
1422
1423         return 0;
1424 }
1425
1426 static int PVRSRVDisconnectBW(u32 ui32BridgeID, void *psBridgeIn,
1427                    struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1428                    struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1429 {
1430         PVR_UNREFERENCED_PARAMETER(psPerProc);
1431         PVR_UNREFERENCED_PARAMETER(psBridgeIn);
1432
1433         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1434                                  PVRSRV_BRIDGE_DISCONNECT_SERVICES);
1435
1436         psRetOUT->eError = PVRSRV_OK;
1437
1438         return 0;
1439 }
1440
1441 static int PVRSRVEnumerateDCBW(u32 ui32BridgeID,
1442                     struct PVRSRV_BRIDGE_IN_ENUMCLASS *psEnumDispClassIN,
1443                     struct PVRSRV_BRIDGE_OUT_ENUMCLASS *psEnumDispClassOUT,
1444                     struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1445 {
1446         PVR_UNREFERENCED_PARAMETER(psPerProc);
1447
1448         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_CLASS);
1449
1450         psEnumDispClassOUT->eError =
1451             PVRSRVEnumerateDCKM(psEnumDispClassIN->sDeviceClass,
1452                                 &psEnumDispClassOUT->ui32NumDevices,
1453                                 &psEnumDispClassOUT->ui32DevID[0]);
1454
1455         return 0;
1456 }
1457
1458 static int PVRSRVOpenDCDeviceBW(u32 ui32BridgeID,
1459      struct PVRSRV_BRIDGE_IN_OPEN_DISPCLASS_DEVICE *psOpenDispClassDeviceIN,
1460      struct PVRSRV_BRIDGE_OUT_OPEN_DISPCLASS_DEVICE *psOpenDispClassDeviceOUT,
1461      struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1462 {
1463         void *hDevCookieInt;
1464         void *hDispClassInfoInt;
1465
1466         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1467                                  PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE);
1468
1469         NEW_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError, psPerProc,
1470                                   1);
1471
1472         psOpenDispClassDeviceOUT->eError =
1473             PVRSRVLookupHandle(psPerProc->psHandleBase,
1474                                &hDevCookieInt,
1475                                psOpenDispClassDeviceIN->hDevCookie,
1476                                PVRSRV_HANDLE_TYPE_DEV_NODE);
1477         if (psOpenDispClassDeviceOUT->eError != PVRSRV_OK)
1478                 return 0;
1479
1480         psOpenDispClassDeviceOUT->eError = PVRSRVOpenDCDeviceKM(psPerProc,
1481                                  psOpenDispClassDeviceIN->ui32DeviceID,
1482                                  hDevCookieInt, &hDispClassInfoInt);
1483
1484         if (psOpenDispClassDeviceOUT->eError != PVRSRV_OK)
1485                 return 0;
1486
1487         PVRSRVAllocHandleNR(psPerProc->psHandleBase,
1488                             &psOpenDispClassDeviceOUT->hDeviceKM,
1489                             hDispClassInfoInt,
1490                             PVRSRV_HANDLE_TYPE_DISP_INFO,
1491                             PVRSRV_HANDLE_ALLOC_FLAG_NONE);
1492         COMMIT_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError,
1493                                      psPerProc);
1494
1495         return 0;
1496 }
1497
1498 static int PVRSRVCloseDCDeviceBW(u32 ui32BridgeID,
1499      struct PVRSRV_BRIDGE_IN_CLOSE_DISPCLASS_DEVICE *psCloseDispClassDeviceIN,
1500      struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1501      struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1502 {
1503         void *pvDispClassInfoInt;
1504
1505         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1506                                  PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE);
1507
1508         psRetOUT->eError =
1509             PVRSRVLookupHandle(psPerProc->psHandleBase,
1510                                &pvDispClassInfoInt,
1511                                psCloseDispClassDeviceIN->hDeviceKM,
1512                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1513
1514         if (psRetOUT->eError != PVRSRV_OK)
1515                 return 0;
1516
1517         psRetOUT->eError = PVRSRVCloseDCDeviceKM(pvDispClassInfoInt, IMG_FALSE);
1518         if (psRetOUT->eError != PVRSRV_OK)
1519                 return 0;
1520
1521         psRetOUT->eError =
1522             PVRSRVReleaseHandle(psPerProc->psHandleBase,
1523                                 psCloseDispClassDeviceIN->hDeviceKM,
1524                                 PVRSRV_HANDLE_TYPE_DISP_INFO);
1525         return 0;
1526 }
1527
1528 static int PVRSRVEnumDCFormatsBW(u32 ui32BridgeID,
1529      struct PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_FORMATS *psEnumDispClassFormatsIN,
1530      struct PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_FORMATS *psEnumDispClassFormatsOUT,
1531      struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1532 {
1533         void *pvDispClassInfoInt;
1534
1535         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1536                                  PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS);
1537
1538         psEnumDispClassFormatsOUT->eError =
1539             PVRSRVLookupHandle(psPerProc->psHandleBase,
1540                                &pvDispClassInfoInt,
1541                                psEnumDispClassFormatsIN->hDeviceKM,
1542                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1543         if (psEnumDispClassFormatsOUT->eError != PVRSRV_OK)
1544                 return 0;
1545
1546         psEnumDispClassFormatsOUT->eError =
1547             PVRSRVEnumDCFormatsKM(pvDispClassInfoInt,
1548                                   &psEnumDispClassFormatsOUT->ui32Count,
1549                                   psEnumDispClassFormatsOUT->asFormat);
1550
1551         return 0;
1552 }
1553
1554 static int PVRSRVEnumDCDimsBW(u32 ui32BridgeID,
1555            struct PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_DIMS *psEnumDispClassDimsIN,
1556            struct PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_DIMS *psEnumDispClassDimsOUT,
1557            struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1558 {
1559         void *pvDispClassInfoInt;
1560
1561         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1562                                  PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS);
1563
1564         psEnumDispClassDimsOUT->eError =
1565             PVRSRVLookupHandle(psPerProc->psHandleBase,
1566                                &pvDispClassInfoInt,
1567                                psEnumDispClassDimsIN->hDeviceKM,
1568                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1569
1570         if (psEnumDispClassDimsOUT->eError != PVRSRV_OK)
1571                 return 0;
1572
1573         psEnumDispClassDimsOUT->eError =
1574             PVRSRVEnumDCDimsKM(pvDispClassInfoInt,
1575                                &psEnumDispClassDimsIN->sFormat,
1576                                &psEnumDispClassDimsOUT->ui32Count,
1577                                psEnumDispClassDimsOUT->asDim);
1578
1579         return 0;
1580 }
1581
1582 static int PVRSRVGetDCSystemBufferBW(u32 ui32BridgeID,
1583    struct PVRSRV_BRIDGE_IN_GET_DISPCLASS_SYSBUFFER *psGetDispClassSysBufferIN,
1584    struct PVRSRV_BRIDGE_OUT_GET_DISPCLASS_SYSBUFFER *psGetDispClassSysBufferOUT,
1585    struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1586 {
1587         void *hBufferInt;
1588         void *pvDispClassInfoInt;
1589
1590         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1591                                  PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER);
1592
1593         NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError, psPerProc,
1594                                   1);
1595
1596         psGetDispClassSysBufferOUT->eError =
1597             PVRSRVLookupHandle(psPerProc->psHandleBase,
1598                                &pvDispClassInfoInt,
1599                                psGetDispClassSysBufferIN->hDeviceKM,
1600                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1601         if (psGetDispClassSysBufferOUT->eError != PVRSRV_OK)
1602                 return 0;
1603
1604         psGetDispClassSysBufferOUT->eError =
1605             PVRSRVGetDCSystemBufferKM(pvDispClassInfoInt, &hBufferInt);
1606
1607         if (psGetDispClassSysBufferOUT->eError != PVRSRV_OK)
1608                 return 0;
1609
1610         PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1611                                &psGetDispClassSysBufferOUT->hBuffer,
1612                                hBufferInt,
1613                                PVRSRV_HANDLE_TYPE_DISP_BUFFER,
1614                                (enum PVRSRV_HANDLE_ALLOC_FLAG)
1615                                (PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE |
1616                                 PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
1617                                psGetDispClassSysBufferIN->hDeviceKM);
1618
1619         COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError,
1620                                      psPerProc);
1621
1622         return 0;
1623 }
1624
1625 static int PVRSRVGetDCInfoBW(u32 ui32BridgeID,
1626           struct PVRSRV_BRIDGE_IN_GET_DISPCLASS_INFO *psGetDispClassInfoIN,
1627           struct PVRSRV_BRIDGE_OUT_GET_DISPCLASS_INFO *psGetDispClassInfoOUT,
1628           struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1629 {
1630         void *pvDispClassInfo;
1631
1632         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1633                                  PVRSRV_BRIDGE_GET_DISPCLASS_INFO);
1634
1635         psGetDispClassInfoOUT->eError =
1636             PVRSRVLookupHandle(psPerProc->psHandleBase,
1637                                &pvDispClassInfo,
1638                                psGetDispClassInfoIN->hDeviceKM,
1639                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1640         if (psGetDispClassInfoOUT->eError != PVRSRV_OK)
1641                 return 0;
1642
1643         psGetDispClassInfoOUT->eError =
1644             PVRSRVGetDCInfoKM(pvDispClassInfo,
1645                               &psGetDispClassInfoOUT->sDisplayInfo);
1646
1647         return 0;
1648 }
1649
1650 static int PVRSRVCreateDCSwapChainBW(u32 ui32BridgeID,
1651                   struct PVRSRV_BRIDGE_IN_CREATE_DISPCLASS_SWAPCHAIN
1652                                 *psCreateDispClassSwapChainIN,
1653                   struct PVRSRV_BRIDGE_OUT_CREATE_DISPCLASS_SWAPCHAIN
1654                                 *psCreateDispClassSwapChainOUT,
1655                   struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1656 {
1657         void *pvDispClassInfo;
1658         void *hSwapChainInt;
1659
1660         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1661                                  PVRSRV_BRIDGE_CREATE_DISPCLASS_SWAPCHAIN);
1662
1663         NEW_HANDLE_BATCH_OR_ERROR(psCreateDispClassSwapChainOUT->eError,
1664                                   psPerProc, 1);
1665
1666         psCreateDispClassSwapChainOUT->eError =
1667             PVRSRVLookupHandle(psPerProc->psHandleBase,
1668                                &pvDispClassInfo,
1669                                psCreateDispClassSwapChainIN->hDeviceKM,
1670                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1671
1672         if (psCreateDispClassSwapChainOUT->eError != PVRSRV_OK)
1673                 return 0;
1674
1675         psCreateDispClassSwapChainOUT->eError =
1676             PVRSRVCreateDCSwapChainKM(psPerProc, pvDispClassInfo,
1677                         psCreateDispClassSwapChainIN->ui32Flags,
1678                         &psCreateDispClassSwapChainIN->sDstSurfAttrib,
1679                         &psCreateDispClassSwapChainIN->sSrcSurfAttrib,
1680                         psCreateDispClassSwapChainIN->ui32BufferCount,
1681                         psCreateDispClassSwapChainIN->ui32OEMFlags,
1682                         &hSwapChainInt,
1683                         &psCreateDispClassSwapChainOUT->ui32SwapChainID);
1684
1685         if (psCreateDispClassSwapChainOUT->eError != PVRSRV_OK)
1686                 return 0;
1687
1688         PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1689                                &psCreateDispClassSwapChainOUT->hSwapChain,
1690                                hSwapChainInt,
1691                                PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN,
1692                                PVRSRV_HANDLE_ALLOC_FLAG_NONE,
1693                                psCreateDispClassSwapChainIN->hDeviceKM);
1694
1695         COMMIT_HANDLE_BATCH_OR_ERROR(psCreateDispClassSwapChainOUT->eError,
1696                                      psPerProc);
1697
1698         return 0;
1699 }
1700
1701 static int PVRSRVDestroyDCSwapChainBW(u32 ui32BridgeID,
1702                            struct PVRSRV_BRIDGE_IN_DESTROY_DISPCLASS_SWAPCHAIN
1703                                         *psDestroyDispClassSwapChainIN,
1704                            struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1705                            struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1706 {
1707         void *pvSwapChain;
1708
1709         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1710                                  PVRSRV_BRIDGE_DESTROY_DISPCLASS_SWAPCHAIN);
1711
1712         psRetOUT->eError =
1713             PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSwapChain,
1714                                psDestroyDispClassSwapChainIN->hSwapChain,
1715                                PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
1716         if (psRetOUT->eError != PVRSRV_OK)
1717                 return 0;
1718
1719         psRetOUT->eError = PVRSRVDestroyDCSwapChainKM(pvSwapChain);
1720
1721         if (psRetOUT->eError != PVRSRV_OK)
1722                 return 0;
1723
1724         psRetOUT->eError =
1725             PVRSRVReleaseHandle(psPerProc->psHandleBase,
1726                                 psDestroyDispClassSwapChainIN->hSwapChain,
1727                                 PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
1728
1729         return 0;
1730 }
1731
1732 static int PVRSRVSetDCDstRectBW(u32 ui32BridgeID,
1733          struct PVRSRV_BRIDGE_IN_SET_DISPCLASS_RECT *psSetDispClassDstRectIN,
1734          struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1735          struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1736 {
1737         void *pvDispClassInfo;
1738         void *pvSwapChain;
1739
1740         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1741                                  PVRSRV_BRIDGE_SET_DISPCLASS_DSTRECT);
1742
1743         psRetOUT->eError =
1744             PVRSRVLookupHandle(psPerProc->psHandleBase,
1745                                &pvDispClassInfo,
1746                                psSetDispClassDstRectIN->hDeviceKM,
1747                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1748         if (psRetOUT->eError != PVRSRV_OK)
1749                 return 0;
1750
1751         psRetOUT->eError =
1752             PVRSRVLookupHandle(psPerProc->psHandleBase,
1753                                &pvSwapChain,
1754                                psSetDispClassDstRectIN->hSwapChain,
1755                                PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
1756
1757         if (psRetOUT->eError != PVRSRV_OK)
1758                 return 0;
1759
1760         psRetOUT->eError =
1761             PVRSRVSetDCDstRectKM(pvDispClassInfo,
1762                                  pvSwapChain, &psSetDispClassDstRectIN->sRect);
1763
1764         return 0;
1765 }
1766
1767 static int PVRSRVSetDCSrcRectBW(u32 ui32BridgeID,
1768      struct PVRSRV_BRIDGE_IN_SET_DISPCLASS_RECT *psSetDispClassSrcRectIN,
1769      struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1770      struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1771 {
1772         void *pvDispClassInfo;
1773         void *pvSwapChain;
1774
1775         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1776                                  PVRSRV_BRIDGE_SET_DISPCLASS_SRCRECT);
1777
1778         psRetOUT->eError =
1779             PVRSRVLookupHandle(psPerProc->psHandleBase,
1780                                &pvDispClassInfo,
1781                                psSetDispClassSrcRectIN->hDeviceKM,
1782                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1783         if (psRetOUT->eError != PVRSRV_OK)
1784                 return 0;
1785
1786         psRetOUT->eError =
1787             PVRSRVLookupHandle(psPerProc->psHandleBase,
1788                                &pvSwapChain,
1789                                psSetDispClassSrcRectIN->hSwapChain,
1790                                PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
1791         if (psRetOUT->eError != PVRSRV_OK)
1792                 return 0;
1793
1794         psRetOUT->eError =
1795             PVRSRVSetDCSrcRectKM(pvDispClassInfo,
1796                                  pvSwapChain, &psSetDispClassSrcRectIN->sRect);
1797
1798         return 0;
1799 }
1800
1801 static int PVRSRVSetDCDstColourKeyBW(u32 ui32BridgeID,
1802        struct PVRSRV_BRIDGE_IN_SET_DISPCLASS_COLOURKEY *psSetDispClassColKeyIN,
1803        struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1804        struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1805 {
1806         void *pvDispClassInfo;
1807         void *pvSwapChain;
1808
1809         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1810                                  PVRSRV_BRIDGE_SET_DISPCLASS_DSTCOLOURKEY);
1811
1812         psRetOUT->eError =
1813             PVRSRVLookupHandle(psPerProc->psHandleBase,
1814                                &pvDispClassInfo,
1815                                psSetDispClassColKeyIN->hDeviceKM,
1816                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1817         if (psRetOUT->eError != PVRSRV_OK)
1818                 return 0;
1819
1820         psRetOUT->eError =
1821             PVRSRVLookupHandle(psPerProc->psHandleBase,
1822                                &pvSwapChain,
1823                                psSetDispClassColKeyIN->hSwapChain,
1824                                PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
1825         if (psRetOUT->eError != PVRSRV_OK)
1826                 return 0;
1827
1828         psRetOUT->eError =
1829             PVRSRVSetDCDstColourKeyKM(pvDispClassInfo,
1830                                       pvSwapChain,
1831                                       psSetDispClassColKeyIN->ui32CKColour);
1832
1833         return 0;
1834 }
1835
1836 static int PVRSRVSetDCSrcColourKeyBW(u32 ui32BridgeID,
1837         struct PVRSRV_BRIDGE_IN_SET_DISPCLASS_COLOURKEY *psSetDispClassColKeyIN,
1838         struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1839         struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1840 {
1841         void *pvDispClassInfo;
1842         void *pvSwapChain;
1843
1844         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1845                                  PVRSRV_BRIDGE_SET_DISPCLASS_SRCCOLOURKEY);
1846
1847         psRetOUT->eError =
1848             PVRSRVLookupHandle(psPerProc->psHandleBase,
1849                                &pvDispClassInfo,
1850                                psSetDispClassColKeyIN->hDeviceKM,
1851                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1852         if (psRetOUT->eError != PVRSRV_OK)
1853                 return 0;
1854
1855         psRetOUT->eError =
1856             PVRSRVLookupHandle(psPerProc->psHandleBase,
1857                                &pvSwapChain,
1858                                psSetDispClassColKeyIN->hSwapChain,
1859                                PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
1860         if (psRetOUT->eError != PVRSRV_OK)
1861                 return 0;
1862
1863         psRetOUT->eError =
1864             PVRSRVSetDCSrcColourKeyKM(pvDispClassInfo,
1865                                       pvSwapChain,
1866                                       psSetDispClassColKeyIN->ui32CKColour);
1867
1868         return 0;
1869 }
1870
1871 static int PVRSRVGetDCBuffersBW(u32 ui32BridgeID,
1872      struct PVRSRV_BRIDGE_IN_GET_DISPCLASS_BUFFERS *psGetDispClassBuffersIN,
1873      struct PVRSRV_BRIDGE_OUT_GET_DISPCLASS_BUFFERS *psGetDispClassBuffersOUT,
1874      struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1875 {
1876         void *pvDispClassInfo;
1877         void *pvSwapChain;
1878         u32 i;
1879
1880         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1881                                  PVRSRV_BRIDGE_GET_DISPCLASS_BUFFERS);
1882
1883         NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError, psPerProc,
1884                                   PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS);
1885
1886         psGetDispClassBuffersOUT->eError =
1887             PVRSRVLookupHandle(psPerProc->psHandleBase,
1888                                &pvDispClassInfo,
1889                                psGetDispClassBuffersIN->hDeviceKM,
1890                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1891         if (psGetDispClassBuffersOUT->eError != PVRSRV_OK)
1892                 return 0;
1893
1894         psGetDispClassBuffersOUT->eError =
1895             PVRSRVLookupHandle(psPerProc->psHandleBase,
1896                                &pvSwapChain,
1897                                psGetDispClassBuffersIN->hSwapChain,
1898                                PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
1899         if (psGetDispClassBuffersOUT->eError != PVRSRV_OK)
1900                 return 0;
1901
1902         psGetDispClassBuffersOUT->eError =
1903             PVRSRVGetDCBuffersKM(pvDispClassInfo,
1904                                  pvSwapChain,
1905                                  &psGetDispClassBuffersOUT->ui32BufferCount,
1906                                  psGetDispClassBuffersOUT->ahBuffer);
1907         if (psGetDispClassBuffersOUT->eError != PVRSRV_OK)
1908                 return 0;
1909
1910         PVR_ASSERT(psGetDispClassBuffersOUT->ui32BufferCount <=
1911                    PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS);
1912
1913         for (i = 0; i < psGetDispClassBuffersOUT->ui32BufferCount; i++) {
1914                 void *hBufferExt;
1915
1916                 PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1917                                &hBufferExt,
1918                                psGetDispClassBuffersOUT->ahBuffer[i],
1919                                PVRSRV_HANDLE_TYPE_DISP_BUFFER,
1920                                (enum PVRSRV_HANDLE_ALLOC_FLAG)
1921                                        (PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE |
1922                                         PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
1923                                psGetDispClassBuffersIN->hSwapChain);
1924
1925                 psGetDispClassBuffersOUT->ahBuffer[i] = hBufferExt;
1926         }
1927
1928         COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError,
1929                                      psPerProc);
1930
1931         return 0;
1932 }
1933
1934 static int PVRSRVSwapToDCBufferBW(u32 ui32BridgeID,
1935       struct PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_BUFFER *psSwapDispClassBufferIN,
1936       struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1937       struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1938 {
1939         void *pvDispClassInfo;
1940         void *pvSwapChainBuf;
1941
1942         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1943                                  PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_BUFFER);
1944
1945         psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
1946                                         &pvDispClassInfo,
1947                                         psSwapDispClassBufferIN->hDeviceKM,
1948                                         PVRSRV_HANDLE_TYPE_DISP_INFO);
1949         if (psRetOUT->eError != PVRSRV_OK)
1950                 return 0;
1951
1952         psRetOUT->eError =
1953             PVRSRVLookupSubHandle(psPerProc->psHandleBase,
1954                                   &pvSwapChainBuf,
1955                                   psSwapDispClassBufferIN->hBuffer,
1956                                   PVRSRV_HANDLE_TYPE_DISP_BUFFER,
1957                                   psSwapDispClassBufferIN->hDeviceKM);
1958         if (psRetOUT->eError != PVRSRV_OK)
1959                 return 0;
1960
1961         psRetOUT->eError =
1962             PVRSRVSwapToDCBufferKM(pvDispClassInfo,
1963                                    pvSwapChainBuf,
1964                                    psSwapDispClassBufferIN->ui32SwapInterval,
1965                                    psSwapDispClassBufferIN->hPrivateTag,
1966                                    psSwapDispClassBufferIN->ui32ClipRectCount,
1967                                    psSwapDispClassBufferIN->sClipRect);
1968
1969         return 0;
1970 }
1971
1972 static int PVRSRVSwapToDCSystemBW(u32 ui32BridgeID,
1973       struct PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_SYSTEM *psSwapDispClassSystemIN,
1974       struct PVRSRV_BRIDGE_RETURN *psRetOUT,
1975       struct PVRSRV_PER_PROCESS_DATA *psPerProc)
1976 {
1977         void *pvDispClassInfo;
1978         void *pvSwapChain;
1979
1980         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
1981                                  PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_SYSTEM);
1982
1983         psRetOUT->eError =
1984             PVRSRVLookupHandle(psPerProc->psHandleBase,
1985                                &pvDispClassInfo,
1986                                psSwapDispClassSystemIN->hDeviceKM,
1987                                PVRSRV_HANDLE_TYPE_DISP_INFO);
1988         if (psRetOUT->eError != PVRSRV_OK)
1989                 return 0;
1990
1991         psRetOUT->eError =
1992             PVRSRVLookupSubHandle(psPerProc->psHandleBase,
1993                                   &pvSwapChain,
1994                                   psSwapDispClassSystemIN->hSwapChain,
1995                                   PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN,
1996                                   psSwapDispClassSystemIN->hDeviceKM);
1997         if (psRetOUT->eError != PVRSRV_OK)
1998                 return 0;
1999         psRetOUT->eError = PVRSRVSwapToDCSystemKM(pvDispClassInfo, pvSwapChain);
2000
2001         return 0;
2002 }
2003
2004 static int PVRSRVOpenBCDeviceBW(u32 ui32BridgeID,
2005    struct PVRSRV_BRIDGE_IN_OPEN_BUFFERCLASS_DEVICE *psOpenBufferClassDeviceIN,
2006    struct PVRSRV_BRIDGE_OUT_OPEN_BUFFERCLASS_DEVICE *psOpenBufferClassDeviceOUT,
2007    struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2008 {
2009         void *hDevCookieInt;
2010         void *hBufClassInfo;
2011
2012         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
2013                                  PVRSRV_BRIDGE_OPEN_BUFFERCLASS_DEVICE);
2014
2015         NEW_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError, psPerProc,
2016                                   1);
2017
2018         psOpenBufferClassDeviceOUT->eError =
2019             PVRSRVLookupHandle(psPerProc->psHandleBase,
2020                                &hDevCookieInt,
2021                                psOpenBufferClassDeviceIN->hDevCookie,
2022                                PVRSRV_HANDLE_TYPE_DEV_NODE);
2023         if (psOpenBufferClassDeviceOUT->eError != PVRSRV_OK)
2024                 return 0;
2025
2026         psOpenBufferClassDeviceOUT->eError =
2027             PVRSRVOpenBCDeviceKM(psPerProc,
2028                                  psOpenBufferClassDeviceIN->ui32DeviceID,
2029                                  hDevCookieInt, &hBufClassInfo);
2030         if (psOpenBufferClassDeviceOUT->eError != PVRSRV_OK)
2031                 return 0;
2032
2033         PVRSRVAllocHandleNR(psPerProc->psHandleBase,
2034                             &psOpenBufferClassDeviceOUT->hDeviceKM,
2035                             hBufClassInfo,
2036                             PVRSRV_HANDLE_TYPE_BUF_INFO,
2037                             PVRSRV_HANDLE_ALLOC_FLAG_NONE);
2038
2039         COMMIT_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError,
2040                                      psPerProc);
2041
2042         return 0;
2043 }
2044
2045 static int PVRSRVCloseBCDeviceBW(u32 ui32BridgeID,
2046    struct PVRSRV_BRIDGE_IN_CLOSE_BUFFERCLASS_DEVICE *psCloseBufferClassDeviceIN,
2047    struct PVRSRV_BRIDGE_RETURN *psRetOUT,
2048    struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2049 {
2050         void *pvBufClassInfo;
2051
2052         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
2053                                  PVRSRV_BRIDGE_CLOSE_BUFFERCLASS_DEVICE);
2054
2055         psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
2056                                &pvBufClassInfo,
2057                                psCloseBufferClassDeviceIN->hDeviceKM,
2058                                PVRSRV_HANDLE_TYPE_BUF_INFO);
2059         if (psRetOUT->eError != PVRSRV_OK)
2060                 return 0;
2061
2062         psRetOUT->eError = PVRSRVCloseBCDeviceKM(pvBufClassInfo, IMG_FALSE);
2063
2064         if (psRetOUT->eError != PVRSRV_OK)
2065                 return 0;
2066
2067         psRetOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
2068                                                psCloseBufferClassDeviceIN->
2069                                                hDeviceKM,
2070                                                PVRSRV_HANDLE_TYPE_BUF_INFO);
2071
2072         return 0;
2073 }
2074
2075 static int PVRSRVGetBCInfoBW(u32 ui32BridgeID,
2076    struct PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_INFO *psGetBufferClassInfoIN,
2077    struct PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_INFO *psGetBufferClassInfoOUT,
2078    struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2079 {
2080         void *pvBufClassInfo;
2081
2082         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
2083                                  PVRSRV_BRIDGE_GET_BUFFERCLASS_INFO);
2084
2085         psGetBufferClassInfoOUT->eError =
2086             PVRSRVLookupHandle(psPerProc->psHandleBase,
2087                                &pvBufClassInfo,
2088                                psGetBufferClassInfoIN->hDeviceKM,
2089                                PVRSRV_HANDLE_TYPE_BUF_INFO);
2090         if (psGetBufferClassInfoOUT->eError != PVRSRV_OK)
2091                 return 0;
2092
2093         psGetBufferClassInfoOUT->eError =
2094             PVRSRVGetBCInfoKM(pvBufClassInfo,
2095                               &psGetBufferClassInfoOUT->sBufferInfo);
2096         return 0;
2097 }
2098
2099 static int PVRSRVGetBCBufferBW(u32 ui32BridgeID,
2100     struct PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_BUFFER *psGetBufferClassBufferIN,
2101     struct PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_BUFFER *psGetBufferClassBufferOUT,
2102     struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2103 {
2104         void *pvBufClassInfo;
2105         void *hBufferInt;
2106
2107         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
2108                                  PVRSRV_BRIDGE_GET_BUFFERCLASS_BUFFER);
2109
2110         NEW_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError, psPerProc,
2111                                   1);
2112
2113         psGetBufferClassBufferOUT->eError =
2114             PVRSRVLookupHandle(psPerProc->psHandleBase,
2115                                &pvBufClassInfo,
2116                                psGetBufferClassBufferIN->hDeviceKM,
2117                                PVRSRV_HANDLE_TYPE_BUF_INFO);
2118         if (psGetBufferClassBufferOUT->eError != PVRSRV_OK)
2119                 return 0;
2120
2121         psGetBufferClassBufferOUT->eError =
2122             PVRSRVGetBCBufferKM(pvBufClassInfo,
2123                                 psGetBufferClassBufferIN->ui32BufferIndex,
2124                                 &hBufferInt);
2125
2126         if (psGetBufferClassBufferOUT->eError != PVRSRV_OK)
2127                 return 0;
2128
2129         PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
2130                                &psGetBufferClassBufferOUT->hBuffer,
2131                                hBufferInt,
2132                                PVRSRV_HANDLE_TYPE_BUF_BUFFER,
2133                                (enum PVRSRV_HANDLE_ALLOC_FLAG)
2134                                        (PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE |
2135                                         PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
2136                                psGetBufferClassBufferIN->hDeviceKM);
2137
2138         COMMIT_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError,
2139                                      psPerProc);
2140
2141         return 0;
2142 }
2143
2144 static int PVRSRVAllocSharedSysMemoryBW(u32 ui32BridgeID,
2145           struct PVRSRV_BRIDGE_IN_ALLOC_SHARED_SYS_MEM *psAllocSharedSysMemIN,
2146           struct PVRSRV_BRIDGE_OUT_ALLOC_SHARED_SYS_MEM *psAllocSharedSysMemOUT,
2147           struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2148 {
2149         struct PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
2150
2151         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
2152                                  PVRSRV_BRIDGE_ALLOC_SHARED_SYS_MEM);
2153
2154         NEW_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc, 1);
2155
2156         psAllocSharedSysMemOUT->eError =
2157             PVRSRVAllocSharedSysMemoryKM(psPerProc,
2158                                          psAllocSharedSysMemIN->ui32Flags,
2159                                          psAllocSharedSysMemIN->ui32Size,
2160                                          &psKernelMemInfo);
2161         if (psAllocSharedSysMemOUT->eError != PVRSRV_OK)
2162                 return 0;
2163
2164         OSMemSet(&psAllocSharedSysMemOUT->sClientMemInfo,
2165                  0, sizeof(psAllocSharedSysMemOUT->sClientMemInfo));
2166
2167         psAllocSharedSysMemOUT->sClientMemInfo.pvLinAddrKM =
2168                     psKernelMemInfo->pvLinAddrKM;
2169
2170         psAllocSharedSysMemOUT->sClientMemInfo.pvLinAddr = NULL;
2171         psAllocSharedSysMemOUT->sClientMemInfo.ui32Flags =
2172                                         psKernelMemInfo->ui32Flags;
2173         psAllocSharedSysMemOUT->sClientMemInfo.ui32AllocSize =
2174                                         psKernelMemInfo->ui32AllocSize;
2175         psAllocSharedSysMemOUT->sClientMemInfo.hMappingInfo =
2176                                         psKernelMemInfo->sMemBlk.hOSMemHandle;
2177
2178         PVRSRVAllocHandleNR(psPerProc->psHandleBase,
2179                          &psAllocSharedSysMemOUT->sClientMemInfo.hKernelMemInfo,
2180                          psKernelMemInfo,
2181                          PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO,
2182                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
2183
2184         COMMIT_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc);
2185
2186         return 0;
2187 }
2188
2189 static int PVRSRVFreeSharedSysMemoryBW(u32 ui32BridgeID,
2190             struct PVRSRV_BRIDGE_IN_FREE_SHARED_SYS_MEM *psFreeSharedSysMemIN,
2191             struct PVRSRV_BRIDGE_OUT_FREE_SHARED_SYS_MEM *psFreeSharedSysMemOUT,
2192             struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2193 {
2194         struct PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
2195
2196         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
2197                                  PVRSRV_BRIDGE_FREE_SHARED_SYS_MEM);
2198
2199         psFreeSharedSysMemOUT->eError =
2200             PVRSRVLookupHandle(psPerProc->psHandleBase,
2201                                (void **)&psKernelMemInfo,
2202                                psFreeSharedSysMemIN->psKernelMemInfo,
2203                                PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
2204
2205         if (psFreeSharedSysMemOUT->eError != PVRSRV_OK)
2206                 return 0;
2207
2208         psFreeSharedSysMemOUT->eError =
2209             PVRSRVFreeSharedSysMemoryKM(psKernelMemInfo);
2210         if (psFreeSharedSysMemOUT->eError != PVRSRV_OK)
2211                 return 0;
2212
2213         psFreeSharedSysMemOUT->eError =
2214             PVRSRVReleaseHandle(psPerProc->psHandleBase,
2215                                 psFreeSharedSysMemIN->psKernelMemInfo,
2216                                 PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
2217         return 0;
2218 }
2219
2220 static int PVRSRVMapMemInfoMemBW(u32 ui32BridgeID,
2221               struct PVRSRV_BRIDGE_IN_MAP_MEMINFO_MEM *psMapMemInfoMemIN,
2222               struct PVRSRV_BRIDGE_OUT_MAP_MEMINFO_MEM *psMapMemInfoMemOUT,
2223               struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2224 {
2225         struct PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
2226         enum PVRSRV_HANDLE_TYPE eHandleType;
2227         void *hParent;
2228         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_MEMINFO_MEM);
2229
2230         NEW_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc, 2);
2231
2232         psMapMemInfoMemOUT->eError =
2233             PVRSRVLookupHandleAnyType(psPerProc->psHandleBase,
2234                                       (void **)&psKernelMemInfo, &eHandleType,
2235                                       psMapMemInfoMemIN->hKernelMemInfo);
2236         if (psMapMemInfoMemOUT->eError != PVRSRV_OK)
2237                 return 0;
2238
2239         switch (eHandleType) {
2240         case PVRSRV_HANDLE_TYPE_MEM_INFO:
2241         case PVRSRV_HANDLE_TYPE_MEM_INFO_REF:
2242         case PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO:
2243                 break;
2244         default:
2245                 psMapMemInfoMemOUT->eError = PVRSRV_ERROR_GENERIC;
2246                 return 0;
2247         }
2248
2249         psMapMemInfoMemOUT->eError =
2250             PVRSRVGetParentHandle(psPerProc->psHandleBase, &hParent,
2251                                   psMapMemInfoMemIN->hKernelMemInfo,
2252                                   eHandleType);
2253         if (psMapMemInfoMemOUT->eError != PVRSRV_OK)
2254                 return 0;
2255         if (hParent == NULL)
2256                 hParent = psMapMemInfoMemIN->hKernelMemInfo;
2257
2258         OSMemSet(&psMapMemInfoMemOUT->sClientMemInfo,
2259                  0, sizeof(psMapMemInfoMemOUT->sClientMemInfo));
2260
2261         psMapMemInfoMemOUT->sClientMemInfo.pvLinAddrKM =
2262                                         psKernelMemInfo->pvLinAddrKM;
2263
2264         psMapMemInfoMemOUT->sClientMemInfo.pvLinAddr = NULL;
2265         psMapMemInfoMemOUT->sClientMemInfo.sDevVAddr =
2266                                         psKernelMemInfo->sDevVAddr;
2267         psMapMemInfoMemOUT->sClientMemInfo.ui32Flags =
2268                                         psKernelMemInfo->ui32Flags;
2269         psMapMemInfoMemOUT->sClientMemInfo.ui32AllocSize =
2270                                         psKernelMemInfo->ui32AllocSize;
2271         psMapMemInfoMemOUT->sClientMemInfo.hMappingInfo =
2272                                         psKernelMemInfo->sMemBlk.hOSMemHandle;
2273
2274         PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
2275                         &psMapMemInfoMemOUT->sClientMemInfo.hKernelMemInfo,
2276                         psKernelMemInfo,
2277                         PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
2278                         PVRSRV_HANDLE_ALLOC_FLAG_MULTI, hParent);
2279
2280         if (psKernelMemInfo->ui32Flags & PVRSRV_MEM_NO_SYNCOBJ) {
2281                 OSMemSet(&psMapMemInfoMemOUT->sClientSyncInfo, 0,
2282                 sizeof(struct PVRSRV_CLIENT_SYNC_INFO));
2283                 psMapMemInfoMemOUT->psKernelSyncInfo = NULL;
2284         } else {
2285                 psMapMemInfoMemOUT->sClientSyncInfo.psSyncData =
2286                     psKernelMemInfo->psKernelSyncInfo->psSyncData;
2287                 psMapMemInfoMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
2288                     psKernelMemInfo->psKernelSyncInfo->
2289                                                     sWriteOpsCompleteDevVAddr;
2290                 psMapMemInfoMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
2291                     psKernelMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
2292
2293                 psMapMemInfoMemOUT->sClientSyncInfo.hMappingInfo =
2294                     psKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->
2295                                                     sMemBlk.hOSMemHandle;
2296
2297                 psMapMemInfoMemOUT->sClientMemInfo.psClientSyncInfo =
2298                     &psMapMemInfoMemOUT->sClientSyncInfo;
2299
2300                 PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
2301                         &psMapMemInfoMemOUT->sClientSyncInfo.hKernelSyncInfo,
2302                         psKernelMemInfo->psKernelSyncInfo,
2303                         PVRSRV_HANDLE_TYPE_SYNC_INFO,
2304                         PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
2305                         psMapMemInfoMemOUT->sClientMemInfo.hKernelMemInfo);
2306         }
2307
2308         COMMIT_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc);
2309
2310         return 0;
2311 }
2312
2313 static int PVRSRVModifySyncOpsBW(u32 ui32BridgeID,
2314                  struct PVRSRV_BRIDGE_IN_MODIFY_SYNC_OPS *psModifySyncOpsIN,
2315                  struct PVRSRV_BRIDGE_OUT_MODIFY_SYNC_OPS *psModifySyncOpsOUT,
2316                  struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2317 {
2318         void *hKernelSyncInfo;
2319         struct PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
2320
2321         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MODIFY_SYNC_OPS);
2322
2323         psModifySyncOpsOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
2324                                         &hKernelSyncInfo,
2325                                         psModifySyncOpsIN->hKernelSyncInfo,
2326                                         PVRSRV_HANDLE_TYPE_SYNC_INFO);
2327         if (psModifySyncOpsOUT->eError != PVRSRV_OK)
2328                 return 0;
2329
2330         psKernelSyncInfo = (struct PVRSRV_KERNEL_SYNC_INFO *)hKernelSyncInfo;
2331
2332         /* We return PRE-INCREMENTED versions of all sync Op Values */
2333
2334         psModifySyncOpsOUT->ui32ReadOpsPending =
2335             psKernelSyncInfo->psSyncData->ui32ReadOpsPending;
2336
2337         psModifySyncOpsOUT->ui32WriteOpsPending =
2338             psKernelSyncInfo->psSyncData->ui32WriteOpsPending;
2339
2340         psModifySyncOpsOUT->ui32ReadOpsComplete =
2341             psKernelSyncInfo->psSyncData->ui32ReadOpsComplete;
2342
2343         psModifySyncOpsOUT->ui32WriteOpsComplete =
2344             psKernelSyncInfo->psSyncData->ui32WriteOpsComplete;
2345
2346         if (psModifySyncOpsIN->ui32ModifyFlags &
2347             PVRSRV_MODIFYSYNCOPS_FLAGS_WOP_INC)
2348                 psKernelSyncInfo->psSyncData->ui32WriteOpsPending++;
2349
2350         if (psModifySyncOpsIN->ui32ModifyFlags &
2351             PVRSRV_MODIFYSYNCOPS_FLAGS_ROP_INC)
2352                 psKernelSyncInfo->psSyncData->ui32ReadOpsPending++;
2353
2354         if (psModifySyncOpsIN->ui32ModifyFlags &
2355             PVRSRV_MODIFYSYNCOPS_FLAGS_WOC_INC)
2356                 psKernelSyncInfo->psSyncData->ui32WriteOpsComplete++;
2357
2358         if (psModifySyncOpsIN->ui32ModifyFlags &
2359             PVRSRV_MODIFYSYNCOPS_FLAGS_ROC_INC)
2360                 psKernelSyncInfo->psSyncData->ui32ReadOpsComplete++;
2361
2362         return 0;
2363 }
2364
2365 static int MMU_GetPDDevPAddrBW(u32 ui32BridgeID,
2366             struct PVRSRV_BRIDGE_IN_GETMMU_PD_DEVPADDR *psGetMmuPDDevPAddrIN,
2367             struct PVRSRV_BRIDGE_OUT_GETMMU_PD_DEVPADDR *psGetMmuPDDevPAddrOUT,
2368             struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2369 {
2370         void *hDevMemContextInt;
2371
2372         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
2373                                  PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR);
2374
2375         psGetMmuPDDevPAddrOUT->eError =
2376             PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
2377                                psGetMmuPDDevPAddrIN->hDevMemContext,
2378                                PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
2379         if (psGetMmuPDDevPAddrOUT->eError != PVRSRV_OK)
2380                 return 0;
2381
2382         psGetMmuPDDevPAddrOUT->sPDDevPAddr =
2383             BM_GetDeviceNode(hDevMemContextInt)->
2384             pfnMMUGetPDDevPAddr(BM_GetMMUContextFromMemContext
2385                               (hDevMemContextInt));
2386         if (psGetMmuPDDevPAddrOUT->sPDDevPAddr.uiAddr)
2387                 psGetMmuPDDevPAddrOUT->eError = PVRSRV_OK;
2388         else
2389                 psGetMmuPDDevPAddrOUT->eError = PVRSRV_ERROR_GENERIC;
2390         return 0;
2391 }
2392
2393 int DummyBW(u32 ui32BridgeID, void *psBridgeIn, void *psBridgeOut,
2394             struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2395 {
2396 #if !defined(CONFIG_PVR_DEBUG_EXTRA)
2397         PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
2398 #endif
2399         PVR_UNREFERENCED_PARAMETER(psBridgeIn);
2400         PVR_UNREFERENCED_PARAMETER(psBridgeOut);
2401         PVR_UNREFERENCED_PARAMETER(psPerProc);
2402
2403 #if defined(DEBUG_BRIDGE_KM)
2404         PVR_DPF(PVR_DBG_ERROR, "%s: BRIDGE ERROR: BridgeID %lu (%s) mapped to "
2405                  "Dummy Wrapper (probably not what you want!)",
2406                  __func__, ui32BridgeID,
2407                  g_BridgeDispatchTable[ui32BridgeID].pszIOCName);
2408 #else
2409         PVR_DPF(PVR_DBG_ERROR, "%s: BRIDGE ERROR: BridgeID %lu mapped to "
2410                  "Dummy Wrapper (probably not what you want!)",
2411                  __func__, ui32BridgeID);
2412 #endif
2413         return -ENOTTY;
2414 }
2415
2416 void _SetDispatchTableEntry(u32 ui32Index, const char *pszIOCName,
2417                             int (*pfFunction)(u32 ui32BridgeID,
2418                                               void *psBridgeIn,
2419                                               void *psBridgeOut,
2420                                               struct PVRSRV_PER_PROCESS_DATA
2421                                                                    *psPerProc),
2422                             const char *pszFunctionName)
2423 {
2424         static u32 ui32PrevIndex = ~0UL;
2425 #if !defined(CONFIG_PVR_DEBUG_EXTRA)
2426         PVR_UNREFERENCED_PARAMETER(pszIOCName);
2427 #endif
2428 #if !defined(DEBUG_BRIDGE_KM_DISPATCH_TABLE) && !defined(DEBUG_BRIDGE_KM)
2429         PVR_UNREFERENCED_PARAMETER(pszFunctionName);
2430 #endif
2431
2432
2433         if (g_BridgeDispatchTable[ui32Index].pfFunction) {
2434 #if defined(DEBUG_BRIDGE_KM)
2435                 PVR_DPF(PVR_DBG_ERROR, "%s: BUG!: "
2436                         "Adding dispatch table entry for %s "
2437                         "clobbers an existing entry for %s",
2438                          __func__, pszIOCName,
2439                          g_BridgeDispatchTable[ui32Index].pszIOCName);
2440 #else
2441                 PVR_DPF(PVR_DBG_ERROR, "%s: BUG!: "
2442                         "Adding dispatch table entry for %s "
2443                         "clobbers an existing entry (index=%lu)",
2444                          __func__, pszIOCName, ui32Index);
2445 #endif
2446                 PVR_DPF(PVR_DBG_ERROR,
2447 "NOTE: Enabling DEBUG_BRIDGE_KM_DISPATCH_TABLE may help debug this issue.",
2448                          __func__);
2449         }
2450
2451         if ((ui32PrevIndex != ~0UL) &&
2452             ((ui32Index >= ui32PrevIndex + DISPATCH_TABLE_GAP_THRESHOLD) ||
2453              (ui32Index <= ui32PrevIndex))) {
2454 #if defined(DEBUG_BRIDGE_KM)
2455                 PVR_DPF(PVR_DBG_WARNING,
2456                          "%s: There is a gap in the dispatch table "
2457                          "between indices %lu (%s) and %lu (%s)",
2458                          __func__, ui32PrevIndex,
2459                          g_BridgeDispatchTable[ui32PrevIndex].pszIOCName,
2460                          ui32Index, pszIOCName);
2461 #else
2462                 PVR_DPF(PVR_DBG_WARNING,
2463                          "%s: There is a gap in the dispatch table "
2464                         "between indices %u and %u (%s)",
2465                          __func__, (unsigned)ui32PrevIndex, (unsigned)ui32Index,
2466                          pszIOCName);
2467 #endif
2468                 PVR_DPF(PVR_DBG_ERROR,
2469                         "NOTE: Enabling DEBUG_BRIDGE_KM_DISPATCH_TABLE "
2470                         "may help debug this issue.",
2471                          __func__);
2472         }
2473
2474         g_BridgeDispatchTable[ui32Index].pfFunction = pfFunction;
2475 #if defined(DEBUG_BRIDGE_KM)
2476         g_BridgeDispatchTable[ui32Index].pszIOCName = pszIOCName;
2477         g_BridgeDispatchTable[ui32Index].pszFunctionName = pszFunctionName;
2478         g_BridgeDispatchTable[ui32Index].ui32CallCount = 0;
2479         g_BridgeDispatchTable[ui32Index].ui32CopyFromUserTotalBytes = 0;
2480 #endif
2481
2482         ui32PrevIndex = ui32Index;
2483 }
2484
2485 static int PVRSRVInitSrvConnectBW(u32 ui32BridgeID, void *psBridgeIn,
2486                                   struct PVRSRV_BRIDGE_RETURN *psRetOUT,
2487                                   struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2488 {
2489         PVR_UNREFERENCED_PARAMETER(psBridgeIn);
2490
2491         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_INITSRV_CONNECT);
2492         PVR_UNREFERENCED_PARAMETER(psBridgeIn);
2493
2494         if (!OSProcHasPrivSrvInit() ||
2495             PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RUNNING) ||
2496             PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RAN)) {
2497                 psRetOUT->eError = PVRSRV_ERROR_GENERIC;
2498                 return 0;
2499         }
2500
2501         PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_RUNNING, IMG_TRUE);
2502         psPerProc->bInitProcess = IMG_TRUE;
2503
2504         psRetOUT->eError = PVRSRV_OK;
2505
2506         return 0;
2507 }
2508
2509 static int PVRSRVInitSrvDisconnectBW(u32 ui32BridgeID,
2510              struct PVRSRV_BRIDGE_IN_INITSRV_DISCONNECT *psInitSrvDisconnectIN,
2511              struct PVRSRV_BRIDGE_RETURN *psRetOUT,
2512              struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2513 {
2514         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
2515                                  PVRSRV_BRIDGE_INITSRV_DISCONNECT);
2516
2517         if (!psPerProc->bInitProcess) {
2518                 psRetOUT->eError = PVRSRV_ERROR_GENERIC;
2519                 return 0;
2520         }
2521
2522         psPerProc->bInitProcess = IMG_FALSE;
2523
2524         PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_RUNNING, IMG_FALSE);
2525         PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_RAN, IMG_TRUE);
2526
2527         psRetOUT->eError =
2528             PVRSRVFinaliseSystem(psInitSrvDisconnectIN->bInitSuccesful);
2529
2530         PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL,
2531                                  (IMG_BOOL)(((psRetOUT->eError == PVRSRV_OK) &&
2532                                               (psInitSrvDisconnectIN->
2533                                                             bInitSuccesful))));
2534
2535         return 0;
2536 }
2537
2538 static int PVRSRVEventObjectWaitBW(u32 ui32BridgeID,
2539            struct PVRSRV_BRIDGE_IN_EVENT_OBJECT_WAIT *psEventObjectWaitIN,
2540            struct PVRSRV_BRIDGE_RETURN *psRetOUT,
2541            struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2542 {
2543         void *hOSEventKM;
2544
2545         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_WAIT);
2546
2547         psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
2548                                       &hOSEventKM,
2549                                       psEventObjectWaitIN->hOSEventKM,
2550                                       PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
2551
2552         if (psRetOUT->eError != PVRSRV_OK)
2553                 return 0;
2554
2555         psRetOUT->eError = OSEventObjectWait(hOSEventKM);
2556
2557         return 0;
2558 }
2559
2560 static int PVRSRVEventObjectOpenBW(u32 ui32BridgeID,
2561            struct PVRSRV_BRIDGE_IN_EVENT_OBJECT_OPEN *psEventObjectOpenIN,
2562            struct PVRSRV_BRIDGE_OUT_EVENT_OBJECT_OPEN *psEventObjectOpenOUT,
2563            struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2564 {
2565
2566         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_OPEN);
2567
2568         NEW_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc, 1);
2569
2570         psEventObjectOpenOUT->eError =
2571             PVRSRVLookupHandle(psPerProc->psHandleBase,
2572                                &psEventObjectOpenIN->sEventObject.hOSEventKM,
2573                                psEventObjectOpenIN->sEventObject.hOSEventKM,
2574                                PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
2575
2576         if (psEventObjectOpenOUT->eError != PVRSRV_OK)
2577                 return 0;
2578
2579         psEventObjectOpenOUT->eError =
2580             OSEventObjectOpen(&psEventObjectOpenIN->sEventObject,
2581                               &psEventObjectOpenOUT->hOSEvent);
2582
2583         if (psEventObjectOpenOUT->eError != PVRSRV_OK)
2584                 return 0;
2585
2586         PVRSRVAllocHandleNR(psPerProc->psHandleBase,
2587                             &psEventObjectOpenOUT->hOSEvent,
2588                             psEventObjectOpenOUT->hOSEvent,
2589                             PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT,
2590                             PVRSRV_HANDLE_ALLOC_FLAG_MULTI);
2591
2592         COMMIT_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc);
2593
2594         return 0;
2595 }
2596
2597 static int PVRSRVEventObjectCloseBW(u32 ui32BridgeID,
2598             struct PVRSRV_BRIDGE_IN_EVENT_OBJECT_CLOSE *psEventObjectCloseIN,
2599             struct PVRSRV_BRIDGE_RETURN *psRetOUT,
2600             struct PVRSRV_PER_PROCESS_DATA *psPerProc)
2601 {
2602         void *hOSEventKM;
2603
2604         PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID,
2605                                  PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE);
2606
2607         psRetOUT->eError =
2608             PVRSRVLookupHandle(psPerProc->psHandleBase,
2609                                &psEventObjectCloseIN->sEventObject.hOSEventKM,
2610                                psEventObjectCloseIN->sEventObject.hOSEventKM,
2611                                PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
2612         if (psRetOUT->eError != PVRSRV_OK)
2613                 return 0;
2614
2615         psRetOUT->eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
2616                                 &hOSEventKM,
2617                                 psEventObjectCloseIN->hOSEventKM,
2618                                 PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
2619
2620         if (psRetOUT->eError != PVRSRV_OK)
2621                 return 0;
2622
2623         psRetOUT->eError =
2624             OSEventObjectClose(&psEventObjectCloseIN->sEventObject, hOSEventKM);
2625
2626         return 0;
2627 }
2628
2629 enum PVRSRV_ERROR CommonBridgeInit(void)
2630 {
2631         u32 i;
2632
2633         SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_DEVICES,
2634                               PVRSRVEnumerateDevicesBW);
2635         SetDispatchTableEntry(PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO,
2636                               PVRSRVAcquireDeviceDataBW);
2637         SetDispatchTableEntry(PVRSRV_BRIDGE_RELEASE_DEVICEINFO, DummyBW);
2638         SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT,
2639                               PVRSRVCreateDeviceMemContextBW);
2640         SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_DEVMEMCONTEXT,
2641                               PVRSRVDestroyDeviceMemContextBW);
2642         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO,
2643                               PVRSRVGetDeviceMemHeapInfoBW);
2644         SetDispatchTableEntry(PVRSRV_BRIDGE_ALLOC_DEVICEMEM,
2645                               PVRSRVAllocDeviceMemBW);
2646         SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_DEVICEMEM,
2647                               PVRSRVFreeDeviceMemBW);
2648         SetDispatchTableEntry(PVRSRV_BRIDGE_GETFREE_DEVICEMEM,
2649                               PVRSRVGetFreeDeviceMemBW);
2650         SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_COMMANDQUEUE, DummyBW);
2651         SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_COMMANDQUEUE, DummyBW);
2652         SetDispatchTableEntry(PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA,
2653                               PVRMMapOSMemHandleToMMapDataBW);
2654         SetDispatchTableEntry(PVRSRV_BRIDGE_CONNECT_SERVICES, PVRSRVConnectBW);
2655         SetDispatchTableEntry(PVRSRV_BRIDGE_DISCONNECT_SERVICES,
2656                               PVRSRVDisconnectBW);
2657         SetDispatchTableEntry(PVRSRV_BRIDGE_WRAP_DEVICE_MEM, DummyBW);
2658         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DEVICEMEMINFO, DummyBW);
2659         SetDispatchTableEntry(PVRSRV_BRIDGE_RESERVE_DEV_VIRTMEM, DummyBW);
2660         SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_DEV_VIRTMEM, DummyBW);
2661         SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_EXT_MEMORY, DummyBW);
2662         SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_EXT_MEMORY, DummyBW);
2663         SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_DEV_MEMORY,
2664                               PVRSRVMapDeviceMemoryBW);
2665         SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_DEV_MEMORY,
2666                               PVRSRVUnmapDeviceMemoryBW);
2667         SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY,
2668                               PVRSRVMapDeviceClassMemoryBW);
2669         SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_DEVICECLASS_MEMORY,
2670                               PVRSRVUnmapDeviceClassMemoryBW);
2671         SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_MEM_INFO_TO_USER, DummyBW);
2672         SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_MEM_INFO_FROM_USER, DummyBW);
2673         SetDispatchTableEntry(PVRSRV_BRIDGE_EXPORT_DEVICEMEM,
2674                               PVRSRVExportDeviceMemBW);
2675         SetDispatchTableEntry(PVRSRV_BRIDGE_RELEASE_MMAP_DATA,
2676                               PVRMMapReleaseMMapDataBW);
2677         SetDispatchTableEntry(PVRSRV_BRIDGE_CACHE_FLUSH_DRM,
2678                               PVRSRVCacheFlushDRIBW);
2679
2680         SetDispatchTableEntry(PVRSRV_BRIDGE_PROCESS_SIMISR_EVENT, DummyBW);
2681         SetDispatchTableEntry(PVRSRV_BRIDGE_REGISTER_SIM_PROCESS, DummyBW);
2682         SetDispatchTableEntry(PVRSRV_BRIDGE_UNREGISTER_SIM_PROCESS, DummyBW);
2683
2684         SetDispatchTableEntry(PVRSRV_BRIDGE_MAPPHYSTOUSERSPACE, DummyBW);
2685         SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAPPHYSTOUSERSPACE, DummyBW);
2686         SetDispatchTableEntry(PVRSRV_BRIDGE_GETPHYSTOUSERSPACEMAP, DummyBW);
2687
2688         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_FB_STATS, DummyBW);
2689
2690         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_MISC_INFO, PVRSRVGetMiscInfoBW);
2691         SetDispatchTableEntry(PVRSRV_BRIDGE_RELEASE_MISC_INFO, DummyBW);
2692
2693
2694 #if defined(PDUMP)
2695         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_INIT, DummyBW);
2696         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_MEMPOL, PDumpMemPolBW);
2697         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPMEM, PDumpMemBW);
2698         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_REG, PDumpRegWithFlagsBW);
2699         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_REGPOL, PDumpRegPolBW);
2700         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_COMMENT, PDumpCommentBW);
2701         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_SETFRAME, PDumpSetFrameBW);
2702         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_ISCAPTURING,
2703                               PDumpIsCaptureFrameBW);
2704         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPBITMAP, PDumpBitmapBW);
2705         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPREADREG, DummyBW);
2706         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_SYNCPOL, PDumpSyncPolBW);
2707         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPSYNC, PDumpSyncDumpBW);
2708         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DRIVERINFO, DummyBW);
2709         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_PDREG, PDumpPDRegBW);
2710         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR,
2711                               PDumpPDDevPAddrBW);
2712         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_CYCLE_COUNT_REG_READ,
2713                               PDumpCycleCountRegReadBW);
2714         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_STARTINITPHASE, DummyBW);
2715         SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_STOPINITPHASE, DummyBW);
2716 #endif
2717
2718         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_OEMJTABLE, DummyBW);
2719
2720         SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_CLASS, PVRSRVEnumerateDCBW);
2721
2722         SetDispatchTableEntry(PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE,
2723                               PVRSRVOpenDCDeviceBW);
2724         SetDispatchTableEntry(PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE,
2725                               PVRSRVCloseDCDeviceBW);
2726         SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS,
2727                               PVRSRVEnumDCFormatsBW);
2728         SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS,
2729                               PVRSRVEnumDCDimsBW);
2730         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER,
2731                               PVRSRVGetDCSystemBufferBW);
2732         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DISPCLASS_INFO,
2733                               PVRSRVGetDCInfoBW);
2734         SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_DISPCLASS_SWAPCHAIN,
2735                               PVRSRVCreateDCSwapChainBW);
2736         SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_DISPCLASS_SWAPCHAIN,
2737                               PVRSRVDestroyDCSwapChainBW);
2738         SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_DSTRECT,
2739                               PVRSRVSetDCDstRectBW);
2740         SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_SRCRECT,
2741                               PVRSRVSetDCSrcRectBW);
2742         SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_DSTCOLOURKEY,
2743                               PVRSRVSetDCDstColourKeyBW);
2744         SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_SRCCOLOURKEY,
2745                               PVRSRVSetDCSrcColourKeyBW);
2746         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DISPCLASS_BUFFERS,
2747                               PVRSRVGetDCBuffersBW);
2748         SetDispatchTableEntry(PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_BUFFER,
2749                               PVRSRVSwapToDCBufferBW);
2750         SetDispatchTableEntry(PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_SYSTEM,
2751                               PVRSRVSwapToDCSystemBW);
2752
2753         SetDispatchTableEntry(PVRSRV_BRIDGE_OPEN_BUFFERCLASS_DEVICE,
2754                               PVRSRVOpenBCDeviceBW);
2755         SetDispatchTableEntry(PVRSRV_BRIDGE_CLOSE_BUFFERCLASS_DEVICE,
2756                               PVRSRVCloseBCDeviceBW);
2757         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_BUFFERCLASS_INFO,
2758                               PVRSRVGetBCInfoBW);
2759         SetDispatchTableEntry(PVRSRV_BRIDGE_GET_BUFFERCLASS_BUFFER,
2760                               PVRSRVGetBCBufferBW);
2761
2762         SetDispatchTableEntry(PVRSRV_BRIDGE_WRAP_EXT_MEMORY,
2763                               PVRSRVWrapExtMemoryBW);
2764         SetDispatchTableEntry(PVRSRV_BRIDGE_UNWRAP_EXT_MEMORY,
2765                               PVRSRVUnwrapExtMemoryBW);
2766
2767         SetDispatchTableEntry(PVRSRV_BRIDGE_ALLOC_SHARED_SYS_MEM,
2768                               PVRSRVAllocSharedSysMemoryBW);
2769         SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_SHARED_SYS_MEM,
2770                               PVRSRVFreeSharedSysMemoryBW);
2771         SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_MEMINFO_MEM,
2772                               PVRSRVMapMemInfoMemBW);
2773
2774         SetDispatchTableEntry(PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR,
2775                               MMU_GetPDDevPAddrBW);
2776
2777         SetDispatchTableEntry(PVRSRV_BRIDGE_INITSRV_CONNECT,
2778                               PVRSRVInitSrvConnectBW);
2779         SetDispatchTableEntry(PVRSRV_BRIDGE_INITSRV_DISCONNECT,
2780                               PVRSRVInitSrvDisconnectBW);
2781
2782         SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_WAIT,
2783                               PVRSRVEventObjectWaitBW);
2784         SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_OPEN,
2785                               PVRSRVEventObjectOpenBW);
2786         SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE,
2787                               PVRSRVEventObjectCloseBW);
2788
2789         SetDispatchTableEntry(PVRSRV_BRIDGE_MODIFY_SYNC_OPS,
2790                               PVRSRVModifySyncOpsBW);
2791
2792         SetSGXDispatchTableEntry();
2793
2794         for (i = 0; i < BRIDGE_DISPATCH_TABLE_ENTRY_COUNT; i++)
2795                 if (!g_BridgeDispatchTable[i].pfFunction) {
2796                         g_BridgeDispatchTable[i].pfFunction = DummyBW;
2797 #if defined(DEBUG_BRIDGE_KM)
2798                         g_BridgeDispatchTable[i].pszIOCName =
2799                                                     "_PVRSRV_BRIDGE_DUMMY";
2800                         g_BridgeDispatchTable[i].pszFunctionName = "DummyBW";
2801                         g_BridgeDispatchTable[i].ui32CallCount = 0;
2802                         g_BridgeDispatchTable[i].ui32CopyFromUserTotalBytes = 0;
2803                         g_BridgeDispatchTable[i].ui32CopyToUserTotalBytes = 0;
2804 #endif
2805                 }
2806
2807         return PVRSRV_OK;
2808 }
2809
2810 static int bridged_check_cmd(u32 cmd_id)
2811 {
2812         if (PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RAN)) {
2813                 if (!PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL)) {
2814                         PVR_DPF(PVR_DBG_ERROR,
2815                         "%s: Initialisation failed.  Driver unusable.",
2816                                  __func__);
2817                         return 1;
2818                 }
2819         } else {
2820                 if (PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RUNNING)) {
2821                         PVR_DPF(PVR_DBG_ERROR,
2822                                  "%s: Initialisation is in progress",
2823                                  __func__);
2824                         return 1;
2825                 } else {
2826                         switch (cmd_id) {
2827                         case PVRSRV_GET_BRIDGE_ID(
2828                                 PVRSRV_BRIDGE_CONNECT_SERVICES):
2829                         case PVRSRV_GET_BRIDGE_ID(
2830                                 PVRSRV_BRIDGE_DISCONNECT_SERVICES):
2831                         case PVRSRV_GET_BRIDGE_ID(
2832                                 PVRSRV_BRIDGE_INITSRV_CONNECT):
2833                         case PVRSRV_GET_BRIDGE_ID(
2834                                 PVRSRV_BRIDGE_INITSRV_DISCONNECT):
2835                                 break;
2836                         default:
2837                                 PVR_DPF(PVR_DBG_ERROR,
2838                         "%s: Driver initialisation not completed yet.",
2839                                          __func__);
2840                                 return 1;
2841                         }
2842                 }
2843         }
2844
2845         return 0;
2846 }
2847
2848 static int bridged_ioctl(struct file *filp, u32 cmd, void *in, void *out,
2849                          size_t in_size,
2850                          struct PVRSRV_PER_PROCESS_DATA *per_proc)
2851 {
2852         int err = -EFAULT;
2853
2854         switch (PVRSRV_IOWR(cmd)) {
2855         case PVRSRV_BRIDGE_ENUM_DEVICES:
2856                 err = PVRSRVEnumerateDevicesBW(cmd, in, out, per_proc);
2857                 break;
2858         case PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO:
2859                 err = PVRSRVAcquireDeviceDataBW(cmd, in, out, per_proc);
2860                 break;
2861         case PVRSRV_BRIDGE_RELEASE_DEVICEINFO:
2862                 err = DummyBW(cmd, in, out, per_proc);
2863                 break;
2864         case PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT:
2865                 err = PVRSRVCreateDeviceMemContextBW(cmd, in, out, per_proc);
2866                 break;
2867         case PVRSRV_BRIDGE_DESTROY_DEVMEMCONTEXT:
2868                 err = PVRSRVDestroyDeviceMemContextBW(cmd, in, out, per_proc);
2869                 break;
2870         case PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO:
2871                 err = PVRSRVGetDeviceMemHeapInfoBW(cmd, in, out, per_proc);
2872                 break;
2873         case PVRSRV_BRIDGE_ALLOC_DEVICEMEM:
2874                 err = PVRSRVAllocDeviceMemBW(cmd, in, out, per_proc);
2875                 break;
2876         case PVRSRV_BRIDGE_FREE_DEVICEMEM:
2877                 err = PVRSRVFreeDeviceMemBW(cmd, in, out, per_proc);
2878                 break;
2879         case PVRSRV_BRIDGE_GETFREE_DEVICEMEM:
2880                 err = PVRSRVGetFreeDeviceMemBW(cmd, in, out, per_proc);
2881                 break;
2882
2883         case PVRSRV_BRIDGE_CREATE_COMMANDQUEUE:
2884         case PVRSRV_BRIDGE_DESTROY_COMMANDQUEUE:
2885                 err = DummyBW(cmd, in, out, per_proc);
2886                 break;
2887
2888         case PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA:
2889                 err = PVRMMapOSMemHandleToMMapDataBW(cmd, in, out, per_proc);
2890                 break;
2891         case PVRSRV_BRIDGE_CONNECT_SERVICES:
2892                 err = PVRSRVConnectBW(cmd, in, out, per_proc);
2893                 break;
2894         case PVRSRV_BRIDGE_DISCONNECT_SERVICES:
2895                 err = PVRSRVDisconnectBW(cmd, in, out, per_proc);
2896                 break;
2897
2898         case PVRSRV_BRIDGE_WRAP_DEVICE_MEM:
2899         case PVRSRV_BRIDGE_GET_DEVICEMEMINFO:
2900         case PVRSRV_BRIDGE_RESERVE_DEV_VIRTMEM:
2901         case PVRSRV_BRIDGE_FREE_DEV_VIRTMEM:
2902         case PVRSRV_BRIDGE_MAP_EXT_MEMORY:
2903         case PVRSRV_BRIDGE_UNMAP_EXT_MEMORY:
2904                 err = DummyBW(cmd, in, out, per_proc);
2905                 break;
2906
2907         case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
2908                 err = PVRSRVMapDeviceMemoryBW(cmd, in, out, per_proc);
2909                 break;
2910         case PVRSRV_BRIDGE_UNMAP_DEV_MEMORY:
2911                 err = PVRSRVUnmapDeviceMemoryBW(cmd, in, out, per_proc);
2912                 break;
2913         case PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY:
2914                 err = PVRSRVMapDeviceClassMemoryBW(cmd, in, out, per_proc);
2915                 break;
2916         case PVRSRV_BRIDGE_UNMAP_DEVICECLASS_MEMORY:
2917                 err = PVRSRVUnmapDeviceClassMemoryBW(cmd, in, out, per_proc);
2918                 break;
2919
2920         case PVRSRV_BRIDGE_MAP_MEM_INFO_TO_USER:
2921         case PVRSRV_BRIDGE_UNMAP_MEM_INFO_FROM_USER:
2922                 err = DummyBW(cmd, in, out, per_proc);
2923                 break;
2924
2925         case PVRSRV_BRIDGE_EXPORT_DEVICEMEM:
2926                 err = PVRSRVExportDeviceMemBW(cmd, in, out, per_proc);
2927                 break;
2928         case PVRSRV_BRIDGE_RELEASE_MMAP_DATA:
2929                 err = PVRMMapReleaseMMapDataBW(cmd, in, out, per_proc);
2930                 break;
2931         case PVRSRV_BRIDGE_CACHE_FLUSH_DRM:
2932                 err = PVRSRVCacheFlushDRIBW(cmd, in, out, per_proc);
2933                 break;
2934
2935         case PVRSRV_BRIDGE_PROCESS_SIMISR_EVENT:
2936         case PVRSRV_BRIDGE_REGISTER_SIM_PROCESS:
2937         case PVRSRV_BRIDGE_UNREGISTER_SIM_PROCESS:
2938         case PVRSRV_BRIDGE_MAPPHYSTOUSERSPACE:
2939         case PVRSRV_BRIDGE_UNMAPPHYSTOUSERSPACE:
2940         case PVRSRV_BRIDGE_GETPHYSTOUSERSPACEMAP:
2941         case PVRSRV_BRIDGE_GET_FB_STATS:
2942                 err = DummyBW(cmd, in, out, per_proc);
2943                 break;
2944
2945         case PVRSRV_BRIDGE_GET_MISC_INFO:
2946                 err = PVRSRVGetMiscInfoBW(cmd, in, out, per_proc);
2947                 break;
2948         case PVRSRV_BRIDGE_RELEASE_MISC_INFO:
2949                 err = DummyBW(cmd, in, out, per_proc);
2950                 break;
2951
2952 #if defined(PDUMP)
2953         case PVRSRV_BRIDGE_PDUMP_INIT:
2954                 err = DummyBW(cmd, in, out, per_proc);
2955                 break;
2956         case PVRSRV_BRIDGE_PDUMP_MEMPOL:
2957                 err = PDumpMemPolBW(cmd, in, out, per_proc);
2958                 break;
2959         case PVRSRV_BRIDGE_PDUMP_DUMPMEM:
2960                 err = PDumpMemBW(cmd, in, out, per_proc);
2961                 break;
2962         case PVRSRV_BRIDGE_PDUMP_REG:
2963                 err = PDumpRegWithFlagsBW(cmd, in, out, per_proc);
2964                 break;
2965         case PVRSRV_BRIDGE_PDUMP_REGPOL:
2966                 err = PDumpRegPolBW(cmd, in, out, per_proc);
2967                 break;
2968         case PVRSRV_BRIDGE_PDUMP_COMMENT:
2969                 err = PDumpCommentBW(cmd, in, out, per_proc);
2970                 break;
2971         case PVRSRV_BRIDGE_PDUMP_SETFRAME:
2972                 err = PDumpSetFrameBW(cmd, in, out, per_proc);
2973                 break;
2974         case PVRSRV_BRIDGE_PDUMP_ISCAPTURING:
2975                 err = PDumpIsCaptureFrameBW(cmd, in, out, per_proc);
2976                 break;
2977         case PVRSRV_BRIDGE_PDUMP_DUMPBITMAP:
2978                 err = PDumpBitmapBW(cmd, in, out, per_proc);
2979                 break;
2980         case PVRSRV_BRIDGE_PDUMP_DUMPREADREG:
2981                 err = DummyBW(cmd, in, out, per_proc);
2982                 break;
2983         case PVRSRV_BRIDGE_PDUMP_SYNCPOL:
2984                 err = PDumpSyncPolBW(cmd, in, out, per_proc);
2985                 break;
2986         case PVRSRV_BRIDGE_PDUMP_DUMPSYNC:
2987                 err = PDumpSyncDumpBW(cmd, in, out, per_proc);
2988                 break;
2989         case PVRSRV_BRIDGE_PDUMP_DRIVERINFO:
2990                 err = DummyBW(cmd, in, out, per_proc);
2991                 break;
2992         case PVRSRV_BRIDGE_PDUMP_PDREG:
2993                 err = PDumpPDRegBW(cmd, in, out, per_proc);
2994                 break;
2995         case PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR:
2996                 err = PDumpPDDevPAddrBW(cmd, in, out, per_proc);
2997                 break;
2998         case PVRSRV_BRIDGE_PDUMP_CYCLE_COUNT_REG_READ:
2999                 err = PDumpCycleCountRegReadBW(cmd, in, out, per_proc);
3000                 break;
3001         case PVRSRV_BRIDGE_PDUMP_STARTINITPHASE:
3002         case PVRSRV_BRIDGE_PDUMP_STOPINITPHASE:
3003                 err = DummyBW(cmd, in, out, per_proc);
3004                 break;
3005 #endif
3006
3007         case PVRSRV_BRIDGE_GET_OEMJTABLE:
3008                 err = DummyBW(cmd, in, out, per_proc);
3009                 break;
3010
3011         case PVRSRV_BRIDGE_ENUM_CLASS:
3012                 err = PVRSRVEnumerateDCBW(cmd, in, out, per_proc);
3013                 break;
3014
3015         case PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE:
3016                 err = PVRSRVOpenDCDeviceBW(cmd, in, out, per_proc);
3017                 break;
3018         case PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE:
3019                 err = PVRSRVCloseDCDeviceBW(cmd, in, out, per_proc);
3020                 break;
3021         case PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS:
3022                 err = PVRSRVEnumDCFormatsBW(cmd, in, out, per_proc);
3023                 break;
3024         case PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS:
3025                 err = PVRSRVEnumDCDimsBW(cmd, in, out, per_proc);
3026                 break;
3027         case PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER:
3028                 err = PVRSRVGetDCSystemBufferBW(cmd, in, out, per_proc);
3029                 break;
3030         case PVRSRV_BRIDGE_GET_DISPCLASS_INFO:
3031                 err = PVRSRVGetDCInfoBW(cmd, in, out, per_proc);
3032                 break;
3033         case PVRSRV_BRIDGE_CREATE_DISPCLASS_SWAPCHAIN:
3034                 err = PVRSRVCreateDCSwapChainBW(cmd, in, out, per_proc);
3035                 break;
3036         case PVRSRV_BRIDGE_DESTROY_DISPCLASS_SWAPCHAIN:
3037                 err = PVRSRVDestroyDCSwapChainBW(cmd, in, out, per_proc);
3038                 break;
3039         case PVRSRV_BRIDGE_SET_DISPCLASS_DSTRECT:
3040                 err = PVRSRVSetDCDstRectBW(cmd, in, out, per_proc);
3041                 break;
3042         case PVRSRV_BRIDGE_SET_DISPCLASS_SRCRECT:
3043                 err = PVRSRVSetDCSrcRectBW(cmd, in, out, per_proc);
3044                 break;
3045         case PVRSRV_BRIDGE_SET_DISPCLASS_DSTCOLOURKEY:
3046                 err = PVRSRVSetDCDstColourKeyBW(cmd, in, out, per_proc);
3047                 break;
3048         case PVRSRV_BRIDGE_SET_DISPCLASS_SRCCOLOURKEY:
3049                 err = PVRSRVSetDCSrcColourKeyBW(cmd, in, out, per_proc);
3050                 break;
3051         case PVRSRV_BRIDGE_GET_DISPCLASS_BUFFERS:
3052                 err = PVRSRVGetDCBuffersBW(cmd, in, out, per_proc);
3053                 break;
3054         case PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_BUFFER:
3055                 err = PVRSRVSwapToDCBufferBW(cmd, in, out, per_proc);
3056                 break;
3057         case PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_SYSTEM:
3058                 err = PVRSRVSwapToDCSystemBW(cmd, in, out, per_proc);
3059                 break;
3060
3061         case PVRSRV_BRIDGE_OPEN_BUFFERCLASS_DEVICE:
3062                 err = PVRSRVOpenBCDeviceBW(cmd, in, out, per_proc);
3063                 break;
3064         case PVRSRV_BRIDGE_CLOSE_BUFFERCLASS_DEVICE:
3065                 err = PVRSRVCloseBCDeviceBW(cmd, in, out, per_proc);
3066                 break;
3067         case PVRSRV_BRIDGE_GET_BUFFERCLASS_INFO:
3068                 err = PVRSRVGetBCInfoBW(cmd, in, out, per_proc);
3069                 break;
3070         case PVRSRV_BRIDGE_GET_BUFFERCLASS_BUFFER:
3071                 err = PVRSRVGetBCBufferBW(cmd, in, out, per_proc);
3072                 break;
3073
3074         case PVRSRV_BRIDGE_WRAP_EXT_MEMORY:
3075                 err = PVRSRVWrapExtMemoryBW(cmd, in, out, per_proc);
3076                 break;
3077         case PVRSRV_BRIDGE_UNWRAP_EXT_MEMORY:
3078                 err = PVRSRVUnwrapExtMemoryBW(cmd, in, out, per_proc);
3079                 break;
3080
3081         case PVRSRV_BRIDGE_ALLOC_SHARED_SYS_MEM:
3082                 err = PVRSRVAllocSharedSysMemoryBW(cmd, in, out, per_proc);
3083                 break;
3084         case PVRSRV_BRIDGE_FREE_SHARED_SYS_MEM:
3085                 err = PVRSRVFreeSharedSysMemoryBW(cmd, in, out, per_proc);
3086                 break;
3087         case PVRSRV_BRIDGE_MAP_MEMINFO_MEM:
3088                 err = PVRSRVMapMemInfoMemBW(cmd, in, out, per_proc);
3089                 break;
3090
3091         case PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR:
3092                 err = MMU_GetPDDevPAddrBW(cmd, in, out, per_proc);
3093                 break;
3094
3095         case PVRSRV_BRIDGE_INITSRV_CONNECT:
3096                 err = PVRSRVInitSrvConnectBW(cmd, in, out, per_proc);
3097                 break;
3098         case PVRSRV_BRIDGE_INITSRV_DISCONNECT:
3099                 err = PVRSRVInitSrvDisconnectBW(cmd, in, out, per_proc);
3100                 break;
3101
3102         case PVRSRV_BRIDGE_EVENT_OBJECT_WAIT:
3103                 err = PVRSRVEventObjectWaitBW(cmd, in, out, per_proc);
3104                 break;
3105         case PVRSRV_BRIDGE_EVENT_OBJECT_OPEN:
3106                 err = PVRSRVEventObjectOpenBW(cmd, in, out, per_proc);
3107                 break;
3108         case PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE:
3109                 err = PVRSRVEventObjectCloseBW(cmd, in, out, per_proc);
3110                 break;
3111
3112         case PVRSRV_BRIDGE_MODIFY_SYNC_OPS:
3113                 err = PVRSRVModifySyncOpsBW(cmd, in, out, per_proc);
3114                 break;
3115
3116         case PVRSRV_BRIDGE_SGX_GETCLIENTINFO:
3117                 err = SGXGetClientInfoBW(cmd, in, out, per_proc);
3118                 break;
3119         case PVRSRV_BRIDGE_SGX_RELEASECLIENTINFO:
3120                 err = SGXReleaseClientInfoBW(cmd, in, out, per_proc);
3121                 break;
3122         case PVRSRV_BRIDGE_SGX_GETINTERNALDEVINFO:
3123                 err = SGXGetInternalDevInfoBW(cmd, in, out, per_proc);
3124                 break;
3125         case PVRSRV_BRIDGE_SGX_DOKICK:
3126                 err = SGXDoKickBW(cmd, in, out, in_size, per_proc);
3127                 break;
3128
3129         case PVRSRV_BRIDGE_SGX_GETPHYSPAGEADDR:
3130         case PVRSRV_BRIDGE_SGX_READREGISTRYDWORD:
3131         case PVRSRV_BRIDGE_SGX_SCHEDULECOMMAND:
3132                 err = DummyBW(cmd, in, out, per_proc);
3133                 break;
3134
3135         case PVRSRV_BRIDGE_SGX_2DQUERYBLTSCOMPLETE:
3136                 err = SGX2DQueryBlitsCompleteBW(filp, cmd, in, out, per_proc);
3137                 break;
3138
3139         case PVRSRV_BRIDGE_SGX_GETMMUPDADDR:
3140                 err = DummyBW(cmd, in, out, per_proc);
3141                 break;
3142
3143         case PVRSRV_BRIDGE_SGX_SUBMITTRANSFER:
3144                 err = SGXSubmitTransferBW(cmd, in, out, per_proc);
3145                 break;
3146         case PVRSRV_BRIDGE_SGX_GETMISCINFO:
3147                 err = SGXGetMiscInfoBW(cmd, in, out, per_proc);
3148                 break;
3149         case PVRSRV_BRIDGE_SGXINFO_FOR_SRVINIT:
3150                 err = SGXGetInfoForSrvinitBW(cmd, in, out, per_proc);
3151                 break;
3152         case PVRSRV_BRIDGE_SGX_DEVINITPART2:
3153                 err = SGXDevInitPart2BW(cmd, in, out, per_proc);
3154                 break;
3155
3156         case PVRSRV_BRIDGE_SGX_FINDSHAREDPBDESC:
3157                 err = SGXFindSharedPBDescBW(cmd, in, out, per_proc);
3158                 break;
3159         case PVRSRV_BRIDGE_SGX_UNREFSHAREDPBDESC:
3160                 err = SGXUnrefSharedPBDescBW(cmd, in, out, per_proc);
3161                 break;
3162         case PVRSRV_BRIDGE_SGX_ADDSHAREDPBDESC:
3163                 err = SGXAddSharedPBDescBW(cmd, in, out, per_proc);
3164                 break;
3165         case PVRSRV_BRIDGE_SGX_REGISTER_HW_RENDER_CONTEXT:
3166                 err = SGXRegisterHWRenderContextBW(cmd, in, out, per_proc);
3167                 break;
3168         case PVRSRV_BRIDGE_SGX_FLUSH_HW_RENDER_TARGET:
3169                 err = SGXFlushHWRenderTargetBW(cmd, in, out, per_proc);
3170                 break;
3171         case PVRSRV_BRIDGE_SGX_UNREGISTER_HW_RENDER_CONTEXT:
3172                 err = SGXUnregisterHWRenderContextBW(cmd, in, out, per_proc);
3173                 break;
3174         case PVRSRV_BRIDGE_SGX_REGISTER_HW_TRANSFER_CONTEXT:
3175                 err = SGXRegisterHWTransferContextBW(cmd, in, out, per_proc);
3176                 break;
3177         case PVRSRV_BRIDGE_SGX_UNREGISTER_HW_TRANSFER_CONTEXT:
3178                 err = SGXUnregisterHWTransferContextBW(cmd, in, out, per_proc);
3179                 break;
3180
3181         case PVRSRV_BRIDGE_SGX_READ_DIFF_COUNTERS:
3182                 err = SGXReadDiffCountersBW(cmd, in, out, per_proc);
3183                 break;
3184         case PVRSRV_BRIDGE_SGX_READ_HWPERF_CB:
3185                 err = SGXReadHWPerfCBBW(cmd, in, out, per_proc);
3186                 break;
3187
3188         case PVRSRV_BRIDGE_SGX_SCHEDULE_PROCESS_QUEUES:
3189                 err = SGXScheduleProcessQueuesBW(cmd, in, out, per_proc);
3190                 break;
3191
3192 #if defined(PDUMP)
3193         case PVRSRV_BRIDGE_SGX_PDUMP_BUFFER_ARRAY:
3194                 err = SGXPDumpBufferArrayBW(cmd, in, out, per_proc);
3195                 break;
3196         case PVRSRV_BRIDGE_SGX_PDUMP_3D_SIGNATURE_REGISTERS:
3197                 err = SGXPDump3DSignatureRegistersBW(cmd, in, out, per_proc);
3198                 break;
3199         case PVRSRV_BRIDGE_SGX_PDUMP_COUNTER_REGISTERS:
3200                 err = SGXPDumpCounterRegistersBW(cmd, in, out, per_proc);
3201                 break;
3202         case PVRSRV_BRIDGE_SGX_PDUMP_TA_SIGNATURE_REGISTERS:
3203                 err = SGXPDumpTASignatureRegistersBW(cmd, in, out, per_proc);
3204                 break;
3205         case PVRSRV_BRIDGE_SGX_PDUMP_HWPERFCB:
3206                 err = SGXPDumpHWPerfCBBW(cmd, in, out, per_proc);
3207                 break;
3208 #endif
3209
3210         default:
3211                 PVR_DPF(PVR_DBG_ERROR, "%s: cmd = %d is out if range!",
3212                         __func__, cmd);
3213        }
3214
3215        return err;
3216 }
3217
3218 int BridgedDispatchKM(struct file *filp, struct PVRSRV_PER_PROCESS_DATA *pd,
3219                       struct PVRSRV_BRIDGE_PACKAGE *pkg)
3220 {
3221
3222         void *in;
3223         void *out;
3224         u32 bid = pkg->ui32BridgeID;
3225         int err = -EFAULT;
3226         struct SYS_DATA *psSysData;
3227
3228 #if defined(DEBUG_BRIDGE_KM)
3229         g_BridgeDispatchTable[bid].ui32CallCount++;
3230         g_BridgeGlobalStats.ui32IOCTLCount++;
3231 #endif
3232         if (!pd->bInitProcess && bridged_check_cmd(bid))
3233                 goto return_fault;
3234
3235         if (SysAcquireData(&psSysData) != PVRSRV_OK)
3236                 goto return_fault;
3237
3238         in = ((struct ENV_DATA *)psSysData->pvEnvSpecificData)->pvBridgeData;
3239         out = (void *)((u8 *)in + PVRSRV_MAX_BRIDGE_IN_SIZE);
3240
3241         if (pkg->ui32InBufferSize > 0 &&
3242             CopyFromUserWrapper(pd, bid, in, pkg->pvParamIn,
3243                                 pkg->ui32InBufferSize) != PVRSRV_OK)
3244                 goto return_fault;
3245
3246         if (bid >= (BRIDGE_DISPATCH_TABLE_ENTRY_COUNT)) {
3247                 PVR_DPF(PVR_DBG_ERROR,
3248                          "%s: ui32BridgeID = %d is out if range!", __func__,
3249                          bid);
3250                 goto return_fault;
3251         }
3252
3253         err = bridged_ioctl(filp, bid, in, out, pkg->ui32InBufferSize, pd);
3254
3255         if (err < 0)
3256                 goto return_fault;
3257
3258         if (CopyToUserWrapper(pd, bid, pkg->pvParamOut, out,
3259                               pkg->ui32OutBufferSize) != PVRSRV_OK)
3260                 goto return_fault;
3261
3262         err = 0;
3263 return_fault:
3264         ReleaseHandleBatch(pd);
3265         return err;
3266 }