2018-01-13 22:22:39 +01:00
|
|
|
// Copyright 2018 yuzu emulator team
|
2018-01-09 16:41:13 +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-14 06:49:35 +01:00
|
|
|
#include <cinttypes>
|
2018-01-12 04:36:56 +01:00
|
|
|
|
2018-01-09 16:41:13 +01:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/logging/log.h"
|
|
|
|
#include "core/hle/service/nvdrv/devices/nvmap.h"
|
|
|
|
|
2018-04-20 03:41:44 +02:00
|
|
|
namespace Service::Nvidia::Devices {
|
2018-01-09 16:41:13 +01:00
|
|
|
|
|
|
|
VAddr nvmap::GetObjectAddress(u32 handle) const {
|
2018-02-08 03:53:31 +01:00
|
|
|
auto object = GetObject(handle);
|
|
|
|
ASSERT(object);
|
2018-01-09 16:41:13 +01:00
|
|
|
ASSERT(object->status == Object::Status::Allocated);
|
|
|
|
return object->addr;
|
|
|
|
}
|
|
|
|
|
Extra nvdrv support (#162)
* FinishInitalize needed for 3.0.1+ games
* nvdrv:s and nvdrv:t both use NVDRV
* Most settings return 0 on hardware, disabled NV_MEMORY_PROFILER for now.
NVN_THROUGH_OPENGL & NVRM_GPU_PREVENT_USE are a few interesting settings to look at. Carefully choosing settings can help with drawing graphics later on
* Initial /dev/nvhost-gpu support
* ZCullBind
* Stubbed SetErrorNotifier
* Fixed SetErrorNotifier log, Added SetChannelPriority
* Allocate GPFIFO Ex2, Allocate Obj Ctx, Submit GPFIFO
* oops
* Fixed up naming/structs/enums. Used vector instead of array for "gpfifo_entry"
* Added missing fixes
* /dev/nvhost-ctrl-gpu
* unneeded struct
* Forgot u32 in enum class
* Automatic descriptor swapping for ioctls, fixed nvgpu_gpu_get_tpc_masks_args being incorrect size
* nvdrv#QueryEvent
* Renamed logs for nvdrv
* Refactor ioctl so nv_result isn't needed
* /dev/nvhost-as-gpu
* Fixed Log service naming, CtxObjects now u32, renamed all structs, added static_asserts to structs, used INSERT_PADDING_WORDS instead of u32s
* nvdevices now uses "Ioctl" union,
* IoctlGpfifoEntry now uses bit field
* final changes
2018-02-06 03:19:31 +01:00
|
|
|
u32 nvmap::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output) {
|
|
|
|
switch (static_cast<IoctlCommand>(command.raw)) {
|
2018-01-21 22:56:58 +01:00
|
|
|
case IoctlCommand::Create:
|
2018-01-09 16:41:13 +01:00
|
|
|
return IocCreate(input, output);
|
2018-01-21 22:56:58 +01:00
|
|
|
case IoctlCommand::Alloc:
|
2018-01-09 16:41:13 +01:00
|
|
|
return IocAlloc(input, output);
|
2018-01-21 22:56:58 +01:00
|
|
|
case IoctlCommand::GetId:
|
2018-01-09 16:41:13 +01:00
|
|
|
return IocGetId(input, output);
|
2018-01-21 22:56:58 +01:00
|
|
|
case IoctlCommand::FromId:
|
2018-01-09 16:41:13 +01:00
|
|
|
return IocFromId(input, output);
|
2018-01-21 22:56:58 +01:00
|
|
|
case IoctlCommand::Param:
|
2018-01-09 16:41:13 +01:00
|
|
|
return IocParam(input, output);
|
2018-05-20 21:23:49 +02:00
|
|
|
case IoctlCommand::Free:
|
|
|
|
return IocFree(input, output);
|
2018-01-09 16:41:13 +01:00
|
|
|
}
|
|
|
|
|
2018-04-23 18:13:53 +02:00
|
|
|
UNIMPLEMENTED_MSG("Unimplemented ioctl");
|
2018-01-21 23:07:44 +01:00
|
|
|
return 0;
|
2018-01-09 16:41:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
u32 nvmap::IocCreate(const std::vector<u8>& input, std::vector<u8>& output) {
|
|
|
|
IocCreateParams params;
|
|
|
|
std::memcpy(¶ms, input.data(), sizeof(params));
|
|
|
|
|
|
|
|
// Create a new nvmap object and obtain a handle to it.
|
|
|
|
auto object = std::make_shared<Object>();
|
|
|
|
object->id = next_id++;
|
|
|
|
object->size = params.size;
|
|
|
|
object->status = Object::Status::Created;
|
2018-05-20 21:23:49 +02:00
|
|
|
object->refcount = 1;
|
2018-01-09 16:41:13 +01:00
|
|
|
|
|
|
|
u32 handle = next_handle++;
|
|
|
|
handles[handle] = std::move(object);
|
|
|
|
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_DEBUG(Service_NVDRV, "size=0x{:08X}", params.size);
|
2018-01-09 16:41:13 +01:00
|
|
|
|
|
|
|
params.handle = handle;
|
|
|
|
|
|
|
|
std::memcpy(output.data(), ¶ms, sizeof(params));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output) {
|
|
|
|
IocAllocParams params;
|
|
|
|
std::memcpy(¶ms, input.data(), sizeof(params));
|
|
|
|
|
2018-02-08 03:53:31 +01:00
|
|
|
auto object = GetObject(params.handle);
|
|
|
|
ASSERT(object);
|
2018-01-09 16:41:13 +01:00
|
|
|
|
|
|
|
object->flags = params.flags;
|
|
|
|
object->align = params.align;
|
|
|
|
object->kind = params.kind;
|
|
|
|
object->addr = params.addr;
|
|
|
|
object->status = Object::Status::Allocated;
|
|
|
|
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_DEBUG(Service_NVDRV, "called, addr={:X}", params.addr);
|
2018-01-09 16:41:13 +01:00
|
|
|
|
|
|
|
std::memcpy(output.data(), ¶ms, sizeof(params));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 nvmap::IocGetId(const std::vector<u8>& input, std::vector<u8>& output) {
|
|
|
|
IocGetIdParams params;
|
|
|
|
std::memcpy(¶ms, input.data(), sizeof(params));
|
|
|
|
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_NVDRV, "called");
|
2018-01-09 16:41:13 +01:00
|
|
|
|
2018-02-08 03:53:31 +01:00
|
|
|
auto object = GetObject(params.handle);
|
|
|
|
ASSERT(object);
|
2018-01-09 16:41:13 +01:00
|
|
|
|
2018-02-08 03:53:31 +01:00
|
|
|
params.id = object->id;
|
2018-01-09 16:41:13 +01:00
|
|
|
|
|
|
|
std::memcpy(output.data(), ¶ms, sizeof(params));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 nvmap::IocFromId(const std::vector<u8>& input, std::vector<u8>& output) {
|
|
|
|
IocFromIdParams params;
|
|
|
|
std::memcpy(¶ms, input.data(), sizeof(params));
|
|
|
|
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_NVDRV, "(STUBBED) called");
|
2018-01-09 16:41:13 +01:00
|
|
|
|
|
|
|
auto itr = std::find_if(handles.begin(), handles.end(),
|
|
|
|
[&](const auto& entry) { return entry.second->id == params.id; });
|
|
|
|
ASSERT(itr != handles.end());
|
|
|
|
|
2018-05-20 21:23:49 +02:00
|
|
|
itr->second->refcount++;
|
|
|
|
|
2018-02-17 19:56:21 +01:00
|
|
|
// Return the existing handle instead of creating a new one.
|
|
|
|
params.handle = itr->first;
|
2018-01-09 16:41:13 +01:00
|
|
|
|
|
|
|
std::memcpy(output.data(), ¶ms, sizeof(params));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 nvmap::IocParam(const std::vector<u8>& input, std::vector<u8>& output) {
|
|
|
|
enum class ParamTypes { Size = 1, Alignment = 2, Base = 3, Heap = 4, Kind = 5, Compr = 6 };
|
|
|
|
|
|
|
|
IocParamParams params;
|
|
|
|
std::memcpy(¶ms, input.data(), sizeof(params));
|
|
|
|
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_NVDRV, "(STUBBED) called type={}", params.param);
|
2018-01-09 16:41:13 +01:00
|
|
|
|
2018-02-08 03:53:31 +01:00
|
|
|
auto object = GetObject(params.handle);
|
|
|
|
ASSERT(object);
|
2018-01-09 16:41:13 +01:00
|
|
|
ASSERT(object->status == Object::Status::Allocated);
|
|
|
|
|
2018-05-23 14:09:24 +02:00
|
|
|
switch (static_cast<ParamTypes>(params.param)) {
|
2018-01-09 16:41:13 +01:00
|
|
|
case ParamTypes::Size:
|
2018-05-23 14:09:24 +02:00
|
|
|
params.result = object->size;
|
2018-01-09 16:41:13 +01:00
|
|
|
break;
|
|
|
|
case ParamTypes::Alignment:
|
2018-05-23 14:09:24 +02:00
|
|
|
params.result = object->align;
|
2018-01-09 16:41:13 +01:00
|
|
|
break;
|
|
|
|
case ParamTypes::Heap:
|
|
|
|
// TODO(Subv): Seems to be a hardcoded value?
|
2018-05-23 14:09:24 +02:00
|
|
|
params.result = 0x40000000;
|
2018-01-09 16:41:13 +01:00
|
|
|
break;
|
|
|
|
case ParamTypes::Kind:
|
2018-05-23 14:09:24 +02:00
|
|
|
params.result = object->kind;
|
2018-01-09 16:41:13 +01:00
|
|
|
break;
|
|
|
|
default:
|
2018-01-12 04:31:12 +01:00
|
|
|
UNIMPLEMENTED();
|
2018-01-09 16:41:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
std::memcpy(output.data(), ¶ms, sizeof(params));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-05-20 21:23:49 +02:00
|
|
|
u32 nvmap::IocFree(const std::vector<u8>& input, std::vector<u8>& output) {
|
2018-07-01 17:48:50 +02:00
|
|
|
// TODO(Subv): These flags are unconfirmed.
|
2018-05-20 21:23:49 +02:00
|
|
|
enum FreeFlags {
|
|
|
|
Freed = 0,
|
|
|
|
NotFreedYet = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
IocFreeParams params;
|
|
|
|
std::memcpy(¶ms, input.data(), sizeof(params));
|
|
|
|
|
2018-07-02 18:13:26 +02:00
|
|
|
LOG_WARNING(Service_NVDRV, "(STUBBED) called");
|
2018-05-20 21:23:49 +02:00
|
|
|
|
|
|
|
auto itr = handles.find(params.handle);
|
|
|
|
ASSERT(itr != handles.end());
|
|
|
|
|
2018-07-01 17:48:50 +02:00
|
|
|
ASSERT(itr->second->refcount > 0);
|
|
|
|
|
2018-05-20 21:23:49 +02:00
|
|
|
itr->second->refcount--;
|
|
|
|
|
|
|
|
params.size = itr->second->size;
|
|
|
|
|
2018-07-01 17:48:50 +02:00
|
|
|
if (itr->second->refcount == 0) {
|
2018-05-20 21:23:49 +02:00
|
|
|
params.flags = Freed;
|
2018-07-01 17:48:50 +02:00
|
|
|
// The address of the nvmap is written to the output if we're finally freeing it, otherwise
|
|
|
|
// 0 is written.
|
|
|
|
params.address = itr->second->addr;
|
|
|
|
} else {
|
2018-05-20 21:23:49 +02:00
|
|
|
params.flags = NotFreedYet;
|
2018-07-01 17:48:50 +02:00
|
|
|
params.address = 0;
|
|
|
|
}
|
2018-05-20 21:23:49 +02:00
|
|
|
|
|
|
|
handles.erase(params.handle);
|
|
|
|
|
|
|
|
std::memcpy(output.data(), ¶ms, sizeof(params));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-04-20 03:41:44 +02:00
|
|
|
} // namespace Service::Nvidia::Devices
|