/*
* RTC.c
*
*  Created on: 2017. 1. 25.
*      Author: kdkor
*/

#include "Cpu1DeviceDefine.h"

struct sDS3234_REGS RTCRegs;
struct sDS3234_REGS RTCWrBuf;

//----------------------RTC---------------------------------------//
unsigned int Flag_write_time = 0;
unsigned int Flag_write_date = 0;
unsigned long RTCDate = 0;
unsigned long RTCTime = 0;

#define CS_LOW                      GPIO_writePin(61, 0)
#define CS_HIGH                     GPIO_writePin(61, 1)

//TODO 임시 코드 이므로 나중에 리뷰 할 것

void InitRTC()
{
//    SPI GPIO핀 설정
//    InitSpidGpio();

    GPIO_setMasterCore(58, GPIO_CORE_CPU1);
       GPIO_setPinConfig(GPIO_58_SPISIMOA);
       GPIO_setDirectionMode(58, GPIO_DIR_MODE_OUT);
       GPIO_setPadConfig(58, GPIO_PIN_TYPE_STD);
       GPIO_setQualificationMode(58, GPIO_QUAL_ASYNC);

       GPIO_setMasterCore(59, GPIO_CORE_CPU1);
       GPIO_setPinConfig(GPIO_59_SPISOMIA);
       GPIO_setDirectionMode(59, GPIO_DIR_MODE_IN);
       GPIO_setPadConfig(59, GPIO_PIN_TYPE_PULLUP);
       GPIO_setQualificationMode(59, GPIO_QUAL_ASYNC);

       GPIO_setMasterCore(60, GPIO_CORE_CPU1);
       GPIO_setPinConfig(GPIO_60_SPICLKA);
       GPIO_setDirectionMode(60, GPIO_DIR_MODE_OUT);
       GPIO_setPadConfig(60, GPIO_PIN_TYPE_STD);
       GPIO_setQualificationMode(60, GPIO_QUAL_ASYNC);

       GPIO_setMasterCore(61, GPIO_CORE_CPU1);
       GPIO_setPinConfig(GPIO_61_GPIO61);
       GPIO_setDirectionMode(61, GPIO_DIR_MODE_OUT);
       GPIO_setPadConfig(61, GPIO_PIN_TYPE_STD);
       GPIO_setQualificationMode(61, GPIO_QUAL_ASYNC);

       SPI_disableModule(SPIA_BASE);
       SPI_setConfig(SPIA_BASE, DEVICE_LSPCLK_FREQ, SPI_PROT_POL0PHA0, SPI_MODE_MASTER_OD, 400000, 8);
       SPI_enableTalk(SPIA_BASE);

       SPI_enableModule(SPIA_BASE);

//    // SPI FIFO 초기화
//    SpiaRegs.SPIFFTX.all = 0xE040;
//    SpiaRegs.SPIFFRX.all = 0x204f;
//    SpiaRegs.SPIFFCT.all = 0x0;
//
//    //SPI 초기화
//    SpiaRegs.SPICCR.all = 0x000F;                // Relinquish SPI from Reset
//    SpiaRegs.SPICTL.all = 0x0006;                // Enable master mode, normal phase,
//                                                 // enable talk, and SPI interrupt disabled.
//
//    SpiaRegs.SPIBRR.bit.SPI_BIT_RATE = 0x0012;   // 4Mbps Baud
//    SpiaRegs.SPICCR.all = 0x008F;                // Relinquish SPI from Reset
//    SpiaRegs.SPIPRI.bit.FREE = 1;                // Set so breakpoints don't disturb xmission

    memset(&RTCRegs, 0, (sizeof(RTCRegs) / sizeof(int)));
    memset(&RTCWrBuf, 0, (sizeof(RTCWrBuf) / sizeof(int)));
}

unsigned int Flag_RTC_request = 0;

unsigned int Spid_TxErr_Cnt = 0;
unsigned int Spid_RxErr_Cnt = 0;
unsigned int Spid_Rx_Data = 0;
unsigned int Spid_Tx_Data = 0;
unsigned int Spi_RTC_Flag_Rx = 0;
unsigned int Spi_RTC_Flag_Tx = 0;

unsigned int Flag_Wr_RTC= 0;
unsigned int RTC_rAddr = 0;
unsigned int RTC_wAddr = 0;


void Spid_Tx(unsigned int Tx_Data)
{

//    if (SpiaRegs.SPIFFTX.bit.TXFFST == 0 && SpiaRegs.SPIFFRX.bit.RXFIFORESET == 1)
//    {
//        SpiaRegs.SPITXBUF = Tx_Data;
//    }
//    else if (SpiaRegs.SPIFFTX.bit.TXFFST > 1)
//    {
//        Spid_TxErr_Cnt = Spid_TxErr_Cnt + SpiaRegs.SPIFFTX.bit.TXFFST;
//    }

        int temp=0;

        CS_LOW;

        SPI_writeDataBlockingNonFIFO(SPIA_BASE, Tx_Data);
        SPI_readDataBlockingNonFIFO(SPIA_BASE);

        CS_HIGH;

}

//unsigned int Spid_Rx(void)
unsigned int Spid_Rx(unsigned int Read_addr)
{
//    if (Spi_RTC_Flag_Rx == 0)
//    {
//        if (SpiaRegs.SPIFFRX.bit.RXFFST == 1)
//        {
//            Spid_Rx_Data = (0x00ff) & (SpiaRegs.SPIRXBUF);
//            Spi_RTC_Flag_Rx = 1;
//            return 1;
//        }
//        else if (SpiaRegs.SPIFFRX.bit.RXFFST > 1)
//        {
//            Spid_RxErr_Cnt = Spid_RxErr_Cnt + SpiaRegs.SPIFFRX.bit.RXFFST;
//            SpiaRegs.SPIFFRX.bit.RXFIFORESET = 0;
//            delay_us(1);
//            SpiaRegs.SPIFFRX.bit.RXFIFORESET = 1;
//        }
//
//    }
//
//    return 0;

        int temp=0;

        CS_LOW;

        SPI_writeDataBlockingNonFIFO(SPIA_BASE, Read_addr);
        temp = SPI_readDataBlockingNonFIFO(SPIA_BASE);
        SPI_writeDataBlockingNonFIFO(SPIA_BASE, Read_addr);
        temp = SPI_readDataBlockingNonFIFO(SPIA_BASE);

//        delay_us(3);
        CS_HIGH;

        return(temp);
}

void RtcRun()
{
    if (Flag_Wr_RTC == 0) RtcReadTime();
    else RtcWriteTime();

}

int wAddr = 0, wData = 0;


void RtcWriteTime()
{

    if (Spi_RTC_Flag_Rx == 0)
    {
        switch (RTC_wAddr)
        {
            case RTC_SEC:
                RTCWrBuf.SecDAT.bit.Tens = RTCWrBuf.Sec / 10;
                RTCWrBuf.SecDAT.bit.Unit = RTCWrBuf.Sec % 10;
                wData = RTCWrBuf.SecDAT.all;
                wAddr = (RTC_SEC | RTC_WR | wData);
                Spid_Tx(wAddr);
                RTC_wAddr = RTC_MIN;

                break;

            case RTC_MIN:
                RTCWrBuf.MinDAT.bit.Tens = RTCWrBuf.Min / 10;
                RTCWrBuf.MinDAT.bit.Unit = RTCWrBuf.Min % 10;
                wData = RTCWrBuf.MinDAT.all;
                wAddr = (RTC_MIN | RTC_WR | wData);
                Spid_Tx(wAddr);
                RTC_wAddr = RTC_HOUR;
                break;

            case RTC_HOUR:
                RTCWrBuf.HourDAT.bit.Tens = RTCWrBuf.Hour / 10;
                RTCWrBuf.HourDAT.bit.Unit = RTCWrBuf.Hour % 10;
                wData = RTCWrBuf.HourDAT.all;
                wAddr = (RTC_HOUR | RTC_WR | wData);
                Spid_Tx(wAddr);
                RTC_wAddr = RTC_DAY;
                break;

            case RTC_DAY:
                RTCWrBuf.DayDAT.bit.Day = RTCWrBuf.Day;
                wData = RTCWrBuf.DayDAT.all;
                wAddr = (RTC_DAY | RTC_WR | wData);
                Spid_Tx(wAddr);
                RTC_wAddr = RTC_DATE;
                break;

            case RTC_DATE:
                RTCWrBuf.DateDAT.bit.Tens = RTCWrBuf.Date / 10;
                RTCWrBuf.DateDAT.bit.Unit = RTCWrBuf.Date % 10;
                wData = RTCWrBuf.DateDAT.all;
                wAddr = (RTC_DATE | RTC_WR | wData);
                Spid_Tx(wAddr);
                RTC_wAddr = RTC_MONTH;
                break;

            case RTC_MONTH:
                RTCWrBuf.MonthDAT.bit.Tens = RTCWrBuf.Month / 10;
                RTCWrBuf.MonthDAT.bit.Unit = RTCWrBuf.Month % 10;
                wData = RTCWrBuf.MonthDAT.all;
                wAddr = (RTC_MONTH | RTC_WR | wData);
                Spid_Tx(wAddr);
                RTC_wAddr = RTC_YEAR;
                break;

            case RTC_YEAR:
                if(RTCWrBuf.Year > 2000) RTCWrBuf.Year = RTCWrBuf.Year - 2000;

                RTCWrBuf.YearDAT.bit.Tens = (RTCWrBuf.Year / 10);
                RTCWrBuf.YearDAT.bit.Unit = RTCWrBuf.Year % 10;
                wData = RTCWrBuf.YearDAT.all;
                wAddr = (RTC_YEAR | RTC_WR | wData);
                Spid_Tx(wAddr);

                RTC_wAddr = RTC_SEC;
                Flag_Wr_RTC = 0;
                break;

            default:
                RTC_wAddr = RTC_SEC;
                Flag_Wr_RTC = 0;
                break;
        }
    }

}

void RtcReadTime()
{
    int rAddr = 0;

    if (Flag_Wr_RTC == 0) Spid_Rx_Data = Spid_Rx(RTC_rAddr);

//    if (Spi_RTC_Flag_Rx == 1 && Flag_Wr_RTC == 0)
    if (Flag_Wr_RTC == 0)
    {

        switch (RTC_rAddr)
        {
            case RTC_SEC:
                RTCRegs.SecDAT.all = Spid_Rx_Data;
                RTCRegs.Sec = (RTCRegs.SecDAT.bit.Tens * 10 + RTCRegs.SecDAT.bit.Unit);
                RTC_rAddr = RTC_MIN;
                Spi_RTC_Flag_Rx = 0;

                break;

            case RTC_MIN:
                RTCRegs.MinDAT.all = Spid_Rx_Data;
                RTCRegs.Min = (RTCRegs.MinDAT.bit.Tens * 10 + RTCRegs.MinDAT.bit.Unit);
                RTC_rAddr = RTC_HOUR;
                Spi_RTC_Flag_Rx = 0;

                break;

            case RTC_HOUR:
                RTCRegs.HourDAT.all = Spid_Rx_Data;
                RTCRegs.Hour = (RTCRegs.HourDAT.bit.Tens * 10 + RTCRegs.HourDAT.bit.Unit);
                RTC_rAddr = RTC_DAY;
                Spi_RTC_Flag_Rx = 0;

                break;

            case RTC_DAY:
                RTCRegs.DayDAT.all = Spid_Rx_Data;
                RTCRegs.Day = (RTCRegs.DayDAT.bit.Day);
                RTC_rAddr = RTC_DATE;
                Spi_RTC_Flag_Rx = 0;
                break;

            case RTC_DATE:
                RTCRegs.DateDAT.all = Spid_Rx_Data;
                RTCRegs.Date = (RTCRegs.DateDAT.bit.Tens * 10 + RTCRegs.DateDAT.bit.Unit);
                RTC_rAddr = RTC_MONTH;
                Spi_RTC_Flag_Rx = 0;
                break;

            case RTC_MONTH:
                RTCRegs.MonthDAT.all = Spid_Rx_Data;
                RTCRegs.Month = (RTCRegs.MonthDAT.bit.Tens * 10 + RTCRegs.MonthDAT.bit.Unit);
                RTC_rAddr = RTC_YEAR;
                Spi_RTC_Flag_Rx = 0;
                break;

            case RTC_YEAR:
                RTCRegs.YearDAT.all = Spid_Rx_Data;
                RTCRegs.Year = (RTCRegs.YearDAT.bit.Tens * 10 + RTCRegs.YearDAT.bit.Unit);
                RTC_rAddr = RTC_SEC;
                Spi_RTC_Flag_Rx = 0;
                break;

            default:
                RTC_rAddr = RTC_SEC;
                Spi_RTC_Flag_Rx = 0;
                break;
        }
    }
    else
    {
        RTC_rAddr = RTC_SEC;
    }

    RTCDate = (unsigned long)RTCRegs.Year * 10000 + RTCRegs.Month * 100 + RTCRegs.Date;
    RTCTime = (unsigned long)RTCRegs.Hour * 10000 + RTCRegs.Min * 100 + RTCRegs.Sec;

    if (Flag_Wr_RTC == 0)
    {
        rAddr = ((RTC_rAddr | RTC_RD) << 8);
        Spid_Tx(rAddr);
    }

}