Macintosh-Tools
/
dingusppc
mirror of https://github.com/dingusdev/dingusppc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Update for July 7, 2019 

The following fixes and changes have been made

- Better Grackle emulation (though far from perfect)
- OpenPIC write/read fixes
- DAVBus Stubs
- Started splitting functionality from the main routine, to slowly make way for a GUI-based version
- Added a new until command argument
- Fixed an entry in the floating point instruction dispatch table
- CMakeLists.txt added
This commit is contained in:
dingusdev 2019-07-06 23:10:32 -07:00 committed by GitHub
parent d776e3918b
commit 2bd717e293
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 316 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
CMakeLists.txt Normal file
View File

@ -0,0 +1,39 @@
cmake_minimum_required(VERSION 3.1)
project(dingusppc)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_AUTOMOC ON)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-c -Wall -O3 -s")
set(SOURCE_FILES
macioserial.cpp
macscsi.cpp
macswim3.cpp
mpc106.cpp
openpic.cpp
poweropcodes.cpp
ppcfpopcodes.cpp
ppcgekkoopcodes.cpp
ppcmemory.cpp
ppcopcodes.cpp
viacuda.cpp
main.cpp
davbus.cpp
)
set(HEADER_FILES
macioserial.h
macscsi.h
macswim3.h
mpc106.h
openpic.h
ppcemumain.h
ppcmemory.h
viacuda.h
davbus.h
)
add_executable(dingusppc ${SOURCE_FILES} ${HEADER_FILES})
install (TARGETS dingusppc DESTINATION bin)

4
README.md
View File

@ -27,11 +27,11 @@ Run the emulator in runtime
Load an ELF file into memory
-eso
-stepi
Execute a single opcode
-epo
-stepp
Execute a page of opcodes (256 instructions at a time)

35
davbus.cpp Normal file
View File

@ -0,0 +1,35 @@
//DingusPPC - Prototype 5bf2
//Written by divingkatae
//(c)2018-20 (theweirdo)
//Please ask for permission
//if you want to distribute this.
//(divingkatae#1017 on Discord)
//Functionality for the DAVBus (Sound Bus + Screamer?)
#include <iostream>
#include <cstring>
#include <cinttypes>
#include "ppcemumain.h"
uint32_t davbus_address;
uint32_t davbus_write_word;
uint32_t davbus_read_word;
void davbus_init(){
}
void davbus_read(){
davbus_read_word = (uint32_t)(machine_upperiocontrol_mem[davbus_address++]);
davbus_read_word = (uint32_t)((machine_upperiocontrol_mem[davbus_address++]) << 8);
davbus_read_word = (uint32_t)((machine_upperiocontrol_mem[davbus_address++]) << 16);
davbus_read_word = (uint32_t)((machine_upperiocontrol_mem[davbus_address]) << 24);
}
void davbus_write(){
machine_upperiocontrol_mem[davbus_address++] = (uint8_t)(davbus_write_word);
machine_upperiocontrol_mem[davbus_address++] = (uint8_t)((davbus_write_word) >> 8);
machine_upperiocontrol_mem[davbus_address++] = (uint8_t)((davbus_write_word) >> 16);
machine_upperiocontrol_mem[davbus_address] = (uint8_t)((davbus_write_word) >> 24);
}

22
davbus.h Normal file
View File

@ -0,0 +1,22 @@
//DingusPPC - Prototype 5bf2
//Written by divingkatae
//(c)2018-20 (theweirdo)
//Please ask for permission
//if you want to distribute this.
//(divingkatae#1017 on Discord)
//Functionality for the DAVBus (Sound Bus + Screamer?)
#ifndef DAVBUS_H_
#define DAVBUS_H_
extern uint32_t davbus_address;
extern uint32_t davbus_write_word;
extern uint32_t davbus_read_word;
extern void davbus_init();
extern void davbus_read();
extern void davbus_write();
#endif

2
dingusppc.cbp
View File

@ -41,6 +41,8 @@
<Add option="-std=c++11" />
<Add option="-fexceptions" />
</Compiler>
<Unit filename="davbus.cpp" />
<Unit filename="davbus.h" />
<Unit filename="macioserial.cpp" />
<Unit filename="macioserial.h" />
<Unit filename="macscsi.cpp" />

169
main.cpp
View File

@ -39,14 +39,17 @@ using namespace std;
SetPRS ppc_state;
bool power_on = 1;
bool grab_branch;
bool grab_exception;
bool grab_return;
bool grab_breakpoint;
uint32_t ppc_cur_instruction;
uint32_t ppc_cur_instruction; //Current instruction for the PPC
uint32_t ppc_effective_address;
uint32_t ppc_real_address;
uint32_t ppc_next_instruction_address;
uint32_t ppc_next_instruction_address; //Used for branching, setting up the NIA
uint32_t temp_address; //used for determining where memory ends up.
uint32_t return_value;
@ -286,27 +289,27 @@ void reg_init(){
//Debugging Functions
uint32_t reg_print(){
for (uint32_t i = 0; i < 32; i++){
printf("FPR %d : %I64u", i, ppc_state.ppc_fpr[i]);
printf("FPR %d : %" PRIx64 "", i, ppc_state.ppc_fpr[i]);
}
ppc_state.ppc_pc = 0;
for (uint32_t i = 0; i < 32; i++){
printf("GPR %d : %d", i, ppc_state.ppc_gpr[i]);
printf("GPR %d : %x", i, ppc_state.ppc_gpr[i]);
}
printf("CR : %d", ppc_state.ppc_cr);
printf("FPSCR : %d", ppc_state.ppc_fpscr);
printf("TBR 0 : %d", ppc_state.ppc_tbr[0]);
printf("TBR 1 : %d", ppc_state.ppc_tbr[1]);
printf("CR : %x", ppc_state.ppc_cr);
printf("FPSCR : %x", ppc_state.ppc_fpscr);
printf("TBR 0 : %x", ppc_state.ppc_tbr[0]);
printf("TBR 1 : %x", ppc_state.ppc_tbr[1]);
for (uint32_t i = 0; i < 1024; i++){
printf("SPR %d : %d", i, ppc_state.ppc_spr[i]);
printf("SPR %d : %x", i, ppc_state.ppc_spr[i]);
}
printf("CR : %d", ppc_state.ppc_cr);
printf("CR : %x", ppc_state.ppc_cr);
printf("MSR : %d", ppc_state.ppc_msr);
printf("MSR : %x", ppc_state.ppc_msr);
for (uint32_t i = 0; i < 16; i++){
printf("SR %d : %d", i, ppc_state.ppc_sr[i]);
printf("SR %d : %x", i, ppc_state.ppc_sr[i]);
}
return 0;
@ -334,6 +337,62 @@ uint32_t reg_write(){
return 0;
}
void execute_interpreter(){
//Main execution loop for the interpreter.
while (power_on){
//printf("PowerPC Address: %x \n", ppc_state.ppc_pc);
quickinstruction_translate(ppc_state.ppc_pc);
ppc_main_opcode();
if (grab_branch & !grab_exception){
ppc_state.ppc_pc = ppc_next_instruction_address;
grab_branch = 0;
ppc_tbr_update();
}
else if (grab_return | grab_exception){
ppc_state.ppc_pc = ppc_next_instruction_address;
grab_exception = 0;
grab_return = 0;
ppc_tbr_update();
}
else{
ppc_state.ppc_pc += 4;
ppc_tbr_update();
}
ppc_cur_instruction = 0;
}
}
void execute_interpreter_bp (uint32_t ppc_break_addr){
//Main loop like the above, with the only big difference
//being that this stops on reaching the desired address.
//It then prints the regs at the time it stopped.
while (ppc_state.ppc_pc != ppc_break_addr){
quickinstruction_translate(ppc_state.ppc_pc);
ppc_main_opcode();
if (grab_branch & !grab_exception){
ppc_state.ppc_pc = ppc_next_instruction_address;
grab_branch = 0;
ppc_tbr_update();
}
else if (grab_return | grab_exception){
ppc_state.ppc_pc = ppc_next_instruction_address;
grab_exception = 0;
grab_return = 0;
ppc_tbr_update();
}
else{
ppc_state.ppc_pc += 4;
ppc_tbr_update();
}
ppc_cur_instruction = 0;
}
reg_print();
}
int main(int argc, char **argv)
{
ram_size_set = 0x4000000; //64 MB of RAM for the Mac
@ -361,7 +420,6 @@ int main(int argc, char **argv)
}
**/
bool power_on = 1;
uint32_t opcode_entered = 0; //used for testing opcodes in playground
std::cout << "DingusPPC - Prototype 5bf3 (6/9/2019) " << endl;
@ -486,7 +544,7 @@ int main(int argc, char **argv)
{"TNT ", "Power Mac 7xxxx/8xxx series"}, //Trinitrotoluene :-)
{"Zanz", "A complete engima."} //Zanzibar (mentioned in Sheepshaver's code, but no match to any known ROM)
};
char configGrab = 0;
uint32_t configInfoOffset = 0;
@ -578,26 +636,7 @@ int main(int argc, char **argv)
}
}
else if ((checker=="1")|(checker=="realtime")|(checker=="/realtime")|(checker=="-realtime")){
while (power_on){
cout << "PowerPC PC Address: " << hex << ppc_state.ppc_pc << endl;
quickinstruction_translate(ppc_state.ppc_pc);
ppc_main_opcode();
if (grab_branch & !grab_exception){
ppc_state.ppc_pc = ppc_next_instruction_address;
grab_branch = 0;
ppc_tbr_update();
}
else if (grab_return | grab_exception){
ppc_state.ppc_pc = ppc_next_instruction_address;
grab_exception = 0;
grab_return = 0;
ppc_tbr_update();
}
else{
ppc_state.ppc_pc += 4;
ppc_tbr_update();
}
ppc_cur_instruction = 0;
execute_interpreter();
/*
if (disk_inserted){
if (disk_word == 32768){
@ -621,7 +660,6 @@ int main(int argc, char **argv)
}
}
*/
}
}
else if ((checker=="e")|(checker=="loadelf")|(checker=="/loadelf")|(checker=="-loadelf")){
ifstream elfFile;
@ -684,32 +722,17 @@ int main(int argc, char **argv)
ppc_state.ppc_pc = atoi(elf_memoffset);
while (power_on){
quickinstruction_translate(ppc_state.ppc_pc);
ppc_main_opcode();
if (grab_branch & !grab_exception){
ppc_state.ppc_pc = ppc_effective_address;
grab_branch = 0;
ppc_tbr_update();
}
else if (grab_return | grab_exception){
ppc_state.ppc_pc = ppc_next_instruction_address;
grab_exception = 0;
grab_return = 0;
ppc_tbr_update();
}
else if (ppc_cur_instruction == 0){
cout << "Opcode 0 executed. Shutting off the power before the flood even starts. \n" << endl;
power_on = 0; //Hack - Prevent flooding the log.
}
else{
ppc_state.ppc_pc += 4;
ppc_tbr_update();
}
ppc_cur_instruction = 0;
}
execute_interpreter();
}
else if (checker=="assemble"){
else if ((checker=="until")|(checker=="/until")|(checker=="-until")){
uint32_t grab_bp = 0x0;
std::cout << hex << "Enter the address in hex for where to stop execution." << endl;
cin >> hex >> opcode_entered;
execute_interpreter_bp(grab_bp);
}
else if (checker=="disas"){
if (argc > 2){
checker = argv[1];
}
@ -721,11 +744,8 @@ int main(int argc, char **argv)
cerr << "Unable to open file for assembling.";
exit(1);
}
cout << "Insert Assembler Here! - TODO" << endl;
}
else if ((checker=="eso")|(checker=="/eso")|(checker=="-eso")){
else if ((checker=="stepi")|(checker=="/stepi")|(checker=="-stepi")){
std::cout << hex << "Ready to execute an opcode?" << endl;
string check_q;
@ -753,7 +773,7 @@ int main(int argc, char **argv)
ppc_cur_instruction = 0;
}
}
else if ((checker=="epo")|(checker=="/epo")|(checker=="-epo")){
else if ((checker=="stepp")|(checker=="/stepp")|(checker=="-stepp")){
std::cout << hex << "Ready to execute a page of opcodes?" << endl;
string check_q;
@ -829,17 +849,18 @@ int main(int argc, char **argv)
}
else{
std::cout << " " << endl;
std::cout << "Please enter one of the following commands when" << endl;
std::cout << "booting up DingusPPC... " << endl;
std::cout << "Please enter one of the following commands when " << endl;
std::cout << "booting up DingusPPC... " << endl;
std::cout << " " << endl;
std::cout << " " << endl;
std::cout << "realtime - Run the emulator in real-time. " << endl;
std::cout << "loadelf - Load an ELF file to run from RAM. " << endl;
std::cout << "fuzzer - Test every single PPC opcode. " << endl;
std::cout << "eso - Execute a single opcode per key press. " << endl;
std::cout << "epo - Execute a page of opcodes per key press. " << endl;
std::cout << "playground - Mess around with and opcodes. " << endl;
//std::cout << "assembler - NOT YET IMPLEMENTED " << endl;
std::cout << "realtime - Run the emulator in real-time. " << endl;
std::cout << "loadelf - Load an ELF file to run from RAM. " << endl;
std::cout << "until - Runs until hitting a specified address. " << endl;
std::cout << "fuzzer - Test every single PPC opcode. " << endl;
std::cout << "stepi - Execute a single opcode per key press. " << endl;
std::cout << "stepp - Execute a page of opcodes per key press." << endl;
std::cout << "playground - Mess around with and opcodes. " << endl;
//std::cout << "disas - NOT YET IMPLEMENTED " << endl;
}
romFile.close();

6
makefile
View File

@ -1,5 +1,5 @@
OBJS = main.o macioserial.o macscsi.o macswim3.o mpc106.o openpic.o poweropcodes.o ppcfpopcodes.o ppcgekkoopcodes.o ppcmemory.o ppcopcodes.o viacuda.o
SOURCE = main.cpp macioserial.cpp macscsi.cpp macswim3.cpp mpc106.cpp openpic.cpp poweropcodes.cpp ppcfpopcodes.cpp ppcgekkoopcodes.cpp ppcmemory.cpp ppcopcodes.cpp viacuda.cpp
OBJS = main.o macioserial.o macscsi.o macswim3.o mpc106.o openpic.o poweropcodes.o ppcfpopcodes.o ppcgekkoopcodes.o ppcmemory.o ppcopcodes.o viacuda.o davbus.o
SOURCE = main.cpp macioserial.cpp macscsi.cpp macswim3.cpp mpc106.cpp openpic.cpp poweropcodes.cpp ppcfpopcodes.cpp ppcgekkoopcodes.cpp ppcmemory.cpp ppcopcodes.cpp viacuda.cpp davbus.cpp
HEADER = macioserial.h macscsi.h macswim3.h mpc106.h openpic.h ppcemumain.h ppcmemory.h viacuda.h
OUT = dingusppc
CC = g++
@ -45,6 +45,8 @@ ppcopcodes.o: ppcopcodes.cpp
viacuda.o: viacuda.cpp
$(CC) $(FLAGS) viacuda.cpp
davbus.o: davbus.cpp
$(CC) $(FLAGS) davbus.cpp
clean:
rm -f $(OBJS) $(OUT)

87
mpc106.cpp
View File

@ -16,9 +16,9 @@
bool mpc106_address_map;
uint32_t mpc106_address;
uint32_t mpc_config_addr;
uint32_t mpc_config_dat;
uint32_t mpc106_address; // For fe000000 - fe00ffff
uint32_t mpc_config_addr; // Device No. and Reg No. included
uint32_t mpc_config_dat; // Value to write to the device
uint32_t mpc106_write_word;
uint32_t mpc106_read_word;
@ -26,39 +26,82 @@ uint16_t mpc106_write_half;
uint16_t mpc106_read_half;
uint8_t mpc106_write_byte;
uint8_t mpc106_read_byte;
unsigned char* mpc106_regs;
void mpc106_init(){
mpc106_regs = (unsigned char*) calloc (256, 1);
memset(mpc106_regs, 0x0, 256);
mpc_config_addr = 0;
mpc_config_dat = 0;
//Initialize Vendor & Device IDs
mpc106_regs[0] = 0x57;
mpc106_regs[1] = 0x10;
machine_fexxxx_mem[0] = 0x57;
machine_fexxxx_mem[1] = 0x10;
mpc106_regs[2] = 0x02;
machine_fexxxx_mem[2] = 0x02;
//PCI command + status
mpc106_regs[4] = 0x06;
mpc106_regs[6] = 0x80;
machine_fexxxx_mem[4] = 0x06;
machine_fexxxx_mem[6] = 0x80;
mpc106_regs[115] = 0xCD;
machine_fexxxx_mem[115] = 0xCD;
mpc106_regs[168] = 0x10;
mpc106_regs[169] = 0x00;
mpc106_regs[170] = 0x00;
mpc106_regs[171] = 0xFF;
machine_fexxxx_mem[168] = 0x10;
machine_fexxxx_mem[169] = 0x00;
machine_fexxxx_mem[170] = 0x00;
machine_fexxxx_mem[171] = 0xFF;
mpc106_regs[172] = 0x0C;
mpc106_regs[173] = 0x06;
mpc106_regs[174] = 0x0C;
mpc106_regs[175] = 0x00;
machine_fexxxx_mem[172] = 0x0C;
machine_fexxxx_mem[173] = 0x06;
machine_fexxxx_mem[174] = 0x0C;
machine_fexxxx_mem[175] = 0x00;
}
void mpc106_write_device(uint32_t value){
uint32_t mpc106_write_device(uint32_t device_addr, uint32_t insert_to_device, uint8_t bit_length){
//Write to the specified device - Invoked when a write is made to 0xFEExxxxx.
//device_addr is what's stored in 0xFEC00CF8.
uint32_t reg_num = (device_addr & 0x07FC) >> 2;
uint32_t dev_num = (device_addr & 0xF800) >> 11;
uint32_t location = reg_num + (dev_num << 11) + 0x3000000;
switch (bit_length){
case 1:
machine_iocontrolmem_mem[location] = (uint8_t)insert_to_device;
case 2:
machine_iocontrolmem_mem[location++] = (uint8_t)insert_to_device;
machine_iocontrolmem_mem[location] = (uint8_t)(insert_to_device >> 8);
case 4:
machine_iocontrolmem_mem[location++] = (uint8_t)insert_to_device;
machine_iocontrolmem_mem[location++] = (uint8_t)(insert_to_device >> 8);
machine_iocontrolmem_mem[location++] = (uint8_t)(insert_to_device >> 16);
machine_iocontrolmem_mem[location] = (uint8_t)(insert_to_device >> 24);
}
return 0;
}
void mpc106_read_device(uint32_t value, uint8_t bit_length){
uint32_t mpc106_read_device(uint32_t device_addr, uint8_t bit_length){
//Read to the specified device - Invoked when a read is made to 0xFEExxxxx.
//device_addr is what's stored in 0xFEC00CF8.
uint32_t reg_num = (device_addr & 0x07FC) >> 2;
uint32_t dev_num = (device_addr & 0xF800) >> 11;
uint32_t location = reg_num + (dev_num << 11) + 0x3000000;
uint32_t grab_value = 0;
switch (bit_length){
case 1:
grab_value |= ((uint32_t)(machine_iocontrolmem_mem[location++]));
case 2:
grab_value |= ((uint32_t)(machine_iocontrolmem_mem[location++]));
grab_value |= ((uint32_t)(machine_iocontrolmem_mem[location++])) << 8;
case 4:
grab_value |= ((uint32_t)(machine_iocontrolmem_mem[location++]));
grab_value |= ((uint32_t)(machine_iocontrolmem_mem[location++])) << 8;
grab_value |= ((uint32_t)(machine_iocontrolmem_mem[location++])) << 16;
grab_value |= ((uint32_t)(machine_iocontrolmem_mem[location])) << 24;
}
return grab_value;
}
void mpc106_read(){

2
mpc106.h
View File

@ -28,5 +28,7 @@ extern unsigned char* mpc106_regs;
extern void mpc106_init();
extern void mpc106_read();
extern void mpc106_write(uint32_t write_word);
extern uint32_t mpc106_write_device(uint32_t device_addr, uint32_t insert_to_device, uint8_t bit_length);
extern uint32_t mpc106_read_device(uint32_t device_addr, uint8_t bit_length);
#endif

10
openpic.cpp
View File

@ -26,9 +26,15 @@ void openpic_init(){
}
void openpic_read(){
machine_upperiocontrol_mem[openpic_address] = openpic_read_word;
openpic_read_word = (uint32_t)(machine_upperiocontrol_mem[openpic_address++]);
openpic_read_word = (uint32_t)((machine_upperiocontrol_mem[openpic_address++]) << 8);
openpic_read_word = (uint32_t)((machine_upperiocontrol_mem[openpic_address++]) << 16);
openpic_read_word = (uint32_t)((machine_upperiocontrol_mem[openpic_address]) << 24);
}
void openpic_write(){
openpic_write_word = machine_upperiocontrol_mem[openpic_address];
machine_upperiocontrol_mem[openpic_address++] = (uint8_t)(openpic_write_word);
machine_upperiocontrol_mem[openpic_address++] = (uint8_t)((openpic_write_word) >> 8);
machine_upperiocontrol_mem[openpic_address++] = (uint8_t)((openpic_write_word) >> 16);
machine_upperiocontrol_mem[openpic_address] = (uint8_t)((openpic_write_word) >> 24);
}

2
ppcemumain.h
View File

@ -745,7 +745,7 @@ static std::map<uint16_t, PPCOpcode> SubOpcode63Grabber=
{1266, &ppc_fmult}, {1272, &ppc_fmsub}, {1274, &ppc_fmadd}, {1276, &ppc_fnmsub}, {1278, &ppc_fnmadd},
{1330, &ppc_fmult}, {1336, &ppc_fmsub}, {1338, &ppc_fmadd}, {1340, &ppc_fnmsub}, {1342, &ppc_fnmadd},
{1394, &ppc_fmult}, {1400, &ppc_fmsub}, {1402, &ppc_fmadd}, {1404, &ppc_fnmsub}, {1406, &ppc_fnmadd},
{1422, &ppc_mffs},
{1422, &ppc_mtfsf},
{1458, &ppc_fmult}, {1464, &ppc_fmsub}, {1466, &ppc_fmadd}, {1468, &ppc_fnmsub}, {1470, &ppc_fnmadd},
{1522, &ppc_fmult}, {1528, &ppc_fmsub}, {1530, &ppc_fmadd}, {1532, &ppc_fnmsub}, {1534, &ppc_fnmadd},
{1586, &ppc_fmult}, {1592, &ppc_fmsub}, {1594, &ppc_fmadd}, {1596, &ppc_fnmsub}, {1598, &ppc_fnmadd},

50
ppcmemory.cpp
View File

@ -21,6 +21,7 @@
#include "ppcmemory.h"
#include "openpic.h"
#include "mpc106.h"
#include "davbus.h"
std::vector<uint32_t> pte_storage;
uint64_t ppc_virtual_address; //It's 52 bits, but 64 bits more than covers the range needed.
@ -427,7 +428,7 @@ void pteg_translate(uint32_t address_grab){
void address_quickinsert_translate(uint32_t address_grab, uint32_t value_insert, uint8_t bit_num){
//Insert a value into memory from a register
printf("Inserting into address %x with %x", address_grab, value_insert);
printf("Inserting into address %x with %x \n", address_grab, value_insert);
uint32_t storage_area = 0;
uint32_t grab_batl = 537;
@ -550,6 +551,13 @@ void address_quickinsert_translate(uint32_t address_grab, uint32_t value_insert,
mac_serial_write();
return;
}
else if ((address_grab >= 0xF3014000) && (address_grab < 0xF3015000)){
davbus_address = storage_area;
davbus_write_word = value_insert;
printf("\nWriting to DAVBus: %x \n", return_value);
davbus_write();
return;
}
else if ((address_grab >= 0xF3015000) && (address_grab < 0xF3016000)){
mac_swim3_address = storage_area;
swim3_write_byte = (uint8_t)value_insert;
@ -564,6 +572,13 @@ void address_quickinsert_translate(uint32_t address_grab, uint32_t value_insert,
via_cuda_write();
return;
}
else if ((address_grab >= 0xF3040000) && (address_grab < 0xF3080000)){
openpic_address = storage_area - 0x3000000;
openpic_write_word = value_insert;
printf("Writing byte to OpenPIC address %x ... %x \n", address_grab, openpic_write_word);
openpic_write();
return;
}
else if (address_grab > 0xF3FFFFFF){
printf("Uncharted territory: %x", address_grab);
return;
@ -578,8 +593,9 @@ void address_quickinsert_translate(uint32_t address_grab, uint32_t value_insert,
grab_macmem_ptr = machine_f8xxxx_mem;
}
else if (address_grab < 0xFEC00000){
storage_area = address_grab % 65536;
grab_macmem_ptr = machine_fexxxx_mem;
mpc106_address = address_grab % 65536;
mpc106_write(value_insert);
return;
}
else if (address_grab < 0xFEE00000){
storage_area = 0x0CF8; //CONFIG_ADDR
@ -590,10 +606,11 @@ void address_quickinsert_translate(uint32_t address_grab, uint32_t value_insert,
printf("ADDRESS SET FOR GRACKLE \n");
printf("Device Number: %d ", dev_num);
printf("Register Number: %d \n", reg_num);
mpc106_address = value_insert;
mpc_config_addr = value_insert;
}
else if (address_grab < 0xFF000000){
storage_area = 0x0CFC; //CONFIG_DATA
mpc106_write_device(mpc_config_addr, value_insert, bit_num);
grab_macmem_ptr = machine_feexxx_mem;
}
else if (address_grab < 0xFF800000){
@ -647,7 +664,7 @@ void address_quickinsert_translate(uint32_t address_grab, uint32_t value_insert,
void address_quickgrab_translate(uint32_t address_grab, uint32_t value_extract, uint8_t bit_num){
//Grab a value from memory into a register
printf("Grabbing from address %x", address_grab);
printf("Grabbing from address %x \n", address_grab);
uint32_t storage_area = 0;
uint32_t grab_batl = 537;
@ -757,6 +774,13 @@ void address_quickgrab_translate(uint32_t address_grab, uint32_t value_extract,
printf("\n Read from Serial: %x \n", return_value);
return;
}
else if ((address_grab >= 0xF3014000) && (address_grab < 0xF3015000)){
davbus_address = storage_area;
davbus_read();
return_value = davbus_read_word;
printf("\n Read from DAVBus: %x \n", return_value);
return;
}
else if ((address_grab >= 0xF3015000) && (address_grab < 0xF3016000)){
mac_swim3_address = storage_area;
mac_swim3_read();
@ -771,9 +795,9 @@ void address_quickgrab_translate(uint32_t address_grab, uint32_t value_extract,
printf("\n Read from CUDA: %x \n", return_value);
return;
}
if ((address_grab >= 0xF3040000) && (address_grab < 0xF3080000)){
openpic_address = address_grab - 0x80000000;
openpic_write();
else if ((address_grab >= 0xF3040000) && (address_grab < 0xF3080000)){
openpic_address = storage_area - 0x3000000;
openpic_read();
return_value = openpic_write_word;
return;
}
@ -790,16 +814,18 @@ void address_quickgrab_translate(uint32_t address_grab, uint32_t value_extract,
grab_macmem_ptr = machine_f8xxxx_mem;
}
else if (address_grab < 0xFEC00000){
storage_area = address_grab % 65536;
grab_macmem_ptr = machine_fexxxx_mem;
mpc106_address = address_grab % 65536;
mpc106_read();
return_value = mpc106_read_word;
return;
}
else if (address_grab < 0xFEE00000){
return_value = (bit_num == 1)? (mpc106_address & 0xFF):(bit_num == 2)?(mpc106_address & 0xFFFF):mpc106_address;
return;
}
else if (address_grab < 0xFF000000){
storage_area = 0x0CFC; //CONFIG_DATA
grab_macmem_ptr = machine_feexxx_mem;
return_value = mpc106_read_device(mpc_config_addr, bit_num);
return;
}
else if (address_grab < 0xFF800000){
storage_area = address_grab % 4096;

5
ppcopcodes.cpp
View File

@ -1437,9 +1437,10 @@ void ppc_bc(){
ppc_next_instruction_address = (ppc_state.ppc_pc + br_bd);
grab_branch = 1;
}
/*
else{
printf("BRANCH FAILED: %d %d", ctr_ok, cnd_ok);
}
}*/
}
void ppc_bca(){
@ -1947,7 +1948,7 @@ void ppc_lbz(){
grab_d = (uint32_t)((int32_t)((int16_t)(ppc_cur_instruction & 0xFFFF)));
ppc_effective_address = (reg_a == 0)?grab_d:(ppc_result_a + grab_d);
address_quickgrab_translate(ppc_effective_address, ppc_result_d, 1);
printf("LBZ Storage Area: %x \n",ppc_effective_address);
//printf("LBZ Storage Area: %x \n",ppc_effective_address);
ppc_result_d = return_value;
return_value = 0;
ppc_store_result_regd();