]>
Commit | Line | Data |
---|---|---|
8a4580e4 AA |
1 | /* |
2 | * sharpslpart.c - MTD partition parser for NAND flash using the SHARP FTL | |
3 | * for logical addressing, as used on the PXA models of the SHARP SL Series. | |
4 | * | |
5 | * Copyright (C) 2017 Andrea Adami <andrea.adami@gmail.com> | |
6 | * | |
7 | * Based on SHARP GPL 2.4 sources: | |
8 | * http://support.ezaurus.com/developer/source/source_dl.asp | |
9 | * drivers/mtd/nand/sharp_sl_logical.c | |
10 | * linux/include/asm-arm/sharp_nand_logical.h | |
11 | * | |
12 | * Copyright (C) 2002 SHARP | |
13 | * | |
14 | * This program is free software; you can redistribute it and/or modify | |
15 | * it under the terms of the GNU General Public License as published by | |
16 | * the Free Software Foundation; either version 2 of the License, or | |
17 | * (at your option) any later version. | |
18 | * | |
19 | * This program is distributed in the hope that it will be useful, | |
20 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
21 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
22 | * GNU General Public License for more details. | |
23 | * | |
24 | */ | |
25 | ||
26 | #include <linux/kernel.h> | |
27 | #include <linux/slab.h> | |
28 | #include <linux/module.h> | |
29 | #include <linux/types.h> | |
30 | #include <linux/bitops.h> | |
31 | #include <linux/sizes.h> | |
32 | #include <linux/mtd/mtd.h> | |
33 | #include <linux/mtd/partitions.h> | |
34 | ||
35 | /* oob structure */ | |
36 | #define NAND_NOOB_LOGADDR_00 8 | |
37 | #define NAND_NOOB_LOGADDR_01 9 | |
38 | #define NAND_NOOB_LOGADDR_10 10 | |
39 | #define NAND_NOOB_LOGADDR_11 11 | |
40 | #define NAND_NOOB_LOGADDR_20 12 | |
41 | #define NAND_NOOB_LOGADDR_21 13 | |
42 | ||
43 | #define BLOCK_IS_RESERVED 0xffff | |
44 | #define BLOCK_UNMASK_COMPLEMENT 1 | |
45 | ||
46 | /* factory defaults */ | |
47 | #define SHARPSL_NAND_PARTS 3 | |
48 | #define SHARPSL_FTL_PART_SIZE (7 * SZ_1M) | |
49 | #define SHARPSL_PARTINFO1_LADDR 0x00060000 | |
50 | #define SHARPSL_PARTINFO2_LADDR 0x00064000 | |
51 | ||
52 | #define BOOT_MAGIC 0x424f4f54 | |
53 | #define FSRO_MAGIC 0x4653524f | |
54 | #define FSRW_MAGIC 0x46535257 | |
55 | ||
56 | /** | |
57 | * struct sharpsl_ftl - Sharp FTL Logical Table | |
58 | * @logmax: number of logical blocks | |
59 | * @log2phy: the logical-to-physical table | |
60 | * | |
61 | * Structure containing the logical-to-physical translation table | |
62 | * used by the SHARP SL FTL. | |
63 | */ | |
64 | struct sharpsl_ftl { | |
65 | unsigned int logmax; | |
66 | unsigned int *log2phy; | |
67 | }; | |
68 | ||
69 | /* verify that the OOB bytes 8 to 15 are free and available for the FTL */ | |
70 | static int sharpsl_nand_check_ooblayout(struct mtd_info *mtd) | |
71 | { | |
72 | u8 freebytes = 0; | |
73 | int section = 0; | |
74 | ||
75 | while (true) { | |
76 | struct mtd_oob_region oobfree = { }; | |
77 | int ret, i; | |
78 | ||
79 | ret = mtd_ooblayout_free(mtd, section++, &oobfree); | |
80 | if (ret) | |
81 | break; | |
82 | ||
83 | if (!oobfree.length || oobfree.offset > 15 || | |
84 | (oobfree.offset + oobfree.length) < 8) | |
85 | continue; | |
86 | ||
87 | i = oobfree.offset >= 8 ? oobfree.offset : 8; | |
88 | for (; i < oobfree.offset + oobfree.length && i < 16; i++) | |
89 | freebytes |= BIT(i - 8); | |
90 | ||
91 | if (freebytes == 0xff) | |
92 | return 0; | |
93 | } | |
94 | ||
95 | return -ENOTSUPP; | |
96 | } | |
97 | ||
98 | static int sharpsl_nand_read_oob(struct mtd_info *mtd, loff_t offs, u8 *buf) | |
99 | { | |
100 | struct mtd_oob_ops ops = { }; | |
101 | int ret; | |
102 | ||
103 | ops.mode = MTD_OPS_PLACE_OOB; | |
104 | ops.ooblen = mtd->oobsize; | |
105 | ops.oobbuf = buf; | |
106 | ||
107 | ret = mtd_read_oob(mtd, offs, &ops); | |
108 | if (ret != 0 || mtd->oobsize != ops.oobretlen) | |
109 | return -1; | |
110 | ||
111 | return 0; | |
112 | } | |
113 | ||
114 | /* | |
115 | * The logical block number assigned to a physical block is stored in the OOB | |
116 | * of the first page, in 3 16-bit copies with the following layout: | |
117 | * | |
118 | * 01234567 89abcdef | |
119 | * -------- -------- | |
120 | * ECC BB xyxyxy | |
121 | * | |
122 | * When reading we check that the first two copies agree. | |
123 | * In case of error, matching is tried using the following pairs. | |
124 | * Reserved values 0xffff mean the block is kept for wear leveling. | |
125 | * | |
126 | * 01234567 89abcdef | |
127 | * -------- -------- | |
128 | * ECC BB xyxy oob[8]==oob[10] && oob[9]==oob[11] -> byte0=8 byte1=9 | |
129 | * ECC BB xyxy oob[10]==oob[12] && oob[11]==oob[13] -> byte0=10 byte1=11 | |
130 | * ECC BB xy xy oob[12]==oob[8] && oob[13]==oob[9] -> byte0=12 byte1=13 | |
131 | */ | |
132 | static int sharpsl_nand_get_logical_num(u8 *oob) | |
133 | { | |
134 | u16 us; | |
135 | int good0, good1; | |
136 | ||
137 | if (oob[NAND_NOOB_LOGADDR_00] == oob[NAND_NOOB_LOGADDR_10] && | |
138 | oob[NAND_NOOB_LOGADDR_01] == oob[NAND_NOOB_LOGADDR_11]) { | |
139 | good0 = NAND_NOOB_LOGADDR_00; | |
140 | good1 = NAND_NOOB_LOGADDR_01; | |
141 | } else if (oob[NAND_NOOB_LOGADDR_10] == oob[NAND_NOOB_LOGADDR_20] && | |
142 | oob[NAND_NOOB_LOGADDR_11] == oob[NAND_NOOB_LOGADDR_21]) { | |
143 | good0 = NAND_NOOB_LOGADDR_10; | |
144 | good1 = NAND_NOOB_LOGADDR_11; | |
145 | } else if (oob[NAND_NOOB_LOGADDR_20] == oob[NAND_NOOB_LOGADDR_00] && | |
146 | oob[NAND_NOOB_LOGADDR_21] == oob[NAND_NOOB_LOGADDR_01]) { | |
147 | good0 = NAND_NOOB_LOGADDR_20; | |
148 | good1 = NAND_NOOB_LOGADDR_21; | |
149 | } else { | |
150 | return -EINVAL; | |
151 | } | |
152 | ||
153 | us = oob[good0] | oob[good1] << 8; | |
154 | ||
155 | /* parity check */ | |
156 | if (hweight16(us) & BLOCK_UNMASK_COMPLEMENT) | |
157 | return -EINVAL; | |
158 | ||
159 | /* reserved */ | |
160 | if (us == BLOCK_IS_RESERVED) | |
161 | return BLOCK_IS_RESERVED; | |
162 | ||
163 | return (us >> 1) & GENMASK(9, 0); | |
164 | } | |
165 | ||
166 | static int sharpsl_nand_init_ftl(struct mtd_info *mtd, struct sharpsl_ftl *ftl) | |
167 | { | |
168 | unsigned int block_num, log_num, phymax; | |
169 | loff_t block_adr; | |
170 | u8 *oob; | |
171 | int i, ret; | |
172 | ||
173 | oob = kzalloc(mtd->oobsize, GFP_KERNEL); | |
174 | if (!oob) | |
175 | return -ENOMEM; | |
176 | ||
177 | phymax = mtd_div_by_eb(SHARPSL_FTL_PART_SIZE, mtd); | |
178 | ||
179 | /* FTL reserves 5% of the blocks + 1 spare */ | |
180 | ftl->logmax = ((phymax * 95) / 100) - 1; | |
181 | ||
182 | ftl->log2phy = kmalloc_array(ftl->logmax, sizeof(*ftl->log2phy), | |
183 | GFP_KERNEL); | |
184 | if (!ftl->log2phy) { | |
185 | ret = -ENOMEM; | |
186 | goto exit; | |
187 | } | |
188 | ||
189 | /* initialize ftl->log2phy */ | |
190 | for (i = 0; i < ftl->logmax; i++) | |
191 | ftl->log2phy[i] = UINT_MAX; | |
192 | ||
193 | /* create physical-logical table */ | |
194 | for (block_num = 0; block_num < phymax; block_num++) { | |
b1d030f8 | 195 | block_adr = (loff_t)block_num * mtd->erasesize; |
8a4580e4 AA |
196 | |
197 | if (mtd_block_isbad(mtd, block_adr)) | |
198 | continue; | |
199 | ||
200 | if (sharpsl_nand_read_oob(mtd, block_adr, oob)) | |
201 | continue; | |
202 | ||
203 | /* get logical block */ | |
204 | log_num = sharpsl_nand_get_logical_num(oob); | |
205 | ||
206 | /* cut-off errors and skip the out-of-range values */ | |
207 | if (log_num > 0 && log_num < ftl->logmax) { | |
208 | if (ftl->log2phy[log_num] == UINT_MAX) | |
209 | ftl->log2phy[log_num] = block_num; | |
210 | } | |
211 | } | |
212 | ||
213 | pr_info("Sharp SL FTL: %d blocks used (%d logical, %d reserved)\n", | |
214 | phymax, ftl->logmax, phymax - ftl->logmax); | |
215 | ||
216 | ret = 0; | |
217 | exit: | |
218 | kfree(oob); | |
219 | return ret; | |
220 | } | |
221 | ||
911c3a30 | 222 | static void sharpsl_nand_cleanup_ftl(struct sharpsl_ftl *ftl) |
8a4580e4 AA |
223 | { |
224 | kfree(ftl->log2phy); | |
225 | } | |
226 | ||
227 | static int sharpsl_nand_read_laddr(struct mtd_info *mtd, | |
228 | loff_t from, | |
229 | size_t len, | |
230 | void *buf, | |
231 | struct sharpsl_ftl *ftl) | |
232 | { | |
233 | unsigned int log_num, final_log_num; | |
234 | unsigned int block_num; | |
235 | loff_t block_adr; | |
236 | loff_t block_ofs; | |
237 | size_t retlen; | |
238 | int err; | |
239 | ||
240 | log_num = mtd_div_by_eb((u32)from, mtd); | |
241 | final_log_num = mtd_div_by_eb(((u32)from + len - 1), mtd); | |
242 | ||
243 | if (len <= 0 || log_num >= ftl->logmax || final_log_num > log_num) | |
244 | return -EINVAL; | |
245 | ||
246 | block_num = ftl->log2phy[log_num]; | |
b1d030f8 | 247 | block_adr = (loff_t)block_num * mtd->erasesize; |
8a4580e4 AA |
248 | block_ofs = mtd_mod_by_eb((u32)from, mtd); |
249 | ||
250 | err = mtd_read(mtd, block_adr + block_ofs, len, &retlen, buf); | |
251 | /* Ignore corrected ECC errors */ | |
252 | if (mtd_is_bitflip(err)) | |
253 | err = 0; | |
254 | ||
255 | if (!err && retlen != len) | |
256 | err = -EIO; | |
257 | ||
258 | if (err) | |
259 | pr_err("sharpslpart: error, read failed at %#llx\n", | |
260 | block_adr + block_ofs); | |
261 | ||
262 | return err; | |
263 | } | |
264 | ||
265 | /* | |
266 | * MTD Partition Parser | |
267 | * | |
268 | * Sample values read from SL-C860 | |
269 | * | |
270 | * # cat /proc/mtd | |
271 | * dev: size erasesize name | |
272 | * mtd0: 006d0000 00020000 "Filesystem" | |
273 | * mtd1: 00700000 00004000 "smf" | |
274 | * mtd2: 03500000 00004000 "root" | |
275 | * mtd3: 04400000 00004000 "home" | |
276 | * | |
277 | * PARTITIONINFO1 | |
278 | * 0x00060000: 00 00 00 00 00 00 70 00 42 4f 4f 54 00 00 00 00 ......p.BOOT.... | |
279 | * 0x00060010: 00 00 70 00 00 00 c0 03 46 53 52 4f 00 00 00 00 ..p.....FSRO.... | |
280 | * 0x00060020: 00 00 c0 03 00 00 00 04 46 53 52 57 00 00 00 00 ........FSRW.... | |
281 | */ | |
282 | struct sharpsl_nand_partinfo { | |
283 | __le32 start; | |
284 | __le32 end; | |
285 | __be32 magic; | |
286 | u32 reserved; | |
287 | }; | |
288 | ||
289 | static int sharpsl_nand_read_partinfo(struct mtd_info *master, | |
290 | loff_t from, | |
291 | size_t len, | |
292 | struct sharpsl_nand_partinfo *buf, | |
293 | struct sharpsl_ftl *ftl) | |
294 | { | |
295 | int ret; | |
296 | ||
297 | ret = sharpsl_nand_read_laddr(master, from, len, buf, ftl); | |
298 | if (ret) | |
299 | return ret; | |
300 | ||
301 | /* check for magics */ | |
302 | if (be32_to_cpu(buf[0].magic) != BOOT_MAGIC || | |
303 | be32_to_cpu(buf[1].magic) != FSRO_MAGIC || | |
304 | be32_to_cpu(buf[2].magic) != FSRW_MAGIC) { | |
305 | pr_err("sharpslpart: magic values mismatch\n"); | |
306 | return -EINVAL; | |
307 | } | |
308 | ||
309 | /* fixup for hardcoded value 64 MiB (for older models) */ | |
310 | buf[2].end = cpu_to_le32(master->size); | |
311 | ||
312 | /* extra sanity check */ | |
313 | if (le32_to_cpu(buf[0].end) <= le32_to_cpu(buf[0].start) || | |
314 | le32_to_cpu(buf[1].start) < le32_to_cpu(buf[0].end) || | |
315 | le32_to_cpu(buf[1].end) <= le32_to_cpu(buf[1].start) || | |
316 | le32_to_cpu(buf[2].start) < le32_to_cpu(buf[1].end) || | |
317 | le32_to_cpu(buf[2].end) <= le32_to_cpu(buf[2].start)) { | |
318 | pr_err("sharpslpart: partition sizes mismatch\n"); | |
319 | return -EINVAL; | |
320 | } | |
321 | ||
322 | return 0; | |
323 | } | |
324 | ||
325 | static int sharpsl_parse_mtd_partitions(struct mtd_info *master, | |
326 | const struct mtd_partition **pparts, | |
327 | struct mtd_part_parser_data *data) | |
328 | { | |
329 | struct sharpsl_ftl ftl; | |
330 | struct sharpsl_nand_partinfo buf[SHARPSL_NAND_PARTS]; | |
331 | struct mtd_partition *sharpsl_nand_parts; | |
332 | int err; | |
333 | ||
334 | /* check that OOB bytes 8 to 15 used by the FTL are actually free */ | |
335 | err = sharpsl_nand_check_ooblayout(master); | |
336 | if (err) | |
337 | return err; | |
338 | ||
339 | /* init logical mgmt (FTL) */ | |
340 | err = sharpsl_nand_init_ftl(master, &ftl); | |
341 | if (err) | |
342 | return err; | |
343 | ||
344 | /* read and validate first partition table */ | |
345 | pr_info("sharpslpart: try reading first partition table\n"); | |
346 | err = sharpsl_nand_read_partinfo(master, | |
347 | SHARPSL_PARTINFO1_LADDR, | |
348 | sizeof(buf), buf, &ftl); | |
349 | if (err) { | |
350 | /* fallback: read second partition table */ | |
351 | pr_warn("sharpslpart: first partition table is invalid, retry using the second\n"); | |
352 | err = sharpsl_nand_read_partinfo(master, | |
353 | SHARPSL_PARTINFO2_LADDR, | |
354 | sizeof(buf), buf, &ftl); | |
355 | } | |
356 | ||
357 | /* cleanup logical mgmt (FTL) */ | |
358 | sharpsl_nand_cleanup_ftl(&ftl); | |
359 | ||
360 | if (err) { | |
361 | pr_err("sharpslpart: both partition tables are invalid\n"); | |
362 | return err; | |
363 | } | |
364 | ||
365 | sharpsl_nand_parts = kzalloc(sizeof(*sharpsl_nand_parts) * | |
366 | SHARPSL_NAND_PARTS, GFP_KERNEL); | |
367 | if (!sharpsl_nand_parts) | |
368 | return -ENOMEM; | |
369 | ||
370 | /* original names */ | |
371 | sharpsl_nand_parts[0].name = "smf"; | |
372 | sharpsl_nand_parts[0].offset = le32_to_cpu(buf[0].start); | |
373 | sharpsl_nand_parts[0].size = le32_to_cpu(buf[0].end) - | |
374 | le32_to_cpu(buf[0].start); | |
375 | ||
376 | sharpsl_nand_parts[1].name = "root"; | |
377 | sharpsl_nand_parts[1].offset = le32_to_cpu(buf[1].start); | |
378 | sharpsl_nand_parts[1].size = le32_to_cpu(buf[1].end) - | |
379 | le32_to_cpu(buf[1].start); | |
380 | ||
381 | sharpsl_nand_parts[2].name = "home"; | |
382 | sharpsl_nand_parts[2].offset = le32_to_cpu(buf[2].start); | |
383 | sharpsl_nand_parts[2].size = le32_to_cpu(buf[2].end) - | |
384 | le32_to_cpu(buf[2].start); | |
385 | ||
386 | *pparts = sharpsl_nand_parts; | |
387 | return SHARPSL_NAND_PARTS; | |
388 | } | |
389 | ||
390 | static struct mtd_part_parser sharpsl_mtd_parser = { | |
391 | .parse_fn = sharpsl_parse_mtd_partitions, | |
392 | .name = "sharpslpart", | |
393 | }; | |
394 | module_mtd_part_parser(sharpsl_mtd_parser); | |
395 | ||
396 | MODULE_LICENSE("GPL"); | |
397 | MODULE_AUTHOR("Andrea Adami <andrea.adami@gmail.com>"); | |
398 | MODULE_DESCRIPTION("MTD partitioning for NAND flash on Sharp SL Series"); |