?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'usb-3.11-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
[linux-2.6.git] / drivers / mtd / nand / diskonchip.c
blob81fa5784f98b390fb28ee81a23e720db56c2cc8b
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
41 static unsigned long __initdata doc_locations[] = {
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 /* CONFIG_MTD_DOCPROBE_HIGH */
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 /* CONFIG_MTD_DOCPROBE_HIGH */
56 #endif
57 0xffffffff };
58
59 static struct mtd_info *doclist = NULL;
60
61 struct 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. */
76 static 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. */
80 static 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
88 static void doc200x_hwcontrol(struct mtd_info *mtd, int cmd,
89 unsigned int bitmask);
90 static void doc200x_select_chip(struct mtd_info *mtd, int chip);
91
92 static int debug = 0;
93 module_param(debug, int, 0);
94
95 static int try_dword = 1;
96 module_param(try_dword, int, 0);
97
98 static int no_ecc_failures = 0;
99 module_param(no_ecc_failures, int, 0);
100
101 static int no_autopart = 0;
102 module_param(no_autopart, int, 0);
103
104 static int show_firmware_partition = 0;
105 module_param(show_firmware_partition, int, 0);
106
107 #ifdef CONFIG_MTD_NAND_DISKONCHIP_BBTWRITE
108 static int inftl_bbt_write = 1;
109 #else
110 static int inftl_bbt_write = 0;
111 #endif
112 module_param(inftl_bbt_write, int, 0);
113
114 static unsigned long doc_config_location = CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS;
115 module_param(doc_config_location, ulong, 0);
116 MODULE_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 */
130 static 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 */
141 static 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
222 static 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 */
241 static 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
272 static 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
297 static 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
309 static 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
324 static 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
341 static 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
356 static 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
377 static 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
423 static 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
445 static 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
459 static 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
470 static 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
484 static 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
497 static 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
514 static 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
529 static 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
547 static 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
578 static 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
605 static 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
635 static 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
659 static 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 column >>= 1;
703 WriteDOC(column, docptr, Mplus_FlashAddress);
704 }
705 if (page_addr != -1) {
706 WriteDOC((unsigned char)(page_addr & 0xff), docptr, Mplus_FlashAddress);
707 WriteDOC((unsigned char)((page_addr >> 8) & 0xff), docptr, Mplus_FlashAddress);
708 /* One more address cycle for higher density devices */
709 if (this->chipsize & 0x0c000000) {
710 WriteDOC((unsigned char)((page_addr >> 16) & 0x0f), docptr, Mplus_FlashAddress);
711 printk("high density\n");
712 }
713 }
714 WriteDOC(0, docptr, Mplus_WritePipeTerm);
715 WriteDOC(0, docptr, Mplus_WritePipeTerm);
716 /* deassert ALE */
717 if (command == NAND_CMD_READ0 || command == NAND_CMD_READ1 ||
718 command == NAND_CMD_READOOB || command == NAND_CMD_READID)
719 WriteDOC(0, docptr, Mplus_FlashControl);
720 }
721
722 /*
723 * program and erase have their own busy handlers
724 * status and sequential in needs no delay
725 */
726 switch (command) {
727
728 case NAND_CMD_PAGEPROG:
729 case NAND_CMD_ERASE1:
730 case NAND_CMD_ERASE2:
731 case NAND_CMD_SEQIN:
732 case NAND_CMD_STATUS:
733 return;
734
735 case NAND_CMD_RESET:
736 if (this->dev_ready)
737 break;
738 udelay(this->chip_delay);
739 WriteDOC(NAND_CMD_STATUS, docptr, Mplus_FlashCmd);
740 WriteDOC(0, docptr, Mplus_WritePipeTerm);
741 WriteDOC(0, docptr, Mplus_WritePipeTerm);
742 while (!(this->read_byte(mtd) & 0x40)) ;
743 return;
744
745 /* This applies to read commands */
746 default:
747 /*
748 * If we don't have access to the busy pin, we apply the given
749 * command delay
750 */
751 if (!this->dev_ready) {
752 udelay(this->chip_delay);
753 return;
754 }
755 }
756
757 /* Apply this short delay always to ensure that we do wait tWB in
758 * any case on any machine. */
759 ndelay(100);
760 /* wait until command is processed */
761 while (!this->dev_ready(mtd)) ;
762 }
763
764 static int doc200x_dev_ready(struct mtd_info *mtd)
765 {
766 struct nand_chip *this = mtd->priv;
767 struct doc_priv *doc = this->priv;
768 void __iomem *docptr = doc->virtadr;
769
770 if (DoC_is_MillenniumPlus(doc)) {
771 /* 11.4.2 -- must NOP four times before checking FR/B# */
772 DoC_Delay(doc, 4);
773 if ((ReadDOC(docptr, Mplus_FlashControl) & CDSN_CTRL_FR_B_MASK) != CDSN_CTRL_FR_B_MASK) {
774 if (debug)
775 printk("not ready\n");
776 return 0;
777 }
778 if (debug)
779 printk("was ready\n");
780 return 1;
781 } else {
782 /* 11.4.2 -- must NOP four times before checking FR/B# */
783 DoC_Delay(doc, 4);
784 if (!(ReadDOC(docptr, CDSNControl) & CDSN_CTRL_FR_B)) {
785 if (debug)
786 printk("not ready\n");
787 return 0;
788 }
789 /* 11.4.2 -- Must NOP twice if it's ready */
790 DoC_Delay(doc, 2);
791 if (debug)
792 printk("was ready\n");
793 return 1;
794 }
795 }
796
797 static int doc200x_block_bad(struct mtd_info *mtd, loff_t ofs, int getchip)
798 {
799 /* This is our last resort if we couldn't find or create a BBT. Just
800 pretend all blocks are good. */
801 return 0;
802 }
803
804 static void doc200x_enable_hwecc(struct mtd_info *mtd, int mode)
805 {
806 struct nand_chip *this = mtd->priv;
807 struct doc_priv *doc = this->priv;
808 void __iomem *docptr = doc->virtadr;
809
810 /* Prime the ECC engine */
811 switch (mode) {
812 case NAND_ECC_READ:
813 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
814 WriteDOC(DOC_ECC_EN, docptr, ECCConf);
815 break;
816 case NAND_ECC_WRITE:
817 WriteDOC(DOC_ECC_RESET, docptr, ECCConf);
818 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, ECCConf);
819 break;
820 }
821 }
822
823 static void doc2001plus_enable_hwecc(struct mtd_info *mtd, int mode)
824 {
825 struct nand_chip *this = mtd->priv;
826 struct doc_priv *doc = this->priv;
827 void __iomem *docptr = doc->virtadr;
828
829 /* Prime the ECC engine */
830 switch (mode) {
831 case NAND_ECC_READ:
832 WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
833 WriteDOC(DOC_ECC_EN, docptr, Mplus_ECCConf);
834 break;
835 case NAND_ECC_WRITE:
836 WriteDOC(DOC_ECC_RESET, docptr, Mplus_ECCConf);
837 WriteDOC(DOC_ECC_EN | DOC_ECC_RW, docptr, Mplus_ECCConf);
838 break;
839 }
840 }
841
842 /* This code is only called on write */
843 static int doc200x_calculate_ecc(struct mtd_info *mtd, const u_char *dat, unsigned char *ecc_code)
844 {
845 struct nand_chip *this = mtd->priv;
846 struct doc_priv *doc = this->priv;
847 void __iomem *docptr = doc->virtadr;
848 int i;
849 int emptymatch = 1;
850
851 /* flush the pipeline */
852 if (DoC_is_2000(doc)) {
853 WriteDOC(doc->CDSNControl & ~CDSN_CTRL_FLASH_IO, docptr, CDSNControl);
854 WriteDOC(0, docptr, 2k_CDSN_IO);
855 WriteDOC(0, docptr, 2k_CDSN_IO);
856 WriteDOC(0, docptr, 2k_CDSN_IO);
857 WriteDOC(doc->CDSNControl, docptr, CDSNControl);
858 } else if (DoC_is_MillenniumPlus(doc)) {
859 WriteDOC(0, docptr, Mplus_NOP);
860 WriteDOC(0, docptr, Mplus_NOP);
861 WriteDOC(0, docptr, Mplus_NOP);
862 } else {
863 WriteDOC(0, docptr, NOP);
864 WriteDOC(0, docptr, NOP);
865 WriteDOC(0, docptr, NOP);
866 }
867
868 for (i = 0; i < 6; i++) {
869 if (DoC_is_MillenniumPlus(doc))
870 ecc_code[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
871 else
872 ecc_code[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
873 if (ecc_code[i] != empty_write_ecc[i])
874 emptymatch = 0;
875 }
876 if (DoC_is_MillenniumPlus(doc))
877 WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
878 else
879 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
880 #if 0
881 /* If emptymatch=1, we might have an all-0xff data buffer. Check. */
882 if (emptymatch) {
883 /* Note: this somewhat expensive test should not be triggered
884 often. It could be optimized away by examining the data in
885 the writebuf routine, and remembering the result. */
886 for (i = 0; i < 512; i++) {
887 if (dat[i] == 0xff)
888 continue;
889 emptymatch = 0;
890 break;
891 }
892 }
893 /* If emptymatch still =1, we do have an all-0xff data buffer.
894 Return all-0xff ecc value instead of the computed one, so
895 it'll look just like a freshly-erased page. */
896 if (emptymatch)
897 memset(ecc_code, 0xff, 6);
898 #endif
899 return 0;
900 }
901
902 static int doc200x_correct_data(struct mtd_info *mtd, u_char *dat,
903 u_char *read_ecc, u_char *isnull)
904 {
905 int i, ret = 0;
906 struct nand_chip *this = mtd->priv;
907 struct doc_priv *doc = this->priv;
908 void __iomem *docptr = doc->virtadr;
909 uint8_t calc_ecc[6];
910 volatile u_char dummy;
911 int emptymatch = 1;
912
913 /* flush the pipeline */
914 if (DoC_is_2000(doc)) {
915 dummy = ReadDOC(docptr, 2k_ECCStatus);
916 dummy = ReadDOC(docptr, 2k_ECCStatus);
917 dummy = ReadDOC(docptr, 2k_ECCStatus);
918 } else if (DoC_is_MillenniumPlus(doc)) {
919 dummy = ReadDOC(docptr, Mplus_ECCConf);
920 dummy = ReadDOC(docptr, Mplus_ECCConf);
921 dummy = ReadDOC(docptr, Mplus_ECCConf);
922 } else {
923 dummy = ReadDOC(docptr, ECCConf);
924 dummy = ReadDOC(docptr, ECCConf);
925 dummy = ReadDOC(docptr, ECCConf);
926 }
927
928 /* Error occurred ? */
929 if (dummy & 0x80) {
930 for (i = 0; i < 6; i++) {
931 if (DoC_is_MillenniumPlus(doc))
932 calc_ecc[i] = ReadDOC_(docptr, DoC_Mplus_ECCSyndrome0 + i);
933 else
934 calc_ecc[i] = ReadDOC_(docptr, DoC_ECCSyndrome0 + i);
935 if (calc_ecc[i] != empty_read_syndrome[i])
936 emptymatch = 0;
937 }
938 /* If emptymatch=1, the read syndrome is consistent with an
939 all-0xff data and stored ecc block. Check the stored ecc. */
940 if (emptymatch) {
941 for (i = 0; i < 6; i++) {
942 if (read_ecc[i] == 0xff)
943 continue;
944 emptymatch = 0;
945 break;
946 }
947 }
948 /* If emptymatch still =1, check the data block. */
949 if (emptymatch) {
950 /* Note: this somewhat expensive test should not be triggered
951 often. It could be optimized away by examining the data in
952 the readbuf routine, and remembering the result. */
953 for (i = 0; i < 512; i++) {
954 if (dat[i] == 0xff)
955 continue;
956 emptymatch = 0;
957 break;
958 }
959 }
960 /* If emptymatch still =1, this is almost certainly a freshly-
961 erased block, in which case the ECC will not come out right.
962 We'll suppress the error and tell the caller everything's
963 OK. Because it is. */
964 if (!emptymatch)
965 ret = doc_ecc_decode(rs_decoder, dat, calc_ecc);
966 if (ret > 0)
967 printk(KERN_ERR "doc200x_correct_data corrected %d errors\n", ret);
968 }
969 if (DoC_is_MillenniumPlus(doc))
970 WriteDOC(DOC_ECC_DIS, docptr, Mplus_ECCConf);
971 else
972 WriteDOC(DOC_ECC_DIS, docptr, ECCConf);
973 if (no_ecc_failures && mtd_is_eccerr(ret)) {
974 printk(KERN_ERR "suppressing ECC failure\n");
975 ret = 0;
976 }
977 return ret;
978 }
979
980 //u_char mydatabuf[528];
981
982 /* The strange out-of-order .oobfree list below is a (possibly unneeded)
983 * attempt to retain compatibility. It used to read:
984 * .oobfree = { {8, 8} }
985 * Since that leaves two bytes unusable, it was changed. But the following
986 * scheme might affect existing jffs2 installs by moving the cleanmarker:
987 * .oobfree = { {6, 10} }
988 * jffs2 seems to handle the above gracefully, but the current scheme seems
989 * safer. The only problem with it is that any code that parses oobfree must
990 * be able to handle out-of-order segments.
991 */
992 static struct nand_ecclayout doc200x_oobinfo = {
993 .eccbytes = 6,
994 .eccpos = {0, 1, 2, 3, 4, 5},
995 .oobfree = {{8, 8}, {6, 2}}
996 };
997
998 /* Find the (I)NFTL Media Header, and optionally also the mirror media header.
999 On successful return, buf will contain a copy of the media header for
1000 further processing. id is the string to scan for, and will presumably be
1001 either "ANAND" or "BNAND". If findmirror=1, also look for the mirror media
1002 header. The page #s of the found media headers are placed in mh0_page and
1003 mh1_page in the DOC private structure. */
1004 static int __init find_media_headers(struct mtd_info *mtd, u_char *buf, const char *id, int findmirror)
1005 {
1006 struct nand_chip *this = mtd->priv;
1007 struct doc_priv *doc = this->priv;
1008 unsigned offs;
1009 int ret;
1010 size_t retlen;
1011
1012 for (offs = 0; offs < mtd->size; offs += mtd->erasesize) {
1013 ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
1014 if (retlen != mtd->writesize)
1015 continue;
1016 if (ret) {
1017 printk(KERN_WARNING "ECC error scanning DOC at 0x%x\n", offs);
1018 }
1019 if (memcmp(buf, id, 6))
1020 continue;
1021 printk(KERN_INFO "Found DiskOnChip %s Media Header at 0x%x\n", id, offs);
1022 if (doc->mh0_page == -1) {
1023 doc->mh0_page = offs >> this->page_shift;
1024 if (!findmirror)
1025 return 1;
1026 continue;
1027 }
1028 doc->mh1_page = offs >> this->page_shift;
1029 return 2;
1030 }
1031 if (doc->mh0_page == -1) {
1032 printk(KERN_WARNING "DiskOnChip %s Media Header not found.\n", id);
1033 return 0;
1034 }
1035 /* Only one mediaheader was found. We want buf to contain a
1036 mediaheader on return, so we'll have to re-read the one we found. */
1037 offs = doc->mh0_page << this->page_shift;
1038 ret = mtd_read(mtd, offs, mtd->writesize, &retlen, buf);
1039 if (retlen != mtd->writesize) {
1040 /* Insanity. Give up. */
1041 printk(KERN_ERR "Read DiskOnChip Media Header once, but can't reread it???\n");
1042 return 0;
1043 }
1044 return 1;
1045 }
1046
1047 static inline int __init nftl_partscan(struct mtd_info *mtd, struct mtd_partition *parts)
1048 {
1049 struct nand_chip *this = mtd->priv;
1050 struct doc_priv *doc = this->priv;
1051 int ret = 0;
1052 u_char *buf;
1053 struct NFTLMediaHeader *mh;
1054 const unsigned psize = 1 << this->page_shift;
1055 int numparts = 0;
1056 unsigned blocks, maxblocks;
1057 int offs, numheaders;
1058
1059 buf = kmalloc(mtd->writesize, GFP_KERNEL);
1060 if (!buf) {
1061 printk(KERN_ERR "DiskOnChip mediaheader kmalloc failed!\n");
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 */
1150 static 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 printk(KERN_ERR "DiskOnChip mediaheader kmalloc failed!\n");
1170 return 0;
1171 }
1172
1173 if (!find_media_headers(mtd, buf, "BNAND", 0))
1174 goto out;
1175 doc->mh1_page = doc->mh0_page + (4096 >> this->page_shift);
1176 mh = (struct INFTLMediaHeader *)buf;
1177
1178 le32_to_cpus(&mh->NoOfBootImageBlocks);
1179 le32_to_cpus(&mh->NoOfBinaryPartitions);
1180 le32_to_cpus(&mh->NoOfBDTLPartitions);
1181 le32_to_cpus(&mh->BlockMultiplierBits);
1182 le32_to_cpus(&mh->FormatFlags);
1183 le32_to_cpus(&mh->PercentUsed);
1184
1185 printk(KERN_INFO " bootRecordID = %s\n"
1186 " NoOfBootImageBlocks = %d\n"
1187 " NoOfBinaryPartitions = %d\n"
1188 " NoOfBDTLPartitions = %d\n"
1189 " BlockMultiplerBits = %d\n"
1190 " FormatFlgs = %d\n"
1191 " OsakVersion = %d.%d.%d.%d\n"
1192 " PercentUsed = %d\n",
1193 mh->bootRecordID, mh->NoOfBootImageBlocks,
1194 mh->NoOfBinaryPartitions,
1195 mh->NoOfBDTLPartitions,
1196 mh->BlockMultiplierBits, mh->FormatFlags,
1197 ((unsigned char *) &mh->OsakVersion)[0] & 0xf,
1198 ((unsigned char *) &mh->OsakVersion)[1] & 0xf,
1199 ((unsigned char *) &mh->OsakVersion)[2] & 0xf,
1200 ((unsigned char *) &mh->OsakVersion)[3] & 0xf,
1201 mh->PercentUsed);
1202
1203 vshift = this->phys_erase_shift + mh->BlockMultiplierBits;
1204
1205 blocks = mtd->size >> vshift;
1206 if (blocks > 32768) {
1207 printk(KERN_ERR "BlockMultiplierBits=%d is inconsistent with device size. Aborting.\n", mh->BlockMultiplierBits);
1208 goto out;
1209 }
1210
1211 blocks = doc->chips_per_floor << (this->chip_shift - this->phys_erase_shift);
1212 if (inftl_bbt_write && (blocks > mtd->erasesize)) {
1213 printk(KERN_ERR "Writeable BBTs spanning more than one erase block are not yet supported. FIX ME!\n");
1214 goto out;
1215 }
1216
1217 /* Scan the partitions */
1218 for (i = 0; (i < 4); i++) {
1219 ip = &(mh->Partitions[i]);
1220 le32_to_cpus(&ip->virtualUnits);
1221 le32_to_cpus(&ip->firstUnit);
1222 le32_to_cpus(&ip->lastUnit);
1223 le32_to_cpus(&ip->flags);
1224 le32_to_cpus(&ip->spareUnits);
1225 le32_to_cpus(&ip->Reserved0);
1226
1227 printk(KERN_INFO " PARTITION[%d] ->\n"
1228 " virtualUnits = %d\n"
1229 " firstUnit = %d\n"
1230 " lastUnit = %d\n"
1231 " flags = 0x%x\n"
1232 " spareUnits = %d\n",
1233 i, ip->virtualUnits, ip->firstUnit,
1234 ip->lastUnit, ip->flags,
1235 ip->spareUnits);
1236
1237 if ((show_firmware_partition == 1) &&
1238 (i == 0) && (ip->firstUnit > 0)) {
1239 parts[0].name = " DiskOnChip IPL / Media Header partition";
1240 parts[0].offset = 0;
1241 parts[0].size = mtd->erasesize * ip->firstUnit;
1242 numparts = 1;
1243 }
1244
1245 if (ip->flags & INFTL_BINARY)
1246 parts[numparts].name = " DiskOnChip BDK partition";
1247 else
1248 parts[numparts].name = " DiskOnChip BDTL partition";
1249 parts[numparts].offset = ip->firstUnit << vshift;
1250 parts[numparts].size = (1 + ip->lastUnit - ip->firstUnit) << vshift;
1251 numparts++;
1252 if (ip->lastUnit > lastvunit)
1253 lastvunit = ip->lastUnit;
1254 if (ip->flags & INFTL_LAST)
1255 break;
1256 }
1257 lastvunit++;
1258 if ((lastvunit << vshift) < end) {
1259 parts[numparts].name = " DiskOnChip Remainder partition";
1260 parts[numparts].offset = lastvunit << vshift;
1261 parts[numparts].size = end - parts[numparts].offset;
1262 numparts++;
1263 }
1264 ret = numparts;
1265 out:
1266 kfree(buf);
1267 return ret;
1268 }
1269
1270 static int __init nftl_scan_bbt(struct mtd_info *mtd)
1271 {
1272 int ret, numparts;
1273 struct nand_chip *this = mtd->priv;
1274 struct doc_priv *doc = this->priv;
1275 struct mtd_partition parts[2];
1276
1277 memset((char *)parts, 0, sizeof(parts));
1278 /* On NFTL, we have to find the media headers before we can read the
1279 BBTs, since they're stored in the media header eraseblocks. */
1280 numparts = nftl_partscan(mtd, parts);
1281 if (!numparts)
1282 return -EIO;
1283 this->bbt_td->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
1284 NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
1285 NAND_BBT_VERSION;
1286 this->bbt_td->veroffs = 7;
1287 this->bbt_td->pages[0] = doc->mh0_page + 1;
1288 if (doc->mh1_page != -1) {
1289 this->bbt_md->options = NAND_BBT_ABSPAGE | NAND_BBT_8BIT |
1290 NAND_BBT_SAVECONTENT | NAND_BBT_WRITE |
1291 NAND_BBT_VERSION;
1292 this->bbt_md->veroffs = 7;
1293 this->bbt_md->pages[0] = doc->mh1_page + 1;
1294 } else {
1295 this->bbt_md = NULL;
1296 }
1297
1298 /* It's safe to set bd=NULL below because NAND_BBT_CREATE is not set.
1299 At least as nand_bbt.c is currently written. */
1300 if ((ret = nand_scan_bbt(mtd, NULL)))
1301 return ret;
1302 mtd_device_register(mtd, NULL, 0);
1303 if (!no_autopart)
1304 mtd_device_register(mtd, parts, numparts);
1305 return 0;
1306 }
1307
1308 static int __init inftl_scan_bbt(struct mtd_info *mtd)
1309 {
1310 int ret, numparts;
1311 struct nand_chip *this = mtd->priv;
1312 struct doc_priv *doc = this->priv;
1313 struct mtd_partition parts[5];
1314
1315 if (this->numchips > doc->chips_per_floor) {
1316 printk(KERN_ERR "Multi-floor INFTL devices not yet supported.\n");
1317 return -EIO;
1318 }
1319
1320 if (DoC_is_MillenniumPlus(doc)) {
1321 this->bbt_td->options = NAND_BBT_2BIT | NAND_BBT_ABSPAGE;
1322 if (inftl_bbt_write)
1323 this->bbt_td->options |= NAND_BBT_WRITE;
1324 this->bbt_td->pages[0] = 2;
1325 this->bbt_md = NULL;
1326 } else {
1327 this->bbt_td->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
1328 if (inftl_bbt_write)
1329 this->bbt_td->options |= NAND_BBT_WRITE;
1330 this->bbt_td->offs = 8;
1331 this->bbt_td->len = 8;
1332 this->bbt_td->veroffs = 7;
1333 this->bbt_td->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
1334 this->bbt_td->reserved_block_code = 0x01;
1335 this->bbt_td->pattern = "MSYS_BBT";
1336
1337 this->bbt_md->options = NAND_BBT_LASTBLOCK | NAND_BBT_8BIT | NAND_BBT_VERSION;
1338 if (inftl_bbt_write)
1339 this->bbt_md->options |= NAND_BBT_WRITE;
1340 this->bbt_md->offs = 8;
1341 this->bbt_md->len = 8;
1342 this->bbt_md->veroffs = 7;
1343 this->bbt_md->maxblocks = INFTL_BBT_RESERVED_BLOCKS;
1344 this->bbt_md->reserved_block_code = 0x01;
1345 this->bbt_md->pattern = "TBB_SYSM";
1346 }
1347
1348 /* It's safe to set bd=NULL below because NAND_BBT_CREATE is not set.
1349 At least as nand_bbt.c is currently written. */
1350 if ((ret = nand_scan_bbt(mtd, NULL)))
1351 return ret;
1352 memset((char *)parts, 0, sizeof(parts));
1353 numparts = inftl_partscan(mtd, parts);
1354 /* At least for now, require the INFTL Media Header. We could probably
1355 do without it for non-INFTL use, since all it gives us is
1356 autopartitioning, but I want to give it more thought. */
1357 if (!numparts)
1358 return -EIO;
1359 mtd_device_register(mtd, NULL, 0);
1360 if (!no_autopart)
1361 mtd_device_register(mtd, parts, numparts);
1362 return 0;
1363 }
1364
1365 static inline int __init doc2000_init(struct mtd_info *mtd)
1366 {
1367 struct nand_chip *this = mtd->priv;
1368 struct doc_priv *doc = this->priv;
1369
1370 this->read_byte = doc2000_read_byte;
1371 this->write_buf = doc2000_writebuf;
1372 this->read_buf = doc2000_readbuf;
1373 this->scan_bbt = nftl_scan_bbt;
1374
1375 doc->CDSNControl = CDSN_CTRL_FLASH_IO | CDSN_CTRL_ECC_IO;
1376 doc2000_count_chips(mtd);
1377 mtd->name = "DiskOnChip 2000 (NFTL Model)";
1378 return (4 * doc->chips_per_floor);
1379 }
1380
1381 static inline int __init doc2001_init(struct mtd_info *mtd)
1382 {
1383 struct nand_chip *this = mtd->priv;
1384 struct doc_priv *doc = this->priv;
1385
1386 this->read_byte = doc2001_read_byte;
1387 this->write_buf = doc2001_writebuf;
1388 this->read_buf = doc2001_readbuf;
1389
1390 ReadDOC(doc->virtadr, ChipID);
1391 ReadDOC(doc->virtadr, ChipID);
1392 ReadDOC(doc->virtadr, ChipID);
1393 if (ReadDOC(doc->virtadr, ChipID) != DOC_ChipID_DocMil) {
1394 /* It's not a Millennium; it's one of the newer
1395 DiskOnChip 2000 units with a similar ASIC.
1396 Treat it like a Millennium, except that it
1397 can have multiple chips. */
1398 doc2000_count_chips(mtd);
1399 mtd->name = "DiskOnChip 2000 (INFTL Model)";
1400 this->scan_bbt = inftl_scan_bbt;
1401 return (4 * doc->chips_per_floor);
1402 } else {
1403 /* Bog-standard Millennium */
1404 doc->chips_per_floor = 1;
1405 mtd->name = "DiskOnChip Millennium";
1406 this->scan_bbt = nftl_scan_bbt;
1407 return 1;
1408 }
1409 }
1410
1411 static inline int __init doc2001plus_init(struct mtd_info *mtd)
1412 {
1413 struct nand_chip *this = mtd->priv;
1414 struct doc_priv *doc = this->priv;
1415
1416 this->read_byte = doc2001plus_read_byte;
1417 this->write_buf = doc2001plus_writebuf;
1418 this->read_buf = doc2001plus_readbuf;
1419 this->scan_bbt = inftl_scan_bbt;
1420 this->cmd_ctrl = NULL;
1421 this->select_chip = doc2001plus_select_chip;
1422 this->cmdfunc = doc2001plus_command;
1423 this->ecc.hwctl = doc2001plus_enable_hwecc;
1424
1425 doc->chips_per_floor = 1;
1426 mtd->name = "DiskOnChip Millennium Plus";
1427
1428 return 1;
1429 }
1430
1431 static int __init doc_probe(unsigned long physadr)
1432 {
1433 unsigned char ChipID;
1434 struct mtd_info *mtd;
1435 struct nand_chip *nand;
1436 struct doc_priv *doc;
1437 void __iomem *virtadr;
1438 unsigned char save_control;
1439 unsigned char tmp, tmpb, tmpc;
1440 int reg, len, numchips;
1441 int ret = 0;
1442
1443 virtadr = ioremap(physadr, DOC_IOREMAP_LEN);
1444 if (!virtadr) {
1445 printk(KERN_ERR "Diskonchip ioremap failed: 0x%x bytes at 0x%lx\n", DOC_IOREMAP_LEN, physadr);
1446 return -EIO;
1447 }
1448
1449 /* It's not possible to cleanly detect the DiskOnChip - the
1450 * bootup procedure will put the device into reset mode, and
1451 * it's not possible to talk to it without actually writing
1452 * to the DOCControl register. So we store the current contents
1453 * of the DOCControl register's location, in case we later decide
1454 * that it's not a DiskOnChip, and want to put it back how we
1455 * found it.
1456 */
1457 save_control = ReadDOC(virtadr, DOCControl);
1458
1459 /* Reset the DiskOnChip ASIC */
1460 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
1461 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_RESET, virtadr, DOCControl);
1462
1463 /* Enable the DiskOnChip ASIC */
1464 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
1465 WriteDOC(DOC_MODE_CLR_ERR | DOC_MODE_MDWREN | DOC_MODE_NORMAL, virtadr, DOCControl);
1466
1467 ChipID = ReadDOC(virtadr, ChipID);
1468
1469 switch (ChipID) {
1470 case DOC_ChipID_Doc2k:
1471 reg = DoC_2k_ECCStatus;
1472 break;
1473 case DOC_ChipID_DocMil:
1474 reg = DoC_ECCConf;
1475 break;
1476 case DOC_ChipID_DocMilPlus16:
1477 case DOC_ChipID_DocMilPlus32:
1478 case 0:
1479 /* Possible Millennium Plus, need to do more checks */
1480 /* Possibly release from power down mode */
1481 for (tmp = 0; (tmp < 4); tmp++)
1482 ReadDOC(virtadr, Mplus_Power);
1483
1484 /* Reset the Millennium Plus ASIC */
1485 tmp = DOC_MODE_RESET | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
1486 WriteDOC(tmp, virtadr, Mplus_DOCControl);
1487 WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
1488
1489 mdelay(1);
1490 /* Enable the Millennium Plus ASIC */
1491 tmp = DOC_MODE_NORMAL | DOC_MODE_MDWREN | DOC_MODE_RST_LAT | DOC_MODE_BDECT;
1492 WriteDOC(tmp, virtadr, Mplus_DOCControl);
1493 WriteDOC(~tmp, virtadr, Mplus_CtrlConfirm);
1494 mdelay(1);
1495
1496 ChipID = ReadDOC(virtadr, ChipID);
1497
1498 switch (ChipID) {
1499 case DOC_ChipID_DocMilPlus16:
1500 reg = DoC_Mplus_Toggle;
1501 break;
1502 case DOC_ChipID_DocMilPlus32:
1503 printk(KERN_ERR "DiskOnChip Millennium Plus 32MB is not supported, ignoring.\n");
1504 default:
1505 ret = -ENODEV;
1506 goto notfound;
1507 }
1508 break;
1509
1510 default:
1511 ret = -ENODEV;
1512 goto notfound;
1513 }
1514 /* Check the TOGGLE bit in the ECC register */
1515 tmp = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1516 tmpb = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1517 tmpc = ReadDOC_(virtadr, reg) & DOC_TOGGLE_BIT;
1518 if ((tmp == tmpb) || (tmp != tmpc)) {
1519 printk(KERN_WARNING "Possible DiskOnChip at 0x%lx failed TOGGLE test, dropping.\n", physadr);
1520 ret = -ENODEV;
1521 goto notfound;
1522 }
1523
1524 for (mtd = doclist; mtd; mtd = doc->nextdoc) {
1525 unsigned char oldval;
1526 unsigned char newval;
1527 nand = mtd->priv;
1528 doc = nand->priv;
1529 /* Use the alias resolution register to determine if this is
1530 in fact the same DOC aliased to a new address. If writes
1531 to one chip's alias resolution register change the value on
1532 the other chip, they're the same chip. */
1533 if (ChipID == DOC_ChipID_DocMilPlus16) {
1534 oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
1535 newval = ReadDOC(virtadr, Mplus_AliasResolution);
1536 } else {
1537 oldval = ReadDOC(doc->virtadr, AliasResolution);
1538 newval = ReadDOC(virtadr, AliasResolution);
1539 }
1540 if (oldval != newval)
1541 continue;
1542 if (ChipID == DOC_ChipID_DocMilPlus16) {
1543 WriteDOC(~newval, virtadr, Mplus_AliasResolution);
1544 oldval = ReadDOC(doc->virtadr, Mplus_AliasResolution);
1545 WriteDOC(newval, virtadr, Mplus_AliasResolution); // restore it
1546 } else {
1547 WriteDOC(~newval, virtadr, AliasResolution);
1548 oldval = ReadDOC(doc->virtadr, AliasResolution);
1549 WriteDOC(newval, virtadr, AliasResolution); // restore it
1550 }
1551 newval = ~newval;
1552 if (oldval == newval) {
1553 printk(KERN_DEBUG "Found alias of DOC at 0x%lx to 0x%lx\n", doc->physadr, physadr);
1554 goto notfound;
1555 }
1556 }
1557
1558 printk(KERN_NOTICE "DiskOnChip found at 0x%lx\n", physadr);
1559
1560 len = sizeof(struct mtd_info) +
1561 sizeof(struct nand_chip) + sizeof(struct doc_priv) + (2 * sizeof(struct nand_bbt_descr));
1562 mtd = kzalloc(len, GFP_KERNEL);
1563 if (!mtd) {
1564 printk(KERN_ERR "DiskOnChip kmalloc (%d bytes) failed!\n", len);
1565 ret = -ENOMEM;
1566 goto fail;
1567 }
1568
1569 nand = (struct nand_chip *) (mtd + 1);
1570 doc = (struct doc_priv *) (nand + 1);
1571 nand->bbt_td = (struct nand_bbt_descr *) (doc + 1);
1572 nand->bbt_md = nand->bbt_td + 1;
1573
1574 mtd->priv = nand;
1575 mtd->owner = THIS_MODULE;
1576
1577 nand->priv = doc;
1578 nand->select_chip = doc200x_select_chip;
1579 nand->cmd_ctrl = doc200x_hwcontrol;
1580 nand->dev_ready = doc200x_dev_ready;
1581 nand->waitfunc = doc200x_wait;
1582 nand->block_bad = doc200x_block_bad;
1583 nand->ecc.hwctl = doc200x_enable_hwecc;
1584 nand->ecc.calculate = doc200x_calculate_ecc;
1585 nand->ecc.correct = doc200x_correct_data;
1586
1587 nand->ecc.layout = &doc200x_oobinfo;
1588 nand->ecc.mode = NAND_ECC_HW_SYNDROME;
1589 nand->ecc.size = 512;
1590 nand->ecc.bytes = 6;
1591 nand->ecc.strength = 2;
1592 nand->bbt_options = NAND_BBT_USE_FLASH;
1593
1594 doc->physadr = physadr;
1595 doc->virtadr = virtadr;
1596 doc->ChipID = ChipID;
1597 doc->curfloor = -1;
1598 doc->curchip = -1;
1599 doc->mh0_page = -1;
1600 doc->mh1_page = -1;
1601 doc->nextdoc = doclist;
1602
1603 if (ChipID == DOC_ChipID_Doc2k)
1604 numchips = doc2000_init(mtd);
1605 else if (ChipID == DOC_ChipID_DocMilPlus16)
1606 numchips = doc2001plus_init(mtd);
1607 else
1608 numchips = doc2001_init(mtd);
1609
1610 if ((ret = nand_scan(mtd, numchips))) {
1611 /* DBB note: i believe nand_release is necessary here, as
1612 buffers may have been allocated in nand_base. Check with
1613 Thomas. FIX ME! */
1614 /* nand_release will call mtd_device_unregister, but we
1615 haven't yet added it. This is handled without incident by
1616 mtd_device_unregister, as far as I can tell. */
1617 nand_release(mtd);
1618 kfree(mtd);
1619 goto fail;
1620 }
1621
1622 /* Success! */
1623 doclist = mtd;
1624 return 0;
1625
1626 notfound:
1627 /* Put back the contents of the DOCControl register, in case it's not
1628 actually a DiskOnChip. */
1629 WriteDOC(save_control, virtadr, DOCControl);
1630 fail:
1631 iounmap(virtadr);
1632 return ret;
1633 }
1634
1635 static void release_nanddoc(void)
1636 {
1637 struct mtd_info *mtd, *nextmtd;
1638 struct nand_chip *nand;
1639 struct doc_priv *doc;
1640
1641 for (mtd = doclist; mtd; mtd = nextmtd) {
1642 nand = mtd->priv;
1643 doc = nand->priv;
1644
1645 nextmtd = doc->nextdoc;
1646 nand_release(mtd);
1647 iounmap(doc->virtadr);
1648 kfree(mtd);
1649 }
1650 }
1651
1652 static int __init init_nanddoc(void)
1653 {
1654 int i, ret = 0;
1655
1656 /* We could create the decoder on demand, if memory is a concern.
1657 * This way we have it handy, if an error happens
1658 *
1659 * Symbolsize is 10 (bits)
1660 * Primitve polynomial is x^10+x^3+1
1661 * first consecutive root is 510
1662 * primitve element to generate roots = 1
1663 * generator polinomial degree = 4
1664 */
1665 rs_decoder = init_rs(10, 0x409, FCR, 1, NROOTS);
1666 if (!rs_decoder) {
1667 printk(KERN_ERR "DiskOnChip: Could not create a RS decoder\n");
1668 return -ENOMEM;
1669 }
1670
1671 if (doc_config_location) {
1672 printk(KERN_INFO "Using configured DiskOnChip probe address 0x%lx\n", doc_config_location);
1673 ret = doc_probe(doc_config_location);
1674 if (ret < 0)
1675 goto outerr;
1676 } else {
1677 for (i = 0; (doc_locations[i] != 0xffffffff); i++) {
1678 doc_probe(doc_locations[i]);
1679 }
1680 }
1681 /* No banner message any more. Print a message if no DiskOnChip
1682 found, so the user knows we at least tried. */
1683 if (!doclist) {
1684 printk(KERN_INFO "No valid DiskOnChip devices found\n");
1685 ret = -ENODEV;
1686 goto outerr;
1687 }
1688 return 0;
1689 outerr:
1690 free_rs(rs_decoder);
1691 return ret;
1692 }
1693
1694 static void __exit cleanup_nanddoc(void)
1695 {
1696 /* Cleanup the nand/DoC resources */
1697 release_nanddoc();
1698
1699 /* Free the reed solomon resources */
1700 if (rs_decoder) {
1701 free_rs(rs_decoder);
1702 }
1703 }
1704
1705 module_init(init_nanddoc);
1706 module_exit(cleanup_nanddoc);
1707
1708 MODULE_LICENSE("GPL");
1709 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1710 MODULE_DESCRIPTION("M-Systems DiskOnChip 2000, Millennium and Millennium Plus device driver");
Linus' kernel tree