/* * Copyright (c) 2012, Freescale Semiconductor, Inc. * All rights reserved. * * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT * SHALL FREESCALE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. */ /* * WARNING! DO NOT EDIT THIS FILE DIRECTLY! * * This file was generated automatically and any changes may be lost. */ #ifndef __HW_UART_REGISTERS_H__ #define __HW_UART_REGISTERS_H__ #include "regs.h" /* * i.MX6UL UART * * UARTv2 * * Registers defined in this header file: * - HW_UART_URXD - UART Receiver Register * - HW_UART_UTXD - UART Transmitter Register * - HW_UART_UCR1 - UART Control Register 1 * - HW_UART_UCR2 - UART Control Register 2 * - HW_UART_UCR3 - UART Control Register 3 * - HW_UART_UCR4 - UART Control Register 4 * - HW_UART_UFCR - UART FIFO Control Register * - HW_UART_USR1 - UART Status Register 1 * - HW_UART_USR2 - UART Status Register 2 * - HW_UART_UESC - UART Escape Character Register * - HW_UART_UTIM - UART Escape Timer Register * - HW_UART_UBIR - UART BRM Incremental Register * - HW_UART_UBMR - UART BRM Modulator Register * - HW_UART_UBRC - UART Baud Rate Count Register * - HW_UART_ONEMS - UART One Millisecond Register * - HW_UART_UTS - UART Test Register * - HW_UART_UMCR - UART RS-485 Mode Control Register * * - hw_uart_t - Struct containing all module registers. */ //! @name Module base addresses //@{ #ifndef REGS_UART_BASE #define HW_UART_INSTANCE_COUNT (8) //!< Number of instances of the UART module. #define HW_UART1 (1) //!< Instance number for UART1. #define HW_UART2 (2) //!< Instance number for UART2. #define HW_UART3 (3) //!< Instance number for UART3. #define HW_UART4 (4) //!< Instance number for UART4. #define HW_UART5 (5) /*!< Instance number for UART5. */ #define HW_UART6 (6) /*!< Instance number for UART6. */ #define HW_UART7 (7) /*!< Instance number for UART7. */ #define HW_UART8 (8) /*!< Instance number for UART8. */ #define REGS_UART1_BASE (0x02020000) //!< Base address for UART instance number 1. #define REGS_UART2_BASE (0x021e8000) //!< Base address for UART instance number 2. #define REGS_UART3_BASE (0x021ec000) //!< Base address for UART instance number 3. #define REGS_UART4_BASE (0x021f0000) //!< Base address for UART instance number 4. #define REGS_UART5_BASE (0x021f4000) //!< Base address for UART instance number 5. #define REGS_UART6_BASE (0x21FC000U) //!< Base address for UART instance number 6. #define REGS_UART7_BASE (0x2018000U) //!< Base address for UART instance number 7. #define REGS_UART8_BASE (0x2024000U) //!< Base address for UART instance number 8. //! @brief Get the base address of UART by instance number. //! @param x UART instance number, from 1 through 5. #define REGS_UART_BASE(x) ( (x) == HW_UART1 ? REGS_UART1_BASE : (x) == HW_UART2 ? REGS_UART2_BASE : (x) == HW_UART3 ? REGS_UART3_BASE : (x) == HW_UART4 ? REGS_UART4_BASE : (x) == HW_UART5 ? REGS_UART5_BASE : (x) == HW_UART6 ? REGS_UART6_BASE : (x) == HW_UART7 ? REGS_UART7_BASE : REGS_UART8_BASE) //! @brief Get the instance number given a base address. //! @param b Base address for an instance of UART. #define REGS_UART_INSTANCE(b) ( (b) == REGS_UART1_BASE ? HW_UART1 : (b) == REGS_UART2_BASE ? HW_UART2 : (b) == REGS_UART3_BASE ? HW_UART3 : (b) == REGS_UART4_BASE ? HW_UART4 : (b) == REGS_UART5_BASE ? HW_UART5 : (b) == REGS_UART6_BASE ? HW_UART6 : (b) == REGS_UART7_BASE ? HW_UART7 : (b) == REGS_UART8_BASE ? HW_UART8 : 0) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_URXD - UART Receiver Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_URXD - UART Receiver Register (RO) * * Reset value: 0x00000000 * * The UART will yield a transfer error on the peripheral bus when core is reading URXD register * with receive interface disabled (RXEN=0 or UARTEN=0). */ typedef union _hw_uart_urxd { reg32_t U; struct _hw_uart_urxd_bitfields { unsigned RX_DATA : 8; //!< [7:0] Received Data . unsigned RESERVED0 : 2; //!< [9:8] Reserved unsigned PRERR : 1; //!< [10] In RS-485 mode, it holds the ninth data bit (bit [8]) of received 9-bit RS-485 data unsigned BRK : 1; //!< [11] BREAK Detect. unsigned FRMERR : 1; //!< [12] Frame Error. unsigned OVRRUN : 1; //!< [13] Receiver Overrun. unsigned ERR : 1; //!< [14] Error Detect. unsigned CHARRDY : 1; //!< [15] Character Ready. unsigned RESERVED1 : 16; //!< [31:16] Reserved } B; } hw_uart_urxd_t; #endif /*! * @name Constants and macros for entire UART_URXD register */ //@{ #define HW_UART_URXD_ADDR(x) (REGS_UART_BASE(x) + 0x0) #ifndef __LANGUAGE_ASM__ #define HW_UART_URXD(x) (*(volatile hw_uart_urxd_t *) HW_UART_URXD_ADDR(x)) #define HW_UART_URXD_RD(x) (HW_UART_URXD(x).U) #endif //@} /* * constants & macros for individual UART_URXD bitfields */ /*! @name Register UART_URXD, field RX_DATA[7:0] (RO) * * Received Data . Holds the received character. In 7-bit mode, the most significant bit (MSB) is * forced to 0. In 8-bit mode, all bits are active. */ //@{ #define BP_UART_URXD_RX_DATA (0) //!< Bit position for UART_URXD_RX_DATA. #define BM_UART_URXD_RX_DATA (0x000000ff) //!< Bit mask for UART_URXD_RX_DATA. //! @brief Get value of UART_URXD_RX_DATA from a register value. #define BG_UART_URXD_RX_DATA(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_URXD_RX_DATA) >> BP_UART_URXD_RX_DATA) //@} /*! @name Register UART_URXD, field PRERR[10] (RO) * * In RS-485 mode, it holds the ninth data bit (bit [8]) of received 9-bit RS-485 data In RS232/IrDA * mode, it is the Parity Error flag . Indicates whether the current character was detected with a * parity error and is possibly corrupted. PRERR is updated for each character read from the RxFIFO. * When parity is disabled, PRERR always reads as 0. * * Values: * - 0 - = No parity error was detected for data in the RX_DATA field * - 1 - = A parity error was detected for data in the RX_DATA field */ //@{ #define BP_UART_URXD_PRERR (10) //!< Bit position for UART_URXD_PRERR. #define BM_UART_URXD_PRERR (0x00000400) //!< Bit mask for UART_URXD_PRERR. //! @brief Get value of UART_URXD_PRERR from a register value. #define BG_UART_URXD_PRERR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_URXD_PRERR) >> BP_UART_URXD_PRERR) //@} /*! @name Register UART_URXD, field BRK[11] (RO) * * BREAK Detect. Indicates whether the current character was detected as a BREAK character. The data * bits and the stop bit are all 0. The FRMERR bit is set when BRK is set. When odd parity is * selected, PRERR is also set when BRK is set. BRK is valid for each character read from the * RxFIFO. * * Values: * - 0 - The current character is not a BREAK character * - 1 - The current character is a BREAK character */ //@{ #define BP_UART_URXD_BRK (11) //!< Bit position for UART_URXD_BRK. #define BM_UART_URXD_BRK (0x00000800) //!< Bit mask for UART_URXD_BRK. //! @brief Get value of UART_URXD_BRK from a register value. #define BG_UART_URXD_BRK(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_URXD_BRK) >> BP_UART_URXD_BRK) //@} /*! @name Register UART_URXD, field FRMERR[12] (RO) * * Frame Error. Indicates whether the current character had a framing error (a missing stop bit) and * is possibly corrupted. FRMERR is updated for each character read from the RxFIFO. * * Values: * - 0 - The current character has no framing error * - 1 - The current character has a framing error */ //@{ #define BP_UART_URXD_FRMERR (12) //!< Bit position for UART_URXD_FRMERR. #define BM_UART_URXD_FRMERR (0x00001000) //!< Bit mask for UART_URXD_FRMERR. //! @brief Get value of UART_URXD_FRMERR from a register value. #define BG_UART_URXD_FRMERR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_URXD_FRMERR) >> BP_UART_URXD_FRMERR) //@} /*! @name Register UART_URXD, field OVRRUN[13] (RO) * * Receiver Overrun. This read-only bit, when HIGH, indicates that the corresponding character was * stored in the last position (32nd) of the Rx FIFO. Even if a 33rd character has not been * detected, this bit will be set to '1' for the 32nd character. * * Values: * - 0 - No RxFIFO overrun was detected * - 1 - A RxFIFO overrun was detected */ //@{ #define BP_UART_URXD_OVRRUN (13) //!< Bit position for UART_URXD_OVRRUN. #define BM_UART_URXD_OVRRUN (0x00002000) //!< Bit mask for UART_URXD_OVRRUN. //! @brief Get value of UART_URXD_OVRRUN from a register value. #define BG_UART_URXD_OVRRUN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_URXD_OVRRUN) >> BP_UART_URXD_OVRRUN) //@} /*! @name Register UART_URXD, field ERR[14] (RO) * * Error Detect. Indicates whether the character present in the RX_DATA field has an error (OVRRUN, * FRMERR, BRK or PRERR) status. The ERR bit is updated and valid for each received character. * * Values: * - 0 - No error status was detected * - 1 - An error status was detected */ //@{ #define BP_UART_URXD_ERR (14) //!< Bit position for UART_URXD_ERR. #define BM_UART_URXD_ERR (0x00004000) //!< Bit mask for UART_URXD_ERR. //! @brief Get value of UART_URXD_ERR from a register value. #define BG_UART_URXD_ERR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_URXD_ERR) >> BP_UART_URXD_ERR) //@} /*! @name Register UART_URXD, field CHARRDY[15] (RO) * * Character Ready. This read-only bit indicates an invalid read when the FIFO becomes empty and * software tries to read the same old data. This bit should not be used for polling for data * written to the RX FIFO. * * Values: * - 0 - Character in RX_DATA field and associated flags are invalid. * - 1 - Character in RX_DATA field and associated flags valid and ready for reading. */ //@{ #define BP_UART_URXD_CHARRDY (15) //!< Bit position for UART_URXD_CHARRDY. #define BM_UART_URXD_CHARRDY (0x00008000) //!< Bit mask for UART_URXD_CHARRDY. //! @brief Get value of UART_URXD_CHARRDY from a register value. #define BG_UART_URXD_CHARRDY(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_URXD_CHARRDY) >> BP_UART_URXD_CHARRDY) //@} //------------------------------------------------------------------------------------------- // HW_UART_UTXD - UART Transmitter Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UTXD - UART Transmitter Register (WO) * * Reset value: 0x00000000 * * The UART will yield a transfer error on the peripheral bus when core is writing into UART_URXD * register with transmit interface disabled (TXEN=0 or UARTEN=0). Memory space between UART_URXD * and UART_UTXD registers is reserved. Any read or write access to this space will be considered as * an invalid access and yield a transfer error . */ typedef union _hw_uart_utxd { reg32_t U; struct _hw_uart_utxd_bitfields { unsigned TX_DATA : 8; //!< [7:0] Transmit Data . unsigned RESERVED0 : 24; //!< [31:8] Reserved. } B; } hw_uart_utxd_t; #endif /*! * @name Constants and macros for entire UART_UTXD register */ //@{ #define HW_UART_UTXD_ADDR(x) (REGS_UART_BASE(x) + 0x40) #ifndef __LANGUAGE_ASM__ #define HW_UART_UTXD(x) (*(volatile hw_uart_utxd_t *) HW_UART_UTXD_ADDR(x)) #define HW_UART_UTXD_WR(x, v) (HW_UART_UTXD(x).U = (v)) #endif //@} /* * constants & macros for individual UART_UTXD bitfields */ /*! @name Register UART_UTXD, field TX_DATA[7:0] (WO) * * Transmit Data . Holds the parallel transmit data inputs. In 7-bit mode, D7 is ignored. In 8-bit * mode, all bits are used. Data is transmitted least significant bit (LSB) first. A new character * is transmitted when the TX_DATA field is written. The TX_DATA field must be written only when the * TRDY bit is high to ensure that corrupted data is not sent. */ //@{ #define BP_UART_UTXD_TX_DATA (0) //!< Bit position for UART_UTXD_TX_DATA. #define BM_UART_UTXD_TX_DATA (0x000000ff) //!< Bit mask for UART_UTXD_TX_DATA. //! @brief Get value of UART_UTXD_TX_DATA from a register value. #define BG_UART_UTXD_TX_DATA(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTXD_TX_DATA) >> BP_UART_UTXD_TX_DATA) //! @brief Format value for bitfield UART_UTXD_TX_DATA. #define BF_UART_UTXD_TX_DATA(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTXD_TX_DATA) & BM_UART_UTXD_TX_DATA) //@} //------------------------------------------------------------------------------------------- // HW_UART_UCR1 - UART Control Register 1 //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UCR1 - UART Control Register 1 (RW) * * Reset value: 0x00000000 */ typedef union _hw_uart_ucr1 { reg32_t U; struct _hw_uart_ucr1_bitfields { unsigned UARTEN : 1; //!< [0] UART Enable . unsigned DOZE : 1; //!< [1] DOZE . unsigned ATDMAEN : 1; //!< [2] Aging DMA Timer Enable . unsigned TXDMAEN : 1; //!< [3] Transmitter Ready DMA Enable . unsigned SNDBRK : 1; //!< [4] Send BREAK . unsigned RTSDEN : 1; //!< [5] RTS Delta Interrupt Enable . unsigned TXMPTYEN : 1; //!< [6] Transmitter Empty Interrupt Enable . unsigned IREN : 1; //!< [7] Infrared Interface Enable . unsigned RXDMAEN : 1; //!< [8] Receive Ready DMA Enable . unsigned RRDYEN : 1; //!< [9] Receiver Ready Interrupt Enable . unsigned ICD : 2; //!< [11:10] Idle Condition Detect . unsigned IDEN : 1; //!< [12] Idle Condition Detected Interrupt Enable . unsigned TRDYEN : 1; //!< [13] Transmitter Ready Interrupt Enable . unsigned ADBR : 1; //!< [14] Automatic Detection of Baud Rate . unsigned ADEN : 1; //!< [15] Automatic Baud Rate Detection Interrupt Enable . unsigned RESERVED0 : 16; //!< [31:16] Reserved } B; } hw_uart_ucr1_t; #endif /*! * @name Constants and macros for entire UART_UCR1 register */ //@{ #define HW_UART_UCR1_ADDR(x) (REGS_UART_BASE(x) + 0x80) #ifndef __LANGUAGE_ASM__ #define HW_UART_UCR1(x) (*(volatile hw_uart_ucr1_t *) HW_UART_UCR1_ADDR(x)) #define HW_UART_UCR1_RD(x) (HW_UART_UCR1(x).U) #define HW_UART_UCR1_WR(x, v) (HW_UART_UCR1(x).U = (v)) #define HW_UART_UCR1_SET(x, v) (HW_UART_UCR1_WR(x, HW_UART_UCR1_RD(x) | (v))) #define HW_UART_UCR1_CLR(x, v) (HW_UART_UCR1_WR(x, HW_UART_UCR1_RD(x) & ~(v))) #define HW_UART_UCR1_TOG(x, v) (HW_UART_UCR1_WR(x, HW_UART_UCR1_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UCR1 bitfields */ /*! @name Register UART_UCR1, field UARTEN[0] (RW) * * UART Enable . Enables/Disables the UART. If UARTEN is negated in the middle of a transmission, * the transmitter stops and pulls the TXD line to a logic 1. UARTEN must be set to 1 before any * access to UTXD and URXD registers, otherwise a transfer error is returned. This bit can be set to * 1 along with other bits in this register. There is no restriction to the sequence of programing * this bit and other control registers. * * Values: * - 0 - Disable the UART * - 1 - Enable the UART */ //@{ #define BP_UART_UCR1_UARTEN (0) //!< Bit position for UART_UCR1_UARTEN. #define BM_UART_UCR1_UARTEN (0x00000001) //!< Bit mask for UART_UCR1_UARTEN. //! @brief Get value of UART_UCR1_UARTEN from a register value. #define BG_UART_UCR1_UARTEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_UARTEN) >> BP_UART_UCR1_UARTEN) //! @brief Format value for bitfield UART_UCR1_UARTEN. #define BF_UART_UCR1_UARTEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_UARTEN) & BM_UART_UCR1_UARTEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the UARTEN field to a new value. #define BW_UART_UCR1_UARTEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_UARTEN) | BF_UART_UCR1_UARTEN(v))) #endif //@} /*! @name Register UART_UCR1, field DOZE[1] (RW) * * DOZE . Determines the UART enable condition in the DOZE state. When doze_req input pin is at '1', * (the ARM Platform executes a doze instruction and the system is placed in the Doze State), the * DOZE bit affects operation of the UART. While in the Doze State, if this bit is asserted, the * UART is disabled. See the description in . * * Values: * - 0 - The UART is enabled when in DOZE state * - 1 - The UART is disabled when in DOZE state */ //@{ #define BP_UART_UCR1_DOZE (1) //!< Bit position for UART_UCR1_DOZE. #define BM_UART_UCR1_DOZE (0x00000002) //!< Bit mask for UART_UCR1_DOZE. //! @brief Get value of UART_UCR1_DOZE from a register value. #define BG_UART_UCR1_DOZE(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_DOZE) >> BP_UART_UCR1_DOZE) //! @brief Format value for bitfield UART_UCR1_DOZE. #define BF_UART_UCR1_DOZE(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_DOZE) & BM_UART_UCR1_DOZE) #ifndef __LANGUAGE_ASM__ //! @brief Set the DOZE field to a new value. #define BW_UART_UCR1_DOZE(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_DOZE) | BF_UART_UCR1_DOZE(v))) #endif //@} /*! @name Register UART_UCR1, field ATDMAEN[2] (RW) * * Aging DMA Timer Enable . Enables/Disables the receive DMA request dma_req_rx for the aging timer * interrupt (triggered with AGTIM flag in USR1[8]). * * Values: * - 0 - Disable AGTIM DMA request * - 1 - Enable AGTIM DMA request */ //@{ #define BP_UART_UCR1_ATDMAEN (2) //!< Bit position for UART_UCR1_ATDMAEN. #define BM_UART_UCR1_ATDMAEN (0x00000004) //!< Bit mask for UART_UCR1_ATDMAEN. //! @brief Get value of UART_UCR1_ATDMAEN from a register value. #define BG_UART_UCR1_ATDMAEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_ATDMAEN) >> BP_UART_UCR1_ATDMAEN) //! @brief Format value for bitfield UART_UCR1_ATDMAEN. #define BF_UART_UCR1_ATDMAEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_ATDMAEN) & BM_UART_UCR1_ATDMAEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the ATDMAEN field to a new value. #define BW_UART_UCR1_ATDMAEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_ATDMAEN) | BF_UART_UCR1_ATDMAEN(v))) #endif //@} /*! @name Register UART_UCR1, field TXDMAEN[3] (RW) * * Transmitter Ready DMA Enable . Enables/Disables the transmit DMA request dma_req_tx when the * transmitter has one or more slots available in the TxFIFO. The fill level in the TxFIFO that * generates the dma_req_tx is controlled by the TXTL bits. A DMA request will be issued as long as * TXDMAEN and TRDY are high even if the transmitter is not enabled. In general, user should enable * the transmitter before enabling the transmit DMA request. * * Values: * - 0 - Disable transmit DMA request * - 1 - Enable transmit DMA request */ //@{ #define BP_UART_UCR1_TXDMAEN (3) //!< Bit position for UART_UCR1_TXDMAEN. #define BM_UART_UCR1_TXDMAEN (0x00000008) //!< Bit mask for UART_UCR1_TXDMAEN. //! @brief Get value of UART_UCR1_TXDMAEN from a register value. #define BG_UART_UCR1_TXDMAEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_TXDMAEN) >> BP_UART_UCR1_TXDMAEN) //! @brief Format value for bitfield UART_UCR1_TXDMAEN. #define BF_UART_UCR1_TXDMAEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_TXDMAEN) & BM_UART_UCR1_TXDMAEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the TXDMAEN field to a new value. #define BW_UART_UCR1_TXDMAEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_TXDMAEN) | BF_UART_UCR1_TXDMAEN(v))) #endif //@} /*! @name Register UART_UCR1, field SNDBRK[4] (RW) * * Send BREAK . Forces the transmitter to send a BREAK character. The transmitter finishes sending * the character in progress (if any) and sends BREAK characters until SNDBRK is reset. Because the * transmitter samples SNDBRK after every bit is transmitted, it is important that SNDBRK is * asserted high for a sufficient period of time to generate a valid BREAK. After the BREAK * transmission completes, the UART transmits 2 mark bits. The user can continue to fill the TxFIFO * and any characters remaining are transmitted when the BREAK is terminated. * * Values: * - 0 - Do not send a BREAK character * - 1 - Send a BREAK character (continuous 0s) */ //@{ #define BP_UART_UCR1_SNDBRK (4) //!< Bit position for UART_UCR1_SNDBRK. #define BM_UART_UCR1_SNDBRK (0x00000010) //!< Bit mask for UART_UCR1_SNDBRK. //! @brief Get value of UART_UCR1_SNDBRK from a register value. #define BG_UART_UCR1_SNDBRK(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_SNDBRK) >> BP_UART_UCR1_SNDBRK) //! @brief Format value for bitfield UART_UCR1_SNDBRK. #define BF_UART_UCR1_SNDBRK(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_SNDBRK) & BM_UART_UCR1_SNDBRK) #ifndef __LANGUAGE_ASM__ //! @brief Set the SNDBRK field to a new value. #define BW_UART_UCR1_SNDBRK(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_SNDBRK) | BF_UART_UCR1_SNDBRK(v))) #endif //@} /*! @name Register UART_UCR1, field RTSDEN[5] (RW) * * RTS Delta Interrupt Enable . Enables/Disables the RTSD interrupt. The current status of the RTS * pin is read in the RTSS bit. * * Values: * - 0 - Disable RTSD interrupt * - 1 - Enable RTSD interrupt */ //@{ #define BP_UART_UCR1_RTSDEN (5) //!< Bit position for UART_UCR1_RTSDEN. #define BM_UART_UCR1_RTSDEN (0x00000020) //!< Bit mask for UART_UCR1_RTSDEN. //! @brief Get value of UART_UCR1_RTSDEN from a register value. #define BG_UART_UCR1_RTSDEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_RTSDEN) >> BP_UART_UCR1_RTSDEN) //! @brief Format value for bitfield UART_UCR1_RTSDEN. #define BF_UART_UCR1_RTSDEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_RTSDEN) & BM_UART_UCR1_RTSDEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the RTSDEN field to a new value. #define BW_UART_UCR1_RTSDEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_RTSDEN) | BF_UART_UCR1_RTSDEN(v))) #endif //@} /*! @name Register UART_UCR1, field TXMPTYEN[6] (RW) * * Transmitter Empty Interrupt Enable . Enables/Disables the transmitter FIFO empty (TXFE) * interrupt. interrupt_uart . When negated, the TXFE interrupt is disabled. An interrupt will be * issued as long as TXMPTYEN and TXFE are high even if the transmitter is not enabled. In general, * user should enable the transmitter before enabling the TXFE interrupt. * * Values: * - 0 - Disable the transmitter FIFO empty interrupt * - 1 - Enable the transmitter FIFO empty interrupt */ //@{ #define BP_UART_UCR1_TXMPTYEN (6) //!< Bit position for UART_UCR1_TXMPTYEN. #define BM_UART_UCR1_TXMPTYEN (0x00000040) //!< Bit mask for UART_UCR1_TXMPTYEN. //! @brief Get value of UART_UCR1_TXMPTYEN from a register value. #define BG_UART_UCR1_TXMPTYEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_TXMPTYEN) >> BP_UART_UCR1_TXMPTYEN) //! @brief Format value for bitfield UART_UCR1_TXMPTYEN. #define BF_UART_UCR1_TXMPTYEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_TXMPTYEN) & BM_UART_UCR1_TXMPTYEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the TXMPTYEN field to a new value. #define BW_UART_UCR1_TXMPTYEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_TXMPTYEN) | BF_UART_UCR1_TXMPTYEN(v))) #endif //@} /*! @name Register UART_UCR1, field IREN[7] (RW) * * Infrared Interface Enable . Enables/Disables the IR interface. See the IR interface description * in , for more information. Note: MDEN(UMCR[0]) must be cleared to 0 when using IrDA interface. * See * * Values: * - 0 - Disable the IR interface * - 1 - Enable the IR interface */ //@{ #define BP_UART_UCR1_IREN (7) //!< Bit position for UART_UCR1_IREN. #define BM_UART_UCR1_IREN (0x00000080) //!< Bit mask for UART_UCR1_IREN. //! @brief Get value of UART_UCR1_IREN from a register value. #define BG_UART_UCR1_IREN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_IREN) >> BP_UART_UCR1_IREN) //! @brief Format value for bitfield UART_UCR1_IREN. #define BF_UART_UCR1_IREN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_IREN) & BM_UART_UCR1_IREN) #ifndef __LANGUAGE_ASM__ //! @brief Set the IREN field to a new value. #define BW_UART_UCR1_IREN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_IREN) | BF_UART_UCR1_IREN(v))) #endif //@} /*! @name Register UART_UCR1, field RXDMAEN[8] (RW) * * Receive Ready DMA Enable . Enables/Disables the receive DMA request dma_req_rx when the receiver * has data in the RxFIFO. The fill level in the RxFIFO at which a DMA request is generated is * controlled by the RXTL bits. When negated, the receive DMA request is disabled. * * Values: * - 0 - Disable DMA request * - 1 - Enable DMA request */ //@{ #define BP_UART_UCR1_RXDMAEN (8) //!< Bit position for UART_UCR1_RXDMAEN. #define BM_UART_UCR1_RXDMAEN (0x00000100) //!< Bit mask for UART_UCR1_RXDMAEN. //! @brief Get value of UART_UCR1_RXDMAEN from a register value. #define BG_UART_UCR1_RXDMAEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_RXDMAEN) >> BP_UART_UCR1_RXDMAEN) //! @brief Format value for bitfield UART_UCR1_RXDMAEN. #define BF_UART_UCR1_RXDMAEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_RXDMAEN) & BM_UART_UCR1_RXDMAEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the RXDMAEN field to a new value. #define BW_UART_UCR1_RXDMAEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_RXDMAEN) | BF_UART_UCR1_RXDMAEN(v))) #endif //@} /*! @name Register UART_UCR1, field RRDYEN[9] (RW) * * Receiver Ready Interrupt Enable . Enables/Disables the RRDY interrupt when the RxFIFO contains * data. The fill level in the RxFIFO at which an interrupt is generated is controlled by the RXTL * bits. When RRDYEN is negated, the receiver ready interrupt is disabled. * * Values: * - 0 - Disables the RRDY interrupt * - 1 - Enables the RRDY interrupt */ //@{ #define BP_UART_UCR1_RRDYEN (9) //!< Bit position for UART_UCR1_RRDYEN. #define BM_UART_UCR1_RRDYEN (0x00000200) //!< Bit mask for UART_UCR1_RRDYEN. //! @brief Get value of UART_UCR1_RRDYEN from a register value. #define BG_UART_UCR1_RRDYEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_RRDYEN) >> BP_UART_UCR1_RRDYEN) //! @brief Format value for bitfield UART_UCR1_RRDYEN. #define BF_UART_UCR1_RRDYEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_RRDYEN) & BM_UART_UCR1_RRDYEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the RRDYEN field to a new value. #define BW_UART_UCR1_RRDYEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_RRDYEN) | BF_UART_UCR1_RRDYEN(v))) #endif //@} /*! @name Register UART_UCR1, field ICD[11:10] (RW) * * Idle Condition Detect . Controls the number of frames RXD is allowed to be idle before an idle * condition is reported. * * Values: * - 00 - Idle for more than 4 frames * - 01 - Idle for more than 8 frames * - 10 - Idle for more than 16 frames * - 11 - Idle for more than 32 frames */ //@{ #define BP_UART_UCR1_ICD (10) //!< Bit position for UART_UCR1_ICD. #define BM_UART_UCR1_ICD (0x00000c00) //!< Bit mask for UART_UCR1_ICD. //! @brief Get value of UART_UCR1_ICD from a register value. #define BG_UART_UCR1_ICD(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_ICD) >> BP_UART_UCR1_ICD) //! @brief Format value for bitfield UART_UCR1_ICD. #define BF_UART_UCR1_ICD(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_ICD) & BM_UART_UCR1_ICD) #ifndef __LANGUAGE_ASM__ //! @brief Set the ICD field to a new value. #define BW_UART_UCR1_ICD(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_ICD) | BF_UART_UCR1_ICD(v))) #endif //@} /*! @name Register UART_UCR1, field IDEN[12] (RW) * * Idle Condition Detected Interrupt Enable . Enables/Disables the IDLE bit to generate an interrupt * ( interrupt_uart = 0). * * Values: * - 0 - Disable the IDLE interrupt * - 1 - Enable the IDLE interrupt */ //@{ #define BP_UART_UCR1_IDEN (12) //!< Bit position for UART_UCR1_IDEN. #define BM_UART_UCR1_IDEN (0x00001000) //!< Bit mask for UART_UCR1_IDEN. //! @brief Get value of UART_UCR1_IDEN from a register value. #define BG_UART_UCR1_IDEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_IDEN) >> BP_UART_UCR1_IDEN) //! @brief Format value for bitfield UART_UCR1_IDEN. #define BF_UART_UCR1_IDEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_IDEN) & BM_UART_UCR1_IDEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the IDEN field to a new value. #define BW_UART_UCR1_IDEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_IDEN) | BF_UART_UCR1_IDEN(v))) #endif //@} /*! @name Register UART_UCR1, field TRDYEN[13] (RW) * * Transmitter Ready Interrupt Enable . Enables/Disables the transmitter Ready Interrupt (TRDY) when * the transmitter has one or more slots available in the TxFIFO. The fill level in the TXFIFO at * which an interrupt is generated is controlled by TxTL bits. When TRDYEN is negated, the * transmitter ready interrupt is disabled. An interrupt will be issued as long as TRDYEN and TRDY * are high even if the transmitter is not enabled. In general, user should enable the transmitter * before enabling the TRDY interrupt. * * Values: * - 0 - Disable the transmitter ready interrupt * - 1 - Enable the transmitter ready interrupt */ //@{ #define BP_UART_UCR1_TRDYEN (13) //!< Bit position for UART_UCR1_TRDYEN. #define BM_UART_UCR1_TRDYEN (0x00002000) //!< Bit mask for UART_UCR1_TRDYEN. //! @brief Get value of UART_UCR1_TRDYEN from a register value. #define BG_UART_UCR1_TRDYEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_TRDYEN) >> BP_UART_UCR1_TRDYEN) //! @brief Format value for bitfield UART_UCR1_TRDYEN. #define BF_UART_UCR1_TRDYEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_TRDYEN) & BM_UART_UCR1_TRDYEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the TRDYEN field to a new value. #define BW_UART_UCR1_TRDYEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_TRDYEN) | BF_UART_UCR1_TRDYEN(v))) #endif //@} /*! @name Register UART_UCR1, field ADBR[14] (RW) * * Automatic Detection of Baud Rate . Enables/Disables automatic baud rate detection. When the ADBR * bit is set and the ADET bit is cleared, the receiver detects the incoming baud rate * automatically. The ADET flag is set when the receiver verifies that the incoming baud rate is * detected properly by detecting an ASCII character "A" or "a" (0x41 or 0x61). * * Values: * - 0 - Disable automatic detection of baud rate * - 1 - Enable automatic detection of baud rate */ //@{ #define BP_UART_UCR1_ADBR (14) //!< Bit position for UART_UCR1_ADBR. #define BM_UART_UCR1_ADBR (0x00004000) //!< Bit mask for UART_UCR1_ADBR. //! @brief Get value of UART_UCR1_ADBR from a register value. #define BG_UART_UCR1_ADBR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_ADBR) >> BP_UART_UCR1_ADBR) //! @brief Format value for bitfield UART_UCR1_ADBR. #define BF_UART_UCR1_ADBR(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_ADBR) & BM_UART_UCR1_ADBR) #ifndef __LANGUAGE_ASM__ //! @brief Set the ADBR field to a new value. #define BW_UART_UCR1_ADBR(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_ADBR) | BF_UART_UCR1_ADBR(v))) #endif //@} /*! @name Register UART_UCR1, field ADEN[15] (RW) * * Automatic Baud Rate Detection Interrupt Enable . Enables/Disables the automatic baud rate detect * complete (ADET) bit to generate an interrupt ( interrupt_uart = 0). * * Values: * - 0 - Disable the automatic baud rate detection interrupt * - 1 - Enable the automatic baud rate detection interrupt */ //@{ #define BP_UART_UCR1_ADEN (15) //!< Bit position for UART_UCR1_ADEN. #define BM_UART_UCR1_ADEN (0x00008000) //!< Bit mask for UART_UCR1_ADEN. //! @brief Get value of UART_UCR1_ADEN from a register value. #define BG_UART_UCR1_ADEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR1_ADEN) >> BP_UART_UCR1_ADEN) //! @brief Format value for bitfield UART_UCR1_ADEN. #define BF_UART_UCR1_ADEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR1_ADEN) & BM_UART_UCR1_ADEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the ADEN field to a new value. #define BW_UART_UCR1_ADEN(x, v) (HW_UART_UCR1_WR(x, (HW_UART_UCR1_RD(x) & ~BM_UART_UCR1_ADEN) | BF_UART_UCR1_ADEN(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UCR2 - UART Control Register 2 //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UCR2 - UART Control Register 2 (RW) * * Reset value: 0x00000001 */ typedef union _hw_uart_ucr2 { reg32_t U; struct _hw_uart_ucr2_bitfields { unsigned SRST : 1; //!< [0] Software Reset . unsigned RXEN : 1; //!< [1] Receiver Enable . unsigned TXEN : 1; //!< [2] Transmitter Enable . unsigned ATEN : 1; //!< [3] Aging Timer Enable . unsigned RTSEN : 1; //!< [4] Request to Send Interrupt Enable. unsigned WS : 1; //!< [5] Word Size . unsigned STPB : 1; //!< [6] Stop . unsigned PROE : 1; //!< [7] Parity Odd/Even . unsigned PREN : 1; //!< [8] Parity Enable . unsigned RTEC : 2; //!< [10:9] Request to Send Edge Control . unsigned ESCEN : 1; //!< [11] Escape Enable . unsigned CTS : 1; //!< [12] Clear to Send . unsigned CTSC : 1; //!< [13] CTS Pin Control . unsigned IRTS : 1; //!< [14] Ignore RTS Pin . unsigned ESCI : 1; //!< [15] Escape Sequence Interrupt Enable . unsigned RESERVED0 : 16; //!< [31:16] Reserved } B; } hw_uart_ucr2_t; #endif /*! * @name Constants and macros for entire UART_UCR2 register */ //@{ #define HW_UART_UCR2_ADDR(x) (REGS_UART_BASE(x) + 0x84) #ifndef __LANGUAGE_ASM__ #define HW_UART_UCR2(x) (*(volatile hw_uart_ucr2_t *) HW_UART_UCR2_ADDR(x)) #define HW_UART_UCR2_RD(x) (HW_UART_UCR2(x).U) #define HW_UART_UCR2_WR(x, v) (HW_UART_UCR2(x).U = (v)) #define HW_UART_UCR2_SET(x, v) (HW_UART_UCR2_WR(x, HW_UART_UCR2_RD(x) | (v))) #define HW_UART_UCR2_CLR(x, v) (HW_UART_UCR2_WR(x, HW_UART_UCR2_RD(x) & ~(v))) #define HW_UART_UCR2_TOG(x, v) (HW_UART_UCR2_WR(x, HW_UART_UCR2_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UCR2 bitfields */ /*! @name Register UART_UCR2, field SRST[0] (RW) * * Software Reset . Once the software writes 0 to SRST , the software reset remains active for 4 * module_clock cycles before the hardware deasserts SRST . The software can only write 0 to SRST . * Writing 1 to SRST is ignored. * * Values: * - 0 - Reset the transmit and receive state machines, all FIFOs and register USR1, USR2, UBIR, UBMR, UBRC , * URXD, UTXD and UTS[6-3]. * - 1 - No reset */ //@{ #define BP_UART_UCR2_SRST (0) //!< Bit position for UART_UCR2_SRST. #define BM_UART_UCR2_SRST (0x00000001) //!< Bit mask for UART_UCR2_SRST. //! @brief Get value of UART_UCR2_SRST from a register value. #define BG_UART_UCR2_SRST(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_SRST) >> BP_UART_UCR2_SRST) //! @brief Format value for bitfield UART_UCR2_SRST. #define BF_UART_UCR2_SRST(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_SRST) & BM_UART_UCR2_SRST) #ifndef __LANGUAGE_ASM__ //! @brief Set the SRST field to a new value. #define BW_UART_UCR2_SRST(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_SRST) | BF_UART_UCR2_SRST(v))) #endif //@} /*! @name Register UART_UCR2, field RXEN[1] (RW) * * Receiver Enable . Enables/Disables the receiver. When the receiver is enabled, if the RXD input * is already low, the receiver does not recognize BREAK characters, because it requires a valid * 1-to-0 transition before it can accept any character. * * Values: * - 0 - Disable the receiver * - 1 - Enable the receiver */ //@{ #define BP_UART_UCR2_RXEN (1) //!< Bit position for UART_UCR2_RXEN. #define BM_UART_UCR2_RXEN (0x00000002) //!< Bit mask for UART_UCR2_RXEN. //! @brief Get value of UART_UCR2_RXEN from a register value. #define BG_UART_UCR2_RXEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_RXEN) >> BP_UART_UCR2_RXEN) //! @brief Format value for bitfield UART_UCR2_RXEN. #define BF_UART_UCR2_RXEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_RXEN) & BM_UART_UCR2_RXEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the RXEN field to a new value. #define BW_UART_UCR2_RXEN(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_RXEN) | BF_UART_UCR2_RXEN(v))) #endif //@} /*! @name Register UART_UCR2, field TXEN[2] (RW) * * Transmitter Enable . Enables/Disables the transmitter. When TXEN is negated the transmitter is * disabled and idle. When the UARTEN and TXEN bits are set the transmitter is enabled. If TXEN is * negated in the middle of a transmission, the UART disables the transmitter immediately, and * starts marking 1s. The transmitter FIFO cannot be written when this bit is cleared. * * Values: * - 0 - Disable the transmitter * - 1 - Enable the transmitter */ //@{ #define BP_UART_UCR2_TXEN (2) //!< Bit position for UART_UCR2_TXEN. #define BM_UART_UCR2_TXEN (0x00000004) //!< Bit mask for UART_UCR2_TXEN. //! @brief Get value of UART_UCR2_TXEN from a register value. #define BG_UART_UCR2_TXEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_TXEN) >> BP_UART_UCR2_TXEN) //! @brief Format value for bitfield UART_UCR2_TXEN. #define BF_UART_UCR2_TXEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_TXEN) & BM_UART_UCR2_TXEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the TXEN field to a new value. #define BW_UART_UCR2_TXEN(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_TXEN) | BF_UART_UCR2_TXEN(v))) #endif //@} /*! @name Register UART_UCR2, field ATEN[3] (RW) * * Aging Timer Enable . This bit is used to enable the aging timer interrupt (triggered with AGTIM) * * Values: * - 0 - AGTIM interrupt disabled * - 1 - AGTIM interrupt enabled */ //@{ #define BP_UART_UCR2_ATEN (3) //!< Bit position for UART_UCR2_ATEN. #define BM_UART_UCR2_ATEN (0x00000008) //!< Bit mask for UART_UCR2_ATEN. //! @brief Get value of UART_UCR2_ATEN from a register value. #define BG_UART_UCR2_ATEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_ATEN) >> BP_UART_UCR2_ATEN) //! @brief Format value for bitfield UART_UCR2_ATEN. #define BF_UART_UCR2_ATEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_ATEN) & BM_UART_UCR2_ATEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the ATEN field to a new value. #define BW_UART_UCR2_ATEN(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_ATEN) | BF_UART_UCR2_ATEN(v))) #endif //@} /*! @name Register UART_UCR2, field RTSEN[4] (RW) * * Request to Send Interrupt Enable. Controls the RTS edge sensitive interrupt. When RTSEN is * asserted and the programmed edge is detected on the RTS pin (the RTSF bit is asserted), an * interrupt will be generated on the interrupt_uart pin. (See .) * * Values: * - 0 - Disable request to send interrupt * - 1 - Enable request to send interrupt */ //@{ #define BP_UART_UCR2_RTSEN (4) //!< Bit position for UART_UCR2_RTSEN. #define BM_UART_UCR2_RTSEN (0x00000010) //!< Bit mask for UART_UCR2_RTSEN. //! @brief Get value of UART_UCR2_RTSEN from a register value. #define BG_UART_UCR2_RTSEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_RTSEN) >> BP_UART_UCR2_RTSEN) //! @brief Format value for bitfield UART_UCR2_RTSEN. #define BF_UART_UCR2_RTSEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_RTSEN) & BM_UART_UCR2_RTSEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the RTSEN field to a new value. #define BW_UART_UCR2_RTSEN(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_RTSEN) | BF_UART_UCR2_RTSEN(v))) #endif //@} /*! @name Register UART_UCR2, field WS[5] (RW) * * Word Size . Controls the character length. When WS is high, the transmitter and receiver are in * 8-bit mode. When WS is low, they are in 7-bit mode. The transmitter ignores bit 7 and the * receiver sets bit 7 to 0. WS can be changed in-between transmission (reception) of characters, * however not when a transmission (reception) is in progress, in which case the length of the * current character being transmitted (received) is unpredictable. * * Values: * - 0 - 7-bit transmit and receive character length (not including START, STOP or PARITY bits) * - 1 - 8-bit transmit and receive character length (not including START, STOP or PARITY bits) */ //@{ #define BP_UART_UCR2_WS (5) //!< Bit position for UART_UCR2_WS. #define BM_UART_UCR2_WS (0x00000020) //!< Bit mask for UART_UCR2_WS. //! @brief Get value of UART_UCR2_WS from a register value. #define BG_UART_UCR2_WS(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_WS) >> BP_UART_UCR2_WS) //! @brief Format value for bitfield UART_UCR2_WS. #define BF_UART_UCR2_WS(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_WS) & BM_UART_UCR2_WS) #ifndef __LANGUAGE_ASM__ //! @brief Set the WS field to a new value. #define BW_UART_UCR2_WS(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_WS) | BF_UART_UCR2_WS(v))) #endif //@} /*! @name Register UART_UCR2, field STPB[6] (RW) * * Stop . Controls the number of stop bits after a character. When STPB is low, 1 stop bit is sent. * When STPB is high, 2 stop bits are sent. STPB also affects the receiver. * * Values: * - 0 - The transmitter sends 1 stop bit. The receiver expects 1 or more stop bits. * - 1 - The transmitter sends 2 stop bits. The receiver expects 2 or more stop bits. */ //@{ #define BP_UART_UCR2_STPB (6) //!< Bit position for UART_UCR2_STPB. #define BM_UART_UCR2_STPB (0x00000040) //!< Bit mask for UART_UCR2_STPB. //! @brief Get value of UART_UCR2_STPB from a register value. #define BG_UART_UCR2_STPB(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_STPB) >> BP_UART_UCR2_STPB) //! @brief Format value for bitfield UART_UCR2_STPB. #define BF_UART_UCR2_STPB(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_STPB) & BM_UART_UCR2_STPB) #ifndef __LANGUAGE_ASM__ //! @brief Set the STPB field to a new value. #define BW_UART_UCR2_STPB(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_STPB) | BF_UART_UCR2_STPB(v))) #endif //@} /*! @name Register UART_UCR2, field PROE[7] (RW) * * Parity Odd/Even . Controls the sense of the parity generator and checker. When PROE is high, odd * parity is generated and expected. When PROE is low, even parity is generated and expected. PROE * has no function if PREN is low. * * Values: * - 0 - Even parity * - 1 - Odd parity */ //@{ #define BP_UART_UCR2_PROE (7) //!< Bit position for UART_UCR2_PROE. #define BM_UART_UCR2_PROE (0x00000080) //!< Bit mask for UART_UCR2_PROE. //! @brief Get value of UART_UCR2_PROE from a register value. #define BG_UART_UCR2_PROE(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_PROE) >> BP_UART_UCR2_PROE) //! @brief Format value for bitfield UART_UCR2_PROE. #define BF_UART_UCR2_PROE(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_PROE) & BM_UART_UCR2_PROE) #ifndef __LANGUAGE_ASM__ //! @brief Set the PROE field to a new value. #define BW_UART_UCR2_PROE(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_PROE) | BF_UART_UCR2_PROE(v))) #endif //@} /*! @name Register UART_UCR2, field PREN[8] (RW) * * Parity Enable . Enables/Disables the parity generator in the transmitter and parity checker in * the receiver. When PREN is asserted, the parity generator and checker are enabled, and disabled * when PREN is negated. * * Values: * - 0 - Disable parity generator and checker * - 1 - Enable parity generator and checker */ //@{ #define BP_UART_UCR2_PREN (8) //!< Bit position for UART_UCR2_PREN. #define BM_UART_UCR2_PREN (0x00000100) //!< Bit mask for UART_UCR2_PREN. //! @brief Get value of UART_UCR2_PREN from a register value. #define BG_UART_UCR2_PREN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_PREN) >> BP_UART_UCR2_PREN) //! @brief Format value for bitfield UART_UCR2_PREN. #define BF_UART_UCR2_PREN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_PREN) & BM_UART_UCR2_PREN) #ifndef __LANGUAGE_ASM__ //! @brief Set the PREN field to a new value. #define BW_UART_UCR2_PREN(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_PREN) | BF_UART_UCR2_PREN(v))) #endif //@} /*! @name Register UART_UCR2, field RTEC[10:9] (RW) * * Request to Send Edge Control . Selects the edge that triggers the RTS interrupt. This has no * effect on the RTS delta interrupt. RTEC has an effect only when RTSEN = 1 (see ). * * Values: * - 00 - Trigger interrupt on a rising edge * - 01 - Trigger interrupt on a falling edge * - 1X - Trigger interrupt on any edge */ //@{ #define BP_UART_UCR2_RTEC (9) //!< Bit position for UART_UCR2_RTEC. #define BM_UART_UCR2_RTEC (0x00000600) //!< Bit mask for UART_UCR2_RTEC. //! @brief Get value of UART_UCR2_RTEC from a register value. #define BG_UART_UCR2_RTEC(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_RTEC) >> BP_UART_UCR2_RTEC) //! @brief Format value for bitfield UART_UCR2_RTEC. #define BF_UART_UCR2_RTEC(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_RTEC) & BM_UART_UCR2_RTEC) #ifndef __LANGUAGE_ASM__ //! @brief Set the RTEC field to a new value. #define BW_UART_UCR2_RTEC(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_RTEC) | BF_UART_UCR2_RTEC(v))) #endif //@} /*! @name Register UART_UCR2, field ESCEN[11] (RW) * * Escape Enable . Enables/Disables the escape sequence detection logic. * * Values: * - 0 - Disable escape sequence detection * - 1 - Enable escape sequence detection */ //@{ #define BP_UART_UCR2_ESCEN (11) //!< Bit position for UART_UCR2_ESCEN. #define BM_UART_UCR2_ESCEN (0x00000800) //!< Bit mask for UART_UCR2_ESCEN. //! @brief Get value of UART_UCR2_ESCEN from a register value. #define BG_UART_UCR2_ESCEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_ESCEN) >> BP_UART_UCR2_ESCEN) //! @brief Format value for bitfield UART_UCR2_ESCEN. #define BF_UART_UCR2_ESCEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_ESCEN) & BM_UART_UCR2_ESCEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the ESCEN field to a new value. #define BW_UART_UCR2_ESCEN(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_ESCEN) | BF_UART_UCR2_ESCEN(v))) #endif //@} /*! @name Register UART_UCR2, field CTS[12] (RW) * * Clear to Send . Controls the CTS pin when the CTSC bit is negated. CTS has no function when CTSC * is asserted. * * Values: * - 0 - The CTS pin is high (inactive) * - 1 - The CTS pin is low (active) */ //@{ #define BP_UART_UCR2_CTS (12) //!< Bit position for UART_UCR2_CTS. #define BM_UART_UCR2_CTS (0x00001000) //!< Bit mask for UART_UCR2_CTS. //! @brief Get value of UART_UCR2_CTS from a register value. #define BG_UART_UCR2_CTS(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_CTS) >> BP_UART_UCR2_CTS) //! @brief Format value for bitfield UART_UCR2_CTS. #define BF_UART_UCR2_CTS(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_CTS) & BM_UART_UCR2_CTS) #ifndef __LANGUAGE_ASM__ //! @brief Set the CTS field to a new value. #define BW_UART_UCR2_CTS(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_CTS) | BF_UART_UCR2_CTS(v))) #endif //@} /*! @name Register UART_UCR2, field CTSC[13] (RW) * * CTS Pin Control . Controls the operation of the CTS output pin. When CTSC is asserted, the CTS * output pin is controlled by the receiver. When the RxFIFO is filled to the level of the * programmed trigger level and the start bit of the overflowing character (TRIGGER LEVEL + 1) is * validated, the CTS output pin is negated to indicate to the far-end transmitter to stop * transmitting. When the trigger level is programmed for less than 32, the receiver continues to * receive data until the RxFIFO is full. When the CTSC bit is negated, the CTS output pin is * controlled by the CTS bit. On reset, because CTSC is cleared to 0, the CTS pin is controlled by * the CTS bit, which again is cleared to 0 on reset. This means that on reset the CTS signal is * negated. * * Values: * - 0 - The CTS pin is controlled by the CTS bit * - 1 - The CTS pin is controlled by the receiver */ //@{ #define BP_UART_UCR2_CTSC (13) //!< Bit position for UART_UCR2_CTSC. #define BM_UART_UCR2_CTSC (0x00002000) //!< Bit mask for UART_UCR2_CTSC. //! @brief Get value of UART_UCR2_CTSC from a register value. #define BG_UART_UCR2_CTSC(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_CTSC) >> BP_UART_UCR2_CTSC) //! @brief Format value for bitfield UART_UCR2_CTSC. #define BF_UART_UCR2_CTSC(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_CTSC) & BM_UART_UCR2_CTSC) #ifndef __LANGUAGE_ASM__ //! @brief Set the CTSC field to a new value. #define BW_UART_UCR2_CTSC(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_CTSC) | BF_UART_UCR2_CTSC(v))) #endif //@} /*! @name Register UART_UCR2, field IRTS[14] (RW) * * Ignore RTS Pin . Forces the RTS input signal presented to the transmitter to always be asserted * (set to low), effectively ignoring the external pin. When in this mode, the RTS pin serves as a * general purpose input. * * Values: * - 0 - Transmit only when the RTS pin is asserted * - 1 - Ignore the RTS pin */ //@{ #define BP_UART_UCR2_IRTS (14) //!< Bit position for UART_UCR2_IRTS. #define BM_UART_UCR2_IRTS (0x00004000) //!< Bit mask for UART_UCR2_IRTS. //! @brief Get value of UART_UCR2_IRTS from a register value. #define BG_UART_UCR2_IRTS(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_IRTS) >> BP_UART_UCR2_IRTS) //! @brief Format value for bitfield UART_UCR2_IRTS. #define BF_UART_UCR2_IRTS(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_IRTS) & BM_UART_UCR2_IRTS) #ifndef __LANGUAGE_ASM__ //! @brief Set the IRTS field to a new value. #define BW_UART_UCR2_IRTS(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_IRTS) | BF_UART_UCR2_IRTS(v))) #endif //@} /*! @name Register UART_UCR2, field ESCI[15] (RW) * * Escape Sequence Interrupt Enable . Enables/Disables the ESCF bit to generate an interrupt. * * Values: * - 0 - Disable the escape sequence interrupt * - 1 - Enable the escape sequence interrupt */ //@{ #define BP_UART_UCR2_ESCI (15) //!< Bit position for UART_UCR2_ESCI. #define BM_UART_UCR2_ESCI (0x00008000) //!< Bit mask for UART_UCR2_ESCI. //! @brief Get value of UART_UCR2_ESCI from a register value. #define BG_UART_UCR2_ESCI(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR2_ESCI) >> BP_UART_UCR2_ESCI) //! @brief Format value for bitfield UART_UCR2_ESCI. #define BF_UART_UCR2_ESCI(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR2_ESCI) & BM_UART_UCR2_ESCI) #ifndef __LANGUAGE_ASM__ //! @brief Set the ESCI field to a new value. #define BW_UART_UCR2_ESCI(x, v) (HW_UART_UCR2_WR(x, (HW_UART_UCR2_RD(x) & ~BM_UART_UCR2_ESCI) | BF_UART_UCR2_ESCI(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UCR3 - UART Control Register 3 //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UCR3 - UART Control Register 3 (RW) * * Reset value: 0x00000700 */ typedef union _hw_uart_ucr3 { reg32_t U; struct _hw_uart_ucr3_bitfields { unsigned ACIEN : 1; //!< [0] Autobaud Counter Interrupt Enable. unsigned INVT : 1; //!< [1] Invert TXD output in RS-232/RS-485 mode, set TXD active level in IrDA mode. unsigned RXDMUXSEL : 1; //!< [2] RXD Muxed Input Selected. unsigned DTRDEN : 1; //!< [3] Data Terminal Ready Delta Enable . unsigned AWAKEN : 1; //!< [4] Asynchronous WAKE Interrupt Enable. unsigned AIRINTEN : 1; //!< [5] Asynchronous IR WAKE Interrupt Enable. unsigned RXDSEN : 1; //!< [6] Receive Status Interrupt Enable. unsigned ADNIMP : 1; //!< [7] Autobaud Detection Not Improved-. unsigned RI : 1; //!< [8] Ring Indicator . unsigned DCD : 1; //!< [9] Data Carrier Detect . unsigned DSR : 1; //!< [10] Data Set Ready . unsigned FRAERREN : 1; //!< [11] Frame Error Interrupt Enable. unsigned PARERREN : 1; //!< [12] Parity Error Interrupt Enable. unsigned DTREN : 1; //!< [13] Data Terminal Ready Interrupt Enable . unsigned DPEC : 2; //!< [15:14] DTR/DSR Interrupt Edge Control . unsigned RESERVED0 : 16; //!< [31:16] Reserved } B; } hw_uart_ucr3_t; #endif /*! * @name Constants and macros for entire UART_UCR3 register */ //@{ #define HW_UART_UCR3_ADDR(x) (REGS_UART_BASE(x) + 0x88) #ifndef __LANGUAGE_ASM__ #define HW_UART_UCR3(x) (*(volatile hw_uart_ucr3_t *) HW_UART_UCR3_ADDR(x)) #define HW_UART_UCR3_RD(x) (HW_UART_UCR3(x).U) #define HW_UART_UCR3_WR(x, v) (HW_UART_UCR3(x).U = (v)) #define HW_UART_UCR3_SET(x, v) (HW_UART_UCR3_WR(x, HW_UART_UCR3_RD(x) | (v))) #define HW_UART_UCR3_CLR(x, v) (HW_UART_UCR3_WR(x, HW_UART_UCR3_RD(x) & ~(v))) #define HW_UART_UCR3_TOG(x, v) (HW_UART_UCR3_WR(x, HW_UART_UCR3_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UCR3 bitfields */ /*! @name Register UART_UCR3, field ACIEN[0] (RW) * * Autobaud Counter Interrupt Enable. This bit is used to enable the autobaud counter stopped * interrupt (triggered with ACST (USR2[11]). * * Values: * - 0 - ACST interrupt disabled * - 1 - ACST interrupt enabled */ //@{ #define BP_UART_UCR3_ACIEN (0) //!< Bit position for UART_UCR3_ACIEN. #define BM_UART_UCR3_ACIEN (0x00000001) //!< Bit mask for UART_UCR3_ACIEN. //! @brief Get value of UART_UCR3_ACIEN from a register value. #define BG_UART_UCR3_ACIEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_ACIEN) >> BP_UART_UCR3_ACIEN) //! @brief Format value for bitfield UART_UCR3_ACIEN. #define BF_UART_UCR3_ACIEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_ACIEN) & BM_UART_UCR3_ACIEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the ACIEN field to a new value. #define BW_UART_UCR3_ACIEN(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_ACIEN) | BF_UART_UCR3_ACIEN(v))) #endif //@} /*! @name Register UART_UCR3, field INVT[1] (RW) * * Invert TXD output in RS-232/RS-485 mode, set TXD active level in IrDA mode. In RS232/RS-485 * mode(UMCR[0] = 1), if this bit is set to 1, the TXD output is inverted before transmitted. In * IrDA mode , when INVT is cleared, the infrared logic block transmits a positive IR 3/16 pulse for * all 0s and 0s are transmitted for 1s. When INVT is set (INVT = 1), the infrared logic block * transmits an active low or negative infrared 3/16 pulse for all 0s and 1s are transmitted for 1s. * * Values: * - 0 - TXD is not inverted * - 0 - TXD Active low transmission * - 1 - TXD is inverted * - 1 - TXD Active high transmission */ //@{ #define BP_UART_UCR3_INVT (1) //!< Bit position for UART_UCR3_INVT. #define BM_UART_UCR3_INVT (0x00000002) //!< Bit mask for UART_UCR3_INVT. //! @brief Get value of UART_UCR3_INVT from a register value. #define BG_UART_UCR3_INVT(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_INVT) >> BP_UART_UCR3_INVT) //! @brief Format value for bitfield UART_UCR3_INVT. #define BF_UART_UCR3_INVT(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_INVT) & BM_UART_UCR3_INVT) #ifndef __LANGUAGE_ASM__ //! @brief Set the INVT field to a new value. #define BW_UART_UCR3_INVT(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_INVT) | BF_UART_UCR3_INVT(v))) #endif //@} /*! @name Register UART_UCR3, field RXDMUXSEL[2] (RW) * * RXD Muxed Input Selected. Selects proper input pins for serial and Infrared input signal. In this * chip, UARTs are used in MUXED mode, so that this bit should always be set. */ //@{ #define BP_UART_UCR3_RXDMUXSEL (2) //!< Bit position for UART_UCR3_RXDMUXSEL. #define BM_UART_UCR3_RXDMUXSEL (0x00000004) //!< Bit mask for UART_UCR3_RXDMUXSEL. //! @brief Get value of UART_UCR3_RXDMUXSEL from a register value. #define BG_UART_UCR3_RXDMUXSEL(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_RXDMUXSEL) >> BP_UART_UCR3_RXDMUXSEL) //! @brief Format value for bitfield UART_UCR3_RXDMUXSEL. #define BF_UART_UCR3_RXDMUXSEL(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_RXDMUXSEL) & BM_UART_UCR3_RXDMUXSEL) #ifndef __LANGUAGE_ASM__ //! @brief Set the RXDMUXSEL field to a new value. #define BW_UART_UCR3_RXDMUXSEL(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_RXDMUXSEL) | BF_UART_UCR3_RXDMUXSEL(v))) #endif //@} /*! @name Register UART_UCR3, field DTRDEN[3] (RW) * * Data Terminal Ready Delta Enable . Enables / Disables the asynchronous DTRD interrupt. When * DTRDEN is asserted and an edge (rising or falling) is detected on DTR (in DCE mode) or on DSR (in * DTE mode), then an interrupt is generated. * * Values: * - 0 - Disable DTRD interrupt * - 1 - Enable DTRD interrupt */ //@{ #define BP_UART_UCR3_DTRDEN (3) //!< Bit position for UART_UCR3_DTRDEN. #define BM_UART_UCR3_DTRDEN (0x00000008) //!< Bit mask for UART_UCR3_DTRDEN. //! @brief Get value of UART_UCR3_DTRDEN from a register value. #define BG_UART_UCR3_DTRDEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_DTRDEN) >> BP_UART_UCR3_DTRDEN) //! @brief Format value for bitfield UART_UCR3_DTRDEN. #define BF_UART_UCR3_DTRDEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_DTRDEN) & BM_UART_UCR3_DTRDEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the DTRDEN field to a new value. #define BW_UART_UCR3_DTRDEN(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_DTRDEN) | BF_UART_UCR3_DTRDEN(v))) #endif //@} /*! @name Register UART_UCR3, field AWAKEN[4] (RW) * * Asynchronous WAKE Interrupt Enable. Controls the asynchronous WAKE interrupt. An interrupt is * generated when AWAKEN is asserted and a falling edge is detected on the RXD pin. * * Values: * - 0 - Disable the AWAKE interrupt * - 1 - Enable the AWAKE interrupt */ //@{ #define BP_UART_UCR3_AWAKEN (4) //!< Bit position for UART_UCR3_AWAKEN. #define BM_UART_UCR3_AWAKEN (0x00000010) //!< Bit mask for UART_UCR3_AWAKEN. //! @brief Get value of UART_UCR3_AWAKEN from a register value. #define BG_UART_UCR3_AWAKEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_AWAKEN) >> BP_UART_UCR3_AWAKEN) //! @brief Format value for bitfield UART_UCR3_AWAKEN. #define BF_UART_UCR3_AWAKEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_AWAKEN) & BM_UART_UCR3_AWAKEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the AWAKEN field to a new value. #define BW_UART_UCR3_AWAKEN(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_AWAKEN) | BF_UART_UCR3_AWAKEN(v))) #endif //@} /*! @name Register UART_UCR3, field AIRINTEN[5] (RW) * * Asynchronous IR WAKE Interrupt Enable. Controls the asynchronous IR WAKE interrupt. An interrupt * is generated when AIRINTEN is asserted and a pulse is detected on the RXD pin. * * Values: * - 0 - Disable the AIRINT interrupt * - 1 - Enable the AIRINT interrupt */ //@{ #define BP_UART_UCR3_AIRINTEN (5) //!< Bit position for UART_UCR3_AIRINTEN. #define BM_UART_UCR3_AIRINTEN (0x00000020) //!< Bit mask for UART_UCR3_AIRINTEN. //! @brief Get value of UART_UCR3_AIRINTEN from a register value. #define BG_UART_UCR3_AIRINTEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_AIRINTEN) >> BP_UART_UCR3_AIRINTEN) //! @brief Format value for bitfield UART_UCR3_AIRINTEN. #define BF_UART_UCR3_AIRINTEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_AIRINTEN) & BM_UART_UCR3_AIRINTEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the AIRINTEN field to a new value. #define BW_UART_UCR3_AIRINTEN(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_AIRINTEN) | BF_UART_UCR3_AIRINTEN(v))) #endif //@} /*! @name Register UART_UCR3, field RXDSEN[6] (RW) * * Receive Status Interrupt Enable. Controls the receive status interrupt ( interrupt_uart ). When * this bit is enabled and RXDS status bit is set, the interrupt interrupt_uart will be generated. * * Values: * - 0 - Disable the RXDS interrupt * - 1 - Enable the RXDS interrupt */ //@{ #define BP_UART_UCR3_RXDSEN (6) //!< Bit position for UART_UCR3_RXDSEN. #define BM_UART_UCR3_RXDSEN (0x00000040) //!< Bit mask for UART_UCR3_RXDSEN. //! @brief Get value of UART_UCR3_RXDSEN from a register value. #define BG_UART_UCR3_RXDSEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_RXDSEN) >> BP_UART_UCR3_RXDSEN) //! @brief Format value for bitfield UART_UCR3_RXDSEN. #define BF_UART_UCR3_RXDSEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_RXDSEN) & BM_UART_UCR3_RXDSEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the RXDSEN field to a new value. #define BW_UART_UCR3_RXDSEN(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_RXDSEN) | BF_UART_UCR3_RXDSEN(v))) #endif //@} /*! @name Register UART_UCR3, field ADNIMP[7] (RW) * * Autobaud Detection Not Improved-. Disables new features of autobaud detection (See , for more * details). * * Values: * - 0 - Autobaud detection new features selected * - 1 - Keep old autobaud detection mechanism */ //@{ #define BP_UART_UCR3_ADNIMP (7) //!< Bit position for UART_UCR3_ADNIMP. #define BM_UART_UCR3_ADNIMP (0x00000080) //!< Bit mask for UART_UCR3_ADNIMP. //! @brief Get value of UART_UCR3_ADNIMP from a register value. #define BG_UART_UCR3_ADNIMP(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_ADNIMP) >> BP_UART_UCR3_ADNIMP) //! @brief Format value for bitfield UART_UCR3_ADNIMP. #define BF_UART_UCR3_ADNIMP(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_ADNIMP) & BM_UART_UCR3_ADNIMP) #ifndef __LANGUAGE_ASM__ //! @brief Set the ADNIMP field to a new value. #define BW_UART_UCR3_ADNIMP(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_ADNIMP) | BF_UART_UCR3_ADNIMP(v))) #endif //@} /*! @name Register UART_UCR3, field RI[8] (RW) * * Ring Indicator . In DCE mode this bit is used by software to control the RI output pin for the * modem interface. In DTE mode, when this bit is set, it will enable the status bit RIDELT (USR2 * (10)) to cause an interrupt. * * Values: * - 0 - RI pin is logic zero (DCE mode) * - 0 - RIDELT interrupt disabled (DTE mode) * - 1 - RI pin is logic one (DCE mode) * - 1 - RIDELT interrupt enabled (DTE mode) */ //@{ #define BP_UART_UCR3_RI (8) //!< Bit position for UART_UCR3_RI. #define BM_UART_UCR3_RI (0x00000100) //!< Bit mask for UART_UCR3_RI. //! @brief Get value of UART_UCR3_RI from a register value. #define BG_UART_UCR3_RI(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_RI) >> BP_UART_UCR3_RI) //! @brief Format value for bitfield UART_UCR3_RI. #define BF_UART_UCR3_RI(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_RI) & BM_UART_UCR3_RI) #ifndef __LANGUAGE_ASM__ //! @brief Set the RI field to a new value. #define BW_UART_UCR3_RI(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_RI) | BF_UART_UCR3_RI(v))) #endif //@} /*! @name Register UART_UCR3, field DCD[9] (RW) * * Data Carrier Detect . In DCE mode this bit is used by software to control the DCD output pin for * the modem interface. In DTE mode, when this bit is set, it will enable the status bit DCDDELT * (USR2 (6)) to cause an interrupt. * * Values: * - 0 - DCD pin is logic zero (DCE mode) * - 0 - DCDDELT interrupt disabled (DTE mode) * - 1 - DCD pin is logic one (DCE mode) * - 1 - DCDDELT interrupt enabled (DTE mode) */ //@{ #define BP_UART_UCR3_DCD (9) //!< Bit position for UART_UCR3_DCD. #define BM_UART_UCR3_DCD (0x00000200) //!< Bit mask for UART_UCR3_DCD. //! @brief Get value of UART_UCR3_DCD from a register value. #define BG_UART_UCR3_DCD(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_DCD) >> BP_UART_UCR3_DCD) //! @brief Format value for bitfield UART_UCR3_DCD. #define BF_UART_UCR3_DCD(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_DCD) & BM_UART_UCR3_DCD) #ifndef __LANGUAGE_ASM__ //! @brief Set the DCD field to a new value. #define BW_UART_UCR3_DCD(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_DCD) | BF_UART_UCR3_DCD(v))) #endif //@} /*! @name Register UART_UCR3, field DSR[10] (RW) * * Data Set Ready . This bit is used by software to control the DSR/DTR output pin for the modem * interface. In DCE mode it applies to DSR and in DTE mode it applies to DTR . * * Values: * - 0 - DSR/ DTR pin is logic zero * - 1 - DSR/ DTR pin is logic one */ //@{ #define BP_UART_UCR3_DSR (10) //!< Bit position for UART_UCR3_DSR. #define BM_UART_UCR3_DSR (0x00000400) //!< Bit mask for UART_UCR3_DSR. //! @brief Get value of UART_UCR3_DSR from a register value. #define BG_UART_UCR3_DSR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_DSR) >> BP_UART_UCR3_DSR) //! @brief Format value for bitfield UART_UCR3_DSR. #define BF_UART_UCR3_DSR(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_DSR) & BM_UART_UCR3_DSR) #ifndef __LANGUAGE_ASM__ //! @brief Set the DSR field to a new value. #define BW_UART_UCR3_DSR(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_DSR) | BF_UART_UCR3_DSR(v))) #endif //@} /*! @name Register UART_UCR3, field FRAERREN[11] (RW) * * Frame Error Interrupt Enable. Enables/Disables the interrupt. When asserted, FRAERREN causes the * FRAMERR bit to generate an interrupt. * * Values: * - 0 - Disable the frame error interrupt * - 1 - Enable the frame error interrupt */ //@{ #define BP_UART_UCR3_FRAERREN (11) //!< Bit position for UART_UCR3_FRAERREN. #define BM_UART_UCR3_FRAERREN (0x00000800) //!< Bit mask for UART_UCR3_FRAERREN. //! @brief Get value of UART_UCR3_FRAERREN from a register value. #define BG_UART_UCR3_FRAERREN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_FRAERREN) >> BP_UART_UCR3_FRAERREN) //! @brief Format value for bitfield UART_UCR3_FRAERREN. #define BF_UART_UCR3_FRAERREN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_FRAERREN) & BM_UART_UCR3_FRAERREN) #ifndef __LANGUAGE_ASM__ //! @brief Set the FRAERREN field to a new value. #define BW_UART_UCR3_FRAERREN(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_FRAERREN) | BF_UART_UCR3_FRAERREN(v))) #endif //@} /*! @name Register UART_UCR3, field PARERREN[12] (RW) * * Parity Error Interrupt Enable. Enables/Disables the interrupt. When asserted, PARERREN causes the * PARITYERR bit to generate an interrupt. * * Values: * - 0 - Disable the parity error interrupt * - 1 - Enable the parity error interrupt */ //@{ #define BP_UART_UCR3_PARERREN (12) //!< Bit position for UART_UCR3_PARERREN. #define BM_UART_UCR3_PARERREN (0x00001000) //!< Bit mask for UART_UCR3_PARERREN. //! @brief Get value of UART_UCR3_PARERREN from a register value. #define BG_UART_UCR3_PARERREN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_PARERREN) >> BP_UART_UCR3_PARERREN) //! @brief Format value for bitfield UART_UCR3_PARERREN. #define BF_UART_UCR3_PARERREN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_PARERREN) & BM_UART_UCR3_PARERREN) #ifndef __LANGUAGE_ASM__ //! @brief Set the PARERREN field to a new value. #define BW_UART_UCR3_PARERREN(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_PARERREN) | BF_UART_UCR3_PARERREN(v))) #endif //@} /*! @name Register UART_UCR3, field DTREN[13] (RW) * * Data Terminal Ready Interrupt Enable . When this bit is set, it will enable the status bit DTRF * (USR2 [13]) (DTR/DSR edge sensitive interrupt) to cause an interrupt. * * Values: * - 0 - Data Terminal Ready Interrupt Disabled * - 1 - Data Terminal Ready Interrupt Enabled */ //@{ #define BP_UART_UCR3_DTREN (13) //!< Bit position for UART_UCR3_DTREN. #define BM_UART_UCR3_DTREN (0x00002000) //!< Bit mask for UART_UCR3_DTREN. //! @brief Get value of UART_UCR3_DTREN from a register value. #define BG_UART_UCR3_DTREN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_DTREN) >> BP_UART_UCR3_DTREN) //! @brief Format value for bitfield UART_UCR3_DTREN. #define BF_UART_UCR3_DTREN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_DTREN) & BM_UART_UCR3_DTREN) #ifndef __LANGUAGE_ASM__ //! @brief Set the DTREN field to a new value. #define BW_UART_UCR3_DTREN(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_DTREN) | BF_UART_UCR3_DTREN(v))) #endif //@} /*! @name Register UART_UCR3, field DPEC[15:14] (RW) * * DTR/DSR Interrupt Edge Control . These bits control the edge of DTR (DCE) or DSR (DTE) on which * an interrupt will be generated. An interrupt will only be generated if the DTREN bit is set. * * Values: * - 00 - interrupt generated on rising edge * - 01 - interrupt generated on falling edge * - 1X - interrupt generated on either edge */ //@{ #define BP_UART_UCR3_DPEC (14) //!< Bit position for UART_UCR3_DPEC. #define BM_UART_UCR3_DPEC (0x0000c000) //!< Bit mask for UART_UCR3_DPEC. //! @brief Get value of UART_UCR3_DPEC from a register value. #define BG_UART_UCR3_DPEC(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR3_DPEC) >> BP_UART_UCR3_DPEC) //! @brief Format value for bitfield UART_UCR3_DPEC. #define BF_UART_UCR3_DPEC(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR3_DPEC) & BM_UART_UCR3_DPEC) #ifndef __LANGUAGE_ASM__ //! @brief Set the DPEC field to a new value. #define BW_UART_UCR3_DPEC(x, v) (HW_UART_UCR3_WR(x, (HW_UART_UCR3_RD(x) & ~BM_UART_UCR3_DPEC) | BF_UART_UCR3_DPEC(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UCR4 - UART Control Register 4 //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UCR4 - UART Control Register 4 (RW) * * Reset value: 0x00008000 */ typedef union _hw_uart_ucr4 { reg32_t U; struct _hw_uart_ucr4_bitfields { unsigned DREN : 1; //!< [0] Receive Data Ready Interrupt Enable . unsigned OREN : 1; //!< [1] Receiver Overrun Interrupt Enable . unsigned BKEN : 1; //!< [2] BREAK Condition Detected Interrupt Enable . unsigned TCEN : 1; //!< [3] Transmit Complete Interrupt Enable . unsigned LPBYP : 1; //!< [4] Low Power Bypass . unsigned IRSC : 1; //!< [5] IR Special Case . unsigned IDDMAEN : 1; //!< [6] DMA IDLE Condition Detected Interrupt Enable Enables/Disables the receive DMA request dma_req_rx for the IDLE interrupt (triggered with IDLE flag in USR2[12]). unsigned WKEN : 1; //!< [7] WAKE Interrupt Enable . unsigned ENIRI : 1; //!< [8] Serial Infrared Interrupt Enable . unsigned INVR : 1; //!< [9] Invert RXD input in RS-232/RS-485 Mode, d etermine RXD input logic level being sampled in In IrDA mode. unsigned CTSTL : 6; //!< [15:10] CTS Trigger Level . unsigned RESERVED0 : 16; //!< [31:16] Reserved } B; } hw_uart_ucr4_t; #endif /*! * @name Constants and macros for entire UART_UCR4 register */ //@{ #define HW_UART_UCR4_ADDR(x) (REGS_UART_BASE(x) + 0x8c) #ifndef __LANGUAGE_ASM__ #define HW_UART_UCR4(x) (*(volatile hw_uart_ucr4_t *) HW_UART_UCR4_ADDR(x)) #define HW_UART_UCR4_RD(x) (HW_UART_UCR4(x).U) #define HW_UART_UCR4_WR(x, v) (HW_UART_UCR4(x).U = (v)) #define HW_UART_UCR4_SET(x, v) (HW_UART_UCR4_WR(x, HW_UART_UCR4_RD(x) | (v))) #define HW_UART_UCR4_CLR(x, v) (HW_UART_UCR4_WR(x, HW_UART_UCR4_RD(x) & ~(v))) #define HW_UART_UCR4_TOG(x, v) (HW_UART_UCR4_WR(x, HW_UART_UCR4_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UCR4 bitfields */ /*! @name Register UART_UCR4, field DREN[0] (RW) * * Receive Data Ready Interrupt Enable . Enables/Disables the RDR bit to generate an interrupt. * * Values: * - 0 - Disable RDR interrupt * - 1 - Enable RDR interrupt */ //@{ #define BP_UART_UCR4_DREN (0) //!< Bit position for UART_UCR4_DREN. #define BM_UART_UCR4_DREN (0x00000001) //!< Bit mask for UART_UCR4_DREN. //! @brief Get value of UART_UCR4_DREN from a register value. #define BG_UART_UCR4_DREN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_DREN) >> BP_UART_UCR4_DREN) //! @brief Format value for bitfield UART_UCR4_DREN. #define BF_UART_UCR4_DREN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_DREN) & BM_UART_UCR4_DREN) #ifndef __LANGUAGE_ASM__ //! @brief Set the DREN field to a new value. #define BW_UART_UCR4_DREN(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_DREN) | BF_UART_UCR4_DREN(v))) #endif //@} /*! @name Register UART_UCR4, field OREN[1] (RW) * * Receiver Overrun Interrupt Enable . Enables/Disables the ORE bit to generate an interrupt. * * Values: * - 0 - Disable ORE interrupt * - 1 - Enable ORE interrupt */ //@{ #define BP_UART_UCR4_OREN (1) //!< Bit position for UART_UCR4_OREN. #define BM_UART_UCR4_OREN (0x00000002) //!< Bit mask for UART_UCR4_OREN. //! @brief Get value of UART_UCR4_OREN from a register value. #define BG_UART_UCR4_OREN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_OREN) >> BP_UART_UCR4_OREN) //! @brief Format value for bitfield UART_UCR4_OREN. #define BF_UART_UCR4_OREN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_OREN) & BM_UART_UCR4_OREN) #ifndef __LANGUAGE_ASM__ //! @brief Set the OREN field to a new value. #define BW_UART_UCR4_OREN(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_OREN) | BF_UART_UCR4_OREN(v))) #endif //@} /*! @name Register UART_UCR4, field BKEN[2] (RW) * * BREAK Condition Detected Interrupt Enable . Enables/Disables the BRCD bit to generate an * interrupt. * * Values: * - 0 - Disable the BRCD interrupt * - 1 - Enable the BRCD interrupt */ //@{ #define BP_UART_UCR4_BKEN (2) //!< Bit position for UART_UCR4_BKEN. #define BM_UART_UCR4_BKEN (0x00000004) //!< Bit mask for UART_UCR4_BKEN. //! @brief Get value of UART_UCR4_BKEN from a register value. #define BG_UART_UCR4_BKEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_BKEN) >> BP_UART_UCR4_BKEN) //! @brief Format value for bitfield UART_UCR4_BKEN. #define BF_UART_UCR4_BKEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_BKEN) & BM_UART_UCR4_BKEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the BKEN field to a new value. #define BW_UART_UCR4_BKEN(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_BKEN) | BF_UART_UCR4_BKEN(v))) #endif //@} /*! @name Register UART_UCR4, field TCEN[3] (RW) * * Transmit Complete Interrupt Enable . Enables/Disables the TXDC bit to generate an interrupt ( * interrupt_uart = 0) An interrupt will be issued as long as TCEN and TXDC are high even if the * transmitter is not enabled. In general, user should enable the transmitter before enabling the * TXDC interrupt. * * Values: * - 0 - Disable TXDC interrupt * - 1 - Enable TXDC interrupt */ //@{ #define BP_UART_UCR4_TCEN (3) //!< Bit position for UART_UCR4_TCEN. #define BM_UART_UCR4_TCEN (0x00000008) //!< Bit mask for UART_UCR4_TCEN. //! @brief Get value of UART_UCR4_TCEN from a register value. #define BG_UART_UCR4_TCEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_TCEN) >> BP_UART_UCR4_TCEN) //! @brief Format value for bitfield UART_UCR4_TCEN. #define BF_UART_UCR4_TCEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_TCEN) & BM_UART_UCR4_TCEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the TCEN field to a new value. #define BW_UART_UCR4_TCEN(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_TCEN) | BF_UART_UCR4_TCEN(v))) #endif //@} /*! @name Register UART_UCR4, field LPBYP[4] (RW) * * Low Power Bypass . Allows to bypass the low power new features in UART. To use during debug * phase. * * Values: * - 0 - Low power features enabled * - 1 - Low power features disabled */ //@{ #define BP_UART_UCR4_LPBYP (4) //!< Bit position for UART_UCR4_LPBYP. #define BM_UART_UCR4_LPBYP (0x00000010) //!< Bit mask for UART_UCR4_LPBYP. //! @brief Get value of UART_UCR4_LPBYP from a register value. #define BG_UART_UCR4_LPBYP(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_LPBYP) >> BP_UART_UCR4_LPBYP) //! @brief Format value for bitfield UART_UCR4_LPBYP. #define BF_UART_UCR4_LPBYP(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_LPBYP) & BM_UART_UCR4_LPBYP) #ifndef __LANGUAGE_ASM__ //! @brief Set the LPBYP field to a new value. #define BW_UART_UCR4_LPBYP(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_LPBYP) | BF_UART_UCR4_LPBYP(v))) #endif //@} /*! @name Register UART_UCR4, field IRSC[5] (RW) * * IR Special Case . Selects the clock for the vote logic. When set, IRSC switches the vote logic * clock from the sampling clock to the UART reference clock. The IR pulses are counted a * predetermined amount of time depending on the reference frequency. See . * * Values: * - 0 - The vote logic uses the sampling clock (16x baud rate) for normal operation * - 1 - The vote logic uses the UART reference clock */ //@{ #define BP_UART_UCR4_IRSC (5) //!< Bit position for UART_UCR4_IRSC. #define BM_UART_UCR4_IRSC (0x00000020) //!< Bit mask for UART_UCR4_IRSC. //! @brief Get value of UART_UCR4_IRSC from a register value. #define BG_UART_UCR4_IRSC(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_IRSC) >> BP_UART_UCR4_IRSC) //! @brief Format value for bitfield UART_UCR4_IRSC. #define BF_UART_UCR4_IRSC(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_IRSC) & BM_UART_UCR4_IRSC) #ifndef __LANGUAGE_ASM__ //! @brief Set the IRSC field to a new value. #define BW_UART_UCR4_IRSC(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_IRSC) | BF_UART_UCR4_IRSC(v))) #endif //@} /*! @name Register UART_UCR4, field IDDMAEN[6] (RW) * * DMA IDLE Condition Detected Interrupt Enable Enables/Disables the receive DMA request dma_req_rx * for the IDLE interrupt (triggered with IDLE flag in USR2[12]). * * Values: * - 0 - DMA IDLE interrupt disabled * - 1 - DMA IDLE interrupt enabled */ //@{ #define BP_UART_UCR4_IDDMAEN (6) //!< Bit position for UART_UCR4_IDDMAEN. #define BM_UART_UCR4_IDDMAEN (0x00000040) //!< Bit mask for UART_UCR4_IDDMAEN. //! @brief Get value of UART_UCR4_IDDMAEN from a register value. #define BG_UART_UCR4_IDDMAEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_IDDMAEN) >> BP_UART_UCR4_IDDMAEN) //! @brief Format value for bitfield UART_UCR4_IDDMAEN. #define BF_UART_UCR4_IDDMAEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_IDDMAEN) & BM_UART_UCR4_IDDMAEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the IDDMAEN field to a new value. #define BW_UART_UCR4_IDDMAEN(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_IDDMAEN) | BF_UART_UCR4_IDDMAEN(v))) #endif //@} /*! @name Register UART_UCR4, field WKEN[7] (RW) * * WAKE Interrupt Enable . Enables/Disables the WAKE bit to generate an interrupt. The WAKE bit is * set at the detection of a start bit by the receiver. * * Values: * - 0 - Disable the WAKE interrupt * - 1 - Enable the WAKE interrupt */ //@{ #define BP_UART_UCR4_WKEN (7) //!< Bit position for UART_UCR4_WKEN. #define BM_UART_UCR4_WKEN (0x00000080) //!< Bit mask for UART_UCR4_WKEN. //! @brief Get value of UART_UCR4_WKEN from a register value. #define BG_UART_UCR4_WKEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_WKEN) >> BP_UART_UCR4_WKEN) //! @brief Format value for bitfield UART_UCR4_WKEN. #define BF_UART_UCR4_WKEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_WKEN) & BM_UART_UCR4_WKEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the WKEN field to a new value. #define BW_UART_UCR4_WKEN(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_WKEN) | BF_UART_UCR4_WKEN(v))) #endif //@} /*! @name Register UART_UCR4, field ENIRI[8] (RW) * * Serial Infrared Interrupt Enable . Enables/Disables the serial infrared interrupt. * * Values: * - 0 - Serial infrared Interrupt disabled * - 1 - Serial infrared Interrupt enabled */ //@{ #define BP_UART_UCR4_ENIRI (8) //!< Bit position for UART_UCR4_ENIRI. #define BM_UART_UCR4_ENIRI (0x00000100) //!< Bit mask for UART_UCR4_ENIRI. //! @brief Get value of UART_UCR4_ENIRI from a register value. #define BG_UART_UCR4_ENIRI(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_ENIRI) >> BP_UART_UCR4_ENIRI) //! @brief Format value for bitfield UART_UCR4_ENIRI. #define BF_UART_UCR4_ENIRI(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_ENIRI) & BM_UART_UCR4_ENIRI) #ifndef __LANGUAGE_ASM__ //! @brief Set the ENIRI field to a new value. #define BW_UART_UCR4_ENIRI(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_ENIRI) | BF_UART_UCR4_ENIRI(v))) #endif //@} /*! @name Register UART_UCR4, field INVR[9] (RW) * * Invert RXD input in RS-232/RS-485 Mode, d etermine RXD input logic level being sampled in In IrDA * mode. In RS232/RS-485 Mode(UMCR[0] = 1), if this bit is set to 1, the RXD input is inverted * before sampled. In IrDA mode ,when cleared, the infrared logic block expects an active low or * negative IR 3/16 pulse for 0s and 1s are expected for 1s. When INVR is set (INVR 1), the infrared * logic block expects an active high or positive IR 3/16 pulse for 0s and 0s are expected for 1s. * * Values: * - 0 - RXD input is not inverted * - 0 - RXD active low detection * - 1 - RXD input is inverted * - 1 - RXD active high detection */ //@{ #define BP_UART_UCR4_INVR (9) //!< Bit position for UART_UCR4_INVR. #define BM_UART_UCR4_INVR (0x00000200) //!< Bit mask for UART_UCR4_INVR. //! @brief Get value of UART_UCR4_INVR from a register value. #define BG_UART_UCR4_INVR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_INVR) >> BP_UART_UCR4_INVR) //! @brief Format value for bitfield UART_UCR4_INVR. #define BF_UART_UCR4_INVR(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_INVR) & BM_UART_UCR4_INVR) #ifndef __LANGUAGE_ASM__ //! @brief Set the INVR field to a new value. #define BW_UART_UCR4_INVR(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_INVR) | BF_UART_UCR4_INVR(v))) #endif //@} /*! @name Register UART_UCR4, field CTSTL[15:10] (RW) * * CTS Trigger Level . Controls the threshold at which the CTS pin is deasserted by the RxFIFO. * After the trigger level is reached and the CTS pin is deasserted, the RxFIFO continues to receive * data until it is full. The CTSTL bits are encoded as shown in the Settings column. Settings 0 to * 32 are in use. All other settings are Reserved. * * Values: * - 000000 - 0 characters received * - ... - * - ... - * - 000001 - 1 characters in the RxFIFO * - 100000 - 32 characters in the RxFIFO (maximum) */ //@{ #define BP_UART_UCR4_CTSTL (10) //!< Bit position for UART_UCR4_CTSTL. #define BM_UART_UCR4_CTSTL (0x0000fc00) //!< Bit mask for UART_UCR4_CTSTL. //! @brief Get value of UART_UCR4_CTSTL from a register value. #define BG_UART_UCR4_CTSTL(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UCR4_CTSTL) >> BP_UART_UCR4_CTSTL) //! @brief Format value for bitfield UART_UCR4_CTSTL. #define BF_UART_UCR4_CTSTL(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UCR4_CTSTL) & BM_UART_UCR4_CTSTL) #ifndef __LANGUAGE_ASM__ //! @brief Set the CTSTL field to a new value. #define BW_UART_UCR4_CTSTL(x, v) (HW_UART_UCR4_WR(x, (HW_UART_UCR4_RD(x) & ~BM_UART_UCR4_CTSTL) | BF_UART_UCR4_CTSTL(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UFCR - UART FIFO Control Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UFCR - UART FIFO Control Register (RW) * * Reset value: 0x00000801 */ typedef union _hw_uart_ufcr { reg32_t U; struct _hw_uart_ufcr_bitfields { unsigned RXTL : 6; //!< [5:0] Receiver Trigger Level . unsigned DCEDTE : 1; //!< [6] DCE/DTE mode select . unsigned RFDIV : 3; //!< [9:7] Reference Frequency Divider. unsigned TXTL : 6; //!< [15:10] Transmitter Trigger Level . unsigned RESERVED0 : 16; //!< [31:16] Reserved } B; } hw_uart_ufcr_t; #endif /*! * @name Constants and macros for entire UART_UFCR register */ //@{ #define HW_UART_UFCR_ADDR(x) (REGS_UART_BASE(x) + 0x90) #ifndef __LANGUAGE_ASM__ #define HW_UART_UFCR(x) (*(volatile hw_uart_ufcr_t *) HW_UART_UFCR_ADDR(x)) #define HW_UART_UFCR_RD(x) (HW_UART_UFCR(x).U) #define HW_UART_UFCR_WR(x, v) (HW_UART_UFCR(x).U = (v)) #define HW_UART_UFCR_SET(x, v) (HW_UART_UFCR_WR(x, HW_UART_UFCR_RD(x) | (v))) #define HW_UART_UFCR_CLR(x, v) (HW_UART_UFCR_WR(x, HW_UART_UFCR_RD(x) & ~(v))) #define HW_UART_UFCR_TOG(x, v) (HW_UART_UFCR_WR(x, HW_UART_UFCR_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UFCR bitfields */ /*! @name Register UART_UFCR, field RXTL[5:0] (RW) * * Receiver Trigger Level . Controls the threshold at which a maskable interrupt is generated by the * RxFIFO. A maskable interrupt is generated whenever the data level in the RxFIFO reaches the * selected threshold. The RXTL bits are encoded as shown in the Settings column. Setting 0 to 32 * are in use. All other settings are Reserved. * * Values: * - 000000 - 0 characters received * - ... - * - ... - * - 000001 - RxFIFO has 1 character * - 011111 - RxFIFO has 31 characters * - 100000 - RxFIFO has 32 characters (maximum) */ //@{ #define BP_UART_UFCR_RXTL (0) //!< Bit position for UART_UFCR_RXTL. #define BM_UART_UFCR_RXTL (0x0000003f) //!< Bit mask for UART_UFCR_RXTL. //! @brief Get value of UART_UFCR_RXTL from a register value. #define BG_UART_UFCR_RXTL(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UFCR_RXTL) >> BP_UART_UFCR_RXTL) //! @brief Format value for bitfield UART_UFCR_RXTL. #define BF_UART_UFCR_RXTL(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UFCR_RXTL) & BM_UART_UFCR_RXTL) #ifndef __LANGUAGE_ASM__ //! @brief Set the RXTL field to a new value. #define BW_UART_UFCR_RXTL(x, v) (HW_UART_UFCR_WR(x, (HW_UART_UFCR_RD(x) & ~BM_UART_UFCR_RXTL) | BF_UART_UFCR_RXTL(v))) #endif //@} /*! @name Register UART_UFCR, field DCEDTE[6] (RW) * * DCE/DTE mode select . Select UART as data communication equipment (DCE mode) or as data terminal * equipment (DTE mode). * * Values: * - 0 - DCE mode selected * - 1 - DTE mode selected */ //@{ #define BP_UART_UFCR_DCEDTE (6) //!< Bit position for UART_UFCR_DCEDTE. #define BM_UART_UFCR_DCEDTE (0x00000040) //!< Bit mask for UART_UFCR_DCEDTE. //! @brief Get value of UART_UFCR_DCEDTE from a register value. #define BG_UART_UFCR_DCEDTE(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UFCR_DCEDTE) >> BP_UART_UFCR_DCEDTE) //! @brief Format value for bitfield UART_UFCR_DCEDTE. #define BF_UART_UFCR_DCEDTE(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UFCR_DCEDTE) & BM_UART_UFCR_DCEDTE) #ifndef __LANGUAGE_ASM__ //! @brief Set the DCEDTE field to a new value. #define BW_UART_UFCR_DCEDTE(x, v) (HW_UART_UFCR_WR(x, (HW_UART_UFCR_RD(x) & ~BM_UART_UFCR_DCEDTE) | BF_UART_UFCR_DCEDTE(v))) #endif //@} /*! @name Register UART_UFCR, field RFDIV[9:7] (RW) * * Reference Frequency Divider. Controls the divide ratio for the reference clock. The input clock * is module_clock . The output from the divider is ref_clk which is used by BRM to create the 16x * baud rate oversampling clock ( brm_clk ). * * Values: * - 000 - Divide input clock by 6 * - 001 - Divide input clock by 5 * - 010 - Divide input clock by 4 * - 011 - Divide input clock by 3 * - 100 - Divide input clock by 2 * - 101 - Divide input clock by 1 * - 110 - Divide input clock by 7 * - 111 - Reserved */ //@{ #define BP_UART_UFCR_RFDIV (7) //!< Bit position for UART_UFCR_RFDIV. #define BM_UART_UFCR_RFDIV (0x00000380) //!< Bit mask for UART_UFCR_RFDIV. //! @brief Get value of UART_UFCR_RFDIV from a register value. #define BG_UART_UFCR_RFDIV(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UFCR_RFDIV) >> BP_UART_UFCR_RFDIV) //! @brief Format value for bitfield UART_UFCR_RFDIV. #define BF_UART_UFCR_RFDIV(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UFCR_RFDIV) & BM_UART_UFCR_RFDIV) #ifndef __LANGUAGE_ASM__ //! @brief Set the RFDIV field to a new value. #define BW_UART_UFCR_RFDIV(x, v) (HW_UART_UFCR_WR(x, (HW_UART_UFCR_RD(x) & ~BM_UART_UFCR_RFDIV) | BF_UART_UFCR_RFDIV(v))) #endif //@} /*! @name Register UART_UFCR, field TXTL[15:10] (RW) * * Transmitter Trigger Level . Controls the threshold at which a maskable interrupt is generated by * the TxFIFO. A maskable interrupt is generated whenever the data level in the TxFIFO falls below * the selected threshold. The bits are encoded as shown in the Settings column. Settings 0 to 32 * are in use. All other settings are Reserved. * * Values: * - 000000 - Reserved * - ... - * - ... - * - 000001 - Reserved * - 000010 - TxFIFO has 2 or fewer characters * - 011111 - TxFIFO has 31 or fewer characters * - 100000 - TxFIFO has 32 characters (maximum) */ //@{ #define BP_UART_UFCR_TXTL (10) //!< Bit position for UART_UFCR_TXTL. #define BM_UART_UFCR_TXTL (0x0000fc00) //!< Bit mask for UART_UFCR_TXTL. //! @brief Get value of UART_UFCR_TXTL from a register value. #define BG_UART_UFCR_TXTL(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UFCR_TXTL) >> BP_UART_UFCR_TXTL) //! @brief Format value for bitfield UART_UFCR_TXTL. #define BF_UART_UFCR_TXTL(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UFCR_TXTL) & BM_UART_UFCR_TXTL) #ifndef __LANGUAGE_ASM__ //! @brief Set the TXTL field to a new value. #define BW_UART_UFCR_TXTL(x, v) (HW_UART_UFCR_WR(x, (HW_UART_UFCR_RD(x) & ~BM_UART_UFCR_TXTL) | BF_UART_UFCR_TXTL(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_USR1 - UART Status Register 1 //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_USR1 - UART Status Register 1 (RW) * * Reset value: 0x00002040 */ typedef union _hw_uart_usr1 { reg32_t U; struct _hw_uart_usr1_bitfields { unsigned RESERVED0 : 3; //!< [2:0] Reserved unsigned SAD : 1; //!< [3] RS-485 Slave Address Detected Interrupt Flag. unsigned AWAKE : 1; //!< [4] Asynchronous WAKE Interrupt Flag. unsigned AIRINT : 1; //!< [5] Asynchronous IR WAKE Interrupt Flag. unsigned RXDS : 1; //!< [6] Receiver IDLE Interrupt Flag. unsigned DTRD : 1; //!< [7] DTR Delta. unsigned AGTIM : 1; //!< [8] Ageing Timer Interrupt Flag. unsigned RRDY : 1; //!< [9] Receiver Ready Interrupt / DMA Flag . unsigned FRAMERR : 1; //!< [10] Frame Error Interrupt Flag . unsigned ESCF : 1; //!< [11] Escape Sequence Interrupt Flag . unsigned RTSD : 1; //!< [12] RTS Delta. unsigned TRDY : 1; //!< [13] Transmitter Ready Interrupt / DMA Flag . unsigned RTSS : 1; //!< [14] RTS Pin Status . unsigned PARITYERR : 1; //!< [15] Parity Error Interrupt Flag . unsigned RESERVED1 : 16; //!< [31:16] Reserved } B; } hw_uart_usr1_t; #endif /*! * @name Constants and macros for entire UART_USR1 register */ //@{ #define HW_UART_USR1_ADDR(x) (REGS_UART_BASE(x) + 0x94) #ifndef __LANGUAGE_ASM__ #define HW_UART_USR1(x) (*(volatile hw_uart_usr1_t *) HW_UART_USR1_ADDR(x)) #define HW_UART_USR1_RD(x) (HW_UART_USR1(x).U) #define HW_UART_USR1_WR(x, v) (HW_UART_USR1(x).U = (v)) #define HW_UART_USR1_SET(x, v) (HW_UART_USR1_WR(x, HW_UART_USR1_RD(x) | (v))) #define HW_UART_USR1_CLR(x, v) (HW_UART_USR1_WR(x, HW_UART_USR1_RD(x) & ~(v))) #define HW_UART_USR1_TOG(x, v) (HW_UART_USR1_WR(x, HW_UART_USR1_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_USR1 bitfields */ /*! @name Register UART_USR1, field SAD[3] (W1C) * * RS-485 Slave Address Detected Interrupt Flag. Indicates if RS-485 Slave Address was detected . * SAD was asserted in RS-485 mode when the SADEN bit is set and Slave Address is detected in RxFIFO * (in Nomal Address Detect Mode, the 9 th data bit = 1; in Automatic Address Detect Mode, the * received charater matches the programmed SLADDR). * * Values: * - 0 - No slave address detected * - 1 - Slave address detected */ //@{ #define BP_UART_USR1_SAD (3) //!< Bit position for UART_USR1_SAD. #define BM_UART_USR1_SAD (0x00000008) //!< Bit mask for UART_USR1_SAD. //! @brief Get value of UART_USR1_SAD from a register value. #define BG_UART_USR1_SAD(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_SAD) >> BP_UART_USR1_SAD) //! @brief Format value for bitfield UART_USR1_SAD. #define BF_UART_USR1_SAD(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR1_SAD) & BM_UART_USR1_SAD) #ifndef __LANGUAGE_ASM__ //! @brief Set the SAD field to a new value. #define BW_UART_USR1_SAD(x, v) (HW_UART_USR1_WR(x, (HW_UART_USR1_RD(x) & ~BM_UART_USR1_SAD) | BF_UART_USR1_SAD(v))) #endif //@} /*! @name Register UART_USR1, field AWAKE[4] (W1C) * * Asynchronous WAKE Interrupt Flag. Indicates that a falling edge was detected on the RXD pin. * Clear AWAKE by writing 1 to it. Writing 0 to AWAKE has no effect. * * Values: * - 0 - No falling edge was detected on the RXD Serial pin * - 1 - A falling edge was detected on the RXD Serial pin */ //@{ #define BP_UART_USR1_AWAKE (4) //!< Bit position for UART_USR1_AWAKE. #define BM_UART_USR1_AWAKE (0x00000010) //!< Bit mask for UART_USR1_AWAKE. //! @brief Get value of UART_USR1_AWAKE from a register value. #define BG_UART_USR1_AWAKE(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_AWAKE) >> BP_UART_USR1_AWAKE) //! @brief Format value for bitfield UART_USR1_AWAKE. #define BF_UART_USR1_AWAKE(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR1_AWAKE) & BM_UART_USR1_AWAKE) #ifndef __LANGUAGE_ASM__ //! @brief Set the AWAKE field to a new value. #define BW_UART_USR1_AWAKE(x, v) (HW_UART_USR1_WR(x, (HW_UART_USR1_RD(x) & ~BM_UART_USR1_AWAKE) | BF_UART_USR1_AWAKE(v))) #endif //@} /*! @name Register UART_USR1, field AIRINT[5] (W1C) * * Asynchronous IR WAKE Interrupt Flag. Indicates that the IR WAKE pulse was detected on the RXD * pin. Clear AIRINT by writing 1 to it. Writing 0 to AIRINT has no effect. * * Values: * - 0 - No pulse was detected on the RXD IrDA pin * - 1 - A pulse was detected on the RXD IrDA pin */ //@{ #define BP_UART_USR1_AIRINT (5) //!< Bit position for UART_USR1_AIRINT. #define BM_UART_USR1_AIRINT (0x00000020) //!< Bit mask for UART_USR1_AIRINT. //! @brief Get value of UART_USR1_AIRINT from a register value. #define BG_UART_USR1_AIRINT(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_AIRINT) >> BP_UART_USR1_AIRINT) //! @brief Format value for bitfield UART_USR1_AIRINT. #define BF_UART_USR1_AIRINT(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR1_AIRINT) & BM_UART_USR1_AIRINT) #ifndef __LANGUAGE_ASM__ //! @brief Set the AIRINT field to a new value. #define BW_UART_USR1_AIRINT(x, v) (HW_UART_USR1_WR(x, (HW_UART_USR1_RD(x) & ~BM_UART_USR1_AIRINT) | BF_UART_USR1_AIRINT(v))) #endif //@} /*! @name Register UART_USR1, field RXDS[6] (RO) * * Receiver IDLE Interrupt Flag. Indicates that the receiver state machine is in an IDLE state, the * next state is IDLE, and the receive pin is high. RXDS is automatically cleared when a character * is received. RXDS is active only when the receiver is enabled. * * Values: * - 0 - Receive in progress * - 1 - Receiver is IDLE */ //@{ #define BP_UART_USR1_RXDS (6) //!< Bit position for UART_USR1_RXDS. #define BM_UART_USR1_RXDS (0x00000040) //!< Bit mask for UART_USR1_RXDS. //! @brief Get value of UART_USR1_RXDS from a register value. #define BG_UART_USR1_RXDS(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_RXDS) >> BP_UART_USR1_RXDS) //@} /*! @name Register UART_USR1, field DTRD[7] (W1C) * * DTR Delta. Indicates whether DTR (in DCE mode) or DSR (in DTE mode) pins changed state. DTRD * generates a maskable interrupt if DTRDEN (UCR3[3]) is set. Clear DTRD by writing 1 to it. Writing * 0 to DTRD has no effect. * * Values: * - 0 - DTR (DCE) or DSR (DTE) pin did not change state since last cleared * - 1 - DTR (DCE) or DSR (DTE) pin changed state (write 1 to clear) */ //@{ #define BP_UART_USR1_DTRD (7) //!< Bit position for UART_USR1_DTRD. #define BM_UART_USR1_DTRD (0x00000080) //!< Bit mask for UART_USR1_DTRD. //! @brief Get value of UART_USR1_DTRD from a register value. #define BG_UART_USR1_DTRD(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_DTRD) >> BP_UART_USR1_DTRD) //! @brief Format value for bitfield UART_USR1_DTRD. #define BF_UART_USR1_DTRD(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR1_DTRD) & BM_UART_USR1_DTRD) #ifndef __LANGUAGE_ASM__ //! @brief Set the DTRD field to a new value. #define BW_UART_USR1_DTRD(x, v) (HW_UART_USR1_WR(x, (HW_UART_USR1_RD(x) & ~BM_UART_USR1_DTRD) | BF_UART_USR1_DTRD(v))) #endif //@} /*! @name Register UART_USR1, field AGTIM[8] (W1C) * * Ageing Timer Interrupt Flag. Indicates that data in the RxFIFO has been idle for a time of 8 * character lengths (where a character length consists of 7 or 8 bits, depending on the setting of * the WS bit in UCR2, with the bit time corresponding to the baud rate setting) and FIFO data level * is less than RxFIFO threshold level (RXTL in the UFCR). Clear by writing a 1 to it. * * Values: * - 0 - AGTIM is not active * - 1 - AGTIM is active (write 1 to clear) */ //@{ #define BP_UART_USR1_AGTIM (8) //!< Bit position for UART_USR1_AGTIM. #define BM_UART_USR1_AGTIM (0x00000100) //!< Bit mask for UART_USR1_AGTIM. //! @brief Get value of UART_USR1_AGTIM from a register value. #define BG_UART_USR1_AGTIM(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_AGTIM) >> BP_UART_USR1_AGTIM) //! @brief Format value for bitfield UART_USR1_AGTIM. #define BF_UART_USR1_AGTIM(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR1_AGTIM) & BM_UART_USR1_AGTIM) #ifndef __LANGUAGE_ASM__ //! @brief Set the AGTIM field to a new value. #define BW_UART_USR1_AGTIM(x, v) (HW_UART_USR1_WR(x, (HW_UART_USR1_RD(x) & ~BM_UART_USR1_AGTIM) | BF_UART_USR1_AGTIM(v))) #endif //@} /*! @name Register UART_USR1, field RRDY[9] (RO) * * Receiver Ready Interrupt / DMA Flag . Indicates that the RxFIFO data level is above the threshold * set by the RXTL bits. (See the RXTL bits description in for setting the interrupt threshold.) * When asserted, RRDY generates a maskable interrupt or DMA request. RRDY is automatically cleared * when data level in the RxFIFO goes below the set threshold level. At reset, RRDY is set to 0. * * Values: * - 0 - No character ready * - 1 - Character(s) ready (interrupt posted) */ //@{ #define BP_UART_USR1_RRDY (9) //!< Bit position for UART_USR1_RRDY. #define BM_UART_USR1_RRDY (0x00000200) //!< Bit mask for UART_USR1_RRDY. //! @brief Get value of UART_USR1_RRDY from a register value. #define BG_UART_USR1_RRDY(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_RRDY) >> BP_UART_USR1_RRDY) //@} /*! @name Register UART_USR1, field FRAMERR[10] (W1C) * * Frame Error Interrupt Flag . Indicates that a frame error is detected. The interrupt_uart * interrupt will be generated if a frame error is detected and the interrupt is enabled. Clear * FRAMERR by writing 1 to it. Writing 0 to FRAMERR has no effect. * * Values: * - 0 - No frame error detected * - 1 - Frame error detected (write 1 to clear) */ //@{ #define BP_UART_USR1_FRAMERR (10) //!< Bit position for UART_USR1_FRAMERR. #define BM_UART_USR1_FRAMERR (0x00000400) //!< Bit mask for UART_USR1_FRAMERR. //! @brief Get value of UART_USR1_FRAMERR from a register value. #define BG_UART_USR1_FRAMERR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_FRAMERR) >> BP_UART_USR1_FRAMERR) //! @brief Format value for bitfield UART_USR1_FRAMERR. #define BF_UART_USR1_FRAMERR(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR1_FRAMERR) & BM_UART_USR1_FRAMERR) #ifndef __LANGUAGE_ASM__ //! @brief Set the FRAMERR field to a new value. #define BW_UART_USR1_FRAMERR(x, v) (HW_UART_USR1_WR(x, (HW_UART_USR1_RD(x) & ~BM_UART_USR1_FRAMERR) | BF_UART_USR1_FRAMERR(v))) #endif //@} /*! @name Register UART_USR1, field ESCF[11] (W1C) * * Escape Sequence Interrupt Flag . Indicates if an escape sequence was detected. ESCF is asserted * when the ESCEN bit is set and an escape sequence is detected in the RxFIFO. Clear ESCF by writing * 1 to it. Writing 0 to ESCF has no effect. * * Values: * - 0 - No escape sequence detected * - 1 - Escape sequence detected (write 1 to clear). */ //@{ #define BP_UART_USR1_ESCF (11) //!< Bit position for UART_USR1_ESCF. #define BM_UART_USR1_ESCF (0x00000800) //!< Bit mask for UART_USR1_ESCF. //! @brief Get value of UART_USR1_ESCF from a register value. #define BG_UART_USR1_ESCF(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_ESCF) >> BP_UART_USR1_ESCF) //! @brief Format value for bitfield UART_USR1_ESCF. #define BF_UART_USR1_ESCF(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR1_ESCF) & BM_UART_USR1_ESCF) #ifndef __LANGUAGE_ASM__ //! @brief Set the ESCF field to a new value. #define BW_UART_USR1_ESCF(x, v) (HW_UART_USR1_WR(x, (HW_UART_USR1_RD(x) & ~BM_UART_USR1_ESCF) | BF_UART_USR1_ESCF(v))) #endif //@} /*! @name Register UART_USR1, field RTSD[12] (W1C) * * RTS Delta. Indicates whether the RTS pin changed state. It (RTSD) generates a maskable interrupt. * When in STOP mode, RTS assertion sets RTSD and can be used to wake the processor. The current * state of the RTS pin is available on the RTSS bit. Clear RTSD by writing 1 to it. Writing 0 to * RTSD has no effect. At reset, RTSD is set to 0. * * Values: * - 0 - RTS pin did not change state since last cleared * - 1 - RTS pin changed state (write 1 to clear) */ //@{ #define BP_UART_USR1_RTSD (12) //!< Bit position for UART_USR1_RTSD. #define BM_UART_USR1_RTSD (0x00001000) //!< Bit mask for UART_USR1_RTSD. //! @brief Get value of UART_USR1_RTSD from a register value. #define BG_UART_USR1_RTSD(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_RTSD) >> BP_UART_USR1_RTSD) //! @brief Format value for bitfield UART_USR1_RTSD. #define BF_UART_USR1_RTSD(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR1_RTSD) & BM_UART_USR1_RTSD) #ifndef __LANGUAGE_ASM__ //! @brief Set the RTSD field to a new value. #define BW_UART_USR1_RTSD(x, v) (HW_UART_USR1_WR(x, (HW_UART_USR1_RD(x) & ~BM_UART_USR1_RTSD) | BF_UART_USR1_RTSD(v))) #endif //@} /*! @name Register UART_USR1, field TRDY[13] (RO) * * Transmitter Ready Interrupt / DMA Flag . Indicates that the TxFIFO emptied below its target * threshold and requires data. TRDY is automatically cleared when the data level in the TxFIFO * exceeds the threshold set by TXTL bits. At reset, TRDY is set to 1. * * Values: * - 0 - The transmitter does not require data * - 1 - The transmitter requires data (interrupt posted) */ //@{ #define BP_UART_USR1_TRDY (13) //!< Bit position for UART_USR1_TRDY. #define BM_UART_USR1_TRDY (0x00002000) //!< Bit mask for UART_USR1_TRDY. //! @brief Get value of UART_USR1_TRDY from a register value. #define BG_UART_USR1_TRDY(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_TRDY) >> BP_UART_USR1_TRDY) //@} /*! @name Register UART_USR1, field RTSS[14] (RO) * * RTS Pin Status . Indicates the current status of the RTS pin. A "snapshot" of the pin is taken * immediately before RTSS is presented to the data bus. RTSS cannot be cleared because all writes * to RTSS are ignored. At reset, RTSS is set to 0. * * Values: * - 0 - The RTS pin is high (inactive) * - 1 - The RTS pin is low (active) */ //@{ #define BP_UART_USR1_RTSS (14) //!< Bit position for UART_USR1_RTSS. #define BM_UART_USR1_RTSS (0x00004000) //!< Bit mask for UART_USR1_RTSS. //! @brief Get value of UART_USR1_RTSS from a register value. #define BG_UART_USR1_RTSS(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_RTSS) >> BP_UART_USR1_RTSS) //@} /*! @name Register UART_USR1, field PARITYERR[15] (W1C) * * Parity Error Interrupt Flag . Indicates a parity error is detected. PARITYERR is cleared by * writing 1 to it. Writing 0 to PARITYERR has no effect. When parity is disabled, PARITYERR always * reads 0. At reset, PARITYERR is set to 0. * * Values: * - 0 - No parity error detected * - 1 - Parity error detected (write 1 to clear) */ //@{ #define BP_UART_USR1_PARITYERR (15) //!< Bit position for UART_USR1_PARITYERR. #define BM_UART_USR1_PARITYERR (0x00008000) //!< Bit mask for UART_USR1_PARITYERR. //! @brief Get value of UART_USR1_PARITYERR from a register value. #define BG_UART_USR1_PARITYERR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR1_PARITYERR) >> BP_UART_USR1_PARITYERR) //! @brief Format value for bitfield UART_USR1_PARITYERR. #define BF_UART_USR1_PARITYERR(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR1_PARITYERR) & BM_UART_USR1_PARITYERR) #ifndef __LANGUAGE_ASM__ //! @brief Set the PARITYERR field to a new value. #define BW_UART_USR1_PARITYERR(x, v) (HW_UART_USR1_WR(x, (HW_UART_USR1_RD(x) & ~BM_UART_USR1_PARITYERR) | BF_UART_USR1_PARITYERR(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_USR2 - UART Status Register 2 //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_USR2 - UART Status Register 2 (RW) * * Reset value: 0x00004028 */ typedef union _hw_uart_usr2 { reg32_t U; struct _hw_uart_usr2_bitfields { unsigned RDR : 1; //!< [0] Receive Data Ready -Indicates that at least 1 character is received and written to the RxFIFO. unsigned ORE : 1; //!< [1] Overrun Error . unsigned BRCD : 1; //!< [2] BREAK Condition Detected . unsigned TXDC : 1; //!< [3] Transmitter Complete . unsigned RTSF : 1; //!< [4] RTS Edge Triggered Interrupt Flag. unsigned DCDIN : 1; //!< [5] Data Carrier Detect Input . unsigned DCDDELT : 1; //!< [6] Data Carrier Detect Delta . unsigned WAKE : 1; //!< [7] Wake . unsigned IRINT : 1; //!< [8] Serial Infrared Interrupt Flag. unsigned RIIN : 1; //!< [9] Ring Indicator Input . unsigned RIDELT : 1; //!< [10] Ring Indicator Delta . unsigned ACST : 1; //!< [11] Autobaud Counter Stopped . unsigned IDLE : 1; //!< [12] Idle Condition . unsigned DTRF : 1; //!< [13] DTR edge triggered interrupt flag . unsigned TXFE : 1; //!< [14] Transmit Buffer FIFO Empty . unsigned ADET : 1; //!< [15] Automatic Baud Rate Detect Complete . unsigned RESERVED0 : 16; //!< [31:16] Reserved } B; } hw_uart_usr2_t; #endif /*! * @name Constants and macros for entire UART_USR2 register */ //@{ #define HW_UART_USR2_ADDR(x) (REGS_UART_BASE(x) + 0x98) #ifndef __LANGUAGE_ASM__ #define HW_UART_USR2(x) (*(volatile hw_uart_usr2_t *) HW_UART_USR2_ADDR(x)) #define HW_UART_USR2_RD(x) (HW_UART_USR2(x).U) #define HW_UART_USR2_WR(x, v) (HW_UART_USR2(x).U = (v)) #define HW_UART_USR2_SET(x, v) (HW_UART_USR2_WR(x, HW_UART_USR2_RD(x) | (v))) #define HW_UART_USR2_CLR(x, v) (HW_UART_USR2_WR(x, HW_UART_USR2_RD(x) & ~(v))) #define HW_UART_USR2_TOG(x, v) (HW_UART_USR2_WR(x, HW_UART_USR2_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_USR2 bitfields */ /*! @name Register UART_USR2, field RDR[0] (RO) * * Receive Data Ready -Indicates that at least 1 character is received and written to the RxFIFO. If * the URXD register is read and there is only 1 character in the RxFIFO, RDR is automatically * cleared. * * Values: * - 0 - No receive data ready * - 1 - Receive data ready */ //@{ #define BP_UART_USR2_RDR (0) //!< Bit position for UART_USR2_RDR. #define BM_UART_USR2_RDR (0x00000001) //!< Bit mask for UART_USR2_RDR. //! @brief Get value of UART_USR2_RDR from a register value. #define BG_UART_USR2_RDR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_RDR) >> BP_UART_USR2_RDR) //@} /*! @name Register UART_USR2, field ORE[1] (W1C) * * Overrun Error . When set to 1, ORE indicates that the receive buffer (RxFIFO) was full (32 chars * inside), and a 33rd character has been fully received. This 33rd character has been discarded. * Clear ORE by writing 1 to it. Writing 0 to ORE has no effect. * * Values: * - 0 - No overrun error * - 1 - Overrun error (write 1 to clear) */ //@{ #define BP_UART_USR2_ORE (1) //!< Bit position for UART_USR2_ORE. #define BM_UART_USR2_ORE (0x00000002) //!< Bit mask for UART_USR2_ORE. //! @brief Get value of UART_USR2_ORE from a register value. #define BG_UART_USR2_ORE(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_ORE) >> BP_UART_USR2_ORE) //! @brief Format value for bitfield UART_USR2_ORE. #define BF_UART_USR2_ORE(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_ORE) & BM_UART_USR2_ORE) #ifndef __LANGUAGE_ASM__ //! @brief Set the ORE field to a new value. #define BW_UART_USR2_ORE(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_ORE) | BF_UART_USR2_ORE(v))) #endif //@} /*! @name Register UART_USR2, field BRCD[2] (W1C) * * BREAK Condition Detected . Indicates that a BREAK condition was detected by the receiver. Clear * BRCD by writing 1 to it. Writing 0 to BRCD has no effect. * * Values: * - 0 - No BREAK condition was detected * - 1 - A BREAK condition was detected (write 1 to clear) */ //@{ #define BP_UART_USR2_BRCD (2) //!< Bit position for UART_USR2_BRCD. #define BM_UART_USR2_BRCD (0x00000004) //!< Bit mask for UART_USR2_BRCD. //! @brief Get value of UART_USR2_BRCD from a register value. #define BG_UART_USR2_BRCD(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_BRCD) >> BP_UART_USR2_BRCD) //! @brief Format value for bitfield UART_USR2_BRCD. #define BF_UART_USR2_BRCD(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_BRCD) & BM_UART_USR2_BRCD) #ifndef __LANGUAGE_ASM__ //! @brief Set the BRCD field to a new value. #define BW_UART_USR2_BRCD(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_BRCD) | BF_UART_USR2_BRCD(v))) #endif //@} /*! @name Register UART_USR2, field TXDC[3] (RO) * * Transmitter Complete . Indicates that the transmit buffer (TxFIFO) and Shift Register is empty; * therefore the transmission is complete. TXDC is cleared automatically when data is written to the * TxFIFO. * * Values: * - 0 - Transmit is incomplete * - 1 - Transmit is complete */ //@{ #define BP_UART_USR2_TXDC (3) //!< Bit position for UART_USR2_TXDC. #define BM_UART_USR2_TXDC (0x00000008) //!< Bit mask for UART_USR2_TXDC. //! @brief Get value of UART_USR2_TXDC from a register value. #define BG_UART_USR2_TXDC(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_TXDC) >> BP_UART_USR2_TXDC) //@} /*! @name Register UART_USR2, field RTSF[4] (W1C) * * RTS Edge Triggered Interrupt Flag. Indicates if a programmed edge is detected on the RTS pin. The * RTEC bits select the edge that generates an interrupt (see ). RTSF can generate an interrupt that * can be masked using the RTSEN bit. Clear RTSF by writing 1 to it. Writing 0 to RTSF has no * effect. * * Values: * - 0 - Programmed edge not detected on RTS * - 1 - Programmed edge detected on RTS (write 1 to clear) */ //@{ #define BP_UART_USR2_RTSF (4) //!< Bit position for UART_USR2_RTSF. #define BM_UART_USR2_RTSF (0x00000010) //!< Bit mask for UART_USR2_RTSF. //! @brief Get value of UART_USR2_RTSF from a register value. #define BG_UART_USR2_RTSF(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_RTSF) >> BP_UART_USR2_RTSF) //! @brief Format value for bitfield UART_USR2_RTSF. #define BF_UART_USR2_RTSF(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_RTSF) & BM_UART_USR2_RTSF) #ifndef __LANGUAGE_ASM__ //! @brief Set the RTSF field to a new value. #define BW_UART_USR2_RTSF(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_RTSF) | BF_UART_USR2_RTSF(v))) #endif //@} /*! @name Register UART_USR2, field DCDIN[5] (RO) * * Data Carrier Detect Input . This bit is used in DTE mode reflect the status of the Data Carrier * Detect input ( DCD ). The Data Carrier Detect input is used to indicate that a carrier signal has * been detected. In DCE mode this bit is always zero. * * Values: * - 0 - Carrier signal Detected * - 1 - No Carrier signal Detected */ //@{ #define BP_UART_USR2_DCDIN (5) //!< Bit position for UART_USR2_DCDIN. #define BM_UART_USR2_DCDIN (0x00000020) //!< Bit mask for UART_USR2_DCDIN. //! @brief Get value of UART_USR2_DCDIN from a register value. #define BG_UART_USR2_DCDIN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_DCDIN) >> BP_UART_USR2_DCDIN) //@} /*! @name Register UART_USR2, field DCDDELT[6] (W1C) * * Data Carrier Detect Delta . This bit is used in DTE mode to indicate that the Data Carrier Detect * input ( DCD ) has changed state. This flag can cause an interrupt if DCD (UCR3[9]) is enabled. * When in STOP mode, this bit can be used to wake the processor. In DCE mode this bit is always * zero. * * Values: * - 0 - Data Carrier Detect input has not changed state * - 1 - Data Carrier Detect input has changed state (write 1 to clear) */ //@{ #define BP_UART_USR2_DCDDELT (6) //!< Bit position for UART_USR2_DCDDELT. #define BM_UART_USR2_DCDDELT (0x00000040) //!< Bit mask for UART_USR2_DCDDELT. //! @brief Get value of UART_USR2_DCDDELT from a register value. #define BG_UART_USR2_DCDDELT(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_DCDDELT) >> BP_UART_USR2_DCDDELT) //! @brief Format value for bitfield UART_USR2_DCDDELT. #define BF_UART_USR2_DCDDELT(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_DCDDELT) & BM_UART_USR2_DCDDELT) #ifndef __LANGUAGE_ASM__ //! @brief Set the DCDDELT field to a new value. #define BW_UART_USR2_DCDDELT(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_DCDDELT) | BF_UART_USR2_DCDDELT(v))) #endif //@} /*! @name Register UART_USR2, field WAKE[7] (W1C) * * Wake . Indicates the start bit is detected. WAKE can generate an interrupt that can be masked * using the WKEN bit. Clear WAKE by writing 1 to it. Writing 0 to WAKE has no effect. * * Values: * - 0 - start bit not detected * - 1 - start bit detected (write 1 to clear) */ //@{ #define BP_UART_USR2_WAKE (7) //!< Bit position for UART_USR2_WAKE. #define BM_UART_USR2_WAKE (0x00000080) //!< Bit mask for UART_USR2_WAKE. //! @brief Get value of UART_USR2_WAKE from a register value. #define BG_UART_USR2_WAKE(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_WAKE) >> BP_UART_USR2_WAKE) //! @brief Format value for bitfield UART_USR2_WAKE. #define BF_UART_USR2_WAKE(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_WAKE) & BM_UART_USR2_WAKE) #ifndef __LANGUAGE_ASM__ //! @brief Set the WAKE field to a new value. #define BW_UART_USR2_WAKE(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_WAKE) | BF_UART_USR2_WAKE(v))) #endif //@} /*! @name Register UART_USR2, field IRINT[8] (W1C) * * Serial Infrared Interrupt Flag. When an edge is detected on the RXD pin during SIR Mode, this * flag will be asserted. This flag can cause an interrupt which can be masked using the control bit * ENIRI: UCR4 [8]. * * Values: * - 0 - no edge detected * - 1 - valid edge detected (write 1 to clear) */ //@{ #define BP_UART_USR2_IRINT (8) //!< Bit position for UART_USR2_IRINT. #define BM_UART_USR2_IRINT (0x00000100) //!< Bit mask for UART_USR2_IRINT. //! @brief Get value of UART_USR2_IRINT from a register value. #define BG_UART_USR2_IRINT(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_IRINT) >> BP_UART_USR2_IRINT) //! @brief Format value for bitfield UART_USR2_IRINT. #define BF_UART_USR2_IRINT(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_IRINT) & BM_UART_USR2_IRINT) #ifndef __LANGUAGE_ASM__ //! @brief Set the IRINT field to a new value. #define BW_UART_USR2_IRINT(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_IRINT) | BF_UART_USR2_IRINT(v))) #endif //@} /*! @name Register UART_USR2, field RIIN[9] (RO) * * Ring Indicator Input . This bit is used in DTE mode to reflect the status if the Ring Indicator * input ( RI ). The Ring Indicator input is used to indicate that a ring has occurred. In DCE mode * this bit is always zero. * * Values: * - 0 - Ring Detected * - 1 - No Ring Detected */ //@{ #define BP_UART_USR2_RIIN (9) //!< Bit position for UART_USR2_RIIN. #define BM_UART_USR2_RIIN (0x00000200) //!< Bit mask for UART_USR2_RIIN. //! @brief Get value of UART_USR2_RIIN from a register value. #define BG_UART_USR2_RIIN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_RIIN) >> BP_UART_USR2_RIIN) //@} /*! @name Register UART_USR2, field RIDELT[10] (W1C) * * Ring Indicator Delta . This bit is used in DTE mode to indicate that the Ring Indicator input ( * RI ) has changed state. This flag can generate an interrupt if RI (UCR3[8]) is enabled. RIDELT is * cleared by writing 1 to it. Writing 0 to RIDELT has no effect. * * Values: * - 0 - Ring Indicator input has not changed state * - 1 - Ring Indicator input has changed state (write 1 to clear) */ //@{ #define BP_UART_USR2_RIDELT (10) //!< Bit position for UART_USR2_RIDELT. #define BM_UART_USR2_RIDELT (0x00000400) //!< Bit mask for UART_USR2_RIDELT. //! @brief Get value of UART_USR2_RIDELT from a register value. #define BG_UART_USR2_RIDELT(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_RIDELT) >> BP_UART_USR2_RIDELT) //! @brief Format value for bitfield UART_USR2_RIDELT. #define BF_UART_USR2_RIDELT(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_RIDELT) & BM_UART_USR2_RIDELT) #ifndef __LANGUAGE_ASM__ //! @brief Set the RIDELT field to a new value. #define BW_UART_USR2_RIDELT(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_RIDELT) | BF_UART_USR2_RIDELT(v))) #endif //@} /*! @name Register UART_USR2, field ACST[11] (W1C) * * Autobaud Counter Stopped . In autobaud detection (ADBR=1), indicates the counter which determines * the baud rate was running and is now stopped. This means either START bit is finished (if * ADNIMP=1), or Bit 0 is finished (if ADNIMP=0). See , for more details. An interrupt can be * flagged on interrupt_uart if ACIEN=1. * * Values: * - 0 - Measurement of bit length not finished (in autobaud) * - 1 - Measurement of bit length finished (in autobaud). (write 1 to clear) */ //@{ #define BP_UART_USR2_ACST (11) //!< Bit position for UART_USR2_ACST. #define BM_UART_USR2_ACST (0x00000800) //!< Bit mask for UART_USR2_ACST. //! @brief Get value of UART_USR2_ACST from a register value. #define BG_UART_USR2_ACST(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_ACST) >> BP_UART_USR2_ACST) //! @brief Format value for bitfield UART_USR2_ACST. #define BF_UART_USR2_ACST(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_ACST) & BM_UART_USR2_ACST) #ifndef __LANGUAGE_ASM__ //! @brief Set the ACST field to a new value. #define BW_UART_USR2_ACST(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_ACST) | BF_UART_USR2_ACST(v))) #endif //@} /*! @name Register UART_USR2, field IDLE[12] (W1C) * * Idle Condition . Indicates that an idle condition has existed for more than a programmed amount * frame (see . An interrupt can be generated by this IDLE bit if IDEN (UCR1[12]) is enabled. IDLE * is cleared by writing 1 to it. Writing 0 to IDLE has no effect. * * Values: * - 0 - No idle condition detected * - 1 - Idle condition detected (write 1 to clear) */ //@{ #define BP_UART_USR2_IDLE (12) //!< Bit position for UART_USR2_IDLE. #define BM_UART_USR2_IDLE (0x00001000) //!< Bit mask for UART_USR2_IDLE. //! @brief Get value of UART_USR2_IDLE from a register value. #define BG_UART_USR2_IDLE(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_IDLE) >> BP_UART_USR2_IDLE) //! @brief Format value for bitfield UART_USR2_IDLE. #define BF_UART_USR2_IDLE(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_IDLE) & BM_UART_USR2_IDLE) #ifndef __LANGUAGE_ASM__ //! @brief Set the IDLE field to a new value. #define BW_UART_USR2_IDLE(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_IDLE) | BF_UART_USR2_IDLE(v))) #endif //@} /*! @name Register UART_USR2, field DTRF[13] (W1C) * * DTR edge triggered interrupt flag . This bit is asserted, when the programmed edge is detected on * the DTR pin (DCE mode) or on DSR (DTE mode). This flag can cause an interrupt if DTREN (UCR3[13]) * is enabled. * * Values: * - 0 - Programmed edge not detected on DTR/DSR * - 1 - Programmed edge detected on DTR/DSR (write 1 to clear) */ //@{ #define BP_UART_USR2_DTRF (13) //!< Bit position for UART_USR2_DTRF. #define BM_UART_USR2_DTRF (0x00002000) //!< Bit mask for UART_USR2_DTRF. //! @brief Get value of UART_USR2_DTRF from a register value. #define BG_UART_USR2_DTRF(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_DTRF) >> BP_UART_USR2_DTRF) //! @brief Format value for bitfield UART_USR2_DTRF. #define BF_UART_USR2_DTRF(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_DTRF) & BM_UART_USR2_DTRF) #ifndef __LANGUAGE_ASM__ //! @brief Set the DTRF field to a new value. #define BW_UART_USR2_DTRF(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_DTRF) | BF_UART_USR2_DTRF(v))) #endif //@} /*! @name Register UART_USR2, field TXFE[14] (RO) * * Transmit Buffer FIFO Empty . Indicates that the transmit buffer (TxFIFO) is empty. TXFE is * cleared automatically when data is written to the TxFIFO. Even though TXFE is high, the * transmission might still be in progress. * * Values: * - 0 - The transmit buffer (TxFIFO) is not empty * - 1 - The transmit buffer (TxFIFO) is empty */ //@{ #define BP_UART_USR2_TXFE (14) //!< Bit position for UART_USR2_TXFE. #define BM_UART_USR2_TXFE (0x00004000) //!< Bit mask for UART_USR2_TXFE. //! @brief Get value of UART_USR2_TXFE from a register value. #define BG_UART_USR2_TXFE(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_TXFE) >> BP_UART_USR2_TXFE) //@} /*! @name Register UART_USR2, field ADET[15] (W1C) * * Automatic Baud Rate Detect Complete . Indicates that an "A" or "a" was received and that the * receiver detected and verified the incoming baud rate. Clear ADET by writing 1 to it. Writing 0 * to ADET has no effect. * * Values: * - 0 - ASCII "A" or "a" was not received * - 1 - ASCII "A" or "a" was received (write 1 to clear) */ //@{ #define BP_UART_USR2_ADET (15) //!< Bit position for UART_USR2_ADET. #define BM_UART_USR2_ADET (0x00008000) //!< Bit mask for UART_USR2_ADET. //! @brief Get value of UART_USR2_ADET from a register value. #define BG_UART_USR2_ADET(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_USR2_ADET) >> BP_UART_USR2_ADET) //! @brief Format value for bitfield UART_USR2_ADET. #define BF_UART_USR2_ADET(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_USR2_ADET) & BM_UART_USR2_ADET) #ifndef __LANGUAGE_ASM__ //! @brief Set the ADET field to a new value. #define BW_UART_USR2_ADET(x, v) (HW_UART_USR2_WR(x, (HW_UART_USR2_RD(x) & ~BM_UART_USR2_ADET) | BF_UART_USR2_ADET(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UESC - UART Escape Character Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UESC - UART Escape Character Register (RW) * * Reset value: 0x0000002b */ typedef union _hw_uart_uesc { reg32_t U; struct _hw_uart_uesc_bitfields { unsigned ESC_CHAR : 8; //!< [7:0] UART Escape Character . unsigned RESERVED0 : 24; //!< [31:8] Reserved } B; } hw_uart_uesc_t; #endif /*! * @name Constants and macros for entire UART_UESC register */ //@{ #define HW_UART_UESC_ADDR(x) (REGS_UART_BASE(x) + 0x9c) #ifndef __LANGUAGE_ASM__ #define HW_UART_UESC(x) (*(volatile hw_uart_uesc_t *) HW_UART_UESC_ADDR(x)) #define HW_UART_UESC_RD(x) (HW_UART_UESC(x).U) #define HW_UART_UESC_WR(x, v) (HW_UART_UESC(x).U = (v)) #define HW_UART_UESC_SET(x, v) (HW_UART_UESC_WR(x, HW_UART_UESC_RD(x) | (v))) #define HW_UART_UESC_CLR(x, v) (HW_UART_UESC_WR(x, HW_UART_UESC_RD(x) & ~(v))) #define HW_UART_UESC_TOG(x, v) (HW_UART_UESC_WR(x, HW_UART_UESC_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UESC bitfields */ /*! @name Register UART_UESC, field ESC_CHAR[7:0] (RW) * * UART Escape Character . Holds the selected escape character that all received characters are * compared against to detect an escape sequence. */ //@{ #define BP_UART_UESC_ESC_CHAR (0) //!< Bit position for UART_UESC_ESC_CHAR. #define BM_UART_UESC_ESC_CHAR (0x000000ff) //!< Bit mask for UART_UESC_ESC_CHAR. //! @brief Get value of UART_UESC_ESC_CHAR from a register value. #define BG_UART_UESC_ESC_CHAR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UESC_ESC_CHAR) >> BP_UART_UESC_ESC_CHAR) //! @brief Format value for bitfield UART_UESC_ESC_CHAR. #define BF_UART_UESC_ESC_CHAR(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UESC_ESC_CHAR) & BM_UART_UESC_ESC_CHAR) #ifndef __LANGUAGE_ASM__ //! @brief Set the ESC_CHAR field to a new value. #define BW_UART_UESC_ESC_CHAR(x, v) (HW_UART_UESC_WR(x, (HW_UART_UESC_RD(x) & ~BM_UART_UESC_ESC_CHAR) | BF_UART_UESC_ESC_CHAR(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UTIM - UART Escape Timer Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UTIM - UART Escape Timer Register (RW) * * Reset value: 0x00000000 */ typedef union _hw_uart_utim { reg32_t U; struct _hw_uart_utim_bitfields { unsigned TIM : 12; //!< [11:0] UART Escape Timer. unsigned RESERVED0 : 20; //!< [31:12] Reserved } B; } hw_uart_utim_t; #endif /*! * @name Constants and macros for entire UART_UTIM register */ //@{ #define HW_UART_UTIM_ADDR(x) (REGS_UART_BASE(x) + 0xa0) #ifndef __LANGUAGE_ASM__ #define HW_UART_UTIM(x) (*(volatile hw_uart_utim_t *) HW_UART_UTIM_ADDR(x)) #define HW_UART_UTIM_RD(x) (HW_UART_UTIM(x).U) #define HW_UART_UTIM_WR(x, v) (HW_UART_UTIM(x).U = (v)) #define HW_UART_UTIM_SET(x, v) (HW_UART_UTIM_WR(x, HW_UART_UTIM_RD(x) | (v))) #define HW_UART_UTIM_CLR(x, v) (HW_UART_UTIM_WR(x, HW_UART_UTIM_RD(x) & ~(v))) #define HW_UART_UTIM_TOG(x, v) (HW_UART_UTIM_WR(x, HW_UART_UTIM_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UTIM bitfields */ /*! @name Register UART_UTIM, field TIM[11:0] (RW) * * UART Escape Timer. Holds the maximum time interval (in ms) allowed between escape characters. The * escape timer register is programmable in intervals of 2 ms. See and for more information on the * UART escape sequence detection. Reset value 0x000 = 2 ms up to 0xFFF = 8.192 s. */ //@{ #define BP_UART_UTIM_TIM (0) //!< Bit position for UART_UTIM_TIM. #define BM_UART_UTIM_TIM (0x00000fff) //!< Bit mask for UART_UTIM_TIM. //! @brief Get value of UART_UTIM_TIM from a register value. #define BG_UART_UTIM_TIM(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTIM_TIM) >> BP_UART_UTIM_TIM) //! @brief Format value for bitfield UART_UTIM_TIM. #define BF_UART_UTIM_TIM(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTIM_TIM) & BM_UART_UTIM_TIM) #ifndef __LANGUAGE_ASM__ //! @brief Set the TIM field to a new value. #define BW_UART_UTIM_TIM(x, v) (HW_UART_UTIM_WR(x, (HW_UART_UTIM_RD(x) & ~BM_UART_UTIM_TIM) | BF_UART_UTIM_TIM(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UBIR - UART BRM Incremental Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UBIR - UART BRM Incremental Register (RW) * * Reset value: 0x00000000 * * This register can be written by both software and hardware. When enabling the automatic baud rate * detection feature hardware can write 0x000F value into the UBIR after finishing detecting baud * rate. Hardware has higher priority when both software and hardware try to write it at the same * cycle Note: The write priority in the new design is not same as the original UART. In the orginal * design, software has higher priotiry than hardware when writing this register at the same time. . * Please note software reset will reset the register to its reset value. */ typedef union _hw_uart_ubir { reg32_t U; struct _hw_uart_ubir_bitfields { unsigned INC : 16; //!< [15:0] Incremental Numerator. unsigned RESERVED0 : 16; //!< [31:16] Reserved } B; } hw_uart_ubir_t; #endif /*! * @name Constants and macros for entire UART_UBIR register */ //@{ #define HW_UART_UBIR_ADDR(x) (REGS_UART_BASE(x) + 0xa4) #ifndef __LANGUAGE_ASM__ #define HW_UART_UBIR(x) (*(volatile hw_uart_ubir_t *) HW_UART_UBIR_ADDR(x)) #define HW_UART_UBIR_RD(x) (HW_UART_UBIR(x).U) #define HW_UART_UBIR_WR(x, v) (HW_UART_UBIR(x).U = (v)) #define HW_UART_UBIR_SET(x, v) (HW_UART_UBIR_WR(x, HW_UART_UBIR_RD(x) | (v))) #define HW_UART_UBIR_CLR(x, v) (HW_UART_UBIR_WR(x, HW_UART_UBIR_RD(x) & ~(v))) #define HW_UART_UBIR_TOG(x, v) (HW_UART_UBIR_WR(x, HW_UART_UBIR_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UBIR bitfields */ /*! @name Register UART_UBIR, field INC[15:0] (RW) * * Incremental Numerator. Holds the numerator value minus one of the BRM ratio (see ). The UBIR * register MUST be updated before the UBMR register for the baud rate to be updated correctly. If * only one register is written to by software, the BRM will ignore this data until the other * register is written to by software. Updating this field using byte accesses is not recommended * and is undefined. */ //@{ #define BP_UART_UBIR_INC (0) //!< Bit position for UART_UBIR_INC. #define BM_UART_UBIR_INC (0x0000ffff) //!< Bit mask for UART_UBIR_INC. //! @brief Get value of UART_UBIR_INC from a register value. #define BG_UART_UBIR_INC(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UBIR_INC) >> BP_UART_UBIR_INC) //! @brief Format value for bitfield UART_UBIR_INC. #define BF_UART_UBIR_INC(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UBIR_INC) & BM_UART_UBIR_INC) #ifndef __LANGUAGE_ASM__ //! @brief Set the INC field to a new value. #define BW_UART_UBIR_INC(x, v) (HW_UART_UBIR_WR(x, (HW_UART_UBIR_RD(x) & ~BM_UART_UBIR_INC) | BF_UART_UBIR_INC(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UBMR - UART BRM Modulator Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UBMR - UART BRM Modulator Register (RW) * * Reset value: 0x00000000 * * This register can be written by both software and hardware. When enabling the automatic baud rate * detection feature hardware can write a proper value into the UBMR based on detected baud rate. * Hardware has higher priority when both software and hardware try to write it at the same cycle * Note: The write priority in the new design is not same as the original UART. In the orginal * design, software has higher priotiry than hardware when writing this register at the same time. . * Please note software reset will reset the register to its reset value. */ typedef union _hw_uart_ubmr { reg32_t U; struct _hw_uart_ubmr_bitfields { unsigned MOD : 16; //!< [15:0] Modulator Denominator. unsigned RESERVED0 : 16; //!< [31:16] Reserved } B; } hw_uart_ubmr_t; #endif /*! * @name Constants and macros for entire UART_UBMR register */ //@{ #define HW_UART_UBMR_ADDR(x) (REGS_UART_BASE(x) + 0xa8) #ifndef __LANGUAGE_ASM__ #define HW_UART_UBMR(x) (*(volatile hw_uart_ubmr_t *) HW_UART_UBMR_ADDR(x)) #define HW_UART_UBMR_RD(x) (HW_UART_UBMR(x).U) #define HW_UART_UBMR_WR(x, v) (HW_UART_UBMR(x).U = (v)) #define HW_UART_UBMR_SET(x, v) (HW_UART_UBMR_WR(x, HW_UART_UBMR_RD(x) | (v))) #define HW_UART_UBMR_CLR(x, v) (HW_UART_UBMR_WR(x, HW_UART_UBMR_RD(x) & ~(v))) #define HW_UART_UBMR_TOG(x, v) (HW_UART_UBMR_WR(x, HW_UART_UBMR_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UBMR bitfields */ /*! @name Register UART_UBMR, field MOD[15:0] (RW) * * Modulator Denominator. Holds the value of the denominator minus one of the BRM ratio (see ). The * UBIR register MUST be updated before the UBMR register for the baud rate to be updated correctly. * If only one register is written to by software, the BRM will ignore this data until the other * register is written to by software. Updating this register using byte accesses is not recommended * and undefined. */ //@{ #define BP_UART_UBMR_MOD (0) //!< Bit position for UART_UBMR_MOD. #define BM_UART_UBMR_MOD (0x0000ffff) //!< Bit mask for UART_UBMR_MOD. //! @brief Get value of UART_UBMR_MOD from a register value. #define BG_UART_UBMR_MOD(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UBMR_MOD) >> BP_UART_UBMR_MOD) //! @brief Format value for bitfield UART_UBMR_MOD. #define BF_UART_UBMR_MOD(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UBMR_MOD) & BM_UART_UBMR_MOD) #ifndef __LANGUAGE_ASM__ //! @brief Set the MOD field to a new value. #define BW_UART_UBMR_MOD(x, v) (HW_UART_UBMR_WR(x, (HW_UART_UBMR_RD(x) & ~BM_UART_UBMR_MOD) | BF_UART_UBMR_MOD(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UBRC - UART Baud Rate Count Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UBRC - UART Baud Rate Count Register (RO) * * Reset value: 0x00000004 */ typedef union _hw_uart_ubrc { reg32_t U; struct _hw_uart_ubrc_bitfields { unsigned BCNT : 16; //!< [15:0] Baud Rate Count Register. unsigned RESERVED0 : 16; //!< [31:16] Reserved } B; } hw_uart_ubrc_t; #endif /*! * @name Constants and macros for entire UART_UBRC register */ //@{ #define HW_UART_UBRC_ADDR(x) (REGS_UART_BASE(x) + 0xac) #ifndef __LANGUAGE_ASM__ #define HW_UART_UBRC(x) (*(volatile hw_uart_ubrc_t *) HW_UART_UBRC_ADDR(x)) #define HW_UART_UBRC_RD(x) (HW_UART_UBRC(x).U) #endif //@} /* * constants & macros for individual UART_UBRC bitfields */ /*! @name Register UART_UBRC, field BCNT[15:0] (RO) * * Baud Rate Count Register. This read only register is used to count the start bit of the incoming * baud rate (if ADNIMP=1), or start bit + bit0 (if ADNIMP=0). When the measurement is done, the * Baud Rate Count Register contains the number of UART internal clock cycles (clock after divider) * present in an incoming bit. BCNT retains its value until the next Automatic Baud Rate Detection * sequence has been initiated. The 16 bit Baud Rate Count register is reset to 4 and stays at hex * FFFF in the case of an overflow. */ //@{ #define BP_UART_UBRC_BCNT (0) //!< Bit position for UART_UBRC_BCNT. #define BM_UART_UBRC_BCNT (0x0000ffff) //!< Bit mask for UART_UBRC_BCNT. //! @brief Get value of UART_UBRC_BCNT from a register value. #define BG_UART_UBRC_BCNT(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UBRC_BCNT) >> BP_UART_UBRC_BCNT) //@} //------------------------------------------------------------------------------------------- // HW_UART_ONEMS - UART One Millisecond Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_ONEMS - UART One Millisecond Register (RW) * * Reset value: 0x00000000 * * This register has been expanded from 16 bits to 24 bits. In previous versions, the 16-bit ONEMS * can only support the maximum 65.535MHz (0xFFFFx1000) ref_clk . To support 4Mbps Bluetooth * application with 66.5MHz module_clock , the value 0x103C4 (66.5M/1000) should be written into * this register. In this case, the 16 bits are not enough to contain the 0x103C4. So this register * was expanded to 24 bits to support high frequency of the ref_clk . */ typedef union _hw_uart_onems { reg32_t U; struct _hw_uart_onems_bitfields { unsigned ONEMS : 24; //!< [23:0] One Millisecond Register. unsigned RESERVED0 : 8; //!< [31:24] Reserved } B; } hw_uart_onems_t; #endif /*! * @name Constants and macros for entire UART_ONEMS register */ //@{ #define HW_UART_ONEMS_ADDR(x) (REGS_UART_BASE(x) + 0xb0) #ifndef __LANGUAGE_ASM__ #define HW_UART_ONEMS(x) (*(volatile hw_uart_onems_t *) HW_UART_ONEMS_ADDR(x)) #define HW_UART_ONEMS_RD(x) (HW_UART_ONEMS(x).U) #define HW_UART_ONEMS_WR(x, v) (HW_UART_ONEMS(x).U = (v)) #define HW_UART_ONEMS_SET(x, v) (HW_UART_ONEMS_WR(x, HW_UART_ONEMS_RD(x) | (v))) #define HW_UART_ONEMS_CLR(x, v) (HW_UART_ONEMS_WR(x, HW_UART_ONEMS_RD(x) & ~(v))) #define HW_UART_ONEMS_TOG(x, v) (HW_UART_ONEMS_WR(x, HW_UART_ONEMS_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_ONEMS bitfields */ /*! @name Register UART_ONEMS, field ONEMS[23:0] (RW) * * One Millisecond Register. This 24-bit register must contain the value of the UART internal * frequency ( ref_clk in ) divided by 1000. The internal frequency is obtained after the UART BRM * internal divider (F ( ref_clk ) = F( module_clock ) / RFDIV). In fact this register contains the * value corresponding to the number of UART BRM internal clock cycles present in one millisecond. * The ONEMS (and UTIM) registers value are used in the escape character detection feature ( ) to * count the number of clock cycles left between two escape characters. The ONEMS register is also * used in infrared special case mode (IRSC = UCR4[5] = 1'b1), see . */ //@{ #define BP_UART_ONEMS_ONEMS (0) //!< Bit position for UART_ONEMS_ONEMS. #define BM_UART_ONEMS_ONEMS (0x00ffffff) //!< Bit mask for UART_ONEMS_ONEMS. //! @brief Get value of UART_ONEMS_ONEMS from a register value. #define BG_UART_ONEMS_ONEMS(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_ONEMS_ONEMS) >> BP_UART_ONEMS_ONEMS) //! @brief Format value for bitfield UART_ONEMS_ONEMS. #define BF_UART_ONEMS_ONEMS(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_ONEMS_ONEMS) & BM_UART_ONEMS_ONEMS) #ifndef __LANGUAGE_ASM__ //! @brief Set the ONEMS field to a new value. #define BW_UART_ONEMS_ONEMS(x, v) (HW_UART_ONEMS_WR(x, (HW_UART_ONEMS_RD(x) & ~BM_UART_ONEMS_ONEMS) | BF_UART_ONEMS_ONEMS(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UTS - UART Test Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UTS - UART Test Register (RW) * * Reset value: 0x00000060 */ typedef union _hw_uart_uts { reg32_t U; struct _hw_uart_uts_bitfields { unsigned SOFTRST : 1; //!< [0] Software Reset. unsigned RESERVED0 : 2; //!< [2:1] Reserved unsigned RXFULL : 1; //!< [3] RxFIFO FULL. unsigned TXFULL : 1; //!< [4] TxFIFO FULL. unsigned RXEMPTY : 1; //!< [5] RxFIFO Empty. unsigned TXEMPTY : 1; //!< [6] TxFIFO Empty. unsigned RESERVED1 : 2; //!< [8:7] Reserved unsigned RXDBG : 1; //!< [9] unsigned LOOPIR : 1; //!< [10] Loop TX and RX for IR Test (LOOPIR) . unsigned DBGEN : 1; //!< [11] unsigned LOOP : 1; //!< [12] Loop TX and RX for Test. unsigned FRCPERR : 1; //!< [13] Force Parity Error. unsigned RESERVED2 : 18; //!< [31:14] Reserved } B; } hw_uart_uts_t; #endif /*! * @name Constants and macros for entire UART_UTS register */ //@{ #define HW_UART_UTS_ADDR(x) (REGS_UART_BASE(x) + 0xb4) #ifndef __LANGUAGE_ASM__ #define HW_UART_UTS(x) (*(volatile hw_uart_uts_t *) HW_UART_UTS_ADDR(x)) #define HW_UART_UTS_RD(x) (HW_UART_UTS(x).U) #define HW_UART_UTS_WR(x, v) (HW_UART_UTS(x).U = (v)) #define HW_UART_UTS_SET(x, v) (HW_UART_UTS_WR(x, HW_UART_UTS_RD(x) | (v))) #define HW_UART_UTS_CLR(x, v) (HW_UART_UTS_WR(x, HW_UART_UTS_RD(x) & ~(v))) #define HW_UART_UTS_TOG(x, v) (HW_UART_UTS_WR(x, HW_UART_UTS_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UTS bitfields */ /*! @name Register UART_UTS, field SOFTRST[0] (RW) * * Software Reset. Indicates the status of the software reset ( SRST bit of UCR2). * * Values: * - 0 - Software reset inactive * - 1 - Software reset active */ //@{ #define BP_UART_UTS_SOFTRST (0) //!< Bit position for UART_UTS_SOFTRST. #define BM_UART_UTS_SOFTRST (0x00000001) //!< Bit mask for UART_UTS_SOFTRST. //! @brief Get value of UART_UTS_SOFTRST from a register value. #define BG_UART_UTS_SOFTRST(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_SOFTRST) >> BP_UART_UTS_SOFTRST) //! @brief Format value for bitfield UART_UTS_SOFTRST. #define BF_UART_UTS_SOFTRST(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_SOFTRST) & BM_UART_UTS_SOFTRST) #ifndef __LANGUAGE_ASM__ //! @brief Set the SOFTRST field to a new value. #define BW_UART_UTS_SOFTRST(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_SOFTRST) | BF_UART_UTS_SOFTRST(v))) #endif //@} /*! @name Register UART_UTS, field RXFULL[3] (RW) * * RxFIFO FULL. Indicates the RxFIFO is full. * * Values: * - 0 - The RxFIFO is not full * - 1 - The RxFIFO is full */ //@{ #define BP_UART_UTS_RXFULL (3) //!< Bit position for UART_UTS_RXFULL. #define BM_UART_UTS_RXFULL (0x00000008) //!< Bit mask for UART_UTS_RXFULL. //! @brief Get value of UART_UTS_RXFULL from a register value. #define BG_UART_UTS_RXFULL(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_RXFULL) >> BP_UART_UTS_RXFULL) //! @brief Format value for bitfield UART_UTS_RXFULL. #define BF_UART_UTS_RXFULL(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_RXFULL) & BM_UART_UTS_RXFULL) #ifndef __LANGUAGE_ASM__ //! @brief Set the RXFULL field to a new value. #define BW_UART_UTS_RXFULL(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_RXFULL) | BF_UART_UTS_RXFULL(v))) #endif //@} /*! @name Register UART_UTS, field TXFULL[4] (RW) * * TxFIFO FULL. Indicates the TxFIFO is full. * * Values: * - 0 - The TxFIFO is not full * - 1 - The TxFIFO is full */ //@{ #define BP_UART_UTS_TXFULL (4) //!< Bit position for UART_UTS_TXFULL. #define BM_UART_UTS_TXFULL (0x00000010) //!< Bit mask for UART_UTS_TXFULL. //! @brief Get value of UART_UTS_TXFULL from a register value. #define BG_UART_UTS_TXFULL(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_TXFULL) >> BP_UART_UTS_TXFULL) //! @brief Format value for bitfield UART_UTS_TXFULL. #define BF_UART_UTS_TXFULL(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_TXFULL) & BM_UART_UTS_TXFULL) #ifndef __LANGUAGE_ASM__ //! @brief Set the TXFULL field to a new value. #define BW_UART_UTS_TXFULL(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_TXFULL) | BF_UART_UTS_TXFULL(v))) #endif //@} /*! @name Register UART_UTS, field RXEMPTY[5] (RW) * * RxFIFO Empty. Indicates the RxFIFO is empty. * * Values: * - 0 - The RxFIFO is not empty * - 1 - The RxFIFO is empty */ //@{ #define BP_UART_UTS_RXEMPTY (5) //!< Bit position for UART_UTS_RXEMPTY. #define BM_UART_UTS_RXEMPTY (0x00000020) //!< Bit mask for UART_UTS_RXEMPTY. //! @brief Get value of UART_UTS_RXEMPTY from a register value. #define BG_UART_UTS_RXEMPTY(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_RXEMPTY) >> BP_UART_UTS_RXEMPTY) //! @brief Format value for bitfield UART_UTS_RXEMPTY. #define BF_UART_UTS_RXEMPTY(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_RXEMPTY) & BM_UART_UTS_RXEMPTY) #ifndef __LANGUAGE_ASM__ //! @brief Set the RXEMPTY field to a new value. #define BW_UART_UTS_RXEMPTY(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_RXEMPTY) | BF_UART_UTS_RXEMPTY(v))) #endif //@} /*! @name Register UART_UTS, field TXEMPTY[6] (RW) * * TxFIFO Empty. Indicates that the TxFIFO is empty. * * Values: * - 0 - The TxFIFO is not empty * - 1 - The TxFIFO is empty */ //@{ #define BP_UART_UTS_TXEMPTY (6) //!< Bit position for UART_UTS_TXEMPTY. #define BM_UART_UTS_TXEMPTY (0x00000040) //!< Bit mask for UART_UTS_TXEMPTY. //! @brief Get value of UART_UTS_TXEMPTY from a register value. #define BG_UART_UTS_TXEMPTY(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_TXEMPTY) >> BP_UART_UTS_TXEMPTY) //! @brief Format value for bitfield UART_UTS_TXEMPTY. #define BF_UART_UTS_TXEMPTY(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_TXEMPTY) & BM_UART_UTS_TXEMPTY) #ifndef __LANGUAGE_ASM__ //! @brief Set the TXEMPTY field to a new value. #define BW_UART_UTS_TXEMPTY(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_TXEMPTY) | BF_UART_UTS_TXEMPTY(v))) #endif //@} /*! @name Register UART_UTS, field RXDBG[9] (RW) * * RX_fifo_debug_mode. This bit controls the operation of the RX fifo read counter when in debug * mode. * * Values: * - 0 - rx fifo read pointer does not increment * - 1 - rx_fifo read pointer increments as normal */ //@{ #define BP_UART_UTS_RXDBG (9) //!< Bit position for UART_UTS_RXDBG. #define BM_UART_UTS_RXDBG (0x00000200) //!< Bit mask for UART_UTS_RXDBG. //! @brief Get value of UART_UTS_RXDBG from a register value. #define BG_UART_UTS_RXDBG(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_RXDBG) >> BP_UART_UTS_RXDBG) //! @brief Format value for bitfield UART_UTS_RXDBG. #define BF_UART_UTS_RXDBG(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_RXDBG) & BM_UART_UTS_RXDBG) #ifndef __LANGUAGE_ASM__ //! @brief Set the RXDBG field to a new value. #define BW_UART_UTS_RXDBG(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_RXDBG) | BF_UART_UTS_RXDBG(v))) #endif //@} /*! @name Register UART_UTS, field LOOPIR[10] (RW) * * Loop TX and RX for IR Test (LOOPIR) . This bit controls loopback from transmitter to receiver in * the InfraRed interface. * * Values: * - 0 - No IR loop * - 1 - Connect IR transmitter to IR receiver */ //@{ #define BP_UART_UTS_LOOPIR (10) //!< Bit position for UART_UTS_LOOPIR. #define BM_UART_UTS_LOOPIR (0x00000400) //!< Bit mask for UART_UTS_LOOPIR. //! @brief Get value of UART_UTS_LOOPIR from a register value. #define BG_UART_UTS_LOOPIR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_LOOPIR) >> BP_UART_UTS_LOOPIR) //! @brief Format value for bitfield UART_UTS_LOOPIR. #define BF_UART_UTS_LOOPIR(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_LOOPIR) & BM_UART_UTS_LOOPIR) #ifndef __LANGUAGE_ASM__ //! @brief Set the LOOPIR field to a new value. #define BW_UART_UTS_LOOPIR(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_LOOPIR) | BF_UART_UTS_LOOPIR(v))) #endif //@} /*! @name Register UART_UTS, field DBGEN[11] (RW) * * debug_enable . This bit controls whether to respond to the debug_req input signal. * * Values: * - 0 - UART will go into debug mode when debug_req is HIGH * - 1 - UART will not go into debug mode even if debug_req is HIGH */ //@{ #define BP_UART_UTS_DBGEN (11) //!< Bit position for UART_UTS_DBGEN. #define BM_UART_UTS_DBGEN (0x00000800) //!< Bit mask for UART_UTS_DBGEN. //! @brief Get value of UART_UTS_DBGEN from a register value. #define BG_UART_UTS_DBGEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_DBGEN) >> BP_UART_UTS_DBGEN) //! @brief Format value for bitfield UART_UTS_DBGEN. #define BF_UART_UTS_DBGEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_DBGEN) & BM_UART_UTS_DBGEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the DBGEN field to a new value. #define BW_UART_UTS_DBGEN(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_DBGEN) | BF_UART_UTS_DBGEN(v))) #endif //@} /*! @name Register UART_UTS, field LOOP[12] (RW) * * Loop TX and RX for Test. Controls loopback for test purposes. When LOOP is high, the receiver * input is internally connected to the transmitter and ignores the RXD pin. The transmitter is * unaffected by LOOP. If RXDMUXSEL (UCR3[2]) is set to 1, the loopback is applied on serial and * IrDA signals. If RXDMUXSEL is set to 0, the loopback is only applied on serial signals. * * Values: * - 0 - Normal receiver operation * - 1 - Internally connect the transmitter output to the receiver input */ //@{ #define BP_UART_UTS_LOOP (12) //!< Bit position for UART_UTS_LOOP. #define BM_UART_UTS_LOOP (0x00001000) //!< Bit mask for UART_UTS_LOOP. //! @brief Get value of UART_UTS_LOOP from a register value. #define BG_UART_UTS_LOOP(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_LOOP) >> BP_UART_UTS_LOOP) //! @brief Format value for bitfield UART_UTS_LOOP. #define BF_UART_UTS_LOOP(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_LOOP) & BM_UART_UTS_LOOP) #ifndef __LANGUAGE_ASM__ //! @brief Set the LOOP field to a new value. #define BW_UART_UTS_LOOP(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_LOOP) | BF_UART_UTS_LOOP(v))) #endif //@} /*! @name Register UART_UTS, field FRCPERR[13] (RW) * * Force Parity Error. Forces the transmitter to generate a parity error if parity is enabled. * FRCPERR is provided for system debugging. * * Values: * - 0 - Generate normal parity * - 1 - Generate inverted parity (error) */ //@{ #define BP_UART_UTS_FRCPERR (13) //!< Bit position for UART_UTS_FRCPERR. #define BM_UART_UTS_FRCPERR (0x00002000) //!< Bit mask for UART_UTS_FRCPERR. //! @brief Get value of UART_UTS_FRCPERR from a register value. #define BG_UART_UTS_FRCPERR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UTS_FRCPERR) >> BP_UART_UTS_FRCPERR) //! @brief Format value for bitfield UART_UTS_FRCPERR. #define BF_UART_UTS_FRCPERR(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UTS_FRCPERR) & BM_UART_UTS_FRCPERR) #ifndef __LANGUAGE_ASM__ //! @brief Set the FRCPERR field to a new value. #define BW_UART_UTS_FRCPERR(x, v) (HW_UART_UTS_WR(x, (HW_UART_UTS_RD(x) & ~BM_UART_UTS_FRCPERR) | BF_UART_UTS_FRCPERR(v))) #endif //@} //------------------------------------------------------------------------------------------- // HW_UART_UMCR - UART RS-485 Mode Control Register //------------------------------------------------------------------------------------------- #ifndef __LANGUAGE_ASM__ /*! * @brief HW_UART_UMCR - UART RS-485 Mode Control Register (RW) * * Reset value: 0x00000000 */ typedef union _hw_uart_umcr { reg32_t U; struct _hw_uart_umcr_bitfields { unsigned MDEN : 1; //!< [0] 9-bit data or Multidrop Mode (RS-485) Enable. unsigned SLAM : 1; //!< [1] RS-485 Slave Address Detect Mode Selection. unsigned TXB8 : 1; //!< [2] Transmit RS-485 bit 8 (the ninth bit or 9 th bit). unsigned SADEN : 1; //!< [3] RS-485 Slave Address Detected Interrupt Enable. unsigned RESERVED0 : 4; //!< [7:4] Reserved unsigned SLADDR : 8; //!< [15:8] RS-485 Slave Address Character. unsigned RESERVED1 : 16; //!< [31:16] Reserved } B; } hw_uart_umcr_t; #endif /*! * @name Constants and macros for entire UART_UMCR register */ //@{ #define HW_UART_UMCR_ADDR(x) (REGS_UART_BASE(x) + 0xb8) #ifndef __LANGUAGE_ASM__ #define HW_UART_UMCR(x) (*(volatile hw_uart_umcr_t *) HW_UART_UMCR_ADDR(x)) #define HW_UART_UMCR_RD(x) (HW_UART_UMCR(x).U) #define HW_UART_UMCR_WR(x, v) (HW_UART_UMCR(x).U = (v)) #define HW_UART_UMCR_SET(x, v) (HW_UART_UMCR_WR(x, HW_UART_UMCR_RD(x) | (v))) #define HW_UART_UMCR_CLR(x, v) (HW_UART_UMCR_WR(x, HW_UART_UMCR_RD(x) & ~(v))) #define HW_UART_UMCR_TOG(x, v) (HW_UART_UMCR_WR(x, HW_UART_UMCR_RD(x) ^ (v))) #endif //@} /* * constants & macros for individual UART_UMCR bitfields */ /*! @name Register UART_UMCR, field MDEN[0] (RW) * * 9-bit data or Multidrop Mode (RS-485) Enable. * * Values: * - 0 - Normal RS-232 or IrDA mode, see for detail. * - 1 - Enable RS-485 mode, see for detail */ //@{ #define BP_UART_UMCR_MDEN (0) //!< Bit position for UART_UMCR_MDEN. #define BM_UART_UMCR_MDEN (0x00000001) //!< Bit mask for UART_UMCR_MDEN. //! @brief Get value of UART_UMCR_MDEN from a register value. #define BG_UART_UMCR_MDEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UMCR_MDEN) >> BP_UART_UMCR_MDEN) //! @brief Format value for bitfield UART_UMCR_MDEN. #define BF_UART_UMCR_MDEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UMCR_MDEN) & BM_UART_UMCR_MDEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the MDEN field to a new value. #define BW_UART_UMCR_MDEN(x, v) (HW_UART_UMCR_WR(x, (HW_UART_UMCR_RD(x) & ~BM_UART_UMCR_MDEN) | BF_UART_UMCR_MDEN(v))) #endif //@} /*! @name Register UART_UMCR, field SLAM[1] (RW) * * RS-485 Slave Address Detect Mode Selection. * * Values: * - 0 - Select Normal Address Detect mode * - 1 - Select Automatic Address Detect mode */ //@{ #define BP_UART_UMCR_SLAM (1) //!< Bit position for UART_UMCR_SLAM. #define BM_UART_UMCR_SLAM (0x00000002) //!< Bit mask for UART_UMCR_SLAM. //! @brief Get value of UART_UMCR_SLAM from a register value. #define BG_UART_UMCR_SLAM(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UMCR_SLAM) >> BP_UART_UMCR_SLAM) //! @brief Format value for bitfield UART_UMCR_SLAM. #define BF_UART_UMCR_SLAM(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UMCR_SLAM) & BM_UART_UMCR_SLAM) #ifndef __LANGUAGE_ASM__ //! @brief Set the SLAM field to a new value. #define BW_UART_UMCR_SLAM(x, v) (HW_UART_UMCR_WR(x, (HW_UART_UMCR_RD(x) & ~BM_UART_UMCR_SLAM) | BF_UART_UMCR_SLAM(v))) #endif //@} /*! @name Register UART_UMCR, field TXB8[2] (RW) * * Transmit RS-485 bit 8 (the ninth bit or 9 th bit). In RS-485 mode, software writes TXB8 bit as * the 9 th data bit to be transmitted. * * Values: * - 0 - 0 will be transmitted as the RS485 9 th data bit * - 1 - 1 will be transmitted as the RS485 9 th data bit */ //@{ #define BP_UART_UMCR_TXB8 (2) //!< Bit position for UART_UMCR_TXB8. #define BM_UART_UMCR_TXB8 (0x00000004) //!< Bit mask for UART_UMCR_TXB8. //! @brief Get value of UART_UMCR_TXB8 from a register value. #define BG_UART_UMCR_TXB8(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UMCR_TXB8) >> BP_UART_UMCR_TXB8) //! @brief Format value for bitfield UART_UMCR_TXB8. #define BF_UART_UMCR_TXB8(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UMCR_TXB8) & BM_UART_UMCR_TXB8) #ifndef __LANGUAGE_ASM__ //! @brief Set the TXB8 field to a new value. #define BW_UART_UMCR_TXB8(x, v) (HW_UART_UMCR_WR(x, (HW_UART_UMCR_RD(x) & ~BM_UART_UMCR_TXB8) | BF_UART_UMCR_TXB8(v))) #endif //@} /*! @name Register UART_UMCR, field SADEN[3] (RW) * * RS-485 Slave Address Detected Interrupt Enable. * * Values: * - 0 - Disable RS-485 Slave Address Detected Interrupt * - 1 - Enable RS-485 Slave Address Detected Interrupt */ //@{ #define BP_UART_UMCR_SADEN (3) //!< Bit position for UART_UMCR_SADEN. #define BM_UART_UMCR_SADEN (0x00000008) //!< Bit mask for UART_UMCR_SADEN. //! @brief Get value of UART_UMCR_SADEN from a register value. #define BG_UART_UMCR_SADEN(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UMCR_SADEN) >> BP_UART_UMCR_SADEN) //! @brief Format value for bitfield UART_UMCR_SADEN. #define BF_UART_UMCR_SADEN(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UMCR_SADEN) & BM_UART_UMCR_SADEN) #ifndef __LANGUAGE_ASM__ //! @brief Set the SADEN field to a new value. #define BW_UART_UMCR_SADEN(x, v) (HW_UART_UMCR_WR(x, (HW_UART_UMCR_RD(x) & ~BM_UART_UMCR_SADEN) | BF_UART_UMCR_SADEN(v))) #endif //@} /*! @name Register UART_UMCR, field SLADDR[15:8] (RW) * * RS-485 Slave Address Character. Holds the selected slave adress character that the receiver wil * try to detect. */ //@{ #define BP_UART_UMCR_SLADDR (8) //!< Bit position for UART_UMCR_SLADDR. #define BM_UART_UMCR_SLADDR (0x0000ff00) //!< Bit mask for UART_UMCR_SLADDR. //! @brief Get value of UART_UMCR_SLADDR from a register value. #define BG_UART_UMCR_SLADDR(r) ((__REG_VALUE_TYPE((r), reg32_t) & BM_UART_UMCR_SLADDR) >> BP_UART_UMCR_SLADDR) //! @brief Format value for bitfield UART_UMCR_SLADDR. #define BF_UART_UMCR_SLADDR(v) ((__REG_VALUE_TYPE((v), reg32_t) << BP_UART_UMCR_SLADDR) & BM_UART_UMCR_SLADDR) #ifndef __LANGUAGE_ASM__ //! @brief Set the SLADDR field to a new value. #define BW_UART_UMCR_SLADDR(x, v) (HW_UART_UMCR_WR(x, (HW_UART_UMCR_RD(x) & ~BM_UART_UMCR_SLADDR) | BF_UART_UMCR_SLADDR(v))) #endif //@} //------------------------------------------------------------------------------------------- // hw_uart_t - module struct //------------------------------------------------------------------------------------------- /*! * @brief All UART module registers. */ #ifndef __LANGUAGE_ASM__ #pragma pack(1) typedef struct _hw_uart { volatile hw_uart_urxd_t URXD; //!< UART Receiver Register reg32_t _reserved0[15]; volatile hw_uart_utxd_t UTXD; //!< UART Transmitter Register reg32_t _reserved1[15]; volatile hw_uart_ucr1_t UCR1; //!< UART Control Register 1 volatile hw_uart_ucr2_t UCR2; //!< UART Control Register 2 volatile hw_uart_ucr3_t UCR3; //!< UART Control Register 3 volatile hw_uart_ucr4_t UCR4; //!< UART Control Register 4 volatile hw_uart_ufcr_t UFCR; //!< UART FIFO Control Register volatile hw_uart_usr1_t USR1; //!< UART Status Register 1 volatile hw_uart_usr2_t USR2; //!< UART Status Register 2 volatile hw_uart_uesc_t UESC; //!< UART Escape Character Register volatile hw_uart_utim_t UTIM; //!< UART Escape Timer Register volatile hw_uart_ubir_t UBIR; //!< UART BRM Incremental Register volatile hw_uart_ubmr_t UBMR; //!< UART BRM Modulator Register volatile hw_uart_ubrc_t UBRC; //!< UART Baud Rate Count Register volatile hw_uart_onems_t ONEMS; //!< UART One Millisecond Register volatile hw_uart_uts_t UTS; //!< UART Test Register volatile hw_uart_umcr_t UMCR; //!< UART RS-485 Mode Control Register } hw_uart_t; #pragma pack() //! @brief Macro to access all UART registers. //! @param x UART instance number. //! @return Reference (not a pointer) to the registers struct. To get a pointer to the struct, //! use the '&' operator, like &HW_UART(0). #define HW_UART(x) (*(hw_uart_t *) REGS_UART_BASE(x)) #endif #endif // __HW_UART_REGISTERS_H__ // v18/121106/1.2.2 // EOF