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

Merge pull request #4245 from aldelaro5/logs-levels-changes 

Lots of Logs levels changes (also enable INFO level in every build)
This commit is contained in:
Mat M 2016-10-02 16:51:44 -04:00 committed by GitHub
parent 2e4ef57b47 f0aa9b3751
commit ccfc081697
57 changed files with 321 additions and 321 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/AudioCommon/OpenALStream.cpp
View File

@ -33,7 +33,7 @@ bool OpenALStream::Start()
{
char* defDevName = pDeviceList.GetDeviceName(pDeviceList.GetDefaultDevice());
WARN_LOG(AUDIO, "Found OpenAL device %s", defDevName);
INFO_LOG(AUDIO, "Found OpenAL device %s", defDevName);
ALCdevice* pDevice = alcOpenDevice(defDevName);
if (pDevice)

6
Source/Core/Common/BreakPoints.cpp
View File

@ -214,9 +214,9 @@ bool TMemCheck::Action(DebugInterface* debug_interface, u32 iValue, u32 addr, bo
{
if (Log)
{
INFO_LOG(MEMMAP, "CHK %08x (%s) %s%i %0*x at %08x (%s)", pc,
debug_interface->GetDescription(pc).c_str(), write ? "Write" : "Read", size * 8,
size * 2, iValue, addr, debug_interface->GetDescription(addr).c_str());
NOTICE_LOG(MEMMAP, "CHK %08x (%s) %s%i %0*x at %08x (%s)", pc,
debug_interface->GetDescription(pc).c_str(), write ? "Write" : "Read", size * 8,
size * 2, iValue, addr, debug_interface->GetDescription(addr).c_str());
}
if (Break)
return true;

4
Source/Core/Common/GL/GLUtil.cpp
View File

@ -46,7 +46,7 @@ GLuint OpenGL_CompileProgram(const std::string& vertexShader, const std::string&
}
else
{
DEBUG_LOG(VIDEO, "GLSL vertex shader compiled:\n%s", vertexShader.c_str());
INFO_LOG(VIDEO, "GLSL vertex shader compiled:\n%s", vertexShader.c_str());
}
bool shader_errors = !Result;
@ -70,7 +70,7 @@ GLuint OpenGL_CompileProgram(const std::string& vertexShader, const std::string&
}
else
{
DEBUG_LOG(VIDEO, "GLSL fragment shader compiled:\n%s", fragmentShader.c_str());
INFO_LOG(VIDEO, "GLSL fragment shader compiled:\n%s", fragmentShader.c_str());
}
shader_errors |= !Result;

2
Source/Core/Common/Logging/Log.h
View File

@ -82,7 +82,7 @@ void GenericLog(LogTypes::LOG_LEVELS level, LogTypes::LOG_TYPE type, const char*
#define MAX_LOGLEVEL LogTypes::LOG_LEVELS::LDEBUG
#else
#ifndef MAX_LOGLEVEL
#define MAX_LOGLEVEL LogTypes::LOG_LEVELS::LWARNING
#define MAX_LOGLEVEL LogTypes::LOG_LEVELS::LINFO
#endif // loglevel
#endif // logging

2
Source/Core/Core/Boot/ElfReader.cpp
View File

@ -104,7 +104,7 @@ const char* ElfReader::GetSectionName(int section) const
// This is just a simple elf loader, good enough to load elfs generated by devkitPPC
bool ElfReader::LoadIntoMemory()
{
DEBUG_LOG(MASTER_LOG, "String section: %i", header->e_shstrndx);
INFO_LOG(MASTER_LOG, "String section: %i", header->e_shstrndx);
// Should we relocate?
bRelocate = (header->e_type != ET_EXEC);

2
Source/Core/Core/Core.cpp
View File

@ -977,7 +977,7 @@ void UpdateWantDeterminism(bool initial)
bool new_want_determinism = Movie::IsMovieActive() || NetPlay::IsNetPlayRunning();
if (new_want_determinism != g_want_determinism || initial)
{
WARN_LOG(COMMON, "Want determinism <- %s", new_want_determinism ? "true" : "false");
NOTICE_LOG(COMMON, "Want determinism <- %s", new_want_determinism ? "true" : "false");
bool was_unpaused = Core::PauseAndLock(true);

34
Source/Core/Core/DSP/DSPHWInterface.cpp
View File

@ -49,11 +49,11 @@ void gdsp_mbox_write_l(Mailbox mbx, u16 val)
#if defined(_DEBUG) || defined(DEBUGFAST)
if (mbx == MAILBOX_DSP)
INFO_LOG(DSP_MAIL, "DSP(WM) B:%i M:0x%08x (pc=0x%04x)", mbx, gdsp_mbox_peek(MAILBOX_DSP),
g_dsp.pc);
DEBUG_LOG(DSP_MAIL, "DSP(WM) B:%i M:0x%08x (pc=0x%04x)", mbx, gdsp_mbox_peek(MAILBOX_DSP),
g_dsp.pc);
else
INFO_LOG(DSP_MAIL, "CPU(WM) B:%i M:0x%08x (pc=0x%04x)", mbx, gdsp_mbox_peek(MAILBOX_CPU),
g_dsp.pc);
DEBUG_LOG(DSP_MAIL, "CPU(WM) B:%i M:0x%08x (pc=0x%04x)", mbx, gdsp_mbox_peek(MAILBOX_CPU),
g_dsp.pc);
#endif
}
@ -81,11 +81,11 @@ u16 gdsp_mbox_read_l(Mailbox mbx)
#if defined(_DEBUG) || defined(DEBUGFAST)
if (mbx == MAILBOX_DSP)
INFO_LOG(DSP_MAIL, "DSP(RM) B:%i M:0x%08x (pc=0x%04x)", mbx, gdsp_mbox_peek(MAILBOX_DSP),
g_dsp.pc);
DEBUG_LOG(DSP_MAIL, "DSP(RM) B:%i M:0x%08x (pc=0x%04x)", mbx, gdsp_mbox_peek(MAILBOX_DSP),
g_dsp.pc);
else
INFO_LOG(DSP_MAIL, "CPU(RM) B:%i M:0x%08x (pc=0x%04x)", mbx, gdsp_mbox_peek(MAILBOX_CPU),
g_dsp.pc);
DEBUG_LOG(DSP_MAIL, "CPU(RM) B:%i M:0x%08x (pc=0x%04x)", mbx, gdsp_mbox_peek(MAILBOX_CPU),
g_dsp.pc);
#endif
return (u16)value;
@ -101,7 +101,7 @@ void gdsp_ifx_write(u32 addr, u32 val)
if (val & 0x1)
DSPHost::InterruptRequest();
else
INFO_LOG(DSPLLE, "Unknown Interrupt Request pc=%04x (%04x)", g_dsp.pc, val);
WARN_LOG(DSPLLE, "Unknown Interrupt Request pc=%04x (%04x)", g_dsp.pc, val);
break;
case DSP_DMBH:
@ -136,7 +136,7 @@ void gdsp_ifx_write(u32 addr, u32 val)
case DSP_GAIN:
if (val)
{
INFO_LOG(DSPLLE, "Gain Written: 0x%04x", val);
DEBUG_LOG(DSPLLE, "Gain Written: 0x%04x", val);
}
case DSP_DSPA:
case DSP_DSMAH:
@ -154,7 +154,7 @@ void gdsp_ifx_write(u32 addr, u32 val)
{
if (pdlabels[(addr & 0xFF) - 0xa0].name && pdlabels[(addr & 0xFF) - 0xa0].description)
{
INFO_LOG(DSPLLE, "%04x MW %s (%04x)", g_dsp.pc, pdlabels[(addr & 0xFF) - 0xa0].name, val);
DEBUG_LOG(DSPLLE, "%04x MW %s (%04x)", g_dsp.pc, pdlabels[(addr & 0xFF) - 0xa0].name, val);
}
else
{
@ -200,8 +200,8 @@ static u16 _gdsp_ifx_read(u16 addr)
{
if (pdlabels[(addr & 0xFF) - 0xa0].name && pdlabels[(addr & 0xFF) - 0xa0].description)
{
INFO_LOG(DSPLLE, "%04x MR %s (%04x)", g_dsp.pc, pdlabels[(addr & 0xFF) - 0xa0].name,
g_dsp.ifx_regs[addr & 0xFF]);
DEBUG_LOG(DSPLLE, "%04x MR %s (%04x)", g_dsp.pc, pdlabels[(addr & 0xFF) - 0xa0].name,
g_dsp.ifx_regs[addr & 0xFF]);
}
else
{
@ -280,8 +280,8 @@ static const u8* gdsp_ddma_in(u16 dsp_addr, u32 addr, u32 size)
Common::swap16(*(const u16*)&g_dsp.cpu_ram[(addr + i) & 0x7FFFFFFF]);
}
}
INFO_LOG(DSPLLE, "*** ddma_in RAM (0x%08x) -> DRAM_DSP (0x%04x) : size (0x%08x)", addr,
dsp_addr / 2, size);
DEBUG_LOG(DSPLLE, "*** ddma_in RAM (0x%08x) -> DRAM_DSP (0x%04x) : size (0x%08x)", addr,
dsp_addr / 2, size);
return dst + dsp_addr;
}
@ -309,8 +309,8 @@ static const u8* gdsp_ddma_out(u16 dsp_addr, u32 addr, u32 size)
}
}
INFO_LOG(DSPLLE, "*** ddma_out DRAM_DSP (0x%04x) -> RAM (0x%08x) : size (0x%08x)", dsp_addr / 2,
addr, size);
DEBUG_LOG(DSPLLE, "*** ddma_out DRAM_DSP (0x%04x) -> RAM (0x%08x) : size (0x%08x)", dsp_addr / 2,
addr, size);
return src + dsp_addr;
}

2
Source/Core/Core/GeckoCode.cpp
View File

@ -79,7 +79,7 @@ static bool InstallCodeHandler()
std::string _rCodeHandlerFilename = File::GetSysDirectory() + GECKO_CODE_HANDLER;
if (!File::ReadFileToString(_rCodeHandlerFilename, data))
{
NOTICE_LOG(ACTIONREPLAY, "Could not enable cheats because codehandler.bin was missing.");
WARN_LOG(ACTIONREPLAY, "Could not enable cheats because codehandler.bin was missing.");
return false;
}

6
Source/Core/Core/HW/BBA-TAP/TAP_Unix.cpp
View File

@ -103,7 +103,7 @@ bool CEXIETHERNET::IsActivated()
bool CEXIETHERNET::SendFrame(const u8* frame, u32 size)
{
#ifdef __linux__
INFO_LOG(SP1, "SendFrame %x\n%s", size, ArrayToString(frame, size, 0x10).c_str());
DEBUG_LOG(SP1, "SendFrame %x\n%s", size, ArrayToString(frame, size, 0x10).c_str());
int writtenBytes = write(fd, frame, size);
if ((u32)writtenBytes != size)
@ -143,8 +143,8 @@ static void ReadThreadHandler(CEXIETHERNET* self)
}
else if (self->readEnabled.IsSet())
{
INFO_LOG(SP1, "Read data: %s",
ArrayToString(self->mRecvBuffer.get(), readBytes, 0x10).c_str());
DEBUG_LOG(SP1, "Read data: %s",
ArrayToString(self->mRecvBuffer.get(), readBytes, 0x10).c_str());
self->mRecvBufferLength = readBytes;
self->RecvHandlePacket();
}

4
Source/Core/Core/HW/CPU.cpp
View File

@ -9,6 +9,7 @@
#include "Common/CommonTypes.h"
#include "Common/Event.h"
#include "Common/Logging/Log.h"
#include "Common/MsgHandler.h"
#include "Core/Core.h"
#include "Core/HW/CPU.h"
#include "Core/HW/Memmap.h"
@ -279,8 +280,7 @@ bool PauseAndLock(bool do_lock, bool unpause_on_unlock, bool control_adjacent)
bool success = s_state_cpu_idle_cvar.wait_for(state_lock, std::chrono::seconds(10),
[] { return !s_state_cpu_thread_active; });
if (!success)
NOTICE_LOG(
POWERPC,
PanicAlert(
"Abandoned CPU Thread synchronization in CPU::PauseAndLock! We'll probably crash now.");
if (control_adjacent)

8
Source/Core/Core/HW/DSP.cpp
View File

@ -498,8 +498,8 @@ static void Do_ARAM_DMA()
if (g_arDMA.Cnt.dir)
{
// ARAM -> MRAM
INFO_LOG(DSPINTERFACE, "DMA %08x bytes from ARAM %08x to MRAM %08x PC: %08x", g_arDMA.Cnt.count,
g_arDMA.ARAddr, g_arDMA.MMAddr, PC);
DEBUG_LOG(DSPINTERFACE, "DMA %08x bytes from ARAM %08x to MRAM %08x PC: %08x",
g_arDMA.Cnt.count, g_arDMA.ARAddr, g_arDMA.MMAddr, PC);
// Outgoing data from ARAM is mirrored every 64MB (verified on real HW)
g_arDMA.ARAddr &= 0x3ffffff;
@ -545,8 +545,8 @@ static void Do_ARAM_DMA()
else
{
// MRAM -> ARAM
INFO_LOG(DSPINTERFACE, "DMA %08x bytes from MRAM %08x to ARAM %08x PC: %08x", g_arDMA.Cnt.count,
g_arDMA.MMAddr, g_arDMA.ARAddr, PC);
DEBUG_LOG(DSPINTERFACE, "DMA %08x bytes from MRAM %08x to ARAM %08x PC: %08x",
g_arDMA.Cnt.count, g_arDMA.MMAddr, g_arDMA.ARAddr, PC);
// Incoming data into ARAM is mirrored every 64MB (verified on real HW)
g_arDMA.ARAddr &= 0x3ffffff;

10
Source/Core/Core/HW/DSPHLE/UCodes/AX.cpp
View File

@ -18,7 +18,7 @@
AXUCode::AXUCode(DSPHLE* dsphle, u32 crc) : UCodeInterface(dsphle, crc), m_cmdlist_size(0)
{
WARN_LOG(DSPHLE, "Instantiating AXUCode: crc=%08x", crc);
INFO_LOG(DSPHLE, "Instantiating AXUCode: crc=%08x", crc);
m_mail_handler.PushMail(DSP_INIT);
DSP::GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
@ -54,7 +54,7 @@ void AXUCode::LoadResamplingCoefficients()
if (fidx >= ArraySize(filenames))
return;
WARN_LOG(DSPHLE, "Loading polyphase resampling coeffs from %s", filename.c_str());
INFO_LOG(DSPHLE, "Loading polyphase resampling coeffs from %s", filename.c_str());
File::IOFile fp(filename, "rb");
fp.ReadBytes(m_coeffs, 0x1000);
@ -82,10 +82,10 @@ void AXUCode::HandleCommandList()
u32 pb_addr = 0;
#if 0
WARN_LOG(DSPHLE, "Command list:");
INFO_LOG(DSPHLE, "Command list:");
for (u32 i = 0; m_cmdlist[i] != CMD_END; ++i)
WARN_LOG(DSPHLE, "%04x", m_cmdlist[i]);
WARN_LOG(DSPHLE, "-------------");
INFO_LOG(DSPHLE, "%04x", m_cmdlist[i]);
INFO_LOG(DSPHLE, "-------------");
#endif
u32 curr_idx = 0;

2
Source/Core/Core/HW/DSPHLE/UCodes/AXWii.cpp
View File

@ -20,7 +20,7 @@ AXWiiUCode::AXWiiUCode(DSPHLE* dsphle, u32 crc) : AXUCode(dsphle, crc), m_last_m
for (u16& volume : m_last_aux_volumes)
volume = 0x8000;
WARN_LOG(DSPHLE, "Instantiating AXWiiUCode");
INFO_LOG(DSPHLE, "Instantiating AXWiiUCode");
m_old_axwii = (crc == 0xfa450138);
}

4
Source/Core/Core/HW/DSPHLE/UCodes/CARD.cpp
View File

@ -11,7 +11,7 @@
CARDUCode::CARDUCode(DSPHLE* dsphle, u32 crc) : UCodeInterface(dsphle, crc)
{
DEBUG_LOG(DSPHLE, "CARDUCode - initialized");
INFO_LOG(DSPHLE, "CARDUCode - initialized");
m_mail_handler.PushMail(DSP_INIT);
}
@ -37,7 +37,7 @@ void CARDUCode::HandleMail(u32 mail)
}
else
{
DEBUG_LOG(DSPHLE, "CARDUCode - unknown command: %x", mail);
WARN_LOG(DSPHLE, "CARDUCode - unknown command: %x", mail);
}
m_mail_handler.PushMail(DSP_DONE);

4
Source/Core/Core/HW/DSPHLE/UCodes/GBA.cpp
View File

@ -134,12 +134,12 @@ void GBAUCode::HandleMail(u32 mail)
m_dsphle->SetUCode(UCODE_ROM);
break;
default:
DEBUG_LOG(DSPHLE, "GBAUCode - unknown 0xcdd1 command: %08x", mail);
WARN_LOG(DSPHLE, "GBAUCode - unknown 0xcdd1 command: %08x", mail);
break;
}
}
else
{
DEBUG_LOG(DSPHLE, "GBAUCode - unknown command: %08x", mail);
WARN_LOG(DSPHLE, "GBAUCode - unknown command: %08x", mail);
}
}

2
Source/Core/Core/HW/DSPHLE/UCodes/INIT.cpp
View File

@ -9,7 +9,7 @@
INITUCode::INITUCode(DSPHLE* dsphle, u32 crc) : UCodeInterface(dsphle, crc)
{
DEBUG_LOG(DSPHLE, "INITUCode - initialized");
INFO_LOG(DSPHLE, "INITUCode - initialized");
m_mail_handler.PushMail(0x80544348);
}

16
Source/Core/Core/HW/DSPHLE/UCodes/ROM.cpp
View File

@ -21,7 +21,7 @@
ROMUCode::ROMUCode(DSPHLE* dsphle, u32 crc)
: UCodeInterface(dsphle, crc), m_current_ucode(), m_boot_task_num_steps(0), m_next_parameter(0)
{
DEBUG_LOG(DSPHLE, "UCode_Rom - initialized");
INFO_LOG(DSPHLE, "UCode_Rom - initialized");
m_mail_handler.Clear();
m_mail_handler.PushMail(0x8071FEED);
}
@ -107,13 +107,13 @@ void ROMUCode::BootUCode()
}
}
DEBUG_LOG(DSPHLE, "CurrentUCode SOURCE Addr: 0x%08x", m_current_ucode.m_ram_address);
DEBUG_LOG(DSPHLE, "CurrentUCode Length: 0x%08x", m_current_ucode.m_length);
DEBUG_LOG(DSPHLE, "CurrentUCode DEST Addr: 0x%08x", m_current_ucode.m_imem_address);
DEBUG_LOG(DSPHLE, "CurrentUCode DMEM Length: 0x%08x", m_current_ucode.m_dmem_length);
DEBUG_LOG(DSPHLE, "CurrentUCode init_vector: 0x%08x", m_current_ucode.m_start_pc);
DEBUG_LOG(DSPHLE, "CurrentUCode CRC: 0x%08x", ector_crc);
DEBUG_LOG(DSPHLE, "BootTask - done");
INFO_LOG(DSPHLE, "CurrentUCode SOURCE Addr: 0x%08x", m_current_ucode.m_ram_address);
INFO_LOG(DSPHLE, "CurrentUCode Length: 0x%08x", m_current_ucode.m_length);
INFO_LOG(DSPHLE, "CurrentUCode DEST Addr: 0x%08x", m_current_ucode.m_imem_address);
INFO_LOG(DSPHLE, "CurrentUCode DMEM Length: 0x%08x", m_current_ucode.m_dmem_length);
INFO_LOG(DSPHLE, "CurrentUCode init_vector: 0x%08x", m_current_ucode.m_start_pc);
INFO_LOG(DSPHLE, "CurrentUCode CRC: 0x%08x", ector_crc);
INFO_LOG(DSPHLE, "BootTask - done");
m_dsphle->SetUCode(ector_crc);
}

2
Source/Core/Core/HW/DSPHLE/UCodes/Zelda.cpp
View File

@ -118,7 +118,7 @@ ZeldaUCode::ZeldaUCode(DSPHLE* dsphle, u32 crc) : UCodeInterface(dsphle, crc)
m_flags = it->second;
m_renderer.SetFlags(m_flags);
WARN_LOG(DSPHLE, "Zelda UCode loaded, crc=%08x, flags=%08x", crc, m_flags);
INFO_LOG(DSPHLE, "Zelda UCode loaded, crc=%08x, flags=%08x", crc, m_flags);
if (m_flags & LIGHT_PROTOCOL)
{

10
Source/Core/Core/HW/DVDInterface.cpp
View File

@ -743,7 +743,7 @@ void ExecuteCommand(u32 command_0, u32 command_1, u32 command_2, u32 output_addr
// Probably only used though WII_IPC
case DVDLowGetCoverReg:
WriteImmediate(s_DICVR.Hex, output_address, reply_to_ios);
INFO_LOG(DVDINTERFACE, "DVDLowGetCoverReg 0x%08x", s_DICVR.Hex);
DEBUG_LOG(DVDINTERFACE, "DVDLowGetCoverReg 0x%08x", s_DICVR.Hex);
break;
// Probably only used by Wii
@ -769,7 +769,7 @@ void ExecuteCommand(u32 command_0, u32 command_1, u32 command_2, u32 output_addr
// Probably only used by Wii
case DVDLowClearCoverInterrupt:
INFO_LOG(DVDINTERFACE, "DVDLowClearCoverInterrupt");
DEBUG_LOG(DVDINTERFACE, "DVDLowClearCoverInterrupt");
s_DICVR.CVRINT = 0;
break;
@ -999,7 +999,7 @@ void ExecuteCommand(u32 command_0, u32 command_1, u32 command_2, u32 output_addr
WriteImmediate(s_current_length >> 2, output_address, reply_to_ios);
break;
default:
WARN_LOG(DVDINTERFACE, "(Audio): Subcommand: %02x Request Audio status %s",
INFO_LOG(DVDINTERFACE, "(Audio): Subcommand: %02x Request Audio status %s",
command_0 >> 16 & 0xFF, s_stream ? "on" : "off");
break;
}
@ -1029,13 +1029,13 @@ void ExecuteCommand(u32 command_0, u32 command_1, u32 command_2, u32 output_addr
{
// TODO: What is this actually supposed to do?
s_stream = true;
WARN_LOG(DVDINTERFACE, "(Audio): Audio enabled");
INFO_LOG(DVDINTERFACE, "(Audio): Audio enabled");
}
else
{
// TODO: What is this actually supposed to do?
s_stream = false;
WARN_LOG(DVDINTERFACE, "(Audio): Audio disabled");
INFO_LOG(DVDINTERFACE, "(Audio): Audio disabled");
}
break;

4
Source/Core/Core/HW/EXI_DeviceAGP.cpp
View File

@ -254,7 +254,7 @@ u32 CEXIAgp::ImmRead(u32 _uSize)
m_current_cmd = 0;
break;
}
INFO_LOG(EXPANSIONINTERFACE, "AGP read %x", uData);
DEBUG_LOG(EXPANSIONINTERFACE, "AGP read %x", uData);
return uData;
}
@ -266,7 +266,7 @@ void CEXIAgp::ImmWrite(u32 _uData, u32 _uSize)
u8 HashCmd;
u64 Mask;
INFO_LOG(EXPANSIONINTERFACE, "AGP command %x", _uData);
DEBUG_LOG(EXPANSIONINTERFACE, "AGP command %x", _uData);
switch (m_current_cmd)
{
case 0xAE020000: // set up 24 bit address for read 2 bytes

10
Source/Core/Core/HW/EXI_DeviceEthernet.cpp
View File

@ -306,7 +306,7 @@ void CEXIETHERNET::MXCommandHandler(u32 data, u32 size)
case BBA_NCRA:
if (data & NCRA_RESET)
{
DEBUG_LOG(SP1, "Software reset");
INFO_LOG(SP1, "Software reset");
// MXSoftReset();
Activate();
}
@ -328,7 +328,7 @@ void CEXIETHERNET::MXCommandHandler(u32 data, u32 size)
if (data & NCRA_ST0)
{
WARN_LOG(SP1, "start tx - local DMA");
INFO_LOG(SP1, "start tx - local DMA");
SendFromPacketBuffer();
}
else if (data & NCRA_ST1)
@ -491,10 +491,10 @@ bool CEXIETHERNET::RecvHandlePacket()
goto wait_for_next;
#ifdef BBA_TRACK_PAGE_PTRS
WARN_LOG(SP1, "RecvHandlePacket %x\n%s", mRecvBufferLength,
INFO_LOG(SP1, "RecvHandlePacket %x\n%s", mRecvBufferLength,
ArrayToString(mRecvBuffer, mRecvBufferLength, 0x100).c_str());
WARN_LOG(SP1, "%x %x %x %x", page_ptr(BBA_BP), page_ptr(BBA_RRP), page_ptr(BBA_RWP),
INFO_LOG(SP1, "%x %x %x %x", page_ptr(BBA_BP), page_ptr(BBA_RRP), page_ptr(BBA_RWP),
page_ptr(BBA_RHBP));
#endif
@ -542,7 +542,7 @@ bool CEXIETHERNET::RecvHandlePacket()
inc_rwp();
#ifdef BBA_TRACK_PAGE_PTRS
WARN_LOG(SP1, "%x %x %x %x", page_ptr(BBA_BP), page_ptr(BBA_RRP), page_ptr(BBA_RWP),
INFO_LOG(SP1, "%x %x %x %x", page_ptr(BBA_BP), page_ptr(BBA_RRP), page_ptr(BBA_RWP),
page_ptr(BBA_RHBP));
#endif

8
Source/Core/Core/HW/EXI_DeviceMemoryCard.cpp
View File

@ -385,8 +385,8 @@ void CEXIMemoryCard::TransferByte(u8& byte)
case cmdPageProgram:
case cmdExtraByteProgram:
case cmdChipErase:
INFO_LOG(EXPANSIONINTERFACE, "EXI MEMCARD: command %02x at position 0. seems normal.",
command);
DEBUG_LOG(EXPANSIONINTERFACE, "EXI MEMCARD: command %02x at position 0. seems normal.",
command);
break;
default:
WARN_LOG(EXPANSIONINTERFACE, "EXI MEMCARD: command %02x at position 0", command);
@ -558,7 +558,7 @@ void CEXIMemoryCard::DMARead(u32 _uAddr, u32 _uSize)
if ((address + _uSize) % BLOCK_SIZE == 0)
{
DEBUG_LOG(EXPANSIONINTERFACE, "reading from block: %x", address / BLOCK_SIZE);
INFO_LOG(EXPANSIONINTERFACE, "reading from block: %x", address / BLOCK_SIZE);
}
// Schedule transfer complete later based on read speed
@ -574,7 +574,7 @@ void CEXIMemoryCard::DMAWrite(u32 _uAddr, u32 _uSize)
if (((address + _uSize) % BLOCK_SIZE) == 0)
{
DEBUG_LOG(EXPANSIONINTERFACE, "writing to block: %x", address / BLOCK_SIZE);
INFO_LOG(EXPANSIONINTERFACE, "writing to block: %x", address / BLOCK_SIZE);
}
// Schedule transfer complete later based on write speed

2
Source/Core/Core/HW/EXI_DeviceMic.cpp
View File

@ -21,7 +21,7 @@
void CEXIMic::StreamLog(const char* msg)
{
DEBUG_LOG(EXPANSIONINTERFACE, "%s: %s", msg, Pa_GetErrorText(pa_error));
INFO_LOG(EXPANSIONINTERFACE, "%s: %s", msg, Pa_GetErrorText(pa_error));
}
void CEXIMic::StreamInit()

8
Source/Core/Core/HW/WII_IPC.cpp
View File

@ -211,8 +211,8 @@ void GenerateAck(u32 _Address)
{
arm_msg = _Address; // dunno if it's really set here, but HLE needs to stay in context
ctrl.Y2 = 1;
INFO_LOG(WII_IPC, "GenerateAck: %08x | %08x [R:%i A:%i E:%i]", ppc_msg, _Address, ctrl.Y1,
ctrl.Y2, ctrl.X1);
DEBUG_LOG(WII_IPC, "GenerateAck: %08x | %08x [R:%i A:%i E:%i]", ppc_msg, _Address, ctrl.Y1,
ctrl.Y2, ctrl.X1);
CoreTiming::ScheduleEvent(1000, updateInterrupts, 0);
}
@ -220,8 +220,8 @@ void GenerateReply(u32 _Address)
{
arm_msg = _Address;
ctrl.Y1 = 1;
INFO_LOG(WII_IPC, "GenerateReply: %08x | %08x [R:%i A:%i E:%i]", ppc_msg, _Address, ctrl.Y1,
ctrl.Y2, ctrl.X1);
DEBUG_LOG(WII_IPC, "GenerateReply: %08x | %08x [R:%i A:%i E:%i]", ppc_msg, _Address, ctrl.Y1,
ctrl.Y2, ctrl.X1);
UpdateInterrupts();
}

4
Source/Core/Core/HW/WiimoteEmu/EmuSubroutines.cpp
View File

@ -70,8 +70,8 @@ void Wiimote::ReportMode(const wm_report_mode* const dr)
*/
void Wiimote::HidOutputReport(const wm_report* const sr, const bool send_ack)
{
INFO_LOG(WIIMOTE, "HidOutputReport (page: %i, cid: 0x%02x, wm: 0x%02x)", m_index,
m_reporting_channel, sr->wm);
DEBUG_LOG(WIIMOTE, "HidOutputReport (page: %i, cid: 0x%02x, wm: 0x%02x)", m_index,
m_reporting_channel, sr->wm);
// WiiBrew:
// In every single Output Report, bit 0 (0x01) of the first byte controls the Rumble feature.

4
Source/Core/Core/HW/WiimoteEmu/WiimoteEmu.cpp
View File

@ -808,8 +808,8 @@ void Wiimote::ControlChannel(const u16 _channelID, const void* _pData, u32 _Size
const hid_packet* const hidp = (hid_packet*)_pData;
INFO_LOG(WIIMOTE, "Emu ControlChannel (page: %i, type: 0x%02x, param: 0x%02x)", m_index,
hidp->type, hidp->param);
DEBUG_LOG(WIIMOTE, "Emu ControlChannel (page: %i, type: 0x%02x, param: 0x%02x)", m_index,
hidp->type, hidp->param);
switch (hidp->type)
{

4
Source/Core/Core/HW/WiimoteReal/IOLinux.cpp
View File

@ -79,7 +79,7 @@ void WiimoteScannerLinux::FindWiimotes(std::vector<Wiimote*>& found_wiimotes, Wi
// Display discovered devices
for (int i = 0; i < found_devices; ++i)
{
ERROR_LOG(WIIMOTE, "found a device...");
NOTICE_LOG(WIIMOTE, "found a device...");
// BT names are a maximum of 248 bytes apparently
char name[255] = {};
@ -89,7 +89,7 @@ void WiimoteScannerLinux::FindWiimotes(std::vector<Wiimote*>& found_wiimotes, Wi
continue;
}
ERROR_LOG(WIIMOTE, "device name %s", name);
NOTICE_LOG(WIIMOTE, "device name %s", name);
if (!IsValidBluetoothName(name))
continue;

18
Source/Core/Core/IPC_HLE/WII_IPC_HLE.cpp
View File

@ -376,8 +376,8 @@ void ExecuteCommand(u32 _Address)
std::shared_ptr<IWII_IPC_HLE_Device> pDevice =
(DeviceID >= 0 && DeviceID < IPC_MAX_FDS) ? g_FdMap[DeviceID] : nullptr;
INFO_LOG(WII_IPC_HLE, "-->> Execute Command Address: 0x%08x (code: %x, device: %x) %p", _Address,
Command, DeviceID, pDevice.get());
DEBUG_LOG(WII_IPC_HLE, "-->> Execute Command Address: 0x%08x (code: %x, device: %x) %p", _Address,
Command, DeviceID, pDevice.get());
switch (Command)
{
@ -388,7 +388,7 @@ void ExecuteCommand(u32 _Address)
std::string DeviceName = Memory::GetString(Memory::Read_U32(_Address + 0xC));
WARN_LOG(WII_IPC_HLE, "Trying to open %s as %d", DeviceName.c_str(), DeviceID);
INFO_LOG(WII_IPC_HLE, "Trying to open %s as %d", DeviceName.c_str(), DeviceID);
if (DeviceID >= 0)
{
if (DeviceName.find("/dev/es") == 0)
@ -419,8 +419,8 @@ void ExecuteCommand(u32 _Address)
{
g_FdMap[DeviceID] = pDevice;
result = pDevice->Open(_Address, Mode);
INFO_LOG(WII_IPC_FILEIO, "IOP: ReOpen (Device=%s, DeviceID=%08x, Mode=%i)",
pDevice->GetDeviceName().c_str(), DeviceID, Mode);
DEBUG_LOG(WII_IPC_FILEIO, "IOP: ReOpen (Device=%s, DeviceID=%08x, Mode=%i)",
pDevice->GetDeviceName().c_str(), DeviceID, Mode);
Memory::Write_U32(DeviceID, _Address + 4);
}
else
@ -435,8 +435,8 @@ void ExecuteCommand(u32 _Address)
pDevice = CreateFileIO(DeviceID, DeviceName);
result = pDevice->Open(_Address, Mode);
INFO_LOG(WII_IPC_FILEIO, "IOP: Open File (Device=%s, ID=%08x, Mode=%i)",
pDevice->GetDeviceName().c_str(), DeviceID, Mode);
DEBUG_LOG(WII_IPC_FILEIO, "IOP: Open File (Device=%s, ID=%08x, Mode=%i)",
pDevice->GetDeviceName().c_str(), DeviceID, Mode);
if (Memory::Read_U32(_Address + 4) == (u32)DeviceID)
{
g_FdMap[DeviceID] = pDevice;
@ -583,7 +583,7 @@ void Update()
if (request_queue.size())
{
WII_IPCInterface::GenerateAck(request_queue.front());
INFO_LOG(WII_IPC_HLE, "||-- Acknowledge IPC Request @ 0x%08x", request_queue.front());
DEBUG_LOG(WII_IPC_HLE, "||-- Acknowledge IPC Request @ 0x%08x", request_queue.front());
u32 command = request_queue.front();
request_queue.pop_front();
ExecuteCommand(command);
@ -593,7 +593,7 @@ void Update()
if (reply_queue.size())
{
WII_IPCInterface::GenerateReply(reply_queue.front());
INFO_LOG(WII_IPC_HLE, "<<-- Reply to IPC Request @ 0x%08x", reply_queue.front());
DEBUG_LOG(WII_IPC_HLE, "<<-- Reply to IPC Request @ 0x%08x", reply_queue.front());
reply_queue.pop_front();
return;
}

18
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_FileIO.cpp
View File

@ -186,8 +186,8 @@ IPCCommandResult CWII_IPC_HLE_Device_FileIO::Seek(u32 _CommandAddress)
ReturnValue = FS_RESULT_FATAL;
const s32 fileSize = (s32)m_file->GetSize();
INFO_LOG(WII_IPC_FILEIO, "FileIO: Seek Pos: 0x%08x, Mode: %i (%s, Length=0x%08x)", SeekPosition,
Mode, m_Name.c_str(), fileSize);
DEBUG_LOG(WII_IPC_FILEIO, "FileIO: Seek Pos: 0x%08x, Mode: %i (%s, Length=0x%08x)",
SeekPosition, Mode, m_Name.c_str(), fileSize);
switch (Mode)
{
@ -256,8 +256,8 @@ IPCCommandResult CWII_IPC_HLE_Device_FileIO::Read(u32 _CommandAddress)
}
else
{
INFO_LOG(WII_IPC_FILEIO, "FileIO: Read 0x%x bytes to 0x%08x from %s", Size, Address,
m_Name.c_str());
DEBUG_LOG(WII_IPC_FILEIO, "FileIO: Read 0x%x bytes to 0x%08x from %s", Size, Address,
m_Name.c_str());
m_file->Seek(m_SeekPos, SEEK_SET); // File might be opened twice, need to seek before we read
ReturnValue = (u32)fread(Memory::GetPointer(Address), 1, Size, m_file->GetHandle());
if (ReturnValue != Size && ferror(m_file->GetHandle()))
@ -299,8 +299,8 @@ IPCCommandResult CWII_IPC_HLE_Device_FileIO::Write(u32 _CommandAddress)
}
else
{
INFO_LOG(WII_IPC_FILEIO, "FileIO: Write 0x%04x bytes from 0x%08x to %s", Size, Address,
m_Name.c_str());
DEBUG_LOG(WII_IPC_FILEIO, "FileIO: Write 0x%04x bytes from 0x%08x to %s", Size, Address,
m_Name.c_str());
m_file->Seek(m_SeekPos,
SEEK_SET); // File might be opened twice, need to seek before we write
if (m_file->WriteBytes(Memory::GetPointer(Address), Size))
@ -324,7 +324,7 @@ IPCCommandResult CWII_IPC_HLE_Device_FileIO::Write(u32 _CommandAddress)
IPCCommandResult CWII_IPC_HLE_Device_FileIO::IOCtl(u32 _CommandAddress)
{
INFO_LOG(WII_IPC_FILEIO, "FileIO: IOCtl (Device=%s)", m_Name.c_str());
DEBUG_LOG(WII_IPC_FILEIO, "FileIO: IOCtl (Device=%s)", m_Name.c_str());
#if defined(_DEBUG) || defined(DEBUGFAST)
DumpCommands(_CommandAddress);
#endif
@ -340,8 +340,8 @@ IPCCommandResult CWII_IPC_HLE_Device_FileIO::IOCtl(u32 _CommandAddress)
u32 m_FileLength = (u32)m_file->GetSize();
const u32 BufferOut = Memory::Read_U32(_CommandAddress + 0x18);
INFO_LOG(WII_IPC_FILEIO, " File: %s, Length: %i, Pos: %i", m_Name.c_str(), m_FileLength,
m_SeekPos);
DEBUG_LOG(WII_IPC_FILEIO, " File: %s, Length: %i, Pos: %i", m_Name.c_str(), m_FileLength,
m_SeekPos);
Memory::Write_U32(m_FileLength, BufferOut);
Memory::Write_U32(m_SeekPos, BufferOut + 4);

28
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_es.cpp
View File

@ -326,8 +326,8 @@ IPCCommandResult CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
else
{
Memory::Write_U32((u32)rNANDContent.GetContentSize(), _CommandAddress + 0x4);
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLECONTENTS: Unable to open content %zu",
rNANDContent.GetContentSize());
ERROR_LOG(WII_IPC_ES, "IOCTL_ES_GETTITLECONTENTS: Unable to open content %zu",
rNANDContent.GetContentSize());
}
return GetDefaultReply();
@ -412,9 +412,9 @@ IPCCommandResult CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
}
}
INFO_LOG(WII_IPC_ES,
"IOCTL_ES_READCONTENT: CFD %x, Address 0x%x, Size %i -> stream pos %i (Index %i)", CFD,
Addr, Size, rContent.m_Position, rContent.m_Index);
DEBUG_LOG(WII_IPC_ES,
"IOCTL_ES_READCONTENT: CFD %x, Address 0x%x, Size %i -> stream pos %i (Index %i)",
CFD, Addr, Size, rContent.m_Position, rContent.m_Index);
Memory::Write_U32(Size, _CommandAddress + 0x4);
return GetDefaultReply();
@ -484,8 +484,8 @@ IPCCommandResult CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
break;
}
INFO_LOG(WII_IPC_ES, "IOCTL_ES_SEEKCONTENT: CFD %x, Address 0x%x, Mode %i -> Pos %i", CFD, Addr,
Mode, rContent.m_Position);
DEBUG_LOG(WII_IPC_ES, "IOCTL_ES_SEEKCONTENT: CFD %x, Address 0x%x, Mode %i -> Pos %i", CFD,
Addr, Mode, rContent.m_Position);
Memory::Write_U32(rContent.m_Position, _CommandAddress + 0x4);
return GetDefaultReply();
@ -779,7 +779,7 @@ IPCCommandResult CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
case IOCTL_ES_GETCONSUMPTION: // This is at least what crediar's ES module does
Memory::Write_U32(0, Buffer.PayloadBuffer[1].m_Address);
Memory::Write_U32(0, _CommandAddress + 0x4);
WARN_LOG(WII_IPC_ES, "IOCTL_ES_GETCONSUMPTION:%d", Memory::Read_U32(_CommandAddress + 4));
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETCONSUMPTION:%d", Memory::Read_U32(_CommandAddress + 4));
return GetDefaultReply();
case IOCTL_ES_DELETETICKET:
@ -1061,13 +1061,13 @@ IPCCommandResult CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
// 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
WARN_LOG(WII_IPC_ES, "IOCTL_ES_CHECKKOREAREGION: Title checked for Korean keys.");
INFO_LOG(WII_IPC_ES, "IOCTL_ES_CHECKKOREAREGION: Title checked for Korean keys.");
Memory::Write_U32(ES_PARAMTER_SIZE_OR_ALIGNMENT, _CommandAddress + 0x4);
return GetDefaultReply();
case IOCTL_ES_GETDEVICECERT: // (Input: none, Output: 384 bytes)
{
WARN_LOG(WII_IPC_ES, "IOCTL_ES_GETDEVICECERT");
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETDEVICECERT");
_dbg_assert_(WII_IPC_ES, Buffer.NumberPayloadBuffer == 1);
u8* destination = Memory::GetPointer(Buffer.PayloadBuffer[0].m_Address);
@ -1078,7 +1078,7 @@ IPCCommandResult CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
case IOCTL_ES_SIGN:
{
WARN_LOG(WII_IPC_ES, "IOCTL_ES_SIGN");
INFO_LOG(WII_IPC_ES, "IOCTL_ES_SIGN");
u8* ap_cert_out = Memory::GetPointer(Buffer.PayloadBuffer[1].m_Address);
u8* data = Memory::GetPointer(Buffer.InBuffer[0].m_Address);
u32 data_size = Buffer.InBuffer[0].m_Size;
@ -1092,7 +1092,7 @@ IPCCommandResult CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
case IOCTL_ES_GETBOOT2VERSION:
{
WARN_LOG(WII_IPC_ES, "IOCTL_ES_GETBOOT2VERSION");
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETBOOT2VERSION");
Memory::Write_U32(
4, Buffer.PayloadBuffer[0].m_Address); // as of 26/02/2012, this was latest bootmii version
@ -1107,12 +1107,12 @@ IPCCommandResult CWII_IPC_HLE_Device_es::IOCtlV(u32 _CommandAddress)
break;
case IOCTL_ES_GETOWNEDTITLECNT:
WARN_LOG(WII_IPC_ES, "IOCTL_ES_GETOWNEDTITLECNT");
INFO_LOG(WII_IPC_ES, "IOCTL_ES_GETOWNEDTITLECNT");
Memory::Write_U32(0, Buffer.PayloadBuffer[0].m_Address);
break;
default:
WARN_LOG(WII_IPC_ES, "CWII_IPC_HLE_Device_es: 0x%x", Buffer.Parameter);
INFO_LOG(WII_IPC_ES, "CWII_IPC_HLE_Device_es: 0x%x", Buffer.Parameter);
DumpCommands(_CommandAddress, 8, LogTypes::WII_IPC_ES);
INFO_LOG(WII_IPC_ES, "command.Parameter: 0x%08x", Buffer.Parameter);
break;

2
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_fs.cpp
View File

@ -478,7 +478,7 @@ s32 CWII_IPC_HLE_Device_fs::ExecuteCommand(u32 _Parameter, u32 _BufferIn, u32 _B
// check if the file already exist
if (File::Exists(Filename))
{
WARN_LOG(WII_IPC_FILEIO, "\tresult = FS_RESULT_EXISTS");
INFO_LOG(WII_IPC_FILEIO, "\tresult = FS_RESULT_EXISTS");
return FS_FILE_EXIST;
}

60
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_hid.cpp
View File

@ -114,7 +114,7 @@ CWII_IPC_HLE_Device_hid::~CWII_IPC_HLE_Device_hid()
IPCCommandResult CWII_IPC_HLE_Device_hid::Open(u32 _CommandAddress, u32 _Mode)
{
DEBUG_LOG(WII_IPC_HID, "HID::Open");
INFO_LOG(WII_IPC_HID, "HID::Open");
m_Active = true;
Memory::Write_U32(GetDeviceID(), _CommandAddress + 4);
return GetDefaultReply();
@ -122,7 +122,7 @@ IPCCommandResult CWII_IPC_HLE_Device_hid::Open(u32 _CommandAddress, u32 _Mode)
IPCCommandResult CWII_IPC_HLE_Device_hid::Close(u32 _CommandAddress, bool _bForce)
{
DEBUG_LOG(WII_IPC_HID, "HID::Close");
INFO_LOG(WII_IPC_HID, "HID::Close");
m_Active = false;
if (!_bForce)
Memory::Write_U32(0, _CommandAddress + 4);
@ -148,15 +148,15 @@ IPCCommandResult CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
{
case IOCTL_HID_GET_ATTACHED:
{
DEBUG_LOG(WII_IPC_HID, "HID::IOCtl(Get Attached) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
BufferIn, BufferInSize, BufferOut, BufferOutSize);
INFO_LOG(WII_IPC_HID, "HID::IOCtl(Get Attached) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
BufferIn, BufferInSize, BufferOut, BufferOutSize);
deviceCommandAddress = _CommandAddress;
return GetNoReply();
}
case IOCTL_HID_OPEN:
{
DEBUG_LOG(WII_IPC_HID, "HID::IOCtl(Open) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
BufferIn, BufferInSize, BufferOut, BufferOutSize);
INFO_LOG(WII_IPC_HID, "HID::IOCtl(Open) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)", BufferIn,
BufferInSize, BufferOut, BufferOutSize);
// hid version, apparently
ReturnValue = 0x40001;
@ -164,8 +164,8 @@ IPCCommandResult CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
}
case IOCTL_HID_SET_SUSPEND:
{
DEBUG_LOG(WII_IPC_HID, "HID::IOCtl(Set Suspend) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
BufferIn, BufferInSize, BufferOut, BufferOutSize);
INFO_LOG(WII_IPC_HID, "HID::IOCtl(Set Suspend) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
BufferIn, BufferInSize, BufferOut, BufferOutSize);
// not actually implemented in IOS
ReturnValue = 0;
break;
@ -199,7 +199,7 @@ IPCCommandResult CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
if (dev_handle == nullptr)
{
DEBUG_LOG(WII_IPC_HID, "Could not find handle: %X", dev_num);
INFO_LOG(WII_IPC_HID, "Could not find handle: %X", dev_num);
break;
}
struct libusb_transfer* transfer = libusb_alloc_transfer(0);
@ -234,7 +234,7 @@ IPCCommandResult CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
if (dev_handle == nullptr)
{
DEBUG_LOG(WII_IPC_HID, "Could not find handle: %X", dev_num);
INFO_LOG(WII_IPC_HID, "Could not find handle: %X", dev_num);
break;
}
@ -269,14 +269,14 @@ IPCCommandResult CWII_IPC_HLE_Device_hid::IOCtl(u32 _CommandAddress)
WII_IPC_HLE_Interface::EnqueueReply(deviceCommandAddress);
deviceCommandAddress = 0;
}
DEBUG_LOG(WII_IPC_HID, "HID::IOCtl(Shutdown) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
BufferIn, BufferInSize, BufferOut, BufferOutSize);
INFO_LOG(WII_IPC_HID, "HID::IOCtl(Shutdown) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
BufferIn, BufferInSize, BufferOut, BufferOutSize);
break;
}
default:
{
DEBUG_LOG(WII_IPC_HID, "HID::IOCtl(0x%x) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
Parameter, BufferIn, BufferInSize, BufferOut, BufferOutSize);
INFO_LOG(WII_IPC_HID, "HID::IOCtl(0x%x) (BufferIn: (%08x, %i), BufferOut: (%08x, %i)",
Parameter, BufferIn, BufferInSize, BufferOut, BufferOutSize);
break;
}
}
@ -293,19 +293,19 @@ bool CWII_IPC_HLE_Device_hid::ClaimDevice(libusb_device_handle* dev)
{
if ((ret = libusb_detach_kernel_driver(dev, 0)) && ret != LIBUSB_ERROR_NOT_SUPPORTED)
{
DEBUG_LOG(WII_IPC_HID, "libusb_detach_kernel_driver failed with error: %d", ret);
ERROR_LOG(WII_IPC_HID, "libusb_detach_kernel_driver failed with error: %d", ret);
return false;
}
}
else if (ret != 0 && ret != LIBUSB_ERROR_NOT_SUPPORTED)
{
DEBUG_LOG(WII_IPC_HID, "libusb_kernel_driver_active error ret = %d", ret);
ERROR_LOG(WII_IPC_HID, "libusb_kernel_driver_active error ret = %d", ret);
return false;
}
if ((ret = libusb_claim_interface(dev, 0)))
{
DEBUG_LOG(WII_IPC_HID, "libusb_claim_interface failed with error: %d", ret);
ERROR_LOG(WII_IPC_HID, "libusb_claim_interface failed with error: %d", ret);
return false;
}
@ -318,13 +318,13 @@ IPCCommandResult CWII_IPC_HLE_Device_hid::IOCtlV(u32 _CommandAddress)
u32 ReturnValue = 0;
SIOCtlVBuffer CommandBuffer(_CommandAddress);
DEBUG_LOG(WII_IPC_HID, "%s - IOCtlV:", GetDeviceName().c_str());
DEBUG_LOG(WII_IPC_HID, " Parameter: 0x%x", CommandBuffer.Parameter);
DEBUG_LOG(WII_IPC_HID, " NumberIn: 0x%08x", CommandBuffer.NumberInBuffer);
DEBUG_LOG(WII_IPC_HID, " NumberOut: 0x%08x", CommandBuffer.NumberPayloadBuffer);
DEBUG_LOG(WII_IPC_HID, " BufferVector: 0x%08x", CommandBuffer.BufferVector);
DEBUG_LOG(WII_IPC_HID, " PayloadAddr: 0x%08x", CommandBuffer.PayloadBuffer[0].m_Address);
DEBUG_LOG(WII_IPC_HID, " PayloadSize: 0x%08x", CommandBuffer.PayloadBuffer[0].m_Size);
INFO_LOG(WII_IPC_HID, "%s - IOCtlV:", GetDeviceName().c_str());
INFO_LOG(WII_IPC_HID, " Parameter: 0x%x", CommandBuffer.Parameter);
INFO_LOG(WII_IPC_HID, " NumberIn: 0x%08x", CommandBuffer.NumberInBuffer);
INFO_LOG(WII_IPC_HID, " NumberOut: 0x%08x", CommandBuffer.NumberPayloadBuffer);
INFO_LOG(WII_IPC_HID, " BufferVector: 0x%08x", CommandBuffer.BufferVector);
INFO_LOG(WII_IPC_HID, " PayloadAddr: 0x%08x", CommandBuffer.PayloadBuffer[0].m_Address);
INFO_LOG(WII_IPC_HID, " PayloadSize: 0x%08x", CommandBuffer.PayloadBuffer[0].m_Size);
#if defined(_DEBUG) || defined(DEBUGFAST)
DumpAsync(CommandBuffer.BufferVector, CommandBuffer.NumberInBuffer,
CommandBuffer.NumberPayloadBuffer);
@ -384,7 +384,7 @@ void CWII_IPC_HLE_Device_hid::FillOutDevices(u32 BufferOut, u32 BufferOutSize)
libusb_device** list;
// libusb_device *found = nullptr;
ssize_t cnt = libusb_get_device_list(nullptr, &list);
DEBUG_LOG(WII_IPC_HID, "Found %ld viable USB devices.", cnt);
INFO_LOG(WII_IPC_HID, "Found %ld viable USB devices.", cnt);
for (d = 0; d < cnt; d++)
{
libusb_device* device = list[d];
@ -393,7 +393,7 @@ void CWII_IPC_HLE_Device_hid::FillOutDevices(u32 BufferOut, u32 BufferOutSize)
if (dRet)
{
// could not aquire the descriptor, no point in trying to use it.
DEBUG_LOG(WII_IPC_HID, "libusb_get_device_descriptor failed with error: %d", dRet);
WARN_LOG(WII_IPC_HID, "libusb_get_device_descriptor failed with error: %d", dRet);
continue;
}
OffsetStart = OffsetBuffer;
@ -455,7 +455,7 @@ void CWII_IPC_HLE_Device_hid::FillOutDevices(u32 BufferOut, u32 BufferOutSize)
else
{
if (cRet)
DEBUG_LOG(WII_IPC_HID, "libusb_get_config_descriptor failed with: %d", cRet);
WARN_LOG(WII_IPC_HID, "libusb_get_config_descriptor failed with: %d", cRet);
deviceValid = false;
OffsetBuffer = OffsetStart;
}
@ -482,8 +482,8 @@ void CWII_IPC_HLE_Device_hid::FillOutDevices(u32 BufferOut, u32 BufferOutSize)
continue;
}
DEBUG_LOG(WII_IPC_HID, "Found device with Vendor: %X Product: %X Devnum: %d", desc.idVendor,
desc.idProduct, devNum);
INFO_LOG(WII_IPC_HID, "Found device with Vendor: %X Product: %X Devnum: %d", desc.idVendor,
desc.idProduct, devNum);
Memory::Write_U32(devNum, OffsetStart + 4); // write device num
}
@ -495,7 +495,7 @@ void CWII_IPC_HLE_Device_hid::FillOutDevices(u32 BufferOut, u32 BufferOutSize)
u16 check_cur = (u16)(hidDeviceAliases[i] >> 48);
if (hidDeviceAliases[i] != 0 && check_cur != check)
{
DEBUG_LOG(WII_IPC_HID, "Removing: device %d %hX %hX", i, check, check_cur);
INFO_LOG(WII_IPC_HID, "Removing: device %d %hX %hX", i, check, check_cur);
std::lock_guard<std::mutex> lk(m_open_devices_mutex);
if (m_open_devices.find(i) != m_open_devices.end())
{

28
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_net.cpp
View File

@ -545,18 +545,18 @@ IPCCommandResult CWII_IPC_HLE_Device_net_wd_command::IOCtlV(u32 CommandAddress)
CommandBuffer.NumberInBuffer, CommandBuffer.NumberPayloadBuffer);
for (u32 i = 0; i < CommandBuffer.NumberInBuffer; ++i)
{
INFO_LOG(WII_IPC_NET, "in %i addr %x size %i", i, CommandBuffer.InBuffer.at(i).m_Address,
CommandBuffer.InBuffer.at(i).m_Size);
INFO_LOG(WII_IPC_NET, "%s",
ArrayToString(Memory::GetPointer(CommandBuffer.InBuffer.at(i).m_Address),
CommandBuffer.InBuffer.at(i).m_Size)
.c_str());
DEBUG_LOG(WII_IPC_NET, "in %i addr %x size %i", i, CommandBuffer.InBuffer.at(i).m_Address,
CommandBuffer.InBuffer.at(i).m_Size);
DEBUG_LOG(WII_IPC_NET, "%s",
ArrayToString(Memory::GetPointer(CommandBuffer.InBuffer.at(i).m_Address),
CommandBuffer.InBuffer.at(i).m_Size)
.c_str());
}
for (u32 i = 0; i < CommandBuffer.NumberPayloadBuffer; ++i)
{
INFO_LOG(WII_IPC_NET, "out %i addr %x size %i", i,
CommandBuffer.PayloadBuffer.at(i).m_Address,
CommandBuffer.PayloadBuffer.at(i).m_Size);
DEBUG_LOG(WII_IPC_NET, "out %i addr %x size %i", i,
CommandBuffer.PayloadBuffer.at(i).m_Address,
CommandBuffer.PayloadBuffer.at(i).m_Size);
}
break;
}
@ -703,9 +703,9 @@ IPCCommandResult CWII_IPC_HLE_Device_net_ip_top::IOCtl(u32 _CommandAddress)
u32 fd = Memory::Read_U32(BufferIn);
WiiSockMan& sm = WiiSockMan::GetInstance();
ReturnValue = sm.DeleteSocket(fd);
DEBUG_LOG(WII_IPC_NET, "%s(%x) %x",
Command == IOCTL_SO_ICMPCLOSE ? "IOCTL_SO_ICMPCLOSE" : "IOCTL_SO_CLOSE", fd,
ReturnValue);
INFO_LOG(WII_IPC_NET, "%s(%x) %x",
Command == IOCTL_SO_ICMPCLOSE ? "IOCTL_SO_ICMPCLOSE" : "IOCTL_SO_CLOSE", fd,
ReturnValue);
break;
}
case IOCTL_SO_ACCEPT:
@ -1081,7 +1081,7 @@ IPCCommandResult CWII_IPC_HLE_Device_net_ip_top::IOCtl(u32 _CommandAddress)
{
for (int i = 0; remoteHost->h_aliases[i]; ++i)
{
INFO_LOG(WII_IPC_NET, "alias%i:%s", i, remoteHost->h_aliases[i]);
DEBUG_LOG(WII_IPC_NET, "alias%i:%s", i, remoteHost->h_aliases[i]);
}
for (int i = 0; remoteHost->h_addr_list[i]; ++i)
@ -1488,7 +1488,7 @@ IPCCommandResult CWII_IPC_HLE_Device_net_ip_top::IOCtlV(u32 CommandAddress)
ip_info.length, ip_info.addr_family);
}
DEBUG_LOG(WII_IPC_NET, "IOCTLV_SO_ICMPPING %x", ip_info.ip);
INFO_LOG(WII_IPC_NET, "IOCTLV_SO_ICMPPING %x", ip_info.ip);
sockaddr_in addr;
addr.sin_family = AF_INET;

36
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_sdio_slot0.cpp
View File

@ -69,7 +69,7 @@ void CWII_IPC_HLE_Device_sdio_slot0::OpenInternal()
WARN_LOG(WII_IPC_SD, "Failed to open SD Card image, trying to create a new 128MB image...");
if (SDCardCreate(128, filename))
{
WARN_LOG(WII_IPC_SD, "Successfully created %s", filename.c_str());
INFO_LOG(WII_IPC_SD, "Successfully created %s", filename.c_str());
m_Card.Open(filename, "r+b");
}
if (!m_Card)
@ -128,11 +128,11 @@ IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress)
u32 reg = Memory::Read_U32(BufferIn);
u32 val = Memory::Read_U32(BufferIn + 16);
DEBUG_LOG(WII_IPC_SD, "IOCTL_WRITEHCR 0x%08x - 0x%08x", reg, val);
INFO_LOG(WII_IPC_SD, "IOCTL_WRITEHCR 0x%08x - 0x%08x", reg, val);
if (reg >= 0x200)
{
DEBUG_LOG(WII_IPC_SD, "IOCTL_WRITEHCR out of range");
WARN_LOG(WII_IPC_SD, "IOCTL_WRITEHCR out of range");
break;
}
@ -160,12 +160,12 @@ IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress)
if (reg >= 0x200)
{
DEBUG_LOG(WII_IPC_SD, "IOCTL_READHCR out of range");
WARN_LOG(WII_IPC_SD, "IOCTL_READHCR out of range");
break;
}
u32 val = m_Registers[reg];
DEBUG_LOG(WII_IPC_SD, "IOCTL_READHCR 0x%08x - 0x%08x", reg, val);
INFO_LOG(WII_IPC_SD, "IOCTL_READHCR 0x%08x - 0x%08x", reg, val);
// Just reading the register
Memory::Write_U32(val, BufferOut);
@ -173,7 +173,7 @@ IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress)
break;
case IOCTL_RESETCARD:
DEBUG_LOG(WII_IPC_SD, "IOCTL_RESETCARD");
INFO_LOG(WII_IPC_SD, "IOCTL_RESETCARD");
if (m_Card)
m_Status |= CARD_INITIALIZED;
// Returns 16bit RCA and 16bit 0s (meaning success)
@ -182,7 +182,7 @@ IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress)
case IOCTL_SETCLK:
{
DEBUG_LOG(WII_IPC_SD, "IOCTL_SETCLK");
INFO_LOG(WII_IPC_SD, "IOCTL_SETCLK");
// libogc only sets it to 1 and makes sure the return isn't negative...
// one half of the sdclk divisor: a power of two or zero.
u32 clock = Memory::Read_U32(BufferIn);
@ -208,7 +208,7 @@ IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::IOCtl(u32 _CommandAddress)
break;
case IOCTL_GETOCR:
DEBUG_LOG(WII_IPC_SD, "IOCTL_GETOCR");
INFO_LOG(WII_IPC_SD, "IOCTL_GETOCR");
Memory::Write_U32(0x80ff8000, BufferOut);
break;
@ -267,8 +267,8 @@ IPCCommandResult CWII_IPC_HLE_Device_sdio_slot0::IOCtlV(u32 _CommandAddress)
switch (CommandBuffer.Parameter)
{
case IOCTLV_SENDCMD:
INFO_LOG(WII_IPC_SD, "IOCTLV_SENDCMD 0x%08x",
Memory::Read_U32(CommandBuffer.InBuffer[0].m_Address));
DEBUG_LOG(WII_IPC_SD, "IOCTLV_SENDCMD 0x%08x",
Memory::Read_U32(CommandBuffer.InBuffer[0].m_Address));
ReturnValue = ExecuteCommand(
CommandBuffer.InBuffer[0].m_Address, CommandBuffer.InBuffer[0].m_Size,
CommandBuffer.InBuffer[1].m_Address, CommandBuffer.InBuffer[1].m_Size,
@ -346,7 +346,7 @@ u32 CWII_IPC_HLE_Device_sdio_slot0::ExecuteCommand(u32 _BufferIn, u32 _BufferInS
break;
case SEND_CSD:
DEBUG_LOG(WII_IPC_SD, "SEND_CSD");
INFO_LOG(WII_IPC_SD, "SEND_CSD");
// <WntrMute> shuffle2_, OCR: 0x80ff8000 CID: 0x38a00000 0x480032d5 0x3c608030 0x8803d420
// CSD: 0xff928040 0xc93efbcf 0x325f5a83 0x00002600
@ -359,7 +359,7 @@ u32 CWII_IPC_HLE_Device_sdio_slot0::ExecuteCommand(u32 _BufferIn, u32 _BufferInS
case ALL_SEND_CID:
case SEND_CID:
DEBUG_LOG(WII_IPC_SD, "(ALL_)SEND_CID");
INFO_LOG(WII_IPC_SD, "(ALL_)SEND_CID");
Memory::Write_U32(0x80114d1c, _BufferOut);
Memory::Write_U32(0x80080000, _BufferOut + 4);
Memory::Write_U32(0x8007b520, _BufferOut + 8);
@ -392,8 +392,8 @@ u32 CWII_IPC_HLE_Device_sdio_slot0::ExecuteCommand(u32 _BufferIn, u32 _BufferInS
{
// Data address (req.arg) is in byte units in a Standard Capacity SD Memory Card
// and in block (512 Byte) units in a High Capacity SD Memory Card.
DEBUG_LOG(WII_IPC_SD, "%sRead %i Block(s) from 0x%08x bsize %i into 0x%08x!",
req.isDMA ? "DMA " : "", req.blocks, req.arg, req.bsize, req.addr);
INFO_LOG(WII_IPC_SD, "%sRead %i Block(s) from 0x%08x bsize %i into 0x%08x!",
req.isDMA ? "DMA " : "", req.blocks, req.arg, req.bsize, req.addr);
if (m_Card)
{
@ -421,8 +421,8 @@ u32 CWII_IPC_HLE_Device_sdio_slot0::ExecuteCommand(u32 _BufferIn, u32 _BufferInS
{
// Data address (req.arg) is in byte units in a Standard Capacity SD Memory Card
// and in block (512 Byte) units in a High Capacity SD Memory Card.
DEBUG_LOG(WII_IPC_SD, "%sWrite %i Block(s) from 0x%08x bsize %i to offset 0x%08x!",
req.isDMA ? "DMA " : "", req.blocks, req.addr, req.bsize, req.arg);
INFO_LOG(WII_IPC_SD, "%sWrite %i Block(s) from 0x%08x bsize %i to offset 0x%08x!",
req.isDMA ? "DMA " : "", req.blocks, req.addr, req.bsize, req.arg);
if (m_Card && SConfig::GetInstance().bEnableMemcardSdWriting)
{
@ -443,13 +443,13 @@ u32 CWII_IPC_HLE_Device_sdio_slot0::ExecuteCommand(u32 _BufferIn, u32 _BufferInS
break;
case EVENT_REGISTER: // async
DEBUG_LOG(WII_IPC_SD, "Register event %x", req.arg);
INFO_LOG(WII_IPC_SD, "Register event %x", req.arg);
m_event.type = (EventType)req.arg;
ret = RET_EVENT_REGISTER;
break;
case EVENT_UNREGISTER: // synchronous
DEBUG_LOG(WII_IPC_SD, "Unregister event %x", req.arg);
INFO_LOG(WII_IPC_SD, "Unregister event %x", req.arg);
m_event.type = (EventType)req.arg;
ret = RET_EVENT_UNREGISTER;
break;

104
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_usb.cpp
View File

@ -90,8 +90,8 @@ CWII_IPC_HLE_Device_usb_oh1_57e_305::CWII_IPC_HLE_Device_usb_oh1_57e_305(
memcpy(BT_DINF.registered[i].name, wmName, 20);
memcpy(BT_DINF.active[i].name, wmName, 20);
INFO_LOG(WII_IPC_WIIMOTE, "Wiimote %d BT ID %x,%x,%x,%x,%x,%x", i, tmpBD.b[0], tmpBD.b[1],
tmpBD.b[2], tmpBD.b[3], tmpBD.b[4], tmpBD.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, "Wiimote %d BT ID %x,%x,%x,%x,%x,%x", i, tmpBD.b[0], tmpBD.b[1],
tmpBD.b[2], tmpBD.b[3], tmpBD.b[4], tmpBD.b[5]);
m_WiiMotes.push_back(CWII_IPC_HLE_WiiMote(this, i, tmpBD, false));
i++;
}
@ -308,13 +308,13 @@ IPCCommandResult CWII_IPC_HLE_Device_usb_oh1_57e_305::IOCtlV(u32 _CommandAddress
_dbg_assert_msg_(WII_IPC_WIIMOTE, 0, "Unknown CWII_IPC_HLE_Device_usb_oh1_57e_305: %x",
CommandBuffer.Parameter);
DEBUG_LOG(WII_IPC_WIIMOTE, "%s - IOCtlV:", GetDeviceName().c_str());
DEBUG_LOG(WII_IPC_WIIMOTE, " Parameter: 0x%x", CommandBuffer.Parameter);
DEBUG_LOG(WII_IPC_WIIMOTE, " NumberIn: 0x%08x", CommandBuffer.NumberInBuffer);
DEBUG_LOG(WII_IPC_WIIMOTE, " NumberOut: 0x%08x", CommandBuffer.NumberPayloadBuffer);
DEBUG_LOG(WII_IPC_WIIMOTE, " BufferVector: 0x%08x", CommandBuffer.BufferVector);
DEBUG_LOG(WII_IPC_WIIMOTE, " PayloadAddr: 0x%08x", CommandBuffer.PayloadBuffer[0].m_Address);
DEBUG_LOG(WII_IPC_WIIMOTE, " PayloadSize: 0x%08x", CommandBuffer.PayloadBuffer[0].m_Size);
INFO_LOG(WII_IPC_WIIMOTE, "%s - IOCtlV:", GetDeviceName().c_str());
INFO_LOG(WII_IPC_WIIMOTE, " Parameter: 0x%x", CommandBuffer.Parameter);
INFO_LOG(WII_IPC_WIIMOTE, " NumberIn: 0x%08x", CommandBuffer.NumberInBuffer);
INFO_LOG(WII_IPC_WIIMOTE, " NumberOut: 0x%08x", CommandBuffer.NumberPayloadBuffer);
INFO_LOG(WII_IPC_WIIMOTE, " BufferVector: 0x%08x", CommandBuffer.BufferVector);
INFO_LOG(WII_IPC_WIIMOTE, " PayloadAddr: 0x%08x", CommandBuffer.PayloadBuffer[0].m_Address);
INFO_LOG(WII_IPC_WIIMOTE, " PayloadSize: 0x%08x", CommandBuffer.PayloadBuffer[0].m_Size);
#if defined(_DEBUG) || defined(DEBUGFAST)
DumpAsync(CommandBuffer.BufferVector, CommandBuffer.NumberInBuffer,
CommandBuffer.NumberPayloadBuffer);
@ -335,7 +335,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendToDevice(u16 _ConnectionHandle, u8
if (pWiiMote == nullptr)
return;
INFO_LOG(WII_IPC_WIIMOTE, "Send ACL Packet to ConnectionHandle 0x%04x", _ConnectionHandle);
DEBUG_LOG(WII_IPC_WIIMOTE, "Send ACL Packet to ConnectionHandle 0x%04x", _ConnectionHandle);
IncDataPacket(_ConnectionHandle);
pWiiMote->ExecuteL2capCmd(_pData, _Size);
}
@ -565,7 +565,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventInquiryComplete()
AddEventToQueue(Event);
INFO_LOG(WII_IPC_WIIMOTE, "Event: Inquiry complete");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: Inquiry complete");
return true;
}
@ -609,10 +609,10 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventInquiryResponse()
pResponse->page_scan_mode = 0;
pResponse->clock_offset = 0x3818;
INFO_LOG(WII_IPC_WIIMOTE, "Event: Send Fake Inquiry of one controller");
INFO_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", pResponse->bdaddr.b[0],
pResponse->bdaddr.b[1], pResponse->bdaddr.b[2], pResponse->bdaddr.b[3],
pResponse->bdaddr.b[4], pResponse->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: Send Fake Inquiry of one controller");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", pResponse->bdaddr.b[0],
pResponse->bdaddr.b[1], pResponse->bdaddr.b[2], pResponse->bdaddr.b[3],
pResponse->bdaddr.b[4], pResponse->bdaddr.b[5]);
}
AddEventToQueue(Event);
@ -650,8 +650,8 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventConnectionComplete(const bdad
{"HCI_LINK_eSCO 0x02 - eSCO"},
};
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventConnectionComplete");
INFO_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pConnectionComplete->Connection_Handle);
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventConnectionComplete");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pConnectionComplete->Connection_Handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pConnectionComplete->bdaddr.b[0], pConnectionComplete->bdaddr.b[1],
pConnectionComplete->bdaddr.b[2], pConnectionComplete->bdaddr.b[3],
@ -686,11 +686,11 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestConnection(
{"HCI_LINK_eSCO 0x02 - eSCO"},
};
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventRequestConnection");
INFO_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pEventRequestConnection->bdaddr.b[0], pEventRequestConnection->bdaddr.b[1],
pEventRequestConnection->bdaddr.b[2], pEventRequestConnection->bdaddr.b[3],
pEventRequestConnection->bdaddr.b[4], pEventRequestConnection->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventRequestConnection");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pEventRequestConnection->bdaddr.b[0], pEventRequestConnection->bdaddr.b[1],
pEventRequestConnection->bdaddr.b[2], pEventRequestConnection->bdaddr.b[3],
pEventRequestConnection->bdaddr.b[4], pEventRequestConnection->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[0]: 0x%02x", pEventRequestConnection->uclass[0]);
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[1]: 0x%02x", pEventRequestConnection->uclass[1]);
DEBUG_LOG(WII_IPC_WIIMOTE, " COD[2]: 0x%02x", pEventRequestConnection->uclass[2]);
@ -716,9 +716,9 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventDisconnect(u16 _connectionHan
AddEventToQueue(Event);
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventDisconnect");
INFO_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pDisconnect->Connection_Handle);
INFO_LOG(WII_IPC_WIIMOTE, " Reason: 0x%02x", pDisconnect->Reason);
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventDisconnect");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pDisconnect->Connection_Handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " Reason: 0x%02x", pDisconnect->Reason);
return true;
}
@ -738,9 +738,9 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventAuthenticationCompleted(u16 _
pEventAuthenticationCompleted->EventStatus = 0;
pEventAuthenticationCompleted->Connection_Handle = _connectionHandle;
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventAuthenticationCompleted");
INFO_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x",
pEventAuthenticationCompleted->Connection_Handle);
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventAuthenticationCompleted");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x",
pEventAuthenticationCompleted->Connection_Handle);
AddEventToQueue(Event);
@ -763,10 +763,10 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRemoteNameReq(const bdaddr_t&
pRemoteNameReq->bdaddr = _bd;
strcpy((char*)pRemoteNameReq->RemoteName, pWiiMote->GetName());
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventRemoteNameReq");
INFO_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", pRemoteNameReq->bdaddr.b[0],
pRemoteNameReq->bdaddr.b[1], pRemoteNameReq->bdaddr.b[2], pRemoteNameReq->bdaddr.b[3],
pRemoteNameReq->bdaddr.b[4], pRemoteNameReq->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventRemoteNameReq");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", pRemoteNameReq->bdaddr.b[0],
pRemoteNameReq->bdaddr.b[1], pRemoteNameReq->bdaddr.b[2], pRemoteNameReq->bdaddr.b[3],
pRemoteNameReq->bdaddr.b[4], pRemoteNameReq->bdaddr.b[5]);
DEBUG_LOG(WII_IPC_WIIMOTE, " RemoteName: %s", pRemoteNameReq->RemoteName);
AddEventToQueue(Event);
@ -797,7 +797,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventReadRemoteFeatures(u16 _conne
pReadRemoteFeatures->features[6] = pWiiMote->GetFeatures()[6];
pReadRemoteFeatures->features[7] = pWiiMote->GetFeatures()[7];
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventReadRemoteFeatures");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventReadRemoteFeatures");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pReadRemoteFeatures->ConnectionHandle);
DEBUG_LOG(WII_IPC_WIIMOTE, " features: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
pReadRemoteFeatures->features[0], pReadRemoteFeatures->features[1],
@ -827,7 +827,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventReadRemoteVerInfo(u16 _connec
pReadRemoteVerInfo->manufacturer = pWiiMote->GetManufactorID();
pReadRemoteVerInfo->lmp_subversion = pWiiMote->GetLMPSubVersion();
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventReadRemoteVerInfo");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventReadRemoteVerInfo");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pReadRemoteVerInfo->ConnectionHandle);
DEBUG_LOG(WII_IPC_WIIMOTE, " lmp_version: 0x%02x", pReadRemoteVerInfo->lmp_version);
DEBUG_LOG(WII_IPC_WIIMOTE, " manufacturer: 0x%04x", pReadRemoteVerInfo->manufacturer);
@ -858,7 +858,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventCommandComplete(u16 opcode, c
memcpy(payload, data, data_size);
}
INFO_LOG(WII_IPC_WIIMOTE, "Event: Command Complete (Opcode: 0x%04x)", hci_event->Opcode);
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: Command Complete (Opcode: 0x%04x)", hci_event->Opcode);
AddEventToQueue(event);
}
@ -899,7 +899,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRoleChange(bdaddr_t _bd, bool
AddEventToQueue(Event);
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventRoleChange");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventRoleChange");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x", pRoleChange->bdaddr.b[0],
pRoleChange->bdaddr.b[1], pRoleChange->bdaddr.b[2], pRoleChange->bdaddr.b[3],
pRoleChange->bdaddr.b[4], pRoleChange->bdaddr.b[5]);
@ -914,7 +914,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventNumberOfCompletedPackets()
(sizeof(hci_num_compl_pkts_info) * m_WiiMotes.size())),
0);
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventNumberOfCompletedPackets");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventNumberOfCompletedPackets");
hci_event_hdr_t* event_hdr = (hci_event_hdr_t*)Event.m_buffer;
hci_num_compl_pkts_ep* event = (hci_num_compl_pkts_ep*)((u8*)event_hdr + sizeof(hci_event_hdr_t));
@ -948,7 +948,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventNumberOfCompletedPackets()
}
else
{
INFO_LOG(WII_IPC_WIIMOTE, "SendEventNumberOfCompletedPackets: no packets; no event");
DEBUG_LOG(WII_IPC_WIIMOTE, "SendEventNumberOfCompletedPackets: no packets; no event");
}
return true;
@ -971,7 +971,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventModeChange(u16 _connectionHan
pModeChange->CurrentMode = _mode;
pModeChange->Value = _value;
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventModeChange");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventModeChange");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pModeChange->Connection_Handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " Current Mode: 0x%02x", pModeChange->CurrentMode = _mode);
@ -986,7 +986,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventLinkKeyNotification(const u8
SQueuedEvent Event(2 + payload_length, 0);
SHCIEventLinkKeyNotification* pEventLinkKey = (SHCIEventLinkKeyNotification*)Event.m_buffer;
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventLinkKeyNotification");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventLinkKeyNotification");
// event header
pEventLinkKey->EventType = HCI_EVENT_RETURN_LINK_KEYS;
@ -1024,7 +1024,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventRequestLinkKey(const bdaddr_t
pEventRequestLinkKey->PayloadLength = sizeof(SHCIEventRequestLinkKey) - 2;
pEventRequestLinkKey->bdaddr = _bd;
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventRequestLinkKey");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventRequestLinkKey");
DEBUG_LOG(WII_IPC_WIIMOTE, " bd: %02x:%02x:%02x:%02x:%02x:%02x",
pEventRequestLinkKey->bdaddr.b[0], pEventRequestLinkKey->bdaddr.b[1],
pEventRequestLinkKey->bdaddr.b[2], pEventRequestLinkKey->bdaddr.b[3],
@ -1051,7 +1051,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventReadClockOffsetComplete(u16 _
pReadClockOffsetComplete->ConnectionHandle = _connectionHandle;
pReadClockOffsetComplete->ClockOffset = 0x3818;
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventReadClockOffsetComplete");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventReadClockOffsetComplete");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x",
pReadClockOffsetComplete->ConnectionHandle);
DEBUG_LOG(WII_IPC_WIIMOTE, " ClockOffset: 0x%04x", pReadClockOffsetComplete->ClockOffset);
@ -1078,7 +1078,7 @@ bool CWII_IPC_HLE_Device_usb_oh1_57e_305::SendEventConPacketTypeChange(u16 _conn
pChangeConPacketType->ConnectionHandle = _connectionHandle;
pChangeConPacketType->PacketType = _packetType;
INFO_LOG(WII_IPC_WIIMOTE, "Event: SendEventConPacketTypeChange");
DEBUG_LOG(WII_IPC_WIIMOTE, "Event: SendEventConPacketTypeChange");
DEBUG_LOG(WII_IPC_WIIMOTE, " Connection_Handle: 0x%04x", pChangeConPacketType->ConnectionHandle);
DEBUG_LOG(WII_IPC_WIIMOTE, " PacketType: 0x%04x", pChangeConPacketType->PacketType);
@ -1098,9 +1098,9 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::ExecuteHCICommandMessage(
u16 ocf = HCI_OCF(pMsg->Opcode);
u16 ogf = HCI_OGF(pMsg->Opcode);
INFO_LOG(WII_IPC_WIIMOTE, "**************************************************");
INFO_LOG(WII_IPC_WIIMOTE, "Execute HCI Command: 0x%04x (ocf: 0x%02x, ogf: 0x%02x)", pMsg->Opcode,
ocf, ogf);
DEBUG_LOG(WII_IPC_WIIMOTE, "**************************************************");
DEBUG_LOG(WII_IPC_WIIMOTE, "Execute HCI Command: 0x%04x (ocf: 0x%02x, ogf: 0x%02x)", pMsg->Opcode,
ocf, ogf);
switch (pMsg->Opcode)
{
@ -1491,7 +1491,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandSniffMode(const u8* input)
const hci_sniff_mode_cp* sniff_mode = reinterpret_cast<const hci_sniff_mode_cp*>(input);
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_SNIFF_MODE");
INFO_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", sniff_mode->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " ConnectionHandle: 0x%04x", sniff_mode->con_handle);
DEBUG_LOG(WII_IPC_WIIMOTE, " max_interval: %f msec", sniff_mode->max_interval * .625);
DEBUG_LOG(WII_IPC_WIIMOTE, " min_interval: %f msec", sniff_mode->min_interval * .625);
DEBUG_LOG(WII_IPC_WIIMOTE, " attempt: %f msec", sniff_mode->attempt * 1.25);
@ -1662,8 +1662,8 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandWriteScanEnable(const u8* input
{"HCI_INQUIRY_AND_PAGE_SCAN_ENABLE"},
};
INFO_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_SCAN_ENABLE: (0x%02x)",
write_scan_enable->scan_enable);
DEBUG_LOG(WII_IPC_WIIMOTE, "Command: HCI_CMD_WRITE_SCAN_ENABLE: (0x%02x)",
write_scan_enable->scan_enable);
DEBUG_LOG(WII_IPC_WIIMOTE, " scan_enable: %s", scanning[write_scan_enable->scan_enable]);
SendEventCommandComplete(HCI_CMD_WRITE_SCAN_ENABLE, &reply, sizeof(hci_write_scan_enable_rp));
@ -1864,7 +1864,7 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4F(const u8* i
reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4F: (callstack WUDiRemovePatch)");
INFO_LOG(WII_IPC_WIIMOTE, "Input (size 0x%x):", size);
DEBUG_LOG(WII_IPC_WIIMOTE, "Input (size 0x%x):", size);
Dolphin_Debugger::PrintDataBuffer(LogTypes::WII_IPC_WIIMOTE, input, size, "Data: ");
@ -1876,8 +1876,8 @@ void CWII_IPC_HLE_Device_usb_oh1_57e_305::CommandVendorSpecific_FC4C(const u8* i
hci_status_rp reply;
reply.status = 0x00;
INFO_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4C:");
INFO_LOG(WII_IPC_WIIMOTE, "Input (size 0x%x):", size);
DEBUG_LOG(WII_IPC_WIIMOTE, "Command: CommandVendorSpecific_FC4C:");
DEBUG_LOG(WII_IPC_WIIMOTE, "Input (size 0x%x):", size);
Dolphin_Debugger::PrintDataBuffer(LogTypes::WII_IPC_WIIMOTE, input, size, "Data: ");
SendEventCommandComplete(0xFC4C, &reply, sizeof(hci_status_rp));

2
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_usb_kbd.cpp
View File

@ -58,7 +58,7 @@ IPCCommandResult CWII_IPC_HLE_Device_usb_kbd::Close(u32 _CommandAddress, bool _b
IPCCommandResult CWII_IPC_HLE_Device_usb_kbd::Write(u32 _CommandAddress)
{
INFO_LOG(WII_IPC_STM, "Ignoring write to CWII_IPC_HLE_Device_usb_kbd");
DEBUG_LOG(WII_IPC_STM, "Ignoring write to CWII_IPC_HLE_Device_usb_kbd");
#if defined(_DEBUG) || defined(DEBUGFAST)
DumpCommands(_CommandAddress, 10, LogTypes::WII_IPC_STM, LogTypes::LDEBUG);
#endif

14
Source/Core/Core/IPC_HLE/WII_IPC_HLE_Device_usb_ven.cpp
View File

@ -36,11 +36,11 @@ IPCCommandResult CWII_IPC_HLE_Device_usb_ven::IOCtlV(u32 _CommandAddress)
{
SIOCtlVBuffer CommandBuffer(_CommandAddress);
DEBUG_LOG(OSHLE, "%s - IOCtlV:", GetDeviceName().c_str());
DEBUG_LOG(OSHLE, " Parameter: 0x%x", CommandBuffer.Parameter);
DEBUG_LOG(OSHLE, " NumberIn: 0x%08x", CommandBuffer.NumberInBuffer);
DEBUG_LOG(OSHLE, " NumberOut: 0x%08x", CommandBuffer.NumberPayloadBuffer);
DEBUG_LOG(OSHLE, " BufferVector: 0x%08x", CommandBuffer.BufferVector);
INFO_LOG(OSHLE, "%s - IOCtlV:", GetDeviceName().c_str());
INFO_LOG(OSHLE, " Parameter: 0x%x", CommandBuffer.Parameter);
INFO_LOG(OSHLE, " NumberIn: 0x%08x", CommandBuffer.NumberInBuffer);
INFO_LOG(OSHLE, " NumberOut: 0x%08x", CommandBuffer.NumberPayloadBuffer);
INFO_LOG(OSHLE, " BufferVector: 0x%08x", CommandBuffer.BufferVector);
DumpAsync(CommandBuffer.BufferVector, CommandBuffer.NumberInBuffer,
CommandBuffer.NumberPayloadBuffer);
@ -57,8 +57,8 @@ IPCCommandResult CWII_IPC_HLE_Device_usb_ven::IOCtl(u32 _CommandAddress)
u32 BufferOut = Memory::Read_U32(_CommandAddress + 0x18);
u32 BufferOutSize = Memory::Read_U32(_CommandAddress + 0x1c);
DEBUG_LOG(OSHLE, "%s - IOCtl: %x", GetDeviceName().c_str(), Command);
DEBUG_LOG(OSHLE, "%x:%x %x:%x", BufferIn, BufferInSize, BufferOut, BufferOutSize);
INFO_LOG(OSHLE, "%s - IOCtl: %x", GetDeviceName().c_str(), Command);
INFO_LOG(OSHLE, "%x:%x %x:%x", BufferIn, BufferInSize, BufferOut, BufferOutSize);
switch (Command)
{

36
Source/Core/Core/IPC_HLE/WII_IPC_HLE_WiiMote.cpp
View File

@ -36,7 +36,7 @@ CWII_IPC_HLE_WiiMote::CWII_IPC_HLE_WiiMote(CWII_IPC_HLE_Device_usb_oh1_57e_305*
m_Name(_Number == WIIMOTE_BALANCE_BOARD ? "Nintendo RVL-WBC-01" : "Nintendo RVL-CNT-01"),
m_pHost(_pHost)
{
DEBUG_LOG(WII_IPC_WIIMOTE, "Wiimote: #%i Constructed", _Number);
INFO_LOG(WII_IPC_WIIMOTE, "Wiimote: #%i Constructed", _Number);
m_ConnectionState = (ready) ? CONN_READY : CONN_INACTIVE;
m_ConnectionHandle = 0x100 + _Number;
@ -240,8 +240,8 @@ void CWII_IPC_HLE_WiiMote::ExecuteL2capCmd(u8* _pData, u32 _Size)
l2cap_hdr_t* pHeader = (l2cap_hdr_t*)_pData;
u8* pData = _pData + sizeof(l2cap_hdr_t);
u32 DataSize = _Size - sizeof(l2cap_hdr_t);
INFO_LOG(WII_IPC_WIIMOTE, " CID 0x%04x, Len 0x%x, DataSize 0x%x", pHeader->dcid, pHeader->length,
DataSize);
DEBUG_LOG(WII_IPC_WIIMOTE, " CID 0x%04x, Len 0x%x, DataSize 0x%x", pHeader->dcid,
pHeader->length, DataSize);
if (pHeader->length != DataSize)
{
@ -367,7 +367,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size
rChannel.SCID = pCommandConnectionReq->scid;
rChannel.DCID = pCommandConnectionReq->scid;
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConnectionRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConnectionRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident);
DEBUG_LOG(WII_IPC_WIIMOTE, " PSM: 0x%04x", rChannel.PSM);
DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", rChannel.SCID);
@ -380,7 +380,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConnectionReq(u8 _Ident, u8* _pData, u32 _Size
Rsp.result = L2CAP_SUCCESS;
Rsp.status = L2CAP_NO_INFO;
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConnectionResponse");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConnectionResponse");
SendCommandToACL(_Ident, L2CAP_CONNECT_RSP, sizeof(l2cap_con_rsp_cp), (u8*)&Rsp);
// update state machine
@ -398,7 +398,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConnectionResponse(u8 _Ident, u8* _pData, u32
_dbg_assert_(WII_IPC_WIIMOTE, _Size == sizeof(l2cap_con_rsp_cp));
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConnectionResponse");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConnectionResponse");
DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", rsp->dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", rsp->scid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Result: 0x%04x", rsp->result);
@ -429,7 +429,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _S
SChannel& rChannel = m_Channel[pCommandConfigReq->dcid];
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConfigurationRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConfigurationRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident);
DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", pCommandConfigReq->dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Flags: 0x%04x", pCommandConfigReq->flags);
@ -484,7 +484,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationReq(u8 _Ident, u8* _pData, u32 _S
RespLen += OptionSize;
}
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConfigurationResponse");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConfigurationResponse");
SendCommandToACL(_Ident, L2CAP_CONFIG_RSP, RespLen, TempBuffer);
// update state machine
@ -498,7 +498,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveConfigurationResponse(u8 _Ident, u8* _pData, u
{
l2cap_cfg_rsp_cp* rsp = (l2cap_cfg_rsp_cp*)_pData;
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConfigurationResponse");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveConfigurationResponse");
DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", rsp->scid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Flags: 0x%04x", rsp->flags);
DEBUG_LOG(WII_IPC_WIIMOTE, " Result: 0x%04x", rsp->result);
@ -518,7 +518,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveDisconnectionReq(u8 _Ident, u8* _pData, u32 _S
{
l2cap_discon_req_cp* pCommandDisconnectionReq = (l2cap_discon_req_cp*)_pData;
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveDisconnectionReq");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] ReceiveDisconnectionReq");
DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident);
DEBUG_LOG(WII_IPC_WIIMOTE, " DCID: 0x%04x", pCommandDisconnectionReq->dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " SCID: 0x%04x", pCommandDisconnectionReq->scid);
@ -528,7 +528,7 @@ void CWII_IPC_HLE_WiiMote::ReceiveDisconnectionReq(u8 _Ident, u8* _pData, u32 _S
Rsp.dcid = pCommandDisconnectionReq->dcid;
Rsp.scid = pCommandDisconnectionReq->scid;
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendDisconnectionResponse");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendDisconnectionResponse");
SendCommandToACL(_Ident, L2CAP_DISCONNECT_RSP, sizeof(l2cap_discon_req_cp), (u8*)&Rsp);
}
@ -555,7 +555,7 @@ void CWII_IPC_HLE_WiiMote::SendConnectionRequest(u16 scid, u16 psm)
cr.psm = psm;
cr.scid = scid;
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConnectionRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConnectionRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Psm: 0x%04x", cr.psm);
DEBUG_LOG(WII_IPC_WIIMOTE, " Scid: 0x%04x", cr.scid);
@ -572,7 +572,7 @@ void CWII_IPC_HLE_WiiMote::SendDisconnectRequest(u16 scid)
cr.dcid = rChannel.DCID;
cr.scid = rChannel.SCID;
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendDisconnectionRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendDisconnectionRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Dcid: 0x%04x", cr.dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Scid: 0x%04x", cr.scid);
@ -593,7 +593,7 @@ void CWII_IPC_HLE_WiiMote::SendConfigurationRequest(u16 scid, u16 MTU, u16 Flush
cr->flags = 0;
Offset += sizeof(l2cap_cfg_req_cp);
INFO_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConfigurationRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, "[L2CAP] SendConfigurationRequest");
DEBUG_LOG(WII_IPC_WIIMOTE, " Dcid: 0x%04x", cr->dcid);
DEBUG_LOG(WII_IPC_WIIMOTE, " Flags: 0x%04x", cr->flags);
@ -741,7 +741,7 @@ static int ParseAttribList(u8* pAttribIDList, u16& _startID, u16& _endID)
_startID = attribList.Read16(attribOffset);
attribOffset += 2;
_endID = _startID;
DEBUG_LOG(WII_IPC_WIIMOTE, "Read just a single attrib - not tested");
WARN_LOG(WII_IPC_WIIMOTE, "Read just a single attrib - not tested");
PanicAlert("Read just a single attrib - not tested");
}
@ -876,7 +876,7 @@ void CWII_IPC_HLE_WiiMote::SendCommandToACL(u8 _Ident, u8 _Code, u8 _CommandLeng
memcpy(&DataFrame[Offset], _pCommandData, _CommandLength);
INFO_LOG(WII_IPC_WIIMOTE, "Send ACL Command to CPU");
DEBUG_LOG(WII_IPC_WIIMOTE, "Send ACL Command to CPU");
DEBUG_LOG(WII_IPC_WIIMOTE, " Ident: 0x%02x", _Ident);
DEBUG_LOG(WII_IPC_WIIMOTE, " Code: 0x%02x", _Code);
@ -923,8 +923,8 @@ void Callback_WiimoteInterruptChannel(int _number, u16 _channelID, const void* _
{
const u8* pData = (const u8*)_pData;
INFO_LOG(WIIMOTE, "====================");
INFO_LOG(WIIMOTE, "Callback_WiimoteInterruptChannel: (Wiimote: #%i)", _number);
DEBUG_LOG(WIIMOTE, "====================");
DEBUG_LOG(WIIMOTE, "Callback_WiimoteInterruptChannel: (Wiimote: #%i)", _number);
DEBUG_LOG(WIIMOTE, " Data: %s", ArrayToString(pData, _Size, 50).c_str());
DEBUG_LOG(WIIMOTE, " Channel: %x", _channelID);

18
Source/Core/Core/IPC_HLE/WII_Socket.cpp
View File

@ -97,8 +97,8 @@ s32 WiiSockMan::GetNetErrorCode(s32 ret, const char* caller, bool isRW)
return ret;
}
INFO_LOG(WII_IPC_NET, "%s failed with error %d: %s, ret= %d", caller, errorCode,
DecodeError(errorCode), ret);
ERROR_LOG(WII_IPC_NET, "%s failed with error %d: %s, ret= %d", caller, errorCode,
DecodeError(errorCode), ret);
s32 ReturnValue = TranslateErrorCode(errorCode, isRW);
WiiSockMan::GetInstance().SetLastNetError(ReturnValue);
@ -449,13 +449,13 @@ void WiiSocket::Update(bool read, bool write, bool except)
has_destaddr ? sizeof(sockaddr) : 0);
ReturnValue = WiiSockMan::GetNetErrorCode(ret, "SO_SENDTO", true);
INFO_LOG(WII_IPC_NET,
"%s = %d Socket: %08x, BufferIn: (%08x, %i), BufferIn2: (%08x, %i), %u.%u.%u.%u",
has_destaddr ? "IOCTLV_SO_SENDTO " : "IOCTLV_SO_SEND ", ReturnValue, fd,
BufferIn, BufferInSize, BufferIn2, BufferInSize2,
local_name.sin_addr.s_addr & 0xFF, (local_name.sin_addr.s_addr >> 8) & 0xFF,
(local_name.sin_addr.s_addr >> 16) & 0xFF,
(local_name.sin_addr.s_addr >> 24) & 0xFF);
DEBUG_LOG(
WII_IPC_NET,
"%s = %d Socket: %08x, BufferIn: (%08x, %i), BufferIn2: (%08x, %i), %u.%u.%u.%u",
has_destaddr ? "IOCTLV_SO_SENDTO " : "IOCTLV_SO_SEND ", ReturnValue, fd, BufferIn,
BufferInSize, BufferIn2, BufferInSize2, local_name.sin_addr.s_addr & 0xFF,
(local_name.sin_addr.s_addr >> 8) & 0xFF, (local_name.sin_addr.s_addr >> 16) & 0xFF,
(local_name.sin_addr.s_addr >> 24) & 0xFF);
break;
}
case IOCTLV_SO_RECVFROM:

6
Source/Core/Core/PowerPC/Interpreter/Interpreter_SystemRegisters.cpp
View File

@ -306,7 +306,7 @@ void Interpreter::mtspr(UGeckoInstruction _inst)
case SPR_HID4:
if (oldValue != rSPR(iIndex))
{
WARN_LOG(POWERPC, "HID4 updated %x %x", oldValue, rSPR(iIndex));
INFO_LOG(POWERPC, "HID4 updated %x %x", oldValue, rSPR(iIndex));
PowerPC::IBATUpdated();
PowerPC::DBATUpdated();
}
@ -388,7 +388,7 @@ void Interpreter::mtspr(UGeckoInstruction _inst)
case SPR_DBAT7U:
if (oldValue != rSPR(iIndex))
{
WARN_LOG(POWERPC, "DBAT updated %d %x %x", iIndex, oldValue, rSPR(iIndex));
INFO_LOG(POWERPC, "DBAT updated %d %x %x", iIndex, oldValue, rSPR(iIndex));
PowerPC::DBATUpdated();
}
break;
@ -411,7 +411,7 @@ void Interpreter::mtspr(UGeckoInstruction _inst)
case SPR_IBAT7U:
if (oldValue != rSPR(iIndex))
{
WARN_LOG(POWERPC, "IBAT updated %d %x %x", iIndex, oldValue, rSPR(iIndex));
INFO_LOG(POWERPC, "IBAT updated %d %x %x", iIndex, oldValue, rSPR(iIndex));
PowerPC::IBATUpdated();
}
break;

2
Source/Core/Core/PowerPC/Jit64/Jit.cpp
View File

@ -341,7 +341,7 @@ static void ImHere()
if ((been_here.find(PC)->second) & 1023)
return;
}
DEBUG_LOG(DYNA_REC, "I'm here - PC = %08x , LR = %08x", PC, LR);
INFO_LOG(DYNA_REC, "I'm here - PC = %08x , LR = %08x", PC, LR);
been_here[PC] = 1;
}

2
Source/Core/Core/PowerPC/Jit64IL/JitIL.cpp
View File

@ -345,7 +345,7 @@ static void ImHere()
return;
}
DEBUG_LOG(DYNA_REC, "I'm here - PC = %08x , LR = %08x", PC, LR);
INFO_LOG(DYNA_REC, "I'm here - PC = %08x , LR = %08x", PC, LR);
been_here[PC] = 1;
}

8
Source/Core/Core/PowerPC/PPCSymbolDB.cpp
View File

@ -147,13 +147,13 @@ void PPCSymbolDB::PrintCalls(u32 funcAddr) const
if (iter != functions.end())
{
const Symbol& f = iter->second;
INFO_LOG(OSHLE, "The function %s at %08x calls:", f.name.c_str(), f.address);
DEBUG_LOG(OSHLE, "The function %s at %08x calls:", f.name.c_str(), f.address);
for (const SCall& call : f.calls)
{
XFuncMap::const_iterator n = functions.find(call.function);
if (n != functions.end())
{
INFO_LOG(CONSOLE, "* %08x : %s", call.callAddress, n->second.name.c_str());
DEBUG_LOG(CONSOLE, "* %08x : %s", call.callAddress, n->second.name.c_str());
}
}
}
@ -169,13 +169,13 @@ void PPCSymbolDB::PrintCallers(u32 funcAddr) const
if (iter != functions.end())
{
const Symbol& f = iter->second;
INFO_LOG(CONSOLE, "The function %s at %08x is called by:", f.name.c_str(), f.address);
DEBUG_LOG(CONSOLE, "The function %s at %08x is called by:", f.name.c_str(), f.address);
for (const SCall& caller : f.callers)
{
XFuncMap::const_iterator n = functions.find(caller.function);
if (n != functions.end())
{
INFO_LOG(CONSOLE, "* %08x : %s", caller.callAddress, n->second.name.c_str());
DEBUG_LOG(CONSOLE, "* %08x : %s", caller.callAddress, n->second.name.c_str());
}
}
}

18
Source/Core/Core/PowerPC/PowerPC.cpp
View File

@ -371,7 +371,7 @@ void CheckExceptions()
MSR &= ~0x04EF36;
PC = NPC = 0x00000400;
INFO_LOG(POWERPC, "EXCEPTION_ISI");
DEBUG_LOG(POWERPC, "EXCEPTION_ISI");
ppcState.Exceptions &= ~EXCEPTION_ISI;
}
else if (exceptions & EXCEPTION_PROGRAM)
@ -383,7 +383,7 @@ void CheckExceptions()
MSR &= ~0x04EF36;
PC = NPC = 0x00000700;
INFO_LOG(POWERPC, "EXCEPTION_PROGRAM");
DEBUG_LOG(POWERPC, "EXCEPTION_PROGRAM");
ppcState.Exceptions &= ~EXCEPTION_PROGRAM;
}
else if (exceptions & EXCEPTION_SYSCALL)
@ -394,7 +394,7 @@ void CheckExceptions()
MSR &= ~0x04EF36;
PC = NPC = 0x00000C00;
INFO_LOG(POWERPC, "EXCEPTION_SYSCALL (PC=%08x)", PC);
DEBUG_LOG(POWERPC, "EXCEPTION_SYSCALL (PC=%08x)", PC);
ppcState.Exceptions &= ~EXCEPTION_SYSCALL;
}
else if (exceptions & EXCEPTION_FPU_UNAVAILABLE)
@ -406,7 +406,7 @@ void CheckExceptions()
MSR &= ~0x04EF36;
PC = NPC = 0x00000800;
INFO_LOG(POWERPC, "EXCEPTION_FPU_UNAVAILABLE");
DEBUG_LOG(POWERPC, "EXCEPTION_FPU_UNAVAILABLE");
ppcState.Exceptions &= ~EXCEPTION_FPU_UNAVAILABLE;
}
else if (exceptions & EXCEPTION_FAKE_MEMCHECK_HIT)
@ -422,7 +422,7 @@ void CheckExceptions()
PC = NPC = 0x00000300;
// DSISR and DAR regs are changed in GenerateDSIException()
INFO_LOG(POWERPC, "EXCEPTION_DSI");
DEBUG_LOG(POWERPC, "EXCEPTION_DSI");
ppcState.Exceptions &= ~EXCEPTION_DSI;
}
else if (exceptions & EXCEPTION_ALIGNMENT)
@ -437,7 +437,7 @@ void CheckExceptions()
// TODO crazy amount of DSISR options to check out
INFO_LOG(POWERPC, "EXCEPTION_ALIGNMENT");
DEBUG_LOG(POWERPC, "EXCEPTION_ALIGNMENT");
ppcState.Exceptions &= ~EXCEPTION_ALIGNMENT;
}
@ -464,7 +464,7 @@ void CheckExternalExceptions()
MSR &= ~0x04EF36;
PC = NPC = 0x00000500;
INFO_LOG(POWERPC, "EXCEPTION_EXTERNAL_INT");
DEBUG_LOG(POWERPC, "EXCEPTION_EXTERNAL_INT");
ppcState.Exceptions &= ~EXCEPTION_EXTERNAL_INT;
_dbg_assert_msg_(POWERPC, (SRR1 & 0x02) != 0, "EXTERNAL_INT unrecoverable???");
@ -477,7 +477,7 @@ void CheckExternalExceptions()
MSR &= ~0x04EF36;
PC = NPC = 0x00000F00;
INFO_LOG(POWERPC, "EXCEPTION_PERFORMANCE_MONITOR");
DEBUG_LOG(POWERPC, "EXCEPTION_PERFORMANCE_MONITOR");
ppcState.Exceptions &= ~EXCEPTION_PERFORMANCE_MONITOR;
}
else if (exceptions & EXCEPTION_DECREMENTER)
@ -488,7 +488,7 @@ void CheckExternalExceptions()
MSR &= ~0x04EF36;
PC = NPC = 0x00000900;
INFO_LOG(POWERPC, "EXCEPTION_DECREMENTER");
DEBUG_LOG(POWERPC, "EXCEPTION_DECREMENTER");
ppcState.Exceptions &= ~EXCEPTION_DECREMENTER;
}
else

4
Source/Core/Core/PowerPC/SignatureDB.cpp
View File

@ -92,8 +92,8 @@ void SignatureDB::List()
{
for (const auto& entry : database)
{
INFO_LOG(OSHLE, "%s : %i bytes, hash = %08x", entry.second.name.c_str(), entry.second.size,
entry.first);
DEBUG_LOG(OSHLE, "%s : %i bytes, hash = %08x", entry.second.name.c_str(), entry.second.size,
entry.first);
}
INFO_LOG(OSHLE, "%zu functions known in current database.", database.size());
}

8
Source/Core/DiscIO/VolumeWiiCrypted.cpp
View File

@ -333,7 +333,7 @@ bool CVolumeWiiCrypted::CheckIntegrity() const
u8 IV[16] = {0};
if (!m_pReader->Read(clusterOff, 0x400, clusterMDCrypted))
{
NOTICE_LOG(DISCIO, "Integrity Check: fail at cluster %d: could not read metadata", clusterID);
WARN_LOG(DISCIO, "Integrity Check: fail at cluster %d: could not read metadata", clusterID);
return false;
}
mbedtls_aes_crypt_cbc(m_AES_ctx.get(), MBEDTLS_AES_DECRYPT, 0x400, IV, clusterMDCrypted,
@ -358,7 +358,7 @@ bool CVolumeWiiCrypted::CheckIntegrity() const
u8 clusterData[0x7C00];
if (!Read((u64)clusterID * 0x7C00, 0x7C00, clusterData, true))
{
NOTICE_LOG(DISCIO, "Integrity Check: fail at cluster %d: could not read data", clusterID);
WARN_LOG(DISCIO, "Integrity Check: fail at cluster %d: could not read data", clusterID);
return false;
}
@ -371,8 +371,8 @@ bool CVolumeWiiCrypted::CheckIntegrity() const
// Note that we do not use strncmp here
if (memcmp(hash, clusterMD + hashID * 20, 20))
{
NOTICE_LOG(DISCIO, "Integrity Check: fail at cluster %d: hash %d is invalid", clusterID,
hashID);
WARN_LOG(DISCIO, "Integrity Check: fail at cluster %d: hash %d is invalid", clusterID,
hashID);
return false;
}
}

14
Source/Core/DolphinWX/ISOProperties.cpp
View File

@ -842,14 +842,14 @@ void CISOProperties::ExportDir(const std::string& _rFullPath, const std::string&
{
if (fst[index].m_FullPath == _rFullPath)
{
DEBUG_LOG(DISCIO, "Found the directory at %u", index);
INFO_LOG(DISCIO, "Found the directory at %u", index);
size = (u32)fst[index].m_FileSize;
break;
}
}
DEBUG_LOG(DISCIO, "Directory found from %u to %u\nextracting to:\n%s", index, size,
_rExportFolder.c_str());
INFO_LOG(DISCIO, "Directory found from %u to %u\nextracting to:\n%s", index, size,
_rExportFolder.c_str());
}
wxString dialogTitle = (index != 0) ? _("Extracting Directory") : _("Extracting All Files");
@ -872,7 +872,7 @@ void CISOProperties::ExportDir(const std::string& _rFullPath, const std::string&
{
const std::string exportName =
StringFromFormat("%s/%s/", _rExportFolder.c_str(), fst[i].m_FullPath.c_str());
DEBUG_LOG(DISCIO, "%s", exportName.c_str());
INFO_LOG(DISCIO, "%s", exportName.c_str());
if (!File::Exists(exportName) && !File::CreateFullPath(exportName))
{
@ -883,14 +883,14 @@ void CISOProperties::ExportDir(const std::string& _rFullPath, const std::string&
if (!File::IsDirectory(exportName))
ERROR_LOG(DISCIO, "%s already exists and is not a directory", exportName.c_str());
DEBUG_LOG(DISCIO, "Folder %s already exists", exportName.c_str());
ERROR_LOG(DISCIO, "Folder %s already exists", exportName.c_str());
}
}
else
{
const std::string exportName =
StringFromFormat("%s/%s", _rExportFolder.c_str(), fst[i].m_FullPath.c_str());
DEBUG_LOG(DISCIO, "%s", exportName.c_str());
INFO_LOG(DISCIO, "%s", exportName.c_str());
if (!File::Exists(exportName) && !fs->ExportFile(fst[i].m_FullPath, exportName))
{
@ -898,7 +898,7 @@ void CISOProperties::ExportDir(const std::string& _rFullPath, const std::string&
}
else
{
DEBUG_LOG(DISCIO, "%s already exists", exportName.c_str());
ERROR_LOG(DISCIO, "%s already exists", exportName.c_str());
}
}
}

2
Source/Core/DolphinWX/X11Utils.cpp
View File

@ -58,7 +58,7 @@ void InhibitScreensaver(Display* dpy, Window win, bool suspend)
while (waitpid(pid, &status, 0) == -1)
;
DEBUG_LOG(VIDEO, "Started xdg-screensaver (PID = %d)", (int)pid);
INFO_LOG(VIDEO, "Started xdg-screensaver (PID = %d)", (int)pid);
}
}

8
Source/Core/InputCommon/GCAdapter.cpp
View File

@ -393,8 +393,8 @@ GCPadStatus Input(int chan)
if (payload_size != sizeof(controller_payload_copy) ||
controller_payload_copy[0] != LIBUSB_DT_HID)
{
INFO_LOG(SERIALINTERFACE, "error reading payload (size: %d, type: %02x)", payload_size,
controller_payload_copy[0]);
ERROR_LOG(SERIALINTERFACE, "error reading payload (size: %d, type: %02x)", payload_size,
controller_payload_copy[0]);
Reset();
}
else
@ -503,7 +503,7 @@ static void ResetRumbleLockNeeded()
int size = 0;
libusb_interrupt_transfer(s_handle, s_endpoint_out, rumble, sizeof(rumble), &size, 16);
DEBUG_LOG(SERIALINTERFACE, "Rumble state reset");
INFO_LOG(SERIALINTERFACE, "Rumble state reset");
}
void Output(int chan, u8 rumble_command)
@ -525,7 +525,7 @@ void Output(int chan, u8 rumble_command)
// Netplay sends invalid data which results in size = 0x00. Ignore it.
if (size != 0x05 && size != 0x00)
{
INFO_LOG(SERIALINTERFACE, "error writing rumble (size: %d)", size);
ERROR_LOG(SERIALINTERFACE, "error writing rumble (size: %d)", size);
Reset();
}
}

2
Source/Core/VideoBackends/OGL/Render.cpp
View File

@ -145,7 +145,7 @@ static void APIENTRY ErrorCallback(GLenum source, GLenum type, GLuint id, GLenum
WARN_LOG(HOST_GPU, "id: %x, source: %s, type: %s - %s", id, s_source, s_type, message);
break;
case GL_DEBUG_SEVERITY_LOW_ARB:
WARN_LOG(HOST_GPU, "id: %x, source: %s, type: %s - %s", id, s_source, s_type, message);
DEBUG_LOG(HOST_GPU, "id: %x, source: %s, type: %s - %s", id, s_source, s_type, message);
break;
case GL_DEBUG_SEVERITY_NOTIFICATION:
DEBUG_LOG(HOST_GPU, "id: %x, source: %s, type: %s - %s", id, s_source, s_type, message);

6
Source/Core/VideoBackends/Software/EfbCopy.cpp
View File

@ -19,9 +19,9 @@ namespace EfbCopy
static void CopyToXfb(u32 xfbAddr, u32 fbWidth, u32 fbHeight, const EFBRectangle& sourceRc,
float Gamma)
{
INFO_LOG(VIDEO, "xfbaddr: %x, fbwidth: %i, fbheight: %i, source: (%i, %i, %i, %i), Gamma %f",
xfbAddr, fbWidth, fbHeight, sourceRc.top, sourceRc.left, sourceRc.bottom, sourceRc.right,
Gamma);
DEBUG_LOG(VIDEO, "xfbaddr: %x, fbwidth: %i, fbheight: %i, source: (%i, %i, %i, %i), Gamma %f",
xfbAddr, fbWidth, fbHeight, sourceRc.top, sourceRc.left, sourceRc.bottom,
sourceRc.right, Gamma);
EfbInterface::yuv422_packed* xfb_in_ram =
(EfbInterface::yuv422_packed*)Memory::GetPointer(xfbAddr);

8
Source/Core/VideoBackends/Software/EfbInterface.cpp
View File

@ -81,7 +81,7 @@ static void SetPixelColorOnly(u32 offset, u8* rgb)
break;
case PEControl::RGB565_Z16:
{
INFO_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet");
WARN_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet");
u32 src = *(u32*)rgb;
u32* dst = (u32*)&efb[offset];
u32 val = *dst & 0xff000000;
@ -122,7 +122,7 @@ static void SetPixelAlphaColor(u32 offset, u8* color)
break;
case PEControl::RGB565_Z16:
{
INFO_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet");
WARN_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet");
u32 src = *(u32*)color;
u32* dst = (u32*)&efb[offset];
u32 val = *dst & 0xff000000;
@ -178,7 +178,7 @@ static void SetPixelDepth(u32 offset, u32 depth)
break;
case PEControl::RGB565_Z16:
{
INFO_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet");
WARN_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet");
u32* dst = (u32*)&efb[offset];
u32 val = *dst & 0xff000000;
val |= depth & 0x00ffffff;
@ -205,7 +205,7 @@ static u32 GetPixelDepth(u32 offset)
break;
case PEControl::RGB565_Z16:
{
INFO_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet");
WARN_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet");
depth = (*(u32*)&efb[offset]) & 0x00ffffff;
}
break;

2
Source/Core/VideoBackends/Software/SWOGLWindow.cpp
View File

@ -18,7 +18,7 @@ void SWOGLWindow::Init(void* window_handle)
GLInterface->SetMode(GLInterfaceMode::MODE_DETECT);
if (!GLInterface->Create(window_handle))
{
INFO_LOG(VIDEO, "GLInterface::Create failed.");
ERROR_LOG(VIDEO, "GLInterface::Create failed.");
}
s_instance.reset(new SWOGLWindow());

14
Source/Core/VideoCommon/CommandProcessor.cpp
View File

@ -325,13 +325,13 @@ void UpdateInterrupts(u64 userdata)
if (userdata)
{
s_interrupt_set.Set();
INFO_LOG(COMMANDPROCESSOR, "Interrupt set");
DEBUG_LOG(COMMANDPROCESSOR, "Interrupt set");
ProcessorInterface::SetInterrupt(INT_CAUSE_CP, true);
}
else
{
s_interrupt_set.Clear();
INFO_LOG(COMMANDPROCESSOR, "Interrupt cleared");
DEBUG_LOG(COMMANDPROCESSOR, "Interrupt cleared");
ProcessorInterface::SetInterrupt(INT_CAUSE_CP, false);
}
CoreTiming::ForceExceptionCheck(0);
@ -359,21 +359,21 @@ void SetCPStatusFromGPU()
{
if (!fifo.bFF_Breakpoint)
{
INFO_LOG(COMMANDPROCESSOR, "Hit breakpoint at %i", fifo.CPReadPointer);
DEBUG_LOG(COMMANDPROCESSOR, "Hit breakpoint at %i", fifo.CPReadPointer);
fifo.bFF_Breakpoint = true;
}
}
else
{
if (fifo.bFF_Breakpoint)
INFO_LOG(COMMANDPROCESSOR, "Cleared breakpoint at %i", fifo.CPReadPointer);
DEBUG_LOG(COMMANDPROCESSOR, "Cleared breakpoint at %i", fifo.CPReadPointer);
fifo.bFF_Breakpoint = false;
}
}
else
{
if (fifo.bFF_Breakpoint)
INFO_LOG(COMMANDPROCESSOR, "Cleared breakpoint at %i", fifo.CPReadPointer);
DEBUG_LOG(COMMANDPROCESSOR, "Cleared breakpoint at %i", fifo.CPReadPointer);
fifo.bFF_Breakpoint = false;
}
@ -426,7 +426,7 @@ void SetCPStatusFromCPU()
if (!interrupt || bpInt || undfInt || ovfInt)
{
s_interrupt_set.Set(interrupt);
INFO_LOG(COMMANDPROCESSOR, "Interrupt set");
DEBUG_LOG(COMMANDPROCESSOR, "Interrupt set");
ProcessorInterface::SetInterrupt(INT_CAUSE_CP, interrupt);
}
}
@ -447,7 +447,7 @@ void SetCpStatusRegister()
m_CPStatusReg.UnderflowLoWatermark = fifo.bFF_LoWatermark;
m_CPStatusReg.OverflowHiWatermark = fifo.bFF_HiWatermark;
INFO_LOG(COMMANDPROCESSOR, "\t Read from STATUS_REGISTER : %04x", m_CPStatusReg.Hex);
DEBUG_LOG(COMMANDPROCESSOR, "\t Read from STATUS_REGISTER : %04x", m_CPStatusReg.Hex);
DEBUG_LOG(
COMMANDPROCESSOR, "(r) status: iBP %s | fReadIdle %s | fCmdIdle %s | iOvF %s | iUndF %s",
m_CPStatusReg.Breakpoint ? "ON" : "OFF", m_CPStatusReg.ReadIdle ? "ON" : "OFF",

2
Source/Core/VideoCommon/OpcodeDecoding.cpp
View File

@ -211,7 +211,7 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list)
if (in_display_list)
{
totalCycles += 6;
WARN_LOG(VIDEO, "recursive display list detected");
INFO_LOG(VIDEO, "recursive display list detected");
}
else
{

4
Source/Core/VideoCommon/PixelEngine.cpp
View File

@ -288,7 +288,7 @@ static void RaiseEvent()
// THIS IS EXECUTED FROM VIDEO THREAD
void SetToken(const u16 token, const bool interrupt)
{
INFO_LOG(PIXELENGINE, "VIDEO Backend raises INT_CAUSE_PE_TOKEN (btw, token: %04x)", token);
DEBUG_LOG(PIXELENGINE, "VIDEO Backend raises INT_CAUSE_PE_TOKEN (btw, token: %04x)", token);
std::lock_guard<std::mutex> lk(s_token_finish_mutex);
@ -302,7 +302,7 @@ void SetToken(const u16 token, const bool interrupt)
// THIS IS EXECUTED FROM VIDEO THREAD (BPStructs.cpp) when a new frame has been drawn
void SetFinish()
{
INFO_LOG(PIXELENGINE, "VIDEO Set Finish");
DEBUG_LOG(PIXELENGINE, "VIDEO Set Finish");
std::lock_guard<std::mutex> lk(s_token_finish_mutex);

2
Source/Core/VideoCommon/XFStructs.cpp
View File

@ -202,7 +202,7 @@ void LoadXFReg(u32 transferSize, u32 baseAddress, DataReader src)
// do not allow writes past registers
if (baseAddress + transferSize > 0x1058)
{
INFO_LOG(VIDEO, "XF load exceeds address space: %x %d bytes", baseAddress, transferSize);
WARN_LOG(VIDEO, "XF load exceeds address space: %x %d bytes", baseAddress, transferSize);
if (baseAddress >= 0x1058)
transferSize = 0;