2018-01-13 22:22:39 +01:00
|
|
|
// Copyright 2018 yuzu emulator team
|
2018-01-08 03:27:58 +01:00
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2018-01-12 04:36:56 +01:00
|
|
|
#include <algorithm>
|
2018-02-12 01:03:31 +01:00
|
|
|
#include <array>
|
2018-09-13 22:43:31 +02:00
|
|
|
#include <cstring>
|
2018-03-21 11:09:40 +01:00
|
|
|
#include <memory>
|
2018-10-30 05:03:25 +01:00
|
|
|
#include <optional>
|
2018-07-23 20:52:32 +02:00
|
|
|
#include <type_traits>
|
2018-07-23 20:48:53 +02:00
|
|
|
#include <utility>
|
2018-10-30 05:03:25 +01:00
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
#include "common/alignment.h"
|
2018-09-13 22:43:31 +02:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/common_funcs.h"
|
|
|
|
#include "common/logging/log.h"
|
2018-07-18 02:11:41 +02:00
|
|
|
#include "common/math_util.h"
|
2018-09-13 22:43:31 +02:00
|
|
|
#include "common/swap.h"
|
2018-01-09 01:12:28 +01:00
|
|
|
#include "core/core_timing.h"
|
2018-01-08 03:27:58 +01:00
|
|
|
#include "core/hle/ipc_helpers.h"
|
2018-11-27 00:34:07 +01:00
|
|
|
#include "core/hle/kernel/readable_event.h"
|
2019-01-01 00:09:41 +01:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2018-11-27 00:34:07 +01:00
|
|
|
#include "core/hle/kernel/writable_event.h"
|
2019-06-07 17:34:55 +02:00
|
|
|
#include "core/hle/service/nvdrv/nvdata.h"
|
2018-02-14 04:12:46 +01:00
|
|
|
#include "core/hle/service/nvdrv/nvdrv.h"
|
2018-01-22 17:54:58 +01:00
|
|
|
#include "core/hle/service/nvflinger/buffer_queue.h"
|
2018-09-13 22:43:31 +02:00
|
|
|
#include "core/hle/service/nvflinger/nvflinger.h"
|
2019-02-26 23:20:02 +01:00
|
|
|
#include "core/hle/service/service.h"
|
2018-01-08 03:27:58 +01:00
|
|
|
#include "core/hle/service/vi/vi.h"
|
|
|
|
#include "core/hle/service/vi/vi_m.h"
|
2018-02-02 10:59:50 +01:00
|
|
|
#include "core/hle/service/vi/vi_s.h"
|
|
|
|
#include "core/hle/service/vi/vi_u.h"
|
2018-04-03 05:28:45 +02:00
|
|
|
#include "core/settings.h"
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-04-20 03:41:44 +02:00
|
|
|
namespace Service::VI {
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2019-01-05 01:31:14 +01:00
|
|
|
constexpr ResultCode ERR_OPERATION_FAILED{ErrorModule::VI, 1};
|
2019-02-26 23:49:32 +01:00
|
|
|
constexpr ResultCode ERR_PERMISSION_DENIED{ErrorModule::VI, 5};
|
2019-01-05 01:31:14 +01:00
|
|
|
constexpr ResultCode ERR_UNSUPPORTED{ErrorModule::VI, 6};
|
2019-02-05 22:20:04 +01:00
|
|
|
constexpr ResultCode ERR_NOT_FOUND{ErrorModule::VI, 7};
|
2019-01-05 01:31:14 +01:00
|
|
|
|
2018-02-07 13:11:17 +01:00
|
|
|
struct DisplayInfo {
|
2019-01-02 21:26:41 +01:00
|
|
|
/// The name of this particular display.
|
2018-02-07 13:11:17 +01:00
|
|
|
char display_name[0x40]{"Default"};
|
2019-01-02 21:26:41 +01:00
|
|
|
|
|
|
|
/// Whether or not the display has a limited number of layers.
|
|
|
|
u8 has_limited_layers{1};
|
2019-11-04 00:54:03 +01:00
|
|
|
INSERT_PADDING_BYTES(7);
|
2019-01-02 21:26:41 +01:00
|
|
|
|
|
|
|
/// Indicates the total amount of layers supported by the display.
|
|
|
|
/// @note This is only valid if has_limited_layers is set.
|
|
|
|
u64 max_layers{1};
|
|
|
|
|
|
|
|
/// Maximum width in pixels.
|
2019-01-02 22:14:40 +01:00
|
|
|
u64 width{1920};
|
2019-01-02 21:26:41 +01:00
|
|
|
|
|
|
|
/// Maximum height in pixels.
|
2019-01-02 22:14:40 +01:00
|
|
|
u64 height{1080};
|
2018-02-07 13:11:17 +01:00
|
|
|
};
|
|
|
|
static_assert(sizeof(DisplayInfo) == 0x60, "DisplayInfo has wrong size");
|
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
class Parcel {
|
|
|
|
public:
|
|
|
|
// This default size was chosen arbitrarily.
|
2018-09-15 15:21:06 +02:00
|
|
|
static constexpr std::size_t DefaultBufferSize = 0x40;
|
2018-01-08 03:27:58 +01:00
|
|
|
Parcel() : buffer(DefaultBufferSize) {}
|
2018-01-18 02:21:14 +01:00
|
|
|
explicit Parcel(std::vector<u8> data) : buffer(std::move(data)) {}
|
2018-01-08 03:27:58 +01:00
|
|
|
virtual ~Parcel() = default;
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
T Read() {
|
2018-07-23 20:52:32 +02:00
|
|
|
static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
|
2018-02-17 19:54:59 +01:00
|
|
|
ASSERT(read_index + sizeof(T) <= buffer.size());
|
2018-07-23 20:52:32 +02:00
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
T val;
|
|
|
|
std::memcpy(&val, buffer.data() + read_index, sizeof(T));
|
|
|
|
read_index += sizeof(T);
|
|
|
|
read_index = Common::AlignUp(read_index, 4);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
T ReadUnaligned() {
|
2018-07-23 20:52:32 +02:00
|
|
|
static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
|
2018-02-17 19:54:59 +01:00
|
|
|
ASSERT(read_index + sizeof(T) <= buffer.size());
|
2018-07-23 20:52:32 +02:00
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
T val;
|
|
|
|
std::memcpy(&val, buffer.data() + read_index, sizeof(T));
|
|
|
|
read_index += sizeof(T);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2018-09-15 15:21:06 +02:00
|
|
|
std::vector<u8> ReadBlock(std::size_t length) {
|
2018-02-17 19:54:59 +01:00
|
|
|
ASSERT(read_index + length <= buffer.size());
|
2018-01-18 02:08:02 +01:00
|
|
|
const u8* const begin = buffer.data() + read_index;
|
|
|
|
const u8* const end = begin + length;
|
|
|
|
std::vector<u8> data(begin, end);
|
2018-01-08 03:27:58 +01:00
|
|
|
read_index += length;
|
|
|
|
read_index = Common::AlignUp(read_index, 4);
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::u16string ReadInterfaceToken() {
|
|
|
|
u32 unknown = Read<u32_le>();
|
|
|
|
u32 length = Read<u32_le>();
|
|
|
|
|
|
|
|
std::u16string token{};
|
|
|
|
|
|
|
|
for (u32 ch = 0; ch < length + 1; ++ch) {
|
|
|
|
token.push_back(ReadUnaligned<u16_le>());
|
|
|
|
}
|
|
|
|
|
|
|
|
read_index = Common::AlignUp(read_index, 4);
|
|
|
|
|
|
|
|
return token;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
void Write(const T& val) {
|
2018-07-23 20:52:32 +02:00
|
|
|
static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
|
|
|
|
|
|
|
|
if (buffer.size() < write_index + sizeof(T)) {
|
2018-01-08 03:27:58 +01:00
|
|
|
buffer.resize(buffer.size() + sizeof(T) + DefaultBufferSize);
|
2018-07-23 20:52:32 +02:00
|
|
|
}
|
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
std::memcpy(buffer.data() + write_index, &val, sizeof(T));
|
|
|
|
write_index += sizeof(T);
|
|
|
|
write_index = Common::AlignUp(write_index, 4);
|
|
|
|
}
|
|
|
|
|
2018-02-14 04:12:46 +01:00
|
|
|
template <typename T>
|
|
|
|
void WriteObject(const T& val) {
|
2018-07-23 20:52:32 +02:00
|
|
|
static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
|
|
|
|
|
|
|
|
const u32_le size = static_cast<u32>(sizeof(val));
|
2018-02-14 04:12:46 +01:00
|
|
|
Write(size);
|
|
|
|
// TODO(Subv): Support file descriptors.
|
|
|
|
Write<u32_le>(0); // Fd count.
|
|
|
|
Write(val);
|
|
|
|
}
|
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
void Deserialize() {
|
2018-02-17 19:54:59 +01:00
|
|
|
ASSERT(buffer.size() > sizeof(Header));
|
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
Header header{};
|
|
|
|
std::memcpy(&header, buffer.data(), sizeof(Header));
|
|
|
|
|
|
|
|
read_index = header.data_offset;
|
|
|
|
DeserializeData();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<u8> Serialize() {
|
|
|
|
ASSERT(read_index == 0);
|
|
|
|
write_index = sizeof(Header);
|
|
|
|
|
|
|
|
SerializeData();
|
|
|
|
|
|
|
|
Header header{};
|
2018-01-20 00:01:41 +01:00
|
|
|
header.data_size = static_cast<u32_le>(write_index - sizeof(Header));
|
2018-02-11 23:28:07 +01:00
|
|
|
header.data_offset = sizeof(Header);
|
|
|
|
header.objects_size = 4;
|
|
|
|
header.objects_offset = sizeof(Header) + header.data_size;
|
2018-01-08 03:27:58 +01:00
|
|
|
std::memcpy(buffer.data(), &header, sizeof(Header));
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
2018-01-18 02:16:48 +01:00
|
|
|
virtual void SerializeData() {}
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-01-18 02:16:48 +01:00
|
|
|
virtual void DeserializeData() {}
|
2018-01-08 03:27:58 +01:00
|
|
|
|
|
|
|
private:
|
|
|
|
struct Header {
|
|
|
|
u32_le data_size;
|
|
|
|
u32_le data_offset;
|
|
|
|
u32_le objects_size;
|
|
|
|
u32_le objects_offset;
|
|
|
|
};
|
|
|
|
static_assert(sizeof(Header) == 16, "ParcelHeader has wrong size");
|
|
|
|
|
|
|
|
std::vector<u8> buffer;
|
2018-09-15 15:21:06 +02:00
|
|
|
std::size_t read_index = 0;
|
|
|
|
std::size_t write_index = 0;
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class NativeWindow : public Parcel {
|
|
|
|
public:
|
2018-04-20 03:34:36 +02:00
|
|
|
explicit NativeWindow(u32 id) {
|
2018-01-08 03:27:58 +01:00
|
|
|
data.id = id;
|
|
|
|
}
|
|
|
|
~NativeWindow() override = default;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void SerializeData() override {
|
|
|
|
Write(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
struct Data {
|
|
|
|
u32_le magic = 2;
|
2018-02-11 23:28:07 +01:00
|
|
|
u32_le process_id = 1;
|
2018-01-08 03:27:58 +01:00
|
|
|
u32_le id;
|
2018-02-11 23:28:07 +01:00
|
|
|
INSERT_PADDING_WORDS(3);
|
2018-01-19 03:21:26 +01:00
|
|
|
std::array<u8, 8> dispdrv = {'d', 'i', 's', 'p', 'd', 'r', 'v', '\0'};
|
2018-02-11 23:28:07 +01:00
|
|
|
INSERT_PADDING_WORDS(2);
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
static_assert(sizeof(Data) == 0x28, "ParcelData has wrong size");
|
|
|
|
|
|
|
|
Data data{};
|
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPConnectRequestParcel : public Parcel {
|
|
|
|
public:
|
2018-07-23 20:48:53 +02:00
|
|
|
explicit IGBPConnectRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
|
2018-01-08 03:27:58 +01:00
|
|
|
Deserialize();
|
|
|
|
}
|
|
|
|
~IGBPConnectRequestParcel() override = default;
|
|
|
|
|
2018-01-18 02:16:48 +01:00
|
|
|
void DeserializeData() override {
|
2018-01-08 03:27:58 +01:00
|
|
|
std::u16string token = ReadInterfaceToken();
|
|
|
|
data = Read<Data>();
|
|
|
|
}
|
|
|
|
|
|
|
|
struct Data {
|
|
|
|
u32_le unk;
|
|
|
|
u32_le api;
|
|
|
|
u32_le producer_controlled_by_app;
|
|
|
|
};
|
|
|
|
|
|
|
|
Data data;
|
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPConnectResponseParcel : public Parcel {
|
|
|
|
public:
|
2018-04-20 03:34:36 +02:00
|
|
|
explicit IGBPConnectResponseParcel(u32 width, u32 height) {
|
2018-01-08 03:27:58 +01:00
|
|
|
data.width = width;
|
|
|
|
data.height = height;
|
|
|
|
}
|
|
|
|
~IGBPConnectResponseParcel() override = default;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void SerializeData() override {
|
|
|
|
Write(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
struct Data {
|
|
|
|
u32_le width;
|
|
|
|
u32_le height;
|
|
|
|
u32_le transform_hint;
|
|
|
|
u32_le num_pending_buffers;
|
|
|
|
u32_le status;
|
|
|
|
};
|
|
|
|
static_assert(sizeof(Data) == 20, "ParcelData has wrong size");
|
|
|
|
|
|
|
|
Data data{};
|
|
|
|
};
|
|
|
|
|
2018-11-17 23:10:10 +01:00
|
|
|
/// Represents a parcel containing one int '0' as its data
|
|
|
|
/// Used by DetachBuffer and Disconnect
|
|
|
|
class IGBPEmptyResponseParcel : public Parcel {
|
|
|
|
protected:
|
|
|
|
void SerializeData() override {
|
|
|
|
Write(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
struct Data {
|
|
|
|
u32_le unk_0;
|
|
|
|
};
|
|
|
|
|
|
|
|
Data data{};
|
|
|
|
};
|
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
class IGBPSetPreallocatedBufferRequestParcel : public Parcel {
|
|
|
|
public:
|
2018-07-23 20:48:53 +02:00
|
|
|
explicit IGBPSetPreallocatedBufferRequestParcel(std::vector<u8> buffer)
|
|
|
|
: Parcel(std::move(buffer)) {
|
2018-01-08 03:27:58 +01:00
|
|
|
Deserialize();
|
|
|
|
}
|
|
|
|
~IGBPSetPreallocatedBufferRequestParcel() override = default;
|
|
|
|
|
2018-01-18 02:16:48 +01:00
|
|
|
void DeserializeData() override {
|
2018-01-08 03:27:58 +01:00
|
|
|
std::u16string token = ReadInterfaceToken();
|
|
|
|
data = Read<Data>();
|
2018-01-22 17:54:58 +01:00
|
|
|
buffer = Read<NVFlinger::IGBPBuffer>();
|
2018-01-08 03:27:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
struct Data {
|
|
|
|
u32_le slot;
|
|
|
|
INSERT_PADDING_WORDS(1);
|
|
|
|
u32_le graphic_buffer_length;
|
|
|
|
INSERT_PADDING_WORDS(1);
|
|
|
|
};
|
|
|
|
|
|
|
|
Data data;
|
2018-01-22 17:54:58 +01:00
|
|
|
NVFlinger::IGBPBuffer buffer;
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPSetPreallocatedBufferResponseParcel : public Parcel {
|
|
|
|
protected:
|
|
|
|
void SerializeData() override {
|
|
|
|
// TODO(Subv): Find out what this means
|
|
|
|
Write<u32>(0);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPDequeueBufferRequestParcel : public Parcel {
|
|
|
|
public:
|
2018-07-23 20:48:53 +02:00
|
|
|
explicit IGBPDequeueBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
|
2018-01-08 03:27:58 +01:00
|
|
|
Deserialize();
|
|
|
|
}
|
|
|
|
~IGBPDequeueBufferRequestParcel() override = default;
|
|
|
|
|
2018-01-18 02:16:48 +01:00
|
|
|
void DeserializeData() override {
|
2018-01-08 03:27:58 +01:00
|
|
|
std::u16string token = ReadInterfaceToken();
|
|
|
|
data = Read<Data>();
|
|
|
|
}
|
|
|
|
|
|
|
|
struct Data {
|
|
|
|
u32_le pixel_format;
|
|
|
|
u32_le width;
|
|
|
|
u32_le height;
|
|
|
|
u32_le get_frame_timestamps;
|
|
|
|
u32_le usage;
|
|
|
|
};
|
|
|
|
|
|
|
|
Data data;
|
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPDequeueBufferResponseParcel : public Parcel {
|
|
|
|
public:
|
2019-06-07 17:34:55 +02:00
|
|
|
explicit IGBPDequeueBufferResponseParcel(u32 slot, Service::Nvidia::MultiFence& multi_fence)
|
|
|
|
: slot(slot), multi_fence(multi_fence) {}
|
2018-01-08 03:27:58 +01:00
|
|
|
~IGBPDequeueBufferResponseParcel() override = default;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void SerializeData() override {
|
2018-02-14 04:12:46 +01:00
|
|
|
Write(slot);
|
2018-02-14 04:51:24 +01:00
|
|
|
Write<u32_le>(1);
|
2019-06-07 17:34:55 +02:00
|
|
|
WriteObject(multi_fence);
|
2018-02-14 04:12:46 +01:00
|
|
|
Write<u32_le>(0);
|
2018-01-08 03:27:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
u32_le slot;
|
2019-06-07 17:34:55 +02:00
|
|
|
Service::Nvidia::MultiFence multi_fence;
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPRequestBufferRequestParcel : public Parcel {
|
|
|
|
public:
|
2018-07-23 20:48:53 +02:00
|
|
|
explicit IGBPRequestBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
|
2018-01-08 03:27:58 +01:00
|
|
|
Deserialize();
|
|
|
|
}
|
|
|
|
~IGBPRequestBufferRequestParcel() override = default;
|
|
|
|
|
2018-01-18 02:16:48 +01:00
|
|
|
void DeserializeData() override {
|
2018-01-08 03:27:58 +01:00
|
|
|
std::u16string token = ReadInterfaceToken();
|
|
|
|
slot = Read<u32_le>();
|
|
|
|
}
|
|
|
|
|
|
|
|
u32_le slot;
|
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPRequestBufferResponseParcel : public Parcel {
|
|
|
|
public:
|
2018-07-23 20:48:53 +02:00
|
|
|
explicit IGBPRequestBufferResponseParcel(NVFlinger::IGBPBuffer buffer) : buffer(buffer) {}
|
2018-01-08 03:27:58 +01:00
|
|
|
~IGBPRequestBufferResponseParcel() override = default;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void SerializeData() override {
|
2018-07-18 02:11:41 +02:00
|
|
|
// TODO(Subv): Figure out what this value means, writing non-zero here will make libnx
|
|
|
|
// try to read an IGBPBuffer object from the parcel.
|
2018-02-17 19:59:45 +01:00
|
|
|
Write<u32_le>(1);
|
|
|
|
WriteObject(buffer);
|
2018-01-08 03:27:58 +01:00
|
|
|
Write<u32_le>(0);
|
|
|
|
}
|
|
|
|
|
2018-01-22 17:54:58 +01:00
|
|
|
NVFlinger::IGBPBuffer buffer;
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPQueueBufferRequestParcel : public Parcel {
|
|
|
|
public:
|
2018-07-23 20:48:53 +02:00
|
|
|
explicit IGBPQueueBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
|
2018-01-08 03:27:58 +01:00
|
|
|
Deserialize();
|
|
|
|
}
|
|
|
|
~IGBPQueueBufferRequestParcel() override = default;
|
|
|
|
|
2018-01-18 02:16:48 +01:00
|
|
|
void DeserializeData() override {
|
2018-01-08 03:27:58 +01:00
|
|
|
std::u16string token = ReadInterfaceToken();
|
|
|
|
data = Read<Data>();
|
|
|
|
}
|
|
|
|
|
|
|
|
struct Data {
|
|
|
|
u32_le slot;
|
2018-02-12 01:03:31 +01:00
|
|
|
INSERT_PADDING_WORDS(3);
|
2018-01-08 03:27:58 +01:00
|
|
|
u32_le timestamp;
|
2018-02-12 01:03:31 +01:00
|
|
|
s32_le is_auto_timestamp;
|
|
|
|
s32_le crop_top;
|
2018-07-18 02:11:41 +02:00
|
|
|
s32_le crop_left;
|
2018-02-12 01:03:31 +01:00
|
|
|
s32_le crop_right;
|
|
|
|
s32_le crop_bottom;
|
|
|
|
s32_le scaling_mode;
|
|
|
|
NVFlinger::BufferQueue::BufferTransformFlags transform;
|
|
|
|
u32_le sticky_transform;
|
2019-06-04 22:10:07 +02:00
|
|
|
INSERT_PADDING_WORDS(1);
|
|
|
|
u32_le swap_interval;
|
2019-06-07 17:34:55 +02:00
|
|
|
Service::Nvidia::MultiFence multi_fence;
|
2018-07-18 02:11:41 +02:00
|
|
|
|
2019-02-27 04:47:49 +01:00
|
|
|
Common::Rectangle<int> GetCropRect() const {
|
2018-07-18 02:11:41 +02:00
|
|
|
return {crop_left, crop_top, crop_right, crop_bottom};
|
|
|
|
}
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
2019-06-07 17:34:55 +02:00
|
|
|
static_assert(sizeof(Data) == 96, "ParcelData has wrong size");
|
2018-01-08 03:27:58 +01:00
|
|
|
|
|
|
|
Data data;
|
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPQueueBufferResponseParcel : public Parcel {
|
|
|
|
public:
|
2018-04-20 03:34:36 +02:00
|
|
|
explicit IGBPQueueBufferResponseParcel(u32 width, u32 height) {
|
2018-01-08 03:27:58 +01:00
|
|
|
data.width = width;
|
|
|
|
data.height = height;
|
|
|
|
}
|
|
|
|
~IGBPQueueBufferResponseParcel() override = default;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void SerializeData() override {
|
|
|
|
Write(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
struct Data {
|
|
|
|
u32_le width;
|
|
|
|
u32_le height;
|
|
|
|
u32_le transform_hint;
|
|
|
|
u32_le num_pending_buffers;
|
|
|
|
u32_le status;
|
|
|
|
};
|
|
|
|
static_assert(sizeof(Data) == 20, "ParcelData has wrong size");
|
|
|
|
|
|
|
|
Data data{};
|
|
|
|
};
|
|
|
|
|
2018-01-21 17:13:47 +01:00
|
|
|
class IGBPQueryRequestParcel : public Parcel {
|
|
|
|
public:
|
2018-07-23 20:48:53 +02:00
|
|
|
explicit IGBPQueryRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
|
2018-01-21 17:13:47 +01:00
|
|
|
Deserialize();
|
|
|
|
}
|
|
|
|
~IGBPQueryRequestParcel() override = default;
|
|
|
|
|
|
|
|
void DeserializeData() override {
|
|
|
|
std::u16string token = ReadInterfaceToken();
|
|
|
|
type = Read<u32_le>();
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 type;
|
|
|
|
};
|
|
|
|
|
|
|
|
class IGBPQueryResponseParcel : public Parcel {
|
|
|
|
public:
|
2018-04-20 03:34:36 +02:00
|
|
|
explicit IGBPQueryResponseParcel(u32 value) : value(value) {}
|
2018-01-21 17:13:47 +01:00
|
|
|
~IGBPQueryResponseParcel() override = default;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
void SerializeData() override {
|
|
|
|
Write(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
u32_le value;
|
|
|
|
};
|
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
class IHOSBinderDriver final : public ServiceFramework<IHOSBinderDriver> {
|
|
|
|
public:
|
2018-01-22 17:54:58 +01:00
|
|
|
explicit IHOSBinderDriver(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
|
2018-01-09 00:18:50 +01:00
|
|
|
: ServiceFramework("IHOSBinderDriver"), nv_flinger(std::move(nv_flinger)) {
|
2018-01-08 03:27:58 +01:00
|
|
|
static const FunctionInfo functions[] = {
|
|
|
|
{0, &IHOSBinderDriver::TransactParcel, "TransactParcel"},
|
|
|
|
{1, &IHOSBinderDriver::AdjustRefcount, "AdjustRefcount"},
|
2018-01-15 23:20:08 +01:00
|
|
|
{2, &IHOSBinderDriver::GetNativeHandle, "GetNativeHandle"},
|
2018-02-14 03:39:58 +01:00
|
|
|
{3, &IHOSBinderDriver::TransactParcel, "TransactParcelAuto"},
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
enum class TransactionId {
|
|
|
|
RequestBuffer = 1,
|
|
|
|
SetBufferCount = 2,
|
|
|
|
DequeueBuffer = 3,
|
|
|
|
DetachBuffer = 4,
|
|
|
|
DetachNextBuffer = 5,
|
|
|
|
AttachBuffer = 6,
|
|
|
|
QueueBuffer = 7,
|
|
|
|
CancelBuffer = 8,
|
|
|
|
Query = 9,
|
|
|
|
Connect = 10,
|
|
|
|
Disconnect = 11,
|
|
|
|
|
|
|
|
AllocateBuffers = 13,
|
|
|
|
SetPreallocatedBuffer = 14
|
|
|
|
};
|
|
|
|
|
2018-02-14 03:54:12 +01:00
|
|
|
void TransactParcel(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u32 id = rp.Pop<u32>();
|
|
|
|
const auto transaction = static_cast<TransactionId>(rp.Pop<u32>());
|
|
|
|
const u32 flags = rp.Pop<u32>();
|
|
|
|
|
|
|
|
LOG_DEBUG(Service_VI, "called. id=0x{:08X} transaction={:X}, flags=0x{:08X}", id,
|
|
|
|
static_cast<u32>(transaction), flags);
|
2018-02-14 03:54:12 +01:00
|
|
|
|
2019-02-21 17:31:53 +01:00
|
|
|
auto& buffer_queue = nv_flinger->FindBufferQueue(id);
|
2018-11-26 07:06:13 +01:00
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
if (transaction == TransactionId::Connect) {
|
2018-02-14 03:54:12 +01:00
|
|
|
IGBPConnectRequestParcel request{ctx.ReadBuffer()};
|
2018-11-16 08:07:42 +01:00
|
|
|
IGBPConnectResponseParcel response{
|
2018-11-19 05:20:47 +01:00
|
|
|
static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedWidth) *
|
|
|
|
Settings::values.resolution_factor),
|
|
|
|
static_cast<u32>(static_cast<u32>(DisplayResolution::UndockedHeight) *
|
|
|
|
Settings::values.resolution_factor)};
|
2018-02-14 03:54:12 +01:00
|
|
|
ctx.WriteBuffer(response.Serialize());
|
2018-01-08 03:27:58 +01:00
|
|
|
} else if (transaction == TransactionId::SetPreallocatedBuffer) {
|
2018-02-14 03:54:12 +01:00
|
|
|
IGBPSetPreallocatedBufferRequestParcel request{ctx.ReadBuffer()};
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2019-02-21 17:31:53 +01:00
|
|
|
buffer_queue.SetPreallocatedBuffer(request.data.slot, request.buffer);
|
2018-01-08 03:27:58 +01:00
|
|
|
|
|
|
|
IGBPSetPreallocatedBufferResponseParcel response{};
|
2018-02-14 03:54:12 +01:00
|
|
|
ctx.WriteBuffer(response.Serialize());
|
2018-01-08 03:27:58 +01:00
|
|
|
} else if (transaction == TransactionId::DequeueBuffer) {
|
2018-02-14 03:54:12 +01:00
|
|
|
IGBPDequeueBufferRequestParcel request{ctx.ReadBuffer()};
|
2018-03-19 01:27:15 +01:00
|
|
|
const u32 width{request.data.width};
|
|
|
|
const u32 height{request.data.height};
|
2019-06-07 17:34:55 +02:00
|
|
|
auto result = buffer_queue.DequeueBuffer(width, height);
|
2018-03-19 01:27:15 +01:00
|
|
|
|
2019-06-07 17:34:55 +02:00
|
|
|
if (result) {
|
2018-03-19 01:27:15 +01:00
|
|
|
// Buffer is available
|
2019-07-01 17:10:27 +02:00
|
|
|
IGBPDequeueBufferResponseParcel response{result->first, *result->second};
|
2018-03-19 01:27:15 +01:00
|
|
|
ctx.WriteBuffer(response.Serialize());
|
|
|
|
} else {
|
|
|
|
// Wait the current thread until a buffer becomes available
|
2018-07-17 06:05:13 +02:00
|
|
|
ctx.SleepClientThread(
|
2019-11-12 11:38:12 +01:00
|
|
|
"IHOSBinderDriver::DequeueBuffer", UINT64_MAX,
|
2018-03-19 01:27:15 +01:00
|
|
|
[=](Kernel::SharedPtr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx,
|
2018-09-13 21:57:45 +02:00
|
|
|
Kernel::ThreadWakeupReason reason) {
|
2018-03-19 01:27:15 +01:00
|
|
|
// Repeat TransactParcel DequeueBuffer when a buffer is available
|
2019-02-21 17:31:53 +01:00
|
|
|
auto& buffer_queue = nv_flinger->FindBufferQueue(id);
|
2019-06-07 17:34:55 +02:00
|
|
|
auto result = buffer_queue.DequeueBuffer(width, height);
|
|
|
|
ASSERT_MSG(result != std::nullopt, "Could not dequeue buffer.");
|
2018-11-30 22:06:49 +01:00
|
|
|
|
2019-07-01 17:10:27 +02:00
|
|
|
IGBPDequeueBufferResponseParcel response{result->first, *result->second};
|
2018-03-19 01:27:15 +01:00
|
|
|
ctx.WriteBuffer(response.Serialize());
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
2018-07-17 06:05:13 +02:00
|
|
|
},
|
2019-02-21 17:31:53 +01:00
|
|
|
buffer_queue.GetWritableBufferWaitEvent());
|
2018-03-19 01:27:15 +01:00
|
|
|
}
|
2018-01-08 03:27:58 +01:00
|
|
|
} else if (transaction == TransactionId::RequestBuffer) {
|
2018-02-14 03:54:12 +01:00
|
|
|
IGBPRequestBufferRequestParcel request{ctx.ReadBuffer()};
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2019-02-21 17:31:53 +01:00
|
|
|
auto& buffer = buffer_queue.RequestBuffer(request.slot);
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
IGBPRequestBufferResponseParcel response{buffer};
|
2018-02-14 03:54:12 +01:00
|
|
|
ctx.WriteBuffer(response.Serialize());
|
2018-01-08 03:27:58 +01:00
|
|
|
} else if (transaction == TransactionId::QueueBuffer) {
|
2018-02-14 03:54:12 +01:00
|
|
|
IGBPQueueBufferRequestParcel request{ctx.ReadBuffer()};
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2019-02-21 17:31:53 +01:00
|
|
|
buffer_queue.QueueBuffer(request.data.slot, request.data.transform,
|
2019-06-07 17:34:55 +02:00
|
|
|
request.data.GetCropRect(), request.data.swap_interval,
|
|
|
|
request.data.multi_fence);
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
IGBPQueueBufferResponseParcel response{1280, 720};
|
2018-02-14 03:54:12 +01:00
|
|
|
ctx.WriteBuffer(response.Serialize());
|
2018-01-21 17:13:47 +01:00
|
|
|
} else if (transaction == TransactionId::Query) {
|
2018-02-14 03:54:12 +01:00
|
|
|
IGBPQueryRequestParcel request{ctx.ReadBuffer()};
|
2018-01-21 17:13:47 +01:00
|
|
|
|
2019-02-21 17:31:53 +01:00
|
|
|
const u32 value =
|
|
|
|
buffer_queue.Query(static_cast<NVFlinger::BufferQueue::QueryType>(request.type));
|
2018-01-21 17:13:47 +01:00
|
|
|
|
|
|
|
IGBPQueryResponseParcel response{value};
|
2018-02-14 03:54:12 +01:00
|
|
|
ctx.WriteBuffer(response.Serialize());
|
2018-02-13 03:15:53 +01:00
|
|
|
} else if (transaction == TransactionId::CancelBuffer) {
|
2018-07-18 04:47:35 +02:00
|
|
|
LOG_CRITICAL(Service_VI, "(STUBBED) called, transaction=CancelBuffer");
|
2018-11-17 23:10:10 +01:00
|
|
|
} else if (transaction == TransactionId::Disconnect ||
|
|
|
|
transaction == TransactionId::DetachBuffer) {
|
|
|
|
const auto buffer = ctx.ReadBuffer();
|
|
|
|
|
|
|
|
IGBPEmptyResponseParcel response{};
|
|
|
|
ctx.WriteBuffer(response.Serialize());
|
2018-01-08 03:27:58 +01:00
|
|
|
} else {
|
|
|
|
ASSERT_MSG(false, "Unimplemented");
|
|
|
|
}
|
2018-02-10 04:50:29 +01:00
|
|
|
|
2018-01-24 01:52:18 +01:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2018-01-08 03:27:58 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
void AdjustRefcount(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u32 id = rp.Pop<u32>();
|
|
|
|
const s32 addval = rp.PopRaw<s32>();
|
|
|
|
const u32 type = rp.Pop<u32>();
|
|
|
|
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called id={}, addval={:08X}, type={:08X}", id, addval,
|
2018-07-02 18:20:50 +02:00
|
|
|
type);
|
2018-11-26 07:06:13 +01:00
|
|
|
|
2018-01-24 01:52:18 +01:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2018-01-08 03:27:58 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
|
|
|
|
2018-01-15 23:20:08 +01:00
|
|
|
void GetNativeHandle(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u32 id = rp.Pop<u32>();
|
|
|
|
const u32 unknown = rp.Pop<u32>();
|
|
|
|
|
2018-11-26 07:06:13 +01:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called id={}, unknown={:08X}", id, unknown);
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2019-02-21 17:31:53 +01:00
|
|
|
const auto& buffer_queue = nv_flinger->FindBufferQueue(id);
|
2018-01-15 23:20:08 +01:00
|
|
|
|
|
|
|
// TODO(Subv): Find out what this actually is.
|
2018-01-24 01:52:18 +01:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 1};
|
2018-01-15 23:20:08 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
2019-02-21 17:31:53 +01:00
|
|
|
rb.PushCopyObjects(buffer_queue.GetBufferWaitEvent());
|
2018-01-15 23:20:08 +01:00
|
|
|
}
|
|
|
|
|
2018-01-22 17:54:58 +01:00
|
|
|
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
|
2018-02-13 03:17:04 +01:00
|
|
|
}; // namespace VI
|
2018-01-08 03:27:58 +01:00
|
|
|
|
|
|
|
class ISystemDisplayService final : public ServiceFramework<ISystemDisplayService> {
|
|
|
|
public:
|
2018-07-19 18:05:48 +02:00
|
|
|
explicit ISystemDisplayService() : ServiceFramework("ISystemDisplayService") {
|
2018-01-08 03:27:58 +01:00
|
|
|
static const FunctionInfo functions[] = {
|
|
|
|
{1200, nullptr, "GetZOrderCountMin"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{1202, nullptr, "GetZOrderCountMax"},
|
|
|
|
{1203, nullptr, "GetDisplayLogicalResolution"},
|
|
|
|
{1204, nullptr, "SetDisplayMagnification"},
|
|
|
|
{2201, nullptr, "SetLayerPosition"},
|
|
|
|
{2203, nullptr, "SetLayerSize"},
|
|
|
|
{2204, nullptr, "GetLayerZ"},
|
2018-01-08 03:27:58 +01:00
|
|
|
{2205, &ISystemDisplayService::SetLayerZ, "SetLayerZ"},
|
2018-04-16 11:04:34 +02:00
|
|
|
{2207, &ISystemDisplayService::SetLayerVisibility, "SetLayerVisibility"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{2209, nullptr, "SetLayerAlpha"},
|
|
|
|
{2312, nullptr, "CreateStrayLayer"},
|
|
|
|
{2400, nullptr, "OpenIndirectLayer"},
|
|
|
|
{2401, nullptr, "CloseIndirectLayer"},
|
|
|
|
{2402, nullptr, "FlipIndirectLayer"},
|
|
|
|
{3000, nullptr, "ListDisplayModes"},
|
|
|
|
{3001, nullptr, "ListDisplayRgbRanges"},
|
|
|
|
{3002, nullptr, "ListDisplayContentTypes"},
|
2018-09-17 17:19:31 +02:00
|
|
|
{3200, &ISystemDisplayService::GetDisplayMode, "GetDisplayMode"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{3201, nullptr, "SetDisplayMode"},
|
|
|
|
{3202, nullptr, "GetDisplayUnderscan"},
|
|
|
|
{3203, nullptr, "SetDisplayUnderscan"},
|
|
|
|
{3204, nullptr, "GetDisplayContentType"},
|
|
|
|
{3205, nullptr, "SetDisplayContentType"},
|
|
|
|
{3206, nullptr, "GetDisplayRgbRange"},
|
|
|
|
{3207, nullptr, "SetDisplayRgbRange"},
|
|
|
|
{3208, nullptr, "GetDisplayCmuMode"},
|
|
|
|
{3209, nullptr, "SetDisplayCmuMode"},
|
|
|
|
{3210, nullptr, "GetDisplayContrastRatio"},
|
|
|
|
{3211, nullptr, "SetDisplayContrastRatio"},
|
|
|
|
{3214, nullptr, "GetDisplayGamma"},
|
|
|
|
{3215, nullptr, "SetDisplayGamma"},
|
|
|
|
{3216, nullptr, "GetDisplayCmuLuma"},
|
|
|
|
{3217, nullptr, "SetDisplayCmuLuma"},
|
|
|
|
{8225, nullptr, "GetSharedBufferMemoryHandleId"},
|
|
|
|
{8250, nullptr, "OpenSharedLayer"},
|
|
|
|
{8251, nullptr, "CloseSharedLayer"},
|
|
|
|
{8252, nullptr, "ConnectSharedLayer"},
|
|
|
|
{8253, nullptr, "DisconnectSharedLayer"},
|
|
|
|
{8254, nullptr, "AcquireSharedFrameBuffer"},
|
|
|
|
{8255, nullptr, "PresentSharedFrameBuffer"},
|
|
|
|
{8256, nullptr, "GetSharedFrameBufferAcquirableEvent"},
|
|
|
|
{8257, nullptr, "FillSharedFrameBufferColor"},
|
|
|
|
{8258, nullptr, "CancelSharedFrameBuffer"},
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void SetLayerZ(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 layer_id = rp.Pop<u64>();
|
|
|
|
const u64 z_value = rp.Pop<u64>();
|
|
|
|
|
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called. layer_id=0x{:016X}, z_value=0x{:016X}", layer_id,
|
|
|
|
z_value);
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2018-01-08 03:27:58 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
2018-04-16 11:04:34 +02:00
|
|
|
|
2019-01-28 14:21:34 +01:00
|
|
|
// This function currently does nothing but return a success error code in
|
|
|
|
// the vi library itself, so do the same thing, but log out the passed in values.
|
2018-04-16 11:04:34 +02:00
|
|
|
void SetLayerVisibility(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 layer_id = rp.Pop<u64>();
|
|
|
|
const bool visibility = rp.Pop<bool>();
|
|
|
|
|
2019-01-28 14:21:34 +01:00
|
|
|
LOG_DEBUG(Service_VI, "called, layer_id=0x{:08X}, visibility={}", layer_id, visibility);
|
2018-11-26 07:06:13 +01:00
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
2018-04-16 11:04:34 +02:00
|
|
|
}
|
2018-09-17 17:19:31 +02:00
|
|
|
|
|
|
|
void GetDisplayMode(Kernel::HLERequestContext& ctx) {
|
2018-11-26 07:06:13 +01:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called");
|
|
|
|
|
2018-09-17 17:19:31 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 6};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
|
|
|
|
if (Settings::values.use_docked_mode) {
|
2018-11-16 08:07:42 +01:00
|
|
|
rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedWidth) *
|
|
|
|
static_cast<u32>(Settings::values.resolution_factor));
|
|
|
|
rb.Push(static_cast<u32>(Service::VI::DisplayResolution::DockedHeight) *
|
|
|
|
static_cast<u32>(Settings::values.resolution_factor));
|
2018-09-17 17:19:31 +02:00
|
|
|
} else {
|
2018-11-16 08:07:42 +01:00
|
|
|
rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedWidth) *
|
|
|
|
static_cast<u32>(Settings::values.resolution_factor));
|
|
|
|
rb.Push(static_cast<u32>(Service::VI::DisplayResolution::UndockedHeight) *
|
|
|
|
static_cast<u32>(Settings::values.resolution_factor));
|
2018-09-17 17:19:31 +02:00
|
|
|
}
|
|
|
|
|
2018-11-26 07:06:13 +01:00
|
|
|
rb.PushRaw<float>(60.0f); // This wouldn't seem to be correct for 30 fps games.
|
2018-09-17 17:19:31 +02:00
|
|
|
rb.Push<u32>(0);
|
|
|
|
}
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
class IManagerDisplayService final : public ServiceFramework<IManagerDisplayService> {
|
|
|
|
public:
|
2018-01-22 17:54:58 +01:00
|
|
|
explicit IManagerDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
|
2018-01-09 00:18:50 +01:00
|
|
|
: ServiceFramework("IManagerDisplayService"), nv_flinger(std::move(nv_flinger)) {
|
2018-01-08 03:27:58 +01:00
|
|
|
static const FunctionInfo functions[] = {
|
2018-04-17 17:37:43 +02:00
|
|
|
{200, nullptr, "AllocateProcessHeapBlock"},
|
|
|
|
{201, nullptr, "FreeProcessHeapBlock"},
|
2018-01-15 07:29:00 +01:00
|
|
|
{1020, &IManagerDisplayService::CloseDisplay, "CloseDisplay"},
|
2018-01-08 03:27:58 +01:00
|
|
|
{1102, nullptr, "GetDisplayResolution"},
|
|
|
|
{2010, &IManagerDisplayService::CreateManagedLayer, "CreateManagedLayer"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{2011, nullptr, "DestroyManagedLayer"},
|
2019-02-25 14:06:47 +01:00
|
|
|
{2012, nullptr, "CreateStrayLayer"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{2050, nullptr, "CreateIndirectLayer"},
|
|
|
|
{2051, nullptr, "DestroyIndirectLayer"},
|
|
|
|
{2052, nullptr, "CreateIndirectProducerEndPoint"},
|
|
|
|
{2053, nullptr, "DestroyIndirectProducerEndPoint"},
|
|
|
|
{2054, nullptr, "CreateIndirectConsumerEndPoint"},
|
|
|
|
{2055, nullptr, "DestroyIndirectConsumerEndPoint"},
|
|
|
|
{2300, nullptr, "AcquireLayerTexturePresentingEvent"},
|
|
|
|
{2301, nullptr, "ReleaseLayerTexturePresentingEvent"},
|
|
|
|
{2302, nullptr, "GetDisplayHotplugEvent"},
|
|
|
|
{2402, nullptr, "GetDisplayHotplugState"},
|
|
|
|
{2501, nullptr, "GetCompositorErrorInfo"},
|
|
|
|
{2601, nullptr, "GetDisplayErrorEvent"},
|
|
|
|
{4201, nullptr, "SetDisplayAlpha"},
|
|
|
|
{4203, nullptr, "SetDisplayLayerStack"},
|
|
|
|
{4205, nullptr, "SetDisplayPowerState"},
|
|
|
|
{4206, nullptr, "SetDefaultDisplay"},
|
2018-01-08 03:27:58 +01:00
|
|
|
{6000, &IManagerDisplayService::AddToLayerStack, "AddToLayerStack"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{6001, nullptr, "RemoveFromLayerStack"},
|
2018-04-16 11:04:34 +02:00
|
|
|
{6002, &IManagerDisplayService::SetLayerVisibility, "SetLayerVisibility"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{6003, nullptr, "SetLayerConfig"},
|
|
|
|
{6004, nullptr, "AttachLayerPresentationTracer"},
|
|
|
|
{6005, nullptr, "DetachLayerPresentationTracer"},
|
|
|
|
{6006, nullptr, "StartLayerPresentationRecording"},
|
|
|
|
{6007, nullptr, "StopLayerPresentationRecording"},
|
|
|
|
{6008, nullptr, "StartLayerPresentationFenceWait"},
|
|
|
|
{6009, nullptr, "StopLayerPresentationFenceWait"},
|
|
|
|
{6010, nullptr, "GetLayerPresentationAllFencesExpiredEvent"},
|
|
|
|
{7000, nullptr, "SetContentVisibility"},
|
|
|
|
{8000, nullptr, "SetConductorLayer"},
|
|
|
|
{8100, nullptr, "SetIndirectProducerFlipOffset"},
|
|
|
|
{8200, nullptr, "CreateSharedBufferStaticStorage"},
|
|
|
|
{8201, nullptr, "CreateSharedBufferTransferMemory"},
|
|
|
|
{8202, nullptr, "DestroySharedBuffer"},
|
|
|
|
{8203, nullptr, "BindSharedLowLevelLayerToManagedLayer"},
|
|
|
|
{8204, nullptr, "BindSharedLowLevelLayerToIndirectLayer"},
|
|
|
|
{8207, nullptr, "UnbindSharedLowLevelLayer"},
|
|
|
|
{8208, nullptr, "ConnectSharedLowLevelLayerToSharedBuffer"},
|
|
|
|
{8209, nullptr, "DisconnectSharedLowLevelLayerFromSharedBuffer"},
|
|
|
|
{8210, nullptr, "CreateSharedLayer"},
|
|
|
|
{8211, nullptr, "DestroySharedLayer"},
|
|
|
|
{8216, nullptr, "AttachSharedLayerToLowLevelLayer"},
|
|
|
|
{8217, nullptr, "ForceDetachSharedLayerFromLowLevelLayer"},
|
|
|
|
{8218, nullptr, "StartDetachSharedLayerFromLowLevelLayer"},
|
|
|
|
{8219, nullptr, "FinishDetachSharedLayerFromLowLevelLayer"},
|
|
|
|
{8220, nullptr, "GetSharedLayerDetachReadyEvent"},
|
|
|
|
{8221, nullptr, "GetSharedLowLevelLayerSynchronizedEvent"},
|
|
|
|
{8222, nullptr, "CheckSharedLowLevelLayerSynchronized"},
|
|
|
|
{8223, nullptr, "RegisterSharedBufferImporterAruid"},
|
|
|
|
{8224, nullptr, "UnregisterSharedBufferImporterAruid"},
|
|
|
|
{8227, nullptr, "CreateSharedBufferProcessHeap"},
|
|
|
|
{8228, nullptr, "GetSharedLayerLayerStacks"},
|
|
|
|
{8229, nullptr, "SetSharedLayerLayerStacks"},
|
|
|
|
{8291, nullptr, "PresentDetachedSharedFrameBufferToLowLevelLayer"},
|
|
|
|
{8292, nullptr, "FillDetachedSharedFrameBufferColor"},
|
|
|
|
{8293, nullptr, "GetDetachedSharedFrameBufferImage"},
|
|
|
|
{8294, nullptr, "SetDetachedSharedFrameBufferImage"},
|
|
|
|
{8295, nullptr, "CopyDetachedSharedFrameBufferImage"},
|
|
|
|
{8296, nullptr, "SetDetachedSharedFrameBufferSubImage"},
|
|
|
|
{8297, nullptr, "GetSharedFrameBufferContentParameter"},
|
|
|
|
{8298, nullptr, "ExpandStartupLogoOnSharedFrameBuffer"},
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2018-01-15 07:29:00 +01:00
|
|
|
void CloseDisplay(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 display = rp.Pop<u64>();
|
|
|
|
|
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called. display=0x{:016X}", display);
|
2018-01-15 07:29:00 +01:00
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2018-01-15 07:29:00 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
|
|
|
|
2018-01-08 03:27:58 +01:00
|
|
|
void CreateManagedLayer(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u32 unknown = rp.Pop<u32>();
|
2018-01-08 03:27:58 +01:00
|
|
|
rp.Skip(1, false);
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 display = rp.Pop<u64>();
|
|
|
|
const u64 aruid = rp.Pop<u64>();
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2019-01-03 01:42:08 +01:00
|
|
|
LOG_WARNING(Service_VI,
|
|
|
|
"(STUBBED) called. unknown=0x{:08X}, display=0x{:016X}, aruid=0x{:016X}",
|
|
|
|
unknown, display, aruid);
|
|
|
|
|
2019-02-05 22:20:04 +01:00
|
|
|
const auto layer_id = nv_flinger->CreateLayer(display);
|
|
|
|
if (!layer_id) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(ERR_NOT_FOUND);
|
|
|
|
return;
|
|
|
|
}
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 4};
|
2018-01-08 03:27:58 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
2019-02-05 22:20:04 +01:00
|
|
|
rb.Push(*layer_id);
|
2018-01-08 03:27:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void AddToLayerStack(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u32 stack = rp.Pop<u32>();
|
|
|
|
const u64 layer_id = rp.Pop<u64>();
|
|
|
|
|
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called. stack=0x{:08X}, layer_id=0x{:016X}", stack,
|
|
|
|
layer_id);
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2018-01-08 03:27:58 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2018-04-16 11:04:34 +02:00
|
|
|
void SetLayerVisibility(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 layer_id = rp.Pop<u64>();
|
|
|
|
const bool visibility = rp.Pop<bool>();
|
|
|
|
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called, layer_id=0x{:X}, visibility={}", layer_id,
|
2018-07-02 18:20:50 +02:00
|
|
|
visibility);
|
2018-11-26 07:06:13 +01:00
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
2018-04-16 11:04:34 +02:00
|
|
|
}
|
|
|
|
|
2018-01-22 17:54:58 +01:00
|
|
|
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
|
|
|
|
public:
|
2018-07-19 18:05:48 +02:00
|
|
|
explicit IApplicationDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
private:
|
2019-01-05 01:31:14 +01:00
|
|
|
enum class ConvertedScaleMode : u64 {
|
2019-01-05 02:32:29 +01:00
|
|
|
Freeze = 0,
|
|
|
|
ScaleToWindow = 1,
|
|
|
|
ScaleAndCrop = 2,
|
|
|
|
None = 3,
|
|
|
|
PreserveAspectRatio = 4,
|
2019-01-05 01:31:14 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
enum class NintendoScaleMode : u32 {
|
|
|
|
None = 0,
|
|
|
|
Freeze = 1,
|
|
|
|
ScaleToWindow = 2,
|
2019-01-05 02:32:29 +01:00
|
|
|
ScaleAndCrop = 3,
|
|
|
|
PreserveAspectRatio = 4,
|
2019-01-05 01:31:14 +01:00
|
|
|
};
|
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void GetRelayService(Kernel::HLERequestContext& ctx) {
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called");
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
|
|
|
|
}
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void GetSystemDisplayService(Kernel::HLERequestContext& ctx) {
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called");
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.PushIpcInterface<ISystemDisplayService>();
|
|
|
|
}
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void GetManagerDisplayService(Kernel::HLERequestContext& ctx) {
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called");
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.PushIpcInterface<IManagerDisplayService>(nv_flinger);
|
|
|
|
}
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void GetIndirectDisplayTransactionService(Kernel::HLERequestContext& ctx) {
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called");
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.PushIpcInterface<IHOSBinderDriver>(nv_flinger);
|
|
|
|
}
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void OpenDisplay(Kernel::HLERequestContext& ctx) {
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called");
|
2018-11-26 07:06:13 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 00:05:15 +01:00
|
|
|
const auto name_buf = rp.PopRaw<std::array<char, 0x40>>();
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2019-01-03 00:05:15 +01:00
|
|
|
OpenDisplayImpl(ctx, std::string_view{name_buf.data(), name_buf.size()});
|
|
|
|
}
|
|
|
|
|
|
|
|
void OpenDefaultDisplay(Kernel::HLERequestContext& ctx) {
|
|
|
|
LOG_DEBUG(Service_VI, "called");
|
|
|
|
|
|
|
|
OpenDisplayImpl(ctx, "Default");
|
|
|
|
}
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2019-01-03 00:05:15 +01:00
|
|
|
void OpenDisplayImpl(Kernel::HLERequestContext& ctx, std::string_view name) {
|
|
|
|
const auto trim_pos = name.find('\0');
|
|
|
|
|
|
|
|
if (trim_pos != std::string_view::npos) {
|
|
|
|
name.remove_suffix(name.size() - trim_pos);
|
|
|
|
}
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2019-02-05 22:20:04 +01:00
|
|
|
const auto display_id = nv_flinger->OpenDisplay(name);
|
|
|
|
if (!display_id) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(ERR_NOT_FOUND);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 4};
|
2018-03-21 11:09:40 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
2019-02-05 22:20:04 +01:00
|
|
|
rb.Push<u64>(*display_id);
|
2018-03-21 11:09:40 +01:00
|
|
|
}
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void CloseDisplay(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 display_id = rp.Pop<u64>();
|
|
|
|
|
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called. display_id=0x{:016X}", display_id);
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2018-03-21 11:09:40 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2019-01-03 02:45:40 +01:00
|
|
|
// This literally does nothing internally in the actual service itself,
|
|
|
|
// and just returns a successful result code regardless of the input.
|
|
|
|
void SetDisplayEnabled(Kernel::HLERequestContext& ctx) {
|
|
|
|
LOG_DEBUG(Service_VI, "called.");
|
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
|
|
|
|
2018-04-03 05:28:45 +02:00
|
|
|
void GetDisplayResolution(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 display_id = rp.Pop<u64>();
|
|
|
|
|
2019-01-05 00:43:15 +01:00
|
|
|
LOG_DEBUG(Service_VI, "called. display_id=0x{:016X}", display_id);
|
2018-04-03 05:28:45 +02:00
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 6};
|
2018-04-03 05:28:45 +02:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
|
2019-01-05 00:43:15 +01:00
|
|
|
// This only returns the fixed values of 1280x720 and makes no distinguishing
|
|
|
|
// between docked and undocked dimensions. We take the liberty of applying
|
|
|
|
// the resolution scaling factor here.
|
|
|
|
rb.Push(static_cast<u64>(DisplayResolution::UndockedWidth) *
|
|
|
|
static_cast<u32>(Settings::values.resolution_factor));
|
|
|
|
rb.Push(static_cast<u64>(DisplayResolution::UndockedHeight) *
|
|
|
|
static_cast<u32>(Settings::values.resolution_factor));
|
2018-04-03 05:28:45 +02:00
|
|
|
}
|
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void SetLayerScalingMode(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-05 01:31:14 +01:00
|
|
|
const auto scaling_mode = rp.PopEnum<NintendoScaleMode>();
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 unknown = rp.Pop<u64>();
|
|
|
|
|
2019-01-05 01:31:14 +01:00
|
|
|
LOG_DEBUG(Service_VI, "called. scaling_mode=0x{:08X}, unknown=0x{:016X}",
|
2019-01-05 01:55:01 +01:00
|
|
|
static_cast<u32>(scaling_mode), unknown);
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2019-01-05 01:31:14 +01:00
|
|
|
|
2019-01-05 02:32:29 +01:00
|
|
|
if (scaling_mode > NintendoScaleMode::PreserveAspectRatio) {
|
2019-01-05 01:31:14 +01:00
|
|
|
LOG_ERROR(Service_VI, "Invalid scaling mode provided.");
|
|
|
|
rb.Push(ERR_OPERATION_FAILED);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (scaling_mode != NintendoScaleMode::ScaleToWindow &&
|
2019-01-05 02:32:29 +01:00
|
|
|
scaling_mode != NintendoScaleMode::PreserveAspectRatio) {
|
2019-01-05 01:31:14 +01:00
|
|
|
LOG_ERROR(Service_VI, "Unsupported scaling mode supplied.");
|
|
|
|
rb.Push(ERR_UNSUPPORTED);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void ListDisplays(Kernel::HLERequestContext& ctx) {
|
2018-11-26 07:06:13 +01:00
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called");
|
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
DisplayInfo display_info;
|
2018-11-16 08:07:42 +01:00
|
|
|
display_info.width *= static_cast<u64>(Settings::values.resolution_factor);
|
|
|
|
display_info.height *= static_cast<u64>(Settings::values.resolution_factor);
|
2018-03-21 11:09:40 +01:00
|
|
|
ctx.WriteBuffer(&display_info, sizeof(DisplayInfo));
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 4};
|
2018-03-21 11:09:40 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.Push<u64>(1);
|
|
|
|
}
|
2018-01-09 00:18:50 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void OpenLayer(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const auto name_buf = rp.PopRaw<std::array<u8, 0x40>>();
|
|
|
|
const auto end = std::find(name_buf.begin(), name_buf.end(), '\0');
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2019-01-03 01:42:08 +01:00
|
|
|
const std::string display_name(name_buf.begin(), end);
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 layer_id = rp.Pop<u64>();
|
|
|
|
const u64 aruid = rp.Pop<u64>();
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2019-01-03 01:42:08 +01:00
|
|
|
LOG_DEBUG(Service_VI, "called. layer_id=0x{:016X}, aruid=0x{:016X}", layer_id, aruid);
|
|
|
|
|
2019-02-05 22:20:04 +01:00
|
|
|
const auto display_id = nv_flinger->OpenDisplay(display_name);
|
|
|
|
if (!display_id) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(ERR_NOT_FOUND);
|
|
|
|
return;
|
|
|
|
}
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2019-02-05 22:20:04 +01:00
|
|
|
const auto buffer_queue_id = nv_flinger->FindBufferQueueId(*display_id, layer_id);
|
|
|
|
if (!buffer_queue_id) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(ERR_NOT_FOUND);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
NativeWindow native_window{*buffer_queue_id};
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 4};
|
2018-03-21 11:09:40 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
|
|
|
|
}
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void CreateStrayLayer(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u32 flags = rp.Pop<u32>();
|
2018-03-21 11:09:40 +01:00
|
|
|
rp.Pop<u32>(); // padding
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 display_id = rp.Pop<u64>();
|
|
|
|
|
|
|
|
LOG_DEBUG(Service_VI, "called. flags=0x{:08X}, display_id=0x{:016X}", flags, display_id);
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
// TODO(Subv): What's the difference between a Stray and a Managed layer?
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2019-02-05 22:20:04 +01:00
|
|
|
const auto layer_id = nv_flinger->CreateLayer(display_id);
|
|
|
|
if (!layer_id) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(ERR_NOT_FOUND);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const auto buffer_queue_id = nv_flinger->FindBufferQueueId(display_id, *layer_id);
|
|
|
|
if (!buffer_queue_id) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(ERR_NOT_FOUND);
|
|
|
|
return;
|
|
|
|
}
|
2018-01-15 23:20:08 +01:00
|
|
|
|
2019-02-05 22:20:04 +01:00
|
|
|
NativeWindow native_window{*buffer_queue_id};
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 6};
|
2018-03-21 11:09:40 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
2019-02-05 22:20:04 +01:00
|
|
|
rb.Push(*layer_id);
|
2018-03-21 11:09:40 +01:00
|
|
|
rb.Push<u64>(ctx.WriteBuffer(native_window.Serialize()));
|
|
|
|
}
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void DestroyStrayLayer(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 layer_id = rp.Pop<u64>();
|
|
|
|
|
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called. layer_id=0x{:016X}", layer_id);
|
2018-02-07 13:11:17 +01:00
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2018-03-21 11:09:40 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
void GetDisplayVsyncEvent(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-03 01:42:08 +01:00
|
|
|
const u64 display_id = rp.Pop<u64>();
|
|
|
|
|
|
|
|
LOG_WARNING(Service_VI, "(STUBBED) called. display_id=0x{:016X}", display_id);
|
2018-01-09 00:29:43 +01:00
|
|
|
|
2019-02-05 21:55:15 +01:00
|
|
|
const auto vsync_event = nv_flinger->FindVsyncEvent(display_id);
|
2019-02-05 22:20:04 +01:00
|
|
|
if (!vsync_event) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(ERR_NOT_FOUND);
|
|
|
|
return;
|
|
|
|
}
|
2018-03-21 11:09:40 +01:00
|
|
|
|
2018-09-19 07:09:59 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 1};
|
2018-03-21 11:09:40 +01:00
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.PushCopyObjects(vsync_event);
|
|
|
|
}
|
|
|
|
|
2018-10-16 17:25:42 +02:00
|
|
|
void ConvertScalingMode(Kernel::HLERequestContext& ctx) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
2019-01-05 01:55:01 +01:00
|
|
|
const auto mode = rp.PopEnum<NintendoScaleMode>();
|
2018-10-16 17:25:42 +02:00
|
|
|
LOG_DEBUG(Service_VI, "called mode={}", static_cast<u32>(mode));
|
|
|
|
|
2019-01-05 01:55:01 +01:00
|
|
|
const auto converted_mode = ConvertScalingModeImpl(mode);
|
|
|
|
|
|
|
|
if (converted_mode.Succeeded()) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 4};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
rb.PushEnum(*converted_mode);
|
|
|
|
} else {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(converted_mode.Code());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static ResultVal<ConvertedScaleMode> ConvertScalingModeImpl(NintendoScaleMode mode) {
|
2018-10-16 17:25:42 +02:00
|
|
|
switch (mode) {
|
|
|
|
case NintendoScaleMode::None:
|
2019-01-05 01:55:01 +01:00
|
|
|
return MakeResult(ConvertedScaleMode::None);
|
2018-10-16 17:25:42 +02:00
|
|
|
case NintendoScaleMode::Freeze:
|
2019-01-05 01:55:01 +01:00
|
|
|
return MakeResult(ConvertedScaleMode::Freeze);
|
2018-10-16 17:25:42 +02:00
|
|
|
case NintendoScaleMode::ScaleToWindow:
|
2019-01-05 01:55:01 +01:00
|
|
|
return MakeResult(ConvertedScaleMode::ScaleToWindow);
|
2019-01-05 02:32:29 +01:00
|
|
|
case NintendoScaleMode::ScaleAndCrop:
|
|
|
|
return MakeResult(ConvertedScaleMode::ScaleAndCrop);
|
|
|
|
case NintendoScaleMode::PreserveAspectRatio:
|
|
|
|
return MakeResult(ConvertedScaleMode::PreserveAspectRatio);
|
2018-10-16 17:25:42 +02:00
|
|
|
default:
|
2019-01-05 01:55:01 +01:00
|
|
|
return ERR_OPERATION_FAILED;
|
2018-10-16 17:25:42 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-21 11:09:40 +01:00
|
|
|
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
|
|
|
|
};
|
2018-01-08 03:27:58 +01:00
|
|
|
|
2018-01-22 17:54:58 +01:00
|
|
|
IApplicationDisplayService::IApplicationDisplayService(
|
|
|
|
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
|
2018-01-09 00:18:50 +01:00
|
|
|
: ServiceFramework("IApplicationDisplayService"), nv_flinger(std::move(nv_flinger)) {
|
2018-01-08 03:27:58 +01:00
|
|
|
static const FunctionInfo functions[] = {
|
|
|
|
{100, &IApplicationDisplayService::GetRelayService, "GetRelayService"},
|
|
|
|
{101, &IApplicationDisplayService::GetSystemDisplayService, "GetSystemDisplayService"},
|
|
|
|
{102, &IApplicationDisplayService::GetManagerDisplayService, "GetManagerDisplayService"},
|
2018-01-15 23:20:08 +01:00
|
|
|
{103, &IApplicationDisplayService::GetIndirectDisplayTransactionService,
|
|
|
|
"GetIndirectDisplayTransactionService"},
|
2018-02-07 13:11:17 +01:00
|
|
|
{1000, &IApplicationDisplayService::ListDisplays, "ListDisplays"},
|
2018-01-08 03:27:58 +01:00
|
|
|
{1010, &IApplicationDisplayService::OpenDisplay, "OpenDisplay"},
|
2019-01-03 00:05:15 +01:00
|
|
|
{1011, &IApplicationDisplayService::OpenDefaultDisplay, "OpenDefaultDisplay"},
|
2018-01-15 23:20:08 +01:00
|
|
|
{1020, &IApplicationDisplayService::CloseDisplay, "CloseDisplay"},
|
2019-01-03 02:45:40 +01:00
|
|
|
{1101, &IApplicationDisplayService::SetDisplayEnabled, "SetDisplayEnabled"},
|
2018-04-03 05:28:45 +02:00
|
|
|
{1102, &IApplicationDisplayService::GetDisplayResolution, "GetDisplayResolution"},
|
2018-01-08 03:27:58 +01:00
|
|
|
{2020, &IApplicationDisplayService::OpenLayer, "OpenLayer"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{2021, nullptr, "CloseLayer"},
|
2018-01-15 23:20:08 +01:00
|
|
|
{2030, &IApplicationDisplayService::CreateStrayLayer, "CreateStrayLayer"},
|
|
|
|
{2031, &IApplicationDisplayService::DestroyStrayLayer, "DestroyStrayLayer"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{2101, &IApplicationDisplayService::SetLayerScalingMode, "SetLayerScalingMode"},
|
2018-10-16 17:25:42 +02:00
|
|
|
{2102, &IApplicationDisplayService::ConvertScalingMode, "ConvertScalingMode"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{2450, nullptr, "GetIndirectLayerImageMap"},
|
|
|
|
{2451, nullptr, "GetIndirectLayerImageCropMap"},
|
|
|
|
{2460, nullptr, "GetIndirectLayerImageRequiredMemoryInfo"},
|
2018-01-08 03:27:58 +01:00
|
|
|
{5202, &IApplicationDisplayService::GetDisplayVsyncEvent, "GetDisplayVsyncEvent"},
|
2018-04-17 17:37:43 +02:00
|
|
|
{5203, nullptr, "GetDisplayVsyncEventForDebug"},
|
2018-01-08 03:27:58 +01:00
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
|
|
|
|
2019-02-26 23:49:32 +01:00
|
|
|
static bool IsValidServiceAccess(Permission permission, Policy policy) {
|
|
|
|
if (permission == Permission::User) {
|
|
|
|
return policy == Policy::User;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (permission == Permission::System || permission == Permission::Manager) {
|
|
|
|
return policy == Policy::User || policy == Policy::Compositor;
|
|
|
|
}
|
2018-03-21 11:09:40 +01:00
|
|
|
|
2019-02-26 23:49:32 +01:00
|
|
|
return false;
|
|
|
|
}
|
hle/service: Default constructors and destructors in the cpp file where applicable
When a destructor isn't defaulted into a cpp file, it can cause the use
of forward declarations to seemingly fail to compile for non-obvious
reasons. It also allows inlining of the construction/destruction logic
all over the place where a constructor or destructor is invoked, which
can lead to code bloat. This isn't so much a worry here, given the
services won't be created and destroyed frequently.
The cause of the above mentioned non-obvious errors can be demonstrated
as follows:
------- Demonstrative example, if you know how the described error happens, skip forwards -------
Assume we have the following in the header, which we'll call "thing.h":
\#include <memory>
// Forward declaration. For example purposes, assume the definition
// of Object is in some header named "object.h"
class Object;
class Thing {
public:
// assume no constructors or destructors are specified here,
// or the constructors/destructors are defined as:
//
// Thing() = default;
// ~Thing() = default;
//
// ... Some interface member functions would be defined here
private:
std::shared_ptr<Object> obj;
};
If this header is included in a cpp file, (which we'll call "main.cpp"),
this will result in a compilation error, because even though no
destructor is specified, the destructor will still need to be generated by
the compiler because std::shared_ptr's destructor is *not* trivial (in
other words, it does something other than nothing), as std::shared_ptr's
destructor needs to do two things:
1. Decrement the shared reference count of the object being pointed to,
and if the reference count decrements to zero,
2. Free the Object instance's memory (aka deallocate the memory it's
pointing to).
And so the compiler generates the code for the destructor doing this inside main.cpp.
Now, keep in mind, the Object forward declaration is not a complete type. All it
does is tell the compiler "a type named Object exists" and allows us to
use the name in certain situations to avoid a header dependency. So the
compiler needs to generate destruction code for Object, but the compiler
doesn't know *how* to destruct it. A forward declaration doesn't tell
the compiler anything about Object's constructor or destructor. So, the
compiler will issue an error in this case because it's undefined
behavior to try and deallocate (or construct) an incomplete type and
std::shared_ptr and std::unique_ptr make sure this isn't the case
internally.
Now, if we had defaulted the destructor in "thing.cpp", where we also
include "object.h", this would never be an issue, as the destructor
would only have its code generated in one place, and it would be in a
place where the full class definition of Object would be visible to the
compiler.
---------------------- End example ----------------------------
Given these service classes are more than certainly going to change in
the future, this defaults the constructors and destructors into the
relevant cpp files to make the construction and destruction of all of
the services consistent and unlikely to run into cases where forward
declarations are indirectly causing compilation errors. It also has the
plus of avoiding the need to rebuild several services if destruction
logic changes, since it would only be necessary to recompile the single
cpp file.
2018-09-11 03:20:52 +02:00
|
|
|
|
2019-02-26 23:20:02 +01:00
|
|
|
void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx,
|
2019-02-26 23:49:32 +01:00
|
|
|
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger,
|
|
|
|
Permission permission) {
|
|
|
|
IPC::RequestParser rp{ctx};
|
|
|
|
const auto policy = rp.PopEnum<Policy>();
|
|
|
|
|
|
|
|
if (!IsValidServiceAccess(permission, policy)) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(ERR_PERMISSION_DENIED);
|
|
|
|
return;
|
|
|
|
}
|
2018-03-21 11:09:40 +01:00
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
2019-02-26 23:20:02 +01:00
|
|
|
rb.PushIpcInterface<IApplicationDisplayService>(std::move(nv_flinger));
|
2018-03-21 11:09:40 +01:00
|
|
|
}
|
|
|
|
|
2018-01-22 19:40:02 +01:00
|
|
|
void InstallInterfaces(SM::ServiceManager& service_manager,
|
|
|
|
std::shared_ptr<NVFlinger::NVFlinger> nv_flinger) {
|
2019-02-26 23:20:02 +01:00
|
|
|
std::make_shared<VI_M>(nv_flinger)->InstallAsService(service_manager);
|
|
|
|
std::make_shared<VI_S>(nv_flinger)->InstallAsService(service_manager);
|
|
|
|
std::make_shared<VI_U>(nv_flinger)->InstallAsService(service_manager);
|
2018-01-08 03:27:58 +01:00
|
|
|
}
|
|
|
|
|
2018-04-20 03:41:44 +02:00
|
|
|
} // namespace Service::VI
|