drivers/pvr/services4/srvkm/common/resman.c

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