MFEEdgeGpio.cpp

/*
** Copyright (C) 2025 CERN
**
** This software is provided 'as-is', without any express or implied
** warranty.  In no event will the authors be held liable for any damages
** arising from the use of this software.
**
** Permission is granted to anyone to use this software for any purpose,
** including commercial applications, and to alter it and redistribute it
** freely, subject to the following restrictions:
**
** 1. The origin of this software must not be misrepresented; you must not
**    claim that you wrote the original software. If you use this software
**    in a product, an acknowledgment in the product documentation would be
**    appreciated but is not required.
** 2. Altered source versions must be plainly marked as such, and must not be
**    misrepresented as being the original software.
** 3. This notice may not be removed or altered from any source distribution.
**
** Created on: 2025-04-17T19:10:16
** Author: Sylvain Fargier <sylvain.fargier@cern.ch>
*/
 
#include "MFEEdgeGpio.hpp"
 
#include <ccut/async.hpp>
#include <edge/edge.h>
 
#include "Exception.hpp"
#include "MFEPlatform.hpp"
 
using namespace smc;
using namespace smc::internal;
using ImmediateCmd = MGrblPlatform::ImmediateCmd;
using RegInfo = MFEPlatform::RegInfo;
 
MFEEdgeGpio::MFEEdgeGpio(const std::string &uid,
                         const std::shared_ptr<MFEPlatform> &mfe) :
    Gpio{uid},
    m_mfe{mfe}
{}
 
std::future<void> MFEEdgeGpio::setIoState(const units::io_port_t &state) const
{
    try
    {
        std::shared_ptr<MFEPlatform> mfe(m_mfe.lock());
        if (!mfe)
            throw Exception(ErrorCode::Canceled, "platform stopped (deleted)");
 
        const std::string uid{this->uid()};
        return mfe->run<void>([uid,
                               state](ImmediateCmd &cmd,
                                      const MGrblPlatform::Context &grblCtx) {
            const MFEPlatform::Context &ctx(
                static_cast<const MFEPlatform::Context &>(grblCtx));
            RegInfo info;
            if (!ctx.getRegInfo(uid, info))
                throw Exception(ErrorCode::Runtime, "invalid gpio uid: " + uid);
            else if (info.reg->reg_attr->rwmode == EDGE_MODE_RO ||
                     info.reg->reg_attr->rwmode == EDGE_MODE_RC)
                throw Exception(ErrorCode::InvalidArguments,
                                "Register is read-only");
            else if (!ctx.edge)
                throw Exception(ErrorCode::Runtime, "edge driver not available");
            uint32_t value = uint32_t(state.value);
            // when writing we need to mask and then shift
            if (info.mask)
                value &= info.mask;
            if (info.shift)
                value <<= info.shift;
            ctx.edge->write(info.reg, value);
            cmd.prom->get<void>().set_value();
        });
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error(ex);
    }
}
 
std::future<units::io_port_t> MFEEdgeGpio::getIoState() const
{
    try
    {
        std::shared_ptr<MFEPlatform> mfe(m_mfe.lock());
        if (!mfe)
            throw Exception(ErrorCode::Canceled, "platform stopped (deleted)");
 
        const std::string uid{this->uid()};
        return mfe->run<units::io_port_t>(
            [uid](ImmediateCmd &cmd, const MGrblPlatform::Context &grblCtx) {
                const MFEPlatform::Context &ctx(
                    static_cast<const MFEPlatform::Context &>(grblCtx));
                RegInfo info;
                if (!ctx.getRegInfo(uid, info))
                    throw Exception(ErrorCode::Runtime,
                                    "invalid gpio uid: " + uid);
                else if (!ctx.edge)
                    throw Exception(ErrorCode::Runtime,
                                    "edge driver not available");
                uint32_t value;
                ctx.edge->read(info.reg, value);
                if (info.shift)
                    value >>= info.shift;
                if (info.mask)
                    value &= info.mask;
 
                cmd.prom->get<units::io_port_t>().set_value(
                    units::io_port_t{value, info.size});
            });
    }
    catch (const Exception &ex)
    {
        return ccut::make_future_error<units::io_port_t>(ex);
    }
}