2 * (C) 2003 Red Hat, Inc.
3 * (C) 2004 Dan Brown <dan_brown@ieee.org>
4 * (C) 2004 Kalev Lember <kalev@smartlink.ee>
6 * Author: David Woodhouse <dwmw2@infradead.org>
7 * Additional Diskonchip 2000 and Millennium support by Dan Brown <dan_brown@ieee.org>
8 * Diskonchip Millennium Plus support by Kalev Lember <kalev@smartlink.ee>
10 * Error correction code lifted from the old docecc code
11 * Author: Fabrice Bellard (fabrice.bellard@netgem.com)
12 * Copyright (C) 2000 Netgem S.A.
13 * converted to the generic Reed-Solomon library by Thomas Gleixner <tglx@linutronix.de>
15 * Interface to generic NAND code for M-Systems DiskOnChip devices
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/sched.h>
21 #include <linux/delay.h>
22 #include <linux/rslib.h>
23 #include <linux/moduleparam.h>
24 #include <linux/slab.h>
27 #include <linux/mtd/mtd.h>
28 #include <linux/mtd/rawnand.h>
29 #include <linux/mtd/doc2000.h>
30 #include <linux/mtd/partitions.h>
31 #include <linux/mtd/inftl.h>
32 #include <linux/module.h>
34 /* Where to look for the devices? */
35 #ifndef CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS
36 #define CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS 0
39 static unsigned long doc_locations[] __initdata = {
40 #if defined (__alpha__) || defined(__i386__) || defined(__x86_64__)
41 #ifdef CONFIG_MTD_NAND_DISKONCHIP_PROBE_HIGH
42 0xfffc8000, 0xfffca000, 0xfffcc000, 0xfffce000,
43 0xfffd0000, 0xfffd2000, 0xfffd4000, 0xfffd6000,
44 0xfffd8000, 0xfffda000, 0xfffdc000, 0xfffde000,
45 0xfffe0000, 0xfffe2000, 0xfffe4000, 0xfffe6000,
46 0xfffe8000, 0xfffea000, 0xfffec000, 0xfffee000,
48 0xc8000, 0xca000, 0xcc000, 0xce000,
49 0xd0000, 0xd2000, 0xd4000, 0xd6000,
50 0xd8000, 0xda000, 0xdc000, 0xde000,
51 0xe0000, 0xe2000, 0xe4000, 0xe6000,
52 0xe8000, 0xea000, 0xec000, 0xee000,
57 static struct mtd_info *doclist = NULL;
60 void __iomem *virtadr;
61 unsigned long physadr;
64 int chips_per_floor; /* The number of chips detected on each floor */
69 struct rs_control *rs_decoder;
70 struct mtd_info *nextdoc;
72 /* Handle the last stage of initialization (BBT scan, partitioning) */
73 int (*late_init)(struct mtd_info *mtd);
76 /* This is the ecc value computed by the HW ecc generator upon writing an empty
77 page, one with all 0xff for data. */
78 static u_char empty_write_ecc[6] = { 0x4b, 0x00, 0xe2, 0x0e, 0x93, 0xf7 };
80 #define INFTL_BBT_RESERVED_BLOCKS 4
82 #define DoC_is_MillenniumPlus(doc) ((doc)->ChipID == DOC_ChipID_DocMilPlus16 || (doc)->ChipID == DOC_ChipID_DocMilPlus32)
83 #define DoC_is_Millennium(doc) ((doc)->ChipID == DOC_ChipID_DocMil)
84 #define DoC_is_2000(doc) ((doc)->ChipID == DOC_ChipID_Doc2k)
86 static void doc200x_hwcontrol(struct nand_chip *this, int cmd,
87 unsigned int bitmask);
88 static void doc200x_select_chip(struct nand_chip *this, int chip);
91 module_param(debug, int, 0);
93 static int try_dword = 1;
94 module_param(try_dword, int, 0);
96 static int no_ecc_failures = 0;
97 module_param(no_ecc_failures, int, 0);
99 static int no_autopart = 0;
100 module_param(no_autopart, int, 0);
102 static int show_firmware_partition = 0;
103 module_param(show_firmware_partition, int, 0);
105 #ifdef CONFIG_MTD_NAND_DISKONCHIP_BBTWRITE
106 static int inftl_bbt_write = 1;
108 static int inftl_bbt_write = 0;
110 module_param(inftl_bbt_write, int, 0);
112 static unsigned long doc_config_location = CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS;
113 module_param(doc_config_location, ulong, 0);
114 MODULE_PARM_DESC(doc_config_location, "Physical memory address at which to probe for DiskOnChip");
116 /* Sector size for HW ECC */
117 #define SECTOR_SIZE 512
118 /* The sector bytes are packed into NB_DATA 10 bit words */
119 #define NB_DATA (((SECTOR_SIZE + 1) * 8 + 6) / 10)
120 /* Number of roots */
122 /* First consective root */
124 /* Number of symbols */
128 * The HW decoder in the DoC ASIC's provides us a error syndrome,
129 * which we must convert to a standard syndrome usable by the generic
130 * Reed-Solomon library code.
132 * Fabrice Bellard figured this out in the old docecc code. I added
133 * some comments, improved a minor bit and converted it to make use
134 * of the generic Reed-Solomon library. tglx
136 static int doc_ecc_decode(struct rs_control *rs, uint8_t *data, uint8_t *ecc)
138 int i, j, nerr, errpos[8];
140 uint16_t ds[4], s[5], tmp, errval[8], syn[4];
141 struct rs_codec *cd = rs->codec;
143 memset(syn, 0, sizeof(syn));
144 /* Convert the ecc bytes into words */
145 ds[0] = ((ecc[4] & 0xff) >> 0) | ((ecc[5] & 0x03) << 8);
146 ds[1] = ((ecc[5] & 0xfc) >> 2) | ((ecc[2] & 0x0f) << 6);
147 ds[2] = ((ecc[2] & 0xf0) >> 4) | ((ecc[3] & 0x3f) << 4);
148 ds[3] = ((ecc[3] & 0xc0) >> 6) | ((ecc[0] & 0xff) << 2);
151 /* Initialize the syndrome buffer */
152 for (i = 0; i < NROOTS; i++)
156 * s[i] = ds[3]x^3 + ds[2]x^2 + ds[1]x^1 + ds[0]
157 * where x = alpha^(FCR + i)
159 for (j = 1; j < NROOTS; j++) {
162 tmp = cd->index_of[ds[j]];
163 for (i = 0; i < NROOTS; i++)
164 s[i] ^= cd->alpha_to[rs_modnn(cd, tmp + (FCR + i) * j)];
167 /* Calc syn[i] = s[i] / alpha^(v + i) */
168 for (i = 0; i < NROOTS; i++) {
170 syn[i] = rs_modnn(cd, cd->index_of[s[i]] + (NN - FCR - i));
172 /* Call the decoder library */
173 nerr = decode_rs16(rs, NULL, NULL, 1019, syn, 0, errpos, 0, errval);
175 /* Incorrectable errors ? */
180 * Correct the errors. The bitpositions are a bit of magic,
181 * but they are given by the design of the de/encoder circuit
184 for (i = 0; i < nerr; i++) {
185 int index, bitpos, pos = 1015 - errpos[i];
187 if (pos >= NB_DATA && pos < 1019)
190 /* extract bit position (MSB first) */
191 pos = 10 * (NB_DATA - 1 - pos) - 6;
192 /* now correct the following 10 bits. At most two bytes
193 can be modified since pos is even */
194 index = (pos >> 3) ^ 1;
196 if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
197 val = (uint8_t) (errval[i] >> (2 + bitpos));
199 if (index < SECTOR_SIZE)
202 index = ((pos >> 3) + 1) ^ 1;
203 bitpos = (bitpos + 10) & 7;
206 if ((index >= 0 && index < SECTOR_SIZE) || index == (SECTOR_SIZE + 1)) {
207 val = (uint8_t) (errval[i] << (8 - bitpos));
209 if (index < SECTOR_SIZE)
214 /* If the parity is wrong, no rescue possible */
215 return parity ? -EBADMSG : nerr;
218 static void DoC_Delay(struct doc_priv *doc, unsigned short cycles)
223 for (i = 0; i < cycles; i++) {
224 if (DoC_is_Millennium(doc))
225 dummy = ReadDOC(doc->virtadr, NOP);
226 else if (DoC_is_MillenniumPlus(doc))
227 dummy = ReadDOC(doc->virtadr, Mplus_NOP);
229 dummy = ReadDOC(doc->virtadr, DOCStatus);
234 #define CDSN_CTRL_FR_B_MASK (CDSN_CTRL_FR_B0 | CDSN_CTRL_FR_B1)
236 /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
237 static int _DoC_WaitReady(struct doc_priv *doc)
239 void __iomem *docptr = doc->virtadr;
240 unsigned long timeo = jiffies + (HZ * 10);
243 printk("_DoC_WaitReady...\n");
244 /* Out-of-line routine to wait for chip response */
245 if (DoC_is_MillenniumPlus(doc)) {
246 while ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK) {
247 if (time_after(jiffies, timeo)) {
248 printk("_DoC_WaitReady timed out.\n");
255 while (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
256 if (time_after(jiffies, timeo)) {
257 printk("_DoC_WaitReady timed out.\n");
268 static inline int DoC_WaitReady(struct doc_priv *doc)
270 void __iomem *docptr = doc->virtadr;
273 if (DoC_is_MillenniumPlus(doc)) {
276 if ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK)
277 /* Call the out-of-line routine to wait */
278 ret = _DoC_WaitReady(doc);
282 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B))
283 /* Call the out-of-line routine to wait */
284 ret = _DoC_WaitReady(doc);
289 printk("DoC_WaitReady OK\n");
293 static void doc2000_write_byte(struct nand_chip *this, u_char datum)
295 struct doc_priv *doc = nand_get_controller_data(this);
296 void __iomem *docptr = doc->virtadr;
299 printk("write_byte %02x\n", datum);
300 WriteDOC(datum, docptr, CDSNSlowIO);
301 WriteDOC(datum, docptr, 2k_CDSN_IO);
304 static u_char doc2000_read_byte(struct nand_chip *this)
306 struct doc_priv *doc = nand_get_controller_data(this);
307 void __iomem *docptr = doc->virtadr;
310 ReadDOC(docptr, CDSNSlowIO);
312 ret = ReadDOC(docptr, 2k_CDSN_IO);
314 printk("read_byte returns %02x\n", ret);
318 static void doc2000_writebuf(struct nand_chip *this, const u_char *buf,
321 struct doc_priv *doc = nand_get_controller_data(this);
322 void __iomem *docptr = doc->virtadr;
325 printk("writebuf of %d bytes: ", len);
326 for (i = 0; i < len; i++) {
327 WriteDOC_(buf[i], docptr, DoC_2k_CDSN_IO + i);
329 printk("%02x ", buf[i]);
335 static void doc2000_readbuf(struct nand_chip *this, u_char *buf, int len)
337 struct doc_priv *doc = nand_get_controller_data(this);
338 void __iomem *docptr = doc->virtadr;
342 printk("readbuf of %d bytes: ", len);
344 for (i = 0; i < len; i++)
345 buf[i] = ReadDOC(docptr, 2k_CDSN_IO + i);
348 static void doc2000_readbuf_dword(struct nand_chip *this, u_char *buf, int len)
350 struct doc_priv *doc = nand_get_controller_data(this);
351 void __iomem *docptr = doc->virtadr;
355 printk("readbuf_dword of %d bytes: ", len);
357 if (unlikely((((unsigned long)buf) | len) & 3)) {
358 for (i = 0; i < len; i++) {
359 *(uint8_t *) (&buf[i]) = ReadDOC(docptr, 2k_CDSN_IO + i);
362 for (i = 0; i < len; i += 4) {
363 *(uint32_t *) (&buf[i]) = readl(docptr + DoC_2k_CDSN_IO + i);
368 static uint16_t __init doc200x_ident_chip(struct mtd_info *mtd, int nr)
370 struct nand_chip *this = mtd_to_nand(mtd);
371 struct doc_priv *doc = nand_get_controller_data(this);
374 doc200x_select_chip(this, nr);
375 doc200x_hwcontrol(this, NAND_CMD_READID,
376 NAND_CTRL_CLE | NAND_CTRL_CHANGE);
377 doc200x_hwcontrol(this, 0, NAND_CTRL_ALE | NAND_CTRL_CHANGE);
378 doc200x_hwcontrol(this, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
380 /* We can't use dev_ready here, but at least we wait for the
381 * command to complete
385 ret = this->legacy.read_byte(this) << 8;
386 ret |= this->legacy.read_byte(this);
388 if (doc->ChipID == DOC_ChipID_Doc2k && try_dword && !nr) {
389 /* First chip probe. See if we get same results by 32-bit access */
394 void __iomem *docptr = doc->virtadr;
396 doc200x_hwcontrol(this, NAND_CMD_READID,
397 NAND_CTRL_CLE | NAND_CTRL_CHANGE);
398 doc200x_hwcontrol(this, 0, NAND_CTRL_ALE | NAND_CTRL_CHANGE);
399 doc200x_hwcontrol(this, NAND_CMD_NONE,
400 NAND_NCE | NAND_CTRL_CHANGE);
404 ident.dword = readl(docptr + DoC_2k_CDSN_IO);
405 if (((ident.byte[0] << 8) | ident.byte[1]) == ret) {
406 pr_info("DiskOnChip 2000 responds to DWORD access\n");
407 this->legacy.read_buf = &doc2000_readbuf_dword;
414 static void __init doc2000_count_chips(struct mtd_info *mtd)
416 struct nand_chip *this = mtd_to_nand(mtd);
417 struct doc_priv *doc = nand_get_controller_data(this);
421 /* Max 4 chips per floor on DiskOnChip 2000 */
422 doc->chips_per_floor = 4;
424 /* Find out what the first chip is */
425 mfrid = doc200x_ident_chip(mtd, 0);
427 /* Find how many chips in each floor. */
428 for (i = 1; i < 4; i++) {
429 if (doc200x_ident_chip(mtd, i) != mfrid)
432 doc->chips_per_floor = i;
433 pr_debug("Detected %d chips per floor.\n", i);
436 static int doc200x_wait(struct nand_chip *this)
438 struct doc_priv *doc = nand_get_controller_data(this);
443 nand_status_op(this, NULL);
445 status = (int)this->legacy.read_byte(this);
450 static void doc2001_write_byte(struct nand_chip *this, u_char datum)
452 struct doc_priv *doc = nand_get_controller_data(this);
453 void __iomem *docptr = doc->virtadr;
455 WriteDOC(datum, docptr, CDSNSlowIO);
456 WriteDOC(datum, docptr, Mil_CDSN_IO);
457 WriteDOC(datum, docptr, WritePipeTerm);
460 static u_char doc2001_read_byte(struct nand_chip *this)
462 struct doc_priv *doc = nand_get_controller_data(this);
463 void __iomem *docptr = doc->virtadr;
465 //ReadDOC(docptr, CDSNSlowIO);
466 /* 11.4.5 -- delay twice to allow extended length cycle */
468 ReadDOC(docptr, ReadPipeInit);
469 //return ReadDOC(docptr, Mil_CDSN_IO);
470 return ReadDOC(docptr, LastDataRead);
473 static void doc2001_writebuf(struct nand_chip *this, const u_char *buf, int len)
475 struct doc_priv *doc = nand_get_controller_data(this);
476 void __iomem *docptr = doc->virtadr;
479 for (i = 0; i < len; i++)
480 WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
481 /* Terminate write pipeline */
482 WriteDOC(0x00, docptr, WritePipeTerm);
485 static void doc2001_readbuf(struct nand_chip *this, u_char *buf, int len)
487 struct doc_priv *doc = nand_get_controller_data(this);
488 void __iomem *docptr = doc->virtadr;
491 /* Start read pipeline */
492 ReadDOC(docptr, ReadPipeInit);
494 for (i = 0; i < len - 1; i++)
495 buf[i] = ReadDOC(docptr, Mil_CDSN_IO + (i & 0xff));
497 /* Terminate read pipeline */
498 buf[i] = ReadDOC(docptr, LastDataRead);
501 static u_char doc2001plus_read_byte(struct nand_chip *this)
503 struct doc_priv *doc = nand_get_controller_data(this);
504 void __iomem *docptr = doc->virtadr;
507 ReadDOC(docptr, Mplus_ReadPipeInit);
508 ReadDOC(docptr, Mplus_ReadPipeInit);
509 ret = ReadDOC(docptr, Mplus_LastDataRead);
511 printk("read_byte returns %02x\n", ret);
515 static void doc2001plus_writebuf(struct nand_chip *this, const u_char *buf, int len)
517 struct doc_priv *doc = nand_get_controller_data(this);
518 void __iomem *docptr = doc->virtadr;
522 printk("writebuf of %d bytes: ", len);
523 for (i = 0; i < len; i++) {
524 WriteDOC_(buf[i], docptr, DoC_Mil_CDSN_IO + i);
526 printk("%02x ", buf[i]);
532 static void doc2001plus_readbuf(struct nand_chip *this, u_char *buf, int len)
534 struct doc_priv *doc = nand_get_controller_data(this);
535 void __iomem *docptr = doc->virtadr;
539 printk("readbuf of %d bytes: ", len);
541 /* Start read pipeline */
542 ReadDOC(docptr, Mplus_ReadPipeInit);
543 ReadDOC(docptr, Mplus_ReadPipeInit);
545 for (i = 0; i < len - 2; i++) {
546 buf[i] = ReadDOC(docptr, Mil_CDSN_IO);
548 printk("%02x ", buf[i]);
551 /* Terminate read pipeline */
552 buf[len - 2] = ReadDOC(docptr, Mplus_LastDataRead);
554 printk("%02x ", buf[len - 2]);
555 buf[len - 1] = ReadDOC(docptr, Mplus_LastDataRead);
557 printk("%02x ", buf[len - 1]);
562 static void doc2001plus_select_chip(struct nand_chip *this, int chip)
564 struct doc_priv *doc = nand_get_controller_data(this);
565 void __iomem *docptr = doc->virtadr;
569 printk("select chip (%d)\n", chip);
572 /* Disable flash internally */
573 WriteDOC(0, docptr, Mplus_FlashSelect);
577 floor = chip / doc->chips_per_floor;
578 chip -= (floor * doc->chips_per_floor);
580 /* Assert ChipEnable and deassert WriteProtect */
581 WriteDOC((DOC_FLASH_CE), docptr, Mplus_FlashSelect);
585 doc->curfloor = floor;
588 static void doc200x_select_chip(struct nand_chip *this, int chip)
590 struct doc_priv *doc = nand_get_controller_data(this);
591 void __iomem *docptr = doc->virtadr;
595 printk("select chip (%d)\n", chip);
600 floor = chip / doc->chips_per_floor;
601 chip -= (floor * doc->chips_per_floor);
603 /* 11.4.4 -- deassert CE before changing chip */
604 doc200x_hwcontrol(this, NAND_CMD_NONE, 0 | NAND_CTRL_CHANGE);
606 WriteDOC(floor, docptr, FloorSelect);
607 WriteDOC(chip, docptr, CDSNDeviceSelect);
609 doc200x_hwcontrol(this, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
612 doc->curfloor = floor;
615 #define CDSN_CTRL_MSK (CDSN_CTRL_CE | CDSN_CTRL_CLE | CDSN_CTRL_ALE)
617 static void doc200x_hwcontrol(struct nand_chip *this, int cmd,
620 struct doc_priv *doc = nand_get_controller_data(this);
621 void __iomem *docptr = doc->virtadr;
623 if (ctrl & NAND_CTRL_CHANGE) {
624 doc->CDSNControl &= ~CDSN_CTRL_MSK;
625 doc->CDSNControl |= ctrl & CDSN_CTRL_MSK;
627 printk("hwcontrol(%d): %02x\n", cmd, doc->CDSNControl);
628 WriteDOC(doc->CDSNControl, docptr, CDSNControl);
629 /* 11.4.3 -- 4 NOPs after CSDNControl write */
632 if (cmd != NAND_CMD_NONE) {
633 if (DoC_is_2000(doc))
634 doc2000_write_byte(this, cmd);
636 doc2001_write_byte(this, cmd);
640 static void doc2001plus_command(struct nand_chip *this, unsigned command,
641 int column, int page_addr)
643 struct mtd_info *mtd = nand_to_mtd(this);
644 struct doc_priv *doc = nand_get_controller_data(this);
645 void __iomem *docptr = doc->virtadr;
648 * Must terminate write pipeline before sending any commands
651 if (command == NAND_CMD_PAGEPROG) {
652 WriteDOC(0x00, docptr, Mplus_WritePipeTerm);
653 WriteDOC(0x00, docptr, Mplus_WritePipeTerm);
657 * Write out the command to the device.
659 if (command == NAND_CMD_SEQIN) {
662 if (column >= mtd->writesize) {
664 column -= mtd->writesize;
665 readcmd = NAND_CMD_READOOB;
666 } else if (column < 256) {
667 /* First 256 bytes --> READ0 */
668 readcmd = NAND_CMD_READ0;
671 readcmd = NAND_CMD_READ1;
673 WriteDOC(readcmd, docptr, Mplus_FlashCmd);
675 WriteDOC(command, docptr, Mplus_FlashCmd);
676 WriteDOC(0, docptr, Mplus_WritePipeTerm);
677 WriteDOC(0, docptr, Mplus_WritePipeTerm);
679 if (column != -1 || page_addr != -1) {
680 /* Serially input address */
682 /* Adjust columns for 16 bit buswidth */
683 if (this->options & NAND_BUSWIDTH_16 &&
684 !nand_opcode_8bits(command))
686 WriteDOC(column, docptr, Mplus_FlashAddress);
688 if (page_addr != -1) {
689 WriteDOC((unsigned char)(page_addr & 0xff), docptr, Mplus_FlashAddress);
690 WriteDOC((unsigned char)((page_addr >> 8) & 0xff), docptr, Mplus_FlashAddress);
691 if (this->options & NAND_ROW_ADDR_3) {
692 WriteDOC((unsigned char)((page_addr >> 16) & 0x0f), docptr, Mplus_FlashAddress);
693 printk("high density\n");
696 WriteDOC(0, docptr, Mplus_WritePipeTerm);
697 WriteDOC(0, docptr, Mplus_WritePipeTerm);
699 if (command == NAND_CMD_READ0 || command == NAND_CMD_READ1 ||
700 command == NAND_CMD_READOOB || command == NAND_CMD_READID)
701 WriteDOC(0, docptr, Mplus_FlashControl);
705 * program and erase have their own busy handlers
706 * status and sequential in needs no delay
710 case NAND_CMD_PAGEPROG:
711 case NAND_CMD_ERASE1:
712 case NAND_CMD_ERASE2:
714 case NAND_CMD_STATUS:
718 if (this->legacy.dev_ready)
720 udelay(this->legacy.chip_delay);
721 WriteDOC(NAND_CMD_STATUS, docptr, Mplus_FlashCmd);
722 WriteDOC(0, docptr, Mplus_WritePipeTerm);
723 WriteDOC(0, docptr, Mplus_WritePipeTerm);
724 while (!(this->legacy.read_byte(this) & 0x40)) ;
727 /* This applies to read commands */
730 * If we don't have access to the busy pin, we apply the given
733 if (!this->legacy.dev_ready) {
734 udelay(this->legacy.chip_delay);
739 /* Apply this short delay always to ensure that we do wait tWB in
740 * any case on any machine. */
742 /* wait until command is processed */
743 while (!this->legacy.dev_ready(this)) ;
746 static int doc200x_dev_ready(struct nand_chip *this)
748 struct doc_priv *doc = nand_get_controller_data(this);
749 void __iomem *docptr = doc->virtadr;
751 if (DoC_is_MillenniumPlus(doc)) {
752 /* 11.4.2 -- must NOP four times before checking FR/B# */
754 if ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK) {
756 printk("not ready\n");
760 printk("was ready\n");
763 /* 11.4.2 -- must NOP four times before checking FR/B# */
765 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
767 printk("not ready\n");
770 /* 11.4.2 -- Must NOP twice if it's ready */
773 printk("was ready\n");
778 static int doc200x_block_bad(struct nand_chip *this, loff_t ofs)
780 /* This is our last resort if we couldn't find or create a BBT. Just
781 pretend all blocks are good. */
785 static void doc200x_enable_hwecc(struct nand_chip *this, int mode)
787 struct doc_priv *doc = nand_get_controller_data(this);
788 void __iomem *docptr = doc->virtadr;
790 /* Prime the ECC engine */
793 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
794 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
797 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
798 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
803 static void doc2001plus_enable_hwecc(struct nand_chip *this, int mode)
805 struct doc_priv *doc = nand_get_controller_data(this);
806 void __iomem *docptr = doc->virtadr;
808 /* Prime the ECC engine */
811 WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
812 WriteDOC(DOC_ECC_EN, docptr, Mplus_ECCConf);
815 WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
816 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, Mplus_ECCConf);
821 /* This code is only called on write */
822 static int doc200x_calculate_ecc(struct nand_chip *this, const u_char *dat,
823 unsigned char *ecc_code)
825 struct doc_priv *doc = nand_get_controller_data(this);
826 void __iomem *docptr = doc->virtadr;
830 /* flush the pipeline */
831 if (DoC_is_2000(doc)) {
832 WriteDOC(doc->CDSNControl & ~CDSN_CTRL_FLASH_IO, docptr, CDSNControl);
833 WriteDOC(0, docptr, 2k_CDSN_IO);
834 WriteDOC(0, docptr, 2k_CDSN_IO);
835 WriteDOC(0, docptr, 2k_CDSN_IO);
836 WriteDOC(doc->CDSNControl, docptr, CDSNControl);
837 } else if (DoC_is_MillenniumPlus(doc)) {
838 WriteDOC(0, docptr, Mplus_NOP);
839 WriteDOC(0, docptr, Mplus_NOP);
840 WriteDOC(0, docptr, Mplus_NOP);
842 WriteDOC(0, docptr, NOP);
843 WriteDOC(0, docptr, NOP);
844 WriteDOC(0, docptr, NOP);
847 for (i = 0; i < 6; i++) {
848 if (DoC_is_MillenniumPlus(doc))
849 ecc_code[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
851 ecc_code[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
852 if (ecc_code[i] != empty_write_ecc[i])
855 if (DoC_is_MillenniumPlus(doc))
856 WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
858 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
860 /* If emptymatch=1, we might have an all-0xff data buffer. Check. */
862 /* Note: this somewhat expensive test should not be triggered
863 often. It could be optimized away by examining the data in
864 the writebuf routine, and remembering the result. */
865 for (i = 0; i < 512; i++) {
872 /* If emptymatch still =1, we do have an all-0xff data buffer.
873 Return all-0xff ecc value instead of the computed one, so
874 it'll look just like a freshly-erased page. */
876 memset(ecc_code, 0xff, 6);
881 static int doc200x_correct_data(struct nand_chip *this, u_char *dat,
882 u_char *read_ecc, u_char *isnull)
885 struct doc_priv *doc = nand_get_controller_data(this);
886 void __iomem *docptr = doc->virtadr;
888 volatile u_char dummy;
890 /* flush the pipeline */
891 if (DoC_is_2000(doc)) {
892 dummy = ReadDOC(docptr, 2k_ECCStatus);
893 dummy = ReadDOC(docptr, 2k_ECCStatus);
894 dummy = ReadDOC(docptr, 2k_ECCStatus);
895 } else if (DoC_is_MillenniumPlus(doc)) {
896 dummy = ReadDOC(docptr, Mplus_ECCConf);
897 dummy = ReadDOC(docptr, Mplus_ECCConf);
898 dummy = ReadDOC(docptr, Mplus_ECCConf);
900 dummy = ReadDOC(docptr, ECCConf);
901 dummy = ReadDOC(docptr, ECCConf);
902 dummy = ReadDOC(docptr, ECCConf);
905 /* Error occurred ? */
907 for (i = 0; i < 6; i++) {
908 if (DoC_is_MillenniumPlus(doc))
909 calc_ecc[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
911 calc_ecc[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
914 ret = doc_ecc_decode(doc->rs_decoder, dat, calc_ecc);
916 pr_err("doc200x_correct_data corrected %d errors\n",
919 if (DoC_is_MillenniumPlus(doc))
920 WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
922 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
923 if (no_ecc_failures && mtd_is_eccerr(ret)) {
924 pr_err("suppressing ECC failure\n");
930 //u_char mydatabuf[528];
932 static int doc200x_ooblayout_ecc(struct mtd_info *mtd, int section,
933 struct mtd_oob_region *oobregion)
938 oobregion->offset = 0;
939 oobregion->length = 6;
944 static int doc200x_ooblayout_free(struct mtd_info *mtd, int section,
945 struct mtd_oob_region *oobregion)
951 * The strange out-of-order free bytes definition is a (possibly
952 * unneeded) attempt to retain compatibility. It used to read:
953 * .oobfree = { {8, 8} }
954 * Since that leaves two bytes unusable, it was changed. But the
955 * following scheme might affect existing jffs2 installs by moving the
957 * .oobfree = { {6, 10} }
958 * jffs2 seems to handle the above gracefully, but the current scheme
959 * seems safer. The only problem with it is that any code retrieving
960 * free bytes position must be able to handle out-of-order segments.
963 oobregion->offset = 8;
964 oobregion->length = 8;
966 oobregion->offset = 6;
967 oobregion->length = 2;
973 static const struct mtd_ooblayout_ops doc200x_ooblayout_ops = {
974 .ecc = doc200x_ooblayout_ecc,
975 .free = doc200x_ooblayout_free,
978 /* Find the (I)NFTL Media Header, and optionally also the mirror media header.
979 On successful return, buf will contain a copy of the media header for
980 further processing. id is the string to scan for, and will presumably be
981 either "ANAND" or "BNAND". If findmirror=1, also look for the mirror media
982 header. The page #s of the found media headers are placed in mh0_page and
983 mh1_page in the DOC private structure. */
984 static int __init find_media_headers(struct mtd_info *mtd, u_char *buf, const char *id, int findmirror)
986 struct nand_chip *this = mtd_to_nand(mtd);
987 struct doc_priv *doc = nand_get_controller_data(this);
992 for (offs = 0; offs < mtd->size; offs += mtd->erasesize) {
993 ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
994 if (retlen != mtd->writesize)
997 pr_warn("ECC error scanning DOC at 0x%x\n", offs);
999 if (memcmp(buf, id, 6))
1001 pr_info("Found DiskOnChip %s Media Header at 0x%x\n", id, offs);
1002 if (doc->mh0_page == -1) {
1003 doc->mh0_page = offs >> this->page_shift;
1008 doc->mh1_page = offs >> this->page_shift;
1011 if (doc->mh0_page == -1) {
1012 pr_warn("DiskOnChip %s Media Header not found.\n", id);
1015 /* Only one mediaheader was found. We want buf to contain a
1016 mediaheader on return, so we'll have to re-read the one we found. */
1017 offs = doc->mh0_page << this->page_shift;
1018 ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
1019 if (retlen != mtd->writesize) {
1020 /* Insanity. Give up. */
1021 pr_err("Read DiskOnChip Media Header once, but can't reread it???\n");
1027 static inline int __init nftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
1029 struct nand_chip *this = mtd_to_nand(mtd);
1030 struct doc_priv *doc = nand_get_controller_data(this);
1033 struct NFTLMediaHeader *mh;
1034 const unsigned psize = 1 << this->page_shift;
1036 unsigned blocks, maxblocks;
1037 int offs, numheaders;
1039 buf = kmalloc(mtd->writesize, GFP_KERNEL);
1043 if (!(numheaders = find_media_headers(mtd, buf, "ANAND", 1)))
1045 mh = (struct NFTLMediaHeader *)buf;
1047 le16_to_cpus(&mh->NumEraseUnits);
1048 le16_to_cpus(&mh->FirstPhysicalEUN);
1049 le32_to_cpus(&mh->FormattedSize);
1051 pr_info(" DataOrgID = %s\n"
1052 " NumEraseUnits = %d\n"
1053 " FirstPhysicalEUN = %d\n"
1054 " FormattedSize = %d\n"
1055 " UnitSizeFactor = %d\n",
1056 mh->DataOrgID, mh->NumEraseUnits,
1057 mh->FirstPhysicalEUN, mh->FormattedSize,
1058 mh->UnitSizeFactor);
1060 blocks = mtd->size >> this->phys_erase_shift;
1061 maxblocks = min(32768U, mtd->erasesize - psize);
1063 if (mh->UnitSizeFactor == 0x00) {
1064 /* Auto-determine UnitSizeFactor. The constraints are:
1065 - There can be at most 32768 virtual blocks.
1066 - There can be at most (virtual block size - page size)
1067 virtual blocks (because MediaHeader+BBT must fit in 1).
1069 mh->UnitSizeFactor = 0xff;
1070 while (blocks > maxblocks) {
1072 maxblocks = min(32768U, (maxblocks << 1) + psize);
1073 mh->UnitSizeFactor--;
1075 pr_warn("UnitSizeFactor=0x00 detected. Correct value is assumed to be 0x%02x.\n", mh->UnitSizeFactor);
1078 /* NOTE: The lines below modify internal variables of the NAND and MTD
1079 layers; variables with have already been configured by nand_scan.
1080 Unfortunately, we didn't know before this point what these values
1081 should be. Thus, this code is somewhat dependent on the exact
1082 implementation of the NAND layer. */
1083 if (mh->UnitSizeFactor != 0xff) {
1084 this->bbt_erase_shift += (0xff - mh->UnitSizeFactor);
1085 mtd->erasesize <<= (0xff - mh->UnitSizeFactor);
1086 pr_info("Setting virtual erase size to %d\n", mtd->erasesize);
1087 blocks = mtd->size >> this->bbt_erase_shift;
1088 maxblocks = min(32768U, mtd->erasesize - psize);
1091 if (blocks > maxblocks) {
1092 pr_err("UnitSizeFactor of 0x%02x is inconsistent with device size. Aborting.\n", mh->UnitSizeFactor);
1096 /* Skip past the media headers. */
1097 offs = max(doc->mh0_page, doc->mh1_page);
1098 offs <<= this->page_shift;
1099 offs += mtd->erasesize;
1101 if (show_firmware_partition == 1) {
1102 parts[0].name = " DiskOnChip Firmware / Media Header partition";
1103 parts[0].offset = 0;
1104 parts[0].size = offs;
1108 parts[numparts].name = " DiskOnChip BDTL partition";
1109 parts[numparts].offset = offs;
1110 parts[numparts].size = (mh->NumEraseUnits - numheaders) << this->bbt_erase_shift;
1112 offs += parts[numparts].size;
1115 if (offs < mtd->size) {
1116 parts[numparts].name = " DiskOnChip Remainder partition";
1117 parts[numparts].offset = offs;
1118 parts[numparts].size = mtd->size - offs;
1128 /* This is a stripped-down copy of the code in inftlmount.c */
1129 static inline int __init inftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
1131 struct nand_chip *this = mtd_to_nand(mtd);
1132 struct doc_priv *doc = nand_get_controller_data(this);
1135 struct INFTLMediaHeader *mh;
1136 struct INFTLPartition *ip;
1139 int vshift, lastvunit = 0;
1141 int end = mtd->size;
1143 if (inftl_bbt_write)
1144 end -= (INFTL_BBT_RESERVED_BLOCKS << this->phys_erase_shift);
1146 buf = kmalloc(mtd->writesize, GFP_KERNEL);
1151 if (!find_media_headers(mtd, buf, "BNAND", 0))
1153 doc->mh1_page = doc->mh0_page + (4096 >> this->page_shift);
1154 mh = (struct INFTLMediaHeader *)buf;
1156 le32_to_cpus(&mh->NoOfBootImageBlocks);
1157 le32_to_cpus(&mh->NoOfBinaryPartitions);
1158 le32_to_cpus(&mh->NoOfBDTLPartitions);
1159 le32_to_cpus(&mh->BlockMultiplierBits);
1160 le32_to_cpus(&mh->FormatFlags);
1161 le32_to_cpus(&mh->PercentUsed);
1163 pr_info(" bootRecordID = %s\n"
1164 " NoOfBootImageBlocks = %d\n"
1165 " NoOfBinaryPartitions = %d\n"
1166 " NoOfBDTLPartitions = %d\n"
1167 " BlockMultiplerBits = %d\n"
1168 " FormatFlgs = %d\n"
1169 " OsakVersion = %d.%d.%d.%d\n"
1170 " PercentUsed = %d\n",
1171 mh->bootRecordID, mh->NoOfBootImageBlocks,
1172 mh->NoOfBinaryPartitions,
1173 mh->NoOfBDTLPartitions,
1174 mh->BlockMultiplierBits, mh->FormatFlags,
1175 ((unsigned char *) &mh->OsakVersion)[0] & 0xf,
1176 ((unsigned char *) &mh->OsakVersion)[1] & 0xf,
1177 ((unsigned char *) &mh->OsakVersion)[2] & 0xf,
1178 ((unsigned char *) &mh->OsakVersion)[3] & 0xf,
1181 vshift = this->phys_erase_shift + mh->BlockMultiplierBits;
1183 blocks = mtd->size >> vshift;
1184 if (blocks > 32768) {
1185 pr_err("BlockMultiplierBits=%d is inconsistent with device size. Aborting.\n", mh->BlockMultiplierBits);
1189 blocks = doc->chips_per_floor << (this->chip_shift - this->phys_erase_shift);
1190 if (inftl_bbt_write && (blocks > mtd->erasesize)) {
1191 pr_err("Writeable BBTs spanning more than one erase block are not yet supported. FIX ME!\n");
1195 /* Scan the partitions */
1196 for (i = 0; (i < 4); i++) {
1197 ip = &(mh->Partitions[i]);
1198 le32_to_cpus(&ip->virtualUnits);
1199 le32_to_cpus(&ip->firstUnit);
1200 le32_to_cpus(&ip->lastUnit);
1201 le32_to_cpus(&ip->flags);
1202 le32_to_cpus(&ip->spareUnits);
1203 le32_to_cpus(&ip->Reserved0);
1205 pr_info(" PARTITION[%d] ->\n"
1206 " virtualUnits = %d\n"
1210 " spareUnits = %d\n",
1211 i, ip->virtualUnits, ip->firstUnit,
1212 ip->lastUnit, ip->flags,
1215 if ((show_firmware_partition == 1) &&
1216 (i == 0) && (ip->firstUnit > 0)) {
1217 parts[0].name = " DiskOnChip IPL / Media Header partition";
1218 parts[0].offset = 0;
1219 parts[0].size = mtd->erasesize * ip->firstUnit;
1223 if (ip->flags & INFTL_BINARY)
1224 parts[numparts].name = " DiskOnChip BDK partition";
1226 parts[numparts].name = " DiskOnChip BDTL partition";
1227 parts[numparts].offset = ip->firstUnit << vshift;
1228 parts[numparts].size = (1 + ip->lastUnit - ip->firstUnit) << vshift;
1230 if (ip->lastUnit > lastvunit)
1231 lastvunit = ip->lastUnit;
1232 if (ip->flags & INFTL_LAST)
1236 if ((lastvunit << vshift) < end) {
1237 parts[numparts].name = " DiskOnChip Remainder partition";
1238 parts[numparts].offset = lastvunit << vshift;
1239 parts[numparts].size = end - parts[numparts].offset;
1248 static int __init nftl_scan_bbt(struct mtd_info *mtd)
1251 struct nand_chip *this = mtd_to_nand(mtd);
1252 struct doc_priv *doc = nand_get_controller_data(this);
1253 struct mtd_partition parts[2];
1255 memset((char *)parts, 0, sizeof(parts));
1256 /* On NFTL, we have to find the media headers before we can read the
1257 BBTs, since they're stored in the media header eraseblocks. */
1258 numparts = nftl_partscan(mtd, parts);
1261 this->bbt_td->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
1262 NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
1264 this->bbt_td->veroffs = 7;
1265 this->bbt_td->pages[0] = doc->mh0_page + 1;
1266 if (doc->mh1_page != -1) {
1267 this->bbt_md->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
1268 NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
1270 this->bbt_md->veroffs = 7;
1271 this->bbt_md->pages[0] = doc->mh1_page + 1;
1273 this->bbt_md = NULL;
1276 ret = nand_create_bbt(this);
1280 return mtd_device_register(mtd, parts, no_autopart ? 0 : numparts);
1283 static int __init inftl_scan_bbt(struct mtd_info *mtd)
1286 struct nand_chip *this = mtd_to_nand(mtd);
1287 struct doc_priv *doc = nand_get_controller_data(this);
1288 struct mtd_partition parts[5];
1290 if (this->numchips > doc->chips_per_floor) {
1291 pr_err("Multi-floor INFTL devices not yet supported.\n");
1295 if (DoC_is_MillenniumPlus(doc)) {
1296 this->bbt_td->options = NAND_BBT_2BIT | NAND_BBT_ABSPAGE;
1297 if (inftl_bbt_write)
1298 this->bbt_td->options |= NAND_BBT_WRITE;
1299 this->bbt_td->pages[0] = 2;
1300 this->bbt_md = NULL;
1302 this->bbt_td->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
1303 if (inftl_bbt_write)
1304 this->bbt_td->options |= NAND_BBT_WRITE;
1305 this->bbt_td->offs = 8;
1306 this->bbt_td->len = 8;
1307 this->bbt_td->veroffs = 7;
1308 this->bbt_td->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
1309 this->bbt_td->reserved_block_code = 0x01;
1310 this->bbt_td->pattern = "MSYS_BBT";
1312 this->bbt_md->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
1313 if (inftl_bbt_write)
1314 this->bbt_md->options |= NAND_BBT_WRITE;
1315 this->bbt_md->offs = 8;
1316 this->bbt_md->len = 8;
1317 this->bbt_md->veroffs = 7;
1318 this->bbt_md->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
1319 this->bbt_md->reserved_block_code = 0x01;
1320 this->bbt_md->pattern = "TBB_SYSM";
1323 ret = nand_create_bbt(this);
1327 memset((char *)parts, 0, sizeof(parts));
1328 numparts = inftl_partscan(mtd, parts);
1329 /* At least for now, require the INFTL Media Header. We could probably
1330 do without it for non-INFTL use, since all it gives us is
1331 autopartitioning, but I want to give it more thought. */
1334 return mtd_device_register(mtd, parts, no_autopart ? 0 : numparts);
1337 static inline int __init doc2000_init(struct mtd_info *mtd)
1339 struct nand_chip *this = mtd_to_nand(mtd);
1340 struct doc_priv *doc = nand_get_controller_data(this);
1342 this->legacy.read_byte = doc2000_read_byte;
1343 this->legacy.write_buf = doc2000_writebuf;
1344 this->legacy.read_buf = doc2000_readbuf;
1345 doc->late_init = nftl_scan_bbt;
1347 doc->CDSNControl = CDSN_CTRL_FLASH_IO | CDSN_CTRL_ECC_IO;
1348 doc2000_count_chips(mtd);
1349 mtd->name = "DiskOnChip 2000 (NFTL Model)";
1350 return (4 * doc->chips_per_floor);
1353 static inline int __init doc2001_init(struct mtd_info *mtd)
1355 struct nand_chip *this = mtd_to_nand(mtd);
1356 struct doc_priv *doc = nand_get_controller_data(this);
1358 this->legacy.read_byte = doc2001_read_byte;
1359 this->legacy.write_buf = doc2001_writebuf;
1360 this->legacy.read_buf = doc2001_readbuf;
1362 ReadDOC(doc->virtadr, ChipID);
1363 ReadDOC(doc->virtadr, ChipID);
1364 ReadDOC(doc->virtadr, ChipID);
1365 if (ReadDOC(doc->virtadr, ChipID) != DOC_ChipID_DocMil) {
1366 /* It's not a Millennium; it's one of the newer
1367 DiskOnChip 2000 units with a similar ASIC.
1368 Treat it like a Millennium, except that it
1369 can have multiple chips. */
1370 doc2000_count_chips(mtd);
1371 mtd->name = "DiskOnChip 2000 (INFTL Model)";
1372 doc->late_init = inftl_scan_bbt;
1373 return (4 * doc->chips_per_floor);
1375 /* Bog-standard Millennium */
1376 doc->chips_per_floor = 1;
1377 mtd->name = "DiskOnChip Millennium";
1378 doc->late_init = nftl_scan_bbt;
1383 static inline int __init doc2001plus_init(struct mtd_info *mtd)
1385 struct nand_chip *this = mtd_to_nand(mtd);
1386 struct doc_priv *doc = nand_get_controller_data(this);
1388 this->legacy.read_byte = doc2001plus_read_byte;
1389 this->legacy.write_buf = doc2001plus_writebuf;
1390 this->legacy.read_buf = doc2001plus_readbuf;
1391 doc->late_init = inftl_scan_bbt;
1392 this->legacy.cmd_ctrl = NULL;
1393 this->select_chip = doc2001plus_select_chip;
1394 this->legacy.cmdfunc = doc2001plus_command;
1395 this->ecc.hwctl = doc2001plus_enable_hwecc;
1397 doc->chips_per_floor = 1;
1398 mtd->name = "DiskOnChip Millennium Plus";
1403 static int __init doc_probe(unsigned long physadr)
1405 struct nand_chip *nand = NULL;
1406 struct doc_priv *doc = NULL;
1407 unsigned char ChipID;
1408 struct mtd_info *mtd;
1409 void __iomem *virtadr;
1410 unsigned char save_control;
1411 unsigned char tmp, tmpb, tmpc;
1412 int reg, len, numchips;
1415 if (!request_mem_region(physadr, DOC_IOREMAP_LEN, "DiskOnChip"))
1417 virtadr = ioremap(physadr, DOC_IOREMAP_LEN);
1419 pr_err("Diskonchip ioremap failed: 0x%x bytes at 0x%lx\n",
1420 DOC_IOREMAP_LEN, physadr);
1425 /* It's not possible to cleanly detect the DiskOnChip - the
1426 * bootup procedure will put the device into reset mode, and
1427 * it's not possible to talk to it without actually writing
1428 * to the DOCControl register. So we store the current contents
1429 * of the DOCControl register's location, in case we later decide
1430 * that it's not a DiskOnChip, and want to put it back how we
1433 save_control = ReadDOC(virtadr, DOCControl);
1435 /* Reset the DiskOnChip ASIC */
1436 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
1437 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
1439 /* Enable the DiskOnChip ASIC */
1440 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
1441 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
1443 ChipID = ReadDOC(virtadr, ChipID);
1446 case DOC_ChipID_Doc2k:
1447 reg = DoC_2k_ECCStatus;
1449 case DOC_ChipID_DocMil:
1452 case DOC_ChipID_DocMilPlus16:
1453 case DOC_ChipID_DocMilPlus32:
1455 /* Possible Millennium Plus, need to do more checks */
1456 /* Possibly release from power down mode */
1457 for (tmp = 0; (tmp < 4); tmp++)
1458 ReadDOC(virtadr, Mplus_Power);
1460 /* Reset the Millennium Plus ASIC */
1461 tmp = DOC_MODE_RESET | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
1462 WriteDOC(tmp, virtadr, Mplus_DOCControl);
1463 WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
1465 usleep_range(1000, 2000);
1466 /* Enable the Millennium Plus ASIC */
1467 tmp = DOC_MODE_NORMAL | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
1468 WriteDOC(tmp, virtadr, Mplus_DOCControl);
1469 WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
1470 usleep_range(1000, 2000);
1472 ChipID = ReadDOC(virtadr, ChipID);
1475 case DOC_ChipID_DocMilPlus16:
1476 reg = DoC_Mplus_Toggle;
1478 case DOC_ChipID_DocMilPlus32:
1479 pr_err("DiskOnChip Millennium Plus 32MB is not supported, ignoring.\n");
1490 /* Check the TOGGLE bit in the ECC register */
1491 tmp = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1492 tmpb = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1493 tmpc = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1494 if ((tmp == tmpb) || (tmp != tmpc)) {
1495 pr_warn("Possible DiskOnChip at 0x%lx failed TOGGLE test, dropping.\n", physadr);
1500 for (mtd = doclist; mtd; mtd = doc->nextdoc) {
1501 unsigned char oldval;
1502 unsigned char newval;
1503 nand = mtd_to_nand(mtd);
1504 doc = nand_get_controller_data(nand);
1505 /* Use the alias resolution register to determine if this is
1506 in fact the same DOC aliased to a new address. If writes
1507 to one chip's alias resolution register change the value on
1508 the other chip, they're the same chip. */
1509 if (ChipID == DOC_ChipID_DocMilPlus16) {
1510 oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
1511 newval = ReadDOC(virtadr, Mplus_AliasResolution);
1513 oldval = ReadDOC(doc->virtadr, AliasResolution);
1514 newval = ReadDOC(virtadr, AliasResolution);
1516 if (oldval != newval)
1518 if (ChipID == DOC_ChipID_DocMilPlus16) {
1519 WriteDOC(~newval, virtadr, Mplus_AliasResolution);
1520 oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
1521 WriteDOC(newval, virtadr, Mplus_AliasResolution); // restore it
1523 WriteDOC(~newval, virtadr, AliasResolution);
1524 oldval = ReadDOC(doc->virtadr, AliasResolution);
1525 WriteDOC(newval, virtadr, AliasResolution); // restore it
1528 if (oldval == newval) {
1529 pr_debug("Found alias of DOC at 0x%lx to 0x%lx\n",
1530 doc->physadr, physadr);
1535 pr_notice("DiskOnChip found at 0x%lx\n", physadr);
1537 len = sizeof(struct nand_chip) + sizeof(struct doc_priv) +
1538 (2 * sizeof(struct nand_bbt_descr));
1539 nand = kzalloc(len, GFP_KERNEL);
1547 * Allocate a RS codec instance
1549 * Symbolsize is 10 (bits)
1550 * Primitve polynomial is x^10+x^3+1
1551 * First consecutive root is 510
1552 * Primitve element to generate roots = 1
1553 * Generator polinomial degree = 4
1555 doc = (struct doc_priv *) (nand + 1);
1556 doc->rs_decoder = init_rs(10, 0x409, FCR, 1, NROOTS);
1557 if (!doc->rs_decoder) {
1558 pr_err("DiskOnChip: Could not create a RS codec\n");
1563 mtd = nand_to_mtd(nand);
1564 nand->bbt_td = (struct nand_bbt_descr *) (doc + 1);
1565 nand->bbt_md = nand->bbt_td + 1;
1567 mtd->owner = THIS_MODULE;
1568 mtd_set_ooblayout(mtd, &doc200x_ooblayout_ops);
1570 nand_set_controller_data(nand, doc);
1571 nand->select_chip = doc200x_select_chip;
1572 nand->legacy.cmd_ctrl = doc200x_hwcontrol;
1573 nand->legacy.dev_ready = doc200x_dev_ready;
1574 nand->legacy.waitfunc = doc200x_wait;
1575 nand->legacy.block_bad = doc200x_block_bad;
1576 nand->ecc.hwctl = doc200x_enable_hwecc;
1577 nand->ecc.calculate = doc200x_calculate_ecc;
1578 nand->ecc.correct = doc200x_correct_data;
1580 nand->ecc.mode = NAND_ECC_HW_SYNDROME;
1581 nand->ecc.size = 512;
1582 nand->ecc.bytes = 6;
1583 nand->ecc.strength = 2;
1584 nand->ecc.options = NAND_ECC_GENERIC_ERASED_CHECK;
1585 nand->bbt_options = NAND_BBT_USE_FLASH;
1586 /* Skip the automatic BBT scan so we can run it manually */
1587 nand->options |= NAND_SKIP_BBTSCAN;
1589 doc->physadr = physadr;
1590 doc->virtadr = virtadr;
1591 doc->ChipID = ChipID;
1596 doc->nextdoc = doclist;
1598 if (ChipID == DOC_ChipID_Doc2k)
1599 numchips = doc2000_init(mtd);
1600 else if (ChipID == DOC_ChipID_DocMilPlus16)
1601 numchips = doc2001plus_init(mtd);
1603 numchips = doc2001_init(mtd);
1605 if ((ret = nand_scan(nand, numchips)) || (ret = doc->late_init(mtd))) {
1606 /* DBB note: i believe nand_release is necessary here, as
1607 buffers may have been allocated in nand_base. Check with
1609 /* nand_release will call mtd_device_unregister, but we
1610 haven't yet added it. This is handled without incident by
1611 mtd_device_unregister, as far as I can tell. */
1621 /* Put back the contents of the DOCControl register, in case it's not
1622 actually a DiskOnChip. */
1623 WriteDOC(save_control, virtadr, DOCControl);
1626 free_rs(doc->rs_decoder);
1631 release_mem_region(physadr, DOC_IOREMAP_LEN);
1636 static void release_nanddoc(void)
1638 struct mtd_info *mtd, *nextmtd;
1639 struct nand_chip *nand;
1640 struct doc_priv *doc;
1642 for (mtd = doclist; mtd; mtd = nextmtd) {
1643 nand = mtd_to_nand(mtd);
1644 doc = nand_get_controller_data(nand);
1646 nextmtd = doc->nextdoc;
1648 iounmap(doc->virtadr);
1649 release_mem_region(doc->physadr, DOC_IOREMAP_LEN);
1650 free_rs(doc->rs_decoder);
1655 static int __init init_nanddoc(void)
1659 if (doc_config_location) {
1660 pr_info("Using configured DiskOnChip probe address 0x%lx\n",
1661 doc_config_location);
1662 ret = doc_probe(doc_config_location);
1666 for (i = 0; (doc_locations[i] != 0xffffffff); i++) {
1667 doc_probe(doc_locations[i]);
1670 /* No banner message any more. Print a message if no DiskOnChip
1671 found, so the user knows we at least tried. */
1673 pr_info("No valid DiskOnChip devices found\n");
1679 static void __exit cleanup_nanddoc(void)
1681 /* Cleanup the nand/DoC resources */
1685 module_init(init_nanddoc);
1686 module_exit(cleanup_nanddoc);
1688 MODULE_LICENSE("GPL");
1689 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1690 MODULE_DESCRIPTION("M-Systems DiskOnChip 2000, Millennium and Millennium Plus device driver");