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 #ifdef CFG_DOC_SUPPORT_2000
18 #define DoC_is_2000(doc) (doc->ChipID == DOC_ChipID_Doc2k)
20 #define DoC_is_2000(doc) (0)
23 #ifdef CFG_DOC_SUPPORT_MILLENNIUM
24 #define DoC_is_Millennium(doc) (doc->ChipID == DOC_ChipID_DocMil)
26 #define DoC_is_Millennium(doc) (0)
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
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
44 If you have this problem, uncomment the following line:
45 #define CFG_DOC_PASSIVE_PROBE
53 static struct DiskOnChip doc_dev_desc[CFG_MAX_DOC_DEVICE];
55 /* Current DOC Device */
56 static int curr_device = -1;
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},
84 /* ------------------------------------------------------------------------- */
86 int do_doc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
93 printf ("Usage:\n%s\n", cmdtp->usage);
96 if (strcmp(argv[1],"info") == 0) {
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]);
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");
114 printf ("\nDevice %d: ", curr_device);
115 doc_print(&doc_dev_desc[curr_device]);
118 printf ("Usage:\n%s\n", cmdtp->usage);
121 if (strcmp(argv[1],"device") == 0) {
122 int dev = (int)simple_strtoul(argv[2], NULL, 10);
124 printf ("\nDevice %d: ", dev);
125 if (dev >= CFG_MAX_DOC_DEVICE) {
126 puts ("unknown device\n");
129 doc_print(&doc_dev_desc[dev]);
132 if (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN) {
138 puts ("... is now current device\n");
143 printf ("Usage:\n%s\n", cmdtp->usage);
146 /* at least 4 args */
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);
155 printf ("\nDOC %s: device %d offset %ld, size %ld ... ",
156 cmd ? "read" : "write", curr_device, off, size);
158 ret = doc_rw(doc_dev_desc + curr_device, cmd, off, size,
159 (size_t *)&total, (u_char*)addr);
161 printf ("%d bytes %s: %s\n", total, cmd ? "read" : "write",
162 ret ? "ERROR" : "OK");
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);
170 printf ("\nDOC erase: device %d offset %ld, size %ld ... ",
171 curr_device, off, size);
173 ret = doc_erase (doc_dev_desc + curr_device, off, size);
175 printf("%s\n", ret ? "ERROR" : "OK");
179 printf ("Usage:\n%s\n", cmdtp->usage);
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"
198 int do_docboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
200 char *boot_device = NULL;
208 #if defined(CONFIG_FIT)
209 const void *fit_hdr = NULL;
212 show_boot_progress (34);
215 addr = CFG_LOAD_ADDR;
216 boot_device = getenv ("bootdevice");
219 addr = simple_strtoul(argv[1], NULL, 16);
220 boot_device = getenv ("bootdevice");
223 addr = simple_strtoul(argv[1], NULL, 16);
224 boot_device = argv[2];
227 addr = simple_strtoul(argv[1], NULL, 16);
228 boot_device = argv[2];
229 offset = simple_strtoul(argv[3], NULL, 16);
232 printf ("Usage:\n%s\n", cmdtp->usage);
233 show_boot_progress (-35);
237 show_boot_progress (35);
239 puts ("\n** No boot device **\n");
240 show_boot_progress (-36);
243 show_boot_progress (36);
245 dev = simple_strtoul(boot_device, &ep, 16);
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);
253 show_boot_progress (37);
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,
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);
265 show_boot_progress (38);
267 switch (genimg_get_format ((void *)addr)) {
268 case IMAGE_FORMAT_LEGACY:
269 hdr = (image_header_t *)addr;
271 image_print_contents (hdr);
273 cnt = image_get_image_size (hdr);
275 #if defined(CONFIG_FIT)
276 case IMAGE_FORMAT_FIT:
277 fit_hdr = (const void *)addr;
278 puts ("Fit image detected...\n");
280 cnt = fit_get_size (fit_hdr);
284 show_boot_progress (-39);
285 puts ("** Unknown image type\n");
288 show_boot_progress (39);
291 if (doc_rw (doc_dev_desc + dev, 1, offset + SECTORSIZE, cnt,
292 NULL, (u_char *)(addr+SECTORSIZE))) {
293 printf ("** Read error on %d\n", dev);
294 show_boot_progress (-40);
297 show_boot_progress (40);
299 #if defined(CONFIG_FIT)
300 /* This cannot be done earlier, we need complete FIT image in RAM first */
301 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
302 if (!fit_check_format (fit_hdr)) {
303 show_boot_progress (-130);
304 puts ("** Bad FIT image format\n");
307 show_boot_progress (131);
308 fit_print_contents (fit_hdr);
312 /* Loading ok, update default load address */
316 /* Check if we should attempt an auto-start */
317 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
319 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
321 local_args[0] = argv[0];
322 local_args[1] = NULL;
324 printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
326 do_bootm (cmdtp, 0, 1, local_args);
333 docboot, 4, 1, do_docboot,
334 "docboot - boot from DOC device\n",
338 int doc_rw (struct DiskOnChip* this, int cmd,
339 loff_t from, size_t len,
340 size_t * retlen, u_char * buf)
342 int noecc, ret = 0, n, total = 0;
346 /* The ECC will not be calculated correctly if
347 less than 512 is written or read */
348 noecc = (from != (from | 0x1ff) + 1) || (len < 0x200);
351 ret = doc_read_ecc(this, from, len,
352 (size_t *)&n, (u_char*)buf,
353 noecc ? (uchar *)NULL : (uchar *)eccbuf);
355 ret = doc_write_ecc(this, from, len,
356 (size_t *)&n, (u_char*)buf,
357 noecc ? (uchar *)NULL : (uchar *)eccbuf);
374 void doc_print(struct DiskOnChip *this) {
375 printf("%s at 0x%lX,\n"
376 "\t %d chip%s %s, size %d MB, \n"
377 "\t total size %ld MB, sector size %ld kB\n",
378 this->name, this->physadr, this->numchips,
379 this->numchips>1 ? "s" : "", this->chips_name,
380 1 << (this->chipshift - 20),
381 this->totlen >> 20, this->erasesize >> 10);
383 if (this->nftl_found) {
384 struct NFTLrecord *nftl = &this->nftl;
385 unsigned long bin_size, flash_size;
387 bin_size = nftl->nb_boot_blocks * this->erasesize;
388 flash_size = (nftl->nb_blocks - nftl->nb_boot_blocks) * this->erasesize;
390 printf("\t NFTL boot record:\n"
391 "\t Binary partition: size %ld%s\n"
392 "\t Flash disk partition: size %ld%s, offset 0x%lx\n",
393 bin_size > (1 << 20) ? bin_size >> 20 : bin_size >> 10,
394 bin_size > (1 << 20) ? "MB" : "kB",
395 flash_size > (1 << 20) ? flash_size >> 20 : flash_size >> 10,
396 flash_size > (1 << 20) ? "MB" : "kB", bin_size);
398 puts ("\t No NFTL boot record found.\n");
402 /* ------------------------------------------------------------------------- */
404 /* This function is needed to avoid calls of the __ashrdi3 function. */
405 static int shr(int val, int shift) {
409 /* Perform the required delay cycles by reading from the appropriate register */
410 static void DoC_Delay(struct DiskOnChip *doc, unsigned short cycles)
415 for (i = 0; i < cycles; i++) {
416 if (DoC_is_Millennium(doc))
417 dummy = ReadDOC(doc->virtadr, NOP);
419 dummy = ReadDOC(doc->virtadr, DOCStatus);
424 /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
425 static int _DoC_WaitReady(struct DiskOnChip *doc)
427 unsigned long docptr = doc->virtadr;
428 unsigned long start = get_timer(0);
431 puts ("_DoC_WaitReady called for out-of-line wait\n");
434 /* Out-of-line routine to wait for chip response */
435 while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
436 #ifdef CFG_DOC_SHORT_TIMEOUT
437 /* it seems that after a certain time the DoC deasserts
438 * the CDSN_CTRL_FR_B although it is not ready...
439 * using a short timout solve this (timer increments every ms) */
440 if (get_timer(start) > 10) {
444 if (get_timer(start) > 10 * 1000) {
445 puts ("_DoC_WaitReady timed out.\n");
455 static int DoC_WaitReady(struct DiskOnChip *doc)
457 unsigned long docptr = doc->virtadr;
458 /* This is inline, to optimise the common case, where it's ready instantly */
461 /* 4 read form NOP register should be issued in prior to the read from CDSNControl
462 see Software Requirement 11.4 item 2. */
465 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
466 /* Call the out-of-line routine to wait */
467 ret = _DoC_WaitReady(doc);
469 /* issue 2 read from NOP register after reading from CDSNControl register
470 see Software Requirement 11.4 item 2. */
476 /* DoC_Command: Send a flash command to the flash chip through the CDSN Slow IO register to
477 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
478 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
480 static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,
481 unsigned char xtraflags)
483 unsigned long docptr = doc->virtadr;
485 if (DoC_is_2000(doc))
486 xtraflags |= CDSN_CTRL_FLASH_IO;
488 /* Assert the CLE (Command Latch Enable) line to the flash chip */
489 WriteDOC(xtraflags | CDSN_CTRL_CLE | CDSN_CTRL_CE, docptr, CDSNControl);
490 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
492 if (DoC_is_Millennium(doc))
493 WriteDOC(command, docptr, CDSNSlowIO);
495 /* Send the command */
496 WriteDOC_(command, docptr, doc->ioreg);
498 /* Lower the CLE line */
499 WriteDOC(xtraflags | CDSN_CTRL_CE, docptr, CDSNControl);
500 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
502 /* Wait for the chip to respond - Software requirement 11.4.1 (extended for any command) */
503 return DoC_WaitReady(doc);
506 /* DoC_Address: Set the current address for the flash chip through the CDSN Slow IO register to
507 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
508 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
510 static int DoC_Address(struct DiskOnChip *doc, int numbytes, unsigned long ofs,
511 unsigned char xtraflags1, unsigned char xtraflags2)
513 unsigned long docptr;
516 docptr = doc->virtadr;
518 if (DoC_is_2000(doc))
519 xtraflags1 |= CDSN_CTRL_FLASH_IO;
521 /* Assert the ALE (Address Latch Enable) line to the flash chip */
522 WriteDOC(xtraflags1 | CDSN_CTRL_ALE | CDSN_CTRL_CE, docptr, CDSNControl);
524 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
526 /* Send the address */
527 /* Devices with 256-byte page are addressed as:
528 Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
529 * there is no device on the market with page256
530 and more than 24 bits.
531 Devices with 512-byte page are addressed as:
532 Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
533 * 25-31 is sent only if the chip support it.
534 * bit 8 changes the read command to be sent
535 (NAND_CMD_READ0 or NAND_CMD_READ1).
538 if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE) {
539 if (DoC_is_Millennium(doc))
540 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
541 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
550 if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE) {
551 for (i = 0; i < doc->pageadrlen; i++, ofs = ofs >> 8) {
552 if (DoC_is_Millennium(doc))
553 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
554 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
558 DoC_Delay(doc, 2); /* Needed for some slow flash chips. mf. */
560 /* FIXME: The SlowIO's for millennium could be replaced by
561 a single WritePipeTerm here. mf. */
563 /* Lower the ALE line */
564 WriteDOC(xtraflags1 | xtraflags2 | CDSN_CTRL_CE, docptr,
567 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
569 /* Wait for the chip to respond - Software requirement 11.4.1 */
570 return DoC_WaitReady(doc);
573 /* Read a buffer from DoC, taking care of Millennium oddities */
574 static void DoC_ReadBuf(struct DiskOnChip *doc, u_char * buf, int len)
577 int modulus = 0xffff;
578 unsigned long docptr;
581 docptr = doc->virtadr;
586 if (DoC_is_Millennium(doc)) {
587 /* Read the data via the internal pipeline through CDSN IO register,
588 see Pipelined Read Operations 11.3 */
589 dummy = ReadDOC(docptr, ReadPipeInit);
591 /* Millennium should use the LastDataRead register - Pipeline Reads */
594 /* This is needed for correctly ECC calculation */
598 for (i = 0; i < len; i++)
599 buf[i] = ReadDOC_(docptr, doc->ioreg + (i & modulus));
601 if (DoC_is_Millennium(doc)) {
602 buf[i] = ReadDOC(docptr, LastDataRead);
606 /* Write a buffer to DoC, taking care of Millennium oddities */
607 static void DoC_WriteBuf(struct DiskOnChip *doc, const u_char * buf, int len)
609 unsigned long docptr;
612 docptr = doc->virtadr;
617 for (i = 0; i < len; i++)
618 WriteDOC_(buf[i], docptr, doc->ioreg + i);
620 if (DoC_is_Millennium(doc)) {
621 WriteDOC(0x00, docptr, WritePipeTerm);
626 /* DoC_SelectChip: Select a given flash chip within the current floor */
628 static inline int DoC_SelectChip(struct DiskOnChip *doc, int chip)
630 unsigned long docptr = doc->virtadr;
632 /* Software requirement 11.4.4 before writing DeviceSelect */
633 /* Deassert the CE line to eliminate glitches on the FCE# outputs */
634 WriteDOC(CDSN_CTRL_WP, docptr, CDSNControl);
635 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
637 /* Select the individual flash chip requested */
638 WriteDOC(chip, docptr, CDSNDeviceSelect);
641 /* Reassert the CE line */
642 WriteDOC(CDSN_CTRL_CE | CDSN_CTRL_FLASH_IO | CDSN_CTRL_WP, docptr,
644 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
646 /* Wait for it to be ready */
647 return DoC_WaitReady(doc);
650 /* DoC_SelectFloor: Select a given floor (bank of flash chips) */
652 static inline int DoC_SelectFloor(struct DiskOnChip *doc, int floor)
654 unsigned long docptr = doc->virtadr;
656 /* Select the floor (bank) of chips required */
657 WriteDOC(floor, docptr, FloorSelect);
659 /* Wait for the chip to be ready */
660 return DoC_WaitReady(doc);
663 /* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */
665 static int DoC_IdentChip(struct DiskOnChip *doc, int floor, int chip)
670 /* Page in the required floor/chip */
671 DoC_SelectFloor(doc, floor);
672 DoC_SelectChip(doc, chip);
675 if (DoC_Command(doc, NAND_CMD_RESET, CDSN_CTRL_WP)) {
677 printf("DoC_Command (reset) for %d,%d returned true\n",
684 /* Read the NAND chip ID: 1. Send ReadID command */
685 if (DoC_Command(doc, NAND_CMD_READID, CDSN_CTRL_WP)) {
687 printf("DoC_Command (ReadID) for %d,%d returned true\n",
693 /* Read the NAND chip ID: 2. Send address byte zero */
694 DoC_Address(doc, ADDR_COLUMN, 0, CDSN_CTRL_WP, 0);
696 /* Read the manufacturer and device id codes from the device */
698 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
699 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
701 mfr = ReadDOC_(doc->virtadr, doc->ioreg);
703 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
704 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
706 id = ReadDOC_(doc->virtadr, doc->ioreg);
708 /* No response - return failure */
709 if (mfr == 0xff || mfr == 0)
712 /* Check it's the same as the first chip we identified.
713 * M-Systems say that any given DiskOnChip device should only
714 * contain _one_ type of flash part, although that's not a
715 * hardware restriction. */
717 if (doc->mfr == mfr && doc->id == id)
718 return 1; /* This is another the same the first */
720 printf("Flash chip at floor %d, chip %d is different:\n",
724 /* Print and store the manufacturer and ID codes. */
725 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
726 if (mfr == nand_flash_ids[i].manufacture_id &&
727 id == nand_flash_ids[i].model_id) {
729 printf("Flash chip found: Manufacturer ID: %2.2X, "
730 "Chip ID: %2.2X (%s)\n", mfr, id,
731 nand_flash_ids[i].name);
737 nand_flash_ids[i].chipshift;
738 doc->page256 = nand_flash_ids[i].page256;
740 nand_flash_ids[i].pageadrlen;
742 nand_flash_ids[i].erasesize;
744 nand_flash_ids[i].name;
753 /* We haven't fully identified the chip. Print as much as we know. */
754 printf("Unknown flash chip found: %2.2X %2.2X\n",
761 /* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */
763 static void DoC_ScanChips(struct DiskOnChip *this)
766 int numchips[MAX_FLOORS];
767 int maxchips = MAX_CHIPS;
774 if (DoC_is_Millennium(this))
775 maxchips = MAX_CHIPS_MIL;
777 /* For each floor, find the number of valid chips it contains */
778 for (floor = 0; floor < MAX_FLOORS; floor++) {
781 for (chip = 0; chip < maxchips && ret != 0; chip++) {
783 ret = DoC_IdentChip(this, floor, chip);
791 /* If there are none at all that we recognise, bail */
792 if (!this->numchips) {
793 puts ("No flash chips recognised.\n");
797 /* Allocate an array to hold the information for each chip */
798 this->chips = malloc(sizeof(struct Nand) * this->numchips);
800 puts ("No memory for allocating chip info structures\n");
806 /* Fill out the chip array with {floor, chipno} for each
807 * detected chip in the device. */
808 for (floor = 0; floor < MAX_FLOORS; floor++) {
809 for (chip = 0; chip < numchips[floor]; chip++) {
810 this->chips[ret].floor = floor;
811 this->chips[ret].chip = chip;
812 this->chips[ret].curadr = 0;
813 this->chips[ret].curmode = 0x50;
818 /* Calculate and print the total size of the device */
819 this->totlen = this->numchips * (1 << this->chipshift);
822 printf("%d flash chips found. Total DiskOnChip size: %ld MB\n",
823 this->numchips, this->totlen >> 20);
827 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
828 * various device information of the NFTL partition and Bad Unit Table. Update
829 * the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
830 * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
832 static int find_boot_record(struct NFTLrecord *nftl)
836 unsigned int block, boot_record_count = 0;
839 struct NFTLMediaHeader *mh = &nftl->MediaHdr;
842 nftl->MediaUnit = BLOCK_NIL;
843 nftl->SpareMediaUnit = BLOCK_NIL;
845 /* search for a valid boot record */
846 for (block = 0; block < nftl->nb_blocks; block++) {
849 /* Check for ANAND header first. Then can whinge if it's found but later
851 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize, SECTORSIZE,
852 (size_t *)&retlen, buf, NULL))) {
853 static int warncount = 5;
856 printf("Block read at 0x%x failed\n", block * nftl->EraseSize);
858 puts ("Further failures for this block will not be printed\n");
863 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
864 /* ANAND\0 not found. Continue */
866 printf("ANAND header not found at 0x%x\n", block * nftl->EraseSize);
872 printf("ANAND header found at 0x%x\n", block * nftl->EraseSize);
875 /* To be safer with BIOS, also use erase mark as discriminant */
876 if ((ret = doc_read_oob(nftl->mtd, block * nftl->EraseSize + SECTORSIZE + 8,
877 8, (size_t *)&retlen, (uchar *)&h1) < 0)) {
879 printf("ANAND header found at 0x%x, but OOB data read failed\n",
880 block * nftl->EraseSize);
885 /* OK, we like it. */
887 if (boot_record_count) {
888 /* We've already processed one. So we just check if
889 this one is the same as the first one we found */
890 if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
892 printf("NFTL Media Headers at 0x%x and 0x%x disagree.\n",
893 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
895 /* if (debug) Print both side by side */
898 if (boot_record_count == 1)
899 nftl->SpareMediaUnit = block;
905 /* This is the first we've seen. Copy the media header structure into place */
906 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
908 /* Do some sanity checks on it */
909 if (mh->UnitSizeFactor == 0) {
911 puts ("UnitSizeFactor 0x00 detected.\n"
912 "This violates the spec but we think we know what it means...\n");
914 } else if (mh->UnitSizeFactor != 0xff) {
915 printf ("Sorry, we don't support UnitSizeFactor "
920 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
921 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
922 printf ("NFTL Media Header sanity check failed:\n"
923 "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
924 nftl->nb_boot_blocks, nftl->nb_blocks);
928 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
929 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
930 printf ("NFTL Media Header sanity check failed:\n"
931 "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
934 nftl->nb_boot_blocks);
938 nftl->nr_sects = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
940 /* If we're not using the last sectors in the device for some reason,
941 reduce nb_blocks accordingly so we forget they're there */
942 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
944 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
945 for (i = 0; i < nftl->nb_blocks; i++) {
946 if ((i & (SECTORSIZE - 1)) == 0) {
947 /* read one sector for every SECTORSIZE of blocks */
948 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize +
949 i + SECTORSIZE, SECTORSIZE,
950 (size_t *)&retlen, buf, (uchar *)&oob)) < 0) {
951 puts ("Read of bad sector table failed\n");
955 /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
956 if (buf[i & (SECTORSIZE - 1)] != 0xff)
957 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
960 nftl->MediaUnit = block;
963 } /* foreach (block) */
965 return boot_record_count?0:-1;
968 /* This routine is made available to other mtd code via
969 * inter_module_register. It must only be accessed through
970 * inter_module_get which will bump the use count of this module. The
971 * addresses passed back in mtd are valid as long as the use count of
972 * this module is non-zero, i.e. between inter_module_get and
973 * inter_module_put. Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
975 static void DoC2k_init(struct DiskOnChip* this)
977 struct NFTLrecord *nftl;
979 switch (this->ChipID) {
980 case DOC_ChipID_Doc2k:
981 this->name = "DiskOnChip 2000";
982 this->ioreg = DoC_2k_CDSN_IO;
984 case DOC_ChipID_DocMil:
985 this->name = "DiskOnChip Millennium";
986 this->ioreg = DoC_Mil_CDSN_IO;
991 printf("%s found at address 0x%lX\n", this->name,
1001 /* Ident all the chips present. */
1002 DoC_ScanChips(this);
1003 if ((!this->numchips) || (!this->chips))
1008 /* Get physical parameters */
1009 nftl->EraseSize = this->erasesize;
1010 nftl->nb_blocks = this->totlen / this->erasesize;
1013 if (find_boot_record(nftl) != 0)
1014 this->nftl_found = 0;
1016 this->nftl_found = 1;
1018 printf("%s @ 0x%lX, %ld MB\n", this->name, this->physadr, this->totlen >> 20);
1021 int doc_read_ecc(struct DiskOnChip* this, loff_t from, size_t len,
1022 size_t * retlen, u_char * buf, u_char * eccbuf)
1024 unsigned long docptr;
1025 struct Nand *mychip;
1026 unsigned char syndrome[6];
1027 volatile char dummy;
1028 int i, len256 = 0, ret=0;
1030 docptr = this->virtadr;
1032 /* Don't allow read past end of device */
1033 if (from >= this->totlen) {
1034 puts ("Out of flash\n");
1038 /* Don't allow a single read to cross a 512-byte block boundary */
1039 if (from + len > ((from | 0x1ff) + 1))
1040 len = ((from | 0x1ff) + 1) - from;
1042 /* The ECC will not be calculated correctly if less than 512 is read */
1043 if (len != 0x200 && eccbuf)
1044 printf("ECC needs a full sector read (adr: %lx size %lx)\n",
1045 (long) from, (long) len);
1048 printf("DoC_Read (adr: %lx size %lx)\n", (long) from, (long) len);
1051 /* Find the chip which is to be used and select it */
1052 mychip = &this->chips[shr(from, this->chipshift)];
1054 if (this->curfloor != mychip->floor) {
1055 DoC_SelectFloor(this, mychip->floor);
1056 DoC_SelectChip(this, mychip->chip);
1057 } else if (this->curchip != mychip->chip) {
1058 DoC_SelectChip(this, mychip->chip);
1061 this->curfloor = mychip->floor;
1062 this->curchip = mychip->chip;
1066 && (from & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1068 DoC_Address(this, ADDR_COLUMN_PAGE, from, CDSN_CTRL_WP,
1072 /* Prime the ECC engine */
1073 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1074 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
1076 /* disable the ECC engine */
1077 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1078 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1081 /* treat crossing 256-byte sector for 2M x 8bits devices */
1082 if (this->page256 && from + len > (from | 0xff) + 1) {
1083 len256 = (from | 0xff) + 1 - from;
1084 DoC_ReadBuf(this, buf, len256);
1086 DoC_Command(this, NAND_CMD_READ0, CDSN_CTRL_WP);
1087 DoC_Address(this, ADDR_COLUMN_PAGE, from + len256,
1088 CDSN_CTRL_WP, CDSN_CTRL_ECC_IO);
1091 DoC_ReadBuf(this, &buf[len256], len - len256);
1093 /* Let the caller know we completed it */
1097 /* Read the ECC data through the DiskOnChip ECC logic */
1098 /* Note: this will work even with 2M x 8bit devices as */
1099 /* they have 8 bytes of OOB per 256 page. mf. */
1100 DoC_ReadBuf(this, eccbuf, 6);
1102 /* Flush the pipeline */
1103 if (DoC_is_Millennium(this)) {
1104 dummy = ReadDOC(docptr, ECCConf);
1105 dummy = ReadDOC(docptr, ECCConf);
1106 i = ReadDOC(docptr, ECCConf);
1108 dummy = ReadDOC(docptr, 2k_ECCStatus);
1109 dummy = ReadDOC(docptr, 2k_ECCStatus);
1110 i = ReadDOC(docptr, 2k_ECCStatus);
1113 /* Check the ECC Status */
1116 /* There was an ECC error */
1118 printf("DiskOnChip ECC Error: Read at %lx\n", (long)from);
1120 /* Read the ECC syndrom through the DiskOnChip ECC logic.
1121 These syndrome will be all ZERO when there is no error */
1122 for (i = 0; i < 6; i++) {
1124 ReadDOC(docptr, ECCSyndrome0 + i);
1126 nb_errors = doc_decode_ecc(buf, syndrome);
1129 printf("Errors corrected: %x\n", nb_errors);
1131 if (nb_errors < 0) {
1132 /* We return error, but have actually done the read. Not that
1133 this can be told to user-space, via sys_read(), but at least
1134 MTD-aware stuff can know about it by checking *retlen */
1135 printf("ECC Errors at %lx\n", (long)from);
1141 printf("ECC DATA at %lxB: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1142 (long)from, eccbuf[0], eccbuf[1], eccbuf[2],
1143 eccbuf[3], eccbuf[4], eccbuf[5]);
1146 /* disable the ECC engine */
1147 WriteDOC(DOC_ECC_DIS, docptr , ECCConf);
1150 /* according to 11.4.1, we need to wait for the busy line
1151 * drop if we read to the end of the page. */
1152 if(0 == ((from + *retlen) & 0x1ff))
1154 DoC_WaitReady(this);
1160 int doc_write_ecc(struct DiskOnChip* this, loff_t to, size_t len,
1161 size_t * retlen, const u_char * buf,
1164 int di; /* Yes, DI is a hangover from when I was disassembling the binary driver */
1165 unsigned long docptr;
1166 volatile char dummy;
1168 struct Nand *mychip;
1170 docptr = this->virtadr;
1172 /* Don't allow write past end of device */
1173 if (to >= this->totlen) {
1174 puts ("Out of flash\n");
1178 /* Don't allow a single write to cross a 512-byte block boundary */
1179 if (to + len > ((to | 0x1ff) + 1))
1180 len = ((to | 0x1ff) + 1) - to;
1182 /* The ECC will not be calculated correctly if less than 512 is written */
1183 if (len != 0x200 && eccbuf)
1184 printf("ECC needs a full sector write (adr: %lx size %lx)\n",
1185 (long) to, (long) len);
1187 /* printf("DoC_Write (adr: %lx size %lx)\n", (long) to, (long) len); */
1189 /* Find the chip which is to be used and select it */
1190 mychip = &this->chips[shr(to, this->chipshift)];
1192 if (this->curfloor != mychip->floor) {
1193 DoC_SelectFloor(this, mychip->floor);
1194 DoC_SelectChip(this, mychip->chip);
1195 } else if (this->curchip != mychip->chip) {
1196 DoC_SelectChip(this, mychip->chip);
1199 this->curfloor = mychip->floor;
1200 this->curchip = mychip->chip;
1202 /* Set device to main plane of flash */
1203 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1206 && (to & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1209 DoC_Command(this, NAND_CMD_SEQIN, 0);
1210 DoC_Address(this, ADDR_COLUMN_PAGE, to, 0, CDSN_CTRL_ECC_IO);
1213 /* Prime the ECC engine */
1214 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1215 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
1217 /* disable the ECC engine */
1218 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1219 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1222 /* treat crossing 256-byte sector for 2M x 8bits devices */
1223 if (this->page256 && to + len > (to | 0xff) + 1) {
1224 len256 = (to | 0xff) + 1 - to;
1225 DoC_WriteBuf(this, buf, len256);
1227 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1229 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1230 /* There's an implicit DoC_WaitReady() in DoC_Command */
1232 dummy = ReadDOC(docptr, CDSNSlowIO);
1235 if (ReadDOC_(docptr, this->ioreg) & 1) {
1236 puts ("Error programming flash\n");
1237 /* Error in programming */
1242 DoC_Command(this, NAND_CMD_SEQIN, 0);
1243 DoC_Address(this, ADDR_COLUMN_PAGE, to + len256, 0,
1247 DoC_WriteBuf(this, &buf[len256], len - len256);
1250 WriteDOC(CDSN_CTRL_ECC_IO | CDSN_CTRL_CE, docptr,
1253 if (DoC_is_Millennium(this)) {
1254 WriteDOC(0, docptr, NOP);
1255 WriteDOC(0, docptr, NOP);
1256 WriteDOC(0, docptr, NOP);
1258 WriteDOC_(0, docptr, this->ioreg);
1259 WriteDOC_(0, docptr, this->ioreg);
1260 WriteDOC_(0, docptr, this->ioreg);
1263 /* Read the ECC data through the DiskOnChip ECC logic */
1264 for (di = 0; di < 6; di++) {
1265 eccbuf[di] = ReadDOC(docptr, ECCSyndrome0 + di);
1268 /* Reset the ECC engine */
1269 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1273 ("OOB data at %lx is %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1274 (long) to, eccbuf[0], eccbuf[1], eccbuf[2], eccbuf[3],
1275 eccbuf[4], eccbuf[5]);
1279 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1281 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1282 /* There's an implicit DoC_WaitReady() in DoC_Command */
1284 dummy = ReadDOC(docptr, CDSNSlowIO);
1287 if (ReadDOC_(docptr, this->ioreg) & 1) {
1288 puts ("Error programming flash\n");
1289 /* Error in programming */
1294 /* Let the caller know we completed it */
1302 /* Write the ECC data to flash */
1303 for (di=0; di<6; di++)
1309 ret = doc_write_oob(this, to, 8, &dummy, x);
1315 int doc_read_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1316 size_t * retlen, u_char * buf)
1318 int len256 = 0, ret;
1319 unsigned long docptr;
1320 struct Nand *mychip;
1322 docptr = this->virtadr;
1324 mychip = &this->chips[shr(ofs, this->chipshift)];
1326 if (this->curfloor != mychip->floor) {
1327 DoC_SelectFloor(this, mychip->floor);
1328 DoC_SelectChip(this, mychip->chip);
1329 } else if (this->curchip != mychip->chip) {
1330 DoC_SelectChip(this, mychip->chip);
1332 this->curfloor = mychip->floor;
1333 this->curchip = mychip->chip;
1335 /* update address for 2M x 8bit devices. OOB starts on the second */
1336 /* page to maintain compatibility with doc_read_ecc. */
1337 if (this->page256) {
1344 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1345 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, CDSN_CTRL_WP, 0);
1347 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1348 /* Note: datasheet says it should automaticaly wrap to the */
1349 /* next OOB block, but it didn't work here. mf. */
1350 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1351 len256 = (ofs | 0x7) + 1 - ofs;
1352 DoC_ReadBuf(this, buf, len256);
1354 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1355 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff),
1359 DoC_ReadBuf(this, &buf[len256], len - len256);
1362 /* Reading the full OOB data drops us off of the end of the page,
1363 * causing the flash device to go into busy mode, so we need
1364 * to wait until ready 11.4.1 and Toshiba TC58256FT docs */
1366 ret = DoC_WaitReady(this);
1372 int doc_write_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1373 size_t * retlen, const u_char * buf)
1376 unsigned long docptr = this->virtadr;
1377 struct Nand *mychip = &this->chips[shr(ofs, this->chipshift)];
1381 printf("doc_write_oob(%lx, %d): %2.2X %2.2X %2.2X %2.2X ... %2.2X %2.2X .. %2.2X %2.2X\n",
1382 (long)ofs, len, buf[0], buf[1], buf[2], buf[3],
1383 buf[8], buf[9], buf[14],buf[15]);
1386 /* Find the chip which is to be used and select it */
1387 if (this->curfloor != mychip->floor) {
1388 DoC_SelectFloor(this, mychip->floor);
1389 DoC_SelectChip(this, mychip->chip);
1390 } else if (this->curchip != mychip->chip) {
1391 DoC_SelectChip(this, mychip->chip);
1393 this->curfloor = mychip->floor;
1394 this->curchip = mychip->chip;
1396 /* disable the ECC engine */
1397 WriteDOC (DOC_ECC_RESET, docptr, ECCConf);
1398 WriteDOC (DOC_ECC_DIS, docptr, ECCConf);
1400 /* Reset the chip, see Software Requirement 11.4 item 1. */
1401 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1403 /* issue the Read2 command to set the pointer to the Spare Data Area. */
1404 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1406 /* update address for 2M x 8bit devices. OOB starts on the second */
1407 /* page to maintain compatibility with doc_read_ecc. */
1408 if (this->page256) {
1415 /* issue the Serial Data In command to initial the Page Program process */
1416 DoC_Command(this, NAND_CMD_SEQIN, 0);
1417 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, 0, 0);
1419 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1420 /* Note: datasheet says it should automaticaly wrap to the */
1421 /* next OOB block, but it didn't work here. mf. */
1422 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1423 len256 = (ofs | 0x7) + 1 - ofs;
1424 DoC_WriteBuf(this, buf, len256);
1426 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1427 DoC_Command(this, NAND_CMD_STATUS, 0);
1428 /* DoC_WaitReady() is implicit in DoC_Command */
1430 dummy = ReadDOC(docptr, CDSNSlowIO);
1433 if (ReadDOC_(docptr, this->ioreg) & 1) {
1434 puts ("Error programming oob data\n");
1435 /* There was an error */
1439 DoC_Command(this, NAND_CMD_SEQIN, 0);
1440 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff), 0, 0);
1443 DoC_WriteBuf(this, &buf[len256], len - len256);
1445 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1446 DoC_Command(this, NAND_CMD_STATUS, 0);
1447 /* DoC_WaitReady() is implicit in DoC_Command */
1449 dummy = ReadDOC(docptr, CDSNSlowIO);
1452 if (ReadDOC_(docptr, this->ioreg) & 1) {
1453 puts ("Error programming oob data\n");
1454 /* There was an error */
1464 int doc_erase(struct DiskOnChip* this, loff_t ofs, size_t len)
1467 unsigned long docptr;
1468 struct Nand *mychip;
1470 if (ofs & (this->erasesize-1) || len & (this->erasesize-1)) {
1471 puts ("Offset and size must be sector aligned\n");
1475 docptr = this->virtadr;
1477 /* FIXME: Do this in the background. Use timers or schedule_task() */
1479 mychip = &this->chips[shr(ofs, this->chipshift)];
1481 if (this->curfloor != mychip->floor) {
1482 DoC_SelectFloor(this, mychip->floor);
1483 DoC_SelectChip(this, mychip->chip);
1484 } else if (this->curchip != mychip->chip) {
1485 DoC_SelectChip(this, mychip->chip);
1487 this->curfloor = mychip->floor;
1488 this->curchip = mychip->chip;
1490 DoC_Command(this, NAND_CMD_ERASE1, 0);
1491 DoC_Address(this, ADDR_PAGE, ofs, 0, 0);
1492 DoC_Command(this, NAND_CMD_ERASE2, 0);
1494 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1496 dummy = ReadDOC(docptr, CDSNSlowIO);
1499 if (ReadDOC_(docptr, this->ioreg) & 1) {
1500 printf("Error erasing at 0x%lx\n", (long)ofs);
1501 /* There was an error */
1504 ofs += this->erasesize;
1505 len -= this->erasesize;
1512 static inline int doccheck(unsigned long potential, unsigned long physadr)
1514 unsigned long window=potential;
1515 unsigned char tmp, ChipID;
1516 #ifndef DOC_PASSIVE_PROBE
1520 /* Routine copied from the Linux DOC driver */
1522 #ifdef CFG_DOCPROBE_55AA
1523 /* Check for 0x55 0xAA signature at beginning of window,
1524 this is no longer true once we remove the IPL (for Millennium */
1525 if (ReadDOC(window, Sig1) != 0x55 || ReadDOC(window, Sig2) != 0xaa)
1527 #endif /* CFG_DOCPROBE_55AA */
1529 #ifndef DOC_PASSIVE_PROBE
1530 /* It's not possible to cleanly detect the DiskOnChip - the
1531 * bootup procedure will put the device into reset mode, and
1532 * it's not possible to talk to it without actually writing
1533 * to the DOCControl register. So we store the current contents
1534 * of the DOCControl register's location, in case we later decide
1535 * that it's not a DiskOnChip, and want to put it back how we
1538 tmp2 = ReadDOC(window, DOCControl);
1540 /* Reset the DiskOnChip ASIC */
1541 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1542 window, DOCControl);
1543 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1544 window, DOCControl);
1546 /* Enable the DiskOnChip ASIC */
1547 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1548 window, DOCControl);
1549 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1550 window, DOCControl);
1551 #endif /* !DOC_PASSIVE_PROBE */
1553 ChipID = ReadDOC(window, ChipID);
1556 case DOC_ChipID_Doc2k:
1557 /* Check the TOGGLE bit in the ECC register */
1558 tmp = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
1559 if ((ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT) != tmp)
1563 case DOC_ChipID_DocMil:
1564 /* Check the TOGGLE bit in the ECC register */
1565 tmp = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
1566 if ((ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT) != tmp)
1571 #ifndef CFG_DOCPROBE_55AA
1573 * if the ID isn't the DoC2000 or DoCMillenium ID, so we can assume
1574 * the DOC is missing
1577 printf("Possible DiskOnChip with unknown ChipID %2.2X found at 0x%lx\n",
1581 #ifndef DOC_PASSIVE_PROBE
1582 /* Put back the contents of the DOCControl register, in case it's not
1583 * actually a DiskOnChip.
1585 WriteDOC(tmp2, window, DOCControl);
1590 puts ("DiskOnChip failed TOGGLE test, dropping.\n");
1592 #ifndef DOC_PASSIVE_PROBE
1593 /* Put back the contents of the DOCControl register: it's not a DiskOnChip */
1594 WriteDOC(tmp2, window, DOCControl);
1599 void doc_probe(unsigned long physadr)
1601 struct DiskOnChip *this = NULL;
1604 if ((ChipID = doccheck(physadr, physadr))) {
1606 for (i=0; i<CFG_MAX_DOC_DEVICE; i++) {
1607 if (doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN) {
1608 this = doc_dev_desc + i;
1614 puts ("Cannot allocate memory for data structures.\n");
1618 if (curr_device == -1)
1621 memset((char *)this, 0, sizeof(struct DiskOnChip));
1623 this->virtadr = physadr;
1624 this->physadr = physadr;
1625 this->ChipID = ChipID;
1629 puts ("No DiskOnChip found\n");