]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/mtd/devices/doc2001.c
3 * Linux driver for Disk-On-Chip Millennium
4 * (c) 1999 Machine Vision Holdings, Inc.
5 * (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
7 * $Id: doc2001.c,v 1.49 2005/11/07 11:14:24 gleixner Exp $
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <asm/errno.h>
14 #include <asm/uaccess.h>
15 #include <linux/miscdevice.h>
16 #include <linux/pci.h>
17 #include <linux/delay.h>
18 #include <linux/slab.h>
19 #include <linux/sched.h>
20 #include <linux/init.h>
21 #include <linux/types.h>
22 #include <linux/bitops.h>
24 #include <linux/mtd/mtd.h>
25 #include <linux/mtd/nand.h>
26 #include <linux/mtd/doc2000.h>
28 /* #define ECC_DEBUG */
30 /* I have no idea why some DoC chips can not use memcop_form|to_io().
31 * This may be due to the different revisions of the ASIC controller built-in or
32 * simplily a QA/Bug issue. Who knows ?? If you have trouble, please uncomment
36 static int doc_read(struct mtd_info
*mtd
, loff_t from
, size_t len
,
37 size_t *retlen
, u_char
*buf
);
38 static int doc_write(struct mtd_info
*mtd
, loff_t to
, size_t len
,
39 size_t *retlen
, const u_char
*buf
);
40 static int doc_read_ecc(struct mtd_info
*mtd
, loff_t from
, size_t len
,
41 size_t *retlen
, u_char
*buf
, u_char
*eccbuf
,
42 struct nand_oobinfo
*oobsel
);
43 static int doc_write_ecc(struct mtd_info
*mtd
, loff_t to
, size_t len
,
44 size_t *retlen
, const u_char
*buf
, u_char
*eccbuf
,
45 struct nand_oobinfo
*oobsel
);
46 static int doc_read_oob(struct mtd_info
*mtd
, loff_t ofs
, size_t len
,
47 size_t *retlen
, u_char
*buf
);
48 static int doc_write_oob(struct mtd_info
*mtd
, loff_t ofs
, size_t len
,
49 size_t *retlen
, const u_char
*buf
);
50 static int doc_erase (struct mtd_info
*mtd
, struct erase_info
*instr
);
52 static struct mtd_info
*docmillist
= NULL
;
54 /* Perform the required delay cycles by reading from the NOP register */
55 static void DoC_Delay(void __iomem
* docptr
, unsigned short cycles
)
60 for (i
= 0; i
< cycles
; i
++)
61 dummy
= ReadDOC(docptr
, NOP
);
64 /* DOC_WaitReady: Wait for RDY line to be asserted by the flash chip */
65 static int _DoC_WaitReady(void __iomem
* docptr
)
67 unsigned short c
= 0xffff;
69 DEBUG(MTD_DEBUG_LEVEL3
,
70 "_DoC_WaitReady called for out-of-line wait\n");
72 /* Out-of-line routine to wait for chip response */
73 while (!(ReadDOC(docptr
, CDSNControl
) & CDSN_CTRL_FR_B
) && --c
)
77 DEBUG(MTD_DEBUG_LEVEL2
, "_DoC_WaitReady timed out.\n");
82 static inline int DoC_WaitReady(void __iomem
* docptr
)
84 /* This is inline, to optimise the common case, where it's ready instantly */
87 /* 4 read form NOP register should be issued in prior to the read from CDSNControl
88 see Software Requirement 11.4 item 2. */
91 if (!(ReadDOC(docptr
, CDSNControl
) & CDSN_CTRL_FR_B
))
92 /* Call the out-of-line routine to wait */
93 ret
= _DoC_WaitReady(docptr
);
95 /* issue 2 read from NOP register after reading from CDSNControl register
96 see Software Requirement 11.4 item 2. */
102 /* DoC_Command: Send a flash command to the flash chip through the CDSN IO register
103 with the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
104 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
106 static void DoC_Command(void __iomem
* docptr
, unsigned char command
,
107 unsigned char xtraflags
)
109 /* Assert the CLE (Command Latch Enable) line to the flash chip */
110 WriteDOC(xtraflags
| CDSN_CTRL_CLE
| CDSN_CTRL_CE
, docptr
, CDSNControl
);
111 DoC_Delay(docptr
, 4);
113 /* Send the command */
114 WriteDOC(command
, docptr
, Mil_CDSN_IO
);
115 WriteDOC(0x00, docptr
, WritePipeTerm
);
117 /* Lower the CLE line */
118 WriteDOC(xtraflags
| CDSN_CTRL_CE
, docptr
, CDSNControl
);
119 DoC_Delay(docptr
, 4);
122 /* DoC_Address: Set the current address for the flash chip through the CDSN IO register
123 with the internal pipeline. Each of 4 delay cycles (read from the NOP register) is
124 required after writing to CDSN Control register, see Software Requirement 11.4 item 3. */
126 static inline void DoC_Address(void __iomem
* docptr
, int numbytes
, unsigned long ofs
,
127 unsigned char xtraflags1
, unsigned char xtraflags2
)
129 /* Assert the ALE (Address Latch Enable) line to the flash chip */
130 WriteDOC(xtraflags1
| CDSN_CTRL_ALE
| CDSN_CTRL_CE
, docptr
, CDSNControl
);
131 DoC_Delay(docptr
, 4);
133 /* Send the address */
137 /* Send single byte, bits 0-7. */
138 WriteDOC(ofs
& 0xff, docptr
, Mil_CDSN_IO
);
139 WriteDOC(0x00, docptr
, WritePipeTerm
);
142 /* Send bits 9-16 followed by 17-23 */
143 WriteDOC((ofs
>> 9) & 0xff, docptr
, Mil_CDSN_IO
);
144 WriteDOC((ofs
>> 17) & 0xff, docptr
, Mil_CDSN_IO
);
145 WriteDOC(0x00, docptr
, WritePipeTerm
);
148 /* Send 0-7, 9-16, then 17-23 */
149 WriteDOC(ofs
& 0xff, docptr
, Mil_CDSN_IO
);
150 WriteDOC((ofs
>> 9) & 0xff, docptr
, Mil_CDSN_IO
);
151 WriteDOC((ofs
>> 17) & 0xff, docptr
, Mil_CDSN_IO
);
152 WriteDOC(0x00, docptr
, WritePipeTerm
);
158 /* Lower the ALE line */
159 WriteDOC(xtraflags1
| xtraflags2
| CDSN_CTRL_CE
, docptr
, CDSNControl
);
160 DoC_Delay(docptr
, 4);
163 /* DoC_SelectChip: Select a given flash chip within the current floor */
164 static int DoC_SelectChip(void __iomem
* docptr
, int chip
)
166 /* Select the individual flash chip requested */
167 WriteDOC(chip
, docptr
, CDSNDeviceSelect
);
168 DoC_Delay(docptr
, 4);
170 /* Wait for it to be ready */
171 return DoC_WaitReady(docptr
);
174 /* DoC_SelectFloor: Select a given floor (bank of flash chips) */
175 static int DoC_SelectFloor(void __iomem
* docptr
, int floor
)
177 /* Select the floor (bank) of chips required */
178 WriteDOC(floor
, docptr
, FloorSelect
);
180 /* Wait for the chip to be ready */
181 return DoC_WaitReady(docptr
);
184 /* DoC_IdentChip: Identify a given NAND chip given {floor,chip} */
185 static int DoC_IdentChip(struct DiskOnChip
*doc
, int floor
, int chip
)
190 /* Page in the required floor/chip
191 FIXME: is this supported by Millennium ?? */
192 DoC_SelectFloor(doc
->virtadr
, floor
);
193 DoC_SelectChip(doc
->virtadr
, chip
);
195 /* Reset the chip, see Software Requirement 11.4 item 1. */
196 DoC_Command(doc
->virtadr
, NAND_CMD_RESET
, CDSN_CTRL_WP
);
197 DoC_WaitReady(doc
->virtadr
);
199 /* Read the NAND chip ID: 1. Send ReadID command */
200 DoC_Command(doc
->virtadr
, NAND_CMD_READID
, CDSN_CTRL_WP
);
202 /* Read the NAND chip ID: 2. Send address byte zero */
203 DoC_Address(doc
->virtadr
, 1, 0x00, CDSN_CTRL_WP
, 0x00);
205 /* Read the manufacturer and device id codes of the flash device through
206 CDSN IO register see Software Requirement 11.4 item 5.*/
207 dummy
= ReadDOC(doc
->virtadr
, ReadPipeInit
);
208 DoC_Delay(doc
->virtadr
, 2);
209 mfr
= ReadDOC(doc
->virtadr
, Mil_CDSN_IO
);
211 DoC_Delay(doc
->virtadr
, 2);
212 id
= ReadDOC(doc
->virtadr
, Mil_CDSN_IO
);
213 dummy
= ReadDOC(doc
->virtadr
, LastDataRead
);
215 /* No response - return failure */
216 if (mfr
== 0xff || mfr
== 0)
219 /* FIXME: to deal with multi-flash on multi-Millennium case more carefully */
220 for (i
= 0; nand_flash_ids
[i
].name
!= NULL
; i
++) {
221 if ( id
== nand_flash_ids
[i
].id
) {
222 /* Try to identify manufacturer */
223 for (j
= 0; nand_manuf_ids
[j
].id
!= 0x0; j
++) {
224 if (nand_manuf_ids
[j
].id
== mfr
)
227 printk(KERN_INFO
"Flash chip found: Manufacturer ID: %2.2X, "
228 "Chip ID: %2.2X (%s:%s)\n",
229 mfr
, id
, nand_manuf_ids
[j
].name
, nand_flash_ids
[i
].name
);
232 doc
->chipshift
= ffs((nand_flash_ids
[i
].chipsize
<< 20)) - 1;
237 if (nand_flash_ids
[i
].name
== NULL
)
243 /* DoC_ScanChips: Find all NAND chips present in a DiskOnChip, and identify them */
244 static void DoC_ScanChips(struct DiskOnChip
*this)
247 int numchips
[MAX_FLOORS_MIL
];
254 /* For each floor, find the number of valid chips it contains */
255 for (floor
= 0,ret
= 1; floor
< MAX_FLOORS_MIL
; floor
++) {
257 for (chip
= 0; chip
< MAX_CHIPS_MIL
&& ret
!= 0; chip
++) {
258 ret
= DoC_IdentChip(this, floor
, chip
);
265 /* If there are none at all that we recognise, bail */
266 if (!this->numchips
) {
267 printk("No flash chips recognised.\n");
271 /* Allocate an array to hold the information for each chip */
272 this->chips
= kmalloc(sizeof(struct Nand
) * this->numchips
, GFP_KERNEL
);
274 printk("No memory for allocating chip info structures\n");
278 /* Fill out the chip array with {floor, chipno} for each
279 * detected chip in the device. */
280 for (floor
= 0, ret
= 0; floor
< MAX_FLOORS_MIL
; floor
++) {
281 for (chip
= 0 ; chip
< numchips
[floor
] ; chip
++) {
282 this->chips
[ret
].floor
= floor
;
283 this->chips
[ret
].chip
= chip
;
284 this->chips
[ret
].curadr
= 0;
285 this->chips
[ret
].curmode
= 0x50;
290 /* Calculate and print the total size of the device */
291 this->totlen
= this->numchips
* (1 << this->chipshift
);
292 printk(KERN_INFO
"%d flash chips found. Total DiskOnChip size: %ld MiB\n",
293 this->numchips
,this->totlen
>> 20);
296 static int DoCMil_is_alias(struct DiskOnChip
*doc1
, struct DiskOnChip
*doc2
)
298 int tmp1
, tmp2
, retval
;
300 if (doc1
->physadr
== doc2
->physadr
)
303 /* Use the alias resolution register which was set aside for this
304 * purpose. If it's value is the same on both chips, they might
305 * be the same chip, and we write to one and check for a change in
306 * the other. It's unclear if this register is usuable in the
307 * DoC 2000 (it's in the Millenium docs), but it seems to work. */
308 tmp1
= ReadDOC(doc1
->virtadr
, AliasResolution
);
309 tmp2
= ReadDOC(doc2
->virtadr
, AliasResolution
);
313 WriteDOC((tmp1
+1) % 0xff, doc1
->virtadr
, AliasResolution
);
314 tmp2
= ReadDOC(doc2
->virtadr
, AliasResolution
);
315 if (tmp2
== (tmp1
+1) % 0xff)
320 /* Restore register contents. May not be necessary, but do it just to
322 WriteDOC(tmp1
, doc1
->virtadr
, AliasResolution
);
327 /* This routine is found from the docprobe code by symbol_get(),
328 * which will bump the use count of this module. */
329 void DoCMil_init(struct mtd_info
*mtd
)
331 struct DiskOnChip
*this = mtd
->priv
;
332 struct DiskOnChip
*old
= NULL
;
334 /* We must avoid being called twice for the same device. */
336 old
= docmillist
->priv
;
339 if (DoCMil_is_alias(this, old
)) {
340 printk(KERN_NOTICE
"Ignoring DiskOnChip Millennium at "
341 "0x%lX - already configured\n", this->physadr
);
342 iounmap(this->virtadr
);
347 old
= old
->nextdoc
->priv
;
352 mtd
->name
= "DiskOnChip Millennium";
353 printk(KERN_NOTICE
"DiskOnChip Millennium found at address 0x%lX\n",
356 mtd
->type
= MTD_NANDFLASH
;
357 mtd
->flags
= MTD_CAP_NANDFLASH
;
358 mtd
->ecctype
= MTD_ECC_RS_DiskOnChip
;
361 /* FIXME: erase size is not always 8KiB */
362 mtd
->erasesize
= 0x2000;
364 mtd
->writesize
= 512;
366 mtd
->owner
= THIS_MODULE
;
367 mtd
->erase
= doc_erase
;
370 mtd
->read
= doc_read
;
371 mtd
->write
= doc_write
;
372 mtd
->read_ecc
= doc_read_ecc
;
373 mtd
->write_ecc
= doc_write_ecc
;
374 mtd
->read_oob
= doc_read_oob
;
375 mtd
->write_oob
= doc_write_oob
;
383 /* Ident all the chips present. */
388 iounmap(this->virtadr
);
390 this->nextdoc
= docmillist
;
392 mtd
->size
= this->totlen
;
397 EXPORT_SYMBOL_GPL(DoCMil_init
);
399 static int doc_read (struct mtd_info
*mtd
, loff_t from
, size_t len
,
400 size_t *retlen
, u_char
*buf
)
402 /* Just a special case of doc_read_ecc */
403 return doc_read_ecc(mtd
, from
, len
, retlen
, buf
, NULL
, NULL
);
406 static int doc_read_ecc (struct mtd_info
*mtd
, loff_t from
, size_t len
,
407 size_t *retlen
, u_char
*buf
, u_char
*eccbuf
,
408 struct nand_oobinfo
*oobsel
)
412 unsigned char syndrome
[6];
413 struct DiskOnChip
*this = mtd
->priv
;
414 void __iomem
*docptr
= this->virtadr
;
415 struct Nand
*mychip
= &this->chips
[from
>> (this->chipshift
)];
417 /* Don't allow read past end of device */
418 if (from
>= this->totlen
)
421 /* Don't allow a single read to cross a 512-byte block boundary */
422 if (from
+ len
> ((from
| 0x1ff) + 1))
423 len
= ((from
| 0x1ff) + 1) - from
;
425 /* Find the chip which is to be used and select it */
426 if (this->curfloor
!= mychip
->floor
) {
427 DoC_SelectFloor(docptr
, mychip
->floor
);
428 DoC_SelectChip(docptr
, mychip
->chip
);
429 } else if (this->curchip
!= mychip
->chip
) {
430 DoC_SelectChip(docptr
, mychip
->chip
);
432 this->curfloor
= mychip
->floor
;
433 this->curchip
= mychip
->chip
;
435 /* issue the Read0 or Read1 command depend on which half of the page
436 we are accessing. Polling the Flash Ready bit after issue 3 bytes
437 address in Sequence Read Mode, see Software Requirement 11.4 item 1.*/
438 DoC_Command(docptr
, (from
>> 8) & 1, CDSN_CTRL_WP
);
439 DoC_Address(docptr
, 3, from
, CDSN_CTRL_WP
, 0x00);
440 DoC_WaitReady(docptr
);
443 /* init the ECC engine, see Reed-Solomon EDC/ECC 11.1 .*/
444 WriteDOC (DOC_ECC_RESET
, docptr
, ECCConf
);
445 WriteDOC (DOC_ECC_EN
, docptr
, ECCConf
);
447 /* disable the ECC engine */
448 WriteDOC (DOC_ECC_RESET
, docptr
, ECCConf
);
449 WriteDOC (DOC_ECC_DIS
, docptr
, ECCConf
);
452 /* Read the data via the internal pipeline through CDSN IO register,
453 see Pipelined Read Operations 11.3 */
454 dummy
= ReadDOC(docptr
, ReadPipeInit
);
456 for (i
= 0; i
< len
-1; i
++) {
457 /* N.B. you have to increase the source address in this way or the
458 ECC logic will not work properly */
459 buf
[i
] = ReadDOC(docptr
, Mil_CDSN_IO
+ (i
& 0xff));
462 memcpy_fromio(buf
, docptr
+ DoC_Mil_CDSN_IO
, len
- 1);
464 buf
[len
- 1] = ReadDOC(docptr
, LastDataRead
);
466 /* Let the caller know we completed it */
471 /* Read the ECC data from Spare Data Area,
472 see Reed-Solomon EDC/ECC 11.1 */
473 dummy
= ReadDOC(docptr
, ReadPipeInit
);
475 for (i
= 0; i
< 5; i
++) {
476 /* N.B. you have to increase the source address in this way or the
477 ECC logic will not work properly */
478 eccbuf
[i
] = ReadDOC(docptr
, Mil_CDSN_IO
+ i
);
481 memcpy_fromio(eccbuf
, docptr
+ DoC_Mil_CDSN_IO
, 5);
483 eccbuf
[5] = ReadDOC(docptr
, LastDataRead
);
485 /* Flush the pipeline */
486 dummy
= ReadDOC(docptr
, ECCConf
);
487 dummy
= ReadDOC(docptr
, ECCConf
);
489 /* Check the ECC Status */
490 if (ReadDOC(docptr
, ECCConf
) & 0x80) {
492 /* There was an ECC error */
494 printk("DiskOnChip ECC Error: Read at %lx\n", (long)from
);
496 /* Read the ECC syndrom through the DiskOnChip ECC logic.
497 These syndrome will be all ZERO when there is no error */
498 for (i
= 0; i
< 6; i
++) {
499 syndrome
[i
] = ReadDOC(docptr
, ECCSyndrome0
+ i
);
501 nb_errors
= doc_decode_ecc(buf
, syndrome
);
503 printk("ECC Errors corrected: %x\n", nb_errors
);
506 /* We return error, but have actually done the read. Not that
507 this can be told to user-space, via sys_read(), but at least
508 MTD-aware stuff can know about it by checking *retlen */
514 printk("ECC DATA at %lx: %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
515 (long)from
, eccbuf
[0], eccbuf
[1], eccbuf
[2], eccbuf
[3],
516 eccbuf
[4], eccbuf
[5]);
519 /* disable the ECC engine */
520 WriteDOC(DOC_ECC_DIS
, docptr
, ECCConf
);
526 static int doc_write (struct mtd_info
*mtd
, loff_t to
, size_t len
,
527 size_t *retlen
, const u_char
*buf
)
530 return doc_write_ecc(mtd
, to
, len
, retlen
, buf
, eccbuf
, NULL
);
533 static int doc_write_ecc (struct mtd_info
*mtd
, loff_t to
, size_t len
,
534 size_t *retlen
, const u_char
*buf
, u_char
*eccbuf
,
535 struct nand_oobinfo
*oobsel
)
539 struct DiskOnChip
*this = mtd
->priv
;
540 void __iomem
*docptr
= this->virtadr
;
541 struct Nand
*mychip
= &this->chips
[to
>> (this->chipshift
)];
543 /* Don't allow write past end of device */
544 if (to
>= this->totlen
)
548 /* Don't allow a single write to cross a 512-byte block boundary */
549 if (to
+ len
> ( (to
| 0x1ff) + 1))
550 len
= ((to
| 0x1ff) + 1) - to
;
552 /* Don't allow writes which aren't exactly one block */
553 if (to
& 0x1ff || len
!= 0x200)
557 /* Find the chip which is to be used and select it */
558 if (this->curfloor
!= mychip
->floor
) {
559 DoC_SelectFloor(docptr
, mychip
->floor
);
560 DoC_SelectChip(docptr
, mychip
->chip
);
561 } else if (this->curchip
!= mychip
->chip
) {
562 DoC_SelectChip(docptr
, mychip
->chip
);
564 this->curfloor
= mychip
->floor
;
565 this->curchip
= mychip
->chip
;
567 /* Reset the chip, see Software Requirement 11.4 item 1. */
568 DoC_Command(docptr
, NAND_CMD_RESET
, 0x00);
569 DoC_WaitReady(docptr
);
570 /* Set device to main plane of flash */
571 DoC_Command(docptr
, NAND_CMD_READ0
, 0x00);
573 /* issue the Serial Data In command to initial the Page Program process */
574 DoC_Command(docptr
, NAND_CMD_SEQIN
, 0x00);
575 DoC_Address(docptr
, 3, to
, 0x00, 0x00);
576 DoC_WaitReady(docptr
);
579 /* init the ECC engine, see Reed-Solomon EDC/ECC 11.1 .*/
580 WriteDOC (DOC_ECC_RESET
, docptr
, ECCConf
);
581 WriteDOC (DOC_ECC_EN
| DOC_ECC_RW
, docptr
, ECCConf
);
583 /* disable the ECC engine */
584 WriteDOC (DOC_ECC_RESET
, docptr
, ECCConf
);
585 WriteDOC (DOC_ECC_DIS
, docptr
, ECCConf
);
588 /* Write the data via the internal pipeline through CDSN IO register,
589 see Pipelined Write Operations 11.2 */
591 for (i
= 0; i
< len
; i
++) {
592 /* N.B. you have to increase the source address in this way or the
593 ECC logic will not work properly */
594 WriteDOC(buf
[i
], docptr
, Mil_CDSN_IO
+ i
);
597 memcpy_toio(docptr
+ DoC_Mil_CDSN_IO
, buf
, len
);
599 WriteDOC(0x00, docptr
, WritePipeTerm
);
602 /* Write ECC data to flash, the ECC info is generated by the DiskOnChip ECC logic
603 see Reed-Solomon EDC/ECC 11.1 */
604 WriteDOC(0, docptr
, NOP
);
605 WriteDOC(0, docptr
, NOP
);
606 WriteDOC(0, docptr
, NOP
);
608 /* Read the ECC data through the DiskOnChip ECC logic */
609 for (i
= 0; i
< 6; i
++) {
610 eccbuf
[i
] = ReadDOC(docptr
, ECCSyndrome0
+ i
);
613 /* ignore the ECC engine */
614 WriteDOC(DOC_ECC_DIS
, docptr
, ECCConf
);
617 /* Write the ECC data to flash */
618 for (i
= 0; i
< 6; i
++) {
619 /* N.B. you have to increase the source address in this way or the
620 ECC logic will not work properly */
621 WriteDOC(eccbuf
[i
], docptr
, Mil_CDSN_IO
+ i
);
624 memcpy_toio(docptr
+ DoC_Mil_CDSN_IO
, eccbuf
, 6);
627 /* write the block status BLOCK_USED (0x5555) at the end of ECC data
628 FIXME: this is only a hack for programming the IPL area for LinuxBIOS
629 and should be replace with proper codes in user space utilities */
630 WriteDOC(0x55, docptr
, Mil_CDSN_IO
);
631 WriteDOC(0x55, docptr
, Mil_CDSN_IO
+ 1);
633 WriteDOC(0x00, docptr
, WritePipeTerm
);
636 printk("OOB data at %lx is %2.2X %2.2X %2.2X %2.2X %2.2X %2.2X\n",
637 (long) to
, eccbuf
[0], eccbuf
[1], eccbuf
[2], eccbuf
[3],
638 eccbuf
[4], eccbuf
[5]);
642 /* Commit the Page Program command and wait for ready
643 see Software Requirement 11.4 item 1.*/
644 DoC_Command(docptr
, NAND_CMD_PAGEPROG
, 0x00);
645 DoC_WaitReady(docptr
);
647 /* Read the status of the flash device through CDSN IO register
648 see Software Requirement 11.4 item 5.*/
649 DoC_Command(docptr
, NAND_CMD_STATUS
, CDSN_CTRL_WP
);
650 dummy
= ReadDOC(docptr
, ReadPipeInit
);
651 DoC_Delay(docptr
, 2);
652 if (ReadDOC(docptr
, Mil_CDSN_IO
) & 1) {
653 printk("Error programming flash\n");
654 /* Error in programming
655 FIXME: implement Bad Block Replacement (in nftl.c ??) */
659 dummy
= ReadDOC(docptr
, LastDataRead
);
661 /* Let the caller know we completed it */
667 static int doc_read_oob(struct mtd_info
*mtd
, loff_t ofs
, size_t len
,
668 size_t *retlen
, u_char
*buf
)
674 struct DiskOnChip
*this = mtd
->priv
;
675 void __iomem
*docptr
= this->virtadr
;
676 struct Nand
*mychip
= &this->chips
[ofs
>> this->chipshift
];
678 /* Find the chip which is to be used and select it */
679 if (this->curfloor
!= mychip
->floor
) {
680 DoC_SelectFloor(docptr
, mychip
->floor
);
681 DoC_SelectChip(docptr
, mychip
->chip
);
682 } else if (this->curchip
!= mychip
->chip
) {
683 DoC_SelectChip(docptr
, mychip
->chip
);
685 this->curfloor
= mychip
->floor
;
686 this->curchip
= mychip
->chip
;
688 /* disable the ECC engine */
689 WriteDOC (DOC_ECC_RESET
, docptr
, ECCConf
);
690 WriteDOC (DOC_ECC_DIS
, docptr
, ECCConf
);
692 /* issue the Read2 command to set the pointer to the Spare Data Area.
693 Polling the Flash Ready bit after issue 3 bytes address in
694 Sequence Read Mode, see Software Requirement 11.4 item 1.*/
695 DoC_Command(docptr
, NAND_CMD_READOOB
, CDSN_CTRL_WP
);
696 DoC_Address(docptr
, 3, ofs
, CDSN_CTRL_WP
, 0x00);
697 DoC_WaitReady(docptr
);
699 /* Read the data out via the internal pipeline through CDSN IO register,
700 see Pipelined Read Operations 11.3 */
701 dummy
= ReadDOC(docptr
, ReadPipeInit
);
703 for (i
= 0; i
< len
-1; i
++) {
704 /* N.B. you have to increase the source address in this way or the
705 ECC logic will not work properly */
706 buf
[i
] = ReadDOC(docptr
, Mil_CDSN_IO
+ i
);
709 memcpy_fromio(buf
, docptr
+ DoC_Mil_CDSN_IO
, len
- 1);
711 buf
[len
- 1] = ReadDOC(docptr
, LastDataRead
);
718 static int doc_write_oob(struct mtd_info
*mtd
, loff_t ofs
, size_t len
,
719 size_t *retlen
, const u_char
*buf
)
726 struct DiskOnChip
*this = mtd
->priv
;
727 void __iomem
*docptr
= this->virtadr
;
728 struct Nand
*mychip
= &this->chips
[ofs
>> this->chipshift
];
730 /* Find the chip which is to be used and select it */
731 if (this->curfloor
!= mychip
->floor
) {
732 DoC_SelectFloor(docptr
, mychip
->floor
);
733 DoC_SelectChip(docptr
, mychip
->chip
);
734 } else if (this->curchip
!= mychip
->chip
) {
735 DoC_SelectChip(docptr
, mychip
->chip
);
737 this->curfloor
= mychip
->floor
;
738 this->curchip
= mychip
->chip
;
740 /* disable the ECC engine */
741 WriteDOC (DOC_ECC_RESET
, docptr
, ECCConf
);
742 WriteDOC (DOC_ECC_DIS
, docptr
, ECCConf
);
744 /* Reset the chip, see Software Requirement 11.4 item 1. */
745 DoC_Command(docptr
, NAND_CMD_RESET
, CDSN_CTRL_WP
);
746 DoC_WaitReady(docptr
);
747 /* issue the Read2 command to set the pointer to the Spare Data Area. */
748 DoC_Command(docptr
, NAND_CMD_READOOB
, CDSN_CTRL_WP
);
750 /* issue the Serial Data In command to initial the Page Program process */
751 DoC_Command(docptr
, NAND_CMD_SEQIN
, 0x00);
752 DoC_Address(docptr
, 3, ofs
, 0x00, 0x00);
754 /* Write the data via the internal pipeline through CDSN IO register,
755 see Pipelined Write Operations 11.2 */
757 for (i
= 0; i
< len
; i
++) {
758 /* N.B. you have to increase the source address in this way or the
759 ECC logic will not work properly */
760 WriteDOC(buf
[i
], docptr
, Mil_CDSN_IO
+ i
);
763 memcpy_toio(docptr
+ DoC_Mil_CDSN_IO
, buf
, len
);
765 WriteDOC(0x00, docptr
, WritePipeTerm
);
767 /* Commit the Page Program command and wait for ready
768 see Software Requirement 11.4 item 1.*/
769 DoC_Command(docptr
, NAND_CMD_PAGEPROG
, 0x00);
770 DoC_WaitReady(docptr
);
772 /* Read the status of the flash device through CDSN IO register
773 see Software Requirement 11.4 item 5.*/
774 DoC_Command(docptr
, NAND_CMD_STATUS
, 0x00);
775 dummy
= ReadDOC(docptr
, ReadPipeInit
);
776 DoC_Delay(docptr
, 2);
777 if (ReadDOC(docptr
, Mil_CDSN_IO
) & 1) {
778 printk("Error programming oob data\n");
779 /* FIXME: implement Bad Block Replacement (in nftl.c ??) */
783 dummy
= ReadDOC(docptr
, LastDataRead
);
790 int doc_erase (struct mtd_info
*mtd
, struct erase_info
*instr
)
793 struct DiskOnChip
*this = mtd
->priv
;
794 __u32 ofs
= instr
->addr
;
795 __u32 len
= instr
->len
;
796 void __iomem
*docptr
= this->virtadr
;
797 struct Nand
*mychip
= &this->chips
[ofs
>> this->chipshift
];
799 if (len
!= mtd
->erasesize
)
800 printk(KERN_WARNING
"Erase not right size (%x != %x)n",
801 len
, mtd
->erasesize
);
803 /* Find the chip which is to be used and select it */
804 if (this->curfloor
!= mychip
->floor
) {
805 DoC_SelectFloor(docptr
, mychip
->floor
);
806 DoC_SelectChip(docptr
, mychip
->chip
);
807 } else if (this->curchip
!= mychip
->chip
) {
808 DoC_SelectChip(docptr
, mychip
->chip
);
810 this->curfloor
= mychip
->floor
;
811 this->curchip
= mychip
->chip
;
813 instr
->state
= MTD_ERASE_PENDING
;
815 /* issue the Erase Setup command */
816 DoC_Command(docptr
, NAND_CMD_ERASE1
, 0x00);
817 DoC_Address(docptr
, 2, ofs
, 0x00, 0x00);
819 /* Commit the Erase Start command and wait for ready
820 see Software Requirement 11.4 item 1.*/
821 DoC_Command(docptr
, NAND_CMD_ERASE2
, 0x00);
822 DoC_WaitReady(docptr
);
824 instr
->state
= MTD_ERASING
;
826 /* Read the status of the flash device through CDSN IO register
827 see Software Requirement 11.4 item 5.
828 FIXME: it seems that we are not wait long enough, some blocks are not
830 DoC_Command(docptr
, NAND_CMD_STATUS
, CDSN_CTRL_WP
);
831 dummy
= ReadDOC(docptr
, ReadPipeInit
);
832 DoC_Delay(docptr
, 2);
833 if (ReadDOC(docptr
, Mil_CDSN_IO
) & 1) {
834 printk("Error Erasing at 0x%x\n", ofs
);
835 /* There was an error
836 FIXME: implement Bad Block Replacement (in nftl.c ??) */
837 instr
->state
= MTD_ERASE_FAILED
;
839 instr
->state
= MTD_ERASE_DONE
;
840 dummy
= ReadDOC(docptr
, LastDataRead
);
842 mtd_erase_callback(instr
);
847 /****************************************************************************
851 ****************************************************************************/
853 static void __exit
cleanup_doc2001(void)
855 struct mtd_info
*mtd
;
856 struct DiskOnChip
*this;
858 while ((mtd
=docmillist
)) {
860 docmillist
= this->nextdoc
;
864 iounmap(this->virtadr
);
870 module_exit(cleanup_doc2001
);
872 MODULE_LICENSE("GPL");
873 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
874 MODULE_DESCRIPTION("Alternative driver for DiskOnChip Millennium");