// SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2017 Free Electrons * * Authors: * Boris Brezillon * Peter Pan */ #define pr_fmt(fmt) "nand: " fmt #include #include /** * nanddev_isbad() - Check if a block is bad * @nand: NAND device * @pos: position pointing to the block we want to check * * Return: true if the block is bad, false otherwise. */ bool nanddev_isbad(struct nand_device *nand, const struct nand_pos *pos) { if (nanddev_bbt_is_initialized(nand)) { unsigned int entry; int status; entry = nanddev_bbt_pos_to_entry(nand, pos); status = nanddev_bbt_get_block_status(nand, entry); /* Lazy block status retrieval */ if (status == NAND_BBT_BLOCK_STATUS_UNKNOWN) { if (nand->ops->isbad(nand, pos)) status = NAND_BBT_BLOCK_FACTORY_BAD; else status = NAND_BBT_BLOCK_GOOD; nanddev_bbt_set_block_status(nand, entry, status); } if (status == NAND_BBT_BLOCK_WORN || status == NAND_BBT_BLOCK_FACTORY_BAD) return true; return false; } return nand->ops->isbad(nand, pos); } EXPORT_SYMBOL_GPL(nanddev_isbad); /** * nanddev_markbad() - Mark a block as bad * @nand: NAND device * @pos: position of the block to mark bad * * Mark a block bad. This function is updating the BBT if available and * calls the low-level markbad hook (nand->ops->markbad()). * * Return: 0 in case of success, a negative error code otherwise. */ int nanddev_markbad(struct nand_device *nand, const struct nand_pos *pos) { struct mtd_info *mtd = nanddev_to_mtd(nand); unsigned int entry; int ret = 0; if (nanddev_isbad(nand, pos)) return 0; ret = nand->ops->markbad(nand, pos); if (ret) pr_warn("failed to write BBM to block @%llx (err = %d)\n", nanddev_pos_to_offs(nand, pos), ret); if (!nanddev_bbt_is_initialized(nand)) goto out; entry = nanddev_bbt_pos_to_entry(nand, pos); ret = nanddev_bbt_set_block_status(nand, entry, NAND_BBT_BLOCK_WORN); if (ret) goto out; ret = nanddev_bbt_update(nand); out: if (!ret) mtd->ecc_stats.badblocks++; return ret; } EXPORT_SYMBOL_GPL(nanddev_markbad); /** * nanddev_isreserved() - Check whether an eraseblock is reserved or not * @nand: NAND device * @pos: NAND position to test * * Checks whether the eraseblock pointed by @pos is reserved or not. * * Return: true if the eraseblock is reserved, false otherwise. */ bool nanddev_isreserved(struct nand_device *nand, const struct nand_pos *pos) { unsigned int entry; int status; if (!nanddev_bbt_is_initialized(nand)) return false; /* Return info from the table */ entry = nanddev_bbt_pos_to_entry(nand, pos); status = nanddev_bbt_get_block_status(nand, entry); return status == NAND_BBT_BLOCK_RESERVED; } EXPORT_SYMBOL_GPL(nanddev_isreserved); /** * nanddev_erase() - Erase a NAND portion * @nand: NAND device * @pos: position of the block to erase * * Erases the block if it's not bad. * * Return: 0 in case of success, a negative error code otherwise. */ int nanddev_erase(struct nand_device *nand, const struct nand_pos *pos) { if (nanddev_isbad(nand, pos) || nanddev_isreserved(nand, pos)) { pr_warn("attempt to erase a bad/reserved block @%llx\n", nanddev_pos_to_offs(nand, pos)); return -EIO; } return nand->ops->erase(nand, pos); } EXPORT_SYMBOL_GPL(nanddev_erase); /** * nanddev_mtd_erase() - Generic mtd->_erase() implementation for NAND devices * @mtd: MTD device * @einfo: erase request * * This is a simple mtd->_erase() implementation iterating over all blocks * concerned by @einfo and calling nand->ops->erase() on each of them. * * Note that mtd->_erase should not be directly assigned to this helper, * because there's no locking here. NAND specialized layers should instead * implement there own wrapper around nanddev_mtd_erase() taking the * appropriate lock before calling nanddev_mtd_erase(). * * Return: 0 in case of success, a negative error code otherwise. */ int nanddev_mtd_erase(struct mtd_info *mtd, struct erase_info *einfo) { struct nand_device *nand = mtd_to_nanddev(mtd); struct nand_pos pos, last; int ret; nanddev_offs_to_pos(nand, einfo->addr, &pos); nanddev_offs_to_pos(nand, einfo->addr + einfo->len - 1, &last); while (nanddev_pos_cmp(&pos, &last) <= 0) { ret = nanddev_erase(nand, &pos); if (ret) { einfo->fail_addr = nanddev_pos_to_offs(nand, &pos); return ret; } nanddev_pos_next_eraseblock(nand, &pos); } return 0; } EXPORT_SYMBOL_GPL(nanddev_mtd_erase); /** * nanddev_mtd_max_bad_blocks() - Get the maximum number of bad eraseblock on * a specific region of the NAND device * @mtd: MTD device * @offs: offset of the NAND region * @len: length of the NAND region * * Default implementation for mtd->_max_bad_blocks(). Only works if * nand->memorg.max_bad_eraseblocks_per_lun is > 0. * * Return: a positive number encoding the maximum number of eraseblocks on a * portion of memory, a negative error code otherwise. */ int nanddev_mtd_max_bad_blocks(struct mtd_info *mtd, loff_t offs, size_t len) { struct nand_device *nand = mtd_to_nanddev(mtd); struct nand_pos pos, end; unsigned int max_bb = 0; if (!nand->memorg.max_bad_eraseblocks_per_lun) return -ENOTSUPP; nanddev_offs_to_pos(nand, offs, &pos); nanddev_offs_to_pos(nand, offs + len, &end); for (nanddev_offs_to_pos(nand, offs, &pos); nanddev_pos_cmp(&pos, &end) < 0; nanddev_pos_next_lun(nand, &pos)) max_bb += nand->memorg.max_bad_eraseblocks_per_lun; return max_bb; } EXPORT_SYMBOL_GPL(nanddev_mtd_max_bad_blocks); /** * nanddev_init() - Initialize a NAND device * @nand: NAND device * @ops: NAND device operations * @owner: NAND device owner * * Initializes a NAND device object. Consistency checks are done on @ops and * @nand->memorg. Also takes care of initializing the BBT. * * Return: 0 in case of success, a negative error code otherwise. */ int nanddev_init(struct nand_device *nand, const struct nand_ops *ops, struct module *owner) { struct mtd_info *mtd = nanddev_to_mtd(nand); struct nand_memory_organization *memorg = nanddev_get_memorg(nand); if (!nand || !ops) return -EINVAL; if (!ops->erase || !ops->markbad || !ops->isbad) return -EINVAL; if (!memorg->bits_per_cell || !memorg->pagesize || !memorg->pages_per_eraseblock || !memorg->eraseblocks_per_lun || !memorg->planes_per_lun || !memorg->luns_per_target || !memorg->ntargets) return -EINVAL; nand->rowconv.eraseblock_addr_shift = fls(memorg->pages_per_eraseblock - 1); nand->rowconv.lun_addr_shift = fls(memorg->eraseblocks_per_lun - 1) + nand->rowconv.eraseblock_addr_shift; nand->ops = ops; mtd->type = memorg->bits_per_cell == 1 ? MTD_NANDFLASH : MTD_MLCNANDFLASH; mtd->flags = MTD_CAP_NANDFLASH; mtd->erasesize = memorg->pagesize * memorg->pages_per_eraseblock; mtd->writesize = memorg->pagesize; mtd->writebufsize = memorg->pagesize; mtd->oobsize = memorg->oobsize; mtd->size = nanddev_size(nand); mtd->owner = owner; return nanddev_bbt_init(nand); } EXPORT_SYMBOL_GPL(nanddev_init); /** * nanddev_cleanup() - Release resources allocated in nanddev_init() * @nand: NAND device * * Basically undoes what has been done in nanddev_init(). */ void nanddev_cleanup(struct nand_device *nand) { if (nanddev_bbt_is_initialized(nand)) nanddev_bbt_cleanup(nand); } EXPORT_SYMBOL_GPL(nanddev_cleanup); MODULE_DESCRIPTION("Generic NAND framework"); MODULE_AUTHOR("Boris Brezillon "); MODULE_LICENSE("GPL v2");