EdkModulePkg/Universal/PCD/Pei/Pcd.c

   1 /** @file PCD PEIM
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12
  13 Module Name: Pcd.c
  14
  15 **/
  16
  17 #include "Service.h"
  18
  19
  20 PCD_PPI mPcdPpiInstance = {
  21   PeiPcdSetSku,
  22
  23   PeiPcdGet8,
  24   PeiPcdGet16,
  25   PeiPcdGet32,
  26   PeiPcdGet64,
  27   PeiPcdGetPtr,
  28   PeiPcdGetBool,
  29   PeiPcdGetSize,
  30
  31   PeiPcdGet8Ex,
  32   PeiPcdGet16Ex,
  33   PeiPcdGet32Ex,
  34   PeiPcdGet64Ex,
  35   PeiPcdGetPtrEx,
  36   PeiPcdGetBoolEx,
  37   PeiPcdGetSizeEx,
  38
  39   PeiPcdSet8,
  40   PeiPcdSet16,
  41   PeiPcdSet32,
  42   PeiPcdSet64,
  43   PeiPcdSetPtr,
  44   PeiPcdSetBool,
  45
  46   PeiPcdSet8Ex,
  47   PeiPcdSet16Ex,
  48   PeiPcdSet32Ex,
  49   PeiPcdSet64Ex,
  50   PeiPcdSetPtrEx,
  51   PeiPcdSetBoolEx,
  52
  53   PeiRegisterCallBackOnSet,
  54   PcdUnRegisterCallBackOnSet,
  55   PeiPcdGetNextToken
  56 };
  57
  58
  59
  60 STATIC EFI_PEI_PPI_DESCRIPTOR  mPpiPCD = {
  61   (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  62   &gPcdPpiGuid,
  63   &mPcdPpiInstance
  64 };
  65
  66
  67
  68 EFI_STATUS
  69 EFIAPI
  70 PcdPeimInit (
  71   IN EFI_FFS_FILE_HEADER      *FfsHeader,
  72   IN EFI_PEI_SERVICES         **PeiServices
  73   )
  74 {
  75   EFI_STATUS Status;
  76
  77   BuildPcdDatabase ();
  78
  79   Status = PeiCoreInstallPpi (&mPpiPCD);
  80
  81   ASSERT_EFI_ERROR (Status);
  82
  83   return EFI_SUCCESS;
  84 }
  85
  86 VOID
  87 EFIAPI
  88 PeiPcdSetSku (
  89   IN  SKU_ID                  SkuId
  90   )
  91 {
  92
  93   GetPcdDatabase()->Init.SystemSkuId = SkuId;
  94
  95   return;
  96 }
  97
  98
  99
 100 UINT8
 101 EFIAPI
 102 PeiPcdGet8 (
 103   IN PCD_TOKEN_NUMBER  TokenNumber
 104   )
 105 {
 106   return *((UINT8 *) GetWorker (TokenNumber, sizeof (UINT8)));
 107 }
 108
 109
 110
 111 UINT16
 112 EFIAPI
 113 PeiPcdGet16 (
 114   IN PCD_TOKEN_NUMBER  TokenNumber
 115   )
 116 {
 117   return ReadUnaligned16 (GetWorker (TokenNumber, sizeof (UINT16)));
 118 }
 119
 120
 121
 122 UINT32
 123 EFIAPI
 124 PeiPcdGet32 (
 125   IN PCD_TOKEN_NUMBER  TokenNumber
 126   )
 127 {
 128   return ReadUnaligned32 (GetWorker (TokenNumber, sizeof (UINT32)));
 129 }
 130
 131
 132
 133 UINT64
 134 EFIAPI
 135 PeiPcdGet64 (
 136   IN PCD_TOKEN_NUMBER  TokenNumber
 137   )
 138 {
 139   return ReadUnaligned64 (GetWorker (TokenNumber, sizeof (UINT64)));
 140 }
 141
 142
 143
 144 VOID *
 145 EFIAPI
 146 PeiPcdGetPtr (
 147   IN PCD_TOKEN_NUMBER  TokenNumber
 148   )
 149 {
 150   return GetWorker (TokenNumber, 0);
 151 }
 152
 153
 154
 155 BOOLEAN
 156 EFIAPI
 157 PeiPcdGetBool (
 158   IN PCD_TOKEN_NUMBER  TokenNumber
 159   )
 160 {
 161   return *((BOOLEAN *) GetWorker (TokenNumber, sizeof (BOOLEAN)));
 162 }
 163
 164
 165
 166 UINTN
 167 EFIAPI
 168 PeiPcdGetSize (
 169   IN PCD_TOKEN_NUMBER  TokenNumber
 170   )
 171 {
 172   ASSERT (TokenNumber < PEI_LOCAL_TOKEN_NUMBER);
 173
 174   return GetPcdDatabase()->Init.SizeTable[TokenNumber];
 175 }
 176
 177
 178
 179 UINT8
 180 EFIAPI
 181 PeiPcdGet8Ex (
 182   IN CONST EFI_GUID        *Guid,
 183   IN PCD_TOKEN_NUMBER  ExTokenNumber
 184   )
 185 {
 186   return *((UINT8 *) ExGetWorker (Guid, ExTokenNumber, sizeof (UINT8)));
 187 }
 188
 189
 190
 191 UINT16
 192 EFIAPI
 193 PeiPcdGet16Ex (
 194   IN CONST EFI_GUID        *Guid,
 195   IN PCD_TOKEN_NUMBER  ExTokenNumber
 196   )
 197 {
 198   return ReadUnaligned16 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT16)));
 199 }
 200
 201
 202
 203 UINT32
 204 EFIAPI
 205 PeiPcdGet32Ex (
 206   IN CONST EFI_GUID        *Guid,
 207   IN PCD_TOKEN_NUMBER  ExTokenNumber
 208   )
 209 {
 210   return ReadUnaligned32 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT32)));
 211 }
 212
 213
 214
 215 UINT64
 216 EFIAPI
 217 PeiPcdGet64Ex (
 218   IN CONST EFI_GUID        *Guid,
 219   IN PCD_TOKEN_NUMBER  ExTokenNumber
 220   )
 221 {
 222   return ReadUnaligned64 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT64)));
 223 }
 224
 225
 226
 227 VOID *
 228 EFIAPI
 229 PeiPcdGetPtrEx (
 230   IN CONST EFI_GUID        *Guid,
 231   IN PCD_TOKEN_NUMBER  ExTokenNumber
 232   )
 233 {
 234   return ExGetWorker (Guid, ExTokenNumber, 0);
 235 }
 236
 237
 238
 239 BOOLEAN
 240 EFIAPI
 241 PeiPcdGetBoolEx (
 242   IN CONST  EFI_GUID        *Guid,
 243   IN PCD_TOKEN_NUMBER                  ExTokenNumber
 244   )
 245 {
 246   return *((BOOLEAN *) ExGetWorker (Guid, ExTokenNumber, sizeof (BOOLEAN)));
 247 }
 248
 249
 250
 251 UINTN
 252 EFIAPI
 253 PeiPcdGetSizeEx (
 254   IN CONST  EFI_GUID        *Guid,
 255   IN PCD_TOKEN_NUMBER                  ExTokenNumber
 256   )
 257 {
 258   return PeiPcdGetSize (GetExPcdTokenNumber (Guid, ExTokenNumber));
 259 }
 260
 261
 262
 263 EFI_STATUS
 264 EFIAPI
 265 PeiPcdSet8 (
 266   IN PCD_TOKEN_NUMBER             TokenNumber,
 267   IN UINT8             Value
 268   )
 269 {
 270   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 271 }
 272
 273
 274
 275 EFI_STATUS
 276 EFIAPI
 277 PeiPcdSet16 (
 278   IN PCD_TOKEN_NUMBER              TokenNumber,
 279   IN UINT16             Value
 280   )
 281 {
 282   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 283 }
 284
 285
 286
 287 EFI_STATUS
 288 EFIAPI
 289 PeiPcdSet32 (
 290   IN PCD_TOKEN_NUMBER              TokenNumber,
 291   IN UINT32             Value
 292   )
 293 {
 294   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 295 }
 296
 297
 298
 299 EFI_STATUS
 300 EFIAPI
 301 PeiPcdSet64 (
 302   IN PCD_TOKEN_NUMBER              TokenNumber,
 303   IN UINT64             Value
 304   )
 305 {
 306   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 307 }
 308
 309
 310 EFI_STATUS
 311 EFIAPI
 312 PeiPcdSetPtr (
 313   IN PCD_TOKEN_NUMBER              TokenNumber,
 314   IN UINTN                         SizeOfBuffer,
 315   IN VOID                          *Buffer
 316   )
 317 {
 318   return SetWorker (TokenNumber, Buffer, SizeOfBuffer, TRUE);
 319 }
 320
 321
 322
 323 EFI_STATUS
 324 EFIAPI
 325 PeiPcdSetBool (
 326   IN PCD_TOKEN_NUMBER              TokenNumber,
 327   IN BOOLEAN            Value
 328   )
 329 {
 330   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 331 }
 332
 333
 334
 335 EFI_STATUS
 336 EFIAPI
 337 PeiPcdSet8Ex (
 338   IN CONST EFI_GUID         *Guid,
 339   IN PCD_TOKEN_NUMBER       ExTokenNumber,
 340   IN UINT8                  Value
 341   )
 342 {
 343   return          ExSetWorker(
 344                               ExTokenNumber,
 345                               Guid,
 346                               &Value,
 347                               sizeof (Value),
 348                               FALSE
 349                               );
 350 }
 351
 352
 353
 354 EFI_STATUS
 355 EFIAPI
 356 PeiPcdSet16Ex (
 357   IN CONST EFI_GUID         *Guid,
 358   IN PCD_TOKEN_NUMBER       ExTokenNumber,
 359   IN UINT16                 Value
 360   )
 361 {
 362   return          ExSetWorker(
 363                               ExTokenNumber,
 364                               Guid,
 365                               &Value,
 366                               sizeof (Value),
 367                               FALSE
 368                               );
 369 }
 370
 371
 372
 373 EFI_STATUS
 374 EFIAPI
 375 PeiPcdSet32Ex (
 376   IN CONST EFI_GUID         *Guid,
 377   IN PCD_TOKEN_NUMBER       ExTokenNumber,
 378   IN UINT32                 Value
 379   )
 380 {
 381   return          ExSetWorker(
 382                               ExTokenNumber,
 383                               Guid,
 384                               &Value,
 385                               sizeof (Value),
 386                               FALSE
 387                               );
 388 }
 389
 390
 391
 392 EFI_STATUS
 393 EFIAPI
 394 PeiPcdSet64Ex (
 395   IN CONST EFI_GUID         *Guid,
 396   IN PCD_TOKEN_NUMBER       ExTokenNumber,
 397   IN UINT64                 Value
 398   )
 399 {
 400   return          ExSetWorker(
 401                               ExTokenNumber,
 402                               Guid,
 403                               &Value,
 404                               sizeof (Value),
 405                               FALSE
 406                               );
 407 }
 408
 409
 410
 411 EFI_STATUS
 412 EFIAPI
 413 PeiPcdSetPtrEx (
 414   IN CONST EFI_GUID         *Guid,
 415   IN PCD_TOKEN_NUMBER       ExTokenNumber,
 416   IN UINTN                  SizeOfBuffer,
 417   IN VOID                   *Value
 418   )
 419 {
 420   return          ExSetWorker(
 421                               ExTokenNumber,
 422                               Guid,
 423                               Value,
 424                               SizeOfBuffer,
 425                               TRUE
 426                               );
 427 }
 428
 429
 430
 431 EFI_STATUS
 432 EFIAPI
 433 PeiPcdSetBoolEx (
 434   IN CONST EFI_GUID       *Guid,
 435   IN PCD_TOKEN_NUMBER     ExTokenNumber,
 436   IN BOOLEAN              Value
 437   )
 438 {
 439   return          ExSetWorker(
 440                               ExTokenNumber,
 441                               Guid,
 442                               &Value,
 443                               sizeof (Value),
 444                               FALSE
 445                               );
 446 }
 447
 448
 449
 450
 451 EFI_STATUS
 452 EFIAPI
 453 PeiRegisterCallBackOnSet (
 454   IN  PCD_TOKEN_NUMBER            ExTokenNumber,
 455   IN  CONST EFI_GUID              *Guid, OPTIONAL
 456   IN  PCD_PPI_CALLBACK            CallBackFunction
 457   )
 458 {
 459   ASSERT (CallBackFunction != NULL);
 460
 461   return PeiRegisterCallBackWorker (ExTokenNumber, Guid, CallBackFunction, TRUE);
 462 }
 463
 464
 465
 466 EFI_STATUS
 467 EFIAPI
 468 PcdUnRegisterCallBackOnSet (
 469   IN  PCD_TOKEN_NUMBER            ExTokenNumber,
 470   IN  CONST EFI_GUID              *Guid, OPTIONAL
 471   IN  PCD_PPI_CALLBACK            CallBackFunction
 472   )
 473 {
 474   ASSERT (CallBackFunction != NULL);
 475
 476   return PeiRegisterCallBackWorker (ExTokenNumber, Guid, CallBackFunction, FALSE);
 477 }
 478
 479
 480
 481 EFI_STATUS
 482 EFIAPI
 483 PeiPcdGetNextToken (
 484   IN CONST EFI_GUID               *Guid, OPTIONAL
 485   IN OUT  PCD_TOKEN_NUMBER        *TokenNumber
 486   )
 487 {
 488   UINTN               GuidTableIdx;
 489   PEI_PCD_DATABASE    *PeiPcdDb;
 490   EFI_GUID            *MatchGuid;
 491   DYNAMICEX_MAPPING   *ExMapTable;
 492   UINTN               i;
 493   BOOLEAN             Found;
 494
 495   if (Guid == NULL) {
 496     (*TokenNumber)++;
 497
 498     if (*TokenNumber >= PEI_NEX_TOKEN_NUMBER) {
 499       *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
 500     }
 501
 502   } else {
 503
 504     if (PEI_EXMAP_TABLE_EMPTY) {
 505       *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
 506       return EFI_NOT_FOUND;
 507     }
 508
 509     //
 510     // Assume PCD Database AutoGen tool is sorting the ExMap based on the following order
 511     // 1) ExGuid
 512     // 2) ExTokenNumber
 513     //
 514     PeiPcdDb = GetPcdDatabase ();
 515
 516     MatchGuid = ScanGuid (PeiPcdDb->Init.GuidTable, sizeof(PeiPcdDb->Init.GuidTable), Guid);
 517
 518     if (MatchGuid == NULL) {
 519       *TokenNumber = (UINTN) PCD_INVALID_TOKEN_NUMBER;
 520       return EFI_NOT_FOUND;
 521     }
 522
 523     GuidTableIdx = MatchGuid - PeiPcdDb->Init.GuidTable;
 524
 525     ExMapTable = PeiPcdDb->Init.ExMapTable;
 526
 527     Found = FALSE;
 528     for (i = 0; i < PEI_EXMAPPING_TABLE_SIZE; i++) {
 529       if (ExMapTable[i].ExGuidIndex == GuidTableIdx) {
 530         Found = TRUE;
 531         break;
 532       }
 533     }
 534
 535     if (Found) {
 536       if (*TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
 537         *TokenNumber = ExMapTable[i].ExTokenNumber;
 538          return EFI_SUCCESS;
 539       }
 540
 541       for ( ; ExMapTable[i].ExGuidIndex == GuidTableIdx; i++) {
 542         if (ExMapTable[i].ExTokenNumber == *TokenNumber) {
 543           i++;
 544           if (ExMapTable[i].ExGuidIndex == GuidTableIdx) {
 545             *TokenNumber = ExMapTable[i].ExTokenNumber;
 546             return EFI_SUCCESS;
 547           } else {
 548             *TokenNumber = (UINTN) PCD_INVALID_TOKEN_NUMBER;
 549             return EFI_SUCCESS;
 550           }
 551         }
 552       }
 553
 554       return EFI_NOT_FOUND;
 555     }
 556
 557   }
 558
 559   return EFI_SUCCESS;
 560 }
 561
 562 EFI_GUID *
 563 EFIAPI
 564 PeiPcdGetNextTokenSpaceGuid (
 565   IN CONST EFI_GUID               *Guid
 566   )
 567 {
 568   UINTN               GuidTableIdx;
 569   EFI_GUID            *MatchGuid;
 570   PEI_PCD_DATABASE    *PeiPcdDb;
 571   DYNAMICEX_MAPPING   *ExMapTable;
 572   UINTN               i;
 573   BOOLEAN             Found;
 574
 575   if (PEI_EXMAP_TABLE_EMPTY) {
 576     return NULL;
 577   }
 578
 579   //
 580   // Assume PCD Database AutoGen tool is sorting the ExMap based on the following order
 581   // 1) ExGuid
 582   // 2) ExTokenNumber
 583   //
 584   PeiPcdDb = GetPcdDatabase ();
 585
 586   MatchGuid = ScanGuid (PeiPcdDb->Init.GuidTable, sizeof(PeiPcdDb->Init.GuidTable), Guid);
 587
 588   if (MatchGuid == NULL) {
 589     return NULL;
 590   }
 591
 592   GuidTableIdx = MatchGuid - PeiPcdDb->Init.GuidTable;
 593
 594   ExMapTable = PeiPcdDb->Init.ExMapTable;
 595
 596   Found = FALSE;
 597   for (i = 0; i < PEI_EXMAPPING_TABLE_SIZE; i++) {
 598     if (ExMapTable[i].ExGuidIndex == GuidTableIdx) {
 599       Found = TRUE;
 600       break;
 601     }
 602   }
 603
 604   if (Found) {
 605     for ( ; i < PEI_EXMAPPING_TABLE_SIZE; i++ ) {
 606       if (ExMapTable[i].ExGuidIndex != GuidTableIdx ) {
 607         if (i < PEI_EXMAPPING_TABLE_SIZE) {
 608           return &PeiPcdDb->Init.GuidTable[ExMapTable[i].ExGuidIndex];
 609         } else {
 610           return NULL;
 611         }
 612       }
 613     }
 614   }
 615
 616   return NULL;
 617
 618 }
 619