mirror of
https://github.com/Atmosphere-NX/Atmosphere
synced 2024-12-22 20:31:14 +00:00
i2c/gpio: hook up open session for sf interface
This commit is contained in:
Michael Scire
parent
f27d6f2fd8
commit
48784da42a
15 changed files with 571 additions and 16 deletions
|
|
@ -31,7 +31,7 @@ namespace ams::gpio::driver {
|
|||
util::TypedStorage<impl::GpioPadSessionImplPadded, impl::GpioPadSessionSize, impl::GpioPadSessionAlign> _impl;
|
||||
};
|
||||
|
||||
Result OpenSession(GpioPadSession *out, DeviceCode device_code);
|
||||
Result OpenSession(GpioPadSession *out, DeviceCode device_code, ddsf::AccessMode access_mode);
|
||||
void CloseSession(GpioPadSession *session);
|
||||
|
||||
Result SetDirection(GpioPadSession *session, gpio::Direction direction);
|
||||
|
|
|
|||
|
|
@ -23,4 +23,7 @@
|
|||
#include <stratosphere/i2c/driver/i2c_select_driver_api.hpp>
|
||||
#include <stratosphere/i2c/driver/i2c_driver_service_api.hpp>
|
||||
#include <stratosphere/i2c/driver/i2c_driver_client_api.hpp>
|
||||
#include <stratosphere/i2c/driver/i2c_bus_api.hpp>
|
||||
#include <stratosphere/i2c/driver/impl/i2c_i2c_session_impl.hpp>
|
||||
#include <stratosphere/i2c/i2c_api.hpp>
|
||||
#include <stratosphere/i2c/i2c_bus_api.hpp>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,45 @@
|
|||
/*
|
||||
* 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/i2c/i2c_types.hpp>
|
||||
|
||||
namespace ams::i2c::driver {
|
||||
|
||||
namespace impl {
|
||||
|
||||
constexpr inline size_t I2cSessionSize = 0x60;
|
||||
constexpr inline size_t I2cSessionAlign = 8;
|
||||
struct alignas(I2cSessionAlign) I2cSessionImplPadded;
|
||||
|
||||
}
|
||||
|
||||
struct I2cSession {
|
||||
util::TypedStorage<impl::I2cSessionImplPadded, impl::I2cSessionSize, impl::I2cSessionAlign> _impl;
|
||||
};
|
||||
|
||||
Result OpenSession(I2cSession *out, DeviceCode device_code);
|
||||
void CloseSession(I2cSession &session);
|
||||
|
||||
Result Send(I2cSession &session, const void *src, size_t src_size, TransactionOption option);
|
||||
Result Receive(void *dst, size_t dst_size, I2cSession &session, TransactionOption option);
|
||||
|
||||
Result ExecuteCommandList(void *dst, size_t dst_size, I2cSession &session, const void *src, size_t src_size);
|
||||
|
||||
Result SetRetryPolicy(I2cSession &session, int max_retry_count, int retry_interval_ms);
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
/*
|
||||
* 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/i2c/driver/i2c_bus_api.hpp>
|
||||
#include <stratosphere/ddsf.hpp>
|
||||
|
||||
namespace ams::i2c::driver {
|
||||
|
||||
class I2cDeviceProperty;
|
||||
|
||||
}
|
||||
|
||||
namespace ams::i2c::driver::impl {
|
||||
|
||||
class I2cSessionImpl : public ::ams::ddsf::ISession {
|
||||
NON_COPYABLE(I2cSessionImpl);
|
||||
NON_MOVEABLE(I2cSessionImpl);
|
||||
AMS_DDSF_CASTABLE_TRAITS(ams::i2c::driver::impl::I2cSessionImpl, ::ams::ddsf::ISession);
|
||||
private:
|
||||
enum class Command {
|
||||
Send = 0,
|
||||
Receive = 1,
|
||||
};
|
||||
private:
|
||||
TimeSpan retry_interval;
|
||||
int max_retry_count;
|
||||
private:
|
||||
Result SendHandler(const u8 **cur_cmd, u8 **cur_dst);
|
||||
Result ReceiveHandler(const u8 **cur_cmd, u8 **cur_dst);
|
||||
Result ExtensionHandler(const u8 **cur_cmd, u8 **cur_dst);
|
||||
|
||||
Result ExecuteTransactionWithRetry(void *dst, Command command, const void *src, size_t size, TransactionOption option);
|
||||
public:
|
||||
I2cSessionImpl(int mr, TimeSpan rt) : retry_interval(rt), max_retry_count(mr) { /* ... */ }
|
||||
|
||||
~I2cSessionImpl() {
|
||||
this->Close();
|
||||
}
|
||||
|
||||
Result Open(I2cDeviceProperty *device, ddsf::AccessMode access_mode);
|
||||
void Close();
|
||||
|
||||
Result Send(const void *src, size_t src_size, TransactionOption option);
|
||||
Result Receive(void *dst, size_t dst_size, TransactionOption option);
|
||||
Result ExecuteCommandList(void *dst, size_t dst_size, const void *src, size_t src_size);
|
||||
Result SetRetryPolicy(int mr, int interval_ms);
|
||||
};
|
||||
static_assert( sizeof(I2cSessionImpl) <= I2cSessionSize);
|
||||
static_assert(alignof(I2cSessionImpl) <= I2cSessionAlign);
|
||||
|
||||
struct alignas(I2cSessionAlign) I2cSessionImplPadded {
|
||||
I2cSessionImpl _impl;
|
||||
u8 _padding[I2cSessionSize - sizeof(I2cSessionImpl)];
|
||||
};
|
||||
static_assert( sizeof(I2cSessionImplPadded) == I2cSessionSize);
|
||||
static_assert(alignof(I2cSessionImplPadded) == I2cSessionAlign);
|
||||
|
||||
ALWAYS_INLINE I2cSessionImpl &GetI2cSessionImpl(I2cSession &session) {
|
||||
return GetReference(session._impl)._impl;
|
||||
}
|
||||
|
||||
ALWAYS_INLINE const I2cSessionImpl &GetI2cSessionImpl(const I2cSession &session) {
|
||||
return GetReference(session._impl)._impl;
|
||||
}
|
||||
|
||||
ALWAYS_INLINE I2cSessionImpl &GetOpenI2cSessionImpl(I2cSession &session) {
|
||||
auto &ref = GetReference(session._impl)._impl;
|
||||
AMS_ASSERT(ref.IsOpen());
|
||||
return ref;
|
||||
}
|
||||
|
||||
ALWAYS_INLINE const I2cSessionImpl &GetOpenI2cSessionImpl(const I2cSession &session) {
|
||||
const auto &ref = GetReference(session._impl)._impl;
|
||||
AMS_ASSERT(ref.IsOpen());
|
||||
return ref;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -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/i2c/i2c_types.hpp>
|
||||
|
||||
namespace ams::i2c {
|
||||
|
||||
struct I2cSession {
|
||||
void *_session;
|
||||
};
|
||||
|
||||
Result OpenSession(I2cSession *out, DeviceCode device_code);
|
||||
void CloseSession(I2cSession &session);
|
||||
|
||||
Result Send(const I2cSession &session, const void *src, size_t src_size, TransactionOption option);
|
||||
Result Receive(void *dst, size_t dst_size, const I2cSession &session, TransactionOption option);
|
||||
|
||||
Result ExecuteCommandList(void *dst, size_t dst_size, const I2cSession &session, const void *src, size_t src_size);
|
||||
|
||||
void SetRetryPolicy(const I2cSession &session, int max_retry_count, int retry_interval_ms);
|
||||
|
||||
}
|
||||
|
|
@ -194,4 +194,57 @@ namespace ams::i2c {
|
|||
}
|
||||
}
|
||||
|
||||
constexpr inline I2cDevice ConvertToI2cDevice(DeviceCode dc) {
|
||||
switch (dc.GetInternalValue()) {
|
||||
case DeviceCode_ClassicController.GetInternalValue(): return I2cDevice_ClassicController;
|
||||
case DeviceCode_Ftm3bd56 .GetInternalValue(): return I2cDevice_Ftm3bd56;
|
||||
case DeviceCode_Tmp451 .GetInternalValue(): return I2cDevice_Tmp451;
|
||||
/* case DeviceCode_Nct72 .GetInternalValue(): return I2cDevice_Nct72; */
|
||||
case DeviceCode_Alc5639 .GetInternalValue(): return I2cDevice_Alc5639;
|
||||
case DeviceCode_Max77620Rtc .GetInternalValue(): return I2cDevice_Max77620Rtc;
|
||||
case DeviceCode_Max77620Pmic .GetInternalValue(): return I2cDevice_Max77620Pmic;
|
||||
case DeviceCode_Max77621Cpu .GetInternalValue(): return I2cDevice_Max77621Cpu;
|
||||
case DeviceCode_Max77621Gpu .GetInternalValue(): return I2cDevice_Max77621Gpu;
|
||||
case DeviceCode_Bq24193 .GetInternalValue(): return I2cDevice_Bq24193;
|
||||
case DeviceCode_Max17050 .GetInternalValue(): return I2cDevice_Max17050;
|
||||
case DeviceCode_Bm92t30mwv .GetInternalValue(): return I2cDevice_Bm92t30mwv;
|
||||
case DeviceCode_Ina226Vdd15v0Hb .GetInternalValue(): return I2cDevice_Ina226Vdd15v0Hb;
|
||||
case DeviceCode_Ina226VsysCpuDs .GetInternalValue(): return I2cDevice_Ina226VsysCpuDs;
|
||||
case DeviceCode_Ina226VsysGpuDs .GetInternalValue(): return I2cDevice_Ina226VsysGpuDs;
|
||||
case DeviceCode_Ina226VsysDdrDs .GetInternalValue(): return I2cDevice_Ina226VsysDdrDs;
|
||||
case DeviceCode_Ina226VsysAp .GetInternalValue(): return I2cDevice_Ina226VsysAp;
|
||||
case DeviceCode_Ina226VsysBlDs .GetInternalValue(): return I2cDevice_Ina226VsysBlDs;
|
||||
case DeviceCode_Bh1730 .GetInternalValue(): return I2cDevice_Bh1730;
|
||||
case DeviceCode_Ina226VsysCore .GetInternalValue(): return I2cDevice_Ina226VsysCore;
|
||||
case DeviceCode_Ina226Soc1V8 .GetInternalValue(): return I2cDevice_Ina226Soc1V8;
|
||||
case DeviceCode_Ina226Lpddr1V8 .GetInternalValue(): return I2cDevice_Ina226Lpddr1V8;
|
||||
case DeviceCode_Ina226Reg1V32 .GetInternalValue(): return I2cDevice_Ina226Reg1V32;
|
||||
case DeviceCode_Ina226Vdd3V3Sys .GetInternalValue(): return I2cDevice_Ina226Vdd3V3Sys;
|
||||
case DeviceCode_HdmiDdc .GetInternalValue(): return I2cDevice_HdmiDdc;
|
||||
case DeviceCode_HdmiScdc .GetInternalValue(): return I2cDevice_HdmiScdc;
|
||||
case DeviceCode_HdmiHdcp .GetInternalValue(): return I2cDevice_HdmiHdcp;
|
||||
case DeviceCode_Fan53528 .GetInternalValue(): return I2cDevice_Fan53528;
|
||||
case DeviceCode_Max77812_3 .GetInternalValue(): return I2cDevice_Max77812_3;
|
||||
case DeviceCode_Max77812_2 .GetInternalValue(): return I2cDevice_Max77812_2;
|
||||
case DeviceCode_Ina226VddDdr0V6 .GetInternalValue(): return I2cDevice_Ina226VddDdr0V6;
|
||||
case DeviceCode_HoagNfcIc .GetInternalValue(): return I2cDevice_HoagNfcIc;
|
||||
AMS_UNREACHABLE_DEFAULT_CASE();
|
||||
}
|
||||
}
|
||||
|
||||
constexpr bool IsPowerBusDeviceCode(DeviceCode device_code) {
|
||||
switch (device_code.GetInternalValue()) {
|
||||
case DeviceCode_Max77620Pmic.GetInternalValue():
|
||||
case DeviceCode_Max77812_3 .GetInternalValue():
|
||||
case DeviceCode_Max77621Cpu .GetInternalValue():
|
||||
case DeviceCode_Max77621Gpu .GetInternalValue():
|
||||
case DeviceCode_Fan53528 .GetInternalValue():
|
||||
case DeviceCode_Max77812_2 .GetInternalValue():
|
||||
case DeviceCode_Max77620Rtc .GetInternalValue():
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -62,34 +62,45 @@ namespace ams::sf {
|
|||
return std::make_shared<typename Interface::ImplSharedPointer<Impl>>(std::make_shared<Impl>(std::forward<Arguments>(args)...));
|
||||
}
|
||||
|
||||
template<typename Interface, typename Impl>
|
||||
class ServiceObjectAllocator {
|
||||
template<typename T>
|
||||
class ServiceObjectAllocatorImpl {
|
||||
private:
|
||||
template<typename>
|
||||
friend class ServiceObjectAllocatorImpl;
|
||||
public:
|
||||
using value_type = typename Interface::ImplHolder<Impl>;
|
||||
using value_type = T;
|
||||
private:
|
||||
MemoryResource * const memory_resource;
|
||||
public:
|
||||
constexpr ServiceObjectAllocator(MemoryResource *mr) : memory_resource(mr) { /* ... */ }
|
||||
constexpr ServiceObjectAllocatorImpl(MemoryResource *mr) : memory_resource(mr) { /* ... */ }
|
||||
|
||||
template<typename U>
|
||||
constexpr ServiceObjectAllocatorImpl(const ServiceObjectAllocatorImpl<U> &rhs) : memory_resource(rhs.memory_resource) { /* ... */ }
|
||||
|
||||
value_type *allocate(size_t n) const {
|
||||
void *mem = this->memory_resource->Allocate(n * sizeof(value_type), alignof(value_type));
|
||||
AMS_ABORT_UNLESS(mem != nullptr);
|
||||
return mem;
|
||||
return static_cast<value_type *>(mem);
|
||||
}
|
||||
|
||||
void deallocate(void *p, size_t n) const {
|
||||
this->memory_resource->Deallocate(p, n * sizeof(value_type), alignof(value_type));
|
||||
}
|
||||
|
||||
inline bool operator==(const ServiceObjectAllocator &rhs) const {
|
||||
template<typename U>
|
||||
inline bool operator==(const ServiceObjectAllocatorImpl<U> &rhs) const {
|
||||
return this->memory_resource->is_equal(*rhs->memory_resource);
|
||||
}
|
||||
|
||||
inline bool operator!=(const ServiceObjectAllocator &rhs) const {
|
||||
template<typename U>
|
||||
inline bool operator!=(const ServiceObjectAllocatorImpl<U> &rhs) const {
|
||||
return !(*this == rhs);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Interface, typename Impl>
|
||||
using ServiceObjectAllocator = ServiceObjectAllocatorImpl<typename Interface::ImplHolder<Impl>>;
|
||||
|
||||
template<typename Interface, typename Impl, typename Allocator, typename... Arguments>
|
||||
requires std::constructible_from<Impl, Arguments...>
|
||||
constexpr ALWAYS_INLINE std::shared_ptr<typename Interface::ImplHolder<Impl>> AllocateShared(const Allocator &allocator, Arguments &&... args) {
|
||||
|
|
|
|||
|
|
@ -33,8 +33,7 @@ namespace ams::gpio::server {
|
|||
}
|
||||
|
||||
Result ManagerImpl::OpenSession(ams::sf::Out<std::shared_ptr<gpio::sf::IPadSession>> out, gpio::GpioPadName pad_name) {
|
||||
/* TODO */
|
||||
AMS_ABORT();
|
||||
return this->OpenSession2(out, ConvertToDeviceCode(pad_name), ddsf::AccessMode_ReadWrite);
|
||||
}
|
||||
|
||||
Result ManagerImpl::OpenSessionForTest(ams::sf::Out<std::shared_ptr<gpio::sf::IPadSession>> out, gpio::GpioPadName pad_name) {
|
||||
|
|
@ -63,8 +62,15 @@ namespace ams::gpio::server {
|
|||
}
|
||||
|
||||
Result ManagerImpl::OpenSession2(ams::sf::Out<std::shared_ptr<gpio::sf::IPadSession>> out, DeviceCode device_code, ddsf::AccessMode access_mode) {
|
||||
/* TODO */
|
||||
AMS_ABORT();
|
||||
/* Allocate a session. */
|
||||
auto session = ams::sf::AllocateShared<gpio::sf::IPadSession, PadSessionImpl>(this->pad_allocator, this);
|
||||
|
||||
/* Open the session. */
|
||||
R_TRY(session->GetImpl().OpenSession(device_code, access_mode));
|
||||
|
||||
/* We succeeded. */
|
||||
out.SetValue(std::move(session));
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result ManagerImpl::IsWakeEventActive2(ams::sf::Out<bool> out, DeviceCode device_code) {
|
||||
|
|
@ -82,5 +88,4 @@ namespace ams::gpio::server {
|
|||
AMS_ABORT();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,10 +35,10 @@ namespace ams::gpio::server {
|
|||
}
|
||||
}
|
||||
|
||||
Result OpenSession(DeviceCode device_code) {
|
||||
Result OpenSession(DeviceCode device_code, ddsf::AccessMode access_mode) {
|
||||
AMS_ABORT_UNLESS(!this->has_session);
|
||||
|
||||
R_TRY(gpio::driver::OpenSession(std::addressof(this->internal_pad_session), device_code));
|
||||
R_TRY(gpio::driver::OpenSession(std::addressof(this->internal_pad_session), device_code, access_mode));
|
||||
this->has_session = true;
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,6 +30,21 @@ namespace ams::i2c {
|
|||
std::shared_ptr<sf::IManager> g_i2c_pcv_manager;
|
||||
constinit int g_i2c_pcv_count = 0;
|
||||
|
||||
using InternalSession = std::shared_ptr<i2c::sf::ISession>;
|
||||
|
||||
InternalSession &GetInterface(const I2cSession &session) {
|
||||
AMS_ASSERT(session._session != nullptr);
|
||||
return *static_cast<InternalSession *>(session._session);
|
||||
}
|
||||
|
||||
std::shared_ptr<sf::IManager> GetManager(DeviceCode device_code) {
|
||||
if (IsPowerBusDeviceCode(device_code)) {
|
||||
return g_i2c_pcv_manager;
|
||||
} else {
|
||||
return g_i2c_manager;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void InitializeWith(std::shared_ptr<i2c::sf::IManager> &&sp, std::shared_ptr<i2c::sf::IManager> &&sp_pcv) {
|
||||
|
|
@ -83,4 +98,64 @@ namespace ams::i2c {
|
|||
}
|
||||
}
|
||||
|
||||
Result OpenSession(I2cSession *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 manager for the device. */
|
||||
auto manager = GetManager(device_code);
|
||||
|
||||
/* Get the session. */
|
||||
{
|
||||
ams::sf::cmif::ServiceObjectHolder object_holder;
|
||||
if (hos::GetVersion() >= hos::Version_6_0_0) {
|
||||
R_TRY(manager->OpenSession2(std::addressof(object_holder), device_code));
|
||||
} else {
|
||||
R_TRY(manager->OpenSession(std::addressof(object_holder), ConvertToI2cDevice(device_code)));
|
||||
}
|
||||
*internal_session = object_holder.GetServiceObject<sf::ISession>();
|
||||
}
|
||||
|
||||
/* Set output. */
|
||||
out->_session = internal_session;
|
||||
|
||||
/* We succeeded. */
|
||||
session_guard.Cancel();
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
void CloseSession(I2cSession &session) {
|
||||
/* Close the session. */
|
||||
delete std::addressof(GetInterface(session));
|
||||
session._session = nullptr;
|
||||
}
|
||||
|
||||
Result Send(const I2cSession &session, const void *src, size_t src_size, TransactionOption option) {
|
||||
const ams::sf::InAutoSelectBuffer buf(src, src_size);
|
||||
|
||||
return GetInterface(session)->Send(buf, option);
|
||||
}
|
||||
|
||||
Result Receive(void *dst, size_t dst_size, const I2cSession &session, TransactionOption option) {
|
||||
const ams::sf::OutAutoSelectBuffer buf(dst, dst_size);
|
||||
|
||||
return GetInterface(session)->Receive(buf, option);
|
||||
}
|
||||
|
||||
Result ExecuteCommandList(void *dst, size_t dst_size, const I2cSession &session, const void *src, size_t src_size) {
|
||||
const ams::sf::OutAutoSelectBuffer buf(dst, dst_size);
|
||||
const ams::sf::InPointerArray<i2c::I2cCommand> arr(static_cast<const i2c::I2cCommand *>(src), src_size);
|
||||
|
||||
return GetInterface(session)->ExecuteCommandList(buf, arr);
|
||||
}
|
||||
|
||||
void SetRetryPolicy(const I2cSession &session, int max_retry_count, int retry_interval_ms) {
|
||||
AMS_ASSERT(max_retry_count >= 0);
|
||||
AMS_ASSERT(retry_interval_ms >= 0);
|
||||
|
||||
R_ABORT_UNLESS(GetInterface(session)->SetRetryPolicy(max_retry_count, retry_interval_ms));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,46 @@
|
|||
/*
|
||||
* 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 "i2c_server_manager_impl.hpp"
|
||||
|
||||
namespace ams::i2c::server {
|
||||
|
||||
namespace {
|
||||
|
||||
ManagerImpl g_manager_impl;
|
||||
ManagerImpl g_pcv_manager_impl;
|
||||
|
||||
std::shared_ptr<i2c::sf::IManager> GetManagerServiceObject() {
|
||||
static std::shared_ptr<i2c::sf::IManager> s_sp = ams::sf::GetSharedPointerTo<i2c::sf::IManager>(g_manager_impl);
|
||||
return s_sp;
|
||||
}
|
||||
|
||||
std::shared_ptr<i2c::sf::IManager> GetManagerServiceObjectPowerBus() {
|
||||
static std::shared_ptr<i2c::sf::IManager> s_sp = ams::sf::GetSharedPointerTo<i2c::sf::IManager>(g_pcv_manager_impl);
|
||||
return s_sp;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
std::shared_ptr<i2c::sf::IManager> GetServiceObject() {
|
||||
return GetManagerServiceObject();
|
||||
}
|
||||
|
||||
std::shared_ptr<i2c::sf::IManager> GetServiceObjectPowerBus() {
|
||||
return GetManagerServiceObjectPowerBus();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
/*
|
||||
* 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 "i2c_server_manager_impl.hpp"
|
||||
|
||||
namespace ams::i2c::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<i2c::sf::ISession>> out, s32 bus_idx, u16 slave_address, i2c::AddressingMode addressing_mode, i2c::SpeedMode speed_mode) {
|
||||
/* TODO */
|
||||
AMS_ABORT();
|
||||
}
|
||||
|
||||
Result ManagerImpl::OpenSession(ams::sf::Out<std::shared_ptr<i2c::sf::ISession>> out, i2c::I2cDevice device) {
|
||||
return this->OpenSession2(out, ConvertToDeviceCode(device));
|
||||
}
|
||||
|
||||
Result ManagerImpl::HasDevice(ams::sf::Out<bool> out, i2c::I2cDevice device) {
|
||||
/* TODO */
|
||||
AMS_ABORT();
|
||||
}
|
||||
|
||||
Result ManagerImpl::HasDeviceForDev(ams::sf::Out<bool> out, i2c::I2cDevice device) {
|
||||
/* TODO */
|
||||
AMS_ABORT();
|
||||
}
|
||||
|
||||
Result ManagerImpl::OpenSession2(ams::sf::Out<std::shared_ptr<i2c::sf::ISession>> out, DeviceCode device_code) {
|
||||
/* Allocate a session. */
|
||||
auto session = ams::sf::AllocateShared<i2c::sf::ISession, SessionImpl>(this->allocator, this);
|
||||
|
||||
/* Open the session. */
|
||||
R_TRY(session->GetImpl().OpenSession(device_code));
|
||||
|
||||
/* We succeeded. */
|
||||
out.SetValue(std::move(session));
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
/*
|
||||
* 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 "i2c_server_session_impl.hpp"
|
||||
|
||||
namespace ams::i2c::server {
|
||||
|
||||
class ManagerImpl {
|
||||
private:
|
||||
lmem::HeapHandle heap_handle;
|
||||
ams::sf::ExpHeapMemoryResource session_memory_resource;
|
||||
typename ams::sf::ServiceObjectAllocator<i2c::sf::ISession, SessionImpl> allocator;
|
||||
u8 heap_buffer[4_KB];
|
||||
public:
|
||||
ManagerImpl();
|
||||
|
||||
~ManagerImpl();
|
||||
public:
|
||||
/* Actual commands. */
|
||||
Result OpenSessionForDev(ams::sf::Out<std::shared_ptr<i2c::sf::ISession>> out, s32 bus_idx, u16 slave_address, i2c::AddressingMode addressing_mode, i2c::SpeedMode speed_mode);
|
||||
Result OpenSession(ams::sf::Out<std::shared_ptr<i2c::sf::ISession>> out, i2c::I2cDevice device);
|
||||
Result HasDevice(ams::sf::Out<bool> out, i2c::I2cDevice device);
|
||||
Result HasDeviceForDev(ams::sf::Out<bool> out, i2c::I2cDevice device);
|
||||
Result OpenSession2(ams::sf::Out<std::shared_ptr<i2c::sf::ISession>> out, DeviceCode device_code);
|
||||
};
|
||||
static_assert(i2c::sf::IsIManager<ManagerImpl>);
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
/*
|
||||
* 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::i2c::server {
|
||||
|
||||
class ManagerImpl;
|
||||
|
||||
class SessionImpl {
|
||||
private:
|
||||
ManagerImpl *parent; /* NOTE: this is an sf::SharedPointer<> in Nintendo's code. */
|
||||
i2c::driver::I2cSession internal_session;
|
||||
bool has_session;
|
||||
public:
|
||||
explicit SessionImpl(ManagerImpl *p) : parent(p), has_session(false) { /* ... */ }
|
||||
|
||||
~SessionImpl() {
|
||||
if (this->has_session) {
|
||||
i2c::driver::CloseSession(this->internal_session);
|
||||
}
|
||||
}
|
||||
|
||||
Result OpenSession(DeviceCode device_code) {
|
||||
AMS_ABORT_UNLESS(!this->has_session);
|
||||
|
||||
R_TRY(i2c::driver::OpenSession(std::addressof(this->internal_session), device_code));
|
||||
this->has_session = true;
|
||||
return ResultSuccess();
|
||||
}
|
||||
public:
|
||||
/* Actual commands. */
|
||||
Result SendOld(const ams::sf::InBuffer &in_data, i2c::TransactionOption option) {
|
||||
return i2c::driver::Send(this->internal_session, in_data.GetPointer(), in_data.GetSize(), option);
|
||||
}
|
||||
|
||||
Result ReceiveOld(const ams::sf::OutBuffer &out_data, i2c::TransactionOption option) {
|
||||
return i2c::driver::Receive(out_data.GetPointer(), out_data.GetSize(), this->internal_session, option);
|
||||
}
|
||||
|
||||
Result ExecuteCommandListOld(const ams::sf::OutBuffer &rcv_buf, const ams::sf::InPointerArray<i2c::I2cCommand> &command_list){
|
||||
return i2c::driver::ExecuteCommandList(rcv_buf.GetPointer(), rcv_buf.GetSize(), this->internal_session, command_list.GetPointer(), command_list.GetSize() * sizeof(i2c::I2cCommand));
|
||||
}
|
||||
|
||||
Result Send(const ams::sf::InAutoSelectBuffer &in_data, i2c::TransactionOption option) {
|
||||
return i2c::driver::Send(this->internal_session, in_data.GetPointer(), in_data.GetSize(), option);
|
||||
}
|
||||
|
||||
Result Receive(const ams::sf::OutAutoSelectBuffer &out_data, i2c::TransactionOption option) {
|
||||
return i2c::driver::Receive(out_data.GetPointer(), out_data.GetSize(), this->internal_session, option);
|
||||
}
|
||||
|
||||
Result ExecuteCommandList(const ams::sf::OutAutoSelectBuffer &rcv_buf, const ams::sf::InPointerArray<i2c::I2cCommand> &command_list) {
|
||||
return i2c::driver::ExecuteCommandList(rcv_buf.GetPointer(), rcv_buf.GetSize(), this->internal_session, command_list.GetPointer(), command_list.GetSize() * sizeof(i2c::I2cCommand));
|
||||
}
|
||||
|
||||
Result SetRetryPolicy(s32 max_retry_count, s32 retry_interval_ms) {
|
||||
return i2c::driver::SetRetryPolicy(this->internal_session, max_retry_count, retry_interval_ms);
|
||||
}
|
||||
};
|
||||
static_assert(i2c::sf::IsISession<SessionImpl>);
|
||||
|
||||
}
|
||||
|
|
@ -33,11 +33,20 @@ namespace ams::boot {
|
|||
/* Initialize the i2c client library with the server manager object. */
|
||||
i2c::InitializeWith(i2c::server::GetServiceObject(), i2c::server::GetServiceObjectPowerBus());
|
||||
|
||||
/* Initialize the board driver without enabling interrupt handlers. */
|
||||
/* Initialize the board driver. */
|
||||
i2c::driver::board::Initialize();
|
||||
|
||||
/* Initialize the driver library. */
|
||||
i2c::driver::Initialize();
|
||||
|
||||
/* Initialize the pwm client library with the server manager object. */
|
||||
/* TODO: pwm::InitializeWith(pwm::server::GetServiceObject()); */
|
||||
|
||||
/* Initialize the pwm board driver. */
|
||||
/* TODO: pwm::driver::board::Initialize(); */
|
||||
|
||||
/* Initialize the pwm driver library. */
|
||||
/* TODO: pwm::driver::Initialize();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue