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; }