ShuriZma
/
desmume
mirror of https://github.com/TASEmulators/desmume.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Firmware: Initializing the fake firmware and applying the firmware settings from an internal firmware config struct are now split into separate operations. This allows the user to freely choose between using internal firmware config or using an external firmware.dfc file for their firmware settings, regardless of whether or not they are booting from external firmware. Fixes #259. 

- Also fixes a compiling issue with compilers that are not MSVC 2015 or later. (Regression from commit ac94244.)
This commit is contained in:
rogerman 2019-03-17 21:55:00 -07:00
parent 175a471e5e
commit c6269ca7ff
9 changed files with 452 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
desmume/src/NDSSystem.cpp
View File

@ -100,7 +100,7 @@ int LagFrameFlag;
int lastLag; int lastLag;
int TotalLagFrames; int TotalLagFrames;
u8 MicSampleSelection = 0; u8 MicSampleSelection = 0;
std::vector<std::vector<u8>> micSamples; std::vector< std::vector<u8> > micSamples;
TSCalInfo TSCal; TSCalInfo TSCal;
@ -2643,7 +2643,7 @@ void NDS_Reset()
} }
bool didLoadExtFirmware = false; bool didLoadExtFirmware = false;
bool canBootFromFirmware = false; bool willBootFromFirmware = false;
bool bootResult = false; bool bootResult = false;
extFirmwareObj = new CFIRMWARE(); extFirmwareObj = new CFIRMWARE();
@ -2653,15 +2653,15 @@ void NDS_Reset()
{ {
didLoadExtFirmware = extFirmwareObj->load(CommonSettings.ExtFirmwarePath); didLoadExtFirmware = extFirmwareObj->load(CommonSettings.ExtFirmwarePath);
//we will allow a proper firmware boot, if: // We will allow a proper firmware boot, if:
//1. we have the ARM7 and ARM9 bioses (its doubtful that our HLE bios implement the necessary functions) // 1. we have the ARM7 and ARM9 bioses (its doubtful that our HLE bios implement the necessary functions)
//2. firmware is available // 2. firmware is available
//3. user has requested booting from firmware // 3. user has requested booting from firmware
canBootFromFirmware = (CommonSettings.BootFromFirmware && didLoadExtFirmware); willBootFromFirmware = (CommonSettings.BootFromFirmware && didLoadExtFirmware);
} }
// If we're doing a fake boot, then we must ensure that this value gets set before any firmware settings are changed. // If we're doing a fake boot, then we must ensure that this value gets set before any firmware settings are changed.
if (!canBootFromFirmware) if (!willBootFromFirmware)
{ {
//bios (or firmware) sets this default, which is generally not important for retail games but some homebrews are depending on //bios (or firmware) sets this default, which is generally not important for retail games but some homebrews are depending on
_MMU_write08<ARMCPU_ARM9>(REG_WRAMCNT,3); _MMU_write08<ARMCPU_ARM9>(REG_WRAMCNT,3);
@ -2672,6 +2672,12 @@ void NDS_Reset()
// what is the purpose of unpack? // what is the purpose of unpack?
extFirmwareObj->unpack(); extFirmwareObj->unpack();
} }
else
{
// If we didn't successfully load firmware from somewhere, then we need to use
// our own internal firmware as a stand-in.
NDS_InitDefaultFirmware(&MMU.fw.data);
}
// Load the firmware settings. // Load the firmware settings.
if (CommonSettings.UseExtFirmwareSettings && didLoadExtFirmware) if (CommonSettings.UseExtFirmwareSettings && didLoadExtFirmware)
@ -2685,11 +2691,11 @@ void NDS_Reset()
else else
{ {
// Otherwise, just use our version of the firmware config. // Otherwise, just use our version of the firmware config.
NDS_InitFirmwareWithConfig(CommonSettings.fwConfig); NDS_ApplyFirmwareSettingsWithConfig(&MMU.fw.data, CommonSettings.fwConfig);
} }
// Finally, boot the firmware. // Finally, boot the firmware.
if (canBootFromFirmware) if (willBootFromFirmware)
{ {
bootResult = NDS_LegitBoot(); bootResult = NDS_LegitBoot();
} }
@ -2707,7 +2713,7 @@ void NDS_Reset()
wifiHandler->CommStart(); wifiHandler->CommStart();
SPU_DeInit(); SPU_DeInit();
SPU_ReInit(!canBootFromFirmware && bootResult); SPU_ReInit(!willBootFromFirmware && bootResult);
//this needs to happen last, pretty much, since it establishes the correct scheduling state based on all of the above initialization //this needs to happen last, pretty much, since it establishes the correct scheduling state based on all of the above initialization
initSchedule(); initSchedule();

2
desmume/src/NDSSystem.h
View File

@ -686,7 +686,7 @@ extern std::string InputDisplayString;
extern int LagFrameFlag; extern int LagFrameFlag;
extern int lastLag, TotalLagFrames; extern int lastLag, TotalLagFrames;
extern u8 MicSampleSelection; extern u8 MicSampleSelection;
extern std::vector<std::vector<u8>> micSamples; extern std::vector< std::vector<u8> > micSamples;
void MovieSRAM(); void MovieSRAM();

617
desmume/src/firmware.cpp
View File

@ -1,5 +1,5 @@
/* /*
Copyright (C) 2009-2018 DeSmuME Team Copyright (C) 2009-2019 DeSmuME Team
This file is free software: you can redistribute it and/or modify This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@ -470,46 +470,7 @@ bool CFIRMWARE::unpack()
bool CFIRMWARE::loadSettings(const char *firmwareUserSettingsFilePath) bool CFIRMWARE::loadSettings(const char *firmwareUserSettingsFilePath)
{ {
if ( (firmwareUserSettingsFilePath == NULL) || (strlen(firmwareUserSettingsFilePath) == 0) ) return NDS_ApplyFirmwareSettingsWithFile(&MMU.fw.data, firmwareUserSettingsFilePath);
{
return false;
}
FILE *fp = fopen(firmwareUserSettingsFilePath, "rb");
if (fp)
{
fseek(fp, 0, SEEK_END);
if (ftell(fp) == DFC_FILE_SIZE)
{
fseek(fp, 0, SEEK_SET);
u8 *usr = new u8[SETTINGS_SIZE];
if (usr)
{
if (fread(usr, 1, DFC_ID_SIZE, fp) == DFC_ID_SIZE)
{
if (memcmp(usr, DFC_ID_CODE, DFC_ID_SIZE) == 0)
{
if (fread(usr, 1, SETTINGS_SIZE, fp) == SETTINGS_SIZE)
{
memcpy(&MMU.fw.data.userSettings0, usr, sizeof(FWUserSettings));
memcpy(&MMU.fw.data.userSettings1, usr, sizeof(FWUserSettings));
memcpy(&MMU.fw.data.wifiInfo, usr + sizeof(FWUserSettings), WIFI_SETTINGS_SIZE);
memcpy(&MMU.fw.data.wifiAP1, usr + sizeof(FWUserSettings) + WIFI_SETTINGS_SIZE, sizeof(FWAccessPointSettings));
printf("Loaded user settings from %s\n", firmwareUserSettingsFilePath);
}
}
}
delete [] usr;
usr = NULL;
}
}
else
printf("Failed loading firmware config from %s (wrong file size)\n", firmwareUserSettingsFilePath);
fclose(fp);
}
return false;
} }
bool CFIRMWARE::saveSettings(const char *firmwareUserSettingsFilePath) bool CFIRMWARE::saveSettings(const char *firmwareUserSettingsFilePath)
@ -726,7 +687,16 @@ void NDS_GetDefaultFirmwareConfig(FirmwareConfig &outConfig)
// The length of the default strings, ignoring the null-terminating character. // The length of the default strings, ignoring the null-terminating character.
outConfig.nicknameLength = strlen(defaultNickname); outConfig.nicknameLength = strlen(defaultNickname);
if (outConfig.nicknameLength > MAX_FW_NICKNAME_LENGTH)
{
outConfig.nicknameLength = MAX_FW_NICKNAME_LENGTH;
}
outConfig.messageLength = strlen(defaultMessage); outConfig.messageLength = strlen(defaultMessage);
if (outConfig.messageLength > MAX_FW_MESSAGE_LENGTH)
{
outConfig.messageLength = MAX_FW_MESSAGE_LENGTH;
}
// Copy the default char buffers into the UTF-16 string buffers. // Copy the default char buffers into the UTF-16 string buffers.
for (size_t i = 0; i < outConfig.nicknameLength; i++) for (size_t i = 0; i < outConfig.nicknameLength; i++)
@ -807,258 +777,419 @@ void NDS_GetCurrentWFCUserID(u8 *outMAC, u8 *outUserID)
} }
} }
void NDS_InitFirmwareWithConfig(const FirmwareConfig &inConfig) void NDS_ApplyFirmwareSettings(NDSFirmwareData *outFirmware,
const FW_HEADER_KEY *headerKey,
const FWUserSettings *userSettings0,
const FWUserSettings *userSettings1,
const FWWifiInfo *wifiInfo,
const FWAccessPointSettings *wifiAP1,
const FWAccessPointSettings *wifiAP2,
const FWAccessPointSettings *wifiAP3)
{ {
// Create the firmware header if (outFirmware == NULL)
NDSFirmwareData &fw = MMU.fw.data; {
memset(&fw, 0, sizeof(NDSFirmwareData)); return;
}
// Firmware identifier if (headerKey != NULL)
fw.header.identifier[0] = 'M'; {
fw.header.identifier[1] = 'A'; memcpy(&outFirmware->header.key, headerKey, sizeof(FW_HEADER_KEY));
fw.header.identifier[2] = 'C'; }
fw.header.identifier[3] = 'P';
// User Settings offset 0x3fe00 / 8 if (userSettings0 != NULL)
fw.header.userSettingsOffset = LOCAL_TO_LE_16( (u16)(offsetof(NDSFirmwareData, userSettings0) / 8) ); {
memcpy(&outFirmware->userSettings0, userSettings0, sizeof(FWUserSettings));
}
if (userSettings1 != NULL)
{
memcpy(&outFirmware->userSettings1, userSettings1, sizeof(FWUserSettings));
}
if (wifiInfo != NULL)
{
memcpy(&outFirmware->wifiInfo, wifiInfo, sizeof(FWWifiInfo));
}
if (wifiAP1 != NULL)
{
memcpy(&outFirmware->wifiAP1, wifiAP1, sizeof(FWAccessPointSettings));
}
if (wifiAP2 != NULL)
{
memcpy(&outFirmware->wifiAP2, wifiAP2, sizeof(FWAccessPointSettings));
}
if (wifiAP3 != NULL)
{
memcpy(&outFirmware->wifiAP3, wifiAP3, sizeof(FWAccessPointSettings));
}
}
bool NDS_ApplyFirmwareSettingsWithFile(NDSFirmwareData *outFirmware, const char *inFileName)
{
bool didReadExtFirmwareData = false;
u8 *extFirmwareData = NULL;
size_t fileSize = 0;
if ( (outFirmware == NULL) || (inFileName == NULL) || (strlen(inFileName) == 0) )
{
return didReadExtFirmwareData;
}
FILE *fp = fopen(inFileName, "rb");
if (fp == NULL)
{
printf("Ext. Firmware: Failed loading config from %s\n Could not open file.\n", inFileName);
return didReadExtFirmwareData;
}
fseek(fp, 0, SEEK_END);
fileSize = (size_t)ftell(fp);
if (fileSize != DFC_FILE_SIZE)
{
printf("Ext. Firmware: Failed loading config from %s\n Actual file size was %zu bytes, expected %zu bytes.\n", inFileName, fileSize, DFC_FILE_SIZE);
fclose(fp);
return didReadExtFirmwareData;
}
fseek(fp, 0, SEEK_SET);
extFirmwareData = (u8 *)malloc(SETTINGS_SIZE);
if (extFirmwareData == NULL)
{
return didReadExtFirmwareData;
}
if (fread(extFirmwareData, 1, DFC_ID_SIZE, fp) == DFC_ID_SIZE)
{
if (memcmp(extFirmwareData, DFC_ID_CODE, DFC_ID_SIZE) == 0)
{
const size_t readSettingsSize = fread(extFirmwareData, 1, SETTINGS_SIZE, fp);
didReadExtFirmwareData = (readSettingsSize == SETTINGS_SIZE);
}
}
fclose(fp);
if (didReadExtFirmwareData)
{
// Need a temp struct here because WIFI_SETTINGS_SIZE is smaller than sizeof(FWWifiInfo).
FWWifiInfo wifiInfo = outFirmware->wifiInfo;
memcpy(&wifiInfo, extFirmwareData + sizeof(FWUserSettings), WIFI_SETTINGS_SIZE);
NDS_ApplyFirmwareSettings(outFirmware,
NULL,
(FWUserSettings *)extFirmwareData,
(FWUserSettings *)extFirmwareData,
&wifiInfo,
(FWAccessPointSettings *)(extFirmwareData + sizeof(FWUserSettings) + WIFI_SETTINGS_SIZE),
NULL,
NULL);
printf("Ext. Firmware: Successfully loaded config from %s\n", inFileName);
}
free(extFirmwareData);
return didReadExtFirmwareData;
}
void NDS_ApplyFirmwareSettingsWithConfig(NDSFirmwareData *outFirmware, const FirmwareConfig &inConfig)
{
if (outFirmware == NULL)
{
return;
}
FW_HEADER_KEY headerKey = outFirmware->header.key;
FWUserSettings userSettings0 = outFirmware->userSettings0;
FWUserSettings userSettings1 = outFirmware->userSettings1;
FWWifiInfo wifiInfo = outFirmware->wifiInfo;
FWAccessPointSettings wifiAP1 = outFirmware->wifiAP1;
FWAccessPointSettings wifiAP2 = outFirmware->wifiAP2;
FWAccessPointSettings wifiAP3 = outFirmware->wifiAP3;
// NDS type // NDS type
if (inConfig.consoleType == NDS_CONSOLE_TYPE_DSI) headerKey.consoleType = inConfig.consoleType;
{
fw.header.key.consoleType = NDS_CONSOLE_TYPE_FAT;
}
else
{
fw.header.key.consoleType = inConfig.consoleType;
}
// User settings (at 0x3FE00 and 0x3FF00) // User settings (at 0x3FE00 and 0x3FF00)
fw.userSettings0.version = 5; userSettings0.favoriteColor = inConfig.favoriteColor;
fw.userSettings0.favoriteColor = inConfig.favoriteColor; userSettings0.birthdayMonth = inConfig.birthdayMonth;
fw.userSettings0.birthdayMonth = inConfig.birthdayMonth; userSettings0.birthdayDay = inConfig.birthdayDay;
fw.userSettings0.birthdayDay = inConfig.birthdayDay;
// Copy the default char buffers into the UTF-16 string buffers. // Copy the default char buffers into the UTF-16 string buffers.
fw.userSettings0.nicknameLength = LOCAL_TO_LE_16((u16)inConfig.nicknameLength); u16 nicknameLength = inConfig.nicknameLength;
fw.userSettings0.messageLength = LOCAL_TO_LE_16((u16)inConfig.messageLength); if (nicknameLength > MAX_FW_NICKNAME_LENGTH)
for (size_t i = 0; i < inConfig.nicknameLength; i++)
{ {
fw.userSettings0.nickname[i] = LOCAL_TO_LE_16(inConfig.nickname[i]); nicknameLength = MAX_FW_NICKNAME_LENGTH;
} }
for (size_t i = 0; i < inConfig.messageLength; i++) u16 messageLength = inConfig.messageLength;
if (messageLength > MAX_FW_MESSAGE_LENGTH)
{ {
fw.userSettings0.message[i] = LOCAL_TO_LE_16(inConfig.message[i]); messageLength = MAX_FW_MESSAGE_LENGTH;
}
userSettings0.nicknameLength = LOCAL_TO_LE_16(nicknameLength);
userSettings0.messageLength = LOCAL_TO_LE_16(messageLength);
memset(userSettings0.nickname, 0, MAX_FW_NICKNAME_LENGTH * sizeof(u16));
for (size_t i = 0; i < nicknameLength; i++)
{
userSettings0.nickname[i] = LOCAL_TO_LE_16(inConfig.nickname[i]);
}
memset(userSettings0.message, 0, MAX_FW_MESSAGE_LENGTH * sizeof(u16));
for (size_t i = 0; i < messageLength; i++)
{
userSettings0.message[i] = LOCAL_TO_LE_16(inConfig.message[i]);
} }
// Default touch-screen calibration settings. // Default touch-screen calibration settings.
fw.userSettings0.tscADC_x1 = LOCAL_TO_LE_16(inConfig.tscADC_x1); userSettings0.tscADC_x1 = LOCAL_TO_LE_16(inConfig.tscADC_x1);
fw.userSettings0.tscADC_y1 = LOCAL_TO_LE_16(inConfig.tscADC_y1); userSettings0.tscADC_y1 = LOCAL_TO_LE_16(inConfig.tscADC_y1);
fw.userSettings0.tscPixel_x1 = inConfig.tscPixel_x1; userSettings0.tscPixel_x1 = inConfig.tscPixel_x1;
fw.userSettings0.tscPixel_y1 = inConfig.tscPixel_y1; userSettings0.tscPixel_y1 = inConfig.tscPixel_y1;
fw.userSettings0.tscADC_x2 = LOCAL_TO_LE_16(inConfig.tscADC_x2); userSettings0.tscADC_x2 = LOCAL_TO_LE_16(inConfig.tscADC_x2);
fw.userSettings0.tscADC_y2 = LOCAL_TO_LE_16(inConfig.tscADC_y2); userSettings0.tscADC_y2 = LOCAL_TO_LE_16(inConfig.tscADC_y2);
fw.userSettings0.tscPixel_x2 = inConfig.tscPixel_x2; userSettings0.tscPixel_x2 = inConfig.tscPixel_x2;
fw.userSettings0.tscPixel_y2 = inConfig.tscPixel_y2; userSettings0.tscPixel_y2 = inConfig.tscPixel_y2;
// Default language and flags. // Default language and flags.
fw.userSettings0.languageFlags.value = 0xFC00; userSettings0.languageFlags.language = inConfig.language;
fw.userSettings0.languageFlags.language = inConfig.language; // English userSettings0.languageFlags.backlightLevel = inConfig.backlightLevel;
fw.userSettings0.languageFlags.gbaModeScreenSelection = 0;
fw.userSettings0.languageFlags.backlightLevel = inConfig.backlightLevel; // Max brightness
fw.userSettings0.languageFlags.bootmenuDisable = 0;
// Since we don't support DSi at the moment, we just fill this area with the default
// NDS data of 0xFF.
memset(fw.userSettings0.nds.unused5, 0xFF, sizeof(fw.userSettings0.nds.unused5));
// Copy the default config for userSettings0 into userSettings1. // Copy the default config for userSettings0 into userSettings1.
fw.userSettings1 = fw.userSettings0; userSettings1 = userSettings0;
fw.userSettings0.updateCounter = 0x0000; userSettings0.updateCounter = 0x0000;
fw.userSettings1.updateCounter = 0x0001; userSettings1.updateCounter = 0x0001;
fw.userSettings0.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0xFFFF, &fw.userSettings0, 0x70) ); userSettings0.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0xFFFF, &userSettings0, 0x70) );
fw.userSettings1.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0xFFFF, &fw.userSettings1, 0x70) ); userSettings1.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0xFFFF, &userSettings1, 0x70) );
// Begin setting up the WiFi info.
fw.wifiInfo.length = 0x0138;
fw.wifiInfo.version = 0;
fw.wifiInfo.channels = 0x3FFE;
fw.wifiInfo.flags = 0xFFFF;
// RF related
fw.wifiInfo.rfType = 2;
fw.wifiInfo.rfBits = 0x18;
fw.wifiInfo.rfEntries = 0x0C;
fw.wifiInfo.UNKNOWN1 = 0x01;
// Wifi I/O init values
fw.wifiInfo.wifiConfig146 = 0x0002; // 0x0044
fw.wifiInfo.wifiConfig148 = 0x0017; // 0x0046
fw.wifiInfo.wifiConfig14A = 0x0026; // 0x0048
fw.wifiInfo.wifiConfig14C = 0x1818; // 0x004A
fw.wifiInfo.wifiConfig120 = 0x0048; // 0x004C
fw.wifiInfo.wifiConfig122 = 0x4840; // 0x004E
fw.wifiInfo.wifiConfig154 = 0x0058; // 0x0050
fw.wifiInfo.wifiConfig144 = 0x0042; // 0x0052
fw.wifiInfo.wifiConfig130 = 0x0140; // 0x0054
fw.wifiInfo.wifiConfig132 = 0x8064; // 0x0056
fw.wifiInfo.wifiConfig140 = 0xE0E0; // 0x0058
fw.wifiInfo.wifiConfig142 = 0x2443; // 0x005A
fw.wifiInfo.wifiConfigPowerTX = 0x000E; // 0x005C
fw.wifiInfo.wifiConfig124 = 0x0032; // 0x005E
fw.wifiInfo.wifiConfig128 = 0x01F4; // 0x0060
fw.wifiInfo.wifiConfig150 = 0x0101; // 0x0062
// Wifi BB init values
memcpy(fw.wifiInfo.bbData, FW_BBInit, sizeof(FW_BBInit));
// Wifi RF init values
memcpy(fw.wifiInfo.Type2.rfValue, FW_RFInit, sizeof(FW_RFInit));
// Wifi channel-related init values
memcpy(fw.wifiInfo.Type2.rfChannelValue24, FW_RFChannel, sizeof(FW_RFChannel));
memcpy(fw.wifiInfo.Type2.bbChannelValue8, FW_BBChannel, sizeof(FW_BBChannel));
memset(fw.wifiInfo.Type2.rfChannelValue8, 0x10, 14);
fw.wifiInfo.UNKNOWN2 = 0x19;
fw.wifiInfo.unused4 = 0xFF;
memset(fw.wifiInfo.unused5, 0xFF, sizeof(fw.wifiInfo.unused5));
// MAC address // MAC address
fw.wifiInfo.MACAddr[0] = inConfig.MACAddress[0]; wifiInfo.MACAddr[0] = inConfig.MACAddress[0];
fw.wifiInfo.MACAddr[1] = inConfig.MACAddress[1]; wifiInfo.MACAddr[1] = inConfig.MACAddress[1];
fw.wifiInfo.MACAddr[2] = inConfig.MACAddress[2]; wifiInfo.MACAddr[2] = inConfig.MACAddress[2];
fw.wifiInfo.MACAddr[3] = inConfig.MACAddress[3]; wifiInfo.MACAddr[3] = inConfig.MACAddress[3];
fw.wifiInfo.MACAddr[4] = inConfig.MACAddress[4]; wifiInfo.MACAddr[4] = inConfig.MACAddress[4];
fw.wifiInfo.MACAddr[5] = inConfig.MACAddress[5]; wifiInfo.MACAddr[5] = inConfig.MACAddress[5];
// Wifi settings CRC16 // Wifi settings CRC16
fw.wifiInfo.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0, &fw.wifiInfo.length, fw.wifiInfo.length) ); wifiInfo.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0, &wifiInfo.length, wifiInfo.length) );
// WFC User ID, uniquely located on the first WiFi profile and no other // WFC User ID, uniquely located on the first WiFi profile and no other
fw.wifiAP1.wfcUserID[0] = inConfig.WFCUserID[0]; wifiAP1.wfcUserID[0] = inConfig.WFCUserID[0];
fw.wifiAP1.wfcUserID[1] = inConfig.WFCUserID[1]; wifiAP1.wfcUserID[1] = inConfig.WFCUserID[1];
fw.wifiAP1.wfcUserID[2] = inConfig.WFCUserID[2]; wifiAP1.wfcUserID[2] = inConfig.WFCUserID[2];
fw.wifiAP1.wfcUserID[3] = inConfig.WFCUserID[3]; wifiAP1.wfcUserID[3] = inConfig.WFCUserID[3];
fw.wifiAP1.wfcUserID[4] = inConfig.WFCUserID[4]; wifiAP1.wfcUserID[4] = inConfig.WFCUserID[4];
fw.wifiAP1.wfcUserID[5] = inConfig.WFCUserID[5]; wifiAP1.wfcUserID[5] = inConfig.WFCUserID[5];
// WiFi profiles // WiFi profiles
if ( ((*(u32 *)inConfig.ipv4Address_AP1 != 0) && (*(u32 *)inConfig.ipv4Gateway_AP1 != 0) && (inConfig.subnetMask_AP1 != 0)) || if ( ((*(u32 *)inConfig.ipv4Address_AP1 != 0) && (*(u32 *)inConfig.ipv4Gateway_AP1 != 0) && (inConfig.subnetMask_AP1 != 0)) ||
(*(u32 *)inConfig.ipv4PrimaryDNS_AP1 != 0) || (*(u32 *)inConfig.ipv4PrimaryDNS_AP1 != 0) ||
(*(u32 *)inConfig.ipv4SecondaryDNS_AP1 != 0) ) (*(u32 *)inConfig.ipv4SecondaryDNS_AP1 != 0) )
{ {
fw.wifiAP1.SSID[0] = 'S'; wifiAP1.SSID[0] = 'S';
fw.wifiAP1.SSID[1] = 'o'; wifiAP1.SSID[1] = 'o';
fw.wifiAP1.SSID[2] = 'f'; wifiAP1.SSID[2] = 'f';
fw.wifiAP1.SSID[3] = 't'; wifiAP1.SSID[3] = 't';
fw.wifiAP1.SSID[4] = 'A'; wifiAP1.SSID[4] = 'A';
fw.wifiAP1.SSID[5] = 'P'; wifiAP1.SSID[5] = 'P';
fw.wifiAP1.ipv4Address[0] = inConfig.ipv4Address_AP1[0]; wifiAP1.ipv4Address[0] = inConfig.ipv4Address_AP1[0];
fw.wifiAP1.ipv4Address[1] = inConfig.ipv4Address_AP1[1]; wifiAP1.ipv4Address[1] = inConfig.ipv4Address_AP1[1];
fw.wifiAP1.ipv4Address[2] = inConfig.ipv4Address_AP1[2]; wifiAP1.ipv4Address[2] = inConfig.ipv4Address_AP1[2];
fw.wifiAP1.ipv4Address[3] = inConfig.ipv4Address_AP1[3]; wifiAP1.ipv4Address[3] = inConfig.ipv4Address_AP1[3];
fw.wifiAP1.ipv4Gateway[0] = inConfig.ipv4Gateway_AP1[0]; wifiAP1.ipv4Gateway[0] = inConfig.ipv4Gateway_AP1[0];
fw.wifiAP1.ipv4Gateway[1] = inConfig.ipv4Gateway_AP1[1]; wifiAP1.ipv4Gateway[1] = inConfig.ipv4Gateway_AP1[1];
fw.wifiAP1.ipv4Gateway[2] = inConfig.ipv4Gateway_AP1[2]; wifiAP1.ipv4Gateway[2] = inConfig.ipv4Gateway_AP1[2];
fw.wifiAP1.ipv4Gateway[3] = inConfig.ipv4Gateway_AP1[3]; wifiAP1.ipv4Gateway[3] = inConfig.ipv4Gateway_AP1[3];
fw.wifiAP1.ipv4PrimaryDNS[0] = inConfig.ipv4PrimaryDNS_AP1[0]; wifiAP1.ipv4PrimaryDNS[0] = inConfig.ipv4PrimaryDNS_AP1[0];
fw.wifiAP1.ipv4PrimaryDNS[1] = inConfig.ipv4PrimaryDNS_AP1[1]; wifiAP1.ipv4PrimaryDNS[1] = inConfig.ipv4PrimaryDNS_AP1[1];
fw.wifiAP1.ipv4PrimaryDNS[2] = inConfig.ipv4PrimaryDNS_AP1[2]; wifiAP1.ipv4PrimaryDNS[2] = inConfig.ipv4PrimaryDNS_AP1[2];
fw.wifiAP1.ipv4PrimaryDNS[3] = inConfig.ipv4PrimaryDNS_AP1[3]; wifiAP1.ipv4PrimaryDNS[3] = inConfig.ipv4PrimaryDNS_AP1[3];
fw.wifiAP1.ipv4SecondaryDNS[0] = inConfig.ipv4SecondaryDNS_AP1[0]; wifiAP1.ipv4SecondaryDNS[0] = inConfig.ipv4SecondaryDNS_AP1[0];
fw.wifiAP1.ipv4SecondaryDNS[1] = inConfig.ipv4SecondaryDNS_AP1[1]; wifiAP1.ipv4SecondaryDNS[1] = inConfig.ipv4SecondaryDNS_AP1[1];
fw.wifiAP1.ipv4SecondaryDNS[2] = inConfig.ipv4SecondaryDNS_AP1[2]; wifiAP1.ipv4SecondaryDNS[2] = inConfig.ipv4SecondaryDNS_AP1[2];
fw.wifiAP1.ipv4SecondaryDNS[3] = inConfig.ipv4SecondaryDNS_AP1[3]; wifiAP1.ipv4SecondaryDNS[3] = inConfig.ipv4SecondaryDNS_AP1[3];
fw.wifiAP1.subnetMask = inConfig.subnetMask_AP1; wifiAP1.subnetMask = inConfig.subnetMask_AP1;
fw.wifiAP1.configureMode = 0; wifiAP1.configureMode = 0;
} }
else else
{ {
fw.wifiAP1.configureMode = 0xFF; wifiAP1.configureMode = 0xFF;
} }
if ( ((*(u32 *)inConfig.ipv4Address_AP2 != 0) && (*(u32 *)inConfig.ipv4Gateway_AP2 != 0) && (inConfig.subnetMask_AP2 != 0)) || if ( ((*(u32 *)inConfig.ipv4Address_AP2 != 0) && (*(u32 *)inConfig.ipv4Gateway_AP2 != 0) && (inConfig.subnetMask_AP2 != 0)) ||
(*(u32 *)inConfig.ipv4PrimaryDNS_AP2 != 0) || (*(u32 *)inConfig.ipv4PrimaryDNS_AP2 != 0) ||
(*(u32 *)inConfig.ipv4SecondaryDNS_AP2 != 0) ) (*(u32 *)inConfig.ipv4SecondaryDNS_AP2 != 0) )
{ {
fw.wifiAP2.SSID[0] = 'S'; wifiAP2.SSID[0] = 'S';
fw.wifiAP2.SSID[1] = 'o'; wifiAP2.SSID[1] = 'o';
fw.wifiAP2.SSID[2] = 'f'; wifiAP2.SSID[2] = 'f';
fw.wifiAP2.SSID[3] = 't'; wifiAP2.SSID[3] = 't';
fw.wifiAP2.SSID[4] = 'A'; wifiAP2.SSID[4] = 'A';
fw.wifiAP2.SSID[5] = 'P'; wifiAP2.SSID[5] = 'P';
fw.wifiAP2.ipv4Address[0] = inConfig.ipv4Address_AP2[0]; wifiAP2.ipv4Address[0] = inConfig.ipv4Address_AP2[0];
fw.wifiAP2.ipv4Address[1] = inConfig.ipv4Address_AP2[1]; wifiAP2.ipv4Address[1] = inConfig.ipv4Address_AP2[1];
fw.wifiAP2.ipv4Address[2] = inConfig.ipv4Address_AP2[2]; wifiAP2.ipv4Address[2] = inConfig.ipv4Address_AP2[2];
fw.wifiAP2.ipv4Address[3] = inConfig.ipv4Address_AP2[3]; wifiAP2.ipv4Address[3] = inConfig.ipv4Address_AP2[3];
fw.wifiAP2.ipv4Gateway[0] = inConfig.ipv4Gateway_AP2[0]; wifiAP2.ipv4Gateway[0] = inConfig.ipv4Gateway_AP2[0];
fw.wifiAP2.ipv4Gateway[1] = inConfig.ipv4Gateway_AP2[1]; wifiAP2.ipv4Gateway[1] = inConfig.ipv4Gateway_AP2[1];
fw.wifiAP2.ipv4Gateway[2] = inConfig.ipv4Gateway_AP2[2]; wifiAP2.ipv4Gateway[2] = inConfig.ipv4Gateway_AP2[2];
fw.wifiAP2.ipv4Gateway[3] = inConfig.ipv4Gateway_AP2[3]; wifiAP2.ipv4Gateway[3] = inConfig.ipv4Gateway_AP2[3];
fw.wifiAP2.ipv4PrimaryDNS[0] = inConfig.ipv4PrimaryDNS_AP2[0]; wifiAP2.ipv4PrimaryDNS[0] = inConfig.ipv4PrimaryDNS_AP2[0];
fw.wifiAP2.ipv4PrimaryDNS[1] = inConfig.ipv4PrimaryDNS_AP2[1]; wifiAP2.ipv4PrimaryDNS[1] = inConfig.ipv4PrimaryDNS_AP2[1];
fw.wifiAP2.ipv4PrimaryDNS[2] = inConfig.ipv4PrimaryDNS_AP2[2]; wifiAP2.ipv4PrimaryDNS[2] = inConfig.ipv4PrimaryDNS_AP2[2];
fw.wifiAP2.ipv4PrimaryDNS[3] = inConfig.ipv4PrimaryDNS_AP2[3]; wifiAP2.ipv4PrimaryDNS[3] = inConfig.ipv4PrimaryDNS_AP2[3];
fw.wifiAP2.ipv4SecondaryDNS[0] = inConfig.ipv4SecondaryDNS_AP2[0]; wifiAP2.ipv4SecondaryDNS[0] = inConfig.ipv4SecondaryDNS_AP2[0];
fw.wifiAP2.ipv4SecondaryDNS[1] = inConfig.ipv4SecondaryDNS_AP2[1]; wifiAP2.ipv4SecondaryDNS[1] = inConfig.ipv4SecondaryDNS_AP2[1];
fw.wifiAP2.ipv4SecondaryDNS[2] = inConfig.ipv4SecondaryDNS_AP2[2]; wifiAP2.ipv4SecondaryDNS[2] = inConfig.ipv4SecondaryDNS_AP2[2];
fw.wifiAP2.ipv4SecondaryDNS[3] = inConfig.ipv4SecondaryDNS_AP2[3]; wifiAP2.ipv4SecondaryDNS[3] = inConfig.ipv4SecondaryDNS_AP2[3];
fw.wifiAP2.subnetMask = inConfig.subnetMask_AP2; wifiAP2.subnetMask = inConfig.subnetMask_AP2;
fw.wifiAP2.configureMode = 0; wifiAP2.configureMode = 0;
} }
else else
{ {
fw.wifiAP2.configureMode = 0xFF; wifiAP2.configureMode = 0xFF;
} }
if ( ((*(u32 *)inConfig.ipv4Address_AP3 != 0) && (*(u32 *)inConfig.ipv4Gateway_AP3 != 0) && (inConfig.subnetMask_AP3 != 0)) || if ( ((*(u32 *)inConfig.ipv4Address_AP3 != 0) && (*(u32 *)inConfig.ipv4Gateway_AP3 != 0) && (inConfig.subnetMask_AP3 != 0)) ||
(*(u32 *)inConfig.ipv4PrimaryDNS_AP3 != 0) || (*(u32 *)inConfig.ipv4PrimaryDNS_AP3 != 0) ||
(*(u32 *)inConfig.ipv4SecondaryDNS_AP3 != 0) ) (*(u32 *)inConfig.ipv4SecondaryDNS_AP3 != 0) )
{ {
fw.wifiAP3.SSID[0] = 'S'; wifiAP3.SSID[0] = 'S';
fw.wifiAP3.SSID[1] = 'o'; wifiAP3.SSID[1] = 'o';
fw.wifiAP3.SSID[2] = 'f'; wifiAP3.SSID[2] = 'f';
fw.wifiAP3.SSID[3] = 't'; wifiAP3.SSID[3] = 't';
fw.wifiAP3.SSID[4] = 'A'; wifiAP3.SSID[4] = 'A';
fw.wifiAP3.SSID[5] = 'P'; wifiAP3.SSID[5] = 'P';
fw.wifiAP3.ipv4Address[0] = inConfig.ipv4Address_AP3[0]; wifiAP3.ipv4Address[0] = inConfig.ipv4Address_AP3[0];
fw.wifiAP3.ipv4Address[1] = inConfig.ipv4Address_AP3[1]; wifiAP3.ipv4Address[1] = inConfig.ipv4Address_AP3[1];
fw.wifiAP3.ipv4Address[2] = inConfig.ipv4Address_AP3[2]; wifiAP3.ipv4Address[2] = inConfig.ipv4Address_AP3[2];
fw.wifiAP3.ipv4Address[3] = inConfig.ipv4Address_AP3[3]; wifiAP3.ipv4Address[3] = inConfig.ipv4Address_AP3[3];
fw.wifiAP3.ipv4Gateway[0] = inConfig.ipv4Gateway_AP3[0]; wifiAP3.ipv4Gateway[0] = inConfig.ipv4Gateway_AP3[0];
fw.wifiAP3.ipv4Gateway[1] = inConfig.ipv4Gateway_AP3[1]; wifiAP3.ipv4Gateway[1] = inConfig.ipv4Gateway_AP3[1];
fw.wifiAP3.ipv4Gateway[2] = inConfig.ipv4Gateway_AP3[2]; wifiAP3.ipv4Gateway[2] = inConfig.ipv4Gateway_AP3[2];
fw.wifiAP3.ipv4Gateway[3] = inConfig.ipv4Gateway_AP3[3]; wifiAP3.ipv4Gateway[3] = inConfig.ipv4Gateway_AP3[3];
fw.wifiAP3.ipv4PrimaryDNS[0] = inConfig.ipv4PrimaryDNS_AP3[0]; wifiAP3.ipv4PrimaryDNS[0] = inConfig.ipv4PrimaryDNS_AP3[0];
fw.wifiAP3.ipv4PrimaryDNS[1] = inConfig.ipv4PrimaryDNS_AP3[1]; wifiAP3.ipv4PrimaryDNS[1] = inConfig.ipv4PrimaryDNS_AP3[1];
fw.wifiAP3.ipv4PrimaryDNS[2] = inConfig.ipv4PrimaryDNS_AP3[2]; wifiAP3.ipv4PrimaryDNS[2] = inConfig.ipv4PrimaryDNS_AP3[2];
fw.wifiAP3.ipv4PrimaryDNS[3] = inConfig.ipv4PrimaryDNS_AP3[3]; wifiAP3.ipv4PrimaryDNS[3] = inConfig.ipv4PrimaryDNS_AP3[3];
fw.wifiAP3.ipv4SecondaryDNS[0] = inConfig.ipv4SecondaryDNS_AP3[0]; wifiAP3.ipv4SecondaryDNS[0] = inConfig.ipv4SecondaryDNS_AP3[0];
fw.wifiAP3.ipv4SecondaryDNS[1] = inConfig.ipv4SecondaryDNS_AP3[1]; wifiAP3.ipv4SecondaryDNS[1] = inConfig.ipv4SecondaryDNS_AP3[1];
fw.wifiAP3.ipv4SecondaryDNS[2] = inConfig.ipv4SecondaryDNS_AP3[2]; wifiAP3.ipv4SecondaryDNS[2] = inConfig.ipv4SecondaryDNS_AP3[2];
fw.wifiAP3.ipv4SecondaryDNS[3] = inConfig.ipv4SecondaryDNS_AP3[3]; wifiAP3.ipv4SecondaryDNS[3] = inConfig.ipv4SecondaryDNS_AP3[3];
fw.wifiAP3.subnetMask = inConfig.subnetMask_AP3; wifiAP3.subnetMask = inConfig.subnetMask_AP3;
fw.wifiAP3.configureMode = 0; wifiAP3.configureMode = 0;
} }
else else
{ {
fw.wifiAP3.configureMode = 0xFF; wifiAP3.configureMode = 0xFF;
} }
fw.wifiAP1.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0, &fw.wifiAP1, 254) ); wifiAP1.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0, &wifiAP1, 254) );
fw.wifiAP2.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0, &fw.wifiAP2, 254) ); wifiAP2.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0, &wifiAP2, 254) );
fw.wifiAP3.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0, &fw.wifiAP3, 254) ); wifiAP3.crc16 = LOCAL_TO_LE_16( (u16)calc_CRC16(0, &wifiAP3, 254) );
if (&inConfig != &CommonSettings.fwConfig) NDS_ApplyFirmwareSettings(outFirmware,
{ &headerKey,
memcpy(&CommonSettings.fwConfig, &inConfig, sizeof(FirmwareConfig)); &userSettings0,
} &userSettings1,
&wifiInfo,
&wifiAP1,
&wifiAP2,
&wifiAP3);
} }
bool NDS_ReadFirmwareDataFromFile(const char *fileName, NDSFirmwareData *outFirmwareData, size_t *outFileSize, int *outConsoleType, u8 *outMACAddr) void NDS_InitDefaultFirmware(NDSFirmwareData *outFirmware)
{
if (outFirmware == NULL)
{
return;
}
// First, clear the firmware data with all zeroes
memset(outFirmware, 0, sizeof(NDSFirmwareData));
FirmwareConfig defaultConfig;
NDS_GetDefaultFirmwareConfig(defaultConfig);
// Firmware identifier
outFirmware->header.identifier[0] = 'M';
outFirmware->header.identifier[1] = 'A';
outFirmware->header.identifier[2] = 'C';
outFirmware->header.identifier[3] = 'P';
// User Settings offset 0x3fe00 / 8
outFirmware->header.userSettingsOffset = LOCAL_TO_LE_16( (u16)(offsetof(NDSFirmwareData, userSettings0) / 8) );
// User settings (at 0x3FE00 and 0x3FF00)
outFirmware->userSettings0.version = 5;
// Default language and flags.
outFirmware->userSettings0.languageFlags.value = 0xFC00;
outFirmware->userSettings0.languageFlags.gbaModeScreenSelection = 0;
outFirmware->userSettings0.languageFlags.bootmenuDisable = 0;
// Since we don't support DSi at the moment, we just fill this area with the default
// NDS data of 0xFF.
memset(outFirmware->userSettings0.nds.unused5, 0xFF, sizeof(outFirmware->userSettings0.nds.unused5));
// Copy the default config for userSettings0 into userSettings1.
outFirmware->userSettings1 = outFirmware->userSettings0;
// Begin setting up the WiFi info.
outFirmware->wifiInfo.length = 0x0138;
outFirmware->wifiInfo.version = 0;
outFirmware->wifiInfo.channels = 0x3FFE;
outFirmware->wifiInfo.flags = 0xFFFF;
// RF related
outFirmware->wifiInfo.rfType = 2;
outFirmware->wifiInfo.rfBits = 0x18;
outFirmware->wifiInfo.rfEntries = 0x0C;
outFirmware->wifiInfo.UNKNOWN1 = 0x01;
// Wifi I/O init values
outFirmware->wifiInfo.wifiConfig146 = 0x0002; // 0x0044
outFirmware->wifiInfo.wifiConfig148 = 0x0017; // 0x0046
outFirmware->wifiInfo.wifiConfig14A = 0x0026; // 0x0048
outFirmware->wifiInfo.wifiConfig14C = 0x1818; // 0x004A
outFirmware->wifiInfo.wifiConfig120 = 0x0048; // 0x004C
outFirmware->wifiInfo.wifiConfig122 = 0x4840; // 0x004E
outFirmware->wifiInfo.wifiConfig154 = 0x0058; // 0x0050
outFirmware->wifiInfo.wifiConfig144 = 0x0042; // 0x0052
outFirmware->wifiInfo.wifiConfig130 = 0x0140; // 0x0054
outFirmware->wifiInfo.wifiConfig132 = 0x8064; // 0x0056
outFirmware->wifiInfo.wifiConfig140 = 0xE0E0; // 0x0058
outFirmware->wifiInfo.wifiConfig142 = 0x2443; // 0x005A
outFirmware->wifiInfo.wifiConfigPowerTX = 0x000E; // 0x005C
outFirmware->wifiInfo.wifiConfig124 = 0x0032; // 0x005E
outFirmware->wifiInfo.wifiConfig128 = 0x01F4; // 0x0060
outFirmware->wifiInfo.wifiConfig150 = 0x0101; // 0x0062
// Wifi BB init values
memcpy(outFirmware->wifiInfo.bbData, FW_BBInit, sizeof(FW_BBInit));
// Wifi RF init values
memcpy(outFirmware->wifiInfo.Type2.rfValue, FW_RFInit, sizeof(FW_RFInit));
// Wifi channel-related init values
memcpy(outFirmware->wifiInfo.Type2.rfChannelValue24, FW_RFChannel, sizeof(FW_RFChannel));
memcpy(outFirmware->wifiInfo.Type2.bbChannelValue8, FW_BBChannel, sizeof(FW_BBChannel));
memset(outFirmware->wifiInfo.Type2.rfChannelValue8, 0x10, 14);
outFirmware->wifiInfo.UNKNOWN2 = 0x19;
outFirmware->wifiInfo.unused4 = 0xFF;
memset(outFirmware->wifiInfo.unused5, 0xFF, sizeof(outFirmware->wifiInfo.unused5));
NDS_ApplyFirmwareSettingsWithConfig(outFirmware, defaultConfig);
}
bool NDS_ReadFirmwareDataFromFile(const char *fileName, NDSFirmwareData *outFirmware, size_t *outFileSize, int *outConsoleType, u8 *outMACAddr)
{ {
bool result = false; bool result = false;
@ -1104,26 +1235,26 @@ bool NDS_ReadFirmwareDataFromFile(const char *fileName, NDSFirmwareData *outFirm
// pieces of data that the caller has requested. // pieces of data that the caller has requested.
result = true; result = true;
if (outFirmwareData != NULL) if (outFirmware != NULL)
{ {
fseek(fp, 0, SEEK_SET); fseek(fp, 0, SEEK_SET);
readBytes = fread(outFirmwareData, 1, sizeof(NDSFirmwareData), fp); readBytes = fread(outFirmware, 1, sizeof(NDSFirmwareData), fp);
if ( readBytes == sizeof(NDSFirmwareData) ) if ( readBytes == sizeof(NDSFirmwareData) )
{ {
if (outConsoleType != NULL) if (outConsoleType != NULL)
{ {
*outConsoleType = (int)outFirmwareData->header.key.consoleType; *outConsoleType = (int)outFirmware->header.key.consoleType;
} }
if (outMACAddr != NULL) if (outMACAddr != NULL)
{ {
outMACAddr[0] = outFirmwareData->wifiInfo.MACAddr[0]; outMACAddr[0] = outFirmware->wifiInfo.MACAddr[0];
outMACAddr[1] = outFirmwareData->wifiInfo.MACAddr[1]; outMACAddr[1] = outFirmware->wifiInfo.MACAddr[1];
outMACAddr[2] = outFirmwareData->wifiInfo.MACAddr[2]; outMACAddr[2] = outFirmware->wifiInfo.MACAddr[2];
outMACAddr[3] = outFirmwareData->wifiInfo.MACAddr[3]; outMACAddr[3] = outFirmware->wifiInfo.MACAddr[3];
outMACAddr[4] = outFirmwareData->wifiInfo.MACAddr[4]; outMACAddr[4] = outFirmware->wifiInfo.MACAddr[4];
outMACAddr[5] = outFirmwareData->wifiInfo.MACAddr[5]; outMACAddr[5] = outFirmware->wifiInfo.MACAddr[5];
} }
} }
else else

16
desmume/src/firmware.h
View File

@ -1,5 +1,5 @@
/* /*
Copyright (C) 2009-2018 DeSmuME Team Copyright (C) 2009-2019 DeSmuME Team
This file is free software: you can redistribute it and/or modify This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@ -446,8 +446,18 @@ int copy_firmware_user_data( u8 *dest_buffer, const u8 *fw_data);
void NDS_GetDefaultFirmwareConfig(FirmwareConfig &outConfig); void NDS_GetDefaultFirmwareConfig(FirmwareConfig &outConfig);
void NDS_GetCurrentWFCUserID(u8 *outMAC, u8 *outUserID); void NDS_GetCurrentWFCUserID(u8 *outMAC, u8 *outUserID);
void NDS_InitFirmwareWithConfig(const FirmwareConfig &inConfig); void NDS_ApplyFirmwareSettings(NDSFirmwareData *outFirmware,
bool NDS_ReadFirmwareDataFromFile(const char *fileName, NDSFirmwareData *outFirmwareData, size_t *outFileSize, int *outConsoleType, u8 *outMACAddr); const FW_HEADER_KEY *headerKey,
const FWUserSettings *userSettings0,
const FWUserSettings *userSettings1,
const FWWifiInfo *wifiInfo,
const FWAccessPointSettings *wifiAP1,
const FWAccessPointSettings *wifiAP2,
const FWAccessPointSettings *wifiAP3);
bool NDS_ApplyFirmwareSettingsWithFile(NDSFirmwareData *outFirmware, const char *inFileName);
void NDS_ApplyFirmwareSettingsWithConfig(NDSFirmwareData *outFirmware, const FirmwareConfig &inConfig);
void NDS_InitDefaultFirmware(NDSFirmwareData *outFirmware);
bool NDS_ReadFirmwareDataFromFile(const char *fileName, NDSFirmwareData *outFirmware, size_t *outFileSize, int *outConsoleType, u8 *outMACAddr);
struct fw_memory_chip struct fw_memory_chip
{ {

13
desmume/src/frontend/posix/cli/main.cpp
View File

@ -1,6 +1,6 @@
/* main.c - this file is part of DeSmuME /* main.c - this file is part of DeSmuME
* *
* Copyright (C) 2006-2017 DeSmuME Team * Copyright (C) 2006-2019 DeSmuME Team
* Copyright (C) 2007 Pascal Giard (evilynux) * Copyright (C) 2007 Pascal Giard (evilynux)
* *
* This file is free software; you can redistribute it and/or modify * This file is free software; you can redistribute it and/or modify
@ -500,14 +500,8 @@ int main(int argc, char ** argv) {
/* this holds some info about our display */ /* this holds some info about our display */
const SDL_VideoInfo *videoInfo; const SDL_VideoInfo *videoInfo;
/* the firmware settings */
FirmwareConfig fw_config;
NDS_Init(); NDS_Init();
/* default the firmware settings, they may get changed later */
NDS_GetDefaultFirmwareConfig(fw_config);
init_config( &my_config); init_config( &my_config);
if ( !fill_config( &my_config, argc, argv)) { if ( !fill_config( &my_config, argc, argv)) {
@ -516,7 +510,7 @@ int main(int argc, char ** argv) {
/* use any language set on the command line */ /* use any language set on the command line */
if ( my_config.firmware_language != -1) { if ( my_config.firmware_language != -1) {
fw_config.language = my_config.firmware_language; CommonSettings.fwConfig.language = my_config.firmware_language;
} }
my_config.process_addonCommands(); my_config.process_addonCommands();
@ -620,9 +614,6 @@ int main(int argc, char ** argv) {
} }
#endif #endif
/* Create the dummy firmware */
NDS_InitFirmwareWithConfig(fw_config);
if ( !my_config.disable_sound) { if ( !my_config.disable_sound) {
SPU_ChangeSoundCore(SNDCORE_SDL, 735 * 4); SPU_ChangeSoundCore(SNDCORE_SDL, 735 * 4);
} }

12
desmume/src/frontend/posix/gtk-glade/main.cpp
View File

@ -1,6 +1,6 @@
/* main.c - this file is part of DeSmuME /* main.c - this file is part of DeSmuME
* *
* Copyright (C) 2007-2015 DeSmuME Team * Copyright (C) 2007-2019 DeSmuME Team
* Copyright (C) 2007 Damien Nozay (damdoum) * Copyright (C) 2007 Damien Nozay (damdoum)
* Copyright (C) 2007 Pascal Giard (evilynux) * Copyright (C) 2007 Pascal Giard (evilynux)
* Author: damdoum at users.sourceforge.net * Author: damdoum at users.sourceforge.net
@ -353,17 +353,12 @@ joinThread_gdb( void *thread_handle) {
static int static int
common_gtk_glade_main( struct configured_features *my_config) { common_gtk_glade_main( struct configured_features *my_config) {
/* the firmware settings */
FirmwareConfig fw_config;
gchar *uifile; gchar *uifile;
GKeyFile *keyfile; GKeyFile *keyfile;
/* default the firmware settings, they may get changed later */
NDS_GetDefaultFirmwareConfig(fw_config);
/* use any language set on the command line */ /* use any language set on the command line */
if ( my_config->firmware_language != -1) { if ( my_config->firmware_language != -1) {
fw_config.language = my_config->firmware_language; CommonSettings.fwConfig.language = my_config->firmware_language;
} }
desmume_savetype(my_config->savetype); desmume_savetype(my_config->savetype);
@ -383,9 +378,6 @@ common_gtk_glade_main( struct configured_features *my_config) {
desmume_init(); desmume_init();
/* Create the dummy firmware */
NDS_InitFirmwareWithConfig(fw_config);
/* /*
* Activate the GDB stubs * Activate the GDB stubs
* This has to come after the NDS_Init (called in desmume_init) * This has to come after the NDS_Init (called in desmume_init)

14
desmume/src/frontend/posix/gtk/main.cpp
View File

@ -1,6 +1,6 @@
/* /*
Copyright (C) 2007 Pascal Giard (evilynux) Copyright (C) 2007 Pascal Giard (evilynux)
Copyright (C) 2006-2018 DeSmuME team Copyright (C) 2006-2019 DeSmuME team
This file is free software: you can redistribute it and/or modify This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@ -3018,18 +3018,11 @@ common_gtk_main( class configured_features *my_config)
GtkWidget *pMenuBar; GtkWidget *pMenuBar;
GtkWidget *pToolBar; GtkWidget *pToolBar;
/* the firmware settings */
FirmwareConfig fw_config;
/* default the firmware settings, they may get changed later */
NDS_GetDefaultFirmwareConfig(fw_config);
/* use any language set on the command line */ /* use any language set on the command line */
if ( my_config->firmware_language != -1) { if ( my_config->firmware_language != -1) {
fw_config.language = my_config->firmware_language; CommonSettings.fwConfig.language = my_config->firmware_language;
} }
//------------------addons---------- //------------------addons----------
my_config->process_addonCommands(); my_config->process_addonCommands();
@ -3143,9 +3136,6 @@ common_gtk_main( class configured_features *my_config)
} }
#endif #endif
/* Create the dummy firmware */
NDS_InitFirmwareWithConfig(fw_config);
/* Initialize joysticks */ /* Initialize joysticks */
if(!init_joy()) return 1; if(!init_joy()) return 1;

3
desmume/src/frontend/windows/main.cpp
View File

@ -2425,9 +2425,6 @@ int _main()
video.setfilter(GetPrivateProfileInt("Video", "Filter", video.NONE, IniName)); video.setfilter(GetPrivateProfileInt("Video", "Filter", video.NONE, IniName));
FilterUpdate(MainWindow->getHWnd(),false); FilterUpdate(MainWindow->getHWnd(),false);
//default the firmware settings, they may get changed later
NDS_GetDefaultFirmwareConfig(CommonSettings.fwConfig);
// Generate the unique MAC address. // Generate the unique MAC address.
{ {
// Get the host's IP4 address. // Get the host's IP4 address.

9
desmume/src/movie.cpp
View File

@ -1,5 +1,5 @@
/* /*
Copyright 2008-2018 DeSmuME team Copyright 2008-2019 DeSmuME team
This file is free software: you can redistribute it and/or modify This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@ -630,7 +630,8 @@ static void LoadSettingsFromMovie(MovieData movieData)
CommonSettings.fwConfig.language = movieData.firmLanguage; CommonSettings.fwConfig.language = movieData.firmLanguage;
// reset firmware (some games can write to it) // reset firmware (some games can write to it)
NDS_InitFirmwareWithConfig(CommonSettings.fwConfig); NDS_InitDefaultFirmware(&MMU.fw.data);
NDS_ApplyFirmwareSettingsWithConfig(&MMU.fw.data, CommonSettings.fwConfig);
} }
if (movieData.advancedTiming != -1) if (movieData.advancedTiming != -1)
CommonSettings.advanced_timing = movieData.advancedTiming; CommonSettings.advanced_timing = movieData.advancedTiming;
@ -822,10 +823,10 @@ void FCEUI_SaveMovie(const char *fname, std::wstring author, START_FROM startFro
// reset firmware (some games can write to it) // reset firmware (some games can write to it)
if (!CommonSettings.UseExtFirmware) if (!CommonSettings.UseExtFirmware)
{ {
NDS_InitFirmwareWithConfig(CommonSettings.fwConfig); NDS_InitDefaultFirmware(&MMU.fw.data);
NDS_ApplyFirmwareSettingsWithConfig(&MMU.fw.data, CommonSettings.fwConfig);
} }
if (startFrom == START_SAVESTATE) if (startFrom == START_SAVESTATE)
{ {
// SS file name should be the same as the movie file name, except for extension // SS file name should be the same as the movie file name, except for extension