#include "BSPUart.h"
#include <cpu.h>
#include <os.h>
#include <os_cpu.h>
#include <bsp_int.h>
#include <bsp_sys.h>
#include <lib_def.h>
#include "BSPSys.h"

#define UART0_RECV_CACHE_MAX   256
#define UART1_RECV_CACHE_MAX   256
#define UART2_RECV_CACHE_MAX   256
#define UART3_RECV_CACHE_MAX   256
#define UART4_RECV_CACHE_MAX   256
#define UART5_RECV_CACHE_MAX   256
#define UART6_RECV_CACHE_MAX   256
#define UART7_RECV_CACHE_MAX   256

static uint8_t usr_uart0_recv_space[UART0_RECV_CACHE_MAX] = {0};
static uint32_t uart0_recv_local = 0;
static uint32_t uart0_recv_temp = 0;

static uint8_t usr_uart1_recv_space[UART1_RECV_CACHE_MAX] = {0};
static uint32_t uart1_recv_local = 0;
static uint32_t uart1_recv_temp = 0;

static uint8_t usr_uart2_recv_space[UART2_RECV_CACHE_MAX] = {0};
static uint32_t uart2_recv_local = 0;
static uint32_t uart2_recv_temp = 0;

static uint8_t usr_uart3_recv_space[UART3_RECV_CACHE_MAX] = {0};
static uint32_t uart3_recv_local = 0;
static uint32_t uart3_recv_temp = 0;

static uint8_t usr_uart4_recv_space[UART4_RECV_CACHE_MAX] = {0};
static uint32_t uart4_recv_local = 0;
static uint32_t uart4_recv_temp = 0;

static uint8_t usr_uart5_recv_space[UART5_RECV_CACHE_MAX] = {0};
static uint32_t uart5_recv_local = 0;
static uint32_t uart5_recv_temp = 0;

static uint8_t usr_uart6_recv_space[UART6_RECV_CACHE_MAX] = {0};
static uint32_t uart6_recv_local = 0;
static uint32_t uart6_recv_temp = 0;

static uint8_t usr_uart7_recv_space[UART7_RECV_CACHE_MAX] = {0};
static uint32_t uart7_recv_local = 0;
static uint32_t uart7_recv_temp = 0;

static void BspUart0IntHandler(void);
static void BspUart1IntHandler(void);
static void BspUart2IntHandler(void);
static void BspUart3IntHandler(void);
static void BspUart4IntHandler(void);
static void BspUart5IntHandler(void);
static void BspUart6IntHandler(void);
static void BspUart7IntHandler(void);

/* UART初始化
 * 参数
 *      uart_id(串口ID):    USR_UART_ID_0
 *                          USR_UART_ID_1
 *                          USR_UART_ID_2
 *                          USR_UART_ID_3
 *                          USR_UART_ID_4
 *                          USR_UART_ID_5
 *                          USR_UART_ID_6
 *                          USR_UART_ID_7
 *      bandrate(波特率):   USR_UART_BANDRATE_9600
 *                          USR_UART_BANDRATE_14400
 *                          USR_UART_BANDRATE_19200
 *                          USR_UART_BANDRATE_38400
 *                          USR_UART_BANDRATE_56000
 *                          USR_UART_BANDRATE_57600
 *                          USR_UART_BANDRATE_115200
 *      databit(数据位):    USR_UART_DATABIT_8
 *                          USR_UART_DATABIT_7
 *                          USR_UART_DATABIT_6
 *                          USR_UART_DATABIT_5
 *      stopbit(停止位):    USR_UART_STOPBIT_ONE
 *                          USR_UART_STOPBIT_TWO
 *      checkbit(校验位):   USR_UART_CHECKBIT_NONE
 *                          USR_UART_CHECKBIT_EVEN
 *                          USR_UART_CHECKBIT_ODD
 * 返回值:
 *      0: 表示成功
 *      -1:表示失败
 */
int8_t UartCommonInit(uint32_t uart_sysctl, uint32_t gpio_sysctl, 
                        uint32_t uart_base, uint32_t gpio_base, 
                        uint32_t gpio_rx, uint32_t gpio_tx, 
                        uint32_t gpio_rx_pin, uint32_t gpio_tx_pin,
                        uint32_t int_id, void (*int_handler)(void),
                        uint32_t int_uart, uint32_t bandrate, 
                        uint8_t databit, uint8_t stopbit, uint8_t checkbit) {
    SysCtlPeripheralEnable(uart_sysctl);
    SysCtlPeripheralEnable(gpio_sysctl);
    GPIOPinConfigure(gpio_rx);
    GPIOPinConfigure(gpio_tx);
    GPIOPinTypeUART(gpio_base, gpio_rx_pin | gpio_tx_pin);
    UARTConfigSetExpClk(uart_base, BspGetSysClock(), bandrate, (databit | stopbit | checkbit));

    BSP_IntVectSet(int_id, (CPU_FNCT_VOID)int_handler);
    BSP_IntEn(int_id);

    IntEnable(int_uart);
    IntPrioritySet(int_uart, 3 << 5); // 设置中断优先级
    UARTIntEnable(uart_base, UART_INT_RX | UART_INT_RT);

    return 0;
}

int8_t BspUartInit(uint8_t uart_id, uint32_t bandrate, uint8_t databit, uint8_t stopbit, uint8_t checkbit) {
    switch (uart_id) {
        case USR_UART0:
            return UartCommonInit(USR_UART0_SYSCTL, USR_UART0_GPIO_SYSCTL, 
                                    USR_UART0_BASE, USR_UART0_GPIO_BASE, 
                                    USR_URAT0_GPIO_RX, USR_UART0_GPIO_TX, 
                                    USR_URAT0_GPIO_RX_PIN, USR_UART0_GPIO_TX_PIN,
                                    USR_BSP_INT_ID_UART0, BspUart0IntHandler,
                                    USR_INT_UART0, bandrate, databit, stopbit, checkbit);
        case USR_UART1:
            return UartCommonInit(USR_UART1_SYSCTL, USR_UART1_GPIO_SYSCTL, 
                                    USR_UART1_BASE, USR_UART1_GPIO_BASE, 
                                    USR_URAT1_GPIO_RX, USR_UART1_GPIO_TX, 
                                    USR_URAT1_GPIO_RX_PIN, USR_UART1_GPIO_TX_PIN,
                                    USR_BSP_INT_ID_UART1, BspUart1IntHandler,
                                    USR_INT_UART1, bandrate, databit, stopbit, checkbit);
        case USR_UART2:
            return UartCommonInit(USR_UART2_SYSCTL, USR_UART2_GPIO_SYSCTL, 
                                    USR_UART2_BASE, USR_UART2_GPIO_BASE, 
                                    USR_URAT2_GPIO_RX, USR_UART2_GPIO_TX, 
                                    USR_URAT2_GPIO_RX_PIN, USR_UART2_GPIO_TX_PIN,
                                    USR_BSP_INT_ID_UART2, BspUart2IntHandler,
                                    USR_INT_UART2, bandrate, databit, stopbit, checkbit);
        case USR_UART3:
            return UartCommonInit(USR_UART3_SYSCTL, USR_UART3_GPIO_SYSCTL, 
                                    USR_UART3_BASE, USR_UART3_GPIO_BASE, 
                                    USR_URAT3_GPIO_RX, USR_UART3_GPIO_TX, 
                                    USR_URAT3_GPIO_RX_PIN, USR_UART3_GPIO_TX_PIN,
                                    USR_BSP_INT_ID_UART3, BspUart3IntHandler,
                                    USR_INT_UART3, bandrate, databit, stopbit, checkbit);
        case USR_UART4:
            return UartCommonInit(USR_UART4_SYSCTL, USR_UART4_GPIO_SYSCTL, 
                                    USR_UART4_BASE, USR_UART4_GPIO_BASE, 
                                    USR_URAT4_GPIO_RX, USR_UART4_GPIO_TX, 
                                    USR_URAT4_GPIO_RX_PIN, USR_UART4_GPIO_TX_PIN,
                                    USR_BSP_INT_ID_UART4, BspUart4IntHandler,
                                    USR_INT_UART4, bandrate, databit, stopbit, checkbit);
        case USR_UART5:
            return UartCommonInit(USR_UART5_SYSCTL, USR_UART5_GPIO_SYSCTL, 
                                    USR_UART5_BASE, USR_UART5_GPIO_BASE, 
                                    USR_URAT5_GPIO_RX, USR_UART5_GPIO_TX, 
                                    USR_URAT5_GPIO_RX_PIN, USR_UART5_GPIO_TX_PIN,
                                    USR_BSP_INT_ID_UART5, BspUart5IntHandler,
                                    USR_INT_UART5, bandrate, databit, stopbit, checkbit);
        case USR_UART6:
            return UartCommonInit(USR_UART6_SYSCTL, USR_UART6_GPIO_SYSCTL, 
                                    USR_UART6_BASE, USR_UART6_GPIO_BASE, 
                                    USR_URAT6_GPIO_RX, USR_UART6_GPIO_TX, 
                                    USR_URAT6_GPIO_RX_PIN, USR_UART6_GPIO_TX_PIN,
                                    USR_BSP_INT_ID_UART6, BspUart6IntHandler,
                                    USR_INT_UART6, bandrate, databit, stopbit, checkbit);
        case USR_UART7:
            return UartCommonInit(USR_UART7_SYSCTL, USR_UART7_GPIO_SYSCTL, 
                                    USR_UART7_BASE, USR_UART7_GPIO_BASE, 
                                    USR_URAT7_GPIO_RX, USR_UART7_GPIO_TX, 
                                    USR_URAT7_GPIO_RX_PIN, USR_UART7_GPIO_TX_PIN,
                                    USR_BSP_INT_ID_UART7, BspUart7IntHandler,
                                    USR_INT_UART7, bandrate, databit, stopbit, checkbit);
        default:
            return -1;
    }
}

/* 串口发送函数
 * 返回值:
 *          0:  成功
 *          -1: 失败
 */
int8_t BspUartSend(uint8_t uart_id, uint8_t *data, uint32_t data_len)
{
    uint32_t i = 0;
    uint32_t uart_base;
    CPU_SR_ALLOC();
    OS_ENTER_CRITICAL();

    switch (uart_id) {
        case USR_UART0: uart_base = UART0_BASE; break;
        case USR_UART1: uart_base = UART1_BASE; break;
        case USR_UART2: uart_base = UART2_BASE; break;
        case USR_UART3: uart_base = UART3_BASE; break;
        case USR_UART4: uart_base = UART4_BASE; break;
        case USR_UART5: uart_base = UART5_BASE; break;
        case USR_UART6: uart_base = UART6_BASE; break;
        case USR_UART7: uart_base = UART7_BASE; break;
        default:
            OS_EXIT_CRITICAL();
            return -1;
    }

    // 发送数据
    for (i = 0; i < data_len; i++) {
        UARTCharPut(uart_base, data[i]);
    }

    while (UARTBusy(uart_base)) {
        //OSTimeDly(1);
    }

    OS_EXIT_CRITICAL();
    return 0;
}


uint32_t BspUartGetInfo(uint8_t uart_id, uint8_t *info, uint32_t info_len)
{
    uint32_t i = 0;
    CPU_SR_ALLOC();
    OS_ENTER_CRITICAL();
    switch (uart_id) {
        case USR_UART0:
            for (i = 0; i < info_len; i++) {
                if (uart0_recv_temp == uart0_recv_local) {
                    break;
                }
                info[i] = usr_uart0_recv_space[uart0_recv_temp];
                uart0_recv_temp++;
                uart0_recv_temp = uart0_recv_temp % UART0_RECV_CACHE_MAX;
            }
            break;
        case USR_UART1:
            for (i = 0; i < info_len; i++) {
                if (uart1_recv_temp == uart1_recv_local) {
                    break;
                }
                info[i] = usr_uart1_recv_space[uart1_recv_temp];
                uart1_recv_temp++;
                uart1_recv_temp = uart1_recv_temp % UART1_RECV_CACHE_MAX;
            }
            break;
        case USR_UART2:
            for (i = 0; i < info_len; i++) {
                if (uart2_recv_temp == uart2_recv_local) {
                    break;
                }
                info[i] = usr_uart2_recv_space[uart2_recv_temp];
                uart2_recv_temp++;
                uart2_recv_temp = uart2_recv_temp % UART2_RECV_CACHE_MAX;
            }
            break;
        case USR_UART3:
            for (i = 0; i < info_len; i++) {
                if (uart3_recv_temp == uart3_recv_local) {
                    break;
                }
                info[i] = usr_uart3_recv_space[uart3_recv_temp];
                uart3_recv_temp++;
                uart3_recv_temp = uart3_recv_temp % UART3_RECV_CACHE_MAX;
            }
            break;
        case USR_UART4:
            for (i = 0; i < info_len; i++) {
                if (uart4_recv_temp == uart4_recv_local) {
                    break;
                }
                info[i] = usr_uart4_recv_space[uart4_recv_temp];
                uart4_recv_temp++;
                uart4_recv_temp = uart4_recv_temp % UART4_RECV_CACHE_MAX;
            }
            break;
        case USR_UART5:
            for (i = 0; i < info_len; i++) {
                if (uart5_recv_temp == uart5_recv_local) {
                    break;
                }
                info[i] = usr_uart5_recv_space[uart5_recv_temp];
                uart5_recv_temp++;
                uart5_recv_temp = uart5_recv_temp % UART5_RECV_CACHE_MAX;
            }
            break;
        case USR_UART6:
            for (i = 0; i < info_len; i++) {
                if (uart6_recv_temp == uart6_recv_local) {
                    break;
                }
                info[i] = usr_uart6_recv_space[uart6_recv_temp];
                uart6_recv_temp++;
                uart6_recv_temp = uart6_recv_temp % UART6_RECV_CACHE_MAX;
            }
            break;
        case USR_UART7:
            for (i = 0; i < info_len; i++) {
                if (uart7_recv_temp == uart7_recv_local) {
                    break;
                }
                info[i] = usr_uart7_recv_space[uart7_recv_temp];
                uart7_recv_temp++;
                uart7_recv_temp = uart7_recv_temp % UART7_RECV_CACHE_MAX;
            }
            break;
        default:
            break;
    }
    OS_EXIT_CRITICAL();
    return i;
}

static void BspUartIntHandler(uint32_t uartBase, uint8_t* recvSpace, uint32_t* recvLocal, uint32_t recvCacheMax) {
    uint32_t ui32Status;
    ui32Status = UARTIntStatus(uartBase, true);
    UARTIntClear(uartBase, ui32Status);
    OSIntEnter();
    while (UARTCharsAvail(uartBase)) {
        recvSpace[*recvLocal] = (uint8_t)UARTCharGetNonBlocking(uartBase);
        (*recvLocal)++;
        *recvLocal = *recvLocal % recvCacheMax;
    }
    OSIntExit();
}

static void BspUart0IntHandler(void) {
    BspUartIntHandler(UART0_BASE, usr_uart0_recv_space, &uart0_recv_local, UART0_RECV_CACHE_MAX);
}

static void BspUart1IntHandler(void) {
    BspUartIntHandler(UART1_BASE, usr_uart1_recv_space, &uart1_recv_local, UART1_RECV_CACHE_MAX);
}

static void BspUart2IntHandler(void) {
    BspUartIntHandler(UART2_BASE, usr_uart2_recv_space, &uart2_recv_local, UART2_RECV_CACHE_MAX);
}

static void BspUart3IntHandler(void) {
    BspUartIntHandler(UART3_BASE, usr_uart3_recv_space, &uart3_recv_local, UART3_RECV_CACHE_MAX);
}

static void BspUart4IntHandler(void) {
    BspUartIntHandler(UART4_BASE, usr_uart4_recv_space, &uart4_recv_local, UART4_RECV_CACHE_MAX);
}

static void BspUart5IntHandler(void) {
    BspUartIntHandler(UART5_BASE, usr_uart5_recv_space, &uart5_recv_local, UART5_RECV_CACHE_MAX);
}

static void BspUart6IntHandler(void) {
    BspUartIntHandler(UART6_BASE, usr_uart6_recv_space, &uart6_recv_local, UART6_RECV_CACHE_MAX);
}

static void BspUart7IntHandler(void) {
    BspUartIntHandler(UART7_BASE, usr_uart7_recv_space, &uart7_recv_local, UART7_RECV_CACHE_MAX);
}