diff options
Diffstat (limited to 'src/core')
26 files changed, 966 insertions, 70 deletions
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 5d74e4546..3621449b3 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -29,6 +29,8 @@ set(SRCS file_sys/ivfc_archive.cpp file_sys/path_parser.cpp file_sys/savedata_archive.cpp + frontend/emu_window.cpp + frontend/key_map.cpp gdbstub/gdbstub.cpp hle/config_mem.cpp hle/applets/applet.cpp @@ -123,7 +125,14 @@ set(SRCS hle/service/nim/nim_s.cpp hle/service/nim/nim_u.cpp hle/service/ns_s.cpp - hle/service/nwm_uds.cpp + hle/service/nwm/nwm.cpp + hle/service/nwm/nwm_cec.cpp + hle/service/nwm/nwm_ext.cpp + hle/service/nwm/nwm_inf.cpp + hle/service/nwm/nwm_sap.cpp + hle/service/nwm/nwm_soc.cpp + hle/service/nwm/nwm_tst.cpp + hle/service/nwm/nwm_uds.cpp hle/service/pm_app.cpp hle/service/ptm/ptm.cpp hle/service/ptm/ptm_gets.cpp @@ -191,6 +200,8 @@ set(HEADERS file_sys/ivfc_archive.h file_sys/path_parser.h file_sys/savedata_archive.h + frontend/emu_window.h + frontend/key_map.h gdbstub/gdbstub.h hle/config_mem.h hle/function_wrappers.h @@ -288,7 +299,14 @@ set(HEADERS hle/service/nim/nim_s.h hle/service/nim/nim_u.h hle/service/ns_s.h - hle/service/nwm_uds.h + hle/service/nwm/nwm.h + hle/service/nwm/nwm_cec.h + hle/service/nwm/nwm_ext.h + hle/service/nwm/nwm_inf.h + hle/service/nwm/nwm_sap.h + hle/service/nwm/nwm_soc.h + hle/service/nwm/nwm_tst.h + hle/service/nwm/nwm_uds.h hle/service/pm_app.h hle/service/ptm/ptm.h hle/service/ptm/ptm_gets.h diff --git a/src/core/core.cpp b/src/core/core.cpp index ee5237096..202cd332b 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -159,6 +159,7 @@ void System::Shutdown() { Kernel::Shutdown(); HW::Shutdown(); CoreTiming::Shutdown(); + cpu_core.reset(); LOG_DEBUG(Core, "Shutdown OK"); } diff --git a/src/core/frontend/emu_window.cpp b/src/core/frontend/emu_window.cpp new file mode 100644 index 000000000..f6f90f9e1 --- /dev/null +++ b/src/core/frontend/emu_window.cpp @@ -0,0 +1,107 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include <algorithm> +#include <cmath> +#include "common/assert.h" +#include "core/frontend/emu_window.h" +#include "core/frontend/key_map.h" +#include "video_core/video_core.h" + +void EmuWindow::ButtonPressed(Service::HID::PadState pad) { + pad_state.hex |= pad.hex; +} + +void EmuWindow::ButtonReleased(Service::HID::PadState pad) { + pad_state.hex &= ~pad.hex; +} + +void EmuWindow::CirclePadUpdated(float x, float y) { + constexpr int MAX_CIRCLEPAD_POS = 0x9C; // Max value for a circle pad position + + // Make sure the coordinates are in the unit circle, + // otherwise normalize it. + float r = x * x + y * y; + if (r > 1) { + r = std::sqrt(r); + x /= r; + y /= r; + } + + circle_pad_x = static_cast<s16>(x * MAX_CIRCLEPAD_POS); + circle_pad_y = static_cast<s16>(y * MAX_CIRCLEPAD_POS); +} + +/** + * Check if the given x/y coordinates are within the touchpad specified by the framebuffer layout + * @param layout FramebufferLayout object describing the framebuffer size and screen positions + * @param framebuffer_x Framebuffer x-coordinate to check + * @param framebuffer_y Framebuffer y-coordinate to check + * @return True if the coordinates are within the touchpad, otherwise false + */ +static bool IsWithinTouchscreen(const Layout::FramebufferLayout& layout, unsigned framebuffer_x, + unsigned framebuffer_y) { + return ( + framebuffer_y >= layout.bottom_screen.top && framebuffer_y < layout.bottom_screen.bottom && + framebuffer_x >= layout.bottom_screen.left && framebuffer_x < layout.bottom_screen.right); +} + +std::tuple<unsigned, unsigned> EmuWindow::ClipToTouchScreen(unsigned new_x, unsigned new_y) { + new_x = std::max(new_x, framebuffer_layout.bottom_screen.left); + new_x = std::min(new_x, framebuffer_layout.bottom_screen.right - 1); + + new_y = std::max(new_y, framebuffer_layout.bottom_screen.top); + new_y = std::min(new_y, framebuffer_layout.bottom_screen.bottom - 1); + + return std::make_tuple(new_x, new_y); +} + +void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) { + if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) + return; + + touch_x = VideoCore::kScreenBottomWidth * + (framebuffer_x - framebuffer_layout.bottom_screen.left) / + (framebuffer_layout.bottom_screen.right - framebuffer_layout.bottom_screen.left); + touch_y = VideoCore::kScreenBottomHeight * + (framebuffer_y - framebuffer_layout.bottom_screen.top) / + (framebuffer_layout.bottom_screen.bottom - framebuffer_layout.bottom_screen.top); + + touch_pressed = true; + pad_state.touch.Assign(1); +} + +void EmuWindow::TouchReleased() { + touch_pressed = false; + touch_x = 0; + touch_y = 0; + pad_state.touch.Assign(0); +} + +void EmuWindow::TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y) { + if (!touch_pressed) + return; + + if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y)) + std::tie(framebuffer_x, framebuffer_y) = ClipToTouchScreen(framebuffer_x, framebuffer_y); + + TouchPressed(framebuffer_x, framebuffer_y); +} + +void EmuWindow::UpdateCurrentFramebufferLayout(unsigned width, unsigned height) { + Layout::FramebufferLayout layout; + switch (Settings::values.layout_option) { + case Settings::LayoutOption::SingleScreen: + layout = Layout::SingleFrameLayout(width, height, Settings::values.swap_screen); + break; + case Settings::LayoutOption::LargeScreen: + layout = Layout::LargeFrameLayout(width, height, Settings::values.swap_screen); + break; + case Settings::LayoutOption::Default: + default: + layout = Layout::DefaultFrameLayout(width, height, Settings::values.swap_screen); + break; + } + NotifyFramebufferLayoutChanged(layout); +} diff --git a/src/core/frontend/emu_window.h b/src/core/frontend/emu_window.h new file mode 100644 index 000000000..835c4d500 --- /dev/null +++ b/src/core/frontend/emu_window.h @@ -0,0 +1,290 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include <tuple> +#include <utility> +#include "common/common_types.h" +#include "common/framebuffer_layout.h" +#include "common/math_util.h" +#include "core/hle/service/hid/hid.h" + +/** + * Abstraction class used to provide an interface between emulation code and the frontend + * (e.g. SDL, QGLWidget, GLFW, etc...). + * + * Design notes on the interaction between EmuWindow and the emulation core: + * - Generally, decisions on anything visible to the user should be left up to the GUI. + * For example, the emulation core should not try to dictate some window title or size. + * This stuff is not the core's business and only causes problems with regards to thread-safety + * anyway. + * - Under certain circumstances, it may be desirable for the core to politely request the GUI + * to set e.g. a minimum window size. However, the GUI should always be free to ignore any + * such hints. + * - EmuWindow may expose some of its state as read-only to the emulation core, however care + * should be taken to make sure the provided information is self-consistent. This requires + * some sort of synchronization (most of this is still a TODO). + * - DO NOT TREAT THIS CLASS AS A GUI TOOLKIT ABSTRACTION LAYER. That's not what it is. Please + * re-read the upper points again and think about it if you don't see this. + */ +class EmuWindow { +public: + /// Data structure to store emuwindow configuration + struct WindowConfig { + bool fullscreen; + int res_width; + int res_height; + std::pair<unsigned, unsigned> min_client_area_size; + }; + + /// Swap buffers to display the next frame + virtual void SwapBuffers() = 0; + + /// Polls window events + virtual void PollEvents() = 0; + + /// Makes the graphics context current for the caller thread + virtual void MakeCurrent() = 0; + + /// Releases (dunno if this is the "right" word) the GLFW context from the caller thread + virtual void DoneCurrent() = 0; + + virtual void ReloadSetKeymaps() = 0; + + /** + * Signals a button press action to the HID module. + * @param pad_state indicates which button to press + * @note only handles real buttons (A/B/X/Y/...), excluding analog inputs like the circle pad. + */ + void ButtonPressed(Service::HID::PadState pad_state); + + /** + * Signals a button release action to the HID module. + * @param pad_state indicates which button to press + * @note only handles real buttons (A/B/X/Y/...), excluding analog inputs like the circle pad. + */ + void ButtonReleased(Service::HID::PadState pad_state); + + /** + * Signals a circle pad change action to the HID module. + * @param x new x-coordinate of the circle pad, in the range [-1.0, 1.0] + * @param y new y-coordinate of the circle pad, in the range [-1.0, 1.0] + * @note the coordinates will be normalized if the radius is larger than 1 + */ + void CirclePadUpdated(float x, float y); + + /** + * Signal that a touch pressed event has occurred (e.g. mouse click pressed) + * @param framebuffer_x Framebuffer x-coordinate that was pressed + * @param framebuffer_y Framebuffer y-coordinate that was pressed + */ + void TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y); + + /// Signal that a touch released event has occurred (e.g. mouse click released) + void TouchReleased(); + + /** + * Signal that a touch movement event has occurred (e.g. mouse was moved over the emu window) + * @param framebuffer_x Framebuffer x-coordinate + * @param framebuffer_y Framebuffer y-coordinate + */ + void TouchMoved(unsigned framebuffer_x, unsigned framebuffer_y); + + /** + * Gets the current pad state (which buttons are pressed). + * @note This should be called by the core emu thread to get a state set by the window thread. + * @note This doesn't include analog input like circle pad direction + * @todo Fix this function to be thread-safe. + * @return PadState object indicating the current pad state + */ + Service::HID::PadState GetPadState() const { + return pad_state; + } + + /** + * Gets the current circle pad state. + * @note This should be called by the core emu thread to get a state set by the window thread. + * @todo Fix this function to be thread-safe. + * @return std::tuple of (x, y), where `x` and `y` are the circle pad coordinates + */ + std::tuple<s16, s16> GetCirclePadState() const { + return std::make_tuple(circle_pad_x, circle_pad_y); + } + + /** + * Gets the current touch screen state (touch X/Y coordinates and whether or not it is pressed). + * @note This should be called by the core emu thread to get a state set by the window thread. + * @todo Fix this function to be thread-safe. + * @return std::tuple of (x, y, pressed) where `x` and `y` are the touch coordinates and + * `pressed` is true if the touch screen is currently being pressed + */ + std::tuple<u16, u16, bool> GetTouchState() const { + return std::make_tuple(touch_x, touch_y, touch_pressed); + } + + /** + * Gets the current accelerometer state (acceleration along each three axis). + * Axis explained: + * +x is the same direction as LEFT on D-pad. + * +y is normal to the touch screen, pointing outward. + * +z is the same direction as UP on D-pad. + * Units: + * 1 unit of return value = 1/512 g (measured by hw test), + * where g is the gravitational acceleration (9.8 m/sec2). + * @note This should be called by the core emu thread to get a state set by the window thread. + * @todo Implement accelerometer input in front-end. + * @return std::tuple of (x, y, z) + */ + std::tuple<s16, s16, s16> GetAccelerometerState() const { + // stubbed + return std::make_tuple(0, -512, 0); + } + + /** + * Gets the current gyroscope state (angular rates about each three axis). + * Axis explained: + * +x is the same direction as LEFT on D-pad. + * +y is normal to the touch screen, pointing outward. + * +z is the same direction as UP on D-pad. + * Orientation is determined by right-hand rule. + * Units: + * 1 unit of return value = (1/coef) deg/sec, + * where coef is the return value of GetGyroscopeRawToDpsCoefficient(). + * @note This should be called by the core emu thread to get a state set by the window thread. + * @todo Implement gyroscope input in front-end. + * @return std::tuple of (x, y, z) + */ + std::tuple<s16, s16, s16> GetGyroscopeState() const { + // stubbed + return std::make_tuple(0, 0, 0); + } + + /** + * Gets the coefficient for units conversion of gyroscope state. + * The conversion formula is r = coefficient * v, + * where v is angular rate in deg/sec, + * and r is the gyroscope state. + * @return float-type coefficient + */ + f32 GetGyroscopeRawToDpsCoefficient() const { + return 14.375f; // taken from hw test, and gyroscope's document + } + + /** + * Returns currently active configuration. + * @note Accesses to the returned object need not be consistent because it may be modified in + * another thread + */ + const WindowConfig& GetActiveConfig() const { + return active_config; + } + + /** + * Requests the internal configuration to be replaced by the specified argument at some point in + * the future. + * @note This method is thread-safe, because it delays configuration changes to the GUI event + * loop. Hence there is no guarantee on when the requested configuration will be active. + */ + void SetConfig(const WindowConfig& val) { + config = val; + } + + /** + * Gets the framebuffer layout (width, height, and screen regions) + * @note This method is thread-safe + */ + const Layout::FramebufferLayout& GetFramebufferLayout() const { + return framebuffer_layout; + } + + /** + * Convenience method to update the current frame layout + * Read from the current settings to determine which layout to use. + */ + void UpdateCurrentFramebufferLayout(unsigned width, unsigned height); + +protected: + EmuWindow() { + // TODO: Find a better place to set this. + config.min_client_area_size = std::make_pair(400u, 480u); + active_config = config; + pad_state.hex = 0; + touch_x = 0; + touch_y = 0; + circle_pad_x = 0; + circle_pad_y = 0; + touch_pressed = false; + } + virtual ~EmuWindow() {} + + /** + * Processes any pending configuration changes from the last SetConfig call. + * This method invokes OnMinimalClientAreaChangeRequest if the corresponding configuration + * field changed. + * @note Implementations will usually want to call this from the GUI thread. + * @todo Actually call this in existing implementations. + */ + void ProcessConfigurationChanges() { + // TODO: For proper thread safety, we should eventually implement a proper + // multiple-writer/single-reader queue... + + if (config.min_client_area_size != active_config.min_client_area_size) { + OnMinimalClientAreaChangeRequest(config.min_client_area_size); + config.min_client_area_size = active_config.min_client_area_size; + } + } + + /** + * Update framebuffer layout with the given parameter. + * @note EmuWindow implementations will usually use this in window resize event handlers. + */ + void NotifyFramebufferLayoutChanged(const Layout::FramebufferLayout& layout) { + framebuffer_layout = layout; + } + + /** + * Update internal client area size with the given parameter. + * @note EmuWindow implementations will usually use this in window resize event handlers. + */ + void NotifyClientAreaSizeChanged(const std::pair<unsigned, unsigned>& size) { + client_area_width = size.first; + client_area_height = size.second; + } + +private: + /** + * Handler called when the minimal client area was requested to be changed via SetConfig. + * For the request to be honored, EmuWindow implementations will usually reimplement this + * function. + */ + virtual void OnMinimalClientAreaChangeRequest( + const std::pair<unsigned, unsigned>& minimal_size) { + // By default, ignore this request and do nothing. + } + + Layout::FramebufferLayout framebuffer_layout; ///< Current framebuffer layout + + unsigned client_area_width; ///< Current client width, should be set by window impl. + unsigned client_area_height; ///< Current client height, should be set by window impl. + + WindowConfig config; ///< Internal configuration (changes pending for being applied in + /// ProcessConfigurationChanges) + WindowConfig active_config; ///< Internal active configuration + + bool touch_pressed; ///< True if touchpad area is currently pressed, otherwise false + + u16 touch_x; ///< Touchpad X-position in native 3DS pixel coordinates (0-320) + u16 touch_y; ///< Touchpad Y-position in native 3DS pixel coordinates (0-240) + + s16 circle_pad_x; ///< Circle pad X-position in native 3DS pixel coordinates (-156 - 156) + s16 circle_pad_y; ///< Circle pad Y-position in native 3DS pixel coordinates (-156 - 156) + + /** + * Clip the provided coordinates to be inside the touchscreen area. + */ + std::tuple<unsigned, unsigned> ClipToTouchScreen(unsigned new_x, unsigned new_y); + + Service::HID::PadState pad_state; +}; diff --git a/src/core/frontend/key_map.cpp b/src/core/frontend/key_map.cpp new file mode 100644 index 000000000..15f0e079c --- /dev/null +++ b/src/core/frontend/key_map.cpp @@ -0,0 +1,152 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include <map> +#include "core/frontend/emu_window.h" +#include "core/frontend/key_map.h" + +namespace KeyMap { + +// TODO (wwylele): currently we treat c-stick as four direction buttons +// and map it directly to EmuWindow::ButtonPressed. +// It should go the analog input way like circle pad does. +const std::array<KeyTarget, Settings::NativeInput::NUM_INPUTS> mapping_targets = {{ + Service::HID::PAD_A, + Service::HID::PAD_B, + Service::HID::PAD_X, + Service::HID::PAD_Y, + Service::HID::PAD_L, + Service::HID::PAD_R, + Service::HID::PAD_ZL, + Service::HID::PAD_ZR, + Service::HID::PAD_START, + Service::HID::PAD_SELECT, + Service::HID::PAD_NONE, + Service::HID::PAD_UP, + Service::HID::PAD_DOWN, + Service::HID::PAD_LEFT, + Service::HID::PAD_RIGHT, + Service::HID::PAD_C_UP, + Service::HID::PAD_C_DOWN, + Service::HID::PAD_C_LEFT, + Service::HID::PAD_C_RIGHT, + + IndirectTarget::CirclePadUp, + IndirectTarget::CirclePadDown, + IndirectTarget::CirclePadLeft, + IndirectTarget::CirclePadRight, + IndirectTarget::CirclePadModifier, +}}; + +static std::map<HostDeviceKey, KeyTarget> key_map; +static int next_device_id = 0; + +static bool circle_pad_up = false; +static bool circle_pad_down = false; +static bool circle_pad_left = false; +static bool circle_pad_right = false; +static bool circle_pad_modifier = false; + +static void UpdateCirclePad(EmuWindow& emu_window) { + constexpr float SQRT_HALF = 0.707106781f; + int x = 0, y = 0; + + if (circle_pad_right) + ++x; + if (circle_pad_left) + --x; + if (circle_pad_up) + ++y; + if (circle_pad_down) + --y; + + float modifier = circle_pad_modifier ? Settings::values.pad_circle_modifier_scale : 1.0f; + emu_window.CirclePadUpdated(x * modifier * (y == 0 ? 1.0f : SQRT_HALF), + y * modifier * (x == 0 ? 1.0f : SQRT_HALF)); +} + +int NewDeviceId() { + return next_device_id++; +} + +void SetKeyMapping(HostDeviceKey key, KeyTarget target) { + key_map[key] = target; +} + +void ClearKeyMapping(int device_id) { + auto iter = key_map.begin(); + while (iter != key_map.end()) { + if (iter->first.device_id == device_id) + key_map.erase(iter++); + else + ++iter; + } +} + +void PressKey(EmuWindow& emu_window, HostDeviceKey key) { + auto target = key_map.find(key); + if (target == key_map.end()) + return; + + if (target->second.direct) { + emu_window.ButtonPressed({{target->second.target.direct_target_hex}}); + } else { + switch (target->second.target.indirect_target) { + case IndirectTarget::CirclePadUp: + circle_pad_up = true; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadDown: + circle_pad_down = true; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadLeft: + circle_pad_left = true; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadRight: + circle_pad_right = true; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadModifier: + circle_pad_modifier = true; + UpdateCirclePad(emu_window); + break; + } + } +} + +void ReleaseKey(EmuWindow& emu_window, HostDeviceKey key) { + auto target = key_map.find(key); + if (target == key_map.end()) + return; + + if (target->second.direct) { + emu_window.ButtonReleased({{target->second.target.direct_target_hex}}); + } else { + switch (target->second.target.indirect_target) { + case IndirectTarget::CirclePadUp: + circle_pad_up = false; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadDown: + circle_pad_down = false; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadLeft: + circle_pad_left = false; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadRight: + circle_pad_right = false; + UpdateCirclePad(emu_window); + break; + case IndirectTarget::CirclePadModifier: + circle_pad_modifier = false; + UpdateCirclePad(emu_window); + break; + } + } +} +} diff --git a/src/core/frontend/key_map.h b/src/core/frontend/key_map.h new file mode 100644 index 000000000..040794578 --- /dev/null +++ b/src/core/frontend/key_map.h @@ -0,0 +1,93 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include <array> +#include <tuple> +#include "core/hle/service/hid/hid.h" + +class EmuWindow; + +namespace KeyMap { + +/** + * Represents key mapping targets that are not real 3DS buttons. + * They will be handled by KeyMap and translated to 3DS input. + */ +enum class IndirectTarget { + CirclePadUp, + CirclePadDown, + CirclePadLeft, + CirclePadRight, + CirclePadModifier, +}; + +/** + * Represents a key mapping target. It can be a PadState that represents real 3DS buttons, + * or an IndirectTarget. + */ +struct KeyTarget { + bool direct; + union { + u32 direct_target_hex; + IndirectTarget indirect_target; + } target; + + KeyTarget() : direct(true) { + target.direct_target_hex = 0; + } + + KeyTarget(Service::HID::PadState pad) : direct(true) { + target.direct_target_hex = pad.hex; + } + + KeyTarget(IndirectTarget i) : direct(false) { + target.indirect_target = i; + } +}; + +/** + * Represents a key for a specific host device. + */ +struct HostDeviceKey { + int key_code; + int device_id; ///< Uniquely identifies a host device + + bool operator<(const HostDeviceKey& other) const { + return std::tie(key_code, device_id) < std::tie(other.key_code, other.device_id); + } + + bool operator==(const HostDeviceKey& other) const { + return std::tie(key_code, device_id) == std::tie(other.key_code, other.device_id); + } +}; + +extern const std::array<KeyTarget, Settings::NativeInput::NUM_INPUTS> mapping_targets; + +/** + * Generates a new device id, which uniquely identifies a host device within KeyMap. + */ +int NewDeviceId(); + +/** + * Maps a device-specific key to a target (a PadState or an IndirectTarget). + */ +void SetKeyMapping(HostDeviceKey key, KeyTarget target); + +/** + * Clears all key mappings belonging to one device. + */ +void ClearKeyMapping(int device_id); + +/** + * Maps a key press action and call the corresponding function in EmuWindow + */ +void PressKey(EmuWindow& emu_window, HostDeviceKey key); + +/** + * Maps a key release action and call the corresponding function in EmuWindow + */ +void ReleaseKey(EmuWindow& emu_window, HostDeviceKey key); +} diff --git a/src/core/hle/hle.cpp b/src/core/hle/hle.cpp deleted file mode 100644 index d73d98a70..000000000 --- a/src/core/hle/hle.cpp +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright 2014 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#include "common/assert.h" -#include "common/logging/log.h" -#include "core/arm/arm_interface.h" -#include "core/core.h" -#include "core/hle/hle.h" -#include "core/hle/service/service.h" - -//////////////////////////////////////////////////////////////////////////////////////////////////// - -namespace { - -bool reschedule; ///< If true, immediately reschedules the CPU to a new thread -} - -namespace HLE { - -void Reschedule(const char* reason) { - DEBUG_ASSERT_MSG(reason != nullptr && strlen(reason) < 256, - "Reschedule: Invalid or too long reason."); - - // TODO(bunnei): It seems that games depend on some CPU execution time elapsing during HLE - // routines. This simulates that time by artificially advancing the number of CPU "ticks". - // The value was chosen empirically, it seems to work well enough for everything tested, but - // is likely not ideal. We should find a more accurate way to simulate timing with HLE. - Core::AppCore().AddTicks(4000); - - Core::AppCore().PrepareReschedule(); - - reschedule = true; -} - -bool IsReschedulePending() { - return reschedule; -} - -void DoneRescheduling() { - reschedule = false; -} - -void Init() { - Service::Init(); - - reschedule = false; - - LOG_DEBUG(Kernel, "initialized OK"); -} - -void Shutdown() { - Service::Shutdown(); - - LOG_DEBUG(Kernel, "shutdown OK"); -} - -} // namespace diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index 18a1b6a16..676154bd4 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -3,9 +3,9 @@ // Refer to the license.txt file included. #include <cmath> -#include "common/emu_window.h" #include "common/logging/log.h" #include "core/core_timing.h" +#include "core/frontend/emu_window.h" #include "core/hle/kernel/event.h" #include "core/hle/kernel/shared_memory.h" #include "core/hle/service/hid/hid.h" diff --git a/src/core/hle/service/nwm/nwm.cpp b/src/core/hle/service/nwm/nwm.cpp new file mode 100644 index 000000000..9f1994dc3 --- /dev/null +++ b/src/core/hle/service/nwm/nwm.cpp @@ -0,0 +1,28 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include "core/hle/service/nwm/nwm.h" +#include "core/hle/service/nwm/nwm_cec.h" +#include "core/hle/service/nwm/nwm_ext.h" +#include "core/hle/service/nwm/nwm_inf.h" +#include "core/hle/service/nwm/nwm_sap.h" +#include "core/hle/service/nwm/nwm_soc.h" +#include "core/hle/service/nwm/nwm_tst.h" +#include "core/hle/service/nwm/nwm_uds.h" + +namespace Service { +namespace NWM { + +void Init() { + AddService(new NWM_CEC); + AddService(new NWM_EXT); + AddService(new NWM_INF); + AddService(new NWM_SAP); + AddService(new NWM_SOC); + AddService(new NWM_TST); + AddService(new NWM_UDS); +} + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm.h b/src/core/hle/service/nwm/nwm.h new file mode 100644 index 000000000..6926b29a6 --- /dev/null +++ b/src/core/hle/service/nwm/nwm.h @@ -0,0 +1,14 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +namespace Service { +namespace NWM { + +/// Initialize all NWM services +void Init(); + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_cec.cpp b/src/core/hle/service/nwm/nwm_cec.cpp new file mode 100644 index 000000000..7f03987df --- /dev/null +++ b/src/core/hle/service/nwm/nwm_cec.cpp @@ -0,0 +1,19 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include "core/hle/service/nwm/nwm_cec.h" + +namespace Service { +namespace NWM { + +const Interface::FunctionInfo FunctionTable[] = { + {0x000D0082, nullptr, "SendProbeRequest"}, +}; + +NWM_CEC::NWM_CEC() { + Register(FunctionTable); +} + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_cec.h b/src/core/hle/service/nwm/nwm_cec.h new file mode 100644 index 000000000..07b6addb5 --- /dev/null +++ b/src/core/hle/service/nwm/nwm_cec.h @@ -0,0 +1,22 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "core/hle/service/service.h" + +namespace Service { +namespace NWM { + +class NWM_CEC final : public Interface { +public: + NWM_CEC(); + + std::string GetPortName() const override { + return "nwm::CEC"; + } +}; + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_ext.cpp b/src/core/hle/service/nwm/nwm_ext.cpp new file mode 100644 index 000000000..605640a13 --- /dev/null +++ b/src/core/hle/service/nwm/nwm_ext.cpp @@ -0,0 +1,19 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include "core/hle/service/nwm/nwm_ext.h" + +namespace Service { +namespace NWM { + +const Interface::FunctionInfo FunctionTable[] = { + {0x00080040, nullptr, "ControlWirelessEnabled"}, +}; + +NWM_EXT::NWM_EXT() { + Register(FunctionTable); +} + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_ext.h b/src/core/hle/service/nwm/nwm_ext.h new file mode 100644 index 000000000..51d39d9ea --- /dev/null +++ b/src/core/hle/service/nwm/nwm_ext.h @@ -0,0 +1,22 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "core/hle/service/service.h" + +namespace Service { +namespace NWM { + +class NWM_EXT final : public Interface { +public: + NWM_EXT(); + + std::string GetPortName() const override { + return "nwm::EXT"; + } +}; + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_inf.cpp b/src/core/hle/service/nwm/nwm_inf.cpp new file mode 100644 index 000000000..c8470589b --- /dev/null +++ b/src/core/hle/service/nwm/nwm_inf.cpp @@ -0,0 +1,21 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include "core/hle/service/nwm/nwm_inf.h" + +namespace Service { +namespace NWM { + +const Interface::FunctionInfo FunctionTable[] = { + {0x000603C4, nullptr, "RecvBeaconBroadcastData"}, + {0x00070742, nullptr, "ConnectToEncryptedAP"}, + {0x00080302, nullptr, "ConnectToAP"}, +}; + +NWM_INF::NWM_INF() { + Register(FunctionTable); +} + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_inf.h b/src/core/hle/service/nwm/nwm_inf.h new file mode 100644 index 000000000..0043d769c --- /dev/null +++ b/src/core/hle/service/nwm/nwm_inf.h @@ -0,0 +1,22 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "core/hle/service/service.h" + +namespace Service { +namespace NWM { + +class NWM_INF final : public Interface { +public: + NWM_INF(); + + std::string GetPortName() const override { + return "nwm::INF"; + } +}; + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_sap.cpp b/src/core/hle/service/nwm/nwm_sap.cpp new file mode 100644 index 000000000..fd29ed761 --- /dev/null +++ b/src/core/hle/service/nwm/nwm_sap.cpp @@ -0,0 +1,20 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include "core/hle/service/nwm/nwm_sap.h" + +namespace Service { +namespace NWM { + +/* +const Interface::FunctionInfo FunctionTable[] = { +}; +*/ + +NWM_SAP::NWM_SAP() { + // Register(FunctionTable); +} + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_sap.h b/src/core/hle/service/nwm/nwm_sap.h new file mode 100644 index 000000000..f692e06d4 --- /dev/null +++ b/src/core/hle/service/nwm/nwm_sap.h @@ -0,0 +1,22 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "core/hle/service/service.h" + +namespace Service { +namespace NWM { + +class NWM_SAP final : public Interface { +public: + NWM_SAP(); + + std::string GetPortName() const override { + return "nwm::SAP"; + } +}; + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_soc.cpp b/src/core/hle/service/nwm/nwm_soc.cpp new file mode 100644 index 000000000..fdffcb925 --- /dev/null +++ b/src/core/hle/service/nwm/nwm_soc.cpp @@ -0,0 +1,20 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include "core/hle/service/nwm/nwm_soc.h" + +namespace Service { +namespace NWM { + +/* +const Interface::FunctionInfo FunctionTable[] = { +}; +*/ + +NWM_SOC::NWM_SOC() { + // Register(FunctionTable); +} + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_soc.h b/src/core/hle/service/nwm/nwm_soc.h new file mode 100644 index 000000000..594941d7e --- /dev/null +++ b/src/core/hle/service/nwm/nwm_soc.h @@ -0,0 +1,22 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "core/hle/service/service.h" + +namespace Service { +namespace NWM { + +class NWM_SOC final : public Interface { +public: + NWM_SOC(); + + std::string GetPortName() const override { + return "nwm::SOC"; + } +}; + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_tst.cpp b/src/core/hle/service/nwm/nwm_tst.cpp new file mode 100644 index 000000000..5f292e5db --- /dev/null +++ b/src/core/hle/service/nwm/nwm_tst.cpp @@ -0,0 +1,20 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include "core/hle/service/nwm/nwm_tst.h" + +namespace Service { +namespace NWM { + +/* +const Interface::FunctionInfo FunctionTable[] = { +}; +*/ + +NWM_TST::NWM_TST() { + // Register(FunctionTable); +} + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm/nwm_tst.h b/src/core/hle/service/nwm/nwm_tst.h new file mode 100644 index 000000000..8deca3216 --- /dev/null +++ b/src/core/hle/service/nwm/nwm_tst.h @@ -0,0 +1,22 @@ +// Copyright 2016 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "core/hle/service/service.h" + +namespace Service { +namespace NWM { + +class NWM_TST final : public Interface { +public: + NWM_TST(); + + std::string GetPortName() const override { + return "nwm::TST"; + } +}; + +} // namespace NWM +} // namespace Service diff --git a/src/core/hle/service/nwm_uds.cpp b/src/core/hle/service/nwm/nwm_uds.cpp index e3160d4b4..08fade320 100644 --- a/src/core/hle/service/nwm_uds.cpp +++ b/src/core/hle/service/nwm/nwm_uds.cpp @@ -5,12 +5,12 @@ #include "common/common_types.h" #include "common/logging/log.h" #include "core/hle/kernel/event.h" -#include "core/hle/service/nwm_uds.h" +#include "core/hle/service/nwm/nwm_uds.h" namespace Service { namespace NWM { -static Kernel::SharedPtr<Kernel::Event> handle_event; +static Kernel::SharedPtr<Kernel::Event> uds_handle_event; /** * NWM_UDS::Shutdown service function @@ -101,7 +101,7 @@ static void InitializeWithVersion(Interface* self) { /* cmd_buff[1] = RESULT_SUCCESS.raw; cmd_buff[2] = 0; - cmd_buff[3] = Kernel::g_handle_table.Create(handle_event) + cmd_buff[3] = Kernel::g_handle_table.Create(uds_handle_event) .MoveFrom(); // TODO(purpasmart): Verify if this is a event handle */ cmd_buff[0] = IPC::MakeHeader(0x1B, 1, 2); @@ -116,6 +116,7 @@ static void InitializeWithVersion(Interface* self) { } const Interface::FunctionInfo FunctionTable[] = { + {0x00010442, nullptr, "Initialize (deprecated)"}, {0x00020000, nullptr, "Scrap"}, {0x00030000, Shutdown, "Shutdown"}, {0x00040402, nullptr, "CreateNetwork (deprecated)"}, @@ -147,13 +148,13 @@ const Interface::FunctionInfo FunctionTable[] = { }; NWM_UDS::NWM_UDS() { - handle_event = Kernel::Event::Create(Kernel::ResetType::OneShot, "NWM_UDS::handle_event"); + uds_handle_event = Kernel::Event::Create(Kernel::ResetType::OneShot, "NWM::uds_handle_event"); Register(FunctionTable); } NWM_UDS::~NWM_UDS() { - handle_event = nullptr; + uds_handle_event = nullptr; } } // namespace NWM diff --git a/src/core/hle/service/nwm_uds.h b/src/core/hle/service/nwm/nwm_uds.h index 55db748f6..55db748f6 100644 --- a/src/core/hle/service/nwm_uds.h +++ b/src/core/hle/service/nwm/nwm_uds.h diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp index 25a7aeea8..7e52a05d9 100644 --- a/src/core/hle/service/service.cpp +++ b/src/core/hle/service/service.cpp @@ -35,7 +35,7 @@ #include "core/hle/service/nfc/nfc.h" #include "core/hle/service/nim/nim.h" #include "core/hle/service/ns_s.h" -#include "core/hle/service/nwm_uds.h" +#include "core/hle/service/nwm/nwm.h" #include "core/hle/service/pm_app.h" #include "core/hle/service/ptm/ptm.h" #include "core/hle/service/qtm/qtm.h" @@ -154,6 +154,7 @@ void Init() { NEWS::Init(); NFC::Init(); NIM::Init(); + NWM::Init(); PTM::Init(); QTM::Init(); @@ -166,7 +167,6 @@ void Init() { AddService(new LDR::LDR_RO); AddService(new MIC::MIC_U); AddService(new NS::NS_S); - AddService(new NWM::NWM_UDS); AddService(new PM::PM_APP); AddService(new SOC::SOC_U); AddService(new SSL::SSL_C); @@ -177,7 +177,6 @@ void Init() { /// Shutdown ServiceManager void Shutdown() { - PTM::Shutdown(); NIM::Shutdown(); NEWS::Shutdown(); diff --git a/src/core/settings.cpp b/src/core/settings.cpp index 626e06cd9..5d23c52f9 100644 --- a/src/core/settings.cpp +++ b/src/core/settings.cpp @@ -7,7 +7,7 @@ #include "settings.h" #include "video_core/video_core.h" -#include "common/emu_window.h" +#include "core/frontend/emu_window.h" namespace Settings { |