Revision 5f9a5ea1
| b/hw/block/pflash_cfi01.c | ||
|---|---|---|
| 105 | 105 |
DPRINTF("%s: command %02x done\n", __func__, pfl->cmd);
|
| 106 | 106 |
/* Reset flash */ |
| 107 | 107 |
pfl->status ^= 0x80; |
| 108 |
memory_region_rom_device_set_readable(&pfl->mem, true);
|
|
| 108 |
memory_region_rom_device_set_romd(&pfl->mem, true);
|
|
| 109 | 109 |
pfl->wcycle = 0; |
| 110 | 110 |
pfl->cmd = 0; |
| 111 | 111 |
} |
| ... | ... | |
| 281 | 281 |
|
| 282 | 282 |
if (!pfl->wcycle) {
|
| 283 | 283 |
/* Set the device in I/O access mode */ |
| 284 |
memory_region_rom_device_set_readable(&pfl->mem, false);
|
|
| 284 |
memory_region_rom_device_set_romd(&pfl->mem, false);
|
|
| 285 | 285 |
} |
| 286 | 286 |
|
| 287 | 287 |
switch (pfl->wcycle) {
|
| ... | ... | |
| 458 | 458 |
"\n", __func__, offset, pfl->wcycle, pfl->cmd, value); |
| 459 | 459 |
|
| 460 | 460 |
reset_flash: |
| 461 |
memory_region_rom_device_set_readable(&pfl->mem, true);
|
|
| 461 |
memory_region_rom_device_set_romd(&pfl->mem, true);
|
|
| 462 | 462 |
|
| 463 | 463 |
pfl->wcycle = 0; |
| 464 | 464 |
pfl->cmd = 0; |
| b/hw/block/pflash_cfi02.c | ||
|---|---|---|
| 111 | 111 |
|
| 112 | 112 |
static void pflash_register_memory(pflash_t *pfl, int rom_mode) |
| 113 | 113 |
{
|
| 114 |
memory_region_rom_device_set_readable(&pfl->orig_mem, rom_mode);
|
|
| 114 |
memory_region_rom_device_set_romd(&pfl->orig_mem, rom_mode);
|
|
| 115 | 115 |
pfl->rom_mode = rom_mode; |
| 116 | 116 |
} |
| 117 | 117 |
|
| b/include/exec/memory.h | ||
|---|---|---|
| 126 | 126 |
ram_addr_t ram_addr; |
| 127 | 127 |
bool subpage; |
| 128 | 128 |
bool terminates; |
| 129 |
bool readable;
|
|
| 129 |
bool romd_mode;
|
|
| 130 | 130 |
bool ram; |
| 131 | 131 |
bool readonly; /* For RAM regions */ |
| 132 | 132 |
bool enabled; |
| ... | ... | |
| 355 | 355 |
bool memory_region_is_ram(MemoryRegion *mr); |
| 356 | 356 |
|
| 357 | 357 |
/** |
| 358 |
* memory_region_is_romd: check whether a memory region is ROMD
|
|
| 358 |
* memory_region_is_romd: check whether a memory region is in ROMD mode
|
|
| 359 | 359 |
* |
| 360 |
* Returns %true is a memory region is ROMD and currently set to allow
|
|
| 360 |
* Returns %true if a memory region is a ROM device and currently set to allow
|
|
| 361 | 361 |
* direct reads. |
| 362 | 362 |
* |
| 363 | 363 |
* @mr: the memory region being queried |
| 364 | 364 |
*/ |
| 365 | 365 |
static inline bool memory_region_is_romd(MemoryRegion *mr) |
| 366 | 366 |
{
|
| 367 |
return mr->rom_device && mr->readable;
|
|
| 367 |
return mr->rom_device && mr->romd_mode;
|
|
| 368 | 368 |
} |
| 369 | 369 |
|
| 370 | 370 |
/** |
| ... | ... | |
| 502 | 502 |
void memory_region_set_readonly(MemoryRegion *mr, bool readonly); |
| 503 | 503 |
|
| 504 | 504 |
/** |
| 505 |
* memory_region_rom_device_set_readable: enable/disable ROM readability
|
|
| 505 |
* memory_region_rom_device_set_romd: enable/disable ROMD mode
|
|
| 506 | 506 |
* |
| 507 | 507 |
* Allows a ROM device (initialized with memory_region_init_rom_device() to |
| 508 |
* to be marked as readable (default) or not readable. When it is readable, |
|
| 509 |
* the device is mapped to guest memory. When not readable, reads are |
|
| 510 |
* forwarded to the #MemoryRegion.read function. |
|
| 508 |
* set to ROMD mode (default) or MMIO mode. When it is in ROMD mode, the |
|
| 509 |
* device is mapped to guest memory and satisfies read access directly. |
|
| 510 |
* When in MMIO mode, reads are forwarded to the #MemoryRegion.read function. |
|
| 511 |
* Writes are always handled by the #MemoryRegion.write function. |
|
| 511 | 512 |
* |
| 512 | 513 |
* @mr: the memory region to be updated |
| 513 |
* @readable: whether reads are satisified directly (%true) or via callbacks |
|
| 514 |
* (%false) |
|
| 514 |
* @romd_mode: %true to put the region into ROMD mode |
|
| 515 | 515 |
*/ |
| 516 |
void memory_region_rom_device_set_readable(MemoryRegion *mr, bool readable);
|
|
| 516 |
void memory_region_rom_device_set_romd(MemoryRegion *mr, bool romd_mode);
|
|
| 517 | 517 |
|
| 518 | 518 |
/** |
| 519 | 519 |
* memory_region_set_coalescing: Enable memory coalescing for the region. |
| b/memory.c | ||
|---|---|---|
| 213 | 213 |
hwaddr offset_in_region; |
| 214 | 214 |
AddrRange addr; |
| 215 | 215 |
uint8_t dirty_log_mask; |
| 216 |
bool readable;
|
|
| 216 |
bool romd_mode;
|
|
| 217 | 217 |
bool readonly; |
| 218 | 218 |
}; |
| 219 | 219 |
|
| ... | ... | |
| 236 | 236 |
return a->mr == b->mr |
| 237 | 237 |
&& addrrange_equal(a->addr, b->addr) |
| 238 | 238 |
&& a->offset_in_region == b->offset_in_region |
| 239 |
&& a->readable == b->readable
|
|
| 239 |
&& a->romd_mode == b->romd_mode
|
|
| 240 | 240 |
&& a->readonly == b->readonly; |
| 241 | 241 |
} |
| 242 | 242 |
|
| ... | ... | |
| 276 | 276 |
r1->addr.size), |
| 277 | 277 |
int128_make64(r2->offset_in_region)) |
| 278 | 278 |
&& r1->dirty_log_mask == r2->dirty_log_mask |
| 279 |
&& r1->readable == r2->readable
|
|
| 279 |
&& r1->romd_mode == r2->romd_mode
|
|
| 280 | 280 |
&& r1->readonly == r2->readonly; |
| 281 | 281 |
} |
| 282 | 282 |
|
| ... | ... | |
| 532 | 532 |
fr.offset_in_region = offset_in_region; |
| 533 | 533 |
fr.addr = addrrange_make(base, now); |
| 534 | 534 |
fr.dirty_log_mask = mr->dirty_log_mask; |
| 535 |
fr.readable = mr->readable;
|
|
| 535 |
fr.romd_mode = mr->romd_mode;
|
|
| 536 | 536 |
fr.readonly = readonly; |
| 537 | 537 |
flatview_insert(view, i, &fr); |
| 538 | 538 |
++i; |
| ... | ... | |
| 552 | 552 |
fr.offset_in_region = offset_in_region; |
| 553 | 553 |
fr.addr = addrrange_make(base, remain); |
| 554 | 554 |
fr.dirty_log_mask = mr->dirty_log_mask; |
| 555 |
fr.readable = mr->readable;
|
|
| 555 |
fr.romd_mode = mr->romd_mode;
|
|
| 556 | 556 |
fr.readonly = readonly; |
| 557 | 557 |
flatview_insert(view, i, &fr); |
| 558 | 558 |
} |
| ... | ... | |
| 801 | 801 |
mr->enabled = true; |
| 802 | 802 |
mr->terminates = false; |
| 803 | 803 |
mr->ram = false; |
| 804 |
mr->readable = true;
|
|
| 804 |
mr->romd_mode = true;
|
|
| 805 | 805 |
mr->readonly = false; |
| 806 | 806 |
mr->rom_device = false; |
| 807 | 807 |
mr->destructor = memory_region_destructor_none; |
| ... | ... | |
| 1121 | 1121 |
} |
| 1122 | 1122 |
} |
| 1123 | 1123 |
|
| 1124 |
void memory_region_rom_device_set_readable(MemoryRegion *mr, bool readable)
|
|
| 1124 |
void memory_region_rom_device_set_romd(MemoryRegion *mr, bool romd_mode)
|
|
| 1125 | 1125 |
{
|
| 1126 |
if (mr->readable != readable) {
|
|
| 1126 |
if (mr->romd_mode != romd_mode) {
|
|
| 1127 | 1127 |
memory_region_transaction_begin(); |
| 1128 |
mr->readable = readable;
|
|
| 1128 |
mr->romd_mode = romd_mode;
|
|
| 1129 | 1129 |
memory_region_update_pending |= mr->enabled; |
| 1130 | 1130 |
memory_region_transaction_commit(); |
| 1131 | 1131 |
} |
| ... | ... | |
| 1659 | 1659 |
base + mr->addr |
| 1660 | 1660 |
+ (hwaddr)int128_get64(mr->size) - 1, |
| 1661 | 1661 |
mr->priority, |
| 1662 |
mr->readable ? 'R' : '-',
|
|
| 1663 |
!mr->readonly && !(mr->rom_device && mr->readable) ? 'W'
|
|
| 1664 |
: '-', |
|
| 1662 |
mr->romd_mode ? 'R' : '-',
|
|
| 1663 |
!mr->readonly && !(mr->rom_device && mr->romd_mode) ? 'W'
|
|
| 1664 |
: '-',
|
|
| 1665 | 1665 |
mr->name, |
| 1666 | 1666 |
mr->alias->name, |
| 1667 | 1667 |
mr->alias_offset, |
| ... | ... | |
| 1674 | 1674 |
base + mr->addr |
| 1675 | 1675 |
+ (hwaddr)int128_get64(mr->size) - 1, |
| 1676 | 1676 |
mr->priority, |
| 1677 |
mr->readable ? 'R' : '-',
|
|
| 1678 |
!mr->readonly && !(mr->rom_device && mr->readable) ? 'W'
|
|
| 1679 |
: '-', |
|
| 1677 |
mr->romd_mode ? 'R' : '-',
|
|
| 1678 |
!mr->readonly && !(mr->rom_device && mr->romd_mode) ? 'W'
|
|
| 1679 |
: '-',
|
|
| 1680 | 1680 |
mr->name); |
| 1681 | 1681 |
} |
| 1682 | 1682 |
|
Also available in: Unified diff