前言

Arm® Generic Interrupt Controller Architecture Specification GIC 架构版本 3 和版本 4

Copyright © 2008, 2011, 2015-2021 Arm Limited or its affiliates. All rights reserved.

Arm Generic Interrupt Controller Architecture Specification GIC 架构版本 3 和版本 4

Copyright © 2008, 2011, 2015-2021 Arm Limited or its affiliates. All rights reserved.

版本信息

本文档进行了以下更改。

变更历史

本规范中的部分信息先前发布于 Arm[®] Generic Interrupt Controller, Architecture version 2.0, Architecture Specification 。

专有声明

本文档受版权和其他相关权利保护，本文档中包含的信息的实践或实施可能受一项或多项专利或待审专利申请的保护。未经 ARM 事先明确书面许可，不得以任何形式通过任何方式复制本文档的任何部分。除非明确规定，否则本文档不授予任何知识产权的明示或暗示许可、禁反言或其他形式的许可。

您对本文档中信息的访问，以您接受不会使用或允许他人使用这些信息来确定实施是否侵犯任何第三方专利为条件。

本文档按“现状“提供。ARM 不提供任何明示、暗示或法定的陈述和保证，包括但不限于关于本文档的适销性、满意质量、不侵权或特定用途适用性的暗示保证。为避免疑义，ARM 不对专利、版权、商业秘密或其他权利的范围和内容进行任何陈述，也未进行任何分析来识别或理解其范围和内容。

本文档可能包含技术错误或印刷错误。

在法律不禁止的范围内，无论何种情况下，ARM 均不对任何损害承担责任，包括但不限于任何直接、间接、特殊、偶然、惩罚性或后果性损害，无论如何造成，无论何种责任理论，因使用本文档而产生，即使 ARM 已被告知可能发生此类损害。

本文档仅包含商业项目。您应负责确保任何使用、复制或披露本文档完全符合任何相关出口法律法规，以确保本文档或其任何部分不会直接或间接违反此类出口法律而出口。在提及 ARM 客户时使用“合作伙伴“一词，并不打算创建或指代与任何其他公司的任何合作伙伴关系。ARM 可能随时对本文档进行更改，恕不另行通知。

如果这些条款中包含的任何条款与涵盖本文档与 ARM 的任何点击或签署书面协议的任何条款冲突，则点击或签署的书面协议优于并取代这些条款的冲突条款。本文档可能为方便起见翻译成其他语言，您同意如果本文档的英文版本与任何翻译之间存在任何冲突，协议英文版本的条款应占上风。

ARM 公司徽标和标有 ® 或 ™ 的词语是 ARM Limited（或其子公司）在美国和/或其他地方的注册商标或商标。保留所有权利。本文档中提及的其他品牌和名称可能是其各自所有者的商标。请遵循 ARM 的商标使用指南：http://www.arm.com/company/policies/trademarks。 Copyright © 2008, 2011, 2015-2021 Arm Limited or its affiliates. All rights reserved.

Arm Limited. Company 02557590 registered in England.

110 Fulbourn Road, Cambridge, England CB1 9NJ.

LES-PRE-20349

保密状态

本文档是非保密的。使用、复制和披露本文档的权利可能受到根据 Arm 与 Arm 交付本文档的一方签订的协议条款的许可限制。

产品状态

本文档中的信息是最终的，即用于已开发的产品。

网址

http://www.arm.com

渐进术语承诺

Arm 重视包容性社区。Arm 认识到我们和我们的行业使用了可能令人反感的术语。Arm 努力引领行业并创造变革。

本文档的先前版本包含可能令人反感的术语。我们已替换这些术语。

如果您在本文档中发现令人反感的术语，请联系 terms@arm.com。

目录 Arm Generic Interrupt Controller Architecture Specification GIC 架构版本 3 和版本 4

词汇表

vii viii

前言

本前言介绍 Arm[®] Generic Interrupt Controller Architecture Specification 。包含以下部分：

• 关于本规范 第 x 页。

• 使用本规范 第 xi 页。

• 约定 第 xiii 页。

• 补充阅读 第 xiv 页。

• 反馈 第 xv 页。 前言 关于本规范

关于本规范

本规范描述了 Arm Generic Interrupt Controller (GIC) 架构。它定义了 GIC 架构的版本 3.0、3.1、3.2（GICv3）、4.0 和 4.1（GICv4）。

在整个文档中，对 GIC 或 一个 GIC 的引用指实现 GIC 架构的设备。除非上下文明确表示引用是设备的 IMPLEMENTATION DEFINED 功能，否则这些引用描述本规范的要求。

目标受众

本规范适用于想要在一系列符合 Arm 标准的实现中设计、实现或编程 GIC 的用户，从简单的单处理器实现到复杂的多处理器系统。它不假设熟悉 GIC 的先前版本。

本规范假设用户对 Arm 产品有一定经验，并熟悉描述 Armv8 架构的术语。有关更多信息，请参见 Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile 。 前言 使用本规范

使用本规范

本规范组织为以下章节：

第 1 章 介绍

阅读本章了解 GIC 的概述，以及本文档使用的术语信息。

第 2 章 中断的分发和路由

阅读本章了解 GIC 如何使用亲和性路由分发中断。

第 3 章 GIC 分区

阅读本章了解 GIC 分区的概述和 GIC 逻辑组件的信息。 第 4 章 物理中断处理和优先级排序 阅读本章了解 GIC 如何处理物理中断。 第 5 章 Locality-specific Peripheral Interrupt 和 ITS 阅读本章了解 Locality-specific Peripheral Interrupt (LPI) 和 Interrupt Translation Service (ITS) 的使用描述。 第 6 章 虚拟中断处理和优先级排序 阅读本章了解 GIC 如何处理虚拟中断。 第 7 章 GICv4.0 虚拟 LPI 支持

阅读本章了解 GIC 如何处理虚拟中断。 第 8 章 GICv4.1 虚拟中断支持 阅读本章了解 GICv4.1 中虚拟中断支持的变更。 第 9 章 内存分区和监控 阅读本章了解 GIC 上下文中的内存分区和监控描述。 第 10 章 连接到 Armv8-R AArch64 PE 阅读本章了解将 GIC 连接到实现 Armv8-R64 的 PE。 第 11 章 电源管理 阅读本章了解 GIC 电源管理。 第 12 章 程序员模型 阅读本章了解 GIC 寄存器接口和所有 GIC 寄存器的描述。 第 13 章 系统错误报告 阅读本章了解 GIC 对错误报告的支持。 第 14 章 传统操作和非对称配置 阅读本章了解 GIC 对传统操作和非对称配置的支持。 附录 A GIC Stream 协议接口

阅读此附录了解 GIC Stream 协议接口使用的 AXI4-Stream 协议标准基于消息的接口描述。

附录 B 伪代码定义

阅读此附录了解本规范中使用的伪代码定义。

词汇表

阅读词汇表了解本规范中使用的一些术语定义。 前言 使用本规范

前言 约定

约定

以下部分描述本书可能使用的约定：

• 排版约定 。

• 信号 。

• 数字 。

• 伪代码描述 。

排版约定

排版约定为：

斜体 引入特殊术语，表示引用。 粗体 表示信号名称，在适当时用于描述性列表中的术语。 等宽字体 用于汇编语法描述、伪代码和源代码示例。也在正文中用于指令助记符和对汇编语法描述、伪代码和源代码示例中出现的其他项的引用。

小型大写字母

用于具有特定技术含义且包含在 词汇表 中的少数术语。

彩色文本 表示链接。这可以是：

• URL，例如 https://developer.arm.com。

• 交叉引用，如果引用信息不在当前页面，则包括引用信息的页码，例如，关于 Generic Interrupt Controller (GIC) 第 1-18 页。

• 链接，指向章节或附录、词汇表条目，或定义彩色术语的文档部分，例如，Banked register 或 GICC_CTLR。

信号

一般来说，本规范不定义处理器信号，但它包含一些信号示例和建议。信号约定为：

信号电平 断言信号的电平取决于信号是高电平有效还是低电平有效。断言意味着：

• 高电平有效信号为 HIGH

• 低电平有效信号为 LOW。

小写 n 在信号名称的开头或结尾表示低电平有效信号。

数字

数字通常用十进制书写。二进制数字前加 0b，十六进制数字前加 0x。在这两种情况下，前缀和相关值都用等宽字体书写，例如 0xFFFF0000。

伪代码描述

本规范使用一种形式的伪代码来提供指定功能的精确描述。此伪代码用等宽字体书写，并遵循 Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile 和 Arm[®] Architecture Reference Manual, Armv7-A and Armv7-R edition 中描述的约定。 前言 补充阅读

补充阅读

本节列出了 Arm 和第三方的相关出版物。

请参见 Arm Developer，https://developer.arm.com 获取 Arm 文档。

Arm 出版物

• AMBA[®] 4 AXI4-Stream Protocol Specification (ARM IHI 0051)。

• Arm[®] Architecture Reference Manual, Armv7-A and Armv7-R edition (ARM DDI 0406)。

• Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile (ARM DDI 0487)。

• Arm[®] Architecture Reference Manual Supplement, Memory System Resource Partitioning and Monitoring (MPAM), for Armv8-A (ARM DDI 0598)。

• Arm[®] Generic Interrupt Controller, Architecture version 2.0, Architecture Specification (ARM IHI 0048)。

• Arm[®] CoreSight[™] Architecture Specification v3.0 (ARM IHI 0029)。

• Arm[®] Server Base System Architecture (SBSA) (ARM-DEN-0029)。

• GICv3 and GICv4 Software Overview (DAI 0492)。

• • Application Note GIC Stream Protocol Interface (ARM-ECM-0495013)。

其他出版物

本手册中引用或提供更多信息的以下书籍：

• JEDEC Solid State Technology Association, Standard Manufacture’s Identification Code , JEP106。 前言 反馈

反馈

Arm 欢迎对其文档提供反馈。

对本手册的反馈

• 如果您对本手册的内容有意见，请发送电子邮件至 errata@arm.com。请提供： • 标题。

• 编号，Arm IHI 0069G。

• 您的意见适用的页码。

• 您意见的简明解释。

Arm 也欢迎对新增和改进的一般建议。 前言 反馈

Chapter 1: 简介

本章提供了GIC架构的简介。它提供了GIC架构的概述以及该架构中的新特性。还提供了本文档使用的术语定义。包含以下部分：

• 关于Generic Interrupt Controller (GIC) .

• 术语 .

• 支持的配置和兼容性 . 1.1 关于Generic Interrupt Controller (GIC)

1.1 关于Generic Interrupt Controller (GIC)

GICv3架构被设计用来与Armv8-A和Armv8-R兼容的_处理单元_ ，PE配合工作。

Generic Interrupt Controller (GIC)架构定义：

• 对任何连接到GIC的PE处理所有中断源的架构要求。

• 适用于单处理器或多处理器系统的通用中断控制器编程接口。

GIC是支持和控制中断的架构化资源。它提供：

• 用于管理中断源、中断行为以及中断路由到一个或多个PE的寄存器。

• 支持：

  • Armv8架构。

• Locality-specific Peripheral Interrupts (LPI)。

  • Private Peripheral Interrupts (PPI)。

• Software Generated Interrupts (SGI)。

  • Shared Peripheral Interrupts (SPI)。

  • 中断屏蔽和优先级处理。

  • 单处理器和多处理器系统。

• 电源管理环境中的唤醒事件。

对于每个PE，GIC架构描述了如何从系统内不同类型的中断生成IRQ和FIQ中断。Armv8-A异常模型描述了PE如何处理这些IRQ和FIQ中断。

中断处理也依赖于Armv8架构的其他方面，如安全状态和虚拟化支持。Arm架构提供了两种安全状态，每种都有相关的物理内存地址空间：

• 安全状态。

• 非安全状态。

GIC架构支持与两种安全状态相关的中断路由和处理。有关更多信息，请参阅_中断分组和安全性_。

GIC架构支持与_虚拟机_，VM相关的虚拟中断处理的Armv8模型。虚拟化系统有：

• 一个管理程序必须包含在EL2执行的组件，负责在VM之间进行切换。

• 在EL1执行的多个VM。

• 在VM上的EL0执行的应用程序。

有关Armv8架构的更多信息，请参阅_Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile_。有关VM的更多信息，请参阅_关于GIC虚拟化支持_。

本规范定义了GIC架构的版本3.0、版本3.1、版本3.2（统称为GICv3）、版本4.0和版本4.1（统称为GICv4.1）。版本2.0（GICv2）仅在GICv3可选的传统操作支持方面进行描述，请参阅_具有传统操作的GICv3_。有关GICv2架构的详细信息，请参阅_Arm[®] Generic Interrupt Controller, Architecture version 2.0, Architecture Specification_。

注意 由于GICv4是GICv3.0和GICv3.1的扩展，本手册中对GICv3的所有引用同样适用于GICv4，除非明确另有说明。GICv4.1架构规范的任何变更都会相应地标出。

1.1.1 从GICv2开始的GIC架构变更

GIC可扩展性

GICv2架构只支持最多八个PE，因此具有无法扩展到大型系统的功能。GICv3通过改变中断路由的机制（称为_亲和性路由_）以及在中断分发中引入一个新组件（称为_Redistributor_）来解决这个问题。有关更多信息，请参阅第3章_GIC分区_。

通过将GICD_CTLR.ARE_S或GICD_CTLR.ARE_NS设置为1来启用安全状态的亲和性路由。

中断分组

_中断分组_是GICv3用来将中断处理与Armv8异常模型对齐的机制：

• Group 0物理中断预期在最高实现的异常级别处理。

• Secure Group 1物理中断预期在Secure EL1或EL2处理。

• Non-secure Group 1物理中断在使用虚拟化的系统中预期在Non-secure EL2处理，或在不使用虚拟化的系统中在Non-secure EL1处理。

这些中断组可以映射到Armv8 FIQ和IRQ信号上，如_中断分组_中所述，使用来自Armv8架构和GICv3架构内的配置位。

在GICv3中，中断分组支持：

• 将每个中断配置为Group 0、Secure Group 1或Non-secure Group 1。

• 使用FIQ异常请求向目标PE发送Group 0物理中断信号。

• 以允许它们在自己的安全状态下使用IRQ处理程序进行处理的方式向目标PE发送Group 1物理中断信号。Group 1中断的确切处理取决于当前的异常级别和安全状态，如第4章_物理中断处理和优先级_中所述。

• Group 0和Group 1中断优先级处理的统一方案。

Interrupt Translation Service (ITS)

Interrupt Translation Service，ITS，提供了允许软件控制如何将转发到ITS的中断转换为：

• 物理中断，在GICv3和GICv4中。

• 虚拟中断，仅在GICv4中。

ITS还允许软件确定转换后中断的目标Redistributor。软件可以通过命令接口和内存中相关的基于表的结构控制ITS。Interrupt Translation Service (ITS)的输出总是LPI，这是一种基于消息的中断形式。请参阅_Interrupt Translation Service_。

Locality-specific Peripheral Interrupts (LPI)

LPI是一类新的中断，显著扩展了GIC可以处理的中断ID空间。LPI是可选的，如果实现，可以由Interrupt Translation Service，ITS生成和支持。请参阅_LPI_。

Software Generated Interrupts (SGI)

由于GICv3支持大规模系统的能力，SGI的上下文已修改，不再包含源PE的身份。请参阅_Software Generated Interrupts_。

注意

原始的SGI格式仅在支持传统操作的GIC实现中可用。

Shared Peripheral Interrupts (SPI)

Distributor中添加了一组新寄存器，以支持基于消息的SPI的设置和清除。请参阅_Shared Peripheral Interrupts_。

System register接口

该接口在Armv8-A或Armv8-R PE中使用System register指令，为CPU interface寄存器提供紧密耦合的接口。该接口用于与中断处理和优先级掩码直接相关的寄存器，以最小化访问延迟。对于虚拟化，以这种方式访问的寄存器包括VM中断处理程序访问的寄存器，以及将虚拟中断从管理程序转发到VM的寄存器。所有其他寄存器都是内存映射的。

对于AArch64状态，System register接口的访问由以下设置启用：

• ICC_SRE_EL1.SRE == 1。

• • ICC_SRE_EL2.SRE == 1。 • ICC_SRE_EL3.SRE == 1。

对于AArch32状态，System register接口的访问由以下设置启用：• ICC_SRE.SRE == 1。 • ICC_HSRE.SRE == 1。 • ICC_MSRE.SRE == 1。

与GICv2向后兼容的其他行为在第14章_传统操作和不对称配置_中描述。

注意

在支持传统操作的GIC中，所有架构化的GIC寄存器都可以进行内存映射访问。

除非另有说明，本手册描述了在启用亲和性路由、System register访问和两种安全状态的系统中的GICv3架构。这意味着：

• GICD_CTLR.ARE_NS == 1。

• • GICD_CTLR.ARE_S == 1。 • GICD_CTLR.DS == 0。

对于在AArch64状态下的操作：

• ICC_SRE_EL1.SRE == 1，对于该寄存器的安全和非安全副本。

• ICC_SRE_EL2.SRE == 1。

• ICC_SRE_EL3.SRE == 1。

对于在AArch32状态下的操作：

• ICC_SRE.SRE == 1。

• ICC_HSRE.SRE == 1。

• ICC_MSRE.SRE == 1。

从GICv3开始，ARE和SRE控制位设置为0的传统操作已被弃用，如果PE实现Secure EL2则被移除。有关传统操作的更多信息，请参阅第14章_传统操作和不对称配置_。

GICv3.1特定的变更

GICv3.1增加了对Memory Partitioning and Monitoring、扩展SPI范围、扩展PPI范围以及对Secure EL2支持的支持。

GICv3.2特定的变更

GICv3.2增加了对Armv8-R AArch64的支持。

GICv4特定的变更

GICv4增加了对直接向VM注入虚拟中断的支持，无需涉及管理程序。直接注入仅由实现至少一个将中断转换为LPI的ITS的系统支持。

GICv4.1特定的变更

GICv4.1扩展了直接注入支持，也可以处理虚拟SGI。GICv4.1改变了某些GICv4数据结构的处理方式。

1.2 术语

本手册中的架构描述使用与Armv8架构相同的术语。有关此术语的更多信息，请参阅_Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile_的A部分介绍。

此外，在适当的地方使用AArch64 System register名称，优先于列出AArch32和AArch64 System register名称。AArch64寄存器名称上的EL _x_后缀表示可以访问该寄存器的最低异常级别。各个AArch64 System register描述包含对提供相同功能的AArch32 System register的引用。

以下部分定义了本手册中使用的架构术语：

• 中断类型 .

• 中断状态 .

• 处理中断的模型 .

• 其他术语 .

1.2.1 中断类型

实现GIC架构的设备可以控制_外设中断_。外设中断通常通过到GIC的物理信号断言。GIC架构定义了以下类型的外设中断：

Locality-specific Peripheral Interrupt (LPI)

LPI是一个有针对性的外设中断，被路由到亲和性层次结构中的特定PE：

• 在启用两种安全状态的系统中，LPI总是Non-secure Group 1中断。

• LPI具有边缘触发行为。

• LPI可以使用ITS路由。

• LPI没有活动状态，因此不需要显式去激活。

• LPI总是基于消息的中断。

有关更多信息，请参阅_LPI_。

Private Peripheral Interrupt (PPI)

这是一个针对单个特定PE的外设中断，不同的PE可以使用相同的中断号来指示不同的事件：

• PPI可以是Group 0中断、Secure Group 1中断或Non-secure Group 1中断。

• PPI可以支持边缘触发或电平敏感行为。

• PPI永远不会使用ITS路由。

• PPI具有活动状态，因此需要显式去激活。

注意

通常，期望PPI被每个PE上相同中断源的不同实例使用，从而允许PE特定事件使用通用中断号，如来自私有定时器的中断。

Shared Peripheral Interrupt (SPI)

这是一个外设中断，Distributor可以将其路由到可以处理该中断的指定PE，或者路由到系统中已配置为接受此类中断的一组PE中的某个PE：

• SPI可以是Group 0中断、Secure Group 1中断或Non-secure Group 1中断。

• SPI可以支持边缘触发或电平敏感行为。

• SPI永远不会使用ITS路由。

• SPI具有活动状态，因此需要显式去激活。

有关更多信息，请参阅_Shared Peripheral Interrupts_。有关Distributor的更多信息，请参阅第3章_GIC分区_。

Software Generated Interrupt (SGI)

SGI通常用于处理器间通信，并通过向GIC中的SGI寄存器写入来生成：

• SGI可以是Group 0中断、Secure Group 1中断或Non-secure Group 1中断。

• SGI具有边缘触发行为。

• SGI永远不会使用ITS路由。

• SGI具有活动状态，因此需要显式去激活。

有关更多信息，请参阅_Software Generated Interrupts_。

边缘触发的中断具有以下属性：

• 在检测到中断信号的上升沿时断言，然后无论信号状态如何，保持断言直到软件确认中断。

有关边缘触发的基于消息的中断的信息，请参阅基于消息的中断。

电平敏感的中断具有以下属性：

• 当中断信号电平为活动状态时断言，当电平不为活动状态时取消断言。

• 由软件显式取消断言。

1.2.2 中断状态

以下状态适用于GIC和连接的PE之间的每个接口：

非活动 不活动或不挂起的中断。 挂起 在硬件中被识别为断言或由软件生成，并等待目标PE处理的中断。

活动 已被PE确认并正在处理的中断，因此在初始中断不再活动之前，同一中断的另一个断言不会作为中断呈现给PE。

LPI没有活动状态，在被PE确认时转换为非活动状态。

活动和挂起 从中断的一次断言活动，并从后续断言挂起的中断。

LPI没有活动和挂起状态，在被PE确认时转换为非活动状态。

GIC维护每个支持的中断的状态。状态机定义了中断状态之间可能的转换，并且对于每种中断类型，定义了导致转换的条件。有关更多信息，请参阅_中断处理状态机_。

1.2.3 处理中断的模型

在多处理器实现中，存在以下处理中断的模型：

有针对性的分发模型

此模型适用于所有PPI和所有LPI。它也适用于：

• 在非传统操作期间的SPI，如果GICD_IROUTER.Interrupt_Routing_Mode == 0。

• 在传统操作期间，当GICD_CTLR.ARE_* == 0时，如果在适当的GICD_ITARGETSR字段中只有一位== 1。

由软件指定的目标PE接收中断。

有针对性的列表模型

此模型仅适用于SGI。多个PE独立接收中断。当PE确认中断时，只为该PE清除中断挂起状态。中断对每个PE保持挂起，直到被PE确认。

N选1模型

此模型仅适用于SPI。中断针对指定的一组PE，并且只在该组中的一个PE上执行。选择哪个PE执行中断是以IMPLEMENTATION DEFINED的方式决定的。架构对可以选择哪些PE应用限制，请参阅_启用中断分发_。

注意

• Arm GIC架构保证N选1中断仅呈现给目标PE集合中列出的一个PE。

• N选1中断可能呈现给一个PE，其中该中断不是最高优先级中断，或者中断被ICC_PMR_EL1或在PE内屏蔽。请参阅_中断生命周期_。

对于传统操作期间的SPI，当在目标寄存器中指定了多个目标PE时，此模型适用。

如果有多个PE可以处理中断，硬件实现一种机制来确定哪个PE激活中断。

1.2.4 其他术语

以下其他术语在本手册中使用：

空闲优先级

在GICv3中，空闲优先级0xFF是当该接口上没有中断活动时从ICC_RPR_EL1读取的运行优先级。在传统操作期间，从GICC_RPR读取的空闲优先级是IMPLEMENTATION DEFINED的，如在GICv2中一样。

Interrupt Identifier (INTID)

唯一标识具有相关事件及其源的中断的数字空间。然后将中断路由到一个或多个PE进行处理。PPI和SGI中断号对每个PE是本地的。SPI和LPI对物理域有全局中断号。有关更多信息，请参阅_INTID_。

Interrupt Routing Infrastructure (IRI)

Distributor、Redistributor以及可选的一个或多个ITS。有关更多信息，请参阅_GIC逻辑组件_。

基于消息的中断

基于消息的中断是由于对指定地址的内存写访问而断言的中断。物理中断可以转换为基于消息的中断。基于消息的中断可以支持电平敏感或边缘触发行为，尽管LPI总是边缘触发的。

GICv3支持两种基于消息的中断机制：

• 用于传送SPI的机制，其中指定的地址保存在Distributor中。在这种情况下，基于消息的中断可以是电平敏感或边缘触发的。

• 用于传送LPI的机制，其中指定的地址保存在ITS（如果实现了ITS）或Redistributor中。

Arm建议在支持PCIe的系统中使用LPI来提供MSI和MSI-X功能的支持。有关更多信息，请参阅第5章_局部特定外设中断和ITS_。GICv3还包括对使用基于消息的中断信号SPI的架构化支持，请参阅_Shared Peripheral Interrupts_。

物理中断

针对物理PE的中断是物理中断。它通过PE连接的物理CPU interface向PE发出信号。

运行优先级

在任何给定时间，CPU interface的运行优先级要么是：

• 活动中断的组优先级，该接口上没有进行优先级下降。

• 如果接口上没有没有进行优先级下降的活动中断，运行优先级是空闲优先级0xFF。

足够优先级

GIC CPU interface将启用的挂起中断的优先级与以下所有内容进行比较，以确定中断是否具有足够的优先级：

• 优先级掩码寄存器ICC_PMR_EL1。

• 接口的抢占设置，如ICC_BPR0_EL1和ICC_BPR1_EL1所示。

• 当前运行优先级，如CPU interface的ICC_RPR_EL1所示。

• 如果中断具有足够的优先级，则向连接的PE发出信号。

虚拟中断

针对VM的中断是虚拟中断。它由关联的虚拟CPU interface发出信号。有关更多信息，请参阅第6章_虚拟中断处理和优先级_。

维护中断

一个物理中断，它向管理程序发出与VM上中断处理相关的关键事件信号，以允许管理程序跟踪这些事件。这些事件由管理程序处理，包括启用和禁用特定组的中断。有关更多信息，请参阅_维护中断_。

1.3 支持的配置和兼容性

在Armv8-A中，EL2和EL3是可选的，PE可以支持这些异常级别中的一个、两个或都不支持。但是：

• PE需要EL3来支持安全和非安全状态。

• PE需要EL2来支持虚拟化。

• 如果没有实现EL3，则只有一个安全状态。该安全状态要么是安全状态，要么是非安全状态。

GICv3根据_Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile_中描述的_相互处理_规则，支持所有这些配置的中断处理，以及在AArch32状态和AArch64状态下的执行。

1.3.1 亲和性路由配置

GICv3架构支持亲和性路由。它提供对以下情况的可选支持：

• 不对称配置，其中为非安全状态启用亲和性路由，为安全状态禁用亲和性路由。这为安全传统环境提供了支持。

• 仅传统环境，其中为安全状态和非安全状态都禁用亲和性路由。

1.3.2 System register配置

当为两种安全状态的执行都启用亲和性路由时，必须配置GIC使用System register访问来处理物理中断。架构不支持为安全状态启用亲和性路由，而不为该安全状态配置System register访问。以这种方式配置GIC会导致UNPREDICTABLE行为。当为非安全状态的执行启用亲和性路由时，GIC架构可选地支持虚拟中断的传统操作，即在EL2执行的管理程序控制下的非安全EL1的传统中断处理。

1.3.3 GIC控制和配置

许多GIC寄存器以不同形式提供，以允许有效的中断处理：

• 用于两种安全状态。

• 用于不同的中断组。

• 对GICv3使用System register访问或对传统操作使用内存映射访问。

当启用System register访问时，GIC架构的控制和配置由架构化的System register和定义GIC程序员模型的相关访问处理。有关更多信息，请参阅第12章_程序员模型_。

一些寄存器总是内存映射的，而其他寄存器在GICv3中使用System register访问，在传统操作中使用内存映射访问。

表1-1显示了总是内存映射的寄存器。

表1-1 内存映射寄存器

• a. 每个PE都有一份Redistributor寄存器的副本。

• b. 一个实现中可以有多个ITS。每个ITS都有自己的GITS寄存器副本。

表1-2显示了传统操作中内存映射的寄存器，但在启用System register访问时在GICv3中被System register访问替代。

表1-2 传统操作的内存映射寄存器

注意

• 在非安全EL1执行的操作系统使用GICC_*或GICV_*寄存器来控制中断，并且不知道差异。

• GICR_*和GITS_*寄存器是在GICv3中引入的。

表1-3显示了当启用System register访问时GICv3支持的寄存器。

表1-3 System register

对虚拟化的Armv8支持和PE操作的异常级别决定是访问物理CPU interface寄存器还是虚拟CPU interface寄存器。

有关寄存器名称和影响使用哪个寄存器的因素的更多信息，请参阅_GIC System register访问_。

1.3.4 对Armv8架构状态的引用

表1-4显示了与GIC操作一起使用或影响GIC操作的Armv8架构状态。

表1-4 影响GIC操作的Armv8架构状态

表1-4 影响GIC操作的Armv8架构状态（续）

• a. 进程状态PSTATE是进程状态信息的抽象。有关更多信息，请参阅_Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile_。

有关这些寄存器和字段的更多信息，请参阅_Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile_。

1.3.5 不支持传统操作的GICv3

在不支持传统操作的实现中，亲和性路由和System register访问是永久启用的。这意味着相关的控制位是RAO/WI。表1-5显示了受此影响的寄存器字段。

表1-5 亲和性路由和System register访问的控制位

a. 该寄存器有安全副本和非安全副本。

如果支持安全虚拟化，这是唯一允许的配置。

1.3.6 支持传统操作的GICv3

传统操作_是与GICv2的有限向后兼容形式，提供给使用GICv3的系统运行使用GICv2的代码，前提是此代码满足本节描述的限制。传统操作在GICv3中是可选的。请参阅_中断的传统支持和不对称配置。

在支持传统操作的GICv3实现中，最多八个PE，其对内存映射寄存器接口的个别支持是IMPLEMENTATION DEFINED，可作为给定VM内的物理或虚拟中断目标。这是IMPLEMENTATION DEFINED：

• 传统操作是否适用于两种安全状态的执行，还是仅适用于安全状态的执行。

• 在非安全EL1执行时，传统操作是否仅在虚拟CPU interface中可用。

在GICv3中，以下限制适用于传统操作：

• GICv2功能GICC_CTLR.AckCtl在GICv2中已被弃用，在GICv3中不受支持。相应地，即使在传统模式下，行为就像GICv2中描述的GICC_CTLR.AckCtl位是RAZ/WI一样。

注意

在支持传统操作的GICv3实现中，当GICV_CTLR.AckCtl设置为1时，允许VM控制非安全中断。但是，Arm弃用了GICV_CTLR.AckCtl的使用。

• 不支持GICv2配置锁定功能和相关的CFGSDISABLE输入信号。

• 在EL2执行的管理程序只能控制它执行的PE上的虚拟中断，不能控制其他PE上的虚拟中断。

对于传统操作，支持不对称配置，其中：

• 在非安全状态和EL3启用亲和性路由和System register访问。

• 在安全EL1禁用亲和性路由和System register访问。

这允许在安全EL1运行的安全操作系统使用传统功能，前提是它不配置非安全中断。

在GICv2中，在安全状态执行的软件可以使用GICC_AIAR、GICC_AEOIR、GICC_AHPPIR和GICC_ABPR来控制非安全状态的中断。在不对称配置中没有等价功能。

Chapter 2: 中断的分发和路由

本章描述使用亲和性路由向目标 PE 分发和路由中断，以及中断 ID 的分配。包含以下部分：

• Distributor 和 Redistributor 。

• INTID 。

• 亲和性路由 。

2.1 Distributor 和 Redistributor

Distributor 提供 SPI 的路由配置，并保存所有相关的路由和优先级信息。

Redistributor 提供 PPI 和 SGI 的配置设置。

Redistributor 总是在有限时间内向 CPU interface 呈现具有最高优先级的待处理中断。有关中断优先级排序的更多信息，请参见 中断优先级排序 。

最高优先级待处理中断可能因以下原因而改变：

• 先前的最高优先级中断已被确认。

• 先前的最高优先级中断已被抢占。

• 先前的最高优先级中断被移除且不再有效。

• 组中断使能已被修改。

• PE 不再是参与 PE。请参见 参与节点 。

2.2 INTID

中断使用 ID 号（INTID）标识。GICv3 支持的 INTID 范围是 IMPLEMENTATION DEFINED，根据以下规则：

• 对于 Distributor 和 Redistributor 支持的 INTID 位数：

• 如果不支持 LPI，Distributor 中的 ID 空间限制为 10 位。这与 GIC 架构的早期版本相同。

• 如果支持 LPI，INTID 字段在 14-24 位范围内是 IMPLEMENTATION DEFINED，如 GICD_TYPER 的寄存器描述中所述。

注意

可以通过 GICR_PROPBASER 配置 Redistributor 使用比 GICD_TYPER 指定的更少的位数。

• 对于 ITS 支持的 INTID 位数： — 如果支持 LPI，INTID 字段在 14-24 位范围内是 IMPLEMENTATION DEFINED。

• INTID 字段的大小由 GITS_TYPER.IDbits 定义。

必须对 ITS 进行编程，以便转发到 Redistributor 的中断在该 Redistributor 支持的中断范围内，否则行为是 UNPREDICTABLE。

• 对于 CPU interface 支持的 INTID 位数：

  • GICv3 CPU interface 支持 16 位或 24 位 INTID 字段，选择是 IMPLEMENTATION DEFINED。支持的物理中断标识符位数由 ICC_CTLR_EL1.IDbits 和 ICC_CTLR_EL3.IDbits 指示。

有效的 INTID 空间由 CPU interface 和 Distributor 中的实现大小决定。将大于支持大小的 INTID 转发到 CPU interface 是编程错误。

未使用的 INTID 位为 RAZ。这意味着任何受影响的位字段都是零扩展的。

表 2-1 显示了 INTID 空间如何按中断类型划分。

表 2-1 INTID

注意 Arm 推荐的 PPI INTID 分配由服务器基础系统架构提供，请参见 Arm[®] Server Base System Architecture (SBSA) 。

GICv4 架构通过支持 vPEID 以及 INTID 空间为每个 VM 提供唯一的 INTID 空间。有关 VM 的更多信息，请参见 关于 GIC 对虚拟化的支持 ，有关 vPEID 的更多信息，请参见 中断转换服务 。

Arm 强烈建议实现的中断分组使用最低的 INTID 号和尽可能小的 INTID 范围。这减少了必须实现的内存中关联表的大小，以及发现例程必须检查的大小。

Arm 强烈建议软件保留：

• INTID0 - INTID7 用于 Non-secure 中断。

• INTID8 - INTID15 用于 Secure 中断。

2.2.1 特殊 INTID

GIC 架构为特殊用途保留的 INTID 列表如下：

1020 GIC 返回此值以响应在 EL3 读取 ICC_IAR0_EL1 或 ICC_HPPIR0_EL1，指示被确认的中断是预期在 Secure EL1 处理的中断。此 INTID 仅在 PE 使用 AArch64 状态在 EL3 执行时，或者 PE 在 AArch32 状态下以 Monitor 模式执行时返回。

当 ICC_CTLR_EL3.RM == 1 时，此值也可以由在 EL3 读取 ICC_IAR1_EL1 或 ICC_HPPIR1_EL1 返回，请参见 非对称操作和 ICC_CTLR_EL3.RM 的使用 。

1021 GIC 返回此值以响应在 EL3 读取 ICC_IAR0_EL1 或 ICC_HPPIR0_EL1，指示被确认的中断是预期在 Non-secure EL1 或 EL2 处理的中断。此 INTID 仅在 PE 使用 AArch64 状态在 EL3 执行时，或者 PE 在 AArch32 状态下以 Monitor 模式执行时返回。当 ICC_CTLR_EL3.RM == 1 时，此值也可以由在 EL3 读取 ICC_IAR1_EL1 或 ICC_HPPIR1_EL1 返回，请参见 非对称操作和 ICC_CTLR_EL3.RM 的使用。

1022 此值仅适用于传统操作。有关更多信息，请参见 特殊 INTID 1022 的使用。

1023 如果没有具有足够优先级的待处理中断可以向 PE 发出信号，或者如果最高优先级待处理中断不适合以下条件，则此值作为中断确认的响应返回：

• 当前安全状态。
• 与系统寄存器关联的中断组。

注意 这些 INTID 不需要中断结束或停用。

有关特殊 INTID 使用的更多信息，请参见以下寄存器的描述：

• ICC_IAR0_EL1。

• ICC_IAR1_EL1。

• ICC_HPPIR0_EL1。

• ICC_HPPIR1_EL1。

2.2.2 混合 INTID 大小的实现

实现可能选择为 GIC 的不同部分实现不同的 INTID 大小，受以下规则约束：

• PE 可以实现 16 位或 24 位 INTID。

  注意

  系统可能包含支持 16 位 INTID 的 PE 和支持 24 位 INTID 的 PE 的混合。

• Distributor 和 Redistributor 必须全部实现相同数量的 INTID 位。

• 在支持 LPI 的系统中，Distributor 和所有 Redistributor 必须实现至少 14 位 INTID。在 Distributor 和 Redistributor 中实现的位数不得超过系统中任何 PE 实现的最小位数。

注意 因为中断可能针对任何 PE，每个 PE 必须能够接收 Redistributor 可以发送的最大 INTID。这意味着 Redistributor 支持的 INTID 大小不能超过系统中每个 PE 支持的最小 INTID 大小。

• 在不支持 LPI 的系统中，Distributor 和所有 Redistributor 必须实现至少 5 位 INTID，不能实现超过 10 位 INTID。对于 GIC 版本 3.1，不能实现超过 13 位 INTID。

• 在包含一个或多个 ITS 的系统中，ITS 可以实现任何值，最多包括 Distributor 和 Redistributor 支持的位数，最少为 14 位，这是 LPI 支持所需的最小位数。

2.2.3 有效中断 ID 检查伪代码

以下伪代码描述了 GIC 如何检查物理中断的 INTID 是否有效：

// InterruptIdentifierValid()
// ==========================

boolean InterruptIdentifierValid(bits(64) data, boolean lpiAllowed)

    // First check whether any out of range bits are set
    integer N = CPUInterfaceIDSize();

    if !IsZero(data<63:N>) then
        if GenerateLocalSError() then
            // Reporting of locally generated SEIs is supported
            IMPLEMENTATION_DEFINED "SError INVALID_INTERRUPT_IDENTIFIER";
            UNPREDICTABLE;

    intID = data<INTID_SIZE-1:0>;

    if !lpiAllowed && IsLPI(intID) then        // LPIs are not supported
        if GenerateLocalSError() then
            // Reporting of locally generated SEIs is supported
            IMPLEMENTATION_DEFINED "SError INVALID_INTERRUPT_IDENTIFIER";
        UNPREDICTABLE;

以下伪代码描述了 GIC 如何检查虚拟中断的 INTID 是否有效：

// VirtualIdentifierValid()
// ========================

boolean VirtualIdentifierValid(bits(64) data, boolean lpiAllowed)

    // First check whether any out of range bits are set
    integer N = VIDBits();

    if !IsZero(data<63:N>) then
        if ICH_VTR_EL2.SEIS == '1' then
            // Reporting of locally generated SEIs is supported
            IMPLEMENTATION_DEFINED "SError INVALID_INTERRUPT_IDENTIFIER";
        UNPREDICTABLE;

    intID = data<INTID_SIZE-1:0>;

    if !lpiAllowed && IsLPI(intID) then        // LPIs are not supported
        if ICH_VTR_EL2.SEIS == '1' then
            // Reporting of locally generated SEIs is supported
            IMPLEMENTATION_DEFINED "SError INVALID_INTERRUPT_IDENTIFIER";
        UNPREDICTABLE;

    // Now check for special identifiers
    if IsSpecial(intID) then
        return FALSE;                              // It is a special ID

    // All the checks pass so the identifier is valid
    return TRUE;

以下伪代码描述 CPU interface ID 大小函数。

// CPUInterfaceIDSize()
// Returns TRUE if the value supplied has bits above the implemented range or
// if the value supplied exceeds the maximum configured size in the
// appropriate GITS_BASERn

boolean VCPUOutOfRange(bits(16) vcpu);

2.3 亲和性路由

亲和性路由是一种基于分层地址的方案，用于识别特定的 PE 节点进行中断路由。

对于 PE，亲和性值在 AArch64 状态下在 MPIDR_EL1 中定义，在 AArch32 状态下在 MPIDR 中定义：

• 亲和性路由是一个 32 位值，由四个 8 位亲和性字段组成。这些字段是节点 a 、b 、c 和 d 。

• 使用 AArch64 状态的 GICv3 可以支持：

  • 四级路由层次结构，a.b.c.d。

  • 三级路由层次结构，0.b.c.d。

• 使用 AArch32 状态的 GICv3 仅支持三个亲和性级别。

• ICC_CTLR_EL3.A3V、ICC_CTLR_EL1.A3V 和 GICD_TYPER.A3V 指示是否实现四级或三级亲和性。

注意 需要四级亲和性的实现必须仅支持 AArch64 状态。

在亲和性层次结构中指定节点的枚举符号为以下形式，其中 Affx 是亲和性级别 x：

Aff3.Aff2.Aff1.Aff0

在 Distributor 中使用 亲和性路由使能（ARE）位启用安全状态的亲和性路由。亲和性路由在以下情况下启用：

• 对于 Secure 中断，如果 GICD_CTLR.ARE_S 设置为 1。

• 对于 Non-secure 中断，如果 GICD_CTLR.ARE_NS 位设置为 1。

如果永久启用亲和性路由，GICD_CTLR.ARE_S 和 GICD_CTLR.ARE_NS 为 RAO/WI。

当启用亲和性路由时处理物理中断，还必须启用系统寄存器访问，请参见 GIC 系统寄存器访问 。对于其他情况，请参见第 14 章 传统操作和非对称配置 。

2.3.1 按 PE 亲和性路由 SPI 和 SGI

SPI 使用亲和性地址和 GICD_IROUTER 中保存的路由模式信息进行路由。SGI 使用软件生成 SGI 时写入的亲和性地址和路由模式信息进行路由。

使用以下寄存器生成 SGI：

• ICC_SGI0R_EL1。

• ICC_SGI1R_EL1。

• ICC_ASGI1R_EL1。

Arm 强烈建议在亲和性级别 0 仅使用 0-15 范围内的值，以与 SGI 目标列表功能对齐。请参见 软件生成中断 。

SPI 和 SGI 使用不同的寄存器进行路由：

• SPI 使用 GICD_IROUTER.Interrupt_Routing_Mode 进行路由：

  • 如果 GICD_IROUTER.Interrupt_Routing_Mode 清除为 0，SPI 路由到由 a.b.c.d 指定的单个 PE。

  • 如果 GICD_IROUTER.Interrupt_Routing_Mode 设置为 1，SPI 路由到定义为参与节点的任何 PE：

    • IRI 选择目标 PE 的机制是 IMPLEMENTATION DEFINED。

    • 当 ICC_CTLR_EL3.PMHE == 1 或 ICC_CTLR_EL1.PMHE == 1 时，IRI 可能使用与 PE 关联的 ICC_PMR_EL1 寄存器来确定目标 PE。

有关参与节点的更多信息，请参见 参与节点 。

• SGI 使用 ICC_SGI0R_EL1.IRM 和 ICC_SGI1R_EL1.IRM 进行路由：

  • 如果 IRM 位设置为 1，SGI 路由到系统中所有参与的 PE，不包括发起 PE。

  • 如果 IRM 位清除为 0，SGI 路由到由 a.b.c.targetlist 指定的 PE 组。

2.3.2 参与节点

配置为使用 1 of N 分发模型的启用 SPI 在以下情况下可以针对 PE：

• GICR_WAKER.ProcessorSleep == 0 且中断的中断组在 PE 上启用。

• GICD_CTLR.E1NWF == 1。

• GICR_TYPER.DPGS == 1，且对于中断的中断组，GICR_CTLR.{DPG1S, DPG1NS, DPG0} == 0。

有关使用 1 of N 分发模型时 PE 是否可以被选择为目标的更多信息，请参见 GICR_CTLR，Redistributor 控制寄存器第 12-621 页 。

有关启用中断和中断组的更多信息，请参见 启用中断分发 。

2.3.3 更改亲和性路由使能

本手册描述了在启用亲和性路由的系统中的 GICv3 架构。这意味着：

• GICD_CTLR.ARE_NS == 1。

• GICD_CTLR.ARE_S == 1。

如果 GICD_CTLR.ARE_NS 或 GICD_CTLR.ARE_S 的值从 1 更改为 0，结果是 UNPREDICTABLE。

当 GICD_CTLR.DS == 0 时：

• 将 GICD_CTLR.ARE_S 从 0 更改为 1 是不可预测的，除非以下所有条件都适用：

  • GICD_CTLR.EnableGrp0 == 0。

  • GICD_CTLR.EnableGrp1S == 0。

  • GICD_CTLR.EnableGrp1NS == 0。

• 将 GICD_CTLR.ARE_NS 从 0 更改为 1 是不可预测的，除非 GICD_CTLR.EnableGrp1NS == 0。

当 GICD_CTLR.DS == 1 时：

• 将 GICD_CTLR.ARE 从 0 更改为 1 是不可预测的，除非以下所有条件都适用： — GICD_CTLR.EnableGrp0 == 0。

  • GICD_CTLR.EnableGrp1 == 0。

注意 清除 GICD_CTLR.EnableGrp0、GICD_CTLR.EnableGrp1S 或 GICD_CTLR.EnableGrp1NS（视情况而定）的效果必须在将 GICD_CTLR.ARE_S 或 GICD_CTLR.ARE_NS 从 0 更改为 1 时可见。软件可以轮询 GICD_CTLR.RWP 来检查清除 GICD_CTLR.EnableGrp0、GICD_CTLR.EnableGrp1S 或 GICD_CTLR.EnableGrp1NS 位的写入是否已完成。

Chapter 3: GIC 分区

• 本章描述 GIC 逻辑分区。包含以下部分： • GIC 逻辑组件 。

• 中断旁路支持 。

3.1 GIC 逻辑组件

GICv3 架构由一组逻辑组件组成：

• 一个 Distributor 。

• 每个支持的 PE 的一个 Redistributor。

• 每个支持的 PE 的一个 CPU interface。

• Interrupt Translation Service 组件（ITS），支持事件到 LPI 的可选转换。

Distributor、Redistributor 和 ITS 统称为 IRI。

图 3-1 显示了 IRI。

b. 每个 PE 有一个 Redistributor。c. 每个 PE 有一个 CPU interface。

图 3-1 中断路由基础设施 CPU interface 处理所有已实现异常级别的物理中断：

• 转换为 LPI 的中断可选择通过 ITS 路由到 Redistributor 和 CPU interface。

• PPI 直接从源路由到本地 Redistributor。

• SPI 从源通过 Distributor 路由到目标 Redistributor 和关联的 CPU interface。

• SGI 由软件通过 CPU interface 和 Redistributor 生成。然后通过 Distributor 路由到一个或多个目标 Redistributor 和关联的 CPU interface。

在 GICv3 中，ITS 是可选组件，将事件转换为物理 LPI。该架构还支持不需要使用 ITS 的直接 LPI。当支持 LPI 时，IMPLEMENTATION DEFINED 是否支持以下任一种：

• 通过访问 Redistributor 中的寄存器支持直接 LPI。

• 通过 ITS 提供 LPI 支持。

实现必须仅支持这些方法中的一种。

在 GICv4 中，必须包含至少一个 ITS 来提供对虚拟 LPI 直接注入的支持。 图 3-2 显示了包含 ITS 的实现中的 GIC 分区。

图 3-2 带有 ITS 的 GIC 逻辑分区

ITS 和 Redistributor 之间的通信机制是 IMPLEMENTATION DEFINED。

CPU interface 和 Redistributor 之间的通信机制也是 IMPLEMENTATION DEFINED。

注意 Arm 建议实现使用 GIC Stream 协议在 CPU interface 和 Redistributor 之间通信，请参见附录 A GIC Stream 协议接口 。

图 3-3 显示了不包含 ITS 且支持直接 LPI 的实现中的 GIC 分区。 3.1 GIC 逻辑组件

以下列表更详细地描述了图 3-2 中描绘的组件：

Distributor

Distributor 对 SPI 和 SGI 进行中断优先级排序和分发到连接到系统中 PE 的 Redistributor 和 CPU interface。GICD_CTLR 提供以下全局设置：

• 启用亲和性路由。

• 禁用安全性。

• 启用 Secure 和 Non-secure Group 1 中断。

• 启用 Group 0 中断。

对于 SPI，Distributor 提供编程接口用于：

• 启用或禁用 SPI。

• 设置每个 SPI 的优先级。

• 每个 SPI 的路由信息。

• 将每个 SPI 设置为电平敏感或边沿触发。

• 生成基于消息的 SPI。

• 将每个 SPI 分配给中断组。

• 控制 SPI 的待处理和活动状态。

Distributor 寄存器以 GICD_ 前缀标识。

有关更多信息，请参见第 2 章 中断分发和路由 。

注意 在传统操作期间处理物理中断时，Distributor 控制 PPI 和 SGI 的配置信息。请参见第 14 章 传统操作和非对称配置 。

中断转换服务，ITS

ITS 是 GICv3 架构中的可选硬件机制，将 LPI 路由到适当的 Redistributor。软件使用命令队列配置 ITS。与 ITS 关联的内存中的表结构将与设备关联的 EventID 转换为 PE 的待处理 INTID。

ITS 在 GICv4 中不是可选的，所有 GICv4 实现必须包含至少一个 ITS。

有关更多信息，请参见 中断转换服务 。

Redistributor Redistributor 是连接到 PE 的 CPU interface 的 IRI 部分。Redistributor 使用内存中保存的数据结构保存所有物理 LPI 的控制、优先级和待处理信息。Redistributor 中的两个寄存器指向这些数据结构：

• GICR_PROPBASER。

• GICR_PENDBASER。

在 GICv4 中，Redistributor 还包含寄存器来处理由 ITS 转发到 Redistributor 并直接转发到 VM 的虚拟 LPI，而无需涉及 hypervisor。这被称为虚拟中断的 直接注入 到 VM。

在 GICv4 中，Redistributor 共同托管所有虚拟 LPI 的控制、优先级和待处理信息，使用内存中保存的数据结构。Redistributor 中的两个寄存器指向这些数据结构：

• GICR_VPROPBASER。

• GICR_VPENDBASER。

在支持 LPI 但不包含 ITS 的实现中，GICR_* 寄存器包含简单的内存映射接口来信号和控制物理 LPI。

Redistributor 提供编程接口用于：

• 识别、控制和配置支持的功能以启用中断和实现的中断路由。

• 启用或禁用 SGI 和 PPI。

• 设置 SGI 和 PPI 的优先级。

• 将每个 PPI 设置为电平敏感或边沿触发。

• 将每个 SGI 和 PPI 分配给中断组。

• 控制 SGI 和 PPI 的待处理状态。

• 控制 SGI 和 PPI 的活动状态。

• 连接的 PE 的电源管理支持。

• 当支持 LPI 时，支持关联中断属性及其待处理状态的内存中数据结构的基地址控制。

• 当支持 GICv4 时，支持关联虚拟中断属性及其待处理状态的内存中数据结构的基地址控制。

Redistributor 寄存器以 GICR_ 前缀标识。

有关 Redistributor 的更多信息，请参见 亲和性路由 和 Distributor 和 Redistributor 。

CPU interface

GIC 架构支持向系统中的 PE 提供寄存器接口的 CPU interface。每个 CPU interface 提供编程接口用于：

• 通用控制和配置，根据实现的安全状态和传统支持要求启用中断处理。

• 确认中断。

• 执行优先级下降。

• 中断的停用。

• 为 PE 设置中断优先级掩码。

• 为 PE 定义抢占策略。

• 确定 PE 的最高优先级待处理中断。

CPU interface 有几个组件：

• 允许监管级别软件控制物理中断处理的组件。与此关联的寄存器以 ICC_ 前缀标识。

• 允许监管级别软件控制虚拟中断处理的组件。与此关联的寄存器以 ICV_ 前缀标识。

• 允许 hypervisor 控制待处理中断集的组件。与此关联的寄存器以 ICH_ 前缀标识。

注意 CPU interface 中的系统寄存器与处理物理域中中断的软件相关联，或与作为 VM 一部分在 Non-secure EL1 执行相关联。HCR_EL2 的配置确定访问是针对物理资源还是虚拟资源。

在 EL2 访问的用于控制 PE 的活动、待处理以及活动和待处理虚拟中断列表的系统寄存器以 ICH_ 前缀标识。

有关处理物理中断的更多信息，请参见第 4 章 物理中断处理和优先级 。

有关处理虚拟中断的更多信息，请参见第 6 章 虚拟中断处理和优先级 。

3.2 中断旁路支持

CPU interface 可选择包含中断信号旁路，以便当接口的中断信号被禁用时，传统中断信号传递到 PE 上的中断请求输入，绕过 GIC 功能。

是否支持旁路是 IMPLEMENTATION DEFINED。

确定是否使用 GICv3 FIQ 和 IRQ 输出或旁路信号的控制因是否启用系统寄存器访问而异。

当启用系统寄存器访问时，在最高实现异常级别使用 ICC_SRE_EL1、ICC_SRE_EL2 或 ICC_SRE_EL3 中的两个位来控制旁路禁用，视情况而定：

• 对于 FIQ 旁路，这是 DFB 位。

• 对于 IRQ 旁路，这是 DIB 位。

当启用系统寄存器访问时使用此旁路机制。有关传统操作期间旁路支持的信息，请参见 传统操作和旁路支持 。

GIC 支持的中断组分配给 FIQ 和 IRQ，如 中断分组 中所述。当启用旁路时，必须在 CPU interface 禁用中断组，否则 GICv3 实现的行为是 UNPREDICTABLE。这意味着：

• 当 ICC_SRE_ELx.DFB == 0 时，ICC_IGRPEN0_EL1.Enable 必须为 0。

• 当 ICC_SRE_ELx.DIB == 0 时，ICC_IGRPEN1_EL1.Enable 必须为 0。

有关启用中断的更多信息，请参见 启用中断分发 。

有关未启用系统寄存器访问时行为的信息，请参见第 14 章 传统操作和非对称配置 。

对于 FIQ，以下伪代码确定向 PE 发送中断信号的源。

if ICC_SRE_EL3.SRE == 1 then
    if ICC_SRE_EL3.DFB == 0 then
        if ICC_SRE_EL1.SRE Secure == 1 then
            BypassFIQsource
        else
            use legacy bypass support
    else
        use GICv3 FIQ output
else
    use legacy bypass support

对于 IRQ，以下伪代码确定向 PE 发送中断信号的源。

if ICC_SRE_EL3.SRE == 1 then
    if ICC_SRE_EL3.DIB == 0 then
        if ICC_SRE_EL1.SRE Secure == 1 then
            BypassIRQsource
        else
            use legacy bypass support
    else
        use GICv3 IRQ output
else
    use legacy bypass support

第4章：物理中断处理和优先级

本章描述了GIC中断处理和优先级的基本方面。它包含以下部分：

• 中断生命周期。

• 局部特定外设中断。

• 私有外设中断。

• 软件生成中断。

• 共享外设中断。

• 中断分组。

• 启用中断分发。

• 中断优先级。

4.1 中断生命周期

GIC中断处理基于GIC中断生命周期，这是一系列适用于使用GIC架构的任何中断的高级流程。中断生命周期为描述中断处理过程的详细步骤提供了基础。GIC还维护一个状态机，在生命周期期间控制中断状态转换。

图4-1显示了物理中断的GIC中断生命周期。

图4-1中的中断生命周期如下：

1. 生成中断。中断由外设或软件生成。

2. 分发。IRI执行中断分组、中断优先级处理，并控制中断向CPU interface的转发。

3. 投递。物理CPU interface将中断投递到对应的PE。

4. 激活。当在PE上运行的软件确认一个中断时，GIC将最高活跃优先级设置为被激活中断的优先级，对于SPI、SGI和PPI，中断变为活跃状态。

5. 优先级下降。在PE上运行的软件向GIC发出信号，表示最高优先级中断已处理到可以下降运行优先级的程度。运行优先级然后具有中断确认之前的值。这是中断处理程序指示中断结束的点。中断结束也可以配置为同时执行中断去激活。

6. 去激活。去激活清除中断的活跃状态，从而允许中断在挂起时再次被获取。LPI不需要去激活。去激活可以配置为与优先级下降同时发生，或者可以配置为稍后作为显式中断去激活操作的结果发生。后一种方法允许软件架构在将中断处理分为初始处理和调度处理方面有优势。

4.1.1 物理CPU interface

CPU interface为连接到GIC的PE提供接口。每个CPU interface连接到单个PE。

CPU interface接收由IRI优先级处理的挂起中断，并确定中断是否是在CPU interface中启用的组的成员，以及是否具有足够的优先级以向PE发送信号。在任何时候，连接的PE都可以确定：

• 其最高优先级挂起中断的INTID，通过读取ICC_HPPIR0_EL1或ICC_HPPIR1_EL1。

• CPU interface的运行优先级，通过读取ICC_RPR_EL1。

注意

尚未进行优先级下降的最高优先级活跃中断的优先级也称为运行优先级。

当确认LPI时，中断的挂起状态在Redistributor中变为非挂起。Redistributor不为LPI维护活跃状态。

当PE在CPU interface确认SGI、PPI或SPI时，如果满足以下条件，IRI将中断状态更改为活跃：

• 它是边缘触发中断，并且自中断确认以来没有检测到另一个边缘。

• 它是电平敏感中断，并且自中断确认以来电平已去断言。

当PE在CPU interface确认SGI、PPI或SPI时，如果满足以下条件，IRI将中断状态更改为活跃和挂起：

• 它是边缘触发中断，并且自中断确认以来检测到另一个边缘。

• 它是电平敏感中断，并且自中断确认以来电平未去断言。

当PE在CPU interface确认SGI、PPI或SPI时，CPU interface可以向PE发送另一个中断信号，以抢占在PE上活跃的中断。如果没有具有足够优先级向PE发送信号的挂起中断，interface去断言向PE的中断请求信号。

中断生命周期的以下阶段在本节的其余部分中描述：

• 激活。

• 优先级下降。

• 去激活。

优先级下降和去激活可以作为单个操作执行，也可以分开，由ICC_CTLR_EL1.EOImode和ICC_CTLR_EL3.EOImode_EL3定义。

激活

中断处理程序读取相应CPU interface中Group 0中断的ICC_IAR0_EL1和Group 1中断的ICC_IAR1_EL1来确认中断。这个读取返回以下之一：

• 最高优先级挂起中断的INTID，如果该中断具有足够的优先级向PE发送信号。这是对中断确认的正常响应。

• 在特定条件下，指示特殊中断号的INTID，参见_INTID_。

读取ICC_IAR0_EL1和ICC_IAR1_EL1是否返回有效INTID取决于：

• 访问的是这两个寄存器中的哪一个。

• PE的Security状态。

• 是否有具有足够优先级向PE发送信号的挂起中断，如果有，是否：

  • 最高优先级挂起中断是Secure Group 1或Non-secure Group 1中断。

  • 该中断组的中断信号发送已启用。

• PE执行的Exception level。

所有中断在确认时都会修改_Active Priorities Registers_。参见_系统寄存器访问Active Priorities寄存器_。

在某些情况下，SCR_EL3.NS的值影响PE确认中断时返回的值。也就是说，当PE在EL3执行时，ICC_IAR0_EL1的Secure读取返回一个特殊中断号，指示最高优先级挂起中断所需的Security状态转换。否则，返回INTID。

对于多处理器实现中的SGI，GIC使用目标列表模型，其中一个PE确认中断对其他CPU interface上的中断状态没有影响。当PE确认中断时，中断的挂起状态仅对该PE清除。中断对其他PE保持挂起。

读取ICC_IAR0_EL1和ICC_IAR1_EL1对返回INTID状态的影响在DSB执行之后才保证可见。

优先级下降

中断确认后，对Group 0中断的ICC_EOIR0_EL1的有效写入，或对Group 1中断的ICC_EOIR1_EL1的有效写入，导致优先级下降。

对ICC_EOIR0_EL1或ICC_EOIR1_EL1的有效写入以执行优先级下降对于每个确认的中断都是必需的，即使对于没有活跃状态的LPI也是如此。优先级下降必须由激活中断的同一个PE执行。

注意 有效写入是满足以下条件的写入：

• 不是UNPREDICTABLE。

• 不被忽略。

• 不是写入不支持的或在1020-1023范围内的INTID。

对于每个CPU interface，GIC架构要求对ICC_EOIR0_EL1和ICC_EOIR1_EL1的有效写入的顺序与从ICC_IAR0_EL1和ICC_IAR1_EL1的读取顺序完全相反，如图4-2所示。

在优先级下降时，运行优先级从由写入ICC_EOIR0_EL1或ICC_EOIR1_EL1指示的中断的优先级降低到：

• 尚未写入ICC_EOIR0_EL1或ICC_EOIR1_EL1的最高优先级活跃中断的优先级。

• 如果没有活跃中断，则为空闲优先级0xFF。

注意 为了与GIC架构规范的可能扩展兼容，软件在确认中断时必须保留从ICC_IAR0_EL1和ICC_IAR1_EL1读取的整个寄存器值，并使用该整个值由同一PE对ICC_EOIR0_EL1和ICC_EOIR1_EL1进行相应写入。

当GICD_CTLR.DS == 0时：

• 对ICC_EOIR0_EL1的写入为Group 0中断执行优先级下降。

• 如果PE在Non-secure状态或EL3操作，对ICC_EOIR1_EL1的写入为Non-secure Group 1中断执行优先级下降。

• 在Secure状态操作时，对ICC_EOIR1_EL1的写入为Secure Group 1中断执行优先级下降。

当GICD_CTLR.DS == 1时：

• 对ICC_EOIR0_EL1的写入为Group 0中断执行优先级下降。

• 对ICC_EOIR1_EL1的写入为Group 1中断执行优先级下降。

去激活

PPI、SGI和SPI在IRI中有活跃状态，必须被去激活。

SGI和PPI必须由激活中断的PE去激活。SPI可以由不同的PE去激活。

中断去激活需要将中断状态更改为：

• 从活跃和挂起变为挂起。

• 从活跃变为非活跃。

根据Exception level和Security状态，适当CPU Interface Control Register中的ICC_CTLR_EL1.EOImode和ICC_CTLR_EL3.EOImode_EL3确定优先级下降和中断去激活是一起发生还是分别发生：

• 当CPU interface中的ICC_CTLR_EL1.EOImode或ICC_CTLR_EL3.EOImode_EL3为0时，优先级下降和中断去激活一起发生，PE写入ICC_EOIR0_EL1或ICC_EOIR1_EL1。在这种情况下，不需要写入ICC_DIR_EL1。

• 当CPU interface中的ICC_CTLR_EL1.EOImode或ICC_CTLR_EL3.EOImode_EL3为1时，优先级下降和中断去激活分离，PE写入ICC_EOIR0_EL1或ICC_EOIR1_EL1。在这种情况下：

  • 当PE写入ICC_EOIR0_EL1或ICC_EOIR1_EL1时发生优先级下降。

  • 中断去激活稍后发生，当PE写入ICC_DIR_EL1时。对ICC_DIR_EL1的有效写入导致Group 0或Group 1中断的中断去激活。

对ICC_DIR_EL1的写入没有排序要求。如果软件在以下条件为真时写入ICC_DIR_EL1，结果是不可预测的：

• 适当的EOIMode位清除为0。

• ICC_CTLR_EL1.EOImode或ICC_CTLR_EL3.EOIMode_EL3设置为1，并且没有对ICC_EOIR0_EL1或ICC_EOIR1_EL1进行相应写入。

当ICC_CTLR_EL1.EOImode或ICC_CTLR_EL3.EOIMode_EL3 == 1但中断在Distributor中不活跃时，对ICC_DIR_EL1的写入必须被忽略。如果支持，实现可能生成系统错误。

表4-1显示了写入ICC_EOIR0_EL1或ICC_EOIR1_EL1如何影响去激活。

表4-1 写入ICC_EOIR0_EL1或ICC_EOIR1_EL1的影响

当GICD_CTLR.DS == 0时，对某些寄存器的访问受到限制。参见_中断分组和安全性_。

以下伪代码确定是否为当前Exception level和Security状态设置EOImode：

// EOImodeSet()
// ============

boolean EOImodeSet()

     if HaveEL(EL3) then
         // EL3 is implemented so return the value appropriate to the EL and security state
         if IsEL3OrMon() && ICC_SRE_EL3.SRE == '1'1 then
             // In EL3
             EOImode = ICC_CTLR_EL3.EOImode_EL3;

         elsif IsSecure() then
             EOImode = ICC_CTLR_EL3.EOImode_EL1S;

         else                                                  // Non-secure
              EOImode = ICC_CTLR_EL3.EOImode_EL1NS;
     else
         // No EL3 so return the value from ICC_CTLR_EL1
         EOImode = ICC_CTLR_EL1.EOImode;

     return EOImode == '1';

Security状态对ICC_DIR_EL1写入的影响

对ICC_DIR_EL1的写入的影响取决于GIC是否支持一个或两个Security状态：

• 如果GICD_CTLR.DS == 0，有效的：

  - 对ICC_DIR_EL1的Secure写入去激活指定的中断，无论该中断是Group 0还是Group 1中断。
  

  • 对ICC_DIR_EL1的Non-secure写入仅在该中断是Non-secure Group 1中断时才去激活指定的中断。

• 如果GICD_CTLR.DS == 1，对ICC_DIR_EL1的有效写入去激活指定的中断，无论该中断是Group 0还是Group 1中断。

表4-2显示了对ICC_DIR_EL1的有效写入的行为。在仅支持单个Security状态的实现中，有效写入具有对ICC_DIR_EL1的Secure写入所示的行为。

表4-2 对ICC_DIR_EL1写入的行为

只有当SCR_EL3.EEL2 == 1时，才能进入Secure EL2。

4.1.2 中断处理状态机

GIC为每个支持的中断维护状态机。中断的可能状态是：

• 非活跃。

• 挂起。

• 活跃。

• 活跃和挂起。

PPI、SGI和SPI可以具有活跃和挂起状态。活跃和挂起的中断永远不会向连接的PE发送信号。

LPI具有保存在与Redistributor相关联的内存中的挂起状态，因此也与PE相关联。这也适用于直接注入的虚拟LPI，参见_关于GICv4.0虚拟局部特定外设中断支持_。

注意 LPI没有活跃或活跃和挂起状态。

图4-3显示了中断处理状态机的实例和可能的状态转换。

a. 当GICD_CTLR.nASSGIreq==1时不适用于SGI，
对LPI也不适用。 图4-3 中断处理状态机

注意 LPI在Redistributor中没有活跃状态，但在CPU interface中需要活跃优先级。参见第5章_局部特定外设中断和ITS_获取更多信息。

Arm期望硬件实现报告GICD_TYPER2.nASSGIcap==0，表示GICD_CTLR.nASSGIreq为RES0。

当Distributor的中断转发和CPU interface的中断信号发送启用时，引起每个状态转换的条件如下：

转换A1或A2，添加挂起状态

当中断变为挂起时发生此转换，要么是由于外设生成中断，要么是由于软件生成中断。

转换B1或B2，移除挂起状态

当中断被外设去断言时（如果中断是电平敏感中断），或当软件更改挂起状态时，发生此转换。

对于LPI，它也在中断确认时发生。

转换C，挂起到活跃

对于边缘触发的SPI、SGI和PPI，此转换在PE确认中断时发生。

对于SPI、SGI和PPI，此转换在软件从ICC_IAR0_EL1或ICC_IAR1_EL1读取INTID值时发生。

转换D，挂起到活跃和挂起

对于电平敏感的SPI、SGI和PPI，此转换在PE确认中断时发生。

转换E1或E2，移除活跃状态

对于SPI、SGI和PPI，此转换在软件去激活中断时发生。

4.2 局部特定外设中断

LPI是目标外设中断，路由到亲和性层次结构内的特定PE。在启用两个Security状态的系统中，LPI始终是Non-secure Group 1中断。LPI仅支持边缘触发行为。有关LPI的更多信息，参见_LPI_。

4.3 私有外设中断

PPI是针对单个特定PE的中断，不同的PE可以使用相同的INTID来指示不同的事件。PPI可以是Group 0中断、Secure Group 1中断或Non-secure Group 1中断。它们可以支持边缘触发或电平敏感行为。

可选的扩展PPI范围使用INTID 1056 - 1119。当GIC在legacy mode操作时，此PPI范围不可用。GICR_TYPER.PPInum指示是否支持扩展PPI范围。

注意 通常，Arm期望PPI由每个PE上相同中断源的不同实例使用，从而允许为PE特定事件（例如来自私有定时器的中断）使用通用INTID。

4.4 软件生成中断

SGI通常用于处理器间通信，通过写入GIC中的SGI寄存器生成。SGI可以是Group 0或Group 1中断，它们只能支持边缘触发行为。

与SGI生成相关的寄存器是CPU interface的一部分：

• PE通过写入ICC_SGI1R_EL1或ICC_ASGI1R_EL1生成Group 1 SGI。

• PE通过写入ICC_SGI0R_EL1生成Group 0 SGI。

• 路由信息作为生成SGI的寄存器写入中的位域值提供。SGI可以路由到：

  • 由a.b.c.targetlist指定的PE组。这可以包括发起PE。

  • 系统中的所有参与PE，除了发起PE。

有关更多信息，参见_按PE亲和性路由SPI和SGI_。

ICC_SGI1R_EL1允许在Secure状态执行的软件生成Secure Group 1 SGI。

ICC_SGI1R_EL1允许在Non-secure状态执行的软件生成Non-secure Group 1 SGI。

ICC_ASGI1R_EL1允许在Secure状态执行的软件生成Non-secure Group 1 SGI。

ICC_ASGI1R_EL1允许在Non-secure状态执行的软件生成Secure Group 1 SGI，如果目标PE对应的Redistributor中的GICR_NSACR设置允许的话。

ICC_SGI0R_EL1允许在Secure状态执行的软件生成Group 0 SGI。

ICC_SGI0R_EL1允许在Non-secure状态执行的软件生成Group 0 SGI，如果目标PE对应的Redistributor中的GICR_NSACR设置允许的话。

有关使用控制寄存器将SGI转发到目标PE的更多信息，参见表12-14。

4.5 共享外设中断

SPI是外设中断，Distributor可以将其路由到可以处理中断的指定PE，或路由到系统中已配置为接受此类中断的一组PE中的一个PE。SPI可以是Group 0或Group 1中断，它们可以支持边缘触发或电平敏感行为。

可选的扩展SPI范围使用INTID 4096 - 5119。当GIC在legacy mode操作时，此SPI范围不可用。GICD_TYPER.ESPI指示是否支持扩展SPI范围。

SPI可以是基于线的或基于消息的中断。

对基于消息的SPI的支持是可选的，可以通过GICD_TYPER.MBIS发现。基于消息的SPI可以是：

• 通过写入GICD_SETSPI_NSR或GICD_SETSPI_SR生成

• 通过写入GICD_CLRSPI_NSR或GICD_CLRSPI_SR清除。

写入这些寄存器的影响取决于目标SPI是否配置为边缘触发或电平敏感中断：

• 对于边缘触发中断，写入GICD_SETSPI_NSR或GICD_SETSPI_SR设置中断挂起。当中断被激活时，或通过写入GICD_CLRSPI_NSR、GICD_CLRSPI_SR或GICD_ICPENDR清除时，中断不再挂起。

• 对于电平敏感中断，写入GICD_SETSPI_NSR或GICD_SETSPI_SR设置中断挂起。它保持挂起直到通过写入GICD_CLRSPI_NSR或GICD_CLRSPI_SR去断言。如果中断在通过写入GICD_SETSPI_NSR或GICD_SETSPI_SR断言和通过写入GICD_CLRSPI_NSR或GICD_CLRSPI_SR去激活之间被激活，则中断变为活跃和挂起。

  • 对于电平敏感中断，写入GICD_ICPENDR对通过写入GICD_SETSPI_NSR或GICD_SETSPI_SR设置为挂起的中断是否有任何影响，或者写入GICD_CLRSPI_NSR或GICD_CLRSPI_SR对通过写入GICD_ISPENDR设置为挂起的中断是否有任何影响，是IMPLEMENTATION DEFINED。

  • 确认通过写入GICD_ISPENDR设置为挂起的中断是否清除挂起状态是IMPLEMENTATION DEFINED。

• 当有挂起中断时将中断配置从电平敏感更改为边缘触发，或从边缘触发更改为电平敏感，会使中断处于UNKNOWN状态。

图4-4显示基于消息的中断请求如何触发SPI。

图4-4 触发SPI

4.6 中断分组

GICv3使用_中断分组_作为将中断处理与Armv8 Exception模型和Security模型对齐的机制。

在具有两个Security状态的系统中，中断配置为以下之一：

• Group 0物理中断：

  • Arm期望这些中断在EL3处理。

• Secure Group 1物理中断：

  • Arm期望这些中断在使用Secure虚拟化的系统中在Secure EL1或Secure EL2处理。

• Non-secure Group 1物理中断：

  • Arm期望这些中断在使用虚拟化的系统中在Non-secure EL2处理，或在不使用虚拟化的系统中在Non-secure EL1处理。

在具有一个Security状态的系统中，中断配置为：

• Group 0。

• Group 1。

在系统级别，GICD_CTLR.DS指示GIC是否配置为一个或两个Security状态。有关Security的更多信息，参见_中断分组和安全性_。

这些中断组映射到Armv8 FIQ和IRQ异常，参见_中断分配到IRQ和FIQ信号_。

GICD_IGROUPR和GICD_IGRPMODR配置SPI的中断组，GICD_IGROUPRE和GICD_IGRPMODRE配置扩展SPI范围的中断组。_n_大于零。

GICR_IGROUPR0和GICR_IGRPMODR0配置SGI和PPI的中断组，GICR_IGROUPRE和GICR_IGRPMODRE配置扩展PPI范围的中断组。_n_大于零。

注意

当GICD_CTLR.DS == 0时，LPI始终是Non-secure Group 1中断。当GICD_CTLR.DS == 1时，LPI始终是Group 1中断。

系统寄存器控制和配置Group 0和Group 1中断：

• 对于Group 0中断，软件使用：

  • ICC_IAR0_EL1在中断确认时读取Group 0 INTID。

  • ICC_EOIR0_EL1写入Group 0中断完成。

  • ICC_BPR0_EL1配置Group 0优先级的binary point。当ICC_CTLR_EL1.CBPR == 1时，此寄存器也用于Group 1优先级。

  • ICC_HPPIR0_EL1读取当前挂起的最高Group 0中断。

  • ICC_IGRPEN0_EL1在CPU interface启用Group 0中断。

• 对于Group 1中断，软件使用：

  • ICC_IAR1_EL1在中断确认时读取Group 1 INTID。

  • ICC_EOIR1_EL1写入Group 1中断完成。

  • ICC_BPR1_EL1为当前Security状态配置Group 1优先级的binary point。

  • ICC_HPPIR1_EL1读取当前挂起的最高Group 1中断。

  • ICC_IGRPEN1_EL1为中断的目标Security状态启用Group 1中断。

在具有两个Security状态的系统中，Group 0中断始终是Secure的。有关分组和Security的更多信息，参见_中断分组和安全性_。

4.6.1 中断分组和安全性

Arm架构提供两个Security状态，每个状态都有相关的物理内存地址空间：

• Secure状态。

• Non-secure状态。

用户和特权代码的软件层次结构可以在任一状态执行，在Non-secure状态执行的软件只能通过对Secure monitor的系统调用访问Secure状态。GIC架构支持与两个Security状态相关的中断的路由和处理。

GICD_CTLR.DS指示GIC是否配置为支持Armv8-A Security模型。此配置影响：

• 寄存器访问，参见_GIC系统寄存器访问_。

• 支持的中断组。

当GICD_CTLR.DS == 0时：

• GIC支持两个Security状态，Secure状态和Non-secure状态。

• GIC支持三个中断组：

  - Group 0。
  
  - Secure Group 1。
  

  • Non-secure Group 1。

• Security状态和GICR_NSACR都确定是否可以生成SGI。

• 在以下期间检查Security状态：

  - 中断配置。
  
  - 中断确认。
  

  • 优先级下降。

  • 去激活。

• 如果满足以下条件，Secure Group 1中断被CPU interface视为Group 0：

  • PE未实现EL3。

  • ICC_SRE_EL1(S).SRE == 0。

当GICD_CTLR.DS == 1时：

• GIC仅支持单个Security状态。这可以是Secure状态或Non-secure状态。

• GIC支持两个中断组：

  • Group 0。

  • Group 1。

• 无论GICR_NSACR中的设置如何，都可以生成SGI。

• 在以下期间不检查Security状态：

  • 中断配置。

  • 中断确认。

  • 优先级下降。

• 去激活。

在多处理器系统中，系统内的一个或多个PE可能支持访问仅在Secure状态可用的资源，或访问仅在Non-secure状态可用的资源。如果软件配置以下情况，这是编程错误：

• Group 0或Secure Group1中断转发到仅支持Non-secure状态的PE。

• Non-secure Group1中断转发到仅支持Secure状态的PE。

每个中断组都有专用的优先级分组寄存器，Group 0中断的ICC_BPR0_EL1和Group 1中断的ICC_BPR1_EL1。但是，可以使用以下方法为两个组配置通用Binary Point Register：

• ICC_CTLR_EL1.CBPR。

• ICC_CTLR_EL3.CBPR_EL1NS和ICC_CTLR_EL3.CBPR_EL1S用于Non-secure Group 1和Secure Group 1中断的独立通用Binary Point Register配置。

有关中断分组和legacy operation的信息，参见第14章_Legacy Operation和不对称配置_。

4.6.2 中断分配到IRQ和FIQ信号

本小节适用于启用亲和性路由的实现。

Group 0物理中断，当它是最高优先级挂起中断并具有足够优先级时，始终作为FIQ发送信号。

Group 1物理中断，当它是最高优先级挂起中断并具有足够优先级时，如果以下任一条件为真，则作为FIQ发送信号，否则作为IRQ发送信号：

• 它是另一个Security状态的中断，即PE未执行的Security状态。

• PE在EL3执行。

表4-3总结了EL3使用AArch64状态时的中断信号发送。

表4-3 EL3使用AArch64状态时两个Security状态的中断信号

表4-4总结了EL3使用AArch32状态时的中断信号发送。当EL3使用AArch32状态时，Secure EL2不存在。

表4-4 EL3使用AArch32状态时两个Security状态的中断信号

表4-5总结了仅支持单个Security状态的系统中的中断信号发送，即未实现EL3或GICD_CTLR.DS == 1。

表4-5 单个Security状态的中断信号

IRQ和FIQ的断言和去断言受PE的当前Exception level和Security状态影响。作为由于接受或从异常返回而发生的Context Synchronization的一部分，CPU interface确保IRQ和FIQ都适当地为PE进入的Exception level和Security状态断言或去断言。

注意 有关GICC_CTLR.FIQEn对不对称配置中中断信号发送的影响，参见_不对称配置_。

4.6.3 中断路由和系统寄存器访问

在AArch64状态执行时，到Exception level的中断路由由以下位控制：

• SCR_EL3.FIQ、SCR_EL3.NS和HCR_EL2.FMO控制FIQ。

• SCR_EL3.IRQ、SCR_EL3.NS和HCR_EL2.IMO控制IRQ。

此路由还控制控制和确认中断的EL1 CPU interface系统寄存器可访问的Exception level。这适用于：

• ICC_IAR0_EL1、ICC_EOIR0_EL1、ICC_HPPIR0_EL1、ICC_BPR0_EL1、ICC_AP0R_EL1和ICC_IGRPEN0_EL1。这些是与Group 0中断相关的寄存器。

• ICC_IAR1_EL1、ICC_EOIR1_EL1、ICC_HPPIR1_EL1、ICC_BPR1_EL1、ICC_AP1R_EL1和ICC_IGRPEN1_EL1。这些是与Group 1中断相关的寄存器。

• ICC_SGI0R_EL1、ICC_SGI1R_EL1、ICC_ASGI1R_EL1、ICC_CTLR_EL1、ICC_DIR_EL1、ICC_PMR_EL1和ICC_RPR_EL1。这些是通用寄存器。

当(SCR_EL3.NS == 1 || SCR_EL3.EEL2== 1) && (HCR_EL2.FMO ==1 || HCR_EL2.IMO == 1))时，EL1的访问是虚拟访问。对ICC_SGI0R_EL1、ICC_SGI1R_EL1和ICC_ASGI1R_EL1的虚拟访问始终生成被接受到EL2的Trap异常。

当Distributor支持两个Security状态时，PE可能不实现EL2或EL3。表4-6显示了这些情况下支持的配置。

表4-6 未实现EL3时支持的配置

4.7 启用中断分发

以下控制位启用和禁用中断分发：

• GICD_CTLR.EnableGrp1S。

• GICD_CTLR.EnableGrp1NS。

• GICD_CTLR.EnableGrp0。

以下控制位在CPU interface启用和禁用中断组的分发：

• ICC_IGRPEN0_EL1.Enable用于Group 0中断。

• ICC_IGRPEN1_EL1.Enable用于Group 1中断。

注意

• 此寄存器有Secure和Non-secure副本。

• ICC_IGRPEN1_EL3.{EnableGrp1S, EnableGrp1NS}。

通过写入GICR_CTLR.EnableLPIs启用物理LPI。

4.7.1 启用单个中断

PPI

当为中断的Security状态启用亲和性路由时，可以通过写入GICR_ISENABLER0和GICR_ICENABLER0启用和禁用PPI。如果支持并配置了物理中断的legacy operation，单个PPI也可以通过写入GICD_ISENABLER和GICD_ICENABLER启用和禁用。对于PPI，n = 0。

可选扩展PPI范围中的PPI通过写入GICR_ISENABLERE和GICD_ICENABLERE启用和禁用。

SPI

单个SPI可以通过写入GICD_ISENABLER和GICD_ICENABLER启用和禁用。对于SPI，n >0。

可选扩展SPI范围中的SPI通过写入GICD_ISENABLERE和GICD_ICENABLERE启用和禁用。

SGI

当启用亲和性路由时，SGI可以通过写入GICR_ISENABLER0和GICR_ICENABLER0启用和禁用。如果支持并配置了物理中断的legacy operation，单个SGI也可以通过写入GICD_ISENABLER和GICD_ICENABLER启用和禁用。对于SGI，n = 0。

注意 SGI是永久启用的，还是可以通过写入GICR_ISENABLER0和GICR_ICENABLER0启用和禁用，是IMPLEMENTATION DEFINED。

LPI

单个LPI可以通过设置LPI Configuration表中编程的启用位来启用。有关使用LPI Configuration表启用LPI的更多信息，参见_LPI配置表_。

4.7.2 组和单个中断启用的交互

GICD_*和GICR_*寄存器在任何时刻确定硬件为每个目标PE知晓的最高优先级挂起中断。此中断呈现给PE的CPU interface以评估是否向PE发送信号。中断启用影响此评估如下：

• 在GICD_*或GICR_*寄存器中单独禁用的挂起中断不是确定最高优先级挂起中断时考虑的中断，因此无法向PE发送信号。

• 在GICD_*或GICR_*寄存器中单独启用但在GICD_CTLR中是禁用组成员的挂起中断不是确定最高优先级挂起中断时考虑的中断，因此无法向PE发送信号。

• 在GICD_*寄存器中单独启用且在GICD_CTLR中是启用组成员但在PE的ICC_IGRPEN0_EL1、ICC_IGRPEN1_EL1或ICC_IGRPEN1_EL3中是禁用组成员的挂起1 of N中断无法为该PE选择。这样的中断在确定最高优先级挂起中断时不被考虑，因此无法向PE发送信号。

• 对于在GICD_*或GICR_*寄存器中单独启用且在GICD_CTLR中是启用组成员但在ICC_IGRPEN0_EL1、ICC_IGRPEN1_EL1或ICC_IGRPEN1_EL3中是禁用组成员的挂起直接中断，是否在确定最高优先级挂起中断时考虑该中断是IMPLEMENTATION DEFINED。如果确定为最高优先级挂起中断，中断不向PE发送信号，但将掩码在ICC_IGRPEN0_EL1、ICC_IGRPEN1_EL1或ICC_IGRPEN1_EL3中是启用组成员的较低优先级挂起中断。

LPI在LPI配置表中单独启用，参见_LPI配置表_。

4.7.3 禁用中断的影响

通过写入适当的GICD_ICENABLER或GICR_ICENABLER0，或通过写入LPI配置表禁用中断，不会阻止该中断更改状态，例如变为挂起。当GICR_CTLR.EnableLPIs == 0时，LPI永远不会设置为挂起。

如果GICD_CTLR.EnableGrp0、GICD_CTLR.EnableGrp1S和GICD_CTLR.EnableGrp1NS都清除为0，是否满足以下条件是IMPLEMENTATION DEFINED：

• 边缘触发中断信号将中断移动到挂起状态。

• 通过写入GICD_SGIR、ICC_SGI0R_EL1、ICC_SGI1R_EL1或ICC_ASGI1R_EL1可以设置SGI为挂起。

如果当相应的GICD_CTLR.EnableGrp0、GICD_CTLR.EnableGrp1NS或GICD_CTLR.EnableGrp1S位从1写入0时中断在CPU interface上挂起，则必须从CPU interface检索中断。

注意 如果中断已经被激活，这可能对转发的中断没有影响。

如果当软件将ICC_IGRPEN0_EL1.Enable、ICC_IGRPEN0_EL1、ICC_IGRPEN1_EL1.Enable或ICC_IGRPEN1_EL3.Enable从1写入0时中断在CPU interface上挂起，中断必须由CPU interface释放以允许Distributor将中断转发到不同的PE。

4.8 中断优先级

本节描述GIC架构中的中断优先级。优先级描述：

• 中断优先级的配置和控制。

• 挂起中断的执行顺序。

• 确定中断何时对目标PE可见，包括：

  • 中断优先级掩码。

  • 优先级分组。

  • 活跃中断的抢占。

软件通过为每个中断源分配优先级值在GIC中配置中断优先级。优先级值是8位无符号二进制数。支持两个Security状态的GIC实现必须实现最少32个和最多256个物理优先级。仅支持单个Security状态的GIC实现必须实现最少16个和最多256个物理优先级。如果GIC实现少于256个优先级，优先级字段的低位是RAZ/WI。这意味着实现的优先级字段位数是IMPLEMENTATION DEFINED，范围4-8。表4-7显示了优先级字段位与实现支持的优先级数量之间的关系。

表4-7 不实现某些优先级字段位的影响

在GIC优先级方案中，较小的数字具有较高的优先级。这意味着分配的优先级值越低，中断的优先级越高。优先级字段值0始终指示可能的最高中断优先级，最低优先级值取决于实现的优先级数量。

GICD_IPRIORITYR寄存器保存每个支持的SPI的优先级值。实现可能为特定目的保留SPI并为该中断分配固定优先级，意味着该中断的优先级值是只读的。对于其他SPI，GICD_IPRIORITYR寄存器可以由软件写入以设置中断优先级。写入GICD_IPRIORITYR是否更改任何活跃SPI的优先级是IMPLEMENTATION DEFINED。

在多处理器实现中，GICR_IPRIORITYR和GICR_IPRIORITYRE寄存器为每个目标PE独立定义每个SGI和PPI INTID的中断优先级。

内存中的LPI配置表和LPI挂起表存储LPI优先级信息和挂起状态，参见_LPI配置表_和_LPI挂起表_。

GIC安全模型为中断优先级设置提供Secure和Non-secure访问。Non-secure访问只能在支持的优先级值的较低优先级一半中配置中断。因此，如果GIC实现32个优先级值，Non-secure访问只看到16个优先级值。参见_中断优先级的软件访问_获取更多信息。

要确定SPI实现的优先级位数，软件可以向可写的GICD_IPRIORITYR优先级字段写入0xFF并读回存储的值。

要确定SGI和PPI实现的优先级位数，软件可以向GICR_IPRIORITYR优先级字段写入0xFF并读回存储的值。

GIC架构不要求系统中的所有PE使用相同数量的优先级位来控制中断优先级。

在多处理器实现中，ICC_CTLR_EL1.PRIbits和ICC_CTLR_EL3.PRIbits为每个目标PE独立指示实现的优先级位数。

注意 Arm建议实现为每个PE支持相同数量的优先级位。

有关虚拟中断支持的优先级范围的信息，参见第6章_虚拟中断处理和优先级_。

注意 Arm建议在以这种方式检查优先级范围之前：

• 对于外设中断，软件首先禁用中断。

• 对于SGI，软件首先检查中断是非活跃的。

如果在特定CPU interface上，多个挂起中断具有相同优先级，并且具有足够优先级供interface向PE发送信号，interface如何选择向哪个中断发送信号是IMPLEMENTATION DEFINED。

GICv3保证最高优先级、未掩码、启用的中断将在有限时间内投递到目标PE。

不保证较高优先级中断总是在较低优先级中断之前获取，尽管这通常是这种情况。

本节的其余部分描述：

• 对Secure中断优先级寄存器字段的Non-secure访问。

• 优先级分组。

• 对Active Priorities寄存器的系统寄存器访问。

• 抢占。

• 优先级掩码。

• 中断优先级的软件访问。

• 更改启用的PPI、SGI和SPI的优先级。

4.8.1 对Secure中断优先级寄存器字段的Non-secure访问

当GICD_CTLR.DS == 0时，GIC支持使用：

• Group 0中断作为Secure中断。

• Secure Group 1中断。

• Non-secure Group 1中断。

为了支持Armv8 Security模型，与Secure中断相关的寄存器字段对Non-secure访问是RAZ/WI。此外，以下规则适用：

对GICx_IPRIORITYR中优先级字段的Non-secure访问：

如果优先级字段对应于_中断优先级的软件访问_中的Non-secure Group 1中断：

• 对于SPI，优先级字段由GICD_IPRIORITYR或GICD_IPRIORITYRE确定。

• 对于PPI和SGI，优先级字段由GICR_IPRIORITYR或GICR_IPRIORITYRE确定。

当SCR_EL3.FIQ == 1时对ICC_PMR_EL1和ICC_RPR_EL1的Non-secure访问：

• 如果当前优先级掩码值在0x00-0x7F范围内：

  • 读访问返回值0x00。

• GIC忽略对ICC_PMR_EL1的写访问。

• 如果当前优先级掩码值在0x80-0xFF范围内：

• 读访问返回当前值的Non-secure读取。

• 基于写入寄存器的优先级掩码值的Non-secure读取，对ICC_PMR_EL1的写访问成功。

注意

这意味着Non-secure写入无法在0x00-0x7F范围内设置优先级掩码值。

当SCR_EL3.FIQ == 0时对ICC_PMR_EL1和ICC_RPR_EL1的Non-secure访问：

适用Secure、未移位视图。

_AArch64函数_提供了伪代码，描述了在支持两个Security状态的GIC中对以下系统寄存器的访问：

• ICC_PMR_EL1。

• ICC_RPR_EL1。

4.8.2 优先级分组

优先级分组使用以下_Binary Point Registers_：

• ICC_BPR0_EL1用于Group 0中断。此寄存器在所有GIC实现中可用。

• ICC_BPR1_EL1的Non-secure副本用于Non-secure Group 1中断。如果实现支持两个Security状态，此寄存器有Secure和Non-secure副本。如果实现仅支持一个Security状态，此寄存器只有一个副本。

• ICC_BPR1_EL1的Secure副本用于Secure Group 1中断。此寄存器仅在支持两个Security状态的GIC实现中可用。

Binary Point Registers将优先级值分为两个字段，组优先级_和_子优先级。在确定抢占时，具有相同组优先级的所有中断被认为具有相同优先级，无论子优先级如何。

当多个挂起中断具有相同组优先级时，GIC使用子优先级字段解决组内的优先级。当一组中有两个或更多挂起中断具有相同子优先级时，GIC如何在中断之间选择是实现特定的。

GIC使用组优先级字段确定挂起中断是否具有足够优先级抢占PE上的执行，如下：

• 中断的组优先级字段值必须低于PE的运行优先级值。运行优先级是该PE上尚未接收到优先级下降的最高优先级活跃中断的组优先级。

• 中断的优先级值必须低于其优先级掩码的值。

ICC_BPR0_EL1确定Group 0中断的优先级分组：

• 当ICC_CTLR_EL3.CBPR_EL1S设置为1时，ICC_BPR0_EL1也确定Secure Group 1中断的优先级分组。

• 当ICC_CTLR_EL3.CBPR_EL1NS设置为1时，ICC_BPR0_EL1也确定Non-secure Group 1中断的优先级分组。

ICC_BPR1_EL1确定Group 1中断的优先级：

• 当ICC_CTLR_EL3.CBPR_EL1S清除为0时，ICC_BPR1_EL1的Secure副本确定Secure Group 1中断的优先级分组。

• 当ICC_CTLR_EL3.CBPR_EL1NS清除为0时，ICC_BPR1_EL1的Non-secure副本确定Non-secure Group 1中断的优先级分组。

表4-8显示了Secure ICC_BPR1_EL1的中断优先级字段分割。

表4-8 当CBPR == 0时的Secure ICC_BPR1_EL1 Binary Point

表4-9显示了Non-secure ICC_BPR1_EL1的中断优先级字段分割。

表4-9 当CBPR == 0时的Non-secure ICC_BPR1_EL1 Binary Point

表4-10显示了ICC_BPR0_EL1的中断优先级字段分割。

表4-10 当CBPR == 1时Group 1中断或Group 0中断的ICC_BPR0_EL1 Binary Point

a. 如果Non-secure写入为Non-secure中断设置优先级值字段，则bit[7] == 1。

支持的最小binary point值取决于IMPLEMENTATION DEFINED的优先级位数，如表4-11所示。

表4-11 最小binary point值支持

实现的优先级位数由ICC_CTLR_EL1.PRIBits和ICC_CTLR_EL3.PRIBits指示。

在支持两个Security状态的GIC中，当：

• ICC_CTLR_EL3.CBPR_EL1S == 1：

  • 在Secure EL1对ICC_BPR1_EL1的写入修改ICC_BPR0_EL1。

  • 在Secure EL1从ICC_BPR1_EL1的读取返回ICC_BPR0_EL1的值。

• ICC_CTLR_EL3.CBPR_EL1NS == 1：

  • 对ICC_BPR1_EL1的Non-secure写入被忽略。

  • 从ICC_BPR1_EL1的Non-secure读取返回ICC_BPR0_EL1 + 1饱和到0b111。

注意

• 当中断使用Non-secure ICC_BPR1_EL1时，有效binary point值是存储在寄存器中的值减一，如表4-9所示。这意味着对中断分组影响没有意识且支持两个Security状态的软件，无论它是在Secure状态还是Non-secure状态的PE上运行，都会看到相同的优先级分组机制。

• 优先级分组总是对完整优先级操作，这是Secure读取可见的值。这与Non-secure读取对应于Non-secure中断的优先级值可见的值不同。参见图4-8和图4-9。

• 当EL3使用AArch32且ICC_MCTLR.CBPR_EL1S == 1时，在EL3且不在Monitor模式下对ICC_BPR1的访问访问ICC_BPR0的状态。

伪代码

以下伪代码指示中断的组优先级。

// GroupBits()
// ===========
// Returns the priority group field for the current BPR value for the group

bits(8) GroupBits(bits(8) priority, IntGroup group)
    bit cbpr_G1NS = if HaveEL(EL3) then ICC_CTLR_EL3.CBPR_EL1NS else ICC_CTLR_EL1.CBPR;
    bit cbpr_G1S = if HaveEL(EL3) then ICC_CTLR_EL3.CBPR_EL1S else '0';

    if (group == IntGroup_G0 ||
         (group == IntGroup_G1NS && cbpr_G1NS == '1') ||
         (group == IntGroup_G1S && cbpr_G1S == '1')) then
         bpr = UInt(ICC_BPR0_EL1.BinaryPoint);
    elsif group == IntGroup_G1S then
         bpr = UInt(ICC_BPR1_EL1S.BinaryPoint);
    else
         bpr = UInt(ICC_BPR1_EL1NS.BinaryPoint) -1;

    mask = Ones(7-bpr):Zeros(bpr+1);

    return priority AND mask;

4.8.3 系统寄存器访问Active Priorities寄存器

物理Group 0和Group 1中断访问不同的Active Priorities寄存器，取决于中断组。

对于Group 0中断，这些寄存器是ICC_AP0R_EL1，其中n = 0-3：

• 如果实现32个或更少的优先级，对ICC_AP0R_EL1的访问（其中n = 1-3）是UNDEFINED。

• 如果实现超过32个且少于65个优先级，对ICC_AP0R_EL1的访问（其中n = 2-3）是undefined。

对于Group 1中断，这些寄存器是ICC_AP1R_EL1，其中n= 0-3：

• 如果实现32个或更少的优先级，对ICC_AP1R_EL1的访问（其中n = 1-3）是undefined。

• 如果实现超过32个且少于65个优先级，对ICC_AP1R_EL1的访问（其中n = 2-3）是undefined。

ICC_AP0R_EL1、Secure ICC_AP1R_EL1和Non-secure ICC_AP1R_EL1的内容是IMPLEMENTATION DEFINED。但是，值0x00000000必须与没有优先级活跃一致。

向这些寄存器写入最后读取值或0x00000000以外的任何值都可能导致：

• 原本会抢占执行的中断不抢占执行。

• 原本不会抢占执行的中断抢占执行。

对Non-secure ICC_AP1R_EL1的Non-secure写入无法阻止正确的优先级处理，无法阻止比Non-secure优先级范围中更高优先级的中断转发。

按照除以下顺序外的任何顺序写入这些寄存器都可能导致UNPREDICTABLE行为：

1. ICC_AP0R_EL1。

2. Secure ICC_AP1R_EL1。

3. Non-secure ICC_AP1R_EL1。

注意 在每次写入ICC_AP0R_EL1、Secure ICC_AP1R_EL1和Non-secure ICC_AP1R_EL1之间不需要ISB。

表4-12显示了ICC_AP0R_EL1的实现。

表4-12 Group 0 Active Priorities Register实现

表4-13显示了ICC_AP1R_EL1的实现。

表4-13 Group 1 Active Priorities Register实现

4.8.4 抢占

CPU interface支持在活跃中断完成之前向目标PE发送更高优先级挂起中断的信号。挂起中断仅在以下两个条件都满足时才发送信号：

• 其优先级高于该CPU interface的优先级掩码。参见_优先级掩码_。

• 其组优先级高于CPU interface上的运行优先级。参见_优先级分组_获取更多信息。

抢占在PE接受新中断时发生，并开始处理新中断而不是先前活跃的中断或当前运行的进程。当这发生时，初始活跃中断被称为_被抢占_。

注意 Process State PSTATE中I或F位的值，以及Exception level和软件硬件中的中断路由控制，确定PE是否通过接受中断来响应发送信号的中断。有关更多信息，参见_Arm[®]架构参考手册，Armv8，针对Armv8-A架构配置文件_。

有关启用中断的更多信息，参见_启用中断分发_。

抢占级别控制

ICC_BPR0_EL1确定Group 0中断是否向PE发送信号以进行可能的抢占。此外：

• 当ICC_CTLR_EL3.CBPR_EL1NS == 1时，ICC_BPR0_EL1也确定Non-secure Group 1中断是否向PE发送信号以进行可能的抢占。

• 当ICC_CTLR_EL3.CBPR_EL1S == 1时，ICC_BPR0_EL1也确定Secure Group 1中断是否向PE发送信号以进行可能的抢占。

ICC_BPR1_EL1确定Group 1中断是否向PE发送信号以进行可能的抢占。此寄存器的Non-secure副本用于Non-secure Group 1中断。Secure副本用于Secure Group 1中断。

当ICC_CTLR_EL3.CBPR_EL1NS设置为1时：

• EL3可以写入ICC_BPR1_EL1(NS)。当EL3使用AArch64状态时，从EL3对ICC_BPR1_EL1(NS)的访问不受ICC_CTLR_EL3.CBPR_EL1NS影响。

  • 当EL3使用AArch32状态时，从Monitor模式对ICC_BPR1_EL1(NS)的访问不受ICC_CTLR_EL3.CBPR_EL1NS影响。

• 在EL1或EL2对ICC_BPR1_EL1的Non-secure写入被忽略。

• 在EL1或EL2对ICC_BPR1_EL1的Non-secure读取返回ICC_BPR0_EL1 +1的值，在7处饱和。

当ICC_CTLR_EL3.CBPR_EL1S设置为1时：

• ICC_BPR1_EL1的Secure读取返回ICC_BPR0_EL1的值。

• ICC_BPR1_EL1的Secure写入更新ICC_BPR0_EL1。

4.8.5 优先级掩码

CPU interface的_Priority Mask Register_ ICC_PMR_EL1为目标PE定义优先级阈值。GIC仅向目标PE发送具有高于此优先级阈值的优先级的挂起中断信号。零值（寄存器重置值）掩码所有中断向关联PE发送信号。GIC在将挂起中断的优先级与优先级阈值比较时不使用优先级分组。

GIC始终掩码具有最低支持优先级的中断。此优先级有时称为空闲优先级。

注意 向ICC_PMR_EL1写入0xFF总是将其设置为最低支持优先级。表4-7显示了最低支持优先级如何随实现的优先级位数变化。

如果GIC提供两个Security状态的支持，如果bit[7] == 0，ICC_PMR_EL1对Non-secure访问是RAZ/WI。在正常操作期间，在Non-secure状态执行的软件在用这样的值编程时不访问ICC_PMR_EL1。

有关与不同GIC配置相关的信息，参见_对Secure中断优先级寄存器字段的Non-secure访问_。

4.8.6 中断优先级的软件访问

本节描述中断优先级的Secure和Non-secure读取，以及它们之间的关系。它还描述对优先级值字段的写入。

注意 本节适用于任何支持两个Security状态的GIC实现。

当PE读取Non-secure Group 1中断的优先级值时，GIC返回该值的Secure或Non-secure读取，取决于访问是Secure还是Non-secure。

GIC实现最少32个和最多256个优先级。这意味着它实现了适当GICR_IPRIORITYR和GICD_IPRIORITYR寄存器中8位优先级值字段的5-8位。所有实现的优先级位都可以通过Secure访问访问，优先级字段的未实现低位是RAZ/WI。图4-5显示了中断优先级值字段的Secure读取。存储在Distributor中的优先级值等效于Secure读取。

图4-5 任何中断优先级字段的Secure读取

在此视图中：

• 位H-D是GIC必须实现的位，对应32个优先级。

• 位C-A是GIC可能实现的位。如果未实现，它们是RAZ/WI。

• GIC必须实现位H-A以提供最大256个优先级。

对于Non-secure访问，GIC支持它为Secure访问支持的一半优先级，这意味着最少16个优先级。图4-6显示了Non-secure Group 1中断的优先级值字段的Non-secure视图。

图4-6 Non-secure Group 1中断优先级字段的Non-secure读取

在此读取中：

• 位G-D是GIC必须实现的位，对应16个优先级。

• 位C-A是GIC可能实现的位，如果未实现则是RAZ/WI。

• GIC必须实现位G-A以提供最大128个优先级。

• 位[0]是RAZ/WI。

优先级值的Non-secure读取不显示值在Distributor的寄存器中如何存储。对于Non-secure Group 1中断优先级字段的Non-secure写入，在存储值之前：

• 值右移一位。

• 值的位[7]设置为1。

此转换意味着Non-secure Group 1中断的优先级值在优先级范围的下半部分。

中断优先级值的Secure读取返回存储在Distributor中的值。图4-7显示了由Non-secure访问设置优先级值字段或由Secure访问设置bit[7] == 1的优先级值的Non-secure Group 1中断的优先级值字段的Secure读取：

图4-7 Non-secure Group 1中断优先级字段的Secure读取

Non-secure Group 1中断优先级值字段的Secure写入可以将位[7]设置为0。如果Secure写入将bit[7]设置为0：

• Non-secure读取返回值GFEDCBA0。

• Non-secure写入可以更改字段的值，但只能更改为字段的Secure读取具有位[7]设置为1的值。

注意

• Non-secure访问的此行为仅适用于GICR_IPRIORITYR和GICD_IPRIORITYR中的优先级值字段，适当时：

  • 如果ICC_PMR_EL1中的Priority字段保存位[7] == 0的值，则该字段对Non-secure访问是RAZ/WI。

  • 如果ICC_RPR_EL1中的Priority字段保存位[7] == 0的值，则该字段对Non-secure读取是RAZ。

• Arm不建议以这种方式为Non-secure Group 1中断将bit[7]设置为0，因为它将中断放在错误的优先级范围一半中以供non-secure代码维护。

图4-8显示了Non-secure Group 1中断优先级值字段读取之间的关系。

图4-9显示了来自Secure和Non-secure访问的中断优先级的软件读取如何与Distributor中保存的优先级值，以及Secure和Non-secure访问可见的中断值相关。图4-9适用于实现最大优先级值范围的GIC。

表4-14显示了GIC实现的优先级值位数如何影响Non-secure Group 1中断优先级的Secure和Non-secure读取。

注意 在Non-secure状态执行的软件无法看到Group 0中断或（如果适用）Secure Group 1中断的优先级设置。

表4-14 不实现某些优先级字段位的影响，两个Security状态

| 由Secure读取看到的实现优先级位 [7:0] | Non-secure Group 1中断的可能优先级字段值 Secure读取 Non-secure读取 | |—|— 0xFF-0x00(255-0)，所有值 0xFE-0x00(254-0)，仅偶数值 | | [7:1] | 0xFE-0x00(254-0)，仅偶数值 0xFC-0x00(252-0)，步长为4 | | [7:2] | 0xFC-0x00(252-0)，步长为4 0xF8-0x00(248-0)，步长为8 | | [7:3] | 0xF8-0x00(248-0)，步长为8 0xF0-0x00(240-0)，步长为16 |

此优先级值表示模型确保编写为与此GIC架构实现一起操作的软件按预期功能，无论GIC是否提供两个Security状态的支持。但是，程序员必须确保软件为Group 0和Group 1中断分配适当的优先级。

注意 为了控制优先级值，Arm强烈建议：

• 对于Group 0中断，软件将优先级值字段的bit[7]设置为0。
• 如果使用Secure写入设置Non-secure Group 1中断的优先级，软件将优先级值字段的bit[7]设置为1。

这确保所有Group 0和（如果适用）Secure Group 1中断具有比所有Non-secure Group 1中断更高的优先级。但是，系统可能有无法用此方案满足的要求。

表4-15显示了确保以下的示例优先级分配方案：

• 一些Group 0中断具有比任何其他中断更高的优先级。

• 一些Secure Group 1中断具有比任何Non-secure Group 1中断更高的优先级。

表4-15 示例优先级分配

• 软件可能不知道GIC支持两个Security状态，因此可能不知道它是否对GIC寄存器进行Secure或Non-secure访问。但是，对于任何实现的中断，软件可以向相应的GICR_IPRIORITYR优先级值字段写入0xFF，然后读回存储在字段中的值以确定支持的中断优先级范围。Arm建议在以这种方式检查优先级范围之前：

  • 对于外设中断，软件首先禁用中断。

• 对于SGI，软件首先检查中断是非活跃的。

4.8.7 更改启用的PPI、SGI和SPI的优先级

如果软件在中断挂起时写入启用中断的GICD_IPRIORITYR、GICD_IPRIORITYRE、GICR_IPRIORITYR和GICR_IPRIORITYRE寄存器，GIC使用旧值还是新值是IMPLEMENTATION DEFINED。GIC确保没有中断被处理超过一次，没有中断丢失。写入的影响必须在有限时间内可见。

第 5 章：本地性特定外设中断和 ITS

本章描述了_本地性特定外设中断_（LPI）和_中断转换服务_（ITS）。包含以下章节：

• LPI。

• 中断转换服务。

• ITS 命令。

• 通用 ITS 伪代码函数。

• ITS 命令错误编码。

• ITS 电源管理。

5.1 LPI

本地性特定外设中断（LPI）是边沿触发的基于消息的中断，如果实现了_中断转换服务_（ITS），则可以使用 ITS 将中断路由到特定的 Redistributor 和连接的 PE。GICv3 为 LPI 提供两种类型的支持。LPI 可以通过以下任一方式支持：

• 使用 ITS 将来自设备的 EventID 转换为 LPI INTID。有关 EventID 的更多信息，请参见_中断转换服务_。

• 通过使用 GICR_SETLPIR 直接将 LPI INTID 转发到 Redistributor。

实现必须只支持这些方法中的一种。

注意

在支持 LPI 但不包含 ITS 的实现中，以下寄存器是强制性的：

• GICR_INVLPIR。

• GICR_INVALLR。

• GICR_SYNCR。

在确实包含 ITS 的实现中，对这些寄存器的支持是 IMPLEMENTATION DEFINED 的。

这些寄存器控制不包含 ITS 的系统中的物理 LPI：

• GICR_SETLPIR。

• GICR_CLRLPIR。

在包含 LPI 的实现中，至少支持 8192 个 LPI。因此，每个中断的配置和每个中断的挂起信息保存在内存中的表中，而不是寄存器中，这些表由保存在 Redistributor 中的寄存器指向。

注意

• Arm 期望实现将在 Redistributor 中缓存表的部分内容，以减少延迟和内存流量。这些缓存的形式是 IMPLEMENTATION DEFINED 的。

• LPI 表的地址在 Non-secure 物理地址空间中。

图 5-1 显示了在包含至少一个 ITS 的实现中 LPI 的生成。

图 5-1 在带有 ITS 的实现中触发 LPI

注意 在图 5-1 中，ITS 到 Redistributor 的通道是 IMPLEMENTATION DEFINED 的。

图 5-2 显示了在没有 ITS 的实现中 LPI 的生成。 5.1 LPI

Message-based interrupts

• 只有在为 Non-secure 状态启用亲和性路由时才支持 LPI。

• LPI 总是 Non-secure Group 1 中断。

当 GICD_CTLR.DS == 1 时：

• 只有在启用亲和性路由时才支持 LPI。

• LPI 总是 Group 1 中断。

有一个单一的全局物理 LPI 空间，以便 LPI 可以在所有 Redistributor 之间移动。软件使用 GICR_PROPBASER.IDbits 编程单一全局物理 LPI 空间的大小。

注意 物理 LPI 空间的大小受实现支持的最大大小限制，该大小在 GICD_TYPER.IDbits 中定义。

对于给定的 Redistributor，LPI 配置和状态在内存中的两个表中维护，在以下章节中描述：

• LPI Configuration 表。

• LPI Pending 表。 如果 Redistributor 支持物理 LPI，它具有：

• 在 LPI Configuration 表中编程的 LPI 优先级和使能位。LPI Configuration 表的地址由 GICR_PROPBASER 定义。如果在 GICR_CTLR.EnableLPIs == 1 时更新 GICR_PROPBASER，效果是 UNPREDICTABLE 的。有关更多信息，请参见_LPI Configuration 表_。

• LPI Pending 表中 LPI 挂起位的内存支持存储。此表特定于特定的 Redistributor。LPI Pending 表的地址由 GICR_PENDBASER 定义。如果在 GICR_CTLR.EnableLPIs == 1 时更新 GICR_PENDBASER，效果是 UNPREDICTABLE 的。

GICR_PROPBASER.IDBits 设置 ID 空间的大小，从而设置 LPI Configuration 表和相应 LPI Pending 表中的条目数量。

通过写入 GICR_CTLR.EnableLPIs 来启用物理 LPI。

注意

当在 Redistributor 接口禁用 LPI 时，即当 GICR_CTLR.EnableLPIs == 0 时，LPI 无法变为挂起。在这种情况下尝试使 LPI 挂起没有效果，LPI 会丢失。这与禁用 SGI、PPI 和 SPI 不同，后者只阻止向 CPU 接口发出中断信号。

GICv4 引入了等效的表来处理虚拟 LPI，地址在 GICR_VPROPBASER 和 GICR_VPENDBASER 中引用。

在 GICv4 中，通过写入 GICR_VPENDBASER.Valid 来启用虚拟 LPI。

5.1.1 LPI Configuration 表

LPI 配置是全局的。GIC 是否支持指向 LPI Configuration 表的不同副本的 Redistributor 是 IMPLEMENTATION DEFINED 的。

GICR_PROPBASER 是否可以在不同的 Redistributor 上设置为不同的值是 IMPLEMENTATION DEFINED 的。GICR_TYPER.CommonLPIAff 指示哪些 Redistributor 在 GICR_CTLR.EnableLPIs == 1 时必须将 GICR_PROPBASER 设置为相同的值。

实现可以将所有需要具有相同值的 GICR_PROPBASER 副本视为访问公共状态。

在需要使用公共 LPI Configuration 表的 Redistributor 上，当 GICR_CTLR.EnableLPIs == 1 时，在 GICR_PROPBASER 的不同副本中设置不同的值会导致 UNPREDICTABLE 行为。

如果在不同的 Redistributor 上将 GICR_PROPBASER 编程为不同的值，则 GIC 读取 LPI Configuration 表时使用哪个或哪些 GICR_PROPBASER 副本是 IMPLEMENTATION DEFINED 的。但是，使用的副本将对应于 GICR_CTLR.EnableLPIs == 1 的 Redistributor。

为避免不可预测的行为，软件必须确保所有 LPI Configuration 表的副本都相同，并且所有更改都是全局可观察的，在以下情况下：

• 在任何 Redistributor 上将 GICR_CTLR.EnableLPIs 从 0 写为 1。

• 在任何 GICR_CTLR.EnableLPIs == 1 的 Redistributor 上写入 GICR_INVLPIR 和 GICR_INVALLR，如果支持直接 LPI。

• 在包含至少一个 ITS 的实现中，ITS 执行 INV 和 INVALL 命令。

内存中的 LPI Configuration 表存储包含每个 LPI 配置信息的条目，其中：

• GICR_PROPBASER 指定一个 4KB 对齐的物理地址。这是 LPI Configuration 表基地址。

• 对于任何 LPI N，表条目的位置由 (base address + (N – 8192)) 定义。

要更改中断的配置，软件写入 LPI Configuration 表，然后发出 INV 或 INVALL 命令。在不包含 ITS 的实现中，软件写入 GICR_INVALLR 或 GICR_INVLPIR。 5.1 LPI

LPI Configuration 表为每个 LPI 包含一个 8 位条目。图 5-3 显示了 LPI Configuration 表条目格式。

7 2 1 0
Priority
RES1
Enable 图 5-3 LPI Configuration 表条目

表 5-1 显示了 LPI Configuration 表条目位分配。

表 5-1 LPI Configuration 表条目位分配

缓存

当 GICR_CTLR.EnableLPI == 1 时，Redistributor 可以缓存来自 GICR_PROPBASER 指向的 LPI Configuration 表的信息，受所有以下规则约束：

• 是否存在一个或多个缓存是 IMPLEMENTATION DEFINED 的。如果存在至少一个缓存，则结构和大小是 IMPLEMENTATION DEFINED 的。

• LPI Configuration 表条目可能在任何时候分配到缓存中。

• 缓存的 LPI Configuration 表条目不保证保留在缓存中。

• 缓存的 LPI Configuration 表条目不保证与内存保持不一致。

• 在适当的无效操作完成之前，不保证 LPI 配置的更改是可见的：

  • 如果实现了一个或多个 ITS，则使用 INV 或 INVALL 命令执行无效。SYNC 命令完成 INV 和 INVALL 命令。

• 如果没有实现 ITS，则通过写入 GICR_INVALLR 或 GICR_INVLPIR 执行无效。

如果没有 GICR_CTLR.EnableLPIs == 1 的 Redistributor，GIC 就没有缓存的 LPI Configuration 表条目。

5.1.2 LPI Pending 表

软件使用有效 LPI INTID 的实现范围，通过写入 GICR_PENDBASER 来配置 LPI Pending 表。此寄存器提供物理 LPI 的 LPI Pending 表的基地址。

当 GICR_CTLR.EnableLPIs == 1 时，每个 Redistributor 在单独的 LPI Pending 表中维护条目，指示每个 LPI 的挂起状态：

0 LPI 未挂起。1 LPI 挂起。

对于给定的 LPI：

• LPI Pending 表中相应的字节是 (base address + (N / 8))。

• 字节中的位位置是 (N MOD 8)。

仅包含零的 LPI Pending 表，包括前 1KB，表示没有挂起的 LPI。

LPI Pending 表的前 1KB 是 IMPLEMENTATION DEFINED 的。但是，如果 LPI Pending 表的前 1KB 和表的其余部分仅包含零，则必须表示没有挂起的 LPI。

LPI Pending 表的前 1KB 内存在初始分配时必须仅包含零，并且这必须对 Redistributor 可见，否则效果是不可预测的。

在正常操作期间，LPI Pending 表仅由 Redistributor 维护。

如果在 GICR_CTLR.EnableLPIs == 1 时软件写入 LPI Pending 表，行为是 UNPREDICTABLE 的。当 GICR_CTLR.EnableLPIs 清零为 0 时，如果在 GICR_CTLR.RWP 读取为 0 之前写入 LPI Pending 表，行为是 UNPREDICTABLE 的。

按照 GICR_TYPER.CommonLPIAff 的指示，需要共享公共 LPI Configuration 表的 Redistributor 可能将 GICR_PENDBASER 的 OuterCache、Shareability 或 InnerCache 字段视为访问公共状态。

在系统中，在 GICR_CTLR.EnableLPIs == 1 的不同 Redistributor 上将 GICR_PENDBASER 的 OuterCache、Shareability 或 InnerCache 字段编程为不同的值是不可预测的。

对于物理 LPI，当 GICR_CTLR.EnableLPIs 更改为 1 时，Redistributor 必须从物理 LPI Pending 表读取物理 LPI 的挂起状态。

注意

如果 GICR_PENDBASER.PTZ == 1，软件保证 LPI Pending 表仅包含零，包括前 1KB。在这种情况下，硬件可能不会读取表的任何部分。

如果 GICR_CTLR.EnableLPIs 清零为 0，则当 GICR_CTLR.RWP 读取为 0 时，GIC 不再访问 LPI Pending 表，并且 LPI Pending 表的任何缓存都被无效。不保证清零 GICR_CTLR.EnableLPIs 会导致在内存中更新 LPI Pending 表。

注意

如果实现了一个或多个 ITS，Arm 强烈建议在将 GICR_CTLR.EnableLPIs 清零为 0 之前将所有 LPI 映射到另一个 Redistributor。

对于虚拟 LPI，当 GICR_CTLR.EnableLPIs ==1 且 GICR_VPENDBASER.Valid 更改为 1 时，Redistributor 必须从虚拟 LPI Pending 表读取虚拟 LPI 的挂起状态。

注意

• 如果 GICR_VPENDBASER.IDAI == 0，软件保证 LPI Pending 表由同一 GIC 实现写出，这意味着硬件可以依赖表的前 1KB，可能不会读取整个表。

• 如果当 GICR_CTLR.EnableLPIs == 1 时 GICR_PROPBASER.IDbits 小于 0b1101，GIC 仍可能访问 LPI Pending 表的 IMPLEMENTATION DEFINED 区域。

5.1.3 Virtual LPI Configuration 表和 virtual LPI Pending 表

GICv4 使用相同的内存表概念来保存虚拟 LPI 的配置和挂起信息。这些表的格式与物理 LPI 相同。

5.2 中断转换服务

中断转换服务（ITS）转换来自设备的输入 EventID，由其 DeviceID 标识，并确定：

1. 此输入的相应 INTID。

2. 目标 Redistributor，并通过它确定该 INTID 的目标 PE。

对于 GICv3，ITS 为转换为物理 LPI 的事件执行此功能。LPI 可以通过 ITS 或直接写入 GICR_SETLPIR 转发到 Redistributor。实现必须只支持这些方法中的一种。

对于 GICv4，ITS 还为直接注入为虚拟 LPI 的中断以及对于 GICv4.1，虚拟 SGI 执行此功能。

ITS 对物理 SGI、SPI 或 PPI 没有影响。

ITS 转换的流程如下：

1. DeviceID 选择_设备表_中描述使用哪个_中断转换表_（ITT）的_设备表条目_（DTE）。

2. EventID 选择 ITT 中描述以下内容的_中断转换条目_（ITE）：

   • 对于物理中断：

     • 输出物理 INTID。

     • 中断集合编号，ICID。

   • 对于虚拟中断，在 GICv4 中：

     • 输出虚拟 INTID。

     • vPEID。

     • 如果 vPE 未被调度，则使用的门铃。

3. 对于物理中断，ICID 选择_集合表_（CT）中的 Collection 表条目，描述目标 Redistributor，因此是中断路由到的目标 PE。

4. 对于虚拟中断，在 GICv4 中，vPEID 选择 vPE 表条目，描述当前托管中断路由到的目标 vPE 的 Redistributor。

转换过程中使用的表在以下章节中更详细地描述：

• ITS 表 。

• 设备表。

• 中断转换表。

• 集合表。

• vPE 表。

这些表使用_ITS 命令_中描述的 ITS 命令创建和维护。GICv3 和 GICv4 不支持对表的直接访问，必须使用 ITS 命令配置表。

5.2.1 ITS 表

当 GIC 提供一组寄存器允许发现以下功能时，软件为 ITS 私有表提供内存：

• 所需的私有表数量。

• 每个表中每个条目的大小。

• 每个表的类型。

注意

所有 ITS 表都在 Non-secure 物理地址空间中。

ITS 表的状态和配置存储在内存中的一组表中。在启用 ITS 之前，此内存由软件分配。 GITS_BASER 指定 ITS 表的基地址和大小，必须在启用 ITS 之前提供。

ITS 表具有平坦结构或两级结构。结构由 GITS_BASER 确定：

• 0 平坦表。在这种情况下，为表分配一个连续的内存块。表的格式是 IMPLEMENTATION DEFINED 的。

  • 如果在 ITS 新分配使用时用于 ITS 表的内存不包含零，则行为是 UNPREDICTABLE 的。

• 1 两级表。在这种情况下，1级表中的每个条目都是 64 位，格式如下：

  • 位 [63] - Valid：

    • 如果此位清零为 0，PhysicalAddress 字段不指向 2 级表的基地址。

    • 如果此位设置为 1，PhysicalAddress 字段指向 2 级表的基地址。

  • 位 [62:52] - RES 0。

  • 位 [51:N] - 2 级表的 PhysicalAddress。N 是指定页面大小所需的位数：

    • 2 级表的大小由 GITS_BASER.Page_Size 确定。

  • 位 [N-1:0] - RES 0。N 是指定页面大小所需的位数。

  • 1 级表由适当的 ID 索引，使得 1 级条目 = ID/(Page Size / Entry Size)。

注意 这允许软件确定必须为给定的 CollectionID、DeviceID 或 vPEID 分配的 2 级表。

对于 1 级表条目，当 Valid == 0 时：

• 如果 Type 字段指定除 Collection 表之外的有效表类型，ITS 丢弃对 2 级表的任何写入。

• 如果 Type 字段指定 Collection 表，且 ICID 大于或等于 GITS_TYPER.HCC 指示的数量，ITS 丢弃对 2 级表的任何写入。

2 级表的格式是 IMPLEMENTATION DEFINED 的。

如果以下情况，行为是 UNPREDICTABLE 的：

• 在 ITS 新分配使用时用于 2 级表的内存不包含零。

• 多个 Valid == 1 的 1 级表条目指向同一个 2 级表。

注意 作为从断电事件恢复 ITS 状态的一部分，描述表的寄存器可以指向以前由 ITS 填充的表，因此可能包含除零之外的值。ITS 电源管理的详细信息是 IMPLEMENTATION DEFINED 的。请参见_ITS 电源管理_。

图 5-4 显示了这些表在转换过程中如何使用。

当 GITS_CTLR.Enabled 从 0 写为 1 时，如果满足以下任何条件，行为是 UNPREDICTABLE 的：

• GITS_CBASER.Valid == 0。

• 对于 Type 字段指示设备的任何 GITS_BASER 寄存器，GITS_BASER.Valid == 0。

• 对于 Type 字段指示集合且 GITS_TYPER.HCC == 0 的任何 GITS_BASER 寄存器，GITS_BASER.Valid == 0。

• 在 GICv4 中，对于 Type 字段指示 vPE 的任何 GITS_BASER 寄存器，GITS_BASER.Valid == 0。

软件访问私有 ITS 表

如果 GITS_BASER.Indirect == 0，如果首次分配给 ITS 时用于 ITS 表的内存不包含全零，则行为是 UNPREDICTABLE 的。

如果 GITS_BASER.Indirect == 1，如果首次分配供 ITS 使用时用于 2 级表的内存不包含全零，则行为是不可预测的。

当 GITS_CTLR.Enabled == 0 且 GITS_CTLR.Quiescent == 1 时：

• 实现将不会访问任何 GITS_BASER 寄存器指向的表。

当 GITS_CTLR.Enabled == 1 或 GITS_CTLR.Quiescent == 0 时：

• 实现将不会访问任何 GITS_BASER.Valid == 0 的 GITS_BASER 寄存器指向的表。

• 对于 GITS_BASER.Valid == 1 且 GITS_BASER.Indirect == 0 的 GITS_BASER 寄存器指向的表，如果软件写入该表，行为是 UNPREDICTABLE 的。

• 对于 GITS_BASER.Valid == 1 且 GITS_BASER.Indirect == 1 的 GITS_BASER 寄存器指向的表：

  • 如果软件写入任何 2 级表条目，行为是 UNPREDICTABLE 的。

  • ITS 不会缓存有效位清零为 0 的 1 级表中的任何条目。

• 如果软件写入有效位设置为 1 的任何 1 级表条目，行为是 UNPREDICTABLE 的。

• 将 1 级表条目的有效位从 0 更改为 1 的写入必须在软件将依赖于该条目的命令添加到 ITS 命令队列之前全局可见。否则，命令是否成功或是否被忽略是未知的。

5.2.2 中断集合

在 GICv3 中，ITS 将其生成的所有物理 LPI 视为_集合_的成员。与集合关联的数据可以保存在 ITS 中、外部内存中或两者中。如果任何 GITS_BASER.Type == 0b100，ITS 支持保存在内存中的集合：

• 当 ITS 支持保存在内存中的集合时，支持的集合总数由软件分配的内存确定：

• 如果 GITS_BASER.Indirect == 0，可以使用以下公式计算内存中支持的集合数量：

((number of pages * page size) / entry size) 此公式的相关值在 GITS_BASER.Size、GITS_BASER.PageSize 和 GITS_BASER.EntrySize 中指示。

• 如果 GITS_BASER.Indirect == 1，可以使用以下公式计算内存中支持的集合数量：

(((number of pages in level 1 table * page size) /8) * (page size/entry size))。此公式的相关值在 GITS_BASER.Size、GITS_BASER.PageSize 和 GITS_BASER.EntrySize 中指示。

注意

间接表允许稀疏分配，因此支持范围内的所有 ICID 可能不可用。

• 当集合同时保存在 ITS 和外部内存中时，集合总数由 GITS_TYPER.CCT 指示。

当 GITS_TYPER.HCC!= 0 时：

• 范围 {0… GITS_TYPER.HCC-1} 中标识符的集合保存在 ITS 中。

• 如果支持，标识符范围大于 GITS_TYPER.HCC 中指示的集合保存在外部内存中。

当 GITS_TYPER.HCC == 0 时：

• ITS 必须支持外部内存中的集合，所有集合都保存在外部内存中。

支持的集合最大数量受 ICID 大小限制：

• 如果 GITS_TYPER.CIL == 0，ICID 是 16 位。

• 如果 GITS_TYPER.CIL == 1，ICID 由 GITS_TYPER.CIDbits 报告。

5.2.3 设备表

设备表_提供_设备表条目（DTE）的表。每个 DTE 描述 DeviceID 和 ITT 基地址之间的映射，该地址指向 ITS 可用于存储 EventID 转换的内存。ITS 使用 ITT 存储指定 DeviceID 的每个 EventID 的转换。DeviceID 是分配给可以创建一系列 EventID 的每个设备的唯一标识符。例如，Arm 期望来自 PCIe 根复合体的 16 位 Requester ID 作为 DeviceID 呈现给 ITS。

DeviceID 为表提供索引值。 表 5-2 显示了可能分配给每个 DTE 的位数示例。

表 5-2 DTE 条目

5.2.4 中断转换表

中断转换表（ITT）特定于可以创建编号事件的每个设备。ITT 中的每个条目称为_中断转换条目_（ITE）。

在 GICv3 中，ITE 仅为物理中断定义。

在 GICv4 中，ITE 为物理中断和虚拟中断定义，并提供以下区别：

• 物理 LPI 的条目和使用 ICT 进行路由信息。

• 虚拟 LPI 的条目和使用_vPE 表_。

必须为 ITT 分配从 ITT Address 开始的连续物理地址空间。大小为 2^(DTE.ITT Range + 1)* GITS_TYPER.ITT_entry_size。

如果内存在 ITS 新分配使用时不包含全零，则行为是 UNPREDICTABLE 的。

如果多个 ITT 在内存中重叠，行为是 UNPREDICTABLE 的。

ITS 对 ITT 的访问使用为设备表指定的相同 Shareability 和 Cacheability 属性。

对于物理中断，每个 ITE 描述输入 EventID 与以下内容之间的映射：

• 发送到目标 PE 的_输出物理 INTID_（pINTID）。

• 标识集合表中条目的 ICID，确定 LPI 的目标 PE。有关集合表的更多信息，请参见_集合表_。

对于虚拟中断，每个 ITE 描述如前面列表中所述的 EventID 映射，以及：

• 发送到目标 vPE 的_输出虚拟 INTID_（vINTID）。

• 标识 vPE 表中条目以确定当前主机 Redistributor 的_虚拟 PE 编号_（vPEID）。有关 vPE 表的更多信息，请参见_vPE 表_。

• 如果在目标 vPE 当前未在物理 PE 上调度时转换虚拟中断，则发送到物理 PE 的物理 LPI。

EventID 为表提供索引值。

表 5-3 显示了可能存储在 ITE 中的位数示例。

表 5-3 ITE 条目

a. 有关 LPI 编号空间大小的信息，请参见_INTID_。

5.2.5 集合表

集合表（CT）提供_集合表条目_（CTE）的表。仅对于物理 LPI，每个 CTE 描述以下内容之间的映射：

• ITT 生成的 ICID。

• 以 GITS_TYPER.PTA 定义格式的目标 Redistributor 的地址。

每个 ITS 有一个 CT，可以保存在寄存器中或内存中，或两者的组合。有关更多信息，请参见 GITS_BASER.Type 和 GITS_TYPER.HCC。

TableID 为表提供索引值。它从 ICID 派生。

表 5-4 显示了可能分配给每个 CT 的位数示例。

表 5-4 CT 条目

5.2.6 vPE 表

vPE 表由 vPE 表条目组成，提供从 ITS 生成的 vPEID 到以下内容的映射：

• 以 GITS_TYPER.PTA 定义格式的目标 Redistributor。

• 与目标 vPE 关联的虚拟 LPI Pending 表的基地址。

由 GITS_BASER 定义的内存区域保存 vPE 表并指示表中每个条目的大小。

vPE 表描述与 ITS 关联的所有 vPE。表 5-5 显示了实现可能在 vPE 表中存储的位数示例。 16 位 vPEID 为表提供索引值。

表 5-5 vPE 表条目

5.2.7 ITS 的控制和配置

使用内存映射接口控制和配置 ITS，其中：

• 可以从 GITS_IIDR 和 GITS_PIDR2 读取版本。

• GITS_TYPER 指定 ITS 支持的功能。

• GITS_CTLR 控制 ITS 的操作。

• GITS_TRANSLATER 接收 EventID 信息。如何提供 DeviceID 是 IMPLEMENTATION DEFINED 的。有关更多详细信息，请参见_ITS 命令_。

• GITS_BASER 寄存器提供有关架构 ITS 内存结构的类型、大小和访问属性的信息。

• GITS_CBASER、GITS_CREADR 和 GITS_CWRITER 存储 ITS 命令队列接口的地址信息。

每个 ITS 都有一个使能位，GITS_CTLR.Enabled。

5.2.8 ITS 命令接口

图 5-5 显示了 ITS 如何提供 ITS 命令队列使用的基地址和大小。

GITS_CBASER、GITS_CREADR 和 GITS_CWRITER 定义 ITS 命令队列。

• GITS_CBASER 使用以下字段：

  • Valid。此字段指示 ITS 命令队列的内存分配。

  • Cacheability。此字段指示对 ITS 命令队列的访问的可缓存性属性。

  • Shareability。此字段指示对 ITS 命令队列的访问的可共享性属性。

  • Physical address。此字段提供包含 ITS 命令队列的内存的基物理地址。

  • Size。此字段指示 ITS 命令队列的物理内存的 4KB 页数。

• GITS_CREADR 指定 ITS 读取下一个要执行的命令的基地址偏移。

• GITS_CWRITER 指定软件写入下一个命令的下一个空闲条目的基地址偏移。

ITS 命令队列条目的大小为 32 字节。这意味着每个 4KB 页面支持 128 个条目。

ITS 命令队列使用小端内存顺序模型。

在 ITS 命令队列中：

• 基地址总是对齐到 64KB。

• 大小以 4KB 的倍数表示。

• 队列回绕的地址总是对齐到 4KB，是（基地址 +（大小 * 4KB））。

注意

所有地址都是 Non-secure 物理地址。 当第一个命令完成时，ITS 开始处理下一个命令。读指针 GITS_CREADR 随着 ITS 处理命令而前进。如果 GITS_CREADR 到达 GITS_CBASER 中指定的内存顶部，则指针回绕到 GITS_CBASER 中指定的基地址。GITS_CWRITER 由软件控制。

当 GITS_CWRITER 和 GITS_CREADR 指定相同的基地址偏移值时，ITS 命令队列为空。

当 GITS_CWRITER 指向缓冲区中 GITS_CREADR 后 32 字节的地址时，ITS 命令队列已满。

当 GITS_CREADR.Stalled == 1 时，不处理后续命令。

INT ITS 命令在执行时生成中断，这可以在特定命令序列完成时生成中断，请参见_ITS 命令_。

5.2.9 与 ITS 命令输出的转换排序

每个命令队列条目看起来是原子执行的，因此转换请求要么看到命令之前的 ITS 状态，要么看到命令之后的 ITS 状态。

SYNC 或 VSYNC 命令完成后发起的转换请求使用与命令执行后状态一致的 ITS 状态进行转换。

在没有 SYNC 或 VSYNC 命令的情况下，架构未定义 ITS 命令和转换请求的排序。

5.2.10 INTID 映射规则的限制

如果软件：

• 将多个 EventID-DeviceID 组合映射到相同的物理 LPI INTID。

• 将具有相同物理 LPI INTID 的门铃中断分配给不同的物理 PE。这仅适用于 GICv4。

• 将 EventID-DeviceID 组合和单独的门铃中断映射到相同的物理 LPI INTID，除非它们针对相同的物理 PE。这适用于所有版本的 GICv4。

• 将多个 EventID-DeviceID 组合映射到相同的虚拟 LPI INTID-vPEID。这仅适用于 GICv4。

• 将 EventID-DeviceID 组合和默认门铃中断映射到相同的物理 LPI INTID。这仅适用于 GICv4.1。

• 将默认门铃和单独门铃映射到相同的物理 LPI INTID。这仅适用于 GICv4.1。

则 GIC 的行为是不可预测的。

注意 从概念上讲，限制是软件不应该将多个 EventID-DeviceID 组合映射到给定虚拟机内的相同 vLPI。但是，ITS 不知道哪些 vPE 属于同一虚拟机。

5.3 ITS 命令

表 5-6 提供了所有 ITS 命令的摘要。

表 5-6 ITS 命令

Arm IHI 0069G 表 5-6 ITS 命令（续）

• a. 此命令以前称为 MAPVI。

• b. 此命令仅存在于 GICv4 中。

• c. 此命令以前称为 VMAPVI。

实现支持的 EventID 和 DeviceID 位数可从 GITS_TYPER 发现。未实现的位是 RES0。

注意

• LPI 的 INTID 在 8192 - 最大数量的范围内。最大数量是 IMPLEMENTATION DEFINED 的。请参见_INTID_。

• 以下参数名称已从与此 GIC 规范相关的初步信息中使用的名称更改：

  • Device 已更改为 DeviceID。

  • ID 已更改为 EventID。

  • pID 已更改为 pINTID。

  • vID 已更改为 vINTID。

  • pCID 已更改为 ICID。

  • target address 已更改为 RDbase。

  • VCPU 已更改为 vPE。

• 集合目标地址 RDbase 的格式由 GITS_TYPER.PTA 指示。

5.3.1 ITS 命令参数中的 IMPLEMENTATION DEFINED 大小

一些 ITS 命令包括以下类型的具有 IMPLEMENTATION DEFINED 大小的参数：

DeviceID

关联设备表支持的设备标识符最大数量由可用位数确定，如 GITS_TYPER.Devbits 指定。

EventID EventID 受最大 MAPD Size 字段限制，该字段受 GITS_TYPER.ID_bits 限制。 ICID 支持的集合数量是 IMPLEMENTATION DEFINED 的：

• 对于不支持外部内存中集合表的实现，GITS_TYPER.HCC 指示集合数量。

• 对于确实支持外部内存中集合表的实现，支持的集合数量受分配的集合表大小限制： — 支持的集合总数计算如下：GITS_TYPER.HCC +（集合表大小/条目大小）当 GITS_TYPER.CIL == 1 时，集合的最大数量受 GITS_TYPER.CIDbits 限制。 pINTID pINTID 受 GICR_PROPBASER.IDbits 限制，该限制受 GICD_TYPER.IDbits 限制。这也适用于 Dbell_pINTID。

RDbase

RDbase 与 Redistributor 关联，以两种格式之一指定：

• 当 GITS_TYPER.PTA == 1 时的 RD_base 基物理地址。

注意 地址可以达到 52 位大小，必须 64KB 对齐。RDbase 字段由地址的位 [51:16] 组成。

• 当 GITS_TYPER.PTA == 0 时，GICR_TYPER.Processor_Number 中指示的 PE 编号。

• vINTID vINTID 可以受 GICR_VPROPBASER.IDbits 限制，该限制受 GICD_TYPER.IDbits 限制。

vPEID vPEID 受 vPE 表大小限制。

5.3.2 命令错误

如果 ITS 在提供给命令的数据中检测到错误，则结果行为是 CONSTRAINED UNPREDICTABLE 选择：

• 忽略命令：

  • 不执行更改中断处理的操作。

  • GITS_CREADR 递增以指向下一个命令，必要时回绕。

  • 如果 GITS_TYPER.SEIS 设置为 1，则生成系统错误。

注意

如何记录系统错误以及如何向 PE 报告是 IMPLEMENTATION DEFINED 的。

• 停止 ITS 命令队列：

  • GITS_CREADR 不递增，继续指向触发错误的条目。

  • — GITS_CREADR.Stalled 设置为 1。

  • 软件可以通过向 GITS_CWRITER.Retry 写入 1 来重启命令处理。

  • 如果 GITS_TYPER.SEIS 设置为 1，则生成系统错误。

    • 注意

如何记录系统错误以及如何向 PE 报告是 IMPLEMENTATION DEFINED 的。

• 将数据视为有效数据：

  • 生成错误的数据被视为具有合法值，并相应地处理命令。

  • GITS_CREADR 递增以指向下一个命令，必要时回绕。

  • 如果 GITS_TYPER.SEIS 设置为 1，则生成系统错误。

注意

如何记录系统错误以及如何向 PE 报告是 IMPLEMENTATION DEFINED 的。

有关更多信息，请参见_ITS 命令错误编码_。

5.3.3 CLEAR

此命令将由 EventID 和 DeviceID 定义的事件转换为 ICID 和 pINTID，并指示适当的 Redistributor 移除挂起状态。

图 5-6 显示了 CLEAR 命令的格式。

图 5-6 CLEAR 命令格式

在图 5-6 中：

• EventID 标识要清除挂起状态的与设备关联的中断。

• DeviceID 指定请求设备。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

命令及其参数为：

CLEAR DeviceID, EventID

如果以下任何情况适用，则发生命令错误：

• DeviceID 超过 ITS 支持的最大值。

• DeviceID 指定的设备未使用 MAPD 映射到中断转换表。

• EventID 超过 ITT 允许的最大值。此值在发出 MAPD 命令时由 Size 字段指定。

• 设备的 EventID 未使用 MAPI 或 MAPTI 映射到集合。

• 设备的 EventID 映射到未使用 MAPC 映射到 RDbase 的集合。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

以下伪代码描述了 CLEAR 命令的操作：

// ITS.CLEAR // =========

ITS.CLEAR(ITSCommand cmd)
    if DeviceOutOfRange(cmd.DeviceID)
    then if GITS_TYPER.SEIS == '1'
    then IMPLEMENTATION_DEFINED "SError CLEAR_DEVICE_OOR";
UNPREDICTABLE;

dte = ReadDeviceTable(UInt(cmd.DeviceID));

if !dte.Valid then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError CLEAR_UNMAPPED_DEVICE";
        UNPREDICTABLE;
    if IdOutOfRange(cmd.EventID, dte.ITT_size) then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError CLEAR_ID_OOR";
            UNPREDICTABLE;
        InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));
        if !ite.Valid then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError CLEAR_UNMAPPED_INTERRUPT";
                UNPREDICTABLE;
            success = ClearPendingState(ite);
            if !success then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError CLEAR_ITE_INVALID";
                    UNPREDICTABLE;
                IncrementReadPointer();
                return;

5.3.4 DISCARD

此命令转换由 EventID 和 DeviceID 定义的事件，并指示适当的 Redistributor 移除中断的挂起状态。它还确保与特定 EventID 关联的 Redistributor 中的任何缓存与内存中保存的配置一致。DISCARD 从 ITT 中移除 DeviceID 和 EventID 的映射，并确保静默丢弃具有特定 EventID 的传入请求。

图 5-7 显示了 DISCARD 命令的格式。

图 5-7 DISCARD 命令格式

在图 5-7 中：

• EventID 标识要丢弃的与设备关联的中断。

• DeviceID 指定请求设备。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

命令及其参数为：

DISCARD DeviceID, EventID

如果以下任何情况适用，则发生命令错误：

• DeviceID 超过 ITS 支持的最大值。

• DeviceID 指定的设备未使用 MAPD 映射到 ITT。

• EventID 超过 ITT 允许的最大值。此值在发出 MAPD 命令时由 Size 字段指定。

• 设备的 EventID 未使用 MAPI 或 MAPTI 映射到集合。

• 设备的 EventID 映射到未使用 MAPC 映射到 RDbase 的集合。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

在 GICv4.1 中，当为映射到虚拟 LPI 的 EventID 和 DeviceID 发出此命令，且关联的 vPEID 未映射到该 ITS 上的 Redistributor 时：

• 它移除 ITS 上 EventID 和 DeviceID 的映射。

• 如果 vPE 在至少一个其他 ITS 上映射，是否清除挂起状态是 IMPLEMENTATION DEFINED 的。

• 如果 vPE 在任何 ITS 上都未映射，则不清除挂起状态。

如果没有为其发出 V=1 的 VMAPP，或者已通过 V=0 的 VMAPP 取消映射，则 vPEID 被归类为_未映射_。

以下伪代码描述了 DISCARD 命令的操作：

// ITS.DISCARD // ===========

ITS.DISCARD(ITSCommand cmd)
    if DeviceOutOfRange(cmd.DeviceID)
    then if GITS_TYPER.SEIS == '1'
    then IMPLEMENTATION_DEFINED "SError DISCARD_DEVICE_OOR";
UNPREDICTABLE;

DeviceTableEntry dte = ReadDeviceTable(UInt(cmd.DeviceID));

if !dte.Valid then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError DISCARD_UNMAPPED_DEVICE";
        UNPREDICTABLE;
    if IdOutOfRange(cmd.EventID, dte.ITT_size) then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError DISCARD_ID_OOR";
            UNPREDICTABLE;
        InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));
        if ite.Valid then success = ClearPendingState(ite);
        if !success then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError DISCARD_ITE_INVALID";
                UNPREDICTABLE;
        else if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError DISCARD_UNMAPPED_INTERRUPT";
            UNPREDICTABLE;

ite.Valid = FALSE; WriteTranslationTable(dte.ITT_base, UInt(cmd.EventID), ite);

IncrementReadPointer(); return;

5.3.5 INT

此命令将由 EventID 和 DeviceID 定义的事件转换为 ICID 和 pINTID，并指示适当的 Redistributor 设置中断挂起。

图 5-8 显示了 INT 命令的格式。

图 5-8 INT 命令格式 在图 5-8 中：

• EventID 标识与设备关联的中断源。然后 ITS 将其转换为 LPI INTID。

• DeviceID 指定请求设备。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

命令及其参数为：

INT DeviceID, EventID

如果以下任何情况适用，则发生命令错误：

• DeviceID 超过 ITS 支持的最大值。

• DeviceID 指定的设备未使用 MAPD 映射到 ITT。

• EventID 超过 ITT 允许的最大值。此值在发出 MAPD 命令时由 Size 字段指定。

• EventID 未使用 MAPI 或 MAPTI 映射到集合。

• 设备的 EventID 映射到未使用 MAPC 映射到 RDbase 的集合。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

以下伪代码描述了 INT 命令的操作：

// ITS.INT // ======= ITS.INT(ITSCommand cmd)
if DeviceOutOfRange(cmd.DeviceID) then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError INT_DEVICE_OOR";
        UNPREDICTABLE;
    DeviceTableEntry dte = ReadDeviceTable(UInt(cmd.DeviceID));
    if !dte.Valid then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError INT_UNMAPPED_DEVICE";
            UNPREDICTABLE;
        if IdOutOfRange(cmd.EventID, dte.ITT_size) then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError INT_ID_OOR";
                UNPREDICTABLE;
            InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));
            if !ite.Valid then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError INT_UNMAPPED_INTERRUPT";
                    UNPREDICTABLE;
                boolean success = SetPendingState(ite);
                if !success then
                    if GITS_TYPER.SEIS == '1' then
                        IMPLEMENTATION_DEFINED "SError INT_ITE_INVALID";
                        UNPREDICTABLE;
                    IncrementReadPointer();
                    return;

5.3.6 INV

此命令指定 ITS 必须确保与指定 EventID 关联的 Redistributor 中的任何缓存与内存中保存的 LPI Configuration 表一致。

在 GICv4.1 中，INV 是否影响默认门铃的生成和优先级是 IMPLEMENTATION DEFINED 的。

注意 无论中断是否映射为物理中断还是虚拟中断，INV 命令都执行相同的功能。

图 5-9 显示了 INV 命令的格式。

图 5-9 INV 命令格式

在图 5-9 中：

• EventID 标识与设备关联的中断源。然后 ITS 将其转换为 LPI INTID。

• DeviceID 指定请求设备。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。 命令及其参数为：

INV DeviceID, EventID

如果以下任何情况适用，则发生命令错误：

• DeviceID 超过 ITS 支持的最大值。

• DeviceID 指定的设备未使用 MAPD 映射到 ITT。

• EventID 超过 ITT 允许的最大值。此值在发出 MAPD 命令时由 Size 字段指定。

• EventID 未使用 MAPI 或 MAPTI 映射到集合。

• 设备的 EventID 对应于物理 LPI 并映射到未使用 MAPC 映射到 RDbase 的集合。

• 设备的 EventID 对应于与未使用 VMAPP GICv4.0 或 VMAPP GICv4.1 映射到 Redistributor 的 vPE 关联的虚拟 LPI。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

以下伪代码描述了 INV 命令的操作：

// ITS.INV // ======= ITS.INV(ITSCommand cmd)
if DeviceOutOfRange(cmd.DeviceID) then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError INV_DEVICE_OOR";
        UNPREDICTABLE;
    DeviceTableEntry dte = ReadDeviceTable(UInt(cmd.DeviceID));
    if !dte.Valid then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError INV_UNMAPPED_DEVICE";
            UNPREDICTABLE;
        if IdOutOfRange(cmd.EventID, dte.ITT_size) then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError INV_ID_OOR";
                UNPREDICTABLE;
            InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));
            if !ite.Valid then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError INV_UNMAPPED_INTERRUPT";
                    UNPREDICTABLE;
                invalidateByITE(ite);
                IncrementReadPointer();
                return;

5.3.7 INVALL

此命令指定 ITS 必须确保与 ICID 定义的中断集合关联的任何缓存与所有 Redistributor 的内存中保存的 LPI Configuration 表一致。

在 GICv4.1 中，INVALL 是否影响默认门铃的生成和优先级是 IMPLEMENTATION DEFINED 的。

图 5-10 显示了 INVALL 命令的格式。

在图 5-10 中：

• ICID 指定中断集合。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

命令及其参数为：

INVALL ICID

如果以下任何情况适用，则发生命令错误：

• ICID 指定的集合超过 ITS 支持的最大数量。

• ICID 指定的集合未使用 MAPC 映射到 RDbase。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

以下伪代码描述了 INVALL 命令的操作：

// ITS.INVALL // ==========

ITS.INVALL(ITSCommand cmd)
    if (CollectionOutOfRange(cmd.ICID))
    then if GITS_TYPER.SEIS == '1'
    then IMPLEMENTATION_DEFINED "SError INVALL_COLLECTION_OOR";
UNPREDICTABLE;

CollectionTableEntry cte = ReadCollectionTable(UInt(cmd.ICID));

if !cte.Valid then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError INVALL_UNMAPPED_COLLECTION";
        UNPREDICTABLE;
    // This invalidates any caches containing the configuration data
    for all interrupts in the
    // collection. Over invalidation is permitted.
    InvalidateCollectionCaches(UInt(cmd.ICID));
    IncrementReadPointer();
    return;

5.3.8 INVDB 仅 GICv4.1

在 GICv4.1 中，ITS 命令 INVDB 分配用于无效默认门铃的配置：

图 5-11 显示了仅 GICv4.1 的 INVDB 命令格式。

• vPEID = vPE 的 vPEID。

// ITS.INVDB // ========= ITS.INVDB(ITSCommand cmd)
if VCPUOutOfRange(cmd.VCPUID) then
    if GITS_TYPER.SEIS == 1 then
        IMPLEMENTATION_DEFINED "SError INVDB_VCPU_OOR";
        UNPREDICTABLE;
    VCPUTableEntry vte = ReadVCPUTable(UInt(cmd.VCPUID));
    if vte.Valid then InvalidateInterruptDoorbellCaches(VCPUID, vte);
    IncrementReadPointer();
    return;

INVDB 由 VSYNC 命令同步。

INVDB 命令完成后，在任何 Redistributor 中都没有与指定 vPE 的默认门铃关联的缓存。

如果以下任何情况适用，则发生命令错误：

• 使用超过 ITS 配置的最大 vPEID 的 vPEID 发出 INVDB：INVDB_VCPU_OOR (0x01_2E11)。

如果以下任一点为真，具有有效 vPEID 的 INVDB 表现为 NOP：

• vPEID 未在 ITS 上映射。

• vPEID 没有默认门铃。

5.3.9 MAPC

此命令将由 ICID 定义的集合表条目映射到由 RDbase 定义的目标 Redistributor。

图 5-12 显示了 MAPC 命令的格式。

图 5-12 MAPC 命令格式

在图 5-12 中：

• V 指定集合的 RDbase 是否有效。

• RDbase 指定集合中中断转发到的目标 Redistributor。请参见_ITS 命令参数中的 IMPLEMENTATION DEFINED 大小_。

• ICID 指定要映射的中断集合。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

如果 GITS_TYPER.PTA == 1 并且指定了物理地址，则目标地址必须 64KB 对齐，意味着只需要位 [47:16]。有关更多信息，请参见_ITS 命令参数中的 IMPLEMENTATION DEFINED 大小_。此外，当 V 清零为 0 时，此字段必须写为零，但硬件可能忽略该值。

命令及其参数为： MAPC ICID, RDbase, V

当 V 为 1 时：

• 如果有中断映射到指定的集合且集合当前映射到 Redistributor，则行为是不可预测的，除非 MAPC 之后跟随 MOVALL，以便将集合的挂起状态从旧目标 Redistributor 移动到新目标 Redistributor。MOVALL 可能由不同的 ITS 发出：

  • 当多个集合从同一源重新映射到同一目的地时，如果在所有 MAPC 全局可观察之前发出 MOVALL，则行为是不可预测的。

  • 如果在 MOVALL 全局可观察之前，在 MAPC 之后发出影响属于重新映射集合的中断的任何 ITS 命令，则行为是不可预测的。

• 如果 RDbase 未指定有效的 Redistributor，则行为是不可预测的。

当 V 为 0 时：

• MAPC 移除指定中断集合的映射。映射到此集合的中断被忽略。

• 如果有中断映射到指定的集合，则行为是不可预测的，限制是来自该设备的进一步转换请求被忽略。

如果以下情况适用，则发生命令错误：

• ICID 指定的集合超过 ITS 支持的最大数量。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

注意

当软件使用 MAPC 命令将集合从目标 Redistributor A 移动到目标 Redistributor B 时，必须在发出伴随的 MOVALL 命令之前向 Redistributor A 发出 SYNC 命令。否则，来自集合的中断仍可能被与 Redistributor A 关联的 PE 接受。

以下伪代码描述了 MAPC 命令的操作：

// ITS.MAPC // ======== ITS.MAPC(ITSCommand cmd)
if CollectionOutOfRange(cmd.ICID) then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError MAPC_COLLECTION_OOR";
        UNPREDICTABLE;
    CollectionTableEntry cte;
    cte.Valid  = cmd.V == '1';
    cte.RDbase = cmd.RDbase;
    WriteCollectionTable(UInt(cmd.ICID), cte);
    IncrementReadPointer();
    return;

5.3.10 MAPD

此命令将与 DeviceID 关联的设备表条目映射到其关联的 ITT，由 ITT_addr 和 Size 定义。

图 5-13 显示了 MAPD 命令的格式。

图 5-13 MAPD 命令格式 在图 5-13 中：

• DeviceID 指定使用 ITT 的设备。

注意 有关将设备映射到 ITT 的更多信息，请参见_中断转换表_。

• V 指定 ITT_addr 和 Size 字段是否有效。

• ITT_addr 指定 ITT 物理地址的位 [51:8]。

• Size 是一个 5 位数字，指定设备支持的位数减一。size 字段启用对此 DeviceID 的转换请求的 EventID 范围检查。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

如果以下任何情况适用，则行为是 UNPREDICTABLE 的：

• DeviceID 已存在映射且映射的 ITT 包含有效的 EventID 映射。

• 当 V == 1 时，指定的 ITT 不包含全零。

命令及其参数为：

MAPD DeviceID, ITT_addr, Size, V

ITT 条目的格式是 IMPLEMENTATION DEFINED 的。典型的示例条目大小为 8 字节，允许以 32 个中断的倍数向设备分配标识符。

当 V 为 1 时：

• MAPD 将 DeviceID 与 ITT 的 256 字节对齐地址关联。

• 当 V 为 0 时：

• MAPD 移除指定 DeviceID 的映射。来自该设备的转换请求被忽略。

• MAPD 移除指定 DeviceID 的映射，来自该设备的中断请求被丢弃。在 DeviceID 再次映射到 ITT 之前，DeviceID 的后续转换不会生成 LPI 或 VLPI。

如果以下任何情况适用，则发生命令错误：

• DeviceID 超过 ITS 支持的最大设备数量。

• 当 V 设置为 1 时，Size 超过 GITS_TYPER.ID_bits 设置允许的最大值。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

注意 ITS 对 ITT 的访问使用为设备表指定的相同 Shareability 和 Cacheability 属性，请参见_设备表_。

以下伪代码描述了 MAPD 命令的操作：

// ITS.MAPD // ======== ITS.MAPD(ITSCommand cmd)
    if DeviceOutOfRange(cmd.DeviceID)
    then if GITS_TYPER.SEIS == '1'
    then IMPLEMENTATION_DEFINED "SError MAPD_DEVICE_OOR";
UNPREDICTABLE;
if SizeOutOfRange(cmd.Size) then

if GITS_TYPER.SEIS == '1' then IMPLEMENTATION_DEFINED "SError MAPD_ITTSIZE_OOR"; UNPREDICTABLE;
// If a device is Re-mapped software must perform the following actions
// to ensure the LPI configuration is up to date:
// 1. Ensure that the device is quiescent and that all interrupts have
//     been handled.
// 2. Remap the device with the new (empty) ITT
//
DeviceTableEntry dte;

5.3.11 MAPI

此命令将由 EventID 和 DeviceID 定义的事件映射到具有 ICID 和 pINTID = EventID 的 ITT 条目。

注意

• pINTID ≥0x2000 用于有效的 LPI INTID。

• 这等价于 MAPTI DeviceID, EventID, EventID, ICID

图 5-14 显示了 MAPI 命令的格式。

图 5-14 MAPI 命令格式

在图 5-14 中：

• EventID 标识要映射的与设备关联的中断。

• DeviceID 指定请求设备。

• ICID 指定包含指定中断的中断集合。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

如果 EventID-DeviceID 组合已存在映射，则行为是 UNPREDICTABLE 的。

命令及其参数为：

MAPI DeviceID, EventID, ICID

如果以下任何情况适用，则发生命令错误：

• DeviceID 超过 ITS 支持的最大值。

• DeviceID 指定的设备未使用 MAPD 映射到 ITT。

• ICID 超过 ITS 支持的最大中断集合数量。有关更多信息，请参见_集合表_。

• EventID 超过 ITT 允许的最大值。此值在发出 MAPD 命令时由 Size 字段指定。 • EventID 未指定有效的 LPI 标识符。请参见_INTID_。在这种情况下，ITS 必须采取_命令错误_中描述的操作。以下伪代码描述了 MAPI 命令的操作：

// ITS.MAPI // ======== ITS.MAPI(ITSCommand cmd)
if DeviceOutOfRange(cmd.DeviceID) then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError MAPI_DEVICE_OOR";
        UNPREDICTABLE;
    if CollectionOutOfRange(cmd.ICID) then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError MAPI_COLLECTION_OOR";
            UNPREDICTABLE;
        DeviceTableEntry dte = ReadDeviceTable(UInt(cmd.DeviceID));
        if !dte.Valid then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError MAPI_UNMAPPED_DEVICE";
                UNPREDICTABLE;
            if IdOutOfRange(cmd.EventID, dte.ITT_size) then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError MAPI_ID_OOR";
                    UNPREDICTABLE;
                if LPIOutOfRange(cmd.EventID) then
                    if GITS_TYPER.SEIS == '1' then
                        IMPLEMENTATION_DEFINED "SError MAPI_ID_OOR";
                        UNPREDICTABLE;
                    InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));

ite.Valid = TRUE; ite.Type = physical_interrupt; ite.OutputID = cmd.EventID; ite.DoorbellID = ZeroExtend(INTID_SPURIOUS); // Don’t generate a doorbell ite.ICID = cmd.ICID;

WriteTranslationTable(dte.ITT_base, UInt(cmd.EventID), ite);

IncrementReadPointer();

return;

5.3.12 MAPTI

此命令将由 EventID 和 DeviceID 定义的事件映射到其关联的 ITE，由与 DeviceID 关联的 ITT 中的 ICID 和 pINTID 定义。

图 5-15 显示了 MAPTI 命令的格式。

图 5-15 MAPTI 命令格式 在图 5-15 中：

• EventID 标识要映射的与设备关联的中断。

• pINTID 是呈现给软件的物理中断的 INTID。

• DeviceID 指定请求设备。

• ICID 指定包含指定物理中断的中断集合。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

如果 EventID-DeviceID 组合已存在映射，则行为是 UNPREDICTABLE 的。

命令及其参数为：

MAPTI DeviceID, EventID, pINTID, ICID

如果以下任何情况适用，则发生命令错误：

• DeviceID 超过 ITS 支持的最大值。

• DeviceID 指定的设备未使用 MAPD 映射到 ITT。

• 集合数量超过 ITS 支持的最大集合数量。有关更多信息，请参见_集合表_。

• EventID 超过 ITT 允许的最大值。此值在发出 MAPD 命令时由 Size 字段指定。

• pINTID 未指定有效的 LPI INTID。有关 LPI INTID 范围的信息，请参见_INTID_。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

以下伪代码描述了 MAPTI 命令的操作：

// ITS.MAPTI // =========

ITS.MAPTI(ITSCommand cmd)

if DeviceOutOfRange(cmd.DeviceID) then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError MAPTI_DEVICE_OOR";
        UNPREDICTABLE;
    if CollectionOutOfRange(cmd.ICID) then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError MAPTI_COLLECTION_OOR";
            UNPREDICTABLE;
        DeviceTableEntry dte = ReadDeviceTable(UInt(cmd.DeviceID));
        if !dte.Valid then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError MAPTI_UNMAPPED_DEVICE";
                UNPREDICTABLE;
            if IdOutOfRange(cmd.EventID, dte.ITT_size) then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError MAPTI_ID_OOR";
                    UNPREDICTABLE;
                if LPIOutOfRange(cmd.pINTID) then
                    if GITS_TYPER.SEIS == '1' then
                        IMPLEMENTATION_DEFINED "SError MAPTI_PHYSICALID_OOR";
                        UNPREDICTABLE;
                    InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));

ite.Valid = TRUE; ite.Type = physical_interrupt; ite.OutputID = cmd.pINTID; ite.DoorbellID = ZeroExtend(INTID_SPURIOUS); // Don’t generate a doorbell ite.ICID = cmd.ICID;

WriteTranslationTable(dte.ITT_base, UInt(cmd.EventID), ite);

IncrementReadPointer();

return;

5.3.13 MOVALL

此命令指示由 RDbase1 指定的 Redistributor 将其所有中断移动到由 RDbase2 指定的 Redistributor。

注意 中断到集合的映射和集合到 Redistributor 的映射通常不受此命令影响。软件必须确保可能受此命令影响的任何中断都针对 RDbase2 指定的 Redistributor，否则系统行为是 UNPREDICTABLE 的。特别是，实现可能选择将所有受影响的集合重新映射到 RDbase2。

图 5-16 显示了 MOVALL 命令的格式。

图 5-16 MOVALL 命令格式

在图 5-16 中：

• RDbase1 指定当前与中断关联的 Redistributor。请参见_ITS 命令参数中的 IMPLEMENTATION DEFINED 大小_。

• RDbase2 指定中断要移动到的 Redistributor。请参见_ITS 命令参数中的 IMPLEMENTATION DEFINED 大小_。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

命令及其参数为：

MOVALL RDbase1, RDbase2

如果 RDbase1 和 RDbase2 未指定有效的 Redistributor，则行为是不可预测的。这些字段的格式由 GITS_TYPER.PTA 指定。

针对禁用 LPI 的 RD 的 MOVALL 是 CONSTRAINED UNPREDICTABLE 的，可选择：

• 清除所有移动的 LPI 的挂起状态。

• 作为 NOP，挂起状态在源 RD 上保持不变。

以下伪代码描述了 MOVALL 命令的操作：

// ITS.MOVALL // ==========

ITS.MOVALL(ITSCommand cmd) rd1 = cmd.RD1base;
rd2 = cmd.RD2base;
if rd1 != rd2
    then MoveAllPendingState(rd1, rd2);

IncrementReadPointer();

return;

5.3.14 MOVI

此命令更新由 DeviceID 和 EventID 定义的事件的 ITT 条目中的 ICID 字段。它还将由 EventID 和 DeviceID 定义的事件转换为 ICID 和 pINTID，并指示适当的 Redistributor 将中断的挂起状态（如果已设置）移动到由新 ICID 定义的 Redistributor，并更新与事件关联的 ITE 以使用新的 ICID。

图 5-17 显示了 MOVI 命令的格式。

图 5-17 MOVI 命令格式

在图 5-17 中：

• EventID 标识要重定向的与设备关联的中断。

• DeviceID 指定请求设备。

• ICID 指定要包含指定物理中断的新中断集合。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

命令及其参数为：

MOVI DeviceID, EventID, ICID

如果以下任何情况适用，则发生命令错误：

• DeviceID 超过 ITS 支持的最大值。

• DeviceID 指定的设备未使用 MAPD 映射到 ITT。

• ICID 超过 ITS 支持的最大中断集合数量。

• ICID 未使用 MAPC 映射到 RDbase。

• EventID 未使用 MAPI 或 MAPTI 映射到集合。

• EventID 对应于虚拟 LPI。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

注意 如果在使用 MOVI 将中断从集合 A 移动到集合 B 后，软件再次将同一中断从集合 B 移动到集合 C，则必须在第二个 MOVI 之前为与集合 A 关联的 Redistributor 使用 SYNC 命令以确保正确行为。

当发出的 MOVI 针对未映射的集合或映射到禁用 LPI 的 Redistributor 的集合时，行为是 CONSTRAINED UNPREDICTABLE 的，可选择：

• 清除移动的 LPI 的挂起状态。

• 源 RD 上的挂起状态保持不变。

以下伪代码描述了 MOVI 命令的操作：

// ITS.MOVI // ========

ITS.MOVI(ITSCommand cmd)

if DeviceOutOfRange(cmd.DeviceID) then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError MOVI_DEVICE_OOR";
        UNPREDICTABLE;
    if CollectionOutOfRange(cmd.ICID) then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError MOVI_COLLECTION_OOR";
            UNPREDICTABLE;
        DeviceTableEntry dte = ReadDeviceTable(UInt(cmd.DeviceID));
        if !dte.Valid then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError MOVI_UNMAPPED_DEVICE";
                UNPREDICTABLE;
            if IdOutOfRange(cmd.EventID, dte.ITT_size) then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError MOVI_ID_OOR";
                    UNPREDICTABLE;
                InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));
                if !ite.Valid then
                    if GITS_TYPER.SEIS == '1' then
                        IMPLEMENTATION_DEFINED "SError MOVI_UNMAPPED_INTERRUPT";
                        IncrementReadPointer();
                        return;
                    if ite.Type == virtual_interrupt then
                        if GITS_TYPER.SEIS == '1' then
                            IMPLEMENTATION_DEFINED "SError MOVI_ID_IS_VIRTUAL";
                            UNPREDICTABLE;
                        CollectionTableEntry cte1 = ReadCollectionTable(UInt(ite.ICID));
                        if !cte1.Valid then
                            if GITS_TYPER.SEIS == '1' then
                                IMPLEMENTATION_DEFINED "SError MOVI_UNMAPPED_COLLECTION";
                                UNPREDICTABLE;
                            CollectionTableEntry cte2 = ReadCollectionTable(UInt(cmd.ICID));
                            if !cte2.Valid then
                                if GITS_TYPER.SEIS == '1' then
                                    IMPLEMENTATION_DEFINED "SError MOVI_UNMAPPED_COLLECTION";
                                    IncrementReadPointer();
                                    return;
                                bits(32) rd1 = cte1.RDbase;
                                bits(32) rd2 = cte2.RDbase;
                                if rd1 != rd2 then
                                    // Move the move the pending state to rd2
                                    if set taking care of any races where the
                                    // interrupt has been forwarded to the processor
                                    MovePendingState(rd1, rd2, ite.OutputID);

5.3.15 SYNC

此命令确保在执行任何进一步的 ITS 命令之前，与 RDbase 指定的 Redistributor 的物理中断关联的所有未完成的 ITS 操作都被全局观察。在 SYNC 执行后，所有先前命令的效果必须应用于对 GITS_TRANSLATER 的后续写入。

图 5-18 显示了 SYNC 命令的格式。

图 5-18 SYNC 命令格式 在图 5-18 中：

• RDbase 指定目标 Redistributor 的物理地址。目标地址的格式由 GITS_TYPER.PTA 确定。有关更多信息，请参见_ITS 命令参数中的 IMPLEMENTATION DEFINED 大小_。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

命令及其参数为：

SYNC RDbase

以下伪代码描述了 SYNC 命令的操作：

// Wait for the external effects of any virtual commands to be observable by all redistributors
// and ensure the internal effects of any previous commands affect any subsequent interrupt
// requests or commands
WaitForVirtualCompletion(rd_base);

IncrementReadPointer();

return;

5.3.16 VINVALL

此命令确保与 vPEID 关联的任何缓存的 Redistributor 信息与内存中保存的关联 LPI Configuration 表一致。

此命令仅在 GICv4 中提供。

图 5-19 显示了 VINVALL 命令的格式。

图 5-19 VINVALL 命令格式

在图 5-19 中：

• vPEID 指定 vPE。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

命令及其参数为：

VINVALL vPEID

如果以下任何情况适用，则发生命令错误：

• vPEID 超过 ITS 支持的最大数量，如 GITS_BASER 定义。

• vPEID 指定的 PE 未使用 VMAPP GICv4.0 映射到 Redistributor。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。 以下伪代码描述了 VINVALL 命令的操作：

// ITS.VINVALL // ===========

ITS.VINVALL(ITSCommand cmd)
    if VCPUOutOfRange(cmd.VCPUID) then

if GITS_TYPER.SEIS == '1' then
    IMPLEMENTATION_DEFINED "SError VINVALL_VCPU_OOR";
    UNPREDICTABLE;
VCPUTableEntry vte = ReadVCPUTable(UInt(cmd.VCPUID));
if !vte.Valid then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError VINVALL_VCPU_INVALID";
        UNPREDICTABLE;
    InvalidateVCPUCaches(UInt(cmd.VCPUID));
    IncrementReadPointer();
    return;

5.3.17 VMAPI

此命令将由 DeviceID 和 EventID 定义的事件映射到具有 vPEID、vINTID=EventID 和 Dbell_PINTID（门铃规定）的 ITT 条目。

注意

• vINTID ≥0x2000 用于有效的 LPI INTID。

• 这等价于 VMAPTI DeviceID, EventID, EventID, pINTID, vPEID。

• Dbell_pINTID 必须是 1023 或 Dbell_pINTID ≥0x2000 用于有效的 LPI INTID。

此命令仅在 GICv4 中提供。

图 5-20 显示了 VMAPI 命令的格式。

在图 5-20 中：

• EventID 标识要呈现给 VM 的与设备关联的中断。

• DeviceID 指定请求设备。

• vPEID 指定 vPE。

• Dbell_pINTID 指定如果 vPE 未调度时呈现给 hypervisor 的 ID。

  • 注意

如果 Dbell_pINTID 指示伪造中断，则不生成物理中断。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

如果 EventID-DeviceID 组合已存在映射，则行为是 UNPREDICTABLE 的。

命令及其参数为：

VMAPI DeviceID, EventID, Dbell_pINTID, vPEID 如果以下任何情况适用，则发生命令错误：

• DeviceID 超过 ITS 支持的最大值。

• vPEID 超过 ITS 支持的最大数量，如 GITS_BASER 定义。

• DeviceID 指定的设备未使用 MAPD 映射到 ITT。

• EventID 超过 ITT 允许的最大值。此值在发出 MAPD 命令时由 Size 字段指定。

• EventID 未指定有效的 LPI INTID。有关有效 LPI INTID 的信息，请参见_INTID_。

• Dbell_pINTID 未指定有效的门铃 INTID，其中有效 INTID 为： — 1023。

  • 在 LPI 支持的范围内。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

以下伪代码描述了 VMAPI 命令的操作：

// ITS.VMAPI // =========

ITS.VMAPI(ITSCommand cmd)
    if DeviceOutOfRange(cmd.DeviceID)
    then if GITS_TYPER.SEIS == '1'
    then IMPLEMENTATION_DEFINED "SError VMAPI_DEVICE_OOR";
UNPREDICTABLE;

if VCPUOutOfRange(cmd.VCPUID) then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError VMAPI_VCPU_OOR";
        UNPREDICTABLE;
    DeviceTableEntry dte = ReadDeviceTable(UInt(cmd.DeviceID));
    if !dte.Valid then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError VMAPI_UNMAPPED_DEVICE";
            UNPREDICTABLE;
        if IdOutOfRange(cmd.EventID, dte.ITT_size) then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError VMAPI_ID_OOR";
                UNPREDICTABLE;
            if LPIOutOfRange(cmd.EventID) then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError VMAPI_ID_OOR";
                    UNPREDICTABLE;
                if LPIOutOfRange(cmd.Dbell_pINTID) then
                    if GITS_TYPER.SEIS == '1' then
                        IMPLEMENTATION_DEFINED "SError VMAPI_PHYSICALID_OOR";
                        UNPREDICTABLE;
                    InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));

ite.Valid = TRUE; ite.Type = virtual_interrupt; ite.OutputID = cmd.EventID; ite.DoorbellID = cmd.Dbell_pINTID; ite.VCPUID = cmd.VCPUID;

WriteTranslationTable(dte.ITT_base, UInt(cmd.EventID), ite);

IncrementReadPointer();

return;

5.3.18 VMAPP GICv4.0

此命令将由 vPEID 定义的 vPE 表条目映射到目标 RDbase，包括关联的虚拟 LPI Pending 表（VPT_addr，VPT_size）。

图 5-21 显示了 GICv4.0 的 VMAPP 命令格式。

图 5-21 VMAPP GICv4.0 命令格式 在图 5-21 中：

• vPEID 指定 vPE。

• V 指定 vPE 的 RDbase 和 VPT_addr 是否有效。

• RDbase 指定拥有 vPE 并且 ITS 为该 PE 定向命令的目标 Redistributor。请参见_ITS 命令参数中的 IMPLEMENTATION DEFINED 大小_。

• VPT_addr 指定 vPE 的虚拟 LPI Pending 表物理地址的位 [51:16]。

注意 目标地址必须 64KB 对齐，意味着只需要位 [51:16]。物理地址的位 [15:0] 为 0。

• VPT_size 指定 vPE 支持的 vINTID 位数减一。

• DW 是 32 字节或四个双字的 ITS 命令包中的双字偏移。

命令及其参数为：

VMAPP vPEID, RDbase, VPT_addr, VPT_size, V

当 V 为 0 时：

• VMAPP 移除指定 vPE 的映射。映射到此 vPE 的中断被丢弃。

当 V 为 1 时：

• 如果 RDbase 未指定有效的 Redistributor，则行为是 UNPREDICTABLE 的。

如果以下任何情况适用，则发生命令错误：

• vPEID 超过 ITS 支持的最大数量，如 GITS_BASER 定义。

• Size 超过 GITS_TYPER.ID_bits 设置允许的最大值。

在这种情况下，ITS 必须采取_命令错误_中描述的操作。

注意 如果系统包含多个 ITS，Arm 强烈建议当另一个 ITS 上有同一 vPEID 的未完成 VMOVP 时，软件不要发出 VMAPP，因为这可能产生竞争条件。

以下伪代码描述了 VMAPP 命令的操作：

// ITS.VMAPP // =========

ITS.VMAPP(ITSCommand cmd)
    if VCPUOutOfRange(cmd.VCPUID) then

if GITS_TYPER.SEIS == '1' then IMPLEMENTATION_DEFINED "SError VMAPP_VCPU_OOR"; UNPREDICTABLE;

VCPUTableEntry vte;
// Common to GICv4.0 and GICv4.1
vte.Valid = cmd.V == '1';
vte.RDbase = cmd.RDbase;

if HasGIC41Ext() then
    // GICv4.1

    if ((Uint(cmd.VPT_size) < 14) || ((Uint(GICD_TYPER.bits) > 23)) then
        if ConstrainUnpredictableBool() then
            (c, cmd.VPT_size) = ConstrainUnpredictableInteger(14, 24);
            assert (c == Constraint_UNKNOWN);

    // Record configuration in vPE Configuration Table,
    // held by Redistributors
    WriteVPEConfigurationTable(UInt(cmd.VCPUID), cmd.RDbase,
        cmd.VCONF_addr, cmd.VPT_addr,
        cmd.Default_Doorbell_pINTID, cmd.VPT_size,
        cmd.V, cmd.Alloc, cmd.PTZ);

    // The ITS could record the size of the VPT to detect out of range
    // INTIDs, or it could rely on the Redistributors doing this.
else
    // GICv4.0
    if SizeOutOfRange(cmd.VPT_size) then
        if GITS_TYPER.SEIS == '1' then IMPLEMENTATION_DEFINED "SError
            VMAPP_VPTSIZE_OOR";
        UNPREDICTABLE;
    vte.VPT_base = cmd.VPT_addr:Zeros(16);
    vte.VPT_size = cmd.VPT_size;

WriteVCPUTable(UInt(cmd.VCPUID), vte);

IncrementReadPointer();

return;

5.3.19 VMAPP GICv4.1

在 GICv4.1 中修改了 VMAPP 命令，以允许指定 vPE 的 LPI 配置和挂起表位置。

图 5-22 显示了 GICv4.1 的 VMAPP 命令格式。

在图 5-22 中：

• RDbase = 标识目标 Redistributor。当 V==0 时为 RES0。

• VCONF_addr = vPE 虚拟配置表地址的位 [51:16]，位 [15:0] 为 0。当 V==0 时为 RES0。

• VPT_addr = vPE 虚拟挂起表地址的位 [51:16]，位 [15:0] 为 0。当 V==0 时为 RES0。

• VPT_size = vPE 的 vINTID 位数。当 V==0 时为 RES0。

• Default_Doorbell_pINTID 是 vPE 的默认门铃。当 V==0 时为 RES0。

• Alloc = 表示这是否为该 vPEID 的第一次映射或最后一次取消映射。

• PTZ = 表示 VPT_addr 是否指向归零的内存，当 V!=1 或 Alloc!=1 时忽略。

命令及其参数为：

VMAPP vPEID, RDbase, VPT_addr, VPT_size, V

当 V 为 0 时：

• VMAPP 移除指定 vPE 的映射。

当 V 为 1 时：

• 如果 RDbase 未指定有效的 Redistributor，则行为是 UNPREDICTABLE。

如果发生以下任何情况，会出现命令错误：

• vPEID 超过 ITS 支持的最大数量，由 GITS_BASER 定义。

• Size 超过 GITS_TYPER.ID_bits 设置允许的最大值。

• V==1 的 VMAPP 指定的 Default_Doorbell_pINTID 值不是 1023 且超出已实现的 LPI 范围。报告的命令错误码为 0x01_2906 (VMAPP_PHYSICALID_OOR)。

在这种情况下，ITS 必须执行 命令错误 中描述的操作。

注意 如果系统包含多个 ITS，Arm 强烈建议软件不要在另一个 ITS 上为相同 vPEID 存在未完成的 VMOVP 时发出 VMAPP，因为这可能会造成竞争条件。

描述该命令操作的伪代码，请参见 VMAPP GICv4.0。

V 和 Alloc 字段的使用

GICv4.1 引入了 vPE 配置表，它与记录虚拟 LPI 配置和挂起表位置的 Redistributor 相关联。该表使用 VMAPP 命令填充。

VMAPP 命令中的 Alloc 字段在创建或销毁 vPE 时使用，用于指示何时应更新 vPE 配置表项。

{V, Alloc}=={0, 1} 的 VMAPP 清理并使 GIC 中保存的与 vPEID 关联的任何缓存虚拟挂起表和虚拟配置表失效。Alloc 字段的无效使用可能导致 UNPREDICTABLE 行为，包括 IRI 的持续访问。

对于 V==1 的 VMAPP，VPT_size 决定了 vINTID 命名空间的大小，从中派生虚拟配置和挂起表的大小。

对于 V==1 的 VMAPP，如果 VPT_size 大于支持的 INTID 大小，则使用以下 CONSTRAINED UNPREDICTABLE 值之一：

• 指定的值。

• 范围内的 UNKNOWN 值。

V==1、Default_Doorbell_pINTID==1023 的 VMAPP 表示无默认门铃。

V==1 且指定以下 Default_Doorbell_pINTID 值之一的 VMAPP 会导致 UNPREDICTABLE 行为：

• 该值用于有效的 EventID 或 DeviceID 映射。

• 该值用于现有有效 vPE 的默认门铃。

Alloc==0 的 VMAPP 表示至少有一个 ITS 中存在该 vPEID 的现有映射。如果不是这样，结果行为是 UNPREDICTABLE。

{V, Alloc}=={1, 1} 的 VMAPP 表示这是任何 ITS 中该 vPEID 的第一次映射。在任何其他时间设置 {V, Alloc}=={1, 1} 会导致 UNPREDICTABLE 行为。

{V, Alloc}=={0, 1} 的 VMAPP 表示这是任何 ITS 中该 vPEID 的最后一次映射。在任何其他时间设置 {V, Alloc}=={0, 1} 会导致 UNPREDICTABLE 行为。

当发出 {V, Alloc}=={1, 1} 的 VMAPP 时，虚拟 LPI 配置表和虚拟 LPI 挂起表被分配给 IRI，并保持分配给 IRI 直到完成 {V, Alloc}=={0, 1} 的 VMAPP。表 5-7 总结了 V 和 Alloc 字段组合的效果。

表 5-7 V 和 Alloc 字段组合的效果

注意 与 Alloc 无效使用相关的 UNPREDICTABLE 行为可能包括 IRI 在释放后继续读取或写入与 vPEID 关联的内存结构。Arm 强烈建议避免这些情况。

{V, Alloc}=={0, x} 的 VMAPP 是自同步的。这意味着在其所有效果完成之前，ITS 命令队列不会显示该命令为已消费。

当实现多个 ITS 时，对不同 ITS 上的相同 vPEID 发出 V==1 的 VMAPP，使用不同的 VCONF_addr、VPT_addr 或 VPT_size 值，会导致 UNPREDICTABLE 行为。

当实现多个 ITS 时，发出 {V, Alloc}=={1, 0} 的 VMAPP，其中 Default_Doorbell_pINTID 或 RDbase 与当前配置的值不匹配，会导致 UNPREDICTABLE 行为。

当 {V, Alloc}!={1, 1} 时，PTZ 位被忽略。

当 {V, Alloc, PTZ}=={1, 1, 0} 时：

• 指定虚拟挂起表的 IMPLEMENTATION DEFINED 区域必须包含全零或已被相同实现的 GIC 填充。否则行为是 UNPREDICTABLE。

• IRI 将加载挂起状态和 SGI 配置。

当 {V, Alloc, PTZ}=={1, 1, 1} 时，指定的虚拟挂起表必须包含全零，否则行为是 UNPREDICTABLE。这包括 SGI 和 IMPLEMENTATION DEFINED 区域。

5.3.20 VMAPTI

此命令将由 DeviceID 和 EventID 定义的事件映射到具有 vPEID 和 vINTID 以及门铃条款 Dbell_pINTID 的 ITT 项中。

注意

• vINTID ≥0x2000 用于有效的 LPI INTID。

• Dbell_pINTID 必须是 1023 或 Dbell_pINTID ≥0x2000 用于有效的 LPI INTID。

此命令仅在 GICv4 中提供。

图 5-23 显示了 VMAPTI 命令的格式。

在图 5-23 中：

• vPEID 指定 vPE。

• DeviceID 指定 vPE 拥有的设备。

• vINTID 指定呈现给控制 DeviceID 指定设备的 vPE 的 INTID。

• Dbell_pINTID 指定当 vPE 未被调度时呈现给 PE 的 pINTID。

注意 如果 Dbell_pINTID 为 1023，则不生成物理中断。

• DW 是 32 字节或四个双字 ITS 命令包内的双字偏移量。

如果 EventID-DeviceID 组合存在现有映射，则行为是 UNPREDICTABLE。

命令及其参数为：

VMAPTI DeviceID, EventID, vINTID, Dbell_pINTID, vPEID

如果发生以下任何情况，会出现命令错误：

• DeviceID 超过 ITS 支持的最大值。

• vPEID 超过 ITS 支持的最大数量，由 GITS_BASER 定义。

• DeviceID 指定的设备未使用 MAPD 映射到 ITT。

• EventID 超过 ITT 允许的最大值。该值由发出 MAPD 命令时的 Size 字段指定。

• vINTID 未指定有效的 LPI INTID，参见 INTIDs。

• Dbell_pINTID 未指定有效的门铃 INTID，其中有效的 INTID 为： — 1023。

  • 在 LPI 支持的范围内。

在这种情况下，ITS 必须执行 命令错误 中描述的操作。

以下伪代码描述了 VMAPTI 命令的操作：

// ITS.VMAPTI // ==========

ITS.VMAPTI(ITSCommand cmd)
    if DeviceOutOfRange(cmd.DeviceID)
    then if GITS_TYPER.SEIS == '1'
    then IMPLEMENTATION_DEFINED "SError VMAPTI_DEVICE_OOR";
UNPREDICTABLE;

if VCPUOutOfRange(cmd.VCPUID) then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError VMAPTI_VCPU_OOR";
        UNPREDICTABLE;
    DeviceTableEntry dte = ReadDeviceTable(UInt(cmd.DeviceID));
    if !dte.Valid then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError VMAPTI_UNMAPPED_DEVICE";
            UNPREDICTABLE;
        if IdOutOfRange(cmd.EventID, dte.ITT_size) then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError VMAPTI_ID_OOR";
                UNPREDICTABLE;
            if LPIOutOfRange(cmd.vINTID) then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError VMAPTI_vINTID_OOR";
                    UNPREDICTABLE;
                if DoorbellOutOfRange(cmd.Dbell_pINTID) then
                    if GITS_TYPER.SEIS == '1' then
                        IMPLEMENTATION_DEFINED "SError VMAPTI_DOORBELL_OOR";
                        UNPREDICTABLE;
                    InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));
                    if ite.Valid then
                        if GITS_TYPER.SEIS == '1' then
                            IMPLEMENTATION_DEFINED "SError VMAPTI_ALREADY_MAPPED";
                            UNPREDICTABLE;
                        ite.Valid = '1';
                        ite.Type = virtual_interrupt;
                        ite.OutputID = cmd.vINTID;
                        ite.VCPUID = cmd.VCPUID;
                        ite.DoorBellOutputID = cmd.Dbell_pINTID;
                        WriteTranslationTable(dte.ITT_base, UInt(cmd.EventID), ite);
                        IncrementReadPointer();
                        return;

5.3.21 VMOVI

此命令将由 DeviceID 和 EventID 定义的事件移动到由新的 vPEID 定义的新 vPE。事件保持与现有 ITT 项中相同的 vINTID。

此命令仅在 GICv4 中提供。

图 5-24 显示了 VMOVI 命令的格式。

在图 5-24 中：

• vPEID 指定新的 vPE。

• DeviceID 指定设备。

• EventID 标识要移动的事件。

• DW 是 32 字节或四个双字 ITS 命令包内的双字偏移量。

命令及其参数为：

VMOVI DeviceID, EventID, vPEID

如果发生以下任何情况，会出现命令错误：

• DeviceID 超过 ITS 支持的最大值。

• vPEID 超过 ITS 支持的最大数量，由 GITS_BASER 定义。

• DeviceID 指定的设备未使用 MAPD 映射到 ITT。

• EventID 超过 ITT 允许的最大值。该值由发出 MAPD 命令时的 Size 字段指定。

• EventID 未映射到现有的 ITT 项。

• EventID 映射到物理 LPI 而不是虚拟 LPI。

• 源或目标 vPE 未使用 VMAPP 映射到 Redistributor。

在这种情况下，ITS 必须执行 命令错误 中描述的操作。

以下伪代码描述了 VMOVI 命令的操作：

// ITS.VMOVI // ==========
ITS.VMOVI(ITSCommand cmd)
    if DeviceOutOfRange(cmd.DeviceID) then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError VMOVI_DEVICE_OOR";
            UNPREDICTABLE;
        if VCPUOutOfRange(cmd.VCPUID) then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError VMOVI_VCPU_OOR";
                UNPREDICTABLE;
            DeviceTableEntry dte = ReadDeviceTable(UInt(cmd.DeviceID));
            if !dte.Valid then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError VMOVI_UNMAPPED_DEVICE";
                    UNPREDICTABLE;
                if IdOutOfRange(cmd.EventID, dte.ITT_size) then
                    if GITS_TYPER.SEIS == '1' then
                        IMPLEMENTATION_DEFINED "SError VMOVI_ID_OOR";
                        UNPREDICTABLE;
                    InterruptTableEntry ite = ReadTranslationTable(dte.ITT_base, UInt(cmd.EventID));
                    if !ite.Valid then
                        if GITS_TYPER.SEIS == '1' then
                            IMPLEMENTATION_DEFINED "SError VMOVI_UNMAPPED_INTERRUPT";
                            UNPREDICTABLE;
                        if ite.Type == physical_interrupt then
                            if GITS_TYPER.SEIS == '1' then
                                IMPLEMENTATION_DEFINED "SError VMOVI_ID_IS_PHYSICAL";
                                UNPREDICTABLE;
                            VCPUTableEntry vte1 = ReadVCPUTable(UInt(ite.VCPUID));
                            VCPUTableEntry vte2 = ReadVCPUTable(UInt(cmd.VCPUID));
                            if !vte1.Valid then
                                if GITS_TYPER.SEIS == '1' then
                                    IMPLEMENTATION_DEFINED "SError VMOVI_ITEVCPU_INVALID";
                                    UNPREDICTABLE;
                                if !vte2.Valid then
                                    if GITS_TYPER.SEIS == '1' then
                                        IMPLEMENTATION_DEFINED "SError VMOVI_CMDVCPU_INVALID";
                                        UNPREDICTABLE;
                                    bits(32) rd1 = vte1.RDbase;
                                    Address vpt1 = vte1.VPT_base;
                                    bits(32) rd2 = vte2.RDbase;
                                    Address vpt2 = vte2.VPT_base;

ite.VCPUID = cmd.VCPUID;

// From this point new interrupts sent to the new VCPU move the pending
// state to rd2 if set taking care of any races where the interrupt
// has been forwarded to the processor
MoveVirtualPendingState(rd1, vpt1, vpt2, ite.OutputID);

IncrementReadPointer();

return;

5.3.22 VMOVP GICv4.0

此命令将由 vPEID 定义的 vPE 表项更新到目标 RDbase。软件必须使用 SequenceNumber 和 ITSList 来同步跨多个 ITS 的 VMOVP 命令的执行。

此命令仅在 GICv4 中提供。

软件必须确保此命令不会与在目标 Redistributor 上调度的 vPEID 一起执行，否则系统行为是 UNPREDICTABLE。

图 5-25 显示了 VMOVP 命令的格式。

在图 5-25 中：

• vPEID 指定 vPE。

• RDbase 指定中断转发到的 Redistributor。参见 ITS 命令参数中的 IMPLEMENTATION DEFINED 大小。

• Sequence Number 指定 ITS 列表中包含的每个 ITS 使用的同步点的标识。当 GITS_TYPER.VMOVP == 0 时，Sequence Number 指定 ITSList 中包含的所有 ITS 使用的同步点的标识。

  • 当 GITS_TYPER.VMOVP == 1 时，Sequence Number 为 RES0。

  • 更多信息，参见 VMOVP 用法。

• ITSList 指定包含在同步操作中的 ITS 实例，其中：

  • ITS 列表中的每个位标识一个 ITS，其中位 [n] 对应于 ITS n。

  • 如果相应的位设置为 1，则包含 ITS。

当 GITS_TYPER.VMOVP == 0 时，ITSList 指定同步操作中包含哪些 ITS。ITSList 的每个位对应一个 ITS，例如 ITSList 的位 [0] 对应 ITS 0，位 [1] 对应 ITS 1。

当 GITS_TYPER.VMOVP ==1 时，ITSList 为 res0。

• DW 是 32 字节或四个双字 ITS 命令包内的双字偏移量。

命令及其参数为：

VMOVP, vPEID, RDbase, SequenceNumber, ITSList

如果发生以下任何情况，会出现命令错误：

• 如果 vPEID 指定的 PE 未使用 VMAPP GICv4.0 映射到 Redistributor。

• vPEID 超过 ITS 支持的最大数量，由 GITS_BASER 定义。

在这种情况下，ITS 必须执行 命令错误 中描述的操作。

以下伪代码描述了 VMOVP 命令的操作：

// ITS.VMOVP // ========= ITS.VMOVP(ITSCommand cmd)
if VCPUOutOfRange(cmd.VCPUID) then
    if GITS_TYPER.SEIS == '1' then
        IMPLEMENTATION_DEFINED "SError VMOVP_VCPU_OOR";
        UNPREDICTABLE;
    VCPUTableEntry vte = ReadVCPUTable(UInt(cmd.VCPUID));
    if !vte.Valid then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError VMOVP_VCPU_INVALID";
            UNPREDICTABLE;

vte.RDbase = cmd.RDbase;

if HasGIC41Ext() then UpdateVPEConfigurationTable(UInt(cmd.VCPUID), cmd.RDbase, cmd.Default_Doorbell_pINTID);

WriteVCPUTable(UInt(cmd.VCPUID), vte);

IncrementReadPointer();

return;

VMOVP 用法

当多个 ITS 控制同一个 vPE 的中断时，必须在不同的 ITS 之间协调移动这个 vPE。这由软件使用这里详述的两种方法之一来控制：

当 GITS_TYPER.VMOVP == 0 时：

• 必须为控制正在移动的 vPE 中断的每个 ITS 发出 VMOVP 命令。这些命令中的每一个都必须具有公共序列号。该序列号不能用于其他 VMOVP 命令，直到先前使用该序列号的所有命令都已被所有 ITS 处理。

• 为每个 ITS 发出的 VMOVP 命令包含受移动 vPE 影响的所有 ITS 的列表。这是 ITS 列表。

• 每个 ITS 必须以与其他 ITS 相同的顺序接收序列号。

当 GITS_TYPER.VMOVP == 1 时：

• VMOVP 命令只能在控制正在移动的 vPE 中断的 ITS 中的一个上发出。

• 实现负责传播更新的映射。

不遵循此方法会导致 UNPREDICTABLE 行为。

注意 如果系统包含多个 ITS，Arm 强烈建议软件不要在另一个 ITS 上为相同 vPEID 存在未完成的 VMOVP 时发出 VMAPP，因为这可能会造成竞争条件。

5.3.23 VMOVP GICv4.1

在 GICv4.1 中修改了 VMOVP 命令，以允许为 vPE 分配默认门铃。

在图 5-26 中：

• Default_Doorbell_pINTID 是 vPE 的默认门铃。

• DB 表示是否将 vPE 标记为在目标上需要默认门铃。

Default_Doorbell_pINTID==1023 的 VMOVP 意味着无默认门铃。对于具有有效 Default_Doorbell_pINTID（除 1023 外）的 VMOVP，默认门铃的挂起状态将转移到新目标。

Default_Doorbell_pINTID==1023 的 VMOVP 会清除旧目标上默认门铃的挂起状态（如果先前指定了一个）。即使门铃使用的 INTID 发生改变，默认门铃的挂起状态也会被转移。移动 vPE 不会改变生成默认门铃的规则。

当发出 VMOVP 时，如果 DB==1，则 vPE 被标记为在新目标上请求默认门铃生成。当 DB==0 时，vPE 被标记为在新目标上不请求默认门铃生成。

如果发生以下任何情况，会出现命令错误：

• vPEID 指定的 PE 未使用 VMAPP 映射到 Redistributor。

• vPEID 超过 ITS 支持的最大数量，由 GITS_BASER 定义。

• VMOVP 指定的 Default_Doorbell_pINTID 值超出已实现的 LPI 范围（除 1023 外）。报告的命令错误码为 0x01_2206(VMOVP_PHYSICALID_OOR)。

在这种情况下，ITS 必须执行 命令错误 中描述的操作。

GICv4.1 中的 VMOVP 用法

GICv4.1 中的 VMOVP 用法与 GICv4.0 中相同。更多信息参见 VMOVP 用法。

5.3.24 仅适用于 GICv4.1 的 vSGI

vSGI 命令设置指定 vSGI 的配置并可选地清除其挂起状态。

图 5-27 显示了 vSGI 命令的格式。

图 5-27 vSGI 命令编码

其中：

• E 是使能配置。

  • 当 C==1 时忽略。

• G 是组配置。

  • 当 C==1 时忽略。

• C 表示是否清除挂起状态。

• Pri 是优先级配置。

  • 当 C==1 时忽略。

• vINTID 是 vSGI 的 INTID。

命令及其参数为：

vSGI vPEID, vINTID, Enable, Priority, Group, Clear

如果发生以下任何情况，会出现命令错误：

• vPEID 超过 ITS 支持的最大数量，由 GITS_BASER 定义。

• vINTID 不在 vSGI 的范围内（0-15）。

在这种情况下，ITS 必须执行 命令错误 中描述的操作。

以下伪代码描述了 vSGI 命令的操作：

// ITS.vSGI
// =========
ITS.vSGI(ITSCommand cmd)
    if VCPUOutOfRange(cmd.VCPUID) then
        if GITS_TYPER.SEIS == '1' then
            IMPLEMENTATION_DEFINED "SError vSGI_VCPU_OOR";
            UNPREDICTABLE;
        if SGIOutOfRange(cmd.vINTID) then
            if GITS_TYPER.SEIS == '1' then
                IMPLEMENTATION_DEFINED "SError vSGI_vINTID_OOR";
                UNPREDICTABLE;
            VCPUTableEntry vte = ReadVCPUTable(UInt(cmd.VCPUID));
            if !vte.Valid then
                if GITS_TYPER.SEIS == '1' then
                    IMPLEMENTATION_DEFINED "SError vSGI_VCPU_INVALID";
                    UNPREDICTABLE;
                if cmd.C == '1' then
                    ClearVirtualSGIPendingState(UInt(cmd.VCPUID), vte, UInt(cmd.vINTID));
                else
                    SetVirtualSGIConfiguration(UInt(cmd.VCPUID), vte, UInt(cmd.vINTID), UInt(cmd.E), UInt(cmd.Pri), UInt(cmd.G));
                IncrementReadPointer();
                return;

5.4 通用 ITS 伪代码函数

本节的一些伪代码函数中出现以下术语：

中断翻译

导致 ITS 尝试在特定表中设置特定挂起位的操作。挂起中断

在特定表中设置特定挂起位。

本节中的伪代码函数基于以下假设：

• 每个 ITS 函数必须作为原子操作执行。实现必须确保观察到的行为与严格原子实现的行为一致。

• 当伪代码向特定 Redistributor 发出一系列读写操作时，这些操作必须按照生成的顺序执行。

• 当伪代码向特定 Redistributor 发出写入时，操作不需要等待写入完成。

• 当伪代码向内存发出写入以更新表时，操作不需要等待这些写入完成。向内存的写入可能永远不会对外部观察者可见。但是，任何此类写入的效果必须按任何后续 ITS 操作的顺序进行，包括处理中断翻译。除了标准规则（内存必须表现得好像对每个位置的写入按程序顺序发生）外，没有其他排序规则。

• 因为每个 ITS 函数都作为原子操作执行，所以在该函数之后发生的任何新中断翻译都必须受到该函数效果的影响。

• Redistributor LPI 配置和 LPI 挂起表的缓存效果在伪代码中明确指定。

• 中断翻译可能设置挂起位，挂起位保持设置状态直到被 PE 处理。当中断挂起时，它可能会受到由后续 ITS 函数更新的中断翻译的影响。

注意 伪代码中使用的一些变量名与正文中使用的不同。受影响变量的列表，参见 伪代码术语 B-910。

以下伪代码使指定翻译的 Redistributor 中 LPI 配置的任何关联缓存失效。

// InvalidateByITE
// ===============
boolean InvalidateByITE(InterruptTableEntry ite)
if ite.Type == physical_interrupt then
    CollectionTableEntry cte = ReadCollectionTable(UInt(ite.ICID));
    if !cte.Valid then
        return FALSE;
    InvalidateInterruptCaches(ite.ICID, ite.OutputID);
else

VCPUTableEntry vte = ReadVCPUTable(UInt(ite.VCPUID));
if !vte.Valid then
    return FALSE;
InvalidateVirtualInterruptCaches(ite.VCPUID, ite.OutputID);
return TRUE;
以下伪代码描述了移动挂起中断。

以下伪代码描述了移动挂起中断。

// MovePendingState()
// ==================

MovePendingState(bits(32) rd1, bits(32) rd2, bits(32) ID)
    if IsPending(GICR_PENDBASER[rd1], ID) then
        // The interrupt is pending in the source redistributor

        // Make sure the interrupt is released or taken by the processor for
        // example by sending a clear and waiting for the response
        EnsureInterruptNotPendingOnProcessor(rd1, ID);

        if IsPending(GICR_PENDBASER[rd1], ID) then
            // The CPU released the interrupt and it is still pending
            // Note: the following must be done without any possibility of the
            // source redistributor re-forwarding the interrupt to the processor
            ClearPendingStateLocal(GICR_PENDBASER[rd1], ID);
            SetPendingStateLocal(GICR_PENDBASER[rd2], ID);

以下伪代码描述了移动挂起虚拟中断。

// MoveVirtualPendingState()
// =========================

MoveVirtualPendingState(bits(32) rd_base, Address vpt1, Address vpt2, bits(32) ID)
    if IsPending(vpt1, ID) then
        // The interrupt is pending in the source redistributor

        // Make sure the interrupt is released or taken by the processor for example by sending a
        // VClear and waiting for the response
        EnsureVirtualInterruptNotPendingOnProcessor(rd_base, vpt1, ID);

        if IsPending(vpt1, ID) then
            // The CPU released the interrupt and it is still pending
            // Note: the following must be done without any possibility of the source redistributor
            // re-forwarding the interrupt to the processor
            ClearVirtualPendingStateLocal(vpt1, ID);
            SetVirtualPendingStateLocal(vpt2, ID);
    return;

以下伪代码描述了使与 vPE 关联的默认门铃的配置数据缓存失效。

// Invalidates any caching of configuration for the default
// doorbell associated with a vPE
InvalidateInterruptDoorbellCaches(UInt VCPUID, VCPUTableEntry vte);

// Sets the configuration of the specified vSGI
SetVirtualSGIConfiguration(UInt VCPUID, VCPUTableEntry vte, UInt Intid,
                           UInt Enable, UInt Priority, UInt Group);

// Clears the pending state of the specified vSGI
ClearVirtualSGIPendingState(UInt VCPUID, VCPUTableEntry vte, UInt Intid);

// Returns TRUE if the ITS supports GICv4.1
Boolean HasGIC41Ext();

以下伪代码描述了移动挂起虚拟中断。

// MoveVirtualPendingState() // =========================
// The names of the Banked core registers.

enumeration RName {RName_0usr, RName_1usr, RName_2usr, RName_3usr, RName_4usr, RName_5usr,
                   RName_6usr, RName_7usr, RName_8usr, RName_8fiq, RName_9usr, RName_9fiq,
                   RName_10usr, RName_10fiq, RName_11usr, RName_11fiq, RName_12usr, RName_12fiq,
                   RName_SPusr, RName_SPfiq, RName_SPirq, RName_SPsvc,
                   RName_SPabt, RName_SPund, RName_SPmon, RName_SPhyp,
                   RName_LRusr, RName_LRfiq, RName_LRirq, RName_LRsvc,
                   RName_LRabt, RName_LRund, RName_LRmon,
                   RName_PC};

array bits(8) _Memory[0..0xFFFFFFFF];

数组总是显式声明的，没有常量数组的记号。数组总是包含至少一个元素，因为：
•      枚举总是包含至少一个符号常量。
•      整数范围总是包含至少一个整数。

数组通常不会直接出现在伪代码中。在伪代码中在语法上看起来像数组的项目通常是类似数组的函数，如 R[i]、MemU[address, size] 或 Elem[vector, i, size]。这些函数打包和抽象了通常在访问底层数组时执行的额外操作，如寄存器组、内存保护、字节序相关的字节排序、独占访问管理和高级 SIMD 元素处理。

以下伪代码描述了使与 vPE 关联的默认门铃的配置数据缓存失效。

// Invalidates any caching of configuration for interrupts which are
// members of the collection specified by "collection"

InvalidateCollectionCaches(integer collection);

5.4.1 ITS 辅助函数

本小节描述 ITS 辅助函数。这些函数是行为未架构化且为 IMPLEMENTATION DEFINED 的行为的占位符函数。

这些函数由分层路径名表示，例如 shared/gic/its/its_helper：

• shared/gic/its/its_helper/Address。

• shared/gic/its/its_helper/ClearPendingState。

• shared/gic/its/its_helper/ClearPendingStateLocal。

• shared/gic/its/its_helper/CollectionOutOfRange。

• shared/gic/its/its_helper/CollectionTableEntry。

• shared/gic/its/its_helper/DeviceOutOfRange。

• shared/gic/its/its_helper/DeviceTableEntry。

• shared/gic/its/its_helper/EndOfCommand。

• shared/gic/its/its_helper/EnsureInterruptNotPendingOnProcessor。

• shared/gic/its/its_helper/EnsureVirtualInterruptNotPendingOnProcessor。

• shared/gic/its/its_helper/IdOutOfRange。

• shared/gic/its/its_helper/IncrementReadPointer。

• shared/gic/its/its_helper/InterruptTableEntry。

• shared/gic/its/its_helper/InterruptType。

• shared/gic/its/its_helper/InterruptType。

• shared/gic/its/its_helper/InvalidateInterruptCaches。

• shared/gic/its/its_helper/InvalidateInterruptConfigurationCaches。

• shared/gic/its/its_helper/InvalidateVCPUCaches。

• shared/gic/its/its_helper/InvalidateVirtualConfigurationCaches。

• shared/gic/its/its_helper/InvalidateVirtualInterruptCaches。

• shared/gic/its/its_helper/IsPending。

• shared/gic/its/its_helper/IsPending。

• shared/gic/its/its_helper/LPIOutOfRange。

• shared/gic/its/its_helper/MoveAllPendingState。

• shared/gic/its/its_helper/ReadCollectionTable。

• shared/gic/its/its_helper/ReadDeviceTable。

• shared/gic/its/its_helper/ReadTranslationTable。

• shared/gic/its/its_helper/ReadVCPUTable。

• shared/gic/its/its_helper/RetargetVirtualInterrupt。

• shared/gic/its/its_helper/SetPendingState。

• shared/gic/its/its_helper/SetPendingStateLocal。

• shared/gic/its/its_helper/SizeOutOfRange。

• shared/gic/its/its_helper/VCPUOutOfRange。

• shared/gic/its/its_helper/VCPUTableEntry。

• shared/gic/its/its_helper/WaitForCompletion。

• shared/gic/its/its_helper/WaitForVirtualCompletion。

• shared/gic/its/its_helper/WriteCollectionTable。

• shared/gic/its/its_helper/WriteDeviceTable。

• shared/gic/its/its_helper/WriteTranslationTable。

• shared/gic/its/its_helper/WriteVCPUTable。

下面是这些函数的详细实现：

shared/gic/its/its_helper/DeviceTableEntry

// DeviceTableEntry
// ================

type DeviceTableEntry is (
    boolean Valid,
    Address ITT_base,
    bits(5) ITT_size
)

shared/gic/its/its_helper/EndOfCommand

// EndOfCommand()
// ================

// 终止当前命令的处理而不递增读指针。
// 这意味着命令将再次运行。

EndOfCommand();

shared/gic/its/its_helper/EnsureInterruptNotPendingOnProcessor

// EnsureInterruptNotPendingOnProcessor()
// ======================================

// 当由 ID 指定的物理中断在连接到由 rd1 指定的 redistributor 的
// CPU 接口上不再挂起时返回

EnsureInterruptNotPendingOnProcessor(bits(32) rd1, bits(32) ID);

shared/gic/its/its_helper/EnsureVirtualInterruptNotPendingOnProcessor

// EnsureVirtualInterruptNotPendingOnProcessor()
// ==========================================

// 当由 ID 指定的虚拟中断在连接到由 rd1 指定的 redistributor 的
// CPU 接口上不再挂起时返回

EnsureVirtualInterruptNotPendingOnProcessor(bits(32) rd1, Address vpt, bits(32) ID);

shared/gic/its/its_helper/IdOutOfRange

// IdOutOfRange()
// ============================

// 如果提供的值具有超出已实现大小或超出 ITT_size 的位，则返回 TRUE

boolean IdOutOfRange(bits(32) ID, bits(5) ITT_size);

shared/gic/its/its_helper/IncrementReadPointer

// IncrementReadPointer()
// ===================

// 递增 GITS_CREADR，如果适当则回绕

IncrementReadPointer();

shared/gic/its/its_helper/InterruptTableEntry

// InterruptTableEntry()
// =====================

type InterruptTableEntry is (
boolean Valid,
InterruptType Type,
bits(32) OutputID,
bits(32) DoorbellID,
bits(16) ICID,
bits(16) VCPUID
)

shared/gic/its/its_helper/InterruptType

// InterruptType
// ====================

enumeration InterruptType { virtual_interrupt, physical_interrupt };

shared/gic/its/its_helper/InvalidateCollectionCaches

//InvalidateCollectionCaches() // =========================

// 使由 "collection" 指定的集合成员中断的任何配置缓存失效

InvalidateCollectionCaches(integer collection);

shared/gic/its/its_helper/InvalidateInterruptCaches

// InvalidateInterruptCaches()
// =============================

// 使由 interruptID 指定的物理中断的任何配置缓存失效，
// 该中断是由 collection 指定的集合的成员

InvalidateInterruptCaches(bits(16) collection, bits(32) interruptID);

shared/gic/its/its_helper/InvalidateInterruptConfigurationCaches

// InvalidateInterruptConfigurationCaches()
// ===================================

InvalidateInterruptConfigurationCaches(bits(32) ID, integer collection);

shared/gic/its/its_helper/InvalidateVCPUCaches

// InvalidateVCPUCaches()
// ==========================

// 使由 vcpu_id 指定的 vPE 的任何配置缓存失效

InvalidateVCPUCaches(integer vcpu_id);

shared/gic/its/its_helper/InvalidateVirtualConfigurationCaches

// InvalidateVirtualConfigurationCaches
// ================================

InvalidateVirtualConfigurationCaches(bits(32) ID, bits(16) VCPU);

shared/gic/its/its_helper/InvalidateVirtualInterruptCaches

// InvalidateVirtualInterruptCaches()
// =====================================

// 使由 vcpu_id 指定的 vPE 的由 interruptID 指定的虚拟中断的
// 任何配置缓存失效

InvalidateVirtualInterruptCaches(bits(16) vcpu_id, bits(32) interruptID);

shared/gic/its/its_helper/IsPending

// IsPending()
// ========================

// 如果由 interruptID 指定的虚拟中断在由 base 指定的 LPI 挂起表中挂起，
// 则返回 TRUE

boolean IsPending(Address base, bits(32) interruptID);

shared/gic/its/its_helper/IsPending

// IsPending()

// ========================
// 如果提供的值具有超出已实现范围的位或如果提供的值超过
// 相应 GITS_BASERn 中配置的最大大小，则返回 TRUE

boolean VCPUOutOfRange(bits(16) vcpu);

shared/gic/its/its_helper/LPIOutOfRange

//LPIOutOfRange()

// ==========================

// 如果提供的值大于 GICD_TYPER.IDbits 允许的值或不在 LPI 范围内
// 且不是 1023，则返回 TRUE

boolean LPIOutOfRange(bits(32) ID);

shared/gic/its/its_helper/MoveAllPendingState

// MoveAllPendingState()
// ===================

// 将所有中断的挂起状态从由 rd1 指定的 Redistributor
// 移动到由 rd2 指定的 Redistributor

MoveAllPendingState(bits(32) rd1, bits(32) rd2);

shared/gic/its/its_helper/ReadCollectionTable

// ReadCollectionTableEntry()
// =========================

// 从内存读取集合表项

CollectionTableEntry ReadCollectionTable(integer index);

shared/gic/its/its_helper/ReadDeviceTable

// ReadDevicePointer()
// ==========================

// 从内存读取设备表项

DeviceTableEntry ReadDeviceTable(integer index);

shared/gic/its/its_helper/ReadTranslationTable

// ReadTranslationTable()
// =======================
// 从内存读取 VCPU 表项

VCPUTableEntry ReadVCPUTable(integer index);

shared/gic/its/its_helper/ReadVCPUTable

//ReadVCPUTable() // ===========================

// 从内存读取 VCPU 表项

VCPUTableEntry ReadVCPUTable(integer index);

shared/gic/its/its_helper/RetargetVirtualInterrupt

// RetargetVirtualInterrupt()
// =======================

RetargetVirtualInterrupt(integer device, bits(32) ID, integer vcpu);

shared/gic/its/its_helper/SetPendingState

// SetPendingState()
// =================

boolean SetPendingState(InterruptTableEntry ite)

     if ite.Type == physical_interrupt then
         CollectionTableEntry cte = ReadCollectionTable(UInt(ite.ICID));

         if !cte.Valid then
             return FALSE;

         bits(32) rd_base = cte.RDbase;

         SetPendingStateLocal(GICR_PENDBASER[rd_base], ite.OutputID);

     else
         VCPUTableEntry vte = ReadVCPUTable(UInt(ite.VCPUID));

         if !vte.Valid then
             return FALSE;

         bits(32) rd_base = vte.RDbase;
         Address vpt = vte.VPT_base;

         SetVirutalPendingStateLocal(vpt, ite.OutputID);

         if (GICR_VPENDBASER[rd_base].Valid == '1' &&
             GICR_VPENDBASER[rd_base].PhysicalAddress != vpt<47:16>) then
             if ite.DoorbellID != ZeroExtend(INTID_SPURIOUS, 32) then
                 // Not resident so set the doorbell interrupt pending as well
                 SetPendingStateLocal(GICR_PENDBASER[rd_base], ite.DoorbellID);

     return TRUE;

shared/gic/its/its_helper/SetPendingStateLocal

// SetPendingStateLocal()
// =======================

// 为拥有由 PendBase 指定的 LPI 挂起表的 Redistributor
// 设置由 INTID 指定的物理中断的挂起状态

SetPendingStateLocal(PBType PendBase, bits(32) INTID);

// SetVirtualPendingStateLocal()
// =======================

// 在由 base 指定的 LPI 挂起表中设置由 INTID 指定的虚拟中断的挂起状态

SetPendingStateLocal(Address base, bits(32)INTID);

shared/gic/its/its_helper/SizeOutOfRange

// SizeOutOfRange()
// =====================

// 如果提供的值超过 GITS_TYPER.ID_bits 允许的最大值，则返回 TRUE

boolean SizeOutOfRange(bits(5) ITT_size);

shared/gic/its/its_helper/VCPUOutOfRange

// VCPUOutOfRange()
// =======================

shared/gic/its/its_helper/VCPUTableEntry

//VCPUTableEntry() // ==================

type VCPUTableEntry is ( boolean Valid, bits(32) RDbase, Address VPT_base, bits(5) VPT_size )

shared/gic/its/its_helper/WaitForCompletion

// WaitForCompletion()
// ============================

// 当任何物理命令的所有外部效果对所有 Redistributor 都可观察
// 且任何先前命令的内部效果影响任何后续中断请求或命令时返回

WaitForCompletion(bits(32) RDbase);

shared/gic/its/its_helper/WaitForVirtualCompletion

// WaitForVirtualCompletion()
// =======================

WaitForVirtualCompletion(bits(32) RDbase);

shared/gic/its/its_helper/WriteCollectionTable

//WriteCollectionTable() // =========================

// 将集合表项写入内存

WriteCollectionTable(integer index, CollectionTableEntry cte);

shared/gic/its/its_helper/WriteDeviceTable

// WriteDeviceTable()
// ========================

// 将设备表项写入内存

WriteDeviceTable(integer index, DeviceTableEntry dte);

shared/gic/its/its_helper/WriteTranslationTable

// WriteTranslationTable()
// ================================

// 将 ITT 表项写入内存

WriteTranslationTable(Address base, integer index, InterruptTableEntry cte);

shared/gic/its/its_helper/WriteVCPUTable

// WriteVCPUTable()
// ===============================

// 将 VCPU 表项写入内存

WriteVCPUTable(integer index, VCPUTableEntry vte);

5.5 ITS 命令错误编码

当 ITS 支持系统错误时，即当 GITS_TYPER.SEIS == 1 时，ITS 命令错误可以报告给软件。如何记录和报告这些错误是 IMPLEMENTATION DEFINED。

表 5-8 显示了 ITS 命令错误编码。

表 5-8 ITS 命令错误编码（续）

表 5-8 ITS 命令错误编码（续）

5.6 ITS 电源管理

本小节描述了启用和禁用 ITS 的软件序列。包含以下部分：

• 启用 ITS 。

• 禁用 ITS 。

5.6.1 启用 ITS

在上电时，ITS 被重置为静止状态，其中 GITS_CTLR.Quiescent == 1 且 GITS_CTLR.Enabled == 0。要启用 ITS，软件必须：

1. 确保支持设备、中断翻译、中断集合或虚拟 CPU 表所需的任何内存结构都已初始化或恢复。

2. 确保 ITS 命令队列已配置。

3. 将 GITS_CTLR.Enabled 设置为 1。

4. 使用适当的 ITS 命令根据需要配置 ITS。有关 ITS 命令的更多信息，参见 ITS 命令。

5.6.2 禁用 ITS

要禁用 ITS，软件必须：

1. 确保所有针对正在关闭的 ITS 的中断都被重定向或禁用。

2. 通过将 GITS_CTLR.Enable 清零为 0 来禁用 ITS。禁用的 ITS 完成所有未完成的操作，然后将 GITS_CTLR.Quiescent 设置为 1。

3. 通过轮询直到 GITS_CTLR.Quiescent == 1 来确保 ITS 处于静止状态。

当 GITS_CTLR.Enable == 0 时，对 GITS_TRANSLATER 的写入访问被忽略。当 GITS_CTLR.Quiescent == 1 时，所有操作都已完成且内存支持的状态已提交。然后 ITS 可以断电到 IMPLEMENTATION DEFINED 状态。

Chapter 6: 虚拟中断处理和优先级

本章描述了GIC虚拟中断处理和优先级的基本方面：

• 关于GIC虚拟化支持 .

• 操作概述 .

• VM的配置和控制 .

• 伪代码 .

6.1 关于GIC虚拟化支持

在EL2执行的管理程序控制下在EL1执行的操作系统有时被称为_虚拟机_（VM）。VM可以支持多处理，这意味着多个由管理程序调度的_虚拟PE_（vPE）在一个或多个物理PE上执行。当vPE在PE上执行时，VM的该vPE被称为在物理PE上调度。

在Armv8中，当EL2被实现并启用时，CPU interface提供机制来最小化将中断路由到VM的管理程序开销。有关vPE的更多信息，请参阅_操作概述_。

有关EL2和虚拟中断的更多信息，请参阅_Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile_。

在GICv4中，对于直接注入的虚拟LPI，调度的vPE由GICR_VPENDBASER确定。有关更多信息，请参阅_门铃中断_。

注意 GIC不为GICD_*、GICR_*和GITS_*寄存器的虚拟化提供额外机制。要虚拟化VM对这些寄存器的访问，管理程序必须为这些内存位置设置stage 2 Data Abort，以便管理程序可以模拟这些效果。有关stage 2 Data Abort的更多信息，请参阅_Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile_。

当GIC提供虚拟化支持时，VM在具有以下特性的环境中操作：

• vPE可以被配置为接收虚拟Group 0中断。

• vPE可以被配置为接收虚拟Group 1中断。

• 虚拟Group 0中断使用虚拟FIQ信号向非安全EL1发出信号。

• 虚拟Group 1中断使用虚拟IRQ信号向非安全EL1发出信号。

• vPE可以像处理物理中断一样处理虚拟中断。

注意

这适用于启用亲和性路由和System register访问的情况。有关传统操作中虚拟中断支持的信息，请参阅_VM传统操作的支持_。

EL2控制VM的虚拟中断生成。这允许在EL2执行的软件：

• 为vPE生成虚拟Group 0和Group 1中断。

• 保存和恢复vPE的中断状态。

• 控制虚拟中断的优先级处理。

• 更改调度的vPE。

GICv4引入了从ITS直接向vPE呈现虚拟LPI的能力，无需管理程序干预。

在传统操作中处理虚拟中断需要GICV_*内存映射接口。有关更多信息，请参阅_VM传统操作的支持_。

6.2 操作概述

GICv3支持Armv8-A虚拟化功能。在EL2执行的管理程序使用ICH_* System register接口来配置和控制在EL1执行的虚拟PE（vPE）。有关VM控制接口的信息，请参阅_VM的配置和控制_。vPE使用ICC_*_EL1 System register接口与GIC通信。HCR_EL2.{IMO, FMO}的配置决定了是访问虚拟还是物理接口寄存器。

注意 本章描述了在启用System register访问的AArch64状态上下文中虚拟中断的处理。本章中交叉引用的各个AArch64 System register描述包含对提供相同功能的AArch32 System register的引用。有关传统操作中VM的信息，请参阅_VM传统操作的支持_。

在EL3或EL2执行的软件配置PE将物理中断路由到EL2。中断可以是：

• 针对vPE的中断。管理程序在目标vPE上将相应的虚拟INTID设置为挂起状态，并包含关于相关物理INTID的信息。当vPE未在PE上调度时，管理程序可能选择重新调度vPE。否则，中断在vPE上保持挂起，供管理程序稍后调度。

• 针对管理程序的中断。此中断可能：

  • 由系统生成。

  • 是与调度的VM相关的维护中断。有关更多详细信息，请参阅_维护中断_。

  • 在GICv4中，是来自ITS的门铃中断。在GICv4中，可以在没有管理程序参与的情况下向vPE呈现虚拟中断。当为vPE设置虚拟中断挂起但vPE未在PE上调度时，必须生成门铃中断。

管理程序根据第4章_物理中断处理和优先级_中描述的规则处理物理中断，然后将其虚拟化。有关传统操作期间物理中断处理及其虚拟化的信息，请参阅第14章_传统操作和不对称配置_。

GIC虚拟化支持包括存储在硬件List寄存器中的vPE虚拟中断列表，请参阅_List寄存器的使用模型_。列表中的每个条目对应于挂起或活动中断，条目描述虚拟中断号、中断组、中断状态和中断的虚拟优先级。列表条目中描述的虚拟中断可以配置为与物理SPI或PPI关联。

GIC实现从List寄存器中保存的中断列表中选择最高优先级挂起虚拟中断，如果与活动虚拟中断和虚拟优先级掩码相比具有足够的虚拟优先级，则根据中断的组将其呈现为虚拟FIQ或虚拟IRQ。虚拟CPU interface控制以与物理中断控制应用于物理中断相同的方式应用于虚拟中断。因此，使用虚拟CPU interface控制，在vPE上执行的软件可以：

• 设置虚拟优先级掩码。

• 控制如何将虚拟优先级分割为组优先级和子优先级。

• 确认虚拟中断。

• 对虚拟中断执行优先级下降。

• 去激活虚拟中断。

虚拟CPU interface支持两种EOImode，因此虚拟EOI可以单独执行优先级下降，或者组合优先级下降和去激活。

当虚拟中断被确认时，虚拟中断的状态在相应的List寄存器条目中从挂起变为活动。

当虚拟中断被去激活时，虚拟中断的状态在相应的List寄存器条目中从活动变为非活动，或从活动和挂起变为挂起。如果虚拟中断与物理中断关联，则相关的物理中断被去激活。

传递到EL1的虚拟中断以类似于在具有单一安全状态的系统中处理物理中断的方式处理，即GICD_CTLR.DS设置为1的情况：

• Group 0中断使用虚拟FIQ信号发出信号。

• Group 1中断使用虚拟IRQ信号发出信号。

• Group 0和Group 1中断共享中断优先级处理和抢占方案。支持最少32级和最多256级优先级，由ICH_VTR_EL2中的值确定。

注意 优先级值不受用于非安全物理中断的移位影响。虽然虚拟化支持多达8位优先级，但必须实现最少5位和最多8位。

注意 有关Armv8-A PE上异常输入的管理规则的信息，请参阅_Arm[®] Architecture Reference Manual, Armv8, for Armv8-A architecture profile_。

在EL1对Group 0寄存器的访问在以下情况下是虚拟的：

• 当前安全状态是非安全且HCR_EL2.FMO == 1。

• 当前安全状态是安全，HCR_EL2.FMO == 1且SCR_EL3.EEL2 == 1。

对以下Group 0 ICC_*寄存器的虚拟访问访问ICV_*等价物：

• 对ICC_AP0R_EL1的访问访问ICV_AP0R_EL1。

• 对ICC_BPR0_EL1的访问访问ICV_BPR0_EL1。

• 对ICC_EOIR0_EL1的访问访问ICV_EOIR0_EL1。

• 对ICC_HPPIR0_EL1的访问访问ICV_HPPIR0_EL1。

• 对ICC_IAR0_EL1的访问访问ICV_IAR0_EL1。

• 对ICC_IGRPEN0_EL1的访问访问ICV_IGRPEN0_EL1。

在EL1对Group 1寄存器的访问在以下情况下是虚拟的：

• 当前安全状态是非安全且HCR_EL2.IMO == 1。

• 当前安全状态是安全，HCR_EL2.IMO == 1且SCR_EL3.EEL2 == 1。

对以下Group 1 ICC_*寄存器的虚拟访问访问ICV_*等价物：

• 对ICC_AP1R_EL1的访问访问ICV_AP1R_EL1。

• 对ICC_BPR1_EL1的访问访问ICV_BPR1_EL1。

• 对ICC_EOIR1_EL1的访问访问ICV_EOIR1_EL1。

• 对ICC_HPPIR1_EL1的访问访问ICV_HPPIR1_EL1。

• 对ICC_IAR1_EL1的访问访问ICV_IAR1_EL1。

• 对ICC_IGRPEN1_EL1的访问访问ICV_IGRPEN1_EL1。

在EL1对通用寄存器的访问在以下情况下是虚拟的：

• 当前安全状态是非安全且（HCR_EL2.FMO == 1 || HCR_EL2.IMO == 1）。

• 当前安全状态是安全，（HCR_EL2.FMO == 1 || HCR_EL2.IMO == 1）且SCR_EL3.EEL2 == 1。

对以下通用ICC_*寄存器的虚拟访问访问ICV_*等价物：

• 对ICC_RPR_EL1的访问访问ICV_RPR_EL1。

• 对ICC_CTLR_EL1的访问访问ICV_CTLR_EL1。

• 对ICC_DIR_EL1的访问访问ICV_DIR_EL1。

• 对ICC_PMR_EL1的访问访问ICV_PMR_EL1。

对ICC_SGI0R_EL1、ICC_SGI1R_EL1或ICC_ASGI1R_EL1的虚拟写入陷阱到EL2。

在EL2执行的软件可以使用ICH_VMCR_EL2和ICH_VTR_EL2访问某些ICV_*寄存器状态，如下所示：

• ICV_PMR_EL1.Priority别名为ICH_VMCR_EL2.VPMR。

• ICV_BPR0_EL1.BinaryPoint别名为ICH_VMCR_EL2.VBPR0。

• ICV_BPR1_EL1.BinaryPoint别名为ICH_VMCR_EL2.VBPR1。

• ICV_CTLR_EL1.EOImode别名为ICH_VMCR_EL2.VEOIM。

• ICV_CTLR_EL1.CBPR别名为ICH_VMCR_EL2.VCBPR。

• ICV_IGRPEN0_EL1别名为ICH_VMCR_EL2.VENG0。

• ICV_IGRPEN1_EL1.别名为ICH_VMCR_EL2.VENG1。

• ICV_CTLR_EL1.PRIbits别名为ICH_VTR_EL2.PRIbits。

• ICV_CTLR_EL1.IDbits别名为ICH_VTR_EL2.IDbits。

• ICV_CTLR_EL1.SEIS别名为ICH_VTR_EL2.SEIS。

• ICV_CTLR_EL1.A3V别名为ICH_VTR_EL2.A3V。

6.2.1 List寄存器的使用模型

中断控制器的一个基本功能是为每个PE开发按优先级排序的挂起中断列表，然后如果中断具有足够的优先级，则向PE呈现最高优先级中断。对于物理中断，此任务完全在硬件中由GIC执行。但是，为了降低硬件成本，GIC使用硬件和软件处理虚拟中断。

对于接收到的针对vPE的每个物理中断，管理程序将该中断添加到呈现给vPE的优先级排序的挂起虚拟中断列表中。GIC硬件还提供一组List寄存器ICH_LR_EL2，它保存当前运行vPE的优先级排序列表中IMPLEMENTATION DEFINED数量的顶部条目。通常，该vPE最多只有几个挂起虚拟中断。List寄存器中的中断然后由vPE在硬件中处理，为VM提供与非虚拟化操作系统处理物理中断相同的行为。

但是，挂起、活动和挂起或活动的中断总数可能超过可用List寄存器的数量。在这种情况下，管理程序可以将一个或多个条目保存到内存中，然后根据其优先级将它们恢复到List寄存器中。这样，List寄存器充当软件控制的vPE挂起、活动或活动和挂起中断列表的缓存。

List寄存器提供维护中断：

• 用于在List寄存器中没有挂起中断时发出信号，以允许管理程序向List寄存器加载更多挂起中断。

• 用于在List寄存器为空或接近空时发出信号，以允许管理程序从内存中的列表重新填充List寄存器。

• 用于在为不在List寄存器中的条目接收到EOI时发出信号，这可能在活动中断保存在内存中时发生。

• 用于启用和禁用虚拟中断组，这可能导致需要更改List寄存器的内容。

有关维护中断的更多详细信息，请参阅_维护中断_。

注意 尽管List寄存器可能只包含活动中断，管理程序在内存中维护任何挂起中断，但挂起中断无法向vPE发出信号，直到管理程序将其添加到List寄存器中。因此，为了最小化中断延迟并确保vPE的高效操作，Arm强烈建议如果List寄存器可用于此中断，List寄存器至少包含一个挂起中断。

List寄存器构成vPE上下文的一部分。当从在PE上运行的一个vPE切换到另一个vPE时，管理程序相应地切换List寄存器。

List寄存器的数量是IMPLEMENTATION DEFINED，可以通过读取ICH_VTR_EL2来发现。

以下伪代码指示实现的List寄存器数量。

// NumListRegs()
// =============
// 实现的List寄存器数量。此值是IMPLEMENTATION DEFINED。

6.2.2 导致UNPREDICTABLE行为的List寄存器使用

以下情况被认为是软件编程错误，会导致UNPREDICTABLE行为：

• 在单个虚拟CPU interface的List寄存器中有两个或多个具有相同pINTID的中断。

• 在List寄存器中有一个与物理中断关联的ICH_LR_EL2.HW= 1的List寄存器条目处于活动状态或挂起状态，但Distributor没有相应的物理中断处于活动状态或活动和挂起状态。

• 如果ICV_CTLR_EL1.EOImode ==0，则要么：

  • List寄存器中有活动中断，其优先级未在相应的Active Priority Register中设置。

  • List寄存器中有两个处于活动状态且具有相同抢占优先级的中断。

• 当支持GICv4时，为vPE拥有有效的List寄存器和ITS映射，它们使用相同的vINTID。

• 当支持GICv4.1时，拥有vINTID设置为SGI的有效List Register并通过ITS为vPE生成相同的SGI。

6.3 VM的配置和控制

虚拟GIC通过为每个PE保存优先级排序的挂起虚拟中断列表来工作。在GICv3中，此列表在软件中编译，顶部的多个条目在硬件的List寄存器中保存。对于LPI，此列表可以使用每个vPE的表编译。这些表由GICR_*寄存器控制。

管理程序使用在EL2可访问的System register接口来切换上下文和控制多个VM。ICH_* System register中保存的上下文是调度vPE的上下文。vPE在以下情况下调度：

• ICH_HCR_EL2.En == 1。

• HCR_EL2.FMO == 1，当虚拟化Group 0中断时。

• HCR_EL2.IMO == 1，当虚拟化Group 1中断时。

• PE在EL1执行且：

  • SCR_EL3.NS == 1。

  • SCR_EL3.EEL2 == 1。

当调度vPE时，ICH_*_EL2寄存器影响在EL1执行的软件。

ICH_*_EL2寄存器如下控制和维护vPE：

• ICH_HCR_EL2用于虚拟中断的顶级配置和控制。

• 有关实现的信息，如支持的虚拟INTID的大小和优先级处理级别数，从ICH_VTR_EL2读取。

• 管理程序可以使用ICH_VMCR_EL2监视和为ICV_CTLR_EL1提供上下文。

• 一组List寄存器ICH_LREL2由管理程序用于向PE转发挂起中断队列，请参阅_List寄存器的使用模型。ICH_LR_EL2中空闲位置的状态保存在ICH_ELRSR_EL2中。

• List寄存器的中断结束状态保存在ICH_EISR_EL2中。

• VM维护中断状态保存在ICH_MISR_EL2中。

• 活动优先级状态保存在：

  • ICH_AP0R_EL2，其中n = 0-3。

  • ICH_AP1R_EL2，其中n = 0-3。

6.3.1 虚拟中断与物理中断的关联

虚拟中断可以响应物理中断而变为挂起，例如，物理中断被特定VM拥有的外设使用，或者它可以由管理程序因其他原因生成，其中没有相应的物理中断。第二种情况可以用于，例如，当管理程序模拟虚拟外设时。

为了支持这两种模型，对于SPI和PPI，GIC List寄存器提供了一种机制来配置虚拟中断与物理中断关联。物理中断和虚拟中断不一定具有相同的INTID。

将虚拟中断与物理中断关联的使用模型

虚拟中断可以按如下方式与物理中断关联：

1. 管理程序在此模型中配置ICC_CTLR_EL1.EOImode == 1。

2. 在接收针对vPE的物理PPI或物理SPI时，中断被传递给管理程序并由管理程序确认，使物理中断变为活动。

3. 管理程序将虚拟中断插入到目标vPE的挂起中断列表中。当管理程序想要为该中断执行优先级下降时，管理程序执行EOI。管理程序不会去激活中断。

4. 当此虚拟中断在该vPE的挂起中断列表中具有足够高的优先级，并且该vPE在PE上调度时，管理程序将此挂起虚拟中断写入List寄存器，并将ICH_LR_EL2.HW设置为1以指示虚拟中断与物理中断关联。相关物理中断的INTID保存在同一List寄存器中。

5. 当vPE运行时，它将接收挂起虚拟中断，并以与确认物理中断相同的方式确认它，使用虚拟CPU interface。当在vPE上运行的中断处理程序完成其任务，虚拟中断要被去激活时，硬件去激活虚拟中断和相关的物理中断。虚拟中断可能由于中断结束而被去激活（如果ICH_VMCR_EL2.VEOIM== 0），或由于单独的去激活而被去激活（如果ICH_VMCR_EL2.VEOIM == 1）。

6.3.2 Active Priority Register

活动优先级使用ICH_AP0R_EL2和ICH_AP1R_EL2（其中n = 0-3）分别为虚拟Group 0和Group 1中断保存。Active Priority Register对实现的每个优先级组都有一位。在GICv3中，虚拟化支持多达8位优先级。但是，由于中断优先级分组，位[0]不能用于抢占。这意味着最多需要128个活动优先级位来维护上下文。实现的寄存器数量取决于支持的组优先级位数，如表6-1所示。

表6-1 管理程序Active Priority Register中的组位计数

如果ICH_AP0R_EL2寄存器中的某位设置为1，则在非安全EL1或非安全EL0执行时，ICH_AP1R_EL2寄存器中的等价位必须为零，否则GIC的行为是UNPREDICTABLE。

如果ICH_AP1R_EL2寄存器中的某位设置为1，则在非安全EL1或非安全EL0执行时，ICH_AP0R_EL2寄存器中的等价位必须为零，否则GIC的行为是UNPREDICTABLE。

ICH_AP0R_EL2提供多达128位的列表，其中每个实现的可抢占优先级都有一位。如果某位为1，这表示在该优先级组中有一个Group 0中断已被确认但尚未进行优先级下降。如果某位为0，这表示在该优先级没有Group 0中断活动，或该优先级组内的所有活动Group 0中断都已经历了优先级下降。

注意 写入Link寄存器不会对Active Priority Register产生影响。

ICH_AP1R_EL2提供多达128位的列表，其中每个实现的可抢占优先级都有一位。如果某位为1，这表示在该优先级组中有一个Group 1中断已被确认但尚未进行优先级下降。如果某位为0，这表示在该优先级没有Group 1中断活动，或该优先级组内的所有活动Group 1中断都已经历了优先级下降。

向这些寄存器写入任何除寄存器最后读取值或0x00000000之外的值可能导致：

• 否则会抢占执行的虚拟中断不抢占执行。

• 否则不会抢占执行的虚拟中断在EL1或EL0抢占执行。

注意 Arm不期望软件为除以下目的之外的任何目的读取和写入这些寄存器：

• 作为软件电源管理的一部分，保存和恢复状态。
• 在同一PE上的vPE之间进行上下文切换。

按除以下顺序之外的任何顺序写入Active Priority Register会导致UNPREDICTABLE行为：

1. ICH_AP0R_EL2。

2. ICH_AP1R_EL2。

注意

写入ICH_AP0R_EL2和写入ICH_AP1R_EL2之间不需要ISB。

6.3.3 维护中断

维护中断可以在实现虚拟化的GIC操作中发出关键事件的信号。这些事件由管理程序处理。

• 注意

• 只有当虚拟CPU interface的全局启用位ICH_HCR_EL2.En设置为1时，才会生成维护中断。

• Arm强烈建议将维护中断配置为使用INTID 25。有关更多信息，请参阅_Server Base System Architecture (SBSA)_。

维护中断是电平敏感中断。ICH_HCR_EL2中的配置位可以设置为1，以在以下情况下启用维护中断的生成：

• Group 0虚拟中断启用。

• Group 1虚拟中断启用。

• Group 0虚拟中断禁用。

• Group 1虚拟中断禁用。

• List寄存器中没有挂起中断。

• 至少有一个EOI请求发生，但相应中断没有有效的List寄存器条目。

• 没有有效条目，或List寄存器中只有一个有效条目。这是下溢条件。

• 至少有一个List寄存器条目收到了EOI请求。

有关维护中断的控制和状态报告的更多信息，请参阅_ICH_MISR_EL2, Interrupt Controller Maintenance Interrupt State Register_。

6.4 伪代码

以下伪代码指示虚拟活动优先级位数。

// ActiveVirtualPRIBits()
// ======================

integer ActiveVirtualPRIBits()
    if VirtualPRIBits() == 8 then
         return 128;
    else
         return 2^(VirtualPREBits());

以下伪代码指示最高活动组虚拟优先级。

// GetHighestActiveVGroup()
// ========================
// 返回一个值，指示来自两个寄存器设置的最高优先级
// 位的中断组。如果没有位设置，则返回None。

IntGroup GetHighestActiveVGroup(bits(128) avp0, bits(128) avp1)
    for rval = 0 to ActiveVirtualPRIBits() - 1
        if avp0<rval> != '0' then
            return IntGroup_G0;
        elsif avp1<rval> != '0' then
            return IntGroup_G1NS;

    return IntGroup_None;

以下伪代码指示最高活动虚拟优先级。

// GetHighestActiveVPriority()
// ===========================
// 返回来自两个寄存器设置的最高优先级位的索引。

// 如果没有位设置，则返回0xFF。

bits(8) GetHighestActiveVPriority(bits(128) avp0, bits(128) avp1)
    for rval = 0 to ActiveVirtualPRIBits() - 1
        if avp0<rval> != '0' || avp1<rval> != '0' then
            return rval<7:0>;

    return Ones();

以下伪代码指示在提供的Active Priority Register中是否设置了任何位。

// VPriorityBitsSet()
// ==================
// 如果在提供的寄存器中设置了任何位，则返回TRUE，否则返回FALSE

boolean VPriorityBitsSet(bits(128) avp0, bits(128) avp1)
    for i = 0 to ActiveVirtualPRIBits() - 1
        if avp0<i> != '0' || avp1<i> != '0' then
            return TRUE;

    return FALSE;

以下伪代码清除提供的虚拟Active Priority Register中的最高优先级位。

// VPriorityDrop()
// ===============
// 清除提供的寄存器中设置的最高优先级位。

VPriorityDrop[bits(128) &avp0, bits(128) &avp1] = bit v
    assert IsZero(v);
    for i = 0 to ActiveVirtualPRIBits() - 1
        if avp0<i> != v then
            avp0<i> = v;
            return;
        elsif avp1<i> != v then
            avp1<i> = v;
            return;

    return;

以下伪代码指示最高活动组虚拟优先级。

// GetHighestActiveVGroup()

// ========================
// 如果提供的值在实现范围之上有位或
// 如果提供的值超过适当GITS_BASERn中的最大配置大小，则返回TRUE

boolean VCPUOutOfRange(bits(16) vcpu);

以下伪代码指示最高活动虚拟优先级。

// GetHighestActiveVPriority() // ===========================

// 返回来自两个寄存器设置的最高优先级位的索引。

// 如果没有位设置，则返回0xFF。

bits(8) GetHighestActiveVPriority(bits(128) avp0,
    bits(128) avp1) for rval = 0 to ActiveVirtualPRIBits() - 1
    if avp0<rval> != '0' || avp1<rval> != '0'
    then return rval<7:0>;

return Ones();

以下伪代码指示在提供的Active Priority Register中是否设置了任何位。

// VPriorityBitsSet()
// ==================
// 如果在提供的寄存器中设置了任何位，则返回TRUE，否则返回FALSE
    boolean VPriorityBitsSet(bits(128) avp0,
    bits(128) avp1)
    for i = 0 to ActiveVirtualPRIBits() - 1
    if avp0<i> != '0' || avp1<i> != '0' then
    return TRUE;
    return FALSE;

以下伪代码清除提供的虚拟Active Priority Register中的最高优先级位。

// VPriorityDrop()
// ===============
// 清除提供的寄存器中设置的最高优先级位。 VPriorityDrop[bits(128) &avp0,
    bits(128) &avp1] = bit v
    assert IsZero(v);
    for i = 0 to ActiveVirtualPRIBits() - 1
    if avp0<i> != v then avp0<i> = v;
return; elsif avp1<i> != v then avp1<i> = v; return;

return;

以下伪代码确定设置了哪些活动位。

// FindActiveVirtualInterrupt()
// ============================
// 查找匹配的List寄存器。如果没有匹配，则返回-1。

integer FindActiveVirtualInterrupt(bits(INTID_SIZE) vID)

    for i = 0 to NumListRegs() - 1
        if ((ICH_LR_EL2[i].State IN {IntState_Active, IntState_ActivePending}) &&
            ICH_LR_EL2[i].VirtualID<INTID_SIZE-1:0> == vID) then
            return i;

    return -1;

以下伪代码基于最小Binary Point Register指示虚拟组优先级。

// VPriorityGroup()
// ================
// 返回最小BPR值的优先级组字段

bits(8) VPriorityGroup(bits(8) priority, integer group)
    integer vpre_bits = VirtualPREBits();
    mask = Ones(vpre_bits):Zeros(8 - vpre_bits);
    return (priority AND mask);

以下伪代码基于适当的Binary Point Register指示虚拟组优先级。

// VGroupBits()
// ============
// 返回组的当前BPR值的优先级组字段

bits(8) VGroupBits(bits(8) priority, bit group)
  if IsSecure() then
     bpr = UInt(ICH_VMCR_EL2.VBPR1);
  else
     bpr = UInt(ICH_VMCR_EL2.VBPR1) -1;

    if group == '0' || ICH_VMCR_EL2.VCBPR == '1' then
        bpr = UInt(ICH_VMCR_EL2.VBPR0);

    mask = Ones(7-bpr):Zeros(bpr+1);
    return (priority AND mask);

以下伪代码指示虚拟ID位数。

// VIDBits()
// =========

integer VIDBits()
    id_bits = ICH_VTR_EL2.IDbits;
    case id_bits of
        when '000' return 16;
        when '001' return 24;
        otherwise   Unreachable();

以下伪代码指示虚拟抢占位数。

// VirtualPREBits()
// ================

integer VirtualPREBits()
    return UInt(ICH_VTR_EL2.PREbits) + 1;

以下伪代码基于最小Binary Point Register指示虚拟组优先级。

// VPriorityGroup()
// ================
// 返回最小BPR值的优先级组字段
    bits(8) VPriorityGroup(bits(8) priority,
    integer group)
    integer vpre_bits = VirtualPREBits(); mask = Ones(vpre_bits):Zeros(8 - vpre_bits);
    return (priority AND mask);