TMS320F2837xD programming CPU2 flash from RAM

//###########################################################################
// FILE:   flash_programming_cpu01.c
// TITLE:  Flash Programming Example for F2837xD.
//
//! \addtogroup dual_example_list
//! <h1> Flash Programming </h1>
//!
//! This example demonstrates F021 Flash API usage.
//
//###########################################################################
// $TI Release: F2837xD Support Library v180 $
// $Release Date: Fri Nov  6 16:19:46 CST 2015 $
// $Copyright: Copyright (C) 2013-2015 Texas Instruments Incorporated -
//             http://www.ti.com/ ALL RIGHTS RESERVED $
//###########################################################################

#include "F28x_Project.h"     // Device Headerfile and Examples Include File

#include <string.h>

//Include Flash API example header file
#include "flash_programming_c28.h"

//*****************************************************************************
// FILE Flash API include file
//*****************************************************************************
#include "F021_F2837xD_C28x.h"

//Data/Program Buffer used for testing the flash API functions
#define  WORDS_IN_FLASH_BUFFER    0x100  // Programming data buffer, words

uint16   Buffer[WORDS_IN_FLASH_BUFFER + 1];
uint32   *Buffer32 = (uint32 *)Buffer;

//*****************************************************************************
// Prototype of the functions used in this example
//*****************************************************************************
void Example_CallFlashAPI(void);

//*****************************************************************************
// This is an example code demonstrating F021 Flash API usage.
// This code is in Flash
//*****************************************************************************
void main(void)
{
// Step 1. Initialize System Control:
// Enable Peripheral Clocks
// This example function is found in the F2837xD_SysCtrl.c file.
    InitSysCtrl();

//  Unlock CSM
//
//  If the API functions are going to run in unsecured RAM
//  then the CSM must be unlocked in order for the flash
//  API functions to access the flash.
//  If the flash API functions are executed from secure memory
//  then this step is not required.
    //DcsmZ1Unlock();

// Step 2. Initialize GPIO:
// This example function is found in the F2837xD_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
   //InitGpio();  // Skipped for this example

// Step 3. Clear all interrupts and initialize PIE vector table:
// Disable CPU interrupts
    DINT;

// Initialize the PIE control registers to their default state.
// The default state is all PIE interrupts disabled and flags
// are cleared.
// This function is found in the F2837xD_PieCtrl.c file.
    InitPieCtrl();

// Disable CPU interrupts and clear all CPU interrupt flags:
    IER = 0x0000;
    IFR = 0x0000;

// Initialize the PIE vector table with pointers to the shell Interrupt
// Service Routines (ISR).
// This will populate the entire table, even if the interrupt
// is not used in this example.  This is useful for debug purposes.
// The shell ISR routines are found in DSP2802x_DefaultIsr.c.
// This function is found in F2837xD_PieVect.c.
    InitPieVectTable();

// Copy time critical code and Flash setup code to RAM
// This includes InitFlash(), Flash API functions and any functions that are
// assigned to ramfuncs section.
// The  RamfuncsLoadStart, RamfuncsLoadEnd, and RamfuncsRunStart
// symbols are created by the linker. Refer to the device .cmd file.

   //memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);

// Call Flash Initialization to setup flash waitstates
// This function must reside in RAM

    InitFlash();

//  Gain pump semaphore
//    SeizeFlashPump();

    //change pump to read-only state
    EALLOW;
	while (FlashPumpSemaphoreRegs.PUMPREQUEST.bit.PUMP_OWNERSHIP != 0x0)
	{
		FlashPumpSemaphoreRegs.PUMPREQUEST.all = IPC_PUMP_KEY | 0x0;
	}
	EDIS;

	//change pump to CPU2
	EALLOW;
	while (FlashPumpSemaphoreRegs.PUMPREQUEST.bit.PUMP_OWNERSHIP != 0x1)
	{
		FlashPumpSemaphoreRegs.PUMPREQUEST.all = IPC_PUMP_KEY | 0x1;
	}
	EDIS;

//  Jump to RAM and call the Flash API functions
    Example_CallFlashAPI();
}

void Synchronize_with_host(void)
{
	Uint32 variable;
	Uint16 i;
/*
		//synchronization from device, indicates L
		EALLOW;
		    GpioCtrlRegs.GPAMUX2.bit.GPIO19 = 0;	//GPIO
		   	GpioCtrlRegs.GPADIR.bit.GPIO19 = GpioCtrlRegs.GPADIR.bit.GPIO19 | (1);	//output
		   	GpioDataRegs.GPADAT.bit.GPIO19 = 0;	//pin GPIO19 to L
		EDIS;

		for (i = 0; i < 2; i++)
		{
	   	//synchronization from host, wait to H
	   	do
	    {
	    EALLOW;
	    	GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 0x0000;
	        GpioCtrlRegs.GPADIR.bit.GPIO18 = GpioCtrlRegs.GPADIR.bit.GPIO18 | (0); //input
	        variable = GpioDataRegs.GPADAT.bit.GPIO18;
	    EDIS;
	    }
	   	while((variable & 0x0001) != 0x0001);

		// synchronization from device, indicates H
		EALLOW;
			GpioCtrlRegs.GPAMUX2.bit.GPIO19 = 0x0000;
		    GpioCtrlRegs.GPADIR.bit.GPIO19 = GpioCtrlRegs.GPADIR.bit.GPIO19 | (1);
		    GpioDataRegs.GPADAT.bit.GPIO19 = 1;	//pin GPIO19 to H
		EDIS;

	   	// synchronization from host, wait to L
	   	do
	    {
	    EALLOW;
	    	GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 0x0000;
	      	GpioCtrlRegs.GPADIR.bit.GPIO18 = GpioCtrlRegs.GPADIR.bit.GPIO18 | (0);
	      	variable = GpioDataRegs.GPADAT.bit.GPIO18;
	    EDIS;
	    } while((variable & 0x0001) == 0x0001);

	   	//synchronization from device, indicates L
	   	EALLOW;
	        GpioCtrlRegs.GPAMUX2.bit.GPIO19 = 0x0000;
	      	GpioCtrlRegs.GPADIR.bit.GPIO19 = GpioCtrlRegs.GPADIR.bit.GPIO19 | (1);
	      	GpioDataRegs.GPADAT.bit.GPIO19 = 0;	//pin GPIO19 to L
	    EDIS;
		}
		*/
}


//*****************************************************************************
//  Example_CallFlashAPI
//
//  This function will interface to the flash API.
//  Flash API functions used in this function are executed from RAM
//*****************************************************************************
#pragma CODE_SECTION(Example_CallFlashAPI, "ramfuncs");
void Example_CallFlashAPI(void)
{

	Fapi_StatusType            oReturnCheck;
    volatile Fapi_FlashStatusType       oFlashStatus;
    Fapi_FlashStatusWordType   oFlashStatusWord;

    //Najprv musim odstartovat algo
    Synchronize_with_host();

    // Disable ECC.  ECC does not have to be disabled to do FSM operations like
    // program and erase.
    // However, on Sonata Rev. 0 silicon, due to an OTP ECC errata,
    // disable ECC to avoid ECC errors while using Flash API functions that
    // read TI-OTP
    EALLOW;
    Flash0EccRegs.ECC_ENABLE.bit.ENABLE = 0x0;
    EDIS;

    // This function is required to initialize the Flash API based on System
    // frequency before any other Flash API operation can be performed
    EALLOW;
	oReturnCheck = Fapi_initializeAPI(F021_CPU0_BASE_ADDRESS, 200);//for now keeping it out
	EDIS;
    if(oReturnCheck != Fapi_Status_Success)
    {
        // Check Flash API documentation for possible errors
    }

    // Fapi_setActiveFlashBank function sets the Flash bank and FMC for further
    // Flash operations to be performed on the bank
    EALLOW;
    oReturnCheck = Fapi_setActiveFlashBank(Fapi_FlashBank0);
    EDIS;
    if(oReturnCheck != Fapi_Status_Success)
    {
        // Check Flash API documentation for possible errors

    }

    EALLOW;
    // Erase the sectors that we have programmed above
    // Erase Sector C
    oReturnCheck = Fapi_issueAsyncCommandWithAddress(Fapi_EraseSector,
                   (uint32 *)Bzero_SectorA_start);

    // Wait until FSM is done with erase sector operation
    while (Fapi_checkFsmForReady() != Fapi_Status_FsmReady){}

    // Verify that SectorC is erased.  The Erase step itself does a verify as
    // it goes.
    // This verify is a 2nd verification that can be done.
    oReturnCheck = Fapi_doBlankCheck((uint32 *)Bzero_SectorA_start,
                   Bzero_16KSector_u32length,
                   &oFlashStatusWord);
    EDIS;


    EALLOW;
    // Enable ECC
    Flash0EccRegs.ECC_ENABLE.bit.ENABLE = 0xA;
    EDIS;

    // Leave control over flash pump
    ReleaseFlashPump();

}	//Example_CallFlashAPI(void)