/*      $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 <[email protected]>
* 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;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.