/*******************************************************************************
Copyright (C) Marvell International Ltd. and its affiliates

This software file (the "File") is owned and distributed by Marvell 
International Ltd. and/or its affiliates ("Marvell") under the following
alternative licensing terms.  Once you have made an election to distribute the
File under one of the following license alternatives, please (i) delete this
introductory statement regarding license alternatives, (ii) delete the two
license alternatives that you have not elected to use and (iii) preserve the
Marvell copyright notice above.

********************************************************************************
Marvell Commercial License Option

If you received this File from Marvell and you have entered into a commercial
license agreement (a "Commercial License") with Marvell, the File is licensed
to you under the terms of the applicable Commercial License.
 
********************************************************************************
Marvell GPL License Option

If you received this File from Marvell, you may opt to use, redistribute and/or 
modify this File in accordance with the terms and conditions of the General 
Public License Version 2, June 1991 (the "GPL License"), a copy of which is 
available along with the File in the license.txt file or by writing to the Free 
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or 
on the worldwide web at http://www.gnu.org/licenses/gpl.txt. 

THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED 
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY 
DISCLAIMED.  The GPL License provides additional details about this warranty 
disclaimer.
********************************************************************************
Marvell BSD License Option

If you received this File from Marvell, you may opt to use, redistribute and/or 
modify this File under the following licensing terms. 
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 Marvell 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 "mflash/mvMFlash.h"
#include "mflash/mvMFlashSpec.h"
#include "mflash/mvPMFlash.h"
#include "mflash/mvPMFlashSpec.h"
#include "ctrlEnv/mvCtrlEnvLib.h" 

/*#define MV_DEBUG*/
#ifdef MV_DEBUG
#define DB(x) x
#else
#define DB(x)
#endif

/* MACROS */

/* Static Functions */
static MV_STATUS waitOnCmdDone              (MV_VOID);
static MV_STATUS waitOnEraseBitClear        (MV_VOID);
static MV_STATUS waitOnInfReadBitClear      (MV_VOID);
static MV_STATUS mvPMFlashReadSR            (MV_U8 * pStatusReg);
static MV_STATUS mvPMFlashReadRegSeq        (MV_U32 prgCmnd, MV_U8 * pStatusReg);
static MV_STATUS mvPMFlashWriteRegSeq       (MV_U32 prgCmnd, MV_U32 reg);
static MV_STATUS mvPMFlashProgSeq           (MV_MFLASH_INFO *pFlash, MV_U32 prgCmnd, MV_U32 offset, MV_U8 *pBlock);
static MV_STATUS mvPMFlashEraseSeq          (MV_MFLASH_INFO *pFlash, MV_U32 eraseCmnd);
static MV_STATUS mvPMFlashIndirectReadSeq   (MV_MFLASH_INFO *pFlash, MV_U32 readCmnd, MV_U8* p8Bytes);

/*******************************************************************************
* waitOnCmdDone - Wait for command done bit
*
* DESCRIPTION:
*       Block waiting for command done. Returns Error Status
*
********************************************************************************/
static MV_STATUS waitOnCmdDone(MV_VOID)
{
	MV_U32 i;
	/* loop over waiting for the command done bit to be set */
	for (i=0; i<MV_MFLASH_MAX_CMD_DONE_LOOP; i++)
		if (MV_REG_READ(MV_PMFLASH_IF_STATUS_REG) & MV_PMFLASH_CMD_DONE_MASK)
			return MV_OK;

    DB(mvOsPrintf("%s WARNING: Command Timeout!\n", __FUNCTION__);)
	return MV_TIMEOUT;
}

/*******************************************************************************
* waitOnEraseBitClear - Wait for erase bit to be cleared by H/W
*
* DESCRIPTION:
*       Block waiting for erase bit (bit13 in Flash command opcode register)
*		to be cleared by hardware as an indication that the command was accepted.
*
********************************************************************************/
static MV_STATUS waitOnEraseBitClear(MV_VOID)
{
	MV_U32 i;
	/* loop over waiting for the command done bit to be set */
	for (i=0; i<MV_MFLASH_MAX_CMD_DONE_LOOP; i++)
		if ((MV_REG_READ(MV_PMFLASH_CMD_OPCODE_REG) & MV_PMFLASH_ERASE_STRT_MASK) == 0)
			return MV_OK;

    DB(mvOsPrintf("%s WARNING: Command Timeout!\n", __FUNCTION__);)
	return MV_TIMEOUT;
}

/*******************************************************************************
* waitOnRdStatusBitClear - Wait for Read status bit to be cleared by H/W
*
* DESCRIPTION:
*       Block waiting for Read bit (bit14 in Flash command opcode register)
*		to be cleared by hardware as an indication that the command was executed.
*
********************************************************************************/
static MV_STATUS waitOnRdStatusBitClear(MV_VOID)
{
	MV_U32 i;
	/* loop over waiting for the command done bit to be set */
	for (i=0; i<MV_MFLASH_MAX_CMD_DONE_LOOP; i++)
		if ((MV_REG_READ(MV_PMFLASH_CMD_OPCODE_REG) & MV_PMFLASH_RDSR_SET_MASK) == 0)
			return MV_OK;

    DB(mvOsPrintf("%s WARNING: Command Timeout!\n", __FUNCTION__);)
	return MV_TIMEOUT;
}

/*******************************************************************************
* waitOnInfReadBitClear - Wait for Information Read bit to be cleared by H/W
*
* DESCRIPTION:
*       Block waiting for IREAD (bit15 in Flash command opcode register)
*		to be cleared by hardware as an indication that the requested 8bytes
*		are ready to be ready by s/w.
*
********************************************************************************/
static MV_STATUS waitOnInfReadBitClear(MV_VOID)
{
	MV_U32 i;
	/* loop over waiting for the command done bit to be set */
	for (i=0; i<MV_MFLASH_MAX_CMD_DONE_LOOP; i++)
		if ((MV_REG_READ(MV_PMFLASH_CMD_OPCODE_REG) & MV_PMFLASH_INF_READ_STRT_MASK) == 0)
			return MV_OK;

    DB(mvOsPrintf("%s WARNING: Command Timeout!\n", __FUNCTION__);)
	return MV_TIMEOUT;
}

/*******************************************************************************
* mvPMFlashReadRegSeq - Read internal register of the MFLASH
*
* DESCRIPTION:
*       Perform the Read internal register RAB
*
********************************************************************************/
static MV_STATUS mvPMFlashReadRegSeq(MV_U32 prgCmnd, MV_U8 * pStatusReg)
{	
	MV_U32 temp;
    MV_STATUS ret;

	/* set commnand opcode = RDSR */
	temp = MV_REG_READ(MV_PMFLASH_CMD_OPCODE_REG);
	temp = ((temp & ~MV_PMFLASH_CMD_OPCD_MASK) | prgCmnd | MV_PMFLASH_EAD9_8_MASK);
	MV_REG_WRITE(MV_PMFLASH_CMD_OPCODE_REG, temp);

	/* trigger the operation */
	MV_REG_BIT_SET(MV_PMFLASH_CMD_OPCODE_REG, MV_PMFLASH_RDSR_SET_MASK);	

	/* wait on the read status bit to be cleared */
	if ((ret = waitOnRdStatusBitClear()) != MV_OK)
		return ret;

	/* wait for command done bit - this is supposed to be immediate */
	if ((ret = waitOnCmdDone()) != MV_OK)
		return ret;

	/* read the satus register */
	*pStatusReg = (MV_REG_READ(MV_PMFLASH_STATUS_REG) & MV_PMFLASH_STATUS_MASK);
	
	return MV_OK;
}

/*******************************************************************************
* mvPMFlashWriteRegSeq - Write internal register of the MFLASH
*
* DESCRIPTION:
*       Perform the write internal register RAB
*
********************************************************************************/
static MV_STATUS mvPMFlashWriteRegSeq(MV_U32 prgCmnd, MV_U32 reg)
{	
    MV_STATUS ret;
	MV_U32 temp;

	/* set data to be written in the address low register */
	MV_REG_WRITE(MV_PMFLASH_ADDR_LOW_REG, (reg & 0xFFFF));

	/* set commnand opcode = prgCmnd */
	temp = MV_REG_READ(MV_PMFLASH_CMD_OPCODE_REG);
	temp = ((temp & ~MV_PMFLASH_CMD_OPCD_MASK) | prgCmnd | MV_PMFLASH_EAD9_8_MASK);
	MV_REG_WRITE(MV_PMFLASH_CMD_OPCODE_REG, temp);

	/* trigger the operation */
	MV_REG_BIT_SET(MV_PMFLASH_CMD_OPCODE_REG, MV_PMFLASH_ERASE_STRT_MASK);	

	/* wait for erase bit to be cleared */
	if ((ret = waitOnEraseBitClear()) != MV_OK)
		return ret;
	
	return MV_OK;
}

/*******************************************************************************
* mvPMFlashReadSR - Read the Status register
*
* DESCRIPTION:
*       Perform the Read status register RAB
*
********************************************************************************/
static MV_STATUS mvPMFlashReadSR(MV_U8 * pStatusReg)
{	
	return mvPMFlashReadRegSeq(MV_PMFLASH_OPCD_RDSR, pStatusReg);
}

/*******************************************************************************
* mvPMFlashProgSeq - Perform the program sequence for the MFLASH
*
* DESCRIPTION:
*       program a 64 byte block (with or without compare after program) on 
*		both the main and information regions of the flash.
*
********************************************************************************/
static MV_STATUS mvPMFlashProgSeq(MV_MFLASH_INFO *pFlash, MV_U32 prgCmnd, MV_U32 offset, 
                                  MV_U8 *pBlock)
{
	MV_U32 i;
	MV_U16 * pBuff;
	MV_U8 status;
	MV_U32 temp;
    MV_STATUS ret;

	/* check that the programming offset is alligned according to requirement */
	if (offset & MV_MFLASH_PROG_ALIGN_MASK)
    {
        DB(mvOsPrintf("%s WARNING: Programming allignment problem!\n", __FUNCTION__);)
		return MV_NOT_ALIGNED;
    }

	/* Set the flash address low */
	MV_REG_WRITE(MV_PMFLASH_ADDR_LOW_REG, (offset & 0xFFFF));

	/* set the flash address high */
	MV_REG_WRITE(MV_PMFLASH_ADDR_HI_REG, ((offset >> 16) & 0xFFFF));

	/* set commnand opcode = prgCmnd */
	temp = MV_REG_READ(MV_PMFLASH_CMD_OPCODE_REG);
	temp = ((temp & ~MV_PMFLASH_CMD_OPCD_MASK) | prgCmnd | MV_PMFLASH_EAD9_8_MASK);
	MV_REG_WRITE(MV_PMFLASH_CMD_OPCODE_REG, temp);

	/* start the programming operation - set bit 12 to 1 */
	MV_REG_BIT_SET(MV_PMFLASH_CMD_OPCODE_REG, MV_PMFLASH_WR_OPER_STRT_MASK);	

	/* serialize the whole 64 byte buffer */
	pBuff = (MV_U16*)pBlock;
	for (i=0; i<MV_PMFLASH_PROG_WORDS_PER_CHUNK; i++)
	{
		MV_REG_WRITE(MV_PMFLASH_DATA_REG, MV_16BIT_LE(*pBuff));
		pBuff++;
	}

	/* stop the programming operation - set bit 12 to 0 */
	MV_REG_BIT_RESET(MV_PMFLASH_CMD_OPCODE_REG, MV_PMFLASH_WR_OPER_STRT_MASK);	

	for (i=0; i<MV_MFLASH_MAX_PRG_LOOP; i++)
	{
		if ((ret = mvPMFlashReadSR(&status)) != MV_OK)
			return ret;

		/* check the WIP bit if cleared (indicating end of programming) */
		if ((status & MV_PMFLASH_STAT_WIP_MASK) == 0)
			return MV_OK;
	}

    DB(mvOsPrintf("%s WARNING: Command Timeout!\n", __FUNCTION__);)
	return MV_TIMEOUT;
}

/*******************************************************************************
* mvPMFlashEraseSeq - Perform the erase sequence for the MFLASH
*
* DESCRIPTION:
*       Erase a complete region in the MFlash (Main, Information or the 
*		whole flash).
*
********************************************************************************/
static MV_STATUS mvPMFlashEraseSeq(MV_MFLASH_INFO *pFlash, MV_U32 eraseCmnd)
{
	MV_U32 i;
	MV_U8 status;
	MV_U32 temp;
    MV_STATUS ret;

	/* set commnand opcode = prgCmnd */
	temp = MV_REG_READ(MV_PMFLASH_CMD_OPCODE_REG);
	temp = ((temp & ~MV_PMFLASH_CMD_OPCD_MASK) | eraseCmnd | MV_PMFLASH_EAD9_8_MASK);
	MV_REG_WRITE(MV_PMFLASH_CMD_OPCODE_REG, temp);

	/* Trigger the erase operation - set bit 13 to 1 */
	MV_REG_BIT_SET(MV_PMFLASH_CMD_OPCODE_REG, MV_PMFLASH_ERASE_STRT_MASK);	

	/* wait for the command to be sent to the device */
	if ((ret = waitOnEraseBitClear()) != MV_OK)
		return ret;

	/* wait for the erase command to be completed */
	for (i=0; i<MV_MFLASH_MAX_PRG_LOOP; i++)
	{
		/* read the Status register */
		if ((ret = mvPMFlashReadSR(&status)) != MV_OK)
			return ret;

		/* check the WIP bit if cleared (indicating end of programming) */
		if ((status & MV_PMFLASH_STAT_WIP_MASK) == 0)
			return MV_OK;
	}

    DB(mvOsPrintf("%s WARNING: Command Timeout!\n", __FUNCTION__);)
	return MV_TIMEOUT;
}

/*******************************************************************************
* mvPMFlashIndirectReadSeq - Perform the Information READ sequence
*
* DESCRIPTION:
*       Read indirectly from the FLASH information region
*
********************************************************************************/
static MV_STATUS mvPMFlashIndirectReadSeq(MV_MFLASH_INFO *pFlash, MV_U32 readCmnd, MV_U8* p8Bytes)
{
	MV_U32 i;
	MV_U16 * dataPrt = (MV_U16*)p8Bytes;
	MV_U32 temp;
    MV_STATUS ret;

	/* set commnand opcode = prgCmnd */
	temp = MV_REG_READ(MV_PMFLASH_CMD_OPCODE_REG);
	temp = ((temp & ~MV_PMFLASH_CMD_OPCD_MASK) | readCmnd | MV_PMFLASH_EAD9_8_MASK);
	MV_REG_WRITE(MV_PMFLASH_CMD_OPCODE_REG, temp);

	/* Trigger the erase operation - set bit 13 to 1 */
	MV_REG_BIT_SET(MV_PMFLASH_CMD_OPCODE_REG, MV_PMFLASH_INF_READ_STRT_MASK);
	
	/* block waiting for bit to be cleared by hardware */
	if ((ret = waitOnInfReadBitClear()) != MV_OK)
		return ret;

	/* read the 8bytes from the Data register into the buffer in 4 iterations */
	for (i=0; i<4; i++)
	{
		*dataPrt = MV_REG_READ(MV_PMFLASH_DATA_REG);
		dataPrt++;
	}

	return MV_OK;
}

/*
#####################################################################################
#####################################################################################
*/

/*******************************************************************************
* mvPMFlashInit - Perform basic initialize for the MFlash device in paralle mode
*
* DESCRIPTION:
*       This function performs the necessary initialization for a Marvell 
*       Sunol flash.
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashInit (MV_MFLASH_INFO *pFlash)
{
    MV_STATUS ret;

    /* Check for null pointer */
    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	/* set the static timing parameters */
	if ((ret = mvPMFlashSetConfig1(pFlash, ((MV_PMFLASH_T2 << 4) | MV_PMFLASH_T1))) != MV_OK)
        return ret;

	if ((ret = mvPMFlashSetConfig3(pFlash, MV_PMFLASH_T7)) != MV_OK)
        return ret;

	if ((ret = mvPMFlashSetSlewRate(pFlash, ((MV_PMFLASH_PCLK_OUT << 4) | 
		                         (MV_PMFLASH_SLEW_2_3 << 2) | 
						          MV_PMFLASH_SLEW_0_1))) != MV_OK)
        return ret;

	return MV_OK;
}

/*******************************************************************************
* mvPMFlash64bWr - Program (no Verify) main flash data
*
* DESCRIPTION:
*       Program an alligned 64byte block in the main flash region of the MFlash
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		offset: offset within the Information region (limited to 1024)
*		pBlock: pointer to the 64 bytes buffer to be programed
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlash64bWr (MV_MFLASH_INFO *pFlash, MV_U32 offset, MV_U8 *pBlock)
{
    /* Check for null pointer */
#ifndef CONFIG_MARVELL
    if(NULL == pBlock)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }
#endif

    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashProgSeq(pFlash, MV_PMFLASH_OPCD_PROGRAM, offset, pBlock);
}

/*******************************************************************************
* mvPMFlash64bWrVerify - Program and Verify Main flash data
*
* DESCRIPTION:
*       Program and Verify a 64byte alligned block in the main region of the 
*       MFlash
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		offset: offset within the main region
*		pBlock: pointer to the 64 bytes buffer to be programed
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlash64bWrVerify (MV_MFLASH_INFO *pFlash, MV_U32 offset, MV_U8 *pBlock)
{
    MV_STATUS ret;
    MV_U8 status;

    /* Check for null pointer */
#ifndef CONFIG_MARVELL
    if(NULL == pBlock)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }
#endif

    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

    /* Perform the program sequence */
	if ((ret = mvPMFlashProgSeq(pFlash, MV_PMFLASH_OPCD_PRG_CMP, offset, pBlock)) != MV_OK)
        return ret;

    /* Read the status register */
	if ((ret = mvPMFlashReadSR(&status)) != MV_OK)
		return ret;

	/* check the result of the compare operartion */
	if (status & MV_PMFLASH_STAT_CMP_MASK)
    {
        DB(mvOsPrintf("%s WARNING: Compare after write Failed!\n", __FUNCTION__);)
		return MV_FAIL;
    }

    return MV_OK;
}

/*******************************************************************************
* mvPMFlash64bInfWr - Program (no Verify) Information data
*
* DESCRIPTION:
*       Program a 64byte alligned block in the information region of the 
*       MFlash - Offset is limited to 1024
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		offset: offset within the Information region (limited to 1024)
*		pBlock: pointer to the 64 bytes buffer to be programed
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlash64bInfWr (MV_MFLASH_INFO *pFlash, MV_U32 offset, MV_U8 *pBlock)
{
    /* Check for null pointer */
    if ((pFlash == NULL) || (pBlock == NULL))
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashProgSeq(pFlash, MV_PMFLASH_OPCD_IPROGRAM, offset, pBlock);
}

/*******************************************************************************
* mvPMFlash64bInfWrVerify - Program and Verify Information data
*
* DESCRIPTION:
*       Program and Verify a 64byte alligned block in the information region 
*       of the MFlash - Offset is limited to 1024
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		offset: offset within the Information region (limited to 1024)
*		pBlock: pointer to the 64 bytes buffer to be programed
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlash64bInfWrVerify (MV_MFLASH_INFO *pFlash, MV_U32 offset, MV_U8 *pBlock)
{
	MV_STATUS ret;
    MV_U8 status;

    /* Check for null pointer */
    if ((pFlash == NULL) || (pBlock == NULL))
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

    /* Perform the program sequence */
	if ((ret = mvPMFlashProgSeq(pFlash, MV_PMFLASH_OPCD_IPRG_CMP, offset, pBlock)) != MV_OK)
        return ret;

    /* Read the status register */
	if ((ret = mvPMFlashReadSR(&status)) != MV_OK)
		return ret;

	/* check the result of the compare operartion */
	if (status & MV_PMFLASH_STAT_CMP_MASK)
    {
        DB(mvOsPrintf("%s WARNING: Compare after write Failed!\n", __FUNCTION__);)
		return MV_FAIL;
    }

    return MV_OK;
}

/*******************************************************************************
* mvPMFlashChipErase - Erase the whole flash
*
* DESCRIPTION:
*       Erase the whole flash (both the Main and Information region).
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashChipErase (MV_MFLASH_INFO *pFlash)
{
    /* Check for null pointer */
    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashEraseSeq(pFlash, MV_PMFLASH_OPCD_CHIP_ERASE);
}

/*******************************************************************************
* mvPMFlashMainErase - Erase the main flash region only
*
* DESCRIPTION:
*       Erase the Main flash region only. The information region will not be
*       affected.
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashMainErase (MV_MFLASH_INFO *pFlash)
{
    /* Check for null pointer */
    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashEraseSeq(pFlash, MV_PMFLASH_OPCD_MAIN_ERASE);
}

/*******************************************************************************
* mvPMFlashInfErase - Erase the information flash region only
*
* DESCRIPTION:
*       Erase the information flash region. The main flash region will not be
*       affected.
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashInfErase (MV_MFLASH_INFO *pFlash)
{
    /* Check for null pointer */
    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashEraseSeq(pFlash, MV_PMFLASH_OPCD_IPAGE_ERASE);
}


/*******************************************************************************
* mvPMFlashSecErase - Erase the single sector of the main flash region 
*
* DESCRIPTION:
*       Erase one sector of the main flash region
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		secNumber: sector number to erase
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashSecErase (MV_MFLASH_INFO *pFlash, MV_U32 secNumber)
{
    /* Check for null pointer */
    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	/* set the sector address in the flash address low */
	MV_REG_WRITE(MV_PMFLASH_ADDR_LOW_REG, (secNumber & 0xFFFF));

	/* Perform the erase sequence*/
	return mvPMFlashEraseSeq(pFlash, MV_PMFLASH_OPCD_PAGE_ERASE);
}


/*******************************************************************************
* mvPMFlashBlockRd - Read a block of Memory from the Main Flash 
*
* DESCRIPTION:
*       Read a block of Memory from the Main Flash 
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		offset: offset to read from the main region of the MFlash
*		blockSize: number of bytes to read from the offset
*
* OUTPUT:
*		pBlock: pointer of the buffer to fill
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashBlockRd (MV_MFLASH_INFO *pFlash, MV_U32 offset, MV_U32 blockSize, 
                            MV_U8 *pBlock)
{
    /* Check for null pointer */
    if ((pFlash == NULL) || (pBlock == NULL))
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	/* check that requested data is in the region */
    if ((offset + blockSize) > (pFlash->sectorNumber * pFlash->sectorSize))
    {
        DB(mvOsPrintf("%s WARNING: Read allignment problem!\n", __FUNCTION__);)
        return MV_BAD_PARAM;
    }
	
    /* Read using direct access */
	mvOsMemcpy(pBlock, (MV_VOID*)(pFlash->baseAddr + offset), blockSize);

	return MV_OK;
}

/*******************************************************************************
* mvPMFlashBlockInfRd - Read a block of Memory from the Information region 
*
* DESCRIPTION:
*       Read a block of Memory from the information region
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		offset: offset to read from the main region of the MFlash
*		blockSize: number of bytes to read from the offset
*
* OUTPUT:
*		pBlock: pointer of the buffer to fill
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashBlockInfRd (MV_MFLASH_INFO *pFlash, MV_U32 offset, MV_U32 blockSize, 
                               MV_U8 *pBlock)
{
    MV_STATUS ret;
	MV_U8 tempBuff[MV_PMFLASH_IREAD_CHUNK_SIZE];
	MV_U32 data2read	= blockSize;
	MV_U32 preAllOfst	= (offset & MV_PMFLASH_IREAD_ALIGN_MASK);
    MV_U32 preAllSz		= (preAllOfst ? (MV_PMFLASH_IREAD_CHUNK_SIZE - preAllOfst) : 0);	
	MV_U32 readOffset	= (offset & ~MV_PMFLASH_IREAD_ALIGN_MASK);

    /* Check for null pointer */
    if ((pFlash == NULL) || (pBlock == NULL))
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	/* sanity check on sizes and offsets based on chip model */
    if ((offset + blockSize) > pFlash->infoSize)
    {
        DB(mvOsPrintf("%s WARNING: Read exceeds flash size!\n", __FUNCTION__);)
        return MV_BAD_PARAM;
    }

	/* set the ADDDRESS HI to zero - since only the low address is needed */
	MV_REG_WRITE(MV_PMFLASH_ADDR_HI_REG, 0); /* only low address is needed */

	/* check if the total block size is less than the first chunk remainder */
	if (data2read < preAllSz)
		preAllSz = data2read;

	/* Check if read offset is not alligned to 8bytes; then perform a read alligned 
	   to 8 bytes and copy only the necessary data */
	if (preAllOfst)
	{
		/* set the read offset address in the flash address Low */
		MV_REG_WRITE(MV_PMFLASH_ADDR_LOW_REG, readOffset);
		if ((ret = mvPMFlashIndirectReadSeq(pFlash, MV_PMFLASH_OPCD_IREAD, tempBuff)) != MV_OK)
			return ret;

		/* copy to the buffer only the needed data */
		mvOsMemcpy (pBlock, &tempBuff[preAllOfst], preAllSz);

		/* increment the pointers and offsets */
		data2read -= preAllSz;
		readOffset += MV_PMFLASH_IREAD_CHUNK_SIZE;
		pBlock += preAllSz;
	}

	/* perform all reads that are alligned to 8bytes and full 8bytes */
	while (data2read >= MV_PMFLASH_IREAD_CHUNK_SIZE)
	{
		/* set the read offset address in the flash address Low */
		MV_REG_WRITE(MV_PMFLASH_ADDR_LOW_REG, readOffset);
		if ((ret = mvPMFlashIndirectReadSeq(pFlash, MV_PMFLASH_OPCD_IREAD, pBlock)) != MV_OK)
			return ret;

		/* increment the pointers and offsets */
		data2read -= MV_PMFLASH_IREAD_CHUNK_SIZE;
		readOffset += MV_PMFLASH_IREAD_CHUNK_SIZE;
		pBlock += MV_PMFLASH_IREAD_CHUNK_SIZE;
	}
	
	/* check if we need to perform a partial read at the end */
	if (data2read)
	{
		/* set the read offset address in the flash address Low */
		MV_REG_WRITE(MV_PMFLASH_ADDR_LOW_REG, readOffset);
		if ((ret = mvPMFlashIndirectReadSeq(pFlash, MV_PMFLASH_OPCD_IREAD, tempBuff)) != MV_OK)
			return ret;
		
		/* copy to the buffer only the needed data */
		mvOsMemcpy (pBlock, tempBuff, data2read);
	}

	return MV_OK;
}

/*******************************************************************************
* mvPMFlashReadConfig1 - Read the Configuration register
*
* DESCRIPTION:
*       Perform the Read CONFIG1 register RAB
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		pConfigReg: pointer to the variable to fill
*
* OUTPUT:
*       pConfigReg: pointer to the variable holding the register value
*
* RETURN:
*       Success or Error code.
*       
********************************************************************************/
MV_STATUS mvPMFlashReadConfig1(MV_MFLASH_INFO *pFlash, MV_U8 * pConfigReg)
{	
    if ((pFlash == NULL) || (pConfigReg == NULL))
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashReadRegSeq(MV_PMFLASH_OPCD_READ_CFG1, pConfigReg);
}

/*******************************************************************************
* mvPMFlashReadConfig2 - Read the Configuration register
*
* DESCRIPTION:
*       Perform the Read CONFIG2 register RAB
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		pConfigReg: pointer to the variable to fill
*
* OUTPUT:
*       pConfigReg: pointer to the variable holding the register value
*
* RETURN:
*       Success or Error code.
*       
********************************************************************************/
MV_STATUS mvPMFlashReadConfig2(MV_MFLASH_INFO *pFlash, MV_U8 * pConfigReg)
{	
	if ((pFlash == NULL) || (pConfigReg == NULL))
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashReadRegSeq(MV_PMFLASH_OPCD_READ_CFG2, pConfigReg);
}

/*******************************************************************************
* mvPMFlashReadConfig3 - Read the Configuration register
*
* DESCRIPTION:
*       Perform the Read CONFIG3 register RAB
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		pConfigReg: pointer to the variable to fill
*
* OUTPUT:
*       pConfigReg: pointer to the variable holding the register value
*
* RETURN:
*       Success or Error code.
*       
********************************************************************************/
MV_STATUS mvPMFlashReadConfig3(MV_MFLASH_INFO *pFlash, MV_U8 * pConfigReg)
{	
	if ((pFlash == NULL) || (pConfigReg == NULL))
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashReadRegSeq(MV_PMFLASH_OPCD_READ_CFG3, pConfigReg);
}

/*******************************************************************************
* mvPMFlashReadConfig4 - Read the Configuration register
*
* DESCRIPTION:
*       Perform the Read CONFIG4 register RAB
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		pConfigReg: pointer to the variable to fill
*
* OUTPUT:
*       pConfigReg: pointer to the variable holding the register value
*
* RETURN:
*       Success or Error code.
*       
********************************************************************************/
MV_STATUS mvPMFlashReadConfig4(MV_MFLASH_INFO *pFlash, MV_U8 * pConfigReg)
{	
	if ((pFlash == NULL) || (pConfigReg == NULL))
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashReadRegSeq(MV_PMFLASH_OPCD_READ_CFG4, pConfigReg);
}

/*******************************************************************************
* mvPMFlashSetConfig1 - Write the Configuration register
*
* DESCRIPTION:
*       Perform the SET CONFIG1 register RAB
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		configReg: value to set in the configuration register
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
********************************************************************************/
MV_STATUS mvPMFlashSetConfig1(MV_MFLASH_INFO *pFlash, MV_U8 configReg)
{	
	if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashWriteRegSeq(MV_PMFLASH_OPCD_SET_CFG1, configReg);
}

/*******************************************************************************
* mvPMFlashSetConfig2 - Write the Configuration register
*
* DESCRIPTION:
*       Perform the SET CONFIG2 register RAB
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		configReg: value to set in the configuration register
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
********************************************************************************/
MV_STATUS mvPMFlashSetConfig2(MV_MFLASH_INFO *pFlash, MV_U8 configReg)
{	
	if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashWriteRegSeq(MV_PMFLASH_OPCD_SET_CFG2, configReg);
}

/*******************************************************************************
* mvPMFlashSetConfig3 - Write the Configuration register
*
* DESCRIPTION:
*       Perform the SET CONFIG3 register RAB
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		configReg: value to set in the configuration register
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
********************************************************************************/
MV_STATUS mvPMFlashSetConfig3(MV_MFLASH_INFO *pFlash, MV_U8 configReg)
{	
	if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashWriteRegSeq(MV_PMFLASH_OPCD_SET_CFG3, configReg);
}

/*******************************************************************************
* mvPMFlashSetConfig4 - Write the Configuration register
*
* DESCRIPTION:
*       Perform the SET CONFIG4 register RAB
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		configReg: value to set in the configuration register
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
********************************************************************************/
MV_STATUS mvPMFlashSetConfig4(MV_MFLASH_INFO *pFlash, MV_U8 configReg)
{	
	if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashWriteRegSeq(MV_PMFLASH_OPCD_SET_CFG4, configReg);
}
/*******************************************************************************
* mvPMFlashSetConfig4 - Write the Configuration register
*
* DESCRIPTION:
*       Perform the SET CONFIG4 register RAB
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		configReg: value to set in the configuration register
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
********************************************************************************/
MV_STATUS mvPMFlashSetSlewRate (MV_MFLASH_INFO *pFlash, MV_U8 configReg)
{
	if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashWriteRegSeq(MV_PMFLASH_OPCD_SET_SLEW, configReg);
}

/*******************************************************************************
* mvPMFlashWriteProtectSet - Set the write protection feature status
*
* DESCRIPTION:
*       Enable or disable the write protection
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		wp: write protection status (enable = MV_TRUE, disable = MVFALSE)
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashWriteProtectSet (MV_MFLASH_INFO *pFlash, MV_BOOL wp)
{
    MV_STATUS ret;
	MV_U8 tempReg;

    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;	
    }

	/* Read the original value */
	if ((ret = mvPMFlashReadConfig4(pFlash, &tempReg)) != MV_OK)
    {
        DB(mvOsPrintf("%s WARNING: Failed to read Config register!\n", __FUNCTION__);)
		return ret;
    }

	/* set the WP bit */
	if (wp) /* write protect active hi */
		tempReg |= MV_PMFLASH_CFG4_WP_MASK;
	else
		tempReg &= ~MV_PMFLASH_CFG4_WP_MASK;

	/* write the new register value */
	if ((ret = mvPMFlashSetConfig4(pFlash, tempReg)) != MV_OK)
		return ret;

	return MV_OK;
}

/*******************************************************************************
* mvPMFlashWriteProtectGet - Get the write protection feature status
*
* DESCRIPTION:
*       Read from the h/w the write protection status
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		pWp: pointer to the variable to read in the write protection status
*
* OUTPUT:
*		pWp: pointer to the variable holding the write protection status
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashWriteProtectGet(MV_MFLASH_INFO *pFlash, MV_BOOL * pWp)
{
    MV_STATUS ret;
	MV_U8 tempReg;

    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;	
    }

	/* Read the original value */
	if ((ret = mvPMFlashReadConfig4(pFlash, &tempReg)) != MV_OK)
    {
        DB(mvOsPrintf("%s WARNING: Failed to read Config register!\n", __FUNCTION__);)
		return ret;
    }

	/* Read the WP bit */
	if (tempReg &= ~MV_PMFLASH_CFG4_WP_MASK)
        *pWp = MV_TRUE;
    else
        *pWp = MV_FALSE;

	return MV_OK;
}

/*******************************************************************************
* mvPMFlashSectorSizeSet - Set the sector size (4K or 32K)
*
* DESCRIPTION:
*       Set the sector size of the MFLASH main region
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		secSize: size of sector in bytes (either 4K or 32K)
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashSectorSizeSet (MV_MFLASH_INFO *pFlash, MV_U32 secSize)
{
    MV_STATUS ret;
	MV_U8 tempReg;

    if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;	
    }

	/* Read the original value */
	if ((ret = mvPMFlashReadConfig4(pFlash, &tempReg)) != MV_OK)
		return ret;

	/* set the sector size bit */
	switch (secSize)
	{
		case MV_MFLASH_SECTOR_SIZE_SMALL:
			tempReg |= MV_PMFLASH_CFG4_PG_SZ_MASK;		/* 1 - 4K */
			break;

		case MV_MFLASH_SECTOR_SIZE_BIG:
			tempReg &= ~MV_PMFLASH_CFG4_PG_SZ_MASK;		/* 0 - 32K */
			break;

		default:
            DB(mvOsPrintf("%s WARNING: Invalid parameter sector size!\n", __FUNCTION__);)
			return MV_BAD_PARAM;
	}

	/* write the new register value */
	if ((ret = mvPMFlashSetConfig4(pFlash, tempReg)) != MV_OK)
		return ret;

	return MV_OK;
}


/*******************************************************************************
* mvPMFlashPrefetchSet - Set the Prefetch mode enable/disable
*
* DESCRIPTION:
*       Enable (MV_TRUE) or Disable (MV_FALSE) the prefetch mode
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*		prefetch: enable/disable (true/false)
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashPrefetchSet (MV_MFLASH_INFO *pFlash, MV_BOOL prefetch)
{
    MV_STATUS ret;
	MV_U8 tempReg;

	if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	/* Read the original value */
	if ((ret = mvPMFlashReadConfig2(pFlash, &tempReg)) != MV_OK)
		return ret;

	/* set the prefetch enable bit */
	if (prefetch) 
		tempReg |= MV_PMFLASH_CFG2_PRFTCH_MASK;		/* prefetch mode active HI */
	else
		tempReg &= ~MV_PMFLASH_CFG2_PRFTCH_MASK;

	/* write the new register value */
	if ((ret = mvPMFlashSetConfig2(pFlash, tempReg)) != MV_OK)
		return ret;

	return MV_OK;
}

/*******************************************************************************
* mvPMFlashShutdownSet - Shutdown the voltage regulator in the flash device
*
* DESCRIPTION:
*       Causes the device to enter in a power save mode untill the next access 
*		to the flash.
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*
* OUTPUT:
*       None.
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashShutdownSet(MV_MFLASH_INFO *pFlash)
{
	if (pFlash == NULL)
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	return mvPMFlashEraseSeq(pFlash, MV_PMFLASH_OPCD_SHUTDOWN);	
}

/*******************************************************************************
* mvPMFlashIdGet - Retreive the MFlash manufacturer and device IDs
*
* DESCRIPTION:
*       Read from the Mflash the 32bit manufacturer ID and the 16bit devide Id.
*
* INPUT:
*       pFlash: Structure with Marvell Flash information
*       pManfCode: pointer to the 32bit to fill the manufacturer Id
*       pDevCode: pointer to the 16bit to fill the device Id
*
* OUTPUT:
*       pManfCode: pointer to the 32bit holding the manufacturer Id
*       pDevCode: pointer to the 16bit holding the device Id
*
* RETURN:
*       Success or Error code.
*       
*
*******************************************************************************/
MV_STATUS mvPMFlashIdGet (MV_MFLASH_INFO *pFlash, MV_U32 * pManfCode, MV_U16 * pDevCode)
{
	MV_U32 temp;	
    MV_STATUS ret;

	if ((pFlash == NULL) || (pManfCode == NULL) || (pDevCode == NULL))
    {
        mvOsPrintf("%s ERROR: Null pointer parameter!\n", __FUNCTION__);
        return MV_BAD_PARAM;
    }

	/* first confiure the Inf Read Data length = 3 (i.e 3*16bit = 6bytes)
	  This is because we need to read 6 bytes (4bytes Manuf. ID and 2 bytes Dev ID) */
	MV_REG_WRITE(MV_PMFLASH_IF_CTRL_REG, MV_PMFLASH_READ_ID_16BIT_COUNT);

	/* set commnand opcode = prgCmnd */
	temp = MV_REG_READ(MV_PMFLASH_CMD_OPCODE_REG);
	temp = ((temp & ~MV_PMFLASH_CMD_OPCD_MASK) | MV_PMFLASH_OPCD_READ_ID | MV_PMFLASH_EAD9_8_MASK);
	MV_REG_WRITE(MV_PMFLASH_CMD_OPCODE_REG, temp);

	/* Trigger the erase operation - set bit 13 to 1 */
	MV_REG_BIT_SET(MV_PMFLASH_CMD_OPCODE_REG, MV_PMFLASH_INF_READ_STRT_MASK);
	
	/* block waiting for bit to be cleared by hardware */
	if ((ret = waitOnInfReadBitClear()) != MV_OK)
		return ret;

	/* read the 6bytes from the Data register into the buffer in 3 iterations */
	/* First re-organize the Manufacturer ID */
	*pManfCode = 0;
	temp = MV_REG_READ(MV_PMFLASH_DATA_REG);		/* First 16bit */
	*pManfCode |= ((temp << 24) & 0xFF000000);
	*pManfCode |= ((temp << 8)  & 0x00FF0000);
	temp = MV_REG_READ(MV_PMFLASH_DATA_REG);		/* Second 16bit */
	*pManfCode |= ((temp << 8) & 0x0000FF00);
	*pManfCode |= ((temp >> 8) & 0x000000FF);

	/* Then re-organize the Device ID */
	*pDevCode = 0;
	temp = MV_REG_READ(MV_PMFLASH_DATA_REG);		/* Third 16bit */
	*pDevCode |= ((temp << 8) & 0x0000FF00);
	*pDevCode |= ((temp >> 8) & 0x000000FF);

	/* Set the word count back to the defualt for IREAD commands = 4*16bit */
	MV_REG_WRITE(MV_PMFLASH_IF_CTRL_REG, MV_PMFLASH_IREAD_16BIT_COUNT);

	return MV_OK;
}