/*
 * @brief LPC13xx Flash/EEPROM programming driver
 *
 * @note
 * Copyright(C) NXP Semiconductors, 2012
 * All rights reserved.
 *
 * @par
 * Software that is described herein is for illustrative purposes only
 * which provides customers with programming information regarding the
 * LPC products.  This software is supplied "AS IS" without any warranties of
 * any kind, and NXP Semiconductors and its licensor disclaim any and
 * all warranties, express or implied, including all implied warranties of
 * merchantability, fitness for a particular purpose and non-infringement of
 * intellectual property rights.  NXP Semiconductors assumes no responsibility
 * or liability for the use of the software, conveys no license or rights under any
 * patent, copyright, mask work right, or any other intellectual property rights in
 * or to any products. NXP Semiconductors reserves the right to make changes
 * in the software without notification. NXP Semiconductors also makes no
 * representation or warranty that such application will be suitable for the
 * specified use without further testing or modification.
 *
 * @par
 * Permission to use, copy, modify, and distribute this software and its
 * documentation is hereby granted, under NXP Semiconductors' and its
 * licensor's relevant copyrights in the software, without fee, provided that it
 * is used in conjunction with NXP Semiconductors microcontrollers.  This
 * copyright, permission, and disclaimer notice must appear in all copies of
 * this code.
 */

#ifndef __FLASH_EEPROM_13XX_H_
#define __FLASH_EEPROM_13XX_H_

#ifdef __cplusplus
extern "C" {
#endif

/** @defgroup FLASH_EEPROM_13XX CHIP: LPC13xx FLASH/EEPROM Programming driver
 * @ingroup CHIP_13XX_Drivers
 * @{
 */

#if defined(CHIP_LPC1347)
#define ERASE_PAGE_SUPPORT
#define EEPROM_RW_SUPPORT
#endif

/** Flash Programming Entry Location */
#define FLASH_ENTRY_LOCATION    (0x1fff1ff1)

/** The maximum number of flash programing parameters */
#define FLASH_PARAMETER_NUM     (5)

/** The maximum number of flash programing results */
#define FLASH_RESULT_NUM        (4)

/** Flash programming function type */
typedef void (*FLASH_ENTRY_T)(unsigned int[], unsigned int[]);

/**
 * @brief Flash command code definitions
 */
typedef enum {
	FLASH_PREPARE = 50,				/*!< Prepare sector(s) for write operation */
	FLASH_COPY_RAM_TO_FLASH = 51,	/*!< Copy RAM to Flash */
	FLASH_ERASE = 52,				/*!< Erase sector(s) */
	FLASH_BLANK_CHECK = 53,			/*!< Blank check sector(s) */
	FLASH_READ_PART_ID = 54,		/*!< Read chip part ID */
	FLASH_READ_BOOT_VER = 55,		/*!< Read chip boot code version */
	FLASH_COMPARE = 56,				/*!< Compare memory areas */
	FLASH_REINVOKE_ISP = 57,		/*!< Reinvoke ISP */
	FLASH_READ_UID = 58,			/*!< Read UID */
#if defined(ERASE_PAGE_SUPPORT)
	FLASH_ERASE_PAGE = 59,			/*!< Erase page */
#endif
#if defined(EEPROM_RW_SUPPORT)
	FLASH_EEPROM_WRITE = 61,		/*!< EEPROM Write */
	FLASH_EEPROM_READ = 62,			/*!< EEPROM Read */
#endif
}  FLASH_CMD_CODE_T;

/**
 * @brief Flash status code definitions
 */
typedef enum {
	CMD_SUCCESS,				/*!< Command is executed successfully. */
	INVALID_COMMAND,			/*!< Invalid command. */
	SRC_ADDR_ERROR,				/*!< Source address is not on a word boundary. */
	DST_ADDR_ERROR,				/*!< Destination address is not on a correct boundary. */
	SRC_ADDR_NOT_MAPPED,		/*!< Source address is not mapped in the memory map. */
	DST_ADDR_NOT_MAPPED,		/*!< Destination address is not mapped in the memory map. */
	COUNT_ERROR,				/*!< Byte count is not multiple of 4 or is not a permitted value. */
	INVALID_SECTOR,				/*!< Sector number is invalid. */
	SECTOR_NOT_BLANK,				/*!< Sector is not blank. */
	SECTOR_NOT_PREPARED_FOR_WRITE_OPERATION,	/*!< Command to prepare sector for write operation was not executed. */
	COMPARE_ERROR,				/*!< Source and destination data is not same. */
	BUSY,						/*!< Flash programming hardware interface is busy. */
} FLASH_STATUS_CODE_T;

#if defined(EEPROM_RW_SUPPORT)
/** EEPROM size */
#define EEPROM_SIZE                 (4 << 10)
#endif

/**
 * @brief Command parameter table structure
 */
typedef struct {
	uint32_t cmd;			/*!< Command code */
	uint32_t pParams[FLASH_PARAMETER_NUM];	/*!< Parameters*/
} FLASH_COMMAND_T;

/**
 * @brief Command result table structure
 */
typedef struct {
	uint32_t status;		/*!< Status code */
	uint32_t pResult[FLASH_RESULT_NUM];		/*!< Results*/
} FLASH_OUTPUT_T;

/* Flash Programming Command Description
   Command                  Parameters              Return Code                                 Result
   ----------------------------------------------------------------------------------------------------------
   FLASH_PREPARE            Start Sector Number     CMD_SUCCESS                                 None
                            End Sector Number       BUSY
                                                    INVALID_SECTOR
   FLASH_COPY_RAM2FLASH     Destination Flash Addr  CMD_SUCCESS                                 None
                            Source RAM Addr         SRC_ADDR_ERROR
                            Number of bytes written SRC_ADDR_NOT_MAPPED
                            CCLK in kHz             DST_ADDR_NOT_MAPPED
                                                    COUNT_ERROR
                                                    SECTOR_NOT_PREPARED_FOR_WRITE_OPERATION
                                                    BUSY
   FLASH_ERASE              Start Sector Number     CMD_SUCCESS                                 None
                            Emd Sector Number       BUSY
                            CCLK in kHz             SECTOR_NOT_PREPARED_FOR_WRITE_OPERATION
                                                    INVALID_SECTOR
   FLASH_BLANK_CHECK        Start Sector Number     CMD_SUCCESS                                 Non Blank Sector Offset(if Status code is SECTOR_NOT_BLANK)
                            End Sector Number       BUSY                                        Content of non blank word location
                                                    SECTOR_NOT_BLANK
                                                    INVALID_SECTOR
   FLASH_READ_PART_ID       None                    CMD_SUCCESS                                 Part ID
   FLASH_READ_BOOT_VER      None                    CMD_SUCCESS                                 <byte1(Major)>.<byte0(Minor)>
   FLASH_COMPARE            Destination Addr        CMD_SUCCESS                                 Offset of the first mismatch
                            Source Address          COMPARE_ERROR
                            Number of bytes compared COUNT_ERROR
                                                    ADDR_ERROR
                                                    ADDR_NOT_MAPPED
   FLASH_REINVOKE_ISP       None                    None                                        None
   FLASH_READ_UID           None                    CMD_SUCCESS                                 The first 32-bit word
                                                                                                The second 32-bit word.
                                                                                                The third 32-bit word.
                                                                                                The fourth 32-bit word
   FLASH_ERASE_PAGE         Start Page Number       CMD_SUCCESS                                 None
                            End Page Number         BUSY
                            CCLK in kHz             SECTOR_NOT_PREPARED_FOR_WRITE_OPERATION
                                                    INVALID_SECTOR
   FLASH_EEPROM_WRITE       EEPROM Addr             CMD_SUCCESS                                 None
                            RAM Addr                SRC_ADDR_NOT_MAPPED
                            Number of bytes written DST_ADDR_NOT_MAPPED
                            CCLK in kHz
   FLASH_EEPROM_READ        EEPROM Addr             CMD_SUCCESS                                 None
                            RAM Addr                SRC_ADDR_NOT_MAPPED
                            Number of bytes read    DST_ADDR_NOT_MAPPED
                            CCLK in kHz
 */

/**
 * @brief [Prepare sectors] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
	uint32_t start;		/*!< Start Sector Number */
	uint32_t end;		/*!<End Sector Number (should be greater than or equal to start sector number).*/
} FLASH_PREPARE_SECTORS_COMMAND_T;

/**
 * @brief [Prepare sectors] command result table structure
 */
typedef struct {
	uint32_t status;			/*!< Status code */
} FLASH_PREPARE_SECTORS_OUTPUT_T;

/**
 * @brief [Copy Ram to Flash] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
	uint32_t dst;		/*!< Destination flash address where data bytes are to be written (256 byte boundary) */
	uint32_t src;		/*!<Source RAM address from which data bytes are to be read (a word boudary).*/
	uint32_t byteNum;	/*!<Number of bytes to be written. Should be 256 | 512 | 1024 | 4096.*/
	uint32_t cclk;		/*!<System Clock Frequency (CCLK) in kHz.*/
} FLASH_COPY_RAM_TO_FLASH_COMMAND_T;

/**
 * @brief [Copy Ram to Flash] command result table structure
 */
typedef struct {
	uint32_t status;			/*!< Status code */
} FLASH_COPY_RAM_TO_FLASH_OUTPUT_T;

/**
 * @brief [Erase Sector(s)] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
	uint32_t start;		/*!< Start Sector Number */
	uint32_t end;		/*!<End Sector Number (should be greater than or equal to start sector number).*/
	uint32_t cclk;		/*!<System Clock Frequency (CCLK) in kHz.*/
} FLASH_ERASE_SECTORS_COMMAND_T;

/**
 * @brief [Erase Sector(s)] command result table structure
 */
typedef struct {
	uint32_t status;			/*!< Status code */
} FLASH_ERASE_SECTORS_OUTPUT_T;

/**
 * @brief [Blank check sector(s)] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
	uint32_t start;		/*!< Start Sector Number */
	uint32_t end;		/*!<End Sector Number (should be greater than or equal to start sector number).*/
} FLASH_BLANK_CHECK_SECTORS_COMMAND_T;

/**
 * @brief [Blank check sector(s)] command result table structure
 */
typedef struct {
	uint32_t status;			/*!< Status code */
	uint32_t firstNonBlankLoc;	/*!< Offset of the first non blank word location if the Status Code is SECTOR_NOT_BLANK.*/
	uint32_t firstNonBlankVal;	/*!<Contents of non blank word location.*/
} FLASH_BLANK_CHECK_SECTORS_OUTPUT_T;

/**
 * @brief [Read Part Identification number] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
} FLASH_READ_PART_ID_COMMAND_T;

/**
 * @brief [Read Part Identification number] command result table structure
 */
typedef struct {
	uint32_t status;	/*!< Status code */
	uint32_t partID;	/*!< Part Identification Number*/
} FLASH_READ_PART_ID_OUTPUT_T;

/**
 * @brief [Read Boot code version number] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
} FLASH_READ_BOOTCODE_VER_COMMAND_T;

/**
 * @brief [Read Boot code version number] command result table structure
 */
typedef struct {
	uint32_t status;	/*!< Status code */
	uint8_t minor;		/*!< Minor*/
	uint8_t major;		/*!< Major*/
} FLASH_READ_BOOTCODE_VER_OUTPUT_T;

/**
 * @brief [Compare memory] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
	uint32_t dst;		/*!<Starting flash or RAM address of data bytes to be compared (a word boundary) */
	uint32_t src;		/*!<Starting flash or RAM address of data bytes to be compared (a word boudary).*/
	uint32_t byteNum;	/*!<Number of bytes to be compared; should be a multiple of 4.*/
} FLASH_COMPARE_MEM_COMMAND_T;

/**
 * @brief [Compare memory] command result table structure
 */
typedef struct {
	uint32_t status;	/*!< Status code */
	uint32_t offset;	/*!< Offset of the first mismatch if the Status Code is COMPARE_ERROR.*/
} FLASH_COMPARE_MEM_OUTPUT_T;

/**
 * @brief [Reinvoke ISP] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
} FLASH_REINVOKE_ISP_COMMAND_T;

/**
 * @brief [Reinvoke ISP] command result table structure
 */
typedef struct {
	uint32_t status;	/*!< Status code */
} FLASH_REINVOKE_ISP_OUTPUT_T;

/**
 * @brief [ReadUID] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
} FLASH_READ_UID_COMMAND_T;

/**
 * @brief [ReadUID] command result table structure
 */
typedef struct {
	uint32_t status;	/*!< Status code */
	uint32_t id[4];		/*!< UID*/
} FLASH_READ_UID_OUTPUT_T;

#if defined(ERASE_PAGE_SUPPORT)
/**
 * @brief [Erase page(s)] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
	uint32_t start;		/*!< Start Page Number */
	uint32_t end;		/*!<End Page Number (should be greater than or equal to start page number).*/
	uint32_t cclk;		/*!<System Clock Frequency (CCLK) in kHz.*/
} FLASH_ERASE_PAGES_COMMAND_T;

/**
 * @brief [Erase page(s)] command result table structure
 */
typedef struct {
	uint32_t status;	/*!< Status code */
} FLASH_ERASE_PAGES_OUTPUT_T;

#endif /* defined(ERASE_PAGE_SUPPORT) */

#if defined(EEPROM_RW_SUPPORT)
/**
 * @brief [Write EEPROM] command parameter table structure
 */
typedef struct {
	uint32_t cmd;			/*!< Command code */
	uint32_t eepromAddr;	/*!< EEPROM address.*/
	uint32_t ramAddr;		/*!< RAM address.*/
	uint32_t byteNum;		/*!<Number of bytes to be written.*/
	uint32_t cclk;			/*!<System Clock Frequency (CCLK) in kHz.*/
} EEPROM_WRITE_COMMAND_T;

/**
 * @brief [Write EEPROM] command result table structure
 */
typedef struct {
	uint32_t status;	/*!< Status code */
} EEPROM_WRITE_OUTPUT_T;

/**
 * @brief [Read EEPROM] command parameter table structure
 */
typedef struct {
	uint32_t cmd;		/*!< Command code */
	uint32_t eepromAddr;	/*!< EEPROM address.*/
	uint32_t ramAddr;		/*!< RAM address.*/
	uint32_t byteNum;		/*!<Number of bytes to be written.*/
	uint32_t cclk;			/*!<System Clock Frequency (CCLK) in kHz.*/
} EEPROM_READ_COMMAND_T;

/**
 * @brief [Read EEPROM] command result table structure
 */
typedef struct {
	uint32_t status;	/*!< Status code */
} EEPROM_READ_OUTPUT_T;

#endif /* defined(EEPROM_RW_SUPPORT) */

/**
 * @brief	Get sector number of the specified address
 * @param	adr		: flash address.
 * @return	sector number
 */
STATIC INLINE uint32_t Chip_FLASH_GetSecNum(uint32_t adr)
{
	return adr >> 12;
}

/**
 * @brief	Execute flash programming command
 * @param	pCommand	: Command information
 * @param	pOutput	: Output information
 * @return	Nothing
 */
STATIC INLINE void Chip_FLASH_Execute(FLASH_COMMAND_T *pCommand, FLASH_OUTPUT_T *pOutput)
{
	((FLASH_ENTRY_T) FLASH_ENTRY_LOCATION)((unsigned int *) pCommand, (unsigned int *) pOutput);
}

/**
 * @brief	Prepare sector(s) for write operation
 * @param	pCommand	: Command information
 * @param	pOutput	: Output information
 * @return	Nothing
 * @note	This command must be executed before executing "Copy RAM to flash" or "Erase Sector(s)" command. <br>
 *			The boot sector can not be prepared by this command.
 */
STATIC INLINE void Chip_FLASH_PrepareSectors(FLASH_PREPARE_SECTORS_COMMAND_T *pCommand,
											 FLASH_PREPARE_SECTORS_OUTPUT_T *pOutput)
{
	Chip_FLASH_Execute((FLASH_COMMAND_T *) pCommand, (FLASH_OUTPUT_T *) pOutput);
}

/**
 * @brief	Copy RAM to flash
 * @param	pCommand	: Command information
 * @param	pOutput	: Output information
 * @return	Nothing
 * @note	The affected sectors should be prepared first by calling "Prepare Sector for Write Operation" command.<br>
 *		The boot sector can not be written by this command.
 */
STATIC INLINE void Chip_FLASH_CopyRamToFlash(FLASH_COPY_RAM_TO_FLASH_COMMAND_T *pCommand,
											 FLASH_COPY_RAM_TO_FLASH_OUTPUT_T *pOutput)
{
	Chip_FLASH_Execute((FLASH_COMMAND_T *) pCommand, (FLASH_OUTPUT_T *) pOutput);
}

/**
 * @brief	Erase Sector(s)
 * @param	pCommand	: Command information
 * @param	pOutput	: Output information
 * @return	Nothing
 * @note	 The boot sector can not be erased by this command.
 */
STATIC INLINE void Chip_FLASH_EraseSectors(FLASH_ERASE_SECTORS_COMMAND_T *pCommand,
										   FLASH_ERASE_SECTORS_OUTPUT_T *pOutput)
{
	Chip_FLASH_Execute((FLASH_COMMAND_T *) pCommand, (FLASH_OUTPUT_T *) pOutput);
}

/**
 * @brief	Blank check sector(s)
 * @param	pCommand	: Command information
 * @param	pOutput	: Output information
 * @return	Nothing
 */
STATIC INLINE void Chip_FLASH_BlankCheckSectors(FLASH_BLANK_CHECK_SECTORS_COMMAND_T *pCommand,
												FLASH_BLANK_CHECK_SECTORS_OUTPUT_T *pOutput)
{
	Chip_FLASH_Execute((FLASH_COMMAND_T *) pCommand, (FLASH_OUTPUT_T *) pOutput);
}

/**
 * @brief	Read Part Identification number
 * @param	pOutput	: Output information
 * @return	Nothing
 */
void Chip_FLASH_ReadPartID(FLASH_READ_PART_ID_OUTPUT_T *pOutput);

/**
 * @brief	Read Boot code version number
 * @param	pOutput	: Output information
 * @return	Nothing
 */
void Chip_FLASH_ReadBootCodeVersion(FLASH_READ_BOOTCODE_VER_OUTPUT_T *pOutput);

/**
 * @brief	Compare memory
 * @param	pCommand	: parameters
 * @param	pOutput	: results
 * @return	Nothing
 * @note	The result may not be correct when the source or destination includes any
 * of the first 512 bytes starting from address zero. The first 512 bytes can be re-mapped to RAM.
 */
STATIC INLINE void Chip_FLASH_CompareMem(FLASH_COMPARE_MEM_COMMAND_T *pCommand,
										 FLASH_COMPARE_MEM_OUTPUT_T *pOutput)
{
	Chip_FLASH_Execute((FLASH_COMMAND_T *) pCommand, (FLASH_OUTPUT_T *) pOutput);
}

/**
 * @brief	Reinvoke ISP
 * @return	Nothing
 */
void Chip_FLASH_ReInvokeISP(void);

/**
 * @brief	Read UID
 * @param	pOutput	: Output information
 * @return	Nothing
 */
void Chip_FLASH_ReadUID(FLASH_READ_UID_OUTPUT_T *pOutput);

#if defined(ERASE_PAGE_SUPPORT)
/**
 * @brief	Erase Page(s)
 * @param	pCommand	: Command information
 * @param	pOutput	: Output information
 * @return	Nothing
 */
STATIC INLINE void Chip_FLASH_ErasePages(FLASH_ERASE_PAGES_COMMAND_T *pCommand,
										 FLASH_ERASE_PAGES_OUTPUT_T *pOutput)
{
	Chip_FLASH_Execute((FLASH_COMMAND_T *) pCommand, (FLASH_OUTPUT_T *) pOutput);
}

#endif /* defined(ERASE_PAGE_SUPPORT) */

#if defined(EEPROM_RW_SUPPORT)
/**
 * @brief	Write EEPROM
 * @param	pCommand	: Command information
 * @param	pOutput	: Output information
 * @return	Nothing
 * @note		The top 64 bytes of the EEPROM memory are reserved and cannot be written to.
 */
STATIC INLINE void Chip_EEPROM_Write(EEPROM_WRITE_COMMAND_T *pCommand,
									 EEPROM_WRITE_OUTPUT_T *pOutput)
{
	Chip_FLASH_Execute((FLASH_COMMAND_T *) pCommand, (FLASH_OUTPUT_T *) pOutput);
}

/**
 * @brief	Read EEPROM
 * @param	pCommand	: Command information
 * @param	pOutput	: Output information
 * @return	Nothing
 */
STATIC INLINE void Chip_EEPROM_Read(EEPROM_READ_COMMAND_T *pCommand,
									EEPROM_READ_OUTPUT_T *pOutput)
{
	Chip_FLASH_Execute((FLASH_COMMAND_T *) pCommand, (FLASH_OUTPUT_T *) pOutput);
}

#endif /*defined(EEPROM_RW_SUPPORT)*/

/**
 * @}
 */

#ifdef __cplusplus
}
#endif

#endif /* __FLASH_EEPROM_13XX_H_ */