/* **************************************************************************** PROJECT : OCTA driver FILE : $Id: r_octa_api.h 15479 2018-01-11 14:04:31Z florian.zimmermann $ ============================================================================ DESCRIPTION Driver for the OCTA(OctaBus Controller) macro ============================================================================ C O P Y R I G H T ============================================================================ Copyright (c) 2017 by Renesas Electronics (Europe) GmbH. Arcadiastrasse 10 D-40472 Duesseldorf Germany All rights reserved. ============================================================================ DISCLAIMER LICENSEE has read, understood and accepted the terms and conditions defined in the license agreement, especially the usage rights. In any case, it is LICENSEE's responsibility to make sure that any user of the software complies with the terms and conditions of the signed license agreement. **************************************************************************** */ /*************************************************************************** Title: Octa Driver API OCTA (OctaBus Controller) driver API. OCTA driver controls OCTA H/W macro and accesses only register of OCTA H/W macro. An application using OCTA driver should include the following header files. * r_typedefs.h * r_octa_api.h */ /*************************************************************************** Section: Definition of a term */ /*************************************************************************** Topics: Word 1 word is 16bits. Word-address is 16bit address. Word-size is 16bit size. Size=1 means 2Byte. Size=2 means 4Byte. */ #ifndef R_OCTA_API_H #define R_OCTA_API_H #ifdef __cplusplus extern "C" { #endif /*************************************************************************** Section: Global defines */ /*************************************************************************** Group: Constants */ /*************************************************************************** Constants: API Version Description: This constant is the value which shows the version information of the OCTA driver. It refers at the <R_OCTA_VersionStringGet> function. Values: R_OCTA_VERSION_HI - This constant is the high byte of the version information. It is major version information. R_OCTA_VERSION_LO - This constant is the low byte of the version information. It is minor version information. */ #define R_OCTA_VERSION_HI (1) #define R_OCTA_VERSION_LO (1) /*************************************************************************** Constants: Internal definition for Command Option Description: These flags are used to <Command Option>. Values: R_OCTA_CMD_WRITE - Use Write transaction. R_OCTA_CMD_READ - Use Read transaction. R_OCTA_CMD_SIZE_NONE - Size is none. R_OCTA_CMD_SIZE_8 - 8 bitwise access. R_OCTA_CMD_SIZE_16 - 16 bitwise access. R_OCTA_CMD_SIZE_MASK - Mask for size get. */ #define R_OCTA_CMD_WRITE (0x0000uL) #define R_OCTA_CMD_READ (0x8000uL) #define R_OCTA_CMD_SIZE_NONE (0x0000uL) #define R_OCTA_CMD_SIZE_8 (0x0001uL) #define R_OCTA_CMD_SIZE_16 (0x0002uL) #define R_OCTA_CMD_SIZE_MASK (0x0003uL) /*************************************************************************** Constants: Command Option Description: OCTA command option flags. These flags are used to OpeFlags(@ <r_octa_CmdTransaction_t>). Values: R_OCTA_CMD_WRITE_NONE - Use Write transaction. No Write size. Only command issue. R_OCTA_CMD_WRITE8 - Use Write transaction. 8 bitwise access.. R_OCTA_CMD_WRITE16 - Use Write transaction. 16 bitwise access. R_OCTA_CMD_READ8 - Use Read transaction. 8 bitwise access.. R_OCTA_CMD_READ16 - Use Read transaction. 16 bitwise access. R_OCTA_CMD_NONE - If the command is not supported, please set to this flag. */ #define R_OCTA_CMD_WRITE_NONE (R_OCTA_CMD_WRITE | R_OCTA_CMD_SIZE_NONE) #define R_OCTA_CMD_WRITE8 (R_OCTA_CMD_WRITE | R_OCTA_CMD_SIZE_8) #define R_OCTA_CMD_WRITE16 (R_OCTA_CMD_WRITE | R_OCTA_CMD_SIZE_16) #define R_OCTA_CMD_READ8 (R_OCTA_CMD_READ | R_OCTA_CMD_SIZE_8) #define R_OCTA_CMD_READ16 (R_OCTA_CMD_READ | R_OCTA_CMD_SIZE_16) #define R_OCTA_CMD_NONE (0xFFFFuL) /*************************************************************************** Section: Global Types */ /*************************************************************************** Group: Enumerations and Types */ /*************************************************************************** Enum: r_octa_Error_t Description: OCTA driver error code. If an error occurs, these enumerations give information about the reason. Values: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_NG - An error has occurred, but no specific error code is defined for it. R_OCTA_ERR_PARAM_INCORRECT - A parameter is incorrect. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_RANGE_PARAM - A parameter is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_DEVICE - OCTA driver is not applicable to target d1x device. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. R_OCTA_ERR_FATAL_HW - Fatal error has occurred at H/W. R_OCTA_ERR_PROTECTED - A process is aborted because of memory protection. R_OCTA_ERR_TIMEOUT - Status polling is timeout. R_OCTA_ERR_COMMAND - A command is not supported. R_OCTA_ERR_LATENCY - A latency value is invalid. */ typedef enum { R_OCTA_ERR_OK = 0, R_OCTA_ERR_NG, R_OCTA_ERR_PARAM_INCORRECT, R_OCTA_ERR_RANGE_UNIT, R_OCTA_ERR_RANGE_PARAM, R_OCTA_ERR_NOT_ACCEPTABLE, R_OCTA_ERR_DEVICE, R_OCTA_ERR_FATAL_OS, R_OCTA_ERR_FATAL_HW, R_OCTA_ERR_PROTECTED, R_OCTA_ERR_TIMEOUT, R_OCTA_ERR_COMMAND, R_OCTA_ERR_LATENCY } r_octa_Error_t; /*************************************************************************** Enum: r_octa_DeviceType_t Description: This type describes the control device type. Values: R_OCTA_DEVICE_FLASH - Octa Flash. R_OCTA_DEVICE_RAM - Octa RAM. */ typedef enum { R_OCTA_DEVICE_FLASH = 0, R_OCTA_DEVICE_RAM } r_octa_DeviceType_t; /*************************************************************************** Enum: r_octa_OperatingMode_t Description: This type describes the operating mode. Values: R_OCTA_MODE_EX_SPACE - External address space mode. Read/Write access to memory-mapped space is possible for Octa RAM/flash memory. R_OCTA_MODE_MANUAL - Manual mode. In case of Octa flash, Read/Write access to register area and Write access to memory is possible. In case of Octa RAM, Read/Write access to register area is possible. */ typedef enum { R_OCTA_MODE_EX_SPACE = 0, R_OCTA_MODE_MANUAL } r_octa_OperatingMode_t; /*************************************************************************** Enum: r_octa_DataTransferMode_t Description: This type describes the data transfer mode. Values: R_OCTA_MODE_SPI - Single I/O STR (Single Transfer Rate), 1 bit per cycle mode. In case of Octa Flash, Read/Write to memory/register access is possible. In case of Octa RAM, it is not supported. R_OCTA_MODE_OPI - Octa I/O STR (Single Transfer Rate), 8 bit per cycle mode. In case of Octa Flash, Read/Write to memory/register access is possible. In case of Octa RAM, it is not supported. R_OCTA_MODE_DOPI - Octa I/O DTR (Double Transfer Rate), 16 bit per cycle mode. In case of Octa Flash, Read/Write to memory/register access is possible. In case of Octa RAM, Read/Write to memory/register access is possible. */ typedef enum { R_OCTA_MODE_SPI = 0, R_OCTA_MODE_OPI, R_OCTA_MODE_DOPI } r_octa_DataTransferMode_t; /*************************************************************************** Enum: r_octa_AddressMode_t Description: This type describes the format of address output to the Octa flash memory. In case of Octa RAM, please set to R_OCTA_ADDRESS_32BIT. Values: R_OCTA_ADDRESS_24BIT - 24 bit address output. R_OCTA_ADDRESS_32BIT - 32 bit address output. */ typedef enum { R_OCTA_ADDRESS_24BIT = 0, R_OCTA_ADDRESS_32BIT } r_octa_AddressMode_t; /*************************************************************************** Enum: r_octa_ProtectionMode_t Description: This type describes the protection mode of the Octa flash memory. Values: R_OCTA_MODE_PROTECT - Set to the protection mode. R_OCTA_MODE_UNPROTECT - Set to the un-protection mode. */ typedef enum { R_OCTA_MODE_PROTECT = 0, R_OCTA_MODE_UNPROTECT } r_octa_ProtectionMode_t; /*************************************************************************** Enum: r_octa_Reg_t Description: This type describes the register of the Octa RAM/flash memory. Values: R_OCTA_STATUS_REG - Status Register. R_OCTA_CONFIG_REG - Configuration Register. R_OCTA_CONFIG2_REG - Configuration2 Register. R_OCTA_NONE_REG - Un used. */ typedef enum { R_OCTA_STATUS_REG = 0, R_OCTA_CONFIG_REG, R_OCTA_CONFIG2_REG, R_OCTA_NONE_REG } r_octa_Reg_t; /*************************************************************************** Enum: r_octa_PreCycle_t Description: This type describes the pre-cycle mode of the Octa RAM/flash memory. This type is used when the data transfer mode is R_OCTA_MODE_DOPI. Values: R_OCTA_PRECYCLE_OFF - pre-cycle mode off. R_OCTA_PRECYCLE_ON - pre-cycle mode on. */ typedef enum { R_OCTA_PRECYCLE_OFF = 0, R_OCTA_PRECYCLE_ON, } r_octa_PreCycle_t; /*************************************************************************** Enum: r_octa_LowPeriod_t Description: This type describes the setting of the period for issuing command when the device chip select pull down. (from the last SCLK low to CS high) Its unit is MCLK cycle. In case of DOPI mode, Actual Cycle is set value - 0.5 clk. If Low=3 is set, actual delay is 2.5 clock (for DOPI mode). (e.g. It is described as tSLCH in data sheet of MX25LW51245G.) Values: R_OCTA_LOWPERIOD_2 - 2 cycles. R_OCTA_LOWPERIOD_3 - 3 cycles. R_OCTA_LOWPERIOD_4 - 4 cycles. R_OCTA_LOWPERIOD_5 - 5 cycles. */ typedef enum { R_OCTA_LOWPERIOD_2 = 0, R_OCTA_LOWPERIOD_3, R_OCTA_LOWPERIOD_4, R_OCTA_LOWPERIOD_5 } r_octa_LowPeriod_t; /*************************************************************************** Enum: r_octa_HighPeriod_t Description: This type describes the setting of the period for the device chip select pull up after the command is finished. (from the last SCLK low to CS high) Its unit is MCLK cycle. In case of DOPI mode, Actual Cycle is set value - 0.5 clk. If High=3 is set, actual delay is 2.5 clock (for DOPI mode). (e.g. It is described as tCLSH in data sheet of MX25LW51245G.) Values: R_OCTA_HIGHPERIOD_2 - 2 cycles. R_OCTA_HIGHPERIOD_3 - 3 cycles. R_OCTA_HIGHPERIOD_4 - 4 cycles. R_OCTA_HIGHPERIOD_5 - 5 cycles. R_OCTA_HIGHPERIOD_6 - 6 cycles. R_OCTA_HIGHPERIOD_7 - 7 cycles. R_OCTA_HIGHPERIOD_8 - 8 cycles. R_OCTA_HIGHPERIOD_9 - 9 cycles. */ typedef enum { R_OCTA_HIGHPERIOD_2 = 0, R_OCTA_HIGHPERIOD_3, R_OCTA_HIGHPERIOD_4, R_OCTA_HIGHPERIOD_5, R_OCTA_HIGHPERIOD_6, R_OCTA_HIGHPERIOD_7, R_OCTA_HIGHPERIOD_8, R_OCTA_HIGHPERIOD_9 } r_octa_HighPeriod_t; /*************************************************************************** Enum: r_octa_BetweenPeriod_t Description: This type describes the setting of the period between two commands. (from CS high to the next CS low). Its unit is MCLK cycle. (e.g. It is described as tSHSL in data sheet of MX25LW51245G.) Values: R_OCTA_BETWEENPERIOD_2 - 2 cycles. R_OCTA_BETWEENPERIOD_5 - 5 cycles. R_OCTA_BETWEENPERIOD_7 - 7 cycles. R_OCTA_BETWEENPERIOD_9 - 9 cycles. R_OCTA_BETWEENPERIOD_11 - 11 cycles. R_OCTA_BETWEENPERIOD_13 - 13 cycles. R_OCTA_BETWEENPERIOD_15 - 15 cycles. R_OCTA_BETWEENPERIOD_17 - 17 cycles. */ typedef enum { R_OCTA_BETWEENPERIOD_2 = 0, R_OCTA_BETWEENPERIOD_5, R_OCTA_BETWEENPERIOD_7, R_OCTA_BETWEENPERIOD_9, R_OCTA_BETWEENPERIOD_11, R_OCTA_BETWEENPERIOD_13, R_OCTA_BETWEENPERIOD_15, R_OCTA_BETWEENPERIOD_17 } r_octa_BetweenPeriod_t; /*************************************************************************** Enum: r_octa_StateType_t Description: This type describes the state type of the register. Values: R_OCTA_TYPE_WEL - State of Write enable latch. R_OCTA_TYPE_WIP - State of Write In Progress. R_OCTA_TYPE_BP - State of Block Protect. R_OCTA_TYPE_DTM - State of Data Transfer mode. R_OCTA_TYPE_PCM - State of Pre-cycle mode. R_OCTA_TYPE_DOS - State of DOS. R_OCTA_TYPE_DL - State of Dummy Length. */ typedef enum { R_OCTA_TYPE_WEL = 0, R_OCTA_TYPE_WIP, R_OCTA_TYPE_BP, R_OCTA_TYPE_PCM, R_OCTA_TYPE_DTM, R_OCTA_TYPE_DOS, R_OCTA_TYPE_DL, } r_octa_StateType_t; /*************************************************************************** typedef: r_octa_CmdTransaction_t Description: This type describes the Octa RAM/flash commands. Struct members: Cmd - Command for Octa RAM/flash memory. In case of Octa flash memory, Cmd is set 1st byte for SPI register commands or 1st byte ~ 2nd byte for OPI register commands. In case of Octa RAM, Cmd is set command address. If the command is not supported, please set to 0xFFFF. Address - Address of the command for Octa RAM/flash memory. In case of Octa flash memory, Address is set 3rd byte~6th byte for OPI register commands. In case of Octa RAM, Address is set Row address and Column address. If the address is not defined, please set to 0. CmdLength - Command length of the command. Its unit is byte. If the command is not supported, please set to 0. AddressLength - Address length of the command. Its unit is byte. If the address is not defined, please set to 0. DummyLength - Dummy length of the command. Its unit is clock cycle. The range is 3 to 20. In case of Octa flash memory, Set Dummy Cycle. In case of Octa RAM, Set Latency Counter. If dummy length is not needed, please set to 0. DataLength - Data length of the command. If data length is not needed, please set to 0. OpeFlags - Operation Flags. Multiple flags can be set with '|'. See definition of <Command Option>. */ typedef struct { uint16_t Cmd; uint32_t Address; uint8_t CmdLength; uint8_t AddressLength; uint8_t DummyLength; uint8_t DataLength; uint32_t OpeFlags; } r_octa_CmdTransaction_t; /*************************************************************************** typedef: r_octa_RegInfo_t Description: This type describes register information of the Octa RAM/flash memory. Struct members: Reg - See <r_octa_Reg_t> Address - Address of the command for Octa RAM/flash memory. In case of Octa flash memory, Address is set 2nd byte~5th byte for SPI register commands or Address is set 3rd byte~6th byte for OPI register commands. In case of Octa RAM, Address is set Row address and Column address. If the address is not defined, please set to 0. AddressLength - Address length of the command. Its unit is byte. If the address is not defined, please set to 0. BitPosition - Bit position of status register or configuration register. */ typedef struct { r_octa_Reg_t Reg; uint32_t Address; uint8_t AddressLength; uint16_t BitPosition; } r_octa_RegInfo_t; /*************************************************************************** typedef: r_octa_RegSetParam_t Description: This type describes register information and set parameter of the Octa RAM/flash memory. Struct members: Reg - See <r_octa_Reg_t> Address - Address of the command for Octa RAM/flash memory. In case of Octa flash memory, Address is set 2nd byte~5th byte for SPI register commands or Address is set 3rd byte~6th byte for OPI register commands. In case of Octa RAM, Address is set Row address and Column address. If the address is not defined, please set to 0. AddressLength - Address length of the command. Its unit is byte. If the address is not defined, please set to 0. BitMask - Bit mask of status register or configuration register. BitSet - Set point to a register. */ typedef struct { r_octa_Reg_t Reg; uint32_t Address; uint8_t AddressLength; uint16_t BitMask; uint16_t BitSet; } r_octa_RegSetParam_t; /*************************************************************************** typedef: r_octa_Timing_t Description: This type describes the Chip Select timing. Struct members: Low - Set the period for issuing command when the device chip select pull down. See <r_octa_LowPeriod_t>. High - Set the period for the device chip select pull up after the command is finished. See <r_octa_HighPeriod_t>. Between - Set the period between two commands. See <r_octa_BetweenPeriod_t>. */ typedef struct { r_octa_LowPeriod_t Low; r_octa_HighPeriod_t High; r_octa_BetweenPeriod_t Between; } r_octa_Timing_t; /*************************************************************************** typedef: r_octa_Command_t Description: This type describes the Octa RAM/flash commands. Struct members: BlockProtect - Block Protection information. WriteEnableLatch - Write Enable Latch. WriteInProgress - Write in progress information. PreCycle - Pre-cycle enable information. FlashTransferType - Transfer type information of connected Octa flash memory. DOS - DOS (DQS on STR mode) information. DQS is "Data Strobe Signal". DummyCycle - Dummy cycle setting information. ReadTiming - Read timing setting of connected Octa RAM/flash memory. See <r_octa_Timing_t>. WriteTiming - Write timing setting of connected Octa RAM/flash memory. See <r_octa_Timing_t>. CfgTiming - Configuration timing setting of connected Octa RAM/flash memory. See <r_octa_Timing_t>. ReadSPI3B - Read SPI 3 byte address command. ReadSPI4B - Read SPI 4 byte address command. ReadOPI - Read OPI command. ReadDOPI - Read DTR (Double Transfer Rate) OPI command. WriteSPI3B - Write SPI 3 byte address command. WriteSPI4B - Write SPI 4 byte address command. WriteOPI - Write OPI command. WriteDOPI - Write DTR (Double Transfer Rate) OPI command. WriteBufInitialSPI - Write buffer Initial SPI command. WriteBufInitialOPI - Write buffer Initial OPI command. WriteBufContinueSPI - Write buffer Continue SPI command. WriteBufContinueOPI - Write buffer Continue OSPI command. WriteBufConfirmSPI - Write buffer Confirm SPI command. WriteBufConfirmOPI - Write buffer Confirm OPI command. WriteEnableSPI - Write Enable SPI command. WriteEnableOPI - Write Enable OPI command. EraseSPI3B - Erase SPI 3 byte address command. EraseSPI4B - Erase SPI 4 byte address command. EraseOPI - Erase OPI command. ReadStsSPI - Read Status SPI command. ReadStsOPI - Read Status OPI command. ReadCfgSPI - Read Configuration SPI command. ReadCfgOPI - Read Configuration OPI command. ReadCfg2SPI - Read Configuration2 SPI command. ReadCfg2OPI - Read Configuration2 OPI command. WriteStsCfgSPI - Write Status / Configuration SPI command. WriteStsOPI - Write Status OPI command. WriteCfgOPI - Write Configuration OPI command. WriteCfg2SPI - Write Configuration2 SPI command. WriteCfg2OPI - Write Configuration2 OPI command. ResetEnableSPI - Reset Enable SPI command. ResetEnableOPI - Reset Enable OPI command. ResetSPI - Reset SPI command. ResetOPI - Reset OPI command. ReadIDSPI - Read ID SPI command. ReadIDOPI - Read ID OPI command. */ typedef struct { r_octa_RegInfo_t BlockProtect; r_octa_RegInfo_t WriteEnableLatch; r_octa_RegInfo_t WriteInProgress; r_octa_RegInfo_t PreCycle; r_octa_RegInfo_t FlashTransferType; r_octa_RegInfo_t DOS; r_octa_RegSetParam_t DummyCycle; r_octa_Timing_t ReadTiming; r_octa_Timing_t WriteTiming; r_octa_Timing_t CfgTiming; r_octa_CmdTransaction_t ReadSPI3B; r_octa_CmdTransaction_t ReadSPI4B; r_octa_CmdTransaction_t ReadOPI; r_octa_CmdTransaction_t ReadDOPI; r_octa_CmdTransaction_t WriteSPI3B; r_octa_CmdTransaction_t WriteSPI4B; r_octa_CmdTransaction_t WriteOPI; r_octa_CmdTransaction_t WriteDOPI; r_octa_CmdTransaction_t WriteBufInitialSPI; r_octa_CmdTransaction_t WriteBufInitialOPI; r_octa_CmdTransaction_t WriteBufContinueSPI; r_octa_CmdTransaction_t WriteBufContinueOPI; r_octa_CmdTransaction_t WriteBufConfirmSPI; r_octa_CmdTransaction_t WriteBufConfirmOPI; r_octa_CmdTransaction_t WriteEnableSPI; r_octa_CmdTransaction_t WriteEnableOPI; r_octa_CmdTransaction_t EraseSPI3B; r_octa_CmdTransaction_t EraseSPI4B; r_octa_CmdTransaction_t EraseOPI; r_octa_CmdTransaction_t ReadStsSPI; r_octa_CmdTransaction_t ReadStsOPI; r_octa_CmdTransaction_t ReadCfgSPI; r_octa_CmdTransaction_t ReadCfgOPI; r_octa_CmdTransaction_t ReadCfg2SPI; r_octa_CmdTransaction_t ReadCfg2OPI; r_octa_CmdTransaction_t WriteStsCfgSPI; r_octa_CmdTransaction_t WriteStsOPI; r_octa_CmdTransaction_t WriteCfgOPI; r_octa_CmdTransaction_t WriteCfg2SPI; r_octa_CmdTransaction_t WriteCfg2OPI; r_octa_CmdTransaction_t ResetEnableSPI; r_octa_CmdTransaction_t ResetEnableOPI; r_octa_CmdTransaction_t ResetSPI; r_octa_CmdTransaction_t ResetOPI; r_octa_CmdTransaction_t ReadIDSPI; r_octa_CmdTransaction_t ReadIDOPI; } r_octa_Command_t; /*************************************************************************** typedef: r_octa_DQSDelay_t Description: This type describes the DQS (Data Strobe Signal) delay. Struct members: EnableCnt - DQS enable counter. During read operation with DQS clock input (RAM/OPI/DOPI mode), DQS clock will transition from high-impedance to zero after command/address phase is finished. To prevent using such invalid DQS clock, user can adjust these configuration to guarantee data correctness. The range is 0 to 15. Actual enable DQS clock input is set value + 1 clock. If EnableCnt=0 is set, Enable DQS clock input at 1st SCLK. If EnableCnt=1 is set, Enable DQS clock input at 2nd SCLK. If EnableCnt=2 is set, Enable DQS clock input at 3rd SCLK. If EnableCnt=3 is set, Enable DQS clock input at 4th SCLK. ... If EnableCnt=15 is set, Enable DQS clock input at 16th SCLK. Reference DQS enable counter settings (when SCLK frequency < 120 MHz) > ---------------------------------------------------------------- > DQS RAM Flash OPI Flash DOPI > -------------------------------------------------------- > delay Pre-cycle Pre-cycle Pre-cycle Pre-cycle Pre-cycle > [SCLK] ON OFF ON ON OFF > ---------------------------------------------------------------- > 0-0.5 3 3-4 7-8 5 5-6 > 0.5-1.5 4 5 8 6 6-7 > 1.5-2.5 5 5-6 9 7 7-8 > ---------------------------------------------------------------- Delay - DQS delay value. Delay value = SCLK output pad delay + SCLK wire bonding + DQS wire bonding + DQS input pad delay (Memory device delay has considered in this table, maximum 2 SCLK cycle) */ typedef struct { uint8_t EnableCnt; uint8_t Delay; } r_octa_DQSDelay_t; /*************************************************************************** typedef: r_octa_Config_t Description: This type describes the configuration of the channel. Struct members: DeviceType - Control device type. See <r_octa_DeviceType_t>. OpeMode - Operating mode. See <r_octa_OperatingMode_t>. DataTransferMode - Data transfer mode. See <r_octa_DataTransferMode_t>. AddressMode - Address mode. See <r_octa_AddressMode_t>. MemorySize - Total memory byte-size of connected Octa RAM/flash memory. RH850/D1M1A supports 64 MByte. MemorySize should be multiple of SectorSize if SectorSize is defined. (e.g. This size is 64 MBytes (64*1024*1024), when MX25LW51245G is connected.) SectorSize - Erase Sector byte-size of connected Octa flash memory. Sector size must be power-of-two value (2^n). If not required, please set to 0. (e.g. This size is 4 Kbytes when MX25LW51245G is connected.) PageSize - Page byte-size of connected Octa flash memory. Page byte-size must be power-of-two value (2^n). If not required, please set to 0. (e.g. This size is 256 bytes when MX25LW51245G is connected.) Command - Command setting. See <r_octa_Command_t>. This memory must be kept allocating till <R_OCTA_Close> is finished. RelaxSize - Relax byte-size. Relax size must be multiple of 4-byte. This size is used in case of manual mode. Some APIs call R_OCTA_Sys_Relax in units of this size. If not required, please set to 0. PreCycle - Pre-cycle mode. See <r_octa_PreCycle_t>. This mode is used when the data transfer mode is R_OCTA_MODE_DOPI. DQSDelay - DQS delay. See <r_octa_DQSDelay_t>. CalAddress - Calibration Start address. This specifies the start address for executing the calibration. The calibration is adjusted by actually reading / writing to the connected OCTA RAM / flash memory while changing the DQS delay value. This driver isn't executed the calibration. If you want to be executed the calibration, please calibrate with data read / data write after calling the R_OCTA_Open function by setting calibration start address to CalAddress, DQS delay value to DQSDelay.Delay. CalAddress must be 32 bit address aligned. If not required, please set to 0xFFFFFFFF. */ typedef struct { r_octa_DeviceType_t DeviceType; r_octa_OperatingMode_t OpeMode; r_octa_DataTransferMode_t DataTransferMode; r_octa_AddressMode_t AddressMode; uint32_t MemorySize; uint32_t SectorSize; uint32_t PageSize; r_octa_Command_t* Command; uint32_t RelaxSize; r_octa_PreCycle_t PreCycle; r_octa_DQSDelay_t DQSDelay; uint32_t CalAddress; } r_octa_Config_t; /*************************************************************************** Section: Global API functions */ /*************************************************************************** Function: R_OCTA_Init Description: This function initializes the OCTA driver. This function calls <R_OCTA_Sys_Init> to initialize environment-dependent setting. This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_DEVICE - OCTA driver is not applicable to target device. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. See <r_octa_Error_t>. Executable Status: Uninitialized - OK (Status will be changed to *Initialized*.) Initialized - NG Idle - NG Executing - NG Executable Connected Device: Octa Flash - OK Octa RAM - OK */ r_octa_Error_t R_OCTA_Init(const uint32_t Unit); /*************************************************************************** Function: R_OCTA_DeInit Description: This function de-initializes the OCTA driver. This function is executed after executing R_OCTA_Close on all channels. This function calls <R_OCTA_Sys_DeInit> to de-initialize environment-dependent setting. This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. See <r_octa_Error_t>. Executable Status: Uninitialized - NG Initialized - OK (Status will be changed to *Uninitialized*.) Idle - NG Executing - NG Executable Connected Device: Octa Flash - OK Octa RAM - OK */ r_octa_Error_t R_OCTA_DeInit(const uint32_t Unit); /*************************************************************************** Function: R_OCTA_Open Description: This function opens the OCTA driver. This function opens the OCTA driver with the operating mode and device type that is specified. This function opens for each specified channel device. In case of external address space mode, Read command and Write command are set to H/W and it enables access from memory-map space. For Octa RAM can be read / write directly. For Octa flash memory can be read directly. Read command and Write command to be set are different depending on the data transfer mode. In case of manual mode, the function enables access the status/configuration register for Octa RAM/flash memory. And enables Write access to memory for Octa flash memory. This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Channel - Device Channel number. Config - Pointer to the <r_octa_Config_t> structure. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_PARAM_INCORRECT - A parameter is incorrect. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_RANGE_PARAM - A parameter is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. R_OCTA_ERR_FATAL_HW - Fatal error has occurred at H/W. R_OCTA_ERR_PROTECTED - A process is aborted because of memory protection. R_OCTA_ERR_COMMAND - A command is not supported. R_OCTA_ERR_LATENCY - A latency value is invalid. See <r_octa_Error_t>. Executable Status: Uninitialized - NG Initialized - OK (Status will be changed to *Idle* or *Executing*.) Idle - NG Executing - NG Status will be changed to *Idle* if R_OCTA_MODE_MANUAL is specified. Status will be changed to *Executing* if R_OCTA_MODE_EX_SPACE is specified. Executable Connected Device: Octa Flash - OK Octa RAM - OK */ r_octa_Error_t R_OCTA_Open(const uint32_t Unit, const uint32_t Channel, const r_octa_Config_t * const Config); /*************************************************************************** Function: R_OCTA_Close Description: This function closes the OCTA driver. In case of external address space mode, this function disables access from the memory-map space. This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Channel - Device Channel number. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. R_OCTA_ERR_FATAL_HW - Fatal error has occurred at H/W. See <r_octa_Error_t>. Executable Status: Uninitialized - NG Initialized - NG Idle - OK (Status will be changed to *Initialized*.) Executing - OK (Status will be changed to *Initialized*.) Executable Connected Device: Octa Flash - OK Octa RAM - OK */ r_octa_Error_t R_OCTA_Close(const uint32_t Unit, const uint32_t Channel); /*************************************************************************** Function: R_OCTA_DataProtect Description: This function sets the protection mode of the Octa flash memory. The write and erase access to Octa Flash memory is prohibited if protection is set. This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Channel - Device Channel number. Mode - Protection mode. See <r_octa_ProtectionMode_t>. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_PARAM_INCORRECT - A parameter is incorrect. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_RANGE_PARAM - A parameter is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. R_OCTA_ERR_FATAL_HW - Fatal error has occurred at H/W. See <r_octa_Error_t>. Executable Status: Uninitialized - NG Initialized - NG Idle - OK Executing - NG Executable Connected Device: Octa Flash - OK Octa RAM - NG */ r_octa_Error_t R_OCTA_DataProtect(const uint32_t Unit, const uint32_t Channel, const r_octa_ProtectionMode_t Mode); /*************************************************************************** Function: R_OCTA_DataErase Description: This function erases the data in the Octa flash memory. This function erases the data in a unit of sector. Therefore this function erases data of the sector including the size from the address. This function erases the sectors in following range. Start sector - Sector that Addr is belonged. End sector - Sector that (Addr + Size - 1) is belonged. In the case of Octa flash memory compatible with RWW (Read-While-Write), it can be executed while reading into the memory map space in external address space mode. This function has the possibility that the processing takes time. Therefore, <R_OCTA_Sys_Relax> is sometimes executed. This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Channel - Device Channel number. Addr - Erase start address of the Octa flash memory. Size - Data size to erase. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_PARAM_INCORRECT - A parameter is incorrect. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_RANGE_PARAM - A parameter is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. R_OCTA_ERR_FATAL_HW - Fatal error has occurred at H/W. R_OCTA_ERR_PROTECTED - A process is aborted because of memory protection. R_OCTA_ERR_TIMEOUT - Status polling is timeout. R_OCTA_ERR_COMMAND - A command is not supported. See <r_octa_Error_t>. Executable Status: Uninitialized - NG Initialized - NG Idle - OK Executing - OK Executable Connected Device: Octa Flash - OK Octa RAM - NG */ r_octa_Error_t R_OCTA_DataErase(const uint32_t Unit, const uint32_t Channel, const uint32_t Addr, const uint32_t Size ); /*************************************************************************** Function: R_OCTA_DataWriteRWW Description: This function writes data to the Octa Flash memory by RWW (Read-While-Write) function. RWW function means read data one bank while another bank is programing or erasing. This function can be executed for Octa flash memory with supporting RWW. If Octa flash memory is not supported RWW, does not guarantee the operation. This function is executed WriteBufInitial, WriteBufContinue and WriteBufConfirm command. These commands to be set are different depending on the data transfer mode. In DTR OPI, the starting address given must be even address (A0=0) and data byte number must be even. This function has the possibility that the processing takes time. Therefore, <R_OCTA_Sys_Relax> is sometimes executed. This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Channel - Device Channel number. Addr - The parameter specifies the write address of the Octa flash memory. If the data transfer mode is R_OCTA_MODE_DOPI, Addr given must be even address. Buf - This is a pointer to the buffer stored write data. Size - The parameter specifies the data byte-size to write. If the data transfer mode is R_OCTA_MODE_DOPI, Size given must be even data size. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_PARAM_INCORRECT - A parameter is incorrect. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_RANGE_PARAM - A parameter is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. R_OCTA_ERR_FATAL_HW - Fatal error has occurred at H/W. R_OCTA_ERR_PROTECTED - A process is aborted because of memory protection. R_OCTA_ERR_TIMEOUT - Status polling is timeout. R_OCTA_ERR_COMMAND - A command is not supported. See <r_octa_Error_t>. Executable Status: Uninitialized - NG Initialized - NG Idle - NG Executing - OK Executable Connected Device: Octa Flash - OK Octa RAM - NG */ r_octa_Error_t R_OCTA_DataWriteRWW(const uint32_t Unit, const uint32_t Channel, const uint32_t Addr, const uint8_t* Buf, const uint32_t Size); /*************************************************************************** Function: R_OCTA_DataWrite Description: This function writes data to the Octa Flash memory. In order to write data to Octa Flash, the data of the sector must have been erased previously. This function executes Write command. Write commands to be set are different depending on the data transfer mode. In DTR OPI, the starting address given must be even address (A0=0) and data byte number must be even. This function has the possibility that the processing takes time. Therefore, <R_OCTA_Sys_Relax> is sometimes executed. This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Channel - Device Channel number. Addr - The parameter specifies the write address of the Octa flash memory. This parameter aligns in the page size of the Octa flash memory. If the data transfer mode is R_OCTA_MODE_DOPI, Addr given must be even address. Buf - This is a pointer to the buffer stored write data. Size - The parameter specifies the data byte-size to write. If the data transfer mode is R_OCTA_MODE_DOPI, Size given must be even data size. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_PARAM_INCORRECT - A parameter is incorrect. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_RANGE_PARAM - A parameter is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. R_OCTA_ERR_FATAL_HW - Fatal error has occurred at H/W. R_OCTA_ERR_PROTECTED - A process is aborted because of memory protection. R_OCTA_ERR_TIMEOUT - Status polling is timeout. See <r_octa_Error_t>. Executable Status: Uninitialized - NG Initialized - NG Idle - OK Executing - NG Executable Connected Device: Octa Flash - OK Octa RAM - NG */ r_octa_Error_t R_OCTA_DataWrite(const uint32_t Unit, const uint32_t Channel, const uint32_t Addr, const uint8_t* Buf, const uint32_t Size); /*************************************************************************** Function: R_OCTA_UserCmdIssue Description: This function executes user command sequence. This function executes when user read / write the status/configuration register and read device ID for Octa RAM/flash memory. Read register in OCTA RAM, the byte order is as following. byte1, byte0, byte3, byte2 Read register in OCTA flash memory, the byte order is as following. byte0, byte1, byte2, byte3 This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Channel - Device Channel number. CmdTransaction - Command sequence. See <r_octa_CmdTransaction_t>. Buf - This is a pointer to the Buffer to store the read/write data. If read transaction is not existed in command sequence, please set to R_NULL. BufSize - Byte-size of data that can be stored to Buf. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_PARAM_INCORRECT - A parameter is incorrect. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_RANGE_PARAM - A parameter is out of range. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. R_OCTA_ERR_FATAL_HW - Fatal error has occurred at H/W. R_OCTA_ERR_COMMAND - A command is not supported. See <r_octa_Error_t>. Executable Status: Uninitialized - NG Initialized - NG Idle - OK Executing - NG Executable Connected Device: Octa Flash - OK Octa RAM - OK */ r_octa_Error_t R_OCTA_UserCmdIssue(const uint32_t Unit, const uint32_t Channel, const r_octa_CmdTransaction_t* const CmdTransaction, uint8_t* const Buf, const uint32_t BufSize); /*************************************************************************** Function: R_OCTA_GetCal Description: This function receives the DQS (Data Strobe Signal) delay value. The DQS delay value uses to adjusting the calibration. This function uses to get the DQS delay value after executing the calibration. The calibration is adjusted by actually reading / writing to the connected OCTA RAM / flash memory while changing the DQS delay value. The DQS delay value was received in this function is sets to DQSDelay.Delay @ <r_octa_Config_t> of argument for R_OCTA_Open function. This function calls <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock> internally. If this function is executed from the interrupt handler, please be careful of specification of <R_OCTA_Sys_Lock> and <R_OCTA_Sys_Unlock>. Parameter: Unit - Instance number. Channel - Device Channel number. Delay - Pointer to the DQS delay value. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_RANGE_UNIT - Unit number is out of range. R_OCTA_ERR_RANGE_PARAM - A parameter is out of range. R_OCTA_ERR_PARAM_INCORRECT - A parameter is incorrect. R_OCTA_ERR_NOT_ACCEPTABLE - A function was called in an incorrect state. R_OCTA_ERR_FATAL_OS - Fatal error has occurred at OS interface. See <r_octa_Error_t>. Executable Status: Uninitialized - NG Initialized - OK Idle - OK Executing - OK Executable Connected Device: Octa Flash - OK Octa RAM - OK */ r_octa_Error_t R_OCTA_GetCal(const uint32_t Unit, const uint32_t Channel, uint8_t* const Delay); /*************************************************************************** Function: R_OCTA_VersionStringGet Description: This function returns the version string of this OCTA driver. Parameter: None Return value: Pointer of string. Executable Status: Uninitialized - OK Initialized - OK Idle - OK Executing - OK Executable Connected Device: Octa Flash - OK Octa RAM - OK */ const uint8_t* R_OCTA_VersionStringGet(void); /*************************************************************************** Function: R_OCTA_MacroVersionGet Description: This function returns the major and minor version of the H/W macro. Parameter: Major - Pointer to store the major version. Minor - Pointer to store the minor version. Return value: R_OCTA_ERR_OK - No error has occurred. R_OCTA_ERR_PARAM_INCORRECT - A parameter is incorrect. See <r_octa_Error_t>. Executable Status: Uninitialized - OK Initialized - OK Idle - OK Executing - OK Executable Connected Device: Octa Flash - OK Octa RAM - OK */ r_octa_Error_t R_OCTA_MacroVersionGet(uint32_t * const Major, uint32_t * const Minor); #ifdef __cplusplus } #endif #endif /* R_OCTA_API_H */