uart_11xx.h

Go to the documentation of this file.

/*
 * @brief LPC11xx UART chip driver
 *
 * @note
 * Copyright(C) NXP Semiconductors, 2012
 * All rights reserved.
 *
 * @par
 * Software that is described herein is for illustrative purposes only
 * which provides customers with programming information regarding the
 * LPC products.  This software is supplied "AS IS" without any warranties of
 * any kind, and NXP Semiconductors and its licensor disclaim any and
 * all warranties, express or implied, including all implied warranties of
 * merchantability, fitness for a particular purpose and non-infringement of
 * intellectual property rights.  NXP Semiconductors assumes no responsibility
 * or liability for the use of the software, conveys no license or rights under any
 * patent, copyright, mask work right, or any other intellectual property rights in
 * or to any products. NXP Semiconductors reserves the right to make changes
 * in the software without notification. NXP Semiconductors also makes no
 * representation or warranty that such application will be suitable for the
 * specified use without further testing or modification.
 *
 * @par
 * Permission to use, copy, modify, and distribute this software and its
 * documentation is hereby granted, under NXP Semiconductors' and its
 * licensor's relevant copyrights in the software, without fee, provided that it
 * is used in conjunction with NXP Semiconductors microcontrollers.  This
 * copyright, permission, and disclaimer notice must appear in all copies of
 * this code.
 */
 
#ifndef __UART_11XX_H_
#define __UART_11XX_H_
 
#include "ring_buffer.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct {                                        
        union {
                __IO uint32_t  DLL;                     
                __O  uint32_t  THR;                     
                __I  uint32_t  RBR;                     
        };
 
        union {
                __IO uint32_t IER;                      
                __IO uint32_t DLM;                      
        };
 
        union {
                __O  uint32_t FCR;                      
                __I  uint32_t IIR;                      
        };
 
        __IO uint32_t LCR;                              
        __IO uint32_t MCR;                              
        __I  uint32_t LSR;                              
        __I  uint32_t MSR;                              
        __IO uint32_t SCR;                              
        __IO uint32_t ACR;                              
        __IO uint32_t ICR;                              
        __IO uint32_t FDR;                              
        __IO uint32_t OSR;                              
        __IO uint32_t TER1;                             
        uint32_t  RESERVED0[3];
    __IO uint32_t HDEN;                         
        __I  uint32_t RESERVED1[1];
        __IO uint32_t SCICTRL;                  
        __IO uint32_t RS485CTRL;                
        __IO uint32_t RS485ADRMATCH;    
        __IO uint32_t RS485DLY;                 
        union {
                __IO uint32_t SYNCCTRL;         
                __I  uint32_t FIFOLVL;          
        };
 
        __IO uint32_t TER2;                             
} LPC_USART_T;
 
 
#define UART_RBR_MASKBIT    (0xFF)                      
#define UART_LOAD_DLL(div)  ((div) & 0xFF)              
#define UART_DLL_MASKBIT    (0xFF)                  
#define UART_LOAD_DLM(div)  (((div) >> 8) & 0xFF)       
#define UART_DLM_MASKBIT    (0xFF)                          
#define UART_IER_RBRINT      (1 << 0)   
#define UART_IER_THREINT     (1 << 1)   
#define UART_IER_RLSINT      (1 << 2)   
#define UART_IER_MSINT       (1 << 3)   
#define UART_IER_CTSINT      (1 << 7)   
#define UART_IER_ABEOINT     (1 << 8)   
#define UART_IER_ABTOINT     (1 << 9)   
#define UART_IER_BITMASK     (0x307)    
#define UART1_IER_BITMASK    (0x30F)    
#define UART2_IER_BITMASK    (0x38F)    
#define UART_IIR_INTSTAT_PEND   (1 << 0)        
#define UART_IIR_FIFO_EN        (3 << 6)        
#define UART_IIR_ABEO_INT       (1 << 8)        
#define UART_IIR_ABTO_INT       (1 << 9)        
#define UART_IIR_BITMASK        (0x3CF)         
/* Interrupt ID bit definitions */
#define UART_IIR_INTID_MASK     (7 << 1)        
#define UART_IIR_INTID_RLS      (3 << 1)        
#define UART_IIR_INTID_RDA      (2 << 1)        
#define UART_IIR_INTID_CTI      (6 << 1)        
#define UART_IIR_INTID_THRE     (1 << 1)        
#define UART_IIR_INTID_MODEM    (0 << 1)        
#define UART_FCR_FIFO_EN        (1 << 0)        
#define UART_FCR_RX_RS          (1 << 1)        
#define UART_FCR_TX_RS          (1 << 2)        
#define UART_FCR_DMAMODE_SEL    (1 << 3)        
#define UART_FCR_BITMASK        (0xCF)          
#define UART_TX_FIFO_SIZE       (16)
 
/* FIFO trigger level bit definitions */
#define UART_FCR_TRG_LEV0       (0)                     
#define UART_FCR_TRG_LEV1       (1 << 6)        
#define UART_FCR_TRG_LEV2       (2 << 6)        
#define UART_FCR_TRG_LEV3       (3 << 6)        
/* UART word length select bit definitions */
#define UART_LCR_WLEN_MASK      (3 << 0)                
#define UART_LCR_WLEN5          (0 << 0)                
#define UART_LCR_WLEN6          (1 << 0)                
#define UART_LCR_WLEN7          (2 << 0)                
#define UART_LCR_WLEN8          (3 << 0)                
/* UART Stop bit select bit definitions */
#define UART_LCR_SBS_MASK       (1 << 2)                
#define UART_LCR_SBS_1BIT       (0 << 2)                
#define UART_LCR_SBS_2BIT       (1 << 2)                
/* UART Parity enable bit definitions */
#define UART_LCR_PARITY_EN      (1 << 3)                
#define UART_LCR_PARITY_DIS     (0 << 3)                
#define UART_LCR_PARITY_ODD     (0 << 4)                
#define UART_LCR_PARITY_EVEN    (1 << 4)                
#define UART_LCR_PARITY_F_1     (2 << 4)                
#define UART_LCR_PARITY_F_0     (3 << 4)                
#define UART_LCR_BREAK_EN       (1 << 6)                
#define UART_LCR_DLAB_EN        (1 << 7)                
#define UART_LCR_BITMASK        (0xFF)                  
#define UART_MCR_DTR_CTRL       (1 << 0)                
#define UART_MCR_RTS_CTRL       (1 << 1)                
#define UART_MCR_LOOPB_EN       (1 << 4)                
#define UART_MCR_AUTO_RTS_EN    (1 << 6)                
#define UART_MCR_AUTO_CTS_EN    (1 << 7)                
#define UART_MCR_BITMASK        (0xD3)                  
#define UART_LSR_RDR        (1 << 0)    
#define UART_LSR_OE         (1 << 1)    
#define UART_LSR_PE         (1 << 2)    
#define UART_LSR_FE         (1 << 3)    
#define UART_LSR_BI         (1 << 4)    
#define UART_LSR_THRE       (1 << 5)    
#define UART_LSR_TEMT       (1 << 6)    
#define UART_LSR_RXFE       (1 << 7)    
#define UART_LSR_TXFE       (1 << 8)    
#define UART_LSR_BITMASK    (0xFF)              
#define UART1_LSR_BITMASK   (0x1FF)             
#define UART_MSR_DELTA_CTS      (1 << 0)        
#define UART_MSR_DELTA_DSR      (1 << 1)        
#define UART_MSR_LO2HI_RI       (1 << 2)        
#define UART_MSR_DELTA_DCD      (1 << 3)        
#define UART_MSR_CTS            (1 << 4)        
#define UART_MSR_DSR            (1 << 5)        
#define UART_MSR_RI             (1 << 6)        
#define UART_MSR_DCD            (1 << 7)        
#define UART_MSR_BITMASK        (0xFF)          
#define UART_ACR_START              (1 << 0)    
#define UART_ACR_MODE               (1 << 1)    
#define UART_ACR_AUTO_RESTART       (1 << 2)    
#define UART_ACR_ABEOINT_CLR        (1 << 8)    
#define UART_ACR_ABTOINT_CLR        (1 << 9)    
#define UART_ACR_BITMASK            (0x307)             
#define UART_RS485CTRL_NMM_EN       (1 << 0)    
#define UART_RS485CTRL_RX_DIS       (1 << 1)    
#define UART_RS485CTRL_AADEN        (1 << 2)    
#define UART_RS485CTRL_SEL_DTR      (1 << 3)    
#define UART_RS485CTRL_DCTRL_EN     (1 << 4)    
#define UART_RS485CTRL_OINV_1       (1 << 5)    
#define UART_RS485CTRL_BITMASK      (0x3F)              
#define UART_ICR_IRDAEN         (1 << 0)                        
#define UART_ICR_IRDAINV        (1 << 1)                        
#define UART_ICR_FIXPULSE_EN    (1 << 2)                        
#define UART_ICR_PULSEDIV(n)    ((n & 0x07) << 3)       
#define UART_ICR_BITMASK        (0x3F)                          
#define UART_HDEN_HDEN          ((1 << 0))                      
#define UART_SCICTRL_SCIEN        (1 << 0)                      
#define UART_SCICTRL_NACKDIS      (1 << 1)                      
#define UART_SCICTRL_PROTSEL_T1   (1 << 2)                      
#define UART_SCICTRL_TXRETRY(n)   ((n & 0x07) << 5)     
#define UART_SCICTRL_GUARDTIME(n) ((n & 0xFF) << 8)     
#define UART_FDR_DIVADDVAL(n)   (n & 0x0F)                      
#define UART_FDR_MULVAL(n)      ((n << 4) & 0xF0)       
#define UART_FDR_BITMASK        (0xFF)                          
#define UART_TER1_TXEN      (1 << 7)            
#define UART_TER2_TXEN      (1 << 0)            
#define UART_SYNCCTRL_SYNC             (1 << 0)                 
#define UART_SYNCCTRL_CSRC_MASTER      (1 << 1)                 
#define UART_SYNCCTRL_FES              (1 << 2)                 
#define UART_SYNCCTRL_TSBYPASS         (1 << 3)                 
#define UART_SYNCCTRL_CSCEN            (1 << 4)                 
#define UART_SYNCCTRL_STARTSTOPDISABLE (1 << 5)         
#define UART_SYNCCTRL_CCCLR            (1 << 6)                 
STATIC INLINE void Chip_UART_TXEnable(LPC_USART_T *pUART)
{
        pUART->TER1 = UART_TER1_TXEN;
}
 
STATIC INLINE void Chip_UART_TXDisable(LPC_USART_T *pUART)
{
        pUART->TER1 = 0;
}
 
STATIC INLINE void Chip_UART_SendByte(LPC_USART_T *pUART, uint8_t data)
{
        pUART->THR = (uint32_t) data;
}
 
STATIC INLINE uint8_t Chip_UART_ReadByte(LPC_USART_T *pUART)
{
        return (uint8_t) (pUART->RBR & UART_RBR_MASKBIT);
}
 
STATIC INLINE void Chip_UART_IntEnable(LPC_USART_T *pUART, uint32_t intMask)
{
        pUART->IER |= intMask;
}
 
STATIC INLINE void Chip_UART_IntDisable(LPC_USART_T *pUART, uint32_t intMask)
{
        pUART->IER &= ~intMask;
}
 
STATIC INLINE uint32_t Chip_UART_GetIntsEnabled(LPC_USART_T *pUART)
{
        return pUART->IER;
}
 
STATIC INLINE uint32_t Chip_UART_ReadIntIDReg(LPC_USART_T *pUART)
{
        return pUART->IIR;
}
 
STATIC INLINE void Chip_UART_SetupFIFOS(LPC_USART_T *pUART, uint32_t fcr)
{
        pUART->FCR = fcr;
}
 
STATIC INLINE void Chip_UART_ConfigData(LPC_USART_T *pUART, uint32_t config)
{
        pUART->LCR = config;
}
 
STATIC INLINE void Chip_UART_EnableDivisorAccess(LPC_USART_T *pUART)
{
        pUART->LCR |= UART_LCR_DLAB_EN;
}
 
STATIC INLINE void Chip_UART_DisableDivisorAccess(LPC_USART_T *pUART)
{
        pUART->LCR &= ~UART_LCR_DLAB_EN;
}
 
STATIC INLINE void Chip_UART_SetDivisorLatches(LPC_USART_T *pUART, uint8_t dll, uint8_t dlm)
{
        pUART->DLL = (uint32_t) dll;
        pUART->DLM = (uint32_t) dlm;
}
 
STATIC INLINE uint32_t Chip_UART_ReadModemControl(LPC_USART_T *pUART)
{
        return pUART->MCR;
}
 
STATIC INLINE void Chip_UART_SetModemControl(LPC_USART_T *pUART, uint32_t mcr)
{
        pUART->MCR |= mcr;
}
 
STATIC INLINE void Chip_UART_ClearModemControl(LPC_USART_T *pUART, uint32_t mcr)
{
        pUART->MCR &= ~mcr;
}
 
STATIC INLINE uint32_t Chip_UART_ReadLineStatus(LPC_USART_T *pUART)
{
        return pUART->LSR;
}
 
STATIC INLINE uint32_t Chip_UART_ReadModemStatus(LPC_USART_T *pUART)
{
        return pUART->MSR;
}
 
STATIC INLINE void Chip_UART_SetScratch(LPC_USART_T *pUART, uint8_t data)
{
        pUART->SCR = (uint32_t) data;
}
 
STATIC INLINE uint8_t Chip_UART_ReadScratch(LPC_USART_T *pUART)
{
        return (uint8_t) (pUART->SCR & 0xFF);
}
 
STATIC INLINE void Chip_UART_SetAutoBaudReg(LPC_USART_T *pUART, uint32_t acr)
{
        pUART->ACR |= acr;
}
 
STATIC INLINE void Chip_UART_ClearAutoBaudReg(LPC_USART_T *pUART, uint32_t acr)
{
        pUART->ACR &= ~acr;
}
 
STATIC INLINE void Chip_UART_SetRS485Flags(LPC_USART_T *pUART, uint32_t ctrl)
{
        pUART->RS485CTRL |= ctrl;
}
 
STATIC INLINE void Chip_UART_ClearRS485Flags(LPC_USART_T *pUART, uint32_t ctrl)
{
        pUART->RS485CTRL &= ~ctrl;
}
 
STATIC INLINE void Chip_UART_SetRS485Addr(LPC_USART_T *pUART, uint8_t addr)
{
        pUART->RS485ADRMATCH = (uint32_t) addr;
}
 
STATIC INLINE uint8_t Chip_UART_GetRS485Addr(LPC_USART_T *pUART)
{
        return (uint8_t) (pUART->RS485ADRMATCH & 0xFF);
}
 
STATIC INLINE void Chip_UART_SetRS485Delay(LPC_USART_T *pUART, uint8_t dly)
{
        pUART->RS485DLY = (uint32_t) dly;
}
 
STATIC INLINE uint8_t Chip_UART_GetRS485Delay(LPC_USART_T *pUART)
{
        return (uint8_t) (pUART->RS485DLY & 0xFF);
}
 
void Chip_UART_Init(LPC_USART_T *pUART);
 
void Chip_UART_DeInit(LPC_USART_T *pUART);
 
int Chip_UART_Send(LPC_USART_T *pUART, const void *data, int numBytes);
 
int Chip_UART_Read(LPC_USART_T *pUART, void *data, int numBytes);
 
uint32_t Chip_UART_SetBaud(LPC_USART_T *pUART, uint32_t baudrate);
 
uint32_t Chip_UART_SetBaudFDR(LPC_USART_T *pUART, uint32_t baudrate);
 
int Chip_UART_SendBlocking(LPC_USART_T *pUART, const void *data, int numBytes);
 
int Chip_UART_ReadBlocking(LPC_USART_T *pUART, void *data, int numBytes);
 
void Chip_UART_RXIntHandlerRB(LPC_USART_T *pUART, RINGBUFF_T *pRB);
 
void Chip_UART_TXIntHandlerRB(LPC_USART_T *pUART, RINGBUFF_T *pRB);
 
uint32_t Chip_UART_SendRB(LPC_USART_T *pUART, RINGBUFF_T *pRB, const void *data, int bytes);
 
int Chip_UART_ReadRB(LPC_USART_T *pUART, RINGBUFF_T *pRB, void *data, int bytes);
 
void Chip_UART_IRQRBHandler(LPC_USART_T *pUART, RINGBUFF_T *pRXRB, RINGBUFF_T *pTXRB);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __UART_11XX_H_ */