uart.h

/*
 * File	: uart.h
 * Copyright (C) 2013 - 2016, Espressif Systems
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of version 3 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef UART_APP_H
#define UART_APP_H

#include "uart_register.h"
#include "eagle_soc.h"
#include "c_types.h"

#define UART_TX_BUFFER_SIZE 256  //Ring buffer length of tx buffer
#define UART_RX_BUFFER_SIZE 256  //Ring buffer length of rx buffer

#define UART_SELFTEST 0   //set 1:enable the loop test demo for uart buffer, FOR UART0

#define UART_HW_RTS  0    //set 1: enable uart hw flow control RTS, PIN MTDO, FOR UART0
#define UART_HW_CTS  0    //set 1: enable uart hw flow control CTS, PIN MTCK, FOR UART0

#define UART0   0
#define UART1   1

//calc bit 0..5 for  UART_CONF0 register - FROM  Uart_reg_release_141118.xls
// stop_bit_num 	[5:4]	2'd1	R/W		Set stop bit: 1:1bit  2:1.5bits  3:2bits
// bit_num		 	[3:2]	2'd3	R/W		Set bit num:  0:5bits 1:6bits 2:7bits 3:8bits
// parity_en		[1]		1'b0	R/W		Set this bit to enable uart parity check
// parity			[0]		1'b0	R/W		Set parity check:  0:even 1:odd
#define CALC_UARTMODE(data_bits,parity,stop_bits) \
	(((parity == NONE_BITS) ? 0x0 : (UART_PARITY_EN | (parity & UART_PARITY))) | \
	((stop_bits & UART_STOP_BIT_NUM) << UART_STOP_BIT_NUM_S) | \
	((data_bits & UART_BIT_NUM) << UART_BIT_NUM_S))
//get data_bits from UART_CONF0 register
#define GETUART_DATABITS(uartmode) ((uartmode >> UART_BIT_NUM_S) & UART_BIT_NUM)
//get stop_bits from UART_CONF0 register
#define GETUART_STOPBITS(uartmode) ((uartmode >> UART_STOP_BIT_NUM_S) & UART_STOP_BIT_NUM)
//get parity from UART_CONF0 register
#define GETUART_PARITYMODE(uartmode) ((uartmode & UART_PARITY_EN) ? uartmode & UART_PARITY : NONE_BITS)

typedef enum {
	FIVE_BITS  = 0x0,
	SIX_BITS   = 0x1,
	SEVEN_BITS = 0x2,
	EIGHT_BITS = 0x3
} UartBitsNum4Char;

typedef enum {
	ONE_STOP_BIT      = 0x1,
	ONE_HALF_STOP_BIT = 0x2,
	TWO_STOP_BIT      = 0x3
} UartStopBitsNum;

typedef enum {
	NONE_BITS = 0x2,
	ODD_BITS  = 0x1,
	EVEN_BITS = 0x0
} UartParityMode;

typedef enum {
    STICK_PARITY_DIS   = 0,
    STICK_PARITY_EN    = 1
} UartExistParity;

typedef enum {
    UART_None_Inverse = 0x0,
    UART_Rxd_Inverse = UART_RXD_INV,
    UART_CTS_Inverse = UART_CTS_INV,
    UART_Txd_Inverse = UART_TXD_INV,
    UART_RTS_Inverse = UART_RTS_INV,
} UART_LineLevelInverse;

typedef enum {
	BIT_RATE_300    = 300,
	BIT_RATE_600    = 600,
	BIT_RATE_1200   = 1200,
	BIT_RATE_2400   = 2400,
	BIT_RATE_4800   = 4800,
	BIT_RATE_9600   = 9600,
	BIT_RATE_19200  = 19200,
	BIT_RATE_38400  = 38400,
	BIT_RATE_57600  = 57600,
	BIT_RATE_74880  = 74880,
	BIT_RATE_115200 = 115200,
	BIT_RATE_230400 = 230400,
	BIT_RATE_256000 = 256000,
	BIT_RATE_312500 = 312500,
	BIT_RATE_320000 = 320000,
	BIT_RATE_460800 = 460800,
	BIT_RATE_576000 = 576000,
	BIT_RATE_921600 = 921600,
	BIT_RATE_1843200 = 1843200,
	BIT_RATE_3686400 = 3686400
} UartBautRate;

typedef enum {
	NONE_CTRL,
	HARDWARE_CTRL,
	XON_XOFF_CTRL
} UartFlowCtrl;

typedef enum {
    USART_HardwareFlowControl_None = 0x0,
    USART_HardwareFlowControl_RTS = 0x1,
    USART_HardwareFlowControl_CTS = 0x2,
    USART_HardwareFlowControl_CTS_RTS = 0x3
} UART_HwFlowCtrl;

typedef enum {
	EMPTY,
	UNDER_WRITE,
	WRITE_OVER
} RcvMsgBuffState;

typedef struct {
	uint32	RcvBuffSize;
	uint8	*pRcvMsgBuff;
	uint8	*pWritePos;
	uint8	*pReadPos;
	uint8	TrigLvl; //JLU: may need to pad
	RcvMsgBuffState  BuffState;
} RcvMsgBuff;

typedef struct {
	uint32	TrxBuffSize;
	uint8	*pTrxBuff;
} TrxMsgBuff;

typedef enum {
	BAUD_RATE_DET,
	WAIT_SYNC_FRM,
	SRCH_MSG_HEAD,
	RCV_MSG_BODY,
	RCV_ESC_CHAR,
} RcvMsgState;

typedef struct {
	UartBautRate		baut_rate;
	UartBitsNum4Char	data_bits;
	UartExistParity		exist_parity;
	UartParityMode		parity;
	UartStopBitsNum		stop_bits;
	UartFlowCtrl		flow_ctrl;
	RcvMsgBuff			rcv_buff;
	TrxMsgBuff			trx_buff;
	RcvMsgState			rcv_state;
	int					received;
	int					buff_uart_no;  //indicate which uart use tx/rx buffer
} UartDevice;

void uart_init(UartBautRate uart0_br, UartBautRate uart1_br);
void uart0_sendStr(const char *str);
void uart0_send(char *buf);


///////////////////////////////////////
#define UART_FIFO_LEN  128  //define the tx fifo length
#define UART_TX_EMPTY_THRESH_VAL 0x10


 struct UartBuffer{
    uint32     UartBuffSize;
    uint8     *pUartBuff;
    uint8     *pInPos;
    uint8     *pOutPos;
    STATUS  BuffState;
    uint16    Space;  //remanent space of the buffer
    uint8  TcpControl;
    struct  UartBuffer     *  nextBuff;
};

struct UartRxBuff{
    uint32     UartRxBuffSize;
    uint8     *pUartRxBuff;
    uint8     *pWritePos;
    uint8     *pReadPos;
    STATUS RxBuffState;
    uint32    Space;  //remanent space of the buffer
} ;

typedef enum {
    RUN = 0,
    BLOCK = 1,
} TCPState;

//void ICACHE_FLASH_ATTR uart_test_rx();
STATUS uart_tx_one_char(uint8 uart, uint8 TxChar);
STATUS uart_tx_one_char_no_wait(uint8 uart, uint8 TxChar);
void  uart1_sendStr_no_wait(const char *str);
struct UartBuffer*  Uart_Buf_Init();

void  uart_rx_intr_enable(uint8 uart_no);
void  uart_rx_intr_disable(uint8 uart_no);
void uart0_tx_buffer(uint8 *buf, uint16 len);

//==============================================
#define FUNC_UART0_CTS 4
#define FUNC_U0CTS                      4
#define FUNC_U1TXD_BK                   2
#define UART_LINE_INV_MASK  (0x3f<<19)
void UART_SetWordLength(uint8 uart_no, UartBitsNum4Char len);
void UART_SetStopBits(uint8 uart_no, UartStopBitsNum bit_num);
void UART_SetLineInverse(uint8 uart_no, UART_LineLevelInverse inverse_mask);
void UART_SetParity(uint8 uart_no, UartParityMode Parity_mode);
void UART_SetBaudrate(uint8 uart_no,uint32 baud_rate);
void UART_SetFlowCtrl(uint8 uart_no,UART_HwFlowCtrl flow_ctrl,uint8 rx_thresh);
void UART_WaitTxFifoEmpty(uint8 uart_no , uint32 time_out_us); //do not use if tx flow control enabled
void UART_ResetFifo(uint8 uart_no);
void UART_ClearIntrStatus(uint8 uart_no,uint32 clr_mask);
void UART_SetIntrEna(uint8 uart_no,uint32 ena_mask);
void UART_SetPrintPort(uint8 uart_no);
bool UART_CheckOutputFinished(uint8 uart_no, uint32 time_out_us);
//==============================================

#endif