2 * CFI parallel flash with Intel command set emulation
4 * Copyright (c) 2006 Thorsten Zitterell
5 * Copyright (c) 2005 Jocelyn Mayer
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 * For now, this code can emulate flashes of 1, 2 or 4 bytes width.
24 * Supported commands/modes are:
31 * It does not support timings
32 * It does not support flash interleaving
33 * It does not implement software data protection as found in many real chips
34 * It does not implement erase suspend/resume commands
35 * It does not implement multiple sectors erase
37 * It does not implement much more ...
43 #include "qemu-timer.h"
45 #define PFLASH_BUG(fmt, args...) \
47 printf("PFLASH: Possible BUG - " fmt, ##args); \
51 /* #define PFLASH_DEBUG */
53 #define DPRINTF(fmt, args...) \
55 printf("PFLASH: " fmt , ##args); \
58 #define DPRINTF(fmt, args...) do { } while (0)
64 target_ulong sector_len
;
65 target_ulong total_len
;
67 int wcycle
; /* if 0, the flash is read normally */
74 uint8_t cfi_table
[0x52];
82 static void pflash_timer (void *opaque
)
84 pflash_t
*pfl
= opaque
;
86 DPRINTF("%s: command %02x done\n", __func__
, pfl
->cmd
);
92 cpu_register_physical_memory(pfl
->base
, pfl
->total_len
,
93 pfl
->off
| IO_MEM_ROMD
| pfl
->fl_mem
);
99 static uint32_t pflash_read (pflash_t
*pfl
, target_ulong offset
, int width
)
107 boff
= offset
& 0xFF; /* why this here ?? */
111 else if (pfl
->width
== 4)
114 DPRINTF("%s: reading offset %08x under cmd %02x\n",
115 __func__
, boff
, pfl
->cmd
);
119 /* Flash area read */
124 DPRINTF("%s: data offset %08x %02x\n", __func__
, offset
, ret
);
127 #if defined(TARGET_WORDS_BIGENDIAN)
128 ret
= p
[offset
] << 8;
129 ret
|= p
[offset
+ 1];
132 ret
|= p
[offset
+ 1] << 8;
134 DPRINTF("%s: data offset %08x %04x\n", __func__
, offset
, ret
);
137 #if defined(TARGET_WORDS_BIGENDIAN)
138 ret
= p
[offset
] << 24;
139 ret
|= p
[offset
+ 1] << 16;
140 ret
|= p
[offset
+ 2] << 8;
141 ret
|= p
[offset
+ 3];
144 ret
|= p
[offset
+ 1] << 8;
145 ret
|= p
[offset
+ 1] << 8;
146 ret
|= p
[offset
+ 2] << 16;
147 ret
|= p
[offset
+ 3] << 24;
149 DPRINTF("%s: data offset %08x %08x\n", __func__
, offset
, ret
);
152 DPRINTF("BUG in %s\n", __func__
);
156 case 0x20: /* Block erase */
157 case 0x50: /* Clear status register */
158 case 0x60: /* Block /un)lock */
159 case 0x70: /* Status Register */
160 case 0xe8: /* Write block */
161 /* Status register read */
163 DPRINTF("%s: status %x\n", __func__
, ret
);
165 case 0x98: /* Query mode */
166 if (boff
> pfl
->cfi_len
)
169 ret
= pfl
->cfi_table
[boff
];
172 /* This should never happen : reset state & treat it as a read */
173 DPRINTF("%s: unknown command state: %x\n", __func__
, pfl
->cmd
);
180 /* update flash content on disk */
181 static void pflash_update(pflash_t
*pfl
, int offset
,
186 offset_end
= offset
+ size
;
187 /* round to sectors */
188 offset
= offset
>> 9;
189 offset_end
= (offset_end
+ 511) >> 9;
190 bdrv_write(pfl
->bs
, offset
, pfl
->storage
+ (offset
<< 9),
191 offset_end
- offset
);
195 static void pflash_write (pflash_t
*pfl
, target_ulong offset
, uint32_t value
,
202 /* WARNING: when the memory area is in ROMD mode, the offset is a
203 ram offset, not a physical address */
206 if (pfl
->wcycle
== 0)
207 offset
-= (target_ulong
)(long)pfl
->storage
;
211 DPRINTF("%s: offset %08x %08x %d wcycle 0x%x\n",
212 __func__
, offset
, value
, width
, pfl
->wcycle
);
214 /* Set the device in I/O access mode */
215 cpu_register_physical_memory(pfl
->base
, pfl
->total_len
, pfl
->fl_mem
);
216 boff
= offset
& (pfl
->sector_len
- 1);
220 else if (pfl
->width
== 4)
223 switch (pfl
->wcycle
) {
229 case 0x20: /* Block erase */
231 offset
&= ~(pfl
->sector_len
- 1);
233 DPRINTF("%s: block erase at 0x%x bytes 0x%x\n", __func__
,
234 offset
, pfl
->sector_len
);
236 memset(p
+ offset
, 0xff, pfl
->sector_len
);
237 pflash_update(pfl
, offset
, pfl
->sector_len
);
238 pfl
->status
|= 0x80; /* Ready! */
240 case 0x50: /* Clear status bits */
241 DPRINTF("%s: Clear status bits\n", __func__
);
244 case 0x60: /* Block (un)lock */
245 DPRINTF("%s: Block unlock\n", __func__
);
247 case 0x70: /* Status Register */
248 DPRINTF("%s: Read status register\n", __func__
);
251 case 0x98: /* CFI query */
252 DPRINTF("%s: CFI query\n", __func__
);
254 case 0xe8: /* Write to buffer */
255 DPRINTF("%s: Write to buffer\n", __func__
);
256 pfl
->status
|= 0x80; /* Ready! */
258 case 0xff: /* Read array mode */
259 DPRINTF("%s: Read array mode\n", __func__
);
269 case 0x20: /* Block erase */
271 if (cmd
== 0xd0) { /* confirm */
274 } if (cmd
== 0xff) { /* read array mode */
281 DPRINTF("%s: block write of 0x%x bytes\n", __func__
, cmd
);
289 } else if (cmd
== 0x01) {
292 } else if (cmd
== 0xff) {
295 DPRINTF("%s: Unknown (un)locking command\n", __func__
);
303 DPRINTF("%s: leaving query mode\n", __func__
);
312 case 0xe8: /* Block write */
314 DPRINTF("%s: block write offset 0x%x value 0x%x counter 0x%x\n",
315 __func__
, offset
, value
, pfl
->counter
);
319 pflash_update(pfl
, offset
, 1);
322 #if defined(TARGET_WORDS_BIGENDIAN)
323 p
[offset
] = value
>> 8;
324 p
[offset
+ 1] = value
;
327 p
[offset
+ 1] = value
>> 8;
329 pflash_update(pfl
, offset
, 2);
332 #if defined(TARGET_WORDS_BIGENDIAN)
333 p
[offset
] = value
>> 24;
334 p
[offset
+ 1] = value
>> 16;
335 p
[offset
+ 2] = value
>> 8;
336 p
[offset
+ 3] = value
;
339 p
[offset
+ 1] = value
>> 8;
340 p
[offset
+ 2] = value
>> 16;
341 p
[offset
+ 3] = value
>> 24;
343 pflash_update(pfl
, offset
, 4);
350 DPRINTF("%s: block write finished\n", __func__
);
358 case 3: /* Confirm mode */
360 case 0xe8: /* Block write */
366 DPRINTF("%s: unknown command for \"write block\"\n", __func__
);
367 PFLASH_BUG("Write block confirm");
372 /* Should never happen */
373 DPRINTF("%s: invalid write state\n", __func__
);
379 printf("%s: Unimplemented flash cmd sequence "
380 "(offset 0x%x, wcycle 0x%x cmd 0x%x value 0x%x\n",
381 __func__
, offset
, pfl
->wcycle
, pfl
->cmd
, value
);
384 cpu_register_physical_memory(pfl
->base
, pfl
->total_len
,
385 pfl
->off
| IO_MEM_ROMD
| pfl
->fl_mem
);
394 static uint32_t pflash_readb (void *opaque
, target_phys_addr_t addr
)
396 return pflash_read(opaque
, addr
, 1);
399 static uint32_t pflash_readw (void *opaque
, target_phys_addr_t addr
)
401 pflash_t
*pfl
= opaque
;
403 return pflash_read(pfl
, addr
, 2);
406 static uint32_t pflash_readl (void *opaque
, target_phys_addr_t addr
)
408 pflash_t
*pfl
= opaque
;
410 return pflash_read(pfl
, addr
, 4);
413 static void pflash_writeb (void *opaque
, target_phys_addr_t addr
,
416 pflash_write(opaque
, addr
, value
, 1);
419 static void pflash_writew (void *opaque
, target_phys_addr_t addr
,
422 pflash_t
*pfl
= opaque
;
424 pflash_write(pfl
, addr
, value
, 2);
427 static void pflash_writel (void *opaque
, target_phys_addr_t addr
,
430 pflash_t
*pfl
= opaque
;
432 pflash_write(pfl
, addr
, value
, 4);
435 static CPUWriteMemoryFunc
*pflash_write_ops
[] = {
441 static CPUReadMemoryFunc
*pflash_read_ops
[] = {
447 /* Count trailing zeroes of a 32 bits quantity */
448 static int ctz32 (uint32_t n
)
473 #if 0 /* This is not necessary as n is never 0 */
481 pflash_t
*pflash_register (target_phys_addr_t base
, ram_addr_t off
,
482 BlockDriverState
*bs
,
483 target_ulong sector_len
, int nb_blocs
, int width
,
484 uint16_t id0
, uint16_t id1
,
485 uint16_t id2
, uint16_t id3
)
488 target_long total_len
;
490 total_len
= sector_len
* nb_blocs
;
492 /* XXX: to be fixed */
493 if (total_len
!= (8 * 1024 * 1024) && total_len
!= (16 * 1024 * 1024) &&
494 total_len
!= (32 * 1024 * 1024) && total_len
!= (64 * 1024 * 1024))
497 pfl
= qemu_mallocz(sizeof(pflash_t
));
501 pfl
->storage
= phys_ram_base
+ off
;
502 pfl
->fl_mem
= cpu_register_io_memory(0,
503 pflash_read_ops
, pflash_write_ops
, pfl
);
505 cpu_register_physical_memory(base
, total_len
,
506 off
| pfl
->fl_mem
| IO_MEM_ROMD
);
510 /* read the initial flash content */
511 bdrv_read(pfl
->bs
, 0, pfl
->storage
, total_len
>> 9);
513 #if 0 /* XXX: there should be a bit to set up read-only,
514 * the same way the hardware does (with WP pin).
520 pfl
->timer
= qemu_new_timer(vm_clock
, pflash_timer
, pfl
);
522 pfl
->sector_len
= sector_len
;
523 pfl
->total_len
= total_len
;
532 /* Hardcoded CFI table */
534 /* Standard "QRY" string */
535 pfl
->cfi_table
[0x10] = 'Q';
536 pfl
->cfi_table
[0x11] = 'R';
537 pfl
->cfi_table
[0x12] = 'Y';
538 /* Command set (Intel) */
539 pfl
->cfi_table
[0x13] = 0x01;
540 pfl
->cfi_table
[0x14] = 0x00;
541 /* Primary extended table address (none) */
542 pfl
->cfi_table
[0x15] = 0x31;
543 pfl
->cfi_table
[0x16] = 0x00;
544 /* Alternate command set (none) */
545 pfl
->cfi_table
[0x17] = 0x00;
546 pfl
->cfi_table
[0x18] = 0x00;
547 /* Alternate extended table (none) */
548 pfl
->cfi_table
[0x19] = 0x00;
549 pfl
->cfi_table
[0x1A] = 0x00;
551 pfl
->cfi_table
[0x1B] = 0x45;
553 pfl
->cfi_table
[0x1C] = 0x55;
554 /* Vpp min (no Vpp pin) */
555 pfl
->cfi_table
[0x1D] = 0x00;
556 /* Vpp max (no Vpp pin) */
557 pfl
->cfi_table
[0x1E] = 0x00;
559 pfl
->cfi_table
[0x1F] = 0x07;
560 /* Timeout for min size buffer write */
561 pfl
->cfi_table
[0x20] = 0x07;
562 /* Typical timeout for block erase */
563 pfl
->cfi_table
[0x21] = 0x0a;
564 /* Typical timeout for full chip erase (4096 ms) */
565 pfl
->cfi_table
[0x22] = 0x00;
567 pfl
->cfi_table
[0x23] = 0x04;
568 /* Max timeout for buffer write */
569 pfl
->cfi_table
[0x24] = 0x04;
570 /* Max timeout for block erase */
571 pfl
->cfi_table
[0x25] = 0x04;
572 /* Max timeout for chip erase */
573 pfl
->cfi_table
[0x26] = 0x00;
575 pfl
->cfi_table
[0x27] = ctz32(total_len
); // + 1;
576 /* Flash device interface (8 & 16 bits) */
577 pfl
->cfi_table
[0x28] = 0x02;
578 pfl
->cfi_table
[0x29] = 0x00;
579 /* Max number of bytes in multi-bytes write */
580 pfl
->cfi_table
[0x2A] = 0x04;
581 pfl
->cfi_table
[0x2B] = 0x00;
582 /* Number of erase block regions (uniform) */
583 pfl
->cfi_table
[0x2C] = 0x01;
584 /* Erase block region 1 */
585 pfl
->cfi_table
[0x2D] = nb_blocs
- 1;
586 pfl
->cfi_table
[0x2E] = (nb_blocs
- 1) >> 8;
587 pfl
->cfi_table
[0x2F] = sector_len
>> 8;
588 pfl
->cfi_table
[0x30] = sector_len
>> 16;
591 pfl
->cfi_table
[0x31] = 'P';
592 pfl
->cfi_table
[0x32] = 'R';
593 pfl
->cfi_table
[0x33] = 'I';
595 pfl
->cfi_table
[0x34] = '1';
596 pfl
->cfi_table
[0x35] = '1';
598 pfl
->cfi_table
[0x36] = 0x00;
599 pfl
->cfi_table
[0x37] = 0x00;
600 pfl
->cfi_table
[0x38] = 0x00;
601 pfl
->cfi_table
[0x39] = 0x00;
603 pfl
->cfi_table
[0x3a] = 0x00;
605 pfl
->cfi_table
[0x3b] = 0x00;
606 pfl
->cfi_table
[0x3c] = 0x00;