This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

functions in evmc66x_uart.c

/******************************************************************************
 * Copyright (c) 2011 Texas Instruments Incorporated - http://www.ti.com
 * 
 *  Redistribution and use in source and binary forms, with or without 
 *  modification, are permitted provided that the following conditions 
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the 
 *    documentation and/or other materials provided with the   
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 *****************************************************************************/

#include "platform_internal.h"

#if (PLATFORM_UART_IN)

/******************************************************************************
 *
 * File Name:  	evmc66x_uart.c
 *
 * Description:	This file contains APIs for  UART. 
 * 
 * 
 ******************************************************************************/

/************************
 * Include Files
 ************************/

/******************************************************************************
 * 
 * Function:	UartInit  
 *
 * Description:	This function initializes the UART. 
 *
 * Parameters:	void
 *
 * Return Value: void
 * 
 ******************************************************************************/
void UartInit(void)
{
    //      Allows access to the divisor latches of the baud generator during a 
    // read or write operation (DLL and DLH)
    CSL_FINS (hUartRegs->LCR, UART_LCR_DLAB, CSL_UART_LCR_DLAB_ENABLE);
    //      Break condition is disabled.
    CSL_FINS (hUartRegs->LCR, UART_LCR_BC,   CSL_UART_LCR_BC_DISABLE);
    //      Stick parity is disabled.
    CSL_FINS (hUartRegs->LCR, UART_LCR_SP,   CSL_UART_LCR_SP_DISABLE);
    //      Odd parity is selected
    CSL_FINS (hUartRegs->LCR, UART_LCR_EPS,  CSL_UART_LCR_EPS_ODD);
    //      No PARITY bit is transmitted or checked
    CSL_FINS (hUartRegs->LCR, UART_LCR_PEN,  CSL_UART_LCR_PEN_DISABLE);    

    // Set the baudrate,for accessing LCR[7] should be enable 
    hUartRegs->DLL  = DLL_VAL;
    hUartRegs->DLH  = DLM_VAL;

    // Allows access to the receiver buffer register (RBR), 
    // the transmitter holding register (THR), and the
    // interrupt enable register (IER) selected.
    CSL_FINS (hUartRegs->LCR, UART_LCR_DLAB, CSL_UART_LCR_DLAB_DISABLE);
    // Even Parity is selected
    CSL_FINS (hUartRegs->LCR, UART_LCR_EPS, CSL_UART_LCR_EPS_EVEN);
    // Parity Enable 
    CSL_FINS (hUartRegs->LCR, UART_LCR_PEN, CSL_UART_LCR_PEN_ENABLE);
 
    // Disable THR, RHR, Receiver line status interrupts
    CSL_FINS (hUartRegs->IER, UART_IER_ERBI,  CSL_UART_IER_ERBI_DISABLE);
    CSL_FINS (hUartRegs->IER, UART_IER_ETBEI, CSL_UART_IER_ETBEI_DISABLE);
    CSL_FINS (hUartRegs->IER, UART_IER_ELSI,  CSL_UART_IER_ELSI_DISABLE);
    CSL_FINS (hUartRegs->IER, UART_IER_EDSSI, CSL_UART_IER_EDSSI_DISABLE);  

    /* If autoflow control is desired, 
    * write appropriate values to the modem 
    * control register (MCR). Note that all UARTs 
    * do not support autoflow control, see 
    * the device-specific data manual for supported features.
    * 
    * MCR
    * ====================================================
    * Bit  Field   Value   Description
    * 5    AFE     0       Autoflow control is disabled
    * 4    LOOP    0       Loop back mode is disabled.
    * 1    RTS     0       RTS control (UARTn_RTS is disabled, 
    *                      UARTn_CTS is only enabled.)
    * =====================================================
    * 
    * 
    */

    hUartRegs->MCR = 0;

    /* Choose the desired response to 
    * emulation suspend events by configuring 
    * the FREE bit and enable the UART by setting 
    * the UTRST and URRST bits in the power and 
    * emulation management register (PWREMU_MGMT).
    * 
    * 
    * PWREMU_MGMT
    * =================================================
    * Bit  Field   Value   Description
    * 14   UTRST   1       Transmitter is enabled
    * 13   URRST   1       Receiver is enabled
    * 0    FREE    1       Free-running mode is enabled
    * ===================================================
    * 
    */
    hUartRegs->PWREMU_MGMT = 0x6001;

    /* Cleanup previous data (rx trigger is also set to 0)*/
    /* Set FCR = 0x07;        */
    CSL_FINS (hUartRegs->FCR, UART_FCR_FIFOEN,   CSL_UART_FCR_FIFOEN_ENABLE);
    CSL_FINS (hUartRegs->FCR, UART_FCR_TXCLR,    CSL_UART_FCR_TXCLR_CLR);
    CSL_FINS (hUartRegs->FCR, UART_FCR_RXCLR,    CSL_UART_FCR_RXCLR_CLR);
    CSL_FINS (hUartRegs->FCR, UART_FCR_DMAMODE1, CSL_UART_FCR_DMAMODE1_DISABLE);
    CSL_FINS (hUartRegs->FCR, UART_FCR_RXFIFTL,  CSL_UART_FCR_RXFIFTL_CHAR1);

    return;
}

/******************************************************************************
 * 
 * Function:	UartSetBaudRate  
 *
 * Description:	This function sets the UART baudrate. 
 *
 * Parameters:	UINT16 uiBaudRate - baudrate to set
 *
 * Return Value: void
 * 
 ******************************************************************************/
void UartSetBaudRate(uint16_t uiBaudRate)
{
    uint8_t uiDLLVal = 0;
    uint8_t uiDLHVal = 0;

    hUartRegs->LCR = 0x80;
    uiDLLVal = (uint8_t )(0x00FF & uiBaudRate);
    uiDLHVal = (uint8_t )(0x00FF & (uiBaudRate  >> 8));

    // Set the baudrate,for accessing LCR[7] should be enable 
    hUartRegs->DLL  = uiDLLVal;
    hUartRegs->DLH  = uiDLHVal;
    hUartRegs->LCR = 0x03;
}

/******************************************************************************
 * 
 * Function:	UartReadBaudRate  
 *
 * Description:	This function reads the UART baudrate. 
 *
 * Parameters:	UART_device eUartDevice - Uart Device
 *
 * Return Value: UINT16 - 16 bit Baudrate read from UART
 * 
 ******************************************************************************/
uint16_t UartReadBaudRate(void)
{
    uint16_t ushBaudrate = 0;
    uint16_t ushTemp = 0;

    hUartRegs->LCR = 0x80;
    // Read the baudrate 
    ushBaudrate = hUartRegs->DLL;
    ushTemp     = hUartRegs->DLH;
    ushBaudrate = (ushBaudrate & 0xFF) | ((ushTemp & 0xFF) << 8); 
    hUartRegs->LCR = 0x03;
    return ushBaudrate;
}

/******************************************************************************
 * 
 * Function:	UartReadData  
 *
 * Description: This function reads a byte of data from I2C UART device  
 * 
 * Return Value: uint8_t - 8-bit value read from the RBR register
 ******************************************************************************/
uint8_t UartReadData(void)
{
	uint8_t uRcvChar = 0;
	
	uRcvChar = CSL_FEXT(hUartRegs->RBR, UART_RBR_DATA);
	
	return uRcvChar;
}

/******************************************************************************
 * 
 * Function:	UartWriteData
 *
 * Description:	This function writes a byte of data to UART device  
 * 
 * Parameters:	uint8_t uchAddress - Address of 8-bit register
 * 				uint8_t uchByte	-  8-bit data to write to THR
 *
 * Return Value: none
 ******************************************************************************/
void UartWriteData(uint8_t uchByte)

{
    while (!(CSL_FEXT(hUartRegs->LSR, UART_LSR_THRE))) {
		platform_delaycycles(10000);
    }
    CSL_FINS(hUartRegs->THR, UART_THR_DATA, uchByte);
    return;
}



/******************************************************************************
 * 
 * Function:	UartIsDataReady
 *
 * Description:	This function gets the status of DR bit  
 * 
 * Parameters:	none
 * 
 * Return Value: Status of DR bit
 * 				
 ******************************************************************************/
Bool UartIsDataReady(void)
{
	Bool DR_val = FALSE;
	
	if (CSL_UART_LSR_DR_READY == (CSL_FEXT(hUartRegs->LSR, UART_LSR_DR))) {
        DR_val  = TRUE;
    }
	
	return (DR_val);
}
/* Nothing past this point */

#endif

Hello,

I am using C6678 DSP. I want to active UART communication of DSP with external sensor. As some members of TI guided me to study pdk library.

C:\ti\pdk_C6678_1_1_2_6\packages\ti\platform\evmc6678l\platform_lib\src\evmc66x_uart.c

I have included path of this library:

"C:\ti\pdk_C6678_1_1_2_6\packages\ti\platform\evmc6678l\platform_lib\lib\debug\ti.platform.evm6678l.ae66"

Now i need some help about functions in this library.

how can i give values of these two arguments  "uint16_t" and "uiBaudRate"? how can i set baud rate?

void UartSetBaudRate(uint16_t uiBaudRate)
{
uint8_t uiDLLVal = 0;
uint8_t uiDLHVal = 0;

hUartRegs->LCR = 0x80;
uiDLLVal = (uint8_t )(0x00FF & uiBaudRate);
uiDLHVal = (uint8_t )(0x00FF & (uiBaudRate >> 8));

// Set the baudrate,for accessing LCR[7] should be enable
hUartRegs->DLL = uiDLLVal;
hUartRegs->DLH = uiDLHVal;
hUartRegs->LCR = 0x03;
}

In the following function, there are two arguments "uint8_t" and "uchByte". How can i find the adress of 8-t register? any document? Is uchByte data, which i'll get from sensor? how can i get adress of THR register? 

void UartWriteData(uint8_t uchByte)

{
while (!(CSL_FEXT(hUartRegs->LSR, UART_LSR_THRE))) {
platform_delaycycles(10000);
}
CSL_FINS(hUartRegs->THR, UART_THR_DATA, uchByte);
return;
}

I did not find this information in the document ( KeyStone Architecture Universal Asynchronous Receiver/Transmitter (UART)). Please help me about this in detail. Thanks

  • Hi Irfan Ullah,

    Irfan: said:

    how can i give values of these two arguments "uint16_t" and "uiBaudRate"? how can i set baud rate? In the following function, there are two arguments "uint8_t" and "uchByte". How can i find the adress of 8-t register? any document? Is uchByte data, which i'll get from sensor? how can i get adress of THR register?

    Looks like you are new to C programming. It is only one argument that is uiBaudRate and uint16_t is the corresponding datatype.

    The UartSetBaudRate() & UartWriteData() are the library functions to configure and write on UART port.

    Please refer the platform.c file on how to configure the UART using the library functions.

    PATH: PDK_INSTALL_DIR\packages\ti\platform\evmc6678l\platform_lib\src\platform.c

    I hope this helps.

    Thanks.

  • Dear Rajasekaran,

    I tried to find  "uiBaudRate" and "uchByte" in "platform.c" file. But, i am not able to find detail of these two arguments. I found only the following lines:

    p_info->cpu.megamodule_revision_major = 
    (uint16_t)(((*megm_rev) & MEGM_REV_ID_MAJ_MASK) >> MEGM_REV_ID_MAJ_SHIFT);

    uint8_t gDeviceNandBBlist[NAND_BLOCKS_PER_DEVICE];

    Please guide me. Thanks

  • Hi Irfan,

    Please refer the code snippet for the usage of UartSetBaudRate(),

    Platform_STATUS platform_uart_set_baudrate(uint32_t baudrate) {
    
    	uint16_t brate;
    
    	IFPRINT(platform_write("platform_uart_set_baudrate(baudrate=%d) called \n", baudrate));
    
        brate = ((Uint16) (PLATFORM_UART_INPUT_CLOCK_RATE/(baudrate * 16)));
    
    	UartSetBaudRate(brate);
    
        return Platform_EOK;
    }
    

    Please refer the code snippet for the usage of UartWriteData(),

    Platform_STATUS platform_uart_write(uint8_t buf)
    {
        UartWriteData(buf);
    
        return Platform_EOK;
    }
    

    Attached platform.c file for your reference. 

    /****************************************************************************
     * Copyright (c) 2011-2012 Texas Instruments Incorporated - http://www.ti.com
     *
     *  Redistribution and use in source and binary forms, with or without
     *  modification, are permitted provided that the following conditions
     *  are met:
     *    Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     *
     *    Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the
     *    distribution.
     *
     *    Neither the name of Texas Instruments Incorporated nor the names of
     *    its contributors may be used to endorse or promote products derived
     *    from this software without specific prior written permission.
     *
     *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     *
     *****************************************************************************/
    #include "platform_internal.h"
    
    /* Errno value */
    uint32_t platform_errno = 0;
    uint32_t platform_init_return_code = 0;
    
    
    /* Platform Library Version*/
    #if (PLATFORM_VERSTRING_IN)
    #pragma DATA_SECTION(platform_library_version,"platform_lib");
    static char platform_library_version[16] = PLATFORM_LIB_VERSION;
    #endif
    
    /* Information we need to keep around for access */
    #pragma DATA_SECTION(platform_mcb,"platform_lib");
    static struct platform_mcb_t {
        uint32_t	frequency;
        int32_t  	board_version;
        int32_t		mastercore;
    } platform_mcb = {0, 0, 0};
    
    #if (PLATFORM_WRITE_IN)
    #pragma DATA_SECTION(write_type,"platform_lib");
    static WRITE_info	write_type;
    #pragma DATA_SECTION(write_buffer,"platform_lib");
    static char			write_buffer[MAX_WRITE_LEN];
    #endif
    
    
    /* This structure holds information about the devices on the platform */
    #if (PLATFORM_NAND_IN)
    #pragma DATA_SECTION(gDeviceNandBBlist,"platform_lib");
    uint8_t gDeviceNandBBlist[BLOCKS_PER_DEVICE];
    
    #pragma DATA_SECTION(gDeviceNand,"platform_lib");
    PLATFORM_DEVICE_info gDeviceNand = {0x2C,	0xA1,PLATFORM_DEVICE_NAND, 8, BLOCKS_PER_DEVICE, PAGES_PER_BLOCK, BYTES_PER_PAGE, SPARE_BYTES_PER_PAGE, PLATFORM_DEVID_MT29F1G08ABCHC, 5, 0x800, 0, NULL, NULL};
    #endif
    
    #if (PLATFORM_NOR_IN)
    #pragma DATA_SECTION(gDeviceNor,"platform_lib");
    PLATFORM_DEVICE_info gDeviceNor  = {0, 0, PLATFORM_DEVICE_NOR, 8, SPI_NOR_SECTOR_COUNT, (SPI_NOR_PAGE_COUNT / SPI_NOR_SECTOR_COUNT), SPI_NOR_PAGE_SIZE, 0, PLATFORM_DEVID_NORN25Q032A, 0, 0, 0, NULL, NULL};
    #endif
    
    #if (PLATFORM_EEPROM_IN)
    #pragma DATA_SECTION(gDeviceEeprom0,"platform_lib");
    PLATFORM_DEVICE_info gDeviceEeprom0 = {PLATFORM_EEPROM_MANUFACTURER_ID,PLATFORM_EEPROM_DEVICE_ID_1,PLATFORM_DEVICE_EEPROM,	8, 1, 1, 65536, 0, PLATFORM_DEVID_EEPROM50, 0, 0, 0, NULL, NULL};
    #pragma DATA_SECTION(gDeviceEeprom1,"platform_lib");
    PLATFORM_DEVICE_info gDeviceEeprom1 = {PLATFORM_EEPROM_MANUFACTURER_ID,PLATFORM_EEPROM_DEVICE_ID_2,PLATFORM_DEVICE_EEPROM,	8, 1, 1, 65536, 0, PLATFORM_DEVID_EEPROM51, 0, 0, 0, NULL, NULL};
    #endif
    
    /* This structure holds information about the EMAC port on the platform */
    #pragma DATA_SECTION(emac_port_mode,"platform_lib");
    PLATFORM_EMAC_PORT_MODE emac_port_mode[PLATFORM_MAX_EMAC_PORT_NUM] =
    {
        PLATFORM_EMAC_PORT_MODE_PHY
    };
    
    #if (PLATFORM_EXTMEMTEST_IN || PLATFORM_INTMEMTEST_IN)
    static inline int32_t platform_memory_test (uint32_t start_address, uint32_t end_address);
    #endif
    
    /******************************************************************************
     * platform_get_frequency
     *
     * Internal function to read frequency from PLL.
     *
     ******************************************************************************/
    static inline uint32_t platform_get_frequency(void)
    {
        CSL_Status      status;
        PllcHwSetup     hwSetupRead;
        uint32_t        dsp_freq;
        
        status = CorePllcGetHwSetup (&hwSetupRead);
    
        if (status != CSL_SOK) {
            IFPRINT(platform_write("platform_get_info: Hardware setup parameters reading... Failed.\n"));
            IFPRINT(platform_write("\tReason: Error setting in hardware validation."\
                    " [status = 0x%x].\n", status));
            platform_errno = PLATFORM_ERRNO_GENERIC;
            return (uint32_t)-1;
        } else {
            /* Compute the real dsp freq (*100) */
            dsp_freq = (hwSetupRead.pllM + 1)>> 1;
            dsp_freq = (dsp_freq * PLATFORM_BASE_CLK_RATE_MHZ)/(hwSetupRead.preDiv + 1);        
        }
    
        return (dsp_freq);
        
    }
    
    Bool
    serial_num_isvalid
    (
        char    c
    )
    {
        if (
            ((c >= '0') && (c <= '9'))    ||
            ((c >= 'a') && (c <= 'z'))    ||
            ((c >= 'A') && (c <= 'Z'))
           )
        {
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
    
    #define MAX_SN_SIZE             10      /* Maximum number of the chars of Serial Number for the EVM */
    #define MAX_SN_STORE_SIZE       128     /* Maximum size in bytes to store the serial number info */   
    static void
    getSerialNumber(char *buf)
    {
    #if (PLATFORM_EEPROM_IN)
    	PLATFORM_DEVICE_info    *p_device;
        uint32_t                i;
    
        buf[0] = 0;
    
        p_device = platform_device_open(PLATFORM_DEVID_EEPROM50, 0);
        if (p_device != NULL) 
        {
            /* Serial number stored in the last 128 bytes of the EEPROM 0x50 */
            if (platform_device_read(p_device->handle, gDeviceEeprom0.page_size-MAX_SN_STORE_SIZE, (uint8_t *)buf, 16) == Platform_EOK)
            {
                for (i = 0; i < MAX_SN_SIZE; i++)
                {
                    if(!serial_num_isvalid(buf[i]))
                    {
                        break;
                    }
                }
                buf[i] = 0;
            }
            else
            {
                IFPRINT(platform_write("Unable to read board serial number."));
            }
        }
    
        platform_device_close(p_device->handle);
    #endif
    
        return;
    }
    
    /******************************************************************************
     * platform_get_info
     ******************************************************************************/
    #if (PLATFORM_GETINFO_IN)
    void platform_get_info(platform_info * p_info)
    {
        uint32_t 			csr 		= CSL_chipReadCSR();
        volatile uint32_t 	*megm_rev   = (uint32_t *) (MEGM_REV_ID_REGISTER);
        uint32_t 			i;
        
        if (p_info == 0) {
            IFPRINT(platform_write("p_info argument is NULL\n"));
            platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
            return;
        }
    
        memset(p_info, 0, sizeof(platform_info));
    
        strncpy(p_info->version, platform_library_version, 16);
    
        p_info->cpu.core_count 	= PLATFORM_CORE_COUNT;
        p_info->cpu.id 		= (Uint16) CSL_FEXT(csr, CHIP_CSR_CPU_ID);
        p_info->cpu.revision_id     = (Uint16) CSL_FEXT(csr, CHIP_CSR_REV_ID);
        strncpy(p_info->cpu.name, PLATFORM_INFO_CPU_NAME, 32);
        
        p_info->cpu.megamodule_revision_major = 
            (uint16_t)(((*megm_rev) & MEGM_REV_ID_MAJ_MASK) >> MEGM_REV_ID_MAJ_SHIFT);
        p_info->cpu.megamodule_revision_minor = 
            (uint16_t)(((*megm_rev) & MEGM_REV_ID_MIN_MASK) >> MEGM_REV_ID_MIN_SHIFT);
    
        strncpy(p_info->board_name, PLATFORM_INFO_BOARD_NAME, 32);
    
    
        if ( TRUE == CSL_BootCfgIsLittleEndian() ) {
            p_info->cpu.endian = PLATFORM_LE;
        } 
        else {
            p_info->cpu.endian = PLATFORM_BE;
        }
    
        p_info->emac.port_count = PLATFORM_MAX_EMAC_PORT_NUM;
    
        p_info->frequency 			= platform_get_frequency();
        platform_mcb.frequency 		= p_info->frequency;
        p_info->board_rev 			= getBoardVersion();  
        platform_mcb.board_version 	= p_info->board_rev;
        getSerialNumber(p_info->serial_nbr);
    
        platform_get_macaddr(PLATFORM_MAC_TYPE_EFUSE, &(p_info->emac.efuse_mac_address[0]));
        platform_get_macaddr(PLATFORM_MAC_TYPE_EEPROM, &(p_info->emac.eeprom_mac_address[0]));
    
        for (i = PLATFORM_USER_LED_CLASS; i < PLATFORM_END_LED_CLASS; i++ ) {        
            switch (i) {
                case PLATFORM_USER_LED_CLASS:
                    p_info->led[i].count     = PLATFORM_FPGA_LED_COUNT;
                    break;
                case PLATFORM_SYSTEM_LED_CLASS:
                    p_info->led[i].count     = PLATFORM_I2C_LED_COUNT;
                    break;
                default:
                    IFPRINT(platform_write("Can't read LED Class information\n"));
                    platform_errno = PLATFORM_ERRNO_LED;
                    break;
            }        
        }
    }
    #endif
    
    /******************************************************************************
     * platform_init
     ******************************************************************************/
    #if (PLATFORM_INIT_IN)
    
    /* Registers to enable or disable memory ECC for L1, L2 and MSMC memories */
    #define L1PEDSTAT	0x01846404
    #define L1PEDCMD	0x01846408
    #define L1PEDADDR	0x0184640C
    #define L2EDSTAT	0x01846004
    #define L2EDCMD		0x01846008
    #define L2EDADDR	0x0184600C
    #define L2EDCPEC	0x01846018
    #define L2EDCNEC	0x0184601C
    #define L2EDCEN		0x01846030
    #define SMCERRAR	0x0BC00008
    #define	SMCERRXR	0x0BC0000C
    #define SMEDCC		0x0BC00010
    #define SMCEA		0x0BC00014
    #define SMSECC		0x0BC00018
    
    /*Enable EDC on MSMC*/
    /* Note: Once MSMC EDC is enabled, error correction stays enabled until
     * the MSMC is reset
     */
    
    static int MSMC_enableEDC ()
    {
    	unsigned int status = 0;
    
    	*(unsigned int *)(SMEDCC) &= 0x7FFFFFFF;	//Clear SEN(bit31)=0
    	*(unsigned int *)(SMEDCC) |= 0x40000000;	//Set ECM(bit30)=1
    
    	/* Check the status */
    	status = *(unsigned int *)(SMEDCC);
    
    
    	if ((status>>30)==0x1)
    		/* Enabled */
    		return 1;
    
    	/* Failed */
    	return 0;
    }
    
    
    /*Enable EDC on L1P*/
    static int enableL1PEDC ()
    {
    	unsigned int status = 0;
    
    	*(unsigned int *)(L1PEDCMD) = 0x1;	//Set EN(bit0)=1
    
    	/* Check the status */
    	status = *(unsigned int *)(L1PEDSTAT);
    
    	if ((status<<28) == 0x10000000)
    		/* Enabled */
    		return 1;
    
    	/* Failed */
    	return 0;
    }
    
    
    /*Enable EDC on L2*/
    static int enableL2EDC ()
    {
    	unsigned int status = 0;
    
    	*(unsigned int *)(L2EDCMD) = 0x1;
    
    	/* Check the status */
    	status = *(unsigned int *)(L2EDSTAT);
    
    	if ((status<<28) == 0x10000000)
    		/* Enabled */
    		return 1;
    
    	/* Failed */
    	return 0;
    }
    
    /*Enable all bits in L2EDCEN*/
    static int enableEDCL2EDCEN ()
    {
    	/* Set DL2CEN(bit0),PL2CEN(bit1),DL2SEN(bit2),PL2SEN(bit3),SDMAEN(bit4)=1 */
    	*(unsigned int *)(L2EDCEN) |= 0x1F;
    	return 1;
    }
    
    Platform_STATUS platform_init(platform_init_flags  * p_flags,
            					  platform_init_config * p_config)
    {
        CSL_Status              status;
        PllcHwSetup             pllc_hwSetup;
        PllcHwSetup             pllc_hwSetupRead;
    
    #ifdef PLATFORM_PLL_REINIT
        int loop_count;
    #endif
    
        /*************************************************************************
         * This routine may be called before BIOS or the application has loaded.
         * Do not try and write debug statements from here.
         ***********************************************************************/
    
        if ((p_flags == 0) || (p_config == 0)){
            platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
            return ( (Platform_STATUS) Platform_EFAIL);
        }
    
        /* Start TCSL so its free running */
        CSL_chipWriteTSCL(0);
    
    #ifdef PLATFORM_PLL_REINIT
        for (loop_count = 0; loop_count < 10; loop_count++) {
            platform_errno = 0;
    #endif
    
            /* PLLC module handle structure */
            if (p_flags->pll) {
    
                /* Set the Core PLL */
                /* Clear local data structures */
                memset(&pllc_hwSetup, 0, sizeof(PllcHwSetup));
    
                /* Setup PLLC hardware parameters */
                pllc_hwSetup.divEnable  = (CSL_BitMask32) (PLLC_DIVEN_PLLDIV2 |
                                                           PLLC_DIVEN_PLLDIV5 |
                                                           PLLC_DIVEN_PLLDIV8) ;
    
                /* Setup PLLC hardware parameters */        
                pllc_hwSetup.pllM       = 
                        (((p_config->pllm) ? p_config->pllm : PLATFORM_PLL1_PLLM_val) - 1);
                pllc_hwSetup.preDiv   = PLATFORM_PLL_PREDIV_val - 1;
                pllc_hwSetup.pllDiv2  = PLATFORM_PLLDIV2_val - 1;
                pllc_hwSetup.pllDiv5  = PLATFORM_PLLDIV5_val - 1;
                pllc_hwSetup.pllDiv8  = PLATFORM_PLLDIV8_val - 1;
                pllc_hwSetup.postDiv  = PLATFORM_PLL_POSTDIV_val -1;
    
                /* set Pll */
                status = CorePllcHwSetup (&pllc_hwSetup);
    
                if (status != CSL_SOK) {
                     platform_errno = PLATFORM_ERRNO_PLL_SETUP;
                    return ( (Platform_STATUS) Platform_EFAIL);
                }
    
                /* Read back */
                status = CorePllcGetHwSetup (&pllc_hwSetupRead);
    
                if (status != CSL_SOK) {
                    platform_errno = PLATFORM_ERRNO_PLL_SETUP;
                    return ( (Platform_STATUS) Platform_EFAIL);
                }
    
                /* Set the DDR3 PLL if DDR flag is set */
                if (p_flags->ddr) {
                    status = SetDDR3PllConfig();
                    if (status != CSL_SOK) {
                        platform_errno = PLATFORM_ERRNO_PLL_SETUP;
                        return ( (Platform_STATUS) Platform_EFAIL);
                    }
                }
            }
    		
            /* Initialize DDR3 */
            if (p_flags->ddr) {
                xmc_setup();
    
                status = DDR3Init();
    
                if (status != CSL_SOK) {
                    platform_errno = PLATFORM_ERRNO_GENERIC;
                    return ( (Platform_STATUS) Platform_EFAIL);
                }
            }
    
    #ifdef PLATFORM_PLL_REINIT
            if (!p_flags->pll || !p_flags->ddr) {
                break;
            }
    
            /* Run DDR3 test */
            if (platform_memory_test(PLL_REINIT_DDR3_TEST_START_ADDR, 
                    PLL_REINIT_DDR3_TEST_END_ADDR) == Platform_EOK) {
                break;
            }
        }
        platform_init_return_code = loop_count;
    
        if (loop_count == 10) {
            platform_errno = PLATFORM_ERRNO_GENERIC;
            return ( (Platform_STATUS) Platform_EFAIL);
        }
    #endif
    
        /* Save frequency, its needed by  platform_delay */
        if(!platform_mcb.frequency) {
          platform_mcb.frequency = platform_get_frequency();
        }
        PowerUpDomains();
    
        /* Enable Error Correction for memory */
        if (p_flags->ecc) {
        	   enableL1PEDC();
        	   enableEDCL2EDCEN();
        	   enableL2EDC();
        	   MSMC_enableEDC();
        }
    
        if (p_flags->phy) {
            configSerdes();
        }
    
        return Platform_EOK;
    }
    #endif
    
    /******************************************************************************
     * platform_get_coreid
     ******************************************************************************/
    #if (PLATFORM_GETCOREID_IN)
    uint32_t platform_get_coreid(void)
    {
        return (CSL_chipReadDNUM());
    }
    #endif
    
    /******************************************************************************
     * platform_getmacaddr
     ******************************************************************************/
    #if (PLATFORM_GETMACADDR_IN)
    Platform_STATUS platform_get_emac_info(uint32_t port_num, PLATFORM_EMAC_EXT_info * emac_info)
    {
        uint32_t mac_addr2, mac_addr1;
    
        IFPRINT(platform_write("platform_get_emac_info called \n"));
    
        emac_info->port_num       = port_num;
        emac_info->mode           = emac_port_mode[port_num];
    
        CSL_BootCfgGetMacIdentifier(&mac_addr1, &mac_addr2);
        emac_info->mac_address[0] = ((mac_addr2 & 0x0000ff00) >> 8);
        emac_info->mac_address[1] =  (mac_addr2 & 0x000000ff);
    
        emac_info->mac_address[2] = ((mac_addr1 & 0xff000000) >> 24);
        emac_info->mac_address[3] = ((mac_addr1 & 0x00ff0000) >> 16);
        emac_info->mac_address[4] = ((mac_addr1 & 0x0000ff00) >> 8);
        emac_info->mac_address[5] =  (mac_addr1 & 0x000000ff);
    
        return Platform_EOK;
    }
    
    /*
     * August 15, 2011 - platform_get_macaddr() is deprecated, application needs to call
     * the new API platform_get_emac_info() to get the MAC address of the port
     */
    Platform_STATUS platform_get_macaddr(PLATFORM_MAC_TYPE type, uint8_t * p_mac_address)
    {
    	IFPRINT(platform_write("platform_get_macaddr called \n"));
    
        switch (type) {
    
            case PLATFORM_MAC_TYPE_EFUSE:
            {
                uint32_t mac_addr2, mac_addr1;
    
                CSL_BootCfgGetMacIdentifier(&mac_addr1, &mac_addr2);
                p_mac_address[0] = ((mac_addr2 & 0x0000ff00) >> 8);
                p_mac_address[1] =  (mac_addr2 & 0x000000ff);
                p_mac_address[2] = ((mac_addr1 & 0xff000000) >> 24);
                p_mac_address[3] = ((mac_addr1 & 0x00ff0000) >> 16);
                p_mac_address[4] = ((mac_addr1 & 0x0000ff00) >> 8);
                p_mac_address[5] =  (mac_addr1 & 0x000000ff);
    
                return Platform_EOK;
            }
            
            default:
            case PLATFORM_MAC_TYPE_EEPROM:
            {
                memset(p_mac_address, 0, 6);
                return ((Platform_STATUS) Platform_EUNSUPPORTED);
            }
        }
    }
    #endif
    
    /******************************************************************************
     * platform_get_emac_start_evt_id
     ******************************************************************************/
    Platform_STATUS platform_get_emac_start_evt_id(void)
    {
        return CSL_GEM_MACRXINTN;
    }
    
    
    /******************************************************************************
     * platform_get_phy_addr
     ******************************************************************************/
    #if (PLATFORM_GETPHYADDR_IN)
    int32_t platform_get_phy_addr(uint32_t port_num)
    {
        IFPRINT(platform_write("platform_get_phy_addr called \n"));
    
        if(port_num == 0)
    	return 0x18;
        else
            return -1;
    }
    #endif
    
    
    /******************************************************************************
     * platform_get_switch_state
     ******************************************************************************/
    #if (PLATFORM_GETSWITCHSTATE_IN)
    uint32_t platform_get_switch_state(uint32_t id)
    {
    	IFPRINT(platform_write("platform_get_switch_state(id=%d) called \n", id));
    
       return (fpgaGetUserSwitch(id));
    }
    #endif
    
    /******************************************************************************
     * platform_phy_link_status
     ******************************************************************************/
    #if (PLATFORM_PHYLINKSTATUS_IN)
    Platform_STATUS platform_phy_link_status(uint32_t port_num)
    {
        return Platform_EOK;
    }
    #endif
    
    /******************************************************************************
     * platform_uart_read
     ******************************************************************************/
    #if (PLATFORM_UART_IN)
    Platform_STATUS platform_uart_read(uint8_t *buf, uint32_t delay)
    {
        uint32_t delayCount = delay;
    
        if (buf == NULL){
            return ((Platform_STATUS) Platform_EINVALID);
        }
    
        while( (UartIsDataReady()) != 1)
        {
            if (delayCount--)
            {
                platform_delay(1);
            }
            else
            {
                IFPRINT(platform_write("platform_uart_read: Read timeout\n"));
                platform_errno = PLATFORM_ERRNO_READTO;
                *buf = UartReadData();
                return ( (Platform_STATUS) Platform_EFAIL);
            }
        }
    
        *buf = UartReadData ();
    
        return Platform_EOK;
    }
    
    /******************************************************************************
     * platform_uart_write
     ******************************************************************************/
    Platform_STATUS platform_uart_write(uint8_t buf)
    {
        UartWriteData(buf);
    
        return Platform_EOK;
    }
    
    /******************************************************************************
     * platform_uart_set_baudrate
     ******************************************************************************/
    Platform_STATUS platform_uart_set_baudrate(uint32_t baudrate) {
    
    	uint16_t brate;
    
    	IFPRINT(platform_write("platform_uart_set_baudrate(baudrate=%d) called \n", baudrate));
    
        brate = ((Uint16) (PLATFORM_UART_INPUT_CLOCK_RATE/(baudrate * 16)));
    
    	UartSetBaudRate(brate);
    
        return Platform_EOK;
    }
    
    /******************************************************************************
     * platform_uart_init
     ******************************************************************************/
    Platform_STATUS platform_uart_init(void) {
    
    	IFPRINT(platform_write("platform_uart_init called \n"));
    
    	UartInit();
    
    	platform_uart_set_baudrate(115200);
    
        return Platform_EOK;
    }
    
    #endif
    
    
    /******************************************************************************
     * platform_fpgaWriteConfigReg
     ******************************************************************************/
    uint32_t platform_fpgaWriteConfigReg(uint8_t uchAddress, uint8_t uchValue)
    {
    	return(fpgaWriteConfigurationRegister(uchAddress, uchValue));
    }
    
    
    /******************************************************************************
     * platform_fpgaReadConfigReg
     ******************************************************************************/
    uint32_t platform_fpgaReadConfigReg(uint8_t uchAddress, uint8_t *puchValue)
    {
    	return(fpgaReadConfigurationRegister(uchAddress, puchValue));
    }
    
    
    /******************************************************************************
     * platform_led
     ******************************************************************************/
    #if (PLATFORM_LED_IN)
    Platform_STATUS platform_led(uint32_t led_id, PLATFORM_LED_OP operation, LED_CLASS_E led_class)
    {
    
    
    	IFPRINT(platform_write("platform_led(ledid=%d,operation=%d,class=%d) called \n", led_id, operation, led_class));
    
        switch (led_class) {
            case PLATFORM_USER_LED_CLASS:
                fpgaControlUserLEDs((FPGA_UserLed)(led_id),(FPGA_LedStatus) operation);
                break;
            case PLATFORM_SYSTEM_LED_CLASS:
            	return ( (Platform_STATUS) Platform_EUNSUPPORTED);
            default:
                IFPRINT(platform_write("platform_led: Invalid led_id %d\n", led_id));
                platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
                return ( (Platform_STATUS) Platform_EUNSUPPORTED);
        }
        return Platform_EOK;
    }
    #endif
    
    /******************************************************************************
     * platform_delay
     ******************************************************************************/
    #if (PLATFORM_DELAY_IN)
    Platform_STATUS platform_delay(uint32_t usecs)
    {
        int32_t delayCount = (int32_t) usecs * platform_mcb.frequency;
        int32_t start_val  = (int32_t) CSL_chipReadTSCL();
    
        while (((int32_t)CSL_chipReadTSCL() - start_val) < delayCount);
    
        return Platform_EOK;
    }
    
    void platform_delaycycles(uint32_t cycles)
    {
    	uint32_t start_val  = CSL_chipReadTSCL();
    
    	while ((CSL_chipReadTSCL() - start_val) < cycles);
    
        return;
    }
    #endif
    
    /******************************************************************************
     * platform_memory_test
     ******************************************************************************/
    #if (PLATFORM_EXTMEMTEST_IN || PLATFORM_INTMEMTEST_IN)
    static int32_t platform_memory_test (uint32_t start_address, uint32_t end_address)
    {
        uint32_t index, value;
    
        /* Write a pattern */
        for (index = start_address; index < end_address; index += 4) {
            *(volatile uint32_t *) index = (uint32_t)index;
        }
    
        /* Read and check the pattern */
        for (index = start_address; index < end_address; index += 4) {
            	
        	value = *(uint32_t *) index;
        	
            if (value  != index) {
                IFPRINT(platform_write("platform_memory_test: Failed at address index = 0x%x value = 0x%x *(index) = 0x%x\n",
                    index, value, *(volatile uint32_t *) index));
                platform_errno = index;
                return (Platform_EFAIL);
            }
        }
    
        /* Write a pattern for complementary values */
        for (index = start_address; index < end_address; index += 4) {
            *(volatile uint32_t *) index = (uint32_t)~index;
        }
    
        /* Read and check the pattern */
        for (index = start_address; index < end_address; index += 4) {
    
        	value = *(uint32_t *) index;
    
            if (value  != ~index) {
                IFPRINT(platform_write("platform_memory_test: Failed at address index = 0x%x value = 0x%x *(index) = 0x%x\n",
                    index, value, *(volatile uint32_t *) index));
                platform_errno = index;
                return (Platform_EFAIL);
            }
        }
    
        return Platform_EOK;
    }
    #endif
    
    /******************************************************************************
     * platform_external_memory_test
     ******************************************************************************/
    #if (PLATFORM_EXTMEMTEST_IN)
    Platform_STATUS platform_external_memory_test(uint32_t start_address, uint32_t end_address)
    {
    	IFPRINT(platform_write("platform_external_memory_test(start=0x%x,end=0x%x) called \n", start_address, end_address));
    
        if((start_address == 0) && (end_address == 0)) {
            start_address = PLATFORM_DDR3_SDRAM_START;
            end_address   = PLATFORM_DDR3_SDRAM_END - 1;
        }
    
        if ((start_address < PLATFORM_DDR3_SDRAM_START) ||
            (end_address >  PLATFORM_DDR3_SDRAM_END) ||
            (start_address >= end_address)){
            IFPRINT(platform_write("platform_external_memory_test: Start address (0x%08x) or end address (0x%08x)\n",
                start_address, end_address));
            platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
            return ((Platform_STATUS) Platform_EINVALID);
        }
    
        return platform_memory_test(start_address, end_address);
    }
    #endif
    
    /******************************************************************************
     * platform_internal_memory_test
     ******************************************************************************/
    #if (PLATFORM_INTMEMTEST_IN)
    Platform_STATUS platform_internal_memory_test(uint32_t id)
    {
        uint32_t start_address, end_address;
        CSL_PSC_MODSTATE state_prev, state_val;
        CSL_PSC_MDLRST   loc_rst_prev, loc_rst_val;
        uint32_t rstiso_prev_flag;    
        uint32_t module_number = 15;
        int32_t status = Platform_EOK;
    
    	IFPRINT(platform_write("platform_internal_memory_test(core=%d) called \n", id));
    
        if (platform_get_coreid() == id) {
            IFPRINT(platform_write("platform_internal_memory_test: Can't run the test own core(%d)\n",
                id));
            platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
            return ((Platform_STATUS) Platform_EUNSUPPORTED);
        }
    
        if (id >= PLATFORM_CORE_COUNT) {
            IFPRINT(platform_write("platform_internal_memory_test: core id should be in range [0..%d]\n",
                PLATFORM_CORE_COUNT - 1));
            platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
            return ((Platform_STATUS) Platform_EINVALID);
        }
    
        /* For the 6657L */
        if(id == 0)
          module_number = 23;
        else
          module_number = 24;
    
        /* Preserve the state, local reset and resetiso values */
        state_prev          = CSL_PSC_getModuleNextState(module_number);
        loc_rst_prev        = CSL_PSC_getModuleLocalReset(module_number);
        rstiso_prev_flag    = CSL_PSC_isModuleResetIsolationEnabled(module_number);
    
        /* Clear the state, local reset and resetiso values */
        state_val           = PSC_MODSTATE_SWRSTDISABLE;
        loc_rst_val         = PSC_MDLRST_ASSERTED;
    
        CSL_PSC_setModuleNextState(module_number, state_val);
        CSL_PSC_setModuleLocalReset(module_number, loc_rst_val);
        CSL_PSC_disableModuleResetIsolation(module_number);
    
        /* Test L1P memory region*/
        start_address = PLATFORM_L1P_BASE_ADDRESS | (id << 24);
        end_address   = start_address + PLATFORM_L1P_SIZE;
        if (platform_memory_test(start_address, end_address) != Platform_EOK) {
            status = Platform_EFAIL;
        }
    
        /* Test L1D memory region*/
        start_address = PLATFORM_L1D_BASE_ADDRESS | (id << 24);
        end_address   = start_address + PLATFORM_L1D_SIZE;
        if (platform_memory_test(start_address, end_address) != Platform_EOK) {
            status = Platform_EFAIL;
        }
    
        /* Restore the previous state, local reset and resetiso values */
        CSL_PSC_setModuleNextState(module_number, state_prev);
        CSL_PSC_setModuleLocalReset(module_number, loc_rst_prev);
        if (rstiso_prev_flag) {
             CSL_PSC_enableModuleResetIsolation(module_number);
        } else {
             CSL_PSC_disableModuleResetIsolation(module_number);
        }
        
        return status;
    }
    #endif
    
    /******************************************************************************
     * platform_write  - Printf or echo to UART or both
     ******************************************************************************/
    #if (PLATFORM_WRITE_IN)
    WRITE_info platform_write_configure (WRITE_info	wtype) {
    	WRITE_info original;
    	IFPRINT(platform_write("platform_write_configure(write_type=%d) called \n", wtype));
    	original = write_type;
    	write_type = wtype;
    	return original;
    }
    
    void platform_write(const char *fmt, ... )
    {
        va_list 	arg_ptr;
    	uint32_t	i, length;
    	
        /* Initial platform_write to temporary buffer.. at least try some sort of sanity check so we don't write all over
         * memory if the print is too large.
         */
        if (strlen(fmt) > MAX_WRITE_LEN) {platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT; return;}
     
        va_start( arg_ptr, fmt );
        length = vsprintf( (char *)write_buffer, fmt, arg_ptr );
        va_end( arg_ptr );
    
    	if ((write_type == PLATFORM_WRITE_PRINTF) || (write_type == PLATFORM_WRITE_ALL)) {
    		printf( "%s", write_buffer );
    	}
    
    	if ((write_type == PLATFORM_WRITE_UART) || (write_type == PLATFORM_WRITE_ALL)) {
    		/* Log to console port (routine only sends a byte at a time) */
    		for (i=0; i < length; i++) {
    			if (write_buffer[i] == '\n') {
    				(void) platform_uart_write((uint8_t)0x0D);
    				(void) platform_uart_write((uint8_t)0x0A);
    			}
    			else {
    				(void) platform_uart_write((uint8_t)write_buffer[i]);
    			}
    		}
    	}
    
    	return;
    }
    #endif
    
    
    /******************************************************************************
     * platform_flash_open
     ******************************************************************************/
    #if (PLATFORM_NAND_IN) || (PLATFORM_NOR_IN)  || (PLATFORM_EEPROM_IN)
    PLATFORM_DEVICE_info *platform_device_open(uint32_t deviceid, uint32_t flags ) {
     
    	PLATFORM_DEVICE_info *p_info;
    
    	IFPRINT(platform_write("platform_device_open(deviceid=0x%x,flags=0x%x) called \n", deviceid, flags));
    
    #if (PLATFORM_NAND_IN)
    
    	if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
    		/* Disable Write protect in NAND */
            if (nandInit() != SUCCESS) {
                IFPRINT(platform_write("platform_dveice_open: Initialization failed.\n"));
                return NULL;
            }
    
            /* Store the open flags */
            gDeviceNand.flags	= flags;
    
            /* Set the device to point to its bad block list */
            gDeviceNand.bblist = (uint8_t *)&gDeviceNandBBlist;
    
            p_info = &gDeviceNand;
    
       		 if (NandGetDetails(p_info) != SUCCESS) {
       		    IFPRINT(platform_write("platform_device_open: Unable to read device information.\n"));
                platform_errno = PLATFORM_ERRNO_BADFLASHDEV;
       		    return NULL;
       		 }
    
    		p_info->handle	= deviceid;
    
           return p_info;
    	}
    
    #endif
    
    #if (PLATFORM_NOR_IN)
    	    
    	NOR_STATUS      nor_status;
        
    	if (deviceid == PLATFORM_DEVID_NORN25Q032A) {
    
    		/* Disable Write protect in NOR */
           //fpgaDisableNorWriteProtect();
           nor_status = nor_init();
           if (nor_status != NOR_EOK) {
                IFPRINT(platform_write("platform_device_open: Initialization failed.\n"));
                return NULL;
            } 
    
           /* Store the open flags */
           gDeviceNor.flags	= flags;
    
           p_info = &gDeviceNor;
    
    	    if (nor_get_details(p_info) != SUCCESS) {
                IFPRINT(platform_write("platform_device_open: Unable to read device information.\n"));
                platform_errno = PLATFORM_ERRNO_BADFLASHDEV;
                return NULL;
    	    }
     
       		p_info->handle	= deviceid;
          
        	return p_info;
    	}
    #endif
    
    #if (PLATFORM_EEPROM_IN)
    
    	if (deviceid == PLATFORM_DEVID_EEPROM50) {
    	    /* Store the open flags */
    	    gDeviceEeprom0.flags	= flags;
                evmI2CInit();
                p_info = &gDeviceEeprom0;
                p_info->handle	= deviceid;
        	return p_info;
    	}
    
    	if (deviceid == PLATFORM_DEVID_EEPROM51) {
    	    /* Store the open flags */
    	    gDeviceEeprom1.flags	= flags;
            evmI2CInit();
    		p_info = &gDeviceEeprom1;
       		p_info->handle	= deviceid;
        	return p_info;
    	}
    
    #endif
    
    	platform_errno = PLATFORM_ERRNO_UNSUPPORTED;
    
    	return NULL;
    }
    #endif
    
    /******************************************************************************
     * platform_flash_close
     ******************************************************************************/
    #if (PLATFORM_NAND_IN) || (PLATFORM_NOR_IN)  || (PLATFORM_EEPROM_IN)
    Platform_STATUS platform_device_close(PLATFORM_DEVHANDLE deviceid) {
     
    	IFPRINT(platform_write("platform_device_close(handle=0x%x) called \n", deviceid));
    
    #if (PLATFORM_NAND_IN)
    	if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
    		gDeviceNand.handle = 0;
    		return Platform_EOK;
    	}
    #endif
    
    #if (PLATFORM_NOR_IN)
    	if (deviceid == PLATFORM_DEVID_NORN25Q032A) {
    		gDeviceNor.handle = 0;
         	return Platform_EOK;   
    	}
    #endif
    
    #if (PLATFORM_EEPROM_IN)
    
    	if (deviceid == PLATFORM_DEVID_EEPROM50) {
    		gDeviceEeprom0.handle = 0;
    		return Platform_EOK;
    	}
    
    	if (deviceid == PLATFORM_DEVID_EEPROM51) {
    		gDeviceEeprom1.handle = 0;
    		return Platform_EOK;
    	}
    
    #endif
    
    	return Platform_EUNSUPPORTED;
    }
    #endif
    
    /******************************************************************************
     * platform_flash_read_spare_data
     ******************************************************************************/
    #if (PLATFORM_NAND_IN) || (PLATFORM_NOR_IN) || (PLATFORM_EEPROM_IN)
    Platform_STATUS platform_device_read_spare_data(PLATFORM_DEVHANDLE deviceid,
    												uint32_t block_number,
    												uint32_t page_number,
    												uint8_t *buf) {
    
    	IFPRINT(platform_write("platform_device_read_spare_data(handle=0x%x, block=%d, page=%d,buf=0x%x) called \n",
    			deviceid, block_number, page_number, buf));
    
    	if (buf == NULL) {
    		platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    		return Platform_EINVALID;
    	}
    
    #if (PLATFORM_NAND_IN)
    	if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
    		if ((block_number >= gDeviceNand.block_count) || (page_number >= gDeviceNand.page_count))
            {
    			platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    			return Platform_EINVALID;
    		}
    
    	    if (NandReadSpareArea (&gDeviceNand, block_number, page_number, buf) != SUCCESS) {
    	        return ( (Platform_STATUS) Platform_EFAIL);
    	    }
           return Platform_EOK;
    	}
    #endif
    
    	return Platform_EUNSUPPORTED;
    													
    }
    #endif
    
    /******************************************************************************
     * platform_device_mark_block_bad
     ******************************************************************************/
    #if PLATFORM_NAND_WRITE_IN
    Platform_STATUS platform_device_mark_block_bad(PLATFORM_DEVHANDLE deviceid,
    												uint32_t block_number) {
    
        uint8_t *buf = NULL;
        PLATFORM_DEVICE_info *p_device;
    
        if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
    		p_device = &gDeviceNand;
        }
    	else {
    		p_device = NULL;
    	}
    
    	if (p_device == NULL) {
    		platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    		return Platform_EINVALID;
    	}
        
        buf =  (uint8_t *) Osal_platformMalloc(platform_roundup(p_device->spare_size, PLATFORM_CACHE_LINE_SIZE),
        										PLATFORM_CACHE_LINE_SIZE);
    
        platform_device_read_spare_data(deviceid, block_number, 0, buf);
    
        buf[p_device->bboffset] = 0xA5; /* BI indicator byte*/
        
    	if ( block_number >= gDeviceNand.block_count ) {
    		platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    		Osal_platformFree(buf, platform_roundup(p_device->spare_size, PLATFORM_CACHE_LINE_SIZE));
    		return Platform_EINVALID;
    	}
    
    	if (NandWriteSpareArea (p_device, block_number, 0, buf) != SUCCESS) {
    		Osal_platformFree(buf, platform_roundup(p_device->spare_size, PLATFORM_CACHE_LINE_SIZE));
    	    return ( (Platform_STATUS) Platform_EFAIL);
    	 }
    
    	Osal_platformFree(buf, platform_roundup(p_device->spare_size, PLATFORM_CACHE_LINE_SIZE));
    
        return Platform_EOK;
    
    }
    #endif
    
    /******************************************************************************
     * platform_flash_write_spare_data
     ******************************************************************************/
    #if (PLATFORM_NAND_IN) || (PLATFORM_NOR_IN) || (PLATFORM_EEPROM_IN)
    Platform_STATUS platform_device_write_spare_data(PLATFORM_DEVHANDLE deviceid,
    												uint32_t block_number,
    												uint32_t page_number,
    												uint8_t *buf) {
    
    	IFPRINT(platform_write("platform_device_write_spare_data(handle=0x%x, block=%d, page=%d,buf=0x%x) called \n",
    			deviceid, block_number, page_number, buf));
    
    	if (buf == NULL) {
    		platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    		return Platform_EINVALID;
    	}
    
    #if (PLATFORM_NAND_WRITE_IN)
    	if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
    		if ((block_number >= gDeviceNand.block_count) || (page_number >= gDeviceNand.page_count))
            {
    			platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    			return Platform_EINVALID;
    		}
    
    	    if (NandWriteSpareArea (&gDeviceNand, block_number, page_number, buf) != SUCCESS) {
    	        return ( (Platform_STATUS) Platform_EFAIL);
    	    }
           return Platform_EOK;
    	}
    #endif
    
    	return Platform_EUNSUPPORTED;
    													
    }
    #endif
    
    /******************************************************************************
     * platform_flash_read
     ******************************************************************************/
    #if (PLATFORM_NAND_IN) || (PLATFORM_NOR_IN) || (PLATFORM_EEPROM_IN)
    Platform_STATUS platform_device_read(PLATFORM_DEVHANDLE 	deviceid,
    									 uint32_t 	offset,
                                         uint8_t 	*buf,
                                         uint32_t	len) {
    
    	IFPRINT(platform_write("platform_device_read(handle=0x%x, offset=%d, len=%d, buf=0x%x) called \n",
    			deviceid, offset, len, buf));
    
    	if (buf == NULL || len == 0) {
    		platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    		return Platform_EINVALID;
    	}
    
    #if (PLATFORM_NAND_IN)
    	if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
        	NAND_ADDR addr;
            uint32_t  read_len = 0;
    
    	    addr.uiColumnAddr= 0;
    
            for (read_len = 0; read_len < len; read_len += gDeviceNand.page_size)
            {
                if (platform_offset_to_blocknpage(deviceid, offset+read_len, &addr.uiBlockAddr, &addr.uiPageAddr) != Platform_EOK) {
                    return Platform_EUNSUPPORTED;
                }
    
                if (readNandPage (&gDeviceNand, addr, &buf[read_len]) != SUCCESS) {
                    return ( (Platform_STATUS) Platform_EFAIL);
                }
            }
    		    
           	return Platform_EOK;
    	}
    #endif
    
    #if (PLATFORM_NOR_IN)
    	if (deviceid == PLATFORM_DEVID_NORN25Q032A) {
    	    if (nor_read (&gDeviceNor, offset, len, buf) != SUCCESS) {
    	        return ( (Platform_STATUS) Platform_EFAIL);
    	    }
         	return Platform_EOK;   
    	}
    #endif
    
    #if (PLATFORM_EEPROM_IN)
    
    	if (deviceid == PLATFORM_DEVID_EEPROM50) {
    	    if (i2cEepromRead (offset, len, buf, 0x50) != I2C_RET_OK) {
    	        IFPRINT(platform_write("platform_eeprom_read: EEPROM read failed\n"));
    	        return ( (Platform_STATUS) Platform_EFAIL);
    	    }
        	return Platform_EOK;
    	}
    
    	if (deviceid == PLATFORM_DEVID_EEPROM51) {
    	    if (i2cEepromRead (offset, len, buf, 0x51) != I2C_RET_OK) {
    	        IFPRINT(platform_write("platform_eeprom_read: EEPROM read failed\n"));
    	        return ( (Platform_STATUS) Platform_EFAIL);
    	    }
        	return Platform_EOK;
    	}
    
    #endif
    
    	return Platform_EUNSUPPORTED;
    
    }
    #endif
    
    /******************************************************************************
     * Computes a block and page based on an offset
     ******************************************************************************/
    #if (PLATFORM_NAND_IN) || (PLATFORM_NOR_IN)
    
    Platform_STATUS platform_offset_to_blocknpage(PLATFORM_DEVHANDLE 	deviceid,
    									 uint32_t 	offset,
                                         uint32_t 	*block,
                                         uint32_t	*page) {
    	uint32_t	leftover;
    	uint32_t	block_size;
    	uint32_t	block_count, page_size, page_count;
    
    	IFPRINT(platform_write("platform_offset_to_blocknpage(handle=0x%x, offset=%d) called \n",
    			deviceid, offset));
    
    	if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
    		block_count = gDeviceNand.block_count;
    		page_size	= gDeviceNand.page_size;
    		page_count 	= gDeviceNand.page_count;
    	}
    	else if (deviceid == PLATFORM_DEVID_NORN25Q032A) {
    		block_count = gDeviceNor.block_count;
    		page_size	= gDeviceNor.page_size;
    		page_count 	= gDeviceNor.page_count;
    	}
    	else {
    		return Platform_EUNSUPPORTED;
    	}
    
    	block_size = (page_count * page_size);
    
    	*block 	  = offset / block_size;
    	leftover  = offset % block_size;
    	*page 	  = leftover / page_size;
    	if (leftover % page_size) {
    		/* All writes must be page aligned for now */
    		return Platform_EUNSUPPORTED;
    	}
    	if (*block > block_count) {
    		return Platform_EINVALID;
    	}
    	if (*page > page_count) {
    		return Platform_EINVALID;
    	}
    
    	IFPRINT(platform_write("platform_offset_to_blocknpage: offset = %d block = %d page = %d \n", offset, *block, *page));
    
    	return Platform_EOK;
    
    }
    
    #endif
    
    /******************************************************************************
     * Computes a block and page based on an offset
     ******************************************************************************/
    #if (PLATFORM_NAND_IN) || (PLATFORM_NOR_IN)
    
    Platform_STATUS platform_blocknpage_to_offset(PLATFORM_DEVHANDLE 	deviceid,
    									 uint32_t 	*offset,
                                         uint32_t 	block,
                                         uint32_t	page) {
    
    	uint32_t	block_count, page_size, page_count;
    
    	IFPRINT(platform_write("platform_blocknpage_to_offset(handle=0x%x, block=%d, page=%d) called \n",
    			deviceid, block, page));
    
    	if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
    		block_count = gDeviceNand.block_count;
    		page_size	= gDeviceNand.page_size;
    		page_count 	= gDeviceNand.page_count;
    	}
    	else if (deviceid == PLATFORM_DEVID_NORN25Q032A) {
    		block_count = gDeviceNor.block_count;
    		page_size	= gDeviceNor.page_size;
    		page_count 	= gDeviceNor.page_count;
    	}
    	else {
    		return Platform_EUNSUPPORTED;
    	}
    
    	if (block >block_count || page > page_count) {
    			return Platform_EINVALID;
    	}
    
    	*offset = 	(block * (page_count * page_size)) + (page * page_size);
    
    	IFPRINT(platform_write("platform_blocknpage_to_offset: offset = %d block = %d page = %d \n", *offset, block, page));
    
    	return Platform_EOK;
    }
    
    #endif
    
    /******************************************************************************
     * platform_flash_write
     ******************************************************************************/
    
    #if (PLATFORM_NAND_IN) || (PLATFORM_NOR_IN) || (PLATFORM_EEPROM_IN)
    
    Platform_STATUS platform_device_write(PLATFORM_DEVHANDLE 	deviceid,
    									 uint32_t 	offset,
                                         uint8_t 	*buf,
                                         uint32_t	len) {
    
    	IFPRINT(platform_write("platform_device_write(handle=0x%x, offset=%d, len=%d, buf=0x%x) called \n",
    			deviceid, offset, len, buf));
    
    	/* Check general args */
    	if (buf == NULL || len == 0) {
    		platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    		return Platform_EINVALID;
    	}
    
    #if (PLATFORM_NAND_WRITE_IN || PLATFORM_NOR_WRITE_IN)
    	if ((deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) || (deviceid == PLATFORM_DEVID_NORN25Q032A))
    	{
    	    NAND_ADDR 			 addr;
    	    NAND_ADDR 			 StartAddress;
    	    Platform_STATUS		 retval = Platform_EOK;
    	    PLATFORM_DEVICE_info *p_device;
    		int32_t				block, page;
    		int32_t				bufindex;
    		int32_t				index;
    		int32_t				useable_page_size;
    		int32_t				block_size;
    		uint32_t			noraddress;
    		uint8_t				*pBlock	= NULL;
    		uint8_t				*pPage	= NULL;
    
    		if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
    			p_device = &gDeviceNand;
    		}
    		else {
    			p_device = &gDeviceNor;
    		}
    
    		/* Calculate the usable page area.. Its the size of the page  */
    		useable_page_size = p_device->page_size;
    
    		/* allocate a buffer big enough to hold one block (must include spare area) */
    		block_size = p_device->page_size * p_device->page_count;
    
    		pBlock = Osal_platformMalloc(platform_roundup(block_size, PLATFORM_CACHE_LINE_SIZE),
    									 PLATFORM_CACHE_LINE_SIZE);
    
    		if ( !pBlock ){
    			platform_errno = PLATFORM_ERRNO_OOM;
    			retval = Platform_EFAIL;
    			goto FLASHWRITE_ERROR;
    		}
    
    		/* allocate a buffer big enough to hold one page of the flash */
    		pPage =  Osal_platformMalloc(platform_roundup(p_device->page_size, PLATFORM_CACHE_LINE_SIZE),
    				 	 	 	 	 	 PLATFORM_CACHE_LINE_SIZE);
    
    		if ( !pPage ){
    			platform_errno = PLATFORM_ERRNO_OOM;
    			retval = Platform_EFAIL;
    			goto FLASHWRITE_ERROR;
    		}
    
    		/* Get starting address */
    		addr.uiColumnAddr= 0;
    		if (platform_offset_to_blocknpage(deviceid, offset, &addr.uiBlockAddr, &addr.uiPageAddr) != Platform_EOK) {
    			retval = Platform_EUNSUPPORTED;
    			goto FLASHWRITE_ERROR;
    		}
    
    		/*
    		 * We can now write the file to flash. The basic algorithm is this:
    		 *  Read the bad block table
    		 *  While we have data to write do
    		 *     skip block if bad
    		 *     read the block   (page level)
    		 *     erase the block  (block level)
    		 *     write the block	(page level)
    		 */
    
    		/* set index to start of the data to write */
    		bufindex = 0;
    
    		/* Initialize the starting block we will be using */
    		block 	= addr.uiBlockAddr;
    		StartAddress.uiBlockAddr  = addr.uiBlockAddr;
    		StartAddress.uiPageAddr	  = addr.uiPageAddr;
    		StartAddress.uiColumnAddr = 0;
    
    		while (len) {
    
    			/* Skip bad blocks */
    			if (p_device->bblist) {
    				if (p_device->bblist[block] == 0x00) {
    					/* Block is bad, skip to next good one */
    					IFPRINT(platform_write( "platform_device_write: Skipping bad block %d. \n", block));
    					block++;
    					while (p_device->bblist[block] == 0x00) {
    						block++;
    					}
    				}
    			}
    
    			/* Make sure we didn't exceed number of blocks  */
    			if (block > p_device->block_count) {
    				IFPRINT(platform_write( "Due to bad blocks, you have run out of room in the Flash for this image. \n"));
    				platform_errno = PLATFORM_ERRNO_NOFREEBLOCKS;
    				retval = Platform_EFAIL;
    				goto FLASHWRITE_ERROR;
    			}
    
    			IFPRINT(platform_write( "platform_device_write: Writing block %d \n", block));
    
    			/*
    			 * Read the block..
    			 *    may need to preserve what we don't actually write out.
    			 */
    			for (page=0, index = 0; page < p_device->page_count;
    				 page ++, index +=p_device->page_size) {
    				addr.uiBlockAddr = block;
    				addr.uiPageAddr	 = page;
    				addr.uiColumnAddr= 0;
    				if (p_device->handle == PLATFORM_DEVID_MT29F1G08ABCHC) {
    #if (PLATFORM_NAND_WRITE_IN)
    
    					if (readNandPage (&gDeviceNand, addr, (uint8_t *)(pBlock + index)) != SUCCESS) {
    						retval = Platform_EFAIL;
    						IFPRINT(platform_write( "platform_device_write: Error reading block %d page %d. \n", block, page));
    						goto FLASHWRITE_ERROR;
    					}
    #endif
    				}
    			    else {
    #if (PLATFORM_NOR_WRITE_IN)
    			    	(void) platform_blocknpage_to_offset(p_device->handle, &noraddress, addr.uiBlockAddr, addr.uiPageAddr);
    			    	 if (nor_read (&gDeviceNor, noraddress, p_device->page_size, (uint8_t *)(pBlock + index)) != SUCCESS) {
    						 retval = Platform_EFAIL;
    						 platform_write( "platform_device_write: Error reading block %d page %d. \n", block, page);
    						 goto FLASHWRITE_ERROR;
    			    	}
    #endif
    			    }
    			}
    
    			/* erase the block */
    			if (p_device->handle == PLATFORM_DEVID_MT29F1G08ABCHC) {
    #if (PLATFORM_NAND_WRITE_IN)
    				if (nandFlashBlockErase (&gDeviceNand, block) != SUCCESS) {
    					IFPRINT(platform_write( "platform_device_write: Could not erase block %d. \n", block));
    					retval = Platform_EFAIL;
    					goto FLASHWRITE_ERROR;
    				}
    #endif
    			}
    			else {
    #if (PLATFORM_NOR_WRITE_IN)
    			    if (nor_erase (&gDeviceNor, block) != SUCCESS) {
    					IFPRINT(platform_write( "platform_device_write: Could not erase block %d. \n", block));
    					retval = Platform_EFAIL;
    					goto FLASHWRITE_ERROR;
    			    }
    #endif
    			}
    
    			/*
    			 * Write the block...
    			 * 	 - Get one page of data and write out or
    			 *   - if we run out of data re-write what we previously read.
    			 */
    			for (page = 0, index = 0; page < p_device->page_count;
    				 page ++, index +=p_device->page_size) {
    
    				IFPRINT(platform_write( "platform_device_write: Writing to block %d page %d \n", block, page));
    
    				if (block == StartAddress.uiBlockAddr && page < StartAddress.uiPageAddr) {
    				   /* if we are within the first block we are writing, then we may have a start
    					* page other than page 0, so re-write what was there.
    					*/
    					memcpy(pPage, (pBlock+bufindex), useable_page_size);
    				}
    				else
    				if (len == 0) {
    					/* we wrote all the data, so write back any pages we pre-read that are left */
    					memcpy(pPage, (pBlock+bufindex), useable_page_size);
    				}
    				else
    				if (len < useable_page_size) {
    					/* we have less than a full page of data */
    					memset(pPage, 0xFF, p_device->page_size);
    					memcpy(pPage, (buf+bufindex), len);
    					len = 0;
    				}
    				else {
    					/* get a full page of data */
    					memcpy(pPage, (buf+bufindex), useable_page_size);
    					len -= useable_page_size;
    					bufindex += useable_page_size;
    				}
    				/* write the page */
    				addr.uiBlockAddr = block;
    				addr.uiPageAddr	 = page;
    				addr.uiColumnAddr= 0;
    				if (p_device->handle == PLATFORM_DEVID_MT29F1G08ABCHC) {
    #if (PLATFORM_NAND_WRITE_IN)
    					if (writeNandPage (&gDeviceNand, addr, pPage) != SUCCESS) {
    						IFPRINT(platform_write( "platform_device_write: Error writing block %d page %d. \n", block, page));
    						retval = Platform_EFAIL;
    						goto FLASHWRITE_ERROR;
    					}
    #endif
    				}
    				else {
    #if (PLATFORM_NOR_WRITE_IN)
    			    	(void) platform_blocknpage_to_offset(p_device->handle, &noraddress, addr.uiBlockAddr, addr.uiPageAddr);
    					if (nor_write(&gDeviceNor, noraddress,  p_device->page_size, pPage) != SUCCESS) {
    						IFPRINT(platform_write( "platform_device_write: Error writing block %d page %d. \n", block, page));
    						retval = Platform_EFAIL;
    						goto FLASHWRITE_ERROR;
    					}
    #endif
    				}
    			}
    
    			/* increment to the next block */
    			block++;
    		}
    	
    FLASHWRITE_ERROR:
    
    		if (pBlock) {
    			Osal_platformFree( pBlock, platform_roundup(block_size, PLATFORM_CACHE_LINE_SIZE) );
    		}
    
    		if (pPage) {
    			Osal_platformFree( pPage, platform_roundup(p_device->page_size, PLATFORM_CACHE_LINE_SIZE));
    		}
    
    		return retval;
    	}
    #endif
    
    #if (PLATFORM_EEPROM_IN) && (PLATFORM_EEPROM_WRITE_IN)
    
    	if (deviceid == PLATFORM_DEVID_EEPROM50) {
    	   if (i2cEepromWriteByteAddr(offset, 0x50, buf, len, I2C_RELEASE_BUS) != I2C_RET_OK) {
    	       IFPRINT(platform_write("platform_device_write: EEPROM write for address 0x%x failed\n", 0x50));
    	       platform_errno = PLATFORM_ERRNO_EEPROM;
    	       return ( (Platform_STATUS) Platform_EFAIL);
    	    }
        	return Platform_EOK;
    	}
    
    	if (deviceid == PLATFORM_DEVID_EEPROM51) {
    	   if (i2cEepromWriteByteAddr(offset, 0x51, buf, len, I2C_RELEASE_BUS) != I2C_RET_OK) {
    	       IFPRINT(platform_write("platform_device_write: EEPROM write for address 0x%x failed\n", 0x51));
    	       platform_errno = PLATFORM_ERRNO_EEPROM;
    	       return ( (Platform_STATUS) Platform_EFAIL);
    	    }
        	return Platform_EOK;
    	}
    
    #endif
    
    	return Platform_EUNSUPPORTED;
    
    }
    #endif
    									
    /******************************************************************************
     * platform_flash_erase_block
     ******************************************************************************/
    #if (PLATFORM_NAND_IN) || (PLATFORM_NOR_IN) || (PLATFORM_EEPROM_IN)
    Platform_STATUS platform_device_erase_block(PLATFORM_DEVHANDLE	deviceid,
                                               uint32_t block_number) {
    
    	IFPRINT(platform_write("platform_device_erase_block(handle=0x%x, blockt=%d) called \n",
    			deviceid, block_number));
    
    #if (PLATFORM_NAND_IN) && (PLATFORM_NAND_WRITE_IN)
    	if (deviceid == PLATFORM_DEVID_MT29F1G08ABCHC) {
    		if (block_number >= gDeviceNand.block_count) {
    			platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    			return Platform_EINVALID;
    		}
    	    if (nandFlashBlockErase (&gDeviceNand, block_number) != SUCCESS) {
    	        return ( (Platform_STATUS) Platform_EFAIL);
    	    }		    
           	return Platform_EOK;
    	}
    #endif
    
    #if (PLATFORM_NOR_IN) && (PLATFORM_NOR_WRITE_IN)
    	if (deviceid == PLATFORM_DEVID_NORN25Q032A) {
    		if (block_number > gDeviceNor.block_count) {
    			platform_errno = PLATFORM_ERRNO_INVALID_ARGUMENT;
    			return Platform_EINVALID;
    		}
    	    if (nor_erase (&gDeviceNor, block_number) != SUCCESS) {
    	        return ( (Platform_STATUS) Platform_EFAIL);
    	    }
         	return Platform_EOK;   
    	}
    #endif
    
    	return Platform_EUNSUPPORTED;
    }
    #endif
    																
    
    #if PLATFORM_CACHE_IN
    uint32_t Convert_CoreLocal2GlobalAddr (uint32_t  addr)
    {
        uint32_t coreNum;
    
        /* Get the core number. */
    #ifdef SIMULATOR_SUPPORT
        coreNum = CSL_chipReadDNUM();
    #else
        coreNum = platform_get_coreid();
    #endif
        /* Check if the address is a valid Local L2 address to convert */
        if ( (addr >= (uint32_t) 0x800000) &&
             (addr <  (uint32_t) 0x880000) ) {
             /* Compute the global address. */
             return ((1 << 28) | (coreNum << 24) | (addr & 0x00ffffff));
        }
        else {
            return (addr);
        }
    }
    #endif
    
    

    Thanks.