Nt32Pkg/CpuRuntimeDxe/Cpu.c

   1 /*++
   2
   3 Copyright (c) 2006 - 2007, 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 Module Name:
  13
  14   Cpu.c
  15
  16 Abstract:
  17
  18   NT Emulation Architectural Protocol Driver as defined in Tiano.
  19   This CPU module abstracts the interrupt subsystem of a platform and
  20   the CPU-specific setjump/long pair.  Other services are not implemented
  21   in this driver.
  22
  23 --*/
  24
  25
  26 #include "CpuDriver.h"
  27
  28
  29 CPU_ARCH_PROTOCOL_PRIVATE mCpuTemplate = {
  30   CPU_ARCH_PROT_PRIVATE_SIGNATURE,
  31   NULL,
  32   {
  33     WinNtFlushCpuDataCache,
  34     WinNtEnableInterrupt,
  35     WinNtDisableInterrupt,
  36     WinNtGetInterruptState,
  37     WinNtInit,
  38     WinNtRegisterInterruptHandler,
  39     WinNtGetTimerValue,
  40     WinNtSetMemoryAttributes,
  41     0,
  42     4
  43   },
  44   {
  45     CpuMemoryServiceRead,
  46     CpuMemoryServiceWrite,
  47     CpuIoServiceRead,
  48     CpuIoServiceWrite
  49   },
  50   0,
  51   TRUE
  52 };
  53
  54 #define EFI_CPU_DATA_MAXIMUM_LENGTH 0x100
  55
  56
  57
  58 typedef union {
  59   EFI_CPU_DATA_RECORD *DataRecord;
  60   UINT8               *Raw;
  61 } EFI_CPU_DATA_RECORD_BUFFER;
  62
  63 EFI_SUBCLASS_TYPE1_HEADER mCpuDataRecordHeader = {
  64   EFI_PROCESSOR_SUBCLASS_VERSION,       // Version
  65   sizeof (EFI_SUBCLASS_TYPE1_HEADER),   // Header Size
  66   0,                                    // Instance, Initialize later
  67   EFI_SUBCLASS_INSTANCE_NON_APPLICABLE, // SubInstance
  68   0                                     // RecordType, Initialize later
  69 };
  70
  71 //
  72 // Service routines for the driver
  73 //
  74 EFI_STATUS
  75 EFIAPI
  76 WinNtFlushCpuDataCache (
  77   IN EFI_CPU_ARCH_PROTOCOL  *This,
  78   IN EFI_PHYSICAL_ADDRESS   Start,
  79   IN UINT64                 Length,
  80   IN EFI_CPU_FLUSH_TYPE     FlushType
  81   )
  82 /*++
  83
  84 Routine Description:
  85
  86   This routine would provide support for flushing the CPU data cache.
  87   In the case of NT emulation environment, this flushing is not necessary and
  88   is thus not implemented.
  89
  90 Arguments:
  91
  92   Pointer to CPU Architectural Protocol interface
  93   Start adddress in memory to flush
  94   Length of memory to flush
  95   Flush type
  96
  97 Returns:
  98
  99   Status
 100     EFI_SUCCESS
 101
 102 --*/
 103 // TODO:    This - add argument and description to function comment
 104 // TODO:    FlushType - add argument and description to function comment
 105 // TODO:    EFI_UNSUPPORTED - add return value to function comment
 106 {
 107   if (FlushType == EfiCpuFlushTypeWriteBackInvalidate) {
 108     //
 109     // Only WB flush is supported. We actually need do nothing on NT emulator
 110     // environment. Classify this to follow EFI spec
 111     //
 112     return EFI_SUCCESS;
 113   }
 114   //
 115   // Other flush types are not supported by NT emulator
 116   //
 117   return EFI_UNSUPPORTED;
 118 }
 119
 120
 121 EFI_STATUS
 122 EFIAPI
 123 WinNtEnableInterrupt (
 124   IN EFI_CPU_ARCH_PROTOCOL  *This
 125   )
 126 /*++
 127
 128 Routine Description:
 129
 130   This routine provides support for emulation of the interrupt enable of the
 131   the system.  For our purposes, CPU enable is just a BOOLEAN that the Timer
 132   Architectural Protocol observes in order to defer behaviour while in its
 133   emulated interrupt, or timer tick.
 134
 135 Arguments:
 136
 137   Pointer to CPU Architectural Protocol interface
 138
 139 Returns:
 140
 141   Status
 142     EFI_SUCCESS
 143
 144 --*/
 145 // TODO:    This - add argument and description to function comment
 146 {
 147   CPU_ARCH_PROTOCOL_PRIVATE *Private;
 148
 149   Private                 = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
 150   Private->InterruptState = TRUE;
 151   return EFI_SUCCESS;
 152 }
 153
 154
 155 EFI_STATUS
 156 EFIAPI
 157 WinNtDisableInterrupt (
 158   IN EFI_CPU_ARCH_PROTOCOL  *This
 159   )
 160 /*++
 161
 162 Routine Description:
 163
 164   This routine provides support for emulation of the interrupt disable of the
 165   the system.  For our purposes, CPU enable is just a BOOLEAN that the Timer
 166   Architectural Protocol observes in order to defer behaviour while in its
 167   emulated interrupt, or timer tick.
 168
 169 Arguments:
 170
 171   Pointer to CPU Architectural Protocol interface
 172
 173 Returns:
 174
 175   Status
 176     EFI_SUCCESS
 177
 178 --*/
 179 // TODO:    This - add argument and description to function comment
 180 {
 181   CPU_ARCH_PROTOCOL_PRIVATE *Private;
 182
 183   Private                 = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
 184   Private->InterruptState = FALSE;
 185   return EFI_SUCCESS;
 186 }
 187
 188
 189 EFI_STATUS
 190 EFIAPI
 191 WinNtGetInterruptState (
 192   IN EFI_CPU_ARCH_PROTOCOL  *This,
 193   OUT BOOLEAN               *State
 194   )
 195 /*++
 196
 197 Routine Description:
 198
 199   This routine provides support for emulation of the interrupt disable of the
 200   the system.  For our purposes, CPU enable is just a BOOLEAN that the Timer
 201   Architectural Protocol observes in order to defer behaviour while in its
 202   emulated interrupt, or timer tick.
 203
 204 Arguments:
 205
 206   Pointer to CPU Architectural Protocol interface
 207
 208 Returns:
 209
 210   Status
 211     EFI_SUCCESS
 212
 213 --*/
 214 // TODO:    This - add argument and description to function comment
 215 // TODO:    State - add argument and description to function comment
 216 // TODO:    EFI_INVALID_PARAMETER - add return value to function comment
 217 {
 218   CPU_ARCH_PROTOCOL_PRIVATE *Private;
 219
 220   if (State == NULL) {
 221     return EFI_INVALID_PARAMETER;
 222   }
 223
 224   Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
 225   *State  = Private->InterruptState;
 226   return EFI_SUCCESS;
 227 }
 228
 229
 230 EFI_STATUS
 231 EFIAPI
 232 WinNtInit (
 233   IN EFI_CPU_ARCH_PROTOCOL  *This,
 234   IN EFI_CPU_INIT_TYPE      InitType
 235   )
 236 /*++
 237
 238 Routine Description:
 239
 240   This routine would support generation of a CPU INIT.  At
 241   present, this code does not provide emulation.
 242
 243 Arguments:
 244
 245   Pointer to CPU Architectural Protocol interface
 246   INIT Type
 247
 248 Returns:
 249
 250   Status
 251     EFI_UNSUPPORTED - not yet implemented
 252
 253 --*/
 254 // TODO:    This - add argument and description to function comment
 255 // TODO:    InitType - add argument and description to function comment
 256 {
 257   CPU_ARCH_PROTOCOL_PRIVATE *Private;
 258
 259   Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
 260   return EFI_UNSUPPORTED;
 261 }
 262
 263
 264 EFI_STATUS
 265 EFIAPI
 266 WinNtRegisterInterruptHandler (
 267   IN EFI_CPU_ARCH_PROTOCOL      *This,
 268   IN EFI_EXCEPTION_TYPE         InterruptType,
 269   IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
 270   )
 271 /*++
 272
 273 Routine Description:
 274
 275   This routine would support registration of an interrupt handler.  At
 276   present, this code does not provide emulation.
 277
 278 Arguments:
 279
 280   Pointer to CPU Architectural Protocol interface
 281   Pointer to interrupt handlers
 282   Interrupt type
 283
 284 Returns:
 285
 286   Status
 287     EFI_UNSUPPORTED - not yet implemented
 288
 289 --*/
 290 // TODO:    This - add argument and description to function comment
 291 // TODO:    InterruptType - add argument and description to function comment
 292 // TODO:    InterruptHandler - add argument and description to function comment
 293 {
 294   CPU_ARCH_PROTOCOL_PRIVATE *Private;
 295
 296   //
 297   // Do parameter checking for EFI spec conformance
 298   //
 299   if (InterruptType < 0 || InterruptType > 0xff) {
 300     return EFI_UNSUPPORTED;
 301   }
 302   //
 303   // Do nothing for Nt32 emulation
 304   //
 305   Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
 306   return EFI_UNSUPPORTED;
 307 }
 308
 309
 310 EFI_STATUS
 311 EFIAPI
 312 WinNtGetTimerValue (
 313   IN  EFI_CPU_ARCH_PROTOCOL *This,
 314   IN  UINT32                TimerIndex,
 315   OUT UINT64                *TimerValue,
 316   OUT UINT64                *TimerPeriod OPTIONAL
 317   )
 318 /*++
 319
 320 Routine Description:
 321
 322   This routine would support querying of an on-CPU timer.  At present,
 323   this code does not provide timer emulation.
 324
 325 Arguments:
 326
 327   This        - Pointer to CPU Architectural Protocol interface
 328   TimerIndex  - Index of given CPU timer
 329   TimerValue  - Output of the timer
 330   TimerPeriod - Output of the timer period
 331
 332 Returns:
 333
 334   EFI_UNSUPPORTED       - not yet implemented
 335   EFI_INVALID_PARAMETER - TimeValue is NULL
 336
 337 --*/
 338 {
 339   if (TimerValue == NULL) {
 340     return EFI_INVALID_PARAMETER;
 341   }
 342
 343   //
 344   // No timer supported
 345   //
 346   return EFI_UNSUPPORTED;
 347 }
 348
 349
 350 EFI_STATUS
 351 EFIAPI
 352 WinNtSetMemoryAttributes (
 353   IN EFI_CPU_ARCH_PROTOCOL  *This,
 354   IN EFI_PHYSICAL_ADDRESS   BaseAddress,
 355   IN UINT64                 Length,
 356   IN UINT64                 Attributes
 357   )
 358 /*++
 359
 360 Routine Description:
 361
 362   This routine would support querying of an on-CPU timer.  At present,
 363   this code does not provide timer emulation.
 364
 365 Arguments:
 366
 367   Pointer to CPU Architectural Protocol interface
 368   Start address of memory region
 369   The size in bytes of the memory region
 370   The bit mask of attributes to set for the memory region
 371
 372 Returns:
 373
 374   Status
 375     EFI_UNSUPPORTED - not yet implemented
 376
 377 --*/
 378 // TODO:    This - add argument and description to function comment
 379 // TODO:    BaseAddress - add argument and description to function comment
 380 // TODO:    Length - add argument and description to function comment
 381 // TODO:    Attributes - add argument and description to function comment
 382 // TODO:    EFI_INVALID_PARAMETER - add return value to function comment
 383 {
 384   CPU_ARCH_PROTOCOL_PRIVATE *Private;
 385
 386   //
 387   // Check for invalid parameter for Spec conformance
 388   //
 389   if (Length == 0) {
 390     return EFI_INVALID_PARAMETER;
 391   }
 392
 393   //
 394   // Do nothing for Nt32 emulation
 395   //
 396   Private = CPU_ARCH_PROTOCOL_PRIVATE_DATA_FROM_THIS (This);
 397   return EFI_UNSUPPORTED;
 398 }
 399
 400
 401 VOID
 402 CpuUpdateDataHub (
 403   VOID
 404   )
 405 /*++
 406
 407 Routine Description:
 408   This function will log processor version and frequency data to data hub.
 409
 410 Arguments:
 411   Event        - Event whose notification function is being invoked.
 412   Context      - Pointer to the notification function's context.
 413
 414 Returns:
 415   None.
 416
 417 --*/
 418 {
 419   EFI_STATUS                  Status;
 420   EFI_CPU_DATA_RECORD_BUFFER  RecordBuffer;
 421   UINT32                      HeaderSize;
 422   UINT32                      TotalSize;
 423   EFI_DATA_HUB_PROTOCOL       *DataHub;
 424   EFI_HII_PROTOCOL            *Hii;
 425   EFI_HII_HANDLE              StringHandle;
 426   EFI_HII_PACKAGES            *PackageList;
 427   STRING_REF                  Token;
 428
 429
 430   //
 431   // Locate DataHub protocol.
 432   //
 433   Status = gBS->LocateProtocol (&gEfiDataHubProtocolGuid, NULL, &DataHub);
 434   if (EFI_ERROR (Status)) {
 435     return;
 436   }
 437
 438   //
 439   // Locate DataHub protocol.
 440   //
 441   Status = gBS->LocateProtocol (&gEfiHiiProtocolGuid, NULL, &Hii);
 442   if (EFI_ERROR (Status)) {
 443     return;
 444   }
 445
 446   //
 447   // Initialize data record header
 448   //
 449   mCpuDataRecordHeader.Instance = 1;
 450   HeaderSize                    = sizeof (EFI_SUBCLASS_TYPE1_HEADER);
 451
 452   RecordBuffer.Raw              = AllocatePool (HeaderSize + EFI_CPU_DATA_MAXIMUM_LENGTH);
 453   if (RecordBuffer.Raw == NULL) {
 454     return ;
 455   }
 456
 457   //
 458   // Initialize strings to HII database
 459   //
 460   PackageList = PreparePackages (1, &gEfiProcessorProducerGuid, CpuStrings);
 461   Status      = Hii->NewPack (Hii, PackageList, &StringHandle);
 462   ASSERT (!EFI_ERROR (Status));
 463   FreePool (PackageList);
 464
 465   CopyMem (RecordBuffer.Raw, &mCpuDataRecordHeader, HeaderSize);
 466
 467   //
 468   // Store processor version data record to data hub
 469   //
 470   Token = 0;
 471   Status = Hii->NewString (Hii, NULL, StringHandle, &Token, (CHAR16 *)PcdGetPtr (PcdWinNtCpuModel));
 472   ASSERT (!EFI_ERROR (Status));
 473
 474   RecordBuffer.DataRecord->DataRecordHeader.RecordType      = ProcessorVersionRecordType;
 475   RecordBuffer.DataRecord->VariableRecord.ProcessorVersion  = Token;
 476   TotalSize = HeaderSize + sizeof (EFI_PROCESSOR_VERSION_DATA);
 477
 478   Status = DataHub->LogData (
 479                       DataHub,
 480                       &gEfiProcessorSubClassGuid,
 481                       &gEfiProcessorProducerGuid,
 482                       EFI_DATA_RECORD_CLASS_DATA,
 483                       RecordBuffer.Raw,
 484                       TotalSize
 485                       );
 486
 487   //
 488   // Store CPU frequency data record to data hub
 489   //
 490   RecordBuffer.DataRecord->DataRecordHeader.RecordType                    = ProcessorCoreFrequencyRecordType;
 491   RecordBuffer.DataRecord->VariableRecord.ProcessorCoreFrequency.Value    = (UINT16) StrDecimalToUintn (PcdGetPtr (PcdWinNtCpuSpeed));
 492   RecordBuffer.DataRecord->VariableRecord.ProcessorCoreFrequency.Exponent = 6;
 493   TotalSize = HeaderSize + sizeof (EFI_PROCESSOR_CORE_FREQUENCY_DATA);
 494
 495   Status = DataHub->LogData (
 496                       DataHub,
 497                       &gEfiProcessorSubClassGuid,
 498                       &gEfiProcessorProducerGuid,
 499                       EFI_DATA_RECORD_CLASS_DATA,
 500                       RecordBuffer.Raw,
 501                       TotalSize
 502                       );
 503
 504   FreePool (RecordBuffer.Raw);
 505 }
 506
 507
 508
 509 EFI_STATUS
 510 EFIAPI
 511 InitializeCpu (
 512   IN EFI_HANDLE        ImageHandle,
 513   IN EFI_SYSTEM_TABLE  *SystemTable
 514   )
 515 /*++
 516
 517 Routine Description:
 518
 519   Initialize the state information for the CPU Architectural Protocol
 520
 521 Arguments:
 522
 523   ImageHandle of the loaded driver
 524   Pointer to the System Table
 525
 526 Returns:
 527
 528   Status
 529
 530   EFI_SUCCESS           - protocol instance can be published
 531   EFI_OUT_OF_RESOURCES  - cannot allocate protocol data structure
 532   EFI_DEVICE_ERROR      - cannot create the thread
 533
 534 --*/
 535 {
 536   EFI_STATUS                Status;
 537
 538   CpuUpdateDataHub ();
 539
 540   Status = gBS->InstallMultipleProtocolInterfaces (
 541                   &mCpuTemplate.Handle,
 542                   &gEfiCpuArchProtocolGuid,   &mCpuTemplate.Cpu,
 543                   &gEfiCpuIoProtocolGuid,     &mCpuTemplate.CpuIo,
 544                   NULL
 545                   );
 546   ASSERT_EFI_ERROR (Status);
 547
 548   return Status;
 549 }
 550
 551