Device: Add bootloader information & getChipVersions()

include/icsneo/device/tree/etherbadge/etherbadge.h

@@ -26,6 +26,10 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::EtherBADGE;
+	}
+
 protected:
 	EtherBADGE(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<EtherBADGESettings>(makeDriver);

include/icsneo/device/tree/neoobd2pro/neoobd2pro.h

@@ -22,6 +22,10 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::neoOBD2Pro;
+	}
+
 private:
 	NeoOBD2PRO(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize(makeDriver);

include/icsneo/device/tree/neoobd2sim/neoobd2sim.h

@@ -21,7 +21,10 @@ public:
 		};
 		return supportedNetworks;
 	}
-
+	
+	ProductID getProductID() const override {
+		return ProductID::neoOBD2Sim;
+	}
 private:
 	NeoOBD2SIM(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize(makeDriver);

include/icsneo/device/tree/neoviconnect/neoviconnect.h

@@ -34,6 +34,28 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::Connect;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::Connect_ZCHIP, true, "ZCHIP", "neovi_connect_zchip_ief", 0, FirmwareType::IEF},
+			{ChipID::Connect_LINUX, true, "Linux Flash", "neovi_connect_lnx_flash_ief", 1, FirmwareType::IEF},
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<FlashPhase>(ChipID::Connect_ZCHIP, BootloaderCommunication::Application, true, false, false)
+			.add<FlashPhase>(ChipID::Connect_LINUX, BootloaderCommunication::Application, false, false, false)
+			.add<FinalizePhase>(ChipID::Connect_ZCHIP, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::Connect_LINUX, BootloaderCommunication::Application)
+			.add<ReconnectPhase>()
+			.addSetting(BootloaderSetting::UpdateAll, true);
+	}
+
 protected:
 	NeoVIConnect(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<NeoVIConnectSettings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/neovifire/neovifire.h

@@ -57,6 +57,9 @@ public:
 		return true;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::neoVIFIRE;
+	}
 private:
 	NeoVIFIRE(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<NeoVIFIRESettings>(makeDriver);

include/icsneo/device/tree/neovifire2/neovifire2.h

@@ -87,6 +87,28 @@ public:
 		};
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::neoVIFIRE2;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::neoVIFIRE2_MCHIP, true, "MCHIP", "fire2_mchip_ief", 0, FirmwareType::IEF},
+			{ChipID::neoVIFIRE2_ZYNQ, true, "ZCHIP", "fire2_zchip_ief", 1, FirmwareType::IEF},
+			{ChipID::neoVIFIRE2_Core, true, "Core", "fire2_core", 2, FirmwareType::IEF},
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::neoVIFIRE2_MCHIP, BootloaderCommunication::RED)
+			.add<FlashPhase>(ChipID::neoVIFIRE2_ZYNQ, BootloaderCommunication::RED, false, true)
+			.add<FlashPhase>(ChipID::neoVIFIRE2_Core, BootloaderCommunication::REDCore, false, false)
+			.add<ReconnectPhase>();
+	}
+	
 protected:
 	NeoVIFIRE2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<NeoVIFIRE2Settings, Disk::NeoMemoryDiskDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/neovifire3/neovifire3.h

@@ -50,6 +50,34 @@ public:
 		return supportedNetworks;
 	}
 	size_t getEthernetActivationLineCount() const override { return 2; }
+
+	ProductID getProductID() const override {
+		return ProductID::neoVIFIRE3;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::neoVIFIRE3_ZCHIP, true, "ZCHIP", "fire3_zchip_ief", 0, FirmwareType::IEF},
+			{ChipID::neoVIFIRE3_SCHIP, true, "SCHIP", "fire3_schip_ief", 1, FirmwareType::IEF},
+			{ChipID::neoVIFIRE3_LINUX, true, "Linux Flash", "fire3_lnx_flash_ief", 2, FirmwareType::IEF},
+			{ChipID::VEM_01_8DW_ZCHIP, true, "VEM-01-Z", "vem_01_8dw_zchip_ief", 3, FirmwareType::IEF}
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<FlashPhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application, true, false)
+			.add<FlashPhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application, false, true)
+			.add<FlashPhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application, false, false, false)
+			.add<FlashPhase>(ChipID::VEM_01_8DW_ZCHIP, BootloaderCommunication::Application, false, false)
+			.add<FinalizePhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::VEM_01_8DW_ZCHIP, BootloaderCommunication::Application)
+			.add<ReconnectPhase>()
+			.addSetting(BootloaderSetting::UpdateAll, true);
+	}
 protected:
 	NeoVIFIRE3(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<NeoVIFIRE3Settings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/neovifire3flexray/neovifire3flexray.h

@@ -53,6 +53,36 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::neoVIFIRE3;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::neoVIFIRE3_ZCHIP, true, "ZCHIP", "fire3_zchip_ief", 0, FirmwareType::IEF},
+			{ChipID::neoVIFIRE3_SCHIP, true, "SCHIP", "fire3_schip_ief", 1, FirmwareType::IEF},
+			{ChipID::neoVIFIRE3_LINUX, true, "Linux Flash", "fire3_lnx_flash_ief", 2, FirmwareType::IEF},
+			{ChipID::VEM_02_FR_ZCHIP, true, "VEM-02-Z", "vem_02_fr_zchip_ief", 3, FirmwareType::IEF},
+			{ChipID::VEM_02_FR_FCHIP, true, "VEM-02-F", "vem_02_fr_fchip_ief", 4, FirmwareType::IEF},
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<FlashPhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application, true, false)
+			.add<FlashPhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application, false, true)
+			.add<FlashPhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application, false, false, false)
+			.add<FlashPhase>(ChipID::VEM_02_FR_FCHIP, BootloaderCommunication::Application, false, false)
+			.add<FlashPhase>(ChipID::VEM_02_FR_ZCHIP, BootloaderCommunication::Application, false, false)
+			.add<FinalizePhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::VEM_02_FR_FCHIP, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::VEM_02_FR_ZCHIP, BootloaderCommunication::Application)
+			.add<ReconnectPhase>()
+			.addSetting(BootloaderSetting::UpdateAll, true);
+	}
 protected:
 	NeoVIFIRE3FlexRay(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<NeoVIFIRE3FlexRaySettings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/neovifire3t1slin/neovifire3t1slin.h

@@ -59,6 +59,9 @@ public:
 
 	bool supportsTC10() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::neoVIFIRE3;
+	}
 protected:
 	NeoVIFIRE3T1SLIN(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<NeoVIFIRE3T1SLINSettings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/neovired2/neovired2.h

@@ -37,6 +37,30 @@ public:
 
 	bool supportsGPTP() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::neoVIFIRE3;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::neoVIFIRE3_ZCHIP, true, "ZCHIP", "fire3_zchip_ief", 0, FirmwareType::IEF},
+			{ChipID::neoVIFIRE3_SCHIP, true, "SCHIP", "fire3_schip_ief", 1, FirmwareType::IEF},
+			{ChipID::neoVIFIRE3_LINUX, true, "Linux Flash", "fire3_lnx_flash_ief", 2, FirmwareType::IEF}
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<FlashPhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application, true, false)
+			.add<FlashPhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application, false, true)
+			.add<FlashPhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application, false, false, false)
+			.add<FinalizePhase>(ChipID::neoVIFIRE3_ZCHIP, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::neoVIFIRE3_SCHIP, BootloaderCommunication::Application)
+			.add<FinalizePhase>(ChipID::neoVIFIRE3_LINUX, BootloaderCommunication::Application)
+			.add<ReconnectPhase>()
+			.addSetting(BootloaderSetting::UpdateAll, true);
+	}
 protected:
 	NeoVIRED2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<NeoVIRED2Settings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/plasion/neoviion.h

@@ -15,6 +15,9 @@ public:
 	// USB PID is 0x0901, standard driver is DXX
 	ICSNEO_FINDABLE_DEVICE(NeoVIION, DeviceType::ION, "40");
 
+	ProductID getProductID() const override {
+		return ProductID::neoVIION;
+	}
 private:
 	NeoVIION(neodevice_t neodevice, const driver_factory_t& makeDriver) : Plasion(neodevice) {
 		initialize<NullSettings, Disk::PlasionDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/plasion/neoviplasma.h

@@ -13,6 +13,9 @@ public:
 	// USB PID is 0x0801, standard driver is DXX
 	ICSNEO_FINDABLE_DEVICE(NeoVIPLASMA, DeviceType::PLASMA, "30");
 
+	ProductID getProductID() const override {
+		return ProductID::neoVIPLASMA;
+	}
 private:
 	NeoVIPLASMA(neodevice_t neodevice, const driver_factory_t& makeDriver) : Plasion(neodevice) {
 		initialize<NullSettings, Disk::PlasionDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/rada2b/rada2b.h

@@ -42,11 +42,32 @@ public:
 	size_t getEthernetActivationLineCount() const override { return 1; }
 	bool supportsGPTP() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADA2B;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADA2B_ZCHIP, true, "ZCHIP", "RADA2B_SW_bin", 0, FirmwareType::Zip},
+			{ChipID::RADA2B_REVB_ZCHIP, false, "ZCHIP", "RADA2B_REVB_SW_bin", 0, FirmwareType::Zip}
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RADA2B_ZCHIP, BootloaderCommunication::RAD)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
 protected:
 	RADA2B(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADA2BSettings, Disk::NeoMemoryDiskDriver, Disk::NeoMemoryDiskDriver>(makeDriver);
 	}
 
+
+
 	void setupPacketizer(Packetizer& packetizer) override {
 		Device::setupPacketizer(packetizer);
 		packetizer.disableChecksum = true;

include/icsneo/device/tree/radcomet/radcometbase.h

@@ -30,6 +30,25 @@ public:
 	bool getEthPhyRegControlSupported() const override { return true; }
 	bool supportsGPTP() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADComet;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADComet_ZYNQ, true, "ZCHIP", "RADComet_SW_bin", 0, FirmwareType::Zip},
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override { 
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RADComet_ZYNQ, BootloaderCommunication::RAD)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
+
 protected:
 	using Device::Device;
 

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

@@ -54,6 +54,25 @@ public:
 	bool supportsTC10() const override { return true; }
 	bool supportsGPTP() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADComet3;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADCOMET3_ZCHIP, true, "ZCHIP", "RADComet3_SW_bin", 0, FirmwareType::Zip},
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RADCOMET3_ZCHIP, BootloaderCommunication::RAD)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
+
 protected:
 	RADComet3(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADComet3Settings>(makeDriver);

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

@@ -29,6 +29,24 @@ public:
 
 	bool getEthPhyRegControlSupported() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADEpsilon;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADEpsilon_MCHIP, true, "MCHIP", "epsilon_mchip_ief", 0, FirmwareType::IEF},
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RADEpsilon_MCHIP, BootloaderCommunication::RED)
+			.add<ReconnectPhase>();
+	}
+
 protected:
 	RADEpsilon(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADEpsilonSettings, Disk::NeoMemoryDiskDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/radepsilonxl/radepsilonxl.h

@@ -28,6 +28,23 @@ public:
 	bool supportsComponentVersions() const override { return true; }
 
 	bool getEthPhyRegControlSupported() const override { return true; }
+	ProductID getProductID() const override {
+		return ProductID::RADEpsilon;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADProxima_MCHIP, true, "MCHIP", "epsilon_mchip_ief", 0, FirmwareType::IEF},
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RADProxima_MCHIP, BootloaderCommunication::RED)
+			.add<ReconnectPhase>();
+	}
 
 protected:
 	RADEpsilonXL(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
@@ -58,6 +75,10 @@ protected:
 	bool supportsEraseMemory() const override {
 		return true;
 	}
+
+	size_t getDiskCount() const override {
+		return 1;
+	}
 };
 
 }; // namespace icsneo

include/icsneo/device/tree/radgalaxy/radgalaxy.h

@@ -63,6 +63,26 @@ public:
 	size_t getEthernetActivationLineCount() const override { return 1; }
 	bool supportsGPTP() const override { return true; }
 
+
+	ProductID getProductID() const override {
+		return ProductID::RADGalaxy;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADGalaxy_ZYNQ, true, "ZCHIP", "RADGalaxy_SG2_SW_bin", 0, FirmwareType::Zip},
+			{ChipID::RADGalaxy_FFG_Zynq, false, "ZCHIP", "RADGalaxy_SG2_FFG_SW_bin", 0, FirmwareType::Zip}
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RADGalaxy_ZYNQ, BootloaderCommunication::RAD)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
 protected:
 	RADGalaxy(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADGalaxySettings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/radgalaxy2/radgalaxy2.h

@@ -67,6 +67,28 @@ public:
 	bool supportsTC10() const override { return true; }
 	bool supportsGPTP() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADGalaxy2;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RAD_GALAXY_2_ZMPCHIP_ID, true, "ZCHIP", "RADGalaxy2_SW_bin_p1", {"RADGalaxy2_SW_bin_p1",  "RADGalaxy2_SW_bin_p2"}, 0, FirmwareType::Zip},
+			{ChipID::RADGALAXY2_SYSMON_CHIP, true, "MCHIP", "galaxy2_sysmon_ief", 1, FirmwareType::IEF}
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RAD_GALAXY_2_ZMPCHIP_ID, BootloaderCommunication::RAD)
+			.add<ReconnectPhase>()
+			.add<FlashPhase>(ChipID::RADGALAXY2_SYSMON_CHIP, BootloaderCommunication::RADGalaxy2Peripheral)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
+
 protected:
 	RADGalaxy2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADGalaxy2Settings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/radgigastar/radgigastar.h

@@ -24,6 +24,88 @@ public:
 	bool supportsTC10() const override { return true; }
 	bool supportsGPTP() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADGigastar;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADGigastar_ZYNQ, true, "ZCHIP", "RADGigastar2_T1S_LIN_SW_bin", 1, FirmwareType::Zip},
+			{ChipID::RADGigastar_FFG_ZYNQ, false, "ZCHIP", "RADGigastar_FFG_SW_bin", 1, FirmwareType::Zip},
+			{ChipID::RADGigastar_USBZ_ZYNQ, true, "USB ZCHIP", "RADGigastar_USBz_SW_bin", 2, FirmwareType::Zip},
+			{ChipID::RADGigastar_USBZ_Z7010_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7010_SW_bin", 2, FirmwareType::Zip},
+			{ChipID::RADGigastar_USBZ_Z7007S_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7007s_SW_bin", 2, FirmwareType::Zip},
+		};
+		return chips;
+	}
+
+	BootloaderPipeline getBootloader() override {
+		if(supportsComponentVersions()) {
+			auto chipVersions = getChipVersions();
+			auto mainVersion = std::find_if(chipVersions.begin(), chipVersions.end(), [](const auto& ver) { return ver.name == "ZCHIP"; });
+			if(mainVersion != chipVersions.end()) {
+				static constexpr uint8_t NewBootloaderMajor = 0;
+				static constexpr uint8_t NewBootloaderMinor = 0;
+
+				if(
+					mainVersion->major > NewBootloaderMajor || 
+					(mainVersion->major == NewBootloaderMajor && mainVersion->minor > NewBootloaderMinor)
+				) {
+					BootloaderPipeline pipeline;
+					for(const auto& version : chipVersions) {
+						pipeline.add<FlashPhase>(version.id, BootloaderCommunication::RADMultiChip);
+					}
+					pipeline.add<ReconnectPhase>();
+					pipeline.add<WaitPhase>(std::chrono::milliseconds(3000));
+					return pipeline;
+				}
+			}
+		}
+		// If we've reached this point, then we use the legacy flashing
+		if(com->driver->isEthernet()) {
+			return BootloaderPipeline()
+				.add<FlashPhase>(ChipID::RADGigastar_ZYNQ, BootloaderCommunication::RAD)
+				.add<ReconnectPhase>()
+				.add<WaitPhase>(std::chrono::milliseconds(3000));
+		}
+		return BootloaderPipeline()
+			.add<FlashPhase>(ChipID::RADGigastar_USBZ_ZYNQ, BootloaderCommunication::RAD)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
+
+	std::vector<VersionReport> getChipVersions(bool refreshComponents = true) override {
+		if(refreshComponents) {
+			refreshComponentVersions();
+		}
+		if(supportsComponentVersions()) {
+			return Device::getChipVersions(false);
+		}
+		static constexpr size_t MainPeriphIndex = 1;
+		static constexpr size_t USBPeriphIndex = 2;
+
+		std::vector<VersionReport> chipVersions;
+		auto& appVersions = getVersions();
+
+		if(appVersions.size() < 3 && !appVersions.empty()) {
+			if(appVersions[0]) {
+				chipVersions.push_back({ChipID::RADGigastar_ZYNQ, "ZCHIP", appVersions[0]->major, appVersions[0]->minor, 0, 0});
+			}
+		} else {
+			if(MainPeriphIndex < appVersions.size()) {
+				if(appVersions[MainPeriphIndex]) {
+					chipVersions.push_back({ChipID::RADGigastar_ZYNQ, "ZCHIP", appVersions[MainPeriphIndex]->major, appVersions[MainPeriphIndex]->minor, 0, 0});
+				}
+			}
+			if(USBPeriphIndex < appVersions.size()) {
+				if(appVersions[USBPeriphIndex]) {
+					chipVersions.push_back({ChipID::RADGigastar_USBZ_ZYNQ, "USB ZCHIP", appVersions[USBPeriphIndex]->major, appVersions[USBPeriphIndex]->minor, 0, 0});
+				}
+			}
+		}
+		return chipVersions;
+	}
+
 protected:
 	RADGigastar(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADGigastarSettings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/radgigastar2/radgigastar2.h

@@ -12,138 +12,259 @@
 namespace icsneo
 {
 
-	class RADGigastar2 : public Device
-	{
-	public:
-		// Serial numbers start with GT
-		// USB PID is 0x1210, standard driver is DXX
-		// Ethernet MAC allocation is 0x22, standard driver is Raw
-		ICSNEO_FINDABLE_DEVICE(RADGigastar2, DeviceType::RADGigastar2, "GT");
-
-		static const std::vector<Network> &GetSupportedNetworks()
-		{
-			static std::vector<Network> supportedNetworks = {
-				Network::NetID::DWCAN_01,
-				Network::NetID::DWCAN_02,
-				Network::NetID::DWCAN_03,
-				Network::NetID::DWCAN_04,
-
-				Network::NetID::ETHERNET_01,
-				Network::NetID::ETHERNET_02,
-
-				Network::NetID::AE_01,
-				Network::NetID::AE_02,
-				Network::NetID::AE_03,
-				Network::NetID::AE_04,
-				Network::NetID::AE_05,
-				Network::NetID::AE_06,
-				Network::NetID::AE_07,
-				Network::NetID::AE_08,
-				Network::NetID::AE_09,
-				Network::NetID::AE_10,
-
-				Network::NetID::LIN_01,
-				Network::NetID::LIN_02,
-				Network::NetID::LIN_03,
-				Network::NetID::LIN_04,
-				Network::NetID::LIN_05,
-				Network::NetID::LIN_06,
-				Network::NetID::LIN_07,
-				Network::NetID::LIN_08,
-				Network::NetID::LIN_09,
-				Network::NetID::LIN_10,
-				Network::NetID::LIN_11,
-				Network::NetID::LIN_12,
-				Network::NetID::LIN_13,
-				Network::NetID::LIN_14,
-				Network::NetID::LIN_15,
-				Network::NetID::LIN_16,
-
-				Network::NetID::I2C_01,
-				Network::NetID::I2C_02,
-
-				Network::NetID::MDIO_01,
-				Network::NetID::MDIO_02,
-
-				Network::NetID::SPI_01,
-				Network::NetID::SPI_02,
-				Network::NetID::SPI_03,
-				Network::NetID::SPI_04,
-				Network::NetID::SPI_05,
-				Network::NetID::SPI_06,
-				Network::NetID::SPI_07,
-				Network::NetID::SPI_08,
-			};
-			return supportedNetworks;
-		}
-
-		size_t getEthernetActivationLineCount() const override { return 1; }
-
-		bool getEthPhyRegControlSupported() const override { return true; }
-
-		bool supportsTC10() const override { return true; }
-		bool supportsGPTP() const override { return true; }
-	
-	protected:
-		RADGigastar2(neodevice_t neodevice, const driver_factory_t &makeDriver) : Device(neodevice)
-		{
-			initialize<RADGigastar2Settings>(makeDriver);
-		}
-
-		void setupPacketizer(Packetizer &packetizer) override
-		{
-			Device::setupPacketizer(packetizer);
-			packetizer.disableChecksum = true;
-			packetizer.align16bit = false;
-		}
-
-		void setupDecoder(Decoder &decoder) override
-		{
-			Device::setupDecoder(decoder);
-			decoder.timestampResolution = 10; // Timestamps are in 10ns increments instead of the usual 25ns
-		}
-
-		void setupEncoder(Encoder &encoder) override
-		{
-			Device::setupEncoder(encoder);
-			encoder.supportCANFD = true;
-			encoder.supportEthPhy = true;
-		}
-
-		void setupSupportedRXNetworks(std::vector<Network> &rxNetworks) override
-		{
-			for (auto &netid : GetSupportedNetworks())
-				rxNetworks.emplace_back(netid);
-		}
-
-		// The supported TX networks are the same as the supported RX networks for this device
-		void setupSupportedTXNetworks(std::vector<Network> &txNetworks) override { setupSupportedRXNetworks(txNetworks); }
-
-		void handleDeviceStatus(const std::shared_ptr<RawMessage> &message) override
-		{
-			if (message->data.size() < sizeof(radgigastar2_status_t))
-				return;
-			std::lock_guard<std::mutex> lk(ioMutex);
-			const radgigastar2_status_t *status = reinterpret_cast<const radgigastar2_status_t *>(message->data.data());
-			ethActivationStatus = status->ethernetActivationLineEnabled;
-		}
-
-		std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override
-		{
-			return 512 * 4;
-		}
-
-		std::optional<MemoryAddress> getCoreminiStartAddressSD() const override
-		{
-			return 0;
-		}
-		
-		size_t getDiskCount() const override 
-		{
-			return 1;
-		}
+class RADGigastar2 : public Device {
+public:
+	enum class FirmwareVariant {
+		T1Sx6_CANx1_LINx16,
+		T1Sx8_CANx4_LINx6,
+		Invalid
 	};
 
+	// Serial numbers start with GT
+	// USB PID is 0x1210, standard driver is DXX
+	// Ethernet MAC allocation is 0x22, standard driver is Raw
+	ICSNEO_FINDABLE_DEVICE(RADGigastar2, DeviceType::RADGigastar2, "GT");
+
+	static const std::vector<Network> &GetSupportedNetworks()
+	{
+		static std::vector<Network> supportedNetworks = {
+			Network::NetID::DWCAN_01,
+			Network::NetID::DWCAN_02,
+			Network::NetID::DWCAN_03,
+			Network::NetID::DWCAN_04,
+
+			Network::NetID::ETHERNET_01,
+			Network::NetID::ETHERNET_02,
+
+			Network::NetID::AE_01,
+			Network::NetID::AE_02,
+			Network::NetID::AE_03,
+			Network::NetID::AE_04,
+			Network::NetID::AE_05,
+			Network::NetID::AE_06,
+			Network::NetID::AE_07,
+			Network::NetID::AE_08,
+			Network::NetID::AE_09,
+			Network::NetID::AE_10,
+
+			Network::NetID::LIN_01,
+			Network::NetID::LIN_02,
+			Network::NetID::LIN_03,
+			Network::NetID::LIN_04,
+			Network::NetID::LIN_05,
+			Network::NetID::LIN_06,
+			Network::NetID::LIN_07,
+			Network::NetID::LIN_08,
+			Network::NetID::LIN_09,
+			Network::NetID::LIN_10,
+			Network::NetID::LIN_11,
+			Network::NetID::LIN_12,
+			Network::NetID::LIN_13,
+			Network::NetID::LIN_14,
+			Network::NetID::LIN_15,
+			Network::NetID::LIN_16,
+
+			Network::NetID::I2C_01,
+			Network::NetID::I2C_02,
+
+			Network::NetID::MDIO_01,
+			Network::NetID::MDIO_02,
+
+			Network::NetID::SPI_01,
+			Network::NetID::SPI_02,
+			Network::NetID::SPI_03,
+			Network::NetID::SPI_04,
+			Network::NetID::SPI_05,
+			Network::NetID::SPI_06,
+			Network::NetID::SPI_07,
+			Network::NetID::SPI_08,
+		};
+		return supportedNetworks;
+	}
+
+	size_t getEthernetActivationLineCount() const override { return 1; }
+
+	bool getEthPhyRegControlSupported() const override { return true; }
+
+	bool supportsTC10() const override { return true; }
+	bool supportsGPTP() const override { return true; }
+
+	ProductID getProductID() const override {
+		return ProductID::RADGigastar2;
+	}
+
+	FirmwareVariant variantToFlash = FirmwareVariant::Invalid;
+	void setVariantToFlash(FirmwareVariant variant) {
+		variantToFlash = variant;
+	}
+
+	FirmwareVariant getCurrentVariant() {
+		if(supportsComponentVersions()) {
+			const auto& components = getComponentVersions();
+			for(const auto& component : components) {
+				if(!component.valid) {
+					continue;
+				}
+
+				if(component.identifier == static_cast<uint32_t>(ChipID::RADGigastar2_ZYNQ)) {
+					auto res = static_cast<FirmwareVariant>(std::clamp<uint8_t>(component.componentInfo, 0, 2));
+					if(variantToFlash == FirmwareVariant::Invalid) {
+						variantToFlash = res; // Set the variantToFlash if it hasn't been set yet, we always flash the same firmware variant as the current if it is unspecified
+					}
+					return res;
+				}
+			}
+		}
+		return FirmwareVariant::Invalid;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> linChips = {
+			{ChipID::RADGigastar2_ZYNQ, true, "ZCHIP", "RADGigastar2_T1S_LIN_SW_bin", 1, FirmwareType::Zip},
+			{ChipID::RADGigastar_USBZ_ZYNQ, true, "USB ZCHIP", "RADGigastar_USBz_SW_bin", 2, FirmwareType::Zip},
+			{ChipID::RADGigastar_USBZ_Z7010_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7010_SW_bin", 2, FirmwareType::Zip},
+			{ChipID::RADGigastar_USBZ_Z7007S_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7007s_SW_bin", 2, FirmwareType::Zip},
+		};
+
+		static std::vector<ChipInfo> t1sChips = {
+			{ChipID::RADGigastar2_ZYNQ, true, "ZCHIP", "RADGigastar2_T1S_CAN_SW_bin", 1, FirmwareType::Zip},
+			{ChipID::RADGigastar_USBZ_ZYNQ, true, "USB ZCHIP", "RADGigastar_USBz_SW_bin", 2, FirmwareType::Zip},
+			{ChipID::RADGigastar_USBZ_Z7010_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7010_SW_bin", 2, FirmwareType::Zip},
+			{ChipID::RADGigastar_USBZ_Z7007S_ZYNQ, false, "USB ZCHIP", "RADGigastar_USBz_Z7007s_SW_bin", 2, FirmwareType::Zip},
+		};
+		
+		if(variantToFlash == FirmwareVariant::T1Sx8_CANx4_LINx6) {
+			return t1sChips;
+		}
+		return linChips; // Assume linChips even if variantToFlash is invalid
+	}
+
+	BootloaderPipeline getBootloader() override {
+		if(supportsComponentVersions()) {
+			auto chipVersions = getChipVersions();
+			auto mainVersion = std::find_if(chipVersions.begin(), chipVersions.end(), [](const auto& ver) { return ver.name == "ZCHIP"; });
+			if(mainVersion != chipVersions.end()) {
+				static constexpr uint8_t NewBootloaderMajor = 0;
+				static constexpr uint8_t NewBootloaderMinor = 0;
+
+				if(
+					mainVersion->major > NewBootloaderMajor || 
+					(mainVersion->major == NewBootloaderMajor && mainVersion->minor > NewBootloaderMinor)
+				) {
+					BootloaderPipeline pipeline;
+					for(const auto& version : chipVersions) {
+						pipeline.add<FlashPhase>(version.id, BootloaderCommunication::RADMultiChip);
+					}
+					pipeline.add<ReconnectPhase>();
+					pipeline.add<WaitPhase>(std::chrono::milliseconds(3000));
+					return pipeline;
+				}
+			}
+		}
+		// If we've reached this point, then we use the legacy flashing
+		if(com->driver->isEthernet()) {
+			return BootloaderPipeline()
+				.add<FlashPhase>(ChipID::RADGigastar2_ZYNQ, BootloaderCommunication::RAD)
+				.add<ReconnectPhase>()
+				.add<WaitPhase>(std::chrono::milliseconds(3000));
+		}
+		return BootloaderPipeline()
+			.add<FlashPhase>(ChipID::RADGigastar_USBZ_ZYNQ, BootloaderCommunication::RAD)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
+
+	std::vector<VersionReport> getChipVersions(bool refreshComponents = true) override {
+		if(refreshComponents) {
+			refreshComponentVersions();
+		}
+		if(supportsComponentVersions()) {
+			return Device::getChipVersions(false);
+		}
+		static constexpr size_t MainPeriphIndex = 1;
+		static constexpr size_t USBPeriphIndex = 2;
+
+		std::vector<VersionReport> chipVersions;
+		auto& appVersions = getVersions();
+
+		if(appVersions.size() < 3 && !appVersions.empty()) {
+			if(appVersions[0]) {
+				chipVersions.push_back({ChipID::RADGigastar2_ZYNQ, "ZCHIP", appVersions[0]->major, appVersions[0]->minor, 0, 0});
+			}
+		} else {
+			if(MainPeriphIndex < appVersions.size()) {
+				if(appVersions[MainPeriphIndex]) {
+					chipVersions.push_back({ChipID::RADGigastar2_ZYNQ, "ZCHIP", appVersions[MainPeriphIndex]->major, appVersions[MainPeriphIndex]->minor, 0, 0});
+				}
+			}
+			if(USBPeriphIndex < appVersions.size()) {
+				if(appVersions[USBPeriphIndex]) {
+					chipVersions.push_back({ChipID::RADGigastar_USBZ_ZYNQ, "USB ZCHIP", appVersions[USBPeriphIndex]->major, appVersions[USBPeriphIndex]->minor, 0, 0});
+				}
+			}
+		}
+		return chipVersions;
+	}
+protected:
+	RADGigastar2(neodevice_t neodevice, const driver_factory_t &makeDriver) : Device(neodevice)
+	{
+		initialize<RADGigastar2Settings>(makeDriver);
+	}
+
+	void setupPacketizer(Packetizer &packetizer) override
+	{
+		Device::setupPacketizer(packetizer);
+		packetizer.disableChecksum = true;
+		packetizer.align16bit = false;
+	}
+
+	void setupDecoder(Decoder &decoder) override
+	{
+		Device::setupDecoder(decoder);
+		decoder.timestampResolution = 10; // Timestamps are in 10ns increments instead of the usual 25ns
+	}
+
+	void setupEncoder(Encoder &encoder) override
+	{
+		Device::setupEncoder(encoder);
+		encoder.supportCANFD = true;
+		encoder.supportEthPhy = true;
+	}
+
+	void setupSupportedRXNetworks(std::vector<Network> &rxNetworks) override
+	{
+		for (auto &netid : GetSupportedNetworks())
+			rxNetworks.emplace_back(netid);
+	}
+
+	// The supported TX networks are the same as the supported RX networks for this device
+	void setupSupportedTXNetworks(std::vector<Network> &txNetworks) override { setupSupportedRXNetworks(txNetworks); }
+
+	void handleDeviceStatus(const std::shared_ptr<RawMessage> &message) override
+	{
+		if (message->data.size() < sizeof(radgigastar2_status_t))
+			return;
+		std::lock_guard<std::mutex> lk(ioMutex);
+		const radgigastar2_status_t *status = reinterpret_cast<const radgigastar2_status_t *>(message->data.data());
+		ethActivationStatus = status->ethernetActivationLineEnabled;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressFlash() const override
+	{
+		return 512 * 4;
+	}
+
+	std::optional<MemoryAddress> getCoreminiStartAddressSD() const override
+	{
+		return 0;
+	}
+	
+	size_t getDiskCount() const override 
+	{
+		return 1;
+	}
+};
+
 }
 
 #endif // __cplusplus

include/icsneo/device/tree/radjupiter/radjupiter.h

@@ -29,6 +29,10 @@ public:
 
 	bool getEthPhyRegControlSupported() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADJupiter;
+	}
+
 protected:
 	RADJupiter(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADJupiterSettings>(makeDriver);

include/icsneo/device/tree/radmars/radmars.h

@@ -21,6 +21,9 @@ public:
 	size_t getEthernetActivationLineCount() const override { return 1; }
 	bool supportsGPTP() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADMars;
+	}
 protected:
 	RADMars(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADMarsSettings, Disk::ExtExtractorDiskReadDriver, Disk::NeoMemoryDiskDriver>(makeDriver);

include/icsneo/device/tree/radmoon2/radmoon2.h

@@ -16,6 +16,26 @@ public:
 
 	uint8_t getPhyAddrOrPort() const override { return 6; };
 
+
+	ProductID getProductID() const override {
+		return ProductID::RADMoon2;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADMoon2_ZYNQ, true, "ZCHIP", "RADMoon2_SW_bin", 0, FirmwareType::Zip},
+			{ChipID::RADMoon2_Z7010_ZYNQ, false, "ZCHIP", "RADMoon2_Z7010_SW_bin", 0, FirmwareType::Zip}
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RADMoon2_ZYNQ, BootloaderCommunication::RAD)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
 protected:
 	RADMoon2(neodevice_t neodevice, const driver_factory_t& makeDriver) : RADMoon2Base(neodevice) {
 		initialize<RADMoon2Settings>(makeDriver);

include/icsneo/device/tree/radmoon2/radmoon2zl.h

@@ -18,6 +18,23 @@ public:
 
 	bool supportsTC10() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADMoon2;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADMoon2_ZL_MCHIP, true, "MCHIP", "radmoon2_zl_mchip_ief", 0, FirmwareType::IEF}
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RADMoon2_ZL_MCHIP, BootloaderCommunication::RED)
+			.add<ReconnectPhase>();
+	}
 protected:
 	RADMoon2ZL(neodevice_t neodevice, const driver_factory_t& makeDriver) : RADMoon2Base(neodevice) {
 		initialize<RADMoon2Settings>(makeDriver);

include/icsneo/device/tree/radmoon3/radmoon3.h

@@ -30,6 +30,24 @@ public:
 
 	bool supportsTC10() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADMoon3;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::RADMoon3_MCHIP, true, "MCHIP", "radmoon3_mchip_ief", 0, FirmwareType::IEF},
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::RADMoon3_MCHIP, BootloaderCommunication::RED)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
 protected:
 	RADMoon3(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADMoon3Settings>(makeDriver);

include/icsneo/device/tree/radmoonduo/radmoonduo.h

@@ -25,6 +25,10 @@ public:
 
 	bool getEthPhyRegControlSupported() const override { return true; }
 
+
+	ProductID getProductID() const override {
+		return ProductID::RADMoonDuo;
+	}
 protected:
 	RADMoonDuo(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADMoonDuoSettings>(makeDriver);

include/icsneo/device/tree/radmoont1s/radmoont1s.h

@@ -34,6 +34,9 @@ public:
 
 	bool supportsTC10() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADMoonT1S;
+	}
 protected:
 	RADMoonT1S(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADMoonT1SSettings>(makeDriver);

include/icsneo/device/tree/radpluto/radpluto.h

@@ -34,6 +34,9 @@ public:
 
 	bool getEthPhyRegControlSupported() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADPluto;
+	}
 protected:
 	RADPluto(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADPlutoSettings>(makeDriver);

include/icsneo/device/tree/radstar2/radstar2.h

@@ -32,6 +32,9 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::RADStar2;
+	}
 protected:
 	RADStar2(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADStar2Settings>(makeDriver);

include/icsneo/device/tree/radsupermoon/radsupermoon.h

@@ -50,6 +50,9 @@ public:
 
 	bool getEthPhyRegControlSupported() const override { return true; }
 
+	ProductID getProductID() const override {
+		return ProductID::RADSupermoon;
+	}
 protected:
 	RADSupermoon(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<RADSupermoonSettings>(makeDriver);

include/icsneo/device/tree/valuecan3/valuecan3.h

@@ -22,6 +22,9 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::ValueCAN3;
+	}
 private:
 	ValueCAN3(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<ValueCAN3Settings>(makeDriver);

include/icsneo/device/tree/valuecan4/valuecan4-1.h

@@ -21,6 +21,24 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::ValueCAN4_1_2;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::ValueCAN4_1_MCHIP, true, "MCHIP", "vcan41_mchip_ief", 0, FirmwareType::IEF},
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::ValueCAN4_1_MCHIP, BootloaderCommunication::RED)
+			.add<ReconnectPhase>();
+	}
+
 protected:
 	ValueCAN4_1(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
 		initialize<ValueCAN4_1Settings>(makeDriver);

include/icsneo/device/tree/valuecan4/valuecan4-2.h

@@ -46,6 +46,25 @@ public:
 		return Device::getProductName();
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::ValueCAN4_1_2;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::ValueCAN4_2_MCHIP, true, "MCHIP", "vcan42_mchip_ief", 0, FirmwareType::IEF},
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::ValueCAN4_2_MCHIP, BootloaderCommunication::RED)
+			.add<ReconnectPhase>()
+			.add<WaitPhase>(std::chrono::milliseconds(3000));
+	}
+
 protected:
 	ValueCAN4_2(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
 		initialize<ValueCAN4_2Settings>(makeDriver);

include/icsneo/device/tree/valuecan4/valuecan4-2el.h

@@ -60,6 +60,25 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::ValueCAN4_2EL_4;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::ValueCAN4_2EL_MCHIP, true, "MCHIP", "vcan44_mchip_ief", 0, FirmwareType::IEF}
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::ValueCAN4_2EL_MCHIP, BootloaderCommunication::RED)
+			.add<ReconnectPhase>();
+	}
+
+
 protected:
 	ValueCAN4_2EL(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
 		initialize<ValueCAN4_2ELSettings>(makeDriver);

include/icsneo/device/tree/valuecan4/valuecan4-4.h

@@ -57,6 +57,25 @@ public:
 		return Device::getProductName();
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::ValueCAN4_2EL_4;
+	}
+
+	const std::vector<ChipInfo>& getChipInfo() const override {
+		static std::vector<ChipInfo> chips = {
+			{ChipID::ValueCAN4_4_MCHIP, true, "MCHIP", "vcan44_mchip_ief", 0, FirmwareType::IEF},
+			{ChipID::ValueCAN4_4_SCHIP, true, "SCHIP", "vcan44_schip_ief", 1, FirmwareType::IEF}
+		};
+		return chips;
+	}
+	
+	BootloaderPipeline getBootloader() override {
+		return BootloaderPipeline()
+			.add<EnterBootloaderPhase>()
+			.add<FlashPhase>(ChipID::ValueCAN4_4_MCHIP, BootloaderCommunication::RED)
+			.add<FlashPhase>(ChipID::ValueCAN4_4_SCHIP, BootloaderCommunication::RED, false, true)
+			.add<ReconnectPhase>();
+	}
 protected:
 	ValueCAN4_4(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
 		initialize<ValueCAN4_4Settings>(makeDriver);

include/icsneo/device/tree/valuecan4/valuecan4industrial.h

@@ -27,6 +27,9 @@ public:
 		return supportedNetworks;
 	}
 
+	ProductID getProductID() const override {
+		return ProductID::ValueCAN4Industrial;
+	}
 protected:
 	ValueCAN4Industrial(neodevice_t neodevice, const driver_factory_t& makeDriver) : ValueCAN4(neodevice) {
 		initialize<ValueCAN4IndustrialSettings>(makeDriver);

include/icsneo/device/tree/vividcan/vividcan.h

@@ -28,6 +28,10 @@ public:
 	}
 
 	bool isOnlineSupported() const override { return false; }
+
+	ProductID getProductID() const override {
+		return ProductID::VividCAN;
+	}
 protected:
 	VividCAN(neodevice_t neodevice, const driver_factory_t& makeDriver) : Device(neodevice) {
 		initialize<VividCANSettings>(makeDriver);