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>
6 * $Id: doc2000.c,v 1.46 2001/10/02 15:05:13 dwmw2 Exp $
14 #include <linux/mtd/nftl.h>
15 #include <linux/mtd/doc2000.h>
17 #error This code is broken and will be removed outright in the next release.
18 #error If you need diskonchip support, please update the Linux driver in
19 #error drivers/mtd/nand/diskonchip.c to work with u-boot.
24 * TODO: must be implemented and tested by someone with HW
27 #ifdef CONFIG_SYS_DOC_SUPPORT_2000
28 #define DoC_is_2000(doc) (doc->ChipID == DOC_ChipID_Doc2k)
30 #define DoC_is_2000(doc) (0)
33 #ifdef CONFIG_SYS_DOC_SUPPORT_MILLENNIUM
34 #define DoC_is_Millennium(doc) (doc->ChipID == DOC_ChipID_DocMil)
36 #define DoC_is_Millennium(doc) (0)
39 /* CONFIG_SYS_DOC_PASSIVE_PROBE:
40 In order to ensure that the BIOS checksum is correct at boot time, and
41 hence that the onboard BIOS extension gets executed, the DiskOnChip
42 goes into reset mode when it is read sequentially: all registers
43 return 0xff until the chip is woken up again by writing to the
46 Unfortunately, this means that the probe for the DiskOnChip is unsafe,
47 because one of the first things it does is write to where it thinks
48 the DOCControl register should be - which may well be shared memory
49 for another device. I've had machines which lock up when this is
50 attempted. Hence the possibility to do a passive probe, which will fail
51 to detect a chip in reset mode, but is at least guaranteed not to lock
54 If you have this problem, uncomment the following line:
55 #define CONFIG_SYS_DOC_PASSIVE_PROBE
63 static struct DiskOnChip doc_dev_desc[CONFIG_SYS_MAX_DOC_DEVICE];
65 /* Current DOC Device */
66 static int curr_device = -1;
68 /* Supported NAND flash devices */
69 static struct nand_flash_dev nand_flash_ids[] = {
70 {"Toshiba TC5816BDC", NAND_MFR_TOSHIBA, 0x64, 21, 1, 2, 0x1000, 0},
71 {"Toshiba TC5832DC", NAND_MFR_TOSHIBA, 0x6b, 22, 0, 2, 0x2000, 0},
72 {"Toshiba TH58V128DC", NAND_MFR_TOSHIBA, 0x73, 24, 0, 2, 0x4000, 0},
73 {"Toshiba TC58256FT/DC", NAND_MFR_TOSHIBA, 0x75, 25, 0, 2, 0x4000, 0},
74 {"Toshiba TH58512FT", NAND_MFR_TOSHIBA, 0x76, 26, 0, 3, 0x4000, 0},
75 {"Toshiba TC58V32DC", NAND_MFR_TOSHIBA, 0xe5, 22, 0, 2, 0x2000, 0},
76 {"Toshiba TC58V64AFT/DC", NAND_MFR_TOSHIBA, 0xe6, 23, 0, 2, 0x2000, 0},
77 {"Toshiba TC58V16BDC", NAND_MFR_TOSHIBA, 0xea, 21, 1, 2, 0x1000, 0},
78 {"Toshiba TH58100FT", NAND_MFR_TOSHIBA, 0x79, 27, 0, 3, 0x4000, 0},
79 {"Samsung KM29N16000", NAND_MFR_SAMSUNG, 0x64, 21, 1, 2, 0x1000, 0},
80 {"Samsung unknown 4Mb", NAND_MFR_SAMSUNG, 0x6b, 22, 0, 2, 0x2000, 0},
81 {"Samsung KM29U128T", NAND_MFR_SAMSUNG, 0x73, 24, 0, 2, 0x4000, 0},
82 {"Samsung KM29U256T", NAND_MFR_SAMSUNG, 0x75, 25, 0, 2, 0x4000, 0},
83 {"Samsung unknown 64Mb", NAND_MFR_SAMSUNG, 0x76, 26, 0, 3, 0x4000, 0},
84 {"Samsung KM29W32000", NAND_MFR_SAMSUNG, 0xe3, 22, 0, 2, 0x2000, 0},
85 {"Samsung unknown 4Mb", NAND_MFR_SAMSUNG, 0xe5, 22, 0, 2, 0x2000, 0},
86 {"Samsung KM29U64000", NAND_MFR_SAMSUNG, 0xe6, 23, 0, 2, 0x2000, 0},
87 {"Samsung KM29W16000", NAND_MFR_SAMSUNG, 0xea, 21, 1, 2, 0x1000, 0},
88 {"Samsung K9F5616Q0C", NAND_MFR_SAMSUNG, 0x45, 25, 0, 2, 0x4000, 1},
89 {"Samsung K9K1216Q0C", NAND_MFR_SAMSUNG, 0x46, 26, 0, 3, 0x4000, 1},
90 {"Samsung K9F1G08U0M", NAND_MFR_SAMSUNG, 0xf1, 27, 0, 2, 0, 0},
94 /* ------------------------------------------------------------------------- */
96 int do_doc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
106 if (strcmp(argv[1],"info") == 0) {
111 for (i=0; i<CONFIG_SYS_MAX_DOC_DEVICE; ++i) {
112 if(doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN)
113 continue; /* list only known devices */
114 printf ("Device %d: ", i);
115 doc_print(&doc_dev_desc[i]);
119 } else if (strcmp(argv[1],"device") == 0) {
120 if ((curr_device < 0) || (curr_device >= CONFIG_SYS_MAX_DOC_DEVICE)) {
121 puts ("\nno devices available\n");
124 printf ("\nDevice %d: ", curr_device);
125 doc_print(&doc_dev_desc[curr_device]);
131 if (strcmp(argv[1],"device") == 0) {
132 int dev = (int)simple_strtoul(argv[2], NULL, 10);
134 printf ("\nDevice %d: ", dev);
135 if (dev >= CONFIG_SYS_MAX_DOC_DEVICE) {
136 puts ("unknown device\n");
139 doc_print(&doc_dev_desc[dev]);
142 if (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN) {
148 puts ("... is now current device\n");
156 /* at least 4 args */
158 if (strcmp(argv[1],"read") == 0 || strcmp(argv[1],"write") == 0) {
159 ulong addr = simple_strtoul(argv[2], NULL, 16);
160 ulong off = simple_strtoul(argv[3], NULL, 16);
161 ulong size = simple_strtoul(argv[4], NULL, 16);
162 int cmd = (strcmp(argv[1],"read") == 0);
165 printf ("\nDOC %s: device %d offset %ld, size %ld ... ",
166 cmd ? "read" : "write", curr_device, off, size);
168 ret = doc_rw(doc_dev_desc + curr_device, cmd, off, size,
169 (size_t *)&total, (u_char*)addr);
171 printf ("%d bytes %s: %s\n", total, cmd ? "read" : "write",
172 ret ? "ERROR" : "OK");
175 } else if (strcmp(argv[1],"erase") == 0) {
176 ulong off = simple_strtoul(argv[2], NULL, 16);
177 ulong size = simple_strtoul(argv[3], NULL, 16);
180 printf ("\nDOC erase: device %d offset %ld, size %ld ... ",
181 curr_device, off, size);
183 ret = doc_erase (doc_dev_desc + curr_device, off, size);
185 printf("%s\n", ret ? "ERROR" : "OK");
198 "Disk-On-Chip sub-system",
199 "info - show available DOC devices\n"
200 "doc device [dev] - show or set current device\n"
201 "doc read addr off size\n"
202 "doc write addr off size - read/write `size'"
203 " bytes starting at offset `off'\n"
204 " to/from memory address `addr'\n"
205 "doc erase off size - erase `size' bytes of DOC from offset `off'\n"
208 int do_docboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
210 char *boot_device = NULL;
218 #if defined(CONFIG_FIT)
219 const void *fit_hdr = NULL;
222 show_boot_progress (34);
225 addr = CONFIG_SYS_LOAD_ADDR;
226 boot_device = getenv ("bootdevice");
229 addr = simple_strtoul(argv[1], NULL, 16);
230 boot_device = getenv ("bootdevice");
233 addr = simple_strtoul(argv[1], NULL, 16);
234 boot_device = argv[2];
237 addr = simple_strtoul(argv[1], NULL, 16);
238 boot_device = argv[2];
239 offset = simple_strtoul(argv[3], NULL, 16);
243 show_boot_progress (-35);
247 show_boot_progress (35);
249 puts ("\n** No boot device **\n");
250 show_boot_progress (-36);
253 show_boot_progress (36);
255 dev = simple_strtoul(boot_device, &ep, 16);
257 if ((dev >= CONFIG_SYS_MAX_DOC_DEVICE) ||
258 (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN)) {
259 printf ("\n** Device %d not available\n", dev);
260 show_boot_progress (-37);
263 show_boot_progress (37);
265 printf ("\nLoading from device %d: %s at 0x%lX (offset 0x%lX)\n",
266 dev, doc_dev_desc[dev].name, doc_dev_desc[dev].physadr,
269 if (doc_rw (doc_dev_desc + dev, 1, offset,
270 SECTORSIZE, NULL, (u_char *)addr)) {
271 printf ("** Read error on %d\n", dev);
272 show_boot_progress (-38);
275 show_boot_progress (38);
277 switch (genimg_get_format ((void *)addr)) {
278 case IMAGE_FORMAT_LEGACY:
279 hdr = (image_header_t *)addr;
281 image_print_contents (hdr);
283 cnt = image_get_image_size (hdr);
285 #if defined(CONFIG_FIT)
286 case IMAGE_FORMAT_FIT:
287 fit_hdr = (const void *)addr;
288 puts ("Fit image detected...\n");
290 cnt = fit_get_size (fit_hdr);
294 show_boot_progress (-39);
295 puts ("** Unknown image type\n");
298 show_boot_progress (39);
301 if (doc_rw (doc_dev_desc + dev, 1, offset + SECTORSIZE, cnt,
302 NULL, (u_char *)(addr+SECTORSIZE))) {
303 printf ("** Read error on %d\n", dev);
304 show_boot_progress (-40);
307 show_boot_progress (40);
309 #if defined(CONFIG_FIT)
310 /* This cannot be done earlier, we need complete FIT image in RAM first */
311 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
312 if (!fit_check_format (fit_hdr)) {
313 show_boot_progress (-130);
314 puts ("** Bad FIT image format\n");
317 show_boot_progress (131);
318 fit_print_contents (fit_hdr);
322 /* Loading ok, update default load address */
326 /* Check if we should attempt an auto-start */
327 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
329 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
331 local_args[0] = argv[0];
332 local_args[1] = NULL;
334 printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
336 do_bootm (cmdtp, 0, 1, local_args);
343 docboot, 4, 1, do_docboot,
344 "boot from DOC device",
348 int doc_rw (struct DiskOnChip* this, int cmd,
349 loff_t from, size_t len,
350 size_t * retlen, u_char * buf)
352 int noecc, ret = 0, n, total = 0;
356 /* The ECC will not be calculated correctly if
357 less than 512 is written or read */
358 noecc = (from != (from | 0x1ff) + 1) || (len < 0x200);
361 ret = doc_read_ecc(this, from, len,
362 (size_t *)&n, (u_char*)buf,
363 noecc ? (uchar *)NULL : (uchar *)eccbuf);
365 ret = doc_write_ecc(this, from, len,
366 (size_t *)&n, (u_char*)buf,
367 noecc ? (uchar *)NULL : (uchar *)eccbuf);
384 void doc_print(struct DiskOnChip *this) {
385 printf("%s at 0x%lX,\n"
386 "\t %d chip%s %s, size %d MB, \n"
387 "\t total size %ld MB, sector size %ld kB\n",
388 this->name, this->physadr, this->numchips,
389 this->numchips>1 ? "s" : "", this->chips_name,
390 1 << (this->chipshift - 20),
391 this->totlen >> 20, this->erasesize >> 10);
393 if (this->nftl_found) {
394 struct NFTLrecord *nftl = &this->nftl;
395 unsigned long bin_size, flash_size;
397 bin_size = nftl->nb_boot_blocks * this->erasesize;
398 flash_size = (nftl->nb_blocks - nftl->nb_boot_blocks) * this->erasesize;
400 printf("\t NFTL boot record:\n"
401 "\t Binary partition: size %ld%s\n"
402 "\t Flash disk partition: size %ld%s, offset 0x%lx\n",
403 bin_size > (1 << 20) ? bin_size >> 20 : bin_size >> 10,
404 bin_size > (1 << 20) ? "MB" : "kB",
405 flash_size > (1 << 20) ? flash_size >> 20 : flash_size >> 10,
406 flash_size > (1 << 20) ? "MB" : "kB", bin_size);
408 puts ("\t No NFTL boot record found.\n");
412 /* ------------------------------------------------------------------------- */
414 /* This function is needed to avoid calls of the __ashrdi3 function. */
415 static int shr(int val, int shift) {
419 /* Perform the required delay cycles by reading from the appropriate register */
420 static void DoC_Delay(struct DiskOnChip *doc, unsigned short cycles)
425 for (i = 0; i < cycles; i++) {
426 if (DoC_is_Millennium(doc))
427 dummy = ReadDOC(doc->virtadr, NOP);
429 dummy = ReadDOC(doc->virtadr, DOCStatus);
434 /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
435 static int _DoC_WaitReady(struct DiskOnChip *doc)
437 unsigned long docptr = doc->virtadr;
438 unsigned long start = get_timer(0);
441 puts ("_DoC_WaitReady called for out-of-line wait\n");
444 /* Out-of-line routine to wait for chip response */
445 while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
446 #ifdef CONFIG_SYS_DOC_SHORT_TIMEOUT
447 /* it seems that after a certain time the DoC deasserts
448 * the CDSN_CTRL_FR_B although it is not ready...
449 * using a short timout solve this (timer increments every ms) */
450 if (get_timer(start) > 10) {
454 if (get_timer(start) > 10 * 1000) {
455 puts ("_DoC_WaitReady timed out.\n");
465 static int DoC_WaitReady(struct DiskOnChip *doc)
467 unsigned long docptr = doc->virtadr;
468 /* This is inline, to optimise the common case, where it's ready instantly */
471 /* 4 read form NOP register should be issued in prior to the read from CDSNControl
472 see Software Requirement 11.4 item 2. */
475 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
476 /* Call the out-of-line routine to wait */
477 ret = _DoC_WaitReady(doc);
479 /* issue 2 read from NOP register after reading from CDSNControl register
480 see Software Requirement 11.4 item 2. */
486 /* DoC_Command: Send a flash command to the flash chip through the CDSN Slow IO register to
487 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
488 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
490 static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,
491 unsigned char xtraflags)
493 unsigned long docptr = doc->virtadr;
495 if (DoC_is_2000(doc))
496 xtraflags |= CDSN_CTRL_FLASH_IO;
498 /* Assert the CLE (Command Latch Enable) line to the flash chip */
499 WriteDOC(xtraflags | CDSN_CTRL_CLE | CDSN_CTRL_CE, docptr, CDSNControl);
500 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
502 if (DoC_is_Millennium(doc))
503 WriteDOC(command, docptr, CDSNSlowIO);
505 /* Send the command */
506 WriteDOC_(command, docptr, doc->ioreg);
508 /* Lower the CLE line */
509 WriteDOC(xtraflags | CDSN_CTRL_CE, docptr, CDSNControl);
510 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
512 /* Wait for the chip to respond - Software requirement 11.4.1 (extended for any command) */
513 return DoC_WaitReady(doc);
516 /* DoC_Address: Set the current address for the flash chip through the CDSN Slow IO register to
517 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
518 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
520 static int DoC_Address(struct DiskOnChip *doc, int numbytes, unsigned long ofs,
521 unsigned char xtraflags1, unsigned char xtraflags2)
523 unsigned long docptr;
526 docptr = doc->virtadr;
528 if (DoC_is_2000(doc))
529 xtraflags1 |= CDSN_CTRL_FLASH_IO;
531 /* Assert the ALE (Address Latch Enable) line to the flash chip */
532 WriteDOC(xtraflags1 | CDSN_CTRL_ALE | CDSN_CTRL_CE, docptr, CDSNControl);
534 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
536 /* Send the address */
537 /* Devices with 256-byte page are addressed as:
538 Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
539 * there is no device on the market with page256
540 and more than 24 bits.
541 Devices with 512-byte page are addressed as:
542 Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
543 * 25-31 is sent only if the chip support it.
544 * bit 8 changes the read command to be sent
545 (NAND_CMD_READ0 or NAND_CMD_READ1).
548 if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE) {
549 if (DoC_is_Millennium(doc))
550 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
551 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
560 if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE) {
561 for (i = 0; i < doc->pageadrlen; i++, ofs = ofs >> 8) {
562 if (DoC_is_Millennium(doc))
563 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
564 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
568 DoC_Delay(doc, 2); /* Needed for some slow flash chips. mf. */
570 /* FIXME: The SlowIO's for millennium could be replaced by
571 a single WritePipeTerm here. mf. */
573 /* Lower the ALE line */
574 WriteDOC(xtraflags1 | xtraflags2 | CDSN_CTRL_CE, docptr,
577 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
579 /* Wait for the chip to respond - Software requirement 11.4.1 */
580 return DoC_WaitReady(doc);
583 /* Read a buffer from DoC, taking care of Millennium oddities */
584 static void DoC_ReadBuf(struct DiskOnChip *doc, u_char * buf, int len)
587 int modulus = 0xffff;
588 unsigned long docptr;
591 docptr = doc->virtadr;
596 if (DoC_is_Millennium(doc)) {
597 /* Read the data via the internal pipeline through CDSN IO register,
598 see Pipelined Read Operations 11.3 */
599 dummy = ReadDOC(docptr, ReadPipeInit);
601 /* Millennium should use the LastDataRead register - Pipeline Reads */
604 /* This is needed for correctly ECC calculation */
608 for (i = 0; i < len; i++)
609 buf[i] = ReadDOC_(docptr, doc->ioreg + (i & modulus));
611 if (DoC_is_Millennium(doc)) {
612 buf[i] = ReadDOC(docptr, LastDataRead);
616 /* Write a buffer to DoC, taking care of Millennium oddities */
617 static void DoC_WriteBuf(struct DiskOnChip *doc, const u_char * buf, int len)
619 unsigned long docptr;
622 docptr = doc->virtadr;
627 for (i = 0; i < len; i++)
628 WriteDOC_(buf[i], docptr, doc->ioreg + i);
630 if (DoC_is_Millennium(doc)) {
631 WriteDOC(0x00, docptr, WritePipeTerm);
636 /* DoC_SelectChip: Select a given flash chip within the current floor */
638 static inline int DoC_SelectChip(struct DiskOnChip *doc, int chip)
640 unsigned long docptr = doc->virtadr;
642 /* Software requirement 11.4.4 before writing DeviceSelect */
643 /* Deassert the CE line to eliminate glitches on the FCE# outputs */
644 WriteDOC(CDSN_CTRL_WP, docptr, CDSNControl);
645 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
647 /* Select the individual flash chip requested */
648 WriteDOC(chip, docptr, CDSNDeviceSelect);
651 /* Reassert the CE line */
652 WriteDOC(CDSN_CTRL_CE | CDSN_CTRL_FLASH_IO | CDSN_CTRL_WP, docptr,
654 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
656 /* Wait for it to be ready */
657 return DoC_WaitReady(doc);
660 /* DoC_SelectFloor: Select a given floor (bank of flash chips) */
662 static inline int DoC_SelectFloor(struct DiskOnChip *doc, int floor)
664 unsigned long docptr = doc->virtadr;
666 /* Select the floor (bank) of chips required */
667 WriteDOC(floor, docptr, FloorSelect);
669 /* Wait for the chip to be ready */
670 return DoC_WaitReady(doc);
673 /* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */
675 static int DoC_IdentChip(struct DiskOnChip *doc, int floor, int chip)
680 /* Page in the required floor/chip */
681 DoC_SelectFloor(doc, floor);
682 DoC_SelectChip(doc, chip);
685 if (DoC_Command(doc, NAND_CMD_RESET, CDSN_CTRL_WP)) {
687 printf("DoC_Command (reset) for %d,%d returned true\n",
694 /* Read the NAND chip ID: 1. Send ReadID command */
695 if (DoC_Command(doc, NAND_CMD_READID, CDSN_CTRL_WP)) {
697 printf("DoC_Command (ReadID) for %d,%d returned true\n",
703 /* Read the NAND chip ID: 2. Send address byte zero */
704 DoC_Address(doc, ADDR_COLUMN, 0, CDSN_CTRL_WP, 0);
706 /* Read the manufacturer and device id codes from the device */
708 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
709 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
711 mfr = ReadDOC_(doc->virtadr, doc->ioreg);
713 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
714 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
716 id = ReadDOC_(doc->virtadr, doc->ioreg);
718 /* No response - return failure */
719 if (mfr == 0xff || mfr == 0)
722 /* Check it's the same as the first chip we identified.
723 * M-Systems say that any given DiskOnChip device should only
724 * contain _one_ type of flash part, although that's not a
725 * hardware restriction. */
727 if (doc->mfr == mfr && doc->id == id)
728 return 1; /* This is another the same the first */
730 printf("Flash chip at floor %d, chip %d is different:\n",
734 /* Print and store the manufacturer and ID codes. */
735 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
736 if (mfr == nand_flash_ids[i].manufacture_id &&
737 id == nand_flash_ids[i].model_id) {
739 printf("Flash chip found: Manufacturer ID: %2.2X, "
740 "Chip ID: %2.2X (%s)\n", mfr, id,
741 nand_flash_ids[i].name);
747 nand_flash_ids[i].chipshift;
748 doc->page256 = nand_flash_ids[i].page256;
750 nand_flash_ids[i].pageadrlen;
752 nand_flash_ids[i].erasesize;
754 nand_flash_ids[i].name;
763 /* We haven't fully identified the chip. Print as much as we know. */
764 printf("Unknown flash chip found: %2.2X %2.2X\n",
771 /* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */
773 static void DoC_ScanChips(struct DiskOnChip *this)
776 int numchips[MAX_FLOORS];
777 int maxchips = MAX_CHIPS;
784 if (DoC_is_Millennium(this))
785 maxchips = MAX_CHIPS_MIL;
787 /* For each floor, find the number of valid chips it contains */
788 for (floor = 0; floor < MAX_FLOORS; floor++) {
791 for (chip = 0; chip < maxchips && ret != 0; chip++) {
793 ret = DoC_IdentChip(this, floor, chip);
801 /* If there are none at all that we recognise, bail */
802 if (!this->numchips) {
803 puts ("No flash chips recognised.\n");
807 /* Allocate an array to hold the information for each chip */
808 this->chips = malloc(sizeof(struct Nand) * this->numchips);
810 puts ("No memory for allocating chip info structures\n");
816 /* Fill out the chip array with {floor, chipno} for each
817 * detected chip in the device. */
818 for (floor = 0; floor < MAX_FLOORS; floor++) {
819 for (chip = 0; chip < numchips[floor]; chip++) {
820 this->chips[ret].floor = floor;
821 this->chips[ret].chip = chip;
822 this->chips[ret].curadr = 0;
823 this->chips[ret].curmode = 0x50;
828 /* Calculate and print the total size of the device */
829 this->totlen = this->numchips * (1 << this->chipshift);
832 printf("%d flash chips found. Total DiskOnChip size: %ld MB\n",
833 this->numchips, this->totlen >> 20);
837 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
838 * various device information of the NFTL partition and Bad Unit Table. Update
839 * the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
840 * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
842 static int find_boot_record(struct NFTLrecord *nftl)
846 unsigned int block, boot_record_count = 0;
849 struct NFTLMediaHeader *mh = &nftl->MediaHdr;
852 nftl->MediaUnit = BLOCK_NIL;
853 nftl->SpareMediaUnit = BLOCK_NIL;
855 /* search for a valid boot record */
856 for (block = 0; block < nftl->nb_blocks; block++) {
859 /* Check for ANAND header first. Then can whinge if it's found but later
861 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize, SECTORSIZE,
862 (size_t *)&retlen, buf, NULL))) {
863 static int warncount = 5;
866 printf("Block read at 0x%x failed\n", block * nftl->EraseSize);
868 puts ("Further failures for this block will not be printed\n");
873 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
874 /* ANAND\0 not found. Continue */
876 printf("ANAND header not found at 0x%x\n", block * nftl->EraseSize);
882 printf("ANAND header found at 0x%x\n", block * nftl->EraseSize);
885 /* To be safer with BIOS, also use erase mark as discriminant */
886 if ((ret = doc_read_oob(nftl->mtd, block * nftl->EraseSize + SECTORSIZE + 8,
887 8, (size_t *)&retlen, (uchar *)&h1) < 0)) {
889 printf("ANAND header found at 0x%x, but OOB data read failed\n",
890 block * nftl->EraseSize);
895 /* OK, we like it. */
897 if (boot_record_count) {
898 /* We've already processed one. So we just check if
899 this one is the same as the first one we found */
900 if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
902 printf("NFTL Media Headers at 0x%x and 0x%x disagree.\n",
903 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
905 /* if (debug) Print both side by side */
908 if (boot_record_count == 1)
909 nftl->SpareMediaUnit = block;
915 /* This is the first we've seen. Copy the media header structure into place */
916 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
918 /* Do some sanity checks on it */
919 if (mh->UnitSizeFactor == 0) {
921 puts ("UnitSizeFactor 0x00 detected.\n"
922 "This violates the spec but we think we know what it means...\n");
924 } else if (mh->UnitSizeFactor != 0xff) {
925 printf ("Sorry, we don't support UnitSizeFactor "
930 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
931 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
932 printf ("NFTL Media Header sanity check failed:\n"
933 "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
934 nftl->nb_boot_blocks, nftl->nb_blocks);
938 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
939 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
940 printf ("NFTL Media Header sanity check failed:\n"
941 "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
944 nftl->nb_boot_blocks);
948 nftl->nr_sects = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
950 /* If we're not using the last sectors in the device for some reason,
951 reduce nb_blocks accordingly so we forget they're there */
952 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
954 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
955 for (i = 0; i < nftl->nb_blocks; i++) {
956 if ((i & (SECTORSIZE - 1)) == 0) {
957 /* read one sector for every SECTORSIZE of blocks */
958 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize +
959 i + SECTORSIZE, SECTORSIZE,
960 (size_t *)&retlen, buf, (uchar *)&oob)) < 0) {
961 puts ("Read of bad sector table failed\n");
965 /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
966 if (buf[i & (SECTORSIZE - 1)] != 0xff)
967 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
970 nftl->MediaUnit = block;
973 } /* foreach (block) */
975 return boot_record_count?0:-1;
978 /* This routine is made available to other mtd code via
979 * inter_module_register. It must only be accessed through
980 * inter_module_get which will bump the use count of this module. The
981 * addresses passed back in mtd are valid as long as the use count of
982 * this module is non-zero, i.e. between inter_module_get and
983 * inter_module_put. Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
985 static void DoC2k_init(struct DiskOnChip* this)
987 struct NFTLrecord *nftl;
989 switch (this->ChipID) {
990 case DOC_ChipID_Doc2k:
991 this->name = "DiskOnChip 2000";
992 this->ioreg = DoC_2k_CDSN_IO;
994 case DOC_ChipID_DocMil:
995 this->name = "DiskOnChip Millennium";
996 this->ioreg = DoC_Mil_CDSN_IO;
1001 printf("%s found at address 0x%lX\n", this->name,
1008 this->curfloor = -1;
1011 /* Ident all the chips present. */
1012 DoC_ScanChips(this);
1013 if ((!this->numchips) || (!this->chips))
1018 /* Get physical parameters */
1019 nftl->EraseSize = this->erasesize;
1020 nftl->nb_blocks = this->totlen / this->erasesize;
1023 if (find_boot_record(nftl) != 0)
1024 this->nftl_found = 0;
1026 this->nftl_found = 1;
1028 printf("%s @ 0x%lX, %ld MB\n", this->name, this->physadr, this->totlen >> 20);
1031 int doc_read_ecc(struct DiskOnChip* this, loff_t from, size_t len,
1032 size_t * retlen, u_char * buf, u_char * eccbuf)
1034 unsigned long docptr;
1035 struct Nand *mychip;
1036 unsigned char syndrome[6];
1037 volatile char dummy;
1038 int i, len256 = 0, ret=0;
1040 docptr = this->virtadr;
1042 /* Don't allow read past end of device */
1043 if (from >= this->totlen) {
1044 puts ("Out of flash\n");
1048 /* Don't allow a single read to cross a 512-byte block boundary */
1049 if (from + len > ((from | 0x1ff) + 1))
1050 len = ((from | 0x1ff) + 1) - from;
1052 /* The ECC will not be calculated correctly if less than 512 is read */
1053 if (len != 0x200 && eccbuf)
1054 printf("ECC needs a full sector read (adr: %lx size %lx)\n",
1055 (long) from, (long) len);
1058 printf("DoC_Read (adr: %lx size %lx)\n", (long) from, (long) len);
1061 /* Find the chip which is to be used and select it */
1062 mychip = &this->chips[shr(from, this->chipshift)];
1064 if (this->curfloor != mychip->floor) {
1065 DoC_SelectFloor(this, mychip->floor);
1066 DoC_SelectChip(this, mychip->chip);
1067 } else if (this->curchip != mychip->chip) {
1068 DoC_SelectChip(this, mychip->chip);
1071 this->curfloor = mychip->floor;
1072 this->curchip = mychip->chip;
1076 && (from & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1078 DoC_Address(this, ADDR_COLUMN_PAGE, from, CDSN_CTRL_WP,
1082 /* Prime the ECC engine */
1083 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1084 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
1086 /* disable the ECC engine */
1087 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1088 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1091 /* treat crossing 256-byte sector for 2M x 8bits devices */
1092 if (this->page256 && from + len > (from | 0xff) + 1) {
1093 len256 = (from | 0xff) + 1 - from;
1094 DoC_ReadBuf(this, buf, len256);
1096 DoC_Command(this, NAND_CMD_READ0, CDSN_CTRL_WP);
1097 DoC_Address(this, ADDR_COLUMN_PAGE, from + len256,
1098 CDSN_CTRL_WP, CDSN_CTRL_ECC_IO);
1101 DoC_ReadBuf(this, &buf[len256], len - len256);
1103 /* Let the caller know we completed it */
1107 /* Read the ECC data through the DiskOnChip ECC logic */
1108 /* Note: this will work even with 2M x 8bit devices as */
1109 /* they have 8 bytes of OOB per 256 page. mf. */
1110 DoC_ReadBuf(this, eccbuf, 6);
1112 /* Flush the pipeline */
1113 if (DoC_is_Millennium(this)) {
1114 dummy = ReadDOC(docptr, ECCConf);
1115 dummy = ReadDOC(docptr, ECCConf);
1116 i = ReadDOC(docptr, ECCConf);
1118 dummy = ReadDOC(docptr, 2k_ECCStatus);
1119 dummy = ReadDOC(docptr, 2k_ECCStatus);
1120 i = ReadDOC(docptr, 2k_ECCStatus);
1123 /* Check the ECC Status */
1126 /* There was an ECC error */
1128 printf("DiskOnChip ECC Error: Read at %lx\n", (long)from);
1130 /* Read the ECC syndrom through the DiskOnChip ECC logic.
1131 These syndrome will be all ZERO when there is no error */
1132 for (i = 0; i < 6; i++) {
1134 ReadDOC(docptr, ECCSyndrome0 + i);
1136 nb_errors = doc_decode_ecc(buf, syndrome);
1139 printf("Errors corrected: %x\n", nb_errors);
1141 if (nb_errors < 0) {
1142 /* We return error, but have actually done the read. Not that
1143 this can be told to user-space, via sys_read(), but at least
1144 MTD-aware stuff can know about it by checking *retlen */
1145 printf("ECC Errors at %lx\n", (long)from);
1151 printf("ECC DATA at %lxB: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1152 (long)from, eccbuf[0], eccbuf[1], eccbuf[2],
1153 eccbuf[3], eccbuf[4], eccbuf[5]);
1156 /* disable the ECC engine */
1157 WriteDOC(DOC_ECC_DIS, docptr , ECCConf);
1160 /* according to 11.4.1, we need to wait for the busy line
1161 * drop if we read to the end of the page. */
1162 if(0 == ((from + *retlen) & 0x1ff))
1164 DoC_WaitReady(this);
1170 int doc_write_ecc(struct DiskOnChip* this, loff_t to, size_t len,
1171 size_t * retlen, const u_char * buf,
1174 int di; /* Yes, DI is a hangover from when I was disassembling the binary driver */
1175 unsigned long docptr;
1176 volatile char dummy;
1178 struct Nand *mychip;
1180 docptr = this->virtadr;
1182 /* Don't allow write past end of device */
1183 if (to >= this->totlen) {
1184 puts ("Out of flash\n");
1188 /* Don't allow a single write to cross a 512-byte block boundary */
1189 if (to + len > ((to | 0x1ff) + 1))
1190 len = ((to | 0x1ff) + 1) - to;
1192 /* The ECC will not be calculated correctly if less than 512 is written */
1193 if (len != 0x200 && eccbuf)
1194 printf("ECC needs a full sector write (adr: %lx size %lx)\n",
1195 (long) to, (long) len);
1197 /* printf("DoC_Write (adr: %lx size %lx)\n", (long) to, (long) len); */
1199 /* Find the chip which is to be used and select it */
1200 mychip = &this->chips[shr(to, this->chipshift)];
1202 if (this->curfloor != mychip->floor) {
1203 DoC_SelectFloor(this, mychip->floor);
1204 DoC_SelectChip(this, mychip->chip);
1205 } else if (this->curchip != mychip->chip) {
1206 DoC_SelectChip(this, mychip->chip);
1209 this->curfloor = mychip->floor;
1210 this->curchip = mychip->chip;
1212 /* Set device to main plane of flash */
1213 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1216 && (to & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1219 DoC_Command(this, NAND_CMD_SEQIN, 0);
1220 DoC_Address(this, ADDR_COLUMN_PAGE, to, 0, CDSN_CTRL_ECC_IO);
1223 /* Prime the ECC engine */
1224 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1225 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
1227 /* disable the ECC engine */
1228 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1229 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1232 /* treat crossing 256-byte sector for 2M x 8bits devices */
1233 if (this->page256 && to + len > (to | 0xff) + 1) {
1234 len256 = (to | 0xff) + 1 - to;
1235 DoC_WriteBuf(this, buf, len256);
1237 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1239 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1240 /* There's an implicit DoC_WaitReady() in DoC_Command */
1242 dummy = ReadDOC(docptr, CDSNSlowIO);
1245 if (ReadDOC_(docptr, this->ioreg) & 1) {
1246 puts ("Error programming flash\n");
1247 /* Error in programming */
1252 DoC_Command(this, NAND_CMD_SEQIN, 0);
1253 DoC_Address(this, ADDR_COLUMN_PAGE, to + len256, 0,
1257 DoC_WriteBuf(this, &buf[len256], len - len256);
1260 WriteDOC(CDSN_CTRL_ECC_IO | CDSN_CTRL_CE, docptr,
1263 if (DoC_is_Millennium(this)) {
1264 WriteDOC(0, docptr, NOP);
1265 WriteDOC(0, docptr, NOP);
1266 WriteDOC(0, docptr, NOP);
1268 WriteDOC_(0, docptr, this->ioreg);
1269 WriteDOC_(0, docptr, this->ioreg);
1270 WriteDOC_(0, docptr, this->ioreg);
1273 /* Read the ECC data through the DiskOnChip ECC logic */
1274 for (di = 0; di < 6; di++) {
1275 eccbuf[di] = ReadDOC(docptr, ECCSyndrome0 + di);
1278 /* Reset the ECC engine */
1279 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1283 ("OOB data at %lx is %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1284 (long) to, eccbuf[0], eccbuf[1], eccbuf[2], eccbuf[3],
1285 eccbuf[4], eccbuf[5]);
1289 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1291 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1292 /* There's an implicit DoC_WaitReady() in DoC_Command */
1294 dummy = ReadDOC(docptr, CDSNSlowIO);
1297 if (ReadDOC_(docptr, this->ioreg) & 1) {
1298 puts ("Error programming flash\n");
1299 /* Error in programming */
1304 /* Let the caller know we completed it */
1312 /* Write the ECC data to flash */
1313 for (di=0; di<6; di++)
1319 ret = doc_write_oob(this, to, 8, &dummy, x);
1325 int doc_read_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1326 size_t * retlen, u_char * buf)
1328 int len256 = 0, ret;
1329 unsigned long docptr;
1330 struct Nand *mychip;
1332 docptr = this->virtadr;
1334 mychip = &this->chips[shr(ofs, this->chipshift)];
1336 if (this->curfloor != mychip->floor) {
1337 DoC_SelectFloor(this, mychip->floor);
1338 DoC_SelectChip(this, mychip->chip);
1339 } else if (this->curchip != mychip->chip) {
1340 DoC_SelectChip(this, mychip->chip);
1342 this->curfloor = mychip->floor;
1343 this->curchip = mychip->chip;
1345 /* update address for 2M x 8bit devices. OOB starts on the second */
1346 /* page to maintain compatibility with doc_read_ecc. */
1347 if (this->page256) {
1354 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1355 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, CDSN_CTRL_WP, 0);
1357 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1358 /* Note: datasheet says it should automaticaly wrap to the */
1359 /* next OOB block, but it didn't work here. mf. */
1360 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1361 len256 = (ofs | 0x7) + 1 - ofs;
1362 DoC_ReadBuf(this, buf, len256);
1364 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1365 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff),
1369 DoC_ReadBuf(this, &buf[len256], len - len256);
1372 /* Reading the full OOB data drops us off of the end of the page,
1373 * causing the flash device to go into busy mode, so we need
1374 * to wait until ready 11.4.1 and Toshiba TC58256FT docs */
1376 ret = DoC_WaitReady(this);
1382 int doc_write_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1383 size_t * retlen, const u_char * buf)
1386 unsigned long docptr = this->virtadr;
1387 struct Nand *mychip = &this->chips[shr(ofs, this->chipshift)];
1391 printf("doc_write_oob(%lx, %d): %2.2X %2.2X %2.2X %2.2X ... %2.2X %2.2X .. %2.2X %2.2X\n",
1392 (long)ofs, len, buf[0], buf[1], buf[2], buf[3],
1393 buf[8], buf[9], buf[14],buf[15]);
1396 /* Find the chip which is to be used and select it */
1397 if (this->curfloor != mychip->floor) {
1398 DoC_SelectFloor(this, mychip->floor);
1399 DoC_SelectChip(this, mychip->chip);
1400 } else if (this->curchip != mychip->chip) {
1401 DoC_SelectChip(this, mychip->chip);
1403 this->curfloor = mychip->floor;
1404 this->curchip = mychip->chip;
1406 /* disable the ECC engine */
1407 WriteDOC (DOC_ECC_RESET, docptr, ECCConf);
1408 WriteDOC (DOC_ECC_DIS, docptr, ECCConf);
1410 /* Reset the chip, see Software Requirement 11.4 item 1. */
1411 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1413 /* issue the Read2 command to set the pointer to the Spare Data Area. */
1414 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1416 /* update address for 2M x 8bit devices. OOB starts on the second */
1417 /* page to maintain compatibility with doc_read_ecc. */
1418 if (this->page256) {
1425 /* issue the Serial Data In command to initial the Page Program process */
1426 DoC_Command(this, NAND_CMD_SEQIN, 0);
1427 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, 0, 0);
1429 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1430 /* Note: datasheet says it should automaticaly wrap to the */
1431 /* next OOB block, but it didn't work here. mf. */
1432 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1433 len256 = (ofs | 0x7) + 1 - ofs;
1434 DoC_WriteBuf(this, buf, len256);
1436 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1437 DoC_Command(this, NAND_CMD_STATUS, 0);
1438 /* DoC_WaitReady() is implicit in DoC_Command */
1440 dummy = ReadDOC(docptr, CDSNSlowIO);
1443 if (ReadDOC_(docptr, this->ioreg) & 1) {
1444 puts ("Error programming oob data\n");
1445 /* There was an error */
1449 DoC_Command(this, NAND_CMD_SEQIN, 0);
1450 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff), 0, 0);
1453 DoC_WriteBuf(this, &buf[len256], len - len256);
1455 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1456 DoC_Command(this, NAND_CMD_STATUS, 0);
1457 /* DoC_WaitReady() is implicit in DoC_Command */
1459 dummy = ReadDOC(docptr, CDSNSlowIO);
1462 if (ReadDOC_(docptr, this->ioreg) & 1) {
1463 puts ("Error programming oob data\n");
1464 /* There was an error */
1474 int doc_erase(struct DiskOnChip* this, loff_t ofs, size_t len)
1477 unsigned long docptr;
1478 struct Nand *mychip;
1480 if (ofs & (this->erasesize-1) || len & (this->erasesize-1)) {
1481 puts ("Offset and size must be sector aligned\n");
1485 docptr = this->virtadr;
1487 /* FIXME: Do this in the background. Use timers or schedule_task() */
1489 mychip = &this->chips[shr(ofs, this->chipshift)];
1491 if (this->curfloor != mychip->floor) {
1492 DoC_SelectFloor(this, mychip->floor);
1493 DoC_SelectChip(this, mychip->chip);
1494 } else if (this->curchip != mychip->chip) {
1495 DoC_SelectChip(this, mychip->chip);
1497 this->curfloor = mychip->floor;
1498 this->curchip = mychip->chip;
1500 DoC_Command(this, NAND_CMD_ERASE1, 0);
1501 DoC_Address(this, ADDR_PAGE, ofs, 0, 0);
1502 DoC_Command(this, NAND_CMD_ERASE2, 0);
1504 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1506 dummy = ReadDOC(docptr, CDSNSlowIO);
1509 if (ReadDOC_(docptr, this->ioreg) & 1) {
1510 printf("Error erasing at 0x%lx\n", (long)ofs);
1511 /* There was an error */
1514 ofs += this->erasesize;
1515 len -= this->erasesize;
1522 static inline int doccheck(unsigned long potential, unsigned long physadr)
1524 unsigned long window=potential;
1525 unsigned char tmp, ChipID;
1526 #ifndef DOC_PASSIVE_PROBE
1530 /* Routine copied from the Linux DOC driver */
1532 #ifdef CONFIG_SYS_DOCPROBE_55AA
1533 /* Check for 0x55 0xAA signature at beginning of window,
1534 this is no longer true once we remove the IPL (for Millennium */
1535 if (ReadDOC(window, Sig1) != 0x55 || ReadDOC(window, Sig2) != 0xaa)
1537 #endif /* CONFIG_SYS_DOCPROBE_55AA */
1539 #ifndef DOC_PASSIVE_PROBE
1540 /* It's not possible to cleanly detect the DiskOnChip - the
1541 * bootup procedure will put the device into reset mode, and
1542 * it's not possible to talk to it without actually writing
1543 * to the DOCControl register. So we store the current contents
1544 * of the DOCControl register's location, in case we later decide
1545 * that it's not a DiskOnChip, and want to put it back how we
1548 tmp2 = ReadDOC(window, DOCControl);
1550 /* Reset the DiskOnChip ASIC */
1551 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1552 window, DOCControl);
1553 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1554 window, DOCControl);
1556 /* Enable the DiskOnChip ASIC */
1557 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1558 window, DOCControl);
1559 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1560 window, DOCControl);
1561 #endif /* !DOC_PASSIVE_PROBE */
1563 ChipID = ReadDOC(window, ChipID);
1566 case DOC_ChipID_Doc2k:
1567 /* Check the TOGGLE bit in the ECC register */
1568 tmp = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
1569 if ((ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT) != tmp)
1573 case DOC_ChipID_DocMil:
1574 /* Check the TOGGLE bit in the ECC register */
1575 tmp = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
1576 if ((ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT) != tmp)
1581 #ifndef CONFIG_SYS_DOCPROBE_55AA
1583 * if the ID isn't the DoC2000 or DoCMillenium ID, so we can assume
1584 * the DOC is missing
1587 printf("Possible DiskOnChip with unknown ChipID %2.2X found at 0x%lx\n",
1591 #ifndef DOC_PASSIVE_PROBE
1592 /* Put back the contents of the DOCControl register, in case it's not
1593 * actually a DiskOnChip.
1595 WriteDOC(tmp2, window, DOCControl);
1600 puts ("DiskOnChip failed TOGGLE test, dropping.\n");
1602 #ifndef DOC_PASSIVE_PROBE
1603 /* Put back the contents of the DOCControl register: it's not a DiskOnChip */
1604 WriteDOC(tmp2, window, DOCControl);
1609 void doc_probe(unsigned long physadr)
1611 struct DiskOnChip *this = NULL;
1614 if ((ChipID = doccheck(physadr, physadr))) {
1616 for (i=0; i<CONFIG_SYS_MAX_DOC_DEVICE; i++) {
1617 if (doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN) {
1618 this = doc_dev_desc + i;
1624 puts ("Cannot allocate memory for data structures.\n");
1628 if (curr_device == -1)
1631 memset((char *)this, 0, sizeof(struct DiskOnChip));
1633 this->virtadr = physadr;
1634 this->physadr = physadr;
1635 this->ChipID = ChipID;
1639 puts ("No DiskOnChip found\n");
1643 void doc_probe(unsigned long physadr) {}