1 files changed, 295 insertions, 0 deletions

diff --git a/lib/x1000-installer/src/xf_nandio.c b/lib/x1000-installer/src/xf_nandio.c
new file mode 100644
index 0000000000..ba79cbbcbf
--- /dev/null
+++ b/lib/x1000-installer/src/xf_nandio.c
@@ -0,0 +1,295 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2021 Aidan MacDonald
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include "xf_nandio.h"
+#include "xf_error.h"
+#include "core_alloc.h"
+#include "system.h"
+#include <string.h>
+#include <stdbool.h>
+
+int xf_nandio_init(struct xf_nandio* nio)
+{
+    int rc;
+
+    memset(nio, 0, sizeof(*nio));
+
+    /* open NAND */
+    nio->ndrv = nand_init();
+    nand_lock(nio->ndrv);
+    rc = nand_open(nio->ndrv);
+    if(rc != NAND_SUCCESS) {
+        nio->nand_err = rc;
+        rc = XF_E_NAND;
+        goto out;
+    }
+
+    /* read chip parameters */
+    nio->page_size = nio->ndrv->chip->page_size;
+    nio->block_size = nio->page_size << nio->ndrv->chip->log2_ppb;
+
+    /* allocate memory */
+    size_t alloc_size = 0;
+    alloc_size += CACHEALIGN_SIZE - 1;
+    alloc_size += nio->block_size * 2;
+
+    nio->alloc_handle = core_alloc("xf_nandio", alloc_size);
+    if(nio->alloc_handle < 0) {
+        rc = XF_E_OUT_OF_MEMORY;
+        goto out_nclose;
+    }
+
+    uint8_t* buffer = core_get_data(nio->alloc_handle);
+    CACHEALIGN_BUFFER(buffer, alloc_size);
+
+    nio->old_buf = buffer;
+    nio->new_buf = &buffer[nio->block_size];
+
+    rc = XF_E_SUCCESS;
+    goto out;
+
+  out_nclose:
+    nand_close(nio->ndrv);
+  out:
+    nand_unlock(nio->ndrv);
+    return rc;
+}
+
+void xf_nandio_destroy(struct xf_nandio* nio)
+{
+    if(nio->alloc_handle > 0) {
+        core_free(nio->alloc_handle);
+        nio->alloc_handle = 0;
+    }
+
+    if(nio->ndrv) {
+        nand_lock(nio->ndrv);
+        nand_close(nio->ndrv);
+        nand_unlock(nio->ndrv);
+        nio->ndrv = NULL;
+    }
+}
+
+static bool is_page_blank(const uint8_t* buf, uint32_t length)
+{
+    for(uint32_t i = 0; i < length; ++i)
+        if(buf[i] != 0xff)
+            return false;
+
+    return true;
+}
+
+static int flush_block(struct xf_nandio* nio, bool invalidate)
+{
+    /* no block, or only reading - flush is a no-op */
+    if(!nio->block_valid || nio->mode == XF_NANDIO_READ)
+        return XF_E_SUCCESS;
+
+    /* nothing to do if new data is same as old data */
+    if(!memcmp(nio->old_buf, nio->new_buf, nio->block_size))
+        return XF_E_SUCCESS;
+
+    /* data mismatch during verification - report the error */
+    if(nio->mode == XF_NANDIO_VERIFY)
+        return XF_E_VERIFY_FAILED;
+
+    /* erase the block */
+    int rc = nand_block_erase(nio->ndrv, nio->cur_block);
+    if(rc != NAND_SUCCESS) {
+        nio->block_valid = false;
+        nio->nand_err = rc;
+        return XF_E_NAND;
+    }
+
+    size_t oob_size = nio->ndrv->chip->oob_size;
+
+    unsigned page = 0;
+    nand_page_t page_addr = nio->cur_block;
+    for(; page < nio->ndrv->ppb; ++page, ++page_addr) {
+        /* skip programming blank pages to go faster & reduce wear */
+        uint8_t* page_data = &nio->new_buf[page * nio->page_size];
+        if(is_page_blank(page_data, nio->page_size))
+            continue;
+
+        /* copy page and write blank OOB data */
+        memcpy(nio->ndrv->page_buf, page_data, nio->page_size);
+        memset(&nio->ndrv->page_buf[nio->page_size], 0xff, oob_size);
+
+        /* program the page */
+        rc = nand_page_program(nio->ndrv, page_addr, nio->ndrv->page_buf);
+        if(rc != NAND_SUCCESS) {
+            nio->block_valid = false;
+            nio->nand_err = rc;
+            return XF_E_NAND;
+        }
+    }
+
+    if(invalidate)
+        nio->block_valid = false;
+    else {
+        /* update our 'old' buffer so a subsequent flush
+         * will not reprogram the same block */
+        memcpy(nio->old_buf, nio->new_buf, nio->block_size);
+    }
+
+    return XF_E_SUCCESS;
+}
+
+static int seek_to_block(struct xf_nandio* nio, nand_block_t block_addr,
+                         size_t offset_in_block)
+{
+    /* already on this block? */
+    if(nio->block_valid && block_addr == nio->cur_block) {
+        nio->offset_in_block = offset_in_block;
+        return XF_E_SUCCESS;
+    }
+
+    /* ensure new block is within range */
+    if(block_addr >= (nio->ndrv->chip->nr_blocks << nio->ndrv->chip->log2_ppb))
+        return XF_E_OUT_OF_RANGE;
+
+    /* flush old block */
+    int rc = flush_block(nio, true);
+    if(rc)
+        return rc;
+
+    nio->block_valid = false;
+
+    /* read the new block */
+    unsigned page = 0;
+    nand_page_t page_addr = block_addr;
+    for(; page < nio->ndrv->ppb; ++page, ++page_addr) {
+        rc = nand_page_read(nio->ndrv, page_addr, nio->ndrv->page_buf);
+        if(rc != NAND_SUCCESS) {
+            nio->nand_err = rc;
+            return XF_E_NAND;
+        }
+
+        memcpy(&nio->old_buf[page * nio->page_size], nio->ndrv->page_buf, nio->page_size);
+    }
+
+    /* copy to 2nd buffer */
+    memcpy(nio->new_buf, nio->old_buf, nio->block_size);
+
+    /* update position */
+    nio->cur_block = block_addr;
+    nio->offset_in_block = offset_in_block;
+    nio->block_valid = true;
+    return XF_E_SUCCESS;
+}
+
+int xf_nandio_set_mode(struct xf_nandio* nio, enum xf_nandio_mode mode)
+{
+    nand_lock(nio->ndrv);
+
+    /* flush the current block before switching to the new mode,
+     * to ensure consistency */
+    int rc = flush_block(nio, false);
+    if(rc)
+        goto err;
+
+    nio->mode = mode;
+    rc = XF_E_SUCCESS;
+
+  err:
+    nand_unlock(nio->ndrv);
+    return rc;
+}
+
+static int nandio_rdwr(struct xf_nandio* nio, void* buf, size_t count, bool write)
+{
+    while(count > 0) {
+        void* ptr;
+        size_t amount = count;
+        int rc = xf_nandio_get_buffer(nio, &ptr, &amount);
+        if(rc)
+            return rc;
+
+        if(write)
+            memcpy(ptr, buf, amount);
+        else
+            memcpy(buf, ptr, amount);
+
+        count -= amount;
+    }
+
+    return XF_E_SUCCESS;
+}
+
+int xf_nandio_seek(struct xf_nandio* nio, size_t offset)
+{
+    uint32_t block_nr = offset / nio->block_size;
+    size_t offset_in_block = offset % nio->block_size;
+    nand_block_t block_addr = block_nr << nio->ndrv->chip->log2_ppb;
+
+    nand_lock(nio->ndrv);
+    int rc = seek_to_block(nio, block_addr, offset_in_block);
+    nand_unlock(nio->ndrv);
+
+    return rc;
+}
+
+int xf_nandio_read(struct xf_nandio* nio, void* buf, size_t count)
+{
+    return nandio_rdwr(nio, buf, count, false);
+}
+
+int xf_nandio_write(struct xf_nandio* nio, const void* buf, size_t count)
+{
+    return nandio_rdwr(nio, (void*)buf, count, true);
+}
+
+int xf_nandio_get_buffer(struct xf_nandio* nio, void** buf, size_t* count)
+{
+    nand_lock(nio->ndrv);
+
+    /* make sure the current block data is read in */
+    int rc = seek_to_block(nio, nio->cur_block, nio->offset_in_block);
+    if(rc)
+        goto err;
+
+    size_t amount_left = nio->block_size - nio->offset_in_block;
+    if(amount_left == 0) {
+        amount_left = nio->block_size;
+        rc = seek_to_block(nio, nio->cur_block + nio->ndrv->ppb, 0);
+        if(rc)
+            goto err;
+    }
+
+    *buf = &nio->new_buf[nio->offset_in_block];
+    *count = MIN(*count, amount_left);
+
+    nio->offset_in_block += *count;
+    rc = XF_E_SUCCESS;
+
+  err:
+    nand_unlock(nio->ndrv);
+    return rc;
+}
+
+int xf_nandio_flush(struct xf_nandio* nio)
+{
+    nand_lock(nio->ndrv);
+    int rc = flush_block(nio, false);
+    nand_unlock(nio->ndrv);
+
+    return rc;
+}