]> git.ipfire.org Git - people/ms/u-boot.git/blob - common/cmd_doc.c
projects / people / ms / u-boot.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' of git://www.denx.de/git/u-boot-mpc85xx
[people/ms/u-boot.git] / common / cmd_doc.c
1 /*
2 * Driver for Disk-On-Chip 2000 and Millennium
3 * (c) 1999 Machine Vision Holdings, Inc.
4 * (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
5 *
6 * $Id: doc2000.c,v 1.46 2001/10/02 15:05:13 dwmw2 Exp $
7 */
8
9 #include <common.h>
10 #include <config.h>
11 #include <command.h>
12 #include <malloc.h>
13 #include <asm/io.h>
14 #include <linux/mtd/nftl.h>
15 #include <linux/mtd/doc2000.h>
16
17 #ifdef CFG_DOC_SUPPORT_2000
18 #define DoC_is_2000(doc) (doc->ChipID == DOC_ChipID_Doc2k)
19 #else
20 #define DoC_is_2000(doc) (0)
21 #endif
22
23 #ifdef CFG_DOC_SUPPORT_MILLENNIUM
24 #define DoC_is_Millennium(doc) (doc->ChipID == DOC_ChipID_DocMil)
25 #else
26 #define DoC_is_Millennium(doc) (0)
27 #endif
28
29 /* CFG_DOC_PASSIVE_PROBE:
30 In order to ensure that the BIOS checksum is correct at boot time, and
31 hence that the onboard BIOS extension gets executed, the DiskOnChip
32 goes into reset mode when it is read sequentially: all registers
33 return 0xff until the chip is woken up again by writing to the
34 DOCControl register.
35
36 Unfortunately, this means that the probe for the DiskOnChip is unsafe,
37 because one of the first things it does is write to where it thinks
38 the DOCControl register should be - which may well be shared memory
39 for another device. I've had machines which lock up when this is
40 attempted. Hence the possibility to do a passive probe, which will fail
41 to detect a chip in reset mode, but is at least guaranteed not to lock
42 the machine.
43
44 If you have this problem, uncomment the following line:
45 #define CFG_DOC_PASSIVE_PROBE
46 */
47
48 #undef DOC_DEBUG
49 #undef ECC_DEBUG
50 #undef PSYCHO_DEBUG
51 #undef NFTL_DEBUG
52
53 static struct DiskOnChip doc_dev_desc[CFG_MAX_DOC_DEVICE];
54
55 /* Current DOC Device */
56 static int curr_device = -1;
57
58 /* Supported NAND flash devices */
59 static struct nand_flash_dev nand_flash_ids[] = {
60 {"Toshiba TC5816BDC", NAND_MFR_TOSHIBA, 0x64, 21, 1, 2, 0x1000, 0},
61 {"Toshiba TC5832DC", NAND_MFR_TOSHIBA, 0x6b, 22, 0, 2, 0x2000, 0},
62 {"Toshiba TH58V128DC", NAND_MFR_TOSHIBA, 0x73, 24, 0, 2, 0x4000, 0},
63 {"Toshiba TC58256FT/DC", NAND_MFR_TOSHIBA, 0x75, 25, 0, 2, 0x4000, 0},
64 {"Toshiba TH58512FT", NAND_MFR_TOSHIBA, 0x76, 26, 0, 3, 0x4000, 0},
65 {"Toshiba TC58V32DC", NAND_MFR_TOSHIBA, 0xe5, 22, 0, 2, 0x2000, 0},
66 {"Toshiba TC58V64AFT/DC", NAND_MFR_TOSHIBA, 0xe6, 23, 0, 2, 0x2000, 0},
67 {"Toshiba TC58V16BDC", NAND_MFR_TOSHIBA, 0xea, 21, 1, 2, 0x1000, 0},
68 {"Toshiba TH58100FT", NAND_MFR_TOSHIBA, 0x79, 27, 0, 3, 0x4000, 0},
69 {"Samsung KM29N16000", NAND_MFR_SAMSUNG, 0x64, 21, 1, 2, 0x1000, 0},
70 {"Samsung unknown 4Mb", NAND_MFR_SAMSUNG, 0x6b, 22, 0, 2, 0x2000, 0},
71 {"Samsung KM29U128T", NAND_MFR_SAMSUNG, 0x73, 24, 0, 2, 0x4000, 0},
72 {"Samsung KM29U256T", NAND_MFR_SAMSUNG, 0x75, 25, 0, 2, 0x4000, 0},
73 {"Samsung unknown 64Mb", NAND_MFR_SAMSUNG, 0x76, 26, 0, 3, 0x4000, 0},
74 {"Samsung KM29W32000", NAND_MFR_SAMSUNG, 0xe3, 22, 0, 2, 0x2000, 0},
75 {"Samsung unknown 4Mb", NAND_MFR_SAMSUNG, 0xe5, 22, 0, 2, 0x2000, 0},
76 {"Samsung KM29U64000", NAND_MFR_SAMSUNG, 0xe6, 23, 0, 2, 0x2000, 0},
77 {"Samsung KM29W16000", NAND_MFR_SAMSUNG, 0xea, 21, 1, 2, 0x1000, 0},
78 {"Samsung K9F5616Q0C", NAND_MFR_SAMSUNG, 0x45, 25, 0, 2, 0x4000, 1},
79 {"Samsung K9K1216Q0C", NAND_MFR_SAMSUNG, 0x46, 26, 0, 3, 0x4000, 1},
80 {"Samsung K9F1G08U0M", NAND_MFR_SAMSUNG, 0xf1, 27, 0, 2, 0, 0},
81 {NULL,}
82 };
83
84 /* ------------------------------------------------------------------------- */
85
86 int do_doc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
87 {
88 int rcode = 0;
89
90 switch (argc) {
91 case 0:
92 case 1:
93 printf ("Usage:\n%s\n", cmdtp->usage);
94 return 1;
95 case 2:
96 if (strcmp(argv[1],"info") == 0) {
97 int i;
98
99 putc ('\n');
100
101 for (i=0; i<CFG_MAX_DOC_DEVICE; ++i) {
102 if(doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN)
103 continue; /* list only known devices */
104 printf ("Device %d: ", i);
105 doc_print(&doc_dev_desc[i]);
106 }
107 return 0;
108
109 } else if (strcmp(argv[1],"device") == 0) {
110 if ((curr_device < 0) || (curr_device >= CFG_MAX_DOC_DEVICE)) {
111 puts ("\nno devices available\n");
112 return 1;
113 }
114 printf ("\nDevice %d: ", curr_device);
115 doc_print(&doc_dev_desc[curr_device]);
116 return 0;
117 }
118 printf ("Usage:\n%s\n", cmdtp->usage);
119 return 1;
120 case 3:
121 if (strcmp(argv[1],"device") == 0) {
122 int dev = (int)simple_strtoul(argv[2], NULL, 10);
123
124 printf ("\nDevice %d: ", dev);
125 if (dev >= CFG_MAX_DOC_DEVICE) {
126 puts ("unknown device\n");
127 return 1;
128 }
129 doc_print(&doc_dev_desc[dev]);
130 /*doc_print (dev);*/
131
132 if (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN) {
133 return 1;
134 }
135
136 curr_device = dev;
137
138 puts ("... is now current device\n");
139
140 return 0;
141 }
142
143 printf ("Usage:\n%s\n", cmdtp->usage);
144 return 1;
145 default:
146 /* at least 4 args */
147
148 if (strcmp(argv[1],"read") == 0 || strcmp(argv[1],"write") == 0) {
149 ulong addr = simple_strtoul(argv[2], NULL, 16);
150 ulong off = simple_strtoul(argv[3], NULL, 16);
151 ulong size = simple_strtoul(argv[4], NULL, 16);
152 int cmd = (strcmp(argv[1],"read") == 0);
153 int ret, total;
154
155 printf ("\nDOC %s: device %d offset %ld, size %ld ... ",
156 cmd ? "read" : "write", curr_device, off, size);
157
158 ret = doc_rw(doc_dev_desc + curr_device, cmd, off, size,
159 (size_t *)&total, (u_char*)addr);
160
161 printf ("%d bytes %s: %s\n", total, cmd ? "read" : "write",
162 ret ? "ERROR" : "OK");
163
164 return ret;
165 } else if (strcmp(argv[1],"erase") == 0) {
166 ulong off = simple_strtoul(argv[2], NULL, 16);
167 ulong size = simple_strtoul(argv[3], NULL, 16);
168 int ret;
169
170 printf ("\nDOC erase: device %d offset %ld, size %ld ... ",
171 curr_device, off, size);
172
173 ret = doc_erase (doc_dev_desc + curr_device, off, size);
174
175 printf("%s\n", ret ? "ERROR" : "OK");
176
177 return ret;
178 } else {
179 printf ("Usage:\n%s\n", cmdtp->usage);
180 rcode = 1;
181 }
182
183 return rcode;
184 }
185 }
186 U_BOOT_CMD(
187 doc, 5, 1, do_doc,
188 "doc - Disk-On-Chip sub-system\n",
189 "info - show available DOC devices\n"
190 "doc device [dev] - show or set current device\n"
191 "doc read addr off size\n"
192 "doc write addr off size - read/write `size'"
193 " bytes starting at offset `off'\n"
194 " to/from memory address `addr'\n"
195 "doc erase off size - erase `size' bytes of DOC from offset `off'\n"
196 );
197
198 int do_docboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
199 {
200 char *boot_device = NULL;
201 char *ep;
202 int dev;
203 ulong cnt;
204 ulong addr;
205 ulong offset = 0;
206 image_header_t *hdr;
207 int rcode = 0;
208 #if defined(CONFIG_FIT)
209 const void *fit_hdr;
210 #endif
211
212 show_boot_progress (34);
213 switch (argc) {
214 case 1:
215 addr = CFG_LOAD_ADDR;
216 boot_device = getenv ("bootdevice");
217 break;
218 case 2:
219 addr = simple_strtoul(argv[1], NULL, 16);
220 boot_device = getenv ("bootdevice");
221 break;
222 case 3:
223 addr = simple_strtoul(argv[1], NULL, 16);
224 boot_device = argv[2];
225 break;
226 case 4:
227 addr = simple_strtoul(argv[1], NULL, 16);
228 boot_device = argv[2];
229 offset = simple_strtoul(argv[3], NULL, 16);
230 break;
231 default:
232 printf ("Usage:\n%s\n", cmdtp->usage);
233 show_boot_progress (-35);
234 return 1;
235 }
236
237 show_boot_progress (35);
238 if (!boot_device) {
239 puts ("\n** No boot device **\n");
240 show_boot_progress (-36);
241 return 1;
242 }
243 show_boot_progress (36);
244
245 dev = simple_strtoul(boot_device, &ep, 16);
246
247 if ((dev >= CFG_MAX_DOC_DEVICE) ||
248 (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN)) {
249 printf ("\n** Device %d not available\n", dev);
250 show_boot_progress (-37);
251 return 1;
252 }
253 show_boot_progress (37);
254
255 printf ("\nLoading from device %d: %s at 0x%lX (offset 0x%lX)\n",
256 dev, doc_dev_desc[dev].name, doc_dev_desc[dev].physadr,
257 offset);
258
259 if (doc_rw (doc_dev_desc + dev, 1, offset,
260 SECTORSIZE, NULL, (u_char *)addr)) {
261 printf ("** Read error on %d\n", dev);
262 show_boot_progress (-38);
263 return 1;
264 }
265 show_boot_progress (38);
266
267 switch (genimg_get_format ((void *)addr)) {
268 case IMAGE_FORMAT_LEGACY:
269 hdr = (image_header_t *)addr;
270
271 image_print_contents (hdr);
272
273 cnt = image_get_image_size (hdr);
274 break;
275 #if defined(CONFIG_FIT)
276 case IMAGE_FORMAT_FIT:
277 fit_hdr = (const void *)addr;
278 if (!fit_check_format (fit_hdr)) {
279 show_boot_progress (-130);
280 puts ("** Bad FIT image format\n");
281 return 1;
282 }
283 show_boot_progress (131);
284 puts ("Fit image detected...\n");
285
286 cnt = fit_get_size (fit_hdr);
287 break;
288 #endif
289 default:
290 show_boot_progress (-39);
291 puts ("** Unknown image type\n");
292 return 1;
293 }
294 show_boot_progress (39);
295
296 cnt -= SECTORSIZE;
297 if (doc_rw (doc_dev_desc + dev, 1, offset + SECTORSIZE, cnt,
298 NULL, (u_char *)(addr+SECTORSIZE))) {
299 printf ("** Read error on %d\n", dev);
300 show_boot_progress (-40);
301 return 1;
302 }
303 show_boot_progress (40);
304
305 #if defined(CONFIG_FIT)
306 /* This cannot be done earlier, we need complete FIT image in RAM first */
307 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT)
308 fit_print_contents ((const void *)addr);
309 #endif
310
311 /* Loading ok, update default load address */
312
313 load_addr = addr;
314
315 /* Check if we should attempt an auto-start */
316 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
317 char *local_args[2];
318 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
319
320 local_args[0] = argv[0];
321 local_args[1] = NULL;
322
323 printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
324
325 do_bootm (cmdtp, 0, 1, local_args);
326 rcode = 1;
327 }
328 return rcode;
329 }
330
331 U_BOOT_CMD(
332 docboot, 4, 1, do_docboot,
333 "docboot - boot from DOC device\n",
334 "loadAddr dev\n"
335 );
336
337 int doc_rw (struct DiskOnChip* this, int cmd,
338 loff_t from, size_t len,
339 size_t * retlen, u_char * buf)
340 {
341 int noecc, ret = 0, n, total = 0;
342 char eccbuf[6];
343
344 while(len) {
345 /* The ECC will not be calculated correctly if
346 less than 512 is written or read */
347 noecc = (from != (from | 0x1ff) + 1) || (len < 0x200);
348
349 if (cmd)
350 ret = doc_read_ecc(this, from, len,
351 (size_t *)&n, (u_char*)buf,
352 noecc ? (uchar *)NULL : (uchar *)eccbuf);
353 else
354 ret = doc_write_ecc(this, from, len,
355 (size_t *)&n, (u_char*)buf,
356 noecc ? (uchar *)NULL : (uchar *)eccbuf);
357
358 if (ret)
359 break;
360
361 from += n;
362 buf += n;
363 total += n;
364 len -= n;
365 }
366
367 if (retlen)
368 *retlen = total;
369
370 return ret;
371 }
372
373 void doc_print(struct DiskOnChip *this) {
374 printf("%s at 0x%lX,\n"
375 "\t %d chip%s %s, size %d MB, \n"
376 "\t total size %ld MB, sector size %ld kB\n",
377 this->name, this->physadr, this->numchips,
378 this->numchips>1 ? "s" : "", this->chips_name,
379 1 << (this->chipshift - 20),
380 this->totlen >> 20, this->erasesize >> 10);
381
382 if (this->nftl_found) {
383 struct NFTLrecord *nftl = &this->nftl;
384 unsigned long bin_size, flash_size;
385
386 bin_size = nftl->nb_boot_blocks * this->erasesize;
387 flash_size = (nftl->nb_blocks - nftl->nb_boot_blocks) * this->erasesize;
388
389 printf("\t NFTL boot record:\n"
390 "\t Binary partition: size %ld%s\n"
391 "\t Flash disk partition: size %ld%s, offset 0x%lx\n",
392 bin_size > (1 << 20) ? bin_size >> 20 : bin_size >> 10,
393 bin_size > (1 << 20) ? "MB" : "kB",
394 flash_size > (1 << 20) ? flash_size >> 20 : flash_size >> 10,
395 flash_size > (1 << 20) ? "MB" : "kB", bin_size);
396 } else {
397 puts ("\t No NFTL boot record found.\n");
398 }
399 }
400
401 /* ------------------------------------------------------------------------- */
402
403 /* This function is needed to avoid calls of the __ashrdi3 function. */
404 static int shr(int val, int shift) {
405 return val >> shift;
406 }
407
408 /* Perform the required delay cycles by reading from the appropriate register */
409 static void DoC_Delay(struct DiskOnChip *doc, unsigned short cycles)
410 {
411 volatile char dummy;
412 int i;
413
414 for (i = 0; i < cycles; i++) {
415 if (DoC_is_Millennium(doc))
416 dummy = ReadDOC(doc->virtadr, NOP);
417 else
418 dummy = ReadDOC(doc->virtadr, DOCStatus);
419 }
420
421 }
422
423 /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
424 static int _DoC_WaitReady(struct DiskOnChip *doc)
425 {
426 unsigned long docptr = doc->virtadr;
427 unsigned long start = get_timer(0);
428
429 #ifdef PSYCHO_DEBUG
430 puts ("_DoC_WaitReady called for out-of-line wait\n");
431 #endif
432
433 /* Out-of-line routine to wait for chip response */
434 while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
435 #ifdef CFG_DOC_SHORT_TIMEOUT
436 /* it seems that after a certain time the DoC deasserts
437 * the CDSN_CTRL_FR_B although it is not ready...
438 * using a short timout solve this (timer increments every ms) */
439 if (get_timer(start) > 10) {
440 return DOC_ETIMEOUT;
441 }
442 #else
443 if (get_timer(start) > 10 * 1000) {
444 puts ("_DoC_WaitReady timed out.\n");
445 return DOC_ETIMEOUT;
446 }
447 #endif
448 udelay(1);
449 }
450
451 return 0;
452 }
453
454 static int DoC_WaitReady(struct DiskOnChip *doc)
455 {
456 unsigned long docptr = doc->virtadr;
457 /* This is inline, to optimise the common case, where it's ready instantly */
458 int ret = 0;
459
460 /* 4 read form NOP register should be issued in prior to the read from CDSNControl
461 see Software Requirement 11.4 item 2. */
462 DoC_Delay(doc, 4);
463
464 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
465 /* Call the out-of-line routine to wait */
466 ret = _DoC_WaitReady(doc);
467
468 /* issue 2 read from NOP register after reading from CDSNControl register
469 see Software Requirement 11.4 item 2. */
470 DoC_Delay(doc, 2);
471
472 return ret;
473 }
474
475 /* DoC_Command: Send a flash command to the flash chip through the CDSN Slow IO register to
476 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
477 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
478
479 static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,
480 unsigned char xtraflags)
481 {
482 unsigned long docptr = doc->virtadr;
483
484 if (DoC_is_2000(doc))
485 xtraflags |= CDSN_CTRL_FLASH_IO;
486
487 /* Assert the CLE (Command Latch Enable) line to the flash chip */
488 WriteDOC(xtraflags | CDSN_CTRL_CLE | CDSN_CTRL_CE, docptr, CDSNControl);
489 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
490
491 if (DoC_is_Millennium(doc))
492 WriteDOC(command, docptr, CDSNSlowIO);
493
494 /* Send the command */
495 WriteDOC_(command, docptr, doc->ioreg);
496
497 /* Lower the CLE line */
498 WriteDOC(xtraflags | CDSN_CTRL_CE, docptr, CDSNControl);
499 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
500
501 /* Wait for the chip to respond - Software requirement 11.4.1 (extended for any command) */
502 return DoC_WaitReady(doc);
503 }
504
505 /* DoC_Address: Set the current address for the flash chip through the CDSN Slow IO register to
506 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
507 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
508
509 static int DoC_Address(struct DiskOnChip *doc, int numbytes, unsigned long ofs,
510 unsigned char xtraflags1, unsigned char xtraflags2)
511 {
512 unsigned long docptr;
513 int i;
514
515 docptr = doc->virtadr;
516
517 if (DoC_is_2000(doc))
518 xtraflags1 |= CDSN_CTRL_FLASH_IO;
519
520 /* Assert the ALE (Address Latch Enable) line to the flash chip */
521 WriteDOC(xtraflags1 | CDSN_CTRL_ALE | CDSN_CTRL_CE, docptr, CDSNControl);
522
523 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
524
525 /* Send the address */
526 /* Devices with 256-byte page are addressed as:
527 Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
528 * there is no device on the market with page256
529 and more than 24 bits.
530 Devices with 512-byte page are addressed as:
531 Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
532 * 25-31 is sent only if the chip support it.
533 * bit 8 changes the read command to be sent
534 (NAND_CMD_READ0 or NAND_CMD_READ1).
535 */
536
537 if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE) {
538 if (DoC_is_Millennium(doc))
539 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
540 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
541 }
542
543 if (doc->page256) {
544 ofs = ofs >> 8;
545 } else {
546 ofs = ofs >> 9;
547 }
548
549 if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE) {
550 for (i = 0; i < doc->pageadrlen; i++, ofs = ofs >> 8) {
551 if (DoC_is_Millennium(doc))
552 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
553 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
554 }
555 }
556
557 DoC_Delay(doc, 2); /* Needed for some slow flash chips. mf. */
558
559 /* FIXME: The SlowIO's for millennium could be replaced by
560 a single WritePipeTerm here. mf. */
561
562 /* Lower the ALE line */
563 WriteDOC(xtraflags1 | xtraflags2 | CDSN_CTRL_CE, docptr,
564 CDSNControl);
565
566 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
567
568 /* Wait for the chip to respond - Software requirement 11.4.1 */
569 return DoC_WaitReady(doc);
570 }
571
572 /* Read a buffer from DoC, taking care of Millennium oddities */
573 static void DoC_ReadBuf(struct DiskOnChip *doc, u_char * buf, int len)
574 {
575 volatile int dummy;
576 int modulus = 0xffff;
577 unsigned long docptr;
578 int i;
579
580 docptr = doc->virtadr;
581
582 if (len <= 0)
583 return;
584
585 if (DoC_is_Millennium(doc)) {
586 /* Read the data via the internal pipeline through CDSN IO register,
587 see Pipelined Read Operations 11.3 */
588 dummy = ReadDOC(docptr, ReadPipeInit);
589
590 /* Millennium should use the LastDataRead register - Pipeline Reads */
591 len--;
592
593 /* This is needed for correctly ECC calculation */
594 modulus = 0xff;
595 }
596
597 for (i = 0; i < len; i++)
598 buf[i] = ReadDOC_(docptr, doc->ioreg + (i & modulus));
599
600 if (DoC_is_Millennium(doc)) {
601 buf[i] = ReadDOC(docptr, LastDataRead);
602 }
603 }
604
605 /* Write a buffer to DoC, taking care of Millennium oddities */
606 static void DoC_WriteBuf(struct DiskOnChip *doc, const u_char * buf, int len)
607 {
608 unsigned long docptr;
609 int i;
610
611 docptr = doc->virtadr;
612
613 if (len <= 0)
614 return;
615
616 for (i = 0; i < len; i++)
617 WriteDOC_(buf[i], docptr, doc->ioreg + i);
618
619 if (DoC_is_Millennium(doc)) {
620 WriteDOC(0x00, docptr, WritePipeTerm);
621 }
622 }
623
624
625 /* DoC_SelectChip: Select a given flash chip within the current floor */
626
627 static inline int DoC_SelectChip(struct DiskOnChip *doc, int chip)
628 {
629 unsigned long docptr = doc->virtadr;
630
631 /* Software requirement 11.4.4 before writing DeviceSelect */
632 /* Deassert the CE line to eliminate glitches on the FCE# outputs */
633 WriteDOC(CDSN_CTRL_WP, docptr, CDSNControl);
634 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
635
636 /* Select the individual flash chip requested */
637 WriteDOC(chip, docptr, CDSNDeviceSelect);
638 DoC_Delay(doc, 4);
639
640 /* Reassert the CE line */
641 WriteDOC(CDSN_CTRL_CE | CDSN_CTRL_FLASH_IO | CDSN_CTRL_WP, docptr,
642 CDSNControl);
643 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
644
645 /* Wait for it to be ready */
646 return DoC_WaitReady(doc);
647 }
648
649 /* DoC_SelectFloor: Select a given floor (bank of flash chips) */
650
651 static inline int DoC_SelectFloor(struct DiskOnChip *doc, int floor)
652 {
653 unsigned long docptr = doc->virtadr;
654
655 /* Select the floor (bank) of chips required */
656 WriteDOC(floor, docptr, FloorSelect);
657
658 /* Wait for the chip to be ready */
659 return DoC_WaitReady(doc);
660 }
661
662 /* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */
663
664 static int DoC_IdentChip(struct DiskOnChip *doc, int floor, int chip)
665 {
666 int mfr, id, i;
667 volatile char dummy;
668
669 /* Page in the required floor/chip */
670 DoC_SelectFloor(doc, floor);
671 DoC_SelectChip(doc, chip);
672
673 /* Reset the chip */
674 if (DoC_Command(doc, NAND_CMD_RESET, CDSN_CTRL_WP)) {
675 #ifdef DOC_DEBUG
676 printf("DoC_Command (reset) for %d,%d returned true\n",
677 floor, chip);
678 #endif
679 return 0;
680 }
681
682
683 /* Read the NAND chip ID: 1. Send ReadID command */
684 if (DoC_Command(doc, NAND_CMD_READID, CDSN_CTRL_WP)) {
685 #ifdef DOC_DEBUG
686 printf("DoC_Command (ReadID) for %d,%d returned true\n",
687 floor, chip);
688 #endif
689 return 0;
690 }
691
692 /* Read the NAND chip ID: 2. Send address byte zero */
693 DoC_Address(doc, ADDR_COLUMN, 0, CDSN_CTRL_WP, 0);
694
695 /* Read the manufacturer and device id codes from the device */
696
697 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
698 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
699 DoC_Delay(doc, 2);
700 mfr = ReadDOC_(doc->virtadr, doc->ioreg);
701
702 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
703 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
704 DoC_Delay(doc, 2);
705 id = ReadDOC_(doc->virtadr, doc->ioreg);
706
707 /* No response - return failure */
708 if (mfr == 0xff || mfr == 0)
709 return 0;
710
711 /* Check it's the same as the first chip we identified.
712 * M-Systems say that any given DiskOnChip device should only
713 * contain _one_ type of flash part, although that's not a
714 * hardware restriction. */
715 if (doc->mfr) {
716 if (doc->mfr == mfr && doc->id == id)
717 return 1; /* This is another the same the first */
718 else
719 printf("Flash chip at floor %d, chip %d is different:\n",
720 floor, chip);
721 }
722
723 /* Print and store the manufacturer and ID codes. */
724 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
725 if (mfr == nand_flash_ids[i].manufacture_id &&
726 id == nand_flash_ids[i].model_id) {
727 #ifdef DOC_DEBUG
728 printf("Flash chip found: Manufacturer ID: %2.2X, "
729 "Chip ID: %2.2X (%s)\n", mfr, id,
730 nand_flash_ids[i].name);
731 #endif
732 if (!doc->mfr) {
733 doc->mfr = mfr;
734 doc->id = id;
735 doc->chipshift =
736 nand_flash_ids[i].chipshift;
737 doc->page256 = nand_flash_ids[i].page256;
738 doc->pageadrlen =
739 nand_flash_ids[i].pageadrlen;
740 doc->erasesize =
741 nand_flash_ids[i].erasesize;
742 doc->chips_name =
743 nand_flash_ids[i].name;
744 return 1;
745 }
746 return 0;
747 }
748 }
749
750
751 #ifdef DOC_DEBUG
752 /* We haven't fully identified the chip. Print as much as we know. */
753 printf("Unknown flash chip found: %2.2X %2.2X\n",
754 id, mfr);
755 #endif
756
757 return 0;
758 }
759
760 /* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */
761
762 static void DoC_ScanChips(struct DiskOnChip *this)
763 {
764 int floor, chip;
765 int numchips[MAX_FLOORS];
766 int maxchips = MAX_CHIPS;
767 int ret = 1;
768
769 this->numchips = 0;
770 this->mfr = 0;
771 this->id = 0;
772
773 if (DoC_is_Millennium(this))
774 maxchips = MAX_CHIPS_MIL;
775
776 /* For each floor, find the number of valid chips it contains */
777 for (floor = 0; floor < MAX_FLOORS; floor++) {
778 ret = 1;
779 numchips[floor] = 0;
780 for (chip = 0; chip < maxchips && ret != 0; chip++) {
781
782 ret = DoC_IdentChip(this, floor, chip);
783 if (ret) {
784 numchips[floor]++;
785 this->numchips++;
786 }
787 }
788 }
789
790 /* If there are none at all that we recognise, bail */
791 if (!this->numchips) {
792 puts ("No flash chips recognised.\n");
793 return;
794 }
795
796 /* Allocate an array to hold the information for each chip */
797 this->chips = malloc(sizeof(struct Nand) * this->numchips);
798 if (!this->chips) {
799 puts ("No memory for allocating chip info structures\n");
800 return;
801 }
802
803 ret = 0;
804
805 /* Fill out the chip array with {floor, chipno} for each
806 * detected chip in the device. */
807 for (floor = 0; floor < MAX_FLOORS; floor++) {
808 for (chip = 0; chip < numchips[floor]; chip++) {
809 this->chips[ret].floor = floor;
810 this->chips[ret].chip = chip;
811 this->chips[ret].curadr = 0;
812 this->chips[ret].curmode = 0x50;
813 ret++;
814 }
815 }
816
817 /* Calculate and print the total size of the device */
818 this->totlen = this->numchips * (1 << this->chipshift);
819
820 #ifdef DOC_DEBUG
821 printf("%d flash chips found. Total DiskOnChip size: %ld MB\n",
822 this->numchips, this->totlen >> 20);
823 #endif
824 }
825
826 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
827 * various device information of the NFTL partition and Bad Unit Table. Update
828 * the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
829 * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
830 */
831 static int find_boot_record(struct NFTLrecord *nftl)
832 {
833 struct nftl_uci1 h1;
834 struct nftl_oob oob;
835 unsigned int block, boot_record_count = 0;
836 int retlen;
837 u8 buf[SECTORSIZE];
838 struct NFTLMediaHeader *mh = &nftl->MediaHdr;
839 unsigned int i;
840
841 nftl->MediaUnit = BLOCK_NIL;
842 nftl->SpareMediaUnit = BLOCK_NIL;
843
844 /* search for a valid boot record */
845 for (block = 0; block < nftl->nb_blocks; block++) {
846 int ret;
847
848 /* Check for ANAND header first. Then can whinge if it's found but later
849 checks fail */
850 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize, SECTORSIZE,
851 (size_t *)&retlen, buf, NULL))) {
852 static int warncount = 5;
853
854 if (warncount) {
855 printf("Block read at 0x%x failed\n", block * nftl->EraseSize);
856 if (!--warncount)
857 puts ("Further failures for this block will not be printed\n");
858 }
859 continue;
860 }
861
862 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
863 /* ANAND\0 not found. Continue */
864 #ifdef PSYCHO_DEBUG
865 printf("ANAND header not found at 0x%x\n", block * nftl->EraseSize);
866 #endif
867 continue;
868 }
869
870 #ifdef NFTL_DEBUG
871 printf("ANAND header found at 0x%x\n", block * nftl->EraseSize);
872 #endif
873
874 /* To be safer with BIOS, also use erase mark as discriminant */
875 if ((ret = doc_read_oob(nftl->mtd, block * nftl->EraseSize + SECTORSIZE + 8,
876 8, (size_t *)&retlen, (uchar *)&h1) < 0)) {
877 #ifdef NFTL_DEBUG
878 printf("ANAND header found at 0x%x, but OOB data read failed\n",
879 block * nftl->EraseSize);
880 #endif
881 continue;
882 }
883
884 /* OK, we like it. */
885
886 if (boot_record_count) {
887 /* We've already processed one. So we just check if
888 this one is the same as the first one we found */
889 if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
890 #ifdef NFTL_DEBUG
891 printf("NFTL Media Headers at 0x%x and 0x%x disagree.\n",
892 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
893 #endif
894 /* if (debug) Print both side by side */
895 return -1;
896 }
897 if (boot_record_count == 1)
898 nftl->SpareMediaUnit = block;
899
900 boot_record_count++;
901 continue;
902 }
903
904 /* This is the first we've seen. Copy the media header structure into place */
905 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
906
907 /* Do some sanity checks on it */
908 if (mh->UnitSizeFactor == 0) {
909 #ifdef NFTL_DEBUG
910 puts ("UnitSizeFactor 0x00 detected.\n"
911 "This violates the spec but we think we know what it means...\n");
912 #endif
913 } else if (mh->UnitSizeFactor != 0xff) {
914 printf ("Sorry, we don't support UnitSizeFactor "
915 "of != 1 yet.\n");
916 return -1;
917 }
918
919 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
920 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
921 printf ("NFTL Media Header sanity check failed:\n"
922 "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
923 nftl->nb_boot_blocks, nftl->nb_blocks);
924 return -1;
925 }
926
927 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
928 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
929 printf ("NFTL Media Header sanity check failed:\n"
930 "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
931 nftl->numvunits,
932 nftl->nb_blocks,
933 nftl->nb_boot_blocks);
934 return -1;
935 }
936
937 nftl->nr_sects = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
938
939 /* If we're not using the last sectors in the device for some reason,
940 reduce nb_blocks accordingly so we forget they're there */
941 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
942
943 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
944 for (i = 0; i < nftl->nb_blocks; i++) {
945 if ((i & (SECTORSIZE - 1)) == 0) {
946 /* read one sector for every SECTORSIZE of blocks */
947 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize +
948 i + SECTORSIZE, SECTORSIZE,
949 (size_t *)&retlen, buf, (uchar *)&oob)) < 0) {
950 puts ("Read of bad sector table failed\n");
951 return -1;
952 }
953 }
954 /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
955 if (buf[i & (SECTORSIZE - 1)] != 0xff)
956 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
957 }
958
959 nftl->MediaUnit = block;
960 boot_record_count++;
961
962 } /* foreach (block) */
963
964 return boot_record_count?0:-1;
965 }
966
967 /* This routine is made available to other mtd code via
968 * inter_module_register. It must only be accessed through
969 * inter_module_get which will bump the use count of this module. The
970 * addresses passed back in mtd are valid as long as the use count of
971 * this module is non-zero, i.e. between inter_module_get and
972 * inter_module_put. Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
973 */
974 static void DoC2k_init(struct DiskOnChip* this)
975 {
976 struct NFTLrecord *nftl;
977
978 switch (this->ChipID) {
979 case DOC_ChipID_Doc2k:
980 this->name = "DiskOnChip 2000";
981 this->ioreg = DoC_2k_CDSN_IO;
982 break;
983 case DOC_ChipID_DocMil:
984 this->name = "DiskOnChip Millennium";
985 this->ioreg = DoC_Mil_CDSN_IO;
986 break;
987 }
988
989 #ifdef DOC_DEBUG
990 printf("%s found at address 0x%lX\n", this->name,
991 this->physadr);
992 #endif
993
994 this->totlen = 0;
995 this->numchips = 0;
996
997 this->curfloor = -1;
998 this->curchip = -1;
999
1000 /* Ident all the chips present. */
1001 DoC_ScanChips(this);
1002 if ((!this->numchips) || (!this->chips))
1003 return;
1004
1005 nftl = &this->nftl;
1006
1007 /* Get physical parameters */
1008 nftl->EraseSize = this->erasesize;
1009 nftl->nb_blocks = this->totlen / this->erasesize;
1010 nftl->mtd = this;
1011
1012 if (find_boot_record(nftl) != 0)
1013 this->nftl_found = 0;
1014 else
1015 this->nftl_found = 1;
1016
1017 printf("%s @ 0x%lX, %ld MB\n", this->name, this->physadr, this->totlen >> 20);
1018 }
1019
1020 int doc_read_ecc(struct DiskOnChip* this, loff_t from, size_t len,
1021 size_t * retlen, u_char * buf, u_char * eccbuf)
1022 {
1023 unsigned long docptr;
1024 struct Nand *mychip;
1025 unsigned char syndrome[6];
1026 volatile char dummy;
1027 int i, len256 = 0, ret=0;
1028
1029 docptr = this->virtadr;
1030
1031 /* Don't allow read past end of device */
1032 if (from >= this->totlen) {
1033 puts ("Out of flash\n");
1034 return DOC_EINVAL;
1035 }
1036
1037 /* Don't allow a single read to cross a 512-byte block boundary */
1038 if (from + len > ((from | 0x1ff) + 1))
1039 len = ((from | 0x1ff) + 1) - from;
1040
1041 /* The ECC will not be calculated correctly if less than 512 is read */
1042 if (len != 0x200 && eccbuf)
1043 printf("ECC needs a full sector read (adr: %lx size %lx)\n",
1044 (long) from, (long) len);
1045
1046 #ifdef PSYCHO_DEBUG
1047 printf("DoC_Read (adr: %lx size %lx)\n", (long) from, (long) len);
1048 #endif
1049
1050 /* Find the chip which is to be used and select it */
1051 mychip = &this->chips[shr(from, this->chipshift)];
1052
1053 if (this->curfloor != mychip->floor) {
1054 DoC_SelectFloor(this, mychip->floor);
1055 DoC_SelectChip(this, mychip->chip);
1056 } else if (this->curchip != mychip->chip) {
1057 DoC_SelectChip(this, mychip->chip);
1058 }
1059
1060 this->curfloor = mychip->floor;
1061 this->curchip = mychip->chip;
1062
1063 DoC_Command(this,
1064 (!this->page256
1065 && (from & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1066 CDSN_CTRL_WP);
1067 DoC_Address(this, ADDR_COLUMN_PAGE, from, CDSN_CTRL_WP,
1068 CDSN_CTRL_ECC_IO);
1069
1070 if (eccbuf) {
1071 /* Prime the ECC engine */
1072 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1073 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
1074 } else {
1075 /* disable the ECC engine */
1076 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1077 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1078 }
1079
1080 /* treat crossing 256-byte sector for 2M x 8bits devices */
1081 if (this->page256 && from + len > (from | 0xff) + 1) {
1082 len256 = (from | 0xff) + 1 - from;
1083 DoC_ReadBuf(this, buf, len256);
1084
1085 DoC_Command(this, NAND_CMD_READ0, CDSN_CTRL_WP);
1086 DoC_Address(this, ADDR_COLUMN_PAGE, from + len256,
1087 CDSN_CTRL_WP, CDSN_CTRL_ECC_IO);
1088 }
1089
1090 DoC_ReadBuf(this, &buf[len256], len - len256);
1091
1092 /* Let the caller know we completed it */
1093 *retlen = len;
1094
1095 if (eccbuf) {
1096 /* Read the ECC data through the DiskOnChip ECC logic */
1097 /* Note: this will work even with 2M x 8bit devices as */
1098 /* they have 8 bytes of OOB per 256 page. mf. */
1099 DoC_ReadBuf(this, eccbuf, 6);
1100
1101 /* Flush the pipeline */
1102 if (DoC_is_Millennium(this)) {
1103 dummy = ReadDOC(docptr, ECCConf);
1104 dummy = ReadDOC(docptr, ECCConf);
1105 i = ReadDOC(docptr, ECCConf);
1106 } else {
1107 dummy = ReadDOC(docptr, 2k_ECCStatus);
1108 dummy = ReadDOC(docptr, 2k_ECCStatus);
1109 i = ReadDOC(docptr, 2k_ECCStatus);
1110 }
1111
1112 /* Check the ECC Status */
1113 if (i & 0x80) {
1114 int nb_errors;
1115 /* There was an ECC error */
1116 #ifdef ECC_DEBUG
1117 printf("DiskOnChip ECC Error: Read at %lx\n", (long)from);
1118 #endif
1119 /* Read the ECC syndrom through the DiskOnChip ECC logic.
1120 These syndrome will be all ZERO when there is no error */
1121 for (i = 0; i < 6; i++) {
1122 syndrome[i] =
1123 ReadDOC(docptr, ECCSyndrome0 + i);
1124 }
1125 nb_errors = doc_decode_ecc(buf, syndrome);
1126
1127 #ifdef ECC_DEBUG
1128 printf("Errors corrected: %x\n", nb_errors);
1129 #endif
1130 if (nb_errors < 0) {
1131 /* We return error, but have actually done the read. Not that
1132 this can be told to user-space, via sys_read(), but at least
1133 MTD-aware stuff can know about it by checking *retlen */
1134 printf("ECC Errors at %lx\n", (long)from);
1135 ret = DOC_EECC;
1136 }
1137 }
1138
1139 #ifdef PSYCHO_DEBUG
1140 printf("ECC DATA at %lxB: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1141 (long)from, eccbuf[0], eccbuf[1], eccbuf[2],
1142 eccbuf[3], eccbuf[4], eccbuf[5]);
1143 #endif
1144
1145 /* disable the ECC engine */
1146 WriteDOC(DOC_ECC_DIS, docptr , ECCConf);
1147 }
1148
1149 /* according to 11.4.1, we need to wait for the busy line
1150 * drop if we read to the end of the page. */
1151 if(0 == ((from + *retlen) & 0x1ff))
1152 {
1153 DoC_WaitReady(this);
1154 }
1155
1156 return ret;
1157 }
1158
1159 int doc_write_ecc(struct DiskOnChip* this, loff_t to, size_t len,
1160 size_t * retlen, const u_char * buf,
1161 u_char * eccbuf)
1162 {
1163 int di; /* Yes, DI is a hangover from when I was disassembling the binary driver */
1164 unsigned long docptr;
1165 volatile char dummy;
1166 int len256 = 0;
1167 struct Nand *mychip;
1168
1169 docptr = this->virtadr;
1170
1171 /* Don't allow write past end of device */
1172 if (to >= this->totlen) {
1173 puts ("Out of flash\n");
1174 return DOC_EINVAL;
1175 }
1176
1177 /* Don't allow a single write to cross a 512-byte block boundary */
1178 if (to + len > ((to | 0x1ff) + 1))
1179 len = ((to | 0x1ff) + 1) - to;
1180
1181 /* The ECC will not be calculated correctly if less than 512 is written */
1182 if (len != 0x200 && eccbuf)
1183 printf("ECC needs a full sector write (adr: %lx size %lx)\n",
1184 (long) to, (long) len);
1185
1186 /* printf("DoC_Write (adr: %lx size %lx)\n", (long) to, (long) len); */
1187
1188 /* Find the chip which is to be used and select it */
1189 mychip = &this->chips[shr(to, this->chipshift)];
1190
1191 if (this->curfloor != mychip->floor) {
1192 DoC_SelectFloor(this, mychip->floor);
1193 DoC_SelectChip(this, mychip->chip);
1194 } else if (this->curchip != mychip->chip) {
1195 DoC_SelectChip(this, mychip->chip);
1196 }
1197
1198 this->curfloor = mychip->floor;
1199 this->curchip = mychip->chip;
1200
1201 /* Set device to main plane of flash */
1202 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1203 DoC_Command(this,
1204 (!this->page256
1205 && (to & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1206 CDSN_CTRL_WP);
1207
1208 DoC_Command(this, NAND_CMD_SEQIN, 0);
1209 DoC_Address(this, ADDR_COLUMN_PAGE, to, 0, CDSN_CTRL_ECC_IO);
1210
1211 if (eccbuf) {
1212 /* Prime the ECC engine */
1213 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1214 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
1215 } else {
1216 /* disable the ECC engine */
1217 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1218 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1219 }
1220
1221 /* treat crossing 256-byte sector for 2M x 8bits devices */
1222 if (this->page256 && to + len > (to | 0xff) + 1) {
1223 len256 = (to | 0xff) + 1 - to;
1224 DoC_WriteBuf(this, buf, len256);
1225
1226 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1227
1228 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1229 /* There's an implicit DoC_WaitReady() in DoC_Command */
1230
1231 dummy = ReadDOC(docptr, CDSNSlowIO);
1232 DoC_Delay(this, 2);
1233
1234 if (ReadDOC_(docptr, this->ioreg) & 1) {
1235 puts ("Error programming flash\n");
1236 /* Error in programming */
1237 *retlen = 0;
1238 return DOC_EIO;
1239 }
1240
1241 DoC_Command(this, NAND_CMD_SEQIN, 0);
1242 DoC_Address(this, ADDR_COLUMN_PAGE, to + len256, 0,
1243 CDSN_CTRL_ECC_IO);
1244 }
1245
1246 DoC_WriteBuf(this, &buf[len256], len - len256);
1247
1248 if (eccbuf) {
1249 WriteDOC(CDSN_CTRL_ECC_IO | CDSN_CTRL_CE, docptr,
1250 CDSNControl);
1251
1252 if (DoC_is_Millennium(this)) {
1253 WriteDOC(0, docptr, NOP);
1254 WriteDOC(0, docptr, NOP);
1255 WriteDOC(0, docptr, NOP);
1256 } else {
1257 WriteDOC_(0, docptr, this->ioreg);
1258 WriteDOC_(0, docptr, this->ioreg);
1259 WriteDOC_(0, docptr, this->ioreg);
1260 }
1261
1262 /* Read the ECC data through the DiskOnChip ECC logic */
1263 for (di = 0; di < 6; di++) {
1264 eccbuf[di] = ReadDOC(docptr, ECCSyndrome0 + di);
1265 }
1266
1267 /* Reset the ECC engine */
1268 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1269
1270 #ifdef PSYCHO_DEBUG
1271 printf
1272 ("OOB data at %lx is %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1273 (long) to, eccbuf[0], eccbuf[1], eccbuf[2], eccbuf[3],
1274 eccbuf[4], eccbuf[5]);
1275 #endif
1276 }
1277
1278 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1279
1280 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1281 /* There's an implicit DoC_WaitReady() in DoC_Command */
1282
1283 dummy = ReadDOC(docptr, CDSNSlowIO);
1284 DoC_Delay(this, 2);
1285
1286 if (ReadDOC_(docptr, this->ioreg) & 1) {
1287 puts ("Error programming flash\n");
1288 /* Error in programming */
1289 *retlen = 0;
1290 return DOC_EIO;
1291 }
1292
1293 /* Let the caller know we completed it */
1294 *retlen = len;
1295
1296 if (eccbuf) {
1297 unsigned char x[8];
1298 size_t dummy;
1299 int ret;
1300
1301 /* Write the ECC data to flash */
1302 for (di=0; di<6; di++)
1303 x[di] = eccbuf[di];
1304
1305 x[6]=0x55;
1306 x[7]=0x55;
1307
1308 ret = doc_write_oob(this, to, 8, &dummy, x);
1309 return ret;
1310 }
1311 return 0;
1312 }
1313
1314 int doc_read_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1315 size_t * retlen, u_char * buf)
1316 {
1317 int len256 = 0, ret;
1318 unsigned long docptr;
1319 struct Nand *mychip;
1320
1321 docptr = this->virtadr;
1322
1323 mychip = &this->chips[shr(ofs, this->chipshift)];
1324
1325 if (this->curfloor != mychip->floor) {
1326 DoC_SelectFloor(this, mychip->floor);
1327 DoC_SelectChip(this, mychip->chip);
1328 } else if (this->curchip != mychip->chip) {
1329 DoC_SelectChip(this, mychip->chip);
1330 }
1331 this->curfloor = mychip->floor;
1332 this->curchip = mychip->chip;
1333
1334 /* update address for 2M x 8bit devices. OOB starts on the second */
1335 /* page to maintain compatibility with doc_read_ecc. */
1336 if (this->page256) {
1337 if (!(ofs & 0x8))
1338 ofs += 0x100;
1339 else
1340 ofs -= 0x8;
1341 }
1342
1343 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1344 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, CDSN_CTRL_WP, 0);
1345
1346 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1347 /* Note: datasheet says it should automaticaly wrap to the */
1348 /* next OOB block, but it didn't work here. mf. */
1349 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1350 len256 = (ofs | 0x7) + 1 - ofs;
1351 DoC_ReadBuf(this, buf, len256);
1352
1353 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1354 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff),
1355 CDSN_CTRL_WP, 0);
1356 }
1357
1358 DoC_ReadBuf(this, &buf[len256], len - len256);
1359
1360 *retlen = len;
1361 /* Reading the full OOB data drops us off of the end of the page,
1362 * causing the flash device to go into busy mode, so we need
1363 * to wait until ready 11.4.1 and Toshiba TC58256FT docs */
1364
1365 ret = DoC_WaitReady(this);
1366
1367 return ret;
1368
1369 }
1370
1371 int doc_write_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1372 size_t * retlen, const u_char * buf)
1373 {
1374 int len256 = 0;
1375 unsigned long docptr = this->virtadr;
1376 struct Nand *mychip = &this->chips[shr(ofs, this->chipshift)];
1377 volatile int dummy;
1378
1379 #ifdef PSYCHO_DEBUG
1380 printf("doc_write_oob(%lx, %d): %2.2X %2.2X %2.2X %2.2X ... %2.2X %2.2X .. %2.2X %2.2X\n",
1381 (long)ofs, len, buf[0], buf[1], buf[2], buf[3],
1382 buf[8], buf[9], buf[14],buf[15]);
1383 #endif
1384
1385 /* Find the chip which is to be used and select it */
1386 if (this->curfloor != mychip->floor) {
1387 DoC_SelectFloor(this, mychip->floor);
1388 DoC_SelectChip(this, mychip->chip);
1389 } else if (this->curchip != mychip->chip) {
1390 DoC_SelectChip(this, mychip->chip);
1391 }
1392 this->curfloor = mychip->floor;
1393 this->curchip = mychip->chip;
1394
1395 /* disable the ECC engine */
1396 WriteDOC (DOC_ECC_RESET, docptr, ECCConf);
1397 WriteDOC (DOC_ECC_DIS, docptr, ECCConf);
1398
1399 /* Reset the chip, see Software Requirement 11.4 item 1. */
1400 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1401
1402 /* issue the Read2 command to set the pointer to the Spare Data Area. */
1403 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1404
1405 /* update address for 2M x 8bit devices. OOB starts on the second */
1406 /* page to maintain compatibility with doc_read_ecc. */
1407 if (this->page256) {
1408 if (!(ofs & 0x8))
1409 ofs += 0x100;
1410 else
1411 ofs -= 0x8;
1412 }
1413
1414 /* issue the Serial Data In command to initial the Page Program process */
1415 DoC_Command(this, NAND_CMD_SEQIN, 0);
1416 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, 0, 0);
1417
1418 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1419 /* Note: datasheet says it should automaticaly wrap to the */
1420 /* next OOB block, but it didn't work here. mf. */
1421 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1422 len256 = (ofs | 0x7) + 1 - ofs;
1423 DoC_WriteBuf(this, buf, len256);
1424
1425 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1426 DoC_Command(this, NAND_CMD_STATUS, 0);
1427 /* DoC_WaitReady() is implicit in DoC_Command */
1428
1429 dummy = ReadDOC(docptr, CDSNSlowIO);
1430 DoC_Delay(this, 2);
1431
1432 if (ReadDOC_(docptr, this->ioreg) & 1) {
1433 puts ("Error programming oob data\n");
1434 /* There was an error */
1435 *retlen = 0;
1436 return DOC_EIO;
1437 }
1438 DoC_Command(this, NAND_CMD_SEQIN, 0);
1439 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff), 0, 0);
1440 }
1441
1442 DoC_WriteBuf(this, &buf[len256], len - len256);
1443
1444 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1445 DoC_Command(this, NAND_CMD_STATUS, 0);
1446 /* DoC_WaitReady() is implicit in DoC_Command */
1447
1448 dummy = ReadDOC(docptr, CDSNSlowIO);
1449 DoC_Delay(this, 2);
1450
1451 if (ReadDOC_(docptr, this->ioreg) & 1) {
1452 puts ("Error programming oob data\n");
1453 /* There was an error */
1454 *retlen = 0;
1455 return DOC_EIO;
1456 }
1457
1458 *retlen = len;
1459 return 0;
1460
1461 }
1462
1463 int doc_erase(struct DiskOnChip* this, loff_t ofs, size_t len)
1464 {
1465 volatile int dummy;
1466 unsigned long docptr;
1467 struct Nand *mychip;
1468
1469 if (ofs & (this->erasesize-1) || len & (this->erasesize-1)) {
1470 puts ("Offset and size must be sector aligned\n");
1471 return DOC_EINVAL;
1472 }
1473
1474 docptr = this->virtadr;
1475
1476 /* FIXME: Do this in the background. Use timers or schedule_task() */
1477 while(len) {
1478 mychip = &this->chips[shr(ofs, this->chipshift)];
1479
1480 if (this->curfloor != mychip->floor) {
1481 DoC_SelectFloor(this, mychip->floor);
1482 DoC_SelectChip(this, mychip->chip);
1483 } else if (this->curchip != mychip->chip) {
1484 DoC_SelectChip(this, mychip->chip);
1485 }
1486 this->curfloor = mychip->floor;
1487 this->curchip = mychip->chip;
1488
1489 DoC_Command(this, NAND_CMD_ERASE1, 0);
1490 DoC_Address(this, ADDR_PAGE, ofs, 0, 0);
1491 DoC_Command(this, NAND_CMD_ERASE2, 0);
1492
1493 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1494
1495 dummy = ReadDOC(docptr, CDSNSlowIO);
1496 DoC_Delay(this, 2);
1497
1498 if (ReadDOC_(docptr, this->ioreg) & 1) {
1499 printf("Error erasing at 0x%lx\n", (long)ofs);
1500 /* There was an error */
1501 goto callback;
1502 }
1503 ofs += this->erasesize;
1504 len -= this->erasesize;
1505 }
1506
1507 callback:
1508 return 0;
1509 }
1510
1511 static inline int doccheck(unsigned long potential, unsigned long physadr)
1512 {
1513 unsigned long window=potential;
1514 unsigned char tmp, ChipID;
1515 #ifndef DOC_PASSIVE_PROBE
1516 unsigned char tmp2;
1517 #endif
1518
1519 /* Routine copied from the Linux DOC driver */
1520
1521 #ifdef CFG_DOCPROBE_55AA
1522 /* Check for 0x55 0xAA signature at beginning of window,
1523 this is no longer true once we remove the IPL (for Millennium */
1524 if (ReadDOC(window, Sig1) != 0x55 || ReadDOC(window, Sig2) != 0xaa)
1525 return 0;
1526 #endif /* CFG_DOCPROBE_55AA */
1527
1528 #ifndef DOC_PASSIVE_PROBE
1529 /* It's not possible to cleanly detect the DiskOnChip - the
1530 * bootup procedure will put the device into reset mode, and
1531 * it's not possible to talk to it without actually writing
1532 * to the DOCControl register. So we store the current contents
1533 * of the DOCControl register's location, in case we later decide
1534 * that it's not a DiskOnChip, and want to put it back how we
1535 * found it.
1536 */
1537 tmp2 = ReadDOC(window, DOCControl);
1538
1539 /* Reset the DiskOnChip ASIC */
1540 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1541 window, DOCControl);
1542 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1543 window, DOCControl);
1544
1545 /* Enable the DiskOnChip ASIC */
1546 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1547 window, DOCControl);
1548 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1549 window, DOCControl);
1550 #endif /* !DOC_PASSIVE_PROBE */
1551
1552 ChipID = ReadDOC(window, ChipID);
1553
1554 switch (ChipID) {
1555 case DOC_ChipID_Doc2k:
1556 /* Check the TOGGLE bit in the ECC register */
1557 tmp = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
1558 if ((ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT) != tmp)
1559 return ChipID;
1560 break;
1561
1562 case DOC_ChipID_DocMil:
1563 /* Check the TOGGLE bit in the ECC register */
1564 tmp = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
1565 if ((ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT) != tmp)
1566 return ChipID;
1567 break;
1568
1569 default:
1570 #ifndef CFG_DOCPROBE_55AA
1571 /*
1572 * if the ID isn't the DoC2000 or DoCMillenium ID, so we can assume
1573 * the DOC is missing
1574 */
1575 # if 0
1576 printf("Possible DiskOnChip with unknown ChipID %2.2X found at 0x%lx\n",
1577 ChipID, physadr);
1578 # endif
1579 #endif
1580 #ifndef DOC_PASSIVE_PROBE
1581 /* Put back the contents of the DOCControl register, in case it's not
1582 * actually a DiskOnChip.
1583 */
1584 WriteDOC(tmp2, window, DOCControl);
1585 #endif
1586 return 0;
1587 }
1588
1589 puts ("DiskOnChip failed TOGGLE test, dropping.\n");
1590
1591 #ifndef DOC_PASSIVE_PROBE
1592 /* Put back the contents of the DOCControl register: it's not a DiskOnChip */
1593 WriteDOC(tmp2, window, DOCControl);
1594 #endif
1595 return 0;
1596 }
1597
1598 void doc_probe(unsigned long physadr)
1599 {
1600 struct DiskOnChip *this = NULL;
1601 int i=0, ChipID;
1602
1603 if ((ChipID = doccheck(physadr, physadr))) {
1604
1605 for (i=0; i<CFG_MAX_DOC_DEVICE; i++) {
1606 if (doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN) {
1607 this = doc_dev_desc + i;
1608 break;
1609 }
1610 }
1611
1612 if (!this) {
1613 puts ("Cannot allocate memory for data structures.\n");
1614 return;
1615 }
1616
1617 if (curr_device == -1)
1618 curr_device = i;
1619
1620 memset((char *)this, 0, sizeof(struct DiskOnChip));
1621
1622 this->virtadr = physadr;
1623 this->physadr = physadr;
1624 this->ChipID = ChipID;
1625
1626 DoC2k_init(this);
1627 } else {
1628 puts ("No DiskOnChip found\n");
1629 }
1630 }
"Das U-Boot" Source Tree