/*      $NetBSD: nand_bbt.c,v 1.8 2018/02/08 07:48:19 mrg 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.
 */

/*
 * Implementation of Bad Block Tables (BBTs).
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: nand_bbt.c,v 1.8 2018/02/08 07:48:19 mrg Exp $");

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

#include "nand.h"
#include "nand_bbt.h"

void
nand_bbt_init(device_t self)
{
        struct nand_softc *sc = device_private(self);
        struct nand_chip *chip = &sc->sc_chip;
        struct nand_bbt *bbt = &sc->sc_bbt;

        bbt->nbbt_size = chip->nc_size / chip->nc_block_size / 4;
        bbt->nbbt_bitmap = kmem_alloc(bbt->nbbt_size, KM_SLEEP);

        memset(bbt->nbbt_bitmap, 0xff, bbt->nbbt_size);
}

void
nand_bbt_detach(device_t self)
{
        struct nand_softc *sc = device_private(self);
        struct nand_bbt *bbt = &sc->sc_bbt;

        kmem_free(bbt->nbbt_bitmap, bbt->nbbt_size);
}

void
nand_bbt_scan(device_t self)
{
        struct nand_softc *sc = device_private(self);
        struct nand_chip *chip = &sc->sc_chip;
        flash_off_t i, blocks, addr;

        blocks = chip->nc_size / chip->nc_block_size;

        aprint_normal_dev(self, "scanning for bad blocks\n");

        addr = 0;
        for (i = 0; i < blocks; i++) {
                if (nand_isfactorybad(self, addr)) {
                        nand_bbt_block_markfactorybad(self, i);
                } else if (nand_iswornoutbad(self, addr)) {
                        nand_bbt_block_markbad(self, i);
                }

                addr += chip->nc_block_size;
        }
}

bool
nand_bbt_update(device_t self)
{
        return true;
}

static bool
nand_bbt_page_has_bbt(device_t self, flash_off_t addr) {
        struct nand_softc *sc = device_private(self);
        struct nand_chip *chip = &sc->sc_chip;
        uint8_t *oob = chip->nc_oob_cache;

        nand_read_oob(self, addr, oob);

        if (oob[NAND_BBT_OFFSET] == 'B' &&
            oob[NAND_BBT_OFFSET + 1] == 'b' &&
            oob[NAND_BBT_OFFSET + 2] == 't') {
                return true;
        } else {
                return false;
        }
}

static bool
nand_bbt_get_bbt_from_page(device_t self, flash_off_t addr)
{
        struct nand_softc *sc = device_private(self);
        struct nand_chip *chip = &sc->sc_chip;
        struct nand_bbt *bbt = &sc->sc_bbt;
        uint8_t *bbtp, *buf = chip->nc_page_cache;
        size_t left, bbt_pages, i;

        bbt_pages = bbt->nbbt_size / chip->nc_page_size;
        if (bbt->nbbt_size % chip->nc_page_size)
                bbt_pages++;
        
        if (nand_isbad(self, addr)) {
                return false;
        }

        if (nand_bbt_page_has_bbt(self, addr)) {
                bbtp = bbt->nbbt_bitmap;
                left = bbt->nbbt_size;

                for (i = 0; i < bbt_pages; i++) {
                        nand_read_page(self, addr, buf);

                        if (i == bbt_pages - 1) {
                                KASSERT(left <= chip->nc_page_size);
                                memcpy(bbtp, buf, left);
                        } else {
                                memcpy(bbtp, buf, chip->nc_page_size);
                        }

                        bbtp += chip->nc_page_size;
                        left -= chip->nc_page_size;
                        addr += chip->nc_page_size;
                }

                return true;
        } else {
                return false;
        }
}

bool
nand_bbt_load(device_t self)
{
        struct nand_softc *sc = device_private(self);
        struct nand_chip *chip = &sc->sc_chip;
        flash_off_t blockaddr;
        int n;

        blockaddr = chip->nc_size - chip->nc_block_size;
        /* XXX currently we check the last 4 blocks */
        for (n = 0; n < 4; n++) {
                if (nand_bbt_get_bbt_from_page(self, blockaddr)) {
                        break;
                } else {
                        blockaddr -= chip->nc_block_size;
                }
        }

        return true;
}

void
nand_bbt_block_markbad(device_t self, flash_off_t block)
{
        if (nand_bbt_block_isbad(self, block)) {
                aprint_error_dev(self,
                    "trying to mark block bad already marked in bbt\n");
        }
        /* XXX check if this is the correct marker */
        nand_bbt_block_mark(self, block, NAND_BBT_MARKER_WORNOUT_BAD);
}

void
nand_bbt_block_markfactorybad(device_t self, flash_off_t block)
{
        if (nand_bbt_block_isbad(self, block)) {
                aprint_error_dev(self,
                    "trying to mark block factory bad already"
                    " marked in bbt\n");
        }
        nand_bbt_block_mark(self, block, NAND_BBT_MARKER_FACTORY_BAD);
}

void
nand_bbt_block_mark(device_t self, flash_off_t block, uint8_t marker)
{
        struct nand_softc *sc = device_private(self);
        struct nand_chip *chip = &sc->sc_chip;
        struct nand_bbt *bbt = &sc->sc_bbt;
        uint8_t clean;

        __USE(chip);
        KASSERT(block < chip->nc_size / chip->nc_block_size);

        clean = (0xfc << ((block % 4) * 2));
        marker = (marker << ((block % 4) * 2));

        /* set byte containing the 2 bit marker for this block */
        bbt->nbbt_bitmap[block / 4] &= clean;
        bbt->nbbt_bitmap[block / 4] |= marker;
}

bool
nand_bbt_block_isbad(device_t self, flash_off_t block)
{
        struct nand_softc *sc = device_private(self);
        struct nand_chip *chip = &sc->sc_chip;
        struct nand_bbt *bbt = &sc->sc_bbt;
        uint8_t byte, marker;
        bool result;

        __USE(chip);
        KASSERT(block < chip->nc_size / chip->nc_block_size);

        /* get byte containing the 2 bit marker for this block */
        byte = bbt->nbbt_bitmap[block / 4];

        /* extract the 2 bit marker from the byte */
        marker = (byte >> ((block % 4) * 2)) & 0x03;

        switch (marker) {
        case NAND_BBT_MARKER_FACTORY_BAD:
        case NAND_BBT_MARKER_WORNOUT_BAD:
        case NAND_BBT_MARKER_RESERVED:
                result = true;
                break;
        case NAND_BBT_MARKER_GOOD:
                result = false;
                break;
        default:
                panic("error in marker extraction");
        }

        return result;
}