← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/gpu/pvr/resman.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
#include "services_headers.h"
 
28
#include "resman.h"
 
29
 
 
30
#ifdef __linux__
 
31
 
 
32
#include <linux/version.h>
 
33
#include <linux/sched.h>
 
34
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)
 
35
#include <linux/hardirq.h>
 
36
#else
 
37
#include <asm/hardirq.h>
 
38
#endif
 
39
 
 
40
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
 
41
#include <linux/semaphore.h>
 
42
#else
 
43
#include <asm/semaphore.h>
 
44
#endif
 
45
 
 
46
static DEFINE_SEMAPHORE(lock);
 
47
 
 
48
#define ACQUIRE_SYNC_OBJ  do {                                                  \
 
49
                if (in_interrupt()) {                                                   \
 
50
                        printk ("ISR cannot take RESMAN mutex\n");      \
 
51
                        BUG();                                                                          \
 
52
                }                                                                                               \
 
53
                else down (&lock);                                                              \
 
54
} while (0)
 
55
#define RELEASE_SYNC_OBJ up (&lock)
 
56
 
 
57
#else
 
58
 
 
59
#define ACQUIRE_SYNC_OBJ
 
60
#define RELEASE_SYNC_OBJ
 
61
 
 
62
#endif
 
63
 
 
64
#define RESMAN_SIGNATURE 0x12345678
 
65
 
 
66
typedef struct _RESMAN_ITEM_
 
67
{
 
68
#ifdef DEBUG
 
69
        IMG_UINT32                              ui32Signature;
 
70
#endif
 
71
        struct _RESMAN_ITEM_    **ppsThis;      
 
72
        struct _RESMAN_ITEM_    *psNext;        
 
73
 
 
74
        IMG_UINT32                              ui32Flags;      
 
75
        IMG_UINT32                              ui32ResType;
 
76
 
 
77
        IMG_PVOID                               pvParam;        
 
78
        IMG_UINT32                              ui32Param;      
 
79
 
 
80
        RESMAN_FREE_FN                  pfnFreeResource;
 
81
} RESMAN_ITEM;
 
82
 
 
83
 
 
84
typedef struct _RESMAN_CONTEXT_
 
85
{
 
86
#ifdef DEBUG
 
87
        IMG_UINT32                                      ui32Signature;
 
88
#endif
 
89
        struct  _RESMAN_CONTEXT_        **ppsThis;
 
90
        struct  _RESMAN_CONTEXT_        *psNext;
 
91
 
 
92
        PVRSRV_PER_PROCESS_DATA         *psPerProc; 
 
93
 
 
94
        RESMAN_ITEM                                     *psResItemList;
 
95
 
 
96
} RESMAN_CONTEXT;
 
97
 
 
98
 
 
99
typedef struct
 
100
{
 
101
        RESMAN_CONTEXT  *psContextList; 
 
102
 
 
103
} RESMAN_LIST, *PRESMAN_LIST;   
 
104
 
 
105
 
 
106
PRESMAN_LIST    gpsResList = IMG_NULL;
 
107
 
 
108
#include "lists.h"       
 
109
 
 
110
static IMPLEMENT_LIST_ANY_VA(RESMAN_ITEM)
 
111
static IMPLEMENT_LIST_ANY_VA_2(RESMAN_ITEM, IMG_BOOL, IMG_FALSE)
 
112
static IMPLEMENT_LIST_INSERT(RESMAN_ITEM)
 
113
static IMPLEMENT_LIST_REMOVE(RESMAN_ITEM)
 
114
static IMPLEMENT_LIST_REVERSE(RESMAN_ITEM)
 
115
 
 
116
static IMPLEMENT_LIST_REMOVE(RESMAN_CONTEXT)
 
117
static IMPLEMENT_LIST_INSERT(RESMAN_CONTEXT)
 
118
 
 
119
 
 
120
#define PRINT_RESLIST(x, y, z)
 
121
 
 
122
static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM *psItem, IMG_BOOL bExecuteCallback, IMG_BOOL bForceCleanup);
 
123
 
 
124
static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT      psContext,
 
125
                                                                                   IMG_UINT32           ui32SearchCriteria,
 
126
                                                                                   IMG_UINT32           ui32ResType,
 
127
                                                                                   IMG_PVOID            pvParam,
 
128
                                                                                   IMG_UINT32           ui32Param,
 
129
                                                                                   IMG_BOOL                     bExecuteCallback);
 
130
 
 
131
 
 
132
#ifdef DEBUG
 
133
        static IMG_VOID ValidateResList(PRESMAN_LIST psResList);
 
134
        #define VALIDATERESLIST() ValidateResList(gpsResList)
 
135
#else
 
136
        #define VALIDATERESLIST()
 
137
#endif
 
138
 
 
139
 
 
140
 
 
141
 
 
142
 
 
143
 
 
144
PVRSRV_ERROR ResManInit(IMG_VOID)
 
145
{
 
146
        if (gpsResList == IMG_NULL)
 
147
        {
 
148
                
 
149
                if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
 
150
                                                sizeof(*gpsResList),
 
151
                                                (IMG_VOID **)&gpsResList, IMG_NULL,
 
152
                                                "Resource Manager List") != PVRSRV_OK)
 
153
                {
 
154
                        return PVRSRV_ERROR_OUT_OF_MEMORY;
 
155
                }
 
156
 
 
157
                
 
158
                gpsResList->psContextList = IMG_NULL;
 
159
 
 
160
                
 
161
                VALIDATERESLIST();
 
162
        }
 
163
 
 
164
        return PVRSRV_OK;
 
165
}
 
166
 
 
167
 
 
168
IMG_VOID ResManDeInit(IMG_VOID)
 
169
{
 
170
        if (gpsResList != IMG_NULL)
 
171
        {
 
172
                
 
173
                OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*gpsResList), gpsResList, IMG_NULL);
 
174
                gpsResList = IMG_NULL;
 
175
        }
 
176
}
 
177
 
 
178
 
 
179
PVRSRV_ERROR PVRSRVResManConnect(IMG_HANDLE                     hPerProc,
 
180
                                                                 PRESMAN_CONTEXT        *phResManContext)
 
181
{
 
182
        PVRSRV_ERROR    eError;
 
183
        PRESMAN_CONTEXT psResManContext;
 
184
 
 
185
        
 
186
        ACQUIRE_SYNC_OBJ;
 
187
 
 
188
        
 
189
        VALIDATERESLIST();
 
190
 
 
191
        
 
192
        eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psResManContext),
 
193
                                                (IMG_VOID **)&psResManContext, IMG_NULL,
 
194
                                                "Resource Manager Context");
 
195
        if (eError != PVRSRV_OK)
 
196
        {
 
197
                PVR_DPF((PVR_DBG_ERROR, "PVRSRVResManConnect: ERROR allocating new RESMAN context struct"));
 
198
 
 
199
                
 
200
                VALIDATERESLIST();
 
201
 
 
202
                
 
203
                RELEASE_SYNC_OBJ;
 
204
 
 
205
                return eError;
 
206
        }
 
207
 
 
208
#ifdef DEBUG
 
209
        psResManContext->ui32Signature = RESMAN_SIGNATURE;
 
210
#endif 
 
211
        psResManContext->psResItemList  = IMG_NULL;
 
212
        psResManContext->psPerProc = hPerProc;
 
213
 
 
214
        
 
215
        List_RESMAN_CONTEXT_Insert(&gpsResList->psContextList, psResManContext);
 
216
 
 
217
        
 
218
        VALIDATERESLIST();
 
219
 
 
220
        
 
221
        RELEASE_SYNC_OBJ;
 
222
 
 
223
        *phResManContext = psResManContext;
 
224
 
 
225
        return PVRSRV_OK;
 
226
}
 
227
 
 
228
 
 
229
IMG_VOID PVRSRVResManDisconnect(PRESMAN_CONTEXT psResManContext,
 
230
                                                                IMG_BOOL                bKernelContext)
 
231
{
 
232
        
 
233
        ACQUIRE_SYNC_OBJ;
 
234
 
 
235
        
 
236
        VALIDATERESLIST();
 
237
 
 
238
        
 
239
        PRINT_RESLIST(gpsResList, psResManContext, IMG_TRUE);
 
240
 
 
241
        
 
242
 
 
243
        if (!bKernelContext)
 
244
        {
 
245
                
 
246
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_OS_USERMODE_MAPPING, 0, 0, IMG_TRUE);
 
247
 
 
248
                
 
249
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DMA_CLIENT_FIFO_DATA, 0, 0, IMG_TRUE);
 
250
 
 
251
                
 
252
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_EVENT_OBJECT, 0, 0, IMG_TRUE);
 
253
 
 
254
                
 
255
                
 
256
                List_RESMAN_ITEM_Reverse(&psResManContext->psResItemList);
 
257
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_MODIFY_SYNC_OPS, 0, 0, IMG_TRUE);
 
258
                List_RESMAN_ITEM_Reverse(&psResManContext->psResItemList);  
 
259
 
 
260
                
 
261
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_HW_RENDER_CONTEXT, 0, 0, IMG_TRUE);
 
262
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_HW_TRANSFER_CONTEXT, 0, 0, IMG_TRUE);
 
263
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_HW_2D_CONTEXT, 0, 0, IMG_TRUE);
 
264
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_TRANSFER_CONTEXT, 0, 0, IMG_TRUE);
 
265
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SHARED_PB_DESC_CREATE_LOCK, 0, 0, IMG_TRUE);
 
266
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SHARED_PB_DESC, 0, 0, IMG_TRUE);
 
267
                
 
268
                
 
269
 
 
270
                
 
271
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SYNC_INFO, 0, 0, IMG_TRUE);
 
272
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICECLASSMEM_MAPPING, 0, 0, IMG_TRUE);
 
273
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_WRAP, 0, 0, IMG_TRUE);
 
274
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_MAPPING, 0, 0, IMG_TRUE);
 
275
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_KERNEL_DEVICEMEM_ALLOCATION, 0, 0, IMG_TRUE);
 
276
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_ALLOCATION, 0, 0, IMG_TRUE);
 
277
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_CONTEXT, 0, 0, IMG_TRUE);
 
278
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SHARED_MEM_INFO, 0, 0, IMG_TRUE);
 
279
 
 
280
                
 
281
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DISPLAYCLASS_SWAPCHAIN_REF, 0, 0, IMG_TRUE);
 
282
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DISPLAYCLASS_DEVICE, 0, 0, IMG_TRUE);
 
283
 
 
284
                
 
285
                FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_BUFFERCLASS_DEVICE, 0, 0, IMG_TRUE);
 
286
        }
 
287
 
 
288
        
 
289
        PVR_ASSERT(psResManContext->psResItemList == IMG_NULL);
 
290
 
 
291
        
 
292
        List_RESMAN_CONTEXT_Remove(psResManContext);
 
293
 
 
294
        
 
295
        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_CONTEXT), psResManContext, IMG_NULL);
 
296
        
 
297
 
 
298
 
 
299
        
 
300
        VALIDATERESLIST();
 
301
 
 
302
        
 
303
        PRINT_RESLIST(gpsResList, psResManContext, IMG_FALSE);
 
304
 
 
305
        
 
306
        RELEASE_SYNC_OBJ;
 
307
}
 
308
 
 
309
 
 
310
PRESMAN_ITEM ResManRegisterRes(PRESMAN_CONTEXT  psResManContext,
 
311
                                                           IMG_UINT32           ui32ResType,
 
312
                                                           IMG_PVOID            pvParam,
 
313
                                                           IMG_UINT32           ui32Param,
 
314
                                                           RESMAN_FREE_FN       pfnFreeResource)
 
315
{
 
316
        PRESMAN_ITEM    psNewResItem;
 
317
 
 
318
        PVR_ASSERT(psResManContext != IMG_NULL);
 
319
        PVR_ASSERT(ui32ResType != 0);
 
320
 
 
321
        if (psResManContext == IMG_NULL)
 
322
        {
 
323
                PVR_DPF((PVR_DBG_ERROR, "ResManRegisterRes: invalid parameter - psResManContext"));
 
324
                return (PRESMAN_ITEM) IMG_NULL;
 
325
        }
 
326
 
 
327
        
 
328
        ACQUIRE_SYNC_OBJ;
 
329
 
 
330
        
 
331
        VALIDATERESLIST();
 
332
 
 
333
        PVR_DPF((PVR_DBG_MESSAGE, "ResManRegisterRes: register resource "
 
334
                        "Context 0x%x, ResType 0x%x, pvParam 0x%x, ui32Param 0x%x, "
 
335
                        "FreeFunc %08X",
 
336
                        (IMG_UINTPTR_T)psResManContext,
 
337
                        ui32ResType,
 
338
                        (IMG_UINTPTR_T)pvParam,
 
339
                        ui32Param,
 
340
                        (IMG_UINTPTR_T)pfnFreeResource));
 
341
 
 
342
        
 
343
        if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
 
344
                                   sizeof(RESMAN_ITEM), (IMG_VOID **)&psNewResItem,
 
345
                                   IMG_NULL,
 
346
                                   "Resource Manager Item") != PVRSRV_OK)
 
347
        {
 
348
                PVR_DPF((PVR_DBG_ERROR, "ResManRegisterRes: "
 
349
                                "ERROR allocating new resource item"));
 
350
 
 
351
                
 
352
                RELEASE_SYNC_OBJ;
 
353
 
 
354
                return((PRESMAN_ITEM)IMG_NULL);
 
355
        }
 
356
 
 
357
        
 
358
#ifdef DEBUG
 
359
        psNewResItem->ui32Signature             = RESMAN_SIGNATURE;
 
360
#endif 
 
361
        psNewResItem->ui32ResType               = ui32ResType;
 
362
        psNewResItem->pvParam                   = pvParam;
 
363
        psNewResItem->ui32Param                 = ui32Param;
 
364
        psNewResItem->pfnFreeResource   = pfnFreeResource;
 
365
        psNewResItem->ui32Flags             = 0;
 
366
 
 
367
        
 
368
        List_RESMAN_ITEM_Insert(&psResManContext->psResItemList, psNewResItem);
 
369
 
 
370
        
 
371
        VALIDATERESLIST();
 
372
 
 
373
        
 
374
        RELEASE_SYNC_OBJ;
 
375
 
 
376
        return(psNewResItem);
 
377
}
 
378
 
 
379
PVRSRV_ERROR ResManFreeResByPtr(RESMAN_ITEM     *psResItem, IMG_BOOL bForceCleanup)
 
380
{
 
381
        PVRSRV_ERROR eError;
 
382
 
 
383
        PVR_ASSERT(psResItem != IMG_NULL);
 
384
 
 
385
        if (psResItem == IMG_NULL)
 
386
        {
 
387
                PVR_DPF((PVR_DBG_MESSAGE, "ResManFreeResByPtr: NULL ptr - nothing to do"));
 
388
                return PVRSRV_OK;
 
389
        }
 
390
 
 
391
        PVR_DPF((PVR_DBG_MESSAGE, "ResManFreeResByPtr: freeing resource at %08X",
 
392
                        (IMG_UINTPTR_T)psResItem));
 
393
 
 
394
        
 
395
        ACQUIRE_SYNC_OBJ;
 
396
 
 
397
        
 
398
        VALIDATERESLIST();
 
399
 
 
400
        
 
401
        eError = FreeResourceByPtr(psResItem, IMG_TRUE, bForceCleanup);
 
402
 
 
403
        
 
404
        VALIDATERESLIST();
 
405
 
 
406
        
 
407
        RELEASE_SYNC_OBJ;
 
408
 
 
409
        return(eError);
 
410
}
 
411
 
 
412
 
 
413
PVRSRV_ERROR ResManFreeResByCriteria(PRESMAN_CONTEXT    psResManContext,
 
414
                                                                         IMG_UINT32                     ui32SearchCriteria,
 
415
                                                                         IMG_UINT32                     ui32ResType,
 
416
                                                                         IMG_PVOID                      pvParam,
 
417
                                                                         IMG_UINT32                     ui32Param)
 
418
{
 
419
        PVRSRV_ERROR    eError;
 
420
 
 
421
        PVR_ASSERT(psResManContext != IMG_NULL);
 
422
 
 
423
        
 
424
        ACQUIRE_SYNC_OBJ;
 
425
 
 
426
        
 
427
        VALIDATERESLIST();
 
428
 
 
429
        PVR_DPF((PVR_DBG_MESSAGE, "ResManFreeResByCriteria: "
 
430
                        "Context 0x%x, Criteria 0x%x, Type 0x%x, Addr 0x%x, Param 0x%x",
 
431
                        (IMG_UINTPTR_T)psResManContext, ui32SearchCriteria, ui32ResType,
 
432
                        (IMG_UINTPTR_T)pvParam, ui32Param));
 
433
 
 
434
        
 
435
        eError = FreeResourceByCriteria(psResManContext, ui32SearchCriteria,
 
436
                                                                        ui32ResType, pvParam, ui32Param,
 
437
                                                                        IMG_TRUE);
 
438
 
 
439
        
 
440
        VALIDATERESLIST();
 
441
 
 
442
        
 
443
        RELEASE_SYNC_OBJ;
 
444
 
 
445
        return eError;
 
446
}
 
447
 
 
448
 
 
449
PVRSRV_ERROR ResManDissociateRes(RESMAN_ITEM            *psResItem,
 
450
                                                         PRESMAN_CONTEXT        psNewResManContext)
 
451
{
 
452
        PVRSRV_ERROR eError = PVRSRV_OK;
 
453
 
 
454
        PVR_ASSERT(psResItem != IMG_NULL);
 
455
 
 
456
        if (psResItem == IMG_NULL)
 
457
        {
 
458
                PVR_DPF((PVR_DBG_ERROR, "ResManDissociateRes: invalid parameter - psResItem"));
 
459
                PVR_DBG_BREAK;
 
460
                return PVRSRV_ERROR_INVALID_PARAMS;
 
461
        }
 
462
 
 
463
#ifdef DEBUG 
 
464
        PVR_ASSERT(psResItem->ui32Signature == RESMAN_SIGNATURE);
 
465
#endif
 
466
 
 
467
        if (psNewResManContext != IMG_NULL)
 
468
        {
 
469
                
 
470
                List_RESMAN_ITEM_Remove(psResItem);
 
471
 
 
472
                
 
473
                List_RESMAN_ITEM_Insert(&psNewResManContext->psResItemList, psResItem);
 
474
 
 
475
        }
 
476
        else
 
477
        {
 
478
                eError = FreeResourceByPtr(psResItem, IMG_FALSE, CLEANUP_WITH_POLL);
 
479
                if(eError != PVRSRV_OK)
 
480
                {
 
481
                        PVR_DPF((PVR_DBG_ERROR, "ResManDissociateRes: failed to free resource by pointer"));
 
482
                        return eError;
 
483
                }
 
484
        }
 
485
 
 
486
        return eError;
 
487
}
 
488
 
 
489
static IMG_BOOL ResManFindResourceByPtr_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
 
490
{
 
491
        RESMAN_ITEM             *psItem;
 
492
 
 
493
        psItem = va_arg(va, RESMAN_ITEM*);
 
494
 
 
495
        return (IMG_BOOL)(psCurItem == psItem);
 
496
}
 
497
 
 
498
 
 
499
IMG_INTERNAL PVRSRV_ERROR ResManFindResourceByPtr(PRESMAN_CONTEXT       psResManContext,
 
500
                                                                                                  RESMAN_ITEM           *psItem)
 
501
{
 
502
        PVRSRV_ERROR    eResult;
 
503
 
 
504
        PVR_ASSERT(psResManContext != IMG_NULL);
 
505
        PVR_ASSERT(psItem != IMG_NULL);
 
506
 
 
507
        if ((psItem == IMG_NULL) || (psResManContext == IMG_NULL))
 
508
        {
 
509
                PVR_DPF((PVR_DBG_ERROR, "ResManFindResourceByPtr: invalid parameter"));
 
510
                PVR_DBG_BREAK;
 
511
                return PVRSRV_ERROR_INVALID_PARAMS;
 
512
        }
 
513
 
 
514
#ifdef DEBUG    
 
515
        PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE);
 
516
#endif
 
517
 
 
518
        
 
519
        ACQUIRE_SYNC_OBJ;
 
520
 
 
521
        PVR_DPF((PVR_DBG_MESSAGE,
 
522
                        "FindResourceByPtr: psItem=%08X, psItem->psNext=%08X",
 
523
                        (IMG_UINTPTR_T)psItem, (IMG_UINTPTR_T)psItem->psNext));
 
524
 
 
525
        PVR_DPF((PVR_DBG_MESSAGE,
 
526
                        "FindResourceByPtr: Resource Ctx 0x%x, Type 0x%x, Addr 0x%x, "
 
527
                        "Param 0x%x, FnCall %08X, Flags 0x%x",
 
528
                        (IMG_UINTPTR_T)psResManContext,
 
529
                        psItem->ui32ResType,
 
530
                        (IMG_UINTPTR_T)psItem->pvParam,
 
531
                        psItem->ui32Param,
 
532
                        (IMG_UINTPTR_T)psItem->pfnFreeResource,
 
533
                        psItem->ui32Flags));
 
534
 
 
535
        
 
536
        if(List_RESMAN_ITEM_IMG_BOOL_Any_va(psResManContext->psResItemList,
 
537
                                                                                &ResManFindResourceByPtr_AnyVaCb,
 
538
                                                                                psItem))
 
539
        {
 
540
                eResult = PVRSRV_OK;
 
541
        }
 
542
        else
 
543
        {
 
544
                eResult = PVRSRV_ERROR_NOT_OWNER;
 
545
        }
 
546
 
 
547
        
 
548
        RELEASE_SYNC_OBJ;
 
549
 
 
550
        return eResult;
 
551
}
 
552
 
 
553
static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM       *psItem,
 
554
                                                                          IMG_BOOL              bExecuteCallback,
 
555
                                                                          IMG_BOOL              bForceCleanup)
 
556
{
 
557
        PVRSRV_ERROR eError = PVRSRV_OK;
 
558
 
 
559
        PVR_ASSERT(psItem != IMG_NULL);
 
560
 
 
561
        if (psItem == IMG_NULL)
 
562
        {
 
563
                PVR_DPF((PVR_DBG_ERROR, "FreeResourceByPtr: invalid parameter"));
 
564
                return PVRSRV_ERROR_INVALID_PARAMS;
 
565
        }
 
566
 
 
567
#ifdef DEBUG    
 
568
        PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE);
 
569
#endif
 
570
 
 
571
        PVR_DPF((PVR_DBG_MESSAGE,
 
572
                        "FreeResourceByPtr: psItem=%08X, psItem->psNext=%08X",
 
573
                        (IMG_UINTPTR_T)psItem, (IMG_UINTPTR_T)psItem->psNext));
 
574
 
 
575
        PVR_DPF((PVR_DBG_MESSAGE,
 
576
                        "FreeResourceByPtr: Type 0x%x, Addr 0x%x, "
 
577
                        "Param 0x%x, FnCall %08X, Flags 0x%x",
 
578
                        psItem->ui32ResType,
 
579
                        (IMG_UINTPTR_T)psItem->pvParam, psItem->ui32Param,
 
580
                        (IMG_UINTPTR_T)psItem->pfnFreeResource, psItem->ui32Flags));
 
581
 
 
582
        
 
583
        List_RESMAN_ITEM_Remove(psItem);
 
584
 
 
585
 
 
586
        
 
587
        RELEASE_SYNC_OBJ;
 
588
 
 
589
        
 
590
        if (bExecuteCallback)
 
591
        {
 
592
                eError = psItem->pfnFreeResource(psItem->pvParam, psItem->ui32Param, bForceCleanup);
 
593
                if (eError != PVRSRV_OK)
 
594
                {
 
595
                        PVR_DPF((PVR_DBG_ERROR, "FreeResourceByPtr: ERROR calling FreeResource function"));
 
596
                }
 
597
        }
 
598
 
 
599
        
 
600
        ACQUIRE_SYNC_OBJ;
 
601
 
 
602
        
 
603
        OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_ITEM), psItem, IMG_NULL);
 
604
 
 
605
        return(eError);
 
606
}
 
607
 
 
608
static IMG_VOID* FreeResourceByCriteria_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
 
609
{
 
610
        IMG_UINT32 ui32SearchCriteria;
 
611
        IMG_UINT32 ui32ResType;
 
612
        IMG_PVOID pvParam;
 
613
        IMG_UINT32 ui32Param;
 
614
 
 
615
        ui32SearchCriteria = va_arg(va, IMG_UINT32);
 
616
        ui32ResType = va_arg(va, IMG_UINT32);
 
617
        pvParam = va_arg(va, IMG_PVOID);
 
618
        ui32Param = va_arg(va, IMG_UINT32);
 
619
 
 
620
        
 
621
        if(
 
622
        
 
623
                (((ui32SearchCriteria & RESMAN_CRITERIA_RESTYPE) == 0UL) ||
 
624
                (psCurItem->ui32ResType == ui32ResType))
 
625
        &&
 
626
        
 
627
                (((ui32SearchCriteria & RESMAN_CRITERIA_PVOID_PARAM) == 0UL) ||
 
628
                         (psCurItem->pvParam == pvParam))
 
629
        &&
 
630
        
 
631
                (((ui32SearchCriteria & RESMAN_CRITERIA_UI32_PARAM) == 0UL) ||
 
632
                         (psCurItem->ui32Param == ui32Param))
 
633
                )
 
634
        {
 
635
                return psCurItem;
 
636
        }
 
637
        else
 
638
        {
 
639
                return IMG_NULL;
 
640
        }
 
641
}
 
642
 
 
643
static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT      psResManContext,
 
644
                                                                                   IMG_UINT32           ui32SearchCriteria,
 
645
                                                                                   IMG_UINT32           ui32ResType,
 
646
                                                                                   IMG_PVOID            pvParam,
 
647
                                                                                   IMG_UINT32           ui32Param,
 
648
                                                                                   IMG_BOOL                     bExecuteCallback)
 
649
{
 
650
        PRESMAN_ITEM    psCurItem;
 
651
        PVRSRV_ERROR    eError = PVRSRV_OK;
 
652
 
 
653
        
 
654
        
 
655
        while((psCurItem = (PRESMAN_ITEM)
 
656
                                List_RESMAN_ITEM_Any_va(psResManContext->psResItemList,
 
657
                                                                                &FreeResourceByCriteria_AnyVaCb,
 
658
                                                                                ui32SearchCriteria,
 
659
                                                                                ui32ResType,
 
660
                                                                                pvParam,
 
661
                                                                                ui32Param)) != IMG_NULL
 
662
                        && eError == PVRSRV_OK)
 
663
        {
 
664
                eError = FreeResourceByPtr(psCurItem, bExecuteCallback, CLEANUP_WITH_POLL);
 
665
        }
 
666
 
 
667
        return eError;
 
668
}
 
669
 
 
670
 
 
671
#ifdef DEBUG
 
672
static IMG_VOID ValidateResList(PRESMAN_LIST psResList)
 
673
{
 
674
        PRESMAN_ITEM    psCurItem, *ppsThisItem;
 
675
        PRESMAN_CONTEXT psCurContext, *ppsThisContext;
 
676
 
 
677
        
 
678
        if (psResList == IMG_NULL)
 
679
        {
 
680
                PVR_DPF((PVR_DBG_MESSAGE, "ValidateResList: resman not initialised yet"));
 
681
                return;
 
682
        }
 
683
 
 
684
        psCurContext = psResList->psContextList;
 
685
        ppsThisContext = &psResList->psContextList;
 
686
 
 
687
        
 
688
        while(psCurContext != IMG_NULL)
 
689
        {
 
690
                
 
691
                PVR_ASSERT(psCurContext->ui32Signature == RESMAN_SIGNATURE);
 
692
                if (psCurContext->ppsThis != ppsThisContext)
 
693
                {
 
694
                        PVR_DPF((PVR_DBG_WARNING,
 
695
                                        "psCC=%08X psCC->ppsThis=%08X psCC->psNext=%08X ppsTC=%08X",
 
696
                                        (IMG_UINTPTR_T)psCurContext,
 
697
                                        (IMG_UINTPTR_T)psCurContext->ppsThis,
 
698
                                        (IMG_UINTPTR_T)psCurContext->psNext,
 
699
                                        (IMG_UINTPTR_T)ppsThisContext));
 
700
                        PVR_ASSERT(psCurContext->ppsThis == ppsThisContext);
 
701
                }
 
702
 
 
703
                
 
704
                psCurItem = psCurContext->psResItemList;
 
705
                ppsThisItem = &psCurContext->psResItemList;
 
706
                while(psCurItem != IMG_NULL)
 
707
                {
 
708
                        
 
709
                        PVR_ASSERT(psCurItem->ui32Signature == RESMAN_SIGNATURE);
 
710
                        if (psCurItem->ppsThis != ppsThisItem)
 
711
                        {
 
712
                                PVR_DPF((PVR_DBG_WARNING,
 
713
                                                "psCurItem=%08X psCurItem->ppsThis=%08X psCurItem->psNext=%08X ppsThisItem=%08X",
 
714
                                                (IMG_UINTPTR_T)psCurItem,
 
715
                                                (IMG_UINTPTR_T)psCurItem->ppsThis,
 
716
                                                (IMG_UINTPTR_T)psCurItem->psNext,
 
717
                                                (IMG_UINTPTR_T)ppsThisItem));
 
718
                                PVR_ASSERT(psCurItem->ppsThis == ppsThisItem);
 
719
                        }
 
720
 
 
721
                        
 
722
                        ppsThisItem = &psCurItem->psNext;
 
723
                        psCurItem = psCurItem->psNext;
 
724
                }
 
725
 
 
726
                
 
727
                ppsThisContext = &psCurContext->psNext;
 
728
                psCurContext = psCurContext->psNext;
 
729
        }
 
730
}
 
731
#endif 
 
732
 
 
733