auto R65816::op_jmp_iaddr() {
aa.l = readPC();
aa.h = readPC();
rd.l = readAddr(aa.w + 0);
L rd.h = readAddr(aa.w + 1);
r.pc.w = rd.w;
}
auto R65816::op_jmp_iladdr() {
aa.l = readPC();
aa.h = readPC();
rd.l = readAddr(aa.w + 0);
rd.h = readAddr(aa.w + 1);
L rd.b = readAddr(aa.w + 2);
r.pc.d = rd.d;
}
void readandprintaddr(char reg, char * desc) {
uint64_t address = readAddr(reg);
int highaddr = (address >> 32);
long lowaddr = (address & 0xffffffff);
uart_puts(desc);
uart_puts(": 0x");
itoa(highaddr, buffer, 16);
uart_puts(buffer);
ltoa(lowaddr, buffer, 16);
uart_puts(buffer);
uart_puts("\r\n");
}
int sendMsg(){
struct sockaddr_l2 addrDest = {0};
char buff[6] = "Salut";
int sock;
readAddr(&addrDest);
if ((sock = socket(AF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP)) < 0) {
perror("SendMsg socket create");
return;
}
if(connect(sock, (struct sockaddr*)&addrDest, sizeof(addrDest))<0){
perror("SendMsg connect");
return;
}
write (sock, buff, sizeof(buff));
close(sock);
}
int main(void){
printf("START\n");
int readCart = 1;
uint8_t ROMmakeup;
uint8_t ROMspeed;
uint8_t bankSize;
uint8_t ROMtype;
uint8_t ROMsize;
uint8_t SRAMsize;
uint8_t country;
uint8_t license;
uint8_t version;
uint32_t VBLvector;
uint32_t resetVector;
uint32_t inverseChecksum;
int i = 0;
int x = 0;
// ------------- Set Registers -----------------------------------------------------
wiringPiSetup () ;
mcp23s17Setup (BASE, 0, _IOControls) ;
mcp23s17Setup (BASE+100, 0,_SNESAddressPins) ;
mcp23s17Setup (BASE+200, 0, _SNESBankAndData) ;
initInterface_SPI();
//----------------------------------------------------------------------------------------------------
/*
# GPA0: /RD
# GPA1: /RESET
# GPA2: /WR
# GPA3: /CS
# GPA4: CART MOSFET
# GPA7: /IRQ
*/
setIOControl(_RD + _CS + _POWER);
//time.sleep(.25)
//-----------------------------------------------------
char cartname[21] = "";
uint32_t headerAddr =32704;
int isLowROM = 1;
int isValid = 0;
if (compareROMchecksums(32704,1) == 1){
printf("Checksums matched\n");
ROMmakeup = readOffset(headerAddr + 21,isLowROM);
ROMspeed = getUpNibble(ROMmakeup);
bankSize = getLowNibble(ROMmakeup);
if (bankSize == 0){
printf("ROM Makeup match for LoROM. Assuming this is the case!\n");
isLowROM = 1;
isValid = 1;
}
else if (bankSize == 1){
printf("ROM Makeup match for HiROM. Assuming this is the case!\n");
headerAddr = 65472;
isLowROM = 0;
isValid = 1;
}
else
printf("Bank Configuration Read Error\n");
}
else
printf("Checksums did not match. Either no cart, or cart read error\n");
//#--- Debug. Manually set bank size ----------
//#isLowROM = 1
//#-------------------------------------------
uint32_t currentAddr = headerAddr;
gotoOffset(headerAddr, isLowROM);
for (i = headerAddr; i <(headerAddr + 20); i++ )
cartname[x++] = readOffset(i,isLowROM);
//cartname = cartname.rstrip()
ROMmakeup = readAddr(headerAddr + 21,isLowROM);
ROMspeed = getUpNibble(ROMmakeup);
bankSize = getLowNibble(ROMmakeup);
ROMtype = readAddr(headerAddr + 22,isLowROM);
ROMsize = getROMsize(headerAddr + 23, isLowROM);
SRAMsize = readAddr(headerAddr + 24,isLowROM);
country = readAddr(headerAddr + 25,isLowROM);
license = readAddr(headerAddr + 26,isLowROM);
version = readAddr(headerAddr + 27,isLowROM);
currentAddr = headerAddr + 28;
inverseChecksum = readAddr(currentAddr,isLowROM);
inverseChecksum += readAddr(currentAddr+1,isLowROM) * 256;
currentAddr = headerAddr + 30;
ROMchecksum = readAddr(currentAddr,isLowROM);
ROMchecksum += readAddr(currentAddr+1,isLowROM) * 256;
currentAddr = headerAddr + 32;
VBLvector = readAddr(currentAddr,isLowROM);
VBLvector += readAddr(currentAddr+1,isLowROM) * 256;
currentAddr = headerAddr + 34;
resetVector = readAddr(currentAddr,isLowROM);
resetVector += readAddr(currentAddr+1,isLowROM) * 256;
int16_t numberOfPages = getNumberOfPages(ROMsize,isLowROM);
printf("Game Title: %s\n", cartname);
printf("ROM Makeup: %d\n", ROMmakeup);
printf(" - ROM Speed: %d\n", ROMspeed);
printf(" - Bank Size: %d\n", bankSize);
printf("ROM Type: %d\n", ROMtype);
if (ROMtype == 243){
printf("\nCapcom CX4 ROM Type detected!");
CX4setROMsize(ROMsize);
printf("\n");
}
printf("ROM Size: %d MBits\n", ROMsize);
int convertedSRAMsize = 0;
printf("SRAM Size: Value: %d",SRAMsize);
if (convertedSRAMsize == 0)
if (SRAMsize <= 12 && SRAMsize > 0)
convertedSRAMsize = 1<<(SRAMsize +3);
printf(" | %d KBits\n", convertedSRAMsize);
printf("Country: %d\n", country);
printf( "License: %d\n", license);
printf( "Version: 1.%d\n",version);
printf( "Inverse Checksum: %x\n", inverseChecksum);
printf( "ROM Checksum: %x\n", + ROMchecksum);
printf( " - Checksums xOr'ed: %x\n", (inverseChecksum | ROMchecksum) );
printf( "\n");
printf( "VBL Vector: %d\n", VBLvector);
printf( "Reset Vector: %d\n", resetVector);
printf( "\n");
printf( "Number of pages: %d\n", numberOfPages );
printf( "\n");
uint8_t *dump;
char fileName[30];
//dump = returnNULLheader()
int y = 0;
uint32_t sizeOfCartInBytes = 0;
uint32_t pageChecksum = 0;
//uint32_t totalChecksum = 0;
uint32_t currentByte = 0;
uint32_t numberOfRemainPages = 0;
uint32_t firstNumberOfPages = 0;
time_t timeStart = 0;
time_t timeEnd = 0;
/*
if directory != "" :
if directory[len(directory)-1] != "/":
directory += "/"
g = open("/tmp/insertedCart",'w')*/
if (isValid == 1){
//g.write(cartname)
if (readCart == 1){
//if os.path.exists(directory + cartname + '.smc'){
// printf("Cart has already been ripped, not ripping again!");
// readCart = 0;
}
else if (readCart == 0)
printf("Will not rip cart due to OPTs");
if (readCart == 1){
numberOfRemainPages = 0;
firstNumberOfPages = numberOfPages;
timeStart = time(NULL);
//f = open(directory + cartname + '.smc','w')
FILE *romfile;
stpcpy(fileName, cartname);
strcat(fileName, ".smc");
romfile = fopen( fileName, "wb");
if (isLowROM == 1){
sizeOfCartInBytes = numberOfPages * 32768;
dump = calloc(sizeOfCartInBytes, sizeof(uint8_t) );
printf("Reading %d Low ROM pages.\n", numberOfPages);
//ROM Ripper
ripROM(0x00, isLowROM, firstNumberOfPages, dump);
}
else{
sizeOfCartInBytes = numberOfPages * 65536;
dump = calloc(sizeOfCartInBytes, sizeof(uint8_t) );
if (numberOfPages > 64){
numberOfRemainPages = ( numberOfPages - 64 ); //# number of pages over 64
printf("Reading first 64 of %d Hi ROM pages.\n", numberOfPages);
firstNumberOfPages = 64;
}
else
printf("Reading %d Hi ROM pages.\n", numberOfPages);
/*dump =*/ ripROM(0xC0, isLowROM, firstNumberOfPages, dump);
if (numberOfRemainPages > 0){
printf("Reading last %d of High ROM pages.\n", numberOfRemainPages);
/*dump +=*/ ripROM(0x40, isLowROM, numberOfRemainPages, dump);
}
}
printf("\n");
printf("Entire Checksum: %x\n", totalChecksum);
printf("\n");
printf("Header Checksum: %x\n", ROMchecksum );
totalChecksum = ( totalChecksum & 0xFFFF );
printf("16-bit Generated Checksum: %x\n", totalChecksum);
if (totalChecksum == ROMchecksum)
printf("-------------------------- CHECKSUMS MATCH!\n");
else
printf("----------WARNING: CHECKSUMS DO NOT MATCH: %x != %x\n", totalChecksum, ROMchecksum);
timeEnd = time(NULL);
//print ""
printf("Address Writes - LowByte: %d HighByte: %d | Bank Writes: %d | Data Reads: %d\n", LowByteWrites, HighByteWrites, BankWrites, DataReads);
printf("\nIt took %d seconds to read cart\n", timeEnd - timeStart);
printf("Size of Cart in Bytes: %d\n", sizeOfCartInBytes);
fwrite(dump, sizeof(uint8_t), sizeOfCartInBytes, romfile);
fclose(romfile);
free(dump);
}
/*if (readSRAM == 1){
f = open(directory + cartname + '.srm','w')
timeStart = time.time()
dump = ripSRAM(convertedSRAMsize,ROMsize,isLowROM)
timeEnd = time.time()
print ""
print "It took " + str(timeEnd - timeStart) + "seconds to read SRAM Data"
f.write(dump)
f.close
}*/
}
else{
//g.write("NULL")
//g.close
}
//#--- Clean Up & End Script ------------------------------------------------------
shutdownInterface_SPI();
}
bool tryPatch(void *data, size_t size)
{
// Find the DSDI reserved space in the file
addr_t patchOffset = quickFind(static_cast<data_t *>(data), dldiMagicString, size, sizeof(dldiMagicString) / sizeof(char));
// no DLDI section
if (patchOffset < 0)
return false;
data_t *pDH = mpcf_dldi;
data_t *pAH = static_cast<data_t *>(data) + patchOffset;
if (pDH[DO_driverSize] > pAH[DO_allocatedSpace])
{
printf("Not enough space for patch. Available %d bytes, need %d bytes\n", 1 << pAH[DO_allocatedSpace], 1 << pDH[DO_driverSize]);
return false;
}
if (memcmp(&pAH[DO_friendlyName], "Default (No interface)", 22))
{
printf("Would have been a candidate for auto-patch DLDI, but there was already a patch installed.");
return false;
}
//----should be able to patch OK-----
addr_t memOffset; // Offset of DLDI after the file is loaded into memory
addr_t relocationOffset; // Value added to all offsets within the patch to fix it properly
addr_t ddmemOffset; // Original offset used in the DLDI file
addr_t ddmemStart; // Start of range that offsets can be in the DLDI file
addr_t ddmemEnd; // End of range that offsets can be in the DLDI file
addr_t ddmemSize; // Size of range that offsets can be in the DLDI file
addr_t addrIter;
memOffset = readAddr(pAH, DO_text_start);
if (!memOffset)
memOffset = readAddr(pAH, DO_startup) - DO_code;
ddmemOffset = readAddr(pDH, DO_text_start);
relocationOffset = memOffset - ddmemOffset;
printf("AUTO-PATCHING DLDI to MPCF! Lucky you!\n\n");
printf("Old driver: %s\n", &pAH[DO_friendlyName]);
printf("New driver: %s\n", &pDH[DO_friendlyName]);
printf("\n");
printf("Position in file: 0x%08X\n", patchOffset);
printf("Position in memory: 0x%08X\n", memOffset);
printf("Patch base address: 0x%08X\n", ddmemOffset);
printf("Relocation offset: 0x%08X\n", relocationOffset);
printf("\n");
ddmemStart = readAddr(pDH, DO_text_start);
ddmemSize = 1 << pDH[DO_driverSize];
ddmemEnd = ddmemStart + ddmemSize;
// Remember how much space is actually reserved
pDH[DO_allocatedSpace] = pAH[DO_allocatedSpace];
// Copy the DLDI patch into the application
memcpy(pAH, pDH, sizeof(mpcf_dldi));
// Fix the section pointers in the header
writeAddr(pAH, DO_text_start, readAddr(pAH, DO_text_start) + relocationOffset);
writeAddr(pAH, DO_data_end, readAddr(pAH, DO_data_end) + relocationOffset);
writeAddr(pAH, DO_glue_start, readAddr(pAH, DO_glue_start) + relocationOffset);
writeAddr(pAH, DO_glue_end, readAddr(pAH, DO_glue_end) + relocationOffset);
writeAddr(pAH, DO_got_start, readAddr(pAH, DO_got_start) + relocationOffset);
writeAddr(pAH, DO_got_end, readAddr(pAH, DO_got_end) + relocationOffset);
writeAddr(pAH, DO_bss_start, readAddr(pAH, DO_bss_start) + relocationOffset);
writeAddr(pAH, DO_bss_end, readAddr(pAH, DO_bss_end) + relocationOffset);
// Fix the function pointers in the header
writeAddr(pAH, DO_startup, readAddr(pAH, DO_startup) + relocationOffset);
writeAddr(pAH, DO_isInserted, readAddr(pAH, DO_isInserted) + relocationOffset);
writeAddr(pAH, DO_readSectors, readAddr(pAH, DO_readSectors) + relocationOffset);
writeAddr(pAH, DO_writeSectors, readAddr(pAH, DO_writeSectors) + relocationOffset);
writeAddr(pAH, DO_clearStatus, readAddr(pAH, DO_clearStatus) + relocationOffset);
writeAddr(pAH, DO_shutdown, readAddr(pAH, DO_shutdown) + relocationOffset);
if (pDH[DO_fixSections] & FIX_ALL)
// Search through and fix pointers within the data section of the file
for (addrIter = readAddr(pDH, DO_text_start) - ddmemStart; addrIter < readAddr(pDH, DO_data_end) - ddmemStart; ++addrIter)
if (ddmemStart <= readAddr(pAH, addrIter) && readAddr(pAH, addrIter) < ddmemEnd)
writeAddr(pAH, addrIter, readAddr(pAH, addrIter) + relocationOffset);
if (pDH[DO_fixSections] & FIX_GLUE)
// Search through and fix pointers within the glue section of the file
for (addrIter = readAddr(pDH, DO_glue_start) - ddmemStart; addrIter < readAddr(pDH, DO_glue_end) - ddmemStart; ++addrIter)
if (ddmemStart <= readAddr(pAH, addrIter) && readAddr(pAH, addrIter) < ddmemEnd)
writeAddr(pAH, addrIter, readAddr(pAH, addrIter) + relocationOffset);
if (pDH[DO_fixSections] & FIX_GOT)
// Search through and fix pointers within the Global Offset Table section of the file
for (addrIter = readAddr(pDH, DO_got_start) - ddmemStart; addrIter < readAddr(pDH, DO_got_end) - ddmemStart; ++addrIter)
if (ddmemStart <= readAddr(pAH, addrIter) && readAddr(pAH, addrIter) < ddmemEnd)
writeAddr(pAH, addrIter, readAddr(pAH, addrIter) + relocationOffset);
if (pDH[DO_fixSections] & FIX_BSS)
// Initialise the BSS to 0
memset(&pAH[readAddr(pDH, DO_bss_start) - ddmemStart] , 0, readAddr(pDH, DO_bss_end) - readAddr(pDH, DO_bss_start));
return true;
}
int runNds (const void* loader, u32 loaderSize, u32 cluster, bool initDisc, bool dldiPatchNds, int argc, const char** argv)
{
char* argStart;
u16* argData;
u16 argTempVal = 0;
int argSize;
const char* argChar;
irqDisable(IRQ_ALL);
// Direct CPU access to VRAM bank C
VRAM_C_CR = VRAM_ENABLE | VRAM_C_LCD;
// Load the loader/patcher into the correct address
vramcpy (LCDC_BANK_C, loader, loaderSize);
// Set the parameters for the loader
// STORED_FILE_CLUSTER = cluster;
writeAddr ((data_t*) LCDC_BANK_C, STORED_FILE_CLUSTER_OFFSET, cluster);
// INIT_DISC = initDisc;
writeAddr ((data_t*) LCDC_BANK_C, INIT_DISC_OFFSET, initDisc);
// WANT_TO_PATCH_DLDI = dldiPatchNds;
writeAddr ((data_t*) LCDC_BANK_C, WANT_TO_PATCH_DLDI_OFFSET, dldiPatchNds);
// Give arguments to loader
argStart = (char*)LCDC_BANK_C + readAddr((data_t*)LCDC_BANK_C, ARG_START_OFFSET);
argStart = (char*)(((int)argStart + 3) & ~3); // Align to word
argData = (u16*)argStart;
argSize = 0;
for (; argc > 0 && *argv; ++argv, --argc)
{
for (argChar = *argv; *argChar != 0; ++argChar, ++argSize)
{
if (argSize & 1)
{
argTempVal |= (*argChar) << 8;
*argData = argTempVal;
++argData;
}
else
{
argTempVal = *argChar;
}
}
if (argSize & 1)
{
*argData = argTempVal;
++argData;
}
argTempVal = 0;
++argSize;
}
*argData = argTempVal;
writeAddr ((data_t*) LCDC_BANK_C, ARG_START_OFFSET, (addr_t)argStart - (addr_t)LCDC_BANK_C);
writeAddr ((data_t*) LCDC_BANK_C, ARG_SIZE_OFFSET, argSize);
// Patch the loader with a DLDI for the card
if (!dldiPatchLoader ((data_t*)LCDC_BANK_C, loaderSize, initDisc)) {
return 3;
}
irqDisable(IRQ_ALL);
// Give the VRAM to the ARM7
VRAM_C_CR = VRAM_ENABLE | VRAM_C_ARM7_0x06000000;
// Reset into a passme loop
REG_EXMEMCNT |= ARM7_OWNS_ROM | ARM7_OWNS_CARD;
*((vu32*)0x027FFFFC) = 0;
*((vu32*)0x027FFE04) = (u32)0xE59FF018;
*((vu32*)0x027FFE24) = (u32)0x027FFE04;
swiSoftReset();
return true;
}
static bool dldiPatchLoader (data_t *binData, u32 binSize, bool clearBSS)
{
addr_t memOffset; // Offset of DLDI after the file is loaded into memory
addr_t patchOffset; // Position of patch destination in the file
addr_t relocationOffset; // Value added to all offsets within the patch to fix it properly
addr_t ddmemOffset; // Original offset used in the DLDI file
addr_t ddmemStart; // Start of range that offsets can be in the DLDI file
addr_t ddmemEnd; // End of range that offsets can be in the DLDI file
addr_t ddmemSize; // Size of range that offsets can be in the DLDI file
addr_t addrIter;
data_t *pDH;
data_t *pAH;
size_t dldiFileSize = 0;
// Find the DLDI reserved space in the file
patchOffset = quickFind (binData, dldiMagicLoaderString, binSize, sizeof(dldiMagicLoaderString));
if (patchOffset < 0) {
// does not have a DLDI section
return false;
}
pDH = (data_t*)(io_dldi_data);
pAH = &(binData[patchOffset]);
if (*((u32*)(pDH + DO_ioType)) == DEVICE_TYPE_DLDI) {
// No DLDI patch
return false;
}
if (pDH[DO_driverSize] > pAH[DO_allocatedSpace]) {
// Not enough space for patch
return false;
}
dldiFileSize = 1 << pDH[DO_driverSize];
memOffset = readAddr (pAH, DO_text_start);
if (memOffset == 0) {
memOffset = readAddr (pAH, DO_startup) - DO_code;
}
ddmemOffset = readAddr (pDH, DO_text_start);
relocationOffset = memOffset - ddmemOffset;
ddmemStart = readAddr (pDH, DO_text_start);
ddmemSize = (1 << pDH[DO_driverSize]);
ddmemEnd = ddmemStart + ddmemSize;
// Remember how much space is actually reserved
pDH[DO_allocatedSpace] = pAH[DO_allocatedSpace];
// Copy the DLDI patch into the application
vramcpy (pAH, pDH, dldiFileSize);
// Fix the section pointers in the header
writeAddr (pAH, DO_text_start, readAddr (pAH, DO_text_start) + relocationOffset);
writeAddr (pAH, DO_data_end, readAddr (pAH, DO_data_end) + relocationOffset);
writeAddr (pAH, DO_glue_start, readAddr (pAH, DO_glue_start) + relocationOffset);
writeAddr (pAH, DO_glue_end, readAddr (pAH, DO_glue_end) + relocationOffset);
writeAddr (pAH, DO_got_start, readAddr (pAH, DO_got_start) + relocationOffset);
writeAddr (pAH, DO_got_end, readAddr (pAH, DO_got_end) + relocationOffset);
writeAddr (pAH, DO_bss_start, readAddr (pAH, DO_bss_start) + relocationOffset);
writeAddr (pAH, DO_bss_end, readAddr (pAH, DO_bss_end) + relocationOffset);
// Fix the function pointers in the header
writeAddr (pAH, DO_startup, readAddr (pAH, DO_startup) + relocationOffset);
writeAddr (pAH, DO_isInserted, readAddr (pAH, DO_isInserted) + relocationOffset);
writeAddr (pAH, DO_readSectors, readAddr (pAH, DO_readSectors) + relocationOffset);
writeAddr (pAH, DO_writeSectors, readAddr (pAH, DO_writeSectors) + relocationOffset);
writeAddr (pAH, DO_clearStatus, readAddr (pAH, DO_clearStatus) + relocationOffset);
writeAddr (pAH, DO_shutdown, readAddr (pAH, DO_shutdown) + relocationOffset);
if (pDH[DO_fixSections] & FIX_ALL) {
// Search through and fix pointers within the data section of the file
for (addrIter = (readAddr(pDH, DO_text_start) - ddmemStart); addrIter < (readAddr(pDH, DO_data_end) - ddmemStart); addrIter++) {
if ((ddmemStart <= readAddr(pAH, addrIter)) && (readAddr(pAH, addrIter) < ddmemEnd)) {
writeAddr (pAH, addrIter, readAddr(pAH, addrIter) + relocationOffset);
}
}
}
if (pDH[DO_fixSections] & FIX_GLUE) {
// Search through and fix pointers within the glue section of the file
for (addrIter = (readAddr(pDH, DO_glue_start) - ddmemStart); addrIter < (readAddr(pDH, DO_glue_end) - ddmemStart); addrIter++) {
if ((ddmemStart <= readAddr(pAH, addrIter)) && (readAddr(pAH, addrIter) < ddmemEnd)) {
writeAddr (pAH, addrIter, readAddr(pAH, addrIter) + relocationOffset);
}
}
}
if (pDH[DO_fixSections] & FIX_GOT) {
// Search through and fix pointers within the Global Offset Table section of the file
for (addrIter = (readAddr(pDH, DO_got_start) - ddmemStart); addrIter < (readAddr(pDH, DO_got_end) - ddmemStart); addrIter++) {
if ((ddmemStart <= readAddr(pAH, addrIter)) && (readAddr(pAH, addrIter) < ddmemEnd)) {
writeAddr (pAH, addrIter, readAddr(pAH, addrIter) + relocationOffset);
}
}
}
if (clearBSS && (pDH[DO_fixSections] & FIX_BSS)) {
// Initialise the BSS to 0, only if the disc is being re-inited
memset (&pAH[readAddr(pDH, DO_bss_start) - ddmemStart] , 0, readAddr(pDH, DO_bss_end) - readAddr(pDH, DO_bss_start));
}
return true;
}
