]> git.ipfire.org Git - people/ms/u-boot.git/blob - common/cmd_nand.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* Get (mostly) rid of CFG_MONITOR_LEN definition; compute real length
[people/ms/u-boot.git] / common / cmd_nand.c
1 /*
2 * Driver for NAND support, Rick Bronson
3 * borrowed heavily from:
4 * (c) 1999 Machine Vision Holdings, Inc.
5 * (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
6 *
7 */
8
9 #include <common.h>
10 #include <command.h>
11 #include <malloc.h>
12 #include <asm/io.h>
13
14 #ifdef CONFIG_SHOW_BOOT_PROGRESS
15 # include <status_led.h>
16 # define SHOW_BOOT_PROGRESS(arg) show_boot_progress(arg)
17 #else
18 # define SHOW_BOOT_PROGRESS(arg)
19 #endif
20
21 #if (CONFIG_COMMANDS & CFG_CMD_NAND)
22
23 #include <linux/mtd/nftl.h>
24 #include <linux/mtd/nand.h>
25 #include <linux/mtd/nand_ids.h>
26
27 /*
28 * Definition of the out of band configuration structure
29 */
30 struct nand_oob_config {
31 int ecc_pos[6]; /* position of ECC bytes inside oob */
32 int badblock_pos; /* position of bad block flag inside oob -1 = inactive */
33 int eccvalid_pos; /* position of ECC valid flag inside oob -1 = inactive */
34 } oob_config = { {0}, 0, 0};
35
36 #define NAND_DEBUG
37 #undef ECC_DEBUG
38 #undef PSYCHO_DEBUG
39 #undef NFTL_DEBUG
40
41 #define CONFIG_MTD_NAND_ECC /* enable ECC */
42 /* #define CONFIG_MTD_NAND_ECC_JFFS2 */
43
44 /*
45 * Function Prototypes
46 */
47 static void nand_print(struct nand_chip *nand);
48 static int nand_rw (struct nand_chip* nand, int cmd,
49 size_t start, size_t len,
50 size_t * retlen, u_char * buf);
51 static int nand_erase(struct nand_chip* nand, size_t ofs, size_t len);
52 static int nand_read_ecc(struct nand_chip *nand, size_t start, size_t len,
53 size_t * retlen, u_char *buf, u_char *ecc_code);
54 static int nand_write_ecc (struct nand_chip* nand, size_t to, size_t len,
55 size_t * retlen, const u_char * buf, u_char * ecc_code);
56 #ifdef CONFIG_MTD_NAND_ECC
57 static int nand_correct_data (u_char *dat, u_char *read_ecc, u_char *calc_ecc);
58 static void nand_calculate_ecc (const u_char *dat, u_char *ecc_code);
59 #endif
60
61 static struct nand_chip nand_dev_desc[CFG_MAX_NAND_DEVICE] = {{0}};
62
63 /* Current NAND Device */
64 static int curr_device = -1;
65
66 /* ------------------------------------------------------------------------- */
67
68 int do_nand (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
69 {
70 int rcode = 0;
71
72 switch (argc) {
73 case 0:
74 case 1:
75 printf ("Usage:\n%s\n", cmdtp->usage);
76 return 1;
77 case 2:
78 if (strcmp(argv[1],"info") == 0) {
79 int i;
80
81 putc ('\n');
82
83 for (i=0; i<CFG_MAX_NAND_DEVICE; ++i) {
84 if(nand_dev_desc[i].ChipID == NAND_ChipID_UNKNOWN)
85 continue; /* list only known devices */
86 printf ("Device %d: ", i);
87 nand_print(&nand_dev_desc[i]);
88 }
89 return 0;
90
91 } else if (strcmp(argv[1],"device") == 0) {
92 if ((curr_device < 0) || (curr_device >= CFG_MAX_NAND_DEVICE)) {
93 puts ("\nno devices available\n");
94 return 1;
95 }
96 printf ("\nDevice %d: ", curr_device);
97 nand_print(&nand_dev_desc[curr_device]);
98 return 0;
99 }
100 printf ("Usage:\n%s\n", cmdtp->usage);
101 return 1;
102 case 3:
103 if (strcmp(argv[1],"device") == 0) {
104 int dev = (int)simple_strtoul(argv[2], NULL, 10);
105
106 printf ("\nDevice %d: ", dev);
107 if (dev >= CFG_MAX_NAND_DEVICE) {
108 puts ("unknown device\n");
109 return 1;
110 }
111 nand_print(&nand_dev_desc[dev]);
112 /*nand_print (dev);*/
113
114 if (nand_dev_desc[dev].ChipID == NAND_ChipID_UNKNOWN) {
115 return 1;
116 }
117
118 curr_device = dev;
119
120 puts ("... is now current device\n");
121
122 return 0;
123 }
124
125 printf ("Usage:\n%s\n", cmdtp->usage);
126 return 1;
127 default:
128 /* at least 4 args */
129
130 if (strcmp(argv[1],"read") == 0 || strcmp(argv[1],"write") == 0) {
131 ulong addr = simple_strtoul(argv[2], NULL, 16);
132 ulong off = simple_strtoul(argv[3], NULL, 16);
133 ulong size = simple_strtoul(argv[4], NULL, 16);
134 int cmd = (strcmp(argv[1],"read") == 0);
135 int ret, total;
136
137 printf ("\nNAND %s: device %d offset %ld, size %ld ... ",
138 cmd ? "read" : "write", curr_device, off, size);
139
140 ret = nand_rw(nand_dev_desc + curr_device, cmd, off, size,
141 &total, (u_char*)addr);
142
143 printf ("%d bytes %s: %s\n", total, cmd ? "read" : "write",
144 ret ? "ERROR" : "OK");
145
146 return ret;
147 } else if (strcmp(argv[1],"erase") == 0) {
148 ulong off = simple_strtoul(argv[2], NULL, 16);
149 ulong size = simple_strtoul(argv[3], NULL, 16);
150 int ret;
151
152 printf ("\nNAND erase: device %d offset %ld, size %ld ... ",
153 curr_device, off, size);
154
155 ret = nand_erase (nand_dev_desc + curr_device, off, size);
156
157 printf("%s\n", ret ? "ERROR" : "OK");
158
159 return ret;
160 } else {
161 printf ("Usage:\n%s\n", cmdtp->usage);
162 rcode = 1;
163 }
164
165 return rcode;
166 }
167 }
168
169 int do_nandboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
170 {
171 char *boot_device = NULL;
172 char *ep;
173 int dev;
174 ulong cnt;
175 ulong addr;
176 ulong offset = 0;
177 image_header_t *hdr;
178 int rcode = 0;
179 switch (argc) {
180 case 1:
181 addr = CFG_LOAD_ADDR;
182 boot_device = getenv ("bootdevice");
183 break;
184 case 2:
185 addr = simple_strtoul(argv[1], NULL, 16);
186 boot_device = getenv ("bootdevice");
187 break;
188 case 3:
189 addr = simple_strtoul(argv[1], NULL, 16);
190 boot_device = argv[2];
191 break;
192 case 4:
193 addr = simple_strtoul(argv[1], NULL, 16);
194 boot_device = argv[2];
195 offset = simple_strtoul(argv[3], NULL, 16);
196 break;
197 default:
198 printf ("Usage:\n%s\n", cmdtp->usage);
199 SHOW_BOOT_PROGRESS (-1);
200 return 1;
201 }
202
203 if (!boot_device) {
204 puts ("\n** No boot device **\n");
205 SHOW_BOOT_PROGRESS (-1);
206 return 1;
207 }
208
209 dev = simple_strtoul(boot_device, &ep, 16);
210
211 if ((dev >= CFG_MAX_NAND_DEVICE) ||
212 (nand_dev_desc[dev].ChipID == NAND_ChipID_UNKNOWN)) {
213 printf ("\n** Device %d not available\n", dev);
214 SHOW_BOOT_PROGRESS (-1);
215 return 1;
216 }
217
218 printf ("\nLoading from device %d: %s at 0x%lX (offset 0x%lX)\n",
219 dev, nand_dev_desc[dev].name, nand_dev_desc[dev].IO_ADDR,
220 offset);
221
222 if (nand_rw (nand_dev_desc + dev, 1, offset,
223 SECTORSIZE, NULL, (u_char *)addr)) {
224 printf ("** Read error on %d\n", dev);
225 SHOW_BOOT_PROGRESS (-1);
226 return 1;
227 }
228
229 hdr = (image_header_t *)addr;
230
231 if (ntohl(hdr->ih_magic) == IH_MAGIC) {
232
233 print_image_hdr (hdr);
234
235 cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
236 cnt -= SECTORSIZE;
237 } else {
238 printf ("\n** Bad Magic Number 0x%x **\n", hdr->ih_magic);
239 SHOW_BOOT_PROGRESS (-1);
240 return 1;
241 }
242
243 if (nand_rw (nand_dev_desc + dev, 1, offset + SECTORSIZE, cnt,
244 NULL, (u_char *)(addr+SECTORSIZE))) {
245 printf ("** Read error on %d\n", dev);
246 SHOW_BOOT_PROGRESS (-1);
247 return 1;
248 }
249
250 /* Loading ok, update default load address */
251
252 load_addr = addr;
253
254 /* Check if we should attempt an auto-start */
255 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
256 char *local_args[2];
257 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
258
259 local_args[0] = argv[0];
260 local_args[1] = NULL;
261
262 printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
263
264 do_bootm (cmdtp, 0, 1, local_args);
265 rcode = 1;
266 }
267 return rcode;
268 }
269
270 static int nand_rw (struct nand_chip* nand, int cmd,
271 size_t start, size_t len,
272 size_t * retlen, u_char * buf)
273 {
274 int noecc, ret = 0, n, total = 0;
275 char eccbuf[6];
276
277 while(len) {
278 /* The ECC will not be calculated correctly if
279 less than 512 is written or read */
280 noecc = (start != (start | 0x1ff) + 1) || (len < 0x200);
281 if (cmd)
282 ret = nand_read_ecc(nand, start, len,
283 &n, (u_char*)buf,
284 noecc ? NULL : eccbuf);
285 else
286 ret = nand_write_ecc(nand, start, len,
287 &n, (u_char*)buf,
288 noecc ? NULL : eccbuf);
289
290 if (ret)
291 break;
292
293 start += n;
294 buf += n;
295 total += n;
296 len -= n;
297 }
298 if (retlen)
299 *retlen = total;
300
301 return ret;
302 }
303
304 static void nand_print(struct nand_chip *nand)
305 {
306 printf("%s at 0x%lX,\n"
307 "\t %d chip%s %s, size %d MB, \n"
308 "\t total size %ld MB, sector size %ld kB\n",
309 nand->name, nand->IO_ADDR, nand->numchips,
310 nand->numchips>1 ? "s" : "", nand->chips_name,
311 1 << (nand->chipshift - 20),
312 nand->totlen >> 20, nand->erasesize >> 10);
313
314 if (nand->nftl_found) {
315 struct NFTLrecord *nftl = &nand->nftl;
316 unsigned long bin_size, flash_size;
317
318 bin_size = nftl->nb_boot_blocks * nand->erasesize;
319 flash_size = (nftl->nb_blocks - nftl->nb_boot_blocks) * nand->erasesize;
320
321 printf("\t NFTL boot record:\n"
322 "\t Binary partition: size %ld%s\n"
323 "\t Flash disk partition: size %ld%s, offset 0x%lx\n",
324 bin_size > (1 << 20) ? bin_size >> 20 : bin_size >> 10,
325 bin_size > (1 << 20) ? "MB" : "kB",
326 flash_size > (1 << 20) ? flash_size >> 20 : flash_size >> 10,
327 flash_size > (1 << 20) ? "MB" : "kB", bin_size);
328 } else {
329 puts ("\t No NFTL boot record found.\n");
330 }
331 }
332
333 /* ------------------------------------------------------------------------- */
334
335 /* This function is needed to avoid calls of the __ashrdi3 function. */
336 #if 0
337 static int shr(int val, int shift)
338 {
339 return val >> shift;
340 }
341 #endif
342 static int NanD_WaitReady(struct nand_chip *nand)
343 {
344 /* This is inline, to optimise the common case, where it's ready instantly */
345 int ret = 0;
346 NAND_WAIT_READY(nand);
347
348 return ret;
349 }
350
351 /* NanD_Command: Send a flash command to the flash chip */
352
353 static inline int NanD_Command(struct nand_chip *nand, unsigned char command)
354 {
355 unsigned long nandptr = nand->IO_ADDR;
356
357 /* Assert the CLE (Command Latch Enable) line to the flash chip */
358 NAND_CTL_SETCLE(nandptr);
359
360 /* Send the command */
361 WRITE_NAND_COMMAND(command, nandptr);
362
363 /* Lower the CLE line */
364 NAND_CTL_CLRCLE(nandptr);
365
366 return NanD_WaitReady(nand);
367 }
368
369 /* NanD_Address: Set the current address for the flash chip */
370
371 static int NanD_Address(struct nand_chip *nand, int numbytes, unsigned long ofs)
372 {
373 unsigned long nandptr;
374 int i;
375
376 nandptr = nand->IO_ADDR;
377
378 /* Assert the ALE (Address Latch Enable) line to the flash chip */
379 NAND_CTL_SETALE(nandptr);
380
381 /* Send the address */
382 /* Devices with 256-byte page are addressed as:
383 * Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
384 * there is no device on the market with page256
385 * and more than 24 bits.
386 * Devices with 512-byte page are addressed as:
387 * Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
388 * 25-31 is sent only if the chip support it.
389 * bit 8 changes the read command to be sent
390 * (NAND_CMD_READ0 or NAND_CMD_READ1).
391 */
392
393 if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE)
394 WRITE_NAND_ADDRESS(ofs, nandptr);
395
396 ofs = ofs >> nand->page_shift;
397
398 if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE)
399 for (i = 0; i < nand->pageadrlen; i++, ofs = ofs >> 8)
400 WRITE_NAND_ADDRESS(ofs, nandptr);
401
402 /* Lower the ALE line */
403 NAND_CTL_CLRALE(nandptr);
404
405 /* Wait for the chip to respond */
406 return NanD_WaitReady(nand);
407 }
408
409 /* NanD_SelectChip: Select a given flash chip within the current floor */
410
411 static inline int NanD_SelectChip(struct nand_chip *nand, int chip)
412 {
413 /* Wait for it to be ready */
414 return NanD_WaitReady(nand);
415 }
416
417 /* NanD_IdentChip: Identify a given NAND chip given {floor,chip} */
418
419 static int NanD_IdentChip(struct nand_chip *nand, int floor, int chip)
420 {
421 int mfr, id, i;
422
423 NAND_ENABLE_CE(nand); /* set pin low */
424 /* Reset the chip */
425 if (NanD_Command(nand, NAND_CMD_RESET)) {
426 #ifdef NAND_DEBUG
427 printf("NanD_Command (reset) for %d,%d returned true\n",
428 floor, chip);
429 #endif
430 NAND_DISABLE_CE(nand); /* set pin high */
431 return 0;
432 }
433
434 /* Read the NAND chip ID: 1. Send ReadID command */
435 if (NanD_Command(nand, NAND_CMD_READID)) {
436 #ifdef NAND_DEBUG
437 printf("NanD_Command (ReadID) for %d,%d returned true\n",
438 floor, chip);
439 #endif
440 NAND_DISABLE_CE(nand); /* set pin high */
441 return 0;
442 }
443
444 /* Read the NAND chip ID: 2. Send address byte zero */
445 NanD_Address(nand, ADDR_COLUMN, 0);
446
447 /* Read the manufacturer and device id codes from the device */
448
449 mfr = READ_NAND(nand->IO_ADDR);
450
451 id = READ_NAND(nand->IO_ADDR);
452
453 NAND_DISABLE_CE(nand); /* set pin high */
454 /* No response - return failure */
455 if (mfr == 0xff || mfr == 0) {
456 printf("NanD_Command (ReadID) got %d %d\n", mfr, id);
457 return 0;
458 }
459
460 /* Check it's the same as the first chip we identified.
461 * M-Systems say that any given nand_chip device should only
462 * contain _one_ type of flash part, although that's not a
463 * hardware restriction. */
464 if (nand->mfr) {
465 if (nand->mfr == mfr && nand->id == id)
466 return 1; /* This is another the same the first */
467 else
468 printf("Flash chip at floor %d, chip %d is different:\n",
469 floor, chip);
470 }
471
472 /* Print and store the manufacturer and ID codes. */
473 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
474 if (mfr == nand_flash_ids[i].manufacture_id &&
475 id == nand_flash_ids[i].model_id) {
476 #ifdef NAND_DEBUG
477 printf("Flash chip found:\n\t Manufacturer ID: 0x%2.2X, "
478 "Chip ID: 0x%2.2X (%s)\n", mfr, id,
479 nand_flash_ids[i].name);
480 #endif
481 if (!nand->mfr) {
482 nand->mfr = mfr;
483 nand->id = id;
484 nand->chipshift =
485 nand_flash_ids[i].chipshift;
486 nand->page256 = nand_flash_ids[i].page256;
487 if (nand->page256) {
488 nand->oobblock = 256;
489 nand->oobsize = 8;
490 nand->page_shift = 8;
491 } else {
492 nand->oobblock = 512;
493 nand->oobsize = 16;
494 nand->page_shift = 9;
495 }
496 nand->pageadrlen =
497 nand_flash_ids[i].pageadrlen;
498 nand->erasesize =
499 nand_flash_ids[i].erasesize;
500 nand->chips_name =
501 nand_flash_ids[i].name;
502 return 1;
503 }
504 return 0;
505 }
506 }
507
508
509 #ifdef NAND_DEBUG
510 /* We haven't fully identified the chip. Print as much as we know. */
511 printf("Unknown flash chip found: %2.2X %2.2X\n",
512 id, mfr);
513 #endif
514
515 return 0;
516 }
517
518 /* NanD_ScanChips: Find all NAND chips present in a nand_chip, and identify them */
519
520 static void NanD_ScanChips(struct nand_chip *nand)
521 {
522 int floor, chip;
523 int numchips[NAND_MAX_FLOORS];
524 int maxchips = NAND_MAX_CHIPS;
525 int ret = 1;
526
527 nand->numchips = 0;
528 nand->mfr = 0;
529 nand->id = 0;
530
531
532 /* For each floor, find the number of valid chips it contains */
533 for (floor = 0; floor < NAND_MAX_FLOORS; floor++) {
534 ret = 1;
535 numchips[floor] = 0;
536 for (chip = 0; chip < maxchips && ret != 0; chip++) {
537
538 ret = NanD_IdentChip(nand, floor, chip);
539 if (ret) {
540 numchips[floor]++;
541 nand->numchips++;
542 }
543 }
544 }
545
546 /* If there are none at all that we recognise, bail */
547 if (!nand->numchips) {
548 puts ("No flash chips recognised.\n");
549 return;
550 }
551
552 /* Allocate an array to hold the information for each chip */
553 nand->chips = malloc(sizeof(struct Nand) * nand->numchips);
554 if (!nand->chips) {
555 puts ("No memory for allocating chip info structures\n");
556 return;
557 }
558
559 ret = 0;
560
561 /* Fill out the chip array with {floor, chipno} for each
562 * detected chip in the device. */
563 for (floor = 0; floor < NAND_MAX_FLOORS; floor++) {
564 for (chip = 0; chip < numchips[floor]; chip++) {
565 nand->chips[ret].floor = floor;
566 nand->chips[ret].chip = chip;
567 nand->chips[ret].curadr = 0;
568 nand->chips[ret].curmode = 0x50;
569 ret++;
570 }
571 }
572
573 /* Calculate and print the total size of the device */
574 nand->totlen = nand->numchips * (1 << nand->chipshift);
575
576 #ifdef NAND_DEBUG
577 printf("%d flash chips found. Total nand_chip size: %ld MB\n",
578 nand->numchips, nand->totlen >> 20);
579 #endif
580 }
581
582 #ifdef CONFIG_MTD_NAND_ECC
583 /* we need to be fast here, 1 us per read translates to 1 second per meg */
584 static void nand_fast_copy (unsigned char *source, unsigned char *dest, long cntr)
585 {
586 while (cntr > 16) {
587 *dest++ = *source++;
588 *dest++ = *source++;
589 *dest++ = *source++;
590 *dest++ = *source++;
591 *dest++ = *source++;
592 *dest++ = *source++;
593 *dest++ = *source++;
594 *dest++ = *source++;
595 *dest++ = *source++;
596 *dest++ = *source++;
597 *dest++ = *source++;
598 *dest++ = *source++;
599 *dest++ = *source++;
600 *dest++ = *source++;
601 *dest++ = *source++;
602 *dest++ = *source++;
603 cntr -= 16;
604 }
605
606 while (cntr > 0) {
607 *dest++ = *source++;
608 cntr--;
609 }
610 }
611 #endif
612
613 /* we need to be fast here, 1 us per read translates to 1 second per meg */
614 static void nand_fast_read(unsigned char *data_buf, int cntr, unsigned long nandptr)
615 {
616 while (cntr > 16) {
617 *data_buf++ = READ_NAND(nandptr);
618 *data_buf++ = READ_NAND(nandptr);
619 *data_buf++ = READ_NAND(nandptr);
620 *data_buf++ = READ_NAND(nandptr);
621 *data_buf++ = READ_NAND(nandptr);
622 *data_buf++ = READ_NAND(nandptr);
623 *data_buf++ = READ_NAND(nandptr);
624 *data_buf++ = READ_NAND(nandptr);
625 *data_buf++ = READ_NAND(nandptr);
626 *data_buf++ = READ_NAND(nandptr);
627 *data_buf++ = READ_NAND(nandptr);
628 *data_buf++ = READ_NAND(nandptr);
629 *data_buf++ = READ_NAND(nandptr);
630 *data_buf++ = READ_NAND(nandptr);
631 *data_buf++ = READ_NAND(nandptr);
632 *data_buf++ = READ_NAND(nandptr);
633 cntr -= 16;
634 }
635
636 while (cntr > 0) {
637 *data_buf++ = READ_NAND(nandptr);
638 cntr--;
639 }
640 }
641
642 /* This routine is made available to other mtd code via
643 * inter_module_register. It must only be accessed through
644 * inter_module_get which will bump the use count of this module. The
645 * addresses passed back in mtd are valid as long as the use count of
646 * this module is non-zero, i.e. between inter_module_get and
647 * inter_module_put. Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
648 */
649
650 /*
651 * NAND read with ECC
652 */
653 static int nand_read_ecc(struct nand_chip *nand, size_t start, size_t len,
654 size_t * retlen, u_char *buf, u_char *ecc_code)
655 {
656 int col, page;
657 int ecc_status = 0;
658 #ifdef CONFIG_MTD_NAND_ECC
659 int j;
660 int ecc_failed = 0;
661 u_char *data_poi;
662 u_char ecc_calc[6];
663 #endif
664 unsigned long nandptr = nand->IO_ADDR;
665
666 /* Do not allow reads past end of device */
667 if ((start + len) > nand->totlen) {
668 printf ("%s: Attempt read beyond end of device %x %x %x\n", __FUNCTION__, (uint) start, (uint) len, (uint) nand->totlen);
669 *retlen = 0;
670 return -1;
671 }
672
673 /* First we calculate the starting page */
674 /*page = shr(start, nand->page_shift);*/
675 page = start >> nand->page_shift;
676
677 /* Get raw starting column */
678 col = start & (nand->oobblock - 1);
679
680 /* Initialize return value */
681 *retlen = 0;
682
683 /* Select the NAND device */
684 NAND_ENABLE_CE(nand); /* set pin low */
685
686 /* Loop until all data read */
687 while (*retlen < len) {
688
689
690 #ifdef CONFIG_MTD_NAND_ECC
691
692 /* Do we have this page in cache ? */
693 if (nand->cache_page == page)
694 goto readdata;
695 /* Send the read command */
696 NanD_Command(nand, NAND_CMD_READ0);
697 NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
698 /* Read in a page + oob data */
699 nand_fast_read(nand->data_buf, nand->oobblock + nand->oobsize, nandptr);
700
701 /* copy data into cache, for read out of cache and if ecc fails */
702 if (nand->data_cache)
703 memcpy (nand->data_cache, nand->data_buf, nand->oobblock + nand->oobsize);
704
705 /* Pick the ECC bytes out of the oob data */
706 for (j = 0; j < 6; j++)
707 ecc_code[j] = nand->data_buf[(nand->oobblock + oob_config.ecc_pos[j])];
708
709 /* Calculate the ECC and verify it */
710 /* If block was not written with ECC, skip ECC */
711 if (oob_config.eccvalid_pos != -1 &&
712 (nand->data_buf[nand->oobblock + oob_config.eccvalid_pos] & 0x0f) != 0x0f) {
713
714 nand_calculate_ecc (&nand->data_buf[0], &ecc_calc[0]);
715 switch (nand_correct_data (&nand->data_buf[0], &ecc_code[0], &ecc_calc[0])) {
716 case -1:
717 printf ("%s: Failed ECC read, page 0x%08x\n", __FUNCTION__, page);
718 ecc_failed++;
719 break;
720 case 1:
721 case 2: /* transfer ECC corrected data to cache */
722 memcpy (nand->data_cache, nand->data_buf, 256);
723 break;
724 }
725 }
726
727 if (oob_config.eccvalid_pos != -1 &&
728 nand->oobblock == 512 && (nand->data_buf[nand->oobblock + oob_config.eccvalid_pos] & 0xf0) != 0xf0) {
729
730 nand_calculate_ecc (&nand->data_buf[256], &ecc_calc[3]);
731 switch (nand_correct_data (&nand->data_buf[256], &ecc_code[3], &ecc_calc[3])) {
732 case -1:
733 printf ("%s: Failed ECC read, page 0x%08x\n", __FUNCTION__, page);
734 ecc_failed++;
735 break;
736 case 1:
737 case 2: /* transfer ECC corrected data to cache */
738 if (nand->data_cache)
739 memcpy (&nand->data_cache[256], &nand->data_buf[256], 256);
740 break;
741 }
742 }
743 readdata:
744 /* Read the data from ECC data buffer into return buffer */
745 data_poi = (nand->data_cache) ? nand->data_cache : nand->data_buf;
746 data_poi += col;
747 if ((*retlen + (nand->oobblock - col)) >= len) {
748 nand_fast_copy (data_poi, buf + *retlen, len - *retlen);
749 *retlen = len;
750 } else {
751 nand_fast_copy (data_poi, buf + *retlen, nand->oobblock - col);
752 *retlen += nand->oobblock - col;
753 }
754 /* Set cache page address, invalidate, if ecc_failed */
755 nand->cache_page = (nand->data_cache && !ecc_failed) ? page : -1;
756
757 ecc_status += ecc_failed;
758 ecc_failed = 0;
759
760 #else
761 /* Send the read command */
762 NanD_Command(nand, NAND_CMD_READ0);
763 NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
764 /* Read the data directly into the return buffer */
765 if ((*retlen + (nand->oobblock - col)) >= len) {
766 nand_fast_read(buf + *retlen, len - *retlen, nandptr);
767 *retlen = len;
768 /* We're done */
769 continue;
770 } else {
771 nand_fast_read(buf + *retlen, nand->oobblock - col, nandptr);
772 *retlen += nand->oobblock - col;
773 }
774 #endif
775 /* For subsequent reads align to page boundary. */
776 col = 0;
777 /* Increment page address */
778 page++;
779 }
780
781 /* De-select the NAND device */
782 NAND_DISABLE_CE(nand); /* set pin high */
783
784 /*
785 * Return success, if no ECC failures, else -EIO
786 * fs driver will take care of that, because
787 * retlen == desired len and result == -EIO
788 */
789 return ecc_status ? -1 : 0;
790 }
791
792 /*
793 * Nand_page_program function is used for write and writev !
794 */
795 static int nand_write_page (struct nand_chip *nand,
796 int page, int col, int last, u_char * ecc_code)
797 {
798
799 int i;
800 #ifdef CONFIG_MTD_NAND_ECC
801 unsigned long nandptr = nand->IO_ADDR;
802 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
803 int ecc_bytes = (nand->oobblock == 512) ? 6 : 3;
804 #endif
805 #endif
806 /* pad oob area */
807 for (i = nand->oobblock; i < nand->oobblock + nand->oobsize; i++)
808 nand->data_buf[i] = 0xff;
809
810 #ifdef CONFIG_MTD_NAND_ECC
811 /* Zero out the ECC array */
812 for (i = 0; i < 6; i++)
813 ecc_code[i] = 0x00;
814
815 /* Read back previous written data, if col > 0 */
816 if (col) {
817 NanD_Command(nand, NAND_CMD_READ0);
818 NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
819 for (i = 0; i < col; i++)
820 nand->data_buf[i] = READ_NAND (nandptr);
821 }
822
823 /* Calculate and write the ECC if we have enough data */
824 if ((col < nand->eccsize) && (last >= nand->eccsize)) {
825 nand_calculate_ecc (&nand->data_buf[0], &(ecc_code[0]));
826 for (i = 0; i < 3; i++)
827 nand->data_buf[(nand->oobblock + oob_config.ecc_pos[i])] = ecc_code[i];
828 if (oob_config.eccvalid_pos != -1)
829 nand->data_buf[nand->oobblock + oob_config.eccvalid_pos] = 0xf0;
830 }
831
832 /* Calculate and write the second ECC if we have enough data */
833 if ((nand->oobblock == 512) && (last == nand->oobblock)) {
834 nand_calculate_ecc (&nand->data_buf[256], &(ecc_code[3]));
835 for (i = 3; i < 6; i++)
836 nand->data_buf[(nand->oobblock + oob_config.ecc_pos[i])] = ecc_code[i];
837 if (oob_config.eccvalid_pos != -1)
838 nand->data_buf[nand->oobblock + oob_config.eccvalid_pos] &= 0x0f;
839 }
840 #endif
841 /* Prepad for partial page programming !!! */
842 for (i = 0; i < col; i++)
843 nand->data_buf[i] = 0xff;
844
845 /* Postpad for partial page programming !!! oob is already padded */
846 for (i = last; i < nand->oobblock; i++)
847 nand->data_buf[i] = 0xff;
848
849 /* Send command to begin auto page programming */
850 NanD_Command(nand, NAND_CMD_SEQIN);
851 NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
852
853 /* Write out complete page of data */
854 for (i = 0; i < (nand->oobblock + nand->oobsize); i++)
855 WRITE_NAND(nand->data_buf[i], nand->IO_ADDR);
856
857 /* Send command to actually program the data */
858 NanD_Command(nand, NAND_CMD_PAGEPROG);
859 NanD_Command(nand, NAND_CMD_STATUS);
860
861 /* See if device thinks it succeeded */
862 if (READ_NAND(nand->IO_ADDR) & 0x01) {
863 printf ("%s: Failed write, page 0x%08x, ", __FUNCTION__, page);
864 return -1;
865 }
866 #ifdef CONFIG_MTD_NAND_VERIFY_WRITE
867 /*
868 * The NAND device assumes that it is always writing to
869 * a cleanly erased page. Hence, it performs its internal
870 * write verification only on bits that transitioned from
871 * 1 to 0. The device does NOT verify the whole page on a
872 * byte by byte basis. It is possible that the page was
873 * not completely erased or the page is becoming unusable
874 * due to wear. The read with ECC would catch the error
875 * later when the ECC page check fails, but we would rather
876 * catch it early in the page write stage. Better to write
877 * no data than invalid data.
878 */
879
880 /* Send command to read back the page */
881 if (col < nand->eccsize)
882 NanD_Command(nand, NAND_CMD_READ0);
883 else
884 NanD_Command(nand, NAND_CMD_READ1);
885 NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
886
887 /* Loop through and verify the data */
888 for (i = col; i < last; i++) {
889 if (nand->data_buf[i] != readb (nand->IO_ADDR)) {
890 printf ("%s: Failed write verify, page 0x%08x ", __FUNCTION__, page);
891 return -1;
892 }
893 }
894
895 #ifdef CONFIG_MTD_NAND_ECC
896 /*
897 * We also want to check that the ECC bytes wrote
898 * correctly for the same reasons stated above.
899 */
900 NanD_Command(nand, NAND_CMD_READOOB);
901 NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
902 for (i = 0; i < nand->oobsize; i++)
903 nand->data_buf[i] = readb (nand->IO_ADDR);
904 for (i = 0; i < ecc_bytes; i++) {
905 if ((nand->data_buf[(oob_config.ecc_pos[i])] != ecc_code[i]) && ecc_code[i]) {
906 printf ("%s: Failed ECC write "
907 "verify, page 0x%08x, " "%6i bytes were succesful\n", __FUNCTION__, page, i);
908 return -1;
909 }
910 }
911 #endif
912 #endif
913 return 0;
914 }
915
916 static int nand_write_ecc (struct nand_chip* nand, size_t to, size_t len,
917 size_t * retlen, const u_char * buf, u_char * ecc_code)
918 {
919 int i, page, col, cnt, ret = 0;
920
921 /* Do not allow write past end of device */
922 if ((to + len) > nand->totlen) {
923 printf ("%s: Attempt to write past end of page\n", __FUNCTION__);
924 return -1;
925 }
926
927 /* Shift to get page */
928 page = ((int) to) >> nand->page_shift;
929
930 /* Get the starting column */
931 col = to & (nand->oobblock - 1);
932
933 /* Initialize return length value */
934 *retlen = 0;
935
936 /* Select the NAND device */
937 NAND_ENABLE_CE(nand); /* set pin low */
938
939 /* Check the WP bit */
940 NanD_Command(nand, NAND_CMD_STATUS);
941 if (!(READ_NAND(nand->IO_ADDR) & 0x80)) {
942 printf ("%s: Device is write protected!!!\n", __FUNCTION__);
943 ret = -1;
944 goto out;
945 }
946
947 /* Loop until all data is written */
948 while (*retlen < len) {
949 /* Invalidate cache, if we write to this page */
950 if (nand->cache_page == page)
951 nand->cache_page = -1;
952
953 /* Write data into buffer */
954 if ((col + len) >= nand->oobblock)
955 for (i = col, cnt = 0; i < nand->oobblock; i++, cnt++)
956 nand->data_buf[i] = buf[(*retlen + cnt)];
957 else
958 for (i = col, cnt = 0; cnt < (len - *retlen); i++, cnt++)
959 nand->data_buf[i] = buf[(*retlen + cnt)];
960 /* We use the same function for write and writev !) */
961 ret = nand_write_page (nand, page, col, i, ecc_code);
962 if (ret)
963 goto out;
964
965 /* Next data start at page boundary */
966 col = 0;
967
968 /* Update written bytes count */
969 *retlen += cnt;
970
971 /* Increment page address */
972 page++;
973 }
974
975 /* Return happy */
976 *retlen = len;
977
978 out:
979 /* De-select the NAND device */
980 NAND_DISABLE_CE(nand); /* set pin high */
981
982 return ret;
983 }
984
985 #if 0 /* not used */
986 /* Read a buffer from NanD */
987 static void NanD_ReadBuf(struct nand_chip *nand, u_char * buf, int len)
988 {
989 unsigned long nandptr;
990
991 nandptr = nand->IO_ADDR;
992
993 for (; len > 0; len--)
994 *buf++ = READ_NAND(nandptr);
995
996 }
997 /* Write a buffer to NanD */
998 static void NanD_WriteBuf(struct nand_chip *nand, const u_char * buf, int len)
999 {
1000 unsigned long nandptr;
1001 int i;
1002
1003 nandptr = nand->IO_ADDR;
1004
1005 if (len <= 0)
1006 return;
1007
1008 for (i = 0; i < len; i++)
1009 WRITE_NAND(buf[i], nandptr);
1010
1011 }
1012
1013 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
1014 * various device information of the NFTL partition and Bad Unit Table. Update
1015 * the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
1016 * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
1017 */
1018 static int find_boot_record(struct NFTLrecord *nftl)
1019 {
1020 struct nftl_uci1 h1;
1021 struct nftl_oob oob;
1022 unsigned int block, boot_record_count = 0;
1023 int retlen;
1024 u8 buf[SECTORSIZE];
1025 struct NFTLMediaHeader *mh = &nftl->MediaHdr;
1026 unsigned int i;
1027
1028 nftl->MediaUnit = BLOCK_NIL;
1029 nftl->SpareMediaUnit = BLOCK_NIL;
1030
1031 /* search for a valid boot record */
1032 for (block = 0; block < nftl->nb_blocks; block++) {
1033 int ret;
1034
1035 /* Check for ANAND header first. Then can whinge if it's found but later
1036 checks fail */
1037 if ((ret = nand_read_ecc(nftl->mtd, block * nftl->EraseSize, SECTORSIZE,
1038 &retlen, buf, NULL))) {
1039 static int warncount = 5;
1040
1041 if (warncount) {
1042 printf("Block read at 0x%x failed\n", block * nftl->EraseSize);
1043 if (!--warncount)
1044 puts ("Further failures for this block will not be printed\n");
1045 }
1046 continue;
1047 }
1048
1049 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
1050 /* ANAND\0 not found. Continue */
1051 #ifdef PSYCHO_DEBUG
1052 printf("ANAND header not found at 0x%x\n", block * nftl->EraseSize);
1053 #endif
1054 continue;
1055 }
1056
1057 #ifdef NFTL_DEBUG
1058 printf("ANAND header found at 0x%x\n", block * nftl->EraseSize);
1059 #endif
1060
1061 /* To be safer with BIOS, also use erase mark as discriminant */
1062 if ((ret = nand_read_oob(nftl->mtd, block * nftl->EraseSize + SECTORSIZE + 8,
1063 8, &retlen, (char *)&h1) < 0)) {
1064 #ifdef NFTL_DEBUG
1065 printf("ANAND header found at 0x%x, but OOB data read failed\n",
1066 block * nftl->EraseSize);
1067 #endif
1068 continue;
1069 }
1070
1071 /* OK, we like it. */
1072
1073 if (boot_record_count) {
1074 /* We've already processed one. So we just check if
1075 this one is the same as the first one we found */
1076 if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
1077 #ifdef NFTL_DEBUG
1078 printf("NFTL Media Headers at 0x%x and 0x%x disagree.\n",
1079 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
1080 #endif
1081 /* if (debug) Print both side by side */
1082 return -1;
1083 }
1084 if (boot_record_count == 1)
1085 nftl->SpareMediaUnit = block;
1086
1087 boot_record_count++;
1088 continue;
1089 }
1090
1091 /* This is the first we've seen. Copy the media header structure into place */
1092 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
1093
1094 /* Do some sanity checks on it */
1095 if (mh->UnitSizeFactor != 0xff) {
1096 puts ("Sorry, we don't support UnitSizeFactor "
1097 "of != 1 yet.\n");
1098 return -1;
1099 }
1100
1101 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
1102 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
1103 printf ("NFTL Media Header sanity check failed:\n"
1104 "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
1105 nftl->nb_boot_blocks, nftl->nb_blocks);
1106 return -1;
1107 }
1108
1109 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
1110 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
1111 printf ("NFTL Media Header sanity check failed:\n"
1112 "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
1113 nftl->numvunits,
1114 nftl->nb_blocks,
1115 nftl->nb_boot_blocks);
1116 return -1;
1117 }
1118
1119 nftl->nr_sects = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
1120
1121 /* If we're not using the last sectors in the device for some reason,
1122 reduce nb_blocks accordingly so we forget they're there */
1123 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
1124
1125 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
1126 for (i = 0; i < nftl->nb_blocks; i++) {
1127 if ((i & (SECTORSIZE - 1)) == 0) {
1128 /* read one sector for every SECTORSIZE of blocks */
1129 if ((ret = nand_read_ecc(nftl->mtd, block * nftl->EraseSize +
1130 i + SECTORSIZE, SECTORSIZE,
1131 &retlen, buf, (char *)&oob)) < 0) {
1132 puts ("Read of bad sector table failed\n");
1133 return -1;
1134 }
1135 }
1136 /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
1137 if (buf[i & (SECTORSIZE - 1)] != 0xff)
1138 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
1139 }
1140
1141 nftl->MediaUnit = block;
1142 boot_record_count++;
1143
1144 } /* foreach (block) */
1145
1146 return boot_record_count?0:-1;
1147 }
1148 static int nand_read_oob(struct nand_chip* nand, size_t ofs, size_t len,
1149 size_t * retlen, u_char * buf)
1150 {
1151 int len256 = 0, ret;
1152 unsigned long nandptr;
1153 struct Nand *mychip;
1154 int ret = 0;
1155
1156 nandptr = nand->IO_ADDR;
1157
1158 mychip = &nand->chips[shr(ofs, nand->chipshift)];
1159
1160 /* update address for 2M x 8bit devices. OOB starts on the second */
1161 /* page to maintain compatibility with nand_read_ecc. */
1162 if (nand->page256) {
1163 if (!(ofs & 0x8))
1164 ofs += 0x100;
1165 else
1166 ofs -= 0x8;
1167 }
1168
1169 NanD_Command(nand, NAND_CMD_READOOB);
1170 NanD_Address(nand, ADDR_COLUMN_PAGE, ofs);
1171
1172 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1173 /* Note: datasheet says it should automaticaly wrap to the */
1174 /* next OOB block, but it didn't work here. mf. */
1175 if (nand->page256 && ofs + len > (ofs | 0x7) + 1) {
1176 len256 = (ofs | 0x7) + 1 - ofs;
1177 NanD_ReadBuf(nand, buf, len256);
1178
1179 NanD_Command(nand, NAND_CMD_READOOB);
1180 NanD_Address(nand, ADDR_COLUMN_PAGE, ofs & (~0x1ff));
1181 }
1182
1183 NanD_ReadBuf(nand, &buf[len256], len - len256);
1184
1185 *retlen = len;
1186 /* Reading the full OOB data drops us off of the end of the page,
1187 * causing the flash device to go into busy mode, so we need
1188 * to wait until ready 11.4.1 and Toshiba TC58256FT nands */
1189
1190 ret = NanD_WaitReady(nand);
1191
1192 return ret;
1193
1194 }
1195 static int nand_write_oob(struct nand_chip* nand, size_t ofs, size_t len,
1196 size_t * retlen, const u_char * buf)
1197 {
1198 int len256 = 0;
1199 unsigned long nandptr = nand->IO_ADDR;
1200
1201 #ifdef PSYCHO_DEBUG
1202 printf("nand_write_oob(%lx, %d): %2.2X %2.2X %2.2X %2.2X ... %2.2X %2.2X .. %2.2X %2.2X\n",
1203 (long)ofs, len, buf[0], buf[1], buf[2], buf[3],
1204 buf[8], buf[9], buf[14],buf[15]);
1205 #endif
1206
1207 /* Reset the chip */
1208 NanD_Command(nand, NAND_CMD_RESET);
1209
1210 /* issue the Read2 command to set the pointer to the Spare Data Area. */
1211 NanD_Command(nand, NAND_CMD_READOOB);
1212 NanD_Address(nand, ADDR_COLUMN_PAGE, ofs);
1213
1214 /* update address for 2M x 8bit devices. OOB starts on the second */
1215 /* page to maintain compatibility with nand_read_ecc. */
1216 if (nand->page256) {
1217 if (!(ofs & 0x8))
1218 ofs += 0x100;
1219 else
1220 ofs -= 0x8;
1221 }
1222
1223 /* issue the Serial Data In command to initial the Page Program process */
1224 NanD_Command(nand, NAND_CMD_SEQIN);
1225 NanD_Address(nand, ADDR_COLUMN_PAGE, ofs);
1226
1227 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1228 /* Note: datasheet says it should automaticaly wrap to the */
1229 /* next OOB block, but it didn't work here. mf. */
1230 if (nand->page256 && ofs + len > (ofs | 0x7) + 1) {
1231 len256 = (ofs | 0x7) + 1 - ofs;
1232 NanD_WriteBuf(nand, buf, len256);
1233
1234 NanD_Command(nand, NAND_CMD_PAGEPROG);
1235 NanD_Command(nand, NAND_CMD_STATUS);
1236 /* NanD_WaitReady() is implicit in NanD_Command */
1237
1238 if (READ_NAND(nandptr) & 1) {
1239 puts ("Error programming oob data\n");
1240 /* There was an error */
1241 *retlen = 0;
1242 return -1;
1243 }
1244 NanD_Command(nand, NAND_CMD_SEQIN);
1245 NanD_Address(nand, ADDR_COLUMN_PAGE, ofs & (~0x1ff));
1246 }
1247
1248 NanD_WriteBuf(nand, &buf[len256], len - len256);
1249
1250 NanD_Command(nand, NAND_CMD_PAGEPROG);
1251 NanD_Command(nand, NAND_CMD_STATUS);
1252 /* NanD_WaitReady() is implicit in NanD_Command */
1253
1254 if (READ_NAND(nandptr) & 1) {
1255 puts ("Error programming oob data\n");
1256 /* There was an error */
1257 *retlen = 0;
1258 return -1;
1259 }
1260
1261 *retlen = len;
1262 return 0;
1263
1264 }
1265 #endif
1266
1267 static int nand_erase(struct nand_chip* nand, size_t ofs, size_t len)
1268 {
1269 unsigned long nandptr;
1270 struct Nand *mychip;
1271 int ret = 0;
1272
1273 if (ofs & (nand->erasesize-1) || len & (nand->erasesize-1)) {
1274 printf ("Offset and size must be sector aligned, erasesize = %d\n",
1275 (int) nand->erasesize);
1276 return -1;
1277 }
1278
1279 nandptr = nand->IO_ADDR;
1280
1281 /* Select the NAND device */
1282 NAND_ENABLE_CE(nand); /* set pin low */
1283
1284 /* Check the WP bit */
1285 NanD_Command(nand, NAND_CMD_STATUS);
1286 if (!(READ_NAND(nand->IO_ADDR) & 0x80)) {
1287 printf ("nand_write_ecc: Device is write protected!!!\n");
1288 ret = -1;
1289 goto out;
1290 }
1291
1292 /* Select the NAND device */
1293 NAND_ENABLE_CE(nand); /* set pin low */
1294
1295 /* Check the WP bit */
1296 NanD_Command(nand, NAND_CMD_STATUS);
1297 if (!(READ_NAND(nand->IO_ADDR) & 0x80)) {
1298 printf ("%s: Device is write protected!!!\n", __FUNCTION__);
1299 ret = -1;
1300 goto out;
1301 }
1302
1303 /* FIXME: Do nand in the background. Use timers or schedule_task() */
1304 while(len) {
1305 /*mychip = &nand->chips[shr(ofs, nand->chipshift)];*/
1306 mychip = &nand->chips[ofs >> nand->chipshift];
1307
1308 NanD_Command(nand, NAND_CMD_ERASE1);
1309 NanD_Address(nand, ADDR_PAGE, ofs);
1310 NanD_Command(nand, NAND_CMD_ERASE2);
1311
1312 NanD_Command(nand, NAND_CMD_STATUS);
1313
1314 if (READ_NAND(nandptr) & 1) {
1315 printf ("%s: Error erasing at 0x%lx\n",
1316 __FUNCTION__, (long)ofs);
1317 /* There was an error */
1318 ret = -1;
1319 goto out;
1320 }
1321 ofs += nand->erasesize;
1322 len -= nand->erasesize;
1323 }
1324
1325 out:
1326 /* De-select the NAND device */
1327 NAND_DISABLE_CE(nand); /* set pin high */
1328
1329 return ret;
1330 }
1331
1332 static inline int nandcheck(unsigned long potential, unsigned long physadr)
1333 {
1334 return 0;
1335 }
1336
1337 void nand_probe(unsigned long physadr)
1338 {
1339 struct nand_chip *nand = NULL;
1340 int i = 0, ChipID = 1;
1341
1342 #ifdef CONFIG_MTD_NAND_ECC_JFFS2
1343 oob_config.ecc_pos[0] = NAND_JFFS2_OOB_ECCPOS0;
1344 oob_config.ecc_pos[1] = NAND_JFFS2_OOB_ECCPOS1;
1345 oob_config.ecc_pos[2] = NAND_JFFS2_OOB_ECCPOS2;
1346 oob_config.ecc_pos[3] = NAND_JFFS2_OOB_ECCPOS3;
1347 oob_config.ecc_pos[4] = NAND_JFFS2_OOB_ECCPOS4;
1348 oob_config.ecc_pos[5] = NAND_JFFS2_OOB_ECCPOS5;
1349 oob_config.badblock_pos = 5;
1350 oob_config.eccvalid_pos = 4;
1351 #else
1352 oob_config.ecc_pos[0] = NAND_NOOB_ECCPOS0;
1353 oob_config.ecc_pos[1] = NAND_NOOB_ECCPOS1;
1354 oob_config.ecc_pos[2] = NAND_NOOB_ECCPOS2;
1355 oob_config.ecc_pos[3] = NAND_NOOB_ECCPOS3;
1356 oob_config.ecc_pos[4] = NAND_NOOB_ECCPOS4;
1357 oob_config.ecc_pos[5] = NAND_NOOB_ECCPOS5;
1358 oob_config.badblock_pos = NAND_NOOB_BADBPOS;
1359 oob_config.eccvalid_pos = NAND_NOOB_ECCVPOS;
1360 #endif
1361
1362 for (i=0; i<CFG_MAX_NAND_DEVICE; i++) {
1363 if (nand_dev_desc[i].ChipID == NAND_ChipID_UNKNOWN) {
1364 nand = nand_dev_desc + i;
1365 break;
1366 }
1367 }
1368
1369 if (curr_device == -1)
1370 curr_device = i;
1371
1372 memset((char *)nand, 0, sizeof(struct nand_chip));
1373
1374 nand->cache_page = -1; /* init the cache page */
1375 nand->IO_ADDR = physadr;
1376 nand->ChipID = ChipID;
1377 NanD_ScanChips(nand);
1378 nand->data_buf = malloc (nand->oobblock + nand->oobsize);
1379 if (!nand->data_buf) {
1380 puts ("Cannot allocate memory for data structures.\n");
1381 return;
1382 }
1383 }
1384
1385 #ifdef CONFIG_MTD_NAND_ECC
1386 /*
1387 * Pre-calculated 256-way 1 byte column parity
1388 */
1389 static const u_char nand_ecc_precalc_table[] = {
1390 0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00,
1391 0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
1392 0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
1393 0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
1394 0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
1395 0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
1396 0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
1397 0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
1398 0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
1399 0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
1400 0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
1401 0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
1402 0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
1403 0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
1404 0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
1405 0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00
1406 };
1407
1408
1409 /*
1410 * Creates non-inverted ECC code from line parity
1411 */
1412 static void nand_trans_result(u_char reg2, u_char reg3,
1413 u_char *ecc_code)
1414 {
1415 u_char a, b, i, tmp1, tmp2;
1416
1417 /* Initialize variables */
1418 a = b = 0x80;
1419 tmp1 = tmp2 = 0;
1420
1421 /* Calculate first ECC byte */
1422 for (i = 0; i < 4; i++) {
1423 if (reg3 & a) /* LP15,13,11,9 --> ecc_code[0] */
1424 tmp1 |= b;
1425 b >>= 1;
1426 if (reg2 & a) /* LP14,12,10,8 --> ecc_code[0] */
1427 tmp1 |= b;
1428 b >>= 1;
1429 a >>= 1;
1430 }
1431
1432 /* Calculate second ECC byte */
1433 b = 0x80;
1434 for (i = 0; i < 4; i++) {
1435 if (reg3 & a) /* LP7,5,3,1 --> ecc_code[1] */
1436 tmp2 |= b;
1437 b >>= 1;
1438 if (reg2 & a) /* LP6,4,2,0 --> ecc_code[1] */
1439 tmp2 |= b;
1440 b >>= 1;
1441 a >>= 1;
1442 }
1443
1444 /* Store two of the ECC bytes */
1445 ecc_code[0] = tmp1;
1446 ecc_code[1] = tmp2;
1447 }
1448
1449 /*
1450 * Calculate 3 byte ECC code for 256 byte block
1451 */
1452 static void nand_calculate_ecc (const u_char *dat, u_char *ecc_code)
1453 {
1454 u_char idx, reg1, reg2, reg3;
1455 int j;
1456
1457 /* Initialize variables */
1458 reg1 = reg2 = reg3 = 0;
1459 ecc_code[0] = ecc_code[1] = ecc_code[2] = 0;
1460
1461 /* Build up column parity */
1462 for(j = 0; j < 256; j++) {
1463
1464 /* Get CP0 - CP5 from table */
1465 idx = nand_ecc_precalc_table[dat[j]];
1466 reg1 ^= (idx & 0x3f);
1467
1468 /* All bit XOR = 1 ? */
1469 if (idx & 0x40) {
1470 reg3 ^= (u_char) j;
1471 reg2 ^= ~((u_char) j);
1472 }
1473 }
1474
1475 /* Create non-inverted ECC code from line parity */
1476 nand_trans_result(reg2, reg3, ecc_code);
1477
1478 /* Calculate final ECC code */
1479 ecc_code[0] = ~ecc_code[0];
1480 ecc_code[1] = ~ecc_code[1];
1481 ecc_code[2] = ((~reg1) << 2) | 0x03;
1482 }
1483
1484 /*
1485 * Detect and correct a 1 bit error for 256 byte block
1486 */
1487 static int nand_correct_data (u_char *dat, u_char *read_ecc, u_char *calc_ecc)
1488 {
1489 u_char a, b, c, d1, d2, d3, add, bit, i;
1490
1491 /* Do error detection */
1492 d1 = calc_ecc[0] ^ read_ecc[0];
1493 d2 = calc_ecc[1] ^ read_ecc[1];
1494 d3 = calc_ecc[2] ^ read_ecc[2];
1495
1496 if ((d1 | d2 | d3) == 0) {
1497 /* No errors */
1498 return 0;
1499 }
1500 else {
1501 a = (d1 ^ (d1 >> 1)) & 0x55;
1502 b = (d2 ^ (d2 >> 1)) & 0x55;
1503 c = (d3 ^ (d3 >> 1)) & 0x54;
1504
1505 /* Found and will correct single bit error in the data */
1506 if ((a == 0x55) && (b == 0x55) && (c == 0x54)) {
1507 c = 0x80;
1508 add = 0;
1509 a = 0x80;
1510 for (i=0; i<4; i++) {
1511 if (d1 & c)
1512 add |= a;
1513 c >>= 2;
1514 a >>= 1;
1515 }
1516 c = 0x80;
1517 for (i=0; i<4; i++) {
1518 if (d2 & c)
1519 add |= a;
1520 c >>= 2;
1521 a >>= 1;
1522 }
1523 bit = 0;
1524 b = 0x04;
1525 c = 0x80;
1526 for (i=0; i<3; i++) {
1527 if (d3 & c)
1528 bit |= b;
1529 c >>= 2;
1530 b >>= 1;
1531 }
1532 b = 0x01;
1533 a = dat[add];
1534 a ^= (b << bit);
1535 dat[add] = a;
1536 return 1;
1537 }
1538 else {
1539 i = 0;
1540 while (d1) {
1541 if (d1 & 0x01)
1542 ++i;
1543 d1 >>= 1;
1544 }
1545 while (d2) {
1546 if (d2 & 0x01)
1547 ++i;
1548 d2 >>= 1;
1549 }
1550 while (d3) {
1551 if (d3 & 0x01)
1552 ++i;
1553 d3 >>= 1;
1554 }
1555 if (i == 1) {
1556 /* ECC Code Error Correction */
1557 read_ecc[0] = calc_ecc[0];
1558 read_ecc[1] = calc_ecc[1];
1559 read_ecc[2] = calc_ecc[2];
1560 return 2;
1561 }
1562 else {
1563 /* Uncorrectable Error */
1564 return -1;
1565 }
1566 }
1567 }
1568
1569 /* Should never happen */
1570 return -1;
1571 }
1572 #endif
1573 #endif /* (CONFIG_COMMANDS & CFG_CMD_NAND) */
"Das U-Boot" Source Tree