NetworkPkg: Fix incorrect unicode string of the AKM/Cipher Suite

REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3813

The size of buffer should be 3 CHAR16 for Null-terminated Unicode
string.
The first char is the AKM/Cipher Suite number, the second char is ' ',
the third char is '\0'.

Cc: Maciej Rabeda <maciej.rabeda@linux.intel.com>
Cc: Fu Siyuan <siyuan.fu@intel.com>
Cc: Wu Jiaxin <jiaxin.wu@intel.com>
Signed-off-by: Heng Luo <heng.luo@intel.com>
Reviewed-by: Maciej Rabeda <maciej.rabeda@linux.intel.com>

.azurepipelines/ReadMe.md

@@ -0,0 +1,50 @@
+# Azure DevOps Pipelines
+
+These yml files are used to provide CI builds using the Azure DevOps Pipeline Service.
+Most of the CI leverages edk2-pytools to support cross platform building and execution.
+
+## Core CI
+
+Focused on building and testing all packages in Edk2 without an actual target platform.
+
+See `.pytools/ReadMe.py` for more details
+
+## Platform CI
+
+Focused on building a single target platform and confirming functionality on that platform.
+
+## Conventions
+
+* Files extension should be *.yml.  *.yaml is also supported but in Edk2 we use those for our package configuration.
+* Platform CI files should be in the `<PlatformPkg>/.azurepipelines` folder.
+* Core CI files are in the root folder.
+* Shared templates are in the `templates` folder.
+* Top level CI files should be named `<host os>-<tool_chain_tag>.yml`
+
+## Links
+
+* Basic Azure Landing Site - https://docs.microsoft.com/en-us/azure/devops/pipelines/?view=azure-devops
+* Pipeline jobs - https://docs.microsoft.com/en-us/azure/devops/pipelines/process/phases?view=azure-devops&tabs=yaml
+* Pipeline yml scheme - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=azure-devops&tabs=schema%2Cparameter-schema
+* Pipeline expression - https://docs.microsoft.com/en-us/azure/devops/pipelines/process/expressions?view=azure-devops
+* PyTools - https://github.com/tianocore/edk2-pytool-extensions and https://github.com/tianocore/edk2-pytool-library
+
+## Lessons Learned
+
+### Templates and parameters
+
+They are great but evil.  If they are used as part of determining the steps of a build they must resolve before the build starts.  They can not use variables set in a yml or determined as part of a matrix.  If they are used in a step then they can be bound late.
+
+### File matching patterns
+
+On Linux this can hang if there are too many files in the search list.
+
+### Templates and file splitting
+
+Suggestion is to do one big yaml file that does what you want for one of your targets.  Then do the second one and find the deltas.  From that you can start to figure out the right split of files, steps, jobs.
+
+### Conditional steps
+
+If you want the step to show up in the log but not run, use a step conditional. This is great when a platform doesn't currently support a feature but you want the builders to know that the features exists and maybe someday it will.
+
+If you want the step to not show up use a template step conditional wrapper.  Beware this will be evaluated early (at build start).  This can hide things not needed on a given OS for example.

.azurepipelines/Ubuntu-GCC5.yml

@@ -0,0 +1,21 @@
+## @file
+# Azure Pipeline build file for a build using ubuntu and GCC5
+#
+# Copyright (c) Microsoft Corporation.
+# Copyright (c) 2020, Hewlett Packard Enterprise Development LP. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+trigger:
+- master
+- stable/*
+pr:
+- master
+- stable/*
+
+jobs:
+- template: templates/pr-gate-build-job.yml
+  parameters:
+    tool_chain_tag: 'GCC5'
+    vm_image: 'ubuntu-latest'
+    arch_list: "IA32,X64,ARM,AARCH64,RISCV64"
+

.azurepipelines/Ubuntu-PatchCheck.yml

@@ -0,0 +1,36 @@
+## @file
+# Azure Pipielines YML file that evalues the patch series in a PR using the
+# python script BaseTools/Scripts/PatchCheck.py.
+#
+# NOTE: This example monitors pull requests against the edk2-ci branch.  Most
+# environments would replace 'edk2-ci' with 'master'.
+#
+# Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+# https://github.com/tianocore
+#
+##
+
+trigger: none
+
+pr:
+- master
+- stable/*
+
+pool:
+  vmImage: 'ubuntu-latest'
+
+steps:
+- checkout: self
+  clean: true
+
+- task: UsePythonVersion@0
+  inputs:
+    versionSpec: '3.7.x'
+    architecture: 'x64'
+
+- script: |
+    git fetch origin $(System.PullRequest.TargetBranch):$(System.PullRequest.TargetBranch)
+    python BaseTools/Scripts/PatchCheck.py $(System.PullRequest.TargetBranch)..$(System.PullRequest.SourceCommitId)
+  displayName: 'Use PatchCheck.py to verify patch series in pull request'

.azurepipelines/Windows-VS2019.yml

@@ -0,0 +1,20 @@
+## @file
+# Azure Pipeline build file for a build using Windows and VS2019
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+trigger:
+- master
+- stable/*
+
+pr:
+- master
+- stable/*
+
+jobs:
+- template: templates/pr-gate-build-job.yml
+  parameters:
+    tool_chain_tag: 'VS2019'
+    vm_image: 'windows-latest'
+    arch_list: "IA32,X64"

.azurepipelines/templates/ReadMe.md

@@ -0,0 +1,59 @@
+# CI Templates
+
+This folder contains azure pipeline yml templates for "Core" and "Platform" Continuous Integration and PR validation.
+
+## Common CI templates
+
+### basetools-build-steps.yml
+
+This template compiles the Edk2 basetools from source.  The steps in this template are
+conditional and will only run if variable `pkg_count` is greater than 0.
+
+It also has two conditional steps only used when the toolchain contains GCC. These two steps
+use `apt` to update the system packages and add those necessary for Edk2 builds.
+
+## Core CI templates
+
+### pr-gate-build-job.yml
+
+This templates contains the jobs and most importantly the matrix of which packages and
+targets to run for Core CI.
+
+### pr-gate-steps.yml
+
+This template is the main Core CI template.  It controls all the steps run and is responsible for most functionality of the Core CI process.  This template sets
+the `pkg_count` variable using the `stuart_pr_eval` tool when the
+build type is "pull request"
+
+### spell-check-prereq-steps.yml
+
+This template installs the node based tools used by the spell checker plugin. The steps
+in this template are conditional and will only run if variable `pkg_count` is greater than 0.
+
+## Platform CI templates
+
+### platform-build-run-steps.yml
+
+This template makes heavy use of pytools to build and run a platform in the Edk2 repo
+
+Also uses basetools-build-steps.yml to compile basetools
+
+#### Special Notes
+
+* For a build type of pull request it will conditionally build if the patches change files that impact the platform.
+  * uses `stuart_pr_eval` to determine impact
+* For manual builds or CI builds it will always build the platform
+* It compiles basetools from source
+* Will use `stuart_build --FlashOnly` to attempt to run the built image if the `Run` parameter is set.
+* See the parameters block for expected configuration options
+* Parameter `extra_install_step` allows the caller to insert extra steps.  This is useful if additional dependencies, tools, or other things need to be installed.  Here is an example of installing qemu on Windows.
+
+    ``` yaml
+    steps:
+    - template: ../../.azurepipelines/templates/build-run-steps.yml
+      parameters:
+        extra_install_step:
+        - powershell: choco install qemu; Write-Host "##vso[task.prependpath]c:\Program Files\qemu"
+          displayName: Install QEMU and Set QEMU on path # friendly name displayed in the UI
+          condition: and(gt(variables.pkg_count, 0), succeeded())
+    ```

.azurepipelines/templates/basetools-build-steps.yml

@@ -0,0 +1,37 @@
+## @file
+# File templates/basetools-build-job.yml
+#
+# template file to build basetools
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+parameters:
+  tool_chain_tag: ''
+
+steps:
+- ${{ if contains(parameters.tool_chain_tag, 'GCC') }}:
+  - bash: sudo apt-get update
+    displayName: Update apt
+    condition: and(gt(variables.pkg_count, 0), succeeded())
+
+  - bash: sudo apt-get install gcc g++ make uuid-dev
+    displayName: Install required tools
+    condition: and(gt(variables.pkg_count, 0), succeeded())
+
+- task: CmdLine@1
+  displayName: Build Base Tools from source
+  inputs:
+    filename: python
+    arguments: BaseTools/Edk2ToolsBuild.py -t ${{ parameters.tool_chain_tag }}
+  condition: and(gt(variables.pkg_count, 0), succeeded())
+
+- task: CopyFiles@2
+  displayName: "Copy base tools build log"
+  inputs:
+    targetFolder: '$(Build.ArtifactStagingDirectory)'
+    SourceFolder: 'BaseTools/BaseToolsBuild'
+    contents: |
+      BASETOOLS_BUILD*.*
+    flattenFolders: true
+  condition: and(gt(variables.pkg_count, 0), succeededOrFailed())

.azurepipelines/templates/platform-build-run-steps.yml

@@ -0,0 +1,140 @@
+
+## @file
+# File steps.yml
+#
+# template file containing the steps to build
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+parameters:
+- name: tool_chain_tag
+  type: string
+  default: ''
+- name: build_pkg
+  type: string
+  default: ''
+- name: build_target
+  type: string
+  default: ''
+- name: build_arch
+  type: string
+  default: ''
+- name: build_file
+  type: string
+  default: ''
+- name: build_flags
+  type: string
+  default: ''
+- name: run_flags
+  type: string
+  default: ''
+
+- name: extra_install_step
+  type: stepList
+  default: []
+
+steps:
+- checkout: self
+  clean: true
+  fetchDepth: 1
+
+- task: UsePythonVersion@0
+  inputs:
+    versionSpec: "3.8.x"
+    architecture: "x64"
+
+- script: pip install -r pip-requirements.txt --upgrade
+  displayName: 'Install/Upgrade pip modules'
+
+# Set default
+- bash: echo "##vso[task.setvariable variable=pkg_count]${{ 1 }}"
+
+# Fetch the target branch so that pr_eval can diff them.
+# Seems like azure pipelines/github changed checkout process in nov 2020.
+- script: git fetch origin $(System.PullRequest.targetBranch)
+  displayName: fetch target branch
+  condition: eq(variables['Build.Reason'], 'PullRequest')
+
+# trim the package list if this is a PR
+- task: CmdLine@1
+  displayName: Check if ${{ parameters.build_pkg }} need testing
+  inputs:
+    filename: stuart_pr_eval
+    arguments: -c ${{ parameters.build_file }} -t ${{ parameters.build_target}} -a ${{ parameters.build_arch}} --pr-target origin/$(System.PullRequest.targetBranch) --output-count-format-string "##vso[task.setvariable variable=pkg_count;isOutpout=true]{pkgcount}"
+  condition: eq(variables['Build.Reason'], 'PullRequest')
+
+ # Setup repo
+- task: CmdLine@1
+  displayName: Setup
+  inputs:
+    filename: stuart_setup
+    arguments: -c ${{ parameters.build_file }} TOOL_CHAIN_TAG=${{ parameters.tool_chain_tag}} -t ${{ parameters.build_target}} -a ${{ parameters.build_arch}} ${{ parameters.build_flags}}
+  condition: and(gt(variables.pkg_count, 0), succeeded())
+
+# Stuart Update
+- task: CmdLine@1
+  displayName: Update
+  inputs:
+    filename: stuart_update
+    arguments: -c ${{ parameters.build_file }} TOOL_CHAIN_TAG=${{ parameters.tool_chain_tag}} -t ${{ parameters.build_target}} -a ${{ parameters.build_arch}} ${{ parameters.build_flags}}
+  condition: and(gt(variables.pkg_count, 0), succeeded())
+
+# build basetools
+#   do this after setup and update so that code base dependencies
+#   are all resolved.
+- template: basetools-build-steps.yml
+  parameters:
+    tool_chain_tag: ${{ parameters.tool_chain_tag }}
+
+# Potential Extra steps
+- ${{ parameters.extra_install_step }}
+
+# Build
+- task: CmdLine@1
+  displayName: Build
+  inputs:
+    filename: stuart_build
+    arguments: -c ${{ parameters.build_file }} TOOL_CHAIN_TAG=${{ parameters.tool_chain_tag}} TARGET=${{ parameters.build_target}} -a ${{ parameters.build_arch}} ${{ parameters.build_flags}}
+  condition: and(gt(variables.pkg_count, 0), succeeded())
+
+# Run
+- task: CmdLine@1
+  displayName: Run to shell
+  inputs:
+    filename: stuart_build
+    arguments: -c ${{ parameters.build_file }} TOOL_CHAIN_TAG=${{ parameters.tool_chain_tag}} TARGET=${{ parameters.build_target}} -a ${{ parameters.build_arch}} ${{ parameters.build_flags}} ${{ parameters.run_flags }} --FlashOnly
+  condition: and(and(gt(variables.pkg_count, 0), succeeded()), eq(variables['Run'], true))
+  timeoutInMinutes: 1
+
+# Copy the build logs to the artifact staging directory
+- task: CopyFiles@2
+  displayName: "Copy build logs"
+  inputs:
+    targetFolder: "$(Build.ArtifactStagingDirectory)"
+    SourceFolder: "Build"
+    contents: |
+      BUILDLOG_*.txt
+      BUILDLOG_*.md
+      CI_*.txt
+      CI_*.md
+      CISETUP.txt
+      SETUPLOG.txt
+      UPDATE_LOG.txt
+      PREVALLOG.txt
+      TestSuites.xml
+      **/BUILD_TOOLS_REPORT.html
+      **/OVERRIDELOG.TXT
+      BASETOOLS_BUILD*.*
+    flattenFolders: true
+  condition: succeededOrFailed()
+
+# Publish build artifacts to Azure Artifacts/TFS or a file share
+- task: PublishBuildArtifacts@1
+  continueOnError: true
+  displayName: "Publish build logs"
+  inputs:
+    pathtoPublish: "$(Build.ArtifactStagingDirectory)"
+    artifactName: "Build Logs $(System.JobName)"
+  condition: succeededOrFailed()

.azurepipelines/templates/pr-gate-build-job.yml

@@ -0,0 +1,72 @@
+## @file
+# File templates/pr-gate-build-job.yml
+#
+# template file used to build supported packages.
+#
+# Copyright (c) Microsoft Corporation.
+# Copyright (c) 2020 - 2021, ARM Limited. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+parameters:
+  tool_chain_tag: ''
+  vm_image: ''
+  arch_list: ''
+
+# Build step
+jobs:
+
+- job: Build_${{ parameters.tool_chain_tag }}
+  timeoutInMinutes: 120
+  #Use matrix to speed up the build process
+  strategy:
+    matrix:
+      TARGET_ARM_ARMPLATFORM:
+        Build.Pkgs: 'ArmPkg,ArmPlatformPkg'
+        Build.Targets: 'DEBUG,RELEASE,NO-TARGET,NOOPT'
+      TARGET_MDE_CPU:
+        Build.Pkgs: 'MdePkg,UefiCpuPkg'
+        Build.Targets: 'DEBUG,RELEASE,NO-TARGET,NOOPT'
+      TARGET_MDEMODULE_DEBUG:
+        Build.Pkgs: 'MdeModulePkg'
+        Build.Targets: 'DEBUG,NOOPT'
+      TARGET_MDEMODULE_RELEASE:
+        Build.Pkgs: 'MdeModulePkg'
+        Build.Targets: 'RELEASE,NO-TARGET'
+      TARGET_NETWORK:
+        Build.Pkgs: 'NetworkPkg,RedfishPkg'
+        Build.Targets: 'DEBUG,RELEASE,NO-TARGET'
+      TARGET_OTHER:
+        Build.Pkgs: 'PcAtChipsetPkg,ShellPkg,StandaloneMmPkg'
+        Build.Targets: 'DEBUG,RELEASE,NO-TARGET'
+      TARGET_FMP_FAT_TEST:
+        Build.Pkgs: 'FmpDevicePkg,FatPkg,UnitTestFrameworkPkg,DynamicTablesPkg'
+        Build.Targets: 'DEBUG,RELEASE,NO-TARGET,NOOPT'
+      TARGET_CRYPTO:
+        Build.Pkgs: 'CryptoPkg'
+        Build.Targets: 'DEBUG,RELEASE,NO-TARGET,NOOPT'
+      TARGET_SECURITY:
+        Build.Pkgs: 'SecurityPkg'
+        Build.Targets: 'DEBUG,RELEASE,NO-TARGET'
+      TARGET_UEFIPAYLOAD:
+        Build.Pkgs: 'UefiPayloadPkg'
+        Build.Targets: 'DEBUG,RELEASE,NO-TARGET'
+      TARGET_PLATFORMS:
+        # For Platforms only check code. Leave it to Platform CI
+        # to build them.
+        Build.Pkgs: 'ArmVirtPkg,EmulatorPkg,OvmfPkg'
+        Build.Targets: 'NO-TARGET'
+
+  workspace:
+    clean: all
+
+  pool:
+    vmImage: ${{ parameters.vm_image }}
+
+  steps:
+  - template: pr-gate-steps.yml
+    parameters:
+      tool_chain_tag: ${{ parameters.tool_chain_tag }}
+      build_pkgs: $(Build.Pkgs)
+      build_targets: $(Build.Targets)
+      build_archs: ${{ parameters.arch_list }}

.azurepipelines/templates/pr-gate-steps.yml

@@ -0,0 +1,138 @@
+## @file
+# File templates/pr-gate-steps.yml
+#
+# template file containing the steps to build
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+parameters:
+  tool_chain_tag: ''
+  build_pkgs: ''
+  build_targets: ''
+  build_archs: ''
+
+steps:
+- checkout: self
+  clean: true
+  fetchDepth: 1
+
+- task: UsePythonVersion@0
+  inputs:
+    versionSpec: '3.8.x'
+    architecture: 'x64'
+
+- script: pip install -r pip-requirements.txt --upgrade
+  displayName: 'Install/Upgrade pip modules'
+
+# Set default
+- bash: |
+    echo "##vso[task.setvariable variable=pkgs_to_build]${{ parameters.build_pkgs }}"
+    echo "##vso[task.setvariable variable=pkg_count]${{ 1 }}"
+
+# Fetch the target branch so that pr_eval can diff them.
+# Seems like azure pipelines/github changed checkout process in nov 2020.
+- script: git fetch origin $(System.PullRequest.targetBranch)
+  displayName: fetch target branch
+  condition: eq(variables['Build.Reason'], 'PullRequest')
+
+# trim the package list if this is a PR
+- task: CmdLine@1
+  displayName: Check if ${{ parameters.build_pkgs }} need testing
+  inputs:
+    filename: stuart_pr_eval
+    arguments: -c .pytool/CISettings.py -p ${{ parameters.build_pkgs }} --pr-target origin/$(System.PullRequest.targetBranch) --output-csv-format-string "##vso[task.setvariable variable=pkgs_to_build;isOutpout=true]{pkgcsv}" --output-count-format-string "##vso[task.setvariable variable=pkg_count;isOutpout=true]{pkgcount}"
+  condition: eq(variables['Build.Reason'], 'PullRequest')
+
+# install spell check prereqs
+- template: spell-check-prereq-steps.yml
+
+# Build repo
+- task: CmdLine@1
+  displayName: Setup ${{ parameters.build_pkgs }} ${{ parameters.build_archs}}
+  inputs:
+    filename: stuart_setup
+    arguments: -c .pytool/CISettings.py -p $(pkgs_to_build) -t ${{ parameters.build_targets}} -a ${{ parameters.build_archs}} TOOL_CHAIN_TAG=${{ parameters.tool_chain_tag}}
+  condition: and(gt(variables.pkg_count, 0), succeeded())
+
+- task: CmdLine@1
+  displayName: Update ${{ parameters.build_pkgs }} ${{ parameters.build_archs}}
+  inputs:
+    filename: stuart_update
+    arguments: -c .pytool/CISettings.py -p $(pkgs_to_build) -t ${{ parameters.build_targets}} -a ${{ parameters.build_archs}} TOOL_CHAIN_TAG=${{ parameters.tool_chain_tag}}
+  condition: and(gt(variables.pkg_count, 0), succeeded())
+
+# build basetools
+#   do this after setup and update so that code base dependencies
+#   are all resolved.
+- template: basetools-build-steps.yml
+  parameters:
+    tool_chain_tag: ${{ parameters.tool_chain_tag }}
+
+- task: CmdLine@1
+  displayName: Build and Test ${{ parameters.build_pkgs }} ${{ parameters.build_archs}}
+  inputs:
+    filename: stuart_ci_build
+    arguments: -c .pytool/CISettings.py -p $(pkgs_to_build) -t ${{ parameters.build_targets}} -a ${{ parameters.build_archs}} TOOL_CHAIN_TAG=${{ parameters.tool_chain_tag}}
+  condition: and(gt(variables.pkg_count, 0), succeeded())
+
+# Publish Test Results to Azure Pipelines/TFS
+- task: PublishTestResults@2
+  displayName: 'Publish junit test results'
+  continueOnError: true
+  condition: and( succeededOrFailed(),gt(variables.pkg_count, 0))
+  inputs:
+    testResultsFormat: 'JUnit' # Options: JUnit, NUnit, VSTest, xUnit
+    testResultsFiles: 'Build/TestSuites.xml'
+    #searchFolder: '$(System.DefaultWorkingDirectory)' # Optional
+    mergeTestResults: true # Optional
+    testRunTitle: $(System.JobName) # Optional
+    #buildPlatform: # Optional
+    #buildConfiguration: # Optional
+    publishRunAttachments: true # Optional
+
+# Publish Test Results to Azure Pipelines/TFS
+- task: PublishTestResults@2
+  displayName: 'Publish host based test results for $(System.JobName)'
+  continueOnError: true
+  condition: and( succeededOrFailed(), gt(variables.pkg_count, 0))
+  inputs:
+    testResultsFormat: 'JUnit' # Options: JUnit, NUnit, VSTest, xUnit
+    testResultsFiles: 'Build/**/*.result.xml'
+    #searchFolder: '$(System.DefaultWorkingDirectory)' # Optional
+    mergeTestResults: false # Optional
+    testRunTitle: ${{ parameters.build_pkgs }} # Optional
+    #buildPlatform: # Optional
+    #buildConfiguration: # Optional
+    publishRunAttachments: true # Optional
+
+# Copy the build logs to the artifact staging directory
+- task: CopyFiles@2
+  displayName: "Copy build logs"
+  inputs:
+    targetFolder: '$(Build.ArtifactStagingDirectory)'
+    SourceFolder: 'Build'
+    contents: |
+      BUILDLOG_*.txt
+      BUILDLOG_*.md
+      CI_*.txt
+      CI_*.md
+      CISETUP.txt
+      SETUPLOG.txt
+      UPDATE_LOG.txt
+      PREVALLOG.txt
+      TestSuites.xml
+      **/BUILD_TOOLS_REPORT.html
+      **/OVERRIDELOG.TXT
+    flattenFolders: true
+  condition: succeededOrFailed()
+
+# Publish build artifacts to Azure Artifacts/TFS or a file share
+- task: PublishBuildArtifacts@1
+  continueOnError: true
+  displayName: "Publish build logs"
+  inputs:
+    pathtoPublish: '$(Build.ArtifactStagingDirectory)'
+    artifactName: 'Build Logs $(System.JobName)'
+  condition: succeededOrFailed()

.azurepipelines/templates/spell-check-prereq-steps.yml

@@ -0,0 +1,22 @@
+## @file
+# File templates/spell-check-prereq-steps.yml
+#
+# template file used to install spell checking prerequisits
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+parameters:
+  none: ''
+
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: '14.x'
+    #checkLatest: false # Optional
+  condition: and(gt(variables.pkg_count, 0), succeeded())
+
+- script: npm install -g cspell
+  displayName: 'Install cspell npm'
+  condition: and(gt(variables.pkg_count, 0), succeeded())

.gitignore

@@ -1,3 +1,7 @@
 Build/
-tags/
 .DS_Store
+*_extdep/
+*.pyc
+__pycache__/
+tags/
+.vscode/

.gitmodules

@@ -4,3 +4,19 @@
 [submodule "SoftFloat"]
 	path = ArmPkg/Library/ArmSoftFloatLib/berkeley-softfloat-3
 	url = https://github.com/ucb-bar/berkeley-softfloat-3.git
+[submodule "UnitTestFrameworkPkg/Library/CmockaLib/cmocka"]
+	path = UnitTestFrameworkPkg/Library/CmockaLib/cmocka
+	url = https://github.com/tianocore/edk2-cmocka.git
+[submodule "MdeModulePkg/Universal/RegularExpressionDxe/oniguruma"]
+	path = MdeModulePkg/Universal/RegularExpressionDxe/oniguruma
+	url = https://github.com/kkos/oniguruma
+[submodule "MdeModulePkg/Library/BrotliCustomDecompressLib/brotli"]
+	path = MdeModulePkg/Library/BrotliCustomDecompressLib/brotli
+	url = https://github.com/google/brotli
+[submodule "BaseTools/Source/C/BrotliCompress/brotli"]
+	path = BaseTools/Source/C/BrotliCompress/brotli
+	url = https://github.com/google/brotli
+	ignore = untracked
+[submodule "RedfishPkg/Library/JsonLib/jansson"]
+	path = RedfishPkg/Library/JsonLib/jansson
+	url = https://github.com/akheron/jansson

.mailmap

@@ -0,0 +1,81 @@
+#
+# This list is used by git-shortlog to update a few name translations
+# in the git archive to adjust for job changes or incorrect/inconsistent
+# name usage.
+#
+# Please keep this file sorted alphabetically, and email in lowercase.
+# The format used is:
+#
+#   Firstname Lastname <email@domain.tld>
+#
+
+Aaron Li <aaron.li@intel.com> <songpeng.li@intel.com>
+Antoine Cœur <coeur@gmx.fr>
+Antoine Cœur <coeur@gmx.fr> <Coeur@gmx.fr>
+Ard Biesheuvel <ard.biesheuvel@linaro.org> <abiesheuvel@Edk2>
+Ashley DeSimone <ashley.e.desimone@intel.com> <ashdesimone@6f19259b-4bc3-4df7-8a09-765794883524>
+Baraneedharan Anbazhagan <anbazhagan@hp.com>
+Chasel Chiu <chasel.chiu@intel.com>
+Christopher J Zurcher <christopher.j.zurcher@intel.com>
+Eric Dong <eric.dong@intel.com>
+Eric Dong <eric.dong@intel.com> Eric Dong <eirc.dong@intel.com>
+Eric Dong <eric.dong@intel.com> <ydong10@6f19259b-4bc3-4df7-8a09-765794883524>
+Eric Dong <eric.dong@intel.com> <ydong10@Edk2>
+Erik Bjorge <erik.c.bjorge@intel.com> <geekboy15a@6f19259b-4bc3-4df7-8a09-765794883524>
+Eugene Cohen <eugene@nuviainc.com>
+Eugene Cohen <eugene@nuviainc.com> <eugene@hp.com>
+Hao A Wu <hao.a.wu@intel.com>
+Hao A Wu <hao.a.wu@intel.com> <hwu1225@Edk2>
+Hot Tian <hot.tian@intel.com>
+Hot Tian <hot.tian@intel.com> <hhtian@6f19259b-4bc3-4df7-8a09-765794883524>
+Jiewen Yao <jiewen.yao@intel.com>
+Jiewen Yao <jiewen.yao@intel.com> <Jiewen.yao@intel.com>
+Jiewen Yao <jiewen.yao@intel.com> <Jiewen.Yao@intel.com>
+Jiewen Yao <jiewen.yao@intel.com> <jyao1>
+Jiewen Yao <jiewen.yao@intel.com> <jyao1@6f19259b-4bc3-4df7-8a09-765794883524>
+Jiewen Yao <jiewen.yao@intel.com> <jyao1@Edk2>
+Jim Dailey <Jim.Dailey@Dell.com>
+Jim Dailey <Jim.Dailey@Dell.com> <Jim_Dailey@Dell.com>
+Laszlo Ersek <lersek@redhat.com> <lersek@6f19259b-4bc3-4df7-8a09-765794883524>
+Laszlo Ersek <lersek@redhat.com> <lersek@Edk2>
+Liming Gao <gaoliming@byosoft.com.cn>
+Liming Gao <liming.gao@intel.com> <Gao, Liming liming.gao@intel.com>
+Liming Gao <liming.gao@intel.com> <lgao4@6f19259b-4bc3-4df7-8a09-765794883524>
+Liming Gao <liming.gao@intel.com> <lgao4@Edk2>
+Liming Gao <liming.gao@intel.com> <liming.gao@intel.com>
+Maciej Rabeda <maciej.rabeda@intel.com>
+Marc-André Lureau <marcandre.lureau@redhat.com> <marcandre.lureau@redhat.com>
+Marvin Häuser <Marvin.Haeuser@outlook.com>
+Marvin Häuser <Marvin.Haeuser@outlook.com> edk2-devel <edk2-devel-bounces@lists.01.org>
+Marvin Häuser <mhaeuser@outlook.de>
+Matt DeVillier <matt.devillier@gmail.com>
+Maurice Ma <maurice.ma@intel.com>
+Michael Kubacki <michael.a.kubacki@intel.com>
+Michael Kubacki <michael.a.kubacki@intel.com> </o=Intel/ou=External (FYDIBOHF25SPDLT)/cn=Recipients/cn=3c8b0226e75f4ab08d20c151cb7a8a72>
+Ming Tan <ming.tan@intel.com>
+Nikolai Saoukh <nms@otdel-1.org>
+Philippe Mathieu-Daudé <philmd@redhat.com>
+Ray Ni <ray.ni@intel.com>
+Ray Ni <ray.ni@intel.com> <C:/Program Files (x86)/Git/O=Intel/OU=Pacifica02/cn=Recipients/cn=rni2>
+Ray Ni <ray.ni@intel.com> <niruiyu@6f19259b-4bc3-4df7-8a09-765794883524>
+Ray Ni <ray.ni@intel.com> <niruiyu@Edk2>
+Ray Ni <ray.ni@intel.com> <ruiyu.ni@intel.com>
+Ray Ni <ray.ni@intel.com> <Ruiyu.ni@Intel.com>
+Ray Ni <ray.ni@intel.com> <ruyu.ni@intel.com>
+Rebecca Cran <rebecca@bluestop.org>
+Rebecca Cran <rebecca@bsdio.com>
+Samer El-Haj-Mahmoud <samer@elhajmahmoud.com> <elhaj@hpe.com>
+Samer El-Haj-Mahmoud <samer@elhajmahmoud.com> <Samer El-Haj-Mahmoud elhaj@hp.com>
+Shenglei Zhang <shenglei.zhang@intel.com>
+Star Zeng <star.zeng@intel.com>
+Star Zeng <star.zeng@intel.com> <lzeng14@6f19259b-4bc3-4df7-8a09-765794883524>
+Star Zeng <star.zeng@intel.com> <lzeng14@Edk2>
+Tom Lendacky <thomas.lendacky@amd.com>
+Vitaly Cheptsov <vit9696@protonmail.com> Vitaly Cheptsov via Groups.Io <vit9696=protonmail.com@groups.io>
+Vladimir Olovyannikov <vladimir.olovyannikov@broadcom.com> Vladimir Olovyannikov via edk2-devel <edk2-devel@lists.01.org>
+Wei6 Xu <wei6.xu@intel.com>
+Yonghong Zhu <yonghong.zhu@intel.com>
+Yonghong Zhu <yonghong.zhu@intel.com> <yzhu52@Edk2>
+Yu-Chen Lin <yuchenlin@synology.com>
+Zhichao Gao <zhichao.gao@intel.com>
+Zhiguang Liu <zhiguang.liu@intel.com>

.mergify/config.yml

@@ -0,0 +1,50 @@
+## @file
+# Mergify YML file that automatically merges a GitHub pull request against
+# edk2-ci if all of the GitHub branch protections have passed.  It also
+# contains rules to:
+# * auto close branches that are not from an EDK II Maintainer
+# * post a comment on pull requests that have merge conflicts.
+# * post a comment on pull requests that have PatchCheck.py errors.
+#
+# Configuration Notes:
+# * Update the 'base=edk2-ci' statements with the name of the branch to merge
+#   pull requests.
+#
+# * Update the 'status-failure' statement with the name of the name of the Azure
+#   Pipelines Build that performs the EDK II Maintainer check.
+#
+# * This file must be checked into the 'default' branch of a repo.  Copies
+#   of this file on other branches of a repo are ignored by Mergify.
+#
+# Copyright (c) 2019 - 2021, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+# https://github.com/apps/mergify
+# https://doc.mergify.io/
+#
+##
+
+queue_rules:
+  - name: default
+    conditions:
+      - base~=(^main|^master|^stable/)
+      - label=push
+
+pull_request_rules:
+  - name: Automatically merge a PR when all required checks pass and 'push' label is present
+    conditions:
+      - base~=(^main|^master|^stable/)
+      - label=push
+    actions:
+      queue:
+        method: rebase
+        rebase_fallback: none
+        name: default
+
+  - name: Post a comment on a PR that can not be merged due to a merge conflict
+    conditions:
+      - base~=(^main|^master|^stable/)
+      - conflict
+    actions:
+      comment:
+        message: PR can not be merged due to conflict.  Please rebase and resubmit

.pytool/CISettings.py

@@ -0,0 +1,228 @@
+# @file
+#
+# Copyright (c) Microsoft Corporation.
+# Copyright (c) 2020, Hewlett Packard Enterprise Development LP. All rights reserved.<BR>
+# Copyright (c) 2020 - 2021, ARM Limited. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+import os
+import logging
+from edk2toolext.environment import shell_environment
+from edk2toolext.invocables.edk2_ci_build import CiBuildSettingsManager
+from edk2toolext.invocables.edk2_setup import SetupSettingsManager, RequiredSubmodule
+from edk2toolext.invocables.edk2_update import UpdateSettingsManager
+from edk2toolext.invocables.edk2_pr_eval import PrEvalSettingsManager
+from edk2toollib.utility_functions import GetHostInfo
+
+
+class Settings(CiBuildSettingsManager, UpdateSettingsManager, SetupSettingsManager, PrEvalSettingsManager):
+
+    def __init__(self):
+        self.ActualPackages = []
+        self.ActualTargets = []
+        self.ActualArchitectures = []
+        self.ActualToolChainTag = ""
+        self.UseBuiltInBaseTools = None
+        self.ActualScopes = None
+
+    # ####################################################################################### #
+    #                             Extra CmdLine configuration                                 #
+    # ####################################################################################### #
+
+    def AddCommandLineOptions(self, parserObj):
+        group = parserObj.add_mutually_exclusive_group()
+        group.add_argument("-force_piptools", "--fpt", dest="force_piptools", action="store_true", default=False, help="Force the system to use pip tools")
+        group.add_argument("-no_piptools", "--npt", dest="no_piptools", action="store_true", default=False, help="Force the system to not use pip tools")
+
+    def RetrieveCommandLineOptions(self, args):
+        super().RetrieveCommandLineOptions(args)
+        if args.force_piptools:
+            self.UseBuiltInBaseTools = True
+        if args.no_piptools:
+            self.UseBuiltInBaseTools = False
+
+    # ####################################################################################### #
+    #                        Default Support for this Ci Build                                #
+    # ####################################################################################### #
+
+    def GetPackagesSupported(self):
+        ''' return iterable of edk2 packages supported by this build.
+        These should be edk2 workspace relative paths '''
+
+        return ("ArmPkg",
+                "ArmPlatformPkg",
+                "ArmVirtPkg",
+                "DynamicTablesPkg",
+                "EmulatorPkg",
+                "MdePkg",
+                "MdeModulePkg",
+                "NetworkPkg",
+                "PcAtChipsetPkg",
+                "SecurityPkg",
+                "UefiCpuPkg",
+                "FmpDevicePkg",
+                "ShellPkg",
+                "StandaloneMmPkg",
+                "FatPkg",
+                "CryptoPkg",
+                "UnitTestFrameworkPkg",
+                "OvmfPkg",
+                "RedfishPkg",
+                "UefiPayloadPkg"
+                )
+
+    def GetArchitecturesSupported(self):
+        ''' return iterable of edk2 architectures supported by this build '''
+        return (
+                "IA32",
+                "X64",
+                "ARM",
+                "AARCH64",
+                "RISCV64")
+
+    def GetTargetsSupported(self):
+        ''' return iterable of edk2 target tags supported by this build '''
+        return ("DEBUG", "RELEASE", "NO-TARGET", "NOOPT")
+
+    # ####################################################################################### #
+    #                     Verify and Save requested Ci Build Config                           #
+    # ####################################################################################### #
+
+    def SetPackages(self, list_of_requested_packages):
+        ''' Confirm the requested package list is valid and configure SettingsManager
+        to build the requested packages.
+
+        Raise UnsupportedException if a requested_package is not supported
+        '''
+        unsupported = set(list_of_requested_packages) - \
+            set(self.GetPackagesSupported())
+        if(len(unsupported) > 0):
+            logging.critical(
+                "Unsupported Package Requested: " + " ".join(unsupported))
+            raise Exception("Unsupported Package Requested: " +
+                            " ".join(unsupported))
+        self.ActualPackages = list_of_requested_packages
+
+    def SetArchitectures(self, list_of_requested_architectures):
+        ''' Confirm the requests architecture list is valid and configure SettingsManager
+        to run only the requested architectures.
+
+        Raise Exception if a list_of_requested_architectures is not supported
+        '''
+        unsupported = set(list_of_requested_architectures) - \
+            set(self.GetArchitecturesSupported())
+        if(len(unsupported) > 0):
+            logging.critical(
+                "Unsupported Architecture Requested: " + " ".join(unsupported))
+            raise Exception(
+                "Unsupported Architecture Requested: " + " ".join(unsupported))
+        self.ActualArchitectures = list_of_requested_architectures
+
+    def SetTargets(self, list_of_requested_target):
+        ''' Confirm the request target list is valid and configure SettingsManager
+        to run only the requested targets.
+
+        Raise UnsupportedException if a requested_target is not supported
+        '''
+        unsupported = set(list_of_requested_target) - \
+            set(self.GetTargetsSupported())
+        if(len(unsupported) > 0):
+            logging.critical(
+                "Unsupported Targets Requested: " + " ".join(unsupported))
+            raise Exception("Unsupported Targets Requested: " +
+                            " ".join(unsupported))
+        self.ActualTargets = list_of_requested_target
+
+    # ####################################################################################### #
+    #                         Actual Configuration for Ci Build                               #
+    # ####################################################################################### #
+
+    def GetActiveScopes(self):
+        ''' return tuple containing scopes that should be active for this process '''
+        if self.ActualScopes is None:
+            scopes = ("cibuild", "edk2-build", "host-based-test")
+
+            self.ActualToolChainTag = shell_environment.GetBuildVars().GetValue("TOOL_CHAIN_TAG", "")
+
+            is_linux = GetHostInfo().os.upper() == "LINUX"
+
+            if self.UseBuiltInBaseTools is None:
+                is_linux = GetHostInfo().os.upper() == "LINUX"
+                # try and import the pip module for basetools
+                try:
+                    import edk2basetools
+                    self.UseBuiltInBaseTools = True
+                except ImportError:
+                    self.UseBuiltInBaseTools = False
+                    pass
+
+            if self.UseBuiltInBaseTools == True:
+                scopes += ('pipbuild-unix',) if is_linux else ('pipbuild-win',)
+                logging.warning("Using Pip Tools based BaseTools")
+            else:
+                logging.warning("Falling back to using in-tree BaseTools")
+
+            if is_linux and self.ActualToolChainTag.upper().startswith("GCC"):
+                if "AARCH64" in self.ActualArchitectures:
+                    scopes += ("gcc_aarch64_linux",)
+                if "ARM" in self.ActualArchitectures:
+                    scopes += ("gcc_arm_linux",)
+                if "RISCV64" in self.ActualArchitectures:
+                    scopes += ("gcc_riscv64_unknown",)
+            self.ActualScopes = scopes
+        return self.ActualScopes
+
+    def GetRequiredSubmodules(self):
+        ''' return iterable containing RequiredSubmodule objects.
+        If no RequiredSubmodules return an empty iterable
+        '''
+        rs = []
+        rs.append(RequiredSubmodule(
+            "ArmPkg/Library/ArmSoftFloatLib/berkeley-softfloat-3", False))
+        rs.append(RequiredSubmodule(
+            "CryptoPkg/Library/OpensslLib/openssl", False))
+        rs.append(RequiredSubmodule(
+            "UnitTestFrameworkPkg/Library/CmockaLib/cmocka", False))
+        rs.append(RequiredSubmodule(
+            "MdeModulePkg/Universal/RegularExpressionDxe/oniguruma", False))
+        rs.append(RequiredSubmodule(
+            "MdeModulePkg/Library/BrotliCustomDecompressLib/brotli", False))
+        rs.append(RequiredSubmodule(
+            "BaseTools/Source/C/BrotliCompress/brotli", False))
+        rs.append(RequiredSubmodule(
+            "RedfishPkg/Library/JsonLib/jansson", False))
+        return rs
+
+    def GetName(self):
+        return "Edk2"
+
+    def GetDependencies(self):
+        return [
+        ]
+
+    def GetPackagesPath(self):
+        return ()
+
+    def GetWorkspaceRoot(self):
+        ''' get WorkspacePath '''
+        return os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+    def FilterPackagesToTest(self, changedFilesList: list, potentialPackagesList: list) -> list:
+        ''' Filter potential packages to test based on changed files. '''
+        build_these_packages = []
+        possible_packages = potentialPackagesList.copy()
+        for f in changedFilesList:
+            # split each part of path for comparison later
+            nodes = f.split("/")
+
+            # python file change in .pytool folder causes building all
+            if f.endswith(".py") and ".pytool" in nodes:
+                build_these_packages = possible_packages
+                break
+
+            # BaseTools files that might change the build
+            if "BaseTools" in nodes:
+                if os.path.splitext(f) not in [".txt", ".md"]:
+                    build_these_packages = possible_packages
+                    break
+        return build_these_packages

.pytool/Plugin/CharEncodingCheck/CharEncodingCheck.py

@@ -0,0 +1,118 @@
+# @file CharEncodingCheck.py
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+
+import os
+import logging
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toolext.environment.var_dict import VarDict
+
+##
+# map
+##
+EcodingMap = {
+    ".md": 'utf-8',
+    ".dsc": 'utf-8',
+    ".dec": 'utf-8',
+    ".c": 'utf-8',
+    ".h": 'utf-8',
+    ".asm": 'utf-8',
+    ".masm": 'utf-8',
+    ".nasm": 'utf-8',
+    ".s": 'utf-8',
+    ".inf": 'utf-8',
+    ".asl": 'utf-8',
+    ".uni": 'utf-8',
+    ".py": 'utf-8'
+}
+
+
+class CharEncodingCheck(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that scans each file in the code tree and confirms the encoding is correct.
+
+    Configuration options:
+    "CharEncodingCheck": {
+        "IgnoreFiles": []
+    }
+    """
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+            testclassname: a descriptive string for the testcase can include whitespace
+            classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+        """
+        return ("Check for valid file encoding for " + packagename, packagename + ".CharEncodingCheck")
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the ci_build_plugin Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - EnvConfig Object
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        overall_status = 0
+        files_tested = 0
+
+        abs_pkg_path = Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(packagename)
+
+        if abs_pkg_path is None:
+            tc.SetSkipped()
+            tc.LogStdError("No Package folder {0}".format(abs_pkg_path))
+            return 0
+
+        for (ext, enc) in EcodingMap.items():
+            files = self.WalkDirectoryForExtension([ext], abs_pkg_path)
+            files = [Edk2pathObj.GetEdk2RelativePathFromAbsolutePath(x) for x in files]  # make edk2relative path so can process ignores
+
+            if "IgnoreFiles" in pkgconfig:
+                for a in pkgconfig["IgnoreFiles"]:
+                    a = a.replace(os.sep, "/")
+                    try:
+                        tc.LogStdOut("Ignoring File {0}".format(a))
+                        files.remove(a)
+                    except:
+                        tc.LogStdError("CharEncodingCheck.IgnoreInf -> {0} not found in filesystem.  Invalid ignore file".format(a))
+                        logging.info("CharEncodingCheck.IgnoreInf -> {0} not found in filesystem.  Invalid ignore file".format(a))
+
+            files = [Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(x) for x in files]
+            for a in files:
+                files_tested += 1
+                if(self.TestEncodingOk(a, enc)):
+                    logging.debug("File {0} Passed Encoding Check {1}".format(a, enc))
+                else:
+                    tc.LogStdError("Encoding Failure in {0}.  Not {1}".format(a, enc))
+                    overall_status += 1
+
+        tc.LogStdOut("Tested Encoding on {0} files".format(files_tested))
+        if overall_status != 0:
+            tc.SetFailed("CharEncoding {0} Failed.  Errors {1}".format(packagename, overall_status), "CHAR_ENCODING_CHECK_FAILED")
+        else:
+            tc.SetSuccess()
+        return overall_status
+
+    def TestEncodingOk(self, apath, encodingValue):
+        try:
+            with open(apath, "rb") as fobj:
+                fobj.read().decode(encodingValue)
+        except Exception as exp:
+            logging.error("Encoding failure: file: {0} type: {1}".format(apath, encodingValue))
+            logging.debug("EXCEPTION: while processing {1} - {0}".format(exp, apath))
+            return False
+
+        return True

.pytool/Plugin/CharEncodingCheck/CharEncodingCheck_plug_in.yaml

@@ -0,0 +1,11 @@
+## @file
+# CiBuildPlugin used to check char encoding
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "Char Encoding Check Test",
+  "module": "CharEncodingCheck"
+}

.pytool/Plugin/CharEncodingCheck/Readme.md

@@ -0,0 +1,18 @@
+# Character Encoding Check Plugin
+
+This CiBuildPlugin scans all the files in a package to make sure each file is
+correctly encoded and all characters can be read.  Improper encoding causes
+tools to fail in some situations especially in different locals.
+
+## Configuration
+
+The plugin can be configured to ignore certain files.
+
+``` yaml
+"CharEncodingCheck": {
+    "IgnoreFiles": []
+}
+```
+### IgnoreFiles
+
+OPTIONAL List of file to ignore.

.pytool/Plugin/CompilerPlugin/CompilerPlugin.py

@@ -0,0 +1,102 @@
+# @file CompilerPlugin.py
+##
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+import logging
+import os
+import re
+from edk2toollib.uefi.edk2.parsers.dsc_parser import DscParser
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toolext.environment.uefi_build import UefiBuilder
+from edk2toolext import edk2_logging
+from edk2toolext.environment.var_dict import VarDict
+
+
+class CompilerPlugin(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that compiles the package dsc
+    from the package being tested.
+
+    Configuration options:
+    "CompilerPlugin": {
+        "DscPath": "<path to dsc from root of pkg>"
+    }
+    """
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+        """
+        target = environment.GetValue("TARGET")
+        return ("Compile " + packagename + " " + target, packagename + ".Compiler." + target)
+
+    def RunsOnTargetList(self):
+        return ["DEBUG", "RELEASE"]
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the ICiBuildPlugin Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - EnvConfig Object
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        self._env = environment
+
+        # Parse the config for required DscPath element
+        if "DscPath" not in pkgconfig:
+            tc.SetSkipped()
+            tc.LogStdError("DscPath not found in config file.  Nothing to compile.")
+            return -1
+
+        AP = Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(packagename)
+
+        APDSC = os.path.join(AP, pkgconfig["DscPath"].strip())
+        AP_Path = Edk2pathObj.GetEdk2RelativePathFromAbsolutePath(APDSC)
+        if AP is None or AP_Path is None or not os.path.isfile(APDSC):
+            tc.SetSkipped()
+            tc.LogStdError("Package Dsc not found.")
+            return -1
+
+        logging.info("Building {0}".format(AP_Path))
+        self._env.SetValue("ACTIVE_PLATFORM", AP_Path, "Set in Compiler Plugin")
+
+        # Parse DSC to check for SUPPORTED_ARCHITECTURES
+        dp = DscParser()
+        dp.SetBaseAbsPath(Edk2pathObj.WorkspacePath)
+        dp.SetPackagePaths(Edk2pathObj.PackagePathList)
+        dp.ParseFile(AP_Path)
+        if "SUPPORTED_ARCHITECTURES" in dp.LocalVars:
+            SUPPORTED_ARCHITECTURES = dp.LocalVars["SUPPORTED_ARCHITECTURES"].split('|')
+            TARGET_ARCHITECTURES = environment.GetValue("TARGET_ARCH").split(' ')
+
+            # Skip if there is no intersection between SUPPORTED_ARCHITECTURES and TARGET_ARCHITECTURES
+            if len(set(SUPPORTED_ARCHITECTURES) & set(TARGET_ARCHITECTURES)) == 0:
+                tc.SetSkipped()
+                tc.LogStdError("No supported architecutres to build")
+                return -1
+
+        uefiBuilder = UefiBuilder()
+        # do all the steps
+        # WorkSpace, PackagesPath, PInHelper, PInManager
+        ret = uefiBuilder.Go(Edk2pathObj.WorkspacePath, os.pathsep.join(Edk2pathObj.PackagePathList), PLMHelper, PLM)
+        if ret != 0:  # failure:
+            tc.SetFailed("Compile failed for {0}".format(packagename), "Compile_FAILED")
+            tc.LogStdError("{0} Compile failed with error code {1} ".format(AP_Path, ret))
+            return 1
+
+        else:
+            tc.SetSuccess()
+            return 0

.pytool/Plugin/CompilerPlugin/Compiler_plug_in.yaml

@@ -0,0 +1,11 @@
+## @file
+# CiBuildPlugin used to compile each package
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "Compiler Plugin",
+  "module": "CompilerPlugin"
+}

.pytool/Plugin/CompilerPlugin/Readme.md

@@ -0,0 +1,17 @@
+# Compiler Plugin
+
+This CiBuildPlugin compiles the package DSC from the package being tested.
+
+## Configuration
+
+The package relative path of the DSC file to build.
+
+``` yaml
+"CompilerPlugin": {
+    "DscPath": "<path to dsc from root of pkg>"
+}
+```
+
+### DscPath
+
+Package relative path to the DSC file to build.

.pytool/Plugin/DependencyCheck/DependencyCheck.py

@@ -0,0 +1,120 @@
+# @file dependency_check.py
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+import logging
+import os
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toollib.uefi.edk2.parsers.inf_parser import InfParser
+from edk2toolext.environment.var_dict import VarDict
+
+
+class DependencyCheck(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that finds all modules (inf files) in a package and reviews the packages used
+    to confirm they are acceptable.  This is to help enforce layering and identify improper
+    dependencies between packages.
+
+    Configuration options:
+    "DependencyCheck": {
+        "AcceptableDependencies": [], # Package dec files that are allowed in all INFs.  Example: MdePkg/MdePkg.dec
+        "AcceptableDependencies-<MODULE_TYPE>": [], # OPTIONAL Package dependencies for INFs that are HOST_APPLICATION
+        "AcceptableDependencies-HOST_APPLICATION": [], # EXAMPLE Package dependencies for INFs that are HOST_APPLICATION
+        "IgnoreInf": []  # Ignore INF if found in filesystem
+    }
+    """
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+                testclassname: a descriptive string for the testcase can include whitespace
+                classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+        """
+        return ("Test Package Dependencies for modules in " + packagename, packagename + ".DependencyCheck")
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the MuBuild Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - EnvConfig Object
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        overall_status = 0
+
+        # Get current platform
+        abs_pkg_path = Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(packagename)
+
+        # Get INF Files
+        INFFiles = self.WalkDirectoryForExtension([".inf"], abs_pkg_path)
+        INFFiles = [Edk2pathObj.GetEdk2RelativePathFromAbsolutePath(x) for x in INFFiles]  # make edk2relative path so can compare with Ignore List
+
+        # Remove ignored INFs
+        if "IgnoreInf" in pkgconfig:
+            for a in pkgconfig["IgnoreInf"]:
+                a = a.replace(os.sep, "/")  ## convert path sep in case ignore list is bad.  Can't change case
+                try:
+                    INFFiles.remove(a)
+                    tc.LogStdOut("IgnoreInf {0}".format(a))
+                except:
+                    logging.info("DependencyConfig.IgnoreInf -> {0} not found in filesystem.  Invalid ignore file".format(a))
+                    tc.LogStdError("DependencyConfig.IgnoreInf -> {0} not found in filesystem.  Invalid ignore file".format(a))
+
+
+        # Get the AccpetableDependencies list
+        if "AcceptableDependencies" not in pkgconfig:
+            logging.info("DependencyCheck Skipped.  No Acceptable Dependencies defined.")
+            tc.LogStdOut("DependencyCheck Skipped.  No Acceptable Dependencies defined.")
+            tc.SetSkipped()
+            return -1
+
+        # Log dependencies
+        for k in pkgconfig.keys():
+            if k.startswith("AcceptableDependencies"):
+                pkgstring = "\n".join(pkgconfig[k])
+                if ("-" in k):
+                    _, _, mod_type = k.partition("-")
+                    tc.LogStdOut(f"Additional dependencies for MODULE_TYPE {mod_type}:\n {pkgstring}")
+                else:
+                    tc.LogStdOut(f"Acceptable Dependencies:\n {pkgstring}")
+
+        # For each INF file
+        for file in INFFiles:
+            ip = InfParser()
+            logging.debug("Parsing " + file)
+            ip.SetBaseAbsPath(Edk2pathObj.WorkspacePath).SetPackagePaths(Edk2pathObj.PackagePathList).ParseFile(file)
+
+            if("MODULE_TYPE" not in ip.Dict):
+                tc.LogStdOut("Ignoring INF. Missing key for MODULE_TYPE {0}".format(file))
+                continue
+
+            mod_type = ip.Dict["MODULE_TYPE"].upper()
+            for p in ip.PackagesUsed:
+                if p not in pkgconfig["AcceptableDependencies"]:
+                    # If not in the main acceptable dependencies list then check module specific
+                    mod_specific_key = "AcceptableDependencies-" + mod_type
+                    if mod_specific_key in pkgconfig and p in pkgconfig[mod_specific_key]:
+                        continue
+
+                    logging.error("Dependency Check: Invalid Dependency INF: {0} depends on pkg {1}".format(file, p))
+                    tc.LogStdError("Dependency Check: Invalid Dependency INF: {0} depends on pkg {1}".format(file, p))
+                    overall_status += 1
+
+        # If XML object exists, add results
+        if overall_status != 0:
+            tc.SetFailed("Failed with {0} errors".format(overall_status), "DEPENDENCYCHECK_FAILED")
+        else:
+            tc.SetSuccess()
+        return overall_status

.pytool/Plugin/DependencyCheck/DependencyCheck_plug_in.yaml

@@ -0,0 +1,13 @@
+## @file
+# CiBuildPlugin used to check all infs within a package
+# to confirm the packagesdependency are on the configured list of acceptable
+# dependencies.
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "Dependency Check Test",
+  "module": "DependencyCheck"
+}

.pytool/Plugin/DependencyCheck/Readme.md

@@ -0,0 +1,31 @@
+# Depdendency Check Plugin
+
+A CiBuildPlugin that finds all modules (inf files) in a package and reviews the
+packages used to confirm they are acceptable.  This is to help enforce layering
+and identify improper dependencies between packages.
+
+## Configuration
+
+The plugin must be configured with the acceptabe package dependencies for the
+package.
+
+``` yaml
+"DependencyCheck": {
+    "AcceptableDependencies": [],
+    "AcceptableDependencies-<MODULE_TYPE>": [],
+    "IgnoreInf": []
+}
+```
+
+### AcceptableDependencies
+
+Package dec files that are allowed in all INFs.  Example: MdePkg/MdePkg.dec
+
+### AcceptableDependencies-<MODULE_TYPE>
+
+OPTIONAL Package dependencies for INFs that have module type <MODULE_TYPE>.
+Example: AcceptableDependencies-HOST_APPLICATION.
+
+### IgnoreInf
+
+OPTIONAL list of INFs to ignore for this dependency check.

.pytool/Plugin/DscCompleteCheck/DscCompleteCheck.py

@@ -0,0 +1,133 @@
+# @file DscCompleteCheck.py
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+import logging
+import os
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toollib.uefi.edk2.parsers.dsc_parser import DscParser
+from edk2toollib.uefi.edk2.parsers.inf_parser import InfParser
+from edk2toolext.environment.var_dict import VarDict
+
+
+class DscCompleteCheck(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that scans the package dsc file and confirms all modules (inf files) are
+    listed in the components sections.
+
+    Configuration options:
+    "DscCompleteCheck": {
+        "DscPath": "<path to dsc from root of pkg>"
+        "IgnoreInf": []  # Ignore INF if found in filesystem by not dsc
+    }
+    """
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+                testclassname: a descriptive string for the testcase can include whitespace
+                classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+        """
+        return ("Check the " + packagename + " DSC for a being complete", packagename + ".DscCompleteCheck")
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the MuBuild Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - VarDict containing the shell environment Build Vars
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        overall_status = 0
+
+        # Parse the config for required DscPath element
+        if "DscPath" not in pkgconfig:
+            tc.SetSkipped()
+            tc.LogStdError(
+                "DscPath not found in config file.  Nothing to check.")
+            return -1
+
+        abs_pkg_path = Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(
+            packagename)
+        abs_dsc_path = os.path.join(abs_pkg_path, pkgconfig["DscPath"].strip())
+        wsr_dsc_path = Edk2pathObj.GetEdk2RelativePathFromAbsolutePath(
+            abs_dsc_path)
+
+        if abs_dsc_path is None or wsr_dsc_path == "" or not os.path.isfile(abs_dsc_path):
+            tc.SetSkipped()
+            tc.LogStdError("Package Dsc not found")
+            return 0
+
+        # Get INF Files
+        INFFiles = self.WalkDirectoryForExtension([".inf"], abs_pkg_path)
+        INFFiles = [Edk2pathObj.GetEdk2RelativePathFromAbsolutePath(
+            x) for x in INFFiles]  # make edk2relative path so can compare with DSC
+
+        # remove ignores
+
+        if "IgnoreInf" in pkgconfig:
+            for a in pkgconfig["IgnoreInf"]:
+                a = a.replace(os.sep, "/")
+                try:
+                    tc.LogStdOut("Ignoring INF {0}".format(a))
+                    INFFiles.remove(a)
+                except:
+                    tc.LogStdError(
+                        "DscCompleteCheck.IgnoreInf -> {0} not found in filesystem.  Invalid ignore file".format(a))
+                    logging.info(
+                        "DscCompleteCheck.IgnoreInf -> {0} not found in filesystem.  Invalid ignore file".format(a))
+
+        # DSC Parser
+        dp = DscParser()
+        dp.SetBaseAbsPath(Edk2pathObj.WorkspacePath)
+        dp.SetPackagePaths(Edk2pathObj.PackagePathList)
+        dp.SetInputVars(environment.GetAllBuildKeyValues())
+        dp.ParseFile(wsr_dsc_path)
+
+        # Check if INF in component section
+        for INF in INFFiles:
+            if not any(INF.strip() in x for x in dp.ThreeMods) and \
+               not any(INF.strip() in x for x in dp.SixMods) and \
+               not any(INF.strip() in x for x in dp.OtherMods):
+
+                infp = InfParser().SetBaseAbsPath(Edk2pathObj.WorkspacePath)
+                infp.SetPackagePaths(Edk2pathObj.PackagePathList)
+                infp.ParseFile(INF)
+                if("MODULE_TYPE" not in infp.Dict):
+                    tc.LogStdOut(
+                        "Ignoring INF. Missing key for MODULE_TYPE {0}".format(INF))
+                    continue
+
+                if(infp.Dict["MODULE_TYPE"] == "HOST_APPLICATION"):
+                    tc.LogStdOut(
+                        "Ignoring INF.  Module type is HOST_APPLICATION {0}".format(INF))
+                    continue
+
+                if len(infp.SupportedPhases) == 1 and \
+                   "HOST_APPLICATION" in infp.SupportedPhases:
+                    tc.LogStdOut(
+                        "Ignoring Library INF due to only supporting type HOST_APPLICATION {0}".format(INF))
+                    continue
+
+                logging.critical(INF + " not in " + wsr_dsc_path)
+                tc.LogStdError("{0} not in {1}".format(INF, wsr_dsc_path))
+                overall_status = overall_status + 1
+
+        # If XML object exists, add result
+        if overall_status != 0:
+            tc.SetFailed("DscCompleteCheck {0} Failed.  Errors {1}".format(
+                wsr_dsc_path, overall_status), "CHECK_FAILED")
+        else:
+            tc.SetSuccess()
+        return overall_status

.pytool/Plugin/DscCompleteCheck/DscCompleteCheck_plug_in.yaml

@@ -0,0 +1,12 @@
+## @file
+# CiBuildPlugin used to confirm all INFs are listed in
+# the components section of package dsc
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "Dsc Complete Check Test",
+  "module": "DscCompleteCheck"
+}

.pytool/Plugin/DscCompleteCheck/Readme.md

@@ -0,0 +1,32 @@
+# Dsc Complete Check Plugin
+
+This CiBuildPlugin scans all INF files from a package and confirms they are
+listed in the package level DSC file. The test considers it an error if any INF
+does not appear in the `Components` section of the package-level DSC (indicating
+that it would not be built if the package were built). This is critical because
+much of the CI infrastructure assumes that all modules will be listed in the DSC
+and compiled.
+
+This test will ignore INFs in the following cases:
+
+1. When MODULE_TYPE = HOST_APPLICATION
+2. When a Library instance **only** supports the HOST_APPLICATION environment
+
+## Configuration
+
+The plugin has a few configuration options to support the UEFI codebase.
+
+``` yaml
+"DscCompleteCheck": {
+        "DscPath": "",   # Path to dsc from root of package
+        "IgnoreInf": []  # Ignore INF if found in filesystem but not dsc
+    }
+```
+
+### DscPath
+
+Path to DSC to consider platform dsc
+
+### IgnoreInf
+
+Ignore error if Inf file is not listed in DSC file

.pytool/Plugin/EccCheck/EccCheck.py

@@ -0,0 +1,407 @@
+# @file EccCheck.py
+#
+# Copyright (c) 2021, Arm Limited. All rights reserved.<BR>
+# Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+import os
+import shutil
+import re
+import csv
+import xml.dom.minidom
+from typing import List, Dict, Tuple
+import logging
+from io import StringIO
+from edk2toolext.environment import shell_environment
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toolext.environment.var_dict import VarDict
+from edk2toollib.utility_functions import RunCmd
+
+
+class EccCheck(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that finds the Ecc issues of newly added code in pull request.
+
+    Configuration options:
+    "EccCheck": {
+        "ExceptionList": [],
+        "IgnoreFiles": []
+    },
+    """
+
+    FindModifyFile = re.compile(r'\+\+\+ b\/(.*)')
+    LineScopePattern = (r'@@ -\d*\,*\d* \+\d*\,*\d* @@.*')
+    LineNumRange = re.compile(r'@@ -\d*\,*\d* \+(\d*)\,*(\d*) @@.*')
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+            testclassname: a descriptive string for the testcase can include whitespace
+            classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+        """
+        return ("Check for efi coding style for " + packagename, packagename + ".EccCheck")
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the ci_build_plugin Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - EnvConfig Object
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        workspace_path = Edk2pathObj.WorkspacePath
+        basetools_path = environment.GetValue("EDK_TOOLS_PATH")
+        python_path = os.path.join(basetools_path, "Source", "Python")
+        env = shell_environment.GetEnvironment()
+        env.set_shell_var('PYTHONPATH', python_path)
+        env.set_shell_var('WORKSPACE', workspace_path)
+        env.set_shell_var('PACKAGES_PATH', os.pathsep.join(Edk2pathObj.PackagePathList))
+        self.ECC_PASS = True
+
+        # Create temp directory
+        temp_path = os.path.join(workspace_path, 'Build', '.pytool', 'Plugin', 'EccCheck')
+        try:
+            # Delete temp directory
+            if os.path.exists(temp_path):
+                shutil.rmtree(temp_path)
+            # Copy package being scanned to temp_path
+            shutil.copytree (
+              os.path.join(workspace_path, packagename),
+              os.path.join(temp_path, packagename),
+              symlinks=True
+              )
+            # Copy exception.xml to temp_path
+            shutil.copyfile (
+              os.path.join(basetools_path, "Source", "Python", "Ecc", "exception.xml"),
+              os.path.join(temp_path, "exception.xml")
+              )
+            # Output file to use for git diff operations
+            temp_diff_output = os.path.join (temp_path, 'diff.txt')
+
+            self.ApplyConfig(pkgconfig, temp_path, packagename)
+            modify_dir_list = self.GetModifyDir(packagename, temp_diff_output)
+            patch = self.GetDiff(packagename, temp_diff_output)
+            ecc_diff_range = self.GetDiffRange(patch, packagename, temp_path)
+            #
+            # Use temp_path as working directory when running ECC tool
+            #
+            self.GenerateEccReport(modify_dir_list, ecc_diff_range, temp_path, basetools_path)
+            ecc_log = os.path.join(temp_path, "Ecc.log")
+            if self.ECC_PASS:
+                # Delete temp directory
+                if os.path.exists(temp_path):
+                    shutil.rmtree(temp_path)
+                tc.SetSuccess()
+                return 0
+            else:
+                with open(ecc_log, encoding='utf8') as output:
+                    ecc_output = output.readlines()
+                    for line in ecc_output:
+                        logging.error(line.strip())
+                # Delete temp directory
+                if os.path.exists(temp_path):
+                    shutil.rmtree(temp_path)
+                tc.SetFailed("EccCheck failed for {0}".format(packagename), "CHECK FAILED")
+                return 1
+        except KeyboardInterrupt:
+            # If EccCheck is interrupted by keybard interrupt, then return failure
+            # Delete temp directory
+            if os.path.exists(temp_path):
+                shutil.rmtree(temp_path)
+            tc.SetFailed("EccCheck interrupted for {0}".format(packagename), "CHECK FAILED")
+            return 1
+        else:
+            # If EccCheck fails for any other exception type, raise the exception
+            # Delete temp directory
+            if os.path.exists(temp_path):
+                shutil.rmtree(temp_path)
+            tc.SetFailed("EccCheck exception for {0}".format(packagename), "CHECK FAILED")
+            raise
+            return 1
+
+    def GetDiff(self, pkg: str, temp_diff_output: str) -> List[str]:
+        patch = []
+        #
+        # Generate unified diff between origin/master and HEAD.
+        #
+        params = "diff --output={} --unified=0 origin/master HEAD".format(temp_diff_output)
+        RunCmd("git", params)
+        with open(temp_diff_output) as file:
+            patch = file.read().strip().split('\n')
+        return patch
+
+    def GetModifyDir(self, pkg: str, temp_diff_output: str) -> List[str]:
+        #
+        # Generate diff between origin/master and HEAD using --diff-filter to
+        # exclude deleted and renamed files that do not need to be scanned by
+        # ECC.  Also use --name-status to only generate the names of the files
+        # with differences.  The output format of this git diff command is a
+        # list of files with the change status and the filename.  The filename
+        # is always at the end of the line.  Examples:
+        #
+        #   M       MdeModulePkg/Application/CapsuleApp/CapsuleApp.h
+        #   M       MdeModulePkg/Application/UiApp/FrontPage.h
+        #
+        params = "diff --output={} --diff-filter=dr --name-status origin/master HEAD".format(temp_diff_output)
+        RunCmd("git", params)
+        dir_list = []
+        with open(temp_diff_output) as file:
+            dir_list = file.read().strip().split('\n')
+
+        modify_dir_list = []
+        for modify_dir in dir_list:
+            #
+            # Parse file name from the end of the line
+            #
+            file_path = modify_dir.strip().split()
+            #
+            # Skip lines that do not have at least 2 elements (status and file name)
+            #
+            if len(file_path) < 2:
+                continue
+            #
+            # Parse the directory name from the file name
+            #
+            file_dir = os.path.dirname(file_path[-1])
+            #
+            # Skip directory names that do not start with the package being scanned.
+            #
+            if file_dir.split('/')[0] != pkg:
+                continue
+            #
+            # Skip directory names that are identical to the package being scanned.
+            # The assumption here is that there are no source files at the package
+            # root.  Instead, the only expected files in the package root are
+            # EDK II meta data files (DEC, DSC, FDF).
+            #
+            if file_dir == pkg:
+                continue
+            #
+            # Skip directory names that are already in the modified dir list
+            #
+            if file_dir in modify_dir_list:
+                continue
+            #
+            # Add the candidate directory to scan to the modified dir list
+            #
+            modify_dir_list.append(file_dir)
+
+        #
+        # Remove duplicates from modify_dir_list
+        # Given a folder path, ECC performs a recursive scan of that folder.
+        # If a parent and child folder are both present in modify_dir_list,
+        # then ECC will perform redudanct scans of source files.  In order
+        # to prevent redundant scans, if a parent and child folder are both
+        # present, then remove all the child folders.
+        #
+        # For example, if modified_dir_list contains the following elements:
+        #   MdeModulePkg/Core/Dxe
+        #   MdeModulePkg/Core/Dxe/Hand
+        #   MdeModulePkg/Core/Dxe/Mem
+        #
+        # Then MdeModulePkg/Core/Dxe/Hand and MdeModulePkg/Core/Dxe/Mem should
+        # be removed because the files in those folders are covered by a scan
+        # of MdeModulePkg/Core/Dxe.
+        #
+        filtered_list = []
+        for dir1 in modify_dir_list:
+            Append = True
+            for dir2 in modify_dir_list:
+                if dir1 == dir2:
+                    continue
+                common = os.path.commonpath([dir1, dir2])
+                if os.path.normpath(common) == os.path.normpath(dir2):
+                    Append = False
+                    break
+            if Append and dir1 not in filtered_list:
+                filtered_list.append(dir1)
+        return filtered_list
+
+    def GetDiffRange(self, patch_diff: List[str], pkg: str, temp_path: str) -> Dict[str, List[Tuple[int, int]]]:
+        IsDelete = True
+        StartCheck = False
+        range_directory: Dict[str, List[Tuple[int, int]]] = {}
+        for line in patch_diff:
+            modify_file = self.FindModifyFile.findall(line)
+            if modify_file and pkg in modify_file[0] and not StartCheck and os.path.isfile(modify_file[0]):
+                modify_file_comment_dic = self.GetCommentRange(modify_file[0], temp_path)
+                IsDelete = False
+                StartCheck = True
+                modify_file_dic = modify_file[0]
+                modify_file_dic = modify_file_dic.replace("/", os.sep)
+                range_directory[modify_file_dic] = []
+            elif line.startswith('--- '):
+                StartCheck = False
+            elif re.match(self.LineScopePattern, line, re.I) and not IsDelete and StartCheck:
+                start_line = self.LineNumRange.search(line).group(1)
+                line_range = self.LineNumRange.search(line).group(2)
+                if not line_range:
+                    line_range = '1'
+                range_directory[modify_file_dic].append((int(start_line), int(start_line) + int(line_range) - 1))
+                for i in modify_file_comment_dic:
+                    if int(i[0]) <= int(start_line) <= int(i[1]):
+                        range_directory[modify_file_dic].append(i)
+        return range_directory
+
+    def GetCommentRange(self, modify_file: str, temp_path: str) -> List[Tuple[int, int]]:
+        comment_range: List[Tuple[int, int]] = []
+        modify_file_path = os.path.join(temp_path, modify_file)
+        if not os.path.exists (modify_file_path):
+            return comment_range
+        with open(modify_file_path) as f:
+            line_no = 1
+            Start = False
+            for line in f:
+                if line.startswith('/**'):
+                    start_no = line_no
+                    Start = True
+                if line.startswith('**/') and Start:
+                    end_no = line_no
+                    Start = False
+                    comment_range.append((int(start_no), int(end_no)))
+                line_no += 1
+
+        if comment_range and comment_range[0][0] == 1:
+            del comment_range[0]
+        return comment_range
+
+    def GenerateEccReport(self, modify_dir_list: List[str], ecc_diff_range: Dict[str, List[Tuple[int, int]]],
+                           temp_path: str, basetools_path: str) -> None:
+        ecc_need = False
+        ecc_run = True
+        config    = os.path.normpath(os.path.join(basetools_path, "Source", "Python", "Ecc", "config.ini"))
+        exception = os.path.normpath(os.path.join(temp_path, "exception.xml"))
+        report    = os.path.normpath(os.path.join(temp_path, "Ecc.csv"))
+        for modify_dir in modify_dir_list:
+            target = os.path.normpath(os.path.join(temp_path, modify_dir))
+            logging.info('Run ECC tool for the commit in %s' % modify_dir)
+            ecc_need = True
+            ecc_params = "-c {0} -e {1} -t {2} -r {3}".format(config, exception, target, report)
+            return_code = RunCmd("Ecc", ecc_params, workingdir=temp_path)
+            if return_code != 0:
+                ecc_run = False
+                break
+            if not ecc_run:
+                logging.error('Fail to run ECC tool')
+            self.ParseEccReport(ecc_diff_range, temp_path)
+
+        if not ecc_need:
+            logging.info("Doesn't need run ECC check")
+
+        return
+
+    def ParseEccReport(self, ecc_diff_range: Dict[str, List[Tuple[int, int]]], temp_path: str) -> None:
+        ecc_log = os.path.join(temp_path, "Ecc.log")
+        ecc_csv = os.path.join(temp_path, "Ecc.csv")
+        row_lines = []
+        ignore_error_code = self.GetIgnoreErrorCode()
+        if os.path.exists(ecc_csv):
+            with open(ecc_csv) as csv_file:
+                reader = csv.reader(csv_file)
+                for row in reader:
+                    for modify_file in ecc_diff_range:
+                        if modify_file in row[3]:
+                            for i in ecc_diff_range[modify_file]:
+                                line_no = int(row[4])
+                                if i[0] <= line_no <= i[1] and row[1] not in ignore_error_code:
+                                    row[0] = '\nEFI coding style error'
+                                    row[1] = 'Error code: ' + row[1]
+                                    row[3] = 'file: ' + row[3]
+                                    row[4] = 'Line number: ' + row[4]
+                                    row_line = '\n  *'.join(row)
+                                    row_lines.append(row_line)
+                                    break
+                            break
+        if row_lines:
+            self.ECC_PASS = False
+
+        with open(ecc_log, 'a') as log:
+            all_line = '\n'.join(row_lines)
+            all_line = all_line + '\n'
+            log.writelines(all_line)
+        return
+
+    def ApplyConfig(self, pkgconfig: Dict[str, List[str]], temp_path: str, pkg: str) -> None:
+        if "IgnoreFiles" in pkgconfig:
+            for a in pkgconfig["IgnoreFiles"]:
+                a = os.path.join(temp_path, pkg, a)
+                a = a.replace(os.sep, "/")
+
+                logging.info("Ignoring Files {0}".format(a))
+                if os.path.exists(a):
+                    if os.path.isfile(a):
+                        os.remove(a)
+                    elif os.path.isdir(a):
+                        shutil.rmtree(a)
+                else:
+                    logging.error("EccCheck.IgnoreInf -> {0} not found in filesystem.  Invalid ignore files".format(a))
+
+        if "ExceptionList" in pkgconfig:
+            exception_list = pkgconfig["ExceptionList"]
+            exception_xml = os.path.join(temp_path, "exception.xml")
+            try:
+                logging.info("Appending exceptions")
+                self.AppendException(exception_list, exception_xml)
+            except Exception as e:
+                logging.error("Fail to apply exceptions")
+                raise e
+        return
+
+    def AppendException(self, exception_list: List[str], exception_xml: str) -> None:
+        error_code_list = exception_list[::2]
+        keyword_list = exception_list[1::2]
+        dom_tree = xml.dom.minidom.parse(exception_xml)
+        root_node = dom_tree.documentElement
+        for error_code, keyword in zip(error_code_list, keyword_list):
+            customer_node = dom_tree.createElement("Exception")
+            keyword_node = dom_tree.createElement("KeyWord")
+            keyword_node_text_value = dom_tree.createTextNode(keyword)
+            keyword_node.appendChild(keyword_node_text_value)
+            customer_node.appendChild(keyword_node)
+            error_code_node = dom_tree.createElement("ErrorID")
+            error_code_text_value = dom_tree.createTextNode(error_code)
+            error_code_node.appendChild(error_code_text_value)
+            customer_node.appendChild(error_code_node)
+            root_node.appendChild(customer_node)
+        with open(exception_xml, 'w') as f:
+            dom_tree.writexml(f, indent='', addindent='', newl='\n', encoding='UTF-8')
+        return
+
+    def GetIgnoreErrorCode(self) -> set:
+        """
+        Below are kinds of error code that are accurate in ecc scanning of edk2 level.
+        But EccCheck plugin is partial scanning so they are always false positive issues.
+        The mapping relationship of error code and error message is listed BaseTools/Sourc/Python/Ecc/EccToolError.py
+        """
+        ignore_error_code = {
+                             "10000",
+                             "10001",
+                             "10002",
+                             "10003",
+                             "10004",
+                             "10005",
+                             "10006",
+                             "10007",
+                             "10008",
+                             "10009",
+                             "10010",
+                             "10011",
+                             "10012",
+                             "10013",
+                             "10015",
+                             "10016",
+                             "10017",
+                             "10022",
+                            }
+        return ignore_error_code

.pytool/Plugin/EccCheck/EccCheck_plug_in.yaml

@@ -0,0 +1,11 @@
+## @file
+# CiBuildPlugin used to check Ecc issues
+#
+# Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "EccCheck Test",
+  "module": "EccCheck"
+}

.pytool/Plugin/EccCheck/Readme.md

@@ -0,0 +1,15 @@
+# EFI Coding style Check Plugin
+
+This CiBuildPlugin finds the Ecc issues of newly added code in pull request.
+
+## Configuration
+
+The plugin can be configured to ignore certain files and issues.
+
+"EccCheck": {
+        "ExceptionList": [],
+        "IgnoreFiles": []
+    },
+    """
+
+OPTIONAL List of file to ignore.

.pytool/Plugin/GuidCheck/GuidCheck.py

@@ -0,0 +1,251 @@
+# @file GuidCheck.py
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+import logging
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toollib.uefi.edk2.guid_list import GuidList
+from edk2toolext.environment.var_dict import VarDict
+
+
+class GuidCheck(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that scans the code tree and looks for duplicate guids
+    from the package being tested.
+
+    Configuration options:
+    "GuidCheck": {
+        "IgnoreGuidName": [], # provide in format guidname=guidvalue or just guidname
+        "IgnoreGuidValue": [],
+        "IgnoreFoldersAndFiles": [],
+        "IgnoreDuplicates": [] # Provide in format guidname=guidname=guidname...
+    }
+    """
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+                testclassname: a descriptive string for the testcase can include whitespace
+                classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+        """
+        return ("Confirm GUIDs are unique in " + packagename, packagename + ".GuidCheck")
+
+    def _FindConflictingGuidValues(self, guidlist: list) -> list:
+        """ Find all duplicate guids by guid value and report them as errors
+        """
+        # Sort the list by guid
+        guidsorted = sorted(
+            guidlist, key=lambda x: x.guid.upper(), reverse=True)
+
+        previous = None  # Store previous entry for comparison
+        error = None
+        errors = []
+        for index in range(len(guidsorted)):
+            i = guidsorted[index]
+            if(previous is not None):
+                if i.guid == previous.guid:  # Error
+                    if(error is None):
+                        # Catch errors with more than 1 conflict
+                        error = ErrorEntry("guid")
+                        error.entries.append(previous)
+                        errors.append(error)
+                    error.entries.append(i)
+                else:
+                    # no match.  clear error
+                    error = None
+            previous = i
+        return errors
+
+    def _FindConflictingGuidNames(self, guidlist: list) -> list:
+        """ Find all duplicate guids by name and if they are not all
+        from inf files report them as errors.  It is ok to have
+        BASE_NAME duplication.
+
+        Is this useful?  It would catch two same named guids in dec file
+        that resolve to different values.
+        """
+        # Sort the list by guid
+        namesorted = sorted(guidlist, key=lambda x: x.name.upper())
+
+        previous = None  # Store previous entry for comparison
+        error = None
+        errors = []
+        for index in range(len(namesorted)):
+            i = namesorted[index]
+            if(previous is not None):
+                # If name matches
+                if i.name == previous.name:
+                    if(error is None):
+                        # Catch errors with more than 1 conflict
+                        error = ErrorEntry("name")
+                        error.entries.append(previous)
+                        errors.append(error)
+                    error.entries.append(i)
+                else:
+                    # no match.  clear error
+                    error = None
+            previous = i
+
+            # Loop thru and remove any errors where all files are infs as it is ok if
+            # they have the same inf base name.
+            for e in errors[:]:
+                if len( [en for en in e.entries if not en.absfilepath.lower().endswith(".inf")]) == 0:
+                    errors.remove(e)
+
+        return errors
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the MuBuild Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - EnvConfig Object
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        Errors = []
+
+        abs_pkg_path = Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(
+            packagename)
+
+        if abs_pkg_path is None:
+            tc.SetSkipped()
+            tc.LogStdError("No package {0}".format(packagename))
+            return -1
+
+        All_Ignores = ["/Build", "/Conf"]
+        # Parse the config for other ignores
+        if "IgnoreFoldersAndFiles" in pkgconfig:
+            All_Ignores.extend(pkgconfig["IgnoreFoldersAndFiles"])
+
+        # Parse the workspace for all GUIDs
+        gs = GuidList.guidlist_from_filesystem(
+            Edk2pathObj.WorkspacePath, ignore_lines=All_Ignores)
+
+        # Remove ignored guidvalue
+        if "IgnoreGuidValue" in pkgconfig:
+            for a in pkgconfig["IgnoreGuidValue"]:
+                try:
+                    tc.LogStdOut("Ignoring Guid {0}".format(a.upper()))
+                    for b in gs[:]:
+                        if b.guid == a.upper():
+                            gs.remove(b)
+                except:
+                    tc.LogStdError("GuidCheck.IgnoreGuid -> {0} not found.  Invalid ignore guid".format(a.upper()))
+                    logging.info("GuidCheck.IgnoreGuid -> {0} not found.  Invalid ignore guid".format(a.upper()))
+
+        # Remove ignored guidname
+        if "IgnoreGuidName" in pkgconfig:
+            for a in pkgconfig["IgnoreGuidName"]:
+                entry = a.split("=")
+                if(len(entry) > 2):
+                    tc.LogStdError("GuidCheck.IgnoreGuidName -> {0} Invalid Format.".format(a))
+                    logging.info("GuidCheck.IgnoreGuidName -> {0} Invalid Format.".format(a))
+                    continue
+                try:
+                    tc.LogStdOut("Ignoring Guid {0}".format(a))
+                    for b in gs[:]:
+                        if b.name == entry[0]:
+                            if(len(entry) == 1):
+                                gs.remove(b)
+                            elif(len(entry) == 2 and b.guid.upper() == entry[1].upper()):
+                                gs.remove(b)
+                            else:
+                                c.LogStdError("GuidCheck.IgnoreGuidName -> {0} incomplete match.  Invalid ignore guid".format(a))
+
+                except:
+                    tc.LogStdError("GuidCheck.IgnoreGuidName -> {0} not found.  Invalid ignore name".format(a))
+                    logging.info("GuidCheck.IgnoreGuidName -> {0} not found.  Invalid ignore name".format(a))
+
+        # Find conflicting Guid Values
+        Errors.extend(self._FindConflictingGuidValues(gs))
+
+        # Check if there are expected duplicates and remove it from the error list
+        if "IgnoreDuplicates" in pkgconfig:
+            for a in pkgconfig["IgnoreDuplicates"]:
+                names = a.split("=")
+                if len(names) < 2:
+                    tc.LogStdError("GuidCheck.IgnoreDuplicates -> {0} invalid format".format(a))
+                    logging.info("GuidCheck.IgnoreDuplicates -> {0} invalid format".format(a))
+                    continue
+
+                for b in Errors[:]:
+                    if b.type != "guid":
+                        continue
+                    ## Make a list of the names that are not in the names list.  If there
+                    ## are any in the list then this error should not be ignored.
+                    t = [x for x in b.entries if x.name not in names]
+                    if(len(t) == len(b.entries)):
+                        ## did not apply to any entry
+                        continue
+                    elif(len(t) == 0):
+                        ## full match - ignore duplicate
+                        tc.LogStdOut("GuidCheck.IgnoreDuplicates -> {0}".format(a))
+                        Errors.remove(b)
+                    elif(len(t) < len(b.entries)):
+                        ## partial match
+                        tc.LogStdOut("GuidCheck.IgnoreDuplicates -> {0} incomplete match".format(a))
+                        logging.info("GuidCheck.IgnoreDuplicates -> {0} incomplete match".format(a))
+                    else:
+                        tc.LogStdOut("GuidCheck.IgnoreDuplicates -> {0} unknown error.".format(a))
+                        logging.info("GuidCheck.IgnoreDuplicates -> {0} unknown error".format(a))
+
+
+
+        # Find conflicting Guid Names
+        Errors.extend(self._FindConflictingGuidNames(gs))
+
+        # Log errors for anything within the package under test
+        for er in Errors[:]:
+            InMyPackage = False
+            for a in er.entries:
+                if abs_pkg_path in a.absfilepath:
+                    InMyPackage = True
+                    break
+            if(not InMyPackage):
+                Errors.remove(er)
+            else:
+                logging.error(str(er))
+                tc.LogStdError(str(er))
+
+        # add result to test case
+        overall_status = len(Errors)
+        if overall_status != 0:
+            tc.SetFailed("GuidCheck {0} Failed.  Errors {1}".format(
+                packagename, overall_status), "CHECK_FAILED")
+        else:
+            tc.SetSuccess()
+        return overall_status
+
+
+class ErrorEntry():
+    """ Custom/private class for reporting errors in the GuidList
+    """
+
+    def __init__(self, errortype):
+        self.type = errortype  # 'guid' or 'name' depending on error type
+        self.entries = []  # GuidListEntry that are in error condition
+
+    def __str__(self):
+        a = f"Error Duplicate {self.type}: "
+        if(self.type == "guid"):
+            a += f" {self.entries[0].guid}"
+        elif(self.type == "name"):
+            a += f" {self.entries[0].name}"
+
+        a += f" ({len(self.entries)})\n"
+
+        for e in self.entries:
+            a += "\t" + str(e) + "\n"
+        return a

.pytool/Plugin/GuidCheck/GuidCheck_plug_in.yaml

@@ -0,0 +1,11 @@
+## @file
+# CiBuildPlugin used to check guid uniqueness
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "Guid Check Test",
+  "module": "GuidCheck"
+}

.pytool/Plugin/GuidCheck/Readme.md

@@ -0,0 +1,80 @@
+# Guid Check Plugin
+
+This CiBuildPlugin scans all the files in a code tree to find all the GUID
+definitions.  After collection it will then look for duplication in the package
+under test.  Uniqueness of all GUIDs are critical within the UEFI environment.
+Duplication can cause numerous issues including locating the wrong data
+structure, calling the wrong function, or decoding the wrong data members.
+
+Currently Scanned:
+
+* INF files are scanned for there Module guid
+* DEC files are scanned for all of their Protocols, PPIs, and Guids as well as
+  the one package GUID.
+
+Any GUID value being equal to two names or even just defined in two files is
+considered an error unless in the ignore list.
+
+Any GUID name that is found more than once is an error unless all occurrences
+are Module GUIDs.  Since the Module GUID is assigned to the Module name it is
+common to have numerous versions of the same module named the same.
+
+## Configuration
+
+The plugin has numerous configuration options to support the UEFI codebase.
+
+``` yaml
+"GuidCheck": {
+        "IgnoreGuidName": [],
+        "IgnoreGuidValue": [],
+        "IgnoreFoldersAndFiles": [],
+        "IgnoreDuplicates": []
+    }
+```
+
+### IgnoreGuidName
+
+This list allows strings in two formats.
+
+* _GuidName_
+  * This will remove any entry with this GuidName from the list of GUIDs
+    therefore ignoring any error associated with this name.
+* _GuidName=GuidValue_
+  * This will also ignore the GUID by name but only if the value equals the
+    GuidValue.
+  * GuidValue should be in registry format.
+  * This is the suggested format to use as it will limit the ignore to only the
+    defined case.
+
+### IgnoreGuidValue
+
+This list allows strings in guid registry format _GuidValue_.
+
+* This will remove any entry with this GuidValue from the list of GUIDs
+  therefore ignoring any error associated with this value.
+* GuidValue must be in registry format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+
+### IgnoreFoldersAndFiles
+
+This supports .gitignore file and folder matching strings including wildcards
+
+* Any folder or file ignored will not be parsed and therefore any GUID defined
+  will be ignored.
+* The plugin will always ignores the following ["/Build", "/Conf"]
+
+### IgnoreDuplicates
+
+This supports strings in the format of _GuidName_=_GuidName_=_GuidName_
+
+* For the error with the GuidNames to be ignored the list must match completely
+  with what is found during the code scan.
+  * For example if there are two GUIDs that are by design equal within the code
+    tree then it should be _GuidName_=_GuidName_
+  * If instead there are three GUIDs then it must be
+    _GuidName_=_GuidName_=_GuidName_
+* This is the best ignore list to use because it is the most strict and will
+  catch new problems when new conflicts are introduced.
+* There are numerous places in the UEFI specification in which two GUID names
+  are assigned the same value.  These names should be set in this ignore list so
+  that they don't cause an error but any additional duplication would still be
+  caught.

.pytool/Plugin/HostUnitTestCompilerPlugin/HostUnitTestCompilerPlugin.py

@@ -0,0 +1,149 @@
+# @file HostUnitTestCompilerPlugin.py
+##
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+import logging
+import os
+import re
+from edk2toollib.uefi.edk2.parsers.dsc_parser import DscParser
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toolext.environment.uefi_build import UefiBuilder
+from edk2toolext import edk2_logging
+from edk2toolext.environment.var_dict import VarDict
+from edk2toollib.utility_functions import GetHostInfo
+
+
+class HostUnitTestCompilerPlugin(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that compiles the dsc for host based unit test apps.
+    An IUefiBuildPlugin may be attached to this plugin that will run the
+    unit tests and collect the results after successful compilation.
+
+    Configuration options:
+    "HostUnitTestCompilerPlugin": {
+        "DscPath": "<path to dsc from root of pkg>"
+    }
+    """
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+            testclassname: a descriptive string for the testcase can include whitespace
+            classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+        """
+        num,types = self.__GetHostUnitTestArch(environment)
+        types = types.replace(" ", "_")
+
+        return ("Compile and Run Host-Based UnitTests for " + packagename + " on arch " + types,
+                packagename + ".HostUnitTestCompiler." + types)
+
+    def RunsOnTargetList(self):
+        return ["NOOPT"]
+
+    #
+    # Find the intersection of application types that can run on this host
+    # and the TARGET_ARCH being build in this request.
+    #
+    # return tuple with (number of UEFI arch types, space separated string)
+    def __GetHostUnitTestArch(self, environment):
+        requested = environment.GetValue("TARGET_ARCH").split(' ')
+        host = []
+        if GetHostInfo().arch == 'x86':
+            #assume 64bit can handle 64 and 32
+            #assume 32bit can only handle 32
+            ## change once IA32 issues resolved host.append("IA32")
+            if GetHostInfo().bit == '64':
+                host.append("X64")
+        elif GetHostInfo().arch == 'ARM':
+            if GetHostInfo().bit == '64':
+                host.append("AARCH64")
+            elif GetHostInfo().bit == '32':
+                host.append("ARM")
+
+        willrun = set(requested) & set(host)
+        return (len(willrun), " ".join(willrun))
+
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the ICiBuildPlugin Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - EnvConfig Object
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        self._env = environment
+        environment.SetValue("CI_BUILD_TYPE", "host_unit_test", "Set in HostUnitTestCompilerPlugin")
+
+        # Parse the config for required DscPath element
+        if "DscPath" not in pkgconfig:
+            tc.SetSkipped()
+            tc.LogStdError("DscPath not found in config file.  Nothing to compile for HostBasedUnitTests.")
+            return -1
+
+        AP = Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(packagename)
+
+        APDSC = os.path.join(AP, pkgconfig["DscPath"].strip())
+        AP_Path = Edk2pathObj.GetEdk2RelativePathFromAbsolutePath(APDSC)
+        if AP is None or AP_Path is None or not os.path.isfile(APDSC):
+            tc.SetSkipped()
+            tc.LogStdError("Package HostBasedUnitTest Dsc not found.")
+            return -1
+
+        logging.info("Building {0}".format(AP_Path))
+        self._env.SetValue("ACTIVE_PLATFORM", AP_Path, "Set in Compiler Plugin")
+        num, RUNNABLE_ARCHITECTURES = self.__GetHostUnitTestArch(environment)
+        if(num == 0):
+            tc.SetSkipped()
+            tc.LogStdError("No host architecture compatibility")
+            return -1
+
+        if not environment.SetValue("TARGET_ARCH",
+                                    RUNNABLE_ARCHITECTURES,
+                                    "Update Target Arch based on Host Support"):
+            #use AllowOverride function since this is a controlled attempt to change
+            environment.AllowOverride("TARGET_ARCH")
+            if not environment.SetValue("TARGET_ARCH",
+                                        RUNNABLE_ARCHITECTURES,
+                                        "Update Target Arch based on Host Support"):
+                raise RuntimeError("Can't Change TARGET_ARCH as required")
+
+        # Parse DSC to check for SUPPORTED_ARCHITECTURES
+        dp = DscParser()
+        dp.SetBaseAbsPath(Edk2pathObj.WorkspacePath)
+        dp.SetPackagePaths(Edk2pathObj.PackagePathList)
+        dp.ParseFile(AP_Path)
+        if "SUPPORTED_ARCHITECTURES" in dp.LocalVars:
+            SUPPORTED_ARCHITECTURES = dp.LocalVars["SUPPORTED_ARCHITECTURES"].split('|')
+            TARGET_ARCHITECTURES = environment.GetValue("TARGET_ARCH").split(' ')
+
+            # Skip if there is no intersection between SUPPORTED_ARCHITECTURES and TARGET_ARCHITECTURES
+            if len(set(SUPPORTED_ARCHITECTURES) & set(TARGET_ARCHITECTURES)) == 0:
+                tc.SetSkipped()
+                tc.LogStdError("No supported architecutres to build for host unit tests")
+                return -1
+
+        uefiBuilder = UefiBuilder()
+        # do all the steps
+        # WorkSpace, PackagesPath, PInHelper, PInManager
+        ret = uefiBuilder.Go(Edk2pathObj.WorkspacePath, os.pathsep.join(Edk2pathObj.PackagePathList), PLMHelper, PLM)
+        if ret != 0:  # failure:
+            tc.SetFailed("Compile failed for {0}".format(packagename), "Compile_FAILED")
+            tc.LogStdError("{0} Compile failed with error code {1} ".format(AP_Path, ret))
+            return 1
+
+        else:
+            tc.SetSuccess()
+            return 0

.pytool/Plugin/HostUnitTestCompilerPlugin/HostUnitTestCompiler_plug_in.yaml

@@ -0,0 +1,12 @@
+##
+# CiBuildPlugin used to build anything that identifies
+# as a unit test.
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "host-based-test",
+  "name": "Host Unit Test Compiler Plugin",
+  "module": "HostUnitTestCompilerPlugin"
+}

.pytool/Plugin/HostUnitTestCompilerPlugin/Readme.md

@@ -0,0 +1,24 @@
+# Host UnitTest Compiler Plugin
+
+A CiBuildPlugin that compiles the dsc for host based unit test apps.
+An IUefiBuildPlugin may be attached to this plugin that will run the unit tests and collect the results after successful compilation.
+
+## Configuration
+
+The package relative path of the DSC file to build.
+
+``` yaml
+"HostUnitTestCompilerPlugin": {
+    "DscPath": "<path to dsc from root of pkg>"
+}
+```
+
+### DscPath
+
+Package relative path to the DSC file to build.
+
+## Copyright
+
+Copyright (c) Microsoft Corporation.
+SPDX-License-Identifier: BSD-2-Clause-Patent
+

.pytool/Plugin/HostUnitTestDscCompleteCheck/HostUnitTestDscCompleteCheck.py

@@ -0,0 +1,140 @@
+# @file HostUnitTestDscCompleteCheck.py
+#
+# This is a copy of DscCompleteCheck with different filtering logic.
+# It should be discussed if this should be one plugin
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+import logging
+import os
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toollib.uefi.edk2.parsers.dsc_parser import DscParser
+from edk2toollib.uefi.edk2.parsers.inf_parser import InfParser
+from edk2toolext.environment.var_dict import VarDict
+
+
+class HostUnitTestDscCompleteCheck(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that scans the package Host Unit Test dsc file and confirms all Host application modules (inf files) are
+    listed in the components sections.
+
+    Configuration options:
+    "HostUnitTestDscCompleteCheck": {
+        "DscPath": "", # Path to Host based unit test DSC file
+        "IgnoreInf": []  # Ignore INF if found in filesystem but not dsc
+    }
+    """
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+                testclassname: a descriptive string for the testcase can include whitespace
+                classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+        """
+        return ("Check the " + packagename + " Host Unit Test DSC for a being complete", packagename + ".HostUnitTestDscCompleteCheck")
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the MuBuild Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - VarDict containing the shell environment Build Vars
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        overall_status = 0
+
+        # Parse the config for required DscPath element
+        if "DscPath" not in pkgconfig:
+            tc.SetSkipped()
+            tc.LogStdError(
+                "DscPath not found in config file.  Nothing to check.")
+            return -1
+
+        abs_pkg_path = Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(
+            packagename)
+        abs_dsc_path = os.path.join(abs_pkg_path, pkgconfig["DscPath"].strip())
+        wsr_dsc_path = Edk2pathObj.GetEdk2RelativePathFromAbsolutePath(
+            abs_dsc_path)
+
+        if abs_dsc_path is None or wsr_dsc_path == "" or not os.path.isfile(abs_dsc_path):
+            tc.SetSkipped()
+            tc.LogStdError("Package Host Unit Test Dsc not found")
+            return 0
+
+        # Get INF Files
+        INFFiles = self.WalkDirectoryForExtension([".inf"], abs_pkg_path)
+        INFFiles = [Edk2pathObj.GetEdk2RelativePathFromAbsolutePath(
+            x) for x in INFFiles]  # make edk2relative path so can compare with DSC
+
+        # remove ignores
+
+        if "IgnoreInf" in pkgconfig:
+            for a in pkgconfig["IgnoreInf"]:
+                a = a.replace(os.sep, "/")
+                try:
+                    tc.LogStdOut("Ignoring INF {0}".format(a))
+                    INFFiles.remove(a)
+                except:
+                    tc.LogStdError(
+                        "HostUnitTestDscCompleteCheck.IgnoreInf -> {0} not found in filesystem.  Invalid ignore file".format(a))
+                    logging.info(
+                        "HostUnitTestDscCompleteCheck.IgnoreInf -> {0} not found in filesystem.  Invalid ignore file".format(a))
+
+        # DSC Parser
+        dp = DscParser()
+        dp.SetBaseAbsPath(Edk2pathObj.WorkspacePath)
+        dp.SetPackagePaths(Edk2pathObj.PackagePathList)
+        dp.SetInputVars(environment.GetAllBuildKeyValues())
+        dp.ParseFile(wsr_dsc_path)
+
+        # Check if INF in component section
+        for INF in INFFiles:
+            if not any(INF.strip() in x for x in dp.ThreeMods) and \
+               not any(INF.strip() in x for x in dp.SixMods) and \
+               not any(INF.strip() in x for x in dp.OtherMods):
+
+                infp = InfParser().SetBaseAbsPath(Edk2pathObj.WorkspacePath)
+                infp.SetPackagePaths(Edk2pathObj.PackagePathList)
+                infp.ParseFile(INF)
+                if("MODULE_TYPE" not in infp.Dict):
+                    tc.LogStdOut(
+                        "Ignoring INF. Missing key for MODULE_TYPE {0}".format(INF))
+                    continue
+
+                if(infp.Dict["MODULE_TYPE"] == "HOST_APPLICATION"):
+                    # should compile test a library that is declared type HOST_APPLICATION
+                    pass
+
+                elif len(infp.SupportedPhases) > 0 and \
+                        "HOST_APPLICATION" in infp.SupportedPhases:
+                    # should compile test a library that supports HOST_APPLICATION but
+                    # require it to be an explicit opt-in
+                    pass
+
+                else:
+                    tc.LogStdOut(
+                        "Ignoring INF. MODULE_TYPE or suppored phases not HOST_APPLICATION {0}".format(INF))
+                    continue
+
+                logging.critical(INF + " not in " + wsr_dsc_path)
+                tc.LogStdError("{0} not in {1}".format(INF, wsr_dsc_path))
+                overall_status = overall_status + 1
+
+        # If XML object exists, add result
+        if overall_status != 0:
+            tc.SetFailed("HostUnitTestDscCompleteCheck {0} Failed.  Errors {1}".format(
+                wsr_dsc_path, overall_status), "CHECK_FAILED")
+        else:
+            tc.SetSuccess()
+        return overall_status

.pytool/Plugin/HostUnitTestDscCompleteCheck/HostUnitTestDscCompleteCheck_plug_in.yaml

@@ -0,0 +1,12 @@
+##
+# CiBuildPlugin used to confirm all INFs are listed in
+# the components section of package dsc
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+    "scope": "host-based-test",
+    "name": "Host Unit Test Dsc Complete Check Test",
+    "module": "HostUnitTestDscCompleteCheck"
+  }

.pytool/Plugin/HostUnitTestDscCompleteCheck/Readme.md

@@ -0,0 +1,32 @@
+# Host Unit Test Dsc Complete Check Plugin
+
+This CiBuildPlugin scans all INF files from a package for those related to host
+based unit tests confirms they are listed in the unit test DSC file for the package.
+The test considers it an error if any INF meeting the requirements does not appear
+in the `Components` section of the unit test DSC. This is critical because
+much of the CI infrastructure assumes that  modules will be listed in the DSC
+and compiled.
+
+This test will only require INFs in the following cases:
+
+1. When MODULE_TYPE = HOST_APPLICATION
+2. When a Library instance supports the HOST_APPLICATION environment
+
+## Configuration
+
+The plugin has a few configuration options to support the UEFI codebase.
+
+``` yaml
+"HostUnitTestDscCompleteCheck": {
+    "DscPath": "", # Path to Host based unit test DSC file
+    "IgnoreInf": []  # Ignore INF if found in filesystem but not dsc
+}
+```
+
+### DscPath
+
+Path to DSC to consider platform dsc
+
+### IgnoreInf
+
+Ignore error if Inf file is not listed in DSC file

.pytool/Plugin/LibraryClassCheck/LibraryClassCheck.py

@@ -0,0 +1,153 @@
+# @file LibraryClassCheck.py
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+import logging
+import os
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toollib.uefi.edk2.parsers.dec_parser import DecParser
+from edk2toollib.uefi.edk2.parsers.inf_parser import InfParser
+from edk2toolext.environment.var_dict import VarDict
+
+
+class LibraryClassCheck(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that scans the code tree and library classes for undeclared
+    files
+
+    Configuration options:
+    "LibraryClassCheck": {
+        IgnoreHeaderFile: [],  # Ignore a file found on disk
+        IgnoreLibraryClass: [] # Ignore a declaration found in dec file
+    }
+    """
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+            testclassname: a descriptive string for the testcase can include whitespace
+            classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+        """
+        return ("Check library class declarations in " + packagename, packagename + ".LibraryClassCheck")
+
+    def __GetPkgDec(self, rootpath):
+        try:
+            allEntries = os.listdir(rootpath)
+            for entry in allEntries:
+                if entry.lower().endswith(".dec"):
+                    return(os.path.join(rootpath, entry))
+        except Exception:
+            logging.error("Unable to find DEC for package:{0}".format(rootpath))
+
+        return None
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the MuBuild Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - EnvConfig Object
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        overall_status = 0
+        LibraryClassIgnore = []
+
+        abs_pkg_path = Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(packagename)
+        abs_dec_path = self.__GetPkgDec(abs_pkg_path)
+        wsr_dec_path = Edk2pathObj.GetEdk2RelativePathFromAbsolutePath(abs_dec_path)
+
+        if abs_dec_path is None or wsr_dec_path == "" or not os.path.isfile(abs_dec_path):
+            tc.SetSkipped()
+            tc.LogStdError("No DEC file {0} in package {1}".format(abs_dec_path, abs_pkg_path))
+            return -1
+
+        # Get all include folders
+        dec = DecParser()
+        dec.SetBaseAbsPath(Edk2pathObj.WorkspacePath).SetPackagePaths(Edk2pathObj.PackagePathList)
+        dec.ParseFile(wsr_dec_path)
+
+        AllHeaderFiles = []
+
+        for includepath in dec.IncludePaths:
+            ## Get all header files in the library folder
+            AbsLibraryIncludePath = os.path.join(abs_pkg_path, includepath, "Library")
+            if(not os.path.isdir(AbsLibraryIncludePath)):
+                continue
+
+            hfiles = self.WalkDirectoryForExtension([".h"], AbsLibraryIncludePath)
+            hfiles = [os.path.relpath(x,abs_pkg_path) for x in hfiles]  # make package root relative path
+            hfiles = [x.replace("\\", "/") for x in hfiles]  # make package relative path
+
+            AllHeaderFiles.extend(hfiles)
+
+        if len(AllHeaderFiles) == 0:
+            tc.SetSkipped()
+            tc.LogStdError(f"No Library include folder in any Include path")
+            return -1
+
+        # Remove ignored paths
+        if "IgnoreHeaderFile" in pkgconfig:
+            for a in pkgconfig["IgnoreHeaderFile"]:
+                try:
+                    tc.LogStdOut("Ignoring Library Header File {0}".format(a))
+                    AllHeaderFiles.remove(a)
+                except:
+                    tc.LogStdError("LibraryClassCheck.IgnoreHeaderFile -> {0} not found.  Invalid Header File".format(a))
+                    logging.info("LibraryClassCheck.IgnoreHeaderFile -> {0} not found.  Invalid Header File".format(a))
+
+        if "IgnoreLibraryClass" in pkgconfig:
+            LibraryClassIgnore = pkgconfig["IgnoreLibraryClass"]
+
+
+        ## Attempt to find library classes
+        for lcd in dec.LibraryClasses:
+            ## Check for correct file path separator
+            if "\\" in lcd.path:
+                tc.LogStdError("LibraryClassCheck.DecFilePathSeparator -> {0} invalid.".format(lcd.path))
+                logging.error("LibraryClassCheck.DecFilePathSeparator -> {0} invalid.".format(lcd.path))
+                overall_status += 1
+                continue
+
+            if lcd.name in LibraryClassIgnore:
+                tc.LogStdOut("Ignoring Library Class Name {0}".format(lcd.name))
+                LibraryClassIgnore.remove(lcd.name)
+                continue
+
+            logging.debug(f"Looking for Library Class {lcd.path}")
+            try:
+                AllHeaderFiles.remove(lcd.path)
+
+            except ValueError:
+                tc.LogStdError(f"Library {lcd.name} with path {lcd.path} not found in package filesystem")
+                logging.error(f"Library {lcd.name} with path {lcd.path} not found in package filesystem")
+                overall_status += 1
+
+        ## any remaining AllHeaderFiles are not described in DEC
+        for h in AllHeaderFiles:
+            tc.LogStdError(f"Library Header File {h} not declared in package DEC {wsr_dec_path}")
+            logging.error(f"Library Header File {h} not declared in package DEC {wsr_dec_path}")
+            overall_status += 1
+
+        ## Warn about any invalid library class names in the ignore list
+        for r in LibraryClassIgnore:
+            tc.LogStdError("LibraryClassCheck.IgnoreLibraryClass -> {0} not found.  Library Class not found".format(r))
+            logging.info("LibraryClassCheck.IgnoreLibraryClass -> {0} not found.  Library Class not found".format(r))
+
+
+        # If XML object exists, add result
+        if overall_status != 0:
+            tc.SetFailed("LibraryClassCheck {0} Failed.  Errors {1}".format(wsr_dec_path, overall_status), "CHECK_FAILED")
+        else:
+            tc.SetSuccess()
+        return overall_status

.pytool/Plugin/LibraryClassCheck/LibraryClassCheck_plug_in.yaml

@@ -0,0 +1,11 @@
+## @file
+# CiBuildPlugin used to check that all library classes are declared correctly in dec file
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "Library Class Check Test",
+  "module": "LibraryClassCheck"
+}

.pytool/Plugin/LibraryClassCheck/Readme.md

@@ -0,0 +1,25 @@
+# Library Class Check Plugin
+
+This CiBuildPlugin scans at all library header files found in the `Library`
+folders in all of the package's declared include directories and ensures that
+all files have a matching LibraryClass declaration in the DEC file for the
+package. Any missing declarations will cause a failure.
+
+## Configuration
+
+The plugin has a few configuration options to support the UEFI codebase.
+
+``` yaml
+"LibraryClassCheck": {
+    IgnoreHeaderFile: [],  # Ignore a file found on disk
+    IgnoreLibraryClass: [] # Ignore a declaration found in dec file
+}
+```
+
+### IgnoreHeaderFile
+
+Ignore a file found on disk
+
+### IgnoreLibraryClass
+
+Ignore a declaration found in dec file

.pytool/Plugin/LicenseCheck/LicenseCheck.py

@@ -0,0 +1,123 @@
+# @file LicenseCheck.py
+#
+# Copyright (c) 2020, Intel Corporation. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+import os
+import shutil
+import logging
+import re
+from io import StringIO
+from typing import List, Tuple
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toolext.environment.var_dict import VarDict
+from edk2toollib.utility_functions import RunCmd
+
+
+class LicenseCheck(ICiBuildPlugin):
+
+    """
+    A CiBuildPlugin to check the license for new added files.
+
+    Configuration options:
+    "LicenseCheck": {
+        "IgnoreFiles": []
+    },
+    """
+
+    license_format_preflix = 'SPDX-License-Identifier'
+
+    bsd2_patent = 'BSD-2-Clause-Patent'
+
+    Readdedfileformat = re.compile(r'\+\+\+ b\/(.*)')
+
+    file_extension_list = [".c", ".h", ".inf", ".dsc", ".dec", ".py", ".bat", ".sh", ".uni", ".yaml",
+                           ".fdf", ".inc", "yml", ".asm", ".asm16", ".asl", ".vfr", ".s", ".S", ".aslc",
+                           ".nasm", ".nasmb", ".idf", ".Vfr", ".H"]
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+            testclassname: a descriptive string for the testcase can include whitespace
+            classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+        """
+        return ("Check for license for " + packagename, packagename + ".LicenseCheck")
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the ci_build_plugin Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - EnvConfig Object
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        # Create temp directory
+        temp_path = os.path.join(Edk2pathObj.WorkspacePath, 'Build', '.pytool', 'Plugin', 'LicenseCheck')
+        if not os.path.exists(temp_path):
+            os.makedirs(temp_path)
+        # Output file to use for git diff operations
+        temp_diff_output = os.path.join (temp_path, 'diff.txt')
+        params = "diff --output={} --unified=0 origin/master HEAD".format(temp_diff_output)
+        RunCmd("git", params)
+        with open(temp_diff_output) as file:
+            patch = file.read().strip().split("\n")
+        # Delete temp directory
+        if os.path.exists(temp_path):
+            shutil.rmtree(temp_path)
+
+        ignore_files = []
+        if "IgnoreFiles" in pkgconfig:
+            ignore_files = pkgconfig["IgnoreFiles"]
+
+        self.ok = True
+        self.startcheck = False
+        self.license = True
+        self.all_file_pass = True
+        count = len(patch)
+        line_index = 0
+        for line in patch:
+            if line.startswith('--- /dev/null'):
+                nextline = patch[line_index + 1]
+                added_file = self.Readdedfileformat.search(nextline).group(1)
+                added_file_extension = os.path.splitext(added_file)[1]
+                if added_file_extension in self.file_extension_list and packagename in added_file:
+                    if (self.IsIgnoreFile(added_file, ignore_files)):
+                        line_index = line_index + 1
+                        continue
+                    self.startcheck = True
+                    self.license = False
+            if self.startcheck and self.license_format_preflix in line:
+                if self.bsd2_patent in line:
+                    self.license = True
+            if line_index + 1 == count or patch[line_index + 1].startswith('diff --') and self.startcheck:
+                if not self.license:
+                    self.all_file_pass = False
+                    error_message = "Invalid license in: " + added_file + " Hint: Only BSD-2-Clause-Patent is accepted."
+                    logging.error(error_message)
+                self.startcheck = False
+                self.license = True
+            line_index = line_index + 1
+
+        if self.all_file_pass:
+            tc.SetSuccess()
+            return 0
+        else:
+            tc.SetFailed("License Check {0} Failed. ".format(packagename), "LICENSE_CHECK_FAILED")
+            return 1
+
+    def IsIgnoreFile(self, file: str, ignore_files: List[str]) -> bool:
+        for f in ignore_files:
+            if f in file:
+                return True
+        return False

.pytool/Plugin/LicenseCheck/LicenseCheck_plug_in.yaml

@@ -0,0 +1,11 @@
+## @file
+# CiBuildPlugin used to check license issues for new added files
+#
+# Copyright (c) 2020, Intel Corporation. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "License Check Test",
+  "module": "LicenseCheck"
+}

.pytool/Plugin/LicenseCheck/Readme.md

@@ -0,0 +1,17 @@
+# License Check Plugin
+
+This CiBuildPlugin scans all new added files in a package to make sure code
+is contributed under BSD-2-Clause-Patent.
+
+## Configuration
+
+The plugin can be configured to ignore certain files.
+
+``` yaml
+"LicenseCheck": {
+    "IgnoreFiles": []
+}
+```
+### IgnoreFiles
+
+OPTIONAL List of file to ignore.

.pytool/Plugin/SpellCheck/Readme.md

@@ -0,0 +1,127 @@
+# Spell Check Plugin
+
+This CiBuildPlugin scans all the files in a given package and checks for
+spelling errors.
+
+This plugin requires NodeJs and cspell.  If the plugin doesn't find its required
+tools then it will mark the test as skipped.
+
+* NodeJS: https://nodejs.org/en/
+* cspell: https://www.npmjs.com/package/cspell
+  * Src and doc available: https://github.com/streetsidesoftware/cspell
+
+## Configuration
+
+The plugin has a few configuration options to support the UEFI codebase.
+
+``` yaml
+  "SpellCheck": {
+      "AuditOnly": False,          # If True, log all errors and then mark as skipped
+      "IgnoreFiles": [],           # use gitignore syntax to ignore errors in matching files
+      "ExtendWords": [],           # words to extend to the dictionary for this package
+      "IgnoreStandardPaths": [],   # Standard Plugin defined paths that should be ignore
+      "AdditionalIncludePaths": [] # Additional paths to spell check (wildcards supported)
+  }
+```
+
+### AuditOnly
+
+Boolean - Default is False.
+If True run the test in an Audit only mode which will log all errors but instead
+of failing the build it will set the test as skipped.  This allows visibility
+into the failures without breaking the build.
+
+### IgnoreFiles
+
+This supports .gitignore file and folder matching strings including wildcards
+
+* All files will be parsed regardless but then any spelling errors found within
+  ignored files will not be reported as an error.
+* Errors in ignored files will still be output to the test results as
+  informational comments.
+
+### ExtendWords
+
+This list allows words to be added to the dictionary for the spell checker when
+this package is tested.  These follow the rules of the cspell config words field.
+
+### IgnoreStandardPaths
+
+This plugin by default will check the below standard paths.  If the package
+would like to ignore any of them list that here.
+
+```python
+[
+# C source
+"*.c",
+"*.h",
+
+# Assembly files
+"*.nasm",
+"*.asm",
+"*.masm",
+"*.s",
+
+# ACPI source language
+"*.asl",
+
+# Edk2 build files
+"*.dsc", "*.dec", "*.fdf", "*.inf",
+
+# Documentation files
+"*.md", "*.txt"
+]
+```
+
+### AdditionalIncludePaths
+
+If the package would to add additional path patterns to be included in
+spellchecking they can be defined here.
+
+## Other configuration
+
+In the cspell.base.json there are numerous other settings configured.  There is
+no support to override these on a per package basis but future features could
+make this available.  One interesting configuration option is `minWordLength`.
+Currently it is set to _5_ which means all 2,3, and 4 letter words will be
+ignored.  This helps minimize the number of technical acronyms, register names,
+and other UEFI specific values that must be ignored.
+
+## False positives
+
+The cspell dictionary is not perfect and there are cases where technical words
+or acronyms are not found in the dictionary.  There are three ways to resolve
+false positives and the choice for which method should be based on how broadly
+the word should be accepted.
+
+### CSpell Base Config file
+
+If the change should apply to all UEFI code and documentation then it should be
+added to the base config file `words` section.  The base config file is adjacent
+to this file and titled `cspell.base.json`.  This is a list of accepted words
+for all spell checking operations on all packages.
+
+### Package Config
+
+In the package `*.ci.yaml` file there is a `SpellCheck` config section.  This
+section allows files to be ignored as well as words that should be considered
+valid for all files within this package.  Add the desired words to the
+"ExtendedWords" member.
+
+### In-line File
+
+CSpell supports numerous methods to annotate your files to ignore words,
+sections, etc.  This can be found in CSpell documentation.  Suggestion here is
+to use a c-style comment at the top of the file to add words that should be
+ignored just for this file.  Obviously this has the highest maintenance cost so
+it should only be used for file unique words.
+
+``` c
+// spell-checker:ignore unenroll, word2, word3
+```
+
+or
+
+```ini
+# spell-checker:ignore unenroll, word2, word3
+```

.pytool/Plugin/SpellCheck/SpellCheck.py

@@ -0,0 +1,218 @@
+# @file SpellCheck.py
+#
+# An edk2-pytool based plugin wrapper for cspell
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+import logging
+import json
+import yaml
+from io import StringIO
+import os
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toollib.utility_functions import RunCmd
+from edk2toolext.environment.var_dict import VarDict
+from edk2toollib.gitignore_parser import parse_gitignore_lines
+from edk2toolext.environment import version_aggregator
+
+
+class SpellCheck(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that uses the cspell node module to scan the files
+    from the package being tested for spelling errors.  The plugin contains
+    the base cspell.json file then thru the configuration options other settings
+    can be changed or extended.
+
+    Configuration options:
+    "SpellCheck": {
+        "AuditOnly": False,          # Don't fail the build if there are errors.  Just log them
+        "IgnoreFiles": [],           # use gitignore syntax to ignore errors in matching files
+        "ExtendWords": [],           # words to extend to the dictionary for this package
+        "IgnoreStandardPaths": [],   # Standard Plugin defined paths that should be ignore
+        "AdditionalIncludePaths": [] # Additional paths to spell check (wildcards supported)
+    }
+    """
+
+    #
+    # A package can remove any of these using IgnoreStandardPaths
+    #
+    STANDARD_PLUGIN_DEFINED_PATHS = ("*.c", "*.h",
+                                     "*.nasm", "*.asm", "*.masm", "*.s",
+                                     "*.asl",
+                                     "*.dsc", "*.dec", "*.fdf", "*.inf",
+                                     "*.md", "*.txt"
+                                     )
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> tuple:
+        """ Provide the testcase name and classname for use in reporting
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                a tuple containing the testcase name and the classname
+                (testcasename, classname)
+                testclassname: a descriptive string for the testcase can include whitespace
+                classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+        """
+        return ("Spell check files in " + packagename, packagename + ".SpellCheck")
+
+    ##
+    # External function of plugin.  This function is used to perform the task of the CiBuild Plugin
+    #
+    #   - package is the edk2 path to package.  This means workspace/packagepath relative.
+    #   - edk2path object configured with workspace and packages path
+    #   - PkgConfig Object (dict) for the pkg
+    #   - EnvConfig Object
+    #   - Plugin Manager Instance
+    #   - Plugin Helper Obj Instance
+    #   - Junit Logger
+    #   - output_stream the StringIO output stream from this plugin via logging
+
+    def RunBuildPlugin(self, packagename, Edk2pathObj, pkgconfig, environment, PLM, PLMHelper, tc, output_stream=None):
+        Errors = []
+
+        abs_pkg_path = Edk2pathObj.GetAbsolutePathOnThisSytemFromEdk2RelativePath(
+            packagename)
+
+        if abs_pkg_path is None:
+            tc.SetSkipped()
+            tc.LogStdError("No package {0}".format(packagename))
+            return -1
+
+        # check for node
+        return_buffer = StringIO()
+        ret = RunCmd("node", "--version", outstream=return_buffer)
+        if (ret != 0):
+            tc.SetSkipped()
+            tc.LogStdError("NodeJs not installed. Test can't run")
+            logging.warning("NodeJs not installed. Test can't run")
+            return -1
+        node_version = return_buffer.getvalue().strip()  # format vXX.XX.XX
+        tc.LogStdOut(f"Node version: {node_version}")
+        version_aggregator.GetVersionAggregator().ReportVersion(
+            "NodeJs", node_version, version_aggregator.VersionTypes.INFO)
+
+        # Check for cspell
+        return_buffer = StringIO()
+        ret = RunCmd("cspell", "--version", outstream=return_buffer)
+        if (ret != 0):
+            tc.SetSkipped()
+            tc.LogStdError("cspell not installed.  Test can't run")
+            logging.warning("cspell not installed.  Test can't run")
+            return -1
+        cspell_version = return_buffer.getvalue().strip()  # format XX.XX.XX
+        tc.LogStdOut(f"CSpell version: {cspell_version}")
+        version_aggregator.GetVersionAggregator().ReportVersion(
+            "CSpell", cspell_version, version_aggregator.VersionTypes.INFO)
+
+        # copy the default as a list
+        package_relative_paths_to_spell_check = list(SpellCheck.STANDARD_PLUGIN_DEFINED_PATHS)
+
+        #
+        # Allow the ci.yaml to remove any of the above standard paths
+        #
+        if("IgnoreStandardPaths" in pkgconfig):
+            for a in pkgconfig["IgnoreStandardPaths"]:
+                if(a in package_relative_paths_to_spell_check):
+                    tc.LogStdOut(
+                        f"ignoring standard path due to ci.yaml ignore: {a}")
+                    package_relative_paths_to_spell_check.remove(a)
+                else:
+                    tc.LogStdOut(f"Invalid IgnoreStandardPaths value: {a}")
+
+        #
+        # check for any additional include paths defined by package config
+        #
+        if("AdditionalIncludePaths" in pkgconfig):
+            package_relative_paths_to_spell_check.extend(
+                pkgconfig["AdditionalIncludePaths"])
+
+        #
+        # Make the path string for cspell to check
+        #
+        relpath = os.path.relpath(abs_pkg_path)
+        cpsell_paths = " ".join(
+            # Double quote each path to defer expansion to cspell parameters
+            [f'"{relpath}/**/{x}"' for x in package_relative_paths_to_spell_check])
+
+        # Make the config file
+        config_file_path = os.path.join(
+            Edk2pathObj.WorkspacePath, "Build", packagename, "cspell_actual_config.json")
+        mydir = os.path.dirname(os.path.abspath(__file__))
+        # load as yaml so it can have comments
+        base = os.path.join(mydir, "cspell.base.yaml")
+        with open(base, "r") as i:
+            config = yaml.safe_load(i)
+
+        if("ExtendWords" in pkgconfig):
+            config["words"].extend(pkgconfig["ExtendWords"])
+        with open(config_file_path, "w") as o:
+            json.dump(config, o)  # output as json so compat with cspell
+
+        All_Ignores = []
+        # Parse the config for other ignores
+        if "IgnoreFiles" in pkgconfig:
+            All_Ignores.extend(pkgconfig["IgnoreFiles"])
+
+        # spell check all the files
+        ignore = parse_gitignore_lines(All_Ignores, os.path.join(
+            abs_pkg_path, "nofile.txt"), abs_pkg_path)
+
+        # result is a list of strings like this
+        #  C:\src\sp-edk2\edk2\FmpDevicePkg\FmpDevicePkg.dec:53:9 - Unknown word (Capule)
+        EasyFix = []
+        results = self._check_spelling(cpsell_paths, config_file_path)
+        for r in results:
+            path, _, word = r.partition(" - Unknown word ")
+            if len(word) == 0:
+                # didn't find pattern
+                continue
+
+            pathinfo = path.rsplit(":", 2)  # remove the line no info
+            if(ignore(pathinfo[0])):  # check against ignore list
+                tc.LogStdOut(f"ignoring error due to ci.yaml ignore: {r}")
+                continue
+
+            # real error
+            EasyFix.append(word.strip().strip("()"))
+            Errors.append(r)
+
+        # Log all errors tc StdError
+        for l in Errors:
+            tc.LogStdError(l.strip())
+
+        # Helper - Log the syntax needed to add these words to dictionary
+        if len(EasyFix) > 0:
+            EasyFix = sorted(set(a.lower() for a in EasyFix))
+            tc.LogStdOut("\n Easy fix:")
+            OneString = "If these are not errors add this to your ci.yaml file.\n"
+            OneString += '"SpellCheck": {\n  "ExtendWords": ['
+            for a in EasyFix:
+                tc.LogStdOut(f'\n"{a}",')
+                OneString += f'\n    "{a}",'
+            logging.info(OneString.rstrip(",") + '\n  ]\n}')
+
+        # add result to test case
+        overall_status = len(Errors)
+        if overall_status != 0:
+            if "AuditOnly" in pkgconfig and pkgconfig["AuditOnly"]:
+                # set as skipped if AuditOnly
+                tc.SetSkipped()
+                return -1
+            else:
+                tc.SetFailed("SpellCheck {0} Failed.  Errors {1}".format(
+                    packagename, overall_status), "CHECK_FAILED")
+        else:
+            tc.SetSuccess()
+        return overall_status
+
+    def _check_spelling(self, abs_file_to_check: str, abs_config_file_to_use: str) -> []:
+        output = StringIO()
+        ret = RunCmd(
+            "cspell", f"--config {abs_config_file_to_use} {abs_file_to_check}", outstream=output)
+        if ret == 0:
+            return []
+        else:
+            return output.getvalue().strip().splitlines()

.pytool/Plugin/SpellCheck/SpellCheck_plug_in.yaml

@@ -0,0 +1,11 @@
+## @file
+# CiBuildPlugin used to check spelling
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "Spell Check Test",
+  "module": "SpellCheck"
+}

.pytool/Plugin/SpellCheck/cspell.base.yaml

@@ -0,0 +1,183 @@
+## @file
+# CSpell configuration
+#
+# Copyright (c) Microsoft Corporation
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+    "version": "0.1",
+    "language": "en",
+    "dictionaries": [
+        "companies ",
+        "softwareTerms",
+        "python",
+        "cpp"
+    ],
+    "ignorePaths": [
+        "*.pdb",
+        "**/*_extdep/**",
+        "*.pdf",
+        "*.exe",
+        "*.jpg"
+    ],
+    "minWordLength": 5,
+    "allowCompoundWords": false,
+    "maxNumberOfProblems": 200,
+    "maxDuplicateProblems": 200,
+    "ignoreWords": [
+        "muchange"
+    ],
+    "words": [
+        "MTRRs",
+        "Microarchitecture",
+        "Goldmont",
+        "cpuid",
+        "mwait",
+        "cstate",
+        "smram",
+        "scrtm",
+        "smbus",
+        "selftest",
+        "socket",
+        "MMRAM",
+        "qword",
+        "ENDBR",
+        "SMBASE",
+        "FXSAVE",
+        "FXRSTOR",
+        "RDRAND",
+        "IOAPIC",
+        "ATAPI",
+        "movsb",
+        "iretw",
+        "XENSTORE",
+        "cdrom",
+        "oprom",
+        "oproms",
+        "varstore",
+        "EKU",
+        "ascii",
+        "nmake",
+        "NVDIMM",
+        "nasmb",
+        "Mtftp",
+        "Hypercall",
+        "hypercalls",
+        "IOMMU",
+        "QEMU",
+        "qemus",
+        "OVMF",
+        "tiano",
+        "tianocore",
+        "edkii",
+        "coreboot",
+        "uefipayload",
+        "bootloader",
+        "bootloaders",
+        "mdepkg",
+        "skuid",
+        "dxefv",
+        "toolchain",
+        "libraryclass",
+        "preboot",
+        "pythonpath",
+        "cygpath",
+        "nuget",
+        "basetools",
+        "prepi",
+        "OPTEE",
+        "stringid",
+        "peims",
+        "memmap",
+        "guids",
+        "uuids",
+        "smbios",
+        "certdb",
+        "certdbv",
+        "EfiSigList",
+        "depex",
+        "IHANDLE",
+        "Virtio",
+        "Mbytes",
+        "Citrix",
+        "initrd",
+        "semihost",
+        "Semihosting",
+        "Trustzone",
+        "Fastboot",
+        "framebuffer",
+        "genfw",
+        "TTYTERM",
+        "miniport",
+        "LFENCE",
+        "PCANSI",
+        "submodule",
+        "submodules",
+        "brotli",
+        "PCCTS",
+        "softfloat",
+        "whitepaper",
+        "ACPICA",
+        "plugfest",
+        "bringup",
+        "formset", #VFR
+        "ideqvallist",
+        "numberof",
+        "oneof",
+        "endformset",
+        "endnumeric",
+        "endoneof",
+        "disableif",
+        "guidid",
+        "classguid",
+        "efivarstore",
+        "formsetguid",
+        "formid",
+        "suppressif",
+        "grayoutif",
+        "ideqval",
+        "endform",
+        "endcheckbox",
+        "questionid",
+        "questionref",
+        "enddate",
+        "endstring",
+        "guidop",
+        "endguidop",
+        "langdef",
+        "dynamicex",
+        "tokenspace",
+        "tokenguid",
+        "pcd's", #seems like cspell bug
+        "peim's",
+        "autogen",
+        "Disasm",
+        "Torito",
+        "SRIOV",
+        "MRIOV",
+        "UARTs",
+        "Consplitter", # common module in UEFI
+        "FIFOs",
+        "ACPINVS",
+        "Endof",  # due to of not being uppercase
+        "bootability",
+        "Sdhci",
+        "inmodule",
+        "RISCV",
+        "edksetup",
+        "iscsi",
+        "nvdata",
+        "pytools",
+        "NTDDI",
+        "Wnonportable",
+        "CLANGPDB",
+        "nologo",
+        "lldmap",
+        "ASMLINK",
+        "NODEFAULTLIB",
+        "vcruntimed",
+        "ucrtd",
+        "msvcrtd",
+        "XIPFLAGS"
+    ]
+}

.pytool/Plugin/UncrustifyCheck/Readme.md

@@ -0,0 +1,120 @@
+# UncrustifyCheck Plugin
+
+This CiBuildPlugin scans all the files in a given package and checks for coding standard compliance issues.
+
+This plugin is enabled by default. If a package would like to prevent the plugin from reporting errors, it can do
+so by enabling [`AuditOnly`](#auditonly) mode.
+
+This plugin requires the directory containing the Uncrustify executable that should be used for this plugin to
+be specified in an environment variable named `UNCRUSTIFY_CI_PATH`. This unique variable name is used to avoid confusion
+with other paths to Uncrustify which might not be the expected build for use by this plugin.
+
+By default, an Uncrustify configuration file named "uncrustify.cfg" located in the same directory as the plugin is
+used. The value can be overridden to a package-specific path with the `ConfigFilePath` configuration file option.
+
+* Uncrustify source code and documentation: https://github.com/uncrustify/uncrustify
+* Project Mu Uncrustify fork source code and documentation: https://dev.azure.com/projectmu/Uncrustify
+
+## Files Checked in a Package
+
+By default, this plugin will discover all files in the package with the following default paths:
+
+```python
+[
+# C source
+"*.c",
+"*.h"
+]
+```
+
+From this list of files, any files ignored by Git or residing in a Git submodule will be removed. If Git is not
+found, submodules are not found, or ignored files are not found no changes are made to the list of discovered files.
+
+To control the paths checked in a given package, review the configuration options described in this file.
+
+## Configuration
+
+The plugin can be configured with a few optional configuration options.
+
+``` yaml
+  "UncrustifyCheck": {
+      "AdditionalIncludePaths": [], # Additional paths to check formatting (wildcards supported).
+      "AuditOnly": False,           # Don't fail the build if there are errors.  Just log them.
+      "ConfigFilePath": "",         # Custom path to an Uncrustify config file.
+      "IgnoreStandardPaths": [],    # Standard Plugin defined paths that should be ignored.
+      "OutputFileDiffs": False,     # Output chunks of formatting diffs in the test case log.
+                                    # This can significantly slow down the plugin on very large packages.
+      "SkipGitExclusions": False    # Don't exclude git ignored files and files in git submodules.
+  }
+```
+
+### `AdditionalIncludePaths`
+
+A package configuration file can specify any additional paths to be included with this option.
+
+At this time, it is recommended all files run against the plugin be written in the C or C++ language.
+
+### `AuditOnly`
+
+`Boolean` - Default is `False`.
+
+If `True`, run the test in an "audit only mode" which will log all errors but instead of failing the build, it will set
+the test as skipped. This allows visibility into the failures without breaking the build.
+
+### `ConfigFilePath`
+
+`String` - Default is `"uncrustify.cfg"`
+
+When specified in the config file, this is a package relative path to the Uncrustify configuration file.
+
+### `IgnoreStandardPaths`
+
+This plugin by default will check the below standard paths. A package configuration file can specify any of these paths
+to be ignored.
+
+```python
+[
+# C source
+"*.c",
+"*.h"
+]
+```
+
+### `OutputFileDiffs`
+
+`Boolean` - Default is `False`.
+
+If `True`, output diffs of formatting changes into the test case log. This is helpful to exactly understand what changes
+need to be made to the source code in order to fix a coding standard compliance issue.
+
+Note that calculating the file diffs on a very large set of of results (e.g. >100 files) can significantly slow down
+plugin execution.
+
+### `SkipGitExclusions`
+
+`Boolean` - Default is `False`.
+
+By default, files in paths matched in a .gitignore file or a recognized git submodule are excluded. If this option
+is `True`, the plugin will not attempt to recognize these files and exclude them.
+
+## High-Level Plugin Operation
+
+This plugin generates two main sets of temporary files:
+
+  1. A working directory in the directory `Build/.pytool/Plugin/Uncrustify`
+  2. For each source file with formatting errors, a sibling file with the `.uncrustify_plugin` extension
+
+The working directory contains temporary files unique to operation of the plugin. All of these files are removed on
+exit of the plugin including successful or unsuccessful execution (such as a Python exception occurring). If for any
+reason, any files in the package exist prior to running the plugin with the `.uncrustify_plugin` extension, the plugin
+will inform the user to remove these files and exit before running Uncrustify. This is to ensure the accuracy of the
+results reported from each execution instance of the plugin.
+
+The plugin determines the list of relevant files to check with Uncrustify and then invokes Uncrustify with that file
+list. For any files not compliant to the configuration file provided, Uncrustify will generate a corresponding file
+with the `.uncrustify_plugin` extension. The plugin discovers all of these files. If any such files are present, this
+indicates a formatting issue was found and the test is marked failed (unless `AuditOnly` mode is enabled).
+
+The test case log will contain a report of which files failed to format properly, allowing the user to run Uncrustify
+against the file locally to fix the issue. If the `OutputFileDiffs` configuration option is set to `True`, the plugin
+will output diff chunks for all code formatting issues in the test case log.

.pytool/Plugin/UncrustifyCheck/UncrustifyCheck.py

@@ -0,0 +1,618 @@
+# @file UncrustifyCheck.py
+#
+# An edk2-pytool based plugin wrapper for Uncrustify
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+import configparser
+import difflib
+import errno
+import logging
+import os
+import pathlib
+import shutil
+import timeit
+from edk2toolext.environment import version_aggregator
+from edk2toolext.environment.plugin_manager import PluginManager
+from edk2toolext.environment.plugintypes.ci_build_plugin import ICiBuildPlugin
+from edk2toolext.environment.plugintypes.uefi_helper_plugin import HelperFunctions
+from edk2toolext.environment.var_dict import VarDict
+from edk2toollib.log.junit_report_format import JunitReportTestCase
+from edk2toollib.uefi.edk2.path_utilities import Edk2Path
+from edk2toollib.utility_functions import  RunCmd
+from io import StringIO
+from typing import Any, Dict, List, Tuple
+
+#
+# Provide more user friendly messages for certain scenarios
+#
+class UncrustifyException(Exception):
+    def __init__(self, message, exit_code):
+        super().__init__(message)
+        self.exit_code = exit_code
+
+
+class UncrustifyAppEnvVarNotFoundException(UncrustifyException):
+    def __init__(self, message):
+        super().__init__(message, -101)
+
+
+class UncrustifyAppVersionErrorException(UncrustifyException):
+    def __init__(self, message):
+        super().__init__(message, -102)
+
+
+class UncrustifyAppExecutionException(UncrustifyException):
+    def __init__(self, message):
+        super().__init__(message, -103)
+
+
+class UncrustifyStalePluginFormattedFilesException(UncrustifyException):
+    def __init__(self, message):
+        super().__init__(message, -120)
+
+
+class UncrustifyInputFileCreationErrorException(UncrustifyException):
+    def __init__(self, message):
+        super().__init__(message, -121)
+
+class UncrustifyInvalidIgnoreStandardPathsException(UncrustifyException):
+    def __init__(self, message):
+        super().__init__(message, -122)
+
+class UncrustifyGitIgnoreFileException(UncrustifyException):
+    def __init__(self, message):
+        super().__init__(message, -140)
+
+
+class UncrustifyGitSubmoduleException(UncrustifyException):
+    def __init__(self, message):
+        super().__init__(message, -141)
+
+
+class UncrustifyCheck(ICiBuildPlugin):
+    """
+    A CiBuildPlugin that uses Uncrustify to check the source files in the
+    package being tested for coding standard issues.
+
+    By default, the plugin runs against standard C source file extensions but
+    its configuration can be modified through its configuration file.
+
+    Configuration options:
+    "UncrustifyCheck": {
+        "AdditionalIncludePaths": [], # Additional paths to check formatting (wildcards supported).
+        "AuditOnly": False,           # Don't fail the build if there are errors.  Just log them.
+        "ConfigFilePath": "",         # Custom path to an Uncrustify config file.
+        "IgnoreStandardPaths": [],    # Standard Plugin defined paths that should be ignored.
+        "OutputFileDiffs": False,     # Output chunks of formatting diffs in the test case log.
+                                      # This can significantly slow down the plugin on very large packages.
+        "SkipGitExclusions": False    # Don't exclude git ignored files and files in git submodules.
+    }
+    """
+
+    #
+    # By default, use an "uncrustify.cfg" config file in the plugin directory
+    # A package can override this path via "ConfigFilePath"
+    #
+    # Note: Values specified via "ConfigFilePath" are relative to the package
+    #
+    DEFAULT_CONFIG_FILE_PATH = os.path.join(
+        pathlib.Path(__file__).parent.resolve(), "uncrustify.cfg")
+
+    #
+    # The extension used for formatted files produced by this plugin
+    #
+    FORMATTED_FILE_EXTENSION = ".uncrustify_plugin"
+
+    #
+    # A package can add any additional paths with "AdditionalIncludePaths"
+    # A package can remove any of these paths with "IgnoreStandardPaths"
+    #
+    STANDARD_PLUGIN_DEFINED_PATHS = ("*.c", "*.h")
+
+    #
+    # The Uncrustify application path should set in this environment variable
+    #
+    UNCRUSTIFY_PATH_ENV_KEY = "UNCRUSTIFY_CI_PATH"
+
+    def GetTestName(self, packagename: str, environment: VarDict) -> Tuple:
+        """ Provide the testcase name and classname for use in reporting
+
+            Args:
+              packagename: string containing name of package to build
+              environment: The VarDict for the test to run in
+            Returns:
+                A tuple containing the testcase name and the classname
+                (testcasename, classname)
+                testclassname: a descriptive string for the testcase can include whitespace
+                classname: should be patterned <packagename>.<plugin>.<optionally any unique condition>
+        """
+        return ("Check file coding standard compliance in " + packagename, packagename + ".UncrustifyCheck")
+
+    def RunBuildPlugin(self, package_rel_path: str, edk2_path: Edk2Path, package_config: Dict[str, List[str]], environment_config: Any, plugin_manager: PluginManager, plugin_manager_helper: HelperFunctions, tc: JunitReportTestCase, output_stream=None) -> int:
+        """
+        External function of plugin. This function is used to perform the task of the CiBuild Plugin.
+
+        Args:
+          - package_rel_path: edk2 workspace relative path to the package
+          - edk2_path: Edk2Path object with workspace and packages paths
+          - package_config: Dictionary with the package configuration
+          - environment_config: Environment configuration
+          - plugin_manager: Plugin Manager Instance
+          - plugin_manager_helper: Plugin Manager Helper Instance
+          - tc: JUnit test case
+          - output_stream: The StringIO output stream from this plugin (logging)
+
+        Returns
+          >0 : Number of errors found
+          0  : Passed successfully
+          -1 : Skipped for missing prereq
+        """
+        try:
+            # Initialize plugin and check pre-requisites.
+            self._initialize_environment_info(
+                package_rel_path, edk2_path, package_config, tc)
+            self._initialize_configuration()
+            self._check_for_preexisting_formatted_files()
+
+            # Log important context information.
+            self._log_uncrustify_app_info()
+
+            # Get template file contents if specified
+            self._get_template_file_contents()
+
+            # Create meta input files & directories
+            self._create_temp_working_directory()
+            self._create_uncrustify_file_list_file()
+
+            self._run_uncrustify()
+
+            # Post-execution actions.
+            self._process_uncrustify_results()
+
+        except UncrustifyException as e:
+            self._tc.LogStdError(
+                f"Uncrustify error {e.exit_code}. Details:\n\n{str(e)}")
+            logging.warning(
+                f"Uncrustify error {e.exit_code}. Details:\n\n{str(e)}")
+            return -1
+        else:
+            if self._formatted_file_error_count > 0:
+                if self._audit_only_mode:
+                    logging.info(
+                        "Setting test as skipped since AuditOnly is enabled")
+                    self._tc.SetSkipped()
+                    return -1
+                else:
+                    self._tc.SetFailed(
+                        f"{self._plugin_name} failed due to {self._formatted_file_error_count} incorrectly formatted files.", "CHECK_FAILED")
+            else:
+                self._tc.SetSuccess()
+            return self._formatted_file_error_count
+        finally:
+            self._cleanup_temporary_formatted_files()
+            self._cleanup_temporary_directory()
+
+    def _initialize_configuration(self) -> None:
+        """
+        Initializes plugin configuration.
+        """
+        self._initialize_app_info()
+        self._initialize_config_file_info()
+        self._initialize_file_to_format_info()
+        self._initialize_test_case_output_options()
+
+    def _check_for_preexisting_formatted_files(self) -> None:
+        """
+        Checks if any formatted files from prior execution are present.
+
+        Existence of such files is an unexpected condition. This might result
+        from an error that occurred during a previous run or a premature exit from a debug scenario. In any case, the package should be clean before starting a new run.
+        """
+        pre_existing_formatted_file_count = len(
+            [str(path.resolve()) for path in pathlib.Path(self._abs_package_path).rglob(f'*{UncrustifyCheck.FORMATTED_FILE_EXTENSION}')])
+
+        if pre_existing_formatted_file_count > 0:
+            raise UncrustifyStalePluginFormattedFilesException(
+                f"{pre_existing_formatted_file_count} formatted files already exist. To prevent overwriting these files, please remove them before running this plugin.")
+
+    def _cleanup_temporary_directory(self) -> None:
+        """
+        Cleans up the temporary directory used for this execution instance.
+
+        This removes the directory and all files created during this instance.
+        """
+        if hasattr(self, '_working_dir'):
+            self._remove_tree(self._working_dir)
+
+    def _cleanup_temporary_formatted_files(self) -> None:
+        """
+        Cleans up the temporary formmatted files produced by Uncrustify.
+
+        This will recursively remove all formatted files generated by Uncrustify
+        during this execution instance.
+        """
+        if hasattr(self, '_abs_package_path'):
+            formatted_files = [str(path.resolve()) for path in pathlib.Path(
+                self._abs_package_path).rglob(f'*{UncrustifyCheck.FORMATTED_FILE_EXTENSION}')]
+
+            for formatted_file in formatted_files:
+                os.remove(formatted_file)
+
+    def _create_temp_working_directory(self) -> None:
+        """
+        Creates the temporary directory used for this execution instance.
+        """
+        self._working_dir = os.path.join(
+            self._abs_workspace_path, "Build", ".pytool", "Plugin", f"{self._plugin_name}")
+
+        try:
+            pathlib.Path(self._working_dir).mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            raise UncrustifyInputFileCreationErrorException(
+                f"Error creating plugin directory {self._working_dir}.\n\n{repr(e)}.")
+
+    def _create_uncrustify_file_list_file(self) -> None:
+        """
+        Creates the file with the list of source files for Uncrustify to process.
+        """
+        self._app_input_file_path = os.path.join(
+            self._working_dir, "uncrustify_file_list.txt")
+
+        with open(self._app_input_file_path, 'w', encoding='utf8') as f:
+            f.writelines(f"\n".join(self._abs_file_paths_to_format))
+
+    def _execute_uncrustify(self) -> None:
+        """
+        Executes Uncrustify with the initialized configuration.
+        """
+        output = StringIO()
+        self._app_exit_code = RunCmd(
+            self._app_path,
+            f"-c {self._app_config_file} -F {self._app_input_file_path} --if-changed --suffix {UncrustifyCheck.FORMATTED_FILE_EXTENSION}", outstream=output)
+        self._app_output = output.getvalue().strip().splitlines()
+
+    def _get_git_ignored_paths(self) -> List[str]:
+        """"
+        Returns a list of file absolute path strings to all files ignored in this git repository.
+
+        If git is not found, an empty list will be returned.
+        """
+        if not shutil.which("git"):
+            logging.warn(
+                "Git is not found on this system. Git submodule paths will not be considered.")
+            return []
+
+        outstream_buffer = StringIO()
+        exit_code = RunCmd("git", "ls-files --other",
+                           workingdir=self._abs_workspace_path, outstream=outstream_buffer, logging_level=logging.NOTSET)
+        if (exit_code != 0):
+            raise UncrustifyGitIgnoreFileException(
+                f"An error occurred reading git ignore settings. This will prevent Uncrustify from running against the expected set of files.")
+
+        # Note: This will potentially be a large list, but at least sorted
+        return outstream_buffer.getvalue().strip().splitlines()
+
+    def _get_git_submodule_paths(self) -> List[str]:
+        """
+        Returns a list of directory absolute path strings to the root of each submodule in the workspace repository.
+
+        If git is not found, an empty list will be returned.
+        """
+        if not shutil.which("git"):
+            logging.warn(
+                "Git is not found on this system. Git submodule paths will not be considered.")
+            return []
+
+        if os.path.isfile(os.path.join(self._abs_workspace_path, ".gitmodules")):
+            logging.info(
+                f".gitmodules file found. Excluding submodules in {self._package_name}.")
+
+            outstream_buffer = StringIO()
+            exit_code = RunCmd("git", "config --file .gitmodules --get-regexp path", workingdir=self._abs_workspace_path, outstream=outstream_buffer, logging_level=logging.NOTSET)
+            if (exit_code != 0):
+                raise UncrustifyGitSubmoduleException(
+                    f".gitmodule file detected but an error occurred reading the file. Cannot proceed with unknown submodule paths.")
+
+            submodule_paths = []
+            for line in outstream_buffer.getvalue().strip().splitlines():
+                submodule_paths.append(
+                    os.path.normpath(os.path.join(self._abs_workspace_path, line.split()[1])))
+
+            return submodule_paths
+        else:
+            return []
+
+    def _get_template_file_contents(self) -> None:
+        """
+        Gets the contents of Uncrustify template files if they are specified
+        in the Uncrustify configuration file.
+        """
+
+        self._file_template_contents = None
+        self._func_template_contents = None
+
+        # Allow no value to allow "set" statements in the config file which do
+        # not specify value assignment
+        parser = configparser.ConfigParser(allow_no_value=True)
+        with open(self._app_config_file, 'r') as cf:
+            parser.read_string("[dummy_section]\n" + cf.read())
+
+        try:
+            file_template_name = parser["dummy_section"]["cmt_insert_file_header"]
+
+            file_template_path = pathlib.Path(file_template_name)
+
+            if not file_template_path.is_file():
+                file_template_path = pathlib.Path(os.path.join(self._plugin_path, file_template_name))
+                self._file_template_contents = file_template_path.read_text()
+        except KeyError:
+            logging.warn("A file header template is not specified in the config file.")
+        except FileNotFoundError:
+            logging.warn("The specified file header template file was not found.")
+        try:
+            func_template_name = parser["dummy_section"]["cmt_insert_func_header"]
+
+            func_template_path = pathlib.Path(func_template_name)
+
+            if not func_template_path.is_file():
+                func_template_path = pathlib.Path(os.path.join(self._plugin_path, func_template_name))
+                self._func_template_contents = func_template_path.read_text()
+        except KeyError:
+            logging.warn("A function header template is not specified in the config file.")
+        except FileNotFoundError:
+            logging.warn("The specified function header template file was not found.")
+
+    def _initialize_app_info(self) -> None:
+        """
+        Initialize Uncrustify application information.
+
+        This function will determine the application path and version.
+        """
+        # Verify Uncrustify is specified in the environment.
+        if UncrustifyCheck.UNCRUSTIFY_PATH_ENV_KEY not in os.environ:
+            raise UncrustifyAppEnvVarNotFoundException(
+                f"Uncrustify environment variable {UncrustifyCheck.UNCRUSTIFY_PATH_ENV_KEY} is not present.")
+
+        self._app_path = shutil.which('uncrustify', path=os.environ[UncrustifyCheck.UNCRUSTIFY_PATH_ENV_KEY])
+
+        if self._app_path is None:
+            raise FileNotFoundError(
+                errno.ENOENT, os.strerror(errno.ENOENT), self._app_path)
+
+        self._app_path = os.path.normcase(os.path.normpath(self._app_path))
+
+        if not os.path.isfile(self._app_path):
+            raise FileNotFoundError(
+                errno.ENOENT, os.strerror(errno.ENOENT), self._app_path)
+
+        # Verify Uncrustify is present at the expected path.
+        return_buffer = StringIO()
+        ret = RunCmd(self._app_path, "--version", outstream=return_buffer)
+        if (ret != 0):
+            raise UncrustifyAppVersionErrorException(
+                f"Error occurred executing --version: {ret}.")
+
+        # Log Uncrustify version information.
+        self._app_version = return_buffer.getvalue().strip()
+        self._tc.LogStdOut(f"Uncrustify version: {self._app_version}")
+        version_aggregator.GetVersionAggregator().ReportVersion(
+            "Uncrustify", self._app_version, version_aggregator.VersionTypes.INFO)
+
+    def _initialize_config_file_info(self) -> None:
+        """
+        Initialize Uncrustify configuration file info.
+
+        The config file path is relative to the package root.
+        """
+        self._app_config_file = UncrustifyCheck.DEFAULT_CONFIG_FILE_PATH
+        if "ConfigFilePath" in self._package_config:
+            self._app_config_file = self._package_config["ConfigFilePath"].strip()
+
+            self._app_config_file = os.path.normpath(
+                os.path.join(self._abs_package_path, self._app_config_file))
+
+        if not os.path.isfile(self._app_config_file):
+            raise FileNotFoundError(
+                errno.ENOENT, os.strerror(errno.ENOENT), self._app_config_file)
+
+    def _initialize_environment_info(self, package_rel_path: str, edk2_path: Edk2Path, package_config: Dict[str, List[str]], tc: JunitReportTestCase) -> None:
+        """
+        Initializes plugin environment information.
+        """
+        self._abs_package_path = edk2_path.GetAbsolutePathOnThisSytemFromEdk2RelativePath(
+            package_rel_path)
+        self._abs_workspace_path = edk2_path.WorkspacePath
+        self._package_config = package_config
+        self._package_name = os.path.basename(
+            os.path.normpath(package_rel_path))
+        self._plugin_name = self.__class__.__name__
+        self._plugin_path = os.path.dirname(os.path.realpath(__file__))
+        self._rel_package_path = package_rel_path
+        self._tc = tc
+
+    def _initialize_file_to_format_info(self) -> None:
+        """
+        Forms the list of source files for Uncrustify to process.
+        """
+        # Create a list of all the package relative file paths in the package to run against Uncrustify.
+        rel_file_paths_to_format = list(
+            UncrustifyCheck.STANDARD_PLUGIN_DEFINED_PATHS)
+
+        # Allow the ci.yaml to remove any of the pre-defined standard paths
+        if "IgnoreStandardPaths" in self._package_config:
+            for a in self._package_config["IgnoreStandardPaths"]:
+                if a.strip() in rel_file_paths_to_format:
+                    self._tc.LogStdOut(
+                        f"Ignoring standard path due to ci.yaml ignore: {a}")
+                    rel_file_paths_to_format.remove(a.strip())
+                else:
+                    raise UncrustifyInvalidIgnoreStandardPathsException(f"Invalid IgnoreStandardPaths value: {a}")
+
+        # Allow the ci.yaml to specify additional include paths for this package
+        if "AdditionalIncludePaths" in self._package_config:
+            rel_file_paths_to_format.extend(
+                self._package_config["AdditionalIncludePaths"])
+
+        self._abs_file_paths_to_format = []
+        for path in rel_file_paths_to_format:
+            self._abs_file_paths_to_format.extend(
+                [str(path.resolve()) for path in pathlib.Path(self._abs_package_path).rglob(path)])
+
+        if not "SkipGitExclusions" in self._package_config or not self._package_config["SkipGitExclusions"]:
+            # Remove files ignored by git
+            logging.info(
+                f"{self._package_name} file count before git ignore file exclusion: {len(self._abs_file_paths_to_format)}")
+
+            ignored_paths = self._get_git_ignored_paths()
+            self._abs_file_paths_to_format = list(
+                set(self._abs_file_paths_to_format).difference(ignored_paths))
+
+            logging.info(
+                f"{self._package_name} file count after git ignore file exclusion: {len(self._abs_file_paths_to_format)}")
+
+            # Remove files in submodules
+            logging.info(
+                f"{self._package_name} file count before submodule exclusion: {len(self._abs_file_paths_to_format)}")
+
+            submodule_paths = tuple(self._get_git_submodule_paths())
+            for path in submodule_paths:
+                logging.info(f"  submodule path: {path}")
+
+            self._abs_file_paths_to_format = [
+                f for f in self._abs_file_paths_to_format if not f.startswith(submodule_paths)]
+
+            logging.info(
+                f"{self._package_name} file count after submodule exclusion: {len(self._abs_file_paths_to_format)}")
+
+        # Sort the files for more consistent results
+        self._abs_file_paths_to_format.sort()
+
+    def _initialize_test_case_output_options(self) -> None:
+        """
+        Initializes options that influence test case output.
+        """
+        self._audit_only_mode = False
+        self._output_file_diffs = False
+
+        if "AuditOnly" in self._package_config and self._package_config["AuditOnly"]:
+            self._audit_only_mode = True
+
+        if "OutputFileDiffs" in self._package_config and self._package_config["OutputFileDiffs"]:
+            self._output_file_diffs = True
+
+    def _log_uncrustify_app_info(self) -> None:
+        """
+        Logs Uncrustify application information.
+        """
+        self._tc.LogStdOut(f"Found Uncrustify at {self._app_path}")
+        self._tc.LogStdOut(f"Uncrustify version: {self._app_version}")
+        self._tc.LogStdOut('\n')
+        logging.info(f"Found Uncrustify at {self._app_path}")
+        logging.info(f"Uncrustify version: {self._app_version}")
+        logging.info('\n')
+
+    def _process_uncrustify_results(self) -> None:
+        """
+        Process the results from Uncrustify.
+
+        Determines whether formatting errors are present and logs failures.
+        """
+        formatted_files = [str(path.resolve()) for path in pathlib.Path(
+            self._abs_package_path).rglob(f'*{UncrustifyCheck.FORMATTED_FILE_EXTENSION}')]
+
+        self._formatted_file_error_count = len(formatted_files)
+
+        if self._formatted_file_error_count > 0:
+            self._tc.LogStdError("Files with formatting errors:\n")
+
+            if self._output_file_diffs:
+                logging.info("Calculating file diffs. This might take a while...")
+
+        for formatted_file in formatted_files:
+            pre_formatted_file = formatted_file[:-
+                                                len(UncrustifyCheck.FORMATTED_FILE_EXTENSION)]
+            logging.error(pre_formatted_file)
+
+            if (self._output_file_diffs or
+                    self._file_template_contents is not None or
+                    self._func_template_contents is not None):
+                self._tc.LogStdError(
+                    f"Formatting errors in {os.path.relpath(pre_formatted_file, self._abs_package_path)}\n")
+
+                with open(formatted_file) as ff:
+                    formatted_file_text = ff.read()
+
+                    if (self._file_template_contents is not None and
+                            self._file_template_contents in formatted_file_text):
+                        self._tc.LogStdError(f"File header is missing in {os.path.relpath(pre_formatted_file, self._abs_package_path)}\n")
+
+                    if (self._func_template_contents is not None and
+                            self._func_template_contents in formatted_file_text):
+                        self._tc.LogStdError(f"A function header is missing in {os.path.relpath(pre_formatted_file, self._abs_package_path)}\n")
+
+                    if self._output_file_diffs:
+                        with open(pre_formatted_file) as pf:
+                            pre_formatted_file_text = pf.read()
+
+                        for line in difflib.unified_diff(pre_formatted_file_text.split('\n'), formatted_file_text.split('\n'), fromfile=pre_formatted_file, tofile=formatted_file, n=3):
+                            self._tc.LogStdError(line)
+
+                        self._tc.LogStdError('\n')
+            else:
+                self._tc.LogStdError(pre_formatted_file)
+
+    def _remove_tree(self, dir_path: str, ignore_errors: bool = False) -> None:
+        """
+        Helper for removing a directory. Over time there have been
+        many private implementations of this due to reliability issues in the
+        shutil implementations. To consolidate on a single function this helper is added.
+
+        On error try to change file attributes. Also add retry logic.
+
+        This function is temporarily borrowed from edk2toollib.utility_functions
+        since the version used in edk2 is not recent enough to include the
+        function.
+
+        This function should be replaced by "RemoveTree" when it is available.
+
+        Args:
+          - dir_path: Path to directory to remove.
+          - ignore_errors: Whether to ignore errors during removal
+        """
+
+        def _remove_readonly(func, path, _):
+            """
+            Private function to attempt to change permissions on file/folder being deleted.
+            """
+            os.chmod(path, os.stat.S_IWRITE)
+            func(path)
+
+        for _ in range(3):  # retry up to 3 times
+            try:
+                shutil.rmtree(dir_path, ignore_errors=ignore_errors, onerror=_remove_readonly)
+            except OSError as err:
+                logging.warning(f"Failed to fully remove {dir_path}: {err}")
+            else:
+                break
+        else:
+            raise RuntimeError(f"Failed to remove {dir_path}")
+
+    def _run_uncrustify(self) -> None:
+        """
+        Runs Uncrustify for this instance of plugin execution.
+        """
+        logging.info("Executing Uncrustify. This might take a while...")
+        start_time = timeit.default_timer()
+        self._execute_uncrustify()
+        end_time = timeit.default_timer() - start_time
+
+        execution_summary = f"Uncrustify executed against {len(self._abs_file_paths_to_format)} files in {self._package_name} in {end_time:.2f} seconds.\n"
+
+        self._tc.LogStdOut(execution_summary)
+        logging.info(execution_summary)
+
+        if self._app_exit_code != 0 and self._app_exit_code != 1:
+            raise UncrustifyAppExecutionException(
+                f"Error {str(self._app_exit_code)} returned from Uncrustify:\n\n{str(self._app_output)}")

.pytool/Plugin/UncrustifyCheck/default_file_header.txt

@@ -0,0 +1,9 @@
+/** @file
+  Brief description of the file's purpose.
+
+  Detailed description of the file's contents and other useful
+  information for a person viewing the file for the first time.
+
+  <<Copyright>>
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+**/

.pytool/Plugin/UncrustifyCheck/default_function_header.txt

@@ -0,0 +1,15 @@
+/**
+  Brief description of this function's purpose.
+
+  Follow it immediately with the detailed description.
+
+  @param[in]      Arg1  Description of Arg1.
+  @param[in]      Arg2  Description of Arg2 This is complicated and requires
+                        multiple lines to describe.
+  @param[out]     Arg3  Description of Arg3.
+  @param[in, out] Arg4  Description of Arg4.
+
+  @retval VAL_ONE  Description of what VAL_ONE signifies.
+  @retval OTHER    This is the only other return value. If there were other
+                   return values, they would be listed.
+**/

.pytool/Plugin/UncrustifyCheck/uncrustify.cfg

@@ -0,0 +1,462 @@
+## @file
+# Uncrustify Configuration File for EDK II C Code
+#
+# Coding Standard: https://edk2-docs.gitbook.io/edk-ii-c-coding-standards-specification/
+#
+# This configuration file is meant to be a "best attempt" to align with the
+# definitions in the EDK II C Coding Standards Specification.
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+
+# Force UTF-8 encoding (no UTF-16)
+enable_digraphs                 = false
+utf8_byte                       = false
+utf8_force                      = true
+
+# Code width / line splitting
+#code_width                      =120     # TODO: This causes non-deterministic behaviour in some cases when code wraps
+ls_code_width                   =false
+ls_for_split_full               =true
+ls_func_split_full              =true
+pos_comma                       =trail
+
+# 5.1.7  All files must end with CRLF
+newlines                        = crlf
+
+# 5.1.2 Do not use tab characters
+
+cmt_convert_tab_to_spaces       = true      # Whether to convert all tabs to spaces in comments. If false, tabs in
+                                            # comments are left alone, unless used for indenting.
+indent_columns                  = 2         # Number of spaces for indentation
+indent_with_tabs                = 0         # Do not use TAB characters
+string_replace_tab_chars        = true      # Replace TAB with SPACE
+                                            # Note: This will break .robot files but is needed for edk2 style
+
+# 5.2.1.1 There shall be only one statement on a line (statement ends with ;)
+nl_multi_line_cond              = true      # Add a newline between ')' and '{' if the ')' is on a different line than
+                                            # the if/for/etc.
+nl_after_semicolon              = true      # Whether to add a newline after semicolons, except in 'for' statements.
+
+# 5.2.1.3 An open brace '{' goes on the same line as the closing parenthesis ')' of simple predicate expressions
+mod_full_brace_do               = add       # Add or remove braces on a single-line 'do' statement.
+mod_full_brace_for              = add
+mod_full_brace_function         = add       # Add or remove braces on a single-line function definition.
+mod_full_brace_if               = add       # Add or remove braces on a single-line 'if' statement. Braces will not be
+                                            # removed if the braced statement contains an 'else'.
+mod_full_brace_if_chain         = false
+mod_full_brace_while            = add
+
+# 5.2.1.4 A close brace '}' always goes at the beginning of the last line of the body
+eat_blanks_after_open_brace     = true
+eat_blanks_before_close_brace   = true      # Whether to remove blank lines before '}'.
+
+# 5.2.2.2 Always put space before and after binary operators.
+sp_assign                       = add       # Add or remove space around assignment operator '=', '+=', etc.
+sp_assign_default               = add
+sp_bool                         = add       # Add or remove space around boolean operators '&&' and '||'.
+sp_compare                      = add       # Add or remove space around compare operator '<', '>', '==', etc.
+
+# 5.2.2.3 Do not put space between unary operators and their object
+sp_addr                         = remove    # A or remove space after the '&' (address-of) unary operator.
+sp_incdec                       = remove    # Add or remove space between '++' and '--' the word to which it is being
+                                            # applied, as in '(--x)' or 'y++;'.
+sp_inv                          = remove    # Add or remove space after the '~' (invert) unary operator.
+sp_not                          = remove    # Add or remove space after the '!' (not) unary operator.
+sp_sign                         = remove    # Add or remove space after '+' or '-', as in 'x = -5' or 'y = +7'.
+
+# 5.2.2.4 Subsequent lines of multi-line function calls should line up two spaces from the beginning of the function
+#         name
+nl_func_call_args_multi_line    = true      # Whether to add a newline after each ',' in a function call if '(' and ')'
+                                            # are in different lines.
+nl_func_call_args_multi_line_ignore_closures = false
+
+# - Indent each argument 2 spaces from the start of the function name. If a
+#   function is called through a structure or union member, of type
+#   pointer-to-function, then indent each argument 2 spaces from the start of the
+#   member name.
+indent_func_call_edk2_style     = true      # Use EDK2 indentation style for function calls  (**CUSTOM SETTING**)
+indent_paren_after_func_call    = true      # Whether to indent the open parenthesis of a function call, if the
+                                            # parenthesis is on its own line.
+
+# - Align the close parenthesis with the start of the last argument
+indent_paren_close              = 0         # How to indent a close parenthesis after a newline.
+                                            # (0: Body, 1: Openparenthesis, 2: Brace level)
+
+
+# 5.2.2.5 Always put space after commas or semicolons that separate items
+sp_after_comma                  = force     # Add or remove space after ',', i.e. 'a,b' vs. 'a, b'.
+sp_before_comma                 = remove    # Add or remove space before ','.
+
+# 5.2.2.6 Always put space before an open parenthesis
+sp_after_sparen                 = add       # Add or remove space after ')' of control statements.
+sp_attribute_paren              = add       # Add or remove space between '__attribute__' and '('.
+sp_before_sparen                = force     # Add or remove space before '(' of control statements
+                                            # ('if', 'for', 'switch', 'while', etc.).
+sp_defined_paren                = force     # Add or remove space between 'defined' and '(' in '#if defined (FOO)'.
+sp_func_call_paren              = force     # Add or remove space between function name and '(' on function calls.
+sp_func_call_paren_empty        = force     # Add or remove space between function name and '()' on function calls
+                                            # without parameters. If set to ignore (the default), sp_func_call_paren is
+                                            # used.
+sp_func_def_paren               = add       # Add or remove space between alias name and '(' of a non-pointer function
+                                            # type typedef.
+sp_func_proto_paren             = add       # Add or remove space between function name and '()' on function declaration
+sp_sizeof_paren                 = force     # Add or remove space between 'sizeof' and '('.
+sp_type_func                    = add       # Add or remove space between return type and function name. A minimum of 1
+                                            # is forced except for pointer return types.
+
+# Not specified, but also good style to remove spaces inside parentheses (Optional)
+sp_cparen_oparen                = remove    # Add or remove space between back-to-back parentheses, i.e. ')(' vs. ') ('.
+sp_inside_fparen                = remove    # Add or remove space inside function '(' and ')'.
+sp_inside_fparens               = remove    # Add or remove space inside empty function '()'.
+sp_inside_paren                 = remove    # Add or remove space inside '(' and ')'.
+sp_inside_paren_cast            = remove    # Add or remove spaces inside cast parentheses. '(int)x'
+sp_inside_square                = remove    # Add or remove space inside a non-empty '[' and ']'.
+sp_paren_paren                  = remove    # Add or remove space between nested parentheses, i.e. '((' vs. ') )'.
+sp_square_fparen                = remove    # Add or remove space between ']' and '(' when part of a function call.
+
+# 5.2.2.7 Put a space before an open brace if it is not on its own line
+sp_do_brace_open                = force     # Add or remove space between 'do' and '{'.
+sp_paren_brace                  = force     # Add or remove space between ')' and '{'.
+sp_sparen_brace                 = force     # Add or remove space between ')' and '{' of of control statements.
+
+# 5.2.2.8 Do not put spaces around structure member and pointer operators
+sp_after_byref                  = remove    # Add or remove space after reference sign '&', if followed by a word.
+sp_before_byref                 = add       # Add or remove space before a reference sign '&'.
+sp_deref                        = remove    # Add or remove space after the '*' (dereference) unary operator. This does
+                                            # not affect the spacing after a '*' that is part of a type.
+sp_member                       = remove    # Add or remove space around the '.' or '->' operators.
+
+# 5.2.2.9 Do not put spaces before open brackets of array subscripts
+sp_before_square                = remove    # Add or remove space before '[' (except '[]').
+sp_before_squares               = remove    # Add or remove space before '[]'.
+sp_before_vardef_square         = remove    # Add or remove space before '[' for a variable definition.
+
+# 5.2.2.10 Use extra parentheses rather than depending on in-depth knowledge of the order of precedence of C
+mod_full_paren_if_bool          = true      # Whether to fully parenthesize Boolean expressions in 'while' and 'if'
+                                            # statement, as in 'if (a && b > c)' => 'if (a && (b > c))'.
+
+# 5.2.2.11 Align a continuation line with the part of the line that it continues.
+use_indent_continue_only_once   = true
+
+# Additional '{}' bracing rules (Optional)
+# NOTE - The style guide specifies two different styles for braces,
+# so these are ignored for now to allow developers some flexibility.
+nl_after_brace_close            = true      # Whether to add a newline after '}'. Does not apply if followed by a
+                                            # necessary ';'.
+nl_brace_else                   = remove    # Add or remove newline between '}' and 'else'.
+nl_brace_while                  = remove    # Add or remove newline between '}' and 'while' of 'do' statement.
+nl_do_brace                     = remove    # Add or remove newline between 'do' and '{'.
+nl_else_brace                   = remove    # Add or remove newline between 'else' and '{'.
+nl_else_if                      = remove    # Add or remove newline between 'else' and 'if'.
+nl_elseif_brace                 = remove    # Add or remove newline between 'else if' and '{'.
+nl_enum_brace                   = remove    # Add or remove newline between 'enum' and '{'.
+nl_fcall_brace                  = remove    # Add or remove newline between a function call's ')' and '{',
+                                            # as in 'list_for_each(item, &list) { }'.
+nl_for_brace                    = remove    # Add or remove newline between 'for' and '{'.
+nl_if_brace                     = remove    # Add or remove newline between 'if' and '{'.
+nl_struct_brace                 = remove    # Add or remove newline between 'struct and '{'.
+nl_switch_brace                 = remove    # Add or remove newline between 'switch' and '{'.
+nl_union_brace                  = remove    # Add or remove newline between 'union' and '{'.
+nl_while_brace                  = remove    # Add or remove newline between 'while' and '{'.
+
+# Additional whitespace rules (Optional)
+sp_after_ptr_star               = remove    # Add or remove space after pointer star '*', if followed by a word.
+                                            # Useful when paired with align_var_def_star_style==2
+sp_after_ptr_star_func          = remove    # Add or remove space after a pointer star '*', if followed by a function
+                                            # prototype or function definition.
+sp_after_semi                   = remove    # Add or remove space after ';', except when followed by a comment.
+sp_before_case_colon            = remove    # Add or remove space before case ':'.
+sp_before_ptr_star              = add       # Add or remove space before pointer star '*'.
+sp_before_ptr_star_func         = add       # Add or remove space before a pointer star '*', if followed by a function
+                                            # prototype or function definition.
+sp_before_semi                  = remove    # Add or remove space before ';'
+sp_before_semi_for              = remove    # Add or remove space before ';' in non-empty 'for' statements.
+sp_before_semi_for_empty        = add       # Add or remove space before a semicolon of an empty part of a for statement
+sp_between_ptr_star             = remove    # Add or remove space between pointer stars '*'. (ie, 'VOID **')
+sp_brace_close_while            = force     # Add or remove space between '}' and 'while'.
+
+sp_after_cast                   = remove
+sp_after_type                   = add
+sp_balance_nested_parens        = false
+sp_before_nl_cont               = add
+sp_before_square_asm_block      = ignore
+sp_before_unnamed_byref         = add
+sp_brace_brace                  = ignore
+sp_brace_else                   = force
+sp_brace_typedef                = add
+sp_case_label                   = force
+sp_cmt_cpp_doxygen              = true
+sp_cond_colon                   = add
+sp_cond_question                = add
+sp_cpp_cast_paren               = force
+sp_else_brace                   = force
+sp_endif_cmt                    = force
+sp_enum_assign                  = add
+sp_inside_braces                = force
+sp_inside_braces_empty          = force
+sp_inside_braces_enum           = force
+sp_inside_braces_struct         = force
+sp_pp_concat                    = add
+sp_pp_stringify                 = add
+sp_return_paren                 = add
+sp_special_semi                 = force
+sp_while_paren_open             = force
+
+# Additional Indentation Rules
+indent_access_spec              = 1
+indent_access_spec_body         = false
+indent_align_assign             = true
+indent_align_string             = true
+indent_bool_paren               = true
+indent_brace_parent             = false
+indent_braces                   = false
+indent_braces_no_class          = false
+indent_braces_no_func           = true
+indent_braces_no_struct         = false
+indent_class                    = false
+indent_class_colon              = false
+indent_cmt_with_tabs            = false         # Whether to indent comments that are not at a brace level with tabs on
+                                                # a tabstop. Requires indent_with_tabs=2. If false, will use spaces.
+indent_col1_comment             = true
+indent_col1_multi_string_literal= true
+indent_comma_paren              = true
+indent_else_if                  = true
+indent_extern                   = false
+indent_first_bool_expr          = true
+
+indent_func_def_param_paren_pos_threshold = 0
+indent_func_param_double                  = false
+indent_func_proto_param                   = true
+indent_ignore_asm_block                   = true
+indent_label                              = 1
+indent_member                             = 2
+indent_namespace                          = false
+indent_param                              = 2
+indent_paren_nl                           = false
+indent_paren_open_brace                   = false
+indent_preserve_sql                       = false
+indent_relative_single_line_comments      = false
+indent_sing_line_comments                 = 0
+indent_single_newlines                    = false
+indent_square_nl                          = false
+indent_switch_case                        = 2
+indent_template_param                     = true
+indent_var_def_blk                        = 0
+indent_var_def_cont                       = false
+
+# Tidy-up rules (Optional)
+mod_move_case_break             = true      # Whether to move a 'break' that appears after a fully braced 'case'
+                                            # before the close brace, as in 'case X: { ... } break;' =>
+                                            # 'case X: { ... break; }'.
+mod_pawn_semicolon              = false
+mod_remove_empty_return         = false     # Whether to remove a void 'return;' that appears as the last statement
+                                            # in a function.
+mod_remove_extra_semicolon      = true
+mod_sort_import                 = false
+mod_sort_include                = false
+mod_sort_using                  = false
+nl_after_case                   = false     # Whether to add a newline after a 'case' statement.
+nl_end_of_file                  = force     # Add or remove newline at the end of the file.
+nl_end_of_file_min              = 1         # The minimum number of newlines at the end of the file
+nl_max                          = 2         # The maximum number of consecutive newlines (3 = 2 blank lines).
+nl_start_of_file                = remove    # Add or remove newlines at the start of the file.
+
+# Code alignment rules (Optional)
+align_asm_colon                 = false
+align_assign_span               = 1         # The span for aligning on '=' in assignments.
+align_assign_thresh             = 0
+align_edk2_style                = true      # Whether to apply edk2-specific alignment formatting
+align_enum_equ_span             = 1         # The span for aligning on '=' in enums.
+align_func_params               = true      # Whether to align variable definitions in prototypes and functions.
+align_func_params_gap           = 2
+align_func_params_span          = 2         # The span for aligning parameter definitions in function on parameter name.
+align_func_params_thresh        = 0
+align_func_proto_span           = 0
+align_keep_tabs                 = false
+align_left_shift                = false
+align_mix_var_proto             = false
+align_nl_cont                   = false
+align_oc_decl_colon             = false
+align_on_operator               = false
+align_on_tabstop                = false
+align_pp_define_gap             = 2
+align_pp_define_span            = 1
+align_right_cmt_at_col          = 0         # Align trailing comment at or beyond column N; 'pulls in' comments as
+                                            # a bonus side effect (0=ignore)
+align_right_cmt_gap             = 0         # If a trailing comment is more than this number of columns away from the
+                                            # text it follows,
+                                            # it will qualify for being aligned. This has to be > 0 to do anything.
+align_right_cmt_mix             = false     # If aligning comments, mix with comments after '}' and #endif with less
+                                            # than 3 spaces before the comment
+align_right_cmt_same_level      = true      # Whether to only align trailing comments that are at the same brace level.
+align_right_cmt_span            = 2         # The span for aligning comments that end lines.
+align_same_func_call_params     = false
+align_single_line_brace         = true
+align_single_line_func          = true
+align_struct_init_span          = 1         # The span for aligning struct initializer values.
+align_typedef_amp_style         = 1
+align_typedef_func              = 1         # How to align typedef'd functions with other typedefs.
+                                            # (0: No align, 1: Align open paranthesis, 2: Align function type name)
+align_typedef_gap               = 2
+align_typedef_span              = 1         # The span for aligning single-line typedefs.
+align_typedef_star_style        = 1
+align_var_def_amp_style         = 1
+align_var_def_attribute         = true
+align_var_def_colon             = true      # Whether to align the colon in struct bit fields.
+align_var_def_gap               = 2         # The gap (minimum spacing for aligned items) for variable definitions.
+align_var_def_inline            = false
+align_var_def_span              = 1         # The span (lines needed to align) for aligning variable definitions.
+align_var_def_star_style        = 1         # How to consider (or treat) the '*' in the alignment of variable
+                                            # definitions.
+                                            # 0: Part of the type     'void *   foo;' (default)
+                                            # 1: Part of the variable 'void     *foo;'
+                                            # 2: Dangling             'void    *foo;'
+                                            # (Note - should also set sp_after_ptr_star=remove)
+align_var_struct_gap            = 4
+align_var_struct_span           = 8         # The span for aligning struct/union member definitions.
+align_var_struct_thresh         = 0
+align_with_tabs                 = false
+
+# Comment formatting
+cmt_align_doxygen_javadoc_tags  = true      # Whether to align doxygen javadoc-style tags ('@param', '@return', etc.)
+                                            # TODO: Eats '[' in '[in]'
+cmt_c_group                     = false
+cmt_c_nl_end                    = true      # Whether to add a newline before the closing '*/' of the combined c-comment.
+cmt_c_nl_start                  = true
+cmt_cpp_group                   = false
+cmt_cpp_nl_end                  = true
+cmt_cpp_nl_start                = true
+cmt_cpp_to_c                    = false
+cmt_indent_multi                = false     # Whether to apply changes to multi-line comments, including cmt_width,
+                                            # keyword substitution and leading chars.
+cmt_insert_before_preproc       = false
+#cmt_insert_file_header          = default_file_header.txt
+#cmt_insert_func_header          = default_function_header.txt
+cmt_multi_check_last            = false
+cmt_multi_first_len_minimum     = 2
+cmt_reflow_mode                 = 1         # How to reflow comments.
+                                            # (0:No reflow, 1:No touching at all, 2: Full reflow)
+cmt_sp_after_star_cont          = 0         # The number of spaces to insert after the star on subsequent comment lines.
+cmt_sp_before_star_cont         = 0         # The number of spaces to insert at the start of subsequent comment lines.
+cmt_star_cont                   = false     # Whether to put a star on subsequent comment lines.
+cmt_width                       = 120       # Try to wrap comments at N columns.
+sp_cmt_cpp_start                = add       # Add or remove space after the opening of a C++ comment, as in
+                                            # '// <here> A'.  NOTE: Breaks indentation within comments.
+
+# Function definitions / declarations
+indent_func_call_param          = false     # Whether to indent continued function call parameters one indent level,
+                                            # rather than aligning parameters under the open parenthesis.
+indent_func_class_param         = false     # Whether to indent continued function call declaration one indent level,
+                                            # rather than aligning parameters under the open parenthesis.
+indent_func_ctor_var_param      = false     # Whether to indent continued class variable constructors one indent level,
+                                            # rather than aligning parameters under the open parenthesis.
+indent_func_def_param           = true      # Whether to indent continued function definition parameters one indent
+                                            # level, rather than aligning parameters under the open parenthesis.
+nl_fdef_brace                   = add       # Add or remove newline between function signature and '{'.
+nl_func_call_end_multi_line     = true      # Whether to add a newline before ')' in a function call if '(' and ')' are
+                                            # in different lines.
+nl_func_call_paren              = remove    # Add or remove newline between a function name and the opening '(' in the
+                                            # call.
+nl_func_call_start_multi_line   = true      # Whether to add a newline after '(' in a function call if '(' and ')' are
+                                            # in different lines.
+nl_func_decl_args               = force     # Add or remove newline after each ',' in a function declaration.
+nl_func_decl_empty              = add       # Add or remove newline between '()' in a function declaration.
+nl_func_def_args                = force     # Add or remove newline after each ',' in a function definition.
+nl_func_def_empty               = add       # Add or remove newline between '()' in a function definition.
+nl_func_def_paren               = remove    # Add or remove newline between a function name and the opening '('
+                                            # in the definition.
+nl_func_paren                   = remove    # Add or remove newline between a function name and the opening '(' in
+                                            # the declaration.
+nl_func_type_name               = add       # Add or remove newline between return type and function name in a function
+                                            # definition.
+sp_fparen_brace                 = force     # Add or remove space between ')' and '{' of function.
+use_indent_func_call_param      = true      # indent_func_call_param will be used
+
+# Additional Newline Rules
+nl_after_brace_open                          = true     # Whether to add a newline after '{'. This also adds a newline
+                                                        # before the matching '}'.
+nl_after_brace_open_cmt                      = true     # Whether to add a newline between the open brace and a
+                                                        # trailing single-line comment.
+                                                        # Requires nl_after_brace_open = true.
+nl_after_do                                  = add      # Add or remove blank line after 'do/while' statement.
+nl_after_for                                 = add      # Add or remove blank line after 'for' statement.
+nl_after_func_body                           = 2        # The number of newlines after '}' of a multi-line function body
+nl_after_func_body_one_liner                 = 2
+nl_after_func_proto                          = 2
+nl_after_func_proto_group                    = 2
+nl_after_if                                  = add
+nl_after_multiline_comment                   = false
+nl_after_return                              = false
+nl_after_struct                              = 2
+nl_after_switch                              = add
+nl_after_vbrace_close                        = true
+nl_after_vbrace_open                         = true
+nl_after_vbrace_open_empty                   = true
+nl_after_while                               = add
+nl_assign_leave_one_liners                   = true
+nl_before_block_comment                      = 2
+nl_before_case                               = false
+nl_before_do                                 = ignore
+nl_before_for                                = ignore
+nl_before_if                                 = ignore
+nl_before_switch                             = ignore
+nl_before_while                              = ignore
+nl_before_whole_file_ifdef                   = 2
+nl_brace_brace                               = force
+nl_brace_struct_var                          = remove
+nl_case_colon_brace                          = add
+nl_class_leave_one_liners                    = false
+nl_collapse_empty_body                       = false
+nl_comment_func_def                          = 1
+nl_create_for_one_liner                      = false
+nl_create_if_one_liner                       = false
+nl_create_while_one_liner                    = false
+nl_define_macro                              = false
+nl_ds_struct_enum_close_brace                = true
+nl_ds_struct_enum_cmt                        = false
+nl_enum_leave_one_liners                     = false
+nl_func_decl_end                             = add
+nl_func_decl_start                           = add
+nl_func_def_end                              = add
+nl_func_def_start                            = add
+nl_func_leave_one_liners                     = false
+nl_func_proto_type_name                      = add
+nl_func_var_def_blk                          = 1
+nl_getset_leave_one_liners                   = false
+nl_if_leave_one_liners                       = false
+nl_multi_line_define                         = false
+nl_squeeze_ifdef                             = false
+nl_var_def_blk_end                           = 0
+nl_var_def_blk_start                         = 0
+
+# Preprocessor Rules
+pp_define_at_level      = true
+pp_if_indent_code       = false
+pp_indent_func_def      = false
+pp_indent_extern        = false
+pp_ignore_define_body   = true                # Workaround: Turn off processing for #define body
+                                              # (current rules do not work for some defines)
+pp_indent               = add
+pp_indent_at_level      = true
+pp_indent_count         = 2
+pp_indent_if            = 2
+pp_indent_region        = 2
+pp_region_indent_code   = false
+pp_space                = remove
+
+#
+# The tokens below are assigned specific types so they are always recognized properly.
+#
+
+# Explicitly define EDK II qualifiers
+set QUALIFIER CONST
+set QUALIFIER EFIAPI
+set QUALIFIER IN
+set QUALIFIER OPTIONAL
+set QUALIFIER OUT
+
+# Explicitly define EDK II types
+set TYPE EFI_STATUS
+set TYPE VOID

.pytool/Plugin/UncrustifyCheck/uncrustify_ext_dep.yaml

@@ -0,0 +1,16 @@
+## @file
+# Downloads the Uncrustify application from a Project Mu NuGet package.
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "id": "uncrustify-ci-1",
+  "scope": "cibuild",
+  "type": "nuget",
+  "name": "mu-uncrustify-release",
+  "source": "https://pkgs.dev.azure.com/projectmu/Uncrustify/_packaging/mu_uncrustify/nuget/v3/index.json",
+  "version": "73.0.3",
+  "flags": ["set_shell_var", "host_specific"],
+  "var_name": "UNCRUSTIFY_CI_PATH"
+}

.pytool/Plugin/UncrustifyCheck/uncrustify_plug_in.yaml

@@ -0,0 +1,11 @@
+## @file
+# CiBuildPlugin used to check coding standard compliance of EDK II style C source code
+#
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+  "scope": "cibuild",
+  "name": "Uncrustify Coding Standard Test",
+  "module": "UncrustifyCheck"
+}

.pytool/Readme.md

@@ -0,0 +1,298 @@
+# Edk2 Continuous Integration
+
+## Basic Status
+
+| Package              | Windows VS2019 (IA32/X64)| Ubuntu GCC (IA32/X64/ARM/AARCH64) | Known Issues |
+| :----                | :-----                   | :----                             | :---         |
+| ArmPkg               |                    | :heavy_check_mark: |
+| ArmPlatformPkg       |                    | :heavy_check_mark: |
+| ArmVirtPkg           | SEE PACKAGE README | SEE PACKAGE README |
+| CryptoPkg            | :heavy_check_mark: | :heavy_check_mark: | Spell checking in audit mode
+| DynamicTablesPkg     |                    | :heavy_check_mark: |
+| EmbeddedPkg          |
+| EmulatorPkg          | SEE PACKAGE README | SEE PACKAGE README | Spell checking in audit mode
+| FatPkg               | :heavy_check_mark: | :heavy_check_mark: |
+| FmpDevicePkg         | :heavy_check_mark: | :heavy_check_mark: |
+| IntelFsp2Pkg         |
+| IntelFsp2WrapperPkg  |
+| MdeModulePkg         | :heavy_check_mark: | :heavy_check_mark: | DxeIpl dependency on ArmPkg, Depends on StandaloneMmPkg, Spell checking in audit mode
+| MdePkg               | :heavy_check_mark: | :heavy_check_mark: | Spell checking in audit mode
+| NetworkPkg           | :heavy_check_mark: | :heavy_check_mark: | Spell checking in audit mode
+| OvmfPkg              | SEE PACKAGE README | SEE PACKAGE README | Spell checking in audit mode
+| PcAtChipsetPkg       | :heavy_check_mark: | :heavy_check_mark: |
+| SecurityPkg          | :heavy_check_mark: | :heavy_check_mark: | Spell checking in audit mode
+| ShellPkg             | :heavy_check_mark: | :heavy_check_mark: | Spell checking in audit mode, 3 modules are not being built by DSC
+| SignedCapsulePkg     |
+| SourceLevelDebugPkg  |
+| StandaloneMmPkg      | :heavy_check_mark: | :heavy_check_mark: |
+| UefiCpuPkg           | :heavy_check_mark: | :heavy_check_mark: | Spell checking in audit mode, 2 binary modules not being built by DSC
+| UefiPayloadPkg       |
+| UnitTestFrameworkPkg | :heavy_check_mark: | :heavy_check_mark: |
+
+For more detailed status look at the test results of the latest CI run on the
+repo readme.
+
+## Background
+
+This Continuous integration and testing infrastructure leverages the TianoCore EDKII Tools PIP modules:
+[library](https://pypi.org/project/edk2-pytool-library/) and
+[extensions](https://pypi.org/project/edk2-pytool-extensions/) (with repos
+located [here](https://github.com/tianocore/edk2-pytool-library) and
+[here](https://github.com/tianocore/edk2-pytool-extensions)).
+
+The primary execution flows can be found in the
+`.azurepipelines/Windows-VS2019.yml` and `.azurepipelines/Ubuntu-GCC5.yml`
+files. These YAML files are consumed by the Azure Dev Ops Build Pipeline and
+dictate what server resources should be used, how they should be configured, and
+what processes should be run on them. An overview of this schema can be found
+[here](https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=azure-devops&tabs=schema).
+
+Inspection of these files reveals the EDKII Tools commands that make up the
+primary processes for the CI build: 'stuart_setup', 'stuart_update', and
+'stuart_ci_build'. These commands come from the EDKII Tools PIP modules and are
+configured as described below. More documentation on the tools can be
+found [here](https://github.com/tianocore/edk2-pytool-extensions/blob/master/docs/using.md)
+and [here](https://github.com/tianocore/edk2-pytool-extensions/blob/master/docs/features/feature_invocables.md).
+
+## Configuration
+
+Configuration of the CI process consists of (in order of precedence):
+
+* command-line arguments passed in via the Pipeline YAML
+* a per-package configuration file (e.g. `<package-name>.ci.yaml`) that is
+  detected by the CI system in EDKII Tools.
+* a global configuration Python module (e.g. `CISetting.py`) passed in via the
+  command-line
+
+The global configuration file is described in
+[this readme](https://github.com/tianocore/edk2-pytool-extensions/blob/master/docs/usability/using_settings_manager.md)
+from the EDKII Tools documentation. This configuration is written as a Python
+module so that decisions can be made dynamically based on command line
+parameters and codebase state.
+
+The per-package configuration file can override most settings in the global
+configuration file, but is not dynamic. This file can be used to skip or
+customize tests that may be incompatible with a specific package.  Each test generally requires
+per package configuration which comes from this file.
+
+## Running CI locally
+
+The EDKII Tools environment (and by extension the ci) is designed to support
+easily and consistently running locally and in a cloud ci environment.  To do
+that a few steps should be followed.  Details of EDKII Tools can be found in the
+[docs folder here](https://github.com/tianocore/edk2-pytool-extensions/tree/master/docs)
+
+### Prerequisets
+
+1. A supported toolchain (others might work but this is what is tested and validated)
+   * Windows 10:
+     * VS 2017 or VS 2019
+     * Windows SDK (for rc)
+     * Windows WDK (for capsules)
+   * Ubuntu 18.04 or Fedora
+     * GCC5
+   * Easy to add more but this is the current state
+2. Python 3.7.x or newer on path
+3. git on path
+4. Recommended to setup and activate a python virtual environment
+5. Install the requirements `pip install --upgrade pip-requirements.txt`
+
+### Running CI
+
+1. clone your edk2 repo
+2. Activate your python virtual environment in cmd window
+3. Get code dependencies (done only when submodules change)
+   * `stuart_setup -c .pytool/CISettings.py TOOL_CHAIN_TAG=<your tag here>`
+4. Update other dependencies (done more often)
+   * `stuart_update -c .pytool/CISettings.py TOOL_CHAIN_TAG=<your tag here>`
+5. Run CI build (--help will give you options)
+   * `stuart_ci_build -c .pytool/CISettings.py TOOL_CHAIN_TAG=<your tag here>`
+   * -p <pkg1,pkg2,pkg3> : To build only certain packages use a CSV list
+   * -a <arch1,arch2,arch3>: To run only certain architectures use a CSV list
+   * -t <target1,target2>: To run only tests related to certain targets use a
+     CSV list
+   * By default all tests are opted in.  Then given a package.ci.yaml file those
+     tests can be configured for a package. Finally setting the check to the
+     value `skip` will skip that plugin.  Examples:
+     * `CompilerPlugin=skip` skip the build test
+     * `GuidCheck=skip` skip the Guid check
+     * `SpellCheck=skip` skip the spell checker
+     * etc
+6. Detailed reports and logs per package are captured in the `Build` directory
+
+## Current PyTool Test Capabilities
+
+All CI tests are instances of EDKII Tools plugins. Documentation on the plugin
+system can be found [here](https://github.com/tianocore/edk2-pytool-extensions/blob/master/docs/usability/using_plugin_manager.md)
+and [here](https://github.com/tianocore/edk2-pytool-extensions/blob/master/docs/features/feature_plugin_manager.md).
+Upon invocation, each plugin will be passed the path to the current package
+under test and a dictionary containing its targeted configuration, as assembled
+from the command line, per-package configuration, and global configuration.
+
+Note: CI plugins are considered unique from build plugins and helper plugins,
+even though some CI plugins may execute steps of a build.
+
+In the example, these plugins live alongside the code under test (in the
+`.pytool/Plugin` directory), but may be moved to the 'edk2-test' repo if that
+location makes more sense for the community.
+
+### Module Inclusion Test - DscCompleteCheck
+
+This scans all INF files from a package and confirms they are
+listed in the package level DSC file. The test considers it an error if any INF
+does not appear in the `Components` section of the package-level DSC (indicating
+that it would not be built if the package were built). This is critical because
+much of the CI infrastructure assumes that all modules will be listed in the DSC
+and compiled.
+
+This test will ignore INFs in the following cases:
+
+1. When `MODULE_TYPE` = `HOST_APPLICATION`
+2. When a Library instance **only** supports the `HOST_APPLICATION` environment
+
+### Host Module Inclusion Test - HostUnitTestDscCompleteCheck
+
+This test scans all INF files from a package for those related to host
+based unit tests and confirms they are listed in the unit test DSC file for the package.
+The test considers it an error if any INF meeting the requirements does not appear
+in the `Components` section of the unit test DSC. This is critical because
+much of the CI infrastructure assumes that  modules will be listed in the DSC
+and compiled.
+
+This test will only require INFs in the following cases:
+
+1. When `MODULE_TYPE` = `HOST_APPLICATION`
+2. When a Library instance explicitly supports the `HOST_APPLICATION` environment
+
+### Code Compilation Test - CompilerPlugin
+
+Once the Module Inclusion Test has verified that all modules would be built if
+all package-level DSCs were built, the Code Compilation Test simply runs through
+and builds every package-level DSC on every toolchain and for every architecture
+that is supported. Any module that fails to build is considered an error.
+
+### Host Unit Test Compilation and Run Test - HostUnitTestCompilerPlugin
+
+A test that compiles the dsc for host based unit test apps.
+On Windows this will also enable a build plugin to execute that will run the unit tests and verify the results.
+
+These tools will be invoked on any CI
+pass that includes the NOOPT target. In order for these tools to do their job,
+the package and tests must be configured in a particular way...
+
+#### Including Host-Based Tests in the Package YAML
+
+For example, looking at the `MdeModulePkg.ci.yaml` config file, there are two
+config options that control HostBased test behavior:
+
+```json
+    ## options defined .pytool/Plugin/HostUnitTestCompilerPlugin
+    "HostUnitTestCompilerPlugin": {
+        "DscPath": "Test/MdeModulePkgHostTest.dsc"
+    },
+```
+
+This option tell the test builder to run. The test builder needs to know which
+modules in this package are host-based tests, so that DSC path is provided.
+
+#### Configuring the HostBased DSC
+
+The HostBased DSC for `MdeModulePkg` is located at
+`MdeModulePkg/Test/MdeModulePkgHostTest.dsc`.
+
+To add automated host-based unit test building to a new package, create a
+similar DSC. The new DSC should make sure to have the `NOOPT` BUILD_TARGET
+and should include the line:
+
+```
+!include UnitTestFrameworkPkg/UnitTestFrameworkPkgHost.dsc.inc
+```
+
+All of the modules that are included in the `Components` section of this
+DSC should be of type HOST_APPLICATION.
+
+### GUID Uniqueness Test - GuidCheck
+
+This test works on the collection of all packages rather than an individual
+package. It looks at all FILE_GUIDs and GUIDs declared in DEC files and ensures
+that they are unique for the codebase. This prevents, for example, accidental
+duplication of GUIDs when using an existing INF as a template for a new module.
+
+### Cross-Package Dependency Test - DependencyCheck
+
+This test compares the list of all packages used in INFs files for a given
+package against a list of "allowed dependencies" in plugin configuration for
+that package. Any module that depends on a disallowed package will cause a test
+failure.
+
+### Library Declaration Test - LibraryClassCheck
+
+This test scans at all library header files found in the `Library` folders in
+all of the package's declared include directories and ensures that all files
+have a matching LibraryClass declaration in the DEC file for the package. Any
+missing declarations will cause a failure.
+
+### Invalid Character Test - CharEncodingCheck
+
+This test scans all files in a package to make sure that there are no invalid
+Unicode characters that may cause build errors in some character
+sets/localizations.
+
+### Spell Checking - cspell
+
+This test runs a spell checker on all files within the package.  This is done
+using the NodeJs cspell tool.  For details check `.pytool/Plugin/SpellCheck`.
+For this plugin to run during ci you must install nodejs and cspell and have
+both available to the command line when running your CI.
+
+Install
+
+* Install nodejs from https://nodejs.org/en/
+* Install cspell
+  1. Open cmd prompt with access to node and npm
+  2. Run `npm install -g cspell`
+
+  More cspell info: https://github.com/streetsidesoftware/cspell
+
+### License Checking - LicenseCheck
+
+Scans all new added files in a package to make sure code is contributed under
+BSD-2-Clause-Patent.
+
+### Ecc tool - EccCheck
+
+Run the Ecc tool on the package. The Ecc tool is available in the BaseTools
+package. It checks that the code complies to the EDKII coding standard.
+
+### Coding Standard Compliance - UncrustifyCheck
+
+Runs the Uncrustify application to check for coding standard compliance issues.
+
+## PyTool Scopes
+
+Scopes are how the PyTool ext_dep, path_env, and plugins are activated.  Meaning
+that if an invocable process has a scope active then those ext_dep and path_env
+will be active. To allow easy integration of PyTools capabilities there are a
+few standard scopes.
+
+| Scope      | Invocable                                            | Description    |
+| :----      | :-----                                               | :----          |
+| global     | edk2_invocable++ - should be base_abstract_invocable | Running an invocables |
+| global-win | edk2_invocable++                                     | Running on Microsoft Windows |
+| global-nix | edk2_invocable++                                     | Running on Linux based OS    |
+| edk2-build |                                                      | This indicates that an invocable is building EDK2 based UEFI code |
+| cibuild    | set in .pytool/CISettings.py                         | Suggested target for edk2 continuous integration builds.  Tools used for CiBuilds can use this scope.  Example: asl compiler |
+| host-based-test | set in .pytool/CISettings.py                    | Turns on the host based tests and plugin |
+| host-test-win | set in .pytool/CISettings.py                      | Enables the host based test runner for Windows |
+
+## Future investments
+
+* PatchCheck tests as plugins
+* MacOS/xcode support
+* Clang/LLVM support
+* Visual Studio AARCH64 and ARM support
+* BaseTools C tools CI/PR and binary release process
+* BaseTools Python tools CI/PR process
+* Extensible private/closed source platform reporting
+* UEFI SCTs
+* Other automation

ArmPkg/ArmPkg.ci.yaml

@@ -0,0 +1,243 @@
+## @file
+# CI configuration for ArmPkg
+#
+# Copyright (c) 2021, Arm Limited. All rights reserved.<BR>
+# SPDX-License-Identifier: BSD-2-Clause-Patent
+##
+{
+    ## options defined .pytool/Plugin/LicenseCheck
+    "LicenseCheck": {
+        "IgnoreFiles": []
+    },
+
+    "EccCheck": {
+        ## Exception sample looks like below:
+        ## "ExceptionList": [
+        ##     "<ErrorID>", "<KeyWord>"
+        ## ]
+        "ExceptionList": [
+        ],
+        ## Both file path and directory path are accepted.
+        "IgnoreFiles": [
+            "Library/ArmSoftFloatLib/berkeley-softfloat-3",
+            "Library/ArmSoftFloatLib/ArmSoftFloatLib.c",
+            "Library/CompilerIntrinsicsLib",
+            "Universal/Smbios/SmbiosMiscDxe"
+        ]
+    },
+
+    ## options defined .pytool/Plugin/CompilerPlugin
+    "CompilerPlugin": {
+        "DscPath": "ArmPkg.dsc"
+    },
+
+    ## options defined .pytool/Plugin/HostUnitTestCompilerPlugin
+    "HostUnitTestCompilerPlugin": {
+        "DscPath": "" # Don't support this test
+    },
+
+    ## options defined .pytool/Plugin/CharEncodingCheck
+    "CharEncodingCheck": {
+        "IgnoreFiles": []
+    },
+
+    ## options defined .pytool/Plugin/DependencyCheck
+    "DependencyCheck": {
+        "AcceptableDependencies": [
+            "ArmPlatformPkg/ArmPlatformPkg.dec",
+            "ArmPkg/ArmPkg.dec",
+            "EmbeddedPkg/EmbeddedPkg.dec",
+            "MdeModulePkg/MdeModulePkg.dec",
+            "MdePkg/MdePkg.dec",
+            "ShellPkg/ShellPkg.dec"
+        ],
+        # For host based unit tests
+        "AcceptableDependencies-HOST_APPLICATION":[
+            "UnitTestFrameworkPkg/UnitTestFrameworkPkg.dec"
+        ],
+        # For UEFI shell based apps
+        "AcceptableDependencies-UEFI_APPLICATION":[],
+        "IgnoreInf": []
+    },
+
+    ## options defined .pytool/Plugin/DscCompleteCheck
+    "DscCompleteCheck": {
+        "IgnoreInf": [],
+        "DscPath": "ArmPkg.dsc"
+    },
+
+    ## options defined .pytool/Plugin/HostUnitTestDscCompleteCheck
+    "HostUnitTestDscCompleteCheck": {
+        "IgnoreInf": [""],
+        "DscPath": "" # Don't support this test
+    },
+
+    ## options defined .pytool/Plugin/GuidCheck
+    "GuidCheck": {
+        "IgnoreGuidName": [],
+        "IgnoreGuidValue": [],
+        "IgnoreFoldersAndFiles": [],
+        "IgnoreDuplicates": [],
+    },
+
+    ## options defined .pytool/Plugin/LibraryClassCheck
+    "LibraryClassCheck": {
+        "IgnoreHeaderFile": []
+    },
+
+    ## options defined .pytool/Plugin/SpellCheck
+    "SpellCheck": {
+        "AuditOnly": False,
+        "IgnoreFiles": [
+            "Library/ArmSoftFloatLib/berkeley-softfloat-3/**"
+        ],                           # use gitignore syntax to ignore errors
+                                     # in matching files
+        "ExtendWords": [
+          "api's",
+          "ackintid",
+          "actlr",
+          "aeabi",
+          "asedis",
+          "ashldi",
+          "ashrdi",
+          "baddr",
+          "ccidx",
+          "ccsidr",
+          "clidr",
+          "clrex",
+          "clzsi",
+          "cnthctl",
+          "cortexa",
+          "cpacr",
+          "cpuactlr",
+          "csselr",
+          "ctzsi",
+          "cygdrive",
+          "cygpaths",
+          "datas",
+          "dcmpeq",
+          "dcmpge",
+          "dcmpgt",
+          "dcmple",
+          "dcmplt",
+          "ddisable",
+          "divdi",
+          "divsi",
+          "dmdepkg",
+          "dpref",
+          "drsub",
+          "fcmpeq",
+          "fcmpge",
+          "fcmpgt",
+          "fcmple",
+          "fcmplt",
+          "ffreestanding",
+          "frsub",
+          "hisilicon",
+          "iccabpr",
+          "iccbpr",
+          "icciar",
+          "iccicr",
+          "icciidr",
+          "iccpir",
+          "iccpmr",
+          "iccrpr",
+          "icdabr",
+          "icdicer",
+          "icdicfr",
+          "icdicpr",
+          "icdictr",
+          "icdiidr",
+          "icdiser",
+          "icdisr",
+          "icdppisr",
+          "icdsgir",
+          "icdspr",
+          "icenabler",
+          "intid",
+          "ipriority",
+          "irouter",
+          "isenabler",
+          "istatus",
+          "itargets",
+          "lable",
+          "ldivmod",
+          "ldmdb",
+          "ldmia",
+          "ldrbt",
+          "ldrex",
+          "ldrexb",
+          "ldrexd",
+          "ldrexh",
+          "ldrhbt",
+          "ldrht",
+          "ldrsb",
+          "ldrsbt",
+          "ldrsh",
+          "lshrdi",
+          "moddi",
+          "modsi",
+          "mpcore",
+          "mpidr",
+          "muldi",
+          "mullu",
+          "nonshareable",
+          "nsacr",
+          "nsasedis",
+          "nuvia",
+          "oldit",
+          "pcten",
+          "plpis",
+          "procno",
+          "readc",
+          "revsh",
+          "rfedb",
+          "sctlr",
+          "smccc",
+          "smlabb",
+          "smlabt",
+          "smlad",
+          "smladx",
+          "smlatb",
+          "smlatt",
+          "smlawb",
+          "smlawt",
+          "smlsd",
+          "smlsdx",
+          "smmla",
+          "smmlar",
+          "smmls",
+          "smmlsr",
+          "sourcery",
+          "srsdb",
+          "ssacr",
+          "stmdb",
+          "stmia",
+          "strbt",
+          "strexb",
+          "strexd",
+          "strexh",
+          "strht",
+          "switchu",
+          "tpidrurw",
+          "ttbcr",
+          "typer",
+          "ucmpdi",
+          "udivdi",
+          "udivmoddi",
+          "udivsi",
+          "uefi's",
+          "uldiv",
+          "umoddi",
+          "umodsi",
+          "usada",
+          "vlpis",
+          "writec"
+        ],                          # words to extend to the dictionary for this package
+        "IgnoreStandardPaths": [    # Standard Plugin defined paths that
+            "*.asm", "*.s"          # should be ignore
+        ],
+        "AdditionalIncludePaths": [] # Additional paths to spell check
+                                     # (wildcards supported)
+    }
+}

ArmPkg/ArmPkg.dec

@@ -2,7 +2,8 @@
 # ARM processor package.
 #
 # Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>
-# Copyright (c) 2011 - 2018, ARM Limited. All rights reserved.
+# Copyright (c) 2011 - 2021, ARM Limited. All rights reserved.
+# Copyright (c) 2021, Ampere Computing LLC. All rights reserved.
 #
 #    SPDX-License-Identifier: BSD-2-Clause-Patent
 #
@@ -27,15 +28,68 @@
   Include                        # Root include for the package
 
 [LibraryClasses.common]
-  ArmLib|Include/Library/ArmLib.h
+  ##  @libraryclass  Convert Arm instructions to a human readable format.
-  ArmMmuLib|Include/Library/ArmMmuLib.h
+  #
-  SemihostLib|Include/Library/Semihosting.h
-  DefaultExceptionHandlerLib|Include/Library/DefaultExceptionHandlerLib.h
   ArmDisassemblerLib|Include/Library/ArmDisassemblerLib.h
+
+  ##  @libraryclass  Provides an interface to Arm generic counters.
+  #
+  ArmGenericTimerCounterLib|Include/Library/ArmGenericTimerCounterLib.h
+
+  ##  @libraryclass  Provides an interface to initialize a
+  #   Generic Interrupt Controller (GIC).
+  #
   ArmGicArchLib|Include/Library/ArmGicArchLib.h
-  ArmMtlLib|ArmPlatformPkg/Include/Library/ArmMtlLib.h
+
+  ##  @libraryclass  Provides a Generic Interrupt Controller (GIC)
+  #   configuration interface.
+  #
+  ArmGicLib|Include/Library/ArmGicLib.h
+
+  ##  @libraryclass  Provides a HyperVisor Call (HVC) interface.
+  #
+  ArmHvcLib|Include/Library/ArmHvcLib.h
+
+  ##  @libraryclass  Provides an interface to Arm registers.
+  #
+  ArmLib|Include/Library/ArmLib.h
+
+  ##  @libraryclass  Provides a Mmu interface.
+  #
+  ArmMmuLib|Include/Library/ArmMmuLib.h
+
+  ##  @libraryclass  Provides a Mailbox Transport Layer (MTL) interface
+  #   for the System Control and Management Interface (SCMI).
+  #
+  ArmMtlLib|Include/Library/ArmMtlLib.h
+
+  ##  @libraryclass  Provides a System Monitor Call (SMC) interface.
+  #
+  ArmSmcLib|Include/Library/ArmSmcLib.h
+
+  ##  @libraryclass  Provides a SuperVisor Call (SVC) interface.
+  #
   ArmSvcLib|Include/Library/ArmSvcLib.h
+
+  ##  @libraryclass  Provides a default exception handler.
+  #
+  DefaultExceptionHandlerLib|Include/Library/DefaultExceptionHandlerLib.h
+
+  ##  @libraryclass  Provides an interface to query miscellaneous OEM
+  #   information.
+  #
+  OemMiscLib|Include/Library/OemMiscLib.h
+
+  ##  @libraryclass  Provides an OpTee interface.
+  #
   OpteeLib|Include/Library/OpteeLib.h
+
+  ##  @libraryclass  Provides a semihosting interface.
+  #
+  SemihostLib|Include/Library/SemihostLib.h
+
+  ##  @libraryclass  Provides an interface for a StandaloneMm Mmu.
+  #
   StandaloneMmMmuLib|Include/Library/StandaloneMmMmuLib.h
 
 [Guids.common]
@@ -78,16 +132,19 @@
   # Define if the GICv3 controller should use the GICv2 legacy
   gArmTokenSpaceGuid.PcdArmGicV3WithV2Legacy|FALSE|BOOLEAN|0x00000042
 
-  # Whether to implement warm reboot for capsule update using a jump back to the
-  # PEI entry point with caches and interrupts disabled.
-  gArmTokenSpaceGuid.PcdArmReenterPeiForCapsuleWarmReboot|FALSE|BOOLEAN|0x0000001F
-
 [PcdsFeatureFlag.ARM]
   # Whether to map normal memory as non-shareable. FALSE is the safe choice, but
   # TRUE may be appropriate to fix performance problems if you don't care about
   # hardware coherency (i.e., no virtualization or cache coherent DMA)
   gArmTokenSpaceGuid.PcdNormalMemoryNonshareableOverride|FALSE|BOOLEAN|0x00000043
 
+[PcdsFeatureFlag.AARCH64, PcdsFeatureFlag.ARM]
+  ## Used to select method for requesting services from S-EL1.<BR><BR>
+  #   TRUE  - Selects FF-A calls for communication between S-EL0 and SPMC.<BR>
+  #   FALSE - Selects SVC calls for communication between S-EL0 and SPMC.<BR>
+  # @Prompt Enable FF-A support.
+  gArmTokenSpaceGuid.PcdFfaEnable|FALSE|BOOLEAN|0x0000005B
+
 [PcdsFixedAtBuild.common]
   gArmTokenSpaceGuid.PcdTrustzoneSupport|FALSE|BOOLEAN|0x00000006
 
@@ -119,6 +176,20 @@
   # The Primary Core is ClusterId[0] & CoreId[0]
   gArmTokenSpaceGuid.PcdArmPrimaryCore|0|UINT32|0x00000037
 
+  #
+  # SMBIOS PCDs
+  #
+  gArmTokenSpaceGuid.PcdSystemProductName|L""|VOID*|0x30000053
+  gArmTokenSpaceGuid.PcdSystemVersion|L""|VOID*|0x30000054
+  gArmTokenSpaceGuid.PcdBaseBoardManufacturer|L""|VOID*|0x30000055
+  gArmTokenSpaceGuid.PcdBaseBoardProductName|L""|VOID*|0x30000056
+  gArmTokenSpaceGuid.PcdBaseBoardVersion|L""|VOID*|0x30000057
+  gArmTokenSpaceGuid.PcdProcessorManufacturer|L""|VOID*|0x30000071
+  gArmTokenSpaceGuid.PcdProcessorVersion|L""|VOID*|0x30000072
+  gArmTokenSpaceGuid.PcdProcessorSerialNumber|L""|VOID*|0x30000073
+  gArmTokenSpaceGuid.PcdProcessorAssetTag|L""|VOID*|0x30000074
+  gArmTokenSpaceGuid.PcdProcessorPartNumber|L""|VOID*|0x30000075
+
   #
   # ARM L2x0 PCDs
   #
@@ -219,6 +290,9 @@
   gArmTokenSpaceGuid.PcdMmBufferBase|0|UINT64|0x00000045
   gArmTokenSpaceGuid.PcdMmBufferSize|0|UINT64|0x00000046
 
+  gArmTokenSpaceGuid.PcdSystemBiosRelease|0xFFFF|UINT16|0x30000058
+  gArmTokenSpaceGuid.PcdEmbeddedControllerFirmwareRelease|0xFFFF|UINT16|0x30000059
+
 [PcdsFixedAtBuild.common, PcdsDynamic.common]
   #
   # ARM Architectural Timer
@@ -264,9 +338,9 @@
   #   UINT64 Mmio32CpuBase; // mapping target in 64-bit cpu-physical space
   #   UINT64 Mmio64CpuBase; // mapping target in 64-bit cpu-physical space
   #
-  #   PcdPciIoTranslation     = IoCpuBase     - PcdPciIoBase;
+  #   gEfiMdePkgTokenSpaceGuid.PcdPciIoTranslation = IoCpuBase - PcdPciIoBase;
-  #   PcdPciMmio32Translation = Mmio32CpuBase - (UINT64)PcdPciMmio32Base;
+  #   gEfiMdePkgTokenSpaceGuid.PcdPciMmio32Translation = Mmio32CpuBase - (UINT64)PcdPciMmio32Base;
-  #   PcdPciMmio64Translation = Mmio64CpuBase - PcdPciMmio64Base;
+  #   gEfiMdePkgTokenSpaceGuid.PcdPciMmio64Translation = Mmio64CpuBase - PcdPciMmio64Base;
   #
   # because (a) the target address space (ie. the cpu-physical space) is
   # 64-bit, and (b) the translation values are meant as offsets for *modular*
@@ -283,11 +357,11 @@
   #   UINT64 TranslatedMmio64Address;   // output parameter
   #
   #   TranslatedIoAddress     = UntranslatedIoAddress +
-  #                             PcdPciIoTranslation;
+  #                             gEfiMdePkgTokenSpaceGuid.PcdPciIoTranslation;
   #   TranslatedMmio32Address = (UINT64)UntranslatedMmio32Address +
-  #                             PcdPciMmio32Translation;
+  #                             gEfiMdePkgTokenSpaceGuid.PcdPciMmio32Translation;
   #   TranslatedMmio64Address = UntranslatedMmio64Address +
-  #                             PcdPciMmio64Translation;
+  #                             gEfiMdePkgTokenSpaceGuid.PcdPciMmio64Translation;
   #
   #  The modular arithmetic performed in UINT64 ensures that the translation
   #  works correctly regardless of the relation between IoCpuBase and
@@ -296,16 +370,20 @@
   #
   gArmTokenSpaceGuid.PcdPciIoBase|0x0|UINT64|0x00000050
   gArmTokenSpaceGuid.PcdPciIoSize|0x0|UINT64|0x00000051
-  gArmTokenSpaceGuid.PcdPciIoTranslation|0x0|UINT64|0x00000052
   gArmTokenSpaceGuid.PcdPciMmio32Base|0x0|UINT32|0x00000053
   gArmTokenSpaceGuid.PcdPciMmio32Size|0x0|UINT32|0x00000054
-  gArmTokenSpaceGuid.PcdPciMmio32Translation|0x0|UINT64|0x00000055
   gArmTokenSpaceGuid.PcdPciMmio64Base|0x0|UINT64|0x00000056
   gArmTokenSpaceGuid.PcdPciMmio64Size|0x0|UINT64|0x00000057
-  gArmTokenSpaceGuid.PcdPciMmio64Translation|0x0|UINT64|0x00000058
 
   #
   # Inclusive range of allowed PCI buses.
   #
   gArmTokenSpaceGuid.PcdPciBusMin|0x0|UINT32|0x00000059
   gArmTokenSpaceGuid.PcdPciBusMax|0x0|UINT32|0x0000005A
+
+[PcdsDynamicEx]
+  #
+  # This dynamic PCD hold the GUID of a firmware FFS which contains
+  # the LinuxBoot payload.
+  #
+  gArmTokenSpaceGuid.PcdLinuxBootFileGuid|{0x0}|VOID*|0x0000005C

ArmPkg/ArmPkg.dsc

@@ -2,8 +2,10 @@
 # ARM processor package.
 #
 # Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>
-# Copyright (c) 2011 - 2018, ARM Ltd. All rights reserved.<BR>
+# Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>
 # Copyright (c) 2016, Linaro Ltd. All rights reserved.<BR>
+# Copyright (c) Microsoft Corporation.<BR>
+# Copyright (c) 2021, Ampere Computing LLC. All rights reserved.
 #
 #    SPDX-License-Identifier: BSD-2-Clause-Patent
 #
@@ -28,17 +30,25 @@
   RELEASE_*_*_CC_FLAGS  = -DMDEPKG_NDEBUG
   *_*_*_CC_FLAGS  = -DDISABLE_NEW_DEPRECATED_INTERFACES
 
+[PcdsFixedAtBuild]
+  gEfiMdePkgTokenSpaceGuid.PcdDefaultTerminalType|4
+
+!include MdePkg/MdeLibs.dsc.inc
+
 [LibraryClasses.common]
   BaseLib|MdePkg/Library/BaseLib/BaseLib.inf
   BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf
+  BootLogoLib|MdeModulePkg/Library/BootLogoLib/BootLogoLib.inf
   CacheMaintenanceLib|ArmPkg/Library/ArmCacheMaintenanceLib/ArmCacheMaintenanceLib.inf
   CapsuleLib|MdeModulePkg/Library/DxeCapsuleLibNull/DxeCapsuleLibNull.inf
   DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf
+  DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf
   HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf
   MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf
   PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf
   PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf
   TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
+  UefiBootManagerLib|MdeModulePkg/Library/UefiBootManagerLib/UefiBootManagerLib.inf
   UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
   UefiDriverEntryPoint|MdePkg/Library/UefiDriverEntryPoint/UefiDriverEntryPoint.inf
   UefiLib|MdePkg/Library/UefiLib/UefiLib.inf
@@ -46,6 +56,7 @@
   UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf
   PeCoffLib|MdePkg/Library/BasePeCoffLib/BasePeCoffLib.inf
   PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
+  PeCoffExtraActionLib|MdePkg/Library/BasePeCoffExtraActionLibNull/BasePeCoffExtraActionLibNull.inf
 
   UefiHiiServicesLib|MdeModulePkg/Library/UefiHiiServicesLib/UefiHiiServicesLib.inf
   HiiLib|MdeModulePkg/Library/UefiHiiLib/UefiHiiLib.inf
@@ -80,6 +91,8 @@
 
   ArmMtlLib|ArmPkg/Library/ArmMtlNullLib/ArmMtlNullLib.inf
 
+  OemMiscLib|ArmPkg/Universal/Smbios/OemMiscLibNull/OemMiscLibNull.inf
+
 [LibraryClasses.common.PEIM]
   HobLib|MdePkg/Library/PeiHobLib/PeiHobLib.inf
   PeimEntryPoint|MdePkg/Library/PeimEntryPoint/PeimEntryPoint.inf
@@ -133,12 +146,23 @@
   ArmPkg/Library/ArmGicArchLib/ArmGicArchLib.inf
   ArmPkg/Library/ArmGicArchSecLib/ArmGicArchSecLib.inf
   ArmPkg/Library/ArmLib/ArmBaseLib.inf
+  ArmPkg/Library/ArmMtlNullLib/ArmMtlNullLib.inf
   ArmPkg/Library/ArmSoftFloatLib/ArmSoftFloatLib.inf
+  ArmPkg/Library/ArmSmcPsciResetSystemLib/ArmSmcPsciResetSystemLib.inf
   ArmPkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointerLib.inf
   ArmPkg/Library/PlatformBootManagerLib/PlatformBootManagerLib.inf
+  ArmPkg/Library/LinuxBootBootManagerLib/LinuxBootBootManagerLib.inf
 
+  ArmPkg/Drivers/ArmCrashDumpDxe/ArmCrashDumpDxe.inf
   ArmPkg/Drivers/ArmScmiDxe/ArmScmiDxe.inf
 
+  ArmPkg/Universal/Smbios/ProcessorSubClassDxe/ProcessorSubClassDxe.inf
+  ArmPkg/Universal/Smbios/SmbiosMiscDxe/SmbiosMiscDxe.inf
+  ArmPkg/Universal/Smbios/OemMiscLibNull/OemMiscLibNull.inf
+
 [Components.AARCH64]
+  ArmPkg/Drivers/MmCommunicationDxe/MmCommunication.inf
   ArmPkg/Library/ArmMmuLib/ArmMmuPeiLib.inf
+
+[Components.AARCH64, Components.ARM]
   ArmPkg/Library/StandaloneMmMmuLib/ArmMmuStandaloneMmLib.inf

ArmPkg/Drivers/ArmCrashDumpDxe/ArmCrashDumpDxe.c

@@ -12,21 +12,23 @@
 #include <Library/UefiBootServicesTableLib.h>
 #include <Protocol/Cpu.h>
 
-STATIC EFI_CPU_ARCH_PROTOCOL      *mCpu;
+STATIC EFI_CPU_ARCH_PROTOCOL  *mCpu;
 
 EFI_STATUS
 EFIAPI
 ArmCrashDumpDxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
-  EFI_STATUS      Status;
+  EFI_STATUS  Status;
 
   Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **)&mCpu);
-  ASSERT_EFI_ERROR(Status);
+  ASSERT_EFI_ERROR (Status);
 
-  return mCpu->RegisterInterruptHandler (mCpu,
+  return mCpu->RegisterInterruptHandler (
-                                         EXCEPT_AARCH64_SYNCHRONOUS_EXCEPTIONS,
+                 mCpu,
-                                         &DefaultExceptionHandler);
+                 EXCEPT_AARCH64_SYNCHRONOUS_EXCEPTIONS,
+                 &DefaultExceptionHandler
+                 );
 }

ArmPkg/Drivers/ArmGic/ArmGicCommonDxe.c

@@ -11,8 +11,8 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
 VOID
 EFIAPI
 IrqInterruptHandler (
-  IN EFI_EXCEPTION_TYPE           InterruptType,
+  IN EFI_EXCEPTION_TYPE  InterruptType,
-  IN EFI_SYSTEM_CONTEXT           SystemContext
+  IN EFI_SYSTEM_CONTEXT  SystemContext
   );
 
 VOID
@@ -26,14 +26,13 @@ ExitBootServicesEvent (
 EFI_HANDLE  gHardwareInterruptHandle = NULL;
 
 // Notifications
-EFI_EVENT EfiExitBootServicesEvent      = (EFI_EVENT)NULL;
+EFI_EVENT  EfiExitBootServicesEvent = (EFI_EVENT)NULL;
 
 // Maximum Number of Interrupts
-UINTN mGicNumInterrupts                 = 0;
+UINTN  mGicNumInterrupts = 0;
 
 HARDWARE_INTERRUPT_HANDLER  *gRegisteredInterruptHandlers = NULL;
 
-
 /**
   Calculate GICD_ICFGRn base address and corresponding bit
   field Int_config[1] of the GIC distributor register.
@@ -47,21 +46,21 @@ HARDWARE_INTERRUPT_HANDLER  *gRegisteredInterruptHandlers = NULL;
 **/
 EFI_STATUS
 GicGetDistributorIcfgBaseAndBit (
-  IN HARDWARE_INTERRUPT_SOURCE             Source,
+  IN HARDWARE_INTERRUPT_SOURCE  Source,
-  OUT UINTN                               *RegAddress,
+  OUT UINTN                     *RegAddress,
-  OUT UINTN                               *Config1Bit
+  OUT UINTN                     *Config1Bit
   )
 {
-  UINTN                  RegIndex;
+  UINTN  RegIndex;
-  UINTN                  Field;
+  UINTN  Field;
 
   if (Source >= mGicNumInterrupts) {
-    ASSERT(Source < mGicNumInterrupts);
+    ASSERT (Source < mGicNumInterrupts);
     return EFI_UNSUPPORTED;
   }
 
-  RegIndex = Source / ARM_GIC_ICDICFR_F_STRIDE;  // NOTE: truncation is significant
+  RegIndex    = Source / ARM_GIC_ICDICFR_F_STRIDE; // NOTE: truncation is significant
-  Field = Source % ARM_GIC_ICDICFR_F_STRIDE;
+  Field       = Source % ARM_GIC_ICDICFR_F_STRIDE;
   *RegAddress = PcdGet64 (PcdGicDistributorBase)
                 + ARM_GIC_ICDICFR
                 + (ARM_GIC_ICDICFR_BYTES * RegIndex);
@@ -71,8 +70,6 @@ GicGetDistributorIcfgBaseAndBit (
   return EFI_SUCCESS;
 }
 
-
-
 /**
   Register Handler for the specified interrupt source.
 
@@ -87,13 +84,13 @@ GicGetDistributorIcfgBaseAndBit (
 EFI_STATUS
 EFIAPI
 RegisterInterruptSource (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source,
+  IN HARDWARE_INTERRUPT_SOURCE        Source,
-  IN HARDWARE_INTERRUPT_HANDLER         Handler
+  IN HARDWARE_INTERRUPT_HANDLER       Handler
   )
 {
   if (Source >= mGicNumInterrupts) {
-    ASSERT(FALSE);
+    ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
 
@@ -108,25 +105,25 @@ RegisterInterruptSource (
   gRegisteredInterruptHandlers[Source] = Handler;
 
   // If the interrupt handler is unregistered then disable the interrupt
-  if (NULL == Handler){
+  if (NULL == Handler) {
     return This->DisableInterruptSource (This, Source);
   } else {
     return This->EnableInterruptSource (This, Source);
   }
 }
 
-STATIC VOID *mCpuArchProtocolNotifyEventRegistration;
+STATIC VOID  *mCpuArchProtocolNotifyEventRegistration;
 
 STATIC
 VOID
 EFIAPI
 CpuArchEventProtocolNotify (
-  IN  EFI_EVENT       Event,
+  IN  EFI_EVENT  Event,
-  IN  VOID            *Context
+  IN  VOID       *Context
   )
 {
-  EFI_CPU_ARCH_PROTOCOL   *Cpu;
+  EFI_CPU_ARCH_PROTOCOL  *Cpu;
-  EFI_STATUS              Status;
+  EFI_STATUS             Status;
 
   // Get the CPU protocol that this driver requires.
   Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **)&Cpu);
@@ -137,17 +134,28 @@ CpuArchEventProtocolNotify (
   // Unregister the default exception handler.
   Status = Cpu->RegisterInterruptHandler (Cpu, ARM_ARCH_EXCEPTION_IRQ, NULL);
   if (EFI_ERROR (Status)) {
-    DEBUG ((DEBUG_ERROR, "%a: Cpu->RegisterInterruptHandler() - %r\n",
+    DEBUG ((
-      __FUNCTION__, Status));
+      DEBUG_ERROR,
+      "%a: Cpu->RegisterInterruptHandler() - %r\n",
+      __FUNCTION__,
+      Status
+      ));
     return;
   }
 
   // Register to receive interrupts
-  Status = Cpu->RegisterInterruptHandler (Cpu, ARM_ARCH_EXCEPTION_IRQ,
+  Status = Cpu->RegisterInterruptHandler (
-                  Context);
+                  Cpu,
+                  ARM_ARCH_EXCEPTION_IRQ,
+                  Context
+                  );
   if (EFI_ERROR (Status)) {
-    DEBUG ((DEBUG_ERROR, "%a: Cpu->RegisterInterruptHandler() - %r\n",
+    DEBUG ((
-      __FUNCTION__, Status));
+      DEBUG_ERROR,
+      "%a: Cpu->RegisterInterruptHandler() - %r\n",
+      __FUNCTION__,
+      Status
+      ));
   }
 
   gBS->CloseEvent (Event);
@@ -157,13 +165,13 @@ EFI_STATUS
 InstallAndRegisterInterruptService (
   IN EFI_HARDWARE_INTERRUPT_PROTOCOL   *InterruptProtocol,
   IN EFI_HARDWARE_INTERRUPT2_PROTOCOL  *Interrupt2Protocol,
-  IN EFI_CPU_INTERRUPT_HANDLER          InterruptHandler,
+  IN EFI_CPU_INTERRUPT_HANDLER         InterruptHandler,
-  IN EFI_EVENT_NOTIFY                   ExitBootServicesEvent
+  IN EFI_EVENT_NOTIFY                  ExitBootServicesEvent
   )
 {
-  EFI_STATUS               Status;
+  EFI_STATUS   Status;
-  CONST UINTN              RihArraySize =
+  CONST UINTN  RihArraySize =
-    (sizeof(HARDWARE_INTERRUPT_HANDLER) * mGicNumInterrupts);
+    (sizeof (HARDWARE_INTERRUPT_HANDLER) * mGicNumInterrupts);
 
   // Initialize the array for the Interrupt Handlers
   gRegisteredInterruptHandlers = AllocateZeroPool (RihArraySize);
@@ -191,7 +199,8 @@ InstallAndRegisterInterruptService (
     TPL_CALLBACK,
     CpuArchEventProtocolNotify,
     InterruptHandler,
-    &mCpuArchProtocolNotifyEventRegistration);
+    &mCpuArchProtocolNotifyEventRegistration
+    );
 
   // Register for an ExitBootServicesEvent
   Status = gBS->CreateEvent (

ArmPkg/Drivers/ArmGic/ArmGicDxe.c

@@ -32,12 +32,12 @@ Abstract:
 **/
 EFI_STATUS
 InterruptDxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
-  EFI_STATUS            Status;
+  EFI_STATUS             Status;
-  ARM_GIC_ARCH_REVISION Revision;
+  ARM_GIC_ARCH_REVISION  Revision;
 
   Revision = ArmGicGetSupportedArchRevision ();
 

ArmPkg/Drivers/ArmGic/ArmGicDxe.h

@@ -6,8 +6,8 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
 
 --*/
 
-#ifndef __ARM_GIC_DXE_H__
+#ifndef ARM_GIC_DXE_H_
-#define __ARM_GIC_DXE_H__
+#define ARM_GIC_DXE_H_
 
 #include <Library/ArmGicLib.h>
 #include <Library/ArmLib.h>
@@ -21,7 +21,7 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
 #include <Protocol/HardwareInterrupt.h>
 #include <Protocol/HardwareInterrupt2.h>
 
-extern UINTN                        mGicNumInterrupts;
+extern UINTN                       mGicNumInterrupts;
 extern HARDWARE_INTERRUPT_HANDLER  *gRegisteredInterruptHandlers;
 
 // Common API
@@ -29,33 +29,32 @@ EFI_STATUS
 InstallAndRegisterInterruptService (
   IN EFI_HARDWARE_INTERRUPT_PROTOCOL   *InterruptProtocol,
   IN EFI_HARDWARE_INTERRUPT2_PROTOCOL  *Interrupt2Protocol,
-  IN EFI_CPU_INTERRUPT_HANDLER          InterruptHandler,
+  IN EFI_CPU_INTERRUPT_HANDLER         InterruptHandler,
-  IN EFI_EVENT_NOTIFY                   ExitBootServicesEvent
+  IN EFI_EVENT_NOTIFY                  ExitBootServicesEvent
   );
 
 EFI_STATUS
 EFIAPI
 RegisterInterruptSource (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source,
+  IN HARDWARE_INTERRUPT_SOURCE        Source,
-  IN HARDWARE_INTERRUPT_HANDLER         Handler
+  IN HARDWARE_INTERRUPT_HANDLER       Handler
   );
 
 // GicV2 API
 EFI_STATUS
 GicV2DxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   );
 
 // GicV3 API
 EFI_STATUS
 GicV3DxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   );
 
-
 // Shared code
 
 /**
@@ -71,9 +70,9 @@ GicV3DxeInitialize (
 **/
 EFI_STATUS
 GicGetDistributorIcfgBaseAndBit (
-  IN HARDWARE_INTERRUPT_SOURCE             Source,
+  IN HARDWARE_INTERRUPT_SOURCE  Source,
-  OUT UINTN                               *RegAddress,
+  OUT UINTN                     *RegAddress,
-  OUT UINTN                               *Config1Bit
+  OUT UINTN                     *Config1Bit
   );
 
-#endif
+#endif // ARM_GIC_DXE_H_

ArmPkg/Drivers/ArmGic/ArmGicLib.c

@@ -1,6 +1,6 @@
 /** @file
 *
-*  Copyright (c) 2011-2018, ARM Limited. All rights reserved.
+*  Copyright (c) 2011-2021, Arm Limited. All rights reserved.
 *
 *  SPDX-License-Identifier: BSD-2-Clause-Patent
 *
@@ -24,11 +24,14 @@
                                            + ARM_GICR_SGI_VLPI_FRAME_SIZE     \
                                            + ARM_GICR_SGI_RESERVED_FRAME_SIZE)
 
-#define ISENABLER_ADDRESS(base,offset) ((base) + \
+#define ISENABLER_ADDRESS(base, offset)  ((base) +\
-          ARM_GICR_CTLR_FRAME_SIZE +  ARM_GICR_ISENABLER + (4 * offset))
+          ARM_GICR_CTLR_FRAME_SIZE + ARM_GICR_ISENABLER + 4 * (offset))
 
-#define ICENABLER_ADDRESS(base,offset) ((base) + \
+#define ICENABLER_ADDRESS(base, offset)  ((base) +\
-          ARM_GICR_CTLR_FRAME_SIZE +  ARM_GICR_ICENABLER + (4 * offset))
+          ARM_GICR_CTLR_FRAME_SIZE + ARM_GICR_ICENABLER + 4 * (offset))
+
+#define IPRIORITY_ADDRESS(base, offset)  ((base) +\
+          ARM_GICR_CTLR_FRAME_SIZE + ARM_GIC_ICDIPR + 4 * (offset))
 
 /**
  *
@@ -54,15 +57,15 @@ SourceIsSpi (
 STATIC
 UINTN
 GicGetCpuRedistributorBase (
-  IN UINTN                 GicRedistributorBase,
+  IN UINTN                  GicRedistributorBase,
-  IN ARM_GIC_ARCH_REVISION Revision
+  IN ARM_GIC_ARCH_REVISION  Revision
   )
 {
-  UINTN MpId;
+  UINTN   MpId;
-  UINTN CpuAffinity;
+  UINTN   CpuAffinity;
-  UINTN Affinity;
+  UINTN   Affinity;
-  UINTN GicCpuRedistributorBase;
+  UINTN   GicCpuRedistributorBase;
-  UINT64 TypeRegister;
+  UINT64  TypeRegister;
 
   MpId = ArmReadMpidr ();
   // Define CPU affinity as:
@@ -80,7 +83,7 @@ GicGetCpuRedistributorBase (
 
   do {
     TypeRegister = MmioRead64 (GicCpuRedistributorBase + ARM_GICR_TYPER);
-    Affinity = ARM_GICR_TYPER_GET_AFFINITY (TypeRegister);
+    Affinity     = ARM_GICR_TYPER_GET_AFFINITY (TypeRegister);
     if (Affinity == CpuAffinity) {
       return GicCpuRedistributorBase;
     }
@@ -104,7 +107,7 @@ GicGetCpuRedistributorBase (
 UINTN
 EFIAPI
 ArmGicGetInterfaceIdentification (
-  IN  INTN          GicInterruptInterfaceBase
+  IN  INTN  GicInterruptInterfaceBase
   )
 {
   // Read the GIC Identification Register
@@ -114,19 +117,26 @@ ArmGicGetInterfaceIdentification (
 UINTN
 EFIAPI
 ArmGicGetMaxNumInterrupts (
-  IN  INTN          GicDistributorBase
+  IN  INTN  GicDistributorBase
   )
 {
-  return 32 * ((MmioRead32 (GicDistributorBase + ARM_GIC_ICDICTR) & 0x1F) + 1);
+  UINTN  ItLines;
+
+  ItLines = MmioRead32 (GicDistributorBase + ARM_GIC_ICDICTR) & 0x1F;
+
+  //
+  // Interrupt ID 1020-1023 are reserved.
+  //
+  return (ItLines == 0x1f) ? 1020 : 32 * (ItLines + 1);
 }
 
 VOID
 EFIAPI
 ArmGicSendSgiTo (
-  IN  INTN          GicDistributorBase,
+  IN  INTN  GicDistributorBase,
-  IN  INTN          TargetListFilter,
+  IN  INTN  TargetListFilter,
-  IN  INTN          CPUTargetList,
+  IN  INTN  CPUTargetList,
-  IN  INTN          SgiId
+  IN  INTN  SgiId
   )
 {
   MmioWrite32 (
@@ -152,12 +162,12 @@ ArmGicSendSgiTo (
 UINTN
 EFIAPI
 ArmGicAcknowledgeInterrupt (
-  IN  UINTN          GicInterruptInterfaceBase,
+  IN  UINTN  GicInterruptInterfaceBase,
-  OUT UINTN          *InterruptId
+  OUT UINTN  *InterruptId
   )
 {
-  UINTN Value;
+  UINTN                  Value;
-  ARM_GIC_ARCH_REVISION Revision;
+  ARM_GIC_ARCH_REVISION  Revision;
 
   Revision = ArmGicGetSupportedArchRevision ();
   if (Revision == ARM_GIC_ARCH_REVISION_2) {
@@ -183,11 +193,11 @@ ArmGicAcknowledgeInterrupt (
 VOID
 EFIAPI
 ArmGicEndOfInterrupt (
-  IN  UINTN                 GicInterruptInterfaceBase,
+  IN  UINTN  GicInterruptInterfaceBase,
-  IN UINTN                  Source
+  IN UINTN   Source
   )
 {
-  ARM_GIC_ARCH_REVISION Revision;
+  ARM_GIC_ARCH_REVISION  Revision;
 
   Revision = ArmGicGetSupportedArchRevision ();
   if (Revision == ARM_GIC_ARCH_REVISION_2) {
@@ -201,25 +211,71 @@ ArmGicEndOfInterrupt (
 
 VOID
 EFIAPI
-ArmGicEnableInterrupt (
+ArmGicSetInterruptPriority (
-  IN UINTN                  GicDistributorBase,
+  IN UINTN  GicDistributorBase,
-  IN UINTN                  GicRedistributorBase,
+  IN UINTN  GicRedistributorBase,
-  IN UINTN                  Source
+  IN UINTN  Source,
+  IN UINTN  Priority
   )
 {
-  UINT32                RegOffset;
+  UINT32                 RegOffset;
-  UINTN                 RegShift;
+  UINTN                  RegShift;
-  ARM_GIC_ARCH_REVISION Revision;
+  ARM_GIC_ARCH_REVISION  Revision;
-  UINTN                 GicCpuRedistributorBase;
+  UINTN                  GicCpuRedistributorBase;
 
-  // Calculate enable register offset and bit position
+  // Calculate register offset and bit position
-  RegOffset = Source / 32;
+  RegOffset = Source / 4;
-  RegShift = Source % 32;
+  RegShift  = (Source % 4) * 8;
 
   Revision = ArmGicGetSupportedArchRevision ();
   if ((Revision == ARM_GIC_ARCH_REVISION_2) ||
       FeaturePcdGet (PcdArmGicV3WithV2Legacy) ||
-      SourceIsSpi (Source)) {
+      SourceIsSpi (Source))
+  {
+    MmioAndThenOr32 (
+      GicDistributorBase + ARM_GIC_ICDIPR + (4 * RegOffset),
+      ~(0xff << RegShift),
+      Priority << RegShift
+      );
+  } else {
+    GicCpuRedistributorBase = GicGetCpuRedistributorBase (
+                                GicRedistributorBase,
+                                Revision
+                                );
+    if (GicCpuRedistributorBase == 0) {
+      return;
+    }
+
+    MmioAndThenOr32 (
+      IPRIORITY_ADDRESS (GicCpuRedistributorBase, RegOffset),
+      ~(0xff << RegShift),
+      Priority << RegShift
+      );
+  }
+}
+
+VOID
+EFIAPI
+ArmGicEnableInterrupt (
+  IN UINTN  GicDistributorBase,
+  IN UINTN  GicRedistributorBase,
+  IN UINTN  Source
+  )
+{
+  UINT32                 RegOffset;
+  UINTN                  RegShift;
+  ARM_GIC_ARCH_REVISION  Revision;
+  UINTN                  GicCpuRedistributorBase;
+
+  // Calculate enable register offset and bit position
+  RegOffset = Source / 32;
+  RegShift  = Source % 32;
+
+  Revision = ArmGicGetSupportedArchRevision ();
+  if ((Revision == ARM_GIC_ARCH_REVISION_2) ||
+      FeaturePcdGet (PcdArmGicV3WithV2Legacy) ||
+      SourceIsSpi (Source))
+  {
     // Write set-enable register
     MmioWrite32 (
       GicDistributorBase + ARM_GIC_ICDISER + (4 * RegOffset),
@@ -237,7 +293,7 @@ ArmGicEnableInterrupt (
 
     // Write set-enable register
     MmioWrite32 (
-      ISENABLER_ADDRESS(GicCpuRedistributorBase, RegOffset),
+      ISENABLER_ADDRESS (GicCpuRedistributorBase, RegOffset),
       1 << RegShift
       );
   }
@@ -246,24 +302,25 @@ ArmGicEnableInterrupt (
 VOID
 EFIAPI
 ArmGicDisableInterrupt (
-  IN UINTN                  GicDistributorBase,
+  IN UINTN  GicDistributorBase,
-  IN UINTN                  GicRedistributorBase,
+  IN UINTN  GicRedistributorBase,
-  IN UINTN                  Source
+  IN UINTN  Source
   )
 {
-  UINT32                RegOffset;
+  UINT32                 RegOffset;
-  UINTN                 RegShift;
+  UINTN                  RegShift;
-  ARM_GIC_ARCH_REVISION Revision;
+  ARM_GIC_ARCH_REVISION  Revision;
-  UINTN                 GicCpuRedistributorBase;
+  UINTN                  GicCpuRedistributorBase;
 
   // Calculate enable register offset and bit position
   RegOffset = Source / 32;
-  RegShift = Source % 32;
+  RegShift  = Source % 32;
 
   Revision = ArmGicGetSupportedArchRevision ();
   if ((Revision == ARM_GIC_ARCH_REVISION_2) ||
       FeaturePcdGet (PcdArmGicV3WithV2Legacy) ||
-      SourceIsSpi (Source)) {
+      SourceIsSpi (Source))
+  {
     // Write clear-enable register
     MmioWrite32 (
       GicDistributorBase + ARM_GIC_ICDICER + (4 * RegOffset),
@@ -271,16 +328,16 @@ ArmGicDisableInterrupt (
       );
   } else {
     GicCpuRedistributorBase = GicGetCpuRedistributorBase (
-      GicRedistributorBase,
+                                GicRedistributorBase,
-      Revision
+                                Revision
-      );
+                                );
     if (GicCpuRedistributorBase == 0) {
       return;
     }
 
     // Write clear-enable register
     MmioWrite32 (
-      ICENABLER_ADDRESS(GicCpuRedistributorBase, RegOffset),
+      ICENABLER_ADDRESS (GicCpuRedistributorBase, RegOffset),
       1 << RegShift
       );
   }
@@ -289,29 +346,30 @@ ArmGicDisableInterrupt (
 BOOLEAN
 EFIAPI
 ArmGicIsInterruptEnabled (
-  IN UINTN                  GicDistributorBase,
+  IN UINTN  GicDistributorBase,
-  IN UINTN                  GicRedistributorBase,
+  IN UINTN  GicRedistributorBase,
-  IN UINTN                  Source
+  IN UINTN  Source
   )
 {
-  UINT32                RegOffset;
+  UINT32                 RegOffset;
-  UINTN                 RegShift;
+  UINTN                  RegShift;
-  ARM_GIC_ARCH_REVISION Revision;
+  ARM_GIC_ARCH_REVISION  Revision;
-  UINTN                 GicCpuRedistributorBase;
+  UINTN                  GicCpuRedistributorBase;
-  UINT32                Interrupts;
+  UINT32                 Interrupts;
 
   // Calculate enable register offset and bit position
   RegOffset = Source / 32;
-  RegShift = Source % 32;
+  RegShift  = Source % 32;
 
   Revision = ArmGicGetSupportedArchRevision ();
   if ((Revision == ARM_GIC_ARCH_REVISION_2) ||
       FeaturePcdGet (PcdArmGicV3WithV2Legacy) ||
-      SourceIsSpi (Source)) {
+      SourceIsSpi (Source))
+  {
     Interrupts = ((MmioRead32 (
                      GicDistributorBase + ARM_GIC_ICDISER + (4 * RegOffset)
                      )
-                  & (1 << RegShift)) != 0);
+                   & (1 << RegShift)) != 0);
   } else {
     GicCpuRedistributorBase = GicGetCpuRedistributorBase (
                                 GicRedistributorBase,
@@ -323,7 +381,7 @@ ArmGicIsInterruptEnabled (
 
     // Read set-enable register
     Interrupts = MmioRead32 (
-                   ISENABLER_ADDRESS(GicCpuRedistributorBase, RegOffset)
+                   ISENABLER_ADDRESS (GicCpuRedistributorBase, RegOffset)
                    );
   }
 
@@ -333,7 +391,7 @@ ArmGicIsInterruptEnabled (
 VOID
 EFIAPI
 ArmGicDisableDistributor (
-  IN  INTN          GicDistributorBase
+  IN  INTN  GicDistributorBase
   )
 {
   // Disable Gic Distributor
@@ -343,10 +401,10 @@ ArmGicDisableDistributor (
 VOID
 EFIAPI
 ArmGicEnableInterruptInterface (
-  IN  INTN          GicInterruptInterfaceBase
+  IN  INTN  GicInterruptInterfaceBase
   )
 {
-  ARM_GIC_ARCH_REVISION Revision;
+  ARM_GIC_ARCH_REVISION  Revision;
 
   Revision = ArmGicGetSupportedArchRevision ();
   if (Revision == ARM_GIC_ARCH_REVISION_2) {
@@ -361,10 +419,10 @@ ArmGicEnableInterruptInterface (
 VOID
 EFIAPI
 ArmGicDisableInterruptInterface (
-  IN  INTN          GicInterruptInterfaceBase
+  IN  INTN  GicInterruptInterfaceBase
   )
 {
-  ARM_GIC_ARCH_REVISION Revision;
+  ARM_GIC_ARCH_REVISION  Revision;
 
   Revision = ArmGicGetSupportedArchRevision ();
   if (Revision == ARM_GIC_ARCH_REVISION_2) {

ArmPkg/Drivers/ArmGic/ArmGicNonSecLib.c

@@ -13,10 +13,10 @@
 VOID
 EFIAPI
 ArmGicEnableDistributor (
-  IN  INTN          GicDistributorBase
+  IN  INTN  GicDistributorBase
   )
 {
-  ARM_GIC_ARCH_REVISION Revision;
+  ARM_GIC_ARCH_REVISION  Revision;
 
   /*
    * Enable GIC distributor in Non-Secure world.

ArmPkg/Drivers/ArmGic/ArmGicSecLib.c

@@ -1,58 +0,0 @@
-/** @file
-*
-*  Copyright (c) 2011-2014, ARM Limited. All rights reserved.
-*
-*  SPDX-License-Identifier: BSD-2-Clause-Patent
-*
-**/
-
-#include <Base.h>
-#include <Library/DebugLib.h>
-#include <Library/IoLib.h>
-#include <Library/ArmGicLib.h>
-
-/*
- * This function configures the interrupts set by the mask to be secure.
- *
- */
-VOID
-EFIAPI
-ArmGicSetSecureInterrupts (
-  IN  UINTN         GicDistributorBase,
-  IN  UINTN*        GicSecureInterruptMask,
-  IN  UINTN         GicSecureInterruptMaskSize
-  )
-{
-  UINTN  Index;
-  UINT32 InterruptStatus;
-
-  // We must not have more interrupts defined by the mask than the number of available interrupts
-  ASSERT(GicSecureInterruptMaskSize <= (ArmGicGetMaxNumInterrupts (GicDistributorBase) / 32));
-
-  // Set all the interrupts defined by the mask as Secure
-  for (Index = 0; Index < GicSecureInterruptMaskSize; Index++) {
-    InterruptStatus = MmioRead32 (GicDistributorBase + ARM_GIC_ICDISR + (Index * 4));
-    MmioWrite32 (GicDistributorBase + ARM_GIC_ICDISR + (Index * 4), InterruptStatus & (~GicSecureInterruptMask[Index]));
-  }
-}
-
-VOID
-EFIAPI
-ArmGicEnableDistributor (
-  IN  INTN          GicDistributorBase
-  )
-{
-  // Turn on the GIC distributor
-  MmioWrite32 (GicDistributorBase + ARM_GIC_ICDDCR, 1);
-}
-
-VOID
-EFIAPI
-ArmGicSetupNonSecure (
-  IN  UINTN         MpId,
-  IN  INTN          GicDistributorBase,
-  IN  INTN          GicInterruptInterfaceBase
-  )
-{
-  ArmGicV2SetupNonSecure (MpId, GicDistributorBase, GicInterruptInterfaceBase);
-}

ArmPkg/Drivers/ArmGic/GicV2/ArmGicV2Dxe.c

@@ -22,11 +22,11 @@ Abstract:
 
 #define ARM_GIC_DEFAULT_PRIORITY  0x80
 
-extern EFI_HARDWARE_INTERRUPT_PROTOCOL gHardwareInterruptV2Protocol;
+extern EFI_HARDWARE_INTERRUPT_PROTOCOL   gHardwareInterruptV2Protocol;
-extern EFI_HARDWARE_INTERRUPT2_PROTOCOL gHardwareInterrupt2V2Protocol;
+extern EFI_HARDWARE_INTERRUPT2_PROTOCOL  gHardwareInterrupt2V2Protocol;
 
-STATIC UINT32 mGicInterruptInterfaceBase;
+STATIC UINT32  mGicInterruptInterfaceBase;
-STATIC UINT32 mGicDistributorBase;
+STATIC UINT32  mGicDistributorBase;
 
 /**
   Enable interrupt source Source.
@@ -42,12 +42,12 @@ STATIC
 EFI_STATUS
 EFIAPI
 GicV2EnableInterruptSource (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source
+  IN HARDWARE_INTERRUPT_SOURCE        Source
   )
 {
   if (Source >= mGicNumInterrupts) {
-    ASSERT(FALSE);
+    ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
 
@@ -70,12 +70,12 @@ STATIC
 EFI_STATUS
 EFIAPI
 GicV2DisableInterruptSource (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source
+  IN HARDWARE_INTERRUPT_SOURCE        Source
   )
 {
   if (Source >= mGicNumInterrupts) {
-    ASSERT(FALSE);
+    ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
 
@@ -99,13 +99,13 @@ STATIC
 EFI_STATUS
 EFIAPI
 GicV2GetInterruptSourceState (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source,
+  IN HARDWARE_INTERRUPT_SOURCE        Source,
-  IN BOOLEAN                            *InterruptState
+  IN BOOLEAN                          *InterruptState
   )
 {
   if (Source >= mGicNumInterrupts) {
-    ASSERT(FALSE);
+    ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
 
@@ -121,7 +121,7 @@ GicV2GetInterruptSourceState (
   @param This     Instance pointer for this protocol
   @param Source   Hardware source of the interrupt
 
-  @retval EFI_SUCCESS       Source interrupt EOI'ed.
+  @retval EFI_SUCCESS       Source interrupt ended successfully.
   @retval EFI_UNSUPPORTED   Source interrupt is not supported
 
 **/
@@ -129,12 +129,12 @@ STATIC
 EFI_STATUS
 EFIAPI
 GicV2EndOfInterrupt (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source
+  IN HARDWARE_INTERRUPT_SOURCE        Source
   )
 {
   if (Source >= mGicNumInterrupts) {
-    ASSERT(FALSE);
+    ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
 
@@ -158,8 +158,8 @@ STATIC
 VOID
 EFIAPI
 GicV2IrqInterruptHandler (
-  IN EFI_EXCEPTION_TYPE           InterruptType,
+  IN EFI_EXCEPTION_TYPE  InterruptType,
-  IN EFI_SYSTEM_CONTEXT           SystemContext
+  IN EFI_SYSTEM_CONTEXT  SystemContext
   )
 {
   UINT32                      GicInterrupt;
@@ -185,7 +185,7 @@ GicV2IrqInterruptHandler (
 }
 
 // The protocol instance produced by this driver
-EFI_HARDWARE_INTERRUPT_PROTOCOL gHardwareInterruptV2Protocol = {
+EFI_HARDWARE_INTERRUPT_PROTOCOL  gHardwareInterruptV2Protocol = {
   RegisterInterruptSource,
   GicV2EnableInterruptSource,
   GicV2DisableInterruptSource,
@@ -208,28 +208,28 @@ EFI_STATUS
 EFIAPI
 GicV2GetTriggerType (
   IN  EFI_HARDWARE_INTERRUPT2_PROTOCOL      *This,
-  IN  HARDWARE_INTERRUPT_SOURCE              Source,
+  IN  HARDWARE_INTERRUPT_SOURCE             Source,
   OUT EFI_HARDWARE_INTERRUPT2_TRIGGER_TYPE  *TriggerType
   )
 {
-  UINTN                   RegAddress;
+  UINTN       RegAddress;
-  UINTN                   Config1Bit;
+  UINTN       Config1Bit;
-  EFI_STATUS              Status;
+  EFI_STATUS  Status;
 
   Status = GicGetDistributorIcfgBaseAndBit (
-              Source,
+             Source,
-              &RegAddress,
+             &RegAddress,
-              &Config1Bit
+             &Config1Bit
-              );
+             );
 
   if (EFI_ERROR (Status)) {
     return Status;
   }
 
   if ((MmioRead32 (RegAddress) & (1 << Config1Bit)) == 0) {
-     *TriggerType = EFI_HARDWARE_INTERRUPT2_TRIGGER_LEVEL_HIGH;
+    *TriggerType = EFI_HARDWARE_INTERRUPT2_TRIGGER_LEVEL_HIGH;
   } else {
-     *TriggerType = EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING;
+    *TriggerType = EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING;
   }
 
   return EFI_SUCCESS;
@@ -254,18 +254,22 @@ GicV2SetTriggerType (
   IN  EFI_HARDWARE_INTERRUPT2_TRIGGER_TYPE  TriggerType
   )
 {
-  UINTN                   RegAddress;
+  UINTN       RegAddress;
-  UINTN                   Config1Bit;
+  UINTN       Config1Bit;
-  UINT32                  Value;
+  UINT32      Value;
-  EFI_STATUS              Status;
+  EFI_STATUS  Status;
-  BOOLEAN                 SourceEnabled;
+  BOOLEAN     SourceEnabled;
 
-  if (   (TriggerType != EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING)
+  if (  (TriggerType != EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING)
-      && (TriggerType != EFI_HARDWARE_INTERRUPT2_TRIGGER_LEVEL_HIGH)) {
+     && (TriggerType != EFI_HARDWARE_INTERRUPT2_TRIGGER_LEVEL_HIGH))
-          DEBUG ((DEBUG_ERROR, "Invalid interrupt trigger type: %d\n", \
+  {
-                  TriggerType));
+    DEBUG ((
-          ASSERT (FALSE);
+      DEBUG_ERROR,
-          return EFI_UNSUPPORTED;
+      "Invalid interrupt trigger type: %d\n", \
+      TriggerType
+      ));
+    ASSERT (FALSE);
+    return EFI_UNSUPPORTED;
   }
 
   Status = GicGetDistributorIcfgBaseAndBit (
@@ -279,7 +283,7 @@ GicV2SetTriggerType (
   }
 
   Status = GicV2GetInterruptSourceState (
-             (EFI_HARDWARE_INTERRUPT_PROTOCOL*)This,
+             (EFI_HARDWARE_INTERRUPT_PROTOCOL *)This,
              Source,
              &SourceEnabled
              );
@@ -296,7 +300,7 @@ GicV2SetTriggerType (
   // otherwise GIC behavior is UNPREDICTABLE.
   if (SourceEnabled) {
     GicV2DisableInterruptSource (
-      (EFI_HARDWARE_INTERRUPT_PROTOCOL*)This,
+      (EFI_HARDWARE_INTERRUPT_PROTOCOL *)This,
       Source
       );
   }
@@ -310,7 +314,7 @@ GicV2SetTriggerType (
   // Restore interrupt state
   if (SourceEnabled) {
     GicV2EnableInterruptSource (
-      (EFI_HARDWARE_INTERRUPT_PROTOCOL*)This,
+      (EFI_HARDWARE_INTERRUPT_PROTOCOL *)This,
       Source
       );
   }
@@ -318,7 +322,7 @@ GicV2SetTriggerType (
   return EFI_SUCCESS;
 }
 
-EFI_HARDWARE_INTERRUPT2_PROTOCOL gHardwareInterrupt2V2Protocol = {
+EFI_HARDWARE_INTERRUPT2_PROTOCOL  gHardwareInterrupt2V2Protocol = {
   (HARDWARE_INTERRUPT2_REGISTER)RegisterInterruptSource,
   (HARDWARE_INTERRUPT2_ENABLE)GicV2EnableInterruptSource,
   (HARDWARE_INTERRUPT2_DISABLE)GicV2DisableInterruptSource,
@@ -345,8 +349,8 @@ GicV2ExitBootServicesEvent (
   IN VOID       *Context
   )
 {
-  UINTN    Index;
+  UINTN   Index;
-  UINT32   GicInterrupt;
+  UINT32  GicInterrupt;
 
   // Disable all the interrupts
   for (Index = 0; Index < mGicNumInterrupts; Index++) {
@@ -382,30 +386,30 @@ GicV2ExitBootServicesEvent (
 **/
 EFI_STATUS
 GicV2DxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
-  EFI_STATUS              Status;
+  EFI_STATUS  Status;
-  UINTN                   Index;
+  UINTN       Index;
-  UINT32                  RegOffset;
+  UINT32      RegOffset;
-  UINTN                   RegShift;
+  UINTN       RegShift;
-  UINT32                  CpuTarget;
+  UINT32      CpuTarget;
 
   // Make sure the Interrupt Controller Protocol is not already installed in
   // the system.
   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gHardwareInterruptProtocolGuid);
 
   mGicInterruptInterfaceBase = PcdGet64 (PcdGicInterruptInterfaceBase);
-  mGicDistributorBase = PcdGet64 (PcdGicDistributorBase);
+  mGicDistributorBase        = PcdGet64 (PcdGicDistributorBase);
-  mGicNumInterrupts = ArmGicGetMaxNumInterrupts (mGicDistributorBase);
+  mGicNumInterrupts          = ArmGicGetMaxNumInterrupts (mGicDistributorBase);
 
   for (Index = 0; Index < mGicNumInterrupts; Index++) {
     GicV2DisableInterruptSource (&gHardwareInterruptV2Protocol, Index);
 
     // Set Priority
     RegOffset = Index / 4;
-    RegShift = (Index % 4) * 8;
+    RegShift  = (Index % 4) * 8;
     MmioAndThenOr32 (
       mGicDistributorBase + ARM_GIC_ICDIPR + (4 * RegOffset),
       ~(0xff << RegShift),

ArmPkg/Drivers/ArmGic/GicV2/ArmGicV2Lib.c

@@ -12,7 +12,7 @@
 UINTN
 EFIAPI
 ArmGicV2AcknowledgeInterrupt (
-  IN  UINTN          GicInterruptInterfaceBase
+  IN  UINTN  GicInterruptInterfaceBase
   )
 {
   // Read the Interrupt Acknowledge Register
@@ -22,8 +22,8 @@ ArmGicV2AcknowledgeInterrupt (
 VOID
 EFIAPI
 ArmGicV2EndOfInterrupt (
-  IN  UINTN                 GicInterruptInterfaceBase,
+  IN  UINTN  GicInterruptInterfaceBase,
-  IN UINTN                  Source
+  IN UINTN   Source
   )
 {
   MmioWrite32 (GicInterruptInterfaceBase + ARM_GIC_ICCEIOR, Source);

ArmPkg/Drivers/ArmGic/GicV2/ArmGicV2NonSecLib.c

@@ -10,11 +10,10 @@
 #include <Library/IoLib.h>
 #include <Library/ArmGicLib.h>
 
-
 VOID
 EFIAPI
 ArmGicV2EnableInterruptInterface (
-  IN  INTN          GicInterruptInterfaceBase
+  IN  INTN  GicInterruptInterfaceBase
   )
 {
   /*
@@ -27,7 +26,7 @@ ArmGicV2EnableInterruptInterface (
 VOID
 EFIAPI
 ArmGicV2DisableInterruptInterface (
-  IN  INTN          GicInterruptInterfaceBase
+  IN  INTN  GicInterruptInterfaceBase
   )
 {
   // Disable Gic Interface

ArmPkg/Drivers/ArmGic/GicV3/ArmGicV3Dxe.c

@@ -12,11 +12,11 @@
 
 #define ARM_GIC_DEFAULT_PRIORITY  0x80
 
-extern EFI_HARDWARE_INTERRUPT_PROTOCOL gHardwareInterruptV3Protocol;
+extern EFI_HARDWARE_INTERRUPT_PROTOCOL   gHardwareInterruptV3Protocol;
-extern EFI_HARDWARE_INTERRUPT2_PROTOCOL gHardwareInterrupt2V3Protocol;
+extern EFI_HARDWARE_INTERRUPT2_PROTOCOL  gHardwareInterrupt2V3Protocol;
 
-STATIC UINTN mGicDistributorBase;
+STATIC UINTN  mGicDistributorBase;
-STATIC UINTN mGicRedistributorsBase;
+STATIC UINTN  mGicRedistributorsBase;
 
 /**
   Enable interrupt source Source.
@@ -32,12 +32,12 @@ STATIC
 EFI_STATUS
 EFIAPI
 GicV3EnableInterruptSource (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source
+  IN HARDWARE_INTERRUPT_SOURCE        Source
   )
 {
   if (Source >= mGicNumInterrupts) {
-    ASSERT(FALSE);
+    ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
 
@@ -60,12 +60,12 @@ STATIC
 EFI_STATUS
 EFIAPI
 GicV3DisableInterruptSource (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source
+  IN HARDWARE_INTERRUPT_SOURCE        Source
   )
 {
   if (Source >= mGicNumInterrupts) {
-    ASSERT(FALSE);
+    ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
 
@@ -89,13 +89,13 @@ STATIC
 EFI_STATUS
 EFIAPI
 GicV3GetInterruptSourceState (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source,
+  IN HARDWARE_INTERRUPT_SOURCE        Source,
-  IN BOOLEAN                            *InterruptState
+  IN BOOLEAN                          *InterruptState
   )
 {
   if (Source >= mGicNumInterrupts) {
-    ASSERT(FALSE);
+    ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
 
@@ -115,7 +115,7 @@ GicV3GetInterruptSourceState (
   @param This     Instance pointer for this protocol
   @param Source   Hardware source of the interrupt
 
-  @retval EFI_SUCCESS       Source interrupt EOI'ed.
+  @retval EFI_SUCCESS       Source interrupt ended successfully.
   @retval EFI_DEVICE_ERROR  Hardware could not be programmed.
 
 **/
@@ -123,12 +123,12 @@ STATIC
 EFI_STATUS
 EFIAPI
 GicV3EndOfInterrupt (
-  IN EFI_HARDWARE_INTERRUPT_PROTOCOL    *This,
+  IN EFI_HARDWARE_INTERRUPT_PROTOCOL  *This,
-  IN HARDWARE_INTERRUPT_SOURCE          Source
+  IN HARDWARE_INTERRUPT_SOURCE        Source
   )
 {
   if (Source >= mGicNumInterrupts) {
-    ASSERT(FALSE);
+    ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
 
@@ -152,8 +152,8 @@ STATIC
 VOID
 EFIAPI
 GicV3IrqInterruptHandler (
-  IN EFI_EXCEPTION_TYPE           InterruptType,
+  IN EFI_EXCEPTION_TYPE  InterruptType,
-  IN EFI_SYSTEM_CONTEXT           SystemContext
+  IN EFI_SYSTEM_CONTEXT  SystemContext
   )
 {
   UINT32                      GicInterrupt;
@@ -179,7 +179,7 @@ GicV3IrqInterruptHandler (
 }
 
 // The protocol instance produced by this driver
-EFI_HARDWARE_INTERRUPT_PROTOCOL gHardwareInterruptV3Protocol = {
+EFI_HARDWARE_INTERRUPT_PROTOCOL  gHardwareInterruptV3Protocol = {
   RegisterInterruptSource,
   GicV3EnableInterruptSource,
   GicV3DisableInterruptSource,
@@ -206,9 +206,9 @@ GicV3GetTriggerType (
   OUT EFI_HARDWARE_INTERRUPT2_TRIGGER_TYPE  *TriggerType
   )
 {
-  UINTN                   RegAddress;
+  UINTN       RegAddress;
-  UINTN                   Config1Bit;
+  UINTN       Config1Bit;
-  EFI_STATUS              Status;
+  EFI_STATUS  Status;
 
   Status = GicGetDistributorIcfgBaseAndBit (
              Source,
@@ -221,9 +221,9 @@ GicV3GetTriggerType (
   }
 
   if ((MmioRead32 (RegAddress) & (1 << Config1Bit)) == 0) {
-     *TriggerType = EFI_HARDWARE_INTERRUPT2_TRIGGER_LEVEL_HIGH;
+    *TriggerType = EFI_HARDWARE_INTERRUPT2_TRIGGER_LEVEL_HIGH;
   } else {
-     *TriggerType = EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING;
+    *TriggerType = EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING;
   }
 
   return EFI_SUCCESS;
@@ -248,18 +248,22 @@ GicV3SetTriggerType (
   IN  EFI_HARDWARE_INTERRUPT2_TRIGGER_TYPE  TriggerType
   )
 {
-  UINTN                   RegAddress;
+  UINTN       RegAddress;
-  UINTN                   Config1Bit;
+  UINTN       Config1Bit;
-  UINT32                  Value;
+  UINT32      Value;
-  EFI_STATUS              Status;
+  EFI_STATUS  Status;
-  BOOLEAN                 SourceEnabled;
+  BOOLEAN     SourceEnabled;
 
-  if (   (TriggerType != EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING)
+  if (  (TriggerType != EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING)
-      && (TriggerType != EFI_HARDWARE_INTERRUPT2_TRIGGER_LEVEL_HIGH)) {
+     && (TriggerType != EFI_HARDWARE_INTERRUPT2_TRIGGER_LEVEL_HIGH))
-          DEBUG ((DEBUG_ERROR, "Invalid interrupt trigger type: %d\n", \
+  {
-                 TriggerType));
+    DEBUG ((
-          ASSERT (FALSE);
+      DEBUG_ERROR,
-          return EFI_UNSUPPORTED;
+      "Invalid interrupt trigger type: %d\n", \
+      TriggerType
+      ));
+    ASSERT (FALSE);
+    return EFI_UNSUPPORTED;
   }
 
   Status = GicGetDistributorIcfgBaseAndBit (
@@ -273,7 +277,7 @@ GicV3SetTriggerType (
   }
 
   Status = GicV3GetInterruptSourceState (
-             (EFI_HARDWARE_INTERRUPT_PROTOCOL*)This,
+             (EFI_HARDWARE_INTERRUPT_PROTOCOL *)This,
              Source,
              &SourceEnabled
              );
@@ -290,7 +294,7 @@ GicV3SetTriggerType (
   // otherwise GIC behavior is UNPREDICTABLE.
   if (SourceEnabled) {
     GicV3DisableInterruptSource (
-      (EFI_HARDWARE_INTERRUPT_PROTOCOL*)This,
+      (EFI_HARDWARE_INTERRUPT_PROTOCOL *)This,
       Source
       );
   }
@@ -303,7 +307,7 @@ GicV3SetTriggerType (
   // Restore interrupt state
   if (SourceEnabled) {
     GicV3EnableInterruptSource (
-      (EFI_HARDWARE_INTERRUPT_PROTOCOL*)This,
+      (EFI_HARDWARE_INTERRUPT_PROTOCOL *)This,
       Source
       );
   }
@@ -311,7 +315,7 @@ GicV3SetTriggerType (
   return EFI_SUCCESS;
 }
 
-EFI_HARDWARE_INTERRUPT2_PROTOCOL gHardwareInterrupt2V3Protocol = {
+EFI_HARDWARE_INTERRUPT2_PROTOCOL  gHardwareInterrupt2V3Protocol = {
   (HARDWARE_INTERRUPT2_REGISTER)RegisterInterruptSource,
   (HARDWARE_INTERRUPT2_ENABLE)GicV3EnableInterruptSource,
   (HARDWARE_INTERRUPT2_DISABLE)GicV3DisableInterruptSource,
@@ -337,17 +341,13 @@ GicV3ExitBootServicesEvent (
   IN VOID       *Context
   )
 {
-  UINTN    Index;
+  UINTN  Index;
 
   // Acknowledge all pending interrupts
   for (Index = 0; Index < mGicNumInterrupts; Index++) {
     GicV3DisableInterruptSource (&gHardwareInterruptV3Protocol, Index);
   }
 
-  for (Index = 0; Index < mGicNumInterrupts; Index++) {
-    GicV3EndOfInterrupt (&gHardwareInterruptV3Protocol, Index);
-  }
-
   // Disable Gic Interface
   ArmGicV3DisableInterruptInterface ();
 
@@ -368,16 +368,14 @@ GicV3ExitBootServicesEvent (
 **/
 EFI_STATUS
 GicV3DxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
-  EFI_STATUS              Status;
+  EFI_STATUS  Status;
-  UINTN                   Index;
+  UINTN       Index;
-  UINT32                  RegOffset;
+  UINT64      CpuTarget;
-  UINTN                   RegShift;
+  UINT64      MpId;
-  UINT64                  CpuTarget;
-  UINT64                  MpId;
 
   // Make sure the Interrupt Controller Protocol is not already installed in
   // the system.
@@ -397,12 +395,11 @@ GicV3DxeInitialize (
     GicV3DisableInterruptSource (&gHardwareInterruptV3Protocol, Index);
 
     // Set Priority
-    RegOffset = Index / 4;
+    ArmGicSetInterruptPriority (
-    RegShift = (Index % 4) * 8;
+      mGicDistributorBase,
-    MmioAndThenOr32 (
+      mGicRedistributorsBase,
-      mGicDistributorBase + ARM_GIC_ICDIPR + (4 * RegOffset),
+      Index,
-      ~(0xff << RegShift),
+      ARM_GIC_DEFAULT_PRIORITY
-      ARM_GIC_DEFAULT_PRIORITY << RegShift
       );
   }
 
@@ -431,14 +428,14 @@ GicV3DxeInitialize (
       }
     }
   } else {
-    MpId = ArmReadMpidr ();
+    MpId      = ArmReadMpidr ();
     CpuTarget = MpId &
-      (ARM_CORE_AFF0 | ARM_CORE_AFF1 | ARM_CORE_AFF2 | ARM_CORE_AFF3);
+                (ARM_CORE_AFF0 | ARM_CORE_AFF1 | ARM_CORE_AFF2 | ARM_CORE_AFF3);
 
     if ((MmioRead32 (
            mGicDistributorBase + ARM_GIC_ICDDCR
-         ) & ARM_GIC_ICDDCR_DS) != 0) {
+           ) & ARM_GIC_ICDDCR_DS) != 0)
-
+    {
       // If the Disable Security (DS) control bit is set, we are dealing with a
       // GIC that has only one security state. In this case, let's assume we are
       // executing in non-secure state (which is appropriate for DXE modules)

ArmPkg/Drivers/ArmPciCpuIo2Dxe/ArmPciCpuIo2Dxe.c

@@ -18,7 +18,7 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
 #include <Library/PcdLib.h>
 #include <Library/UefiBootServicesTableLib.h>
 
-#define MAX_IO_PORT_ADDRESS   0xFFFF
+#define MAX_IO_PORT_ADDRESS  0xFFFF
 
 //
 // Handle for the CPU I/O 2 Protocol
@@ -28,7 +28,7 @@ STATIC EFI_HANDLE  mHandle = NULL;
 //
 // Lookup table for increment values based on transfer widths
 //
-STATIC CONST UINT8 mInStride[] = {
+STATIC CONST UINT8  mInStride[] = {
   1, // EfiCpuIoWidthUint8
   2, // EfiCpuIoWidthUint16
   4, // EfiCpuIoWidthUint32
@@ -46,7 +46,7 @@ STATIC CONST UINT8 mInStride[] = {
 //
 // Lookup table for increment values based on transfer widths
 //
-STATIC CONST UINT8 mOutStride[] = {
+STATIC CONST UINT8  mOutStride[] = {
   1, // EfiCpuIoWidthUint8
   2, // EfiCpuIoWidthUint16
   4, // EfiCpuIoWidthUint32
@@ -117,14 +117,14 @@ CpuIoCheckParameter (
   // For FIFO type, the target address won't increase during the access,
   // so treat Count as 1
   //
-  if (Width >= EfiCpuIoWidthFifoUint8 && Width <= EfiCpuIoWidthFifoUint64) {
+  if ((Width >= EfiCpuIoWidthFifoUint8) && (Width <= EfiCpuIoWidthFifoUint64)) {
     Count = 1;
   }
 
   //
   // Check to see if Width is in the valid range for I/O Port operations
   //
-  Width = (EFI_CPU_IO_PROTOCOL_WIDTH) (Width & 0x03);
+  Width = (EFI_CPU_IO_PROTOCOL_WIDTH)(Width & 0x03);
   if (!MmioOperation && (Width == EfiCpuIoWidthUint64)) {
     return EFI_INVALID_PARAMETER;
   }
@@ -161,6 +161,7 @@ CpuIoCheckParameter (
     if (MaxCount < (Count - 1)) {
       return EFI_UNSUPPORTED;
     }
+
     if (Address > LShiftU64 (MaxCount - Count + 1, Width)) {
       return EFI_UNSUPPORTED;
     }
@@ -240,9 +241,9 @@ CpuMemoryServiceRead (
   //
   // Select loop based on the width of the transfer
   //
-  InStride = mInStride[Width];
+  InStride       = mInStride[Width];
-  OutStride = mOutStride[Width];
+  OutStride      = mOutStride[Width];
-  OperationWidth = (EFI_CPU_IO_PROTOCOL_WIDTH) (Width & 0x03);
+  OperationWidth = (EFI_CPU_IO_PROTOCOL_WIDTH)(Width & 0x03);
   for (Uint8Buffer = Buffer; Count > 0; Address += InStride, Uint8Buffer += OutStride, Count--) {
     if (OperationWidth == EfiCpuIoWidthUint8) {
       *Uint8Buffer = MmioRead8 ((UINTN)Address);
@@ -254,6 +255,7 @@ CpuMemoryServiceRead (
       *((UINT64 *)Uint8Buffer) = MmioRead64 ((UINTN)Address);
     }
   }
+
   return EFI_SUCCESS;
 }
 
@@ -321,9 +323,9 @@ CpuMemoryServiceWrite (
   //
   // Select loop based on the width of the transfer
   //
-  InStride = mInStride[Width];
+  InStride       = mInStride[Width];
-  OutStride = mOutStride[Width];
+  OutStride      = mOutStride[Width];
-  OperationWidth = (EFI_CPU_IO_PROTOCOL_WIDTH) (Width & 0x03);
+  OperationWidth = (EFI_CPU_IO_PROTOCOL_WIDTH)(Width & 0x03);
   for (Uint8Buffer = Buffer; Count > 0; Address += InStride, Uint8Buffer += OutStride, Count--) {
     if (OperationWidth == EfiCpuIoWidthUint8) {
       MmioWrite8 ((UINTN)Address, *Uint8Buffer);
@@ -335,6 +337,7 @@ CpuMemoryServiceWrite (
       MmioWrite64 ((UINTN)Address, *((UINT64 *)Uint8Buffer));
     }
   }
+
   return EFI_SUCCESS;
 }
 
@@ -404,9 +407,9 @@ CpuIoServiceRead (
   //
   // Select loop based on the width of the transfer
   //
-  InStride = mInStride[Width];
+  InStride       = mInStride[Width];
-  OutStride = mOutStride[Width];
+  OutStride      = mOutStride[Width];
-  OperationWidth = (EFI_CPU_IO_PROTOCOL_WIDTH) (Width & 0x03);
+  OperationWidth = (EFI_CPU_IO_PROTOCOL_WIDTH)(Width & 0x03);
 
   for (Uint8Buffer = Buffer; Count > 0; Address += InStride, Uint8Buffer += OutStride, Count--) {
     if (OperationWidth == EfiCpuIoWidthUint8) {
@@ -490,9 +493,9 @@ CpuIoServiceWrite (
   //
   // Select loop based on the width of the transfer
   //
-  InStride = mInStride[Width];
+  InStride       = mInStride[Width];
-  OutStride = mOutStride[Width];
+  OutStride      = mOutStride[Width];
-  OperationWidth = (EFI_CPU_IO_PROTOCOL_WIDTH) (Width & 0x03);
+  OperationWidth = (EFI_CPU_IO_PROTOCOL_WIDTH)(Width & 0x03);
 
   for (Uint8Buffer = (UINT8 *)Buffer; Count > 0; Address += InStride, Uint8Buffer += OutStride, Count--) {
     if (OperationWidth == EfiCpuIoWidthUint8) {
@@ -510,7 +513,7 @@ CpuIoServiceWrite (
 //
 // CPU I/O 2 Protocol instance
 //
-STATIC EFI_CPU_IO2_PROTOCOL mCpuIo2 = {
+STATIC EFI_CPU_IO2_PROTOCOL  mCpuIo2 = {
   {
     CpuMemoryServiceRead,
     CpuMemoryServiceWrite
@@ -521,7 +524,6 @@ STATIC EFI_CPU_IO2_PROTOCOL mCpuIo2 = {
   }
 };
 
-
 /**
   The user Entry Point for module CpuIo2Dxe. The user code starts with this function.
 
@@ -539,12 +541,13 @@ ArmPciCpuIo2Initialize (
   IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
-  EFI_STATUS Status;
+  EFI_STATUS  Status;
 
   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiCpuIo2ProtocolGuid);
   Status = gBS->InstallMultipleProtocolInterfaces (
                   &mHandle,
-                  &gEfiCpuIo2ProtocolGuid, &mCpuIo2,
+                  &gEfiCpuIo2ProtocolGuid,
+                  &mCpuIo2,
                   NULL
                   );
   ASSERT_EFI_ERROR (Status);

ArmPkg/Drivers/ArmPciCpuIo2Dxe/ArmPciCpuIo2Dxe.inf

@@ -38,7 +38,7 @@
   UefiBootServicesTableLib
 
 [Pcd]
-  gArmTokenSpaceGuid.PcdPciIoTranslation
+  gEfiMdePkgTokenSpaceGuid.PcdPciIoTranslation
 
 [Protocols]
   gEfiCpuIo2ProtocolGuid                         ## PRODUCES

ArmPkg/Drivers/ArmScmiDxe/ArmScmiBaseProtocolPrivate.h

@@ -14,7 +14,7 @@
 
 // Return values of BASE_DISCOVER_LIST_PROTOCOLS command.
 typedef struct {
-  UINT32 NumProtocols;
+  UINT32    NumProtocols;
 
   // Array of four protocols in each element
   // Total elements = 1 + (NumProtocols-1)/4
@@ -22,7 +22,7 @@ typedef struct {
   // NOTE: Since EDK2 does not allow flexible array member [] we declare
   // here array of 1 element length. However below is used as a variable
   // length array.
-  UINT8 Protocols[1];
+  UINT8     Protocols[1];
 } BASE_DISCOVER_LIST;
 
 /** Initialize Base protocol and install protocol on a given handle.
@@ -34,7 +34,7 @@ typedef struct {
 **/
 EFI_STATUS
 ScmiBaseProtocolInit (
-  IN OUT EFI_HANDLE* Handle
+  IN OUT EFI_HANDLE  *Handle
   );
 
 #endif /* ARM_SCMI_BASE_PROTOCOL_PRIVATE_H_ */

ArmPkg/Drivers/ArmScmiDxe/ArmScmiClockProtocolPrivate.h

@@ -16,57 +16,56 @@
 
 // Clock rate in two 32bit words.
 typedef struct {
-  UINT32 Low;
+  UINT32    Low;
-  UINT32 High;
+  UINT32    High;
 } CLOCK_RATE_DWORD;
 
 // Format of the returned rate array. Linear or Non-linear,.RatesFlag Bit[12]
-#define RATE_FORMAT_SHIFT           12
+#define RATE_FORMAT_SHIFT  12
-#define RATE_FORMAT_MASK            0x0001
+#define RATE_FORMAT_MASK   0x0001
-#define RATE_FORMAT(RatesFlags)     ((RatesFlags >> RATE_FORMAT_SHIFT)  \
+#define RATE_FORMAT(RatesFlags)  ((RatesFlags >> RATE_FORMAT_SHIFT)     \
                                      & RATE_FORMAT_MASK)
 
 // Number of remaining rates after a call to the SCP, RatesFlag Bits[31:16]
-#define NUM_REMAIN_RATES_SHIFT        16
+#define NUM_REMAIN_RATES_SHIFT  16
 #define NUM_REMAIN_RATES(RatesFlags)  ((RatesFlags >> NUM_REMAIN_RATES_SHIFT))
 
 // Number of rates that are returned by a call.to the SCP, RatesFlag Bits[11:0]
-#define NUM_RATES_MASK              0x0FFF
+#define NUM_RATES_MASK  0x0FFF
-#define NUM_RATES(RatesFlags)       (RatesFlags & NUM_RATES_MASK)
+#define NUM_RATES(RatesFlags)  (RatesFlags & NUM_RATES_MASK)
 
 // Return values for the CLOCK_DESCRIBER_RATE command.
 typedef struct {
-  UINT32 NumRatesFlags;
+  UINT32              NumRatesFlags;
 
   // NOTE: Since EDK2 does not allow flexible array member [] we declare
   // here array of 1 element length. However below is used as a variable
   // length array.
-  CLOCK_RATE_DWORD Rates[1];
+  CLOCK_RATE_DWORD    Rates[1];
 } CLOCK_DESCRIBE_RATES;
 
-#define CLOCK_SET_DEFAULT_FLAGS   0
+#define CLOCK_SET_DEFAULT_FLAGS  0
 
 // Message parameters for CLOCK_RATE_SET command.
 typedef struct {
-  UINT32 Flags;
+  UINT32              Flags;
-  UINT32 ClockId;
+  UINT32              ClockId;
-  CLOCK_RATE_DWORD Rate;
+  CLOCK_RATE_DWORD    Rate;
 } CLOCK_RATE_SET_ATTRIBUTES;
 
-
 // Message parameters for CLOCK_CONFIG_SET command.
 typedef struct {
-  UINT32 ClockId;
+  UINT32    ClockId;
-  UINT32 Attributes;
+  UINT32    Attributes;
 } CLOCK_CONFIG_SET_ATTRIBUTES;
 
 //  if ClockAttr Bit[0] is set then clock device is enabled.
-#define CLOCK_ENABLE_MASK         0x1
+#define CLOCK_ENABLE_MASK  0x1
 #define CLOCK_ENABLED(ClockAttr)  ((ClockAttr & CLOCK_ENABLE_MASK) == 1)
 
 typedef struct {
-  UINT32 Attributes;
+  UINT32    Attributes;
-  UINT8  ClockName[SCMI_MAX_STR_LEN];
+  UINT8     ClockName[SCMI_MAX_STR_LEN];
 } CLOCK_ATTRIBUTES;
 
 #pragma pack()
@@ -79,7 +78,7 @@ typedef struct {
 **/
 EFI_STATUS
 ScmiClockProtocolInit (
-  IN EFI_HANDLE *Handle
+  IN EFI_HANDLE  *Handle
   );
 
 #endif /* ARM_SCMI_CLOCK_PROTOCOL_PRIVATE_H_ */

ArmPkg/Drivers/ArmScmiDxe/ArmScmiDxe.inf

@@ -1,6 +1,6 @@
 #/** @file
 #
-#  Copyright (c) 2017-2018, Arm Limited. All rights reserved.
+#  Copyright (c) 2017-2021, Arm Limited. All rights reserved.<BR>
 #
 #  SPDX-License-Identifier: BSD-2-Clause-Patent
 #
@@ -18,11 +18,16 @@
   ENTRY_POINT                    = ArmScmiDxeEntryPoint
 
 [Sources.common]
-  Scmi.c
+  ArmScmiBaseProtocolPrivate.h
+  ArmScmiClockProtocolPrivate.h
+  ArmScmiPerformanceProtocolPrivate.h
   ScmiBaseProtocol.c
+  Scmi.c
   ScmiClockProtocol.c
   ScmiDxe.c
+  ScmiDxe.h
   ScmiPerformanceProtocol.c
+  ScmiPrivate.h
 
 [Packages]
   ArmPkg/ArmPkg.dec

ArmPkg/Drivers/ArmScmiDxe/ArmScmiPerformanceProtocolPrivate.h

@@ -1,6 +1,6 @@
 /** @file
 
-  Copyright (c) 2017-2018, Arm Limited. All rights reserved.
+  Copyright (c) 2017-2021, Arm Limited. All rights reserved.
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
@@ -15,23 +15,23 @@
 #include <Protocol/ArmScmiPerformanceProtocol.h>
 
 // Number of performance levels returned by a call to the SCP, Lvls Bits[11:0]
-#define NUM_PERF_LEVELS_MASK          0x0FFF
+#define NUM_PERF_LEVELS_MASK  0x0FFF
-#define NUM_PERF_LEVELS(Lvls) (Lvls & NUM_PERF_LEVELS_MASK)
+#define NUM_PERF_LEVELS(Lvls)  (Lvls & NUM_PERF_LEVELS_MASK)
 
 // Number of performance levels remaining after a call to the SCP, Lvls Bits[31:16]
 #define NUM_REMAIN_PERF_LEVELS_SHIFT  16
-#define NUM_REMAIN_PERF_LEVELS(Lvls) (Lvls >> NUM_REMAIN_PERF_LEVELS_SHIFT)
+#define NUM_REMAIN_PERF_LEVELS(Lvls)  (Lvls >> NUM_REMAIN_PERF_LEVELS_SHIFT)
 
-/** Return values for SCMI_MESSAGE_ID_PERFORMANCE_DESCRIBE_LEVELS command.
+/** Return values for ScmiMessageIdPerformanceDescribeLevels command.
-  SCMI Spec <EFBFBD> 4.5.2.5
+  SCMI Spec section 4.5.2.5
 **/
 typedef struct {
-  UINT32 NumLevels;
+  UINT32                    NumLevels;
 
   // NOTE: Since EDK2 does not allow flexible array member [] we declare
   // here array of 1 element length. However below is used as a variable
   // length array.
-  SCMI_PERFORMANCE_LEVEL PerfLevel[1]; // Offset to array of performance levels
+  SCMI_PERFORMANCE_LEVEL    PerfLevel[1]; // Offset to array of performance levels
 } PERF_DESCRIBE_LEVELS;
 
 /** Initialize performance management protocol and install on a given Handle.
@@ -43,7 +43,7 @@ typedef struct {
 **/
 EFI_STATUS
 ScmiPerformanceProtocolInit (
-  IN EFI_HANDLE* Handle
+  IN EFI_HANDLE  *Handle
   );
 
 #endif /* ARM_SCMI_PERFORMANCE_PROTOCOL_PRIVATE_H_ */

ArmPkg/Drivers/ArmScmiDxe/Scmi.c

@@ -1,6 +1,6 @@
 /** @file
 
-  Copyright (c) 2017-2018, Arm Limited. All rights reserved.
+  Copyright (c) 2017-2021, Arm Limited. All rights reserved.
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
@@ -29,7 +29,7 @@
 **/
 EFI_STATUS
 ScmiCommandGetPayload (
-  OUT UINT32** Payload
+  OUT UINT32  **Payload
   )
 {
   EFI_STATUS   Status;
@@ -76,7 +76,7 @@ EFI_STATUS
 ScmiCommandExecute (
   IN     SCMI_COMMAND  *Command,
   IN OUT UINT32        *PayloadLength,
-  OUT    UINT32       **ReturnValues OPTIONAL
+  OUT    UINT32        **ReturnValues OPTIONAL
   )
 {
   EFI_STATUS             Status;
@@ -95,7 +95,7 @@ ScmiCommandExecute (
   // Fill in message header.
   MessageHeader = SCMI_MESSAGE_HEADER (
                     Command->MessageId,
-                    SCMI_MESSAGE_TYPE_COMMAND,
+                    ScmiMessageTypeCommand,
                     Command->ProtocolId
                     );
 
@@ -121,10 +121,12 @@ ScmiCommandExecute (
     return EFI_DEVICE_ERROR;
   }
 
-  Response = (SCMI_MESSAGE_RESPONSE*)MtlGetChannelPayload (Channel);
+  Response = (SCMI_MESSAGE_RESPONSE *)MtlGetChannelPayload (Channel);
 
-  if (Response->Status != SCMI_SUCCESS) {
+  if (Response->Status != ScmiSuccess) {
-    DEBUG ((DEBUG_ERROR, "SCMI error: ProtocolId = 0x%x, MessageId = 0x%x, error = %d\n",
+    DEBUG ((
+      DEBUG_ERROR,
+      "SCMI error: ProtocolId = 0x%x, MessageId = 0x%x, error = %d\n",
       Command->ProtocolId,
       Command->MessageId,
       Response->Status
@@ -161,8 +163,9 @@ ScmiProtocolDiscoveryCommon (
   )
 {
   SCMI_COMMAND  Command;
-  UINT32        PayloadLength = 0;
+  UINT32        PayloadLength;
 
+  PayloadLength      = 0;
   Command.ProtocolId = ProtocolId;
   Command.MessageId  = MessageId;
 
@@ -189,13 +192,13 @@ ScmiGetProtocolVersion (
   OUT UINT32            *Version
   )
 {
-  EFI_STATUS             Status;
+  EFI_STATUS  Status;
-  UINT32                 *ProtocolVersion;
+  UINT32      *ProtocolVersion;
 
   Status = ScmiProtocolDiscoveryCommon (
              ProtocolId,
-             SCMI_MESSAGE_ID_PROTOCOL_VERSION,
+             ScmiMessageIdProtocolVersion,
-             (UINT32**)&ProtocolVersion
+             (UINT32 **)&ProtocolVersion
              );
   if (EFI_ERROR (Status)) {
     return Status;
@@ -223,7 +226,7 @@ ScmiGetProtocolAttributes (
 {
   return ScmiProtocolDiscoveryCommon (
            ProtocolId,
-           SCMI_MESSAGE_ID_PROTOCOL_ATTRIBUTES,
+           ScmiMessageIdProtocolAttributes,
            ReturnValues
            );
 }
@@ -245,7 +248,7 @@ ScmiGetProtocolMessageAttributes (
 {
   return ScmiProtocolDiscoveryCommon (
            ProtocolId,
-           SCMI_MESSAGE_ID_PROTOCOL_MESSAGE_ATTRIBUTES,
+           ScmiMessageIdProtocolMessageAttributes,
            ReturnValues
            );
 }

ArmPkg/Drivers/ArmScmiDxe/ScmiBaseProtocol.c

@@ -1,6 +1,6 @@
 /** @file
 
-  Copyright (c) 2017-2018, Arm Limited. All rights reserved.
+  Copyright (c) 2017-2021, Arm Limited. All rights reserved.<BR>
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
@@ -34,7 +34,7 @@ BaseGetVersion (
   OUT UINT32              *Version
   )
 {
-  return ScmiGetProtocolVersion (SCMI_PROTOCOL_ID_BASE, Version);
+  return ScmiGetProtocolVersion (ScmiProtocolIdBase, Version);
 }
 
 /** Return total number of SCMI protocols supported by the SCP firmware.
@@ -57,7 +57,7 @@ BaseGetTotalProtocols (
   EFI_STATUS  Status;
   UINT32      *ReturnValues;
 
-  Status = ScmiGetProtocolAttributes (SCMI_PROTOCOL_ID_BASE, &ReturnValues);
+  Status = ScmiGetProtocolAttributes (ScmiProtocolIdBase, &ReturnValues);
   if (EFI_ERROR (Status)) {
     return Status;
   }
@@ -69,9 +69,9 @@ BaseGetTotalProtocols (
 
 /** Common function which returns vendor details.
 
-  @param[in] MessageId       SCMI_MESSAGE_ID_BASE_DISCOVER_VENDOR
+  @param[in] MessageId       ScmiMessageIdBaseDiscoverVendor
                              OR
-                             SCMI_MESSAGE_ID_BASE_DISCOVER_SUB_VENDOR
+                             ScmiMessageIdBaseDiscoverSubVendor
 
   @param[out] VendorIdentifier ASCII name of the vendor/subvendor.
 
@@ -91,7 +91,7 @@ BaseDiscoverVendorDetails (
   SCMI_COMMAND  Cmd;
   UINT32        PayloadLength;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_BASE;
+  Cmd.ProtocolId = ScmiProtocolIdBase;
   Cmd.MessageId  = MessageId;
 
   PayloadLength = 0;
@@ -106,9 +106,9 @@ BaseDiscoverVendorDetails (
   }
 
   AsciiStrCpyS (
-    (CHAR8*)VendorIdentifier,
+    (CHAR8 *)VendorIdentifier,
     SCMI_MAX_STR_LEN,
-    (CONST CHAR8*)ReturnValues
+    (CONST CHAR8 *)ReturnValues
     );
 
   return EFI_SUCCESS;
@@ -133,7 +133,7 @@ BaseDiscoverVendor (
   )
 {
   return BaseDiscoverVendorDetails (
-           SCMI_MESSAGE_ID_BASE_DISCOVER_VENDOR,
+           ScmiMessageIdBaseDiscoverVendor,
            VendorIdentifier
            );
 }
@@ -156,7 +156,7 @@ BaseDiscoverSubVendor (
   )
 {
   return BaseDiscoverVendorDetails (
-           SCMI_MESSAGE_ID_BASE_DISCOVER_SUB_VENDOR,
+           ScmiMessageIdBaseDiscoverSubVendor,
            VendorIdentifier
            );
 }
@@ -183,8 +183,8 @@ BaseDiscoverImplVersion (
   SCMI_COMMAND  Cmd;
   UINT32        PayloadLength;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_BASE;
+  Cmd.ProtocolId = ScmiProtocolIdBase;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_BASE_DISCOVER_IMPLEMENTATION_VERSION;
+  Cmd.MessageId  = ScmiMessageIdBaseDiscoverImplementationVersion;
 
   PayloadLength = 0;
 
@@ -250,13 +250,12 @@ BaseDiscoverListProtocols (
     return EFI_BUFFER_TOO_SMALL;
   }
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_BASE;
+  Cmd.ProtocolId = ScmiProtocolIdBase;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_BASE_DISCOVER_LIST_PROTOCOLS;
+  Cmd.MessageId  = ScmiMessageIdBaseDiscoverListProtocols;
 
   Skip = 0;
 
   while (Skip < TotalProtocols) {
-
     *MessageParams = Skip;
 
     // Note PayloadLength is a IN/OUT parameter.
@@ -265,7 +264,7 @@ BaseDiscoverListProtocols (
     Status = ScmiCommandExecute (
                &Cmd,
                &PayloadLength,
-               (UINT32**)&DiscoverList
+               (UINT32 **)&DiscoverList
                );
     if (EFI_ERROR (Status)) {
       return Status;
@@ -282,7 +281,7 @@ BaseDiscoverListProtocols (
 }
 
 // Instance of the SCMI Base protocol.
-STATIC CONST SCMI_BASE_PROTOCOL BaseProtocol = {
+STATIC CONST SCMI_BASE_PROTOCOL  BaseProtocol = {
   BaseGetVersion,
   BaseGetTotalProtocols,
   BaseDiscoverVendor,
@@ -300,7 +299,7 @@ STATIC CONST SCMI_BASE_PROTOCOL BaseProtocol = {
 **/
 EFI_STATUS
 ScmiBaseProtocolInit (
-  IN OUT EFI_HANDLE* Handle
+  IN OUT EFI_HANDLE  *Handle
   )
 {
   return gBS->InstallMultipleProtocolInterfaces (

ArmPkg/Drivers/ArmScmiDxe/ScmiClockProtocol.c

@@ -1,6 +1,6 @@
 /** @file
 
-  Copyright (c) 2017-2018, Arm Limited. All rights reserved.
+  Copyright (c) 2017-2021, Arm Limited. All rights reserved.
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
@@ -28,11 +28,11 @@
 STATIC
 UINT64
 ConvertTo64Bit (
-  IN UINT32 Low,
+  IN UINT32  Low,
-  IN UINT32 High
+  IN UINT32  High
   )
 {
-   return (Low | ((UINT64)High << 32));
+  return (Low | ((UINT64)High << 32));
 }
 
 /** Return version of the clock management protocol supported by SCP firmware.
@@ -52,7 +52,7 @@ ClockGetVersion (
   OUT UINT32               *Version
   )
 {
-  return ScmiGetProtocolVersion (SCMI_PROTOCOL_ID_CLOCK, Version);
+  return ScmiGetProtocolVersion (ScmiProtocolIdClock, Version);
 }
 
 /** Return total number of clock devices supported by the clock management
@@ -74,9 +74,9 @@ ClockGetTotalClocks (
   )
 {
   EFI_STATUS  Status;
-  UINT32     *ReturnValues;
+  UINT32      *ReturnValues;
 
-  Status = ScmiGetProtocolAttributes (SCMI_PROTOCOL_ID_CLOCK, &ReturnValues);
+  Status = ScmiGetProtocolAttributes (ScmiProtocolIdClock, &ReturnValues);
   if (EFI_ERROR (Status)) {
     return Status;
   }
@@ -108,12 +108,12 @@ ClockGetClockAttributes (
   OUT CHAR8                *ClockAsciiName
   )
 {
-  EFI_STATUS          Status;
+  EFI_STATUS  Status;
 
-  UINT32              *MessageParams;
+  UINT32            *MessageParams;
-  CLOCK_ATTRIBUTES    *ClockAttributes;
+  CLOCK_ATTRIBUTES  *ClockAttributes;
-  SCMI_COMMAND        Cmd;
+  SCMI_COMMAND      Cmd;
-  UINT32              PayloadLength;
+  UINT32            PayloadLength;
 
   Status = ScmiCommandGetPayload (&MessageParams);
   if (EFI_ERROR (Status)) {
@@ -122,26 +122,27 @@ ClockGetClockAttributes (
 
   *MessageParams = ClockId;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_CLOCK;
+  Cmd.ProtocolId = ScmiProtocolIdClock;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_CLOCK_ATTRIBUTES;
+  Cmd.MessageId  = ScmiMessageIdClockAttributes;
 
   PayloadLength = sizeof (ClockId);
 
   Status = ScmiCommandExecute (
              &Cmd,
              &PayloadLength,
-             (UINT32**)&ClockAttributes
+             (UINT32 **)&ClockAttributes
              );
   if (EFI_ERROR (Status)) {
     return Status;
   }
-   // TRUE if bit 0 of ClockAttributes->Attributes is set.
+
+  // TRUE if bit 0 of ClockAttributes->Attributes is set.
   *Enabled = CLOCK_ENABLED (ClockAttributes->Attributes);
 
   AsciiStrCpyS (
     ClockAsciiName,
     SCMI_MAX_STR_LEN,
-    (CONST CHAR8*)ClockAttributes->ClockName
+    (CONST CHAR8 *)ClockAttributes->ClockName
     );
 
   return EFI_SUCCESS;
@@ -152,10 +153,10 @@ ClockGetClockAttributes (
   @param[in] This        A pointer to SCMI_CLOCK_PROTOCOL Instance.
   @param[in] ClockId     Identifier for the clock device.
 
-  @param[out] Format      SCMI_CLOCK_RATE_FORMAT_DISCRETE: Clock device
+  @param[out] Format      ScmiClockRateFormatDiscrete: Clock device
                           supports range of clock rates which are non-linear.
 
-                          SCMI_CLOCK_RATE_FORMAT_LINEAR: Clock device supports
+                          ScmiClockRateFormatLinear: Clock device supports
                           range of linear clock rates from Min to Max in steps.
 
   @param[out] TotalRates  Total number of rates.
@@ -174,50 +175,51 @@ STATIC
 EFI_STATUS
 ClockDescribeRates (
   IN     SCMI_CLOCK_PROTOCOL     *This,
-  IN     UINT32                   ClockId,
+  IN     UINT32                  ClockId,
   OUT    SCMI_CLOCK_RATE_FORMAT  *Format,
   OUT    UINT32                  *TotalRates,
   IN OUT UINT32                  *RateArraySize,
   OUT    SCMI_CLOCK_RATE         *RateArray
   )
 {
-  EFI_STATUS             Status;
+  EFI_STATUS  Status;
 
-  UINT32                 PayloadLength;
+  UINT32                PayloadLength;
-  SCMI_COMMAND           Cmd;
+  SCMI_COMMAND          Cmd;
-  UINT32                 *MessageParams;
+  UINT32                *MessageParams;
-  CLOCK_DESCRIBE_RATES   *DescribeRates;
+  CLOCK_DESCRIBE_RATES  *DescribeRates;
-  CLOCK_RATE_DWORD       *Rate;
+  CLOCK_RATE_DWORD      *Rate;
 
-  UINT32                 RequiredArraySize = 0;
+  UINT32  RequiredArraySize;
-  UINT32                 RateIndex = 0;
+  UINT32  RateIndex;
-  UINT32                 RateNo;
+  UINT32  RateNo;
-  UINT32                 RateOffset;
+  UINT32  RateOffset;
 
-  *TotalRates = 0;
+  *TotalRates       = 0;
+  RequiredArraySize = 0;
+  RateIndex         = 0;
 
   Status = ScmiCommandGetPayload (&MessageParams);
   if (EFI_ERROR (Status)) {
     return Status;
   }
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_CLOCK;
+  Cmd.ProtocolId = ScmiProtocolIdClock;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_CLOCK_DESCRIBE_RATES;
+  Cmd.MessageId  = ScmiMessageIdClockDescribeRates;
 
-  *MessageParams++  = ClockId;
+  *MessageParams++ = ClockId;
 
   do {
-
     *MessageParams = RateIndex;
 
     // Set Payload length, note PayloadLength is a IN/OUT parameter.
-    PayloadLength  = sizeof (ClockId) + sizeof (RateIndex);
+    PayloadLength = sizeof (ClockId) + sizeof (RateIndex);
 
     // Execute and wait for response on a SCMI channel.
     Status = ScmiCommandExecute (
                &Cmd,
                &PayloadLength,
-               (UINT32**)&DescribeRates
+               (UINT32 **)&DescribeRates
                );
     if (EFI_ERROR (Status)) {
       return Status;
@@ -234,11 +236,11 @@ ClockDescribeRates (
       *TotalRates = NUM_RATES (DescribeRates->NumRatesFlags)
                     + NUM_REMAIN_RATES (DescribeRates->NumRatesFlags);
 
-      if (*Format == SCMI_CLOCK_RATE_FORMAT_DISCRETE) {
+      if (*Format == ScmiClockRateFormatDiscrete) {
-         RequiredArraySize = (*TotalRates) * sizeof (UINT64);
+        RequiredArraySize = (*TotalRates) * sizeof (UINT64);
       } else {
-         // We need to return triplet of 64 bit value for each rate
+        // We need to return triplet of 64 bit value for each rate
-         RequiredArraySize = (*TotalRates) * 3 * sizeof (UINT64);
+        RequiredArraySize = (*TotalRates) * 3 * sizeof (UINT64);
       }
 
       if (RequiredArraySize > (*RateArraySize)) {
@@ -249,26 +251,30 @@ ClockDescribeRates (
 
     RateOffset = 0;
 
-    if (*Format == SCMI_CLOCK_RATE_FORMAT_DISCRETE) {
+    if (*Format == ScmiClockRateFormatDiscrete) {
       for (RateNo = 0; RateNo < NUM_RATES (DescribeRates->NumRatesFlags); RateNo++) {
         Rate = &DescribeRates->Rates[RateOffset++];
         // Non-linear discrete rates.
-        RateArray[RateIndex++].Rate = ConvertTo64Bit (Rate->Low, Rate->High);
+        RateArray[RateIndex++].DiscreteRate.Rate =
+          ConvertTo64Bit (Rate->Low, Rate->High);
       }
     } else {
       for (RateNo = 0; RateNo < NUM_RATES (DescribeRates->NumRatesFlags); RateNo++) {
         // Linear clock rates from minimum to maximum in steps
         // Minimum clock rate.
-        Rate = &DescribeRates->Rates[RateOffset++];
+        Rate                                    = &DescribeRates->Rates[RateOffset++];
-        RateArray[RateIndex].Min = ConvertTo64Bit (Rate->Low, Rate->High);
+        RateArray[RateIndex].ContinuousRate.Min =
+          ConvertTo64Bit (Rate->Low, Rate->High);
 
         Rate = &DescribeRates->Rates[RateOffset++];
         // Maximum clock rate.
-        RateArray[RateIndex].Max = ConvertTo64Bit (Rate->Low, Rate->High);
+        RateArray[RateIndex].ContinuousRate.Max =
+          ConvertTo64Bit (Rate->Low, Rate->High);
 
         Rate = &DescribeRates->Rates[RateOffset++];
         // Step.
-        RateArray[RateIndex++].Step = ConvertTo64Bit (Rate->Low, Rate->High);
+        RateArray[RateIndex++].ContinuousRate.Step =
+          ConvertTo64Bit (Rate->Low, Rate->High);
       }
     }
   } while (NUM_REMAIN_RATES (DescribeRates->NumRatesFlags) != 0);
@@ -298,13 +304,13 @@ ClockRateGet (
   OUT UINT64               *Rate
   )
 {
-  EFI_STATUS     Status;
+  EFI_STATUS  Status;
 
   UINT32            *MessageParams;
   CLOCK_RATE_DWORD  *ClockRate;
   SCMI_COMMAND      Cmd;
 
-  UINT32         PayloadLength;
+  UINT32  PayloadLength;
 
   Status = ScmiCommandGetPayload (&MessageParams);
   if (EFI_ERROR (Status)) {
@@ -312,10 +318,10 @@ ClockRateGet (
   }
 
   // Fill arguments for clock protocol command.
-  *MessageParams  = ClockId;
+  *MessageParams = ClockId;
 
-  Cmd.ProtocolId  = SCMI_PROTOCOL_ID_CLOCK;
+  Cmd.ProtocolId = ScmiProtocolIdClock;
-  Cmd.MessageId   = SCMI_MESSAGE_ID_CLOCK_RATE_GET;
+  Cmd.MessageId  = ScmiMessageIdClockRateGet;
 
   PayloadLength = sizeof (ClockId);
 
@@ -323,7 +329,7 @@ ClockRateGet (
   Status = ScmiCommandExecute (
              &Cmd,
              &PayloadLength,
-             (UINT32**)&ClockRate
+             (UINT32 **)&ClockRate
              );
   if (EFI_ERROR (Status)) {
     return Status;
@@ -352,24 +358,24 @@ ClockRateSet (
   IN UINT64               Rate
   )
 {
-  EFI_STATUS                  Status;
+  EFI_STATUS                 Status;
-  CLOCK_RATE_SET_ATTRIBUTES   *ClockRateSetAttributes;
+  CLOCK_RATE_SET_ATTRIBUTES  *ClockRateSetAttributes;
-  SCMI_COMMAND                Cmd;
+  SCMI_COMMAND               Cmd;
-  UINT32                      PayloadLength;
+  UINT32                     PayloadLength;
 
-  Status = ScmiCommandGetPayload ((UINT32**)&ClockRateSetAttributes);
+  Status = ScmiCommandGetPayload ((UINT32 **)&ClockRateSetAttributes);
   if (EFI_ERROR (Status)) {
     return Status;
   }
 
   // Fill arguments for clock protocol command.
-  ClockRateSetAttributes->ClockId    = ClockId;
+  ClockRateSetAttributes->ClockId   = ClockId;
-  ClockRateSetAttributes->Flags      = CLOCK_SET_DEFAULT_FLAGS;
+  ClockRateSetAttributes->Flags     = CLOCK_SET_DEFAULT_FLAGS;
-  ClockRateSetAttributes->Rate.Low   = (UINT32)Rate;
+  ClockRateSetAttributes->Rate.Low  = (UINT32)Rate;
-  ClockRateSetAttributes->Rate.High  = (UINT32)(Rate >> 32);
+  ClockRateSetAttributes->Rate.High = (UINT32)(Rate >> 32);
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_CLOCK;
+  Cmd.ProtocolId = ScmiProtocolIdClock;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_CLOCK_RATE_SET;
+  Cmd.MessageId  = ScmiMessageIdClockRateSet;
 
   PayloadLength = sizeof (CLOCK_RATE_SET_ATTRIBUTES);
 
@@ -396,17 +402,17 @@ ClockRateSet (
 STATIC
 EFI_STATUS
 ClockEnable (
-  IN SCMI_CLOCK2_PROTOCOL *This,
+  IN SCMI_CLOCK2_PROTOCOL  *This,
-  IN UINT32               ClockId,
+  IN UINT32                ClockId,
-  IN BOOLEAN              Enable
+  IN BOOLEAN               Enable
   )
 {
-  EFI_STATUS                  Status;
+  EFI_STATUS                   Status;
-  CLOCK_CONFIG_SET_ATTRIBUTES *ClockConfigSetAttributes;
+  CLOCK_CONFIG_SET_ATTRIBUTES  *ClockConfigSetAttributes;
-  SCMI_COMMAND                Cmd;
+  SCMI_COMMAND                 Cmd;
-  UINT32                      PayloadLength;
+  UINT32                       PayloadLength;
 
-  Status = ScmiCommandGetPayload ((UINT32**)&ClockConfigSetAttributes);
+  Status = ScmiCommandGetPayload ((UINT32 **)&ClockConfigSetAttributes);
   if (EFI_ERROR (Status)) {
     return Status;
   }
@@ -415,8 +421,8 @@ ClockEnable (
   ClockConfigSetAttributes->ClockId    = ClockId;
   ClockConfigSetAttributes->Attributes = Enable ? BIT0 : 0;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_CLOCK;
+  Cmd.ProtocolId = ScmiProtocolIdClock;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_CLOCK_CONFIG_SET;
+  Cmd.MessageId  = ScmiMessageIdClockConfigSet;
 
   PayloadLength = sizeof (CLOCK_CONFIG_SET_ATTRIBUTES);
 
@@ -431,17 +437,17 @@ ClockEnable (
 }
 
 // Instance of the SCMI clock management protocol.
-STATIC CONST SCMI_CLOCK_PROTOCOL ScmiClockProtocol = {
+STATIC CONST SCMI_CLOCK_PROTOCOL  ScmiClockProtocol = {
   ClockGetVersion,
   ClockGetTotalClocks,
   ClockGetClockAttributes,
   ClockDescribeRates,
   ClockRateGet,
   ClockRateSet
- };
+};
 
 // Instance of the SCMI clock management protocol.
-STATIC CONST SCMI_CLOCK2_PROTOCOL ScmiClock2Protocol = {
+STATIC CONST SCMI_CLOCK2_PROTOCOL  ScmiClock2Protocol = {
   (SCMI_CLOCK2_GET_VERSION)ClockGetVersion,
   (SCMI_CLOCK2_GET_TOTAL_CLOCKS)ClockGetTotalClocks,
   (SCMI_CLOCK2_GET_CLOCK_ATTRIBUTES)ClockGetClockAttributes,
@@ -450,7 +456,7 @@ STATIC CONST SCMI_CLOCK2_PROTOCOL ScmiClock2Protocol = {
   (SCMI_CLOCK2_RATE_SET)ClockRateSet,
   SCMI_CLOCK2_PROTOCOL_VERSION,
   ClockEnable
- };
+};
 
 /** Initialize clock management protocol and install protocol on a given handle.
 
@@ -460,7 +466,7 @@ STATIC CONST SCMI_CLOCK2_PROTOCOL ScmiClock2Protocol = {
 **/
 EFI_STATUS
 ScmiClockProtocolInit (
-  IN EFI_HANDLE* Handle
+  IN EFI_HANDLE  *Handle
   )
 {
   return gBS->InstallMultipleProtocolInterfaces (

ArmPkg/Drivers/ArmScmiDxe/ScmiDxe.c

@@ -1,12 +1,12 @@
 /** @file
 
-  Copyright (c) 2017-2018, Arm Limited. All rights reserved.
+  Copyright (c) 2017-2021, Arm Limited. All rights reserved.<BR>
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
-  System Control and Management Interface V1.0
+  @par Specification Reference:
-    http://infocenter.arm.com/help/topic/com.arm.doc.den0056a/
+  - Arm System Control and Management Interface - Platform Design Document
-    DEN0056A_System_Control_and_Management_Interface.pdf
+    (https://developer.arm.com/documentation/den0056/)
 **/
 
 #include <Base.h>
@@ -23,10 +23,10 @@
 #include "ScmiDxe.h"
 #include "ScmiPrivate.h"
 
-STATIC CONST SCMI_PROTOCOL_ENTRY Protocols[] = {
+STATIC CONST SCMI_PROTOCOL_ENTRY  Protocols[] = {
-  { SCMI_PROTOCOL_ID_BASE, ScmiBaseProtocolInit },
+  { ScmiProtocolIdBase,        ScmiBaseProtocolInit        },
-  { SCMI_PROTOCOL_ID_PERFORMANCE, ScmiPerformanceProtocolInit },
+  { ScmiProtocolIdPerformance, ScmiPerformanceProtocolInit },
-  { SCMI_PROTOCOL_ID_CLOCK, ScmiClockProtocolInit }
+  { ScmiProtocolIdClock,       ScmiClockProtocolInit       }
 };
 
 /** ARM SCMI driver entry point function.
@@ -47,8 +47,8 @@ STATIC CONST SCMI_PROTOCOL_ENTRY Protocols[] = {
 EFI_STATUS
 EFIAPI
 ArmScmiDxeEntryPoint (
-  IN EFI_HANDLE             ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE       *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
   EFI_STATUS          Status;
@@ -61,7 +61,7 @@ ArmScmiDxeEntryPoint (
   UINT32              SupportedListSize;
 
   // Every SCMI implementation must implement the base protocol.
-  ASSERT (Protocols[0].Id == SCMI_PROTOCOL_ID_BASE);
+  ASSERT (Protocols[0].Id == ScmiProtocolIdBase);
 
   Status = ScmiBaseProtocolInit (&ImageHandle);
   if (EFI_ERROR (Status)) {
@@ -72,7 +72,7 @@ ArmScmiDxeEntryPoint (
   Status = gBS->LocateProtocol (
                   &gArmScmiBaseProtocolGuid,
                   NULL,
-                  (VOID**)&BaseProtocol
+                  (VOID **)&BaseProtocol
                   );
   if (EFI_ERROR (Status)) {
     ASSERT (FALSE);
@@ -86,7 +86,10 @@ ArmScmiDxeEntryPoint (
     return Status;
   }
 
-  if (Version != BASE_PROTOCOL_VERSION) {
+  // Accept any version between SCMI v1.0 and SCMI v2.0
+  if ((Version < BASE_PROTOCOL_VERSION_V1) ||
+      (Version > BASE_PROTOCOL_VERSION_V2))
+  {
     ASSERT (FALSE);
     return EFI_UNSUPPORTED;
   }
@@ -94,7 +97,7 @@ ArmScmiDxeEntryPoint (
   // Apart from Base protocol, SCMI may implement various other protocols,
   // query total protocols implemented by the SCP firmware.
   NumProtocols = 0;
-  Status = BaseProtocol->GetTotalProtocols (BaseProtocol, &NumProtocols);
+  Status       = BaseProtocol->GetTotalProtocols (BaseProtocol, &NumProtocols);
   if (EFI_ERROR (Status)) {
     ASSERT (FALSE);
     return Status;
@@ -107,7 +110,7 @@ ArmScmiDxeEntryPoint (
   Status = gBS->AllocatePool (
                   EfiBootServicesData,
                   SupportedListSize,
-                  (VOID**)&SupportedList
+                  (VOID **)&SupportedList
                   );
   if (EFI_ERROR (Status)) {
     ASSERT (FALSE);
@@ -128,7 +131,8 @@ ArmScmiDxeEntryPoint (
 
   // Install supported protocol on ImageHandle.
   for (ProtocolIndex = 1; ProtocolIndex < ARRAY_SIZE (Protocols);
-       ProtocolIndex++) {
+       ProtocolIndex++)
+  {
     for (Index = 0; Index < NumProtocols; Index++) {
       if (Protocols[ProtocolIndex].Id == SupportedList[Index]) {
         Status = Protocols[ProtocolIndex].InitFn (&ImageHandle);
@@ -136,6 +140,7 @@ ArmScmiDxeEntryPoint (
           ASSERT_EFI_ERROR (Status);
           return Status;
         }
+
         break;
       }
     }

ArmPkg/Drivers/ArmScmiDxe/ScmiDxe.h

@@ -8,12 +8,13 @@
     http://infocenter.arm.com/help/topic/com.arm.doc.den0056a/
     DEN0056A_System_Control_and_Management_Interface.pdf
 **/
+
 #ifndef SCMI_DXE_H_
 #define SCMI_DXE_H_
 
 #include "ScmiPrivate.h"
 
-#define MAX_VENDOR_LEN       SCMI_MAX_STR_LEN
+#define MAX_VENDOR_LEN  SCMI_MAX_STR_LEN
 
 /** Pointer to protocol initialization function.
 
@@ -29,8 +30,8 @@ EFI_STATUS
   );
 
 typedef struct {
-  SCMI_PROTOCOL_ID Id;            // Protocol Id.
+  SCMI_PROTOCOL_ID          Id;     // Protocol Id.
-  SCMI_PROTOCOL_INIT_FXN InitFn;  // Protocol init function.
+  SCMI_PROTOCOL_INIT_FXN    InitFn; // Protocol init function.
 } SCMI_PROTOCOL_ENTRY;
 
 #endif /* SCMI_DXE_H_ */

ArmPkg/Drivers/ArmScmiDxe/ScmiPerformanceProtocol.c

@@ -1,6 +1,6 @@
 /** @file
 
-  Copyright (c) 2017-2018, Arm Limited. All rights reserved.
+  Copyright (c) 2017-2021, Arm Limited. All rights reserved.<BR>
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
@@ -35,7 +35,7 @@ PerformanceGetVersion (
   OUT UINT32                     *Version
   )
 {
-  return ScmiGetProtocolVersion (SCMI_PROTOCOL_ID_PERFORMANCE, Version);
+  return ScmiGetProtocolVersion (ScmiProtocolIdPerformance, Version);
 }
 
 /** Return protocol attributes of the performance management protocol.
@@ -51,15 +51,15 @@ PerformanceGetVersion (
 STATIC
 EFI_STATUS
 PerformanceGetAttributes (
-  IN  SCMI_PERFORMANCE_PROTOCOL              *This,
+  IN  SCMI_PERFORMANCE_PROTOCOL             *This,
-  OUT SCMI_PERFORMANCE_PROTOCOL_ATTRIBUTES   *Attributes
+  OUT SCMI_PERFORMANCE_PROTOCOL_ATTRIBUTES  *Attributes
   )
 {
   EFI_STATUS  Status;
-  UINT32* ReturnValues;
+  UINT32      *ReturnValues;
 
   Status = ScmiGetProtocolAttributes (
-             SCMI_PROTOCOL_ID_PERFORMANCE,
+             ScmiProtocolIdPerformance,
              &ReturnValues
              );
   if (EFI_ERROR (Status)) {
@@ -90,7 +90,7 @@ STATIC
 EFI_STATUS
 PerformanceDomainAttributes (
   IN  SCMI_PERFORMANCE_PROTOCOL           *This,
-  IN  UINT32                               DomainId,
+  IN  UINT32                              DomainId,
   OUT SCMI_PERFORMANCE_DOMAIN_ATTRIBUTES  *DomainAttributes
   )
 {
@@ -107,8 +107,8 @@ PerformanceDomainAttributes (
 
   *MessageParams = DomainId;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_PERFORMANCE;
+  Cmd.ProtocolId = ScmiProtocolIdPerformance;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_PERFORMANCE_DOMAIN_ATTRIBUTES;
+  Cmd.MessageId  = ScmiMessageIdPerformanceDomainAttributes;
 
   PayloadLength = sizeof (DomainId);
 
@@ -160,30 +160,29 @@ PerformanceDescribeLevels (
   EFI_STATUS    Status;
   UINT32        PayloadLength;
   SCMI_COMMAND  Cmd;
-  UINT32*       MessageParams;
+  UINT32        *MessageParams;
   UINT32        LevelIndex;
   UINT32        RequiredSize;
   UINT32        LevelNo;
   UINT32        ReturnNumLevels;
   UINT32        ReturnRemainNumLevels;
 
-  PERF_DESCRIBE_LEVELS *Levels;
+  PERF_DESCRIBE_LEVELS  *Levels;
 
   Status = ScmiCommandGetPayload (&MessageParams);
   if (EFI_ERROR (Status)) {
     return Status;
   }
 
-  LevelIndex = 0;
+  LevelIndex   = 0;
   RequiredSize = 0;
 
   *MessageParams++ = DomainId;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_PERFORMANCE;
+  Cmd.ProtocolId = ScmiProtocolIdPerformance;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_PERFORMANCE_DESCRIBE_LEVELS;
+  Cmd.MessageId  = ScmiMessageIdPerformanceDescribeLevels;
 
   do {
-
     *MessageParams = LevelIndex;
 
     // Note, PayloadLength is an IN/OUT parameter.
@@ -192,13 +191,13 @@ PerformanceDescribeLevels (
     Status = ScmiCommandExecute (
                &Cmd,
                &PayloadLength,
-               (UINT32**)&Levels
+               (UINT32 **)&Levels
                );
     if (EFI_ERROR (Status)) {
       return Status;
     }
 
-    ReturnNumLevels = NUM_PERF_LEVELS (Levels->NumLevels);
+    ReturnNumLevels       = NUM_PERF_LEVELS (Levels->NumLevels);
     ReturnRemainNumLevels = NUM_REMAIN_PERF_LEVELS (Levels->NumLevels);
 
     if (RequiredSize == 0) {
@@ -213,13 +212,12 @@ PerformanceDescribeLevels (
     }
 
     for (LevelNo = 0; LevelNo < ReturnNumLevels; LevelNo++) {
-       CopyMem (
+      CopyMem (
-         &LevelArray[LevelIndex++],
+        &LevelArray[LevelIndex++],
-         &Levels->PerfLevel[LevelNo],
+        &Levels->PerfLevel[LevelNo],
-         sizeof (SCMI_PERFORMANCE_LEVEL)
+        sizeof (SCMI_PERFORMANCE_LEVEL)
-         );
+        );
     }
-
   } while (ReturnRemainNumLevels != 0);
 
   *LevelArraySize = RequiredSize;
@@ -239,9 +237,9 @@ PerformanceDescribeLevels (
 **/
 EFI_STATUS
 PerformanceLimitsSet (
-  IN SCMI_PERFORMANCE_PROTOCOL *This,
+  IN SCMI_PERFORMANCE_PROTOCOL  *This,
-  IN UINT32                    DomainId,
+  IN UINT32                     DomainId,
-  IN SCMI_PERFORMANCE_LIMITS   *Limits
+  IN SCMI_PERFORMANCE_LIMITS    *Limits
   )
 {
   EFI_STATUS    Status;
@@ -258,8 +256,8 @@ PerformanceLimitsSet (
   *MessageParams++ = Limits->RangeMax;
   *MessageParams   = Limits->RangeMin;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_PERFORMANCE;
+  Cmd.ProtocolId = ScmiProtocolIdPerformance;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_PERFORMANCE_LIMITS_SET;
+  Cmd.MessageId  = ScmiMessageIdPerformanceLimitsSet;
 
   PayloadLength = sizeof (DomainId) + sizeof (SCMI_PERFORMANCE_LIMITS);
 
@@ -285,9 +283,9 @@ PerformanceLimitsSet (
 **/
 EFI_STATUS
 PerformanceLimitsGet (
-  SCMI_PERFORMANCE_PROTOCOL *This,
+  SCMI_PERFORMANCE_PROTOCOL  *This,
-  UINT32                    DomainId,
+  UINT32                     DomainId,
-  SCMI_PERFORMANCE_LIMITS   *Limits
+  SCMI_PERFORMANCE_LIMITS    *Limits
   )
 {
   EFI_STATUS    Status;
@@ -304,15 +302,15 @@ PerformanceLimitsGet (
 
   *MessageParams = DomainId;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_PERFORMANCE;
+  Cmd.ProtocolId = ScmiProtocolIdPerformance;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_PERFORMANCE_LIMITS_GET;
+  Cmd.MessageId  = ScmiMessageIdPerformanceLimitsGet;
 
   PayloadLength = sizeof (DomainId);
 
   Status = ScmiCommandExecute (
              &Cmd,
              &PayloadLength,
-             (UINT32**)&ReturnValues
+             (UINT32 **)&ReturnValues
              );
   if (EFI_ERROR (Status)) {
     return Status;
@@ -336,9 +334,9 @@ PerformanceLimitsGet (
 **/
 EFI_STATUS
 PerformanceLevelSet (
-  IN SCMI_PERFORMANCE_PROTOCOL *This,
+  IN SCMI_PERFORMANCE_PROTOCOL  *This,
-  IN UINT32                    DomainId,
+  IN UINT32                     DomainId,
-  IN UINT32                    Level
+  IN UINT32                     Level
   )
 {
   EFI_STATUS    Status;
@@ -354,8 +352,8 @@ PerformanceLevelSet (
   *MessageParams++ = DomainId;
   *MessageParams   = Level;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_PERFORMANCE;
+  Cmd.ProtocolId = ScmiProtocolIdPerformance;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_PERFORMANCE_LEVEL_SET;
+  Cmd.MessageId  = ScmiMessageIdPerformanceLevelSet;
 
   PayloadLength = sizeof (DomainId) + sizeof (Level);
 
@@ -381,9 +379,9 @@ PerformanceLevelSet (
 **/
 EFI_STATUS
 PerformanceLevelGet (
-  IN  SCMI_PERFORMANCE_PROTOCOL *This,
+  IN  SCMI_PERFORMANCE_PROTOCOL  *This,
-  IN  UINT32                    DomainId,
+  IN  UINT32                     DomainId,
-  OUT UINT32                    *Level
+  OUT UINT32                     *Level
   )
 {
   EFI_STATUS    Status;
@@ -399,8 +397,8 @@ PerformanceLevelGet (
 
   *MessageParams = DomainId;
 
-  Cmd.ProtocolId = SCMI_PROTOCOL_ID_PERFORMANCE;
+  Cmd.ProtocolId = ScmiProtocolIdPerformance;
-  Cmd.MessageId  = SCMI_MESSAGE_ID_PERFORMANCE_LEVEL_GET;
+  Cmd.MessageId  = ScmiMessageIdPerformanceLevelGet;
 
   PayloadLength = sizeof (DomainId);
 
@@ -419,7 +417,7 @@ PerformanceLevelGet (
 }
 
 // Instance of the SCMI performance management protocol.
-STATIC CONST SCMI_PERFORMANCE_PROTOCOL PerformanceProtocol = {
+STATIC CONST SCMI_PERFORMANCE_PROTOCOL  PerformanceProtocol = {
   PerformanceGetVersion,
   PerformanceGetAttributes,
   PerformanceDomainAttributes,
@@ -439,7 +437,7 @@ STATIC CONST SCMI_PERFORMANCE_PROTOCOL PerformanceProtocol = {
 **/
 EFI_STATUS
 ScmiPerformanceProtocolInit (
-  IN EFI_HANDLE* Handle
+  IN EFI_HANDLE  *Handle
   )
 {
   return gBS->InstallMultipleProtocolInterfaces (

ArmPkg/Drivers/ArmScmiDxe/ScmiPrivate.h

@@ -1,6 +1,6 @@
 /** @file
 
-  Copyright (c) 2017-2018, Arm Limited. All rights reserved.
+  Copyright (c) 2017-2021, Arm Limited. All rights reserved.<BR>
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
@@ -8,65 +8,66 @@
     http://infocenter.arm.com/help/topic/com.arm.doc.den0056a/
     DEN0056A_System_Control_and_Management_Interface.pdf
 **/
+
 #ifndef SCMI_PRIVATE_H_
 #define SCMI_PRIVATE_H_
 
 // SCMI protocol IDs.
 typedef enum {
-  SCMI_PROTOCOL_ID_BASE         = 0x10,
+  ScmiProtocolIdBase        = 0x10,
-  SCMI_PROTOCOL_ID_POWER_DOMAIN = 0x11,
+  ScmiProtocolIdPowerDomain = 0x11,
-  SCMI_PROTOCOL_ID_SYSTEM_POWER = 0x12,
+  ScmiProtocolIdSystemPower = 0x12,
-  SCMI_PROTOCOL_ID_PERFORMANCE  = 0x13,
+  ScmiProtocolIdPerformance = 0x13,
-  SCMI_PROTOCOL_ID_CLOCK        = 0x14,
+  ScmiProtocolIdClock       = 0x14,
-  SCMI_PROTOCOL_ID_SENSOR       = 0x15
+  ScmiProtocolIdSensor      = 0x15
 } SCMI_PROTOCOL_ID;
 
 // SCMI message types.
 typedef enum {
-  SCMI_MESSAGE_TYPE_COMMAND          = 0,
+  ScmiMessageTypeCommand         = 0,
-  SCMI_MESSAGE_TYPE_DELAYED_RESPONSE = 2, // Skipping 1 is deliberate.
+  ScmiMessageTypeDelayedResponse = 2, // Skipping 1 is deliberate.
-  SCMI_MESSAGE_TYPE_NOTIFICATION     = 3
+  ScmiMessageTypeNotification    = 3
 } SCMI_MESSAGE_TYPE;
 
 // SCMI response error codes.
 typedef enum {
-  SCMI_SUCCESS            =  0,
+  ScmiSuccess           =  0,
-  SCMI_NOT_SUPPORTED      = -1,
+  ScmiNotSupported      = -1,
-  SCMI_INVALID_PARAMETERS = -2,
+  ScmiInvalidParameters = -2,
-  SCMI_DENIED             = -3,
+  ScmiDenied            = -3,
-  SCMI_NOT_FOUND          = -4,
+  ScmiNotFound          = -4,
-  SCMI_OUT_OF_RANGE       = -5,
+  ScmiOutOfRange        = -5,
-  SCMI_BUSY               = -6,
+  ScmiBusy              = -6,
-  SCMI_COMMS_ERROR        = -7,
+  ScmiCommsError        = -7,
-  SCMI_GENERIC_ERROR      = -8,
+  ScmiGenericError      = -8,
-  SCMI_HARDWARE_ERROR     = -9,
+  ScmiHardwareError     = -9,
-  SCMI_PROTOCOL_ERROR     = -10
+  ScmiProtocolError     = -10
 } SCMI_STATUS;
 
 // SCMI message IDs common to all protocols.
 typedef enum {
-  SCMI_MESSAGE_ID_PROTOCOL_VERSION            = 0x0,
+  ScmiMessageIdProtocolVersion           = 0x0,
-  SCMI_MESSAGE_ID_PROTOCOL_ATTRIBUTES         = 0x1,
+  ScmiMessageIdProtocolAttributes        = 0x1,
-  SCMI_MESSAGE_ID_PROTOCOL_MESSAGE_ATTRIBUTES = 0x2
+  ScmiMessageIdProtocolMessageAttributes = 0x2
 } SCMI_MESSAGE_ID;
 
 // Not defined in SCMI specification but will help to identify a message.
 typedef struct {
-  SCMI_PROTOCOL_ID ProtocolId;
+  SCMI_PROTOCOL_ID    ProtocolId;
-  UINT32 MessageId;
+  UINT32              MessageId;
 } SCMI_COMMAND;
 
 #pragma pack(1)
 
 // Response to a SCMI command.
 typedef struct {
-  INT32 Status;
+  INT32     Status;
-  UINT32 ReturnValues[];
+  UINT32    ReturnValues[];
 } SCMI_MESSAGE_RESPONSE;
 
 // Message header. MsgId[7:0], MsgType[9:8], ProtocolId[17:10]
-#define MESSAGE_TYPE_SHIFT       8
+#define MESSAGE_TYPE_SHIFT  8
-#define PROTOCOL_ID_SHIFT       10
+#define PROTOCOL_ID_SHIFT   10
 #define SCMI_MESSAGE_HEADER(MsgId, MsgType, ProtocolId)  (           \
                             MsgType << MESSAGE_TYPE_SHIFT   |        \
                             ProtocolId << PROTOCOL_ID_SHIFT |        \
@@ -74,7 +75,7 @@ typedef struct {
                             )
 // SCMI message header.
 typedef struct {
-  UINT32 MessageHeader;
+  UINT32    MessageHeader;
 } SCMI_MESSAGE_HEADER;
 
 #pragma pack()
@@ -89,7 +90,7 @@ typedef struct {
 **/
 EFI_STATUS
 ScmiCommandGetPayload (
-  OUT UINT32** Payload
+  OUT UINT32  **Payload
   );
 
 /** Execute a SCMI command and receive a response.
@@ -115,7 +116,7 @@ EFI_STATUS
 ScmiCommandExecute (
   IN     SCMI_COMMAND  *Command,
   IN OUT UINT32        *PayloadLength,
-  OUT    UINT32       **ReturnValues OPTIONAL
+  OUT    UINT32        **ReturnValues OPTIONAL
   );
 
 /** Return protocol version from SCP for a given protocol ID.

ArmPkg/Drivers/CpuDxe/AArch64/Mmu.c

@@ -2,7 +2,7 @@
 
 Copyright (c) 2009, Hewlett-Packard Company. All rights reserved.<BR>
 Portions copyright (c) 2010, Apple Inc. All rights reserved.<BR>
-Portions copyright (c) 2011-2013, ARM Ltd. All rights reserved.<BR>
+Portions copyright (c) 2011-2021, Arm Limited. All rights reserved.<BR>
 Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
 
 SPDX-License-Identifier: BSD-2-Clause-Patent
@@ -13,56 +13,120 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
 #include <Library/MemoryAllocationLib.h>
 #include "CpuDxe.h"
 
-#define TT_ATTR_INDX_INVALID    ((UINT32)~0)
+#define INVALID_ENTRY  ((UINT32)~0)
+
+#define MIN_T0SZ        16
+#define BITS_PER_LEVEL  9
+
+STATIC
+VOID
+GetRootTranslationTableInfo (
+  IN  UINTN  T0SZ,
+  OUT UINTN  *RootTableLevel,
+  OUT UINTN  *RootTableEntryCount
+  )
+{
+  *RootTableLevel      = (T0SZ - MIN_T0SZ) / BITS_PER_LEVEL;
+  *RootTableEntryCount = TT_ENTRY_COUNT >> (T0SZ - MIN_T0SZ) % BITS_PER_LEVEL;
+}
+
+STATIC
+UINT64
+PageAttributeToGcdAttribute (
+  IN UINT64  PageAttributes
+  )
+{
+  UINT64  GcdAttributes;
+
+  switch (PageAttributes & TT_ATTR_INDX_MASK) {
+    case TT_ATTR_INDX_DEVICE_MEMORY:
+      GcdAttributes = EFI_MEMORY_UC;
+      break;
+    case TT_ATTR_INDX_MEMORY_NON_CACHEABLE:
+      GcdAttributes = EFI_MEMORY_WC;
+      break;
+    case TT_ATTR_INDX_MEMORY_WRITE_THROUGH:
+      GcdAttributes = EFI_MEMORY_WT;
+      break;
+    case TT_ATTR_INDX_MEMORY_WRITE_BACK:
+      GcdAttributes = EFI_MEMORY_WB;
+      break;
+    default:
+      DEBUG ((
+        DEBUG_ERROR,
+        "PageAttributeToGcdAttribute: PageAttributes:0x%lX not supported.\n",
+        PageAttributes
+        ));
+      ASSERT (0);
+      // The Global Coherency Domain (GCD) value is defined as a bit set.
+      // Returning 0 means no attribute has been set.
+      GcdAttributes = 0;
+  }
+
+  // Determine protection attributes
+  if (((PageAttributes & TT_AP_MASK) == TT_AP_NO_RO) ||
+      ((PageAttributes & TT_AP_MASK) == TT_AP_RO_RO))
+  {
+    // Read only cases map to write-protect
+    GcdAttributes |= EFI_MEMORY_RO;
+  }
+
+  // Process eXecute Never attribute
+  if ((PageAttributes & (TT_PXN_MASK | TT_UXN_MASK)) != 0) {
+    GcdAttributes |= EFI_MEMORY_XP;
+  }
+
+  return GcdAttributes;
+}
 
 STATIC
 UINT64
 GetFirstPageAttribute (
   IN UINT64  *FirstLevelTableAddress,
-  IN UINTN    TableLevel
+  IN UINTN   TableLevel
   )
 {
-  UINT64 FirstEntry;
+  UINT64  FirstEntry;
 
   // Get the first entry of the table
   FirstEntry = *FirstLevelTableAddress;
 
-  if ((TableLevel != 3) && (FirstEntry & TT_TYPE_MASK) == TT_TYPE_TABLE_ENTRY) {
+  if ((TableLevel != 3) && ((FirstEntry & TT_TYPE_MASK) == TT_TYPE_TABLE_ENTRY)) {
     // Only valid for Levels 0, 1 and 2
 
     // Get the attribute of the subsequent table
-    return GetFirstPageAttribute ((UINT64*)(FirstEntry & TT_ADDRESS_MASK_DESCRIPTION_TABLE), TableLevel + 1);
+    return GetFirstPageAttribute ((UINT64 *)(FirstEntry & TT_ADDRESS_MASK_DESCRIPTION_TABLE), TableLevel + 1);
   } else if (((FirstEntry & TT_TYPE_MASK) == TT_TYPE_BLOCK_ENTRY) ||
              ((TableLevel == 3) && ((FirstEntry & TT_TYPE_MASK) == TT_TYPE_BLOCK_ENTRY_LEVEL3)))
   {
     return FirstEntry & TT_ATTR_INDX_MASK;
   } else {
-    return TT_ATTR_INDX_INVALID;
+    return INVALID_ENTRY;
   }
 }
 
 STATIC
 UINT64
 GetNextEntryAttribute (
-  IN     UINT64 *TableAddress,
+  IN     UINT64  *TableAddress,
   IN     UINTN   EntryCount,
   IN     UINTN   TableLevel,
   IN     UINT64  BaseAddress,
-  IN OUT UINT32 *PrevEntryAttribute,
+  IN OUT UINT32  *PrevEntryAttribute,
-  IN OUT UINT64 *StartGcdRegion
+  IN OUT UINT64  *StartGcdRegion
   )
 {
-  UINTN                             Index;
+  UINTN                            Index;
-  UINT64                            Entry;
+  UINT64                           Entry;
-  UINT32                            EntryAttribute;
+  UINT32                           EntryAttribute;
-  UINT32                            EntryType;
+  UINT32                           EntryType;
-  EFI_STATUS                        Status;
+  EFI_STATUS                       Status;
-  UINTN                             NumberOfDescriptors;
+  UINTN                            NumberOfDescriptors;
   EFI_GCD_MEMORY_SPACE_DESCRIPTOR  *MemorySpaceMap;
 
   // Get the memory space map from GCD
   MemorySpaceMap = NULL;
-  Status = gDS->GetMemorySpaceMap (&NumberOfDescriptors, &MemorySpaceMap);
+  Status         = gDS->GetMemorySpaceMap (&NumberOfDescriptors, &MemorySpaceMap);
   ASSERT_EFI_ERROR (Status);
 
   // We cannot get more than 3-level page table
@@ -71,24 +135,28 @@ GetNextEntryAttribute (
   // While the top level table might not contain TT_ENTRY_COUNT entries;
   // the subsequent ones should be filled up
   for (Index = 0; Index < EntryCount; Index++) {
-    Entry = TableAddress[Index];
+    Entry          = TableAddress[Index];
-    EntryType = Entry & TT_TYPE_MASK;
+    EntryType      = Entry & TT_TYPE_MASK;
     EntryAttribute = Entry  & TT_ATTR_INDX_MASK;
 
     // If Entry is a Table Descriptor type entry then go through the sub-level table
     if ((EntryType == TT_TYPE_BLOCK_ENTRY) ||
-        ((TableLevel == 3) && (EntryType == TT_TYPE_BLOCK_ENTRY_LEVEL3))) {
+        ((TableLevel == 3) && (EntryType == TT_TYPE_BLOCK_ENTRY_LEVEL3)))
-      if ((*PrevEntryAttribute == TT_ATTR_INDX_INVALID) || (EntryAttribute != *PrevEntryAttribute)) {
+    {
-        if (*PrevEntryAttribute != TT_ATTR_INDX_INVALID) {
+      if ((*PrevEntryAttribute == INVALID_ENTRY) || (EntryAttribute != *PrevEntryAttribute)) {
+        if (*PrevEntryAttribute != INVALID_ENTRY) {
           // Update GCD with the last region
-          SetGcdMemorySpaceAttributes (MemorySpaceMap, NumberOfDescriptors,
+          SetGcdMemorySpaceAttributes (
-              *StartGcdRegion,
+            MemorySpaceMap,
-              (BaseAddress + (Index * TT_ADDRESS_AT_LEVEL(TableLevel))) - *StartGcdRegion,
+            NumberOfDescriptors,
-              PageAttributeToGcdAttribute (*PrevEntryAttribute));
+            *StartGcdRegion,
+            (BaseAddress + (Index * TT_ADDRESS_AT_LEVEL (TableLevel))) - *StartGcdRegion,
+            PageAttributeToGcdAttribute (*PrevEntryAttribute)
+            );
         }
 
         // Start of the new region
-        *StartGcdRegion = BaseAddress + (Index * TT_ADDRESS_AT_LEVEL(TableLevel));
+        *StartGcdRegion     = BaseAddress + (Index * TT_ADDRESS_AT_LEVEL (TableLevel));
         *PrevEntryAttribute = EntryAttribute;
       } else {
         continue;
@@ -98,46 +166,53 @@ GetNextEntryAttribute (
       ASSERT (TableLevel < 3);
 
       // Increase the level number and scan the sub-level table
-      GetNextEntryAttribute ((UINT64*)(Entry & TT_ADDRESS_MASK_DESCRIPTION_TABLE),
+      GetNextEntryAttribute (
-                             TT_ENTRY_COUNT, TableLevel + 1,
+        (UINT64 *)(Entry & TT_ADDRESS_MASK_DESCRIPTION_TABLE),
-                             (BaseAddress + (Index * TT_ADDRESS_AT_LEVEL(TableLevel))),
+        TT_ENTRY_COUNT,
-                             PrevEntryAttribute, StartGcdRegion);
+        TableLevel + 1,
+        (BaseAddress + (Index * TT_ADDRESS_AT_LEVEL (TableLevel))),
+        PrevEntryAttribute,
+        StartGcdRegion
+        );
     } else {
-      if (*PrevEntryAttribute != TT_ATTR_INDX_INVALID) {
+      if (*PrevEntryAttribute != INVALID_ENTRY) {
         // Update GCD with the last region
-        SetGcdMemorySpaceAttributes (MemorySpaceMap, NumberOfDescriptors,
+        SetGcdMemorySpaceAttributes (
-            *StartGcdRegion,
+          MemorySpaceMap,
-            (BaseAddress + (Index * TT_ADDRESS_AT_LEVEL(TableLevel))) - *StartGcdRegion,
+          NumberOfDescriptors,
-            PageAttributeToGcdAttribute (*PrevEntryAttribute));
+          *StartGcdRegion,
+          (BaseAddress + (Index * TT_ADDRESS_AT_LEVEL (TableLevel))) - *StartGcdRegion,
+          PageAttributeToGcdAttribute (*PrevEntryAttribute)
+          );
 
         // Start of the new region
-        *StartGcdRegion = BaseAddress + (Index * TT_ADDRESS_AT_LEVEL(TableLevel));
+        *StartGcdRegion     = BaseAddress + (Index * TT_ADDRESS_AT_LEVEL (TableLevel));
-        *PrevEntryAttribute = TT_ATTR_INDX_INVALID;
+        *PrevEntryAttribute = INVALID_ENTRY;
       }
     }
   }
 
   FreePool (MemorySpaceMap);
 
-  return BaseAddress + (EntryCount * TT_ADDRESS_AT_LEVEL(TableLevel));
+  return BaseAddress + (EntryCount * TT_ADDRESS_AT_LEVEL (TableLevel));
 }
 
 EFI_STATUS
 SyncCacheConfig (
-  IN  EFI_CPU_ARCH_PROTOCOL *CpuProtocol
+  IN  EFI_CPU_ARCH_PROTOCOL  *CpuProtocol
   )
 {
-  EFI_STATUS                          Status;
+  EFI_STATUS                       Status;
-  UINT32                              PageAttribute = 0;
+  UINT32                           PageAttribute;
-  UINT64                             *FirstLevelTableAddress;
+  UINT64                           *FirstLevelTableAddress;
-  UINTN                               TableLevel;
+  UINTN                            TableLevel;
-  UINTN                               TableCount;
+  UINTN                            TableCount;
-  UINTN                               NumberOfDescriptors;
+  UINTN                            NumberOfDescriptors;
-  EFI_GCD_MEMORY_SPACE_DESCRIPTOR    *MemorySpaceMap;
+  EFI_GCD_MEMORY_SPACE_DESCRIPTOR  *MemorySpaceMap;
-  UINTN                               Tcr;
+  UINTN                            Tcr;
-  UINTN                               T0SZ;
+  UINTN                            T0SZ;
-  UINT64                              BaseAddressGcdRegion;
+  UINT64                           BaseAddressGcdRegion;
-  UINT64                              EndAddressGcdRegion;
+  UINT64                           EndAddressGcdRegion;
 
   // This code assumes MMU is enabled and filed with section translations
   ASSERT (ArmMmuEnabled ());
@@ -146,7 +221,7 @@ SyncCacheConfig (
   // Get the memory space map from GCD
   //
   MemorySpaceMap = NULL;
-  Status = gDS->GetMemorySpaceMap (&NumberOfDescriptors, &MemorySpaceMap);
+  Status         = gDS->GetMemorySpaceMap (&NumberOfDescriptors, &MemorySpaceMap);
   ASSERT_EFI_ERROR (Status);
 
   // The GCD implementation maintains its own copy of the state of memory space attributes.  GCD needs
@@ -156,7 +231,7 @@ SyncCacheConfig (
   // with a way for GCD to query the CPU Arch. driver of the existing memory space attributes instead.
 
   // Obtain page table base
-  FirstLevelTableAddress = (UINT64*)(ArmGetTTBR0BaseAddress ());
+  FirstLevelTableAddress = (UINT64 *)(ArmGetTTBR0BaseAddress ());
 
   // Get Translation Control Register value
   Tcr = ArmGetTCR ();
@@ -171,17 +246,24 @@ SyncCacheConfig (
 
   // We scan from the start of the memory map (ie: at the address 0x0)
   BaseAddressGcdRegion = 0x0;
-  EndAddressGcdRegion = GetNextEntryAttribute (FirstLevelTableAddress,
+  EndAddressGcdRegion  = GetNextEntryAttribute (
-                                               TableCount, TableLevel,
+                           FirstLevelTableAddress,
-                                               BaseAddressGcdRegion,
+                           TableCount,
-                                               &PageAttribute, &BaseAddressGcdRegion);
+                           TableLevel,
+                           BaseAddressGcdRegion,
+                           &PageAttribute,
+                           &BaseAddressGcdRegion
+                           );
 
   // Update GCD with the last region if valid
-  if (PageAttribute != TT_ATTR_INDX_INVALID) {
+  if (PageAttribute != INVALID_ENTRY) {
-    SetGcdMemorySpaceAttributes (MemorySpaceMap, NumberOfDescriptors,
+    SetGcdMemorySpaceAttributes (
-        BaseAddressGcdRegion,
+      MemorySpaceMap,
-        EndAddressGcdRegion - BaseAddressGcdRegion,
+      NumberOfDescriptors,
-        PageAttributeToGcdAttribute (PageAttribute));
+      BaseAddressGcdRegion,
+      EndAddressGcdRegion - BaseAddressGcdRegion,
+      PageAttributeToGcdAttribute (PageAttribute)
+      );
   }
 
   FreePool (MemorySpaceMap);
@@ -191,42 +273,43 @@ SyncCacheConfig (
 
 UINT64
 EfiAttributeToArmAttribute (
-  IN UINT64                    EfiAttributes
+  IN UINT64  EfiAttributes
   )
 {
-  UINT64 ArmAttributes;
+  UINT64  ArmAttributes;
 
   switch (EfiAttributes & EFI_MEMORY_CACHETYPE_MASK) {
-  case EFI_MEMORY_UC:
+    case EFI_MEMORY_UC:
-    if (ArmReadCurrentEL () == AARCH64_EL2) {
+      if (ArmReadCurrentEL () == AARCH64_EL2) {
-      ArmAttributes = TT_ATTR_INDX_DEVICE_MEMORY | TT_XN_MASK;
+        ArmAttributes = TT_ATTR_INDX_DEVICE_MEMORY | TT_XN_MASK;
-    } else {
+      } else {
-      ArmAttributes = TT_ATTR_INDX_DEVICE_MEMORY | TT_UXN_MASK | TT_PXN_MASK;
+        ArmAttributes = TT_ATTR_INDX_DEVICE_MEMORY | TT_UXN_MASK | TT_PXN_MASK;
-    }
+      }
-    break;
+
-  case EFI_MEMORY_WC:
+      break;
-    ArmAttributes = TT_ATTR_INDX_MEMORY_NON_CACHEABLE;
+    case EFI_MEMORY_WC:
-    break;
+      ArmAttributes = TT_ATTR_INDX_MEMORY_NON_CACHEABLE;
-  case EFI_MEMORY_WT:
+      break;
-    ArmAttributes = TT_ATTR_INDX_MEMORY_WRITE_THROUGH | TT_SH_INNER_SHAREABLE;
+    case EFI_MEMORY_WT:
-    break;
+      ArmAttributes = TT_ATTR_INDX_MEMORY_WRITE_THROUGH | TT_SH_INNER_SHAREABLE;
-  case EFI_MEMORY_WB:
+      break;
-    ArmAttributes = TT_ATTR_INDX_MEMORY_WRITE_BACK | TT_SH_INNER_SHAREABLE;
+    case EFI_MEMORY_WB:
-    break;
+      ArmAttributes = TT_ATTR_INDX_MEMORY_WRITE_BACK | TT_SH_INNER_SHAREABLE;
-  default:
+      break;
-    ArmAttributes = TT_ATTR_INDX_MASK;
+    default:
+      ArmAttributes = TT_ATTR_INDX_MASK;
   }
 
   // Set the access flag to match the block attributes
   ArmAttributes |= TT_AF;
 
   // Determine protection attributes
-  if (EfiAttributes & EFI_MEMORY_RO) {
+  if ((EfiAttributes & EFI_MEMORY_RO) != 0) {
-    ArmAttributes |= TT_AP_RO_RO;
+    ArmAttributes |= TT_AP_NO_RO;
   }
 
   // Process eXecute Never attribute
-  if (EfiAttributes & EFI_MEMORY_XP) {
+  if ((EfiAttributes & EFI_MEMORY_XP) != 0) {
     ArmAttributes |= TT_PXN_MASK;
   }
 
@@ -237,19 +320,19 @@ EfiAttributeToArmAttribute (
 // And then the function will identify the size of the region that has the same page table attribute.
 EFI_STATUS
 GetMemoryRegionRec (
-  IN     UINT64                  *TranslationTable,
+  IN     UINT64  *TranslationTable,
-  IN     UINTN                    TableLevel,
+  IN     UINTN   TableLevel,
-  IN     UINT64                  *LastBlockEntry,
+  IN     UINT64  *LastBlockEntry,
-  IN OUT UINTN                   *BaseAddress,
+  IN OUT UINTN   *BaseAddress,
-  OUT    UINTN                   *RegionLength,
+  OUT    UINTN   *RegionLength,
-  OUT    UINTN                   *RegionAttributes
+  OUT    UINTN   *RegionAttributes
   )
 {
-  EFI_STATUS Status;
+  EFI_STATUS  Status;
-  UINT64    *NextTranslationTable;
+  UINT64      *NextTranslationTable;
-  UINT64    *BlockEntry;
+  UINT64      *BlockEntry;
-  UINT64     BlockEntryType;
+  UINT64      BlockEntryType;
-  UINT64     EntryType;
+  UINT64      EntryType;
 
   if (TableLevel != 3) {
     BlockEntryType = TT_TYPE_BLOCK_ENTRY;
@@ -258,22 +341,25 @@ GetMemoryRegionRec (
   }
 
   // Find the block entry linked to the Base Address
-  BlockEntry = (UINT64*)TT_GET_ENTRY_FOR_ADDRESS (TranslationTable, TableLevel, *BaseAddress);
+  BlockEntry = (UINT64 *)TT_GET_ENTRY_FOR_ADDRESS (TranslationTable, TableLevel, *BaseAddress);
-  EntryType = *BlockEntry & TT_TYPE_MASK;
+  EntryType  = *BlockEntry & TT_TYPE_MASK;
 
   if ((TableLevel < 3) && (EntryType == TT_TYPE_TABLE_ENTRY)) {
-    NextTranslationTable = (UINT64*)(*BlockEntry & TT_ADDRESS_MASK_DESCRIPTION_TABLE);
+    NextTranslationTable = (UINT64 *)(*BlockEntry & TT_ADDRESS_MASK_DESCRIPTION_TABLE);
 
     // The entry is a page table, so we go to the next level
     Status = GetMemoryRegionRec (
-        NextTranslationTable, // Address of the next level page table
+               NextTranslationTable, // Address of the next level page table
-        TableLevel + 1, // Next Page Table level
+               TableLevel + 1,       // Next Page Table level
-        (UINTN*)TT_LAST_BLOCK_ADDRESS(NextTranslationTable, TT_ENTRY_COUNT),
+               (UINTN *)TT_LAST_BLOCK_ADDRESS (NextTranslationTable, TT_ENTRY_COUNT),
-        BaseAddress, RegionLength, RegionAttributes);
+               BaseAddress,
+               RegionLength,
+               RegionAttributes
+               );
 
     // In case of 'Success', it means the end of the block region has been found into the upper
     // level translation table
-    if (!EFI_ERROR(Status)) {
+    if (!EFI_ERROR (Status)) {
       return EFI_SUCCESS;
     }
 
@@ -282,7 +368,7 @@ GetMemoryRegionRec (
   } else if (EntryType == BlockEntryType) {
     // We have found the BlockEntry attached to the address. We save its start address (the start
     // address might be before the 'BaseAddress') and attributes
-    *BaseAddress      = *BaseAddress & ~(TT_ADDRESS_AT_LEVEL(TableLevel) - 1);
+    *BaseAddress      = *BaseAddress & ~(TT_ADDRESS_AT_LEVEL (TableLevel) - 1);
     *RegionLength     = 0;
     *RegionAttributes = *BlockEntry & TT_ATTRIBUTES_MASK;
   } else {
@@ -292,11 +378,12 @@ GetMemoryRegionRec (
 
   while (BlockEntry <= LastBlockEntry) {
     if ((*BlockEntry & TT_ATTRIBUTES_MASK) == *RegionAttributes) {
-      *RegionLength = *RegionLength + TT_BLOCK_ENTRY_SIZE_AT_LEVEL(TableLevel);
+      *RegionLength = *RegionLength + TT_BLOCK_ENTRY_SIZE_AT_LEVEL (TableLevel);
     } else {
       // In case we have found the end of the region we return success
       return EFI_SUCCESS;
     }
+
     BlockEntry++;
   }
 
@@ -308,13 +395,13 @@ GetMemoryRegionRec (
 
 EFI_STATUS
 GetMemoryRegion (
-  IN OUT UINTN                   *BaseAddress,
+  IN OUT UINTN  *BaseAddress,
-  OUT    UINTN                   *RegionLength,
+  OUT    UINTN  *RegionLength,
-  OUT    UINTN                   *RegionAttributes
+  OUT    UINTN  *RegionAttributes
   )
 {
   EFI_STATUS  Status;
-  UINT64     *TranslationTable;
+  UINT64      *TranslationTable;
   UINTN       TableLevel;
   UINTN       EntryCount;
   UINTN       T0SZ;
@@ -327,9 +414,14 @@ GetMemoryRegion (
   // Get the Table info from T0SZ
   GetRootTranslationTableInfo (T0SZ, &TableLevel, &EntryCount);
 
-  Status = GetMemoryRegionRec (TranslationTable, TableLevel,
+  Status = GetMemoryRegionRec (
-      (UINTN*)TT_LAST_BLOCK_ADDRESS(TranslationTable, EntryCount),
+             TranslationTable,
-      BaseAddress, RegionLength, RegionAttributes);
+             TableLevel,
+             (UINTN *)TT_LAST_BLOCK_ADDRESS (TranslationTable, EntryCount),
+             BaseAddress,
+             RegionLength,
+             RegionAttributes
+             );
 
   // If the region continues up to the end of the root table then GetMemoryRegionRec()
   // will return EFI_NOT_FOUND

ArmPkg/Drivers/CpuDxe/Arm/Mmu.c

@@ -2,7 +2,7 @@
 
 Copyright (c) 2009, Hewlett-Packard Company. All rights reserved.<BR>
 Portions copyright (c) 2010, Apple Inc. All rights reserved.<BR>
-Portions copyright (c) 2013, ARM Ltd. All rights reserved.<BR>
+Portions copyright (c) 2013-2021, Arm Limited. All rights reserved.<BR>
 Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
 
 SPDX-License-Identifier: BSD-2-Clause-Patent
@@ -22,7 +22,7 @@ SectionToGcdAttributes (
   *GcdAttributes = 0;
 
   // determine cacheability attributes
-  switch(SectionAttributes & TT_DESCRIPTOR_SECTION_CACHE_POLICY_MASK) {
+  switch (SectionAttributes & TT_DESCRIPTOR_SECTION_CACHE_POLICY_MASK) {
     case TT_DESCRIPTOR_SECTION_CACHE_POLICY_STRONGLY_ORDERED:
       *GcdAttributes |= EFI_MEMORY_UC;
       break;
@@ -49,9 +49,9 @@ SectionToGcdAttributes (
   }
 
   // determine protection attributes
-  switch(SectionAttributes & TT_DESCRIPTOR_SECTION_AP_MASK) {
+  switch (SectionAttributes & TT_DESCRIPTOR_SECTION_AP_MASK) {
     case TT_DESCRIPTOR_SECTION_AP_NO_NO: // no read, no write
-      //*GcdAttributes |= EFI_MEMORY_RO | EFI_MEMORY_RP;
+      // *GcdAttributes |= EFI_MEMORY_RO | EFI_MEMORY_RP;
       break;
 
     case TT_DESCRIPTOR_SECTION_AP_RW_NO:
@@ -86,7 +86,7 @@ PageToGcdAttributes (
   *GcdAttributes = 0;
 
   // determine cacheability attributes
-  switch(PageAttributes & TT_DESCRIPTOR_PAGE_CACHE_POLICY_MASK) {
+  switch (PageAttributes & TT_DESCRIPTOR_PAGE_CACHE_POLICY_MASK) {
     case TT_DESCRIPTOR_PAGE_CACHE_POLICY_STRONGLY_ORDERED:
       *GcdAttributes |= EFI_MEMORY_UC;
       break;
@@ -113,9 +113,9 @@ PageToGcdAttributes (
   }
 
   // determine protection attributes
-  switch(PageAttributes & TT_DESCRIPTOR_PAGE_AP_MASK) {
+  switch (PageAttributes & TT_DESCRIPTOR_PAGE_AP_MASK) {
     case TT_DESCRIPTOR_PAGE_AP_NO_NO: // no read, no write
-      //*GcdAttributes |= EFI_MEMORY_RO | EFI_MEMORY_RP;
+      // *GcdAttributes |= EFI_MEMORY_RO | EFI_MEMORY_RP;
       break;
 
     case TT_DESCRIPTOR_PAGE_AP_RW_NO:
@@ -143,43 +143,43 @@ PageToGcdAttributes (
 
 EFI_STATUS
 SyncCacheConfigPage (
-  IN     UINT32                             SectionIndex,
+  IN     UINT32                           SectionIndex,
-  IN     UINT32                             FirstLevelDescriptor,
+  IN     UINT32                           FirstLevelDescriptor,
-  IN     UINTN                              NumberOfDescriptors,
+  IN     UINTN                            NumberOfDescriptors,
-  IN     EFI_GCD_MEMORY_SPACE_DESCRIPTOR    *MemorySpaceMap,
+  IN     EFI_GCD_MEMORY_SPACE_DESCRIPTOR  *MemorySpaceMap,
-  IN OUT EFI_PHYSICAL_ADDRESS               *NextRegionBase,
+  IN OUT EFI_PHYSICAL_ADDRESS             *NextRegionBase,
-  IN OUT UINT64                             *NextRegionLength,
+  IN OUT UINT64                           *NextRegionLength,
-  IN OUT UINT32                             *NextSectionAttributes
+  IN OUT UINT32                           *NextSectionAttributes
   )
 {
-  EFI_STATUS                          Status;
+  EFI_STATUS                     Status;
-  UINT32                              i;
+  UINT32                         i;
-  volatile ARM_PAGE_TABLE_ENTRY       *SecondLevelTable;
+  volatile ARM_PAGE_TABLE_ENTRY  *SecondLevelTable;
-  UINT32                              NextPageAttributes = 0;
+  UINT32                         NextPageAttributes;
-  UINT32                              PageAttributes = 0;
+  UINT32                         PageAttributes;
-  UINT32                              BaseAddress;
+  UINT32                         BaseAddress;
-  UINT64                              GcdAttributes;
+  UINT64                         GcdAttributes;
 
   // Get the Base Address from FirstLevelDescriptor;
-  BaseAddress = TT_DESCRIPTOR_PAGE_BASE_ADDRESS(SectionIndex << TT_DESCRIPTOR_SECTION_BASE_SHIFT);
+  BaseAddress = TT_DESCRIPTOR_PAGE_BASE_ADDRESS (SectionIndex << TT_DESCRIPTOR_SECTION_BASE_SHIFT);
 
   // Convert SectionAttributes into PageAttributes
   NextPageAttributes =
-      TT_DESCRIPTOR_CONVERT_TO_PAGE_CACHE_POLICY(*NextSectionAttributes,0) |
+    TT_DESCRIPTOR_CONVERT_TO_PAGE_CACHE_POLICY (*NextSectionAttributes, 0) |
-      TT_DESCRIPTOR_CONVERT_TO_PAGE_AP(*NextSectionAttributes);
+    TT_DESCRIPTOR_CONVERT_TO_PAGE_AP (*NextSectionAttributes);
 
   // obtain page table base
   SecondLevelTable = (ARM_PAGE_TABLE_ENTRY *)(FirstLevelDescriptor & TT_DESCRIPTOR_SECTION_PAGETABLE_ADDRESS_MASK);
 
-  for (i=0; i < TRANSLATION_TABLE_PAGE_COUNT; i++) {
+  for (i = 0; i < TRANSLATION_TABLE_PAGE_COUNT; i++) {
     if ((SecondLevelTable[i] & TT_DESCRIPTOR_PAGE_TYPE_MASK) == TT_DESCRIPTOR_PAGE_TYPE_PAGE) {
       // extract attributes (cacheability and permissions)
       PageAttributes = SecondLevelTable[i] & (TT_DESCRIPTOR_PAGE_CACHE_POLICY_MASK | TT_DESCRIPTOR_PAGE_AP_MASK);
 
       if (NextPageAttributes == 0) {
         // start on a new region
-        *NextRegionLength = 0;
+        *NextRegionLength  = 0;
-        *NextRegionBase = BaseAddress | (i << TT_DESCRIPTOR_PAGE_BASE_SHIFT);
+        *NextRegionBase    = BaseAddress | (i << TT_DESCRIPTOR_PAGE_BASE_SHIFT);
         NextPageAttributes = PageAttributes;
       } else if (PageAttributes != NextPageAttributes) {
         // Convert Section Attributes into GCD Attributes
@@ -190,8 +190,8 @@ SyncCacheConfigPage (
         SetGcdMemorySpaceAttributes (MemorySpaceMap, NumberOfDescriptors, *NextRegionBase, *NextRegionLength, GcdAttributes);
 
         // start on a new region
-        *NextRegionLength = 0;
+        *NextRegionLength  = 0;
-        *NextRegionBase = BaseAddress | (i << TT_DESCRIPTOR_PAGE_BASE_SHIFT);
+        *NextRegionBase    = BaseAddress | (i << TT_DESCRIPTOR_PAGE_BASE_SHIFT);
         NextPageAttributes = PageAttributes;
       }
     } else if (NextPageAttributes != 0) {
@@ -202,37 +202,37 @@ SyncCacheConfigPage (
       // update GCD with these changes (this will recurse into our own CpuSetMemoryAttributes below which is OK)
       SetGcdMemorySpaceAttributes (MemorySpaceMap, NumberOfDescriptors, *NextRegionBase, *NextRegionLength, GcdAttributes);
 
-      *NextRegionLength = 0;
+      *NextRegionLength  = 0;
-      *NextRegionBase = BaseAddress | (i << TT_DESCRIPTOR_PAGE_BASE_SHIFT);
+      *NextRegionBase    = BaseAddress | (i << TT_DESCRIPTOR_PAGE_BASE_SHIFT);
       NextPageAttributes = 0;
     }
+
     *NextRegionLength += TT_DESCRIPTOR_PAGE_SIZE;
   }
 
   // Convert back PageAttributes into SectionAttributes
   *NextSectionAttributes =
-      TT_DESCRIPTOR_CONVERT_TO_SECTION_CACHE_POLICY(NextPageAttributes,0) |
+    TT_DESCRIPTOR_CONVERT_TO_SECTION_CACHE_POLICY (NextPageAttributes, 0) |
-      TT_DESCRIPTOR_CONVERT_TO_SECTION_AP(NextPageAttributes);
+    TT_DESCRIPTOR_CONVERT_TO_SECTION_AP (NextPageAttributes);
 
   return EFI_SUCCESS;
 }
 
 EFI_STATUS
 SyncCacheConfig (
-  IN  EFI_CPU_ARCH_PROTOCOL *CpuProtocol
+  IN  EFI_CPU_ARCH_PROTOCOL  *CpuProtocol
   )
 {
-  EFI_STATUS                          Status;
+  EFI_STATUS                           Status;
-  UINT32                              i;
+  UINT32                               i;
-  EFI_PHYSICAL_ADDRESS                NextRegionBase;
+  EFI_PHYSICAL_ADDRESS                 NextRegionBase;
-  UINT64                              NextRegionLength;
+  UINT64                               NextRegionLength;
-  UINT32                              NextSectionAttributes = 0;
+  UINT32                               NextSectionAttributes;
-  UINT32                              SectionAttributes = 0;
+  UINT32                               SectionAttributes;
-  UINT64                              GcdAttributes;
+  UINT64                               GcdAttributes;
-  volatile ARM_FIRST_LEVEL_DESCRIPTOR   *FirstLevelTable;
+  volatile ARM_FIRST_LEVEL_DESCRIPTOR  *FirstLevelTable;
-  UINTN                               NumberOfDescriptors;
+  UINTN                                NumberOfDescriptors;
-  EFI_GCD_MEMORY_SPACE_DESCRIPTOR     *MemorySpaceMap;
+  EFI_GCD_MEMORY_SPACE_DESCRIPTOR      *MemorySpaceMap;
-
 
   DEBUG ((DEBUG_PAGE, "SyncCacheConfig()\n"));
 
@@ -243,10 +243,9 @@ SyncCacheConfig (
   // Get the memory space map from GCD
   //
   MemorySpaceMap = NULL;
-  Status = gDS->GetMemorySpaceMap (&NumberOfDescriptors, &MemorySpaceMap);
+  Status         = gDS->GetMemorySpaceMap (&NumberOfDescriptors, &MemorySpaceMap);
   ASSERT_EFI_ERROR (Status);
 
-
   // The GCD implementation maintains its own copy of the state of memory space attributes.  GCD needs
   // to know what the initial memory space attributes are.  The CPU Arch. Protocol does not provide a
   // GetMemoryAttributes function for GCD to get this so we must resort to calling GCD (as if we were
@@ -261,15 +260,15 @@ SyncCacheConfig (
 
   // iterate through each 1MB descriptor
   NextRegionBase = NextRegionLength = 0;
-  for (i=0; i < TRANSLATION_TABLE_SECTION_COUNT; i++) {
+  for (i = 0; i < TRANSLATION_TABLE_SECTION_COUNT; i++) {
     if ((FirstLevelTable[i] & TT_DESCRIPTOR_SECTION_TYPE_MASK) == TT_DESCRIPTOR_SECTION_TYPE_SECTION) {
       // extract attributes (cacheability and permissions)
       SectionAttributes = FirstLevelTable[i] & (TT_DESCRIPTOR_SECTION_CACHE_POLICY_MASK | TT_DESCRIPTOR_SECTION_AP_MASK);
 
       if (NextSectionAttributes == 0) {
         // start on a new region
-        NextRegionLength = 0;
+        NextRegionLength      = 0;
-        NextRegionBase = TT_DESCRIPTOR_SECTION_BASE_ADDRESS(i << TT_DESCRIPTOR_SECTION_BASE_SHIFT);
+        NextRegionBase        = TT_DESCRIPTOR_SECTION_BASE_ADDRESS (i << TT_DESCRIPTOR_SECTION_BASE_SHIFT);
         NextSectionAttributes = SectionAttributes;
       } else if (SectionAttributes != NextSectionAttributes) {
         // Convert Section Attributes into GCD Attributes
@@ -280,21 +279,27 @@ SyncCacheConfig (
         SetGcdMemorySpaceAttributes (MemorySpaceMap, NumberOfDescriptors, NextRegionBase, NextRegionLength, GcdAttributes);
 
         // start on a new region
-        NextRegionLength = 0;
+        NextRegionLength      = 0;
-        NextRegionBase = TT_DESCRIPTOR_SECTION_BASE_ADDRESS(i << TT_DESCRIPTOR_SECTION_BASE_SHIFT);
+        NextRegionBase        = TT_DESCRIPTOR_SECTION_BASE_ADDRESS (i << TT_DESCRIPTOR_SECTION_BASE_SHIFT);
         NextSectionAttributes = SectionAttributes;
       }
+
       NextRegionLength += TT_DESCRIPTOR_SECTION_SIZE;
-    } else if (TT_DESCRIPTOR_SECTION_TYPE_IS_PAGE_TABLE(FirstLevelTable[i])) {
+    } else if (TT_DESCRIPTOR_SECTION_TYPE_IS_PAGE_TABLE (FirstLevelTable[i])) {
       // In this case any bits set in the 'NextSectionAttributes' are garbage and were set from
       // bits that are actually part of the pagetable address.  We clear it out to zero so that
       // the SyncCacheConfigPage will use the page attributes instead of trying to convert the
       // section attributes into page attributes
       NextSectionAttributes = 0;
-      Status = SyncCacheConfigPage (
+      Status                = SyncCacheConfigPage (
-          i,FirstLevelTable[i],
+                                i,
-          NumberOfDescriptors, MemorySpaceMap,
+                                FirstLevelTable[i],
-          &NextRegionBase,&NextRegionLength,&NextSectionAttributes);
+                                NumberOfDescriptors,
+                                MemorySpaceMap,
+                                &NextRegionBase,
+                                &NextRegionLength,
+                                &NextSectionAttributes
+                                );
       ASSERT_EFI_ERROR (Status);
     } else {
       // We do not support yet 16MB sections
@@ -309,10 +314,11 @@ SyncCacheConfig (
         // update GCD with these changes (this will recurse into our own CpuSetMemoryAttributes below which is OK)
         SetGcdMemorySpaceAttributes (MemorySpaceMap, NumberOfDescriptors, NextRegionBase, NextRegionLength, GcdAttributes);
 
-        NextRegionLength = 0;
+        NextRegionLength      = 0;
-        NextRegionBase = TT_DESCRIPTOR_SECTION_BASE_ADDRESS(i << TT_DESCRIPTOR_SECTION_BASE_SHIFT);
+        NextRegionBase        = TT_DESCRIPTOR_SECTION_BASE_ADDRESS (i << TT_DESCRIPTOR_SECTION_BASE_SHIFT);
         NextSectionAttributes = 0;
       }
+
       NextRegionLength += TT_DESCRIPTOR_SECTION_SIZE;
     }
   } // section entry loop
@@ -333,10 +339,10 @@ SyncCacheConfig (
 
 UINT64
 EfiAttributeToArmAttribute (
-  IN UINT64                    EfiAttributes
+  IN UINT64  EfiAttributes
   )
 {
-  UINT64 ArmAttributes;
+  UINT64  ArmAttributes;
 
   switch (EfiAttributes & EFI_MEMORY_CACHETYPE_MASK) {
     case EFI_MEMORY_UC:
@@ -345,7 +351,7 @@ EfiAttributeToArmAttribute (
       break;
 
     case EFI_MEMORY_WC:
-      // Map to normal non-cachable
+      // Map to normal non-cacheable
       ArmAttributes = TT_DESCRIPTOR_SECTION_CACHE_POLICY_NON_CACHEABLE; // TEX [2:0]= 001 = 0x2, B=0, C=0
       break;
 
@@ -366,14 +372,14 @@ EfiAttributeToArmAttribute (
   }
 
   // Determine protection attributes
-  if (EfiAttributes & EFI_MEMORY_RO) {
+  if ((EfiAttributes & EFI_MEMORY_RO) != 0) {
     ArmAttributes |= TT_DESCRIPTOR_SECTION_AP_RO_RO;
   } else {
     ArmAttributes |= TT_DESCRIPTOR_SECTION_AP_RW_RW;
   }
 
   // Determine eXecute Never attribute
-  if (EfiAttributes & EFI_MEMORY_XP) {
+  if ((EfiAttributes & EFI_MEMORY_XP) != 0) {
     ArmAttributes |= TT_DESCRIPTOR_SECTION_XN_MASK;
   }
 
@@ -382,15 +388,15 @@ EfiAttributeToArmAttribute (
 
 EFI_STATUS
 GetMemoryRegionPage (
-  IN     UINT32                  *PageTable,
+  IN     UINT32  *PageTable,
-  IN OUT UINTN                   *BaseAddress,
+  IN OUT UINTN   *BaseAddress,
-  OUT    UINTN                   *RegionLength,
+  OUT    UINTN   *RegionLength,
-  OUT    UINTN                   *RegionAttributes
+  OUT    UINTN   *RegionAttributes
   )
 {
-  UINT32      PageAttributes;
+  UINT32  PageAttributes;
-  UINT32      TableIndex;
+  UINT32  TableIndex;
-  UINT32      PageDescriptor;
+  UINT32  PageDescriptor;
 
   // Convert the section attributes into page attributes
   PageAttributes = ConvertSectionAttributesToPageAttributes (*RegionAttributes, 0);
@@ -400,7 +406,7 @@ GetMemoryRegionPage (
   ASSERT (TableIndex < TRANSLATION_TABLE_PAGE_COUNT);
 
   // Go through the page table to find the end of the section
-  for (; TableIndex < TRANSLATION_TABLE_PAGE_COUNT; TableIndex++) {
+  for ( ; TableIndex < TRANSLATION_TABLE_PAGE_COUNT; TableIndex++) {
     // Get the section at the given index
     PageDescriptor = PageTable[TableIndex];
 
@@ -416,7 +422,7 @@ GetMemoryRegionPage (
       }
     } else {
       // We do not support Large Page yet. We return EFI_SUCCESS that means end of the region.
-      ASSERT(0);
+      ASSERT (0);
       return EFI_SUCCESS;
     }
   }
@@ -426,9 +432,9 @@ GetMemoryRegionPage (
 
 EFI_STATUS
 GetMemoryRegion (
-  IN OUT UINTN                   *BaseAddress,
+  IN OUT UINTN  *BaseAddress,
-  OUT    UINTN                   *RegionLength,
+  OUT    UINTN  *RegionLength,
-  OUT    UINTN                   *RegionAttributes
+  OUT    UINTN  *RegionAttributes
   )
 {
   EFI_STATUS                  Status;
@@ -436,8 +442,8 @@ GetMemoryRegion (
   UINT32                      PageAttributes;
   UINT32                      PageTableIndex;
   UINT32                      SectionDescriptor;
-  ARM_FIRST_LEVEL_DESCRIPTOR *FirstLevelTable;
+  ARM_FIRST_LEVEL_DESCRIPTOR  *FirstLevelTable;
-  UINT32                     *PageTable;
+  UINT32                      *PageTable;
 
   // Initialize the arguments
   *RegionLength = 0;
@@ -459,32 +465,32 @@ GetMemoryRegion (
   if (((SectionDescriptor & TT_DESCRIPTOR_SECTION_TYPE_MASK) == TT_DESCRIPTOR_SECTION_TYPE_SECTION) ||
       ((SectionDescriptor & TT_DESCRIPTOR_SECTION_TYPE_MASK) == TT_DESCRIPTOR_SECTION_TYPE_SUPERSECTION))
   {
-    *BaseAddress = (*BaseAddress) & TT_DESCRIPTOR_SECTION_BASE_ADDRESS_MASK;
+    *BaseAddress      = (*BaseAddress) & TT_DESCRIPTOR_SECTION_BASE_ADDRESS_MASK;
     *RegionAttributes = SectionDescriptor & TT_DESCRIPTOR_SECTION_ATTRIBUTE_MASK;
   } else {
     // Otherwise, we round it to the page boundary
     *BaseAddress = (*BaseAddress) & TT_DESCRIPTOR_PAGE_BASE_ADDRESS_MASK;
 
     // Get the attribute at the page table level (Level 2)
-    PageTable = (UINT32*)(SectionDescriptor & TT_DESCRIPTOR_SECTION_PAGETABLE_ADDRESS_MASK);
+    PageTable = (UINT32 *)(SectionDescriptor & TT_DESCRIPTOR_SECTION_PAGETABLE_ADDRESS_MASK);
 
     // Calculate index into first level translation table for start of modification
     PageTableIndex = ((*BaseAddress) & TT_DESCRIPTOR_PAGE_INDEX_MASK)  >> TT_DESCRIPTOR_PAGE_BASE_SHIFT;
     ASSERT (PageTableIndex < TRANSLATION_TABLE_PAGE_COUNT);
 
-    PageAttributes = PageTable[PageTableIndex] & TT_DESCRIPTOR_PAGE_ATTRIBUTE_MASK;
+    PageAttributes    = PageTable[PageTableIndex] & TT_DESCRIPTOR_PAGE_ATTRIBUTE_MASK;
     *RegionAttributes = TT_DESCRIPTOR_CONVERT_TO_SECTION_CACHE_POLICY (PageAttributes, 0) |
                         TT_DESCRIPTOR_CONVERT_TO_SECTION_AP (PageAttributes);
   }
 
-  for (;TableIndex < TRANSLATION_TABLE_SECTION_COUNT; TableIndex++) {
+  for ( ; TableIndex < TRANSLATION_TABLE_SECTION_COUNT; TableIndex++) {
     // Get the section at the given index
     SectionDescriptor = FirstLevelTable[TableIndex];
 
     // If the entry is a level-2 page table then we scan it to find the end of the region
     if (TT_DESCRIPTOR_SECTION_TYPE_IS_PAGE_TABLE (SectionDescriptor)) {
       // Extract the page table location from the descriptor
-      PageTable = (UINT32*)(SectionDescriptor & TT_DESCRIPTOR_SECTION_PAGETABLE_ADDRESS_MASK);
+      PageTable = (UINT32 *)(SectionDescriptor & TT_DESCRIPTOR_SECTION_PAGETABLE_ADDRESS_MASK);
 
       // Scan the page table to find the end of the region.
       Status = GetMemoryRegionPage (PageTable, BaseAddress, RegionLength, RegionAttributes);
@@ -494,7 +500,8 @@ GetMemoryRegion (
         break;
       }
     } else if (((SectionDescriptor & TT_DESCRIPTOR_SECTION_TYPE_MASK) == TT_DESCRIPTOR_SECTION_TYPE_SECTION) ||
-               ((SectionDescriptor & TT_DESCRIPTOR_SECTION_TYPE_MASK) == TT_DESCRIPTOR_SECTION_TYPE_SUPERSECTION)) {
+               ((SectionDescriptor & TT_DESCRIPTOR_SECTION_TYPE_MASK) == TT_DESCRIPTOR_SECTION_TYPE_SUPERSECTION))
+    {
       if ((SectionDescriptor & TT_DESCRIPTOR_SECTION_ATTRIBUTE_MASK) != *RegionAttributes) {
         // If the attributes of the section differ from the one targeted then we exit the loop
         break;

ArmPkg/Drivers/CpuDxe/CpuDxe.c

@@ -11,7 +11,7 @@
 
 #include <Guid/IdleLoopEvent.h>
 
-BOOLEAN                   mIsFlushingGCD;
+BOOLEAN  mIsFlushingGCD;
 
 /**
   This function flushes the range of addresses from Start to Start+Length
@@ -43,13 +43,12 @@ BOOLEAN                   mIsFlushingGCD;
 EFI_STATUS
 EFIAPI
 CpuFlushCpuDataCache (
-  IN EFI_CPU_ARCH_PROTOCOL           *This,
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
-  IN EFI_PHYSICAL_ADDRESS            Start,
+  IN EFI_PHYSICAL_ADDRESS   Start,
-  IN UINT64                          Length,
+  IN UINT64                 Length,
-  IN EFI_CPU_FLUSH_TYPE              FlushType
+  IN EFI_CPU_FLUSH_TYPE     FlushType
   )
 {
-
   switch (FlushType) {
     case EfiCpuFlushTypeWriteBack:
       WriteBackDataCacheRange ((VOID *)(UINTN)Start, (UINTN)Length);
@@ -67,7 +66,6 @@ CpuFlushCpuDataCache (
   return EFI_SUCCESS;
 }
 
-
 /**
   This function enables interrupt processing by the processor.
 
@@ -80,7 +78,7 @@ CpuFlushCpuDataCache (
 EFI_STATUS
 EFIAPI
 CpuEnableInterrupt (
-  IN EFI_CPU_ARCH_PROTOCOL          *This
+  IN EFI_CPU_ARCH_PROTOCOL  *This
   )
 {
   ArmEnableInterrupts ();
@@ -88,7 +86,6 @@ CpuEnableInterrupt (
   return EFI_SUCCESS;
 }
 
-
 /**
   This function disables interrupt processing by the processor.
 
@@ -101,7 +98,7 @@ CpuEnableInterrupt (
 EFI_STATUS
 EFIAPI
 CpuDisableInterrupt (
-  IN EFI_CPU_ARCH_PROTOCOL          *This
+  IN EFI_CPU_ARCH_PROTOCOL  *This
   )
 {
   ArmDisableInterrupts ();
@@ -109,7 +106,6 @@ CpuDisableInterrupt (
   return EFI_SUCCESS;
 }
 
-
 /**
   This function retrieves the processor's current interrupt state a returns it in
   State. If interrupts are currently enabled, then TRUE is returned. If interrupts
@@ -126,19 +122,18 @@ CpuDisableInterrupt (
 EFI_STATUS
 EFIAPI
 CpuGetInterruptState (
-  IN  EFI_CPU_ARCH_PROTOCOL         *This,
+  IN  EFI_CPU_ARCH_PROTOCOL  *This,
-  OUT BOOLEAN                       *State
+  OUT BOOLEAN                *State
   )
 {
   if (State == NULL) {
     return EFI_INVALID_PARAMETER;
   }
 
-  *State = ArmGetInterruptState();
+  *State = ArmGetInterruptState ();
   return EFI_SUCCESS;
 }
 
-
 /**
   This function generates an INIT on the processor. If this function succeeds, then the
   processor will be reset, and control will not be returned to the caller. If InitType is
@@ -158,8 +153,8 @@ CpuGetInterruptState (
 EFI_STATUS
 EFIAPI
 CpuInit (
-  IN EFI_CPU_ARCH_PROTOCOL           *This,
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
-  IN EFI_CPU_INIT_TYPE               InitType
+  IN EFI_CPU_INIT_TYPE      InitType
   )
 {
   return EFI_UNSUPPORTED;
@@ -168,9 +163,9 @@ CpuInit (
 EFI_STATUS
 EFIAPI
 CpuRegisterInterruptHandler (
-  IN EFI_CPU_ARCH_PROTOCOL          *This,
+  IN EFI_CPU_ARCH_PROTOCOL      *This,
-  IN EFI_EXCEPTION_TYPE             InterruptType,
+  IN EFI_EXCEPTION_TYPE         InterruptType,
-  IN EFI_CPU_INTERRUPT_HANDLER      InterruptHandler
+  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
   )
 {
   return RegisterInterruptHandler (InterruptType, InterruptHandler);
@@ -179,10 +174,10 @@ CpuRegisterInterruptHandler (
 EFI_STATUS
 EFIAPI
 CpuGetTimerValue (
-  IN  EFI_CPU_ARCH_PROTOCOL          *This,
+  IN  EFI_CPU_ARCH_PROTOCOL  *This,
-  IN  UINT32                         TimerIndex,
+  IN  UINT32                 TimerIndex,
-  OUT UINT64                         *TimerValue,
+  OUT UINT64                 *TimerValue,
-  OUT UINT64                         *TimerPeriod   OPTIONAL
+  OUT UINT64                 *TimerPeriod   OPTIONAL
   )
 {
   return EFI_UNSUPPORTED;
@@ -199,8 +194,8 @@ CpuGetTimerValue (
 VOID
 EFIAPI
 IdleLoopEventCallback (
-  IN EFI_EVENT                Event,
+  IN EFI_EVENT  Event,
-  IN VOID                     *Context
+  IN VOID       *Context
   )
 {
   CpuSleep ();
@@ -209,8 +204,8 @@ IdleLoopEventCallback (
 //
 // Globals used to initialize the protocol
 //
-EFI_HANDLE            mCpuHandle = NULL;
+EFI_HANDLE             mCpuHandle = NULL;
-EFI_CPU_ARCH_PROTOCOL mCpu = {
+EFI_CPU_ARCH_PROTOCOL  mCpu       = {
   CpuFlushCpuDataCache,
   CpuEnableInterrupt,
   CpuDisableInterrupt,
@@ -226,7 +221,7 @@ EFI_CPU_ARCH_PROTOCOL mCpu = {
 STATIC
 VOID
 InitializeDma (
-  IN OUT  EFI_CPU_ARCH_PROTOCOL   *CpuArchProtocol
+  IN OUT  EFI_CPU_ARCH_PROTOCOL  *CpuArchProtocol
   )
 {
   CpuArchProtocol->DmaBufferAlignment = ArmCacheWritebackGranule ();
@@ -234,22 +229,23 @@ InitializeDma (
 
 EFI_STATUS
 CpuDxeInitialize (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
   EFI_STATUS  Status;
-  EFI_EVENT    IdleLoopEvent;
+  EFI_EVENT   IdleLoopEvent;
 
   InitializeExceptions (&mCpu);
 
   InitializeDma (&mCpu);
 
   Status = gBS->InstallMultipleProtocolInterfaces (
-                &mCpuHandle,
+                  &mCpuHandle,
-                &gEfiCpuArchProtocolGuid,           &mCpu,
+                  &gEfiCpuArchProtocolGuid,
-                NULL
+                  &mCpu,
-                );
+                  NULL
+                  );
 
   //
   // Make sure GCD and MMU settings match. This API calls gDS->SetMemorySpaceAttributes ()
@@ -262,8 +258,8 @@ CpuDxeInitialize (
 
   // If the platform is a MPCore system then install the Configuration Table describing the
   // secondary core states
-  if (ArmIsMpCore()) {
+  if (ArmIsMpCore ()) {
-    PublishArmProcessorTable();
+    PublishArmProcessorTable ();
   }
 
   //

ArmPkg/Drivers/CpuDxe/CpuDxe.h

@@ -7,8 +7,8 @@
 
 **/
 
-#ifndef __CPU_DXE_ARM_EXCEPTION_H__
+#ifndef CPU_DXE_H_
-#define __CPU_DXE_ARM_EXCEPTION_H__
+#define CPU_DXE_H_
 
 #include <Uefi.h>
 
@@ -31,7 +31,7 @@
 #include <Protocol/DebugSupport.h>
 #include <Protocol/LoadedImage.h>
 
-extern BOOLEAN mIsFlushingGCD;
+extern BOOLEAN  mIsFlushingGCD;
 
 /**
   This function registers and enables the handler specified by InterruptHandler for a processor
@@ -55,11 +55,10 @@ extern BOOLEAN mIsFlushingGCD;
 **/
 EFI_STATUS
 RegisterInterruptHandler (
-  IN EFI_EXCEPTION_TYPE             InterruptType,
+  IN EFI_EXCEPTION_TYPE         InterruptType,
-  IN EFI_CPU_INTERRUPT_HANDLER      InterruptHandler
+  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
   );
 
-
 /**
   This function registers and enables the handler specified by InterruptHandler for a processor
   interrupt or exception type specified by InterruptType. If InterruptHandler is NULL, then the
@@ -82,28 +81,27 @@ RegisterInterruptHandler (
 **/
 EFI_STATUS
 RegisterDebuggerInterruptHandler (
-  IN EFI_EXCEPTION_TYPE             InterruptType,
+  IN EFI_EXCEPTION_TYPE         InterruptType,
-  IN EFI_CPU_INTERRUPT_HANDLER      InterruptHandler
+  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
   );
 
-
 EFI_STATUS
 EFIAPI
 CpuSetMemoryAttributes (
-  IN EFI_CPU_ARCH_PROTOCOL     *This,
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
-  IN EFI_PHYSICAL_ADDRESS      BaseAddress,
+  IN EFI_PHYSICAL_ADDRESS   BaseAddress,
-  IN UINT64                    Length,
+  IN UINT64                 Length,
-  IN UINT64                    Attributes
+  IN UINT64                 Attributes
   );
 
 EFI_STATUS
 InitializeExceptions (
-  IN EFI_CPU_ARCH_PROTOCOL    *Cpu
+  IN EFI_CPU_ARCH_PROTOCOL  *Cpu
   );
 
 EFI_STATUS
 SyncCacheConfig (
-  IN  EFI_CPU_ARCH_PROTOCOL *CpuProtocol
+  IN  EFI_CPU_ARCH_PROTOCOL  *CpuProtocol
   );
 
 /**
@@ -117,37 +115,30 @@ SyncCacheConfig (
 **/
 VOID
 EFIAPI
-PublishArmProcessorTable(
+PublishArmProcessorTable (
   VOID
   );
 
 // The ARM Attributes might be defined on 64-bit (case of the long format description table)
 UINT64
 EfiAttributeToArmAttribute (
-  IN UINT64                    EfiAttributes
+  IN UINT64  EfiAttributes
   );
 
 EFI_STATUS
 GetMemoryRegion (
-  IN OUT UINTN                   *BaseAddress,
+  IN OUT UINTN  *BaseAddress,
-  OUT    UINTN                   *RegionLength,
+  OUT    UINTN  *RegionLength,
-  OUT    UINTN                   *RegionAttributes
+  OUT    UINTN  *RegionAttributes
-  );
-
-VOID
-GetRootTranslationTableInfo (
-  IN  UINTN    T0SZ,
-  OUT UINTN   *TableLevel,
-  OUT UINTN   *TableEntryCount
   );
 
 EFI_STATUS
 SetGcdMemorySpaceAttributes (
-  IN EFI_GCD_MEMORY_SPACE_DESCRIPTOR    *MemorySpaceMap,
+  IN EFI_GCD_MEMORY_SPACE_DESCRIPTOR  *MemorySpaceMap,
-  IN UINTN                               NumberOfDescriptors,
+  IN UINTN                            NumberOfDescriptors,
-  IN EFI_PHYSICAL_ADDRESS                BaseAddress,
+  IN EFI_PHYSICAL_ADDRESS             BaseAddress,
-  IN UINT64                              Length,
+  IN UINT64                           Length,
-  IN UINT64                              Attributes
+  IN UINT64                           Attributes
   );
 
-#endif // __CPU_DXE_ARM_EXCEPTION_H__
+#endif // CPU_DXE_H_

ArmPkg/Drivers/CpuDxe/CpuMmuCommon.c

@@ -29,33 +29,36 @@
 **/
 EFI_STATUS
 SearchGcdMemorySpaces (
-  IN EFI_GCD_MEMORY_SPACE_DESCRIPTOR    *MemorySpaceMap,
+  IN EFI_GCD_MEMORY_SPACE_DESCRIPTOR  *MemorySpaceMap,
-  IN UINTN                               NumberOfDescriptors,
+  IN UINTN                            NumberOfDescriptors,
-  IN EFI_PHYSICAL_ADDRESS                BaseAddress,
+  IN EFI_PHYSICAL_ADDRESS             BaseAddress,
-  IN UINT64                              Length,
+  IN UINT64                           Length,
-  OUT UINTN                             *StartIndex,
+  OUT UINTN                           *StartIndex,
-  OUT UINTN                             *EndIndex
+  OUT UINTN                           *EndIndex
   )
 {
-  UINTN           Index;
+  UINTN  Index;
 
   *StartIndex = 0;
   *EndIndex   = 0;
   for (Index = 0; Index < NumberOfDescriptors; Index++) {
     if ((BaseAddress >= MemorySpaceMap[Index].BaseAddress) &&
-        (BaseAddress < (MemorySpaceMap[Index].BaseAddress + MemorySpaceMap[Index].Length))) {
+        (BaseAddress < (MemorySpaceMap[Index].BaseAddress + MemorySpaceMap[Index].Length)))
+    {
       *StartIndex = Index;
     }
+
     if (((BaseAddress + Length - 1) >= MemorySpaceMap[Index].BaseAddress) &&
-        ((BaseAddress + Length - 1) < (MemorySpaceMap[Index].BaseAddress + MemorySpaceMap[Index].Length))) {
+        ((BaseAddress + Length - 1) < (MemorySpaceMap[Index].BaseAddress + MemorySpaceMap[Index].Length)))
+    {
       *EndIndex = Index;
       return EFI_SUCCESS;
     }
   }
+
   return EFI_NOT_FOUND;
 }
 
-
 /**
   Sets the attributes for a specified range in Gcd Memory Space Map.
 
@@ -74,11 +77,11 @@ SearchGcdMemorySpaces (
 **/
 EFI_STATUS
 SetGcdMemorySpaceAttributes (
-  IN EFI_GCD_MEMORY_SPACE_DESCRIPTOR    *MemorySpaceMap,
+  IN EFI_GCD_MEMORY_SPACE_DESCRIPTOR  *MemorySpaceMap,
-  IN UINTN                               NumberOfDescriptors,
+  IN UINTN                            NumberOfDescriptors,
-  IN EFI_PHYSICAL_ADDRESS                BaseAddress,
+  IN EFI_PHYSICAL_ADDRESS             BaseAddress,
-  IN UINT64                              Length,
+  IN UINT64                           Length,
-  IN UINT64                              Attributes
+  IN UINT64                           Attributes
   )
 {
   EFI_STATUS            Status;
@@ -88,14 +91,21 @@ SetGcdMemorySpaceAttributes (
   EFI_PHYSICAL_ADDRESS  RegionStart;
   UINT64                RegionLength;
 
-  DEBUG ((DEBUG_GCD, "SetGcdMemorySpaceAttributes[0x%lX; 0x%lX] = 0x%lX\n",
+  DEBUG ((
-      BaseAddress, BaseAddress + Length, Attributes));
+    DEBUG_GCD,
+    "SetGcdMemorySpaceAttributes[0x%lX; 0x%lX] = 0x%lX\n",
+    BaseAddress,
+    BaseAddress + Length,
+    Attributes
+    ));
 
   // We do not support a smaller granularity than 4KB on ARM Architecture
   if ((Length & EFI_PAGE_MASK) != 0) {
-    DEBUG ((DEBUG_WARN,
+    DEBUG ((
-            "Warning: We do not support smaller granularity than 4KB on ARM Architecture (passed length: 0x%lX).\n",
+      DEBUG_WARN,
-            Length));
+      "Warning: We do not support smaller granularity than 4KB on ARM Architecture (passed length: 0x%lX).\n",
+      Length
+      ));
   }
 
   //
@@ -120,6 +130,7 @@ SetGcdMemorySpaceAttributes (
     if (MemorySpaceMap[Index].GcdMemoryType == EfiGcdMemoryTypeNonExistent) {
       continue;
     }
+
     //
     // Calculate the start and end address of the overlapping range
     //
@@ -128,11 +139,13 @@ SetGcdMemorySpaceAttributes (
     } else {
       RegionStart = MemorySpaceMap[Index].BaseAddress;
     }
+
     if ((BaseAddress + Length - 1) < (MemorySpaceMap[Index].BaseAddress + MemorySpaceMap[Index].Length)) {
       RegionLength = BaseAddress + Length - RegionStart;
     } else {
       RegionLength = MemorySpaceMap[Index].BaseAddress + MemorySpaceMap[Index].Length - RegionStart;
     }
+
     //
     // Set memory attributes according to MTRR attribute and the original attribute of descriptor
     //
@@ -170,10 +183,10 @@ SetGcdMemorySpaceAttributes (
 EFI_STATUS
 EFIAPI
 CpuSetMemoryAttributes (
-  IN EFI_CPU_ARCH_PROTOCOL    *This,
+  IN EFI_CPU_ARCH_PROTOCOL  *This,
-  IN EFI_PHYSICAL_ADDRESS      BaseAddress,
+  IN EFI_PHYSICAL_ADDRESS   BaseAddress,
-  IN UINT64                    Length,
+  IN UINT64                 Length,
-  IN UINT64                    EfiAttributes
+  IN UINT64                 EfiAttributes
   )
 {
   EFI_STATUS  Status;
@@ -197,7 +210,7 @@ CpuSetMemoryAttributes (
 
   // Get the region starting from 'BaseAddress' and its 'Attribute'
   RegionBaseAddress = BaseAddress;
-  Status = GetMemoryRegion (&RegionBaseAddress, &RegionLength, &RegionArmAttributes);
+  Status            = GetMemoryRegion (&RegionBaseAddress, &RegionLength, &RegionArmAttributes);
 
   // Data & Instruction Caches are flushed when we set new memory attributes.
   // So, we only set the attributes if the new region is different.

ArmPkg/Drivers/CpuDxe/CpuMpCore.c

@@ -1,6 +1,6 @@
 /** @file
 *
-*  Copyright (c) 2011-2014, ARM Limited. All rights reserved.
+*  Copyright (c) 2011-2021, Arm Limited. All rights reserved.<BR>
 *
 *  SPDX-License-Identifier: BSD-2-Clause-Patent
 *
@@ -14,7 +14,7 @@
 
 #include <Guid/ArmMpCoreInfo.h>
 
-ARM_PROCESSOR_TABLE mArmProcessorTableTemplate = {
+ARM_PROCESSOR_TABLE  mArmProcessorTableTemplate = {
   {
     EFI_ARM_PROCESSOR_TABLE_SIGNATURE,
     0,
@@ -26,13 +26,13 @@ ARM_PROCESSOR_TABLE mArmProcessorTableTemplate = {
     EFI_ARM_PROCESSOR_TABLE_CREATOR_REVISION,
     { 0 },
     0
-  },   //ARM Processor table header
+  },   // ARM Processor table header
   0,   // Number of entries in ARM processor Table
   NULL // ARM Processor Table
 };
 
 /** Publish ARM Processor Data table in UEFI SYSTEM Table.
- * @param:  HobStart               Pointer to the beginning of the HOB List from PEI.
+ * @param  HobStart               Pointer to the beginning of the HOB List from PEI.
  *
  * Description : This function iterates through HOB list and finds ARM processor Table Entry HOB.
  *               If  the ARM processor Table Entry HOB is found, the HOB data is copied to run-time memory
@@ -45,47 +45,48 @@ PublishArmProcessorTable (
   VOID
   )
 {
-  EFI_PEI_HOB_POINTERS    Hob;
+  EFI_PEI_HOB_POINTERS  Hob;
 
   Hob.Raw = GetHobList ();
 
   // Iterate through the HOBs and find if there is ARM PROCESSOR ENTRY HOB
-  for (; !END_OF_HOB_LIST(Hob); Hob.Raw = GET_NEXT_HOB(Hob)) {
+  for ( ; !END_OF_HOB_LIST (Hob); Hob.Raw = GET_NEXT_HOB (Hob)) {
     // Check for Correct HOB type
     if ((GET_HOB_TYPE (Hob)) == EFI_HOB_TYPE_GUID_EXTENSION) {
       // Check for correct GUID type
-      if (CompareGuid(&(Hob.Guid->Name), &gArmMpCoreInfoGuid)) {
+      if (CompareGuid (&(Hob.Guid->Name), &gArmMpCoreInfoGuid)) {
-        ARM_PROCESSOR_TABLE     *ArmProcessorTable;
+        ARM_PROCESSOR_TABLE  *ArmProcessorTable;
-        EFI_STATUS              Status;
+        EFI_STATUS           Status;
 
         // Allocate Runtime memory for ARM processor table
-        ArmProcessorTable = (ARM_PROCESSOR_TABLE*)AllocateRuntimePool(sizeof(ARM_PROCESSOR_TABLE));
+        ArmProcessorTable = (ARM_PROCESSOR_TABLE *)AllocateRuntimePool (sizeof (ARM_PROCESSOR_TABLE));
 
         // Check if the memory allocation is successful or not
-        ASSERT(NULL != ArmProcessorTable);
+        ASSERT (NULL != ArmProcessorTable);
 
         // Set ARM processor table to default values
-        CopyMem(ArmProcessorTable,&mArmProcessorTableTemplate,sizeof(ARM_PROCESSOR_TABLE));
+        CopyMem (ArmProcessorTable, &mArmProcessorTableTemplate, sizeof (ARM_PROCESSOR_TABLE));
 
         // Fill in Length fields of ARM processor table
-        ArmProcessorTable->Header.Length = sizeof(ARM_PROCESSOR_TABLE);
+        ArmProcessorTable->Header.Length  = sizeof (ARM_PROCESSOR_TABLE);
-        ArmProcessorTable->Header.DataLen = GET_GUID_HOB_DATA_SIZE(Hob);
+        ArmProcessorTable->Header.DataLen = GET_GUID_HOB_DATA_SIZE (Hob);
 
         // Fill in Identifier(ARM processor table GUID)
         ArmProcessorTable->Header.Identifier = gArmMpCoreInfoGuid;
 
         // Set Number of ARM core entries in the Table
-        ArmProcessorTable->NumberOfEntries = GET_GUID_HOB_DATA_SIZE(Hob)/sizeof(ARM_CORE_INFO);
+        ArmProcessorTable->NumberOfEntries = GET_GUID_HOB_DATA_SIZE (Hob)/sizeof (ARM_CORE_INFO);
 
         // Allocate runtime memory for ARM processor Table entries
-        ArmProcessorTable->ArmCpus = (ARM_CORE_INFO*)AllocateRuntimePool (
+        ArmProcessorTable->ArmCpus = (ARM_CORE_INFO *)AllocateRuntimePool (
-           ArmProcessorTable->NumberOfEntries * sizeof(ARM_CORE_INFO));
+                                                        ArmProcessorTable->NumberOfEntries * sizeof (ARM_CORE_INFO)
+                                                        );
 
         // Check if the memory allocation is successful or not
-        ASSERT(NULL != ArmProcessorTable->ArmCpus);
+        ASSERT (NULL != ArmProcessorTable->ArmCpus);
 
         // Copy ARM Processor Table data from HOB list to newly allocated memory
-        CopyMem(ArmProcessorTable->ArmCpus,GET_GUID_HOB_DATA(Hob), ArmProcessorTable->Header.DataLen);
+        CopyMem (ArmProcessorTable->ArmCpus, GET_GUID_HOB_DATA (Hob), ArmProcessorTable->Header.DataLen);
 
         // Install the ARM Processor table into EFI system configuration table
         Status = gBS->InstallConfigurationTable (&gArmMpCoreInfoGuid, ArmProcessorTable);

ArmPkg/Drivers/CpuDxe/Exception.c

@@ -1,7 +1,7 @@
 /** @file
 
   Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  Portions Copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.<BR>
+  Portions Copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
@@ -13,22 +13,23 @@
 
 EFI_STATUS
 InitializeExceptions (
-  IN EFI_CPU_ARCH_PROTOCOL    *Cpu
+  IN EFI_CPU_ARCH_PROTOCOL  *Cpu
-  ) {
+  )
-  EFI_STATUS                      Status;
+{
-  EFI_VECTOR_HANDOFF_INFO         *VectorInfoList;
+  EFI_STATUS               Status;
-  EFI_VECTOR_HANDOFF_INFO         *VectorInfo;
+  EFI_VECTOR_HANDOFF_INFO  *VectorInfoList;
-  BOOLEAN                         IrqEnabled;
+  EFI_VECTOR_HANDOFF_INFO  *VectorInfo;
-  BOOLEAN                         FiqEnabled;
+  BOOLEAN                  IrqEnabled;
+  BOOLEAN                  FiqEnabled;
 
   VectorInfo = (EFI_VECTOR_HANDOFF_INFO *)NULL;
-  Status = EfiGetSystemConfigurationTable(&gEfiVectorHandoffTableGuid, (VOID **)&VectorInfoList);
+  Status     = EfiGetSystemConfigurationTable (&gEfiVectorHandoffTableGuid, (VOID **)&VectorInfoList);
-  if (Status == EFI_SUCCESS && VectorInfoList != NULL) {
+  if ((Status == EFI_SUCCESS) && (VectorInfoList != NULL)) {
     VectorInfo = VectorInfoList;
   }
 
   // initialize the CpuExceptionHandlerLib so we take over the exception vector table from the DXE Core
-  InitializeCpuExceptionHandlers(VectorInfo);
+  InitializeCpuExceptionHandlers (VectorInfo);
 
   Status = EFI_SUCCESS;
 
@@ -63,7 +64,7 @@ InitializeExceptions (
   //
   DEBUG_CODE (
     ArmEnableAsynchronousAbort ();
-  );
+    );
 
   return Status;
 }
@@ -89,10 +90,11 @@ previously installed.
 
 **/
 EFI_STATUS
-RegisterInterruptHandler(
+RegisterInterruptHandler (
-  IN EFI_EXCEPTION_TYPE             InterruptType,
+  IN EFI_EXCEPTION_TYPE         InterruptType,
-  IN EFI_CPU_INTERRUPT_HANDLER      InterruptHandler
+  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
-  ) {
+  )
+{
   // pass down to CpuExceptionHandlerLib
-  return (EFI_STATUS)RegisterCpuInterruptHandler(InterruptType, InterruptHandler);
+  return (EFI_STATUS)RegisterCpuInterruptHandler (InterruptType, InterruptHandler);
 }

ArmPkg/Drivers/CpuPei/CpuPei.c

@@ -16,8 +16,6 @@ Abstract:
 
 **/
 
-
-
 //
 // The package level header files this module uses
 //
@@ -58,10 +56,10 @@ InitializeCpuPeim (
   IN CONST EFI_PEI_SERVICES     **PeiServices
   )
 {
-  EFI_STATUS              Status;
+  EFI_STATUS            Status;
-  ARM_MP_CORE_INFO_PPI    *ArmMpCoreInfoPpi;
+  ARM_MP_CORE_INFO_PPI  *ArmMpCoreInfoPpi;
-  UINTN                   ArmCoreCount;
+  UINTN                 ArmCoreCount;
-  ARM_CORE_INFO           *ArmCoreInfoTable;
+  ARM_CORE_INFO         *ArmCoreInfoTable;
 
   // Enable program flow prediction, if supported.
   ArmEnableBranchPrediction ();
@@ -70,12 +68,12 @@ InitializeCpuPeim (
   BuildCpuHob (ArmGetPhysicalAddressBits (), PcdGet8 (PcdPrePiCpuIoSize));
 
   // Only MP Core platform need to produce gArmMpCoreInfoPpiGuid
-  Status = PeiServicesLocatePpi (&gArmMpCoreInfoPpiGuid, 0, NULL, (VOID**)&ArmMpCoreInfoPpi);
+  Status = PeiServicesLocatePpi (&gArmMpCoreInfoPpiGuid, 0, NULL, (VOID **)&ArmMpCoreInfoPpi);
-  if (!EFI_ERROR(Status)) {
+  if (!EFI_ERROR (Status)) {
     // Build the MP Core Info Table
     ArmCoreCount = 0;
-    Status = ArmMpCoreInfoPpi->GetMpCoreInfo (&ArmCoreCount, &ArmCoreInfoTable);
+    Status       = ArmMpCoreInfoPpi->GetMpCoreInfo (&ArmCoreCount, &ArmCoreInfoTable);
-    if (!EFI_ERROR(Status) && (ArmCoreCount > 0)) {
+    if (!EFI_ERROR (Status) && (ArmCoreCount > 0)) {
       // Build MPCore Info HOB
       BuildGuidDataHob (&gArmMpCoreInfoGuid, ArmCoreInfoTable, sizeof (ARM_CORE_INFO) * ArmCoreCount);
     }

ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdog.h

@@ -5,20 +5,21 @@
 *  SPDX-License-Identifier: BSD-2-Clause-Patent
 *
 **/
-#ifndef __GENERIC_WATCHDOG_H__
+
-#define __GENERIC_WATCHDOG_H__
+#ifndef GENERIC_WATCHDOG_H_
+#define GENERIC_WATCHDOG_H_
 
 // Refresh Frame:
-#define GENERIC_WDOG_REFRESH_REG              ((UINTN)FixedPcdGet64 (PcdGenericWatchdogRefreshBase) + 0x000)
+#define GENERIC_WDOG_REFRESH_REG  ((UINTN)FixedPcdGet64 (PcdGenericWatchdogRefreshBase) + 0x000)
 
 // Control Frame:
-#define GENERIC_WDOG_CONTROL_STATUS_REG       ((UINTN)FixedPcdGet64 (PcdGenericWatchdogControlBase) + 0x000)
+#define GENERIC_WDOG_CONTROL_STATUS_REG      ((UINTN)FixedPcdGet64 (PcdGenericWatchdogControlBase) + 0x000)
-#define GENERIC_WDOG_OFFSET_REG               ((UINTN)FixedPcdGet64 (PcdGenericWatchdogControlBase) + 0x008)
+#define GENERIC_WDOG_OFFSET_REG              ((UINTN)FixedPcdGet64 (PcdGenericWatchdogControlBase) + 0x008)
-#define GENERIC_WDOG_COMPARE_VALUE_REG_LOW    ((UINTN)FixedPcdGet64 (PcdGenericWatchdogControlBase) + 0x010)
+#define GENERIC_WDOG_COMPARE_VALUE_REG_LOW   ((UINTN)FixedPcdGet64 (PcdGenericWatchdogControlBase) + 0x010)
-#define GENERIC_WDOG_COMPARE_VALUE_REG_HIGH   ((UINTN)FixedPcdGet64 (PcdGenericWatchdogControlBase) + 0x014)
+#define GENERIC_WDOG_COMPARE_VALUE_REG_HIGH  ((UINTN)FixedPcdGet64 (PcdGenericWatchdogControlBase) + 0x014)
 
 // Values of bit 0 of the Control/Status Register
-#define GENERIC_WDOG_ENABLED          1
+#define GENERIC_WDOG_ENABLED   1
-#define GENERIC_WDOG_DISABLED         0
+#define GENERIC_WDOG_DISABLED  0
 
-#endif  // __GENERIC_WATCHDOG_H__
+#endif // GENERIC_WATCHDOG_H_

ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.c

@@ -25,18 +25,18 @@
 
 /* The number of 100ns periods (the unit of time passed to these functions)
    in a second */
-#define TIME_UNITS_PER_SECOND 10000000
+#define TIME_UNITS_PER_SECOND  10000000
 
 // Tick frequency of the generic timer basis of the generic watchdog.
-STATIC UINTN mTimerFrequencyHz = 0;
+STATIC UINTN  mTimerFrequencyHz = 0;
 
 /* In cases where the compare register was set manually, information about
    how long the watchdog was asked to wait cannot be retrieved from hardware.
    It is therefore stored here. 0 means the timer is not running. */
-STATIC UINT64 mNumTimerTicks = 0;
+STATIC UINT64  mNumTimerTicks = 0;
 
-STATIC EFI_HARDWARE_INTERRUPT2_PROTOCOL *mInterruptProtocol;
+STATIC EFI_HARDWARE_INTERRUPT2_PROTOCOL  *mInterruptProtocol;
-STATIC EFI_WATCHDOG_TIMER_NOTIFY        mWatchdogNotify;
+STATIC EFI_WATCHDOG_TIMER_NOTIFY         mWatchdogNotify;
 
 STATIC
 VOID
@@ -97,12 +97,12 @@ STATIC
 VOID
 EFIAPI
 WatchdogInterruptHandler (
-  IN  HARDWARE_INTERRUPT_SOURCE   Source,
+  IN  HARDWARE_INTERRUPT_SOURCE  Source,
-  IN  EFI_SYSTEM_CONTEXT          SystemContext
+  IN  EFI_SYSTEM_CONTEXT         SystemContext
   )
 {
-  STATIC CONST CHAR16 ResetString[]= L"The generic watchdog timer ran out.";
+  STATIC CONST CHAR16  ResetString[] = L"The generic watchdog timer ran out.";
-  UINT64              TimerPeriod;
+  UINT64               TimerPeriod;
 
   WatchdogDisable ();
 
@@ -119,8 +119,12 @@ WatchdogInterruptHandler (
     mWatchdogNotify (TimerPeriod + 1);
   }
 
-  gRT->ResetSystem (EfiResetCold, EFI_TIMEOUT, StrSize (ResetString),
+  gRT->ResetSystem (
-         (CHAR16 *)ResetString);
+         EfiResetCold,
+         EFI_TIMEOUT,
+         StrSize (ResetString),
+         (CHAR16 *)ResetString
+         );
 
   // If we got here then the reset didn't work
   ASSERT (FALSE);
@@ -154,15 +158,15 @@ STATIC
 EFI_STATUS
 EFIAPI
 WatchdogRegisterHandler (
-  IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL         *This,
+  IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL  *This,
-  IN EFI_WATCHDOG_TIMER_NOTIFY                NotifyFunction
+  IN EFI_WATCHDOG_TIMER_NOTIFY         NotifyFunction
   )
 {
-  if (mWatchdogNotify == NULL && NotifyFunction == NULL) {
+  if ((mWatchdogNotify == NULL) && (NotifyFunction == NULL)) {
     return EFI_INVALID_PARAMETER;
   }
 
-  if (mWatchdogNotify != NULL && NotifyFunction != NULL) {
+  if ((mWatchdogNotify != NULL) && (NotifyFunction != NULL)) {
     return EFI_ALREADY_STARTED;
   }
 
@@ -188,11 +192,11 @@ STATIC
 EFI_STATUS
 EFIAPI
 WatchdogSetTimerPeriod (
-  IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL         *This,
+  IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL  *This,
-  IN UINT64                                   TimerPeriod   // In 100ns units
+  IN UINT64                            TimerPeriod          // In 100ns units
   )
 {
-  UINTN       SystemCount;
+  UINTN  SystemCount;
 
   // if TimerPeriod is 0, this is a request to stop the watchdog.
   if (TimerPeriod == 0) {
@@ -244,8 +248,8 @@ STATIC
 EFI_STATUS
 EFIAPI
 WatchdogGetTimerPeriod (
-  IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL         *This,
+  IN EFI_WATCHDOG_TIMER_ARCH_PROTOCOL  *This,
-  OUT UINT64                                  *TimerPeriod
+  OUT UINT64                           *TimerPeriod
   )
 {
   if (TimerPeriod == NULL) {
@@ -289,26 +293,29 @@ WatchdogGetTimerPeriod (
   Retrieves the period of the timer interrupt in 100ns units.
 
 **/
-STATIC EFI_WATCHDOG_TIMER_ARCH_PROTOCOL mWatchdogTimer = {
+STATIC EFI_WATCHDOG_TIMER_ARCH_PROTOCOL  mWatchdogTimer = {
   WatchdogRegisterHandler,
   WatchdogSetTimerPeriod,
   WatchdogGetTimerPeriod
 };
 
-STATIC EFI_EVENT mEfiExitBootServicesEvent;
+STATIC EFI_EVENT  mEfiExitBootServicesEvent;
 
 EFI_STATUS
 EFIAPI
 GenericWatchdogEntry (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
-  EFI_STATUS                      Status;
+  EFI_STATUS  Status;
-  EFI_HANDLE                      Handle;
+  EFI_HANDLE  Handle;
 
-  Status = gBS->LocateProtocol (&gHardwareInterrupt2ProtocolGuid, NULL,
+  Status = gBS->LocateProtocol (
-                  (VOID **)&mInterruptProtocol);
+                  &gHardwareInterrupt2ProtocolGuid,
+                  NULL,
+                  (VOID **)&mInterruptProtocol
+                  );
   ASSERT_EFI_ERROR (Status);
 
   /* Make sure the Watchdog Timer Architectural Protocol has not been installed
@@ -320,33 +327,44 @@ GenericWatchdogEntry (
   ASSERT (mTimerFrequencyHz != 0);
 
   // Install interrupt handler
-  Status = mInterruptProtocol->RegisterInterruptSource (mInterruptProtocol,
+  Status = mInterruptProtocol->RegisterInterruptSource (
+                                 mInterruptProtocol,
                                  FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),
-                                 WatchdogInterruptHandler);
+                                 WatchdogInterruptHandler
+                                 );
   if (EFI_ERROR (Status)) {
     return Status;
   }
 
-  Status = mInterruptProtocol->SetTriggerType (mInterruptProtocol,
+  Status = mInterruptProtocol->SetTriggerType (
+                                 mInterruptProtocol,
                                  FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),
-                                 EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING);
+                                 EFI_HARDWARE_INTERRUPT2_TRIGGER_EDGE_RISING
+                                 );
   if (EFI_ERROR (Status)) {
     goto UnregisterHandler;
   }
 
   // Install the Timer Architectural Protocol onto a new handle
   Handle = NULL;
-  Status = gBS->InstallMultipleProtocolInterfaces (&Handle,
+  Status = gBS->InstallMultipleProtocolInterfaces (
-                  &gEfiWatchdogTimerArchProtocolGuid, &mWatchdogTimer,
+                  &Handle,
-                  NULL);
+                  &gEfiWatchdogTimerArchProtocolGuid,
+                  &mWatchdogTimer,
+                  NULL
+                  );
   if (EFI_ERROR (Status)) {
     goto UnregisterHandler;
   }
 
   // Register for an ExitBootServicesEvent
-  Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_NOTIFY,
+  Status = gBS->CreateEvent (
-                  WatchdogExitBootServicesEvent, NULL,
+                  EVT_SIGNAL_EXIT_BOOT_SERVICES,
-                  &mEfiExitBootServicesEvent);
+                  TPL_NOTIFY,
+                  WatchdogExitBootServicesEvent,
+                  NULL,
+                  &mEfiExitBootServicesEvent
+                  );
   ASSERT_EFI_ERROR (Status);
 
   mNumTimerTicks = 0;
@@ -356,8 +374,10 @@ GenericWatchdogEntry (
 
 UnregisterHandler:
   // Unregister the handler
-  mInterruptProtocol->RegisterInterruptSource (mInterruptProtocol,
+  mInterruptProtocol->RegisterInterruptSource (
+                        mInterruptProtocol,
                         FixedPcdGet32 (PcdGenericWatchdogEl2IntrNum),
-                        NULL);
+                        NULL
+                        );
   return Status;
 }

ArmPkg/Drivers/GenericWatchdogDxe/GenericWatchdogDxe.inf

@@ -1,5 +1,5 @@
 #
-#  Copyright (c) 2013-2017, ARM Limited. All rights reserved.
+#  Copyright (c) 2013-2021, Arm Limited. All rights reserved.<BR>
 #
 #  SPDX-License-Identifier: BSD-2-Clause-Patent
 #
@@ -13,6 +13,7 @@
   ENTRY_POINT                    = GenericWatchdogEntry
 
 [Sources.common]
+  GenericWatchdog.h
   GenericWatchdogDxe.c
 
 [Packages]

ArmPkg/Drivers/MmCommunicationDxe/MmCommunicate.h

@@ -1,22 +1,22 @@
 /** @file
 
-  Copyright (c) 2016-2018, ARM Limited. All rights reserved.
+  Copyright (c) 2016-2021, Arm Limited. All rights reserved.<BR>
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
 **/
 
-#if !defined _MM_COMMUNICATE_H_
+#ifndef MM_COMMUNICATE_H_
-#define _MM_COMMUNICATE_H_
+#define MM_COMMUNICATE_H_
 
-#define MM_MAJOR_VER_MASK        0xEFFF0000
+#define MM_MAJOR_VER_MASK   0xEFFF0000
-#define MM_MINOR_VER_MASK        0x0000FFFF
+#define MM_MINOR_VER_MASK   0x0000FFFF
-#define MM_MAJOR_VER_SHIFT       16
+#define MM_MAJOR_VER_SHIFT  16
 
-#define MM_MAJOR_VER(x) (((x) & MM_MAJOR_VER_MASK) >> MM_MAJOR_VER_SHIFT)
+#define MM_MAJOR_VER(x)  (((x) & MM_MAJOR_VER_MASK) >> MM_MAJOR_VER_SHIFT)
-#define MM_MINOR_VER(x) ((x) & MM_MINOR_VER_MASK)
+#define MM_MINOR_VER(x)  ((x) & MM_MINOR_VER_MASK)
 
-#define MM_CALLER_MAJOR_VER      0x1UL
+#define MM_CALLER_MAJOR_VER  0x1UL
-#define MM_CALLER_MINOR_VER      0x0
+#define MM_CALLER_MINOR_VER  0x0
 
-#endif /* _MM_COMMUNICATE_H_ */
+#endif /* MM_COMMUNICATE_H_ */

ArmPkg/Drivers/MmCommunicationDxe/MmCommunication.c

@@ -1,6 +1,6 @@
 /** @file
 
-  Copyright (c) 2016-2018, ARM Limited. All rights reserved.
+  Copyright (c) 2016-2021, Arm Limited. All rights reserved.<BR>
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
@@ -16,7 +16,7 @@
 #include <Library/UefiBootServicesTableLib.h>
 #include <Library/UefiRuntimeServicesTableLib.h>
 
-#include <Protocol/MmCommunication.h>
+#include <Protocol/MmCommunication2.h>
 
 #include <IndustryStandard/ArmStdSmc.h>
 
@@ -39,47 +39,48 @@ STATIC EFI_HANDLE  mMmCommunicateHandle;
 /**
   Communicates with a registered handler.
 
-  This function provides an interface to send and receive messages to the
+  This function provides a service to send and receive messages from a registered UEFI service.
-  Standalone MM environment on behalf of UEFI services.  This function is part
-  of the MM Communication Protocol that may be called in physical mode prior to
-  SetVirtualAddressMap() and in virtual mode after SetVirtualAddressMap().
 
-  @param[in]      This                The EFI_MM_COMMUNICATION_PROTOCOL
+  @param[in] This                     The EFI_MM_COMMUNICATION_PROTOCOL instance.
-                                      instance.
+  @param[in, out] CommBufferPhysical  Physical address of the MM communication buffer
-  @param[in, out] CommBuffer          A pointer to the buffer to convey
+  @param[in, out] CommBufferVirtual   Virtual address of the MM communication buffer
-                                      into MMRAM.
+  @param[in, out] CommSize            The size of the data buffer being passed in. On input,
-  @param[in, out] CommSize            The size of the data buffer being
+                                      when not omitted, the buffer should cover EFI_MM_COMMUNICATE_HEADER
-                                      passed in. This is optional.
+                                      and the value of MessageLength field. On exit, the size
+                                      of data being returned. Zero if the handler does not
+                                      wish to reply with any data. This parameter is optional
+                                      and may be NULL.
+
+  @retval EFI_SUCCESS            The message was successfully posted.
+  @retval EFI_INVALID_PARAMETER  CommBufferPhysical or CommBufferVirtual was NULL, or
+                                 integer value pointed by CommSize does not cover
+                                 EFI_MM_COMMUNICATE_HEADER and the value of MessageLength
+                                 field.
+  @retval EFI_BAD_BUFFER_SIZE    The buffer is too large for the MM implementation.
+                                 If this error is returned, the MessageLength field
+                                 in the CommBuffer header or the integer pointed by
+                                 CommSize, are updated to reflect the maximum payload
+                                 size the implementation can accommodate.
+  @retval EFI_ACCESS_DENIED      The CommunicateBuffer parameter or CommSize parameter,
+                                 if not omitted, are in address range that cannot be
+                                 accessed by the MM environment.
 
-  @retval EFI_SUCCESS                 The message was successfully posted.
-  @retval EFI_INVALID_PARAMETER       The CommBuffer was NULL.
-  @retval EFI_BAD_BUFFER_SIZE         The buffer size is incorrect for the MM
-                                      implementation. If this error is
-                                      returned, the MessageLength field in
-                                      the CommBuffer header or the integer
-                                      pointed by CommSize are updated to reflect
-                                      the maximum payload size the
-                                      implementation can accommodate.
-  @retval EFI_ACCESS_DENIED           The CommunicateBuffer parameter
-                                      or CommSize parameter, if not omitted,
-                                      are in address range that cannot be
-                                      accessed by the MM environment
 **/
-STATIC
 EFI_STATUS
 EFIAPI
-MmCommunicationCommunicate (
+MmCommunication2Communicate (
-  IN CONST EFI_MM_COMMUNICATION_PROTOCOL  *This,
+  IN CONST EFI_MM_COMMUNICATION2_PROTOCOL  *This,
-  IN OUT VOID                             *CommBuffer,
+  IN OUT VOID                              *CommBufferPhysical,
-  IN OUT UINTN                            *CommSize OPTIONAL
+  IN OUT VOID                              *CommBufferVirtual,
+  IN OUT UINTN                             *CommSize OPTIONAL
   )
 {
-  EFI_MM_COMMUNICATE_HEADER   *CommunicateHeader;
+  EFI_MM_COMMUNICATE_HEADER  *CommunicateHeader;
-  ARM_SMC_ARGS                CommunicateSmcArgs;
+  ARM_SMC_ARGS               CommunicateSmcArgs;
-  EFI_STATUS                  Status;
+  EFI_STATUS                 Status;
-  UINTN                       BufferSize;
+  UINTN                      BufferSize;
 
-  Status = EFI_ACCESS_DENIED;
+  Status     = EFI_ACCESS_DENIED;
   BufferSize = 0;
 
   ZeroMem (&CommunicateSmcArgs, sizeof (ARM_SMC_ARGS));
@@ -87,11 +88,12 @@ MmCommunicationCommunicate (
   //
   // Check parameters
   //
-  if (CommBuffer == NULL) {
+  if ((CommBufferVirtual == NULL) || (CommBufferPhysical == NULL)) {
     return EFI_INVALID_PARAMETER;
   }
 
-  CommunicateHeader = CommBuffer;
+  Status            = EFI_SUCCESS;
+  CommunicateHeader = CommBufferVirtual;
   // CommBuffer is a mandatory parameter. Hence, Rely on
   // MessageLength + Header to ascertain the
   // total size of the communication payload rather than
@@ -100,33 +102,41 @@ MmCommunicationCommunicate (
                sizeof (CommunicateHeader->HeaderGuid) +
                sizeof (CommunicateHeader->MessageLength);
 
-  // If the length of the CommBuffer is 0 then return the expected length.
+  // If CommSize is not omitted, perform size inspection before proceeding.
-  if (CommSize) {
+  if (CommSize != NULL) {
     // This case can be used by the consumer of this driver to find out the
     // max size that can be used for allocating CommBuffer.
     if ((*CommSize == 0) ||
-        (*CommSize > mNsCommBuffMemRegion.Length)) {
+        (*CommSize > mNsCommBuffMemRegion.Length))
+    {
       *CommSize = mNsCommBuffMemRegion.Length;
-      return EFI_BAD_BUFFER_SIZE;
+      Status    = EFI_BAD_BUFFER_SIZE;
     }
+
     //
-    // CommSize must match MessageLength + sizeof (EFI_MM_COMMUNICATE_HEADER);
+    // CommSize should cover at least MessageLength + sizeof (EFI_MM_COMMUNICATE_HEADER);
     //
-    if (*CommSize != BufferSize) {
+    if (*CommSize < BufferSize) {
-        return EFI_INVALID_PARAMETER;
+      Status = EFI_INVALID_PARAMETER;
     }
   }
 
   //
-  // If the buffer size is 0 or greater than what can be tolerated by the MM
+  // If the message length is 0 or greater than what can be tolerated by the MM
   // environment then return the expected size.
   //
-  if ((BufferSize == 0) ||
+  if ((CommunicateHeader->MessageLength == 0) ||
-      (BufferSize > mNsCommBuffMemRegion.Length)) {
+      (BufferSize > mNsCommBuffMemRegion.Length))
+  {
     CommunicateHeader->MessageLength = mNsCommBuffMemRegion.Length -
                                        sizeof (CommunicateHeader->HeaderGuid) -
                                        sizeof (CommunicateHeader->MessageLength);
-    return EFI_BAD_BUFFER_SIZE;
+    Status = EFI_BAD_BUFFER_SIZE;
+  }
+
+  // MessageLength or CommSize check has failed, return here.
+  if (EFI_ERROR (Status)) {
+    return Status;
   }
 
   // SMC Function ID
@@ -136,7 +146,7 @@ MmCommunicationCommunicate (
   CommunicateSmcArgs.Arg1 = 0;
 
   // Copy Communication Payload
-  CopyMem ((VOID *)mNsCommBuffMemRegion.VirtualBase, CommBuffer, BufferSize);
+  CopyMem ((VOID *)mNsCommBuffMemRegion.VirtualBase, CommBufferVirtual, BufferSize);
 
   // comm_buffer_address (64-bit physical address)
   CommunicateSmcArgs.Arg2 = (UINTN)mNsCommBuffMemRegion.PhysicalBase;
@@ -148,41 +158,41 @@ MmCommunicationCommunicate (
   ArmCallSmc (&CommunicateSmcArgs);
 
   switch (CommunicateSmcArgs.Arg0) {
-  case ARM_SMC_MM_RET_SUCCESS:
+    case ARM_SMC_MM_RET_SUCCESS:
-    ZeroMem (CommBuffer, BufferSize);
+      ZeroMem (CommBufferVirtual, BufferSize);
-    // On successful return, the size of data being returned is inferred from
+      // On successful return, the size of data being returned is inferred from
-    // MessageLength + Header.
+      // MessageLength + Header.
-    CommunicateHeader = (EFI_MM_COMMUNICATE_HEADER *)mNsCommBuffMemRegion.VirtualBase;
+      CommunicateHeader = (EFI_MM_COMMUNICATE_HEADER *)mNsCommBuffMemRegion.VirtualBase;
-    BufferSize = CommunicateHeader->MessageLength +
+      BufferSize        = CommunicateHeader->MessageLength +
-                 sizeof (CommunicateHeader->HeaderGuid) +
+                          sizeof (CommunicateHeader->HeaderGuid) +
-                 sizeof (CommunicateHeader->MessageLength);
+                          sizeof (CommunicateHeader->MessageLength);
 
-    CopyMem (
+      CopyMem (
-      CommBuffer,
+        CommBufferVirtual,
-      (VOID *)mNsCommBuffMemRegion.VirtualBase,
+        (VOID *)mNsCommBuffMemRegion.VirtualBase,
-      BufferSize
+        BufferSize
-      );
+        );
-    Status = EFI_SUCCESS;
+      Status = EFI_SUCCESS;
-    break;
+      break;
 
-  case ARM_SMC_MM_RET_INVALID_PARAMS:
+    case ARM_SMC_MM_RET_INVALID_PARAMS:
-    Status = EFI_INVALID_PARAMETER;
+      Status = EFI_INVALID_PARAMETER;
-    break;
+      break;
 
-  case ARM_SMC_MM_RET_DENIED:
+    case ARM_SMC_MM_RET_DENIED:
-    Status = EFI_ACCESS_DENIED;
+      Status = EFI_ACCESS_DENIED;
-    break;
+      break;
 
-  case ARM_SMC_MM_RET_NO_MEMORY:
+    case ARM_SMC_MM_RET_NO_MEMORY:
-    // Unexpected error since the CommSize was checked for zero length
+      // Unexpected error since the CommSize was checked for zero length
-    // prior to issuing the SMC
+      // prior to issuing the SMC
-    Status = EFI_OUT_OF_RESOURCES;
+      Status = EFI_OUT_OF_RESOURCES;
-    ASSERT (0);
+      ASSERT (0);
-    break;
+      break;
 
-  default:
+    default:
-    Status = EFI_ACCESS_DENIED;
+      Status = EFI_ACCESS_DENIED;
-    ASSERT (0);
+      ASSERT (0);
   }
 
   return Status;
@@ -191,8 +201,8 @@ MmCommunicationCommunicate (
 //
 // MM Communication Protocol instance
 //
-EFI_MM_COMMUNICATION_PROTOCOL  mMmCommunication = {
+STATIC EFI_MM_COMMUNICATION2_PROTOCOL  mMmCommunication2 = {
-  MmCommunicationCommunicate
+  MmCommunication2Communicate
 };
 
 /**
@@ -214,7 +224,7 @@ VOID
 EFIAPI
 NotifySetVirtualAddressMap (
   IN EFI_EVENT  Event,
-  IN VOID      *Context
+  IN VOID       *Context
   )
 {
   EFI_STATUS  Status;
@@ -224,19 +234,23 @@ NotifySetVirtualAddressMap (
                   (VOID **)&mNsCommBuffMemRegion.VirtualBase
                   );
   if (EFI_ERROR (Status)) {
-    DEBUG ((DEBUG_ERROR, "NotifySetVirtualAddressMap():"
+    DEBUG ((
-            " Unable to convert MM runtime pointer. Status:0x%r\n", Status));
+      DEBUG_ERROR,
+      "NotifySetVirtualAddressMap():"
+      " Unable to convert MM runtime pointer. Status:0x%r\n",
+      Status
+      ));
   }
-
 }
 
 STATIC
 EFI_STATUS
-GetMmCompatibility ()
+GetMmCompatibility (
+  )
 {
-  EFI_STATUS   Status;
+  EFI_STATUS    Status;
-  UINT32       MmVersion;
+  UINT32        MmVersion;
-  ARM_SMC_ARGS MmVersionArgs;
+  ARM_SMC_ARGS  MmVersionArgs;
 
   // MM_VERSION uses SMC32 calling conventions
   MmVersionArgs.Arg0 = ARM_SMC_ID_MM_VERSION_AARCH32;
@@ -245,20 +259,68 @@ GetMmCompatibility ()
 
   MmVersion = MmVersionArgs.Arg0;
 
-  if ((MM_MAJOR_VER(MmVersion) == MM_CALLER_MAJOR_VER) &&
+  if ((MM_MAJOR_VER (MmVersion) == MM_CALLER_MAJOR_VER) &&
-      (MM_MINOR_VER(MmVersion) >= MM_CALLER_MINOR_VER)) {
+      (MM_MINOR_VER (MmVersion) >= MM_CALLER_MINOR_VER))
-    DEBUG ((DEBUG_INFO, "MM Version: Major=0x%x, Minor=0x%x\n",
+  {
-            MM_MAJOR_VER(MmVersion), MM_MINOR_VER(MmVersion)));
+    DEBUG ((
+      DEBUG_INFO,
+      "MM Version: Major=0x%x, Minor=0x%x\n",
+      MM_MAJOR_VER (MmVersion),
+      MM_MINOR_VER (MmVersion)
+      ));
     Status = EFI_SUCCESS;
   } else {
-    DEBUG ((DEBUG_ERROR, "Incompatible MM Versions.\n Current Version: Major=0x%x, Minor=0x%x.\n Expected: Major=0x%x, Minor>=0x%x.\n",
+    DEBUG ((
-            MM_MAJOR_VER(MmVersion), MM_MINOR_VER(MmVersion), MM_CALLER_MAJOR_VER, MM_CALLER_MINOR_VER));
+      DEBUG_ERROR,
+      "Incompatible MM Versions.\n Current Version: Major=0x%x, Minor=0x%x.\n Expected: Major=0x%x, Minor>=0x%x.\n",
+      MM_MAJOR_VER (MmVersion),
+      MM_MINOR_VER (MmVersion),
+      MM_CALLER_MAJOR_VER,
+      MM_CALLER_MINOR_VER
+      ));
     Status = EFI_UNSUPPORTED;
   }
 
   return Status;
 }
 
+STATIC EFI_GUID *CONST  mGuidedEventGuid[] = {
+  &gEfiEndOfDxeEventGroupGuid,
+  &gEfiEventExitBootServicesGuid,
+  &gEfiEventReadyToBootGuid,
+};
+
+STATIC EFI_EVENT  mGuidedEvent[ARRAY_SIZE (mGuidedEventGuid)];
+
+/**
+  Event notification that is fired when GUIDed Event Group is signaled.
+
+  @param  Event                 The Event that is being processed, not used.
+  @param  Context               Event Context, not used.
+
+**/
+STATIC
+VOID
+EFIAPI
+MmGuidedEventNotify (
+  IN EFI_EVENT  Event,
+  IN VOID       *Context
+  )
+{
+  EFI_MM_COMMUNICATE_HEADER  Header;
+  UINTN                      Size;
+
+  //
+  // Use Guid to initialize EFI_SMM_COMMUNICATE_HEADER structure
+  //
+  CopyGuid (&Header.HeaderGuid, Context);
+  Header.MessageLength = 1;
+  Header.Data[0]       = 0;
+
+  Size = sizeof (Header);
+  MmCommunication2Communicate (&mMmCommunication2, &Header, &Header, &Size);
+}
+
 /**
   The Entry Point for MM Communication
 
@@ -275,23 +337,24 @@ GetMmCompatibility ()
 **/
 EFI_STATUS
 EFIAPI
-MmCommunicationInitialize (
+MmCommunication2Initialize (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
   IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
-  EFI_STATUS                 Status;
+  EFI_STATUS  Status;
+  UINTN       Index;
 
   // Check if we can make the MM call
   Status = GetMmCompatibility ();
-  if (EFI_ERROR(Status)) {
+  if (EFI_ERROR (Status)) {
     goto ReturnErrorStatus;
   }
 
   mNsCommBuffMemRegion.PhysicalBase = PcdGet64 (PcdMmBufferBase);
   // During boot , Virtual and Physical are same
   mNsCommBuffMemRegion.VirtualBase = mNsCommBuffMemRegion.PhysicalBase;
-  mNsCommBuffMemRegion.Length = PcdGet64 (PcdMmBufferSize);
+  mNsCommBuffMemRegion.Length      = PcdGet64 (PcdMmBufferSize);
 
   ASSERT (mNsCommBuffMemRegion.PhysicalBase != 0);
 
@@ -306,8 +369,11 @@ MmCommunicationInitialize (
                   EFI_MEMORY_RUNTIME
                   );
   if (EFI_ERROR (Status)) {
-    DEBUG ((DEBUG_ERROR, "MmCommunicateInitialize: "
+    DEBUG ((
-            "Failed to add MM-NS Buffer Memory Space\n"));
+      DEBUG_ERROR,
+      "MmCommunicateInitialize: "
+      "Failed to add MM-NS Buffer Memory Space\n"
+      ));
     goto ReturnErrorStatus;
   }
 
@@ -317,21 +383,27 @@ MmCommunicationInitialize (
                   EFI_MEMORY_WB | EFI_MEMORY_XP | EFI_MEMORY_RUNTIME
                   );
   if (EFI_ERROR (Status)) {
-    DEBUG ((DEBUG_ERROR, "MmCommunicateInitialize: "
+    DEBUG ((
-            "Failed to set MM-NS Buffer Memory attributes\n"));
+      DEBUG_ERROR,
+      "MmCommunicateInitialize: "
+      "Failed to set MM-NS Buffer Memory attributes\n"
+      ));
     goto CleanAddedMemorySpace;
   }
 
   // Install the communication protocol
   Status = gBS->InstallProtocolInterface (
                   &mMmCommunicateHandle,
-                  &gEfiMmCommunicationProtocolGuid,
+                  &gEfiMmCommunication2ProtocolGuid,
                   EFI_NATIVE_INTERFACE,
-                  &mMmCommunication
+                  &mMmCommunication2
                   );
-  if (EFI_ERROR(Status)) {
+  if (EFI_ERROR (Status)) {
-    DEBUG ((DEBUG_ERROR, "MmCommunicationInitialize: "
+    DEBUG ((
-            "Failed to install MM communication protocol\n"));
+      DEBUG_ERROR,
+      "MmCommunicationInitialize: "
+      "Failed to install MM communication protocol\n"
+      ));
     goto CleanAddedMemorySpace;
   }
 
@@ -345,14 +417,34 @@ MmCommunicationInitialize (
                   NULL,
                   &mSetVirtualAddressMapEvent
                   );
-  if (Status == EFI_SUCCESS) {
+  ASSERT_EFI_ERROR (Status);
-    return Status;
+
+  for (Index = 0; Index < ARRAY_SIZE (mGuidedEventGuid); Index++) {
+    Status = gBS->CreateEventEx (
+                    EVT_NOTIFY_SIGNAL,
+                    TPL_CALLBACK,
+                    MmGuidedEventNotify,
+                    mGuidedEventGuid[Index],
+                    mGuidedEventGuid[Index],
+                    &mGuidedEvent[Index]
+                    );
+    ASSERT_EFI_ERROR (Status);
+    if (EFI_ERROR (Status)) {
+      while (Index-- > 0) {
+        gBS->CloseEvent (mGuidedEvent[Index]);
+      }
+
+      goto UninstallProtocol;
+    }
   }
 
+  return EFI_SUCCESS;
+
+UninstallProtocol:
   gBS->UninstallProtocolInterface (
          mMmCommunicateHandle,
-         &gEfiMmCommunicationProtocolGuid,
+         &gEfiMmCommunication2ProtocolGuid,
-         &mMmCommunication
+         &mMmCommunication2
          );
 
 CleanAddedMemorySpace:

ArmPkg/Drivers/MmCommunicationDxe/MmCommunication.inf

@@ -2,7 +2,7 @@
 #
 #  DXE MM Communicate driver
 #
-#  Copyright (c) 2016 - 2018, ARM Limited. All rights reserved.
+#  Copyright (c) 2016 - 2021, Arm Limited. All rights reserved.<BR>
 #
 #  SPDX-License-Identifier: BSD-2-Clause-Patent
 #
@@ -14,7 +14,7 @@
   FILE_GUID                      = 09EE81D3-F15E-43F4-85B4-CB9873DA5D6B
   MODULE_TYPE                    = DXE_RUNTIME_DRIVER
   VERSION_STRING                 = 1.0
-  ENTRY_POINT                    = MmCommunicationInitialize
+  ENTRY_POINT                    = MmCommunication2Initialize
 
 #
 # The following is for reference only and not required by
@@ -24,6 +24,7 @@
 #
 
 [Sources.AARCH64]
+  MmCommunicate.h
   MmCommunication.c
 
 [Packages]
@@ -40,7 +41,12 @@
   UefiDriverEntryPoint
 
 [Protocols]
-  gEfiMmCommunicationProtocolGuid              ## PRODUCES
+  gEfiMmCommunication2ProtocolGuid              ## PRODUCES
+
+[Guids]
+  gEfiEndOfDxeEventGroupGuid
+  gEfiEventExitBootServicesGuid
+  gEfiEventReadyToBootGuid
 
 [Pcd.common]
   gArmTokenSpaceGuid.PcdMmBufferBase

ArmPkg/Drivers/TimerDxe/TimerDxe.c

@@ -1,13 +1,12 @@
 /** @file
   Timer Architecture Protocol driver of the ARM flavor
 
-  Copyright (c) 2011-2013 ARM Ltd. All rights reserved.<BR>
+  Copyright (c) 2011-2021, Arm Limited. All rights reserved.<BR>
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
 **/
 
-
 #include <PiDxe.h>
 
 #include <Library/ArmLib.h>
@@ -24,18 +23,18 @@
 #include <Protocol/HardwareInterrupt.h>
 
 // The notification function to call on every timer interrupt.
-EFI_TIMER_NOTIFY      mTimerNotifyFunction     = (EFI_TIMER_NOTIFY)NULL;
+EFI_TIMER_NOTIFY  mTimerNotifyFunction     = (EFI_TIMER_NOTIFY)NULL;
-EFI_EVENT             EfiExitBootServicesEvent = (EFI_EVENT)NULL;
+EFI_EVENT         EfiExitBootServicesEvent = (EFI_EVENT)NULL;
 
 // The current period of the timer interrupt
-UINT64 mTimerPeriod = 0;
+UINT64  mTimerPeriod = 0;
 // The latest Timer Tick calculated for mTimerPeriod
-UINT64 mTimerTicks = 0;
+UINT64  mTimerTicks = 0;
 // Number of elapsed period since the last Timer interrupt
-UINT64 mElapsedPeriod = 1;
+UINT64  mElapsedPeriod = 1;
 
 // Cached copy of the Hardware Interrupt protocol instance
-EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;
+EFI_HARDWARE_INTERRUPT_PROTOCOL  *gInterrupt = NULL;
 
 /**
   This function registers the handler NotifyFunction so it is called every time
@@ -133,9 +132,9 @@ TimerDriverSetTimerPeriod (
   IN UINT64                   TimerPeriod
   )
 {
-  UINT64      CounterValue;
+  UINT64   CounterValue;
-  UINT64      TimerTicks;
+  UINT64   TimerTicks;
-  EFI_TPL     OriginalTPL;
+  EFI_TPL  OriginalTPL;
 
   // Always disable the timer
   ArmGenericTimerDisableTimer ();
@@ -166,7 +165,7 @@ TimerDriverSetTimerPeriod (
     ArmGenericTimerEnableTimer ();
   } else {
     // Save the new timer period
-    mTimerPeriod   = TimerPeriod;
+    mTimerPeriod = TimerPeriod;
     // Reset the elapsed period
     mElapsedPeriod = 1;
   }
@@ -192,8 +191,8 @@ TimerDriverSetTimerPeriod (
 EFI_STATUS
 EFIAPI
 TimerDriverGetTimerPeriod (
-  IN EFI_TIMER_ARCH_PROTOCOL   *This,
+  IN EFI_TIMER_ARCH_PROTOCOL  *This,
-  OUT UINT64                   *TimerPeriod
+  OUT UINT64                  *TimerPeriod
   )
 {
   if (TimerPeriod == NULL) {
@@ -262,7 +261,7 @@ TimerDriverGenerateSoftInterrupt (
   a period of time.
 
 **/
-EFI_TIMER_ARCH_PROTOCOL   gTimer = {
+EFI_TIMER_ARCH_PROTOCOL  gTimer = {
   TimerDriverRegisterHandler,
   TimerDriverSetTimerPeriod,
   TimerDriverGetTimerPeriod,
@@ -285,13 +284,13 @@ EFI_TIMER_ARCH_PROTOCOL   gTimer = {
 VOID
 EFIAPI
 TimerInterruptHandler (
-  IN  HARDWARE_INTERRUPT_SOURCE   Source,
+  IN  HARDWARE_INTERRUPT_SOURCE  Source,
-  IN  EFI_SYSTEM_CONTEXT          SystemContext
+  IN  EFI_SYSTEM_CONTEXT         SystemContext
   )
 {
-  EFI_TPL      OriginalTPL;
+  EFI_TPL  OriginalTPL;
-  UINT64       CurrentValue;
+  UINT64   CurrentValue;
-  UINT64       CompareValue;
+  UINT64   CompareValue;
 
   //
   // DXE core uses this callback for the EFI timer tick. The DXE core uses locks
@@ -305,9 +304,8 @@ TimerInterruptHandler (
   gInterrupt->EndOfInterrupt (gInterrupt, Source);
 
   // Check if the timer interrupt is active
-  if ((ArmGenericTimerGetTimerCtrlReg () ) & ARM_ARCH_TIMER_ISTATUS) {
+  if ((ArmGenericTimerGetTimerCtrlReg ()) & ARM_ARCH_TIMER_ISTATUS) {
-
+    if (mTimerNotifyFunction != 0) {
-    if (mTimerNotifyFunction) {
       mTimerNotifyFunction (mTimerPeriod * mElapsedPeriod);
     }
 
@@ -338,7 +336,6 @@ TimerInterruptHandler (
   gBS->RestoreTPL (OriginalTPL);
 }
 
-
 /**
   Initialize the state information for the Timer Architectural Protocol and
   the Timer Debug support protocol that allows the debugger to break into a
@@ -355,11 +352,11 @@ TimerInterruptHandler (
 EFI_STATUS
 EFIAPI
 TimerInitialize (
-  IN EFI_HANDLE         ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE   *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
-  EFI_HANDLE  Handle = NULL;
+  EFI_HANDLE  Handle;
   EFI_STATUS  Status;
   UINTN       TimerCtrlReg;
   UINT32      TimerHypIntrNum;
@@ -374,7 +371,7 @@ TimerInitialize (
   ASSERT_EFI_ERROR (Status);
 
   // Disable the timer
-  TimerCtrlReg = ArmGenericTimerGetTimerCtrlReg ();
+  TimerCtrlReg  = ArmGenericTimerGetTimerCtrlReg ();
   TimerCtrlReg |= ARM_ARCH_TIMER_IMASK;
   TimerCtrlReg &= ~ARM_ARCH_TIMER_ENABLE;
   ArmGenericTimerSetTimerCtrlReg (TimerCtrlReg);
@@ -405,16 +402,18 @@ TimerInitialize (
   ASSERT_EFI_ERROR (Status);
 
   // Set up default timer
-  Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod)); // TIMER_DEFAULT_PERIOD
+  Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32 (PcdTimerPeriod)); // TIMER_DEFAULT_PERIOD
   ASSERT_EFI_ERROR (Status);
 
+  Handle = NULL;
   // Install the Timer Architectural Protocol onto a new handle
-  Status = gBS->InstallMultipleProtocolInterfaces(
+  Status = gBS->InstallMultipleProtocolInterfaces (
                   &Handle,
-                  &gEfiTimerArchProtocolGuid,      &gTimer,
+                  &gEfiTimerArchProtocolGuid,
+                  &gTimer,
                   NULL
                   );
-  ASSERT_EFI_ERROR(Status);
+  ASSERT_EFI_ERROR (Status);
 
   // Everything is ready, unmask and enable timer interrupts
   TimerCtrlReg = ARM_ARCH_TIMER_ENABLE;

ArmPkg/Filesystem/SemihostFs/Arm/SemihostFs.c

@@ -2,7 +2,7 @@
   Support a Semi Host file system over a debuggers JTAG
 
   Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
-  Portions copyright (c) 2011 - 2014, ARM Ltd. All rights reserved.<BR>
+  Portions copyright (c) 2011 - 2021, Arm Limited. All rights reserved.<BR>
 
   SPDX-License-Identifier: BSD-2-Clause-Patent
 
@@ -27,16 +27,16 @@
 
 #include "SemihostFs.h"
 
-#define DEFAULT_SEMIHOST_FS_LABEL   L"SemihostFs"
+#define DEFAULT_SEMIHOST_FS_LABEL  L"SemihostFs"
 
-STATIC CHAR16 *mSemihostFsLabel;
+STATIC CHAR16  *mSemihostFsLabel;
 
-EFI_SIMPLE_FILE_SYSTEM_PROTOCOL gSemihostFs = {
+EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  gSemihostFs = {
   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION,
   VolumeOpen
 };
 
-EFI_FILE gSemihostFsFile = {
+EFI_FILE  gSemihostFsFile = {
   EFI_FILE_PROTOCOL_REVISION,
   FileOpen,
   FileClose,
@@ -51,47 +51,50 @@ EFI_FILE gSemihostFsFile = {
 };
 
 //
-// Device path for semi-hosting. It contains our autogened Caller ID GUID.
+// Device path for semi-hosting. It contains our auto-generated Caller ID GUID.
 //
 typedef struct {
-  VENDOR_DEVICE_PATH        Guid;
+  VENDOR_DEVICE_PATH          Guid;
-  EFI_DEVICE_PATH_PROTOCOL  End;
+  EFI_DEVICE_PATH_PROTOCOL    End;
 } SEMIHOST_DEVICE_PATH;
 
-SEMIHOST_DEVICE_PATH gDevicePath = {
+SEMIHOST_DEVICE_PATH  gDevicePath = {
   {
-    { HARDWARE_DEVICE_PATH, HW_VENDOR_DP, { sizeof (VENDOR_DEVICE_PATH), 0 } },
+    { HARDWARE_DEVICE_PATH, HW_VENDOR_DP,                   { sizeof (VENDOR_DEVICE_PATH),       0 }
+    },
     EFI_CALLER_ID_GUID
   },
-  { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 } }
+  { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }
+  }
 };
 
 typedef struct {
-  LIST_ENTRY    Link;
+  LIST_ENTRY       Link;
-  UINT64        Signature;
+  UINT64           Signature;
-  EFI_FILE      File;
+  EFI_FILE         File;
-  CHAR8         *FileName;
+  CHAR8            *FileName;
-  UINT64        OpenMode;
+  UINT64           OpenMode;
-  UINT32        Position;
+  UINT32           Position;
-  UINTN         SemihostHandle;
+  UINTN            SemihostHandle;
-  BOOLEAN       IsRoot;
+  BOOLEAN          IsRoot;
-  EFI_FILE_INFO Info;
+  EFI_FILE_INFO    Info;
 } SEMIHOST_FCB;
 
-#define SEMIHOST_FCB_SIGNATURE      SIGNATURE_32( 'S', 'H', 'F', 'C' )
+#define SEMIHOST_FCB_SIGNATURE  SIGNATURE_32( 'S', 'H', 'F', 'C' )
-#define SEMIHOST_FCB_FROM_THIS(a)   CR(a, SEMIHOST_FCB, File, SEMIHOST_FCB_SIGNATURE)
+#define SEMIHOST_FCB_FROM_THIS(a)  CR(a, SEMIHOST_FCB, File, SEMIHOST_FCB_SIGNATURE)
-#define SEMIHOST_FCB_FROM_LINK(a)   CR(a, SEMIHOST_FCB, Link, SEMIHOST_FCB_SIGNATURE);
+#define SEMIHOST_FCB_FROM_LINK(a)  CR(a, SEMIHOST_FCB, Link, SEMIHOST_FCB_SIGNATURE);
 
 EFI_HANDLE  gInstallHandle = NULL;
-LIST_ENTRY  gFileList = INITIALIZE_LIST_HEAD_VARIABLE (gFileList);
+LIST_ENTRY  gFileList      = INITIALIZE_LIST_HEAD_VARIABLE (gFileList);
 
 SEMIHOST_FCB *
 AllocateFCB (
   VOID
   )
 {
-  SEMIHOST_FCB *Fcb = AllocateZeroPool (sizeof (SEMIHOST_FCB));
+  SEMIHOST_FCB  *Fcb;
 
+  Fcb = AllocateZeroPool (sizeof (SEMIHOST_FCB));
   if (Fcb != NULL) {
     CopyMem (&Fcb->File, &gSemihostFsFile, sizeof (gSemihostFsFile));
     Fcb->Signature = SEMIHOST_FCB_SIGNATURE;
@@ -102,7 +105,7 @@ AllocateFCB (
 
 VOID
 FreeFCB (
-  IN SEMIHOST_FCB *Fcb
+  IN SEMIHOST_FCB  *Fcb
   )
 {
   // Remove Fcb from gFileList.
@@ -114,15 +117,13 @@ FreeFCB (
   FreePool (Fcb);
 }
 
-
-
 EFI_STATUS
 VolumeOpen (
-  IN  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
+  IN  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *This,
-  OUT EFI_FILE                        **Root
+  OUT EFI_FILE                         **Root
   )
 {
-  SEMIHOST_FCB *RootFcb = NULL;
+  SEMIHOST_FCB  *RootFcb;
 
   if (Root == NULL) {
     return EFI_INVALID_PARAMETER;
@@ -133,7 +134,7 @@ VolumeOpen (
     return EFI_OUT_OF_RESOURCES;
   }
 
-  RootFcb->IsRoot = TRUE;
+  RootFcb->IsRoot         = TRUE;
   RootFcb->Info.Attribute = EFI_FILE_READ_ONLY | EFI_FILE_DIRECTORY;
 
   InsertTailList (&gFileList, &RootFcb->Link);
@@ -190,29 +191,33 @@ FileOpen (
     return EFI_INVALID_PARAMETER;
   }
 
-  if ( (OpenMode != EFI_FILE_MODE_READ) &&
+  if ((OpenMode != EFI_FILE_MODE_READ) &&
-       (OpenMode != (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE)) &&
+      (OpenMode != (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE)) &&
-       (OpenMode != (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE)) ) {
+      (OpenMode != (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE)))
+  {
     return EFI_INVALID_PARAMETER;
   }
 
-  if ((OpenMode & EFI_FILE_MODE_CREATE) &&
+  if (((OpenMode & EFI_FILE_MODE_CREATE) != 0) &&
-      (Attributes & EFI_FILE_DIRECTORY)    ) {
+      ((Attributes & EFI_FILE_DIRECTORY) != 0))
+  {
     return EFI_WRITE_PROTECTED;
   }
 
-  Length = StrLen (FileName) + 1;
+  Length        = StrLen (FileName) + 1;
   AsciiFileName = AllocatePool (Length);
   if (AsciiFileName == NULL) {
     return EFI_OUT_OF_RESOURCES;
   }
+
   UnicodeStrToAsciiStrS (FileName, AsciiFileName, Length);
 
   // Opening '/', '\', '.', or the NULL pathname is trying to open the root directory
   if ((AsciiStrCmp (AsciiFileName, "\\") == 0) ||
       (AsciiStrCmp (AsciiFileName, "/")  == 0) ||
       (AsciiStrCmp (AsciiFileName, "")   == 0) ||
-      (AsciiStrCmp (AsciiFileName, ".")  == 0)    ) {
+      (AsciiStrCmp (AsciiFileName, ".")  == 0))
+  {
     FreePool (AsciiFileName);
     return (VolumeOpen (&gSemihostFs, NewHandle));
   }
@@ -231,10 +236,11 @@ FileOpen (
   } else {
     SemihostMode = SEMIHOST_FILE_MODE_READ | SEMIHOST_FILE_MODE_BINARY | SEMIHOST_FILE_MODE_UPDATE;
   }
+
   Return = SemihostFileOpen (AsciiFileName, SemihostMode, &SemihostHandle);
 
   if (RETURN_ERROR (Return)) {
-    if (OpenMode & EFI_FILE_MODE_CREATE) {
+    if ((OpenMode & EFI_FILE_MODE_CREATE) != 0) {
       //
       // In the create if does not exist case, if the opening in update
       // mode failed, create it and open it in update mode. The update
@@ -277,7 +283,8 @@ FileOpen (
 
   FileFcb->Info.FileSize     = Length;
   FileFcb->Info.PhysicalSize = Length;
-  FileFcb->Info.Attribute    = (OpenMode & EFI_FILE_MODE_CREATE) ? Attributes : 0;
+  FileFcb->Info.Attribute    = ((OpenMode & EFI_FILE_MODE_CREATE) != 0) ?
+                               Attributes : 0;
 
   InsertTailList (&gFileList, &FileFcb->Link);
 
@@ -306,7 +313,7 @@ STATIC
 EFI_STATUS
 TruncateFile (
   IN CHAR8  *FileName,
-  IN UINTN   Size
+  IN UINTN  Size
   )
 {
   EFI_STATUS     Status;
@@ -336,7 +343,7 @@ TruncateFile (
     goto Error;
   }
 
-  Read = 0;
+  Read      = 0;
   Remaining = Size;
   while (Remaining > 0) {
     ToRead = Remaining;
@@ -344,11 +351,12 @@ TruncateFile (
     if (RETURN_ERROR (Return)) {
       goto Error;
     }
+
     Remaining -= ToRead;
     Read      += ToRead;
   }
 
-  Return = SemihostFileClose (FileHandle);
+  Return     = SemihostFileClose (FileHandle);
   FileHandle = 0;
   if (RETURN_ERROR (Return)) {
     goto Error;
@@ -377,12 +385,12 @@ Error:
   if (FileHandle != 0) {
     SemihostFileClose (FileHandle);
   }
+
   if (Buffer != NULL) {
     FreePool (Buffer);
   }
 
   return (Status);
-
 }
 
 /**
@@ -400,13 +408,13 @@ FileClose (
   IN EFI_FILE  *This
   )
 {
-  SEMIHOST_FCB   *Fcb;
+  SEMIHOST_FCB  *Fcb;
 
   if (This == NULL) {
     return EFI_INVALID_PARAMETER;
   }
 
-  Fcb = SEMIHOST_FCB_FROM_THIS(This);
+  Fcb = SEMIHOST_FCB_FROM_THIS (This);
 
   if (!Fcb->IsRoot) {
     SemihostFileClose (Fcb->SemihostHandle);
@@ -418,6 +426,7 @@ FileClose (
     if (Fcb->Info.FileSize < Fcb->Info.PhysicalSize) {
       TruncateFile (Fcb->FileName, Fcb->Info.FileSize);
     }
+
     FreePool (Fcb->FileName);
   }
 
@@ -439,7 +448,7 @@ FileClose (
 **/
 EFI_STATUS
 FileDelete (
-  IN EFI_FILE *This
+  IN EFI_FILE  *This
   )
 {
   SEMIHOST_FCB   *Fcb;
@@ -469,6 +478,7 @@ FileDelete (
     if (RETURN_ERROR (Return)) {
       return EFI_WARN_DELETE_FAILURE;
     }
+
     return EFI_SUCCESS;
   } else {
     return EFI_WARN_DELETE_FAILURE;
@@ -564,14 +574,15 @@ ExtendFile (
   }
 
   Remaining = Size;
-  SetMem (WriteBuffer, 0, sizeof(WriteBuffer));
+  SetMem (WriteBuffer, 0, sizeof (WriteBuffer));
   while (Remaining > 0) {
-    WriteNb = MIN (Remaining, sizeof(WriteBuffer));
+    WriteNb   = MIN (Remaining, sizeof (WriteBuffer));
     WriteSize = WriteNb;
-    Return = SemihostFileWrite (Fcb->SemihostHandle, &WriteSize, WriteBuffer);
+    Return    = SemihostFileWrite (Fcb->SemihostHandle, &WriteSize, WriteBuffer);
     if (RETURN_ERROR (Return)) {
       return EFI_DEVICE_ERROR;
     }
+
     Remaining -= WriteNb;
   }
 
@@ -597,9 +608,9 @@ ExtendFile (
 **/
 EFI_STATUS
 FileWrite (
-  IN     EFI_FILE *This,
+  IN     EFI_FILE  *This,
-  IN OUT UINTN    *BufferSize,
+  IN OUT UINTN     *BufferSize,
-  IN     VOID     *Buffer
+  IN     VOID      *Buffer
   )
 {
   SEMIHOST_FCB   *Fcb;
@@ -615,8 +626,9 @@ FileWrite (
   Fcb = SEMIHOST_FCB_FROM_THIS (This);
 
   // We cannot write a read-only file
-  if ((Fcb->Info.Attribute & EFI_FILE_READ_ONLY)
+  if (  (Fcb->Info.Attribute & EFI_FILE_READ_ONLY)
-      || !(Fcb->OpenMode & EFI_FILE_MODE_WRITE)) {
+     || !(Fcb->OpenMode & EFI_FILE_MODE_WRITE))
+  {
     return EFI_ACCESS_DENIED;
   }
 
@@ -630,11 +642,12 @@ FileWrite (
     if (EFI_ERROR (Status)) {
       return Status;
     }
+
     Fcb->Info.FileSize = Fcb->Position;
   }
 
   WriteSize = *BufferSize;
-  Return = SemihostFileWrite (Fcb->SemihostHandle, &WriteSize, Buffer);
+  Return    = SemihostFileWrite (Fcb->SemihostHandle, &WriteSize, Buffer);
   if (RETURN_ERROR (Return)) {
     return EFI_DEVICE_ERROR;
   }
@@ -648,6 +661,7 @@ FileWrite (
   if (RETURN_ERROR (Return)) {
     return EFI_DEVICE_ERROR;
   }
+
   Fcb->Info.PhysicalSize = Length;
 
   return EFI_SUCCESS;
@@ -666,17 +680,17 @@ FileWrite (
 **/
 EFI_STATUS
 FileGetPosition (
-  IN  EFI_FILE    *This,
+  IN  EFI_FILE  *This,
-  OUT UINT64      *Position
+  OUT UINT64    *Position
   )
 {
-  SEMIHOST_FCB *Fcb;
+  SEMIHOST_FCB  *Fcb;
 
   if ((This == NULL) || (Position == NULL)) {
     return EFI_INVALID_PARAMETER;
   }
 
-  Fcb = SEMIHOST_FCB_FROM_THIS(This);
+  Fcb = SEMIHOST_FCB_FROM_THIS (This);
 
   *Position = Fcb->Position;
 
@@ -699,8 +713,8 @@ FileGetPosition (
 **/
 EFI_STATUS
 FileSetPosition (
-  IN EFI_FILE *This,
+  IN EFI_FILE  *This,
-  IN UINT64   Position
+  IN UINT64    Position
   )
 {
   SEMIHOST_FCB   *Fcb;
@@ -716,8 +730,7 @@ FileSetPosition (
     if (Position != 0) {
       return EFI_UNSUPPORTED;
     }
-  }
+  } else {
-  else {
     //
     // UEFI Spec section 12.5:
     // "Seeking to position 0xFFFFFFFFFFFFFFFF causes the current position to
@@ -726,6 +739,7 @@ FileSetPosition (
     if (Position == 0xFFFFFFFFFFFFFFFF) {
       Position = Fcb->Info.FileSize;
     }
+
     Return = SemihostFileSeek (Fcb->SemihostHandle, MIN (Position, Fcb->Info.FileSize));
     if (RETURN_ERROR (Return)) {
       return EFI_DEVICE_ERROR;
@@ -758,13 +772,14 @@ GetFileInfo (
   OUT    VOID          *Buffer
   )
 {
-  EFI_FILE_INFO   *Info = NULL;
+  EFI_FILE_INFO  *Info;
-  UINTN           NameSize = 0;
+  UINTN          NameSize;
-  UINTN           ResultSize;
+  UINTN          ResultSize;
-  UINTN           Index;
+  UINTN          Index;
 
-  if (Fcb->IsRoot == TRUE) {
+  if (Fcb->IsRoot) {
-    ResultSize = SIZE_OF_EFI_FILE_INFO + sizeof(CHAR16);
+    NameSize   = 0;
+    ResultSize = SIZE_OF_EFI_FILE_INFO + sizeof (CHAR16);
   } else {
     NameSize   = AsciiStrLen (Fcb->FileName) + 1;
     ResultSize = SIZE_OF_EFI_FILE_INFO + NameSize * sizeof (CHAR16);
@@ -783,8 +798,8 @@ GetFileInfo (
   // Fill in the structure
   Info->Size = ResultSize;
 
-  if (Fcb->IsRoot == TRUE) {
+  if (Fcb->IsRoot) {
-    Info->FileName[0]  = L'\0';
+    Info->FileName[0] = L'\0';
   } else {
     for (Index = 0; Index < NameSize; Index++) {
       Info->FileName[Index] = Fcb->FileName[Index];
@@ -815,9 +830,9 @@ GetFileInfo (
 STATIC
 EFI_STATUS
 GetFilesystemInfo (
-  IN     SEMIHOST_FCB *Fcb,
+  IN     SEMIHOST_FCB  *Fcb,
-  IN OUT UINTN        *BufferSize,
+  IN OUT UINTN         *BufferSize,
-  OUT    VOID         *Buffer
+  OUT    VOID          *Buffer
   )
 {
   EFI_FILE_SYSTEM_INFO  *Info;
@@ -879,18 +894,19 @@ FileGetInfo (
   OUT    VOID      *Buffer
   )
 {
-  SEMIHOST_FCB *Fcb;
+  SEMIHOST_FCB  *Fcb;
-  EFI_STATUS   Status;
+  EFI_STATUS    Status;
-  UINTN        ResultSize;
+  UINTN         ResultSize;
 
   if ((This == NULL)                         ||
       (InformationType == NULL)              ||
       (BufferSize == NULL)                   ||
-      ((Buffer == NULL) && (*BufferSize > 0))  ) {
+      ((Buffer == NULL) && (*BufferSize > 0)))
+  {
     return EFI_INVALID_PARAMETER;
   }
 
-  Fcb = SEMIHOST_FCB_FROM_THIS(This);
+  Fcb = SEMIHOST_FCB_FROM_THIS (This);
 
   if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid)) {
     Status = GetFilesystemInfo (Fcb, BufferSize, Buffer);
@@ -960,11 +976,12 @@ SetFileInfo (
     return EFI_ACCESS_DENIED;
   }
 
-  Length = StrLen (Info->FileName) + 1;
+  Length        = StrLen (Info->FileName) + 1;
   AsciiFileName = AllocatePool (Length);
   if (AsciiFileName == NULL) {
     return EFI_OUT_OF_RESOURCES;
   }
+
   UnicodeStrToAsciiStrS (Info->FileName, AsciiFileName, Length);
 
   FileSizeIsDifferent = (Info->FileSize != Fcb->Info.FileSize);
@@ -982,7 +999,8 @@ SetFileInfo (
   // description.
   //
   if ((Fcb->OpenMode == EFI_FILE_MODE_READ)     ||
-      (Fcb->Info.Attribute & EFI_FILE_READ_ONLY)  ) {
+      (Fcb->Info.Attribute & EFI_FILE_READ_ONLY))
+  {
     if (FileSizeIsDifferent || FileNameIsDifferent || ReadOnlyIsDifferent) {
       Status = EFI_ACCESS_DENIED;
       goto Error;
@@ -1003,6 +1021,7 @@ SetFileInfo (
       if (EFI_ERROR (Status)) {
         goto Error;
       }
+
       //
       // The read/write position from the host file system point of view
       // is at the end of the file. If the position from this module
@@ -1013,12 +1032,14 @@ SetFileInfo (
         FileSetPosition (&Fcb->File, Fcb->Position);
       }
     }
+
     Fcb->Info.FileSize = FileSize;
 
     Return = SemihostFileLength (Fcb->SemihostHandle, &Length);
     if (RETURN_ERROR (Return)) {
       goto Error;
     }
+
     Fcb->Info.PhysicalSize = Length;
   }
 
@@ -1045,6 +1066,7 @@ SetFileInfo (
     if (RETURN_ERROR (Return)) {
       goto Error;
     }
+
     FreePool (Fcb->FileName);
     Fcb->FileName = AsciiFileName;
     AsciiFileName = NULL;
@@ -1116,19 +1138,24 @@ FileSetInfo (
     if (Info->Size < (SIZE_OF_EFI_FILE_INFO + StrSize (Info->FileName))) {
       return EFI_INVALID_PARAMETER;
     }
+
     if (BufferSize < Info->Size) {
       return EFI_BAD_BUFFER_SIZE;
     }
+
     return SetFileInfo (Fcb, Info);
   } else if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid)) {
     SystemInfo = Buffer;
     if (SystemInfo->Size <
-        (SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (SystemInfo->VolumeLabel))) {
+        (SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (SystemInfo->VolumeLabel)))
+    {
       return EFI_INVALID_PARAMETER;
     }
+
     if (BufferSize < SystemInfo->Size) {
       return EFI_BAD_BUFFER_SIZE;
     }
+
     Buffer = SystemInfo->VolumeLabel;
 
     if (StrSize (Buffer) > 0) {
@@ -1152,18 +1179,19 @@ FileSetInfo (
 
 EFI_STATUS
 FileFlush (
-  IN EFI_FILE *File
+  IN EFI_FILE  *File
   )
 {
-  SEMIHOST_FCB *Fcb;
+  SEMIHOST_FCB  *Fcb;
 
-  Fcb = SEMIHOST_FCB_FROM_THIS(File);
+  Fcb = SEMIHOST_FCB_FROM_THIS (File);
 
   if (Fcb->IsRoot) {
     return EFI_SUCCESS;
   } else {
-    if ((Fcb->Info.Attribute & EFI_FILE_READ_ONLY)
+    if (  (Fcb->Info.Attribute & EFI_FILE_READ_ONLY)
-        || !(Fcb->OpenMode & EFI_FILE_MODE_WRITE)) {
+       || !(Fcb->OpenMode & EFI_FILE_MODE_WRITE))
+    {
       return EFI_ACCESS_DENIED;
     } else {
       return EFI_SUCCESS;
@@ -1173,11 +1201,11 @@ FileFlush (
 
 EFI_STATUS
 SemihostFsEntryPoint (
-  IN EFI_HANDLE           ImageHandle,
+  IN EFI_HANDLE        ImageHandle,
-  IN EFI_SYSTEM_TABLE     *SystemTable
+  IN EFI_SYSTEM_TABLE  *SystemTable
   )
 {
-  EFI_STATUS    Status;
+  EFI_STATUS  Status;
 
   Status = EFI_NOT_FOUND;
 
@@ -1189,12 +1217,14 @@ SemihostFsEntryPoint (
 
     Status = gBS->InstallMultipleProtocolInterfaces (
                     &gInstallHandle,
-                    &gEfiSimpleFileSystemProtocolGuid, &gSemihostFs,
+                    &gEfiSimpleFileSystemProtocolGuid,
-                    &gEfiDevicePathProtocolGuid,       &gDevicePath,
+                    &gSemihostFs,
+                    &gEfiDevicePathProtocolGuid,
+                    &gDevicePath,
                     NULL
                     );
 
-    if (EFI_ERROR(Status)) {
+    if (EFI_ERROR (Status)) {
       FreePool (mSemihostFsLabel);
     }
   }