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