#include "common.h"
#include "udma.h"
#include "udma_if.h"
#include "hw_mcspi.h"


#define TIMER_TICK 5000000
static uint32_t interrupt_count;
static uint8_t tx_buffer[TR_BUFF_SIZE];
static uint8_t rx_buffer[TR_BUFF_SIZE];

static void interrupt_handler()
{
    uint32_t status = MAP_SPIIntStatus(GSPI_BASE,true);
    interrupt_count++;
    Report("Count: %d\n\r",interrupt_count);
    if(interrupt_count > 100)
    {
        Message("Reached 100 interrupts...\n\r");
        while(1){}
    }
    if(status &  SPI_INT_DMATX)
    {
        Message(" SPI_INT_DMATX\n\r");
        MAP_SPIIntClear(GSPI_BASE,SPI_INT_DMATX);
        return;
    }
    if(status & SPI_INT_DMARX)
    {
        Message("SPI_INT_DMARX  \n\r");
        MAP_SPIIntClear(GSPI_BASE,SPI_INT_DMARX);
        return;
    }
    Message("Unkown Interrupt\n\r");
//  Message("int\n\r");
}

int main()
{
    interrupt_count = 0;

    uint32_t output_count = 0;
    uint32_t sum = 0;
    uint32_t tick_count = 0;
    uint32_t tx_crc = 0;


    init();
    // initialize buffers with some known value
    memset(tx_buffer,0x55,sizeof(tx_buffer));
    memset(rx_buffer,0x22,sizeof(rx_buffer));

    for(int i = 0; i < TR_BUFF_SIZE; i++)
    {
        tx_buffer[i] = 0x20+i;
    }
    // configure SPI
    MAP_SPIReset(GSPI_BASE);

    UDMAInit();

    MAP_SPIConfigSetExpClk(GSPI_BASE,MAP_PRCMPeripheralClockGet(PRCM_GSPI),
                     SPI_IF_BIT_RATE,SPI_MODE_SLAVE,SPI_SUB_MODE_0,
                     (SPI_HW_CTRL_CS |
                     SPI_4PIN_MODE |
                     SPI_TURBO_OFF |
                     SPI_CS_ACTIVEHIGH |
                     SPI_WL_8));
    MAP_SPIIntRegister(GSPI_BASE,interrupt_handler);

    SetupTransfer(UDMA_CH30_GSPI_RX,UDMA_MODE_BASIC,TR_BUFF_SIZE,
                UDMA_SIZE_8,UDMA_ARB_1,
                (void *)(GSPI_BASE + MCSPI_O_RX0),UDMA_SRC_INC_NONE,
                rx_buffer,UDMA_DST_INC_8);

    SetupTransfer(UDMA_CH31_GSPI_TX,UDMA_MODE_BASIC,TR_BUFF_SIZE,
                UDMA_SIZE_8,UDMA_ARB_1,
                tx_buffer,UDMA_SRC_INC_8,
                (void *)(GSPI_BASE + MCSPI_O_TX0),UDMA_DST_INC_NONE);
    SPIDmaEnable(GSPI_BASE,SPI_RX_DMA|SPI_TX_DMA);
    //MAP_SPIIntEnable(GSPI_BASE,SPI_INT_DMATX | SPI_INT_DMARX );
    MAP_SPIIntEnable(GSPI_BASE, SPI_INT_DMARX | SPI_INT_DMATX  );
    MAP_SPIEnable(GSPI_BASE);
//  MAP_uDMAIntClear(0xffffffff);
//  MAP_uDMAChannelAssign( UDMA_CH30_GSPI_RX );
//    MAP_uDMAChannelAssign( UDMA_CH31_GSPI_TX);
  //  MAP_uDMAChannelRequest(UDMA_CH30_GSPI_RX);
  //  MAP_uDMAChannelRequest(UDMA_CH31_GSPI_TX);

    Message("Enabled SPI Interface in Slave Mode!\n\r");
//  change_seed(456546,35345,345346,3463);
//  tx_crc = fill_buffer(tx_buffer,TR_BUFF_SIZE,"TX");

    Message("Starting while...\n\r");
    uint32_t timer = 0;
    while(1)
    {

    //  memcpy(tx_buffer,rx_buffer,TR_BUFF_SIZE);
        // here we could also change the tx_buffer
        //  tx_buffer[TR_BUFF_SIZE - 1] = 18;
        // we want to print out the buffer
        // on the slave side after each transfer.
        // As each transfer will cause
        // TR_BUFF_SIZE interrupts, we check if our
        // local counter is less than interrupt_count
        // which is incremeted in the interrupt handler
        sum = 0;
        if(timer > TIMER_TICK)
        {
            Report("Timer Tick %d!\n\r",tick_count);
            tick_count++;
        }
        if((output_count < interrupt_count) || timer > TIMER_TICK)
        {
            for(int i = 0; i < TR_BUFF_SIZE; i++)
            {
                sum += rx_buffer[i];
            }
            Report("The sum in the Rx buffer is: %d\n\r",sum);
            Report("Checksum Rx buffer is: 0x%02x\n\r",crc(rx_buffer));
            Report("interrupt: %d\n\r",interrupt_count);
            Message("TX-");
            print_buffer(tx_buffer,TR_BUFF_SIZE);
            Message("RX-");
            print_buffer(rx_buffer,TR_BUFF_SIZE);
            output_count++;
        }
        if(timer > TIMER_TICK)
        {
            timer = 0;
        }
        timer++;
    }
    return 0;
}