/*      $NetBSD: nor.h,v 1.5 2018/04/19 21:50:09 christos 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.
 */

#ifndef _NOR_H_
#define _NOR_H_

#include <sys/param.h>
#include <sys/cdefs.h>

#include <sys/bufq.h>
#include <sys/buf.h>
#include <sys/device.h>

#include <sys/bus.h>

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

#ifdef NOR_DEBUG
#define DPRINTF(x)      do { printf x ; } while (0)
#else
#define DPRINTF(x)
#endif

/**
 * nor_chip: structure containing the required information
 *            about the NOR chip.
 */
struct nor_chip {
        struct nor_ecc *nc_ecc;         /* ecc information */
        uint8_t *nc_oob_cache;          /* buffer for oob cache */
        uint8_t *nc_page_cache;         /* buffer for page cache */
        uint8_t *nc_ecc_cache;
        size_t nc_size;                 /* storage size in bytes */
        size_t nc_page_size;            /* page (write buf) size in bytes */
        size_t nc_line_size;            /* read line in bytes */
        size_t nc_block_pages;          /* block size in pages */
        size_t nc_block_size;           /* block size in bytes */
        size_t nc_spare_size;           /* spare (oob) size in bytes */
        uint32_t nc_lun_blocks;         /* LUN size in blocks */
        uint32_t nc_flags;              /* bitfield flags */
        uint32_t nc_quirks;             /* bitfield quirks */
        unsigned int nc_page_shift;     /* page shift for page alignment */
        unsigned int nc_page_mask;      /* page mask for page alignment */
        unsigned int nc_block_shift;    /* write shift */
        unsigned int nc_block_mask;     /* write mask */
        uint8_t nc_num_luns;            /* number of LUNs */
        uint8_t nc_manf_id;             /* manufacturer id */
        uint8_t nc_dev_id;              /* device id  */
        uint8_t nc_badmarker_offs;      /* offset for marking bad blocks */
};

/* driver softc for nor */
struct nor_softc {
        device_t sc_dev;
        device_t sc_controller_dev;
        struct flash_interface sc_flash_if;
        struct nor_interface *sc_nor_if;
        void *nor_softc;
        struct nor_chip sc_chip;
        bus_addr_t sc_bus_addr;         /* chip base address */
        bus_size_t sc_bus_size;         /* total NOR size */
        off_t sc_part_offset;           /* partition start, offset from base */
        size_t sc_part_size;            /* partition size */
        bus_space_tag_t sc_bst;
        bus_space_handle_t sc_bsh;
        kmutex_t sc_device_lock; /* serialize access to chip */
        struct flash_io sc_flash_io;
};

/* structure holding the nor api */
struct nor_interface {
        /* basic nor controller commands */
        int  (*scan_media)(device_t self, struct nor_chip *chip);
        void (*init) (device_t);
        void (*select) (device_t, bool); /* optional */
        void (*read_1) (device_t, flash_off_t, uint8_t *);
        void (*read_2) (device_t, flash_off_t, uint16_t *);
        void (*read_4) (device_t, flash_off_t, uint32_t *);
        void (*read_buf_1) (device_t, flash_off_t, uint8_t *, size_t);
        void (*read_buf_2) (device_t, flash_off_t, uint16_t *, size_t);
        void (*read_buf_4) (device_t, flash_off_t, uint32_t *, size_t);
        void (*write_1) (device_t, flash_off_t, uint8_t);
        void (*write_2) (device_t, flash_off_t, uint16_t);
        void (*write_4) (device_t, flash_off_t, uint32_t);
        void (*write_buf_1) (device_t, flash_off_t, const uint8_t *, size_t);
        void (*write_buf_2) (device_t, flash_off_t, const uint16_t *, size_t);
        void (*write_buf_4) (device_t, flash_off_t, const uint32_t *, size_t);
        int  (*busy) (device_t, flash_off_t, u_long);

        int (*read_page) (device_t, flash_off_t, uint8_t *);
        int (*program_page) (device_t, flash_off_t, const uint8_t *);
        int (*erase_block) (device_t, flash_off_t);
        int (*erase_all) (device_t);

        void *private;          /* where to attach e.g. struct cfi */
        int access_width;       /* x8/x16/x32: 1/2/4 */

        /* flash partition information */
        const struct flash_partition *part_info;
        int part_num;
};

/* attach args */
struct nor_attach_args {
        struct nor_interface *naa_nor_if;
};

static __inline bool
nor_busy(device_t device, flash_off_t offset, u_long usec)
{
        struct nor_softc *sc = device_private(device);
        bool rv;

        KASSERT(sc->sc_nor_if->select != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->select(sc->sc_controller_dev, true);

        if (sc->sc_nor_if->busy != NULL) {
                rv = sc->sc_nor_if->busy(sc->sc_controller_dev, offset, usec);
        } else {
                DELAY(usec);
                rv = false;
        }

        sc->sc_nor_if->select(sc->sc_controller_dev, false);

        return rv;
}

static __inline void
nor_select(device_t self, bool enable)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->select != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->select(sc->sc_controller_dev, enable);
}

static __inline void
nor_read_1(device_t self, flash_off_t offset, uint8_t *data)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->read_1 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->read_1(sc->sc_controller_dev, offset, data);
}

static __inline void
nor_read_2(device_t self, flash_off_t offset, uint16_t *data)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->read_2 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->read_2(sc->sc_controller_dev, offset, data);
}

static __inline void
nor_read_4(device_t self, flash_off_t offset, uint32_t *data)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->read_4 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->read_4(sc->sc_controller_dev, offset, data);
}

static __inline void
nor_write_1(device_t self, flash_off_t offset, uint8_t data)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->write_1 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->write_1(sc->sc_controller_dev, offset, data);
}

static __inline void
nor_write_2(device_t self, flash_off_t offset, uint16_t data)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->write_2 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->write_2(sc->sc_controller_dev, offset, data);
}

static __inline void
nor_write_4(device_t self, flash_off_t offset, uint16_t data)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->write_4 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->write_4(sc->sc_controller_dev, offset, data);
}

static __inline void
nor_read_buf_1(device_t self, flash_off_t offset, void *buf, size_t size)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->read_buf_1 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->read_buf_1(sc->sc_controller_dev, offset, buf, size);
}

static __inline void
nor_read_buf_2(device_t self, flash_off_t offset, void *buf, size_t size)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->read_buf_2 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->read_buf_2(sc->sc_controller_dev, offset, buf, size);
}

static __inline void
nor_read_buf_4(device_t self, flash_off_t offset, void *buf, size_t size)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->read_buf_4 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->read_buf_4(sc->sc_controller_dev, offset, buf, size);
}

static __inline void
nor_write_buf_1(device_t self, flash_off_t offset, const void *buf, size_t size)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->write_buf_1 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->write_buf_1(sc->sc_controller_dev, offset, buf, size);
}

static __inline void
nor_write_buf_2(device_t self, flash_off_t offset, const void *buf, size_t size)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->write_buf_2 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->write_buf_2(sc->sc_controller_dev, offset, buf, size);
}

static __inline void
nor_write_buf_4(device_t self, flash_off_t offset, const void *buf, size_t size)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->write_buf_4 != NULL);
        KASSERT(sc->sc_controller_dev != NULL);

        sc->sc_nor_if->write_buf_4(sc->sc_controller_dev, offset, buf, size);
}

static __inline int
nor_read_page(device_t self, flash_off_t offset, uint8_t *data)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->read_page != NULL);

        return sc->sc_nor_if->read_page(self, offset, data);
}

static __inline int
nor_program_page(device_t self, flash_off_t offset, const uint8_t *data)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->program_page != NULL);

        return sc->sc_nor_if->program_page(self, offset, data);
}

static __inline int
nor_erase_all(device_t self)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->erase_all != NULL);

        return sc->sc_nor_if->erase_all(self);
}

static __inline int
nor_erase_block(device_t self, flash_off_t offset)
{
        struct nor_softc *sc = device_private(self);

        KASSERT(sc->sc_nor_if->erase_block != NULL);

        return sc->sc_nor_if->erase_block(self, offset);
}

/* Manufacturer IDs defined by JEDEC */
enum {
        NOR_MFR_UNKNOWN         = 0x00,
        NOR_MFR_AMD             = 0x01,
        NOR_MFR_FUJITSU         = 0x04,
        NOR_MFR_RENESAS         = 0x07,
        NOR_MFR_STMICRO         = 0x20,
        NOR_MFR_MICRON          = 0x2c,
        NOR_MFR_NATIONAL        = 0x8f,
        NOR_MFR_TOSHIBA         = 0x98,
        NOR_MFR_HYNIX           = 0xad,
        NOR_MFGR_MACRONIX       = 0xc2,
        NOR_MFR_SAMSUNG         = 0xec
};

struct nor_manufacturer {
        int id;
        const char *name;
};

extern const struct nor_manufacturer nor_mfrs[];

/* public nor specific functions */
device_t nor_attach_mi(struct nor_interface *, device_t);
void nor_init_interface(struct nor_interface *);


#endif  /* _NOR_H_ */