blob: 3d717c039d444a54c3cd756d8a8c44e0474abbc0 [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
17#ifdef CFG_DOC_SUPPORT_2000
18#define DoC_is_2000(doc) (doc->ChipID == DOC_ChipID_Doc2k)
19#else
20#define DoC_is_2000(doc) (0)
21#endif
22
23#ifdef CFG_DOC_SUPPORT_MILLENNIUM
24#define DoC_is_Millennium(doc) (doc->ChipID == DOC_ChipID_DocMil)
25#else
26#define DoC_is_Millennium(doc) (0)
27#endif
28
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
34 DOCControl register.
35
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
42 the machine.
43
44 If you have this problem, uncomment the following line:
45#define CFG_DOC_PASSIVE_PROBE
46*/
47
48#undef DOC_DEBUG
49#undef ECC_DEBUG
50#undef PSYCHO_DEBUG
51#undef NFTL_DEBUG
52
53static struct DiskOnChip doc_dev_desc[CFG_MAX_DOC_DEVICE];
54
55/* Current DOC Device */
56static int curr_device = -1;
57
Marian Balakowicz2fc000d2006-04-05 20:46:41 +020058/* Supported NAND flash devices */
59static 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},
81 {NULL,}
82};
83
wdenkc6097192002-11-03 00:24:07 +000084/* ------------------------------------------------------------------------- */
85
86int do_doc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
87{
88 int rcode = 0;
89
90 switch (argc) {
91 case 0:
92 case 1:
93 printf ("Usage:\n%s\n", cmdtp->usage);
94 return 1;
95 case 2:
wdenk8bde7f72003-06-27 21:31:46 +000096 if (strcmp(argv[1],"info") == 0) {
wdenkc6097192002-11-03 00:24:07 +000097 int i;
98
99 putc ('\n');
100
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]);
106 }
107 return 0;
108
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");
112 return 1;
113 }
114 printf ("\nDevice %d: ", curr_device);
115 doc_print(&doc_dev_desc[curr_device]);
116 return 0;
117 }
118 printf ("Usage:\n%s\n", cmdtp->usage);
119 return 1;
120 case 3:
121 if (strcmp(argv[1],"device") == 0) {
122 int dev = (int)simple_strtoul(argv[2], NULL, 10);
123
124 printf ("\nDevice %d: ", dev);
125 if (dev >= CFG_MAX_DOC_DEVICE) {
126 puts ("unknown device\n");
127 return 1;
128 }
129 doc_print(&doc_dev_desc[dev]);
130 /*doc_print (dev);*/
131
132 if (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN) {
133 return 1;
134 }
135
136 curr_device = dev;
137
138 puts ("... is now current device\n");
139
140 return 0;
141 }
142
143 printf ("Usage:\n%s\n", cmdtp->usage);
144 return 1;
145 default:
146 /* at least 4 args */
147
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);
153 int ret, total;
154
155 printf ("\nDOC %s: device %d offset %ld, size %ld ... ",
156 cmd ? "read" : "write", curr_device, off, size);
157
158 ret = doc_rw(doc_dev_desc + curr_device, cmd, off, size,
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200159 (size_t *)&total, (u_char*)addr);
wdenkc6097192002-11-03 00:24:07 +0000160
161 printf ("%d bytes %s: %s\n", total, cmd ? "read" : "write",
162 ret ? "ERROR" : "OK");
163
164 return ret;
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);
168 int ret;
169
170 printf ("\nDOC erase: device %d offset %ld, size %ld ... ",
171 curr_device, off, size);
172
173 ret = doc_erase (doc_dev_desc + curr_device, off, size);
174
175 printf("%s\n", ret ? "ERROR" : "OK");
176
177 return ret;
178 } else {
179 printf ("Usage:\n%s\n", cmdtp->usage);
180 rcode = 1;
181 }
182
183 return rcode;
184 }
185}
wdenk0d498392003-07-01 21:06:45 +0000186U_BOOT_CMD(
187 doc, 5, 1, do_doc,
wdenk8bde7f72003-06-27 21:31:46 +0000188 "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"
196);
wdenkc6097192002-11-03 00:24:07 +0000197
198int do_docboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
199{
200 char *boot_device = NULL;
201 char *ep;
202 int dev;
203 ulong cnt;
204 ulong addr;
205 ulong offset = 0;
206 image_header_t *hdr;
207 int rcode = 0;
208
Heiko Schocherfad63402007-07-13 09:54:17 +0200209 show_boot_progress (34);
wdenkc6097192002-11-03 00:24:07 +0000210 switch (argc) {
211 case 1:
212 addr = CFG_LOAD_ADDR;
213 boot_device = getenv ("bootdevice");
214 break;
215 case 2:
216 addr = simple_strtoul(argv[1], NULL, 16);
217 boot_device = getenv ("bootdevice");
218 break;
219 case 3:
220 addr = simple_strtoul(argv[1], NULL, 16);
221 boot_device = argv[2];
222 break;
223 case 4:
224 addr = simple_strtoul(argv[1], NULL, 16);
225 boot_device = argv[2];
226 offset = simple_strtoul(argv[3], NULL, 16);
227 break;
228 default:
229 printf ("Usage:\n%s\n", cmdtp->usage);
Heiko Schocherfad63402007-07-13 09:54:17 +0200230 show_boot_progress (-35);
wdenkc6097192002-11-03 00:24:07 +0000231 return 1;
232 }
233
Heiko Schocherfad63402007-07-13 09:54:17 +0200234 show_boot_progress (35);
wdenkc6097192002-11-03 00:24:07 +0000235 if (!boot_device) {
236 puts ("\n** No boot device **\n");
Heiko Schocherfad63402007-07-13 09:54:17 +0200237 show_boot_progress (-36);
wdenkc6097192002-11-03 00:24:07 +0000238 return 1;
239 }
Heiko Schocherfad63402007-07-13 09:54:17 +0200240 show_boot_progress (36);
wdenkc6097192002-11-03 00:24:07 +0000241
242 dev = simple_strtoul(boot_device, &ep, 16);
243
244 if ((dev >= CFG_MAX_DOC_DEVICE) ||
245 (doc_dev_desc[dev].ChipID == DOC_ChipID_UNKNOWN)) {
246 printf ("\n** Device %d not available\n", dev);
Heiko Schocherfad63402007-07-13 09:54:17 +0200247 show_boot_progress (-37);
wdenkc6097192002-11-03 00:24:07 +0000248 return 1;
249 }
Heiko Schocherfad63402007-07-13 09:54:17 +0200250 show_boot_progress (37);
wdenkc6097192002-11-03 00:24:07 +0000251
252 printf ("\nLoading from device %d: %s at 0x%lX (offset 0x%lX)\n",
253 dev, doc_dev_desc[dev].name, doc_dev_desc[dev].physadr,
254 offset);
255
256 if (doc_rw (doc_dev_desc + dev, 1, offset,
257 SECTORSIZE, NULL, (u_char *)addr)) {
258 printf ("** Read error on %d\n", dev);
Heiko Schocherfad63402007-07-13 09:54:17 +0200259 show_boot_progress (-38);
wdenkc6097192002-11-03 00:24:07 +0000260 return 1;
261 }
Heiko Schocherfad63402007-07-13 09:54:17 +0200262 show_boot_progress (38);
wdenkc6097192002-11-03 00:24:07 +0000263
264 hdr = (image_header_t *)addr;
265
266 if (hdr->ih_magic == IH_MAGIC) {
267
268 print_image_hdr (hdr);
269
Wolfgang Denkdc013d42006-03-12 01:59:35 +0100270 cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
wdenkc6097192002-11-03 00:24:07 +0000271 cnt -= SECTORSIZE;
272 } else {
273 puts ("\n** Bad Magic Number **\n");
Heiko Schocherfad63402007-07-13 09:54:17 +0200274 show_boot_progress (-39);
wdenkc6097192002-11-03 00:24:07 +0000275 return 1;
276 }
Heiko Schocherfad63402007-07-13 09:54:17 +0200277 show_boot_progress (39);
wdenkc6097192002-11-03 00:24:07 +0000278
279 if (doc_rw (doc_dev_desc + dev, 1, offset + SECTORSIZE, cnt,
280 NULL, (u_char *)(addr+SECTORSIZE))) {
281 printf ("** Read error on %d\n", dev);
Heiko Schocherfad63402007-07-13 09:54:17 +0200282 show_boot_progress (-40);
wdenkc6097192002-11-03 00:24:07 +0000283 return 1;
284 }
Heiko Schocherfad63402007-07-13 09:54:17 +0200285 show_boot_progress (40);
wdenkc6097192002-11-03 00:24:07 +0000286
287 /* Loading ok, update default load address */
288
289 load_addr = addr;
290
291 /* Check if we should attempt an auto-start */
292 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
293 char *local_args[2];
294 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
295
296 local_args[0] = argv[0];
297 local_args[1] = NULL;
298
299 printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
300
301 do_bootm (cmdtp, 0, 1, local_args);
302 rcode = 1;
303 }
304 return rcode;
305}
306
wdenk0d498392003-07-01 21:06:45 +0000307U_BOOT_CMD(
308 docboot, 4, 1, do_docboot,
wdenk8bde7f72003-06-27 21:31:46 +0000309 "docboot - boot from DOC device\n",
310 "loadAddr dev\n"
311);
312
wdenkc6097192002-11-03 00:24:07 +0000313int doc_rw (struct DiskOnChip* this, int cmd,
314 loff_t from, size_t len,
315 size_t * retlen, u_char * buf)
316{
317 int noecc, ret = 0, n, total = 0;
318 char eccbuf[6];
319
320 while(len) {
321 /* The ECC will not be calculated correctly if
322 less than 512 is written or read */
323 noecc = (from != (from | 0x1ff) + 1) || (len < 0x200);
324
325 if (cmd)
326 ret = doc_read_ecc(this, from, len,
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200327 (size_t *)&n, (u_char*)buf,
328 noecc ? (uchar *)NULL : (uchar *)eccbuf);
wdenkc6097192002-11-03 00:24:07 +0000329 else
330 ret = doc_write_ecc(this, from, len,
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200331 (size_t *)&n, (u_char*)buf,
332 noecc ? (uchar *)NULL : (uchar *)eccbuf);
wdenkc6097192002-11-03 00:24:07 +0000333
334 if (ret)
335 break;
336
337 from += n;
338 buf += n;
339 total += n;
340 len -= n;
341 }
342
343 if (retlen)
344 *retlen = total;
345
346 return ret;
347}
348
349void doc_print(struct DiskOnChip *this) {
350 printf("%s at 0x%lX,\n"
351 "\t %d chip%s %s, size %d MB, \n"
352 "\t total size %ld MB, sector size %ld kB\n",
353 this->name, this->physadr, this->numchips,
354 this->numchips>1 ? "s" : "", this->chips_name,
355 1 << (this->chipshift - 20),
356 this->totlen >> 20, this->erasesize >> 10);
357
358 if (this->nftl_found) {
359 struct NFTLrecord *nftl = &this->nftl;
360 unsigned long bin_size, flash_size;
361
362 bin_size = nftl->nb_boot_blocks * this->erasesize;
363 flash_size = (nftl->nb_blocks - nftl->nb_boot_blocks) * this->erasesize;
364
365 printf("\t NFTL boot record:\n"
366 "\t Binary partition: size %ld%s\n"
367 "\t Flash disk partition: size %ld%s, offset 0x%lx\n",
368 bin_size > (1 << 20) ? bin_size >> 20 : bin_size >> 10,
369 bin_size > (1 << 20) ? "MB" : "kB",
370 flash_size > (1 << 20) ? flash_size >> 20 : flash_size >> 10,
371 flash_size > (1 << 20) ? "MB" : "kB", bin_size);
372 } else {
373 puts ("\t No NFTL boot record found.\n");
374 }
375}
376
377/* ------------------------------------------------------------------------- */
378
379/* This function is needed to avoid calls of the __ashrdi3 function. */
380static int shr(int val, int shift) {
381 return val >> shift;
382}
383
384/* Perform the required delay cycles by reading from the appropriate register */
385static void DoC_Delay(struct DiskOnChip *doc, unsigned short cycles)
386{
387 volatile char dummy;
388 int i;
389
390 for (i = 0; i < cycles; i++) {
391 if (DoC_is_Millennium(doc))
392 dummy = ReadDOC(doc->virtadr, NOP);
393 else
394 dummy = ReadDOC(doc->virtadr, DOCStatus);
395 }
396
397}
398
399/* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
400static int _DoC_WaitReady(struct DiskOnChip *doc)
401{
402 unsigned long docptr = doc->virtadr;
403 unsigned long start = get_timer(0);
404
405#ifdef PSYCHO_DEBUG
406 puts ("_DoC_WaitReady called for out-of-line wait\n");
407#endif
408
409 /* Out-of-line routine to wait for chip response */
410 while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
411#ifdef CFG_DOC_SHORT_TIMEOUT
412 /* it seems that after a certain time the DoC deasserts
413 * the CDSN_CTRL_FR_B although it is not ready...
414 * using a short timout solve this (timer increments every ms) */
415 if (get_timer(start) > 10) {
416 return DOC_ETIMEOUT;
417 }
418#else
419 if (get_timer(start) > 10 * 1000) {
420 puts ("_DoC_WaitReady timed out.\n");
421 return DOC_ETIMEOUT;
422 }
423#endif
424 udelay(1);
wdenk8bde7f72003-06-27 21:31:46 +0000425 }
wdenkc6097192002-11-03 00:24:07 +0000426
427 return 0;
428}
429
430static int DoC_WaitReady(struct DiskOnChip *doc)
431{
432 unsigned long docptr = doc->virtadr;
433 /* This is inline, to optimise the common case, where it's ready instantly */
434 int ret = 0;
435
436 /* 4 read form NOP register should be issued in prior to the read from CDSNControl
437 see Software Requirement 11.4 item 2. */
438 DoC_Delay(doc, 4);
439
440 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
441 /* Call the out-of-line routine to wait */
442 ret = _DoC_WaitReady(doc);
443
444 /* issue 2 read from NOP register after reading from CDSNControl register
445 see Software Requirement 11.4 item 2. */
446 DoC_Delay(doc, 2);
447
448 return ret;
449}
450
451/* DoC_Command: Send a flash command to the flash chip through the CDSN Slow IO register to
452 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
453 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
454
455static inline int DoC_Command(struct DiskOnChip *doc, unsigned char command,
456 unsigned char xtraflags)
457{
458 unsigned long docptr = doc->virtadr;
459
460 if (DoC_is_2000(doc))
461 xtraflags |= CDSN_CTRL_FLASH_IO;
462
463 /* Assert the CLE (Command Latch Enable) line to the flash chip */
464 WriteDOC(xtraflags | CDSN_CTRL_CLE | CDSN_CTRL_CE, docptr, CDSNControl);
465 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
466
467 if (DoC_is_Millennium(doc))
468 WriteDOC(command, docptr, CDSNSlowIO);
469
470 /* Send the command */
471 WriteDOC_(command, docptr, doc->ioreg);
472
473 /* Lower the CLE line */
474 WriteDOC(xtraflags | CDSN_CTRL_CE, docptr, CDSNControl);
475 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
476
477 /* Wait for the chip to respond - Software requirement 11.4.1 (extended for any command) */
478 return DoC_WaitReady(doc);
479}
480
481/* DoC_Address: Set the current address for the flash chip through the CDSN Slow IO register to
482 bypass the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
483 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
484
485static int DoC_Address(struct DiskOnChip *doc, int numbytes, unsigned long ofs,
486 unsigned char xtraflags1, unsigned char xtraflags2)
487{
488 unsigned long docptr;
489 int i;
490
491 docptr = doc->virtadr;
492
493 if (DoC_is_2000(doc))
494 xtraflags1 |= CDSN_CTRL_FLASH_IO;
495
496 /* Assert the ALE (Address Latch Enable) line to the flash chip */
497 WriteDOC(xtraflags1 | CDSN_CTRL_ALE | CDSN_CTRL_CE, docptr, CDSNControl);
498
499 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
500
501 /* Send the address */
502 /* Devices with 256-byte page are addressed as:
503 Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
504 * there is no device on the market with page256
505 and more than 24 bits.
506 Devices with 512-byte page are addressed as:
507 Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
508 * 25-31 is sent only if the chip support it.
509 * bit 8 changes the read command to be sent
510 (NAND_CMD_READ0 or NAND_CMD_READ1).
511 */
512
513 if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE) {
514 if (DoC_is_Millennium(doc))
515 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
516 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
517 }
518
519 if (doc->page256) {
520 ofs = ofs >> 8;
521 } else {
522 ofs = ofs >> 9;
523 }
524
525 if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE) {
526 for (i = 0; i < doc->pageadrlen; i++, ofs = ofs >> 8) {
527 if (DoC_is_Millennium(doc))
528 WriteDOC(ofs & 0xff, docptr, CDSNSlowIO);
529 WriteDOC_(ofs & 0xff, docptr, doc->ioreg);
530 }
531 }
532
533 DoC_Delay(doc, 2); /* Needed for some slow flash chips. mf. */
534
535 /* FIXME: The SlowIO's for millennium could be replaced by
536 a single WritePipeTerm here. mf. */
537
538 /* Lower the ALE line */
539 WriteDOC(xtraflags1 | xtraflags2 | CDSN_CTRL_CE, docptr,
540 CDSNControl);
541
542 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
543
544 /* Wait for the chip to respond - Software requirement 11.4.1 */
545 return DoC_WaitReady(doc);
546}
547
wdenk7152b1d2003-09-05 23:19:14 +0000548/* Read a buffer from DoC, taking care of Millennium oddities */
wdenkc6097192002-11-03 00:24:07 +0000549static void DoC_ReadBuf(struct DiskOnChip *doc, u_char * buf, int len)
550{
551 volatile int dummy;
552 int modulus = 0xffff;
553 unsigned long docptr;
554 int i;
555
556 docptr = doc->virtadr;
557
558 if (len <= 0)
559 return;
560
561 if (DoC_is_Millennium(doc)) {
562 /* Read the data via the internal pipeline through CDSN IO register,
563 see Pipelined Read Operations 11.3 */
564 dummy = ReadDOC(docptr, ReadPipeInit);
565
566 /* Millennium should use the LastDataRead register - Pipeline Reads */
567 len--;
568
569 /* This is needed for correctly ECC calculation */
570 modulus = 0xff;
571 }
572
573 for (i = 0; i < len; i++)
574 buf[i] = ReadDOC_(docptr, doc->ioreg + (i & modulus));
575
576 if (DoC_is_Millennium(doc)) {
577 buf[i] = ReadDOC(docptr, LastDataRead);
578 }
579}
580
wdenk7152b1d2003-09-05 23:19:14 +0000581/* Write a buffer to DoC, taking care of Millennium oddities */
wdenkc6097192002-11-03 00:24:07 +0000582static void DoC_WriteBuf(struct DiskOnChip *doc, const u_char * buf, int len)
583{
584 unsigned long docptr;
585 int i;
586
587 docptr = doc->virtadr;
588
589 if (len <= 0)
590 return;
591
592 for (i = 0; i < len; i++)
593 WriteDOC_(buf[i], docptr, doc->ioreg + i);
594
595 if (DoC_is_Millennium(doc)) {
596 WriteDOC(0x00, docptr, WritePipeTerm);
597 }
598}
599
600
601/* DoC_SelectChip: Select a given flash chip within the current floor */
602
603static inline int DoC_SelectChip(struct DiskOnChip *doc, int chip)
604{
605 unsigned long docptr = doc->virtadr;
606
607 /* Software requirement 11.4.4 before writing DeviceSelect */
608 /* Deassert the CE line to eliminate glitches on the FCE# outputs */
609 WriteDOC(CDSN_CTRL_WP, docptr, CDSNControl);
610 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
611
612 /* Select the individual flash chip requested */
613 WriteDOC(chip, docptr, CDSNDeviceSelect);
614 DoC_Delay(doc, 4);
615
616 /* Reassert the CE line */
617 WriteDOC(CDSN_CTRL_CE | CDSN_CTRL_FLASH_IO | CDSN_CTRL_WP, docptr,
618 CDSNControl);
619 DoC_Delay(doc, 4); /* Software requirement 11.4.3 for Millennium */
620
621 /* Wait for it to be ready */
622 return DoC_WaitReady(doc);
623}
624
625/* DoC_SelectFloor: Select a given floor (bank of flash chips) */
626
627static inline int DoC_SelectFloor(struct DiskOnChip *doc, int floor)
628{
629 unsigned long docptr = doc->virtadr;
630
631 /* Select the floor (bank) of chips required */
632 WriteDOC(floor, docptr, FloorSelect);
633
634 /* Wait for the chip to be ready */
635 return DoC_WaitReady(doc);
636}
637
638/* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */
639
640static int DoC_IdentChip(struct DiskOnChip *doc, int floor, int chip)
641{
642 int mfr, id, i;
643 volatile char dummy;
644
645 /* Page in the required floor/chip */
646 DoC_SelectFloor(doc, floor);
647 DoC_SelectChip(doc, chip);
648
649 /* Reset the chip */
650 if (DoC_Command(doc, NAND_CMD_RESET, CDSN_CTRL_WP)) {
651#ifdef DOC_DEBUG
652 printf("DoC_Command (reset) for %d,%d returned true\n",
653 floor, chip);
654#endif
655 return 0;
656 }
657
658
659 /* Read the NAND chip ID: 1. Send ReadID command */
660 if (DoC_Command(doc, NAND_CMD_READID, CDSN_CTRL_WP)) {
661#ifdef DOC_DEBUG
662 printf("DoC_Command (ReadID) for %d,%d returned true\n",
663 floor, chip);
664#endif
665 return 0;
666 }
667
668 /* Read the NAND chip ID: 2. Send address byte zero */
669 DoC_Address(doc, ADDR_COLUMN, 0, CDSN_CTRL_WP, 0);
670
671 /* Read the manufacturer and device id codes from the device */
672
673 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
674 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
675 DoC_Delay(doc, 2);
676 mfr = ReadDOC_(doc->virtadr, doc->ioreg);
677
678 /* CDSN Slow IO register see Software Requirement 11.4 item 5. */
679 dummy = ReadDOC(doc->virtadr, CDSNSlowIO);
680 DoC_Delay(doc, 2);
681 id = ReadDOC_(doc->virtadr, doc->ioreg);
682
683 /* No response - return failure */
684 if (mfr == 0xff || mfr == 0)
685 return 0;
686
687 /* Check it's the same as the first chip we identified.
688 * M-Systems say that any given DiskOnChip device should only
689 * contain _one_ type of flash part, although that's not a
690 * hardware restriction. */
691 if (doc->mfr) {
692 if (doc->mfr == mfr && doc->id == id)
693 return 1; /* This is another the same the first */
694 else
695 printf("Flash chip at floor %d, chip %d is different:\n",
696 floor, chip);
697 }
698
699 /* Print and store the manufacturer and ID codes. */
700 for (i = 0; nand_flash_ids[i].name != NULL; i++) {
701 if (mfr == nand_flash_ids[i].manufacture_id &&
702 id == nand_flash_ids[i].model_id) {
703#ifdef DOC_DEBUG
704 printf("Flash chip found: Manufacturer ID: %2.2X, "
705 "Chip ID: %2.2X (%s)\n", mfr, id,
706 nand_flash_ids[i].name);
707#endif
708 if (!doc->mfr) {
709 doc->mfr = mfr;
710 doc->id = id;
711 doc->chipshift =
712 nand_flash_ids[i].chipshift;
713 doc->page256 = nand_flash_ids[i].page256;
714 doc->pageadrlen =
715 nand_flash_ids[i].pageadrlen;
716 doc->erasesize =
717 nand_flash_ids[i].erasesize;
718 doc->chips_name =
719 nand_flash_ids[i].name;
720 return 1;
721 }
722 return 0;
723 }
724 }
725
726
727#ifdef DOC_DEBUG
728 /* We haven't fully identified the chip. Print as much as we know. */
729 printf("Unknown flash chip found: %2.2X %2.2X\n",
730 id, mfr);
731#endif
732
733 return 0;
734}
735
736/* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */
737
738static void DoC_ScanChips(struct DiskOnChip *this)
739{
740 int floor, chip;
741 int numchips[MAX_FLOORS];
742 int maxchips = MAX_CHIPS;
743 int ret = 1;
744
745 this->numchips = 0;
746 this->mfr = 0;
747 this->id = 0;
748
749 if (DoC_is_Millennium(this))
750 maxchips = MAX_CHIPS_MIL;
751
752 /* For each floor, find the number of valid chips it contains */
753 for (floor = 0; floor < MAX_FLOORS; floor++) {
754 ret = 1;
755 numchips[floor] = 0;
756 for (chip = 0; chip < maxchips && ret != 0; chip++) {
757
758 ret = DoC_IdentChip(this, floor, chip);
759 if (ret) {
760 numchips[floor]++;
761 this->numchips++;
762 }
763 }
764 }
765
766 /* If there are none at all that we recognise, bail */
767 if (!this->numchips) {
768 puts ("No flash chips recognised.\n");
769 return;
770 }
771
772 /* Allocate an array to hold the information for each chip */
773 this->chips = malloc(sizeof(struct Nand) * this->numchips);
774 if (!this->chips) {
775 puts ("No memory for allocating chip info structures\n");
776 return;
777 }
778
779 ret = 0;
780
781 /* Fill out the chip array with {floor, chipno} for each
782 * detected chip in the device. */
783 for (floor = 0; floor < MAX_FLOORS; floor++) {
784 for (chip = 0; chip < numchips[floor]; chip++) {
785 this->chips[ret].floor = floor;
786 this->chips[ret].chip = chip;
787 this->chips[ret].curadr = 0;
788 this->chips[ret].curmode = 0x50;
789 ret++;
790 }
791 }
792
793 /* Calculate and print the total size of the device */
794 this->totlen = this->numchips * (1 << this->chipshift);
795
796#ifdef DOC_DEBUG
797 printf("%d flash chips found. Total DiskOnChip size: %ld MB\n",
798 this->numchips, this->totlen >> 20);
799#endif
800}
801
802/* find_boot_record: Find the NFTL Media Header and its Spare copy which contains the
803 * various device information of the NFTL partition and Bad Unit Table. Update
804 * the ReplUnitTable[] table accroding to the Bad Unit Table. ReplUnitTable[]
805 * is used for management of Erase Unit in other routines in nftl.c and nftlmount.c
806 */
807static int find_boot_record(struct NFTLrecord *nftl)
808{
809 struct nftl_uci1 h1;
810 struct nftl_oob oob;
811 unsigned int block, boot_record_count = 0;
812 int retlen;
813 u8 buf[SECTORSIZE];
814 struct NFTLMediaHeader *mh = &nftl->MediaHdr;
815 unsigned int i;
816
817 nftl->MediaUnit = BLOCK_NIL;
818 nftl->SpareMediaUnit = BLOCK_NIL;
819
820 /* search for a valid boot record */
821 for (block = 0; block < nftl->nb_blocks; block++) {
822 int ret;
823
824 /* Check for ANAND header first. Then can whinge if it's found but later
825 checks fail */
826 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize, SECTORSIZE,
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200827 (size_t *)&retlen, buf, NULL))) {
wdenkc6097192002-11-03 00:24:07 +0000828 static int warncount = 5;
829
830 if (warncount) {
831 printf("Block read at 0x%x failed\n", block * nftl->EraseSize);
832 if (!--warncount)
833 puts ("Further failures for this block will not be printed\n");
834 }
835 continue;
836 }
837
838 if (retlen < 6 || memcmp(buf, "ANAND", 6)) {
839 /* ANAND\0 not found. Continue */
840#ifdef PSYCHO_DEBUG
841 printf("ANAND header not found at 0x%x\n", block * nftl->EraseSize);
842#endif
843 continue;
844 }
845
846#ifdef NFTL_DEBUG
847 printf("ANAND header found at 0x%x\n", block * nftl->EraseSize);
848#endif
849
850 /* To be safer with BIOS, also use erase mark as discriminant */
851 if ((ret = doc_read_oob(nftl->mtd, block * nftl->EraseSize + SECTORSIZE + 8,
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200852 8, (size_t *)&retlen, (uchar *)&h1) < 0)) {
wdenkc6097192002-11-03 00:24:07 +0000853#ifdef NFTL_DEBUG
854 printf("ANAND header found at 0x%x, but OOB data read failed\n",
855 block * nftl->EraseSize);
856#endif
857 continue;
858 }
859
860 /* OK, we like it. */
861
862 if (boot_record_count) {
863 /* We've already processed one. So we just check if
864 this one is the same as the first one we found */
865 if (memcmp(mh, buf, sizeof(struct NFTLMediaHeader))) {
866#ifdef NFTL_DEBUG
867 printf("NFTL Media Headers at 0x%x and 0x%x disagree.\n",
868 nftl->MediaUnit * nftl->EraseSize, block * nftl->EraseSize);
869#endif
870 /* if (debug) Print both side by side */
871 return -1;
872 }
873 if (boot_record_count == 1)
874 nftl->SpareMediaUnit = block;
875
876 boot_record_count++;
877 continue;
878 }
879
880 /* This is the first we've seen. Copy the media header structure into place */
881 memcpy(mh, buf, sizeof(struct NFTLMediaHeader));
882
883 /* Do some sanity checks on it */
wdenk7205e402003-09-10 22:30:53 +0000884 if (mh->UnitSizeFactor == 0) {
885#ifdef NFTL_DEBUG
886 puts ("UnitSizeFactor 0x00 detected.\n"
887 "This violates the spec but we think we know what it means...\n");
888#endif
889 } else if (mh->UnitSizeFactor != 0xff) {
890 printf ("Sorry, we don't support UnitSizeFactor "
wdenkc6097192002-11-03 00:24:07 +0000891 "of != 1 yet.\n");
892 return -1;
893 }
894
895 nftl->nb_boot_blocks = le16_to_cpu(mh->FirstPhysicalEUN);
896 if ((nftl->nb_boot_blocks + 2) >= nftl->nb_blocks) {
897 printf ("NFTL Media Header sanity check failed:\n"
898 "nb_boot_blocks (%d) + 2 > nb_blocks (%d)\n",
899 nftl->nb_boot_blocks, nftl->nb_blocks);
900 return -1;
901 }
902
903 nftl->numvunits = le32_to_cpu(mh->FormattedSize) / nftl->EraseSize;
904 if (nftl->numvunits > (nftl->nb_blocks - nftl->nb_boot_blocks - 2)) {
905 printf ("NFTL Media Header sanity check failed:\n"
906 "numvunits (%d) > nb_blocks (%d) - nb_boot_blocks(%d) - 2\n",
907 nftl->numvunits,
908 nftl->nb_blocks,
909 nftl->nb_boot_blocks);
910 return -1;
911 }
912
913 nftl->nr_sects = nftl->numvunits * (nftl->EraseSize / SECTORSIZE);
914
915 /* If we're not using the last sectors in the device for some reason,
916 reduce nb_blocks accordingly so we forget they're there */
917 nftl->nb_blocks = le16_to_cpu(mh->NumEraseUnits) + le16_to_cpu(mh->FirstPhysicalEUN);
918
919 /* read the Bad Erase Unit Table and modify ReplUnitTable[] accordingly */
920 for (i = 0; i < nftl->nb_blocks; i++) {
921 if ((i & (SECTORSIZE - 1)) == 0) {
922 /* read one sector for every SECTORSIZE of blocks */
923 if ((ret = doc_read_ecc(nftl->mtd, block * nftl->EraseSize +
924 i + SECTORSIZE, SECTORSIZE,
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200925 (size_t *)&retlen, buf, (uchar *)&oob)) < 0) {
wdenkc6097192002-11-03 00:24:07 +0000926 puts ("Read of bad sector table failed\n");
927 return -1;
928 }
929 }
930 /* mark the Bad Erase Unit as RESERVED in ReplUnitTable */
931 if (buf[i & (SECTORSIZE - 1)] != 0xff)
932 nftl->ReplUnitTable[i] = BLOCK_RESERVED;
933 }
934
935 nftl->MediaUnit = block;
936 boot_record_count++;
937
938 } /* foreach (block) */
939
940 return boot_record_count?0:-1;
941}
942
943/* This routine is made available to other mtd code via
944 * inter_module_register. It must only be accessed through
945 * inter_module_get which will bump the use count of this module. The
946 * addresses passed back in mtd are valid as long as the use count of
947 * this module is non-zero, i.e. between inter_module_get and
948 * inter_module_put. Keith Owens <kaos@ocs.com.au> 29 Oct 2000.
949 */
950static void DoC2k_init(struct DiskOnChip* this)
951{
952 struct NFTLrecord *nftl;
953
954 switch (this->ChipID) {
955 case DOC_ChipID_Doc2k:
956 this->name = "DiskOnChip 2000";
957 this->ioreg = DoC_2k_CDSN_IO;
958 break;
959 case DOC_ChipID_DocMil:
960 this->name = "DiskOnChip Millennium";
961 this->ioreg = DoC_Mil_CDSN_IO;
962 break;
963 }
964
965#ifdef DOC_DEBUG
966 printf("%s found at address 0x%lX\n", this->name,
967 this->physadr);
968#endif
969
970 this->totlen = 0;
971 this->numchips = 0;
972
973 this->curfloor = -1;
974 this->curchip = -1;
975
976 /* Ident all the chips present. */
977 DoC_ScanChips(this);
wdenk7205e402003-09-10 22:30:53 +0000978 if ((!this->numchips) || (!this->chips))
979 return;
wdenkc6097192002-11-03 00:24:07 +0000980
981 nftl = &this->nftl;
982
983 /* Get physical parameters */
984 nftl->EraseSize = this->erasesize;
wdenk8bde7f72003-06-27 21:31:46 +0000985 nftl->nb_blocks = this->totlen / this->erasesize;
wdenkc6097192002-11-03 00:24:07 +0000986 nftl->mtd = this;
987
988 if (find_boot_record(nftl) != 0)
989 this->nftl_found = 0;
990 else
991 this->nftl_found = 1;
992
993 printf("%s @ 0x%lX, %ld MB\n", this->name, this->physadr, this->totlen >> 20);
994}
995
996int doc_read_ecc(struct DiskOnChip* this, loff_t from, size_t len,
997 size_t * retlen, u_char * buf, u_char * eccbuf)
998{
999 unsigned long docptr;
1000 struct Nand *mychip;
1001 unsigned char syndrome[6];
1002 volatile char dummy;
1003 int i, len256 = 0, ret=0;
1004
1005 docptr = this->virtadr;
1006
1007 /* Don't allow read past end of device */
1008 if (from >= this->totlen) {
1009 puts ("Out of flash\n");
1010 return DOC_EINVAL;
1011 }
1012
1013 /* Don't allow a single read to cross a 512-byte block boundary */
1014 if (from + len > ((from | 0x1ff) + 1))
1015 len = ((from | 0x1ff) + 1) - from;
1016
1017 /* The ECC will not be calculated correctly if less than 512 is read */
1018 if (len != 0x200 && eccbuf)
1019 printf("ECC needs a full sector read (adr: %lx size %lx)\n",
1020 (long) from, (long) len);
1021
wdenk7152b1d2003-09-05 23:19:14 +00001022#ifdef PSYCHO_DEBUG
wdenkc6097192002-11-03 00:24:07 +00001023 printf("DoC_Read (adr: %lx size %lx)\n", (long) from, (long) len);
1024#endif
1025
1026 /* Find the chip which is to be used and select it */
1027 mychip = &this->chips[shr(from, this->chipshift)];
1028
1029 if (this->curfloor != mychip->floor) {
1030 DoC_SelectFloor(this, mychip->floor);
1031 DoC_SelectChip(this, mychip->chip);
1032 } else if (this->curchip != mychip->chip) {
1033 DoC_SelectChip(this, mychip->chip);
1034 }
1035
1036 this->curfloor = mychip->floor;
1037 this->curchip = mychip->chip;
1038
1039 DoC_Command(this,
1040 (!this->page256
1041 && (from & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1042 CDSN_CTRL_WP);
1043 DoC_Address(this, ADDR_COLUMN_PAGE, from, CDSN_CTRL_WP,
1044 CDSN_CTRL_ECC_IO);
1045
1046 if (eccbuf) {
1047 /* Prime the ECC engine */
1048 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1049 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
1050 } else {
1051 /* disable the ECC engine */
1052 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1053 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1054 }
1055
1056 /* treat crossing 256-byte sector for 2M x 8bits devices */
1057 if (this->page256 && from + len > (from | 0xff) + 1) {
1058 len256 = (from | 0xff) + 1 - from;
1059 DoC_ReadBuf(this, buf, len256);
1060
1061 DoC_Command(this, NAND_CMD_READ0, CDSN_CTRL_WP);
1062 DoC_Address(this, ADDR_COLUMN_PAGE, from + len256,
1063 CDSN_CTRL_WP, CDSN_CTRL_ECC_IO);
1064 }
1065
1066 DoC_ReadBuf(this, &buf[len256], len - len256);
1067
1068 /* Let the caller know we completed it */
1069 *retlen = len;
1070
1071 if (eccbuf) {
1072 /* Read the ECC data through the DiskOnChip ECC logic */
1073 /* Note: this will work even with 2M x 8bit devices as */
1074 /* they have 8 bytes of OOB per 256 page. mf. */
1075 DoC_ReadBuf(this, eccbuf, 6);
1076
1077 /* Flush the pipeline */
1078 if (DoC_is_Millennium(this)) {
1079 dummy = ReadDOC(docptr, ECCConf);
1080 dummy = ReadDOC(docptr, ECCConf);
1081 i = ReadDOC(docptr, ECCConf);
1082 } else {
1083 dummy = ReadDOC(docptr, 2k_ECCStatus);
1084 dummy = ReadDOC(docptr, 2k_ECCStatus);
1085 i = ReadDOC(docptr, 2k_ECCStatus);
1086 }
1087
1088 /* Check the ECC Status */
1089 if (i & 0x80) {
1090 int nb_errors;
1091 /* There was an ECC error */
1092#ifdef ECC_DEBUG
1093 printf("DiskOnChip ECC Error: Read at %lx\n", (long)from);
1094#endif
1095 /* Read the ECC syndrom through the DiskOnChip ECC logic.
1096 These syndrome will be all ZERO when there is no error */
1097 for (i = 0; i < 6; i++) {
1098 syndrome[i] =
1099 ReadDOC(docptr, ECCSyndrome0 + i);
1100 }
wdenk8bde7f72003-06-27 21:31:46 +00001101 nb_errors = doc_decode_ecc(buf, syndrome);
wdenkc6097192002-11-03 00:24:07 +00001102
1103#ifdef ECC_DEBUG
1104 printf("Errors corrected: %x\n", nb_errors);
1105#endif
wdenk8bde7f72003-06-27 21:31:46 +00001106 if (nb_errors < 0) {
wdenkc6097192002-11-03 00:24:07 +00001107 /* We return error, but have actually done the read. Not that
1108 this can be told to user-space, via sys_read(), but at least
1109 MTD-aware stuff can know about it by checking *retlen */
1110 printf("ECC Errors at %lx\n", (long)from);
1111 ret = DOC_EECC;
wdenk8bde7f72003-06-27 21:31:46 +00001112 }
wdenkc6097192002-11-03 00:24:07 +00001113 }
1114
1115#ifdef PSYCHO_DEBUG
1116 printf("ECC DATA at %lxB: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1117 (long)from, eccbuf[0], eccbuf[1], eccbuf[2],
1118 eccbuf[3], eccbuf[4], eccbuf[5]);
1119#endif
1120
1121 /* disable the ECC engine */
1122 WriteDOC(DOC_ECC_DIS, docptr , ECCConf);
1123 }
1124
1125 /* according to 11.4.1, we need to wait for the busy line
wdenk8bde7f72003-06-27 21:31:46 +00001126 * drop if we read to the end of the page. */
wdenkc6097192002-11-03 00:24:07 +00001127 if(0 == ((from + *retlen) & 0x1ff))
1128 {
1129 DoC_WaitReady(this);
1130 }
1131
1132 return ret;
1133}
1134
1135int doc_write_ecc(struct DiskOnChip* this, loff_t to, size_t len,
1136 size_t * retlen, const u_char * buf,
1137 u_char * eccbuf)
1138{
1139 int di; /* Yes, DI is a hangover from when I was disassembling the binary driver */
1140 unsigned long docptr;
1141 volatile char dummy;
1142 int len256 = 0;
1143 struct Nand *mychip;
1144
1145 docptr = this->virtadr;
1146
1147 /* Don't allow write past end of device */
1148 if (to >= this->totlen) {
1149 puts ("Out of flash\n");
1150 return DOC_EINVAL;
1151 }
1152
1153 /* Don't allow a single write to cross a 512-byte block boundary */
1154 if (to + len > ((to | 0x1ff) + 1))
1155 len = ((to | 0x1ff) + 1) - to;
1156
1157 /* The ECC will not be calculated correctly if less than 512 is written */
1158 if (len != 0x200 && eccbuf)
1159 printf("ECC needs a full sector write (adr: %lx size %lx)\n",
1160 (long) to, (long) len);
1161
1162 /* printf("DoC_Write (adr: %lx size %lx)\n", (long) to, (long) len); */
1163
1164 /* Find the chip which is to be used and select it */
1165 mychip = &this->chips[shr(to, this->chipshift)];
1166
1167 if (this->curfloor != mychip->floor) {
1168 DoC_SelectFloor(this, mychip->floor);
1169 DoC_SelectChip(this, mychip->chip);
1170 } else if (this->curchip != mychip->chip) {
1171 DoC_SelectChip(this, mychip->chip);
1172 }
1173
1174 this->curfloor = mychip->floor;
1175 this->curchip = mychip->chip;
1176
1177 /* Set device to main plane of flash */
1178 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1179 DoC_Command(this,
1180 (!this->page256
1181 && (to & 0x100)) ? NAND_CMD_READ1 : NAND_CMD_READ0,
1182 CDSN_CTRL_WP);
1183
1184 DoC_Command(this, NAND_CMD_SEQIN, 0);
1185 DoC_Address(this, ADDR_COLUMN_PAGE, to, 0, CDSN_CTRL_ECC_IO);
1186
1187 if (eccbuf) {
1188 /* Prime the ECC engine */
1189 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1190 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
1191 } else {
1192 /* disable the ECC engine */
1193 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
1194 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1195 }
1196
1197 /* treat crossing 256-byte sector for 2M x 8bits devices */
1198 if (this->page256 && to + len > (to | 0xff) + 1) {
1199 len256 = (to | 0xff) + 1 - to;
1200 DoC_WriteBuf(this, buf, len256);
1201
1202 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1203
1204 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1205 /* There's an implicit DoC_WaitReady() in DoC_Command */
1206
1207 dummy = ReadDOC(docptr, CDSNSlowIO);
1208 DoC_Delay(this, 2);
1209
1210 if (ReadDOC_(docptr, this->ioreg) & 1) {
1211 puts ("Error programming flash\n");
1212 /* Error in programming */
1213 *retlen = 0;
1214 return DOC_EIO;
1215 }
1216
1217 DoC_Command(this, NAND_CMD_SEQIN, 0);
1218 DoC_Address(this, ADDR_COLUMN_PAGE, to + len256, 0,
1219 CDSN_CTRL_ECC_IO);
1220 }
1221
1222 DoC_WriteBuf(this, &buf[len256], len - len256);
1223
1224 if (eccbuf) {
1225 WriteDOC(CDSN_CTRL_ECC_IO | CDSN_CTRL_CE, docptr,
1226 CDSNControl);
1227
1228 if (DoC_is_Millennium(this)) {
1229 WriteDOC(0, docptr, NOP);
1230 WriteDOC(0, docptr, NOP);
1231 WriteDOC(0, docptr, NOP);
1232 } else {
1233 WriteDOC_(0, docptr, this->ioreg);
1234 WriteDOC_(0, docptr, this->ioreg);
1235 WriteDOC_(0, docptr, this->ioreg);
1236 }
1237
1238 /* Read the ECC data through the DiskOnChip ECC logic */
1239 for (di = 0; di < 6; di++) {
1240 eccbuf[di] = ReadDOC(docptr, ECCSyndrome0 + di);
1241 }
1242
1243 /* Reset the ECC engine */
1244 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
1245
1246#ifdef PSYCHO_DEBUG
1247 printf
1248 ("OOB data at %lx is %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
1249 (long) to, eccbuf[0], eccbuf[1], eccbuf[2], eccbuf[3],
1250 eccbuf[4], eccbuf[5]);
1251#endif
1252 }
1253
1254 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1255
1256 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1257 /* There's an implicit DoC_WaitReady() in DoC_Command */
1258
1259 dummy = ReadDOC(docptr, CDSNSlowIO);
1260 DoC_Delay(this, 2);
1261
1262 if (ReadDOC_(docptr, this->ioreg) & 1) {
1263 puts ("Error programming flash\n");
1264 /* Error in programming */
1265 *retlen = 0;
1266 return DOC_EIO;
1267 }
1268
1269 /* Let the caller know we completed it */
1270 *retlen = len;
1271
1272 if (eccbuf) {
1273 unsigned char x[8];
1274 size_t dummy;
1275 int ret;
1276
1277 /* Write the ECC data to flash */
1278 for (di=0; di<6; di++)
1279 x[di] = eccbuf[di];
1280
1281 x[6]=0x55;
1282 x[7]=0x55;
1283
1284 ret = doc_write_oob(this, to, 8, &dummy, x);
1285 return ret;
1286 }
1287 return 0;
1288}
1289
1290int doc_read_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1291 size_t * retlen, u_char * buf)
1292{
1293 int len256 = 0, ret;
1294 unsigned long docptr;
1295 struct Nand *mychip;
1296
1297 docptr = this->virtadr;
1298
1299 mychip = &this->chips[shr(ofs, this->chipshift)];
1300
1301 if (this->curfloor != mychip->floor) {
1302 DoC_SelectFloor(this, mychip->floor);
1303 DoC_SelectChip(this, mychip->chip);
1304 } else if (this->curchip != mychip->chip) {
1305 DoC_SelectChip(this, mychip->chip);
1306 }
1307 this->curfloor = mychip->floor;
1308 this->curchip = mychip->chip;
1309
1310 /* update address for 2M x 8bit devices. OOB starts on the second */
1311 /* page to maintain compatibility with doc_read_ecc. */
1312 if (this->page256) {
1313 if (!(ofs & 0x8))
1314 ofs += 0x100;
1315 else
1316 ofs -= 0x8;
1317 }
1318
1319 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1320 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, CDSN_CTRL_WP, 0);
1321
1322 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1323 /* Note: datasheet says it should automaticaly wrap to the */
1324 /* next OOB block, but it didn't work here. mf. */
1325 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1326 len256 = (ofs | 0x7) + 1 - ofs;
1327 DoC_ReadBuf(this, buf, len256);
1328
1329 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1330 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff),
1331 CDSN_CTRL_WP, 0);
1332 }
1333
1334 DoC_ReadBuf(this, &buf[len256], len - len256);
1335
1336 *retlen = len;
1337 /* Reading the full OOB data drops us off of the end of the page,
wdenk8bde7f72003-06-27 21:31:46 +00001338 * causing the flash device to go into busy mode, so we need
1339 * to wait until ready 11.4.1 and Toshiba TC58256FT docs */
wdenkc6097192002-11-03 00:24:07 +00001340
1341 ret = DoC_WaitReady(this);
1342
1343 return ret;
1344
1345}
1346
1347int doc_write_oob(struct DiskOnChip* this, loff_t ofs, size_t len,
1348 size_t * retlen, const u_char * buf)
1349{
1350 int len256 = 0;
1351 unsigned long docptr = this->virtadr;
1352 struct Nand *mychip = &this->chips[shr(ofs, this->chipshift)];
1353 volatile int dummy;
1354
1355#ifdef PSYCHO_DEBUG
1356 printf("doc_write_oob(%lx, %d): %2.2X %2.2X %2.2X %2.2X ... %2.2X %2.2X .. %2.2X %2.2X\n",
1357 (long)ofs, len, buf[0], buf[1], buf[2], buf[3],
1358 buf[8], buf[9], buf[14],buf[15]);
1359#endif
1360
1361 /* Find the chip which is to be used and select it */
1362 if (this->curfloor != mychip->floor) {
1363 DoC_SelectFloor(this, mychip->floor);
1364 DoC_SelectChip(this, mychip->chip);
1365 } else if (this->curchip != mychip->chip) {
1366 DoC_SelectChip(this, mychip->chip);
1367 }
1368 this->curfloor = mychip->floor;
1369 this->curchip = mychip->chip;
1370
1371 /* disable the ECC engine */
1372 WriteDOC (DOC_ECC_RESET, docptr, ECCConf);
1373 WriteDOC (DOC_ECC_DIS, docptr, ECCConf);
1374
1375 /* Reset the chip, see Software Requirement 11.4 item 1. */
1376 DoC_Command(this, NAND_CMD_RESET, CDSN_CTRL_WP);
1377
1378 /* issue the Read2 command to set the pointer to the Spare Data Area. */
1379 DoC_Command(this, NAND_CMD_READOOB, CDSN_CTRL_WP);
1380
1381 /* update address for 2M x 8bit devices. OOB starts on the second */
1382 /* page to maintain compatibility with doc_read_ecc. */
1383 if (this->page256) {
1384 if (!(ofs & 0x8))
1385 ofs += 0x100;
1386 else
1387 ofs -= 0x8;
1388 }
1389
1390 /* issue the Serial Data In command to initial the Page Program process */
1391 DoC_Command(this, NAND_CMD_SEQIN, 0);
1392 DoC_Address(this, ADDR_COLUMN_PAGE, ofs, 0, 0);
1393
1394 /* treat crossing 8-byte OOB data for 2M x 8bit devices */
1395 /* Note: datasheet says it should automaticaly wrap to the */
1396 /* next OOB block, but it didn't work here. mf. */
1397 if (this->page256 && ofs + len > (ofs | 0x7) + 1) {
1398 len256 = (ofs | 0x7) + 1 - ofs;
1399 DoC_WriteBuf(this, buf, len256);
1400
1401 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1402 DoC_Command(this, NAND_CMD_STATUS, 0);
1403 /* DoC_WaitReady() is implicit in DoC_Command */
1404
1405 dummy = ReadDOC(docptr, CDSNSlowIO);
1406 DoC_Delay(this, 2);
1407
1408 if (ReadDOC_(docptr, this->ioreg) & 1) {
1409 puts ("Error programming oob data\n");
1410 /* There was an error */
1411 *retlen = 0;
1412 return DOC_EIO;
1413 }
1414 DoC_Command(this, NAND_CMD_SEQIN, 0);
1415 DoC_Address(this, ADDR_COLUMN_PAGE, ofs & (~0x1ff), 0, 0);
1416 }
1417
1418 DoC_WriteBuf(this, &buf[len256], len - len256);
1419
1420 DoC_Command(this, NAND_CMD_PAGEPROG, 0);
1421 DoC_Command(this, NAND_CMD_STATUS, 0);
1422 /* DoC_WaitReady() is implicit in DoC_Command */
1423
1424 dummy = ReadDOC(docptr, CDSNSlowIO);
1425 DoC_Delay(this, 2);
1426
1427 if (ReadDOC_(docptr, this->ioreg) & 1) {
1428 puts ("Error programming oob data\n");
1429 /* There was an error */
1430 *retlen = 0;
1431 return DOC_EIO;
1432 }
1433
1434 *retlen = len;
1435 return 0;
1436
1437}
1438
1439int doc_erase(struct DiskOnChip* this, loff_t ofs, size_t len)
1440{
1441 volatile int dummy;
1442 unsigned long docptr;
1443 struct Nand *mychip;
1444
1445 if (ofs & (this->erasesize-1) || len & (this->erasesize-1)) {
1446 puts ("Offset and size must be sector aligned\n");
1447 return DOC_EINVAL;
1448 }
1449
1450 docptr = this->virtadr;
1451
1452 /* FIXME: Do this in the background. Use timers or schedule_task() */
1453 while(len) {
1454 mychip = &this->chips[shr(ofs, this->chipshift)];
1455
1456 if (this->curfloor != mychip->floor) {
1457 DoC_SelectFloor(this, mychip->floor);
1458 DoC_SelectChip(this, mychip->chip);
1459 } else if (this->curchip != mychip->chip) {
1460 DoC_SelectChip(this, mychip->chip);
1461 }
1462 this->curfloor = mychip->floor;
1463 this->curchip = mychip->chip;
1464
1465 DoC_Command(this, NAND_CMD_ERASE1, 0);
1466 DoC_Address(this, ADDR_PAGE, ofs, 0, 0);
1467 DoC_Command(this, NAND_CMD_ERASE2, 0);
1468
1469 DoC_Command(this, NAND_CMD_STATUS, CDSN_CTRL_WP);
1470
1471 dummy = ReadDOC(docptr, CDSNSlowIO);
1472 DoC_Delay(this, 2);
1473
1474 if (ReadDOC_(docptr, this->ioreg) & 1) {
1475 printf("Error erasing at 0x%lx\n", (long)ofs);
1476 /* There was an error */
1477 goto callback;
1478 }
1479 ofs += this->erasesize;
1480 len -= this->erasesize;
1481 }
1482
1483 callback:
1484 return 0;
1485}
1486
1487static inline int doccheck(unsigned long potential, unsigned long physadr)
1488{
1489 unsigned long window=potential;
1490 unsigned char tmp, ChipID;
1491#ifndef DOC_PASSIVE_PROBE
1492 unsigned char tmp2;
1493#endif
1494
1495 /* Routine copied from the Linux DOC driver */
1496
1497#ifdef CFG_DOCPROBE_55AA
1498 /* Check for 0x55 0xAA signature at beginning of window,
1499 this is no longer true once we remove the IPL (for Millennium */
1500 if (ReadDOC(window, Sig1) != 0x55 || ReadDOC(window, Sig2) != 0xaa)
1501 return 0;
1502#endif /* CFG_DOCPROBE_55AA */
1503
1504#ifndef DOC_PASSIVE_PROBE
1505 /* It's not possible to cleanly detect the DiskOnChip - the
1506 * bootup procedure will put the device into reset mode, and
1507 * it's not possible to talk to it without actually writing
1508 * to the DOCControl register. So we store the current contents
1509 * of the DOCControl register's location, in case we later decide
1510 * that it's not a DiskOnChip, and want to put it back how we
1511 * found it.
1512 */
1513 tmp2 = ReadDOC(window, DOCControl);
1514
1515 /* Reset the DiskOnChip ASIC */
1516 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1517 window, DOCControl);
1518 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET,
1519 window, DOCControl);
1520
1521 /* Enable the DiskOnChip ASIC */
1522 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1523 window, DOCControl);
1524 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL,
1525 window, DOCControl);
1526#endif /* !DOC_PASSIVE_PROBE */
1527
1528 ChipID = ReadDOC(window, ChipID);
1529
1530 switch (ChipID) {
1531 case DOC_ChipID_Doc2k:
1532 /* Check the TOGGLE bit in the ECC register */
1533 tmp = ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT;
1534 if ((ReadDOC(window, 2k_ECCStatus) & DOC_TOGGLE_BIT) != tmp)
1535 return ChipID;
1536 break;
1537
1538 case DOC_ChipID_DocMil:
1539 /* Check the TOGGLE bit in the ECC register */
1540 tmp = ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT;
1541 if ((ReadDOC(window, ECCConf) & DOC_TOGGLE_BIT) != tmp)
1542 return ChipID;
1543 break;
1544
1545 default:
1546#ifndef CFG_DOCPROBE_55AA
1547/*
1548 * if the ID isn't the DoC2000 or DoCMillenium ID, so we can assume
1549 * the DOC is missing
1550 */
1551# if 0
1552 printf("Possible DiskOnChip with unknown ChipID %2.2X found at 0x%lx\n",
1553 ChipID, physadr);
1554# endif
1555#endif
1556#ifndef DOC_PASSIVE_PROBE
1557 /* Put back the contents of the DOCControl register, in case it's not
1558 * actually a DiskOnChip.
1559 */
1560 WriteDOC(tmp2, window, DOCControl);
1561#endif
1562 return 0;
1563 }
1564
1565 puts ("DiskOnChip failed TOGGLE test, dropping.\n");
1566
1567#ifndef DOC_PASSIVE_PROBE
1568 /* Put back the contents of the DOCControl register: it's not a DiskOnChip */
1569 WriteDOC(tmp2, window, DOCControl);
1570#endif
1571 return 0;
1572}
1573
1574void doc_probe(unsigned long physadr)
1575{
1576 struct DiskOnChip *this = NULL;
1577 int i=0, ChipID;
1578
1579 if ((ChipID = doccheck(physadr, physadr))) {
1580
1581 for (i=0; i<CFG_MAX_DOC_DEVICE; i++) {
1582 if (doc_dev_desc[i].ChipID == DOC_ChipID_UNKNOWN) {
1583 this = doc_dev_desc + i;
1584 break;
1585 }
1586 }
1587
1588 if (!this) {
1589 puts ("Cannot allocate memory for data structures.\n");
1590 return;
1591 }
1592
1593 if (curr_device == -1)
1594 curr_device = i;
1595
1596 memset((char *)this, 0, sizeof(struct DiskOnChip));
1597
1598 this->virtadr = physadr;
1599 this->physadr = physadr;
1600 this->ChipID = ChipID;
1601
1602 DoC2k_init(this);
1603 } else {
1604 puts ("No DiskOnChip found\n");
1605 }
1606}