/** * Allocate memory for a packet buffer for a given netbuf. * * @param buf the netbuf for which to allocate a packet buffer * @param size the size of the packet buffer to allocate * @return pointer to the allocated memory * NULL if no memory could be allocated */ int analyzeNand(int first,int last,int mode) { int foundBB, foundEDC, block, page, status; unsigned long offset; unsigned char* pagebuf; unsigned char EDC[3]; BBMnand.BadBlocksCount = 0; pagebuf = (unsigned char *)malloc(sfc.page_sz_phys); console_clrscr(); printf("\nStarting Analyzation!\n\n"); for (block=first; block < last; block++) { printf("\rCurrently @ block %04X",block); foundBB = 0; foundEDC= 0; for (page=0; page < sfc.pages_in_block; page++) { offset = (block*sfc.block_sz)+(page*sfc.page_sz); status = sfcx_read_page(pagebuf,offset,1); if(!sfcx_is_pageempty(pagebuf) && !sfcx_is_pagevalid(pagebuf)) foundBB = 1; if(status & STATUS_BB_ER) foundBB = 1; if(mode){ memset(EDC,0,0x3); memcpy(EDC,&pagebuf[sfc.page_sz_phys-0x3],0x3); sfcx_calcecc(pagebuf); if (memcmp(EDC,&pagebuf[sfc.page_sz_phys-0x3],0x3)) foundEDC = 1; } } if (foundBB){ BBMnand.BadBlocks[BBMnand.BadBlocksCount++] = block; printf("\nBad Block found @ %04X\n",block); } if (foundEDC){ BBMnand.EDCerrorBlocks[BBMnand.EDCerrorCount++] = block; printf("\nEDC Error found @ %04X\n",block); } } return 0; }
int flash_from_file(const char *filename, int raw) { int i, logic_pos, status = 0x200; unsigned char *block, *block_flash, *bad_block; float pct = 0.f; FILE *f = fopen(filename, "rb"); if (!f) { printf("\nError: Failed to open file: %s\n", filename); return -1; } printf("\nFlashing from %s...\n", filename); printf("0x%x block's to write...\n", sfc.size_blocks); if (!f) return -1; if (raw == -1) /* auto */ { fseek(f, 0, SEEK_END); raw = detect_read_write_modus(ftell(f)); if (raw == -1) return -1; fseek(f, 0, SEEK_SET); } block = (unsigned char*) malloc(sfc.block_sz_phys); block_flash = (unsigned char*) malloc(sfc.block_sz_phys); bad_block = (unsigned char*) malloc(sfc.block_sz_phys); unsigned nand_size = sfc.size_bytes; // Dump only 64mb on big nand if ((nand_size == NAND_SIZE_512MB) | (nand_size == NAND_SIZE_256MB)) { nand_size = NAND_SIZE_64MB; } for (i = 0; i < nand_size; i += sfc.block_sz) { memset(block, 0xFF, sizeof (block)); if (!fread(block, 1, sfc.page_sz_phys * sfc.pages_in_block, f)) { printf("Error reading ...\r\n"); return i; } pct = ((float) i / (float) (nand_size)); App.SetProgressValue(pct); // printf("Writing block: 0x%x of 0x%x (%iMB/%iMB)\r\n", sfcx_address_to_block(i) +1 , sfc.size_blocks , (i + sfc.block_sz) >> 20, nand_size >> 20); //Check for bad block sfcx_writereg(SFCX_STATUS, sfcx_readreg(SFCX_STATUS)); sfcx_writereg(SFCX_ADDRESS, i); sfcx_writereg(SFCX_COMMAND, raw ? PHY_PAGE_TO_BUF : LOG_PAGE_TO_BUF); // Wait Busy while ((status = sfcx_readreg(SFCX_STATUS)) & 1); if ((!raw)) { logic_pos = sfcx_readreg(SFCX_PHYSICAL); if (!(logic_pos & 0x04000000)) /* shouldn't happen, unless the existing image is broken. just assume the block is okay. */ { printf("Error: Uh, oh, don't know. Reading @ block %08x failed. logic_pos: %i\r\n", i, sfcx_address_to_block(logic_pos)); logic_pos = i; } logic_pos &= 0x3fffe00; if (logic_pos != i) { printf("Relocating/moving bad block from position 0x%x to 0x%x\r\n", sfcx_address_to_block(i), sfcx_address_to_block(logic_pos)); } } else if (status & 0x40) //Bad Block Management { printf("Bad block ...\r\n"); #if 0 logic_pos = sfc.last_bad_block_pos * sfc.block_sz; sfc.last_bad_block_pos--; sfcx_set_blocknumber(block, sfcx_address_to_block(i)); sfcx_calcecc((int*) block); if (logic_pos != i) { printf("Relocating/moving bad block from position 0x%x to 0x%x\n", sfcx_address_to_block(i), sfcx_address_to_block(logic_pos)); } #endif } else { logic_pos = i; } #if 0 if (sfc.last_bad_block_pos == sfcx_address_to_block(i)) { //We reach the the last entry bad block in reserved area printf("\nWriting only to last entry bad block in the reserved area."); break; } #endif //Erase block in Nand sfcx_erase_block(logic_pos); //Write block to Nand sfcx_write_block(block, logic_pos); } printf("\nWrite done\n"); fclose(f); free(block); free(block_flash); free(bad_block); if (App.Warning("Flashing is complete, reboot the console?") == TRUE) { xenon_smc_power_reboot(); } return 0; }
/** * Allocate memory for a packet buffer for a given netbuf. * * @param buf the netbuf for which to allocate a packet buffer * @param size the size of the packet buffer to allocate * @return pointer to the allocated memory * NULL if no memory could be allocated */ int analyzeFile(char *path,int firstblock,int lastblock,int mode) { FILE *f; int foundBB, foundEDC, block, page; unsigned long filelength, offset; unsigned char* pagebuf; unsigned char EDC[3]; BBMfile.BadBlocksCount = 0; pagebuf = (unsigned char *)malloc(sfc.page_sz_phys); console_clrscr(); f = fopen(path, "rb"); if (!f){ printf(" ! Can't open %s\n",path); waitforexit(); } fseek(f, 0, SEEK_END); filelength=ftell(f); fseek(f, 0, SEEK_SET); printf("\nStarting Analyzing!\n\n"); for (block = firstblock; block < lastblock; block++) { printf("\rCurrently @ block %04X",block); foundBB = 0; foundEDC= 0; for (page = 0; page < sfc.pages_in_block; page++) { offset = (block*sfc.block_sz_phys)+(page*sfc.page_sz_phys); memset(pagebuf,0xFF,sfc.page_sz_phys); fseek(f,offset,SEEK_SET); fread(pagebuf,1,sfc.page_sz_phys,f); if(!sfcx_is_pageempty(pagebuf) && (!sfcx_is_pagevalid(pagebuf))) foundBB = 1; if(mode == (1||2)){ memset(EDC,0,0x3); memcpy(EDC,&pagebuf[sfc.page_sz_phys-0x3],0x3); sfcx_calcecc(pagebuf); if (memcmp(EDC,&pagebuf[sfc.page_sz_phys-0x3],0x3)) foundEDC = 1; } } if (foundBB){ BBMfile.BadBlocks[BBMfile.BadBlocksCount++] = block; printf("\nBad Block found @ %04X\n",block); } if (foundEDC){ BBMfile.EDCerrorBlocks[BBMfile.EDCerrorCount++] = block; printf("\nEDC Error found @ %04X\n",block); } } fclose(f); return 0; }
/** * Allocate memory for a packet buffer for a given netbuf. * * @param buf the netbuf for which to allocate a packet buffer * @param size the size of the packet buffer to allocate * @return pointer to the allocated memory * NULL if no memory could be allocated */ int updateXeLL(char *path) { FILE *f; int i, j, k, status, startblock, current, offsetinblock, blockcnt, filelength; unsigned char *updxell, *user, *spare; console_clrscr(); /* Check if updxell.bin is present */ f = fopen(path, "rb"); if (!f){ printf(" ! Can't find / open %s\n",path); waitforexit(); } if (sfc.initialized != SFCX_INITIALIZED){ fclose(f); printf(" ! sfcx is not initialized! Unable to update XeLL in NAND!\n"); waitforexit(); } /* Check filesize of updxell.bin, only accept full 256kb binaries */ fseek(f, 0, SEEK_END); filelength=ftell(f); fseek(f, 0, SEEK_SET); if (filelength != XELL_SIZE){ fclose(f); printf(" ! %s does not have the correct size of 256kb. Aborting update!\n", path); waitforexit(); } printf(" * Update-XeLL binary found @ %s ! Looking for XeLL binary in NAND now.\n", path); for (k = 0; k < XELL_OFFSET_COUNT; k++) { current = xelloffsets[k]; offsetinblock = current % sfc.block_sz; startblock = current/sfc.block_sz; blockcnt = offsetinblock ? (XELL_SIZE/sfc.block_sz)+1 : (XELL_SIZE/sfc.block_sz); spare = (unsigned char*)malloc(blockcnt*sfc.pages_in_block*sfc.meta_sz); if(!spare){ printf(" ! Error while memallocating filebuffer (spare)\n"); waitforexit(); } user = (unsigned char*)malloc(blockcnt*sfc.block_sz); if(!user){ printf(" ! Error while memallocating filebuffer (user)\n"); waitforexit(); } j = 0; for (i = (startblock*sfc.pages_in_block); i< (startblock+blockcnt)*sfc.pages_in_block; i++) { sfcx_read_page(sfcx_page, (i*sfc.page_sz), 1); //Split rawpage into user & spare memcpy(&user[j*sfc.page_sz],&sfcx_page[0x0],sfc.page_sz); memcpy(&spare[j*sfc.meta_sz],&sfcx_page[sfc.page_sz],sfc.meta_sz); j++; } if (memcmp(&user[offsetinblock+(XELL_FOOTER_OFFSET)],XELL_FOOTER,XELL_FOOTER_LENGTH) == 0){ printf(" * XeLL Binary found @ 0x%08X\n", (startblock*sfc.block_sz)+offsetinblock); updxell = (unsigned char*)malloc(XELL_SIZE); if(!updxell){ printf(" ! Error while memallocating filebuffer (updxell)\n"); waitforexit(); } status = fread(updxell,1,XELL_SIZE,f); if (status != XELL_SIZE){ fclose(f); printf(" ! Error reading file from %s\n", path); waitforexit(); } if (!memcmp(updxell, elfhdr, 4)){ printf(" * really, we don't need an elf.\n"); waitforexit(); } if (memcmp(&updxell[XELL_FOOTER_OFFSET],XELL_FOOTER, XELL_FOOTER_LENGTH)){ printf(" ! XeLL does not seem to have matching footer, Aborting update!\n"); waitforexit(); } fclose(f); memcpy(&user[offsetinblock], updxell,XELL_SIZE); //Copy over updxell.bin printf(" * Writing to NAND!\n"); j = 0; for (i = startblock*sfc.pages_in_block; i < (startblock+blockcnt)*sfc.pages_in_block; i ++) { if (!(i%sfc.pages_in_block)) sfcx_erase_block(i*sfc.page_sz); /* Copy user & spare data together in a single rawpage */ memcpy(&sfcx_page[0x0],&user[j*sfc.page_sz],sfc.page_sz); memcpy(&sfcx_page[sfc.page_sz],&spare[j*sfc.meta_sz],sfc.meta_sz); j++; if (!(sfcx_is_pageempty(sfcx_page))) // We dont need to write to erased pages { memset(&sfcx_page[sfc.page_sz+0x0C],0x0, 4); //zero only EDC bytes sfcx_calcecc((unsigned int *)sfcx_page); //recalc EDC bytes sfcx_write_page(sfcx_page, i*sfc.page_sz); } } printf(" * XeLL flashed! Reboot the xbox to enjoy the new build\n"); for(;;); } } printf(" ! Couldn't locate XeLL binary in NAND. Aborting!\n"); waitforexit(); }