text: /**
   * @file xmc_usic.h
   * @date 2020-12-05
   *
   * @cond
   *****************************************************************************
   * XMClib v2.2.0 - XMC Peripheral Driver Library
   *
   * Copyright (c) 2015-2020, Infineon Technologies AG
   * All rights reserved.
   *
   * Boost Software License - Version 1.0 - August 17th, 2003
   *
   * Permission is hereby granted, free of charge, to any person or organization
   * obtaining a copy of the software and accompanying documentation covered by
   * this license (the "Software") to use, reproduce, display, distribute,
   * execute, and transmit the Software, and to prepare derivative works of the
   * Software, and to permit third-parties to whom the Software is furnished to
   * do so, all subject to the following:
   *
   * The copyright notices in the Software and this entire statement, including
   * the above license grant, this restriction and the following disclaimer,
   * must be included in all copies of the Software, in whole or in part, and
   * all derivative works of the Software, unless such copies or derivative
   * works are solely in the form of machine-executable object code generated by
   * a source language processor.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
   * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
   * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
   * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
   * DEALINGS IN THE SOFTWARE.
   *
   * To improve the quality of the software, users are encouraged to share
   * modifications, enhancements or bug fixes with Infineon Technologies AG
   * at XMCSupport@infineon.com.
   *****************************************************************************
   *
   * Change History
   * --------------
   *
   * 2015-02-20:
   *     - Initial draft<br>
   *     - Documentation improved <br>
   *
   * 2015-05-08:
   *     - Added XMC_USIC_CH_SetInputTriggerCombinationMode() and XMC_USIC_CH_SetTransmitBufferStatus()  <br>
   *
   * 2015-06-20:
   *     - Removed version macros and declaration of GetDriverVersion API
   *
   * 2015-08-17:
   *     - Bug fixed in XMC_USIC_CH_SetTransmitBufferStatus API. OR operator removed.
   *
   * 2015-08-24:
   *     - Added APIs for enabling/disabling delay compensation XMC_USIC_CH_DisableDelayCompensation() and
   *       XMC_USIC_CH_DisableDelayCompensation()
   *
   * 2015-08-25:
   *     - Added APIs for defining if the data shift unit input is derived
   *       from the input data path DXn or from the selected protocol pre-processors: XMC_USIC_CH_ConnectInputDataShiftToPPP()
   *       and XMC_USIC_CH_ConnectInputDataShiftToDataInput()
   *
   * 2015-08-27:
   *     - Fixed bug in XMC_USIC_CH_BRG_CLOCK_SOURCE_DX1T value.
   *     - Added APIs for direct TBUF access: XMC_USIC_CH_WriteToTBUF() and XMC_USIC_CH_WriteToTBUFTCI()
   *     - Added APIs for external input for BRG configuration:XMC_USIC_CH_ConfigExternalInputSignalToBRG() and XMC_USIC_CH_SetBRGInputClockSource()
   *
   * 2015-08-28:
   *     - Added API for enabling the transfer trigger unit to set bit TCSR.TE if the trigger signal DX2T becomes active. Feature used for RS-232
   *       Clear to Send (CTS) signal: XMC_USIC_CH_EnableTBUFDataValidTrigger() and XMC_USIC_CH_DisableTBUFDataValidTrigger().
   *
   * 2016-03-09:
   *     - Optimization of write only registers
   *
   * 2016-04-10:
   *     - Added an API to put the data into FIFO when hardware port control is enabled: XMC_USIC_CH_TXFIFO_PutDataHPCMode() <br>
   *
   * 2017-02-10:
   *     - Added XMC_USIC_CH_SetShiftDirection() to allow selection of shift direction of the data words for transmision and reception
   *     - Added XMC_USIC_CH_GetCaptureTimerValue() and XMC_USIC_CH_SetFractionalDivider()
   *
   * 2017-09-08:
   *     - Fixed value of macro XMC_USIC_CH_SHIFT_DIRECTION_MSB_FIRST used in XMC_USIC_CH_SetShiftDirection()
   *
   * 2018-09-29:
   *     - Added XMC_USIC_CH_SetBaudrateEx which uses the integer divider instead of the fractional divider <br>
   *
   * 2019-05-07:
   *     - Added XMC_USIC_CH_GetBaudrate(), XMC_USIC_CH_GetSCLKFrequency() and XMC_USIC_CH_GetMCLKFrequency()
   *
   * 2019-07-01:
   *     - Changed XMC_USIC_CH_SetBaudrateEx() input parameter types
   *
   * 2019-09-30:
   *     - Added XMC_USIC_CH_InvalidateReadData(), XMC_USIC_CH_EnableWordLengthControl() and XMC_USIC_CH_DisableWordLengthControl()
   *
   * 2019-12-05:
   *     - Added XMC_USIC_CH_TXFIFO_PutDataEx()
   *
   * 2020-04-30:
   *     - Added XMC_USIC_CH_TXFIFO_SetTriggerLimit() and XMC_USIC_CH_RXFIFO_SetTriggerLimit()
   *
   * 2020-12-05:
   *     - Added XMC_USIC_CH_BRG_CLOCK_SOURCE_DX1S to XMC_USIC_CH_BRG_CLOCK_SOURCE_t
   *     - Added XMC_USIC_CH_BRG_CTQSEL_t
   *     - Added XMC_USIC_CH_SetBaudrateDivider()
   * 
   * @endcond
   *
   */
  
  #ifndef XMC_USIC_H
  #define XMC_USIC_H
  /*******************************************************************************
   * HEADER FILES
   *******************************************************************************/
  
  #include "xmc_common.h"
  
  /**
   * @addtogroup XMClib XMC Peripheral Library
   * @{
   */
  
  /**
   * @addtogroup USIC
   * @brief Universal Serial Interface Channel(USIC) driver for serial communication.
   *
   * The Universal Serial Interface Channel(USIC) module is a flexible interface module
   * covering several serial communication protocols. A USIC module contains two
   * independent communication channels named USICx_CH0 and USICx_CH1, with x
   * being the number of the USIC module. The user can program, during run-time, which protocol will be handled
   * by each communication channel and which pins are used.
   * The driver provides APIs, configuration structures and enumerations to configure common features of multiple serial
   * communication protocols.
   *
   * USIC driver features:
   * -# Allows configuration of FIFO for transmit and receive functions.
   * -# Provides a structure type XMC_USIC_CH_t to represent the USIC channel registers in a programmer
   friendly format.
   * -# Allows configuration of automatic update for frame length, word length, slave select or slave address.
   * -# Allows transmission of data to FIFO using XMC_USIC_CH_TXFIFO_PutData() and XMC_USIC_CH_TXFIFO_PutDataFLEMode()
   * -# Allows reading of received data in FIFO using XMC_USIC_CH_RXFIFO_GetData()
   * -# Allows configuration of baudrate using XMC_USIC_CH_SetBaudrate()
   * -# Provides API to trigger interrupts using XMC_USIC_CH_TriggerServiceRequest()
   * @{
   */
  
  /*******************************************************************************
   * MACROS
   *******************************************************************************/
  
  #define XMC_USIC0 ((XMC_USIC_t *)USIC0_BASE)			/**< USIC0 module base address */
  #define XMC_USIC0_CH0 ((XMC_USIC_CH_t *)USIC0_CH0_BASE)	/**< USIC0 channel 0 base address */
  #define XMC_USIC0_CH1 ((XMC_USIC_CH_t *)USIC0_CH1_BASE)	/**< USIC0 channel 1 base address */
  
  #if defined(USIC1)
  #define XMC_USIC1 ((XMC_USIC_t *)USIC1_BASE)			/**< USIC1 module base address */
  #define XMC_USIC1_CH0 ((XMC_USIC_CH_t *)USIC1_CH0_BASE)	/**< USIC1 channel 0 base address */
  #define XMC_USIC1_CH1 ((XMC_USIC_CH_t *)USIC1_CH1_BASE)	/**< USIC1 channel 1 base address */
  #endif
  
  #if defined(USIC2)
  #define XMC_USIC2 ((XMC_USIC_t *)USIC2_BASE)			/**< USIC2 module base address */
  #define XMC_USIC2_CH0 ((XMC_USIC_CH_t *)USIC2_CH0_BASE)	/**< USIC2 channel 0 base address */
  #define XMC_USIC2_CH1 ((XMC_USIC_CH_t *)USIC2_CH1_BASE)	/**< USIC2 channel 1 base address */
  #endif
  
  #define USIC_CH_DXCR_DSEL_Msk  USIC_CH_DX0CR_DSEL_Msk   /**< Common mask for DSEL bitfield mask in DXnCR register */
  #define USIC_CH_DXCR_DSEL_Pos  USIC_CH_DX0CR_DSEL_Pos   /**< Common mask for DSEL bitfield position in DXnCR register */
  #define USIC_CH_DXCR_SFSEL_Pos USIC_CH_DX0CR_SFSEL_Pos  /**< Common mask for SFSEL bitfield position in DXnCR register */
  #define USIC_CH_DXCR_SFSEL_Msk USIC_CH_DX0CR_SFSEL_Msk  /**< Common mask for SFSEL bitfield mask in DXnCR register */
  #define USIC_CH_DXCR_DPOL_Msk  USIC_CH_DX0CR_DPOL_Msk   /**< Common mask for DPOL bitfield mask in DXnCR register */
  #define USIC_CH_DXCR_DFEN_Msk  USIC_CH_DX0CR_DFEN_Msk   /**< Common mask for DFEN bitfield mask in DXnCR register */
  #define USIC_CH_DXCR_DSEN_Msk  USIC_CH_DX0CR_DSEN_Msk   /**< Common mask for DSEN bitfield mask in DXnCR register */
  #define USIC_CH_DXCR_CM_Pos    USIC_CH_DX0CR_CM_Pos     /**< Common mask for CM bitfield position in DXnCR register */
  #define USIC_CH_DXCR_CM_Msk    USIC_CH_DX0CR_CM_Msk     /**< Common mask for CM bitfield mask in DXnCR register */
  #define USIC_CH_DXCR_INSW_Msk  USIC_CH_DX0CR_INSW_Msk   /**< Common mask for INSW bitfield mask in DXnCR register */
  #define USIC_CH_DXCR_INSW_pos  USIC_CH_DX0CR_INSW_Pos   /**< Common mask for INSW bitfield position in DXnCR register */
  
  #if UC_FAMILY == XMC1
  #include "xmc1_usic_map.h"
  #endif
  
  #if UC_FAMILY == XMC4
  #include "xmc4_usic_map.h"
  #endif
  
  /*******************************************************************************
   * ENUMS
   *******************************************************************************/
  
  /**
   * USIC channel driver status
   */
  typedef enum XMC_USIC_CH_STATUS
  {
    XMC_USIC_CH_STATUS_OK,    /**< USIC driver status : OK */
    XMC_USIC_CH_STATUS_ERROR, /**< USIC driver status : ERROR */
    XMC_USIC_CH_STATUS_BUSY   /**< USIC driver status : BUSY */
  } XMC_USIC_CH_STATUS_t;
  
  /**
  * USIC channel kernel mode
  */
  typedef enum XMC_USIC_CH_KERNEL_MODE
  {
    XMC_USIC_CH_KERNEL_MODE_RUN_0  = 0x0UL,  /**< Run mode 0 (transmission and reception possible)*/
    XMC_USIC_CH_KERNEL_MODE_RUN_1  = 0x1UL << USIC_CH_KSCFG_NOMCFG_Pos,  /**< Run mode 1 (transmission and reception possible)*/
    XMC_USIC_CH_KERNEL_MODE_STOP_0 = 0x2UL << USIC_CH_KSCFG_NOMCFG_Pos,  /**< Stop mode 0 (no transmission, but reception possible)*/
    XMC_USIC_CH_KERNEL_MODE_STOP_1 = 0x3UL << USIC_CH_KSCFG_NOMCFG_Pos   /**< Stop mode 1 (both transmission and reception not possible)*/
  } XMC_USIC_CH_KERNEL_MODE_t;
  
  /**
   * USIC channel operating mode
   */
  typedef enum XMC_USIC_CH_OPERATING_MODE
  {
    XMC_USIC_CH_OPERATING_MODE_IDLE = 0x0UL, /**< USIC channel idle */
    XMC_USIC_CH_OPERATING_MODE_SPI  = 0x1UL << USIC_CH_CCR_MODE_Pos, /**< SPI mode */
    XMC_USIC_CH_OPERATING_MODE_UART = 0x2UL << USIC_CH_CCR_MODE_Pos, /**< UART mode */
    XMC_USIC_CH_OPERATING_MODE_I2S  = 0x3UL << USIC_CH_CCR_MODE_Pos, /**< I2S mode */
    XMC_USIC_CH_OPERATING_MODE_I2C  = 0x4UL << USIC_CH_CCR_MODE_Pos  /**< I2C mode */
  } XMC_USIC_CH_OPERATING_MODE_t;
  
  /**
   * USIC channel inputs
   */
  typedef enum XMC_USIC_CH_INPUT
  {
    XMC_USIC_CH_INPUT_DX0, /**< DX0 input */
    XMC_USIC_CH_INPUT_DX1, /**< DX1 input */
    XMC_USIC_CH_INPUT_DX2, /**< DX2 input */
    XMC_USIC_CH_INPUT_DX3, /**< DX3 input */
    XMC_USIC_CH_INPUT_DX4, /**< DX4 input */
    XMC_USIC_CH_INPUT_DX5  /**< DX5 input */
  } XMC_USIC_CH_INPUT_t;
  
  /**
   * USIC channel input source sampling frequency
   */
  typedef enum XMC_USIC_CH_INPUT_SAMPLING_FREQ
  {
    XMC_USIC_CH_INPUT_SAMPLING_FREQ_FPERIPH            = 0x0UL, /**< Use fperiph frequency for input source sampling*/
    XMC_USIC_CH_INPUT_SAMPLING_FREQ_FRACTIONAL_DIVIDER = 0x1UL << USIC_CH_DXCR_SFSEL_Pos  /**< Use fFD(fractional divider) frequency for input source sampling*/
  } XMC_USIC_CH_INPUT_SAMPLING_FREQ_t;
  
  /**
   * USIC channel input combination mode
   */
  typedef enum XMC_USIC_CH_INPUT_COMBINATION_MODE
  {
    XMC_USIC_CH_INPUT_COMBINATION_MODE_TRIGGER_DISABLED = 0x0UL, /**< The trigger activation is disabled.*/
    XMC_USIC_CH_INPUT_COMBINATION_MODE_RISING_EDGE      = 0x1UL, /**< A rising edge activates DXnT*/
    XMC_USIC_CH_INPUT_COMBINATION_MODE_FALLING_EDGE     = 0x2UL, /**< A falling edge activates DXnT*/
    XMC_USIC_CH_INPUT_COMBINATION_MODE_BOTH_EDGES       = 0x3UL, /**< Both edges activate DXnT*/
  } XMC_USIC_CH_INPUT_COMBINATION_MODE_t;
  
  /**
   * USIC channel data transmission start modes.
   * Data shifted out of the transmit pin depends on the value configured for the
   * TDEN bitfield of the TCSR register. Following enum values are used for configuring
   * the TCSR->TDEN bitfield.
   */
  typedef enum XMC_USIC_CH_START_TRANSMISION_MODE
  {
    XMC_USIC_CH_START_TRANSMISION_DISABLED      = 0x0U, /**< Passive data level is sent out on transmission. */
    XMC_USIC_CH_START_TRANSMISION_ON_TDV        = 0x1UL << USIC_CH_TCSR_TDEN_Pos, /**< Transmission of the data word in TBUF can be started if TDV = 1 */
    XMC_USIC_CH_START_TRANSMISION_ON_TDV_DX2S_0 = 0x2UL << USIC_CH_TCSR_TDEN_Pos, /**< Transmission of the data word in TBUF can be started if TDV = 1 while DX2S_0 */
    XMC_USIC_CH_START_TRANSMISION_ON_TDV_DX2S_1 = 0x3UL << USIC_CH_TCSR_TDEN_Pos  /**< Transmission of the data word in TBUF can be started if TDV = 1 while DX2S_1 */
  } XMC_USIC_CH_START_TRANSMISION_MODE_t;
  
  /**
   * USIC channel interrupt node pointers
   */
  typedef enum XMC_USIC_CH_INTERRUPT_NODE_POINTER
  {
    XMC_USIC_CH_INTERRUPT_NODE_POINTER_TRANSMIT_SHIFT      = USIC_CH_INPR_TSINP_Pos, /**< Node pointer for transmit shift interrupt */
    XMC_USIC_CH_INTERRUPT_NODE_POINTER_TRANSMIT_BUFFER     = USIC_CH_INPR_TBINP_Pos, /**< Node pointer for transmit buffer interrupt */
    XMC_USIC_CH_INTERRUPT_NODE_POINTER_RECEIVE             = USIC_CH_INPR_RINP_Pos,  /**< Node pointer for receive interrupt */
    XMC_USIC_CH_INTERRUPT_NODE_POINTER_ALTERNATE_RECEIVE   = USIC_CH_INPR_AINP_Pos,  /**< Node pointer for alternate receive interrupt */
    XMC_USIC_CH_INTERRUPT_NODE_POINTER_PROTOCOL            = USIC_CH_INPR_PINP_Pos   /**< Node pointer for protocol related interrupts */
  } XMC_USIC_CH_INTERRUPT_NODE_POINTER_t;
  
  /**
   * USIC channel events
   */
  typedef enum XMC_USIC_CH_EVENT
  {
    XMC_USIC_CH_EVENT_RECEIVE_START       = USIC_CH_CCR_RSIEN_Msk, /**< Receive start event */
    XMC_USIC_CH_EVENT_DATA_LOST           = USIC_CH_CCR_DLIEN_Msk, /**< Data lost event */
    XMC_USIC_CH_EVENT_TRANSMIT_SHIFT      = USIC_CH_CCR_TSIEN_Msk, /**< Transmit shift event */
    XMC_USIC_CH_EVENT_TRANSMIT_BUFFER     = USIC_CH_CCR_TBIEN_Msk, /**< Transmit buffer event */
    XMC_USIC_CH_EVENT_STANDARD_RECEIVE    = USIC_CH_CCR_RIEN_Msk,  /**< Receive event */
    XMC_USIC_CH_EVENT_ALTERNATIVE_RECEIVE = USIC_CH_CCR_AIEN_Msk,  /**< Alternate receive event */
    XMC_USIC_CH_EVENT_BAUD_RATE_GENERATOR = USIC_CH_CCR_BRGIEN_Msk /**< Baudrate generator event */
  } XMC_USIC_CH_EVENT_t;
  
  /**
  * USIC channel parity mode
  */
  typedef enum XMC_USIC_CH_PARITY_MODE
  {
    XMC_USIC_CH_PARITY_MODE_NONE     = 0x0UL,  /**< Disable parity mode */
    XMC_USIC_CH_PARITY_MODE_EVEN     = 0x2UL << USIC_CH_CCR_PM_Pos,  /**< Enable even parity mode */
    XMC_USIC_CH_PARITY_MODE_ODD      = 0x3UL << USIC_CH_CCR_PM_Pos   /**< Enable odd parity mode */
  } XMC_USIC_CH_PARITY_MODE_t;
  
  /**
  * USIC channel data output mode
  */
  typedef enum XMC_USIC_CH_DATA_OUTPUT_MODE
  {
    XMC_USIC_CH_DATA_OUTPUT_MODE_NORMAL   = 0x0UL,  /**< Data output normal mode */
    XMC_USIC_CH_DATA_OUTPUT_MODE_INVERTED = 0x1UL << USIC_CH_SCTR_DOCFG_Pos   /**< Data output inverted mode */
  } XMC_USIC_CH_DATA_OUTPUT_MODE_t;
  
  /**
  * USIC channel data transmit buffer status
  */
  typedef enum XMC_USIC_CH_TBUF_STATUS
  {
    XMC_USIC_CH_TBUF_STATUS_IDLE = 0x0UL,                 /**< Transfer buffer is currently idle*/
    XMC_USIC_CH_TBUF_STATUS_BUSY = USIC_CH_TCSR_TDV_Msk   /**< Transfer buffer is currently busy*/
  } XMC_USIC_CH_TBUF_STATUS_t;
  
  
  
  /**
  * USIC channel data transmit buffer status modification
  */
  typedef enum XMC_USIC_CH_TBUF_STATUS_SET
  {
    XMC_USIC_CH_TBUF_STATUS_SET_BUSY   = 0x1UL, /**< Set Transfer buffer status to busy*/
    XMC_USIC_CH_TBUF_STATUS_SET_IDLE   = 0x2UL  /**< Set Transfer buffer status to idle*/
  } XMC_USIC_CH_TBUF_STATUS_SET_t;
  
  /**
  * USIC channel receive buffer status
  */
  typedef enum XMC_USIC_CH_RBUF_STATUS
  {
    XMC_USIC_CH_RBUF_STATUS_DATA_VALID0 = USIC_CH_RBUFSR_RDV0_Msk, /**< RBUF0 data has not yet been read out*/
    XMC_USIC_CH_RBUF_STATUS_DATA_VALID1 = USIC_CH_RBUFSR_RDV1_Msk  /**< RBUF1 data has not yet been read out*/
  } XMC_USIC_CH_RBUF_STATUS_t;
  
  /**
   * USIC channel output signal passive data level
  */
  typedef enum XMC_USCI_CH_PASSIVE_DATA_LEVEL
  {
    XMC_USIC_CH_PASSIVE_DATA_LEVEL0 = 0x0UL, /**< Passive level(idle mode signal level) 0 */
    XMC_USIC_CH_PASSIVE_DATA_LEVEL1 = 0x1UL << USIC_CH_SCTR_PDL_Pos  /**< Passive level(idle mode signal level) 1 */
  } XMC_USIC_CH_PASSIVE_DATA_LEVEL_t;
  
  /**
  * USIC channel receive FIFO size
  */
  typedef enum XMC_USIC_CH_FIFO_SIZE
  {
    XMC_USIC_CH_FIFO_DISABLED     = 0x0U,  /**< FIFO Disabled */
    XMC_USIC_CH_FIFO_SIZE_2WORDS  = 0x1U,  /**< FIFO size: 2 words */
    XMC_USIC_CH_FIFO_SIZE_4WORDS  = 0x2U,  /**< FIFO size: 4 words */
    XMC_USIC_CH_FIFO_SIZE_8WORDS  = 0x3U,  /**< FIFO size: 8 words */
    XMC_USIC_CH_FIFO_SIZE_16WORDS = 0x4U,  /**< FIFO size: 16 words */
    XMC_USIC_CH_FIFO_SIZE_32WORDS = 0x5U,  /**< FIFO size: 32 words */
    XMC_USIC_CH_FIFO_SIZE_64WORDS = 0x6U   /**< FIFO size: 64 words */
  } XMC_USIC_CH_FIFO_SIZE_t;
  
  /**
  * USIC channel transmit FIFO interrupt node pointers
  */
  typedef enum XMC_USIC_CH_TXFIFO_INTERRUPT_NODE_POINTER
  {
    XMC_USIC_CH_TXFIFO_INTERRUPT_NODE_POINTER_STANDARD  = USIC_CH_TBCTR_STBINP_Pos,  /**< Node pointer for FIFO standard transmit interrupt */
    XMC_USIC_CH_TXFIFO_INTERRUPT_NODE_POINTER_ALTERNATE = USIC_CH_TBCTR_ATBINP_Pos   /**< Node pointer for transmit FIFO error interrupt */
  } XMC_USIC_CH_TXFIFO_INTERRUPT_NODE_POINTER_t;
  
  /**
  * USIC channel transmit FIFO event configuration
  */
  typedef enum XMC_USIC_CH_TXFIFO_EVENT_CONF
  {
    XMC_USIC_CH_TXFIFO_EVENT_CONF_STANDARD  = USIC_CH_TBCTR_STBIEN_Msk,   /**< Enable FIFO standard transmit interrupt */
    XMC_USIC_CH_TXFIFO_EVENT_CONF_ERROR     = (int32_t)USIC_CH_TBCTR_TBERIEN_Msk  /**< Enable transmit FIFO error interrupt */
  } XMC_USIC_CH_TXFIFO_EVENT_CONF_t;
  
  /**
  * USIC channel transmit FIFO status
  */
  typedef enum XMC_USIC_CH_TXFIFO_EVENT
  {
    XMC_USIC_CH_TXFIFO_EVENT_STANDARD = USIC_CH_TRBSR_STBI_Msk,    /**< Transmit FIFO status: Standard event */
    XMC_USIC_CH_TXFIFO_EVENT_ERROR    = USIC_CH_TRBSR_TBERI_Msk    /**< Transmit FIFO status: Error event */
  } XMC_USIC_CH_TXFIFO_EVENT_t;
  
  /**
  * USIC channel receive FIFO interrupt node pointers
  */
  typedef enum XMC_USIC_CH_RXFIFO_INTERRUPT_NODE_POINTER
  {
    XMC_USIC_CH_RXFIFO_INTERRUPT_NODE_POINTER_STANDARD  = USIC_CH_RBCTR_SRBINP_Pos, /**< Node pointer for FIFO standard receive interrupt */
    XMC_USIC_CH_RXFIFO_INTERRUPT_NODE_POINTER_ALTERNATE = USIC_CH_RBCTR_ARBINP_Pos  /**< Node pointer for FIFO alternative receive interrupt */
  } XMC_USIC_CH_RXFIFO_INTERRUPT_NODE_POINTER_t;
  
  /**
  * USIC channel receive FIFO event configuration
  */
  typedef enum XMC_USIC_CH_RXFIFO_EVENT_CONF
  {
    XMC_USIC_CH_RXFIFO_EVENT_CONF_STANDARD  = USIC_CH_RBCTR_SRBIEN_Msk,   /**< Enable FIFO standard receive interrupt */
    XMC_USIC_CH_RXFIFO_EVENT_CONF_ERROR     = (int32_t)USIC_CH_RBCTR_RBERIEN_Msk,  /**< Enable receive FIFO error interrupt */
    XMC_USIC_CH_RXFIFO_EVENT_CONF_ALTERNATE = USIC_CH_RBCTR_ARBIEN_Msk   /**< Enable FIFO alternative receive interrupt */
  } XMC_USIC_CH_RXFIFO_EVENT_CONF_t;
  
  /**
  * USIC channel receive FIFO status
  */
  typedef enum XMC_USIC_CH_RXFIFO_EVENT
  {
    XMC_USIC_CH_RXFIFO_EVENT_STANDARD  = USIC_CH_TRBSR_SRBI_Msk,   /**< Receive FIFO status: Standard event */
    XMC_USIC_CH_RXFIFO_EVENT_ERROR     = USIC_CH_TRBSR_RBERI_Msk,  /**< Receive FIFO status: Error event */
    XMC_USIC_CH_RXFIFO_EVENT_ALTERNATE = USIC_CH_TRBSR_ARBI_Msk    /**< Receive FIFO status: Alternative event */
  } XMC_USIC_CH_RXFIFO_EVENT_t;
  
  /**
  * USIC channel baudrate generator clock source
  */
  typedef enum XMC_USIC_CH_BRG_CLOCK_SOURCE
  {
    XMC_USIC_CH_BRG_CLOCK_SOURCE_DIVIDER = 0x0UL, /**< Baudrate generator clock source : Source divider. (Internal clock source)*/
    XMC_USIC_CH_BRG_CLOCK_SOURCE_DX1T    = 0x2UL << USIC_CH_BRG_CLKSEL_Pos,  /**< Baudrate generator clock source : DX1T. (External clock source) */
    XMC_USIC_CH_BRG_CLOCK_SOURCE_DX1S    = 0x3UL << USIC_CH_BRG_CLKSEL_Pos  /**< Baudrate generator clock source : DX1S. (External clock source) */
  } XMC_USIC_CH_BRG_CLOCK_SOURCE_t;
  
  /**
  * USIC channel input selection for CTQ
  */
  typedef enum XMC_USIC_CH_BRG_CTQSEL
  {
    XMC_USIC_CH_BRG_CTQSEL_PDIV = 0x0UL, /**< fCTQIN = fPDIV */
    XMC_USIC_CH_BRG_CTQSEL_PPP  = 0x1UL << USIC_CH_BRG_CTQSEL_Pos,  /**< fCTQIN = fPPP */
    XMC_USIC_CH_BRG_CTQSEL_SCLK = 0x2UL << USIC_CH_BRG_CTQSEL_Pos,  /**< fCTQIN = fSCLK */
    XMC_USIC_CH_BRG_CTQSEL_MCLK = 0x3UL << USIC_CH_BRG_CTQSEL_Pos  /**< fCTQIN = fMCLK */
  } XMC_USIC_CH_BRG_CTQSEL_t;
  
  
  /**
  * USIC channel baudrate generator divider mode
  */
  typedef enum XMC_USIC_CH_BRG_CLOCK_DIVIDER_MODE
  {
    XMC_USIC_CH_BRG_CLOCK_DIVIDER_MODE_DISABLED   = 0x0UL, /**< Baudrate generator clock divider: Disabled */
    XMC_USIC_CH_BRG_CLOCK_DIVIDER_MODE_NORMAL     = 0x1UL << USIC_CH_FDR_DM_Pos, /**< Baudrate generator clock divider: Normal mode */
    XMC_USIC_CH_BRG_CLOCK_DIVIDER_MODE_FRACTIONAL = 0x2UL << USIC_CH_FDR_DM_Pos  /**< Baudrate generator clock divider: Fractional mode */
  } XMC_USIC_CH_BRG_CLOCK_DIVIDER_MODE_t;
  
  /**
  * USIC channel baudrate generator master clock passive level
  */
  typedef enum XMC_USIC_CH_BRG_MASTER_CLOCK_PASSIVE_LEVEL
  {
    XMC_USIC_CH_BRG_MASTER_CLOCK_PASSIVE_LEVEL_0 = 0x0UL, /**< Baudrate generator master clock passive level(idle mode signal level) 0*/
    XMC_USIC_CH_BRG_MASTER_CLOCK_PASSIVE_LEVEL_1 = 0x1UL << USIC_CH_BRG_MCLKCFG_Pos  /**< Baudrate generator master clock passive level((idle mode signal level)) 1*/
  } XMC_USIC_CH_BRG_MASTER_CLOCK_PASSIVE_LEVEL_t;
  
  /**
  * USIC channel baudrate generator shift clock passive level
  */
  typedef enum XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL
  {
    XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_0_DELAY_DISABLED = 0x0UL, /**< Shift clock passive level 0, delay disabled */
    XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_1_DELAY_DISABLED = 0x1UL << USIC_CH_BRG_SCLKCFG_Pos, /**< Shift clock passive level 1, delay disabled */
    XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_0_DELAY_ENABLED  = (int32_t)(0x2UL << USIC_CH_BRG_SCLKCFG_Pos), /**< Shift clock passive level 0, delay enabled */
    XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_1_DELAY_ENABLED  = (int32_t)(0x3UL << USIC_CH_BRG_SCLKCFG_Pos)  /**< Shift clock passive level 1, delay enabled */
  } XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_t;
  
  /**
  * USIC channel baudrate generator shift clock output
  */
  typedef enum XMC_USIC_CH_BRG_SHIFT_CLOCK_OUTPUT
  {
    XMC_USIC_CH_BRG_SHIFT_CLOCK_OUTPUT_SCLK = 0x0UL, /**< Baudrate generator shift clock output: SCL.(Internally generated shift clock)*/
    XMC_USIC_CH_BRG_SHIFT_CLOCK_OUTPUT_DX1 = 0x1UL << USIC_CH_BRG_SCLKOSEL_Pos   /**< Baudrate generator shift clock output: DX1. (External input shift clock)*/
  } XMC_USIC_CH_BRG_SHIFT_CLOCK_OUTPUT_t;
  
  /**
  * USIC channel shift direction.
  * Defines the shift direction of the data words for transmission and reception
  */
  typedef enum XMC_USIC_CH_SHIFT_DIRECTION
  {
    XMC_USIC_CH_SHIFT_DIRECTION_LSB_FIRST = 0x0UL, /**< Shift LSB first. The first data bit of a data word is located at bit position 0. */
    XMC_USIC_CH_SHIFT_DIRECTION_MSB_FIRST = 0x1UL << USIC_CH_SCTR_SDIR_Pos /**< Shift MSB first. The first data bit of a data word is located at the bit position given by the configured word length. */
  } XMC_USIC_CH_SHIFT_DIRECTION_t;
  
  
  /*******************************************************************************
   * DATA STRUCTURES
   *******************************************************************************/
  
  /*Anonymous structure/union guard start*/
  #if defined(__CC_ARM)
  #pragma push
  #pragma anon_unions
  #elif defined(__TASKING__)
  #pragma warning 586
  #endif
  
  /**
   * USIC module structure
   */
  typedef USIC_GLOBAL_TypeDef XMC_USIC_t;
  
  /**
   * USIC channel structure.<br> The members of the structure are same as in the device header file,
   * except for some registers.
   * DX0CR, DX1CR, DX2CR, DX3CR, DX4CR and DX5CR are replaced with the array DXCR[6].
   * TBUF0 to TBUF31 are replaced with TBUF[32].
   * IN0 to IN31 are replaced with IN[32].
   */
  typedef struct XMC_USIC_CH
  {
    __I  uint32_t  RESERVED0;
    __I  uint32_t  CCFG;			/**< Channel configuration register*/
    __I  uint32_t  RESERVED1;
    __IO uint32_t  KSCFG;			/**< Kernel state configuration register*/
    __IO uint32_t  FDR;			/**< Fractional divider configuration register*/
    __IO uint32_t  BRG;			/**< Baud rate generator register*/
    __IO uint32_t  INPR;			/**< Interrupt node pointer register*/
    __IO uint32_t  DXCR[6];		/**< Input control registers DX0 to DX5.*/
    __IO uint32_t  SCTR;			/**< Shift control register*/
    __IO uint32_t  TCSR;
  
    union
    {
      __IO uint32_t  PCR_IICMode;	/**< I2C protocol configuration register*/
      __IO uint32_t  PCR_IISMode; /**< I2S protocol configuration register*/
      __IO uint32_t  PCR_SSCMode;	/**< SPI protocol configuration register*/
      __IO uint32_t  PCR;			/**< Protocol configuration register*/
      __IO uint32_t  PCR_ASCMode;	/**< UART protocol configuration register*/
    };
    __IO uint32_t  CCR;			/**< Channel control register*/
    __IO uint32_t  CMTR;			/**< Capture mode timer register*/
  
    union
    {
      __IO uint32_t  PSR_IICMode;	/**< I2C protocol status register*/
      __IO uint32_t  PSR_IISMode;	/**< I2S protocol status register*/
      __IO uint32_t  PSR_SSCMode;	/**< SPI protocol status register*/
      __IO uint32_t  PSR;			/**< Protocol status register*/
      __IO uint32_t  PSR_ASCMode;	/**< UART protocol status register*/
    };
    __O  uint32_t  PSCR;			/**< Protocol status clear register*/
    __I  uint32_t  RBUFSR;		/**< Receive buffer status register*/
    __I  uint32_t  RBUF;			/**< Receive buffer register*/
    __I  uint32_t  RBUFD;			/**< Debug mode receive buffer register*/
    __I  uint32_t  RBUF0;			/**< Receive buffer 0*/
    __I  uint32_t  RBUF1;			/**< Receive buffer 1*/
    __I  uint32_t  RBUF01SR;		/**< Receive buffer status register*/
    __O  uint32_t  FMR;			/**< Flag modification register*/
    __I  uint32_t  RESERVED2[5];
    __IO uint32_t  TBUF[32];		/**< Tranmsit buffer registers*/
    __IO uint32_t  BYP;			/**< FIFO bypass register*/
    __IO uint32_t  BYPCR;			/**< FIFO bypass control register*/
    __IO uint32_t  TBCTR;			/**< Transmit FIFO control register*/
    __IO uint32_t  RBCTR;			/**< Receive FIFO control register*/
    __I  uint32_t  TRBPTR;		/**< Transmit/recive buffer pointer register*/
    __IO uint32_t  TRBSR;			/**< Transmit/receive buffer status register*/
    __O  uint32_t  TRBSCR;		/**< Transmit/receive buffer status clear register*/
    __I  uint32_t  OUTR;			/**< Receive FIFO output register*/
    __I  uint32_t  OUTDR;			/**< Receive FIFO debug output register*/
    __I  uint32_t  RESERVED3[23];
    __O  uint32_t  IN[32];		/**< Transmit FIFO input register*/
  } XMC_USIC_CH_t;
  
  
  /*Anonymous structure/union guard end*/
  #if defined(__CC_ARM)
  #pragma pop
  #elif defined(__TASKING__)
  #pragma warning restore
  #endif
  
  /*******************************************************************************
   * API PROTOTYPES
   ******************************************************************************/
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  __STATIC_INLINE bool XMC_USIC_IsModuleValid(const XMC_USIC_t *const module)
  {
    bool tmp;
  
    tmp = (module == XMC_USIC0);
  #if defined(XMC_USIC1)
    tmp = tmp || (module == XMC_USIC1);
  #endif
  #if defined(XMC_USIC2)
    tmp = tmp || (module == XMC_USIC2);
  #endif
  
    return tmp;
  }
  
  __STATIC_INLINE bool XMC_USIC_IsChannelValid(const XMC_USIC_CH_t *const channel)
  {
    bool tmp;
  
    tmp = ((channel == XMC_USIC0_CH0) || (channel == XMC_USIC0_CH1));
  #if defined(XMC_USIC1)
    tmp = tmp || ((channel == XMC_USIC1_CH0) || (channel == XMC_USIC1_CH1));
  #endif
  #if defined(XMC_USIC2)
    tmp = tmp || ((channel == XMC_USIC2_CH0) || (channel == XMC_USIC2_CH1));
  #endif
  
    return tmp;
  }
  
  /* Common APIs */
  
  /**
   * @param  usic Pointer to USIC module handler of type @ref XMC_USIC_t.\n
   * 				\b Range: @ref XMC_USIC0 to @ref XMC_USIC2 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables the USIC module.\n\n
   * Enables the clock for the USIC module by following the
   * clock enabling sequence for the selected device.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_Enable(), XMC_USIC_Disable() \n\n\n
   */
  void XMC_USIC_Enable(XMC_USIC_t *const usic);
  /**
   * @param  usic Pointer to USIC module handler of type @ref XMC_USIC_t.\n
   * 				\b Range: @ref XMC_USIC0 to @ref XMC_USIC2 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables the USIC module.\n\n
   * Disables the clock for the USIC module by following the clock
   * disabling sequence for the selected device.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_Disable(), XMC_USIC_Enable() \n\n\n
   */
  void XMC_USIC_Disable(XMC_USIC_t *const usic);
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables the USIC channel. \n\n
   * USIC channel is enabled by setting the module enable bit in KSCFG register bitfield MODEN.
   * On enabling, the channel is set to idle mode.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_Disable(), XMC_USIC_Enable() \n\n\n
   */
  void XMC_USIC_CH_Enable(XMC_USIC_CH_t *const channel);
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables the USIC channel.\n\n
   * USIC channel is disabled by setting the module enable bit(MDEN) to 0 in the register KSCFG.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_Enable(), XMC_USIC_Disable() \n\n\n
   */
  void XMC_USIC_CH_Disable(XMC_USIC_CH_t *const channel);
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  rate Desired baudrate. \b Range: minimum value = 100, maximum value depends on the peripheral clock frequency  \n
   * 				and \a oversampling. Maximum baudrate can be derived using the formula: (fperiph * 1023)/(1024 * oversampling)
   * @param  oversampling Required oversampling. The value indicates the number of time quanta for one symbol of data. \n
   * 						This can be related to the number of samples for each logic state of the data signal. \n
   * 						\b Range: 1 to 32. Value should be chosen based on the protocol used.
   * @return Status indicating the baudrate configuration.\n
   * 			\b Range: @ref XMC_USIC_CH_STATUS_OK if baudrate is successfully configured,
   * 					  @ref XMC_USIC_CH_STATUS_ERROR if desired baudrate or oversampling is invalid.
   *
   * \par<b>Description</b><br>
   * Configures the baudrate of the USIC channel. \n\n
   * Baudrate is configured by considering the peripheral frequency and the desired baudrate.
   * Optimum values of FDR->STEP and BRG->PDIV are calulated and used for generating the desired
   * baudrate.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetStartTransmisionMode(), XMC_USIC_CH_SetInputSource() \n\n\n
   */
  XMC_USIC_CH_STATUS_t XMC_USIC_CH_SetBaudrate(XMC_USIC_CH_t *const channel, uint32_t rate, uint32_t oversampling);
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   *           \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  rate Desired baudrate. Only integer dividers of peripheral clock are achievable
   * @param  oversampling Required oversampling. The value indicates the number of time quanta for one symbol of data. \n
   *            This can be related to the number of samples for each logic state of the data signal. \n
   *            \b Range: 1 to 32. Value should be chosen based on the protocol used.
   * @return Status indicating the baudrate configuration.\n
   *      \b Range: @ref XMC_USIC_CH_STATUS_OK if baudrate is successfully configured,
   *            @ref XMC_USIC_CH_STATUS_ERROR if desired baudrate or oversampling is invalid.
   *
   * \par<b>Description</b><br>
   * Configures the baudrate of the USIC channel using the integer divider which restrics the achievable baudrate but decreses jitter. \n\n
   * Baudrate is configured by considering the peripheral frequency and the desired baudrate.
   * Optimum values of FDR->STEP and BRG->PDIV are calulated and used for generating the desired
   * baudrate.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetStartTransmisionMode(), XMC_USIC_CH_SetInputSource() \n\n\n
   */
  XMC_USIC_CH_STATUS_t XMC_USIC_CH_SetBaudrateEx(XMC_USIC_CH_t *const channel, int32_t rate, int32_t oversampling);
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   *           \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  clksel Baudrate generator clock source.
   * @param  pppen Enable 2:1 Divider for fPPP.
   * @param  pdiv Divider Factor to generate fPDIV = fPPP / (pDIV + 1)
   * @param  ctqsel Input selection for CTQ.
   * @param  pctq Pre-Divider for Time Quanta Counter. fCTQIN / (PCQT + 1)
   * @param  dctq Denominator for Time Quanta Counter. fTQ / (DCTQ + 1)
   * @return None
   *
   * \par<b>Description</b><br>
   * Configures the baudrate generator of the USIC channel.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetFractionalDivider() \n\n\n
   */
  void XMC_USIC_CH_SetBaudrateDivider(XMC_USIC_CH_t *const channel, 
                                      XMC_USIC_CH_BRG_CLOCK_SOURCE_t clksel,
                                      bool pppen,
                                      uint32_t pdiv,
                                      XMC_USIC_CH_BRG_CTQSEL_t ctqsel,
                                      uint32_t pctq,
                                      uint32_t dctq);
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   *           \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return baudrate currently used by USIC channel for .\n
   *
   * \par<b>Description</b><br>
   * Calculates the current used baudrate (fCTQIN) of a USIC channel. \n\n
   * @image html ../images/usic_brg.png
   * @image latex ../images/usic_brg.png
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetBaudrateMode(), XMC_USIC_CH_SetBaudrate(), XMC_USIC_CH_SetBaudrateEx() \n\n\n
   */
  uint32_t XMC_USIC_CH_GetBaudrate(XMC_USIC_CH_t *const channel);
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   *           \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return baudrate currently used by USIC channel.\n
   *
   * \par<b>Description</b><br>
   * Calculates the current used SCLK frequency of a USIC channel. \n\n
   * @image html ../images/usic_brg.png
   * @image latex ../images/usic_brg.png
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetBaudrateMode(), XMC_USIC_CH_SetBaudrate(), XMC_USIC_CH_SetBaudrateEx() \n\n\n
   */
  uint32_t XMC_USIC_CH_GetSCLKFrequency(XMC_USIC_CH_t *const channel);
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   *           \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return baudrate currently used by USIC channel.\n
   *
   * \par<b>Description</b><br>
   * Calculates the current used MCLK frequency of a USIC channel. \n\n
   * @image html ../images/usic_brg.png
   * @image latex ../images/usic_brg.png
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetBaudrateMode(), XMC_USIC_CH_SetBaudrate(), XMC_USIC_CH_SetBaudrateEx() \n\n\n
   */
  uint32_t XMC_USIC_CH_GetMCLKFrequency(XMC_USIC_CH_t *const channel);
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  pdiv Desired divider for the external frequency input. \b Range: minimum value = 1, maximum value = 1024 \n
   * @param  oversampling Required oversampling. The value indicates the number of time quanta for one symbol of data. \n
   * 						This can be related to the number of samples for each logic state of the data signal. \n
   * 						\b Range: 1 to 32. Value should be chosen based on the protocol used.
   * @param  combination_mode Selects which edge of the synchronized(and optionally filtered) signal DXnS actives the trigger
   *                          output DXnT of the input stage.
   *
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables the external frequency input for the Baudrate Generator and configures the divider, oversampling and
   * the combination mode of the USIC channel. \n\n
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetBRGInputClockSource(), XMC_USIC_CH_SetInputTriggerCombinationMode() \n\n\n
   */
  void XMC_USIC_CH_ConfigExternalInputSignalToBRG(XMC_USIC_CH_t *const channel,
      const uint16_t pdiv,
      const uint32_t oversampling,
      const XMC_USIC_CH_INPUT_COMBINATION_MODE_t combination_mode);
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @param  source Input source select for the input stage. The table below maps the enum value with the input channel.
   * <table><tr><td>0</td><td>DXnA</td></tr><tr><td>1</td><td>DXnB</td></tr><tr><td>2</td><td>DXnC</td></tr><tr><td>3</td><td>DXnD</td></tr>
   * <tr><td>4</td><td>DXnE</td></tr><tr><td>5</td><td>DXnF</td></tr><tr><td>6</td><td>DXnG</td></tr><tr><td>7</td><td>Always 1</td>
   * </tr></table>
   * @return None
   *
   * \par<b>Description</b><br>
   * Selects the data source for USIC input stage.\n\n
   * Selects the input data signal source among DXnA, DXnB.. DXnG for the input stage. The API can be used for all the input stages
   * like DX0CR, DX1CR etc.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableInputInversion(), XMC_USIC_CH_EnableInputDigitalFilter(), XMC_USIC_CH_EnableInputSync(),
   * XMC_USIC_CH_SetInputSamplingFreq()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetInputSource(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_INPUT_t input, const uint8_t source)
  {
    channel->DXCR[input] = (uint32_t)((channel->DXCR[input] & (uint32_t)(~USIC_CH_DXCR_DSEL_Msk)) |
                                      ((uint32_t)source << USIC_CH_DXCR_DSEL_Pos));
  }
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @return None
   *
   * \par<b>Description</b><br>
   * The input of the data shift unit is controlled by the
   * protocol pre-processor. \n\n
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_ConnectInputDataShiftToDataInput()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_ConnectInputDataShiftToPPP(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_INPUT_t input)
  {
    channel->DXCR[input] &= (uint32_t)~USIC_CH_DXCR_INSW_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @return None
   *
   * \par<b>Description</b><br>
   * The input of the data shift unit is connected to
   * the selected data input line. \n\n
   *
   * This setting is used
   * if the signals are directly derived from an input
   * pin without treatment by the protocol preprocessor.
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_ConnectInputDataShiftToPPP()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_ConnectInputDataShiftToDataInput(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_INPUT_t input)
  {
    channel->DXCR[input] |= USIC_CH_DXCR_INSW_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables input inversion for USIC channel input data signal. \n\n
   *
   * Polarity of the input source can be changed to provide inverted data input.
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_DisableInputInversion()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_EnableInputInversion(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_INPUT_t input)
  {
    channel->DXCR[input] |= USIC_CH_DXCR_DPOL_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables input inversion for USIC channel. \n\n
   *
   * Resets the input data polarity for the USIC channel input data signal.
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableInputInversion()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_DisableInputInversion(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_INPUT_t input)
  {
    channel->DXCR[input] &= (uint32_t)~USIC_CH_DXCR_DPOL_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables delay compensation. \n\n
   *
   * Delay compensation can be applied to the receive path.
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_DisableDelayCompensation()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_EnableDelayCompensation(XMC_USIC_CH_t *const channel)
  {
    channel->DXCR[1U] |= USIC_CH_DX1CR_DCEN_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables delay compensation.. \n\n
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableDelayCompensation()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_DisableDelayCompensation(XMC_USIC_CH_t *const channel)
  {
    channel->DXCR[1U] &= (uint32_t)~USIC_CH_DX1CR_DCEN_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables the input digital filter for USIC channel input data signal. \n\n
   * Input data signal from the selected multiplexer will be digitally filtered.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_DisableInputDigitalFilter()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_EnableInputDigitalFilter(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_INPUT_t input)
  {
    channel->DXCR[input] |= (uint32_t)USIC_CH_DXCR_DFEN_Msk;
  }
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables the input digital filter for USIC channel input data signal. \n\n
   * Input data signal from the selected multiplexer will not be digitally filtered.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableInputDigitalFilter()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_DisableInputDigitalFilter(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_INPUT_t input)
  {
    channel->DXCR[input] &= (uint32_t)~USIC_CH_DXCR_DFEN_Msk;
  }
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables input synchronization for the USIC channel input data signal. \n\n
   * Input data signal from the selected multiplexer will be synchronized with fPERIPH.
   * A noisy signal can be synchronized and filtered by enabling the digital filter.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_DisableInputSync(), XMC_USIC_CH_EnableInputDigitalFilter()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_EnableInputSync(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_INPUT_t input)
  {
    channel->DXCR[input] |= (uint32_t)USIC_CH_DXCR_DSEN_Msk;
  }
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables input synchronization for the USIC channel input data signal. \n\n
   * Input data signal from the selected multiplexer will not be synchronized.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableInputSync(), XMC_USIC_CH_DisableInputDigitalFilter() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_DisableInputSync(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_INPUT_t input)
  {
    channel->DXCR[input] &= (uint32_t)~USIC_CH_DXCR_DSEN_Msk;
  }
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support..
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @param  sampling_freq Sampling frequency value of type \a XMC_USIC_CH_INPUT_SAMPLING_FREQ_t.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets sampling frequency for USIC channel input data signal. \n\n
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetInputSource(), XMC_USIC_CH_EnableInputSync(), XMC_USIC_CH_EnableInputDigitalFilter() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetInputSamplingFreq(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_INPUT_t input,
      const XMC_USIC_CH_INPUT_SAMPLING_FREQ_t sampling_freq)
  {
    channel->DXCR[input] = (uint32_t)(channel->DXCR[input] & (~USIC_CH_DXCR_SFSEL_Msk)) |
                           ((uint32_t)sampling_freq);
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support..
   * @param  input USIC channel input stage of type @ref XMC_USIC_CH_INPUT_t. \n
   * 				 \b Range: @ref XMC_USIC_CH_INPUT_DX0 to @ref XMC_USIC_CH_INPUT_DX5
   * @param  combination_mode Combination mode value of type \a XMC_USIC_CH_INPUT_COMBINATION_MODE_t.
   * @return None
   *
   * \par<b>Description</b><br>
   * Selects which edge of the synchronized signal DXnS activates the trigger output DXnT of the input stage. \n\n
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetInputSource(), XMC_USIC_CH_EnableInputSync(), XMC_USIC_CH_EnableInputDigitalFilter() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetInputTriggerCombinationMode(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_INPUT_t input,
      const XMC_USIC_CH_INPUT_COMBINATION_MODE_t combination_mode)
  {
    channel->DXCR[input] = (uint32_t)(channel->DXCR[input] & (~USIC_CH_DXCR_CM_Msk)) |
                           ((uint32_t)combination_mode << USIC_CH_DXCR_CM_Pos);
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  clock_source clock source for the BRG.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets the clock source for the BRG. \n\n
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetInputTriggerCombinationMode(), XMC_USIC_CH_SetExternalClockBRGDivider()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetBRGInputClockSource(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_BRG_CLOCK_SOURCE_t clock_source)
  {
    channel->BRG = (uint32_t)(channel->BRG & (~USIC_CH_BRG_CLKSEL_Msk)) | (uint32_t)(clock_source);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param data Data to be transmitted. \n
   *           \b Range: 16bit unsigned data. minimum= 0, maximum= 65535
   * @return None
   *
   * \par<b>Description</b><br>
   * Writes data into the transmit buffer. \n\n
   * The data provided is placed in TBUF[0U].
   *
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_WriteToTBUFTCI() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_WriteToTBUF(XMC_USIC_CH_t *const channel, const uint16_t data)
  {
    channel->TBUF[0U] = data;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param data Data to be transmitted.
   * @param transmit_control_information transmit control information to be configured while transmitting the data. \n
   * 			\b Range: minimum= 0, maximum= 31.
   * @return None
   *
   * \par<b>Description</b><br>
   * Writes data to the transmit buffer in a control mode. \n\n
   * When the respective control mode is enabled , this API can be used.
   *
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_WriteToTBUF() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_WriteToTBUFTCI(XMC_USIC_CH_t *const channel,
      const uint16_t data,
      const uint32_t transmit_control_information)
  {
    channel->TBUF[transmit_control_information] = data;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  word_length Number of bits to be configured for a data word. \n
   * 					   \b Range: minimum= 1, maximum= 16. \n
   * 					   e.g: For word length of 8, \a word_length should be provided as 8.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets the data word length in number of bits. \n\n
   * Sets the number of bits to represent a data word. Frame length should be a multiple of word length.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetFrameLength()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetWordLength(XMC_USIC_CH_t *const channel, const uint8_t word_length)
  {
    channel->SCTR = (uint32_t)(channel->SCTR & (~USIC_CH_SCTR_WLE_Msk)) |
                    (uint32_t)(((uint32_t)word_length - 1UL)  << USIC_CH_SCTR_WLE_Pos);
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   *           \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  word_length Number of bits to be configured for a data word. \n
   *             \b Range: minimum= 1, maximum= 16. \n
   *             e.g: For word length of 8, \a word_length should be provided as 8.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets the data word length in number of bits. \n\n
   * Sets the number of bits to represent a data word. Frame length should be a multiple of word length.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetFrameLength()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetShiftDirection(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_SHIFT_DIRECTION_t shift_direction)
  {
    channel->SCTR = (uint32_t)(channel->SCTR & (~USIC_CH_SCTR_SDIR_Msk)) | (uint32_t)shift_direction;
  }
  
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   *           \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Captured counter value
   *
   *
   * \par<b>Description</b><br>
   * The value of the counter is captured if one of the trigger signals DX0T or DX1T are activated by the corresponding input stage.
   */
  __STATIC_INLINE uint32_t XMC_USIC_CH_GetCaptureTimerValue(const XMC_USIC_CH_t *const channel)
  {
    return channel->CMTR;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   *           \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  mode divider mode ::XMC_USIC_CH_BRG_CLOCK_DIVIDER_MODE_t \n
   * @param  step divider \n
   *             \b XMC_USIC_CH_BRG_CLOCK_DIVIDER_MODE_NORMAL resulting divider = 1023 - step \n
   *             \b XMC_USIC_CH_BRG_CLOCK_DIVIDER_MODE_FRACTIONAL resulting divider = 1023 / step \n
   *
   * @return None
   *
   * \par<b>Description</b><br>
   * The fractional divider generates its output frequency fFD by either dividing the input frequency fPERIPH by an integer factor n or by multiplication of n/1024.
   *
   */
  __STATIC_INLINE void XMC_USIC_CH_SetFractionalDivider(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_BRG_CLOCK_DIVIDER_MODE_t mode, const uint16_t step)
  {
    channel->FDR = mode | step;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  frame_length Number of bits in a frame. \n
   * 						\b Range: minimum= 1, maximum= 0x3f. The maximum value for fixed frame size is 0x3f. \n
   * 						e.g: For a frame length of 16, \a frame_length should be provided as 16.
   * @return None
   *
   * \par<b>Description</b><br>
   * Define the data frame length.\n\n
   * Set the number of bits to be serially transmitted in a frame.
   * The frame length should be multiples of word length. If the value is set to 0x40, the frame length
   * has to be controlled explicitly.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetWordLength(), XMC_USIC_CH_EnableFrameLengthControl() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetFrameLength(XMC_USIC_CH_t *const channel, const uint8_t frame_length)
  {
    channel->SCTR = (uint32_t)(channel->SCTR & (~USIC_CH_SCTR_FLE_Msk)) |
                    (((uint32_t)frame_length - 0x1U)  << USIC_CH_SCTR_FLE_Pos);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param event Bit mask of the channel events to be enabled. Use @ref XMC_USIC_CH_EVENT_t for the bit masks. \n
   * 				\b Range: @ref XMC_USIC_CH_EVENT_RECEIVE_START, @ref XMC_USIC_CH_EVENT_DATA_LOST etc. Multiple events
   * 				can be combined using \a OR operation.
   * @return None
   *
   * \par<b>Description</b><br>
   * Enable the channel interrupt events.\n\n
   * Common channel events related to serial communication can be configured using this API.
   * Multiple events can be combined using the bitwise OR operation and configured in one function call.
   * XMC_USIC_CH_EVENT_t enumerates multiple protocol event bitmasks. These enumerations can be used as input to the API.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_DisableEvent(), XMC_USIC_CH_SetInterruptNodePointer() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_EnableEvent(XMC_USIC_CH_t *const channel, const uint32_t event)
  {
    channel->CCR |= event;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				  \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param event Bit mask of the channel events to be disabled. Use @ref XMC_USIC_CH_EVENT_t for the bit masks. \n
   * 				\b Range: @ref XMC_USIC_CH_EVENT_RECEIVE_START, @ref XMC_USIC_CH_EVENT_DATA_LOST etc. Multiple events
   * 				can be combined using \a OR operation.
   * @return None
   *
   * \par<b>Description</b><br>
   * Disable the channel interrupt events. \n\n
   * Multiple events can be combined using the bitwise OR operation and configured in one function call.
   * XMC_USIC_CH_EVENT_t enumerates multiple protocol event bitmasks. These enumerations can be used as input to the API.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableEvent(), XMC_USIC_CH_SetInterruptNodePointer() \n\n\n
  */
  __STATIC_INLINE void XMC_USIC_CH_DisableEvent(XMC_USIC_CH_t *const channel, const uint32_t event)
  {
    channel->CCR &= (uint32_t)~event;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				  \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  interrupt_node Interrupt node pointer to be configured. \n
   * 						  \b Range: @ref XMC_USIC_CH_INTERRUPT_NODE_POINTER_TRANSMIT_SHIFT,
   * 						  			@ref XMC_USIC_CH_INTERRUPT_NODE_POINTER_TRANSMIT_BUFFER etc.
   * @param service_request Service request number.\n
   * 						  \b Range: 0 to 5.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets the interrupt node for USIC channel events. \n\n
   * For an event to generate interrupt, node pointer should be configured with service request(SR0, SR1..SR5).
   * The NVIC node gets linked to the interrupt event by doing so.<br>
   * Note: NVIC node should be separately enabled to generate the interrupt.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableEvent() \n\n\n
   */
  void XMC_USIC_CH_SetInterruptNodePointer(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_INTERRUPT_NODE_POINTER_t interrupt_node,
      const uint32_t service_request);
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Stataus @ref XMC_USIC_CH_TBUF_STATUS_IDLE if transmit buffer is free,
   *                 @ref XMC_USIC_CH_TBUF_STATUS_BUSY if transmit buffer is busy.
   *
   * \par<b>Description</b><br>
   * Gets transmit buffer status. \n\n
   * Status indicates whether the transmit buffer is free, or busy transmitting data.
   * The status depends on the value of TDV flag in TCSR register.
   * This status can be used while transmitting data. Transmit data when the transmit buffer
   * status is @ref XMC_USIC_CH_TBUF_STATUS_IDLE.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetDataOutputMode() \n\n\n
   */
  __STATIC_INLINE XMC_USIC_CH_TBUF_STATUS_t XMC_USIC_CH_GetTransmitBufferStatus(XMC_USIC_CH_t *const channel)
  {
    return (XMC_USIC_CH_TBUF_STATUS_t)(channel->TCSR & USIC_CH_TCSR_TDV_Msk);
  }
  
  /**
   * @brief API to get receive buffer status
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Status of data validity check for RBUF0 and RBUF1. \n
   * 		   Returned value should be masked with RDV0 and RDV1 bits to know the status. \n
   * 		   \b Range: @ref XMC_USIC_CH_RBUF_STATUS_DATA_VALID0, @ref XMC_USIC_CH_RBUF_STATUS_DATA_VALID1.
   *
   * \par<b>Description</b><br>
   * Checks if RBUF0 and RBUF1 have valid unread data. \n\n
   * It checks the bits RDV0 and RDV1 of the RBUFSR register.
   * Returns the value of RBUFSR masked with bitmasks of RDV0 and RDV1.
   * It can be used to decide whether 2bytes has to be read from RBUF or 1 byte.
   * If both bitmasks XMC_USIC_CH_RBUF_STATUS_DATA_VALID0 and XMC_USIC_CH_RBUF_STATUS_DATA_VALID1
   * are set, then 2 bytes can be read from RBUF. If only either of them is set, then only one byte
   * can be read from RBUF.
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_GetTransmitBufferStatus() \n\n\n
   */
  __STATIC_INLINE uint32_t XMC_USIC_CH_GetReceiveBufferStatus(XMC_USIC_CH_t *const channel)
  {
    return ((uint32_t) (channel->RBUFSR & (USIC_CH_RBUFSR_RDV0_Msk | USIC_CH_RBUFSR_RDV1_Msk)));
  }
  
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  start_transmision_mode Transmission mode to be enabled. \n
   * 								\b Range: @ref XMC_USIC_CH_START_TRANSMISION_DISABLED,
   * 								@ref XMC_USIC_CH_START_TRANSMISION_ON_TDV, @ref XMC_USIC_CH_START_TRANSMISION_ON_TDV_DX2S_0,
   * 								@ref XMC_USIC_CH_START_TRANSMISION_ON_TDV_DX2S_1
   *
   * @return None
   *
   * \par<b>Description</b><br>
   * Configures data transmission. \n\n
   * The configuration affects the data shifted on the DOUT0 pin.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_GetTransmitBufferStatus(), XMC_USIC_CH_SetDataOutputMode() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetStartTransmisionMode(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_START_TRANSMISION_MODE_t start_transmision_mode)
  {
    channel->TCSR = (uint32_t)(channel->TCSR & (~USIC_CH_TCSR_TDEN_Msk)) | (uint32_t)start_transmision_mode;
  }
  
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  data_output_mode  Data output mode. \n
   * 			\b Range: @ref XMC_USIC_CH_DATA_OUTPUT_MODE_NORMAL, @ref XMC_USIC_CH_DATA_OUTPUT_MODE_INVERTED
   * @return None
   *
   * \par<b>Description</b><br>
   * Configures the mode for data output. \n\n
   * USIC channel can be configured to shift inverted data or direct data based on the input to the API.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetStartTransmisionMode() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetDataOutputMode(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_DATA_OUTPUT_MODE_t data_output_mode)
  {
    channel->SCTR = (uint32_t)(channel->SCTR & (~USIC_CH_SCTR_DOCFG_Msk)) | (uint32_t)data_output_mode;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables automatic update of frame length. \n\n
   * When the automatic update of frame length is enabled, frame length is configured based on the
   * index of the TBUF[]/IN[] register array. When the data is written to TBUF[x], frame length is configured
   * with the mask value of \a x at the last 5 bit positions. Same logic is applicable if data is written to
   * IN[x] register.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_DisableFrameLengthControl(), XMC_USIC_CH_TXFIFO_PutDataFLEMode() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_EnableFrameLengthControl(XMC_USIC_CH_t *const channel)
  {
    channel->TCSR = (uint32_t)(channel->TCSR & (~(USIC_CH_TCSR_WLEMD_Msk |
                               USIC_CH_TCSR_SELMD_Msk |
                               USIC_CH_TCSR_WAMD_Msk |
                               USIC_CH_TCSR_HPCMD_Msk))) |
                    (uint32_t)USIC_CH_TCSR_FLEMD_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables automatic update of word length. \n\n
   * When the automatic update of word length is enabled, word length is configured based on the
   * index of the TBUF[]/IN[] register array. When the data is written to TBUF[x], word length is configured
   * with the mask value of \a x at the last 5 bit positions. Same logic is applicable if data is written to
   * IN[x] register.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_DisableFrameLengthControl(), XMC_USIC_CH_TXFIFO_PutDataFLEMode() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_EnableWordLengthControl(XMC_USIC_CH_t *const channel)
  {
    channel->TCSR = (uint32_t)(channel->TCSR & (~(USIC_CH_TCSR_WLEMD_Msk |
                               USIC_CH_TCSR_SELMD_Msk |
                               USIC_CH_TCSR_WAMD_Msk |
                               USIC_CH_TCSR_HPCMD_Msk))) |
                    (uint32_t)USIC_CH_TCSR_WLEMD_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables automatic update of frame length. \n\n
   * When automatic update of frame length is disabled, frame length has to configured explicitly.
   * Frame length remains fixed until it is changed again.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableFrameLengthControl(), XMC_USIC_CH_SetFrameLength() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_DisableFrameLengthControl(XMC_USIC_CH_t *const channel)
  {
    channel->TCSR &= (uint32_t)~USIC_CH_TCSR_FLEMD_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables automatic update of word length. \n\n
   * When automatic update of word length is disabled, word length has to configured explicitly.
   * Word length remains fixed until it is changed again.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableFrameLengthControl(), XMC_USIC_CH_SetWordLength() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_DisableWordLengthControl(XMC_USIC_CH_t *const channel)
  {
    channel->TCSR &= (uint32_t)~USIC_CH_TCSR_WLEMD_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Bit TCSR.TE is set if DX2T becomes active while TDV = 1. \n\n
   * Enables the transfer trigger unit to set bit TCSR.TE if the trigger signal DX2T becomes active
   * for event driven transfer starts.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_DisableTBUFDataValidTrigger()\n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_EnableTBUFDataValidTrigger(XMC_USIC_CH_t *const channel)
  {
    channel->TCSR |= (uint32_t)USIC_CH_TCSR_TDVTR_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables the trigger of TDV depending on DX2T signal. \n\n
   * Bit TCSR.TE is permanently set.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableTBUFDataValidTrigger() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_DisableTBUFDataValidTrigger(XMC_USIC_CH_t *const channel)
  {
    channel->TCSR &= (uint32_t)~USIC_CH_TCSR_TDVTR_Msk;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  service_request_line service request number of the event to be triggered. \n
   * 			\b Range: 0 to 5.
   * @return None
   *
   * \par<b>Description</b><br>
   * Trigger a USIC interrupt service request.\n\n
   * When the USIC service request is triggered, the NVIC interrupt associated with it will be
   * generated if enabled.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_SetInterruptNodePointer() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TriggerServiceRequest(XMC_USIC_CH_t *const channel, const uint32_t service_request_line)
  {
    channel->FMR = (uint32_t)(USIC_CH_FMR_SIO0_Msk << service_request_line);
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  transmit_buffer_status clearing or setting the TDV flag. \n
   *
   * @return None
   *
   * \par<b>Description</b><br>
   * Modify TCSR.TDV and TCSR.TE to control the start of a data word transmission by software.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_GetTransmitBufferStatus() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetTransmitBufferStatus(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_TBUF_STATUS_SET_t transmit_buffer_status)
  {
    channel->FMR = (uint32_t)transmit_buffer_status;
  }
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   *
   * @return None
   *
   * \par<b>Description</b><br>
   * Modify TCSR.TDV and TCSR.TE to control the start of a data word transmission by software.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_GetTransmitBufferStatus() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_InvalidateReadData(XMC_USIC_CH_t *const channel)
  {
    channel->FMR = USIC_CH_FMR_CRDV0_Msk | USIC_CH_FMR_CRDV1_Msk;
  }
  
  
  /**
   * @param  channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  passive_level Value of passive level for the channel. \n
   * 			\b Range: @ref XMC_USIC_CH_PASSIVE_DATA_LEVEL0, @ref XMC_USIC_CH_PASSIVE_DATA_LEVEL1
   * @return None
   *
   * \par<b>Description</b><br>
   * Set the passive data level of the output signal. \n\n
   * When the USIC channel transmit stage is idle, the output signal level stays at the
   * configured passive level.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_GetTransmitBufferStatus(), XMC_USIC_CH_SetStartTransmisionMode() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetPassiveDataLevel(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_PASSIVE_DATA_LEVEL_t passive_level)
  {
    channel->SCTR &= (~USIC_CH_SCTR_PDL_Msk);
    channel->SCTR |= (uint32_t)passive_level;
  }
  
  /* TX FIFO APIs */
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param data_pointer Start position inside the FIFO buffer. \n
   * 		\b Range: 0 to 63.
   * @param size Required size of the transmit FIFO. \n
   * 		\b Range: @ref XMC_USIC_CH_FIFO_DISABLED, @ref XMC_USIC_CH_FIFO_SIZE_2WORDS.. @ref XMC_USIC_CH_FIFO_SIZE_64WORDS
   * @param limit Threshold of transmit FIFO filling level to be considered for generating events. \n
   * 		\b Range: 0 to \a size -1.
   * @return None
   *
   * \par<b>Description</b><br>
   * Initializes the transmit FIFO. \n\n
   * Transmit FIFO is a subset of a common FIFO sized 64 words. This FIFO is shared between 2 channels of the USIC module.
   * Each channel can share the FIFO for transmission and reception. \a data_pointer represents the start index in the common FIFO,
   * from where transmit data can be put, for the selected USIC channel. \a size represents the size of transmit FIFO as a multiple of
   * 2. Since the FIFO is shared between 2 USIC channels, FIFO size should be carefully selected. A FIFO standard transmit buffer
   * event is generated when the FIFO filling level falls below the \a limit value.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_EnableEvent(), XMC_USIC_CH_TXFIFO_SetInterruptNodePointer() \n\n\n
   */
  void XMC_USIC_CH_TXFIFO_Configure(XMC_USIC_CH_t *const channel,
                                    const uint32_t data_pointer,
                                    const XMC_USIC_CH_FIFO_SIZE_t size,
                                    const uint32_t limit);
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param size Required size of the transmit FIFO. \n
   * 		\b Range: @ref XMC_USIC_CH_FIFO_DISABLED, @ref XMC_USIC_CH_FIFO_SIZE_2WORDS.. @ref XMC_USIC_CH_FIFO_SIZE_64WORDS
   * @param limit Threshold for transmit FIFO filling level to be considered for generating events. \n
   * 		\b Range: 0 to \a size -1.
   * @return None
   *
   * \deprecated { Use XMC_USIC_CH_TXFIFO_SetSizeTriggerLimit() }
   *
   * \par<b>Description</b><br>
   * Sets the size and trigger limit for the transmit FIFO. \n\n
   * The API is not to be called for initializing the transmit FIFO. The API shall be used for the
   * runtime change of transmit FIFO trigger limit. FIFO start position will not be affected on execution.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_SetSizeTriggerLimit() \n\n\n
   */
  void XMC_USIC_CH_TXFIFO_SetSizeTriggerLimit(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_FIFO_SIZE_t size,
      const uint32_t limit);
  
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param limit Threshold for transmit FIFO filling level to be considered for generating events. \n
   * 		\b Range: 0 to \a fifo size -1.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets the trigger limit for the TX FIFO. \n\n
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_SetSizeTriggerLimit() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TXFIFO_SetTriggerLimit(XMC_USIC_CH_t *const channel,
      const uint32_t limit)
  {
    channel->TBCTR = (channel->TBCTR & (uint32_t)~USIC_CH_TBCTR_LIMIT_Msk) | ((limit << USIC_CH_TBCTR_LIMIT_Pos) & USIC_CH_TBCTR_LIMIT_Msk);
  }
  
  
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param event Events to be enabled. Multiple events can be bitwise OR combined. @ref XMC_USIC_CH_TXFIFO_EVENT_CONF_t \n
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables the interrupt events related to transmit FIFO. \n\n
   * Event bitmasks can be constructed using the enumeration @ref XMC_USIC_CH_TXFIFO_EVENT_CONF_t.
   * Multiple events can be enabled by providing multiple events in a single call. For providing
   * multiple events, combine the events using bitwise OR operation. Events are configured in the TBCTR register.<br>
   *
   * Note: API only enables the events. For interrupt generation, interrupt node must be configured and NVIC node
   * must be enabled.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_SetInterruptNodePointer() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TXFIFO_EnableEvent(XMC_USIC_CH_t *const channel, const uint32_t event)
  {
    channel->TBCTR |= event;
  }
  
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param event Events to be disabled. @ref XMC_USIC_CH_TXFIFO_EVENT_CONF_t \n
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables the interrupt events related to transmit FIFO. \n\n
   * By disabling the interrupt events, generation of interrupt is stopped. User can poll the event
   * flags from the status register using the API XMC_USIC_CH_TXFIFO_GetEvent().
   * Event bitmasks can be constructed using the enumeration @ref XMC_USIC_CH_TXFIFO_EVENT_CONF_t. For providing
   * multiple events, combine the events using bitwise OR operation.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_GetEvent(), XMC_USIC_CH_TXFIFO_EnableEvent() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TXFIFO_DisableEvent(XMC_USIC_CH_t *const channel, const uint32_t event)
  {
    channel->TBCTR &= (uint32_t)~event;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				      \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param interrupt_node Node pointer representing the transmit FIFO events. \n
   * 						  \b Range: @ref XMC_USIC_CH_TXFIFO_INTERRUPT_NODE_POINTER_STANDARD,
   * 						  			@ref XMC_USIC_CH_TXFIFO_INTERRUPT_NODE_POINTER_ALTERNATE
   * @param service_request The service request to be used for interrupt generation. \n
   * 						  \b Range: 0 to 5.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets an interrupt node for the transmit FIFO events.\n\n
   * A node pointer represents one or more interrupt events. Service request represents the interrupt node to be used
   * among the 6 interrupt nodes available for USIC module.
   * API configures the service request to be used for interrupt generation for the events selected.
   * A transmit FIFO event can generate an interrupt only if the interrupt node is configured for the event and
   * the interrupt generation is enabled for the event. For example, transmit FIFO standard transmit buffer
   * interrupt is generated if the interrupt node for the same is set and interrupt is enabled.<br>
   *
   * Note: NVIC node should be explicitly enabled for the interrupt generation.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_EnableEvent() \n\n\n
   */
  void XMC_USIC_CH_TXFIFO_SetInterruptNodePointer(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_TXFIFO_INTERRUPT_NODE_POINTER_t interrupt_node,
      const uint32_t service_request);
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param data Data to be transmitted. \n
   *           \b Range: 16bit unsigned data. minimum= 0, maximum= 65535
   * @return None
   *
   * \par<b>Description</b><br>
   * Writes data into the transmit FIFO. \n\n
   * The data provided is placed in the transmit FIFO.
   * The transmit FIFO should be configured before calling this API.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_EnableEvent() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TXFIFO_PutData(XMC_USIC_CH_t *const channel, const uint16_t data)
  {
    channel->IN[0] = data;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param data Data to be transmitted. \n
   *           \b Range: 16bit unsigned data. minimum= 0, maximum= 65535
   * @param loc Input location. \n
   * @return None
   *
   * \par<b>Description</b><br>
   * Transmit data can be loaded to TBUF by software by writing to the transmit buffer input
   * locations TBUFx (x = 00-31), consisting of 32 consecutive addresses. The data written
   * to one of these input locations is stored in the transmit buffer TBUF. Additionally, the
   * address of the written location is evaluated and can be used for additional control
   * purposes. This 5-bit wide information (named Transmit Control Information TCI) can be
   * used for different purposes in different protocols.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableWordLengthControl() \n
   * XMC_USIC_CH_EnableFrameLengthControl() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TXFIFO_PutDataEx(XMC_USIC_CH_t *const channel, const uint16_t data, uint8_t loc)
  {
    channel->IN[loc] = data;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param data Data to be transmitted.
   * @param frame_length Frame length to be configured while transmitting the data. \n
   * 			\b Range: minimum= 0, maximum= 31. e.g: For a frame length of 16, set \a frame_length as 15.
   * @return None
   *
   * \par<b>Description</b><br>
   * Writes data to the transmit FIFO in frame length control mode. \n\n
   * When frame length control is enabled for dynamic update of frame length, this API can be used.
   * \a frame_length represents the frame length to be updated by the peripheral.
   * \a frame_length is used as index for the IN[] register array.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_PutDataEx() \n
   * XMC_USIC_CH_EnableFrameLengthControl() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TXFIFO_PutDataFLEMode(XMC_USIC_CH_t *const channel,
      const uint16_t data,
      const uint32_t frame_length)
  {
    channel->IN[frame_length] = data;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param data Data to be transmitted.
   * @param frame_length Frame length to be configured while transmitting the data. \n
   * 			\b Range: minimum= 0, maximum= 31. e.g: For a frame length of 16, set \a frame_length as 15.
   * @return None
   *
   * \par<b>Description</b><br>
   * Writes data to the transmit FIFO in hardware port control mode. \n\n
   * When hardware port control is enabled for dynamic update of frame length, this API can be used.
   * \a frame_length represents the frame length to be updated by the peripheral.
   * \a frame_length is used as index for the IN[] register array.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableFrameLengthControl() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TXFIFO_PutDataHPCMode(XMC_USIC_CH_t *const channel,
      const uint16_t data,
      const uint32_t frame_length)
  {
    channel->IN[frame_length] = data;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Clears the contents of transmit FIFO. \n\n
   * Transmit FIFO contents will be cleared and the filling level will be reset to 0.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_GetLevel() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TXFIFO_Flush(XMC_USIC_CH_t *const channel)
  {
    channel->TRBSCR = (uint32_t)USIC_CH_TRBSCR_FLUSHTB_Msk;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Status \a true if transmit FIFO is full
   *              \a false if transmit FIFO is not full.
   *
   * \par<b>Description</b><br>
   * Checks if transmit FIFO is full. \n\n
   * When the transmit FIFO filling level reaches the configured size, FIFO full flag is set.
   * User should not write to the FIFO when the transmit FIFO is full.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_IsEmpty(), XMC_USIC_CH_TXFIFO_Flush() \n\n\n
   */
  __STATIC_INLINE bool XMC_USIC_CH_TXFIFO_IsFull(XMC_USIC_CH_t *const channel)
  {
    return (bool)(channel->TRBSR & USIC_CH_TRBSR_TFULL_Msk);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Status \a true if transmit FIFO is empty
   *              \a false if transmit FIFO has some data.
   *
   * \par<b>Description</b><br>
   * Checks if transmit FIFO is empty. \n\n
   * When the transmit FIFO is empty, data can be written to FIFO.
   * When the last written word to the transmit FIFO is transmitted out of the FIFO,
   * FIFO empty flag is set.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_Flush(), XMC_USIC_CH_TXFIFO_PutData() \n\n\n
   */
  __STATIC_INLINE bool XMC_USIC_CH_TXFIFO_IsEmpty(XMC_USIC_CH_t *const channel)
  {
    return (bool)(channel->TRBSR & USIC_CH_TRBSR_TEMPTY_Msk);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Transmit FIFO filling level. \n
   *           \b Range: minimum= 0(FIFO empty), maximum= transmit FIFO size.
   *
   * \par<b>Description</b><br>
   * Gets the transmit FIFO filling level. \n\n
   * For every word written to the FIFO, filling level is updated. The API gives the value
   * of this filling level.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_Flush(), XMC_USIC_CH_TXFIFO_PutData() \n\n\n
   */
  __STATIC_INLINE uint32_t XMC_USIC_CH_TXFIFO_GetLevel(XMC_USIC_CH_t *const channel)
  {
    return ((uint32_t)(channel->TRBSR & USIC_CH_TRBSR_TBFLVL_Msk) >> USIC_CH_TRBSR_TBFLVL_Pos);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Status of standard transmit and transmit buffer error events. @ref XMC_USIC_CH_TXFIFO_EVENT_t \n
   *
   * \par<b>Description</b><br>
   * Gets the transmit FIFO event status. \n\n
   * Gives the status of transmit FIFO standard transmit buffer event and transmit buffer error event.
   * The status bits are located at their bit positions in the TRBSR register in the returned value.
   * User can make use of the @ref XMC_USIC_CH_TXFIFO_EVENT_t enumeration for checking the status of return value.
   * The status can be found by using the bitwise AND operation on the returned value with the enumerated value.<br>
   *
   * Note: Event status flags should be cleared by the user explicitly.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_ClearEvent() \n\n\n
   */
  __STATIC_INLINE uint32_t XMC_USIC_CH_TXFIFO_GetEvent(XMC_USIC_CH_t *const channel)
  {
    return (uint32_t)((channel->TRBSR) & (USIC_CH_TRBSR_STBI_Msk |
                                          USIC_CH_TRBSR_TBERI_Msk));
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  event Transmit FIFO events to be cleared. \n
   * 			     \b Range: @ref XMC_USIC_CH_TXFIFO_EVENT_STANDARD, @ref XMC_USIC_CH_TXFIFO_EVENT_ERROR.
   * @return None
   *
   * \par<b>Description</b><br>
   * Clears the transmit FIFO event flags in the status register. \n\n
   * USIC channel peripheral does not clear the event flags after they are read.
   * This API clears the events provided in the \a mask value.
   * XMC_USIC_CH_TXFIFO_EVENT enumeration can be used as input. Multiple events
   * can be cleared by providing a mask value obtained by bitwise OR operation of
   * multiple event enumerations.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_GetEvent() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_TXFIFO_ClearEvent(XMC_USIC_CH_t *const channel,
      const uint32_t event)
  {
    channel->TRBSCR = event;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param data_pointer Start position inside the FIFO buffer. \n
   * 		\b Range: 0 to 63.
   * @param size Required size of the receive FIFO. \n
   * 		\b Range: @ref XMC_USIC_CH_FIFO_DISABLED, @ref XMC_USIC_CH_FIFO_SIZE_2WORDS.. @ref XMC_USIC_CH_FIFO_SIZE_64WORDS
   * @param limit Threshold of receive FIFO filling level to be considered for generating events. \n
   * 		\b Range: 0 to \a size -1.
   * @return None
   *
   * \par<b>Description</b><br>
   * Configures the receive FIFO. \n\n
   * Receive FIFO is the subset of a common FIFO sized 64 words. This FIFO is shared between 2 channels of the USIC module.
   * Each channel can share the FIFO for transmission and reception. \a data_pointer represents the start index in the common FIFO,
   * from where received data can be put. \a size represents the size of receive FIFO as a multiple of 2.
   * Since the FIFO is shared between 2 USIC channels, FIFO size should be carefully selected. A FIFO standard receive buffer
   * event or alternative receive buffer event is generated when the FIFO filling level exceeds the \a limit value.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_EnableEvent(), XMC_USIC_CH_RXFIFO_SetInterruptNodePointer() \n\n\n
  */
  void XMC_USIC_CH_RXFIFO_Configure(XMC_USIC_CH_t *const channel,
                                    const uint32_t data_pointer,
                                    const XMC_USIC_CH_FIFO_SIZE_t size,
                                    const uint32_t limit);
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param size Required size of the receive FIFO. \n
   * 		\b Range: @ref XMC_USIC_CH_FIFO_DISABLED, @ref XMC_USIC_CH_FIFO_SIZE_2WORDS.. @ref XMC_USIC_CH_FIFO_SIZE_64WORDS
   * @param limit Threshold for receive FIFO filling level to be considered for generating events. \n
   * 		\b Range: 0 to \a size -1.
   * @return None
   *
   * \deprecated { Use XMC_USIC_CH_RXFIFO_SetTriggerLimit() }
   *
   * \par<b>Description</b><br>
   * Sets the size and trigger limit for the receive FIFO. \n\n
   * The API is not to be called for initializing the receive FIFO. The API shall be used for the
   * runtime change of receive FIFO trigger limit. FIFO start position will not be affected on execution.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_SetSizeTriggerLimit()\ n\n\n
   */
  void XMC_USIC_CH_RXFIFO_SetSizeTriggerLimit(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_FIFO_SIZE_t size,
      const uint32_t limit);
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param limit Threshold for transmit FIFO filling level to be considered for generating events. \n
   * 		\b Range: 0 to \a fifo size -1.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets the trigger limit for the TX FIFO. \n\n
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_TXFIFO_SetSizeTriggerLimit() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_RXFIFO_SetTriggerLimit(XMC_USIC_CH_t *const channel,
      const uint32_t limit)
  {
    channel->RBCTR = (channel->RBCTR & (uint32_t)~USIC_CH_RBCTR_LIMIT_Msk) | ((limit << USIC_CH_RBCTR_LIMIT_Pos) & USIC_CH_RBCTR_LIMIT_Msk);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param event Events to be enabled. Multiple events can be bitwise OR combined. @ref XMC_USIC_CH_RXFIFO_EVENT_CONF_t\n
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables the interrupt events related to transmit FIFO. \n\n
   * Event bitmasks can be constructed using the enumeration @ref XMC_USIC_CH_RXFIFO_EVENT_CONF_t.
   * Multiple events can be enabled by providing multiple events in a single call. For providing
   * multiple events, combine the events using bitwise OR operation.<br>
   *
   * Note: API only enables the events. For interrupt generation, interrupt node must be configured and NVIC node
   * must be enabled.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_SetInterruptNodePointer() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_RXFIFO_EnableEvent(XMC_USIC_CH_t *const channel, const uint32_t event)
  {
    channel->RBCTR |= event;
  }
  
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param event Events to be disabled. \n
   * 			\b Range: @ref XMC_USIC_CH_RXFIFO_EVENT_CONF_STANDARD, @ref XMC_USIC_CH_RXFIFO_EVENT_CONF_ERROR,
   * 			@ref XMC_USIC_CH_RXFIFO_EVENT_CONF_ALTERNATE.
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables the selected interrupt events related to receive FIFO. \n\n
   * By disabling the interrupt events, generation of interrupt is stopped. User can poll the event
   * flags from the status register using the API XMC_USIC_CH_RXFIFO_GetEvent().
   * Event bitmasks can be constructed using the enumeration \a XMC_USIC_CH_RXFIFO_EVENT_CONF. For providing
   * multiple events, combine the events using bitwise OR operation.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_GetEvent(), XMC_USIC_CH_RXFIFO_EnableEvent() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_RXFIFO_DisableEvent(XMC_USIC_CH_t *const channel, const uint32_t event)
  {
    channel->RBCTR &= (uint32_t)~event;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param interrupt_node Node pointer representing the receive FIFO events. \n
   * 					\b Range: @ref XMC_USIC_CH_RXFIFO_INTERRUPT_NODE_POINTER_STANDARD,
   * 					@ref XMC_USIC_CH_RXFIFO_INTERRUPT_NODE_POINTER_ALTERNATE
   * @param service_request The service request to be used for interrupt generation.\n
   * 					\b Range: 0 to 5.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets an interrupt node for the receive FIFO events. \n\n
   * A node pointer represents one or more interrupt events. Service request represents the interrupt node to be used
   * among the 6 interrupt nodes available for USIC module.
   * API configures the service request to be used for interrupt generation for the events selected.
   * A receive FIFO event can generate an interrupt only if the interrupt node is configured for the event and
   * the interrupt generation is enabled for the event. For example, transmit FIFO standard transmit buffer
   * interrupt is generated if the interrupt node for the same is set and interrupt is enabled.<br>
   *
   * Note: NVIC node should be explicitly enabled for the interrupt generation.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_EnableEvent() \n\n\n
   */
  void XMC_USIC_CH_RXFIFO_SetInterruptNodePointer(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_RXFIFO_INTERRUPT_NODE_POINTER_t interrupt_node,
      const uint32_t service_request);
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Value read from the receive FIFO. \n
   * 			\b Range: 16bit data. Length of data depends on the word length configuration.
   *
   * \par<b>Description</b><br>
   * Gets data from the receive FIFO. \n\n
   * Receive FIFO should be read only if data is availble in the FIFO. This can be checked using
   * the API XMC_USIC_CH_RXFIFO_IsEmpty(). Receive FIFO error flag will be set if an attempt is made
   * to read from an empty receive FIFO. To read all the received data, user should keep reading data
   * until receive FIFO is empty.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_ClearEvent() \n\n\n
   */
  __STATIC_INLINE uint16_t XMC_USIC_CH_RXFIFO_GetData(XMC_USIC_CH_t *const channel)
  {
    return (uint16_t)(channel->OUTR);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Clears the contents of receive FIFO. \n\n
   * Receive FIFO contents will be cleared and the filling level will be reset to 0.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_GetLevel() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_RXFIFO_Flush(XMC_USIC_CH_t *const channel)
  {
    channel->TRBSCR = (uint32_t)USIC_CH_TRBSCR_FLUSHRB_Msk;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Status \a true if receive FIFO is full
   *              \a false if receive FIFO is not full.
   *
   * \par<b>Description</b><br>
   * Checks if receive FIFO is full. \n\n
   * When the receive FIFO filling level reaches the configured size, FIFO full flag is set.
   * Any data received when the receive FIFO is full, is lost.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_IsEmpty(), XMC_USIC_CH_RXFIFO_Flush() \n\n\n
   */
  __STATIC_INLINE bool XMC_USIC_CH_RXFIFO_IsFull(XMC_USIC_CH_t *const channel)
  {
    return (bool)(channel->TRBSR & USIC_CH_TRBSR_RFULL_Msk);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Status \a true if receive FIFO is empty,
   *              \a false if receive FIFO has some data.
   *
   * \par<b>Description</b><br>
   * Checks if receive FIFO is empty. \n\n
   * When the receive FIFO is empty, received data will be put in receive FIFO.
   * When the last received word in the FIFO is read, FIFO empty flag is set. Any attempt
   * to read from an empty receive FIFO will set the receive FIFO error flag.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_Flush(), XMC_USIC_CH_RXFIFO_PutData() \n\n\n
   */
  __STATIC_INLINE bool XMC_USIC_CH_RXFIFO_IsEmpty(XMC_USIC_CH_t *const channel)
  {
    return (bool)(channel->TRBSR & USIC_CH_TRBSR_REMPTY_Msk);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return uint32_t Receive FIFO filling level. \n
   *           \b Range: minimum= 0(FIFO empty), maximum= receive FIFO size.
   *
   * \par<b>Description</b><br>
   * Gets the receive FIFO filling level. \n\n
   * For every word received, the filling level is incremented. The API gives the value
   * of this filling level. The filling level is decremented when the data is read out of the
   * receive FIFO.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_Flush(), XMC_USIC_CH_RXFIFO_PutData() \n\n\n
   */
  __STATIC_INLINE uint32_t XMC_USIC_CH_RXFIFO_GetLevel(XMC_USIC_CH_t *const channel)
  {
    return ((uint32_t)(channel->TRBSR & USIC_CH_TRBSR_RBFLVL_Msk) >> USIC_CH_TRBSR_RBFLVL_Pos);
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return Status of standard receive buffer, alternative receive buffer and receive buffer error events. \n
   * 			\b Range: @ref XMC_USIC_CH_RXFIFO_EVENT_STANDARD, @ref XMC_USIC_CH_RXFIFO_EVENT_ERROR,
   * 					  @ref XMC_USIC_CH_RXFIFO_EVENT_ALTERNATE.
   *
   * \par<b>Description</b><br>
   * Gets the receive FIFO events' status. \n\n
   * Gives the status of receive FIFO standard receive buffer event, alternative receive buffer event and receive buffer error event.
   * The status bits are located at their bitpositions in the TRBSR register in the returned value.
   * User can make use of the XMC_USIC_CH_RXFIFO_EVENT enumeration for checking the status of return value.
   * The status can be found by using the bitwise AND operation on the returned value with the enumerated value.<br>
   *
   * Note: Event status flags should be cleared by the user explicitly.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_ClearEvent()\n\n\n
   */
  __STATIC_INLINE uint32_t XMC_USIC_CH_RXFIFO_GetEvent(XMC_USIC_CH_t *const channel)
  {
    return (uint32_t)((channel->TRBSR) & (USIC_CH_TRBSR_SRBI_Msk |
                                          USIC_CH_TRBSR_RBERI_Msk |
                                          USIC_CH_TRBSR_ARBI_Msk));
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param  event Receive FIFO events to be cleared. \n
   * 			\b Range: @ref XMC_USIC_CH_RXFIFO_EVENT_STANDARD, @ref XMC_USIC_CH_RXFIFO_EVENT_ERROR,
   * 					  @ref XMC_USIC_CH_RXFIFO_EVENT_ALTERNATE.
   * @return None
   *
   * \par<b>Description</b><br>
   * Clears the receive FIFO event flags in the status register. \n\n
   * USIC channel peripheral does not clear the event flags after they are read.
   * This API clears the events provided in the \a mask value.
   * XMC_USIC_CH_RXFIFO_EVENT enumeration can be used as input. Multiple events
   * can be cleared by providing a mask value obtained by bitwise OR operation of
   * multiple event enumerations.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_RXFIFO_GetEvent() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_RXFIFO_ClearEvent(XMC_USIC_CH_t *const channel,
      const uint32_t event)
  {
    channel->TRBSCR = event;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Enables time measurement using the capture mode timer. \n\n
   * Time measurement is enabled by setting the timer enable flag in BRG register.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_DisableTimeMeasurement() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_EnableTimeMeasurement(XMC_USIC_CH_t *const channel)
  {
    channel->BRG |= (uint32_t)USIC_CH_BRG_TMEN_Msk;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @return None
   *
   * \par<b>Description</b><br>
   * Disables time measurement using the capture mode timer. \n\n
   * Time measurement is disabled by clearing the timer enable flag in BRG register.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_CH_EnableTimeMeasurement() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_DisableTimeMeasurement(XMC_USIC_CH_t *const channel)
  {
    channel->BRG &= (uint32_t)~USIC_CH_BRG_TMEN_Msk;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param passive_level Passive level for the master clock output. \n
   * 					\b Range: @ref XMC_USIC_CH_BRG_MASTER_CLOCK_PASSIVE_LEVEL_0, @ref XMC_USIC_CH_BRG_MASTER_CLOCK_PASSIVE_LEVEL_1.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets the idle mode pin level for the master clock output. \n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetMclkOutputPassiveLevel(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_BRG_MASTER_CLOCK_PASSIVE_LEVEL_t passive_level)
  {
    channel->BRG = (uint32_t)(channel->BRG & (~USIC_CH_BRG_MCLKCFG_Msk)) | (uint32_t)passive_level;
  }
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param passive_level Passive level for the clock output. \n
   * 					\b Range: @ref XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_0_DELAY_DISABLED,
   * 							  @ref XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_0_DELAY_ENABLED,
   * 							  @ref XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_1_DELAY_DISABLED,
   *							  @ref XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_1_DELAY_ENABLED,
   * @param clock_output Shift clock source selection. \n
   * 					\b Range: Use @ref XMC_USIC_CH_BRG_SHIFT_CLOCK_OUTPUT_SCLK,
   * 								  @ref XMC_USIC_CH_BRG_SHIFT_CLOCK_OUTPUT_DX1
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets the idle mode shift clock output level and selects the shift clock source. \n\n
   * Shift clock idle mode output level can be set to logic high or low. Shift clock output can be configured to have a
   * delay of half shift clock period. Both the configurations are available as enumeration values defined with type
   * @ref XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_t.
   * This value should be configured based on the slave device requirement.
   * Shift clock source can be selected between internal clock(master) and external input(slave).
   *
   */
  __STATIC_INLINE void XMC_USIC_CH_ConfigureShiftClockOutput(XMC_USIC_CH_t *const channel,
      const XMC_USIC_CH_BRG_SHIFT_CLOCK_PASSIVE_LEVEL_t passive_level,
      const XMC_USIC_CH_BRG_SHIFT_CLOCK_OUTPUT_t clock_output)
  {
    channel->BRG = (uint32_t)(channel->BRG & (~(USIC_CH_BRG_SCLKCFG_Msk |
                              USIC_CH_BRG_SCLKOSEL_Msk))) |
                   (uint32_t)passive_level |
                   (uint32_t)clock_output;
  }
  
  /**
   * @param channel Pointer to USIC channel handler of type @ref XMC_USIC_CH_t \n
   * 				   \b Range: @ref XMC_USIC0_CH0, @ref XMC_USIC0_CH1 to @ref XMC_USIC2_CH1 based on device support.
   * @param mode USIC channel operation mode. \n
   * 				\b Range: @ref XMC_USIC_CH_OPERATING_MODE_IDLE, @ref XMC_USIC_CH_OPERATING_MODE_SPI,
   * 						  @ref XMC_USIC_CH_OPERATING_MODE_UART, @ref XMC_USIC_CH_OPERATING_MODE_I2S,
   * 						  @ref XMC_USIC_CH_OPERATING_MODE_I2C.
   * @return None
   *
   * \par<b>Description</b><br>
   * Sets the USIC channel operation mode.\n\n
   * A USIC channel can support multiple serial communication protocols like UART, SPI, I2C and I2S.
   * The API sets the input operation mode to the USIC channel.
   *
   * \par<b>Related APIs:</b><BR>
   * XMC_USIC_Enable(), XMC_USIC_CH_Enable() \n\n\n
   */
  __STATIC_INLINE void XMC_USIC_CH_SetMode(XMC_USIC_CH_t *const channel, const XMC_USIC_CH_OPERATING_MODE_t mode)
  {
    channel->CCR = (uint32_t)(channel->CCR & (~(USIC_CH_CCR_MODE_Msk))) | (uint32_t)mode;
  }
  #ifdef __cplusplus
  }
  #endif
  
  /**
   * @}
   */
  
  /**
   * @}
   */
  
  #endif
  