Device: RADComet3: Add Ethernet settings

include/icsneo/device/tree/radcomet3/radcomet3settings.h

@@ -114,11 +114,49 @@ 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)
 			return std::nullopt;
-		
+
 		return std::make_optional((t1s->flags & ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA) != 0);
 	}
 
@@ -126,12 +164,12 @@ public:
 		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return false;
-		
+
 		if(enable)
 			t1s->flags |= ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA;
 		else
 			t1s->flags &= ~ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA;
-		
+
 		return true;
 	}
 
@@ -139,7 +177,7 @@ public:
 		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return std::nullopt;
-		
+
 		return std::make_optional(t1s->local_id);
 	}
 
@@ -147,7 +185,7 @@ public:
 		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return false;
-		
+
 		t1s->local_id = id;
 		return true;
 	}
@@ -156,7 +194,7 @@ public:
 		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return std::nullopt;
-		
+
 		return std::make_optional(t1s->max_num_nodes);
 	}
 
@@ -164,7 +202,7 @@ public:
 		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return false;
-		
+
 		t1s->max_num_nodes = nodes;
 		return true;
 	}
@@ -173,7 +211,7 @@ public:
 		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return std::nullopt;
-		
+
 		return std::make_optional(t1s->to_timer);
 	}
 
@@ -181,7 +219,7 @@ public:
 		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return false;
-		
+
 		t1s->to_timer = timer;
 		return true;
 	}
@@ -190,7 +228,7 @@ public:
 		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return std::nullopt;
-		
+
 		return std::make_optional(t1s->max_burst_count);
 	}
 
@@ -198,7 +236,7 @@ public:
 		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return false;
-		
+
 		t1s->max_burst_count = burst;
 		return true;
 	}
@@ -207,7 +245,7 @@ public:
 		const ETHERNET10T1S_SETTINGS* t1s = getT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return std::nullopt;
-		
+
 		return std::make_optional(t1s->burst_timer);
 	}
 
@@ -215,17 +253,291 @@ public:
 		ETHERNET10T1S_SETTINGS* t1s = getMutableT1SSettingsFor(net);
 		if(t1s == nullptr)
 			return false;
-		
+
 		t1s->burst_timer = timer;
 		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>();
 		if(cfg == nullptr)
 			return nullptr;
-		
+
 		switch(net.getNetID()) {
 			case Network::NetID::AE_02: return &(cfg->t1s1);
 			case Network::NetID::AE_03: return &(cfg->t1s2);
@@ -243,7 +555,7 @@ private:
 		auto cfg = getMutableStructurePointer<radcomet3_settings_t>();
 		if(cfg == nullptr)
 			return nullptr;
-		
+
 		switch(net.getNetID()) {
 			case Network::NetID::AE_02: return &(cfg->t1s1);
 			case Network::NetID::AE_03: return &(cfg->t1s2);

include/icsneo/device/tree/radepsilon/radepsilonsettings.h

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