aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/gpu/pvr/resman.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/gpu/pvr/resman.c')
-rw-r--r--drivers/gpu/pvr/resman.c736
1 files changed, 736 insertions, 0 deletions
diff --git a/drivers/gpu/pvr/resman.c b/drivers/gpu/pvr/resman.c
new file mode 100644
index 00000000000..5d865a7d2c1
--- /dev/null
+++ b/drivers/gpu/pvr/resman.c
@@ -0,0 +1,736 @@
1/**********************************************************************
2 *
3 * Copyright(c) 2008 Imagination Technologies Ltd. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful but, except
10 * as otherwise stated in writing, without any warranty; without even the
11 * implied warranty of merchantability or fitness for a particular purpose.
12 * See the GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * The full GNU General Public License is included in this distribution in
19 * the file called "COPYING".
20 *
21 * Contact Information:
22 * Imagination Technologies Ltd. <gpl-support@imgtec.com>
23 * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
24 *
25 ******************************************************************************/
26
27#include "services_headers.h"
28#include "resman.h"
29
30#ifdef __linux__
31#ifndef AUTOCONF_INCLUDED
32 #include <linux/config.h>
33#endif
34
35#include <linux/version.h>
36#include <linux/sched.h>
37#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)
38#include <linux/hardirq.h>
39#else
40#include <asm/hardirq.h>
41#endif
42
43#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
44#include <linux/semaphore.h>
45#else
46#include <asm/semaphore.h>
47#endif
48
49static DECLARE_MUTEX(lock);
50
51#define ACQUIRE_SYNC_OBJ do { \
52 if (in_interrupt()) { \
53 printk ("ISR cannot take RESMAN mutex\n"); \
54 BUG(); \
55 } \
56 else down (&lock); \
57} while (0)
58#define RELEASE_SYNC_OBJ up (&lock)
59
60#else
61
62#define ACQUIRE_SYNC_OBJ
63#define RELEASE_SYNC_OBJ
64
65#endif
66
67#define RESMAN_SIGNATURE 0x12345678
68
69typedef struct _RESMAN_ITEM_
70{
71#ifdef DEBUG
72 IMG_UINT32 ui32Signature;
73#endif
74 struct _RESMAN_ITEM_ **ppsThis;
75 struct _RESMAN_ITEM_ *psNext;
76
77 IMG_UINT32 ui32Flags;
78 IMG_UINT32 ui32ResType;
79
80 IMG_PVOID pvParam;
81 IMG_UINT32 ui32Param;
82
83 RESMAN_FREE_FN pfnFreeResource;
84} RESMAN_ITEM;
85
86
87typedef struct _RESMAN_CONTEXT_
88{
89#ifdef DEBUG
90 IMG_UINT32 ui32Signature;
91#endif
92 struct _RESMAN_CONTEXT_ **ppsThis;
93 struct _RESMAN_CONTEXT_ *psNext;
94
95 PVRSRV_PER_PROCESS_DATA *psPerProc;
96
97 RESMAN_ITEM *psResItemList;
98
99} RESMAN_CONTEXT;
100
101
102typedef struct
103{
104 RESMAN_CONTEXT *psContextList;
105
106} RESMAN_LIST, *PRESMAN_LIST;
107
108
109PRESMAN_LIST gpsResList = IMG_NULL;
110
111#include "lists.h"
112
113static IMPLEMENT_LIST_ANY_VA(RESMAN_ITEM)
114static IMPLEMENT_LIST_ANY_VA_2(RESMAN_ITEM, IMG_BOOL, IMG_FALSE)
115static IMPLEMENT_LIST_INSERT(RESMAN_ITEM)
116static IMPLEMENT_LIST_REMOVE(RESMAN_ITEM)
117static IMPLEMENT_LIST_REVERSE(RESMAN_ITEM)
118
119static IMPLEMENT_LIST_REMOVE(RESMAN_CONTEXT)
120static IMPLEMENT_LIST_INSERT(RESMAN_CONTEXT)
121
122
123#define PRINT_RESLIST(x, y, z)
124
125static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM *psItem, IMG_BOOL bExecuteCallback);
126
127static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT psContext,
128 IMG_UINT32 ui32SearchCriteria,
129 IMG_UINT32 ui32ResType,
130 IMG_PVOID pvParam,
131 IMG_UINT32 ui32Param,
132 IMG_BOOL bExecuteCallback);
133
134
135#ifdef DEBUG
136 static IMG_VOID ValidateResList(PRESMAN_LIST psResList);
137 #define VALIDATERESLIST() ValidateResList(gpsResList)
138#else
139 #define VALIDATERESLIST()
140#endif
141
142
143
144
145
146
147PVRSRV_ERROR ResManInit(IMG_VOID)
148{
149 if (gpsResList == IMG_NULL)
150 {
151
152 if (OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP,
153 sizeof(*gpsResList),
154 (IMG_VOID **)&gpsResList, IMG_NULL,
155 "Resource Manager List") != PVRSRV_OK)
156 {
157 return PVRSRV_ERROR_OUT_OF_MEMORY;
158 }
159
160
161 gpsResList->psContextList = IMG_NULL;
162
163
164 VALIDATERESLIST();
165 }
166
167 return PVRSRV_OK;
168}
169
170
171IMG_VOID ResManDeInit(IMG_VOID)
172{
173 if (gpsResList != IMG_NULL)
174 {
175
176 OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*gpsResList), gpsResList, IMG_NULL);
177 gpsResList = IMG_NULL;
178 }
179}
180
181
182PVRSRV_ERROR PVRSRVResManConnect(IMG_HANDLE hPerProc,
183 PRESMAN_CONTEXT *phResManContext)
184{
185 PVRSRV_ERROR eError;
186 PRESMAN_CONTEXT psResManContext;
187
188
189 ACQUIRE_SYNC_OBJ;
190
191
192 VALIDATERESLIST();
193
194
195 eError = OSAllocMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(*psResManContext),
196 (IMG_VOID **)&psResManContext, IMG_NULL,
197 "Resource Manager Context");
198 if (eError != PVRSRV_OK)
199 {
200 PVR_DPF((PVR_DBG_ERROR, "PVRSRVResManConnect: ERROR allocating new RESMAN context struct"));
201
202
203 VALIDATERESLIST();
204
205
206 RELEASE_SYNC_OBJ;
207
208 return eError;
209 }
210
211#ifdef DEBUG
212 psResManContext->ui32Signature = RESMAN_SIGNATURE;
213#endif
214 psResManContext->psResItemList = IMG_NULL;
215 psResManContext->psPerProc = hPerProc;
216
217
218 List_RESMAN_CONTEXT_Insert(&gpsResList->psContextList, psResManContext);
219
220
221 VALIDATERESLIST();
222
223
224 RELEASE_SYNC_OBJ;
225
226 *phResManContext = psResManContext;
227
228 return PVRSRV_OK;
229}
230
231
232IMG_VOID PVRSRVResManDisconnect(PRESMAN_CONTEXT psResManContext,
233 IMG_BOOL bKernelContext)
234{
235
236 ACQUIRE_SYNC_OBJ;
237
238
239 VALIDATERESLIST();
240
241
242 PRINT_RESLIST(gpsResList, psResManContext, IMG_TRUE);
243
244
245
246 if (!bKernelContext)
247 {
248
249 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_OS_USERMODE_MAPPING, 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_DISPLAYCLASS_SWAPCHAIN_REF, 0, 0, IMG_TRUE);
272 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DISPLAYCLASS_DEVICE, 0, 0, IMG_TRUE);
273
274
275 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_BUFFERCLASS_DEVICE, 0, 0, IMG_TRUE);
276
277
278 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SYNC_INFO, 0, 0, IMG_TRUE);
279 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICECLASSMEM_MAPPING, 0, 0, IMG_TRUE);
280 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_WRAP, 0, 0, IMG_TRUE);
281 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_MAPPING, 0, 0, IMG_TRUE);
282 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_KERNEL_DEVICEMEM_ALLOCATION, 0, 0, IMG_TRUE);
283 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_ALLOCATION, 0, 0, IMG_TRUE);
284 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_DEVICEMEM_CONTEXT, 0, 0, IMG_TRUE);
285 FreeResourceByCriteria(psResManContext, RESMAN_CRITERIA_RESTYPE, RESMAN_TYPE_SHARED_MEM_INFO, 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
310PRESMAN_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
379PVRSRV_ERROR ResManFreeResByPtr(RESMAN_ITEM *psResItem)
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);
402
403
404 VALIDATERESLIST();
405
406
407 RELEASE_SYNC_OBJ;
408
409 return(eError);
410}
411
412
413PVRSRV_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
449PVRSRV_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);
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
489static 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
499IMG_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
553static PVRSRV_ERROR FreeResourceByPtr(RESMAN_ITEM *psItem,
554 IMG_BOOL bExecuteCallback)
555{
556 PVRSRV_ERROR eError;
557
558 PVR_ASSERT(psItem != IMG_NULL);
559
560 if (psItem == IMG_NULL)
561 {
562 PVR_DPF((PVR_DBG_ERROR, "FreeResourceByPtr: invalid parameter"));
563 return PVRSRV_ERROR_INVALID_PARAMS;
564 }
565
566#ifdef DEBUG
567 PVR_ASSERT(psItem->ui32Signature == RESMAN_SIGNATURE);
568#endif
569
570 PVR_DPF((PVR_DBG_MESSAGE,
571 "FreeResourceByPtr: psItem=%08X, psItem->psNext=%08X",
572 (IMG_UINTPTR_T)psItem, (IMG_UINTPTR_T)psItem->psNext));
573
574 PVR_DPF((PVR_DBG_MESSAGE,
575 "FreeResourceByPtr: Type 0x%x, Addr 0x%x, "
576 "Param 0x%x, FnCall %08X, Flags 0x%x",
577 psItem->ui32ResType,
578 (IMG_UINTPTR_T)psItem->pvParam, psItem->ui32Param,
579 (IMG_UINTPTR_T)psItem->pfnFreeResource, psItem->ui32Flags));
580
581
582 List_RESMAN_ITEM_Remove(psItem);
583
584
585
586 RELEASE_SYNC_OBJ;
587
588
589 if (bExecuteCallback)
590 {
591 eError = psItem->pfnFreeResource(psItem->pvParam, psItem->ui32Param);
592 if (eError != PVRSRV_OK)
593 {
594 PVR_DPF((PVR_DBG_ERROR, "FreeResourceByPtr: ERROR calling FreeResource function"));
595 }
596 }
597
598
599 ACQUIRE_SYNC_OBJ;
600
601
602 eError = OSFreeMem(PVRSRV_OS_PAGEABLE_HEAP, sizeof(RESMAN_ITEM), psItem, IMG_NULL);
603 if (eError != PVRSRV_OK)
604 {
605 PVR_DPF((PVR_DBG_ERROR, "FreeResourceByPtr: ERROR freeing resource list item memory"));
606 }
607
608 return(eError);
609}
610
611static IMG_VOID* FreeResourceByCriteria_AnyVaCb(RESMAN_ITEM *psCurItem, va_list va)
612{
613 IMG_UINT32 ui32SearchCriteria;
614 IMG_UINT32 ui32ResType;
615 IMG_PVOID pvParam;
616 IMG_UINT32 ui32Param;
617
618 ui32SearchCriteria = va_arg(va, IMG_UINT32);
619 ui32ResType = va_arg(va, IMG_UINT32);
620 pvParam = va_arg(va, IMG_PVOID);
621 ui32Param = va_arg(va, IMG_UINT32);
622
623
624 if(
625
626 (((ui32SearchCriteria & RESMAN_CRITERIA_RESTYPE) == 0UL) ||
627 (psCurItem->ui32ResType == ui32ResType))
628 &&
629
630 (((ui32SearchCriteria & RESMAN_CRITERIA_PVOID_PARAM) == 0UL) ||
631 (psCurItem->pvParam == pvParam))
632 &&
633
634 (((ui32SearchCriteria & RESMAN_CRITERIA_UI32_PARAM) == 0UL) ||
635 (psCurItem->ui32Param == ui32Param))
636 )
637 {
638 return psCurItem;
639 }
640 else
641 {
642 return IMG_NULL;
643 }
644}
645
646static PVRSRV_ERROR FreeResourceByCriteria(PRESMAN_CONTEXT psResManContext,
647 IMG_UINT32 ui32SearchCriteria,
648 IMG_UINT32 ui32ResType,
649 IMG_PVOID pvParam,
650 IMG_UINT32 ui32Param,
651 IMG_BOOL bExecuteCallback)
652{
653 PRESMAN_ITEM psCurItem;
654 PVRSRV_ERROR eError = PVRSRV_OK;
655
656
657
658 while((psCurItem = (PRESMAN_ITEM)
659 List_RESMAN_ITEM_Any_va(psResManContext->psResItemList,
660 &FreeResourceByCriteria_AnyVaCb,
661 ui32SearchCriteria,
662 ui32ResType,
663 pvParam,
664 ui32Param)) != IMG_NULL
665 && eError == PVRSRV_OK)
666 {
667 eError = FreeResourceByPtr(psCurItem, bExecuteCallback);
668 }
669
670 return eError;
671}
672
673
674#ifdef DEBUG
675static IMG_VOID ValidateResList(PRESMAN_LIST psResList)
676{
677 PRESMAN_ITEM psCurItem, *ppsThisItem;
678 PRESMAN_CONTEXT psCurContext, *ppsThisContext;
679
680
681 if (psResList == IMG_NULL)
682 {
683 PVR_DPF((PVR_DBG_MESSAGE, "ValidateResList: resman not initialised yet"));
684 return;
685 }
686
687 psCurContext = psResList->psContextList;
688 ppsThisContext = &psResList->psContextList;
689
690
691 while(psCurContext != IMG_NULL)
692 {
693
694 PVR_ASSERT(psCurContext->ui32Signature == RESMAN_SIGNATURE);
695 if (psCurContext->ppsThis != ppsThisContext)
696 {
697 PVR_DPF((PVR_DBG_WARNING,
698 "psCC=%08X psCC->ppsThis=%08X psCC->psNext=%08X ppsTC=%08X",
699 (IMG_UINTPTR_T)psCurContext,
700 (IMG_UINTPTR_T)psCurContext->ppsThis,
701 (IMG_UINTPTR_T)psCurContext->psNext,
702 (IMG_UINTPTR_T)ppsThisContext));
703 PVR_ASSERT(psCurContext->ppsThis == ppsThisContext);
704 }
705
706
707 psCurItem = psCurContext->psResItemList;
708 ppsThisItem = &psCurContext->psResItemList;
709 while(psCurItem != IMG_NULL)
710 {
711
712 PVR_ASSERT(psCurItem->ui32Signature == RESMAN_SIGNATURE);
713 if (psCurItem->ppsThis != ppsThisItem)
714 {
715 PVR_DPF((PVR_DBG_WARNING,
716 "psCurItem=%08X psCurItem->ppsThis=%08X psCurItem->psNext=%08X ppsThisItem=%08X",
717 (IMG_UINTPTR_T)psCurItem,
718 (IMG_UINTPTR_T)psCurItem->ppsThis,
719 (IMG_UINTPTR_T)psCurItem->psNext,
720 (IMG_UINTPTR_T)ppsThisItem));
721 PVR_ASSERT(psCurItem->ppsThis == ppsThisItem);
722 }
723
724
725 ppsThisItem = &psCurItem->psNext;
726 psCurItem = psCurItem->psNext;
727 }
728
729
730 ppsThisContext = &psCurContext->psNext;
731 psCurContext = psCurContext->psNext;
732 }
733}
734#endif
735
736
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-25 07:52:24 -0400