/*
 * FlashProgram.c
 *
 *  Created on: Jan 22, 2019
 *      Author: shlomo
 */

//#include <stdint.h>
#include "include.h"
#include "driverlib/rom.h"
#include "driverlib/flash.h"
#include <DataDef.h>
#include "FlashProgram.h"

//#define FLASH_DEBUG
#ifdef FLASH_DEBUG
#define  MAX_CONT_LOG 100

#define READ 1
#define DELETE 2
uint32_t Address[MAX_CONT_LOG+1] = {0};
uint32_t Size[MAX_CONT_LOG+1] = {0};
uint32_t EraseWrite[MAX_CONT_LOG+1] = {0};
byte RxIndex = 0;
#endif
//*****************************************************************************
//
// Read the application image from the file system and program it into flash.
//
// This function will attempt to open and read the firmware image file from
// the mass storage device.  If the file is found it will be programmed into
// flash.  The name of the file to be read is configured by the macro
// \b USB_UPDATE_FILENAME.  It will be programmed into flash starting at the
// address specified by ui32FlashStart.
//
// \return Zero if successful or non-zero if the file cannot be read or
// programmed.
//
//*****************************************************************************
uint32_t ReadAppAndProgram(uint32_t ui32FlashStart,uint32_t ui32FileSize,void* buffer)
{
    //uint32_t ui32FileSize;
    uint32_t ui32DataSize;
    uint32_t ui32Remaining;
    uint32_t ui32ProgAddr;
    uint32_t ui32BufferAddr;
    volatile uint32_t ui32Idx;
    uint32_t status = OK;
    //uint32_t ui32FlashEnd;

#ifdef FLASH_DEBUG
    Address[RxIndex] = ui32FlashStart;
    Size[RxIndex] = ui32FileSize;
    EraseWrite[RxIndex] = READ;
    if (RxIndex++>=MAX_CONT_LOG)
        RxIndex = 0;
#endif
    //
    // Get the size of flash.  This is the ending address of the flash.
    // If reserved space is configured, then the ending address is reduced
    // by the amount of the reserved block.
    //
    //ui32FlashEnd = ui32FlashStart + ui32FileSize;


    //
    // Check to make sure the file size is not too large to fit in the flash.
    // If it is too large, then return an error.
    //
    /*if((ui32FileSize + ui32FlashStart) > ui32FlashEnd)
    {
        return(1);
    }*/

    //
    // Enter a loop to erase all the requested flash pages beginning at the
    // application start address (above the USB stick updater).
    //
    /*for(ui32Idx = ui32FlashStart; ui32Idx < ui32FlashEnd; ui32Idx += 1024)
    {
        ROM_FlashErase(ui32Idx);
    }*/

    //
    // Enter a loop to read sectors from the application image file and
    // program into flash.  Start at the user app start address (above the USB
    // stick updater).
    //
    ui32ProgAddr = ui32FlashStart;
    ui32BufferAddr = (uint32_t)buffer;
    ui32Remaining = ui32FileSize;
    while(ui32Remaining)
    {
        //
        // Compute how much data was read from this sector and adjust the
        // remaining amount.
        //

        ui32DataSize = ui32Remaining >= 512 ? 512 : ui32Remaining;
        ui32Remaining -= ui32DataSize;

        //
        // Call the function to program a block of flash.  The length of the
        // block passed to the flash function must be divisible by 4.
        //

        ROM_IntMasterDisable();
        status = ROM_FlashProgram((uint32_t *)ui32BufferAddr, ui32ProgAddr,(ui32DataSize + 3) & ~3);
        ROM_IntMasterEnable();
        if (status)
            Report("FlashProgram Error", __FILE__,status,ui32ProgAddr , RpMessage, (ui32DataSize + 3) & ~3, 0);

        //
        // If there is more image to program, then update the programming
        // address.  Progress will continue to the next iteration of
        // the while loop.
        //
        if(ui32Remaining)
        {
            ui32ProgAddr += ui32DataSize;
            ui32BufferAddr += ui32DataSize;
        }

    }

    //
    // If we make it here, that means that an attempt to read a sector of
    // data from the device was not successful.  That means that the complete
    // user app has not been programmed into flash, so just return an error
    // indication.
    //
    return(1);
}
int base_flashErased = false;
uint32_t EraseFlashSection(void)
{
    volatile uint32_t ui32Idx = FLASH_RAM_BASE;
    uint32_t status;

    if (base_flashErased == true)
        return WARNING;
    else
        base_flashErased = true; //once in a run

#ifdef FLASH_DEBUG
    Address[RxIndex] = ui32FlashStart;
    Size[RxIndex] = ui32FileSize;
    EraseWrite[RxIndex] = DELETE;
    if (RxIndex++>=MAX_CONT_LOG)
        RxIndex = 0;
#endif
    status = FlashErase(ui32Idx);
    //FlashErase returns 0 or -1
    return status;

}
/*void FlashTest(void)
{
    int i;
    uint32_t stack[0x200];
    uint32_t offset = 0;

    for (i = 0; i < 0x200; i++)
        stack[i] = i;

    while (offset < FLASH_SIZE)
    {
        ReadAppAndProgram(FLASH_RAM_BASE+offset,0x200,stack);
        offset+=0x200;
    }
    EraseFlashSection();

}*/
//Each word may not be subject to more than a specific number of programming cycles before an
//erase cycle is required. In other words, for any given word, FlashProgram can only be called
//twice before FlashErase is called.
void FlashInit(void)
{
    volatile uint32_t ui32Idx;
    //FlashUsecSet(120);
#ifdef FLASH_DEBUG
    Address[RxIndex] = FLASH_RAM_BASE;
    Size[RxIndex] = FLASH_SIZE;
    EraseWrite[RxIndex] = DELETE;
    if (RxIndex++>=MAX_CONT_LOG)
        RxIndex = 0;
#endif
    ROM_IntMasterDisable();
    for(ui32Idx = FLASH_RAM_BASE; ui32Idx < FLASH_RAM_BASE+FLASH_SIZE; ui32Idx += 1024)
    {
        ROM_FlashErase(ui32Idx);
    }
    ROM_IntMasterEnable();
}