EdkModulePkg/Universal/PCD/Dxe/Pcd.c

   1 /** @file
   2 PCD DXE driver
   3
   4 Copyright (c) 2006, Intel Corporation
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13
  14 Module Name: Pcd.c
  15
  16 **/
  17
  18 #include "Service.h"
  19
  20
  21 PCD_PROTOCOL mPcdInstance = {
  22   DxePcdSetSku,
  23
  24   DxePcdGet8,
  25   DxePcdGet16,
  26   DxePcdGet32,
  27   DxePcdGet64,
  28   DxePcdGetPtr,
  29   DxePcdGetBool,
  30   DxePcdGetSize,
  31
  32   DxePcdGet8Ex,
  33   DxePcdGet16Ex,
  34   DxePcdGet32Ex,
  35   DxePcdGet64Ex,
  36   DxePcdGetPtrEx,
  37   DxePcdGetBoolEx,
  38   DxePcdGetSizeEx,
  39
  40   DxePcdSet8,
  41   DxePcdSet16,
  42   DxePcdSet32,
  43   DxePcdSet64,
  44   DxePcdSetPtr,
  45   DxePcdSetBool,
  46
  47   DxePcdSet8Ex,
  48   DxePcdSet16Ex,
  49   DxePcdSet32Ex,
  50   DxePcdSet64Ex,
  51   DxePcdSetPtrEx,
  52   DxePcdSetBoolEx,
  53
  54   DxeRegisterCallBackOnSet,
  55   DxeUnRegisterCallBackOnSet,
  56   DxePcdGetNextToken
  57 };
  58
  59
  60 //
  61 // Static global to reduce the code size
  62 //
  63 static EFI_HANDLE NewHandle = NULL;
  64
  65 EFI_STATUS
  66 EFIAPI
  67 PcdDxeInit (
  68   IN EFI_HANDLE           ImageHandle,
  69   IN EFI_SYSTEM_TABLE     *SystemTable
  70   )
  71 {
  72   EFI_STATUS          Status;
  73
  74   //
  75   // Make sure the Pcd Protocol is not already installed in the system
  76   //
  77
  78   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gPcdProtocolGuid);
  79
  80   BuildPcdDxeDataBase ();
  81
  82   //
  83   // BugBug Check if PcdDatabase is already installed.
  84   //
  85
  86   Status = gBS->InstallProtocolInterface (
  87                   &NewHandle,
  88                   &gPcdProtocolGuid,
  89                   EFI_NATIVE_INTERFACE,
  90                   &mPcdInstance
  91                   );
  92
  93   ASSERT_EFI_ERROR (Status);
  94
  95   return EFI_SUCCESS;
  96
  97 }
  98
  99
 100 VOID
 101 EFIAPI
 102 DxePcdSetSku (
 103   IN  UINTN         SkuId
 104   )
 105 {
 106   mPcdDatabase->PeiDb.Init.SystemSkuId = (SKU_ID) SkuId;
 107
 108   return;
 109 }
 110
 111
 112
 113 UINT8
 114 EFIAPI
 115 DxePcdGet8 (
 116   IN UINTN                    TokenNumber
 117   )
 118 {
 119   return *((UINT8 *) GetWorker (TokenNumber, sizeof (UINT8)));
 120 }
 121
 122
 123
 124 UINT16
 125 EFIAPI
 126 DxePcdGet16 (
 127   IN UINTN                    TokenNumber
 128   )
 129 {
 130   return ReadUnaligned16 (GetWorker (TokenNumber, sizeof (UINT16)));
 131 }
 132
 133
 134
 135 UINT32
 136 EFIAPI
 137 DxePcdGet32 (
 138   IN UINTN                    TokenNumber
 139   )
 140 {
 141   return ReadUnaligned32 (GetWorker (TokenNumber, sizeof (UINT32)));
 142 }
 143
 144
 145
 146 UINT64
 147 EFIAPI
 148 DxePcdGet64 (
 149   IN UINTN                     TokenNumber
 150   )
 151 {
 152   return ReadUnaligned64(GetWorker (TokenNumber, sizeof (UINT64)));
 153 }
 154
 155
 156
 157 VOID *
 158 EFIAPI
 159 DxePcdGetPtr (
 160   IN UINTN                     TokenNumber
 161   )
 162 {
 163   return GetWorker (TokenNumber, 0);
 164 }
 165
 166
 167
 168 BOOLEAN
 169 EFIAPI
 170 DxePcdGetBool (
 171   IN UINTN                     TokenNumber
 172   )
 173 {
 174   return *((BOOLEAN *) GetWorker (TokenNumber, sizeof (BOOLEAN)));
 175 }
 176
 177
 178
 179 UINTN
 180 EFIAPI
 181 DxePcdGetSize (
 182   IN UINTN                     TokenNumber
 183   )
 184 {
 185   UINT16 * SizeTable;
 186   //
 187   // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.
 188   // We have to decrement TokenNumber by 1 to make it usable
 189   // as the array index.
 190   //
 191   TokenNumber--;
 192
 193   SizeTable = (TokenNumber < PEI_LOCAL_TOKEN_NUMBER) ? mPcdDatabase->PeiDb.Init.SizeTable :
 194                                                     mPcdDatabase->DxeDb.Init.SizeTable;
 195
 196
 197   TokenNumber = (TokenNumber < PEI_LOCAL_TOKEN_NUMBER) ? TokenNumber : (TokenNumber - PEI_LOCAL_TOKEN_NUMBER);
 198
 199   return SizeTable[TokenNumber];
 200 }
 201
 202
 203
 204 UINT8
 205 EFIAPI
 206 DxePcdGet8Ex (
 207   IN CONST EFI_GUID         *Guid,
 208   IN UINTN                 ExTokenNumber
 209   )
 210 {
 211   return *((UINT8 *) ExGetWorker (Guid, ExTokenNumber, sizeof(UINT8)));
 212 }
 213
 214
 215
 216 UINT16
 217 EFIAPI
 218 DxePcdGet16Ex (
 219   IN CONST EFI_GUID        *Guid,
 220   IN UINTN                ExTokenNumber
 221   )
 222 {
 223   return ReadUnaligned16 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT16)));
 224 }
 225
 226
 227
 228 UINT32
 229 EFIAPI
 230 DxePcdGet32Ex (
 231   IN CONST EFI_GUID        *Guid,
 232   IN UINTN                 ExTokenNumber
 233   )
 234 {
 235   return ReadUnaligned32 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT32)));
 236 }
 237
 238
 239
 240 UINT64
 241 EFIAPI
 242 DxePcdGet64Ex (
 243   IN CONST EFI_GUID        *Guid,
 244   IN UINTN                 ExTokenNumber
 245   )
 246 {
 247   return ReadUnaligned64 (ExGetWorker (Guid, ExTokenNumber, sizeof(UINT64)));
 248 }
 249
 250
 251
 252 VOID *
 253 EFIAPI
 254 DxePcdGetPtrEx (
 255   IN CONST EFI_GUID        *Guid,
 256   IN UINTN                 ExTokenNumber
 257   )
 258 {
 259   return ExGetWorker (Guid, ExTokenNumber, 0);
 260 }
 261
 262
 263
 264 BOOLEAN
 265 EFIAPI
 266 DxePcdGetBoolEx (
 267   IN CONST EFI_GUID        *Guid,
 268   IN UINTN                 ExTokenNumber
 269   )
 270 {
 271   return *((BOOLEAN *) ExGetWorker (Guid, ExTokenNumber, sizeof(BOOLEAN)));
 272 }
 273
 274
 275
 276 UINTN
 277 EFIAPI
 278 DxePcdGetSizeEx (
 279   IN CONST EFI_GUID        *Guid,
 280   IN UINTN                 ExTokenNumber
 281   )
 282 {
 283   return DxePcdGetSize(GetExPcdTokenNumber (Guid, (UINT32) ExTokenNumber));
 284 }
 285
 286
 287
 288 EFI_STATUS
 289 EFIAPI
 290 DxePcdSet8 (
 291   IN UINTN              TokenNumber,
 292   IN UINT8              Value
 293   )
 294 {
 295   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 296 }
 297
 298
 299
 300 EFI_STATUS
 301 EFIAPI
 302 DxePcdSet16 (
 303   IN UINTN              TokenNumber,
 304   IN UINT16             Value
 305   )
 306 {
 307   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 308 }
 309
 310
 311
 312 EFI_STATUS
 313 EFIAPI
 314 DxePcdSet32 (
 315   IN UINTN              TokenNumber,
 316   IN UINT32             Value
 317   )
 318 {
 319   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 320 }
 321
 322
 323
 324 EFI_STATUS
 325 EFIAPI
 326 DxePcdSet64 (
 327   IN UINTN              TokenNumber,
 328   IN UINT64             Value
 329   )
 330 {
 331   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 332 }
 333
 334
 335
 336 EFI_STATUS
 337 EFIAPI
 338 DxePcdSetPtr (
 339   IN UINTN              TokenNumber,
 340   IN UINTN              SizeOfBuffer,
 341   IN VOID               *Buffer
 342   )
 343 {
 344   return SetWorker (TokenNumber, Buffer, SizeOfBuffer, TRUE);
 345 }
 346
 347
 348
 349 EFI_STATUS
 350 EFIAPI
 351 DxePcdSetBool (
 352   IN UINTN              TokenNumber,
 353   IN BOOLEAN            Value
 354   )
 355 {
 356   return SetWorker (TokenNumber, &Value, sizeof (Value), FALSE);
 357 }
 358
 359
 360
 361 EFI_STATUS
 362 EFIAPI
 363 DxePcdSet8Ex (
 364   IN CONST EFI_GUID         *Guid,
 365   IN UINTN                  ExTokenNumber,
 366   IN UINT8                  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 DxePcdSet16Ex (
 383   IN CONST EFI_GUID    *Guid,
 384   IN UINTN             ExTokenNumber,
 385   IN UINT16            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 DxePcdSet32Ex (
 402   IN CONST EFI_GUID     *Guid,
 403   IN UINTN              ExTokenNumber,
 404   IN UINT32             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 DxePcdSet64Ex (
 421   IN CONST EFI_GUID    *Guid,
 422   IN UINTN             ExTokenNumber,
 423   IN UINT64            Value
 424   )
 425 {
 426   return          ExSetWorker(
 427                               ExTokenNumber,
 428                               Guid,
 429                               &Value,
 430                               sizeof (Value),
 431                               FALSE
 432                               );
 433 }
 434
 435
 436
 437 EFI_STATUS
 438 EFIAPI
 439 DxePcdSetPtrEx (
 440   IN CONST EFI_GUID         *Guid,
 441   IN UINTN                  ExTokenNumber,
 442   IN UINTN                  SizeOfBuffer,
 443   IN VOID                   *Buffer
 444   )
 445 {
 446   return          ExSetWorker(
 447                               ExTokenNumber,
 448                               Guid,
 449                               Buffer,
 450                               SizeOfBuffer,
 451                               TRUE
 452                               );
 453 }
 454
 455
 456
 457 EFI_STATUS
 458 EFIAPI
 459 DxePcdSetBoolEx (
 460   IN CONST EFI_GUID    *Guid,
 461   IN UINTN             ExTokenNumber,
 462   IN BOOLEAN           Value
 463   )
 464 {
 465   return          ExSetWorker(
 466                               ExTokenNumber,
 467                               Guid,
 468                               &Value,
 469                               sizeof (Value),
 470                               TRUE
 471                               );
 472 }
 473
 474
 475
 476
 477 EFI_STATUS
 478 EFIAPI
 479 DxeRegisterCallBackOnSet (
 480   IN  UINTN                   TokenNumber,
 481   IN  CONST EFI_GUID          *Guid, OPTIONAL
 482   IN  PCD_PROTOCOL_CALLBACK   CallBackFunction
 483   )
 484 {
 485   ASSERT (CallBackFunction != NULL);
 486
 487   return DxeRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);
 488 }
 489
 490
 491
 492 EFI_STATUS
 493 EFIAPI
 494 DxeUnRegisterCallBackOnSet (
 495   IN  UINTN                   TokenNumber,
 496   IN  CONST EFI_GUID          *Guid, OPTIONAL
 497   IN  PCD_PROTOCOL_CALLBACK   CallBackFunction
 498   )
 499 {
 500   ASSERT (CallBackFunction != NULL);
 501
 502   return DxeUnRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction);
 503 }
 504
 505
 506
 507 EFI_STATUS
 508 EFIAPI
 509 DxePcdGetNextToken (
 510   IN CONST EFI_GUID         *Guid, OPTIONAL
 511   IN OUT   UINTN            *TokenNumber
 512   )
 513 {
 514   UINTN               ExTokenNumber;
 515
 516   //
 517   // Scan the local token space
 518   //
 519   if (Guid == NULL) {
 520     (*TokenNumber)++;
 521     if (*TokenNumber == PCD_INVALID_TOKEN_NUMBER) {
 522       return EFI_SUCCESS;
 523     } else {
 524       if (*TokenNumber >= PEI_NEX_TOKEN_NUMBER &&
 525           *TokenNumber < PEI_LOCAL_TOKEN_NUMBER) {
 526         //
 527         // The first Non-Ex type Token Number for DXE PCD
 528         // database is PEI_LOCAL_TOKEN_NUMBER
 529         //
 530         *TokenNumber = PEI_LOCAL_TOKEN_NUMBER;
 531         return EFI_SUCCESS;
 532       } else if (*TokenNumber >= DXE_NEX_TOKEN_NUMBER + PEI_LOCAL_TOKEN_NUMBER) {
 533         *TokenNumber = PCD_INVALID_TOKEN_NUMBER;
 534         return EFI_SUCCESS;
 535       }
 536     }
 537   }
 538
 539   if (PEI_EXMAP_TABLE_EMPTY && PEI_EXMAP_TABLE_EMPTY) {
 540     *TokenNumber = (UINTN) PCD_INVALID_TOKEN_NUMBER;
 541     return EFI_NOT_FOUND;
 542   }
 543
 544   ExTokenNumber = *TokenNumber;
 545   if (!PEI_EXMAP_TABLE_EMPTY) {
 546     ExTokenNumber = ExGetNextTokeNumber (
 547                         Guid,
 548                         ExTokenNumber,
 549                         mPcdDatabase->PeiDb.Init.GuidTable,
 550                         sizeof(mPcdDatabase->PeiDb.Init.GuidTable),
 551                         mPcdDatabase->PeiDb.Init.ExMapTable,
 552                         sizeof(mPcdDatabase->PeiDb.Init.ExMapTable)
 553                         );
 554   }
 555
 556   if (!DXE_EXMAP_TABLE_EMPTY) {
 557     ExTokenNumber = ExGetNextTokeNumber (
 558                         Guid,
 559                         ExTokenNumber,
 560                         mPcdDatabase->PeiDb.Init.GuidTable,
 561                         sizeof(mPcdDatabase->PeiDb.Init.GuidTable),
 562                         mPcdDatabase->PeiDb.Init.ExMapTable,
 563                         sizeof(mPcdDatabase->PeiDb.Init.ExMapTable)
 564                         );
 565   }
 566
 567   *TokenNumber = ExTokenNumber;
 568
 569   return EFI_SUCCESS;
 570 }
 571