int CARD_ReadUnaligned(card_file *cardfile, void *buffer, unsigned int length, unsigned int offset, int slot) {
void *dst = buffer;
u8 *read_buffer = (u8*)memalign(32,card_sectorsize[slot]);
int ret = CARD_ERROR_READY;
print_gecko("Unaligned read dst %08X offset %08X length %i\r\n", dst, offset, length);
// Unaligned because we're in the middle of a sector, read partial
ret = CARD_Read(cardfile, read_buffer, card_sectorsize[slot], offset-(offset&0x1ff));
print_gecko("CARD_Read offset %08X length %i\r\n", offset-(offset&0x1ff), card_sectorsize[slot]);
if(ret != CARD_ERROR_READY) {
free(read_buffer);
return ret;
}
int amountRead = card_sectorsize[slot]-(offset&0x1ff);
int amountToCopy = length > amountRead ? amountRead : length;
memcpy(dst, read_buffer+(offset&0x1ff), amountToCopy);
dst += amountToCopy;
length -= amountToCopy;
offset += amountToCopy;
if(length != 0) {
print_gecko("Unaligned read leftovers offset %08X length %i\r\n", offset, length);
// At least this will be aligned
ret = CARD_Read(cardfile, read_buffer, card_sectorsize[slot], offset);
print_gecko("CARD_Read offset %08X length %i\r\n", offset, card_sectorsize[slot]);
if(ret != CARD_ERROR_READY) {
free(read_buffer);
return ret;
}
memcpy(dst, read_buffer, length);
}
free(read_buffer);
return ret;
}
/****************************************************************************
* LoadMCFile
* Load savebuffer from Memory Card file
***************************************************************************/
int
LoadMCFile (char *buf, int slot, char *filename, bool silent)
{
int CardError;
unsigned int blocks;
unsigned int SectorSize;
int bytesleft = 0;
int bytesread = 0;
/*** Initialize Card System ***/
memset (SysArea, 0, CARD_WORKAREA);
CARD_Init ("VBA0", "00");
/*** Try to mount the card ***/
CardError = MountCard(slot, NOTSILENT);
if (CardError == 0)
{
/*** Get Sector Size ***/
CARD_GetSectorSize (slot, &SectorSize);
if (!CardFileExists (filename, slot))
{
if (!silent)
WaitPrompt("Unable to open file");
return 0;
}
memset (&CardFile, 0, sizeof (CardFile));
CardError = CARD_Open (slot, filename, &CardFile);
blocks = CardFile.len;
if (blocks < SectorSize)
blocks = SectorSize;
if (blocks % SectorSize)
blocks += SectorSize;
memset (buf, 0, 0x22000);
bytesleft = blocks;
bytesread = 0;
while (bytesleft > 0)
{
CARD_Read (&CardFile, buf + bytesread, SectorSize, bytesread);
bytesleft -= SectorSize;
bytesread += SectorSize;
}
CARD_Close (&CardFile);
CARD_Unmount (slot);
}
else
if (slot == CARD_SLOTA)
WaitPrompt("Unable to Mount Slot A Memory Card!");
else
WaitPrompt("Unable to Mount Slot B Memory Card!");
return bytesread;
}
/****************************************************************************
* Verify Memory Card file against buffer
***************************************************************************/
static int
VerifyMCFile (char *buf, int slot, char *filename, int datasize)
{
card_file CardFile;
int CardError;
unsigned int blocks;
unsigned int SectorSize;
int bytesleft = 0;
int bytesread = 0;
verifybuffer = (u8 *)memalign(32, 262144);
memset (verifybuffer, 0, 262144);
// Get Sector Size
CARD_GetSectorSize (slot, &SectorSize);
memset (&CardFile, 0, sizeof (CardFile));
CardError = CARD_Open (slot, filename, &CardFile);
if(CardError)
{
ErrorPrompt("Unable to open file!");
}
else
{
blocks = CardFile.len;
if (blocks < SectorSize)
blocks = SectorSize;
if (blocks % SectorSize)
blocks += SectorSize;
if (blocks > (unsigned int)datasize)
blocks = datasize;
bytesleft = blocks;
bytesread = 0;
while (bytesleft > 0)
{
CardError = CARD_Read (&CardFile, verifybuffer, SectorSize, bytesread);
if (CardError || memcmp (buf + bytesread, verifybuffer, (unsigned int)bytesleft < SectorSize ? bytesleft : SectorSize) )
{
bytesread = 0;
ErrorPrompt("File integrity could not be verified!");
break;
}
bytesleft -= SectorSize;
bytesread += SectorSize;
ShowProgress ("Verifying...", bytesread, blocks);
}
CARD_Close (&CardFile);
CancelAction();
}
free(verifybuffer);
return bytesread;
}
//---------------------------------------------------------------------------------
int main() {
//---------------------------------------------------------------------------------
VIDEO_Init();
rmode = VIDEO_GetPreferredMode(NULL);
PAD_Init();
xfb = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
VIDEO_Configure(rmode);
VIDEO_SetNextFramebuffer(xfb);
VIDEO_SetBlack(FALSE);
VIDEO_Flush();
VIDEO_WaitVSync();
if(rmode->viTVMode&VI_NON_INTERLACE) VIDEO_WaitVSync();
console_init(xfb,20,64,rmode->fbWidth,rmode->xfbHeight,rmode->fbWidth*2);
VIDEO_SetNextFramebuffer(xfb);
printf("Memory Card Demo\n\n");
while (1) {
printf("Insert A card in slot B and press A\n");
do {
PAD_ScanPads();
if (PAD_ButtonsDown(0) & PAD_BUTTON_START) PSOreload();
VIDEO_WaitVSync();
} while ( !(PAD_ButtonsDown(0) & PAD_BUTTON_A));
printf("Mounting card ...\n");
CARD_Init("DEMO","00");
int SlotB_error = CARD_Mount(CARD_SLOTB, SysArea, card_removed);
printf("slot B code %d\n",SlotB_error);
int CardError;
if (SlotB_error >= 0) {
unsigned int SectorSize = 0;
CARD_GetSectorSize(CARD_SLOTB,&SectorSize);
printf("Sector size is %d bytes.\n\n",SectorSize);
char *CardBuffer = (char *)memalign(32,SectorSize);
printf("Starting directory\n");
card_dir CardDir;
card_file CardFile;
CardError = CARD_FindFirst(CARD_SLOTB, &CardDir, true);
bool found = false;
while ( CARD_ERROR_NOFILE != CardError ) {
printf("%s %s %s\n",CardDir.filename,CardDir.gamecode,CardDir.company);
CardError = CARD_FindNext(&CardDir);
if ( 0 == strcmp (DemoFileName, (char *)CardDir.filename)) found = true;
};
printf("Finished directory\n\n");
if (found) {
printf("Test file contains :- \n");
CardError = CARD_Open(CARD_SLOTB ,DemoFileName,&CardFile);
CARD_Read(&CardFile,CardBuffer,SectorSize,0);
printf("%s\n",CardBuffer);
CARD_Close(&CardFile);
CARD_Delete(CARD_SLOTB,DemoFileName);
} else {
printf("writing test file ...\n");
CardError = CARD_Create(CARD_SLOTB ,DemoFileName,SectorSize,&CardFile);
if (0 == CardError) {
time_t gc_time;
gc_time = time(NULL);
sprintf(CardBuffer,"This text was written by MemCardDemo\nat %s\n",ctime(&gc_time));
CardError = CARD_Write(&CardFile,CardBuffer,SectorSize,0);
CardError = CARD_Close(&CardFile);
}
}
CARD_Unmount(CARD_SLOTB);
free(CardBuffer);
}
}
}
int slot_load(int slot, int device)
{
char filename[MAXPATHLEN];
int filesize, done = 0;
int offset = 0;
u8 *savebuffer;
if (slot > 0)
{
GUI_MsgBoxOpen("Information","Loading State ...",1);
}
else
{
if (!sram.on)
{
GUI_WaitPrompt("Error","SRAM is disabled !");
return 0;
}
GUI_MsgBoxOpen("Information","Loading SRAM ...",1);
}
if (!device)
{
/* FAT support */
if (slot > 0)
sprintf (filename,"%s/saves/%s.gp%d", DEFAULT_PATH, rom_filename, slot - 1);
else
sprintf (filename,"%s/saves/%s.srm", DEFAULT_PATH, rom_filename);
/* Open file */
FILE *fp = fopen(filename, "rb");
if (!fp)
{
GUI_WaitPrompt("Error","Unable to open file !");
return 0;
}
/* Read size */
fseek(fp, 0, SEEK_END);
filesize = ftell(fp);
fseek(fp, 0, SEEK_SET);
/* allocate buffer */
savebuffer = (u8 *)memalign(32,filesize);
if (!savebuffer)
{
GUI_WaitPrompt("Error","Unable to allocate memory !");
fclose(fp);
return 0;
}
/* Read into buffer (2k blocks) */
while (filesize > FILECHUNK)
{
fread(savebuffer + done, FILECHUNK, 1, fp);
done += FILECHUNK;
filesize -= FILECHUNK;
}
/* Read remaining bytes */
fread(savebuffer + done, filesize, 1, fp);
done += filesize;
fclose(fp);
}
else
{
/* Memory Card support */
if (slot > 0)
sprintf(filename, "MD-%04X.gp%d", rominfo.realchecksum, slot - 1);
else
sprintf(filename, "MD-%04X.srm", rominfo.realchecksum);
/* Initialise the CARD system */
char action[64];
memset(&SysArea, 0, CARD_WORKAREA);
CARD_Init("GENP", "00");
/* CARD slot */
device--;
/* Attempt to mount the card */
if (!CardMount(device))
{
GUI_WaitPrompt("Error","Unable to mount memory card");
return 0;
}
/* Retrieve the sector size */
u32 SectorSize = 0;
int CardError = CARD_GetSectorSize(device, &SectorSize);
if (!SectorSize)
{
sprintf(action, "Invalid sector size (%d)", CardError);
GUI_WaitPrompt("Error",action);
CARD_Unmount(device);
return 0;
}
/* Open file */
card_file CardFile;
CardError = CARD_Open(device, filename, &CardFile);
if (CardError)
{
sprintf(action, "Unable to open file (%d)", CardError);
GUI_WaitPrompt("Error",action);
CARD_Unmount(device);
return 0;
}
/* Retrieve file size */
filesize = CardFile.len;
if (filesize % SectorSize)
filesize = ((filesize / SectorSize) + 1) * SectorSize;
/* Allocate buffer */
savebuffer = (u8 *)memalign(32,filesize);
if (!savebuffer)
{
GUI_WaitPrompt("Error","Unable to allocate memory !");
CARD_Close(&CardFile);
CARD_Unmount(device);
return 0;
}
/* Read file sectors */
while (filesize > 0)
{
CARD_Read(&CardFile, &savebuffer[done], SectorSize, done);
done += SectorSize;
filesize -= SectorSize;
}
CARD_Close(&CardFile);
CARD_Unmount(device);
offset = 2112;
}
if (slot > 0)
{
/* Load state */
if (!state_load(&savebuffer[offset]))
{
free(savebuffer);
GUI_WaitPrompt("Error","Unable to load state !");
return 0;
}
}
else
{
/* Load SRAM & update CRC */
memcpy(sram.sram, &savebuffer[offset], 0x10000);
sram.crc = crc32(0, sram.sram, 0x10000);
}
free(savebuffer);
GUI_MsgBoxClose();
return 1;
}
// This is only called where length = file.size
int deviceHandler_CARD_readFile(file_handle* file, void* buffer, unsigned int length){
unsigned int slot = file->fileBase>>24, ret = 0, file_no = file->fileBase&0xFFFFFF;
void *dst = buffer;
// Get the sector size
u32 SectorSize = 0;
CARD_GetSectorSize (slot, &SectorSize);
// Create the .gci header
card_stat CardStat;
GCI gci;
CARD_GetStatus(slot,file_no,&CardStat);
memset(&gci, 0xFF, sizeof(GCI));
/*** Populate the GCI ***/
memcpy(&gci.gamecode, &CardStat.gamecode, 4);
memcpy(&gci.company, &CardStat.company, 2);
gci.banner_fmt = CardStat.banner_fmt;
memcpy(&gci.filename, &CardStat.filename, 0x20);
gci.time = CardStat.time;
gci.icon_addr = CardStat.icon_addr;
gci.icon_fmt = CardStat.icon_fmt;
gci.icon_speed = CardStat.icon_speed;
gci.unknown1 = gci.unknown2 = 0;
gci.index = 32;
gci.filesize8 = (CardStat.len / 8192);
gci.comment_addr = CardStat.comment_addr;
memcpy(dst, &gci, sizeof(GCI));
dst+= sizeof(GCI);
// Re-init the card with the original file gamecode & company
char game_code[16];
memcpy(&game_code[0],&gci.gamecode, 4);
game_code[4] = 0;
CARD_SetGamecode((const char *)&game_code[0]);
memcpy(&game_code[0],&gci.company, 2);
game_code[2] = 0;
CARD_SetCompany((const char *)&game_code[0]);
// Use the original file name
char file_name[CARD_FILENAMELEN];
memset(&file_name[0],0,CARD_FILENAMELEN);
memcpy(&file_name[0], file->name,strlen(file->name)-4);
print_gecko("Try to open: [%s]\r\n",&file_name[0]);
// Read the actual file data now
char *read_buffer = NULL;
card_file *memcard_file = NULL;
memcard_file = (card_file*)memalign(32,sizeof(card_file));
if(!memcard_file) {
return -2;
}
memset(memcard_file, 0, sizeof(card_file));
// Open the Entry
if((ret = CARD_Open(slot, (const char*)&file_name[0], memcard_file)) != CARD_ERROR_NOFILE){
/* Allocate the read buffer */
u32 readSize = ((memcard_file->len % SectorSize) != 0) ?
((memcard_file->len/SectorSize)+1) * SectorSize : memcard_file->len;
read_buffer = memalign(32,SectorSize);
if(!read_buffer) {
free(memcard_file);
return -2;
}
print_gecko("Reading: [%i] bytes\r\n",readSize);
/* Read the file */
int i = 0;
for(i=0;i<(readSize/SectorSize);i++) {
ret = CARD_Read(memcard_file,read_buffer, SectorSize, i*SectorSize);
if(!ret) {
memcpy(dst,read_buffer,(i==(readSize/SectorSize)-1) ? (memcard_file->len % SectorSize):SectorSize);
}
dst+=SectorSize;
print_gecko("Read: [%i] bytes ret [%i]\r\n",SectorSize,ret);
}
}
else {
print_gecko("ret: [%i]\r\n",ret);
}
CARD_Close(memcard_file);
free(read_buffer);
free(memcard_file);
return !ret ? length : ret;
}
/****************************************************************************
* LoadMCFile
* Load savebuffer from Memory Card file
***************************************************************************/
int
LoadMCFile (char *buf, int slot, char *filename, bool silent)
{
card_file CardFile;
int CardError;
unsigned int blocks;
unsigned int SectorSize;
int bytesleft = 0;
int bytesread = 0;
// Try to mount the card
CardError = MountMC(slot, NOTSILENT);
if (CardError == 0)
{
// Get Sector Size
CARD_GetSectorSize (slot, &SectorSize);
memset (&CardFile, 0, sizeof (CardFile));
CardError = CARD_Open (slot, filename, &CardFile);
if(CardError)
{
if(!silent)
ErrorPrompt("Unable to open file!");
}
else
{
blocks = CardFile.len;
if (blocks < SectorSize)
blocks = SectorSize;
if (blocks % SectorSize)
blocks += SectorSize;
bytesleft = blocks;
bytesread = 0;
while (bytesleft > 0)
{
CardError = CARD_Read (&CardFile, buf + bytesread, SectorSize, bytesread);
if(CardError)
{
ErrorPrompt("Error loading file!");
bytesread = 0;
break;
}
bytesleft -= SectorSize;
bytesread += SectorSize;
ShowProgress ("Loading...", bytesread, blocks);
}
CARD_Close (&CardFile);
CancelAction();
}
CARD_Unmount(slot);
}
// discard save icon and comments
memmove(buf, buf+sizeof(saveicon)+64, bytesread);
bytesread -= (sizeof(saveicon)+64);
free(SysArea);
return bytesread;
}
/****************************************************************************
* CardReadFile
*
* Retrieve a file from the previously populated list.
* Place in filebuffer space, for collection by SMB write.
****************************************************************************/
int CardReadFile (int slot, int id)
{
int bytesdone = 0;
int err;
u32 SectorSize;
char company[4];
char gamecode[6];
int filesize;
if (id >= cardcount)
{
WaitPrompt("Bad id");
return 0; /*** Bad id ***/
}
/*** Clear the work buffers ***/
memset (FileBuffer, 0, MAXFILEBUFFER);
memset (SysArea, 0, CARD_WORKAREA);
//add null char
company[2] = gamecode[4] = 0;
memcpy (company, &CardList[id].company, 2);
memcpy (gamecode, &CardList[id].gamecode, 4);
/*** Mount the card ***/
err = MountCard(slot);
if (err < 0)
{
WaitCardError("CardMount", err);
return 0; /*** Unable to mount the card ***/
}
/*** Retrieve sector size ***/
CARD_GetSectorSize (slot, &SectorSize);
/*** Initialise for this company & gamecode ***/
CARD_SetCompany(company);
CARD_SetGamecode(gamecode);
/*** Open the file ***/
err = CARD_Open (slot, (char *) &CardList[id].filename, &CardFile);
if (err < 0)
{
CARD_Unmount (slot);
WaitCardError("CardOpen", err);
return 0;
}
#ifdef STATUSOGC
/*** Get card status info ***/
CARD_GetStatus (slot, CardFile.filenum, &CardStatus);
CARD_GetAttributes(slot,CardFile.filenum, &permission);
GCIMakeHeader();
#else
//get directory entry (same as gci header, but with all the data)
memset(&gci,0,sizeof(GCI));
__card_getstatusex(slot,CardFile.filenum,&gci);
/*** Copy to head of buffer ***/
memcpy(FileBuffer, &gci, sizeof(GCI));
#endif
/*** Copy the file contents to the buffer ***/
filesize = CardFile.len;
while (bytesdone < filesize)
{
CARD_Read (&CardFile, FileBuffer + MCDATAOFFSET + bytesdone, SectorSize, bytesdone);
bytesdone += SectorSize;
}
/*** Close the file ***/
CARD_Close (&CardFile);
/*** Unmount the card ***/
CARD_Unmount (slot);
return filesize + MCDATAOFFSET;
}
//TODO: get icon and banner settings
int CardReadFileHeader (int slot, int id)
{
int bytesdone = 0;
int err;
u32 SectorSize;
char company[4];
char gamecode[6];
int filesize;
int i;
u16 check_fmt, check_speed;
if (id >= cardcount)
{
WaitPrompt("Bad id");
return 0; /*** Bad id ***/
}
/*** Clear the work buffers ***/
memset (FileBuffer, 0, MAXFILEBUFFER);
memset (CommentBuffer, 0, 64);
memset (SysArea, 0, CARD_WORKAREA);
//add null char
company[2] = gamecode[4] = 0;
memcpy (company, &CardList[id].company, 2);
memcpy (gamecode, &CardList[id].gamecode, 4);
/*** Mount the card ***/
err = MountCard(slot);
if (err < 0)
{
WaitCardError("CardMount", err);
return 0; /*** Unable to mount the card ***/
}
/*** Retrieve sector size ***/
CARD_GetSectorSize (slot, &SectorSize);
/*** Initialise for this company & gamecode ***/
CARD_SetCompany((const char*)company);
CARD_SetGamecode((const char*)gamecode);
/*** Open the file ***/
err = CARD_Open (slot, (char *) &CardList[id].filename, &CardFile);
if (err < 0)
{
CARD_Unmount (slot);
WaitCardError("CardOpen", err);
return 0;
}
#ifdef STATUSOGC
/*** Get card status info ***/
CARD_GetStatus (slot, CardFile.filenum, &CardStatus);
CARD_GetAttributes(slot,CardFile.filenum, &permission);
GCIMakeHeader();
#else
//get directory entry (same as gci header, but with all the data)
memset(&gci,0,sizeof(GCI));
__card_getstatusex(slot,CardFile.filenum,&gci);
/*** Copy to head of buffer ***/
memcpy(FileBuffer, &gci, sizeof(GCI));
#endif
/*** Copy the file contents to the buffer ***/
filesize = CardFile.len;
while (bytesdone < filesize)
{
CARD_Read (&CardFile, FileBuffer + MCDATAOFFSET + bytesdone, SectorSize, bytesdone);
bytesdone += SectorSize;
}
/***
Get the Banner/Icon Data from the memory card file.
Very specific if/else setup to minimize data copies.
***/
u8* offset = FileBuffer + MCDATAOFFSET + gci.icon_addr;
/*** Get the Banner/Icon Data from the save file ***/
if ((gci.banner_fmt&CARD_BANNER_MASK) == CARD_BANNER_RGB) {
//RGB banners are 96*32*2 in size
memcpy(bannerdata, offset, 6144);
offset += 6144;
}
else if ((gci.banner_fmt&CARD_BANNER_MASK) == CARD_BANNER_CI) {
memcpy(bannerdataCI, offset, 3072);
offset += 3072;
memcpy(tlutbanner, offset, 512);
offset += 512;
}
//Icon data
int shared_pal = 0;
lastframe = 0;
numicons = 0;
int j =0;
i=0;
int current_icon = 0;
for (current_icon=0;i<CARD_MAXICONS;++current_icon){
//no need to clear all values since we will only use the ones until lasticon
frametable[current_icon] = 0;
iconindex[current_icon] = 0;
//Animation speed is mandatory to be set even for a single icon
//When a speed is 0 there are no more icons
//Some games may have bits set after the "blank icon" both in
//speed (Baten Kaitos) and format (Wario Ware Inc.) bytes, which are just garbage
if (!SDCARD_GetIconSpeed(gci.icon_speed,current_icon)){
break;
}else
{//We've got a frame
lastframe+=SDCARD_GetIconSpeed(gci.icon_speed,current_icon)*4;//Count the total frames
frametable[current_icon]=lastframe; //Store the end frame of the icon
if (SDCARD_GetIconFmt(gci.icon_fmt,current_icon) != 0)
{
//count the number of real icons
numicons++;
iconindex[current_icon]=current_icon; //Map the icon
//CI with shared palette
if (SDCARD_GetIconFmt(gci.icon_fmt,current_icon) == 1) {
memcpy(icondata[current_icon], offset, 1024);
offset += 1024;
shared_pal = 1;
}
//CI with palette after the icon
else if (SDCARD_GetIconFmt(gci.icon_fmt,current_icon) == 3)
{
memcpy(icondata[current_icon], offset, 1024);
offset += 1024;
memcpy(tlut[current_icon], offset, 512);
offset += 512;
}
//RGB 16 bit icon
else if (SDCARD_GetIconFmt(gci.icon_fmt,current_icon) == 2)
{
memcpy(icondataRGB[current_icon], offset, 2048);
offset += 2048;
}
}else
{ //Get next real icon
for(j=current_icon;j<CARD_MAXICONS;++j){
if (SDCARD_GetIconFmt(gci.icon_fmt,j) != 0)
{
iconindex[current_icon]=j; //Map blank frame to next real icon
break;
}
}
}
}
}
lasticon = current_icon-1;
//Now get icon indexes for ping-pong style icons
if (SDCARD_GetIconAnim(gci.banner_fmt) == CARD_ANIM_BOUNCE && current_icon>1) //We need at least 3 icons
{
j=current_icon;
for (i = current_icon-2; 0 < i; --i, ++j)
{
lastframe += SDCARD_GetIconSpeed(gci.icon_speed,i)*4;
frametable[j] = lastframe;
iconindex[j] = iconindex[i];
}
lasticon = j-1;
}
//Get the shared palette
if (shared_pal) memcpy(tlut[8], offset, 512);
/*** Get the comment (two 32 byte strings) into buffer ***/
memcpy(CommentBuffer, FileBuffer + MCDATAOFFSET + gci.comment_addr, 64);
/*** Close the file ***/
CARD_Close (&CardFile);
/*** Unmount the card ***/
CARD_Unmount (slot);
return filesize + MCDATAOFFSET;
}
/****************************************************************************
* ManageState
*
* Here is the main Freeze File Management stuff.
* The output file contains an icon (2K), 64 bytes comment and the STATE (~128k)
*
* direction == 0 save, 1 load.
****************************************************************************/
int ManageState (u8 direction, u8 device)
{
if (!smsromsize)
return 0;
char filename[MAXJOLIET];
/* clean buffer */
memset(savebuffer, 0, 0x12000);
if (direction)
ShowAction ("Loading State ...");
else
ShowAction ("Saving State ...");
if (device == 0)
{
/* FAT support */
sprintf (filename, "%s.spz", rom_filename);
return FAT_ManageFile(filename,direction);
}
/* Memory CARD support */
char action[80];
int CardError;
unsigned int SectorSize = 0;
int blocks;
char comment[2][32] = { {"SMS Plus 1.3 [FRZ]"}, {"Freeze State"} };
int outbytes = 0;
int sbo;
int state_size = 0;
/* First, build a filename */
sprintf (filename, "%08X.spz", (u32)crc32 (0, &cart.rom[0], smsromsize));
strcpy (comment[1], filename);
/* set MCARD slot nr. */
u8 CARDSLOT = device - 1;
/* Saving */
if (direction == 0)
{
/*** Build the output buffer ***/
memcpy (&savebuffer, &icon, 2048);
memcpy (&savebuffer[2048], &comment[0], 64);
state_size = system_save_state(&savebuffer[2112]);
}
outbytes = 2048 + 64 + state_size;
/*** Initialise the CARD system ***/
memset (&SysArea, 0, CARD_WORKAREA);
CARD_Init ("SMSP", "00");
/*** Attempt to mount the card ***/
CardError = MountTheCard (CARDSLOT);
if (CardError)
{
/*** Retrieve the sector size ***/
CardError = CARD_GetSectorSize (CARDSLOT, &SectorSize);
if (SectorSize)
{
switch (direction)
{
case 0: /*** Saving ***/
/*** Determine number of blocks on this card ***/
blocks = (outbytes / SectorSize) * SectorSize;
if (outbytes % SectorSize) blocks += SectorSize;
/*** Check if a previous save exists ***/
if (CardFileExists (filename,CARDSLOT))
{
CardError = CARD_Open (CARDSLOT, filename, &CardFile);
if (CardError)
{
sprintf (action, "Error Open : %d", CardError);
WaitPrompt (action);
CARD_Unmount (CARDSLOT);
return 0;
}
int size = CardFile.len;
CARD_Close (&CardFile);
if (size < blocks)
{
/* new size is bigger: check if there is enough space left */
CardError = CARD_Create (CARDSLOT, "TEMP", blocks-size, &CardFile);
if (CardError)
{
sprintf (action, "Error Update : %d", CardError);
WaitPrompt (action);
CARD_Unmount (CARDSLOT);
return 0;
}
CARD_Close (&CardFile);
CARD_Delete(CARDSLOT, "TEMP");
}
/* always delete existing slot */
CARD_Delete(CARDSLOT, filename);
}
/*** Create a new slot ***/
CardError = CARD_Create (CARDSLOT, filename, blocks, &CardFile);
if (CardError)
{
sprintf (action, "Error create : %d %d", CardError, CARDSLOT);
WaitPrompt (action);
CARD_Unmount (CARDSLOT);
return 0;
}
/*** Continue and save ***/
CARD_GetStatus (CARDSLOT, CardFile.filenum, &CardStatus);
CardStatus.icon_addr = 0x0;
CardStatus.icon_fmt = 2;
CardStatus.icon_speed = 1;
CardStatus.comment_addr = 2048;
CARD_SetStatus (CARDSLOT, CardFile.filenum, &CardStatus);
/*** And write the blocks out ***/
sbo = 0;
while (outbytes > 0)
{
CardError = CARD_Write (&CardFile, &savebuffer[sbo], SectorSize, sbo);
outbytes -= SectorSize;
sbo += SectorSize;
}
CARD_Close (&CardFile);
CARD_Unmount (CARDSLOT);
sprintf (action, "Saved %d bytes successfully", blocks);
WaitPrompt (action);
return 1;
default: /*** Loading ***/
if (!CardFileExists (filename, CARDSLOT))
{
WaitPrompt ("No Savestate Found");
CARD_Unmount (CARDSLOT);
return 0;
}
memset (&CardFile, 0, sizeof (CardFile));
CardError = CARD_Open (CARDSLOT, filename, &CardFile);
if (CardError)
{
sprintf (action, "Error Open : %d", CardError);
WaitPrompt (action);
CARD_Unmount (CARDSLOT);
return 0;
}
blocks = CardFile.len;
if (blocks < SectorSize) blocks = SectorSize;
if (blocks % SectorSize) blocks++;
/*** Just read the file back in ***/
sbo = 0;
int size = blocks;
while (blocks > 0)
{
CARD_Read (&CardFile, &savebuffer[sbo], SectorSize, sbo);
sbo += SectorSize;
blocks -= SectorSize;
}
CARD_Close (&CardFile);
CARD_Unmount (CARDSLOT);
/*** Load State ***/
system_load_state(&savebuffer[2112]);
/*** Inform user ***/
sprintf (action, "Loaded %d bytes successfully", size);
WaitPrompt (action);
return 1;
}
}
WaitPrompt ("Invalid sector size");
return 0;
}
WaitPrompt ("Unable to mount memory card");
return 0; /*** Signal failure ***/
}
s32 deviceHandler_CARD_readFile(file_handle* file, void* buffer, u32 length){
card_file cardfile;
void *dst = buffer;
card_dir* cd = (card_dir*)&file->other;
char *filename = getRelativeName(file->name);
unsigned int slot = (!strncmp((const char*)initial_CARDB.name, file->name, 7)), ret = 0;
if(cd->company[0] == '\0' && cd->gamecode[0] == '\0') {
// Find the file we don't know about and populate this file_handle if we find it.
if(!findFile(file)) {
return CARD_ERROR_NOFILE;
}
CARD_SetCompany((const char*)cd->company);
CARD_SetGamecode((const char*)cd->gamecode);
}
else {
CARD_SetCompany((const char*)cd->company);
CARD_SetGamecode((const char*)cd->gamecode);
}
int swissFile = !strncmp((const char*)cd->gamecode, "SWIS", 4)
&& !strncmp((const char*)cd->company, "S0", 2);
// Open the file based on the slot & file name
ret = CARD_Open(slot,filename, &cardfile);
print_gecko("Tried to open: [%s] in slot %s got res: %i\r\n",filename, slot ? "B":"A", ret);
if(ret != CARD_ERROR_READY) return ret;
u8 *read_buffer = (u8*)memalign(32,card_sectorsize[slot]);
if(!read_buffer) {
return -1;
}
/* Read from the file */
u32 amountRead = 0;
// If this file was put here by swiss, then skip the first 8192 bytes
if(swissFile && !isCopyGCIMode) {
print_gecko("Swiss copied file detected, skipping icon\r\n");
file->offset += 8192;
}
if(isCopyGCIMode) {
// Write out a .GCI
card_stat cardstat;
GCI gci;
CARD_GetStatus(slot, cardfile.filenum, &cardstat);
memset(&gci, 0, sizeof(GCI));
memcpy(&gci.gamecode,cd->gamecode,4);
memcpy(&gci.company,cd->company,2);
memcpy(&gci.filename,file->name,CARD_FILENAMELEN);
gci.reserved01 = 0xFF;
gci.banner_fmt = cardstat.banner_fmt;
gci.time = cardstat.time;
gci.icon_addr = cardstat.icon_addr;
gci.icon_fmt = cardstat.icon_fmt;
gci.icon_speed = cardstat.icon_speed;
gci.unknown1 = cd->permissions;
gci.filesize8 = cardstat.len / 8192;
gci.reserved02 = 0xFFFF;
gci.comment_addr = cardstat.comment_addr;
memcpy(dst, &gci, sizeof(GCI));
dst+=sizeof(GCI);
length-=sizeof(GCI);
amountRead += sizeof(GCI);
}
while(length > 0 && file->offset < file->size) {
int readsize = length > card_sectorsize[slot] ? card_sectorsize[slot] : length;
print_gecko("Need to read: [%i] more bytes\r\n", length);
if(file->offset&0x1ff) {
ret = CARD_ReadUnaligned(&cardfile, read_buffer, card_sectorsize[slot], file->offset, slot);
}
else {
ret = CARD_Read(&cardfile, read_buffer, card_sectorsize[slot], file->offset);
// Sometimes reads fail the first time stupidly, retry at least once.
print_gecko("Read: [%i] bytes ret [%i] from offset [%i]\r\n",card_sectorsize[slot],ret, file->offset);
if(ret == CARD_ERROR_BUSY) {
print_gecko("Read retry\r\n");
usleep(2000);
ret = CARD_Read(&cardfile, read_buffer, card_sectorsize[slot], file->offset);
}
}
if(ret == CARD_ERROR_READY)
memcpy(dst,read_buffer,readsize);
else
return ret;
dst+=readsize;
file->offset += readsize;
length -= readsize;
amountRead += readsize;
}
// For swiss adjusted files, don't trail off the end.
if(swissFile && length != 0) {
amountRead+= length;
}
DCFlushRange(dst, amountRead);
CARD_Close(&cardfile);
free(read_buffer);
return amountRead;
}
//---------------------------------------------------------------------------------
int main() {
//---------------------------------------------------------------------------------
VIDEO_Init();
rmode = VIDEO_GetPreferredMode(NULL);
PAD_Init();
xfb = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
VIDEO_Configure(rmode);
VIDEO_SetNextFramebuffer(xfb);
VIDEO_SetBlack(FALSE);
VIDEO_Flush();
VIDEO_WaitVSync();
if(rmode->viTVMode&VI_NON_INTERLACE) VIDEO_WaitVSync();
console_init(xfb,20,64,rmode->fbWidth,rmode->xfbHeight,rmode->fbWidth*2);
VIDEO_SetNextFramebuffer(xfb);
int slot = CARD_SLOTA;
u32 i;
int tomenu = 0;
u16 buttonsDown;
u8 pressed = 0;
int filesize;
int bytesdone = 0;
while(1){
VIDEO_ClearFrameBuffer (rmode, xfb, COLOR_BLACK);
listpos=0;
tomenu=0;
pressed = 0;
printf("\x1b[2;0H");
printf("Memory Card Loader 0.2 by Suloku\n");
printf("********************************\n\n");
printf("Press A or B button to select a slot.\n");
while (1){
PAD_ScanPads();
buttonsDown=PAD_ButtonsDown(0);
if (buttonsDown & PAD_BUTTON_A){ slot = CARD_SLOTA; pressed = 1;}
if (buttonsDown & PAD_BUTTON_B){ slot = CARD_SLOTB; pressed = 1;}
if (buttonsDown & PAD_BUTTON_START){ PSOreload();}
VIDEO_WaitVSync();
if (pressed) break;
}
printf("Mounting card in slot %s...", (slot==0?"A":"B"));
int Slot_error = MountCard(slot);
printf("code %d. ",Slot_error);
int CardError;
if (Slot_error >= 0) {
printf("Sector size is %d bytes.\n",sectsize);
printf("Reading memory card files...");
card_dir CardDir;
card_file CardFile;
CardError = CARD_FindFirst(slot, &CardDir, true);
cardcount = 0;
while ( CARD_ERROR_NOFILE != CardError ) {
if (strncmp ("DOLX", (char *)CardDir.gamecode, 4) == 0){
memcpy (&CardList[cardcount], &CardDir, sizeof (card_dir));
cardcount++;
}
CardError = CARD_FindNext(&CardDir);
}
printf("finished.\n\n");
if (cardcount == 0){
printf("No dol files in memory card in slot %s\n\n", (slot==0?"A":"B"));
waitA();
}else{
while (1){
pressed = 0;
VIDEO_ClearFrameBuffer (rmode, xfb, COLOR_BLACK);
printf("\x1b[2;0H");
printf("Memory Card Loader 0.1 by Suloku\n");
printf("********************************\n\n");
printf("Dol files in memory card %s: %d\n\n", (slot==0?"A":"B"), cardcount);
if (listpos!=0) printf ("/\\/\\\n");
else printf(" \n");
for (i=listpos; i<listpos+10; i++){
printf (" ");
if (i==listpos) printf ("-->");
printf("%s \n",CardList[i].filename);
if (i>= cardcount )break;
}
printf("\x1b[18;0H");
if (cardcount >=10 && listpos != cardcount-1) printf ("\\/\\/\n");
else{
printf(" \n");
}
printf("\n\t\tPress B button to go back to slot select.\n\n");
while (1){
PAD_ScanPads();
buttonsDown=PAD_ButtonsDown(0);
if (buttonsDown & PAD_BUTTON_UP){
listpos--;
if (listpos <0) listpos = 0;
pressed = 1;
}
if (buttonsDown & PAD_BUTTON_DOWN){
listpos++;
if (listpos >= cardcount-1) listpos = cardcount-1;
pressed = 1;
}
if (buttonsDown & PAD_BUTTON_LEFT){
listpos-=10;
if (listpos <0) listpos = 0;
pressed = 1;
}
if (buttonsDown & PAD_BUTTON_RIGHT){
listpos+=10;
if (listpos >= cardcount-1) listpos = cardcount-1;
pressed = 1;
}
if (buttonsDown & PAD_BUTTON_A){
printf("Loading %s...\n", CardList[listpos].filename);
/*** Initialise for this company & gamecode ***/
//add null char
company[2] = gamecode[4] = 0;
memcpy (company, &CardList[listpos].company, 2);
memcpy (gamecode, &CardList[listpos].gamecode, 4);
CARD_SetCompany(company);
CARD_SetGamecode(gamecode);
CardError = CARD_Open(slot ,(char*)&CardList[listpos].filename,&CardFile);
if (CardError < 0)
{
CARD_Unmount (slot);
printf("Error %d while opening file.\n", CardError);
waitA();
}else{
/*** Copy the file contents to the buffer ***/
filesize = CardFile.len;
u8 *dolbuffer = (u8*) memalign(32, filesize);
while (bytesdone < filesize)
{
CardError= CARD_Read(&CardFile, dolbuffer+bytesdone, sectsize, bytesdone);
bytesdone += sectsize;
}
CARD_Close(&CardFile);
CARD_Unmount(slot);
//boot dol
//This will load cli_buffer and cli_size
getclifrombuffer(dolbuffer, filesize);
if (cli_buffer!=NULL){
// Build a command line to pass to the DOL
int argc2 = 0;
char *argv2[1024];
//add a terminating null character for last argument if needed
if (cli_buffer[cli_size-1] != '\0'){
cli_buffer[cli_size] = '\0';
cli_size += 1;
}
// CLI parse
char bootpath[CARD_FILENAMELEN+10];
sprintf(bootpath, "mc%d:/%s", slot, (char*)&CardList[listpos].filename);
argv2[argc2] = bootpath;
argc2++;
// First argument is at the beginning of the file
if(cli_buffer[0] != '\r' && cli_buffer[0] != '\n') {
argv2[argc2] = cli_buffer;
argc2++;
}
// Search for the others after each newline
int i;
for(i = 0; i < cli_size; i++) {
if(cli_buffer[i] == '\r' || cli_buffer[i] == '\n') {
cli_buffer[i] = '\0';
}
else if(cli_buffer[i - 1] == '\0') {
argv2[argc2] = cli_buffer + i;
argc2++;
if(argc2 >= 1024)
break;
}
}
DOLtoARAM(dolbuffer, argc2, argc2 == 0 ? NULL : argv2);
}else{
DOLtoARAM(dolbuffer, 0, NULL);
}
//If we get here dol was invalid
if(dolbuffer != NULL) free(dolbuffer);
printf("Not a valid dol file.\n");
waitA();
tomenu = 1;
}
pressed = 1;
}
if (buttonsDown & PAD_BUTTON_B){ pressed = 1;tomenu=1;}
if (buttonsDown & PAD_BUTTON_START){ PSOreload();}
VIDEO_WaitVSync();
if (pressed) break;
}
if (tomenu) break;
}
}
CARD_Unmount(slot);
}else{
printf("\n\nCan't mount card in slot %s!\n", (slot==0?"A":"B"));
waitA();
}
}
return 0;
}
/****************************************************************************
* Verify Memory Card file against buffer
***************************************************************************/
int
VerifyMCFile (char *buf, int slot, char *filename, int datasize)
{
int CardError;
unsigned int blocks;
unsigned int SectorSize;
char msg[80];
int bytesleft = 0;
int bytesread = 0;
/*** Initialize Card System ***/
memset (SysArea, 0, CARD_WORKAREA);
CARD_Init ("VBA0", "00");
/*** Try to mount the card ***/
CardError = MountCard(slot, NOTSILENT);
if (CardError == 0)
{
/*** Get Sector Size ***/
CARD_GetSectorSize (slot, &SectorSize);
if (!CardFileExists (filename, slot))
{
CARD_Unmount (slot);
WaitPrompt("Unable to open file for verify!");
return 0;
}
memset (&CardFile, 0, sizeof (CardFile));
CardError = CARD_Open (slot, filename, &CardFile);
blocks = CardFile.len;
if (blocks < SectorSize)
blocks = SectorSize;
if (blocks % SectorSize)
blocks += SectorSize;
if (blocks > (unsigned int)datasize)
blocks = datasize;
memset (verifbuffer, 0, VERIFBUFFERSIZE);
bytesleft = blocks;
bytesread = 0;
while (bytesleft > 0)
{
CARD_Read (&CardFile, verifbuffer, SectorSize, bytesread);
if ( memcmp (buf + bytesread, verifbuffer, (unsigned int)bytesleft < SectorSize ? bytesleft : SectorSize) )
{
CARD_Close (&CardFile);
CARD_Unmount (slot);
WaitPrompt("File did not verify!");
return 0;
}
bytesleft -= SectorSize;
bytesread += SectorSize;
sprintf (msg, "Verified %d of %d bytes", bytesread, blocks);
ShowProgress (msg, bytesread, blocks);
}
CARD_Close (&CardFile);
CARD_Unmount (slot);
return 1;
}
else
if (slot == CARD_SLOTA)
WaitPrompt("Unable to Mount Slot A Memory Card!");
else
WaitPrompt("Unable to Mount Slot B Memory Card!");
return 0;
}
void MCManage(int mode, int slot)
{
char mcFilename[80];
int CardError;
card_dir CardDir;
card_file CardFile;
int SectorSize;
int found = 0;
int FileSize;
int actualSize;
int savedBytes=0;
char debug[128];
CARDSLOT = slot;
/*** Build the file name ***/
sprintf(mcFilename, "FCEU-%08x.fcs", iNESGameCRC32);
/*** Mount the Card ***/
CARD_Init("FCEU", "00");
/*** Try for memory card in slot A ***/
CardError = CARD_Mount(CARDSLOT, SysArea, CardRemoved );
if ( CardError >= 0 )
{
/*** Get card sector size ***/
CardError = CARD_GetSectorSize(CARDSLOT, &SectorSize);
switch ( mode ) {
case 0 : { /*** Save Game ***/
/*** Look for this file ***/
CardError = CARD_FindFirst(CARDSLOT, &CardDir, true);
found = 0;
card_stat CardStatus;
while ( CardError != CARD_ERROR_NOFILE )
{
CardError = CARD_FindNext(&CardDir);
if ( strcmp(CardDir.filename, mcFilename) == 0 )
found = 1;
}
/*** Determine number of sectors required ***/
savedBytes = actualSize = GCFCEUSS_Save();
sprintf(debug, "Saving in MC ...");
ShowAction(debug);
FileSize = ( actualSize / SectorSize ) * SectorSize;
if ( actualSize % SectorSize )
FileSize += SectorSize;
/*** Now write the file out ***/
if ( !found )
CardError = CARD_Create(CARDSLOT, mcFilename, FileSize, &CardFile);
else
CardError = CARD_Open(CARDSLOT, mcFilename, &CardFile);
CARD_GetStatus( CARDSLOT, CardFile.filenum, &CardStatus);
CardStatus.icon_addr = 0;
CardStatus.icon_fmt = 2;
CardStatus.icon_speed = 1;
CardStatus.comment_addr = sizeof(saveicon);
CARD_SetStatus( CARDSLOT, CardFile.filenum, &CardStatus);
/*** Haha! libogc only write one block at a time! ***/
if ( CardError == 0 )
{
int sbo = 0;
while ( actualSize > 0 )
{
CardError = CARD_Write(&CardFile, &statebuffer[sbo], SectorSize, sbo );
actualSize -= SectorSize;
sbo += SectorSize;
}
CardError = CARD_Close(&CardFile);
sprintf(debug, "Saved %d bytes successfully!", savedBytes);
WaitPrompt(debug);
}
else WaitPrompt("Save Failed!");
CARD_Unmount(CARDSLOT);
}
break; /*** End save ***/
case 1: { /*** Load state ***/
/*** Look for this file ***/
CardError = CARD_FindFirst(CARDSLOT, &CardDir, true);
memopen(); /*** Clear the buffer ***/
found = 0;
while ( CardError != CARD_ERROR_NOFILE )
{
CardError = CARD_FindNext(&CardDir);
if ( strcmp(CardDir.filename, mcFilename) == 0 )
found = 1;
}
if ( found == 0 )
{
WaitPrompt("No Save Game Found");
CARD_Unmount(CARDSLOT);
return;
}
/*** Load the file into memory ***/
CardError = CARD_Open(CARDSLOT, mcFilename, &CardFile);
CardError = CARD_Read(&CardFile, &statebuffer, SectorSize, 0);
/*** Get actual size of the file ***/
memcpy(&actualSize, &statebuffer[FILESIZEOFFSET], 4);
savedBytes = actualSize;
int sbo = SectorSize;
actualSize -= SectorSize;
while( actualSize > 0 )
{
CARD_Read(&CardFile, &statebuffer[sbo], SectorSize, sbo);
actualSize -= SectorSize;
sbo += SectorSize;
}
CARD_Close(&CardFile);
/*** Finally, do load ***/
GCFCEUSS_Load();
CARD_Unmount(CARDSLOT);
sprintf(debug, "Loaded %d bytes successfully!", savedBytes);
WaitPrompt(debug);
}
break; /*** End load ***/
default: break;
}
} else {
WaitPrompt("Cannot Mount Memory Card!");
}
}
