mirror of
https://github.com/citra-mirror/citra.git
synced 2024-08-20 10:23:23 +02:00
Merge pull request #713 from bunnei/qt-emuthread-fixes
Fix emulation state resetting to support multiple emulation sessions
This commit is contained in:
commit
6a2d8c46f2
@ -10,6 +10,7 @@
|
||||
|
||||
#include "common/common.h"
|
||||
#include "bootmanager.h"
|
||||
#include "main.h"
|
||||
|
||||
#include "core/core.h"
|
||||
#include "core/settings.h"
|
||||
@ -27,43 +28,33 @@
|
||||
#define COPYRIGHT "Copyright (C) 2013-2014 Citra Team"
|
||||
|
||||
EmuThread::EmuThread(GRenderWindow* render_window) :
|
||||
filename(""), exec_cpu_step(false), cpu_running(false),
|
||||
stop_run(false), render_window(render_window)
|
||||
{
|
||||
exec_step(false), running(false), stop_run(false), render_window(render_window) {
|
||||
|
||||
connect(this, SIGNAL(started()), render_window, SLOT(moveContext()));
|
||||
}
|
||||
|
||||
void EmuThread::SetFilename(std::string filename)
|
||||
{
|
||||
this->filename = filename;
|
||||
}
|
||||
|
||||
void EmuThread::run()
|
||||
{
|
||||
void EmuThread::run() {
|
||||
stop_run = false;
|
||||
|
||||
// holds whether the cpu was running during the last iteration,
|
||||
// so that the DebugModeLeft signal can be emitted before the
|
||||
// next execution step
|
||||
bool was_active = false;
|
||||
while (!stop_run)
|
||||
{
|
||||
if (cpu_running)
|
||||
{
|
||||
while (!stop_run) {
|
||||
if (running) {
|
||||
if (!was_active)
|
||||
emit DebugModeLeft();
|
||||
|
||||
Core::RunLoop();
|
||||
|
||||
was_active = cpu_running || exec_cpu_step;
|
||||
if (!was_active)
|
||||
was_active = running || exec_step;
|
||||
if (!was_active && !stop_run)
|
||||
emit DebugModeEntered();
|
||||
}
|
||||
else if (exec_cpu_step)
|
||||
{
|
||||
} else if (exec_step) {
|
||||
if (!was_active)
|
||||
emit DebugModeLeft();
|
||||
|
||||
exec_cpu_step = false;
|
||||
exec_step = false;
|
||||
Core::SingleStep();
|
||||
emit DebugModeEntered();
|
||||
yieldCurrentThread();
|
||||
@ -71,47 +62,10 @@ void EmuThread::run()
|
||||
was_active = false;
|
||||
}
|
||||
}
|
||||
|
||||
render_window->moveContext();
|
||||
|
||||
Core::Stop();
|
||||
}
|
||||
|
||||
void EmuThread::Stop()
|
||||
{
|
||||
if (!isRunning())
|
||||
{
|
||||
LOG_WARNING(Frontend, "EmuThread::Stop called while emu thread wasn't running, returning...");
|
||||
return;
|
||||
}
|
||||
stop_run = true;
|
||||
|
||||
// Release emu threads from any breakpoints, so that this doesn't hang forever.
|
||||
Pica::g_debug_context->ClearBreakpoints();
|
||||
|
||||
//core::g_state = core::SYS_DIE;
|
||||
|
||||
// TODO: Waiting here is just a bad workaround for retarded shutdown logic.
|
||||
wait(1000);
|
||||
if (isRunning())
|
||||
{
|
||||
LOG_WARNING(Frontend, "EmuThread still running, terminating...");
|
||||
quit();
|
||||
|
||||
// TODO: Waiting 50 seconds can be necessary if the logging subsystem has a lot of spam
|
||||
// queued... This should be fixed.
|
||||
wait(50000);
|
||||
if (isRunning())
|
||||
{
|
||||
LOG_CRITICAL(Frontend, "EmuThread STILL running, something is wrong here...");
|
||||
terminate();
|
||||
}
|
||||
}
|
||||
LOG_INFO(Frontend, "EmuThread stopped");
|
||||
|
||||
System::Shutdown();
|
||||
}
|
||||
|
||||
|
||||
// This class overrides paintEvent and resizeEvent to prevent the GUI thread from stealing GL context.
|
||||
// The corresponding functionality is handled in EmuThread instead
|
||||
class GGLWidgetInternal : public QGLWidget
|
||||
@ -133,13 +87,9 @@ private:
|
||||
GRenderWindow* parent;
|
||||
};
|
||||
|
||||
EmuThread& GRenderWindow::GetEmuThread()
|
||||
{
|
||||
return emu_thread;
|
||||
}
|
||||
GRenderWindow::GRenderWindow(QWidget* parent, EmuThread* emu_thread) :
|
||||
QWidget(parent), emu_thread(emu_thread), keyboard_id(0) {
|
||||
|
||||
GRenderWindow::GRenderWindow(QWidget* parent) : QWidget(parent), emu_thread(this), keyboard_id(0)
|
||||
{
|
||||
std::string window_title = Common::StringFromFormat("Citra | %s-%s", Common::g_scm_branch, Common::g_scm_desc);
|
||||
setWindowTitle(QString::fromStdString(window_title));
|
||||
|
||||
@ -160,7 +110,6 @@ GRenderWindow::GRenderWindow(QWidget* parent) : QWidget(parent), emu_thread(this
|
||||
layout->addWidget(child);
|
||||
layout->setMargin(0);
|
||||
setLayout(layout);
|
||||
connect(&emu_thread, SIGNAL(started()), this, SLOT(moveContext()));
|
||||
|
||||
OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
|
||||
|
||||
@ -180,29 +129,17 @@ void GRenderWindow::moveContext()
|
||||
// We need to move GL context to the swapping thread in Qt5
|
||||
#if QT_VERSION > QT_VERSION_CHECK(5, 0, 0)
|
||||
// If the thread started running, move the GL Context to the new thread. Otherwise, move it back.
|
||||
child->context()->moveToThread((QThread::currentThread() == qApp->thread()) ? &emu_thread : qApp->thread());
|
||||
auto thread = (QThread::currentThread() == qApp->thread() && emu_thread != nullptr) ? emu_thread : qApp->thread();
|
||||
child->context()->moveToThread(thread);
|
||||
#endif
|
||||
}
|
||||
|
||||
GRenderWindow::~GRenderWindow()
|
||||
{
|
||||
if (emu_thread.isRunning())
|
||||
emu_thread.Stop();
|
||||
}
|
||||
|
||||
void GRenderWindow::SwapBuffers()
|
||||
{
|
||||
// MakeCurrent is already called in renderer_opengl
|
||||
child->swapBuffers();
|
||||
}
|
||||
|
||||
void GRenderWindow::closeEvent(QCloseEvent* event)
|
||||
{
|
||||
if (emu_thread.isRunning())
|
||||
emu_thread.Stop();
|
||||
QWidget::closeEvent(event);
|
||||
}
|
||||
|
||||
void GRenderWindow::MakeCurrent()
|
||||
{
|
||||
child->makeCurrent();
|
||||
@ -335,3 +272,11 @@ void GRenderWindow::OnClientAreaResized(unsigned width, unsigned height)
|
||||
void GRenderWindow::OnMinimalClientAreaChangeRequest(const std::pair<unsigned,unsigned>& minimal_size) {
|
||||
setMinimumSize(minimal_size.first, minimal_size.second);
|
||||
}
|
||||
|
||||
void GRenderWindow::OnEmulationStarting(EmuThread* emu_thread) {
|
||||
this->emu_thread = emu_thread;
|
||||
}
|
||||
|
||||
void GRenderWindow::OnEmulationStopping() {
|
||||
emu_thread = nullptr;
|
||||
}
|
||||
|
@ -9,72 +9,58 @@
|
||||
|
||||
#include "common/common.h"
|
||||
#include "common/emu_window.h"
|
||||
#include "common/thread.h"
|
||||
|
||||
class QScreen;
|
||||
class QKeyEvent;
|
||||
|
||||
class GRenderWindow;
|
||||
class GMainWindow;
|
||||
|
||||
class EmuThread : public QThread
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
/**
|
||||
* Set image filename
|
||||
*
|
||||
* @param filename
|
||||
* @warning Only call when not running!
|
||||
*/
|
||||
void SetFilename(std::string filename);
|
||||
EmuThread(GRenderWindow* render_window);
|
||||
|
||||
/**
|
||||
* Start emulation (on new thread)
|
||||
*
|
||||
* @warning Only call when not running!
|
||||
*/
|
||||
void run() override;
|
||||
|
||||
/**
|
||||
* Allow the CPU to process a single instruction (if cpu is not running)
|
||||
*
|
||||
* Steps the emulation thread by a single CPU instruction (if the CPU is not already running)
|
||||
* @note This function is thread-safe
|
||||
*/
|
||||
void ExecStep() { exec_cpu_step = true; }
|
||||
void ExecStep() { exec_step = true; }
|
||||
|
||||
/**
|
||||
* Allow the CPU to continue processing instructions without interruption
|
||||
*
|
||||
* Sets whether the emulation thread is running or not
|
||||
* @param running Boolean value, set the emulation thread to running if true
|
||||
* @note This function is thread-safe
|
||||
*/
|
||||
void SetCpuRunning(bool running) { cpu_running = running; }
|
||||
void SetRunning(bool running) { this->running = running; }
|
||||
|
||||
/**
|
||||
* Allow the CPU to continue processing instructions without interruption
|
||||
*
|
||||
* @note This function is thread-safe
|
||||
*/
|
||||
bool IsCpuRunning() { return cpu_running; }
|
||||
|
||||
|
||||
public slots:
|
||||
/**
|
||||
* Stop emulation and wait for the thread to finish.
|
||||
*
|
||||
* @details: This function will wait a second for the thread to finish; if it hasn't finished until then, we'll terminate() it and wait another second, hoping that it will be terminated by then.
|
||||
* @note: This function is thread-safe.
|
||||
* Check if the emulation thread is running or not
|
||||
* @return True if the emulation thread is running, otherwise false
|
||||
* @note This function is thread-safe
|
||||
*/
|
||||
void Stop();
|
||||
bool IsRunning() { return running; }
|
||||
|
||||
/**
|
||||
* Requests for the emulation thread to stop running
|
||||
*/
|
||||
void RequestStop() {
|
||||
stop_run = true;
|
||||
running = false;
|
||||
};
|
||||
|
||||
private:
|
||||
friend class GRenderWindow;
|
||||
|
||||
EmuThread(GRenderWindow* render_window);
|
||||
|
||||
std::string filename;
|
||||
|
||||
bool exec_cpu_step;
|
||||
bool cpu_running;
|
||||
bool exec_step;
|
||||
bool running;
|
||||
std::atomic<bool> stop_run;
|
||||
|
||||
GRenderWindow* render_window;
|
||||
@ -100,10 +86,7 @@ class GRenderWindow : public QWidget, public EmuWindow
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
GRenderWindow(QWidget* parent = NULL);
|
||||
~GRenderWindow();
|
||||
|
||||
void closeEvent(QCloseEvent*) override;
|
||||
GRenderWindow(QWidget* parent, EmuThread* emu_thread);
|
||||
|
||||
// EmuWindow implementation
|
||||
void SwapBuffers() override;
|
||||
@ -116,8 +99,6 @@ public:
|
||||
void restoreGeometry(const QByteArray& geometry); // overridden
|
||||
QByteArray saveGeometry(); // overridden
|
||||
|
||||
EmuThread& GetEmuThread();
|
||||
|
||||
void keyPressEvent(QKeyEvent* event) override;
|
||||
void keyReleaseEvent(QKeyEvent* event) override;
|
||||
|
||||
@ -134,15 +115,18 @@ public:
|
||||
public slots:
|
||||
void moveContext(); // overridden
|
||||
|
||||
void OnEmulationStarting(EmuThread* emu_thread);
|
||||
void OnEmulationStopping();
|
||||
|
||||
private:
|
||||
void OnMinimalClientAreaChangeRequest(const std::pair<unsigned,unsigned>& minimal_size) override;
|
||||
|
||||
QGLWidget* child;
|
||||
|
||||
EmuThread emu_thread;
|
||||
|
||||
QByteArray geometry;
|
||||
|
||||
/// Device id of keyboard for use with KeyMap
|
||||
int keyboard_id;
|
||||
|
||||
EmuThread* emu_thread;
|
||||
};
|
||||
|
@ -18,8 +18,8 @@
|
||||
#include "core/arm/disassembler/arm_disasm.h"
|
||||
|
||||
|
||||
DisassemblerModel::DisassemblerModel(QObject* parent) : QAbstractListModel(parent), base_address(0), code_size(0), program_counter(0), selection(QModelIndex()) {
|
||||
|
||||
DisassemblerModel::DisassemblerModel(QObject* parent) :
|
||||
QAbstractListModel(parent), base_address(0), code_size(0), program_counter(0), selection(QModelIndex()) {
|
||||
}
|
||||
|
||||
int DisassemblerModel::columnCount(const QModelIndex& parent) const {
|
||||
@ -158,34 +158,28 @@ void DisassemblerModel::SetNextInstruction(unsigned int address) {
|
||||
emit dataChanged(prev_index, prev_index);
|
||||
}
|
||||
|
||||
DisassemblerWidget::DisassemblerWidget(QWidget* parent, EmuThread& emu_thread) : QDockWidget(parent), base_addr(0), emu_thread(emu_thread)
|
||||
{
|
||||
disasm_ui.setupUi(this);
|
||||
DisassemblerWidget::DisassemblerWidget(QWidget* parent, EmuThread* emu_thread) :
|
||||
QDockWidget(parent), emu_thread(emu_thread), base_addr(0) {
|
||||
|
||||
model = new DisassemblerModel(this);
|
||||
disasm_ui.treeView->setModel(model);
|
||||
disasm_ui.setupUi(this);
|
||||
|
||||
RegisterHotkey("Disassembler", "Start/Stop", QKeySequence(Qt::Key_F5), Qt::ApplicationShortcut);
|
||||
RegisterHotkey("Disassembler", "Step", QKeySequence(Qt::Key_F10), Qt::ApplicationShortcut);
|
||||
RegisterHotkey("Disassembler", "Step into", QKeySequence(Qt::Key_F11), Qt::ApplicationShortcut);
|
||||
RegisterHotkey("Disassembler", "Set Breakpoint", QKeySequence(Qt::Key_F9), Qt::ApplicationShortcut);
|
||||
|
||||
connect(disasm_ui.button_breakpoint, SIGNAL(clicked()), model, SLOT(OnSetOrUnsetBreakpoint()));
|
||||
connect(disasm_ui.button_step, SIGNAL(clicked()), this, SLOT(OnStep()));
|
||||
connect(disasm_ui.button_pause, SIGNAL(clicked()), this, SLOT(OnPause()));
|
||||
connect(disasm_ui.button_continue, SIGNAL(clicked()), this, SLOT(OnContinue()));
|
||||
|
||||
connect(disasm_ui.treeView->selectionModel(), SIGNAL(currentChanged(const QModelIndex&, const QModelIndex&)),
|
||||
model, SLOT(OnSelectionChanged(const QModelIndex&)));
|
||||
|
||||
connect(GetHotkey("Disassembler", "Start/Stop", this), SIGNAL(activated()), this, SLOT(OnToggleStartStop()));
|
||||
connect(GetHotkey("Disassembler", "Step", this), SIGNAL(activated()), this, SLOT(OnStep()));
|
||||
connect(GetHotkey("Disassembler", "Step into", this), SIGNAL(activated()), this, SLOT(OnStepInto()));
|
||||
connect(GetHotkey("Disassembler", "Set Breakpoint", this), SIGNAL(activated()), model, SLOT(OnSetOrUnsetBreakpoint()));
|
||||
|
||||
setEnabled(false);
|
||||
}
|
||||
|
||||
void DisassemblerWidget::Init()
|
||||
{
|
||||
void DisassemblerWidget::Init() {
|
||||
model->ParseFromAddress(Core::g_app_core->GetPC());
|
||||
|
||||
disasm_ui.treeView->resizeColumnToContents(0);
|
||||
@ -197,25 +191,21 @@ void DisassemblerWidget::Init()
|
||||
disasm_ui.treeView->selectionModel()->setCurrentIndex(model_index, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
|
||||
}
|
||||
|
||||
void DisassemblerWidget::OnContinue()
|
||||
{
|
||||
emu_thread.SetCpuRunning(true);
|
||||
void DisassemblerWidget::OnContinue() {
|
||||
emu_thread->SetRunning(true);
|
||||
}
|
||||
|
||||
void DisassemblerWidget::OnStep()
|
||||
{
|
||||
void DisassemblerWidget::OnStep() {
|
||||
OnStepInto(); // change later
|
||||
}
|
||||
|
||||
void DisassemblerWidget::OnStepInto()
|
||||
{
|
||||
emu_thread.SetCpuRunning(false);
|
||||
emu_thread.ExecStep();
|
||||
void DisassemblerWidget::OnStepInto() {
|
||||
emu_thread->SetRunning(false);
|
||||
emu_thread->ExecStep();
|
||||
}
|
||||
|
||||
void DisassemblerWidget::OnPause()
|
||||
{
|
||||
emu_thread.SetCpuRunning(false);
|
||||
void DisassemblerWidget::OnPause() {
|
||||
emu_thread->SetRunning(false);
|
||||
|
||||
// TODO: By now, the CPU might not have actually stopped...
|
||||
if (Core::g_app_core) {
|
||||
@ -223,17 +213,15 @@ void DisassemblerWidget::OnPause()
|
||||
}
|
||||
}
|
||||
|
||||
void DisassemblerWidget::OnToggleStartStop()
|
||||
{
|
||||
emu_thread.SetCpuRunning(!emu_thread.IsCpuRunning());
|
||||
void DisassemblerWidget::OnToggleStartStop() {
|
||||
emu_thread->SetRunning(!emu_thread->IsRunning());
|
||||
}
|
||||
|
||||
void DisassemblerWidget::OnDebugModeEntered()
|
||||
{
|
||||
void DisassemblerWidget::OnDebugModeEntered() {
|
||||
ARMword next_instr = Core::g_app_core->GetPC();
|
||||
|
||||
if (model->GetBreakPoints().IsAddressBreakPoint(next_instr))
|
||||
emu_thread.SetCpuRunning(false);
|
||||
emu_thread->SetRunning(false);
|
||||
|
||||
model->SetNextInstruction(next_instr);
|
||||
|
||||
@ -242,16 +230,35 @@ void DisassemblerWidget::OnDebugModeEntered()
|
||||
disasm_ui.treeView->selectionModel()->setCurrentIndex(model_index, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
|
||||
}
|
||||
|
||||
void DisassemblerWidget::OnDebugModeLeft()
|
||||
{
|
||||
|
||||
void DisassemblerWidget::OnDebugModeLeft() {
|
||||
}
|
||||
|
||||
int DisassemblerWidget::SelectedRow()
|
||||
{
|
||||
int DisassemblerWidget::SelectedRow() {
|
||||
QModelIndex index = disasm_ui.treeView->selectionModel()->currentIndex();
|
||||
if (!index.isValid())
|
||||
return -1;
|
||||
|
||||
return disasm_ui.treeView->selectionModel()->currentIndex().row();
|
||||
}
|
||||
|
||||
void DisassemblerWidget::OnEmulationStarting(EmuThread* emu_thread) {
|
||||
this->emu_thread = emu_thread;
|
||||
|
||||
model = new DisassemblerModel(this);
|
||||
disasm_ui.treeView->setModel(model);
|
||||
|
||||
connect(disasm_ui.treeView->selectionModel(), SIGNAL(currentChanged(const QModelIndex&, const QModelIndex&)),
|
||||
model, SLOT(OnSelectionChanged(const QModelIndex&)));
|
||||
connect(disasm_ui.button_breakpoint, SIGNAL(clicked()), model, SLOT(OnSetOrUnsetBreakpoint()));
|
||||
connect(GetHotkey("Disassembler", "Set Breakpoint", this), SIGNAL(activated()), model, SLOT(OnSetOrUnsetBreakpoint()));
|
||||
|
||||
Init();
|
||||
setEnabled(true);
|
||||
}
|
||||
|
||||
void DisassemblerWidget::OnEmulationStopping() {
|
||||
disasm_ui.treeView->setModel(nullptr);
|
||||
delete model;
|
||||
emu_thread = nullptr;
|
||||
setEnabled(false);
|
||||
}
|
||||
|
@ -51,7 +51,7 @@ class DisassemblerWidget : public QDockWidget
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
DisassemblerWidget(QWidget* parent, EmuThread& emu_thread);
|
||||
DisassemblerWidget(QWidget* parent, EmuThread* emu_thread);
|
||||
|
||||
void Init();
|
||||
|
||||
@ -65,6 +65,9 @@ public slots:
|
||||
void OnDebugModeEntered();
|
||||
void OnDebugModeLeft();
|
||||
|
||||
void OnEmulationStarting(EmuThread* emu_thread);
|
||||
void OnEmulationStopping();
|
||||
|
||||
private:
|
||||
// returns -1 if no row is selected
|
||||
int SelectedRow();
|
||||
@ -75,5 +78,5 @@ private:
|
||||
|
||||
u32 base_addr;
|
||||
|
||||
EmuThread& emu_thread;
|
||||
EmuThread* emu_thread;
|
||||
};
|
||||
|
@ -7,8 +7,7 @@
|
||||
#include "core/core.h"
|
||||
#include "core/arm/arm_interface.h"
|
||||
|
||||
RegistersWidget::RegistersWidget(QWidget* parent) : QDockWidget(parent)
|
||||
{
|
||||
RegistersWidget::RegistersWidget(QWidget* parent) : QDockWidget(parent) {
|
||||
cpu_regs_ui.setupUi(this);
|
||||
|
||||
tree = cpu_regs_ui.treeWidget;
|
||||
@ -18,8 +17,7 @@ RegistersWidget::RegistersWidget(QWidget* parent) : QDockWidget(parent)
|
||||
registers->setExpanded(true);
|
||||
CSPR->setExpanded(true);
|
||||
|
||||
for (int i = 0; i < 16; ++i)
|
||||
{
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
QTreeWidgetItem* child = new QTreeWidgetItem(QStringList(QString("R[%1]").arg(i, 2, 10, QLatin1Char('0'))));
|
||||
registers->addChild(child);
|
||||
}
|
||||
@ -39,12 +37,16 @@ RegistersWidget::RegistersWidget(QWidget* parent) : QDockWidget(parent)
|
||||
CSPR->addChild(new QTreeWidgetItem(QStringList("C")));
|
||||
CSPR->addChild(new QTreeWidgetItem(QStringList("Z")));
|
||||
CSPR->addChild(new QTreeWidgetItem(QStringList("N")));
|
||||
|
||||
setEnabled(false);
|
||||
}
|
||||
|
||||
void RegistersWidget::OnDebugModeEntered()
|
||||
{
|
||||
void RegistersWidget::OnDebugModeEntered() {
|
||||
ARM_Interface* app_core = Core::g_app_core;
|
||||
|
||||
if (app_core == nullptr)
|
||||
return;
|
||||
|
||||
for (int i = 0; i < 16; ++i)
|
||||
registers->child(i)->setText(1, QString("0x%1").arg(app_core->GetReg(i), 8, 16, QLatin1Char('0')));
|
||||
|
||||
@ -66,7 +68,22 @@ void RegistersWidget::OnDebugModeEntered()
|
||||
CSPR->child(14)->setText(1, QString("%1").arg((app_core->GetCPSR() >> 31) & 0x1)); // N - Negative/Less than
|
||||
}
|
||||
|
||||
void RegistersWidget::OnDebugModeLeft()
|
||||
{
|
||||
|
||||
void RegistersWidget::OnDebugModeLeft() {
|
||||
}
|
||||
|
||||
void RegistersWidget::OnEmulationStarting(EmuThread* emu_thread) {
|
||||
setEnabled(true);
|
||||
}
|
||||
|
||||
void RegistersWidget::OnEmulationStopping() {
|
||||
// Reset widget text
|
||||
for (int i = 0; i < 16; ++i)
|
||||
registers->child(i)->setText(1, QString(""));
|
||||
|
||||
for (int i = 0; i < 15; ++i)
|
||||
CSPR->child(i)->setText(1, QString(""));
|
||||
|
||||
CSPR->setText(1, QString(""));
|
||||
|
||||
setEnabled(false);
|
||||
}
|
||||
|
@ -8,6 +8,7 @@
|
||||
#include <QTreeWidgetItem>
|
||||
|
||||
class QTreeWidget;
|
||||
class EmuThread;
|
||||
|
||||
class RegistersWidget : public QDockWidget
|
||||
{
|
||||
@ -20,6 +21,9 @@ public slots:
|
||||
void OnDebugModeEntered();
|
||||
void OnDebugModeLeft();
|
||||
|
||||
void OnEmulationStarting(EmuThread* emu_thread);
|
||||
void OnEmulationStopping();
|
||||
|
||||
private:
|
||||
Ui::ARMRegisters cpu_regs_ui;
|
||||
|
||||
|
@ -15,6 +15,7 @@
|
||||
#include "common/logging/log.h"
|
||||
#include "common/logging/backend.h"
|
||||
#include "common/logging/filter.h"
|
||||
#include "common/make_unique.h"
|
||||
#include "common/platform.h"
|
||||
#include "common/scope_exit.h"
|
||||
|
||||
@ -46,7 +47,7 @@
|
||||
|
||||
#include "version.h"
|
||||
|
||||
GMainWindow::GMainWindow()
|
||||
GMainWindow::GMainWindow() : emu_thread(nullptr)
|
||||
{
|
||||
Pica::g_debug_context = Pica::DebugContext::Construct();
|
||||
|
||||
@ -55,14 +56,14 @@ GMainWindow::GMainWindow()
|
||||
ui.setupUi(this);
|
||||
statusBar()->hide();
|
||||
|
||||
render_window = new GRenderWindow;
|
||||
render_window = new GRenderWindow(this, emu_thread.get());
|
||||
render_window->hide();
|
||||
|
||||
profilerWidget = new ProfilerWidget(this);
|
||||
addDockWidget(Qt::BottomDockWidgetArea, profilerWidget);
|
||||
profilerWidget->hide();
|
||||
|
||||
disasmWidget = new DisassemblerWidget(this, render_window->GetEmuThread());
|
||||
disasmWidget = new DisassemblerWidget(this, emu_thread.get());
|
||||
addDockWidget(Qt::BottomDockWidgetArea, disasmWidget);
|
||||
disasmWidget->hide();
|
||||
|
||||
@ -138,14 +139,12 @@ GMainWindow::GMainWindow()
|
||||
connect(ui.action_Single_Window_Mode, SIGNAL(triggered(bool)), this, SLOT(ToggleWindowMode()));
|
||||
connect(ui.action_Hotkeys, SIGNAL(triggered()), this, SLOT(OnOpenHotkeysDialog()));
|
||||
|
||||
// BlockingQueuedConnection is important here, it makes sure we've finished refreshing our views before the CPU continues
|
||||
connect(&render_window->GetEmuThread(), SIGNAL(DebugModeEntered()), disasmWidget, SLOT(OnDebugModeEntered()), Qt::BlockingQueuedConnection);
|
||||
connect(&render_window->GetEmuThread(), SIGNAL(DebugModeEntered()), registersWidget, SLOT(OnDebugModeEntered()), Qt::BlockingQueuedConnection);
|
||||
connect(&render_window->GetEmuThread(), SIGNAL(DebugModeEntered()), callstackWidget, SLOT(OnDebugModeEntered()), Qt::BlockingQueuedConnection);
|
||||
|
||||
connect(&render_window->GetEmuThread(), SIGNAL(DebugModeLeft()), disasmWidget, SLOT(OnDebugModeLeft()), Qt::BlockingQueuedConnection);
|
||||
connect(&render_window->GetEmuThread(), SIGNAL(DebugModeLeft()), registersWidget, SLOT(OnDebugModeLeft()), Qt::BlockingQueuedConnection);
|
||||
connect(&render_window->GetEmuThread(), SIGNAL(DebugModeLeft()), callstackWidget, SLOT(OnDebugModeLeft()), Qt::BlockingQueuedConnection);
|
||||
connect(this, SIGNAL(EmulationStarting(EmuThread*)), disasmWidget, SLOT(OnEmulationStarting(EmuThread*)));
|
||||
connect(this, SIGNAL(EmulationStopping()), disasmWidget, SLOT(OnEmulationStopping()));
|
||||
connect(this, SIGNAL(EmulationStarting(EmuThread*)), registersWidget, SLOT(OnEmulationStarting(EmuThread*)));
|
||||
connect(this, SIGNAL(EmulationStopping()), registersWidget, SLOT(OnEmulationStopping()));
|
||||
connect(this, SIGNAL(EmulationStarting(EmuThread*)), render_window, SLOT(OnEmulationStarting(EmuThread*)));
|
||||
connect(this, SIGNAL(EmulationStopping()), render_window, SLOT(OnEmulationStopping()));
|
||||
|
||||
// Setup hotkeys
|
||||
RegisterHotkey("Main Window", "Load File", QKeySequence::Open);
|
||||
@ -196,32 +195,76 @@ void GMainWindow::OnDisplayTitleBars(bool show)
|
||||
}
|
||||
}
|
||||
|
||||
void GMainWindow::BootGame(std::string filename)
|
||||
{
|
||||
void GMainWindow::BootGame(std::string filename) {
|
||||
LOG_INFO(Frontend, "Citra starting...\n");
|
||||
|
||||
// Initialize the core emulation
|
||||
System::Init(render_window);
|
||||
|
||||
// Load a game or die...
|
||||
// Load the game
|
||||
if (Loader::ResultStatus::Success != Loader::LoadFile(filename)) {
|
||||
LOG_CRITICAL(Frontend, "Failed to load ROM!");
|
||||
System::Shutdown();
|
||||
return;
|
||||
}
|
||||
|
||||
disasmWidget->Init();
|
||||
// Create and start the emulation thread
|
||||
emu_thread = Common::make_unique<EmuThread>(render_window);
|
||||
emit EmulationStarting(emu_thread.get());
|
||||
emu_thread->start();
|
||||
|
||||
// BlockingQueuedConnection is important here, it makes sure we've finished refreshing our views before the CPU continues
|
||||
connect(emu_thread.get(), SIGNAL(DebugModeEntered()), disasmWidget, SLOT(OnDebugModeEntered()), Qt::BlockingQueuedConnection);
|
||||
connect(emu_thread.get(), SIGNAL(DebugModeEntered()), registersWidget, SLOT(OnDebugModeEntered()), Qt::BlockingQueuedConnection);
|
||||
connect(emu_thread.get(), SIGNAL(DebugModeEntered()), callstackWidget, SLOT(OnDebugModeEntered()), Qt::BlockingQueuedConnection);
|
||||
connect(emu_thread.get(), SIGNAL(DebugModeLeft()), disasmWidget, SLOT(OnDebugModeLeft()), Qt::BlockingQueuedConnection);
|
||||
connect(emu_thread.get(), SIGNAL(DebugModeLeft()), registersWidget, SLOT(OnDebugModeLeft()), Qt::BlockingQueuedConnection);
|
||||
connect(emu_thread.get(), SIGNAL(DebugModeLeft()), callstackWidget, SLOT(OnDebugModeLeft()), Qt::BlockingQueuedConnection);
|
||||
|
||||
// Update the GUI
|
||||
registersWidget->OnDebugModeEntered();
|
||||
callstackWidget->OnDebugModeEntered();
|
||||
|
||||
render_window->GetEmuThread().SetFilename(filename);
|
||||
render_window->GetEmuThread().start();
|
||||
|
||||
render_window->show();
|
||||
|
||||
OnStartGame();
|
||||
}
|
||||
|
||||
void GMainWindow::ShutdownGame() {
|
||||
emu_thread->RequestStop();
|
||||
|
||||
// Release emu threads from any breakpoints
|
||||
// This belongs after RequestStop() and before wait() because if emulation stops on a GPU
|
||||
// breakpoint after (or before) RequestStop() is called, the emulation would never be able
|
||||
// to continue out to the main loop and terminate. Thus wait() would hang forever.
|
||||
// TODO(bunnei): This function is not thread safe, but it's being used as if it were
|
||||
Pica::g_debug_context->ClearBreakpoints();
|
||||
|
||||
emit EmulationStopping();
|
||||
|
||||
// Wait for emulation thread to complete and delete it
|
||||
emu_thread->wait();
|
||||
emu_thread = nullptr;
|
||||
|
||||
// Shutdown the core emulation
|
||||
System::Shutdown();
|
||||
|
||||
// Update the GUI
|
||||
ui.action_Start->setEnabled(false);
|
||||
ui.action_Pause->setEnabled(false);
|
||||
ui.action_Stop->setEnabled(false);
|
||||
render_window->hide();
|
||||
}
|
||||
|
||||
void GMainWindow::OnMenuLoadFile()
|
||||
{
|
||||
QString filename = QFileDialog::getOpenFileName(this, tr("Load File"), QString(), tr("3DS executable (*.3ds *.3dsx *.elf *.axf *.bin *.cci *.cxi)"));
|
||||
if (filename.size())
|
||||
BootGame(filename.toLatin1().data());
|
||||
if (filename.size()) {
|
||||
// Shutdown previous session if the emu thread is still active...
|
||||
if (emu_thread != nullptr)
|
||||
ShutdownGame();
|
||||
|
||||
BootGame(filename.toLatin1().data());
|
||||
}
|
||||
}
|
||||
|
||||
void GMainWindow::OnMenuLoadSymbolMap() {
|
||||
@ -232,7 +275,7 @@ void GMainWindow::OnMenuLoadSymbolMap() {
|
||||
|
||||
void GMainWindow::OnStartGame()
|
||||
{
|
||||
render_window->GetEmuThread().SetCpuRunning(true);
|
||||
emu_thread->SetRunning(true);
|
||||
|
||||
ui.action_Start->setEnabled(false);
|
||||
ui.action_Pause->setEnabled(true);
|
||||
@ -241,21 +284,15 @@ void GMainWindow::OnStartGame()
|
||||
|
||||
void GMainWindow::OnPauseGame()
|
||||
{
|
||||
render_window->GetEmuThread().SetCpuRunning(false);
|
||||
emu_thread->SetRunning(false);
|
||||
|
||||
ui.action_Start->setEnabled(true);
|
||||
ui.action_Pause->setEnabled(false);
|
||||
ui.action_Stop->setEnabled(true);
|
||||
}
|
||||
|
||||
void GMainWindow::OnStopGame()
|
||||
{
|
||||
render_window->GetEmuThread().SetCpuRunning(false);
|
||||
// TODO: Shutdown core
|
||||
|
||||
ui.action_Start->setEnabled(true);
|
||||
ui.action_Pause->setEnabled(false);
|
||||
ui.action_Stop->setEnabled(false);
|
||||
void GMainWindow::OnStopGame() {
|
||||
ShutdownGame();
|
||||
}
|
||||
|
||||
void GMainWindow::OnOpenHotkeysDialog()
|
||||
@ -265,24 +302,22 @@ void GMainWindow::OnOpenHotkeysDialog()
|
||||
}
|
||||
|
||||
|
||||
void GMainWindow::ToggleWindowMode()
|
||||
{
|
||||
bool enable = ui.action_Single_Window_Mode->isChecked();
|
||||
if (!enable && render_window->parent() != nullptr)
|
||||
{
|
||||
ui.horizontalLayout->removeWidget(render_window);
|
||||
render_window->setParent(nullptr);
|
||||
render_window->setVisible(true);
|
||||
render_window->RestoreGeometry();
|
||||
render_window->setFocusPolicy(Qt::NoFocus);
|
||||
}
|
||||
else if (enable && render_window->parent() == nullptr)
|
||||
{
|
||||
void GMainWindow::ToggleWindowMode() {
|
||||
if (ui.action_Single_Window_Mode->isChecked()) {
|
||||
// Render in the main window...
|
||||
render_window->BackupGeometry();
|
||||
ui.horizontalLayout->addWidget(render_window);
|
||||
render_window->setVisible(true);
|
||||
render_window->setFocusPolicy(Qt::ClickFocus);
|
||||
render_window->setFocus();
|
||||
|
||||
} else {
|
||||
// Render in a separate window...
|
||||
ui.horizontalLayout->removeWidget(render_window);
|
||||
render_window->setParent(nullptr);
|
||||
render_window->setVisible(true);
|
||||
render_window->RestoreGeometry();
|
||||
render_window->setFocusPolicy(Qt::NoFocus);
|
||||
}
|
||||
}
|
||||
|
||||
@ -303,6 +338,8 @@ void GMainWindow::closeEvent(QCloseEvent* event)
|
||||
settings.setValue("firstStart", false);
|
||||
SaveHotkeys(settings);
|
||||
|
||||
ShutdownGame();
|
||||
|
||||
render_window->close();
|
||||
|
||||
QWidget::closeEvent(event);
|
||||
|
@ -5,12 +5,14 @@
|
||||
#ifndef _CITRA_QT_MAIN_HXX_
|
||||
#define _CITRA_QT_MAIN_HXX_
|
||||
|
||||
#include <memory>
|
||||
#include <QMainWindow>
|
||||
|
||||
#include "ui_main.h"
|
||||
|
||||
class GImageInfo;
|
||||
class GRenderWindow;
|
||||
class EmuThread;
|
||||
class ProfilerWidget;
|
||||
class DisassemblerWidget;
|
||||
class RegistersWidget;
|
||||
@ -34,8 +36,27 @@ public:
|
||||
GMainWindow();
|
||||
~GMainWindow();
|
||||
|
||||
signals:
|
||||
|
||||
/**
|
||||
* Signal that is emitted when a new EmuThread has been created and an emulation session is
|
||||
* about to start. At this time, the core system emulation has been initialized, and all
|
||||
* emulation handles and memory should be valid.
|
||||
*
|
||||
* @param emu_thread Pointer to the newly created EmuThread (to be used by widgets that need to
|
||||
* access/change emulation state).
|
||||
*/
|
||||
void EmulationStarting(EmuThread* emu_thread);
|
||||
|
||||
/**
|
||||
* Signal that is emitted when emulation is about to stop. At this time, the EmuThread and core
|
||||
* system emulation handles and memory are still valid, but are about become invalid.
|
||||
*/
|
||||
void EmulationStopping();
|
||||
|
||||
private:
|
||||
void BootGame(std::string filename);
|
||||
void ShutdownGame();
|
||||
|
||||
void closeEvent(QCloseEvent* event) override;
|
||||
|
||||
@ -55,6 +76,8 @@ private:
|
||||
|
||||
GRenderWindow* render_window;
|
||||
|
||||
std::unique_ptr<EmuThread> emu_thread;
|
||||
|
||||
ProfilerWidget* profilerWidget;
|
||||
DisassemblerWidget* disasmWidget;
|
||||
RegistersWidget* registersWidget;
|
||||
|
@ -90,6 +90,9 @@
|
||||
</property>
|
||||
</action>
|
||||
<action name="action_Start">
|
||||
<property name="enabled">
|
||||
<bool>false</bool>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>&Start</string>
|
||||
</property>
|
||||
|
@ -2,6 +2,8 @@
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include "common/make_unique.h"
|
||||
|
||||
#include "core/arm/skyeye_common/armemu.h"
|
||||
#include "core/arm/skyeye_common/vfp/vfp.h"
|
||||
|
||||
@ -17,7 +19,7 @@ const static cpu_config_t s_arm11_cpu_info = {
|
||||
};
|
||||
|
||||
ARM_DynCom::ARM_DynCom(PrivilegeMode initial_mode) {
|
||||
state = std::unique_ptr<ARMul_State>(new ARMul_State);
|
||||
state = Common::make_unique<ARMul_State>();
|
||||
|
||||
ARMul_NewState(state.get());
|
||||
ARMul_SelectProcessor(state.get(), ARM_v6_Prop | ARM_v5_Prop | ARM_v5e_Prop);
|
||||
|
@ -6,7 +6,6 @@
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdio>
|
||||
#include <unordered_map>
|
||||
|
||||
#include "common/logging/log.h"
|
||||
#include "common/profiler.h"
|
||||
@ -3533,25 +3532,6 @@ const transop_fp_t arm_instruction_trans[] = {
|
||||
INTERPRETER_TRANSLATE(blx_1_thumb)
|
||||
};
|
||||
|
||||
typedef std::unordered_map<u32, int> bb_map;
|
||||
static bb_map CreamCache;
|
||||
|
||||
static void insert_bb(unsigned int addr, int start) {
|
||||
CreamCache[addr] = start;
|
||||
}
|
||||
|
||||
static int find_bb(unsigned int addr, int& start) {
|
||||
int ret = -1;
|
||||
bb_map::const_iterator it = CreamCache.find(addr);
|
||||
if (it != CreamCache.end()) {
|
||||
start = static_cast<int>(it->second);
|
||||
ret = 0;
|
||||
} else {
|
||||
ret = -1;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
enum {
|
||||
FETCH_SUCCESS,
|
||||
FETCH_FAILURE
|
||||
@ -3674,7 +3654,9 @@ translated:
|
||||
}
|
||||
ret = inst_base->br;
|
||||
};
|
||||
insert_bb(pc_start, bb_start);
|
||||
|
||||
cpu->instruction_cache[pc_start] = bb_start;
|
||||
|
||||
return KEEP_GOING;
|
||||
}
|
||||
|
||||
@ -4001,9 +3983,14 @@ unsigned InterpreterMainLoop(ARMul_State* state) {
|
||||
|
||||
phys_addr = cpu->Reg[15];
|
||||
|
||||
if (find_bb(cpu->Reg[15], ptr) == -1)
|
||||
// Find the cached instruction cream, otherwise translate it...
|
||||
auto itr = cpu->instruction_cache.find(cpu->Reg[15]);
|
||||
if (itr != cpu->instruction_cache.end()) {
|
||||
ptr = itr->second;
|
||||
} else {
|
||||
if (InterpreterTranslate(cpu, ptr, cpu->Reg[15]) == FETCH_EXCEPTION)
|
||||
goto END;
|
||||
}
|
||||
|
||||
inst_base = (arm_inst *)&inst_buf[ptr];
|
||||
GOTO_NEXT_INST;
|
||||
|
@ -26,8 +26,6 @@
|
||||
\***************************************************************************/
|
||||
ARMul_State* ARMul_NewState(ARMul_State* state)
|
||||
{
|
||||
memset(state, 0, sizeof(ARMul_State));
|
||||
|
||||
state->Emulate = RUN;
|
||||
state->Mode = USER32MODE;
|
||||
|
||||
|
@ -17,6 +17,8 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <unordered_map>
|
||||
|
||||
#include "common/common_types.h"
|
||||
#include "core/arm/skyeye_common/arm_regformat.h"
|
||||
#include "core/arm/skyeye_common/skyeye_defs.h"
|
||||
@ -152,6 +154,10 @@ So, if lateabtSig=1, then it means Late Abort Model(Base Updated Abort Model)
|
||||
|
||||
// Added by ksh in 2005-10-1
|
||||
cpu_config_t* cpu;
|
||||
|
||||
// TODO(bunnei): Move this cache to a better place - it should be per codeset (likely per
|
||||
// process for our purposes), not per ARMul_State (which tracks CPU core state).
|
||||
std::unordered_map<u32, int> instruction_cache;
|
||||
};
|
||||
|
||||
/***************************************************************************\
|
||||
|
@ -160,6 +160,16 @@ void Init() {
|
||||
last_global_time_us = 0;
|
||||
has_ts_events = 0;
|
||||
mhz_change_callbacks.clear();
|
||||
|
||||
first = nullptr;
|
||||
ts_first = nullptr;
|
||||
ts_last = nullptr;
|
||||
|
||||
event_pool = nullptr;
|
||||
event_ts_pool = nullptr;
|
||||
allocated_ts_events = 0;
|
||||
|
||||
advance_callback = nullptr;
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
|
@ -61,6 +61,8 @@ template void Read<u16>(u16 &var, const u32 addr);
|
||||
template void Read<u8>(u8 &var, const u32 addr);
|
||||
|
||||
void Init() {
|
||||
memset(&config_mem, 0, sizeof(config_mem));
|
||||
|
||||
config_mem.update_flag = 0; // No update
|
||||
config_mem.sys_core_ver = 0x2;
|
||||
config_mem.unit_info = 0x1; // Bit 0 set for Retail
|
||||
@ -76,4 +78,7 @@ void Init() {
|
||||
config_mem.firm_sys_core_ver = 0x2;
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
@ -20,4 +20,6 @@ void Read(T &var, const u32 addr);
|
||||
|
||||
void Init();
|
||||
|
||||
void Shutdown();
|
||||
|
||||
} // namespace
|
||||
|
@ -23,7 +23,7 @@ Common::Profiling::TimingCategory profiler_svc("SVC Calls");
|
||||
|
||||
static std::vector<ModuleDef> g_module_db;
|
||||
|
||||
bool g_reschedule = false; ///< If true, immediately reschedules the CPU to a new thread
|
||||
bool g_reschedule; ///< If true, immediately reschedules the CPU to a new thread
|
||||
|
||||
static const FunctionDef* GetSVCInfo(u32 opcode) {
|
||||
u32 func_num = opcode & 0xFFFFFF; // 8 bits
|
||||
@ -73,17 +73,20 @@ static void RegisterAllModules() {
|
||||
}
|
||||
|
||||
void Init() {
|
||||
Service::Init();
|
||||
|
||||
RegisterAllModules();
|
||||
|
||||
Service::Init();
|
||||
ConfigMem::Init();
|
||||
SharedPage::Init();
|
||||
|
||||
g_reschedule = false;
|
||||
|
||||
LOG_DEBUG(Kernel, "initialized OK");
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
ConfigMem::Shutdown();
|
||||
SharedPage::Shutdown();
|
||||
Service::Shutdown();
|
||||
|
||||
g_module_db.clear();
|
||||
|
@ -14,11 +14,10 @@
|
||||
|
||||
namespace Kernel {
|
||||
|
||||
unsigned int Object::next_object_id = 0;
|
||||
|
||||
SharedPtr<Thread> g_main_thread = nullptr;
|
||||
unsigned int Object::next_object_id;
|
||||
SharedPtr<Thread> g_main_thread;
|
||||
HandleTable g_handle_table;
|
||||
u64 g_program_id = 0;
|
||||
u64 g_program_id;
|
||||
|
||||
void WaitObject::AddWaitingThread(SharedPtr<Thread> thread) {
|
||||
auto itr = std::find(waiting_threads.begin(), waiting_threads.end(), thread);
|
||||
@ -138,6 +137,10 @@ void HandleTable::Clear() {
|
||||
void Init() {
|
||||
Kernel::ThreadingInit();
|
||||
Kernel::TimersInit();
|
||||
|
||||
Object::next_object_id = 0;
|
||||
g_program_id = 0;
|
||||
g_main_thread = nullptr;
|
||||
}
|
||||
|
||||
/// Shutdown the kernel
|
||||
|
@ -95,12 +95,13 @@ public:
|
||||
return false;
|
||||
}
|
||||
|
||||
public:
|
||||
static unsigned int next_object_id;
|
||||
|
||||
private:
|
||||
friend void intrusive_ptr_add_ref(Object*);
|
||||
friend void intrusive_ptr_release(Object*);
|
||||
|
||||
static unsigned int next_object_id;
|
||||
|
||||
unsigned int ref_count = 0;
|
||||
unsigned int object_id = next_object_id++;
|
||||
};
|
||||
|
@ -23,7 +23,7 @@
|
||||
namespace Kernel {
|
||||
|
||||
/// Event type for the thread wake up event
|
||||
static int ThreadWakeupEventType = -1;
|
||||
static int ThreadWakeupEventType;
|
||||
|
||||
bool Thread::ShouldWait() {
|
||||
return status != THREADSTATUS_DEAD;
|
||||
@ -42,7 +42,7 @@ static Common::ThreadQueueList<Thread*, THREADPRIO_LOWEST+1> ready_queue;
|
||||
static Thread* current_thread;
|
||||
|
||||
// The first available thread id at startup
|
||||
static u32 next_thread_id = 1;
|
||||
static u32 next_thread_id;
|
||||
|
||||
/**
|
||||
* Creates a new thread ID
|
||||
@ -497,6 +497,12 @@ void Thread::SetWaitSynchronizationOutput(s32 output) {
|
||||
void ThreadingInit() {
|
||||
ThreadWakeupEventType = CoreTiming::RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
|
||||
|
||||
current_thread = nullptr;
|
||||
next_thread_id = 1;
|
||||
|
||||
thread_list.clear();
|
||||
ready_queue.clear();
|
||||
|
||||
// Setup the idle thread
|
||||
SetupIdleThread();
|
||||
}
|
||||
|
@ -12,7 +12,7 @@
|
||||
namespace Kernel {
|
||||
|
||||
/// The event type of the generic timer callback event
|
||||
static int timer_callback_event_type = -1;
|
||||
static int timer_callback_event_type;
|
||||
// TODO(yuriks): This can be removed if Timer objects are explicitly pooled in the future, allowing
|
||||
// us to simply use a pool index or similar.
|
||||
static Kernel::HandleTable timer_callback_handle_table;
|
||||
@ -89,6 +89,7 @@ static void TimerCallback(u64 timer_handle, int cycles_late) {
|
||||
}
|
||||
|
||||
void TimersInit() {
|
||||
timer_callback_handle_table.Clear();
|
||||
timer_callback_event_type = CoreTiming::RegisterEvent("TimerCallback", TimerCallback);
|
||||
}
|
||||
|
||||
|
@ -28,15 +28,15 @@ namespace APT {
|
||||
static const VAddr SHARED_FONT_VADDR = 0x18000000;
|
||||
|
||||
/// Handle to shared memory region designated to for shared system font
|
||||
static Kernel::SharedPtr<Kernel::SharedMemory> shared_font_mem = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::SharedMemory> shared_font_mem;
|
||||
|
||||
static Kernel::SharedPtr<Kernel::Mutex> lock = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::Event> notification_event = nullptr; ///< APT notification event
|
||||
static Kernel::SharedPtr<Kernel::Event> start_event = nullptr; ///< APT start event
|
||||
static Kernel::SharedPtr<Kernel::Mutex> lock;
|
||||
static Kernel::SharedPtr<Kernel::Event> notification_event; ///< APT notification event
|
||||
static Kernel::SharedPtr<Kernel::Event> start_event; ///< APT start event
|
||||
|
||||
static std::vector<u8> shared_font;
|
||||
|
||||
static u32 cpu_percent = 0; ///< CPU time available to the running application
|
||||
static u32 cpu_percent; ///< CPU time available to the running application
|
||||
|
||||
void Initialize(Service::Interface* self) {
|
||||
u32* cmd_buff = Kernel::GetCommandBuffer();
|
||||
@ -309,6 +309,7 @@ void Init() {
|
||||
}
|
||||
|
||||
lock = Kernel::Mutex::Create(false, "APT_U:Lock");
|
||||
|
||||
cpu_percent = 0;
|
||||
|
||||
// TODO(bunnei): Check if these are created in Initialize or on APT process startup.
|
||||
@ -317,7 +318,11 @@ void Init() {
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
|
||||
shared_font.clear();
|
||||
shared_font_mem = nullptr;
|
||||
lock = nullptr;
|
||||
notification_event = nullptr;
|
||||
start_event = nullptr;
|
||||
}
|
||||
|
||||
} // namespace APT
|
||||
|
@ -207,6 +207,7 @@ void Init() {
|
||||
|
||||
// Initialize the Username block
|
||||
// TODO(Subv): Initialize this directly in the variable when MSVC supports char16_t string literals
|
||||
memset(&CONSOLE_USERNAME_BLOCK, 0, sizeof(CONSOLE_USERNAME_BLOCK));
|
||||
CONSOLE_USERNAME_BLOCK.ng_word = 0;
|
||||
CONSOLE_USERNAME_BLOCK.zero = 0;
|
||||
|
||||
@ -219,7 +220,6 @@ void Init() {
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
|
||||
}
|
||||
|
||||
} // namespace CFG
|
||||
|
@ -11,7 +11,7 @@
|
||||
|
||||
namespace DSP_DSP {
|
||||
|
||||
static u32 read_pipe_count = 0;
|
||||
static u32 read_pipe_count;
|
||||
static Kernel::SharedPtr<Kernel::Event> semaphore_event;
|
||||
static Kernel::SharedPtr<Kernel::Event> interrupt_event;
|
||||
|
||||
|
@ -20,17 +20,17 @@ namespace HID {
|
||||
static const int MAX_CIRCLEPAD_POS = 0x9C; ///< Max value for a circle pad position
|
||||
|
||||
// Handle to shared memory region designated to HID_User service
|
||||
static Kernel::SharedPtr<Kernel::SharedMemory> shared_mem = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::SharedMemory> shared_mem;
|
||||
|
||||
// Event handles
|
||||
static Kernel::SharedPtr<Kernel::Event> event_pad_or_touch_1 = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::Event> event_pad_or_touch_2 = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::Event> event_accelerometer = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::Event> event_gyroscope = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::Event> event_debug_pad = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::Event> event_pad_or_touch_1;
|
||||
static Kernel::SharedPtr<Kernel::Event> event_pad_or_touch_2;
|
||||
static Kernel::SharedPtr<Kernel::Event> event_accelerometer;
|
||||
static Kernel::SharedPtr<Kernel::Event> event_gyroscope;
|
||||
static Kernel::SharedPtr<Kernel::Event> event_debug_pad;
|
||||
|
||||
static u32 next_pad_index = 0;
|
||||
static u32 next_touch_index = 0;
|
||||
static u32 next_pad_index;
|
||||
static u32 next_touch_index;
|
||||
|
||||
// TODO(peachum):
|
||||
// Add a method for setting analog input from joystick device for the circle Pad.
|
||||
@ -175,6 +175,12 @@ void Init() {
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
shared_mem = nullptr;
|
||||
event_pad_or_touch_1 = nullptr;
|
||||
event_pad_or_touch_2 = nullptr;
|
||||
event_accelerometer = nullptr;
|
||||
event_gyroscope = nullptr;
|
||||
event_debug_pad = nullptr;
|
||||
}
|
||||
|
||||
} // namespace HID
|
||||
|
@ -15,8 +15,8 @@
|
||||
namespace Service {
|
||||
namespace IR {
|
||||
|
||||
static Kernel::SharedPtr<Kernel::Event> handle_event = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::SharedMemory> shared_memory = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::Event> handle_event;
|
||||
static Kernel::SharedPtr<Kernel::SharedMemory> shared_memory;
|
||||
|
||||
void GetHandles(Service::Interface* self) {
|
||||
u32* cmd_buff = Kernel::GetCommandBuffer();
|
||||
@ -41,6 +41,8 @@ void Init() {
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
shared_memory = nullptr;
|
||||
handle_event = nullptr;
|
||||
}
|
||||
|
||||
} // namespace IR
|
||||
|
@ -11,7 +11,7 @@
|
||||
|
||||
namespace NWM_UDS {
|
||||
|
||||
static Kernel::SharedPtr<Kernel::Event> handle_event = nullptr;
|
||||
static Kernel::SharedPtr<Kernel::Event> handle_event;
|
||||
|
||||
/**
|
||||
* NWM_UDS::Shutdown service function
|
||||
|
@ -18,9 +18,9 @@ static const GameCoin default_game_coin = { 0x4F00, 42, 0, 0, 0, 2014, 12, 29 };
|
||||
/// Id of the SharedExtData archive used by the PTM process
|
||||
static const std::vector<u8> ptm_shared_extdata_id = {0, 0, 0, 0, 0x0B, 0, 0, 0xF0, 0, 0, 0, 0};
|
||||
|
||||
static bool shell_open = true;
|
||||
static bool shell_open;
|
||||
|
||||
static bool battery_is_charging = true;
|
||||
static bool battery_is_charging;
|
||||
|
||||
u32 GetAdapterState() {
|
||||
// TODO(purpasmart96): This function is only a stub,
|
||||
@ -43,6 +43,9 @@ void Init() {
|
||||
AddService(new PTM_Sysm_Interface);
|
||||
AddService(new PTM_U_Interface);
|
||||
|
||||
shell_open = true;
|
||||
battery_is_charging = true;
|
||||
|
||||
// Open the SharedExtSaveData archive 0xF000000B and create the gamecoin.dat file if it doesn't exist
|
||||
FileSys::Path archive_path(ptm_shared_extdata_id);
|
||||
auto archive_result = Service::FS::OpenArchive(Service::FS::ArchiveIdCode::SharedExtSaveData, archive_path);
|
||||
|
@ -11,7 +11,7 @@
|
||||
|
||||
namespace Y2R_U {
|
||||
|
||||
static Kernel::SharedPtr<Kernel::Event> completion_event = 0;
|
||||
static Kernel::SharedPtr<Kernel::Event> completion_event;
|
||||
|
||||
/**
|
||||
* Y2R_U::IsBusyConversion service function
|
||||
|
@ -62,6 +62,8 @@ template void Read<u16>(u16 &var, const u32 addr);
|
||||
template void Read<u8>(u8 &var, const u32 addr);
|
||||
|
||||
void Set3DSlider(float amount) {
|
||||
memset(&shared_page, 0, sizeof(shared_page));
|
||||
|
||||
shared_page.sliderstate_3d = amount;
|
||||
shared_page.ledstate_3d = (amount == 0.0f); // off when non-zero
|
||||
}
|
||||
@ -71,4 +73,7 @@ void Init() {
|
||||
Set3DSlider(0.0f);
|
||||
}
|
||||
|
||||
void Shutdown() {
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
@ -23,4 +23,6 @@ void Set3DSlider(float amount);
|
||||
|
||||
void Init();
|
||||
|
||||
void Shutdown();
|
||||
|
||||
} // namespace
|
||||
|
@ -29,8 +29,7 @@ namespace GPU {
|
||||
Regs g_regs;
|
||||
|
||||
/// True if the current frame was skipped
|
||||
bool g_skip_frame = false;
|
||||
|
||||
bool g_skip_frame;
|
||||
/// 268MHz / gpu_refresh_rate frames per second
|
||||
static u64 frame_ticks;
|
||||
/// Event id for CoreTiming
|
||||
@ -38,7 +37,7 @@ static int vblank_event;
|
||||
/// Total number of frames drawn
|
||||
static u64 frame_count;
|
||||
/// True if the last frame was skipped
|
||||
static bool last_skip_frame = false;
|
||||
static bool last_skip_frame;
|
||||
|
||||
template <typename T>
|
||||
inline void Read(T &var, const u32 raw_addr) {
|
||||
@ -320,6 +319,8 @@ static void VBlankCallback(u64 userdata, int cycles_late) {
|
||||
|
||||
/// Initialize hardware
|
||||
void Init() {
|
||||
memset(&g_regs, 0, sizeof(g_regs));
|
||||
|
||||
auto& framebuffer_top = g_regs.framebuffer_config[0];
|
||||
auto& framebuffer_sub = g_regs.framebuffer_config[1];
|
||||
|
||||
@ -349,6 +350,7 @@ void Init() {
|
||||
frame_ticks = 268123480 / Settings::values.gpu_refresh_rate;
|
||||
last_skip_frame = false;
|
||||
g_skip_frame = false;
|
||||
frame_count = 0;
|
||||
|
||||
vblank_event = CoreTiming::RegisterEvent("GPU::VBlankCallback", VBlankCallback);
|
||||
CoreTiming::ScheduleEvent(frame_ticks, vblank_event);
|
||||
|
@ -63,6 +63,8 @@ void Init() {
|
||||
|
||||
/// Shutdown hardware
|
||||
void Shutdown() {
|
||||
GPU::Shutdown();
|
||||
LCD::Shutdown();
|
||||
LOG_DEBUG(HW, "shutdown OK");
|
||||
}
|
||||
|
||||
|
@ -55,6 +55,7 @@ template void Write<u8>(u32 addr, const u8 data);
|
||||
|
||||
/// Initialize hardware
|
||||
void Init() {
|
||||
memset(&g_regs, 0, sizeof(g_regs));
|
||||
LOG_DEBUG(HW_LCD, "initialized OK");
|
||||
}
|
||||
|
||||
|
@ -11,30 +11,30 @@
|
||||
|
||||
namespace Memory {
|
||||
|
||||
u8* g_base = nullptr; ///< The base pointer to the auto-mirrored arena.
|
||||
u8* g_base; ///< The base pointer to the auto-mirrored arena.
|
||||
|
||||
static MemArena arena; ///< The MemArena class
|
||||
static MemArena arena; ///< The MemArena class
|
||||
|
||||
u8* g_exefs_code = nullptr; ///< ExeFS:/.code is loaded here
|
||||
u8* g_system_mem = nullptr; ///< System memory
|
||||
u8* g_heap = nullptr; ///< Application heap (main memory)
|
||||
u8* g_heap_linear = nullptr; ///< Linear heap
|
||||
u8* g_vram = nullptr; ///< Video memory (VRAM) pointer
|
||||
u8* g_shared_mem = nullptr; ///< Shared memory
|
||||
u8* g_dsp_mem = nullptr; ///< DSP memory
|
||||
u8* g_kernel_mem; ///< Kernel memory
|
||||
u8* g_exefs_code; ///< ExeFS:/.code is loaded here
|
||||
u8* g_system_mem; ///< System memory
|
||||
u8* g_heap; ///< Application heap (main memory)
|
||||
u8* g_heap_linear; ///< Linear heap
|
||||
u8* g_vram; ///< Video memory (VRAM) pointer
|
||||
u8* g_shared_mem; ///< Shared memory
|
||||
u8* g_dsp_mem; ///< DSP memory
|
||||
u8* g_kernel_mem; ///< Kernel memory
|
||||
|
||||
static u8* physical_bootrom = nullptr; ///< Bootrom physical memory
|
||||
static u8* uncached_bootrom = nullptr;
|
||||
static u8* physical_bootrom; ///< Bootrom physical memory
|
||||
static u8* uncached_bootrom;
|
||||
|
||||
static u8* physical_exefs_code = nullptr; ///< Phsical ExeFS:/.code is loaded here
|
||||
static u8* physical_system_mem = nullptr; ///< System physical memory
|
||||
static u8* physical_fcram = nullptr; ///< Main physical memory (FCRAM)
|
||||
static u8* physical_heap_gsp = nullptr; ///< GSP heap physical memory
|
||||
static u8* physical_vram = nullptr; ///< Video physical memory (VRAM)
|
||||
static u8* physical_shared_mem = nullptr; ///< Physical shared memory
|
||||
static u8* physical_dsp_mem = nullptr; ///< Physical DSP memory
|
||||
static u8* physical_kernel_mem; ///< Kernel memory
|
||||
static u8* physical_exefs_code; ///< Phsical ExeFS:/.code is loaded here
|
||||
static u8* physical_system_mem; ///< System physical memory
|
||||
static u8* physical_fcram; ///< Main physical memory (FCRAM)
|
||||
static u8* physical_heap_gsp; ///< GSP heap physical memory
|
||||
static u8* physical_vram; ///< Video physical memory (VRAM)
|
||||
static u8* physical_shared_mem; ///< Physical shared memory
|
||||
static u8* physical_dsp_mem; ///< Physical DSP memory
|
||||
static u8* physical_kernel_mem; ///< Kernel memory
|
||||
|
||||
// We don't declare the IO region in here since its handled by other means.
|
||||
static MemoryView g_views[] = {
|
||||
@ -73,6 +73,7 @@ void Init() {
|
||||
}
|
||||
|
||||
g_base = MemoryMap_Setup(g_views, kNumMemViews, flags, &arena);
|
||||
MemBlock_Init();
|
||||
|
||||
LOG_DEBUG(HW_Memory, "initialized OK, RAM at %p (mirror at 0 @ %p)", g_heap,
|
||||
physical_fcram);
|
||||
@ -81,9 +82,29 @@ void Init() {
|
||||
void Shutdown() {
|
||||
u32 flags = 0;
|
||||
MemoryMap_Shutdown(g_views, kNumMemViews, flags, &arena);
|
||||
|
||||
arena.ReleaseSpace();
|
||||
MemBlock_Shutdown();
|
||||
|
||||
g_base = nullptr;
|
||||
g_exefs_code = nullptr;
|
||||
g_system_mem = nullptr;
|
||||
g_heap = nullptr;
|
||||
g_heap_linear = nullptr;
|
||||
g_vram = nullptr;
|
||||
g_shared_mem = nullptr;
|
||||
g_dsp_mem = nullptr;
|
||||
g_kernel_mem = nullptr;
|
||||
|
||||
physical_bootrom = nullptr;
|
||||
uncached_bootrom = nullptr;
|
||||
physical_exefs_code = nullptr;
|
||||
physical_system_mem = nullptr;
|
||||
physical_fcram = nullptr;
|
||||
physical_heap_gsp = nullptr;
|
||||
physical_vram = nullptr;
|
||||
physical_shared_mem = nullptr;
|
||||
physical_dsp_mem = nullptr;
|
||||
physical_kernel_mem = nullptr;
|
||||
|
||||
LOG_DEBUG(HW_Memory, "shutdown OK");
|
||||
}
|
||||
|
@ -171,6 +171,12 @@ u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions);
|
||||
*/
|
||||
u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions);
|
||||
|
||||
/// Initialize mapped memory blocks
|
||||
void MemBlock_Init();
|
||||
|
||||
/// Shutdown mapped memory blocks
|
||||
void MemBlock_Shutdown();
|
||||
|
||||
inline const char* GetCharPointer(const VAddr address) {
|
||||
return (const char *)GetPointer(address);
|
||||
}
|
||||
|
@ -15,7 +15,6 @@ namespace Memory {
|
||||
|
||||
static std::map<u32, MemoryBlock> heap_map;
|
||||
static std::map<u32, MemoryBlock> heap_linear_map;
|
||||
static std::map<u32, MemoryBlock> shared_map;
|
||||
|
||||
/// Convert a physical address to virtual address
|
||||
VAddr PhysicalToVirtualAddress(const PAddr addr) {
|
||||
@ -185,12 +184,6 @@ u8 *GetPointer(const VAddr vaddr) {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Maps a block of memory on the heap
|
||||
* @param size Size of block in bytes
|
||||
* @param operation Memory map operation type
|
||||
* @param flags Memory allocation flags
|
||||
*/
|
||||
u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions) {
|
||||
MemoryBlock block;
|
||||
|
||||
@ -208,12 +201,6 @@ u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions) {
|
||||
return block.GetVirtualAddress();
|
||||
}
|
||||
|
||||
/**
|
||||
* Maps a block of memory on the linear heap
|
||||
* @param size Size of block in bytes
|
||||
* @param operation Memory map operation type
|
||||
* @param flags Memory allocation flags
|
||||
*/
|
||||
u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions) {
|
||||
MemoryBlock block;
|
||||
|
||||
@ -231,6 +218,14 @@ u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions) {
|
||||
return block.GetVirtualAddress();
|
||||
}
|
||||
|
||||
void MemBlock_Init() {
|
||||
}
|
||||
|
||||
void MemBlock_Shutdown() {
|
||||
heap_map.clear();
|
||||
heap_linear_map.clear();
|
||||
}
|
||||
|
||||
u8 Read8(const VAddr addr) {
|
||||
u8 data = 0;
|
||||
Read<u8>(data, addr);
|
||||
|
Loading…
Reference in New Issue
Block a user