/**************************************************************************//**
* @file     pan_hal_uart.c
* @version  V0.0.0
* $Revision: 1 $
* $Date:    23/09/10 $
* @brief    Panchip series UART (Universal Asynchronous Receiver-Transmitter) HAL source file.
* @note
* Copyright (C) 2023 Panchip Technology Corp. All rights reserved.
*****************************************************************************/

#include "pan_hal.h"


UART_HandleTypeDef UART_Handle_Array[2] =
    {
        {.pUartx = UART0,
         .initObj = {0},
         .interruptObj = {0},
         .pTxBuffPtr = NULL,
         .txXferSize = 0,
         .txXferCount = 0,
         .pRxBuffPtr = NULL,
         .rxXferSize = 0,
         .rxXferCount = 0,
         .IRQn = UART0_IRQn,
         .rxIntCallback = NULL,
         .txIntCallback = NULL,
         .dmaSrc = DMAC_Peripheral_UART0_Rx,
         .dmaDst = DMAC_Peripheral_UART0_Tx,
         .errorCode = 0},
        {.pUartx = UART1,
         .initObj = {0},
         .interruptObj = {0},
         .pTxBuffPtr = NULL,
         .txXferSize = 0,
         .txXferCount = 0,
         .pRxBuffPtr = NULL,
         .rxXferSize = 0,
         .rxXferCount = 0,
         .IRQn = UART1_IRQn,
         .rxIntCallback = NULL,
         .txIntCallback = NULL,
         .dmaSrc = DMAC_Peripheral_UART1_Rx,
         .dmaDst = DMAC_Peripheral_UART1_Tx,
         .errorCode = 0}};

void HAL_DelayMs(uint32_t t)
{
    for (uint32_t i = 0; i < t; i++)
    {
        SYS_delay_10nop(0x1080);
    }
}



bool HAL_UART_Init(UART_HandleTypeDef *pUart)
{
    uint32_t tmpreg = 0x00;
    uint32_t integerdivider = 0x00;
    uint32_t fractionaldivider = 0x00;
    uint64_t apbclock = 0x00;

	if(pUart->pUartx == UART0)
	{
		CLK_APB1PeriphClockCmd(CLK_APB1Periph_UART0, ENABLE);
	}
	else if(pUart->pUartx == UART1)
	{
		CLK_APB2PeriphClockCmd(CLK_APB2Periph_UART1, ENABLE);
	}
	
    /*---------------------------- UART BRR Configuration -----------------------*/
    /* Configure the UART Baud Rate */
    apbclock = CLK_GetPeripheralFreq((void *)pUart->pUartx);
    /*unlock to enable write & read divisor register*/
    pUart->pUartx->LCR |= UART_LCR_DLAB_Msk;
    /* Determine the integer part baud_rate_divisor =  PCLK*100 / (16*required_baud_rate)*/
    integerdivider = ((25 * apbclock) / (4 * (pUart->initObj.baudRate)));

    // Too high baudrate (too small divider) would cause DLL/DLH be all 0 which means UART disabled,
    // thus return false if this happens.
    if (integerdivider < 100)
        return false;

    tmpreg = (integerdivider / 100);
    pUart->pUartx->RBR_THR_DLL = tmpreg & 0xFF;
    pUart->pUartx->IER_DLH = (tmpreg & 0xFF00) >> 8;

    /* Determine the fractional part */
    fractionaldivider = integerdivider - (100 * tmpreg);

    /* Implement the fractional part in the register */
    pUart->pUartx->DLF = ((((fractionaldivider * 16) + 50) / 100));
    pUart->pUartx->LCR &= ~UART_LCR_DLAB_Msk;

    /*---------------------------- UART Line Configuration -----------------------*/
    tmpreg = pUart->pUartx->LCR;
    tmpreg &= ~(UART_LCR_SP_Msk | UART_LCR_EPS_Msk | UART_LCR_PEN_Msk | UART_LCR_STOP_Msk | UART_LCR_DLS_Msk);
    tmpreg |= (pUart->initObj.format);
    pUart->pUartx->LCR = tmpreg;

    /*-------------------------------enable fifo----------------------------------*/
    pUart->pUartx->SCR |= UART_FCR_FIFOE_Msk;
    pUart->pUartx->IIR_FCR = pUart->pUartx->SCR;
    UART_EnableFifo(pUart->pUartx);

    return true;
}

void HAL_UART_SendData(UART_HandleTypeDef *pUart, uint8_t *pbuf, size_t size)
{
    pUart->pTxBuffPtr = pbuf;
    pUart->txXferSize = size;
    pUart->txXferCount = 0;
    while (pUart->txXferCount < pUart->txXferSize)
    {
        UART_SendData(pUart->pUartx, pUart->pTxBuffPtr[pUart->txXferCount++]);
        while (!(UART_GetLineStatus(pUart->pUartx) & UART_LSR_TEMT_Msk))
            ;
    }
}

void HAL_UART_ReceiveData(UART_HandleTypeDef *pUart, uint8_t *pbuf, size_t size, uint32_t timeout)
{
    UART_SetRxTrigger(pUart->pUartx, UART_RX_FIFO_HALF_FULL);

    pUart->pRxBuffPtr = pbuf;
    pUart->rxXferSize = size;
    pUart->rxXferCount = 0;
    while (pUart->rxXferCount < pUart->rxXferSize)
    {
        while ((UART_GetLineStatus(pUart->pUartx) & UART_LSR_DR_Msk))
        {
            pUart->pRxBuffPtr[pUart->rxXferCount++] = UART_ReceiveData(pUart->pUartx);
        }
    }
}

void HAL_UART_SendData_INT(UART_HandleTypeDef *pUart, uint8_t *pbuf, size_t size, UART_CallbackFunc callback)
{
    pUart->pTxBuffPtr = pbuf;
    pUart->txXferSize = size;
    pUart->txXferCount = 0;
    pUart->txIntCallback = callback;
    UART_SetTxTrigger(pUart->pUartx, UART_TX_FIFO_EMPTY);

    pUart->interruptObj.switchFlag = ENABLE;
    pUart->interruptObj.interruptMode = HAL_UART_INT_THR_EMPTY;
    HAL_UART_Init_INT(pUart);
    NVIC_EnableIRQ(pUart->IRQn);
}

void HAL_UART_ReceiveData_INT(UART_HandleTypeDef *pUart, uint8_t *pbuf, size_t size,uint32_t timeout,UART_CallbackFunc callback)
{
    pUart->pRxBuffPtr = pbuf;
    pUart->rxXferSize = size;
    pUart->rxXferCount = 0;
    pUart->rxIntCallback = callback;
	UART_SetRxTrigger(pUart->pUartx, UART_RX_FIFO_TWO_LESS_THAN_FULL);

    pUart->interruptObj.switchFlag = ENABLE;
    pUart->interruptObj.interruptMode = HAL_UART_INT_RECV_DATA_AVL;
    HAL_UART_Init_INT(pUart);
    pUart->interruptObj.interruptMode = HAL_UART_INT_LINE_STATUS;
    HAL_UART_Init_INT(pUart);
    pUart->interruptObj.interruptMode = HAL_UART_INT_ALL;
    HAL_UART_Init_INT(pUart);
    NVIC_EnableIRQ(pUart->IRQn);
}



void HAL_UART_SendData_DMA(UART_HandleTypeDef *pUart, uint8_t *pbuf, size_t size, UART_CallbackFunc callback)
{
    pUart->interruptObj.switchFlag = ENABLE;
    pUart->interruptObj.interruptMode = HAL_UART_INT_THR_EMPTY;
    HAL_UART_Init_INT(pUart);

    pUart->pTxBuffPtr = pbuf;
    pUart->txXferSize = size;
    pUart->txXferCount = 0;

    UART_ResetTxFifo(pUart->pUartx);
    UART_SetTxTrigger(pUart->pUartx, UART_TX_FIFO_HALF_FULL);
    UART_EnablePtime(pUart->pUartx); //Enable Programmable THRE Interrupt Mode

    uint32_t txChNum = 0xFF;
    // Initialize the DMA controller
    DMAC_Init(DMA);
    NVIC_EnableIRQ(DMA_IRQn);

    /* Get free DMA channel */
    txChNum = DMAC_AcquireChannel(DMA);
    /* Enable DMA transfer interrupt */
    DMAC_ClrIntFlagMsk(DMA, txChNum, DMAC_FLAG_INDEX_TFR);
    DMAC_ClrIntFlagMsk(DMA, txChNum, DMAC_FLAG_INDEX_DSTTFR);
    DMAC_ClrIntFlagMsk(DMA, txChNum, DMAC_FLAG_INDEX_BLK);
    DMAC_ClrIntFlagMsk(DMA, txChNum, DMAC_FLAG_INDEX_ERR);
    dma_mem2uart_config.PeripheralDst = pUart->dmaDst;
    DMAC_Channel_Array[txChNum].ConfigTmp = dma_mem2uart_config;
    DMAC_Channel_Array[txChNum].CallbackUart = callback;
    DMAC_Channel_Array[txChNum].PeriMode = DMAC_Peri_UART;
    DMAC_Channel_Array[txChNum].pBuffPtr = (uint32_t*)pUart->pTxBuffPtr;
    DMAC_Channel_Array[txChNum].XferSize = pUart->txXferSize;
    DMAC_SetChannelConfig(DMA, txChNum, &DMAC_Channel_Array[txChNum].ConfigTmp);

    /* Condition check */
    uint32_t DataWidthInByteSrc = 1 << DMAC_Channel_Array[txChNum].ConfigTmp.DataWidthSrc;
    uint32_t BlockSize = size / DataWidthInByteSrc; // BlockSize = DataLen / DataWidthInByteSrc

    /* Start DMA Tx channel */
    DMAC_StartChannel(DMA, txChNum, pbuf, (void *)&(pUart->pUartx->RBR_THR_DLL), BlockSize);
}

void HAL_UART_ReceiveData_DMA(UART_HandleTypeDef *pUart, uint8_t *pbuf, size_t size, uint32_t timeout,UART_CallbackFunc callback)
{
    pUart->pRxBuffPtr = pbuf;
    pUart->rxXferSize = size;
    pUart->rxXferCount = 0;
    UART_ResetRxFifo(pUart->pUartx);

    UART_SetRxTrigger(pUart->pUartx, UART_RX_FIFO_HALF_FULL);
    uint32_t rxChNum = 0xFF;
    // Initialize the DMA controller
    DMAC_Init(DMA);
    NVIC_EnableIRQ(DMA_IRQn);
    rxChNum = DMAC_AcquireChannel(DMA);
    /* Enable DMA transfer interrupt */
    DMAC_ClrIntFlagMsk(DMA, rxChNum, DMAC_FLAG_INDEX_TFR);
    DMAC_ClrIntFlagMsk(DMA, rxChNum, DMAC_FLAG_INDEX_SRCTFR);
    DMAC_ClrIntFlagMsk(DMA, rxChNum, DMAC_FLAG_INDEX_BLK);
    DMAC_ClrIntFlagMsk(DMA, rxChNum, DMAC_FLAG_INDEX_ERR);

    // dma_uart2mem_config.PeripheralDst = pUart->dmaSrc;
    DMAC_Channel_Array[rxChNum].ConfigTmp = dma_uart2mem_config;
    DMAC_Channel_Array[rxChNum].ConfigTmp.PeripheralSrc = pUart->dmaSrc;
    DMAC_Channel_Array[rxChNum].CallbackUart = callback;
    DMAC_Channel_Array[rxChNum].PeriMode = DMAC_Peri_UART;
    DMAC_Channel_Array[rxChNum].pBuffPtr = (uint32_t*)pUart->pRxBuffPtr;
    DMAC_Channel_Array[rxChNum].XferSize = pUart->rxXferSize;
    DMAC_SetChannelConfig(DMA, rxChNum, &DMAC_Channel_Array[rxChNum].ConfigTmp);

    /* Condition check */
    uint32_t dataWidthInByteSrc = 1 <<DMAC_Channel_Array[rxChNum].ConfigTmp.DataWidthSrc;
    uint32_t blockSize = size / dataWidthInByteSrc;    //blockSize = DataLen / dataWidthInByteSrc
    /* Start DMA Rx channel */
    DMAC_StartChannel(DMA, rxChNum, (void*)&(pUart->pUartx->RBR_THR_DLL), pUart->pRxBuffPtr, blockSize);
}


void HAL_UART_Init_INT(UART_HandleTypeDef *pUart)
{
    if (pUart->interruptObj.switchFlag == ENABLE)
    {
        pUart->pUartx->IER_DLH |= ((pUart->interruptObj.interruptMode << UART_IER_ALL_IRQ_Pos) & UART_IER_ALL_IRQ_Msk);
    }
    else if (pUart->interruptObj.switchFlag == DISABLE)
    {
        pUart->pUartx->IER_DLH &= ~((pUart->interruptObj.interruptMode << UART_IER_ALL_IRQ_Pos) & UART_IER_ALL_IRQ_Msk);
    }
}

static void UART_HandleLineStatus(UART_HandleTypeDef *pUart)
{
    uint32_t lineStatus = UART_GetLineStatus(pUart->pUartx);

    // Filter line error
    if ((lineStatus & (UART_LINE_OVERRUN_ERR | UART_LINE_PARITY_ERR | UART_LINE_FRAME_ERR | UART_LINE_RECV_FIFO_EMPTY)) != 0x0)
    {

    }

    // Handle THRE event
    if (lineStatus & UART_LINE_THRE)
    {
        if ((pUart->pUartx->IER_DLH & UART_IER_EPTI_Msk) == 0)
        {

        }

        else if ((pUart->pUartx->IIR_FCR & UART_IIR_FIFOSE_Msk) != 0)
        {

        }
    }
}

static void UART_HandleModemStatus(UART_HandleTypeDef *pUart)
{
    uint32_t modemStatus = UART_GetModemStatus(pUart->pUartx);
}

static void UART_HandleReceivedData(UART_HandleTypeDef *pUart,UART_Cb_Flag_Opt flag)
{
    while (!UART_IsRxFifoEmpty(pUart->pUartx))
    {
        pUart->pRxBuffPtr[pUart->rxXferCount++] = UART_ReceiveData(pUart->pUartx);
    }
    
    if (flag == UART_CB_FLAG_RX_TIMEOUT)
    {
		if(pUart->rxXferCount >= pUart->rxXferSize)
		{
			pUart->rxXferCount = pUart->rxXferSize;
		}

        if (pUart->rxIntCallback != NULL)
        {
            pUart->rxIntCallback(flag,pUart->pRxBuffPtr,pUart->rxXferCount);
        }
        pUart->rxXferCount = 0;
    }
}

static void UART_HandleTransmittingData(UART_HandleTypeDef *pUart)
{
    while (!UART_IsTxFifoFull(pUart->pUartx))
    {
        if (pUart->txXferCount < pUart->txXferSize)
        {
            UART_SendData(pUart->pUartx, pUart->pTxBuffPtr[pUart->txXferCount++]);
        }
        else
        {
            UART_DisableIrq(pUart->pUartx, UART_IRQ_THR_EMPTY); // Disable THRE Interrupt after transmitting done
            if (pUart->txIntCallback != NULL)
            {
                pUart->txIntCallback(UART_CB_FLAG_TX_FINISH, pUart->pTxBuffPtr,pUart->txXferCount);
            }
            break;
        }
    }   
}

static void UART_HandleProc(UART_HandleTypeDef *pUart)
{
    UART_EventDef event = UART_GetActiveEvent(pUart->pUartx);

    switch (event)
    {
    case UART_EVENT_LINE:
        UART_HandleLineStatus(pUart);
        break;
    case UART_EVENT_DATA:
        UART_HandleReceivedData(pUart,UART_CB_FLAG_RX_FINISH);
        break;
    case UART_EVENT_TIMEOUT:
        UART_HandleReceivedData(pUart,UART_CB_FLAG_RX_TIMEOUT);
        break;
    case UART_EVENT_THR_EMPTY:
        UART_HandleTransmittingData(pUart);
        break;
    case UART_EVENT_MODEM:
        UART_HandleModemStatus(pUart);
        break;
    case UART_EVENT_NONE:
        /* Just ignore this event. */
        break;
    default:
        break;
    }
}

void UART0_IRQHandler(void)
{
    UART_HandleProc(&UART_Handle_Array[0]);
}

void UART1_IRQHandler(void)
{
    UART_HandleProc(&UART_Handle_Array[1]);
}


/*** (C) COPYRIGHT 2023 Panchip Technology Corp. ***/