/*
 * spi_init.c
 *
 *  Created on: 5 сент. 2023 г.
 *      Author: seklyuts
 */

#include "f28x_project.h"
#include "biss.h"

#define     SPI_PROGRAM_CS_GPAMUX1          GpioCtrlRegs.GPDMUX1.bit.GPIO98
#define     SPI_PROGRAM_CS_GPAGMUX1         GpioCtrlRegs.GPDGMUX1.bit.GPIO98
#define     SPI_PROGRAM_CS_GPADIR           GpioCtrlRegs.GPDDIR.bit.GPIO98
#define     SPI_PROGRAM_CS_GPADAT           GpioDataRegs.GPDDAT.bit.GPIO98



uint16_t BissCount = BISS_C_BITS;

__interrupt void spia_rx_isr(void);
__interrupt void spia_tx_isr(void);

__interrupt void spib_rx_isr(void);
__interrupt void spib_tx_isr(void);


__interrupt void spic_rx_isr(void);
__interrupt void spic_tx_isr(void);

uint16_t rxBuff[BISS_C_BITS];
uint16_t indexRxBuff = 0;



void SpiAInit(void)
{
    //
    // Initialize SPI-A
    //
    //
    // Initialize SPI FIFO registers
    //
    CpuSysRegs.PCLKCR8.bit.SPI_A = 1;

    SpiaRegs.SPIFFTX.all = 0xE040;
    SpiaRegs.SPIFFRX.all = 0x2044;
    SpiaRegs.SPIFFCT.all = 0x0;

    //
    // Initialize core SPI registers
    //
    //
    // Set reset low before configuration changes
    // Clock polarity (0 == rising, 1 == falling)
    // 16-bit character
    // Enable loop-back
    //
    SpiaRegs.SPICCR.bit.SPISWRESET = 0;
    SpiaRegs.SPICCR.bit.CLKPOLARITY = 0;
    SpiaRegs.SPICCR.bit.SPICHAR = (8 - 1);
    SpiaRegs.SPICCR.bit.SPILBK = 0;

    //
    // Enable master (0 == slave, 1 == master)
    // Enable transmission (Talk)
    // Clock phase (0 == normal, 1 == delayed)
    // SPI interrupts are disabled
    //
    SpiaRegs.SPICTL.bit.MASTER_SLAVE = 1;
    SpiaRegs.SPICTL.bit.TALK = 1;
    SpiaRegs.SPICTL.bit.CLK_PHASE = 1;
    SpiaRegs.SPICTL.bit.SPIINTENA = 0;

    PieCtrlRegs.PIEIER6.bit.INTx1 = 0;
    PieCtrlRegs.PIEIER6.bit.INTx2 = 0;

    PieVectTable.SPIA_RX_INT = &spia_rx_isr;
    PieVectTable.SPIA_TX_INT = &spia_tx_isr;
    //
    // Set the baud rate using a 1 MHz SPICLK
    // BRR = (LSPCLK / SPICLK) - 1
    //
    SpiaRegs.SPIBRR.bit.SPI_BIT_RATE = ((50000000 / 1000000) - 1);

    // Set FREE bit
    // Halting on a breakpoint will not halt the SPI
    //
    SpiaRegs.SPIPRI.bit.FREE = 1;

    //
    // Release the SPI from reset
    //
    SpiaRegs.SPICCR.bit.SPISWRESET = 1;
}

void SpiAGpioInit(void)
{
       EALLOW;

    //
    // Enable internal pull-up for the selected pins
    //
    // Pull-ups can be enabled or disabled by the user.
    // This will enable the pullups for the specified pins.
    //
    GpioCtrlRegs.GPBPUD.bit.GPIO32 = 0;  // Enable pull-up on (SPISIMOA)
    GpioCtrlRegs.GPBPUD.bit.GPIO33 = 0;  // Enable pull-up on (SPISOMIA)
    GpioCtrlRegs.GPBPUD.bit.GPIO34 = 0;  // Enable pull-up on (SPICLKA)
    GpioCtrlRegs.GPBPUD.bit.GPIO35 = 0;  // Enable pull-up on (SPISTEA)

    //
    // Set qualification for selected pins to asynch only
    //
    // This will select asynch (no qualification) for the selected pins.
    //
    GpioCtrlRegs.GPBQSEL1.bit.GPIO32 = 3; // Asynch input (SPISIMOA)
    GpioCtrlRegs.GPBQSEL1.bit.GPIO33 = 3; // Asynch input (SPISOMIA)
    GpioCtrlRegs.GPBQSEL1.bit.GPIO34 = 3; // Asynch input (SPICLKA)
    GpioCtrlRegs.GPBQSEL1.bit.GPIO35 = 3; // Asynch input (SPISTEA)

    //
    // Configure SPI-A pins
    //
    // This specifies which of the possible GPIO pins will be SPI functional
    // pins.
    //
    GpioCtrlRegs.GPBMUX1.bit.GPIO32 = 3; // Configure GPIO32 as SPISIMOA
    GpioCtrlRegs.GPBMUX1.bit.GPIO33 = 3; // Configure GPIO33 as SPISOMIA
    GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 3; // Configure GPIO34 as SPICLKA
    GpioCtrlRegs.GPBMUX1.bit.GPIO35 = 3; // Configure GPIO35 as SPISTEA


    SPI_PROGRAM_CS_GPAMUX1 = 0;//program CS for BL25CM1A
    SPI_PROGRAM_CS_GPAGMUX1 = 0;
    SPI_PROGRAM_CS_GPADIR = 1;
    SPI_PROGRAM_CS_GPADAT = 0;

    EDIS;
}


void spi_TurnOnCS1_GD25Q16E(void)
{
    EALLOW;
    GpioCtrlRegs.GPBMUX1.bit.GPIO35 = 3; // Configure GPIO35 as SPISTEA
    EDIS;
}

void spi_TurnOffCS1_GD25Q16E(void)
{
    EALLOW;
    GpioCtrlRegs.GPBMUX1.bit.GPIO35 = 0;
    GpioDataRegs.GPBDAT.bit.GPIO35 = 1;
    EDIS;
}

void Gpio_SPI_CS_BL25CM1A(uint16_t out_bit)
{
    EALLOW;
    SPI_PROGRAM_CS_GPADAT = out_bit;
    EDIS;
}


void spi_transmitAData(uint16_t a)
{
    SpiaRegs.SPITXBUF = a<<8;
}


__interrupt void spia_rx_isr(void)
{
    uint16_t temp = SpiaRegs.SPISTS.all;
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;
}


__interrupt void spia_tx_isr(void)
{
    uint16_t temp = SpiaRegs.SPISTS.all;
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;
}




void SpiBInit(void)
{

    CpuSysRegs.PCLKCR8.bit.SPI_B = 1;

    SpibRegs.SPIFFTX.all = 0xE04F;
    SpibRegs.SPIFFRX.all = 0x2026;//RXFIFORESET = 1; RXFFINTCLR = 1; RXFFIENA = 1; RXFFIL = 6
    SpibRegs.SPIFFCT.all = 0x0;

    //
    // Initialize core SPI registers
    //
    //
    // Set reset low before configuration changes
    // Clock polarity (0 == rising, 1 == falling)
    // 16-bit character
    // Enable loop-back
    //
    SpibRegs.SPICCR.bit.SPISWRESET = 0;
    SpibRegs.SPICCR.bit.CLKPOLARITY = 0;
    SpibRegs.SPICCR.bit.SPICHAR = 0xF; //16
    SpibRegs.SPICCR.bit.SPILBK = 0;
    SpibRegs.SPICCR.bit.HS_MODE = 1;

    //
    // Enable master (0 == slave, 1 == master)
    // Enable transmission (Talk)
    // Clock phase (0 == normal, 1 == delayed)
    // SPI interrupts are enabled
    //
    SpibRegs.SPICTL.bit.MASTER_SLAVE = 0;//Slave
    SpibRegs.SPICTL.bit.TALK = 1;
    SpibRegs.SPICTL.bit.CLK_PHASE = 1;
    SpibRegs.SPICTL.bit.SPIINTENA = 1;


    EALLOW;
    PieVectTable.SPIB_RX_INT = &spib_rx_isr;
    PieVectTable.SPIB_TX_INT = &spib_tx_isr;
    EDIS;

    IER |= M_INT6;

    PieCtrlRegs.PIEIER6.bit.INTx3 = 1; //3.4.5 PIE Channel Mapping str 150 of trm
    PieCtrlRegs.PIEIER6.bit.INTx4 = 1; // 3 - RX, 4 - TX


    SpibRegs.SPIFFTX.bit.TXFFIENA = 0;
    SpibRegs.SPIFFRX.bit.RXFFIENA = 1;
    //
    // Set the baud rate using a 1 MHz SPICLK
    // BRR = (LSPCLK / SPICLK) - 1
    //
    SpibRegs.SPIBRR.bit.SPI_BIT_RATE = ((50000000 / 1000000) - 1);

    // Set FREE bit
    // Halting on a breakpoint will not halt the SPI
    //
    SpibRegs.SPIPRI.bit.FREE = 1;

    //
    // Release the SPI from reset
    //
    SpibRegs.SPICCR.bit.SPISWRESET = 1;
}

void SpiBGpioInit(void)
{
       EALLOW;

    //
    // Enable internal pull-up for the selected pins
    //
    // Pull-ups can be enabled or disabled by the user.
    // This will enable the pullups for the specified pins.
    //
    GpioCtrlRegs.GPDPUD.bit.GPIO100 = 0;  // Enable pull-up on GPIO16 (SPISIMOB)
//    GpioCtrlRegs.GPAPUD.bit.GPIO25 = 0;  // Enable pull-up on GPIO17 (SPISOMIB)

    GpioCtrlRegs.GPDPUD.bit.GPIO102 = 0;  // Enable pull-up on GPIO18 (SPICLKB)
//    GpioCtrlRegs.GPAPUD.bit.GPIO26 = 0;  // Enable pull-up on GPIO18 (SPICLKB)

    GpioCtrlRegs.GPAPUD.bit.GPIO27 = 0;  // Enable pull-up on GPIO19 (SPISTEB)

    //
    // Set qualification for selected pins to asynch only
    //
    // This will select asynch (no qualification) for the selected pins.
    //
    GpioCtrlRegs.GPDQSEL1.bit.GPIO100 = 3; // Asynch input GPIO16 (SPISIMOB)
//    GpioCtrlRegs.GPAQSEL2.bit.GPIO25 = 3; // Asynch input GPIO17 (SPISOMIB)

    GpioCtrlRegs.GPDQSEL1.bit.GPIO102 = 3; // Asynch input GPIO18 (SPICLKB)
//    GpioCtrlRegs.GPAQSEL2.bit.GPIO26 = 3; // Asynch input GPIO18 (SPICLKB)

    GpioCtrlRegs.GPAQSEL2.bit.GPIO27 = 3; // Asynch input GPIO19 (SPISTEB)


    GpioCtrlRegs.GPDMUX1.bit.GPIO99 = 0;
    GpioCtrlRegs.GPDGMUX1.bit.GPIO99 = 0;
    GpioCtrlRegs.GPDDIR.bit.GPIO99 = 1;
    GpioDataRegs.GPDDAT.bit.GPIO99 = 0;

    //
    // Configure SPI-A pins
    //
    // This specifies which of the possible GPIO pins will be SPI functional
    // pins.
    //
    GPIO_SetupPinMux(100, 0, 6);
//    GPIO_SetupPinMux(25, 0, 6);

    GPIO_SetupPinMux(102, 0, 6);
//    GPIO_SetupPinMux(26, 0, 6);

    GPIO_SetupPinMux(27, 0, 6);
//    SpibRegs.SPITXBUF = 0xFFFF;

//    GpioCtrlRegs.GPAMUX1.bit.GPIO24 = 2; // Configure GPIO16 as SPISIMOA
//    GpioCtrlRegs.GPAMUX1.bit.GPIO25 = 2; // Configure GPIO17 as SPISOMIA
//    GpioCtrlRegs.GPAMUX1.bit.GPIO26 = 2; // Configure GPIO18 as SPICLKA
//    GpioCtrlRegs.GPAMUX1.bit.GPIO27 = 2; // Configure GPIO19 as SPISTEA
//    GpioCtrlRegs.GPAMUX2.bit.GPIO24 = 1; // Configure GPIO16 as SPISIMOA
//    GpioCtrlRegs.GPAMUX2.bit.GPIO25 = 1; // Configure GPIO17 as SPISOMIA
//    GpioCtrlRegs.GPAMUX2.bit.GPIO26 = 1; // Configure GPIO18 as SPICLKA
//    GpioCtrlRegs.GPAMUX2.bit.GPIO27 = 1; // Configure GPIO19 as SPISTEA
    EDIS;
}

void transmitBData(uint16_t a)
{
    SpibRegs.SPITXBUF = a;
}


__interrupt void spib_rx_isr(void)
{
//    SpibRegs.SPIFFRX.all = 0x2036;//RXFIFORESET = 1; RXFFINTCLR = 1; RXFFIENA = 1; RXFFIL = 6
    uint16_t temp = SpibRegs.SPISTS.all;
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;
    SpibRegs.SPIFFRX.bit.RXFFIL = 6;
    SpibRegs.SPIFFRX.bit.RXFFIENA = 1;
    SpibRegs.SPIFFRX.bit.RXFFINTCLR = 1;
}


__interrupt void spib_tx_isr(void)
{
    uint16_t temp = SpibRegs.SPISTS.all;
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;
    SpibRegs.SPIFFTX.all = 0xE04F;
    SpibRegs.SPIFFTX.bit.TXFFIL = 0x0;
//    SpibRegs.SPIFFTX.bit.TXFFIENA = 1;
    SpibRegs.SPIFFTX.bit.TXFFINTCLR = 1;
}



//Spi-C




void SpiCInit(void)
{

    CpuSysRegs.PCLKCR8.bit.SPI_C = 1;

    SpicRegs.SPIFFTX.all = 0xE04F;
    SpicRegs.SPIFFRX.all = 0x2026;//RXFIFORESET = 1; RXFFINTCLR = 1; RXFFIENA = 1; RXFFIL = 6
    SpicRegs.SPIFFCT.all = 0x0;
    SpicRegs.SPIFFRX.bit.RXFFIL = BissCount;

    //
    // Initialize core SPI registers
    //
    //
    // Set reset low before configuration changes
    // Clock polarity (0 == rising, 1 == falling)
    // 16-bit character
    // Enable loop-back
    //
    SpicRegs.SPICCR.bit.SPISWRESET = 0;
    SpicRegs.SPICCR.bit.CLKPOLARITY = BISS_CLK_POL;
    SpicRegs.SPICCR.bit.SPICHAR = 0xF; //16
    SpicRegs.SPICCR.bit.SPILBK = 0;
    SpicRegs.SPICCR.bit.HS_MODE = 1;

    //
    // Enable master (0 == slave, 1 == master)
    // Enable transmission (Talk)
    // Clock phase (0 == normal, 1 == delayed)
    // SPI interrupts are enabled
    //
    SpicRegs.SPICTL.bit.MASTER_SLAVE = 0;//Slave
    SpicRegs.SPICTL.bit.TALK = 1;
    SpicRegs.SPICTL.bit.CLK_PHASE = BISS_CLK_PHASE;
    SpicRegs.SPICTL.bit.SPIINTENA = 1;


    EALLOW;
    PieVectTable.SPIC_RX_INT = &spic_rx_isr;
    PieVectTable.SPIC_TX_INT = &spic_tx_isr;
    EDIS;

    IER |= M_INT6;

    PieCtrlRegs.PIEIER6.bit.INTx9 = 1; //3.4.5 PIE Channel Mapping str 150 of trm
    PieCtrlRegs.PIEIER6.bit.INTx10 = 1; // 3 - RX, 4 - TX


    SpicRegs.SPIFFTX.bit.TXFFIENA = 0;
    SpicRegs.SPIFFRX.bit.RXFFIENA = 1;
    //
    // Set the baud rate using a 1 MHz SPICLK
    // BRR = (LSPCLK / SPICLK) - 1
    //
    SpicRegs.SPIBRR.bit.SPI_BIT_RATE = ((50000000 / 1000000) - 1);

    // Set FREE bit
    // Halting on a breakpoint will not halt the SPI
    //
    SpicRegs.SPIPRI.bit.FREE = 1;

    SpicRegs.SPIPRI.bit.STEINV = 1;
    //
    // Release the SPI from reset
    //
    SpicRegs.SPICCR.bit.SPISWRESET = 1;

}

void SpiCGpioInit(void)
{
       EALLOW;

    //
    // Enable internal pull-up for the selected pins
    //
    // Pull-ups can be enabled or disabled by the user.
    // This will enable the pullups for the specified pins.
    //
    GpioCtrlRegs.GPDPUD.bit.GPIO100 = 0;  // Enable pull-up on  (SPISIMOB)


    GpioCtrlRegs.GPDPUD.bit.GPIO102 = 0;  // Enable pull-up on  (SPICLKB)


    GpioCtrlRegs.GPCPUD.bit.GPIO72 = 0;  // Enable pull-up on (SPISTEB)

    //
    // Set qualification for selected pins to asynch only
    //
    // This will select asynch (no qualification) for the selected pins.
    //
    GpioCtrlRegs.GPDQSEL1.bit.GPIO100 = 3; // Asynch input(SPISIMOB)


    GpioCtrlRegs.GPDQSEL1.bit.GPIO102 = 3; // Asynch input(SPICLKB)


    GpioCtrlRegs.GPCQSEL1.bit.GPIO72 = 3; // Asynch input(SPISTEB)


    GpioCtrlRegs.GPDMUX1.bit.GPIO99 = 0;
    GpioCtrlRegs.GPDGMUX1.bit.GPIO99 = 0;
    GpioCtrlRegs.GPDDIR.bit.GPIO99 = 1;
    GpioDataRegs.GPDDAT.bit.GPIO99 = 0;

    //
    // Configure SPI-A pins
    //
    // This specifies which of the possible GPIO pins will be SPI functional
    // pins.
    //
    GPIO_SetupPinMux(100, 0, 6);


    GPIO_SetupPinMux(102, 0, 6);


    GPIO_SetupPinMux(72, 0, 15);



    EDIS;
}

void transmitCData(uint16_t a)
{
    SpicRegs.SPITXBUF = a;
}

void resetIndexRxBuff(void)
{
    indexRxBuff = 0;
}

uint64_t BissTest = 0;
uint16_t BissErrRead = 0;
uint32_t BissTestShift0[16];


__interrupt void spic_rx_isr(void)
{
    uint16_t BissEmptyBits = 0;
    for(indexRxBuff = 0; indexRxBuff < BissCount; indexRxBuff++)
    {
        rxBuff[indexRxBuff] = SpicRegs.SPIRXBUF;
    }

    BissTest = ((uint64_t)rxBuff[0] << 48) +  ((uint64_t)rxBuff[1] << 32) + ((uint64_t)rxBuff[2] << 16) + ((uint64_t)rxBuff[3]);

    while(((BissTest & 0xC000000000000000) != 0x8000000000000000) && (BissEmptyBits < 15))
    {
            BissTest = BissTest << 1;
            BissEmptyBits++;
    }
    BissTestShift0[BissEmptyBits]++;
    if( (BissTest & 0xC000000000000000) == 0x8000000000000000) BissCalc(BissTest);
    else BissErrRead++;



    uint16_t temp = SpicRegs.SPISTS.all;
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;
    SpicRegs.SPIFFRX.bit.RXFFIL = BissCount;
    SpicRegs.SPIFFRX.bit.RXFFIENA = 1;
    SpicRegs.SPIFFRX.bit.RXFFINTCLR = 1;
}


__interrupt void spic_tx_isr(void)
{
    uint16_t temp = SpibRegs.SPISTS.all;
    PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;
    SpicRegs.SPIFFTX.all = 0xE04F;
    SpicRegs.SPIFFTX.bit.TXFFIL = 0x0;
//    SpibRegs.SPIFFTX.bit.TXFFIENA = 1;
    SpicRegs.SPIFFTX.bit.TXFFINTCLR = 1;
}