sven
/
libicsneo
mirror of https://github.com/intrepidcs/libicsneo.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Device: RADComet3: Add Ethernet settings

master
Thomas Stoddard 2026-01-28 21:00:39 +00:00 committed by Kyle Schwarz
parent f6926cbb22
commit 5f16adc103
4 changed files with 588 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
bindings/python/icsneopy/device/idevicesettings.cpp
View File

@ -12,7 +12,6 @@ namespace icsneo {
struct DeviceSettingsNamespace {
using EthLinkMode = AELinkMode;
using LinkSpeed = EthLinkSpeed;
};
void init_idevicesettings(pybind11::module_& m) {
@ -23,13 +22,17 @@ void init_idevicesettings(pybind11::module_& m) {
.value("Slave", DeviceSettingsNamespace::EthLinkMode::AE_LINK_SLAVE)
.value("Master", DeviceSettingsNamespace::EthLinkMode::AE_LINK_MASTER);
pybind11::enum_<DeviceSettingsNamespace::LinkSpeed>(settings, "EthernetLinkSpeed")
.value("Speed10M", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_10)
.value("Speed100M", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_100)
.value("Speed1G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_1000)
.value("Speed2_5G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_2500)
.value("Speed5G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_5000)
.value("Speed10G", DeviceSettingsNamespace::LinkSpeed::ETH_SPEED_10000);
pybind11::enum_<EthPhyLinkMode>(settings, "PhyLinkMode")
.value("ETH_LINK_MODE_AUTO_NEGOTIATION", ETH_LINK_MODE_AUTO_NEGOTIATION)
.value("ETH_LINK_MODE_10MBPS_HALFDUPLEX", ETH_LINK_MODE_10MBPS_HALFDUPLEX)
.value("ETH_LINK_MODE_10MBPS_FULLDUPLEX", ETH_LINK_MODE_10MBPS_FULLDUPLEX)
.value("ETH_LINK_MODE_100MBPS_HALFDUPLEX", ETH_LINK_MODE_100MBPS_HALFDUPLEX)
.value("ETH_LINK_MODE_100MBPS_FULLDUPLEX", ETH_LINK_MODE_100MBPS_FULLDUPLEX)
.value("ETH_LINK_MODE_1GBPS_HALFDUPLEX", ETH_LINK_MODE_1GBPS_HALFDUPLEX)
.value("ETH_LINK_MODE_1GBPS_FULLDUPLEX", ETH_LINK_MODE_1GBPS_FULLDUPLEX)
.value("ETH_LINK_MODE_2_5GBPS_FULLDUPLEX", ETH_LINK_MODE_2_5GBPS_FULLDUPLEX)
.value("ETH_LINK_MODE_5GBPS_FULLDUPLEX", ETH_LINK_MODE_5GBPS_FULLDUPLEX)
.value("ETH_LINK_MODE_10GBPS_FULLDUPLEX", ETH_LINK_MODE_10GBPS_FULLDUPLEX);
pybind11::enum_<LINMode>(settings, "LINMode")
.value("Sleep", LINMode::SLEEP_MODE)
@ -63,7 +66,7 @@ void init_idevicesettings(pybind11::module_& m) {
.def("get_lin_commander_response_time", &IDeviceSettings::getLINCommanderResponseTimeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("set_lin_commander_response_time", &IDeviceSettings::setLINCommanderResponseTimeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
// Ethernet PHY methods
// Ethernet PHY methods (index-based for switch devices)
.def("get_phy_enable", &IDeviceSettings::getPhyEnable, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("get_phy_mode", &IDeviceSettings::getPhyMode, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("get_phy_speed", &IDeviceSettings::getPhySpeed, pybind11::call_guard<pybind11::gil_scoped_release>())
@ -71,6 +74,15 @@ void init_idevicesettings(pybind11::module_& m) {
.def("set_phy_mode", &IDeviceSettings::setPhyMode, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("set_phy_speed", &IDeviceSettings::setPhySpeed, pybind11::call_guard<pybind11::gil_scoped_release>())
// Ethernet PHY methods (network-based for multi-interface devices)
.def("get_phy_enable_for", &IDeviceSettings::getPhyEnableFor, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("get_phy_role_for", &IDeviceSettings::getPhyRoleFor, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("get_phy_link_mode_for", &IDeviceSettings::getPhyLinkModeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("set_phy_enable_for", &IDeviceSettings::setPhyEnableFor, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("set_phy_role_for", &IDeviceSettings::setPhyRoleFor, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("set_phy_link_mode_for", &IDeviceSettings::setPhyLinkModeFor, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("get_supported_phy_link_modes_for", &IDeviceSettings::getSupportedPhyLinkModesFor, pybind11::call_guard<pybind11::gil_scoped_release>())
// 10BASE-T1S methods
.def("is_t1s_plca_enabled", &IDeviceSettings::isT1SPLCAEnabledFor, pybind11::call_guard<pybind11::gil_scoped_release>())
.def("set_t1s_plca", &IDeviceSettings::setT1SPLCAFor, pybind11::call_guard<pybind11::gil_scoped_release>())

222
include/icsneo/device/idevicesettings.h
View File

@ -54,14 +54,18 @@ enum AELinkMode
AE_LINK_SLAVE
};
enum EthLinkSpeed
enum EthPhyLinkMode
{
ETH_SPEED_10 = 0,
ETH_SPEED_100,
ETH_SPEED_1000,
ETH_SPEED_2500,
ETH_SPEED_5000,
ETH_SPEED_10000,
ETH_LINK_MODE_AUTO_NEGOTIATION = 0,
ETH_LINK_MODE_10MBPS_HALFDUPLEX,
ETH_LINK_MODE_10MBPS_FULLDUPLEX,
ETH_LINK_MODE_100MBPS_HALFDUPLEX,
ETH_LINK_MODE_100MBPS_FULLDUPLEX,
ETH_LINK_MODE_1GBPS_HALFDUPLEX,
ETH_LINK_MODE_1GBPS_FULLDUPLEX,
ETH_LINK_MODE_2_5GBPS_FULLDUPLEX,
ETH_LINK_MODE_5GBPS_FULLDUPLEX,
ETH_LINK_MODE_10GBPS_FULLDUPLEX
};
typedef struct
@ -69,7 +73,7 @@ typedef struct
uint16_t networkId;
uint8_t linkStatus;
uint8_t linkFullDuplex;
uint8_t linkSpeed; // see EthLinkSpeed
uint8_t linkSpeed; // 0=10Mbps, 1=100Mbps, 2=1Gbps, 3=2.5Gbps, 4=5Gbps, 5=10Gbps
int8_t linkMode; // for automotive networks - see AELinkMode
} EthernetNetworkStatus;
@ -366,6 +370,11 @@ typedef struct SERDESGEN_SETTINGS_t
#define ETHERNET_SETTINGS2_FLAG_DEVICE_HOSTING_ENABLE 0x10
#define ETHERNET_SETTINGS2_FLAG_COMM_IN_USE 0x80
// ETHERNET_SETTINGS2 flags2 bit definitions
#define ETHERNET_SETTINGS2_FLAGS2_LINK_MODE_SLAVE 0x01 // bit0: 0=master, 1=slave
#define ETHERNET_SETTINGS2_FLAGS2_PHY_MODE_LEGACY 0x02 // bit1: 0=IEEE, 1=legacy
#define ETHERNET_SETTINGS2_FLAGS2_LINK_MODE_AUTO 0x04 // bit2: auto master/slave negotiation
typedef struct ETHERNET_SETTINGS2_t
{
/* bit0: 0=half duplex, 1=full duplex
@ -379,7 +388,13 @@ typedef struct ETHERNET_SETTINGS2_t
uint32_t ip_addr;
uint32_t netmask;
uint32_t gateway;
uint8_t rsvd[2];
/* FLAGS2
* bit0: link mode - 0=master, 1=slave
* bit1: PHY mode - 0=IEEE, 1=legacy
* bit2: auto master/slave
*/
uint8_t flags2;
uint8_t rsvd;
} ETHERNET_SETTINGS2;
#define ETHERNET_SETTINGS2_SIZE 16
@ -808,6 +823,26 @@ public:
return reinterpret_cast<LIN_SETTINGS*>((void*)(settings.data() + (offset - settingsInDeviceRAM.data())));
}
virtual const ETHERNET_SETTINGS2* getEthernetSettingsFor(Network net) const { (void)net; return nullptr; }
ETHERNET_SETTINGS2* getMutableEthernetSettingsFor(Network net) {
if(disabled || readonly)
return nullptr;
const uint8_t* offset = (const uint8_t*)getEthernetSettingsFor(net);
if(offset == nullptr)
return nullptr;
return reinterpret_cast<ETHERNET_SETTINGS2*>((void*)(settings.data() + (offset - settingsInDeviceRAM.data())));
}
virtual const AE_SETTINGS* getAESettingsFor(Network net) const { (void)net; return nullptr; }
AE_SETTINGS* getMutableAESettingsFor(Network net) {
if(disabled || readonly)
return nullptr;
const uint8_t* offset = (const uint8_t*)getAESettingsFor(net);
if(offset == nullptr)
return nullptr;
return reinterpret_cast<AE_SETTINGS*>((void*)(settings.data() + (offset - settingsInDeviceRAM.data())));
}
/**
* Some devices have groupings of networks, where software
* switchable termination can only be applied to one network
@ -908,39 +943,176 @@ public:
*/
bool setLINCommanderResponseTimeFor(Network net, uint8_t bits);
/**
* Set PHY role (Master/Slave/Auto) for switch devices (Epsilon/XL, Jupiter, etc) using port index.
* For all other devices, use setPhyRoleFor() instead.
*
* @param index Port index (0-based)
* @param mode Master/Slave/Auto role
* @return true if successful
*/
virtual bool setPhyMode(uint8_t index, AELinkMode mode) {
(void)index, (void)mode;
return false;
}
/**
* Enable/disable PHY for switch devices (Epsilon/XL, Jupiter, etc) using port index.
* For all other devices, use setPhyEnableFor() instead.
*
* @param index Port index (0-based)
* @param enable True to enable, false to disable
* @return true if successful
*/
virtual bool setPhyEnable(uint8_t index, bool enable) {
(void)index, (void)enable;
return false;
}
virtual bool setPhySpeed(uint8_t index, EthLinkSpeed speed) {
(void)index, (void)speed;
/**
* Set PHY link mode (speed and duplex) for switch devices (Epsilon/XL, Jupiter, etc) using port index.
* For all other devices, use setPhyLinkModeFor() instead.
*
* @param index Port index (0-based)
* @param mode Link mode (speed + duplex combination)
* @return true if successful
*/
virtual bool setPhySpeed(uint8_t index, EthPhyLinkMode mode) {
(void)index, (void)mode;
return false;
}
/**
* Get PHY role (Master/Slave/Auto) for switch devices (Epsilon/XL, Jupiter, etc) using port index.
* For all other devices, use getPhyRoleFor() instead.
*
* @param index Port index (0-based)
* @return Current role, or nullopt if not available
*/
virtual std::optional<AELinkMode> getPhyMode(uint8_t index) {
(void)index;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
return std::nullopt;
}
/**
* Get PHY enable state for switch devices (Epsilon/XL, Jupiter, etc) using port index.
* For all other devices, use getPhyEnableFor() instead.
*
* @param index Port index (0-based)
* @return True if enabled, false if disabled, nullopt if not available
*/
virtual std::optional<bool> getPhyEnable(uint8_t index) {
(void)index;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
return std::nullopt;
}
virtual std::optional<EthLinkSpeed> getPhySpeed(uint8_t index) {
/**
* Get PHY link mode (speed and duplex) for switch devices (Epsilon/XL, Jupiter, etc) using port index.
* For all other devices, use getPhyLinkModeFor() instead.
*
* @param index Port index (0-based)
* @return Current link mode, or nullopt if not available
*/
virtual std::optional<EthPhyLinkMode> getPhySpeed(uint8_t index) {
(void)index;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
return std::nullopt;
}
/**
* Set PHY role (Master/Slave/Auto) for network-based devices.
* For switch devices, use setPhyMode() with port index instead.
*
* @param net Network ID
* @param mode Master/Slave/Auto role
* @return true if successful
*/
virtual bool setPhyRoleFor(Network net, AELinkMode mode) {
(void)net, (void)mode;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
return false;
}
/**
* Enable/disable PHY for network-based devices.
* For switch devices, use setPhyEnable() with port index instead.
*
* @param net Network ID
* @param enable True to enable, false to disable
* @return true if successful
*/
virtual bool setPhyEnableFor(Network net, bool enable) {
(void)net, (void)enable;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
return false;
}
/**
* Get PHY role (Master/Slave/Auto) for network-based devices.
* For switch devices, use getPhyMode() with port index instead.
*
* @param net Network ID
* @return Current role, or nullopt if not available
*/
virtual std::optional<AELinkMode> getPhyRoleFor(Network net) const {
(void)net;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
return std::nullopt;
}
/**
* Get PHY enable state for network-based devices.
* For switch devices, use getPhyEnable() with port index instead.
*
* @param net Network ID
* @return True if enabled, false if disabled, nullopt if not available
*/
virtual std::optional<bool> getPhyEnableFor(Network net) const {
(void)net;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
return std::nullopt;
}
/**
* Get supported PHY link modes (combined speed+duplex) for a network.
* Each mode represents a valid hardware configuration.
*
* @param net The network to query
* @return Vector of supported modes, empty if network doesn't support PHY settings
*/
virtual std::vector<EthPhyLinkMode> getSupportedPhyLinkModesFor(Network net) const {
(void)net;
return {}; // Default: no PHY support
}
/**
* Set PHY link mode (speed and duplex together).
*
* @param net The network to configure
* @param mode The link mode to set
* @return true if successful, false if mode not supported or error occurred
*/
virtual bool setPhyLinkModeFor(Network net, EthPhyLinkMode mode) {
(void)net; (void)mode;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
return false;
}
/**
* Get current PHY link mode.
*
* @param net The network to query
* @return Current link mode, or nullopt if not available or not configured
*/
virtual std::optional<EthPhyLinkMode> getPhyLinkModeFor(Network net) const {
(void)net;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
return std::nullopt;
}
virtual std::optional<bool> isT1SPLCAEnabledFor(Network net) const {
(void)net;
report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
@ -1049,6 +1221,32 @@ protected:
return nullptr;
return reinterpret_cast<ICSNEO_UNALIGNED(uint64_t*)>((void*)(settings.data() + (offset - settingsInDeviceRAM.data())));
}
static bool SetNetworkEnabled(uint64_t* bitfields, size_t count, uint64_t networkID) {
const size_t index = networkID / 64;
const size_t offset = networkID & 0x3F;
if (index >= count)
return false;
bitfields[index] |= (1ULL << offset);
return true;
}
static bool ClearNetworkEnabled(uint64_t* bitfields, size_t count, uint64_t networkID) {
const size_t index = networkID / 64;
const size_t offset = networkID & 0x3F;
if (index >= count)
return false;
bitfields[index] &= ~(1ULL << offset);
return true;
}
static bool GetNetworkEnabled(const uint64_t* bitfields, size_t count, uint64_t networkID) {
const size_t index = networkID / 64;
const size_t offset = networkID & 0x3F;
if (index >= count)
return false;
return (bitfields[index] & (1ULL << offset)) != 0;
}
};
}

312
include/icsneo/device/tree/radcomet3/radcomet3settings.h
View File

@ -114,6 +114,44 @@ public:
}
}
const ETHERNET_SETTINGS2* getEthernetSettingsFor(Network net) const override {
auto cfg = getStructurePointer<radcomet3_settings_t>();
if(cfg == nullptr)
return nullptr;
switch(net.getNetID()) {
case Network::NetID::ETHERNET_01:
return &(cfg->ethernet);
case Network::NetID::AE_01:
return &(cfg->ethT1);
case Network::NetID::AE_02:
return &(cfg->ethT1s1);
case Network::NetID::AE_03:
return &(cfg->ethT1s2);
case Network::NetID::AE_04:
return &(cfg->ethT1s3);
case Network::NetID::AE_05:
return &(cfg->ethT1s4);
case Network::NetID::AE_06:
return &(cfg->ethT1s5);
case Network::NetID::AE_07:
return &(cfg->ethT1s6);
default:
return nullptr;
}
}
const AE_SETTINGS* getAESettingsFor(Network net) const override {
auto cfg = getStructurePointer<radcomet3_settings_t>();
if(cfg == nullptr)
return nullptr;
switch(net.getNetID()) {
case Network::NetID::AE_01:
return &(cfg->ae_01);
default:
return nullptr;
}
}
std::optional<bool> isT1SPLCAEnabledFor(Network net) const override {
const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
if(t1s == nullptr)
@ -220,6 +258,280 @@ public:
return true;
}
bool setPhyRoleFor(Network net, AELinkMode mode) override {
if (mode != AE_LINK_AUTO && mode != AE_LINK_MASTER && mode != AE_LINK_SLAVE) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
}
AE_SETTINGS* ae = getMutableAESettingsFor(net);
if (ae == nullptr) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
}
ae->ucConfigMode = static_cast<uint8_t>(mode);
ETHERNET_SETTINGS2* ethSettings = getMutableEthernetSettingsFor(net);
if (ethSettings == nullptr) {
return false;
}
uint8_t& flags2 = ethSettings->flags2;
switch (mode) {
case AE_LINK_AUTO:
flags2 |= ETHERNET_SETTINGS2_FLAGS2_LINK_MODE_AUTO;
break;
case AE_LINK_MASTER:
flags2 &= ~ETHERNET_SETTINGS2_FLAGS2_LINK_MODE_AUTO;
flags2 &= ~ETHERNET_SETTINGS2_FLAGS2_LINK_MODE_SLAVE;
break;
case AE_LINK_SLAVE:
flags2 &= ~ETHERNET_SETTINGS2_FLAGS2_LINK_MODE_AUTO;
flags2 |= ETHERNET_SETTINGS2_FLAGS2_LINK_MODE_SLAVE;
break;
}
return true;
}
bool setPhyEnableFor(Network net, bool enable) override {
auto cfg = getMutableStructurePointer<radcomet3_settings_t>();
if (cfg == nullptr)
return false;
if (net.getType() != Network::Type::Ethernet && net.getType() != Network::Type::AutomotiveEthernet) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
}
auto coreMini = net.getCoreMini();
if (!coreMini.has_value()) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
}
const uint64_t networkID = static_cast<uint64_t>(coreMini.value());
uint64_t bitfields[2] = { cfg->network_enables, cfg->network_enables_2 };
const bool success = enable ?
SetNetworkEnabled(bitfields, 2, networkID) :
ClearNetworkEnabled(bitfields, 2, networkID);
if (!success) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
}
cfg->network_enables = bitfields[0];
cfg->network_enables_2 = bitfields[1];
return true;
}
std::optional<AELinkMode> getPhyRoleFor(Network net) const override {
const AE_SETTINGS* ae = getAESettingsFor(net);
if (ae == nullptr) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return std::nullopt;
}
switch (ae->ucConfigMode) {
case 0:
return std::make_optional(AE_LINK_AUTO);
case 1:
return std::make_optional(AE_LINK_MASTER);
case 2:
return std::make_optional(AE_LINK_SLAVE);
default:
return std::make_optional(AE_LINK_AUTO);
}
}
std::optional<bool> getPhyEnableFor(Network net) const override {
auto cfg = getStructurePointer<radcomet3_settings_t>();
if (cfg == nullptr) {
report(APIEvent::Type::SettingsReadError, APIEvent::Severity::Error);
return std::nullopt;
}
if (net.getType() != Network::Type::Ethernet && net.getType() != Network::Type::AutomotiveEthernet) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return std::nullopt;
}
auto coreMini = net.getCoreMini();
if (!coreMini.has_value()) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return std::nullopt;
}
const uint64_t networkID = static_cast<uint64_t>(coreMini.value());
const uint64_t bitfields[2] = { cfg->network_enables, cfg->network_enables_2 };
return GetNetworkEnabled(bitfields, 2, networkID);
}
std::vector<EthPhyLinkMode> getSupportedPhyLinkModesFor(Network net) const override {
switch(net.getNetID()) {
case Network::NetID::ETHERNET_01:
return {
ETH_LINK_MODE_AUTO_NEGOTIATION,
ETH_LINK_MODE_10MBPS_FULLDUPLEX,
ETH_LINK_MODE_100MBPS_FULLDUPLEX,
ETH_LINK_MODE_1GBPS_FULLDUPLEX
};
case Network::NetID::AE_01:
return {
ETH_LINK_MODE_AUTO_NEGOTIATION,
ETH_LINK_MODE_100MBPS_FULLDUPLEX,
ETH_LINK_MODE_1GBPS_FULLDUPLEX
};
case Network::NetID::AE_02:
case Network::NetID::AE_03:
case Network::NetID::AE_04:
case Network::NetID::AE_05:
case Network::NetID::AE_06:
case Network::NetID::AE_07:
return {ETH_LINK_MODE_10MBPS_HALFDUPLEX};
default:
return {};
}
}
bool setPhyLinkModeFor(Network net, EthPhyLinkMode mode) override {
auto supported = getSupportedPhyLinkModesFor(net);
if (std::find(supported.begin(), supported.end(), mode) == supported.end()) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
}
auto cfg = getMutableStructurePointer<radcomet3_settings_t>();
if (cfg == nullptr)
return false;
if (net.getNetID() == Network::NetID::AE_01) {
AE_SETTINGS* ae = getMutableAESettingsFor(net);
if (ae == nullptr) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
}
switch (mode) {
case ETH_LINK_MODE_AUTO_NEGOTIATION:
ae->link_spd = 3;
cfg->ethT1.link_speed = 2;
cfg->ethT1.flags |= ETHERNET_SETTINGS2_FLAG_AUTO_NEG;
cfg->ethT1.flags |= ETHERNET_SETTINGS2_FLAG_FULL_DUPLEX;
break;
case ETH_LINK_MODE_100MBPS_FULLDUPLEX:
ae->link_spd = 1;
cfg->ethT1.link_speed = 1;
cfg->ethT1.flags &= ~ETHERNET_SETTINGS2_FLAG_AUTO_NEG;
cfg->ethT1.flags |= ETHERNET_SETTINGS2_FLAG_FULL_DUPLEX;
break;
case ETH_LINK_MODE_1GBPS_FULLDUPLEX:
ae->link_spd = 2;
cfg->ethT1.link_speed = 2;
cfg->ethT1.flags &= ~ETHERNET_SETTINGS2_FLAG_AUTO_NEG;
cfg->ethT1.flags |= ETHERNET_SETTINGS2_FLAG_FULL_DUPLEX;
break;
default:
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
}
} else if (net.getNetID() == Network::NetID::ETHERNET_01) {
switch (mode) {
case ETH_LINK_MODE_AUTO_NEGOTIATION:
cfg->ethernet.flags |= ETHERNET_SETTINGS2_FLAG_AUTO_NEG;
cfg->ethernet.link_speed = 2;
cfg->ethernet.flags |= ETHERNET_SETTINGS2_FLAG_FULL_DUPLEX;
break;
case ETH_LINK_MODE_10MBPS_FULLDUPLEX:
cfg->ethernet.link_speed = 0;
cfg->ethernet.flags &= ~ETHERNET_SETTINGS2_FLAG_AUTO_NEG;
cfg->ethernet.flags |= ETHERNET_SETTINGS2_FLAG_FULL_DUPLEX;
break;
case ETH_LINK_MODE_100MBPS_FULLDUPLEX:
cfg->ethernet.link_speed = 1;
cfg->ethernet.flags &= ~ETHERNET_SETTINGS2_FLAG_AUTO_NEG;
cfg->ethernet.flags |= ETHERNET_SETTINGS2_FLAG_FULL_DUPLEX;
break;
case ETH_LINK_MODE_1GBPS_FULLDUPLEX:
cfg->ethernet.link_speed = 2;
cfg->ethernet.flags &= ~ETHERNET_SETTINGS2_FLAG_AUTO_NEG;
cfg->ethernet.flags |= ETHERNET_SETTINGS2_FLAG_FULL_DUPLEX;
break;
default:
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
}
}
return true;
}
std::optional<EthPhyLinkMode> getPhyLinkModeFor(Network net) const override {
auto cfg = getStructurePointer<radcomet3_settings_t>();
if (cfg == nullptr) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return std::nullopt;
}
if (net.getNetID() == Network::NetID::ETHERNET_01) {
if (cfg->ethernet.flags & ETHERNET_SETTINGS2_FLAG_AUTO_NEG) {
return ETH_LINK_MODE_AUTO_NEGOTIATION;
}
bool fullDuplex = (cfg->ethernet.flags & ETHERNET_SETTINGS2_FLAG_FULL_DUPLEX) != 0;
switch (cfg->ethernet.link_speed) {
case 0:
return fullDuplex ? ETH_LINK_MODE_10MBPS_FULLDUPLEX
: ETH_LINK_MODE_10MBPS_HALFDUPLEX;
case 1:
return fullDuplex ? ETH_LINK_MODE_100MBPS_FULLDUPLEX
: ETH_LINK_MODE_100MBPS_HALFDUPLEX;
case 2:
return fullDuplex ? ETH_LINK_MODE_1GBPS_FULLDUPLEX
: ETH_LINK_MODE_1GBPS_HALFDUPLEX;
default:
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return std::nullopt;
}
} else if (net.getNetID() == Network::NetID::AE_01) {
const AE_SETTINGS* ae = &cfg->ae_01;
// Check auto-negotiate
if (ae->link_spd == 3 || (cfg->ethT1.flags & ETHERNET_SETTINGS2_FLAG_AUTO_NEG)) {
return ETH_LINK_MODE_AUTO_NEGOTIATION;
}
// T1 is always full-duplex
switch (ae->link_spd) {
case 1: // 100 Mbps
return ETH_LINK_MODE_100MBPS_FULLDUPLEX;
case 2: // 1000 Mbps
return ETH_LINK_MODE_1GBPS_FULLDUPLEX;
default:
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return std::nullopt;
}
} else if (net.getNetID() >= Network::NetID::AE_02 && net.getNetID() <= Network::NetID::AE_07) {
// 10BASE-T1S ports - half-duplex only
return ETH_LINK_MODE_10MBPS_HALFDUPLEX;
} else {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return std::nullopt;
}
}
private:
const ETHERNET10T1S_SETTINGS* getT1SSettingsFor(Network net) const {
auto cfg = getStructurePointer<radcomet3_settings_t>();

53
include/icsneo/device/tree/radepsilon/radepsilonsettings.h
View File

@ -168,7 +168,7 @@ public:
return true;
}
bool setPhySpeed(uint8_t index, EthLinkSpeed speed) override {
bool setPhySpeed(uint8_t index, EthPhyLinkMode mode) override {
if (index > RADEPSILON_MAX_PHY) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
@ -178,19 +178,30 @@ public:
return false;
}
EpsilonPhySpeed epsilonSpeed;
switch (speed) {
switch (mode) {
case ETH_LINK_MODE_AUTO_NEGOTIATION:
// Auto-negotiate - default to 1G base speed
epsilonSpeed = EpsilonPhySpeed::Speed1000;
break;
case ETH_LINK_MODE_100MBPS_FULLDUPLEX:
epsilonSpeed = EpsilonPhySpeed::Speed100;
break;
case ETH_LINK_MODE_1GBPS_FULLDUPLEX:
epsilonSpeed = EpsilonPhySpeed::Speed1000;
break;
case ETH_LINK_MODE_10GBPS_FULLDUPLEX:
epsilonSpeed = EpsilonPhySpeed::Speed10000;
break;
// Reject half-duplex modes - automotive T1 is full-duplex only
case ETH_LINK_MODE_10MBPS_HALFDUPLEX:
case ETH_LINK_MODE_10MBPS_FULLDUPLEX:
case ETH_LINK_MODE_100MBPS_HALFDUPLEX:
case ETH_LINK_MODE_1GBPS_HALFDUPLEX:
case ETH_LINK_MODE_2_5GBPS_FULLDUPLEX:
case ETH_LINK_MODE_5GBPS_FULLDUPLEX:
default:
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return false;
case ETH_SPEED_100:
epsilonSpeed = EpsilonPhySpeed::Speed100;
break;
case ETH_SPEED_1000:
epsilonSpeed = EpsilonPhySpeed::Speed1000;
break;
case ETH_SPEED_10000:
epsilonSpeed = EpsilonPhySpeed::Speed10000;
break;
}
cfg->switchSettings.speed[index] = static_cast<uint8_t>(epsilonSpeed);
return true;
@ -235,7 +246,7 @@ public:
return std::make_optional(static_cast<bool>(cfg->switchSettings.enablePhy[index]));
}
std::optional<EthLinkSpeed> getPhySpeed(uint8_t index) override {
std::optional<EthPhyLinkMode> getPhySpeed(uint8_t index) override {
if (index > RADEPSILON_MAX_PHY) {
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return std::nullopt;
@ -244,22 +255,18 @@ public:
if (cfg == nullptr) {
return std::nullopt;
}
EthLinkSpeed speed;
// Automotive Ethernet T1 is always full-duplex
switch (static_cast<EpsilonPhySpeed>(cfg->switchSettings.speed[index])) {
case EpsilonPhySpeed::Speed100:
return ETH_LINK_MODE_100MBPS_FULLDUPLEX;
case EpsilonPhySpeed::Speed1000:
return ETH_LINK_MODE_1GBPS_FULLDUPLEX;
case EpsilonPhySpeed::Speed10000:
return ETH_LINK_MODE_10GBPS_FULLDUPLEX;
default:
report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
return std::nullopt;
case EpsilonPhySpeed::Speed100:
speed = ETH_SPEED_100;
break;
case EpsilonPhySpeed::Speed1000:
speed = ETH_SPEED_1000;
break;
case EpsilonPhySpeed::Speed10000:
speed = ETH_SPEED_10000;
break;
}
return std::make_optional(speed);
}
private: