claunia/86Box
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

Another round of sonarlint work

Browse Source
This commit is contained in:
Jasmine Iwanek
2023-06-28 13:46:28 -04:00
parent b750471e5c
commit 1116aadb6f
135 changed files with 2425 additions and 1355 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/mem/catalyst_flash.c
View File

@@ -55,19 +55,22 @@ enum {
};
typedef struct flash_t {
uint8_t command, pad,
pad0, pad1,
*array;
uint8_t command;
uint8_t pad;
uint8_t pad0;
uint8_t pad1;
uint8_t *array;
mem_mapping_t mapping, mapping_h[2];
mem_mapping_t mapping;
mem_mapping_t mapping_h[2];
} flash_t;
static char flash_path[1024];
static uint8_t
flash_read(uint32_t addr, void *p)
flash_read(uint32_t addr, void *priv)
{
flash_t *dev = (flash_t *) p;
flash_t *dev = (flash_t *) priv;
uint8_t ret = 0xff;
addr &= biosmask;
@@ -86,6 +89,9 @@ flash_read(uint32_t addr, void *p)
else if (addr == 0x00001)
ret = 0xB4; /* 28F010 */
break;
default:
break;
}
return ret;
@@ -141,13 +147,15 @@ flash_write(uint32_t addr, uint8_t val, void *p)
}
static void
flash_writew(uint32_t addr, uint16_t val, void *p)
flash_writew(UNUSED(uint32_t addr), UNUSED(uint16_t val), UNUSED(void *priv))
{
//
}
static void
flash_writel(uint32_t addr, uint32_t val, void *p)
flash_writel(UNUSED(uint32_t addr), UNUSED(uint32_t val), UNUSED(void *priv))
{
//
}
static void
@@ -179,7 +187,7 @@ catalyst_flash_reset(void *priv)
}
static void *
catalyst_flash_init(const device_t *info)
catalyst_flash_init(UNUSED(const device_t *info))
{
FILE *f;
flash_t *dev;

21
src/mem/i2c_eeprom.c
View File

@@ -23,13 +23,18 @@
#include <wchar.h>
#include <86box/86box.h>
#include <86box/i2c.h>
#include <86box/plat_unused.h>
typedef struct {
typedef struct i2c_eeprom_t {
void *i2c;
uint8_t addr, *data, writable;
uint8_t addr;
uint8_t *data;
uint8_t writable;
uint32_t addr_mask, addr_register;
uint8_t addr_len, addr_pos;
uint32_t addr_mask;
uint32_t addr_register;
uint8_t addr_len;
uint8_t addr_pos;
} i2c_eeprom_t;
#ifdef ENABLE_I2C_EEPROM_LOG
@@ -51,7 +56,7 @@ i2c_eeprom_log(const char *fmt, ...)
#endif
static uint8_t
i2c_eeprom_start(void *bus, uint8_t addr, uint8_t read, void *priv)
i2c_eeprom_start(UNUSED(void *bus), uint8_t addr, uint8_t read, void *priv)
{
i2c_eeprom_t *dev = (i2c_eeprom_t *) priv;
@@ -66,7 +71,7 @@ i2c_eeprom_start(void *bus, uint8_t addr, uint8_t read, void *priv)
}
static uint8_t
i2c_eeprom_read(void *bus, uint8_t addr, void *priv)
i2c_eeprom_read(UNUSED(void *bus), UNUSED(uint8_t addr), void *priv)
{
i2c_eeprom_t *dev = (i2c_eeprom_t *) priv;
uint8_t ret = dev->data[dev->addr_register];
@@ -79,7 +84,7 @@ i2c_eeprom_read(void *bus, uint8_t addr, void *priv)
}
static uint8_t
i2c_eeprom_write(void *bus, uint8_t addr, uint8_t data, void *priv)
i2c_eeprom_write(UNUSED(void *bus), uint8_t addr, uint8_t data, void *priv)
{
i2c_eeprom_t *dev = (i2c_eeprom_t *) priv;
@@ -104,7 +109,7 @@ i2c_eeprom_write(void *bus, uint8_t addr, uint8_t data, void *priv)
}
static void
i2c_eeprom_stop(void *bus, uint8_t addr, void *priv)
i2c_eeprom_stop(UNUSED(void *bus), UNUSED(uint8_t addr), void *priv)
{
i2c_eeprom_t *dev = (i2c_eeprom_t *) priv;

62
src/mem/intel_flash.c
View File

@@ -58,25 +58,30 @@ enum {
};
typedef struct flash_t {
uint8_t command, status,
pad, flags,
*array;
uint8_t command;
uint8_t status;
uint8_t pad;
uint8_t flags;
uint8_t *array;
uint16_t flash_id, pad16;
uint16_t flash_id;
uint16_t pad16;
uint32_t program_addr,
block_start[BLOCKS_NUM], block_end[BLOCKS_NUM],
block_len[BLOCKS_NUM];
uint32_t program_addr;
uint32_t block_start[BLOCKS_NUM];
uint32_t block_end[BLOCKS_NUM];
uint32_t block_len[BLOCKS_NUM];
mem_mapping_t mapping[4], mapping_h[16];
mem_mapping_t mapping[4];
mem_mapping_t mapping_h[16];
} flash_t;
static char flash_path[1024];
static uint8_t
flash_read(uint32_t addr, void *p)
flash_read(uint32_t addr, void *priv)
{
flash_t *dev = (flash_t *) p;
flash_t *dev = (flash_t *) priv;
uint8_t ret = 0xff;
if (dev->flags & FLAG_INV_A16)
@@ -84,8 +89,8 @@ flash_read(uint32_t addr, void *p)
addr &= biosmask;
switch (dev->command) {
case CMD_READ_ARRAY:
default:
case CMD_READ_ARRAY:
ret = dev->array[addr];
break;
@@ -105,9 +110,9 @@ flash_read(uint32_t addr, void *p)
}
static uint16_t
flash_readw(uint32_t addr, void *p)
flash_readw(uint32_t addr, void *priv)
{
flash_t *dev = (flash_t *) p;
flash_t *dev = (flash_t *) priv;
uint16_t *q;
uint16_t ret = 0xffff;
@@ -123,8 +128,8 @@ flash_readw(uint32_t addr, void *p)
if (dev->flags & FLAG_WORD)
switch (dev->command) {
case CMD_READ_ARRAY:
default:
case CMD_READ_ARRAY:
break;
case CMD_IID:
@@ -143,9 +148,9 @@ flash_readw(uint32_t addr, void *p)
}
static uint32_t
flash_readl(uint32_t addr, void *p)
flash_readl(uint32_t addr, void *priv)
{
flash_t *dev = (flash_t *) p;
flash_t *dev = (flash_t *) priv;
uint32_t *q;
if (dev->flags & FLAG_INV_A16)
@@ -158,10 +163,9 @@ flash_readl(uint32_t addr, void *p)
}
static void
flash_write(uint32_t addr, uint8_t val, void *p)
flash_write(uint32_t addr, uint8_t val, void *priv)
{
flash_t *dev = (flash_t *) p;
int i;
flash_t *dev = (flash_t *) priv;
uint32_t bb_mask = biosmask & 0xffffe000;
if (biosmask == 0x7ffff)
bb_mask &= 0xffff8000;
@@ -175,7 +179,7 @@ flash_write(uint32_t addr, uint8_t val, void *p)
switch (dev->command) {
case CMD_ERASE_SETUP:
if (val == CMD_ERASE_CONFIRM) {
for (i = 0; i < 6; i++) {
for (uint8_t i = 0; i < 6; i++) {
if ((i == dev->program_addr) && (addr >= dev->block_start[i]) && (addr <= dev->block_end[i]))
memset(&(dev->array[dev->block_start[i]]), 0xff, dev->block_len[i]);
}
@@ -200,7 +204,7 @@ flash_write(uint32_t addr, uint8_t val, void *p)
dev->status = 0;
break;
case CMD_ERASE_SETUP:
for (i = 0; i < 7; i++) {
for (uint8_t i = 0; i < 7; i++) {
if ((addr >= dev->block_start[i]) && (addr <= dev->block_end[i]))
dev->program_addr = i;
}
@@ -209,6 +213,9 @@ flash_write(uint32_t addr, uint8_t val, void *p)
case CMD_PROGRAM_SETUP_ALT:
dev->program_addr = addr;
break;
default:
break;
}
}
}
@@ -266,16 +273,19 @@ flash_writew(uint32_t addr, uint16_t val, void *p)
case CMD_PROGRAM_SETUP_ALT:
dev->program_addr = addr;
break;
default:
break;
}
}
}
static void
flash_writel(uint32_t addr, uint32_t val, void *p)
flash_writel(UNUSED(uint32_t addr), UNUSED(uint32_t val), UNUSED(void *priv))
{
#if 0
flash_writew(addr, val & 0xffff, p);
flash_writew(addr + 2, (val >> 16) & 0xffff, p);
flash_writew(addr, val & 0xffff, priv);
flash_writew(addr + 2, (val >> 16) & 0xffff, priv);
#endif
}
@@ -522,10 +532,10 @@ intel_flash_init(const device_t *info)
}
static void
intel_flash_close(void *p)
intel_flash_close(void *priv)
{
FILE *f;
flash_t *dev = (flash_t *) p;
flash_t *dev = (flash_t *) priv;
f = nvr_fopen(flash_path, "wb");
fwrite(&(dev->array[dev->block_start[BLOCK_MAIN1]]), dev->block_len[BLOCK_MAIN1], 1, f);

194
src/mem/mem.c
View File

@@ -1776,7 +1776,7 @@ mem_write_phys(void *src, uint32_t addr, int transfer_size)
}
uint8_t
mem_read_ram(uint32_t addr, void *priv)
mem_read_ram(uint32_t addr, UNUSED(void *priv))
{
#ifdef ENABLE_MEM_LOG
if ((addr >= 0xa0000) && (addr <= 0xbffff))
@@ -1790,7 +1790,7 @@ mem_read_ram(uint32_t addr, void *priv)
}
uint16_t
mem_read_ramw(uint32_t addr, void *priv)
mem_read_ramw(uint32_t addr, UNUSED(void *priv))
{
#ifdef ENABLE_MEM_LOG
if ((addr >= 0xa0000) && (addr <= 0xbffff))
@@ -1804,7 +1804,7 @@ mem_read_ramw(uint32_t addr, void *priv)
}
uint32_t
mem_read_raml(uint32_t addr, void *priv)
mem_read_raml(uint32_t addr, UNUSED(void *priv))
{
#ifdef ENABLE_MEM_LOG
if ((addr >= 0xa0000) && (addr <= 0xbffff))
@@ -1818,7 +1818,7 @@ mem_read_raml(uint32_t addr, void *priv)
}
uint8_t
mem_read_ram_2gb(uint32_t addr, void *priv)
mem_read_ram_2gb(uint32_t addr, UNUSED(void *priv))
{
#ifdef ENABLE_MEM_LOG
if ((addr >= 0xa0000) && (addr <= 0xbffff))
@@ -1831,7 +1831,7 @@ mem_read_ram_2gb(uint32_t addr, void *priv)
}
uint16_t
mem_read_ram_2gbw(uint32_t addr, void *priv)
mem_read_ram_2gbw(uint32_t addr, UNUSED(void *priv))
{
#ifdef ENABLE_MEM_LOG
if ((addr >= 0xa0000) && (addr <= 0xbffff))
@@ -1844,7 +1844,7 @@ mem_read_ram_2gbw(uint32_t addr, void *priv)
}
uint32_t
mem_read_ram_2gbl(uint32_t addr, void *priv)
mem_read_ram_2gbl(uint32_t addr, UNUSED(void *priv))
{
#ifdef ENABLE_MEM_LOG
if ((addr >= 0xa0000) && (addr <= 0xbffff))
@@ -1858,71 +1858,71 @@ mem_read_ram_2gbl(uint32_t addr, void *priv)
#ifdef USE_NEW_DYNAREC
static inline int
page_index(page_t *p)
page_index(page_t *page)
{
return ((uintptr_t) p - (uintptr_t) pages) / sizeof(page_t);
return ((uintptr_t) page - (uintptr_t) pages) / sizeof(page_t);
}
void
page_add_to_evict_list(page_t *p)
page_add_to_evict_list(page_t *page)
{
pages[purgable_page_list_head].evict_prev = page_index(p);
p->evict_next = purgable_page_list_head;
p->evict_prev = 0;
pages[purgable_page_list_head].evict_prev = page_index(page);
page->evict_next = purgable_page_list_head;
page->evict_prev = 0;
purgable_page_list_head = pages[purgable_page_list_head].evict_prev;
purgeable_page_count++;
}
void
page_remove_from_evict_list(page_t *p)
page_remove_from_evict_list(page_t *page)
{
if (!page_in_evict_list(p))
if (!page_in_evict_list(page))
fatal("page_remove_from_evict_list: not in evict list!\n");
if (p->evict_prev)
pages[p->evict_prev].evict_next = p->evict_next;
if (page->evict_prev)
pages[page->evict_prev].evict_next = page->evict_next;
else
purgable_page_list_head = p->evict_next;
if (p->evict_next)
pages[p->evict_next].evict_prev = p->evict_prev;
p->evict_prev = EVICT_NOT_IN_LIST;
purgable_page_list_head = page->evict_next;
if (page->evict_next)
pages[page->evict_next].evict_prev = page->evict_prev;
page->evict_prev = EVICT_NOT_IN_LIST;
purgeable_page_count--;
}
void
mem_write_ramb_page(uint32_t addr, uint8_t val, page_t *p)
mem_write_ramb_page(uint32_t addr, uint8_t val, page_t *page)
{
if (p == NULL)
if (page == NULL)
return;
# ifdef USE_DYNAREC
if ((p->mem == NULL) || (p->mem == page_ff) || (val != p->mem[addr & 0xfff]) || codegen_in_recompile) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != page->mem[addr & 0xfff]) || codegen_in_recompile) {
# else
if ((p->mem == NULL) || (p->mem == page_ff) || (val != p->mem[addr & 0xfff])) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != page->mem[addr & 0xfff])) {
# endif
uint64_t mask = (uint64_t) 1 << ((addr >> PAGE_MASK_SHIFT) & PAGE_MASK_MASK);
int byte_offset = (addr >> PAGE_BYTE_MASK_SHIFT) & PAGE_BYTE_MASK_OFFSET_MASK;
uint64_t byte_mask = (uint64_t) 1 << (addr & PAGE_BYTE_MASK_MASK);
p->mem[addr & 0xfff] = val;
p->dirty_mask |= mask;
if ((p->code_present_mask & mask) && !page_in_evict_list(p))
page_add_to_evict_list(p);
p->byte_dirty_mask[byte_offset] |= byte_mask;
if ((p->byte_code_present_mask[byte_offset] & byte_mask) && !page_in_evict_list(p))
page_add_to_evict_list(p);
page->mem[addr & 0xfff] = val;
page->dirty_mask |= mask;
if ((page->code_present_mask & mask) && !page_in_evict_list(page))
page_add_to_evict_list(page);
page->byte_dirty_mask[byte_offset] |= byte_mask;
if ((page->byte_code_present_mask[byte_offset] & byte_mask) && !page_in_evict_list(page))
page_add_to_evict_list(page);
}
}
void
mem_write_ramw_page(uint32_t addr, uint16_t val, page_t *p)
mem_write_ramw_page(uint32_t addr, uint16_t val, page_t *page)
{
if (p == NULL)
if (page == NULL)
return;
# ifdef USE_DYNAREC
if ((p->mem == NULL) || (p->mem == page_ff) || (val != *(uint16_t *) &p->mem[addr & 0xfff]) || codegen_in_recompile) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != *(uint16_t *) &page->mem[addr & 0xfff]) || codegen_in_recompile) {
# else
if ((p->mem == NULL) || (p->mem == page_ff) || (val != *(uint16_t *) &p->mem[addr & 0xfff])) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != *(uint16_t *) &page->mem[addr & 0xfff])) {
# endif
uint64_t mask = (uint64_t) 1 << ((addr >> PAGE_MASK_SHIFT) & PAGE_MASK_MASK);
int byte_offset = (addr >> PAGE_BYTE_MASK_SHIFT) & PAGE_BYTE_MASK_OFFSET_MASK;
@@ -1930,34 +1930,34 @@ mem_write_ramw_page(uint32_t addr, uint16_t val, page_t *p)
if ((addr & 0xf) == 0xf)
mask |= (mask << 1);
*(uint16_t *) &p->mem[addr & 0xfff] = val;
p->dirty_mask |= mask;
if ((p->code_present_mask & mask) && !page_in_evict_list(p))
page_add_to_evict_list(p);
*(uint16_t *) &page->mem[addr & 0xfff] = val;
page->dirty_mask |= mask;
if ((page->code_present_mask & mask) && !page_in_evict_list(page))
page_add_to_evict_list(page);
if ((addr & PAGE_BYTE_MASK_MASK) == PAGE_BYTE_MASK_MASK) {
p->byte_dirty_mask[byte_offset + 1] |= 1;
if ((p->byte_code_present_mask[byte_offset + 1] & 1) && !page_in_evict_list(p))
page_add_to_evict_list(p);
page->byte_dirty_mask[byte_offset + 1] |= 1;
if ((page->byte_code_present_mask[byte_offset + 1] & 1) && !page_in_evict_list(page))
page_add_to_evict_list(page);
} else
byte_mask |= (byte_mask << 1);
p->byte_dirty_mask[byte_offset] |= byte_mask;
page->byte_dirty_mask[byte_offset] |= byte_mask;
if ((p->byte_code_present_mask[byte_offset] & byte_mask) && !page_in_evict_list(p))
page_add_to_evict_list(p);
if ((page->byte_code_present_mask[byte_offset] & byte_mask) && !page_in_evict_list(page))
page_add_to_evict_list(page);
}
}
void
mem_write_raml_page(uint32_t addr, uint32_t val, page_t *p)
mem_write_raml_page(uint32_t addr, uint32_t val, page_t *page)
{
if (p == NULL)
if (page == NULL)
return;
# ifdef USE_DYNAREC
if ((p->mem == NULL) || (p->mem == page_ff) || (val != *(uint32_t *) &p->mem[addr & 0xfff]) || codegen_in_recompile) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != *(uint32_t *) &page->mem[addr & 0xfff]) || codegen_in_recompile) {
# else
if ((p->mem == NULL) || (p->mem == page_ff) || (val != *(uint32_t *) &p->mem[addr & 0xfff])) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != *(uint32_t *) &page->mem[addr & 0xfff])) {
# endif
uint64_t mask = (uint64_t) 1 << ((addr >> PAGE_MASK_SHIFT) & PAGE_MASK_MASK);
int byte_offset = (addr >> PAGE_BYTE_MASK_SHIFT) & PAGE_BYTE_MASK_OFFSET_MASK;
@@ -1965,79 +1965,79 @@ mem_write_raml_page(uint32_t addr, uint32_t val, page_t *p)
if ((addr & 0xf) >= 0xd)
mask |= (mask << 1);
*(uint32_t *) &p->mem[addr & 0xfff] = val;
p->dirty_mask |= mask;
p->byte_dirty_mask[byte_offset] |= byte_mask;
if (!page_in_evict_list(p) && ((p->code_present_mask & mask) || (p->byte_code_present_mask[byte_offset] & byte_mask)))
page_add_to_evict_list(p);
*(uint32_t *) &page->mem[addr & 0xfff] = val;
page->dirty_mask |= mask;
page->byte_dirty_mask[byte_offset] |= byte_mask;
if (!page_in_evict_list(page) && ((page->code_present_mask & mask) || (page->byte_code_present_mask[byte_offset] & byte_mask)))
page_add_to_evict_list(page);
if ((addr & PAGE_BYTE_MASK_MASK) > (PAGE_BYTE_MASK_MASK - 3)) {
uint32_t byte_mask_2 = 0xf >> (4 - (addr & 3));
p->byte_dirty_mask[byte_offset + 1] |= byte_mask_2;
if ((p->byte_code_present_mask[byte_offset + 1] & byte_mask_2) && !page_in_evict_list(p))
page_add_to_evict_list(p);
page->byte_dirty_mask[byte_offset + 1] |= byte_mask_2;
if ((page->byte_code_present_mask[byte_offset + 1] & byte_mask_2) && !page_in_evict_list(page))
page_add_to_evict_list(page);
}
}
}
#else
void
mem_write_ramb_page(uint32_t addr, uint8_t val, page_t *p)
mem_write_ramb_page(uint32_t addr, uint8_t val, page_t *page)
{
if (p == NULL)
if (page == NULL)
return;
# ifdef USE_DYNAREC
if ((p->mem == NULL) || (p->mem == page_ff) || (val != p->mem[addr & 0xfff]) || codegen_in_recompile) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != page->mem[addr & 0xfff]) || codegen_in_recompile) {
# else
if ((p->mem == NULL) || (p->mem == page_ff) || (val != p->mem[addr & 0xfff])) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != page->mem[addr & 0xfff])) {
# endif
uint64_t mask = (uint64_t) 1 << ((addr >> PAGE_MASK_SHIFT) & PAGE_MASK_MASK);
p->dirty_mask[(addr >> PAGE_MASK_INDEX_SHIFT) & PAGE_MASK_INDEX_MASK] |= mask;
p->mem[addr & 0xfff] = val;
page->dirty_mask[(addr >> PAGE_MASK_INDEX_SHIFT) & PAGE_MASK_INDEX_MASK] |= mask;
page->mem[addr & 0xfff] = val;
}
}
void
mem_write_ramw_page(uint32_t addr, uint16_t val, page_t *p)
mem_write_ramw_page(uint32_t addr, uint16_t val, page_t *page)
{
if (p == NULL)
if (page == NULL)
return;
# ifdef USE_DYNAREC
if ((p->mem == NULL) || (p->mem == page_ff) || (val != *(uint16_t *) &p->mem[addr & 0xfff]) || codegen_in_recompile) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != *(uint16_t *) &page->mem[addr & 0xfff]) || codegen_in_recompile) {
# else
if ((p->mem == NULL) || (p->mem == page_ff) || (val != *(uint16_t *) &p->mem[addr & 0xfff])) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != *(uint16_t *) &page->mem[addr & 0xfff])) {
# endif
uint64_t mask = (uint64_t) 1 << ((addr >> PAGE_MASK_SHIFT) & PAGE_MASK_MASK);
if ((addr & 0xf) == 0xf)
mask |= (mask << 1);
p->dirty_mask[(addr >> PAGE_MASK_INDEX_SHIFT) & PAGE_MASK_INDEX_MASK] |= mask;
*(uint16_t *) &p->mem[addr & 0xfff] = val;
page->dirty_mask[(addr >> PAGE_MASK_INDEX_SHIFT) & PAGE_MASK_INDEX_MASK] |= mask;
*(uint16_t *) &page->mem[addr & 0xfff] = val;
}
}
void
mem_write_raml_page(uint32_t addr, uint32_t val, page_t *p)
mem_write_raml_page(uint32_t addr, uint32_t val, page_t *page)
{
if (p == NULL)
if (page == NULL)
return;
# ifdef USE_DYNAREC
if ((p->mem == NULL) || (p->mem == page_ff) || (val != *(uint32_t *) &p->mem[addr & 0xfff]) || codegen_in_recompile) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != *(uint32_t *) &page->mem[addr & 0xfff]) || codegen_in_recompile) {
# else
if ((p->mem == NULL) || (p->mem == page_ff) || (val != *(uint32_t *) &p->mem[addr & 0xfff])) {
if ((page->mem == NULL) || (page->mem == page_ff) || (val != *(uint32_t *) &page->mem[addr & 0xfff])) {
# endif
uint64_t mask = (uint64_t) 1 << ((addr >> PAGE_MASK_SHIFT) & PAGE_MASK_MASK);
if ((addr & 0xf) >= 0xd)
mask |= (mask << 1);
p->dirty_mask[(addr >> PAGE_MASK_INDEX_SHIFT) & PAGE_MASK_INDEX_MASK] |= mask;
*(uint32_t *) &p->mem[addr & 0xfff] = val;
page->dirty_mask[(addr >> PAGE_MASK_INDEX_SHIFT) & PAGE_MASK_INDEX_MASK] |= mask;
*(uint32_t *) &page->mem[addr & 0xfff] = val;
}
}
#endif
void
mem_write_ram(uint32_t addr, uint8_t val, void *priv)
mem_write_ram(uint32_t addr, uint8_t val, UNUSED(void *priv))
{
#ifdef ENABLE_MEM_LOG
if ((addr >= 0xa0000) && (addr <= 0xbffff))
@@ -2065,7 +2065,7 @@ mem_write_ramw(uint32_t addr, uint16_t val, void *priv)
}
void
mem_write_raml(uint32_t addr, uint32_t val, void *priv)
mem_write_raml(uint32_t addr, uint32_t val, UNUSED(void *priv))
{
#ifdef ENABLE_MEM_LOG
if ((addr >= 0xa0000) && (addr <= 0xbffff))
@@ -2079,7 +2079,7 @@ mem_write_raml(uint32_t addr, uint32_t val, void *priv)
}
static uint8_t
mem_read_remapped(uint32_t addr, void *priv)
mem_read_remapped(uint32_t addr, UNUSED(void *priv))
{
addr = 0xA0000 + (addr - remap_start_addr);
if (is286)
@@ -2088,7 +2088,7 @@ mem_read_remapped(uint32_t addr, void *priv)
}
static uint16_t
mem_read_remappedw(uint32_t addr, void *priv)
mem_read_remappedw(uint32_t addr, UNUSED(void *priv))
{
addr = 0xA0000 + (addr - remap_start_addr);
if (is286)
@@ -2097,7 +2097,7 @@ mem_read_remappedw(uint32_t addr, void *priv)
}
static uint32_t
mem_read_remappedl(uint32_t addr, void *priv)
mem_read_remappedl(uint32_t addr, UNUSED(void *priv))
{
addr = 0xA0000 + (addr - remap_start_addr);
if (is286)
@@ -2106,7 +2106,7 @@ mem_read_remappedl(uint32_t addr, void *priv)
}
static uint8_t
mem_read_remapped2(uint32_t addr, void *priv)
mem_read_remapped2(uint32_t addr, UNUSED(void *priv))
{
addr = 0xD0000 + (addr - remap_start_addr2);
if (is286)
@@ -2115,7 +2115,7 @@ mem_read_remapped2(uint32_t addr, void *priv)
}
static uint16_t
mem_read_remappedw2(uint32_t addr, void *priv)
mem_read_remappedw2(uint32_t addr, UNUSED(void *priv))
{
addr = 0xD0000 + (addr - remap_start_addr2);
if (is286)
@@ -2124,7 +2124,7 @@ mem_read_remappedw2(uint32_t addr, void *priv)
}
static uint32_t
mem_read_remappedl2(uint32_t addr, void *priv)
mem_read_remappedl2(uint32_t addr, UNUSED(void *priv))
{
addr = 0xD0000 + (addr - remap_start_addr2);
if (is286)
@@ -2133,7 +2133,7 @@ mem_read_remappedl2(uint32_t addr, void *priv)
}
static void
mem_write_remapped(uint32_t addr, uint8_t val, void *priv)
mem_write_remapped(uint32_t addr, uint8_t val, UNUSED(void *priv))
{
uint32_t oldaddr = addr;
addr = 0xA0000 + (addr - remap_start_addr);
@@ -2157,7 +2157,7 @@ mem_write_remappedw(uint32_t addr, uint16_t val, void *priv)
}
static void
mem_write_remappedl(uint32_t addr, uint32_t val, void *priv)
mem_write_remappedl(uint32_t addr, uint32_t val, UNUSED(void *priv))
{
uint32_t oldaddr = addr;
addr = 0xA0000 + (addr - remap_start_addr);
@@ -2169,7 +2169,7 @@ mem_write_remappedl(uint32_t addr, uint32_t val, void *priv)
}
static void
mem_write_remapped2(uint32_t addr, uint8_t val, void *priv)
mem_write_remapped2(uint32_t addr, uint8_t val, UNUSED(void *priv))
{
uint32_t oldaddr = addr;
addr = 0xD0000 + (addr - remap_start_addr2);
@@ -2193,7 +2193,7 @@ mem_write_remappedw2(uint32_t addr, uint16_t val, void *priv)
}
static void
mem_write_remappedl2(uint32_t addr, uint32_t val, void *priv)
mem_write_remappedl2(uint32_t addr, uint32_t val, UNUSED(void *priv))
{
uint32_t oldaddr = addr;
addr = 0xD0000 + (addr - remap_start_addr2);
@@ -2208,7 +2208,7 @@ void
mem_invalidate_range(uint32_t start_addr, uint32_t end_addr)
{
#ifdef USE_NEW_DYNAREC
page_t *p;
page_t *page;
start_addr &= ~PAGE_MASK_MASK;
end_addr = (end_addr + PAGE_MASK_MASK) & ~PAGE_MASK_MASK;
@@ -2217,15 +2217,15 @@ mem_invalidate_range(uint32_t start_addr, uint32_t end_addr)
if ((start_addr >> 12) >= pages_sz)
continue;
p = &pages[start_addr >> 12];
if (p) {
p->dirty_mask = 0xffffffffffffffffULL;
page = &pages[start_addr >> 12];
if (page) {
page->dirty_mask = 0xffffffffffffffffULL;
if ((p->mem != page_ff) && p->byte_dirty_mask)
memset(p->byte_dirty_mask, 0xff, 64 * sizeof(uint64_t));
if ((page->mem != page_ff) && page->byte_dirty_mask)
memset(page->byte_dirty_mask, 0xff, 64 * sizeof(uint64_t));
if (!page_in_evict_list(p))
page_add_to_evict_list(p);
if (!page_in_evict_list(page))
page_add_to_evict_list(page);
}
}
#else
@@ -2598,7 +2598,9 @@ mem_a20_init(void)
if (is6117)
rammask |= 0x03000000;
flushmmucache();
// mem_a20_state = mem_a20_key | mem_a20_alt;
#if 0
mem_a20_state = mem_a20_key | mem_a20_alt;
#endif
} else {
rammask = 0xfffff;
flushmmucache();

8
src/mem/rom.c
View File

@@ -384,7 +384,7 @@ rom_reset(uint32_t addr, int sz)
}
uint8_t
bios_read(uint32_t addr, void *priv)
bios_read(uint32_t addr, UNUSED(void *priv))
{
uint8_t ret = 0xff;
@@ -397,7 +397,7 @@ bios_read(uint32_t addr, void *priv)
}
uint16_t
bios_readw(uint32_t addr, void *priv)
bios_readw(uint32_t addr, UNUSED(void *priv))
{
uint16_t ret = 0xffff;
@@ -410,7 +410,7 @@ bios_readw(uint32_t addr, void *priv)
}
uint32_t
bios_readl(uint32_t addr, void *priv)
bios_readl(uint32_t addr, UNUSED(void *priv))
{
uint32_t ret = 0xffffffff;
@@ -524,7 +524,7 @@ bios_load(const char *fn1, const char *fn2, uint32_t addr, int sz, int off, int
}
int
bios_load_linear_combined(const char *fn1, const char *fn2, int sz, int off)
bios_load_linear_combined(const char *fn1, const char *fn2, int sz, UNUSED(int off))
{
uint8_t ret = 0;

23
src/mem/spd.c
View File

@@ -27,6 +27,7 @@
#include <86box/spd.h>
#include <86box/version.h>
#include <86box/machine.h>
#include <86box/plat_unused.h>
#define SPD_ROLLUP(x) ((x) >= 16 ? ((x) -15) : (x))
@@ -54,7 +55,7 @@ spd_log(const char *fmt, ...)
#endif
static void
spd_close(void *priv)
spd_close(UNUSED(void *priv))
{
spd_log("SPD: close()\n");
@@ -67,7 +68,7 @@ spd_close(void *priv)
}
static void *
spd_init(const device_t *info)
spd_init(UNUSED(const device_t *info))
{
spd_log("SPD: init()\n");
@@ -181,7 +182,6 @@ spd_register(uint8_t ram_type, uint8_t slot_mask, uint16_t max_module_size)
uint8_t slot;
uint8_t slot_count;
uint8_t row;
uint8_t i;
uint16_t min_module_size;
uint16_t rows[SPD_MAX_SLOTS];
uint16_t asym;
@@ -262,7 +262,7 @@ spd_register(uint8_t ram_type, uint8_t slot_mask, uint16_t max_module_size)
edo_data->dram_width = 8;
edo_data->spd_rev = 0x12;
for (i = spd_write_part_no(edo_data->part_no, (ram_type == SPD_TYPE_FPM) ? "FPM" : "EDO", rows[row]);
for (int i = spd_write_part_no(edo_data->part_no, (ram_type == SPD_TYPE_FPM) ? "FPM" : "EDO", rows[row]);
i < sizeof(edo_data->part_no); i++)
edo_data->part_no[i] = ' '; /* part number should be space-padded */
edo_data->rev_code[0] = BCD8(EMU_VERSION_MAJ);
@@ -270,9 +270,9 @@ spd_register(uint8_t ram_type, uint8_t slot_mask, uint16_t max_module_size)
edo_data->mfg_year = 20;
edo_data->mfg_week = 17;
for (i = 0; i < 63; i++)
for (uint8_t i = 0; i < 63; i++)
edo_data->checksum += spd_modules[slot]->data[i];
for (i = 0; i < 129; i++)
for (uint8_t i = 0; i < 129; i++)
edo_data->checksum2 += spd_modules[slot]->data[i];
break;
@@ -316,7 +316,7 @@ spd_register(uint8_t ram_type, uint8_t slot_mask, uint16_t max_module_size)
sdram_data->ca_hold = sdram_data->data_hold = 0x08;
sdram_data->spd_rev = 0x12;
for (i = spd_write_part_no(sdram_data->part_no, "SDR", rows[row]);
for (int i = spd_write_part_no(sdram_data->part_no, "SDR", rows[row]);
i < sizeof(sdram_data->part_no); i++)
sdram_data->part_no[i] = ' '; /* part number should be space-padded */
sdram_data->rev_code[0] = BCD8(EMU_VERSION_MAJ);
@@ -327,11 +327,14 @@ spd_register(uint8_t ram_type, uint8_t slot_mask, uint16_t max_module_size)
sdram_data->freq = 100;
sdram_data->features = 0xFF;
for (i = 0; i < 63; i++)
for (uint8_t i = 0; i < 63; i++)
sdram_data->checksum += spd_modules[slot]->data[i];
for (i = 0; i < 129; i++)
for (uint8_t i = 0; i < 129; i++)
sdram_data->checksum2 += spd_modules[slot]->data[i];
break;
default:
break;
}
row++;
@@ -388,7 +391,7 @@ spd_write_drbs(uint8_t *regs, uint8_t reg_min, uint8_t reg_max, uint8_t drb_unit
/* Write DRB register, adding the previous DRB's value. */
if (row == 0)
regs[drb] = 0;
else if ((apollo) && (drb == apollo))
else if (apollo && (drb == apollo))
regs[drb] = regs[drb | 0xf]; /* 5F comes before 56 */
else
regs[drb] = regs[drb - 1];

63
src/mem/sst_flash.c
View File

@@ -35,21 +35,31 @@
#include <86box/m_xt_xi8088.h>
typedef struct sst_t {
uint8_t manufacturer, id, has_bbp, is_39,
page_bytes, sdp, bbp_first_8k, bbp_last_8k;
uint8_t manufacturer;
uint8_t id;
uint8_t has_bbp;
uint8_t is_39;
uint8_t page_bytes;
uint8_t sdp;
uint8_t bbp_first_8k;
uint8_t bbp_last_8k;
int command_state, id_mode,
dirty;
int command_state;
int id_mode;
int dirty;
uint32_t size, mask,
page_mask, page_base,
last_addr;
uint32_t size;
uint32_t mask;
uint32_t page_mask;
uint32_t page_base;
uint32_t last_addr;
uint8_t page_buffer[128],
page_dirty[128];
uint8_t page_buffer[128];
uint8_t page_dirty[128];
uint8_t *array;
mem_mapping_t mapping[8], mapping_h[8];
mem_mapping_t mapping[8];
mem_mapping_t mapping_h[8];
pc_timer_t page_write_timer;
} sst_t;
@@ -252,9 +262,9 @@ sst_page_write(void *priv)
}
static uint8_t
sst_read_id(uint32_t addr, void *p)
sst_read_id(uint32_t addr, void *priv)
{
sst_t *dev = (sst_t *) p;
sst_t *dev = (sst_t *) priv;
uint8_t ret = 0x00;
if ((addr & 0xffff) == 0)
@@ -291,9 +301,9 @@ sst_buf_write(sst_t *dev, uint32_t addr, uint8_t val)
}
static void
sst_write(uint32_t addr, uint8_t val, void *p)
sst_write(uint32_t addr, uint8_t val, void *priv)
{
sst_t *dev = (sst_t *) p;
sst_t *dev = (sst_t *) priv;
switch (dev->command_state) {
case 0:
@@ -359,19 +369,22 @@ sst_write(uint32_t addr, uint8_t val, void *p)
dev->bbp_last_8k = 0xff;
dev->command_state = 0;
break;
default:
break;
}
}
static uint8_t
sst_read(uint32_t addr, void *p)
sst_read(uint32_t addr, void *priv)
{
sst_t *dev = (sst_t *) p;
sst_t *dev = (sst_t *) priv;
uint8_t ret = 0xff;
addr &= 0x000fffff;
if (dev->id_mode)
ret = sst_read_id(addr, p);
ret = sst_read_id(addr, priv);
else {
if ((addr >= biosaddr) && (addr <= (biosaddr + biosmask)))
ret = dev->array[addr - biosaddr];
@@ -381,15 +394,15 @@ sst_read(uint32_t addr, void *p)
}
static uint16_t
sst_readw(uint32_t addr, void *p)
sst_readw(uint32_t addr, void *priv)
{
sst_t *dev = (sst_t *) p;
sst_t *dev = (sst_t *) priv;
uint16_t ret = 0xffff;
addr &= 0x000fffff;
if (dev->id_mode)
ret = sst_read(addr, p) | (sst_read(addr + 1, p) << 8);
ret = sst_read(addr, priv) | (sst_read(addr + 1, priv) << 8);
else {
if ((addr >= biosaddr) && (addr <= (biosaddr + biosmask)))
ret = *(uint16_t *) &dev->array[addr - biosaddr];
@@ -399,15 +412,15 @@ sst_readw(uint32_t addr, void *p)
}
static uint32_t
sst_readl(uint32_t addr, void *p)
sst_readl(uint32_t addr, void *priv)
{
sst_t *dev = (sst_t *) p;
sst_t *dev = (sst_t *) priv;
uint32_t ret = 0xffffffff;
addr &= 0x000fffff;
if (dev->id_mode)
ret = sst_readw(addr, p) | (sst_readw(addr + 2, p) << 16);
ret = sst_readw(addr, priv) | (sst_readw(addr + 2, priv) << 16);
else {
if ((addr >= biosaddr) && (addr <= (biosaddr + biosmask)))
ret = *(uint32_t *) &dev->array[addr - biosaddr];
@@ -499,10 +512,10 @@ sst_init(const device_t *info)
}
static void
sst_close(void *p)
sst_close(void *priv)
{
FILE *f;
sst_t *dev = (sst_t *) p;
sst_t *dev = (sst_t *) priv;
if (dev->dirty) {
f = nvr_fopen(flash_path, "wb");