SecurityPkg/Library/Tpm2DeviceLibDTpm/Tpm2Tis.c

   1 /** @file
   2   TIS (TPM Interface Specification) functions used by dTPM2.0 library.
   3
   4 Copyright (c) 2013 - 2016, Intel Corporation. All rights reserved.<BR>
   5 (C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include <IndustryStandard/Tpm20.h>
  17
  18 #include <Library/BaseLib.h>
  19 #include <Library/BaseMemoryLib.h>
  20 #include <Library/IoLib.h>
  21 #include <Library/TimerLib.h>
  22 #include <Library/DebugLib.h>
  23 #include <Library/Tpm2DeviceLib.h>
  24 #include <Library/PcdLib.h>
  25
  26 #include <IndustryStandard/TpmTis.h>
  27
  28 #define TIS_TIMEOUT_MAX             (90000 * 1000)  // 90s
  29
  30 //
  31 // Max TPM command/reponse length
  32 //
  33 #define TPMCMDBUFLENGTH             0x500
  34
  35 /**
  36   Check whether TPM chip exist.
  37
  38   @param[in] TisReg  Pointer to TIS register.
  39
  40   @retval    TRUE    TPM chip exists.
  41   @retval    FALSE   TPM chip is not found.
  42 **/
  43 BOOLEAN
  44 TisPcPresenceCheck (
  45   IN      TIS_PC_REGISTERS_PTR      TisReg
  46   )
  47 {
  48   UINT8                             RegRead;
  49
  50   RegRead = MmioRead8 ((UINTN)&TisReg->Access);
  51   return (BOOLEAN)(RegRead != (UINT8)-1);
  52 }
  53
  54 /**
  55   Check whether the value of a TPM chip register satisfies the input BIT setting.
  56
  57   @param[in]  Register     Address port of register to be checked.
  58   @param[in]  BitSet       Check these data bits are set.
  59   @param[in]  BitClear     Check these data bits are clear.
  60   @param[in]  TimeOut      The max wait time (unit MicroSecond) when checking register.
  61
  62   @retval     EFI_SUCCESS  The register satisfies the check bit.
  63   @retval     EFI_TIMEOUT  The register can't run into the expected status in time.
  64 **/
  65 EFI_STATUS
  66 TisPcWaitRegisterBits (
  67   IN      UINT8                     *Register,
  68   IN      UINT8                     BitSet,
  69   IN      UINT8                     BitClear,
  70   IN      UINT32                    TimeOut
  71   )
  72 {
  73   UINT8                             RegRead;
  74   UINT32                            WaitTime;
  75
  76   for (WaitTime = 0; WaitTime < TimeOut; WaitTime += 30){
  77     RegRead = MmioRead8 ((UINTN)Register);
  78     if ((RegRead & BitSet) == BitSet && (RegRead & BitClear) == 0)
  79       return EFI_SUCCESS;
  80     MicroSecondDelay (30);
  81   }
  82   return EFI_TIMEOUT;
  83 }
  84
  85 /**
  86   Get BurstCount by reading the burstCount field of a TIS regiger
  87   in the time of default TIS_TIMEOUT_D.
  88
  89   @param[in]  TisReg                Pointer to TIS register.
  90   @param[out] BurstCount            Pointer to a buffer to store the got BurstConut.
  91
  92   @retval     EFI_SUCCESS           Get BurstCount.
  93   @retval     EFI_INVALID_PARAMETER TisReg is NULL or BurstCount is NULL.
  94   @retval     EFI_TIMEOUT           BurstCount can't be got in time.
  95 **/
  96 EFI_STATUS
  97 TisPcReadBurstCount (
  98   IN      TIS_PC_REGISTERS_PTR      TisReg,
  99      OUT  UINT16                    *BurstCount
 100   )
 101 {
 102   UINT32                            WaitTime;
 103   UINT8                             DataByte0;
 104   UINT8                             DataByte1;
 105
 106   if (BurstCount == NULL || TisReg == NULL) {
 107     return EFI_INVALID_PARAMETER;
 108   }
 109
 110   WaitTime = 0;
 111   do {
 112     //
 113     // TIS_PC_REGISTERS_PTR->burstCount is UINT16, but it is not 2bytes aligned,
 114     // so it needs to use MmioRead8 to read two times
 115     //
 116     DataByte0   = MmioRead8 ((UINTN)&TisReg->BurstCount);
 117     DataByte1   = MmioRead8 ((UINTN)&TisReg->BurstCount + 1);
 118     *BurstCount = (UINT16)((DataByte1 << 8) + DataByte0);
 119     if (*BurstCount != 0) {
 120       return EFI_SUCCESS;
 121     }
 122     MicroSecondDelay (30);
 123     WaitTime += 30;
 124   } while (WaitTime < TIS_TIMEOUT_D);
 125
 126   return EFI_TIMEOUT;
 127 }
 128
 129 /**
 130   Set TPM chip to ready state by sending ready command TIS_PC_STS_READY
 131   to Status Register in time.
 132
 133   @param[in] TisReg                Pointer to TIS register.
 134
 135   @retval    EFI_SUCCESS           TPM chip enters into ready state.
 136   @retval    EFI_INVALID_PARAMETER TisReg is NULL.
 137   @retval    EFI_TIMEOUT           TPM chip can't be set to ready state in time.
 138 **/
 139 EFI_STATUS
 140 TisPcPrepareCommand (
 141   IN      TIS_PC_REGISTERS_PTR      TisReg
 142   )
 143 {
 144   EFI_STATUS                        Status;
 145
 146   if (TisReg == NULL) {
 147     return EFI_INVALID_PARAMETER;
 148   }
 149
 150   MmioWrite8((UINTN)&TisReg->Status, TIS_PC_STS_READY);
 151   Status = TisPcWaitRegisterBits (
 152              &TisReg->Status,
 153              TIS_PC_STS_READY,
 154              0,
 155              TIS_TIMEOUT_B
 156              );
 157   return Status;
 158 }
 159
 160 /**
 161   Get the control of TPM chip by sending requestUse command TIS_PC_ACC_RQUUSE
 162   to ACCESS Register in the time of default TIS_TIMEOUT_A.
 163
 164   @param[in] TisReg                Pointer to TIS register.
 165
 166   @retval    EFI_SUCCESS           Get the control of TPM chip.
 167   @retval    EFI_INVALID_PARAMETER TisReg is NULL.
 168   @retval    EFI_NOT_FOUND         TPM chip doesn't exit.
 169   @retval    EFI_TIMEOUT           Can't get the TPM control in time.
 170 **/
 171 EFI_STATUS
 172 TisPcRequestUseTpm (
 173   IN      TIS_PC_REGISTERS_PTR      TisReg
 174   )
 175 {
 176   EFI_STATUS                        Status;
 177
 178   if (TisReg == NULL) {
 179     return EFI_INVALID_PARAMETER;
 180   }
 181
 182   if (!TisPcPresenceCheck (TisReg)) {
 183     return EFI_NOT_FOUND;
 184   }
 185
 186   MmioWrite8((UINTN)&TisReg->Access, TIS_PC_ACC_RQUUSE);
 187   Status = TisPcWaitRegisterBits (
 188              &TisReg->Access,
 189              (UINT8)(TIS_PC_ACC_ACTIVE |TIS_PC_VALID),
 190              0,
 191              TIS_TIMEOUT_A
 192              );
 193   return Status;
 194 }
 195
 196 /**
 197   Send a command to TPM for execution and return response data.
 198
 199   @param[in]      TisReg        TPM register space base address.
 200   @param[in]      BufferIn      Buffer for command data.
 201   @param[in]      SizeIn        Size of command data.
 202   @param[in, out] BufferOut     Buffer for response data.
 203   @param[in, out] SizeOut       Size of response data.
 204
 205   @retval EFI_SUCCESS           Operation completed successfully.
 206   @retval EFI_BUFFER_TOO_SMALL  Response data buffer is too small.
 207   @retval EFI_DEVICE_ERROR      Unexpected device behavior.
 208   @retval EFI_UNSUPPORTED       Unsupported TPM version
 209
 210 **/
 211 EFI_STATUS
 212 Tpm2TisTpmCommand (
 213   IN     TIS_PC_REGISTERS_PTR       TisReg,
 214   IN     UINT8                      *BufferIn,
 215   IN     UINT32                     SizeIn,
 216   IN OUT UINT8                      *BufferOut,
 217   IN OUT UINT32                     *SizeOut
 218   )
 219 {
 220   EFI_STATUS                        Status;
 221   UINT16                            BurstCount;
 222   UINT32                            Index;
 223   UINT32                            TpmOutSize;
 224   UINT16                            Data16;
 225   UINT32                            Data32;
 226
 227   DEBUG_CODE (
 228     UINTN  DebugSize;
 229
 230     DEBUG ((EFI_D_VERBOSE, "Tpm2TisTpmCommand Send - "));
 231     if (SizeIn > 0x100) {
 232       DebugSize = 0x40;
 233     } else {
 234       DebugSize = SizeIn;
 235     }
 236     for (Index = 0; Index < DebugSize; Index++) {
 237       DEBUG ((EFI_D_VERBOSE, "%02x ", BufferIn[Index]));
 238     }
 239     if (DebugSize != SizeIn) {
 240       DEBUG ((EFI_D_VERBOSE, "...... "));
 241       for (Index = SizeIn - 0x20; Index < SizeIn; Index++) {
 242         DEBUG ((EFI_D_VERBOSE, "%02x ", BufferIn[Index]));
 243       }
 244     }
 245     DEBUG ((EFI_D_VERBOSE, "\n"));
 246   );
 247   TpmOutSize = 0;
 248
 249   Status = TisPcPrepareCommand (TisReg);
 250   if (EFI_ERROR (Status)){
 251     DEBUG ((DEBUG_ERROR, "Tpm2 is not ready for command!\n"));
 252     return EFI_DEVICE_ERROR;
 253   }
 254   //
 255   // Send the command data to Tpm
 256   //
 257   Index = 0;
 258   while (Index < SizeIn) {
 259     Status = TisPcReadBurstCount (TisReg, &BurstCount);
 260     if (EFI_ERROR (Status)) {
 261       Status = EFI_DEVICE_ERROR;
 262       goto Exit;
 263     }
 264     for (; BurstCount > 0 && Index < SizeIn; BurstCount--) {
 265       MmioWrite8((UINTN)&TisReg->DataFifo, *(BufferIn + Index));
 266       Index++;
 267     }
 268   }
 269   //
 270   // Check the Tpm status STS_EXPECT change from 1 to 0
 271   //
 272   Status = TisPcWaitRegisterBits (
 273              &TisReg->Status,
 274              (UINT8) TIS_PC_VALID,
 275              TIS_PC_STS_EXPECT,
 276              TIS_TIMEOUT_C
 277              );
 278   if (EFI_ERROR (Status)) {
 279     DEBUG ((DEBUG_ERROR, "Tpm2 The send buffer too small!\n"));
 280     Status = EFI_BUFFER_TOO_SMALL;
 281     goto Exit;
 282   }
 283   //
 284   // Executed the TPM command and waiting for the response data ready
 285   //
 286   MmioWrite8((UINTN)&TisReg->Status, TIS_PC_STS_GO);
 287
 288   //
 289   // NOTE: That may take many seconds to minutes for certain commands, such as key generation.
 290   //
 291   Status = TisPcWaitRegisterBits (
 292              &TisReg->Status,
 293              (UINT8) (TIS_PC_VALID | TIS_PC_STS_DATA),
 294              0,
 295              TIS_TIMEOUT_MAX
 296              );
 297   if (EFI_ERROR (Status)) {
 298     DEBUG ((DEBUG_ERROR, "Wait for Tpm2 response data time out!!\n"));
 299     Status = EFI_DEVICE_ERROR;
 300     goto Exit;
 301   }
 302   //
 303   // Get response data header
 304   //
 305   Index = 0;
 306   BurstCount = 0;
 307   while (Index < sizeof (TPM2_RESPONSE_HEADER)) {
 308     Status = TisPcReadBurstCount (TisReg, &BurstCount);
 309     if (EFI_ERROR (Status)) {
 310       Status = EFI_DEVICE_ERROR;
 311       goto Exit;
 312     }
 313     for (; BurstCount > 0; BurstCount--) {
 314       *(BufferOut + Index) = MmioRead8 ((UINTN)&TisReg->DataFifo);
 315       Index++;
 316       if (Index == sizeof (TPM2_RESPONSE_HEADER)) break;
 317     }
 318   }
 319   DEBUG_CODE (
 320     DEBUG ((EFI_D_VERBOSE, "Tpm2TisTpmCommand ReceiveHeader - "));
 321     for (Index = 0; Index < sizeof (TPM2_RESPONSE_HEADER); Index++) {
 322       DEBUG ((EFI_D_VERBOSE, "%02x ", BufferOut[Index]));
 323     }
 324     DEBUG ((EFI_D_VERBOSE, "\n"));
 325   );
 326   //
 327   // Check the reponse data header (tag,parasize and returncode )
 328   //
 329   CopyMem (&Data16, BufferOut, sizeof (UINT16));
 330   // TPM2 should not use this RSP_COMMAND
 331   if (SwapBytes16 (Data16) == TPM_ST_RSP_COMMAND) {
 332     DEBUG ((EFI_D_ERROR, "TPM2: TPM_ST_RSP error - %x\n", TPM_ST_RSP_COMMAND));
 333     Status = EFI_UNSUPPORTED;
 334     goto Exit;
 335   }
 336
 337   CopyMem (&Data32, (BufferOut + 2), sizeof (UINT32));
 338   TpmOutSize  = SwapBytes32 (Data32);
 339   if (*SizeOut < TpmOutSize) {
 340     Status = EFI_BUFFER_TOO_SMALL;
 341     goto Exit;
 342   }
 343   *SizeOut = TpmOutSize;
 344   //
 345   // Continue reading the remaining data
 346   //
 347   while ( Index < TpmOutSize ) {
 348     for (; BurstCount > 0; BurstCount--) {
 349       *(BufferOut + Index) = MmioRead8 ((UINTN)&TisReg->DataFifo);
 350       Index++;
 351       if (Index == TpmOutSize) {
 352         Status = EFI_SUCCESS;
 353         goto Exit;
 354       }
 355     }
 356     Status = TisPcReadBurstCount (TisReg, &BurstCount);
 357     if (EFI_ERROR (Status)) {
 358       Status = EFI_DEVICE_ERROR;
 359       goto Exit;
 360     }
 361   }
 362 Exit:
 363   DEBUG_CODE (
 364     DEBUG ((EFI_D_VERBOSE, "Tpm2TisTpmCommand Receive - "));
 365     for (Index = 0; Index < TpmOutSize; Index++) {
 366       DEBUG ((EFI_D_VERBOSE, "%02x ", BufferOut[Index]));
 367     }
 368     DEBUG ((EFI_D_VERBOSE, "\n"));
 369   );
 370   MmioWrite8((UINTN)&TisReg->Status, TIS_PC_STS_READY);
 371   return Status;
 372 }
 373
 374 /**
 375   This service enables the sending of commands to the TPM2.
 376
 377   @param[in]      InputParameterBlockSize  Size of the TPM2 input parameter block.
 378   @param[in]      InputParameterBlock      Pointer to the TPM2 input parameter block.
 379   @param[in,out]  OutputParameterBlockSize Size of the TPM2 output parameter block.
 380   @param[in]      OutputParameterBlock     Pointer to the TPM2 output parameter block.
 381
 382   @retval EFI_SUCCESS            The command byte stream was successfully sent to the device and a response was successfully received.
 383   @retval EFI_DEVICE_ERROR       The command was not successfully sent to the device or a response was not successfully received from the device.
 384   @retval EFI_BUFFER_TOO_SMALL   The output parameter block is too small.
 385 **/
 386 EFI_STATUS
 387 EFIAPI
 388 DTpm2TisSubmitCommand (
 389   IN UINT32            InputParameterBlockSize,
 390   IN UINT8             *InputParameterBlock,
 391   IN OUT UINT32        *OutputParameterBlockSize,
 392   IN UINT8             *OutputParameterBlock
 393   )
 394 {
 395   return Tpm2TisTpmCommand (
 396            (TIS_PC_REGISTERS_PTR) (UINTN) PcdGet64 (PcdTpmBaseAddress),
 397            InputParameterBlock,
 398            InputParameterBlockSize,
 399            OutputParameterBlock,
 400            OutputParameterBlockSize
 401            );
 402 }
 403
 404 /**
 405   This service requests use TPM2.
 406
 407   @retval EFI_SUCCESS      Get the control of TPM2 chip.
 408   @retval EFI_NOT_FOUND    TPM2 not found.
 409   @retval EFI_DEVICE_ERROR Unexpected device behavior.
 410 **/
 411 EFI_STATUS
 412 EFIAPI
 413 DTpm2TisRequestUseTpm (
 414   VOID
 415   )
 416 {
 417   return TisPcRequestUseTpm ((TIS_PC_REGISTERS_PTR) (UINTN) PcdGet64 (PcdTpmBaseAddress));
 418 }