/*
  PDD layer implementation for peripheral type PORT
  (C) 2013 Freescale, Inc. All rights reserved.

  This file is static and it is generated from API-Factory
*/

#if !defined(PORT_PDD_H_)
#define PORT_PDD_H_

/* ----------------------------------------------------------------------------
   -- Test if supported MCU is active
   ---------------------------------------------------------------------------- */

#if !defined(MCU_ACTIVE)
  // No MCU is active
  #error PORT PDD library: No derivative is active. Place proper #include with PDD memory map before including PDD library.
#elif \
      !defined(MCU_MK10D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK10D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK10D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK10F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK10DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK11D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK11D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK12D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK20D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK20D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK20D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK20F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK20DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK21D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK21D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK21F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK21F12WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK22D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK22F12810) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK22F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK22F25612) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK22F51212) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK24F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK30D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK30D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK30DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK40D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK40D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK40DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK40X256VMD100) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK50D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK50D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK50DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK51D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK51D7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK51DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK52D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK52DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK53D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK53DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK60D10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK60F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK60F15) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK60DZ10) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK60N512VMD100) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK61F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK61F15) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK61F12WS) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK61F15WS) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK63F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK63F12WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK64F12) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK65F18) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK65F18WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK66F18) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MK70F12) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK70F15) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK70F12WS) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MK70F15WS) /* PORTA, PORTB, PORTC, PORTD, PORTE, PORTF */ && \
      !defined(MCU_MKE02Z2) /* PORT */ && \
      !defined(MCU_MKE02Z4) /* PORT */ && \
      !defined(MCU_SKEAZN642) /* PORT */ && \
      !defined(MCU_MKE04Z1284) /* PORT */ && \
      !defined(MCU_MKE04Z4) /* PORT */ && \
      !defined(MCU_SKEAZN84) /* PORT */ && \
      !defined(MCU_MKE06Z4) /* PORT */ && \
      !defined(MCU_MKL02Z4) /* PORTA, PORTB */ && \
      !defined(MCU_MKL03Z4) /* PORTA, PORTB */ && \
      !defined(MCU_MKL04Z4) /* PORTA, PORTB */ && \
      !defined(MCU_MKL05Z4) /* PORTA, PORTB */ && \
      !defined(MCU_MKL14Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKL15Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKL16Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKL24Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKL25Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKL26Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKL34Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKL36Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKL46Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKV10Z7) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKV31F12810) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKV31F25612) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKV31F51212) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKW01Z4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKW21D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKW21D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKW22D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKW22D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKW24D5) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_MKW24D5WS) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_PCK20L4) /* PORTA, PORTB, PORTC, PORTD, PORTE */ && \
      !defined(MCU_SKEAZ1284) /* PORT */
  // Unsupported MCU is active
  #error PORT PDD library: Unsupported derivative is active.
#endif

#include "PDD_Types.h"

/* ----------------------------------------------------------------------------
   -- Method symbol definitions
   ---------------------------------------------------------------------------- */

/* Pin masks */
#define PORT_PDD_PIN_0  0x1U                     /**< Pin 0 mask */
#define PORT_PDD_PIN_1  0x2U                     /**< Pin 1 mask */
#define PORT_PDD_PIN_2  0x4U                     /**< Pin 2 mask */
#define PORT_PDD_PIN_3  0x8U                     /**< Pin 3 mask */
#define PORT_PDD_PIN_4  0x10U                    /**< Pin 4 mask */
#define PORT_PDD_PIN_5  0x20U                    /**< Pin 5 mask */
#define PORT_PDD_PIN_6  0x40U                    /**< Pin 6 mask */
#define PORT_PDD_PIN_7  0x80U                    /**< Pin 7 mask */
#define PORT_PDD_PIN_8  0x100U                   /**< Pin 8 mask */
#define PORT_PDD_PIN_9  0x200U                   /**< Pin 9 mask */
#define PORT_PDD_PIN_10 0x400U                   /**< Pin 10 mask */
#define PORT_PDD_PIN_11 0x800U                   /**< Pin 11 mask */
#define PORT_PDD_PIN_12 0x1000U                  /**< Pin 12 mask */
#define PORT_PDD_PIN_13 0x2000U                  /**< Pin 13 mask */
#define PORT_PDD_PIN_14 0x4000U                  /**< Pin 14 mask */
#define PORT_PDD_PIN_15 0x8000U                  /**< Pin 15 mask */
#define PORT_PDD_PIN_16 0x10000U                 /**< Pin 16 mask */
#define PORT_PDD_PIN_17 0x20000U                 /**< Pin 17 mask */
#define PORT_PDD_PIN_18 0x40000U                 /**< Pin 18 mask */
#define PORT_PDD_PIN_19 0x80000U                 /**< Pin 19 mask */
#define PORT_PDD_PIN_20 0x100000U                /**< Pin 20 mask */
#define PORT_PDD_PIN_21 0x200000U                /**< Pin 21 mask */
#define PORT_PDD_PIN_22 0x400000U                /**< Pin 22 mask */
#define PORT_PDD_PIN_23 0x800000U                /**< Pin 23 mask */
#define PORT_PDD_PIN_24 0x1000000U               /**< Pin 24 mask */
#define PORT_PDD_PIN_25 0x2000000U               /**< Pin 25 mask */
#define PORT_PDD_PIN_26 0x4000000U               /**< Pin 26 mask */
#define PORT_PDD_PIN_27 0x8000000U               /**< Pin 27 mask */
#define PORT_PDD_PIN_28 0x10000000U              /**< Pin 28 mask */
#define PORT_PDD_PIN_29 0x20000000U              /**< Pin 29 mask */
#define PORT_PDD_PIN_30 0x40000000U              /**< Pin 30 mask */
#define PORT_PDD_PIN_31 0x80000000U              /**< Pin 31 mask */

#if ((defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN84)))
/* List of pins offering high drive capability */
  #define PORT_PDD_PTB5 0x2U                       /**< PTB5 mask */
  #define PORT_PDD_PTC1 0x4U                       /**< PTC1 mask */
  #define PORT_PDD_PTC5 0x8U                       /**< PTC5 mask */

#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) */
/* List of pins offering high drive capability */
  #define PORT_PDD_PTB4 0x1U                       /**< PTB4 mask */
  #define PORT_PDD_PTB5 0x2U                       /**< PTB5 mask */
  #define PORT_PDD_PTD0 0x4U                       /**< PTD0 mask */
  #define PORT_PDD_PTD1 0x8U                       /**< PTD1 mask */
  #define PORT_PDD_PTE0 0x10U                      /**< PTE0 mask */
  #define PORT_PDD_PTE1 0x20U                      /**< PTE1 mask */
  #define PORT_PDD_PTH0 0x40U                      /**< PTH0 mask */
  #define PORT_PDD_PTH1 0x80U                      /**< PTH1 mask */

#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) */
/* Filter selection */
#define PORT_PDD_NO_FILTER 0U                    /**< No filter */
#define PORT_PDD_BUSCLK    0U                    /**< BUSCLK */
#define PORT_PDD_FLTDIV1   0x1U                  /**< FLTDIV1 */
#define PORT_PDD_FLTDIV2   0x2U                  /**< FLTDIV2 */
#define PORT_PDD_FLTDIV3   0x3U                  /**< FLTDIV3 */

#if ((defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN84)))
/* Modules offering input pin filtering capability */
  #define PORT_PDD_PTA  0U                         /**< Selects filter for input from PTA */
  #define PORT_PDD_PTB  0x2U                       /**< Selects filter for input from PTB */
  #define PORT_PDD_PTC  0x4U                       /**< Selects filter for input from PTC */
  #define PORT_PDD_RST  0x10U                      /**< Selects filter for input from RST */
  #define PORT_PDD_KBI0 0x12U                      /**< Selects filter for input from KBI0 */
  #define PORT_PDD_KBI1 0x14U                      /**< Selects filter for input from KBI1 */
  #define PORT_PDD_NMI  0x16U                      /**< Selects filter for input from NMI */
  #define PORT_PDD_IIC  0xAU                       /**< Selects filter for input from IIC */
  #define PORT_PDD_FTM0 0xCU                       /**< Selects filter for input from FTM0 */
  #define PORT_PDD_PWT  0xEU                       /**< Selects filter for input from PWT */

#elif ((defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_SKEAZN642)))
/* Modules offering input pin filtering capability */
  #define PORT_PDD_PTA  0U                         /**< Selects filter for input from PTA */
  #define PORT_PDD_PTB  0x2U                       /**< Selects filter for input from PTB */
  #define PORT_PDD_PTC  0x4U                       /**< Selects filter for input from PTC */
  #define PORT_PDD_PTD  0x6U                       /**< Selects filter for input from PTD */
  #define PORT_PDD_PTE  0x8U                       /**< Selects filter for input from PTE */
  #define PORT_PDD_PTF  0xAU                       /**< Selects filter for input from PTF */
  #define PORT_PDD_PTG  0xCU                       /**< Selects filter for input from PTG */
  #define PORT_PDD_PTH  0xEU                       /**< Selects filter for input from PTH */
  #define PORT_PDD_RST  0x10U                      /**< Selects filter for input from RST */
  #define PORT_PDD_KBI0 0x12U                      /**< Selects filter for input from KBI0 */
  #define PORT_PDD_KBI1 0x14U                      /**< Selects filter for input from KBI1 */
  #define PORT_PDD_NMI  0x16U                      /**< Selects filter for input from NMI */

#else /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */
/* Modules offering input pin filtering capability */
  #define PORT_PDD_PTA  0U                         /**< Selects filter for input from PTA */
  #define PORT_PDD_PTB  0x2U                       /**< Selects filter for input from PTB */
  #define PORT_PDD_PTC  0x4U                       /**< Selects filter for input from PTC */
  #define PORT_PDD_PTD  0x6U                       /**< Selects filter for input from PTD */
  #define PORT_PDD_PTE  0x8U                       /**< Selects filter for input from PTE */
  #define PORT_PDD_PTF  0xAU                       /**< Selects filter for input from PTF */
  #define PORT_PDD_PTG  0xCU                       /**< Selects filter for input from PTG */
  #define PORT_PDD_PTH  0xEU                       /**< Selects filter for input from PTH */
  #define PORT_PDD_RST  0x10U                      /**< Selects filter for input from RST */
  #define PORT_PDD_KBI0 0x12U                      /**< Selects filter for input from KBI0 */
  #define PORT_PDD_KBI1 0x14U                      /**< Selects filter for input from KBI1 */
  #define PORT_PDD_NMI  0x16U                      /**< Selects filter for input from NMI */
  #define PORT_PDD_PTI  0U                         /**< Selects filter for input from PTI */
  #define PORT_PDD_IRQ  0x4U                       /**< Selects filter for input from IRQ */
  #define PORT_PDD_FTM0 0x6U                       /**< Selects filter for input from FTM0 */
  #define PORT_PDD_FTM1 0x8U                       /**< Selects filter for input from FTM1 */
  #define PORT_PDD_PWT  0xAU                       /**< Selects filter for input from PWT */
  #define PORT_PDD_I2C0 0xCU                       /**< Selects filter for input from I2C0 */
  #define PORT_PDD_I2C1 0xEU                       /**< Selects filter for input from I2C1 */

#endif /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */
/* Constants for pull type selection */
#define PORT_PDD_PULL_DOWN 0U                    /**< Pull down */
#define PORT_PDD_PULL_UP   0x1U                  /**< Pull up */

/* Constants for pull enabling/disabling */
#define PORT_PDD_PULL_DISABLE 0U                 /**< Pull resistor disabled */
#define PORT_PDD_PULL_ENABLE  0x2U               /**< Pull resistor enabled */

/* Constants for slew rate setting */
#define PORT_PDD_SLEW_RATE_FAST 0U               /**< Fast slew rate */
#define PORT_PDD_SLEW_RATE_SLOW 0x4U             /**< Slow slew rate */

/* Constants for slew rate setting */
#define PORT_PDD_PASSIVE_FILTER_DISABLE 0U       /**< Passive filter disabled */
#define PORT_PDD_PASSIVE_FILTER_ENABLE  0x10U    /**< Passive filter enabled */

/* Constants for open drain setting */
#define PORT_PDD_OPEN_DRAIN_DISABLE 0U           /**< Open drain disabled */
#define PORT_PDD_OPEN_DRAIN_ENABLE  0x20U        /**< Open drain enabled */

/* Constants for drive strength setting */
#define PORT_PDD_DRIVE_STRENGTH_LOW  0U          /**< Low drive strength */
#define PORT_PDD_DRIVE_STRENGTH_HIGH 0x40U       /**< High drive strength */

/* Constants for mux control setting */
#define PORT_PDD_MUX_CONTROL_DISABLE 0U          /**< Mux control disabled */
#define PORT_PDD_MUX_CONTROL_ALT1    0x100U      /**< Pin used with alternate 1 functionality */
#define PORT_PDD_MUX_CONTROL_ALT2    0x200U      /**< Pin used with alternate 2 functionality */
#define PORT_PDD_MUX_CONTROL_ALT3    0x300U      /**< Pin used with alternate 3 functionality */
#define PORT_PDD_MUX_CONTROL_ALT4    0x400U      /**< Pin used with alternate 4 functionality */
#define PORT_PDD_MUX_CONTROL_ALT5    0x500U      /**< Pin used with alternate 5 functionality */
#define PORT_PDD_MUX_CONTROL_ALT6    0x600U      /**< Pin used with alternate 6 functionality */
#define PORT_PDD_MUX_CONTROL_ALT7    0x700U      /**< Pin used with alternate 7 functionality */

/* Constants for pin lock setting */
#define PORT_PDD_PIN_CONTROL_UNLOCK 0U           /**< Pin control unlocked */
#define PORT_PDD_PIN_CONTROL_LOCK   0x8000U      /**< Pin control locked */

/* Constants for interrupt configuration setting */
#define PORT_PDD_INTERRUPT_DMA_DISABLED      0U  /**< Interrupt and DMA disabled */
#define PORT_PDD_DMA_ON_RISING               0x10000U /**< DMA enabled on rising edge */
#define PORT_PDD_DMA_ON_FALLING              0x20000U /**< DMA enabled on falling edge */
#define PORT_PDD_DMA_ON_RISING_FALLING       0x30000U /**< DMA enabled on rising and falling edges */
#define PORT_PDD_INTERRUPT_ON_ZERO           0x80000U /**< Interrupt enabled on low level */
#define PORT_PDD_INTERRUPT_ON_RISING         0x90000U /**< Interrupt enabled on rising edge */
#define PORT_PDD_INTERRUPT_ON_FALLING        0xA0000U /**< Interrupt enabled on falling edge */
#define PORT_PDD_INTERRUPT_ON_RISING_FALLING 0xB0000U /**< Interrupt enabled on rising and falling edges */
#define PORT_PDD_INTERRUPT_ON_ONE            0xC0000U /**< Interrupt enabled on high level */

/* Constants for digital clock source setting */
#define PORT_PDD_BUS_CLOCK 0U                    /**< Bus clock as filter clock source */
#define PORT_PDD_LPO_CLOCK 0x1U                  /**< LPO clock as filter clock source */

/* Constants for Filter Division Set 1 */
#define PORT_PDD_BUSCLK_DIV_2  0U                /**< BUSCLK/2 */
#define PORT_PDD_BUSCLK_DIV_4  0x1000000U        /**< BUSCLK/4 */
#define PORT_PDD_BUSCLK_DIV_8  0x2000000U        /**< BUSCLK/8 */
#define PORT_PDD_BUSCLK_DIV_16 0x3000000U        /**< BUSCLK/16 */

/* Constants for Filter Division Set 2 */
#define PORT_PDD_BUSCLK_DIV_32   0U              /**< BUSCLK/32 */
#define PORT_PDD_BUSCLK_DIV_64   0x4000000U      /**< BUSCLK/64 */
#define PORT_PDD_BUSCLK_DIV_128  0x8000000U      /**< BUSCLK/128 */
#define PORT_PDD_BUSCLK_DIV_256  0xC000000U      /**< BUSCLK/256 */
#define PORT_PDD_BUSCLK_DIV_512  0x10000000U     /**< BUSCLK/512 */
#define PORT_PDD_BUSCLK_DIV_1024 0x14000000U     /**< BUSCLK/1024 */
#define PORT_PDD_BUSCLK_DIV_2048 0x18000000U     /**< BUSCLK/2048 */
#define PORT_PDD_BUSCLK_DIV_4096 0x1C000000U     /**< BUSCLK/4096 */

/* Constants for Filter Division Set 3 */
#define PORT_PDD_LPOCLK         0U               /**< LPOCLK */
#define PORT_PDD_LPOCLK_DIV_2   0x20000000U      /**< LPOCLK/2 */
#define PORT_PDD_LPOCLK_DIV_4   0x40000000U      /**< LPOCLK/4 */
#define PORT_PDD_LPOCLK_DIV_8   0x60000000U      /**< LPOCLK/8 */
#define PORT_PDD_LPOCLK_DIV_16  0x80000000U      /**< LPOCLK/16 */
#define PORT_PDD_LPOCLK_DIV_32  0xA0000000U      /**< LPOCLK/32 */
#define PORT_PDD_LPOCLK_DIV_64  0xC0000000U      /**< LPOCLK/64 */
#define PORT_PDD_LPOCLK_DIV_128 0xE0000000U      /**< LPOCLK/128 */


/* ----------------------------------------------------------------------------
   -- GetPinPullSelect
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets which pull resistor is selected.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of "Constants for pull type selection" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetPinPullSelect(<peripheral>_BASE_PTR,
 *      periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinPullSelect(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_PS_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- SetPinPullSelect
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets pull type.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @param Type Pull type. This parameter is of "Constants for pull type
 *        selection" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_SetPinPullSelect(<peripheral>_BASE_PTR, periphID,
 *      PORT_PDD_PULL_DOWN);
 *      @endcode
 */
#define PORT_PDD_SetPinPullSelect(PeripheralBase, PinIndex, Type) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) = \
     (uint32)(( \
      (uint32)(( \
       PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \
       (uint32)(~(uint32)PORT_PCR_PS_MASK)) & ( \
       (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \
      (uint32)(Type))) \
  )

/* ----------------------------------------------------------------------------
   -- GetPinPullEnable
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets whether pull resistor is enabled.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of "Constants for pull enabling/disabling" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetPinPullEnable(<peripheral>_BASE_PTR,
 *      periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinPullEnable(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_PE_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- SetPinPullEnable
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets pull type.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @param State Requested state of pull enable. This parameter is of "Constants
 *        for pull enabling/disabling" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_SetPinPullEnable(<peripheral>_BASE_PTR, periphID,
 *      PORT_PDD_PULL_DISABLE);
 *      @endcode
 */
#define PORT_PDD_SetPinPullEnable(PeripheralBase, PinIndex, State) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) = \
     (uint32)(( \
      (uint32)(( \
       PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \
       (uint32)(~(uint32)PORT_PCR_PE_MASK)) & ( \
       (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \
      (uint32)(State))) \
  )

/* ----------------------------------------------------------------------------
   -- GetPinSlewRate
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets how slew rate is set.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of "Constants for slew rate setting" type. The value
 *         is cast to "uint32".
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetPinSlewRate(<peripheral>_BASE_PTR,
 *      periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinSlewRate(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_SRE_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- SetPinSlewRate
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets slew rate.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @param State Requested state of slew rate. This parameter is of "Constants
 *        for slew rate setting" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_SetPinSlewRate(<peripheral>_BASE_PTR, periphID,
 *      PORT_PDD_SLEW_RATE_FAST);
 *      @endcode
 */
#define PORT_PDD_SetPinSlewRate(PeripheralBase, PinIndex, State) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) = \
     (uint32)(( \
      (uint32)(( \
       PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \
       (uint32)(~(uint32)PORT_PCR_SRE_MASK)) & ( \
       (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \
      (uint32)(State))) \
  )

/* ----------------------------------------------------------------------------
   -- GetPinPassiveFilter
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets whether passive filter is enabled.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of "Constants for slew rate setting" type. The value
 *         is cast to "uint32".
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetPinPassiveFilter(<peripheral>_BASE_PTR,
 *      periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinPassiveFilter(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_PFE_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- SetPinPassiveFilter
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets passive filter.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @param State Requested state of passive filter. This parameter is of
 *        "Constants for slew rate setting" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_SetPinPassiveFilter(<peripheral>_BASE_PTR, periphID,
 *      PORT_PDD_PASSIVE_FILTER_DISABLE);
 *      @endcode
 */
#define PORT_PDD_SetPinPassiveFilter(PeripheralBase, PinIndex, State) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) = \
     (uint32)(( \
      (uint32)(( \
       PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \
       (uint32)(~(uint32)PORT_PCR_PFE_MASK)) & ( \
       (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \
      (uint32)(State))) \
  )

/* ----------------------------------------------------------------------------
   -- GetPinOpenDrain
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets whether open drain is enabled.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of "Constants for open drain setting" type. The value
 *         is cast to "uint32".
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetPinOpenDrain(<peripheral>_BASE_PTR,
 *      periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinOpenDrain(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_ODE_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- SetPinOpenDrain
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets open drain.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @param State Requested state of open drain. This parameter is of "Constants
 *        for open drain setting" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_SetPinOpenDrain(<peripheral>_BASE_PTR, periphID,
 *      PORT_PDD_OPEN_DRAIN_DISABLE);
 *      @endcode
 */
#define PORT_PDD_SetPinOpenDrain(PeripheralBase, PinIndex, State) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) = \
     (uint32)(( \
      (uint32)(( \
       PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \
       (uint32)(~(uint32)PORT_PCR_ODE_MASK)) & ( \
       (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \
      (uint32)(State))) \
  )

/* ----------------------------------------------------------------------------
   -- GetPinDriverStrength
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets how drive strength is set.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of "Constants for drive strength setting" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetPinDriverStrength(<peripheral>_BASE_PTR,
 *      periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinDriverStrength(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_DSE_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- SetPinDriveStrength
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets drive strength.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @param State Requested state of drive strength. This parameter is of
 *        "Constants for drive strength setting" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_SetPinDriveStrength(<peripheral>_BASE_PTR, periphID,
 *      PORT_PDD_DRIVE_STRENGTH_LOW);
 *      @endcode
 */
#define PORT_PDD_SetPinDriveStrength(PeripheralBase, PinIndex, State) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) = \
     (uint32)(( \
      (uint32)(( \
       PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \
       (uint32)(~(uint32)PORT_PCR_DSE_MASK)) & ( \
       (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \
      (uint32)(State))) \
  )

/* ----------------------------------------------------------------------------
   -- GetPinMuxControl
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets how mux control is set.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of "Constants for mux control setting" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetPinMuxControl(<peripheral>_BASE_PTR,
 *      periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinMuxControl(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_MUX_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- SetPinMuxControl
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets mux control.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @param State Requested state of Mux control. This parameter is of "Constants
 *        for mux control setting" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_SetPinMuxControl(<peripheral>_BASE_PTR, periphID,
 *      PORT_PDD_MUX_CONTROL_DISABLE);
 *      @endcode
 */
#define PORT_PDD_SetPinMuxControl(PeripheralBase, PinIndex, State) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) = \
     (uint32)(( \
      (uint32)(( \
       PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \
       (uint32)(~(uint32)PORT_PCR_MUX_MASK)) & ( \
       (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \
      (uint32)(State))) \
  )

/* ----------------------------------------------------------------------------
   -- GetPinControlLock
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets how pin lock is set.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of "Constants for pin lock setting" type. The value
 *         is cast to "uint32".
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetPinControlLock(<peripheral>_BASE_PTR,
 *      periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinControlLock(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_LK_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- LockPinControl
   ---------------------------------------------------------------------------- */

/**
 * @brief Locks pin control such as settings of pull, slew rate, passive filter,
 * open drain, mux control and pin lock.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @param State Requested state of pin lock. This parameter is of "Constants for
 *        pin lock setting" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_LockPinControl(<peripheral>_BASE_PTR, periphID,
 *      PORT_PDD_PIN_CONTROL_UNLOCK);
 *      @endcode
 */
#define PORT_PDD_LockPinControl(PeripheralBase, PinIndex, State) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) = \
     (uint32)(( \
      (uint32)(( \
       PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \
       (uint32)(~(uint32)PORT_PCR_LK_MASK)) & ( \
       (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \
      (uint32)(State))) \
  )

/* ----------------------------------------------------------------------------
   -- GetPinInterruptConfiguration
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets how interupt configuration is set.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of "Constants for interrupt configuration setting"
 *         type. The value is cast to "uint32".
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result =
 *      PORT_PDD_GetPinInterruptConfiguration(<peripheral>_BASE_PTR, periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinInterruptConfiguration(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_IRQC_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- SetPinInterruptConfiguration
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets interrupt configuration.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @param State Requested state of interrupt configuration. This parameter is of
 *        "Constants for interrupt configuration setting" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_SetPinInterruptConfiguration(<peripheral>_BASE_PTR, periphID,
 *      PORT_PDD_INTERRUPT_DMA_DISABLED);
 *      @endcode
 */
#define PORT_PDD_SetPinInterruptConfiguration(PeripheralBase, PinIndex, State) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) = \
     (uint32)(( \
      (uint32)(( \
       PORT_PCR_REG(PeripheralBase,(PinIndex))) & (( \
       (uint32)(~(uint32)PORT_PCR_IRQC_MASK)) & ( \
       (uint32)(~(uint32)PORT_PCR_ISF_MASK))))) | ( \
      (uint32)(State))) \
  )

/* ----------------------------------------------------------------------------
   -- GetPinInterruptFlag
   ---------------------------------------------------------------------------- */

/**
 * @brief Returns interrupt flags.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetPinInterruptFlag(<peripheral>_BASE_PTR,
 *      periphID);
 *      @endcode
 */
#define PORT_PDD_GetPinInterruptFlag(PeripheralBase, PinIndex) ( \
    (uint32)(PORT_PCR_REG(PeripheralBase,(PinIndex)) & PORT_PCR_ISF_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- GetInterruptFlags
   ---------------------------------------------------------------------------- */

/**
 * @brief Returns interrupt flags.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORTA_ISFR, PORTB_ISFR,
 *          PORTC_ISFR, PORTD_ISFR, PORTE_ISFR, PORTF_ISFR (depending on the
 *          peripheral).
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetInterruptFlags(<peripheral>_BASE_PTR);
 *      @endcode
 */
#define PORT_PDD_GetInterruptFlags(PeripheralBase) ( \
    PORT_ISFR_REG(PeripheralBase) \
  )

/* ----------------------------------------------------------------------------
   -- ClearPinInterruptFlag
   ---------------------------------------------------------------------------- */

/**
 * @brief Clears interrupt flag.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PinIndex Pin index inside the port. This parameter is of index type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PCR[PinIndex].
 * @par Example:
 *      @code
 *      PORT_PDD_ClearPinInterruptFlag(<peripheral>_BASE_PTR, periphID);
 *      @endcode
 */
#define PORT_PDD_ClearPinInterruptFlag(PeripheralBase, PinIndex) ( \
    PORT_PCR_REG(PeripheralBase,(PinIndex)) |= \
     PORT_PCR_ISF_MASK \
  )

/* ----------------------------------------------------------------------------
   -- ClearInterruptFlags
   ---------------------------------------------------------------------------- */

/**
 * @brief Clears interrupt flag bits defined by mask parameter.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Mask Mask of pins to clearing theirs interrupt flags. Use constants
 *        from group "Pin masks". This parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORTA_ISFR, PORTB_ISFR,
 *          PORTC_ISFR, PORTD_ISFR, PORTE_ISFR, PORTF_ISFR (depending on the
 *          peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_ClearInterruptFlags(<peripheral>_BASE_PTR, PORT_PDD_PIN_0);
 *      @endcode
 */
#define PORT_PDD_ClearInterruptFlags(PeripheralBase, Mask) ( \
    PORT_ISFR_REG(PeripheralBase) = \
     (uint32)(Mask) \
  )

/* ----------------------------------------------------------------------------
   -- SetGlobalPinControl
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets required pin control for required pins of whole port.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Mask Mask of pins in port where the bit 0 corresponds with the pin
 *        which has index 0 within the port and the bit 31 corresponds with the pin
 *        which has index 31 within the port. This parameter is a 32-bit value.
 * @param Value Settings of pull, slew rate, passive filter, open drain, mux
 *        control and pin lock . This parameter is a 16-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORTA_GPCLR,
 *          PORTA_GPCHR, PORTB_GPCLR, PORTB_GPCHR, PORTC_GPCLR, PORTC_GPCHR, PORTD_GPCLR,
 *          PORTD_GPCHR, PORTE_GPCLR, PORTE_GPCHR, PORTF_GPCLR, PORTF_GPCHR
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetGlobalPinControl(<peripheral>_BASE_PTR, 1, 1);
 *      @endcode
 */
#define PORT_PDD_SetGlobalPinControl(PeripheralBase, Mask, Value) ( \
    (PORT_GPCLR_REG(PeripheralBase) = \
     (uint32)(( \
      (uint32)((uint32)((uint32)(Mask) & 0xFFFFU) << PORT_GPCLR_GPWE_SHIFT)) | ( \
      (uint32)(Value)))), \
    (PORT_GPCHR_REG(PeripheralBase) = \
     (uint32)(( \
      (uint32)((uint32)(Mask) & (uint32)(~(uint32)0xFFFFU))) | ( \
      (uint32)(Value)))) \
  )

/* ----------------------------------------------------------------------------
   -- SetGlobalPinControlLow
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets required pin control for required pins from low part of port.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Mask Mask of pins in port where the bit 0 corresponds with the pin
 *        which has index 0 within the port and the bit 15 corresponds with the pin
 *        which has index 15 within the port. This parameter is a 16-bit value.
 * @param Value Settings of pull, slew rate, passive filter, open drain, mux
 *        control and pin lock . This parameter is a 16-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORTA_GPCLR,
 *          PORTB_GPCLR, PORTC_GPCLR, PORTD_GPCLR, PORTE_GPCLR, PORTF_GPCLR (depending on
 *          the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetGlobalPinControlLow(<peripheral>_BASE_PTR, 1, 1);
 *      @endcode
 */
#define PORT_PDD_SetGlobalPinControlLow(PeripheralBase, Mask, Value) ( \
    PORT_GPCLR_REG(PeripheralBase) = \
     (uint32)((uint32)((uint32)(Mask) << PORT_GPCLR_GPWE_SHIFT) | (uint32)(Value)) \
  )

/* ----------------------------------------------------------------------------
   -- SetGlobalPinControlHigh
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets required pin control for required pins from high part of port.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Mask Mask of pins in port where the bit 0 corresponds with the pin
 *        which has index 16 within the port and the bit 15 corresponds with the pin
 *        which has index 31 within the port. This parameter is a 16-bit value.
 * @param Value Settings of pull, slew rate, passive filter, open drain, mux
 *        control and pin lock . This parameter is a 16-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORTA_GPCHR,
 *          PORTB_GPCHR, PORTC_GPCHR, PORTD_GPCHR, PORTE_GPCHR, PORTF_GPCHR (depending on
 *          the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetGlobalPinControlHigh(<peripheral>_BASE_PTR, 1, 1);
 *      @endcode
 */
#define PORT_PDD_SetGlobalPinControlHigh(PeripheralBase, Mask, Value) ( \
    PORT_GPCHR_REG(PeripheralBase) = \
     (uint32)((uint32)((uint32)(Mask) << PORT_GPCHR_GPWE_SHIFT) | (uint32)(Value)) \
  )

/* ----------------------------------------------------------------------------
   -- GetEnableDigitalFilterStatusMask
   ---------------------------------------------------------------------------- */

/**
 * @brief Returns enable status of digital filter for whole port.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORTA_DFER, PORTB_DFER,
 *          PORTC_DFER, PORTD_DFER, PORTE_DFER, PORTF_DFER (depending on the
 *          peripheral).
 * @par Example:
 *      @code
 *      uint32 result =
 *      PORT_PDD_GetEnableDigitalFilterStatusMask(<peripheral>_BASE_PTR);
 *      @endcode
 */
#define PORT_PDD_GetEnableDigitalFilterStatusMask(PeripheralBase) ( \
    PORT_DFER_REG(PeripheralBase) \
  )

/* ----------------------------------------------------------------------------
   -- EnableDigitalFilters
   ---------------------------------------------------------------------------- */

/**
 * @brief Enables digital filters.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Mask Mask of pins. Use constants from group "Pin masks". This
 *        parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORTA_DFER, PORTB_DFER,
 *          PORTC_DFER, PORTD_DFER, PORTE_DFER, PORTF_DFER (depending on the
 *          peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_EnableDigitalFilters(<peripheral>_BASE_PTR, PORT_PDD_PIN_0);
 *      @endcode
 */
#define PORT_PDD_EnableDigitalFilters(PeripheralBase, Mask) ( \
    PORT_DFER_REG(PeripheralBase) |= \
     (uint32)(Mask) \
  )

/* ----------------------------------------------------------------------------
   -- DisableDigitalFilters
   ---------------------------------------------------------------------------- */

/**
 * @brief Disables digital filters.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Mask Mask of pins. Use constants from group "Pin masks". This
 *        parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORTA_DFER, PORTB_DFER,
 *          PORTC_DFER, PORTD_DFER, PORTE_DFER, PORTF_DFER (depending on the
 *          peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_DisableDigitalFilters(<peripheral>_BASE_PTR, PORT_PDD_PIN_0);
 *      @endcode
 */
#define PORT_PDD_DisableDigitalFilters(PeripheralBase, Mask) ( \
    PORT_DFER_REG(PeripheralBase) &= \
     (uint32)(~(uint32)(Mask)) \
  )

/* ----------------------------------------------------------------------------
   -- GetFilterClockSource
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets how filter clock source is set.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a value of "Constants for digital clock source setting" type.
 *         The value is cast to "uint32".
 * @remarks The macro accesses the following registers: PORTA_DFCR, PORTB_DFCR,
 *          PORTC_DFCR, PORTD_DFCR, PORTE_DFCR, PORTF_DFCR (depending on the
 *          peripheral).
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetFilterClockSource(<peripheral>_BASE_PTR);
 *      @endcode
 */
#define PORT_PDD_GetFilterClockSource(PeripheralBase) ( \
    (uint32)(PORT_DFCR_REG(PeripheralBase) & PORT_DFCR_CS_MASK) \
  )

/* ----------------------------------------------------------------------------
   -- SetFilterClockSource
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets filter clock source.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param State Requested state of filter clock source. This parameter is of
 *        "Constants for digital clock source setting" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORTA_DFCR, PORTB_DFCR,
 *          PORTC_DFCR, PORTD_DFCR, PORTE_DFCR, PORTF_DFCR (depending on the
 *          peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilterClockSource(<peripheral>_BASE_PTR,
 *      PORT_PDD_BUS_CLOCK);
 *      @endcode
 */
#define PORT_PDD_SetFilterClockSource(PeripheralBase, State) ( \
    PORT_DFCR_REG(PeripheralBase) = \
     (uint32)(( \
      (uint32)(PORT_DFCR_REG(PeripheralBase) & (uint32)(~(uint32)PORT_DFCR_CS_MASK))) | ( \
      (uint32)(State))) \
  )

/* ----------------------------------------------------------------------------
   -- GetFilterLength
   ---------------------------------------------------------------------------- */

/**
 * @brief Returns filter length in clock cycles.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORTA_DFWR, PORTB_DFWR,
 *          PORTC_DFWR, PORTD_DFWR, PORTE_DFWR, PORTF_DFWR (depending on the
 *          peripheral).
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetFilterLength(<peripheral>_BASE_PTR);
 *      @endcode
 */
#define PORT_PDD_GetFilterLength(PeripheralBase) ( \
    PORT_DFWR_REG(PeripheralBase) \
  )

/* ----------------------------------------------------------------------------
   -- SetFilterLength
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets filter length in clock cycles.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Parameter specifying new value. This parameter is a 5-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORTA_DFWR, PORTB_DFWR,
 *          PORTC_DFWR, PORTD_DFWR, PORTE_DFWR, PORTF_DFWR (depending on the
 *          peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilterLength(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
#define PORT_PDD_SetFilterLength(PeripheralBase, Value) ( \
    PORT_DFWR_REG(PeripheralBase) = \
     (uint32)(Value) \
  )

/* ----------------------------------------------------------------------------
   -- GetFilterDivisionSet1
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)))
/**
 * @brief Gets configuration of the Filter Division Set 1.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a value of "Constants for Filter Division Set 1" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetFilterDivisionSet1(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_GetFilterDivisionSet1(PeripheralBase) ( \
      (uint32)(PORT_IOFLT0_REG(PeripheralBase) & PORT_IOFLT0_FLTDIV1_MASK) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
/**
 * @brief Gets configuration of the Filter Division Set 1.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a value of "Constants for Filter Division Set 1" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetFilterDivisionSet1(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_GetFilterDivisionSet1(PeripheralBase) ( \
      (uint32)(PORT_IOFLT_REG(PeripheralBase) & PORT_IOFLT_FLTDIV1_MASK) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */

/* ----------------------------------------------------------------------------
   -- SetFilterDivisionSet1
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)))
/**
 * @brief Configures Filter Division Set 1.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param FilterDivision Filter division 1. This parameter is of "Constants for
 *        Filter Division Set 1" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilterDivisionSet1(<peripheral>_BASE_PTR,
 *      PORT_PDD_BUSCLK_DIV_2);
 *      @endcode
 */
  #define PORT_PDD_SetFilterDivisionSet1(PeripheralBase, FilterDivision) ( \
      PORT_IOFLT0_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(( \
         PORT_IOFLT0_REG(PeripheralBase)) & ( \
         (uint32)(~(uint32)PORT_IOFLT0_FLTDIV1_MASK)))) | ( \
        (uint32)(FilterDivision))) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
/**
 * @brief Configures Filter Division Set 1.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param FilterDivision Filter division 1. This parameter is of "Constants for
 *        Filter Division Set 1" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilterDivisionSet1(<peripheral>_BASE_PTR,
 *      PORT_PDD_BUSCLK_DIV_2);
 *      @endcode
 */
  #define PORT_PDD_SetFilterDivisionSet1(PeripheralBase, FilterDivision) ( \
      PORT_IOFLT_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(( \
         PORT_IOFLT_REG(PeripheralBase)) & ( \
         (uint32)(~(uint32)PORT_IOFLT_FLTDIV1_MASK)))) | ( \
        (uint32)(FilterDivision))) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */

/* ----------------------------------------------------------------------------
   -- GetFilterDivisionSet2
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)))
/**
 * @brief Gets configuration of the Filter Division Set 2.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a value of "Constants for Filter Division Set 2" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetFilterDivisionSet2(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_GetFilterDivisionSet2(PeripheralBase) ( \
      (uint32)(PORT_IOFLT0_REG(PeripheralBase) & PORT_IOFLT0_FLTDIV2_MASK) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
/**
 * @brief Gets configuration of the Filter Division Set 2.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a value of "Constants for Filter Division Set 2" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetFilterDivisionSet2(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_GetFilterDivisionSet2(PeripheralBase) ( \
      (uint32)(PORT_IOFLT_REG(PeripheralBase) & PORT_IOFLT_FLTDIV2_MASK) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */

/* ----------------------------------------------------------------------------
   -- SetFilterDivisionSet2
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)))
/**
 * @brief Configures Filter Division Set 2.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param FilterDivision Filter division 2. This parameter is of "Constants for
 *        Filter Division Set 2" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilterDivisionSet2(<peripheral>_BASE_PTR,
 *      PORT_PDD_BUSCLK_DIV_32);
 *      @endcode
 */
  #define PORT_PDD_SetFilterDivisionSet2(PeripheralBase, FilterDivision) ( \
      PORT_IOFLT0_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(( \
         PORT_IOFLT0_REG(PeripheralBase)) & ( \
         (uint32)(~(uint32)PORT_IOFLT0_FLTDIV2_MASK)))) | ( \
        (uint32)(FilterDivision))) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
/**
 * @brief Configures Filter Division Set 2.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param FilterDivision Filter division 2. This parameter is of "Constants for
 *        Filter Division Set 2" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilterDivisionSet2(<peripheral>_BASE_PTR,
 *      PORT_PDD_BUSCLK_DIV_32);
 *      @endcode
 */
  #define PORT_PDD_SetFilterDivisionSet2(PeripheralBase, FilterDivision) ( \
      PORT_IOFLT_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(( \
         PORT_IOFLT_REG(PeripheralBase)) & ( \
         (uint32)(~(uint32)PORT_IOFLT_FLTDIV2_MASK)))) | ( \
        (uint32)(FilterDivision))) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */

/* ----------------------------------------------------------------------------
   -- GetFilterDivisionSet3
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)))
/**
 * @brief Gets configuration of the Filter Division Set 3.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a value of "Constants for Filter Division Set 3" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetFilterDivisionSet3(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_GetFilterDivisionSet3(PeripheralBase) ( \
      (uint32)(PORT_IOFLT0_REG(PeripheralBase) & PORT_IOFLT0_FLTDIV3_MASK) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
/**
 * @brief Gets configuration of the Filter Division Set 3.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a value of "Constants for Filter Division Set 3" type. The
 *         value is cast to "uint32".
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_GetFilterDivisionSet3(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_GetFilterDivisionSet3(PeripheralBase) ( \
      (uint32)(PORT_IOFLT_REG(PeripheralBase) & PORT_IOFLT_FLTDIV3_MASK) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */

/* ----------------------------------------------------------------------------
   -- SetFilterDivisionSet3
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)))
/**
 * @brief Configures Filter Division Set 3.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param FilterDivision Filter division 3. This parameter is of "Constants for
 *        Filter Division Set 3" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilterDivisionSet3(<peripheral>_BASE_PTR, PORT_PDD_LPOCLK);
 *      @endcode
 */
  #define PORT_PDD_SetFilterDivisionSet3(PeripheralBase, FilterDivision) ( \
      PORT_IOFLT0_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(( \
         PORT_IOFLT0_REG(PeripheralBase)) & ( \
         (uint32)(~(uint32)PORT_IOFLT0_FLTDIV3_MASK)))) | ( \
        (uint32)(FilterDivision))) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
/**
 * @brief Configures Filter Division Set 3.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param FilterDivision Filter division 3. This parameter is of "Constants for
 *        Filter Division Set 3" type.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT, PORT_IOFLT0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilterDivisionSet3(<peripheral>_BASE_PTR, PORT_PDD_LPOCLK);
 *      @endcode
 */
  #define PORT_PDD_SetFilterDivisionSet3(PeripheralBase, FilterDivision) ( \
      PORT_IOFLT_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(( \
         PORT_IOFLT_REG(PeripheralBase)) & ( \
         (uint32)(~(uint32)PORT_IOFLT_FLTDIV3_MASK)))) | ( \
        (uint32)(FilterDivision))) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */

/* ----------------------------------------------------------------------------
   -- GetFilter
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets filter configuration for module input pins.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Module Module. Use constants from group "Modules offering input pin
 *        filtering capability". This parameter is 5 bits wide.
 * @return Use constants from group "Filter selection" for processing return
 *         value. The value is cast to "uint8".
 * @remarks The macro accesses the following registers: PORT_IOFLT.
 * @par Example:
 *      @code
 *      uint8 result = PORT_PDD_GetFilter(<peripheral>_BASE_PTR,
 *      PORT_PDD_PTA);
 *      @endcode
 */
#define PORT_PDD_GetFilter(PeripheralBase, Module) ( \
    (uint8)((uint8)(PORT_IOFLT_REG(PeripheralBase) >> (uint8)(Module)) & (uint8)0x3U) \
  )

/* ----------------------------------------------------------------------------
   -- SetFilter
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets filter for module input pins.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Module Module to be configured. Use constants from group "Modules
 *        offering input pin filtering capability". This parameter is 5 bits wide.
 * @param Filter Selected filter. Use constants from group "Filter selection".
 *        This parameter is 2 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT.
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilter(<peripheral>_BASE_PTR, PORT_PDD_PTA,
 *      PORT_PDD_NO_FILTER);
 *      @endcode
 */
#define PORT_PDD_SetFilter(PeripheralBase, Module, Filter) ( \
    PORT_IOFLT_REG(PeripheralBase) = \
     (uint32)(( \
      (uint32)(( \
       PORT_IOFLT_REG(PeripheralBase)) & ( \
       (uint32)(~(uint32)((uint32)0x3U << (uint8)(Module)))))) | ( \
      (uint32)((uint32)(Filter) << (uint8)(Module)))) \
  )

/* ----------------------------------------------------------------------------
   -- WritePortFilterReg
   ---------------------------------------------------------------------------- */

/**
 * @brief Writes port filter register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Value to be written into IOFLT0 register. This parameter is a
 *        32-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT.
 * @par Example:
 *      @code
 *      PORT_PDD_WritePortFilterReg(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
#define PORT_PDD_WritePortFilterReg(PeripheralBase, Value) ( \
    PORT_IOFLT_REG(PeripheralBase) = \
     (uint32)(Value) \
  )

/* ----------------------------------------------------------------------------
   -- ReadPortFilterReg
   ---------------------------------------------------------------------------- */

/**
 * @brief Reads port filter register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORT_IOFLT.
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_ReadPortFilterReg(<peripheral>_BASE_PTR);
 *      @endcode
 */
#define PORT_PDD_ReadPortFilterReg(PeripheralBase) ( \
    PORT_IOFLT_REG(PeripheralBase) \
  )

/* ----------------------------------------------------------------------------
   -- EnablePullupLowPortMask
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)))
/**
 * @brief Enables/Disables pullup resistors on low port pins specified by mask
 * parameters.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PullupDisableMask Mask of low port pins to be disabled. Use constants
 *        from group "Pin masks". This parameter is 32 bits wide.
 * @param PullupEnableMask Mask of low port pins to be enabled. Use constants
 *        from group "Pin masks". This parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_EnablePullupLowPortMask(<peripheral>_BASE_PTR, PORT_PDD_PIN_0,
 *      PORT_PDD_PIN_0);
 *      @endcode
 */
  #define PORT_PDD_EnablePullupLowPortMask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \
      PORT_PUE0_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(PORT_PUE0_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \
        (uint32)(PullupEnableMask))) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
/**
 * @brief Enables/Disables pullup resistors on low port pins specified by mask
 * parameters.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PullupDisableMask Mask of low port pins to be disabled. Use constants
 *        from group "Pin masks". This parameter is 32 bits wide.
 * @param PullupEnableMask Mask of low port pins to be enabled. Use constants
 *        from group "Pin masks". This parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_EnablePullupLowPortMask(<peripheral>_BASE_PTR, PORT_PDD_PIN_0,
 *      PORT_PDD_PIN_0);
 *      @endcode
 */
  #define PORT_PDD_EnablePullupLowPortMask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \
      PORT_PUEL_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(PORT_PUEL_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \
        (uint32)(PullupEnableMask))) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */

/* ----------------------------------------------------------------------------
   -- WritePullupEnableLowReg
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)))
/**
 * @brief Writes pullup enable low register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Parameter specifying mask of the new pullup enable setting for
 *        low port pins. Bit #0 of the mask controls pullup setting of the low
 *        port pin #0, bit #31 controls setting of the pin #31. Bit value 0 disables
 *        pullup for associated low port pin, bit value 1 enables pullup for
 *        associated low port pin. This parameter is a 32-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_WritePullupEnableLowReg(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
  #define PORT_PDD_WritePullupEnableLowReg(PeripheralBase, Value) ( \
      PORT_PUE0_REG(PeripheralBase) = \
       (uint32)(Value) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
/**
 * @brief Writes pullup enable low register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Parameter specifying mask of the new pullup enable setting for
 *        low port pins. Bit #0 of the mask controls pullup setting of the low
 *        port pin #0, bit #31 controls setting of the pin #31. Bit value 0 disables
 *        pullup for associated low port pin, bit value 1 enables pullup for
 *        associated low port pin. This parameter is a 32-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_WritePullupEnableLowReg(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
  #define PORT_PDD_WritePullupEnableLowReg(PeripheralBase, Value) ( \
      PORT_PUEL_REG(PeripheralBase) = \
       (uint32)(Value) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */

/* ----------------------------------------------------------------------------
   -- ReadPullupEnableLowReg
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)))
/**
 * @brief Reads pullup enable configuration of the low port pins. Bit #0 of
 * return value contains pullup setting of the low port pin #0, bit #31 contains
 * setting of the pin #31.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result =
 *      PORT_PDD_ReadPullupEnableLowReg(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_ReadPullupEnableLowReg(PeripheralBase) ( \
      PORT_PUE0_REG(PeripheralBase) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */
/**
 * @brief Reads pullup enable configuration of the low port pins. Bit #0 of
 * return value contains pullup setting of the low port pin #0, bit #31 contains
 * setting of the pin #31.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORT_PUEL, PORT_PUE0
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result =
 *      PORT_PDD_ReadPullupEnableLowReg(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_ReadPullupEnableLowReg(PeripheralBase) ( \
      PORT_PUEL_REG(PeripheralBase) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN642)) || (defined(MCU_SKEAZN84)) */

/* ----------------------------------------------------------------------------
   -- EnablePullupHighPortMask
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_SKEAZN642)))
/**
 * @brief Enables/Disables pullup resistors on high port pins specified by mask
 * parameters.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PullupDisableMask Mask of high port pins with pullup to be disabled.
 *        Use constants from group "Pin masks". This parameter is 32 bits wide.
 * @param PullupEnableMask Mask of high port pins with pullup to be enabled. Use
 *        constants from group "Pin masks". This parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_EnablePullupHighPortMask(<peripheral>_BASE_PTR,
 *      PORT_PDD_PIN_0, PORT_PDD_PIN_0);
 *      @endcode
 */
  #define PORT_PDD_EnablePullupHighPortMask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \
      PORT_PUEH_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(PORT_PUEH_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \
        (uint32)(PullupEnableMask))) \
    )
#else /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */
/**
 * @brief Enables/Disables pullup resistors on high port pins specified by mask
 * parameters.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PullupDisableMask Mask of high port pins with pullup to be disabled.
 *        Use constants from group "Pin masks". This parameter is 32 bits wide.
 * @param PullupEnableMask Mask of high port pins with pullup to be enabled. Use
 *        constants from group "Pin masks". This parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_EnablePullupHighPortMask(<peripheral>_BASE_PTR,
 *      PORT_PDD_PIN_0, PORT_PDD_PIN_0);
 *      @endcode
 */
  #define PORT_PDD_EnablePullupHighPortMask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \
      PORT_PUE1_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(PORT_PUE1_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \
        (uint32)(PullupEnableMask))) \
    )
#endif /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */

/* ----------------------------------------------------------------------------
   -- WritePullupEnableHighReg
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_SKEAZN642)))
/**
 * @brief Writes pullup enable high register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Parameter specifying mask of the new pullup enable setting for
 *        high port pins. Bit #0 of the mask controls pullup setting of the high
 *        port pin #0, bit #31 controls setting of the pin #31. Bit value 0
 *        disables pullup for associated high port pin, bit value 1 enables pullup for
 *        associated high port pin. This parameter is a 32-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_WritePullupEnableHighReg(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
  #define PORT_PDD_WritePullupEnableHighReg(PeripheralBase, Value) ( \
      PORT_PUEH_REG(PeripheralBase) = \
       (uint32)(Value) \
    )
#else /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */
/**
 * @brief Writes pullup enable high register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Parameter specifying mask of the new pullup enable setting for
 *        high port pins. Bit #0 of the mask controls pullup setting of the high
 *        port pin #0, bit #31 controls setting of the pin #31. Bit value 0
 *        disables pullup for associated high port pin, bit value 1 enables pullup for
 *        associated high port pin. This parameter is a 32-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      PORT_PDD_WritePullupEnableHighReg(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
  #define PORT_PDD_WritePullupEnableHighReg(PeripheralBase, Value) ( \
      PORT_PUE1_REG(PeripheralBase) = \
       (uint32)(Value) \
    )
#endif /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */

/* ----------------------------------------------------------------------------
   -- ReadPullupEnableHighReg
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_SKEAZN642)))
/**
 * @brief Reads pullup enable configuration of the high port pins. Bit #0 of
 * return value contains pullup setting of the high port pin #0, bit #31 contains
 * setting of the pin #31.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result =
 *      PORT_PDD_ReadPullupEnableHighReg(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_ReadPullupEnableHighReg(PeripheralBase) ( \
      PORT_PUEH_REG(PeripheralBase) \
    )
#else /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */
/**
 * @brief Reads pullup enable configuration of the high port pins. Bit #0 of
 * return value contains pullup setting of the high port pin #0, bit #31 contains
 * setting of the pin #31.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORT_PUEH, PORT_PUE1
 *          (depending on the peripheral).
 * @par Example:
 *      @code
 *      uint32 result =
 *      PORT_PDD_ReadPullupEnableHighReg(<peripheral>_BASE_PTR);
 *      @endcode
 */
  #define PORT_PDD_ReadPullupEnableHighReg(PeripheralBase) ( \
      PORT_PUE1_REG(PeripheralBase) \
    )
#endif /* (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) */

/* ----------------------------------------------------------------------------
   -- EnableHighDriveMask
   ---------------------------------------------------------------------------- */

#if ((defined(MCU_MKE04Z4)) || (defined(MCU_SKEAZN84)))
/**
 * @brief Enables/Disables high current drive capability on port pins specified
 * by mask parameters.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param HighDriveDisableMask Mask of pins with high drive to be disabled. Use
 *        constants from group "List of pins offering high drive capability".
 *        This parameter is 32 bits wide.
 * @param HighDriveEnableMask Mask of pins with high drive to be enabled. Use
 *        constants from group "List of pins offering high drive capability". This
 *        parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_HDRVE.
 * @par Example:
 *      @code
 *      PORT_PDD_EnableHighDriveMask(<peripheral>_BASE_PTR, PORT_PDD_PTB5,
 *      PORT_PDD_PTB5);
 *      @endcode
 */
  #define PORT_PDD_EnableHighDriveMask(PeripheralBase, HighDriveDisableMask, HighDriveEnableMask) ( \
      PORT_HDRVE_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(PORT_HDRVE_REG(PeripheralBase) & (uint32)(~(uint32)(HighDriveDisableMask)))) | ( \
        (uint32)(HighDriveEnableMask))) \
    )
#else /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) */
/**
 * @brief Enables/Disables high current drive capability on port pins specified
 * by mask parameters.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param HighDriveDisableMask Mask of pins with high drive to be disabled. Use
 *        constants from group "List of pins offering high drive capability".
 *        This parameter is 32 bits wide.
 * @param HighDriveEnableMask Mask of pins with high drive to be enabled. Use
 *        constants from group "List of pins offering high drive capability". This
 *        parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_HDRVE.
 * @par Example:
 *      @code
 *      PORT_PDD_EnableHighDriveMask(<peripheral>_BASE_PTR, PORT_PDD_PTB4,
 *      PORT_PDD_PTB4);
 *      @endcode
 */
  #define PORT_PDD_EnableHighDriveMask(PeripheralBase, HighDriveDisableMask, HighDriveEnableMask) ( \
      PORT_HDRVE_REG(PeripheralBase) = \
       (uint32)(( \
        (uint32)(PORT_HDRVE_REG(PeripheralBase) & (uint32)(~(uint32)(HighDriveDisableMask)))) | ( \
        (uint32)(HighDriveEnableMask))) \
    )
#endif /* (defined(MCU_MKE02Z2)) || (defined(MCU_MKE02Z4)) || (defined(MCU_MKE04Z1284)) || (defined(MCU_MKE06Z4)) || (defined(MCU_SKEAZ1284)) || (defined(MCU_SKEAZN642)) */

/* ----------------------------------------------------------------------------
   -- WriteHighDriveEnableReg
   ---------------------------------------------------------------------------- */

/**
 * @brief Writes high drive enable register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Parameter specifying mask of the new high drive enable setting
 *        for associated pins. Pins supporting high drive capability are defined
 *        by High drive pin list. This parameter is a 32-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_HDRVE.
 * @par Example:
 *      @code
 *      PORT_PDD_WriteHighDriveEnableReg(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
#define PORT_PDD_WriteHighDriveEnableReg(PeripheralBase, Value) ( \
    PORT_HDRVE_REG(PeripheralBase) = \
     (uint32)(Value) \
  )

/* ----------------------------------------------------------------------------
   -- ReadHighDriveEnableReg
   ---------------------------------------------------------------------------- */

/**
 * @brief Reads high drive enable configuration of the associated pins. Pins
 * supporting high drive capability are defined by High drive pin list.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORT_HDRVE.
 * @par Example:
 *      @code
 *      uint32 result =
 *      PORT_PDD_ReadHighDriveEnableReg(<peripheral>_BASE_PTR);
 *      @endcode
 */
#define PORT_PDD_ReadHighDriveEnableReg(PeripheralBase) ( \
    PORT_HDRVE_REG(PeripheralBase) \
  )

/* ----------------------------------------------------------------------------
   -- GetFilter0
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets filter 0 configuration for module input pins.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Module Module. Use constants from group "Modules offering input pin
 *        filtering capability". This parameter is 5 bits wide.
 * @return Use constants from group "Filter selection" for processing return
 *         value. The value is cast to "uint8".
 * @remarks The macro accesses the following registers: PORT_IOFLT0.
 * @par Example:
 *      @code
 *      uint8 result = PORT_PDD_GetFilter0(<peripheral>_BASE_PTR,
 *      PORT_PDD_PTA);
 *      @endcode
 */
#define PORT_PDD_GetFilter0(PeripheralBase, Module) ( \
    (uint8)(( \
     (uint8)(PORT_IOFLT0_REG(PeripheralBase) >> (uint8)(Module))) & ( \
     (uint8)0x3U)) \
  )

/* ----------------------------------------------------------------------------
   -- GetFilter1
   ---------------------------------------------------------------------------- */

/**
 * @brief Gets filter 1 configuration for module input pins.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Module Module. Use constants from group "Modules offering input pin
 *        filtering capability". This parameter is 5 bits wide.
 * @return Use constants from group "Filter selection" for processing return
 *         value. The value is cast to "uint8".
 * @remarks The macro accesses the following registers: PORT_IOFLT1.
 * @par Example:
 *      @code
 *      uint8 result = PORT_PDD_GetFilter1(<peripheral>_BASE_PTR,
 *      PORT_PDD_PTA);
 *      @endcode
 */
#define PORT_PDD_GetFilter1(PeripheralBase, Module) ( \
    (uint8)(( \
     (uint8)(PORT_IOFLT1_REG(PeripheralBase) >> (uint8)(Module))) & ( \
     (uint8)0x3U)) \
  )

/* ----------------------------------------------------------------------------
   -- SetFilter0
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets filter 0 for module input pins.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Module Module to be configured. Use constants from group "Modules
 *        offering input pin filtering capability". This parameter is 5 bits wide.
 * @param Filter Selected filter. Use constants from group "Filter selection".
 *        This parameter is 2 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT0.
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilter0(<peripheral>_BASE_PTR, PORT_PDD_PTA,
 *      PORT_PDD_NO_FILTER);
 *      @endcode
 */
#define PORT_PDD_SetFilter0(PeripheralBase, Module, Filter) ( \
    PORT_IOFLT0_REG(PeripheralBase) = \
     (uint32)(( \
      (uint32)(( \
       PORT_IOFLT0_REG(PeripheralBase)) & ( \
       (uint32)(~(uint32)((uint32)0x3U << (uint8)(Module)))))) | ( \
      (uint32)((uint32)(Filter) << (uint8)(Module)))) \
  )

/* ----------------------------------------------------------------------------
   -- SetFilter1
   ---------------------------------------------------------------------------- */

/**
 * @brief Sets filter 1 for module input pins.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Module Module to be configured. Use constants from group "Modules
 *        offering input pin filtering capability". This parameter is 5 bits wide.
 * @param Filter Selected filter. Use constants from group "Filter selection".
 *        This parameter is 2 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT1.
 * @par Example:
 *      @code
 *      PORT_PDD_SetFilter1(<peripheral>_BASE_PTR, PORT_PDD_PTA,
 *      PORT_PDD_NO_FILTER);
 *      @endcode
 */
#define PORT_PDD_SetFilter1(PeripheralBase, Module, Filter) ( \
    PORT_IOFLT1_REG(PeripheralBase) = \
     (uint32)(( \
      (uint32)(( \
       PORT_IOFLT1_REG(PeripheralBase)) & ( \
       (uint32)(~(uint32)((uint32)0x3U << (uint8)(Module)))))) | ( \
      (uint32)((uint32)(Filter) << (uint8)(Module)))) \
  )

/* ----------------------------------------------------------------------------
   -- WritePortFilter0Reg
   ---------------------------------------------------------------------------- */

/**
 * @brief Writes port filter 0 register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Value to be written into IOFLT1 register. This parameter is a
 *        32-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT0.
 * @par Example:
 *      @code
 *      PORT_PDD_WritePortFilter0Reg(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
#define PORT_PDD_WritePortFilter0Reg(PeripheralBase, Value) ( \
    PORT_IOFLT0_REG(PeripheralBase) = \
     (uint32)(Value) \
  )

/* ----------------------------------------------------------------------------
   -- WritePortFilter1Reg
   ---------------------------------------------------------------------------- */

/**
 * @brief Writes port filter 1 register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Value to be written into IOFLT register. This parameter is a
 *        32-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_IOFLT1.
 * @par Example:
 *      @code
 *      PORT_PDD_WritePortFilter1Reg(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
#define PORT_PDD_WritePortFilter1Reg(PeripheralBase, Value) ( \
    PORT_IOFLT1_REG(PeripheralBase) = \
     (uint32)(Value) \
  )

/* ----------------------------------------------------------------------------
   -- ReadPortFilter0Reg
   ---------------------------------------------------------------------------- */

/**
 * @brief Reads port filter 0 register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORT_IOFLT0.
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_ReadPortFilter0Reg(<peripheral>_BASE_PTR);
 *      @endcode
 */
#define PORT_PDD_ReadPortFilter0Reg(PeripheralBase) ( \
    PORT_IOFLT0_REG(PeripheralBase) \
  )

/* ----------------------------------------------------------------------------
   -- ReadPortFilter1Reg
   ---------------------------------------------------------------------------- */

/**
 * @brief Reads port filter 1 register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORT_IOFLT1.
 * @par Example:
 *      @code
 *      uint32 result = PORT_PDD_ReadPortFilter1Reg(<peripheral>_BASE_PTR);
 *      @endcode
 */
#define PORT_PDD_ReadPortFilter1Reg(PeripheralBase) ( \
    PORT_IOFLT1_REG(PeripheralBase) \
  )

/* ----------------------------------------------------------------------------
   -- EnablePullupPort2Mask
   ---------------------------------------------------------------------------- */

/**
 * @brief Enables/Disables pullup resistors on port 2 pins specified by mask
 * parameters.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param PullupDisableMask Mask of high port pins with pullup to be disabled.
 *        Use constants from group "Pin masks". This parameter is 32 bits wide.
 * @param PullupEnableMask Mask of high port pins with pullup to be enabled. Use
 *        constants from group "Pin masks". This parameter is 32 bits wide.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUE2.
 * @par Example:
 *      @code
 *      PORT_PDD_EnablePullupPort2Mask(<peripheral>_BASE_PTR, PORT_PDD_PIN_0,
 *      PORT_PDD_PIN_0);
 *      @endcode
 */
#define PORT_PDD_EnablePullupPort2Mask(PeripheralBase, PullupDisableMask, PullupEnableMask) ( \
    PORT_PUE2_REG(PeripheralBase) = \
     (uint32)(( \
      (uint32)(PORT_PUE2_REG(PeripheralBase) & (uint32)(~(uint32)(PullupDisableMask)))) | ( \
      (uint32)(PullupEnableMask))) \
  )

/* ----------------------------------------------------------------------------
   -- WritePort2PullupEnableReg
   ---------------------------------------------------------------------------- */

/**
 * @brief Writes port 2 pullup enable high register.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @param Value Parameter specifying mask of the new pullup enable setting for
 *        high port pins. Bit #0 of the mask controls pullup setting of the high
 *        port pin #0, bit #31 controls setting of the pin #31. Bit value 0
 *        disables pullup for associated high port pin, bit value 1 enables pullup for
 *        associated high port pin. This parameter is a 32-bit value.
 * @return Returns a value of void type.
 * @remarks The macro accesses the following registers: PORT_PUE2.
 * @par Example:
 *      @code
 *      PORT_PDD_WritePort2PullupEnableReg(<peripheral>_BASE_PTR, 1);
 *      @endcode
 */
#define PORT_PDD_WritePort2PullupEnableReg(PeripheralBase, Value) ( \
    PORT_PUE2_REG(PeripheralBase) = \
     (uint32)(Value) \
  )

/* ----------------------------------------------------------------------------
   -- ReadPort2PullupEnableReg
   ---------------------------------------------------------------------------- */

/**
 * @brief Reads port 2 pullup enable configuration of the high port pins. Bit #0
 * of return value contains pullup setting of the high port pin #0, bit #31
 * contains setting of the pin #31.
 * @param PeripheralBase Pointer to a peripheral registers structure (peripheral
 *        base address). You can use the constant defined in the registers
 *        definition header file (<peripheral>_BASE_PTR) or the constant defined in
 *        the peripheral initialization component header file
 *        (<component_name>_DEVICE).
 * @return Returns a 32-bit value.
 * @remarks The macro accesses the following registers: PORT_PUE2.
 * @par Example:
 *      @code
 *      uint32 result =
 *      PORT_PDD_ReadPort2PullupEnableReg(<peripheral>_BASE_PTR);
 *      @endcode
 */
#define PORT_PDD_ReadPort2PullupEnableReg(PeripheralBase) ( \
    PORT_PUE2_REG(PeripheralBase) \
  )
#endif  /* #if defined(PORT_PDD_H_) */

/* PORT_PDD.h, eof. */
