1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62#include <linux/slab.h>
63#include <linux/types.h>
64#include <linux/mtd/mtd.h>
65#include <linux/mtd/bbm.h>
66#include <linux/mtd/nand.h>
67#include <linux/mtd/nand_ecc.h>
68#include <linux/bitops.h>
69#include <linux/delay.h>
70#include <linux/vmalloc.h>
71#include <linux/export.h>
72#include <linux/string.h>
73
74static int check_pattern_no_oob(uint8_t *buf, struct nand_bbt_descr *td)
75{
76 if (memcmp(buf, td->pattern, td->len))
77 return -1;
78 return 0;
79}
80
81
82
83
84
85
86
87
88
89
90
91
92static int check_pattern(uint8_t *buf, int len, int paglen, struct nand_bbt_descr *td)
93{
94 int end = 0;
95 uint8_t *p = buf;
96
97 if (td->options & NAND_BBT_NO_OOB)
98 return check_pattern_no_oob(buf, td);
99
100 end = paglen + td->offs;
101 if (td->options & NAND_BBT_SCANEMPTY)
102 if (memchr_inv(p, 0xff, end))
103 return -1;
104 p += end;
105
106
107 if (memcmp(p, td->pattern, td->len))
108 return -1;
109
110 if (td->options & NAND_BBT_SCANEMPTY) {
111 p += td->len;
112 end += td->len;
113 if (memchr_inv(p, 0xff, len - end))
114 return -1;
115 }
116 return 0;
117}
118
119
120
121
122
123
124
125
126
127
128static int check_short_pattern(uint8_t *buf, struct nand_bbt_descr *td)
129{
130
131 if (memcmp(buf + td->offs, td->pattern, td->len))
132 return -1;
133 return 0;
134}
135
136
137
138
139
140
141
142static u32 add_marker_len(struct nand_bbt_descr *td)
143{
144 u32 len;
145
146 if (!(td->options & NAND_BBT_NO_OOB))
147 return 0;
148
149 len = td->len;
150 if (td->options & NAND_BBT_VERSION)
151 len++;
152 return len;
153}
154
155
156
157
158
159
160
161
162
163
164
165
166static int read_bbt(struct mtd_info *mtd, uint8_t *buf, int page, int num,
167 struct nand_bbt_descr *td, int offs)
168{
169 int res, ret = 0, i, j, act = 0;
170 struct nand_chip *this = mtd->priv;
171 size_t retlen, len, totlen;
172 loff_t from;
173 int bits = td->options & NAND_BBT_NRBITS_MSK;
174 uint8_t msk = (uint8_t)((1 << bits) - 1);
175 u32 marker_len;
176 int reserved_block_code = td->reserved_block_code;
177
178 totlen = (num * bits) >> 3;
179 marker_len = add_marker_len(td);
180 from = ((loff_t)page) << this->page_shift;
181
182 while (totlen) {
183 len = min(totlen, (size_t)(1 << this->bbt_erase_shift));
184 if (marker_len) {
185
186
187
188
189 len -= marker_len;
190 from += marker_len;
191 marker_len = 0;
192 }
193 res = mtd_read(mtd, from, len, &retlen, buf);
194 if (res < 0) {
195 if (mtd_is_eccerr(res)) {
196 pr_info("nand_bbt: ECC error in BBT at "
197 "0x%012llx\n", from & ~mtd->writesize);
198 return res;
199 } else if (mtd_is_bitflip(res)) {
200 pr_info("nand_bbt: corrected error in BBT at "
201 "0x%012llx\n", from & ~mtd->writesize);
202 ret = res;
203 } else {
204 pr_info("nand_bbt: error reading BBT\n");
205 return res;
206 }
207 }
208
209
210 for (i = 0; i < len; i++) {
211 uint8_t dat = buf[i];
212 for (j = 0; j < 8; j += bits, act += 2) {
213 uint8_t tmp = (dat >> j) & msk;
214 if (tmp == msk)
215 continue;
216 if (reserved_block_code && (tmp == reserved_block_code)) {
217 pr_info("nand_read_bbt: reserved block at 0x%012llx\n",
218 (loff_t)((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
219 this->bbt[offs + (act >> 3)] |= 0x2 << (act & 0x06);
220 mtd->ecc_stats.bbtblocks++;
221 continue;
222 }
223
224
225
226
227 pr_info("nand_read_bbt: bad block at 0x%012llx\n",
228 (loff_t)((offs << 2) + (act >> 1)) << this->bbt_erase_shift);
229
230 if (tmp == 0)
231 this->bbt[offs + (act >> 3)] |= 0x3 << (act & 0x06);
232 else
233 this->bbt[offs + (act >> 3)] |= 0x1 << (act & 0x06);
234 mtd->ecc_stats.badblocks++;
235 }
236 }
237 totlen -= len;
238 from += len;
239 }
240 return ret;
241}
242
243
244
245
246
247
248
249
250
251
252
253
254static int read_abs_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td, int chip)
255{
256 struct nand_chip *this = mtd->priv;
257 int res = 0, i;
258
259 if (td->options & NAND_BBT_PERCHIP) {
260 int offs = 0;
261 for (i = 0; i < this->numchips; i++) {
262 if (chip == -1 || chip == i)
263 res = read_bbt(mtd, buf, td->pages[i],
264 this->chipsize >> this->bbt_erase_shift,
265 td, offs);
266 if (res)
267 return res;
268 offs += this->chipsize >> (this->bbt_erase_shift + 2);
269 }
270 } else {
271 res = read_bbt(mtd, buf, td->pages[0],
272 mtd->size >> this->bbt_erase_shift, td, 0);
273 if (res)
274 return res;
275 }
276 return 0;
277}
278
279
280static int scan_read_data(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
281 struct nand_bbt_descr *td)
282{
283 size_t retlen;
284 size_t len;
285
286 len = td->len;
287 if (td->options & NAND_BBT_VERSION)
288 len++;
289
290 return mtd_read(mtd, offs, len, &retlen, buf);
291}
292
293
294
295
296
297
298
299
300
301
302
303
304static int scan_read_oob(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
305 size_t len)
306{
307 struct mtd_oob_ops ops;
308 int res, ret = 0;
309
310 ops.mode = MTD_OPS_PLACE_OOB;
311 ops.ooboffs = 0;
312 ops.ooblen = mtd->oobsize;
313
314 while (len > 0) {
315 ops.datbuf = buf;
316 ops.len = min(len, (size_t)mtd->writesize);
317 ops.oobbuf = buf + ops.len;
318
319 res = mtd_read_oob(mtd, offs, &ops);
320 if (res) {
321 if (!mtd_is_bitflip_or_eccerr(res))
322 return res;
323 else if (mtd_is_eccerr(res) || !ret)
324 ret = res;
325 }
326
327 buf += mtd->oobsize + mtd->writesize;
328 len -= mtd->writesize;
329 offs += mtd->writesize;
330 }
331 return ret;
332}
333
334static int scan_read(struct mtd_info *mtd, uint8_t *buf, loff_t offs,
335 size_t len, struct nand_bbt_descr *td)
336{
337 if (td->options & NAND_BBT_NO_OOB)
338 return scan_read_data(mtd, buf, offs, td);
339 else
340 return scan_read_oob(mtd, buf, offs, len);
341}
342
343
344static int scan_write_bbt(struct mtd_info *mtd, loff_t offs, size_t len,
345 uint8_t *buf, uint8_t *oob)
346{
347 struct mtd_oob_ops ops;
348
349 ops.mode = MTD_OPS_PLACE_OOB;
350 ops.ooboffs = 0;
351 ops.ooblen = mtd->oobsize;
352 ops.datbuf = buf;
353 ops.oobbuf = oob;
354 ops.len = len;
355
356 return mtd_write_oob(mtd, offs, &ops);
357}
358
359static u32 bbt_get_ver_offs(struct mtd_info *mtd, struct nand_bbt_descr *td)
360{
361 u32 ver_offs = td->veroffs;
362
363 if (!(td->options & NAND_BBT_NO_OOB))
364 ver_offs += mtd->writesize;
365 return ver_offs;
366}
367
368
369
370
371
372
373
374
375
376
377
378static void read_abs_bbts(struct mtd_info *mtd, uint8_t *buf,
379 struct nand_bbt_descr *td, struct nand_bbt_descr *md)
380{
381 struct nand_chip *this = mtd->priv;
382
383
384 if (td->options & NAND_BBT_VERSION) {
385 scan_read(mtd, buf, (loff_t)td->pages[0] << this->page_shift,
386 mtd->writesize, td);
387 td->version[0] = buf[bbt_get_ver_offs(mtd, td)];
388 pr_info("Bad block table at page %d, version 0x%02X\n",
389 td->pages[0], td->version[0]);
390 }
391
392
393 if (md && (md->options & NAND_BBT_VERSION)) {
394 scan_read(mtd, buf, (loff_t)md->pages[0] << this->page_shift,
395 mtd->writesize, md);
396 md->version[0] = buf[bbt_get_ver_offs(mtd, md)];
397 pr_info("Bad block table at page %d, version 0x%02X\n",
398 md->pages[0], md->version[0]);
399 }
400}
401
402
403static int scan_block_full(struct mtd_info *mtd, struct nand_bbt_descr *bd,
404 loff_t offs, uint8_t *buf, size_t readlen,
405 int scanlen, int numpages)
406{
407 int ret, j;
408
409 ret = scan_read_oob(mtd, buf, offs, readlen);
410
411 if (ret && !mtd_is_bitflip_or_eccerr(ret))
412 return ret;
413
414 for (j = 0; j < numpages; j++, buf += scanlen) {
415 if (check_pattern(buf, scanlen, mtd->writesize, bd))
416 return 1;
417 }
418 return 0;
419}
420
421
422static int scan_block_fast(struct mtd_info *mtd, struct nand_bbt_descr *bd,
423 loff_t offs, uint8_t *buf, int numpages)
424{
425 struct mtd_oob_ops ops;
426 int j, ret;
427
428 ops.ooblen = mtd->oobsize;
429 ops.oobbuf = buf;
430 ops.ooboffs = 0;
431 ops.datbuf = NULL;
432 ops.mode = MTD_OPS_PLACE_OOB;
433
434 for (j = 0; j < numpages; j++) {
435
436
437
438
439 ret = mtd_read_oob(mtd, offs, &ops);
440
441 if (ret && !mtd_is_bitflip_or_eccerr(ret))
442 return ret;
443
444 if (check_short_pattern(buf, bd))
445 return 1;
446
447 offs += mtd->writesize;
448 }
449 return 0;
450}
451
452
453
454
455
456
457
458
459
460
461
462
463static int create_bbt(struct mtd_info *mtd, uint8_t *buf,
464 struct nand_bbt_descr *bd, int chip)
465{
466 struct nand_chip *this = mtd->priv;
467 int i, numblocks, numpages, scanlen;
468 int startblock;
469 loff_t from;
470 size_t readlen;
471
472 pr_info("Scanning device for bad blocks\n");
473
474 if (bd->options & NAND_BBT_SCANALLPAGES)
475 numpages = 1 << (this->bbt_erase_shift - this->page_shift);
476 else if (bd->options & NAND_BBT_SCAN2NDPAGE)
477 numpages = 2;
478 else
479 numpages = 1;
480
481 if (!(bd->options & NAND_BBT_SCANEMPTY)) {
482
483 scanlen = 0;
484 readlen = bd->len;
485 } else {
486
487 scanlen = mtd->writesize + mtd->oobsize;
488 readlen = numpages * mtd->writesize;
489 }
490
491 if (chip == -1) {
492
493
494
495
496 numblocks = mtd->size >> (this->bbt_erase_shift - 1);
497 startblock = 0;
498 from = 0;
499 } else {
500 if (chip >= this->numchips) {
501 pr_warn("create_bbt(): chipnr (%d) > available chips (%d)\n",
502 chip + 1, this->numchips);
503 return -EINVAL;
504 }
505 numblocks = this->chipsize >> (this->bbt_erase_shift - 1);
506 startblock = chip * numblocks;
507 numblocks += startblock;
508 from = (loff_t)startblock << (this->bbt_erase_shift - 1);
509 }
510
511 if (this->bbt_options & NAND_BBT_SCANLASTPAGE)
512 from += mtd->erasesize - (mtd->writesize * numpages);
513
514 for (i = startblock; i < numblocks;) {
515 int ret;
516
517 BUG_ON(bd->options & NAND_BBT_NO_OOB);
518
519 if (bd->options & NAND_BBT_SCANALLPAGES)
520 ret = scan_block_full(mtd, bd, from, buf, readlen,
521 scanlen, numpages);
522 else
523 ret = scan_block_fast(mtd, bd, from, buf, numpages);
524
525 if (ret < 0)
526 return ret;
527
528 if (ret) {
529 this->bbt[i >> 3] |= 0x03 << (i & 0x6);
530 pr_warn("Bad eraseblock %d at 0x%012llx\n",
531 i >> 1, (unsigned long long)from);
532 mtd->ecc_stats.badblocks++;
533 }
534
535 i += 2;
536 from += (1 << this->bbt_erase_shift);
537 }
538 return 0;
539}
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556static int search_bbt(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *td)
557{
558 struct nand_chip *this = mtd->priv;
559 int i, chips;
560 int bits, startblock, block, dir;
561 int scanlen = mtd->writesize + mtd->oobsize;
562 int bbtblocks;
563 int blocktopage = this->bbt_erase_shift - this->page_shift;
564
565
566 if (td->options & NAND_BBT_LASTBLOCK) {
567 startblock = (mtd->size >> this->bbt_erase_shift) - 1;
568 dir = -1;
569 } else {
570 startblock = 0;
571 dir = 1;
572 }
573
574
575 if (td->options & NAND_BBT_PERCHIP) {
576 chips = this->numchips;
577 bbtblocks = this->chipsize >> this->bbt_erase_shift;
578 startblock &= bbtblocks - 1;
579 } else {
580 chips = 1;
581 bbtblocks = mtd->size >> this->bbt_erase_shift;
582 }
583
584
585 bits = td->options & NAND_BBT_NRBITS_MSK;
586
587 for (i = 0; i < chips; i++) {
588
589 td->version[i] = 0;
590 td->pages[i] = -1;
591
592 for (block = 0; block < td->maxblocks; block++) {
593
594 int actblock = startblock + dir * block;
595 loff_t offs = (loff_t)actblock << this->bbt_erase_shift;
596
597
598 scan_read(mtd, buf, offs, mtd->writesize, td);
599 if (!check_pattern(buf, scanlen, mtd->writesize, td)) {
600 td->pages[i] = actblock << blocktopage;
601 if (td->options & NAND_BBT_VERSION) {
602 offs = bbt_get_ver_offs(mtd, td);
603 td->version[i] = buf[offs];
604 }
605 break;
606 }
607 }
608 startblock += this->chipsize >> this->bbt_erase_shift;
609 }
610
611 for (i = 0; i < chips; i++) {
612 if (td->pages[i] == -1)
613 pr_warn("Bad block table not found for chip %d\n", i);
614 else
615 pr_info("Bad block table found at page %d, version "
616 "0x%02X\n", td->pages[i], td->version[i]);
617 }
618 return 0;
619}
620
621
622
623
624
625
626
627
628
629
630static void search_read_bbts(struct mtd_info *mtd, uint8_t *buf,
631 struct nand_bbt_descr *td,
632 struct nand_bbt_descr *md)
633{
634
635 search_bbt(mtd, buf, td);
636
637
638 if (md)
639 search_bbt(mtd, buf, md);
640}
641
642
643
644
645
646
647
648
649
650
651
652static int write_bbt(struct mtd_info *mtd, uint8_t *buf,
653 struct nand_bbt_descr *td, struct nand_bbt_descr *md,
654 int chipsel)
655{
656 struct nand_chip *this = mtd->priv;
657 struct erase_info einfo;
658 int i, j, res, chip = 0;
659 int bits, startblock, dir, page, offs, numblocks, sft, sftmsk;
660 int nrchips, bbtoffs, pageoffs, ooboffs;
661 uint8_t msk[4];
662 uint8_t rcode = td->reserved_block_code;
663 size_t retlen, len = 0;
664 loff_t to;
665 struct mtd_oob_ops ops;
666
667 ops.ooblen = mtd->oobsize;
668 ops.ooboffs = 0;
669 ops.datbuf = NULL;
670 ops.mode = MTD_OPS_PLACE_OOB;
671
672 if (!rcode)
673 rcode = 0xff;
674
675 if (td->options & NAND_BBT_PERCHIP) {
676 numblocks = (int)(this->chipsize >> this->bbt_erase_shift);
677
678 if (chipsel == -1) {
679 nrchips = this->numchips;
680 } else {
681 nrchips = chipsel + 1;
682 chip = chipsel;
683 }
684 } else {
685 numblocks = (int)(mtd->size >> this->bbt_erase_shift);
686 nrchips = 1;
687 }
688
689
690 for (; chip < nrchips; chip++) {
691
692
693
694
695
696 if (td->pages[chip] != -1) {
697 page = td->pages[chip];
698 goto write;
699 }
700
701
702
703
704
705 if (td->options & NAND_BBT_LASTBLOCK) {
706 startblock = numblocks * (chip + 1) - 1;
707 dir = -1;
708 } else {
709 startblock = chip * numblocks;
710 dir = 1;
711 }
712
713 for (i = 0; i < td->maxblocks; i++) {
714 int block = startblock + dir * i;
715
716 switch ((this->bbt[block >> 2] >>
717 (2 * (block & 0x03))) & 0x03) {
718 case 0x01:
719 case 0x03:
720 continue;
721 }
722 page = block <<
723 (this->bbt_erase_shift - this->page_shift);
724
725 if (!md || md->pages[chip] != page)
726 goto write;
727 }
728 pr_err("No space left to write bad block table\n");
729 return -ENOSPC;
730 write:
731
732
733 bits = td->options & NAND_BBT_NRBITS_MSK;
734 msk[2] = ~rcode;
735 switch (bits) {
736 case 1: sft = 3; sftmsk = 0x07; msk[0] = 0x00; msk[1] = 0x01;
737 msk[3] = 0x01;
738 break;
739 case 2: sft = 2; sftmsk = 0x06; msk[0] = 0x00; msk[1] = 0x01;
740 msk[3] = 0x03;
741 break;
742 case 4: sft = 1; sftmsk = 0x04; msk[0] = 0x00; msk[1] = 0x0C;
743 msk[3] = 0x0f;
744 break;
745 case 8: sft = 0; sftmsk = 0x00; msk[0] = 0x00; msk[1] = 0x0F;
746 msk[3] = 0xff;
747 break;
748 default: return -EINVAL;
749 }
750
751 bbtoffs = chip * (numblocks >> 2);
752
753 to = ((loff_t)page) << this->page_shift;
754
755
756 if (td->options & NAND_BBT_SAVECONTENT) {
757
758 to &= ~((loff_t)((1 << this->bbt_erase_shift) - 1));
759 len = 1 << this->bbt_erase_shift;
760 res = mtd_read(mtd, to, len, &retlen, buf);
761 if (res < 0) {
762 if (retlen != len) {
763 pr_info("nand_bbt: error reading block "
764 "for writing the bad block table\n");
765 return res;
766 }
767 pr_warn("nand_bbt: ECC error while reading "
768 "block for writing bad block table\n");
769 }
770
771 ops.ooblen = (len >> this->page_shift) * mtd->oobsize;
772 ops.oobbuf = &buf[len];
773 res = mtd_read_oob(mtd, to + mtd->writesize, &ops);
774 if (res < 0 || ops.oobretlen != ops.ooblen)
775 goto outerr;
776
777
778 pageoffs = page - (int)(to >> this->page_shift);
779 offs = pageoffs << this->page_shift;
780
781 memset(&buf[offs], 0xff, (size_t)(numblocks >> sft));
782 ooboffs = len + (pageoffs * mtd->oobsize);
783
784 } else if (td->options & NAND_BBT_NO_OOB) {
785 ooboffs = 0;
786 offs = td->len;
787
788 if (td->options & NAND_BBT_VERSION)
789 offs++;
790
791 len = (size_t)(numblocks >> sft);
792 len += offs;
793
794 len = ALIGN(len, mtd->writesize);
795
796 memset(buf, 0xff, len);
797
798 memcpy(buf, td->pattern, td->len);
799 } else {
800
801 len = (size_t)(numblocks >> sft);
802
803 len = ALIGN(len, mtd->writesize);
804
805 memset(buf, 0xff, len +
806 (len >> this->page_shift)* mtd->oobsize);
807 offs = 0;
808 ooboffs = len;
809
810 memcpy(&buf[ooboffs + td->offs], td->pattern, td->len);
811 }
812
813 if (td->options & NAND_BBT_VERSION)
814 buf[ooboffs + td->veroffs] = td->version[chip];
815
816
817 for (i = 0; i < numblocks;) {
818 uint8_t dat;
819 dat = this->bbt[bbtoffs + (i >> 2)];
820 for (j = 0; j < 4; j++, i++) {
821 int sftcnt = (i << (3 - sft)) & sftmsk;
822
823 buf[offs + (i >> sft)] &=
824 ~(msk[dat & 0x03] << sftcnt);
825 dat >>= 2;
826 }
827 }
828
829 memset(&einfo, 0, sizeof(einfo));
830 einfo.mtd = mtd;
831 einfo.addr = to;
832 einfo.len = 1 << this->bbt_erase_shift;
833 res = nand_erase_nand(mtd, &einfo, 1);
834 if (res < 0)
835 goto outerr;
836
837 res = scan_write_bbt(mtd, to, len, buf,
838 td->options & NAND_BBT_NO_OOB ? NULL :
839 &buf[len]);
840 if (res < 0)
841 goto outerr;
842
843 pr_info("Bad block table written to 0x%012llx, version 0x%02X\n",
844 (unsigned long long)to, td->version[chip]);
845
846
847 td->pages[chip] = page;
848 }
849 return 0;
850
851 outerr:
852 pr_warn("nand_bbt: error while writing bad block table %d\n", res);
853 return res;
854}
855
856
857
858
859
860
861
862
863
864static inline int nand_memory_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
865{
866 struct nand_chip *this = mtd->priv;
867
868 bd->options &= ~NAND_BBT_SCANEMPTY;
869 return create_bbt(mtd, this->buffers->databuf, bd, -1);
870}
871
872
873
874
875
876
877
878
879
880
881
882
883static int check_create(struct mtd_info *mtd, uint8_t *buf, struct nand_bbt_descr *bd)
884{
885 int i, chips, writeops, create, chipsel, res, res2;
886 struct nand_chip *this = mtd->priv;
887 struct nand_bbt_descr *td = this->bbt_td;
888 struct nand_bbt_descr *md = this->bbt_md;
889 struct nand_bbt_descr *rd, *rd2;
890
891
892 if (td->options & NAND_BBT_PERCHIP)
893 chips = this->numchips;
894 else
895 chips = 1;
896
897 for (i = 0; i < chips; i++) {
898 writeops = 0;
899 create = 0;
900 rd = NULL;
901 rd2 = NULL;
902 res = res2 = 0;
903
904 chipsel = (td->options & NAND_BBT_PERCHIP) ? i : -1;
905
906 if (md) {
907 if (td->pages[i] == -1 && md->pages[i] == -1) {
908 create = 1;
909 writeops = 0x03;
910 } else if (td->pages[i] == -1) {
911 rd = md;
912 writeops = 0x01;
913 } else if (md->pages[i] == -1) {
914 rd = td;
915 writeops = 0x02;
916 } else if (td->version[i] == md->version[i]) {
917 rd = td;
918 if (!(td->options & NAND_BBT_VERSION))
919 rd2 = md;
920 } else if (((int8_t)(td->version[i] - md->version[i])) > 0) {
921 rd = td;
922 writeops = 0x02;
923 } else {
924 rd = md;
925 writeops = 0x01;
926 }
927 } else {
928 if (td->pages[i] == -1) {
929 create = 1;
930 writeops = 0x01;
931 } else {
932 rd = td;
933 }
934 }
935
936 if (create) {
937
938 if (!(td->options & NAND_BBT_CREATE))
939 continue;
940
941
942 if (!(this->bbt_options & NAND_BBT_CREATE_EMPTY))
943 create_bbt(mtd, buf, bd, chipsel);
944
945 td->version[i] = 1;
946 if (md)
947 md->version[i] = 1;
948 }
949
950
951 if (rd) {
952 res = read_abs_bbt(mtd, buf, rd, chipsel);
953 if (mtd_is_eccerr(res)) {
954
955 rd->pages[i] = -1;
956 rd->version[i] = 0;
957 i--;
958 continue;
959 }
960 }
961
962 if (rd2) {
963 res2 = read_abs_bbt(mtd, buf, rd2, chipsel);
964 if (mtd_is_eccerr(res2)) {
965
966 rd2->pages[i] = -1;
967 rd2->version[i] = 0;
968 i--;
969 continue;
970 }
971 }
972
973
974 if (mtd_is_bitflip(res) || mtd_is_bitflip(res2))
975 writeops = 0x03;
976
977
978 if (md) {
979 td->version[i] = max(td->version[i], md->version[i]);
980 md->version[i] = td->version[i];
981 }
982
983
984 if ((writeops & 0x01) && (td->options & NAND_BBT_WRITE)) {
985 res = write_bbt(mtd, buf, td, md, chipsel);
986 if (res < 0)
987 return res;
988 }
989
990
991 if ((writeops & 0x02) && md && (md->options & NAND_BBT_WRITE)) {
992 res = write_bbt(mtd, buf, md, td, chipsel);
993 if (res < 0)
994 return res;
995 }
996 }
997 return 0;
998}
999
1000
1001
1002
1003
1004
1005
1006
1007
1008static void mark_bbt_region(struct mtd_info *mtd, struct nand_bbt_descr *td)
1009{
1010 struct nand_chip *this = mtd->priv;
1011 int i, j, chips, block, nrblocks, update;
1012 uint8_t oldval, newval;
1013
1014
1015 if (td->options & NAND_BBT_PERCHIP) {
1016 chips = this->numchips;
1017 nrblocks = (int)(this->chipsize >> this->bbt_erase_shift);
1018 } else {
1019 chips = 1;
1020 nrblocks = (int)(mtd->size >> this->bbt_erase_shift);
1021 }
1022
1023 for (i = 0; i < chips; i++) {
1024 if ((td->options & NAND_BBT_ABSPAGE) ||
1025 !(td->options & NAND_BBT_WRITE)) {
1026 if (td->pages[i] == -1)
1027 continue;
1028 block = td->pages[i] >> (this->bbt_erase_shift - this->page_shift);
1029 block <<= 1;
1030 oldval = this->bbt[(block >> 3)];
1031 newval = oldval | (0x2 << (block & 0x06));
1032 this->bbt[(block >> 3)] = newval;
1033 if ((oldval != newval) && td->reserved_block_code)
1034 nand_update_bbt(mtd, (loff_t)block << (this->bbt_erase_shift - 1));
1035 continue;
1036 }
1037 update = 0;
1038 if (td->options & NAND_BBT_LASTBLOCK)
1039 block = ((i + 1) * nrblocks) - td->maxblocks;
1040 else
1041 block = i * nrblocks;
1042 block <<= 1;
1043 for (j = 0; j < td->maxblocks; j++) {
1044 oldval = this->bbt[(block >> 3)];
1045 newval = oldval | (0x2 << (block & 0x06));
1046 this->bbt[(block >> 3)] = newval;
1047 if (oldval != newval)
1048 update = 1;
1049 block += 2;
1050 }
1051
1052
1053
1054
1055
1056 if (update && td->reserved_block_code)
1057 nand_update_bbt(mtd, (loff_t)(block - 2) << (this->bbt_erase_shift - 1));
1058 }
1059}
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069static void verify_bbt_descr(struct mtd_info *mtd, struct nand_bbt_descr *bd)
1070{
1071 struct nand_chip *this = mtd->priv;
1072 u32 pattern_len;
1073 u32 bits;
1074 u32 table_size;
1075
1076 if (!bd)
1077 return;
1078
1079 pattern_len = bd->len;
1080 bits = bd->options & NAND_BBT_NRBITS_MSK;
1081
1082 BUG_ON((this->bbt_options & NAND_BBT_NO_OOB) &&
1083 !(this->bbt_options & NAND_BBT_USE_FLASH));
1084 BUG_ON(!bits);
1085
1086 if (bd->options & NAND_BBT_VERSION)
1087 pattern_len++;
1088
1089 if (bd->options & NAND_BBT_NO_OOB) {
1090 BUG_ON(!(this->bbt_options & NAND_BBT_USE_FLASH));
1091 BUG_ON(!(this->bbt_options & NAND_BBT_NO_OOB));
1092 BUG_ON(bd->offs);
1093 if (bd->options & NAND_BBT_VERSION)
1094 BUG_ON(bd->veroffs != bd->len);
1095 BUG_ON(bd->options & NAND_BBT_SAVECONTENT);
1096 }
1097
1098 if (bd->options & NAND_BBT_PERCHIP)
1099 table_size = this->chipsize >> this->bbt_erase_shift;
1100 else
1101 table_size = mtd->size >> this->bbt_erase_shift;
1102 table_size >>= 3;
1103 table_size *= bits;
1104 if (bd->options & NAND_BBT_NO_OOB)
1105 table_size += pattern_len;
1106 BUG_ON(table_size > (1 << this->bbt_erase_shift));
1107}
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121int nand_scan_bbt(struct mtd_info *mtd, struct nand_bbt_descr *bd)
1122{
1123 struct nand_chip *this = mtd->priv;
1124 int len, res = 0;
1125 uint8_t *buf;
1126 struct nand_bbt_descr *td = this->bbt_td;
1127 struct nand_bbt_descr *md = this->bbt_md;
1128
1129 len = mtd->size >> (this->bbt_erase_shift + 2);
1130
1131
1132
1133
1134 this->bbt = kzalloc(len, GFP_KERNEL);
1135 if (!this->bbt)
1136 return -ENOMEM;
1137
1138
1139
1140
1141
1142 if (!td) {
1143 if ((res = nand_memory_bbt(mtd, bd))) {
1144 pr_err("nand_bbt: can't scan flash and build the RAM-based BBT\n");
1145 kfree(this->bbt);
1146 this->bbt = NULL;
1147 }
1148 return res;
1149 }
1150 verify_bbt_descr(mtd, td);
1151 verify_bbt_descr(mtd, md);
1152
1153
1154 len = (1 << this->bbt_erase_shift);
1155 len += (len >> this->page_shift) * mtd->oobsize;
1156 buf = vmalloc(len);
1157 if (!buf) {
1158 kfree(this->bbt);
1159 this->bbt = NULL;
1160 return -ENOMEM;
1161 }
1162
1163
1164 if (td->options & NAND_BBT_ABSPAGE) {
1165 read_abs_bbts(mtd, buf, td, md);
1166 } else {
1167
1168 search_read_bbts(mtd, buf, td, md);
1169 }
1170
1171 res = check_create(mtd, buf, bd);
1172
1173
1174 mark_bbt_region(mtd, td);
1175 if (md)
1176 mark_bbt_region(mtd, md);
1177
1178 vfree(buf);
1179 return res;
1180}
1181
1182
1183
1184
1185
1186
1187
1188
1189int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
1190{
1191 struct nand_chip *this = mtd->priv;
1192 int len, res = 0;
1193 int chip, chipsel;
1194 uint8_t *buf;
1195 struct nand_bbt_descr *td = this->bbt_td;
1196 struct nand_bbt_descr *md = this->bbt_md;
1197
1198 if (!this->bbt || !td)
1199 return -EINVAL;
1200
1201
1202 len = (1 << this->bbt_erase_shift);
1203 len += (len >> this->page_shift) * mtd->oobsize;
1204 buf = kmalloc(len, GFP_KERNEL);
1205 if (!buf)
1206 return -ENOMEM;
1207
1208
1209 if (td->options & NAND_BBT_PERCHIP) {
1210 chip = (int)(offs >> this->chip_shift);
1211 chipsel = chip;
1212 } else {
1213 chip = 0;
1214 chipsel = -1;
1215 }
1216
1217 td->version[chip]++;
1218 if (md)
1219 md->version[chip]++;
1220
1221
1222 if (td->options & NAND_BBT_WRITE) {
1223 res = write_bbt(mtd, buf, td, md, chipsel);
1224 if (res < 0)
1225 goto out;
1226 }
1227
1228 if (md && (md->options & NAND_BBT_WRITE)) {
1229 res = write_bbt(mtd, buf, md, td, chipsel);
1230 }
1231
1232 out:
1233 kfree(buf);
1234 return res;
1235}
1236
1237
1238
1239
1240
1241static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
1242
1243
1244static uint8_t bbt_pattern[] = {'B', 'b', 't', '0' };
1245static uint8_t mirror_pattern[] = {'1', 't', 'b', 'B' };
1246
1247static struct nand_bbt_descr bbt_main_descr = {
1248 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1249 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1250 .offs = 8,
1251 .len = 4,
1252 .veroffs = 12,
1253 .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1254 .pattern = bbt_pattern
1255};
1256
1257static struct nand_bbt_descr bbt_mirror_descr = {
1258 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1259 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP,
1260 .offs = 8,
1261 .len = 4,
1262 .veroffs = 12,
1263 .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1264 .pattern = mirror_pattern
1265};
1266
1267static struct nand_bbt_descr bbt_main_no_oob_descr = {
1268 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1269 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
1270 | NAND_BBT_NO_OOB,
1271 .len = 4,
1272 .veroffs = 4,
1273 .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1274 .pattern = bbt_pattern
1275};
1276
1277static struct nand_bbt_descr bbt_mirror_no_oob_descr = {
1278 .options = NAND_BBT_LASTBLOCK | NAND_BBT_CREATE | NAND_BBT_WRITE
1279 | NAND_BBT_2BIT | NAND_BBT_VERSION | NAND_BBT_PERCHIP
1280 | NAND_BBT_NO_OOB,
1281 .len = 4,
1282 .veroffs = 4,
1283 .maxblocks = NAND_BBT_SCAN_MAXBLOCKS,
1284 .pattern = mirror_pattern
1285};
1286
1287#define BADBLOCK_SCAN_MASK (~NAND_BBT_NO_OOB)
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297static int nand_create_badblock_pattern(struct nand_chip *this)
1298{
1299 struct nand_bbt_descr *bd;
1300 if (this->badblock_pattern) {
1301 pr_warn("Bad block pattern already allocated; not replacing\n");
1302 return -EINVAL;
1303 }
1304 bd = kzalloc(sizeof(*bd), GFP_KERNEL);
1305 if (!bd)
1306 return -ENOMEM;
1307 bd->options = this->bbt_options & BADBLOCK_SCAN_MASK;
1308 bd->offs = this->badblockpos;
1309 bd->len = (this->options & NAND_BUSWIDTH_16) ? 2 : 1;
1310 bd->pattern = scan_ff_pattern;
1311 bd->options |= NAND_BBT_DYNAMICSTRUCT;
1312 this->badblock_pattern = bd;
1313 return 0;
1314}
1315
1316
1317
1318
1319
1320
1321
1322
1323int nand_default_bbt(struct mtd_info *mtd)
1324{
1325 struct nand_chip *this = mtd->priv;
1326
1327
1328 if (this->bbt_options & NAND_BBT_USE_FLASH) {
1329
1330 if (!this->bbt_td) {
1331 if (this->bbt_options & NAND_BBT_NO_OOB) {
1332 this->bbt_td = &bbt_main_no_oob_descr;
1333 this->bbt_md = &bbt_mirror_no_oob_descr;
1334 } else {
1335 this->bbt_td = &bbt_main_descr;
1336 this->bbt_md = &bbt_mirror_descr;
1337 }
1338 }
1339 } else {
1340 this->bbt_td = NULL;
1341 this->bbt_md = NULL;
1342 }
1343
1344 if (!this->badblock_pattern)
1345 nand_create_badblock_pattern(this);
1346
1347 return nand_scan_bbt(mtd, this->badblock_pattern);
1348}
1349
1350
1351
1352
1353
1354
1355
1356int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt)
1357{
1358 struct nand_chip *this = mtd->priv;
1359 int block;
1360 uint8_t res;
1361
1362
1363 block = (int)(offs >> (this->bbt_erase_shift - 1));
1364 res = (this->bbt[block >> 3] >> (block & 0x06)) & 0x03;
1365
1366 pr_debug("nand_isbad_bbt(): bbt info for offs 0x%08x: "
1367 "(block %d) 0x%02x\n",
1368 (unsigned int)offs, block >> 1, res);
1369
1370 switch ((int)res) {
1371 case 0x00:
1372 return 0;
1373 case 0x01:
1374 return 1;
1375 case 0x02:
1376 return allowbbt ? 0 : 1;
1377 }
1378 return 1;
1379}
1380
1381EXPORT_SYMBOL(nand_scan_bbt);
1382EXPORT_SYMBOL(nand_default_bbt);
1383EXPORT_SYMBOL_GPL(nand_update_bbt);
1384