Loading...
Note: File does not exist in v6.8.
1/*
2 * drivers/mtd/nand/diskonchip.c
3 *
4 * (C) 2003 Red Hat, Inc.
5 * (C) 2004 Dan Brown <dan_brown@ieee.org>
6 * (C) 2004 Kalev Lember <kalev@smartlink.ee>
7 *
8 * Author: David Woodhouse <dwmw2@infradead.org>
9 * Additional Diskonchip 2000 and Millennium support by Dan Brown <dan_brown@ieee.org>
10 * Diskonchip Millennium Plus support by Kalev Lember <kalev@smartlink.ee>
11 *
12 * Error correction code lifted from the old docecc code
13 * Author: Fabrice Bellard (fabrice.bellard@netgem.com)
14 * Copyright (C) 2000 Netgem S.A.
15 * converted to the generic Reed-Solomon library by Thomas Gleixner <tglx@linutronix.de>
16 *
17 * Interface to generic NAND code for M-Systems DiskOnChip devices
18 */
19
20#include <linux/kernel.h>
21#include <linux/init.h>
22#include <linux/sched.h>
23#include <linux/delay.h>
24#include <linux/rslib.h>
25#include <linux/moduleparam.h>
26#include <linux/slab.h>
27#include <asm/io.h>
28
29#include <linux/mtd/mtd.h>
30#include <linux/mtd/nand.h>
31#include <linux/mtd/doc2000.h>
32#include <linux/mtd/partitions.h>
33#include <linux/mtd/inftl.h>
34#include <linux/module.h>
35
36/* Where to look for the devices? */
37#ifndef CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS
38#define CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS 0
39#endif
40
41static unsigned long doc_locations[] __initdata = {
42#if defined (__alpha__) || defined(__i386__) || defined(__x86_64__)
43#ifdef CONFIG_MTD_NAND_DISKONCHIP_PROBE_HIGH
44 0xfffc8000, 0xfffca000, 0xfffcc000, 0xfffce000,
45 0xfffd0000, 0xfffd2000, 0xfffd4000, 0xfffd6000,
46 0xfffd8000, 0xfffda000, 0xfffdc000, 0xfffde000,
47 0xfffe0000, 0xfffe2000, 0xfffe4000, 0xfffe6000,
48 0xfffe8000, 0xfffea000, 0xfffec000, 0xfffee000,
49#else
50 0xc8000, 0xca000, 0xcc000, 0xce000,
51 0xd0000, 0xd2000, 0xd4000, 0xd6000,
52 0xd8000, 0xda000, 0xdc000, 0xde000,
53 0xe0000, 0xe2000, 0xe4000, 0xe6000,
54 0xe8000, 0xea000, 0xec000, 0xee000,
55#endif
56#endif
57 0xffffffff };
58
59static struct mtd_info *doclist = NULL;
60
61struct doc_priv {
62 void __iomem *virtadr;
63 unsigned long physadr;
64 u_char ChipID;
65 u_char CDSNControl;
66 int chips_per_floor; /* The number of chips detected on each floor */
67 int curfloor;
68 int curchip;
69 int mh0_page;
70 int mh1_page;
71 struct mtd_info *nextdoc;
72};
73
74/* This is the syndrome computed by the HW ecc generator upon reading an empty
75 page, one with all 0xff for data and stored ecc code. */
76static u_char empty_read_syndrome[6] = { 0x26, 0xff, 0x6d, 0x47, 0x73, 0x7a };
77
78/* This is the ecc value computed by the HW ecc generator upon writing an empty
79 page, one with all 0xff for data. */
80static u_char empty_write_ecc[6] = { 0x4b, 0x00, 0xe2, 0x0e, 0x93, 0xf7 };
81
82#define INFTL_BBT_RESERVED_BLOCKS 4
83
84#define DoC_is_MillenniumPlus(doc) ((doc)->ChipID == DOC_ChipID_DocMilPlus16 || (doc)->ChipID == DOC_ChipID_DocMilPlus32)
85#define DoC_is_Millennium(doc) ((doc)->ChipID == DOC_ChipID_DocMil)
86#define DoC_is_2000(doc) ((doc)->ChipID == DOC_ChipID_Doc2k)
87
88static void doc200x_hwcontrol(struct mtd_info *mtd, int cmd,
89 unsigned int bitmask);
90static void doc200x_select_chip(struct mtd_info *mtd, int chip);
91
92static int debug = 0;
93module_param(debug, int, 0);
94
95static int try_dword = 1;
96module_param(try_dword, int, 0);
97
98static int no_ecc_failures = 0;
99module_param(no_ecc_failures, int, 0);
100
101static int no_autopart = 0;
102module_param(no_autopart, int, 0);
103
104static int show_firmware_partition = 0;
105module_param(show_firmware_partition, int, 0);
106
107#ifdef CONFIG_MTD_NAND_DISKONCHIP_BBTWRITE
108static int inftl_bbt_write = 1;
109#else
110static int inftl_bbt_write = 0;
111#endif
112module_param(inftl_bbt_write, int, 0);
113
114static unsigned long doc_config_location = CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS;
115module_param(doc_config_location, ulong, 0);
116MODULE_PARM_DESC(doc_config_location, "Physical memory address at which to probe for DiskOnChip");
117
118/* Sector size for HW ECC */
119#define SECTOR_SIZE 512
120/* The sector bytes are packed into NB_DATA 10 bit words */
121#define NB_DATA (((SECTOR_SIZE + 1) * 8 + 6) / 10)
122/* Number of roots */
123#define NROOTS 4
124/* First consective root */
125#define FCR 510
126/* Number of symbols */
127#define NN 1023
128
129/* the Reed Solomon control structure */
130static struct rs_control *rs_decoder;
131
132/*
133 * The HW decoder in the DoC ASIC's provides us a error syndrome,
134 * which we must convert to a standard syndrome usable by the generic
135 * Reed-Solomon library code.
136 *
137 * Fabrice Bellard figured this out in the old docecc code. I added
138 * some comments, improved a minor bit and converted it to make use
139 * of the generic Reed-Solomon library. tglx
140 */
141static int doc_ecc_decode(struct rs_control *rs, uint8_t *data, uint8_t *ecc)
142{
143 int i, j, nerr, errpos[8];
144 uint8_t parity;
145 uint16_t ds[4], s[5], tmp, errval[8], syn[4];
146
147 memset(syn, 0, sizeof(syn));
148 /* Convert the ecc bytes into words */
149 ds[0] = ((ecc[4] & 0xff) >> 0) | ((ecc[5] & 0x03) << 8);
150 ds[1] = ((ecc[5] & 0xfc) >> 2) | ((ecc[2] & 0x0f) << 6);
151 ds[2] = ((ecc[2] & 0xf0) >> 4) | ((ecc[3] & 0x3f) << 4);
152 ds[3] = ((ecc[3] & 0xc0) >> 6) | ((ecc[0] & 0xff) << 2);
153 parity = ecc[1];
154
155 /* Initialize the syndrome buffer */
156 for (i = 0; i < NROOTS; i++)
157 s[i] = ds[0];
158 /*
159 * Evaluate
160 * s[i] = ds[3]x^3 + ds[2]x^2 + ds[1]x^1 + ds[0]
161 * where x = alpha^(FCR + i)
162 */
163 for (j = 1; j < NROOTS; j++) {
164 if (ds[j] == 0)
165 continue;
166 tmp = rs->index_of[ds[j]];
167 for (i = 0; i < NROOTS; i++)
168 s[i] ^= rs->alpha_to[rs_modnn(rs, tmp + (FCR + i) * j)];
169 }
170
171 /* Calc syn[i] = s[i] / alpha^(v + i) */
172 for (i = 0; i < NROOTS; i++) {
173 if (s[i])
174 syn[i] = rs_modnn(rs, rs->index_of[s[i]] + (NN - FCR - i));
175 }
176 /* Call the decoder library */
177 nerr = decode_rs16(rs, NULL, NULL, 1019, syn, 0, errpos, 0, errval);
178
179 /* Incorrectable errors ? */
180 if (nerr < 0)
181 return nerr;
182
183 /*
184 * Correct the errors. The bitpositions are a bit of magic,
185 * but they are given by the design of the de/encoder circuit
186 * in the DoC ASIC's.
187 */
188 for (i = 0; i < nerr; i++) {
189 int index, bitpos, pos = 1015 - errpos[i];
190 uint8_t val;
191 if (pos >= NB_DATA && pos < 1019)
192 continue;
193 if (pos < NB_DATA) {
194 /* extract bit position (MSB first) */
195 pos = 10 * (NB_DATA - 1 - pos) - 6;
196 /* now correct the following 10 bits. At most two bytes
197 can be modified since pos is even */
198 index = (pos >> 3) ^ 1;
199 bitpos = pos & 7;
200 if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
201 val = (uint8_t) (errval[i] >> (2 + bitpos));
202 parity ^= val;
203 if (index < SECTOR_SIZE)
204 data[index] ^= val;
205 }
206 index = ((pos >> 3) + 1) ^ 1;
207 bitpos = (bitpos + 10) & 7;
208 if (bitpos == 0)
209 bitpos = 8;
210 if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
211 val = (uint8_t) (errval[i] << (8 - bitpos));
212 parity ^= val;
213 if (index < SECTOR_SIZE)
214 data[index] ^= val;
215 }
216 }
217 }
218 /* If the parity is wrong, no rescue possible */
219 return parity ? -EBADMSG : nerr;
220}
221
222static void DoC_Delay(struct doc_priv *doc, unsigned short cycles)
223{
224 volatile char dummy;
225 int i;
226
227 for (i = 0; i < cycles; i++) {
228 if (DoC_is_Millennium(doc))
229 dummy = ReadDOC(doc->virtadr, NOP);
230 else if (DoC_is_MillenniumPlus(doc))
231 dummy = ReadDOC(doc->virtadr, Mplus_NOP);
232 else
233 dummy = ReadDOC(doc->virtadr, DOCStatus);
234 }
235
236}
237
238#define CDSN_CTRL_FR_B_MASK (CDSN_CTRL_FR_B0 | CDSN_CTRL_FR_B1)
239
240/* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
241static int _DoC_WaitReady(struct doc_priv *doc)
242{
243 void __iomem *docptr = doc->virtadr;
244 unsigned long timeo = jiffies + (HZ * 10);
245
246 if (debug)
247 printk("_DoC_WaitReady...\n");
248 /* Out-of-line routine to wait for chip response */
249 if (DoC_is_MillenniumPlus(doc)) {
250 while ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK) {
251 if (time_after(jiffies, timeo)) {
252 printk("_DoC_WaitReady timed out.\n");
253 return -EIO;
254 }
255 udelay(1);
256 cond_resched();
257 }
258 } else {
259 while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
260 if (time_after(jiffies, timeo)) {
261 printk("_DoC_WaitReady timed out.\n");
262 return -EIO;
263 }
264 udelay(1);
265 cond_resched();
266 }
267 }
268
269 return 0;
270}
271
272static inline int DoC_WaitReady(struct doc_priv *doc)
273{
274 void __iomem *docptr = doc->virtadr;
275 int ret = 0;
276
277 if (DoC_is_MillenniumPlus(doc)) {
278 DoC_Delay(doc, 4);
279
280 if ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK)
281 /* Call the out-of-line routine to wait */
282 ret = _DoC_WaitReady(doc);
283 } else {
284 DoC_Delay(doc, 4);
285
286 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
287 /* Call the out-of-line routine to wait */
288 ret = _DoC_WaitReady(doc);
289 DoC_Delay(doc, 2);
290 }
291
292 if (debug)
293 printk("DoC_WaitReady OK\n");
294 return ret;
295}
296
297static void doc2000_write_byte(struct mtd_info *mtd, u_char datum)
298{
299 struct nand_chip *this = mtd->priv;
300 struct doc_priv *doc = this->priv;
301 void __iomem *docptr = doc->virtadr;
302
303 if (debug)
304 printk("write_byte %02x\n", datum);
305 WriteDOC(datum, docptr, CDSNSlowIO);
306 WriteDOC(datum, docptr, 2k_CDSN_IO);
307}
308
309static u_char doc2000_read_byte(struct mtd_info *mtd)
310{
311 struct nand_chip *this = mtd->priv;
312 struct doc_priv *doc = this->priv;
313 void __iomem *docptr = doc->virtadr;
314 u_char ret;
315
316 ReadDOC(docptr, CDSNSlowIO);
317 DoC_Delay(doc, 2);
318 ret = ReadDOC(docptr, 2k_CDSN_IO);
319 if (debug)
320 printk("read_byte returns %02x\n", ret);
321 return ret;
322}
323
324static void doc2000_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
325{
326 struct nand_chip *this = mtd->priv;
327 struct doc_priv *doc = this->priv;
328 void __iomem *docptr = doc->virtadr;
329 int i;
330 if (debug)
331 printk("writebuf of %d bytes: ", len);
332 for (i = 0; i < len; i++) {
333 WriteDOC_(buf[i], docptr, DoC_2k_CDSN_IO + i);
334 if (debug && i < 16)
335 printk("%02x ", buf[i]);
336 }
337 if (debug)
338 printk("\n");
339}
340
341static void doc2000_readbuf(struct mtd_info *mtd, u_char *buf, int len)
342{
343 struct nand_chip *this = mtd->priv;
344 struct doc_priv *doc = this->priv;
345 void __iomem *docptr = doc->virtadr;
346 int i;
347
348 if (debug)
349 printk("readbuf of %d bytes: ", len);
350
351 for (i = 0; i < len; i++) {
352 buf[i] = ReadDOC(docptr, 2k_CDSN_IO + i);
353 }
354}
355
356static void doc2000_readbuf_dword(struct mtd_info *mtd, u_char *buf, int len)
357{
358 struct nand_chip *this = mtd->priv;
359 struct doc_priv *doc = this->priv;
360 void __iomem *docptr = doc->virtadr;
361 int i;
362
363 if (debug)
364 printk("readbuf_dword of %d bytes: ", len);
365
366 if (unlikely((((unsigned long)buf) | len) & 3)) {
367 for (i = 0; i < len; i++) {
368 *(uint8_t *) (&buf[i]) = ReadDOC(docptr, 2k_CDSN_IO + i);
369 }
370 } else {
371 for (i = 0; i < len; i += 4) {
372 *(uint32_t *) (&buf[i]) = readl(docptr + DoC_2k_CDSN_IO + i);
373 }
374 }
375}
376
377static uint16_t __init doc200x_ident_chip(struct mtd_info *mtd, int nr)
378{
379 struct nand_chip *this = mtd->priv;
380 struct doc_priv *doc = this->priv;
381 uint16_t ret;
382
383 doc200x_select_chip(mtd, nr);
384 doc200x_hwcontrol(mtd, NAND_CMD_READID,
385 NAND_CTRL_CLE | NAND_CTRL_CHANGE);
386 doc200x_hwcontrol(mtd, 0, NAND_CTRL_ALE | NAND_CTRL_CHANGE);
387 doc200x_hwcontrol(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
388
389 /* We can't use dev_ready here, but at least we wait for the
390 * command to complete
391 */
392 udelay(50);
393
394 ret = this->read_byte(mtd) << 8;
395 ret |= this->read_byte(mtd);
396
397 if (doc->ChipID == DOC_ChipID_Doc2k && try_dword && !nr) {
398 /* First chip probe. See if we get same results by 32-bit access */
399 union {
400 uint32_t dword;
401 uint8_t byte[4];
402 } ident;
403 void __iomem *docptr = doc->virtadr;
404
405 doc200x_hwcontrol(mtd, NAND_CMD_READID,
406 NAND_CTRL_CLE | NAND_CTRL_CHANGE);
407 doc200x_hwcontrol(mtd, 0, NAND_CTRL_ALE | NAND_CTRL_CHANGE);
408 doc200x_hwcontrol(mtd, NAND_CMD_NONE,
409 NAND_NCE | NAND_CTRL_CHANGE);
410
411 udelay(50);
412
413 ident.dword = readl(docptr + DoC_2k_CDSN_IO);
414 if (((ident.byte[0] << 8) | ident.byte[1]) == ret) {
415 printk(KERN_INFO "DiskOnChip 2000 responds to DWORD access\n");
416 this->read_buf = &doc2000_readbuf_dword;
417 }
418 }
419
420 return ret;
421}
422
423static void __init doc2000_count_chips(struct mtd_info *mtd)
424{
425 struct nand_chip *this = mtd->priv;
426 struct doc_priv *doc = this->priv;
427 uint16_t mfrid;
428 int i;
429
430 /* Max 4 chips per floor on DiskOnChip 2000 */
431 doc->chips_per_floor = 4;
432
433 /* Find out what the first chip is */
434 mfrid = doc200x_ident_chip(mtd, 0);
435
436 /* Find how many chips in each floor. */
437 for (i = 1; i < 4; i++) {
438 if (doc200x_ident_chip(mtd, i) != mfrid)
439 break;
440 }
441 doc->chips_per_floor = i;
442 printk(KERN_DEBUG "Detected %d chips per floor.\n", i);
443}
444
445static int doc200x_wait(struct mtd_info *mtd, struct nand_chip *this)
446{
447 struct doc_priv *doc = this->priv;
448
449 int status;
450
451 DoC_WaitReady(doc);
452 this->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
453 DoC_WaitReady(doc);
454 status = (int)this->read_byte(mtd);
455
456 return status;
457}
458
459static void doc2001_write_byte(struct mtd_info *mtd, u_char datum)
460{
461 struct nand_chip *this = mtd->priv;
462 struct doc_priv *doc = this->priv;
463 void __iomem *docptr = doc->virtadr;
464
465 WriteDOC(datum, docptr, CDSNSlowIO);
466 WriteDOC(datum, docptr, Mil_CDSN_IO);
467 WriteDOC(datum, docptr, WritePipeTerm);
468}
469
470static u_char doc2001_read_byte(struct mtd_info *mtd)
471{
472 struct nand_chip *this = mtd->priv;
473 struct doc_priv *doc = this->priv;
474 void __iomem *docptr = doc->virtadr;
475
476 //ReadDOC(docptr, CDSNSlowIO);
477 /* 11.4.5 -- delay twice to allow extended length cycle */
478 DoC_Delay(doc, 2);
479 ReadDOC(docptr, ReadPipeInit);
480 //return ReadDOC(docptr, Mil_CDSN_IO);
481 return ReadDOC(docptr, LastDataRead);
482}
483
484static void doc2001_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
485{
486 struct nand_chip *this = mtd->priv;
487 struct doc_priv *doc = this->priv;
488 void __iomem *docptr = doc->virtadr;
489 int i;
490
491 for (i = 0; i < len; i++)
492 WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
493 /* Terminate write pipeline */
494 WriteDOC(0x00, docptr, WritePipeTerm);
495}
496
497static void doc2001_readbuf(struct mtd_info *mtd, u_char *buf, int len)
498{
499 struct nand_chip *this = mtd->priv;
500 struct doc_priv *doc = this->priv;
501 void __iomem *docptr = doc->virtadr;
502 int i;
503
504 /* Start read pipeline */
505 ReadDOC(docptr, ReadPipeInit);
506
507 for (i = 0; i < len - 1; i++)
508 buf[i] = ReadDOC(docptr, Mil_CDSN_IO + (i & 0xff));
509
510 /* Terminate read pipeline */
511 buf[i] = ReadDOC(docptr, LastDataRead);
512}
513
514static u_char doc2001plus_read_byte(struct mtd_info *mtd)
515{
516 struct nand_chip *this = mtd->priv;
517 struct doc_priv *doc = this->priv;
518 void __iomem *docptr = doc->virtadr;
519 u_char ret;
520
521 ReadDOC(docptr, Mplus_ReadPipeInit);
522 ReadDOC(docptr, Mplus_ReadPipeInit);
523 ret = ReadDOC(docptr, Mplus_LastDataRead);
524 if (debug)
525 printk("read_byte returns %02x\n", ret);
526 return ret;
527}
528
529static void doc2001plus_writebuf(struct mtd_info *mtd, const u_char *buf, int len)
530{
531 struct nand_chip *this = mtd->priv;
532 struct doc_priv *doc = this->priv;
533 void __iomem *docptr = doc->virtadr;
534 int i;
535
536 if (debug)
537 printk("writebuf of %d bytes: ", len);
538 for (i = 0; i < len; i++) {
539 WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
540 if (debug && i < 16)
541 printk("%02x ", buf[i]);
542 }
543 if (debug)
544 printk("\n");
545}
546
547static void doc2001plus_readbuf(struct mtd_info *mtd, u_char *buf, int len)
548{
549 struct nand_chip *this = mtd->priv;
550 struct doc_priv *doc = this->priv;
551 void __iomem *docptr = doc->virtadr;
552 int i;
553
554 if (debug)
555 printk("readbuf of %d bytes: ", len);
556
557 /* Start read pipeline */
558 ReadDOC(docptr, Mplus_ReadPipeInit);
559 ReadDOC(docptr, Mplus_ReadPipeInit);
560
561 for (i = 0; i < len - 2; i++) {
562 buf[i] = ReadDOC(docptr, Mil_CDSN_IO);
563 if (debug && i < 16)
564 printk("%02x ", buf[i]);
565 }
566
567 /* Terminate read pipeline */
568 buf[len - 2] = ReadDOC(docptr, Mplus_LastDataRead);
569 if (debug && i < 16)
570 printk("%02x ", buf[len - 2]);
571 buf[len - 1] = ReadDOC(docptr, Mplus_LastDataRead);
572 if (debug && i < 16)
573 printk("%02x ", buf[len - 1]);
574 if (debug)
575 printk("\n");
576}
577
578static void doc2001plus_select_chip(struct mtd_info *mtd, int chip)
579{
580 struct nand_chip *this = mtd->priv;
581 struct doc_priv *doc = this->priv;
582 void __iomem *docptr = doc->virtadr;
583 int floor = 0;
584
585 if (debug)
586 printk("select chip (%d)\n", chip);
587
588 if (chip == -1) {
589 /* Disable flash internally */
590 WriteDOC(0, docptr, Mplus_FlashSelect);
591 return;
592 }
593
594 floor = chip / doc->chips_per_floor;
595 chip -= (floor * doc->chips_per_floor);
596
597 /* Assert ChipEnable and deassert WriteProtect */
598 WriteDOC((DOC_FLASH_CE), docptr, Mplus_FlashSelect);
599 this->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
600
601 doc->curchip = chip;
602 doc->curfloor = floor;
603}
604
605static void doc200x_select_chip(struct mtd_info *mtd, int chip)
606{
607 struct nand_chip *this = mtd->priv;
608 struct doc_priv *doc = this->priv;
609 void __iomem *docptr = doc->virtadr;
610 int floor = 0;
611
612 if (debug)
613 printk("select chip (%d)\n", chip);
614
615 if (chip == -1)
616 return;
617
618 floor = chip / doc->chips_per_floor;
619 chip -= (floor * doc->chips_per_floor);
620
621 /* 11.4.4 -- deassert CE before changing chip */
622 doc200x_hwcontrol(mtd, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);
623
624 WriteDOC(floor, docptr, FloorSelect);
625 WriteDOC(chip, docptr, CDSNDeviceSelect);
626
627 doc200x_hwcontrol(mtd, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
628
629 doc->curchip = chip;
630 doc->curfloor = floor;
631}
632
633#define CDSN_CTRL_MSK (CDSN_CTRL_CE | CDSN_CTRL_CLE | CDSN_CTRL_ALE)
634
635static void doc200x_hwcontrol(struct mtd_info *mtd, int cmd,
636 unsigned int ctrl)
637{
638 struct nand_chip *this = mtd->priv;
639 struct doc_priv *doc = this->priv;
640 void __iomem *docptr = doc->virtadr;
641
642 if (ctrl & NAND_CTRL_CHANGE) {
643 doc->CDSNControl &= ~CDSN_CTRL_MSK;
644 doc->CDSNControl |= ctrl & CDSN_CTRL_MSK;
645 if (debug)
646 printk("hwcontrol(%d): %02x\n", cmd, doc->CDSNControl);
647 WriteDOC(doc->CDSNControl, docptr, CDSNControl);
648 /* 11.4.3 -- 4 NOPs after CSDNControl write */
649 DoC_Delay(doc, 4);
650 }
651 if (cmd != NAND_CMD_NONE) {
652 if (DoC_is_2000(doc))
653 doc2000_write_byte(mtd, cmd);
654 else
655 doc2001_write_byte(mtd, cmd);
656 }
657}
658
659static void doc2001plus_command(struct mtd_info *mtd, unsigned command, int column, int page_addr)
660{
661 struct nand_chip *this = mtd->priv;
662 struct doc_priv *doc = this->priv;
663 void __iomem *docptr = doc->virtadr;
664
665 /*
666 * Must terminate write pipeline before sending any commands
667 * to the device.
668 */
669 if (command == NAND_CMD_PAGEPROG) {
670 WriteDOC(0x00, docptr, Mplus_WritePipeTerm);
671 WriteDOC(0x00, docptr, Mplus_WritePipeTerm);
672 }
673
674 /*
675 * Write out the command to the device.
676 */
677 if (command == NAND_CMD_SEQIN) {
678 int readcmd;
679
680 if (column >= mtd->writesize) {
681 /* OOB area */
682 column -= mtd->writesize;
683 readcmd = NAND_CMD_READOOB;
684 } else if (column < 256) {
685 /* First 256 bytes --> READ0 */
686 readcmd = NAND_CMD_READ0;
687 } else {
688 column -= 256;
689 readcmd = NAND_CMD_READ1;
690 }
691 WriteDOC(readcmd, docptr, Mplus_FlashCmd);
692 }
693 WriteDOC(command, docptr, Mplus_FlashCmd);
694 WriteDOC(0, docptr, Mplus_WritePipeTerm);
695 WriteDOC(0, docptr, Mplus_WritePipeTerm);
696
697 if (column != -1 || page_addr != -1) {
698 /* Serially input address */
699 if (column != -1) {
700 /* Adjust columns for 16 bit buswidth */
701 if (this->options & NAND_BUSWIDTH_16 &&
702 !nand_opcode_8bits(command))
703 column >>= 1;
704 WriteDOC(column, docptr, Mplus_FlashAddress);
705 }
706 if (page_addr != -1) {
707 WriteDOC((unsigned char)(page_addr & 0xff), docptr, Mplus_FlashAddress);
708 WriteDOC((unsigned char)((page_addr >> 8) & 0xff), docptr, Mplus_FlashAddress);
709 /* One more address cycle for higher density devices */
710 if (this->chipsize & 0x0c000000) {
711 WriteDOC((unsigned char)((page_addr >> 16) & 0x0f), docptr, Mplus_FlashAddress);
712 printk("high density\n");
713 }
714 }
715 WriteDOC(0, docptr, Mplus_WritePipeTerm);
716 WriteDOC(0, docptr, Mplus_WritePipeTerm);
717 /* deassert ALE */
718 if (command == NAND_CMD_READ0 || command == NAND_CMD_READ1 ||
719 command == NAND_CMD_READOOB || command == NAND_CMD_READID)
720 WriteDOC(0, docptr, Mplus_FlashControl);
721 }
722
723 /*
724 * program and erase have their own busy handlers
725 * status and sequential in needs no delay
726 */
727 switch (command) {
728
729 case NAND_CMD_PAGEPROG:
730 case NAND_CMD_ERASE1:
731 case NAND_CMD_ERASE2:
732 case NAND_CMD_SEQIN:
733 case NAND_CMD_STATUS:
734 return;
735
736 case NAND_CMD_RESET:
737 if (this->dev_ready)
738 break;
739 udelay(this->chip_delay);
740 WriteDOC(NAND_CMD_STATUS, docptr, Mplus_FlashCmd);
741 WriteDOC(0, docptr, Mplus_WritePipeTerm);
742 WriteDOC(0, docptr, Mplus_WritePipeTerm);
743 while (!(this->read_byte(mtd) & 0x40)) ;
744 return;
745
746 /* This applies to read commands */
747 default:
748 /*
749 * If we don't have access to the busy pin, we apply the given
750 * command delay
751 */
752 if (!this->dev_ready) {
753 udelay(this->chip_delay);
754 return;
755 }
756 }
757
758 /* Apply this short delay always to ensure that we do wait tWB in
759 * any case on any machine. */
760 ndelay(100);
761 /* wait until command is processed */
762 while (!this->dev_ready(mtd)) ;
763}
764
765static int doc200x_dev_ready(struct mtd_info *mtd)
766{
767 struct nand_chip *this = mtd->priv;
768 struct doc_priv *doc = this->priv;
769 void __iomem *docptr = doc->virtadr;
770
771 if (DoC_is_MillenniumPlus(doc)) {
772 /* 11.4.2 -- must NOP four times before checking FR/B# */
773 DoC_Delay(doc, 4);
774 if ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK) {
775 if (debug)
776 printk("not ready\n");
777 return 0;
778 }
779 if (debug)
780 printk("was ready\n");
781 return 1;
782 } else {
783 /* 11.4.2 -- must NOP four times before checking FR/B# */
784 DoC_Delay(doc, 4);
785 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
786 if (debug)
787 printk("not ready\n");
788 return 0;
789 }
790 /* 11.4.2 -- Must NOP twice if it's ready */
791 DoC_Delay(doc, 2);
792 if (debug)
793 printk("was ready\n");
794 return 1;
795 }
796}
797
798static int doc200x_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
799{
800 /* This is our last resort if we couldn't find or create a BBT. Just
801 pretend all blocks are good. */
802 return 0;
803}
804
805static void doc200x_enable_hwecc(struct mtd_info *mtd, int mode)
806{
807 struct nand_chip *this = mtd->priv;
808 struct doc_priv *doc = this->priv;
809 void __iomem *docptr = doc->virtadr;
810
811 /* Prime the ECC engine */
812 switch (mode) {
813 case NAND_ECC_READ:
814 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
815 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
816 break;
817 case NAND_ECC_WRITE:
818 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
819 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
820 break;
821 }
822}
823
824static void doc2001plus_enable_hwecc(struct mtd_info *mtd, int mode)
825{
826 struct nand_chip *this = mtd->priv;
827 struct doc_priv *doc = this->priv;
828 void __iomem *docptr = doc->virtadr;
829
830 /* Prime the ECC engine */
831 switch (mode) {
832 case NAND_ECC_READ:
833 WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
834 WriteDOC(DOC_ECC_EN, docptr, Mplus_ECCConf);
835 break;
836 case NAND_ECC_WRITE:
837 WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
838 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, Mplus_ECCConf);
839 break;
840 }
841}
842
843/* This code is only called on write */
844static int doc200x_calculate_ecc(struct mtd_info *mtd, const u_char *dat, unsigned char *ecc_code)
845{
846 struct nand_chip *this = mtd->priv;
847 struct doc_priv *doc = this->priv;
848 void __iomem *docptr = doc->virtadr;
849 int i;
850 int emptymatch = 1;
851
852 /* flush the pipeline */
853 if (DoC_is_2000(doc)) {
854 WriteDOC(doc->CDSNControl & ~CDSN_CTRL_FLASH_IO, docptr, CDSNControl);
855 WriteDOC(0, docptr, 2k_CDSN_IO);
856 WriteDOC(0, docptr, 2k_CDSN_IO);
857 WriteDOC(0, docptr, 2k_CDSN_IO);
858 WriteDOC(doc->CDSNControl, docptr, CDSNControl);
859 } else if (DoC_is_MillenniumPlus(doc)) {
860 WriteDOC(0, docptr, Mplus_NOP);
861 WriteDOC(0, docptr, Mplus_NOP);
862 WriteDOC(0, docptr, Mplus_NOP);
863 } else {
864 WriteDOC(0, docptr, NOP);
865 WriteDOC(0, docptr, NOP);
866 WriteDOC(0, docptr, NOP);
867 }
868
869 for (i = 0; i < 6; i++) {
870 if (DoC_is_MillenniumPlus(doc))
871 ecc_code[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
872 else
873 ecc_code[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
874 if (ecc_code[i] != empty_write_ecc[i])
875 emptymatch = 0;
876 }
877 if (DoC_is_MillenniumPlus(doc))
878 WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
879 else
880 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
881#if 0
882 /* If emptymatch=1, we might have an all-0xff data buffer. Check. */
883 if (emptymatch) {
884 /* Note: this somewhat expensive test should not be triggered
885 often. It could be optimized away by examining the data in
886 the writebuf routine, and remembering the result. */
887 for (i = 0; i < 512; i++) {
888 if (dat[i] == 0xff)
889 continue;
890 emptymatch = 0;
891 break;
892 }
893 }
894 /* If emptymatch still =1, we do have an all-0xff data buffer.
895 Return all-0xff ecc value instead of the computed one, so
896 it'll look just like a freshly-erased page. */
897 if (emptymatch)
898 memset(ecc_code, 0xff, 6);
899#endif
900 return 0;
901}
902
903static int doc200x_correct_data(struct mtd_info *mtd, u_char *dat,
904 u_char *read_ecc, u_char *isnull)
905{
906 int i, ret = 0;
907 struct nand_chip *this = mtd->priv;
908 struct doc_priv *doc = this->priv;
909 void __iomem *docptr = doc->virtadr;
910 uint8_t calc_ecc[6];
911 volatile u_char dummy;
912 int emptymatch = 1;
913
914 /* flush the pipeline */
915 if (DoC_is_2000(doc)) {
916 dummy = ReadDOC(docptr, 2k_ECCStatus);
917 dummy = ReadDOC(docptr, 2k_ECCStatus);
918 dummy = ReadDOC(docptr, 2k_ECCStatus);
919 } else if (DoC_is_MillenniumPlus(doc)) {
920 dummy = ReadDOC(docptr, Mplus_ECCConf);
921 dummy = ReadDOC(docptr, Mplus_ECCConf);
922 dummy = ReadDOC(docptr, Mplus_ECCConf);
923 } else {
924 dummy = ReadDOC(docptr, ECCConf);
925 dummy = ReadDOC(docptr, ECCConf);
926 dummy = ReadDOC(docptr, ECCConf);
927 }
928
929 /* Error occurred ? */
930 if (dummy & 0x80) {
931 for (i = 0; i < 6; i++) {
932 if (DoC_is_MillenniumPlus(doc))
933 calc_ecc[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
934 else
935 calc_ecc[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
936 if (calc_ecc[i] != empty_read_syndrome[i])
937 emptymatch = 0;
938 }
939 /* If emptymatch=1, the read syndrome is consistent with an
940 all-0xff data and stored ecc block. Check the stored ecc. */
941 if (emptymatch) {
942 for (i = 0; i < 6; i++) {
943 if (read_ecc[i] == 0xff)
944 continue;
945 emptymatch = 0;
946 break;
947 }
948 }
949 /* If emptymatch still =1, check the data block. */
950 if (emptymatch) {
951 /* Note: this somewhat expensive test should not be triggered
952 often. It could be optimized away by examining the data in
953 the readbuf routine, and remembering the result. */
954 for (i = 0; i < 512; i++) {
955 if (dat[i] == 0xff)
956 continue;
957 emptymatch = 0;
958 break;
959 }
960 }
961 /* If emptymatch still =1, this is almost certainly a freshly-
962 erased block, in which case the ECC will not come out right.
963 We'll suppress the error and tell the caller everything's
964 OK. Because it is. */
965 if (!emptymatch)
966 ret = doc_ecc_decode(rs_decoder, dat, calc_ecc);
967 if (ret > 0)
968 printk(KERN_ERR "doc200x_correct_data corrected %d errors\n", ret);
969 }
970 if (DoC_is_MillenniumPlus(doc))
971 WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
972 else
973 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
974 if (no_ecc_failures && mtd_is_eccerr(ret)) {
975 printk(KERN_ERR "suppressing ECC failure\n");
976 ret = 0;
977 }
978 return ret;
979}
980
981//u_char mydatabuf[528];
982
983/* The strange out-of-order .oobfree list below is a (possibly unneeded)
984 * attempt to retain compatibility. It used to read:
985 * .oobfree = { {8, 8} }
986 * Since that leaves two bytes unusable, it was changed. But the following
987 * scheme might affect existing jffs2 installs by moving the cleanmarker:
988 * .oobfree = { {6, 10} }
989 * jffs2 seems to handle the above gracefully, but the current scheme seems
990 * safer. The only problem with it is that any code that parses oobfree must
991 * be able to handle out-of-order segments.
992 */
993static struct nand_ecclayout doc200x_oobinfo = {
994 .eccbytes = 6,
995 .eccpos = {0, 1, 2, 3, 4, 5},
996 .oobfree = {{8, 8}, {6, 2}}
997};
998
999/* Find the (I)NFTL Media Header, and optionally also the mirror media header.
1000 On successful return, buf will contain a copy of the media header for
1001 further processing. id is the string to scan for, and will presumably be
1002 either "ANAND" or "BNAND". If findmirror=1, also look for the mirror media
1003 header. The page #s of the found media headers are placed in mh0_page and
1004 mh1_page in the DOC private structure. */
1005static int __init find_media_headers(struct mtd_info *mtd, u_char *buf, const char *id, int findmirror)
1006{
1007 struct nand_chip *this = mtd->priv;
1008 struct doc_priv *doc = this->priv;
1009 unsigned offs;
1010 int ret;
1011 size_t retlen;
1012
1013 for (offs = 0; offs < mtd->size; offs += mtd->erasesize) {
1014 ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
1015 if (retlen != mtd->writesize)
1016 continue;
1017 if (ret) {
1018 printk(KERN_WARNING "ECC error scanning DOC at 0x%x\n", offs);
1019 }
1020 if (memcmp(buf, id, 6))
1021 continue;
1022 printk(KERN_INFO "Found DiskOnChip %s Media Header at 0x%x\n", id, offs);
1023 if (doc->mh0_page == -1) {
1024 doc->mh0_page = offs >> this->page_shift;
1025 if (!findmirror)
1026 return 1;
1027 continue;
1028 }
1029 doc->mh1_page = offs >> this->page_shift;
1030 return 2;
1031 }
1032 if (doc->mh0_page == -1) {
1033 printk(KERN_WARNING "DiskOnChip %s Media Header not found.\n", id);
1034 return 0;
1035 }
1036 /* Only one mediaheader was found. We want buf to contain a
1037 mediaheader on return, so we'll have to re-read the one we found. */
1038 offs = doc->mh0_page << this->page_shift;
1039 ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
1040 if (retlen != mtd->writesize) {
1041 /* Insanity. Give up. */
1042 printk(KERN_ERR "Read DiskOnChip Media Header once, but can't reread it???\n");
1043 return 0;
1044 }
1045 return 1;
1046}
1047
1048static inline int __init nftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
1049{
1050 struct nand_chip *this = mtd->priv;
1051 struct doc_priv *doc = this->priv;
1052 int ret = 0;
1053 u_char *buf;
1054 struct NFTLMediaHeader *mh;
1055 const unsigned psize = 1 << this->page_shift;
1056 int numparts = 0;
1057 unsigned blocks, maxblocks;
1058 int offs, numheaders;
1059
1060 buf = kmalloc(mtd->writesize, GFP_KERNEL);
1061 if (!buf) {
1062 return 0;
1063 }
1064 if (!(numheaders = find_media_headers(mtd, buf, "ANAND", 1)))
1065 goto out;
1066 mh = (struct NFTLMediaHeader *)buf;
1067
1068 le16_to_cpus(&mh->NumEraseUnits);
1069 le16_to_cpus(&mh->FirstPhysicalEUN);
1070 le32_to_cpus(&mh->FormattedSize);
1071
1072 printk(KERN_INFO " DataOrgID = %s\n"
1073 " NumEraseUnits = %d\n"
1074 " FirstPhysicalEUN = %d\n"
1075 " FormattedSize = %d\n"
1076 " UnitSizeFactor = %d\n",
1077 mh->DataOrgID, mh->NumEraseUnits,
1078 mh->FirstPhysicalEUN, mh->FormattedSize,
1079 mh->UnitSizeFactor);
1080
1081 blocks = mtd->size >> this->phys_erase_shift;
1082 maxblocks = min(32768U, mtd->erasesize - psize);
1083
1084 if (mh->UnitSizeFactor == 0x00) {
1085 /* Auto-determine UnitSizeFactor. The constraints are:
1086 - There can be at most 32768 virtual blocks.
1087 - There can be at most (virtual block size - page size)
1088 virtual blocks (because MediaHeader+BBT must fit in 1).
1089 */
1090 mh->UnitSizeFactor = 0xff;
1091 while (blocks > maxblocks) {
1092 blocks >>= 1;
1093 maxblocks = min(32768U, (maxblocks << 1) + psize);
1094 mh->UnitSizeFactor--;
1095 }
1096 printk(KERN_WARNING "UnitSizeFactor=0x00 detected. Correct value is assumed to be 0x%02x.\n", mh->UnitSizeFactor);
1097 }
1098
1099 /* NOTE: The lines below modify internal variables of the NAND and MTD
1100 layers; variables with have already been configured by nand_scan.
1101 Unfortunately, we didn't know before this point what these values
1102 should be. Thus, this code is somewhat dependent on the exact
1103 implementation of the NAND layer. */
1104 if (mh->UnitSizeFactor != 0xff) {
1105 this->bbt_erase_shift += (0xff - mh->UnitSizeFactor);
1106 mtd->erasesize <<= (0xff - mh->UnitSizeFactor);
1107 printk(KERN_INFO "Setting virtual erase size to %d\n", mtd->erasesize);
1108 blocks = mtd->size >> this->bbt_erase_shift;
1109 maxblocks = min(32768U, mtd->erasesize - psize);
1110 }
1111
1112 if (blocks > maxblocks) {
1113 printk(KERN_ERR "UnitSizeFactor of 0x%02x is inconsistent with device size. Aborting.\n", mh->UnitSizeFactor);
1114 goto out;
1115 }
1116
1117 /* Skip past the media headers. */
1118 offs = max(doc->mh0_page, doc->mh1_page);
1119 offs <<= this->page_shift;
1120 offs += mtd->erasesize;
1121
1122 if (show_firmware_partition == 1) {
1123 parts[0].name = " DiskOnChip Firmware / Media Header partition";
1124 parts[0].offset = 0;
1125 parts[0].size = offs;
1126 numparts = 1;
1127 }
1128
1129 parts[numparts].name = " DiskOnChip BDTL partition";
1130 parts[numparts].offset = offs;
1131 parts[numparts].size = (mh->NumEraseUnits - numheaders) << this->bbt_erase_shift;
1132
1133 offs += parts[numparts].size;
1134 numparts++;
1135
1136 if (offs < mtd->size) {
1137 parts[numparts].name = " DiskOnChip Remainder partition";
1138 parts[numparts].offset = offs;
1139 parts[numparts].size = mtd->size - offs;
1140 numparts++;
1141 }
1142
1143 ret = numparts;
1144 out:
1145 kfree(buf);
1146 return ret;
1147}
1148
1149/* This is a stripped-down copy of the code in inftlmount.c */
1150static inline int __init inftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
1151{
1152 struct nand_chip *this = mtd->priv;
1153 struct doc_priv *doc = this->priv;
1154 int ret = 0;
1155 u_char *buf;
1156 struct INFTLMediaHeader *mh;
1157 struct INFTLPartition *ip;
1158 int numparts = 0;
1159 int blocks;
1160 int vshift, lastvunit = 0;
1161 int i;
1162 int end = mtd->size;
1163
1164 if (inftl_bbt_write)
1165 end -= (INFTL_BBT_RESERVED_BLOCKS << this->phys_erase_shift);
1166
1167 buf = kmalloc(mtd->writesize, GFP_KERNEL);
1168 if (!buf) {
1169 return 0;
1170 }
1171
1172 if (!find_media_headers(mtd, buf, "BNAND", 0))
1173 goto out;
1174 doc->mh1_page = doc->mh0_page + (4096 >> this->page_shift);
1175 mh = (struct INFTLMediaHeader *)buf;
1176
1177 le32_to_cpus(&mh->NoOfBootImageBlocks);
1178 le32_to_cpus(&mh->NoOfBinaryPartitions);
1179 le32_to_cpus(&mh->NoOfBDTLPartitions);
1180 le32_to_cpus(&mh->BlockMultiplierBits);
1181 le32_to_cpus(&mh->FormatFlags);
1182 le32_to_cpus(&mh->PercentUsed);
1183
1184 printk(KERN_INFO " bootRecordID = %s\n"
1185 " NoOfBootImageBlocks = %d\n"
1186 " NoOfBinaryPartitions = %d\n"
1187 " NoOfBDTLPartitions = %d\n"
1188 " BlockMultiplerBits = %d\n"
1189 " FormatFlgs = %d\n"
1190 " OsakVersion = %d.%d.%d.%d\n"
1191 " PercentUsed = %d\n",
1192 mh->bootRecordID, mh->NoOfBootImageBlocks,
1193 mh->NoOfBinaryPartitions,
1194 mh->NoOfBDTLPartitions,
1195 mh->BlockMultiplierBits, mh->FormatFlags,
1196 ((unsigned char *) &mh->OsakVersion)[0] & 0xf,
1197 ((unsigned char *) &mh->OsakVersion)[1] & 0xf,
1198 ((unsigned char *) &mh->OsakVersion)[2] & 0xf,
1199 ((unsigned char *) &mh->OsakVersion)[3] & 0xf,
1200 mh->PercentUsed);
1201
1202 vshift = this->phys_erase_shift + mh->BlockMultiplierBits;
1203
1204 blocks = mtd->size >> vshift;
1205 if (blocks > 32768) {
1206 printk(KERN_ERR "BlockMultiplierBits=%d is inconsistent with device size. Aborting.\n", mh->BlockMultiplierBits);
1207 goto out;
1208 }
1209
1210 blocks = doc->chips_per_floor << (this->chip_shift - this->phys_erase_shift);
1211 if (inftl_bbt_write && (blocks > mtd->erasesize)) {
1212 printk(KERN_ERR "Writeable BBTs spanning more than one erase block are not yet supported. FIX ME!\n");
1213 goto out;
1214 }
1215
1216 /* Scan the partitions */
1217 for (i = 0; (i < 4); i++) {
1218 ip = &(mh->Partitions[i]);
1219 le32_to_cpus(&ip->virtualUnits);
1220 le32_to_cpus(&ip->firstUnit);
1221 le32_to_cpus(&ip->lastUnit);
1222 le32_to_cpus(&ip->flags);
1223 le32_to_cpus(&ip->spareUnits);
1224 le32_to_cpus(&ip->Reserved0);
1225
1226 printk(KERN_INFO " PARTITION[%d] ->\n"
1227 " virtualUnits = %d\n"
1228 " firstUnit = %d\n"
1229 " lastUnit = %d\n"
1230 " flags = 0x%x\n"
1231 " spareUnits = %d\n",
1232 i, ip->virtualUnits, ip->firstUnit,
1233 ip->lastUnit, ip->flags,
1234 ip->spareUnits);
1235
1236 if ((show_firmware_partition == 1) &&
1237 (i == 0) && (ip->firstUnit > 0)) {
1238 parts[0].name = " DiskOnChip IPL / Media Header partition";
1239 parts[0].offset = 0;
1240 parts[0].size = mtd->erasesize * ip->firstUnit;
1241 numparts = 1;
1242 }
1243
1244 if (ip->flags & INFTL_BINARY)
1245 parts[numparts].name = " DiskOnChip BDK partition";
1246 else
1247 parts[numparts].name = " DiskOnChip BDTL partition";
1248 parts[numparts].offset = ip->firstUnit << vshift;
1249 parts[numparts].size = (1 + ip->lastUnit - ip->firstUnit) << vshift;
1250 numparts++;
1251 if (ip->lastUnit > lastvunit)
1252 lastvunit = ip->lastUnit;
1253 if (ip->flags & INFTL_LAST)
1254 break;
1255 }
1256 lastvunit++;
1257 if ((lastvunit << vshift) < end) {
1258 parts[numparts].name = " DiskOnChip Remainder partition";
1259 parts[numparts].offset = lastvunit << vshift;
1260 parts[numparts].size = end - parts[numparts].offset;
1261 numparts++;
1262 }
1263 ret = numparts;
1264 out:
1265 kfree(buf);
1266 return ret;
1267}
1268
1269static int __init nftl_scan_bbt(struct mtd_info *mtd)
1270{
1271 int ret, numparts;
1272 struct nand_chip *this = mtd->priv;
1273 struct doc_priv *doc = this->priv;
1274 struct mtd_partition parts[2];
1275
1276 memset((char *)parts, 0, sizeof(parts));
1277 /* On NFTL, we have to find the media headers before we can read the
1278 BBTs, since they're stored in the media header eraseblocks. */
1279 numparts = nftl_partscan(mtd, parts);
1280 if (!numparts)
1281 return -EIO;
1282 this->bbt_td->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
1283 NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
1284 NAND_BBT_VERSION;
1285 this->bbt_td->veroffs = 7;
1286 this->bbt_td->pages[0] = doc->mh0_page + 1;
1287 if (doc->mh1_page != -1) {
1288 this->bbt_md->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
1289 NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
1290 NAND_BBT_VERSION;
1291 this->bbt_md->veroffs = 7;
1292 this->bbt_md->pages[0] = doc->mh1_page + 1;
1293 } else {
1294 this->bbt_md = NULL;
1295 }
1296
1297 /* It's safe to set bd=NULL below because NAND_BBT_CREATE is not set.
1298 At least as nand_bbt.c is currently written. */
1299 if ((ret = nand_scan_bbt(mtd, NULL)))
1300 return ret;
1301 mtd_device_register(mtd, NULL, 0);
1302 if (!no_autopart)
1303 mtd_device_register(mtd, parts, numparts);
1304 return 0;
1305}
1306
1307static int __init inftl_scan_bbt(struct mtd_info *mtd)
1308{
1309 int ret, numparts;
1310 struct nand_chip *this = mtd->priv;
1311 struct doc_priv *doc = this->priv;
1312 struct mtd_partition parts[5];
1313
1314 if (this->numchips > doc->chips_per_floor) {
1315 printk(KERN_ERR "Multi-floor INFTL devices not yet supported.\n");
1316 return -EIO;
1317 }
1318
1319 if (DoC_is_MillenniumPlus(doc)) {
1320 this->bbt_td->options = NAND_BBT_2BIT | NAND_BBT_ABSPAGE;
1321 if (inftl_bbt_write)
1322 this->bbt_td->options |= NAND_BBT_WRITE;
1323 this->bbt_td->pages[0] = 2;
1324 this->bbt_md = NULL;
1325 } else {
1326 this->bbt_td->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
1327 if (inftl_bbt_write)
1328 this->bbt_td->options |= NAND_BBT_WRITE;
1329 this->bbt_td->offs = 8;
1330 this->bbt_td->len = 8;
1331 this->bbt_td->veroffs = 7;
1332 this->bbt_td->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
1333 this->bbt_td->reserved_block_code = 0x01;
1334 this->bbt_td->pattern = "MSYS_BBT";
1335
1336 this->bbt_md->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
1337 if (inftl_bbt_write)
1338 this->bbt_md->options |= NAND_BBT_WRITE;
1339 this->bbt_md->offs = 8;
1340 this->bbt_md->len = 8;
1341 this->bbt_md->veroffs = 7;
1342 this->bbt_md->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
1343 this->bbt_md->reserved_block_code = 0x01;
1344 this->bbt_md->pattern = "TBB_SYSM";
1345 }
1346
1347 /* It's safe to set bd=NULL below because NAND_BBT_CREATE is not set.
1348 At least as nand_bbt.c is currently written. */
1349 if ((ret = nand_scan_bbt(mtd, NULL)))
1350 return ret;
1351 memset((char *)parts, 0, sizeof(parts));
1352 numparts = inftl_partscan(mtd, parts);
1353 /* At least for now, require the INFTL Media Header. We could probably
1354 do without it for non-INFTL use, since all it gives us is
1355 autopartitioning, but I want to give it more thought. */
1356 if (!numparts)
1357 return -EIO;
1358 mtd_device_register(mtd, NULL, 0);
1359 if (!no_autopart)
1360 mtd_device_register(mtd, parts, numparts);
1361 return 0;
1362}
1363
1364static inline int __init doc2000_init(struct mtd_info *mtd)
1365{
1366 struct nand_chip *this = mtd->priv;
1367 struct doc_priv *doc = this->priv;
1368
1369 this->read_byte = doc2000_read_byte;
1370 this->write_buf = doc2000_writebuf;
1371 this->read_buf = doc2000_readbuf;
1372 this->scan_bbt = nftl_scan_bbt;
1373
1374 doc->CDSNControl = CDSN_CTRL_FLASH_IO | CDSN_CTRL_ECC_IO;
1375 doc2000_count_chips(mtd);
1376 mtd->name = "DiskOnChip 2000 (NFTL Model)";
1377 return (4 * doc->chips_per_floor);
1378}
1379
1380static inline int __init doc2001_init(struct mtd_info *mtd)
1381{
1382 struct nand_chip *this = mtd->priv;
1383 struct doc_priv *doc = this->priv;
1384
1385 this->read_byte = doc2001_read_byte;
1386 this->write_buf = doc2001_writebuf;
1387 this->read_buf = doc2001_readbuf;
1388
1389 ReadDOC(doc->virtadr, ChipID);
1390 ReadDOC(doc->virtadr, ChipID);
1391 ReadDOC(doc->virtadr, ChipID);
1392 if (ReadDOC(doc->virtadr, ChipID) != DOC_ChipID_DocMil) {
1393 /* It's not a Millennium; it's one of the newer
1394 DiskOnChip 2000 units with a similar ASIC.
1395 Treat it like a Millennium, except that it
1396 can have multiple chips. */
1397 doc2000_count_chips(mtd);
1398 mtd->name = "DiskOnChip 2000 (INFTL Model)";
1399 this->scan_bbt = inftl_scan_bbt;
1400 return (4 * doc->chips_per_floor);
1401 } else {
1402 /* Bog-standard Millennium */
1403 doc->chips_per_floor = 1;
1404 mtd->name = "DiskOnChip Millennium";
1405 this->scan_bbt = nftl_scan_bbt;
1406 return 1;
1407 }
1408}
1409
1410static inline int __init doc2001plus_init(struct mtd_info *mtd)
1411{
1412 struct nand_chip *this = mtd->priv;
1413 struct doc_priv *doc = this->priv;
1414
1415 this->read_byte = doc2001plus_read_byte;
1416 this->write_buf = doc2001plus_writebuf;
1417 this->read_buf = doc2001plus_readbuf;
1418 this->scan_bbt = inftl_scan_bbt;
1419 this->cmd_ctrl = NULL;
1420 this->select_chip = doc2001plus_select_chip;
1421 this->cmdfunc = doc2001plus_command;
1422 this->ecc.hwctl = doc2001plus_enable_hwecc;
1423
1424 doc->chips_per_floor = 1;
1425 mtd->name = "DiskOnChip Millennium Plus";
1426
1427 return 1;
1428}
1429
1430static int __init doc_probe(unsigned long physadr)
1431{
1432 unsigned char ChipID;
1433 struct mtd_info *mtd;
1434 struct nand_chip *nand;
1435 struct doc_priv *doc;
1436 void __iomem *virtadr;
1437 unsigned char save_control;
1438 unsigned char tmp, tmpb, tmpc;
1439 int reg, len, numchips;
1440 int ret = 0;
1441
1442 if (!request_mem_region(physadr, DOC_IOREMAP_LEN, "DiskOnChip"))
1443 return -EBUSY;
1444 virtadr = ioremap(physadr, DOC_IOREMAP_LEN);
1445 if (!virtadr) {
1446 printk(KERN_ERR "Diskonchip ioremap failed: 0x%x bytes at 0x%lx\n", DOC_IOREMAP_LEN, physadr);
1447 ret = -EIO;
1448 goto error_ioremap;
1449 }
1450
1451 /* It's not possible to cleanly detect the DiskOnChip - the
1452 * bootup procedure will put the device into reset mode, and
1453 * it's not possible to talk to it without actually writing
1454 * to the DOCControl register. So we store the current contents
1455 * of the DOCControl register's location, in case we later decide
1456 * that it's not a DiskOnChip, and want to put it back how we
1457 * found it.
1458 */
1459 save_control = ReadDOC(virtadr, DOCControl);
1460
1461 /* Reset the DiskOnChip ASIC */
1462 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
1463 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
1464
1465 /* Enable the DiskOnChip ASIC */
1466 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
1467 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
1468
1469 ChipID = ReadDOC(virtadr, ChipID);
1470
1471 switch (ChipID) {
1472 case DOC_ChipID_Doc2k:
1473 reg = DoC_2k_ECCStatus;
1474 break;
1475 case DOC_ChipID_DocMil:
1476 reg = DoC_ECCConf;
1477 break;
1478 case DOC_ChipID_DocMilPlus16:
1479 case DOC_ChipID_DocMilPlus32:
1480 case 0:
1481 /* Possible Millennium Plus, need to do more checks */
1482 /* Possibly release from power down mode */
1483 for (tmp = 0; (tmp < 4); tmp++)
1484 ReadDOC(virtadr, Mplus_Power);
1485
1486 /* Reset the Millennium Plus ASIC */
1487 tmp = DOC_MODE_RESET | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
1488 WriteDOC(tmp, virtadr, Mplus_DOCControl);
1489 WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
1490
1491 mdelay(1);
1492 /* Enable the Millennium Plus ASIC */
1493 tmp = DOC_MODE_NORMAL | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
1494 WriteDOC(tmp, virtadr, Mplus_DOCControl);
1495 WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
1496 mdelay(1);
1497
1498 ChipID = ReadDOC(virtadr, ChipID);
1499
1500 switch (ChipID) {
1501 case DOC_ChipID_DocMilPlus16:
1502 reg = DoC_Mplus_Toggle;
1503 break;
1504 case DOC_ChipID_DocMilPlus32:
1505 printk(KERN_ERR "DiskOnChip Millennium Plus 32MB is not supported, ignoring.\n");
1506 default:
1507 ret = -ENODEV;
1508 goto notfound;
1509 }
1510 break;
1511
1512 default:
1513 ret = -ENODEV;
1514 goto notfound;
1515 }
1516 /* Check the TOGGLE bit in the ECC register */
1517 tmp = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1518 tmpb = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1519 tmpc = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1520 if ((tmp == tmpb) || (tmp != tmpc)) {
1521 printk(KERN_WARNING "Possible DiskOnChip at 0x%lx failed TOGGLE test, dropping.\n", physadr);
1522 ret = -ENODEV;
1523 goto notfound;
1524 }
1525
1526 for (mtd = doclist; mtd; mtd = doc->nextdoc) {
1527 unsigned char oldval;
1528 unsigned char newval;
1529 nand = mtd->priv;
1530 doc = nand->priv;
1531 /* Use the alias resolution register to determine if this is
1532 in fact the same DOC aliased to a new address. If writes
1533 to one chip's alias resolution register change the value on
1534 the other chip, they're the same chip. */
1535 if (ChipID == DOC_ChipID_DocMilPlus16) {
1536 oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
1537 newval = ReadDOC(virtadr, Mplus_AliasResolution);
1538 } else {
1539 oldval = ReadDOC(doc->virtadr, AliasResolution);
1540 newval = ReadDOC(virtadr, AliasResolution);
1541 }
1542 if (oldval != newval)
1543 continue;
1544 if (ChipID == DOC_ChipID_DocMilPlus16) {
1545 WriteDOC(~newval, virtadr, Mplus_AliasResolution);
1546 oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
1547 WriteDOC(newval, virtadr, Mplus_AliasResolution); // restore it
1548 } else {
1549 WriteDOC(~newval, virtadr, AliasResolution);
1550 oldval = ReadDOC(doc->virtadr, AliasResolution);
1551 WriteDOC(newval, virtadr, AliasResolution); // restore it
1552 }
1553 newval = ~newval;
1554 if (oldval == newval) {
1555 printk(KERN_DEBUG "Found alias of DOC at 0x%lx to 0x%lx\n", doc->physadr, physadr);
1556 goto notfound;
1557 }
1558 }
1559
1560 printk(KERN_NOTICE "DiskOnChip found at 0x%lx\n", physadr);
1561
1562 len = sizeof(struct mtd_info) +
1563 sizeof(struct nand_chip) + sizeof(struct doc_priv) + (2 * sizeof(struct nand_bbt_descr));
1564 mtd = kzalloc(len, GFP_KERNEL);
1565 if (!mtd) {
1566 ret = -ENOMEM;
1567 goto fail;
1568 }
1569
1570 nand = (struct nand_chip *) (mtd + 1);
1571 doc = (struct doc_priv *) (nand + 1);
1572 nand->bbt_td = (struct nand_bbt_descr *) (doc + 1);
1573 nand->bbt_md = nand->bbt_td + 1;
1574
1575 mtd->priv = nand;
1576 mtd->owner = THIS_MODULE;
1577
1578 nand->priv = doc;
1579 nand->select_chip = doc200x_select_chip;
1580 nand->cmd_ctrl = doc200x_hwcontrol;
1581 nand->dev_ready = doc200x_dev_ready;
1582 nand->waitfunc = doc200x_wait;
1583 nand->block_bad = doc200x_block_bad;
1584 nand->ecc.hwctl = doc200x_enable_hwecc;
1585 nand->ecc.calculate = doc200x_calculate_ecc;
1586 nand->ecc.correct = doc200x_correct_data;
1587
1588 nand->ecc.layout = &doc200x_oobinfo;
1589 nand->ecc.mode = NAND_ECC_HW_SYNDROME;
1590 nand->ecc.size = 512;
1591 nand->ecc.bytes = 6;
1592 nand->ecc.strength = 2;
1593 nand->bbt_options = NAND_BBT_USE_FLASH;
1594
1595 doc->physadr = physadr;
1596 doc->virtadr = virtadr;
1597 doc->ChipID = ChipID;
1598 doc->curfloor = -1;
1599 doc->curchip = -1;
1600 doc->mh0_page = -1;
1601 doc->mh1_page = -1;
1602 doc->nextdoc = doclist;
1603
1604 if (ChipID == DOC_ChipID_Doc2k)
1605 numchips = doc2000_init(mtd);
1606 else if (ChipID == DOC_ChipID_DocMilPlus16)
1607 numchips = doc2001plus_init(mtd);
1608 else
1609 numchips = doc2001_init(mtd);
1610
1611 if ((ret = nand_scan(mtd, numchips))) {
1612 /* DBB note: i believe nand_release is necessary here, as
1613 buffers may have been allocated in nand_base. Check with
1614 Thomas. FIX ME! */
1615 /* nand_release will call mtd_device_unregister, but we
1616 haven't yet added it. This is handled without incident by
1617 mtd_device_unregister, as far as I can tell. */
1618 nand_release(mtd);
1619 kfree(mtd);
1620 goto fail;
1621 }
1622
1623 /* Success! */
1624 doclist = mtd;
1625 return 0;
1626
1627 notfound:
1628 /* Put back the contents of the DOCControl register, in case it's not
1629 actually a DiskOnChip. */
1630 WriteDOC(save_control, virtadr, DOCControl);
1631 fail:
1632 iounmap(virtadr);
1633
1634error_ioremap:
1635 release_mem_region(physadr, DOC_IOREMAP_LEN);
1636
1637 return ret;
1638}
1639
1640static void release_nanddoc(void)
1641{
1642 struct mtd_info *mtd, *nextmtd;
1643 struct nand_chip *nand;
1644 struct doc_priv *doc;
1645
1646 for (mtd = doclist; mtd; mtd = nextmtd) {
1647 nand = mtd->priv;
1648 doc = nand->priv;
1649
1650 nextmtd = doc->nextdoc;
1651 nand_release(mtd);
1652 iounmap(doc->virtadr);
1653 release_mem_region(doc->physadr, DOC_IOREMAP_LEN);
1654 kfree(mtd);
1655 }
1656}
1657
1658static int __init init_nanddoc(void)
1659{
1660 int i, ret = 0;
1661
1662 /* We could create the decoder on demand, if memory is a concern.
1663 * This way we have it handy, if an error happens
1664 *
1665 * Symbolsize is 10 (bits)
1666 * Primitve polynomial is x^10+x^3+1
1667 * first consecutive root is 510
1668 * primitve element to generate roots = 1
1669 * generator polinomial degree = 4
1670 */
1671 rs_decoder = init_rs(10, 0x409, FCR, 1, NROOTS);
1672 if (!rs_decoder) {
1673 printk(KERN_ERR "DiskOnChip: Could not create a RS decoder\n");
1674 return -ENOMEM;
1675 }
1676
1677 if (doc_config_location) {
1678 printk(KERN_INFO "Using configured DiskOnChip probe address 0x%lx\n", doc_config_location);
1679 ret = doc_probe(doc_config_location);
1680 if (ret < 0)
1681 goto outerr;
1682 } else {
1683 for (i = 0; (doc_locations[i] != 0xffffffff); i++) {
1684 doc_probe(doc_locations[i]);
1685 }
1686 }
1687 /* No banner message any more. Print a message if no DiskOnChip
1688 found, so the user knows we at least tried. */
1689 if (!doclist) {
1690 printk(KERN_INFO "No valid DiskOnChip devices found\n");
1691 ret = -ENODEV;
1692 goto outerr;
1693 }
1694 return 0;
1695 outerr:
1696 free_rs(rs_decoder);
1697 return ret;
1698}
1699
1700static void __exit cleanup_nanddoc(void)
1701{
1702 /* Cleanup the nand/DoC resources */
1703 release_nanddoc();
1704
1705 /* Free the reed solomon resources */
1706 if (rs_decoder) {
1707 free_rs(rs_decoder);
1708 }
1709}
1710
1711module_init(init_nanddoc);
1712module_exit(cleanup_nanddoc);
1713
1714MODULE_LICENSE("GPL");
1715MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1716MODULE_DESCRIPTION("M-Systems DiskOnChip 2000, Millennium and Millennium Plus device driver");