1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2017 Free Electrons 4 * 5 * Authors: 6 * Boris Brezillon <boris.brezillon@free-electrons.com> 7 * Peter Pan <peterpandong@micron.com> 8 */ 9 10 #define pr_fmt(fmt) "nand: " fmt 11 12 #include <linux/module.h> 13 #include <linux/mtd/nand.h> 14 15 /** 16 * nanddev_isbad() - Check if a block is bad 17 * @nand: NAND device 18 * @pos: position pointing to the block we want to check 19 * 20 * Return: true if the block is bad, false otherwise. 21 */ 22 bool nanddev_isbad(struct nand_device *nand, const struct nand_pos *pos) 23 { 24 if (nanddev_bbt_is_initialized(nand)) { 25 unsigned int entry; 26 int status; 27 28 entry = nanddev_bbt_pos_to_entry(nand, pos); 29 status = nanddev_bbt_get_block_status(nand, entry); 30 /* Lazy block status retrieval */ 31 if (status == NAND_BBT_BLOCK_STATUS_UNKNOWN) { 32 if (nand->ops->isbad(nand, pos)) 33 status = NAND_BBT_BLOCK_FACTORY_BAD; 34 else 35 status = NAND_BBT_BLOCK_GOOD; 36 37 nanddev_bbt_set_block_status(nand, entry, status); 38 } 39 40 if (status == NAND_BBT_BLOCK_WORN || 41 status == NAND_BBT_BLOCK_FACTORY_BAD) 42 return true; 43 44 return false; 45 } 46 47 return nand->ops->isbad(nand, pos); 48 } 49 EXPORT_SYMBOL_GPL(nanddev_isbad); 50 51 /** 52 * nanddev_markbad() - Mark a block as bad 53 * @nand: NAND device 54 * @pos: position of the block to mark bad 55 * 56 * Mark a block bad. This function is updating the BBT if available and 57 * calls the low-level markbad hook (nand->ops->markbad()). 58 * 59 * Return: 0 in case of success, a negative error code otherwise. 60 */ 61 int nanddev_markbad(struct nand_device *nand, const struct nand_pos *pos) 62 { 63 struct mtd_info *mtd = nanddev_to_mtd(nand); 64 unsigned int entry; 65 int ret = 0; 66 67 if (nanddev_isbad(nand, pos)) 68 return 0; 69 70 ret = nand->ops->markbad(nand, pos); 71 if (ret) 72 pr_warn("failed to write BBM to block @%llx (err = %d)\n", 73 nanddev_pos_to_offs(nand, pos), ret); 74 75 if (!nanddev_bbt_is_initialized(nand)) 76 goto out; 77 78 entry = nanddev_bbt_pos_to_entry(nand, pos); 79 ret = nanddev_bbt_set_block_status(nand, entry, NAND_BBT_BLOCK_WORN); 80 if (ret) 81 goto out; 82 83 ret = nanddev_bbt_update(nand); 84 85 out: 86 if (!ret) 87 mtd->ecc_stats.badblocks++; 88 89 return ret; 90 } 91 EXPORT_SYMBOL_GPL(nanddev_markbad); 92 93 /** 94 * nanddev_isreserved() - Check whether an eraseblock is reserved or not 95 * @nand: NAND device 96 * @pos: NAND position to test 97 * 98 * Checks whether the eraseblock pointed by @pos is reserved or not. 99 * 100 * Return: true if the eraseblock is reserved, false otherwise. 101 */ 102 bool nanddev_isreserved(struct nand_device *nand, const struct nand_pos *pos) 103 { 104 unsigned int entry; 105 int status; 106 107 if (!nanddev_bbt_is_initialized(nand)) 108 return false; 109 110 /* Return info from the table */ 111 entry = nanddev_bbt_pos_to_entry(nand, pos); 112 status = nanddev_bbt_get_block_status(nand, entry); 113 return status == NAND_BBT_BLOCK_RESERVED; 114 } 115 EXPORT_SYMBOL_GPL(nanddev_isreserved); 116 117 /** 118 * nanddev_erase() - Erase a NAND portion 119 * @nand: NAND device 120 * @pos: position of the block to erase 121 * 122 * Erases the block if it's not bad. 123 * 124 * Return: 0 in case of success, a negative error code otherwise. 125 */ 126 int nanddev_erase(struct nand_device *nand, const struct nand_pos *pos) 127 { 128 if (nanddev_isbad(nand, pos) || nanddev_isreserved(nand, pos)) { 129 pr_warn("attempt to erase a bad/reserved block @%llx\n", 130 nanddev_pos_to_offs(nand, pos)); 131 return -EIO; 132 } 133 134 return nand->ops->erase(nand, pos); 135 } 136 EXPORT_SYMBOL_GPL(nanddev_erase); 137 138 /** 139 * nanddev_mtd_erase() - Generic mtd->_erase() implementation for NAND devices 140 * @mtd: MTD device 141 * @einfo: erase request 142 * 143 * This is a simple mtd->_erase() implementation iterating over all blocks 144 * concerned by @einfo and calling nand->ops->erase() on each of them. 145 * 146 * Note that mtd->_erase should not be directly assigned to this helper, 147 * because there's no locking here. NAND specialized layers should instead 148 * implement there own wrapper around nanddev_mtd_erase() taking the 149 * appropriate lock before calling nanddev_mtd_erase(). 150 * 151 * Return: 0 in case of success, a negative error code otherwise. 152 */ 153 int nanddev_mtd_erase(struct mtd_info *mtd, struct erase_info *einfo) 154 { 155 struct nand_device *nand = mtd_to_nanddev(mtd); 156 struct nand_pos pos, last; 157 int ret; 158 159 nanddev_offs_to_pos(nand, einfo->addr, &pos); 160 nanddev_offs_to_pos(nand, einfo->addr + einfo->len - 1, &last); 161 while (nanddev_pos_cmp(&pos, &last) <= 0) { 162 ret = nanddev_erase(nand, &pos); 163 if (ret) { 164 einfo->fail_addr = nanddev_pos_to_offs(nand, &pos); 165 einfo->state = MTD_ERASE_FAILED; 166 167 return ret; 168 } 169 170 nanddev_pos_next_eraseblock(nand, &pos); 171 } 172 173 einfo->state = MTD_ERASE_DONE; 174 175 return 0; 176 } 177 EXPORT_SYMBOL_GPL(nanddev_mtd_erase); 178 179 /** 180 * nanddev_init() - Initialize a NAND device 181 * @nand: NAND device 182 * @ops: NAND device operations 183 * @owner: NAND device owner 184 * 185 * Initializes a NAND device object. Consistency checks are done on @ops and 186 * @nand->memorg. Also takes care of initializing the BBT. 187 * 188 * Return: 0 in case of success, a negative error code otherwise. 189 */ 190 int nanddev_init(struct nand_device *nand, const struct nand_ops *ops, 191 struct module *owner) 192 { 193 struct mtd_info *mtd = nanddev_to_mtd(nand); 194 struct nand_memory_organization *memorg = nanddev_get_memorg(nand); 195 196 if (!nand || !ops) 197 return -EINVAL; 198 199 if (!ops->erase || !ops->markbad || !ops->isbad) 200 return -EINVAL; 201 202 if (!memorg->bits_per_cell || !memorg->pagesize || 203 !memorg->pages_per_eraseblock || !memorg->eraseblocks_per_lun || 204 !memorg->planes_per_lun || !memorg->luns_per_target || 205 !memorg->ntargets) 206 return -EINVAL; 207 208 nand->rowconv.eraseblock_addr_shift = 209 fls(memorg->pages_per_eraseblock - 1); 210 nand->rowconv.lun_addr_shift = fls(memorg->eraseblocks_per_lun - 1) + 211 nand->rowconv.eraseblock_addr_shift; 212 213 nand->ops = ops; 214 215 mtd->type = memorg->bits_per_cell == 1 ? 216 MTD_NANDFLASH : MTD_MLCNANDFLASH; 217 mtd->flags = MTD_CAP_NANDFLASH; 218 mtd->erasesize = memorg->pagesize * memorg->pages_per_eraseblock; 219 mtd->writesize = memorg->pagesize; 220 mtd->writebufsize = memorg->pagesize; 221 mtd->oobsize = memorg->oobsize; 222 mtd->size = nanddev_size(nand); 223 mtd->owner = owner; 224 225 return nanddev_bbt_init(nand); 226 } 227 EXPORT_SYMBOL_GPL(nanddev_init); 228 229 /** 230 * nanddev_cleanup() - Release resources allocated in nanddev_init() 231 * @nand: NAND device 232 * 233 * Basically undoes what has been done in nanddev_init(). 234 */ 235 void nanddev_cleanup(struct nand_device *nand) 236 { 237 if (nanddev_bbt_is_initialized(nand)) 238 nanddev_bbt_cleanup(nand); 239 } 240 EXPORT_SYMBOL_GPL(nanddev_cleanup); 241 242 MODULE_DESCRIPTION("Generic NAND framework"); 243 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>"); 244 MODULE_LICENSE("GPL v2"); 245