OmniNX/Atmosphere
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pwm: implement driver for boot sysmodule

Browse Source
This commit is contained in:
Michael Scire
2020-11-01 23:04:19 -08:00
parent 4cc4f5fdb0
commit aa63b1eab7
41 changed files with 2107 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/impl/pwm_impl_pwm_driver_api.cpp Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "pwm_impl_pwm_driver_api.hpp"
#include "pwm_pwm_driver_impl.hpp"
namespace ams::pwm::driver::board::nintendo_nx::impl {
namespace {
constexpr inline const dd::PhysicalAddress PwmRegistersPhysicalAddress = 0x7000A000;
constexpr inline size_t PwmRegistersSize = 0x100;
constexpr const ChannelDefinition SupportedChannels[] = {
{ pwm::DeviceCode_CpuFan, 0 },
{ pwm::DeviceCode_LcdBacklight, 1 },
};
}
Result InitializePwmDriver() {
/* Get the memory resource with which to allocate our driver/devices. */
auto *memory_resource = ddsf::GetMemoryResource();
/* Allocate storage for our driver. */
auto *driver_storage = memory_resource->Allocate(sizeof(PwmDriverImpl), alignof(PwmDriverImpl));
AMS_ABORT_UNLESS(driver_storage != nullptr);
/* Create our driver. */
auto *driver = new (static_cast<PwmDriverImpl *>(driver_storage)) PwmDriverImpl(PwmRegistersPhysicalAddress, PwmRegistersSize, SupportedChannels, util::size(SupportedChannels));
/* Register our driver. */
pwm::driver::RegisterDriver(driver);
/* Create our devices. */
for (const auto &entry : SupportedChannels) {
auto *device_storage = memory_resource->Allocate(sizeof(PwmDriverImpl), alignof(PwmDriverImpl));
AMS_ABORT_UNLESS(device_storage != nullptr);
/* Create our driver. */
auto *device = new (static_cast<PwmDeviceImpl *>(device_storage)) PwmDeviceImpl(entry.channel_id);
/* Register the device with our driver. */
driver->RegisterDevice(device);
/* Register the device code with our driver. */
R_ABORT_UNLESS(pwm::driver::RegisterDeviceCode(entry.device_code, device));
}
return ResultSuccess();
}
}

28
libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/impl/pwm_impl_pwm_driver_api.hpp Normal file
View File

@@ -0,0 +1,28 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <stratosphere.hpp>
namespace ams::pwm::driver::board::nintendo_nx::impl {
struct ChannelDefinition {
DeviceCode device_code;
int channel_id;
};
Result InitializePwmDriver();
}

255
libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/impl/pwm_pwm_driver_impl.cpp Normal file
View File

@@ -0,0 +1,255 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "pwm_pwm_driver_impl.hpp"
namespace ams::pwm::driver::board::nintendo_nx::impl {
namespace {
constexpr inline u32 PwmClockRateHz = 45'333'333;
constexpr inline TimeSpan DefaultChannelPeriod = TimeSpan::FromMilliSeconds(10);
constexpr inline int MaxDuty = 0x100;
template<typename T>
T DivideRoundUp(T a, T b) {
return (a + (b / 2)) / b;
}
}
PwmDriverImpl::PwmDriverImpl(dd::PhysicalAddress paddr, size_t sz, const ChannelDefinition *c, size_t nc) : registers_phys_addr(paddr), registers_size(sz), channels(c), num_channels(nc), registers(0) {
/* ... */
}
void PwmDriverImpl::PowerOn() {
/* Initialize pcv driver. */
pcv::Initialize();
/* Setup clock/power for pwm. */
R_ABORT_UNLESS(pcv::SetReset(pcv::Module_Pwm, true));
R_ABORT_UNLESS(pcv::SetClockEnabled(pcv::Module_Pwm, true));
R_ABORT_UNLESS(pcv::SetClockRate(pcv::Module_Pwm, PwmClockRateHz));
R_ABORT_UNLESS(pcv::SetReset(pcv::Module_Pwm, false));
}
void PwmDriverImpl::PowerOff() {
/* Disable clock and hold pwm in reset. */
/* NOTE: Nintendo does not check this succeeds. */
pcv::SetClockEnabled(pcv::Module_Pwm, false);
pcv::SetReset(pcv::Module_Pwm, true);
/* Finalize pcv driver. */
pcv::Finalize();
}
void PwmDriverImpl::InitializeDriver() {
/* Get the registers virtual address. */
this->registers = dd::QueryIoMapping(this->registers_phys_addr, this->registers_size);
AMS_ABORT_UNLESS(this->registers != 0);
/* Setup power to pwm. */
this->PowerOn();
}
void PwmDriverImpl::FinalizeDriver() {
/* Shut down power to pwm. */
this->PowerOff();
}
Result PwmDriverImpl::InitializeDevice(IPwmDevice *device) {
/* Validate the device. */
AMS_ASSERT(device != nullptr);
/* Configure initial settings. */
/* NOTE: None of these results are checked. */
this->SetEnabled(device, false);
this->SetDuty(device, 0);
this->SetPeriod(device, DefaultChannelPeriod);
return ResultSuccess();
}
void PwmDriverImpl::FinalizeDevice(IPwmDevice *device) {
/* Validate the device. */
AMS_ASSERT(device != nullptr);
/* Nothing to do here. */
AMS_UNUSED(device);
}
Result PwmDriverImpl::SetPeriod(IPwmDevice *device, TimeSpan period) {
/* Validate the device. */
AMS_ASSERT(device != nullptr);
/* Verify the period is valid. */
const auto ns = period.GetNanoSeconds();
R_UNLESS(ns > 0, pwm::ResultInvalidArgument());
/* Convert the ns to a desired frequency (rounding up). */
const auto hz = DivideRoundUp(TimeSpan::FromSeconds(1).GetNanoSeconds(), ns);
R_UNLESS(hz > 0, pwm::ResultInvalidArgument());
/* Convert the frequency to a pfm value. */
const u32 pfm = std::min<u32>(std::max<u32>(DivideRoundUp<u64>(PwmClockRateHz, hz * 256), 1) - 1, 0x1FFF);
/* Acquire exclusive access to the device registers. */
std::scoped_lock lk(device->SafeCastTo<PwmDeviceImpl>());
/* Update the period. */
reg::ReadWrite(this->GetRegistersFor(device) + PWM_CONTROLLER_PWM_CSR, PWM_REG_BITS_VALUE(PWM_CSR_PFM, pfm));
return ResultSuccess();
}
Result PwmDriverImpl::GetPeriod(TimeSpan *out, IPwmDevice *device) {
/* Validate the device. */
AMS_ASSERT(out != nullptr);
AMS_ASSERT(device != nullptr);
/* Get the pfm value. */
const u32 pfm = reg::GetValue(this->GetRegistersFor(device) + PWM_CONTROLLER_PWM_CSR, PWM_REG_BITS_MASK(PWM_CSR_PFM));
/* Convert it to a frequency. */
/* pfm = ((ClockRate / (hz * 256)) - 1) -> hz = (ClockRate / ((pfm + 1) * 256)) */
const auto hz = DivideRoundUp<s64>(PwmClockRateHz, (pfm + 1) * 256);
/* Convert the frequency to a period. */
const auto ns = DivideRoundUp(TimeSpan::FromSeconds(1).GetNanoSeconds(), hz);
/* Set the output. */
*out = TimeSpan::FromNanoSeconds(ns);
return ResultSuccess();
}
Result PwmDriverImpl::SetDuty(IPwmDevice *device, int duty) {
/* Validate the device. */
AMS_ASSERT(device != nullptr);
/* Validate the duty. */
R_UNLESS(0 <= duty && duty < MaxDuty, pwm::ResultInvalidArgument());
/* Acquire exclusive access to the device registers. */
std::scoped_lock lk(device->SafeCastTo<PwmDeviceImpl>());
/* Update the duty. */
reg::ReadWrite(this->GetRegistersFor(device) + PWM_CONTROLLER_PWM_CSR, PWM_REG_BITS_VALUE(PWM_CSR_PWM, static_cast<u32>(duty)));
return ResultSuccess();
}
Result PwmDriverImpl::GetDuty(int *out, IPwmDevice *device) {
/* Validate the device. */
AMS_ASSERT(out != nullptr);
AMS_ASSERT(device != nullptr);
/* Get the duty. */
*out = static_cast<int>(reg::GetValue(this->GetRegistersFor(device) + PWM_CONTROLLER_PWM_CSR, PWM_REG_BITS_MASK(PWM_CSR_PWM)));
return ResultSuccess();
}
Result PwmDriverImpl::SetScale(IPwmDevice *device, double scale) {
/* Validate the device. */
AMS_ASSERT(device != nullptr);
/* Convert the scale to a duty. */
const int duty = static_cast<int>(((scale * 256.0) / 100.0) + 0.5);
/* Set the duty. */
return this->SetDuty(device, duty);
}
Result PwmDriverImpl::GetScale(double *out, IPwmDevice *device) {
/* Validate the device. */
AMS_ASSERT(out != nullptr);
AMS_ASSERT(device != nullptr);
/* Get the duty. */
const int duty = static_cast<int>(reg::GetValue(this->GetRegistersFor(device) + PWM_CONTROLLER_PWM_CSR, PWM_REG_BITS_MASK(PWM_CSR_PWM)));
/* Convert to scale. */
*out = (static_cast<double>(duty) * 100.0) / 256.0;
return ResultSuccess();
}
Result PwmDriverImpl::SetEnabled(IPwmDevice *device, bool en) {
/* Validate the device. */
AMS_ASSERT(device != nullptr);
/* Acquire exclusive access to the device registers. */
std::scoped_lock lk(device->SafeCastTo<PwmDeviceImpl>());
/* Update the enable. */
reg::ReadWrite(this->GetRegistersFor(device) + PWM_CONTROLLER_PWM_CSR, PWM_REG_BITS_ENUM_SEL(PWM_CSR_ENB, en, ENABLE, DISABLE));
return ResultSuccess();
}
Result PwmDriverImpl::GetEnabled(bool *out, IPwmDevice *device) {
/* Validate the device. */
AMS_ASSERT(out != nullptr);
AMS_ASSERT(device != nullptr);
/* Get the enable. */
*out = reg::HasValue(this->GetRegistersFor(device) + PWM_CONTROLLER_PWM_CSR, PWM_REG_BITS_ENUM(PWM_CSR_ENB, ENABLE));
return ResultSuccess();
}
Result PwmDriverImpl::Suspend() {
/* Suspend each device. */
this->ForEachDevice([&](ddsf::IDevice &device) -> bool {
/* Convert the device to a pwm device. */
auto &pwm_device = device.SafeCastTo<PwmDeviceImpl>();
/* Cache the suspend value. */
pwm_device.SetSuspendValue(reg::Read(this->GetRegistersFor(pwm_device) + PWM_CONTROLLER_PWM_CSR));
/* Acquire exclusive access to the device. */
std::scoped_lock lk(pwm_device);
/* Disable the device. */
reg::ReadWrite(this->GetRegistersFor(pwm_device) + PWM_CONTROLLER_PWM_CSR, PWM_REG_BITS_ENUM(PWM_CSR_ENB, DISABLE));
/* Continue to the next device. */
return true;
});
/* Disable clock to pwm. */
return pcv::SetClockEnabled(pcv::Module_Pwm, false);
}
void PwmDriverImpl::Resume() {
/* Power on. */
this->PowerOn();
/* Resume each device. */
this->ForEachDevice([&](ddsf::IDevice &device) -> bool {
/* Convert the device to a pwm device. */
auto &pwm_device = device.SafeCastTo<PwmDeviceImpl>();
/* Acquire exclusive access to the device. */
std::scoped_lock lk(pwm_device);
/* Write the device's suspend value. */
reg::Write(this->GetRegistersFor(pwm_device) + PWM_CONTROLLER_PWM_CSR, pwm_device.GetSuspendValue());
/* Continue to the next device. */
return true;
});
}
}

85
libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/impl/pwm_pwm_driver_impl.hpp Normal file
View File

@@ -0,0 +1,85 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <stratosphere.hpp>
#include "pwm_impl_pwm_driver_api.hpp"
namespace ams::pwm::driver::board::nintendo_nx::impl {
class PwmDeviceImpl : public ::ams::pwm::driver::IPwmDevice {
NON_COPYABLE(PwmDeviceImpl);
NON_MOVEABLE(PwmDeviceImpl);
AMS_DDSF_CASTABLE_TRAITS(ams::pwm::driver::board::nintendo_nx::impl::PwmDeviceImpl, ::ams::pwm::driver::IPwmDevice);
private:
os::SdkMutex suspend_mutex;
u32 suspend_value;
public:
PwmDeviceImpl(int channel) : IPwmDevice(channel), suspend_mutex(), suspend_value() { /* ... */ }
void SetSuspendValue(u32 v) { this->suspend_value = v; }
u32 GetSuspendValue() const { return this->suspend_value; }
void lock() { return this->suspend_mutex.lock(); }
void unlock() { return this->suspend_mutex.unlock(); }
};
class PwmDriverImpl : public ::ams::pwm::driver::IPwmDriver {
NON_COPYABLE(PwmDriverImpl);
NON_MOVEABLE(PwmDriverImpl);
AMS_DDSF_CASTABLE_TRAITS(ams::pwm::driver::board::nintendo_nx::impl::PwmDriverImpl, ::ams::pwm::driver::IPwmDriver);
private:
dd::PhysicalAddress registers_phys_addr;
size_t registers_size;
const ChannelDefinition *channels;
size_t num_channels;
uintptr_t registers;
private:
ALWAYS_INLINE uintptr_t GetRegistersFor(IPwmDevice &device) {
return registers + PWM_CONTROLLER_PWM_CHANNEL_OFFSET(device.GetChannelIndex());
}
ALWAYS_INLINE uintptr_t GetRegistersFor(IPwmDevice *device) {
return this->GetRegistersFor(*device);
}
void PowerOn();
void PowerOff();
public:
PwmDriverImpl(dd::PhysicalAddress paddr, size_t sz, const ChannelDefinition *c, size_t nsc);
virtual void InitializeDriver() override;
virtual void FinalizeDriver() override;
virtual Result InitializeDevice(IPwmDevice *device) override;
virtual void FinalizeDevice(IPwmDevice *device) override;
virtual Result SetPeriod(IPwmDevice *device, TimeSpan period) override;
virtual Result GetPeriod(TimeSpan *out, IPwmDevice *device) override;
virtual Result SetDuty(IPwmDevice *device, int duty) override;
virtual Result GetDuty(int *out, IPwmDevice *device) override;
virtual Result SetScale(IPwmDevice *device, double scale) override;
virtual Result GetScale(double *out, IPwmDevice *device) override;
virtual Result SetEnabled(IPwmDevice *device, bool en) override;
virtual Result GetEnabled(bool *out, IPwmDevice *device) override;
virtual Result Suspend() override;
virtual void Resume() override;
};
}

26
libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/pwm_driver_api.cpp Normal file
View File

@@ -0,0 +1,26 @@
/*
* Copyright (c) 2018-2020 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stratosphere.hpp>
#include "impl/pwm_impl_pwm_driver_api.hpp"
namespace ams::pwm::driver::board::nintendo_nx {
void Initialize() {
R_ABORT_UNLESS(impl::InitializePwmDriver());
/* TODO: R_ABORT_UNLESS(impl::InitializePmcDriver()); */
}
}