i2c/gpio: hook up open session for sf interface

This commit is contained in:
Michael Scire 2020-10-31 21:50:21 -07:00 committed by SciresM
parent b74b309a77
commit 42caa4ffd1
15 changed files with 571 additions and 16 deletions

View file

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

View file

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

View file

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

View file

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

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

View file

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

View file

@ -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) {

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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