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>
18 #ifdef CFG_DOC_SUPPORT_2000
19 #define DoC_is_2000(doc) (doc->ChipID == DOC_ChipID_Doc2k)
21 #define DoC_is_2000(doc) (0)
24 #ifdef CFG_DOC_SUPPORT_MILLENNIUM
25 #define DoC_is_Millennium(doc) (doc->ChipID == DOC_ChipID_DocMil)
27 #define DoC_is_Millennium(doc) (0)
30 /* CFG_DOC_PASSIVE_PROBE:
31 In order to ensure that the BIOS checksum is correct at boot time, and
32 hence that the onboard BIOS extension gets executed, the DiskOnChip
33 goes into reset mode when it is read sequentially: all registers
34 return 0xff until the chip is woken up again by writing to the
37 Unfortunately, this means that the probe for the DiskOnChip is unsafe,
38 because one of the first things it does is write to where it thinks
39 the DOCControl register should be - which may well be shared memory
40 for another device. I've had machines which lock up when this is
41 attempted. Hence the possibility to do a passive probe, which will fail
42 to detect a chip in reset mode, but is at least guaranteed not to lock
45 If you have this problem, uncomment the following line:
46 #define CFG_DOC_PASSIVE_PROBE
54 static struct DiskOnChip doc_dev_desc[CFG_MAX_DOC_DEVICE];
56 /* Current DOC Device */
57 static int curr_device = -1;
59 /* Supported NAND flash devices */
60 static struct nand_flash_dev nand_flash_ids[] = {
61 {"Toshiba TC5816BDC", NAND_MFR_TOSHIBA, 0x64, 21, 1, 2, 0x1000, 0},
62 {"Toshiba TC5832DC", NAND_MFR_TOSHIBA, 0x6b, 22, 0, 2, 0x2000, 0},
63 {"Toshiba TH58V128DC", NAND_MFR_TOSHIBA, 0x73, 24, 0, 2, 0x4000, 0},
64 {"Toshiba TC58256FT/DC", NAND_MFR_TOSHIBA, 0x75, 25, 0, 2, 0x4000, 0},
65 {"Toshiba TH58512FT", NAND_MFR_TOSHIBA, 0x76, 26, 0, 3, 0x4000, 0},
66 {"Toshiba TC58V32DC", NAND_MFR_TOSHIBA, 0xe5, 22, 0, 2, 0x2000, 0},
67 {"Toshiba TC58V64AFT/DC", NAND_MFR_TOSHIBA, 0xe6, 23, 0, 2, 0x2000, 0},
68 {"Toshiba TC58V16BDC", NAND_MFR_TOSHIBA, 0xea, 21, 1, 2, 0x1000, 0},
69 {"Toshiba TH58100FT", NAND_MFR_TOSHIBA, 0x79, 27, 0, 3, 0x4000, 0},
70 {"Samsung KM29N16000", NAND_MFR_SAMSUNG, 0x64, 21, 1, 2, 0x1000, 0},
71 {"Samsung unknown 4Mb", NAND_MFR_SAMSUNG, 0x6b, 22, 0, 2, 0x2000, 0},
72 {"Samsung KM29U128T", NAND_MFR_SAMSUNG, 0x73, 24, 0, 2, 0x4000, 0},
73 {"Samsung KM29U256T", NAND_MFR_SAMSUNG, 0x75, 25, 0, 2, 0x4000, 0},
74 {"Samsung unknown 64Mb", NAND_MFR_SAMSUNG, 0x76, 26, 0, 3, 0x4000, 0},
75 {"Samsung KM29W32000", NAND_MFR_SAMSUNG, 0xe3, 22, 0, 2, 0x2000, 0},
76 {"Samsung unknown 4Mb", NAND_MFR_SAMSUNG, 0xe5, 22, 0, 2, 0x2000, 0},
77 {"Samsung KM29U64000", NAND_MFR_SAMSUNG, 0xe6, 23, 0, 2, 0x2000, 0},
78 {"Samsung KM29W16000", NAND_MFR_SAMSUNG, 0xea, 21, 1, 2, 0x1000, 0},
79 {"Samsung K9F5616Q0C", NAND_MFR_SAMSUNG, 0x45, 25, 0, 2, 0x4000, 1},
80 {"Samsung K9K1216Q0C", NAND_MFR_SAMSUNG, 0x46, 26, 0, 3, 0x4000, 1},
81 {"Samsung K9F1G08U0M", NAND_MFR_SAMSUNG, 0xf1, 27, 0, 2, 0, 0},
85 /* ------------------------------------------------------------------------- */
87 int do_doc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
94 printf ("Usage:\n%s\n", cmdtp->usage);
97 if (strcmp(argv[1],"info") == 0) {
102 for (i=0; i<CFG_MAX_DOC_DEVICE; ++i) {
103 if(doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN)
104 continue; /* list only known devices */
105 printf ("Device %d: ", i);
106 doc_print(&doc_dev_desc[i]);
110 } else if (strcmp(argv[1],"device") == 0) {
111 if ((curr_device < 0) || (curr_device >= CFG_MAX_DOC_DEVICE)) {
112 puts ("\nno devices available\n");
115 printf ("\nDevice %d: ", curr_device);
116 doc_print(&doc_dev_desc[curr_device]);
119 printf ("Usage:\n%s\n", cmdtp->usage);
122 if (strcmp(argv[1],"device") == 0) {
123 int dev = (int)simple_strtoul(argv[2], NULL, 10);
125 printf ("\nDevice %d: ", dev);
126 if (dev >= CFG_MAX_DOC_DEVICE) {
127 puts ("unknown device\n");
130 doc_print(&doc_dev_desc[dev]);
133 if (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN) {
139 puts ("... is now current device\n");
144 printf ("Usage:\n%s\n", cmdtp->usage);
147 /* at least 4 args */
149 if (strcmp(argv[1],"read") == 0 || strcmp(argv[1],"write") == 0) {
150 ulong addr = simple_strtoul(argv[2], NULL, 16);
151 ulong off = simple_strtoul(argv[3], NULL, 16);
152 ulong size = simple_strtoul(argv[4], NULL, 16);
153 int cmd = (strcmp(argv[1],"read") == 0);
156 printf ("\nDOC %s: device %d offset %ld, size %ld ... ",
157 cmd ? "read" : "write", curr_device, off, size);
159 ret = doc_rw(doc_dev_desc + curr_device, cmd, off, size,
160 (size_t *)&total, (u_char*)addr);
162 printf ("%d bytes %s: %s\n", total, cmd ? "read" : "write",
163 ret ? "ERROR" : "OK");
166 } else if (strcmp(argv[1],"erase") == 0) {
167 ulong off = simple_strtoul(argv[2], NULL, 16);
168 ulong size = simple_strtoul(argv[3], NULL, 16);
171 printf ("\nDOC erase: device %d offset %ld, size %ld ... ",
172 curr_device, off, size);
174 ret = doc_erase (doc_dev_desc + curr_device, off, size);
176 printf("%s\n", ret ? "ERROR" : "OK");
180 printf ("Usage:\n%s\n", cmdtp->usage);
189 "doc - Disk-On-Chip sub-system\n",
190 "info - show available DOC devices\n"
191 "doc device [dev] - show or set current device\n"
192 "doc read addr off size\n"
193 "doc write addr off size - read/write `size'"
194 " bytes starting at offset `off'\n"
195 " to/from memory address `addr'\n"
196 "doc erase off size - erase `size' bytes of DOC from offset `off'\n"
199 int do_docboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
201 char *boot_device = NULL;
209 #if defined(CONFIG_FIT)
210 const void *fit_hdr = NULL;
213 show_boot_progress (34);
216 addr = CFG_LOAD_ADDR;
217 boot_device = getenv ("bootdevice");
220 addr = simple_strtoul(argv[1], NULL, 16);
221 boot_device = getenv ("bootdevice");
224 addr = simple_strtoul(argv[1], NULL, 16);
225 boot_device = argv[2];
228 addr = simple_strtoul(argv[1], NULL, 16);
229 boot_device = argv[2];
230 offset = simple_strtoul(argv[3], NULL, 16);
233 printf ("Usage:\n%s\n", cmdtp->usage);
234 show_boot_progress (-35);
238 show_boot_progress (35);
240 puts ("\n** No boot device **\n");
241 show_boot_progress (-36);
244 show_boot_progress (36);
246 dev = simple_strtoul(boot_device, &ep, 16);
248 if ((dev >= CFG_MAX_DOC_DEVICE) ||
249 (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN)) {
250 printf ("\n** Device %d not available\n", dev);
251 show_boot_progress (-37);
254 show_boot_progress (37);
256 printf ("\nLoading from device %d: %s at 0x%lX (offset 0x%lX)\n",
257 dev, doc_dev_desc[dev].name, doc_dev_desc[dev].physadr,
260 if (doc_rw (doc_dev_desc + dev, 1, offset,
261 SECTORSIZE, NULL, (u_char *)addr)) {
262 printf ("** Read error on %d\n", dev);
263 show_boot_progress (-38);
266 show_boot_progress (38);
268 switch (genimg_get_format ((void *)addr)) {
269 case IMAGE_FORMAT_LEGACY:
270 hdr = (image_header_t *)addr;
272 image_print_contents (hdr);
274 cnt = image_get_image_size (hdr);
276 #if defined(CONFIG_FIT)
277 case IMAGE_FORMAT_FIT:
278 fit_hdr = (const void *)addr;
279 puts ("Fit image detected...\n");
281 cnt = fit_get_size (fit_hdr);
285 show_boot_progress (-39);
286 puts ("** Unknown image type\n");
289 show_boot_progress (39);
292 if (doc_rw (doc_dev_desc + dev, 1, offset + SECTORSIZE, cnt,
293 NULL, (u_char *)(addr+SECTORSIZE))) {
294 printf ("** Read error on %d\n", dev);
295 show_boot_progress (-40);
298 show_boot_progress (40);
300 #if defined(CONFIG_FIT)
301 /* This cannot be done earlier, we need complete FIT image in RAM first */
302 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
303 if (!fit_check_format (fit_hdr)) {
304 show_boot_progress (-130);
305 puts ("** Bad FIT image format\n");
308 show_boot_progress (131);
309 fit_print_contents (fit_hdr);
313 /* Loading ok, update default load address */
317 /* Check if we should attempt an auto-start */
318 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
320 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
322 local_args[0] = argv[0];
323 local_args[1] = NULL;
325 printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
327 do_bootm (cmdtp, 0, 1, local_args);
334 docboot, 4, 1, do_docboot,
335 "docboot - boot from DOC device\n",
339 int doc_rw (struct DiskOnChip* this, int cmd,
340 loff_t from, size_t len,
341 size_t * retlen, u_char * buf)
343 int noecc, ret = 0, n, total = 0;
347 /* The ECC will not be calculated correctly if
348 less than 512 is written or read */
349 noecc = (from != (from | 0x1ff) + 1) || (len < 0x200);
352 ret = doc_read_ecc(this, from, len,
353 (size_t *)&n, (u_char*)buf,
354 noecc ? (uchar *)NULL : (uchar *)eccbuf);
356 ret = doc_write_ecc(this, from, len,
357 (size_t *)&n, (u_char*)buf,
358 noecc ? (uchar *)NULL : (uchar *)eccbuf);
375 void doc_print(struct DiskOnChip *this) {
376 printf("%s at 0x%lX,\n"
377 "\t %d chip%s %s, size %d MB, \n"
378 "\t total size %ld MB, sector size %ld kB\n",
379 this->name, this->physadr, this->numchips,
380 this->numchips>1 ? "s" : "", this->chips_name,
381 1 << (this->chipshift - 20),
382 this->totlen >> 20, this->erasesize >> 10);
384 if (this->nftl_found) {
385 struct NFTLrecord *nftl = &this->nftl;
386 unsigned long bin_size, flash_size;
388 bin_size = nftl->nb_boot_blocks * this->erasesize;
389 flash_size = (nftl->nb_blocks - nftl->nb_boot_blocks) * this->erasesize;
391 printf("\t NFTL boot record:\n"
392 "\t Binary partition: size %ld%s\n"
393 "\t Flash disk partition: size %ld%s, offset 0x%lx\n",
394 bin_size > (1 << 20) ? bin_size >> 20 : bin_size >> 10,
395 bin_size > (1 << 20) ? "MB" : "kB",
396 flash_size > (1 << 20) ? flash_size >> 20 : flash_size >> 10,
397 flash_size > (1 << 20) ? "MB" : "kB", bin_size);
399 puts ("\t No NFTL boot record found.\n");
403 /* ------------------------------------------------------------------------- */
405 /* This function is needed to avoid calls of the __ashrdi3 function. */
406 static int shr(int val, int shift) {
410 /* Perform the required delay cycles by reading from the appropriate register */
411 static void DoC_Delay(struct DiskOnChip *doc, unsigned short cycles)
416 for (i = 0; i < cycles; i++) {
417 if (DoC_is_Millennium(doc))
418 dummy = ReadDOC(doc->virtadr, NOP);
420 dummy = ReadDOC(doc->virtadr, DOCStatus);
425 /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
426 static int _DoC_WaitReady(struct DiskOnChip *doc)
428 unsigned long docptr = doc->virtadr;
429 unsigned long start = get_timer(0);
432 puts ("_DoC_WaitReady called for out-of-line wait\n");
435 /* Out-of-line routine to wait for chip response */
436 while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
437 #ifdef CFG_DOC_SHORT_TIMEOUT
438 /* it seems that after a certain time the DoC deasserts
439 * the CDSN_CTRL_FR_B although it is not ready...
440 * using a short timout solve this (timer increments every ms) */
441 if (get_timer(start) > 10) {
445 if (get_timer(start) > 10 * 1000) {
446 puts ("_DoC_WaitReady timed out.\n");
456 static int DoC_WaitReady(struct DiskOnChip *doc)
458 unsigned long docptr = doc->virtadr;
459 /* This is inline, to optimise the common case, where it's ready instantly */
462 /* 4 read form NOP register should be issued in prior to the read from CDSNControl
463 see Software Requirement 11.4 item 2. */
466 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
467 /* Call the out-of-line routine to wait */
468 ret = _DoC_WaitReady(doc);
470 /* issue 2 read from NOP register after reading from CDSNControl register
471 see Software Requirement 11.4 item 2. */
477 /* DoC_Command: Send a flash command to the flash chip through the CDSN Slow IO register to
478 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
479 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
481 static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,
482 unsigned char xtraflags)
484 unsigned long docptr = doc->virtadr;
486 if (DoC_is_2000(doc))
487 xtraflags |= CDSN_CTRL_FLASH_IO;
489 /* Assert the CLE (Command Latch Enable) line to the flash chip */
490 WriteDOC(xtraflags | CDSN_CTRL_CLE | CDSN_CTRL_CE, docptr, CDSNControl);
491 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
493 if (DoC_is_Millennium(doc))
494 WriteDOC(command, docptr, CDSNSlowIO);
496 /* Send the command */
497 WriteDOC_(command, docptr, doc->ioreg);
499 /* Lower the CLE line */
500 WriteDOC(xtraflags | CDSN_CTRL_CE, docptr, CDSNControl);
501 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
503 /* Wait for the chip to respond - Software requirement 11.4.1 (extended for any command) */
504 return DoC_WaitReady(doc);
507 /* DoC_Address: Set the current address for the flash chip through the CDSN Slow IO register to
508 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
509 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
511 static int DoC_Address(struct DiskOnChip *doc, int numbytes, unsigned long ofs,
512 unsigned char xtraflags1, unsigned char xtraflags2)
514 unsigned long docptr;
517 docptr = doc->virtadr;
519 if (DoC_is_2000(doc))
520 xtraflags1 |= CDSN_CTRL_FLASH_IO;
522 /* Assert the ALE (Address Latch Enable) line to the flash chip */
523 WriteDOC(xtraflags1 | CDSN_CTRL_ALE | CDSN_CTRL_CE, docptr, CDSNControl);
525 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
527 /* Send the address */
528 /* Devices with 256-byte page are addressed as:
529 Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
530 * there is no device on the market with page256
531 and more than 24 bits.
532 Devices with 512-byte page are addressed as:
533 Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
534 * 25-31 is sent only if the chip support it.
535 * bit 8 changes the read command to be sent
536 (NAND_CMD_READ0 or NAND_CMD_READ1).
539 if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE) {
540 if (DoC_is_Millennium(doc))
541 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
542 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
551 if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE) {
552 for (i = 0; i < doc->pageadrlen; i++, ofs = ofs >> 8) {
553 if (DoC_is_Millennium(doc))
554 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
555 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
559 DoC_Delay(doc, 2); /* Needed for some slow flash chips. mf. */
561 /* FIXME: The SlowIO's for millennium could be replaced by
562 a single WritePipeTerm here. mf. */
564 /* Lower the ALE line */
565 WriteDOC(xtraflags1 | xtraflags2 | CDSN_CTRL_CE, docptr,
568 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
570 /* Wait for the chip to respond - Software requirement 11.4.1 */
571 return DoC_WaitReady(doc);
574 /* Read a buffer from DoC, taking care of Millennium oddities */
575 static void DoC_ReadBuf(struct DiskOnChip *doc, u_char * buf, int len)
578 int modulus = 0xffff;
579 unsigned long docptr;
582 docptr = doc->virtadr;
587 if (DoC_is_Millennium(doc)) {
588 /* Read the data via the internal pipeline through CDSN IO register,
589 see Pipelined Read Operations 11.3 */
590 dummy = ReadDOC(docptr, ReadPipeInit);
592 /* Millennium should use the LastDataRead register - Pipeline Reads */
595 /* This is needed for correctly ECC calculation */
599 for (i = 0; i < len; i++)
600 buf[i] = ReadDOC_(docptr, doc->ioreg + (i & modulus));
602 if (DoC_is_Millennium(doc)) {
603 buf[i] = ReadDOC(docptr, LastDataRead);
607 /* Write a buffer to DoC, taking care of Millennium oddities */
608 static void DoC_WriteBuf(struct DiskOnChip *doc, const u_char * buf, int len)
610 unsigned long docptr;
613 docptr = doc->virtadr;
618 for (i = 0; i < len; i++)
619 WriteDOC_(buf[i], docptr, doc->ioreg + i);
621 if (DoC_is_Millennium(doc)) {
622 WriteDOC(0x00, docptr, WritePipeTerm);
627 /* DoC_SelectChip: Select a given flash chip within the current floor */
629 static inline int DoC_SelectChip(struct DiskOnChip *doc, int chip)
631 unsigned long docptr = doc->virtadr;
633 /* Software requirement 11.4.4 before writing DeviceSelect */
634 /* Deassert the CE line to eliminate glitches on the FCE# outputs */
635 WriteDOC(CDSN_CTRL_WP, docptr, CDSNControl);
636 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
638 /* Select the individual flash chip requested */
639 WriteDOC(chip, docptr, CDSNDeviceSelect);
642 /* Reassert the CE line */
643 WriteDOC(CDSN_CTRL_CE | CDSN_CTRL_FLASH_IO | CDSN_CTRL_WP, docptr,
645 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
647 /* Wait for it to be ready */
648 return DoC_WaitReady(doc);
651 /* DoC_SelectFloor: Select a given floor (bank of flash chips) */
653 static inline int DoC_SelectFloor(struct DiskOnChip *doc, int floor)
655 unsigned long docptr = doc->virtadr;
657 /* Select the floor (bank) of chips required */
658 WriteDOC(floor, docptr, FloorSelect);
660 /* Wait for the chip to be ready */
661 return DoC_WaitReady(doc);
664 /* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */
666 static int DoC_IdentChip(struct DiskOnChip *doc, int floor, int chip)
671 /* Page in the required floor/chip */
672 DoC_SelectFloor(doc, floor);
673 DoC_SelectChip(doc, chip);
676 if (DoC_Command(doc, NAND_CMD_RESET, CDSN_CTRL_WP)) {
678 printf("DoC_Command (reset) for %d,%d returned true\n",
685 /* Read the NAND chip ID: 1. Send ReadID command */
686 if (DoC_Command(doc, NAND_CMD_READID, CDSN_CTRL_WP)) {
688 printf("DoC_Command (ReadID) for %d,%d returned true\n",
694 /* Read the NAND chip ID: 2. Send address byte zero */
695 DoC_Address(doc, ADDR_COLUMN, 0, CDSN_CTRL_WP, 0);
697 /* Read the manufacturer and device id codes from the device */
699 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
700 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
702 mfr = ReadDOC_(doc->virtadr, doc->ioreg);
704 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
705 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
707 id = ReadDOC_(doc->virtadr, doc->ioreg);
709 /* No response - return failure */
710 if (mfr == 0xff || mfr == 0)
713 /* Check it's the same as the first chip we identified.
714 * M-Systems say that any given DiskOnChip device should only
715 * contain _one_ type of flash part, although that's not a
716 * hardware restriction. */
718 if (doc->mfr == mfr && doc->id == id)
719 return 1; /* This is another the same the first */
721 printf("Flash chip at floor %d, chip %d is different:\n",
725 /* Print and store the manufacturer and ID codes. */
726 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
727 if (mfr == nand_flash_ids[i].manufacture_id &&
728 id == nand_flash_ids[i].model_id) {
730 printf("Flash chip found: Manufacturer ID: %2.2X, "
731 "Chip ID: %2.2X (%s)\n", mfr, id,
732 nand_flash_ids[i].name);
738 nand_flash_ids[i].chipshift;
739 doc->page256 = nand_flash_ids[i].page256;
741 nand_flash_ids[i].pageadrlen;
743 nand_flash_ids[i].erasesize;
745 nand_flash_ids[i].name;
754 /* We haven't fully identified the chip. Print as much as we know. */
755 printf("Unknown flash chip found: %2.2X %2.2X\n",
762 /* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */
764 static void DoC_ScanChips(struct DiskOnChip *this)
767 int numchips[MAX_FLOORS];
768 int maxchips = MAX_CHIPS;
775 if (DoC_is_Millennium(this))
776 maxchips = MAX_CHIPS_MIL;
778 /* For each floor, find the number of valid chips it contains */
779 for (floor = 0; floor < MAX_FLOORS; floor++) {
782 for (chip = 0; chip < maxchips && ret != 0; chip++) {
784 ret = DoC_IdentChip(this, floor, chip);
792 /* If there are none at all that we recognise, bail */
793 if (!this->numchips) {
794 puts ("No flash chips recognised.\n");
798 /* Allocate an array to hold the information for each chip */
799 this->chips = malloc(sizeof(struct Nand) * this->numchips);
801 puts ("No memory for allocating chip info structures\n");
807 /* Fill out the chip array with {floor, chipno} for each
808 * detected chip in the device. */
809 for (floor = 0; floor < MAX_FLOORS; floor++) {
810 for (chip = 0; chip < numchips[floor]; chip++) {
811 this->chips[ret].floor = floor;
812 this->chips[ret].chip = chip;
813 this->chips[ret].curadr = 0;
814 this->chips[ret].curmode = 0x50;
819 /* Calculate and print the total size of the device */
820 this->totlen = this->numchips * (1 << this->chipshift);
823 printf("%d flash chips found. Total DiskOnChip size: %ld MB\n",
824 this->numchips, this->totlen >> 20);
828 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
829 * various device information of the NFTL partition and Bad Unit Table. Update
830 * the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
831 * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
833 static int find_boot_record(struct NFTLrecord *nftl)
837 unsigned int block, boot_record_count = 0;
840 struct NFTLMediaHeader *mh = &nftl->MediaHdr;
843 nftl->MediaUnit = BLOCK_NIL;
844 nftl->SpareMediaUnit = BLOCK_NIL;
846 /* search for a valid boot record */
847 for (block = 0; block < nftl->nb_blocks; block++) {
850 /* Check for ANAND header first. Then can whinge if it's found but later
852 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize, SECTORSIZE,
853 (size_t *)&retlen, buf, NULL))) {
854 static int warncount = 5;
857 printf("Block read at 0x%x failed\n", block * nftl->EraseSize);
859 puts ("Further failures for this block will not be printed\n");
864 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
865 /* ANAND\0 not found. Continue */
867 printf("ANAND header not found at 0x%x\n", block * nftl->EraseSize);
873 printf("ANAND header found at 0x%x\n", block * nftl->EraseSize);
876 /* To be safer with BIOS, also use erase mark as discriminant */
877 if ((ret = doc_read_oob(nftl->mtd, block * nftl->EraseSize + SECTORSIZE + 8,
878 8, (size_t *)&retlen, (uchar *)&h1) < 0)) {
880 printf("ANAND header found at 0x%x, but OOB data read failed\n",
881 block * nftl->EraseSize);
886 /* OK, we like it. */
888 if (boot_record_count) {
889 /* We've already processed one. So we just check if
890 this one is the same as the first one we found */
891 if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
893 printf("NFTL Media Headers at 0x%x and 0x%x disagree.\n",
894 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
896 /* if (debug) Print both side by side */
899 if (boot_record_count == 1)
900 nftl->SpareMediaUnit = block;
906 /* This is the first we've seen. Copy the media header structure into place */
907 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
909 /* Do some sanity checks on it */
910 if (mh->UnitSizeFactor == 0) {
912 puts ("UnitSizeFactor 0x00 detected.\n"
913 "This violates the spec but we think we know what it means...\n");
915 } else if (mh->UnitSizeFactor != 0xff) {
916 printf ("Sorry, we don't support UnitSizeFactor "
921 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
922 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
923 printf ("NFTL Media Header sanity check failed:\n"
924 "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
925 nftl->nb_boot_blocks, nftl->nb_blocks);
929 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
930 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
931 printf ("NFTL Media Header sanity check failed:\n"
932 "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
935 nftl->nb_boot_blocks);
939 nftl->nr_sects = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
941 /* If we're not using the last sectors in the device for some reason,
942 reduce nb_blocks accordingly so we forget they're there */
943 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
945 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
946 for (i = 0; i < nftl->nb_blocks; i++) {
947 if ((i & (SECTORSIZE - 1)) == 0) {
948 /* read one sector for every SECTORSIZE of blocks */
949 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize +
950 i + SECTORSIZE, SECTORSIZE,
951 (size_t *)&retlen, buf, (uchar *)&oob)) < 0) {
952 puts ("Read of bad sector table failed\n");
956 /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
957 if (buf[i & (SECTORSIZE - 1)] != 0xff)
958 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
961 nftl->MediaUnit = block;
964 } /* foreach (block) */
966 return boot_record_count?0:-1;
969 /* This routine is made available to other mtd code via
970 * inter_module_register. It must only be accessed through
971 * inter_module_get which will bump the use count of this module. The
972 * addresses passed back in mtd are valid as long as the use count of
973 * this module is non-zero, i.e. between inter_module_get and
974 * inter_module_put. Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
976 static void DoC2k_init(struct DiskOnChip* this)
978 struct NFTLrecord *nftl;
980 switch (this->ChipID) {
981 case DOC_ChipID_Doc2k:
982 this->name = "DiskOnChip 2000";
983 this->ioreg = DoC_2k_CDSN_IO;
985 case DOC_ChipID_DocMil:
986 this->name = "DiskOnChip Millennium";
987 this->ioreg = DoC_Mil_CDSN_IO;
992 printf("%s found at address 0x%lX\n", this->name,
1002 /* Ident all the chips present. */
1003 DoC_ScanChips(this);
1004 if ((!this->numchips) || (!this->chips))
1009 /* Get physical parameters */
1010 nftl->EraseSize = this->erasesize;
1011 nftl->nb_blocks = this->totlen / this->erasesize;
1014 if (find_boot_record(nftl) != 0)
1015 this->nftl_found = 0;
1017 this->nftl_found = 1;
1019 printf("%s @ 0x%lX, %ld MB\n", this->name, this->physadr, this->totlen >> 20);
1022 int doc_read_ecc(struct DiskOnChip* this, loff_t from, size_t len,
1023 size_t * retlen, u_char * buf, u_char * eccbuf)
1025 unsigned long docptr;
1026 struct Nand *mychip;
1027 unsigned char syndrome[6];
1028 volatile char dummy;
1029 int i, len256 = 0, ret=0;
1031 docptr = this->virtadr;
1033 /* Don't allow read past end of device */
1034 if (from >= this->totlen) {
1035 puts ("Out of flash\n");
1039 /* Don't allow a single read to cross a 512-byte block boundary */
1040 if (from + len > ((from | 0x1ff) + 1))
1041 len = ((from | 0x1ff) + 1) - from;
1043 /* The ECC will not be calculated correctly if less than 512 is read */
1044 if (len != 0x200 && eccbuf)
1045 printf("ECC needs a full sector read (adr: %lx size %lx)\n",
1046 (long) from, (long) len);
1049 printf("DoC_Read (adr: %lx size %lx)\n", (long) from, (long) len);
1052 /* Find the chip which is to be used and select it */
1053 mychip = &this->chips[shr(from, this->chipshift)];
1055 if (this->curfloor != mychip->floor) {
1056 DoC_SelectFloor(this, mychip->floor);
1057 DoC_SelectChip(this, mychip->chip);
1058 } else if (this->curchip != mychip->chip) {
1059 DoC_SelectChip(this, mychip->chip);
1062 this->curfloor = mychip->floor;
1063 this->curchip = mychip->chip;
1067 && (from & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1069 DoC_Address(this, ADDR_COLUMN_PAGE, from, CDSN_CTRL_WP,
1073 /* Prime the ECC engine */
1074 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1075 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
1077 /* disable the ECC engine */
1078 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1079 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1082 /* treat crossing 256-byte sector for 2M x 8bits devices */
1083 if (this->page256 && from + len > (from | 0xff) + 1) {
1084 len256 = (from | 0xff) + 1 - from;
1085 DoC_ReadBuf(this, buf, len256);
1087 DoC_Command(this, NAND_CMD_READ0, CDSN_CTRL_WP);
1088 DoC_Address(this, ADDR_COLUMN_PAGE, from + len256,
1089 CDSN_CTRL_WP, CDSN_CTRL_ECC_IO);
1092 DoC_ReadBuf(this, &buf[len256], len - len256);
1094 /* Let the caller know we completed it */
1098 /* Read the ECC data through the DiskOnChip ECC logic */
1099 /* Note: this will work even with 2M x 8bit devices as */
1100 /* they have 8 bytes of OOB per 256 page. mf. */
1101 DoC_ReadBuf(this, eccbuf, 6);
1103 /* Flush the pipeline */
1104 if (DoC_is_Millennium(this)) {
1105 dummy = ReadDOC(docptr, ECCConf);
1106 dummy = ReadDOC(docptr, ECCConf);
1107 i = ReadDOC(docptr, ECCConf);
1109 dummy = ReadDOC(docptr, 2k_ECCStatus);
1110 dummy = ReadDOC(docptr, 2k_ECCStatus);
1111 i = ReadDOC(docptr, 2k_ECCStatus);
1114 /* Check the ECC Status */
1117 /* There was an ECC error */
1119 printf("DiskOnChip ECC Error: Read at %lx\n", (long)from);
1121 /* Read the ECC syndrom through the DiskOnChip ECC logic.
1122 These syndrome will be all ZERO when there is no error */
1123 for (i = 0; i < 6; i++) {
1125 ReadDOC(docptr, ECCSyndrome0 + i);
1127 nb_errors = doc_decode_ecc(buf, syndrome);
1130 printf("Errors corrected: %x\n", nb_errors);
1132 if (nb_errors < 0) {
1133 /* We return error, but have actually done the read. Not that
1134 this can be told to user-space, via sys_read(), but at least
1135 MTD-aware stuff can know about it by checking *retlen */
1136 printf("ECC Errors at %lx\n", (long)from);
1142 printf("ECC DATA at %lxB: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1143 (long)from, eccbuf[0], eccbuf[1], eccbuf[2],
1144 eccbuf[3], eccbuf[4], eccbuf[5]);
1147 /* disable the ECC engine */
1148 WriteDOC(DOC_ECC_DIS, docptr , ECCConf);
1151 /* according to 11.4.1, we need to wait for the busy line
1152 * drop if we read to the end of the page. */
1153 if(0 == ((from + *retlen) & 0x1ff))
1155 DoC_WaitReady(this);
1161 int doc_write_ecc(struct DiskOnChip* this, loff_t to, size_t len,
1162 size_t * retlen, const u_char * buf,
1165 int di; /* Yes, DI is a hangover from when I was disassembling the binary driver */
1166 unsigned long docptr;
1167 volatile char dummy;
1169 struct Nand *mychip;
1171 docptr = this->virtadr;
1173 /* Don't allow write past end of device */
1174 if (to >= this->totlen) {
1175 puts ("Out of flash\n");
1179 /* Don't allow a single write to cross a 512-byte block boundary */
1180 if (to + len > ((to | 0x1ff) + 1))
1181 len = ((to | 0x1ff) + 1) - to;
1183 /* The ECC will not be calculated correctly if less than 512 is written */
1184 if (len != 0x200 && eccbuf)
1185 printf("ECC needs a full sector write (adr: %lx size %lx)\n",
1186 (long) to, (long) len);
1188 /* printf("DoC_Write (adr: %lx size %lx)\n", (long) to, (long) len); */
1190 /* Find the chip which is to be used and select it */
1191 mychip = &this->chips[shr(to, this->chipshift)];
1193 if (this->curfloor != mychip->floor) {
1194 DoC_SelectFloor(this, mychip->floor);
1195 DoC_SelectChip(this, mychip->chip);
1196 } else if (this->curchip != mychip->chip) {
1197 DoC_SelectChip(this, mychip->chip);
1200 this->curfloor = mychip->floor;
1201 this->curchip = mychip->chip;
1203 /* Set device to main plane of flash */
1204 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1207 && (to & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1210 DoC_Command(this, NAND_CMD_SEQIN, 0);
1211 DoC_Address(this, ADDR_COLUMN_PAGE, to, 0, CDSN_CTRL_ECC_IO);
1214 /* Prime the ECC engine */
1215 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1216 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
1218 /* disable the ECC engine */
1219 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1220 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1223 /* treat crossing 256-byte sector for 2M x 8bits devices */
1224 if (this->page256 && to + len > (to | 0xff) + 1) {
1225 len256 = (to | 0xff) + 1 - to;
1226 DoC_WriteBuf(this, buf, len256);
1228 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1230 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1231 /* There's an implicit DoC_WaitReady() in DoC_Command */
1233 dummy = ReadDOC(docptr, CDSNSlowIO);
1236 if (ReadDOC_(docptr, this->ioreg) & 1) {
1237 puts ("Error programming flash\n");
1238 /* Error in programming */
1243 DoC_Command(this, NAND_CMD_SEQIN, 0);
1244 DoC_Address(this, ADDR_COLUMN_PAGE, to + len256, 0,
1248 DoC_WriteBuf(this, &buf[len256], len - len256);
1251 WriteDOC(CDSN_CTRL_ECC_IO | CDSN_CTRL_CE, docptr,
1254 if (DoC_is_Millennium(this)) {
1255 WriteDOC(0, docptr, NOP);
1256 WriteDOC(0, docptr, NOP);
1257 WriteDOC(0, docptr, NOP);
1259 WriteDOC_(0, docptr, this->ioreg);
1260 WriteDOC_(0, docptr, this->ioreg);
1261 WriteDOC_(0, docptr, this->ioreg);
1264 /* Read the ECC data through the DiskOnChip ECC logic */
1265 for (di = 0; di < 6; di++) {
1266 eccbuf[di] = ReadDOC(docptr, ECCSyndrome0 + di);
1269 /* Reset the ECC engine */
1270 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1274 ("OOB data at %lx is %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1275 (long) to, eccbuf[0], eccbuf[1], eccbuf[2], eccbuf[3],
1276 eccbuf[4], eccbuf[5]);
1280 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1282 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1283 /* There's an implicit DoC_WaitReady() in DoC_Command */
1285 dummy = ReadDOC(docptr, CDSNSlowIO);
1288 if (ReadDOC_(docptr, this->ioreg) & 1) {
1289 puts ("Error programming flash\n");
1290 /* Error in programming */
1295 /* Let the caller know we completed it */
1303 /* Write the ECC data to flash */
1304 for (di=0; di<6; di++)
1310 ret = doc_write_oob(this, to, 8, &dummy, x);
1316 int doc_read_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1317 size_t * retlen, u_char * buf)
1319 int len256 = 0, ret;
1320 unsigned long docptr;
1321 struct Nand *mychip;
1323 docptr = this->virtadr;
1325 mychip = &this->chips[shr(ofs, this->chipshift)];
1327 if (this->curfloor != mychip->floor) {
1328 DoC_SelectFloor(this, mychip->floor);
1329 DoC_SelectChip(this, mychip->chip);
1330 } else if (this->curchip != mychip->chip) {
1331 DoC_SelectChip(this, mychip->chip);
1333 this->curfloor = mychip->floor;
1334 this->curchip = mychip->chip;
1336 /* update address for 2M x 8bit devices. OOB starts on the second */
1337 /* page to maintain compatibility with doc_read_ecc. */
1338 if (this->page256) {
1345 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1346 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, CDSN_CTRL_WP, 0);
1348 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1349 /* Note: datasheet says it should automaticaly wrap to the */
1350 /* next OOB block, but it didn't work here. mf. */
1351 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1352 len256 = (ofs | 0x7) + 1 - ofs;
1353 DoC_ReadBuf(this, buf, len256);
1355 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1356 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff),
1360 DoC_ReadBuf(this, &buf[len256], len - len256);
1363 /* Reading the full OOB data drops us off of the end of the page,
1364 * causing the flash device to go into busy mode, so we need
1365 * to wait until ready 11.4.1 and Toshiba TC58256FT docs */
1367 ret = DoC_WaitReady(this);
1373 int doc_write_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1374 size_t * retlen, const u_char * buf)
1377 unsigned long docptr = this->virtadr;
1378 struct Nand *mychip = &this->chips[shr(ofs, this->chipshift)];
1382 printf("doc_write_oob(%lx, %d): %2.2X %2.2X %2.2X %2.2X ... %2.2X %2.2X .. %2.2X %2.2X\n",
1383 (long)ofs, len, buf[0], buf[1], buf[2], buf[3],
1384 buf[8], buf[9], buf[14],buf[15]);
1387 /* Find the chip which is to be used and select it */
1388 if (this->curfloor != mychip->floor) {
1389 DoC_SelectFloor(this, mychip->floor);
1390 DoC_SelectChip(this, mychip->chip);
1391 } else if (this->curchip != mychip->chip) {
1392 DoC_SelectChip(this, mychip->chip);
1394 this->curfloor = mychip->floor;
1395 this->curchip = mychip->chip;
1397 /* disable the ECC engine */
1398 WriteDOC (DOC_ECC_RESET, docptr, ECCConf);
1399 WriteDOC (DOC_ECC_DIS, docptr, ECCConf);
1401 /* Reset the chip, see Software Requirement 11.4 item 1. */
1402 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1404 /* issue the Read2 command to set the pointer to the Spare Data Area. */
1405 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1407 /* update address for 2M x 8bit devices. OOB starts on the second */
1408 /* page to maintain compatibility with doc_read_ecc. */
1409 if (this->page256) {
1416 /* issue the Serial Data In command to initial the Page Program process */
1417 DoC_Command(this, NAND_CMD_SEQIN, 0);
1418 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, 0, 0);
1420 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1421 /* Note: datasheet says it should automaticaly wrap to the */
1422 /* next OOB block, but it didn't work here. mf. */
1423 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1424 len256 = (ofs | 0x7) + 1 - ofs;
1425 DoC_WriteBuf(this, buf, len256);
1427 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1428 DoC_Command(this, NAND_CMD_STATUS, 0);
1429 /* DoC_WaitReady() is implicit in DoC_Command */
1431 dummy = ReadDOC(docptr, CDSNSlowIO);
1434 if (ReadDOC_(docptr, this->ioreg) & 1) {
1435 puts ("Error programming oob data\n");
1436 /* There was an error */
1440 DoC_Command(this, NAND_CMD_SEQIN, 0);
1441 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff), 0, 0);
1444 DoC_WriteBuf(this, &buf[len256], len - len256);
1446 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1447 DoC_Command(this, NAND_CMD_STATUS, 0);
1448 /* DoC_WaitReady() is implicit in DoC_Command */
1450 dummy = ReadDOC(docptr, CDSNSlowIO);
1453 if (ReadDOC_(docptr, this->ioreg) & 1) {
1454 puts ("Error programming oob data\n");
1455 /* There was an error */
1465 int doc_erase(struct DiskOnChip* this, loff_t ofs, size_t len)
1468 unsigned long docptr;
1469 struct Nand *mychip;
1471 if (ofs & (this->erasesize-1) || len & (this->erasesize-1)) {
1472 puts ("Offset and size must be sector aligned\n");
1476 docptr = this->virtadr;
1478 /* FIXME: Do this in the background. Use timers or schedule_task() */
1480 mychip = &this->chips[shr(ofs, this->chipshift)];
1482 if (this->curfloor != mychip->floor) {
1483 DoC_SelectFloor(this, mychip->floor);
1484 DoC_SelectChip(this, mychip->chip);
1485 } else if (this->curchip != mychip->chip) {
1486 DoC_SelectChip(this, mychip->chip);
1488 this->curfloor = mychip->floor;
1489 this->curchip = mychip->chip;
1491 DoC_Command(this, NAND_CMD_ERASE1, 0);
1492 DoC_Address(this, ADDR_PAGE, ofs, 0, 0);
1493 DoC_Command(this, NAND_CMD_ERASE2, 0);
1495 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1497 dummy = ReadDOC(docptr, CDSNSlowIO);
1500 if (ReadDOC_(docptr, this->ioreg) & 1) {
1501 printf("Error erasing at 0x%lx\n", (long)ofs);
1502 /* There was an error */
1505 ofs += this->erasesize;
1506 len -= this->erasesize;
1513 static inline int doccheck(unsigned long potential, unsigned long physadr)
1515 unsigned long window=potential;
1516 unsigned char tmp, ChipID;
1517 #ifndef DOC_PASSIVE_PROBE
1521 /* Routine copied from the Linux DOC driver */
1523 #ifdef CFG_DOCPROBE_55AA
1524 /* Check for 0x55 0xAA signature at beginning of window,
1525 this is no longer true once we remove the IPL (for Millennium */
1526 if (ReadDOC(window, Sig1) != 0x55 || ReadDOC(window, Sig2) != 0xaa)
1528 #endif /* CFG_DOCPROBE_55AA */
1530 #ifndef DOC_PASSIVE_PROBE
1531 /* It's not possible to cleanly detect the DiskOnChip - the
1532 * bootup procedure will put the device into reset mode, and
1533 * it's not possible to talk to it without actually writing
1534 * to the DOCControl register. So we store the current contents
1535 * of the DOCControl register's location, in case we later decide
1536 * that it's not a DiskOnChip, and want to put it back how we
1539 tmp2 = ReadDOC(window, DOCControl);
1541 /* Reset the DiskOnChip ASIC */
1542 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1543 window, DOCControl);
1544 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1545 window, DOCControl);
1547 /* Enable the DiskOnChip ASIC */
1548 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1549 window, DOCControl);
1550 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1551 window, DOCControl);
1552 #endif /* !DOC_PASSIVE_PROBE */
1554 ChipID = ReadDOC(window, ChipID);
1557 case DOC_ChipID_Doc2k:
1558 /* Check the TOGGLE bit in the ECC register */
1559 tmp = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
1560 if ((ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT) != tmp)
1564 case DOC_ChipID_DocMil:
1565 /* Check the TOGGLE bit in the ECC register */
1566 tmp = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
1567 if ((ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT) != tmp)
1572 #ifndef CFG_DOCPROBE_55AA
1574 * if the ID isn't the DoC2000 or DoCMillenium ID, so we can assume
1575 * the DOC is missing
1578 printf("Possible DiskOnChip with unknown ChipID %2.2X found at 0x%lx\n",
1582 #ifndef DOC_PASSIVE_PROBE
1583 /* Put back the contents of the DOCControl register, in case it's not
1584 * actually a DiskOnChip.
1586 WriteDOC(tmp2, window, DOCControl);
1591 puts ("DiskOnChip failed TOGGLE test, dropping.\n");
1593 #ifndef DOC_PASSIVE_PROBE
1594 /* Put back the contents of the DOCControl register: it's not a DiskOnChip */
1595 WriteDOC(tmp2, window, DOCControl);
1600 void doc_probe(unsigned long physadr)
1602 struct DiskOnChip *this = NULL;
1605 if ((ChipID = doccheck(physadr, physadr))) {
1607 for (i=0; i<CFG_MAX_DOC_DEVICE; i++) {
1608 if (doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN) {
1609 this = doc_dev_desc + i;
1615 puts ("Cannot allocate memory for data structures.\n");
1619 if (curr_device == -1)
1622 memset((char *)this, 0, sizeof(struct DiskOnChip));
1624 this->virtadr = physadr;
1625 this->physadr = physadr;
1626 this->ChipID = ChipID;
1630 puts ("No DiskOnChip found\n");
1634 void doc_probe(unsigned long physadr) {}