chip/gpio/GPIO.h

 
#ifndef MCXA153_A3754241_08E1_4F86_B049_0FACC9D70DF5
#define MCXA153_A3754241_08E1_4F86_B049_0FACC9D70DF5
 
/* ***************************************************************************************
 * Include
 */
#include "mframe.h"
 
//----------------------------------------------------------------------------------------
#include "./../Processor.h"
#include "./../gpio/Count.h"
#include "./../gpio/InterruptConfig.h"
#include "./../gpio/Mask.h"
#include "./../gpio/PinConfig.h"
#include "./../gpio/Register.h"
#include "./../gpio/Shift.h"
#include "./../gpio/VersionInfo.h"
 
//----------------------------------------------------------------------------------------
 
/* ***************************************************************************************
 * Namespace
 */
namespace mcxa153::chip::gpio {
  class GPIO;
 
  Register* const GPIO0 =
      reinterpret_cast<Register*>(mcxa153::chip::Processor::BASE_GPIO0);
 
  Register* const GPIO1 =
      reinterpret_cast<Register*>(mcxa153::chip::Processor::BASE_GPIO1);
 
  Register* const GPIO2 =
      reinterpret_cast<Register*>(mcxa153::chip::Processor::BASE_GPIO2);
 
  Register* const GPIO3 =
      reinterpret_cast<Register*>(mcxa153::chip::Processor::BASE_GPIO3);
 
  Register* const GPIO[4] = {GPIO0, GPIO1, GPIO2, GPIO3};
}  // namespace mcxa153::chip::gpio
 
/* ***************************************************************************************
 * Class/Interface/Struct/Enum
 */
 
class mcxa153::chip::gpio::GPIO : public ufm::lang::NonInstantiable {
  /* *************************************************************************************
   * Variable
   */
 
  /* *************************************************************************************
   * Abstract Method
   */
 
  /* *************************************************************************************
   * Construct Method
   */
 protected:
  virtual ~GPIO(void) override = default;
 
  /* *************************************************************************************
   * Operator Method
   */
 
  /* *************************************************************************************
   * Override Method
   */
 
  /* *************************************************************************************
   * Public Method
   */
 
  /* *************************************************************************************
   * Protected Method
   */
 
  /* *************************************************************************************
   * Private Method
   */
 
  /* *************************************************************************************
   * Static Variable
   */
 
  /* *************************************************************************************
   * Static Method
   */
 public:
  static void pinInit(Register* base, uint32 pin, const PinConfig& config);
 
  static void getVersionInfo(Register* base, VersionInfo& info);
 
  static inline void portInputEnable(Register* base, uint32 mask) {
    base->pidr &= static_cast<uint32>(~mask);
  }
 
  static inline void portInputDisable(Register* base, uint32 mask) {
    base->pidr |= static_cast<uint32>(mask);
  }
 
  static inline void pinWrite(Register* base, uint32 pin, uint8 output) {
    if (output == 0U) {
      base->pcor = static_cast<uint32>(1UL << pin);
    } else {
      base->psor = static_cast<uint32>(1UL << pin);
    }
  }
 
  static inline void portSet(Register* base, uint32 mask) {
    base->psor = static_cast<uint32>(mask);
  }
 
  static inline void portClear(Register* base, uint32 mask) {
    base->pcor = static_cast<uint32>(mask);
  }
 
  static inline void portToggle(Register* base, uint32 mask) {
    base->ptor = static_cast<uint32>(mask);
  }
 
  static inline uint32 pinRead(Register* base, uint32 pin) {
    return ((static_cast<uint32>(base->pdir) >> pin) & 0x01UL);
  }
 
  static inline void setPinInterruptConfig(Register*       base,
                                           uint32          pin,
                                           InterruptConfig config) {
    base->icr[pin] =
        static_cast<uint32>((base->icr[pin] & ~+Mask::ICR_IRQC) | GPIO::ICR_IRQC(+config));
  }
 
  static uint32 gpioGetInterruptFlags(Register* base);
 
  static uint8 pinGetInterruptFlag(Register* base, uint32 pin);
 
  static void gpioClearInterruptFlags(Register* base, uint32 mask);
 
  static void pinClearInterruptFlag(Register* base, uint32 pin);
 
  static inline uint32 getPinsDMARequestFlags(Register* base) {
    return (base->isfr[1]);
  }
 
  static inline void setMultipleInterruptPinsConfig(Register*       base,
                                                    uint32          mask,
                                                    InterruptConfig config) {
    if (0UL != (mask & 0xffffUL)) {
      base->giclr = static_cast<uint32>((GPIO::ICR_IRQC(+config)) | (mask & 0xffffU));
    }
    mask = mask >> 16U;
    if (mask != 0UL) {
      base->gichr = static_cast<uint32>((GPIO::ICR_IRQC(+config)) | (mask & 0xffffU));
    }
  }
 
  static inline constexpr uint32 VERID_FEATURE(uint32 value) {
    return ((value << +Shift::VERID_FEATURE) & +Mask::VERID_FEATURE);
  }
 
  static inline constexpr uint32 VERID_MINOR(uint32 value) {
    return ((value << +Shift::VERID_MINOR) & +Mask::VERID_MINOR);
  }
 
  static inline constexpr uint32 VERID_MAJOR(uint32 value) {
    return ((value << +Shift::VERID_MAJOR) & +Mask::VERID_MAJOR);
  }
 
  static inline constexpr uint32 PARAM_IRQNUM(uint32 value) {
    return ((value << +Shift::PARAM_IRQNUM) & +Mask::PARAM_IRQNUM);
  }
 
  static inline constexpr uint32 PDOR_PDO0(uint32 value) {
    return ((value << +Shift::PDOR_PDO0) & +Mask::PDOR_PDO0);
  }
 
  static inline constexpr uint32 PDOR_PDO1(uint32 value) {
    return ((value << +Shift::PDOR_PDO1) & +Mask::PDOR_PDO1);
  }
 
  static inline constexpr uint32 PDOR_PDO2(uint32 value) {
    return ((value << +Shift::PDOR_PDO2) & +Mask::PDOR_PDO2);
  }
 
  static inline constexpr uint32 PDOR_PDO3(uint32 value) {
    return ((value << +Shift::PDOR_PDO3) & +Mask::PDOR_PDO3);
  }
 
  static inline constexpr uint32 PDOR_PDO4(uint32 value) {
    return ((value << +Shift::PDOR_PDO4) & +Mask::PDOR_PDO4);
  }
 
  static inline constexpr uint32 PDOR_PDO5(uint32 value) {
    return ((value << +Shift::PDOR_PDO5) & +Mask::PDOR_PDO5);
  }
 
  static inline constexpr uint32 PDOR_PDO6(uint32 value) {
    return ((value << +Shift::PDOR_PDO6) & +Mask::PDOR_PDO6);
  }
 
  static inline constexpr uint32 PDOR_PDO7(uint32 value) {
    return ((value << +Shift::PDOR_PDO7) & +Mask::PDOR_PDO7);
  }
 
  static inline constexpr uint32 PDOR_PDO8(uint32 value) {
    return ((value << +Shift::PDOR_PDO8) & +Mask::PDOR_PDO8);
  }
 
  static inline constexpr uint32 PDOR_PDO9(uint32 value) {
    return ((value << +Shift::PDOR_PDO9) & +Mask::PDOR_PDO9);
  }
 
  static inline constexpr uint32 PDOR_PDO10(uint32 value) {
    return ((value << +Shift::PDOR_PDO10) & +Mask::PDOR_PDO10);
  }
 
  static inline constexpr uint32 PDOR_PDO11(uint32 value) {
    return ((value << +Shift::PDOR_PDO11) & +Mask::PDOR_PDO11);
  }
 
  static inline constexpr uint32 PDOR_PDO12(uint32 value) {
    return ((value << +Shift::PDOR_PDO12) & +Mask::PDOR_PDO12);
  }
 
  static inline constexpr uint32 PDOR_PDO13(uint32 value) {
    return ((value << +Shift::PDOR_PDO13) & +Mask::PDOR_PDO13);
  }
 
  static inline constexpr uint32 PDOR_PDO14(uint32 value) {
    return ((value << +Shift::PDOR_PDO14) & +Mask::PDOR_PDO14);
  }
 
  static inline constexpr uint32 PDOR_PDO15(uint32 value) {
    return ((value << +Shift::PDOR_PDO15) & +Mask::PDOR_PDO15);
  }
 
  static inline constexpr uint32 PDOR_PDO16(uint32 value) {
    return ((value << +Shift::PDOR_PDO16) & +Mask::PDOR_PDO16);
  }
 
  static inline constexpr uint32 PDOR_PDO17(uint32 value) {
    return ((value << +Shift::PDOR_PDO17) & +Mask::PDOR_PDO17);
  }
 
  static inline constexpr uint32 PDOR_PDO18(uint32 value) {
    return ((value << +Shift::PDOR_PDO18) & +Mask::PDOR_PDO18);
  }
 
  static inline constexpr uint32 PDOR_PDO19(uint32 value) {
    return ((value << +Shift::PDOR_PDO19) & +Mask::PDOR_PDO19);
  }
 
  static inline constexpr uint32 PDOR_PDO20(uint32 value) {
    return ((value << +Shift::PDOR_PDO20) & +Mask::PDOR_PDO20);
  }
 
  static inline constexpr uint32 PDOR_PDO21(uint32 value) {
    return ((value << +Shift::PDOR_PDO21) & +Mask::PDOR_PDO21);
  }
 
  static inline constexpr uint32 PDOR_PDO22(uint32 value) {
    return ((value << +Shift::PDOR_PDO22) & +Mask::PDOR_PDO22);
  }
 
  static inline constexpr uint32 PDOR_PDO23(uint32 value) {
    return ((value << +Shift::PDOR_PDO23) & +Mask::PDOR_PDO23);
  }
 
  static inline constexpr uint32 PDOR_PDO24(uint32 value) {
    return ((value << +Shift::PDOR_PDO24) & +Mask::PDOR_PDO24);
  }
 
  static inline constexpr uint32 PDOR_PDO25(uint32 value) {
    return ((value << +Shift::PDOR_PDO25) & +Mask::PDOR_PDO25);
  }
 
  static inline constexpr uint32 PDOR_PDO26(uint32 value) {
    return ((value << +Shift::PDOR_PDO26) & +Mask::PDOR_PDO26);
  }
 
  static inline constexpr uint32 PDOR_PDO27(uint32 value) {
    return ((value << +Shift::PDOR_PDO27) & +Mask::PDOR_PDO27);
  }
 
  static inline constexpr uint32 PDOR_PDO28(uint32 value) {
    return ((value << +Shift::PDOR_PDO28) & +Mask::PDOR_PDO28);
  }
 
  static inline constexpr uint32 PDOR_PDO29(uint32 value) {
    return ((value << +Shift::PDOR_PDO29) & +Mask::PDOR_PDO29);
  }
 
  static inline constexpr uint32 PDOR_PDO30(uint32 value) {
    return ((value << +Shift::PDOR_PDO30) & +Mask::PDOR_PDO30);
  }
 
  static inline constexpr uint32 PDOR_PDO31(uint32 value) {
    return ((value << +Shift::PDOR_PDO31) & +Mask::PDOR_PDO31);
  }
 
  static inline constexpr uint32 PSOR_PTSO0(uint32 value) {
    return ((value << +Shift::PSOR_PTSO0) & +Mask::PSOR_PTSO0);
  }
 
  static inline constexpr uint32 PSOR_PTSO1(uint32 value) {
    return ((value << +Shift::PSOR_PTSO1) & +Mask::PSOR_PTSO1);
  }
 
  static inline constexpr uint32 PSOR_PTSO2(uint32 value) {
    return ((value << +Shift::PSOR_PTSO2) & +Mask::PSOR_PTSO2);
  }
 
  static inline constexpr uint32 PSOR_PTSO3(uint32 value) {
    return ((value << +Shift::PSOR_PTSO3) & +Mask::PSOR_PTSO3);
  }
 
  static inline constexpr uint32 PSOR_PTSO4(uint32 value) {
    return ((value << +Shift::PSOR_PTSO4) & +Mask::PSOR_PTSO4);
  }
 
  static inline constexpr uint32 PSOR_PTSO5(uint32 value) {
    return ((value << +Shift::PSOR_PTSO5) & +Mask::PSOR_PTSO5);
  }
 
  static inline constexpr uint32 PSOR_PTSO6(uint32 value) {
    return ((value << +Shift::PSOR_PTSO6) & +Mask::PSOR_PTSO6);
  }
 
  static inline constexpr uint32 PSOR_PTSO7(uint32 value) {
    return ((value << +Shift::PSOR_PTSO7) & +Mask::PSOR_PTSO7);
  }
 
  static inline constexpr uint32 PSOR_PTSO8(uint32 value) {
    return ((value << +Shift::PSOR_PTSO8) & +Mask::PSOR_PTSO8);
  }
 
  static inline constexpr uint32 PSOR_PTSO9(uint32 value) {
    return ((value << +Shift::PSOR_PTSO9) & +Mask::PSOR_PTSO9);
  }
 
  static inline constexpr uint32 PSOR_PTSO10(uint32 value) {
    return ((value << +Shift::PSOR_PTSO10) & +Mask::PSOR_PTSO10);
  }
 
  static inline constexpr uint32 PSOR_PTSO11(uint32 value) {
    return ((value << +Shift::PSOR_PTSO11) & +Mask::PSOR_PTSO11);
  }
 
  static inline constexpr uint32 PSOR_PTSO12(uint32 value) {
    return ((value << +Shift::PSOR_PTSO12) & +Mask::PSOR_PTSO12);
  }
 
  static inline constexpr uint32 PSOR_PTSO13(uint32 value) {
    return ((value << +Shift::PSOR_PTSO13) & +Mask::PSOR_PTSO13);
  }
 
  static inline constexpr uint32 PSOR_PTSO14(uint32 value) {
    return ((value << +Shift::PSOR_PTSO14) & +Mask::PSOR_PTSO14);
  }
 
  static inline constexpr uint32 PSOR_PTSO15(uint32 value) {
    return ((value << +Shift::PSOR_PTSO15) & +Mask::PSOR_PTSO15);
  }
 
  static inline constexpr uint32 PSOR_PTSO16(uint32 value) {
    return ((value << +Shift::PSOR_PTSO16) & +Mask::PSOR_PTSO16);
  }
 
  static inline constexpr uint32 PSOR_PTSO17(uint32 value) {
    return ((value << +Shift::PSOR_PTSO17) & +Mask::PSOR_PTSO17);
  }
 
  static inline constexpr uint32 PSOR_PTSO18(uint32 value) {
    return ((value << +Shift::PSOR_PTSO18) & +Mask::PSOR_PTSO18);
  }
 
  static inline constexpr uint32 PSOR_PTSO19(uint32 value) {
    return ((value << +Shift::PSOR_PTSO19) & +Mask::PSOR_PTSO19);
  }
 
  static inline constexpr uint32 PSOR_PTSO20(uint32 value) {
    return ((value << +Shift::PSOR_PTSO20) & +Mask::PSOR_PTSO20);
  }
 
  static inline constexpr uint32 PSOR_PTSO21(uint32 value) {
    return ((value << +Shift::PSOR_PTSO21) & +Mask::PSOR_PTSO21);
  }
 
  static inline constexpr uint32 PSOR_PTSO22(uint32 value) {
    return ((value << +Shift::PSOR_PTSO22) & +Mask::PSOR_PTSO22);
  }
 
  static inline constexpr uint32 PSOR_PTSO23(uint32 value) {
    return ((value << +Shift::PSOR_PTSO23) & +Mask::PSOR_PTSO23);
  }
 
  static inline constexpr uint32 PSOR_PTSO24(uint32 value) {
    return ((value << +Shift::PSOR_PTSO24) & +Mask::PSOR_PTSO24);
  }
 
  static inline constexpr uint32 PSOR_PTSO25(uint32 value) {
    return ((value << +Shift::PSOR_PTSO25) & +Mask::PSOR_PTSO25);
  }
 
  static inline constexpr uint32 PSOR_PTSO26(uint32 value) {
    return ((value << +Shift::PSOR_PTSO26) & +Mask::PSOR_PTSO26);
  }
 
  static inline constexpr uint32 PSOR_PTSO27(uint32 value) {
    return ((value << +Shift::PSOR_PTSO27) & +Mask::PSOR_PTSO27);
  }
 
  static inline constexpr uint32 PSOR_PTSO28(uint32 value) {
    return ((value << +Shift::PSOR_PTSO28) & +Mask::PSOR_PTSO28);
  }
 
  static inline constexpr uint32 PSOR_PTSO29(uint32 value) {
    return ((value << +Shift::PSOR_PTSO29) & +Mask::PSOR_PTSO29);
  }
 
  static inline constexpr uint32 PSOR_PTSO30(uint32 value) {
    return ((value << +Shift::PSOR_PTSO30) & +Mask::PSOR_PTSO30);
  }
 
  static inline constexpr uint32 PSOR_PTSO31(uint32 value) {
    return ((value << +Shift::PSOR_PTSO31) & +Mask::PSOR_PTSO31);
  }
 
  static inline constexpr uint32 PCOR_PTCO0(uint32 value) {
    return ((value << +Shift::PCOR_PTCO0) & +Mask::PCOR_PTCO0);
  }
 
  static inline constexpr uint32 PCOR_PTCO1(uint32 value) {
    return ((value << +Shift::PCOR_PTCO1) & +Mask::PCOR_PTCO1);
  }
 
  static inline constexpr uint32 PCOR_PTCO2(uint32 value) {
    return ((value << +Shift::PCOR_PTCO2) & +Mask::PCOR_PTCO2);
  }
 
  static inline constexpr uint32 PCOR_PTCO3(uint32 value) {
    return ((value << +Shift::PCOR_PTCO3) & +Mask::PCOR_PTCO3);
  }
 
  static inline constexpr uint32 PCOR_PTCO4(uint32 value) {
    return ((value << +Shift::PCOR_PTCO4) & +Mask::PCOR_PTCO4);
  }
 
  static inline constexpr uint32 PCOR_PTCO5(uint32 value) {
    return ((value << +Shift::PCOR_PTCO5) & +Mask::PCOR_PTCO5);
  }
 
  static inline constexpr uint32 PCOR_PTCO6(uint32 value) {
    return ((value << +Shift::PCOR_PTCO6) & +Mask::PCOR_PTCO6);
  }
 
  static inline constexpr uint32 PCOR_PTCO7(uint32 value) {
    return ((value << +Shift::PCOR_PTCO7) & +Mask::PCOR_PTCO7);
  }
 
  static inline constexpr uint32 PCOR_PTCO8(uint32 value) {
    return ((value << +Shift::PCOR_PTCO8) & +Mask::PCOR_PTCO8);
  }
 
  static inline constexpr uint32 PCOR_PTCO9(uint32 value) {
    return ((value << +Shift::PCOR_PTCO9) & +Mask::PCOR_PTCO9);
  }
 
  static inline constexpr uint32 PCOR_PTCO10(uint32 value) {
    return ((value << +Shift::PCOR_PTCO10) & +Mask::PCOR_PTCO10);
  }
 
  static inline constexpr uint32 PCOR_PTCO11(uint32 value) {
    return ((value << +Shift::PCOR_PTCO11) & +Mask::PCOR_PTCO11);
  }
 
  static inline constexpr uint32 PCOR_PTCO12(uint32 value) {
    return ((value << +Shift::PCOR_PTCO12) & +Mask::PCOR_PTCO12);
  }
 
  static inline constexpr uint32 PCOR_PTCO13(uint32 value) {
    return ((value << +Shift::PCOR_PTCO13) & +Mask::PCOR_PTCO13);
  }
 
  static inline constexpr uint32 PCOR_PTCO14(uint32 value) {
    return ((value << +Shift::PCOR_PTCO14) & +Mask::PCOR_PTCO14);
  }
 
  static inline constexpr uint32 PCOR_PTCO15(uint32 value) {
    return ((value << +Shift::PCOR_PTCO15) & +Mask::PCOR_PTCO15);
  }
 
  static inline constexpr uint32 PCOR_PTCO16(uint32 value) {
    return ((value << +Shift::PCOR_PTCO16) & +Mask::PCOR_PTCO16);
  }
 
  static inline constexpr uint32 PCOR_PTCO17(uint32 value) {
    return ((value << +Shift::PCOR_PTCO17) & +Mask::PCOR_PTCO17);
  }
 
  static inline constexpr uint32 PCOR_PTCO18(uint32 value) {
    return ((value << +Shift::PCOR_PTCO18) & +Mask::PCOR_PTCO18);
  }
 
  static inline constexpr uint32 PCOR_PTCO19(uint32 value) {
    return ((value << +Shift::PCOR_PTCO19) & +Mask::PCOR_PTCO19);
  }
 
  static inline constexpr uint32 PCOR_PTCO20(uint32 value) {
    return ((value << +Shift::PCOR_PTCO20) & +Mask::PCOR_PTCO20);
  }
 
  static inline constexpr uint32 PCOR_PTCO21(uint32 value) {
    return ((value << +Shift::PCOR_PTCO21) & +Mask::PCOR_PTCO21);
  }
 
  static inline constexpr uint32 PCOR_PTCO22(uint32 value) {
    return ((value << +Shift::PCOR_PTCO22) & +Mask::PCOR_PTCO22);
  }
 
  static inline constexpr uint32 PCOR_PTCO23(uint32 value) {
    return ((value << +Shift::PCOR_PTCO23) & +Mask::PCOR_PTCO23);
  }
 
  static inline constexpr uint32 PCOR_PTCO24(uint32 value) {
    return ((value << +Shift::PCOR_PTCO24) & +Mask::PCOR_PTCO24);
  }
 
  static inline constexpr uint32 PCOR_PTCO25(uint32 value) {
    return ((value << +Shift::PCOR_PTCO25) & +Mask::PCOR_PTCO25);
  }
 
  static inline constexpr uint32 PCOR_PTCO26(uint32 value) {
    return ((value << +Shift::PCOR_PTCO26) & +Mask::PCOR_PTCO26);
  }
 
  static inline constexpr uint32 PCOR_PTCO27(uint32 value) {
    return ((value << +Shift::PCOR_PTCO27) & +Mask::PCOR_PTCO27);
  }
 
  static inline constexpr uint32 PCOR_PTCO28(uint32 value) {
    return ((value << +Shift::PCOR_PTCO28) & +Mask::PCOR_PTCO28);
  }
 
  static inline constexpr uint32 PCOR_PTCO29(uint32 value) {
    return ((value << +Shift::PCOR_PTCO29) & +Mask::PCOR_PTCO29);
  }
 
  static inline constexpr uint32 PCOR_PTCO30(uint32 value) {
    return ((value << +Shift::PCOR_PTCO30) & +Mask::PCOR_PTCO30);
  }
 
  static inline constexpr uint32 PCOR_PTCO31(uint32 value) {
    return ((value << +Shift::PCOR_PTCO31) & +Mask::PCOR_PTCO31);
  }
 
  static inline constexpr uint32 PTOR_PTTO0(uint32 value) {
    return ((value << +Shift::PTOR_PTTO0) & +Mask::PTOR_PTTO0);
  }
 
  static inline constexpr uint32 PTOR_PTTO1(uint32 value) {
    return ((value << +Shift::PTOR_PTTO1) & +Mask::PTOR_PTTO1);
  }
 
  static inline constexpr uint32 PTOR_PTTO2(uint32 value) {
    return ((value << +Shift::PTOR_PTTO2) & +Mask::PTOR_PTTO2);
  }
 
  static inline constexpr uint32 PTOR_PTTO3(uint32 value) {
    return ((value << +Shift::PTOR_PTTO3) & +Mask::PTOR_PTTO3);
  }
 
  static inline constexpr uint32 PTOR_PTTO4(uint32 value) {
    return ((value << +Shift::PTOR_PTTO4) & +Mask::PTOR_PTTO4);
  }
 
  static inline constexpr uint32 PTOR_PTTO5(uint32 value) {
    return ((value << +Shift::PTOR_PTTO5) & +Mask::PTOR_PTTO5);
  }
 
  static inline constexpr uint32 PTOR_PTTO6(uint32 value) {
    return ((value << +Shift::PTOR_PTTO6) & +Mask::PTOR_PTTO6);
  }
 
  static inline constexpr uint32 PTOR_PTTO7(uint32 value) {
    return ((value << +Shift::PTOR_PTTO7) & +Mask::PTOR_PTTO7);
  }
 
  static inline constexpr uint32 PTOR_PTTO8(uint32 value) {
    return ((value << +Shift::PTOR_PTTO8) & +Mask::PTOR_PTTO8);
  }
 
  static inline constexpr uint32 PTOR_PTTO9(uint32 value) {
    return ((value << +Shift::PTOR_PTTO9) & +Mask::PTOR_PTTO9);
  }
 
  static inline constexpr uint32 PTOR_PTTO10(uint32 value) {
    return ((value << +Shift::PTOR_PTTO10) & +Mask::PTOR_PTTO10);
  }
 
  static inline constexpr uint32 PTOR_PTTO11(uint32 value) {
    return ((value << +Shift::PTOR_PTTO11) & +Mask::PTOR_PTTO11);
  }
 
  static inline constexpr uint32 PTOR_PTTO12(uint32 value) {
    return ((value << +Shift::PTOR_PTTO12) & +Mask::PTOR_PTTO12);
  }
 
  static inline constexpr uint32 PTOR_PTTO13(uint32 value) {
    return ((value << +Shift::PTOR_PTTO13) & +Mask::PTOR_PTTO13);
  }
 
  static inline constexpr uint32 PTOR_PTTO14(uint32 value) {
    return ((value << +Shift::PTOR_PTTO14) & +Mask::PTOR_PTTO14);
  }
 
  static inline constexpr uint32 PTOR_PTTO15(uint32 value) {
    return ((value << +Shift::PTOR_PTTO15) & +Mask::PTOR_PTTO15);
  }
 
  static inline constexpr uint32 PTOR_PTTO16(uint32 value) {
    return ((value << +Shift::PTOR_PTTO16) & +Mask::PTOR_PTTO16);
  }
 
  static inline constexpr uint32 PTOR_PTTO17(uint32 value) {
    return ((value << +Shift::PTOR_PTTO17) & +Mask::PTOR_PTTO17);
  }
 
  static inline constexpr uint32 PTOR_PTTO18(uint32 value) {
    return ((value << +Shift::PTOR_PTTO18) & +Mask::PTOR_PTTO18);
  }
 
  static inline constexpr uint32 PTOR_PTTO19(uint32 value) {
    return ((value << +Shift::PTOR_PTTO19) & +Mask::PTOR_PTTO19);
  }
 
  static inline constexpr uint32 PTOR_PTTO20(uint32 value) {
    return ((value << +Shift::PTOR_PTTO20) & +Mask::PTOR_PTTO20);
  }
 
  static inline constexpr uint32 PTOR_PTTO21(uint32 value) {
    return ((value << +Shift::PTOR_PTTO21) & +Mask::PTOR_PTTO21);
  }
 
  static inline constexpr uint32 PTOR_PTTO22(uint32 value) {
    return ((value << +Shift::PTOR_PTTO22) & +Mask::PTOR_PTTO22);
  }
 
  static inline constexpr uint32 PTOR_PTTO23(uint32 value) {
    return ((value << +Shift::PTOR_PTTO23) & +Mask::PTOR_PTTO23);
  }
 
  static inline constexpr uint32 PTOR_PTTO24(uint32 value) {
    return ((value << +Shift::PTOR_PTTO24) & +Mask::PTOR_PTTO24);
  }
 
  static inline constexpr uint32 PTOR_PTTO25(uint32 value) {
    return ((value << +Shift::PTOR_PTTO25) & +Mask::PTOR_PTTO25);
  }
 
  static inline constexpr uint32 PTOR_PTTO26(uint32 value) {
    return ((value << +Shift::PTOR_PTTO26) & +Mask::PTOR_PTTO26);
  }
 
  static inline constexpr uint32 PTOR_PTTO27(uint32 value) {
    return ((value << +Shift::PTOR_PTTO27) & +Mask::PTOR_PTTO27);
  }
 
  static inline constexpr uint32 PTOR_PTTO28(uint32 value) {
    return ((value << +Shift::PTOR_PTTO28) & +Mask::PTOR_PTTO28);
  }
 
  static inline constexpr uint32 PTOR_PTTO29(uint32 value) {
    return ((value << +Shift::PTOR_PTTO29) & +Mask::PTOR_PTTO29);
  }
 
  static inline constexpr uint32 PTOR_PTTO30(uint32 value) {
    return ((value << +Shift::PTOR_PTTO30) & +Mask::PTOR_PTTO30);
  }
 
  static inline constexpr uint32 PTOR_PTTO31(uint32 value) {
    return ((value << +Shift::PTOR_PTTO31) & +Mask::PTOR_PTTO31);
  }
 
  static inline constexpr uint32 PDIR_PDI0(uint32 value) {
    return ((value << +Shift::PDIR_PDI0) & +Mask::PDIR_PDI0);
  }
 
  static inline constexpr uint32 PDIR_PDI1(uint32 value) {
    return ((value << +Shift::PDIR_PDI1) & +Mask::PDIR_PDI1);
  }
 
  static inline constexpr uint32 PDIR_PDI2(uint32 value) {
    return ((value << +Shift::PDIR_PDI2) & +Mask::PDIR_PDI2);
  }
 
  static inline constexpr uint32 PDIR_PDI3(uint32 value) {
    return ((value << +Shift::PDIR_PDI3) & +Mask::PDIR_PDI3);
  }
 
  static inline constexpr uint32 PDIR_PDI4(uint32 value) {
    return ((value << +Shift::PDIR_PDI4) & +Mask::PDIR_PDI4);
  }
 
  static inline constexpr uint32 PDIR_PDI5(uint32 value) {
    return ((value << +Shift::PDIR_PDI5) & +Mask::PDIR_PDI5);
  }
 
  static inline constexpr uint32 PDIR_PDI6(uint32 value) {
    return ((value << +Shift::PDIR_PDI6) & +Mask::PDIR_PDI6);
  }
 
  static inline constexpr uint32 PDIR_PDI7(uint32 value) {
    return ((value << +Shift::PDIR_PDI7) & +Mask::PDIR_PDI7);
  }
 
  static inline constexpr uint32 PDIR_PDI8(uint32 value) {
    return ((value << +Shift::PDIR_PDI8) & +Mask::PDIR_PDI8);
  }
 
  static inline constexpr uint32 PDIR_PDI9(uint32 value) {
    return ((value << +Shift::PDIR_PDI9) & +Mask::PDIR_PDI9);
  }
 
  static inline constexpr uint32 PDIR_PDI10(uint32 value) {
    return ((value << +Shift::PDIR_PDI10) & +Mask::PDIR_PDI10);
  }
 
  static inline constexpr uint32 PDIR_PDI11(uint32 value) {
    return ((value << +Shift::PDIR_PDI11) & +Mask::PDIR_PDI11);
  }
 
  static inline constexpr uint32 PDIR_PDI12(uint32 value) {
    return ((value << +Shift::PDIR_PDI12) & +Mask::PDIR_PDI12);
  }
 
  static inline constexpr uint32 PDIR_PDI13(uint32 value) {
    return ((value << +Shift::PDIR_PDI13) & +Mask::PDIR_PDI13);
  }
 
  static inline constexpr uint32 PDIR_PDI14(uint32 value) {
    return ((value << +Shift::PDIR_PDI14) & +Mask::PDIR_PDI14);
  }
 
  static inline constexpr uint32 PDIR_PDI15(uint32 value) {
    return ((value << +Shift::PDIR_PDI15) & +Mask::PDIR_PDI15);
  }
 
  static inline constexpr uint32 PDIR_PDI16(uint32 value) {
    return ((value << +Shift::PDIR_PDI16) & +Mask::PDIR_PDI16);
  }
 
  static inline constexpr uint32 PDIR_PDI17(uint32 value) {
    return ((value << +Shift::PDIR_PDI17) & +Mask::PDIR_PDI17);
  }
 
  static inline constexpr uint32 PDIR_PDI18(uint32 value) {
    return ((value << +Shift::PDIR_PDI18) & +Mask::PDIR_PDI18);
  }
 
  static inline constexpr uint32 PDIR_PDI19(uint32 value) {
    return ((value << +Shift::PDIR_PDI19) & +Mask::PDIR_PDI19);
  }
 
  static inline constexpr uint32 PDIR_PDI20(uint32 value) {
    return ((value << +Shift::PDIR_PDI20) & +Mask::PDIR_PDI20);
  }
 
  static inline constexpr uint32 PDIR_PDI21(uint32 value) {
    return ((value << +Shift::PDIR_PDI21) & +Mask::PDIR_PDI21);
  }
 
  static inline constexpr uint32 PDIR_PDI22(uint32 value) {
    return ((value << +Shift::PDIR_PDI22) & +Mask::PDIR_PDI22);
  }
 
  static inline constexpr uint32 PDIR_PDI23(uint32 value) {
    return ((value << +Shift::PDIR_PDI23) & +Mask::PDIR_PDI23);
  }
 
  static inline constexpr uint32 PDIR_PDI24(uint32 value) {
    return ((value << +Shift::PDIR_PDI24) & +Mask::PDIR_PDI24);
  }
 
  static inline constexpr uint32 PDIR_PDI25(uint32 value) {
    return ((value << +Shift::PDIR_PDI25) & +Mask::PDIR_PDI25);
  }
 
  static inline constexpr uint32 PDIR_PDI26(uint32 value) {
    return ((value << +Shift::PDIR_PDI26) & +Mask::PDIR_PDI26);
  }
 
  static inline constexpr uint32 PDIR_PDI27(uint32 value) {
    return ((value << +Shift::PDIR_PDI27) & +Mask::PDIR_PDI27);
  }
 
  static inline constexpr uint32 PDIR_PDI28(uint32 value) {
    return ((value << +Shift::PDIR_PDI28) & +Mask::PDIR_PDI28);
  }
 
  static inline constexpr uint32 PDIR_PDI29(uint32 value) {
    return ((value << +Shift::PDIR_PDI29) & +Mask::PDIR_PDI29);
  }
 
  static inline constexpr uint32 PDIR_PDI30(uint32 value) {
    return ((value << +Shift::PDIR_PDI30) & +Mask::PDIR_PDI30);
  }
 
  static inline constexpr uint32 PDIR_PDI31(uint32 value) {
    return ((value << +Shift::PDIR_PDI31) & +Mask::PDIR_PDI31);
  }
 
  static inline constexpr uint32 PDDR_PDD0(uint32 value) {
    return ((value << +Shift::PDDR_PDD0) & +Mask::PDDR_PDD0);
  }
 
  static inline constexpr uint32 PDDR_PDD1(uint32 value) {
    return ((value << +Shift::PDDR_PDD1) & +Mask::PDDR_PDD1);
  }
 
  static inline constexpr uint32 PDDR_PDD2(uint32 value) {
    return ((value << +Shift::PDDR_PDD2) & +Mask::PDDR_PDD2);
  }
 
  static inline constexpr uint32 PDDR_PDD3(uint32 value) {
    return ((value << +Shift::PDDR_PDD3) & +Mask::PDDR_PDD3);
  }
 
  static inline constexpr uint32 PDDR_PDD4(uint32 value) {
    return ((value << +Shift::PDDR_PDD4) & +Mask::PDDR_PDD4);
  }
 
  static inline constexpr uint32 PDDR_PDD5(uint32 value) {
    return ((value << +Shift::PDDR_PDD5) & +Mask::PDDR_PDD5);
  }
 
  static inline constexpr uint32 PDDR_PDD6(uint32 value) {
    return ((value << +Shift::PDDR_PDD6) & +Mask::PDDR_PDD6);
  }
 
  static inline constexpr uint32 PDDR_PDD7(uint32 value) {
    return ((value << +Shift::PDDR_PDD7) & +Mask::PDDR_PDD7);
  }
 
  static inline constexpr uint32 PDDR_PDD8(uint32 value) {
    return ((value << +Shift::PDDR_PDD8) & +Mask::PDDR_PDD8);
  }
 
  static inline constexpr uint32 PDDR_PDD9(uint32 value) {
    return ((value << +Shift::PDDR_PDD9) & +Mask::PDDR_PDD9);
  }
 
  static inline constexpr uint32 PDDR_PDD10(uint32 value) {
    return ((value << +Shift::PDDR_PDD10) & +Mask::PDDR_PDD10);
  }
 
  static inline constexpr uint32 PDDR_PDD11(uint32 value) {
    return ((value << +Shift::PDDR_PDD11) & +Mask::PDDR_PDD11);
  }
 
  static inline constexpr uint32 PDDR_PDD12(uint32 value) {
    return ((value << +Shift::PDDR_PDD12) & +Mask::PDDR_PDD12);
  }
 
  static inline constexpr uint32 PDDR_PDD13(uint32 value) {
    return ((value << +Shift::PDDR_PDD13) & +Mask::PDDR_PDD13);
  }
 
  static inline constexpr uint32 PDDR_PDD14(uint32 value) {
    return ((value << +Shift::PDDR_PDD14) & +Mask::PDDR_PDD14);
  }
 
  static inline constexpr uint32 PDDR_PDD15(uint32 value) {
    return ((value << +Shift::PDDR_PDD15) & +Mask::PDDR_PDD15);
  }
 
  static inline constexpr uint32 PDDR_PDD16(uint32 value) {
    return ((value << +Shift::PDDR_PDD16) & +Mask::PDDR_PDD16);
  }
 
  static inline constexpr uint32 PDDR_PDD17(uint32 value) {
    return ((value << +Shift::PDDR_PDD17) & +Mask::PDDR_PDD17);
  }
 
  static inline constexpr uint32 PDDR_PDD18(uint32 value) {
    return ((value << +Shift::PDDR_PDD18) & +Mask::PDDR_PDD18);
  }
 
  static inline constexpr uint32 PDDR_PDD19(uint32 value) {
    return ((value << +Shift::PDDR_PDD19) & +Mask::PDDR_PDD19);
  }
 
  static inline constexpr uint32 PDDR_PDD20(uint32 value) {
    return ((value << +Shift::PDDR_PDD20) & +Mask::PDDR_PDD20);
  }
 
  static inline constexpr uint32 PDDR_PDD21(uint32 value) {
    return ((value << +Shift::PDDR_PDD21) & +Mask::PDDR_PDD21);
  }
 
  static inline constexpr uint32 PDDR_PDD22(uint32 value) {
    return ((value << +Shift::PDDR_PDD22) & +Mask::PDDR_PDD22);
  }
 
  static inline constexpr uint32 PDDR_PDD23(uint32 value) {
    return ((value << +Shift::PDDR_PDD23) & +Mask::PDDR_PDD23);
  }
 
  static inline constexpr uint32 PDDR_PDD24(uint32 value) {
    return ((value << +Shift::PDDR_PDD24) & +Mask::PDDR_PDD24);
  }
 
  static inline constexpr uint32 PDDR_PDD25(uint32 value) {
    return ((value << +Shift::PDDR_PDD25) & +Mask::PDDR_PDD25);
  }
 
  static inline constexpr uint32 PDDR_PDD26(uint32 value) {
    return ((value << +Shift::PDDR_PDD26) & +Mask::PDDR_PDD26);
  }
 
  static inline constexpr uint32 PDDR_PDD27(uint32 value) {
    return ((value << +Shift::PDDR_PDD27) & +Mask::PDDR_PDD27);
  }
 
  static inline constexpr uint32 PDDR_PDD28(uint32 value) {
    return ((value << +Shift::PDDR_PDD28) & +Mask::PDDR_PDD28);
  }
 
  static inline constexpr uint32 PDDR_PDD29(uint32 value) {
    return ((value << +Shift::PDDR_PDD29) & +Mask::PDDR_PDD29);
  }
 
  static inline constexpr uint32 PDDR_PDD30(uint32 value) {
    return ((value << +Shift::PDDR_PDD30) & +Mask::PDDR_PDD30);
  }
 
  static inline constexpr uint32 PDDR_PDD31(uint32 value) {
    return ((value << +Shift::PDDR_PDD31) & +Mask::PDDR_PDD31);
  }
 
  static inline constexpr uint32 PIDR_PID0(uint32 value) {
    return ((value << +Shift::PIDR_PID0) & +Mask::PIDR_PID0);
  }
 
  static inline constexpr uint32 PIDR_PID1(uint32 value) {
    return ((value << +Shift::PIDR_PID1) & +Mask::PIDR_PID1);
  }
 
  static inline constexpr uint32 PIDR_PID2(uint32 value) {
    return ((value << +Shift::PIDR_PID2) & +Mask::PIDR_PID2);
  }
 
  static inline constexpr uint32 PIDR_PID3(uint32 value) {
    return ((value << +Shift::PIDR_PID3) & +Mask::PIDR_PID3);
  }
 
  static inline constexpr uint32 PIDR_PID4(uint32 value) {
    return ((value << +Shift::PIDR_PID4) & +Mask::PIDR_PID4);
  }
 
  static inline constexpr uint32 PIDR_PID5(uint32 value) {
    return ((value << +Shift::PIDR_PID5) & +Mask::PIDR_PID5);
  }
 
  static inline constexpr uint32 PIDR_PID6(uint32 value) {
    return ((value << +Shift::PIDR_PID6) & +Mask::PIDR_PID6);
  }
 
  static inline constexpr uint32 PIDR_PID7(uint32 value) {
    return ((value << +Shift::PIDR_PID7) & +Mask::PIDR_PID7);
  }
 
  static inline constexpr uint32 PIDR_PID8(uint32 value) {
    return ((value << +Shift::PIDR_PID8) & +Mask::PIDR_PID8);
  }
 
  static inline constexpr uint32 PIDR_PID9(uint32 value) {
    return ((value << +Shift::PIDR_PID9) & +Mask::PIDR_PID9);
  }
 
  static inline constexpr uint32 PIDR_PID10(uint32 value) {
    return ((value << +Shift::PIDR_PID10) & +Mask::PIDR_PID10);
  }
 
  static inline constexpr uint32 PIDR_PID11(uint32 value) {
    return ((value << +Shift::PIDR_PID11) & +Mask::PIDR_PID11);
  }
 
  static inline constexpr uint32 PIDR_PID12(uint32 value) {
    return ((value << +Shift::PIDR_PID12) & +Mask::PIDR_PID12);
  }
 
  static inline constexpr uint32 PIDR_PID13(uint32 value) {
    return ((value << +Shift::PIDR_PID13) & +Mask::PIDR_PID13);
  }
 
  static inline constexpr uint32 PIDR_PID14(uint32 value) {
    return ((value << +Shift::PIDR_PID14) & +Mask::PIDR_PID14);
  }
 
  static inline constexpr uint32 PIDR_PID15(uint32 value) {
    return ((value << +Shift::PIDR_PID15) & +Mask::PIDR_PID15);
  }
 
  static inline constexpr uint32 PIDR_PID16(uint32 value) {
    return ((value << +Shift::PIDR_PID16) & +Mask::PIDR_PID16);
  }
 
  static inline constexpr uint32 PIDR_PID17(uint32 value) {
    return ((value << +Shift::PIDR_PID17) & +Mask::PIDR_PID17);
  }
 
  static inline constexpr uint32 PIDR_PID18(uint32 value) {
    return ((value << +Shift::PIDR_PID18) & +Mask::PIDR_PID18);
  }
 
  static inline constexpr uint32 PIDR_PID19(uint32 value) {
    return ((value << +Shift::PIDR_PID19) & +Mask::PIDR_PID19);
  }
 
  static inline constexpr uint32 PIDR_PID20(uint32 value) {
    return ((value << +Shift::PIDR_PID20) & +Mask::PIDR_PID20);
  }
 
  static inline constexpr uint32 PIDR_PID21(uint32 value) {
    return ((value << +Shift::PIDR_PID21) & +Mask::PIDR_PID21);
  }
 
  static inline constexpr uint32 PIDR_PID22(uint32 value) {
    return ((value << +Shift::PIDR_PID22) & +Mask::PIDR_PID22);
  }
 
  static inline constexpr uint32 PIDR_PID23(uint32 value) {
    return ((value << +Shift::PIDR_PID23) & +Mask::PIDR_PID23);
  }
 
  static inline constexpr uint32 PIDR_PID24(uint32 value) {
    return ((value << +Shift::PIDR_PID24) & +Mask::PIDR_PID24);
  }
 
  static inline constexpr uint32 PIDR_PID25(uint32 value) {
    return ((value << +Shift::PIDR_PID25) & +Mask::PIDR_PID25);
  }
 
  static inline constexpr uint32 PIDR_PID26(uint32 value) {
    return ((value << +Shift::PIDR_PID26) & +Mask::PIDR_PID26);
  }
 
  static inline constexpr uint32 PIDR_PID27(uint32 value) {
    return ((value << +Shift::PIDR_PID27) & +Mask::PIDR_PID27);
  }
 
  static inline constexpr uint32 PIDR_PID28(uint32 value) {
    return ((value << +Shift::PIDR_PID28) & +Mask::PIDR_PID28);
  }
 
  static inline constexpr uint32 PIDR_PID29(uint32 value) {
    return ((value << +Shift::PIDR_PID29) & +Mask::PIDR_PID29);
  }
 
  static inline constexpr uint32 PIDR_PID30(uint32 value) {
    return ((value << +Shift::PIDR_PID30) & +Mask::PIDR_PID30);
  }
 
  static inline constexpr uint32 PIDR_PID31(uint32 value) {
    return ((value << +Shift::PIDR_PID31) & +Mask::PIDR_PID31);
  }
 
  static inline constexpr uint8 PDR_PD(uint8 value) {
    return static_cast<uint8>((value << static_cast<uint8>(+Shift::PDR_PD)) &
                              static_cast<uint8>(+Mask::PDR_PD));
  }
 
  static inline constexpr uint32 ICR_IRQC(uint32 value) {
    return ((value << +Shift::ICR_IRQC) & +Mask::ICR_IRQC);
  }
 
  static inline constexpr uint32 ICR_ISF(uint32 value) {
    return ((value << +Shift::ICR_ISF) & +Mask::ICR_ISF);
  }
 
  static inline constexpr uint32 GICLR_GIWE0(uint32 value) {
    return ((value << +Shift::GICLR_GIWE0) & +Mask::GICLR_GIWE0);
  }
 
  static inline constexpr uint32 GICLR_GIWE1(uint32 value) {
    return ((value << +Shift::GICLR_GIWE1) & +Mask::GICLR_GIWE1);
  }
 
  static inline constexpr uint32 GICLR_GIWE2(uint32 value) {
    return ((value << +Shift::GICLR_GIWE2) & +Mask::GICLR_GIWE2);
  }
 
  static inline constexpr uint32 GICLR_GIWE3(uint32 value) {
    return ((value << +Shift::GICLR_GIWE3) & +Mask::GICLR_GIWE3);
  }
 
  static inline constexpr uint32 GICLR_GIWE4(uint32 value) {
    return ((value << +Shift::GICLR_GIWE4) & +Mask::GICLR_GIWE4);
  }
 
  static inline constexpr uint32 GICLR_GIWE5(uint32 value) {
    return ((value << +Shift::GICLR_GIWE5) & +Mask::GICLR_GIWE5);
  }
 
  static inline constexpr uint32 GICLR_GIWE6(uint32 value) {
    return ((value << +Shift::GICLR_GIWE6) & +Mask::GICLR_GIWE6);
  }
 
  static inline constexpr uint32 GICLR_GIWE7(uint32 value) {
    return ((value << +Shift::GICLR_GIWE7) & +Mask::GICLR_GIWE7);
  }
 
  static inline constexpr uint32 GICLR_GIWE8(uint32 value) {
    return ((value << +Shift::GICLR_GIWE8) & +Mask::GICLR_GIWE8);
  }
 
  static inline constexpr uint32 GICLR_GIWE9(uint32 value) {
    return ((value << +Shift::GICLR_GIWE9) & +Mask::GICLR_GIWE9);
  }
 
  static inline constexpr uint32 GICLR_GIWE10(uint32 value) {
    return ((value << +Shift::GICLR_GIWE10) & +Mask::GICLR_GIWE10);
  }
 
  static inline constexpr uint32 GICLR_GIWE11(uint32 value) {
    return ((value << +Shift::GICLR_GIWE11) & +Mask::GICLR_GIWE11);
  }
 
  static inline constexpr uint32 GICLR_GIWE12(uint32 value) {
    return ((value << +Shift::GICLR_GIWE12) & +Mask::GICLR_GIWE12);
  }
 
  static inline constexpr uint32 GICLR_GIWE13(uint32 value) {
    return ((value << +Shift::GICLR_GIWE13) & +Mask::GICLR_GIWE13);
  }
 
  static inline constexpr uint32 GICLR_GIWE14(uint32 value) {
    return ((value << +Shift::GICLR_GIWE14) & +Mask::GICLR_GIWE14);
  }
 
  static inline constexpr uint32 GICLR_GIWE15(uint32 value) {
    return ((value << +Shift::GICLR_GIWE15) & +Mask::GICLR_GIWE15);
  }
 
  static inline constexpr uint32 GICLR_GIWD(uint32 value) {
    return ((value << +Shift::GICLR_GIWD) & +Mask::GICLR_GIWD);
  }
 
  static inline constexpr uint32 GICHR_GIWE16(uint32 value) {
    return ((value << +Shift::GICHR_GIWE16) & +Mask::GICHR_GIWE16);
  }
 
  static inline constexpr uint32 GICHR_GIWE17(uint32 value) {
    return ((value << +Shift::GICHR_GIWE17) & +Mask::GICHR_GIWE17);
  }
 
  static inline constexpr uint32 GICHR_GIWE18(uint32 value) {
    return ((value << +Shift::GICHR_GIWE18) & +Mask::GICHR_GIWE18);
  }
 
  static inline constexpr uint32 GICHR_GIWE19(uint32 value) {
    return ((value << +Shift::GICHR_GIWE19) & +Mask::GICHR_GIWE19);
  }
 
  static inline constexpr uint32 GICHR_GIWE20(uint32 value) {
    return ((value << +Shift::GICHR_GIWE20) & +Mask::GICHR_GIWE20);
  }
 
  static inline constexpr uint32 GICHR_GIWE21(uint32 value) {
    return ((value << +Shift::GICHR_GIWE21) & +Mask::GICHR_GIWE21);
  }
 
  static inline constexpr uint32 GICHR_GIWE22(uint32 value) {
    return ((value << +Shift::GICHR_GIWE22) & +Mask::GICHR_GIWE22);
  }
 
  static inline constexpr uint32 GICHR_GIWE23(uint32 value) {
    return ((value << +Shift::GICHR_GIWE23) & +Mask::GICHR_GIWE23);
  }
 
  static inline constexpr uint32 GICHR_GIWE24(uint32 value) {
    return ((value << +Shift::GICHR_GIWE24) & +Mask::GICHR_GIWE24);
  }
 
  static inline constexpr uint32 GICHR_GIWE25(uint32 value) {
    return ((value << +Shift::GICHR_GIWE25) & +Mask::GICHR_GIWE25);
  }
 
  static inline constexpr uint32 GICHR_GIWE26(uint32 value) {
    return ((value << +Shift::GICHR_GIWE26) & +Mask::GICHR_GIWE26);
  }
 
  static inline constexpr uint32 GICHR_GIWE27(uint32 value) {
    return ((value << +Shift::GICHR_GIWE27) & +Mask::GICHR_GIWE27);
  }
 
  static inline constexpr uint32 GICHR_GIWE28(uint32 value) {
    return ((value << +Shift::GICHR_GIWE28) & +Mask::GICHR_GIWE28);
  }
 
  static inline constexpr uint32 GICHR_GIWE29(uint32 value) {
    return ((value << +Shift::GICHR_GIWE29) & +Mask::GICHR_GIWE29);
  }
 
  static inline constexpr uint32 GICHR_GIWE30(uint32 value) {
    return ((value << +Shift::GICHR_GIWE30) & +Mask::GICHR_GIWE30);
  }
 
  static inline constexpr uint32 GICHR_GIWE31(uint32 value) {
    return ((value << +Shift::GICHR_GIWE31) & +Mask::GICHR_GIWE31);
  }
 
  static inline constexpr uint32 GICHR_GIWD(uint32 value) {
    return ((value << +Shift::GICHR_GIWD) & +Mask::GICHR_GIWD);
  }
 
  static inline constexpr uint32 ISFR_ISF0(uint32 value) {
    return ((value << +Shift::ISFR_ISF0) & +Mask::ISFR_ISF0);
  }
 
  static inline constexpr uint32 ISFR_ISF1(uint32 value) {
    return ((value << +Shift::ISFR_ISF1) & +Mask::ISFR_ISF1);
  }
 
  static inline constexpr uint32 ISFR_ISF2(uint32 value) {
    return ((value << +Shift::ISFR_ISF2) & +Mask::ISFR_ISF2);
  }
 
  static inline constexpr uint32 ISFR_ISF3(uint32 value) {
    return ((value << +Shift::ISFR_ISF3) & +Mask::ISFR_ISF3);
  }
 
  static inline constexpr uint32 ISFR_ISF4(uint32 value) {
    return ((value << +Shift::ISFR_ISF4) & +Mask::ISFR_ISF4);
  }
 
  static inline constexpr uint32 ISFR_ISF5(uint32 value) {
    return ((value << +Shift::ISFR_ISF5) & +Mask::ISFR_ISF5);
  }
 
  static inline constexpr uint32 ISFR_ISF6(uint32 value) {
    return ((value << +Shift::ISFR_ISF6) & +Mask::ISFR_ISF6);
  }
 
  static inline constexpr uint32 ISFR_ISF7(uint32 value) {
    return ((value << +Shift::ISFR_ISF7) & +Mask::ISFR_ISF7);
  }
 
  static inline constexpr uint32 ISFR_ISF8(uint32 value) {
    return ((value << +Shift::ISFR_ISF8) & +Mask::ISFR_ISF8);
  }
 
  static inline constexpr uint32 ISFR_ISF9(uint32 value) {
    return ((value << +Shift::ISFR_ISF9) & +Mask::ISFR_ISF9);
  }
 
  static inline constexpr uint32 ISFR_ISF10(uint32 value) {
    return ((value << +Shift::ISFR_ISF10) & +Mask::ISFR_ISF10);
  }
 
  static inline constexpr uint32 ISFR_ISF11(uint32 value) {
    return ((value << +Shift::ISFR_ISF11) & +Mask::ISFR_ISF11);
  }
 
  static inline constexpr uint32 ISFR_ISF12(uint32 value) {
    return ((value << +Shift::ISFR_ISF12) & +Mask::ISFR_ISF12);
  }
 
  static inline constexpr uint32 ISFR_ISF13(uint32 value) {
    return ((value << +Shift::ISFR_ISF13) & +Mask::ISFR_ISF13);
  }
 
  static inline constexpr uint32 ISFR_ISF14(uint32 value) {
    return ((value << +Shift::ISFR_ISF14) & +Mask::ISFR_ISF14);
  }
 
  static inline constexpr uint32 ISFR_ISF15(uint32 value) {
    return ((value << +Shift::ISFR_ISF15) & +Mask::ISFR_ISF15);
  }
 
  static inline constexpr uint32 ISFR_ISF16(uint32 value) {
    return ((value << +Shift::ISFR_ISF16) & +Mask::ISFR_ISF16);
  }
 
  static inline constexpr uint32 ISFR_ISF17(uint32 value) {
    return ((value << +Shift::ISFR_ISF17) & +Mask::ISFR_ISF17);
  }
 
  static inline constexpr uint32 ISFR_ISF18(uint32 value) {
    return ((value << +Shift::ISFR_ISF18) & +Mask::ISFR_ISF18);
  }
 
  static inline constexpr uint32 ISFR_ISF19(uint32 value) {
    return ((value << +Shift::ISFR_ISF19) & +Mask::ISFR_ISF19);
  }
 
  static inline constexpr uint32 ISFR_ISF20(uint32 value) {
    return ((value << +Shift::ISFR_ISF20) & +Mask::ISFR_ISF20);
  }
 
  static inline constexpr uint32 ISFR_ISF21(uint32 value) {
    return ((value << +Shift::ISFR_ISF21) & +Mask::ISFR_ISF21);
  }
 
  static inline constexpr uint32 ISFR_ISF22(uint32 value) {
    return ((value << +Shift::ISFR_ISF22) & +Mask::ISFR_ISF22);
  }
 
  static inline constexpr uint32 ISFR_ISF23(uint32 value) {
    return ((value << +Shift::ISFR_ISF23) & +Mask::ISFR_ISF23);
  }
 
  static inline constexpr uint32 ISFR_ISF24(uint32 value) {
    return ((value << +Shift::ISFR_ISF24) & +Mask::ISFR_ISF24);
  }
 
  static inline constexpr uint32 ISFR_ISF25(uint32 value) {
    return ((value << +Shift::ISFR_ISF25) & +Mask::ISFR_ISF25);
  }
 
  static inline constexpr uint32 ISFR_ISF26(uint32 value) {
    return ((value << +Shift::ISFR_ISF26) & +Mask::ISFR_ISF26);
  }
 
  static inline constexpr uint32 ISFR_ISF27(uint32 value) {
    return ((value << +Shift::ISFR_ISF27) & +Mask::ISFR_ISF27);
  }
 
  static inline constexpr uint32 ISFR_ISF28(uint32 value) {
    return ((value << +Shift::ISFR_ISF28) & +Mask::ISFR_ISF28);
  }
 
  static inline constexpr uint32 ISFR_ISF29(uint32 value) {
    return ((value << +Shift::ISFR_ISF29) & +Mask::ISFR_ISF29);
  }
 
  static inline constexpr uint32 ISFR_ISF30(uint32 value) {
    return ((value << +Shift::ISFR_ISF30) & +Mask::ISFR_ISF30);
  }
 
  static inline constexpr uint32 ISFR_ISF31(uint32 value) {
    return ((value << +Shift::ISFR_ISF31) & +Mask::ISFR_ISF31);
  }
};
 
/* ***************************************************************************************
 * End of file
 */
 
#endif /* MCXA153_A3754241_08E1_4F86_B049_0FACC9D70DF5 */