]>
git.proxmox.com Git - qemu.git/blob - hw/nand.c
2 * Flash NAND memory emulation. Based on "16M x 8 Bit NAND Flash
3 * Memory" datasheet for the KM29U128AT / K9F2808U0A chips from
6 * Copyright (c) 2006 Openedhand Ltd.
7 * Written by Andrzej Zaborowski <balrog@zabor.org>
9 * This code is licensed under the GNU GPL v2.
16 # define NAND_CMD_READ0 0x00
17 # define NAND_CMD_READ1 0x01
18 # define NAND_CMD_READ2 0x50
19 # define NAND_CMD_LPREAD2 0x30
20 # define NAND_CMD_NOSERIALREAD2 0x35
21 # define NAND_CMD_RANDOMREAD1 0x05
22 # define NAND_CMD_RANDOMREAD2 0xe0
23 # define NAND_CMD_READID 0x90
24 # define NAND_CMD_RESET 0xff
25 # define NAND_CMD_PAGEPROGRAM1 0x80
26 # define NAND_CMD_PAGEPROGRAM2 0x10
27 # define NAND_CMD_CACHEPROGRAM2 0x15
28 # define NAND_CMD_BLOCKERASE1 0x60
29 # define NAND_CMD_BLOCKERASE2 0xd0
30 # define NAND_CMD_READSTATUS 0x70
31 # define NAND_CMD_COPYBACKPRG1 0x85
33 # define NAND_IOSTATUS_ERROR (1 << 0)
34 # define NAND_IOSTATUS_PLANE0 (1 << 1)
35 # define NAND_IOSTATUS_PLANE1 (1 << 2)
36 # define NAND_IOSTATUS_PLANE2 (1 << 3)
37 # define NAND_IOSTATUS_PLANE3 (1 << 4)
38 # define NAND_IOSTATUS_BUSY (1 << 6)
39 # define NAND_IOSTATUS_UNPROTCT (1 << 7)
41 # define MAX_PAGE 0x800
45 uint8_t manf_id
, chip_id
;
47 int page_shift
, oob_shift
, erase_shift
, addr_shift
;
49 BlockDriverState
*bdrv
;
52 int cle
, ale
, ce
, wp
, gnd
;
54 uint8_t io
[MAX_PAGE
+ MAX_OOB
+ 0x400];
63 void (*blk_write
)(struct nand_flash_s
*s
);
64 void (*blk_erase
)(struct nand_flash_s
*s
);
65 void (*blk_load
)(struct nand_flash_s
*s
, uint32_t addr
, int offset
);
68 # define NAND_NO_AUTOINCR 0x00000001
69 # define NAND_BUSWIDTH_16 0x00000002
70 # define NAND_NO_PADDING 0x00000004
71 # define NAND_CACHEPRG 0x00000008
72 # define NAND_COPYBACK 0x00000010
73 # define NAND_IS_AND 0x00000020
74 # define NAND_4PAGE_ARRAY 0x00000040
75 # define NAND_NO_READRDY 0x00000100
76 # define NAND_SAMSUNG_LP (NAND_NO_PADDING | NAND_COPYBACK)
80 # define PAGE(addr) ((addr) >> ADDR_SHIFT)
81 # define PAGE_START(page) (PAGE(page) * (PAGE_SIZE + OOB_SIZE))
82 # define PAGE_MASK ((1 << ADDR_SHIFT) - 1)
83 # define OOB_SHIFT (PAGE_SHIFT - 5)
84 # define OOB_SIZE (1 << OOB_SHIFT)
85 # define SECTOR(addr) ((addr) >> (9 + ADDR_SHIFT - PAGE_SHIFT))
86 # define SECTOR_OFFSET(addr) ((addr) & ((511 >> PAGE_SHIFT) << 8))
88 # define PAGE_SIZE 256
90 # define PAGE_SECTORS 1
93 # define PAGE_SIZE 512
95 # define PAGE_SECTORS 1
98 # define PAGE_SIZE 2048
99 # define PAGE_SHIFT 11
100 # define PAGE_SECTORS 4
101 # define ADDR_SHIFT 16
104 /* Information based on Linux drivers/mtd/nand/nand_ids.c */
111 } nand_flash_ids
[0x100] = {
112 [0 ... 0xff] = { 0 },
114 [0x6e] = { 1, 8, 8, 4, 0 },
115 [0x64] = { 2, 8, 8, 4, 0 },
116 [0x6b] = { 4, 8, 9, 4, 0 },
117 [0xe8] = { 1, 8, 8, 4, 0 },
118 [0xec] = { 1, 8, 8, 4, 0 },
119 [0xea] = { 2, 8, 8, 4, 0 },
120 [0xd5] = { 4, 8, 9, 4, 0 },
121 [0xe3] = { 4, 8, 9, 4, 0 },
122 [0xe5] = { 4, 8, 9, 4, 0 },
123 [0xd6] = { 8, 8, 9, 4, 0 },
125 [0x39] = { 8, 8, 9, 4, 0 },
126 [0xe6] = { 8, 8, 9, 4, 0 },
127 [0x49] = { 8, 16, 9, 4, NAND_BUSWIDTH_16
},
128 [0x59] = { 8, 16, 9, 4, NAND_BUSWIDTH_16
},
130 [0x33] = { 16, 8, 9, 5, 0 },
131 [0x73] = { 16, 8, 9, 5, 0 },
132 [0x43] = { 16, 16, 9, 5, NAND_BUSWIDTH_16
},
133 [0x53] = { 16, 16, 9, 5, NAND_BUSWIDTH_16
},
135 [0x35] = { 32, 8, 9, 5, 0 },
136 [0x75] = { 32, 8, 9, 5, 0 },
137 [0x45] = { 32, 16, 9, 5, NAND_BUSWIDTH_16
},
138 [0x55] = { 32, 16, 9, 5, NAND_BUSWIDTH_16
},
140 [0x36] = { 64, 8, 9, 5, 0 },
141 [0x76] = { 64, 8, 9, 5, 0 },
142 [0x46] = { 64, 16, 9, 5, NAND_BUSWIDTH_16
},
143 [0x56] = { 64, 16, 9, 5, NAND_BUSWIDTH_16
},
145 [0x78] = { 128, 8, 9, 5, 0 },
146 [0x39] = { 128, 8, 9, 5, 0 },
147 [0x79] = { 128, 8, 9, 5, 0 },
148 [0x72] = { 128, 16, 9, 5, NAND_BUSWIDTH_16
},
149 [0x49] = { 128, 16, 9, 5, NAND_BUSWIDTH_16
},
150 [0x74] = { 128, 16, 9, 5, NAND_BUSWIDTH_16
},
151 [0x59] = { 128, 16, 9, 5, NAND_BUSWIDTH_16
},
153 [0x71] = { 256, 8, 9, 5, 0 },
156 * These are the new chips with large page size. The pagesize and the
157 * erasesize is determined from the extended id bytes
159 # define LP_OPTIONS (NAND_SAMSUNG_LP | NAND_NO_READRDY | NAND_NO_AUTOINCR)
160 # define LP_OPTIONS16 (LP_OPTIONS | NAND_BUSWIDTH_16)
163 [0xa2] = { 64, 8, 0, 0, LP_OPTIONS
},
164 [0xf2] = { 64, 8, 0, 0, LP_OPTIONS
},
165 [0xb2] = { 64, 16, 0, 0, LP_OPTIONS16
},
166 [0xc2] = { 64, 16, 0, 0, LP_OPTIONS16
},
169 [0xa1] = { 128, 8, 0, 0, LP_OPTIONS
},
170 [0xf1] = { 128, 8, 0, 0, LP_OPTIONS
},
171 [0xb1] = { 128, 16, 0, 0, LP_OPTIONS16
},
172 [0xc1] = { 128, 16, 0, 0, LP_OPTIONS16
},
175 [0xaa] = { 256, 8, 0, 0, LP_OPTIONS
},
176 [0xda] = { 256, 8, 0, 0, LP_OPTIONS
},
177 [0xba] = { 256, 16, 0, 0, LP_OPTIONS16
},
178 [0xca] = { 256, 16, 0, 0, LP_OPTIONS16
},
181 [0xac] = { 512, 8, 0, 0, LP_OPTIONS
},
182 [0xdc] = { 512, 8, 0, 0, LP_OPTIONS
},
183 [0xbc] = { 512, 16, 0, 0, LP_OPTIONS16
},
184 [0xcc] = { 512, 16, 0, 0, LP_OPTIONS16
},
187 [0xa3] = { 1024, 8, 0, 0, LP_OPTIONS
},
188 [0xd3] = { 1024, 8, 0, 0, LP_OPTIONS
},
189 [0xb3] = { 1024, 16, 0, 0, LP_OPTIONS16
},
190 [0xc3] = { 1024, 16, 0, 0, LP_OPTIONS16
},
193 [0xa5] = { 2048, 8, 0, 0, LP_OPTIONS
},
194 [0xd5] = { 2048, 8, 0, 0, LP_OPTIONS
},
195 [0xb5] = { 2048, 16, 0, 0, LP_OPTIONS16
},
196 [0xc5] = { 2048, 16, 0, 0, LP_OPTIONS16
},
199 static void nand_reset(struct nand_flash_s
*s
)
201 s
->cmd
= NAND_CMD_READ0
;
206 s
->status
&= NAND_IOSTATUS_UNPROTCT
;
209 static void nand_command(struct nand_flash_s
*s
)
216 case NAND_CMD_READID
:
217 s
->io
[0] = s
->manf_id
;
218 s
->io
[1] = s
->chip_id
;
219 s
->io
[2] = 'Q'; /* Don't-care byte (often 0xa5) */
220 if (nand_flash_ids
[s
->chip_id
].options
& NAND_SAMSUNG_LP
)
221 s
->io
[3] = 0x15; /* Page Size, Block Size, Spare Size.. */
223 s
->io
[3] = 0xc0; /* Multi-plane */
228 case NAND_CMD_RANDOMREAD2
:
229 case NAND_CMD_NOSERIALREAD2
:
230 if (!(nand_flash_ids
[s
->chip_id
].options
& NAND_SAMSUNG_LP
))
233 s
->blk_load(s
, s
->addr
, s
->addr
& ((1 << s
->addr_shift
) - 1));
240 case NAND_CMD_PAGEPROGRAM1
:
245 case NAND_CMD_PAGEPROGRAM2
:
251 case NAND_CMD_BLOCKERASE1
:
254 case NAND_CMD_BLOCKERASE2
:
255 if (nand_flash_ids
[s
->chip_id
].options
& NAND_SAMSUNG_LP
)
265 case NAND_CMD_READSTATUS
:
266 s
->io
[0] = s
->status
;
272 printf("%s: Unknown NAND command 0x%02x\n", __FUNCTION__
, s
->cmd
);
277 * Chip inputs are CLE, ALE, CE, WP, GND and eight I/O pins. Chip
278 * outputs are R/B and eight I/O pins.
280 * CE, WP and R/B are active low.
282 void nand_setpins(struct nand_flash_s
*s
,
283 int cle
, int ale
, int ce
, int wp
, int gnd
)
291 s
->status
|= NAND_IOSTATUS_UNPROTCT
;
293 s
->status
&= ~NAND_IOSTATUS_UNPROTCT
;
296 void nand_getpins(struct nand_flash_s
*s
, int *rb
)
301 void nand_setio(struct nand_flash_s
*s
, uint8_t value
)
303 if (!s
->ce
&& s
->cle
) {
304 if (nand_flash_ids
[s
->chip_id
].options
& NAND_SAMSUNG_LP
) {
305 if (s
->cmd
== NAND_CMD_READ0
&& value
== NAND_CMD_LPREAD2
)
307 if (value
== NAND_CMD_RANDOMREAD1
) {
308 s
->addr
&= ~((1 << s
->addr_shift
) - 1);
313 if (value
== NAND_CMD_READ0
)
315 else if (value
== NAND_CMD_READ1
) {
317 value
= NAND_CMD_READ0
;
319 else if (value
== NAND_CMD_READ2
) {
320 s
->offset
= 1 << s
->page_shift
;
321 value
= NAND_CMD_READ0
;
326 if (s
->cmd
== NAND_CMD_READSTATUS
||
327 s
->cmd
== NAND_CMD_PAGEPROGRAM2
||
328 s
->cmd
== NAND_CMD_BLOCKERASE1
||
329 s
->cmd
== NAND_CMD_BLOCKERASE2
||
330 s
->cmd
== NAND_CMD_NOSERIALREAD2
||
331 s
->cmd
== NAND_CMD_RANDOMREAD2
||
332 s
->cmd
== NAND_CMD_RESET
)
335 if (s
->cmd
!= NAND_CMD_RANDOMREAD2
) {
342 s
->addr
|= value
<< (s
->addrlen
* 8);
345 if (s
->addrlen
== 1 && s
->cmd
== NAND_CMD_READID
)
348 if (!(nand_flash_ids
[s
->chip_id
].options
& NAND_SAMSUNG_LP
) &&
350 s
->cmd
== NAND_CMD_READ0
||
351 s
->cmd
== NAND_CMD_PAGEPROGRAM1
))
353 if ((nand_flash_ids
[s
->chip_id
].options
& NAND_SAMSUNG_LP
) &&
355 s
->cmd
== NAND_CMD_READ0
||
356 s
->cmd
== NAND_CMD_PAGEPROGRAM1
))
360 if (!s
->cle
&& !s
->ale
&& s
->cmd
== NAND_CMD_PAGEPROGRAM1
) {
361 if (s
->iolen
< (1 << s
->page_shift
) + (1 << s
->oob_shift
))
362 s
->io
[s
->iolen
++] = value
;
363 } else if (!s
->cle
&& !s
->ale
&& s
->cmd
== NAND_CMD_COPYBACKPRG1
) {
364 if ((s
->addr
& ((1 << s
->addr_shift
) - 1)) <
365 (1 << s
->page_shift
) + (1 << s
->oob_shift
)) {
366 s
->io
[s
->iolen
+ (s
->addr
& ((1 << s
->addr_shift
) - 1))] = value
;
372 uint8_t nand_getio(struct nand_flash_s
*s
)
376 /* Allow sequential reading */
377 if (!s
->iolen
&& s
->cmd
== NAND_CMD_READ0
) {
378 offset
= (s
->addr
& ((1 << s
->addr_shift
) - 1)) + s
->offset
;
381 s
->blk_load(s
, s
->addr
, offset
);
383 s
->iolen
= (1 << s
->page_shift
) - offset
;
385 s
->iolen
= (1 << s
->page_shift
) + (1 << s
->oob_shift
) - offset
;
388 if (s
->ce
|| s
->iolen
<= 0)
392 return *(s
->ioaddr
++);
395 struct nand_flash_s
*nand_init(int manf_id
, int chip_id
)
398 struct nand_flash_s
*s
;
400 if (nand_flash_ids
[chip_id
].size
== 0) {
401 cpu_abort(cpu_single_env
, "%s: Unsupported NAND chip ID.\n",
405 s
= (struct nand_flash_s
*) qemu_mallocz(sizeof(struct nand_flash_s
));
407 s
->manf_id
= manf_id
;
408 s
->chip_id
= chip_id
;
409 s
->size
= nand_flash_ids
[s
->chip_id
].size
<< 20;
410 if (nand_flash_ids
[s
->chip_id
].options
& NAND_SAMSUNG_LP
) {
414 s
->page_shift
= nand_flash_ids
[s
->chip_id
].page_shift
;
415 s
->erase_shift
= nand_flash_ids
[s
->chip_id
].erase_shift
;
418 switch (1 << s
->page_shift
) {
429 cpu_abort(cpu_single_env
, "%s: Unsupported NAND block size.\n",
433 pagesize
= 1 << s
->oob_shift
;
435 if (s
->bdrv
&& bdrv_getlength(s
->bdrv
) >=
436 (s
->pages
<< s
->page_shift
) + (s
->pages
<< s
->oob_shift
)) {
442 pagesize
+= 1 << s
->page_shift
;
444 s
->storage
= (uint8_t *) memset(qemu_malloc(s
->pages
* pagesize
),
445 0xff, s
->pages
* pagesize
);
449 void nand_done(struct nand_flash_s
*s
)
453 bdrv_delete(s
->bdrv
);
456 if (!s
->bdrv
|| s
->mem_oob
)
464 /* Program a single page */
465 static void glue(nand_blk_write_
, PAGE_SIZE
)(struct nand_flash_s
*s
)
467 uint32_t off
, page
, sector
, soff
;
468 uint8_t iobuf
[(PAGE_SECTORS
+ 2) * 0x200];
469 if (PAGE(s
->addr
) >= s
->pages
)
473 memcpy(s
->storage
+ PAGE_START(s
->addr
) + (s
->addr
& PAGE_MASK
) +
474 s
->offset
, s
->io
, s
->iolen
);
475 } else if (s
->mem_oob
) {
476 sector
= SECTOR(s
->addr
);
477 off
= (s
->addr
& PAGE_MASK
) + s
->offset
;
478 soff
= SECTOR_OFFSET(s
->addr
);
479 if (bdrv_read(s
->bdrv
, sector
, iobuf
, PAGE_SECTORS
) == -1) {
480 printf("%s: read error in sector %i\n", __FUNCTION__
, sector
);
484 memcpy(iobuf
+ (soff
| off
), s
->io
, MIN(s
->iolen
, PAGE_SIZE
- off
));
485 if (off
+ s
->iolen
> PAGE_SIZE
) {
486 page
= PAGE(s
->addr
);
487 memcpy(s
->storage
+ (page
<< OOB_SHIFT
), s
->io
+ PAGE_SIZE
- off
,
488 MIN(OOB_SIZE
, off
+ s
->iolen
- PAGE_SIZE
));
491 if (bdrv_write(s
->bdrv
, sector
, iobuf
, PAGE_SECTORS
) == -1)
492 printf("%s: write error in sector %i\n", __FUNCTION__
, sector
);
494 off
= PAGE_START(s
->addr
) + (s
->addr
& PAGE_MASK
) + s
->offset
;
497 if (bdrv_read(s
->bdrv
, sector
, iobuf
, PAGE_SECTORS
+ 2) == -1) {
498 printf("%s: read error in sector %i\n", __FUNCTION__
, sector
);
502 memcpy(iobuf
+ soff
, s
->io
, s
->iolen
);
504 if (bdrv_write(s
->bdrv
, sector
, iobuf
, PAGE_SECTORS
+ 2) == -1)
505 printf("%s: write error in sector %i\n", __FUNCTION__
, sector
);
510 /* Erase a single block */
511 static void glue(nand_blk_erase_
, PAGE_SIZE
)(struct nand_flash_s
*s
)
513 uint32_t i
, page
, addr
;
514 uint8_t iobuf
[0x200] = { [0 ... 0x1ff] = 0xff, };
515 addr
= s
->addr
& ~((1 << (ADDR_SHIFT
+ s
->erase_shift
)) - 1);
517 if (PAGE(addr
) >= s
->pages
)
521 memset(s
->storage
+ PAGE_START(addr
),
522 0xff, (PAGE_SIZE
+ OOB_SIZE
) << s
->erase_shift
);
523 } else if (s
->mem_oob
) {
524 memset(s
->storage
+ (PAGE(addr
) << OOB_SHIFT
),
525 0xff, OOB_SIZE
<< s
->erase_shift
);
527 page
= SECTOR(addr
+ (ADDR_SHIFT
+ s
->erase_shift
));
528 for (; i
< page
; i
++)
529 if (bdrv_write(s
->bdrv
, i
, iobuf
, 1) == -1)
530 printf("%s: write error in sector %i\n", __FUNCTION__
, i
);
532 addr
= PAGE_START(addr
);
534 if (bdrv_read(s
->bdrv
, page
, iobuf
, 1) == -1)
535 printf("%s: read error in sector %i\n", __FUNCTION__
, page
);
536 memset(iobuf
+ (addr
& 0x1ff), 0xff, (~addr
& 0x1ff) + 1);
537 if (bdrv_write(s
->bdrv
, page
, iobuf
, 1) == -1)
538 printf("%s: write error in sector %i\n", __FUNCTION__
, page
);
540 memset(iobuf
, 0xff, 0x200);
541 i
= (addr
& ~0x1ff) + 0x200;
542 for (addr
+= ((PAGE_SIZE
+ OOB_SIZE
) << s
->erase_shift
) - 0x200;
543 i
< addr
; i
+= 0x200)
544 if (bdrv_write(s
->bdrv
, i
>> 9, iobuf
, 1) == -1)
545 printf("%s: write error in sector %i\n", __FUNCTION__
, i
>> 9);
548 if (bdrv_read(s
->bdrv
, page
, iobuf
, 1) == -1)
549 printf("%s: read error in sector %i\n", __FUNCTION__
, page
);
550 memset(iobuf
, 0xff, ((addr
- 1) & 0x1ff) + 1);
551 if (bdrv_write(s
->bdrv
, page
, iobuf
, 1) == -1)
552 printf("%s: write error in sector %i\n", __FUNCTION__
, page
);
556 static void glue(nand_blk_load_
, PAGE_SIZE
)(struct nand_flash_s
*s
,
557 uint32_t addr
, int offset
)
559 if (PAGE(addr
) >= s
->pages
)
564 if (bdrv_read(s
->bdrv
, SECTOR(addr
), s
->io
, PAGE_SECTORS
) == -1)
565 printf("%s: read error in sector %i\n",
566 __FUNCTION__
, SECTOR(addr
));
567 memcpy(s
->io
+ SECTOR_OFFSET(s
->addr
) + PAGE_SIZE
,
568 s
->storage
+ (PAGE(s
->addr
) << OOB_SHIFT
),
570 s
->ioaddr
= s
->io
+ SECTOR_OFFSET(s
->addr
) + offset
;
572 if (bdrv_read(s
->bdrv
, PAGE_START(addr
) >> 9,
573 s
->io
, (PAGE_SECTORS
+ 2)) == -1)
574 printf("%s: read error in sector %i\n",
575 __FUNCTION__
, PAGE_START(addr
) >> 9);
576 s
->ioaddr
= s
->io
+ (PAGE_START(addr
) & 0x1ff) + offset
;
579 memcpy(s
->io
, s
->storage
+ PAGE_START(s
->addr
) +
580 offset
, PAGE_SIZE
+ OOB_SIZE
- offset
);
584 s
->addr
&= PAGE_SIZE
- 1;
585 s
->addr
+= PAGE_SIZE
;
588 static void glue(nand_init_
, PAGE_SIZE
)(struct nand_flash_s
*s
)
590 s
->oob_shift
= PAGE_SHIFT
- 5;
591 s
->pages
= s
->size
>> PAGE_SHIFT
;
592 s
->addr_shift
= ADDR_SHIFT
;
594 s
->blk_erase
= glue(nand_blk_erase_
, PAGE_SIZE
);
595 s
->blk_write
= glue(nand_blk_write_
, PAGE_SIZE
);
596 s
->blk_load
= glue(nand_blk_load_
, PAGE_SIZE
);