Logon.hxx

Go to the documentation of this file.

 
#ifndef _DCC_LOGON_HXX_
#define _DCC_LOGON_HXX_
 
#include "dcc/LogonFeedback.hxx"
#include "dcc/PacketSource.hxx"
#include "dcc/TrackIf.hxx"
#include "dcc/UpdateLoop.hxx"
#include "executor/StateFlow.hxx"
 
namespace dcc
{
 
class LogonHandlerModule
{
public:
    unsigned num_locos();
 
    bool is_valid_loco_id(unsigned loco_id);
 
    uint8_t &loco_flags(unsigned loco_id);
 
    uint64_t loco_did(unsigned loco_id);
 
    unsigned create_or_lookup_loco(uint64_t decoder_id);
 
    void run_address_policy(unsigned loco_id, uint16_t desired_address);
 
    uint16_t assigned_address(unsigned loco_id);
 
    void assign_complete(unsigned loco_id);
    
    enum Flags
    {
        FLAG_NEEDS_GET_SHORTINFO = 0x01,
        FLAG_PENDING_GET_SHORTINFO = 0x02,
 
        FLAG_NEEDS_ASSIGN = 0x04,
        FLAG_PENDING_ASSIGN = 0x08,
 
        FLAG_COMPLETE = 0x10,
        FLAG_ERROR_STATE = 0x20,
        FLAG_PENDING_RETRY = 0x40,
        FLAG_PENDING_TICK = 0x80,
    };
}; // LogonHandlerModule
 
template <class Module>
class LogonHandler : public StateFlowBase, private LogonFeedbackCallbacks
{
public:
    LogonHandler(
        Service *service, TrackIf *track, RailcomHubFlow *rcom_hub, Module *m)
        : StateFlowBase(service)
        , trackIf_(track)
        , module_(m)
        , fbParser_(this, rcom_hub)
        , hasLogonEnableConflict_(0)
        , hasLogonEnableFeedback_(0)
        , needShutdown_(0)
    {
    }
 
    void startup_logon(uint16_t cid, uint8_t session_id)
    {
        cid_ = cid;
        sessionId_ = session_id;
        start_flow(STATE(allocate_logon_now));
    }
 
#ifdef GTEST
    void shutdown()
    {
        needShutdown_ = 1;
        timer_.ensure_triggered();
        logonSelect_.ensure_triggered();
    }
#endif
 
    // Callbacks from LogonFeedback
 
    PacketType classify_packet(uintptr_t feedback_key) override
    {
        if (feedback_key >= 1 << 14)
        {
            LOG(INFO, "classify %x", (unsigned)feedback_key);
        }
        if (is_logon_enable_key(feedback_key))
        {
            return LOGON_ENABLE;
        }
        else if (is_select_shortinfo_key(feedback_key))
        {
            return SELECT_SHORTINFO;
        }
        else if (is_logon_assign_key(feedback_key))
        {
            return LOGON_ASSIGN;
        }
        return UNKNOWN;
    }
 
    void process_select_shortinfo(
        uintptr_t feedback_key, bool error, uint64_t data) override
    {
        if (!is_select_shortinfo_key(feedback_key))
        {
            LOG(WARNING, "Unexpected select shortinfo key: %08x",
                (unsigned)feedback_key);
            return;
        }
        unsigned loco_id = feedback_key & LOCO_ID_MASK;
        if (!module_->is_valid_loco_id(loco_id))
        {
            LOG(WARNING,
                "Unexpected select shortinfo key: %08x - invalid loco id",
                (unsigned)feedback_key);
            return;
        }
        uint8_t &flags = module_->loco_flags(loco_id);
        LOG(INFO, "Select shortinfo for loco ID %d, flags %02x error %d",
            loco_id, flags, error);
        flags &= ~LogonHandlerModule::FLAG_PENDING_GET_SHORTINFO;
        if (error)
        {
            if (flags & LogonHandlerModule::FLAG_PENDING_RETRY)
            {
                flags &= ~LogonHandlerModule::FLAG_PENDING_RETRY;
                flags |= LogonHandlerModule::FLAG_ERROR_STATE;
                return;
            }
            else
            {
                flags |= LogonHandlerModule::FLAG_NEEDS_GET_SHORTINFO |
                    LogonHandlerModule::FLAG_PENDING_RETRY;
                logonSelect_.wakeup();
                return;
            }
        }
        if (flags &
            (LogonHandlerModule::FLAG_NEEDS_ASSIGN |
                LogonHandlerModule::FLAG_PENDING_ASSIGN))
        {
            // Got multiple returns.
            return;
        }
        module_->run_address_policy(loco_id, (data >> 32) & 0x3FFF);
        flags |= LogonHandlerModule::FLAG_NEEDS_ASSIGN;
        logonSelect_.wakeup();
    }
 
    void process_logon_assign(
        uintptr_t feedback_key, bool error, uint64_t data) override
    {
        if (!is_logon_assign_key(feedback_key))
        {
            LOG(WARNING, "Unexpected logon assign key: %08x",
                (unsigned)feedback_key);
            return;
        }
        unsigned loco_id = feedback_key & LOCO_ID_MASK;
        if (!module_->is_valid_loco_id(loco_id))
        {
            LOG(WARNING, "Unexpected logon assign key: %08x - invalid loco id",
                (unsigned)feedback_key);
            return;
        }
        uint8_t &flags = module_->loco_flags(loco_id);
        flags &= ~LogonHandlerModule::FLAG_PENDING_ASSIGN;
        if (flags & LogonHandlerModule::FLAG_COMPLETE)
        {
            // duplicate responses.
            return;
        }
        if (error)
        {
            if (flags & LogonHandlerModule::FLAG_PENDING_RETRY)
            {
                flags &= ~LogonHandlerModule::FLAG_PENDING_RETRY;
                flags |= LogonHandlerModule::FLAG_ERROR_STATE;
                return;
            }
            else
            {
                flags |= LogonHandlerModule::FLAG_NEEDS_ASSIGN |
                    LogonHandlerModule::FLAG_PENDING_RETRY;
                logonSelect_.wakeup();
                return;
            }
        }
        module_->assign_complete(loco_id);
        flags &= ~LogonHandlerModule::FLAG_PENDING_TICK;
        LOG(INFO, "Assign completed for loco %d address %d", loco_id,
            module_->assigned_address(loco_id));
    }
 
    void process_decoder_id(
        uintptr_t feedback_key, bool error, uint64_t data) override
    {
        timer_.ensure_triggered();
        if (data)
        {
            hasLogonEnableFeedback_ = 1;
        } else {
            // No railcom feedback returned.
            return;
        }
        if (LOGLEVEL >= INFO)
        {
            unsigned didh = (data >> 32) & 0xfff;
            unsigned didl = data & 0xffffffffu;
            LOG(INFO, "Decoder id %03x%08x error %d", didh, didl, error);
        }
        if (error)
        {
            hasLogonEnableConflict_ = 1;
            return;
        }
        uint64_t did = data & DECODER_ID_MASK;
        auto lid = module_->create_or_lookup_loco(did);
        if (!module_->is_valid_loco_id(lid))
        {
            return;
        }
        auto &flags = module_->loco_flags(lid);
        flags |= LogonHandlerModule::FLAG_NEEDS_GET_SHORTINFO;
        logonSelect_.wakeup();
    }
 
private:
    Action allocate_logon_now()
    {
        return allocate_and_call(trackIf_, STATE(send_logon_now));
    }
 
    Action send_logon_now()
    {
        logon_send_helper(Defs::LogonEnableParam::NOW, 0);
        return wait_and_call(STATE(start_logon_wait));
    }
 
    Action start_logon_wait()
    {
        if (needShutdown_)
        {
            return exit();
        }
        auto next_time = lastLogonTime_ + MSEC_TO_NSEC(LOGON_PERIOD_MSEC);
        timer_.start_absolute(next_time);
        return wait_and_call(STATE(evaluate_logon));
    }
 
    Action evaluate_logon()
    {
        if (needShutdown_)
        {
            return exit();
        }
        if (timer_.is_triggered())
        {
            // found something via logon
            if (hasLogonEnableConflict_)
            {
                hasLogonEnableConflict_ = 0;
                hasLogonEnableFeedback_ = 0;
                return call_immediately(STATE(allocate_logon_many));
            }
            // Not sure why we were woken up, let's start a sleep again.
            return call_immediately(STATE(start_logon_wait));
        }
        else
        {
            // timer expired, send another logon.
            return call_immediately(STATE(allocate_logon_now));
        }
    }
 
    Action allocate_logon_many()
    {
        return allocate_and_call(trackIf_, STATE(send_logon_many));
    }
 
    Action send_logon_many()
    {
        logon_send_helper(Defs::LogonEnableParam::ALL, 3);
        return wait_and_call(STATE(many_logon_wait));
    }
 
    Action many_logon_wait()
    {
        if (countLogonToSend_ >= 4)
        {
            countLogonToSend_ -= 4;
            return call_immediately(STATE(allocate_logon_many));
        }
        else
        {
            countLogonToSend_ = 0;
            return call_immediately(STATE(start_logon_wait));
        }
    }
 
    void logon_send_helper(Defs::LogonEnableParam param, unsigned rept)
    {
        HASSERT(rept < 4u);
        auto *b = get_allocation_result(trackIf_);
        b->data()->set_dcc_logon_enable(param, cid_, sessionId_);
        b->data()->feedback_key = LOGON_ENABLE_KEY;
        b->data()->packet_header.rept_count = rept;
        b->set_done(bn_.reset(this));
 
        hasLogonEnableFeedback_ = 0;
        hasLogonEnableConflict_ = 0;
        lastLogonTime_ = os_get_time_monotonic();
 
        trackIf_->send(b);
    }
 
    class LogonSelect;
    friend class LogonSelect;
 
    class LogonSelect : public StateFlowBase, public ::Timer
    {
    public:
        LogonSelect(LogonHandler *parent)
            : StateFlowBase(parent->service())
            , ::Timer(parent->service()->executor()->active_timers())
            , parent_(parent)
        {
            start(MSEC_TO_NSEC(50));
        }
 
        void wakeup()
        {
            if (is_terminated())
            {
                cycleNextId_ = 0;
                start_flow(STATE(search));
            }
        }
 
        void tick()
        {
            bool need_wakeup = false;
            for (unsigned id = 0; id < m()->num_locos() && id < MAX_LOCO_ID;
                 ++id)
            {
                uint8_t &fl = m()->loco_flags(cycleNextId_);
                if (fl & LogonHandlerModule::FLAG_PENDING_TICK)
                {
                    fl &= ~LogonHandlerModule::FLAG_PENDING_TICK;
                }
                else if (fl & LogonHandlerModule::FLAG_PENDING_RETRY)
                {
                    fl &= ~LogonHandlerModule::FLAG_PENDING_RETRY;
                    fl |= LogonHandlerModule::FLAG_ERROR_STATE;
                }
                else if (fl & LogonHandlerModule::FLAG_ERROR_STATE)
                {
                    // re-tried every now and then. We would probably need an
                    // extra counter for this though somewhere.
                }
                else if (fl & LogonHandlerModule::FLAG_PENDING_GET_SHORTINFO)
                {
                    fl &= ~LogonHandlerModule::FLAG_PENDING_GET_SHORTINFO;
                    fl |= LogonHandlerModule::FLAG_NEEDS_GET_SHORTINFO |
                        LogonHandlerModule::FLAG_PENDING_RETRY;
                    need_wakeup = true;
                }
                else if (fl & LogonHandlerModule::FLAG_PENDING_ASSIGN)
                {
                    fl &= ~LogonHandlerModule::FLAG_PENDING_ASSIGN;
                    fl |= LogonHandlerModule::FLAG_NEEDS_ASSIGN |
                        LogonHandlerModule::FLAG_PENDING_RETRY;
                    need_wakeup = true;
                }
            }
            if (need_wakeup)
            {
                wakeup();
            }
        }
 
    private:
        long long timeout() override
        {
            if (parent_->needShutdown_)
            {
                return 0;
            }
            tick();
            return RESTART;
        }
 
        Module *m()
        {
            return parent_->module_;
        }
 
        TrackIf *track()
        {
            return parent_->trackIf_;
        }
 
        Action search()
        {
            if (parent_->needShutdown_)
            {
                return exit();
            }
            bool mid_cycle = (cycleNextId_ != 0);
            for (;
                 cycleNextId_ < m()->num_locos() && cycleNextId_ <= MAX_LOCO_ID;
                 ++cycleNextId_)
            {
                uint8_t fl = m()->loco_flags(cycleNextId_);
                if (fl & LogonHandlerModule::FLAG_NEEDS_GET_SHORTINFO)
                {
                    return allocate_and_call(
                        parent_->trackIf_, STATE(send_get_shortinfo));
                }
                if (fl & LogonHandlerModule::FLAG_NEEDS_ASSIGN)
                {
                    return allocate_and_call(
                        parent_->trackIf_, STATE(send_assign));
                }
            }
            cycleNextId_ = 0;
            // Check if we need to run the search for the first half of the
            // loco space too.
            if (mid_cycle)
            {
                return again();
            }
            return exit();
        }
 
        Action send_get_shortinfo()
        {
            auto *b = get_allocation_result(parent_->trackIf_);
            uint64_t did = m()->loco_did(cycleNextId_);
            b->data()->set_dcc_select_shortinfo(did);
            b->data()->feedback_key =
                SELECT_SHORTINFO_KEY | (cycleNextId_ & LOCO_ID_MASK);
            b->set_done(bn_.reset((StateFlowBase *)this));
            track()->send(b);
            uint8_t &fl = m()->loco_flags(cycleNextId_);
            fl &= ~LogonHandlerModule::FLAG_NEEDS_GET_SHORTINFO;
            fl |= LogonHandlerModule::FLAG_PENDING_GET_SHORTINFO |
                LogonHandlerModule::FLAG_PENDING_TICK;
            return wait_and_call(STATE(search));
        }
 
        Action send_assign()
        {
            auto *b = get_allocation_result(parent_->trackIf_);
            uint64_t did = m()->loco_did(cycleNextId_);
            b->data()->set_dcc_logon_assign(
                did, m()->assigned_address(cycleNextId_));
            b->data()->feedback_key =
                LOGON_ASSIGN_KEY | (cycleNextId_ & LOCO_ID_MASK);
            b->set_done(bn_.reset((StateFlowBase *)this));
            track()->send(b);
            uint8_t &fl = m()->loco_flags(cycleNextId_);
            fl &= ~LogonHandlerModule::FLAG_NEEDS_ASSIGN;
            fl |= LogonHandlerModule::FLAG_PENDING_ASSIGN |
                LogonHandlerModule::FLAG_PENDING_TICK;
            return wait_and_call(STATE(search));
        }
 
        LogonHandler *parent_;
 
        unsigned cycleNextId_;
 
        BarrierNotifiable bn_;
    } logonSelect_ {this};
 
    static constexpr uintptr_t LOGON_ENABLE_KEY =
        uint32_t((Defs::ADDRESS_LOGON << 24) | (Defs::DCC_LOGON_ENABLE << 16));
 
    static constexpr bool is_logon_enable_key(uintptr_t feedback_key)
    {
        return feedback_key == LOGON_ENABLE_KEY;
    }
 
    static constexpr uintptr_t SELECT_SHORTINFO_KEY =
        uint32_t((Defs::ADDRESS_LOGON << 24) | (Defs::DCC_SELECT << 16) |
            (Defs::CMD_READ_SHORT_INFO << 12));
 
    static constexpr bool is_select_shortinfo_key(uintptr_t feedback_key)
    {
        return ((feedback_key & ~LOCO_ID_MASK) == SELECT_SHORTINFO_KEY);
    }
 
    static constexpr uintptr_t LOGON_ASSIGN_KEY =
        uint32_t((Defs::ADDRESS_LOGON << 24) | (Defs::DCC_LOGON_ASSIGN << 16));
 
    static constexpr bool is_logon_assign_key(uintptr_t feedback_key)
    {
        return ((feedback_key & ~LOCO_ID_MASK) == LOGON_ASSIGN_KEY);
    }
 
    static constexpr unsigned LOGON_PERIOD_MSEC = 295;
 
    static constexpr unsigned MAX_LOCO_ID = 0xfff;
    static constexpr uintptr_t LOCO_ID_MASK = MAX_LOCO_ID;
 
    static constexpr uint64_t DECODER_ID_MASK = (1ull << 44) - 1;
 
    TrackIf *trackIf_;
 
    Module *module_;
 
    StateFlowTimer timer_ {this};
 
    LogonFeedbackParser fbParser_;
 
    BarrierNotifiable bn_;
 
    long long lastLogonTime_ {0};
 
    uint16_t cid_;
    uint8_t sessionId_;
 
    uint8_t hasLogonEnableConflict_ : 1;
    uint8_t hasLogonEnableFeedback_ : 1;
    uint8_t needShutdown_ : 1;
 
    uint8_t countLogonToSend_ {0};
 
}; // LogonHandler
 
} // namespace dcc
 
#endif // _DCC_LOGON_HXX_