1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2021 Rockchip Electronics Co. Ltd.
4 *
5 */
6
7 #include <linux/mtd/bbt_store.h>
8 #include <linux/slab.h>
9
10 #ifdef BBT_DEBUG
11 #define BBT_DBG pr_err
12 #else
13 #define BBT_DBG(args...)
14 #endif
15
16 struct nanddev_bbt_info {
17 u8 pattern[4];
18 unsigned int version;
19 };
20
21 static u8 bbt_pattern[] = {'B', 'b', 't', '0' };
22
nanddev_read_bbt(struct nand_device * nand,u32 block,bool update)23 static int nanddev_read_bbt(struct nand_device *nand, u32 block, bool update)
24 {
25 unsigned int bits_per_block = fls(NAND_BBT_BLOCK_NUM_STATUS);
26 unsigned int nblocks = nanddev_neraseblocks(nand);
27 unsigned int nbytes = DIV_ROUND_UP(nblocks * bits_per_block,
28 BITS_PER_LONG) * sizeof(*nand->bbt.cache);
29 struct mtd_info *mtd = nanddev_to_mtd(nand);
30 u8 *data_buf, *oob_buf;
31 struct nanddev_bbt_info *bbt_info;
32 struct mtd_oob_ops ops;
33 int bbt_page_num;
34 int ret = 0;
35 unsigned int version = 0;
36
37 if (!nand->bbt.cache)
38 return -ENOMEM;
39
40 if (block >= nblocks)
41 return -EINVAL;
42
43 /* Aligned to page size, and even pages is better */
44 bbt_page_num = (sizeof(struct nanddev_bbt_info) + nbytes +
45 mtd->writesize - 1) >> (ffs(mtd->writesize) - 1);
46 bbt_page_num = (bbt_page_num + 1) / 2 * 2;
47 data_buf = kzalloc(bbt_page_num * mtd->writesize, GFP_KERNEL);
48 if (!data_buf)
49 return -ENOMEM;
50 oob_buf = kzalloc(bbt_page_num * mtd->oobsize, GFP_KERNEL);
51 if (!oob_buf) {
52 kfree(data_buf);
53
54 return -ENOMEM;
55 }
56
57 bbt_info = (struct nanddev_bbt_info *)(data_buf + nbytes);
58
59 memset(&ops, 0, sizeof(struct mtd_oob_ops));
60 ops.mode = MTD_OPS_PLACE_OOB;
61 ops.datbuf = data_buf;
62 ops.len = bbt_page_num * mtd->writesize;
63 ops.oobbuf = oob_buf;
64 ops.ooblen = bbt_page_num * mtd->oobsize;
65 ops.ooboffs = 0;
66
67 ret = mtd_read_oob(mtd, block * mtd->erasesize, &ops);
68 if (ret && ret != -EUCLEAN) {
69 pr_err("%s fail %d\n", __func__, ret);
70 ret = -EIO;
71 goto out;
72 } else {
73 ret = 0;
74 }
75
76 if (oob_buf[0] != 0xff && !memcmp(bbt_pattern, bbt_info->pattern, 4))
77 version = bbt_info->version;
78
79 BBT_DBG("read_bbt from blk=%d tag=%d ver=%d\n", block, update, version);
80 if (update && version > nand->bbt.version) {
81 memcpy(nand->bbt.cache, data_buf, nbytes);
82 nand->bbt.version = version;
83 }
84
85 out:
86 kfree(oob_buf);
87 kfree(data_buf);
88
89 return ret < 0 ? -EIO : version;
90 }
91
nanddev_write_bbt(struct nand_device * nand,u32 block)92 static int nanddev_write_bbt(struct nand_device *nand, u32 block)
93 {
94 unsigned int bits_per_block = fls(NAND_BBT_BLOCK_NUM_STATUS);
95 unsigned int nblocks = nanddev_neraseblocks(nand);
96 unsigned int nbytes = DIV_ROUND_UP(nblocks * bits_per_block,
97 BITS_PER_LONG) * sizeof(*nand->bbt.cache);
98 struct mtd_info *mtd = nanddev_to_mtd(nand);
99 u8 *data_buf, *oob_buf;
100 struct nanddev_bbt_info *bbt_info;
101 struct mtd_oob_ops ops;
102 int bbt_page_num;
103 int ret = 0;
104 struct nand_pos pos;
105
106 BBT_DBG("write_bbt to blk=%d ver=%d\n", block, nand->bbt.version);
107 if (!nand->bbt.cache)
108 return -ENOMEM;
109
110 if (block >= nblocks)
111 return -EINVAL;
112
113 /* Aligned to page size, and even pages is better */
114 bbt_page_num = (sizeof(struct nanddev_bbt_info) + nbytes +
115 mtd->writesize - 1) >> (ffs(mtd->writesize) - 1);
116 bbt_page_num = (bbt_page_num + 1) / 2 * 2;
117
118 data_buf = kzalloc(bbt_page_num * mtd->writesize, GFP_KERNEL);
119 if (!data_buf)
120 return -ENOMEM;
121 oob_buf = kzalloc(bbt_page_num * mtd->oobsize, GFP_KERNEL);
122 if (!oob_buf) {
123 kfree(data_buf);
124
125 return -ENOMEM;
126 }
127
128 bbt_info = (struct nanddev_bbt_info *)(data_buf + nbytes);
129
130 memcpy(data_buf, nand->bbt.cache, nbytes);
131 memcpy(bbt_info, bbt_pattern, 4);
132 bbt_info->version = nand->bbt.version;
133
134 nanddev_offs_to_pos(nand, block * mtd->erasesize, &pos);
135 ret = nand->ops->erase(nand, &pos);
136 if (ret)
137 goto out;
138
139 memset(&ops, 0, sizeof(struct mtd_oob_ops));
140 ops.mode = MTD_OPS_PLACE_OOB;
141 ops.datbuf = data_buf;
142 ops.len = bbt_page_num * mtd->writesize;
143 ops.oobbuf = oob_buf;
144 ops.ooblen = bbt_page_num * mtd->oobsize;
145 ops.ooboffs = 0;
146 ret = mtd_write_oob(mtd, block * mtd->erasesize, &ops);
147
148 out:
149 kfree(oob_buf);
150 kfree(data_buf);
151
152 return ret;
153 }
154
nanddev_bbt_format(struct nand_device * nand)155 static int nanddev_bbt_format(struct nand_device *nand)
156 {
157 unsigned int nblocks = nanddev_neraseblocks(nand);
158 struct mtd_info *mtd = nanddev_to_mtd(nand);
159 struct nand_pos pos;
160 u32 start_block, block;
161
162 start_block = nblocks - NANDDEV_BBT_SCAN_MAXBLOCKS;
163
164 for (block = 0; block < nblocks; block++) {
165 nanddev_offs_to_pos(nand, block * mtd->erasesize, &pos);
166 if (nanddev_isbad(nand, &pos))
167 nanddev_bbt_set_block_status(nand, block,
168 NAND_BBT_BLOCK_FACTORY_BAD);
169 }
170
171 for (block = 0; block < NANDDEV_BBT_SCAN_MAXBLOCKS; block++) {
172 if (nanddev_bbt_get_block_status(nand, start_block + block) ==
173 NAND_BBT_BLOCK_GOOD)
174 nanddev_bbt_set_block_status(nand, start_block + block,
175 NAND_BBT_BLOCK_WORN);
176 }
177
178 return 0;
179 }
180
181 /**
182 * nanddev_scan_bbt_in_flash() - Scan for a BBT in the flash
183 * @nand: nand device
184 *
185 * Scan a bbt in flash, if not exist, format one.
186 *
187 * Return: 0 in case of success, a negative error code otherwise.
188 */
nanddev_scan_bbt_in_flash(struct nand_device * nand)189 int nanddev_scan_bbt_in_flash(struct nand_device *nand)
190 {
191 unsigned int nblocks = nanddev_neraseblocks(nand);
192 u32 start_block, block;
193 int ret = 0;
194
195 nand->bbt.version = 0;
196 start_block = nblocks - NANDDEV_BBT_SCAN_MAXBLOCKS;
197 for (block = 0; block < NANDDEV_BBT_SCAN_MAXBLOCKS; block++)
198 nanddev_read_bbt(nand, start_block + block, true);
199
200 if (nand->bbt.version == 0) {
201 nanddev_bbt_format(nand);
202 ret = nanddev_bbt_in_flash_update(nand);
203 if (ret) {
204 nand->bbt.option = 0;
205 pr_err("%s fail\n", __func__);
206 }
207 }
208
209 nand->bbt.option |= NANDDEV_BBT_SCANNED;
210
211 return ret;
212 }
213 EXPORT_SYMBOL_GPL(nanddev_scan_bbt_in_flash);
214
215 /**
216 * nanddev_bbt_in_flash_update() - Update a BBT
217 * @nand: nand device
218 *
219 * Update the BBT to flash.
220 *
221 * Return: 0 in case of success, a negative error code otherwise.
222 */
nanddev_bbt_in_flash_update(struct nand_device * nand)223 int nanddev_bbt_in_flash_update(struct nand_device *nand)
224 {
225 if (nand->bbt.option & NANDDEV_BBT_SCANNED) {
226 unsigned int nblocks = nanddev_neraseblocks(nand);
227 u32 bbt_version[NANDDEV_BBT_SCAN_MAXBLOCKS];
228 int start_block, block;
229 u32 min_version, block_des;
230 int ret, count = 0;
231
232 start_block = nblocks - NANDDEV_BBT_SCAN_MAXBLOCKS;
233 for (block = 0; block < NANDDEV_BBT_SCAN_MAXBLOCKS; block++) {
234 ret = nanddev_bbt_get_block_status(nand, start_block + block);
235 if (ret == NAND_BBT_BLOCK_FACTORY_BAD) {
236 bbt_version[block] = 0xFFFFFFFF;
237 continue;
238 }
239 ret = nanddev_read_bbt(nand, start_block + block,
240 false);
241 if (ret < 0)
242 bbt_version[block] = 0xFFFFFFFF;
243 else if (ret == 0)
244 bbt_version[block] = 0;
245 else
246 bbt_version[block] = ret;
247 }
248 get_min_ver:
249 min_version = 0xFFFFFFFF;
250 block_des = 0;
251 for (block = 0; block < NANDDEV_BBT_SCAN_MAXBLOCKS; block++) {
252 if (bbt_version[block] < min_version) {
253 min_version = bbt_version[block];
254 block_des = start_block + block;
255 }
256 }
257
258 if (block_des > 0) {
259 nand->bbt.version++;
260 ret = nanddev_write_bbt(nand, block_des);
261 bbt_version[block_des - start_block] = 0xFFFFFFFF;
262 if (ret) {
263 pr_err("%s blk= %d ret= %d\n", __func__,
264 block_des, ret);
265 goto get_min_ver;
266 } else {
267 count++;
268 if (count < 2)
269 goto get_min_ver;
270 BBT_DBG("%s success\n", __func__);
271 }
272 } else {
273 pr_err("%s failed\n", __func__);
274
275 return -EINVAL;
276 }
277 }
278
279 return 0;
280 }
281 EXPORT_SYMBOL_GPL(nanddev_bbt_in_flash_update);
282