//
// "Alpine" file loading
// Since the developers were coming after us with torches and pitchforks, we decided to
// allow this kind of thing. ;-) But ONLY FOR THE DEVS, DAMMIT! >:-U O_O
//
bool AlpineLoadFile(char * path)
{
uint8 * buffer = NULL;
jaguarROMSize = JaguarLoadROM(buffer, path);
if (jaguarROMSize == 0)
{
// It's up to the GUI to deal with failure, not us. ;-)
WriteLog("FILE: Could not load Alpine from file \"%s\"...\nAborting load!\n", path);
return false;
}
jaguarMainROMCRC32 = crc32_calcCheckSum(buffer, jaguarROMSize);
WriteLog("CRC: %08X\n", (unsigned int)jaguarMainROMCRC32);
EepromInit();
jaguarRunAddress = 0x802000;
WriteLog("FILE: Setting up Alpine ROM with non-standard length... Run address: 00802000, length: %08X\n", jaguarROMSize);
memset(jagMemSpace + 0x800000, 0xFF, 0x2000);
memcpy(jagMemSpace + 0x802000, buffer, jaguarROMSize);
delete[] buffer;
// Maybe instead of this, we could try requiring the STUBULATOR ROM? Just a thought...
// Try setting the vector to say, $1000 and putting an instruction there that loops forever:
// This kludge works! Yeah!
SET32(jaguarMainRAM, 0x10, 0x00001000); // Set Exception #4 (Illegal Instruction)
SET16(jaguarMainRAM, 0x1000, 0x60FE); // Here: bra Here
return true;
}
//------------------------------------------------------------------------------
/// Initialize EEPROM devices and transfer one or sevral modules from EEPROM to the
/// target memory (SRAM/SDRAM).
/// \param pTd Pointer to transfer descriptor array.
/// \param nbTd Number of transfer descriptors.
//------------------------------------------------------------------------------
int BOOT_EEPROM_CopyBin(const Tdesc *pTd, unsigned char nbTd)
{
unsigned char *pDest; // Dest pointer for copy
unsigned int sizeToCopy; // remaining bytes number to copy
unsigned int memoryOffset; // Dataflash read offset
unsigned int packetSize; // Dataflash read size
Async async;
// Initialize EEPROM
EepromInit();
// Check word alignment
if (pTd->offset % PAGE_SIZE) {
TRACE_ERROR("Offset not word aligned\n\r");
return BOOT_EEPROM_ERROR_GP;
}
// Transfert data from EEPROM to External RAM
//-------------------------------------------------------------------------
memset(&async, 0, sizeof(async));
async.callback = (void *) TestCallback;
// Foreach module transfer data from EEPROM to memory
while (nbTd--) {
TRACE_INFO("Copy \"%s\" (%d bytes) from EEPROM 0x%08x to 0x%08x\n\r",
pTd->strDescr,
pTd->size,
pTd->offset,
pTd->dest
);
pDest = (unsigned char*)pTd->dest;
sizeToCopy = pTd->size;
memoryOffset = pTd->offset;
while (sizeToCopy > 0) {
// Write packet after packets
packetSize = (sizeToCopy < PAGE_SIZE) ? sizeToCopy : PAGE_SIZE;
// Read the page and copy
TWID_Read(&twid, AT24C_ADDRESS, memoryOffset, 2, pDest, PAGE_SIZE, &async);
while (!ASYNC_IsFinished(&async));
// Update pointer
memoryOffset += packetSize;
pDest += packetSize;
sizeToCopy -= packetSize;
}
++pTd;
}
return BOOT_EEPROM_SUCCESS;
}
//
// Jaguar file loading
// We do a more intelligent file analysis here instead of relying on (possible false)
// file extensions which people don't seem to give two shits about anyway. :-(
//
bool JaguarLoadFile(char * path)
{
uint8 * buffer = NULL;
jaguarROMSize = JaguarLoadROM(buffer, path);
if (jaguarROMSize == 0)
{
// It's up to the GUI to report errors, not us. :-)
WriteLog("FILE: Could not load ROM from file \"%s\"...\nAborting load!\n", path);
return false;
}
jaguarMainROMCRC32 = crc32_calcCheckSum(buffer, jaguarROMSize);
WriteLog("CRC: %08X\n", (unsigned int)jaguarMainROMCRC32);
// TODO: Check for EEPROM file in ZIP file. If there is no EEPROM in the user's EEPROM
// directory, copy the one from the ZIP file, if it exists.
EepromInit();
jaguarRunAddress = 0x802000; // For non-BIOS runs, this is true
int fileType = ParseFileType(buffer, jaguarROMSize);
jaguarCartInserted = false;
if (fileType == JST_ROM)
{
jaguarCartInserted = true;
memcpy(jagMemSpace + 0x800000, buffer, jaguarROMSize);
// Checking something...
jaguarRunAddress = GET32(jagMemSpace, 0x800404);
WriteLog("FILE: Cartridge run address is reported as $%X...\n", jaguarRunAddress);
delete[] buffer;
return true;
}
else if (fileType == JST_ALPINE)
{
// File extension ".ROM": Alpine image that loads/runs at $802000
WriteLog("FILE: Setting up Alpine ROM... Run address: 00802000, length: %08X\n", jaguarROMSize);
memset(jagMemSpace + 0x800000, 0xFF, 0x2000);
memcpy(jagMemSpace + 0x802000, buffer, jaguarROMSize);
delete[] buffer;
// Maybe instead of this, we could try requiring the STUBULATOR ROM? Just a thought...
// Try setting the vector to say, $1000 and putting an instruction there that loops forever:
// This kludge works! Yeah!
SET32(jaguarMainRAM, 0x10, 0x00001000);
SET16(jaguarMainRAM, 0x1000, 0x60FE); // Here: bra Here
return true;
}
else if (fileType == JST_ABS_TYPE1)
{
// For ABS type 1, run address == load address
uint32 loadAddress = GET32(buffer, 0x16),
codeSize = GET32(buffer, 0x02) + GET32(buffer, 0x06);
WriteLog("FILE: Setting up homebrew (ABS-1)... Run address: %08X, length: %08X\n", loadAddress, codeSize);
memcpy(jagMemSpace + loadAddress, buffer + 0x24, codeSize);
delete[] buffer;
jaguarRunAddress = loadAddress;
return true;
}
else if (fileType == JST_ABS_TYPE2)
{
uint32 loadAddress = GET32(buffer, 0x28), runAddress = GET32(buffer, 0x24),
codeSize = GET32(buffer, 0x18) + GET32(buffer, 0x1C);
WriteLog("FILE: Setting up homebrew (ABS-2)... Run address: %08X, length: %08X\n", runAddress, codeSize);
memcpy(jagMemSpace + loadAddress, buffer + 0xA8, codeSize);
delete[] buffer;
jaguarRunAddress = runAddress;
return true;
}
// NB: This is *wrong*
/*
Basically, if there is no "JAG" at position $1C, then the long there is the load/start
address in LITTLE ENDIAN.
If "JAG" is present, the the next character ("R" or "L") determines the size of the
JagServer command (2 bytes vs. 4). Following that are the commands themselves;
typically it will either be 2 (load) or 3 (load & run). Command headers go like so:
2:
Load address (long)
Length (long)
payload
3:
Load address (long)
Length (long)
Run address (long)
payload
5: (Reset)
[command only]
7: (Run at address)
Run address (long)
[no payload]
9: (Clear memory)
Start address (long)
End address (long)
[no payload]
10: (Poll for commands)
[command only]
12: (Load & run user program)
filname, terminated with NULL
[no payload]
$FFFF: (Halt)
[no payload]
*/
else if (fileType == JST_JAGSERVER)
{
// This kind of shiaut should be in the detection code below...
// (and now it is! :-)
// if (buffer[0x1C] == 'J' && buffer[0x1D] == 'A' && buffer[0x1E] == 'G')
// {
// Still need to do some checking here for type 2 vs. type 3. This assumes 3
// Also, JAGR vs. JAGL (word command size vs. long command size)
uint32 loadAddress = GET32(buffer, 0x22), runAddress = GET32(buffer, 0x2A);
WriteLog("FILE: Setting up homebrew (Jag Server)... Run address: $%X, length: $%X\n", runAddress, jaguarROMSize - 0x2E);
memcpy(jagMemSpace + loadAddress, buffer + 0x2E, jaguarROMSize - 0x2E);
delete[] buffer;
jaguarRunAddress = runAddress;
return true;
// }
// else // Special WTFOMGBBQ type here...
// {
// uint32_t loadAddress = (buffer[0x1F] << 24) | (buffer[0x1E] << 16) | (buffer[0x1D] << 8) | buffer[0x1C];
// WriteLog("FILE: Setting up homebrew (GEMDOS WTFOMGBBQ type)... Run address: $%X, length: $%X\n", loadAddress, jaguarROMSize - 0x20);
// memcpy(jagMemSpace + loadAddress, buffer + 0x20, jaguarROMSize - 0x20);
// delete[] buffer;
// jaguarRunAddress = loadAddress;
// return true;
// }
}
else if (fileType == JST_WTFOMGBBQ)
{
uint32_t loadAddress = (buffer[0x1F] << 24) | (buffer[0x1E] << 16) | (buffer[0x1D] << 8) | buffer[0x1C];
WriteLog("FILE: Setting up homebrew (GEMDOS WTFOMGBBQ type)... Run address: $%X, length: $%X\n", loadAddress, jaguarROMSize - 0x20);
memcpy(jagMemSpace + loadAddress, buffer + 0x20, jaguarROMSize - 0x20);
delete[] buffer;
jaguarRunAddress = loadAddress;
return true;
}
// We can assume we have JST_NONE at this point. :-P
return false;
}
