/* m8260Flash.c - Flash memory device driver for 28F016 flash devices */

/* Copyright 1984-1999 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01d,15jul99,ms_  make compliant with our coding standards
01c,05jun99,cn   added sysFlashUpdate, updated documentation, removed 
		 unnecessary code.
01b,28may99,ms_  get flash28.h locally, not from the driver include location
01a,05may99,cn   derived from version 01k of mem/flashMem.c.
*/

/*
DESCRIPTION
This library contains routines to manipulate the 28F016 flash memory.  Read 
and write routines are included.

The macro values FLASH_ADRS, FLASH_SIZE, and FLASH_WIDTH must be defined to
indicate the address, size (in bytes), and the data-access width (in bytes) of
the flash memory. Besides, the macro FLASH_SIZE_WRITEABLE should be defined
to a reasonable amount of flash-memory that needs to be modified. In fact, 
the user is not likely to need to change the entire contents of the device.

*/

#include "drv/mem/flash28.h"

/* defines */

#define FLASH_DEF       UINT32
#define FLASH_CAST      (UINT32 *)
#define FLASH_BLK_SZ	0x10000
#define FLASH_ALIGN_SZ (FLASH_BLK_SZ * FLASH_WIDTH)

#ifdef FLASH_SIZE_WRITEABLE
#   define FLASH_MEM_SIZE		FLASH_SIZE_WRITEABLE
#else
#   define FLASH_MEM_SIZE		FLASH_SIZE
#endif	/* FLASH_SIZE_WRITEABLE */

/* globals */

/* forward declarations */

STATUS	sysFlashErase (UINT32 offset);
STATUS	sysFlashWrite (FLASH_DEF * pFB, UINT32 size, UINT32 offset,
                       FLASH_DEF value);
STATUS	sysFlashGet (UCHAR * string, UINT32 strLen, UINT32 offset);
UINT8	sysFlashTypeGet (void);
STATUS	sysFlashUpdate (UCHAR * filename);

/******************************************************************************
*
* sysFlashGet - get the contents of flash memory
*
* This routine copies the contents of flash memory into a specified
* string.  The string is terminated with an EOS.
*
* RETURNS: OK, or ERROR if access is outside the flash memory range.
*
* SEE ALSO: sysFlashSet()
*
* INTERNAL
* If multiple tasks are calling sysFlashSet() and sysFlashGet(),
* they should use a semaphore to ensure mutually exclusive access.
*/

STATUS sysFlashGet
    (
    UCHAR	* string,	/* where to copy flash memory      */
    UINT32	  strLen,	/* maximum number of bytes to copy */
    UINT32	  offset	/* byte offset into flash memory   */
    )
    {
    if ((offset < 0) || (strLen < 0) || ((offset + strLen) > FLASH_MEM_SIZE))
        return (ERROR);

    bcopyBytes ((char *) (FLASH_ADRS + offset), string, strLen);
    string [strLen] = EOS;

    return (OK);
    }

/******************************************************************************
*
* sysFlashErase - erase the contents of flash memory
*
* This routine clears the contents of flash memory from the specified
* <offset> up to the top.
*
* Flash 28F016 devices support block erase mode. This means each of the 32
* 64-KByte blocks is erased by writing a flash erase command to
* the device at any address within the target block, and verifying that 
* the operation completed successfully.
*
* RETURNS: OK, or ERROR if the contents of flash memory cannot be erased.
*/

STATUS sysFlashErase
    (
    UINT32 offset		/* offset from flash base address */
    )
    {
    volatile FLASH_DEF * pFA = FLASH_CAST (offset + FLASH_ADRS);
    STATUS retVal = OK;

    *pFA = FLASH28_CMD_RESET;

    for (; (pFA <= FLASH_CAST (FLASH_ADRS + ((UINT32) FLASH_MEM_SIZE - 1)))
	 && (retVal == OK); pFA += FLASH_BLK_SZ)
	{
	*pFA = FLASH28_CMD_ERASE_SETUP;             /* setup */
	*pFA = FLASH28F008_CMD_ERASE;               /* erase */
 
	/* Check Write State Machine Status */
 
	do
	    *pFA = FLASH28F008_CMD_READ_STATUS;
	while ((*pFA & FLASH28F008_STAT_WSMS) != FLASH28F008_STAT_WSMS);
 
	/* Check Erase Error Status */
     
	if ((*pFA & FLASH28F008_STAT_EWS) != 0)
	    {
	    *pFA = FLASH28F008_CMD_CLEAR_STATUS;
	    retVal = ERROR;
	    }

	/* check we are at the last block */

	if (pFA >= FLASH_CAST (FLASH_ADRS + (FLASH_MEM_SIZE - FLASH_ALIGN_SZ)))
	    break;
	}

    pFA = FLASH_CAST (FLASH_ADRS);
    *pFA = FLASH28_CMD_RESET;

    return (retVal);
    }

/******************************************************************************
*
* sysFlashWrite - write data to flash memory
*
* This routine copies specified data of a specified length, <size>, into a
* specified offset, <offset>, in the flash memory.  Data is passed as a string,
* <pFB>, if not NULL.  If NULL, data is taken as a repeated sequence of
* <value>.
* The parameter <offset> must be appropriately aligned for the width of
* the Flash devices in use.
*
* Flash 28F016 devices are programmed by a sequence of operations:
* .iP
* set up device to write
* .iP
* perform write
* .iP
* verify the write
* .LP
*
* RETURNS: OK, or ERROR if the write operation fails.
*
* SEE ALSO: sysFlashSet()
*/

STATUS sysFlashWrite
    (
    FLASH_DEF * pFB,	/* string to be copied; use <value> if NULL */
    UINT32 size,	/* size to program in bytes */
    UINT32 offset,	/* byte offset into flash memory */
    FLASH_DEF value	/* value to program */
    )
    {
    volatile FLASH_DEF * pFA = FLASH_CAST (FLASH_ADRS);	/* flash address */
    STATUS retVal = OK;

    *pFA = FLASH28_CMD_RESET;

    for (pFA = FLASH_CAST (FLASH_ADRS + offset); (pFA < FLASH_CAST
	(FLASH_ADRS + size + offset)) && (retVal == OK); pFA++)
	{
	if (pFB != NULL)
	    value = *pFB++;

	*pFA = FLASH28_CMD_PROG_SETUP;	/* write setup */
	*pFA = value;			/* data to write */

	/* Check Write State Machine Status */

	do
	    {
	    *pFA = FLASH28F008_CMD_READ_STATUS;
	    }
	while ((*pFA & FLASH28F008_STAT_WSMS) != FLASH28F008_STAT_WSMS);


	/* Check Byte Write Error Status */

	if ((*pFA & FLASH28F008_STAT_BWS) != 0)
	    {
	    *pFA = FLASH28F008_CMD_CLEAR_STATUS;
	    retVal = ERROR;
	    }
	}

    pFA = FLASH_CAST (FLASH_ADRS);
    *pFA = FLASH28_CMD_RESET;

    return (retVal);
    }

/******************************************************************************
*
* sysFlashTypeGet - determine the device type of on-board flash memory
*
* This routine uses the `read identifier code' command to determine the 
* device type of * on-board flash memory. The returned value should be 
* the one in drv/mem/flash28.h
*
* RETURNS: An integer indicating the device type of on-board flash memory.
*/

UINT8 sysFlashTypeGet (void)
    {
    volatile FLASH_DEF * pFA = FLASH_CAST (FLASH_ADRS);	/* flash address */
    UINT8 retVal;
    UINT32 temp;

    *pFA = FLASH28_CMD_RESET;
    *pFA = FLASH28_CMD_READ_ID;

    temp = (UINT32) *++pFA;

    retVal = (UINT8) temp;

    *pFA = FLASH28_CMD_RESET;

    return (retVal);
    }

/******************************************************************************
*
* sysFlashUpdate - update the contents of the flash device
*
* This code allows the user to overwrite the flash device with data from
* a file. It will copy data from "filename" to the flash device.  It first
* erase the device, and it attempts to write data to the flash device 
* via sysFlashWrite ().
*
* The user should pass a binary bootrom file, for example
* to update the bootrom with a VxWorks BSP bootrom image:
* .CS
*       % make bootrom
*         make: `bootrom' is up to date.
*       % elfToBin < bootrom > bootrom.bin
*
* -> sysUpdateFlash ("hostname:/tmp/bootrom.bin")
* The flash has been updated without error.
* .CE
*
* RETURNS: OK, or ERROR: if the file was not accessable, the
* file was too large to fit into the flash, the buffers cannot
* be allocated, sysFlashErase () or sysFlashWrite () returned error.
*
* SEE ALSO: sysFlashErase(), sysFlashGet(), sysFlashTypeGet(), sysFlashWrite()
*
* INTERNAL
* If multiple tasks are calling sysFlashSet() and sysFlashGet(),
* they should use a semaphore to ensure mutually exclusive access to flash
* memory.
*/

STATUS sysFlashUpdate
    (
    UCHAR * filename	/* file to be copied into flash memory */
    )
    {
    UCHAR	* pMemBuf;		/* holds the flash data */
    int		fd;                 	/* the bootrom image fd */
    int		statReturn;             /* return values    */

    /* first step is to open the file */

    if ((fd = open (filename, O_RDONLY, 0444)) == ERROR)
        return (ERROR);

    /* now we read it */

    pMemBuf = calloc (FLASH_MEM_SIZE, 1);
 
    if (pMemBuf == NULL)
        {
        printErr ("sysFlashUpdate: ");
        printErr ("Could not allocate 0x%x bytes.\n", (long) FLASH_MEM_SIZE);
        close (fd);
        return (ERROR);
        }
 
    statReturn = read (fd, pMemBuf, FLASH_MEM_SIZE);
 
    if ((statReturn > FLASH_MEM_SIZE) || (statReturn <= 0)) 
        {
        printErr ("Failed to read from file \n");
        close (fd);
	free (pMemBuf);
        return (ERROR);
	}

    /* see if contents are actually changing */

    if (bcmp ((char *) (FLASH_ADRS), pMemBuf, FLASH_MEM_SIZE) == 0)
	return (OK);

    /* now we can erase the device */

    if (sysFlashErase (0) == ERROR)
        return (ERROR);

    /* write to the device */

    if (sysFlashWrite ((FLASH_DEF *) pMemBuf, statReturn, 0, 0) == ERROR)
	{
        printErr ("Failed to write to the device \n");
        close (fd);
	free (pMemBuf);
        return (ERROR);
	}

    return (OK);
    }