w25q_validation.cpp

/*
 * w25q_validation.cpp
 *
 *  Created on: Aug 30, 2026
 *      Author: johng
 */
 
#include "w25q_validation.hpp"
 
#include <stdio.h>
 
W25QValidation::W25QValidation(W25QFlashSPI &flash) : _flash(flash) {
    resetReport();
}
 
void W25QValidation::resetReport() {
    _report.status = W25Q_VALIDATION_STATUS_PASS;
    _report.failedTest = W25Q_VALIDATION_TEST_NONE;
    _report.failedPhase = W25Q_VALIDATION_PHASE_IDLE;
    _report.failedOffset = 0;
    _report.expectedValue = 0;
    _report.actualValue = 0;
    _report.testsRun = 0;
}
 
void W25QValidation::recordFailure(w25qValidationTestId_t testId, w25qValidationPhase_t phase,
        uint32_t offset, uint8_t expectedValue, uint8_t actualValue) {
    _report.status = W25Q_VALIDATION_STATUS_FAIL;
    _report.failedTest = testId;
    _report.failedPhase = phase;
    _report.failedOffset = offset;
    _report.expectedValue = expectedValue;
    _report.actualValue = actualValue;
}
 
const char *W25QValidation::getTestName(w25qValidationTestId_t testId) {
    switch (testId) {
    case W25Q_VALIDATION_TEST_ERASED_STATE:
        return "Erased-state test";
    case W25Q_VALIDATION_TEST_SMALL_RANGE:
        return "Small range read/write test";
    case W25Q_VALIDATION_TEST_PATTERN:
        return "Pattern data test";
    case W25Q_VALIDATION_TEST_PAGE_BOUNDARY:
        return "Page-boundary write test";
    case W25Q_VALIDATION_TEST_NONE:
    default:
        return "None";
    }
}
 
const char *W25QValidation::getPhaseName(w25qValidationPhase_t phase) {
    switch (phase) {
    case W25Q_VALIDATION_PHASE_ERASE:
        return "erase";
    case W25Q_VALIDATION_PHASE_FILL:
        return "fill";
    case W25Q_VALIDATION_PHASE_VERIFY:
        return "verify";
    case W25Q_VALIDATION_PHASE_IDLE:
    default:
        return "idle";
    }
}
 
void W25QValidation::printFailure() const {
    printf("  FAIL\r\n");
    printf("    Test    : %s\r\n", getTestName(_report.failedTest));
    printf("    Phase   : %s\r\n", getPhaseName(_report.failedPhase));
    printf("    Offset  : 0x%06lX\r\n", (unsigned long)_report.failedOffset);
    printf("    Expected: 0x%02X\r\n", _report.expectedValue);
    printf("    Actual  : 0x%02X\r\n", _report.actualValue);
}
 
bool W25QValidation::runErasedStateTest() {
    _report.testsRun++;
    _report.failedTest = W25Q_VALIDATION_TEST_ERASED_STATE;
    _report.failedPhase = W25Q_VALIDATION_PHASE_ERASE;
 
    printf("[TEST 1] %s\r\n", getTestName(W25Q_VALIDATION_TEST_ERASED_STATE));
 
    bool erased = _flash.eraseSector(W25Q_VALIDATION_BASE_ADDR);
    if (!erased) {
        recordFailure(W25Q_VALIDATION_TEST_ERASED_STATE, W25Q_VALIDATION_PHASE_ERASE,
                W25Q_VALIDATION_BASE_ADDR, 0xFF, 0x00);
        printFailure();
        return false;
    }
 
    _report.failedPhase = W25Q_VALIDATION_PHASE_VERIFY;
 
    uint8_t buf[W25Q_VALIDATION_SMALL_RANGE_SIZE];
    bool readOk = _flash.readBuffer(W25Q_VALIDATION_BASE_ADDR, buf, sizeof(buf));
    if (!readOk) {
        recordFailure(W25Q_VALIDATION_TEST_ERASED_STATE, W25Q_VALIDATION_PHASE_VERIFY,
                W25Q_VALIDATION_BASE_ADDR, 0xFF, 0x00);
        printFailure();
        return false;
    }
 
    for (uint32_t offset = 0; offset < sizeof(buf); offset++) {
        if (buf[offset] != 0xFF) {
            recordFailure(W25Q_VALIDATION_TEST_ERASED_STATE, W25Q_VALIDATION_PHASE_VERIFY,
                    W25Q_VALIDATION_BASE_ADDR + offset, 0xFF, buf[offset]);
            printFailure();
            return false;
        }
    }
 
    printf("  PASS\r\n");
    return true;
}
 
bool W25QValidation::runSmallRangeTest() {
    _report.testsRun++;
    _report.failedTest = W25Q_VALIDATION_TEST_SMALL_RANGE;
    _report.failedPhase = W25Q_VALIDATION_PHASE_ERASE;
 
    printf("[TEST 2] %s\r\n", getTestName(W25Q_VALIDATION_TEST_SMALL_RANGE));
 
    bool erased = _flash.eraseSector(W25Q_VALIDATION_BASE_ADDR);
    if (!erased) {
        recordFailure(W25Q_VALIDATION_TEST_SMALL_RANGE, W25Q_VALIDATION_PHASE_ERASE,
                W25Q_VALIDATION_BASE_ADDR, 0, 0);
        printFailure();
        return false;
    }
 
    uint8_t writeBuf[W25Q_VALIDATION_SMALL_RANGE_SIZE];
    for (uint32_t offset = 0; offset < sizeof(writeBuf); offset++) {
        writeBuf[offset] = (uint8_t)(offset & 0xFFu);
    }
 
    _report.failedPhase = W25Q_VALIDATION_PHASE_FILL;
    bool written = _flash.writeBuffer(W25Q_VALIDATION_BASE_ADDR, writeBuf, sizeof(writeBuf));
    if (!written) {
        recordFailure(W25Q_VALIDATION_TEST_SMALL_RANGE, W25Q_VALIDATION_PHASE_FILL,
                W25Q_VALIDATION_BASE_ADDR, 0, 0);
        printFailure();
        return false;
    }
 
    _report.failedPhase = W25Q_VALIDATION_PHASE_VERIFY;
    uint8_t readBuf[W25Q_VALIDATION_SMALL_RANGE_SIZE];
    bool readOk = _flash.readBuffer(W25Q_VALIDATION_BASE_ADDR, readBuf, sizeof(readBuf));
    if (!readOk) {
        recordFailure(W25Q_VALIDATION_TEST_SMALL_RANGE, W25Q_VALIDATION_PHASE_VERIFY,
                W25Q_VALIDATION_BASE_ADDR, 0, 0);
        printFailure();
        return false;
    }
 
    for (uint32_t offset = 0; offset < sizeof(readBuf); offset++) {
        uint8_t expectedValue = (uint8_t)(offset & 0xFFu);
        if (readBuf[offset] != expectedValue) {
            recordFailure(W25Q_VALIDATION_TEST_SMALL_RANGE, W25Q_VALIDATION_PHASE_VERIFY,
                    W25Q_VALIDATION_BASE_ADDR + offset, expectedValue, readBuf[offset]);
            printFailure();
            return false;
        }
    }
 
    printf("  PASS\r\n");
    return true;
}
 
bool W25QValidation::runPatternTest() {
    static const uint8_t patterns[] = {
        0x00u, 0xFFu, 0x55u, 0xAAu,
        0x01u, 0x02u, 0x04u, 0x08u, 0x10u, 0x20u, 0x40u, 0x80u,
        0xFEu, 0xFDu, 0xFBu, 0xF7u, 0xEFu, 0xDFu, 0xBFu, 0x7Fu
    };
    uint32_t patternCount = (uint32_t)(sizeof(patterns) / sizeof(patterns[0]));
 
    _report.testsRun++;
    _report.failedTest = W25Q_VALIDATION_TEST_PATTERN;
 
    printf("[TEST 3] %s\r\n", getTestName(W25Q_VALIDATION_TEST_PATTERN));
 
    for (uint32_t patternIndex = 0; patternIndex < patternCount; patternIndex++) {
        uint8_t expectedValue = patterns[patternIndex];
 
        // Each pattern re-erases first: Page Program can only clear bits
        // (1 -> 0), so writing e.g. 0xFF after 0x00 would silently fail to
        // set any bits back without an erase in between.
        _report.failedPhase = W25Q_VALIDATION_PHASE_ERASE;
        bool erased = _flash.eraseSector(W25Q_VALIDATION_BASE_ADDR);
        if (!erased) {
            recordFailure(W25Q_VALIDATION_TEST_PATTERN, W25Q_VALIDATION_PHASE_ERASE,
                    W25Q_VALIDATION_BASE_ADDR, expectedValue, 0);
            printFailure();
            return false;
        }
 
        uint8_t writeBuf[W25Q_VALIDATION_PATTERN_TEST_SIZE];
        for (uint32_t i = 0; i < sizeof(writeBuf); i++) {
            writeBuf[i] = expectedValue;
        }
 
        _report.failedPhase = W25Q_VALIDATION_PHASE_FILL;
        bool written = _flash.writeBuffer(W25Q_VALIDATION_BASE_ADDR, writeBuf, sizeof(writeBuf));
        if (!written) {
            recordFailure(W25Q_VALIDATION_TEST_PATTERN, W25Q_VALIDATION_PHASE_FILL,
                    W25Q_VALIDATION_BASE_ADDR, expectedValue, 0);
            printFailure();
            return false;
        }
 
        _report.failedPhase = W25Q_VALIDATION_PHASE_VERIFY;
        uint8_t readBuf[W25Q_VALIDATION_PATTERN_TEST_SIZE];
        bool readOk = _flash.readBuffer(W25Q_VALIDATION_BASE_ADDR, readBuf, sizeof(readBuf));
        if (!readOk) {
            recordFailure(W25Q_VALIDATION_TEST_PATTERN, W25Q_VALIDATION_PHASE_VERIFY,
                    W25Q_VALIDATION_BASE_ADDR, expectedValue, 0);
            printFailure();
            return false;
        }
 
        for (uint32_t offset = 0; offset < sizeof(readBuf); offset++) {
            if (readBuf[offset] != expectedValue) {
                recordFailure(W25Q_VALIDATION_TEST_PATTERN, W25Q_VALIDATION_PHASE_VERIFY,
                        W25Q_VALIDATION_BASE_ADDR + offset, expectedValue, readBuf[offset]);
                printFailure();
                return false;
            }
        }
 
        printf("  [%2lu/%2lu] Pattern 0x%02X PASS\r\n",
                (unsigned long)(patternIndex + 1), (unsigned long)patternCount, expectedValue);
    }
 
    printf("  PASS\r\n");
    return true;
}
 
bool W25QValidation::runPageBoundaryTest() {
    _report.testsRun++;
    _report.failedTest = W25Q_VALIDATION_TEST_PAGE_BOUNDARY;
    _report.failedPhase = W25Q_VALIDATION_PHASE_ERASE;
 
    printf("[TEST 4] %s\r\n", getTestName(W25Q_VALIDATION_TEST_PAGE_BOUNDARY));
 
    bool erased = _flash.eraseSector(W25Q_VALIDATION_BASE_ADDR);
    if (!erased) {
        recordFailure(W25Q_VALIDATION_TEST_PAGE_BOUNDARY, W25Q_VALIDATION_PHASE_ERASE,
                W25Q_VALIDATION_BASE_ADDR, 0, 0);
        printFailure();
        return false;
    }
 
    // Start 128 bytes before a page boundary so the write spans two pages --
    // exercises writeBuffer()'s internal per-page splitting logic.
    uint32_t startAddr = W25Q_VALIDATION_BASE_ADDR + (W25Q_PAGE_SIZE - 128u);
 
    uint8_t writeBuf[W25Q_VALIDATION_BOUNDARY_TEST_SIZE];
    for (uint32_t i = 0; i < sizeof(writeBuf); i++) {
        writeBuf[i] = (uint8_t)(i & 0xFFu);
    }
 
    _report.failedPhase = W25Q_VALIDATION_PHASE_FILL;
    bool written = _flash.writeBuffer(startAddr, writeBuf, sizeof(writeBuf));
    if (!written) {
        recordFailure(W25Q_VALIDATION_TEST_PAGE_BOUNDARY, W25Q_VALIDATION_PHASE_FILL,
                startAddr, 0, 0);
        printFailure();
        return false;
    }
 
    _report.failedPhase = W25Q_VALIDATION_PHASE_VERIFY;
    uint8_t readBuf[W25Q_VALIDATION_BOUNDARY_TEST_SIZE];
    bool readOk = _flash.readBuffer(startAddr, readBuf, sizeof(readBuf));
    if (!readOk) {
        recordFailure(W25Q_VALIDATION_TEST_PAGE_BOUNDARY, W25Q_VALIDATION_PHASE_VERIFY,
                startAddr, 0, 0);
        printFailure();
        return false;
    }
 
    for (uint32_t offset = 0; offset < sizeof(readBuf); offset++) {
        uint8_t expectedValue = (uint8_t)(offset & 0xFFu);
        if (readBuf[offset] != expectedValue) {
            recordFailure(W25Q_VALIDATION_TEST_PAGE_BOUNDARY, W25Q_VALIDATION_PHASE_VERIFY,
                    startAddr + offset, expectedValue, readBuf[offset]);
            printFailure();
            return false;
        }
    }
 
    printf("  PASS\r\n");
    return true;
}
 
const w25qValidationReport_t *W25QValidation::RunAll() {
    resetReport();
 
    printf("W25Q validation start\r\n\r\n");
    printf("WARNING: this suite is destructive -- it overwrites the first sector\r\n");
    printf("(%lu bytes) starting at address 0x%06lX.\r\n\r\n",
            (unsigned long)W25Q_SECTOR_SIZE, (unsigned long)W25Q_VALIDATION_BASE_ADDR);
 
    bool ok = runErasedStateTest();
 
    if (ok) {
        printf("\r\n");
        ok = runSmallRangeTest();
    }
 
    if (ok) {
        printf("\r\n");
        ok = runPatternTest();
    }
 
    if (ok) {
        printf("\r\n");
        ok = runPageBoundaryTest();
    }
 
    if (ok) {
        printf("\r\nW25Q validation complete: PASS\r\n");
    } else {
        printf("\r\nW25Q validation complete: FAIL\r\n");
    }
 
    return &_report;
}
 
const w25qValidationReport_t *W25QValidation::GetReport() const {
    return &_report;
}