switch_cfg.h

Go to the documentation of this file.

// Copyright 2021-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/cfgbus_core.h>
#include <satcat5/ethernet.h>
 
namespace satcat5 {
    namespace eth {
        constexpr u32 VTAG_ADMIT_ALL    = 0x00000000u;
        constexpr u32 VTAG_RESTRICT     = 0x00010000u;
        constexpr u32 VTAG_PRIORITY     = 0x00110000u;
        constexpr u32 VTAG_MANDATORY    = 0x00220000u;
 
        constexpr u32 VPOL_UNLIMITED    = 0x80000000u;
        constexpr u32 VPOL_DEMOTE       = 0x90000000u;
        constexpr u32 VPOL_STRICT       = 0xA0000000u;
        constexpr u32 VPOL_AUTO         = 0xB0000000u;
 
        // Define unit scaling for VLAN rate-limiter configuration.
        constexpr u32 VRATE_SCALE_1X    = 0x00000000u;  // 1 LSB = 8 kbps
        constexpr u32 VRATE_SCALE_256X  = 0x08000000u;  // 1 LSB = 2 Mbps
        constexpr u64 VRATE_THRESHOLD   = 100000000;
 
        constexpr u32 VLAN_CONNECT_ALL  = (u32)(-1);
        constexpr u32 VLAN_CONNECT_NONE = 0;
 
        struct VtagPolicy {
            u32 value;
 
            inline u32 policy() const
                { return u32(value & 0x00FF0000); }
            inline unsigned port() const
                { return unsigned(value >> 24); }
            inline satcat5::eth::VlanTag vtag() const
                { return VlanTag{u16(value & 0x0000FFFF)}; }
 
            constexpr VtagPolicy(u32 port, u32 policy, VlanTag vtag = VTAG_DEFAULT)
                : value(policy | vtag.value | ((port & 0xFF) << 24)) {}
            constexpr VtagPolicy()
                : value(0) {}
            explicit constexpr VtagPolicy(u32 other)
                : value(other) {}
            constexpr VtagPolicy(const VtagPolicy& other)
                : value(other.value) {}
            VtagPolicy& operator=(const VtagPolicy& other)
                { value = other.value; return *this; }
        };
 
        constexpr satcat5::eth::VtagPolicy
            VCFG_DEFAULT(0, VTAG_ADMIT_ALL, VTAG_DEFAULT);
 
        struct VlanRate {
            u32 tok_policy;             
            u32 tok_rate;               
            u32 tok_max;                
 
            static constexpr u32 bps2rate(u64 rate_bps) {
                return (rate_bps < VRATE_THRESHOLD)
                    ? u32(rate_bps / 8000)
                    : u32(rate_bps / 2000000);
            }
 
            constexpr VlanRate()        // Default constructor
                : tok_policy(VPOL_UNLIMITED)
                , tok_rate(0)
                , tok_max(0) {}
            constexpr VlanRate(
                u32 policy,             // Policy (e.g., VPOL_STRICT)
                u64 rate_bps,           // Rate limit (bits per second)
                u32 burst_msec=1)       // Burst duration in milliseconds
                : tok_policy(
                    rate_bps < VRATE_THRESHOLD
                    ? (policy | VRATE_SCALE_1X)
                    : (policy | VRATE_SCALE_256X))
                , tok_rate(bps2rate(rate_bps))
                , tok_max(burst_msec * bps2rate(rate_bps))
            {
                // Nothing else to initialize.
            }
        };
 
        constexpr satcat5::eth::VlanRate
            VRATE_ZERO          (VPOL_STRICT, 0, 0),
            VRATE_8KBPS         (VPOL_STRICT,        8000ull, 4096),
            VRATE_16KBPS        (VPOL_STRICT,       16000ull, 2048),
            VRATE_32KBPS        (VPOL_STRICT,       32000ull, 1024),
            VRATE_64KBPS        (VPOL_STRICT,       64000ull,  512),
            VRATE_128KBPS       (VPOL_STRICT,      128000ull,  256),
            VRATE_256KBPS       (VPOL_STRICT,      256000ull,  128),
            VRATE_512KBPS       (VPOL_STRICT,      512000ull,   64),
            VRATE_1MBPS         (VPOL_STRICT,     1000000ull,   32),
            VRATE_2MBPS         (VPOL_STRICT,     2000000ull,   16),
            VRATE_4MBPS         (VPOL_STRICT,     4000000ull,    8),
            VRATE_8MBPS         (VPOL_STRICT,     8000000ull,    4),
            VRATE_10MBPS        (VPOL_STRICT,    10000000ull,    3),
            VRATE_16MBPS        (VPOL_STRICT,    16000000ull,    2),
            VRATE_100MBPS       (VPOL_STRICT,   100000000ull),
            VRATE_1GBPS         (VPOL_STRICT,  1000000000ull),
            VRATE_10GBPS        (VPOL_STRICT, 10000000000ull),
            VRATE_UNLIMITED     (VPOL_UNLIMITED, 0, 0);
 
        class SwitchConfig {
        public:
            SwitchConfig(satcat5::cfg::ConfigBus* cfg, unsigned devaddr);
 
            void log_info(const char* label);
 
            u32 port_count();
 
            void priority_reset();
 
            bool priority_set(u16 etype, unsigned plen = 16);
 
            void set_miss_bcast(unsigned port_idx, bool enable);
 
            void set_miss_mask(u32 mask);
 
            u32 get_miss_mask();
 
            void set_promiscuous(unsigned port_idx, bool enable);
 
            void set_promiscuous_mask(u32 mask);
 
            u32 get_promiscuous_mask();
 
            void set_traffic_filter(u16 etype = 0);
            inline u16 get_traffic_filter() const {return m_stats_filter;}
 
            u32 get_traffic_count();
 
            u16 get_frame_min();
            u16 get_frame_max();
 
            satcat5::cfg::Register get_log_register();
 
            s32  ptp_get_offset_rx(unsigned port_idx);
            s32  ptp_get_offset_tx(unsigned port_idx);
            u32  ptp_get_2step_mask();
            void ptp_set_offset_rx(unsigned port_idx, s32 subns);
            void ptp_set_offset_tx(unsigned port_idx, s32 subns);
            void ptp_set_2step(unsigned port_idx, bool enable);
 
            void vlan_reset(bool lockdown = false);
            u32 vlan_get_mask(u16 vid);
            void vlan_set_mask(u16 vid, u32 mask);
            void vlan_set_port(const VtagPolicy& cfg);
            void vlan_join(u16 vid, unsigned port);
            void vlan_leave(u16 vid, unsigned port);
            void vlan_set_rate(u16 vid, const satcat5::eth::VlanRate& cfg);
 
            unsigned mactbl_size();
            bool mactbl_read(
                unsigned tbl_idx,
                unsigned& port_idx,
                satcat5::eth::MacAddr& mac_addr);
            bool mactbl_write(
                unsigned port_idx,
                const satcat5::eth::MacAddr& mac_addr);
            bool mactbl_clear();
            bool mactbl_learn(bool enable);
            void mactbl_log(const char* label);
 
            // Define ConfigBus register map (see also: switch_types.vhd)
            static constexpr unsigned
                REG_PORTCOUNT    = 0,   
                REG_DATAPATH     = 1,   
                REG_CORECLOCK    = 2,   
                REG_MACCOUNT     = 3,   
                REG_PROMISC      = 4,   
                REG_PRIORITY     = 5,   
                REG_PKTCOUNT     = 6,   
                REG_FRAMESIZE    = 7,   
                REG_VLAN_PORT    = 8,   
                REG_VLAN_VID     = 9,   
                REG_VLAN_MASK    = 10,  
                REG_MACTBL_LSB   = 11,  
                REG_MACTBL_MSB   = 12,  
                REG_MACTBL_CTRL  = 13,  
                REG_MISS_BCAST   = 14,  
                REG_PTP_2STEP    = 15,  
                REG_VLAN_RATE    = 16,  
                REG_LOGGING      = 17;  
 
            // Additional ConfigBus registers for each port.
            static constexpr unsigned REG_PORT(unsigned idx)
                {return 512 + 16*idx;}          
            static constexpr unsigned REG_PTP_RX(unsigned idx)
                {return REG_PORT(idx) + 8;}     
            static constexpr unsigned REG_PTP_TX(unsigned idx)
                {return REG_PORT(idx) + 9;}     
 
        protected:
            bool mactbl_wait_idle();            
 
            satcat5::cfg::Register m_reg;       
            u32 m_pri_wridx;                    
            u16 m_stats_filter;                 
        };
    }
}