QSPI: limit page-write loop to remaining bytes

F/221

Author: danielinux

src/qspi_flash.c

@@ -431,7 +431,7 @@ int spi_flash_write(uint32_t address, const void *data, int len)
         ret = qspi_write_enable();
         if (ret == 0) {
             uint8_t* ptr;
-            xferSz = len;
+            xferSz = len - (page * FLASH_PAGE_SIZE);
             if (xferSz > FLASH_PAGE_SIZE)
                 xferSz = FLASH_PAGE_SIZE;
 

tools/unit-tests/Makefile

@@ -38,7 +38,7 @@ TESTS:=unit-parser unit-extflash unit-string unit-spi-flash unit-aes128 \
        unit-image unit-image-rsa unit-nvm unit-nvm-flagshome unit-enc-nvm \
        unit-enc-nvm-flagshome unit-delta unit-update-flash \
        unit-update-flash-enc unit-update-ram unit-pkcs11_store unit-psa_store unit-disk \
-       unit-multiboot unit-boot-x86-fsp
+       unit-multiboot unit-boot-x86-fsp unit-qspi-flash
 
 all: $(TESTS)
 
@@ -106,6 +106,9 @@ unit-extflash: ../../include/target.h unit-extflash.c
 unit-spi-flash: ../../include/target.h unit-spi-flash.c
 	gcc -o $@ $^ $(CFLAGS) $(LDFLAGS)
 
+unit-qspi-flash: ../../include/target.h unit-qspi-flash.c
+	gcc -o $@ $^ $(CFLAGS) $(LDFLAGS)
+
 unit-string: ../../include/target.h unit-string.c
 	gcc -o $@ $^ $(CFLAGS) -DDEBUG_UART -DPRINTF_ENABLED $(LDFLAGS)
 

tools/unit-tests/unit-qspi-flash.c

@@ -0,0 +1,116 @@
+/* unit-qspi-flash.c
+ *
+ * Unit tests for qspi_flash.c.
+ */
+
+#define QSPI_FLASH
+
+#include <check.h>
+#include <stdint.h>
+#include <string.h>
+
+static int program_call_count;
+static uint32_t program_sizes[8];
+static const uint8_t *program_ptrs[8];
+static uint32_t program_addrs[8];
+
+void spi_init(int polarity, int phase)
+{
+    (void)polarity;
+    (void)phase;
+}
+
+void spi_release(void)
+{
+}
+
+#include "../../src/qspi_flash.c"
+
+int qspi_transfer(uint8_t fmode, const uint8_t cmd,
+    uint32_t addr, uint32_t addrSz, uint32_t addrMode,
+    uint32_t alt, uint32_t altSz, uint32_t altMode,
+    uint32_t dummySz,
+    uint8_t* data, uint32_t dataSz, uint32_t dataMode)
+{
+    (void)fmode;
+    (void)addrSz;
+    (void)addrMode;
+    (void)alt;
+    (void)altSz;
+    (void)altMode;
+    (void)dummySz;
+    (void)dataMode;
+
+    if (cmd == READ_SR_CMD) {
+        ck_assert_ptr_nonnull(data);
+        ck_assert_uint_ge(dataSz, 1);
+        data[0] = FLASH_SR_WRITE_EN;
+        return 0;
+    }
+
+    if (cmd == FLASH_WRITE_CMD) {
+        ck_assert_int_lt(program_call_count, (int)(sizeof(program_sizes) / sizeof(program_sizes[0])));
+        program_sizes[program_call_count] = dataSz;
+        program_ptrs[program_call_count] = data;
+        program_addrs[program_call_count] = addr;
+        program_call_count++;
+        return 0;
+    }
+
+    return 0;
+}
+
+static void setup(void)
+{
+    program_call_count = 0;
+    memset(program_sizes, 0, sizeof(program_sizes));
+    memset(program_ptrs, 0, sizeof(program_ptrs));
+    memset(program_addrs, 0, sizeof(program_addrs));
+}
+
+START_TEST(test_qspi_write_splits_last_page_to_remaining_bytes)
+{
+    uint8_t buf[300];
+    int ret;
+
+    memset(buf, 0xA5, sizeof(buf));
+
+    ret = spi_flash_write(0x1000, buf, sizeof(buf));
+
+    ck_assert_int_eq(ret, 0);
+    ck_assert_int_eq(program_call_count, 2);
+    ck_assert_uint_eq(program_sizes[0], FLASH_PAGE_SIZE);
+    ck_assert_ptr_eq(program_ptrs[0], buf);
+    ck_assert_uint_eq(program_addrs[0], 0x1000);
+    ck_assert_uint_eq(program_sizes[1], sizeof(buf) - FLASH_PAGE_SIZE);
+    ck_assert_ptr_eq(program_ptrs[1], buf + FLASH_PAGE_SIZE);
+    ck_assert_uint_eq(program_addrs[1], 0x1000 + FLASH_PAGE_SIZE);
+}
+END_TEST
+
+static Suite *qspi_flash_suite(void)
+{
+    Suite *s;
+    TCase *tc;
+
+    s = suite_create("QSPI Flash");
+    tc = tcase_create("Write");
+    tcase_add_checked_fixture(tc, setup, NULL);
+    tcase_add_test(tc, test_qspi_write_splits_last_page_to_remaining_bytes);
+    suite_add_tcase(s, tc);
+    return s;
+}
+
+int main(void)
+{
+    Suite *s;
+    SRunner *sr;
+    int failed;
+
+    s = qspi_flash_suite();
+    sr = srunner_create(s);
+    srunner_run_all(sr, CK_NORMAL);
+    failed = srunner_ntests_failed(sr);
+    srunner_free(sr);
+    return failed == 0 ? 0 : 1;
+}