starred/Mu
1
0
Fork 0
mirror of https://github.com/libretro/Mu.git synced 2026-09-24 15:46:20 +00:00
Code Issues 18 Packages Projects Releases 2 Wiki Activity

Cleanups, add PCMCIA slot stuff to ARM

Browse Source
This commit is contained in:
meepingsnesroms
2019-05-01 13:06:06 -07:00
parent 4d803c6fc0
commit 368757023c
7 changed files with 205 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
qtBuildSystem/Mu/Mu.pro
View File

@@ -232,6 +232,7 @@ SOURCES += \
HEADERS += \
../../src/dbvz.h \
../../src/pxa255/pxa255Accessors.c.h \
debugviewer.h \
emuwrapper.h \
mainwindow.h \

6
src/dbvz.c
View File

@@ -1392,9 +1392,13 @@ void dbvzLoadBootloader(uint8_t* data, uint32_t size){
size = 0;
size = u32Min(size, DBVZ_BOOTLOADER_SIZE);
//copy size bytes from buffer to bootloader area
for(index = 0; index < size; index++)
registerArrayWrite8(DBVZ_REG_SIZE - DBVZ_BOOTLOADER_SIZE + index, data[index]);
for(index = size; index < DBVZ_BOOTLOADER_SIZE; index++)
//fill remainig space with 0x00
for(; index < DBVZ_BOOTLOADER_SIZE; index++)
registerArrayWrite8(DBVZ_REG_SIZE - DBVZ_BOOTLOADER_SIZE + index, 0x00);
}

105
src/pxa255/pxa255.c
View File

@@ -19,46 +19,16 @@
#include "../emulator.h"
#define PXA255_IO_BASE 0x40000000
#define PXA255_MEMCTRL_BASE 0x48000000
uint16_t* pxa255Framebuffer;
static Pxa255ic tungstenCIc;
static Pxa255lcd tungstenCLcd;
//PXA255 register accessors
static uint8_t pxa255_read_byte(uint32_t addr){
}
static uint16_t pxa255_read_half(uint32_t addr){
}
static uint32_t pxa255_read_word(uint32_t addr){
uint32_t out;
switch(addr >> 16){
case PXA255_LCD_BASE >> 16:
pxa255lcdPrvMemAccessF(&tungstenCLcd, addr, 4, false, &out);
return out;
default:
return 0x00000000;
}
}
static void pxa255_write_byte(uint32_t addr, uint8_t value){
}
static void pxa255_write_half(uint32_t addr, uint16_t value){
}
static void pxa255_write_word(uint32_t addr, uint32_t value){
switch(addr >> 16){
case PXA255_LCD_BASE >> 16:
pxa255lcdPrvMemAccessF(&tungstenCLcd, addr, 4, true, &value);
return;
default:
return;
}
}
#include "pxa255Accessors.c.h"
bool pxa255Init(uint8_t** returnRom, uint8_t** returnRam){
uint32_t mem_offset = 0;
@@ -69,7 +39,9 @@ bool pxa255Init(uint8_t** returnRom, uint8_t** returnRam){
return false;
addr_cache_init();
memset(mem_areas, 0x00, sizeof(mem_areas));
//regions
//ROM
mem_areas[0].base = PXA255_ROM_START_ADDRESS;
mem_areas[0].size = TUNGSTEN_C_ROM_SIZE;
@@ -82,11 +54,18 @@ bool pxa255Init(uint8_t** returnRom, uint8_t** returnRam){
mem_areas[1].ptr = mem_and_flags + mem_offset;
mem_offset += TUNGSTEN_C_RAM_SIZE;
//CPU registers
mem_areas[2].base = PXA255_REG_START_ADDRESS;
mem_areas[2].size = 0x40000000;//size of address space, not all of it is mapped
//PCMCIA0/1
mem_areas[2].base = PXA255_PCMCIA0_START_ADDRESS;
mem_areas[2].size = PXA255_PCMCIA0_SIZE + PXA255_PCMCIA1_SIZE;
mem_areas[2].ptr = NULL;
//CPU registers
mem_areas[3].base = PXA255_REG_START_ADDRESS;
mem_areas[3].size = PXA255_REG_SIZE;//size of address space, not all of it is mapped
mem_areas[3].ptr = NULL;
//accessors
//default
for(i = 0; i < PXA255_TOTAL_MEMORY_BANKS; i++){
// will fallback to bad_* on non-memory addresses
read_byte_map[i] = memory_read_byte;
@@ -97,16 +76,50 @@ bool pxa255Init(uint8_t** returnRom, uint8_t** returnRam){
write_word_map[i] = memory_write_word;
}
//add PXA255 register range
for(i = PXA255_START_BANK(PXA255_REG_START_ADDRESS); i <= PXA255_END_BANK(PXA255_REG_START_ADDRESS, mem_areas[2].size); i++){
read_byte_map[i] = pxa255_read_byte;
read_half_map[i] = pxa255_read_half;
read_word_map[i] = pxa255_read_word;
write_byte_map[i] = pxa255_write_byte;
write_half_map[i] = pxa255_write_half;
write_word_map[i] = pxa255_write_word;
//PCMCIA0
for(i = PXA255_START_BANK(PXA255_PCMCIA0_START_ADDRESS); i <= PXA255_END_BANK(PXA255_PCMCIA0_START_ADDRESS, PXA255_PCMCIA0_SIZE); i++){
read_byte_map[i] = pxa255_pcmcia0_read_byte;
read_half_map[i] = pxa255_pcmcia0_read_half;
read_word_map[i] = pxa255_pcmcia0_read_word;
write_byte_map[i] = pxa255_pcmcia0_write_byte;
write_half_map[i] = pxa255_pcmcia0_write_half;
write_word_map[i] = pxa255_pcmcia0_write_word;
}
//PCMCIA1
for(i = PXA255_START_BANK(PXA255_PCMCIA1_START_ADDRESS); i <= PXA255_END_BANK(PXA255_PCMCIA1_START_ADDRESS, PXA255_PCMCIA1_SIZE); i++){
read_byte_map[i] = pxa255_pcmcia1_read_byte;
read_half_map[i] = pxa255_pcmcia1_read_half;
read_word_map[i] = pxa255_pcmcia1_read_word;
write_byte_map[i] = pxa255_pcmcia1_write_byte;
write_half_map[i] = pxa255_pcmcia1_write_half;
write_word_map[i] = pxa255_pcmcia1_write_word;
}
//IO
read_byte_map[PXA255_START_BANK(PXA255_IO_BASE)] = pxa255_io_read_byte;
read_half_map[PXA255_START_BANK(PXA255_IO_BASE)] = bad_read_half;
read_word_map[PXA255_START_BANK(PXA255_IO_BASE)] = pxa255_io_read_word;
write_byte_map[PXA255_START_BANK(PXA255_IO_BASE)] = pxa255_io_write_byte;
write_half_map[PXA255_START_BANK(PXA255_IO_BASE)] = bad_write_half;
write_word_map[PXA255_START_BANK(PXA255_IO_BASE)] = pxa255_io_write_word;
//LCD
read_byte_map[PXA255_START_BANK(PXA255_LCD_BASE)] = bad_read_byte;
read_half_map[PXA255_START_BANK(PXA255_LCD_BASE)] = bad_read_half;
read_word_map[PXA255_START_BANK(PXA255_LCD_BASE)] = pxa255_lcd_read_word;
write_byte_map[PXA255_START_BANK(PXA255_LCD_BASE)] = bad_write_byte;
write_half_map[PXA255_START_BANK(PXA255_LCD_BASE)] = bad_write_half;
write_word_map[PXA255_START_BANK(PXA255_LCD_BASE)] = pxa255_lcd_write_word;
//MEMCTRL
read_byte_map[PXA255_START_BANK(PXA255_MEMCTRL_BASE)] = bad_read_byte;
read_half_map[PXA255_START_BANK(PXA255_MEMCTRL_BASE)] = bad_read_half;
read_word_map[PXA255_START_BANK(PXA255_MEMCTRL_BASE)] = pxa255_memctrl_read_word;
write_byte_map[PXA255_START_BANK(PXA255_MEMCTRL_BASE)] = bad_write_byte;
write_half_map[PXA255_START_BANK(PXA255_MEMCTRL_BASE)] = bad_write_half;
write_word_map[PXA255_START_BANK(PXA255_MEMCTRL_BASE)] = pxa255_memctrl_write_word;
//set up CPU hardware
pxa255icInit(&tungstenCIc);
pxa255lcdInit(&tungstenCLcd, &tungstenCIc);

128
src/pxa255/pxa255Accessors.c.h Normal file
View File

@@ -0,0 +1,128 @@
static uint8_t pxa255_io_read_byte(uint32_t addr){
//is only vaild for UART stuff
}
static uint32_t pxa255_io_read_word(uint32_t addr){
uint32_t out;
switch(addr >> 16){
case PXA255_CLOCK_MANAGER_BASE >> 16:
case PXA255_POWER_MANAGER_BASE >> 16:
case PXA255_DMA_BASE >> 16:
case PXA255_GPIO_BASE >> 16:
case PXA255_IC_BASE >> 16:
case PXA255_RTC_BASE >> 16:
case PXA255_TIMR_BASE >> 16:
case PXA255_FFUART_BASE >> 16:
case PXA255_BTUART_BASE >> 16:
case PXA255_STUART_BASE >> 16:
//need to implement these
debugLog("Unimplemented 32 bit PXA255 register read:0x%08X\n", addr);
return 0x00000000;
default:
debugLog("Invalid 32 bit PXA255 register read:0x%08X\n", addr);
return 0x00000000;
}
}
static void pxa255_io_write_byte(uint32_t addr, uint8_t value){
//is only vaild for UART stuff
}
static void pxa255_io_write_word(uint32_t addr, uint32_t value){
switch(addr >> 16){
case PXA255_CLOCK_MANAGER_BASE >> 16:
case PXA255_POWER_MANAGER_BASE >> 16:
case PXA255_DMA_BASE >> 16:
case PXA255_GPIO_BASE >> 16:
case PXA255_IC_BASE >> 16:
case PXA255_RTC_BASE >> 16:
case PXA255_TIMR_BASE >> 16:
case PXA255_FFUART_BASE >> 16:
case PXA255_BTUART_BASE >> 16:
case PXA255_STUART_BASE >> 16:
//need to implement these
debugLog("Unimplemented 32 bit PXA255 register write:0x%08X, value:0x%08X\n", addr, value);
return;
default:
debugLog("Invalid 32 bit PXA255 register write:0x%08X, value:0x%08X\n", addr, value);
return;
}
}
static uint32_t pxa255_lcd_read_word(uint32_t addr){
uint32_t out;
pxa255lcdPrvMemAccessF(&tungstenCLcd, addr, 4, false, &out);
debugLog("32 bit PXA255 LCD register read:0x%08X\n", addr);
return out;
}
static void pxa255_lcd_write_word(uint32_t addr, uint32_t value){
pxa255lcdPrvMemAccessF(&tungstenCLcd, addr, 4, true, &value);
debugLog("32 bit PXA255 LCD register write:0x%08X, value:0x%08X\n", addr, value);
}
static uint32_t pxa255_memctrl_read_word(uint32_t addr){
debugLog("32 bit PXA255 MEMCTRL register read:0x%08X\n", addr);
return 0x00000000;
}
static void pxa255_memctrl_write_word(uint32_t addr, uint32_t value){
debugLog("32 bit PXA255 MEMCTRL register write:0x%08X, value:0x%08X\n", addr, value);
}
static uint8_t pxa255_pcmcia0_read_byte(uint32_t addr){
debugLog("PCMCIA0 8 bit read:0x%08X\n", addr);
return 0x00;
}
static uint16_t pxa255_pcmcia0_read_half(uint32_t addr){
debugLog("PCMCIA0 16 bit read:0x%08X\n", addr);
return 0x0000;
}
static uint32_t pxa255_pcmcia0_read_word(uint32_t addr){
debugLog("PCMCIA0 32 bit read:0x%08X\n", addr);
return 0x00000000;
}
static void pxa255_pcmcia0_write_byte(uint32_t addr, uint8_t value){
debugLog("PCMCIA0 8 bit write:0x%08X, value:0x%02X\n", addr, value);
}
static void pxa255_pcmcia0_write_half(uint32_t addr, uint16_t value){
debugLog("PCMCIA0 16 bit write:0x%08X, value:0x%04X\n", addr, value);
}
static void pxa255_pcmcia0_write_word(uint32_t addr, uint32_t value){
debugLog("PCMCIA0 32 bit write:0x%08X, value:0x%08X\n", addr, value);
}
static uint8_t pxa255_pcmcia1_read_byte(uint32_t addr){
debugLog("PCMCIA1 8 bit read:0x%08X\n", addr);
return 0x00;
}
static uint16_t pxa255_pcmcia1_read_half(uint32_t addr){
debugLog("PCMCIA1 16 bit read:0x%08X\n", addr);
return 0x0000;
}
static uint32_t pxa255_pcmcia1_read_word(uint32_t addr){
debugLog("PCMCIA1 32 bit read:0x%08X\n", addr);
return 0x00000000;
}
static void pxa255_pcmcia1_write_byte(uint32_t addr, uint8_t value){
debugLog("PCMCIA1 8 bit write:0x%08X, value:0x%02X\n", addr, value);
}
static void pxa255_pcmcia1_write_half(uint32_t addr, uint16_t value){
debugLog("PCMCIA1 16 bit write:0x%08X, value:0x%04X\n", addr, value);
}
static void pxa255_pcmcia1_write_word(uint32_t addr, uint32_t value){
debugLog("PCMCIA1 32 bit write:0x%08X, value:0x%08X\n", addr, value);
}

6
src/pxa255/pxa255_CPU.h
View File

@@ -67,12 +67,6 @@ typedef struct ArmCpu{
// various other cpu config options
UInt32 vectorBase; //address of vector base
#ifdef ARM_V6
Boolean EEE; //endianness one exception entry
Boolean impreciseAbtWaiting;
#endif
ArmCpuMemF memF;
ArmCpuEmulErr emulErrF;
ArmCpuHypercall hypercallF;

25
src/pxa255/pxa255_types.h
View File

@@ -6,6 +6,8 @@
#include <stddef.h>
#include <string.h>
#include "../emulator.h"
typedef uint64_t UInt64;
typedef int64_t Int64;
typedef uint32_t UInt32;
@@ -15,30 +17,17 @@ typedef int16_t Int16;
typedef uint8_t UInt8;
typedef int8_t Int8;
typedef uint8_t Err;
typedef bool Boolean;//may need to be uint8_t, thats its type in the original source
typedef uint8_t Boolean;//must use uint8_t, some functions store extra info in the other bits
#define errNone 0x00
#define errInternal 0x01
/*
#define _INLINE_ inline __attribute__ ((always_inline))
#define _UNUSED_ __attribute__((unused))
*/
#define _INLINE_ inline
#define _UNUSED_
/* runtime stuffs */
/*
void err_str(const char* str);
void err_hex(UInt32 val);
void err_dec(UInt32 val);
*/
#define err_str(x)
#define err_hex(x)
#define err_dec(x)
#define err_str(str) debugLog(str)
#define err_hex(num) debugLog("0x%X", num)
#define err_dec(num) debugLog("%d", num)
#define __mem_zero(mem, len) memset(mem, 0x00, len)
#define __mem_copy(d, s, sz) memcpy(d, s, sz)
#define __mem_copy(dst, src, size) memcpy(dst, src, size)
#endif

5
src/tungstenCBus.h
View File

@@ -3,9 +3,14 @@
#define PXA255_ROM_START_ADDRESS 0x00000000
#define PXA255_RAM_START_ADDRESS 0xA0000000
#define PXA255_PCMCIA0_START_ADDRESS 0x20000000
#define PXA255_PCMCIA1_START_ADDRESS 0x30000000
#define PXA255_REG_START_ADDRESS 0x40000000
#define TUNGSTEN_C_ROM_SIZE (10 * 0x100000)//10mb ROM
#define TUNGSTEN_C_RAM_SIZE (64 * 0x100000)//64mb RAM
#define PXA255_PCMCIA0_SIZE 0x10000000
#define PXA255_PCMCIA1_SIZE 0x10000000
#define PXA255_REG_SIZE 0x0C000000
#define PXA255_BANK_SCOOT 26
#define PXA255_NUM_BANKS(areaSize) (((areaSize) >> PXA255_BANK_SCOOT) + ((areaSize) & ((1 << PXA255_BANK_SCOOT) - 1) ? 1 : 0))