?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: et131x: attack the config stuff
[wandboard.git] / drivers / mtd / nftlmount.c
blob8b22b1836e9fee9281565e2e89294ec4d2b47ad5
1 /*
2 * NFTL mount code with extensive checks
3 *
4 * Author: Fabrice Bellard (fabrice.bellard@netgem.com)
5 * Copyright (C) 2000 Netgem S.A.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include <linux/kernel.h>
23 #include <asm/errno.h>
24 #include <linux/delay.h>
25 #include <linux/slab.h>
26 #include <linux/mtd/mtd.h>
27 #include <linux/mtd/nand.h>
28 #include <linux/mtd/nftl.h>
29
30 #define SECTORSIZE 512
31
32 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
33 * various device information of the NFTL partition and Bad Unit Table. Update
34 * the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
35 * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
36 */
37 static int find_boot_record(struct NFTLrecord *nftl)
38 {
39 struct nftl_uci1 h1;
40 unsigned int block, boot_record_count = 0;
41 size_t retlen;
42 u8 buf[SECTORSIZE];
43 struct NFTLMediaHeader *mh = &nftl->MediaHdr;
44 struct mtd_info *mtd = nftl->mbd.mtd;
45 unsigned int i;
46
47 /* Assume logical EraseSize == physical erasesize for starting the scan.
48 We'll sort it out later if we find a MediaHeader which says otherwise */
49 /* Actually, we won't. The new DiskOnChip driver has already scanned
50 the MediaHeader and adjusted the virtual erasesize it presents in
51 the mtd device accordingly. We could even get rid of
52 nftl->EraseSize if there were any point in doing so. */
53 nftl->EraseSize = nftl->mbd.mtd->erasesize;
54 nftl->nb_blocks = (u32)nftl->mbd.mtd->size / nftl->EraseSize;
55
56 nftl->MediaUnit = BLOCK_NIL;
57 nftl->SpareMediaUnit = BLOCK_NIL;
58
59 /* search for a valid boot record */
60 for (block = 0; block < nftl->nb_blocks; block++) {
61 int ret;
62
63 /* Check for ANAND header first. Then can whinge if it's found but later
64 checks fail */
65 ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
66 &retlen, buf);
67 /* We ignore ret in case the ECC of the MediaHeader is invalid
68 (which is apparently acceptable) */
69 if (retlen != SECTORSIZE) {
70 static int warncount = 5;
71
72 if (warncount) {
73 printk(KERN_WARNING "Block read at 0x%x of mtd%d failed: %d\n",
74 block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
75 if (!--warncount)
76 printk(KERN_WARNING "Further failures for this block will not be printed\n");
77 }
78 continue;
79 }
80
81 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
82 /* ANAND\0 not found. Continue */
83 #if 0
84 printk(KERN_DEBUG "ANAND header not found at 0x%x in mtd%d\n",
85 block * nftl->EraseSize, nftl->mbd.mtd->index);
86 #endif
87 continue;
88 }
89
90 /* To be safer with BIOS, also use erase mark as discriminant */
91 if ((ret = nftl_read_oob(mtd, block * nftl->EraseSize +
92 SECTORSIZE + 8, 8, &retlen,
93 (char *)&h1) < 0)) {
94 printk(KERN_WARNING "ANAND header found at 0x%x in mtd%d, but OOB data read failed (err %d)\n",
95 block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
96 continue;
97 }
98
99 #if 0 /* Some people seem to have devices without ECC or erase marks
100 on the Media Header blocks. There are enough other sanity
101 checks in here that we can probably do without it.
102 */
103 if (le16_to_cpu(h1.EraseMark | h1.EraseMark1) != ERASE_MARK) {
104 printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but erase mark not present (0x%04x,0x%04x instead)\n",
105 block * nftl->EraseSize, nftl->mbd.mtd->index,
106 le16_to_cpu(h1.EraseMark), le16_to_cpu(h1.EraseMark1));
107 continue;
108 }
109
110 /* Finally reread to check ECC */
111 if ((ret = mtd->read(mtd, block * nftl->EraseSize, SECTORSIZE,
112 &retlen, buf) < 0)) {
113 printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but ECC read failed (err %d)\n",
114 block * nftl->EraseSize, nftl->mbd.mtd->index, ret);
115 continue;
116 }
117
118 /* Paranoia. Check the ANAND header is still there after the ECC read */
119 if (memcmp(buf, "ANAND", 6)) {
120 printk(KERN_NOTICE "ANAND header found at 0x%x in mtd%d, but went away on reread!\n",
121 block * nftl->EraseSize, nftl->mbd.mtd->index);
122 printk(KERN_NOTICE "New data are: %02x %02x %02x %02x %02x %02x\n",
123 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
124 continue;
125 }
126 #endif
127 /* OK, we like it. */
128
129 if (boot_record_count) {
130 /* We've already processed one. So we just check if
131 this one is the same as the first one we found */
132 if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
133 printk(KERN_NOTICE "NFTL Media Headers at 0x%x and 0x%x disagree.\n",
134 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
135 /* if (debug) Print both side by side */
136 if (boot_record_count < 2) {
137 /* We haven't yet seen two real ones */
138 return -1;
139 }
140 continue;
141 }
142 if (boot_record_count == 1)
143 nftl->SpareMediaUnit = block;
144
145 /* Mark this boot record (NFTL MediaHeader) block as reserved */
146 nftl->ReplUnitTable[block] = BLOCK_RESERVED;
147
148
149 boot_record_count++;
150 continue;
151 }
152
153 /* This is the first we've seen. Copy the media header structure into place */
154 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
155
156 /* Do some sanity checks on it */
157 #if 0
158 The new DiskOnChip driver scans the MediaHeader itself, and presents a virtual
159 erasesize based on UnitSizeFactor. So the erasesize we read from the mtd
160 device is already correct.
161 if (mh->UnitSizeFactor == 0) {
162 printk(KERN_NOTICE "NFTL: UnitSizeFactor 0x00 detected. This violates the spec but we think we know what it means...\n");
163 } else if (mh->UnitSizeFactor < 0xfc) {
164 printk(KERN_NOTICE "Sorry, we don't support UnitSizeFactor 0x%02x\n",
165 mh->UnitSizeFactor);
166 return -1;
167 } else if (mh->UnitSizeFactor != 0xff) {
168 printk(KERN_NOTICE "WARNING: Support for NFTL with UnitSizeFactor 0x%02x is experimental\n",
169 mh->UnitSizeFactor);
170 nftl->EraseSize = nftl->mbd.mtd->erasesize << (0xff - mh->UnitSizeFactor);
171 nftl->nb_blocks = (u32)nftl->mbd.mtd->size / nftl->EraseSize;
172 }
173 #endif
174 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
175 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
176 printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
177 printk(KERN_NOTICE "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
178 nftl->nb_boot_blocks, nftl->nb_blocks);
179 return -1;
180 }
181
182 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
183 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
184 printk(KERN_NOTICE "NFTL Media Header sanity check failed:\n");
185 printk(KERN_NOTICE "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
186 nftl->numvunits, nftl->nb_blocks, nftl->nb_boot_blocks);
187 return -1;
188 }
189
190 nftl->mbd.size = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
191
192 /* If we're not using the last sectors in the device for some reason,
193 reduce nb_blocks accordingly so we forget they're there */
194 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
195
196 /* XXX: will be suppressed */
197 nftl->lastEUN = nftl->nb_blocks - 1;
198
199 /* memory alloc */
200 nftl->EUNtable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL);
201 if (!nftl->EUNtable) {
202 printk(KERN_NOTICE "NFTL: allocation of EUNtable failed\n");
203 return -ENOMEM;
204 }
205
206 nftl->ReplUnitTable = kmalloc(nftl->nb_blocks * sizeof(u16), GFP_KERNEL);
207 if (!nftl->ReplUnitTable) {
208 kfree(nftl->EUNtable);
209 printk(KERN_NOTICE "NFTL: allocation of ReplUnitTable failed\n");
210 return -ENOMEM;
211 }
212
213 /* mark the bios blocks (blocks before NFTL MediaHeader) as reserved */
214 for (i = 0; i < nftl->nb_boot_blocks; i++)
215 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
216 /* mark all remaining blocks as potentially containing data */
217 for (; i < nftl->nb_blocks; i++) {
218 nftl->ReplUnitTable[i] = BLOCK_NOTEXPLORED;
219 }
220
221 /* Mark this boot record (NFTL MediaHeader) block as reserved */
222 nftl->ReplUnitTable[block] = BLOCK_RESERVED;
223
224 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
225 for (i = 0; i < nftl->nb_blocks; i++) {
226 #if 0
227 The new DiskOnChip driver already scanned the bad block table. Just query it.
228 if ((i & (SECTORSIZE - 1)) == 0) {
229 /* read one sector for every SECTORSIZE of blocks */
230 if ((ret = mtd->read(nftl->mbd.mtd, block * nftl->EraseSize +
231 i + SECTORSIZE, SECTORSIZE, &retlen,
232 buf)) < 0) {
233 printk(KERN_NOTICE "Read of bad sector table failed (err %d)\n",
234 ret);
235 kfree(nftl->ReplUnitTable);
236 kfree(nftl->EUNtable);
237 return -1;
238 }
239 }
240 /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
241 if (buf[i & (SECTORSIZE - 1)] != 0xff)
242 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
243 #endif
244 if (nftl->mbd.mtd->block_isbad(nftl->mbd.mtd, i * nftl->EraseSize))
245 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
246 }
247
248 nftl->MediaUnit = block;
249 boot_record_count++;
250
251 } /* foreach (block) */
252
253 return boot_record_count?0:-1;
254 }
255
256 static int memcmpb(void *a, int c, int n)
257 {
258 int i;
259 for (i = 0; i < n; i++) {
260 if (c != ((unsigned char *)a)[i])
261 return 1;
262 }
263 return 0;
264 }
265
266 /* check_free_sector: check if a free sector is actually FREE, i.e. All 0xff in data and oob area */
267 static int check_free_sectors(struct NFTLrecord *nftl, unsigned int address, int len,
268 int check_oob)
269 {
270 u8 buf[SECTORSIZE + nftl->mbd.mtd->oobsize];
271 struct mtd_info *mtd = nftl->mbd.mtd;
272 size_t retlen;
273 int i;
274
275 for (i = 0; i < len; i += SECTORSIZE) {
276 if (mtd->read(mtd, address, SECTORSIZE, &retlen, buf))
277 return -1;
278 if (memcmpb(buf, 0xff, SECTORSIZE) != 0)
279 return -1;
280
281 if (check_oob) {
282 if(nftl_read_oob(mtd, address, mtd->oobsize,
283 &retlen, &buf[SECTORSIZE]) < 0)
284 return -1;
285 if (memcmpb(buf + SECTORSIZE, 0xff, mtd->oobsize) != 0)
286 return -1;
287 }
288 address += SECTORSIZE;
289 }
290
291 return 0;
292 }
293
294 /* NFTL_format: format a Erase Unit by erasing ALL Erase Zones in the Erase Unit and
295 * Update NFTL metadata. Each erase operation is checked with check_free_sectors
296 *
297 * Return: 0 when succeed, -1 on error.
298 *
299 * ToDo: 1. Is it neceressary to check_free_sector after erasing ??
300 */
301 int NFTL_formatblock(struct NFTLrecord *nftl, int block)
302 {
303 size_t retlen;
304 unsigned int nb_erases, erase_mark;
305 struct nftl_uci1 uci;
306 struct erase_info *instr = &nftl->instr;
307 struct mtd_info *mtd = nftl->mbd.mtd;
308
309 /* Read the Unit Control Information #1 for Wear-Leveling */
310 if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8,
311 8, &retlen, (char *)&uci) < 0)
312 goto default_uci1;
313
314 erase_mark = le16_to_cpu ((uci.EraseMark | uci.EraseMark1));
315 if (erase_mark != ERASE_MARK) {
316 default_uci1:
317 uci.EraseMark = cpu_to_le16(ERASE_MARK);
318 uci.EraseMark1 = cpu_to_le16(ERASE_MARK);
319 uci.WearInfo = cpu_to_le32(0);
320 }
321
322 memset(instr, 0, sizeof(struct erase_info));
323
324 /* XXX: use async erase interface, XXX: test return code */
325 instr->mtd = nftl->mbd.mtd;
326 instr->addr = block * nftl->EraseSize;
327 instr->len = nftl->EraseSize;
328 mtd->erase(mtd, instr);
329
330 if (instr->state == MTD_ERASE_FAILED) {
331 printk("Error while formatting block %d\n", block);
332 goto fail;
333 }
334
335 /* increase and write Wear-Leveling info */
336 nb_erases = le32_to_cpu(uci.WearInfo);
337 nb_erases++;
338
339 /* wrap (almost impossible with current flashs) or free block */
340 if (nb_erases == 0)
341 nb_erases = 1;
342
343 /* check the "freeness" of Erase Unit before updating metadata
344 * FixMe: is this check really necessary ? since we have check the
345 * return code after the erase operation. */
346 if (check_free_sectors(nftl, instr->addr, nftl->EraseSize, 1) != 0)
347 goto fail;
348
349 uci.WearInfo = le32_to_cpu(nb_erases);
350 if (nftl_write_oob(mtd, block * nftl->EraseSize + SECTORSIZE +
351 8, 8, &retlen, (char *)&uci) < 0)
352 goto fail;
353 return 0;
354 fail:
355 /* could not format, update the bad block table (caller is responsible
356 for setting the ReplUnitTable to BLOCK_RESERVED on failure) */
357 nftl->mbd.mtd->block_markbad(nftl->mbd.mtd, instr->addr);
358 return -1;
359 }
360
361 /* check_sectors_in_chain: Check that each sector of a Virtual Unit Chain is correct.
362 * Mark as 'IGNORE' each incorrect sector. This check is only done if the chain
363 * was being folded when NFTL was interrupted.
364 *
365 * The check_free_sectors in this function is neceressary. There is a possible
366 * situation that after writing the Data area, the Block Control Information is
367 * not updated according (due to power failure or something) which leaves the block
368 * in an umconsistent state. So we have to check if a block is really FREE in this
369 * case. */
370 static void check_sectors_in_chain(struct NFTLrecord *nftl, unsigned int first_block)
371 {
372 struct mtd_info *mtd = nftl->mbd.mtd;
373 unsigned int block, i, status;
374 struct nftl_bci bci;
375 int sectors_per_block;
376 size_t retlen;
377
378 sectors_per_block = nftl->EraseSize / SECTORSIZE;
379 block = first_block;
380 for (;;) {
381 for (i = 0; i < sectors_per_block; i++) {
382 if (nftl_read_oob(mtd,
383 block * nftl->EraseSize + i * SECTORSIZE,
384 8, &retlen, (char *)&bci) < 0)
385 status = SECTOR_IGNORE;
386 else
387 status = bci.Status | bci.Status1;
388
389 switch(status) {
390 case SECTOR_FREE:
391 /* verify that the sector is really free. If not, mark
392 as ignore */
393 if (memcmpb(&bci, 0xff, 8) != 0 ||
394 check_free_sectors(nftl, block * nftl->EraseSize + i * SECTORSIZE,
395 SECTORSIZE, 0) != 0) {
396 printk("Incorrect free sector %d in block %d: "
397 "marking it as ignored\n",
398 i, block);
399
400 /* sector not free actually : mark it as SECTOR_IGNORE */
401 bci.Status = SECTOR_IGNORE;
402 bci.Status1 = SECTOR_IGNORE;
403 nftl_write_oob(mtd, block *
404 nftl->EraseSize +
405 i * SECTORSIZE, 8,
406 &retlen, (char *)&bci);
407 }
408 break;
409 default:
410 break;
411 }
412 }
413
414 /* proceed to next Erase Unit on the chain */
415 block = nftl->ReplUnitTable[block];
416 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
417 printk("incorrect ReplUnitTable[] : %d\n", block);
418 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
419 break;
420 }
421 }
422
423 /* calc_chain_length: Walk through a Virtual Unit Chain and estimate chain length */
424 static int calc_chain_length(struct NFTLrecord *nftl, unsigned int first_block)
425 {
426 unsigned int length = 0, block = first_block;
427
428 for (;;) {
429 length++;
430 /* avoid infinite loops, although this is guaranted not to
431 happen because of the previous checks */
432 if (length >= nftl->nb_blocks) {
433 printk("nftl: length too long %d !\n", length);
434 break;
435 }
436
437 block = nftl->ReplUnitTable[block];
438 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
439 printk("incorrect ReplUnitTable[] : %d\n", block);
440 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
441 break;
442 }
443 return length;
444 }
445
446 /* format_chain: Format an invalid Virtual Unit chain. It frees all the Erase Units in a
447 * Virtual Unit Chain, i.e. all the units are disconnected.
448 *
449 * It is not stricly correct to begin from the first block of the chain because
450 * if we stop the code, we may see again a valid chain if there was a first_block
451 * flag in a block inside it. But is it really a problem ?
452 *
453 * FixMe: Figure out what the last statesment means. What if power failure when we are
454 * in the for (;;) loop formatting blocks ??
455 */
456 static void format_chain(struct NFTLrecord *nftl, unsigned int first_block)
457 {
458 unsigned int block = first_block, block1;
459
460 printk("Formatting chain at block %d\n", first_block);
461
462 for (;;) {
463 block1 = nftl->ReplUnitTable[block];
464
465 printk("Formatting block %d\n", block);
466 if (NFTL_formatblock(nftl, block) < 0) {
467 /* cannot format !!!! Mark it as Bad Unit */
468 nftl->ReplUnitTable[block] = BLOCK_RESERVED;
469 } else {
470 nftl->ReplUnitTable[block] = BLOCK_FREE;
471 }
472
473 /* goto next block on the chain */
474 block = block1;
475
476 if (!(block == BLOCK_NIL || block < nftl->nb_blocks))
477 printk("incorrect ReplUnitTable[] : %d\n", block);
478 if (block == BLOCK_NIL || block >= nftl->nb_blocks)
479 break;
480 }
481 }
482
483 /* check_and_mark_free_block: Verify that a block is free in the NFTL sense (valid erase mark) or
484 * totally free (only 0xff).
485 *
486 * Definition: Free Erase Unit -- A properly erased/formatted Free Erase Unit should have meet the
487 * following critia:
488 * 1. */
489 static int check_and_mark_free_block(struct NFTLrecord *nftl, int block)
490 {
491 struct mtd_info *mtd = nftl->mbd.mtd;
492 struct nftl_uci1 h1;
493 unsigned int erase_mark;
494 size_t retlen;
495
496 /* check erase mark. */
497 if (nftl_read_oob(mtd, block * nftl->EraseSize + SECTORSIZE + 8, 8,
498 &retlen, (char *)&h1) < 0)
499 return -1;
500
501 erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
502 if (erase_mark != ERASE_MARK) {
503 /* if no erase mark, the block must be totally free. This is
504 possible in two cases : empty filsystem or interrupted erase (very unlikely) */
505 if (check_free_sectors (nftl, block * nftl->EraseSize, nftl->EraseSize, 1) != 0)
506 return -1;
507
508 /* free block : write erase mark */
509 h1.EraseMark = cpu_to_le16(ERASE_MARK);
510 h1.EraseMark1 = cpu_to_le16(ERASE_MARK);
511 h1.WearInfo = cpu_to_le32(0);
512 if (nftl_write_oob(mtd,
513 block * nftl->EraseSize + SECTORSIZE + 8, 8,
514 &retlen, (char *)&h1) < 0)
515 return -1;
516 } else {
517 #if 0
518 /* if erase mark present, need to skip it when doing check */
519 for (i = 0; i < nftl->EraseSize; i += SECTORSIZE) {
520 /* check free sector */
521 if (check_free_sectors (nftl, block * nftl->EraseSize + i,
522 SECTORSIZE, 0) != 0)
523 return -1;
524
525 if (nftl_read_oob(mtd, block * nftl->EraseSize + i,
526 16, &retlen, buf) < 0)
527 return -1;
528 if (i == SECTORSIZE) {
529 /* skip erase mark */
530 if (memcmpb(buf, 0xff, 8))
531 return -1;
532 } else {
533 if (memcmpb(buf, 0xff, 16))
534 return -1;
535 }
536 }
537 #endif
538 }
539
540 return 0;
541 }
542
543 /* get_fold_mark: Read fold mark from Unit Control Information #2, we use FOLD_MARK_IN_PROGRESS
544 * to indicate that we are in the progression of a Virtual Unit Chain folding. If the UCI #2
545 * is FOLD_MARK_IN_PROGRESS when mounting the NFTL, the (previous) folding process is interrupted
546 * for some reason. A clean up/check of the VUC is neceressary in this case.
547 *
548 * WARNING: return 0 if read error
549 */
550 static int get_fold_mark(struct NFTLrecord *nftl, unsigned int block)
551 {
552 struct mtd_info *mtd = nftl->mbd.mtd;
553 struct nftl_uci2 uci;
554 size_t retlen;
555
556 if (nftl_read_oob(mtd, block * nftl->EraseSize + 2 * SECTORSIZE + 8,
557 8, &retlen, (char *)&uci) < 0)
558 return 0;
559
560 return le16_to_cpu((uci.FoldMark | uci.FoldMark1));
561 }
562
563 int NFTL_mount(struct NFTLrecord *s)
564 {
565 int i;
566 unsigned int first_logical_block, logical_block, rep_block, nb_erases, erase_mark;
567 unsigned int block, first_block, is_first_block;
568 int chain_length, do_format_chain;
569 struct nftl_uci0 h0;
570 struct nftl_uci1 h1;
571 struct mtd_info *mtd = s->mbd.mtd;
572 size_t retlen;
573
574 /* search for NFTL MediaHeader and Spare NFTL Media Header */
575 if (find_boot_record(s) < 0) {
576 printk("Could not find valid boot record\n");
577 return -1;
578 }
579
580 /* init the logical to physical table */
581 for (i = 0; i < s->nb_blocks; i++) {
582 s->EUNtable[i] = BLOCK_NIL;
583 }
584
585 /* first pass : explore each block chain */
586 first_logical_block = 0;
587 for (first_block = 0; first_block < s->nb_blocks; first_block++) {
588 /* if the block was not already explored, we can look at it */
589 if (s->ReplUnitTable[first_block] == BLOCK_NOTEXPLORED) {
590 block = first_block;
591 chain_length = 0;
592 do_format_chain = 0;
593
594 for (;;) {
595 /* read the block header. If error, we format the chain */
596 if (nftl_read_oob(mtd,
597 block * s->EraseSize + 8, 8,
598 &retlen, (char *)&h0) < 0 ||
599 nftl_read_oob(mtd,
600 block * s->EraseSize +
601 SECTORSIZE + 8, 8,
602 &retlen, (char *)&h1) < 0) {
603 s->ReplUnitTable[block] = BLOCK_NIL;
604 do_format_chain = 1;
605 break;
606 }
607
608 logical_block = le16_to_cpu ((h0.VirtUnitNum | h0.SpareVirtUnitNum));
609 rep_block = le16_to_cpu ((h0.ReplUnitNum | h0.SpareReplUnitNum));
610 nb_erases = le32_to_cpu (h1.WearInfo);
611 erase_mark = le16_to_cpu ((h1.EraseMark | h1.EraseMark1));
612
613 is_first_block = !(logical_block >> 15);
614 logical_block = logical_block & 0x7fff;
615
616 /* invalid/free block test */
617 if (erase_mark != ERASE_MARK || logical_block >= s->nb_blocks) {
618 if (chain_length == 0) {
619 /* if not currently in a chain, we can handle it safely */
620 if (check_and_mark_free_block(s, block) < 0) {
621 /* not really free: format it */
622 printk("Formatting block %d\n", block);
623 if (NFTL_formatblock(s, block) < 0) {
624 /* could not format: reserve the block */
625 s->ReplUnitTable[block] = BLOCK_RESERVED;
626 } else {
627 s->ReplUnitTable[block] = BLOCK_FREE;
628 }
629 } else {
630 /* free block: mark it */
631 s->ReplUnitTable[block] = BLOCK_FREE;
632 }
633 /* directly examine the next block. */
634 goto examine_ReplUnitTable;
635 } else {
636 /* the block was in a chain : this is bad. We
637 must format all the chain */
638 printk("Block %d: free but referenced in chain %d\n",
639 block, first_block);
640 s->ReplUnitTable[block] = BLOCK_NIL;
641 do_format_chain = 1;
642 break;
643 }
644 }
645
646 /* we accept only first blocks here */
647 if (chain_length == 0) {
648 /* this block is not the first block in chain :
649 ignore it, it will be included in a chain
650 later, or marked as not explored */
651 if (!is_first_block)
652 goto examine_ReplUnitTable;
653 first_logical_block = logical_block;
654 } else {
655 if (logical_block != first_logical_block) {
656 printk("Block %d: incorrect logical block: %d expected: %d\n",
657 block, logical_block, first_logical_block);
658 /* the chain is incorrect : we must format it,
659 but we need to read it completly */
660 do_format_chain = 1;
661 }
662 if (is_first_block) {
663 /* we accept that a block is marked as first
664 block while being last block in a chain
665 only if the chain is being folded */
666 if (get_fold_mark(s, block) != FOLD_MARK_IN_PROGRESS ||
667 rep_block != 0xffff) {
668 printk("Block %d: incorrectly marked as first block in chain\n",
669 block);
670 /* the chain is incorrect : we must format it,
671 but we need to read it completly */
672 do_format_chain = 1;
673 } else {
674 printk("Block %d: folding in progress - ignoring first block flag\n",
675 block);
676 }
677 }
678 }
679 chain_length++;
680 if (rep_block == 0xffff) {
681 /* no more blocks after */
682 s->ReplUnitTable[block] = BLOCK_NIL;
683 break;
684 } else if (rep_block >= s->nb_blocks) {
685 printk("Block %d: referencing invalid block %d\n",
686 block, rep_block);
687 do_format_chain = 1;
688 s->ReplUnitTable[block] = BLOCK_NIL;
689 break;
690 } else if (s->ReplUnitTable[rep_block] != BLOCK_NOTEXPLORED) {
691 /* same problem as previous 'is_first_block' test:
692 we accept that the last block of a chain has
693 the first_block flag set if folding is in
694 progress. We handle here the case where the
695 last block appeared first */
696 if (s->ReplUnitTable[rep_block] == BLOCK_NIL &&
697 s->EUNtable[first_logical_block] == rep_block &&
698 get_fold_mark(s, first_block) == FOLD_MARK_IN_PROGRESS) {
699 /* EUNtable[] will be set after */
700 printk("Block %d: folding in progress - ignoring first block flag\n",
701 rep_block);
702 s->ReplUnitTable[block] = rep_block;
703 s->EUNtable[first_logical_block] = BLOCK_NIL;
704 } else {
705 printk("Block %d: referencing block %d already in another chain\n",
706 block, rep_block);
707 /* XXX: should handle correctly fold in progress chains */
708 do_format_chain = 1;
709 s->ReplUnitTable[block] = BLOCK_NIL;
710 }
711 break;
712 } else {
713 /* this is OK */
714 s->ReplUnitTable[block] = rep_block;
715 block = rep_block;
716 }
717 }
718
719 /* the chain was completely explored. Now we can decide
720 what to do with it */
721 if (do_format_chain) {
722 /* invalid chain : format it */
723 format_chain(s, first_block);
724 } else {
725 unsigned int first_block1, chain_to_format, chain_length1;
726 int fold_mark;
727
728 /* valid chain : get foldmark */
729 fold_mark = get_fold_mark(s, first_block);
730 if (fold_mark == 0) {
731 /* cannot get foldmark : format the chain */
732 printk("Could read foldmark at block %d\n", first_block);
733 format_chain(s, first_block);
734 } else {
735 if (fold_mark == FOLD_MARK_IN_PROGRESS)
736 check_sectors_in_chain(s, first_block);
737
738 /* now handle the case where we find two chains at the
739 same virtual address : we select the longer one,
740 because the shorter one is the one which was being
741 folded if the folding was not done in place */
742 first_block1 = s->EUNtable[first_logical_block];
743 if (first_block1 != BLOCK_NIL) {
744 /* XXX: what to do if same length ? */
745 chain_length1 = calc_chain_length(s, first_block1);
746 printk("Two chains at blocks %d (len=%d) and %d (len=%d)\n",
747 first_block1, chain_length1, first_block, chain_length);
748
749 if (chain_length >= chain_length1) {
750 chain_to_format = first_block1;
751 s->EUNtable[first_logical_block] = first_block;
752 } else {
753 chain_to_format = first_block;
754 }
755 format_chain(s, chain_to_format);
756 } else {
757 s->EUNtable[first_logical_block] = first_block;
758 }
759 }
760 }
761 }
762 examine_ReplUnitTable:;
763 }
764
765 /* second pass to format unreferenced blocks and init free block count */
766 s->numfreeEUNs = 0;
767 s->LastFreeEUN = le16_to_cpu(s->MediaHdr.FirstPhysicalEUN);
768
769 for (block = 0; block < s->nb_blocks; block++) {
770 if (s->ReplUnitTable[block] == BLOCK_NOTEXPLORED) {
771 printk("Unreferenced block %d, formatting it\n", block);
772 if (NFTL_formatblock(s, block) < 0)
773 s->ReplUnitTable[block] = BLOCK_RESERVED;
774 else
775 s->ReplUnitTable[block] = BLOCK_FREE;
776 }
777 if (s->ReplUnitTable[block] == BLOCK_FREE) {
778 s->numfreeEUNs++;
779 s->LastFreeEUN = block;
780 }
781 }
782
783 return 0;
784 }
WandBoard kernel