mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2024-12-18 08:22:04 +00:00
Code Issues Releases Activity

pwm: implement driver for boot sysmodule

Browse source
This commit is contained in:
Michael Scire 2020-11-01 23:04:19 -08:00 committed by SciresM
parent 35552bac2c
commit 3d31837ca1
41 changed files with 2107 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libraries/libstratosphere/include/stratosphere.hpp
View file

@ -61,6 +61,7 @@
#include <stratosphere/nim.hpp> #include <stratosphere/nim.hpp>
#include <stratosphere/ns.hpp> #include <stratosphere/ns.hpp>
#include <stratosphere/patcher.hpp> #include <stratosphere/patcher.hpp>
#include <stratosphere/pcv.hpp>
#include <stratosphere/pgl.hpp> #include <stratosphere/pgl.hpp>
#include <stratosphere/psc.hpp> #include <stratosphere/psc.hpp>
#include <stratosphere/pm.hpp> #include <stratosphere/pm.hpp>

20
libraries/libstratosphere/include/stratosphere/pcv.hpp Normal file
View file

@ -0,0 +1,20 @@
/*
* 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/pcv/pcv_types.hpp>
#include <stratosphere/pcv/pcv_api.hpp>

30
libraries/libstratosphere/include/stratosphere/pcv/pcv_api.hpp Normal file
View file

@ -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/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/pcv/pcv_types.hpp>
namespace ams::pcv {
void Initialize();
void Finalize();
Result SetClockEnabled(Module module, bool en);
Result SetClockRate(Module module, ClockHz hz);
Result SetReset(Module module, bool en);
}

116
libraries/libstratosphere/include/stratosphere/pcv/pcv_types.hpp Normal file
View file

@ -0,0 +1,116 @@
/*
* 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 <vapours.hpp>
namespace ams::pcv {
using ClockHz = u32;
using MicroVolt = s32;
using MilliC = s32;
/* TODO: Device codes? */
enum Module {
Module_Cpu = 0,
Module_Gpu = 1,
Module_I2s1 = 2,
Module_I2s2 = 3,
Module_I2s3 = 4,
Module_Pwm = 5,
Module_I2c1 = 6,
Module_I2c2 = 7,
Module_I2c3 = 8,
Module_I2c4 = 9,
Module_I2c5 = 10,
Module_I2c6 = 11,
Module_Spi1 = 12,
Module_Spi2 = 13,
Module_Spi3 = 14,
Module_Spi4 = 15,
Module_Disp1 = 16,
Module_Disp2 = 17,
Module_Isp = 18,
Module_Vi = 19,
Module_Sdmmc1 = 20,
Module_Sdmmc2 = 21,
Module_Sdmmc3 = 22,
Module_Sdmmc4 = 23,
Module_Owr = 24,
Module_Csite = 25,
Module_Tsec = 26,
Module_Mselect = 27,
Module_Hda2codec2x = 28,
Module_Actmon = 29,
Module_I2cSlow = 30,
Module_Sor1 = 31,
Module_Sata = 32,
Module_Hda = 33,
Module_XusbCoreHostSrc = 34,
Module_XusbFalconSrc = 35,
Module_XusbFsSrc = 36,
Module_XusbCoreDevSrc = 37,
Module_XusbSsSrc = 38,
Module_UartA = 39,
Module_UartB = 40,
Module_UartC = 41,
Module_UartD = 42,
Module_Host1x = 43,
Module_Entropy = 44,
Module_SocTherm = 45,
Module_Vic = 46,
Module_Nvenc = 47,
Module_Nvjpg = 48,
Module_Nvdec = 49,
Module_Qspi = 50,
Module_ViI2c = 51,
Module_Tsecb = 52,
Module_Ape = 53,
Module_AudioDsp = 54,
Module_AudioUart = 55,
Module_Emc = 56,
Module_Plle = 57,
Module_PlleHwSeq = 58,
Module_Dsi = 59,
Module_Maud = 60,
Module_Dpaux1 = 61,
Module_MipiCal = 62,
Module_UartFstMipiCal = 63,
Module_Osc = 64,
Module_SysBus = 65,
Module_SorSafe = 66,
Module_XusbSs = 67,
Module_XusbHost = 68,
Module_XusbDevice = 69,
Module_Extperiph1 = 70,
Module_Ahub = 71,
Module_Hda2hdmicodec = 72,
Module_Gpuaux = 73,
Module_UsbD = 74,
Module_Usb2 = 75,
Module_Pcie = 76,
Module_Afi = 77,
Module_PciExClk = 78,
Module_PExUsbPhy = 79,
Module_XUsbPadCtl = 80,
Module_Apbdma = 81,
Module_Usb2TrkClk = 82,
Module_XUsbIoPll = 83,
Module_XUsbIoPllHwSeq = 84,
Module_Cec = 85,
Module_Extperiph2 = 86,
};
}

10
libraries/libstratosphere/include/stratosphere/pwm.hpp
View file

@ -15,6 +15,14 @@
*/ */
#pragma once #pragma once
#include <stratosphere/pwm/pwm_types.hpp> #include <stratosphere/pwm/pwm_types.hpp>
#include <stratosphere/pwm/pwm_select_channel_name.hpp> #include <stratosphere/pwm/pwm_select_channel_name.hpp>
#include <stratosphere/pwm/sf/pwm_sf_i_channel_session.hpp>
#include <stratosphere/pwm/sf/pwm_sf_i_manager.hpp>
#include <stratosphere/pwm/server/pwm_server_api.hpp>
#include <stratosphere/pwm/driver/pwm_select_driver_api.hpp>
#include <stratosphere/pwm/driver/pwm_driver_service_api.hpp>
#include <stratosphere/pwm/driver/pwm_driver_client_api.hpp>
#include <stratosphere/pwm/driver/pwm_channel_api.hpp>
#include <stratosphere/pwm/pwm_api.hpp>
#include <stratosphere/pwm/pwm_channel_api.hpp>

24
libraries/libstratosphere/include/stratosphere/pwm/driver/board/nintendo_nx/pwm_driver_api.hpp Normal file
View file

@ -0,0 +1,24 @@
/*
* 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 <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
namespace ams::pwm::driver::board::nintendo_nx {
void Initialize();
}

50
libraries/libstratosphere/include/stratosphere/pwm/driver/pwm_channel_api.hpp Normal file
View file

@ -0,0 +1,50 @@
/*
* 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 <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
namespace ams::pwm::driver {
namespace impl {
constexpr inline size_t ChannelSessionSize = 0x60;
constexpr inline size_t ChannelSessionAlign = 8;
struct alignas(ChannelSessionAlign) ChannelSessionImplPadded;
}
struct ChannelSession {
util::TypedStorage<impl::ChannelSessionImplPadded, impl::ChannelSessionSize, impl::ChannelSessionAlign> _impl;
};
Result OpenSession(ChannelSession *out, DeviceCode device_code);
void CloseSession(ChannelSession &session);
void SetPeriod(ChannelSession &session, TimeSpan period);
TimeSpan GetPeriod(ChannelSession &session);
void SetDuty(ChannelSession &session, int duty);
int GetDuty(ChannelSession &session);
void SetEnabled(ChannelSession &session, bool en);
bool GetEnabled(ChannelSession &session);
void SetScale(ChannelSession &session, double scale);
double GetScale(ChannelSession &session);
}

25
libraries/libstratosphere/include/stratosphere/pwm/driver/pwm_driver_client_api.hpp Normal file
View file

@ -0,0 +1,25 @@
/*
* 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 <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
namespace ams::pwm::driver {
void Initialize();
void Finalize();
}

30
libraries/libstratosphere/include/stratosphere/pwm/driver/pwm_driver_service_api.hpp Normal file
View file

@ -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/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
#include <stratosphere/pwm/driver/pwm_i_pwm_device.hpp>
#include <stratosphere/pwm/driver/pwm_i_pwm_driver.hpp>
namespace ams::pwm::driver {
void RegisterDriver(IPwmDriver *driver);
void UnregisterDriver(IPwmDriver *driver);
Result RegisterDeviceCode(DeviceCode device_code, IPwmDevice *device);
bool UnregisterDeviceCode(DeviceCode device_code);
}

36
libraries/libstratosphere/include/stratosphere/pwm/driver/pwm_i_pwm_device.hpp Normal file
View file

@ -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/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
#include <stratosphere/ddsf.hpp>
namespace ams::pwm::driver {
class IPwmDevice : public ::ams::ddsf::IDevice {
NON_COPYABLE(IPwmDevice);
NON_MOVEABLE(IPwmDevice);
AMS_DDSF_CASTABLE_TRAITS(ams::pwm::IPwmDevice, ::ams::ddsf::IDriver);
private:
int channel_index;
public:
IPwmDevice(int id) : IDevice(false), channel_index(id) { /* ... */ }
virtual ~IPwmDevice() { /* ... */ }
constexpr int GetChannelIndex() const { return this->channel_index; }
};
}

54
libraries/libstratosphere/include/stratosphere/pwm/driver/pwm_i_pwm_driver.hpp Normal file
View file

@ -0,0 +1,54 @@
/*
* 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 <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
#include <stratosphere/pwm/driver/pwm_i_pwm_device.hpp>
#include <stratosphere/ddsf.hpp>
namespace ams::pwm::driver {
class IPwmDriver : public ::ams::ddsf::IDriver {
NON_COPYABLE(IPwmDriver);
NON_MOVEABLE(IPwmDriver);
AMS_DDSF_CASTABLE_TRAITS(ams::pwm::IPwmDriver, ::ams::ddsf::IDriver);
public:
IPwmDriver() : IDriver() { /* ... */ }
virtual ~IPwmDriver() { /* ... */ }
virtual void InitializeDriver() = 0;
virtual void FinalizeDriver() = 0;
virtual Result InitializeDevice(IPwmDevice *device) = 0;
virtual void FinalizeDevice(IPwmDevice *device) = 0;
virtual Result SetPeriod(IPwmDevice *device, TimeSpan period) = 0;
virtual Result GetPeriod(TimeSpan *out, IPwmDevice *device) = 0;
virtual Result SetDuty(IPwmDevice *device, int duty) = 0;
virtual Result GetDuty(int *out, IPwmDevice *device) = 0;
virtual Result SetScale(IPwmDevice *device, double scale) = 0;
virtual Result GetScale(double *out, IPwmDevice *device) = 0;
virtual Result SetEnabled(IPwmDevice *device, bool en) = 0;
virtual Result GetEnabled(bool *out, IPwmDevice *device) = 0;
virtual Result Suspend() = 0;
virtual void Resume() = 0;
};
}

36
libraries/libstratosphere/include/stratosphere/pwm/driver/pwm_select_driver_api.hpp Normal file
View file

@ -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/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
#include <stratosphere/pwm/driver/pwm_i_pwm_driver.hpp>
#if defined(ATMOSPHERE_BOARD_NINTENDO_NX)
#include <stratosphere/pwm/driver/board/nintendo_nx/pwm_driver_api.hpp>
namespace ams::pwm::driver::board {
using namespace ams::pwm::driver::board::nintendo_nx;
}
#else
#error "Unknown board for ams::pwm::driver::"
#endif

26
libraries/libstratosphere/include/stratosphere/pwm/pwm_api.hpp 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/>.
*/
#pragma once
#include <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
#include <stratosphere/pwm/sf/pwm_sf_i_manager.hpp>
namespace ams::pwm {
void InitializeWith(std::shared_ptr<pwm::sf::IManager> &&sp);
void Finalize();
}

41
libraries/libstratosphere/include/stratosphere/pwm/pwm_channel_api.hpp Normal file
View file

@ -0,0 +1,41 @@
/*
* 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 <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
namespace ams::pwm {
struct ChannelSession {
void *_session;
};
Result OpenSession(ChannelSession *out, DeviceCode device_code);
void CloseSession(ChannelSession &session);
void SetPeriod(ChannelSession &session, TimeSpan period);
TimeSpan GetPeriod(ChannelSession &session);
void SetDuty(ChannelSession &session, int duty);
int GetDuty(ChannelSession &session);
void SetEnabled(ChannelSession &session, bool en);
bool GetEnabled(ChannelSession &session);
void SetScale(ChannelSession &session, double scale);
double GetScale(ChannelSession &session);
}

25
libraries/libstratosphere/include/stratosphere/pwm/server/pwm_server_api.hpp Normal file
View file

@ -0,0 +1,25 @@
/*
* 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 <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
#include <stratosphere/pwm/sf/pwm_sf_i_manager.hpp>
namespace ams::pwm::server {
std::shared_ptr<pwm::sf::IManager> GetServiceObject();
}

35
libraries/libstratosphere/include/stratosphere/pwm/sf/pwm_sf_i_channel_session.hpp Normal file
View file

@ -0,0 +1,35 @@
/*
* 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 <vapours.hpp>
#include <stratosphere/pwm/pwm_types.hpp>
namespace ams::pwm::sf {
#define AMS_PWM_I_CHANNEL_SESSION_INTERFACE_INFO(C, H) \
AMS_SF_METHOD_INFO(C, H, 0, Result, SetPeriod, (TimeSpanType period) ) \
AMS_SF_METHOD_INFO(C, H, 1, Result, GetPeriod, (ams::sf::Out<TimeSpanType> out) ) \
AMS_SF_METHOD_INFO(C, H, 2, Result, SetDuty, (int duty) ) \
AMS_SF_METHOD_INFO(C, H, 3, Result, GetDuty, (ams::sf::Out<int> out) ) \
AMS_SF_METHOD_INFO(C, H, 4, Result, SetEnabled, (bool enabled) ) \
AMS_SF_METHOD_INFO(C, H, 5, Result, GetEnabled, (ams::sf::Out<bool> out) ) \
AMS_SF_METHOD_INFO(C, H, 6, Result, SetScale, (double scale), hos::Version_6_0_0) \
AMS_SF_METHOD_INFO(C, H, 7, Result, GetScale, (ams::sf::Out<double> out), hos::Version_6_0_0)
AMS_SF_DEFINE_INTERFACE(IChannelSession, AMS_PWM_I_CHANNEL_SESSION_INTERFACE_INFO)
}

32
libraries/libstratosphere/include/stratosphere/pwm/sf/pwm_sf_i_manager.hpp Normal file
View file

@ -0,0 +1,32 @@
/*
* 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 <vapours.hpp>
#include <stratosphere/ddsf/ddsf_types.hpp>
#include <stratosphere/pwm/pwm_select_channel_name.hpp>
#include <stratosphere/pwm/sf/pwm_sf_i_channel_session.hpp>
namespace ams::pwm::sf {
#define AMS_PWM_I_MANAGER_INTERFACE_INFO(C, H) \
AMS_SF_METHOD_INFO(C, H, 0, Result, OpenSessionForDev, (ams::sf::Out<std::shared_ptr<pwm::sf::IChannelSession>> out, int channel) ) \
AMS_SF_METHOD_INFO(C, H, 1, Result, OpenSession, (ams::sf::Out<std::shared_ptr<pwm::sf::IChannelSession>> out, pwm::ChannelName channel_name) ) \
AMS_SF_METHOD_INFO(C, H, 2, Result, OpenSession2, (ams::sf::Out<std::shared_ptr<pwm::sf::IChannelSession>> out, DeviceCode device_code), hos::Version_6_0_0)
AMS_SF_DEFINE_INTERFACE(IManager, AMS_PWM_I_MANAGER_INTERFACE_INFO)
}

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

124
libraries/libstratosphere/source/pwm/driver/impl/pwm_channel_session_impl.cpp Normal file
View file

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

77
libraries/libstratosphere/source/pwm/driver/impl/pwm_channel_session_impl.hpp Normal file
View file

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

126
libraries/libstratosphere/source/pwm/driver/impl/pwm_driver_core.cpp Normal file
View file

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

33
libraries/libstratosphere/source/pwm/driver/impl/pwm_driver_core.hpp Normal file
View file

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

97
libraries/libstratosphere/source/pwm/driver/pwm_driver_channel_api.cpp Normal file
View file

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

30
libraries/libstratosphere/source/pwm/driver/pwm_driver_client_api.cpp Normal file
View file

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

38
libraries/libstratosphere/source/pwm/driver/pwm_driver_service_api.cpp Normal file
View file

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

126
libraries/libstratosphere/source/pwm/pwm_api.cpp Normal file
View file

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

36
libraries/libstratosphere/source/pwm/server/pwm_server_api.cpp Normal file
View file

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

88
libraries/libstratosphere/source/pwm/server/pwm_server_channel_session_impl.hpp Normal file
View file

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

51
libraries/libstratosphere/source/pwm/server/pwm_server_manager_impl.cpp Normal file
View file

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

40
libraries/libstratosphere/source/pwm/server/pwm_server_manager_impl.hpp Normal file
View file

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

1
libraries/libvapours/include/vapours/results.hpp
View file

@ -47,6 +47,7 @@
#include <vapours/results/pgl_results.hpp> #include <vapours/results/pgl_results.hpp>
#include <vapours/results/pm_results.hpp> #include <vapours/results/pm_results.hpp>
#include <vapours/results/psc_results.hpp> #include <vapours/results/psc_results.hpp>
#include <vapours/results/pwm_results.hpp>
#include <vapours/results/ro_results.hpp> #include <vapours/results/ro_results.hpp>
#include <vapours/results/sdmmc_results.hpp> #include <vapours/results/sdmmc_results.hpp>
#include <vapours/results/settings_results.hpp> #include <vapours/results/settings_results.hpp>

26
libraries/libvapours/include/vapours/results/pwm_results.hpp 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/>.
*/
#pragma once
#include <vapours/results/results_common.hpp>
namespace ams::pwm {
R_DEFINE_NAMESPACE_RESULT_MODULE(189);
R_DEFINE_ERROR_RESULT(InvalidArgument, 2);
}

1
libraries/libvapours/include/vapours/tegra.hpp
View file

@ -35,6 +35,7 @@
#include <vapours/tegra/tegra_pinmux.hpp> #include <vapours/tegra/tegra_pinmux.hpp>
#include <vapours/tegra/tegra_pg_up.hpp> #include <vapours/tegra/tegra_pg_up.hpp>
#include <vapours/tegra/tegra_pmc.hpp> #include <vapours/tegra/tegra_pmc.hpp>
#include <vapours/tegra/tegra_pwm.hpp>
#include <vapours/tegra/tegra_sb.hpp> #include <vapours/tegra/tegra_sb.hpp>
#include <vapours/tegra/tegra_sysctr0.hpp> #include <vapours/tegra/tegra_sysctr0.hpp>
#include <vapours/tegra/tegra_timer.hpp> #include <vapours/tegra/tegra_timer.hpp>

43
libraries/libvapours/include/vapours/tegra/tegra_pwm.hpp Normal file
View file

@ -0,0 +1,43 @@
/*
* 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 <vapours/common.hpp>
#include <vapours/assert.hpp>
#include <vapours/literals.hpp>
#include <vapours/util.hpp>
#include <vapours/results.hpp>
#include <vapours/reg.hpp>
#define PWM_CONTROLLER_PWM_CHANNEL_OFFSET(channel) (0x10 * channel)
#define PWM_CONTROLLER_PWM_CSR (0x000)
#define PWM_REG_BITS_MASK(NAME) REG_NAMED_BITS_MASK (PWM_CONTROLLER, NAME)
#define PWM_REG_BITS_VALUE(NAME, VALUE) REG_NAMED_BITS_VALUE (PWM_CONTROLLER, NAME, VALUE)
#define PWM_REG_BITS_ENUM(NAME, ENUM) REG_NAMED_BITS_ENUM (PWM_CONTROLLER, NAME, ENUM)
#define PWM_REG_BITS_ENUM_SEL(NAME, __COND__, TRUE_ENUM, FALSE_ENUM) REG_NAMED_BITS_ENUM_SEL(PWM_CONTROLLER, NAME, __COND__, TRUE_ENUM, FALSE_ENUM)
#define DEFINE_PWM_REG(NAME, __OFFSET__, __WIDTH__) REG_DEFINE_NAMED_REG (PWM_CONTROLLER, NAME, __OFFSET__, __WIDTH__)
#define DEFINE_PWM_REG_BIT_ENUM(NAME, __OFFSET__, ZERO, ONE) REG_DEFINE_NAMED_BIT_ENUM (PWM_CONTROLLER, NAME, __OFFSET__, ZERO, ONE)
#define DEFINE_PWM_REG_TWO_BIT_ENUM(NAME, __OFFSET__, ZERO, ONE, TWO, THREE) REG_DEFINE_NAMED_TWO_BIT_ENUM (PWM_CONTROLLER, NAME, __OFFSET__, ZERO, ONE, TWO, THREE)
#define DEFINE_PWM_REG_THREE_BIT_ENUM(NAME, __OFFSET__, ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN) REG_DEFINE_NAMED_THREE_BIT_ENUM(PWM_CONTROLLER, NAME, __OFFSET__, ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN)
#define DEFINE_PWM_REG_FOUR_BIT_ENUM(NAME, __OFFSET__, ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, ELEVEN, TWELVE, THIRTEEN, FOURTEEN, FIFTEEN) REG_DEFINE_NAMED_FOUR_BIT_ENUM (PWM_CONTROLLER, NAME, __OFFSET__, ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, ELEVEN, TWELVE, THIRTEEN, FOURTEEN, FIFTEEN)
DEFINE_PWM_REG(PWM_CSR_PFM, 0, 13);
DEFINE_PWM_REG(PWM_CSR_PWM, 16, 15);
DEFINE_PWM_REG_BIT_ENUM(PWM_CSR_ENB, 31, DISABLE, ENABLE);

4
libraries/libvapours/include/vapours/timespan.hpp
View file

@ -95,6 +95,10 @@ namespace ams {
constexpr ALWAYS_INLINE friend TimeSpan operator+(const TimeSpan &lhs, const TimeSpan &rhs) { TimeSpan r(lhs); return r += rhs; } constexpr ALWAYS_INLINE friend TimeSpan operator+(const TimeSpan &lhs, const TimeSpan &rhs) { TimeSpan r(lhs); return r += rhs; }
constexpr ALWAYS_INLINE friend TimeSpan operator-(const TimeSpan &lhs, const TimeSpan &rhs) { TimeSpan r(lhs); return r -= rhs; } constexpr ALWAYS_INLINE friend TimeSpan operator-(const TimeSpan &lhs, const TimeSpan &rhs) { TimeSpan r(lhs); return r -= rhs; }
constexpr ALWAYS_INLINE operator TimeSpanType() const {
return this->ts;
}
}; };
} }

128
stratosphere/boot/source/api_overrides/clkrst_api_for_boot.board.nintendo_nx.cpp → stratosphere/boot/source/api_overrides/pcv_clkrst_api_for_boot.board.nintendo_nx.cpp
View file

@ -15,7 +15,7 @@
*/ */
#include <stratosphere.hpp> #include <stratosphere.hpp>
namespace ams::clkrst { namespace ams {
namespace { namespace {
@ -47,14 +47,15 @@ namespace ams::clkrst {
constexpr inline const struct { constexpr inline const struct {
const ClkRstDefinition *definition; const ClkRstDefinition *definition;
DeviceCode device_code; DeviceCode device_code;
pcv::Module pcv_module;
} ClkRstDefinitionMap[] = { } ClkRstDefinitionMap[] = {
{ std::addressof(Definitions[0]), i2c::DeviceCode_I2c1 }, { std::addressof(Definitions[0]), i2c::DeviceCode_I2c1, pcv::Module_I2c1 },
{ std::addressof(Definitions[1]), i2c::DeviceCode_I2c2 }, { std::addressof(Definitions[1]), i2c::DeviceCode_I2c2, pcv::Module_I2c2 },
{ std::addressof(Definitions[2]), i2c::DeviceCode_I2c3 }, { std::addressof(Definitions[2]), i2c::DeviceCode_I2c3, pcv::Module_I2c3 },
{ std::addressof(Definitions[3]), i2c::DeviceCode_I2c4 }, { std::addressof(Definitions[3]), i2c::DeviceCode_I2c4, pcv::Module_I2c4 },
{ std::addressof(Definitions[4]), i2c::DeviceCode_I2c5 }, { std::addressof(Definitions[4]), i2c::DeviceCode_I2c5, pcv::Module_I2c5 },
{ std::addressof(Definitions[5]), i2c::DeviceCode_I2c6 }, { std::addressof(Definitions[5]), i2c::DeviceCode_I2c6, pcv::Module_I2c6 },
{ std::addressof(Definitions[6]), pwm::DeviceCode_LcdBacklight }, { std::addressof(Definitions[6]), pwm::DeviceCode_LcdBacklight, pcv::Module_Pwm },
}; };
ALWAYS_INLINE const ClkRstDefinition *GetDefinition(DeviceCode device_code) { ALWAYS_INLINE const ClkRstDefinition *GetDefinition(DeviceCode device_code) {
@ -71,7 +72,21 @@ namespace ams::clkrst {
return def; return def;
} }
ALWAYS_INLINE const ClkRstDefinition &GetDefinition(ClkRstSession *session) { ALWAYS_INLINE const ClkRstDefinition &GetDefinition(pcv::Module module) {
const ClkRstDefinition *def = nullptr;
for (const auto &entry : ClkRstDefinitionMap) {
if (entry.pcv_module == module) {
def = entry.definition;
break;
}
}
AMS_ABORT_UNLESS(def != nullptr);
return *def;
}
ALWAYS_INLINE const ClkRstDefinition &GetDefinition(clkrst::ClkRstSession *session) {
const ClkRstDefinition *def = nullptr; const ClkRstDefinition *def = nullptr;
for (const auto &entry : ClkRstDefinitionMap) { for (const auto &entry : ClkRstDefinitionMap) {
@ -85,8 +100,37 @@ namespace ams::clkrst {
return *def; return *def;
} }
void SetResetEnabled(const ClkRstDefinition &def, bool en) {
/* Set or clear reset. */
reg::ReadWrite(g_clkrst_registers + def.rst_ofs, (en ? 1u : 0u) << def.rst_index, 1u << def.rst_index);
} }
void SetClockEnabled(const ClkRstDefinition &def, bool en) {
/* Set or clear reset. */
reg::ReadWrite(g_clkrst_registers + def.clk_en_ofs, (en ? 1u : 0u) << def.clk_en_index, 1u << def.clk_en_index);
}
void SetClockRate(const ClkRstDefinition &def, u32 hz) {
/* Enable clock. */
reg::ReadWrite(g_clkrst_registers + def.clk_en_ofs, 1u << def.clk_en_index, 1u << def.clk_en_index);
/* Set the clock divisor. */
reg::ReadWrite(g_clkrst_registers + def.clk_src_ofs, CLK_RST_REG_BITS_VALUE(CLK_SOURCE_CLK_DIVISOR, def.clk_divisor));
/* Wait for 2us for clock setting to take. */
os::SleepThread(TimeSpan::FromMicroSeconds(2));
/* Set the clock source. */
reg::ReadWrite(g_clkrst_registers + def.clk_src_ofs, CLK_RST_REG_BITS_VALUE(CLK_SOURCE_CLK_SOURCE, def.clk_src));
/* Wait for 2us for clock setting to take. */
os::SleepThread(TimeSpan::FromMicroSeconds(2));
}
}
namespace clkrst {
void Initialize() { void Initialize() {
/* ... */ /* ... */
} }
@ -107,39 +151,18 @@ namespace ams::clkrst {
} }
void SetResetAsserted(ClkRstSession *session) { void SetResetAsserted(ClkRstSession *session) {
/* Get the definition. */
const auto &def = GetDefinition(session);
/* Assert reset. */ /* Assert reset. */
reg::ReadWrite(g_clkrst_registers + def.rst_ofs, 1u << def.rst_index, 1u << def.rst_index); SetResetEnabled(GetDefinition(session), true);
} }
void SetResetDeasserted(ClkRstSession *session) { void SetResetDeasserted(ClkRstSession *session) {
/* Get the definition. */ /* Assert reset. */
const auto &def = GetDefinition(session); SetResetEnabled(GetDefinition(session), false);
/* Clear reset. */
reg::ReadWrite(g_clkrst_registers + def.rst_ofs, 0, 1u << def.rst_index);
} }
void SetClockRate(ClkRstSession *session, u32 hz) { void SetClockRate(ClkRstSession *session, u32 hz) {
/* Get the definition. */ /* Set the clock rate. */
const auto &def = GetDefinition(session); SetClockRate(GetDefinition(session), hz);
/* Enable clock. */
reg::ReadWrite(g_clkrst_registers + def.clk_en_ofs, 1u << def.clk_en_index, 1u << def.clk_en_index);
/* Set the clock divisor. */
reg::ReadWrite(g_clkrst_registers + def.clk_src_ofs, CLK_RST_REG_BITS_VALUE(CLK_SOURCE_CLK_DIVISOR, def.clk_divisor));
/* Wait for 2us for clock setting to take. */
os::SleepThread(TimeSpan::FromMicroSeconds(2));
/* Set the clock source. */
reg::ReadWrite(g_clkrst_registers + def.clk_src_ofs, CLK_RST_REG_BITS_VALUE(CLK_SOURCE_CLK_SOURCE, def.clk_src));
/* Wait for 2us for clock setting to take. */
os::SleepThread(TimeSpan::FromMicroSeconds(2));
} }
void SetClockDisabled(ClkRstSession *session) { void SetClockDisabled(ClkRstSession *session) {
@ -147,3 +170,38 @@ namespace ams::clkrst {
} }
} }
namespace pcv {
void Initialize() {
/* ... */
}
void Finalize() {
/* ... */
}
Result SetClockEnabled(Module module, bool en) {
/* Set clock. */
SetClockEnabled(GetDefinition(module), en);
return ResultSuccess();
}
Result SetClockRate(Module module, ClockHz hz) {
/* Set the clock rate. */
SetClockRate(GetDefinition(module), hz);
return ResultSuccess();
}
Result SetReset(Module module, bool en) {
/* Set reset. */
SetResetEnabled(GetDefinition(module), en);
return ResultSuccess();
}
}
}

6
stratosphere/boot/source/boot_driver_management.cpp
View file

@ -40,13 +40,13 @@ namespace ams::boot {
i2c::driver::Initialize(); i2c::driver::Initialize();
/* Initialize the pwm client library with the server manager object. */ /* Initialize the pwm client library with the server manager object. */
/* TODO: pwm::InitializeWith(pwm::server::GetServiceObject()); */ pwm::InitializeWith(pwm::server::GetServiceObject());
/* Initialize the pwm board driver. */ /* Initialize the pwm board driver. */
/* TODO: pwm::driver::board::Initialize(); */ pwm::driver::board::Initialize();
/* Initialize the pwm driver library. */ /* Initialize the pwm driver library. */
/* TODO: pwm::driver::Initialize(); */ pwm::driver::Initialize();
} }
} }