pwm: implement driver for boot sysmodule

libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/impl/pwm_impl_pwm_driver_api.cpp

@@ -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();
+    }
+
+}

libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/impl/pwm_impl_pwm_driver_api.hpp

@@ -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();
+
+}

libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/impl/pwm_pwm_driver_impl.cpp

@@ -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;
+        });
+    }
+
+}

libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/impl/pwm_pwm_driver_impl.hpp

@@ -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;
+    };
+
+}

libraries/libstratosphere/source/pwm/driver/board/nintendo_nx/pwm_driver_api.cpp

@@ -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()); */
+    }
+
+}

libraries/libstratosphere/source/pwm/driver/impl/pwm_channel_session_impl.cpp

@@ -0,0 +1,124 @@
+/*
+ * 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_driver_core.hpp"
+#include "pwm_channel_session_impl.hpp"
+
+namespace ams::pwm::driver::impl {
+
+    Result ChannelSessionImpl::Open(IPwmDevice *device, ddsf::AccessMode access_mode) {
+        AMS_ASSERT(device != nullptr);
+
+        /* Check if we're the device's first session. */
+        const bool first = !device->HasAnyOpenSession();
+
+        /* Open the session. */
+        R_TRY(ddsf::OpenSession(device, this, access_mode));
+        auto guard = SCOPE_GUARD { ddsf::CloseSession(this); };
+
+        /* If we're the first session, initialize the device. */
+        if (first) {
+            R_TRY(device->GetDriver().SafeCastTo<IPwmDriver>().InitializeDevice(device));
+        }
+
+        /* We're opened. */
+        guard.Cancel();
+        return ResultSuccess();
+    }
+
+    void ChannelSessionImpl::Close() {
+        /* If we're not open, do nothing. */
+        if (!this->IsOpen()) {
+            return;
+        }
+
+        /* Get the device. */
+        auto &device = this->GetDevice().SafeCastTo<IPwmDevice>();
+
+        /* Close the session. */
+        ddsf::CloseSession(this);
+
+        /* If there are no remaining sessions, finalize the device. */
+        if (!device.HasAnyOpenSession()) {
+            device.GetDriver().SafeCastTo<IPwmDriver>().FinalizeDevice(std::addressof(device));
+        }
+    }
+
+    Result ChannelSessionImpl::SetPeriod(TimeSpan period) {
+        /* Get the device. */
+        IPwmDevice &device = this->GetDevice().SafeCastTo<IPwmDevice>();
+
+        /* Invoke the driver handler. */
+        return device.GetDriver().SafeCastTo<IPwmDriver>().SetPeriod(std::addressof(device), period);
+    }
+
+    Result ChannelSessionImpl::GetPeriod(TimeSpan *out) {
+        /* Get the device. */
+        IPwmDevice &device = this->GetDevice().SafeCastTo<IPwmDevice>();
+
+        /* Invoke the driver handler. */
+        return device.GetDriver().SafeCastTo<IPwmDriver>().GetPeriod(out, std::addressof(device));
+    }
+
+    Result ChannelSessionImpl::SetDuty(int duty) {
+        /* Get the device. */
+        IPwmDevice &device = this->GetDevice().SafeCastTo<IPwmDevice>();
+
+        /* Invoke the driver handler. */
+        return device.GetDriver().SafeCastTo<IPwmDriver>().SetDuty(std::addressof(device), duty);
+    }
+
+    Result ChannelSessionImpl::GetDuty(int *out) {
+        /* Get the device. */
+        IPwmDevice &device = this->GetDevice().SafeCastTo<IPwmDevice>();
+
+        /* Invoke the driver handler. */
+        return device.GetDriver().SafeCastTo<IPwmDriver>().GetDuty(out, std::addressof(device));
+    }
+
+    Result ChannelSessionImpl::SetEnabled(bool en) {
+        /* Get the device. */
+        IPwmDevice &device = this->GetDevice().SafeCastTo<IPwmDevice>();
+
+        /* Invoke the driver handler. */
+        return device.GetDriver().SafeCastTo<IPwmDriver>().SetEnabled(std::addressof(device), en);
+    }
+
+    Result ChannelSessionImpl::GetEnabled(bool *out) {
+        /* Get the device. */
+        IPwmDevice &device = this->GetDevice().SafeCastTo<IPwmDevice>();
+
+        /* Invoke the driver handler. */
+        return device.GetDriver().SafeCastTo<IPwmDriver>().GetEnabled(out, std::addressof(device));
+    }
+
+    Result ChannelSessionImpl::SetScale(double scale) {
+        /* Get the device. */
+        IPwmDevice &device = this->GetDevice().SafeCastTo<IPwmDevice>();
+
+        /* Invoke the driver handler. */
+        return device.GetDriver().SafeCastTo<IPwmDriver>().SetScale(std::addressof(device), scale);
+    }
+
+    Result ChannelSessionImpl::GetScale(double *out) {
+        /* Get the device. */
+        IPwmDevice &device = this->GetDevice().SafeCastTo<IPwmDevice>();
+
+        /* Invoke the driver handler. */
+        return device.GetDriver().SafeCastTo<IPwmDriver>().GetScale(out, std::addressof(device));
+    }
+
+}

libraries/libstratosphere/source/pwm/driver/impl/pwm_channel_session_impl.hpp

@@ -0,0 +1,77 @@
+/*
+ * 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::impl {
+
+    class ChannelSessionImpl : public ::ams::ddsf::ISession {
+        NON_COPYABLE(ChannelSessionImpl);
+        NON_MOVEABLE(ChannelSessionImpl);
+        AMS_DDSF_CASTABLE_TRAITS(ams::pwm::driver::impl::ChannelSessionImpl, ::ams::ddsf::ISession);
+        public:
+            ChannelSessionImpl() { /* ... */ }
+
+            ~ChannelSessionImpl() {
+                this->Close();
+            }
+
+            Result Open(IPwmDevice *device, ddsf::AccessMode access_mode);
+            void Close();
+
+            Result SetPeriod(TimeSpan period);
+            Result GetPeriod(TimeSpan *out);
+
+            Result SetDuty(int duty);
+            Result GetDuty(int *out);
+
+            Result SetEnabled(bool en);
+            Result GetEnabled(bool *out);
+
+            Result SetScale(double scale);
+            Result GetScale(double *out);
+    };
+    static_assert( sizeof(ChannelSessionImpl) <= ChannelSessionSize);
+    static_assert(alignof(ChannelSessionImpl) <= ChannelSessionAlign);
+
+    struct alignas(ChannelSessionAlign) ChannelSessionImplPadded {
+        ChannelSessionImpl _impl;
+        u8 _padding[ChannelSessionSize - sizeof(ChannelSessionImpl)];
+    };
+    static_assert( sizeof(ChannelSessionImplPadded) == ChannelSessionSize);
+    static_assert(alignof(ChannelSessionImplPadded) == ChannelSessionAlign);
+
+    ALWAYS_INLINE ChannelSessionImpl &GetChannelSessionImpl(ChannelSession &session) {
+        return GetReference(session._impl)._impl;
+    }
+
+    ALWAYS_INLINE const ChannelSessionImpl &GetChannelSessionImpl(const ChannelSession &session) {
+        return GetReference(session._impl)._impl;
+    }
+
+    ALWAYS_INLINE ChannelSessionImpl &GetOpenChannelSessionImpl(ChannelSession &session) {
+        auto &ref = GetReference(session._impl)._impl;
+        AMS_ASSERT(ref.IsOpen());
+        return ref;
+    }
+
+    ALWAYS_INLINE const ChannelSessionImpl &GetOpenChannelSessionImpl(const ChannelSession &session) {
+        const auto &ref = GetReference(session._impl)._impl;
+        AMS_ASSERT(ref.IsOpen());
+        return ref;
+    }
+
+}

libraries/libstratosphere/source/pwm/driver/impl/pwm_driver_core.cpp

@@ -0,0 +1,126 @@
+/*
+ * 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_driver_core.hpp"
+
+namespace ams::pwm::driver::impl {
+
+    namespace {
+
+        constinit os::SdkMutex g_init_mutex;
+        constinit int g_init_count = 0;
+
+        pwm::driver::IPwmDriver::List &GetPwmDriverList() {
+            static pwm::driver::IPwmDriver::List s_driver_list;
+            return s_driver_list;
+        }
+
+        ddsf::DeviceCodeEntryManager &GetDeviceCodeEntryManager() {
+            static ddsf::DeviceCodeEntryManager s_device_code_entry_manager(ddsf::GetDeviceCodeEntryHolderMemoryResource());
+            return s_device_code_entry_manager;
+        }
+
+    }
+
+
+    void InitializeDrivers() {
+        std::scoped_lock lk(g_init_mutex);
+
+        /* Initialize all registered drivers, if this is our first initialization. */
+        if ((g_init_count++) == 0) {
+            for (auto &driver : GetPwmDriverList()) {
+                driver.SafeCastTo<IPwmDriver>().InitializeDriver();
+            }
+        }
+    }
+
+    void FinalizeDrivers() {
+        std::scoped_lock lk(g_init_mutex);
+
+        /* If we have no remaining sessions, close. */
+        if ((--g_init_count) == 0) {
+            /* Reset all device code entries. */
+            GetDeviceCodeEntryManager().Reset();
+
+            /* Finalize all drivers. */
+            for (auto &driver : GetPwmDriverList()) {
+                driver.SafeCastTo<IPwmDriver>().FinalizeDriver();
+            }
+        }
+    }
+
+    void RegisterDriver(IPwmDriver *driver) {
+        AMS_ASSERT(driver != nullptr);
+        GetPwmDriverList().push_back(*driver);
+    }
+
+    void UnregisterDriver(IPwmDriver *driver) {
+        AMS_ASSERT(driver != nullptr);
+        if (driver->IsLinkedToList()) {
+            auto &list = GetPwmDriverList();
+            list.erase(list.iterator_to(*driver));
+        }
+    }
+
+    Result RegisterDeviceCode(DeviceCode device_code, IPwmDevice *device) {
+        AMS_ASSERT(device != nullptr);
+        R_TRY(GetDeviceCodeEntryManager().Add(device_code, device));
+        return ResultSuccess();
+    }
+
+    bool UnregisterDeviceCode(DeviceCode device_code) {
+        return GetDeviceCodeEntryManager().Remove(device_code);
+    }
+
+    Result FindDevice(IPwmDevice **out, DeviceCode device_code) {
+        /* Validate output. */
+        AMS_ASSERT(out != nullptr);
+
+        /* Find the device. */
+        ddsf::IDevice *device;
+        R_TRY(GetDeviceCodeEntryManager().FindDevice(std::addressof(device), device_code));
+
+        /* Set output. */
+        *out = device->SafeCastToPointer<IPwmDevice>();
+        return ResultSuccess();
+    }
+
+    Result FindDeviceByChannelIndex(IPwmDevice **out, int channel) {
+        /* Validate output. */
+        AMS_ASSERT(out != nullptr);
+
+        /* Find the device. */
+        bool found = false;
+        GetDeviceCodeEntryManager().ForEachEntry([&](ddsf::DeviceCodeEntry &entry) -> bool {
+            /* Convert the entry to an IPwmDevice. */
+            auto &device = entry.GetDevice().SafeCastTo<IPwmDevice>();
+
+            /* Check if the device is the one we're looking for. */
+            if (device.GetChannelIndex() == channel) {
+                found = true;
+                *out = std::addressof(device);
+                return false;
+            }
+            return true;
+        });
+
+        /* Check that we found the pad. */
+        R_UNLESS(found, ddsf::ResultDeviceCodeNotFound());
+
+        return ResultSuccess();
+    }
+
+}

libraries/libstratosphere/source/pwm/driver/impl/pwm_driver_core.hpp

@@ -0,0 +1,33 @@
+/*
+ * 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::impl {
+
+    void InitializeDrivers();
+    void FinalizeDrivers();
+
+    void RegisterDriver(IPwmDriver *driver);
+    void UnregisterDriver(IPwmDriver *driver);
+
+    Result RegisterDeviceCode(DeviceCode device_code, IPwmDevice *device);
+    bool UnregisterDeviceCode(DeviceCode device_code);
+
+    Result FindDevice(IPwmDevice **out, DeviceCode device_code);
+    Result FindDeviceByChannelIndex(IPwmDevice **out, int channel);
+
+}

libraries/libstratosphere/source/pwm/driver/pwm_driver_channel_api.cpp

@@ -0,0 +1,97 @@
+/*
+ * 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_driver_core.hpp"
+#include "impl/pwm_channel_session_impl.hpp"
+
+namespace ams::pwm::driver {
+
+    namespace {
+
+        Result OpenSessionImpl(ChannelSession *out, IPwmDevice *device) {
+            /* Construct the session. */
+            auto *session = new (std::addressof(impl::GetChannelSessionImpl(*out))) impl::ChannelSessionImpl;
+            auto session_guard = SCOPE_GUARD { session->~ChannelSessionImpl(); };
+
+            /* Open the session. */
+            R_TRY(session->Open(device, ddsf::AccessMode_ReadWrite));
+
+            /* We succeeded. */
+            session_guard.Cancel();
+            return ResultSuccess();
+        }
+
+    }
+
+    Result OpenSession(ChannelSession *out, DeviceCode device_code) {
+        AMS_ASSERT(out != nullptr);
+
+        /* Find the device. */
+        IPwmDevice *device = nullptr;
+        R_TRY(impl::FindDevice(std::addressof(device), device_code));
+        AMS_ASSERT(device != nullptr);
+
+        /* Open the session. */
+        R_TRY(OpenSessionImpl(out, device));
+
+        return ResultSuccess();
+    }
+
+    void CloseSession(ChannelSession &session) {
+        impl::GetOpenChannelSessionImpl(session).~ChannelSessionImpl();
+    }
+
+    void SetPeriod(ChannelSession &session, TimeSpan period) {
+        R_ABORT_UNLESS(impl::GetOpenChannelSessionImpl(session).SetPeriod(period));
+    }
+
+    TimeSpan GetPeriod(ChannelSession &session) {
+        TimeSpan out_val;
+        R_ABORT_UNLESS(impl::GetOpenChannelSessionImpl(session).GetPeriod(std::addressof(out_val)));
+        return out_val;
+    }
+
+    void SetDuty(ChannelSession &session, int duty) {
+        R_ABORT_UNLESS(impl::GetOpenChannelSessionImpl(session).SetDuty(duty));
+    }
+
+    int GetDuty(ChannelSession &session) {
+        int out_val;
+        R_ABORT_UNLESS(impl::GetOpenChannelSessionImpl(session).GetDuty(std::addressof(out_val)));
+        return out_val;
+    }
+
+    void SetEnabled(ChannelSession &session, bool en) {
+        R_ABORT_UNLESS(impl::GetOpenChannelSessionImpl(session).SetEnabled(en));
+    }
+
+    bool GetEnabled(ChannelSession &session) {
+        bool out_val;
+        R_ABORT_UNLESS(impl::GetOpenChannelSessionImpl(session).GetEnabled(std::addressof(out_val)));
+        return out_val;
+    }
+
+    void SetScale(ChannelSession &session, double scale) {
+        R_ABORT_UNLESS(impl::GetOpenChannelSessionImpl(session).SetScale(scale));
+    }
+
+    double GetScale(ChannelSession &session) {
+        double out_val;
+        R_ABORT_UNLESS(impl::GetOpenChannelSessionImpl(session).GetScale(std::addressof(out_val)));
+        return out_val;
+    }
+}

libraries/libstratosphere/source/pwm/driver/pwm_driver_client_api.cpp

@@ -0,0 +1,30 @@
+/*
+ * 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_driver_core.hpp"
+
+namespace ams::pwm::driver {
+
+    void Initialize() {
+        return impl::InitializeDrivers();
+    }
+
+    void Finalize() {
+        return impl::FinalizeDrivers();
+    }
+
+}

libraries/libstratosphere/source/pwm/driver/pwm_driver_service_api.cpp

@@ -0,0 +1,38 @@
+/*
+ * 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_driver_core.hpp"
+
+namespace ams::pwm::driver {
+
+    void RegisterDriver(IPwmDriver *driver) {
+        return impl::RegisterDriver(driver);
+    }
+
+    void UnregisterDriver(IPwmDriver *driver) {
+        return impl::UnregisterDriver(driver);
+    }
+
+    Result RegisterDeviceCode(DeviceCode device_code, IPwmDevice *device) {
+        return impl::RegisterDeviceCode(device_code, device);
+    }
+
+    bool UnregisterDeviceCode(DeviceCode device_code) {
+        return impl::UnregisterDeviceCode(device_code);
+    }
+
+}

libraries/libstratosphere/source/pwm/pwm_api.cpp

@@ -0,0 +1,126 @@
+/*
+ * 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>
+
+namespace ams::pwm {
+
+    namespace {
+
+        constinit os::SdkMutex g_init_mutex;
+        constinit int g_initialize_count = 0;
+
+        std::shared_ptr<sf::IManager> g_pwm_manager;
+
+        using InternalSession = std::shared_ptr<pwm::sf::IChannelSession>;
+
+        InternalSession &GetInterface(const ChannelSession &session) {
+            AMS_ASSERT(session._session != nullptr);
+            return *static_cast<InternalSession *>(session._session);
+        }
+    }
+
+    void InitializeWith(std::shared_ptr<pwm::sf::IManager> &&sp) {
+        std::scoped_lock lk(g_init_mutex);
+
+        AMS_ABORT_UNLESS(g_initialize_count == 0);
+
+        g_pwm_manager = std::move(sp);
+
+        g_initialize_count = 1;
+    }
+
+    void Finalize() {
+        std::scoped_lock lk(g_init_mutex);
+
+        AMS_ASSERT(g_initialize_count > 0);
+
+        if ((--g_initialize_count) == 0) {
+            g_pwm_manager.reset();
+        }
+    }
+
+    Result OpenSession(ChannelSession *out, DeviceCode device_code) {
+        /* Allocate the session. */
+        InternalSession *internal_session = new (std::nothrow) InternalSession;
+        AMS_ABORT_UNLESS(internal_session != nullptr);
+        auto session_guard = SCOPE_GUARD { delete internal_session; };
+
+        /* Get the session. */
+        {
+            ams::sf::cmif::ServiceObjectHolder object_holder;
+            if (hos::GetVersion() >= hos::Version_6_0_0) {
+                R_TRY(g_pwm_manager->OpenSession2(std::addressof(object_holder), device_code));
+            } else {
+                R_TRY(g_pwm_manager->OpenSession(std::addressof(object_holder), ConvertToChannelName(device_code)));
+            }
+            *internal_session = object_holder.GetServiceObject<sf::IChannelSession>();
+        }
+
+        /* Set output. */
+        out->_session = internal_session;
+
+        /* We succeeded. */
+        session_guard.Cancel();
+        return ResultSuccess();
+    }
+
+    void CloseSession(ChannelSession &session) {
+        /* Close the session. */
+        delete std::addressof(GetInterface(session));
+        session._session = nullptr;
+    }
+
+    void SetPeriod(ChannelSession &session, TimeSpan period) {
+        R_ABORT_UNLESS(GetInterface(session)->SetPeriod(period));
+    }
+
+    TimeSpan GetPeriod(ChannelSession &session) {
+        TimeSpanType out_val;
+        R_ABORT_UNLESS(GetInterface(session)->GetPeriod(std::addressof(out_val)));
+        return out_val;
+    }
+
+    void SetDuty(ChannelSession &session, int duty) {
+        R_ABORT_UNLESS(GetInterface(session)->SetDuty(duty));
+    }
+
+    int GetDuty(ChannelSession &session) {
+        int out_val;
+        R_ABORT_UNLESS(GetInterface(session)->GetDuty(std::addressof(out_val)));
+        return out_val;
+    }
+
+    void SetEnabled(ChannelSession &session, bool en) {
+        R_ABORT_UNLESS(GetInterface(session)->SetEnabled(en));
+    }
+
+    bool GetEnabled(ChannelSession &session) {
+        bool out_val;
+        R_ABORT_UNLESS(GetInterface(session)->GetEnabled(std::addressof(out_val)));
+        return out_val;
+    }
+
+    void SetScale(ChannelSession &session, double scale) {
+        R_ABORT_UNLESS(GetInterface(session)->SetScale(scale));
+    }
+
+    double GetScale(ChannelSession &session) {
+        double out_val;
+        R_ABORT_UNLESS(GetInterface(session)->GetScale(std::addressof(out_val)));
+        return out_val;
+    }
+
+}

libraries/libstratosphere/source/pwm/server/pwm_server_api.cpp

@@ -0,0 +1,36 @@
+/*
+ * 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_server_manager_impl.hpp"
+
+namespace ams::pwm::server {
+
+    namespace {
+
+        ManagerImpl g_manager_impl;
+
+        std::shared_ptr<pwm::sf::IManager> GetManagerServiceObject() {
+            static std::shared_ptr<pwm::sf::IManager> s_sp = ams::sf::GetSharedPointerTo<pwm::sf::IManager>(g_manager_impl);
+            return s_sp;
+        }
+
+    }
+
+    std::shared_ptr<pwm::sf::IManager> GetServiceObject() {
+        return GetManagerServiceObject();
+    }
+
+}

libraries/libstratosphere/source/pwm/server/pwm_server_channel_session_impl.hpp

@@ -0,0 +1,88 @@
+/*
+ * 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::server {
+
+    class ManagerImpl;
+
+    class ChannelSessionImpl {
+        private:
+            ManagerImpl *parent; /* NOTE: this is an sf::SharedPointer<> in Nintendo's code. */
+            pwm::driver::ChannelSession internal_session;
+            bool has_session;
+        public:
+            explicit ChannelSessionImpl(ManagerImpl *p) : parent(p), has_session(false) { /* ... */ }
+
+            ~ChannelSessionImpl() {
+                if (this->has_session) {
+                    pwm::driver::CloseSession(this->internal_session);
+                }
+            }
+
+            Result OpenSession(DeviceCode device_code) {
+                AMS_ABORT_UNLESS(!this->has_session);
+
+                R_TRY(pwm::driver::OpenSession(std::addressof(this->internal_session), device_code));
+                this->has_session = true;
+                return ResultSuccess();
+            }
+        public:
+            /* Actual commands. */
+            Result SetPeriod(TimeSpanType period) {
+                pwm::driver::SetPeriod(this->internal_session, period);
+                return ResultSuccess();
+            }
+
+            Result GetPeriod(ams::sf::Out<TimeSpanType> out) {
+                out.SetValue(pwm::driver::GetPeriod(this->internal_session));
+                return ResultSuccess();
+            }
+
+            Result SetDuty(int duty) {
+                pwm::driver::SetDuty(this->internal_session, duty);
+                return ResultSuccess();
+            }
+
+            Result GetDuty(ams::sf::Out<int> out) {
+                out.SetValue(pwm::driver::GetDuty(this->internal_session));
+                return ResultSuccess();
+            }
+
+            Result SetEnabled(bool enabled) {
+                pwm::driver::SetEnabled(this->internal_session, enabled);
+                return ResultSuccess();
+            }
+
+            Result GetEnabled(ams::sf::Out<bool> out) {
+                out.SetValue(pwm::driver::GetEnabled(this->internal_session));
+                return ResultSuccess();
+            }
+
+            Result SetScale(double scale) {
+                pwm::driver::SetScale(this->internal_session, scale);
+                return ResultSuccess();
+            }
+
+            Result GetScale(ams::sf::Out<double> out) {
+                out.SetValue(pwm::driver::GetScale(this->internal_session));
+                return ResultSuccess();
+            }
+    };
+    static_assert(pwm::sf::IsIChannelSession<ChannelSessionImpl>);
+
+}

libraries/libstratosphere/source/pwm/server/pwm_server_manager_impl.cpp

@@ -0,0 +1,51 @@
+/*
+ * 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_server_manager_impl.hpp"
+
+namespace ams::pwm::server {
+
+    ManagerImpl::ManagerImpl() : session_memory_resource(), allocator(std::addressof(session_memory_resource)) {
+        this->heap_handle = lmem::CreateExpHeap(this->heap_buffer, sizeof(this->heap_buffer), lmem::CreateOption_None);
+        this->session_memory_resource.Attach(this->heap_handle);
+    }
+
+    ManagerImpl::~ManagerImpl() {
+        lmem::DestroyExpHeap(this->heap_handle);
+    }
+
+    Result ManagerImpl::OpenSessionForDev(ams::sf::Out<std::shared_ptr<pwm::sf::IChannelSession>> out, int channel) {
+        /* TODO */
+        AMS_ABORT();
+    }
+
+    Result ManagerImpl::OpenSession(ams::sf::Out<std::shared_ptr<pwm::sf::IChannelSession>> out, pwm::ChannelName channel_name) {
+        return this->OpenSession2(out, ConvertToDeviceCode(channel_name));
+    }
+
+    Result ManagerImpl::OpenSession2(ams::sf::Out<std::shared_ptr<pwm::sf::IChannelSession>> out, DeviceCode device_code) {
+        /* Allocate a session. */
+        auto session = ams::sf::AllocateShared<pwm::sf::IChannelSession, ChannelSessionImpl>(this->allocator, this);
+
+        /* Open the session. */
+        R_TRY(session->GetImpl().OpenSession(device_code));
+
+        /* We succeeded. */
+        out.SetValue(std::move(session));
+        return ResultSuccess();
+    }
+
+}

libraries/libstratosphere/source/pwm/server/pwm_server_manager_impl.hpp

@@ -0,0 +1,40 @@
+/*
+ * 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_server_channel_session_impl.hpp"
+
+namespace ams::pwm::server {
+
+    class ManagerImpl {
+        private:
+            lmem::HeapHandle heap_handle;
+            ams::sf::ExpHeapMemoryResource session_memory_resource;
+            typename ams::sf::ServiceObjectAllocator<pwm::sf::IChannelSession, ChannelSessionImpl> allocator;
+            u8 heap_buffer[4_KB];
+        public:
+            ManagerImpl();
+
+            ~ManagerImpl();
+        public:
+            /* Actual commands. */
+            Result OpenSessionForDev(ams::sf::Out<std::shared_ptr<pwm::sf::IChannelSession>> out, int channel);
+            Result OpenSession(ams::sf::Out<std::shared_ptr<pwm::sf::IChannelSession>> out, pwm::ChannelName channel_name);
+            Result OpenSession2(ams::sf::Out<std::shared_ptr<pwm::sf::IChannelSession>> out, DeviceCode device_code);
+    };
+    static_assert(pwm::sf::IsIManager<ManagerImpl>);
+
+}