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 = PeiServicesInstallPpi (&mPpiPCD);
  80
  81   ASSERT_EFI_ERROR (Status);
  82
  83   return EFI_SUCCESS;
  84 }
  85
  86 VOID
  87 EFIAPI
  88 PeiPcdSetSku (
  89   IN  UINTN                  SkuId
  90   )
  91 {
  92
  93   GetPcdDatabase()->Init.SystemSkuId = (SKU_ID) SkuId;
  94
  95   return;
  96 }
  97
  98
  99
 100 UINT8
 101 EFIAPI
 102 PeiPcdGet8 (
 103   IN UINTN             TokenNumber
 104   )
 105 {
 106   return *((UINT8 *) GetWorker (TokenNumber, sizeof (UINT8)));
 107 }
 108
 109
 110
 111 UINT16
 112 EFIAPI
 113 PeiPcdGet16 (
 114   IN UINTN             TokenNumber
 115   )
 116 {
 117   return ReadUnaligned16 (GetWorker (TokenNumber, sizeof (UINT16)));
 118 }
 119
 120
 121
 122 UINT32
 123 EFIAPI
 124 PeiPcdGet32 (
 125   IN UINTN             TokenNumber
 126   )
 127 {
 128   return ReadUnaligned32 (GetWorker (TokenNumber, sizeof (UINT32)));
 129 }
 130
 131
 132
 133 UINT64
 134 EFIAPI
 135 PeiPcdGet64 (
 136   IN UINTN             TokenNumber
 137   )
 138 {
 139   return ReadUnaligned64 (GetWorker (TokenNumber, sizeof (UINT64)));
 140 }
 141
 142
 143
 144 VOID *
 145 EFIAPI
 146 PeiPcdGetPtr (
 147   IN UINTN             TokenNumber
 148   )
 149 {
 150   return GetWorker (TokenNumber, 0);
 151 }
 152
 153
 154
 155 BOOLEAN
 156 EFIAPI
 157 PeiPcdGetBool (
 158   IN UINTN             TokenNumber
 159   )
 160 {
 161   return *((BOOLEAN *) GetWorker (TokenNumber, sizeof (BOOLEAN)));
 162 }
 163
 164
 165
 166 UINTN
 167 EFIAPI
 168 PeiPcdGetSize (
 169   IN UINTN             TokenNumber
 170   )
 171 {
 172   //
 173   // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
 174   // We have to decrement TokenNumber by 1 to make it usable
 175   // as the array index.
 176   //
 177   TokenNumber--;
 178
 179   ASSERT (TokenNumber < PEI_LOCAL_TOKEN_NUMBER);
 180
 181   return GetPcdDatabase()->Init.SizeTable[TokenNumber];
 182 }
 183
 184
 185
 186 UINT8
 187 EFIAPI
 188 PeiPcdGet8Ex (
 189   IN CONST EFI_GUID        *Guid,
 190   IN UINTN             ExTokenNumber
 191   )
 192 {
 193   return *((UINT8 *) ExGetWorker (Guid, ExTokenNumber, sizeof (UINT8)));
 194 }
 195
 196
 197
 198 UINT16
 199 EFIAPI
 200 PeiPcdGet16Ex (
 201   IN CONST EFI_GUID        *Guid,
 202   IN UINTN             ExTokenNumber
 203   )
 204 {
 205   return ReadUnaligned16 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT16)));
 206 }
 207
 208
 209
 210 UINT32
 211 EFIAPI
 212 PeiPcdGet32Ex (
 213   IN CONST EFI_GUID        *Guid,
 214   IN UINTN             ExTokenNumber
 215   )
 216 {
 217   return ReadUnaligned32 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT32)));
 218 }
 219
 220
 221
 222 UINT64
 223 EFIAPI
 224 PeiPcdGet64Ex (
 225   IN CONST EFI_GUID        *Guid,
 226   IN UINTN             ExTokenNumber
 227   )
 228 {
 229   return ReadUnaligned64 (ExGetWorker (Guid, ExTokenNumber, sizeof (UINT64)));
 230 }
 231
 232
 233
 234 VOID *
 235 EFIAPI
 236 PeiPcdGetPtrEx (
 237   IN CONST EFI_GUID        *Guid,
 238   IN UINTN             ExTokenNumber
 239   )
 240 {
 241   return ExGetWorker (Guid, ExTokenNumber, 0);
 242 }
 243
 244
 245
 246 BOOLEAN
 247 EFIAPI
 248 PeiPcdGetBoolEx (
 249   IN CONST  EFI_GUID        *Guid,
 250   IN UINTN                             ExTokenNumber
 251   )
 252 {
 253   return *((BOOLEAN *) ExGetWorker (Guid, ExTokenNumber, sizeof (BOOLEAN)));
 254 }
 255
 256
 257
 258 UINTN
 259 EFIAPI
 260 PeiPcdGetSizeEx (
 261   IN CONST  EFI_GUID        *Guid,
 262   IN UINTN                             ExTokenNumber
 263   )
 264 {
 265   return PeiPcdGetSize (GetExPcdTokenNumber (Guid, ExTokenNumber));
 266 }
 267
 268
 269
 270 EFI_STATUS
 271 EFIAPI
 272 PeiPcdSet8 (
 273   IN UINTN                        TokenNumber,
 274   IN UINT8             Value
 275   )
 276 {
 277   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 278 }
 279
 280
 281
 282 EFI_STATUS
 283 EFIAPI
 284 PeiPcdSet16 (
 285   IN UINTN                         TokenNumber,
 286   IN UINT16             Value
 287   )
 288 {
 289   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 290 }
 291
 292
 293
 294 EFI_STATUS
 295 EFIAPI
 296 PeiPcdSet32 (
 297   IN UINTN                         TokenNumber,
 298   IN UINT32             Value
 299   )
 300 {
 301   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 302 }
 303
 304
 305
 306 EFI_STATUS
 307 EFIAPI
 308 PeiPcdSet64 (
 309   IN UINTN                         TokenNumber,
 310   IN UINT64             Value
 311   )
 312 {
 313   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 314 }
 315
 316
 317 EFI_STATUS
 318 EFIAPI
 319 PeiPcdSetPtr (
 320   IN UINTN                         TokenNumber,
 321   IN UINTN                         SizeOfBuffer,
 322   IN VOID                          *Buffer
 323   )
 324 {
 325   return SetWorker (TokenNumber, Buffer, SizeOfBuffer, TRUE);
 326 }
 327
 328
 329
 330 EFI_STATUS
 331 EFIAPI
 332 PeiPcdSetBool (
 333   IN UINTN                         TokenNumber,
 334   IN BOOLEAN            Value
 335   )
 336 {
 337   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 338 }
 339
 340
 341
 342 EFI_STATUS
 343 EFIAPI
 344 PeiPcdSet8Ex (
 345   IN CONST EFI_GUID         *Guid,
 346   IN UINTN                  ExTokenNumber,
 347   IN UINT8                  Value
 348   )
 349 {
 350   return          ExSetWorker(
 351                               ExTokenNumber,
 352                               Guid,
 353                               &Value,
 354                               sizeof (Value),
 355                               FALSE
 356                               );
 357 }
 358
 359
 360
 361 EFI_STATUS
 362 EFIAPI
 363 PeiPcdSet16Ex (
 364   IN CONST EFI_GUID         *Guid,
 365   IN UINTN                  ExTokenNumber,
 366   IN UINT16                 Value
 367   )
 368 {
 369   return          ExSetWorker(
 370                               ExTokenNumber,
 371                               Guid,
 372                               &Value,
 373                               sizeof (Value),
 374                               FALSE
 375                               );
 376 }
 377
 378
 379
 380 EFI_STATUS
 381 EFIAPI
 382 PeiPcdSet32Ex (
 383   IN CONST EFI_GUID         *Guid,
 384   IN UINTN                  ExTokenNumber,
 385   IN UINT32                 Value
 386   )
 387 {
 388   return          ExSetWorker(
 389                               ExTokenNumber,
 390                               Guid,
 391                               &Value,
 392                               sizeof (Value),
 393                               FALSE
 394                               );
 395 }
 396
 397
 398
 399 EFI_STATUS
 400 EFIAPI
 401 PeiPcdSet64Ex (
 402   IN CONST EFI_GUID         *Guid,
 403   IN UINTN                  ExTokenNumber,
 404   IN UINT64                 Value
 405   )
 406 {
 407   return          ExSetWorker(
 408                               ExTokenNumber,
 409                               Guid,
 410                               &Value,
 411                               sizeof (Value),
 412                               FALSE
 413                               );
 414 }
 415
 416
 417
 418 EFI_STATUS
 419 EFIAPI
 420 PeiPcdSetPtrEx (
 421   IN CONST EFI_GUID         *Guid,
 422   IN UINTN                  ExTokenNumber,
 423   IN UINTN                  SizeOfBuffer,
 424   IN VOID                   *Value
 425   )
 426 {
 427   return          ExSetWorker(
 428                               ExTokenNumber,
 429                               Guid,
 430                               Value,
 431                               SizeOfBuffer,
 432                               TRUE
 433                               );
 434 }
 435
 436
 437
 438 EFI_STATUS
 439 EFIAPI
 440 PeiPcdSetBoolEx (
 441   IN CONST EFI_GUID       *Guid,
 442   IN UINTN                ExTokenNumber,
 443   IN BOOLEAN              Value
 444   )
 445 {
 446   return          ExSetWorker(
 447                               ExTokenNumber,
 448                               Guid,
 449                               &Value,
 450                               sizeof (Value),
 451                               FALSE
 452                               );
 453 }
 454
 455
 456
 457
 458 EFI_STATUS
 459 EFIAPI
 460 PeiRegisterCallBackOnSet (
 461   IN  UINTN                       ExTokenNumber,
 462   IN  CONST EFI_GUID              *Guid, OPTIONAL
 463   IN  PCD_PPI_CALLBACK            CallBackFunction
 464   )
 465 {
 466   ASSERT (CallBackFunction != NULL);
 467
 468   return PeiRegisterCallBackWorker (ExTokenNumber, Guid, CallBackFunction, TRUE);
 469 }
 470
 471
 472
 473 EFI_STATUS
 474 EFIAPI
 475 PcdUnRegisterCallBackOnSet (
 476   IN  UINTN                       ExTokenNumber,
 477   IN  CONST EFI_GUID              *Guid, OPTIONAL
 478   IN  PCD_PPI_CALLBACK            CallBackFunction
 479   )
 480 {
 481   ASSERT (CallBackFunction != NULL);
 482
 483   return PeiRegisterCallBackWorker (ExTokenNumber, Guid, CallBackFunction, FALSE);
 484 }
 485
 486
 487
 488 EFI_STATUS
 489 EFIAPI
 490 PeiPcdGetNextToken (
 491   IN CONST EFI_GUID               *Guid, OPTIONAL
 492   IN OUT  UINTN                   *TokenNumber
 493   )
 494 {
 495   UINTN               GuidTableIdx;
 496   PEI_PCD_DATABASE    *PeiPcdDb;
 497   EFI_GUID            *MatchGuid;
 498   DYNAMICEX_MAPPING   *ExMapTable;
 499   UINTN               i;
 500   BOOLEAN             Found;
 501
 502   if (Guid == NULL) {
 503     (*TokenNumber)++;
 504
 505     if (*TokenNumber >= PEI_NEX_TOKEN_NUMBER) {
 506       *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
 507     }
 508
 509   } else {
 510
 511     if (PEI_EXMAP_TABLE_EMPTY) {
 512       *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
 513       return EFI_NOT_FOUND;
 514     }
 515
 516     //
 517     // Assume PCD Database AutoGen tool is sorting the ExMap based on the following order
 518     // 1) ExGuid
 519     // 2) ExTokenNumber
 520     //
 521     PeiPcdDb = GetPcdDatabase ();
 522
 523     MatchGuid = ScanGuid (PeiPcdDb->Init.GuidTable, sizeof(PeiPcdDb->Init.GuidTable), Guid);
 524
 525     if (MatchGuid == NULL) {
 526       *TokenNumber = (UINTN) PCD_INVALID_TOKEN_NUMBER;
 527       return EFI_NOT_FOUND;
 528     }
 529
 530     GuidTableIdx = MatchGuid - PeiPcdDb->Init.GuidTable;
 531
 532     ExMapTable = PeiPcdDb->Init.ExMapTable;
 533
 534     Found = FALSE;
 535     for (i = 0; i < PEI_EXMAPPING_TABLE_SIZE; i++) {
 536       if (ExMapTable[i].ExGuidIndex == GuidTableIdx) {
 537         Found = TRUE;
 538         break;
 539       }
 540     }
 541
 542     if (Found) {
 543       if (*TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
 544         *TokenNumber = ExMapTable[i].ExTokenNumber;
 545          return EFI_SUCCESS;
 546       }
 547
 548       for ( ; ExMapTable[i].ExGuidIndex == GuidTableIdx; i++) {
 549         if (ExMapTable[i].ExTokenNumber == *TokenNumber) {
 550           i++;
 551           if (ExMapTable[i].ExGuidIndex == GuidTableIdx) {
 552             *TokenNumber = ExMapTable[i].ExTokenNumber;
 553             return EFI_SUCCESS;
 554           } else {
 555             *TokenNumber = (UINTN) PCD_INVALID_TOKEN_NUMBER;
 556             return EFI_SUCCESS;
 557           }
 558         }
 559       }
 560
 561       return EFI_NOT_FOUND;
 562     }
 563
 564   }
 565
 566   return EFI_SUCCESS;
 567 }
 568
 569 EFI_STATUS
 570 EFIAPI
 571 PeiPcdGetNextTokenSpaceGuid (
 572   IN OUT CONST EFI_GUID               **Guid
 573   )
 574 {
 575   UINTN               GuidTableIdx;
 576   EFI_GUID            *MatchGuid;
 577   PEI_PCD_DATABASE    *PeiPcdDb;
 578   DYNAMICEX_MAPPING   *ExMapTable;
 579   UINTN               i;
 580   BOOLEAN             Found;
 581
 582    if (*Guid == NULL) {
 583     if (PEI_EXMAP_TABLE_EMPTY) {
 584       return EFI_SUCCESS;
 585     } else {
 586       //
 587       // return the first Token Space Guid.
 588       //
 589       *Guid = &PeiPcdDb->Init.GuidTable[ExMapTable[0].ExGuidIndex];
 590       return EFI_SUCCESS;
 591     }
 592    }
 593
 594   //
 595   // Assume PCD Database AutoGen tool is sorting the ExMap based on the following order
 596   // 1) ExGuid
 597   // 2) ExTokenNumber
 598   //
 599   PeiPcdDb = GetPcdDatabase ();
 600
 601   MatchGuid = ScanGuid (PeiPcdDb->Init.GuidTable, sizeof(PeiPcdDb->Init.GuidTable), *Guid);
 602
 603   if (MatchGuid == NULL) {
 604     return EFI_NOT_FOUND;
 605   }
 606
 607   GuidTableIdx = MatchGuid - PeiPcdDb->Init.GuidTable;
 608
 609   ExMapTable = PeiPcdDb->Init.ExMapTable;
 610
 611   Found = FALSE;
 612   for (i = 0; i < PEI_EXMAPPING_TABLE_SIZE; i++) {
 613     if (ExMapTable[i].ExGuidIndex == GuidTableIdx) {
 614       Found = TRUE;
 615       break;
 616     }
 617   }
 618
 619   if (Found) {
 620     for ( ; i < PEI_EXMAPPING_TABLE_SIZE; i++ ) {
 621       if (ExMapTable[i].ExGuidIndex != GuidTableIdx ) {
 622         *Guid = &PeiPcdDb->Init.GuidTable[ExMapTable[i].ExGuidIndex];
 623         return EFI_SUCCESS;
 624       }
 625     }
 626   }
 627
 628   return EFI_NOT_FOUND;
 629
 630 }
 631