/*      $NetBSD: nor.c,v 1.7 2021/08/07 16:19:13 thorpej Exp $  */

/*-
 * Copyright (c) 2011 Department of Software Engineering,
 *                    University of Szeged, Hungary
 * Copyright (c) 2011 Adam Hoka <ahoka@NetBSD.org>
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by the Department of Software Engineering, University of Szeged, Hungary
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/* Common driver for NOR chips implementing the ONFI CFI specification */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: nor.c,v 1.7 2021/08/07 16:19:13 thorpej Exp $");

#include "locators.h"
#include "opt_nor.h"

#include <sys/param.h>
#include <sys/types.h>
#include <sys/device.h>
#include <sys/kmem.h>
#include <sys/sysctl.h>
#include <sys/atomic.h>

#include <dev/flash/flash.h>
#include <dev/flash/flash_io.h>
#include <dev/nor/nor.h>


static int nor_match(device_t, cfdata_t, void *);
static void nor_attach(device_t, device_t, void *);
static int nor_detach(device_t, int);
static bool nor_shutdown(device_t, int);
static int nor_print(void *, const char *);
static int nor_search(device_t, cfdata_t, const int *, void *);

/* flash interface implementation */
static int nor_flash_isbad(device_t, flash_off_t, bool *);
static int nor_flash_markbad(device_t, flash_off_t);
static int nor_flash_write(device_t, flash_off_t, size_t, size_t *,
        const u_char *);
static int nor_flash_read(device_t, flash_off_t, size_t, size_t *, uint8_t *);
static int nor_flash_erase_all(device_t);
static int nor_flash_erase(device_t, struct flash_erase_instruction *);
static int nor_flash_submit(device_t, buf_t *);

/* default functions for driver development */
static void nor_default_select(device_t, bool);
static int  nor_default_read_page(device_t, flash_off_t, uint8_t *);
static int  nor_default_program_page(device_t, flash_off_t, const uint8_t *);

static int nor_scan_media(device_t, struct nor_chip *);

CFATTACH_DECL_NEW(nor, sizeof(struct nor_softc),
    nor_match, nor_attach, nor_detach, NULL);

#ifdef NOR_DEBUG
int     nordebug = NOR_DEBUG;
#endif

int nor_cachesync_timeout = 1;
int nor_cachesync_nodenum;

struct flash_interface nor_flash_if = {
        .type = FLASH_TYPE_NOR,

        .read = nor_flash_read,
        .write = nor_flash_write,
        .erase = nor_flash_erase,
        .block_isbad = nor_flash_isbad,
        .block_markbad = nor_flash_markbad,

        .submit = nor_flash_submit
};

#ifdef NOR_VERBOSE
const struct nor_manufacturer nor_mfrs[] = {
        { NOR_MFR_AMD,          "AMD" },
        { NOR_MFR_FUJITSU,      "Fujitsu" },
        { NOR_MFR_RENESAS,      "Renesas" },
        { NOR_MFR_STMICRO,      "ST Micro" },
        { NOR_MFR_MICRON,       "Micron" },
        { NOR_MFR_NATIONAL,     "National" },
        { NOR_MFR_TOSHIBA,      "Toshiba" },
        { NOR_MFR_HYNIX,        "Hynix" },
        { NOR_MFGR_MACRONIX,    "Macronix" },
        { NOR_MFR_SAMSUNG,      "Samsung" },
        { NOR_MFR_UNKNOWN,      "Unknown" }
};

static const char *
nor_midtoname(int id)
{
        int i;

        for (i = 0; nor_mfrs[i].id != 0; i++) {
                if (nor_mfrs[i].id == id)
                        return nor_mfrs[i].name;
        }

        KASSERT(nor_mfrs[i].id == 0);

        return nor_mfrs[i].name;
}
#endif

/* ARGSUSED */
static int
nor_match(device_t parent, cfdata_t match, void *aux)
{
        /* pseudo device, always attaches */
        return 1;
}

static void
nor_attach(device_t parent, device_t self, void *aux)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_attach_args * const naa = aux;
        struct nor_chip * const chip = &sc->sc_chip;

        sc->sc_dev = self;
        sc->sc_controller_dev = parent;
        sc->sc_nor_if = naa->naa_nor_if;

        aprint_naive("\n");
        aprint_normal("\n");

        if (nor_scan_media(self, chip))
                return;

        sc->sc_flash_if = nor_flash_if;
        sc->sc_flash_if.erasesize = chip->nc_block_size;
        sc->sc_flash_if.page_size = chip->nc_page_size;
        sc->sc_flash_if.writesize = chip->nc_page_size;

        /* allocate cache */
#ifdef NOTYET
        chip->nc_oob_cache = kmem_alloc(chip->nc_spare_size, KM_SLEEP);
#endif
        chip->nc_page_cache = kmem_alloc(chip->nc_page_size, KM_SLEEP);

        mutex_init(&sc->sc_device_lock, MUTEX_DEFAULT, IPL_NONE);

        if (flash_sync_thread_init(&sc->sc_flash_io, self, &sc->sc_flash_if)) {
                goto error;
        }

        if (!pmf_device_register1(sc->sc_dev, NULL, NULL, nor_shutdown))
                aprint_error_dev(sc->sc_dev,
                    "couldn't establish power handler\n");

#ifdef NOR_BBT
        nor_bbt_init(self);
        nor_bbt_scan(self);
#endif

        /*
         * Attach all our devices
         */
        config_search(self, NULL,
            CFARGS(.search = nor_search));

        return;

error:
#ifdef NOTET
        kmem_free(chip->nc_oob_cache, chip->nc_spare_size);
#endif
        kmem_free(chip->nc_page_cache, chip->nc_page_size);
        mutex_destroy(&sc->sc_device_lock);
}

static int
nor_search(device_t parent, cfdata_t cf, const int *ldesc, void *aux)
{
        struct nor_softc * const sc = device_private(parent);
        struct nor_chip * const chip = &sc->sc_chip;
        struct flash_attach_args faa;

        faa.partinfo.part_offset = cf->cf_loc[FLASHBUSCF_OFFSET];

        if (cf->cf_loc[FLASHBUSCF_SIZE] == 0) {
                faa.partinfo.part_size =
                    chip->nc_size - faa.partinfo.part_offset;
        } else {
                faa.partinfo.part_size = cf->cf_loc[FLASHBUSCF_SIZE];
        }

        if (cf->cf_loc[FLASHBUSCF_READONLY])
                faa.partinfo.part_flags = FLASH_PART_READONLY;
        else
                faa.partinfo.part_flags = 0;

        faa.flash_if = &sc->sc_flash_if;

        if (config_probe(parent, cf, &faa)) {
                if (config_attach(parent, cf, &faa, nor_print,
                                  CFARGS_NONE) != NULL) {
                        return 0;
                } else {
                        return 1;
                }
        }

        return 1;
}

static int
nor_detach(device_t self, int flags)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;
        int error = 0;

        error = config_detach_children(self, flags);
        if (error) {
                return error;
        }

        flash_sync_thread_destroy(&sc->sc_flash_io);
#ifdef NOR_BBT
        nor_bbt_detach(self);
#endif
#ifdef NOTET
        /* free oob cache */
        kmem_free(chip->nc_oob_cache, chip->nc_spare_size);
#endif
        kmem_free(chip->nc_page_cache, chip->nc_page_size);

        mutex_destroy(&sc->sc_device_lock);

        pmf_device_deregister(sc->sc_dev);

        return error;
}

static int
nor_print(void *aux, const char *pnp)
{
        if (pnp != NULL)
                aprint_normal("nor at %s\n", pnp);

        return UNCONF;
}

/* ask for a nor driver to attach to the controller */
device_t
nor_attach_mi(struct nor_interface * const nor_if, device_t parent)
{
        struct nor_attach_args arg;

        KASSERT(nor_if != NULL);

        if (nor_if->select == NULL)
                nor_if->select = &nor_default_select;
        if (nor_if->read_page == NULL)
                nor_if->read_page = &nor_default_read_page;
        if (nor_if->program_page == NULL)
                nor_if->program_page = &nor_default_program_page;

        arg.naa_nor_if = nor_if;

        device_t dev = config_found(parent, &arg, nor_print,
            CFARGS(.iattr = "norbus"));

        return dev;
}

static void
nor_default_select(device_t self, bool n)
{
        /* do nothing */
        return;
}

static int
nor_flash_submit(device_t self, buf_t * const bp)
{
        struct nor_softc * const sc = device_private(self);

        return flash_io_submit(&sc->sc_flash_io, bp);
}


/* default everything to reasonable values, to ease future api changes */
void
nor_init_interface(struct nor_interface * const nor_if)
{
        nor_if->select = &nor_default_select;
        nor_if->read_1 = NULL;
        nor_if->read_2 = NULL;
        nor_if->read_4 = NULL;
        nor_if->read_buf_1 = NULL;
        nor_if->read_buf_2 = NULL;
        nor_if->read_buf_4 = NULL;
        nor_if->write_1 = NULL;
        nor_if->write_2 = NULL;
        nor_if->write_4 = NULL;
        nor_if->write_buf_1 = NULL;
        nor_if->write_buf_2 = NULL;
        nor_if->write_buf_4 = NULL;
        nor_if->busy = NULL;
}

#ifdef NOTYET
/* handle quirks here */
static void
nor_quirks(device_t self, struct nor_chip * const chip)
{
        /* this is an example only! */
        switch (chip->nc_manf_id) {
        case NOR_MFR_SAMSUNG:
                if (chip->nc_dev_id == 0x00) {
                        /* do something only samsung chips need */
                        /* or */
                        /* chip->nc_quirks |= NC_QUIRK_NO_READ_START */
                }
        }

        return;
}
#endif

/**
 * scan media to determine the chip's properties
 * this function resets the device
 */
static int
nor_scan_media(device_t self, struct nor_chip * const chip)
{
        struct nor_softc * const sc = device_private(self);
        char pbuf[3][sizeof("XXXX MB")];

        KASSERT(sc->sc_nor_if != NULL);
        KASSERT(sc->sc_nor_if->scan_media != NULL);
        int error = sc->sc_nor_if->scan_media(self, chip);
        if (error != 0)
                return error;

#ifdef NOR_VERBOSE
        aprint_normal_dev(self,
            "manufacturer id: 0x%.4x (%s), device id: 0x%.4x\n",
            chip->nc_manf_id,
            nor_midtoname(chip->nc_manf_id),
            chip->nc_dev_id);
#endif

        format_bytes(pbuf[0], sizeof(pbuf[0]), chip->nc_page_size);
        format_bytes(pbuf[1], sizeof(pbuf[1]), chip->nc_spare_size);
        format_bytes(pbuf[2], sizeof(pbuf[2]), chip->nc_block_size);
        aprint_normal_dev(self,
            "page size: %s, spare size: %s, block size: %s\n",
            pbuf[0], pbuf[1], pbuf[2]);

        format_bytes(pbuf[0], sizeof(pbuf[0]), chip->nc_size);
        aprint_normal_dev(self,
            "LUN size: %" PRIu32 " blocks, LUNs: %" PRIu8
            ", total storage size: %s\n",
            chip->nc_lun_blocks, chip->nc_num_luns, pbuf[0]);

#ifdef NOTYET
        /* XXX does this apply to nor? */
        /*
         * calculate badblock marker offset in oob
         * we try to be compatible with linux here
         */
        if (chip->nc_page_size > 512)
                chip->nc_badmarker_offs = 0;
        else
                chip->nc_badmarker_offs = 5;
#endif

        /* Calculate page shift and mask */
        chip->nc_page_shift = ffs(chip->nc_page_size) - 1;
        chip->nc_page_mask = ~(chip->nc_page_size - 1);
        /* same for block */
        chip->nc_block_shift = ffs(chip->nc_block_size) - 1;
        chip->nc_block_mask = ~(chip->nc_block_size - 1);

#ifdef NOTYET
        /* look for quirks here if needed in future */
        nor_quirks(self, chip);
#endif

        return 0;
}

/* ARGSUSED */
static bool
nor_shutdown(device_t self, int howto)
{
        return true;
}

/* implementation of the block device API */

/* read a page, default implementation */
static int
nor_default_read_page(device_t self, flash_off_t offset, uint8_t * const data)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;

        /*
         * access by specified access_width
         * note: #bits == 1 << width
         */
        switch(sc->sc_nor_if->access_width) {
        case 0:
                nor_read_buf_1(self, offset, data, chip->nc_page_size);
                break;
        case 1:
                nor_read_buf_2(self, offset, data, chip->nc_page_size);
                break;
        case 2:
                nor_read_buf_4(self, offset, data, chip->nc_page_size);
                break;
#ifdef NOTYET
        case 3:
                nor_read_buf_8(self, offset, data, chip->nc_page_size);
                break;
#endif
        default:
                panic("%s: bad width %d\n", __func__, sc->sc_nor_if->access_width);
        }

#if 0
        /* for debugging new drivers */
        nor_dump_data("page", data, chip->nc_page_size);
#endif

        return 0;
}

/* write a page, default implementation */
static int
nor_default_program_page(device_t self, flash_off_t offset,
    const uint8_t * const data)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;

        /*
         * access by specified width
         * #bits == 1 << access_width
         */
        switch(sc->sc_nor_if->access_width) {
        case 0:
                nor_write_buf_1(self, offset, data, chip->nc_page_size);
                break;
        case 1:
                nor_write_buf_2(self, offset, data, chip->nc_page_size);
                break;
        case 2:
                nor_write_buf_4(self, offset, data, chip->nc_page_size);
                break;
#ifdef NOTYET
        case 3:
                nor_write_buf_8(self, offset, data, chip->nc_page_size);
                break;
#endif
        default:
                panic("%s: bad width %d\n", __func__,
                        sc->sc_nor_if->access_width);
        }

#if 0
        /* for debugging new drivers */
        nor_dump_data("page", data, chip->nc_page_size);
#endif

        return 0;
}

/*
 * nor_flash_erase_all - erase the entire chip
 *
 * XXX a good way to brick your system
 */
static int
nor_flash_erase_all(device_t self)
{
        struct nor_softc * const sc = device_private(self);
        int error;

        mutex_enter(&sc->sc_device_lock);
        error = nor_erase_all(self);
        mutex_exit(&sc->sc_device_lock);

        return error;
}

static int
nor_flash_erase(device_t self, struct flash_erase_instruction * const ei)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;
        flash_off_t addr;
        int error = 0;

        if (ei->ei_addr < 0 || ei->ei_len < chip->nc_block_size)
                return EINVAL;

        if (ei->ei_addr + ei->ei_len > chip->nc_size) {
                DPRINTF(("%s: erase address is past the end"
                        " of the device\n", __func__));
                return EINVAL;
        }

        if ((ei->ei_addr == 0) && (ei->ei_len == chip->nc_size)
        &&  (sc->sc_nor_if->erase_all != NULL)) {
                return nor_flash_erase_all(self);
        }

        if (ei->ei_addr % chip->nc_block_size != 0) {
                aprint_error_dev(self,
                    "nor_flash_erase: ei_addr (%ju) is not"
                    " a multiple of block size (%ju)\n",
                    (uintmax_t)ei->ei_addr,
                    (uintmax_t)chip->nc_block_size);
                return EINVAL;
        }

        if (ei->ei_len % chip->nc_block_size != 0) {
                aprint_error_dev(self,
                    "nor_flash_erase: ei_len (%ju) is not"
                    " a multiple of block size (%ju)",
                    (uintmax_t)ei->ei_len,
                    (uintmax_t)chip->nc_block_size);
                return EINVAL;
        }

        mutex_enter(&sc->sc_device_lock);
        addr = ei->ei_addr;
        while (addr < ei->ei_addr + ei->ei_len) {
#ifdef NOTYET
                if (nor_isbad(self, addr)) {
                        aprint_error_dev(self, "bad block encountered\n");
                        ei->ei_state = FLASH_ERASE_FAILED;
                        error = EIO;
                        goto out;
                }
#endif

                error = nor_erase_block(self, addr);
                if (error) {
                        ei->ei_state = FLASH_ERASE_FAILED;
                        goto out;
                }

                addr += chip->nc_block_size;
        }
        mutex_exit(&sc->sc_device_lock);

        ei->ei_state = FLASH_ERASE_DONE;
        if (ei->ei_callback != NULL) {
                ei->ei_callback(ei);
        }

        return 0;
out:
        mutex_exit(&sc->sc_device_lock);

        return error;
}

/*
 * handle (page) unaligned write to nor
 */
static int
nor_flash_write_unaligned(device_t self, flash_off_t offset, size_t len,
    size_t * const retlen, const uint8_t * const buf)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;
        flash_off_t first, last, firstoff;
        const uint8_t *bufp;
        flash_off_t addr;
        size_t left, count;
        int error = 0, i;

        first = offset & chip->nc_page_mask;
        firstoff = offset & ~chip->nc_page_mask;
        /* XXX check if this should be len - 1 */
        last = (offset + len) & chip->nc_page_mask;
        count = last - first + 1;

        addr = first;
        *retlen = 0;

        mutex_enter(&sc->sc_device_lock);
        if (count == 1) {
#ifdef NOTYET
                if (nor_isbad(self, addr)) {
                        aprint_error_dev(self,
                            "nor_flash_write_unaligned: "
                            "bad block encountered\n");
                        error = EIO;
                        goto out;
                }
#endif

                error = nor_read_page(self, addr, chip->nc_page_cache);
                if (error) {
                        goto out;
                }

                memcpy(chip->nc_page_cache + firstoff, buf, len);

                error = nor_program_page(self, addr, chip->nc_page_cache);
                if (error) {
                        goto out;
                }

                *retlen = len;
                goto out;
        }

        bufp = buf;
        left = len;

        for (i = 0; i < count && left != 0; i++) {
#ifdef NOTYET
                if (nor_isbad(self, addr)) {
                        aprint_error_dev(self,
                            "nor_flash_write_unaligned: "
                            "bad block encountered\n");
                        error = EIO;
                        goto out;
                }
#endif

                if (i == 0) {
                        error = nor_read_page(self, addr, chip->nc_page_cache);
                        if (error) {
                                goto out;
                        }

                        memcpy(chip->nc_page_cache + firstoff,
                            bufp, chip->nc_page_size - firstoff);

                        printf("write page: %s: %d\n", __FILE__, __LINE__);
                        error = nor_program_page(self, addr,
                                chip->nc_page_cache);
                        if (error) {
                                goto out;
                        }

                        bufp += chip->nc_page_size - firstoff;
                        left -= chip->nc_page_size - firstoff;
                        *retlen += chip->nc_page_size - firstoff;

                } else if (i == count - 1) {
                        error = nor_read_page(self, addr, chip->nc_page_cache);
                        if (error) {
                                goto out;
                        }

                        memcpy(chip->nc_page_cache, bufp, left);

                        error = nor_program_page(self, addr,
                                chip->nc_page_cache);
                        if (error) {
                                goto out;
                        }

                        *retlen += left;
                        KASSERT(left < chip->nc_page_size);

                } else {
                        /* XXX debug */
                        if (left > chip->nc_page_size) {
                                printf("left: %zu, i: %d, count: %zu\n",
                                    (size_t )left, i, count);
                        }
                        KASSERT(left > chip->nc_page_size);

                        error = nor_program_page(self, addr, bufp);
                        if (error) {
                                goto out;
                        }

                        bufp += chip->nc_page_size;
                        left -= chip->nc_page_size;
                        *retlen += chip->nc_page_size;
                }

                addr += chip->nc_page_size;
        }

        KASSERT(*retlen == len);
out:
        mutex_exit(&sc->sc_device_lock);

        return error;
}

static int
nor_flash_write(device_t self, flash_off_t offset, size_t len,
    size_t * const retlen, const uint8_t * const buf)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;
        const uint8_t *bufp;
        size_t pages, page;
        daddr_t addr;
        int error = 0;

        if ((offset + len) > chip->nc_size) {
                DPRINTF(("%s: write (off: 0x%jx, len: %ju),"
                        " exceeds device size (0x%jx)\n", __func__,
                        (uintmax_t)offset, (uintmax_t)len,
                        (uintmax_t)chip->nc_size));
                return EINVAL;
        }

        if (len % chip->nc_page_size != 0 ||
            offset % chip->nc_page_size != 0) {
                return nor_flash_write_unaligned(self,
                    offset, len, retlen, buf);
        }

        pages = len / chip->nc_page_size;
        KASSERT(pages != 0);
        *retlen = 0;

        addr = offset;
        bufp = buf;

        mutex_enter(&sc->sc_device_lock);
        for (page = 0; page < pages; page++) {
#ifdef NOTYET
                /* do we need this check here? */
                if (nor_isbad(self, addr)) {
                        aprint_error_dev(self,
                            "nor_flash_write: bad block encountered\n");

                        error = EIO;
                        goto out;
                }
#endif

                error = nor_program_page(self, addr, bufp);
                if (error) {
                        goto out;
                }

                addr += chip->nc_page_size;
                bufp += chip->nc_page_size;
                *retlen += chip->nc_page_size;
        }
out:
        mutex_exit(&sc->sc_device_lock);
        DPRINTF(("%s: retlen: %zu, len: %zu\n", __func__, *retlen, len));

        return error;
}

/*
 * handle (page) unaligned read from nor
 */
static int
nor_flash_read_unaligned(device_t self, flash_off_t offset, size_t len,
    size_t * const retlen, uint8_t * const buf)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;
        daddr_t first, last, count, firstoff;
        uint8_t *bufp;
        daddr_t addr;
        size_t left;
        int error = 0, i;

        first = offset & chip->nc_page_mask;
        firstoff = offset & ~chip->nc_page_mask;
        last = (offset + len) & chip->nc_page_mask;
        count = (last - first) / chip->nc_page_size + 1;

        addr = first;
        bufp = buf;
        left = len;
        *retlen = 0;

        mutex_enter(&sc->sc_device_lock);
        if (count == 1) {
                error = nor_read_page(self, addr, chip->nc_page_cache);
                if (error) {
                        goto out;
                }

                memcpy(bufp, chip->nc_page_cache + firstoff, len);

                *retlen = len;
                goto out;
        }

        for (i = 0; i < count && left != 0; i++) {
                /* XXX Why use the page cache here ? */
                error = nor_read_page(self, addr, chip->nc_page_cache);
                if (error) {
                        goto out;
                }

                if (i == 0) {
                        memcpy(bufp, chip->nc_page_cache + firstoff,
                            chip->nc_page_size - firstoff);

                        bufp += chip->nc_page_size - firstoff;
                        left -= chip->nc_page_size - firstoff;
                        *retlen += chip->nc_page_size - firstoff;

                } else if (i == count - 1) {
                        memcpy(bufp, chip->nc_page_cache, left);
                        *retlen += left;
                        KASSERT(left < chip->nc_page_size);

                } else {
                        memcpy(bufp, chip->nc_page_cache, chip->nc_page_size);

                        bufp += chip->nc_page_size;
                        left -= chip->nc_page_size;
                        *retlen += chip->nc_page_size;
                }

                addr += chip->nc_page_size;
        }
        KASSERT(*retlen == len);
out:
        mutex_exit(&sc->sc_device_lock);

        return error;
}

static int
nor_flash_read(device_t self, flash_off_t offset, size_t len,
    size_t * const retlen, uint8_t * const buf)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;
        uint8_t *bufp;
        size_t addr;
        size_t i, pages;
        int error = 0;

        *retlen = 0;

        DPRINTF(("%s: off: 0x%jx, len: %zu\n",
                __func__, (uintmax_t)offset, len));

        if (__predict_false((offset + len) > chip->nc_size)) {
                DPRINTF(("%s: read (off: 0x%jx, len: %zu),"
                        " exceeds device size (%ju)\n", __func__,
                        (uintmax_t)offset, len, (uintmax_t)chip->nc_size));
                return EINVAL;
        }

        /* Handle unaligned access, shouldnt be needed when using the
         * block device, as strategy handles it, so only low level
         * accesses will use this path
         */
        /* XXX^2 */
#if 0
        if (len < chip->nc_page_size)
                panic("TODO page size is larger than read size");
#endif

        if (len % chip->nc_page_size != 0 ||
            offset % chip->nc_page_size != 0) {
                return nor_flash_read_unaligned(self,
                    offset, len, retlen, buf);
        }

        bufp = buf;
        addr = offset;
        pages = len / chip->nc_page_size;

        mutex_enter(&sc->sc_device_lock);
        for (i = 0; i < pages; i++) {
#ifdef NOTYET
                /* XXX do we need this check here? */
                if (nor_isbad(self, addr)) {
                        aprint_error_dev(self, "bad block encountered\n");
                        error = EIO;
                        goto out;
                }
#endif
                error = nor_read_page(self, addr, bufp);
                if (error)
                        goto out;

                bufp += chip->nc_page_size;
                addr += chip->nc_page_size;
                *retlen += chip->nc_page_size;
        }
out:
        mutex_exit(&sc->sc_device_lock);

        return error;
}

static int
nor_flash_isbad(device_t self, flash_off_t ofs, bool * const isbad)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;
#ifdef NOTYET
        bool result;
#endif

        if (ofs > chip->nc_size) {
                DPRINTF(("%s: offset 0x%jx is larger than"
                        " device size (0x%jx)\n", __func__,
                        (uintmax_t)ofs, (uintmax_t)chip->nc_size));
                return EINVAL;
        }

        if (ofs % chip->nc_block_size != 0) {
                DPRINTF(("offset (0x%jx) is not the multiple of block size "
                        "(%ju)",
                        (uintmax_t)ofs, (uintmax_t)chip->nc_block_size));
                return EINVAL;
        }

#ifdef NOTYET
        mutex_enter(&sc->sc_device_lock);
        result = nor_isbad(self, ofs);
        mutex_exit(&sc->sc_device_lock);

        *isbad = result;
#else
        *isbad = false;
#endif

        return 0;
}

static int
nor_flash_markbad(device_t self, flash_off_t ofs)
{
        struct nor_softc * const sc = device_private(self);
        struct nor_chip * const chip = &sc->sc_chip;

        if (ofs > chip->nc_size) {
                DPRINTF(("%s: offset 0x%jx is larger than"
                        " device size (0x%jx)\n", __func__,
                        ofs, (uintmax_t)chip->nc_size));
                return EINVAL;
        }

        if (ofs % chip->nc_block_size != 0) {
                panic("offset (%ju) is not the multiple of block size (%ju)",
                    (uintmax_t)ofs, (uintmax_t)chip->nc_block_size);
        }

        /* TODO: implement this */

        return 0;
}

static int
sysctl_nor_verify(SYSCTLFN_ARGS)
{
        int error, t;
        struct sysctlnode node;

        node = *rnode;
        t = *(int *)rnode->sysctl_data;
        node.sysctl_data = &t;
        error = sysctl_lookup(SYSCTLFN_CALL(&node));
        if (error || newp == NULL)
                return error;

        if (node.sysctl_num == nor_cachesync_nodenum) {
                if (t <= 0 || t > 60)
                        return EINVAL;
        } else {
                return EINVAL;
        }

        *(int *)rnode->sysctl_data = t;

        return 0;
}

SYSCTL_SETUP(sysctl_nor, "sysctl nor subtree setup")
{
        int rc, nor_root_num;
        const struct sysctlnode *node;

        if ((rc = sysctl_createv(clog, 0, NULL, &node,
            CTLFLAG_PERMANENT, CTLTYPE_NODE, "nor",
            SYSCTL_DESCR("NOR driver controls"),
            NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) {
                goto error;
        }

        nor_root_num = node->sysctl_num;

        if ((rc = sysctl_createv(clog, 0, NULL, &node,
            CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
            CTLTYPE_INT, "cache_sync_timeout",
            SYSCTL_DESCR("NOR write cache sync timeout in seconds"),
            sysctl_nor_verify, 0, &nor_cachesync_timeout,
            0, CTL_HW, nor_root_num, CTL_CREATE,
            CTL_EOL)) != 0) {
                goto error;
        }

        nor_cachesync_nodenum = node->sysctl_num;

        return;

error:
        aprint_error("%s: sysctl_createv failed (rc = %d)\n", __func__, rc);
}

MODULE(MODULE_CLASS_DRIVER, nor, "flash");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
nor_modcmd(modcmd_t cmd, void *opaque)
{
        switch (cmd) {
        case MODULE_CMD_INIT:
#ifdef _MODULE
                return config_init_component(cfdriver_ioconf_nor,
                    cfattach_ioconf_nor, cfdata_ioconf_nor);
#else
                return 0;
#endif
        case MODULE_CMD_FINI:
#ifdef _MODULE
                return config_fini_component(cfdriver_ioconf_nor,
                    cfattach_ioconf_nor, cfdata_ioconf_nor);
#else
                return 0;
#endif
        default:
                return ENOTTY;
        }
}