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  */
nanddev_isbad(struct nand_device * nand,const struct nand_pos * pos)22 bool nanddev_isbad(struct nand_device *nand, const struct nand_pos *pos)
23 {
24 	if (mtd_check_expert_analysis_mode())
25 		return false;
26 
27 	if (nanddev_bbt_is_initialized(nand)) {
28 		unsigned int entry;
29 		int status;
30 
31 		entry = nanddev_bbt_pos_to_entry(nand, pos);
32 		status = nanddev_bbt_get_block_status(nand, entry);
33 		/* Lazy block status retrieval */
34 		if (status == NAND_BBT_BLOCK_STATUS_UNKNOWN) {
35 			if (nand->ops->isbad(nand, pos))
36 				status = NAND_BBT_BLOCK_FACTORY_BAD;
37 			else
38 				status = NAND_BBT_BLOCK_GOOD;
39 
40 			nanddev_bbt_set_block_status(nand, entry, status);
41 		}
42 
43 		if (status == NAND_BBT_BLOCK_WORN ||
44 		    status == NAND_BBT_BLOCK_FACTORY_BAD)
45 			return true;
46 
47 		return false;
48 	}
49 
50 	return nand->ops->isbad(nand, pos);
51 }
52 EXPORT_SYMBOL_GPL(nanddev_isbad);
53 
54 /**
55  * nanddev_markbad() - Mark a block as bad
56  * @nand: NAND device
57  * @pos: position of the block to mark bad
58  *
59  * Mark a block bad. This function is updating the BBT if available and
60  * calls the low-level markbad hook (nand->ops->markbad()).
61  *
62  * Return: 0 in case of success, a negative error code otherwise.
63  */
nanddev_markbad(struct nand_device * nand,const struct nand_pos * pos)64 int nanddev_markbad(struct nand_device *nand, const struct nand_pos *pos)
65 {
66 	struct mtd_info *mtd = nanddev_to_mtd(nand);
67 	unsigned int entry;
68 	int ret = 0;
69 
70 	if (nanddev_isbad(nand, pos))
71 		return 0;
72 
73 	ret = nand->ops->markbad(nand, pos);
74 	if (ret)
75 		pr_warn("failed to write BBM to block @%llx (err = %d)\n",
76 			nanddev_pos_to_offs(nand, pos), ret);
77 
78 	if (!nanddev_bbt_is_initialized(nand))
79 		goto out;
80 
81 	entry = nanddev_bbt_pos_to_entry(nand, pos);
82 	ret = nanddev_bbt_set_block_status(nand, entry, NAND_BBT_BLOCK_WORN);
83 	if (ret)
84 		goto out;
85 
86 	ret = nanddev_bbt_update(nand);
87 
88 out:
89 	if (!ret)
90 		mtd->ecc_stats.badblocks++;
91 
92 	return ret;
93 }
94 EXPORT_SYMBOL_GPL(nanddev_markbad);
95 
96 /**
97  * nanddev_isreserved() - Check whether an eraseblock is reserved or not
98  * @nand: NAND device
99  * @pos: NAND position to test
100  *
101  * Checks whether the eraseblock pointed by @pos is reserved or not.
102  *
103  * Return: true if the eraseblock is reserved, false otherwise.
104  */
nanddev_isreserved(struct nand_device * nand,const struct nand_pos * pos)105 bool nanddev_isreserved(struct nand_device *nand, const struct nand_pos *pos)
106 {
107 	unsigned int entry;
108 	int status;
109 
110 	if (!nanddev_bbt_is_initialized(nand))
111 		return false;
112 
113 	/* Return info from the table */
114 	entry = nanddev_bbt_pos_to_entry(nand, pos);
115 	status = nanddev_bbt_get_block_status(nand, entry);
116 	return status == NAND_BBT_BLOCK_RESERVED;
117 }
118 EXPORT_SYMBOL_GPL(nanddev_isreserved);
119 
120 /**
121  * nanddev_erase() - Erase a NAND portion
122  * @nand: NAND device
123  * @pos: position of the block to erase
124  *
125  * Erases the block if it's not bad.
126  *
127  * Return: 0 in case of success, a negative error code otherwise.
128  */
nanddev_erase(struct nand_device * nand,const struct nand_pos * pos)129 int nanddev_erase(struct nand_device *nand, const struct nand_pos *pos)
130 {
131 	if (nanddev_isbad(nand, pos) || nanddev_isreserved(nand, pos)) {
132 		pr_warn("attempt to erase a bad/reserved block @%llx\n",
133 			nanddev_pos_to_offs(nand, pos));
134 		return -EIO;
135 	}
136 
137 	return nand->ops->erase(nand, pos);
138 }
139 EXPORT_SYMBOL_GPL(nanddev_erase);
140 
141 /**
142  * nanddev_mtd_erase() - Generic mtd->_erase() implementation for NAND devices
143  * @mtd: MTD device
144  * @einfo: erase request
145  *
146  * This is a simple mtd->_erase() implementation iterating over all blocks
147  * concerned by @einfo and calling nand->ops->erase() on each of them.
148  *
149  * Note that mtd->_erase should not be directly assigned to this helper,
150  * because there's no locking here. NAND specialized layers should instead
151  * implement there own wrapper around nanddev_mtd_erase() taking the
152  * appropriate lock before calling nanddev_mtd_erase().
153  *
154  * Return: 0 in case of success, a negative error code otherwise.
155  */
nanddev_mtd_erase(struct mtd_info * mtd,struct erase_info * einfo)156 int nanddev_mtd_erase(struct mtd_info *mtd, struct erase_info *einfo)
157 {
158 	struct nand_device *nand = mtd_to_nanddev(mtd);
159 	struct nand_pos pos, last;
160 	int ret;
161 
162 	nanddev_offs_to_pos(nand, einfo->addr, &pos);
163 	nanddev_offs_to_pos(nand, einfo->addr + einfo->len - 1, &last);
164 	while (nanddev_pos_cmp(&pos, &last) <= 0) {
165 		ret = nanddev_erase(nand, &pos);
166 		if (ret) {
167 			einfo->fail_addr = nanddev_pos_to_offs(nand, &pos);
168 
169 			return ret;
170 		}
171 
172 		nanddev_pos_next_eraseblock(nand, &pos);
173 	}
174 
175 	return 0;
176 }
177 EXPORT_SYMBOL_GPL(nanddev_mtd_erase);
178 
179 /**
180  * nanddev_mtd_max_bad_blocks() - Get the maximum number of bad eraseblock on
181  *				  a specific region of the NAND device
182  * @mtd: MTD device
183  * @offs: offset of the NAND region
184  * @len: length of the NAND region
185  *
186  * Default implementation for mtd->_max_bad_blocks(). Only works if
187  * nand->memorg.max_bad_eraseblocks_per_lun is > 0.
188  *
189  * Return: a positive number encoding the maximum number of eraseblocks on a
190  * portion of memory, a negative error code otherwise.
191  */
nanddev_mtd_max_bad_blocks(struct mtd_info * mtd,loff_t offs,size_t len)192 int nanddev_mtd_max_bad_blocks(struct mtd_info *mtd, loff_t offs, size_t len)
193 {
194 	struct nand_device *nand = mtd_to_nanddev(mtd);
195 	struct nand_pos pos, end;
196 	unsigned int max_bb = 0;
197 
198 	if (!nand->memorg.max_bad_eraseblocks_per_lun)
199 		return -ENOTSUPP;
200 
201 	nanddev_offs_to_pos(nand, offs, &pos);
202 	nanddev_offs_to_pos(nand, offs + len, &end);
203 
204 	for (nanddev_offs_to_pos(nand, offs, &pos);
205 	     nanddev_pos_cmp(&pos, &end) < 0;
206 	     nanddev_pos_next_lun(nand, &pos))
207 		max_bb += nand->memorg.max_bad_eraseblocks_per_lun;
208 
209 	return max_bb;
210 }
211 EXPORT_SYMBOL_GPL(nanddev_mtd_max_bad_blocks);
212 
213 /**
214  * nanddev_get_ecc_engine() - Find and get a suitable ECC engine
215  * @nand: NAND device
216  */
nanddev_get_ecc_engine(struct nand_device * nand)217 static int nanddev_get_ecc_engine(struct nand_device *nand)
218 {
219 	int engine_type;
220 
221 	/* Read the user desires in terms of ECC engine/configuration */
222 	of_get_nand_ecc_user_config(nand);
223 
224 	engine_type = nand->ecc.user_conf.engine_type;
225 	if (engine_type == NAND_ECC_ENGINE_TYPE_INVALID)
226 		engine_type = nand->ecc.defaults.engine_type;
227 
228 	switch (engine_type) {
229 	case NAND_ECC_ENGINE_TYPE_NONE:
230 		return 0;
231 	case NAND_ECC_ENGINE_TYPE_SOFT:
232 		nand->ecc.engine = nand_ecc_get_sw_engine(nand);
233 		break;
234 	case NAND_ECC_ENGINE_TYPE_ON_DIE:
235 		nand->ecc.engine = nand_ecc_get_on_die_hw_engine(nand);
236 		break;
237 	case NAND_ECC_ENGINE_TYPE_ON_HOST:
238 		nand->ecc.engine = nand_ecc_get_on_host_hw_engine(nand);
239 		if (PTR_ERR(nand->ecc.engine) == -EPROBE_DEFER)
240 			return -EPROBE_DEFER;
241 		break;
242 	default:
243 		pr_err("Missing ECC engine type\n");
244 	}
245 
246 	if (!nand->ecc.engine)
247 		return  -EINVAL;
248 
249 	return 0;
250 }
251 
252 /**
253  * nanddev_put_ecc_engine() - Dettach and put the in-use ECC engine
254  * @nand: NAND device
255  */
nanddev_put_ecc_engine(struct nand_device * nand)256 static int nanddev_put_ecc_engine(struct nand_device *nand)
257 {
258 	switch (nand->ecc.ctx.conf.engine_type) {
259 	case NAND_ECC_ENGINE_TYPE_ON_HOST:
260 		nand_ecc_put_on_host_hw_engine(nand);
261 		break;
262 	case NAND_ECC_ENGINE_TYPE_NONE:
263 	case NAND_ECC_ENGINE_TYPE_SOFT:
264 	case NAND_ECC_ENGINE_TYPE_ON_DIE:
265 	default:
266 		break;
267 	}
268 
269 	return 0;
270 }
271 
272 /**
273  * nanddev_find_ecc_configuration() - Find a suitable ECC configuration
274  * @nand: NAND device
275  */
nanddev_find_ecc_configuration(struct nand_device * nand)276 static int nanddev_find_ecc_configuration(struct nand_device *nand)
277 {
278 	int ret;
279 
280 	if (!nand->ecc.engine)
281 		return -ENOTSUPP;
282 
283 	ret = nand_ecc_init_ctx(nand);
284 	if (ret)
285 		return ret;
286 
287 	if (!nand_ecc_is_strong_enough(nand))
288 		pr_warn("WARNING: %s: the ECC used on your system is too weak compared to the one required by the NAND chip\n",
289 			nand->mtd.name);
290 
291 	return 0;
292 }
293 
294 /**
295  * nanddev_ecc_engine_init() - Initialize an ECC engine for the chip
296  * @nand: NAND device
297  */
nanddev_ecc_engine_init(struct nand_device * nand)298 int nanddev_ecc_engine_init(struct nand_device *nand)
299 {
300 	int ret;
301 
302 	/* Look for the ECC engine to use */
303 	ret = nanddev_get_ecc_engine(nand);
304 	if (ret) {
305 		if (ret != -EPROBE_DEFER)
306 			pr_err("No ECC engine found\n");
307 
308 		return ret;
309 	}
310 
311 	/* No ECC engine requested */
312 	if (!nand->ecc.engine)
313 		return 0;
314 
315 	/* Configure the engine: balance user input and chip requirements */
316 	ret = nanddev_find_ecc_configuration(nand);
317 	if (ret) {
318 		pr_err("No suitable ECC configuration\n");
319 		nanddev_put_ecc_engine(nand);
320 
321 		return ret;
322 	}
323 
324 	return 0;
325 }
326 EXPORT_SYMBOL_GPL(nanddev_ecc_engine_init);
327 
328 /**
329  * nanddev_ecc_engine_cleanup() - Cleanup ECC engine initializations
330  * @nand: NAND device
331  */
nanddev_ecc_engine_cleanup(struct nand_device * nand)332 void nanddev_ecc_engine_cleanup(struct nand_device *nand)
333 {
334 	if (nand->ecc.engine)
335 		nand_ecc_cleanup_ctx(nand);
336 
337 	nanddev_put_ecc_engine(nand);
338 }
339 EXPORT_SYMBOL_GPL(nanddev_ecc_engine_cleanup);
340 
341 /**
342  * nanddev_init() - Initialize a NAND device
343  * @nand: NAND device
344  * @ops: NAND device operations
345  * @owner: NAND device owner
346  *
347  * Initializes a NAND device object. Consistency checks are done on @ops and
348  * @nand->memorg. Also takes care of initializing the BBT.
349  *
350  * Return: 0 in case of success, a negative error code otherwise.
351  */
nanddev_init(struct nand_device * nand,const struct nand_ops * ops,struct module * owner)352 int nanddev_init(struct nand_device *nand, const struct nand_ops *ops,
353 		 struct module *owner)
354 {
355 	struct mtd_info *mtd = nanddev_to_mtd(nand);
356 	struct nand_memory_organization *memorg = nanddev_get_memorg(nand);
357 
358 	if (!nand || !ops)
359 		return -EINVAL;
360 
361 	if (!ops->erase || !ops->markbad || !ops->isbad)
362 		return -EINVAL;
363 
364 	if (!memorg->bits_per_cell || !memorg->pagesize ||
365 	    !memorg->pages_per_eraseblock || !memorg->eraseblocks_per_lun ||
366 	    !memorg->planes_per_lun || !memorg->luns_per_target ||
367 	    !memorg->ntargets)
368 		return -EINVAL;
369 
370 	nand->rowconv.eraseblock_addr_shift =
371 					fls(memorg->pages_per_eraseblock - 1);
372 	nand->rowconv.lun_addr_shift = fls(memorg->eraseblocks_per_lun - 1) +
373 				       nand->rowconv.eraseblock_addr_shift;
374 
375 	nand->ops = ops;
376 
377 	mtd->type = memorg->bits_per_cell == 1 ?
378 		    MTD_NANDFLASH : MTD_MLCNANDFLASH;
379 	mtd->flags = MTD_CAP_NANDFLASH;
380 	mtd->erasesize = memorg->pagesize * memorg->pages_per_eraseblock;
381 	mtd->writesize = memorg->pagesize;
382 	mtd->writebufsize = memorg->pagesize;
383 	mtd->oobsize = memorg->oobsize;
384 	mtd->size = nanddev_size(nand);
385 	mtd->owner = owner;
386 
387 	return nanddev_bbt_init(nand);
388 }
389 EXPORT_SYMBOL_GPL(nanddev_init);
390 
391 /**
392  * nanddev_cleanup() - Release resources allocated in nanddev_init()
393  * @nand: NAND device
394  *
395  * Basically undoes what has been done in nanddev_init().
396  */
nanddev_cleanup(struct nand_device * nand)397 void nanddev_cleanup(struct nand_device *nand)
398 {
399 	if (nanddev_bbt_is_initialized(nand))
400 		nanddev_bbt_cleanup(nand);
401 }
402 EXPORT_SYMBOL_GPL(nanddev_cleanup);
403 
404 MODULE_DESCRIPTION("Generic NAND framework");
405 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>");
406 MODULE_LICENSE("GPL v2");
407