/* ----------------------------------------------------------------------------
 * Copyright (c) Huawei Technologies Co., Ltd. 2013-2020. All rights reserved.
 * Description: Hwi HeadFile
 * Author: Huawei LiteOS Team
 * Create: 2013-01-01
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 1. Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
 * to endorse or promote products derived from this software without specific prior written
 * permission.
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * --------------------------------------------------------------------------- */

/**
 * @defgroup los_hwi Hardware interrupt
 * @ingroup kernel
 */
#ifndef _LOS_HWI_H
#define _LOS_HWI_H

#include "los_base.h"
#include "hal_hwi.h"
#include "arch/cpu.h"
#include "arch/interrupt.h"

#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */

/**
 * @ingroup los_hwi
 * Count of interrupts.
 */
/*这行代码声明了一个名为g_intCount的数组，但它的定义并不在当前的源文件中。
关键字"extern"告诉编译器该数组是在其他地方定义的，这通常意味着它在其他源文件或库中。
在链接阶段，编译器会去找到实际的g_intCount的定义，然后将其与当前的代码进行链接。*/
extern size_t g_intCount[];

/**
 * An interrupt is active.
 */

extern size_t IntActive(VOID);//IntActive(VOID)函数是用于获取当前活动的中断数量的函数。该函数没有参数，返回类型为无符号整数类型（size_t）。

/**
 * @ingroup los_hwi
 * It is used to check whether there are active interrupts or not.
 *
 * @see OS_INT_INACTIVE
 */

 /*在LiteOS操作系统中，#define OS_INT_ACTIVE IntActive() 是一个预处理指令，用来定义一个宏。它将OS_INT_ACTIVE 定义为调用 IntActive() 函数的结果。

 宏定义是一种在代码中使用的文本替换机制。在这种情况下，
 当代码中出现 OS_INT_ACTIVE 时，预处理器会将其替换为 IntActive() 函数的调用，从
 而实际上就是将函数调用作为一个宏使用。

 这种宏定义的目的可能是为了简化代码书写或提高代码的可读性。
 通过定义宏，可以通过简单的名称（OS_INT_ACTIVE）来表示复杂的函数调用（IntActive()），
 从而使代码更加简洁和易于理解。*/
#define OS_INT_ACTIVE IntActive()

/**
 * @ingroup los_hwi
 * Check whether there are active interrupts or not.
 * The API returns a boolean value. True means no active interrupts on the current CPU.
 * False means that there are active interrupts on the current CPU.
 *
 * @see OS_INT_ACTIVE
 */
/*在LiteOS操作系统中，#define OS_INT_INACTIVE (!(OS_INT_ACTIVE)) 是一个预处理指令，
用来定义一个宏。它将OS_INT_INACTIVE 定义为对 OS_INT_ACTIVE 取反的结果。

具体来说，OS_INT_ACTIVE 是一个宏，表示调用 IntActive() 函数的结果。
而 OS_INT_INACTIVE 是另一个宏，表示对 OS_INT_ACTIVE 取反的结果。
在这种情况下，使用逻辑非运算符 ! 将 OS_INT_ACTIVE 的结果取反。

这个宏定义的目的可能是用于表示当前中断是否处于非活动状态。
如果 OS_INT_ACTIVE 为真（非零），则表示中断处于活动状态；
而 OS_INT_INACTIVE 则为假（零），表示中断处于非活动状态。

通过这种方式定义宏，可以方便地在代码中判断中断状态并进行相应的处理。
代码中使用 OS_INT_INACTIVE 可以更加直观地表示中断是否处于非活动状态，
提高代码的可读性和可维护性。
*/
#define OS_INT_INACTIVE (!(OS_INT_ACTIVE))

/**
 * @ingroup los_hwi
 * Highest priority of a hardware interrupt.This is an external parameter.
 * The priority range is [OS_HWI_PRIO_HIGHEST, OS_HWI_PRIO_HIGHEST + LOSCFG_HWI_PRIO_LIMIT - 1].
 */
/*在LiteOS操作系统中，#define OS_HWI_PRIO_HIGHEST 0 是一个预处理指令，
用来定义一个宏。它将 OS_HWI_PRIO_HIGHEST 定义为数字 0。

在LiteOS操作系统中，中断（Interrupt）也被称为硬件中断（Hardware Interrupt），
简称为 HWI。HWI具有不同的优先级（Priority），优先级越高，中断响应的时间越短。
OS_HWI_PRIO_HIGHEST 是一个表示最高中断优先级的宏，其值为 0。

在LiteOS操作系统中，中断的优先级是用数字表示的，数字越小表示优先级越高。
因此，OS_HWI_PRIO_HIGHEST 表示的是最高中断优先级，也就是数字最小的中断优先级。
在一些特定场景下，需要使用最高中断优先级，
这时候可以使用 OS_HWI_PRIO_HIGHEST 宏来表示最高中断优先级的数字值 0，
从而方便地进行代码编写。*/
#define OS_HWI_PRIO_HIGHEST 0

/**
 * @ingroup los_hwi
 * This represents the interrupt priority range, the larger number, the lower priority, the interrupt processor is
 * modified uniformly.
 */
/*在LiteOS操作系统中，
#define OS_HWI_PRIO_LOWEST (LOSCFG_HWI_PRIO_LIMIT - 1) 是一个预处理指令，
用来定义一个宏。它将 OS_HWI_PRIO_LOWEST 定义为 LOSCFG_HWI_PRIO_LIMIT 减去 1 的结果。

在LiteOS操作系统中，中断（Interrupt）也被称为硬件中断（Hardware Interrupt），
简称为 HWI。HWI具有不同的优先级（Priority），优先级越高，中断响应的时间越短。OS_HWI_PRIO_LOWEST 是一个表示最低中断优先级的宏，其值为 LOSCFG_HWI_PRIO_LIMIT - 1。

LOSCFG_HWI_PRIO_LIMIT 是一个配置参数，用于表示系统支持的最大中断优先级数。
因此，OS_HWI_PRIO_LOWEST 表示的是最低中断优先级，也就是数字最大的中断优先级，
其值等于最大中断优先级数减去 1。
在一些特定场景下，需要使用最低中断优先级，
这时候可以使用 OS_HWI_PRIO_LOWEST 宏来表示最低中断优先级的数字值，从而方便地进行代码编写。*/
#define OS_HWI_PRIO_LOWEST (LOSCFG_HWI_PRIO_LIMIT - 1)

/**
 * @ingroup los_hwi
 * The lower priority number, the higher priority, so OS_HWI_PRIO_LOWEST big than OS_HWI_PRIO_HIGHEST.
 */
/*该宏接受一个参数 pri，表示要判断的中断优先级值。
宏的定义使用了逻辑与运算符 && 和比较运算符 >=、<=。
具体解释如下：

((pri) >= OS_HWI_PRIO_HIGHEST) 表示判断 pri 是否大于等于最高中断优先级（OS_HWI_PRIO_HIGHEST）。如果 pri 大于等于最高中断优先级，则该条件结果为真（非零）；否则为假（零）。
((pri) <= OS_HWI_PRIO_LOWEST) 表示判断 pri 是否小于等于最低中断优先级（OS_HWI_PRIO_LOWEST）。如果 pri 小于等于最低中断优先级，则该条件结果为真（非零）；否则为假（零）。
整个宏定义将以上两个条件使用逻辑与运算符 && 连接起来，
即 (((pri) >= OS_HWI_PRIO_HIGHEST) && ((pri) <= OS_HWI_PRIO_LOWEST))。
只有当 pri 同时满足大于等于最高中断优先级和小于等于最低中断优先级时，
该条件结果为真（非零），表示中断优先级有效；否则为假（零），表示中断优先级无效。
这个宏的作用是在进行中断优先级的判断和设置时，
确保所使用的中断优先级值在有效范围内，避免出现错误的中断优先级设置。*/
#define HWI_PRI_VALID(pri) (((pri) >= OS_HWI_PRIO_HIGHEST) && ((pri) <= OS_HWI_PRIO_LOWEST))

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: Invalid interrupt number.
 *
 * Value: 0x02000900.
 *
 * Solution: Ensure that the interrupt number is valid.
 * @attention
 * <ul>
 * <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
 * </ul>
 */
/*是两个预处理指令，用来定义错误码。

这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：

LOS_ERRNO_HWI_NUM_INVALID 是一个表示无效中断号的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，
它接受两个参数：模块号和错误码值。
其中，LOS_MOD_HWI 表示HWI模块的模块号，0x00 表示错误码值。
因此，LOS_ERRNO_HWI_NUM_INVALID 的值就是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_NUM_INVALID 是 LOS_ERRNO_HWI_NUM_INVALID 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示无效中断号的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在配置和使用中断时，如果遇到了无效的中断号，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_NUM_INVALID 或 OS_ERRNO_HWI_NUM_INVALID，
来判断中断号是否有效，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_NUM_INVALID               LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x00)
#define OS_ERRNO_HWI_NUM_INVALID                LOS_ERRNO_HWI_NUM_INVALID

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: Null hardware interrupt handling function.
 *
 * Value: 0x02000901.
 *
 * Solution: Pass in a valid non-null hardware interrupt handling function.
 * @attention
 * <ul>
 * <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
 * </ul>
 */
/*是两个预处理指令，用来定义错误码。

这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：

LOS_ERRNO_HWI_PROC_FUNC_NULL 是一个表示中断处理函数为空的错误码。该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，
它接受两个参数：模块号和错误码值。
其中，LOS_MOD_HWI 表示HWI模块的模块号，0x01 表示错误码值。
因此，LOS_ERRNO_HWI_PROC_FUNC_NULL 的值就是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_PROC_FUNC_NULL 是 LOS_ERRNO_HWI_PROC_FUNC_NULL 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示中断处理函数为空的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在配置和使用中断时，如果中断处理函数为空，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_PROC_FUNC_NULL 或 OS_ERRNO_HWI_PROC_FUNC_NULL，来判断中断处理函数是否正确设置，
进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_PROC_FUNC_NULL            LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x01)
#define OS_ERRNO_HWI_PROC_FUNC_NULL             LOS_ERRNO_HWI_PROC_FUNC_NULL

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: Insufficient interrupt resources for hardware interrupt creation.
 *
 * Value: 0x02000902.
 *
 * Solution: This error code is not in use temporarily.
 * @deprecated This error code is obsolete since LiteOS 5.0.0.
 */
/**/
/*定义了一个错误码，表示硬件中断（HWI）回调函数不可用的情况。
具体解释如下：

OS_ERRNO_HWI_CB_UNAVAILABLE 是用来表示硬件中断（HWI）回调函数不可用的错误码。
它由 LOS_ERRNO_OS_ERROR 宏生成，该宏接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x02 表示错误码值。
因此，OS_ERRNO_HWI_CB_UNAVAILABLE 的值是根据模块号和错误码值计算得出的。
这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置和注册中断回调函数时，如果回调函数不可用，
可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_CB_UNAVAILABLE，来判断回调函数的可用性，
从而进行相应的错误处理。*/
#define OS_ERRNO_HWI_CB_UNAVAILABLE LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x02)

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: Insufficient memory for hardware interrupt initialization.
 *
 * Value: 0x02000903.
 *
 * Solution: Expand the configured memory.
 * @attention
 * <ul>
 * <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
 * </ul>
 */
/*是两个预处理指令，用来定义错误码。

这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：

LOS_ERRNO_HWI_NO_MEMORY 是一个表示无法分配内存的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
其中，LOS_MOD_HWI 表示HWI模块的模块号，0x03 表示错误码值。
因此，LOS_ERRNO_HWI_NO_MEMORY 的值就是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_NO_MEMORY 是 LOS_ERRNO_HWI_NO_MEMORY 的别名。通过将其定义为相同的值，
可以在代码中使用更简洁的名称来表示无法分配内存的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置和注册中断处理函数时，如果出现无法分配内存的情况，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_NO_MEMORY 或 OS_ERRNO_HWI_NO_MEMORY，
来判断内存是否分配成功，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_NO_MEMORY                 LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x03)
#define OS_ERRNO_HWI_NO_MEMORY                  LOS_ERRNO_HWI_NO_MEMORY

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: The interrupt has already been created.
 *
 * Value: 0x02000904.
 *
 * Solution: Check whether the interrupt specified by the passed-in interrupt number has
 * already been created.
 * @attention
 * <ul>
 * <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
 * </ul>
 */
/*是两个预处理指令，用于定义错误码。

这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：

LOS_ERRNO_HWI_ALREADY_CREATED 是一个表示中断已经被创建的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x04 表示错误码值。
因此，LOS_ERRNO_HWI_ALREADY_CREATED 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_ALREADY_CREATED 是 LOS_ERRNO_HWI_ALREADY_CREATED 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示中断已经被创建的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在创建中断时，如果中断已经被创建，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_ALREADY_CREATED 或 OS_ERRNO_HWI_ALREADY_CREATED，
来判断中断是否已经存在，从而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_ALREADY_CREATED           LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x04)
#define OS_ERRNO_HWI_ALREADY_CREATED            LOS_ERRNO_HWI_ALREADY_CREATED

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: Invalid interrupt priority.
 *
 * Value: 0x02000905.
 *
 * Solution: Ensure that the interrupt priority is valid.
 * @attention
 * <ul>
 * <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
 * </ul>
 */
/*是两个预处理指令，用于定义错误码。

这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：

LOS_ERRNO_HWI_PRIO_INVALID 是一个表示中断优先级无效的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x05 表示错误码值。
因此，LOS_ERRNO_HWI_PRIO_INVALID 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_PRIO_INVALID 是 LOS_ERRNO_HWI_PRIO_INVALID 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示中断优先级无效的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置中断优先级时，如果提供了无效的优先级值，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_PRIO_INVALID 或 OS_ERRNO_HWI_PRIO_INVALID，来判断优先级是否有效，
进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_PRIO_INVALID              LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x05)
#define OS_ERRNO_HWI_PRIO_INVALID               LOS_ERRNO_HWI_PRIO_INVALID

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: Incorrect interrupt creation mode.
 *
 * Value: 0x02000906.
 *
 * Solution: This error code is not in use temporarily.
 * @deprecated This error code is obsolete since LiteOS 5.0.0.
 */
/*是一个预处理指令，用于定义错误码。

该错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，
具体来说是中断模式无效的错误。
它是通过使用LiteOS提供的错误码宏 LOS_ERRNO_OS_ERROR 来定义的。
该宏接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x06 表示错误码值。
因此，OS_ERRNO_HWI_MODE_INVALID 的值是根据模块号和错误码值计算得出的。
这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置中断模式时，如果提供了无效的模式值，
可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_MODE_INVALID ，
来判断模式是否有效，进而进行相应的错误处理。*/
#define OS_ERRNO_HWI_MODE_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x06)

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: The interrupt has already been created as a fast interrupt.
 *
 * Value: 0x02000907.
 *
 * Solution: This error code is not in use temporarily.
 * @deprecated This error code is obsolete since LiteOS 5.0.0.
 */
/*是一个预处理指令，用于定义错误码。

该错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，
具体来说是快速中断模式已经被创建的错误。
它是通过使用LiteOS提供的错误码宏 LOS_ERRNO_OS_ERROR 来定义的。
该宏接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x07 表示错误码值。
因此，OS_ERRNO_HWI_FASTMODE_ALREADY_CREATED 的值是根据模块号和错误码值计算得出的。

这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在创建快速中断模式时，如果该模式已经被创建，
可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_FASTMODE_ALREADY_CREATED ，
来判断快速中断模式是否已经存在，从而进行相应的错误处理。*/
#define OS_ERRNO_HWI_FASTMODE_ALREADY_CREATED LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x07)

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: The API is called during an interrupt, which is not allowed.
 *
 * Value: 0x02000908.
 *
 * Solution: This error code is not in use temporarily.
 * @attention
 * <ul>
 * <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
 * </ul>
 */
/*是两个预处理指令，用于定义错误码。

这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是硬件中断发生错误的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：

LOS_ERRNO_HWI_INTERR 是一个表示硬件中断发生错误的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，
它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x08 表示错误码值。
因此，LOS_ERRNO_HWI_INTERR 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_INTERR 是 LOS_ERRNO_HWI_INTERR 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示硬件中断发生错误的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在中断处理函数中，如果硬件中断发生错误，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_INTERR 或 OS_ERRNO_HWI_INTERR，
来判断中断是否发生了错误，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_INTERR                    LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x08)
#define OS_ERRNO_HWI_INTERR                     LOS_ERRNO_HWI_INTERR

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: the hardware interrupt supports SHARED error.
 *
 * Value: 0x02000909.
 *
 * Solution: Check the input params hwiMode and irqParam of LOS_HwiCreate or
 * LOS_HwiDelete whether adapt the current hardware interrupt.
 * @attention
 * <ul>
 * <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
 * </ul>
 */
/*是两个预处理指令，用于定义错误码。

这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是共享中断错误的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：

LOS_ERRNO_HWI_SHARED_ERROR 是一个表示共享中断错误的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x09 表示错误码值。
因此，LOS_ERRNO_HWI_SHARED_ERROR 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_SHARED_ERROR 是 LOS_ERRNO_HWI_SHARED_ERROR 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示共享中断错误的错误码。
这些错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在设置共享中断时，如果发生了错误，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_SHARED_ERROR 或 OS_ERRNO_HWI_SHARED_ERROR，
来判断共享中断是否设置成功，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_SHARED_ERROR              LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x09)
#define OS_ERRNO_HWI_SHARED_ERROR               LOS_ERRNO_HWI_SHARED_ERROR

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: Invalid interrupt Arg when interrupt mode is IRQF_SHARED.
 *
 * Value: 0x0200090a.
 *
 * Solution: This error code is not in use temporarily.
 * @deprecated This error code is obsolete since LiteOS 5.0.0.
 */
/*是一个预处理指令，用于定义错误码。

这个错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是硬件中断参数无效的错误。
它是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：

OS_ERRNO_HWI_ARG_INVALID 是一个表示硬件中断参数无效的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x0a 表示错误码值。
因此，OS_ERRNO_HWI_ARG_INVALID 的值是根据模块号和错误码值计算得出的。
这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在注册硬件中断处理函数时，如果传递给函数的参数无效，
可以通过检查返回的错误码是否等于 OS_ERRNO_HWI_ARG_INVALID，来判断参数是否有效，
进而进行相应的错误处理。*/
#define OS_ERRNO_HWI_ARG_INVALID LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x0a)

/**
 * @ingroup los_hwi
 * Hardware interrupt error code: The interrupt corresponded to the hardware interrupt number
 * or devid has not been created.
 *
 * Value: 0x0200090b.
 *
 * Solution: Check the irqParam->pDevId of LOS_HwiDelete, make sure the devid need to delete.
 * @attention
 * <ul>
 * <li>Please use macros starting with LOS, and macros starting with OS will not be supported.</li>
 * </ul>
 */
/*是两个预处理指令，用于定义错误码。

这些错误码用于表示在操作系统的硬件中断（HWI）模块中发生的错误，具体来说是硬件中断号未创建的错误。
它们是通过使用LiteOS提供的错误码宏来定义的。
具体解释如下：

LOS_ERRNO_HWI_HWINUM_UNCREATE 是一个表示硬件中断号未创建的错误码。
该错误码的值由 LOS_ERRNO_OS_ERROR 宏生成，它接受两个参数：模块号和错误码值。
在这里，LOS_MOD_HWI 表示HWI模块的模块号，0x0b 表示错误码值。
因此，LOS_ERRNO_HWI_HWINUM_UNCREATE 的值是根据模块号和错误码值计算得出的。
OS_ERRNO_HWI_HWINUM_UNCREATE 是 LOS_ERRNO_HWI_HWINUM_UNCREATE 的别名。
通过将其定义为相同的值，可以在代码中使用更简洁的名称来表示硬件中断号未创建的错误码。
这个错误码可以在编程过程中用于判断和处理HWI模块相关的错误情况。
例如，在请求处理某个硬件中断时，如果指定的中断号未创建，
可以通过检查返回的错误码是否等于 LOS_ERRNO_HWI_HWINUM_UNCREATE 或 OS_ERRNO_HWI_HWINUM_UNCREATE，
来判断中断号是否有效，进而进行相应的错误处理。*/
#define LOS_ERRNO_HWI_HWINUM_UNCREATE           LOS_ERRNO_OS_ERROR(LOS_MOD_HWI, 0x0b)
#define OS_ERRNO_HWI_HWINUM_UNCREATE            LOS_ERRNO_HWI_HWINUM_UNCREATE

/**
 * @ingroup los_hwi
 * Define the type HWI_HANDLE_T for a hardware interrupt number, the type is an unsigned int.
 */
//这行代码定义了一个新的类型 HWI_HANDLE_T，它被定义为 UINT32，即无符号32位整数。在这里，HWI_HANDLE_T 被用来表示硬件中断的句柄或标识符。
typedef UINT32 HWI_HANDLE_T;

/**
 * @ingroup los_hwi
 * Define the type HWI_PRIOR_T for a hardware interrupt priority, the type is an unsigned short.
 */
//这行代码定义了一个新的类型 HWI_PRIOR_T，它被定义为 UINT16，即无符号16位整数。在这里，HWI_PRIOR_T 被用来表示硬件中断的优先级。
typedef UINT16 HWI_PRIOR_T;

/**
 * @ingroup los_hwi
 * Define the type HWI_MODE_T for hardware interrupt mode configurations, the type is an unsigned short.
 */
//这行代码定义了一个新的类型 HWI_MODE_T，它被定义为 UINT16，即无符号16位整数。在这里，HWI_MODE_T 被用来表示硬件中断的模式配置。
typedef UINT16 HWI_MODE_T;

/**
 * @ingroup los_hwi
 * Define the type HWI_ARG_T for the parameter used for the hardware interrupt creation function.
 * The function of this parameter varies among platforms.
 */
/*这行代码定义了一个新的类型 HWI_ARG_T，它被定义为 UINTPTR，
即一个无符号整数，其大小与指针大小相同。
在这里，HWI_ARG_T 被用来表示硬件中断创建函数的参数，其具体含义会因平台而异。*/
typedef UINTPTR HWI_ARG_T;

/**
 * @ingroup  los_hwi
 * @brief Define the type of a hardware interrupt handling function.
 *
 * @par Description:
 * This definition is used to declare the type of a hardware interrupt handling function.
 * It will be used when calling LOS_HwiCreate.
 * @attention
 * None.
 *
 * @param None.
 *
 * @retval None.
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see LOS_HwiCreate
 * @since Huawei LiteOS V100R001C00
 */
/*这行代码定义了一个函数指针类型 HWI_PROC_FUNC，它指向一个没有参数和返回值的函数。
在这里，HWI_PROC_FUNC 被用来表示硬件中断处理函数的类型。*/
typedef VOID (*HWI_PROC_FUNC)(VOID);

/**
 * @ingroup  los_hwi
 * The flag means the IRQ is allowed to share among several devices.
 *
 * The flag only used by the kernel as part of the IRQ handling routines.
 */
/*这个宏定义了一个常量 IRQF_SHARED，其值为 0x8000U。
在这里，IRQF_SHARED 用于表示一个共享的硬件中断。*/
#define IRQF_SHARED 0x8000U

/**
 * @ingroup  los_hwi
 * The hardware interrupt parameter for #LOS_HwiDelete and interrupt handler in #LOS_HwiCreate.
 */
/*这个代码定义了一个名为 HWI_IRQ_PARAM_S 的结构体类型，结构体内包含了以下成员：
int swIrq: 表示中断号的整数变量。
VOID *pDevId: 表示触发中断的设备ID的指针变量。
const CHAR *pName: 表示中断名称的指针变量。

这个结构体类型 HWI_IRQ_PARAM_S 用作 LOS_HwiDelete 函数和 LOS_HwiCreate 函数中的硬件中断参数。
通过使用这个结构体，
可以传递中断号、设备ID和中断名称等信息给函数，以进行相应的操作或处理。*/
typedef struct tagIrqParam {
    int swIrq;          /**< The interrupt number */
    VOID *pDevId;       /**< The pointer to the device ID that launches the interrupt */
    const CHAR *pName;  /**< The interrupt name */
} HWI_IRQ_PARAM_S;

/**
 * @ingroup los_hwi
 * @brief Disable all interrupts.
 *
 * @par Description:
 * This API is used to disable all IRQ and FIQ interrupts in the CPSR.
 * @attention
 * None.
 *
 * @param None.
 *
 * @retval #UINT32 CPSR value before all interrupts are disabled.
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see LOS_IntRestore
 * @since Huawei LiteOS V100R001C00
 */
/*这段代码定义了一个静态内联函数 LOS_IntLock()，具体解释如下：

STATIC INLINE：

STATIC 关键字指示该函数的作用域为当前文件，在其他文件中不可见。
INLINE 关键字告诉编译器将该函数的代码插入到调用处，而不是生成函数调用。
UINT32：

UINT32 表示返回值类型为无符号32位整数。
LOS_IntLock(VOID)：

LOS_IntLock 是函数的名称，它接受一个 VOID 参数，表示没有输入参数。
return ArchIntLock();：

这行代码调用了 ArchIntLock() 函数，并将其返回值作为 LOS_IntLock() 函数的返回值。
ArchIntLock() 是一个硬件相关的函数，用于禁用中断，并返回之前的中断状态。
因为函数声明为内联函数且函数体非常简单，
所以编译器会在调用处直接插入 ArchIntLock() 的代码，提高执行效率。
总结：LOS_IntLock() 函数是一个内联函数，
它调用底层的 ArchIntLock() 函数来禁用中断，并返回之前的中断状态。
这个函数的目的是为了保护关键代码区域，防止被中断打断，以确保数据的一致性和可靠性。*/
STATIC INLINE UINT32 LOS_IntLock(VOID)
{
    return ArchIntLock();
}

/**
 * @ingroup los_hwi
 * @brief Enable all interrupts.
 *
 * @par Description:
 * This API is used to enable all IRQ and FIQ interrupts in the CPSR.
 * @attention
 * None.
 *
 * @param None.
 *
 * @retval #UINT32 CPSR value after all interrupts are enabled.
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see LOS_IntLock
 */
/*return ArchIntUnlock();：

这行代码调用了 ArchIntUnlock() 函数，并将其返回值作为 LOS_IntUnLock() 函数的返回值。
ArchIntUnlock() 是一个硬件相关的函数，用于恢复之前被禁用的中断状态。
总结：LOS_IntUnLock() 函数是一个内联函数，
它调用底层的 ArchIntUnlock() 函数来恢复之前被禁用的中断状态。
这个函数的目的是为了在临界区执行完毕后，恢复中断，允许其他中断事件发生。*/
STATIC INLINE UINT32 LOS_IntUnLock(VOID)
{
    return ArchIntUnlock();
}

/**
 * @ingroup los_hwi
 * @brief Restore interrupts.
 *
 * @par Description:
 * This API is used to restore the CPSR value obtained before all interrupts are disabled by #LOS_IntLock.
 * @attention
 * This API can be called only after all interrupts are disabled, and the input parameter value should be
 * the value returned by #LOS_IntLock.
 *
 * @param intSave [IN] Type #UINT32. CPSR value before all interrupts are disabled.
 *
 * @retval None.
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see LOS_IntLock
 * @since Huawei LiteOS V100R001C00
 */
/*ArchIntRestore(intSave);：

这行代码调用了 ArchIntRestore() 函数，将之前保存的中断状态作为参数传递给它。
ArchIntRestore() 是一个硬件相关的函数，用于根据传入的中断状态值恢复中断。
总结：LOS_IntRestore() 函数是一个内联函数，
它调用底层的 ArchIntRestore() 函数来根据之前保存的中断状态恢复中断。
这个函数的目的是在一段被禁用中断的代码执行完毕后，恢复中断状态，允许其他中断事件发生。
由于函数没有返回值，所以不会返回任何结果。*/
STATIC INLINE VOID LOS_IntRestore(UINT32 intSave)
{
    ArchIntRestore(intSave);
}

/**
 * @ingroup  los_hwi
 * @brief Create a hardware interrupt.
 *
 * @par Description:
 * This API is used to configure a hardware interrupt and register a hardware interrupt handling function.
 *
 * @attention
 * <ul>
 * <li>The hardware interrupt module is usable only when the configuration item for
 * hardware interrupt tailoring is enabled.</li>
 * <li>Before executing an interrupt on a platform, refer to the chip manual of the platform.</li>
 * <li>The parameter handler of this interface is a interrupt handler, it should be correct, otherwise,
 * the system may be abnormal.</li>
 * <li>The input irqParam could be NULL, if not, it should be address which point to a struct HWI_IRQ_PARAM_S,
 * the parameter pDenId and pName should be constant.</li>
 * <li>A smaller value indicates a higher interrupt priority, the interrupt processor is modified uniformly.</li>
 * </ul>
 *
 * @param  hwiNum     [IN] Type #HWI_HANDLE_T. The hardware interrupt number. The value range is
                                              [OS_USER_HWI_MIN, OS_USER_HWI_MAX].
 * @param  hwiPrio    [IN] Type #HWI_PRIOR_T. The hardware interrupt priority. The value range is
 *                                            [OS_HWI_PRIO_HIGHEST, OS_HWI_PRIO_LOWEST].
 * @param  hwiMode    [IN] Type #HWI_MODE_T. The hardware interrupt mode.
 * @param  hwiHandler [IN] Type #HWI_PROC_FUNC. The interrupt handler used when a hardware interrupt is triggered.
 * @param  irqParam   [IN] Type #HWI_IRQ_PARAM_S. The input parameter of the interrupt handler used when
 *                                                a hardware interrupt is triggered.
 *
 * @retval #LOS_ERRNO_HWI_PROC_FUNC_NULL      Null hardware interrupt handling function.
 * @retval #LOS_ERRNO_HWI_NUM_INVALID         Invalid interrupt number.
 * @retval #LOS_ERRNO_HWI_NO_MEMORY           Insufficient memory for hardware interrupt creation.
 * @retval #LOS_ERRNO_HWI_ALREADY_CREATED     The interrupt handler being created has already been created.
 * @retval #LOS_ERRNO_HWI_SHARED_ERROR        The interrupt can not be shared. The interrupt number has been
 *                                            registered as a non-shared interrupt, or a shared interrupt is
 *                                            specified to be created, but the device ID is empty.
 * @retval #LOS_OK                            The interrupt is successfully created.
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see LOS_HwiDelete
 * @since Huawei LiteOS V100R001C00
 */
extern UINT32 LOS_HwiCreate(HWI_HANDLE_T hwiNum,//表示中断号或中断向量的标识。
                            HWI_PRIOR_T hwiPrio,//表示中断的优先级。
                            HWI_MODE_T hwiMode,//表示中断的模式（如边沿触发、电平触发等）。
                            HWI_PROC_FUNC hwiHandler,//表示中断处理函数的指针。
                            HWI_IRQ_PARAM_S *irqParam);//表示中断参数的结构体指针。

/**
 * @ingroup  los_hwi
 * @brief delete a hardware interrupt.
 *
 * @par Description:
 * This API is used to delete a hardware interrupt.
 *
 * @attention
 * <ul>
 * <li>The hardware interrupt module is usable only when the configuration item for
 * hardware interrupt tailoring is enabled.</li>
 * <li>Hardware interrupt number value range: [OS_USER_HWI_MIN, OS_USER_HWI_MAX].</li>
 * <li>Before executing an interrupt on a platform, refer to the chip manual of the platform.</li>
 * </ul>
 *
 * @param  hwiNum   [IN] Type #HWI_HANDLE_T. The hardware interrupt number.
 * @param  irqParam [IN] Type #HWI_IRQ_PARAM_S *. ID of hardware interrupt which will base on
 *                                                when delete the hardware interrupt.
 *
 * @retval #LOS_ERRNO_HWI_NUM_INVALID         Invalid interrupt number.
 * @retval #LOS_ERRNO_HWI_SHARED_ERROR        The interrupt number is a shared interrupt, but the device ID of the
 *                                            shared interrupt to be deleted is not specified.
 * @retval #LOS_ERRNO_HWI_HWINUM_UNCREATE     The interrupt corresponded to the hwiNum(
 *                                            the hardware interrupt number) or
 *                                            irqParam->pDevId(the interrupt device id)
 *                                            has not been created.
 * @retval #LOS_ERRNO_HWI_PROC_FUNC_NULL      Not supported disable interrupt.
 * @retval #LOS_OK                            The interrupt is successfully deleted.
 *
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see LOS_HwiCreate
 * @since Huawei LiteOS V100R001C00
 */
//是一个函数声明，用于在 LiteOS 操作系统中删除一个中断处理程序。
/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要删除的中断号或中断向量的标识。
HWI_IRQ_PARAM_S *irqParam 是函数的第二个参数，表示中断参数的结构体指针。*/
extern UINT32 LOS_HwiDelete(HWI_HANDLE_T hwiNum, HWI_IRQ_PARAM_S *irqParam);

/**
 * @ingroup los_hwi
 * @brief Trigger interrupts.
 *
 * @par Description:
 * The generation of external hardware interrupts is simulated by writing
 * the relevant registers of the interrupt controller.
 * @attention
 * This function depends on the hardware implementation of the interrupt controller.
 *
 * @param hwiNum   [IN] Type #HWI_HANDLE_T. The hardware interrupt number.
 *
 * @retval #LOS_ERRNO_HWI_NUM_INVALID         Invalid interrupt number.
 * @retval #LOS_ERRNO_HWI_PROC_FUNC_NULL      Not supported by the interrupt controller.
 * @retval #LOS_OK                            The interrupt is successfully triggered.
 *
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @since Huawei LiteOS V200R005C00
 */
//是一个函数声明，用于在 LiteOS 操作系统中触发一个指定的中断。
//HWI_HANDLE_T hwiNum 是函数的参数，表示要触发的中断号或中断向量的标识。
extern UINT32 LOS_HwiTrigger(HWI_HANDLE_T hwiNum);

/**
 * @ingroup los_hwi
 * @brief clear interrupts.
 *
 * @par Description:
 * Clear the status bit of the interrupt number corresponding to the interrupt controller.
 * @attention
 * This function depends on the hardware implementation of the interrupt controller.
 *
 * @param hwiNum   [IN] Type #HWI_HANDLE_T. The hardware interrupt number.
 *
 * @retval #LOS_ERRNO_HWI_NUM_INVALID         Invalid interrupt number.
 * @retval #LOS_ERRNO_HWI_PROC_FUNC_NULL      Not supported by the interrupt controller.
 * @retval #LOS_OK                            The interrupt is successfully cleared.
 *
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @since Huawei LiteOS V200R005C00
 */
//是一个函数声明，用于在 LiteOS 操作系统中清除（复位）一个指定的中断。
/*HWI_HANDLE_T hwiNum 是函数的参数，表示要清除的中断号或中断向量的标识。
函数的作用是根据指定的中断号，将相应的中断标志位清除，即将中断状态复位。
通过调用该函数，可以清除中断触发后的状态，以便重新准备下一次中断处理。*/
extern UINT32 LOS_HwiClear(HWI_HANDLE_T hwiNum);

/**
 * @ingroup los_hwi
 * @brief Enable interrupts.
 *
 * @par Description:
 * Enable the corresponding interrupt mask of the interrupt controller, so
 * that the interrupt source can be sent to the CPU.
 * @attention
 * This function depends on the hardware implementation of the interrupt controller.
 *
 * @param hwiNum   [IN] Type #HWI_HANDLE_T. The hardware interrupt number.
 *
 * @retval #LOS_ERRNO_HWI_NUM_INVALID         Invalid interrupt number.
 * @retval #LOS_ERRNO_HWI_PROC_FUNC_NULL      Not supported by the interrupt controller.
 * @retval #LOS_OK                            The interrupt is successfully enabled.
 *
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see LOS_HwiDisable
 * @since Huawei LiteOS V200R005C00
 */
//是一个函数声明，用于在 LiteOS 操作系统中使能（启用）一个指定的中断。
/*HWI_HANDLE_T hwiNum 是函数的参数，表示要使能的中断号或中断向量的标识。
函数的作用是根据指定的中断号，将相应的中断使能位设置为有效，即启用该中断。
启用中断后，当满足中断触发条件时，系统将会跳转执行对应的中断处理程序。*/
extern UINT32 LOS_HwiEnable(HWI_HANDLE_T hwiNum);

/**
 * @ingroup los_hwi
 * @brief Disable interrupts.
 *
 * @par Description:
 * Disable the corresponding interrupt mask of the interrupt controller, so
 * that the interrupt source can be sent to the CPU.
 * @attention
 * This function depends on the hardware implementation of the interrupt controller.
 *
 * @param hwiNum   [IN] Type #HWI_HANDLE_T. The hardware interrupt number.
 *
 * @retval #LOS_ERRNO_HWI_NUM_INVALID         Invalid interrupt number.
 * @retval #LOS_ERRNO_HWI_PROC_FUNC_NULL      Not supported by the interrupt controller.
 * @retval #LOS_OK                            The interrupt is successfully disabled.
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see LOS_HwiEnable
 * @since Huawei LiteOS V200R005C00
 */
//是一个函数声明，用于在 LiteOS 操作系统中禁用（关闭）一个指定的中断。
/*HWI_HANDLE_T hwiNum 是函数的参数，表示要禁用的中断号或中断向量的标识。
函数的作用是根据指定的中断号，将相应的中断使能位设置为无效，即禁用该中断。
禁用中断后，即使满足中断触发条件，系统也不会跳转执行对应的中断处理程序。*/
extern UINT32 LOS_HwiDisable(HWI_HANDLE_T hwiNum);

#ifdef LOSCFG_KERNEL_SMP
/**
 * @ingroup los_hwi
 * @brief Send inter-core interrupts to designated cores.
 *
 * @par Description:
 * Send inter-core interrupts to designated cores.
 * @attention
 * This function depends on the hardware implementation of the interrupt
 * controller and CPU architecture, Only used in SMP architecture.
 *
 * @param hwiNum   [IN] Type #HWI_HANDLE_T: hardware interrupt number.
 * @param cpuMask  [IN] Type #UINT32: CPU number.
 *
 * @retval #LOS_ERRNO_HWI_NUM_INVALID         Invalid interrupt number.
 * @retval #LOS_ERRNO_HWI_PROC_FUNC_NULL      Not supported by the interrupt controller.
 * @retval #LOS_OK                            Inter-core interrupt sent successfully.
 *
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @since Huawei LiteOS V200R005C00
 */
//是一个函数声明，用于在 LiteOS 操作系统中向指定的处理器发送中断请求。
/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要发送的中断号或中断向量的标识。
UINT32 cpuMask 是函数的第二个参数，表示中断发送的目标处理器掩码，用于指定将中断发送到哪些处理器上。
函数的作用是向指定的处理器发送中断请求，
即通过中断控制器向目标处理器发送中断信号，触发相应的中断处理操作。*/
extern UINT32 LOS_HwiSendIpi(HWI_HANDLE_T hwiNum, UINT32 cpuMask);

/**
 * @ingroup los_hwi
 * @brief Interrupt response specified CPU processing.
 *
 * @par Description:
 * Interrupt response specified CPU processing.
 * @attention
 * This function depends on the hardware implementation of the interrupt
 * controller and CPU architecture, Only used in SMP architecture.
 *
 * @param hwiNum   [IN] Type #HWI_HANDLE_T. The hardware interrupt number.
 * @param cpuMask  [IN] Type #UINT32. The CPU number.
 *
 * @retval #LOS_ERRNO_HWI_NUM_INVALID         Invalid interrupt number.
 * @retval #LOS_ERRNO_HWI_PROC_FUNC_NULL      Not supported by the interrupt controller.
 * @retval #LOS_OK                            The interrupt is successfully set affinity.
 *
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @since Huawei LiteOS V200R005C00
 */
//是一个函数声明，用于在 LiteOS 操作系统中设置指定中断的亲和性（Affinity）。
/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要设置亲和性的中断号或中断向量的标识。
UINT32 cpuMask 是函数的第二个参数，表示要设置的中断亲和性掩码，用于指定该中断可以在哪些处理器上执行。
函数的作用是设置指定中断的亲和性，即将中断与特定的处理器相关联。当中断被触发时，
只有与中断亲和性相关的处理器才会尝试执行中断处理程序，
从而避免了不必要的中断传递和处理开销。*/
extern UINT32 LOS_HwiSetAffinity(HWI_HANDLE_T hwiNum, UINT32 cpuMask);
#endif /* LOSCFG_KERNEL_SMP */

/**
 * @ingroup los_hwi
 * @brief Set interrupts priority.
 *
 * @par Description:
 * Set interrupts priority.
 * @attention
 * This function depends on the hardware implementation of the interrupt
 * controller and CPU architecture.
 *
 * @param hwiNum     [IN] Type #HWI_HANDLE_T: hardware interrupt number.
 * @param priority   [IN] Type #HWI_PRIOR_T: interrupt priority to be set.
 *
 * @retval #LOS_ERRNO_HWI_NUM_INVALID         Invalid interrupt number.
 * @retval #LOS_ERRNO_HWI_PRIO_INVALID        Invalid interrupt priority.
 * @retval #LOS_ERRNO_HWI_PROC_FUNC_NULL      Not supported by the interrupt controller.
 * @retval #LOS_OK                            The interrupt is successfully set priority.
 *
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API
 * declaration.</li></ul>
 * @see None
 * @since Huawei LiteOS V200R005C00
 */
//是一个函数声明，用于在 LiteOS 操作系统中设置指定中断的优先级（Priority）。
/*HWI_HANDLE_T hwiNum 是函数的第一个参数，表示要设置优先级的中断号或中断向量的标识。
HWI_PRIOR_T priority 是函数的第二个参数，表示要设置的中断优先级。
函数的作用是设置指定中断的优先级，即确定中断在系统中的相对执行优先级。
较高优先级的中断将优先获得处理器资源，并在其他中断之前得到响应和执行。*/
extern UINT32 LOS_HwiSetPriority(HWI_HANDLE_T hwiNum, HWI_PRIOR_T priority);

#ifdef LOSCFG_KERNEL_LOWPOWER
/**
 * @ingroup los_hwi
 * @brief Define the lowpower framework wakeup function type.
 *
 * @par Description:
 * This API is used to define the lowpower framework wakeup function type.
 *
 * @attention None.
 *
 * @param  hwiNum [IN] The interrupt number.
 *
 * @retval None.
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see None.
 * @since Huawei LiteOS V200R005C10
 */
//是一个函数指针类型的定义。
/*这部分定义了函数指针所指向的函数的参数列表，其中包含一个名为 hwiNum 的参数，其类型为 HWI_HANDLE_T。
因此，整体来说，typedef VOID (*WAKEUPFROMINTHOOK)(HWI_HANDLE_T hwiNum) 定义了一个函数指针类型 WAKEUPFROMINTHOOK，
它指向一个不返回数值的函数，并且该函数接受一个 HWI_HANDLE_T 类型的参数 hwiNum。*/
typedef VOID (*WAKEUPFROMINTHOOK)(HWI_HANDLE_T hwiNum);

/**
 * @ingroup  los_hwi
 * @brief Register a hook to wakeup from interrupt.
 *
 * @par Description:
 * This API is used to register a recovery function after wakeup from interrupt
 *
 * @attention None.
 *
 * @param  hook [IN] The lowpower wakeup hook.
 *
 * @retval None.
 * @par Dependency:
 * <ul><li>los_hwi.h: the header file that contains the API declaration.</li></ul>
 * @see None.
 * @since Huawei LiteOS V200R005C10
 */
//是用于注册中断唤醒钩子函数的外部声明。
/*WAKEUPFROMINTHOOK hook 是函数的参数，它是一个指向中断唤醒钩子函数的指针。
函数的作用是注册中断唤醒钩子函数，
即将指定的函数指针（指向中断唤醒处理函数的指针）注册到系统中，
以便在特定的中断事件发生时执行相应的处理操作。*/
extern VOID LOS_IntWakeupHookReg(WAKEUPFROMINTHOOK hook);
#endif

#ifdef __cplusplus
#if __cplusplus
}
#endif /* __cplusplus */
#endif /* __cplusplus */

#endif /* _LOS_HWI_H */
