227 lines
7.9 KiB
C
227 lines
7.9 KiB
C
/*
|
|
* @brief SPIFI registers and control functions
|
|
*
|
|
* @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 __SPIFI_001_H_
|
|
#define __SPIFI_001_H_
|
|
|
|
#include "sys_config.h"
|
|
#include "cmsis.h"
|
|
#include "spifi_rom_api.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
// FIXME this file needs work and better explanations
|
|
|
|
/** @defgroup IP_SPIFI_001 IP: SPIFI register block and driver
|
|
* @ingroup IP_Drivers
|
|
* @{
|
|
*/
|
|
|
|
extern void cancel_mem_mode(SPIFIobj *obj);
|
|
extern void (*set_mem_mode) (SPIFIobj *obj);
|
|
|
|
/* mid level functions */
|
|
extern int32_t checkAd(SPIFIobj *obj, SPIFIopers *opers);
|
|
extern int32_t setProt(SPIFIobj *obj, SPIFIopers *opers, char *change,
|
|
char *saveProt);
|
|
extern int32_t check_block(SPIFIobj *obj, char *source, SPIFIopers *opers,
|
|
uint32_t check_program);
|
|
extern int32_t send_erase_cmd(SPIFIobj *obj, uint8_t op, uint32_t addr);
|
|
extern uint32_t ck_erase(SPIFIobj *obj, uint32_t *addr, uint32_t length);
|
|
extern int32_t prog_block(SPIFIobj *obj, char *source, SPIFIopers *opers,
|
|
uint32_t *left_in_page);
|
|
extern uint32_t ck_prog(SPIFIobj *obj, char *source, char *dest, uint32_t length);
|
|
|
|
/* low level functions */
|
|
extern void setSize(SPIFIobj *obj, int32_t value);
|
|
extern int32_t setDev(SPIFIobj *obj, uint32_t opts, uint32_t mem_cmd,
|
|
uint32_t prog_cmd);
|
|
extern uint32_t cmd(uc op, uc addrLen, uc intLen, uint16_t len);
|
|
extern uint32_t readAd(SPIFIobj *obj, uint32_t cmd, uint32_t addr);
|
|
extern void send04(SPIFIobj *obj, uc op, uc len, uint32_t value);
|
|
extern void wren_sendAd(SPIFIobj *obj, uint32_t cmd, uint32_t addr, uint32_t value);
|
|
extern int32_t write_stat(SPIFIobj *obj, uc len, uint16_t value);
|
|
extern int32_t wait_busy(SPIFIobj *obj, uc prog_or_erase);
|
|
|
|
/**
|
|
* @brief This call sends the standardized Read JEDEC ID command to the
|
|
* attached serial Flash device. If it responds, it is set up for reading
|
|
* in ARM memory space.
|
|
* @param obj : Pointer to uninitialized SPIFIobj structure
|
|
* @param csHigh : Value that is one less than the minimum number of clock
|
|
* cycles with the CS pin high, that the SPIFI should maintain between
|
|
* commands. Compute this from the SPIFI clock period and the minimum high
|
|
* time of CS from the serial flash data sheet:
|
|
* csHigh = ceiling( min CS high / SPIFI clock period) - 1
|
|
* @param options : contains bits controlling the SPIFI behavior. See @ref IP_SPIFI_OPTIONS
|
|
* @param mhz : should be the serial clock divided by 1000000.
|
|
* @return A return value of zero indicates success. Non-zero error codes indicate various error states.
|
|
*/
|
|
STATIC INLINE int32_t IP_SPIFI_Init(SPIFIobj *obj, uint32_t csHigh, uint32_t options, uint32_t mhz)
|
|
{
|
|
return spifi_init(obj, csHigh, options, mhz);
|
|
}
|
|
|
|
/**
|
|
* @brief This call programs opers.length bytes in the serial flash. An
|
|
* IP_SPIFI_Program call with source equal to opers.dest and opers.options
|
|
* not including S_FORCE_ERASE can be used to protect or unprotect sectors
|
|
* depending on the value of opers.protect.
|
|
* @param obj : Pointer to initialized SPIFIobj structure (from IP_SPIFI_Init)
|
|
* @param source : is the address of the data to be programmed
|
|
* @param opers : specifies programming and erasing options
|
|
* @return A return value of zero indicates success. Non-zero error codes
|
|
* indicate various error states.
|
|
*/
|
|
STATIC INLINE int32_t IP_SPIFI_Program(SPIFIobj *obj, char *source, SPIFIopers *opers)
|
|
{
|
|
return spifi_program(obj, source, opers);
|
|
}
|
|
|
|
/**
|
|
* @brief This call erases opers.length bytes in the serial flash.
|
|
* @param obj : Pointer to initialized SPIFIobj structure (from IP_SPIFI_Init)
|
|
* @param opers : specifies erasing options
|
|
* @return A return value of zero indicates success. Non-zero error codes
|
|
* indicate various error states.
|
|
*/
|
|
STATIC INLINE int32_t IP_SPIFI_Erase(SPIFIobj *obj, SPIFIopers *opers)
|
|
{
|
|
return spifi_erase(obj, opers);
|
|
}
|
|
|
|
/**
|
|
* @brief : This function disables the memory mapping of the external QSPI flash.
|
|
* @param obj : Pointer to initialized SPIFIobj structure (from IP_SPIFI_Init)
|
|
* @return No return value
|
|
*/
|
|
STATIC INLINE void IP_SPIFI_CancelMemMode(SPIFIobj *obj)
|
|
{
|
|
cancel_mem_mode(obj);
|
|
}
|
|
|
|
STATIC INLINE void IP_SPIFI_SetMemMode(SPIFIobj *obj)
|
|
{
|
|
set_mem_mode(obj);
|
|
}
|
|
|
|
/* mid level functions */
|
|
STATIC INLINE int32_t IP_SPIFI_checkAd(SPIFIobj *obj, SPIFIopers *opers)
|
|
{
|
|
return checkAd(obj, opers);
|
|
}
|
|
|
|
STATIC INLINE int32_t IP_SPIFI_setProt(SPIFIobj *obj, SPIFIopers *opers, char *change, char *saveProt)
|
|
{
|
|
return setProt(obj, opers, change, saveProt);
|
|
}
|
|
|
|
STATIC INLINE int32_t IP_SPIFI_CheckBlock(SPIFIobj *obj, char *source, SPIFIopers *opers,
|
|
uint32_t check_program)
|
|
{
|
|
return check_block(obj, source, opers, check_program);
|
|
}
|
|
|
|
STATIC INLINE int32_t IP_SPIFI_SendEraseCmd(SPIFIobj *obj, uint8_t op, uint32_t addr)
|
|
{
|
|
return send_erase_cmd(obj, op, addr);
|
|
}
|
|
|
|
STATIC INLINE uint32_t IP_SPIFI_CkErase(SPIFIobj *obj, uint32_t *addr, uint32_t length)
|
|
{
|
|
return ck_erase(obj, addr, length);
|
|
}
|
|
|
|
STATIC INLINE int32_t IP_SPIFI_ProgBlock(SPIFIobj *obj, char *source, SPIFIopers *opers,
|
|
uint32_t *left_in_page)
|
|
{
|
|
return prog_block(obj, source, opers, left_in_page);
|
|
}
|
|
|
|
STATIC INLINE uint32_t IP_SPIFI_CkProg(SPIFIobj *obj, char *source, char *dest, uint32_t length)
|
|
{
|
|
return ck_prog(obj, source, dest, length);
|
|
}
|
|
|
|
/* low level functions */
|
|
STATIC INLINE void IP_SPIFI_SetSize(SPIFIobj *obj, int32_t value)
|
|
{
|
|
setSize(obj, value);
|
|
}
|
|
|
|
STATIC INLINE int32_t IP_SPIFI_SetDev(SPIFIobj *obj, uint32_t opts, uint32_t mem_cmd,
|
|
uint32_t prog_cmd)
|
|
{
|
|
return setDev(obj, opts, mem_cmd, prog_cmd);
|
|
}
|
|
|
|
STATIC INLINE uint32_t IP_SPIFI_Cmd(uc op, uc addrLen, uc intLen, uint16_t len)
|
|
{
|
|
return cmd(op, addrLen, intLen, len);
|
|
}
|
|
|
|
STATIC INLINE uint32_t IP_SPIFI_ReadAd(SPIFIobj *obj, uint32_t cmd, uint32_t addr)
|
|
{
|
|
return readAd(obj, cmd, addr);
|
|
}
|
|
|
|
STATIC INLINE void IP_SPIFI_Send04(SPIFIobj *obj, uc op, uc len, uint32_t value)
|
|
{
|
|
send04(obj, op, len, value);
|
|
}
|
|
|
|
STATIC INLINE void IP_SPIFI_WrEnSendAd(SPIFIobj *obj, uint32_t cmd, uint32_t addr, uint32_t value)
|
|
{
|
|
wren_sendAd(obj, cmd, addr, value);
|
|
}
|
|
|
|
STATIC INLINE int32_t IP_SPIFI_WriteStat(SPIFIobj *obj, uc len, uint16_t value)
|
|
{
|
|
return write_stat(obj, len, value);
|
|
}
|
|
|
|
STATIC INLINE int32_t IP_SPIFI_WaitBusy(SPIFIobj *obj, uc prog_or_erase)
|
|
{
|
|
return wait_busy(obj, prog_or_erase);
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* __SPIFI_001_H_ */
|