mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-02-10 14:39:01 +01:00
Core: Convert logging over to fmt pt.3
Continues the migration over to fmt up to IOS' ES module.
This commit is contained in:
Lioncash
parent
858d7612ef
commit
cbbf044064
@ -22,10 +22,10 @@ bool GCIFile::LoadHeader()
|
||||
if (!save_file)
|
||||
return false;
|
||||
|
||||
INFO_LOG(EXPANSIONINTERFACE, "Reading header from disk for %s", m_filename.c_str());
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "Reading header from disk for {}", m_filename);
|
||||
if (!save_file.ReadBytes(&m_gci_header, sizeof(m_gci_header)))
|
||||
{
|
||||
ERROR_LOG(EXPANSIONINTERFACE, "Failed to read header for %s", m_filename.c_str());
|
||||
ERROR_LOG_FMT(EXPANSIONINTERFACE, "Failed to read header for {}", m_filename);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -43,17 +43,17 @@ bool GCIFile::LoadSaveBlocks()
|
||||
if (!save_file)
|
||||
return false;
|
||||
|
||||
INFO_LOG(EXPANSIONINTERFACE, "Reading savedata from disk for %s", m_filename.c_str());
|
||||
u16 num_blocks = m_gci_header.m_block_count;
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "Reading savedata from disk for {}", m_filename);
|
||||
const u16 num_blocks = m_gci_header.m_block_count;
|
||||
|
||||
const u32 size = num_blocks * BLOCK_SIZE;
|
||||
u64 file_size = save_file.GetSize();
|
||||
const u64 file_size = save_file.GetSize();
|
||||
if (file_size != size + DENTRY_SIZE)
|
||||
{
|
||||
ERROR_LOG(EXPANSIONINTERFACE,
|
||||
"%s\nwas not loaded because it is an invalid GCI.\n File size (0x%" PRIx64
|
||||
") does not match the size recorded in the header (0x%x)",
|
||||
m_filename.c_str(), file_size, size + DENTRY_SIZE);
|
||||
ERROR_LOG_FMT(EXPANSIONINTERFACE,
|
||||
"{}\nwas not loaded because it is an invalid GCI.\n File size ({:#x}) does not "
|
||||
"match the size recorded in the header ({:#x})",
|
||||
m_filename.c_str(), file_size, size + DENTRY_SIZE);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -61,7 +61,7 @@ bool GCIFile::LoadSaveBlocks()
|
||||
save_file.Seek(DENTRY_SIZE, SEEK_SET);
|
||||
if (!save_file.ReadBytes(m_save_data.data(), size))
|
||||
{
|
||||
ERROR_LOG(EXPANSIONINTERFACE, "Failed to read data from GCI file %s", m_filename.c_str());
|
||||
ERROR_LOG_FMT(EXPANSIONINTERFACE, "Failed to read data from GCI file {}", m_filename);
|
||||
m_save_data.clear();
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -889,7 +889,7 @@ GCMemcardImportFileRetVal GCMemcard::ImportFile(const DEntry& direntry,
|
||||
for (int i = 0; i < fileBlocks; ++i)
|
||||
{
|
||||
if (firstBlock == 0xFFFF)
|
||||
PanicAlert("Fatal Error");
|
||||
PanicAlertFmt("Fatal Error");
|
||||
m_data_blocks[firstBlock - MC_FST_BLOCKS] = saveBlocks[i];
|
||||
if (i == fileBlocks - 1)
|
||||
nextBlock = 0xFFFF;
|
||||
|
||||
@ -44,10 +44,10 @@ bool GCMemcardDirectory::LoadGCI(Memcard::GCIFile gci)
|
||||
{
|
||||
if (gci.m_gci_header.GCI_FileName() == already_loaded_gci.m_gci_header.GCI_FileName())
|
||||
{
|
||||
ERROR_LOG(EXPANSIONINTERFACE,
|
||||
"%s\nwas not loaded because it has the same internal filename as previously "
|
||||
"loaded save\n%s",
|
||||
gci.m_filename.c_str(), already_loaded_gci.m_filename.c_str());
|
||||
ERROR_LOG_FMT(EXPANSIONINTERFACE,
|
||||
"{}\nwas not loaded because it has the same internal filename as previously "
|
||||
"loaded save\n{}",
|
||||
gci.m_filename, already_loaded_gci.m_filename);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@ -58,26 +58,27 @@ bool GCMemcardDirectory::LoadGCI(Memcard::GCIFile gci)
|
||||
const u16 num_blocks = gci.m_gci_header.m_block_count;
|
||||
if (num_blocks > 2043)
|
||||
{
|
||||
ERROR_LOG(EXPANSIONINTERFACE,
|
||||
"%s\nwas not loaded because it is an invalid GCI.\nNumber of blocks claimed to be %u",
|
||||
gci.m_filename.c_str(), num_blocks);
|
||||
ERROR_LOG_FMT(
|
||||
EXPANSIONINTERFACE,
|
||||
"{}\nwas not loaded because it is an invalid GCI.\nNumber of blocks claimed to be {}",
|
||||
gci.m_filename, num_blocks);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!gci.LoadSaveBlocks())
|
||||
{
|
||||
ERROR_LOG(EXPANSIONINTERFACE, "Failed to load data of %s", gci.m_filename.c_str());
|
||||
ERROR_LOG_FMT(EXPANSIONINTERFACE, "Failed to load data of {}", gci.m_filename);
|
||||
return false;
|
||||
}
|
||||
|
||||
// reserve storage for the save file in the BAT
|
||||
u16 first_block = m_bat1.AssignBlocksContiguous(num_blocks);
|
||||
const u16 first_block = m_bat1.AssignBlocksContiguous(num_blocks);
|
||||
if (first_block == 0xFFFF)
|
||||
{
|
||||
ERROR_LOG(
|
||||
ERROR_LOG_FMT(
|
||||
EXPANSIONINTERFACE,
|
||||
"%s\nwas not loaded because there are not enough free blocks on the virtual memory card",
|
||||
gci.m_filename.c_str());
|
||||
"{}\nwas not loaded because there are not enough free blocks on the virtual memory card",
|
||||
gci.m_filename);
|
||||
return false;
|
||||
}
|
||||
gci.m_gci_header.m_first_block = first_block;
|
||||
@ -174,7 +175,7 @@ GCMemcardDirectory::GCMemcardDirectory(const std::string& directory, int slot,
|
||||
gci.m_dirty = false;
|
||||
if (!gci.LoadHeader())
|
||||
{
|
||||
ERROR_LOG(EXPANSIONINTERFACE, "Failed to load header of %s", filename.c_str());
|
||||
ERROR_LOG_FMT(EXPANSIONINTERFACE, "Failed to load header of {}", filename);
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -329,7 +330,7 @@ s32 GCMemcardDirectory::Write(u32 dest_address, s32 length, const u8* src_addres
|
||||
{
|
||||
std::unique_lock<std::mutex> l(m_write_mutex);
|
||||
if (length != 0x80)
|
||||
INFO_LOG(EXPANSIONINTERFACE, "Writing to 0x%x. Length: 0x%x", dest_address, length);
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "Writing to {:#x}. Length: {:#x}", dest_address, length);
|
||||
s32 block = dest_address / Memcard::BLOCK_SIZE;
|
||||
u32 offset = dest_address % Memcard::BLOCK_SIZE;
|
||||
s32 extra = 0; // used for write calls that are across multiple blocks
|
||||
@ -377,7 +378,7 @@ s32 GCMemcardDirectory::Write(u32 dest_address, s32 length, const u8* src_addres
|
||||
m_last_block = SaveAreaRW(block, true);
|
||||
if (m_last_block == -1)
|
||||
{
|
||||
PanicAlertT("Report: GCIFolder Writing to unallocated block 0x%x", block);
|
||||
PanicAlertFmtT("Report: GCIFolder Writing to unallocated block {0:#x}", block);
|
||||
exit(0);
|
||||
}
|
||||
}
|
||||
@ -397,12 +398,12 @@ void GCMemcardDirectory::ClearBlock(u32 address)
|
||||
{
|
||||
if (address % Memcard::BLOCK_SIZE)
|
||||
{
|
||||
PanicAlertT("GCMemcardDirectory: ClearBlock called with invalid block address");
|
||||
PanicAlertFmtT("GCMemcardDirectory: ClearBlock called with invalid block address");
|
||||
return;
|
||||
}
|
||||
|
||||
u32 block = address / Memcard::BLOCK_SIZE;
|
||||
INFO_LOG(EXPANSIONINTERFACE, "Clearing block %u", block);
|
||||
const u32 block = address / Memcard::BLOCK_SIZE;
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "Clearing block {}", block);
|
||||
switch (block)
|
||||
{
|
||||
case 0:
|
||||
@ -446,8 +447,8 @@ inline void GCMemcardDirectory::SyncSaves()
|
||||
{
|
||||
if (current->m_dir_entries[i].m_gamecode != Memcard::DEntry::UNINITIALIZED_GAMECODE)
|
||||
{
|
||||
INFO_LOG(EXPANSIONINTERFACE, "Syncing save 0x%x",
|
||||
Common::swap32(current->m_dir_entries[i].m_gamecode.data()));
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "Syncing save {:#x}",
|
||||
Common::swap32(current->m_dir_entries[i].m_gamecode.data()));
|
||||
bool added = false;
|
||||
while (i >= m_saves.size())
|
||||
{
|
||||
@ -467,15 +468,16 @@ inline void GCMemcardDirectory::SyncSaves()
|
||||
|
||||
if ((gamecode != 0xFFFFFFFF) && (gamecode != new_gamecode))
|
||||
{
|
||||
PanicAlertT("Game overwrote with another games save. Data corruption ahead 0x%x, 0x%x",
|
||||
Common::swap32(m_saves[i].m_gci_header.m_gamecode.data()),
|
||||
Common::swap32(current->m_dir_entries[i].m_gamecode.data()));
|
||||
PanicAlertFmtT(
|
||||
"Game overwrote with another games save. Data corruption ahead {0:#x}, {1:#x}",
|
||||
Common::swap32(m_saves[i].m_gci_header.m_gamecode.data()),
|
||||
Common::swap32(current->m_dir_entries[i].m_gamecode.data()));
|
||||
}
|
||||
memcpy((u8*)&(m_saves[i].m_gci_header), (u8*)&(current->m_dir_entries[i]),
|
||||
Memcard::DENTRY_SIZE);
|
||||
if (old_start != new_start)
|
||||
{
|
||||
INFO_LOG(EXPANSIONINTERFACE, "Save moved from 0x%x to 0x%x", old_start, new_start);
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "Save moved from {:#x} to {:#x}", old_start, new_start);
|
||||
m_saves[i].m_used_blocks.clear();
|
||||
m_saves[i].m_save_data.clear();
|
||||
}
|
||||
@ -487,8 +489,8 @@ inline void GCMemcardDirectory::SyncSaves()
|
||||
}
|
||||
else if ((i < m_saves.size()) && (*(u32*)&(m_saves[i].m_gci_header) != 0xFFFFFFFF))
|
||||
{
|
||||
INFO_LOG(EXPANSIONINTERFACE, "Clearing and/or deleting save 0x%x",
|
||||
Common::swap32(m_saves[i].m_gci_header.m_gamecode.data()));
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "Clearing and/or deleting save {:#x}",
|
||||
Common::swap32(m_saves[i].m_gci_header.m_gamecode.data()));
|
||||
m_saves[i].m_gci_header.m_gamecode = Memcard::DEntry::UNINITIALIZED_GAMECODE;
|
||||
m_saves[i].m_save_data.clear();
|
||||
m_saves[i].m_used_blocks.clear();
|
||||
@ -570,18 +572,19 @@ bool GCMemcardDirectory::SetUsedBlocks(int save_index)
|
||||
block = current_bat->GetNextBlock(block);
|
||||
if (block == 0)
|
||||
{
|
||||
PanicAlertT("BAT incorrect. Dolphin will now exit");
|
||||
PanicAlertFmtT("BAT incorrect. Dolphin will now exit");
|
||||
exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
u16 num_blocks = m_saves[save_index].m_gci_header.m_block_count;
|
||||
u16 blocks_from_bat = (u16)m_saves[save_index].m_used_blocks.size();
|
||||
const u16 num_blocks = m_saves[save_index].m_gci_header.m_block_count;
|
||||
const u16 blocks_from_bat = static_cast<u16>(m_saves[save_index].m_used_blocks.size());
|
||||
if (blocks_from_bat != num_blocks)
|
||||
{
|
||||
PanicAlertT("Warning: Number of blocks indicated by the BAT (%u) does not match that of the "
|
||||
"loaded file header (%u)",
|
||||
blocks_from_bat, num_blocks);
|
||||
PanicAlertFmtT(
|
||||
"Warning: Number of blocks indicated by the BAT ({0}) does not match that of the "
|
||||
"loaded file header ({1})",
|
||||
blocks_from_bat, num_blocks);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -605,8 +608,8 @@ void GCMemcardDirectory::FlushToFile()
|
||||
// The save's header has been changed but the actual save blocks haven't been read/written
|
||||
// to
|
||||
// skip flushing this file until actual save data is modified
|
||||
ERROR_LOG(EXPANSIONINTERFACE,
|
||||
"GCI header modified without corresponding save data changes");
|
||||
ERROR_LOG_FMT(EXPANSIONINTERFACE,
|
||||
"GCI header modified without corresponding save data changes");
|
||||
continue;
|
||||
}
|
||||
if (save.m_filename.empty())
|
||||
@ -621,8 +624,10 @@ void GCMemcardDirectory::FlushToFile()
|
||||
default_save_name.insert(default_save_name.end() - 4, '0');
|
||||
}
|
||||
if (File::Exists(default_save_name))
|
||||
PanicAlertT("Failed to find new filename.\n%s\n will be overwritten",
|
||||
default_save_name.c_str());
|
||||
{
|
||||
PanicAlertFmtT("Failed to find new filename.\n{0}\n will be overwritten",
|
||||
default_save_name);
|
||||
}
|
||||
save.m_filename = default_save_name;
|
||||
}
|
||||
File::IOFile gci(save.m_filename, "wb");
|
||||
@ -641,7 +646,7 @@ void GCMemcardDirectory::FlushToFile()
|
||||
++errors;
|
||||
Core::DisplayMessage(
|
||||
fmt::format("Failed to write save contents to {}", save.m_filename), 4000);
|
||||
ERROR_LOG(EXPANSIONINTERFACE, "Failed to save data to %s", save.m_filename.c_str());
|
||||
ERROR_LOG_FMT(EXPANSIONINTERFACE, "Failed to save data to {}", save.m_filename);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -667,7 +672,7 @@ void GCMemcardDirectory::FlushToFile()
|
||||
const u32 gamecode = Common::swap32(save.m_gci_header.m_gamecode.data());
|
||||
if (gamecode != m_game_id && gamecode != 0xFFFFFFFF && !save.m_save_data.empty())
|
||||
{
|
||||
INFO_LOG(EXPANSIONINTERFACE, "Flushing savedata to disk for %s", save.m_filename.c_str());
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "Flushing savedata to disk for {}", save.m_filename);
|
||||
save.m_save_data.clear();
|
||||
}
|
||||
}
|
||||
|
||||
@ -45,7 +45,7 @@ MemoryCard::MemoryCard(const std::string& filename, int card_index, u16 size_mbi
|
||||
m_memcard_data = std::make_unique<u8[]>(m_memory_card_size);
|
||||
memset(&m_memcard_data[0], 0xFF, m_memory_card_size);
|
||||
|
||||
INFO_LOG(EXPANSIONINTERFACE, "Reading memory card %s", m_filename.c_str());
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "Reading memory card {}", m_filename);
|
||||
file.ReadBytes(&m_memcard_data[0], m_memory_card_size);
|
||||
}
|
||||
else
|
||||
@ -69,7 +69,7 @@ MemoryCard::MemoryCard(const std::string& filename, int card_index, u16 size_mbi
|
||||
// Fills in the remaining blocks
|
||||
memset(&m_memcard_data[MC_HDR_SIZE], 0xFF, m_memory_card_size - MC_HDR_SIZE);
|
||||
|
||||
INFO_LOG(EXPANSIONINTERFACE, "No memory card found. A new one was created instead.");
|
||||
INFO_LOG_FMT(EXPANSIONINTERFACE, "No memory card found. A new one was created instead.");
|
||||
}
|
||||
|
||||
// Class members (including inherited ones) have now been initialized, so
|
||||
@ -113,15 +113,15 @@ void MemoryCard::CheckPath(std::string& memcardPath, const std::string& gameRegi
|
||||
// If the old file exists we are polite and ask if we should copy it
|
||||
std::string oldFilename = filename;
|
||||
filename.replace(filename.size() - 4, 4, ext);
|
||||
if (PanicYesNoT("Memory Card filename in Slot %c is incorrect\n"
|
||||
"Region not specified\n\n"
|
||||
"Slot %c path was changed to\n"
|
||||
"%s\n"
|
||||
"Would you like to copy the old file to this new location?\n",
|
||||
isSlotA ? 'A' : 'B', isSlotA ? 'A' : 'B', filename.c_str()))
|
||||
if (PanicYesNoFmtT("Memory Card filename in Slot {0} is incorrect\n"
|
||||
"Region not specified\n\n"
|
||||
"Slot {1} path was changed to\n"
|
||||
"{2}\n"
|
||||
"Would you like to copy the old file to this new location?\n",
|
||||
isSlotA ? 'A' : 'B', isSlotA ? 'A' : 'B', filename))
|
||||
{
|
||||
if (!File::Copy(oldFilename, filename))
|
||||
PanicAlertT("Copy failed");
|
||||
PanicAlertFmtT("Copy failed");
|
||||
}
|
||||
}
|
||||
memcardPath = filename; // Always correct the path!
|
||||
@ -178,12 +178,12 @@ void MemoryCard::FlushThread()
|
||||
// Note - file may have changed above, after ctor
|
||||
if (!file)
|
||||
{
|
||||
PanicAlertT(
|
||||
"Could not write memory card file %s.\n\n"
|
||||
PanicAlertFmtT(
|
||||
"Could not write memory card file {0}.\n\n"
|
||||
"Are you running Dolphin from a CD/DVD, or is the save file maybe write protected?\n\n"
|
||||
"Are you receiving this after moving the emulator directory?\nIf so, then you may "
|
||||
"need to re-specify your memory card location in the options.",
|
||||
m_filename.c_str());
|
||||
m_filename);
|
||||
|
||||
// Exit the flushing thread - further flushes will be ignored unless
|
||||
// the thread is recreated.
|
||||
@ -214,7 +214,7 @@ s32 MemoryCard::Read(u32 src_address, s32 length, u8* dest_address)
|
||||
{
|
||||
if (!IsAddressInBounds(src_address))
|
||||
{
|
||||
PanicAlertT("MemoryCard: Read called with invalid source address (0x%x)", src_address);
|
||||
PanicAlertFmtT("MemoryCard: Read called with invalid source address ({0:#x})", src_address);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -226,7 +226,8 @@ s32 MemoryCard::Write(u32 dest_address, s32 length, const u8* src_address)
|
||||
{
|
||||
if (!IsAddressInBounds(dest_address))
|
||||
{
|
||||
PanicAlertT("MemoryCard: Write called with invalid destination address (0x%x)", dest_address);
|
||||
PanicAlertFmtT("MemoryCard: Write called with invalid destination address ({0:#x})",
|
||||
dest_address);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -242,7 +243,7 @@ void MemoryCard::ClearBlock(u32 address)
|
||||
{
|
||||
if (address & (Memcard::BLOCK_SIZE - 1) || !IsAddressInBounds(address))
|
||||
{
|
||||
PanicAlertT("MemoryCard: ClearBlock called on invalid address (0x%x)", address);
|
||||
PanicAlertFmtT("MemoryCard: ClearBlock called on invalid address ({0:#x})", address);
|
||||
return;
|
||||
}
|
||||
else
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
|
||||
#include "Common/ChunkFile.h"
|
||||
#include "Common/CommonTypes.h"
|
||||
#include "Common/Logging/Log.h"
|
||||
#include "Common/Swap.h"
|
||||
#include "Core/ConfigManager.h"
|
||||
#include "Core/CoreTiming.h"
|
||||
@ -294,17 +295,18 @@ static void RunSIBuffer(u64 user_data, s64 cycles_late)
|
||||
{
|
||||
if (s_com_csr.TSTART)
|
||||
{
|
||||
u32 request_length = ConvertSILengthField(s_com_csr.OUTLNGTH);
|
||||
u32 expected_response_length = ConvertSILengthField(s_com_csr.INLNGTH);
|
||||
std::vector<u8> request_copy(s_si_buffer.data(), s_si_buffer.data() + request_length);
|
||||
const u32 request_length = ConvertSILengthField(s_com_csr.OUTLNGTH);
|
||||
const u32 expected_response_length = ConvertSILengthField(s_com_csr.INLNGTH);
|
||||
const std::vector<u8> request_copy(s_si_buffer.data(), s_si_buffer.data() + request_length);
|
||||
|
||||
std::unique_ptr<ISIDevice>& device = s_channel[s_com_csr.CHANNEL].device;
|
||||
u32 actual_response_length = device->RunBuffer(s_si_buffer.data(), request_length);
|
||||
const std::unique_ptr<ISIDevice>& device = s_channel[s_com_csr.CHANNEL].device;
|
||||
const u32 actual_response_length = device->RunBuffer(s_si_buffer.data(), request_length);
|
||||
|
||||
DEBUG_LOG(SERIALINTERFACE,
|
||||
"RunSIBuffer chan: %d request_length: %u expected_response_length: %u "
|
||||
"actual_response_length: %u",
|
||||
s_com_csr.CHANNEL, request_length, expected_response_length, actual_response_length);
|
||||
DEBUG_LOG_FMT(SERIALINTERFACE,
|
||||
"RunSIBuffer chan: {} request_length: {} expected_response_length: {} "
|
||||
"actual_response_length: {}",
|
||||
s_com_csr.CHANNEL, request_length, expected_response_length,
|
||||
actual_response_length);
|
||||
if (expected_response_length != actual_response_length)
|
||||
{
|
||||
std::ostringstream ss;
|
||||
@ -312,10 +314,10 @@ static void RunSIBuffer(u64 user_data, s64 cycles_late)
|
||||
{
|
||||
ss << std::hex << std::setw(2) << std::setfill('0') << (int)b << ' ';
|
||||
}
|
||||
DEBUG_LOG(
|
||||
DEBUG_LOG_FMT(
|
||||
SERIALINTERFACE,
|
||||
"RunSIBuffer: expected_response_length(%u) != actual_response_length(%u): request: %s",
|
||||
expected_response_length, actual_response_length, ss.str().c_str());
|
||||
"RunSIBuffer: expected_response_length({}) != actual_response_length({}): request: {}",
|
||||
expected_response_length, actual_response_length, ss.str());
|
||||
}
|
||||
|
||||
// TODO:
|
||||
|
||||
@ -66,8 +66,8 @@ SIDevices ISIDevice::GetDeviceType() const
|
||||
int ISIDevice::RunBuffer(u8* buffer, int request_length)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
DEBUG_LOG(SERIALINTERFACE, "Send Data Device(%i) - Length(%i) ", m_device_number,
|
||||
request_length);
|
||||
DEBUG_LOG_FMT(SERIALINTERFACE, "Send Data Device({}) - Length({}) ", m_device_number,
|
||||
request_length);
|
||||
|
||||
std::string temp;
|
||||
int num = 0;
|
||||
@ -79,12 +79,12 @@ int ISIDevice::RunBuffer(u8* buffer, int request_length)
|
||||
|
||||
if ((num % 8) == 0)
|
||||
{
|
||||
DEBUG_LOG(SERIALINTERFACE, "%s", temp.c_str());
|
||||
DEBUG_LOG_FMT(SERIALINTERFACE, "{}", temp);
|
||||
temp.clear();
|
||||
}
|
||||
}
|
||||
|
||||
DEBUG_LOG(SERIALINTERFACE, "%s", temp.c_str());
|
||||
DEBUG_LOG_FMT(SERIALINTERFACE, "{}", temp);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -300,8 +300,8 @@ int CSIDevice_GBA::RunBuffer(u8* buffer, int request_length)
|
||||
if (m_sock_server.Connect())
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
NOTICE_LOG(SERIALINTERFACE, "%01d cmd %02x [> %02x%02x%02x%02x]", m_device_number, buffer[0],
|
||||
buffer[1], buffer[2], buffer[3], buffer[4]);
|
||||
NOTICE_LOG_FMT(SERIALINTERFACE, "{} cmd {:02x} [> {:02x}{:02x}{:02x}{:02x}]", m_device_number,
|
||||
buffer[0], buffer[1], buffer[2], buffer[3], buffer[4]);
|
||||
#endif
|
||||
m_sock_server.Send(buffer);
|
||||
}
|
||||
@ -341,16 +341,17 @@ int CSIDevice_GBA::RunBuffer(u8* buffer, int request_length)
|
||||
const Common::Log::LOG_LEVELS log_level =
|
||||
(m_last_cmd == CMD_STATUS || m_last_cmd == CMD_RESET) ? Common::Log::LERROR :
|
||||
Common::Log::LWARNING;
|
||||
GENERIC_LOG(Common::Log::SERIALINTERFACE, log_level,
|
||||
"%01d [< %02x%02x%02x%02x%02x] (%i)", m_device_number,
|
||||
buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], num_data_received);
|
||||
GENERIC_LOG_FMT(Common::Log::SERIALINTERFACE, log_level,
|
||||
"{} [< {:02x}{:02x}{:02x}{:02x}{:02x}] ({})",
|
||||
m_device_number, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4],
|
||||
num_data_received);
|
||||
#endif
|
||||
return num_data_received;
|
||||
}
|
||||
}
|
||||
|
||||
// This should never happen, but appease MSVC which thinks it might.
|
||||
ERROR_LOG(SERIALINTERFACE, "Unknown state %i\n", static_cast<int>(m_next_action));
|
||||
ERROR_LOG_FMT(SERIALINTERFACE, "Unknown state {}\n", m_next_action);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -65,7 +65,7 @@ int CSIDevice_GCController::RunBuffer(u8* buffer, int request_length)
|
||||
|
||||
case CMD_DIRECT:
|
||||
{
|
||||
INFO_LOG(SERIALINTERFACE, "PAD - Direct (Request length: %d)", request_length);
|
||||
INFO_LOG_FMT(SERIALINTERFACE, "PAD - Direct (Request length: {})", request_length);
|
||||
u32 high, low;
|
||||
GetData(high, low);
|
||||
for (int i = 0; i < 4; i++)
|
||||
@ -78,7 +78,7 @@ int CSIDevice_GCController::RunBuffer(u8* buffer, int request_length)
|
||||
|
||||
case CMD_ORIGIN:
|
||||
{
|
||||
INFO_LOG(SERIALINTERFACE, "PAD - Get Origin");
|
||||
INFO_LOG_FMT(SERIALINTERFACE, "PAD - Get Origin");
|
||||
|
||||
u8* calibration = reinterpret_cast<u8*>(&m_origin);
|
||||
for (int i = 0; i < (int)sizeof(SOrigin); i++)
|
||||
@ -91,7 +91,7 @@ int CSIDevice_GCController::RunBuffer(u8* buffer, int request_length)
|
||||
// Recalibrate (FiRES: i am not 100 percent sure about this)
|
||||
case CMD_RECALIBRATE:
|
||||
{
|
||||
INFO_LOG(SERIALINTERFACE, "PAD - Recalibrate");
|
||||
INFO_LOG_FMT(SERIALINTERFACE, "PAD - Recalibrate");
|
||||
|
||||
u8* calibration = reinterpret_cast<u8*>(&m_origin);
|
||||
for (int i = 0; i < (int)sizeof(SOrigin); i++)
|
||||
@ -104,8 +104,8 @@ int CSIDevice_GCController::RunBuffer(u8* buffer, int request_length)
|
||||
// DEFAULT
|
||||
default:
|
||||
{
|
||||
ERROR_LOG(SERIALINTERFACE, "Unknown SI command (0x%x)", command);
|
||||
PanicAlert("SI: Unknown command (0x%x)", command);
|
||||
ERROR_LOG_FMT(SERIALINTERFACE, "Unknown SI command ({:#x})", command);
|
||||
PanicAlertFmt("SI: Unknown command ({:#x})", command);
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -263,12 +263,12 @@ CSIDevice_GCController::HandleButtonCombos(const GCPadStatus& pad_status)
|
||||
{
|
||||
if (m_last_button_combo == COMBO_RESET)
|
||||
{
|
||||
INFO_LOG(SERIALINTERFACE, "PAD - COMBO_RESET");
|
||||
INFO_LOG_FMT(SERIALINTERFACE, "PAD - COMBO_RESET");
|
||||
ProcessorInterface::ResetButton_Tap();
|
||||
}
|
||||
else if (m_last_button_combo == COMBO_ORIGIN)
|
||||
{
|
||||
INFO_LOG(SERIALINTERFACE, "PAD - COMBO_ORIGIN");
|
||||
INFO_LOG_FMT(SERIALINTERFACE, "PAD - COMBO_ORIGIN");
|
||||
SetOrigin(pad_status);
|
||||
}
|
||||
|
||||
@ -303,7 +303,7 @@ void CSIDevice_GCController::SendCommand(u32 command, u8 poll)
|
||||
|
||||
case CMD_WRITE:
|
||||
{
|
||||
unsigned int type = controller_command.parameter1; // 0 = stop, 1 = rumble, 2 = stop hard
|
||||
const u32 type = controller_command.parameter1; // 0 = stop, 1 = rumble, 2 = stop hard
|
||||
|
||||
// get the correct pad number that should rumble locally when using netplay
|
||||
const int pad_num = NetPlay_InGamePadToLocalPad(m_device_number);
|
||||
@ -316,18 +316,18 @@ void CSIDevice_GCController::SendCommand(u32 command, u8 poll)
|
||||
CSIDevice_GCController::Rumble(pad_num, 0.0);
|
||||
}
|
||||
|
||||
if (!poll)
|
||||
if (poll == 0)
|
||||
{
|
||||
m_mode = controller_command.parameter2;
|
||||
INFO_LOG(SERIALINTERFACE, "PAD %i set to mode %i", m_device_number, m_mode);
|
||||
INFO_LOG_FMT(SERIALINTERFACE, "PAD {} set to mode {}", m_device_number, m_mode);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
{
|
||||
ERROR_LOG(SERIALINTERFACE, "Unknown direct command (0x%x)", command);
|
||||
PanicAlert("SI: Unknown direct command");
|
||||
ERROR_LOG_FMT(SERIALINTERFACE, "Unknown direct command ({:#x})", command);
|
||||
PanicAlertFmt("SI: Unknown direct command");
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
@ -129,15 +129,15 @@ void CSIDevice_GCSteeringWheel::SendCommand(u32 command, u8 poll)
|
||||
Pad::Rumble(pad_num, 0);
|
||||
break;
|
||||
default:
|
||||
WARN_LOG(SERIALINTERFACE, "Unknown CMD_FORCE type %i", int(type));
|
||||
WARN_LOG_FMT(SERIALINTERFACE, "Unknown CMD_FORCE type {}", int(type));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!poll)
|
||||
if (poll == 0)
|
||||
{
|
||||
m_mode = wheel_command.parameter2;
|
||||
INFO_LOG(SERIALINTERFACE, "PAD %i set to mode %i", m_device_number, m_mode);
|
||||
INFO_LOG_FMT(SERIALINTERFACE, "PAD {} set to mode {}", m_device_number, m_mode);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
@ -27,7 +27,7 @@ int CSIDevice_Keyboard::RunBuffer(u8* buffer, int request_length)
|
||||
ISIDevice::RunBuffer(buffer, request_length);
|
||||
|
||||
// Read the command
|
||||
EBufferCommands command = static_cast<EBufferCommands>(buffer[0]);
|
||||
const auto command = static_cast<EBufferCommands>(buffer[0]);
|
||||
|
||||
// Handle it
|
||||
switch (command)
|
||||
@ -42,7 +42,7 @@ int CSIDevice_Keyboard::RunBuffer(u8* buffer, int request_length)
|
||||
|
||||
case CMD_DIRECT:
|
||||
{
|
||||
INFO_LOG(SERIALINTERFACE, "Keyboard - Direct (Request Length: %d)", request_length);
|
||||
INFO_LOG_FMT(SERIALINTERFACE, "Keyboard - Direct (Request Length: {})", request_length);
|
||||
u32 high, low;
|
||||
GetData(high, low);
|
||||
for (int i = 0; i < 4; i++)
|
||||
@ -55,7 +55,7 @@ int CSIDevice_Keyboard::RunBuffer(u8* buffer, int request_length)
|
||||
|
||||
default:
|
||||
{
|
||||
ERROR_LOG(SERIALINTERFACE, "Unknown SI command (0x%x)", command);
|
||||
ERROR_LOG_FMT(SERIALINTERFACE, "Unknown SI command ({:#x})", command);
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -98,7 +98,7 @@ void CSIDevice_Keyboard::SendCommand(u32 command, u8 poll)
|
||||
break;
|
||||
default:
|
||||
{
|
||||
ERROR_LOG(SERIALINTERFACE, "Unknown direct command (0x%x)", command);
|
||||
ERROR_LOG_FMT(SERIALINTERFACE, "Unknown direct command ({:#x})", command);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
@ -30,7 +30,7 @@ void Wiimote::HandleReportMode(const OutputReportMode& dr)
|
||||
if (!DataReportBuilder::IsValidMode(dr.mode))
|
||||
{
|
||||
// A real wiimote ignores the entire message if the mode is invalid.
|
||||
WARN_LOG(WIIMOTE, "Game requested invalid report mode: 0x%02x", int(dr.mode));
|
||||
WARN_LOG_FMT(WIIMOTE, "Game requested invalid report mode: {:#04x}", dr.mode);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -56,7 +56,7 @@ void Wiimote::InvokeHandler(H&& handler, const WiimoteCommon::OutputReportGeneri
|
||||
{
|
||||
if (size < sizeof(T))
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "InvokeHandler: report: 0x%02x invalid size: %d", int(rpt.rpt_id), size);
|
||||
ERROR_LOG_FMT(WIIMOTE, "InvokeHandler: report: {:#04x} invalid size: {}", rpt.rpt_id, size);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -75,18 +75,18 @@ void Wiimote::EventUnlinked()
|
||||
|
||||
void Wiimote::InterruptDataOutput(const u8* data, u32 size)
|
||||
{
|
||||
if (!size)
|
||||
if (size == 0)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "OutputData: zero sized data");
|
||||
ERROR_LOG_FMT(WIIMOTE, "OutputData: zero sized data");
|
||||
return;
|
||||
}
|
||||
|
||||
auto& rpt = *reinterpret_cast<const OutputReportGeneric*>(data);
|
||||
const auto& rpt = *reinterpret_cast<const OutputReportGeneric*>(data);
|
||||
const int rpt_size = size - OutputReportGeneric::HEADER_SIZE;
|
||||
|
||||
if (!rpt_size)
|
||||
if (rpt_size == 0)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "OutputData: zero sized report");
|
||||
ERROR_LOG_FMT(WIIMOTE, "OutputData: zero sized report");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -130,7 +130,7 @@ void Wiimote::InterruptDataOutput(const u8* data, u32 size)
|
||||
InvokeHandler<OutputReportEnableFeature>(&Wiimote::HandleIRLogicEnable2, rpt, rpt_size);
|
||||
break;
|
||||
default:
|
||||
PanicAlert("HidOutputReport: Unknown report ID 0x%02x", int(rpt.rpt_id));
|
||||
PanicAlertFmt("HidOutputReport: Unknown report ID {:#04x}", rpt.rpt_id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -255,17 +255,17 @@ void Wiimote::HandleWriteData(const OutputReportWriteData& wd)
|
||||
{
|
||||
// FYI: Writes during an active read will occasionally produce a "busy" (0x4) ack.
|
||||
// We won't simulate that as it often does work. Poorly programmed games may rely on it.
|
||||
WARN_LOG(WIIMOTE, "WriteData: write during active read request.");
|
||||
WARN_LOG_FMT(WIIMOTE, "WriteData: write during active read request.");
|
||||
}
|
||||
|
||||
u16 address = Common::swap16(wd.address);
|
||||
const u16 address = Common::swap16(wd.address);
|
||||
|
||||
DEBUG_LOG(WIIMOTE, "Wiimote::WriteData: 0x%02x @ 0x%02x @ 0x%02x (%d)", wd.space,
|
||||
wd.slave_address, address, wd.size);
|
||||
DEBUG_LOG_FMT(WIIMOTE, "Wiimote::WriteData: {:#04x} @ {:#04x} @ {:#04x} ({})", wd.space,
|
||||
wd.slave_address, address, wd.size);
|
||||
|
||||
if (0 == wd.size || wd.size > 16)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "WriteData: invalid size: %d", wd.size);
|
||||
WARN_LOG_FMT(WIIMOTE, "WriteData: invalid size: {}", wd.size);
|
||||
// A real wiimote silently ignores such a request:
|
||||
return;
|
||||
}
|
||||
@ -278,7 +278,7 @@ void Wiimote::HandleWriteData(const OutputReportWriteData& wd)
|
||||
{
|
||||
if (address + wd.size > EEPROM_FREE_SIZE)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "WriteData: address + size out of bounds!");
|
||||
WARN_LOG_FMT(WIIMOTE, "WriteData: address + size out of bounds!");
|
||||
error_code = ErrorCode::InvalidAddress;
|
||||
}
|
||||
else
|
||||
@ -295,7 +295,7 @@ void Wiimote::HandleWriteData(const OutputReportWriteData& wd)
|
||||
// Attempting to access the EEPROM directly over i2c results in error 8.
|
||||
if (EEPROM_I2C_ADDR == m_read_request.slave_address)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Attempt to write EEPROM directly.");
|
||||
WARN_LOG_FMT(WIIMOTE, "Attempt to write EEPROM directly.");
|
||||
error_code = ErrorCode::InvalidAddress;
|
||||
break;
|
||||
}
|
||||
@ -311,7 +311,7 @@ void Wiimote::HandleWriteData(const OutputReportWriteData& wd)
|
||||
break;
|
||||
|
||||
default:
|
||||
WARN_LOG(WIIMOTE, "WriteData: invalid address space: 0x%x", wd.space);
|
||||
WARN_LOG_FMT(WIIMOTE, "WriteData: invalid address space: {:#x}", wd.space);
|
||||
// A real wiimote gives error 6:
|
||||
error_code = ErrorCode::InvalidSpace;
|
||||
break;
|
||||
@ -383,7 +383,7 @@ void Wiimote::HandleSpeakerData(const WiimoteCommon::OutputReportSpeakerData& rp
|
||||
{
|
||||
if (rpt.length > std::size(rpt.data))
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Bad speaker data length: %d", rpt.length);
|
||||
ERROR_LOG_FMT(WIIMOTE, "Bad speaker data length: {}", rpt.length);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -403,7 +403,7 @@ void Wiimote::HandleReadData(const OutputReportReadData& rd)
|
||||
if (m_read_request.size)
|
||||
{
|
||||
// There is already an active read being processed.
|
||||
WARN_LOG(WIIMOTE, "ReadData: attempting read during active request.");
|
||||
WARN_LOG_FMT(WIIMOTE, "ReadData: attempting read during active request.");
|
||||
|
||||
// A real wm+ sends a busy ack in this situation.
|
||||
SendAck(OutputReportID::ReadData, ErrorCode::Busy);
|
||||
@ -417,8 +417,8 @@ void Wiimote::HandleReadData(const OutputReportReadData& rd)
|
||||
// A zero size request is just ignored, like on the real wiimote.
|
||||
m_read_request.size = Common::swap16(rd.size);
|
||||
|
||||
DEBUG_LOG(WIIMOTE, "Wiimote::ReadData: %d @ 0x%02x @ 0x%02x (%d)", int(m_read_request.space),
|
||||
m_read_request.slave_address, m_read_request.address, m_read_request.size);
|
||||
DEBUG_LOG_FMT(WIIMOTE, "Wiimote::ReadData: {} @ {:#04x} @ {:#04x} ({})", m_read_request.space,
|
||||
m_read_request.slave_address, m_read_request.address, m_read_request.size);
|
||||
|
||||
// Send up to one read-data-reply.
|
||||
// If more data needs to be sent it will happen on the next "Update()"
|
||||
@ -480,7 +480,7 @@ bool Wiimote::ProcessReadDataRequest()
|
||||
// Attempting to access the EEPROM directly over i2c results in error 8.
|
||||
if (EEPROM_I2C_ADDR == m_read_request.slave_address)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Attempt to read EEPROM directly.");
|
||||
WARN_LOG_FMT(WIIMOTE, "Attempt to read EEPROM directly.");
|
||||
error_code = ErrorCode::InvalidAddress;
|
||||
break;
|
||||
}
|
||||
@ -504,8 +504,8 @@ bool Wiimote::ProcessReadDataRequest()
|
||||
|
||||
if (bytes_read != bytes_to_read)
|
||||
{
|
||||
DEBUG_LOG(WIIMOTE, "Responding with read error 7 @ 0x%x @ 0x%x (%d)",
|
||||
m_read_request.slave_address, m_read_request.address, m_read_request.size);
|
||||
DEBUG_LOG_FMT(WIIMOTE, "Responding with read error 7 @ {:#x} @ {:#x} ({})",
|
||||
m_read_request.slave_address, m_read_request.address, m_read_request.size);
|
||||
error_code = ErrorCode::Nack;
|
||||
break;
|
||||
}
|
||||
@ -515,7 +515,7 @@ bool Wiimote::ProcessReadDataRequest()
|
||||
break;
|
||||
|
||||
default:
|
||||
WARN_LOG(WIIMOTE, "ReadData: invalid address space: 0x%x", int(m_read_request.space));
|
||||
WARN_LOG_FMT(WIIMOTE, "ReadData: invalid address space: {:#x}", int(m_read_request.space));
|
||||
// A real wiimote gives error 6:
|
||||
error_code = ErrorCode::InvalidSpace;
|
||||
break;
|
||||
|
||||
@ -501,7 +501,7 @@ EncryptionKey KeyGen::GenerateFromExtensionKeyData(const ExtKeyData& ext_key) co
|
||||
|
||||
// Retail games never hit this path but some homebrew fills encryption key with 0x00.
|
||||
// Real extensions seem to then use entirely differnet "sboxes" for table generation.
|
||||
WARN_LOG(WIIMOTE, "Extension key gen did not match any idx. Generating fallback tables.");
|
||||
WARN_LOG_FMT(WIIMOTE, "Extension key gen did not match any idx. Generating fallback tables.");
|
||||
return GenerateFallbackTables(rand, key);
|
||||
}
|
||||
|
||||
|
||||
@ -234,7 +234,7 @@ int MotionPlus::BusWrite(u8 slave_addr, u8 addr, int count, const u8* data_in)
|
||||
return m_i2c_bus.BusWrite(slave_addr, addr, count, data_in);
|
||||
}
|
||||
|
||||
DEBUG_LOG(WIIMOTE, "Inactive M+ write 0x%x : %s", addr, ArrayToString(data_in, count).c_str());
|
||||
DEBUG_LOG_FMT(WIIMOTE, "Inactive M+ write {:#x} : {}", addr, ArrayToString(data_in, count));
|
||||
|
||||
auto const result = RawWrite(&m_reg_data, addr, count, data_in);
|
||||
|
||||
@ -255,7 +255,7 @@ int MotionPlus::BusWrite(u8 slave_addr, u8 addr, int count, const u8* data_in)
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEBUG_LOG(WIIMOTE, "Active M+ write 0x%x : %s", addr, ArrayToString(data_in, count).c_str());
|
||||
DEBUG_LOG_FMT(WIIMOTE, "Active M+ write {:#x} : {}", addr, ArrayToString(data_in, count));
|
||||
|
||||
auto const result = RawWrite(&m_reg_data, addr, count, data_in);
|
||||
|
||||
@ -273,7 +273,7 @@ int MotionPlus::BusWrite(u8 slave_addr, u8 addr, int count, const u8* data_in)
|
||||
case offsetof(Register, challenge_type):
|
||||
if (ChallengeState::ParameterXReady == m_reg_data.challenge_state)
|
||||
{
|
||||
DEBUG_LOG(WIIMOTE, "M+ challenge: 0x%x", m_reg_data.challenge_type);
|
||||
DEBUG_LOG_FMT(WIIMOTE, "M+ challenge: {:#x}", m_reg_data.challenge_type);
|
||||
|
||||
// After games read parameter x they write here to request y0 or y1.
|
||||
if (0 == m_reg_data.challenge_type)
|
||||
@ -301,7 +301,7 @@ int MotionPlus::BusWrite(u8 slave_addr, u8 addr, int count, const u8* data_in)
|
||||
|
||||
case offsetof(Register, calibration_trigger):
|
||||
// Games seem to invoke this to start and stop calibration. Exact consequences unknown.
|
||||
DEBUG_LOG(WIIMOTE, "M+ calibration trigger: 0x%x", m_reg_data.calibration_trigger);
|
||||
DEBUG_LOG_FMT(WIIMOTE, "M+ calibration trigger: {:#x}", m_reg_data.calibration_trigger);
|
||||
break;
|
||||
|
||||
case PASSTHROUGH_MODE_OFFSET:
|
||||
@ -343,7 +343,7 @@ void MotionPlus::OnPassthroughModeWrite()
|
||||
|
||||
void MotionPlus::Activate()
|
||||
{
|
||||
DEBUG_LOG(WIIMOTE, "M+ has been activated.");
|
||||
DEBUG_LOG_FMT(WIIMOTE, "M+ has been activated.");
|
||||
|
||||
m_reg_data.ext_identifier[2] = ACTIVE_DEVICE_ADDR << 1;
|
||||
|
||||
@ -360,7 +360,7 @@ void MotionPlus::Activate()
|
||||
|
||||
void MotionPlus::Deactivate()
|
||||
{
|
||||
DEBUG_LOG(WIIMOTE, "M+ has been deactivated.");
|
||||
DEBUG_LOG_FMT(WIIMOTE, "M+ has been deactivated.");
|
||||
|
||||
m_reg_data.ext_identifier[2] = INACTIVE_DEVICE_ADDR << 1;
|
||||
|
||||
@ -421,7 +421,7 @@ void MotionPlus::Update()
|
||||
{
|
||||
if (is_ext_connected)
|
||||
{
|
||||
DEBUG_LOG(WIIMOTE, "M+ initializing new extension.");
|
||||
DEBUG_LOG_FMT(WIIMOTE, "M+ initializing new extension.");
|
||||
|
||||
// The M+ automatically initializes an extension when attached.
|
||||
|
||||
@ -488,7 +488,7 @@ void MotionPlus::Update()
|
||||
// Big-int little endian parameter x.
|
||||
param_x.WriteLittleEndianBinary(&m_reg_data.challenge_data);
|
||||
|
||||
DEBUG_LOG(WIIMOTE, "M+ parameter x ready.");
|
||||
DEBUG_LOG_FMT(WIIMOTE, "M+ parameter x ready.");
|
||||
m_reg_data.challenge_state = ChallengeState::ParameterXReady;
|
||||
break;
|
||||
}
|
||||
@ -514,7 +514,7 @@ void MotionPlus::Update()
|
||||
param_y1.WriteLittleEndianBinary(&m_reg_data.challenge_data);
|
||||
}
|
||||
|
||||
DEBUG_LOG(WIIMOTE, "M+ parameter y ready.");
|
||||
DEBUG_LOG_FMT(WIIMOTE, "M+ parameter y ready.");
|
||||
m_reg_data.challenge_state = ChallengeState::ParameterYReady;
|
||||
break;
|
||||
|
||||
@ -583,7 +583,7 @@ void MotionPlus::PrepareInput(const Common::Vec3& angular_velocity)
|
||||
break;
|
||||
default:
|
||||
// This really shouldn't happen as the M+ deactivates on an invalid mode write.
|
||||
ERROR_LOG(WIIMOTE, "M+ unknown passthrough-mode %d", int(GetPassthroughMode()));
|
||||
ERROR_LOG_FMT(WIIMOTE, "M+ unknown passthrough-mode {}", GetPassthroughMode());
|
||||
mplus_data.is_mp_data = true;
|
||||
break;
|
||||
}
|
||||
|
||||
@ -117,13 +117,13 @@ void SpeakerLogic::SpeakerData(const u8* data, int length, float speaker_pan)
|
||||
}
|
||||
else
|
||||
{
|
||||
ERROR_LOG(IOS_WIIMOTE, "Unknown speaker format %x", reg_data.format);
|
||||
ERROR_LOG_FMT(IOS_WIIMOTE, "Unknown speaker format {:x}", reg_data.format);
|
||||
return;
|
||||
}
|
||||
|
||||
if (reg_data.volume > volume_divisor)
|
||||
{
|
||||
DEBUG_LOG(IOS_WIIMOTE, "Wiimote volume is higher than suspected maximum!");
|
||||
DEBUG_LOG_FMT(IOS_WIIMOTE, "Wiimote volume is higher than suspected maximum!");
|
||||
volume_divisor = reg_data.volume;
|
||||
}
|
||||
|
||||
|
||||
@ -82,7 +82,7 @@ void Wiimote::Reset()
|
||||
if (m_eeprom_dirty)
|
||||
{
|
||||
// Write out existing EEPROM
|
||||
INFO_LOG(WIIMOTE, "Wrote EEPROM for %s", GetName().c_str());
|
||||
INFO_LOG_FMT(WIIMOTE, "Wrote EEPROM for {}", GetName());
|
||||
std::ofstream file;
|
||||
File::OpenFStream(file, eeprom_file, std::ios::binary | std::ios::out);
|
||||
file.write(reinterpret_cast<char*>(m_eeprom.data.data()), EEPROM_FREE_SIZE);
|
||||
@ -405,7 +405,7 @@ bool Wiimote::ProcessExtensionPortEvent()
|
||||
// FYI: This happens even during a read request which continues after the status report is sent.
|
||||
m_reporting_mode = InputReportID::ReportDisabled;
|
||||
|
||||
DEBUG_LOG(WIIMOTE, "Sending status report due to extension status change.");
|
||||
DEBUG_LOG_FMT(WIIMOTE, "Sending status report due to extension status change.");
|
||||
|
||||
HandleRequestStatus(OutputReportRequestStatus{});
|
||||
|
||||
|
||||
@ -27,7 +27,7 @@ void WiimoteScannerAndroid::FindWiimotes(std::vector<Wiimote*>& found_wiimotes,
|
||||
found_wiimotes.clear();
|
||||
found_board = nullptr;
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "Finding Wiimotes");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Finding Wiimotes");
|
||||
|
||||
JNIEnv* env = IDCache::GetEnvForThread();
|
||||
|
||||
|
||||
@ -24,7 +24,7 @@ WiimoteScannerLinux::WiimoteScannerLinux() : m_device_id(-1), m_device_sock(-1)
|
||||
m_device_id = hci_get_route(nullptr);
|
||||
if (m_device_id < 0)
|
||||
{
|
||||
NOTICE_LOG(WIIMOTE, "Bluetooth not found.");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Bluetooth not found.");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -32,7 +32,7 @@ WiimoteScannerLinux::WiimoteScannerLinux() : m_device_id(-1), m_device_sock(-1)
|
||||
m_device_sock = hci_open_dev(m_device_id);
|
||||
if (m_device_sock < 0)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Unable to open Bluetooth.");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Unable to open Bluetooth.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
@ -66,26 +66,26 @@ void WiimoteScannerLinux::FindWiimotes(std::vector<Wiimote*>& found_wiimotes, Wi
|
||||
hci_inquiry(m_device_id, wait_len, max_infos, lap, &scan_infos_ptr, IREQ_CACHE_FLUSH);
|
||||
if (found_devices < 0)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Error searching for Bluetooth devices.");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Error searching for Bluetooth devices.");
|
||||
return;
|
||||
}
|
||||
|
||||
DEBUG_LOG(WIIMOTE, "Found %i Bluetooth device(s).", found_devices);
|
||||
DEBUG_LOG_FMT(WIIMOTE, "Found {} Bluetooth device(s).", found_devices);
|
||||
|
||||
// Display discovered devices
|
||||
for (int i = 0; i < found_devices; ++i)
|
||||
{
|
||||
NOTICE_LOG(WIIMOTE, "found a device...");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "found a device...");
|
||||
|
||||
// BT names are a maximum of 248 bytes apparently
|
||||
char name[255] = {};
|
||||
if (hci_read_remote_name(m_device_sock, &scan_infos[i].bdaddr, sizeof(name), name, 1000) < 0)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "name request failed");
|
||||
ERROR_LOG_FMT(WIIMOTE, "name request failed");
|
||||
continue;
|
||||
}
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "device name %s", name);
|
||||
NOTICE_LOG_FMT(WIIMOTE, "device name {}", name);
|
||||
if (!IsValidDeviceName(name))
|
||||
continue;
|
||||
|
||||
@ -100,12 +100,12 @@ void WiimoteScannerLinux::FindWiimotes(std::vector<Wiimote*>& found_wiimotes, Wi
|
||||
if (IsBalanceBoardName(name))
|
||||
{
|
||||
found_board = wm;
|
||||
NOTICE_LOG(WIIMOTE, "Found balance board (%s).", bdaddr_str);
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Found balance board ({}).", bdaddr_str);
|
||||
}
|
||||
else
|
||||
{
|
||||
found_wiimotes.push_back(wm);
|
||||
NOTICE_LOG(WIIMOTE, "Found Wiimote (%s).", bdaddr_str);
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Found Wiimote ({}).", bdaddr_str);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -120,7 +120,7 @@ WiimoteLinux::WiimoteLinux(bdaddr_t bdaddr) : m_bdaddr(bdaddr)
|
||||
int fds[2];
|
||||
if (pipe(fds))
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "pipe failed");
|
||||
ERROR_LOG_FMT(WIIMOTE, "pipe failed");
|
||||
abort();
|
||||
}
|
||||
m_wakeup_pipe_w = fds[1];
|
||||
@ -152,7 +152,7 @@ bool WiimoteLinux::ConnectInternal()
|
||||
// If opening channel fails sleep and try again
|
||||
if (retry == 3)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Unable to connect control channel of Wiimote: %s", strerror(errno));
|
||||
WARN_LOG_FMT(WIIMOTE, "Unable to connect control channel of Wiimote: {}", strerror(errno));
|
||||
close(m_cmd_sock);
|
||||
m_cmd_sock = -1;
|
||||
return false;
|
||||
@ -163,7 +163,7 @@ bool WiimoteLinux::ConnectInternal()
|
||||
}
|
||||
else
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Unable to open control socket to Wiimote: %s", strerror(errno));
|
||||
WARN_LOG_FMT(WIIMOTE, "Unable to open control socket to Wiimote: {}", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -177,7 +177,8 @@ bool WiimoteLinux::ConnectInternal()
|
||||
// If opening channel fails sleep and try again
|
||||
if (retry == 3)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Unable to connect interrupt channel of Wiimote: %s", strerror(errno));
|
||||
WARN_LOG_FMT(WIIMOTE, "Unable to connect interrupt channel of Wiimote: {}",
|
||||
strerror(errno));
|
||||
close(m_int_sock);
|
||||
close(m_cmd_sock);
|
||||
m_int_sock = m_cmd_sock = -1;
|
||||
@ -189,7 +190,7 @@ bool WiimoteLinux::ConnectInternal()
|
||||
}
|
||||
else
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Unable to open interrupt socket to Wiimote: %s", strerror(errno));
|
||||
WARN_LOG_FMT(WIIMOTE, "Unable to open interrupt socket to Wiimote: {}", strerror(errno));
|
||||
close(m_cmd_sock);
|
||||
m_int_sock = m_cmd_sock = -1;
|
||||
return false;
|
||||
@ -217,7 +218,7 @@ void WiimoteLinux::IOWakeup()
|
||||
char c = 0;
|
||||
if (write(m_wakeup_pipe_w, &c, 1) != 1)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Unable to write to wakeup pipe.");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Unable to write to wakeup pipe.");
|
||||
}
|
||||
}
|
||||
|
||||
@ -238,7 +239,7 @@ int WiimoteLinux::IORead(u8* buf)
|
||||
|
||||
if (poll(pollfds.data(), pollfds.size(), -1) == -1)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Unable to poll Wiimote %i input socket.", m_index + 1);
|
||||
ERROR_LOG_FMT(WIIMOTE, "Unable to poll Wiimote {} input socket.", m_index + 1);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -247,7 +248,7 @@ int WiimoteLinux::IORead(u8* buf)
|
||||
char c;
|
||||
if (read(m_wakeup_pipe_r, &c, 1) != 1)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Unable to read from wakeup pipe.");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Unable to read from wakeup pipe.");
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@ -260,15 +261,15 @@ int WiimoteLinux::IORead(u8* buf)
|
||||
if (r == -1)
|
||||
{
|
||||
// Error reading data
|
||||
ERROR_LOG(WIIMOTE, "Receiving data from Wiimote %i.", m_index + 1);
|
||||
ERROR_LOG_FMT(WIIMOTE, "Receiving data from Wiimote {}.", m_index + 1);
|
||||
|
||||
if (errno == ENOTCONN)
|
||||
{
|
||||
// This can happen if the Bluetooth dongle is disconnected
|
||||
ERROR_LOG(WIIMOTE,
|
||||
"Bluetooth appears to be disconnected. "
|
||||
"Wiimote %i will be disconnected.",
|
||||
m_index + 1);
|
||||
ERROR_LOG_FMT(WIIMOTE,
|
||||
"Bluetooth appears to be disconnected. "
|
||||
"Wiimote {} will be disconnected.",
|
||||
m_index + 1);
|
||||
}
|
||||
|
||||
r = 0;
|
||||
|
||||
@ -180,7 +180,8 @@ void init_lib()
|
||||
// all nullptr.
|
||||
if (!load_hid() || !load_bthprops())
|
||||
{
|
||||
NOTICE_LOG(WIIMOTE, "Failed to load Bluetooth support libraries, Wiimotes will not function");
|
||||
NOTICE_LOG_FMT(WIIMOTE,
|
||||
"Failed to load Bluetooth support libraries, Wiimotes will not function");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -232,20 +233,21 @@ std::wstring GetDeviceProperty(const HDEVINFO& device_info, const PSP_DEVINFO_DA
|
||||
|
||||
int IOWritePerSetOutputReport(HANDLE& dev_handle, const u8* buf, size_t len, DWORD* written)
|
||||
{
|
||||
BOOLEAN result = pHidD_SetOutputReport(dev_handle, const_cast<u8*>(buf) + 1, (ULONG)(len - 1));
|
||||
const BOOLEAN result =
|
||||
pHidD_SetOutputReport(dev_handle, const_cast<u8*>(buf) + 1, (ULONG)(len - 1));
|
||||
if (!result)
|
||||
{
|
||||
DWORD err = GetLastError();
|
||||
const DWORD err = GetLastError();
|
||||
if (err == ERROR_SEM_TIMEOUT)
|
||||
{
|
||||
NOTICE_LOG(WIIMOTE, "IOWrite[WWM_SET_OUTPUT_REPORT]: Unable to send data to the Wiimote");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "IOWrite[WWM_SET_OUTPUT_REPORT]: Unable to send data to the Wiimote");
|
||||
}
|
||||
else if (err != ERROR_GEN_FAILURE)
|
||||
{
|
||||
// Some third-party adapters (DolphinBar) use this
|
||||
// error code to signal the absence of a Wiimote
|
||||
// linked to the HID device.
|
||||
WARN_LOG(WIIMOTE, "IOWrite[WWM_SET_OUTPUT_REPORT]: Error: %08x", err);
|
||||
WARN_LOG_FMT(WIIMOTE, "IOWrite[WWM_SET_OUTPUT_REPORT]: Error: {:08x}", err);
|
||||
}
|
||||
}
|
||||
|
||||
@ -288,14 +290,14 @@ int IOWritePerWriteFile(HANDLE& dev_handle, OVERLAPPED& hid_overlap_write,
|
||||
switch (error)
|
||||
{
|
||||
case ERROR_INVALID_USER_BUFFER:
|
||||
INFO_LOG(WIIMOTE, "IOWrite[WWM_WRITE_FILE]: Falling back to SetOutputReport");
|
||||
INFO_LOG_FMT(WIIMOTE, "IOWrite[WWM_WRITE_FILE]: Falling back to SetOutputReport");
|
||||
write_method = WWM_SET_OUTPUT_REPORT;
|
||||
return IOWritePerSetOutputReport(dev_handle, buf, len, written);
|
||||
case ERROR_IO_PENDING:
|
||||
// Pending is no error!
|
||||
break;
|
||||
default:
|
||||
WARN_LOG(WIIMOTE, "IOWrite[WWM_WRITE_FILE]: Error on WriteFile: %08x", error);
|
||||
WARN_LOG_FMT(WIIMOTE, "IOWrite[WWM_WRITE_FILE]: Error on WriteFile: {:08x}", error);
|
||||
CancelIo(dev_handle);
|
||||
return 0;
|
||||
}
|
||||
@ -311,13 +313,13 @@ int IOWritePerWriteFile(HANDLE& dev_handle, OVERLAPPED& hid_overlap_write,
|
||||
|
||||
if (WAIT_TIMEOUT == wait_result)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "IOWrite[WWM_WRITE_FILE]: A timeout occurred on writing to Wiimote.");
|
||||
WARN_LOG_FMT(WIIMOTE, "IOWrite[WWM_WRITE_FILE]: A timeout occurred on writing to Wiimote.");
|
||||
CancelIo(dev_handle);
|
||||
return 1;
|
||||
}
|
||||
else if (WAIT_FAILED == wait_result)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "IOWrite[WWM_WRITE_FILE]: A wait error occurred on writing to Wiimote.");
|
||||
WARN_LOG_FMT(WIIMOTE, "IOWrite[WWM_WRITE_FILE]: A wait error occurred on writing to Wiimote.");
|
||||
CancelIo(dev_handle);
|
||||
return 1;
|
||||
}
|
||||
@ -407,7 +409,7 @@ bool CheckForToshibaStack(const DEVINST& hid_interface_device_instance)
|
||||
return (class_driver_provider == L"TOSHIBA");
|
||||
}
|
||||
|
||||
DEBUG_LOG(WIIMOTE, "Unable to detect class driver provider!");
|
||||
DEBUG_LOG_FMT(WIIMOTE, "Unable to detect class driver provider!");
|
||||
|
||||
return false;
|
||||
}
|
||||
@ -477,7 +479,7 @@ bool IsWiimote(const std::basic_string<TCHAR>& device_path, WinWriteMethod& meth
|
||||
case InputReportID::Status:
|
||||
return true;
|
||||
default:
|
||||
WARN_LOG(WIIMOTE, "IsWiimote(): Received unexpected report %02x", buf[1]);
|
||||
WARN_LOG_FMT(WIIMOTE, "IsWiimote(): Received unexpected report {:02x}", buf[1]);
|
||||
invalid_report_count++;
|
||||
// If we receive over 15 invalid reports, then this is probably not a Wiimote.
|
||||
if (invalid_report_count > 15)
|
||||
@ -637,8 +639,6 @@ bool WiimoteWindows::ConnectInternal()
|
||||
TCHAR name[128] = {};
|
||||
pHidD_GetProductString(dev_handle, name, 128);
|
||||
|
||||
//ERROR_LOG(WIIMOTE, "Product string: %s", TStrToUTF8(name).c_str());
|
||||
|
||||
if (!IsValidBluetoothName(TStrToUTF8(name)))
|
||||
{
|
||||
CloseHandle(dev_handle);
|
||||
@ -664,7 +664,7 @@ bool WiimoteWindows::ConnectInternal()
|
||||
/*
|
||||
if (!SetThreadPriority(m_wiimote_thread.native_handle(), THREAD_PRIORITY_TIME_CRITICAL))
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Failed to set Wiimote thread priority");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Failed to set Wiimote thread priority");
|
||||
}
|
||||
*/
|
||||
|
||||
@ -756,7 +756,8 @@ int IORead(HANDLE& dev_handle, OVERLAPPED& hid_overlap_read, u8* buf, int index)
|
||||
return -1;
|
||||
}
|
||||
|
||||
WARN_LOG(WIIMOTE, "GetOverlappedResult error %d on Wiimote %i.", overlapped_err, index + 1);
|
||||
WARN_LOG_FMT(WIIMOTE, "GetOverlappedResult error {} on Wiimote {}.", overlapped_err,
|
||||
index + 1);
|
||||
return 0;
|
||||
}
|
||||
// If IOWakeup sets the event so GetOverlappedResult returns prematurely, but the request is
|
||||
@ -770,17 +771,17 @@ int IORead(HANDLE& dev_handle, OVERLAPPED& hid_overlap_read, u8* buf, int index)
|
||||
}
|
||||
else
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "ReadFile error %d on Wiimote %i.", read_err, index + 1);
|
||||
WARN_LOG_FMT(WIIMOTE, "ReadFile error {} on Wiimote {}.", read_err, index + 1);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// ReadFile will always return 22 bytes read.
|
||||
// So we need to calculate the actual report size by its report ID
|
||||
DWORD report_size = static_cast<DWORD>(GetReportSize(buf[1]));
|
||||
const auto report_size = static_cast<DWORD>(GetReportSize(buf[1]));
|
||||
if (report_size == 0)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Received unsupported report %d in Wii Remote %i", buf[1], index + 1);
|
||||
WARN_LOG_FMT(WIIMOTE, "Received unsupported report {} in Wii Remote {}", buf[1], index + 1);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -894,8 +895,8 @@ void ProcessWiimotes(bool new_scan, const T& callback)
|
||||
while (hFindDevice)
|
||||
{
|
||||
// btdi.szName is sometimes missing it's content - it's a bt feature..
|
||||
DEBUG_LOG(WIIMOTE, "Authenticated %i connected %i remembered %i ", btdi.fAuthenticated,
|
||||
btdi.fConnected, btdi.fRemembered);
|
||||
DEBUG_LOG_FMT(WIIMOTE, "Authenticated {} connected {} remembered {} ", btdi.fAuthenticated,
|
||||
btdi.fConnected, btdi.fRemembered);
|
||||
|
||||
if (IsValidDeviceName(WStringToUTF8(btdi.szName)))
|
||||
{
|
||||
@ -925,7 +926,7 @@ void RemoveWiimote(BLUETOOTH_DEVICE_INFO_STRUCT& btdi)
|
||||
{
|
||||
if (SUCCEEDED(pBluetoothRemoveDevice(&btdi.Address)))
|
||||
{
|
||||
NOTICE_LOG(WIIMOTE, "Removed BT Device", GetLastError());
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Removed BT Device {}", GetLastError());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -939,8 +940,9 @@ bool AttachWiimote(HANDLE hRadio, const BLUETOOTH_RADIO_INFO& radio_info,
|
||||
{
|
||||
auto const& wm_addr = btdi.Address.rgBytes;
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "Found Wiimote (%02x:%02x:%02x:%02x:%02x:%02x). Enabling HID service.",
|
||||
wm_addr[0], wm_addr[1], wm_addr[2], wm_addr[3], wm_addr[4], wm_addr[5]);
|
||||
NOTICE_LOG_FMT(
|
||||
WIIMOTE, "Found Wiimote ({:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}). Enabling HID service.",
|
||||
wm_addr[0], wm_addr[1], wm_addr[2], wm_addr[3], wm_addr[4], wm_addr[5]);
|
||||
|
||||
#if defined(AUTHENTICATE_WIIMOTES)
|
||||
// Authenticate
|
||||
@ -953,7 +955,8 @@ bool AttachWiimote(HANDLE hRadio, const BLUETOOTH_RADIO_INFO& radio_info,
|
||||
|
||||
if (ERROR_SUCCESS != auth_result)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "AttachWiimote: BluetoothAuthenticateDeviceEx returned %08x", auth_result);
|
||||
ERROR_LOG_FMT(WIIMOTE, "AttachWiimote: BluetoothAuthenticateDeviceEx returned {:08x}",
|
||||
auth_result);
|
||||
}
|
||||
|
||||
DWORD pcServices = 16;
|
||||
@ -964,8 +967,8 @@ bool AttachWiimote(HANDLE hRadio, const BLUETOOTH_RADIO_INFO& radio_info,
|
||||
|
||||
if (ERROR_SUCCESS != srv_result)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "AttachWiimote: BluetoothEnumerateInstalledServices returned %08x",
|
||||
srv_result);
|
||||
ERROR_LOG_FMT(WIIMOTE, "AttachWiimote: BluetoothEnumerateInstalledServices returned {:08x}",
|
||||
srv_result);
|
||||
}
|
||||
#endif
|
||||
// Activate service
|
||||
@ -976,7 +979,7 @@ bool AttachWiimote(HANDLE hRadio, const BLUETOOTH_RADIO_INFO& radio_info,
|
||||
|
||||
if (FAILED(hr))
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "AttachWiimote: BluetoothSetServiceState returned %08x", hr);
|
||||
ERROR_LOG_FMT(WIIMOTE, "AttachWiimote: BluetoothSetServiceState returned {:08x}", hr);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -996,13 +999,13 @@ bool ForgetWiimote(BLUETOOTH_DEVICE_INFO_STRUCT& btdi)
|
||||
// Sometimes SetServiceState takes a while..
|
||||
auto const avoid_forget_seconds = 5.0;
|
||||
|
||||
auto pair_time = s_connect_times.find(btdi.Address.ullLong);
|
||||
const auto pair_time = s_connect_times.find(btdi.Address.ullLong);
|
||||
if (pair_time == s_connect_times.end() ||
|
||||
std::difftime(time(nullptr), pair_time->second) >= avoid_forget_seconds)
|
||||
{
|
||||
// Make Windows forget about device so it will re-find it if visible.
|
||||
// This is also required to detect a disconnect for some reason..
|
||||
NOTICE_LOG(WIIMOTE, "Removing remembered Wiimote.");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Removing remembered Wiimote.");
|
||||
pBluetoothRemoveDevice(&btdi.Address);
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -38,7 +38,7 @@ void WiimoteScannerDarwin::FindWiimotes(std::vector<Wiimote*>& found_wiimotes,
|
||||
bool btFailed = [bth addressAsString] == nil;
|
||||
if (btFailed)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "No Bluetooth host controller");
|
||||
WARN_LOG_FMT(WIIMOTE, "No Bluetooth host controller");
|
||||
[bth release];
|
||||
return;
|
||||
}
|
||||
@ -51,7 +51,7 @@ void WiimoteScannerDarwin::FindWiimotes(std::vector<Wiimote*>& found_wiimotes,
|
||||
|
||||
if ([bti start] != kIOReturnSuccess)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Unable to do Bluetooth discovery");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Unable to do Bluetooth discovery");
|
||||
[bth release];
|
||||
[sbt release];
|
||||
btFailed = true;
|
||||
@ -65,7 +65,7 @@ void WiimoteScannerDarwin::FindWiimotes(std::vector<Wiimote*>& found_wiimotes,
|
||||
int found_devices = [[bti foundDevices] count];
|
||||
|
||||
if (found_devices)
|
||||
NOTICE_LOG(WIIMOTE, "Found %i Bluetooth devices", found_devices);
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Found {} Bluetooth devices", found_devices);
|
||||
|
||||
NSEnumerator* en = [[bti foundDevices] objectEnumerator];
|
||||
for (int i = 0; i < found_devices; i++)
|
||||
@ -131,7 +131,8 @@ bool WiimoteDarwin::ConnectInternal()
|
||||
IOReturn ret = [m_btd openConnection];
|
||||
if (ret)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Unable to open Bluetooth connection to Wiimote %i: %x", m_index + 1, ret);
|
||||
ERROR_LOG_FMT(WIIMOTE, "Unable to open Bluetooth connection to Wiimote {}: {:x}", m_index + 1,
|
||||
ret);
|
||||
[cbt release];
|
||||
return false;
|
||||
}
|
||||
@ -139,7 +140,7 @@ bool WiimoteDarwin::ConnectInternal()
|
||||
ret = [m_btd openL2CAPChannelSync:&m_cchan withPSM:kBluetoothL2CAPPSMHIDControl delegate:cbt];
|
||||
if (ret)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Unable to open control channel for Wiimote %i: %x", m_index + 1, ret);
|
||||
ERROR_LOG_FMT(WIIMOTE, "Unable to open control channel for Wiimote {}: {:x}", m_index + 1, ret);
|
||||
goto bad;
|
||||
}
|
||||
// Apple docs claim:
|
||||
@ -152,13 +153,14 @@ bool WiimoteDarwin::ConnectInternal()
|
||||
ret = [m_btd openL2CAPChannelSync:&m_ichan withPSM:kBluetoothL2CAPPSMHIDInterrupt delegate:cbt];
|
||||
if (ret)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Unable to open interrupt channel for Wiimote %i: %x", m_index + 1, ret);
|
||||
WARN_LOG_FMT(WIIMOTE, "Unable to open interrupt channel for Wiimote {}: {:x}", m_index + 1,
|
||||
ret);
|
||||
goto bad;
|
||||
}
|
||||
[m_ichan retain];
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "Connected to Wiimote %i at %s", m_index + 1,
|
||||
[[m_btd addressString] UTF8String]);
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Connected to Wiimote {} at {}", m_index + 1,
|
||||
[[m_btd addressString] UTF8String]);
|
||||
|
||||
m_connected = true;
|
||||
|
||||
@ -190,7 +192,7 @@ void WiimoteDarwin::DisconnectInternal()
|
||||
if (!IsConnected())
|
||||
return;
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "Disconnecting Wiimote %i", m_index + 1);
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Disconnecting Wiimote {}", m_index + 1);
|
||||
|
||||
m_connected = false;
|
||||
}
|
||||
@ -240,7 +242,9 @@ void WiimoteDarwin::EnablePowerAssertionInternal()
|
||||
if (IOReturn ret = IOPMAssertionCreateWithName(
|
||||
kIOPMAssertPreventUserIdleDisplaySleep, kIOPMAssertionLevelOn,
|
||||
CFSTR("Dolphin Wiimote activity"), &m_pm_assertion))
|
||||
ERROR_LOG(WIIMOTE, "Could not create power management assertion: %08x", ret);
|
||||
{
|
||||
ERROR_LOG_FMT(WIIMOTE, "Could not create power management assertion: {:08x}", ret);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -249,7 +253,7 @@ void WiimoteDarwin::DisablePowerAssertionInternal()
|
||||
if (m_pm_assertion != kIOPMNullAssertionID)
|
||||
{
|
||||
if (IOReturn ret = IOPMAssertionRelease(m_pm_assertion))
|
||||
ERROR_LOG(WIIMOTE, "Could not release power management assertion: %08x", ret);
|
||||
ERROR_LOG_FMT(WIIMOTE, "Could not release power management assertion: {:08x}", ret);
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
@ -264,8 +268,8 @@ void WiimoteDarwin::DisablePowerAssertionInternal()
|
||||
|
||||
- (void)deviceInquiryDeviceFound:(IOBluetoothDeviceInquiry*)sender device:(IOBluetoothDevice*)device
|
||||
{
|
||||
NOTICE_LOG(WIIMOTE, "Discovered Bluetooth device at %s: %s", [[device addressString] UTF8String],
|
||||
[[device name] UTF8String]);
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Discovered Bluetooth device at {}: {}",
|
||||
[[device addressString] UTF8String], [[device name] UTF8String]);
|
||||
|
||||
if ([[sender foundDevices] count] == maxDevices)
|
||||
[sender stop];
|
||||
@ -294,19 +298,19 @@ void WiimoteDarwin::DisablePowerAssertionInternal()
|
||||
|
||||
if (wm == nullptr)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Received packet for unknown Wiimote");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Received packet for unknown Wiimote");
|
||||
return;
|
||||
}
|
||||
|
||||
if (length > WiimoteCommon::MAX_PAYLOAD)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Dropping packet for Wiimote %i, too large", wm->GetIndex() + 1);
|
||||
WARN_LOG_FMT(WIIMOTE, "Dropping packet for Wiimote {}, too large", wm->GetIndex() + 1);
|
||||
return;
|
||||
}
|
||||
|
||||
if (wm->m_inputlen != -1)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Dropping packet for Wiimote %i, queue full", wm->GetIndex() + 1);
|
||||
WARN_LOG_FMT(WIIMOTE, "Dropping packet for Wiimote {}, queue full", wm->GetIndex() + 1);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -335,11 +339,11 @@ void WiimoteDarwin::DisablePowerAssertionInternal()
|
||||
|
||||
if (wm == nullptr)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Channel for unknown Wiimote was closed");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Channel for unknown Wiimote was closed");
|
||||
return;
|
||||
}
|
||||
|
||||
WARN_LOG(WIIMOTE, "Lost channel to Wiimote %i", wm->GetIndex() + 1);
|
||||
WARN_LOG_FMT(WIIMOTE, "Lost channel to Wiimote {}", wm->GetIndex() + 1);
|
||||
|
||||
wm->DisconnectInternal();
|
||||
}
|
||||
|
||||
@ -18,10 +18,10 @@ static bool IsDeviceUsable(const std::string& device_path)
|
||||
hid_device* handle = hid_open_path(device_path.c_str());
|
||||
if (handle == nullptr)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE,
|
||||
"Could not connect to Wii Remote at \"%s\". "
|
||||
"Do you have permission to access the device?",
|
||||
device_path.c_str());
|
||||
ERROR_LOG_FMT(WIIMOTE,
|
||||
"Could not connect to Wii Remote at \"{}\". "
|
||||
"Do you have permission to access the device?",
|
||||
device_path);
|
||||
return false;
|
||||
}
|
||||
// Some third-party adapters (DolphinBar) always expose all four Wii Remotes as HIDs
|
||||
@ -31,7 +31,7 @@ static bool IsDeviceUsable(const std::string& device_path)
|
||||
const int result = hid_write(handle, report, sizeof(report));
|
||||
// The DolphinBar uses EPIPE to signal the absence of a Wii Remote connected to this HID.
|
||||
if (result == -1 && errno != EPIPE)
|
||||
ERROR_LOG(WIIMOTE, "Couldn't write to Wii Remote at \"%s\".", device_path.c_str());
|
||||
ERROR_LOG_FMT(WIIMOTE, "Couldn't write to Wii Remote at \"{}\".", device_path);
|
||||
|
||||
hid_close(handle);
|
||||
return result != -1;
|
||||
@ -48,7 +48,7 @@ WiimoteScannerHidapi::WiimoteScannerHidapi()
|
||||
WiimoteScannerHidapi::~WiimoteScannerHidapi()
|
||||
{
|
||||
if (hid_exit() == -1)
|
||||
ERROR_LOG(WIIMOTE, "Failed to clean up hidapi.");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Failed to clean up hidapi.");
|
||||
}
|
||||
|
||||
bool WiimoteScannerHidapi::IsReady() const
|
||||
@ -75,10 +75,10 @@ void WiimoteScannerHidapi::FindWiimotes(std::vector<Wiimote*>& wiimotes, Wiimote
|
||||
else
|
||||
wiimotes.push_back(wiimote);
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "Found %s at %s: %ls %ls (%04hx:%04hx)",
|
||||
is_balance_board ? "balance board" : "Wiimote", device->path,
|
||||
device->manufacturer_string, device->product_string, device->vendor_id,
|
||||
device->product_id);
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Found {} at {}: {} {} ({:04x}:{:04x})",
|
||||
is_balance_board ? "balance board" : "Wiimote", device->path,
|
||||
WStringToUTF8(device->manufacturer_string),
|
||||
WStringToUTF8(device->product_string), device->vendor_id, device->product_id);
|
||||
}
|
||||
hid_free_enumeration(list);
|
||||
}
|
||||
@ -100,10 +100,10 @@ bool WiimoteHidapi::ConnectInternal()
|
||||
m_handle = hid_open_path(m_device_path.c_str());
|
||||
if (m_handle == nullptr)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE,
|
||||
"Could not connect to Wii Remote at \"%s\". "
|
||||
"Do you have permission to access the device?",
|
||||
m_device_path.c_str());
|
||||
ERROR_LOG_FMT(WIIMOTE,
|
||||
"Could not connect to Wii Remote at \"{}\". "
|
||||
"Do you have permission to access the device?",
|
||||
m_device_path);
|
||||
}
|
||||
return m_handle != nullptr;
|
||||
}
|
||||
@ -126,7 +126,7 @@ int WiimoteHidapi::IORead(u8* buf)
|
||||
// TODO: If and once we use hidapi across plaforms, change our internal API to clean up this mess.
|
||||
if (result == -1)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Failed to read from %s.", m_device_path.c_str());
|
||||
ERROR_LOG_FMT(WIIMOTE, "Failed to read from {}.", m_device_path);
|
||||
return 0; // error
|
||||
}
|
||||
if (result == 0)
|
||||
@ -143,7 +143,7 @@ int WiimoteHidapi::IOWrite(const u8* buf, size_t len)
|
||||
int result = hid_write(m_handle, buf + 1, len - 1);
|
||||
if (result == -1)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Failed to write to %s.", m_device_path.c_str());
|
||||
ERROR_LOG_FMT(WIIMOTE, "Failed to write to {}.", m_device_path);
|
||||
return 0;
|
||||
}
|
||||
return (result == 0) ? 1 : result;
|
||||
|
||||
@ -126,7 +126,7 @@ void AddWiimoteToPool(std::unique_ptr<Wiimote> wiimote)
|
||||
|
||||
if (!wiimote->Connect(POOL_WIIMOTE_INDEX))
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Failed to connect real wiimote.");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Failed to connect real wiimote.");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -147,7 +147,7 @@ void Wiimote::Shutdown()
|
||||
ClearReadQueue();
|
||||
m_write_reports.Clear();
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "Disconnected real wiimote.");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Disconnected real wiimote.");
|
||||
}
|
||||
|
||||
// to be called from CPU thread
|
||||
@ -293,7 +293,7 @@ void Wiimote::Read()
|
||||
}
|
||||
else if (0 == result)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Wiimote::IORead failed. Disconnecting Wii Remote %d.", m_index + 1);
|
||||
ERROR_LOG_FMT(WIIMOTE, "Wiimote::IORead failed. Disconnecting Wii Remote {}.", m_index + 1);
|
||||
DisconnectInternal();
|
||||
}
|
||||
}
|
||||
@ -337,7 +337,7 @@ bool Wiimote::IsBalanceBoard()
|
||||
if (!IOWrite(init_extension_rpt1, sizeof(init_extension_rpt1)) ||
|
||||
!IOWrite(init_extension_rpt2, sizeof(init_extension_rpt2)))
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "IsBalanceBoard(): Failed to initialise extension.");
|
||||
ERROR_LOG_FMT(WIIMOTE, "IsBalanceBoard(): Failed to initialise extension.");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -374,8 +374,8 @@ bool Wiimote::IsBalanceBoard()
|
||||
const auto* reply = reinterpret_cast<InputReportReadDataReply*>(&buf[2]);
|
||||
if (Common::swap16(reply->address) != 0x00fe)
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "IsBalanceBoard(): Received unexpected data reply for address %X",
|
||||
Common::swap16(reply->address));
|
||||
ERROR_LOG_FMT(WIIMOTE, "IsBalanceBoard(): Received unexpected data reply for address {:X}",
|
||||
Common::swap16(reply->address));
|
||||
return false;
|
||||
}
|
||||
// A Balance Board ext can be identified by checking for 0x0402.
|
||||
@ -386,7 +386,8 @@ bool Wiimote::IsBalanceBoard()
|
||||
const auto* ack = reinterpret_cast<InputReportAck*>(&buf[2]);
|
||||
if (ack->rpt_id == OutputReportID::ReadData && ack->error_code != ErrorCode::Success)
|
||||
{
|
||||
WARN_LOG(WIIMOTE, "Failed to read from 0xa400fe, assuming Wiimote is not a Balance Board.");
|
||||
WARN_LOG_FMT(WIIMOTE,
|
||||
"Failed to read from 0xa400fe, assuming Wiimote is not a Balance Board.");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@ -578,12 +579,12 @@ void WiimoteScanner::PoolThreadFunc()
|
||||
{
|
||||
if (!it->wiimote->IsConnected())
|
||||
{
|
||||
INFO_LOG(WIIMOTE, "Removing disconnected wiimote pool entry.");
|
||||
INFO_LOG_FMT(WIIMOTE, "Removing disconnected wiimote pool entry.");
|
||||
it = s_wiimote_pool.erase(it);
|
||||
}
|
||||
else if (it->IsExpired())
|
||||
{
|
||||
INFO_LOG(WIIMOTE, "Removing expired wiimote pool entry.");
|
||||
INFO_LOG_FMT(WIIMOTE, "Removing expired wiimote pool entry.");
|
||||
it = s_wiimote_pool.erase(it);
|
||||
}
|
||||
else
|
||||
@ -610,7 +611,7 @@ void WiimoteScanner::ThreadFunc()
|
||||
|
||||
Common::SetCurrentThreadName("Wiimote Scanning Thread");
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "Wiimote scanning thread has started.");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Wiimote scanning thread has started.");
|
||||
|
||||
// Create and destroy scanner backends here to ensure all operations stay on the same thread. The
|
||||
// HIDAPI backend on macOS has an error condition when IOHIDManagerCreate and IOHIDManagerClose
|
||||
@ -696,7 +697,7 @@ void WiimoteScanner::ThreadFunc()
|
||||
|
||||
pool_thread.join();
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "Wiimote scanning thread has stopped.");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Wiimote scanning thread has stopped.");
|
||||
}
|
||||
|
||||
bool Wiimote::Connect(int index)
|
||||
@ -752,13 +753,13 @@ void Wiimote::ThreadFunc()
|
||||
{
|
||||
if (m_need_prepare.TestAndClear() && !PrepareOnThread())
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Wiimote::PrepareOnThread failed. Disconnecting Wiimote %d.",
|
||||
m_index + 1);
|
||||
ERROR_LOG_FMT(WIIMOTE, "Wiimote::PrepareOnThread failed. Disconnecting Wiimote {}.",
|
||||
m_index + 1);
|
||||
break;
|
||||
}
|
||||
if (!Write())
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Wiimote::Write failed. Disconnecting Wiimote %d.", m_index + 1);
|
||||
ERROR_LOG_FMT(WIIMOTE, "Wiimote::Write failed. Disconnecting Wiimote {}.", m_index + 1);
|
||||
break;
|
||||
}
|
||||
Read();
|
||||
@ -826,7 +827,7 @@ void Initialize(::Wiimote::InitializeMode init_mode)
|
||||
if (g_real_wiimotes_initialized)
|
||||
return;
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "WiimoteReal::Initialize");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "WiimoteReal::Initialize");
|
||||
|
||||
g_real_wiimotes_initialized = true;
|
||||
}
|
||||
@ -845,7 +846,7 @@ void Shutdown()
|
||||
g_real_wiimotes_initialized = false;
|
||||
s_wiimote_scanner.StopThread();
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "WiimoteReal::Shutdown");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "WiimoteReal::Shutdown");
|
||||
|
||||
std::lock_guard lk(g_wiimotes_mutex);
|
||||
for (unsigned int i = 0; i < MAX_BBMOTES; ++i)
|
||||
@ -878,7 +879,7 @@ static bool TryToConnectWiimoteToSlot(std::unique_ptr<Wiimote>& wm, unsigned int
|
||||
|
||||
if (!wm->Connect(i))
|
||||
{
|
||||
ERROR_LOG(WIIMOTE, "Failed to connect real wiimote.");
|
||||
ERROR_LOG_FMT(WIIMOTE, "Failed to connect real wiimote.");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -894,7 +895,7 @@ static bool TryToConnectWiimoteToSlot(std::unique_ptr<Wiimote>& wm, unsigned int
|
||||
WiimoteCommon::UpdateSource(i);
|
||||
});
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "Connected real wiimote to slot %i.", i + 1);
|
||||
NOTICE_LOG_FMT(WIIMOTE, "Connected real wiimote to slot {}.", i + 1);
|
||||
|
||||
return true;
|
||||
}
|
||||
@ -904,7 +905,7 @@ static void TryToConnectBalanceBoard(std::unique_ptr<Wiimote> wm)
|
||||
if (TryToConnectWiimoteToSlot(wm, WIIMOTE_BALANCE_BOARD))
|
||||
return;
|
||||
|
||||
NOTICE_LOG(WIIMOTE, "No open slot for real balance board.");
|
||||
NOTICE_LOG_FMT(WIIMOTE, "No open slot for real balance board.");
|
||||
}
|
||||
|
||||
static void HandleWiimoteDisconnect(int index)
|
||||
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include "Core/IOS/DI/DI.h"
|
||||
|
||||
#include <cinttypes>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
@ -76,13 +75,13 @@ IPCCommandResult DI::IOCtl(const IOCtlRequest& request)
|
||||
const u8 command = Memory::Read_U8(request.buffer_in);
|
||||
if (request.request != command)
|
||||
{
|
||||
WARN_LOG(
|
||||
IOS_DI,
|
||||
"IOCtl: Received conflicting commands: ioctl 0x%02x, buffer 0x%02x. Using ioctl command.",
|
||||
request.request, command);
|
||||
WARN_LOG_FMT(IOS_DI,
|
||||
"IOCtl: Received conflicting commands: ioctl {:#04x}, buffer {:#04x}. Using "
|
||||
"ioctl command.",
|
||||
request.request, command);
|
||||
}
|
||||
|
||||
bool ready_to_execute = !m_executing_command.has_value();
|
||||
const bool ready_to_execute = !m_executing_command.has_value();
|
||||
m_commands_to_execute.push_back(request.address);
|
||||
|
||||
if (ready_to_execute)
|
||||
@ -99,7 +98,7 @@ void DI::ProcessQueuedIOCtl()
|
||||
{
|
||||
if (m_commands_to_execute.empty())
|
||||
{
|
||||
PanicAlert("IOS::HLE::Device::DI: There is no command to execute!");
|
||||
PanicAlertFmt("IOS::HLE::Device::DI: There is no command to execute!");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -120,7 +119,7 @@ std::optional<DI::DIResult> DI::WriteIfFits(const IOCtlRequest& request, u32 val
|
||||
{
|
||||
if (request.buffer_out_size < 4)
|
||||
{
|
||||
WARN_LOG(IOS_DI, "Output buffer is too small to contain result; returning security error");
|
||||
WARN_LOG_FMT(IOS_DI, "Output buffer is too small to contain result; returning security error");
|
||||
return DIResult::SecurityError;
|
||||
}
|
||||
else
|
||||
@ -134,8 +133,8 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
{
|
||||
if (request.buffer_in_size != 0x20)
|
||||
{
|
||||
ERROR_LOG(IOS_DI, "IOCtl: Received bad input buffer size 0x%02x, should be 0x20",
|
||||
request.buffer_in_size);
|
||||
ERROR_LOG_FMT(IOS_DI, "IOCtl: Received bad input buffer size {:#04x}, should be 0x20",
|
||||
request.buffer_in_size);
|
||||
return DIResult::SecurityError;
|
||||
}
|
||||
|
||||
@ -144,12 +143,12 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
switch (static_cast<DIIoctl>(request.request))
|
||||
{
|
||||
case DIIoctl::DVDLowInquiry:
|
||||
INFO_LOG(IOS_DI, "DVDLowInquiry");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowInquiry");
|
||||
DICMDBUF0 = 0x12000000;
|
||||
DICMDBUF1 = 0;
|
||||
return StartDMATransfer(0x20, request);
|
||||
case DIIoctl::DVDLowReadDiskID:
|
||||
INFO_LOG(IOS_DI, "DVDLowReadDiskID");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowReadDiskID");
|
||||
DICMDBUF0 = 0xA8000040;
|
||||
DICMDBUF1 = 0;
|
||||
DICMDBUF2 = 0x20;
|
||||
@ -166,19 +165,20 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
{
|
||||
const u32 length = Memory::Read_U32(request.buffer_in + 4);
|
||||
const u32 position = Memory::Read_U32(request.buffer_in + 8);
|
||||
INFO_LOG(IOS_DI, "DVDLowRead: offset 0x%08x (byte 0x%09" PRIx64 "), length 0x%x", position,
|
||||
static_cast<u64>(position) << 2, length);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowRead: offset {:#010x} (byte {:#011x}), length {:#x}", position,
|
||||
static_cast<u64>(position) << 2, length);
|
||||
if (m_current_partition == DiscIO::PARTITION_NONE)
|
||||
{
|
||||
ERROR_LOG(IOS_DI, "Attempted to perform a decrypting read when no partition is open!");
|
||||
ERROR_LOG_FMT(IOS_DI, "Attempted to perform a decrypting read when no partition is open!");
|
||||
return DIResult::SecurityError;
|
||||
}
|
||||
if (request.buffer_out_size < length)
|
||||
{
|
||||
WARN_LOG(IOS_DI,
|
||||
"Output buffer is too small for the result of the read (%d bytes given, needed at "
|
||||
"least %d); returning security error",
|
||||
request.buffer_out_size, length);
|
||||
WARN_LOG_FMT(
|
||||
IOS_DI,
|
||||
"Output buffer is too small for the result of the read ({} bytes given, needed at "
|
||||
"least {}); returning security error",
|
||||
request.buffer_out_size, length);
|
||||
return DIResult::SecurityError;
|
||||
}
|
||||
m_last_length = position; // An actual mistake in IOS
|
||||
@ -189,25 +189,25 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
case DIIoctl::DVDLowWaitForCoverClose:
|
||||
// This is a bit awkward to implement, as it doesn't return for a long time, so just act as if
|
||||
// the cover was immediately closed
|
||||
INFO_LOG(IOS_DI, "DVDLowWaitForCoverClose - skipping");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowWaitForCoverClose - skipping");
|
||||
return DIResult::CoverClosed;
|
||||
case DIIoctl::DVDLowGetCoverRegister:
|
||||
{
|
||||
u32 dicvr = DICVR;
|
||||
DEBUG_LOG(IOS_DI, "DVDLowGetCoverRegister 0x%08x", dicvr);
|
||||
const u32 dicvr = DICVR;
|
||||
DEBUG_LOG_FMT(IOS_DI, "DVDLowGetCoverRegister {:#010x}", dicvr);
|
||||
return WriteIfFits(request, dicvr);
|
||||
}
|
||||
case DIIoctl::DVDLowNotifyReset:
|
||||
INFO_LOG(IOS_DI, "DVDLowNotifyReset");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowNotifyReset");
|
||||
ResetDIRegisters();
|
||||
return DIResult::Success;
|
||||
case DIIoctl::DVDLowSetSpinupFlag:
|
||||
ERROR_LOG(IOS_DI, "DVDLowSetSpinupFlag - not a valid command, rejecting");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowSetSpinupFlag - not a valid command, rejecting");
|
||||
return DIResult::BadArgument;
|
||||
case DIIoctl::DVDLowReadDvdPhysical:
|
||||
{
|
||||
const u8 position = Memory::Read_U8(request.buffer_in + 7);
|
||||
INFO_LOG(IOS_DI, "DVDLowReadDvdPhysical: position 0x%02x", position);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowReadDvdPhysical: position {:#04x}", position);
|
||||
DICMDBUF0 = 0xAD000000 | (position << 8);
|
||||
DICMDBUF1 = 0;
|
||||
DICMDBUF2 = 0;
|
||||
@ -216,7 +216,7 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
case DIIoctl::DVDLowReadDvdCopyright:
|
||||
{
|
||||
const u8 position = Memory::Read_U8(request.buffer_in + 7);
|
||||
INFO_LOG(IOS_DI, "DVDLowReadDvdCopyright: position 0x%02x", position);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowReadDvdCopyright: position {:#04x}", position);
|
||||
DICMDBUF0 = 0xAD010000 | (position << 8);
|
||||
DICMDBUF1 = 0;
|
||||
DICMDBUF2 = 0;
|
||||
@ -225,59 +225,59 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
case DIIoctl::DVDLowReadDvdDiscKey:
|
||||
{
|
||||
const u8 position = Memory::Read_U8(request.buffer_in + 7);
|
||||
INFO_LOG(IOS_DI, "DVDLowReadDvdDiscKey: position 0x%02x", position);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowReadDvdDiscKey: position {:#04x}", position);
|
||||
DICMDBUF0 = 0xAD020000 | (position << 8);
|
||||
DICMDBUF1 = 0;
|
||||
DICMDBUF2 = 0;
|
||||
return StartDMATransfer(0x800, request);
|
||||
}
|
||||
case DIIoctl::DVDLowGetLength:
|
||||
INFO_LOG(IOS_DI, "DVDLowGetLength 0x%08x", m_last_length);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowGetLength {:#010x}", m_last_length);
|
||||
return WriteIfFits(request, m_last_length);
|
||||
case DIIoctl::DVDLowGetImmBuf:
|
||||
{
|
||||
u32 diimmbuf = DIIMMBUF;
|
||||
INFO_LOG(IOS_DI, "DVDLowGetImmBuf 0x%08x", diimmbuf);
|
||||
const u32 diimmbuf = DIIMMBUF;
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowGetImmBuf {:#010x}", diimmbuf);
|
||||
return WriteIfFits(request, diimmbuf);
|
||||
}
|
||||
case DIIoctl::DVDLowMaskCoverInterrupt:
|
||||
INFO_LOG(IOS_DI, "DVDLowMaskCoverInterrupt");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowMaskCoverInterrupt");
|
||||
DVDInterface::SetInterruptEnabled(DVDInterface::DIInterruptType::CVRINT, false);
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DI_INTERRUPT_MASK_COMMAND);
|
||||
return DIResult::Success;
|
||||
case DIIoctl::DVDLowClearCoverInterrupt:
|
||||
DEBUG_LOG(IOS_DI, "DVDLowClearCoverInterrupt");
|
||||
DEBUG_LOG_FMT(IOS_DI, "DVDLowClearCoverInterrupt");
|
||||
DVDInterface::ClearInterrupt(DVDInterface::DIInterruptType::CVRINT);
|
||||
return DIResult::Success;
|
||||
case DIIoctl::DVDLowUnmaskStatusInterrupts:
|
||||
INFO_LOG(IOS_DI, "DVDLowUnmaskStatusInterrupts");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowUnmaskStatusInterrupts");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DI_INTERRUPT_MASK_COMMAND);
|
||||
// Dummied out
|
||||
return DIResult::Success;
|
||||
case DIIoctl::DVDLowGetCoverStatus:
|
||||
// TODO: handle resetting case
|
||||
INFO_LOG(IOS_DI, "DVDLowGetCoverStatus: Disc %sInserted",
|
||||
DVDInterface::IsDiscInside() ? "" : "Not ");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowGetCoverStatus: Disc {}Inserted",
|
||||
DVDInterface::IsDiscInside() ? "" : "Not ");
|
||||
return WriteIfFits(request, DVDInterface::IsDiscInside() ? 2 : 1);
|
||||
case DIIoctl::DVDLowUnmaskCoverInterrupt:
|
||||
INFO_LOG(IOS_DI, "DVDLowUnmaskCoverInterrupt");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowUnmaskCoverInterrupt");
|
||||
DVDInterface::SetInterruptEnabled(DVDInterface::DIInterruptType::CVRINT, true);
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DI_INTERRUPT_MASK_COMMAND);
|
||||
return DIResult::Success;
|
||||
case DIIoctl::DVDLowReset:
|
||||
{
|
||||
const bool spinup = Memory::Read_U32(request.buffer_in + 4);
|
||||
INFO_LOG(IOS_DI, "DVDLowReset %s spinup", spinup ? "with" : "without");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowReset {} spinup", spinup ? "with" : "without");
|
||||
DVDInterface::ResetDrive(spinup);
|
||||
ResetDIRegisters();
|
||||
return DIResult::Success;
|
||||
}
|
||||
case DIIoctl::DVDLowOpenPartition:
|
||||
ERROR_LOG(IOS_DI, "DVDLowOpenPartition as an ioctl - rejecting");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowOpenPartition as an ioctl - rejecting");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
return DIResult::SecurityError;
|
||||
case DIIoctl::DVDLowClosePartition:
|
||||
INFO_LOG(IOS_DI, "DVDLowClosePartition");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowClosePartition");
|
||||
ChangePartition(DiscIO::PARTITION_NONE);
|
||||
return DIResult::Success;
|
||||
case DIIoctl::DVDLowUnencryptedRead:
|
||||
@ -285,8 +285,8 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
const u32 length = Memory::Read_U32(request.buffer_in + 4);
|
||||
const u32 position = Memory::Read_U32(request.buffer_in + 8);
|
||||
const u32 end = position + (length >> 2); // a 32-bit offset
|
||||
INFO_LOG(IOS_DI, "DVDLowUnencryptedRead: offset 0x%08x (byte 0x%09" PRIx64 "), length 0x%x",
|
||||
position, static_cast<u64>(position) << 2, length);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowUnencryptedRead: offset {:#010x} (byte {:#011x}), length {:#x}",
|
||||
position, static_cast<u64>(position) << 2, length);
|
||||
// (start, end) as 32-bit offsets
|
||||
// Older IOS versions only accept the first range. Later versions added the extra ranges to
|
||||
// check how the drive responds to out of bounds reads (an error 001 check).
|
||||
@ -306,51 +306,51 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
return StartDMATransfer(length, request);
|
||||
}
|
||||
}
|
||||
WARN_LOG(IOS_DI, "DVDLowUnencryptedRead: trying to read from an illegal region!");
|
||||
WARN_LOG_FMT(IOS_DI, "DVDLowUnencryptedRead: trying to read from an illegal region!");
|
||||
return DIResult::SecurityError;
|
||||
}
|
||||
case DIIoctl::DVDLowEnableDvdVideo:
|
||||
ERROR_LOG(IOS_DI, "DVDLowEnableDvdVideo - rejecting");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowEnableDvdVideo - rejecting");
|
||||
return DIResult::SecurityError;
|
||||
// There are a bunch of ioctlvs that are also (unintentionally) usable as ioctls; reject these in
|
||||
// Dolphin as games are unlikely to use them.
|
||||
case DIIoctl::DVDLowGetNoDiscOpenPartitionParams:
|
||||
ERROR_LOG(IOS_DI, "DVDLowGetNoDiscOpenPartitionParams as an ioctl - rejecting");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowGetNoDiscOpenPartitionParams as an ioctl - rejecting");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
return DIResult::SecurityError;
|
||||
case DIIoctl::DVDLowNoDiscOpenPartition:
|
||||
ERROR_LOG(IOS_DI, "DVDLowNoDiscOpenPartition as an ioctl - rejecting");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowNoDiscOpenPartition as an ioctl - rejecting");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
return DIResult::SecurityError;
|
||||
case DIIoctl::DVDLowGetNoDiscBufferSizes:
|
||||
ERROR_LOG(IOS_DI, "DVDLowGetNoDiscBufferSizes as an ioctl - rejecting");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowGetNoDiscBufferSizes as an ioctl - rejecting");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
return DIResult::SecurityError;
|
||||
case DIIoctl::DVDLowOpenPartitionWithTmdAndTicket:
|
||||
ERROR_LOG(IOS_DI, "DVDLowOpenPartitionWithTmdAndTicket as an ioctl - rejecting");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowOpenPartitionWithTmdAndTicket as an ioctl - rejecting");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
return DIResult::SecurityError;
|
||||
case DIIoctl::DVDLowOpenPartitionWithTmdAndTicketView:
|
||||
ERROR_LOG(IOS_DI, "DVDLowOpenPartitionWithTmdAndTicketView as an ioctl - rejecting");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowOpenPartitionWithTmdAndTicketView as an ioctl - rejecting");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
return DIResult::SecurityError;
|
||||
case DIIoctl::DVDLowGetStatusRegister:
|
||||
{
|
||||
u32 disr = DISR;
|
||||
INFO_LOG(IOS_DI, "DVDLowGetStatusRegister: 0x%08x", disr);
|
||||
const u32 disr = DISR;
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowGetStatusRegister: {:#010x}", disr);
|
||||
return WriteIfFits(request, disr);
|
||||
}
|
||||
case DIIoctl::DVDLowGetControlRegister:
|
||||
{
|
||||
u32 dicr = DICR;
|
||||
INFO_LOG(IOS_DI, "DVDLowGetControlRegister: 0x%08x", dicr);
|
||||
const u32 dicr = DICR;
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowGetControlRegister: {:#010x}", dicr);
|
||||
return WriteIfFits(request, dicr);
|
||||
}
|
||||
case DIIoctl::DVDLowReportKey:
|
||||
{
|
||||
const u8 param1 = Memory::Read_U8(request.buffer_in + 7);
|
||||
const u32 param2 = Memory::Read_U32(request.buffer_in + 8);
|
||||
INFO_LOG(IOS_DI, "DVDLowReportKey: param1 0x%02x, param2 0x%06x", param1, param2);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowReportKey: param1 {:#04x}, param2 {:#08x}", param1, param2);
|
||||
DICMDBUF0 = 0xA4000000 | (param1 << 16);
|
||||
DICMDBUF1 = param2 & 0xFFFFFF;
|
||||
DICMDBUF2 = 0;
|
||||
@ -359,8 +359,8 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
case DIIoctl::DVDLowSeek:
|
||||
{
|
||||
const u32 position = Memory::Read_U32(request.buffer_in + 4); // 32-bit offset
|
||||
INFO_LOG(IOS_DI, "DVDLowSeek: position 0x%08x, translated to 0x%08x", position,
|
||||
position); // TODO: do partition translation!
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowSeek: position {:#010x}, translated to {:#010x}", position,
|
||||
position); // TODO: do partition translation!
|
||||
DICMDBUF0 = 0xAB000000;
|
||||
DICMDBUF1 = position;
|
||||
return StartImmediateTransfer(request, false);
|
||||
@ -371,8 +371,8 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
const u8 flag2 = Memory::Read_U8(request.buffer_in + 11);
|
||||
const u32 length = Memory::Read_U32(request.buffer_in + 12);
|
||||
const u32 position = Memory::Read_U32(request.buffer_in + 16);
|
||||
INFO_LOG(IOS_DI, "DVDLowReadDvd(%d, %d): position 0x%06x, length 0x%06x", flag1, flag2,
|
||||
position, length);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowReadDvd({}, {}): position {:#08x}, length {:#08x}", flag1, flag2,
|
||||
position, length);
|
||||
DICMDBUF0 = 0xD0000000 | ((flag1 & 1) << 7) | ((flag2 & 1) << 6);
|
||||
DICMDBUF1 = position & 0xFFFFFF;
|
||||
DICMDBUF2 = length & 0xFFFFFF;
|
||||
@ -383,41 +383,41 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
const u8 flag1 = Memory::Read_U8(request.buffer_in + 7);
|
||||
const u8 param2 = Memory::Read_U8(request.buffer_in + 11);
|
||||
const u32 position = Memory::Read_U32(request.buffer_in + 12);
|
||||
INFO_LOG(IOS_DI, "DVDLowReadDvdConfig(%d, %d): position 0x%06x", flag1, param2, position);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowReadDvdConfig({}, {}): position {:#08x}", flag1, param2, position);
|
||||
DICMDBUF0 = 0xD1000000 | ((flag1 & 1) << 16) | param2;
|
||||
DICMDBUF1 = position & 0xFFFFFF;
|
||||
DICMDBUF2 = 0;
|
||||
return StartImmediateTransfer(request);
|
||||
}
|
||||
case DIIoctl::DVDLowStopLaser:
|
||||
INFO_LOG(IOS_DI, "DVDLowStopLaser");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowStopLaser");
|
||||
DICMDBUF0 = 0xD2000000;
|
||||
return StartImmediateTransfer(request);
|
||||
case DIIoctl::DVDLowOffset:
|
||||
{
|
||||
const u8 flag = Memory::Read_U8(request.buffer_in + 7);
|
||||
const u32 offset = Memory::Read_U32(request.buffer_in + 8);
|
||||
INFO_LOG(IOS_DI, "DVDLowOffset(%d): offset 0x%08x", flag, offset);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowOffset({}): offset {:#010x}", flag, offset);
|
||||
DICMDBUF0 = 0xD9000000 | ((flag & 1) << 16);
|
||||
DICMDBUF1 = offset;
|
||||
return StartImmediateTransfer(request);
|
||||
}
|
||||
case DIIoctl::DVDLowReadDiskBca:
|
||||
INFO_LOG(IOS_DI, "DVDLowReadDiskBca");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowReadDiskBca");
|
||||
DICMDBUF0 = 0xDA000000;
|
||||
return StartDMATransfer(0x40, request);
|
||||
case DIIoctl::DVDLowRequestDiscStatus:
|
||||
INFO_LOG(IOS_DI, "DVDLowRequestDiscStatus");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowRequestDiscStatus");
|
||||
DICMDBUF0 = 0xDB000000;
|
||||
return StartImmediateTransfer(request);
|
||||
case DIIoctl::DVDLowRequestRetryNumber:
|
||||
INFO_LOG(IOS_DI, "DVDLowRequestRetryNumber");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowRequestRetryNumber");
|
||||
DICMDBUF0 = 0xDC000000;
|
||||
return StartImmediateTransfer(request);
|
||||
case DIIoctl::DVDLowSetMaximumRotation:
|
||||
{
|
||||
const u8 speed = Memory::Read_U8(request.buffer_in + 7);
|
||||
INFO_LOG(IOS_DI, "DVDLowSetMaximumRotation: speed %d", speed);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowSetMaximumRotation: speed {}", speed);
|
||||
DICMDBUF0 = 0xDD000000 | ((speed & 3) << 16);
|
||||
return StartImmediateTransfer(request, false);
|
||||
}
|
||||
@ -425,12 +425,12 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
{
|
||||
const u8 flag1 = Memory::Read_U8(request.buffer_in + 7);
|
||||
const u8 flag2 = Memory::Read_U8(request.buffer_in + 11);
|
||||
INFO_LOG(IOS_DI, "DVDLowSerMeasControl(%d, %d)", flag1, flag2);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowSerMeasControl({}, {})", flag1, flag2);
|
||||
DICMDBUF0 = 0xDF000000 | ((flag1 & 1) << 17) | ((flag2 & 1) << 16);
|
||||
return StartDMATransfer(0x20, request);
|
||||
}
|
||||
case DIIoctl::DVDLowRequestError:
|
||||
INFO_LOG(IOS_DI, "DVDLowRequestError");
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowRequestError");
|
||||
DICMDBUF0 = 0xE0000000;
|
||||
return StartImmediateTransfer(request);
|
||||
case DIIoctl::DVDLowAudioStream:
|
||||
@ -438,8 +438,8 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
const u8 mode = Memory::Read_U8(request.buffer_in + 7);
|
||||
const u32 length = Memory::Read_U32(request.buffer_in + 8);
|
||||
const u32 position = Memory::Read_U32(request.buffer_in + 12);
|
||||
INFO_LOG(IOS_DI, "DVDLowAudioStream(%d): offset 0x%08x (byte 0x%09" PRIx64 "), length 0x%x",
|
||||
mode, position, static_cast<u64>(position) << 2, length);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowAudioStream({}): offset {:#010x} (byte {:#011x}), length {:#x}",
|
||||
mode, position, static_cast<u64>(position) << 2, length);
|
||||
DICMDBUF0 = 0xE1000000 | ((mode & 3) << 16);
|
||||
DICMDBUF1 = position;
|
||||
DICMDBUF2 = length;
|
||||
@ -448,7 +448,7 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
case DIIoctl::DVDLowRequestAudioStatus:
|
||||
{
|
||||
const u8 mode = Memory::Read_U8(request.buffer_in + 7);
|
||||
INFO_LOG(IOS_DI, "DVDLowRequestAudioStatus(%d)", mode);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowRequestAudioStatus({})", mode);
|
||||
DICMDBUF0 = 0xE2000000 | ((mode & 3) << 16);
|
||||
DICMDBUF1 = 0;
|
||||
// Note that this command does not copy the value written to DIIMMBUF, which makes it rather
|
||||
@ -459,7 +459,7 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
{
|
||||
const u8 eject = Memory::Read_U8(request.buffer_in + 7);
|
||||
const u8 kill = Memory::Read_U8(request.buffer_in + 11);
|
||||
INFO_LOG(IOS_DI, "DVDLowStopMotor(%d, %d)", eject, kill);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowStopMotor({}, {})", eject, kill);
|
||||
DICMDBUF0 = 0xE3000000 | ((eject & 1) << 17) | ((kill & 1) << 20);
|
||||
DICMDBUF1 = 0;
|
||||
return StartImmediateTransfer(request);
|
||||
@ -468,8 +468,8 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
{
|
||||
const u8 enable = Memory::Read_U8(request.buffer_in + 7);
|
||||
const u8 buffer_size = Memory::Read_U8(request.buffer_in + 11);
|
||||
INFO_LOG(IOS_DI, "DVDLowAudioBufferConfig: %s, buffer size %d", enable ? "enabled" : "disabled",
|
||||
buffer_size);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowAudioBufferConfig: {}, buffer size {}",
|
||||
enable ? "enabled" : "disabled", buffer_size);
|
||||
DICMDBUF0 = 0xE4000000 | ((enable & 1) << 16) | (buffer_size & 0xf);
|
||||
DICMDBUF1 = 0;
|
||||
// On the other hand, this command *does* copy DIIMMBUF, but the actual code in the drive never
|
||||
@ -477,7 +477,7 @@ std::optional<DI::DIResult> DI::StartIOCtl(const IOCtlRequest& request)
|
||||
return StartImmediateTransfer(request);
|
||||
}
|
||||
default:
|
||||
ERROR_LOG(IOS_DI, "Unknown ioctl 0x%02x", request.request);
|
||||
ERROR_LOG_FMT(IOS_DI, "Unknown ioctl {:#04x}", request.request);
|
||||
return DIResult::SecurityError;
|
||||
}
|
||||
}
|
||||
@ -489,10 +489,11 @@ std::optional<DI::DIResult> DI::StartDMATransfer(u32 command_length, const IOCtl
|
||||
// Actual /dev/di will still send a command, but won't write the length or output address,
|
||||
// causing it to eventually time out after 15 seconds. Just immediately time out here,
|
||||
// instead.
|
||||
WARN_LOG(IOS_DI,
|
||||
"Output buffer is too small for the result of the command (%d bytes given, needed at "
|
||||
"least %d); returning read timed out (immediately, instead of waiting)",
|
||||
request.buffer_out_size, command_length);
|
||||
WARN_LOG_FMT(
|
||||
IOS_DI,
|
||||
"Output buffer is too small for the result of the command ({} bytes given, needed at "
|
||||
"least {}); returning read timed out (immediately, instead of waiting)",
|
||||
request.buffer_out_size, command_length);
|
||||
return DIResult::ReadTimedOut;
|
||||
}
|
||||
|
||||
@ -500,10 +501,11 @@ std::optional<DI::DIResult> DI::StartDMATransfer(u32 command_length, const IOCtl
|
||||
{
|
||||
// In most cases, the actual DI driver just hangs for unaligned data, but let's be a bit more
|
||||
// gentle.
|
||||
WARN_LOG(IOS_DI,
|
||||
"Output buffer or length is incorrectly aligned (buffer 0x%08x, buffer length %x, "
|
||||
"command length %x)",
|
||||
request.buffer_out, request.buffer_out_size, command_length);
|
||||
WARN_LOG_FMT(
|
||||
IOS_DI,
|
||||
"Output buffer or length is incorrectly aligned (buffer {:#010x}, buffer length {:x}, "
|
||||
"command length {:x})",
|
||||
request.buffer_out, request.buffer_out_size, command_length);
|
||||
return DIResult::BadArgument;
|
||||
}
|
||||
|
||||
@ -520,10 +522,11 @@ std::optional<DI::DIResult> DI::StartImmediateTransfer(const IOCtlRequest& reque
|
||||
{
|
||||
if (write_to_buf && request.buffer_out_size < 4)
|
||||
{
|
||||
WARN_LOG(IOS_DI,
|
||||
"Output buffer size is too small for an immediate transfer (%d bytes, should be at "
|
||||
"least 4). Performing transfer anyways.",
|
||||
request.buffer_out_size);
|
||||
WARN_LOG_FMT(
|
||||
IOS_DI,
|
||||
"Output buffer size is too small for an immediate transfer ({} bytes, should be at "
|
||||
"least 4). Performing transfer anyways.",
|
||||
request.buffer_out_size);
|
||||
}
|
||||
|
||||
m_executing_command->m_copy_diimmbuf = write_to_buf;
|
||||
@ -555,8 +558,8 @@ void DI::InterruptFromDVDInterface(DVDInterface::DIInterruptType interrupt_type)
|
||||
result = DIResult::DriveError;
|
||||
break;
|
||||
default:
|
||||
PanicAlert("IOS::HLE::Device::DI: Unexpected DVDInterface interrupt %d!",
|
||||
static_cast<int>(interrupt_type));
|
||||
PanicAlertFmt("IOS::HLE::Device::DI: Unexpected DVDInterface interrupt {0}!",
|
||||
static_cast<int>(interrupt_type));
|
||||
result = DIResult::DriveError;
|
||||
break;
|
||||
}
|
||||
@ -568,8 +571,8 @@ void DI::InterruptFromDVDInterface(DVDInterface::DIInterruptType interrupt_type)
|
||||
}
|
||||
else
|
||||
{
|
||||
PanicAlert("IOS::HLE::Device::DI: Received interrupt from DVDInterface when device wasn't "
|
||||
"registered!");
|
||||
PanicAlertFmt("IOS::HLE::Device::DI: Received interrupt from DVDInterface when device wasn't "
|
||||
"registered!");
|
||||
}
|
||||
}
|
||||
|
||||
@ -581,14 +584,15 @@ void DI::FinishDICommandCallback(u64 userdata, s64 ticksbehind)
|
||||
if (di)
|
||||
di->FinishDICommand(result);
|
||||
else
|
||||
PanicAlert("IOS::HLE::Device::DI: Received interrupt from DI when device wasn't registered!");
|
||||
PanicAlertFmt(
|
||||
"IOS::HLE::Device::DI: Received interrupt from DI when device wasn't registered!");
|
||||
}
|
||||
|
||||
void DI::FinishDICommand(DIResult result)
|
||||
{
|
||||
if (!m_executing_command.has_value())
|
||||
{
|
||||
PanicAlert("IOS::HLE::Device::DI: There is no command to finish!");
|
||||
PanicAlertFmt("IOS::HLE::Device::DI: There is no command to finish!");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -617,17 +621,18 @@ IPCCommandResult DI::IOCtlV(const IOCtlVRequest& request)
|
||||
|
||||
if (request.in_vectors[0].size != 0x20)
|
||||
{
|
||||
ERROR_LOG(IOS_DI, "IOCtlV: Received bad input buffer size 0x%02x, should be 0x20",
|
||||
request.in_vectors[0].size);
|
||||
ERROR_LOG_FMT(IOS_DI, "IOCtlV: Received bad input buffer size {:#04x}, should be 0x20",
|
||||
request.in_vectors[0].size);
|
||||
return GetDefaultReply(static_cast<s32>(DIResult::BadArgument));
|
||||
}
|
||||
const u8 command = Memory::Read_U8(request.in_vectors[0].address);
|
||||
if (request.request != command)
|
||||
{
|
||||
WARN_LOG(IOS_DI,
|
||||
"IOCtlV: Received conflicting commands: ioctl 0x%02x, buffer 0x%02x. Using ioctlv "
|
||||
"command.",
|
||||
request.request, command);
|
||||
WARN_LOG_FMT(
|
||||
IOS_DI,
|
||||
"IOCtlV: Received conflicting commands: ioctl {:#04x}, buffer {:#04x}. Using ioctlv "
|
||||
"command.",
|
||||
request.request, command);
|
||||
}
|
||||
|
||||
DIResult return_value = DIResult::BadArgument;
|
||||
@ -637,20 +642,21 @@ IPCCommandResult DI::IOCtlV(const IOCtlVRequest& request)
|
||||
{
|
||||
if (request.in_vectors.size() != 3 || request.io_vectors.size() != 2)
|
||||
{
|
||||
ERROR_LOG(IOS_DI, "DVDLowOpenPartition: bad vector count %zu in/%zu out",
|
||||
request.in_vectors.size(), request.io_vectors.size());
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowOpenPartition: bad vector count {} in/{} out",
|
||||
request.in_vectors.size(), request.io_vectors.size());
|
||||
break;
|
||||
}
|
||||
if (request.in_vectors[1].address != 0)
|
||||
{
|
||||
ERROR_LOG(IOS_DI,
|
||||
"DVDLowOpenPartition with ticket - not implemented, ignoring ticket parameter");
|
||||
ERROR_LOG_FMT(IOS_DI,
|
||||
"DVDLowOpenPartition with ticket - not implemented, ignoring ticket parameter");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
}
|
||||
if (request.in_vectors[2].address != 0)
|
||||
{
|
||||
ERROR_LOG(IOS_DI,
|
||||
"DVDLowOpenPartition with cert chain - not implemented, ignoring certs parameter");
|
||||
ERROR_LOG_FMT(
|
||||
IOS_DI,
|
||||
"DVDLowOpenPartition with cert chain - not implemented, ignoring certs parameter");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
}
|
||||
|
||||
@ -658,7 +664,7 @@ IPCCommandResult DI::IOCtlV(const IOCtlVRequest& request)
|
||||
static_cast<u64>(Memory::Read_U32(request.in_vectors[0].address + 4)) << 2;
|
||||
ChangePartition(DiscIO::Partition(partition_offset));
|
||||
|
||||
INFO_LOG(IOS_DI, "DVDLowOpenPartition: partition_offset 0x%09" PRIx64, partition_offset);
|
||||
INFO_LOG_FMT(IOS_DI, "DVDLowOpenPartition: partition_offset {:#011x}", partition_offset);
|
||||
|
||||
// Read TMD to the buffer
|
||||
const IOS::ES::TMDReader tmd = DVDThread::GetTMD(m_current_partition);
|
||||
@ -672,30 +678,30 @@ IPCCommandResult DI::IOCtlV(const IOCtlVRequest& request)
|
||||
break;
|
||||
}
|
||||
case DIIoctl::DVDLowGetNoDiscOpenPartitionParams:
|
||||
ERROR_LOG(IOS_DI, "DVDLowGetNoDiscOpenPartitionParams - dummied out");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowGetNoDiscOpenPartitionParams - dummied out");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
request.DumpUnknown(GetDeviceName(), Common::Log::IOS_DI);
|
||||
break;
|
||||
case DIIoctl::DVDLowNoDiscOpenPartition:
|
||||
ERROR_LOG(IOS_DI, "DVDLowNoDiscOpenPartition - dummied out");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowNoDiscOpenPartition - dummied out");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
request.DumpUnknown(GetDeviceName(), Common::Log::IOS_DI);
|
||||
break;
|
||||
case DIIoctl::DVDLowGetNoDiscBufferSizes:
|
||||
ERROR_LOG(IOS_DI, "DVDLowGetNoDiscBufferSizes - dummied out");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowGetNoDiscBufferSizes - dummied out");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
request.DumpUnknown(GetDeviceName(), Common::Log::IOS_DI);
|
||||
break;
|
||||
case DIIoctl::DVDLowOpenPartitionWithTmdAndTicket:
|
||||
ERROR_LOG(IOS_DI, "DVDLowOpenPartitionWithTmdAndTicket - not implemented");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowOpenPartitionWithTmdAndTicket - not implemented");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
break;
|
||||
case DIIoctl::DVDLowOpenPartitionWithTmdAndTicketView:
|
||||
ERROR_LOG(IOS_DI, "DVDLowOpenPartitionWithTmdAndTicketView - not implemented");
|
||||
ERROR_LOG_FMT(IOS_DI, "DVDLowOpenPartitionWithTmdAndTicketView - not implemented");
|
||||
DolphinAnalytics::Instance().ReportGameQuirk(GameQuirk::USES_DIFFERENT_PARTITION_COMMAND);
|
||||
break;
|
||||
default:
|
||||
ERROR_LOG(IOS_DI, "Unknown ioctlv 0x%02x", request.request);
|
||||
ERROR_LOG_FMT(IOS_DI, "Unknown ioctlv {:#04x}", request.request);
|
||||
request.DumpUnknown(GetDeviceName(), Common::Log::IOS_DI);
|
||||
}
|
||||
return GetDefaultReply(static_cast<s32>(return_value));
|
||||
|
||||
@ -94,21 +94,21 @@ bool IOCtlVRequest::HasNumberOfValidVectors(const size_t in_count, const size_t
|
||||
std::all_of(io_vectors.begin(), io_vectors.end(), IsValidVector);
|
||||
}
|
||||
|
||||
void IOCtlRequest::Log(const std::string& device_name, Common::Log::LOG_TYPE type,
|
||||
void IOCtlRequest::Log(std::string_view device_name, Common::Log::LOG_TYPE type,
|
||||
Common::Log::LOG_LEVELS verbosity) const
|
||||
{
|
||||
GENERIC_LOG(type, verbosity, "%s (fd %u) - IOCtl 0x%x (in_size=0x%x, out_size=0x%x)",
|
||||
device_name.c_str(), fd, request, buffer_in_size, buffer_out_size);
|
||||
GENERIC_LOG_FMT(type, verbosity, "{} (fd {}) - IOCtl {:#x} (in_size={:#x}, out_size={:#x})",
|
||||
device_name, fd, request, buffer_in_size, buffer_out_size);
|
||||
}
|
||||
|
||||
void IOCtlRequest::Dump(const std::string& description, Common::Log::LOG_TYPE type,
|
||||
Common::Log::LOG_LEVELS level) const
|
||||
{
|
||||
Log("===== " + description, type, level);
|
||||
GENERIC_LOG(type, level, "In buffer\n%s",
|
||||
HexDump(Memory::GetPointer(buffer_in), buffer_in_size).c_str());
|
||||
GENERIC_LOG(type, level, "Out buffer\n%s",
|
||||
HexDump(Memory::GetPointer(buffer_out), buffer_out_size).c_str());
|
||||
GENERIC_LOG_FMT(type, level, "In buffer\n{}",
|
||||
HexDump(Memory::GetPointer(buffer_in), buffer_in_size));
|
||||
GENERIC_LOG_FMT(type, level, "Out buffer\n{}",
|
||||
HexDump(Memory::GetPointer(buffer_out), buffer_out_size));
|
||||
}
|
||||
|
||||
void IOCtlRequest::DumpUnknown(const std::string& description, Common::Log::LOG_TYPE type,
|
||||
@ -117,20 +117,22 @@ void IOCtlRequest::DumpUnknown(const std::string& description, Common::Log::LOG_
|
||||
Dump("Unknown IOCtl - " + description, type, level);
|
||||
}
|
||||
|
||||
void IOCtlVRequest::Dump(const std::string& description, Common::Log::LOG_TYPE type,
|
||||
void IOCtlVRequest::Dump(std::string_view description, Common::Log::LOG_TYPE type,
|
||||
Common::Log::LOG_LEVELS level) const
|
||||
{
|
||||
GENERIC_LOG(type, level, "===== %s (fd %u) - IOCtlV 0x%x (%zu in, %zu io)", description.c_str(),
|
||||
fd, request, in_vectors.size(), io_vectors.size());
|
||||
GENERIC_LOG_FMT(type, level, "===== {} (fd {}) - IOCtlV {:#x} ({} in, {} io)", description, fd,
|
||||
request, in_vectors.size(), io_vectors.size());
|
||||
|
||||
size_t i = 0;
|
||||
for (const auto& vector : in_vectors)
|
||||
GENERIC_LOG(type, level, "in[%zu] (size=0x%x):\n%s", i++, vector.size,
|
||||
HexDump(Memory::GetPointer(vector.address), vector.size).c_str());
|
||||
{
|
||||
GENERIC_LOG_FMT(type, level, "in[{}] (size={:#x}):\n{}", i++, vector.size,
|
||||
HexDump(Memory::GetPointer(vector.address), vector.size));
|
||||
}
|
||||
|
||||
i = 0;
|
||||
for (const auto& vector : io_vectors)
|
||||
GENERIC_LOG(type, level, "io[%zu] (size=0x%x)", i++, vector.size);
|
||||
GENERIC_LOG_FMT(type, level, "io[{}] (size={:#x})", i++, vector.size);
|
||||
}
|
||||
|
||||
void IOCtlVRequest::DumpUnknown(const std::string& description, Common::Log::LOG_TYPE type,
|
||||
@ -173,12 +175,15 @@ IPCCommandResult Device::Close(u32 fd)
|
||||
|
||||
IPCCommandResult Device::Unsupported(const Request& request)
|
||||
{
|
||||
static std::map<IPCCommandType, std::string> names = {{{IPC_CMD_READ, "Read"},
|
||||
{IPC_CMD_WRITE, "Write"},
|
||||
{IPC_CMD_SEEK, "Seek"},
|
||||
{IPC_CMD_IOCTL, "IOCtl"},
|
||||
{IPC_CMD_IOCTLV, "IOCtlV"}}};
|
||||
WARN_LOG(IOS, "%s does not support %s()", m_name.c_str(), names[request.command].c_str());
|
||||
static const std::map<IPCCommandType, std::string_view> names{{
|
||||
{IPC_CMD_READ, "Read"},
|
||||
{IPC_CMD_WRITE, "Write"},
|
||||
{IPC_CMD_SEEK, "Seek"},
|
||||
{IPC_CMD_IOCTL, "IOCtl"},
|
||||
{IPC_CMD_IOCTLV, "IOCtlV"},
|
||||
}};
|
||||
|
||||
WARN_LOG_FMT(IOS, "{} does not support {}()", m_name, names.at(request.command));
|
||||
return GetDefaultReply(IPC_EINVAL);
|
||||
}
|
||||
|
||||
|
||||
@ -130,7 +130,7 @@ struct IOCtlRequest final : Request
|
||||
u32 buffer_out = 0;
|
||||
u32 buffer_out_size = 0;
|
||||
explicit IOCtlRequest(u32 address);
|
||||
void Log(const std::string& description, Common::Log::LOG_TYPE type = Common::Log::IOS,
|
||||
void Log(std::string_view description, Common::Log::LOG_TYPE type = Common::Log::IOS,
|
||||
Common::Log::LOG_LEVELS level = Common::Log::LINFO) const;
|
||||
void Dump(const std::string& description, Common::Log::LOG_TYPE type = Common::Log::IOS,
|
||||
Common::Log::LOG_LEVELS level = Common::Log::LINFO) const;
|
||||
@ -157,7 +157,7 @@ struct IOCtlVRequest final : Request
|
||||
const IOVector* GetVector(size_t index) const;
|
||||
explicit IOCtlVRequest(u32 address);
|
||||
bool HasNumberOfValidVectors(size_t in_count, size_t io_count) const;
|
||||
void Dump(const std::string& description, Common::Log::LOG_TYPE type = Common::Log::IOS,
|
||||
void Dump(std::string_view description, Common::Log::LOG_TYPE type = Common::Log::IOS,
|
||||
Common::Log::LOG_LEVELS level = Common::Log::LINFO) const;
|
||||
void DumpUnknown(const std::string& description, Common::Log::LOG_TYPE type = Common::Log::IOS,
|
||||
Common::Log::LOG_LEVELS level = Common::Log::LERROR) const;
|
||||
|
||||
@ -10,20 +10,20 @@ namespace IOS::HLE::Device
|
||||
{
|
||||
IPCCommandResult Stub::Open(const OpenRequest& request)
|
||||
{
|
||||
WARN_LOG(IOS, "%s faking Open()", m_name.c_str());
|
||||
WARN_LOG_FMT(IOS, "{} faking Open()", m_name);
|
||||
m_is_active = true;
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
IPCCommandResult Stub::IOCtl(const IOCtlRequest& request)
|
||||
{
|
||||
WARN_LOG(IOS, "%s faking IOCtl()", m_name.c_str());
|
||||
WARN_LOG_FMT(IOS, "{} faking IOCtl()", m_name);
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
IPCCommandResult Stub::IOCtlV(const IOCtlVRequest& request)
|
||||
{
|
||||
WARN_LOG(IOS, "%s faking IOCtlV()", m_name.c_str());
|
||||
WARN_LOG_FMT(IOS, "{} faking IOCtlV()", m_name);
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
} // namespace IOS::HLE::Device
|
||||
|
||||
@ -5,7 +5,6 @@
|
||||
#include "Core/IOS/ES/ES.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cinttypes>
|
||||
#include <cstdio>
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
@ -63,7 +62,10 @@ ES::ES(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
|
||||
const auto result = m_ios.GetFS()->CreateDirectory(PID_KERNEL, PID_KERNEL, directory.path,
|
||||
directory.attribute, directory.modes);
|
||||
if (result != FS::ResultCode::Success && result != FS::ResultCode::AlreadyExists)
|
||||
ERROR_LOG(IOS_ES, "Failed to create %s: error %d", directory.path, FS::ConvertResult(result));
|
||||
{
|
||||
ERROR_LOG_FMT(IOS_ES, "Failed to create {}: error {}", directory.path,
|
||||
FS::ConvertResult(result));
|
||||
}
|
||||
|
||||
// Now update the UID/GID and other attributes.
|
||||
m_ios.GetFS()->SetMetadata(0, directory.path, directory.uid, directory.gid, directory.attribute,
|
||||
@ -74,7 +76,7 @@ ES::ES(Kernel& ios, const std::string& device_name) : Device(ios, device_name)
|
||||
|
||||
if (s_title_to_launch != 0)
|
||||
{
|
||||
NOTICE_LOG(IOS, "Re-launching title after IOS reload.");
|
||||
NOTICE_LOG_FMT(IOS, "Re-launching title after IOS reload.");
|
||||
LaunchTitle(s_title_to_launch, true);
|
||||
s_title_to_launch = 0;
|
||||
}
|
||||
@ -99,7 +101,7 @@ void TitleContext::Update(const IOS::ES::TMDReader& tmd_, const IOS::ES::TicketR
|
||||
{
|
||||
if (!tmd_.IsValid() || !ticket_.IsValid())
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "TMD or ticket is not valid -- refusing to update title context");
|
||||
ERROR_LOG_FMT(IOS_ES, "TMD or ticket is not valid -- refusing to update title context");
|
||||
return;
|
||||
}
|
||||
|
||||
@ -120,12 +122,13 @@ IPCCommandResult ES::GetTitleDirectory(const IOCtlVRequest& request)
|
||||
if (!request.HasNumberOfValidVectors(1, 1))
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
|
||||
u64 TitleID = Memory::Read_U64(request.in_vectors[0].address);
|
||||
const u64 title_id = Memory::Read_U64(request.in_vectors[0].address);
|
||||
|
||||
char* Path = (char*)Memory::GetPointer(request.io_vectors[0].address);
|
||||
sprintf(Path, "/title/%08x/%08x/data", (u32)(TitleID >> 32), (u32)TitleID);
|
||||
char* path = reinterpret_cast<char*>(Memory::GetPointer(request.io_vectors[0].address));
|
||||
sprintf(path, "/title/%08x/%08x/data", static_cast<u32>(title_id >> 32),
|
||||
static_cast<u32>(title_id));
|
||||
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_GETTITLEDIR: %s", Path);
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_GETTITLEDIR: {}", path);
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
@ -148,8 +151,8 @@ IPCCommandResult ES::GetTitleId(const IOCtlVRequest& request)
|
||||
return GetDefaultReply(ret);
|
||||
|
||||
Memory::Write_U64(title_id, request.io_vectors[0].address);
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_GETTITLEID: %08x/%08x", static_cast<u32>(title_id >> 32),
|
||||
static_cast<u32>(title_id));
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_GETTITLEID: {:08x}/{:08x}", static_cast<u32>(title_id >> 32),
|
||||
static_cast<u32>(title_id));
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
@ -158,9 +161,9 @@ static bool UpdateUIDAndGID(Kernel& kernel, const IOS::ES::TMDReader& tmd)
|
||||
IOS::ES::UIDSys uid_sys{kernel.GetFS()};
|
||||
const u64 title_id = tmd.GetTitleId();
|
||||
const u32 uid = uid_sys.GetOrInsertUIDForTitle(title_id);
|
||||
if (!uid)
|
||||
if (uid == 0)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "Failed to get UID for title %016" PRIx64, title_id);
|
||||
ERROR_LOG_FMT(IOS_ES, "Failed to get UID for title {:016x}", title_id);
|
||||
return false;
|
||||
}
|
||||
kernel.SetUidForPPC(uid);
|
||||
@ -200,7 +203,7 @@ IPCCommandResult ES::SetUID(u32 uid, const IOCtlVRequest& request)
|
||||
const s32 ret = CheckIsAllowedToSetUID(m_ios, uid, m_title_context.tmd);
|
||||
if (ret < 0)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "SetUID: Permission check failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "SetUID: Permission check failed with error {}", ret);
|
||||
return GetDefaultReply(ret);
|
||||
}
|
||||
|
||||
@ -210,7 +213,7 @@ IPCCommandResult ES::SetUID(u32 uid, const IOCtlVRequest& request)
|
||||
|
||||
if (!UpdateUIDAndGID(m_ios, tmd))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "SetUID: Failed to get UID for title %016" PRIx64, title_id);
|
||||
ERROR_LOG_FMT(IOS_ES, "SetUID: Failed to get UID for title {:016x}", title_id);
|
||||
return GetDefaultReply(ES_SHORT_READ);
|
||||
}
|
||||
|
||||
@ -220,17 +223,18 @@ IPCCommandResult ES::SetUID(u32 uid, const IOCtlVRequest& request)
|
||||
bool ES::LaunchTitle(u64 title_id, bool skip_reload)
|
||||
{
|
||||
m_title_context.Clear();
|
||||
INFO_LOG(IOS_ES, "ES_Launch: Title context changed: (none)");
|
||||
INFO_LOG_FMT(IOS_ES, "ES_Launch: Title context changed: (none)");
|
||||
|
||||
NOTICE_LOG(IOS_ES, "Launching title %016" PRIx64 "...", title_id);
|
||||
NOTICE_LOG_FMT(IOS_ES, "Launching title {:016x}...", title_id);
|
||||
|
||||
if ((title_id == Titles::SHOP || title_id == Titles::KOREAN_SHOP) &&
|
||||
m_ios.GetIOSC().IsUsingDefaultId())
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "Refusing to launch the shop channel with default device credentials");
|
||||
CriticalAlertT("You cannot use the Wii Shop Channel without using your own device credentials."
|
||||
"\nPlease refer to the NAND usage guide for setup instructions: "
|
||||
"https://dolphin-emu.org/docs/guides/nand-usage-guide/");
|
||||
ERROR_LOG_FMT(IOS_ES, "Refusing to launch the shop channel with default device credentials");
|
||||
CriticalAlertFmtT(
|
||||
"You cannot use the Wii Shop Channel without using your own device credentials."
|
||||
"\nPlease refer to the NAND usage guide for setup instructions: "
|
||||
"https://dolphin-emu.org/docs/guides/nand-usage-guide/");
|
||||
|
||||
// Send the user back to the system menu instead of returning an error, which would
|
||||
// likely make the system menu crash. Doing this is okay as anyone who has the shop
|
||||
@ -256,7 +260,7 @@ bool ES::LaunchIOS(u64 ios_title_id)
|
||||
// (indirectly via boot2), we can just launch MIOS when BC is launched.
|
||||
if (ios_title_id == Titles::BC)
|
||||
{
|
||||
NOTICE_LOG(IOS, "BC: Launching MIOS...");
|
||||
NOTICE_LOG_FMT(IOS, "BC: Launching MIOS...");
|
||||
return LaunchIOS(Titles::MIOS);
|
||||
}
|
||||
|
||||
@ -271,9 +275,9 @@ bool ES::LaunchIOS(u64 ios_title_id)
|
||||
if (!tmd.IsValid() || !ticket.IsValid() || !tmd.GetContent(tmd.GetBootIndex(), &content) ||
|
||||
!m_ios.BootIOS(ios_title_id, GetContentPath(ios_title_id, content)))
|
||||
{
|
||||
PanicAlertT("Could not launch IOS %016" PRIx64 " because it is missing from the NAND.\n"
|
||||
"The emulated software will likely hang now.",
|
||||
ios_title_id);
|
||||
PanicAlertFmtT("Could not launch IOS {0:016x} because it is missing from the NAND.\n"
|
||||
"The emulated software will likely hang now.",
|
||||
ios_title_id);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
@ -291,14 +295,14 @@ bool ES::LaunchPPCTitle(u64 title_id, bool skip_reload)
|
||||
{
|
||||
if (title_id == Titles::SYSTEM_MENU)
|
||||
{
|
||||
PanicAlertT("Could not launch the Wii Menu because it is missing from the NAND.\n"
|
||||
"The emulated software will likely hang now.");
|
||||
PanicAlertFmtT("Could not launch the Wii Menu because it is missing from the NAND.\n"
|
||||
"The emulated software will likely hang now.");
|
||||
}
|
||||
else
|
||||
{
|
||||
PanicAlertT("Could not launch title %016" PRIx64 " because it is missing from the NAND.\n"
|
||||
"The emulated software will likely hang now.",
|
||||
title_id);
|
||||
PanicAlertFmtT("Could not launch title {0:016x} because it is missing from the NAND.\n"
|
||||
"The emulated software will likely hang now.",
|
||||
title_id);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@ -314,14 +318,14 @@ bool ES::LaunchPPCTitle(u64 title_id, bool skip_reload)
|
||||
}
|
||||
|
||||
m_title_context.Update(tmd, ticket, DiscIO::Platform::WiiWAD);
|
||||
INFO_LOG(IOS_ES, "LaunchPPCTitle: Title context changed: %016" PRIx64, tmd.GetTitleId());
|
||||
INFO_LOG_FMT(IOS_ES, "LaunchPPCTitle: Title context changed: {:016x}", tmd.GetTitleId());
|
||||
|
||||
// Note: the UID/GID is also updated for IOS titles, but since we have no guarantee IOS titles
|
||||
// are installed, we can only do this for PPC titles.
|
||||
if (!UpdateUIDAndGID(m_ios, m_title_context.tmd))
|
||||
{
|
||||
m_title_context.Clear();
|
||||
INFO_LOG(IOS_ES, "LaunchPPCTitle: Title context changed: (none)");
|
||||
INFO_LOG_FMT(IOS_ES, "LaunchPPCTitle: Title context changed: (none)");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -395,14 +399,14 @@ IPCCommandResult ES::Close(u32 fd)
|
||||
context->active = false;
|
||||
context->ipc_fd = -1;
|
||||
|
||||
INFO_LOG(IOS_ES, "ES: Close");
|
||||
INFO_LOG_FMT(IOS_ES, "ES: Close");
|
||||
m_is_active = false;
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
IPCCommandResult ES::IOCtlV(const IOCtlVRequest& request)
|
||||
{
|
||||
DEBUG_LOG(IOS_ES, "%s (0x%x)", GetDeviceName().c_str(), request.request);
|
||||
DEBUG_LOG_FMT(IOS_ES, "{} ({:#x})", GetDeviceName(), request.request);
|
||||
auto context = FindActiveContext(request.fd);
|
||||
if (context == m_contexts.end())
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
@ -552,8 +556,8 @@ IPCCommandResult ES::IOCtlV(const IOCtlVRequest& request)
|
||||
|
||||
case IOCTL_ES_UNKNOWN_41:
|
||||
case IOCTL_ES_UNKNOWN_42:
|
||||
PanicAlert("IOS-ES: Unimplemented ioctlv 0x%x (%zu in vectors, %zu io vectors)",
|
||||
request.request, request.in_vectors.size(), request.io_vectors.size());
|
||||
PanicAlertFmt("IOS-ES: Unimplemented ioctlv {:#x} ({} in vectors, {} io vectors)",
|
||||
request.request, request.in_vectors.size(), request.io_vectors.size());
|
||||
request.DumpUnknown(GetDeviceName(), Common::Log::IOS_ES, Common::Log::LERROR);
|
||||
return GetDefaultReply(IPC_EINVAL);
|
||||
|
||||
@ -570,7 +574,7 @@ IPCCommandResult ES::GetConsumption(const IOCtlVRequest& request)
|
||||
|
||||
// This is at least what crediar's ES module does
|
||||
Memory::Write_U32(0, request.io_vectors[1].address);
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_GETCONSUMPTION");
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_GETCONSUMPTION");
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
@ -579,23 +583,23 @@ IPCCommandResult ES::Launch(const IOCtlVRequest& request)
|
||||
if (!request.HasNumberOfValidVectors(2, 0))
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
|
||||
u64 TitleID = Memory::Read_U64(request.in_vectors[0].address);
|
||||
u32 view = Memory::Read_U32(request.in_vectors[1].address);
|
||||
u64 ticketid = Memory::Read_U64(request.in_vectors[1].address + 4);
|
||||
u32 devicetype = Memory::Read_U32(request.in_vectors[1].address + 12);
|
||||
u64 titleid = Memory::Read_U64(request.in_vectors[1].address + 16);
|
||||
u16 access = Memory::Read_U16(request.in_vectors[1].address + 24);
|
||||
const u64 title_id = Memory::Read_U64(request.in_vectors[0].address);
|
||||
const u32 view = Memory::Read_U32(request.in_vectors[1].address);
|
||||
const u64 ticketid = Memory::Read_U64(request.in_vectors[1].address + 4);
|
||||
const u32 devicetype = Memory::Read_U32(request.in_vectors[1].address + 12);
|
||||
const u64 titleid = Memory::Read_U64(request.in_vectors[1].address + 16);
|
||||
const u16 access = Memory::Read_U16(request.in_vectors[1].address + 24);
|
||||
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_LAUNCH %016" PRIx64 " %08x %016" PRIx64 " %08x %016" PRIx64 " %04x",
|
||||
TitleID, view, ticketid, devicetype, titleid, access);
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_LAUNCH {:016x} {:08x} {:016x} {:08x} {:016x} {:04x}", title_id,
|
||||
view, ticketid, devicetype, titleid, access);
|
||||
|
||||
// Prevent loading installed IOSes that are not emulated.
|
||||
if (!IOS::HLE::IsEmulated(TitleID))
|
||||
if (!IOS::HLE::IsEmulated(title_id))
|
||||
return GetDefaultReply(FS_ENOENT);
|
||||
|
||||
// IOS replies to the request through the mailbox on failure, and acks if the launch succeeds.
|
||||
// Note: Launch will potentially reset the whole IOS state -- including this ES instance.
|
||||
if (!LaunchTitle(TitleID))
|
||||
if (!LaunchTitle(title_id))
|
||||
return GetDefaultReply(FS_ENOENT);
|
||||
|
||||
// ES_LAUNCH involves restarting IOS, which results in two acknowledgements in a row
|
||||
@ -655,7 +659,7 @@ static ReturnCode WriteTmdForDiVerify(FS::FileSystem* fs, const IOS::ES::TMDRead
|
||||
ReturnCode ES::DIVerify(const IOS::ES::TMDReader& tmd, const IOS::ES::TicketReader& ticket)
|
||||
{
|
||||
m_title_context.Clear();
|
||||
INFO_LOG(IOS_ES, "ES_DIVerify: Title context changed: (none)");
|
||||
INFO_LOG_FMT(IOS_ES, "ES_DIVerify: Title context changed: (none)");
|
||||
|
||||
if (!tmd.IsValid() || !ticket.IsValid())
|
||||
return ES_EINVAL;
|
||||
@ -664,7 +668,7 @@ ReturnCode ES::DIVerify(const IOS::ES::TMDReader& tmd, const IOS::ES::TicketRead
|
||||
return ES_EINVAL;
|
||||
|
||||
m_title_context.Update(tmd, ticket, DiscIO::Platform::WiiDisc);
|
||||
INFO_LOG(IOS_ES, "ES_DIVerify: Title context changed: %016" PRIx64, tmd.GetTitleId());
|
||||
INFO_LOG_FMT(IOS_ES, "ES_DIVerify: Title context changed: {:016x}", tmd.GetTitleId());
|
||||
|
||||
// XXX: We are supposed to verify the TMD and ticket here, but cannot because
|
||||
// this may cause issues with custom/patched games.
|
||||
@ -674,7 +678,7 @@ ReturnCode ES::DIVerify(const IOS::ES::TMDReader& tmd, const IOS::ES::TicketRead
|
||||
{
|
||||
if (const ReturnCode ret = WriteTmdForDiVerify(fs.get(), tmd))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "DiVerify failed to write disc TMD to NAND.");
|
||||
ERROR_LOG_FMT(IOS_ES, "DiVerify failed to write disc TMD to NAND.");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
@ -932,7 +936,7 @@ ReturnCode ES::VerifyContainer(VerifyContainerType type, VerifyMode mode,
|
||||
ret = iosc.ImportCertificate(ca_cert, IOSC::HANDLE_ROOT_KEY, handle, PID_ES);
|
||||
if (ret != IPC_SUCCESS)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "VerifyContainer: IOSC_ImportCertificate(ca) failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "VerifyContainer: IOSC_ImportCertificate(ca) failed with error {}", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -946,7 +950,8 @@ ReturnCode ES::VerifyContainer(VerifyContainerType type, VerifyMode mode,
|
||||
ret = iosc.ImportCertificate(issuer_cert, handle, issuer_handle, PID_ES);
|
||||
if (ret != IPC_SUCCESS)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "VerifyContainer: IOSC_ImportCertificate(issuer) failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "VerifyContainer: IOSC_ImportCertificate(issuer) failed with error {}",
|
||||
ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -955,7 +960,7 @@ ReturnCode ES::VerifyContainer(VerifyContainerType type, VerifyMode mode,
|
||||
ret = iosc.VerifyPublicKeySign(signed_blob.GetSha1(), issuer_handle, signature, PID_ES);
|
||||
if (ret != IPC_SUCCESS)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "VerifyContainer: IOSC_VerifyPublicKeySign failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "VerifyContainer: IOSC_VerifyPublicKeySign failed with error {}", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -963,11 +968,14 @@ ReturnCode ES::VerifyContainer(VerifyContainerType type, VerifyMode mode,
|
||||
{
|
||||
ret = WriteNewCertToStore(issuer_cert);
|
||||
if (ret != IPC_SUCCESS)
|
||||
ERROR_LOG(IOS_ES, "VerifyContainer: Writing the issuer cert failed with return code %d", ret);
|
||||
{
|
||||
ERROR_LOG_FMT(IOS_ES, "VerifyContainer: Writing the issuer cert failed with return code {}",
|
||||
ret);
|
||||
}
|
||||
|
||||
ret = WriteNewCertToStore(ca_cert);
|
||||
if (ret != IPC_SUCCESS)
|
||||
ERROR_LOG(IOS_ES, "VerifyContainer: Writing the CA cert failed with return code %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "VerifyContainer: Writing the CA cert failed with return code {}", ret);
|
||||
}
|
||||
|
||||
if (ret == IPC_SUCCESS && issuer_handle_out)
|
||||
|
||||
@ -6,7 +6,6 @@
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cinttypes>
|
||||
#include <cstddef>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
@ -430,8 +429,8 @@ std::array<u8, 16> TicketReader::GetTitleKey(const HLE::IOSC& iosc) const
|
||||
u8 index = m_bytes.at(offsetof(Ticket, common_key_index));
|
||||
if (index >= HLE::IOSC::COMMON_KEY_HANDLES.size())
|
||||
{
|
||||
PanicAlert("Bad common key index for title %016" PRIx64 ": %u -- using common key 0",
|
||||
GetTitleId(), index);
|
||||
PanicAlertFmt("Bad common key index for title {:016x}: {} -- using common key 0", GetTitleId(),
|
||||
index);
|
||||
index = 0;
|
||||
}
|
||||
auto common_key_handle = HLE::IOSC::COMMON_KEY_HANDLES[index];
|
||||
@ -654,7 +653,7 @@ u32 UIDSys::GetOrInsertUIDForTitle(const u64 title_id)
|
||||
const u32 current_uid = GetUIDFromTitle(title_id);
|
||||
if (current_uid)
|
||||
{
|
||||
INFO_LOG(IOS_ES, "Title %016" PRIx64 " already exists in uid.sys", title_id);
|
||||
INFO_LOG_FMT(IOS_ES, "Title {:016x} already exists in uid.sys", title_id);
|
||||
return current_uid;
|
||||
}
|
||||
|
||||
@ -671,7 +670,7 @@ u32 UIDSys::GetOrInsertUIDForTitle(const u64 title_id)
|
||||
if (!file || !file->Seek(0, HLE::FS::SeekMode::End) || !file->Write(&swapped_title_id, 1) ||
|
||||
!file->Write(&swapped_uid, 1))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "Failed to write to /sys/uid.sys");
|
||||
ERROR_LOG_FMT(IOS_ES, "Failed to write to /sys/uid.sys");
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -23,7 +23,7 @@ namespace IOS::HLE::Device
|
||||
ReturnCode ES::GetDeviceId(u32* device_id) const
|
||||
{
|
||||
*device_id = m_ios.GetIOSC().GetDeviceId();
|
||||
INFO_LOG(IOS_ES, "GetDeviceId: %08X", *device_id);
|
||||
INFO_LOG_FMT(IOS_ES, "GetDeviceId: {:08X}", *device_id);
|
||||
return IPC_SUCCESS;
|
||||
}
|
||||
|
||||
@ -83,7 +83,7 @@ IPCCommandResult ES::CheckKoreaRegion(const IOCtlVRequest& request)
|
||||
// IOS70 has this to let system menu 4.2 check if the console is region changed. it returns
|
||||
// -1017
|
||||
// if the IOS didn't find the Korean keys and 0 if it does. 0 leads to a error 003
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_CHECKKOREAREGION: Title checked for Korean keys.");
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_CHECKKOREAREGION: Title checked for Korean keys.");
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
}
|
||||
|
||||
@ -92,7 +92,7 @@ IPCCommandResult ES::GetDeviceCertificate(const IOCtlVRequest& request)
|
||||
if (!request.HasNumberOfValidVectors(0, 1) || request.io_vectors[0].size != 0x180)
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_GETDEVICECERT");
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_GETDEVICECERT");
|
||||
|
||||
const IOS::CertECC cert = m_ios.GetIOSC().GetDeviceCertificate();
|
||||
Memory::CopyToEmu(request.io_vectors[0].address, &cert, sizeof(cert));
|
||||
@ -104,7 +104,7 @@ IPCCommandResult ES::Sign(const IOCtlVRequest& request)
|
||||
if (!request.HasNumberOfValidVectors(1, 2))
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_SIGN");
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_SIGN");
|
||||
u8* ap_cert_out = Memory::GetPointer(request.io_vectors[1].address);
|
||||
u8* data = Memory::GetPointer(request.in_vectors[0].address);
|
||||
u32 data_size = request.in_vectors[0].size;
|
||||
@ -148,14 +148,14 @@ ReturnCode ES::VerifySign(const std::vector<u8>& hash, const std::vector<u8>& ec
|
||||
certs_bytes, ng_cert);
|
||||
if (ret != IPC_SUCCESS)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "VerifySign: VerifyContainer(ng) failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "VerifySign: VerifyContainer(ng) failed with error {}", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
ret = iosc.VerifyPublicKeySign(ap.GetSha1(), ng_cert, ap.GetSignatureData(), PID_ES);
|
||||
if (ret != IPC_SUCCESS)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "VerifySign: IOSC_VerifyPublicKeySign(ap) failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "VerifySign: IOSC_VerifyPublicKeySign(ap) failed with error {}", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -168,7 +168,7 @@ ReturnCode ES::VerifySign(const std::vector<u8>& hash, const std::vector<u8>& ec
|
||||
ret = iosc.ImportPublicKey(ap_cert, ap.GetPublicKey().data(), nullptr, PID_ES);
|
||||
if (ret != IPC_SUCCESS)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "VerifySign: IOSC_ImportPublicKey(ap) failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "VerifySign: IOSC_ImportPublicKey(ap) failed with error {}", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -177,7 +177,7 @@ ReturnCode ES::VerifySign(const std::vector<u8>& hash, const std::vector<u8>& ec
|
||||
ret = iosc.VerifyPublicKeySign(sha1, ap_cert, ecc_signature, PID_ES);
|
||||
if (ret != IPC_SUCCESS)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "VerifySign: IOSC_VerifyPublicKeySign(data) failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "VerifySign: IOSC_VerifyPublicKeySign(data) failed with error {}", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@ -5,7 +5,6 @@
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cctype>
|
||||
#include <cinttypes>
|
||||
#include <functional>
|
||||
#include <iterator>
|
||||
#include <string>
|
||||
@ -75,7 +74,7 @@ static std::vector<u64> GetTitlesInTitleOrImport(FS::FileSystem* fs, const std::
|
||||
const auto entries = fs->ReadDirectory(PID_KERNEL, PID_KERNEL, titles_dir);
|
||||
if (!entries)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "%s is not a directory", titles_dir.c_str());
|
||||
ERROR_LOG_FMT(IOS_ES, "{} is not a directory", titles_dir);
|
||||
return {};
|
||||
}
|
||||
|
||||
@ -128,7 +127,7 @@ std::vector<u64> ES::GetTitlesWithTickets() const
|
||||
const auto entries = fs->ReadDirectory(PID_KERNEL, PID_KERNEL, "/ticket");
|
||||
if (!entries)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "/ticket is not a directory");
|
||||
ERROR_LOG_FMT(IOS_ES, "/ticket is not a directory");
|
||||
return {};
|
||||
}
|
||||
|
||||
@ -232,7 +231,7 @@ bool ES::CreateTitleDirectories(u64 title_id, u16 group_id) const
|
||||
fs->SetMetadata(PID_KERNEL, content_dir, PID_KERNEL, PID_KERNEL, 0, content_dir_modes);
|
||||
if (result1 != FS::ResultCode::Success || result2 != FS::ResultCode::Success)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "Failed to create or set metadata on content dir for %016" PRIx64, title_id);
|
||||
ERROR_LOG_FMT(IOS_ES, "Failed to create or set metadata on content dir for {:016x}", title_id);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -242,7 +241,7 @@ bool ES::CreateTitleDirectories(u64 title_id, u16 group_id) const
|
||||
fs->CreateDirectory(PID_KERNEL, PID_KERNEL, data_dir, 0,
|
||||
data_dir_modes) != FS::ResultCode::Success))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "Failed to create data dir for %016" PRIx64, title_id);
|
||||
ERROR_LOG_FMT(IOS_ES, "Failed to create data dir for {:016x}", title_id);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -250,7 +249,7 @@ bool ES::CreateTitleDirectories(u64 title_id, u16 group_id) const
|
||||
const u32 uid = uid_sys.GetOrInsertUIDForTitle(title_id);
|
||||
if (fs->SetMetadata(0, data_dir, uid, group_id, 0, data_dir_modes) != FS::ResultCode::Success)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "Failed to set metadata on data dir for %016" PRIx64, title_id);
|
||||
ERROR_LOG_FMT(IOS_ES, "Failed to set metadata on data dir for {:016x}", title_id);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -268,7 +267,7 @@ bool ES::InitImport(const IOS::ES::TMDReader& tmd)
|
||||
fs->CreateFullPath(PID_KERNEL, PID_KERNEL, import_content_dir + '/', 0, content_dir_modes);
|
||||
if (result != FS::ResultCode::Success)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "InitImport: Failed to create content dir for %016" PRIx64, tmd.GetTitleId());
|
||||
ERROR_LOG_FMT(IOS_ES, "InitImport: Failed to create content dir for {:016x}", tmd.GetTitleId());
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -282,7 +281,7 @@ bool ES::InitImport(const IOS::ES::TMDReader& tmd)
|
||||
const auto rename_result = fs->Rename(PID_KERNEL, PID_KERNEL, content_dir, import_content_dir);
|
||||
if (rename_result != FS::ResultCode::Success)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "InitImport: Failed to move content dir for %016" PRIx64, tmd.GetTitleId());
|
||||
ERROR_LOG_FMT(IOS_ES, "InitImport: Failed to move content dir for {:016x}", tmd.GetTitleId());
|
||||
return false;
|
||||
}
|
||||
DeleteDirectoriesIfEmpty(m_ios.GetFS().get(), import_content_dir);
|
||||
@ -316,7 +315,7 @@ bool ES::FinishImport(const IOS::ES::TMDReader& tmd)
|
||||
if (fs->Rename(PID_KERNEL, PID_KERNEL, import_content_dir, content_dir) !=
|
||||
FS::ResultCode::Success)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "FinishImport: Failed to rename import directory to %s", content_dir.c_str());
|
||||
ERROR_LOG_FMT(IOS_ES, "FinishImport: Failed to rename import directory to {}", content_dir);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include "Core/IOS/ES/ES.h"
|
||||
|
||||
#include <cinttypes>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
@ -40,7 +39,7 @@ s32 ES::OpenContent(const IOS::ES::TMDReader& tmd, u16 content_index, u32 uid)
|
||||
entry.m_content = content;
|
||||
entry.m_title_id = title_id;
|
||||
entry.m_uid = uid;
|
||||
INFO_LOG(IOS_ES, "OpenContent: title ID %016" PRIx64 ", UID 0x%x, CFD %zu", title_id, uid, i);
|
||||
INFO_LOG_FMT(IOS_ES, "OpenContent: title ID {:016x}, UID {:#x}, CFD {}", title_id, uid, i);
|
||||
return static_cast<s32>(i);
|
||||
}
|
||||
|
||||
@ -125,7 +124,7 @@ ReturnCode ES::CloseContent(u32 cfd, u32 uid)
|
||||
|
||||
m_ios.GetFS()->Close(entry.m_fd);
|
||||
entry = {};
|
||||
INFO_LOG(IOS_ES, "CloseContent: CFD %u", cfd);
|
||||
INFO_LOG_FMT(IOS_ES, "CloseContent: CFD {}", cfd);
|
||||
return IPC_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
@ -4,7 +4,6 @@
|
||||
|
||||
#include "Core/IOS/ES/ES.h"
|
||||
|
||||
#include <cinttypes>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
@ -26,8 +25,8 @@ IPCCommandResult ES::GetStoredContentsCount(const IOS::ES::TMDReader& tmd,
|
||||
const u16 num_contents = static_cast<u16>(GetStoredContentsFromTMD(tmd).size());
|
||||
Memory::Write_U32(num_contents, request.io_vectors[0].address);
|
||||
|
||||
INFO_LOG(IOS_ES, "GetStoredContentsCount (0x%x): %u content(s) for %016" PRIx64, request.request,
|
||||
num_contents, tmd.GetTitleId());
|
||||
INFO_LOG_FMT(IOS_ES, "GetStoredContentsCount ({:#x}): {} content(s) for {:016x}",
|
||||
request.request, num_contents, tmd.GetTitleId());
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
@ -129,7 +128,7 @@ IPCCommandResult ES::GetTitles(const std::vector<u64>& titles, const IOCtlVReque
|
||||
for (size_t i = 0; i < std::min(max_count, titles.size()); i++)
|
||||
{
|
||||
Memory::Write_U64(titles[i], request.io_vectors[0].address + static_cast<u32>(i) * sizeof(u64));
|
||||
INFO_LOG(IOS_ES, " title %016" PRIx64, titles[i]);
|
||||
INFO_LOG_FMT(IOS_ES, " title {:016x}", titles[i]);
|
||||
}
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
@ -137,7 +136,7 @@ IPCCommandResult ES::GetTitles(const std::vector<u64>& titles, const IOCtlVReque
|
||||
IPCCommandResult ES::GetTitleCount(const IOCtlVRequest& request)
|
||||
{
|
||||
const std::vector<u64> titles = GetInstalledTitles();
|
||||
INFO_LOG(IOS_ES, "GetTitleCount: %zu titles", titles.size());
|
||||
INFO_LOG_FMT(IOS_ES, "GetTitleCount: {} titles", titles.size());
|
||||
return GetTitleCount(titles, request);
|
||||
}
|
||||
|
||||
@ -159,7 +158,7 @@ IPCCommandResult ES::GetStoredTMDSize(const IOCtlVRequest& request)
|
||||
const u32 tmd_size = static_cast<u32>(tmd.GetBytes().size());
|
||||
Memory::Write_U32(tmd_size, request.io_vectors[0].address);
|
||||
|
||||
INFO_LOG(IOS_ES, "GetStoredTMDSize: %u bytes for %016" PRIx64, tmd_size, title_id);
|
||||
INFO_LOG_FMT(IOS_ES, "GetStoredTMDSize: {} bytes for {:016x}", tmd_size, title_id);
|
||||
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
@ -183,14 +182,14 @@ IPCCommandResult ES::GetStoredTMD(const IOCtlVRequest& request)
|
||||
|
||||
Memory::CopyToEmu(request.io_vectors[0].address, raw_tmd.data(), raw_tmd.size());
|
||||
|
||||
INFO_LOG(IOS_ES, "GetStoredTMD: title %016" PRIx64 " (buffer size: %u)", title_id, MaxCount);
|
||||
INFO_LOG_FMT(IOS_ES, "GetStoredTMD: title {:016x} (buffer size: {})", title_id, MaxCount);
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
IPCCommandResult ES::GetOwnedTitleCount(const IOCtlVRequest& request)
|
||||
{
|
||||
const std::vector<u64> titles = GetTitlesWithTickets();
|
||||
INFO_LOG(IOS_ES, "GetOwnedTitleCount: %zu titles", titles.size());
|
||||
INFO_LOG_FMT(IOS_ES, "GetOwnedTitleCount: {} titles", titles.size());
|
||||
return GetTitleCount(titles, request);
|
||||
}
|
||||
|
||||
@ -204,7 +203,7 @@ IPCCommandResult ES::GetBoot2Version(const IOCtlVRequest& request)
|
||||
if (!request.HasNumberOfValidVectors(0, 1))
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_GETBOOT2VERSION");
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_GETBOOT2VERSION");
|
||||
|
||||
// as of 26/02/2012, this was latest bootmii version
|
||||
Memory::Write_U32(4, request.io_vectors[0].address);
|
||||
@ -219,7 +218,7 @@ IPCCommandResult ES::GetSharedContentsCount(const IOCtlVRequest& request) const
|
||||
const u32 count = GetSharedContentsCount();
|
||||
Memory::Write_U32(count, request.io_vectors[0].address);
|
||||
|
||||
INFO_LOG(IOS_ES, "GetSharedContentsCount: %u contents", count);
|
||||
INFO_LOG_FMT(IOS_ES, "GetSharedContentsCount: {} contents", count);
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
@ -236,7 +235,7 @@ IPCCommandResult ES::GetSharedContents(const IOCtlVRequest& request) const
|
||||
const u32 count = std::min(static_cast<u32>(hashes.size()), max_count);
|
||||
Memory::CopyToEmu(request.io_vectors[0].address, hashes.data(), 20 * count);
|
||||
|
||||
INFO_LOG(IOS_ES, "GetSharedContents: %u contents (%u requested)", count, max_count);
|
||||
INFO_LOG_FMT(IOS_ES, "GetSharedContents: {} contents ({} requested)", count, max_count);
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
} // namespace IOS::HLE::Device
|
||||
|
||||
@ -63,14 +63,15 @@ ReturnCode ES::ImportTicket(const std::vector<u8>& ticket_bytes, const std::vect
|
||||
{
|
||||
if (device_id != ticket_device_id)
|
||||
{
|
||||
WARN_LOG(IOS_ES, "Device ID mismatch: ticket %08x, device %08x", ticket_device_id, device_id);
|
||||
WARN_LOG_FMT(IOS_ES, "Device ID mismatch: ticket {:08x}, device {:08x}", ticket_device_id,
|
||||
device_id);
|
||||
return ES_DEVICE_ID_MISMATCH;
|
||||
}
|
||||
const ReturnCode ret = ticket.Unpersonalise(m_ios.GetIOSC());
|
||||
if (ret < 0)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportTicket: Failed to unpersonalise ticket for %016" PRIx64 " (%d)",
|
||||
ticket.GetTitleId(), ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportTicket: Failed to unpersonalise ticket for {:016x} ({})",
|
||||
ticket.GetTitleId(), ret);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
@ -87,7 +88,7 @@ ReturnCode ES::ImportTicket(const std::vector<u8>& ticket_bytes, const std::vect
|
||||
if (write_ret != IPC_SUCCESS)
|
||||
return write_ret;
|
||||
|
||||
INFO_LOG(IOS_ES, "ImportTicket: Imported ticket for title %016" PRIx64, ticket.GetTitleId());
|
||||
INFO_LOG_FMT(IOS_ES, "ImportTicket: Imported ticket for title {:016x}", ticket.GetTitleId());
|
||||
return IPC_SUCCESS;
|
||||
}
|
||||
|
||||
@ -137,7 +138,7 @@ static void ResetTitleImportContext(ES::Context* context, IOSC& iosc)
|
||||
|
||||
ReturnCode ES::ImportTmd(Context& context, const std::vector<u8>& tmd_bytes)
|
||||
{
|
||||
INFO_LOG(IOS_ES, "ImportTmd");
|
||||
INFO_LOG_FMT(IOS_ES, "ImportTmd");
|
||||
|
||||
// Ioctlv 0x2b writes the TMD to /tmp/title.tmd (for imports) and doesn't seem to write it
|
||||
// to either /import or /title. So here we simply have to set the import TMD.
|
||||
@ -155,13 +156,13 @@ ReturnCode ES::ImportTmd(Context& context, const std::vector<u8>& tmd_bytes)
|
||||
context.title_import_export.tmd, cert_store);
|
||||
if (ret != IPC_SUCCESS)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportTmd: VerifyContainer failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportTmd: VerifyContainer failed with error {}", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (!InitImport(context.title_import_export.tmd))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportTmd: Failed to initialise title import");
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportTmd: Failed to initialise title import");
|
||||
return ES_EIO;
|
||||
}
|
||||
|
||||
@ -169,11 +170,11 @@ ReturnCode ES::ImportTmd(Context& context, const std::vector<u8>& tmd_bytes)
|
||||
InitBackupKey(m_title_context.tmd, m_ios.GetIOSC(), &context.title_import_export.key_handle);
|
||||
if (ret != IPC_SUCCESS)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportTmd: InitBackupKey failed with error %d", ret);
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportTmd: InitBackupKey failed with error {}", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
INFO_LOG(IOS_ES, "ImportTmd: All checks passed, marking context as valid");
|
||||
INFO_LOG_FMT(IOS_ES, "ImportTmd: All checks passed, marking context as valid");
|
||||
context.title_import_export.valid = true;
|
||||
return IPC_SUCCESS;
|
||||
}
|
||||
@ -211,12 +212,12 @@ static ReturnCode InitTitleImportKey(const std::vector<u8>& ticket_bytes, IOSC&
|
||||
ReturnCode ES::ImportTitleInit(Context& context, const std::vector<u8>& tmd_bytes,
|
||||
const std::vector<u8>& cert_chain, VerifySignature verify_signature)
|
||||
{
|
||||
INFO_LOG(IOS_ES, "ImportTitleInit");
|
||||
INFO_LOG_FMT(IOS_ES, "ImportTitleInit");
|
||||
ResetTitleImportContext(&context, m_ios.GetIOSC());
|
||||
context.title_import_export.tmd.SetBytes(tmd_bytes);
|
||||
if (!context.title_import_export.tmd.IsValid())
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "Invalid TMD while adding title (size = %zd)", tmd_bytes.size());
|
||||
ERROR_LOG_FMT(IOS_ES, "Invalid TMD while adding title (size = {})", tmd_bytes.size());
|
||||
return ES_EINVAL;
|
||||
}
|
||||
|
||||
@ -281,25 +282,23 @@ ReturnCode ES::ImportContentBegin(Context& context, u64 title_id, u32 content_id
|
||||
{
|
||||
if (context.title_import_export.content.valid)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "Trying to add content when we haven't finished adding "
|
||||
"another content. Unsupported.");
|
||||
ERROR_LOG_FMT(IOS_ES, "Trying to add content when we haven't finished adding "
|
||||
"another content. Unsupported.");
|
||||
return ES_EINVAL;
|
||||
}
|
||||
context.title_import_export.content = {};
|
||||
context.title_import_export.content.id = content_id;
|
||||
|
||||
INFO_LOG(IOS_ES, "ImportContentBegin: title %016" PRIx64 ", content ID %08x", title_id,
|
||||
context.title_import_export.content.id);
|
||||
INFO_LOG_FMT(IOS_ES, "ImportContentBegin: title {:016x}, content ID {:08x}", title_id,
|
||||
context.title_import_export.content.id);
|
||||
|
||||
if (!context.title_import_export.valid)
|
||||
return ES_EINVAL;
|
||||
|
||||
if (title_id != context.title_import_export.tmd.GetTitleId())
|
||||
{
|
||||
ERROR_LOG(IOS_ES,
|
||||
"ImportContentBegin: title id %016" PRIx64 " != "
|
||||
"TMD title id %016" PRIx64 ", ignoring",
|
||||
title_id, context.title_import_export.tmd.GetTitleId());
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportContentBegin: title id {:016x} != TMD title id {:016x}, ignoring",
|
||||
title_id, context.title_import_export.tmd.GetTitleId());
|
||||
return ES_EINVAL;
|
||||
}
|
||||
|
||||
@ -334,7 +333,7 @@ IPCCommandResult ES::ImportContentBegin(Context& context, const IOCtlVRequest& r
|
||||
|
||||
ReturnCode ES::ImportContentData(Context& context, u32 content_fd, const u8* data, u32 data_size)
|
||||
{
|
||||
INFO_LOG(IOS_ES, "ImportContentData: content fd %08x, size %d", content_fd, data_size);
|
||||
INFO_LOG_FMT(IOS_ES, "ImportContentData: content fd {:08x}, size {}", content_fd, data_size);
|
||||
context.title_import_export.content.buffer.insert(
|
||||
context.title_import_export.content.buffer.end(), data, data + data_size);
|
||||
return IPC_SUCCESS;
|
||||
@ -365,7 +364,7 @@ static std::string GetImportContentPath(u64 title_id, u32 content_id)
|
||||
|
||||
ReturnCode ES::ImportContentEnd(Context& context, u32 content_fd)
|
||||
{
|
||||
INFO_LOG(IOS_ES, "ImportContentEnd: content fd %08x", content_fd);
|
||||
INFO_LOG_FMT(IOS_ES, "ImportContentEnd: content fd {:08x}", content_fd);
|
||||
|
||||
if (!context.title_import_export.valid || !context.title_import_export.content.valid)
|
||||
return ES_EINVAL;
|
||||
@ -383,7 +382,8 @@ ReturnCode ES::ImportContentEnd(Context& context, u32 content_fd)
|
||||
&content_info);
|
||||
if (!CheckIfContentHashMatches(decrypted_data, content_info))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportContentEnd: Hash for content %08x doesn't match", content_info.id);
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportContentEnd: Hash for content {:08x} doesn't match",
|
||||
content_info.id);
|
||||
return ES_HASH_MISMATCH;
|
||||
}
|
||||
|
||||
@ -408,7 +408,7 @@ ReturnCode ES::ImportContentEnd(Context& context, u32 content_fd)
|
||||
const auto file = fs->CreateAndOpenFile(PID_KERNEL, PID_KERNEL, temp_path, content_modes);
|
||||
if (!file || !file->Write(decrypted_data.data(), content_info.size))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportContentEnd: Failed to write to %s", temp_path.c_str());
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportContentEnd: Failed to write to {}", temp_path);
|
||||
return ES_EIO;
|
||||
}
|
||||
}
|
||||
@ -417,7 +417,7 @@ ReturnCode ES::ImportContentEnd(Context& context, u32 content_fd)
|
||||
if (rename_result != FS::ResultCode::Success)
|
||||
{
|
||||
fs->Delete(PID_KERNEL, PID_KERNEL, temp_path);
|
||||
ERROR_LOG(IOS_ES, "ImportContentEnd: Failed to move content to %s", content_path.c_str());
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportContentEnd: Failed to move content to {}", content_path);
|
||||
return FS::ConvertResult(rename_result);
|
||||
}
|
||||
|
||||
@ -457,7 +457,8 @@ ReturnCode ES::ImportTitleDone(Context& context)
|
||||
{
|
||||
if (!context.title_import_export.valid || context.title_import_export.content.valid)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportTitleDone: No title import, or a content import is still in progress");
|
||||
ERROR_LOG_FMT(IOS_ES,
|
||||
"ImportTitleDone: No title import, or a content import is still in progress");
|
||||
return ES_EINVAL;
|
||||
}
|
||||
|
||||
@ -466,23 +467,23 @@ ReturnCode ES::ImportTitleDone(Context& context)
|
||||
if (title_id - 0x100000001LL <= 0x100 &&
|
||||
!HasAllRequiredContents(m_ios, context.title_import_export.tmd))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportTitleDone: Some required contents are missing");
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportTitleDone: Some required contents are missing");
|
||||
return ES_EINVAL;
|
||||
}
|
||||
|
||||
if (!WriteImportTMD(context.title_import_export.tmd))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportTitleDone: Failed to write import TMD");
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportTitleDone: Failed to write import TMD");
|
||||
return ES_EIO;
|
||||
}
|
||||
|
||||
if (!FinishImport(context.title_import_export.tmd))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "ImportTitleDone: Failed to finalise title import");
|
||||
ERROR_LOG_FMT(IOS_ES, "ImportTitleDone: Failed to finalise title import");
|
||||
return ES_EIO;
|
||||
}
|
||||
|
||||
INFO_LOG(IOS_ES, "ImportTitleDone: title %016" PRIx64, title_id);
|
||||
INFO_LOG_FMT(IOS_ES, "ImportTitleDone: title {:016x}", title_id);
|
||||
ResetTitleImportContext(&context, m_ios.GetIOSC());
|
||||
return IPC_SUCCESS;
|
||||
}
|
||||
@ -506,7 +507,7 @@ ReturnCode ES::ImportTitleCancel(Context& context)
|
||||
{
|
||||
const u64 title_id = context.title_import_export.tmd.GetTitleId();
|
||||
FinishStaleImport(title_id);
|
||||
INFO_LOG(IOS_ES, "ImportTitleCancel: title %016" PRIx64, title_id);
|
||||
INFO_LOG_FMT(IOS_ES, "ImportTitleCancel: title {:016x}", title_id);
|
||||
}
|
||||
|
||||
ResetTitleImportContext(&context, m_ios.GetIOSC());
|
||||
@ -696,7 +697,7 @@ ReturnCode ES::ExportContentBegin(Context& context, u64 title_id, u32 content_id
|
||||
if (!context.title_import_export.valid ||
|
||||
context.title_import_export.tmd.GetTitleId() != title_id)
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "Tried to use ExportContentBegin with an invalid title export context.");
|
||||
ERROR_LOG_FMT(IOS_ES, "Tried to use ExportContentBegin with an invalid title export context.");
|
||||
return ES_EINVAL;
|
||||
}
|
||||
|
||||
|
||||
@ -5,7 +5,6 @@
|
||||
#include "Core/IOS/ES/ES.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cinttypes>
|
||||
#include <cstddef>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
@ -43,7 +42,7 @@ IPCCommandResult ES::GetTicketViewCount(const IOCtlVRequest& request)
|
||||
if (!request.HasNumberOfValidVectors(1, 1))
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
|
||||
u64 TitleID = Memory::Read_U64(request.in_vectors[0].address);
|
||||
const u64 TitleID = Memory::Read_U64(request.in_vectors[0].address);
|
||||
|
||||
const IOS::ES::TicketReader ticket = FindSignedTicket(TitleID);
|
||||
u32 view_count = ticket.IsValid() ? static_cast<u32>(ticket.GetNumberOfTickets()) : 0;
|
||||
@ -51,16 +50,16 @@ IPCCommandResult ES::GetTicketViewCount(const IOCtlVRequest& request)
|
||||
if (!IOS::HLE::IsEmulated(TitleID))
|
||||
{
|
||||
view_count = 0;
|
||||
ERROR_LOG(IOS_ES, "GetViewCount: Dolphin doesn't emulate IOS title %016" PRIx64, TitleID);
|
||||
ERROR_LOG_FMT(IOS_ES, "GetViewCount: Dolphin doesn't emulate IOS title {:016x}", TitleID);
|
||||
}
|
||||
else if (ShouldReturnFakeViewsForIOSes(TitleID, m_title_context))
|
||||
{
|
||||
view_count = 1;
|
||||
WARN_LOG(IOS_ES, "GetViewCount: Faking IOS title %016" PRIx64 " being present", TitleID);
|
||||
WARN_LOG_FMT(IOS_ES, "GetViewCount: Faking IOS title {:016x} being present", TitleID);
|
||||
}
|
||||
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_GETVIEWCNT for titleID: %016" PRIx64 " (View Count = %u)", TitleID,
|
||||
view_count);
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_GETVIEWCNT for titleID: {:016x} (View Count = {})", TitleID,
|
||||
view_count);
|
||||
|
||||
Memory::Write_U32(view_count, request.io_vectors[0].address);
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
@ -71,14 +70,14 @@ IPCCommandResult ES::GetTicketViews(const IOCtlVRequest& request)
|
||||
if (!request.HasNumberOfValidVectors(2, 1))
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
|
||||
u64 TitleID = Memory::Read_U64(request.in_vectors[0].address);
|
||||
u32 maxViews = Memory::Read_U32(request.in_vectors[1].address);
|
||||
const u64 TitleID = Memory::Read_U64(request.in_vectors[0].address);
|
||||
const u32 maxViews = Memory::Read_U32(request.in_vectors[1].address);
|
||||
|
||||
const IOS::ES::TicketReader ticket = FindSignedTicket(TitleID);
|
||||
|
||||
if (!IOS::HLE::IsEmulated(TitleID))
|
||||
{
|
||||
ERROR_LOG(IOS_ES, "GetViews: Dolphin doesn't emulate IOS title %016" PRIx64, TitleID);
|
||||
ERROR_LOG_FMT(IOS_ES, "GetViews: Dolphin doesn't emulate IOS title {:016x}", TitleID);
|
||||
}
|
||||
else if (ticket.IsValid())
|
||||
{
|
||||
@ -93,11 +92,10 @@ IPCCommandResult ES::GetTicketViews(const IOCtlVRequest& request)
|
||||
else if (ShouldReturnFakeViewsForIOSes(TitleID, m_title_context))
|
||||
{
|
||||
Memory::Memset(request.io_vectors[0].address, 0, sizeof(IOS::ES::TicketView));
|
||||
WARN_LOG(IOS_ES, "GetViews: Faking IOS title %016" PRIx64 " being present", TitleID);
|
||||
WARN_LOG_FMT(IOS_ES, "GetViews: Faking IOS title {:016x} being present", TitleID);
|
||||
}
|
||||
|
||||
INFO_LOG(IOS_ES, "IOCTL_ES_GETVIEWS for titleID: %016" PRIx64 " (MaxViews = %i)", TitleID,
|
||||
maxViews);
|
||||
INFO_LOG_FMT(IOS_ES, "IOCTL_ES_GETVIEWS for titleID: {:016x} (MaxViews = {})", TitleID, maxViews);
|
||||
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
@ -147,7 +145,7 @@ ReturnCode ES::GetTicketFromView(const u8* ticket_view, u8* ticket, u32* ticket_
|
||||
// Currently, we have no support for v1 tickets at all (unlike IOS), so we fake it
|
||||
// and return that there is no ticket.
|
||||
// TODO: implement GetV1TicketFromView when we gain v1 ticket support.
|
||||
ERROR_LOG(IOS_ES, "GetV1TicketFromView: Unimplemented -- returning -1028");
|
||||
ERROR_LOG_FMT(IOS_ES, "GetV1TicketFromView: Unimplemented -- returning -1028");
|
||||
return ES_NO_TICKET;
|
||||
}
|
||||
if (ticket != nullptr)
|
||||
@ -210,8 +208,7 @@ IPCCommandResult ES::GetTMDViewSize(const IOCtlVRequest& request)
|
||||
if (!request.HasNumberOfValidVectors(1, 1))
|
||||
return GetDefaultReply(ES_EINVAL);
|
||||
|
||||
u64 TitleID = Memory::Read_U64(request.in_vectors[0].address);
|
||||
|
||||
const u64 TitleID = Memory::Read_U64(request.in_vectors[0].address);
|
||||
const IOS::ES::TMDReader tmd = FindInstalledTMD(TitleID);
|
||||
|
||||
if (!tmd.IsValid())
|
||||
@ -220,7 +217,7 @@ IPCCommandResult ES::GetTMDViewSize(const IOCtlVRequest& request)
|
||||
const u32 view_size = static_cast<u32>(tmd.GetRawView().size());
|
||||
Memory::Write_U32(view_size, request.io_vectors[0].address);
|
||||
|
||||
INFO_LOG(IOS_ES, "GetTMDViewSize: %u bytes for title %016" PRIx64, view_size, TitleID);
|
||||
INFO_LOG_FMT(IOS_ES, "GetTMDViewSize: {} bytes for title {:016x}", view_size, TitleID);
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
@ -246,7 +243,7 @@ IPCCommandResult ES::GetTMDViews(const IOCtlVRequest& request)
|
||||
|
||||
Memory::CopyToEmu(request.io_vectors[0].address, raw_view.data(), raw_view.size());
|
||||
|
||||
INFO_LOG(IOS_ES, "GetTMDView: %zu bytes for title %016" PRIx64, raw_view.size(), title_id);
|
||||
INFO_LOG_FMT(IOS_ES, "GetTMDView: {} bytes for title {:016x}", raw_view.size(), title_id);
|
||||
return GetDefaultReply(IPC_SUCCESS);
|
||||
}
|
||||
|
||||
|
||||
@ -105,7 +105,7 @@ static bool SetupMemory(u64 ios_title_id, MemorySetupType setup_type)
|
||||
|
||||
if (target_imv == GetMemoryValues().end())
|
||||
{
|
||||
ERROR_LOG(IOS, "Unknown IOS version: %016" PRIx64, ios_title_id);
|
||||
ERROR_LOG_FMT(IOS, "Unknown IOS version: {:016x}", ios_title_id);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -249,10 +249,10 @@ Kernel::Kernel(u64 title_id) : m_title_id(title_id)
|
||||
|
||||
EmulationKernel::EmulationKernel(u64 title_id) : Kernel(title_id)
|
||||
{
|
||||
INFO_LOG(IOS, "Starting IOS %016" PRIx64, title_id);
|
||||
INFO_LOG_FMT(IOS, "Starting IOS {:016x}", title_id);
|
||||
|
||||
if (!SetupMemory(title_id, MemorySetupType::IOSReload))
|
||||
WARN_LOG(IOS, "No information about this IOS -- cannot set up memory values");
|
||||
WARN_LOG_FMT(IOS, "No information about this IOS -- cannot set up memory values");
|
||||
|
||||
if (title_id == Titles::MIOS)
|
||||
{
|
||||
@ -521,10 +521,10 @@ std::shared_ptr<Device::Device> EmulationKernel::GetDeviceByName(const std::stri
|
||||
IPCCommandResult Kernel::OpenDevice(OpenRequest& request)
|
||||
{
|
||||
const s32 new_fd = GetFreeDeviceID();
|
||||
INFO_LOG(IOS, "Opening %s (mode %d, fd %d)", request.path.c_str(), request.flags, new_fd);
|
||||
INFO_LOG_FMT(IOS, "Opening {} (mode {}, fd {})", request.path, request.flags, new_fd);
|
||||
if (new_fd < 0 || new_fd >= IPC_MAX_FDS)
|
||||
{
|
||||
ERROR_LOG(IOS, "Couldn't get a free fd, too many open files");
|
||||
ERROR_LOG_FMT(IOS, "Couldn't get a free fd, too many open files");
|
||||
return IPCCommandResult{IPC_EMAX, true, 5000 * SystemTimers::TIMER_RATIO};
|
||||
}
|
||||
request.fd = new_fd;
|
||||
@ -546,7 +546,7 @@ IPCCommandResult Kernel::OpenDevice(OpenRequest& request)
|
||||
|
||||
if (!device)
|
||||
{
|
||||
ERROR_LOG(IOS, "Unknown device: %s", request.path.c_str());
|
||||
ERROR_LOG_FMT(IOS, "Unknown device: {}", request.path);
|
||||
return {IPC_ENOENT, true, 3700 * SystemTimers::TIMER_RATIO};
|
||||
}
|
||||
|
||||
@ -575,7 +575,7 @@ IPCCommandResult Kernel::HandleIPCCommand(const Request& request)
|
||||
return IPCCommandResult{IPC_EINVAL, true, 550 * SystemTimers::TIMER_RATIO};
|
||||
|
||||
IPCCommandResult ret;
|
||||
u64 wall_time_before = Common::Timer::GetTimeUs();
|
||||
const u64 wall_time_before = Common::Timer::GetTimeUs();
|
||||
|
||||
switch (request.command)
|
||||
{
|
||||
@ -604,12 +604,12 @@ IPCCommandResult Kernel::HandleIPCCommand(const Request& request)
|
||||
break;
|
||||
}
|
||||
|
||||
u64 wall_time_after = Common::Timer::GetTimeUs();
|
||||
const u64 wall_time_after = Common::Timer::GetTimeUs();
|
||||
constexpr u64 BLOCKING_IPC_COMMAND_THRESHOLD_US = 2000;
|
||||
if (wall_time_after - wall_time_before > BLOCKING_IPC_COMMAND_THRESHOLD_US)
|
||||
{
|
||||
WARN_LOG(IOS, "Previous request to device %s blocked emulation for %" PRIu64 " microseconds.",
|
||||
device->GetDeviceName().c_str(), wall_time_after - wall_time_before);
|
||||
WARN_LOG_FMT(IOS, "Previous request to device {} blocked emulation for {} microseconds.",
|
||||
device->GetDeviceName(), wall_time_after - wall_time_before);
|
||||
}
|
||||
|
||||
return ret;
|
||||
@ -690,7 +690,7 @@ void Kernel::UpdateIPC()
|
||||
if (!m_reply_queue.empty())
|
||||
{
|
||||
GenerateReply(m_reply_queue.front());
|
||||
DEBUG_LOG(IOS, "<<-- Reply to IPC Request @ 0x%08x", m_reply_queue.front());
|
||||
DEBUG_LOG_FMT(IOS, "<<-- Reply to IPC Request @ {:#010x}", m_reply_queue.front());
|
||||
m_reply_queue.pop_front();
|
||||
return;
|
||||
}
|
||||
@ -698,7 +698,7 @@ void Kernel::UpdateIPC()
|
||||
if (!m_ack_queue.empty())
|
||||
{
|
||||
GenerateAck(m_ack_queue.front());
|
||||
WARN_LOG(IOS, "<<-- Double-ack to IPC Request @ 0x%08x", m_ack_queue.front());
|
||||
WARN_LOG_FMT(IOS, "<<-- Double-ack to IPC Request @ {:#010x}", m_ack_queue.front());
|
||||
m_ack_queue.pop_front();
|
||||
return;
|
||||
}
|
||||
|
||||
@ -328,7 +328,7 @@ ReturnCode IOSC::VerifyPublicKeySign(const std::array<u8, 20>& sha1, Handle sign
|
||||
MBEDTLS_MD_SHA1, 0, sha1.data(), signature.data());
|
||||
if (ret != 0)
|
||||
{
|
||||
WARN_LOG(IOS, "VerifyPublicKeySign: RSA verification failed (error %d)", ret);
|
||||
WARN_LOG_FMT(IOS, "VerifyPublicKeySign: RSA verification failed (error {})", ret);
|
||||
return IOSC_FAIL_CHECKVALUE;
|
||||
}
|
||||
|
||||
@ -561,14 +561,14 @@ void IOSC::LoadEntries()
|
||||
File::IOFile file{File::GetUserPath(D_WIIROOT_IDX) + "/keys.bin", "rb"};
|
||||
if (!file)
|
||||
{
|
||||
WARN_LOG(IOS, "keys.bin could not be found. Default values will be used.");
|
||||
WARN_LOG_FMT(IOS, "keys.bin could not be found. Default values will be used.");
|
||||
return;
|
||||
}
|
||||
|
||||
BootMiiKeyDump dump;
|
||||
if (!file.ReadBytes(&dump, sizeof(dump)))
|
||||
{
|
||||
ERROR_LOG(IOS, "Failed to read from keys.bin.");
|
||||
ERROR_LOG_FMT(IOS, "Failed to read from keys.bin.");
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
@ -55,7 +55,7 @@ bool Load()
|
||||
Memory::Write_U32(0x09142001, 0x3180);
|
||||
|
||||
ReinitHardware();
|
||||
NOTICE_LOG(IOS, "Reinitialised hardware.");
|
||||
NOTICE_LOG_FMT(IOS, "Reinitialised hardware.");
|
||||
|
||||
// Load symbols for the IPL if they exist.
|
||||
if (!g_symbolDB.IsEmpty())
|
||||
@ -74,7 +74,7 @@ bool Load()
|
||||
PowerPC::SetMode(PowerPC::CoreMode::Interpreter);
|
||||
MSR.Hex = 0;
|
||||
PC = 0x3400;
|
||||
NOTICE_LOG(IOS, "Loaded MIOS and bootstrapped PPC.");
|
||||
NOTICE_LOG_FMT(IOS, "Loaded MIOS and bootstrapped PPC.");
|
||||
|
||||
// IOS writes 0 to 0x30f8 before bootstrapping the PPC. Once started, the IPL eventually writes
|
||||
// 0xdeadbeef there, then waits for it to be cleared by IOS before continuing.
|
||||
@ -83,7 +83,7 @@ bool Load()
|
||||
PowerPC::SetMode(core_mode);
|
||||
|
||||
Memory::Write_U32(0x00000000, ADDRESS_INIT_SEMAPHORE);
|
||||
NOTICE_LOG(IOS, "IPL ready.");
|
||||
NOTICE_LOG_FMT(IOS, "IPL ready.");
|
||||
SConfig::GetInstance().m_is_mios = true;
|
||||
DVDInterface::UpdateRunningGameMetadata();
|
||||
return true;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user