a4092: mfgtool: link against spi.c instead of duplicating SPI code

mfgtool.c copy-pasted ~250 lines of low-level SPI code that already
existed in spi.c: nibble word packing, MMIO helpers, SPI byte-level
tx/rx, status register access, write enable, block protection, erase,
page program, and streaming read/write/erase functions.

Remove the duplicated code and link mfgtool against spi.c directly.
To support this:

  - spi.h: expose spi_read_sr1(), spi_read_sr2(), spi_read_unique_id(),
    and move SR1/SR2 bit defines from spi.c to the header
  - spi.c: make spi_read_sr1() and spi_read_sr2() non-static; add
    spi_read_unique_id(); add progress callback to
    spi_erase_range_blocks() (existing callers pass NULL)
  - mfgtool.c: include spi.h, drop all duplicated SPI code, update
    spi_write_buf_pagewise() calls for the progress parameter, add
    'uid' command using the now-shared spi_read_unique_id()
  - Makefile: add spi.c to the mfgtool link line

The mfgtool-specific settle-poll logic in spi_wait_wip_clear() (which
waited for WIP to first appear SET before polling for clear) is dropped
in favor of spi.c's simpler poll-for-clear. The settle-poll was a
manufacturing debug aid and is not essential.

Author: reinauer

util/a4092flash/Makefile

@@ -50,9 +50,9 @@ a4092flash: $(SRCS) *.h
 	$(QUIET)$(CC) $(CFLAGS) -o $@ $(SRCS) $(LDLIBS)
 	$(QUIET)$(STRIP) -s $@
 
-mfgtool: mfgtool.c mfg_flash.h
+mfgtool: mfgtool.c mfg_flash.h spi.c spi.h nibble_word.h
 	@echo Building $@
-	$(QUIET)$(CC) $(CFLAGS) -o $@ mfgtool.c $(LDLIBS)
+	$(QUIET)$(CC) $(CFLAGS) -o $@ mfgtool.c spi.c $(LDLIBS)
 
 test:
 	@echo Building NVRAM tests

util/a4092flash/mfgtool.c

@@ -37,16 +37,7 @@
 #include <proto/alib.h>
 #include <dos/dosextens.h>
 #include "../../ndkcompat.h"
-
-/* Use mirrored addresses for writes to work around 68030 write-allocation bug.
- * The MMU must be configured to make the write-mirror non-cacheable.
- * For now however, we disable write-allocation instead of using different
- * addresses.
- */
-#define SPI_PORT_READ_HOLD_OFFS  0x7FFFE0
-#define SPI_PORT_READ_END_OFFS   0x7FFFF0
-#define SPI_PORT_WRITE_HOLD_OFFS 0x7FFFC0
-#define SPI_PORT_WRITE_END_OFFS  0x7FFFD0
+#include "spi.h"
 
 /* A4092 board identification (matches main.c) */
 #define MANUF_ID_COMMODORE_BRAUNSCHWEIG 513
@@ -64,256 +55,6 @@ struct ConfigDev* FindConfigDev(struct ConfigDev*, LONG, LONG);
 
 #define MAX_TRANSFER_SIZE (8 * 1024 * 1024)
 
-static inline uint32_t pack_nibble_word(uint8_t b)
-{
-    uint32_t hi = ((uint32_t)((b >> 4) & 0x0F)) << 28; /* bits 28..31 */
-    uint32_t lo = ((uint32_t)( b       & 0x0F)) << 12; /* bits 12..15 */
-    return hi | lo;
-}
-static inline uint8_t unpack_nibble_word(uint32_t w)
-{
-    uint8_t hi = (uint8_t)((w >> 28) & 0x0F);
-    uint8_t lo = (uint8_t)((w >> 12) & 0x0F);
-    return (uint8_t)((hi << 4) | lo);
-}
-static inline void mmio_write_hold(uint32_t base, uint8_t v)
-{
-    volatile uint32_t *p = (volatile uint32_t *)(uintptr_t)(base + SPI_PORT_WRITE_HOLD_OFFS);
-    *p = pack_nibble_word(v);
-}
-static inline void mmio_write_end(uint32_t base, uint8_t v)
-{
-    volatile uint32_t *p = (volatile uint32_t *)(uintptr_t)(base + SPI_PORT_WRITE_END_OFFS);
-    *p = pack_nibble_word(v);
-}
-static inline uint8_t mmio_read_hold(uint32_t base)
-{
-    volatile uint32_t *p = (volatile uint32_t *)(uintptr_t)(base + SPI_PORT_READ_HOLD_OFFS);
-    uint32_t w = *p;
-    return unpack_nibble_word(w);
-}
-static inline uint8_t mmio_read_end(uint32_t base)
-{
-    volatile uint32_t *p = (volatile uint32_t *)(uintptr_t)(base + SPI_PORT_READ_END_OFFS);
-    uint32_t w = *p;
-    return unpack_nibble_word(w);
-}
-
-/* ===== SPI commands / constants ===== */
-enum {
-    SPI_CMD_WREN   = 0x06,
-    SPI_CMD_RDSR1  = 0x05,
-    SPI_CMD_WRSR   = 0x01,
-    SPI_CMD_RDSR2  = 0x35,
-    SPI_CMD_RDID   = 0x9F,
-    SPI_CMD_READ   = 0x03,
-    SPI_CMD_PP     = 0x02,
-    SPI_CMD_SE_4K  = 0x20,
-    SPI_CMD_BE64K  = 0xD8,
-};
-
-#define SR1_WIP     0x01
-#define SR1_WEL     0x02
-#define SR1_BP_MASK 0x1C
-
-#define SR2_QE      0x02
-
-#define SPI_PAGE_SIZE   256u
-#define SPI_BLOCK_SIZE  65536u
-
-/* ===== low-level bytewise helpers ===== */
-static inline void spi_tx_hold(uint32_t base, uint8_t v) { mmio_write_hold(base, v); }
-static inline void spi_tx_end (uint32_t base, uint8_t v) {
-    mmio_write_end (base, v);
-    //for (volatile int i = 0; i < 200; i++);
-}
-static inline uint8_t spi_rx_hold(uint32_t base) {
-    return mmio_read_hold(base);
-}
-static inline uint8_t spi_rx_end (uint32_t base) {
-    return mmio_read_end (base);
-}
-
-/* ===== status / waits ===== */
-static void spi_write_enable(uint32_t base)
-{
-    spi_tx_end(base, SPI_CMD_WREN);
-}
-static uint8_t spi_read_sr1(uint32_t base)
-{
-    spi_tx_hold(base, SPI_CMD_RDSR1);
-    return spi_rx_end(base);
-}
-static uint8_t spi_read_sr2(uint32_t base)
-{
-    spi_tx_hold(base, SPI_CMD_RDSR2);
-    return spi_rx_end(base);
-}
-static bool spi_wait_wip_clear(uint32_t base, uint32_t max_iters)
-{
-    const uint32_t settle_polls = 4096;
-    bool saw_wip = false;
-
-    /* Allow the SPI engine to finish clocking the opcode before polling aggressively. */
-    for (uint32_t i = 0; i < settle_polls; ++i) {
-        uint8_t sr = spi_read_sr1(base);
-        if (sr & SR1_WIP) {
-            saw_wip = true;
-            break;
-        }
-    }
-
-    if (!saw_wip) {
-        fprintf(stderr, "SPI: command never asserted WIP (SR1=%02X)\n", spi_read_sr1(base));
-        return false;
-    }
-
-    for (uint32_t i = 0; i < max_iters; ++i) {
-        if ((spi_read_sr1(base) & SR1_WIP) == 0) {
-            return true;
-        }
-    }
-
-    fprintf(stderr, "SPI: timeout waiting for WIP clear (SR1=%02X)\n", spi_read_sr1(base));
-    return false;
-}
-static bool spi_wait_wel_set(uint32_t base, uint32_t max_iters)
-{
-    while (max_iters--) {
-        if (spi_read_sr1(base) & SR1_WEL) {
-            return true;
-        }
-    }
-    return false;
-}
-
-static bool spi_write_status(uint32_t base, uint8_t sr1, uint8_t sr2)
-{
-    spi_write_enable(base);
-    if (!spi_wait_wel_set(base, 1000)) {
-        fprintf(stderr, "ERROR: WEL not set before status write\n");
-        return false;
-    }
-    spi_tx_hold(base, SPI_CMD_WRSR);
-    spi_tx_hold(base, sr1);
-    spi_tx_end(base, sr2);
-    if (!spi_wait_wip_clear(base, 100000)) {
-        fprintf(stderr, "ERROR: status register write timed out\n");
-        return false;
-    }
-    return true;
-}
-
-static bool spi_clear_block_protect(uint32_t base)
-{
-    uint8_t sr1 = spi_read_sr1(base);
-    uint8_t sr2 = spi_read_sr2(base);
-    if ((sr1 & SR1_BP_MASK) == 0) {
-        return true;
-    }
-    uint8_t new_sr1 = sr1 & (uint8_t)~SR1_BP_MASK;
-    printf("SPI flash reports block protection (SR1=%02X SR2=%02X); clearing BP bits...\n", sr1, sr2);
-    if (!spi_write_status(base, new_sr1, sr2)) {
-        fprintf(stderr, "ERROR: failed to clear block protection bits\n");
-        return false;
-    }
-    uint8_t verify1 = spi_read_sr1(base);
-    uint8_t verify2 = spi_read_sr2(base);
-    if (verify1 & SR1_BP_MASK) {
-        fprintf(stderr, "ERROR: block protection bits still set (SR1=%02X SR2=%02X). Check WP# pin.\n", verify1, verify2);
-        return false;
-    }
-    return true;
-}
-
-/* ===== single ops ===== */
-static void spi_read_id(uint32_t base, uint8_t *mfg, uint8_t *type, uint8_t *cap)
-{
-    spi_tx_hold(base, SPI_CMD_RDID);
-    if (mfg)  *mfg  = spi_rx_hold(base);
-    if (type) *type = spi_rx_hold(base);
-    if (cap)  *cap  = spi_rx_end(base);
-}
-static bool spi_block_erase(uint32_t base, uint32_t baddr)
-{
-    spi_write_enable(base);
-    if (!spi_wait_wel_set(base, 1000)) {
-        fprintf(stderr, "ERROR: WEL not set before erase at 0x%08lX\n", (unsigned long)baddr);
-        return false;
-    }
-    spi_tx_hold(base, SPI_CMD_BE64K);
-    spi_tx_hold(base, (baddr >> 16) & 0xFF);
-    spi_tx_hold(base, (baddr >> 8)  & 0xFF);
-    spi_tx_end (base,  baddr        & 0xFF);
-    return spi_wait_wip_clear(base, 2000000);
-}
-static bool spi_sector_erase_4k(uint32_t base, uint32_t baddr)
-{
-    spi_write_enable(base);
-    if (!spi_wait_wel_set(base, 1000)) {
-        fprintf(stderr, "ERROR: WEL not set before 4K erase at 0x%08lX\n", (unsigned long)baddr);
-        return false;
-    }
-    spi_tx_hold(base, SPI_CMD_SE_4K);
-    spi_tx_hold(base, (baddr >> 16) & 0xFF);
-    spi_tx_hold(base, (baddr >> 8)  & 0xFF);
-    spi_tx_end (base,  baddr        & 0xFF);
-    return spi_wait_wip_clear(base, 2000000);
-}
-
-static bool spi_page_program(uint32_t base, uint32_t addr, const uint8_t *data, size_t len)
-{
-    if (!len || len > SPI_PAGE_SIZE) return false;
-    spi_write_enable(base);
-    if (!spi_wait_wel_set(base, 1000)) {
-        fprintf(stderr, "ERROR: WEL not set before program at 0x%08lX\n", (unsigned long)addr);
-        return false;
-    }
-    spi_tx_hold(base, SPI_CMD_PP);
-    spi_tx_hold(base, (addr >> 16) & 0xFF);
-    spi_tx_hold(base, (addr >> 8)  & 0xFF);
-    spi_tx_hold(base,  addr        & 0xFF);
-    for (size_t i=0; i+1<len; ++i) spi_tx_hold(base, data[i]);
-    spi_tx_end(base, data[len-1]);
-    return spi_wait_wip_clear(base, 100000);
-}
-
-/* ===== streaming helpers ===== */
-static bool spi_read_buf(uint32_t base, uint32_t addr, uint8_t *out, size_t len)
-{
-    if (!len) return true;
-    spi_tx_hold(base, SPI_CMD_READ);
-    spi_tx_hold(base, (addr >> 16) & 0xFF);
-    spi_tx_hold(base, (addr >> 8)  & 0xFF);
-    spi_tx_hold(base,  addr        & 0xFF);
-    for (size_t i=0; i+1<len; ++i) out[i] = spi_rx_hold(base);
-    out[len-1] = spi_rx_end(base);
-    return true;
-}
-static bool spi_write_buf_pagewise(uint32_t base, uint32_t addr, const uint8_t *in, size_t len)
-{
-    while (len) {
-        uint32_t page_off  = addr & (SPI_PAGE_SIZE-1);
-        uint32_t page_room = SPI_PAGE_SIZE - page_off;
-        size_t chunk = len < page_room ? len : page_room;
-        if (!spi_page_program(base, addr, in, chunk)) return false;
-        addr += chunk; in += chunk; len -= chunk;
-    }
-    return true;
-}
-static bool spi_erase_range_blocks(uint32_t base, uint32_t addr, size_t len,
-                                   void (*progress)(size_t done, size_t total))
-{
-    uint32_t start = (addr / SPI_BLOCK_SIZE) * SPI_BLOCK_SIZE;
-    uint32_t end   = ((addr + (uint32_t)len - 1) / SPI_BLOCK_SIZE) * SPI_BLOCK_SIZE;
-    size_t total = (end - start) / SPI_BLOCK_SIZE + 1, k = 0;
-    for (uint32_t b = start; b <= end; b += SPI_BLOCK_SIZE, ++k) {
-        if (progress) progress(k, total);
-        if (!spi_block_erase(base, b)) return false;
-    }
-    if (progress) progress(total, total);
-    return true;
-}
 static bool spi_verify_buf(uint32_t base, uint32_t addr, const uint8_t *ref, size_t len,
                            void (*progress)(size_t done, size_t total))
 {
@@ -806,6 +547,7 @@ static void usage(const char *argv0)
     printf(
 "Usage:\n"
 "  %s id\n"
+"  %s uid\n"
 "  %s read  <addr> <len> <outfile>\n"
 "  %s erase <addr> <len> [--verify]\n"
 "  %s write <addr> <infile> [--verify]\n"
@@ -823,7 +565,7 @@ static void usage(const char *argv0)
 "  - 'writemfg' programs manufacturing data from a config file.\n"
 "  - 'readmfg' reads manufacturing data from flash to a config file.\n"
 "  - 'dumpmfg' displays manufacturing data on the console.\n"
-, argv0, argv0, argv0, argv0, argv0, argv0, argv0, argv0, argv0, argv0);
+, argv0, argv0, argv0, argv0, argv0, argv0, argv0, argv0, argv0, argv0, argv0);
 }
 
 /* parse CSV of hex bytes for 'patch' */
@@ -891,6 +633,15 @@ static int cmd_id(uint32_t base)
     return 0;
 }
 
+static int cmd_uid(uint32_t base)
+{
+    uint8_t id[8];
+    spi_read_unique_id(base, id);
+    printf("Unique ID: %02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
+           id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7]);
+    return 0;
+}
+
 static int cmd_read(uint32_t base, uint32_t addr, size_t len, const char *outfile)
 {
     if (len > MAX_TRANSFER_SIZE) { fprintf(stderr,"len too large (max %d)\n", MAX_TRANSFER_SIZE); return 2; }
@@ -932,7 +683,7 @@ static int cmd_write(uint32_t base, const char *saddr, const char *infile, bool
     size_t done=0;
     while (done<len) {
         size_t chunk = (len-done) > 4096 ? 4096 : (len-done);
-        if (!spi_write_buf_pagewise(base, addr+done, img+done, chunk)) {
+        if (!spi_write_buf_pagewise(base, addr+done, img+done, chunk, NULL)) {
             fprintf(stderr,"program failed at +0x%zx\n", done);
             free(img); return 3;
         }
@@ -970,7 +721,7 @@ static int cmd_patch(uint32_t base, const char *saddr, const char *hexlist)
     if (!parse_hexbytes(hexlist, &bytes, &n) || n==0) { free(bytes); fprintf(stderr,"bad hex bytes\n"); return 2; }
     if (!spi_clear_block_protect(base)) { free(bytes); return 3; }
     printf("Patching %zu byte(s) at 0x%08lX (assumes erased)...\n", n, (unsigned long)addr);
-    bool ok = spi_write_buf_pagewise(base, addr, bytes, n);
+    bool ok = spi_write_buf_pagewise(base, addr, bytes, n, NULL);
     free(bytes);
     if (!ok) { fprintf(stderr,"patch failed\n"); return 3; }
     printf("Patch OK\n"); return 0;
@@ -1039,7 +790,7 @@ static int cmd_writemfg(uint32_t base, const char *config_file)
     }
 
     /* Write 256 bytes */
-    if (!spi_write_buf_pagewise(base, MFG_FLASH_OFFSET, (const uint8_t *)&mfg, sizeof(mfg))) {
+    if (!spi_write_buf_pagewise(base, MFG_FLASH_OFFSET, (const uint8_t *)&mfg, sizeof(mfg), NULL)) {
         fprintf(stderr, "ERROR: flash write failed\n");
         return 3;
     }
@@ -1154,6 +905,9 @@ int main(int argc, char **argv)
     if (strcmp(cmd,"id")==0) {
         return cmd_id(base);
     }
+    else if (strcmp(cmd,"uid")==0) {
+        return cmd_uid(base);
+    }
     else if (strcmp(cmd,"read")==0) {
         if (argi+2 >= argc) { usage(argv[0]); return 1; }
         uint32_t addr; size_t len;