DadDrivers::cIS25LP064A

Namespace: DadDrivers::cIS25LP064A
Files: IS25LP064A.h / IS25LP064A.cpp
Directory: DAD_FORGE/Drivers/
Inheritance: iQSPI_FlashMemory
Description: Implementation of the ISSI IS25LP064A QSPI Flash memory management. This class provides memory access via indirect mode (QSPI commands) or memory-mapped mode (direct CPU access), with Quad I/O mode support.

📋 Class Description

The cIS25LP064A class implements the iQSPI_FlashMemory interface for the ISSI IS25LP064A component. It handles read/write operations in Quad I/O mode, erase cycles (sector, block, chip) and allows switching between indirect command mode and Memory-Mapped Mode for direct processor access. It also supports “Dual Flash” mode to double capacity and read speed.

🔗 External Dependencies

File Inclusions

Included File	Source	Role
`"iQSPI_FLashMemory.h"`	`DAD_FORGE/Drivers`	Base interface for QSPI Flash memory

External Functions Called

Function	Source	Usage
`HAL_QSPI_Command`	`HAL`	Sending QSPI commands
`HAL_QSPI_Transmit`	`HAL`	Transmitting data via QSPI
`HAL_QSPI_Receive`	`HAL`	Receiving data via QSPI
`HAL_QSPI_Abort`	`HAL`	Aborting the current QSPI operation
`HAL_QSPI_MemoryMapped`	`HAL`	Configuring memory-mapped mode
`HAL_GetTick`	`HAL`	Retrieving system time for timeouts
`HAL_Delay`	`HAL`	System wait

🎯 Associated Enumerations and Structures

IS25LP064A_Commands

Set of commands specific to the ISSI IS25LP064A component’s instruction set.

Element / Variable	Type / Value (if applicable)	Description
`CMD_WRITE_ENABLE`	`0x06`	Write Enable (WREN)
`CMD_READ_STATUS_REG1`	`0x05`	Read Status Register-1 (RDSR1)
`CMD_READ_ID`	`0xAB`	Read ID / Release Power Down
`CMD_READ_JEDEC_ID`	`0x9F`	Read JEDEC ID
`CMD_READ_NORMAL`	`0x03`	Normal Read (READ)
`CMD_READ_FAST_QUAD_IO`	`0xEB`	Fast Read Quad I/O (4READ)
`CMD_PAGE_PROGRAM`	`0x02`	Page Program (PP)
`CMD_QUAD_PAGE_PROGRAM`	`0x32`	Quad Input Page Program (QPP)
`CMD_SECTOR_ERASE`	`0x20`	Sector Erase 4KB (SE)
`CMD_BLOCK_ERASE_32K`	`0x52`	Block Erase 32KB (BE32)
`CMD_BLOCK_ERASE_64K`	`0xD8`	Block Erase 64KB (BE64)
`CMD_CHIP_ERASE`	`0xC7`	Chip Erase (CE)
`CMD_RESET_DEVICE`	`0x99`	Reset Device (RST)

📚 Public Methods

Init

Element	Details
Method	`HAL_StatusTypeDef Init(QSPI_HandleTypeDef* phqspi, bool DualMode, uint32_t MemoryMappedBaseAddress)`
Description	Initializes the QSPI interface and the component. Performs a software reset and configures the status registers (Write Enable, Quad Enable).
Parameter(s)
`phqspi`	`QSPI_HandleTypeDef*` : HAL QSPI handle
`DualMode`	`bool` : Enables dual mode (two chips)
`MemoryMappedBaseAddress`	`uint32_t` : Base address for memory-mapped mode
Return	`HAL_StatusTypeDef` : Initialization status

ModeMemoryMap

Element	Details
Method	`HAL_StatusTypeDef ModeMemoryMap()`
Description	Configures the memory in memory-mapped mode to allow the CPU to directly access data via the memory address.
Return	`HAL_StatusTypeDef` : Operation status

ModeIndirect

Element	Details
Method	`HAL_StatusTypeDef ModeIndirect()`
Description	Switches the memory to indirect mode to allow the use of standard QSPI commands.
Return	`HAL_StatusTypeDef` : Operation status

Read

Element	Details
Method	`HAL_StatusTypeDef Read(uint8_t* pData, uint32_t MappedAddress, uint32_t NbData)`
Description	Reads data from memory using Quad I/O mode (4-4-4).
Parameter(s)
`pData`	`uint8_t*` : Destination buffer
`MappedAddress`	`uint32_t` : Mapped memory address
`NbData`	`uint32_t` : Number of bytes to read
Return	`HAL_StatusTypeDef` : Read status

Write

Element	Details
Method	`HAL_StatusTypeDef Write(uint8_t* pData, uint32_t MappedAddress, uint32_t NbData)`
Description	Writes data to memory using Quad Page Program mode, with page offset management.
Parameter(s)
`pData`	`uint8_t*` : Source buffer
`MappedAddress`	`uint32_t` : Mapped memory address
`NbData`	`uint32_t` : Number of bytes to write
Return	`HAL_StatusTypeDef` : Write status

EraseBlock4K

Element	Details
Method	`HAL_StatusTypeDef EraseBlock4K(uint32_t MappedAddress)`
Description	Erases a 4 KB sector at the specified address.
Parameter(s)
`MappedAddress`	`uint32_t` : Mapped memory address
Return	`HAL_StatusTypeDef` : Erase status

EraseBlock32K

Element	Details
Method	`HAL_StatusTypeDef EraseBlock32K(uint32_t MappedAddress)`
Description	Erases a 32 KB block at the specified address.
Parameter(s)
`MappedAddress`	`uint32_t` : Mapped memory address
Return	`HAL_StatusTypeDef` : Erase status

EraseBlock64K

Element	Details
Method	`HAL_StatusTypeDef EraseBlock64K(uint32_t MappedAddress)`
Description	Erases a 64 KB block at the specified address.
Parameter(s)
`MappedAddress`	`uint32_t` : Mapped memory address
Return	`HAL_StatusTypeDef` : Erase status

EraseChip

Element	Details
Method	`HAL_StatusTypeDef EraseChip()`
Description	Erases the entire memory chip.
Return	`HAL_StatusTypeDef` : Operation status

getSize

Element	Details
Method	`uint32_t getSize() const`
Description	Returns the total memory size in bytes (takes Dual mode into account).
Return	`uint32_t` : Total size in bytes

getFlashID

Element	Details
Method	`HAL_StatusTypeDef getFlashID(FlashID* pID)`
Description	Retrieves the JEDEC identifier of the Flash memory.
Parameter(s)
`pID`	`FlashID*` : Structure to store the ID
Return	`HAL_StatusTypeDef` : Read status

🔒 Protected / Private Methods

WriteEnable

Element	Details
Method	`HAL_StatusTypeDef WriteEnable()`
Description	Enables writing on the component via the WREN command.
Return	`HAL_StatusTypeDef` : Operation status

WaitWhileBusy

Element	Details
Method	`HAL_StatusTypeDef WaitWhileBusy(uint32_t Timeout)`
Description	Waits for the BUSY bit in the status register to be cleared (within a given timeout).
Parameter(s)
`Timeout`	`uint32_t` : Maximum wait time in ms
Return	`HAL_StatusTypeDef` : HAL_OK if completed, HAL_TIMEOUT if timeout exceeded

📦 Data

Private Variables

Member	Type	Description
`m_pQSPI`	`QSPI_HandleTypeDef*`	HAL QSPI handle used for communication
`m_MemoryMappedBaseAddress`	`uint32_t`	Base address for memory-mapped access
`m_DualMode`	`bool`	Flag indicating whether Dual Flash mode is active
`m_MappedMode`	`bool`	Flag indicating whether the memory is currently in mapped mode

💡 Usage Example

#include "IS25LP064A.h"
    
using namespace DadDrivers;

int main()
{
    QSPI_HandleTypeDef hqspi;  // Configured by HAL_QSPI_Init
    
    // cIS25LP064A flash initialization
    cIS25LP064A flash;
    
    if (flash.Init(&hqspi, false, 0x90000000) != HAL_OK) {
        Error_Handler();
    }
    
    // Identification verification
    FlashID id;
    if (flash.getFlashID(&id) == HAL_OK) {
        printf("Manufacturer: 0x%02X\n", id.ManufactuerID);  // 0xEF = Winbond
        printf("Device ID: 0x%02X %02X\n", 
               id.MemoryType, id.Capacity);  // 0x4018 or 0x7018
    }
    
    // Data write (page size = 256 bytes)
    uint8_t data[256] = {0xAA, 0x55, 0x88, 0x00};  // Test pattern
    if (flash.Write(data, 0x90000000, 256) == HAL_OK) {
        printf("Write completed\n");
    }

    // Data read from flash
    uint8_t buffer[256];
    if (flash.Read(buffer, 0x90000000, 256) == HAL_OK) {
        printf("Read: %02X %02X %02X %02X\n", 
               buffer[0], buffer[1], buffer[2], buffer[3]);
    }
    
    // 32K block erase
    if (flash.EraseBlock32K(0x90000000) == HAL_OK) {
        printf("32K block erased\n");
    }
    
    // Memory mapping for fast CPU access
    if (flash.ModeMemoryMap() == HAL_OK) {
        // Direct read from mapped address (as if it were RAM)
        uint8_t* mappedAddr = (uint8_t*)0x90000000;
        *mappedAddr = 0xDEADBEEF;  // Direct write
        
        printf("Read value: %02X\n", *mappedAddr);
        
        // Return to indirect mode before erase/programming
        flash.ModeIndirect();
    }

    return 0;
}