← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/gpu/pvr/bridged_pvr_bridge.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/gpu/pvr/bridged_pvr_bridge.c
1
 
/**********************************************************************
2
 
 *
3
 
 * Copyright (C) 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
 
 
28
 
 
29
 
#include <stddef.h>
30
 
 
31
 
#include "img_defs.h"
32
 
#include "services.h"
33
 
#include "pvr_bridge_km.h"
34
 
#include "pvr_debug.h"
35
 
#include "ra.h"
36
 
#include "pvr_bridge.h"
37
 
#if defined(SUPPORT_SGX)
38
 
#include "sgx_bridge.h"
39
 
#endif
40
 
#if defined(SUPPORT_VGX)
41
 
#include "vgx_bridge.h"
42
 
#endif
43
 
#if defined(SUPPORT_MSVDX)
44
 
#include "msvdx_bridge.h"
45
 
#endif
46
 
#include "perproc.h"
47
 
#include "device.h"
48
 
#include "buffer_manager.h"
49
 
 
50
 
#include "pdump_km.h"
51
 
#include "syscommon.h"
52
 
 
53
 
#include "bridged_pvr_bridge.h"
54
 
#if defined(SUPPORT_SGX)
55
 
#include "bridged_sgx_bridge.h"
56
 
#endif
57
 
#if defined(SUPPORT_VGX)
58
 
#include "bridged_vgx_bridge.h"
59
 
#endif
60
 
#if defined(SUPPORT_MSVDX)
61
 
#include "bridged_msvdx_bridge.h"
62
 
#endif
63
 
 
64
 
#include "env_data.h"
65
 
 
66
 
#if defined (__linux__)
67
 
#include "mmap.h"
68
 
#endif
69
 
 
70
 
 
71
 
#include "srvkm.h"
72
 
 
73
 
PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY g_BridgeDispatchTable[BRIDGE_DISPATCH_TABLE_ENTRY_COUNT];
74
 
 
75
 
#if defined(DEBUG_BRIDGE_KM)
76
 
PVRSRV_BRIDGE_GLOBAL_STATS g_BridgeGlobalStats;
77
 
#endif
78
 
 
79
 
#if defined(PVR_SECURE_HANDLES) || defined (SUPPORT_SID_INTERFACE)
80
 
static IMG_BOOL abSharedDeviceMemHeap[PVRSRV_MAX_CLIENT_HEAPS];
81
 
static IMG_BOOL *pbSharedDeviceMemHeap = abSharedDeviceMemHeap;
82
 
#else
83
 
static IMG_BOOL *pbSharedDeviceMemHeap = (IMG_BOOL*)IMG_NULL;
84
 
#endif
85
 
 
86
 
 
87
 
#if defined(DEBUG_BRIDGE_KM)
88
 
PVRSRV_ERROR
89
 
CopyFromUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData,
90
 
                    IMG_UINT32 ui32BridgeID,
91
 
                    IMG_VOID *pvDest,
92
 
                    IMG_VOID *pvSrc,
93
 
                    IMG_UINT32 ui32Size)
94
 
{
95
 
    g_BridgeDispatchTable[ui32BridgeID].ui32CopyFromUserTotalBytes+=ui32Size;
96
 
    g_BridgeGlobalStats.ui32TotalCopyFromUserBytes+=ui32Size;
97
 
    return OSCopyFromUser(pProcData, pvDest, pvSrc, ui32Size);
98
 
}
99
 
PVRSRV_ERROR
100
 
CopyToUserWrapper(PVRSRV_PER_PROCESS_DATA *pProcData,
101
 
                  IMG_UINT32 ui32BridgeID,
102
 
                  IMG_VOID *pvDest,
103
 
                  IMG_VOID *pvSrc,
104
 
                  IMG_UINT32 ui32Size)
105
 
{
106
 
    g_BridgeDispatchTable[ui32BridgeID].ui32CopyToUserTotalBytes+=ui32Size;
107
 
    g_BridgeGlobalStats.ui32TotalCopyToUserBytes+=ui32Size;
108
 
    return OSCopyToUser(pProcData, pvDest, pvSrc, ui32Size);
109
 
}
110
 
#endif
111
 
 
112
 
 
113
 
static IMG_INT
114
 
PVRSRVEnumerateDevicesBW(IMG_UINT32 ui32BridgeID,
115
 
                         IMG_VOID *psBridgeIn,
116
 
                         PVRSRV_BRIDGE_OUT_ENUMDEVICE *psEnumDeviceOUT,
117
 
                         PVRSRV_PER_PROCESS_DATA *psPerProc)
118
 
{
119
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_DEVICES);
120
 
 
121
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
122
 
    PVR_UNREFERENCED_PARAMETER(psBridgeIn);
123
 
 
124
 
    psEnumDeviceOUT->eError =
125
 
        PVRSRVEnumerateDevicesKM(&psEnumDeviceOUT->ui32NumDevices,
126
 
                                 psEnumDeviceOUT->asDeviceIdentifier);
127
 
 
128
 
    return 0;
129
 
}
130
 
 
131
 
static IMG_INT
132
 
PVRSRVAcquireDeviceDataBW(IMG_UINT32 ui32BridgeID,
133
 
                          PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO *psAcquireDevInfoIN,
134
 
                          PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO *psAcquireDevInfoOUT,
135
 
                          PVRSRV_PER_PROCESS_DATA *psPerProc)
136
 
{
137
 
    IMG_HANDLE hDevCookieInt;
138
 
 
139
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO);
140
 
 
141
 
    psAcquireDevInfoOUT->eError =
142
 
        PVRSRVAcquireDeviceDataKM(psAcquireDevInfoIN->uiDevIndex,
143
 
                                  psAcquireDevInfoIN->eDeviceType,
144
 
                                  &hDevCookieInt);
145
 
    if(psAcquireDevInfoOUT->eError != PVRSRV_OK)
146
 
    {
147
 
        return 0;
148
 
    }
149
 
 
150
 
 
151
 
        psAcquireDevInfoOUT->eError =
152
 
        PVRSRVAllocHandle(psPerProc->psHandleBase,
153
 
                          &psAcquireDevInfoOUT->hDevCookie,
154
 
                          hDevCookieInt,
155
 
                          PVRSRV_HANDLE_TYPE_DEV_NODE,
156
 
                          PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
157
 
 
158
 
    return 0;
159
 
}
160
 
 
161
 
 
162
 
static IMG_INT
163
 
PVRSRVCreateDeviceMemContextBW(IMG_UINT32 ui32BridgeID,
164
 
                               PVRSRV_BRIDGE_IN_CREATE_DEVMEMCONTEXT *psCreateDevMemContextIN,
165
 
                               PVRSRV_BRIDGE_OUT_CREATE_DEVMEMCONTEXT *psCreateDevMemContextOUT,
166
 
                               PVRSRV_PER_PROCESS_DATA *psPerProc)
167
 
{
168
 
    IMG_HANDLE hDevCookieInt;
169
 
    IMG_HANDLE hDevMemContextInt;
170
 
    IMG_UINT32 i;
171
 
    IMG_BOOL bCreated;
172
 
#if defined (SUPPORT_SID_INTERFACE)
173
 
    PVRSRV_HEAP_INFO_KM asHeapInfo[PVRSRV_MAX_CLIENT_HEAPS];
174
 
#endif
175
 
 
176
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT);
177
 
 
178
 
 
179
 
    NEW_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError, psPerProc, PVRSRV_MAX_CLIENT_HEAPS + 1)
180
 
 
181
 
    psCreateDevMemContextOUT->eError =
182
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
183
 
                           psCreateDevMemContextIN->hDevCookie,
184
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
185
 
 
186
 
    if(psCreateDevMemContextOUT->eError != PVRSRV_OK)
187
 
    {
188
 
        return 0;
189
 
    }
190
 
 
191
 
    psCreateDevMemContextOUT->eError =
192
 
        PVRSRVCreateDeviceMemContextKM(hDevCookieInt,
193
 
                                       psPerProc,
194
 
                                       &hDevMemContextInt,
195
 
                                       &psCreateDevMemContextOUT->ui32ClientHeapCount,
196
 
#if defined (SUPPORT_SID_INTERFACE)
197
 
                                       &asHeapInfo[0],
198
 
#else
199
 
                                       &psCreateDevMemContextOUT->sHeapInfo[0],
200
 
#endif
201
 
                                       &bCreated,
202
 
                                       pbSharedDeviceMemHeap);
203
 
 
204
 
    if(psCreateDevMemContextOUT->eError != PVRSRV_OK)
205
 
    {
206
 
        return 0;
207
 
    }
208
 
 
209
 
 
210
 
    if(bCreated)
211
 
    {
212
 
        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
213
 
                          &psCreateDevMemContextOUT->hDevMemContext,
214
 
                          hDevMemContextInt,
215
 
                          PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT,
216
 
                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
217
 
    }
218
 
    else
219
 
    {
220
 
        psCreateDevMemContextOUT->eError =
221
 
            PVRSRVFindHandle(psPerProc->psHandleBase,
222
 
                             &psCreateDevMemContextOUT->hDevMemContext,
223
 
                             hDevMemContextInt,
224
 
                             PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
225
 
        if(psCreateDevMemContextOUT->eError != PVRSRV_OK)
226
 
        {
227
 
            return 0;
228
 
        }
229
 
    }
230
 
 
231
 
    for(i = 0; i < psCreateDevMemContextOUT->ui32ClientHeapCount; i++)
232
 
    {
233
 
#if defined (SUPPORT_SID_INTERFACE)
234
 
        IMG_SID hDevMemHeapExt;
235
 
#else
236
 
        IMG_HANDLE hDevMemHeapExt;
237
 
#endif
238
 
 
239
 
#if defined(PVR_SECURE_HANDLES) || defined (SUPPORT_SID_INTERFACE)
240
 
        if(abSharedDeviceMemHeap[i])
241
 
#endif
242
 
        {
243
 
 
244
 
#if defined (SUPPORT_SID_INTERFACE)
245
 
            PVRSRVAllocHandleNR(psPerProc->psHandleBase,
246
 
                              &hDevMemHeapExt,
247
 
                              asHeapInfo[i].hDevMemHeap,
248
 
                              PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
249
 
                              PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
250
 
#else
251
 
            PVRSRVAllocHandleNR(psPerProc->psHandleBase, &hDevMemHeapExt,
252
 
                              psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap,
253
 
                              PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
254
 
                              PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
255
 
#endif
256
 
        }
257
 
#if defined(PVR_SECURE_HANDLES) || defined (SUPPORT_SID_INTERFACE)
258
 
        else
259
 
        {
260
 
 
261
 
            if(bCreated)
262
 
            {
263
 
#if defined (SUPPORT_SID_INTERFACE)
264
 
                PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
265
 
                                     &hDevMemHeapExt,
266
 
                                     asHeapInfo[i].hDevMemHeap,
267
 
                                     PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
268
 
                                     PVRSRV_HANDLE_ALLOC_FLAG_NONE,
269
 
                                     psCreateDevMemContextOUT->hDevMemContext);
270
 
#else
271
 
                PVRSRVAllocSubHandleNR(psPerProc->psHandleBase, &hDevMemHeapExt,
272
 
                                     psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap,
273
 
                                     PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
274
 
                                     PVRSRV_HANDLE_ALLOC_FLAG_NONE,
275
 
                                     psCreateDevMemContextOUT->hDevMemContext);
276
 
#endif
277
 
            }
278
 
            else
279
 
            {
280
 
                psCreateDevMemContextOUT->eError =
281
 
                    PVRSRVFindHandle(psPerProc->psHandleBase,
282
 
                                     &hDevMemHeapExt,
283
 
#if defined (SUPPORT_SID_INTERFACE)
284
 
                                     asHeapInfo[i].hDevMemHeap,
285
 
#else
286
 
                                   psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap,
287
 
#endif
288
 
                                     PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
289
 
                if(psCreateDevMemContextOUT->eError != PVRSRV_OK)
290
 
                {
291
 
                    return 0;
292
 
                }
293
 
            }
294
 
        }
295
 
#endif
296
 
        psCreateDevMemContextOUT->sHeapInfo[i].hDevMemHeap      = hDevMemHeapExt;
297
 
#if defined (SUPPORT_SID_INTERFACE)
298
 
        psCreateDevMemContextOUT->sHeapInfo[i].ui32HeapID       = asHeapInfo[i].ui32HeapID;
299
 
        psCreateDevMemContextOUT->sHeapInfo[i].sDevVAddrBase    = asHeapInfo[i].sDevVAddrBase;
300
 
        psCreateDevMemContextOUT->sHeapInfo[i].ui32HeapByteSize = asHeapInfo[i].ui32HeapByteSize;
301
 
        psCreateDevMemContextOUT->sHeapInfo[i].ui32Attribs      = asHeapInfo[i].ui32Attribs;
302
 
        psCreateDevMemContextOUT->sHeapInfo[i].ui32XTileStride  = asHeapInfo[i].ui32XTileStride;
303
 
#endif
304
 
    }
305
 
 
306
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psCreateDevMemContextOUT->eError, psPerProc)
307
 
 
308
 
    return 0;
309
 
}
310
 
 
311
 
static IMG_INT
312
 
PVRSRVDestroyDeviceMemContextBW(IMG_UINT32 ui32BridgeID,
313
 
                                PVRSRV_BRIDGE_IN_DESTROY_DEVMEMCONTEXT *psDestroyDevMemContextIN,
314
 
                                PVRSRV_BRIDGE_RETURN *psRetOUT,
315
 
                                PVRSRV_PER_PROCESS_DATA *psPerProc)
316
 
{
317
 
    IMG_HANDLE hDevCookieInt;
318
 
    IMG_HANDLE hDevMemContextInt;
319
 
    IMG_BOOL bDestroyed;
320
 
 
321
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DESTROY_DEVMEMCONTEXT);
322
 
 
323
 
    psRetOUT->eError =
324
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
325
 
                           psDestroyDevMemContextIN->hDevCookie,
326
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
327
 
 
328
 
    if(psRetOUT->eError != PVRSRV_OK)
329
 
    {
330
 
        return 0;
331
 
    }
332
 
 
333
 
    psRetOUT->eError =
334
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
335
 
                           psDestroyDevMemContextIN->hDevMemContext,
336
 
                           PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
337
 
 
338
 
    if(psRetOUT->eError != PVRSRV_OK)
339
 
    {
340
 
        return 0;
341
 
    }
342
 
 
343
 
    psRetOUT->eError =
344
 
        PVRSRVDestroyDeviceMemContextKM(hDevCookieInt, hDevMemContextInt, &bDestroyed);
345
 
 
346
 
    if(psRetOUT->eError != PVRSRV_OK)
347
 
    {
348
 
        return 0;
349
 
    }
350
 
 
351
 
    if(bDestroyed)
352
 
    {
353
 
        psRetOUT->eError =
354
 
            PVRSRVReleaseHandle(psPerProc->psHandleBase,
355
 
                                psDestroyDevMemContextIN->hDevMemContext,
356
 
                                PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
357
 
    }
358
 
 
359
 
    return 0;
360
 
}
361
 
 
362
 
 
363
 
static IMG_INT
364
 
PVRSRVGetDeviceMemHeapInfoBW(IMG_UINT32 ui32BridgeID,
365
 
                               PVRSRV_BRIDGE_IN_GET_DEVMEM_HEAPINFO *psGetDevMemHeapInfoIN,
366
 
                               PVRSRV_BRIDGE_OUT_GET_DEVMEM_HEAPINFO *psGetDevMemHeapInfoOUT,
367
 
                               PVRSRV_PER_PROCESS_DATA *psPerProc)
368
 
{
369
 
    IMG_HANDLE hDevCookieInt;
370
 
    IMG_HANDLE hDevMemContextInt;
371
 
    IMG_UINT32 i;
372
 
#if defined (SUPPORT_SID_INTERFACE)
373
 
    PVRSRV_HEAP_INFO_KM asHeapInfo[PVRSRV_MAX_CLIENT_HEAPS];
374
 
#endif
375
 
 
376
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO);
377
 
 
378
 
    NEW_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc, PVRSRV_MAX_CLIENT_HEAPS)
379
 
 
380
 
    psGetDevMemHeapInfoOUT->eError =
381
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
382
 
                           psGetDevMemHeapInfoIN->hDevCookie,
383
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
384
 
 
385
 
    if(psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
386
 
    {
387
 
        return 0;
388
 
    }
389
 
 
390
 
    psGetDevMemHeapInfoOUT->eError =
391
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
392
 
                           psGetDevMemHeapInfoIN->hDevMemContext,
393
 
                           PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
394
 
 
395
 
    if(psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
396
 
    {
397
 
        return 0;
398
 
    }
399
 
 
400
 
    psGetDevMemHeapInfoOUT->eError =
401
 
        PVRSRVGetDeviceMemHeapInfoKM(hDevCookieInt,
402
 
                                       hDevMemContextInt,
403
 
                                       &psGetDevMemHeapInfoOUT->ui32ClientHeapCount,
404
 
#if defined (SUPPORT_SID_INTERFACE)
405
 
                                       &asHeapInfo[0],
406
 
#else
407
 
                                       &psGetDevMemHeapInfoOUT->sHeapInfo[0],
408
 
#endif
409
 
                                       pbSharedDeviceMemHeap);
410
 
 
411
 
    if(psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
412
 
    {
413
 
        return 0;
414
 
    }
415
 
 
416
 
    for(i = 0; i < psGetDevMemHeapInfoOUT->ui32ClientHeapCount; i++)
417
 
    {
418
 
#if defined (SUPPORT_SID_INTERFACE)
419
 
        IMG_SID hDevMemHeapExt;
420
 
#else
421
 
        IMG_HANDLE hDevMemHeapExt;
422
 
#endif
423
 
 
424
 
#if defined(PVR_SECURE_HANDLES) || defined (SUPPORT_SID_INTERFACE)
425
 
        if(abSharedDeviceMemHeap[i])
426
 
#endif
427
 
        {
428
 
            
429
 
#if defined (SUPPORT_SID_INTERFACE)
430
 
            PVRSRVAllocHandleNR(psPerProc->psHandleBase,
431
 
                                &hDevMemHeapExt,
432
 
                                asHeapInfo[i].hDevMemHeap,
433
 
                                PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
434
 
                                PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
435
 
#else
436
 
            PVRSRVAllocHandleNR(psPerProc->psHandleBase, &hDevMemHeapExt,
437
 
                                psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap,
438
 
                                PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP,
439
 
                                PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
440
 
#endif
441
 
        }
442
 
#if defined(PVR_SECURE_HANDLES) || defined (SUPPORT_SID_INTERFACE)
443
 
        else
444
 
        {
445
 
 
446
 
            psGetDevMemHeapInfoOUT->eError =
447
 
                PVRSRVFindHandle(psPerProc->psHandleBase,
448
 
                                 &hDevMemHeapExt,
449
 
#if defined (SUPPORT_SID_INTERFACE)
450
 
                                 asHeapInfo[i].hDevMemHeap,
451
 
#else
452
 
                                 psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap,
453
 
#endif
454
 
                                 PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
455
 
            if(psGetDevMemHeapInfoOUT->eError != PVRSRV_OK)
456
 
            {
457
 
                return 0;
458
 
            }
459
 
        }
460
 
#endif
461
 
        psGetDevMemHeapInfoOUT->sHeapInfo[i].hDevMemHeap      = hDevMemHeapExt;
462
 
#if defined (SUPPORT_SID_INTERFACE)
463
 
        psGetDevMemHeapInfoOUT->sHeapInfo[i].ui32HeapID       = asHeapInfo[i].ui32HeapID;
464
 
        psGetDevMemHeapInfoOUT->sHeapInfo[i].sDevVAddrBase    = asHeapInfo[i].sDevVAddrBase;
465
 
        psGetDevMemHeapInfoOUT->sHeapInfo[i].ui32HeapByteSize = asHeapInfo[i].ui32HeapByteSize;
466
 
        psGetDevMemHeapInfoOUT->sHeapInfo[i].ui32Attribs      = asHeapInfo[i].ui32Attribs;
467
 
        psGetDevMemHeapInfoOUT->sHeapInfo[i].ui32XTileStride  = asHeapInfo[i].ui32XTileStride;
468
 
#endif
469
 
    }
470
 
 
471
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psGetDevMemHeapInfoOUT->eError, psPerProc)
472
 
 
473
 
    return 0;
474
 
}
475
 
 
476
 
 
477
 
#if defined(OS_PVRSRV_ALLOC_DEVICE_MEM_BW)
478
 
IMG_INT
479
 
PVRSRVAllocDeviceMemBW(IMG_UINT32 ui32BridgeID,
480
 
                       PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM *psAllocDeviceMemIN,
481
 
                       PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM *psAllocDeviceMemOUT,
482
 
                       PVRSRV_PER_PROCESS_DATA *psPerProc);
483
 
#else
484
 
static IMG_INT
485
 
PVRSRVAllocDeviceMemBW(IMG_UINT32 ui32BridgeID,
486
 
                       PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM *psAllocDeviceMemIN,
487
 
                       PVRSRV_BRIDGE_OUT_ALLOCDEVICEMEM *psAllocDeviceMemOUT,
488
 
                       PVRSRV_PER_PROCESS_DATA *psPerProc)
489
 
{
490
 
    PVRSRV_KERNEL_MEM_INFO *psMemInfo;
491
 
    IMG_HANDLE hDevCookieInt;
492
 
    IMG_HANDLE hDevMemHeapInt;
493
 
    IMG_UINT32 ui32ShareIndex;
494
 
    IMG_BOOL bUseShareMemWorkaround;
495
 
 
496
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ALLOC_DEVICEMEM);
497
 
 
498
 
    NEW_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc, 2)
499
 
 
500
 
    psAllocDeviceMemOUT->eError =
501
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
502
 
                           psAllocDeviceMemIN->hDevCookie,
503
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
504
 
 
505
 
    if(psAllocDeviceMemOUT->eError != PVRSRV_OK)
506
 
    {
507
 
        return 0;
508
 
    }
509
 
 
510
 
    psAllocDeviceMemOUT->eError =
511
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemHeapInt,
512
 
                           psAllocDeviceMemIN->hDevMemHeap,
513
 
                           PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
514
 
 
515
 
    if(psAllocDeviceMemOUT->eError != PVRSRV_OK)
516
 
    {
517
 
        return 0;
518
 
    }
519
 
 
520
 
    
521
 
 
522
 
    bUseShareMemWorkaround = ((psAllocDeviceMemIN->ui32Attribs & PVRSRV_MEM_XPROC) != 0) ? IMG_TRUE : IMG_FALSE;
523
 
    ui32ShareIndex = 7654321; 
524
 
 
525
 
    if (bUseShareMemWorkaround)
526
 
    {
527
 
        
528
 
        
529
 
 
530
 
        psAllocDeviceMemOUT->eError =
531
 
            BM_XProcWorkaroundFindNewBufferAndSetShareIndex(&ui32ShareIndex);
532
 
        if(psAllocDeviceMemOUT->eError != PVRSRV_OK)
533
 
        {
534
 
            return 0;
535
 
        }
536
 
    }
537
 
 
538
 
    psAllocDeviceMemOUT->eError =
539
 
        PVRSRVAllocDeviceMemKM(hDevCookieInt,
540
 
                               psPerProc,
541
 
                               hDevMemHeapInt,
542
 
                               psAllocDeviceMemIN->ui32Attribs,
543
 
                               psAllocDeviceMemIN->ui32Size,
544
 
                               psAllocDeviceMemIN->ui32Alignment,
545
 
                               &psMemInfo,
546
 
                               "" );
547
 
 
548
 
    if (bUseShareMemWorkaround)
549
 
    {
550
 
        PVR_ASSERT(ui32ShareIndex != 7654321);
551
 
        BM_XProcWorkaroundUnsetShareIndex(ui32ShareIndex);
552
 
    }
553
 
 
554
 
    if(psAllocDeviceMemOUT->eError != PVRSRV_OK)
555
 
    {
556
 
        return 0;
557
 
    }
558
 
 
559
 
    psMemInfo->sShareMemWorkaround.bInUse = bUseShareMemWorkaround;
560
 
    if (bUseShareMemWorkaround)
561
 
    {
562
 
        PVR_ASSERT(ui32ShareIndex != 7654321);
563
 
        psMemInfo->sShareMemWorkaround.ui32ShareIndex = ui32ShareIndex;
564
 
        psMemInfo->sShareMemWorkaround.hDevCookieInt = hDevCookieInt;
565
 
        psMemInfo->sShareMemWorkaround.ui32OrigReqAttribs = psAllocDeviceMemIN->ui32Attribs;
566
 
        psMemInfo->sShareMemWorkaround.ui32OrigReqSize = (IMG_UINT32)psAllocDeviceMemIN->ui32Size;
567
 
        psMemInfo->sShareMemWorkaround.ui32OrigReqAlignment = (IMG_UINT32)psAllocDeviceMemIN->ui32Alignment;
568
 
    }
569
 
 
570
 
    OSMemSet(&psAllocDeviceMemOUT->sClientMemInfo,
571
 
             0,
572
 
             sizeof(psAllocDeviceMemOUT->sClientMemInfo));
573
 
 
574
 
    psAllocDeviceMemOUT->sClientMemInfo.pvLinAddrKM =
575
 
            psMemInfo->pvLinAddrKM;
576
 
 
577
 
#if defined (__linux__)
578
 
    psAllocDeviceMemOUT->sClientMemInfo.pvLinAddr = 0;
579
 
#else
580
 
    psAllocDeviceMemOUT->sClientMemInfo.pvLinAddr = psMemInfo->pvLinAddrKM;
581
 
#endif
582
 
    psAllocDeviceMemOUT->sClientMemInfo.sDevVAddr = psMemInfo->sDevVAddr;
583
 
    psAllocDeviceMemOUT->sClientMemInfo.ui32Flags = psMemInfo->ui32Flags;
584
 
    psAllocDeviceMemOUT->sClientMemInfo.uAllocSize = psMemInfo->uAllocSize;
585
 
#if defined (SUPPORT_SID_INTERFACE)
586
 
#else
587
 
  psAllocDeviceMemOUT->sClientMemInfo.hMappingInfo = psMemInfo->sMemBlk.hOSMemHandle;
588
 
#endif
589
 
 
590
 
    PVRSRVAllocHandleNR(psPerProc->psHandleBase,
591
 
                      &psAllocDeviceMemOUT->sClientMemInfo.hKernelMemInfo,
592
 
                      psMemInfo,
593
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO,
594
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE);
595
 
 
596
 
 #if defined (SUPPORT_SID_INTERFACE)
597
 
   PVR_ASSERT(psAllocDeviceMemOUT->sClientMemInfo.hKernelMemInfo != 0);
598
 
 
599
 
    if (psMemInfo->sMemBlk.hOSMemHandle != IMG_NULL)
600
 
    {
601
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
602
 
                      &psAllocDeviceMemOUT->sClientMemInfo.hMappingInfo,
603
 
                      psMemInfo->sMemBlk.hOSMemHandle,
604
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO,
605
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE,
606
 
                      psAllocDeviceMemOUT->sClientMemInfo.hKernelMemInfo);
607
 
    }
608
 
    else
609
 
    {
610
 
        psAllocDeviceMemOUT->sClientMemInfo.hMappingInfo = 0;
611
 
    }
612
 
#endif
613
 
 
614
 
    if(psAllocDeviceMemIN->ui32Attribs & PVRSRV_MEM_NO_SYNCOBJ)
615
 
    {
616
 
        
617
 
        OSMemSet(&psAllocDeviceMemOUT->sClientSyncInfo,
618
 
                 0,
619
 
                 sizeof (PVRSRV_CLIENT_SYNC_INFO));
620
 
        psAllocDeviceMemOUT->sClientMemInfo.psClientSyncInfo = IMG_NULL;
621
 
    }
622
 
    else
623
 
    {
624
 
        
625
 
 
626
 
#if !defined(PVRSRV_DISABLE_UM_SYNCOBJ_MAPPINGS)
627
 
        psAllocDeviceMemOUT->sClientSyncInfo.psSyncData =
628
 
            psMemInfo->psKernelSyncInfo->psSyncData;
629
 
        psAllocDeviceMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
630
 
            psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
631
 
        psAllocDeviceMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
632
 
            psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
633
 
 
634
 
#if defined (SUPPORT_SID_INTERFACE)
635
 
        if (psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle != IMG_NULL)
636
 
        {
637
 
                PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
638
 
                                     &psAllocDeviceMemOUT->sClientSyncInfo.hMappingInfo,
639
 
                                     psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle,
640
 
                                     PVRSRV_HANDLE_TYPE_SYNC_INFO,
641
 
                                     PVRSRV_HANDLE_ALLOC_FLAG_NONE,
642
 
                                     psAllocDeviceMemOUT->sClientMemInfo.hKernelMemInfo);
643
 
        }
644
 
        else
645
 
        {
646
 
            psAllocDeviceMemOUT->sClientSyncInfo.hMappingInfo = 0;
647
 
        }
648
 
#else
649
 
        psAllocDeviceMemOUT->sClientSyncInfo.hMappingInfo =
650
 
            psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
651
 
#endif
652
 
#endif
653
 
 
654
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
655
 
                             &psAllocDeviceMemOUT->sClientSyncInfo.hKernelSyncInfo,
656
 
                             psMemInfo->psKernelSyncInfo,
657
 
                             PVRSRV_HANDLE_TYPE_SYNC_INFO,
658
 
                             PVRSRV_HANDLE_ALLOC_FLAG_NONE,
659
 
                             psAllocDeviceMemOUT->sClientMemInfo.hKernelMemInfo);
660
 
 
661
 
        psAllocDeviceMemOUT->sClientMemInfo.psClientSyncInfo =
662
 
            &psAllocDeviceMemOUT->sClientSyncInfo;
663
 
 
664
 
    }
665
 
 
666
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psAllocDeviceMemOUT->eError, psPerProc)
667
 
 
668
 
    return 0;
669
 
}
670
 
 
671
 
#endif 
672
 
 
673
 
static IMG_INT
674
 
PVRSRVFreeDeviceMemBW(IMG_UINT32 ui32BridgeID,
675
 
                      PVRSRV_BRIDGE_IN_FREEDEVICEMEM *psFreeDeviceMemIN,
676
 
                      PVRSRV_BRIDGE_RETURN *psRetOUT,
677
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
678
 
{
679
 
    IMG_HANDLE hDevCookieInt;
680
 
    IMG_VOID *pvKernelMemInfo;
681
 
 
682
 
 
683
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_FREE_DEVICEMEM);
684
 
 
685
 
    psRetOUT->eError =
686
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
687
 
                           psFreeDeviceMemIN->hDevCookie,
688
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
689
 
 
690
 
    if(psRetOUT->eError != PVRSRV_OK)
691
 
    {
692
 
        return 0;
693
 
    }
694
 
 
695
 
    psRetOUT->eError =
696
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
697
 
                           &pvKernelMemInfo,
698
 
#if defined (SUPPORT_SID_INTERFACE)
699
 
                           psFreeDeviceMemIN->hKernelMemInfo,
700
 
#else
701
 
                           psFreeDeviceMemIN->psKernelMemInfo,
702
 
#endif
703
 
                           PVRSRV_HANDLE_TYPE_MEM_INFO);
704
 
 
705
 
    if(psRetOUT->eError != PVRSRV_OK)
706
 
    {
707
 
        return 0;
708
 
    }
709
 
 
710
 
    psRetOUT->eError = PVRSRVFreeDeviceMemKM(hDevCookieInt, pvKernelMemInfo);
711
 
 
712
 
    if(psRetOUT->eError != PVRSRV_OK)
713
 
    {
714
 
        return 0;
715
 
    }
716
 
 
717
 
    psRetOUT->eError =
718
 
        PVRSRVReleaseHandle(psPerProc->psHandleBase,
719
 
#if defined (SUPPORT_SID_INTERFACE)
720
 
                            psFreeDeviceMemIN->hKernelMemInfo,
721
 
#else
722
 
                            psFreeDeviceMemIN->psKernelMemInfo,
723
 
#endif
724
 
                            PVRSRV_HANDLE_TYPE_MEM_INFO);
725
 
 
726
 
    return 0;
727
 
}
728
 
 
729
 
 
730
 
static IMG_INT
731
 
PVRSRVExportDeviceMemBW(IMG_UINT32 ui32BridgeID,
732
 
                      PVRSRV_BRIDGE_IN_EXPORTDEVICEMEM *psExportDeviceMemIN,
733
 
                      PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *psExportDeviceMemOUT,
734
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
735
 
{
736
 
    IMG_HANDLE hDevCookieInt;
737
 
#if defined (SUPPORT_SID_INTERFACE)
738
 
    PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo = IMG_NULL;
739
 
#else
740
 
    PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
741
 
#endif
742
 
 
743
 
    PVR_ASSERT(ui32BridgeID == PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_EXPORT_DEVICEMEM) ||
744
 
               ui32BridgeID == PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_EXPORT_DEVICEMEM_2));
745
 
    PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
746
 
 
747
 
    
748
 
    psExportDeviceMemOUT->eError =
749
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
750
 
                           &hDevCookieInt,
751
 
                           psExportDeviceMemIN->hDevCookie,
752
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
753
 
 
754
 
    if(psExportDeviceMemOUT->eError != PVRSRV_OK)
755
 
    {
756
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVExportDeviceMemBW: can't find devcookie"));
757
 
        return 0;
758
 
    }
759
 
 
760
 
    
761
 
    psExportDeviceMemOUT->eError =
762
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
763
 
                           (IMG_PVOID *)&psKernelMemInfo,
764
 
#if defined (SUPPORT_SID_INTERFACE)
765
 
                           psExportDeviceMemIN->hKernelMemInfo,
766
 
#else
767
 
                           psExportDeviceMemIN->psKernelMemInfo,
768
 
#endif
769
 
                           PVRSRV_HANDLE_TYPE_MEM_INFO);
770
 
 
771
 
    if(psExportDeviceMemOUT->eError != PVRSRV_OK)
772
 
    {
773
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVExportDeviceMemBW: can't find kernel meminfo"));
774
 
        return 0;
775
 
    }
776
 
 
777
 
    
778
 
    psExportDeviceMemOUT->eError =
779
 
        PVRSRVFindHandle(KERNEL_HANDLE_BASE,
780
 
                             &psExportDeviceMemOUT->hMemInfo,
781
 
                             psKernelMemInfo,
782
 
                             PVRSRV_HANDLE_TYPE_MEM_INFO);
783
 
    if(psExportDeviceMemOUT->eError == PVRSRV_OK)
784
 
    {
785
 
        
786
 
        PVR_DPF((PVR_DBG_MESSAGE, "PVRSRVExportDeviceMemBW: allocation is already exported"));
787
 
        return 0;
788
 
    }
789
 
 
790
 
    
791
 
    psExportDeviceMemOUT->eError = PVRSRVAllocHandle(KERNEL_HANDLE_BASE,
792
 
                                                    &psExportDeviceMemOUT->hMemInfo,
793
 
                                                    psKernelMemInfo,
794
 
                                                    PVRSRV_HANDLE_TYPE_MEM_INFO,
795
 
                                                    PVRSRV_HANDLE_ALLOC_FLAG_NONE);
796
 
    if (psExportDeviceMemOUT->eError != PVRSRV_OK)
797
 
    {
798
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVExportDeviceMemBW: failed to allocate handle from global handle list"));
799
 
        return 0;
800
 
    }
801
 
 
802
 
    
803
 
    psKernelMemInfo->ui32Flags |= PVRSRV_MEM_EXPORTED;
804
 
 
805
 
    return 0;
806
 
}
807
 
 
808
 
 
809
 
static IMG_INT
810
 
PVRSRVMapDeviceMemoryBW(IMG_UINT32 ui32BridgeID,
811
 
                             PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *psMapDevMemIN,
812
 
                             PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *psMapDevMemOUT,
813
 
                             PVRSRV_PER_PROCESS_DATA *psPerProc)
814
 
{
815
 
    PVRSRV_KERNEL_MEM_INFO  *psSrcKernelMemInfo = IMG_NULL;
816
 
    PVRSRV_KERNEL_MEM_INFO  *psDstKernelMemInfo = IMG_NULL;
817
 
    IMG_HANDLE              hDstDevMemHeap = IMG_NULL;
818
 
 
819
 
    PVR_ASSERT(ui32BridgeID == PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_MAP_DEV_MEMORY) ||
820
 
               ui32BridgeID == PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_MAP_DEV_MEMORY_2));
821
 
    PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
822
 
 
823
 
    NEW_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc, 2)
824
 
 
825
 
 
826
 
    psMapDevMemOUT->eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
827
 
                                                (IMG_VOID**)&psSrcKernelMemInfo,
828
 
                                                psMapDevMemIN->hKernelMemInfo,
829
 
                                                PVRSRV_HANDLE_TYPE_MEM_INFO);
830
 
    if(psMapDevMemOUT->eError != PVRSRV_OK)
831
 
    {
832
 
        return 0;
833
 
    }
834
 
 
835
 
 
836
 
    psMapDevMemOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
837
 
                                                &hDstDevMemHeap,
838
 
                                                psMapDevMemIN->hDstDevMemHeap,
839
 
                                                PVRSRV_HANDLE_TYPE_DEV_MEM_HEAP);
840
 
    if(psMapDevMemOUT->eError != PVRSRV_OK)
841
 
    {
842
 
        return 0;
843
 
    }
844
 
 
845
 
    
846
 
    if (psSrcKernelMemInfo->sShareMemWorkaround.bInUse)
847
 
    {
848
 
        PVR_DPF((PVR_DBG_MESSAGE, "using the mem wrap workaround."));
849
 
 
850
 
 
851
 
 
852
 
 
853
 
 
854
 
 
855
 
 
856
 
 
857
 
 
858
 
        psMapDevMemOUT->eError = BM_XProcWorkaroundSetShareIndex(psSrcKernelMemInfo->sShareMemWorkaround.ui32ShareIndex);
859
 
        if(psMapDevMemOUT->eError != PVRSRV_OK)
860
 
        {
861
 
            PVR_DPF((PVR_DBG_ERROR, "PVRSRVMapDeviceMemoryBW(): failed to recycle shared buffer"));
862
 
            return 0;
863
 
        }
864
 
 
865
 
        psMapDevMemOUT->eError =
866
 
            PVRSRVAllocDeviceMemKM(psSrcKernelMemInfo->sShareMemWorkaround.hDevCookieInt,
867
 
                                   psPerProc,
868
 
                                   hDstDevMemHeap,
869
 
                                   psSrcKernelMemInfo->sShareMemWorkaround.ui32OrigReqAttribs | PVRSRV_MEM_NO_SYNCOBJ,
870
 
                                   psSrcKernelMemInfo->sShareMemWorkaround.ui32OrigReqSize,
871
 
                                   psSrcKernelMemInfo->sShareMemWorkaround.ui32OrigReqAlignment,
872
 
                                   &psDstKernelMemInfo,
873
 
                                   "" );
874
 
        
875
 
 
876
 
        BM_XProcWorkaroundUnsetShareIndex(psSrcKernelMemInfo->sShareMemWorkaround.ui32ShareIndex);
877
 
        if(psMapDevMemOUT->eError != PVRSRV_OK)
878
 
        {
879
 
            PVR_DPF((PVR_DBG_ERROR, "lakjgfgewjlrgebhe"));
880
 
            return 0;
881
 
        }
882
 
 
883
 
        if(psSrcKernelMemInfo->psKernelSyncInfo)
884
 
        {
885
 
            psSrcKernelMemInfo->psKernelSyncInfo->ui32RefCount++;
886
 
        }
887
 
 
888
 
        psDstKernelMemInfo->psKernelSyncInfo = psSrcKernelMemInfo->psKernelSyncInfo;
889
 
    }
890
 
    else
891
 
    {
892
 
    
893
 
    psMapDevMemOUT->eError = PVRSRVMapDeviceMemoryKM(psPerProc,
894
 
                                                  psSrcKernelMemInfo,
895
 
                                                  hDstDevMemHeap,
896
 
                                                  &psDstKernelMemInfo);
897
 
    if(psMapDevMemOUT->eError != PVRSRV_OK)
898
 
    {
899
 
        return 0;
900
 
    }
901
 
    }
902
 
 
903
 
    
904
 
    psDstKernelMemInfo->sShareMemWorkaround = psSrcKernelMemInfo->sShareMemWorkaround;
905
 
 
906
 
    OSMemSet(&psMapDevMemOUT->sDstClientMemInfo,
907
 
             0,
908
 
             sizeof(psMapDevMemOUT->sDstClientMemInfo));
909
 
    OSMemSet(&psMapDevMemOUT->sDstClientSyncInfo,
910
 
             0,
911
 
             sizeof(psMapDevMemOUT->sDstClientSyncInfo));
912
 
 
913
 
    psMapDevMemOUT->sDstClientMemInfo.pvLinAddrKM =
914
 
            psDstKernelMemInfo->pvLinAddrKM;
915
 
 
916
 
    psMapDevMemOUT->sDstClientMemInfo.pvLinAddr = 0;
917
 
    psMapDevMemOUT->sDstClientMemInfo.sDevVAddr = psDstKernelMemInfo->sDevVAddr;
918
 
    psMapDevMemOUT->sDstClientMemInfo.ui32Flags = psDstKernelMemInfo->ui32Flags;
919
 
    psMapDevMemOUT->sDstClientMemInfo.uAllocSize = psDstKernelMemInfo->uAllocSize;
920
 
#if defined (SUPPORT_SID_INTERFACE)
921
 
#else
922
 
    psMapDevMemOUT->sDstClientMemInfo.hMappingInfo = psDstKernelMemInfo->sMemBlk.hOSMemHandle;
923
 
#endif
924
 
 
925
 
    
926
 
    PVRSRVAllocHandleNR(psPerProc->psHandleBase,
927
 
                      &psMapDevMemOUT->sDstClientMemInfo.hKernelMemInfo,
928
 
                      psDstKernelMemInfo,
929
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO,
930
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE);
931
 
    psMapDevMemOUT->sDstClientSyncInfo.hKernelSyncInfo = IMG_NULL;
932
 
 
933
 
#if defined (SUPPORT_SID_INTERFACE)
934
 
    
935
 
    if (psDstKernelMemInfo->sMemBlk.hOSMemHandle != IMG_NULL)
936
 
    {
937
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
938
 
                      &psMapDevMemOUT->sDstClientMemInfo.hMappingInfo,
939
 
                      psDstKernelMemInfo->sMemBlk.hOSMemHandle,
940
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO,
941
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE,
942
 
                      psMapDevMemOUT->sDstClientMemInfo.hKernelMemInfo);
943
 
    }
944
 
    else
945
 
    {
946
 
        psMapDevMemOUT->sDstClientMemInfo.hMappingInfo = 0;
947
 
    }
948
 
#endif
949
 
 
950
 
    
951
 
    if(psDstKernelMemInfo->psKernelSyncInfo)
952
 
    {
953
 
#if !defined(PVRSRV_DISABLE_UM_SYNCOBJ_MAPPINGS)
954
 
        psMapDevMemOUT->sDstClientSyncInfo.psSyncData =
955
 
            psDstKernelMemInfo->psKernelSyncInfo->psSyncData;
956
 
        psMapDevMemOUT->sDstClientSyncInfo.sWriteOpsCompleteDevVAddr =
957
 
            psDstKernelMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
958
 
        psMapDevMemOUT->sDstClientSyncInfo.sReadOpsCompleteDevVAddr =
959
 
            psDstKernelMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
960
 
 
961
 
#if defined (SUPPORT_SID_INTERFACE)
962
 
        
963
 
        if (psDstKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle != IMG_NULL)
964
 
        {
965
 
            PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
966
 
                          &psMapDevMemOUT->sDstClientSyncInfo.hMappingInfo,
967
 
                          psDstKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle,
968
 
                          PVRSRV_HANDLE_TYPE_MEM_INFO,
969
 
                          PVRSRV_HANDLE_ALLOC_FLAG_NONE,
970
 
                          psMapDevMemOUT->sDstClientMemInfo.hKernelMemInfo);
971
 
        }
972
 
        else
973
 
        {
974
 
            psMapDevMemOUT->sDstClientSyncInfo.hMappingInfo = 0;
975
 
        }
976
 
#else
977
 
      psMapDevMemOUT->sDstClientSyncInfo.hMappingInfo =
978
 
          psDstKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
979
 
#endif
980
 
#endif
981
 
 
982
 
        psMapDevMemOUT->sDstClientMemInfo.psClientSyncInfo = &psMapDevMemOUT->sDstClientSyncInfo;
983
 
        
984
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
985
 
                      &psMapDevMemOUT->sDstClientSyncInfo.hKernelSyncInfo,
986
 
                      psDstKernelMemInfo->psKernelSyncInfo,
987
 
                      PVRSRV_HANDLE_TYPE_SYNC_INFO,
988
 
                      PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
989
 
                      psMapDevMemOUT->sDstClientMemInfo.hKernelMemInfo);
990
 
    }
991
 
 
992
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevMemOUT->eError, psPerProc)
993
 
 
994
 
    return 0;
995
 
}
996
 
 
997
 
 
998
 
static IMG_INT
999
 
PVRSRVUnmapDeviceMemoryBW(IMG_UINT32 ui32BridgeID,
1000
 
                             PVRSRV_BRIDGE_IN_UNMAP_DEV_MEMORY *psUnmapDevMemIN,
1001
 
                             PVRSRV_BRIDGE_RETURN *psRetOUT,
1002
 
                             PVRSRV_PER_PROCESS_DATA *psPerProc)
1003
 
{
1004
 
    PVRSRV_KERNEL_MEM_INFO  *psKernelMemInfo = IMG_NULL;
1005
 
 
1006
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_UNMAP_DEV_MEMORY);
1007
 
 
1008
 
    psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
1009
 
                                            (IMG_VOID**)&psKernelMemInfo,
1010
 
#if defined (SUPPORT_SID_INTERFACE)
1011
 
                                            psUnmapDevMemIN->hKernelMemInfo,
1012
 
#else
1013
 
                                            psUnmapDevMemIN->psKernelMemInfo,
1014
 
#endif
1015
 
                                            PVRSRV_HANDLE_TYPE_MEM_INFO);
1016
 
    if(psRetOUT->eError != PVRSRV_OK)
1017
 
    {
1018
 
        return 0;
1019
 
    }
1020
 
 
1021
 
    if (psKernelMemInfo->sShareMemWorkaround.bInUse)
1022
 
    {
1023
 
        psRetOUT->eError = PVRSRVFreeDeviceMemKM(psKernelMemInfo->sShareMemWorkaround.hDevCookieInt, psKernelMemInfo);
1024
 
        if(psRetOUT->eError != PVRSRV_OK)
1025
 
        {
1026
 
            PVR_DPF((PVR_DBG_ERROR, "PVRSRVUnmapDeviceMemoryBW: internal error, should expect FreeDeviceMem to fail"));
1027
 
            return 0;
1028
 
        }
1029
 
    }
1030
 
    else
1031
 
    {
1032
 
        psRetOUT->eError = PVRSRVUnmapDeviceMemoryKM(psKernelMemInfo);
1033
 
        if(psRetOUT->eError != PVRSRV_OK)
1034
 
        {
1035
 
            return 0;
1036
 
        }
1037
 
    }
1038
 
 
1039
 
    psRetOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
1040
 
#if defined (SUPPORT_SID_INTERFACE)
1041
 
                            psUnmapDevMemIN->hKernelMemInfo,
1042
 
#else
1043
 
                            psUnmapDevMemIN->psKernelMemInfo,
1044
 
#endif
1045
 
                            PVRSRV_HANDLE_TYPE_MEM_INFO);
1046
 
 
1047
 
    return 0;
1048
 
}
1049
 
 
1050
 
 
1051
 
 
1052
 
static IMG_INT
1053
 
PVRSRVMapDeviceClassMemoryBW(IMG_UINT32 ui32BridgeID,
1054
 
                             PVRSRV_BRIDGE_IN_MAP_DEVICECLASS_MEMORY *psMapDevClassMemIN,
1055
 
                             PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *psMapDevClassMemOUT,
1056
 
                             PVRSRV_PER_PROCESS_DATA *psPerProc)
1057
 
{
1058
 
    PVRSRV_KERNEL_MEM_INFO *psMemInfo;
1059
 
    IMG_HANDLE hOSMapInfo;
1060
 
    IMG_HANDLE hDeviceClassBufferInt;
1061
 
    IMG_HANDLE hDevMemContextInt;
1062
 
    PVRSRV_HANDLE_TYPE eHandleType;
1063
 
 
1064
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY);
1065
 
 
1066
 
    NEW_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc, 2)
1067
 
 
1068
 
    
1069
 
    psMapDevClassMemOUT->eError =
1070
 
        PVRSRVLookupHandleAnyType(psPerProc->psHandleBase,
1071
 
                                  &hDeviceClassBufferInt,
1072
 
                                  &eHandleType,
1073
 
                                  psMapDevClassMemIN->hDeviceClassBuffer);
1074
 
 
1075
 
    if(psMapDevClassMemOUT->eError != PVRSRV_OK)
1076
 
    {
1077
 
        return 0;
1078
 
    }
1079
 
 
1080
 
    
1081
 
    psMapDevClassMemOUT->eError =
1082
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1083
 
                           &hDevMemContextInt,
1084
 
                           psMapDevClassMemIN->hDevMemContext,
1085
 
                           PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
1086
 
 
1087
 
    if(psMapDevClassMemOUT->eError != PVRSRV_OK)
1088
 
    {
1089
 
        return 0;
1090
 
    }
1091
 
 
1092
 
    
1093
 
    switch(eHandleType)
1094
 
    {
1095
 
#if defined(PVR_SECURE_HANDLES) || defined (SUPPORT_SID_INTERFACE)
1096
 
       case PVRSRV_HANDLE_TYPE_DISP_BUFFER:
1097
 
        case PVRSRV_HANDLE_TYPE_BUF_BUFFER:
1098
 
#else
1099
 
        case PVRSRV_HANDLE_TYPE_NONE:
1100
 
#endif
1101
 
            break;
1102
 
        default:
1103
 
            psMapDevClassMemOUT->eError = PVRSRV_ERROR_INVALID_HANDLE_TYPE;
1104
 
            return 0;
1105
 
    }
1106
 
 
1107
 
    psMapDevClassMemOUT->eError =
1108
 
        PVRSRVMapDeviceClassMemoryKM(psPerProc,
1109
 
                                     hDevMemContextInt,
1110
 
                                     hDeviceClassBufferInt,
1111
 
                                     &psMemInfo,
1112
 
                                     &hOSMapInfo);
1113
 
    if(psMapDevClassMemOUT->eError != PVRSRV_OK)
1114
 
    {
1115
 
        return 0;
1116
 
    }
1117
 
 
1118
 
    OSMemSet(&psMapDevClassMemOUT->sClientMemInfo,
1119
 
             0,
1120
 
             sizeof(psMapDevClassMemOUT->sClientMemInfo));
1121
 
    OSMemSet(&psMapDevClassMemOUT->sClientSyncInfo,
1122
 
             0,
1123
 
             sizeof(psMapDevClassMemOUT->sClientSyncInfo));
1124
 
 
1125
 
    psMapDevClassMemOUT->sClientMemInfo.pvLinAddrKM =
1126
 
            psMemInfo->pvLinAddrKM;
1127
 
 
1128
 
    psMapDevClassMemOUT->sClientMemInfo.pvLinAddr = 0;
1129
 
    psMapDevClassMemOUT->sClientMemInfo.sDevVAddr = psMemInfo->sDevVAddr;
1130
 
    psMapDevClassMemOUT->sClientMemInfo.ui32Flags = psMemInfo->ui32Flags;
1131
 
    psMapDevClassMemOUT->sClientMemInfo.uAllocSize = psMemInfo->uAllocSize;
1132
 
#if defined (SUPPORT_SID_INTERFACE)
1133
 
    if (psMemInfo->sMemBlk.hOSMemHandle != 0)
1134
 
    {
1135
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1136
 
                      &psMapDevClassMemOUT->sClientMemInfo.hMappingInfo,
1137
 
                      psMemInfo->sMemBlk.hOSMemHandle,
1138
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO,
1139
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE,
1140
 
                      psMapDevClassMemIN->hDeviceClassBuffer);
1141
 
    }
1142
 
    else
1143
 
    {
1144
 
         psMapDevClassMemOUT->sClientMemInfo.hMappingInfo = 0;
1145
 
    }
1146
 
#else
1147
 
  psMapDevClassMemOUT->sClientMemInfo.hMappingInfo = psMemInfo->sMemBlk.hOSMemHandle;
1148
 
#endif
1149
 
 
1150
 
    PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1151
 
                      &psMapDevClassMemOUT->sClientMemInfo.hKernelMemInfo,
1152
 
                      psMemInfo,
1153
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO,
1154
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE,
1155
 
                      psMapDevClassMemIN->hDeviceClassBuffer);
1156
 
 
1157
 
    psMapDevClassMemOUT->sClientSyncInfo.hKernelSyncInfo = IMG_NULL;
1158
 
 
1159
 
    
1160
 
    if(psMemInfo->psKernelSyncInfo)
1161
 
    {
1162
 
#if !defined(PVRSRV_DISABLE_UM_SYNCOBJ_MAPPINGS)
1163
 
        psMapDevClassMemOUT->sClientSyncInfo.psSyncData =
1164
 
            psMemInfo->psKernelSyncInfo->psSyncData;
1165
 
        psMapDevClassMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
1166
 
            psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
1167
 
        psMapDevClassMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
1168
 
            psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
1169
 
 
1170
 
#if defined (SUPPORT_SID_INTERFACE)
1171
 
       if (psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle != 0)
1172
 
        {
1173
 
            PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1174
 
                              &psMapDevClassMemOUT->sClientSyncInfo.hMappingInfo,
1175
 
                              psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle,
1176
 
                              PVRSRV_HANDLE_TYPE_SYNC_INFO,
1177
 
                              PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
1178
 
                              psMapDevClassMemOUT->sClientMemInfo.hKernelMemInfo);
1179
 
        }
1180
 
        else
1181
 
        {
1182
 
            psMapDevClassMemOUT->sClientSyncInfo.hMappingInfo = 0;
1183
 
        }
1184
 
#else
1185
 
      psMapDevClassMemOUT->sClientSyncInfo.hMappingInfo =
1186
 
          psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
1187
 
#endif
1188
 
#endif
1189
 
 
1190
 
        psMapDevClassMemOUT->sClientMemInfo.psClientSyncInfo = &psMapDevClassMemOUT->sClientSyncInfo;
1191
 
        
1192
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1193
 
                          &psMapDevClassMemOUT->sClientSyncInfo.hKernelSyncInfo,
1194
 
                          psMemInfo->psKernelSyncInfo,
1195
 
                          PVRSRV_HANDLE_TYPE_SYNC_INFO,
1196
 
                          PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
1197
 
                          psMapDevClassMemOUT->sClientMemInfo.hKernelMemInfo);
1198
 
    }
1199
 
 
1200
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psMapDevClassMemOUT->eError, psPerProc)
1201
 
 
1202
 
    return 0;
1203
 
}
1204
 
 
1205
 
static IMG_INT
1206
 
PVRSRVUnmapDeviceClassMemoryBW(IMG_UINT32 ui32BridgeID,
1207
 
                               PVRSRV_BRIDGE_IN_UNMAP_DEVICECLASS_MEMORY *psUnmapDevClassMemIN,
1208
 
                               PVRSRV_BRIDGE_RETURN *psRetOUT,
1209
 
                               PVRSRV_PER_PROCESS_DATA *psPerProc)
1210
 
{
1211
 
    IMG_VOID *pvKernelMemInfo;
1212
 
 
1213
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_UNMAP_DEVICECLASS_MEMORY);
1214
 
 
1215
 
    psRetOUT->eError =
1216
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &pvKernelMemInfo,
1217
 
#if defined (SUPPORT_SID_INTERFACE)
1218
 
                           psUnmapDevClassMemIN->hKernelMemInfo,
1219
 
#else
1220
 
                           psUnmapDevClassMemIN->psKernelMemInfo,
1221
 
#endif
1222
 
                           PVRSRV_HANDLE_TYPE_MEM_INFO);
1223
 
    if(psRetOUT->eError != PVRSRV_OK)
1224
 
    {
1225
 
        return 0;
1226
 
    }
1227
 
 
1228
 
    psRetOUT->eError = PVRSRVUnmapDeviceClassMemoryKM(pvKernelMemInfo);
1229
 
 
1230
 
    if(psRetOUT->eError != PVRSRV_OK)
1231
 
    {
1232
 
        return 0;
1233
 
    }
1234
 
 
1235
 
    psRetOUT->eError =
1236
 
        PVRSRVReleaseHandle(psPerProc->psHandleBase,
1237
 
#if defined (SUPPORT_SID_INTERFACE)
1238
 
                            psUnmapDevClassMemIN->hKernelMemInfo,
1239
 
#else
1240
 
                            psUnmapDevClassMemIN->psKernelMemInfo,
1241
 
#endif
1242
 
                            PVRSRV_HANDLE_TYPE_MEM_INFO);
1243
 
 
1244
 
    return 0;
1245
 
}
1246
 
 
1247
 
 
1248
 
#if defined(OS_PVRSRV_WRAP_EXT_MEM_BW)
1249
 
IMG_INT
1250
 
PVRSRVWrapExtMemoryBW(IMG_UINT32 ui32BridgeID,
1251
 
                      PVRSRV_BRIDGE_IN_WRAP_EXT_MEMORY *psWrapExtMemIN,
1252
 
                      PVRSRV_BRIDGE_OUT_WRAP_EXT_MEMORY *psWrapExtMemOUT,
1253
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc);
1254
 
#else 
1255
 
static IMG_INT
1256
 
PVRSRVWrapExtMemoryBW(IMG_UINT32 ui32BridgeID,
1257
 
                      PVRSRV_BRIDGE_IN_WRAP_EXT_MEMORY *psWrapExtMemIN,
1258
 
                      PVRSRV_BRIDGE_OUT_WRAP_EXT_MEMORY *psWrapExtMemOUT,
1259
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
1260
 
{
1261
 
    IMG_HANDLE hDevCookieInt;
1262
 
    IMG_HANDLE hDevMemContextInt;
1263
 
    PVRSRV_KERNEL_MEM_INFO *psMemInfo;
1264
 
    IMG_SYS_PHYADDR *psSysPAddr = IMG_NULL;
1265
 
        IMG_UINT32 ui32PageTableSize = 0;
1266
 
 
1267
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_WRAP_EXT_MEMORY);
1268
 
 
1269
 
    NEW_HANDLE_BATCH_OR_ERROR(psWrapExtMemOUT->eError, psPerProc, 2)
1270
 
 
1271
 
    
1272
 
    psWrapExtMemOUT->eError =
1273
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevCookieInt,
1274
 
                           psWrapExtMemIN->hDevCookie,
1275
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
1276
 
    if(psWrapExtMemOUT->eError != PVRSRV_OK)
1277
 
    {
1278
 
        return 0;
1279
 
    }
1280
 
 
1281
 
    
1282
 
    psWrapExtMemOUT->eError =
1283
 
    PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
1284
 
                   psWrapExtMemIN->hDevMemContext,
1285
 
                   PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
1286
 
 
1287
 
    if(psWrapExtMemOUT->eError != PVRSRV_OK)
1288
 
    {
1289
 
        return 0;
1290
 
    }
1291
 
 
1292
 
    if(psWrapExtMemIN->ui32NumPageTableEntries)
1293
 
    {
1294
 
        ui32PageTableSize = psWrapExtMemIN->ui32NumPageTableEntries
1295
 
                        * sizeof(IMG_SYS_PHYADDR);
1296
 
 
1297
 
        ASSIGN_AND_EXIT_ON_ERROR(psWrapExtMemOUT->eError,
1298
 
                  OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
1299
 
                  ui32PageTableSize,
1300
 
                  (IMG_VOID **)&psSysPAddr, 0,
1301
 
                  "Page Table"));
1302
 
 
1303
 
        if(CopyFromUserWrapper(psPerProc,
1304
 
                               ui32BridgeID,
1305
 
                               psSysPAddr,
1306
 
                               psWrapExtMemIN->psSysPAddr,
1307
 
                               ui32PageTableSize) != PVRSRV_OK)
1308
 
        {
1309
 
            OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,  ui32PageTableSize, (IMG_VOID *)psSysPAddr, 0);
1310
 
            
1311
 
            return -EFAULT;
1312
 
        }
1313
 
    }
1314
 
 
1315
 
    psWrapExtMemOUT->eError =
1316
 
        PVRSRVWrapExtMemoryKM(hDevCookieInt,
1317
 
                              psPerProc,
1318
 
                              hDevMemContextInt,
1319
 
                              psWrapExtMemIN->ui32ByteSize,
1320
 
                              psWrapExtMemIN->ui32PageOffset,
1321
 
                              psWrapExtMemIN->bPhysContig,
1322
 
                              psSysPAddr,
1323
 
                              psWrapExtMemIN->pvLinAddr,
1324
 
                              psWrapExtMemIN->ui32Flags,
1325
 
                              &psMemInfo);
1326
 
 
1327
 
    if(psWrapExtMemIN->ui32NumPageTableEntries)
1328
 
    {
1329
 
        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
1330
 
              ui32PageTableSize,
1331
 
              (IMG_VOID *)psSysPAddr, 0);
1332
 
        
1333
 
    }
1334
 
 
1335
 
    if(psWrapExtMemOUT->eError != PVRSRV_OK)
1336
 
    {
1337
 
        return 0;
1338
 
    }
1339
 
 
1340
 
    psWrapExtMemOUT->sClientMemInfo.pvLinAddrKM =
1341
 
            psMemInfo->pvLinAddrKM;
1342
 
 
1343
 
    
1344
 
    psWrapExtMemOUT->sClientMemInfo.pvLinAddr = 0;
1345
 
    psWrapExtMemOUT->sClientMemInfo.sDevVAddr = psMemInfo->sDevVAddr;
1346
 
    psWrapExtMemOUT->sClientMemInfo.ui32Flags = psMemInfo->ui32Flags;
1347
 
    psWrapExtMemOUT->sClientMemInfo.uAllocSize = psMemInfo->uAllocSize;
1348
 
#if defined (SUPPORT_SID_INTERFACE)
1349
 
#else
1350
 
    psWrapExtMemOUT->sClientMemInfo.hMappingInfo = psMemInfo->sMemBlk.hOSMemHandle;
1351
 
#endif
1352
 
 
1353
 
    PVRSRVAllocHandleNR(psPerProc->psHandleBase,
1354
 
                      &psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo,
1355
 
                      psMemInfo,
1356
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO,
1357
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE);
1358
 
 
1359
 
#if defined (SUPPORT_SID_INTERFACE)
1360
 
    
1361
 
    if (psMemInfo->sMemBlk.hOSMemHandle != IMG_NULL)
1362
 
    {
1363
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1364
 
                      &psWrapExtMemOUT->sClientMemInfo.hMappingInfo,
1365
 
                      psMemInfo->sMemBlk.hOSMemHandle,
1366
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO,
1367
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE,
1368
 
                      psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo);
1369
 
    }
1370
 
    else
1371
 
    {
1372
 
        psWrapExtMemOUT->sClientMemInfo.hMappingInfo = 0;
1373
 
    }
1374
 
#endif
1375
 
 
1376
 
    
1377
 
#if !defined(PVRSRV_DISABLE_UM_SYNCOBJ_MAPPINGS)
1378
 
    psWrapExtMemOUT->sClientSyncInfo.psSyncData =
1379
 
        psMemInfo->psKernelSyncInfo->psSyncData;
1380
 
    psWrapExtMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
1381
 
        psMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
1382
 
    psWrapExtMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
1383
 
        psMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
1384
 
 
1385
 
#if defined (SUPPORT_SID_INTERFACE)
1386
 
    
1387
 
    if (psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle != IMG_NULL)
1388
 
    {
1389
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1390
 
                      &psWrapExtMemOUT->sClientSyncInfo.hMappingInfo,
1391
 
                      psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle,
1392
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO,
1393
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE,
1394
 
                      psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo);
1395
 
    }
1396
 
    else
1397
 
    {
1398
 
        psWrapExtMemOUT->sClientSyncInfo.hMappingInfo = 0;
1399
 
    }
1400
 
#else
1401
 
    psWrapExtMemOUT->sClientSyncInfo.hMappingInfo =
1402
 
        psMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
1403
 
#endif
1404
 
#endif
1405
 
 
1406
 
    psWrapExtMemOUT->sClientMemInfo.psClientSyncInfo = &psWrapExtMemOUT->sClientSyncInfo;
1407
 
 
1408
 
    PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
1409
 
                      &psWrapExtMemOUT->sClientSyncInfo.hKernelSyncInfo,
1410
 
                      (IMG_HANDLE)psMemInfo->psKernelSyncInfo,
1411
 
                      PVRSRV_HANDLE_TYPE_SYNC_INFO,
1412
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE,
1413
 
                      psWrapExtMemOUT->sClientMemInfo.hKernelMemInfo);
1414
 
 
1415
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psWrapExtMemOUT->eError, psPerProc)
1416
 
 
1417
 
    return 0;
1418
 
}
1419
 
#endif 
1420
 
 
1421
 
static IMG_INT
1422
 
PVRSRVUnwrapExtMemoryBW(IMG_UINT32 ui32BridgeID,
1423
 
                        PVRSRV_BRIDGE_IN_UNWRAP_EXT_MEMORY *psUnwrapExtMemIN,
1424
 
                        PVRSRV_BRIDGE_RETURN *psRetOUT,
1425
 
                        PVRSRV_PER_PROCESS_DATA *psPerProc)
1426
 
{
1427
 
    IMG_VOID *pvMemInfo;
1428
 
 
1429
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_UNWRAP_EXT_MEMORY);
1430
 
 
1431
 
    psRetOUT->eError =
1432
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1433
 
                           &pvMemInfo,
1434
 
                           psUnwrapExtMemIN->hKernelMemInfo,
1435
 
                           PVRSRV_HANDLE_TYPE_MEM_INFO);
1436
 
    if(psRetOUT->eError != PVRSRV_OK)
1437
 
    {
1438
 
        return 0;
1439
 
    }
1440
 
 
1441
 
    psRetOUT->eError =
1442
 
        PVRSRVUnwrapExtMemoryKM((PVRSRV_KERNEL_MEM_INFO *)pvMemInfo);
1443
 
    if(psRetOUT->eError != PVRSRV_OK)
1444
 
    {
1445
 
        return 0;
1446
 
    }
1447
 
 
1448
 
    psRetOUT->eError =
1449
 
        PVRSRVReleaseHandle(psPerProc->psHandleBase,
1450
 
                           psUnwrapExtMemIN->hKernelMemInfo,
1451
 
                           PVRSRV_HANDLE_TYPE_MEM_INFO);
1452
 
 
1453
 
    return 0;
1454
 
}
1455
 
 
1456
 
static IMG_INT
1457
 
PVRSRVGetFreeDeviceMemBW(IMG_UINT32 ui32BridgeID,
1458
 
                         PVRSRV_BRIDGE_IN_GETFREEDEVICEMEM *psGetFreeDeviceMemIN,
1459
 
                         PVRSRV_BRIDGE_OUT_GETFREEDEVICEMEM *psGetFreeDeviceMemOUT,
1460
 
                         PVRSRV_PER_PROCESS_DATA *psPerProc)
1461
 
{
1462
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GETFREE_DEVICEMEM);
1463
 
 
1464
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
1465
 
 
1466
 
    psGetFreeDeviceMemOUT->eError =
1467
 
        PVRSRVGetFreeDeviceMemKM(psGetFreeDeviceMemIN->ui32Flags,
1468
 
                                 &psGetFreeDeviceMemOUT->ui32Total,
1469
 
                                 &psGetFreeDeviceMemOUT->ui32Free,
1470
 
                                 &psGetFreeDeviceMemOUT->ui32LargestBlock);
1471
 
 
1472
 
    return 0;
1473
 
}
1474
 
 
1475
 
static IMG_INT
1476
 
PVRMMapOSMemHandleToMMapDataBW(IMG_UINT32 ui32BridgeID,
1477
 
                                  PVRSRV_BRIDGE_IN_MHANDLE_TO_MMAP_DATA *psMMapDataIN,
1478
 
                                  PVRSRV_BRIDGE_OUT_MHANDLE_TO_MMAP_DATA *psMMapDataOUT,
1479
 
                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
1480
 
{
1481
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA);
1482
 
 
1483
 
#if defined (__linux__)
1484
 
    psMMapDataOUT->eError =
1485
 
        PVRMMapOSMemHandleToMMapData(psPerProc,
1486
 
                                        psMMapDataIN->hMHandle,
1487
 
                                        &psMMapDataOUT->ui32MMapOffset,
1488
 
                                        &psMMapDataOUT->ui32ByteOffset,
1489
 
                                        &psMMapDataOUT->ui32RealByteSize,
1490
 
                                        &psMMapDataOUT->ui32UserVAddr);
1491
 
#else
1492
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
1493
 
    PVR_UNREFERENCED_PARAMETER(psMMapDataIN);
1494
 
 
1495
 
    psMMapDataOUT->eError = PVRSRV_ERROR_NOT_SUPPORTED;
1496
 
#endif
1497
 
    return 0;
1498
 
}
1499
 
 
1500
 
 
1501
 
static IMG_INT
1502
 
PVRMMapReleaseMMapDataBW(IMG_UINT32 ui32BridgeID,
1503
 
                                  PVRSRV_BRIDGE_IN_RELEASE_MMAP_DATA *psMMapDataIN,
1504
 
                                  PVRSRV_BRIDGE_OUT_RELEASE_MMAP_DATA *psMMapDataOUT,
1505
 
                                  PVRSRV_PER_PROCESS_DATA *psPerProc)
1506
 
{
1507
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_RELEASE_MMAP_DATA);
1508
 
 
1509
 
#if defined (__linux__)
1510
 
    psMMapDataOUT->eError =
1511
 
        PVRMMapReleaseMMapData(psPerProc,
1512
 
                                        psMMapDataIN->hMHandle,
1513
 
                                        &psMMapDataOUT->bMUnmap,
1514
 
                                        &psMMapDataOUT->ui32RealByteSize,
1515
 
                                        &psMMapDataOUT->ui32UserVAddr);
1516
 
#else
1517
 
 
1518
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
1519
 
    PVR_UNREFERENCED_PARAMETER(psMMapDataIN);
1520
 
 
1521
 
    psMMapDataOUT->eError = PVRSRV_ERROR_NOT_SUPPORTED;
1522
 
#endif
1523
 
    return 0;
1524
 
}
1525
 
 
1526
 
 
1527
 
#if defined (SUPPORT_SID_INTERFACE)
1528
 
static IMG_INT
1529
 
PVRSRVChangeDeviceMemoryAttributesBW(IMG_UINT32 ui32BridgeID,
1530
 
                                     PVRSRV_BRIDGE_IN_CHG_DEV_MEM_ATTRIBS *psChgMemAttribIN,
1531
 
                                     PVRSRV_BRIDGE_RETURN *psRetOUT,
1532
 
                                     PVRSRV_PER_PROCESS_DATA *psPerProc)
1533
 
{
1534
 
    IMG_HANDLE hKernelMemInfo;
1535
 
 
1536
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CHG_DEV_MEM_ATTRIBS);
1537
 
 
1538
 
    psRetOUT->eError =
1539
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1540
 
                           &hKernelMemInfo,
1541
 
                           psChgMemAttribIN->hKernelMemInfo,
1542
 
                           PVRSRV_HANDLE_TYPE_MEM_INFO);
1543
 
 
1544
 
    if(psRetOUT->eError != PVRSRV_OK)
1545
 
    {
1546
 
        return 0;
1547
 
    }
1548
 
 
1549
 
    psRetOUT->eError =
1550
 
        PVRSRVChangeDeviceMemoryAttributesKM(hKernelMemInfo, psChgMemAttribIN->ui32Attribs);
1551
 
 
1552
 
    return 0;
1553
 
}
1554
 
#else
1555
 
static IMG_INT
1556
 
PVRSRVChangeDeviceMemoryAttributesBW(IMG_UINT32 ui32BridgeID,
1557
 
                                     PVRSRV_BRIDGE_IN_CHG_DEV_MEM_ATTRIBS *psChgMemAttribIN,
1558
 
                                     PVRSRV_BRIDGE_RETURN *psRetOUT,
1559
 
                                     PVRSRV_PER_PROCESS_DATA *psPerProc)
1560
 
{
1561
 
    PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
1562
 
    PVR_UNREFERENCED_PARAMETER(psChgMemAttribIN);
1563
 
    PVR_UNREFERENCED_PARAMETER(psRetOUT);
1564
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
1565
 
 
1566
 
    return 0;
1567
 
}
1568
 
#endif
1569
 
 
1570
 
#ifdef PDUMP
1571
 
static IMG_INT
1572
 
PDumpIsCaptureFrameBW(IMG_UINT32 ui32BridgeID,
1573
 
                      IMG_VOID *psBridgeIn,
1574
 
                      PVRSRV_BRIDGE_OUT_PDUMP_ISCAPTURING *psPDumpIsCapturingOUT,
1575
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
1576
 
{
1577
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_ISCAPTURING);
1578
 
    PVR_UNREFERENCED_PARAMETER(psBridgeIn);
1579
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
1580
 
 
1581
 
    psPDumpIsCapturingOUT->bIsCapturing = PDumpIsCaptureFrameKM();
1582
 
    psPDumpIsCapturingOUT->eError = PVRSRV_OK;
1583
 
 
1584
 
    return 0;
1585
 
}
1586
 
 
1587
 
static IMG_INT
1588
 
PDumpCommentBW(IMG_UINT32 ui32BridgeID,
1589
 
               PVRSRV_BRIDGE_IN_PDUMP_COMMENT *psPDumpCommentIN,
1590
 
               PVRSRV_BRIDGE_RETURN *psRetOUT,
1591
 
               PVRSRV_PER_PROCESS_DATA *psPerProc)
1592
 
{
1593
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_COMMENT);
1594
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
1595
 
 
1596
 
    psRetOUT->eError = PDumpCommentKM(&psPDumpCommentIN->szComment[0],
1597
 
                                      psPDumpCommentIN->ui32Flags);
1598
 
    return 0;
1599
 
}
1600
 
 
1601
 
static IMG_INT
1602
 
PDumpSetFrameBW(IMG_UINT32 ui32BridgeID,
1603
 
                PVRSRV_BRIDGE_IN_PDUMP_SETFRAME *psPDumpSetFrameIN,
1604
 
                PVRSRV_BRIDGE_RETURN *psRetOUT,
1605
 
                PVRSRV_PER_PROCESS_DATA *psPerProc)
1606
 
{
1607
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_SETFRAME);
1608
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
1609
 
 
1610
 
    psRetOUT->eError = PDumpSetFrameKM(psPDumpSetFrameIN->ui32Frame);
1611
 
 
1612
 
    return 0;
1613
 
}
1614
 
 
1615
 
static IMG_INT
1616
 
PDumpRegWithFlagsBW(IMG_UINT32 ui32BridgeID,
1617
 
                    PVRSRV_BRIDGE_IN_PDUMP_DUMPREG *psPDumpRegDumpIN,
1618
 
                    PVRSRV_BRIDGE_RETURN *psRetOUT,
1619
 
                    PVRSRV_PER_PROCESS_DATA *psPerProc)
1620
 
{
1621
 
    PVRSRV_DEVICE_NODE *psDeviceNode;
1622
 
 
1623
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_REG);
1624
 
 
1625
 
    psRetOUT->eError =
1626
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1627
 
                           (IMG_VOID **)&psDeviceNode,
1628
 
                           psPDumpRegDumpIN->hDevCookie,
1629
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
1630
 
    if(psRetOUT->eError != PVRSRV_OK)
1631
 
    {
1632
 
        return 0;
1633
 
    }
1634
 
 
1635
 
    psRetOUT->eError = PDumpRegWithFlagsKM (psPDumpRegDumpIN->szRegRegion,
1636
 
                                            psPDumpRegDumpIN->sHWReg.ui32RegAddr,
1637
 
                                            psPDumpRegDumpIN->sHWReg.ui32RegVal,
1638
 
                                            psPDumpRegDumpIN->ui32Flags);
1639
 
 
1640
 
    return 0;
1641
 
}
1642
 
 
1643
 
static IMG_INT
1644
 
PDumpRegPolBW(IMG_UINT32 ui32BridgeID,
1645
 
              PVRSRV_BRIDGE_IN_PDUMP_REGPOL *psPDumpRegPolIN,
1646
 
              PVRSRV_BRIDGE_RETURN *psRetOUT,
1647
 
              PVRSRV_PER_PROCESS_DATA *psPerProc)
1648
 
{
1649
 
    PVRSRV_DEVICE_NODE *psDeviceNode;
1650
 
 
1651
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_REGPOL);
1652
 
 
1653
 
    psRetOUT->eError =
1654
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1655
 
                           (IMG_VOID **)&psDeviceNode,
1656
 
                           psPDumpRegPolIN->hDevCookie,
1657
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
1658
 
    if(psRetOUT->eError != PVRSRV_OK)
1659
 
    {
1660
 
        return 0;
1661
 
    }
1662
 
 
1663
 
 
1664
 
    psRetOUT->eError =
1665
 
        PDumpRegPolWithFlagsKM(psPDumpRegPolIN->szRegRegion,
1666
 
                               psPDumpRegPolIN->sHWReg.ui32RegAddr,
1667
 
                               psPDumpRegPolIN->sHWReg.ui32RegVal,
1668
 
                               psPDumpRegPolIN->ui32Mask,
1669
 
                               psPDumpRegPolIN->ui32Flags,
1670
 
                               PDUMP_POLL_OPERATOR_EQUAL);
1671
 
 
1672
 
    return 0;
1673
 
}
1674
 
 
1675
 
static IMG_INT
1676
 
PDumpMemPolBW(IMG_UINT32 ui32BridgeID,
1677
 
              PVRSRV_BRIDGE_IN_PDUMP_MEMPOL *psPDumpMemPolIN,
1678
 
              PVRSRV_BRIDGE_RETURN *psRetOUT,
1679
 
              PVRSRV_PER_PROCESS_DATA *psPerProc)
1680
 
{
1681
 
    IMG_VOID *pvMemInfo;
1682
 
 
1683
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_MEMPOL);
1684
 
 
1685
 
    psRetOUT->eError =
1686
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1687
 
                           &pvMemInfo,
1688
 
#if defined (SUPPORT_SID_INTERFACE)
1689
 
                           psPDumpMemPolIN->hKernelMemInfo,
1690
 
#else
1691
 
                           psPDumpMemPolIN->psKernelMemInfo,
1692
 
#endif
1693
 
                           PVRSRV_HANDLE_TYPE_MEM_INFO);
1694
 
    if(psRetOUT->eError != PVRSRV_OK)
1695
 
    {
1696
 
        return 0;
1697
 
    }
1698
 
 
1699
 
    psRetOUT->eError =
1700
 
        PDumpMemPolKM(((PVRSRV_KERNEL_MEM_INFO *)pvMemInfo),
1701
 
                      psPDumpMemPolIN->ui32Offset,
1702
 
                      psPDumpMemPolIN->ui32Value,
1703
 
                      psPDumpMemPolIN->ui32Mask,
1704
 
                      psPDumpMemPolIN->eOperator,
1705
 
                      psPDumpMemPolIN->ui32Flags,
1706
 
                      MAKEUNIQUETAG(pvMemInfo));
1707
 
 
1708
 
    return 0;
1709
 
}
1710
 
 
1711
 
static IMG_INT
1712
 
PDumpMemBW(IMG_UINT32 ui32BridgeID,
1713
 
           PVRSRV_BRIDGE_IN_PDUMP_DUMPMEM *psPDumpMemDumpIN,
1714
 
           PVRSRV_BRIDGE_RETURN *psRetOUT,
1715
 
           PVRSRV_PER_PROCESS_DATA *psPerProc)
1716
 
{
1717
 
    IMG_VOID *pvMemInfo;
1718
 
 
1719
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPMEM);
1720
 
 
1721
 
    psRetOUT->eError =
1722
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1723
 
                           &pvMemInfo,
1724
 
#if defined (SUPPORT_SID_INTERFACE)
1725
 
                           psPDumpMemDumpIN->hKernelMemInfo,
1726
 
#else
1727
 
                           psPDumpMemDumpIN->psKernelMemInfo,
1728
 
#endif
1729
 
                           PVRSRV_HANDLE_TYPE_MEM_INFO);
1730
 
    if(psRetOUT->eError != PVRSRV_OK)
1731
 
    {
1732
 
        return 0;
1733
 
    }
1734
 
 
1735
 
    psRetOUT->eError =
1736
 
        PDumpMemUM(psPerProc,
1737
 
                   psPDumpMemDumpIN->pvAltLinAddr,
1738
 
                   psPDumpMemDumpIN->pvLinAddr,
1739
 
                   pvMemInfo,
1740
 
                   psPDumpMemDumpIN->ui32Offset,
1741
 
                   psPDumpMemDumpIN->ui32Bytes,
1742
 
                   psPDumpMemDumpIN->ui32Flags,
1743
 
                   MAKEUNIQUETAG(pvMemInfo));
1744
 
 
1745
 
    return 0;
1746
 
}
1747
 
 
1748
 
static IMG_INT
1749
 
PDumpBitmapBW(IMG_UINT32 ui32BridgeID,
1750
 
              PVRSRV_BRIDGE_IN_PDUMP_BITMAP *psPDumpBitmapIN,
1751
 
              PVRSRV_BRIDGE_RETURN *psRetOUT,
1752
 
              PVRSRV_PER_PROCESS_DATA *psPerProc)
1753
 
{
1754
 
    PVRSRV_DEVICE_NODE *psDeviceNode;
1755
 
    IMG_HANDLE hDevMemContextInt;
1756
 
 
1757
 
    PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
1758
 
 
1759
 
    psRetOUT->eError =
1760
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID **)&psDeviceNode,
1761
 
                           psPDumpBitmapIN->hDevCookie,
1762
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
1763
 
 
1764
 
    psRetOUT->eError =
1765
 
        PVRSRVLookupHandle( psPerProc->psHandleBase,
1766
 
                            &hDevMemContextInt,
1767
 
                            psPDumpBitmapIN->hDevMemContext,
1768
 
                            PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
1769
 
 
1770
 
    if(psRetOUT->eError != PVRSRV_OK)
1771
 
    {
1772
 
        return 0;
1773
 
    }
1774
 
 
1775
 
    psRetOUT->eError =
1776
 
        PDumpBitmapKM(psDeviceNode,
1777
 
                      &psPDumpBitmapIN->szFileName[0],
1778
 
                      psPDumpBitmapIN->ui32FileOffset,
1779
 
                      psPDumpBitmapIN->ui32Width,
1780
 
                      psPDumpBitmapIN->ui32Height,
1781
 
                      psPDumpBitmapIN->ui32StrideInBytes,
1782
 
                      psPDumpBitmapIN->sDevBaseAddr,
1783
 
                      hDevMemContextInt,
1784
 
                      psPDumpBitmapIN->ui32Size,
1785
 
                      psPDumpBitmapIN->ePixelFormat,
1786
 
                      psPDumpBitmapIN->eMemFormat,
1787
 
                      psPDumpBitmapIN->ui32Flags);
1788
 
 
1789
 
    return 0;
1790
 
}
1791
 
 
1792
 
static IMG_INT
1793
 
PDumpReadRegBW(IMG_UINT32 ui32BridgeID,
1794
 
               PVRSRV_BRIDGE_IN_PDUMP_READREG *psPDumpReadRegIN,
1795
 
               PVRSRV_BRIDGE_RETURN *psRetOUT,
1796
 
               PVRSRV_PER_PROCESS_DATA *psPerProc)
1797
 
{
1798
 
    PVRSRV_DEVICE_NODE *psDeviceNode;
1799
 
 
1800
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPREADREG);
1801
 
 
1802
 
    psRetOUT->eError =
1803
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, (IMG_VOID **)&psDeviceNode,
1804
 
                           psPDumpReadRegIN->hDevCookie,
1805
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
1806
 
 
1807
 
    psRetOUT->eError =
1808
 
        PDumpReadRegKM(&psPDumpReadRegIN->szRegRegion[0],
1809
 
                       &psPDumpReadRegIN->szFileName[0],
1810
 
                       psPDumpReadRegIN->ui32FileOffset,
1811
 
                       psPDumpReadRegIN->ui32Address,
1812
 
                       psPDumpReadRegIN->ui32Size,
1813
 
                       psPDumpReadRegIN->ui32Flags);
1814
 
 
1815
 
    return 0;
1816
 
}
1817
 
 
1818
 
static IMG_INT
1819
 
PDumpMemPagesBW(IMG_UINT32 ui32BridgeID,
1820
 
                  PVRSRV_BRIDGE_IN_PDUMP_MEMPAGES *psPDumpMemPagesIN,
1821
 
                  PVRSRV_BRIDGE_RETURN *psRetOUT,
1822
 
                  PVRSRV_PER_PROCESS_DATA *psPerProc)
1823
 
{
1824
 
    PVRSRV_DEVICE_NODE *psDeviceNode;
1825
 
 
1826
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_MEMPAGES);
1827
 
 
1828
 
    psRetOUT->eError =
1829
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1830
 
                           (IMG_VOID **)&psDeviceNode,
1831
 
                           psPDumpMemPagesIN->hDevCookie,
1832
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
1833
 
 
1834
 
    if(psRetOUT->eError != PVRSRV_OK)
1835
 
    {
1836
 
        return 0;
1837
 
    }
1838
 
 
1839
 
 
1840
 
    return 0;
1841
 
}
1842
 
 
1843
 
static IMG_INT
1844
 
PDumpDriverInfoBW(IMG_UINT32 ui32BridgeID,
1845
 
                  PVRSRV_BRIDGE_IN_PDUMP_DRIVERINFO *psPDumpDriverInfoIN,
1846
 
                  PVRSRV_BRIDGE_RETURN *psRetOUT,
1847
 
                  PVRSRV_PER_PROCESS_DATA *psPerProc)
1848
 
{
1849
 
    IMG_UINT32 ui32PDumpFlags;
1850
 
 
1851
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DRIVERINFO);
1852
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
1853
 
 
1854
 
    ui32PDumpFlags = 0;
1855
 
    if(psPDumpDriverInfoIN->bContinuous)
1856
 
    {
1857
 
        ui32PDumpFlags |= PDUMP_FLAGS_CONTINUOUS;
1858
 
    }
1859
 
    psRetOUT->eError =
1860
 
        PDumpDriverInfoKM(&psPDumpDriverInfoIN->szString[0],
1861
 
                          ui32PDumpFlags);
1862
 
 
1863
 
    return 0;
1864
 
}
1865
 
 
1866
 
static IMG_INT
1867
 
PDumpSyncDumpBW(IMG_UINT32 ui32BridgeID,
1868
 
                PVRSRV_BRIDGE_IN_PDUMP_DUMPSYNC *psPDumpSyncDumpIN,
1869
 
                PVRSRV_BRIDGE_RETURN *psRetOUT,
1870
 
                PVRSRV_PER_PROCESS_DATA *psPerProc)
1871
 
{
1872
 
    IMG_UINT32 ui32Bytes = psPDumpSyncDumpIN->ui32Bytes;
1873
 
    IMG_VOID *pvSyncInfo;
1874
 
 
1875
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPSYNC);
1876
 
 
1877
 
    psRetOUT->eError =
1878
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSyncInfo,
1879
 
#if defined (SUPPORT_SID_INTERFACE)
1880
 
                           psPDumpSyncDumpIN->hKernelSyncInfo,
1881
 
#else
1882
 
                           psPDumpSyncDumpIN->psKernelSyncInfo,
1883
 
#endif
1884
 
                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
1885
 
    if(psRetOUT->eError != PVRSRV_OK)
1886
 
    {
1887
 
        return 0;
1888
 
    }
1889
 
 
1890
 
    psRetOUT->eError =
1891
 
        PDumpMemUM(psPerProc,
1892
 
                   psPDumpSyncDumpIN->pvAltLinAddr,
1893
 
                   IMG_NULL,
1894
 
                   ((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncDataMemInfoKM,
1895
 
                   psPDumpSyncDumpIN->ui32Offset,
1896
 
                   ui32Bytes,
1897
 
                   0,
1898
 
                   MAKEUNIQUETAG(((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncDataMemInfoKM));
1899
 
 
1900
 
    return 0;
1901
 
}
1902
 
 
1903
 
static IMG_INT
1904
 
PDumpSyncPolBW(IMG_UINT32 ui32BridgeID,
1905
 
               PVRSRV_BRIDGE_IN_PDUMP_SYNCPOL *psPDumpSyncPolIN,
1906
 
               PVRSRV_BRIDGE_RETURN *psRetOUT,
1907
 
               PVRSRV_PER_PROCESS_DATA *psPerProc)
1908
 
{
1909
 
    IMG_UINT32 ui32Offset;
1910
 
    IMG_VOID *pvSyncInfo;
1911
 
    IMG_UINT32 ui32Value;
1912
 
    IMG_UINT32 ui32Mask;
1913
 
 
1914
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_SYNCPOL);
1915
 
 
1916
 
    psRetOUT->eError =
1917
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1918
 
                           &pvSyncInfo,
1919
 
#if defined (SUPPORT_SID_INTERFACE)
1920
 
                           psPDumpSyncPolIN->hKernelSyncInfo,
1921
 
#else
1922
 
                           psPDumpSyncPolIN->psKernelSyncInfo,
1923
 
#endif
1924
 
                           PVRSRV_HANDLE_TYPE_SYNC_INFO);
1925
 
    if(psRetOUT->eError != PVRSRV_OK)
1926
 
    {
1927
 
        return 0;
1928
 
    }
1929
 
 
1930
 
    if(psPDumpSyncPolIN->bIsRead)
1931
 
    {
1932
 
        ui32Offset = offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete);
1933
 
    }
1934
 
    else
1935
 
    {
1936
 
        ui32Offset = offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete);
1937
 
    }
1938
 
 
1939
 
    
1940
 
    if (psPDumpSyncPolIN->bUseLastOpDumpVal)
1941
 
    {
1942
 
        if(psPDumpSyncPolIN->bIsRead)
1943
 
        {
1944
 
            ui32Value = ((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncData->ui32LastReadOpDumpVal;
1945
 
        }
1946
 
        else
1947
 
        {
1948
 
            ui32Value = ((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncData->ui32LastOpDumpVal;
1949
 
        }
1950
 
        ui32Mask = 0xffffffff;
1951
 
    }
1952
 
    else
1953
 
    {
1954
 
        ui32Value = psPDumpSyncPolIN->ui32Value;
1955
 
        ui32Mask =  psPDumpSyncPolIN->ui32Mask;
1956
 
    }
1957
 
 
1958
 
    psRetOUT->eError =
1959
 
        PDumpMemPolKM(((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncDataMemInfoKM,
1960
 
                      ui32Offset,
1961
 
                      ui32Value,
1962
 
                      ui32Mask,
1963
 
                      PDUMP_POLL_OPERATOR_EQUAL,
1964
 
                      0,
1965
 
                      MAKEUNIQUETAG(((PVRSRV_KERNEL_SYNC_INFO *)pvSyncInfo)->psSyncDataMemInfoKM));
1966
 
 
1967
 
    return 0;
1968
 
}
1969
 
 
1970
 
 
1971
 
static IMG_INT
1972
 
PDumpCycleCountRegReadBW(IMG_UINT32 ui32BridgeID,
1973
 
                         PVRSRV_BRIDGE_IN_PDUMP_CYCLE_COUNT_REG_READ *psPDumpCycleCountRegReadIN,
1974
 
                         PVRSRV_BRIDGE_RETURN *psRetOUT,
1975
 
                         PVRSRV_PER_PROCESS_DATA *psPerProc)
1976
 
{
1977
 
    PVRSRV_DEVICE_NODE *psDeviceNode;
1978
 
 
1979
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_CYCLE_COUNT_REG_READ);
1980
 
 
1981
 
    psRetOUT->eError =
1982
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
1983
 
                           (IMG_VOID **)&psDeviceNode,
1984
 
                           psPDumpCycleCountRegReadIN->hDevCookie,
1985
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
1986
 
    if(psRetOUT->eError != PVRSRV_OK)
1987
 
    {
1988
 
        return 0;
1989
 
    }
1990
 
 
1991
 
    PDumpCycleCountRegRead(&psDeviceNode->sDevId,
1992
 
                           psPDumpCycleCountRegReadIN->ui32RegOffset,
1993
 
                           psPDumpCycleCountRegReadIN->bLastFrame);
1994
 
 
1995
 
    psRetOUT->eError = PVRSRV_OK;
1996
 
 
1997
 
    return 0;
1998
 
}
1999
 
 
2000
 
static IMG_INT
2001
 
PDumpPDDevPAddrBW(IMG_UINT32 ui32BridgeID,
2002
 
                  PVRSRV_BRIDGE_IN_PDUMP_DUMPPDDEVPADDR *psPDumpPDDevPAddrIN,
2003
 
                  PVRSRV_BRIDGE_RETURN *psRetOUT,
2004
 
                  PVRSRV_PER_PROCESS_DATA *psPerProc)
2005
 
{
2006
 
    IMG_VOID *pvMemInfo;
2007
 
 
2008
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR);
2009
 
 
2010
 
    psRetOUT->eError =
2011
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &pvMemInfo,
2012
 
                           psPDumpPDDevPAddrIN->hKernelMemInfo,
2013
 
                           PVRSRV_HANDLE_TYPE_MEM_INFO);
2014
 
    if(psRetOUT->eError != PVRSRV_OK)
2015
 
    {
2016
 
        return 0;
2017
 
    }
2018
 
 
2019
 
    psRetOUT->eError =
2020
 
        PDumpPDDevPAddrKM((PVRSRV_KERNEL_MEM_INFO *)pvMemInfo,
2021
 
                          psPDumpPDDevPAddrIN->ui32Offset,
2022
 
                          psPDumpPDDevPAddrIN->sPDDevPAddr,
2023
 
                          MAKEUNIQUETAG(pvMemInfo),
2024
 
                          PDUMP_PD_UNIQUETAG);
2025
 
    return 0;
2026
 
}
2027
 
 
2028
 
static IMG_INT
2029
 
PDumpStartInitPhaseBW(IMG_UINT32 ui32BridgeID,
2030
 
                      IMG_VOID *psBridgeIn,
2031
 
                      PVRSRV_BRIDGE_RETURN *psRetOUT,
2032
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
2033
 
{
2034
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_STARTINITPHASE);
2035
 
    PVR_UNREFERENCED_PARAMETER(psBridgeIn);
2036
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
2037
 
 
2038
 
    psRetOUT->eError = PDumpStartInitPhaseKM();
2039
 
 
2040
 
    return 0;
2041
 
}
2042
 
 
2043
 
static IMG_INT
2044
 
PDumpStopInitPhaseBW(IMG_UINT32 ui32BridgeID,
2045
 
                      IMG_VOID *psBridgeIn,
2046
 
                      PVRSRV_BRIDGE_RETURN *psRetOUT,
2047
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
2048
 
{
2049
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_PDUMP_STOPINITPHASE);
2050
 
    PVR_UNREFERENCED_PARAMETER(psBridgeIn);
2051
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
2052
 
 
2053
 
    psRetOUT->eError = PDumpStopInitPhaseKM();
2054
 
 
2055
 
    return 0;
2056
 
}
2057
 
 
2058
 
#endif 
2059
 
 
2060
 
 
2061
 
static IMG_INT
2062
 
PVRSRVGetMiscInfoBW(IMG_UINT32 ui32BridgeID,
2063
 
                    PVRSRV_BRIDGE_IN_GET_MISC_INFO *psGetMiscInfoIN,
2064
 
                    PVRSRV_BRIDGE_OUT_GET_MISC_INFO *psGetMiscInfoOUT,
2065
 
                    PVRSRV_PER_PROCESS_DATA *psPerProc)
2066
 
{
2067
 
#if defined (SUPPORT_SID_INTERFACE)
2068
 
    PVRSRV_MISC_INFO_KM sMiscInfo = {0};
2069
 
#endif
2070
 
    PVRSRV_ERROR eError;
2071
 
 
2072
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_MISC_INFO);
2073
 
#if defined (SUPPORT_SID_INTERFACE)
2074
 
    sMiscInfo.ui32StateRequest = psGetMiscInfoIN->sMiscInfo.ui32StateRequest;
2075
 
    sMiscInfo.ui32StatePresent = psGetMiscInfoIN->sMiscInfo.ui32StatePresent;
2076
 
    sMiscInfo.ui32MemoryStrLen = psGetMiscInfoIN->sMiscInfo.ui32MemoryStrLen;
2077
 
    sMiscInfo.pszMemoryStr     = psGetMiscInfoIN->sMiscInfo.pszMemoryStr;
2078
 
 
2079
 
    OSMemCopy(&sMiscInfo.sCacheOpCtl,
2080
 
              &psGetMiscInfoIN->sMiscInfo.sCacheOpCtl,
2081
 
              sizeof(sMiscInfo.sCacheOpCtl));
2082
 
#else
2083
 
 
2084
 
    OSMemCopy(&psGetMiscInfoOUT->sMiscInfo,
2085
 
              &psGetMiscInfoIN->sMiscInfo,
2086
 
              sizeof(PVRSRV_MISC_INFO));
2087
 
#endif
2088
 
 
2089
 
    if (((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_MEMSTATS_PRESENT) != 0) &&
2090
 
        ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0) &&
2091
 
        ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_FREEMEM_PRESENT) != 0))
2092
 
    {
2093
 
        
2094
 
        psGetMiscInfoOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
2095
 
        return 0;
2096
 
    }
2097
 
 
2098
 
    if (((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_MEMSTATS_PRESENT) != 0) ||
2099
 
        ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_DDKVERSION_PRESENT) != 0) ||
2100
 
        ((psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_FREEMEM_PRESENT) != 0))
2101
 
    {
2102
 
        
2103
 
#if defined (SUPPORT_SID_INTERFACE)
2104
 
        ASSIGN_AND_EXIT_ON_ERROR(psGetMiscInfoOUT->eError,
2105
 
                    OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
2106
 
                            psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen,
2107
 
                            (IMG_VOID **)&sMiscInfo.pszMemoryStr, 0,
2108
 
                            "Output string buffer"));
2109
 
        psGetMiscInfoOUT->eError = PVRSRVGetMiscInfoKM(&sMiscInfo);
2110
 
 
2111
 
        
2112
 
        eError = CopyToUserWrapper(psPerProc, ui32BridgeID,
2113
 
                                   psGetMiscInfoIN->sMiscInfo.pszMemoryStr,
2114
 
                                   sMiscInfo.pszMemoryStr,
2115
 
                                   sMiscInfo.ui32MemoryStrLen);
2116
 
#else
2117
 
        ASSIGN_AND_EXIT_ON_ERROR(psGetMiscInfoOUT->eError,
2118
 
                    OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
2119
 
                            psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen,
2120
 
                            (IMG_VOID **)&psGetMiscInfoOUT->sMiscInfo.pszMemoryStr, 0,
2121
 
                            "Output string buffer"));
2122
 
 
2123
 
        psGetMiscInfoOUT->eError = PVRSRVGetMiscInfoKM(&psGetMiscInfoOUT->sMiscInfo);
2124
 
 
2125
 
        
2126
 
        eError = CopyToUserWrapper(psPerProc, ui32BridgeID,
2127
 
                                   psGetMiscInfoIN->sMiscInfo.pszMemoryStr,
2128
 
                                   psGetMiscInfoOUT->sMiscInfo.pszMemoryStr,
2129
 
                                   psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen);
2130
 
#endif
2131
 
 
2132
 
        
2133
 
#if defined (SUPPORT_SID_INTERFACE)
2134
 
        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
2135
 
                  sMiscInfo.ui32MemoryStrLen,
2136
 
                 (IMG_VOID *)sMiscInfo.pszMemoryStr, 0);
2137
 
#else
2138
 
        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
2139
 
                  psGetMiscInfoOUT->sMiscInfo.ui32MemoryStrLen,
2140
 
                 (IMG_VOID *)psGetMiscInfoOUT->sMiscInfo.pszMemoryStr, 0);
2141
 
#endif
2142
 
 
2143
 
        
2144
 
        psGetMiscInfoOUT->sMiscInfo.pszMemoryStr = psGetMiscInfoIN->sMiscInfo.pszMemoryStr;
2145
 
 
2146
 
        if(eError != PVRSRV_OK)
2147
 
        {
2148
 
            
2149
 
            PVR_DPF((PVR_DBG_ERROR, "PVRSRVGetMiscInfoBW Error copy to user"));
2150
 
            return -EFAULT;
2151
 
        }
2152
 
    }
2153
 
    else
2154
 
    {
2155
 
#if defined (SUPPORT_SID_INTERFACE)
2156
 
        psGetMiscInfoOUT->eError = PVRSRVGetMiscInfoKM(&sMiscInfo);
2157
 
#else
2158
 
        psGetMiscInfoOUT->eError = PVRSRVGetMiscInfoKM(&psGetMiscInfoOUT->sMiscInfo);
2159
 
#endif
2160
 
    }
2161
 
 
2162
 
    
2163
 
    if (psGetMiscInfoOUT->eError != PVRSRV_OK)
2164
 
    {
2165
 
        return 0;
2166
 
    }
2167
 
 
2168
 
    
2169
 
#if defined (SUPPORT_SID_INTERFACE)
2170
 
    if (sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT)
2171
 
#else
2172
 
    if (psGetMiscInfoIN->sMiscInfo.ui32StateRequest & PVRSRV_MISC_INFO_GLOBALEVENTOBJECT_PRESENT)
2173
 
#endif
2174
 
    {
2175
 
        psGetMiscInfoOUT->eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
2176
 
                                                    &psGetMiscInfoOUT->sMiscInfo.sGlobalEventObject.hOSEventKM,
2177
 
#if defined (SUPPORT_SID_INTERFACE)
2178
 
                                                    sMiscInfo.sGlobalEventObject.hOSEventKM,
2179
 
#else
2180
 
                                                    psGetMiscInfoOUT->sMiscInfo.sGlobalEventObject.hOSEventKM,
2181
 
#endif
2182
 
                                                    PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT,
2183
 
                                                    PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
2184
 
 
2185
 
        if (psGetMiscInfoOUT->eError != PVRSRV_OK)
2186
 
        {
2187
 
            return 0;
2188
 
        }
2189
 
 
2190
 
#if defined (SUPPORT_SID_INTERFACE)
2191
 
        OSMemCopy(&psGetMiscInfoOUT->sMiscInfo.sGlobalEventObject.szName,
2192
 
                           sMiscInfo.sGlobalEventObject.szName,
2193
 
                           EVENTOBJNAME_MAXLENGTH);
2194
 
 
2195
 
#endif
2196
 
    }
2197
 
 
2198
 
#if defined (SUPPORT_SID_INTERFACE)
2199
 
    if (sMiscInfo.hSOCTimerRegisterOSMemHandle)
2200
 
#else
2201
 
    if (psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle)
2202
 
#endif
2203
 
    {
2204
 
        
2205
 
        psGetMiscInfoOUT->eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
2206
 
                          &psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle,
2207
 
#if defined (SUPPORT_SID_INTERFACE)
2208
 
                          sMiscInfo.hSOCTimerRegisterOSMemHandle,
2209
 
#else
2210
 
                          psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle,
2211
 
#endif
2212
 
                          PVRSRV_HANDLE_TYPE_SOC_TIMER,
2213
 
                          PVRSRV_HANDLE_ALLOC_FLAG_SHARED);
2214
 
 
2215
 
        if (psGetMiscInfoOUT->eError != PVRSRV_OK)
2216
 
        {
2217
 
            return 0;
2218
 
        }
2219
 
    }
2220
 
#if defined (SUPPORT_SID_INTERFACE)
2221
 
    else
2222
 
    {
2223
 
        psGetMiscInfoOUT->sMiscInfo.hSOCTimerRegisterOSMemHandle = 0;
2224
 
    }
2225
 
 
2226
 
    
2227
 
    psGetMiscInfoOUT->sMiscInfo.ui32StateRequest = sMiscInfo.ui32StateRequest;
2228
 
    psGetMiscInfoOUT->sMiscInfo.ui32StatePresent = sMiscInfo.ui32StatePresent;
2229
 
 
2230
 
    psGetMiscInfoOUT->sMiscInfo.pvSOCTimerRegisterKM = sMiscInfo.pvSOCTimerRegisterKM;
2231
 
    psGetMiscInfoOUT->sMiscInfo.pvSOCTimerRegisterUM = sMiscInfo.pvSOCTimerRegisterUM;
2232
 
    psGetMiscInfoOUT->sMiscInfo.pvSOCClockGateRegs   = sMiscInfo.pvSOCClockGateRegs;
2233
 
 
2234
 
    psGetMiscInfoOUT->sMiscInfo.ui32SOCClockGateRegsSize = sMiscInfo.ui32SOCClockGateRegsSize;
2235
 
 
2236
 
    OSMemCopy(&psGetMiscInfoOUT->sMiscInfo.aui32DDKVersion,
2237
 
              &sMiscInfo.aui32DDKVersion,
2238
 
              sizeof(psGetMiscInfoOUT->sMiscInfo.aui32DDKVersion));
2239
 
    OSMemCopy(&psGetMiscInfoOUT->sMiscInfo.sCacheOpCtl,
2240
 
              &sMiscInfo.sCacheOpCtl,
2241
 
              sizeof(psGetMiscInfoOUT->sMiscInfo.sCacheOpCtl));
2242
 
#endif
2243
 
 
2244
 
    return 0;
2245
 
}
2246
 
 
2247
 
static IMG_INT
2248
 
PVRSRVConnectBW(IMG_UINT32 ui32BridgeID,
2249
 
                PVRSRV_BRIDGE_IN_CONNECT_SERVICES *psConnectServicesIN,
2250
 
                PVRSRV_BRIDGE_OUT_CONNECT_SERVICES *psConnectServicesOUT,
2251
 
                PVRSRV_PER_PROCESS_DATA *psPerProc)
2252
 
{
2253
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CONNECT_SERVICES);
2254
 
 
2255
 
#if defined(PDUMP)
2256
 
    
2257
 
        if ((psConnectServicesIN->ui32Flags & SRV_FLAGS_PERSIST) != 0)
2258
 
        {
2259
 
        psPerProc->bPDumpPersistent = IMG_TRUE;
2260
 
        }
2261
 
 
2262
 
#if defined(SUPPORT_PDUMP_MULTI_PROCESS)
2263
 
    
2264
 
        if ((psConnectServicesIN->ui32Flags & SRV_FLAGS_PDUMP_ACTIVE) != 0)
2265
 
        {
2266
 
        psPerProc->bPDumpActive = IMG_TRUE;
2267
 
        }
2268
 
#endif 
2269
 
#else
2270
 
    PVR_UNREFERENCED_PARAMETER(psConnectServicesIN);
2271
 
#endif
2272
 
    psConnectServicesOUT->hKernelServices = psPerProc->hPerProcData;
2273
 
    psConnectServicesOUT->eError = PVRSRV_OK;
2274
 
 
2275
 
    return 0;
2276
 
}
2277
 
 
2278
 
static IMG_INT
2279
 
PVRSRVDisconnectBW(IMG_UINT32 ui32BridgeID,
2280
 
                   IMG_VOID *psBridgeIn,
2281
 
                   PVRSRV_BRIDGE_RETURN *psRetOUT,
2282
 
                   PVRSRV_PER_PROCESS_DATA *psPerProc)
2283
 
{
2284
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
2285
 
    PVR_UNREFERENCED_PARAMETER(psBridgeIn);
2286
 
 
2287
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DISCONNECT_SERVICES);
2288
 
 
2289
 
    
2290
 
    psRetOUT->eError = PVRSRV_OK;
2291
 
 
2292
 
    return 0;
2293
 
}
2294
 
 
2295
 
static IMG_INT
2296
 
PVRSRVEnumerateDCBW(IMG_UINT32 ui32BridgeID,
2297
 
                    PVRSRV_BRIDGE_IN_ENUMCLASS *psEnumDispClassIN,
2298
 
                    PVRSRV_BRIDGE_OUT_ENUMCLASS *psEnumDispClassOUT,
2299
 
                    PVRSRV_PER_PROCESS_DATA *psPerProc)
2300
 
{
2301
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
2302
 
 
2303
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_CLASS);
2304
 
 
2305
 
    psEnumDispClassOUT->eError =
2306
 
        PVRSRVEnumerateDCKM(psEnumDispClassIN->sDeviceClass,
2307
 
                            &psEnumDispClassOUT->ui32NumDevices,
2308
 
                            &psEnumDispClassOUT->ui32DevID[0]);
2309
 
 
2310
 
    return 0;
2311
 
}
2312
 
 
2313
 
static IMG_INT
2314
 
PVRSRVOpenDCDeviceBW(IMG_UINT32 ui32BridgeID,
2315
 
                     PVRSRV_BRIDGE_IN_OPEN_DISPCLASS_DEVICE *psOpenDispClassDeviceIN,
2316
 
                     PVRSRV_BRIDGE_OUT_OPEN_DISPCLASS_DEVICE *psOpenDispClassDeviceOUT,
2317
 
                     PVRSRV_PER_PROCESS_DATA *psPerProc)
2318
 
{
2319
 
    IMG_HANDLE hDevCookieInt;
2320
 
    IMG_HANDLE hDispClassInfoInt;
2321
 
 
2322
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE);
2323
 
 
2324
 
    NEW_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError, psPerProc, 1)
2325
 
 
2326
 
    psOpenDispClassDeviceOUT->eError =
2327
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2328
 
                           &hDevCookieInt,
2329
 
                           psOpenDispClassDeviceIN->hDevCookie,
2330
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
2331
 
    if(psOpenDispClassDeviceOUT->eError != PVRSRV_OK)
2332
 
    {
2333
 
        return 0;
2334
 
    }
2335
 
 
2336
 
    psOpenDispClassDeviceOUT->eError =
2337
 
        PVRSRVOpenDCDeviceKM(psPerProc,
2338
 
                             psOpenDispClassDeviceIN->ui32DeviceID,
2339
 
                             hDevCookieInt,
2340
 
                             &hDispClassInfoInt);
2341
 
 
2342
 
    if(psOpenDispClassDeviceOUT->eError != PVRSRV_OK)
2343
 
    {
2344
 
        return 0;
2345
 
    }
2346
 
 
2347
 
    PVRSRVAllocHandleNR(psPerProc->psHandleBase,
2348
 
                      &psOpenDispClassDeviceOUT->hDeviceKM,
2349
 
                      hDispClassInfoInt,
2350
 
                      PVRSRV_HANDLE_TYPE_DISP_INFO,
2351
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE);
2352
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psOpenDispClassDeviceOUT->eError, psPerProc)
2353
 
 
2354
 
    return 0;
2355
 
}
2356
 
 
2357
 
static IMG_INT
2358
 
PVRSRVCloseDCDeviceBW(IMG_UINT32 ui32BridgeID,
2359
 
                      PVRSRV_BRIDGE_IN_CLOSE_DISPCLASS_DEVICE *psCloseDispClassDeviceIN,
2360
 
                      PVRSRV_BRIDGE_RETURN *psRetOUT,
2361
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
2362
 
{
2363
 
    IMG_VOID *pvDispClassInfoInt;
2364
 
 
2365
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE);
2366
 
 
2367
 
    psRetOUT->eError =
2368
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2369
 
                           &pvDispClassInfoInt,
2370
 
                           psCloseDispClassDeviceIN->hDeviceKM,
2371
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2372
 
 
2373
 
    if(psRetOUT->eError != PVRSRV_OK)
2374
 
    {
2375
 
        return 0;
2376
 
    }
2377
 
 
2378
 
    psRetOUT->eError = PVRSRVCloseDCDeviceKM(pvDispClassInfoInt, IMG_FALSE);
2379
 
    if(psRetOUT->eError != PVRSRV_OK)
2380
 
    {
2381
 
        return 0;
2382
 
    }
2383
 
 
2384
 
    psRetOUT->eError =
2385
 
        PVRSRVReleaseHandle(psPerProc->psHandleBase,
2386
 
                            psCloseDispClassDeviceIN->hDeviceKM,
2387
 
                            PVRSRV_HANDLE_TYPE_DISP_INFO);
2388
 
    return 0;
2389
 
}
2390
 
 
2391
 
static IMG_INT
2392
 
PVRSRVEnumDCFormatsBW(IMG_UINT32 ui32BridgeID,
2393
 
                      PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_FORMATS *psEnumDispClassFormatsIN,
2394
 
                      PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_FORMATS *psEnumDispClassFormatsOUT,
2395
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
2396
 
{
2397
 
    IMG_VOID *pvDispClassInfoInt;
2398
 
 
2399
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS);
2400
 
 
2401
 
    psEnumDispClassFormatsOUT->eError =
2402
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2403
 
                           &pvDispClassInfoInt,
2404
 
                           psEnumDispClassFormatsIN->hDeviceKM,
2405
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2406
 
    if(psEnumDispClassFormatsOUT->eError != PVRSRV_OK)
2407
 
    {
2408
 
        return 0;
2409
 
    }
2410
 
 
2411
 
    psEnumDispClassFormatsOUT->eError =
2412
 
        PVRSRVEnumDCFormatsKM(pvDispClassInfoInt,
2413
 
                              &psEnumDispClassFormatsOUT->ui32Count,
2414
 
                              psEnumDispClassFormatsOUT->asFormat);
2415
 
 
2416
 
    return 0;
2417
 
}
2418
 
 
2419
 
static IMG_INT
2420
 
PVRSRVEnumDCDimsBW(IMG_UINT32 ui32BridgeID,
2421
 
                   PVRSRV_BRIDGE_IN_ENUM_DISPCLASS_DIMS *psEnumDispClassDimsIN,
2422
 
                   PVRSRV_BRIDGE_OUT_ENUM_DISPCLASS_DIMS *psEnumDispClassDimsOUT,
2423
 
                   PVRSRV_PER_PROCESS_DATA *psPerProc)
2424
 
{
2425
 
    IMG_VOID *pvDispClassInfoInt;
2426
 
 
2427
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS);
2428
 
 
2429
 
    psEnumDispClassDimsOUT->eError =
2430
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2431
 
                           &pvDispClassInfoInt,
2432
 
                           psEnumDispClassDimsIN->hDeviceKM,
2433
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2434
 
 
2435
 
    if(psEnumDispClassDimsOUT->eError != PVRSRV_OK)
2436
 
    {
2437
 
        return 0;
2438
 
    }
2439
 
 
2440
 
    psEnumDispClassDimsOUT->eError =
2441
 
        PVRSRVEnumDCDimsKM(pvDispClassInfoInt,
2442
 
                           &psEnumDispClassDimsIN->sFormat,
2443
 
                           &psEnumDispClassDimsOUT->ui32Count,
2444
 
                           psEnumDispClassDimsOUT->asDim);
2445
 
 
2446
 
    return 0;
2447
 
}
2448
 
 
2449
 
static IMG_INT
2450
 
PVRSRVGetDCSystemBufferBW(IMG_UINT32 ui32BridgeID,
2451
 
                          PVRSRV_BRIDGE_IN_GET_DISPCLASS_SYSBUFFER *psGetDispClassSysBufferIN,  
2452
 
                          PVRSRV_BRIDGE_OUT_GET_DISPCLASS_SYSBUFFER *psGetDispClassSysBufferOUT,
2453
 
                          PVRSRV_PER_PROCESS_DATA *psPerProc)
2454
 
{
2455
 
    IMG_HANDLE hBufferInt;
2456
 
    IMG_VOID *pvDispClassInfoInt;
2457
 
 
2458
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER);
2459
 
 
2460
 
    NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError, psPerProc, 1)
2461
 
 
2462
 
    psGetDispClassSysBufferOUT->eError =
2463
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2464
 
                           &pvDispClassInfoInt,
2465
 
                           psGetDispClassSysBufferIN->hDeviceKM,
2466
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2467
 
    if(psGetDispClassSysBufferOUT->eError != PVRSRV_OK)
2468
 
    {
2469
 
        return 0;
2470
 
    }
2471
 
 
2472
 
    psGetDispClassSysBufferOUT->eError =
2473
 
        PVRSRVGetDCSystemBufferKM(pvDispClassInfoInt,
2474
 
                                  &hBufferInt);
2475
 
 
2476
 
    if(psGetDispClassSysBufferOUT->eError != PVRSRV_OK)
2477
 
    {
2478
 
        return 0;
2479
 
    }
2480
 
 
2481
 
     
2482
 
    PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
2483
 
                         &psGetDispClassSysBufferOUT->hBuffer,
2484
 
                         hBufferInt,
2485
 
                         PVRSRV_HANDLE_TYPE_DISP_BUFFER,
2486
 
                         (PVRSRV_HANDLE_ALLOC_FLAG)(PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE | PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
2487
 
                         psGetDispClassSysBufferIN->hDeviceKM);
2488
 
 
2489
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassSysBufferOUT->eError, psPerProc)
2490
 
 
2491
 
    return 0;
2492
 
}
2493
 
 
2494
 
static IMG_INT
2495
 
PVRSRVGetDCInfoBW(IMG_UINT32 ui32BridgeID,
2496
 
                  PVRSRV_BRIDGE_IN_GET_DISPCLASS_INFO *psGetDispClassInfoIN,
2497
 
                  PVRSRV_BRIDGE_OUT_GET_DISPCLASS_INFO *psGetDispClassInfoOUT,
2498
 
                  PVRSRV_PER_PROCESS_DATA *psPerProc)
2499
 
{
2500
 
    IMG_VOID *pvDispClassInfo;
2501
 
 
2502
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DISPCLASS_INFO);
2503
 
 
2504
 
    psGetDispClassInfoOUT->eError =
2505
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2506
 
                           &pvDispClassInfo,
2507
 
                           psGetDispClassInfoIN->hDeviceKM,
2508
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2509
 
    if(psGetDispClassInfoOUT->eError != PVRSRV_OK)
2510
 
    {
2511
 
        return 0;
2512
 
    }
2513
 
 
2514
 
    psGetDispClassInfoOUT->eError =
2515
 
        PVRSRVGetDCInfoKM(pvDispClassInfo,
2516
 
                          &psGetDispClassInfoOUT->sDisplayInfo);
2517
 
 
2518
 
    return 0;
2519
 
}
2520
 
 
2521
 
static IMG_INT
2522
 
PVRSRVCreateDCSwapChainBW(IMG_UINT32 ui32BridgeID,
2523
 
                          PVRSRV_BRIDGE_IN_CREATE_DISPCLASS_SWAPCHAIN *psCreateDispClassSwapChainIN,
2524
 
                          PVRSRV_BRIDGE_OUT_CREATE_DISPCLASS_SWAPCHAIN *psCreateDispClassSwapChainOUT,
2525
 
                          PVRSRV_PER_PROCESS_DATA *psPerProc)
2526
 
{
2527
 
    IMG_VOID *pvDispClassInfo;
2528
 
    IMG_HANDLE hSwapChainInt;
2529
 
    IMG_UINT32  ui32SwapChainID;
2530
 
 
2531
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CREATE_DISPCLASS_SWAPCHAIN);
2532
 
 
2533
 
    NEW_HANDLE_BATCH_OR_ERROR(psCreateDispClassSwapChainOUT->eError, psPerProc, 1)
2534
 
 
2535
 
    psCreateDispClassSwapChainOUT->eError =
2536
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2537
 
                           &pvDispClassInfo,
2538
 
                           psCreateDispClassSwapChainIN->hDeviceKM,
2539
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2540
 
 
2541
 
    if(psCreateDispClassSwapChainOUT->eError != PVRSRV_OK)
2542
 
    {
2543
 
        return 0;
2544
 
    }
2545
 
 
2546
 
    
2547
 
    ui32SwapChainID = psCreateDispClassSwapChainIN->ui32SwapChainID;
2548
 
 
2549
 
    psCreateDispClassSwapChainOUT->eError =
2550
 
        PVRSRVCreateDCSwapChainKM(psPerProc, pvDispClassInfo,
2551
 
                                  psCreateDispClassSwapChainIN->ui32Flags,
2552
 
                                  &psCreateDispClassSwapChainIN->sDstSurfAttrib,
2553
 
                                  &psCreateDispClassSwapChainIN->sSrcSurfAttrib,
2554
 
                                  psCreateDispClassSwapChainIN->ui32BufferCount,
2555
 
                                  psCreateDispClassSwapChainIN->ui32OEMFlags,
2556
 
                                  &hSwapChainInt,
2557
 
                                  &ui32SwapChainID);
2558
 
 
2559
 
    if(psCreateDispClassSwapChainOUT->eError != PVRSRV_OK)
2560
 
    {
2561
 
        return 0;
2562
 
    }
2563
 
 
2564
 
    
2565
 
    psCreateDispClassSwapChainOUT->ui32SwapChainID = ui32SwapChainID;
2566
 
 
2567
 
    PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
2568
 
                      &psCreateDispClassSwapChainOUT->hSwapChain,
2569
 
                      hSwapChainInt,
2570
 
                      PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN,
2571
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE,
2572
 
                      psCreateDispClassSwapChainIN->hDeviceKM);
2573
 
 
2574
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psCreateDispClassSwapChainOUT->eError, psPerProc)
2575
 
 
2576
 
    return 0;
2577
 
}
2578
 
 
2579
 
static IMG_INT
2580
 
PVRSRVDestroyDCSwapChainBW(IMG_UINT32 ui32BridgeID,
2581
 
                           PVRSRV_BRIDGE_IN_DESTROY_DISPCLASS_SWAPCHAIN *psDestroyDispClassSwapChainIN,
2582
 
                           PVRSRV_BRIDGE_RETURN *psRetOUT,
2583
 
                           PVRSRV_PER_PROCESS_DATA *psPerProc)
2584
 
{
2585
 
    IMG_VOID *pvSwapChain;
2586
 
 
2587
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DESTROY_DISPCLASS_SWAPCHAIN);
2588
 
 
2589
 
    psRetOUT->eError =
2590
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &pvSwapChain,
2591
 
                           psDestroyDispClassSwapChainIN->hSwapChain,
2592
 
                           PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
2593
 
    if(psRetOUT->eError != PVRSRV_OK)
2594
 
    {
2595
 
        return 0;
2596
 
    }
2597
 
 
2598
 
    psRetOUT->eError =
2599
 
        PVRSRVDestroyDCSwapChainKM(pvSwapChain);
2600
 
 
2601
 
    if(psRetOUT->eError != PVRSRV_OK)
2602
 
    {
2603
 
        return 0;
2604
 
    }
2605
 
 
2606
 
    psRetOUT->eError =
2607
 
        PVRSRVReleaseHandle(psPerProc->psHandleBase,
2608
 
                            psDestroyDispClassSwapChainIN->hSwapChain,
2609
 
                            PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
2610
 
 
2611
 
    return 0;
2612
 
}
2613
 
 
2614
 
static IMG_INT
2615
 
PVRSRVSetDCDstRectBW(IMG_UINT32 ui32BridgeID,
2616
 
                     PVRSRV_BRIDGE_IN_SET_DISPCLASS_RECT *psSetDispClassDstRectIN,
2617
 
                     PVRSRV_BRIDGE_RETURN *psRetOUT,
2618
 
                     PVRSRV_PER_PROCESS_DATA *psPerProc)
2619
 
{
2620
 
    IMG_VOID *pvDispClassInfo;
2621
 
    IMG_VOID *pvSwapChain;
2622
 
 
2623
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SET_DISPCLASS_DSTRECT);
2624
 
 
2625
 
    psRetOUT->eError =
2626
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2627
 
                           &pvDispClassInfo,
2628
 
                           psSetDispClassDstRectIN->hDeviceKM,
2629
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2630
 
    if(psRetOUT->eError != PVRSRV_OK)
2631
 
    {
2632
 
        return 0;
2633
 
    }
2634
 
 
2635
 
    psRetOUT->eError =
2636
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2637
 
                           &pvSwapChain,
2638
 
                           psSetDispClassDstRectIN->hSwapChain,
2639
 
                           PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
2640
 
 
2641
 
    if(psRetOUT->eError != PVRSRV_OK)
2642
 
    {
2643
 
        return 0;
2644
 
    }
2645
 
 
2646
 
    psRetOUT->eError =
2647
 
        PVRSRVSetDCDstRectKM(pvDispClassInfo,
2648
 
                             pvSwapChain,
2649
 
                             &psSetDispClassDstRectIN->sRect);
2650
 
 
2651
 
    return 0;
2652
 
}
2653
 
 
2654
 
static IMG_INT
2655
 
PVRSRVSetDCSrcRectBW(IMG_UINT32 ui32BridgeID,
2656
 
                     PVRSRV_BRIDGE_IN_SET_DISPCLASS_RECT *psSetDispClassSrcRectIN,
2657
 
                     PVRSRV_BRIDGE_RETURN *psRetOUT,
2658
 
                     PVRSRV_PER_PROCESS_DATA *psPerProc)
2659
 
{
2660
 
    IMG_VOID *pvDispClassInfo;
2661
 
    IMG_VOID *pvSwapChain;
2662
 
 
2663
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SET_DISPCLASS_SRCRECT);
2664
 
 
2665
 
    psRetOUT->eError =
2666
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2667
 
                           &pvDispClassInfo,
2668
 
                           psSetDispClassSrcRectIN->hDeviceKM,
2669
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2670
 
    if(psRetOUT->eError != PVRSRV_OK)
2671
 
    {
2672
 
        return 0;
2673
 
    }
2674
 
 
2675
 
    psRetOUT->eError =
2676
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2677
 
                           &pvSwapChain,
2678
 
                           psSetDispClassSrcRectIN->hSwapChain,
2679
 
                           PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
2680
 
    if(psRetOUT->eError != PVRSRV_OK)
2681
 
    {
2682
 
        return 0;
2683
 
    }
2684
 
 
2685
 
    psRetOUT->eError =
2686
 
        PVRSRVSetDCSrcRectKM(pvDispClassInfo,
2687
 
                             pvSwapChain,
2688
 
                             &psSetDispClassSrcRectIN->sRect);
2689
 
 
2690
 
    return 0;
2691
 
}
2692
 
 
2693
 
static IMG_INT
2694
 
PVRSRVSetDCDstColourKeyBW(IMG_UINT32 ui32BridgeID,
2695
 
                          PVRSRV_BRIDGE_IN_SET_DISPCLASS_COLOURKEY *psSetDispClassColKeyIN,
2696
 
                          PVRSRV_BRIDGE_RETURN *psRetOUT,
2697
 
                          PVRSRV_PER_PROCESS_DATA *psPerProc)
2698
 
{
2699
 
    IMG_VOID *pvDispClassInfo;
2700
 
    IMG_VOID *pvSwapChain;
2701
 
 
2702
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SET_DISPCLASS_DSTCOLOURKEY);
2703
 
 
2704
 
    psRetOUT->eError =
2705
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2706
 
                           &pvDispClassInfo,
2707
 
                           psSetDispClassColKeyIN->hDeviceKM,
2708
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2709
 
    if(psRetOUT->eError != PVRSRV_OK)
2710
 
    {
2711
 
        return 0;
2712
 
    }
2713
 
 
2714
 
    psRetOUT->eError =
2715
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2716
 
                           &pvSwapChain,
2717
 
                           psSetDispClassColKeyIN->hSwapChain,
2718
 
                           PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
2719
 
    if(psRetOUT->eError != PVRSRV_OK)
2720
 
    {
2721
 
        return 0;
2722
 
    }
2723
 
 
2724
 
    psRetOUT->eError =
2725
 
        PVRSRVSetDCDstColourKeyKM(pvDispClassInfo,
2726
 
                                  pvSwapChain,
2727
 
                                  psSetDispClassColKeyIN->ui32CKColour);
2728
 
 
2729
 
    return 0;
2730
 
}
2731
 
 
2732
 
static IMG_INT
2733
 
PVRSRVSetDCSrcColourKeyBW(IMG_UINT32 ui32BridgeID,
2734
 
                          PVRSRV_BRIDGE_IN_SET_DISPCLASS_COLOURKEY *psSetDispClassColKeyIN,
2735
 
                          PVRSRV_BRIDGE_RETURN *psRetOUT,
2736
 
                          PVRSRV_PER_PROCESS_DATA *psPerProc)
2737
 
{
2738
 
    IMG_VOID *pvDispClassInfo;
2739
 
    IMG_VOID *pvSwapChain;
2740
 
 
2741
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SET_DISPCLASS_SRCCOLOURKEY);
2742
 
 
2743
 
    psRetOUT->eError =
2744
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2745
 
                           &pvDispClassInfo,
2746
 
                           psSetDispClassColKeyIN->hDeviceKM,
2747
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2748
 
    if(psRetOUT->eError != PVRSRV_OK)
2749
 
    {
2750
 
        return 0;
2751
 
    }
2752
 
 
2753
 
    psRetOUT->eError =
2754
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2755
 
                           &pvSwapChain,
2756
 
                           psSetDispClassColKeyIN->hSwapChain,
2757
 
                           PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
2758
 
    if(psRetOUT->eError != PVRSRV_OK)
2759
 
    {
2760
 
        return 0;
2761
 
    }
2762
 
 
2763
 
    psRetOUT->eError =
2764
 
        PVRSRVSetDCSrcColourKeyKM(pvDispClassInfo,
2765
 
                                  pvSwapChain,
2766
 
                                  psSetDispClassColKeyIN->ui32CKColour);
2767
 
 
2768
 
    return 0;
2769
 
}
2770
 
 
2771
 
static IMG_INT
2772
 
PVRSRVGetDCBuffersBW(IMG_UINT32 ui32BridgeID,
2773
 
                     PVRSRV_BRIDGE_IN_GET_DISPCLASS_BUFFERS *psGetDispClassBuffersIN,
2774
 
                     PVRSRV_BRIDGE_OUT_GET_DISPCLASS_BUFFERS *psGetDispClassBuffersOUT,
2775
 
                     PVRSRV_PER_PROCESS_DATA *psPerProc)
2776
 
{
2777
 
    IMG_VOID    *pvDispClassInfo;
2778
 
    IMG_VOID    *pvSwapChain;
2779
 
    IMG_UINT32   i;
2780
 
#if defined (SUPPORT_SID_INTERFACE)
2781
 
    IMG_HANDLE  *pahBuffer;
2782
 
#endif
2783
 
 
2784
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_DISPCLASS_BUFFERS);
2785
 
 
2786
 
    NEW_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError, psPerProc, PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS)
2787
 
 
2788
 
    psGetDispClassBuffersOUT->eError =
2789
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2790
 
                           &pvDispClassInfo,
2791
 
                           psGetDispClassBuffersIN->hDeviceKM,
2792
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2793
 
    if(psGetDispClassBuffersOUT->eError != PVRSRV_OK)
2794
 
    {
2795
 
        return 0;
2796
 
    }
2797
 
 
2798
 
    psGetDispClassBuffersOUT->eError =
2799
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2800
 
                           &pvSwapChain,
2801
 
                           psGetDispClassBuffersIN->hSwapChain,
2802
 
                           PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN);
2803
 
    if(psGetDispClassBuffersOUT->eError != PVRSRV_OK)
2804
 
    {
2805
 
        return 0;
2806
 
    }
2807
 
 
2808
 
#if defined (SUPPORT_SID_INTERFACE)
2809
 
    psGetDispClassBuffersOUT->eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
2810
 
                                                  sizeof(IMG_HANDLE) * PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS,
2811
 
                                                  (IMG_PVOID *)&pahBuffer, 0,
2812
 
                                                  "Temp Swapchain Buffers");
2813
 
 
2814
 
    if (psGetDispClassBuffersOUT->eError != PVRSRV_OK)
2815
 
    {
2816
 
        return 0;
2817
 
    }
2818
 
#endif
2819
 
 
2820
 
    psGetDispClassBuffersOUT->eError =
2821
 
        PVRSRVGetDCBuffersKM(pvDispClassInfo,
2822
 
                             pvSwapChain,
2823
 
                             &psGetDispClassBuffersOUT->ui32BufferCount,
2824
 
#if defined (SUPPORT_SID_INTERFACE)
2825
 
                             pahBuffer);
2826
 
#else
2827
 
                             psGetDispClassBuffersOUT->ahBuffer);
2828
 
#endif
2829
 
    if (psGetDispClassBuffersOUT->eError != PVRSRV_OK)
2830
 
    {
2831
 
        return 0;
2832
 
    }
2833
 
 
2834
 
    PVR_ASSERT(psGetDispClassBuffersOUT->ui32BufferCount <= PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS);
2835
 
 
2836
 
    for(i = 0; i < psGetDispClassBuffersOUT->ui32BufferCount; i++)
2837
 
    {
2838
 
#if defined (SUPPORT_SID_INTERFACE)
2839
 
        IMG_SID hBufferExt;
2840
 
#else
2841
 
        IMG_HANDLE hBufferExt;
2842
 
#endif
2843
 
 
2844
 
         
2845
 
#if defined (SUPPORT_SID_INTERFACE)
2846
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
2847
 
                             &hBufferExt,
2848
 
                             pahBuffer[i],
2849
 
                             PVRSRV_HANDLE_TYPE_DISP_BUFFER,
2850
 
                             (PVRSRV_HANDLE_ALLOC_FLAG)(PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE | PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
2851
 
                             psGetDispClassBuffersIN->hSwapChain);
2852
 
#else
2853
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
2854
 
                             &hBufferExt,
2855
 
                             psGetDispClassBuffersOUT->ahBuffer[i],
2856
 
                             PVRSRV_HANDLE_TYPE_DISP_BUFFER,
2857
 
                             (PVRSRV_HANDLE_ALLOC_FLAG)(PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE | PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
2858
 
                             psGetDispClassBuffersIN->hSwapChain);
2859
 
#endif
2860
 
 
2861
 
        psGetDispClassBuffersOUT->ahBuffer[i] = hBufferExt;
2862
 
    }
2863
 
 
2864
 
#if defined (SUPPORT_SID_INTERFACE)
2865
 
    OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,
2866
 
              sizeof(IMG_HANDLE) * PVRSRV_MAX_DC_SWAPCHAIN_BUFFERS,
2867
 
              (IMG_PVOID)pahBuffer, 0);
2868
 
#endif
2869
 
 
2870
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psGetDispClassBuffersOUT->eError, psPerProc)
2871
 
 
2872
 
    return 0;
2873
 
}
2874
 
 
2875
 
static IMG_INT
2876
 
PVRSRVSwapToDCBufferBW(IMG_UINT32 ui32BridgeID,
2877
 
                       PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_BUFFER *psSwapDispClassBufferIN,
2878
 
                       PVRSRV_BRIDGE_RETURN *psRetOUT,
2879
 
                       PVRSRV_PER_PROCESS_DATA *psPerProc)
2880
 
{
2881
 
    IMG_VOID  *pvDispClassInfo;
2882
 
    IMG_VOID  *pvSwapChainBuf;
2883
 
#if defined (SUPPORT_SID_INTERFACE)
2884
 
    IMG_HANDLE hPrivateTag;
2885
 
#endif
2886
 
 
2887
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_BUFFER);
2888
 
 
2889
 
    psRetOUT->eError =
2890
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2891
 
                           &pvDispClassInfo,
2892
 
                           psSwapDispClassBufferIN->hDeviceKM,
2893
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2894
 
    if(psRetOUT->eError != PVRSRV_OK)
2895
 
    {
2896
 
        return 0;
2897
 
    }
2898
 
 
2899
 
    psRetOUT->eError =
2900
 
        PVRSRVLookupSubHandle(psPerProc->psHandleBase,
2901
 
                           &pvSwapChainBuf,
2902
 
                           psSwapDispClassBufferIN->hBuffer,
2903
 
                           PVRSRV_HANDLE_TYPE_DISP_BUFFER,
2904
 
                           psSwapDispClassBufferIN->hDeviceKM);
2905
 
    if(psRetOUT->eError != PVRSRV_OK)
2906
 
    {
2907
 
        return 0;
2908
 
    }
2909
 
 
2910
 
#if defined (SUPPORT_SID_INTERFACE)
2911
 
    if (psSwapDispClassBufferIN->hPrivateTag != 0)
2912
 
    {
2913
 
        psRetOUT->eError =
2914
 
            PVRSRVLookupSubHandle(psPerProc->psHandleBase,
2915
 
                               &hPrivateTag,
2916
 
                               psSwapDispClassBufferIN->hPrivateTag,
2917
 
                               PVRSRV_HANDLE_TYPE_DISP_BUFFER,
2918
 
                               psSwapDispClassBufferIN->hDeviceKM);
2919
 
        if(psRetOUT->eError != PVRSRV_OK)
2920
 
        {
2921
 
            return 0;
2922
 
        }
2923
 
    }
2924
 
    else
2925
 
    {
2926
 
        hPrivateTag = IMG_NULL;
2927
 
    }
2928
 
#endif
2929
 
 
2930
 
 
2931
 
    psRetOUT->eError =
2932
 
        PVRSRVSwapToDCBufferKM(pvDispClassInfo,
2933
 
                               pvSwapChainBuf,
2934
 
                               psSwapDispClassBufferIN->ui32SwapInterval,
2935
 
#if defined (SUPPORT_SID_INTERFACE)
2936
 
                               hPrivateTag,
2937
 
#else
2938
 
                               psSwapDispClassBufferIN->hPrivateTag,
2939
 
#endif
2940
 
                               psSwapDispClassBufferIN->ui32ClipRectCount,
2941
 
                               psSwapDispClassBufferIN->sClipRect);
2942
 
 
2943
 
    return 0;
2944
 
}
2945
 
 
2946
 
static IMG_INT
2947
 
PVRSRVSwapToDCSystemBW(IMG_UINT32 ui32BridgeID,
2948
 
                       PVRSRV_BRIDGE_IN_SWAP_DISPCLASS_TO_SYSTEM *psSwapDispClassSystemIN,
2949
 
                       PVRSRV_BRIDGE_RETURN *psRetOUT,
2950
 
                       PVRSRV_PER_PROCESS_DATA *psPerProc)
2951
 
{
2952
 
    IMG_VOID *pvDispClassInfo;
2953
 
    IMG_VOID *pvSwapChain;
2954
 
 
2955
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_SYSTEM);
2956
 
 
2957
 
    psRetOUT->eError =
2958
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2959
 
                           &pvDispClassInfo,
2960
 
                           psSwapDispClassSystemIN->hDeviceKM,
2961
 
                           PVRSRV_HANDLE_TYPE_DISP_INFO);
2962
 
    if(psRetOUT->eError != PVRSRV_OK)
2963
 
    {
2964
 
        return 0;
2965
 
    }
2966
 
 
2967
 
    psRetOUT->eError =
2968
 
        PVRSRVLookupSubHandle(psPerProc->psHandleBase,
2969
 
                           &pvSwapChain,
2970
 
                           psSwapDispClassSystemIN->hSwapChain,
2971
 
                           PVRSRV_HANDLE_TYPE_DISP_SWAP_CHAIN,
2972
 
                           psSwapDispClassSystemIN->hDeviceKM);
2973
 
    if(psRetOUT->eError != PVRSRV_OK)
2974
 
    {
2975
 
        return 0;
2976
 
    }
2977
 
    psRetOUT->eError =
2978
 
        PVRSRVSwapToDCSystemKM(pvDispClassInfo,
2979
 
                               pvSwapChain);
2980
 
 
2981
 
    return 0;
2982
 
}
2983
 
 
2984
 
static IMG_INT
2985
 
PVRSRVOpenBCDeviceBW(IMG_UINT32 ui32BridgeID,
2986
 
                     PVRSRV_BRIDGE_IN_OPEN_BUFFERCLASS_DEVICE *psOpenBufferClassDeviceIN,
2987
 
                     PVRSRV_BRIDGE_OUT_OPEN_BUFFERCLASS_DEVICE *psOpenBufferClassDeviceOUT,
2988
 
                     PVRSRV_PER_PROCESS_DATA *psPerProc)
2989
 
{
2990
 
    IMG_HANDLE hDevCookieInt;
2991
 
    IMG_HANDLE hBufClassInfo;
2992
 
 
2993
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_OPEN_BUFFERCLASS_DEVICE);
2994
 
 
2995
 
    NEW_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError, psPerProc, 1)
2996
 
 
2997
 
    psOpenBufferClassDeviceOUT->eError =
2998
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
2999
 
                           &hDevCookieInt,
3000
 
                           psOpenBufferClassDeviceIN->hDevCookie,
3001
 
                           PVRSRV_HANDLE_TYPE_DEV_NODE);
3002
 
    if(psOpenBufferClassDeviceOUT->eError != PVRSRV_OK)
3003
 
    {
3004
 
        return 0;
3005
 
    }
3006
 
 
3007
 
    psOpenBufferClassDeviceOUT->eError =
3008
 
        PVRSRVOpenBCDeviceKM(psPerProc,
3009
 
                             psOpenBufferClassDeviceIN->ui32DeviceID,
3010
 
                             hDevCookieInt,
3011
 
                             &hBufClassInfo);
3012
 
    if(psOpenBufferClassDeviceOUT->eError != PVRSRV_OK)
3013
 
    {
3014
 
        return 0;
3015
 
    }
3016
 
 
3017
 
    PVRSRVAllocHandleNR(psPerProc->psHandleBase,
3018
 
                      &psOpenBufferClassDeviceOUT->hDeviceKM,
3019
 
                      hBufClassInfo,
3020
 
                      PVRSRV_HANDLE_TYPE_BUF_INFO,
3021
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE);
3022
 
 
3023
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psOpenBufferClassDeviceOUT->eError, psPerProc)
3024
 
 
3025
 
    return 0;
3026
 
}
3027
 
 
3028
 
static IMG_INT
3029
 
PVRSRVCloseBCDeviceBW(IMG_UINT32 ui32BridgeID,
3030
 
                      PVRSRV_BRIDGE_IN_CLOSE_BUFFERCLASS_DEVICE *psCloseBufferClassDeviceIN,
3031
 
                      PVRSRV_BRIDGE_RETURN *psRetOUT,
3032
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
3033
 
{
3034
 
    IMG_VOID *pvBufClassInfo;
3035
 
 
3036
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CLOSE_BUFFERCLASS_DEVICE);
3037
 
 
3038
 
    psRetOUT->eError =
3039
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
3040
 
                           &pvBufClassInfo,
3041
 
                           psCloseBufferClassDeviceIN->hDeviceKM,
3042
 
                           PVRSRV_HANDLE_TYPE_BUF_INFO);
3043
 
    if(psRetOUT->eError != PVRSRV_OK)
3044
 
    {
3045
 
        return 0;
3046
 
    }
3047
 
 
3048
 
    psRetOUT->eError =
3049
 
        PVRSRVCloseBCDeviceKM(pvBufClassInfo, IMG_FALSE);
3050
 
 
3051
 
    if(psRetOUT->eError != PVRSRV_OK)
3052
 
    {
3053
 
        return 0;
3054
 
    }
3055
 
 
3056
 
    psRetOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
3057
 
                                           psCloseBufferClassDeviceIN->hDeviceKM,
3058
 
                                           PVRSRV_HANDLE_TYPE_BUF_INFO);
3059
 
 
3060
 
    return 0;
3061
 
}
3062
 
 
3063
 
static IMG_INT
3064
 
PVRSRVGetBCInfoBW(IMG_UINT32 ui32BridgeID,
3065
 
                  PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_INFO *psGetBufferClassInfoIN,
3066
 
                  PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_INFO *psGetBufferClassInfoOUT,
3067
 
                  PVRSRV_PER_PROCESS_DATA *psPerProc)
3068
 
{
3069
 
    IMG_VOID *pvBufClassInfo;
3070
 
 
3071
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_BUFFERCLASS_INFO);
3072
 
 
3073
 
    psGetBufferClassInfoOUT->eError =
3074
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
3075
 
                           &pvBufClassInfo,
3076
 
                           psGetBufferClassInfoIN->hDeviceKM,
3077
 
                           PVRSRV_HANDLE_TYPE_BUF_INFO);
3078
 
    if(psGetBufferClassInfoOUT->eError != PVRSRV_OK)
3079
 
    {
3080
 
        return 0;
3081
 
    }
3082
 
 
3083
 
    psGetBufferClassInfoOUT->eError =
3084
 
        PVRSRVGetBCInfoKM(pvBufClassInfo,
3085
 
                          &psGetBufferClassInfoOUT->sBufferInfo);
3086
 
    return 0;
3087
 
}
3088
 
 
3089
 
static IMG_INT
3090
 
PVRSRVGetBCBufferBW(IMG_UINT32 ui32BridgeID,
3091
 
                    PVRSRV_BRIDGE_IN_GET_BUFFERCLASS_BUFFER *psGetBufferClassBufferIN,
3092
 
                    PVRSRV_BRIDGE_OUT_GET_BUFFERCLASS_BUFFER *psGetBufferClassBufferOUT,
3093
 
                    PVRSRV_PER_PROCESS_DATA *psPerProc)
3094
 
{
3095
 
    IMG_VOID *pvBufClassInfo;
3096
 
    IMG_HANDLE hBufferInt;
3097
 
 
3098
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GET_BUFFERCLASS_BUFFER);
3099
 
 
3100
 
    NEW_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError, psPerProc, 1)
3101
 
 
3102
 
    psGetBufferClassBufferOUT->eError =
3103
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
3104
 
                           &pvBufClassInfo,
3105
 
                           psGetBufferClassBufferIN->hDeviceKM,
3106
 
                           PVRSRV_HANDLE_TYPE_BUF_INFO);
3107
 
    if(psGetBufferClassBufferOUT->eError != PVRSRV_OK)
3108
 
    {
3109
 
        return 0;
3110
 
    }
3111
 
 
3112
 
    psGetBufferClassBufferOUT->eError =
3113
 
        PVRSRVGetBCBufferKM(pvBufClassInfo,
3114
 
                            psGetBufferClassBufferIN->ui32BufferIndex,
3115
 
                            &hBufferInt);
3116
 
 
3117
 
    if(psGetBufferClassBufferOUT->eError != PVRSRV_OK)
3118
 
    {
3119
 
        return 0;
3120
 
    }
3121
 
 
3122
 
     
3123
 
    PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
3124
 
                         &psGetBufferClassBufferOUT->hBuffer,
3125
 
                         hBufferInt,
3126
 
                         PVRSRV_HANDLE_TYPE_BUF_BUFFER,
3127
 
                         (PVRSRV_HANDLE_ALLOC_FLAG)(PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE |  PVRSRV_HANDLE_ALLOC_FLAG_SHARED),
3128
 
                         psGetBufferClassBufferIN->hDeviceKM);
3129
 
 
3130
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psGetBufferClassBufferOUT->eError, psPerProc)
3131
 
 
3132
 
    return 0;
3133
 
}
3134
 
 
3135
 
 
3136
 
static IMG_INT
3137
 
PVRSRVAllocSharedSysMemoryBW(IMG_UINT32 ui32BridgeID,
3138
 
                             PVRSRV_BRIDGE_IN_ALLOC_SHARED_SYS_MEM *psAllocSharedSysMemIN,
3139
 
                             PVRSRV_BRIDGE_OUT_ALLOC_SHARED_SYS_MEM *psAllocSharedSysMemOUT,
3140
 
                             PVRSRV_PER_PROCESS_DATA *psPerProc)
3141
 
{
3142
 
    PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
3143
 
 
3144
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ALLOC_SHARED_SYS_MEM);
3145
 
 
3146
 
    NEW_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc, 1)
3147
 
 
3148
 
    psAllocSharedSysMemOUT->eError =
3149
 
        PVRSRVAllocSharedSysMemoryKM(psPerProc,
3150
 
                                     psAllocSharedSysMemIN->ui32Flags,
3151
 
                                     psAllocSharedSysMemIN->ui32Size,
3152
 
                                     &psKernelMemInfo);
3153
 
    if(psAllocSharedSysMemOUT->eError != PVRSRV_OK)
3154
 
    {
3155
 
        return 0;
3156
 
    }
3157
 
 
3158
 
    OSMemSet(&psAllocSharedSysMemOUT->sClientMemInfo,
3159
 
             0,
3160
 
             sizeof(psAllocSharedSysMemOUT->sClientMemInfo));
3161
 
 
3162
 
    psAllocSharedSysMemOUT->sClientMemInfo.pvLinAddrKM =
3163
 
            psKernelMemInfo->pvLinAddrKM;
3164
 
 
3165
 
    psAllocSharedSysMemOUT->sClientMemInfo.pvLinAddr = 0;
3166
 
    psAllocSharedSysMemOUT->sClientMemInfo.ui32Flags =
3167
 
        psKernelMemInfo->ui32Flags;
3168
 
    psAllocSharedSysMemOUT->sClientMemInfo.uAllocSize =
3169
 
        psKernelMemInfo->uAllocSize;
3170
 
#if defined (SUPPORT_SID_INTERFACE)
3171
 
    if (psKernelMemInfo->sMemBlk.hOSMemHandle != IMG_NULL)
3172
 
    {
3173
 
        PVRSRVAllocHandleNR(psPerProc->psHandleBase,
3174
 
                          &psAllocSharedSysMemOUT->sClientMemInfo.hMappingInfo,
3175
 
                          psKernelMemInfo->sMemBlk.hOSMemHandle,
3176
 
                          PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO,
3177
 
                          PVRSRV_HANDLE_ALLOC_FLAG_NONE);
3178
 
    }
3179
 
    else
3180
 
    {
3181
 
        psAllocSharedSysMemOUT->sClientMemInfo.hMappingInfo = 0;
3182
 
    }
3183
 
#else
3184
 
    psAllocSharedSysMemOUT->sClientMemInfo.hMappingInfo = psKernelMemInfo->sMemBlk.hOSMemHandle;
3185
 
#endif
3186
 
 
3187
 
    PVRSRVAllocHandleNR(psPerProc->psHandleBase,
3188
 
                      &psAllocSharedSysMemOUT->sClientMemInfo.hKernelMemInfo,
3189
 
                      psKernelMemInfo,
3190
 
                      PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO,
3191
 
                      PVRSRV_HANDLE_ALLOC_FLAG_NONE);
3192
 
 
3193
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psAllocSharedSysMemOUT->eError, psPerProc)
3194
 
 
3195
 
    return 0;
3196
 
}
3197
 
 
3198
 
static IMG_INT
3199
 
PVRSRVFreeSharedSysMemoryBW(IMG_UINT32 ui32BridgeID,
3200
 
                            PVRSRV_BRIDGE_IN_FREE_SHARED_SYS_MEM *psFreeSharedSysMemIN,
3201
 
                            PVRSRV_BRIDGE_OUT_FREE_SHARED_SYS_MEM *psFreeSharedSysMemOUT,
3202
 
                            PVRSRV_PER_PROCESS_DATA *psPerProc)
3203
 
{
3204
 
    PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
3205
 
 
3206
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_FREE_SHARED_SYS_MEM);
3207
 
 
3208
 
    psFreeSharedSysMemOUT->eError =
3209
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
3210
 
                           (IMG_VOID **)&psKernelMemInfo,
3211
 
#if defined (SUPPORT_SID_INTERFACE)
3212
 
                           psFreeSharedSysMemIN->hKernelMemInfo,
3213
 
#else
3214
 
                           psFreeSharedSysMemIN->psKernelMemInfo,
3215
 
#endif
3216
 
                           PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
3217
 
 
3218
 
    if(psFreeSharedSysMemOUT->eError != PVRSRV_OK)
3219
 
        return 0;
3220
 
 
3221
 
    psFreeSharedSysMemOUT->eError =
3222
 
        PVRSRVFreeSharedSysMemoryKM(psKernelMemInfo);
3223
 
    if(psFreeSharedSysMemOUT->eError != PVRSRV_OK)
3224
 
        return 0;
3225
 
#if defined (SUPPORT_SID_INTERFACE)
3226
 
    if (psFreeSharedSysMemIN->hMappingInfo != 0)
3227
 
    {
3228
 
        psFreeSharedSysMemOUT->eError =
3229
 
            PVRSRVReleaseHandle(psPerProc->psHandleBase,
3230
 
                                psFreeSharedSysMemIN->hMappingInfo,
3231
 
                                PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
3232
 
        if(psFreeSharedSysMemOUT->eError != PVRSRV_OK)
3233
 
        {
3234
 
            return 0;
3235
 
        }
3236
 
    }
3237
 
#endif
3238
 
 
3239
 
    psFreeSharedSysMemOUT->eError =
3240
 
        PVRSRVReleaseHandle(psPerProc->psHandleBase,
3241
 
#if defined (SUPPORT_SID_INTERFACE)
3242
 
                            psFreeSharedSysMemIN->hKernelMemInfo,
3243
 
#else
3244
 
                            psFreeSharedSysMemIN->psKernelMemInfo,
3245
 
#endif
3246
 
                            PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO);
3247
 
    return 0;
3248
 
}
3249
 
 
3250
 
static IMG_INT
3251
 
PVRSRVMapMemInfoMemBW(IMG_UINT32 ui32BridgeID,
3252
 
                      PVRSRV_BRIDGE_IN_MAP_MEMINFO_MEM *psMapMemInfoMemIN,
3253
 
                      PVRSRV_BRIDGE_OUT_MAP_MEMINFO_MEM *psMapMemInfoMemOUT,
3254
 
                      PVRSRV_PER_PROCESS_DATA *psPerProc)
3255
 
{
3256
 
    PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;
3257
 
    PVRSRV_HANDLE_TYPE eHandleType;
3258
 
#if defined (SUPPORT_SID_INTERFACE)
3259
 
    IMG_SID     hParent;
3260
 
#else
3261
 
    IMG_HANDLE  hParent;
3262
 
#endif
3263
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MAP_MEMINFO_MEM);
3264
 
 
3265
 
    NEW_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc, 2)
3266
 
 
3267
 
    psMapMemInfoMemOUT->eError =
3268
 
        PVRSRVLookupHandleAnyType(psPerProc->psHandleBase,
3269
 
                           (IMG_VOID **)&psKernelMemInfo,
3270
 
                           &eHandleType,
3271
 
                           psMapMemInfoMemIN->hKernelMemInfo);
3272
 
    if(psMapMemInfoMemOUT->eError != PVRSRV_OK)
3273
 
    {
3274
 
        return 0;
3275
 
    }
3276
 
 
3277
 
    switch (eHandleType)
3278
 
    {
3279
 
#if defined(PVR_SECURE_HANDLES) || defined (SUPPORT_SID_INTERFACE)
3280
 
        case PVRSRV_HANDLE_TYPE_MEM_INFO:
3281
 
        case PVRSRV_HANDLE_TYPE_MEM_INFO_REF:
3282
 
        case PVRSRV_HANDLE_TYPE_SHARED_SYS_MEM_INFO:
3283
 
#else
3284
 
        case PVRSRV_HANDLE_TYPE_NONE:
3285
 
#endif
3286
 
            break;
3287
 
        default:
3288
 
            psMapMemInfoMemOUT->eError = PVRSRV_ERROR_INVALID_HANDLE_TYPE;
3289
 
            return 0;
3290
 
    }
3291
 
 
3292
 
    
3293
 
    psMapMemInfoMemOUT->eError =
3294
 
        PVRSRVGetParentHandle(psPerProc->psHandleBase,
3295
 
                    &hParent,
3296
 
                    psMapMemInfoMemIN->hKernelMemInfo,
3297
 
                    eHandleType);
3298
 
    if (psMapMemInfoMemOUT->eError != PVRSRV_OK)
3299
 
    {
3300
 
        return 0;
3301
 
    }
3302
 
#if defined (SUPPORT_SID_INTERFACE)
3303
 
    if (hParent == 0)
3304
 
#else
3305
 
    if (hParent == IMG_NULL)
3306
 
#endif
3307
 
    {
3308
 
        hParent = psMapMemInfoMemIN->hKernelMemInfo;
3309
 
    }
3310
 
 
3311
 
    OSMemSet(&psMapMemInfoMemOUT->sClientMemInfo,
3312
 
             0,
3313
 
             sizeof(psMapMemInfoMemOUT->sClientMemInfo));
3314
 
 
3315
 
    psMapMemInfoMemOUT->sClientMemInfo.pvLinAddrKM =
3316
 
            psKernelMemInfo->pvLinAddrKM;
3317
 
 
3318
 
    psMapMemInfoMemOUT->sClientMemInfo.pvLinAddr = 0;
3319
 
    psMapMemInfoMemOUT->sClientMemInfo.sDevVAddr =
3320
 
        psKernelMemInfo->sDevVAddr;
3321
 
    psMapMemInfoMemOUT->sClientMemInfo.ui32Flags =
3322
 
        psKernelMemInfo->ui32Flags;
3323
 
    psMapMemInfoMemOUT->sClientMemInfo.uAllocSize =
3324
 
        psKernelMemInfo->uAllocSize;
3325
 
#if defined (SUPPORT_SID_INTERFACE)
3326
 
    if (psKernelMemInfo->sMemBlk.hOSMemHandle != IMG_NULL)
3327
 
    {
3328
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
3329
 
                          &psMapMemInfoMemOUT->sClientMemInfo.hMappingInfo,
3330
 
                          psKernelMemInfo->sMemBlk.hOSMemHandle,
3331
 
                          PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
3332
 
                          PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
3333
 
                          hParent);
3334
 
    }
3335
 
    else
3336
 
    {
3337
 
        psMapMemInfoMemOUT->sClientMemInfo.hMappingInfo = 0;
3338
 
    }
3339
 
#else
3340
 
    psMapMemInfoMemOUT->sClientMemInfo.hMappingInfo = psKernelMemInfo->sMemBlk.hOSMemHandle;
3341
 
#endif
3342
 
 
3343
 
    PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
3344
 
                      &psMapMemInfoMemOUT->sClientMemInfo.hKernelMemInfo,
3345
 
                      psKernelMemInfo,
3346
 
                      PVRSRV_HANDLE_TYPE_MEM_INFO_REF,
3347
 
                      PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
3348
 
                      hParent);
3349
 
 
3350
 
    if(psKernelMemInfo->ui32Flags & PVRSRV_MEM_NO_SYNCOBJ)
3351
 
    {
3352
 
        
3353
 
        OSMemSet(&psMapMemInfoMemOUT->sClientSyncInfo,
3354
 
                 0,
3355
 
                 sizeof (PVRSRV_CLIENT_SYNC_INFO));
3356
 
    }
3357
 
    else
3358
 
    {
3359
 
        
3360
 
#if !defined(PVRSRV_DISABLE_UM_SYNCOBJ_MAPPINGS)
3361
 
        psMapMemInfoMemOUT->sClientSyncInfo.psSyncData =
3362
 
            psKernelMemInfo->psKernelSyncInfo->psSyncData;
3363
 
        psMapMemInfoMemOUT->sClientSyncInfo.sWriteOpsCompleteDevVAddr =
3364
 
            psKernelMemInfo->psKernelSyncInfo->sWriteOpsCompleteDevVAddr;
3365
 
        psMapMemInfoMemOUT->sClientSyncInfo.sReadOpsCompleteDevVAddr =
3366
 
            psKernelMemInfo->psKernelSyncInfo->sReadOpsCompleteDevVAddr;
3367
 
 
3368
 
#if defined (SUPPORT_SID_INTERFACE)
3369
 
    if (psKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle != IMG_NULL)
3370
 
    {
3371
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
3372
 
                             &psMapMemInfoMemOUT->sClientSyncInfo.hMappingInfo,
3373
 
                             psKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle,
3374
 
                             PVRSRV_HANDLE_TYPE_SYNC_INFO,
3375
 
                             PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
3376
 
                             psMapMemInfoMemOUT->sClientMemInfo.hKernelMemInfo);
3377
 
    }
3378
 
    else
3379
 
    {
3380
 
        psMapMemInfoMemOUT->sClientSyncInfo.hMappingInfo = 0;
3381
 
    }
3382
 
#else
3383
 
        psMapMemInfoMemOUT->sClientSyncInfo.hMappingInfo =
3384
 
            psKernelMemInfo->psKernelSyncInfo->psSyncDataMemInfoKM->sMemBlk.hOSMemHandle;
3385
 
#endif
3386
 
#endif
3387
 
 
3388
 
        psMapMemInfoMemOUT->sClientMemInfo.psClientSyncInfo = &psMapMemInfoMemOUT->sClientSyncInfo;
3389
 
 
3390
 
        PVRSRVAllocSubHandleNR(psPerProc->psHandleBase,
3391
 
                               &psMapMemInfoMemOUT->sClientSyncInfo.hKernelSyncInfo,
3392
 
                               psKernelMemInfo->psKernelSyncInfo,
3393
 
                               PVRSRV_HANDLE_TYPE_SYNC_INFO,
3394
 
                               PVRSRV_HANDLE_ALLOC_FLAG_MULTI,
3395
 
                               psMapMemInfoMemOUT->sClientMemInfo.hKernelMemInfo);
3396
 
    }
3397
 
 
3398
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psMapMemInfoMemOUT->eError, psPerProc)
3399
 
 
3400
 
    return 0;
3401
 
}
3402
 
 
3403
 
 
3404
 
 
3405
 
static IMG_INT
3406
 
MMU_GetPDDevPAddrBW(IMG_UINT32 ui32BridgeID,
3407
 
                    PVRSRV_BRIDGE_IN_GETMMU_PD_DEVPADDR *psGetMmuPDDevPAddrIN,
3408
 
                    PVRSRV_BRIDGE_OUT_GETMMU_PD_DEVPADDR *psGetMmuPDDevPAddrOUT,
3409
 
                    PVRSRV_PER_PROCESS_DATA *psPerProc)
3410
 
{
3411
 
    IMG_HANDLE hDevMemContextInt;
3412
 
 
3413
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR);
3414
 
 
3415
 
    psGetMmuPDDevPAddrOUT->eError =
3416
 
        PVRSRVLookupHandle(psPerProc->psHandleBase, &hDevMemContextInt,
3417
 
                           psGetMmuPDDevPAddrIN->hDevMemContext,
3418
 
                           PVRSRV_HANDLE_TYPE_DEV_MEM_CONTEXT);
3419
 
    if(psGetMmuPDDevPAddrOUT->eError != PVRSRV_OK)
3420
 
    {
3421
 
        return 0;
3422
 
    }
3423
 
 
3424
 
    psGetMmuPDDevPAddrOUT->sPDDevPAddr =
3425
 
        BM_GetDeviceNode(hDevMemContextInt)->pfnMMUGetPDDevPAddr(BM_GetMMUContextFromMemContext(hDevMemContextInt));
3426
 
    if(psGetMmuPDDevPAddrOUT->sPDDevPAddr.uiAddr)
3427
 
    {
3428
 
        psGetMmuPDDevPAddrOUT->eError = PVRSRV_OK;
3429
 
    }
3430
 
    else
3431
 
    {
3432
 
        psGetMmuPDDevPAddrOUT->eError = PVRSRV_ERROR_INVALID_PHYS_ADDR;
3433
 
    }
3434
 
    return 0;
3435
 
}
3436
 
 
3437
 
 
3438
 
 
3439
 
IMG_INT
3440
 
DummyBW(IMG_UINT32 ui32BridgeID,
3441
 
        IMG_VOID *psBridgeIn,
3442
 
        IMG_VOID *psBridgeOut,
3443
 
        PVRSRV_PER_PROCESS_DATA *psPerProc)
3444
 
{
3445
 
#if !defined(DEBUG)
3446
 
    PVR_UNREFERENCED_PARAMETER(ui32BridgeID);
3447
 
#endif
3448
 
    PVR_UNREFERENCED_PARAMETER(psBridgeIn);
3449
 
    PVR_UNREFERENCED_PARAMETER(psBridgeOut);
3450
 
    PVR_UNREFERENCED_PARAMETER(psPerProc);
3451
 
 
3452
 
#if defined(DEBUG_BRIDGE_KM)
3453
 
    PVR_DPF((PVR_DBG_ERROR, "%s: BRIDGE ERROR: BridgeID %u (%s) mapped to "
3454
 
             "Dummy Wrapper (probably not what you want!)",
3455
 
             __FUNCTION__, ui32BridgeID, g_BridgeDispatchTable[ui32BridgeID].pszIOCName));
3456
 
#else
3457
 
    PVR_DPF((PVR_DBG_ERROR, "%s: BRIDGE ERROR: BridgeID %u mapped to "
3458
 
             "Dummy Wrapper (probably not what you want!)",
3459
 
             __FUNCTION__, ui32BridgeID));
3460
 
#endif
3461
 
    return -ENOTTY;
3462
 
}
3463
 
 
3464
 
 
3465
 
IMG_VOID
3466
 
_SetDispatchTableEntry(IMG_UINT32 ui32Index,
3467
 
                       const IMG_CHAR *pszIOCName,
3468
 
                       BridgeWrapperFunction pfFunction,
3469
 
                       const IMG_CHAR *pszFunctionName)
3470
 
{
3471
 
    static IMG_UINT32 ui32PrevIndex = ~0UL;     
3472
 
#if !defined(DEBUG)
3473
 
    PVR_UNREFERENCED_PARAMETER(pszIOCName);
3474
 
#endif
3475
 
#if !defined(DEBUG_BRIDGE_KM_DISPATCH_TABLE) && !defined(DEBUG_BRIDGE_KM)
3476
 
    PVR_UNREFERENCED_PARAMETER(pszFunctionName);
3477
 
#endif
3478
 
 
3479
 
#if defined(DEBUG_BRIDGE_KM_DISPATCH_TABLE)
3480
 
    
3481
 
    PVR_DPF((PVR_DBG_WARNING, "%s: %d %s %s", __FUNCTION__, ui32Index, pszIOCName, pszFunctionName));
3482
 
#endif
3483
 
 
3484
 
    
3485
 
    if(g_BridgeDispatchTable[ui32Index].pfFunction)
3486
 
    {
3487
 
#if defined(DEBUG_BRIDGE_KM)
3488
 
        PVR_DPF((PVR_DBG_ERROR,
3489
 
                 "%s: BUG!: Adding dispatch table entry for %s clobbers an existing entry for %s",
3490
 
                 __FUNCTION__, pszIOCName, g_BridgeDispatchTable[ui32Index].pszIOCName));
3491
 
#else
3492
 
        PVR_DPF((PVR_DBG_ERROR,
3493
 
                 "%s: BUG!: Adding dispatch table entry for %s clobbers an existing entry (index=%u)",
3494
 
                 __FUNCTION__, pszIOCName, ui32Index));
3495
 
#endif
3496
 
        PVR_DPF((PVR_DBG_ERROR, "NOTE: Enabling DEBUG_BRIDGE_KM_DISPATCH_TABLE may help debug this issue."));
3497
 
    }
3498
 
 
3499
 
    
3500
 
    if((ui32PrevIndex != ~0UL) &&
3501
 
       ((ui32Index >= ui32PrevIndex + DISPATCH_TABLE_GAP_THRESHOLD) ||
3502
 
        (ui32Index <= ui32PrevIndex)))
3503
 
    {
3504
 
#if defined(DEBUG_BRIDGE_KM)
3505
 
        PVR_DPF((PVR_DBG_WARNING,
3506
 
                 "%s: There is a gap in the dispatch table between indices %u (%s) and %u (%s)",
3507
 
                 __FUNCTION__, ui32PrevIndex, g_BridgeDispatchTable[ui32PrevIndex].pszIOCName,
3508
 
                 ui32Index, pszIOCName));
3509
 
#else
3510
 
        PVR_DPF((PVR_DBG_WARNING,
3511
 
                 "%s: There is a gap in the dispatch table between indices %u and %u (%s)",
3512
 
                 __FUNCTION__, (IMG_UINT)ui32PrevIndex, (IMG_UINT)ui32Index, pszIOCName));
3513
 
#endif
3514
 
        PVR_DPF((PVR_DBG_ERROR, "NOTE: Enabling DEBUG_BRIDGE_KM_DISPATCH_TABLE may help debug this issue."));
3515
 
    }
3516
 
 
3517
 
    g_BridgeDispatchTable[ui32Index].pfFunction = pfFunction;
3518
 
#if defined(DEBUG_BRIDGE_KM)
3519
 
    g_BridgeDispatchTable[ui32Index].pszIOCName = pszIOCName;
3520
 
    g_BridgeDispatchTable[ui32Index].pszFunctionName = pszFunctionName;
3521
 
    g_BridgeDispatchTable[ui32Index].ui32CallCount = 0;
3522
 
    g_BridgeDispatchTable[ui32Index].ui32CopyFromUserTotalBytes = 0;
3523
 
#endif
3524
 
 
3525
 
    ui32PrevIndex = ui32Index;
3526
 
}
3527
 
 
3528
 
static IMG_INT
3529
 
PVRSRVInitSrvConnectBW(IMG_UINT32 ui32BridgeID,
3530
 
                       IMG_VOID *psBridgeIn,
3531
 
                       PVRSRV_BRIDGE_RETURN *psRetOUT,
3532
 
                       PVRSRV_PER_PROCESS_DATA *psPerProc)
3533
 
{
3534
 
    PVR_UNREFERENCED_PARAMETER(psBridgeIn);
3535
 
 
3536
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_INITSRV_CONNECT);
3537
 
    PVR_UNREFERENCED_PARAMETER(psBridgeIn);
3538
 
 
3539
 
     
3540
 
    if((OSProcHasPrivSrvInit() == IMG_FALSE) || PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RUNNING) || PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RAN))
3541
 
    {
3542
 
        psRetOUT->eError = PVRSRV_ERROR_SRV_CONNECT_FAILED;
3543
 
        return 0;
3544
 
    }
3545
 
 
3546
 
#if defined (__linux__)
3547
 
    PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_RUNNING, IMG_TRUE);
3548
 
#endif
3549
 
    psPerProc->bInitProcess = IMG_TRUE;
3550
 
 
3551
 
    psRetOUT->eError = PVRSRV_OK;
3552
 
 
3553
 
    return 0;
3554
 
}
3555
 
 
3556
 
 
3557
 
static IMG_INT
3558
 
PVRSRVInitSrvDisconnectBW(IMG_UINT32 ui32BridgeID,
3559
 
                          PVRSRV_BRIDGE_IN_INITSRV_DISCONNECT *psInitSrvDisconnectIN,
3560
 
                          PVRSRV_BRIDGE_RETURN *psRetOUT,
3561
 
                          PVRSRV_PER_PROCESS_DATA *psPerProc)
3562
 
{
3563
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_INITSRV_DISCONNECT);
3564
 
 
3565
 
    if(!psPerProc->bInitProcess)
3566
 
    {
3567
 
        psRetOUT->eError = PVRSRV_ERROR_SRV_DISCONNECT_FAILED;
3568
 
        return 0;
3569
 
    }
3570
 
 
3571
 
    psPerProc->bInitProcess = IMG_FALSE;
3572
 
 
3573
 
    PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_RUNNING, IMG_FALSE);
3574
 
    PVRSRVSetInitServerState(PVRSRV_INIT_SERVER_RAN, IMG_TRUE);
3575
 
 
3576
 
    psRetOUT->eError = PVRSRVFinaliseSystem(psInitSrvDisconnectIN->bInitSuccesful);
3577
 
 
3578
 
    PVRSRVSetInitServerState( PVRSRV_INIT_SERVER_SUCCESSFUL ,
3579
 
                ((psRetOUT->eError == PVRSRV_OK) && (psInitSrvDisconnectIN->bInitSuccesful))
3580
 
                ? IMG_TRUE : IMG_FALSE);
3581
 
 
3582
 
    return 0;
3583
 
}
3584
 
 
3585
 
 
3586
 
static IMG_INT
3587
 
PVRSRVEventObjectWaitBW(IMG_UINT32 ui32BridgeID,
3588
 
                          PVRSRV_BRIDGE_IN_EVENT_OBJECT_WAIT *psEventObjectWaitIN,
3589
 
                          PVRSRV_BRIDGE_RETURN *psRetOUT,
3590
 
                          PVRSRV_PER_PROCESS_DATA *psPerProc)
3591
 
{
3592
 
    IMG_HANDLE hOSEventKM;
3593
 
 
3594
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_WAIT);
3595
 
 
3596
 
    psRetOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
3597
 
                           &hOSEventKM,
3598
 
                           psEventObjectWaitIN->hOSEventKM,
3599
 
                           PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
3600
 
 
3601
 
    if(psRetOUT->eError != PVRSRV_OK)
3602
 
    {
3603
 
        return 0;
3604
 
    }
3605
 
 
3606
 
    psRetOUT->eError = OSEventObjectWaitKM(hOSEventKM);
3607
 
 
3608
 
    return 0;
3609
 
}
3610
 
 
3611
 
 
3612
 
static IMG_INT
3613
 
PVRSRVEventObjectOpenBW(IMG_UINT32 ui32BridgeID,
3614
 
                          PVRSRV_BRIDGE_IN_EVENT_OBJECT_OPEN *psEventObjectOpenIN,
3615
 
                          PVRSRV_BRIDGE_OUT_EVENT_OBJECT_OPEN *psEventObjectOpenOUT,
3616
 
                          PVRSRV_PER_PROCESS_DATA *psPerProc)
3617
 
{
3618
 
#if defined (SUPPORT_SID_INTERFACE)
3619
 
    PVRSRV_EVENTOBJECT_KM sEventObject;
3620
 
    IMG_HANDLE hOSEvent;
3621
 
#endif
3622
 
 
3623
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_OPEN);
3624
 
 
3625
 
    NEW_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc, 1)
3626
 
 
3627
 
    psEventObjectOpenOUT->eError =
3628
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
3629
 
#if defined (SUPPORT_SID_INTERFACE)
3630
 
                           &sEventObject.hOSEventKM,
3631
 
#else
3632
 
                           &psEventObjectOpenIN->sEventObject.hOSEventKM,
3633
 
#endif
3634
 
                           psEventObjectOpenIN->sEventObject.hOSEventKM,
3635
 
                           PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
3636
 
 
3637
 
    if(psEventObjectOpenOUT->eError != PVRSRV_OK)
3638
 
    {
3639
 
        return 0;
3640
 
    }
3641
 
 
3642
 
#if defined (SUPPORT_SID_INTERFACE)
3643
 
    OSMemCopy(&sEventObject.szName,
3644
 
                           &psEventObjectOpenIN->sEventObject.szName,
3645
 
              EVENTOBJNAME_MAXLENGTH);
3646
 
 
3647
 
    psEventObjectOpenOUT->eError = OSEventObjectOpenKM(&sEventObject, &hOSEvent);
3648
 
#else
3649
 
    psEventObjectOpenOUT->eError = OSEventObjectOpenKM(&psEventObjectOpenIN->sEventObject, &psEventObjectOpenOUT->hOSEvent);
3650
 
#endif
3651
 
 
3652
 
    if(psEventObjectOpenOUT->eError != PVRSRV_OK)
3653
 
    {
3654
 
        return 0;
3655
 
    }
3656
 
 
3657
 
#if defined (SUPPORT_SID_INTERFACE)
3658
 
#if !defined (WINXP) && !defined(SUPPORT_VISTA)
3659
 
    PVRSRVAllocHandleNR(psPerProc->psHandleBase,
3660
 
                      &psEventObjectOpenOUT->hOSEvent,
3661
 
                      hOSEvent,
3662
 
                      PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT,
3663
 
                      PVRSRV_HANDLE_ALLOC_FLAG_MULTI);
3664
 
#endif
3665
 
#else
3666
 
    PVRSRVAllocHandleNR(psPerProc->psHandleBase,
3667
 
                      &psEventObjectOpenOUT->hOSEvent,
3668
 
                      psEventObjectOpenOUT->hOSEvent,
3669
 
                      PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT,
3670
 
                      PVRSRV_HANDLE_ALLOC_FLAG_MULTI);
3671
 
#endif
3672
 
 
3673
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psEventObjectOpenOUT->eError, psPerProc)
3674
 
 
3675
 
    return 0;
3676
 
}
3677
 
 
3678
 
 
3679
 
static IMG_INT
3680
 
PVRSRVEventObjectCloseBW(IMG_UINT32 ui32BridgeID,
3681
 
                          PVRSRV_BRIDGE_IN_EVENT_OBJECT_CLOSE *psEventObjectCloseIN,
3682
 
                          PVRSRV_BRIDGE_RETURN *psRetOUT,
3683
 
                          PVRSRV_PER_PROCESS_DATA *psPerProc)
3684
 
{
3685
 
    IMG_HANDLE hOSEventKM;
3686
 
#if defined (SUPPORT_SID_INTERFACE)
3687
 
    PVRSRV_EVENTOBJECT_KM sEventObject;
3688
 
#endif
3689
 
 
3690
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE);
3691
 
 
3692
 
    psRetOUT->eError =
3693
 
        PVRSRVLookupHandle(psPerProc->psHandleBase,
3694
 
#if defined (SUPPORT_SID_INTERFACE)
3695
 
                           &sEventObject.hOSEventKM,
3696
 
#else
3697
 
                           &psEventObjectCloseIN->sEventObject.hOSEventKM,
3698
 
#endif
3699
 
                           psEventObjectCloseIN->sEventObject.hOSEventKM,
3700
 
                           PVRSRV_HANDLE_TYPE_SHARED_EVENT_OBJECT);
3701
 
    if(psRetOUT->eError != PVRSRV_OK)
3702
 
    {
3703
 
        return 0;
3704
 
    }
3705
 
 
3706
 
    psRetOUT->eError = PVRSRVLookupAndReleaseHandle(psPerProc->psHandleBase,
3707
 
                           &hOSEventKM,
3708
 
                           psEventObjectCloseIN->hOSEventKM,
3709
 
                           PVRSRV_HANDLE_TYPE_EVENT_OBJECT_CONNECT);
3710
 
 
3711
 
    if(psRetOUT->eError != PVRSRV_OK)
3712
 
    {
3713
 
        return 0;
3714
 
    }
3715
 
 
3716
 
#if defined (SUPPORT_SID_INTERFACE)
3717
 
    if(CopyFromUserWrapper(psPerProc, ui32BridgeID,
3718
 
                           &sEventObject.szName,
3719
 
                           &psEventObjectCloseIN->sEventObject.szName,
3720
 
                           EVENTOBJNAME_MAXLENGTH) != PVRSRV_OK)
3721
 
    {
3722
 
        
3723
 
        return -EFAULT;
3724
 
    }
3725
 
 
3726
 
    psRetOUT->eError = OSEventObjectCloseKM(&sEventObject, hOSEventKM);
3727
 
#else
3728
 
    psRetOUT->eError = OSEventObjectCloseKM(&psEventObjectCloseIN->sEventObject, hOSEventKM);
3729
 
#endif
3730
 
 
3731
 
    return 0;
3732
 
}
3733
 
 
3734
 
 
3735
 
typedef struct _MODIFY_SYNC_OP_INFO
3736
 
{
3737
 
    IMG_HANDLE  hResItem;
3738
 
    PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
3739
 
    IMG_UINT32  ui32ModifyFlags;
3740
 
    IMG_UINT32  ui32ReadOpsPendingSnapShot;
3741
 
    IMG_UINT32  ui32WriteOpsPendingSnapShot;
3742
 
} MODIFY_SYNC_OP_INFO;
3743
 
 
3744
 
 
3745
 
static PVRSRV_ERROR DoQuerySyncOpsSatisfied(PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo,
3746
 
                                            IMG_UINT32 ui32ReadOpsPendingSnapShot,
3747
 
                                            IMG_UINT32 ui32WriteOpsPendingSnapShot)
3748
 
{
3749
 
    IMG_UINT32 ui32WriteOpsPending;
3750
 
    IMG_UINT32 ui32ReadOpsPending;
3751
 
 
3752
 
    
3753
 
    if (!psKernelSyncInfo)
3754
 
    {
3755
 
        return PVRSRV_ERROR_INVALID_PARAMS;
3756
 
    }
3757
 
 
3758
 
    
3759
 
 
3760
 
 
3761
 
 
3762
 
 
3763
 
 
3764
 
 
3765
 
 
3766
 
 
3767
 
 
3768
 
    ui32WriteOpsPending = psKernelSyncInfo->psSyncData->ui32WriteOpsPending;
3769
 
    ui32ReadOpsPending = psKernelSyncInfo->psSyncData->ui32ReadOpsPending;
3770
 
 
3771
 
    if((ui32WriteOpsPending - ui32WriteOpsPendingSnapShot >=
3772
 
        ui32WriteOpsPending - psKernelSyncInfo->psSyncData->ui32WriteOpsComplete) &&
3773
 
       (ui32ReadOpsPending - ui32ReadOpsPendingSnapShot >=
3774
 
        ui32ReadOpsPending - psKernelSyncInfo->psSyncData->ui32ReadOpsComplete))
3775
 
    {
3776
 
#if defined(PDUMP) && !defined(SUPPORT_VGX)
3777
 
        
3778
 
        PDumpComment("Poll for read ops complete to reach value (pdump: %u, actual snapshot: %u)",
3779
 
                     psKernelSyncInfo->psSyncData->ui32LastReadOpDumpVal,
3780
 
                     ui32ReadOpsPendingSnapShot);
3781
 
        PDumpMemPolKM(psKernelSyncInfo->psSyncDataMemInfoKM,
3782
 
                          offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
3783
 
                      psKernelSyncInfo->psSyncData->ui32LastReadOpDumpVal,
3784
 
                          0xFFFFFFFF,
3785
 
                      PDUMP_POLL_OPERATOR_EQUAL, 
3786
 
                          0,
3787
 
                          MAKEUNIQUETAG(psKernelSyncInfo->psSyncDataMemInfoKM));
3788
 
 
3789
 
        
3790
 
        PDumpComment("Poll for write ops complete to reach value (pdump: %u, actual snapshot: %u)",
3791
 
                     psKernelSyncInfo->psSyncData->ui32LastOpDumpVal,
3792
 
                     ui32WriteOpsPendingSnapShot);
3793
 
        PDumpMemPolKM(psKernelSyncInfo->psSyncDataMemInfoKM,
3794
 
                          offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
3795
 
                      psKernelSyncInfo->psSyncData->ui32LastOpDumpVal,
3796
 
                          0xFFFFFFFF,
3797
 
                      PDUMP_POLL_OPERATOR_EQUAL, 
3798
 
                          0,
3799
 
                          MAKEUNIQUETAG(psKernelSyncInfo->psSyncDataMemInfoKM));
3800
 
        
3801
 
 
3802
 
#endif
3803
 
        return PVRSRV_OK;
3804
 
    }
3805
 
    else
3806
 
    {
3807
 
        return PVRSRV_ERROR_RETRY;
3808
 
    }
3809
 
}
3810
 
 
3811
 
 
3812
 
static PVRSRV_ERROR DoModifyCompleteSyncOps(MODIFY_SYNC_OP_INFO *psModSyncOpInfo)
3813
 
{
3814
 
    PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
3815
 
 
3816
 
    psKernelSyncInfo = psModSyncOpInfo->psKernelSyncInfo;
3817
 
 
3818
 
    if (!psKernelSyncInfo)
3819
 
    {
3820
 
        return PVRSRV_ERROR_INVALID_PARAMS;
3821
 
    }
3822
 
 
3823
 
    
3824
 
    if((psModSyncOpInfo->ui32WriteOpsPendingSnapShot != psKernelSyncInfo->psSyncData->ui32WriteOpsComplete)
3825
 
       || (psModSyncOpInfo->ui32ReadOpsPendingSnapShot != psKernelSyncInfo->psSyncData->ui32ReadOpsComplete))
3826
 
    {
3827
 
        return PVRSRV_ERROR_BAD_SYNC_STATE;
3828
 
    }
3829
 
 
3830
 
    
3831
 
    if(psModSyncOpInfo->ui32ModifyFlags & PVRSRV_MODIFYSYNCOPS_FLAGS_WO_INC)
3832
 
    {
3833
 
        psKernelSyncInfo->psSyncData->ui32WriteOpsComplete++;
3834
 
    }
3835
 
 
3836
 
    
3837
 
    if(psModSyncOpInfo->ui32ModifyFlags & PVRSRV_MODIFYSYNCOPS_FLAGS_RO_INC)
3838
 
    {
3839
 
        psKernelSyncInfo->psSyncData->ui32ReadOpsComplete++;
3840
 
    }
3841
 
 
3842
 
    return PVRSRV_OK;
3843
 
}
3844
 
 
3845
 
 
3846
 
static PVRSRV_ERROR ModifyCompleteSyncOpsCallBack(IMG_PVOID     pvParam,
3847
 
                                                    IMG_UINT32  ui32Param,
3848
 
                                                    IMG_BOOL    bDummy)
3849
 
{
3850
 
    MODIFY_SYNC_OP_INFO     *psModSyncOpInfo;
3851
 
 
3852
 
    PVR_UNREFERENCED_PARAMETER(ui32Param);
3853
 
    PVR_UNREFERENCED_PARAMETER(bDummy);
3854
 
 
3855
 
    if (!pvParam)
3856
 
    {
3857
 
        PVR_DPF((PVR_DBG_ERROR, "ModifyCompleteSyncOpsCallBack: invalid parameter"));
3858
 
        return PVRSRV_ERROR_INVALID_PARAMS;
3859
 
    }
3860
 
 
3861
 
    psModSyncOpInfo = (MODIFY_SYNC_OP_INFO*)pvParam;
3862
 
 
3863
 
    if (psModSyncOpInfo->psKernelSyncInfo)
3864
 
    {
3865
 
        
3866
 
        LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
3867
 
        {
3868
 
            if (DoQuerySyncOpsSatisfied(psModSyncOpInfo->psKernelSyncInfo,
3869
 
                                        psModSyncOpInfo->ui32ReadOpsPendingSnapShot,
3870
 
                                        psModSyncOpInfo->ui32WriteOpsPendingSnapShot) == PVRSRV_OK)
3871
 
            {
3872
 
                goto OpFlushedComplete;
3873
 
            }
3874
 
            PVR_DPF((PVR_DBG_WARNING, "ModifyCompleteSyncOpsCallBack: waiting for current Ops to flush"));
3875
 
            OSSleepms(1);
3876
 
        } END_LOOP_UNTIL_TIMEOUT();
3877
 
 
3878
 
        PVR_DPF((PVR_DBG_ERROR, "ModifyCompleteSyncOpsCallBack: timeout whilst waiting for current Ops to flush."));
3879
 
        PVR_DPF((PVR_DBG_ERROR, "  Write ops pending snapshot = %d, write ops complete = %d",
3880
 
                 psModSyncOpInfo->ui32WriteOpsPendingSnapShot,
3881
 
                 psModSyncOpInfo->psKernelSyncInfo->psSyncData->ui32WriteOpsComplete));
3882
 
        PVR_DPF((PVR_DBG_ERROR, "  Read ops pending snapshot = %d, write ops complete = %d",
3883
 
                 psModSyncOpInfo->ui32ReadOpsPendingSnapShot,
3884
 
                 psModSyncOpInfo->psKernelSyncInfo->psSyncData->ui32ReadOpsComplete));
3885
 
 
3886
 
        return PVRSRV_ERROR_TIMEOUT;
3887
 
 
3888
 
    OpFlushedComplete:
3889
 
 
3890
 
        DoModifyCompleteSyncOps(psModSyncOpInfo);
3891
 
    }
3892
 
 
3893
 
    OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP,  sizeof(MODIFY_SYNC_OP_INFO), (IMG_VOID *)psModSyncOpInfo, 0);
3894
 
    
3895
 
 
3896
 
    
3897
 
    PVRSRVScheduleDeviceCallbacks();
3898
 
 
3899
 
    return PVRSRV_OK;
3900
 
}
3901
 
 
3902
 
 
3903
 
static IMG_INT
3904
 
PVRSRVCreateSyncInfoModObjBW(IMG_UINT32                                         ui32BridgeID,
3905
 
                                     IMG_VOID                                           *psBridgeIn,
3906
 
                                     PVRSRV_BRIDGE_OUT_CREATE_SYNC_INFO_MOD_OBJ  *psCreateSyncInfoModObjOUT,
3907
 
                                     PVRSRV_PER_PROCESS_DATA                            *psPerProc)
3908
 
{
3909
 
    MODIFY_SYNC_OP_INFO     *psModSyncOpInfo;
3910
 
 
3911
 
    PVR_UNREFERENCED_PARAMETER(psBridgeIn);
3912
 
 
3913
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_CREATE_SYNC_INFO_MOD_OBJ);
3914
 
 
3915
 
    NEW_HANDLE_BATCH_OR_ERROR(psCreateSyncInfoModObjOUT->eError, psPerProc, 1)
3916
 
 
3917
 
    ASSIGN_AND_EXIT_ON_ERROR(psCreateSyncInfoModObjOUT->eError,
3918
 
              OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
3919
 
              sizeof(MODIFY_SYNC_OP_INFO),
3920
 
              (IMG_VOID **)&psModSyncOpInfo, 0,
3921
 
              "ModSyncOpInfo (MODIFY_SYNC_OP_INFO)"));
3922
 
 
3923
 
    psModSyncOpInfo->psKernelSyncInfo = IMG_NULL; 
3924
 
 
3925
 
    psCreateSyncInfoModObjOUT->eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
3926
 
                                                                  &psCreateSyncInfoModObjOUT->hKernelSyncInfoModObj,
3927
 
                                                                  psModSyncOpInfo,
3928
 
                                                                  PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ,
3929
 
                                                                  PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE);
3930
 
 
3931
 
    if (psCreateSyncInfoModObjOUT->eError != PVRSRV_OK)
3932
 
    {
3933
 
        return 0;
3934
 
    }
3935
 
 
3936
 
    psModSyncOpInfo->hResItem = ResManRegisterRes(psPerProc->hResManContext,
3937
 
                                                  RESMAN_TYPE_MODIFY_SYNC_OPS,
3938
 
                                                  psModSyncOpInfo,
3939
 
                                                  0,
3940
 
                                                  &ModifyCompleteSyncOpsCallBack);
3941
 
 
3942
 
    COMMIT_HANDLE_BATCH_OR_ERROR(psCreateSyncInfoModObjOUT->eError, psPerProc)
3943
 
 
3944
 
    return 0;
3945
 
}
3946
 
 
3947
 
 
3948
 
static IMG_INT
3949
 
PVRSRVDestroySyncInfoModObjBW(IMG_UINT32                                          ui32BridgeID,
3950
 
                              PVRSRV_BRIDGE_IN_DESTROY_SYNC_INFO_MOD_OBJ          *psDestroySyncInfoModObjIN,
3951
 
                              PVRSRV_BRIDGE_RETURN                                *psDestroySyncInfoModObjOUT,
3952
 
                              PVRSRV_PER_PROCESS_DATA                             *psPerProc)
3953
 
{
3954
 
    MODIFY_SYNC_OP_INFO     *psModSyncOpInfo;
3955
 
 
3956
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DESTROY_SYNC_INFO_MOD_OBJ);
3957
 
 
3958
 
    psDestroySyncInfoModObjOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
3959
 
                                                                    (IMG_VOID**)&psModSyncOpInfo,
3960
 
                                                                    psDestroySyncInfoModObjIN->hKernelSyncInfoModObj,
3961
 
                                                                    PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
3962
 
    if (psDestroySyncInfoModObjOUT->eError != PVRSRV_OK)
3963
 
    {
3964
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVDestroySyncInfoModObjBW: PVRSRVLookupHandle failed"));
3965
 
        return 0;
3966
 
    }
3967
 
 
3968
 
    if(psModSyncOpInfo->psKernelSyncInfo != IMG_NULL)
3969
 
    {
3970
 
        
3971
 
        psDestroySyncInfoModObjOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
3972
 
        return 0;
3973
 
    }
3974
 
 
3975
 
    psDestroySyncInfoModObjOUT->eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
3976
 
                                                                     psDestroySyncInfoModObjIN->hKernelSyncInfoModObj,
3977
 
                                                                     PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
3978
 
 
3979
 
    if (psDestroySyncInfoModObjOUT->eError != PVRSRV_OK)
3980
 
    {
3981
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVDestroySyncInfoModObjBW: PVRSRVReleaseHandle failed"));
3982
 
        return 0;
3983
 
    }
3984
 
 
3985
 
    psDestroySyncInfoModObjOUT->eError = ResManFreeResByPtr(psModSyncOpInfo->hResItem, CLEANUP_WITH_POLL);
3986
 
    if (psDestroySyncInfoModObjOUT->eError != PVRSRV_OK)
3987
 
    {
3988
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVDestroySyncInfoModObjBW: ResManFreeResByPtr failed"));
3989
 
        return 0;
3990
 
    }
3991
 
 
3992
 
    return 0;
3993
 
}
3994
 
 
3995
 
 
3996
 
static IMG_INT
3997
 
PVRSRVModifyPendingSyncOpsBW(IMG_UINT32                                 ui32BridgeID,
3998
 
                              PVRSRV_BRIDGE_IN_MODIFY_PENDING_SYNC_OPS  *psModifySyncOpsIN,
3999
 
                              PVRSRV_BRIDGE_OUT_MODIFY_PENDING_SYNC_OPS *psModifySyncOpsOUT,
4000
 
                              PVRSRV_PER_PROCESS_DATA                   *psPerProc)
4001
 
{
4002
 
    PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
4003
 
    MODIFY_SYNC_OP_INFO     *psModSyncOpInfo;
4004
 
 
4005
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MODIFY_PENDING_SYNC_OPS);
4006
 
 
4007
 
    psModifySyncOpsOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
4008
 
                                                    (IMG_VOID**)&psModSyncOpInfo,
4009
 
                                                    psModifySyncOpsIN->hKernelSyncInfoModObj,
4010
 
                                                    PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
4011
 
    if (psModifySyncOpsOUT->eError != PVRSRV_OK)
4012
 
    {
4013
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyPendingSyncOpsBW: PVRSRVLookupHandle failed"));
4014
 
        return 0;
4015
 
    }
4016
 
 
4017
 
    psModifySyncOpsOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
4018
 
                                                    (IMG_VOID**)&psKernelSyncInfo,
4019
 
                                                    psModifySyncOpsIN->hKernelSyncInfo,
4020
 
                                                    PVRSRV_HANDLE_TYPE_SYNC_INFO);
4021
 
    if (psModifySyncOpsOUT->eError != PVRSRV_OK)
4022
 
    {
4023
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyPendingSyncOpsBW: PVRSRVLookupHandle failed"));
4024
 
        return 0;
4025
 
    }
4026
 
 
4027
 
    if(psModSyncOpInfo->psKernelSyncInfo)
4028
 
    {
4029
 
        
4030
 
        psModifySyncOpsOUT->eError = PVRSRV_ERROR_RETRY;
4031
 
        PVR_DPF((PVR_DBG_VERBOSE, "PVRSRVModifyPendingSyncOpsBW: SyncInfo Modification object is not empty"));
4032
 
        return 0;
4033
 
    }
4034
 
 
4035
 
    
4036
 
    psModSyncOpInfo->psKernelSyncInfo = psKernelSyncInfo;
4037
 
    psModSyncOpInfo->ui32ModifyFlags = psModifySyncOpsIN->ui32ModifyFlags;
4038
 
    psModSyncOpInfo->ui32ReadOpsPendingSnapShot = psKernelSyncInfo->psSyncData->ui32ReadOpsPending;
4039
 
    psModSyncOpInfo->ui32WriteOpsPendingSnapShot = psKernelSyncInfo->psSyncData->ui32WriteOpsPending;
4040
 
 
4041
 
    
4042
 
 
4043
 
    psModifySyncOpsOUT->ui32ReadOpsPending = psKernelSyncInfo->psSyncData->ui32ReadOpsPending;
4044
 
    psModifySyncOpsOUT->ui32WriteOpsPending = psKernelSyncInfo->psSyncData->ui32WriteOpsPending;
4045
 
 
4046
 
    if(psModifySyncOpsIN->ui32ModifyFlags & PVRSRV_MODIFYSYNCOPS_FLAGS_WO_INC)
4047
 
    {
4048
 
        psKernelSyncInfo->psSyncData->ui32WriteOpsPending++;
4049
 
    }
4050
 
 
4051
 
    if(psModifySyncOpsIN->ui32ModifyFlags & PVRSRV_MODIFYSYNCOPS_FLAGS_RO_INC)
4052
 
    {
4053
 
        psKernelSyncInfo->psSyncData->ui32ReadOpsPending++;
4054
 
    }
4055
 
 
4056
 
    
4057
 
    psModifySyncOpsOUT->eError = ResManDissociateRes(psModSyncOpInfo->hResItem,
4058
 
                                                     psPerProc->hResManContext);
4059
 
 
4060
 
    if (psModifySyncOpsOUT->eError != PVRSRV_OK)
4061
 
    {
4062
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyPendingSyncOpsBW: PVRSRVLookupHandle failed"));
4063
 
        return 0;
4064
 
    }
4065
 
 
4066
 
    return 0;
4067
 
}
4068
 
 
4069
 
 
4070
 
static IMG_INT
4071
 
PVRSRVModifyCompleteSyncOpsBW(IMG_UINT32                            ui32BridgeID,
4072
 
                      PVRSRV_BRIDGE_IN_MODIFY_COMPLETE_SYNC_OPS     *psModifySyncOpsIN,
4073
 
                      PVRSRV_BRIDGE_RETURN                          *psModifySyncOpsOUT,
4074
 
                      PVRSRV_PER_PROCESS_DATA                       *psPerProc)
4075
 
{
4076
 
    MODIFY_SYNC_OP_INFO     *psModSyncOpInfo;
4077
 
 
4078
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_MODIFY_COMPLETE_SYNC_OPS);
4079
 
 
4080
 
    psModifySyncOpsOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
4081
 
                                                    (IMG_VOID**)&psModSyncOpInfo,
4082
 
                                                    psModifySyncOpsIN->hKernelSyncInfoModObj,
4083
 
                                                    PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
4084
 
    if (psModifySyncOpsOUT->eError != PVRSRV_OK)
4085
 
    {
4086
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyCompleteSyncOpsBW: PVRSRVLookupHandle failed"));
4087
 
        return 0;
4088
 
    }
4089
 
 
4090
 
    if(psModSyncOpInfo->psKernelSyncInfo == IMG_NULL)
4091
 
    {
4092
 
        
4093
 
        psModifySyncOpsOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
4094
 
        return 0;
4095
 
    }
4096
 
 
4097
 
    psModifySyncOpsOUT->eError = DoModifyCompleteSyncOps(psModSyncOpInfo);
4098
 
 
4099
 
    if (psModifySyncOpsOUT->eError != PVRSRV_OK)
4100
 
    {
4101
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVModifyCompleteSyncOpsBW: DoModifyCompleteSyncOps failed"));
4102
 
        return 0;
4103
 
    }
4104
 
 
4105
 
    psModSyncOpInfo->psKernelSyncInfo = IMG_NULL;
4106
 
 
4107
 
    
4108
 
    PVRSRVScheduleDeviceCallbacks();
4109
 
 
4110
 
    return 0;
4111
 
}
4112
 
 
4113
 
 
4114
 
static IMG_INT
4115
 
PVRSRVSyncOpsTakeTokenBW(IMG_UINT32                                 ui32BridgeID,
4116
 
                         PVRSRV_BRIDGE_IN_SYNC_OPS_TAKE_TOKEN       *psSyncOpsTakeTokenIN,
4117
 
                         PVRSRV_BRIDGE_OUT_SYNC_OPS_TAKE_TOKEN      *psSyncOpsTakeTokenOUT,
4118
 
                         PVRSRV_PER_PROCESS_DATA                    *psPerProc)
4119
 
{
4120
 
    PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
4121
 
 
4122
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_OPS_TAKE_TOKEN);
4123
 
 
4124
 
    psSyncOpsTakeTokenOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
4125
 
                                                       (IMG_VOID**)&psKernelSyncInfo,
4126
 
                                                       psSyncOpsTakeTokenIN->hKernelSyncInfo,
4127
 
                                                       PVRSRV_HANDLE_TYPE_SYNC_INFO);
4128
 
    if (psSyncOpsTakeTokenOUT->eError != PVRSRV_OK)
4129
 
    {
4130
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncOpsTakeTokenBW: PVRSRVLookupHandle failed"));
4131
 
        return 0;
4132
 
    }
4133
 
 
4134
 
    
4135
 
 
4136
 
    psSyncOpsTakeTokenOUT->ui32ReadOpsPending = psKernelSyncInfo->psSyncData->ui32ReadOpsPending;
4137
 
    psSyncOpsTakeTokenOUT->ui32WriteOpsPending = psKernelSyncInfo->psSyncData->ui32WriteOpsPending;
4138
 
 
4139
 
    return 0;
4140
 
}
4141
 
 
4142
 
 
4143
 
static IMG_INT
4144
 
PVRSRVSyncOpsFlushToTokenBW(IMG_UINT32                                         ui32BridgeID,
4145
 
                            PVRSRV_BRIDGE_IN_SYNC_OPS_FLUSH_TO_TOKEN           *psSyncOpsFlushToTokenIN,
4146
 
                            PVRSRV_BRIDGE_RETURN                               *psSyncOpsFlushToTokenOUT,
4147
 
                            PVRSRV_PER_PROCESS_DATA                            *psPerProc)
4148
 
{
4149
 
    PVRSRV_KERNEL_SYNC_INFO *psKernelSyncInfo;
4150
 
    IMG_UINT32 ui32ReadOpsPendingSnapshot;
4151
 
    IMG_UINT32 ui32WriteOpsPendingSnapshot;
4152
 
 
4153
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_TOKEN);
4154
 
 
4155
 
    psSyncOpsFlushToTokenOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
4156
 
                                                          (IMG_VOID**)&psKernelSyncInfo,
4157
 
                                                          psSyncOpsFlushToTokenIN->hKernelSyncInfo,
4158
 
                                                          PVRSRV_HANDLE_TYPE_SYNC_INFO);
4159
 
    if (psSyncOpsFlushToTokenOUT->eError != PVRSRV_OK)
4160
 
    {
4161
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncOpsFlushToTokenBW: PVRSRVLookupHandle failed"));
4162
 
        return 0;
4163
 
    }
4164
 
 
4165
 
    ui32ReadOpsPendingSnapshot = psSyncOpsFlushToTokenIN->ui32ReadOpsPendingSnapshot;
4166
 
    ui32WriteOpsPendingSnapshot = psSyncOpsFlushToTokenIN->ui32WriteOpsPendingSnapshot;
4167
 
 
4168
 
    psSyncOpsFlushToTokenOUT->eError = DoQuerySyncOpsSatisfied(psKernelSyncInfo,
4169
 
                                                               ui32ReadOpsPendingSnapshot,
4170
 
                                                               ui32WriteOpsPendingSnapshot);
4171
 
 
4172
 
    if (psSyncOpsFlushToTokenOUT->eError != PVRSRV_OK && psSyncOpsFlushToTokenOUT->eError != PVRSRV_ERROR_RETRY)
4173
 
    {
4174
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncOpsFlushToTokenBW: DoQuerySyncOpsSatisfied failed"));
4175
 
        return 0;
4176
 
    }
4177
 
 
4178
 
    return 0;
4179
 
}
4180
 
 
4181
 
 
4182
 
static IMG_INT
4183
 
PVRSRVSyncOpsFlushToModObjBW(IMG_UINT32                                         ui32BridgeID,
4184
 
                             PVRSRV_BRIDGE_IN_SYNC_OPS_FLUSH_TO_MOD_OBJ         *psSyncOpsFlushToModObjIN,
4185
 
                             PVRSRV_BRIDGE_RETURN                               *psSyncOpsFlushToModObjOUT,
4186
 
                             PVRSRV_PER_PROCESS_DATA                            *psPerProc)
4187
 
{
4188
 
    MODIFY_SYNC_OP_INFO     *psModSyncOpInfo;
4189
 
 
4190
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_MOD_OBJ);
4191
 
 
4192
 
    psSyncOpsFlushToModObjOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
4193
 
                                                           (IMG_VOID**)&psModSyncOpInfo,
4194
 
                                                           psSyncOpsFlushToModObjIN->hKernelSyncInfoModObj,
4195
 
                                                           PVRSRV_HANDLE_TYPE_SYNC_INFO_MOD_OBJ);
4196
 
    if (psSyncOpsFlushToModObjOUT->eError != PVRSRV_OK)
4197
 
    {
4198
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncOpsFlushToModObjBW: PVRSRVLookupHandle failed"));
4199
 
        return 0;
4200
 
    }
4201
 
 
4202
 
    if(psModSyncOpInfo->psKernelSyncInfo == IMG_NULL)
4203
 
    {
4204
 
        
4205
 
        psSyncOpsFlushToModObjOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
4206
 
        return 0;
4207
 
    }
4208
 
 
4209
 
    psSyncOpsFlushToModObjOUT->eError = DoQuerySyncOpsSatisfied(psModSyncOpInfo->psKernelSyncInfo,
4210
 
                                                                psModSyncOpInfo->ui32ReadOpsPendingSnapShot,
4211
 
                                                                psModSyncOpInfo->ui32WriteOpsPendingSnapShot);
4212
 
 
4213
 
    if (psSyncOpsFlushToModObjOUT->eError != PVRSRV_OK && psSyncOpsFlushToModObjOUT->eError != PVRSRV_ERROR_RETRY)
4214
 
    {
4215
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncOpsFlushToModObjBW: DoQuerySyncOpsSatisfied failed"));
4216
 
        return 0;
4217
 
    }
4218
 
 
4219
 
    return 0;
4220
 
}
4221
 
 
4222
 
 
4223
 
static IMG_INT
4224
 
PVRSRVSyncOpsFlushToDeltaBW(IMG_UINT32                                         ui32BridgeID,
4225
 
                            PVRSRV_BRIDGE_IN_SYNC_OPS_FLUSH_TO_DELTA           *psSyncOpsFlushToDeltaIN,
4226
 
                            PVRSRV_BRIDGE_RETURN                               *psSyncOpsFlushToDeltaOUT,
4227
 
                            PVRSRV_PER_PROCESS_DATA                            *psPerProc)
4228
 
{
4229
 
    PVRSRV_KERNEL_SYNC_INFO     *psSyncInfo;
4230
 
    IMG_UINT32 ui32DeltaRead;
4231
 
    IMG_UINT32 ui32DeltaWrite;
4232
 
 
4233
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_DELTA);
4234
 
 
4235
 
    psSyncOpsFlushToDeltaOUT->eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
4236
 
                                                          (IMG_VOID**)&psSyncInfo,
4237
 
                                                          psSyncOpsFlushToDeltaIN->hKernelSyncInfo,
4238
 
                                                          PVRSRV_HANDLE_TYPE_SYNC_INFO);
4239
 
    if (psSyncOpsFlushToDeltaOUT->eError != PVRSRV_OK)
4240
 
    {
4241
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncOpsFlushToDeltaBW: PVRSRVLookupHandle failed"));
4242
 
        return 0;
4243
 
    }
4244
 
 
4245
 
    
4246
 
    ui32DeltaRead = psSyncInfo->psSyncData->ui32ReadOpsPending - psSyncInfo->psSyncData->ui32ReadOpsComplete;
4247
 
    ui32DeltaWrite = psSyncInfo->psSyncData->ui32WriteOpsPending - psSyncInfo->psSyncData->ui32WriteOpsComplete;
4248
 
 
4249
 
    if (ui32DeltaRead <= psSyncOpsFlushToDeltaIN->ui32Delta && ui32DeltaWrite <= psSyncOpsFlushToDeltaIN->ui32Delta)
4250
 
    {
4251
 
#if defined(PDUMP) && !defined(SUPPORT_VGX)
4252
 
        
4253
 
        PDumpComment("Poll for read ops complete to delta (%u)",
4254
 
                     psSyncOpsFlushToDeltaIN->ui32Delta);
4255
 
        psSyncOpsFlushToDeltaOUT->eError =
4256
 
            PDumpMemPolKM(psSyncInfo->psSyncDataMemInfoKM,
4257
 
                          offsetof(PVRSRV_SYNC_DATA, ui32ReadOpsComplete),
4258
 
                          psSyncInfo->psSyncData->ui32LastReadOpDumpVal,
4259
 
                          0xFFFFFFFF,
4260
 
                          PDUMP_POLL_OPERATOR_GREATEREQUAL,
4261
 
                          0,
4262
 
                          MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
4263
 
 
4264
 
        
4265
 
        PDumpComment("Poll for write ops complete to delta (%u)",
4266
 
                     psSyncOpsFlushToDeltaIN->ui32Delta);
4267
 
        psSyncOpsFlushToDeltaOUT->eError =
4268
 
            PDumpMemPolKM(psSyncInfo->psSyncDataMemInfoKM,
4269
 
                          offsetof(PVRSRV_SYNC_DATA, ui32WriteOpsComplete),
4270
 
                          psSyncInfo->psSyncData->ui32LastOpDumpVal,
4271
 
                          0xFFFFFFFF,
4272
 
                          PDUMP_POLL_OPERATOR_GREATEREQUAL,
4273
 
                          0,
4274
 
                          MAKEUNIQUETAG(psSyncInfo->psSyncDataMemInfoKM));
4275
 
#endif
4276
 
 
4277
 
        psSyncOpsFlushToDeltaOUT->eError = PVRSRV_OK;
4278
 
    }
4279
 
    else
4280
 
    {
4281
 
        psSyncOpsFlushToDeltaOUT->eError = PVRSRV_ERROR_RETRY;
4282
 
    }
4283
 
 
4284
 
    return 0;
4285
 
}
4286
 
 
4287
 
 
4288
 
static PVRSRV_ERROR
4289
 
FreeSyncInfoCallback(IMG_PVOID  pvParam,
4290
 
                     IMG_UINT32 ui32Param,
4291
 
                     IMG_BOOL   bDummy)
4292
 
{
4293
 
    PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
4294
 
    PVRSRV_ERROR eError;
4295
 
 
4296
 
    PVR_UNREFERENCED_PARAMETER(ui32Param);
4297
 
    PVR_UNREFERENCED_PARAMETER(bDummy);
4298
 
 
4299
 
    psSyncInfo = (PVRSRV_KERNEL_SYNC_INFO *)pvParam;
4300
 
 
4301
 
    eError = PVRSRVFreeSyncInfoKM(psSyncInfo);
4302
 
    if (eError != PVRSRV_OK)
4303
 
    {
4304
 
        return eError;
4305
 
    }
4306
 
 
4307
 
    return PVRSRV_OK;
4308
 
}
4309
 
 
4310
 
 
4311
 
static IMG_INT
4312
 
PVRSRVAllocSyncInfoBW(IMG_UINT32                                         ui32BridgeID,
4313
 
                      PVRSRV_BRIDGE_IN_ALLOC_SYNC_INFO                  *psAllocSyncInfoIN,
4314
 
                      PVRSRV_BRIDGE_OUT_ALLOC_SYNC_INFO                 *psAllocSyncInfoOUT,
4315
 
                      PVRSRV_PER_PROCESS_DATA                           *psPerProc)
4316
 
{
4317
 
    PVRSRV_KERNEL_SYNC_INFO     *psSyncInfo;
4318
 
    PVRSRV_ERROR eError;
4319
 
    PVRSRV_DEVICE_NODE *psDeviceNode;
4320
 
    IMG_HANDLE hDevMemContext;
4321
 
 
4322
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_ALLOC_SYNC_INFO);
4323
 
 
4324
 
    NEW_HANDLE_BATCH_OR_ERROR(psAllocSyncInfoOUT->eError, psPerProc, 1)
4325
 
 
4326
 
    eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
4327
 
                                (IMG_HANDLE *)&psDeviceNode,
4328
 
                                psAllocSyncInfoIN->hDevCookie,
4329
 
                                PVRSRV_HANDLE_TYPE_DEV_NODE);
4330
 
    if(eError != PVRSRV_OK)
4331
 
    {
4332
 
        goto allocsyncinfo_errorexit;
4333
 
    }
4334
 
 
4335
 
    hDevMemContext = psDeviceNode->sDevMemoryInfo.pBMKernelContext;
4336
 
 
4337
 
    eError = PVRSRVAllocSyncInfoKM(psDeviceNode,
4338
 
                                   hDevMemContext,
4339
 
                                   &psSyncInfo);
4340
 
 
4341
 
    if (eError != PVRSRV_OK)
4342
 
    {
4343
 
        goto allocsyncinfo_errorexit;
4344
 
    }
4345
 
 
4346
 
    eError = PVRSRVAllocHandle(psPerProc->psHandleBase,
4347
 
                               &psAllocSyncInfoOUT->hKernelSyncInfo,
4348
 
                               psSyncInfo,
4349
 
                               PVRSRV_HANDLE_TYPE_SYNC_INFO,
4350
 
                               PVRSRV_HANDLE_ALLOC_FLAG_PRIVATE);
4351
 
 
4352
 
    if(eError != PVRSRV_OK)
4353
 
    {
4354
 
        goto allocsyncinfo_errorexit_freesyncinfo;
4355
 
    }
4356
 
 
4357
 
    psSyncInfo->hResItem = ResManRegisterRes(psPerProc->hResManContext,
4358
 
                                               RESMAN_TYPE_SYNC_INFO,
4359
 
                                               psSyncInfo,
4360
 
                                               0,
4361
 
                                               FreeSyncInfoCallback);
4362
 
 
4363
 
    
4364
 
    goto allocsyncinfo_commit;
4365
 
 
4366
 
    
4367
 
 allocsyncinfo_errorexit_freesyncinfo:
4368
 
    PVRSRVFreeSyncInfoKM(psSyncInfo);
4369
 
 
4370
 
 allocsyncinfo_errorexit:
4371
 
 
4372
 
    
4373
 
 allocsyncinfo_commit:
4374
 
    psAllocSyncInfoOUT->eError = eError;
4375
 
    COMMIT_HANDLE_BATCH_OR_ERROR(eError, psPerProc);
4376
 
 
4377
 
    return 0;
4378
 
}
4379
 
 
4380
 
 
4381
 
static IMG_INT
4382
 
PVRSRVFreeSyncInfoBW(IMG_UINT32                                          ui32BridgeID,
4383
 
                     PVRSRV_BRIDGE_IN_FREE_SYNC_INFO                     *psFreeSyncInfoIN,
4384
 
                     PVRSRV_BRIDGE_RETURN                                *psFreeSyncInfoOUT,
4385
 
                     PVRSRV_PER_PROCESS_DATA                             *psPerProc)
4386
 
{
4387
 
    PVRSRV_KERNEL_SYNC_INFO *psSyncInfo;
4388
 
    PVRSRV_ERROR eError;
4389
 
 
4390
 
    PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_FREE_SYNC_INFO);
4391
 
 
4392
 
    eError = PVRSRVLookupHandle(psPerProc->psHandleBase,
4393
 
                                (IMG_VOID**)&psSyncInfo,
4394
 
                                psFreeSyncInfoIN->hKernelSyncInfo,
4395
 
                                PVRSRV_HANDLE_TYPE_SYNC_INFO);
4396
 
    if (eError != PVRSRV_OK)
4397
 
    {
4398
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeSyncInfoBW: PVRSRVLookupHandle failed"));
4399
 
        psFreeSyncInfoOUT->eError = eError;
4400
 
        return 0;
4401
 
    }
4402
 
 
4403
 
    eError = PVRSRVReleaseHandle(psPerProc->psHandleBase,
4404
 
                                 psFreeSyncInfoIN->hKernelSyncInfo,
4405
 
                                 PVRSRV_HANDLE_TYPE_SYNC_INFO);
4406
 
 
4407
 
    if (eError != PVRSRV_OK)
4408
 
    {
4409
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeSyncInfoBW: PVRSRVReleaseHandle failed"));
4410
 
        psFreeSyncInfoOUT->eError = eError;
4411
 
        return 0;
4412
 
    }
4413
 
 
4414
 
    eError = ResManFreeResByPtr(psSyncInfo->hResItem, CLEANUP_WITH_POLL);
4415
 
    if (eError != PVRSRV_OK)
4416
 
    {
4417
 
        PVR_DPF((PVR_DBG_ERROR, "PVRSRVFreeSyncInfoBW: ResManFreeResByPtr failed"));
4418
 
        psFreeSyncInfoOUT->eError = eError;
4419
 
        return 0;
4420
 
    }
4421
 
 
4422
 
    return 0;
4423
 
}
4424
 
 
4425
 
 
4426
 
PVRSRV_ERROR
4427
 
CommonBridgeInit(IMG_VOID)
4428
 
{
4429
 
    IMG_UINT32 i;
4430
 
 
4431
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_DEVICES, PVRSRVEnumerateDevicesBW);
4432
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO, PVRSRVAcquireDeviceDataBW);
4433
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_RELEASE_DEVICEINFO, DummyBW);
4434
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_DEVMEMCONTEXT, PVRSRVCreateDeviceMemContextBW);
4435
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_DEVMEMCONTEXT, PVRSRVDestroyDeviceMemContextBW);
4436
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DEVMEM_HEAPINFO, PVRSRVGetDeviceMemHeapInfoBW);
4437
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_ALLOC_DEVICEMEM, PVRSRVAllocDeviceMemBW);
4438
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_DEVICEMEM, PVRSRVFreeDeviceMemBW);
4439
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GETFREE_DEVICEMEM, PVRSRVGetFreeDeviceMemBW);
4440
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_COMMANDQUEUE, DummyBW);
4441
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_COMMANDQUEUE, DummyBW);
4442
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MHANDLE_TO_MMAP_DATA, PVRMMapOSMemHandleToMMapDataBW);
4443
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_CONNECT_SERVICES, PVRSRVConnectBW);
4444
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_DISCONNECT_SERVICES, PVRSRVDisconnectBW);
4445
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_WRAP_DEVICE_MEM, DummyBW);
4446
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DEVICEMEMINFO, DummyBW);
4447
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_RESERVE_DEV_VIRTMEM , DummyBW);
4448
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_DEV_VIRTMEM, DummyBW);
4449
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_EXT_MEMORY, DummyBW);
4450
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_EXT_MEMORY, DummyBW);
4451
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_DEV_MEMORY, PVRSRVMapDeviceMemoryBW);
4452
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_DEV_MEMORY, PVRSRVUnmapDeviceMemoryBW);
4453
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY, PVRSRVMapDeviceClassMemoryBW);
4454
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_DEVICECLASS_MEMORY, PVRSRVUnmapDeviceClassMemoryBW);
4455
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_MEM_INFO_TO_USER, DummyBW);
4456
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAP_MEM_INFO_FROM_USER, DummyBW);
4457
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_EXPORT_DEVICEMEM, PVRSRVExportDeviceMemBW);
4458
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_RELEASE_MMAP_DATA, PVRMMapReleaseMMapDataBW);
4459
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_CHG_DEV_MEM_ATTRIBS, PVRSRVChangeDeviceMemoryAttributesBW);
4460
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_DEV_MEMORY_2, PVRSRVMapDeviceMemoryBW);
4461
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_EXPORT_DEVICEMEM_2, PVRSRVExportDeviceMemBW);
4462
 
 
4463
 
    
4464
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PROCESS_SIMISR_EVENT, DummyBW);
4465
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_REGISTER_SIM_PROCESS, DummyBW);
4466
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_UNREGISTER_SIM_PROCESS, DummyBW);
4467
 
 
4468
 
    
4469
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MAPPHYSTOUSERSPACE, DummyBW);
4470
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_UNMAPPHYSTOUSERSPACE, DummyBW);
4471
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GETPHYSTOUSERSPACEMAP, DummyBW);
4472
 
 
4473
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_FB_STATS, DummyBW);
4474
 
 
4475
 
    
4476
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_MISC_INFO, PVRSRVGetMiscInfoBW);
4477
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_RELEASE_MISC_INFO, DummyBW);
4478
 
 
4479
 
    
4480
 
#if defined (SUPPORT_OVERLAY_ROTATE_BLIT)
4481
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_INIT_3D_OVL_BLT_RES, DummyBW);
4482
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_DEINIT_3D_OVL_BLT_RES, DummyBW);
4483
 
#endif
4484
 
 
4485
 
 
4486
 
    
4487
 
#if defined(PDUMP)
4488
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_INIT, DummyBW);
4489
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_MEMPOL, PDumpMemPolBW);
4490
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPMEM, PDumpMemBW);
4491
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_REG, PDumpRegWithFlagsBW);
4492
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_REGPOL, PDumpRegPolBW);
4493
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_COMMENT, PDumpCommentBW);
4494
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_SETFRAME, PDumpSetFrameBW);
4495
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_ISCAPTURING, PDumpIsCaptureFrameBW);
4496
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPBITMAP, PDumpBitmapBW);
4497
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPREADREG, PDumpReadRegBW);
4498
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_SYNCPOL, PDumpSyncPolBW);
4499
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPSYNC, PDumpSyncDumpBW);
4500
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_MEMPAGES, PDumpMemPagesBW);
4501
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DRIVERINFO, PDumpDriverInfoBW);
4502
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_DUMPPDDEVPADDR, PDumpPDDevPAddrBW);
4503
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_CYCLE_COUNT_REG_READ, PDumpCycleCountRegReadBW);
4504
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_STARTINITPHASE, PDumpStartInitPhaseBW);
4505
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_PDUMP_STOPINITPHASE, PDumpStopInitPhaseBW);
4506
 
#endif 
4507
 
 
4508
 
    
4509
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_OEMJTABLE, DummyBW);
4510
 
 
4511
 
    
4512
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_CLASS, PVRSRVEnumerateDCBW);
4513
 
 
4514
 
    
4515
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_OPEN_DISPCLASS_DEVICE, PVRSRVOpenDCDeviceBW);
4516
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_CLOSE_DISPCLASS_DEVICE, PVRSRVCloseDCDeviceBW);
4517
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_DISPCLASS_FORMATS, PVRSRVEnumDCFormatsBW);
4518
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_ENUM_DISPCLASS_DIMS, PVRSRVEnumDCDimsBW);
4519
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DISPCLASS_SYSBUFFER, PVRSRVGetDCSystemBufferBW);
4520
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DISPCLASS_INFO, PVRSRVGetDCInfoBW);
4521
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_DISPCLASS_SWAPCHAIN, PVRSRVCreateDCSwapChainBW);
4522
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_DISPCLASS_SWAPCHAIN, PVRSRVDestroyDCSwapChainBW);
4523
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_DSTRECT, PVRSRVSetDCDstRectBW);
4524
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_SRCRECT, PVRSRVSetDCSrcRectBW);
4525
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_DSTCOLOURKEY, PVRSRVSetDCDstColourKeyBW);
4526
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SET_DISPCLASS_SRCCOLOURKEY, PVRSRVSetDCSrcColourKeyBW);
4527
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_DISPCLASS_BUFFERS, PVRSRVGetDCBuffersBW);
4528
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_BUFFER, PVRSRVSwapToDCBufferBW);
4529
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SWAP_DISPCLASS_TO_SYSTEM, PVRSRVSwapToDCSystemBW);
4530
 
 
4531
 
    
4532
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_OPEN_BUFFERCLASS_DEVICE, PVRSRVOpenBCDeviceBW);
4533
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_CLOSE_BUFFERCLASS_DEVICE, PVRSRVCloseBCDeviceBW);
4534
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_BUFFERCLASS_INFO, PVRSRVGetBCInfoBW);
4535
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GET_BUFFERCLASS_BUFFER, PVRSRVGetBCBufferBW);
4536
 
 
4537
 
    
4538
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_WRAP_EXT_MEMORY, PVRSRVWrapExtMemoryBW);
4539
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_UNWRAP_EXT_MEMORY, PVRSRVUnwrapExtMemoryBW);
4540
 
 
4541
 
    
4542
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_ALLOC_SHARED_SYS_MEM, PVRSRVAllocSharedSysMemoryBW);
4543
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_SHARED_SYS_MEM, PVRSRVFreeSharedSysMemoryBW);
4544
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MAP_MEMINFO_MEM, PVRSRVMapMemInfoMemBW);
4545
 
 
4546
 
    
4547
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_GETMMU_PD_DEVPADDR, MMU_GetPDDevPAddrBW);
4548
 
 
4549
 
    
4550
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_INITSRV_CONNECT,    &PVRSRVInitSrvConnectBW);
4551
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_INITSRV_DISCONNECT, &PVRSRVInitSrvDisconnectBW);
4552
 
 
4553
 
    
4554
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_WAIT,  &PVRSRVEventObjectWaitBW);
4555
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_OPEN,  &PVRSRVEventObjectOpenBW);
4556
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_EVENT_OBJECT_CLOSE, &PVRSRVEventObjectCloseBW);
4557
 
 
4558
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_CREATE_SYNC_INFO_MOD_OBJ, PVRSRVCreateSyncInfoModObjBW);
4559
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_DESTROY_SYNC_INFO_MOD_OBJ, PVRSRVDestroySyncInfoModObjBW);
4560
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MODIFY_PENDING_SYNC_OPS, PVRSRVModifyPendingSyncOpsBW);
4561
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_MODIFY_COMPLETE_SYNC_OPS, PVRSRVModifyCompleteSyncOpsBW);
4562
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SYNC_OPS_TAKE_TOKEN, PVRSRVSyncOpsTakeTokenBW);
4563
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_TOKEN, PVRSRVSyncOpsFlushToTokenBW);
4564
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_MOD_OBJ, PVRSRVSyncOpsFlushToModObjBW);
4565
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_SYNC_OPS_FLUSH_TO_DELTA, PVRSRVSyncOpsFlushToDeltaBW);
4566
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_ALLOC_SYNC_INFO, PVRSRVAllocSyncInfoBW);
4567
 
    SetDispatchTableEntry(PVRSRV_BRIDGE_FREE_SYNC_INFO, PVRSRVFreeSyncInfoBW);
4568
 
 
4569
 
#if defined (SUPPORT_SGX)
4570
 
    SetSGXDispatchTableEntry();
4571
 
#endif
4572
 
#if defined (SUPPORT_VGX)
4573
 
    SetVGXDispatchTableEntry();
4574
 
#endif
4575
 
#if defined (SUPPORT_MSVDX)
4576
 
    SetMSVDXDispatchTableEntry();
4577
 
#endif
4578
 
 
4579
 
 
4580
 
    
4581
 
    
4582
 
    for(i=0;i<BRIDGE_DISPATCH_TABLE_ENTRY_COUNT;i++)
4583
 
    {
4584
 
        if(!g_BridgeDispatchTable[i].pfFunction)
4585
 
        {
4586
 
            g_BridgeDispatchTable[i].pfFunction = &DummyBW;
4587
 
#if defined(DEBUG_BRIDGE_KM)
4588
 
            g_BridgeDispatchTable[i].pszIOCName = "_PVRSRV_BRIDGE_DUMMY";
4589
 
            g_BridgeDispatchTable[i].pszFunctionName = "DummyBW";
4590
 
            g_BridgeDispatchTable[i].ui32CallCount = 0;
4591
 
            g_BridgeDispatchTable[i].ui32CopyFromUserTotalBytes = 0;
4592
 
            g_BridgeDispatchTable[i].ui32CopyToUserTotalBytes = 0;
4593
 
#endif
4594
 
        }
4595
 
    }
4596
 
 
4597
 
    return PVRSRV_OK;
4598
 
}
4599
 
 
4600
 
IMG_INT BridgedDispatchKM(PVRSRV_PER_PROCESS_DATA * psPerProc,
4601
 
                      PVRSRV_BRIDGE_PACKAGE   * psBridgePackageKM)
4602
 
{
4603
 
 
4604
 
    IMG_VOID   * psBridgeIn;
4605
 
    IMG_VOID   * psBridgeOut;
4606
 
    BridgeWrapperFunction pfBridgeHandler;
4607
 
    IMG_UINT32   ui32BridgeID = psBridgePackageKM->ui32BridgeID;
4608
 
    IMG_INT      err          = -EFAULT;
4609
 
 
4610
 
#if defined(DEBUG_TRACE_BRIDGE_KM)
4611
 
    PVR_DPF((PVR_DBG_ERROR, "%s: %s",
4612
 
             __FUNCTION__,
4613
 
             g_BridgeDispatchTable[ui32BridgeID].pszIOCName));
4614
 
#endif
4615
 
 
4616
 
#if defined(DEBUG_BRIDGE_KM)
4617
 
    g_BridgeDispatchTable[ui32BridgeID].ui32CallCount++;
4618
 
    g_BridgeGlobalStats.ui32IOCTLCount++;
4619
 
#endif
4620
 
 
4621
 
    if(!psPerProc->bInitProcess)
4622
 
    {
4623
 
        if(PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RAN))
4624
 
        {
4625
 
            if(!PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_SUCCESSFUL))
4626
 
            {
4627
 
                PVR_DPF((PVR_DBG_ERROR, "%s: Initialisation failed.  Driver unusable.",
4628
 
                         __FUNCTION__));
4629
 
                goto return_fault;
4630
 
            }
4631
 
        }
4632
 
        else
4633
 
        {
4634
 
            if(PVRSRVGetInitServerState(PVRSRV_INIT_SERVER_RUNNING))
4635
 
            {
4636
 
                PVR_DPF((PVR_DBG_ERROR, "%s: Initialisation is in progress",
4637
 
                         __FUNCTION__));
4638
 
                goto return_fault;
4639
 
            }
4640
 
            else
4641
 
            {
4642
 
                
4643
 
                switch(ui32BridgeID)
4644
 
                {
4645
 
                    case PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_CONNECT_SERVICES):
4646
 
                    case PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_DISCONNECT_SERVICES):
4647
 
                    case PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_INITSRV_CONNECT):
4648
 
                    case PVRSRV_GET_BRIDGE_ID(PVRSRV_BRIDGE_INITSRV_DISCONNECT):
4649
 
                        break;
4650
 
                    default:
4651
 
                        PVR_DPF((PVR_DBG_ERROR, "%s: Driver initialisation not completed yet.",
4652
 
                                 __FUNCTION__));
4653
 
                        goto return_fault;
4654
 
                }
4655
 
            }
4656
 
        }
4657
 
    }
4658
 
 
4659
 
 
4660
 
 
4661
 
#if defined(__linux__)
4662
 
    {
4663
 
        
4664
 
        SYS_DATA *psSysData;
4665
 
 
4666
 
        SysAcquireData(&psSysData);
4667
 
 
4668
 
        
4669
 
        psBridgeIn = ((ENV_DATA *)psSysData->pvEnvSpecificData)->pvBridgeData;
4670
 
        psBridgeOut = (IMG_PVOID)((IMG_PBYTE)psBridgeIn + PVRSRV_MAX_BRIDGE_IN_SIZE);
4671
 
 
4672
 
        
4673
 
#if defined(DEBUG)
4674
 
        PVR_ASSERT(psBridgePackageKM->ui32InBufferSize < PVRSRV_MAX_BRIDGE_IN_SIZE);
4675
 
        PVR_ASSERT(psBridgePackageKM->ui32OutBufferSize < PVRSRV_MAX_BRIDGE_OUT_SIZE);
4676
 
#endif
4677
 
 
4678
 
        if(psBridgePackageKM->ui32InBufferSize > 0)
4679
 
        {
4680
 
            if(!OSAccessOK(PVR_VERIFY_READ,
4681
 
                            psBridgePackageKM->pvParamIn,
4682
 
                            psBridgePackageKM->ui32InBufferSize))
4683
 
            {
4684
 
                PVR_DPF((PVR_DBG_ERROR, "%s: Invalid pvParamIn pointer", __FUNCTION__));
4685
 
            }
4686
 
 
4687
 
            if(CopyFromUserWrapper(psPerProc,
4688
 
                                   ui32BridgeID,
4689
 
                                   psBridgeIn,
4690
 
                                   psBridgePackageKM->pvParamIn,
4691
 
                                   psBridgePackageKM->ui32InBufferSize)
4692
 
              != PVRSRV_OK)
4693
 
            {
4694
 
                goto return_fault;
4695
 
            }
4696
 
        }
4697
 
    }
4698
 
#else
4699
 
    psBridgeIn  = psBridgePackageKM->pvParamIn;
4700
 
    psBridgeOut = psBridgePackageKM->pvParamOut;
4701
 
#endif
4702
 
 
4703
 
    if(ui32BridgeID >= (BRIDGE_DISPATCH_TABLE_ENTRY_COUNT))
4704
 
    {
4705
 
        PVR_DPF((PVR_DBG_ERROR, "%s: ui32BridgeID = %d is out if range!",
4706
 
                 __FUNCTION__, ui32BridgeID));
4707
 
        goto return_fault;
4708
 
    }
4709
 
    pfBridgeHandler =
4710
 
        (BridgeWrapperFunction)g_BridgeDispatchTable[ui32BridgeID].pfFunction;
4711
 
    err = pfBridgeHandler(ui32BridgeID,
4712
 
                          psBridgeIn,
4713
 
                          psBridgeOut,
4714
 
                          psPerProc);
4715
 
    if(err < 0)
4716
 
    {
4717
 
        goto return_fault;
4718
 
    }
4719
 
 
4720
 
 
4721
 
#if defined(__linux__)
4722
 
    
4723
 
    if(CopyToUserWrapper(psPerProc,
4724
 
                         ui32BridgeID,
4725
 
                         psBridgePackageKM->pvParamOut,
4726
 
                         psBridgeOut,
4727
 
                         psBridgePackageKM->ui32OutBufferSize)
4728
 
       != PVRSRV_OK)
4729
 
    {
4730
 
        goto return_fault;
4731
 
    }
4732
 
#endif
4733
 
 
4734
 
    err = 0;
4735
 
return_fault:
4736
 
 
4737
 
    ReleaseHandleBatch(psPerProc);
4738
 
    return err;
4739
 
}
4740