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)
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 if (!fit_check_format (fit_hdr)) {
279 puts ("** Bad FIT image format\n");
282 puts ("Fit image detected...\n");
284 cnt = fit_get_size (fit_hdr);
288 show_boot_progress (-39);
289 puts ("** Unknown image type\n");
292 show_boot_progress (39);
295 if (doc_rw (doc_dev_desc + dev, 1, offset + SECTORSIZE, cnt,
296 NULL, (u_char *)(addr+SECTORSIZE))) {
297 printf ("** Read error on %d\n", dev);
298 show_boot_progress (-40);
301 show_boot_progress (40);
303 #if defined(CONFIG_FIT)
304 /* This cannot be done earlier, we need complete FIT image in RAM first */
305 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT)
306 fit_print_contents ((const void *)addr);
309 /* Loading ok, update default load address */
313 /* Check if we should attempt an auto-start */
314 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
316 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
318 local_args[0] = argv[0];
319 local_args[1] = NULL;
321 printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
323 do_bootm (cmdtp, 0, 1, local_args);
330 docboot, 4, 1, do_docboot,
331 "docboot - boot from DOC device\n",
335 int doc_rw (struct DiskOnChip* this, int cmd,
336 loff_t from, size_t len,
337 size_t * retlen, u_char * buf)
339 int noecc, ret = 0, n, total = 0;
343 /* The ECC will not be calculated correctly if
344 less than 512 is written or read */
345 noecc = (from != (from | 0x1ff) + 1) || (len < 0x200);
348 ret = doc_read_ecc(this, from, len,
349 (size_t *)&n, (u_char*)buf,
350 noecc ? (uchar *)NULL : (uchar *)eccbuf);
352 ret = doc_write_ecc(this, from, len,
353 (size_t *)&n, (u_char*)buf,
354 noecc ? (uchar *)NULL : (uchar *)eccbuf);
371 void doc_print(struct DiskOnChip *this) {
372 printf("%s at 0x%lX,\n"
373 "\t %d chip%s %s, size %d MB, \n"
374 "\t total size %ld MB, sector size %ld kB\n",
375 this->name, this->physadr, this->numchips,
376 this->numchips>1 ? "s" : "", this->chips_name,
377 1 << (this->chipshift - 20),
378 this->totlen >> 20, this->erasesize >> 10);
380 if (this->nftl_found) {
381 struct NFTLrecord *nftl = &this->nftl;
382 unsigned long bin_size, flash_size;
384 bin_size = nftl->nb_boot_blocks * this->erasesize;
385 flash_size = (nftl->nb_blocks - nftl->nb_boot_blocks) * this->erasesize;
387 printf("\t NFTL boot record:\n"
388 "\t Binary partition: size %ld%s\n"
389 "\t Flash disk partition: size %ld%s, offset 0x%lx\n",
390 bin_size > (1 << 20) ? bin_size >> 20 : bin_size >> 10,
391 bin_size > (1 << 20) ? "MB" : "kB",
392 flash_size > (1 << 20) ? flash_size >> 20 : flash_size >> 10,
393 flash_size > (1 << 20) ? "MB" : "kB", bin_size);
395 puts ("\t No NFTL boot record found.\n");
399 /* ------------------------------------------------------------------------- */
401 /* This function is needed to avoid calls of the __ashrdi3 function. */
402 static int shr(int val, int shift) {
406 /* Perform the required delay cycles by reading from the appropriate register */
407 static void DoC_Delay(struct DiskOnChip *doc, unsigned short cycles)
412 for (i = 0; i < cycles; i++) {
413 if (DoC_is_Millennium(doc))
414 dummy = ReadDOC(doc->virtadr, NOP);
416 dummy = ReadDOC(doc->virtadr, DOCStatus);
421 /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
422 static int _DoC_WaitReady(struct DiskOnChip *doc)
424 unsigned long docptr = doc->virtadr;
425 unsigned long start = get_timer(0);
428 puts ("_DoC_WaitReady called for out-of-line wait\n");
431 /* Out-of-line routine to wait for chip response */
432 while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
433 #ifdef CFG_DOC_SHORT_TIMEOUT
434 /* it seems that after a certain time the DoC deasserts
435 * the CDSN_CTRL_FR_B although it is not ready...
436 * using a short timout solve this (timer increments every ms) */
437 if (get_timer(start) > 10) {
441 if (get_timer(start) > 10 * 1000) {
442 puts ("_DoC_WaitReady timed out.\n");
452 static int DoC_WaitReady(struct DiskOnChip *doc)
454 unsigned long docptr = doc->virtadr;
455 /* This is inline, to optimise the common case, where it's ready instantly */
458 /* 4 read form NOP register should be issued in prior to the read from CDSNControl
459 see Software Requirement 11.4 item 2. */
462 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
463 /* Call the out-of-line routine to wait */
464 ret = _DoC_WaitReady(doc);
466 /* issue 2 read from NOP register after reading from CDSNControl register
467 see Software Requirement 11.4 item 2. */
473 /* DoC_Command: Send a flash command to the flash chip through the CDSN Slow IO register to
474 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
475 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
477 static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,
478 unsigned char xtraflags)
480 unsigned long docptr = doc->virtadr;
482 if (DoC_is_2000(doc))
483 xtraflags |= CDSN_CTRL_FLASH_IO;
485 /* Assert the CLE (Command Latch Enable) line to the flash chip */
486 WriteDOC(xtraflags | CDSN_CTRL_CLE | CDSN_CTRL_CE, docptr, CDSNControl);
487 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
489 if (DoC_is_Millennium(doc))
490 WriteDOC(command, docptr, CDSNSlowIO);
492 /* Send the command */
493 WriteDOC_(command, docptr, doc->ioreg);
495 /* Lower the CLE line */
496 WriteDOC(xtraflags | CDSN_CTRL_CE, docptr, CDSNControl);
497 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
499 /* Wait for the chip to respond - Software requirement 11.4.1 (extended for any command) */
500 return DoC_WaitReady(doc);
503 /* DoC_Address: Set the current address for the flash chip through the CDSN Slow IO register to
504 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
505 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
507 static int DoC_Address(struct DiskOnChip *doc, int numbytes, unsigned long ofs,
508 unsigned char xtraflags1, unsigned char xtraflags2)
510 unsigned long docptr;
513 docptr = doc->virtadr;
515 if (DoC_is_2000(doc))
516 xtraflags1 |= CDSN_CTRL_FLASH_IO;
518 /* Assert the ALE (Address Latch Enable) line to the flash chip */
519 WriteDOC(xtraflags1 | CDSN_CTRL_ALE | CDSN_CTRL_CE, docptr, CDSNControl);
521 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
523 /* Send the address */
524 /* Devices with 256-byte page are addressed as:
525 Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
526 * there is no device on the market with page256
527 and more than 24 bits.
528 Devices with 512-byte page are addressed as:
529 Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
530 * 25-31 is sent only if the chip support it.
531 * bit 8 changes the read command to be sent
532 (NAND_CMD_READ0 or NAND_CMD_READ1).
535 if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE) {
536 if (DoC_is_Millennium(doc))
537 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
538 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
547 if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE) {
548 for (i = 0; i < doc->pageadrlen; i++, ofs = ofs >> 8) {
549 if (DoC_is_Millennium(doc))
550 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
551 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
555 DoC_Delay(doc, 2); /* Needed for some slow flash chips. mf. */
557 /* FIXME: The SlowIO's for millennium could be replaced by
558 a single WritePipeTerm here. mf. */
560 /* Lower the ALE line */
561 WriteDOC(xtraflags1 | xtraflags2 | CDSN_CTRL_CE, docptr,
564 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
566 /* Wait for the chip to respond - Software requirement 11.4.1 */
567 return DoC_WaitReady(doc);
570 /* Read a buffer from DoC, taking care of Millennium oddities */
571 static void DoC_ReadBuf(struct DiskOnChip *doc, u_char * buf, int len)
574 int modulus = 0xffff;
575 unsigned long docptr;
578 docptr = doc->virtadr;
583 if (DoC_is_Millennium(doc)) {
584 /* Read the data via the internal pipeline through CDSN IO register,
585 see Pipelined Read Operations 11.3 */
586 dummy = ReadDOC(docptr, ReadPipeInit);
588 /* Millennium should use the LastDataRead register - Pipeline Reads */
591 /* This is needed for correctly ECC calculation */
595 for (i = 0; i < len; i++)
596 buf[i] = ReadDOC_(docptr, doc->ioreg + (i & modulus));
598 if (DoC_is_Millennium(doc)) {
599 buf[i] = ReadDOC(docptr, LastDataRead);
603 /* Write a buffer to DoC, taking care of Millennium oddities */
604 static void DoC_WriteBuf(struct DiskOnChip *doc, const u_char * buf, int len)
606 unsigned long docptr;
609 docptr = doc->virtadr;
614 for (i = 0; i < len; i++)
615 WriteDOC_(buf[i], docptr, doc->ioreg + i);
617 if (DoC_is_Millennium(doc)) {
618 WriteDOC(0x00, docptr, WritePipeTerm);
623 /* DoC_SelectChip: Select a given flash chip within the current floor */
625 static inline int DoC_SelectChip(struct DiskOnChip *doc, int chip)
627 unsigned long docptr = doc->virtadr;
629 /* Software requirement 11.4.4 before writing DeviceSelect */
630 /* Deassert the CE line to eliminate glitches on the FCE# outputs */
631 WriteDOC(CDSN_CTRL_WP, docptr, CDSNControl);
632 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
634 /* Select the individual flash chip requested */
635 WriteDOC(chip, docptr, CDSNDeviceSelect);
638 /* Reassert the CE line */
639 WriteDOC(CDSN_CTRL_CE | CDSN_CTRL_FLASH_IO | CDSN_CTRL_WP, docptr,
641 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
643 /* Wait for it to be ready */
644 return DoC_WaitReady(doc);
647 /* DoC_SelectFloor: Select a given floor (bank of flash chips) */
649 static inline int DoC_SelectFloor(struct DiskOnChip *doc, int floor)
651 unsigned long docptr = doc->virtadr;
653 /* Select the floor (bank) of chips required */
654 WriteDOC(floor, docptr, FloorSelect);
656 /* Wait for the chip to be ready */
657 return DoC_WaitReady(doc);
660 /* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */
662 static int DoC_IdentChip(struct DiskOnChip *doc, int floor, int chip)
667 /* Page in the required floor/chip */
668 DoC_SelectFloor(doc, floor);
669 DoC_SelectChip(doc, chip);
672 if (DoC_Command(doc, NAND_CMD_RESET, CDSN_CTRL_WP)) {
674 printf("DoC_Command (reset) for %d,%d returned true\n",
681 /* Read the NAND chip ID: 1. Send ReadID command */
682 if (DoC_Command(doc, NAND_CMD_READID, CDSN_CTRL_WP)) {
684 printf("DoC_Command (ReadID) for %d,%d returned true\n",
690 /* Read the NAND chip ID: 2. Send address byte zero */
691 DoC_Address(doc, ADDR_COLUMN, 0, CDSN_CTRL_WP, 0);
693 /* Read the manufacturer and device id codes from the device */
695 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
696 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
698 mfr = ReadDOC_(doc->virtadr, doc->ioreg);
700 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
701 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
703 id = ReadDOC_(doc->virtadr, doc->ioreg);
705 /* No response - return failure */
706 if (mfr == 0xff || mfr == 0)
709 /* Check it's the same as the first chip we identified.
710 * M-Systems say that any given DiskOnChip device should only
711 * contain _one_ type of flash part, although that's not a
712 * hardware restriction. */
714 if (doc->mfr == mfr && doc->id == id)
715 return 1; /* This is another the same the first */
717 printf("Flash chip at floor %d, chip %d is different:\n",
721 /* Print and store the manufacturer and ID codes. */
722 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
723 if (mfr == nand_flash_ids[i].manufacture_id &&
724 id == nand_flash_ids[i].model_id) {
726 printf("Flash chip found: Manufacturer ID: %2.2X, "
727 "Chip ID: %2.2X (%s)\n", mfr, id,
728 nand_flash_ids[i].name);
734 nand_flash_ids[i].chipshift;
735 doc->page256 = nand_flash_ids[i].page256;
737 nand_flash_ids[i].pageadrlen;
739 nand_flash_ids[i].erasesize;
741 nand_flash_ids[i].name;
750 /* We haven't fully identified the chip. Print as much as we know. */
751 printf("Unknown flash chip found: %2.2X %2.2X\n",
758 /* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */
760 static void DoC_ScanChips(struct DiskOnChip *this)
763 int numchips[MAX_FLOORS];
764 int maxchips = MAX_CHIPS;
771 if (DoC_is_Millennium(this))
772 maxchips = MAX_CHIPS_MIL;
774 /* For each floor, find the number of valid chips it contains */
775 for (floor = 0; floor < MAX_FLOORS; floor++) {
778 for (chip = 0; chip < maxchips && ret != 0; chip++) {
780 ret = DoC_IdentChip(this, floor, chip);
788 /* If there are none at all that we recognise, bail */
789 if (!this->numchips) {
790 puts ("No flash chips recognised.\n");
794 /* Allocate an array to hold the information for each chip */
795 this->chips = malloc(sizeof(struct Nand) * this->numchips);
797 puts ("No memory for allocating chip info structures\n");
803 /* Fill out the chip array with {floor, chipno} for each
804 * detected chip in the device. */
805 for (floor = 0; floor < MAX_FLOORS; floor++) {
806 for (chip = 0; chip < numchips[floor]; chip++) {
807 this->chips[ret].floor = floor;
808 this->chips[ret].chip = chip;
809 this->chips[ret].curadr = 0;
810 this->chips[ret].curmode = 0x50;
815 /* Calculate and print the total size of the device */
816 this->totlen = this->numchips * (1 << this->chipshift);
819 printf("%d flash chips found. Total DiskOnChip size: %ld MB\n",
820 this->numchips, this->totlen >> 20);
824 /* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
825 * various device information of the NFTL partition and Bad Unit Table. Update
826 * the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
827 * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
829 static int find_boot_record(struct NFTLrecord *nftl)
833 unsigned int block, boot_record_count = 0;
836 struct NFTLMediaHeader *mh = &nftl->MediaHdr;
839 nftl->MediaUnit = BLOCK_NIL;
840 nftl->SpareMediaUnit = BLOCK_NIL;
842 /* search for a valid boot record */
843 for (block = 0; block < nftl->nb_blocks; block++) {
846 /* Check for ANAND header first. Then can whinge if it's found but later
848 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize, SECTORSIZE,
849 (size_t *)&retlen, buf, NULL))) {
850 static int warncount = 5;
853 printf("Block read at 0x%x failed\n", block * nftl->EraseSize);
855 puts ("Further failures for this block will not be printed\n");
860 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
861 /* ANAND\0 not found. Continue */
863 printf("ANAND header not found at 0x%x\n", block * nftl->EraseSize);
869 printf("ANAND header found at 0x%x\n", block * nftl->EraseSize);
872 /* To be safer with BIOS, also use erase mark as discriminant */
873 if ((ret = doc_read_oob(nftl->mtd, block * nftl->EraseSize + SECTORSIZE + 8,
874 8, (size_t *)&retlen, (uchar *)&h1) < 0)) {
876 printf("ANAND header found at 0x%x, but OOB data read failed\n",
877 block * nftl->EraseSize);
882 /* OK, we like it. */
884 if (boot_record_count) {
885 /* We've already processed one. So we just check if
886 this one is the same as the first one we found */
887 if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
889 printf("NFTL Media Headers at 0x%x and 0x%x disagree.\n",
890 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
892 /* if (debug) Print both side by side */
895 if (boot_record_count == 1)
896 nftl->SpareMediaUnit = block;
902 /* This is the first we've seen. Copy the media header structure into place */
903 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
905 /* Do some sanity checks on it */
906 if (mh->UnitSizeFactor == 0) {
908 puts ("UnitSizeFactor 0x00 detected.\n"
909 "This violates the spec but we think we know what it means...\n");
911 } else if (mh->UnitSizeFactor != 0xff) {
912 printf ("Sorry, we don't support UnitSizeFactor "
917 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
918 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
919 printf ("NFTL Media Header sanity check failed:\n"
920 "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
921 nftl->nb_boot_blocks, nftl->nb_blocks);
925 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
926 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
927 printf ("NFTL Media Header sanity check failed:\n"
928 "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
931 nftl->nb_boot_blocks);
935 nftl->nr_sects = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
937 /* If we're not using the last sectors in the device for some reason,
938 reduce nb_blocks accordingly so we forget they're there */
939 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
941 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
942 for (i = 0; i < nftl->nb_blocks; i++) {
943 if ((i & (SECTORSIZE - 1)) == 0) {
944 /* read one sector for every SECTORSIZE of blocks */
945 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize +
946 i + SECTORSIZE, SECTORSIZE,
947 (size_t *)&retlen, buf, (uchar *)&oob)) < 0) {
948 puts ("Read of bad sector table failed\n");
952 /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
953 if (buf[i & (SECTORSIZE - 1)] != 0xff)
954 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
957 nftl->MediaUnit = block;
960 } /* foreach (block) */
962 return boot_record_count?0:-1;
965 /* This routine is made available to other mtd code via
966 * inter_module_register. It must only be accessed through
967 * inter_module_get which will bump the use count of this module. The
968 * addresses passed back in mtd are valid as long as the use count of
969 * this module is non-zero, i.e. between inter_module_get and
970 * inter_module_put. Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
972 static void DoC2k_init(struct DiskOnChip* this)
974 struct NFTLrecord *nftl;
976 switch (this->ChipID) {
977 case DOC_ChipID_Doc2k:
978 this->name = "DiskOnChip 2000";
979 this->ioreg = DoC_2k_CDSN_IO;
981 case DOC_ChipID_DocMil:
982 this->name = "DiskOnChip Millennium";
983 this->ioreg = DoC_Mil_CDSN_IO;
988 printf("%s found at address 0x%lX\n", this->name,
998 /* Ident all the chips present. */
1000 if ((!this->numchips) || (!this->chips))
1005 /* Get physical parameters */
1006 nftl->EraseSize = this->erasesize;
1007 nftl->nb_blocks = this->totlen / this->erasesize;
1010 if (find_boot_record(nftl) != 0)
1011 this->nftl_found = 0;
1013 this->nftl_found = 1;
1015 printf("%s @ 0x%lX, %ld MB\n", this->name, this->physadr, this->totlen >> 20);
1018 int doc_read_ecc(struct DiskOnChip* this, loff_t from, size_t len,
1019 size_t * retlen, u_char * buf, u_char * eccbuf)
1021 unsigned long docptr;
1022 struct Nand *mychip;
1023 unsigned char syndrome[6];
1024 volatile char dummy;
1025 int i, len256 = 0, ret=0;
1027 docptr = this->virtadr;
1029 /* Don't allow read past end of device */
1030 if (from >= this->totlen) {
1031 puts ("Out of flash\n");
1035 /* Don't allow a single read to cross a 512-byte block boundary */
1036 if (from + len > ((from | 0x1ff) + 1))
1037 len = ((from | 0x1ff) + 1) - from;
1039 /* The ECC will not be calculated correctly if less than 512 is read */
1040 if (len != 0x200 && eccbuf)
1041 printf("ECC needs a full sector read (adr: %lx size %lx)\n",
1042 (long) from, (long) len);
1045 printf("DoC_Read (adr: %lx size %lx)\n", (long) from, (long) len);
1048 /* Find the chip which is to be used and select it */
1049 mychip = &this->chips[shr(from, this->chipshift)];
1051 if (this->curfloor != mychip->floor) {
1052 DoC_SelectFloor(this, mychip->floor);
1053 DoC_SelectChip(this, mychip->chip);
1054 } else if (this->curchip != mychip->chip) {
1055 DoC_SelectChip(this, mychip->chip);
1058 this->curfloor = mychip->floor;
1059 this->curchip = mychip->chip;
1063 && (from & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1065 DoC_Address(this, ADDR_COLUMN_PAGE, from, CDSN_CTRL_WP,
1069 /* Prime the ECC engine */
1070 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1071 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
1073 /* disable the ECC engine */
1074 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1075 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1078 /* treat crossing 256-byte sector for 2M x 8bits devices */
1079 if (this->page256 && from + len > (from | 0xff) + 1) {
1080 len256 = (from | 0xff) + 1 - from;
1081 DoC_ReadBuf(this, buf, len256);
1083 DoC_Command(this, NAND_CMD_READ0, CDSN_CTRL_WP);
1084 DoC_Address(this, ADDR_COLUMN_PAGE, from + len256,
1085 CDSN_CTRL_WP, CDSN_CTRL_ECC_IO);
1088 DoC_ReadBuf(this, &buf[len256], len - len256);
1090 /* Let the caller know we completed it */
1094 /* Read the ECC data through the DiskOnChip ECC logic */
1095 /* Note: this will work even with 2M x 8bit devices as */
1096 /* they have 8 bytes of OOB per 256 page. mf. */
1097 DoC_ReadBuf(this, eccbuf, 6);
1099 /* Flush the pipeline */
1100 if (DoC_is_Millennium(this)) {
1101 dummy = ReadDOC(docptr, ECCConf);
1102 dummy = ReadDOC(docptr, ECCConf);
1103 i = ReadDOC(docptr, ECCConf);
1105 dummy = ReadDOC(docptr, 2k_ECCStatus);
1106 dummy = ReadDOC(docptr, 2k_ECCStatus);
1107 i = ReadDOC(docptr, 2k_ECCStatus);
1110 /* Check the ECC Status */
1113 /* There was an ECC error */
1115 printf("DiskOnChip ECC Error: Read at %lx\n", (long)from);
1117 /* Read the ECC syndrom through the DiskOnChip ECC logic.
1118 These syndrome will be all ZERO when there is no error */
1119 for (i = 0; i < 6; i++) {
1121 ReadDOC(docptr, ECCSyndrome0 + i);
1123 nb_errors = doc_decode_ecc(buf, syndrome);
1126 printf("Errors corrected: %x\n", nb_errors);
1128 if (nb_errors < 0) {
1129 /* We return error, but have actually done the read. Not that
1130 this can be told to user-space, via sys_read(), but at least
1131 MTD-aware stuff can know about it by checking *retlen */
1132 printf("ECC Errors at %lx\n", (long)from);
1138 printf("ECC DATA at %lxB: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1139 (long)from, eccbuf[0], eccbuf[1], eccbuf[2],
1140 eccbuf[3], eccbuf[4], eccbuf[5]);
1143 /* disable the ECC engine */
1144 WriteDOC(DOC_ECC_DIS, docptr , ECCConf);
1147 /* according to 11.4.1, we need to wait for the busy line
1148 * drop if we read to the end of the page. */
1149 if(0 == ((from + *retlen) & 0x1ff))
1151 DoC_WaitReady(this);
1157 int doc_write_ecc(struct DiskOnChip* this, loff_t to, size_t len,
1158 size_t * retlen, const u_char * buf,
1161 int di; /* Yes, DI is a hangover from when I was disassembling the binary driver */
1162 unsigned long docptr;
1163 volatile char dummy;
1165 struct Nand *mychip;
1167 docptr = this->virtadr;
1169 /* Don't allow write past end of device */
1170 if (to >= this->totlen) {
1171 puts ("Out of flash\n");
1175 /* Don't allow a single write to cross a 512-byte block boundary */
1176 if (to + len > ((to | 0x1ff) + 1))
1177 len = ((to | 0x1ff) + 1) - to;
1179 /* The ECC will not be calculated correctly if less than 512 is written */
1180 if (len != 0x200 && eccbuf)
1181 printf("ECC needs a full sector write (adr: %lx size %lx)\n",
1182 (long) to, (long) len);
1184 /* printf("DoC_Write (adr: %lx size %lx)\n", (long) to, (long) len); */
1186 /* Find the chip which is to be used and select it */
1187 mychip = &this->chips[shr(to, this->chipshift)];
1189 if (this->curfloor != mychip->floor) {
1190 DoC_SelectFloor(this, mychip->floor);
1191 DoC_SelectChip(this, mychip->chip);
1192 } else if (this->curchip != mychip->chip) {
1193 DoC_SelectChip(this, mychip->chip);
1196 this->curfloor = mychip->floor;
1197 this->curchip = mychip->chip;
1199 /* Set device to main plane of flash */
1200 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1203 && (to & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1206 DoC_Command(this, NAND_CMD_SEQIN, 0);
1207 DoC_Address(this, ADDR_COLUMN_PAGE, to, 0, CDSN_CTRL_ECC_IO);
1210 /* Prime the ECC engine */
1211 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1212 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
1214 /* disable the ECC engine */
1215 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1216 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1219 /* treat crossing 256-byte sector for 2M x 8bits devices */
1220 if (this->page256 && to + len > (to | 0xff) + 1) {
1221 len256 = (to | 0xff) + 1 - to;
1222 DoC_WriteBuf(this, buf, len256);
1224 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1226 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1227 /* There's an implicit DoC_WaitReady() in DoC_Command */
1229 dummy = ReadDOC(docptr, CDSNSlowIO);
1232 if (ReadDOC_(docptr, this->ioreg) & 1) {
1233 puts ("Error programming flash\n");
1234 /* Error in programming */
1239 DoC_Command(this, NAND_CMD_SEQIN, 0);
1240 DoC_Address(this, ADDR_COLUMN_PAGE, to + len256, 0,
1244 DoC_WriteBuf(this, &buf[len256], len - len256);
1247 WriteDOC(CDSN_CTRL_ECC_IO | CDSN_CTRL_CE, docptr,
1250 if (DoC_is_Millennium(this)) {
1251 WriteDOC(0, docptr, NOP);
1252 WriteDOC(0, docptr, NOP);
1253 WriteDOC(0, docptr, NOP);
1255 WriteDOC_(0, docptr, this->ioreg);
1256 WriteDOC_(0, docptr, this->ioreg);
1257 WriteDOC_(0, docptr, this->ioreg);
1260 /* Read the ECC data through the DiskOnChip ECC logic */
1261 for (di = 0; di < 6; di++) {
1262 eccbuf[di] = ReadDOC(docptr, ECCSyndrome0 + di);
1265 /* Reset the ECC engine */
1266 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1270 ("OOB data at %lx is %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1271 (long) to, eccbuf[0], eccbuf[1], eccbuf[2], eccbuf[3],
1272 eccbuf[4], eccbuf[5]);
1276 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1278 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1279 /* There's an implicit DoC_WaitReady() in DoC_Command */
1281 dummy = ReadDOC(docptr, CDSNSlowIO);
1284 if (ReadDOC_(docptr, this->ioreg) & 1) {
1285 puts ("Error programming flash\n");
1286 /* Error in programming */
1291 /* Let the caller know we completed it */
1299 /* Write the ECC data to flash */
1300 for (di=0; di<6; di++)
1306 ret = doc_write_oob(this, to, 8, &dummy, x);
1312 int doc_read_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1313 size_t * retlen, u_char * buf)
1315 int len256 = 0, ret;
1316 unsigned long docptr;
1317 struct Nand *mychip;
1319 docptr = this->virtadr;
1321 mychip = &this->chips[shr(ofs, this->chipshift)];
1323 if (this->curfloor != mychip->floor) {
1324 DoC_SelectFloor(this, mychip->floor);
1325 DoC_SelectChip(this, mychip->chip);
1326 } else if (this->curchip != mychip->chip) {
1327 DoC_SelectChip(this, mychip->chip);
1329 this->curfloor = mychip->floor;
1330 this->curchip = mychip->chip;
1332 /* update address for 2M x 8bit devices. OOB starts on the second */
1333 /* page to maintain compatibility with doc_read_ecc. */
1334 if (this->page256) {
1341 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1342 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, CDSN_CTRL_WP, 0);
1344 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1345 /* Note: datasheet says it should automaticaly wrap to the */
1346 /* next OOB block, but it didn't work here. mf. */
1347 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1348 len256 = (ofs | 0x7) + 1 - ofs;
1349 DoC_ReadBuf(this, buf, len256);
1351 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1352 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff),
1356 DoC_ReadBuf(this, &buf[len256], len - len256);
1359 /* Reading the full OOB data drops us off of the end of the page,
1360 * causing the flash device to go into busy mode, so we need
1361 * to wait until ready 11.4.1 and Toshiba TC58256FT docs */
1363 ret = DoC_WaitReady(this);
1369 int doc_write_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1370 size_t * retlen, const u_char * buf)
1373 unsigned long docptr = this->virtadr;
1374 struct Nand *mychip = &this->chips[shr(ofs, this->chipshift)];
1378 printf("doc_write_oob(%lx, %d): %2.2X %2.2X %2.2X %2.2X ... %2.2X %2.2X .. %2.2X %2.2X\n",
1379 (long)ofs, len, buf[0], buf[1], buf[2], buf[3],
1380 buf[8], buf[9], buf[14],buf[15]);
1383 /* Find the chip which is to be used and select it */
1384 if (this->curfloor != mychip->floor) {
1385 DoC_SelectFloor(this, mychip->floor);
1386 DoC_SelectChip(this, mychip->chip);
1387 } else if (this->curchip != mychip->chip) {
1388 DoC_SelectChip(this, mychip->chip);
1390 this->curfloor = mychip->floor;
1391 this->curchip = mychip->chip;
1393 /* disable the ECC engine */
1394 WriteDOC (DOC_ECC_RESET, docptr, ECCConf);
1395 WriteDOC (DOC_ECC_DIS, docptr, ECCConf);
1397 /* Reset the chip, see Software Requirement 11.4 item 1. */
1398 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1400 /* issue the Read2 command to set the pointer to the Spare Data Area. */
1401 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1403 /* update address for 2M x 8bit devices. OOB starts on the second */
1404 /* page to maintain compatibility with doc_read_ecc. */
1405 if (this->page256) {
1412 /* issue the Serial Data In command to initial the Page Program process */
1413 DoC_Command(this, NAND_CMD_SEQIN, 0);
1414 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, 0, 0);
1416 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1417 /* Note: datasheet says it should automaticaly wrap to the */
1418 /* next OOB block, but it didn't work here. mf. */
1419 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1420 len256 = (ofs | 0x7) + 1 - ofs;
1421 DoC_WriteBuf(this, buf, len256);
1423 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1424 DoC_Command(this, NAND_CMD_STATUS, 0);
1425 /* DoC_WaitReady() is implicit in DoC_Command */
1427 dummy = ReadDOC(docptr, CDSNSlowIO);
1430 if (ReadDOC_(docptr, this->ioreg) & 1) {
1431 puts ("Error programming oob data\n");
1432 /* There was an error */
1436 DoC_Command(this, NAND_CMD_SEQIN, 0);
1437 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff), 0, 0);
1440 DoC_WriteBuf(this, &buf[len256], len - len256);
1442 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1443 DoC_Command(this, NAND_CMD_STATUS, 0);
1444 /* DoC_WaitReady() is implicit in DoC_Command */
1446 dummy = ReadDOC(docptr, CDSNSlowIO);
1449 if (ReadDOC_(docptr, this->ioreg) & 1) {
1450 puts ("Error programming oob data\n");
1451 /* There was an error */
1461 int doc_erase(struct DiskOnChip* this, loff_t ofs, size_t len)
1464 unsigned long docptr;
1465 struct Nand *mychip;
1467 if (ofs & (this->erasesize-1) || len & (this->erasesize-1)) {
1468 puts ("Offset and size must be sector aligned\n");
1472 docptr = this->virtadr;
1474 /* FIXME: Do this in the background. Use timers or schedule_task() */
1476 mychip = &this->chips[shr(ofs, this->chipshift)];
1478 if (this->curfloor != mychip->floor) {
1479 DoC_SelectFloor(this, mychip->floor);
1480 DoC_SelectChip(this, mychip->chip);
1481 } else if (this->curchip != mychip->chip) {
1482 DoC_SelectChip(this, mychip->chip);
1484 this->curfloor = mychip->floor;
1485 this->curchip = mychip->chip;
1487 DoC_Command(this, NAND_CMD_ERASE1, 0);
1488 DoC_Address(this, ADDR_PAGE, ofs, 0, 0);
1489 DoC_Command(this, NAND_CMD_ERASE2, 0);
1491 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1493 dummy = ReadDOC(docptr, CDSNSlowIO);
1496 if (ReadDOC_(docptr, this->ioreg) & 1) {
1497 printf("Error erasing at 0x%lx\n", (long)ofs);
1498 /* There was an error */
1501 ofs += this->erasesize;
1502 len -= this->erasesize;
1509 static inline int doccheck(unsigned long potential, unsigned long physadr)
1511 unsigned long window=potential;
1512 unsigned char tmp, ChipID;
1513 #ifndef DOC_PASSIVE_PROBE
1517 /* Routine copied from the Linux DOC driver */
1519 #ifdef CFG_DOCPROBE_55AA
1520 /* Check for 0x55 0xAA signature at beginning of window,
1521 this is no longer true once we remove the IPL (for Millennium */
1522 if (ReadDOC(window, Sig1) != 0x55 || ReadDOC(window, Sig2) != 0xaa)
1524 #endif /* CFG_DOCPROBE_55AA */
1526 #ifndef DOC_PASSIVE_PROBE
1527 /* It's not possible to cleanly detect the DiskOnChip - the
1528 * bootup procedure will put the device into reset mode, and
1529 * it's not possible to talk to it without actually writing
1530 * to the DOCControl register. So we store the current contents
1531 * of the DOCControl register's location, in case we later decide
1532 * that it's not a DiskOnChip, and want to put it back how we
1535 tmp2 = ReadDOC(window, DOCControl);
1537 /* Reset the DiskOnChip ASIC */
1538 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1539 window, DOCControl);
1540 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1541 window, DOCControl);
1543 /* Enable the DiskOnChip ASIC */
1544 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1545 window, DOCControl);
1546 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1547 window, DOCControl);
1548 #endif /* !DOC_PASSIVE_PROBE */
1550 ChipID = ReadDOC(window, ChipID);
1553 case DOC_ChipID_Doc2k:
1554 /* Check the TOGGLE bit in the ECC register */
1555 tmp = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
1556 if ((ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT) != tmp)
1560 case DOC_ChipID_DocMil:
1561 /* Check the TOGGLE bit in the ECC register */
1562 tmp = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
1563 if ((ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT) != tmp)
1568 #ifndef CFG_DOCPROBE_55AA
1570 * if the ID isn't the DoC2000 or DoCMillenium ID, so we can assume
1571 * the DOC is missing
1574 printf("Possible DiskOnChip with unknown ChipID %2.2X found at 0x%lx\n",
1578 #ifndef DOC_PASSIVE_PROBE
1579 /* Put back the contents of the DOCControl register, in case it's not
1580 * actually a DiskOnChip.
1582 WriteDOC(tmp2, window, DOCControl);
1587 puts ("DiskOnChip failed TOGGLE test, dropping.\n");
1589 #ifndef DOC_PASSIVE_PROBE
1590 /* Put back the contents of the DOCControl register: it's not a DiskOnChip */
1591 WriteDOC(tmp2, window, DOCControl);
1596 void doc_probe(unsigned long physadr)
1598 struct DiskOnChip *this = NULL;
1601 if ((ChipID = doccheck(physadr, physadr))) {
1603 for (i=0; i<CFG_MAX_DOC_DEVICE; i++) {
1604 if (doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN) {
1605 this = doc_dev_desc + i;
1611 puts ("Cannot allocate memory for data structures.\n");
1615 if (curr_device == -1)
1618 memset((char *)this, 0, sizeof(struct DiskOnChip));
1620 this->virtadr = physadr;
1621 this->physadr = physadr;
1622 this->ChipID = ChipID;
1626 puts ("No DiskOnChip found\n");