CI: Deploy: Also push git history

CI: Adjust twine upload args
CI: Add tag upload & deploy
2026-11-04 12:59:07 +01:00 · 2026-11-01 18:04:33 -05:00 · 2026-11-01 11:28:02 -05:00 · 2026-10-31 11:24:38 -04:00 · 2026-10-29 12:33:38 -04:00 · 2026-10-23 12:42:08 -04:00
189 changed files with 17496 additions and 8217 deletions
@@ -1,3 +1,6 @@
+default:
+  interruptible: true
+
 variables:
  DEBIAN_FRONTEND: noninteractive
  LIBICSNEO_ICSPB_REPO: https://gitlab-ci-token:${CI_JOB_TOKEN}@${LIBICSNEO_ICSPB_GIT}
@@ -44,7 +47,7 @@ unit_test windows/x64:
  script:
    - apt update -y
    - apt upgrade -y
-    - apt install -y g++ ninja-build cmake libpcap-dev git ca-certificates
+    - apt install -y g++ ninja-build cmake git ca-certificates
    - echo "$ICS_IPA_CA_CRT" >/usr/local/share/ca-certificates/ica-ipa-ca.crt
    - update-ca-certificates --fresh
    - sh ci/build-posix.sh
@@ -61,7 +64,6 @@ unit_test windows/x64:
  script:
    - apt update -y
    - apt upgrade -y
-    - apt install -y libpcap-dev
    - build/libicsneo-unit-tests
  tags:
    - linux-build
@@ -72,7 +74,7 @@ unit_test windows/x64:
  script:
    - apt update -y
    - apt upgrade -y
-    - apt install -y clang lld ninja-build cmake libpcap-dev git ca-certificates
+    - apt install -y clang lld ninja-build cmake git ca-certificates
    - echo "$ICS_IPA_CA_CRT" >/usr/local/share/ca-certificates/ica-ipa-ca.crt
    - update-ca-certificates --fresh
    - CC=clang CXX=clang++ LDFLAGS=-fuse-ld=lld sh ci/build-posix.sh
@@ -89,7 +91,6 @@ unit_test windows/x64:
  script:
    - apt update -y
    - apt upgrade -y
-    - apt install -y libpcap-dev
    - build/libicsneo-unit-tests
  tags:
    - linux-build
@@ -156,7 +157,7 @@ unit_test linux/ubuntu/2604/amd64/clang:
    - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
    - echo fastestmirror=True >>/etc/dnf/dnf.conf
    - dnf upgrade -y
-    - dnf install -y g++ libpcap-devel cmake ninja-build git ca-certificates
+    - dnf install -y g++ cmake ninja-build git ca-certificates
    - echo "$ICS_IPA_CA_CRT" >/etc/pki/ca-trust/source/anchors/ica-ipa-ca.crt
    - update-ca-trust
    - sh ci/build-posix.sh
@@ -177,7 +178,6 @@ unit_test linux/ubuntu/2604/amd64/clang:
    - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
    - echo fastestmirror=True >>/etc/dnf/dnf.conf
    - dnf upgrade -y
-    - dnf install -y libpcap-devel
    - build/libicsneo-unit-tests
  tags:
    - linux-build
@@ -192,7 +192,7 @@ unit_test linux/ubuntu/2604/amd64/clang:
    - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
    - echo fastestmirror=True >>/etc/dnf/dnf.conf
    - dnf upgrade -y
-    - dnf install -y clang lld libpcap-devel cmake ninja-build git ca-certificates
+    - dnf install -y clang lld cmake ninja-build git ca-certificates
    - echo "$ICS_IPA_CA_CRT" >/etc/pki/ca-trust/source/anchors/ica-ipa-ca.crt
    - update-ca-trust
    - CC=clang CXX=clang++ LDFLAGS=-fuse-ld=lld sh ci/build-posix.sh
@@ -213,7 +213,6 @@ unit_test linux/ubuntu/2604/amd64/clang:
    - echo max_parallel_downloads=10 >>/etc/dnf/dnf.conf
    - echo fastestmirror=True >>/etc/dnf/dnf.conf
    - dnf upgrade -y
-    - dnf install -y libpcap-devel
    - build/libicsneo-unit-tests
  tags:
    - linux-build
@@ -276,13 +275,9 @@ build python/linux/amd64:
  tags:
    - linux-native-amd64
  variables:
-    CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
-    CIBW_BUILD: "*manylinux*" # no musl
    CIBW_ARCHS: x86_64
-    CIBW_ENVIRONMENT: PCAP_ROOT=/project/libpcap/install
-    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=/project/icspb
  script:
-    - sh ci/build-wheel-posix.sh
+    - sh ci/build-wheel-linux.sh
  artifacts:
    paths:
      - wheelhouse
@@ -292,13 +287,9 @@ build python/linux/arm64:
  tags:
    - arm64-linux-build
  variables:
-    CIBW_BEFORE_ALL: sh ci/bootstrap-cibuildwheel.sh && sh ci/bootstrap-libpcap.sh
-    CIBW_BUILD: "*manylinux*" # no musl
    CIBW_ARCHS: aarch64
-    CIBW_ENVIRONMENT: PCAP_ROOT=/project/libpcap/install
-    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=/project/icspb
  script:
-    - sh ci/build-wheel-posix.sh
+    - sh ci/build-wheel-linux.sh
  artifacts:
    paths:
      - wheelhouse
@@ -307,14 +298,8 @@ build python/macos:
  stage: build
  tags:
    - macos-arm64
-  variables:
-    CIBW_BEFORE_ALL: sh ci/bootstrap-libpcap.sh
-    CIBW_ARCHS: arm64
-    CIBW_ENVIRONMENT: PCAP_ROOT=$CI_PROJECT_DIR/libpcap/install
-    SKBUILD_CMAKE_DEFINE: ICSPB_BOOTSTRAP_DIR=$CI_PROJECT_DIR/icspb
-    MACOSX_DEPLOYMENT_TARGET: 10.14
  script:
-    - sh ci/build-wheel-posix.sh
+    - sh ci/build-wheel-macos.sh
  artifacts:
    paths:
      - wheelhouse
@@ -335,6 +320,7 @@ build python/windows:

 deploy python/pypi:
  stage: deploy
+  interruptible: false
  variables:
    TWINE_USERNAME: __token__
    TWINE_PASSWORD: $PYPI_TOKEN
@@ -343,9 +329,10 @@ deploy python/pypi:
  image: python:3.13
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+    - if: $CI_COMMIT_TAG
  script:
    - python3 -m pip install -U twine
-    - twine upload wheelhouse/*
+    - twine upload --verbose wheelhouse/*
  dependencies:
    - build python/linux/amd64
    - build python/linux/arm64
@@ -359,6 +346,7 @@ deploy python/pypi:

 push github:
  stage: deploy
+  interruptible: false
  tags:
    - linux-build
  image: alpine:latest
@@ -366,10 +354,17 @@ push github:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
      when: delayed
      start_in: 10 minutes
+      variables:
+        REFSPEC: HEAD:master
+    - if: $CI_COMMIT_TAG
+      when: delayed
+      start_in: 10 minutes
+      variables:
+        REFSPEC: $CI_COMMIT_TAG
  dependencies:
    - deploy python/pypi
  needs:
    - deploy python/pypi
  script:
    - apk add git
-    - git push https://$LIBICSNEO_GITHUB_USERNAME:$LIBICSNEO_GITHUB_TOKEN@github.com/intrepidcs/libicsneo.git HEAD:master
+    - git push https://$LIBICSNEO_GITHUB_USERNAME:$LIBICSNEO_GITHUB_TOKEN@github.com/intrepidcs/libicsneo.git $REFSPEC
@@ -1,10 +0,0 @@
-# Intrepid Control System, Inc. neoVI Devices
-SUBSYSTEM=="usb", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
-KERNEL=="ttyUSB?", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
-KERNEL=="ttyACM?", ATTRS{idVendor}=="093c", GROUP="users", MODE="0666"
-
-ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idVendor}=="093c", KERNEL=="ttyUSB*", \
-RUN+="/bin/sh -c 'echo $id:1.0>/sys/bus/usb/drivers/ftdi_sio/unbind'"
-
-ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idVendor}=="093c", DRIVER=="usbhid", \
-RUN+="/bin/sh -c 'echo $id:1.0>/sys/bus/usb/drivers/usbhid/unbind'"
@@ -53,22 +53,20 @@ option(LIBICSNEO_BUILD_ICSNEOC2 "Build dynamic C2 library" ON)
 option(LIBICSNEO_BUILD_ICSNEOC2_STATIC "Build static C2 library" ON)
 option(LIBICSNEO_BUILD_ICSNEOLEGACY "Build icsnVC40 compatibility library" ON)
 option(LIBICSNEO_BUILD_ICSNEOLEGACY_STATIC "Build static icsnVC40 compatibility library" ON)
-set(LIBICSNEO_NPCAP_INCLUDE_DIR "" CACHE STRING "Npcap include directory; set to build with Npcap")

 # Device Drivers
 # You almost certainly don't want firmio for your build,
 # it is only relevant for communication between Linux and
 # CoreMini from the onboard processor of the device.
 option(LIBICSNEO_ENABLE_FIRMIO "Enable communication between Linux and CoreMini within the same device" OFF)
-option(LIBICSNEO_ENABLE_RAW_ETHERNET "Enable devices which communicate over raw ethernet" ON)
-option(LIBICSNEO_ENABLE_CDCACM "Enable devices which communicate over USB CDC ACM" ON)
-option(LIBICSNEO_ENABLE_TCP "Enable devices which communicate over TCP" OFF)
-option(LIBICSNEO_ENABLE_DXX "Enable devices which communicate over D2XX/D3XX via libredxx" ON)

 option(LIBICSNEO_ENABLE_BINDINGS_PYTHON "Enable Python library" OFF)

+option(LIBICSNEO_ENABLE_BOOTLOADER "Enable bootloader firmware update support" OFF)
+
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded")
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)

 include(GNUInstallDirs)

@@ -142,82 +140,10 @@ if(LIBICSNEO_BUILD_DOCS)
 	endif()
 endif()

-if(WIN32)
-	set(PLATFORM_SRC
-		platform/windows/strings.cpp
-		platform/windows/registry.cpp
-	)
-
-	if(LIBICSNEO_ENABLE_RAW_ETHERNET)
-		list(APPEND PLATFORM_SRC
-			platform/windows/pcap.cpp
-			platform/windows/internal/pcapdll.cpp
-		)
-	endif()
-
-	if(LIBICSNEO_ENABLE_CDCACM)
-		list(APPEND PLATFORM_SRC
-			platform/windows/cdcacm.cpp
-		)
-	endif()
-else() # Darwin or Linux
-	set(PLATFORM_SRC)
-
-	if(LIBICSNEO_ENABLE_FIRMIO)
-		list(APPEND PLATFORM_SRC
-			platform/posix/firmio.cpp
-		)
-	endif()
-
-	if(LIBICSNEO_ENABLE_RAW_ETHERNET)
-		list(APPEND PLATFORM_SRC
-			platform/posix/pcap.cpp
-		)
-	endif()
-
-	if(LIBICSNEO_ENABLE_CDCACM)
-		list(APPEND PLATFORM_SRC
-			platform/posix/cdcacm.cpp
-		)
-
-		if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-			list(APPEND PLATFORM_SRC
-				platform/posix/darwin/cdcacmdarwin.cpp
-			)
-		else() # Linux or other
-			list(APPEND PLATFORM_SRC
-				platform/posix/linux/cdcacmlinux.cpp
-			)
-			if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-				message(WARNING
-					"There is no CDCACM platform port defined for ${CMAKE_SYSTEM_NAME}!\n"
-					"The Linux platform code will be used, as it will generally allow building, but some devices may not enumerate properly."
-				)
-			endif()
-		endif()
-	endif()
+if(LIBICSNEO_ENABLE_FIRMIO AND NOT WIN32)
+	set(PLATFORM_SRC platform/posix/firmio.cpp)
 endif()

-if(LIBICSNEO_ENABLE_DXX)
-	list(APPEND PLATFORM_SRC
-		platform/dxx.cpp
-	)
-endif()
-
-if(LIBICSNEO_ENABLE_TCP)
-	list(APPEND PLATFORM_SRC
-		platform/tcp.cpp
-	)
-endif()
-
-# Extensions
-set(LIBICSNEO_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-foreach(EXT_PATH ${LIBICSNEO_EXTENSION_DIRS})
-	get_filename_component(EXT_DIR ${EXT_PATH} NAME)
-	message("Adding extension " ${EXT_DIR})
-	add_subdirectory(${EXT_PATH} ${CMAKE_CURRENT_BINARY_DIR}/${EXT_DIR})
-endforeach()
-
 set(SRC_FILES
 	communication/message/flexray/control/flexraycontrolmessage.cpp
 	communication/message/callback/streamoutput/a2bwavoutput.cpp
@@ -234,8 +160,14 @@ set(SRC_FILES
 	communication/message/ethernetstatusmessage.cpp
 	communication/message/networkmutexmessage.cpp
 	communication/message/clientidmessage.cpp
+	communication/message/mfgconfigmessage.cpp
 	communication/message/transmitmessage.cpp
+
+
 	communication/message/spiportkeymessage.cpp
+	communication/message/genericapidatamessage.cpp
+	communication/message/genericapistatusmessage.cpp
+	communication/message/iso15765message.cpp
 	communication/packet/flexraypacket.cpp
 	communication/packet/canpacket.cpp
 	communication/packet/a2bpacket.cpp
@@ -300,6 +232,28 @@ set(SRC_FILES
 	${PLATFORM_SRC}
 )

+if(LIBICSNEO_ENABLE_BOOTLOADER)
+	list(APPEND SRC_FILES
+		device/extensions/bootloader/api.cpp
+		device/extensions/bootloader/version.cpp
+		device/extensions/bootloader/platform/logging.cpp
+		device/extensions/bootloader/parser/ief.cpp
+		device/extensions/bootloader/parser/fwzip.cpp
+		device/extensions/bootloader/parser/fwbin.cpp
+		device/extensions/bootloader/parser/fwbundle.cpp
+		device/extensions/bootloader/parser/fwloader.cpp
+		device/extensions/bootloader/communication/red.cpp
+		device/extensions/bootloader/communication/radmultichipcommunication.cpp
+		device/extensions/bootloader/communication/communication.cpp
+		device/extensions/bootloader/communication/radperiphcommunication.cpp
+		device/extensions/bootloader/communication/radcommunication.cpp
+		device/extensions/bootloader/communication/redpacketizer.cpp
+		device/extensions/bootloader/communication/redcore.cpp
+		device/extensions/bootloader/communication/application.cpp
+		device/extensions/bootloader/communication/redbase.cpp
+	)
+endif()
+
 # Generate build info header
 execute_process(
 	COMMAND git rev-parse --abbrev-ref HEAD
@@ -329,17 +283,6 @@ configure_file(api/icsneocpp/buildinfo.h.template ${CMAKE_CURRENT_BINARY_DIR}/ge
 configure_file(api/icsneoc/version.rc.template ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc/version.rc)
 configure_file(api/icsneoc2/version.rc.template ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc2/version.rc)

-foreach(EXTINC ${LIBICSNEO_EXTENSION_INCLUDES})
-	message("Including " ${EXTINC})
-	list(APPEND LIBICSNEO_EXT_CODE_INCS_LIST "#include \"${EXTINC}\"")
-endforeach()
-list(JOIN LIBICSNEO_EXT_CODE_INCS_LIST "\n" LIBICSNEO_EXT_CODE_INCS)
-foreach(EXTCLASS ${LIBICSNEO_EXTENSION_CLASSES})
-	list(APPEND LIBICSNEO_EXT_CODE_LIST "device->addExtension(std::make_shared<${EXTCLASS}>(*device))\;")
-endforeach()
-list(JOIN LIBICSNEO_EXT_CODE_LIST "\n\t" LIBICSNEO_EXT_CODE)
-configure_file(include/icsneo/device/extensions/builtin.h.template ${CMAKE_CURRENT_BINARY_DIR}/generated/extensions/builtin.h)
-
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR})

 add_library(icsneocpp
@@ -350,78 +293,24 @@ add_library(icsneocpp
 	api/icsneocpp/version.cpp
 	${SRC_FILES}
 )
-message("Include paths " ${LIBICSNEO_EXTENSION_INCLUDE_PATHS})
 target_include_directories(icsneocpp
 	PUBLIC
 		$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
 		$<INSTALL_INTERFACE:>
 	PRIVATE
 		${CMAKE_CURRENT_SOURCE_DIR}/include
-		${LIBICSNEO_EXTENSION_INCLUDE_PATHS}
 )
 target_link_libraries(icsneocpp PUBLIC Threads::Threads $<$<BOOL:${WIN32}>:ws2_32 iphlpapi>)
-set_property(TARGET icsneocpp PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_compile_features(icsneocpp PUBLIC cxx_auto_type cxx_constexpr cxx_lambdas cxx_nullptr cxx_range_for cxx_rvalue_references cxx_sizeof_member cxx_strong_enums)
 target_compile_options(icsneocpp PRIVATE ${LIBICSNEO_COMPILER_WARNINGS})
-message("Loaded extensions: " ${LIBICSNEO_EXTENSION_TARGETS})
-target_link_libraries(icsneocpp PUBLIC ${LIBICSNEO_EXTENSION_TARGETS})
 if(LIBICSNEO_ENABLE_FIRMIO)
 	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_FIRMIO)
 endif()
-if(LIBICSNEO_ENABLE_RAW_ETHERNET)
-	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_RAW_ETHERNET)
-endif()
-if(LIBICSNEO_ENABLE_CDCACM)
-	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_CDCACM)
-	if(APPLE)
-		find_library(CORE_FOUNDATION_FRAMEWORK CoreFoundation REQUIRED)
-		find_library(IO_KIT_FRAMEWORK IOKit REQUIRED)
-		target_link_libraries(icsneocpp PRIVATE ${CORE_FOUNDATION_FRAMEWORK} ${IO_KIT_FRAMEWORK})
-	endif()
-endif()
-if(LIBICSNEO_ENABLE_DXX)
-	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_DXX)
-	target_link_libraries(icsneocpp PRIVATE libredxx::libredxx)
-endif()
-if(LIBICSNEO_ENABLE_TCP)
-	target_compile_definitions(icsneocpp PRIVATE ICSNEO_ENABLE_TCP)
-	if(WIN32)
-		target_link_libraries(icsneocpp PRIVATE ws2_32 iphlpapi)
-	endif()
-endif()

 # fatfs
 add_subdirectory(third-party/fatfs)
-set_property(TARGET fatfs PROPERTY POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(icsneocpp PRIVATE fatfs)

-# dxx
-if(LIBICSNEO_ENABLE_DXX)
-	include(FetchContent)
-	FetchContent_Declare(libredxx
-		GIT_REPOSITORY https://github.com/Zeranoe/libredxx.git
-		GIT_TAG e823a96c39a64ab41b7d1632dbe8f86bb854df83
-	)
-	set(LIBREDXX_DISABLE_INSTALL ON)
-	FetchContent_MakeAvailable(libredxx)
-endif()
-
-# pcap
-if(LIBICSNEO_ENABLE_RAW_ETHERNET)
-	if(WIN32)
-		if(LIBICSNEO_NPCAP_INCLUDE_DIR STREQUAL "")
-			target_include_directories(icsneocpp PUBLIC AFTER third-party/winpcap/include)
-			add_definitions(-DWPCAP -DHAVE_REMOTE)
-		else()
-			target_include_directories(icsneocpp PUBLIC AFTER ${LIBICSNEO_NPCAP_INCLUDE_DIR})
-		endif()
-	else()
-		find_package(PCAP REQUIRED)
-		target_include_directories(icsneocpp PUBLIC ${PCAP_INCLUDE_DIR})
-		target_link_libraries(icsneocpp PUBLIC ${PCAP_LIBRARY})
-	endif(WIN32)
-endif(LIBICSNEO_ENABLE_RAW_ETHERNET)
-
 # protobuf
 if(DEFINED ENV{LIBICSNEO_ICSPB_REPO})
 	set(LIBICSNEO_ICSPB_REPO "$ENV{LIBICSNEO_ICSPB_REPO}")
@@ -437,6 +326,59 @@ FetchContent_Declare(icspb
 FetchContent_MakeAvailable(icspb)
 target_link_libraries(icsneocpp PRIVATE icspb::icspb)

+# libicsbl
+if(LIBICSNEO_ENABLE_BOOTLOADER)
+	if(NOT LIBICSNEO_LIBICSBL_ZIP_URL)
+		if(DEFINED ENV{LIBICSNEO_LIBICSBL_ZIP_URL})
+			set(LIBICSNEO_LIBICSBL_ZIP_URL "$ENV{LIBICSNEO_LIBICSBL_ZIP_URL}")
+		else()
+			if(NOT LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX)
+				if(DEFINED ENV{LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX})
+					set(LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX "$ENV{LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}")
+				else()
+					set(LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX "https://cdn.intrepidcs.net/libicsbl/5ce699ada0ccaadb92cabda6e3537c09b333020e")
+				endif()
+			endif()
+			if(NOT LIBICSNEO_LIBICSBL_VERSION)
+				if(DEFINED ENV{LIBICSNEO_LIBICSBL_VERSION})
+					set(LIBICSNEO_LIBICSBL_VERSION "$ENV{LIBICSNEO_LIBICSBL_VERSION}")
+				else()
+					set(LIBICSNEO_LIBICSBL_VERSION "26.4.0")
+				endif()
+			endif()
+			if(WIN32)
+				if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8 OR CMAKE_CXX_COMPILER_ARCHITECTURE_ID MATCHES "ARM")
+					message(FATAL_ERROR "Unsupported bootloader architecture: ${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}")
+				endif()
+				set(LIBICSNEO_LIBICSBL_ZIP_URL "${LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}/libicsbl-${LIBICSNEO_LIBICSBL_VERSION}-windows-amd64.zip")
+			elseif(APPLE)
+				set(LIBICSNEO_LIBICSBL_ZIP_URL "${LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}/libicsbl-${LIBICSNEO_LIBICSBL_VERSION}-macos-universal.zip")
+			else()
+				if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+					set(LIBICSNEO_LIBICSBL_ZIP_URL "${LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}/libicsbl-${LIBICSNEO_LIBICSBL_VERSION}-linux-x86_64-glibc.zip")
+				elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
+					set(LIBICSNEO_LIBICSBL_ZIP_URL "${LIBICSNEO_LIBICSBL_ZIP_URL_PREFIX}/libicsbl-${LIBICSNEO_LIBICSBL_VERSION}-linux-aarch64-glibc.zip")
+				else()
+					message(FATAL_ERROR "Unsupported CMAKE_SYSTEM_PROCESSOR: ${CMAKE_SYSTEM_PROCESSOR}")
+				endif()
+			endif()
+		endif()
+	endif()
+
+	FetchContent_Declare(
+		libicsbl
+		URL "${LIBICSNEO_LIBICSBL_ZIP_URL}"
+	)
+	FetchContent_MakeAvailable(libicsbl)
+	set(libicsbl_ROOT "${libicsbl_SOURCE_DIR}")
+	find_package(libicsbl CONFIG REQUIRED)
+	target_link_libraries(icsneocpp PUBLIC libicsbl::icsbl)
+
+	# miniz
+	add_subdirectory(third-party/miniz)
+	target_link_libraries(icsneocpp PRIVATE miniz)
+endif()
+
 if(LIBICSNEO_BUILD_ICSNEOC)
 	add_library(icsneoc SHARED api/icsneoc/icsneoc.cpp ${CMAKE_CURRENT_BINARY_DIR}/generated/icsneoc/version.rc)
 	target_include_directories(icsneoc
@@ -564,10 +506,12 @@ if(LIBICSNEO_BUILD_UNIT_TESTS)
 		test/unit/a2bencoderdecodertest.cpp
 		test/unit/mdioencoderdecodertest.cpp
 		test/unit/livedataencoderdecodertest.cpp
+		test/unit/macsectest.cpp
 		test/unit/ringbuffertest.cpp
 		test/unit/apperrordecodertest.cpp
 		test/unit/icsneoc2.cpp
-		test/unit/windowsstrings.cpp
+		test/unit/ethphyregistertest.cpp
+		test/unit/tc10test.cpp
 		test/unit/periodictest.cpp
 	)

@@ -30,13 +30,13 @@ Instructions for installing each API can be found in its respective documentatio
 - neoVI PLASMA
 - neoVI RED 2
 - RAD-A2B
+- RAD-Argos
 - RAD-Comet 2
 - RAD-Comet 3
 - RAD-Epsilon
 - RAD-EpsilonXL
 - RAD-Galaxy
 - RAD-Galaxy 2
- RAD-Gemini
 - RAD-Gigastar
 - RAD-Gigastar 2
 - RAD-Moon 2
@@ -471,6 +471,7 @@ icsneoc2_error_t icsneoc2_message_lin_status_flags_get(const icsneoc2_message_t*
 	if(lin_msg->statusFlags.HasUpdatedResponderOnce) *status_flags |= ICSNEOC2_LIN_STATUS_HAS_UPDATED_RESPONDER_ONCE;
 	if(lin_msg->statusFlags.BusRecovered) *status_flags |= ICSNEOC2_LIN_STATUS_BUS_RECOVERED;
 	if(lin_msg->statusFlags.BreakOnly) *status_flags |= ICSNEOC2_LIN_STATUS_BREAK_ONLY;
+	if(lin_msg->statusFlags.WakeupRequest) *status_flags |= ICSNEOC2_LIN_STATUS_WAKEUP_REQUEST;
 	return icsneoc2_error_success;
 }

@@ -706,7 +706,7 @@ icsneoc2_error_t icsneoc2_settings_t1s_burst_timer_set(icsneoc2_device_t* device
    return icsneoc2_error_success;
 }

-icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
+icsneoc2_error_t icsneoc2_settings_t1s_max_burst_get(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t* value) {
    // Make sure the device is valid
    auto res = icsneoc2_device_is_valid(device);
    if(res != icsneoc2_error_success) {
@@ -725,7 +725,7 @@ icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_get(icsneoc2_device_t
    }
 }

-icsneoc2_error_t icsneoc2_settings_t1s_max_burst_timer_for_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
+icsneoc2_error_t icsneoc2_settings_t1s_max_burst_set(icsneoc2_device_t* device, icsneoc2_netid_t netid, uint8_t value) {
    // Make sure the device is valid
    auto res = icsneoc2_device_is_valid(device);
    if(res != icsneoc2_error_success) {
@@ -117,6 +117,9 @@ static constexpr const char* GPTP_NOT_SUPPORTED = "GPTP clock synchronization is
 static constexpr const char* SETTING_NOT_AVAILABLE = "Requested a setting that is not available on this device";
 static constexpr const char* DISK_FORMAT_NOT_SUPPORTED = "Disk formatting is not supported on this device.";
 static constexpr const char* DISK_FORMAT_INVALID_COUNT = "Disk format config disk count is mismatched with device disk count.";
+static constexpr const char* TC10_REQUEST_FAILED = "The device rejected the TC10 request.";
+static constexpr const char* FIRMWARE_UPDATE_NOT_SUPPORTED = "Firmware updates are not supported for this device.";
+static constexpr const char* FIRMWARE_UPDATE_FAILED = "The firmware update failed.";

 // Transport Errors
 static constexpr const char* FAILED_TO_READ = "A read operation failed.";
@@ -168,6 +171,7 @@ static constexpr const char* SERVD_POLL_ERROR = "Error polling on Servd socket";
 static constexpr const char* SERVD_NODATA_ERROR = "No data received from Servd";
 static constexpr const char* SERVD_JOIN_MULTICAST_ERROR = "Error joining Servd multicast group";
 static constexpr const char* SERVD_NOT_REACHABLE = "Could not reach Servd; ensure it is installed and running";
+static constexpr const char* SERVD_DISABLED = "Servd is disabled via LIBICSNEO_USE_SERVD; no devices will be found";

 // DXX
 static constexpr const char* DXX_ERROR_SYS = "System error, check errno/GetLastError()";
@@ -381,6 +385,12 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return DISK_FORMAT_NOT_SUPPORTED;
 		case Type::DiskFormatInvalidCount:
 			return DISK_FORMAT_INVALID_COUNT;
+		case Type::TC10RequestFailed:
+			return TC10_REQUEST_FAILED;
+		case Type::FirmwareUpdateNotSupported:
+			return FIRMWARE_UPDATE_NOT_SUPPORTED;
+		case Type::FirmwareUpdateFailed:
+			return FIRMWARE_UPDATE_FAILED;

 		// VSA
 		case Type::VSABufferCorrupted:
@@ -442,6 +452,8 @@ const char* APIEvent::DescriptionForType(Type type) {
 			return SERVD_JOIN_MULTICAST_ERROR;
 		case Type::ServdNotReachable:
 			return SERVD_NOT_REACHABLE;
+		case Type::ServdDisabled:
+			return SERVD_DISABLED;

 		// DXX
 		case Type::DXXErrorSys:
@@ -65,7 +65,6 @@ void EventManager::add(APIEvent event) {
 				std::lock_guard<std::mutex> eventsLock(eventsMutex);
 				addEventInternal(event);
 			} // free the lock so that callbacks may modify events
-			runCallbacks(event);
 		} else {
 			std::lock_guard<std::mutex> errorsLock(errorsMutex);
 			lastUserErrors[std::this_thread::get_id()] = event;
@@ -75,8 +74,8 @@ void EventManager::add(APIEvent event) {
 			std::lock_guard<std::mutex> eventsLock(eventsMutex);
 			addEventInternal(event);
 		} // free the lock so that callbacks may modify events
-		runCallbacks(event);
 	}
+	runCallbacks(event);
 }

 void EventManager::addEventInternal(APIEvent event) {
@@ -100,9 +99,13 @@ void EventManager::addEventInternal(APIEvent event) {
 }

 void EventManager::runCallbacks(APIEvent event) {
-	std::lock_guard<std::mutex> lk(callbacksMutex);
-	for(auto& i : callbacks)
-		i.second.callIfMatch(std::make_shared<APIEvent>(event));
+    std::map<int, icsneo::EventCallback> tempCallbacks;
+    {
+        std::lock_guard<std::mutex> lk(callbacksMutex);
+        tempCallbacks = callbacks;
+    }
+    for(auto& i : tempCallbacks)
+        i.second.callIfMatch(std::make_shared<APIEvent>(event));
 }

 void EventManager::setEventLimit(size_t newLimit) {
@@ -20,9 +20,16 @@ Heartbeat::~Heartbeat() {
 void Heartbeat::run() {
 	EventManager::GetInstance().downgradeErrorsOnCurrentThread();

-	auto filter = std::make_shared<MessageFilter>(Message::Type::ResetStatus);
+	auto filter = std::make_shared<MessageFilter>();
+	filter->includeInternalInAny = true;
 	bool status = false;
-	auto cbHandle = device.com->addMessageCallback(std::make_shared<MessageCallback>(filter, [&](std::shared_ptr<Message>) {
+	auto cbHandle = device.com->addMessageCallback(std::make_shared<MessageCallback>(filter, [&](std::shared_ptr<Message> msg) {
+		// TODO: remove DeviceStatus after 2027-08-17, as ResetStatus should be widely supported
+		const bool isHeartbeat =
+			(msg->type == Message::Type::ResetStatus) ||
+			(msg->type == Message::Type::RawMessage && std::static_pointer_cast<RawMessage>(msg)->network == Network::NetID::DeviceStatus);
+		if(!isHeartbeat)
+			return;
 		{
 			std::lock_guard lk(mutex);
 			status = true;
@@ -545,15 +545,13 @@ int LegacyDLLExport icsneoGetTimeStampForMsg(void* hObject, icsSpyMessage* pMsg,
 void LegacyDLLExport icsneoGetISO15765Status(void* hObject, int lNetwork, int lClearTxStatus, int lClearRxStatus,
 	int* lTxStatus, int* lRxStatus)
 {
-	// TODO Implement
-	return;
+	// Not supported
 }

 void LegacyDLLExport icsneoSetISO15765RxParameters(void* hObject, int lNetwork, int lEnable, spyFilterLong* pFF_CFMsgFilter,
 	icsSpyMessage* pTxMsg, int lCFTimeOutMs, int lFlowCBlockSize, int lUsesExtendedAddressing, int lUseHardwareIfPresent)
 {
-	// TODO Implement
-	return;
+	// Not supported
 }

 int LegacyDLLExport icsneoGetRTC(void* hObject, icsSpyTime* time)
@@ -835,26 +833,25 @@ int LegacyDLLExport icsneoGetErrorInfo(int lErrorNumber, char* szErrorDescriptio
 //ISO15765-2 Functions
 int LegacyDLLExport icsneoISO15765_EnableNetworks(void* hObject, unsigned long ulNetworks)
 {
-	// TODO Implement
+	// Not supported
 	return false;
 }

 int LegacyDLLExport icsneoISO15765_DisableNetworks(void* hObject)
 {
-	// TODO Implement
+	// Not supported
 	return false;
 }

-int LegacyDLLExport icsneoISO15765_TransmitMessage(void* hObject, unsigned long ulNetworkID, stCM_ISO157652_TxMessage* pMsg,
-	unsigned long ulBlockingTimeout)
+int LegacyDLLExport icsneoISO15765_TransmitMessage(void* hObject, unsigned long ulNetworkID, stCM_ISO157652_TxMessage* pMsg, unsigned long ulBlockingTimeout)
 {
-	// TODO Implement
+	// Not supported
 	return false;
 }

 int LegacyDLLExport icsneoISO15765_ReceiveMessage(void* hObject, int ulNetworkID, stCM_ISO157652_RxMessage* pMsg)
 {
-	// TODO Implement
+	// Not supported
 	return false;
 }

@@ -1076,8 +1073,8 @@ int LegacyDLLExport icsneoGetDeviceSettingsType(void* hObject, EPlasmaIonVnetCha
 	case NEODEVICE_RADMOON3:
 		*pDeviceSettingsType = DeviceRADMoon3SettingsType;
 		break;
-	case NEODEVICE_RADGEMINI:
-		*pDeviceSettingsType = DeviceRADGeminiSettingsType;
+	case NEODEVICE_RADARGOS:
+		*pDeviceSettingsType = DeviceRADArgosSettingsType;
 		break;
 	case NEODEVICE_RED2:
 		*pDeviceSettingsType = DeviceRed2SettingsType;
@@ -1285,10 +1282,11 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 		return false;

 	neodevice_t* device = reinterpret_cast<neodevice_t*>(hObject);
+    const auto& cmd = static_cast<icsneo::J2534Command>(*CmdBuf);

-	switch (*CmdBuf)
+	switch (cmd)
 	{
-	case J2534NVCMD_SetNetworkBaudRate:
+	case icsneo::J2534Command::SetNetworkBaudRate:

 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1298,7 +1296,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 			iRetVal = 0;
 		break;

-	case J2534NVCMD_GetNetworkBaudRate:
+	case icsneo::J2534Command::GetNetworkBaudRate:
 	{
 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1311,7 +1309,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 		*pTmp = static_cast<uint64_t>(ret);
 		break;
 	}
-	case J2534NVCMD_SetCANFDRate:
+	case icsneo::J2534Command::SetCANFDRate:

 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1322,7 +1320,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 			iRetVal = 0;
 		break;

-	case J2534NVCMD_GetCANFDRate:
+	case icsneo::J2534Command::GetCANFDRate:

 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1332,7 +1330,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 		*pTmp = icsneo_getFDBaudrate(device, NetworkID);
 		break;

-	case J2534NVCMD_GetCANFDTermination:
+	case icsneo::J2534Command::GetCANFDTermination:

 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1368,7 +1366,7 @@ int LegacyDLLExport icsneoJ2534Cmd(void* hObject, unsigned char* CmdBuf, short L
 		}
 		break;

-	case J2534NVCMD_SetCANFDTermination:
+	case icsneo::J2534Command::SetCANFDTermination:

 		pTmp = (uint64_t *)&CmdBuf[1];
 		NetworkID = (uint16_t)*pTmp;
@@ -1422,11 +1420,9 @@ int LegacyDLLExport icsneoEnableBusVoltageMonitor(void* hObject, unsigned int en
 	return false;
 }

-int LegacyDLLExport icsneoISO15765_TransmitMessageEx(void* hObject,
-	unsigned long ulNetworkID,
-	ISO15765_2015_TxMessage* pMsg,
-	unsigned long ulBlockingTimeout)
+int LegacyDLLExport icsneoISO15765_TransmitMessageEx(void* hObject, unsigned long ulNetworkID, ISO15765_2015_TxMessage* pMsg, unsigned long ulBlockingTimeout)
 {
+	// Not supported
 	return false;
 }

@@ -26,6 +26,7 @@ pybind11_add_module(icsneopy
    icsneopy/communication/message/message.cpp
    icsneopy/communication/message/canmessage.cpp
    icsneopy/communication/message/canerrormessage.cpp
+    icsneopy/communication/message/iso15765message.cpp
    icsneopy/communication/message/ethernetmessage.cpp
    icsneopy/communication/message/linmessage.cpp
    icsneopy/communication/message/tc10statusmessage.cpp
@@ -40,6 +41,9 @@ pybind11_add_module(icsneopy
    icsneopy/communication/message/livedatamessage.cpp
    icsneopy/communication/message/callback/messagecallback.cpp
    icsneopy/communication/message/filter/messagefilter.cpp
+    icsneopy/communication/message/filter/main51messagefilter.cpp
+    icsneopy/communication/message/main51message.cpp
+    icsneopy/communication/command.cpp
    icsneopy/core/macseccfg.cpp
    icsneopy/flexray/flexray.cpp
    icsneopy/disk/diskdriver.cpp
@@ -53,11 +57,30 @@ pybind11_add_module(icsneopy
 )
 target_link_libraries(icsneopy PRIVATE icsneocpp)

+if(LIBICSNEO_ENABLE_BOOTLOADER)
+    target_sources(icsneopy PRIVATE icsneopy/bootloader/bootloader.cpp)
+    target_compile_definitions(icsneopy PRIVATE ICSNEO_ENABLE_BOOTLOADER)
+    if(WIN32)
+        # Windows has no build RPATH; the .pyd only finds DLLs in its own directory
+        add_custom_command(TARGET icsneopy POST_BUILD
+            COMMAND "${CMAKE_COMMAND}" -E copy_if_different "$<TARGET_FILE:libicsbl::icsbl>" "$<TARGET_FILE_DIR:icsneopy>"
+            VERBATIM
+        )
+    endif()
+endif()
+
 install(TARGETS icsneopy LIBRARY DESTINATION icsneopy)

 find_program(STUBGEN_EXE stubgen)
 if(STUBGEN_EXE)
-    add_custom_command(TARGET icsneopy POST_BUILD COMMAND stubgen -v -p icsneopy -o .)
+    # Multi-config generators put the extension in Release/ or Debug/. Import
+    # that freshly built module, not a globally installed older icsneopy.
+    add_custom_command(TARGET icsneopy POST_BUILD
+        COMMAND "${CMAKE_COMMAND}" -E rm -f "${CMAKE_CURRENT_BINARY_DIR}/icsneopy.pyi"
+        COMMAND "${STUBGEN_EXE}" -v -p icsneopy -o "${CMAKE_CURRENT_BINARY_DIR}"
+        WORKING_DIRECTORY "$<TARGET_FILE_DIR:icsneopy>"
+        VERBATIM
+    )
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/icsneopy.pyi py.typed DESTINATION icsneopy)
 endif()

@@ -92,6 +92,9 @@ void init_event(pybind11::module_& m) {
 		.value("SettingNotAvaiableDevice", APIEvent::Type::SettingNotAvaiableDevice)
 		.value("DiskFormatNotSupported", APIEvent::Type::DiskFormatNotSupported)
 		.value("DiskFormatInvalidCount", APIEvent::Type::DiskFormatInvalidCount)
+		.value("TC10RequestFailed", APIEvent::Type::TC10RequestFailed)
+		.value("FirmwareUpdateNotSupported", APIEvent::Type::FirmwareUpdateNotSupported)
+		.value("FirmwareUpdateFailed", APIEvent::Type::FirmwareUpdateFailed)
 		.value("FailedToRead", APIEvent::Type::FailedToRead)
 		.value("FailedToWrite", APIEvent::Type::FailedToWrite)
 		.value("DriverFailedToOpen", APIEvent::Type::DriverFailedToOpen)
@@ -127,6 +130,7 @@ void init_event(pybind11::module_& m) {
 		.value("ServdNoDataError", APIEvent::Type::ServdNoDataError)
 		.value("ServdJoinMulticastError", APIEvent::Type::ServdJoinMulticastError)
 		.value("ServdNotReachable", APIEvent::Type::ServdNotReachable)
+		.value("ServdDisabled", APIEvent::Type::ServdDisabled)
 		.value("DXXErrorSys", APIEvent::Type::DXXErrorSys)
 		.value("DXXErrorInt", APIEvent::Type::DXXErrorInt)
 		.value("DXXErrorOverflow", APIEvent::Type::DXXErrorOverflow)
@@ -0,0 +1,37 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/functional.h>
+
+#include "icsneo/device/extensions/bootloader/api.h"
+#include "icsneo/device/extensions/bootloader/parser/fwloader.h"
+
+namespace icsneo {
+
+struct BootloaderNamespace {};
+
+void init_bootloader(pybind11::module_& m) {
+	// Dummy class to act as Bootloader namespace
+	pybind11::classh<BootloaderNamespace> bootloader(m, "Bootloader");
+
+	// Opaque handle returned by FWLoader.load and consumed by update
+	pybind11::classh<Bootloader::FWRepo>(bootloader, "FWRepo");
+
+	pybind11::classh<Bootloader::FWLoader>(bootloader, "FWLoader")
+		.def_static("load", &Bootloader::FWLoader::Load, pybind11::arg("path"), pybind11::call_guard<pybind11::gil_scoped_release>());
+
+	bootloader.def_static("update",
+		[](Device& device, const Bootloader::FWRepo& fw, Bootloader::Logger logger, bool alreadyInBootloader, bool forceFlash) {
+			if(!logger) {
+				logger = [](Device::OpenStatusType, const std::string&, std::optional<double>) { return Device::OpenDirective::Continue; };
+			}
+			return Bootloader::update(device, fw, logger, alreadyInBootloader, forceFlash);
+		},
+		pybind11::arg("device"),
+		pybind11::arg("fw"),
+		pybind11::arg("logger") = pybind11::none(),
+		pybind11::arg("already_in_bootloader") = false,
+		pybind11::arg("force_flash") = false,
+		pybind11::call_guard<pybind11::gil_scoped_release>());
+}
+
+} // namespace icsneo
@@ -0,0 +1,40 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/native_enum.h>
+
+#include "icsneo/communication/command.h"
+
+namespace icsneo {
+
+void init_command(pybind11::module_& m) {
+	pybind11::native_enum<Command>(m, "Command", "enum.IntEnum")
+		.value("Main51RxBufferOverflow", Command::Main51RxBufferOverflow)
+		.value("Main51StartCmd", Command::Main51StartCmd)
+		.value("Main51TxFifoOverflow", Command::Main51TxFifoOverflow)
+		.value("Main51BulkInNoData", Command::Main51BulkInNoData)
+		.value("Main51SetModeComplete", Command::Main51SetModeComplete)
+		.value("Main51ReadEeprom", Command::Main51ReadEeprom)
+		.value("Main51CmdDone", Command::Main51CmdDone)
+		.value("Main51ErrStatus", Command::Main51ErrStatus)
+		.value("Main51ReadSectorBuff", Command::Main51ReadSectorBuff)
+		.value("Main51WriteSectorBuff", Command::Main51WriteSectorBuff)
+		.value("Main51MmcProcessDone", Command::Main51MmcProcessDone)
+		.value("Main51ReInitDone", Command::Main51ReInitDone)
+		.value("EnableNetworkCommunication", Command::EnableNetworkCommunication)
+		.value("EnableNetworkCommunicationEx", Command::EnableNetworkCommunicationEx)
+		.value("KeepAlive", Command::KeepAlive)
+		.value("RequestSerialNumber", Command::RequestSerialNumber)
+		.value("GetMainVersion", Command::GetMainVersion)
+		.value("SetSettings", Command::SetSettings)
+		.value("SaveSettings", Command::SaveSettings)
+		.value("SetDefaultSettings", Command::SetDefaultSettings)
+		.value("ReadSettings", Command::ReadSettings)
+		.value("ScriptStatus", Command::ScriptStatus)
+		.value("WiVICommand", Command::WiVICommand)
+		.value("Extended", Command::Extended)
+		.value("ExtendedData", Command::ExtendedData)
+		.value("FlexRayControl", Command::FlexRayControl)
+		.value("CoreMiniPreload", Command::CoreMiniPreload)
+		.finalize();
+}
+
+} // namespace icsneo
@@ -0,0 +1,13 @@
+#include <pybind11/pybind11.h>
+
+#include "icsneo/communication/message/filter/main51messagefilter.h"
+
+namespace icsneo {
+
+void init_main51messagefilter(pybind11::module_& m) {
+	pybind11::classh<Main51MessageFilter, MessageFilter>(m, "Main51MessageFilter")
+		.def(pybind11::init<>())
+		.def(pybind11::init<Command>());
+}
+
+} // namespace icsneo
@@ -0,0 +1,48 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "icsneo/communication/message/iso15765message.h"
+
+namespace icsneo {
+
+void init_iso15765message(pybind11::module_& m) {
+	auto args = pybind11::classh<Iso15765MessageArgs>(m, "Iso15765MessageArgs");
+
+	pybind11::classh<Iso15765MessageArgs::ArbId>(args, "ArbId")
+		.def(pybind11::init<uint32_t, bool>(), pybind11::arg("id") = 0, pybind11::arg("is_29bit") = false)
+		.def_readwrite("id", &Iso15765MessageArgs::ArbId::Id)
+		.def_readwrite("is_29bit", &Iso15765MessageArgs::ArbId::Is29Bit);
+
+	args.def(pybind11::init<>())
+		.def_property("tx_index", &Iso15765MessageArgs::getTxIndex, &Iso15765MessageArgs::setTxIndex)
+		.def_property("arb_id",
+			[](Iso15765MessageArgs& self) -> Iso15765MessageArgs::ArbId& {
+				return const_cast<Iso15765MessageArgs::ArbId&>(self.getArbId());
+			},
+			&Iso15765MessageArgs::setArbId,
+			pybind11::return_value_policy::reference_internal)
+		.def_property("flow_control_arb_id",
+			[](Iso15765MessageArgs& self) -> Iso15765MessageArgs::ArbId& {
+				return const_cast<Iso15765MessageArgs::ArbId&>(self.getFlowControlArbId());
+			},
+			&Iso15765MessageArgs::setFlowControlArbId,
+			pybind11::return_value_policy::reference_internal)
+		.def_property("flow_control_arb_id_mask", &Iso15765MessageArgs::getFlowControlArbIdMask, &Iso15765MessageArgs::setFlowControlArbIdMask)
+		.def_property("is_can_fd", &Iso15765MessageArgs::getIsCanFd, &Iso15765MessageArgs::setIsCanFd)
+		.def_property("is_brs_enabled", &Iso15765MessageArgs::getIsBrsEnabled, &Iso15765MessageArgs::setIsBrsEnabled)
+		.def_property("tx_dl", &Iso15765MessageArgs::getTxDl, &Iso15765MessageArgs::setTxDl)
+		.def_property("st_min", &Iso15765MessageArgs::getStMin, &Iso15765MessageArgs::setStMin)
+		.def_property("block_size", &Iso15765MessageArgs::getBlockSize, &Iso15765MessageArgs::setBlockSize)
+		.def_property("extended_address", &Iso15765MessageArgs::getExtendedAddress, &Iso15765MessageArgs::setExtendedAddress)
+		.def_property("flow_control_extended_address", &Iso15765MessageArgs::getFlowControlExtendedAddress, &Iso15765MessageArgs::setFlowControlExtendedAddress)
+		.def_property("padding_value", &Iso15765MessageArgs::getPaddingValue, &Iso15765MessageArgs::setPaddingValue)
+		.def_property("fs_timeout", &Iso15765MessageArgs::getFsTimeout, &Iso15765MessageArgs::setFsTimeout)
+		.def_property("fs_wait_timeout", &Iso15765MessageArgs::getFsWaitTimeout, &Iso15765MessageArgs::setFsWaitTimeout)
+		.def_property("cf_timeout", &Iso15765MessageArgs::getCfTimeout, &Iso15765MessageArgs::setCfTimeout)
+		.def_property("data",
+			&Iso15765MessageArgs::getData,
+			[](Iso15765MessageArgs& self, std::vector<uint8_t> data) { self.setData(std::move(data)); })
+		.def_property("is_flow_control_enabled", &Iso15765MessageArgs::getIsFlowControlEnabled, &Iso15765MessageArgs::setIsFlowControlEnabled);
+}
+
+} // namespace icsneo
@@ -28,7 +28,8 @@ void init_linmessage(pybind11::module_& m) {
 		.def_readwrite("UpdateResponderOnce", &LINStatusFlags::UpdateResponderOnce)
 		.def_readwrite("HasUpdatedResponderOnce", &LINStatusFlags::HasUpdatedResponderOnce)
 		.def_readwrite("BusRecovered", &LINStatusFlags::BusRecovered)
-		.def_readwrite("BreakOnly", &LINStatusFlags::BreakOnly);
+		.def_readwrite("BreakOnly", &LINStatusFlags::BreakOnly)
+		.def_readwrite("WakeupRequest", &LINStatusFlags::WakeupRequest);

 	pybind11::classh<LINMessage, Frame> linMessage(m, "LINMessage");

@@ -39,7 +40,8 @@ void init_linmessage(pybind11::module_& m) {
 		.value("LIN_BREAK_ONLY", LINMessage::Type::LIN_BREAK_ONLY)
 		.value("LIN_SYNC_ONLY", LINMessage::Type::LIN_SYNC_ONLY)
 		.value("LIN_UPDATE_RESPONDER", LINMessage::Type::LIN_UPDATE_RESPONDER)
-		.value("LIN_ERROR", LINMessage::Type::LIN_ERROR);
+		.value("LIN_ERROR", LINMessage::Type::LIN_ERROR)
+		.value("LIN_WAKEUP_REQUEST", LINMessage::Type::LIN_WAKEUP_REQUEST);

 	linMessage
 		.def(pybind11::init<>())
@@ -0,0 +1,13 @@
+#include <pybind11/pybind11.h>
+
+#include "icsneo/communication/message/main51message.h"
+
+namespace icsneo {
+
+void init_main51message(pybind11::module_& m) {
+	pybind11::classh<Main51Message, RawMessage>(m, "Main51Message")
+		.def(pybind11::init<>())
+		.def_readonly("command", &Main51Message::command);
+}
+
+} // namespace icsneo
@@ -154,7 +154,6 @@ void init_macsecconfig(pybind11::module_ & m)
 		.def("set_storage", &MACsecConfig::setStorage, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("clear", &MACsecConfig::clear, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("serialize", &MACsecConfig::serialize, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("get_bin_index", &MACsecConfig::getBinIndex, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_type", &MACsecConfig::getType, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_max_num_rule", &MACsecConfig::getMaxNumRule, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_max_num_secy", &MACsecConfig::getMaxNumSecY, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -134,7 +134,8 @@ void init_chipid(pybind11::module_& m) {
 		.value("SFPModule_lan8670_MCHIP", ChipID::SFPModule_lan8670_MCHIP)
 		.value("RADGigastar2_ZYNQ", ChipID::RADGigastar2_ZYNQ)
 		.value("SFPModule_ent11100_MCHIP", ChipID::SFPModule_ent11100_MCHIP)
-		.value("RADGemini_MCHIP", ChipID::RADGemini_MCHIP)
+		.value("RADArgos_MCHIP", ChipID::RADArgos_MCHIP)
+		.value("SFPModule_ad1101_MCHIP", ChipID::SFPModule_ad1101_MCHIP)
 		.value("Invalid", ChipID::Invalid)
 		.finalize();
 }
@@ -2,6 +2,7 @@
 #include <pybind11/stl.h>
 #include <pybind11/functional.h>
 #include <pybind11/chrono.h>
+#include <pybind11/native_enum.h>

 #include "icsneo/device/device.h"
 #include "icsneo/device/extensions/deviceextension.h"
@@ -12,7 +13,22 @@
 namespace icsneo {

 void init_device(pybind11::module_& m) {
-	pybind11::classh<Device>(m, "Device")
+	pybind11::classh<Device> device(m, "Device");
+
+	pybind11::native_enum<Device::OpenDirective>(device, "OpenDirective", "enum.IntEnum")
+		.value("Continue", Device::OpenDirective::Continue)
+		.value("Cancel", Device::OpenDirective::Cancel)
+		.value("Skip", Device::OpenDirective::Skip)
+		.finalize();
+
+	pybind11::native_enum<Device::OpenStatusType>(device, "OpenStatusType", "enum.IntEnum")
+		.value("QuestionContinueSkipCancel", Device::OpenStatusType::QuestionContinueSkipCancel)
+		.value("QuestionContinueCancel", Device::OpenStatusType::QuestionContinueCancel)
+		.value("Progress", Device::OpenStatusType::Progress)
+		.value("Failed", Device::OpenStatusType::Failed)
+		.finalize();
+
+	device
 		.def("__repr__", &Device::describe)
 		.def("add_message_callback", &Device::addMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("clear_script", &Device::clearScript, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -34,6 +50,7 @@ void init_device(pybind11::module_& m) {
 		.def("get_serial", &Device::getSerial)
 		.def("get_pcb_serial", &Device::getPCBSerial, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_mac_addresses", &Device::getMACAddresses, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("get_macsec_networks", &Device::getMACsecNetworks)
 		.def("get_supported_rx_networks", &Device::getSupportedRXNetworks, pybind11::return_value_policy::reference)
 		.def("get_supported_tx_networks", &Device::getSupportedTXNetworks, pybind11::return_value_policy::reference)
 		.def("get_tc10_status", &Device::getTC10Status, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -44,6 +61,10 @@ void init_device(pybind11::module_& m) {
 		.def("is_online_supported", &Device::isOnlineSupported)
 		.def("is_online", &Device::isOnline)
 		.def("is_open", &Device::isOpen)
+		.def("iso15765_enable", &Device::iso15765Enable, pybind11::arg("network"), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("iso15765_disable_all", &Device::iso15765DisableAll, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("iso15765_transmit_message", &Device::iso15765TransmitMessage, pybind11::arg("network"), pybind11::arg("message"), pybind11::arg("timeout"), pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("iso15765_setup_rx_flow_control", &Device::iso15765SetupRxFlowControl, pybind11::arg("network"), pybind11::arg("message"), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("open", [](Device& device) { return device.open(); }, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("prepare_script_load", &Device::prepareScriptLoad, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("remove_message_callback", &Device::removeMessageCallback, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -64,7 +85,7 @@ void init_device(pybind11::module_& m) {
 		.def("set_value_live_data", &Device::setValueLiveData, pybind11::arg("message"), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("transmit", pybind11::overload_cast<std::shared_ptr<Frame>>(&Device::transmit), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("upload_coremini", [](Device& device, std::string& path, Disk::MemoryType memType) { std::ifstream ifs(path, std::ios::binary); return device.uploadCoremini(ifs, memType); }, pybind11::call_guard<pybind11::gil_scoped_release>())
-		.def("write_macsec_config", &Device::writeMACsecConfig, pybind11::call_guard<pybind11::gil_scoped_release>())
+		.def("write_macsec_config", &Device::writeMACsecConfig, pybind11::arg("config"), pybind11::arg("network"), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("send_eth_phy_msg", &Device::sendEthPhyMsg, pybind11::arg("message"), pybind11::arg("timeout") = std::chrono::milliseconds(50), pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("get_chip_versions", &Device::getChipVersions, pybind11::arg("refreshComponents") = true, pybind11::call_guard<pybind11::gil_scoped_release>())
 		.def("supports_disk_formatting", &Device::supportsDiskFormatting, pybind11::call_guard<pybind11::gil_scoped_release>())
@@ -38,7 +38,7 @@ void init_devicetype(pybind11::module_& m) {
 		.value("RADGalaxy2", DeviceType::Enum::RADGalaxy2)
 		.value("RADwBMS", DeviceType::Enum::RADwBMS)
 		.value("RADMoon3", DeviceType::Enum::RADMoon3)
-		.value("RADGemini", DeviceType::Enum::RADGemini)
+		.value("RADArgos", DeviceType::Enum::RADArgos)
 		.value("RADComet2", DeviceType::Enum::RADComet2)
 		.value("FIRE3_FlexRay", DeviceType::Enum::FIRE3_FlexRay)
 		.value("FIRE3_T1S_LIN", DeviceType::Enum::FIRE3_T1S_LIN)
@@ -15,6 +15,7 @@ void init_devicetype(pybind11::module_&);
 void init_message(pybind11::module_&);
 void init_canmessage(pybind11::module_&);
 void init_canerrormessage(pybind11::module_&);
+void init_iso15765message(pybind11::module_&);
 void init_ethernetmessage(pybind11::module_&);
 void init_linmessage(pybind11::module_&);
 void init_tc10statusmessage(pybind11::module_&);
@@ -32,7 +33,10 @@ void init_deviceextension(pybind11::module_&);
 void init_chipid(pybind11::module_&);
 void init_versionreport(pybind11::module_&);
 void init_device(pybind11::module_&);
+void init_command(pybind11::module_&);
+void init_main51message(pybind11::module_&);
 void init_messagefilter(pybind11::module_&);
+void init_main51messagefilter(pybind11::module_&);
 void init_messagecallback(pybind11::module_&);
 void init_version(pybind11::module_&);
 void init_flexray(pybind11::module_& m);
@@ -40,6 +44,9 @@ void init_idevicesettings(pybind11::module_&);
 void init_ethphymessage(pybind11::module_&);
 void init_livedata(pybind11::module_&);
 void init_livedatamessage(pybind11::module_&);
+#ifdef ICSNEO_ENABLE_BOOTLOADER
+void init_bootloader(pybind11::module_&);
+#endif

 PYBIND11_MODULE(icsneopy, m) {
 	pybind11::options options;
@@ -57,6 +64,7 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_message(m);
 	init_canmessage(m);
 	init_canerrormessage(m);
+	init_iso15765message(m);
 	init_ethernetmessage(m);
 	init_linmessage(m);
 	init_tc10statusmessage(m);
@@ -69,7 +77,10 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_scriptstatusmessage(m);
 	init_spimessage(m);
 	init_livedatamessage(m);
+	init_command(m);
+	init_main51message(m);
 	init_messagefilter(m);
+	init_main51messagefilter(m);
 	init_messagecallback(m);
 	init_diskdriver(m);
 	init_diskdetails(m);
@@ -80,6 +91,9 @@ PYBIND11_MODULE(icsneopy, m) {
 	init_device(m);
    init_deviceextension(m);
 	init_idevicesettings(m);
+#ifdef ICSNEO_ENABLE_BOOTLOADER
+	init_bootloader(m);
+#endif

 	m.def("find_all_devices", &FindAllDevices);
 	m.def("get_supported_devices", &GetSupportedDevices);
@@ -1,18 +0,0 @@
-#!/bin/sh
-
-VERSION="1.10.5"
-ROOT="$PWD/libpcap"
-SOURCE="$ROOT/source"
-BUILD="$ROOT/build"
-INSTALL="$ROOT/install"
-
-mkdir -p "$ROOT"
-cd "$ROOT" || exit 1
-
-curl -LO "https://www.tcpdump.org/release/libpcap-$VERSION.tar.xz" || exit 1
-tar -xf "libpcap-$VERSION.tar.xz" || exit 1
-mv "libpcap-$VERSION" "$SOURCE" || exit 1
-
-cmake -D CMAKE_POSITION_INDEPENDENT_CODE=ON -D CMAKE_INSTALL_PREFIX="$INSTALL" -D BUILD_SHARED_LIBS=OFF -D BUILD_WITH_LIBNL=OFF -D DISABLE_DBUS=ON -D DISABLE_LINUX_USBMON=ON -D DISABLE_BLUETOOTH=ON -D DISABLE_NETMAP=ON -D DISABLE_DPDK=ON -D DISABLE_RDMA=ON -D DISABLE_DAG=ON -D DISABLE_SEPTEL=ON -D DISABLE_SNF=ON -D DISABLE_TC=ON -B "$BUILD" -S "$SOURCE" || exit 1
-cmake --build "$BUILD" || exit 1
-cmake --install "$BUILD" || exit 1
@@ -1,6 +1,6 @@
 #!/bin/sh

-cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_EXAMPLES=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_TCP=OFF || exit 1
+cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DLIBICSNEO_BUILD_EXAMPLES=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_BOOTLOADER=ON || exit 1

 cmake --build build || exit 1

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+export CIBW_BEFORE_ALL="sh ci/bootstrap-cibuildwheel.sh"
+export CIBW_BUILD="*manylinux*" # no musl
+export CIBW_ENVIRONMENT="LD_LIBRARY_PATH=/project/fc/libicsbl-src/lib64"
+export SKBUILD_CMAKE_DEFINE="LIBICSNEO_ENABLE_BOOTLOADER=ON;ICSPB_BOOTSTRAP_DIR=/project/icspb;FETCHCONTENT_BASE_DIR=/project/fc"
+
+sh ci/build-wheel-posix.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+export CIBW_ARCHS="arm64"
+export SKBUILD_CMAKE_DEFINE="LIBICSNEO_ENABLE_BOOTLOADER=ON;ICSPB_BOOTSTRAP_DIR=$PWD/icspb;FETCHCONTENT_BASE_DIR=$PWD/fc"
+export REPAIR_LIBRARY_PATH="$PWD/fc/libicsbl-src/lib"
+export MACOSX_DEPLOYMENT_TARGET="10.14"
+
+sh ci/build-wheel-posix.sh
@@ -3,6 +3,9 @@

 call "%VCVARS64_2022%"

+set "SKBUILD_CMAKE_DEFINE=LIBICSNEO_ENABLE_BOOTLOADER=ON;ICSPB_BOOTSTRAP_DIR=%CD%\icspb;FETCHCONTENT_BASE_DIR=%CD%\fc"
+set "PATH=%CD%\fc\libicsbl-src\bin;%PATH%"
+
 python.exe -m venv env || exit /b 1
 call env\Scripts\Activate.bat || exit /b 1
 python.exe -m pip install cibuildwheel || exit /b 1
@@ -3,6 +3,6 @@

 mkdir build >nul 2>&1

-cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON-DLIBICSNEO_ENABLE_TCP=ON || exit /b 1
+cmake -GNinja -Bbuild -DCMAKE_BUILD_TYPE=Release -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DLIBICSNEO_BUILD_UNIT_TESTS=ON -DLIBICSNEO_ENABLE_BOOTLOADER=ON || exit /b 1

 cmake --build build || exit /b 1
@@ -1,74 +0,0 @@
-# - Try to find libpcap include dirs and libraries
-#
-# Usage of this module as follows:
-#
-#     find_package(PCAP)
-#
-# Variables used by this module, they can change the default behaviour and need
-# to be set before calling find_package:
-#
-#  PCAP_ROOT_DIR             Set this variable to the root installation of
-#                            libpcap if the module has problems finding the
-#                            proper installation path.
-#
-# Variables defined by this module:
-#
-#  PCAP_FOUND                System has libpcap, include and library dirs found
-#  PCAP_INCLUDE_DIR          The libpcap include directories.
-#  PCAP_LIBRARY              The libpcap library (possibly includes a thread
-#                            library e.g. required by pf_ring's libpcap)
-#  HAVE_PF_RING              If a found version of libpcap supports PF_RING
-
-find_path(PCAP_ROOT_DIR
-	NAMES include/pcap.h
-)
-
-find_path(PCAP_INCLUDE_DIR
-	NAMES pcap.h
-	HINTS ${PCAP_ROOT_DIR}/include
-)
-
-find_library(PCAP_LIBRARY
-	NAMES pcap
-	HINTS ${PCAP_ROOT_DIR}/lib
-)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(PCAP DEFAULT_MSG
-	PCAP_LIBRARY
-	PCAP_INCLUDE_DIR
-)
-
-include(CheckCSourceCompiles)
-set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY})
-check_c_source_compiles("int main() { return 0; }" PCAP_LINKS_SOLO)
-set(CMAKE_REQUIRED_LIBRARIES)
-
-# check if linking against libpcap also needs to link against a thread library
-if (NOT PCAP_LINKS_SOLO)
-	find_package(Threads)
-	if (THREADS_FOUND)
-		set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY} ${CMAKE_THREAD_LIBS_INIT})
-		check_c_source_compiles("int main() { return 0; }" PCAP_NEEDS_THREADS)
-		set(CMAKE_REQUIRED_LIBRARIES)
-	endif ()
-	if (THREADS_FOUND AND PCAP_NEEDS_THREADS)
-		set(_tmp ${PCAP_LIBRARY} ${CMAKE_THREAD_LIBS_INIT})
-		list(REMOVE_DUPLICATES _tmp)
-		set(PCAP_LIBRARY ${_tmp}
-			CACHE STRING "Libraries needed to link against libpcap" FORCE)
-	else ()
-		message(FATAL_ERROR "Couldn't determine how to link against libpcap")
-	endif ()
-endif ()
-
-include(CheckFunctionExists)
-set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY})
-check_function_exists(pcap_get_pfring_id HAVE_PF_RING)
-set(CMAKE_REQUIRED_LIBRARIES)
-
-mark_as_advanced(
-	PCAP_ROOT_DIR
-	PCAP_INCLUDE_DIR
-	PCAP_LIBRARY
-)
@@ -26,7 +26,10 @@
 #include "icsneo/communication/message/ethernetstatusmessage.h"
 #include "icsneo/communication/message/networkmutexmessage.h"
 #include "icsneo/communication/message/clientidmessage.h"
+#include "icsneo/communication/message/mfgconfigmessage.h"
 #include "icsneo/communication/message/spiportkeymessage.h"
+#include "icsneo/communication/message/genericapidatamessage.h"
+#include "icsneo/communication/message/genericapistatusmessage.h"
 #include "icsneo/communication/command.h"
 #include "icsneo/device/device.h"
 #include "icsneo/communication/packet/canpacket.h"
@@ -41,6 +44,7 @@
 #include "icsneo/communication/packet/i2cpacket.h"
 #include "icsneo/communication/packet/scriptstatuspacket.h"
 #include "icsneo/communication/packet/linpacket.h"
+#include "icsneo/communication/message/iso15765message.h"
 #include "icsneo/communication/packet/componentversionpacket.h"
 #include "icsneo/communication/packet/supportedfeaturespacket.h"
 #include "icsneo/communication/packet/mdiopacket.h"
@@ -345,6 +349,12 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 						case ExtendedCommand::ExecuteSPIPortKeyOperation:
 							result = SPIPortKeyMessage::DecodeToMessage(packet->data);
 							return true;
+						case ExtendedCommand::ReadGenericAPIData:
+							result = GenericAPIDataMessage::DecodeToMessage(packet->data);
+							return true;
+						case ExtendedCommand::ReadGenericAPIStatus:
+							result = GenericAPIStatusMessage::DecodeToMessage(packet->data);
+							return true;
 						case ExtendedCommand::GetTC10Status:
 							result = TC10StatusMessage::DecodeToMessage(packet->data);
 							return true;
@@ -363,6 +373,9 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac
 							);
 							protoapi::Id protoId = protoapi::getProtoId(responseBody.data(), responseBody.size());
 							switch(protoId) {
+								case protoapi::Id::MfgConfig:
+									result = MfgConfigMessage::DecodeToMessage(responseBody);
+									return true;
 								case protoapi::Id::NetworkMutex:
 									result = NetworkMutexMessage::DecodeToMessage(responseBody);
 									return true;
@@ -467,6 +480,14 @@ bool Decoder::decode(std::shared_ptr<Message>& result, const std::shared_ptr<Pac

 							return true;
 						}
+						case Command::J2534Command: {
+							result = J2534CommandMessage::decodeToMessage(packet->data);
+							if(!result) {
+								report(APIEvent::Type::PacketDecodingError, APIEvent::Severity::Error);
+								return false;
+							}
+							return true;
+						}
 						default:
 							auto msg = std::make_shared<Main51Message>();
 							msg->command = Command(packet->data[0]);
@@ -0,0 +1,28 @@
+#include "icsneo/communication/message/genericapidatamessage.h"
+#include "icsneo/communication/message/extendedresponsemessage.h"
+#include "icsneo/communication/command.h"
+
+using namespace icsneo;
+
+std::shared_ptr<GenericAPIDataMessage> GenericAPIDataMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+	if(bytestream.size() < sizeof(ExtendedResponseMessage::ResponseHeader))
+		return nullptr;
+
+	const auto* hdr = reinterpret_cast<const ExtendedResponseMessage::ResponseHeader*>(bytestream.data());
+
+	if(hdr->command != ExtendedCommand::ReadGenericAPIData)
+		return nullptr;
+
+	const size_t required = sizeof(ExtendedResponseMessage::ResponseHeader) + sizeof(GenericAPIDataHeader);
+	if(bytestream.size() < required)
+		return nullptr;
+
+	auto msg = std::make_shared<GenericAPIDataMessage>();
+
+	const auto* packet = reinterpret_cast<const GenericAPIDataPacket*>(bytestream.data() + sizeof(ExtendedResponseMessage::ResponseHeader));
+
+	msg->functionId = packet->header.functionId;
+	msg->buffer.resize(packet->header.bufferLength);
+	std::copy(packet->buffer, packet->buffer + packet->header.bufferLength, msg->buffer.data());
+	return msg;
+}
@@ -0,0 +1,29 @@
+#include "icsneo/communication/message/genericapistatusmessage.h"
+#include "icsneo/communication/message/extendedresponsemessage.h"
+#include "icsneo/communication/command.h"
+
+using namespace icsneo;
+
+std::shared_ptr<GenericAPIStatusMessage> GenericAPIStatusMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+	if(bytestream.size() < sizeof(ExtendedResponseMessage::ResponseHeader))
+		return nullptr;
+
+	const auto* hdr = reinterpret_cast<const ExtendedResponseMessage::ResponseHeader*>(bytestream.data());
+
+	if(hdr->command != ExtendedCommand::ReadGenericAPIStatus)
+		return nullptr;
+
+	const size_t required = sizeof(ExtendedResponseMessage::ResponseHeader) + sizeof(GenericAPIStatusResponsePacket);
+	if(bytestream.size() < required)
+		return nullptr;
+
+	auto msg = std::make_shared<GenericAPIStatusMessage>();
+
+	const auto* packet = reinterpret_cast<const GenericAPIStatusResponsePacket*>(bytestream.data() + sizeof(ExtendedResponseMessage::ResponseHeader));
+
+	msg->functionId = packet->functionId;
+	msg->finishedProcessing = static_cast<bool>(packet->finishedProcessing);
+	msg->functionError = packet->functionError;
+	msg->callbackError = packet->callbackError;
+	return msg;
+}
@@ -0,0 +1,337 @@
+#include "icsneo/communication/message/iso15765message.h"
+
+#include <cstring>
+
+using namespace icsneo;
+
+std::shared_ptr<J2534CommandMessage> J2534CommandMessage::decodeToMessage(const std::vector<uint8_t>& data) {
+	if(data.size() < 2)
+		return nullptr;
+
+	auto msg = std::make_shared<J2534CommandMessage>((J2534Command)data[1]);
+	if(data.size() > 2)
+        msg->setArgumentData(std::vector<uint8_t>(data.begin() + 2, data.end()));
+
+	return msg;
+}
+
+uint16_t J2534CommandMessage::read16LE(size_t o) const {
+	return (uint16_t)((uint16_t)argumentData[o] | ((uint16_t)argumentData[o + 1] << 8));
+}
+
+void J2534CommandMessage::write16LE(size_t o, uint16_t v) {
+	argumentData[o] = (uint8_t)(v & 0xFF);
+	argumentData[o + 1] = (uint8_t)((v >> 8) & 0xFF);
+}
+
+uint16_t J2534CommandMessage::read16BE(size_t o) const {
+	return (uint16_t)(((uint16_t)argumentData[o] << 8) | argumentData[o + 1]);
+}
+
+void J2534CommandMessage::write16BE(size_t o, uint16_t v) {
+	argumentData[o] = (uint8_t)((v >> 8) & 0xFF);
+	argumentData[o + 1] = (uint8_t)(v & 0xFF);
+}
+
+void J2534CommandMessage::writeBits16LE(size_t o, unsigned bitPos, unsigned bitCount, uint32_t value) {
+	const uint16_t mask = (uint16_t)(((1u << bitCount) - 1u) << bitPos);
+	uint16_t word = read16LE(o);
+	word = (uint16_t)((word & ~mask) | (((value << bitPos) & mask)));
+	write16LE(o, word);
+}
+
+uint32_t J2534CommandMessage::read32LE(size_t o) const {
+	return  (uint32_t)argumentData[o]
+		| ((uint32_t)argumentData[o + 1] << 8)
+		| ((uint32_t)argumentData[o + 2] << 16)
+		| ((uint32_t)argumentData[o + 3] << 24);
+}
+
+void J2534CommandMessage::write32LE(size_t o, uint32_t v) {
+	argumentData[o] = (uint8_t)(v & 0xFF);
+	argumentData[o + 1] = (uint8_t)((v >> 8) & 0xFF);
+	argumentData[o + 2] = (uint8_t)((v >> 16) & 0xFF);
+	argumentData[o + 3] = (uint8_t)((v >> 24) & 0xFF);
+}
+
+uint32_t J2534CommandMessage::read32BE(size_t o) const {
+	return ((uint32_t)argumentData[o] << 24) | ((uint32_t)argumentData[o + 1] << 16)
+		| ((uint32_t)argumentData[o + 2] << 8) | (uint32_t)argumentData[o + 3];
+}
+
+void J2534CommandMessage::write32BE(size_t o, uint32_t v) {
+	argumentData[o] = (uint8_t)((v >> 24) & 0xFF);
+	argumentData[o + 1] = (uint8_t)((v >> 16) & 0xFF);
+	argumentData[o + 2] = (uint8_t)((v >> 8) & 0xFF);
+	argumentData[o + 3] = (uint8_t)(v & 0xFF);
+}
+
+J2534_RxCanFilter J2534SetupCanRxFilteringMessage::getRxCanFilter() const {
+	constexpr size_t filterSize = sizeof(J2534_RxCanFilter::fb);
+	J2534_RxCanFilter filter = {};
+	if(argumentData.size() >= (10 + filterSize))
+	{
+		filter.idx = (argumentData[2] << 8) | argumentData[3];
+		filter.enabled = (argumentData[4] << 8) | argumentData[5];
+		filter.filterCount = (argumentData[6] << 8) | argumentData[7];
+		filter.fb = *((MessageFilterBytes*)(argumentData.data() + 8));
+		filter.networkId = (argumentData[8 + filterSize] << 8) | argumentData[9 + filterSize];
+	}
+	return filter;
+}
+
+void J2534SetupCanRxFilteringMessage::setRxCanFilter(const J2534_RxCanFilter& filter) {
+	argumentData.resize(10 + sizeof(filter.fb));
+	argumentData[2] = (filter.idx >> 8) & 0xFF;
+	argumentData[3] = filter.idx & 0xFF;
+	argumentData[4] = (filter.enabled >> 8) & 0xFF;
+	argumentData[5] = filter.enabled & 0xFF;
+	argumentData[6] = (filter.filterCount >> 8) & 0xFF;
+	argumentData[7] = filter.filterCount & 0xFF;
+    *((MessageFilterBytes*)(argumentData.data() + 8)) = filter.fb;
+	argumentData[8 + sizeof(filter.fb)] = (filter.networkId >> 8) & 0xFF;
+	argumentData[9 + sizeof(filter.fb)] = filter.networkId & 0xFF;
+}
+
+
+J2534SetupIso15765FlowControlMessage::J2534SetupIso15765FlowControlMessage()
+	: J2534CommandMessage(J2534Command::SetupIso15765RxFilter) {
+	argumentData.resize(MessageSize);
+	// Bytes [0..1] were populated by the base constructor. Everything else starts at zero
+	// (matches the previous behavior which zeroed the flt region and left the rest of the
+	// caller-supplied struct as-is; typical callers value-initialized their struct too).
+	for(size_t i = 2; i < MessageSize; ++i)
+		argumentData[i] = 0;
+}
+
+void J2534SetupIso15765FlowControlMessage::rebuildFilterBytes(void) {
+	// Zero the 28-byte flt region.
+	for(size_t i = 0; i < FltSize; ++i)
+		argumentData[FltOffset + i] = 0;
+
+	const uint32_t id      = read32LE(IdOffset);
+	const uint32_t idMask  = read32LE(IdMaskOffset);
+	const bool is29Bit     = getFlagBit(FlagId29BitEnable);
+	const bool extAddr     = getFlagBit(FlagExtAddressEnable);
+	const uint8_t extAddrByte = argumentData[ExtAddrOffset];
+
+	// CoreMiniMessageFilterBytes has an interleaved layout:
+	//   uiFilterMask0 at flt+0,  uiFilterID0 at flt+2
+	//   uiFilterMask1 at flt+4,  uiFilterID1 at flt+6
+	//   uiFilterMask2 at flt+8,  uiFilterID2 at flt+10
+	//   datalink.uiFilterMask3 at flt+12, datalink.uiFilterID3 at flt+14
+	//
+	// CoreMiniMsgBitsCAN bit layout within each 16-bit unit:
+	//   unit0: IDE(bit0), SRR(bit1), SID(bits2-12), NETWORKINDEX(bits13-15)
+	//   unit1: EID(bits0-11), TXMSG(bit12), ...
+	//   unit2: DLC(bits0-3), ..., RTR(bit9), EID2(bits10-15)
+	const size_t MaskUnit0  = FltOffset + 0;
+	const size_t MaskUnit1  = FltOffset + 4;
+	const size_t MaskUnit2  = FltOffset + 8;
+	const size_t ValueUnit0 = FltOffset + 2;
+	const size_t ValueUnit1 = FltOffset + 6;
+	const size_t ValueUnit2 = FltOffset + 10;
+
+	// filter arbid: pMask->IDE = 1
+	writeBits16LE(MaskUnit0, /*bit*/0, /*width*/1, 1);
+
+	if(is29Bit) {
+		// pValue->IDE = 1; pValue->SID = (id >> 18) & 0x7FF
+		writeBits16LE(ValueUnit0, 0, 1, 1);
+		writeBits16LE(ValueUnit0, 2, 11, (id >> 18) & 0x7FF);
+		// pValue->EID = (id >> 6) & 0xFFF
+		writeBits16LE(ValueUnit1, 0, 12, (id >> 6) & 0xFFF);
+		// pValue->EID2 = id & 0x3F
+		writeBits16LE(ValueUnit2, 10, 6, id & 0x3F);
+		// pMask->SID = (id_mask >> 18) & 0x7FF
+		writeBits16LE(MaskUnit0, 2, 11, (idMask >> 18) & 0x7FF);
+		// pMask->EID = (id_mask >> 6) & 0xFFF  (overlaps pValue->{IDE,SID} storage)
+		writeBits16LE(MaskUnit1, 0, 12, (idMask >> 6) & 0xFFF);
+		// pMask->EID2 = id_mask & 0x3F         (overlaps pValue->EID storage)
+		writeBits16LE(MaskUnit2, 10, 6, idMask & 0x3F);
+	} else {
+		// pValue->IDE = 0 (already zero); pValue->SID = id
+		writeBits16LE(ValueUnit0, 2, 11, id & 0x7FF);
+		// pMask->SID = id_mask
+		writeBits16LE(MaskUnit0, 2, 11, idMask & 0x7FF);
+	}
+
+	// Extended-address filter: writes into the datalink.uiFilterID3 / uiFilterMask3 bytes.
+	//   uiFilterMask3 = flt[12..13] = wire[37..38]
+	//   uiFilterID3   = flt[14..15] = wire[39..40]
+	if(extAddr) {
+		const size_t kValueBytes = FltOffset + 14; // uiFilterID3
+		const size_t kMaskBytes  = FltOffset + 12; // uiFilterMask3
+		argumentData[kValueBytes + 0] = extAddrByte;
+		argumentData[kMaskBytes  + 0] = 0xFF;
+		argumentData[kValueBytes + 1] = 0;
+		argumentData[kMaskBytes  + 1] = 0;
+	}
+}
+
+uint16_t J2534SetupIso15765FlowControlMessage::getIdx(void) const { return read16LE(IdxOffset); }
+void J2534SetupIso15765FlowControlMessage::setIdx(uint16_t idx) { write16LE(IdxOffset, idx); }
+
+uint16_t J2534SetupIso15765FlowControlMessage::getCoreMiniId(void) const { return read16LE(CoreMiniOffset); }
+void J2534SetupIso15765FlowControlMessage::setCoreMiniId(uint16_t coreMiniId) { write16LE(CoreMiniOffset, coreMiniId); }
+
+uint8_t J2534SetupIso15765FlowControlMessage::getPadding(void) const { return argumentData[PaddingOffset]; }
+void J2534SetupIso15765FlowControlMessage::setPadding(uint8_t padding) { argumentData[PaddingOffset] = padding; }
+
+uint32_t J2534SetupIso15765FlowControlMessage::getId(void) const { return read32LE(IdOffset); }
+void J2534SetupIso15765FlowControlMessage::setId(uint32_t id) { write32LE(IdOffset, id); rebuildFilterBytes(); }
+
+uint32_t J2534SetupIso15765FlowControlMessage::getIdMask(void) const { return read32LE(IdMaskOffset); }
+void J2534SetupIso15765FlowControlMessage::setIdMask(uint32_t idMask) { write32LE(IdMaskOffset, idMask); rebuildFilterBytes(); }
+
+uint32_t J2534SetupIso15765FlowControlMessage::getFcId(void) const { return read32LE(FcIdOffset); }
+void J2534SetupIso15765FlowControlMessage::setFcId(uint32_t fcId) { write32LE(FcIdOffset, fcId); }
+
+uint8_t J2534SetupIso15765FlowControlMessage::getFlowControlExtendedAddress(void) const { return argumentData[FcExtAddrOffset]; }
+void J2534SetupIso15765FlowControlMessage::setFlowControlExtendedAddress(uint8_t addr) { argumentData[FcExtAddrOffset] = addr; }
+
+uint8_t J2534SetupIso15765FlowControlMessage::getExtendedAddress(void) const { return argumentData[ExtAddrOffset]; }
+void J2534SetupIso15765FlowControlMessage::setExtendedAddress(uint8_t addr) { argumentData[ExtAddrOffset] = addr; rebuildFilterBytes(); }
+
+uint8_t J2534SetupIso15765FlowControlMessage::getBlockSize(void) const { return argumentData[BlockSizeOffset]; }
+void J2534SetupIso15765FlowControlMessage::setBlockSize(uint8_t blockSize) { argumentData[BlockSizeOffset] = blockSize; }
+
+uint8_t J2534SetupIso15765FlowControlMessage::getStMin(void) const { return argumentData[StMinOffset]; }
+void J2534SetupIso15765FlowControlMessage::setStMin(uint8_t stMin) { argumentData[StMinOffset] = stMin; }
+
+uint16_t J2534SetupIso15765FlowControlMessage::getCfTimeout(void) const { return read16LE(CfTimeoutOffset); }
+void J2534SetupIso15765FlowControlMessage::setCfTimeout(uint16_t cfTimeout) { write16LE(CfTimeoutOffset, cfTimeout); }
+
+uint32_t J2534SetupIso15765FlowControlMessage::getFlags(void) const { return read32LE(FlagsOffset); }
+void J2534SetupIso15765FlowControlMessage::setFlags(uint32_t flags) { write32LE(FlagsOffset, flags); rebuildFilterBytes(); }
+
+bool J2534SetupIso15765FlowControlMessage::getEnable(void) const { return getFlagBit(FlagEnable); }
+void J2534SetupIso15765FlowControlMessage::setEnable(bool enable) { setFlagBit(FlagEnable, enable); }
+
+bool J2534SetupIso15765FlowControlMessage::getIs29BitEnabled(void) const { return getFlagBit(FlagId29BitEnable); }
+void J2534SetupIso15765FlowControlMessage::setIs29BitEnabled(bool enable) { setFlagBit(FlagId29BitEnable, enable); rebuildFilterBytes(); }
+
+bool J2534SetupIso15765FlowControlMessage::getIsFc29BitEnabled(void) const { return getFlagBit(FlagFcId29BitEnable); }
+void J2534SetupIso15765FlowControlMessage::setIsFc29BitEnabled(bool enable) { setFlagBit(FlagFcId29BitEnable, enable); }
+
+bool J2534SetupIso15765FlowControlMessage::getExtAddressEnabled(void) const { return getFlagBit(FlagExtAddressEnable); }
+void J2534SetupIso15765FlowControlMessage::setExtAddressEnabled(bool enable) { setFlagBit(FlagExtAddressEnable, enable); rebuildFilterBytes(); }
+
+bool J2534SetupIso15765FlowControlMessage::getFcExtAddressEnabled(void) const { return getFlagBit(FlagFcExtAddressEnable); }
+void J2534SetupIso15765FlowControlMessage::setFcExtAddressEnabled(bool enable) { setFlagBit(FlagFcExtAddressEnable, enable); }
+
+bool J2534SetupIso15765FlowControlMessage::getFlowControlTransmissionEnabled(void) const { return getFlagBit(FlagEnableFlowControlTransmit); }
+void J2534SetupIso15765FlowControlMessage::setFlowControlTransmissionEnabled(bool enable) { setFlagBit(FlagEnableFlowControlTransmit, enable); }
+
+bool J2534SetupIso15765FlowControlMessage::getPaddingEnabled(void) const { return getFlagBit(FlagPaddingEnable); }
+void J2534SetupIso15765FlowControlMessage::setPaddingEnabled(bool enable) { setFlagBit(FlagPaddingEnable, enable); }
+
+bool J2534SetupIso15765FlowControlMessage::getIsCanFd(void) const { return getFlagBit(FlagIsCanFd); }
+void J2534SetupIso15765FlowControlMessage::setIsCanFd(bool enable) { setFlagBit(FlagIsCanFd, enable); }
+
+bool J2534SetupIso15765FlowControlMessage::getIsBrsEnabled(void) const { return getFlagBit(FlagIsBrsEnabled); }
+void J2534SetupIso15765FlowControlMessage::setIsBrsEnabled(bool enable) { setFlagBit(FlagIsBrsEnabled, enable); }
+
+void J2534SetupIso15765FlowControlMessage::setFlagBit(uint32_t mask, bool enable) {
+	uint32_t f = read32LE(FlagsOffset);
+	if(enable) f |= mask;
+	else        f &= ~mask;
+	write32LE(FlagsOffset, f);
+}
+
+bool J2534SetupIso15765FlowControlMessage::getFlagBit(uint32_t mask) const {
+	return (read32LE(FlagsOffset) & mask) != 0;
+}
+
+uint16_t Iso15765TxSetupMessage::getIdx(void) const { return read16LE(SetupIdxOffset); }
+void Iso15765TxSetupMessage::setIdx(uint16_t idx) { write16LE(SetupIdxOffset, idx); }
+
+uint16_t Iso15765TxSetupMessage::getCoreMiniId(void) const { return read16LE(SetupCoreMiniOffset); }
+void Iso15765TxSetupMessage::setCoreMiniId(uint16_t coreMiniId) { write16LE(SetupCoreMiniOffset, coreMiniId); }
+
+uint32_t Iso15765TxSetupMessage::getMessageLength(void) const { return read32LE(SetupMsgLenOffset); }
+void Iso15765TxSetupMessage::setMessageLength(uint32_t messageLength) { write32LE(SetupMsgLenOffset, messageLength); }
+
+uint8_t Iso15765TxSetupMessage::getPadding(void) const { return argumentData[SetupPaddingOffset]; }
+void Iso15765TxSetupMessage::setPadding(uint8_t padding) { argumentData[SetupPaddingOffset] = padding; }
+
+uint8_t Iso15765TxSetupMessage::getTxDl(void) const { return argumentData[SetupTxDlOffset]; }
+void Iso15765TxSetupMessage::setTxDl(uint8_t txDl) { argumentData[SetupTxDlOffset] = txDl; }
+
+uint32_t Iso15765TxSetupMessage::getId(void) const { return read32LE(SetupIdOffset); }
+void Iso15765TxSetupMessage::setId(uint32_t id) { write32LE(SetupIdOffset, id); }
+
+uint32_t Iso15765TxSetupMessage::getFcId(void) const { return read32LE(SetupFcIdOffset); }
+void Iso15765TxSetupMessage::setFcId(uint32_t fcId) { write32LE(SetupFcIdOffset, fcId); }
+
+uint32_t Iso15765TxSetupMessage::getFcIdMask(void) const { return read32LE(SetupFcIdMaskOffset); }
+void Iso15765TxSetupMessage::setFcIdMask(uint32_t fcIdMask) { write32LE(SetupFcIdMaskOffset, fcIdMask); }
+
+uint8_t Iso15765TxSetupMessage::getFlowControlExtendedAddress(void) const { return argumentData[SetupFcExtAddrOffset]; }
+void Iso15765TxSetupMessage::setFlowControlExtendedAddress(uint8_t addr) { argumentData[SetupFcExtAddrOffset] = addr; }
+
+uint8_t Iso15765TxSetupMessage::getExtendedAddress(void) const { return argumentData[SetupExtAddrOffset]; }
+void Iso15765TxSetupMessage::setExtendedAddress(uint8_t addr) { argumentData[SetupExtAddrOffset] = addr; }
+
+uint16_t Iso15765TxSetupMessage::getFsTimeout(void) const { return read16LE(SetupFsTimeoutOffset); }
+void Iso15765TxSetupMessage::setFsTimeout(uint16_t timeout) { write16LE(SetupFsTimeoutOffset, timeout); }
+
+uint16_t Iso15765TxSetupMessage::getFsWait(void) const { return read16LE(SetupFsWaitOffset); }
+void Iso15765TxSetupMessage::setFsWait(uint16_t wait) { write16LE(SetupFsWaitOffset, wait); }
+
+uint32_t Iso15765TxSetupMessage::getFlags(void) const { return read32LE(SetupFlagsOffset); }
+void Iso15765TxSetupMessage::setFlags(uint32_t flags) { write32LE(SetupFlagsOffset, flags); }
+
+uint8_t Iso15765TxSetupMessage::getStMin(void) const { return argumentData[SetupStMinOffset]; }
+void Iso15765TxSetupMessage::setStMin(uint8_t stMin) { argumentData[SetupStMinOffset] = stMin; }
+
+uint8_t Iso15765TxSetupMessage::getBlockSize(void) const { return argumentData[SetupBlockSizeOffset]; }
+void Iso15765TxSetupMessage::setBlockSize(uint8_t blockSize) { argumentData[SetupBlockSizeOffset] = blockSize; }
+
+bool Iso15765TxSetupMessage::getIs29BitEnabled(void) const { return getFlagBit(FlagId29BitEnable); }
+void Iso15765TxSetupMessage::setIs29BitEnabled(bool enable) { setFlagBit(FlagId29BitEnable, enable); }
+bool Iso15765TxSetupMessage::getIsFc29BitEnabled(void) const { return getFlagBit(FlagFcId29BitEnable); }
+void Iso15765TxSetupMessage::setIsFc29BitEnabled(bool enable) { setFlagBit(FlagFcId29BitEnable, enable); }
+bool Iso15765TxSetupMessage::getExtAddressEnabled(void) const { return getFlagBit(FlagExtAddressEnable); }
+void Iso15765TxSetupMessage::setExtAddressEnabled(bool enable) { setFlagBit(FlagExtAddressEnable, enable); }
+bool Iso15765TxSetupMessage::getFcExtAddressEnabled(void) const { return getFlagBit(FlagFcExtAddressEnable); }
+void Iso15765TxSetupMessage::setFcExtAddressEnabled(bool enable) { setFlagBit(FlagFcExtAddressEnable, enable); }
+bool Iso15765TxSetupMessage::getOverrideStMin(void) const { return getFlagBit(FlagOverrideStMin); }
+void Iso15765TxSetupMessage::setOverrideStMin(bool enable) { setFlagBit(FlagOverrideStMin, enable); }
+bool Iso15765TxSetupMessage::getOverrideBlockSize(void) const { return getFlagBit(FlagOverrideBlockSize); }
+void Iso15765TxSetupMessage::setOverrideBlockSize(bool enable) { setFlagBit(FlagOverrideBlockSize, enable); }
+bool Iso15765TxSetupMessage::getPaddingEnabled(void) const { return getFlagBit(FlagPaddingEnable); }
+void Iso15765TxSetupMessage::setPaddingEnabled(bool enable) { setFlagBit(FlagPaddingEnable, enable); }
+bool Iso15765TxSetupMessage::getIsCanFd(void) const { return getFlagBit(FlagIsCanFd); }
+void Iso15765TxSetupMessage::setIsCanFd(bool enable) { setFlagBit(FlagIsCanFd, enable); }
+bool Iso15765TxSetupMessage::getIsBrsEnabled(void) const { return getFlagBit(FlagIsBrsEnabled); }
+void Iso15765TxSetupMessage::setIsBrsEnabled(bool enable) { setFlagBit(FlagIsBrsEnabled, enable); }
+
+bool Iso15765TxSetupMessage::getFlagBit(uint32_t mask) const {
+	return (getFlags() & mask) != 0;
+}
+
+void Iso15765TxSetupMessage::setFlagBit(uint32_t mask, bool enable) {
+	uint32_t f = getFlags();
+	if(enable) f |= mask;
+	else        f &= ~mask;
+	setFlags(f);
+}
+
+uint16_t Iso15765TxDataMessage::getIdx(void) const { return read16LE(DataIdxOffset); }
+void Iso15765TxDataMessage::setIdx(uint16_t idx) { write16LE(DataIdxOffset, idx); }
+
+uint32_t Iso15765TxDataMessage::getOffset(void) const { return read32LE(DataOffsetOffset); }
+void Iso15765TxDataMessage::setOffset(uint32_t offset) { write32LE(DataOffsetOffset, offset); }
+
+uint16_t Iso15765TxDataMessage::getLen(void) const { return read16LE(DataLenOffset); }
+
+const uint8_t* Iso15765TxDataMessage::getData(void) const { return argumentData.data() + DataPayloadOffset; }
+
+void Iso15765TxDataMessage::setData(const uint8_t* sourceData, uint16_t len) {
+    len = std::min(len, (uint16_t)MaxDataLength);
+	argumentData.resize(DataPayloadOffset + len);
+	write16LE(DataLenOffset, len);
+	if(len > 0 && sourceData != nullptr)
+		std::copy(sourceData, sourceData + len, argumentData.begin() + DataPayloadOffset);
+}
@@ -0,0 +1,77 @@
+#include "icsneo/communication/message/mfgconfigmessage.h"
+#include "icsneo/communication/icspb.h"
+
+#include <algorithm>
+
+using namespace icsneo;
+
+static MfgConfigMessage::VersionNumber versionFromProto(const settings::common::v1::VersionNumber& version) {
+	MfgConfigMessage::VersionNumber decoded;
+	decoded.major = version.major();
+	decoded.minor = version.minor();
+	if(version.has_release())
+		decoded.release = version.release();
+	if(version.has_build())
+		decoded.build = version.build();
+	return decoded;
+}
+
+std::shared_ptr<MfgConfigMessage> MfgConfigMessage::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+	MfgConfigMessage decoded;
+	settings::manufacturing::v1::MfgConfig msg;
+
+	if(!protoapi::processResponse(bytestream.data(), bytestream.size(), msg)) {
+		return nullptr;
+	}
+
+	if(msg.has_serial_number()) {
+		decoded.serialNumber = msg.serial_number();
+	}
+	if(msg.has_manufacture_date()) {
+		const auto& date = msg.manufacture_date();
+		decoded.manufactureDate = MfgDate{date.manufacture_day(), date.manufacture_month(), date.manufacture_year()};
+	}
+	if(msg.has_hardware_rev()) {
+		decoded.hardwareRev = versionFromProto(msg.hardware_rev());
+	}
+	if(msg.has_product_id()) {
+		decoded.productId = static_cast<uint8_t>(msg.product_id());
+	}
+	if(msg.has_bootloader_rev()) {
+		decoded.bootloaderRev = versionFromProto(msg.bootloader_rev());
+	}
+	if(msg.has_usb_descriptor()) {
+		decoded.usbDescriptor = msg.usb_descriptor();
+	}
+	for(const auto& mac : msg.mac_addresses()) {
+		const auto& bytes = mac.mac_addr();
+		if(bytes.size() < MACAddressLength)
+			continue;
+		MACAddress address{};
+		std::copy_n(bytes.begin(), MACAddressLength, address.begin());
+		decoded.macAddresses.push_back(address);
+	}
+	if(msg.has_pcb_serial()) {
+		decoded.pcbSerial = msg.pcb_serial().pcb_serial();
+	}
+	if(msg.has_chip_id()) {
+		decoded.chipId = static_cast<ChipID>(msg.chip_id());
+	}
+	if(msg.has_imei()) {
+		decoded.imei = msg.imei();
+	}
+	if(msg.has_parent_product_id()) {
+		decoded.parentProductId = static_cast<uint8_t>(msg.parent_product_id());
+	}
+	if(msg.has_software_version_lock()) {
+		decoded.softwareVersionLock = versionFromProto(msg.software_version_lock());
+	}
+
+	return std::make_shared<MfgConfigMessage>(decoded);
+}
+
+std::vector<uint8_t> MfgConfigMessage::EncodeArgumentsForGet() {
+	settings::manufacturing::v1::MfgConfig msg;
+	msg.Clear();
+	return protoapi::getPayload(protoapi::Command::GET, msg);
+}
@@ -137,6 +137,7 @@ static std::vector<uint8_t> EncodeFromMessageLIN(std::shared_ptr<Frame> frame, c
 			linpacket->CoreMiniBitsLIN.TXResponder = 1;
 			break;
 		case LINMessage::Type::LIN_BREAK_ONLY:
+			linpacket->CoreMiniBitsLIN.TXCommander = 1;
 			linpacket->CoreMiniBitsLIN.BreakOnly = 1;
 			break;
 		default:
@@ -151,6 +152,7 @@ static std::vector<uint8_t> EncodeFromMessageLIN(std::shared_ptr<Frame> frame, c
 	                linmsg->linMsgType == LINMessage::Type::LIN_UPDATE_RESPONDER) && dataLen > 0;

 	if(hasData) {
+		LINMessage::calcChecksum(*linmsg);
 		// len includes data bytes + 1 checksum byte
 		linpacket->CoreMiniBitsLIN.len = static_cast<uint16_t>(dataLen + 1);
 		std::copy(linmsg->data.begin(), linmsg->data.begin() + dataLen, linpacket->data);
@@ -20,7 +20,7 @@ std::shared_ptr<EthPhyMessage> HardwareEthernetPhyRegisterPacket::DecodeToMessag
 	if(
 		(PhyPacketVersion == pHeader->version) &&
 		(sizeof(PhyRegisterPacket_t) == pHeader->entryBytes) &&
-		(numEntries <= MaxPhyEntries) &&
+		(numEntries > 0 && numEntries <= MaxPhyEntries) &&
 		((bytestream.size() - sizeof(PhyRegisterHeader_t))
 			== (sizeof(PhyRegisterPacket_t) * numEntries))
 	)
@@ -30,11 +30,16 @@ std::shared_ptr<EthPhyMessage> HardwareEthernetPhyRegisterPacket::DecodeToMessag
 		for(size_t entryIdx{0}; entryIdx < numEntries; ++entryIdx)
 		{
 			const PhyRegisterPacket_t* pEntry = (pFirstEntry + entryIdx);
+			if(pEntry->version != PhyPacketVersion) {
+				report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+				return nullptr;
+			}
 			auto phyMessage = std::make_shared<PhyMessage>();
 			phyMessage->Enabled = (pEntry->Enabled != 0u);
 			phyMessage->WriteEnable = (pEntry->WriteEnable != 0u);
 			phyMessage->Clause45Enable = (pEntry->Clause45Enable != 0u);
 			phyMessage->BusIndex = static_cast<uint8_t>(pEntry->BusIndex);
+			phyMessage->Status = static_cast<uint8_t>(pEntry->status);
 			phyMessage->Version = static_cast<uint8_t>(pEntry->version);
 			if(phyMessage->Clause45Enable)
 				phyMessage->Clause45 = pEntry->clause45;
@@ -43,6 +48,10 @@ std::shared_ptr<EthPhyMessage> HardwareEthernetPhyRegisterPacket::DecodeToMessag
 			msg->messages.push_back(phyMessage);
 		}
 	}
+	else {
+		report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+		return nullptr;
+	}
 	return msg;
 }

@@ -59,7 +68,20 @@ bool HardwareEthernetPhyRegisterPacket::EncodeFromMessage(const EthPhyMessage& m
 		report(APIEvent::Type::MessageMaxLengthExceeded, APIEvent::Severity::Error);
 		return false;
 	}
-	auto byteSize = (messageCount * sizeof(PhyRegisterPacket_t)) + sizeof(PhyRegisterHeader_t);
+	// Validate every entry before touching the caller's output or submitting a command.
+	for(const auto& entry : message.messages) {
+		if(!entry) {
+			report(APIEvent::Type::RequiredParameterNull, APIEvent::Severity::Error);
+			return false;
+		}
+		if(entry->BusIndex > 15 || entry->Version != PhyPacketVersion ||
+			(entry->Clause45Enable ? (entry->Clause45.port > FiveBits || entry->Clause45.device > FiveBits) :
+			(entry->Clause22.phyAddr > FiveBits || entry->Clause22.regAddr > FiveBits))) {
+			report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+			return false;
+		}
+	}
+	auto byteSize = bytestream.size() + (messageCount * sizeof(PhyRegisterPacket_t)) + sizeof(PhyRegisterHeader_t);
 	bytestream.reserve(byteSize);
 	bytestream.push_back(static_cast<uint8_t>(messageCount & 0xFF));
 	bytestream.push_back(static_cast<uint8_t>((messageCount >> 8) & 0xFF));
@@ -67,7 +89,7 @@ bool HardwareEthernetPhyRegisterPacket::EncodeFromMessage(const EthPhyMessage& m
 	bytestream.push_back(static_cast<uint8_t>(sizeof(PhyRegisterPacket_t)));
 	for(auto& phyMessage : message.messages)
 	{
-		PhyRegisterPacket_t tempPacket;
+		PhyRegisterPacket_t tempPacket{};
 		tempPacket.Enabled = phyMessage->Enabled ? 0x1u : 0x0u;
 		tempPacket.WriteEnable = phyMessage->WriteEnable ? 0x1u : 0x0u;
 		tempPacket.BusIndex = (phyMessage->BusIndex & 0xF);
@@ -72,18 +72,30 @@ std::shared_ptr<Message> HardwareLINPacket::DecodeToMessage(const std::vector<ui
 		static_cast<bool>(packet->CoreMiniBitsLIN.UpdateResponderOnce),
 		static_cast<bool>(packet->CoreMiniBitsLIN.HasUpdatedResponderOnce),
 		static_cast<bool>(packet->CoreMiniBitsLIN.BusRecovered),
-		static_cast<bool>(packet->CoreMiniBitsLIN.BreakOnly)
+		static_cast<bool>(packet->CoreMiniBitsLIN.BreakOnly),
+		static_cast<bool>(packet->CoreMiniBitsLIN.WakeupRequest)
 	};
-	if(msg->statusFlags.TxCommander || msg->statusFlags.TxResponder)
+	// Wake type only for a wake-only pulse. A UART/LIN break or a complete
+	// frame may also carry WakeupRequest; those keep their existing type.
+	const bool wakeupPulse = msg->statusFlags.WakeupRequest &&
+		packet->CoreMiniBitsLIN.len == 0 &&
+		packet->CoreMiniBitsLIN.ID == 0 &&
+		!msg->statusFlags.BreakOnly &&
+		!msg->errFlags.ErrRxBreakOnly &&
+		!msg->errFlags.ErrRxBreakSyncOnly;
+	if(wakeupPulse)
+		msg->linMsgType = LINMessage::Type::LIN_WAKEUP_REQUEST;
+	else if(msg->statusFlags.TxCommander || msg->statusFlags.TxResponder)
 		msg->linMsgType = LINMessage::Type::LIN_COMMANDER_MSG;
 	else if(msg->statusFlags.BreakOnly)
 		msg->linMsgType = LINMessage::Type::LIN_BREAK_ONLY;
-	if( msg->errFlags.ErrRxBreakOnly     || msg->errFlags.ErrRxBreakSyncOnly ||
+	if( !wakeupPulse &&
+		(msg->errFlags.ErrRxBreakOnly     || msg->errFlags.ErrRxBreakSyncOnly ||
 		msg->errFlags.ErrTxRxMismatch    || msg->errFlags.ErrRxBreakNotZero  ||
 		msg->errFlags.ErrRxBreakTooShort || msg->errFlags.ErrRxSyncNot55     ||
 		msg->errFlags.ErrRxDataLenOver8  || msg->errFlags.ErrFrameSync       ||
 		msg->errFlags.ErrFrameMessageID  || msg->errFlags.ErrChecksumMatch   ||
-		msg->errFlags.ErrFrameResponderData )
+		msg->errFlags.ErrFrameResponderData) )
 		{ msg->linMsgType = LINMessage::Type::LIN_ERROR; }

 	msg->timestamp = packet->timestamp;
@@ -103,7 +115,7 @@ bool HardwareLINPacket::EncodeFromMessage(LINMessage& message, std::vector<uint8
 		}
 		case LINMessage::Type::LIN_BREAK_ONLY:
 		{
-			size |= 0x20u;
+			size |= 0x80u | 0x20u;
 			break;
 		}
 		case LINMessage::Type::NOT_SET:
@@ -231,16 +231,16 @@ MACsecConfig::MACsecConfig(const DeviceType& deviceType) : type(deviceType) {
 		case icsneo::DeviceType::Enum::RADMoon3:
 		case icsneo::DeviceType::Enum::RADEpsilon:
 		case icsneo::DeviceType::Enum::RADGigastar2:
+		case icsneo::DeviceType::Enum::RADComet2:
+		case icsneo::DeviceType::Enum::RADComet3:
 			maxSecY = 2;
 			maxRule = 2;
 			maxSa = 4;
-			binIndex = 0;
 			break;
 		default:
 			maxSecY = 0;
 			maxSa = 0;
 			maxRule = 0;
-			binIndex = 0;
 			ReportEvent(APIEvent::Type::MACsecNotSupported, APIEvent::Severity::Error);
 			return;
 	}
@@ -515,10 +515,6 @@ MACsecConfig::operator bool() const {
 	return (maxSa != 0) || (maxSecY != 0) || (maxRule != 0);
 }

-uint16_t MACsecConfig::getBinIndex() const {
-	return binIndex;
-}
-
 DeviceType MACsecConfig::getType() const {
 	return type;
 }
@@ -8,6 +8,7 @@
 #include "icsneo/disk/fat.h"
 #include "icsneo/communication/message/filter/extendedresponsefilter.h"
 #include "icsneo/communication/message/networkmutexmessage.h"
+#include "icsneo/communication/message/mfgconfigmessage.h"
 #include "icsneo/communication/message/transmitmessage.h"

 #ifdef _MSC_VER
@@ -238,12 +239,12 @@ std::vector<VersionReport> Device::getChipVersions(bool refreshComponents) {
 					auto& version = chipVersions.back();

 					auto disectedVersion = disectVersion(component.dotVersion);
-					version.id          = chipInfo.id;
-					version.name        = chipInfo.name;
-					version.major       = disectedVersion[0];
-					version.minor       = disectedVersion[1];
+					version.id		  = chipInfo.id;
+					version.name		= chipInfo.name;
+					version.major	   = disectedVersion[0];
+					version.minor	   = disectedVersion[1];
 					version.maintenance = disectedVersion[2];
-					version.build       = disectedVersion[3];
+					version.build	   = disectedVersion[3];
 				}
 			}
 		}
@@ -263,12 +264,12 @@ std::vector<VersionReport> Device::getChipVersions(bool refreshComponents) {
 			chipVersions.emplace_back();
 			auto& version = chipVersions.back();

-			version.id          = chipInfo.id;
-			version.name        = chipInfo.name;
-			version.major       = appVer->major;
-			version.minor       = appVer->minor;
+			version.id		  = chipInfo.id;
+			version.name		= chipInfo.name;
+			version.major	   = appVer->major;
+			version.minor	   = appVer->minor;
 			version.maintenance = 0;
-			version.build       = 0;
+			version.build	   = 0;
 		}			
 	}
 	return chipVersions;
@@ -923,6 +924,36 @@ std::shared_ptr<HardwareInfo> Device::getHardwareInfo(std::chrono::milliseconds
 	return hardwareInfo;
 }

+std::shared_ptr<MfgConfigMessage> Device::getMfgConfig() {
+	if(!isOpen()) {
+		report(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error);
+		return nullptr;
+	}
+
+	std::vector<uint8_t> payload = MfgConfigMessage::EncodeArgumentsForGet();
+
+	auto response = com->waitForMessageSync(
+		[this, payload]() {
+			return com->sendCommand(ExtendedCommand::ProtobufAPI, payload);
+		},
+		std::make_shared<MessageFilter>(Message::Type::MfgConfig),
+		std::chrono::milliseconds(250)
+	);
+
+	if(!response) {
+		report(APIEvent::Type::Timeout, APIEvent::Severity::Error);
+		return nullptr;
+	}
+
+	auto mfgConfig = std::dynamic_pointer_cast<MfgConfigMessage>(response);
+	if(!mfgConfig) {
+		report(APIEvent::Type::UnexpectedResponse, APIEvent::Severity::Error);
+		return nullptr;
+	}
+
+	return mfgConfig;
+}
+

 std::optional<uint64_t> Device::readLogicalDisk(uint64_t pos, uint8_t* into, uint64_t amount, std::chrono::milliseconds timeout, Disk::MemoryType memType) {
 	if(!into || timeout <= std::chrono::milliseconds(0)) {
@@ -2022,7 +2053,12 @@ std::optional<EthPhyMessage> Device::sendEthPhyMsg(const EthPhyMessage& message,
 	}

 	std::vector<uint8_t> bytes;
-	HardwareEthernetPhyRegisterPacket::EncodeFromMessage(message, bytes, report);
+	if(timeout.count() <= 0) {
+		report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	if(!HardwareEthernetPhyRegisterPacket::EncodeFromMessage(message, bytes, report))
+		return std::nullopt;
 	std::shared_ptr<Message> response = com->waitForMessageSync(
 		[this, bytes](){ return com->sendCommand(Command::PHYControlRegisters, bytes); },
 		std::make_shared<MessageFilter>(Message::Type::EthernetPhyRegister), timeout);
@@ -3623,7 +3659,7 @@ bool Device::requestTC10Wake(Network::NetID network) {
 	*(Network::NetID*)args.data() = network;
 	auto msg = com->waitForMessageSync([&] {
 		return com->sendCommand(ExtendedCommand::RequestTC10Wake, args);
-	}, std::make_shared<MessageFilter>(Message::Type::ExtendedResponse), std::chrono::milliseconds(1000));
+	}, std::make_shared<ExtendedResponseFilter>(ExtendedCommand::RequestTC10Wake), std::chrono::milliseconds(1000));

 	if(!msg) {
 		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
@@ -3636,7 +3672,11 @@ bool Device::requestTC10Wake(Network::NetID network) {
 		return false;
 	}

-	return resp->response == ExtendedResponse::OK;
+	if(resp->response != ExtendedResponse::OK) {
+		report(APIEvent::Type::TC10RequestFailed, APIEvent::Severity::Error);
+		return false;
+	}
+	return true;
 }

 bool Device::requestTC10Sleep(Network::NetID network) {
@@ -3648,7 +3688,7 @@ bool Device::requestTC10Sleep(Network::NetID network) {
 	*(Network::NetID*)args.data() = network;
 	auto msg = com->waitForMessageSync([&] {
 		return com->sendCommand(ExtendedCommand::RequestTC10Sleep, args);
-	}, std::make_shared<MessageFilter>(Message::Type::ExtendedResponse), std::chrono::milliseconds(1000));
+	}, std::make_shared<ExtendedResponseFilter>(ExtendedCommand::RequestTC10Sleep), std::chrono::milliseconds(1000));

 	if(!msg) {
 		report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
@@ -3661,7 +3701,11 @@ bool Device::requestTC10Sleep(Network::NetID network) {
 		return false;
 	}

-	return typed->response == ExtendedResponse::OK;
+	if(typed->response != ExtendedResponse::OK) {
+		report(APIEvent::Type::TC10RequestFailed, APIEvent::Severity::Error);
+		return false;
+	}
+	return true;
 }

 bool Device::reboot(bool safe) {
@@ -3730,7 +3774,15 @@ std::optional<GPTPStatus> Device::getGPTPStatus(std::chrono::milliseconds timeou
 	return *retMsg;
 }

-bool Device::writeMACsecConfig(const MACsecConfig& cfg) {
+std::vector<Network> Device::getMACsecNetworks() const {
+	std::vector<Network> networks;
+	for(const auto& network : getMACsecNetworkMap()) {
+		networks.emplace_back(network.first);
+	}
+	return networks;
+}
+
+bool Device::writeMACsecConfig(const MACsecConfig& cfg, Network::NetID network) {
 	if(!cfg) {
 		report(APIEvent::Type::MACsecNotSupported, APIEvent::Severity::Error);
 		return false;
@@ -3741,8 +3793,15 @@ bool Device::writeMACsecConfig(const MACsecConfig& cfg) {
 		return false;
 	}

+	const auto& networks = getMACsecNetworkMap();
+	const auto binaryIndex = networks.find(network);
+	if(binaryIndex == networks.end()) {
+		report(APIEvent::Type::MACsecNotSupported, APIEvent::Severity::Error);
+		return false;
+	}
+
 	std::vector<uint8_t> raw = cfg.serialize();
-	return writeBinaryFile(raw, cfg.getBinIndex());
+	return writeBinaryFile(raw, binaryIndex->second);
 }

 bool Device::enableNetworkCommunication(bool enable, uint32_t timeout) {
@@ -4096,3 +4155,256 @@ void Device::restartHeartbeat() {
 	stopHeartbeat();
 	startHeartbeat();
 }
+
+bool Device::iso15765Enable(const Network& network) {
+	return J2534_EnableIso15765(network, true);
+}
+
+bool Device::iso15765DisableAll(void) {
+	bool ok = true;
+	for(const auto& slot : iso15765FirmwareEnabled)
+	{
+        if (slot.second)
+        {
+            if (!J2534_EnableIso15765(slot.first, false))
+                ok = false;
+        }
+	}
+	return ok;
+}
+
+bool Device::iso15765TransmitMessage(const Network& network, const Iso15765MessageArgs& msg, const std::chrono::milliseconds& timeout) {
+	if (!isOnline())
+		return false;
+
+	if(iso15765FirmwareEnabled.find(network) == iso15765FirmwareEnabled.end() || !iso15765FirmwareEnabled[network])
+		return false;
+
+	bool result;
+	Iso15765TxSetupMessage setupMsg;
+
+	//Set the network ID to use
+	if(const auto& coreMiniId = network.getCoreMini())
+		setupMsg.setCoreMiniId((uint16_t)*coreMiniId);
+
+	const uint8_t txIndex = msg.getTxIndex();
+	setupMsg.setIdx(txIndex);
+
+	setupMsg.setId(msg.getArbId().Id);
+	setupMsg.setFcId(msg.getFlowControlArbId().Id);
+	setupMsg.setFcIdMask(msg.getFlowControlArbIdMask());
+
+	setupMsg.setFsTimeout(msg.getFsTimeout());
+	setupMsg.setFsWait(msg.getFsWaitTimeout());
+
+	const uint32_t messageLength = (uint32_t)msg.getData().size();
+	setupMsg.setMessageLength(messageLength);
+	setupMsg.setIs29BitEnabled(msg.getArbId().Is29Bit);
+	setupMsg.setIsFc29BitEnabled(msg.getFlowControlArbId().Is29Bit);
+	if(const auto& extAddress = msg.getExtendedAddress())
+	{
+		setupMsg.setExtAddressEnabled(true);
+		setupMsg.setExtendedAddress(*extAddress);
+	}
+	if(const auto& extFcAddress = msg.getFlowControlExtendedAddress())
+	{
+		setupMsg.setFcExtAddressEnabled(true);
+		setupMsg.setFlowControlExtendedAddress(*extFcAddress);
+	}
+	if(const auto& stMin = msg.getStMin())
+	{
+		setupMsg.setOverrideStMin(true);
+		setupMsg.setStMin(*stMin);
+	}
+	if(const auto& blockSize = msg.getBlockSize())
+	{
+		setupMsg.setOverrideBlockSize(true);
+		setupMsg.setBlockSize(*blockSize);
+	}
+	if(const auto& padding = msg.getPaddingValue())
+	{
+		setupMsg.setPaddingEnabled(true);
+		setupMsg.setPadding(*padding);
+	}
+	setupMsg.setIsBrsEnabled(msg.getIsBrsEnabled());
+	setupMsg.setIsCanFd(msg.getIsCanFd());
+	setupMsg.setTxDl(msg.getTxDl());
+
+	{
+		uint32_t octetsToSend = messageLength;
+		const uint8_t* payload = msg.getData().data();
+		uint32_t offset = 0;
+
+		result = J2534_Transaction(network, std::move(setupMsg), timeout);
+		while(result && octetsToSend)
+		{
+			const uint16_t chunkSize = (uint16_t)std::min((uint32_t)Iso15765TxDataMessage::MaxDataLength, octetsToSend);
+
+			Iso15765TxDataMessage dataMsg;
+			dataMsg.setIdx(txIndex);
+			dataMsg.setOffset(offset);
+			dataMsg.setData(&payload[offset], chunkSize);
+
+			result = J2534_Transaction(network, std::move(dataMsg), timeout);
+
+			offset += chunkSize;
+			octetsToSend -= chunkSize;
+		}
+	}
+
+	return result;
+}
+
+bool Device::iso15765SetupRxFlowControl(const Network& network, const Iso15765MessageArgs& msg) {
+	if (!isOnline())
+		return false;
+
+	if(iso15765FirmwareEnabled.find(network) == iso15765FirmwareEnabled.end() || !iso15765FirmwareEnabled[network])
+		return false;
+
+	J2534SetupIso15765FlowControlMessage rxFlowControl;
+
+	rxFlowControl.setIsBrsEnabled(msg.getIsBrsEnabled());
+	rxFlowControl.setIsCanFd(msg.getIsCanFd());
+	rxFlowControl.setIdx(msg.getTxIndex());
+	if(const auto& coreMiniId = network.getCoreMini())
+		rxFlowControl.setCoreMiniId((uint16_t)*coreMiniId);
+	rxFlowControl.setEnable(true);
+	if(const auto& blockSize = msg.getBlockSize())
+	{
+		rxFlowControl.setBlockSize(*blockSize);
+	}
+	rxFlowControl.setCfTimeout(msg.getCfTimeout());
+	rxFlowControl.setFlowControlTransmissionEnabled(msg.getIsFlowControlEnabled());
+	if(const auto& extAddress = msg.getExtendedAddress())
+	{
+		rxFlowControl.setExtendedAddress(*extAddress);
+		rxFlowControl.setExtAddressEnabled(true);
+	}
+	if(const auto& fcExtAddress = msg.getFlowControlExtendedAddress())
+	{
+		rxFlowControl.setFlowControlExtendedAddress(*fcExtAddress);
+		rxFlowControl.setFcExtAddressEnabled(true);
+	}
+	rxFlowControl.setFcId(msg.getFlowControlArbId().Id);
+	rxFlowControl.setIsFc29BitEnabled(msg.getFlowControlArbId().Is29Bit);
+	rxFlowControl.setIs29BitEnabled(msg.getArbId().Is29Bit);
+	rxFlowControl.setId(msg.getArbId().Id);
+	rxFlowControl.setIdMask(msg.getFlowControlArbIdMask());
+	if(const auto& padding = msg.getPaddingValue())
+	{
+		rxFlowControl.setPadding(*padding);
+		rxFlowControl.setPaddingEnabled(true);
+	}
+	if(const auto& stMin = msg.getStMin())
+	{
+		rxFlowControl.setStMin(*stMin);
+	}
+
+	return J2534_Transaction(network, std::move(rxFlowControl), std::chrono::milliseconds(0));
+}
+
+bool Device::J2534_Transaction(const Network& network, J2534CommandMessage&& msg, const std::chrono::milliseconds& timeout) {
+	msg.network = network;
+	if (timeout.count())
+	{
+		static std::shared_ptr<MessageFilter> filter = std::make_shared<Main51MessageFilter>(Command::J2534Command);
+		const auto& response = com->waitForMessageSync([&](void)
+			{
+				return com->sendCommand(msg.command, msg.getArgumentData());
+			}, filter, timeout);
+
+		if (!response)
+		{
+			report(APIEvent::Type::NoDeviceResponse, APIEvent::Severity::Error);
+			return false;
+		}
+
+		auto responseMsg = std::dynamic_pointer_cast<Main51Message>(response);
+		if (!responseMsg || responseMsg->command != Command::J2534Command)
+		{
+			report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
+			return false;
+		}
+	}
+	else
+	{
+		return com->sendCommand(msg.command, msg.getArgumentData());
+	}
+
+	// NOTE: responseMsg->data.front()
+
+	return true;
+}
+
+
+bool Device::J2534_ClearRxFilters(const Network& network)
+{
+	return J2534_Transaction(network, J2534CommandMessage(J2534CommandMessage::J2534Command::SetupClearCanRxFilters, { (uint8_t)0 /* is this necessary? */}), std::chrono::milliseconds(0));
+}
+
+bool Device::J2534_SetupCanRxFilter(const Network& network, const J2534_RxCanFilter& rxCanFilter)
+{
+	return J2534_Transaction(network, J2534SetupCanRxFilteringMessage(rxCanFilter), std::chrono::milliseconds(0));
+}
+
+bool Device::J2534_EnableFiltering(const Network& network, const bool enable)
+{
+	return J2534_Transaction(network, J2534EnableFilteringMessage(enable), std::chrono::milliseconds(0));
+}
+
+
+
+bool Device::J2534_EnableIso15765(const Network& network, const bool enable)
+{
+	if (iso15765FirmwareEnabled[network] == enable)
+		return true;
+
+	if (!J2534_Transaction(network, J2534EnableMessage(enable), std::chrono::milliseconds(0)))
+		return false;
+
+	iso15765FirmwareEnabled[network] = enable;
+
+	if (enable)
+	{
+		// Turn OFF filtering of CAN messages in the firmware
+		return J2534_EnableFirmwareUsbPassFilters(network, false);
+	}
+	return true;
+}
+
+bool Device::J2534_ClearRxFilter(const Network& network, unsigned int iIndex)
+{
+	if (const auto& slot = iso15765FirmwareEnabled.find(network); slot != iso15765FirmwareEnabled.end() && slot->second)
+	{
+		J2534_RxCanFilter rxFilter;
+		memset(&rxFilter, 0, sizeof(rxFilter));
+		rxFilter.idx = (uint16_t)iIndex;
+		return J2534_SetupCanRxFilter(network, rxFilter);
+	}
+	return false;
+}
+
+bool Device::J2534_EnableFirmwareUsbPassFilters(const Network& network, const bool enable)
+{
+	const auto& slot = iso15765FirmwareEnabled.find(network);
+	if (slot == iso15765FirmwareEnabled.end())
+		return false;
+	//check for disconnect here!
+	if (!slot->second)
+	{
+		// Tried to shut-off Rx table message filtering but FW ISO15765 was not enabled
+		return true; //just ignore it, no filtering can occur anyway
+	}
+
+	if (enable) //turning ON filtering in the Firmware based on the rx table
+	{
+		//Rx table message filtering is on by default in the firmware when m_bISO15765_FW_Enabled is true
+		//need to check here to see if we set index 0 to a PASS all filter (i.e. turned off USB filtering)
+		if (!J2534_ClearRxFilters(network))
+			return false;
+	}
+
+	// New "filtering enable" mechanism - old firmware ignores this frame
+	return J2534_EnableFiltering(network, enable);
+}
@@ -1,29 +1,12 @@
 #include "icsneo/device/devicefinder.h"
 #include "icsneo/platform/devices.h"
 #include "icsneo/device/founddevice.h"
-#include "generated/extensions/builtin.h"
 #include "icsneo/platform/servd.h"

 #ifdef ICSNEO_ENABLE_FIRMIO
 #include "icsneo/platform/firmio.h"
 #endif

-#ifdef ICSNEO_ENABLE_RAW_ETHERNET
-#include "icsneo/platform/pcap.h"
-#endif
-
-#ifdef ICSNEO_ENABLE_CDCACM
-#include "icsneo/platform/cdcacm.h"
-#endif
-
-#ifdef ICSNEO_ENABLE_DXX
-#include "icsneo/platform/dxx.h"
-#endif
-
-#ifdef ICSNEO_ENABLE_TCP
-#include "icsneo/platform/tcp.h"
-#endif
-
 using namespace icsneo;

 template<typename T>
@@ -56,22 +39,8 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 	} else {
 		#ifdef ICSNEO_ENABLE_FIRMIO
 		FirmIO::Find(newDriverFoundDevices);
-		#endif
-	
-		#ifdef ICSNEO_ENABLE_TCP
-		TCP::Find(newDriverFoundDevices);
-		#endif
-	
-		#ifdef ICSNEO_ENABLE_RAW_ETHERNET
-		PCAP::Find(newDriverFoundDevices);
-		#endif
-	
-		#ifdef ICSNEO_ENABLE_CDCACM
-		CDCACM::Find(newDriverFoundDevices);
-		#endif
-	
-		#ifdef ICSNEO_ENABLE_DXX
-		DXX::Find(newDriverFoundDevices);
+		#else
+		EventManager::GetInstance().add(APIEvent::Type::ServdDisabled, APIEvent::Severity::EventWarning);
 		#endif
 	}

@@ -221,8 +190,8 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		makeIfSerialMatches<RADMoon3>(dev, newFoundDevices);
 		#endif

-		#ifdef __RADGEMINI_H_
-		makeIfSerialMatches<RADGemini>(dev, newFoundDevices);
+		#ifdef __RADARGOS_H_
+		makeIfSerialMatches<RADArgos>(dev, newFoundDevices);
 		#endif

 		#ifdef __RADMOONDUO_H_
@@ -274,10 +243,6 @@ std::vector<std::shared_ptr<Device>> DeviceFinder::FindAll() {
 		#endif
 	}

-	for(auto& device : newFoundDevices) {
-		AddBuiltInExtensionsTo(device);
-	}
-
 	// Grab a weak pointer from the new devices
 	foundDevices.insert(foundDevices.end(), newFoundDevices.begin(), newFoundDevices.end());

@@ -388,8 +353,8 @@ const std::vector<DeviceType>& DeviceFinder::GetSupportedDevices() {
 		RADMoon3::DEVICE_TYPE,
 		#endif

-		#ifdef __RADGEMINI_H_
-		RADGemini::DEVICE_TYPE,
+		#ifdef __RADARGOS_H_
+		RADArgos::DEVICE_TYPE,
 		#endif

 		#ifdef __RADMOONDUO_H_
@@ -0,0 +1,366 @@
+#include "icsneo/device/extensions/bootloader/api.h"
+#include "icsneo/device/extensions/bootloader/communication/radcommunication.h"
+#include "icsneo/device/extensions/bootloader/communication/radmultichipcommunication.h"
+#include "icsneo/device/extensions/bootloader/communication/radperiphcommunication.h"
+#include "icsneo/device/extensions/bootloader/communication/redcore.h"
+#include "icsneo/device/extensions/bootloader/communication/red.h"
+#include "icsneo/device/extensions/bootloader/communication/application.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+#include "icsneo/communication/message/resetstatusmessage.h"
+#include "icsneo/api/lifetime.h"
+
+#include <algorithm>
+#include <chrono>
+#include <set>
+#include <thread>
+#include <unordered_set>
+
+using namespace icsneo;
+using namespace icsneo::Bootloader;
+
+static std::unique_ptr<Bootloader::Communication> getCommunication(
+	icsneo::Device& device, const FlashPhase& phase, const ChipInfo& chip
+) {
+	switch(phase.comm) {
+		case BootloaderCommunication::Application:
+			return std::make_unique<Application>(device, chip, phase.authenticate, phase.encrypt);
+		case BootloaderCommunication::RED:
+			return std::make_unique<REDCommunication>(device, chip, phase.authenticate, phase.encrypt);
+		case BootloaderCommunication::REDCore:
+			return std::make_unique<REDCoreCommunication>(device, chip);
+		case BootloaderCommunication::RAD:
+			return std::make_unique<RADCommunication>(device, chip);
+		case BootloaderCommunication::RADMultiChip:
+			return std::make_unique<RADMultiChipCommunication>(device, chip, phase.authenticate, phase.slot);
+		case BootloaderCommunication::RADGalaxy2Peripheral:
+			return std::make_unique<RADPeriphCommunication>(device, chip);
+		case BootloaderCommunication::Invalid:
+			break;
+	}
+	return nullptr;
+}
+
+static bool findInfo(icsneo::Device& device, ChipID chip, ChipInfo& info) {
+	const auto& allInfo = device.getChipInfo();
+	auto iter = std::find_if(allInfo.begin(), allInfo.end(), [chip](const auto& candidate) { return candidate.id == chip; });
+	if(iter == allInfo.end()) {
+		return false;
+	}
+	info = *iter;
+	return true;
+}
+
+static const FlashPhase* findCorrespondingFlashPhase(const BootloaderPipeline& pipeline, ChipID chip) {
+	for(const auto& phase : pipeline.phases) {
+		if(phase->getType() == BootloaderPhase::Type::Flash) {
+			const auto* flashPhase = static_cast<const FlashPhase*>(phase.get());
+			if(flashPhase->chip == chip) {
+				return flashPhase;
+			}
+		}
+	}
+	return nullptr;
+}
+
+static std::string chipString(ChipID chip) {
+	return "chip id: " + std::to_string(static_cast<int>(chip));
+}
+
+bool Bootloader::requiresUpdate(icsneo::Device& device, const FWRepo& fw) {
+	const auto versions = device.getChipVersions();
+	for(const auto& info : device.getChipInfo()) {
+		if(!info.defaultEnabled || !info.iefName) {
+			continue;
+		}
+		auto iter = std::find_if(versions.begin(), versions.end(), [&info](const auto& ver) { return ver.id == info.id; });
+		if(iter == versions.end()) {
+			continue;
+		}
+		auto ver = fw.getChipVersion(info.iefName);
+		if(ver && *ver != iter->makeAppVersion()) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/**
+ * Open the communication, run the action, then close it
+ */
+template<typename Action>
+static bool withCommunication(Bootloader::Communication* com, const ChipInfo& info, const char* phaseName, Action action) {
+	if(!com) {
+		Log::Error(phaseName, "no bootloader communication for " + chipString(info.id));
+		return false;
+	}
+	if(!com->open()) {
+		Log::Error(phaseName, "failed to open communication for " + chipString(info.id));
+		return false;
+	}
+	if(!action(*com)) {
+		return false;
+	}
+	if(!com->close()) {
+		Log::Error(phaseName, "failed to close communication for " + chipString(info.id));
+		return false;
+	}
+	return true;
+}
+
+static bool runPipeline(
+	icsneo::Device& device,
+	const BootloaderPipeline& pipeline,
+	const FWRepo& fw,
+	const Logger& logger,
+	bool alreadyInBootloader,
+	bool forceFlash
+) {
+	icsneo::Lifetime suppressHeartbeats = device.suppressDisconnects();
+	const auto versions = device.getChipVersions();
+	std::unordered_set<icsneo::ChipID> chipsFlashed;
+
+	bool updateAll = false;
+	if(auto iter = pipeline.settings.find(BootloaderSetting::UpdateAll); iter != pipeline.settings.end()) {
+		updateAll = std::get<bool>(iter->second);
+	}
+
+	for(const auto& phase : pipeline.phases) {
+		switch(phase->getType()) {
+			case BootloaderPhase::Type::EnterBootloader: {
+				if(alreadyInBootloader) {
+					Log::Trace("EnterBootloaderPhase", "device already in bootloader, skipping");
+					break;
+				}
+				Log::Info("EnterBootloaderPhase", "entering bootloader");
+				if(!enterBootloader(device)) {
+					Log::Error("EnterBootloaderPhase", "failed to enter bootloader");
+					return false;
+				}
+				break;
+			}
+			case BootloaderPhase::Type::Flash: {
+				const auto& flashPhase = static_cast<const FlashPhase&>(*phase);
+				Log::Info("FlashPhase", "started for " + chipString(flashPhase.chip));
+
+				ChipInfo info;
+				if(!findInfo(device, flashPhase.chip, info)) {
+					Log::Error("FlashPhase", "failed to find chip info for " + chipString(flashPhase.chip));
+					return false;
+				}
+
+				const auto sourceVer = info.iefName ? fw.getChipVersion(info.iefName) : std::nullopt;
+				if(!sourceVer) {
+					Log::Trace("FlashPhase", "skipped, no source version for " + chipString(flashPhase.chip));
+					break;
+				}
+				if(!updateAll && !forceFlash) {
+					auto iter = std::find_if(versions.begin(), versions.end(), [&info](const auto& ver) { return ver.id == info.id; });
+					if(iter == versions.end()) {
+						Log::Trace("FlashPhase", "skipped, chip not reported by the device, " + chipString(flashPhase.chip));
+						break;
+					}
+					if(iter->makeAppVersion() == *sourceVer) {
+						Log::Trace("FlashPhase", "skipped, chip already at target version, " + chipString(flashPhase.chip));
+						break;
+					}
+				}
+
+				auto com = getCommunication(device, flashPhase, info);
+				if(!withCommunication(com.get(), info, "FlashPhase", [&](Bootloader::Communication& opened) {
+					if(!opened.flash(fw, logger)) {
+						Log::Error("FlashPhase", "failed to flash " + chipString(flashPhase.chip));
+						return false;
+					}
+					return true;
+				})) {
+					return false;
+				}
+
+				chipsFlashed.insert(info.id);
+				Log::Info("FlashPhase", "completed successfully for " + chipString(flashPhase.chip));
+				break;
+			}
+			case BootloaderPhase::Type::Finalize: {
+				const auto& finalizePhase = static_cast<const FinalizePhase&>(*phase);
+				if(!chipsFlashed.count(finalizePhase.chip)) {
+					Log::Trace("FinalizePhase", "skipped, chip not flashed, " + chipString(finalizePhase.chip));
+					break;
+				}
+				Log::Info("FinalizePhase", "started for " + chipString(finalizePhase.chip));
+				const FlashPhase* flashPhase = findCorrespondingFlashPhase(pipeline, finalizePhase.chip);
+				ChipInfo info;
+				if(!flashPhase || !findInfo(device, finalizePhase.chip, info)) {
+					// Should never happen (developer error)
+					Log::Error("FinalizePhase", "no flash phase or chip info for " + chipString(finalizePhase.chip));
+					return false;
+				}
+
+				auto com = getCommunication(device, *flashPhase, info);
+				if(com && !com->hasFinalizationStep()) {
+					Log::Trace("FinalizePhase", "skipped, no finalization step for " + chipString(finalizePhase.chip));
+					break;
+				}
+
+				if(!withCommunication(com.get(), info, "FinalizePhase", [&](Bootloader::Communication& opened) {
+					if(!opened.finalize()) {
+						Log::Error("FinalizePhase", "failed to finalize " + chipString(finalizePhase.chip));
+						return false;
+					}
+					return true;
+				})) {
+					return false;
+				}
+				Log::Info("FinalizePhase", "completed successfully for " + chipString(finalizePhase.chip));
+				break;
+			}
+			case BootloaderPhase::Type::Reconnect: {
+				Log::Info("ReconnectPhase", "reconnecting to device");
+				if(!device.reconnect(std::chrono::milliseconds(60000))) {
+					Log::Error("ReconnectPhase", "failed to reconnect to device");
+					return false;
+				}
+				break;
+			}
+			case BootloaderPhase::Type::Wait: {
+				const auto& waitPhase = static_cast<const WaitPhase&>(*phase);
+				Log::Trace("WaitPhase", "waiting " + std::to_string(waitPhase.timeout.count()) + "ms");
+				std::this_thread::sleep_for(waitPhase.timeout);
+				break;
+			}
+			case BootloaderPhase::Type::EnterApplication: {
+				const auto& enterAppPhase = static_cast<const EnterApplicationPhase&>(*phase);
+				if(!chipsFlashed.count(enterAppPhase.chip)) {
+					Log::Trace("EnterApplicationPhase", "skipped, chip not flashed, " + chipString(enterAppPhase.chip));
+					break;
+				}
+				Log::Info("EnterApplicationPhase", "started for " + chipString(enterAppPhase.chip));
+				const FlashPhase* flashPhase = findCorrespondingFlashPhase(pipeline, enterAppPhase.chip);
+				ChipInfo info;
+				if(!flashPhase || !findInfo(device, enterAppPhase.chip, info)) {
+					// Should never happen (developer error)
+					Log::Error("EnterApplicationPhase", "no flash phase or chip info for " + chipString(enterAppPhase.chip));
+					return false;
+				}
+
+				auto com = getCommunication(device, *flashPhase, info);
+				if(!withCommunication(com.get(), info, "EnterApplicationPhase", [&](Bootloader::Communication& opened) {
+					if(!opened.enterApplication()) {
+						Log::Error("EnterApplicationPhase", "failed to enter application for " + chipString(enterAppPhase.chip));
+						return false;
+					}
+					return true;
+				})) {
+					return false;
+				}
+				Log::Info("EnterApplicationPhase", "completed successfully for " + chipString(enterAppPhase.chip));
+				break;
+			}
+		}
+	}
+	return exitBootloader(device, logger, !chipsFlashed.empty());
+}
+
+bool Bootloader::update(
+	icsneo::Device& device,
+	const FWRepo& fw,
+	Logger logger,
+	bool alreadyInBootloader,
+	bool forceFlash
+) {
+	const auto pipeline = device.getBootloader();
+	if(!pipeline) {
+		device.getEventHandler()(APIEvent::Type::FirmwareUpdateNotSupported, APIEvent::Severity::Error);
+		return false;
+	}
+
+	if(!runPipeline(device, pipeline, fw, logger, alreadyInBootloader, forceFlash)) {
+		device.getEventHandler()(APIEvent::Type::FirmwareUpdateFailed, APIEvent::Severity::Error);
+		return false;
+	}
+	return true;
+}
+
+bool Bootloader::enterBootloader(icsneo::Device& device) {
+	if(!device.com->sendCommand(icsneo::Command::EnterBootloader)) {
+		return false;
+	}
+	return device.reconnect(std::chrono::milliseconds(30000));
+}
+
+bool Bootloader::exitBootloader(icsneo::Device& device, Logger logger, bool updatedChips) {
+	if(!updatedChips) {
+		return true;
+	}
+	logger(icsneo::Device::OpenStatusType::Progress, "Connecting to the device...", std::nullopt);
+	return verifyConnection(device, logger);
+}
+
+/**
+ * Toggle network communication and wait up to 5 seconds for a reset status confirming the change.
+ * Like icsneo::Device::goOnline(), a timeout is not an error.
+ */
+static bool setCommunicationEnabled(icsneo::Device& device, const Logger& logger, bool enable, double progressStart) {
+	static constexpr std::chrono::seconds Timeout(5);
+	const auto filter = std::make_shared<MessageFilter>(Message::Type::ResetStatus);
+
+	if(!device.com->sendCommand(Command::EnableNetworkCommunication, enable)) {
+		return false;
+	}
+	device.com->sendCommand(Command::UpdateLEDState, std::vector<uint8_t>({uint8_t(enable ? 0x10 : 0x04)}));
+
+	const auto startTime = std::chrono::steady_clock::now();
+	auto elapsedTime = std::chrono::duration<double>(0);
+	while(elapsedTime < Timeout) {
+		bool failOut = false;
+		auto msg = device.com->waitForMessageSync([&device, &failOut]() {
+			if(!device.com->sendCommand(Command::RequestStatusUpdate)) {
+				failOut = true;
+				return false;
+			}
+			return true;
+		}, filter, std::chrono::milliseconds(100));
+
+		if(failOut) {
+			return false;
+		}
+
+		if(msg && std::static_pointer_cast<icsneo::ResetStatusMessage>(msg)->comEnabled == enable) {
+			break;
+		}
+
+		// Each call covers half of the overall progress
+		logger(icsneo::Device::OpenStatusType::Progress, "Connecting to the device...", progressStart + (elapsedTime / Timeout) / 2.0);
+		elapsedTime = std::chrono::steady_clock::now() - startTime;
+	}
+	logger(icsneo::Device::OpenStatusType::Progress, "Connecting to the device...", progressStart + 0.5);
+	return true;
+}
+
+bool Bootloader::verifyConnection(icsneo::Device& device, Logger logger) {
+	// Firmware needs to confirm the update by verifying that it can enable/disable the connection on the device
+	return setCommunicationEnabled(device, logger, true, 0.0) && setCommunicationEnabled(device, logger, false, 0.5);
+}
+
+bool Bootloader::isSFPChip(const icsneo::Bootloader::Chip& chip) {
+	static const std::set<icsneo::ChipID> sfpChipIDs = {
+		icsneo::ChipID::SFPModule_88q2112_MCHIP,
+		icsneo::ChipID::SFPModule_88q2221_MCHIP,
+		icsneo::ChipID::SFPModule_88q3244_MCHIP,
+		icsneo::ChipID::SFPModule_ent11100_MCHIP,
+		icsneo::ChipID::SFPModule_lan8670_MCHIP,
+		icsneo::ChipID::SFPModule_ad1101_MCHIP,
+	};
+	return sfpChipIDs.find(chip.getID()) != sfpChipIDs.end();
+}
+
+bool Bootloader::isSFPIEF(const icsneo::Bootloader::IEF& ief) {
+	static const std::set<icsneo::Device::ProductID> sfpProductIDs = {
+		icsneo::Device::ProductID::SFPModule_88q2112,
+		icsneo::Device::ProductID::SFPModule_88q2221m,
+		icsneo::Device::ProductID::SFPModule_88q4364,
+		icsneo::Device::ProductID::SFPModule_ent11100,
+		icsneo::Device::ProductID::SFPModule_lan8670,
+		icsneo::Device::ProductID::SFPModule_ad1101,
+	};
+	return sfpProductIDs.find(static_cast<icsneo::Device::ProductID>(ief.getVersion().prodId)) != sfpProductIDs.end();
+}
@@ -0,0 +1,407 @@
+#include "icsneo/device/extensions/bootloader/communication/application.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+#include "icsneo/device/extensions/bootloader/api.h"
+#include "icsneo/communication/message/extendedresponsemessage.h"
+#include "icsneo/communication/message/main51message.h"
+
+#include <algorithm>
+#include <condition_variable>
+#include <cstring>
+#include <limits>
+#include <mutex>
+#include <optional>
+#include <thread>
+
+#include <icsbl/icsbl.h>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+bool Application::enterApplication() {
+	// Always reboot
+	Log::Info(__func__, "sending reboot command");
+	bool ok = device.com->sendCommand(icsneo::ExtendedCommand::Reboot);
+	if(!ok) {
+		Log::Error(__func__, "reboot command failed");
+	}
+	return ok;
+}
+
+bool Application::finalize() {
+	Log::Debug(__func__, "sending finalize command");
+	bool ok = sendCommand(Update::Finalize, [](double) {});
+	if(!ok) {
+		Log::Error(__func__, "finalize command failed");
+	}
+	return ok;
+}
+
+bool Application::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	Log::Info(__func__, "starting flash for " + targetChip.getName());
+	const auto& srcVer = fw.getVersion();
+
+	std::vector<uint8_t> bin;
+	if(!fw.getFW(targetChip.getIEFName(), bin)) {
+		Log::Error(__func__, "failed to get firmware for " + targetChip.getIEFName());
+		return false;
+	}
+
+	IEF ief;
+	if(!ief.load(std::move(bin))) {
+		Log::Error(__func__, "failed to load IEF for " + targetChip.getName());
+		return false;
+	}
+
+	auto currentString = "Preparing to update " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+
+	// The supplied IEF is not for this product
+	if(ief.getVersion().prodId != static_cast<uint8_t>(device.getProductID())) {
+		Log::Error(__func__, "IEF product ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	// The supplied IEF is for this product, but not for this chip
+	if(ief.getVersion().chipId != static_cast<uint8_t>(targetChip.getID())) {
+		Log::Error(__func__, "IEF chip ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	if(doAuthChecks) {
+		if(!authenticate()) {
+			Log::Error(__func__, "authentication failed for " + targetChip.getName());
+			return false;
+		}
+
+		// Tell the application software what version of Vehicle Spy 3 this firmware is from.
+		// We check to make sure it approves, but also, the device will not accept new firmware
+		// if we have not sent this.
+		// Sometimes new hardware revisions can not accept firmware which is too old.
+		if(!sendCommand(Update::CheckVersion, [](double) {}, 0, {srcVer.major, srcVer.minor, srcVer.release, srcVer.build})) {
+			Log::Error(__func__, "version check failed for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	bool ok = sendSoftware(ief.getSectors(), ief.getBlockSize(), handler);
+	if(!ok) {
+		Log::Error(__func__, "sendSoftware failed for " + targetChip.getName());
+	}
+	return ok;
+}
+
+bool Application::authenticate() {
+	icsbl_seed_v1 seed = {};
+	if(!icsbl_generate_seed_v1(device.getSerialNumber(), &seed)) {
+		Log::Error(__func__, "libicsbl could not generate an authentication challenge");
+		return false;
+	}
+
+	// Send the challenge (seed.a), the device replies with seed.b and one trailing byte
+	std::vector<uint8_t> cmdArgs(sizeof(seed.a));
+	writeLE32(cmdArgs.data(), seed.a[0]);
+	writeLE32(cmdArgs.data() + 4, seed.a[1]);
+
+	auto filter = std::make_shared<icsneo::MessageFilter>(icsneo::Message::Type::Main51);
+	auto msg = device.com->waitForMessageSync([&] {
+		return device.com->sendCommand(icsneo::Command::ValidateDevice, cmdArgs);
+	}, filter, std::chrono::milliseconds(200));
+
+	if(!msg) {
+		Log::Error(__func__, "No response from the device");
+		return false;
+	}
+
+	auto main51Msg = std::static_pointer_cast<icsneo::Main51Message>(msg);
+
+	if(main51Msg->data.size() != sizeof(seed.b) + 1) {
+		Log::Error(__func__, "Unexpected authentication reply size from the device");
+		return false;
+	}
+
+	const bool authenticated = readLE32(main51Msg->data.data()) == seed.b[0] && readLE32(main51Msg->data.data() + 4) == seed.b[1];
+	if(!authenticated) {
+		Log::Error(__func__, "The authentication reply does not match, the device did not authenticate");
+	}
+	return authenticated;
+}
+
+bool Application::validateFirmware(const DeviceAppVersion& chipSrcVer) {
+	return sendCommand(Update::CheckComponentVersion, [](double) {}, 0, {chipSrcVer.major, chipSrcVer.minor});
+}
+
+bool Application::sendSoftware(const std::vector<uint8_t>& bin, const icsneo::Device::OpenStatusHandler& handler) {
+	Log::Debug(__func__, "starting for " + targetChip.getName() + " (" + std::to_string(bin.size()) + " bytes)");
+	auto currentString = "Preparing to update " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+	if(bin.empty() || bin.size() > std::numeric_limits<uint32_t>::max()) {
+		Log::Error(__func__, "invalid firmware size for " + targetChip.getName());
+		return false;
+	}
+	const uint32_t totalSize = static_cast<uint32_t>(bin.size());
+
+	Log::Debug(__func__, "erasing " + targetChip.getName());
+	if(!sendCommand(Update::Erase, 0, totalSize, [&](double progress) {
+		handler(icsneo::Device::OpenStatusType::Progress, currentString, progress);
+	}, std::chrono::milliseconds(45000))) {
+		Log::Error(__func__, "erase failed for " + targetChip.getName());
+		return false;
+	}
+
+	currentString = "Updating " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+
+	const uint32_t stepSize = std::min<uint32_t>(totalSize, 2048);
+	uint32_t bytesTransferred = 0;
+	while(bytesTransferred < totalSize) {
+		const uint32_t bytesToSend = std::min(stepSize, totalSize - bytesTransferred);
+		if(!sendCommand(Update::Write, [](double) {}, bytesTransferred, { bin.begin() + bytesTransferred, bin.begin() + bytesTransferred + bytesToSend})) {
+			Log::Error(__func__, "write failed at offset " + std::to_string(bytesTransferred) + " for " + targetChip.getName());
+			return false;
+		}
+
+		bytesTransferred += bytesToSend;
+		handler(icsneo::Device::OpenStatusType::Progress, currentString, double(bytesTransferred) / totalSize);
+	}
+	Log::Debug(__func__, "write complete, validating " + targetChip.getName());
+	if(!validateComponent()) {
+		Log::Error(__func__, "validation failed for " + targetChip.getName());
+		return false;
+	}
+	Log::Debug(__func__, "completed successfully for " + targetChip.getName());
+	return true;
+}
+
+bool Application::sendSoftware(const std::vector<IEF::Sector>& sectorPairs, uint32_t blockSize, const icsneo::Device::OpenStatusHandler& handler) {
+	if(sectorPairs.empty()) {
+		Log::Error(__func__, "no sectors to flash for " + targetChip.getName());
+		return false;
+	}
+
+	Log::Debug(__func__, "starting for " + targetChip.getName() + " (" + std::to_string(sectorPairs.size()) + " sectors)");
+	auto currentString = "Preparing to update " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+	uint64_t totalSize = 0;
+	for(const auto& sector : sectorPairs) {
+		totalSize += sector.second.size();
+	}
+	if(totalSize > std::numeric_limits<uint32_t>::max()) {
+		Log::Error(__func__, "total size too large for " + targetChip.getName());
+		return false;
+	}
+
+	if(totalSize == 0) {
+		Log::Error(__func__, "total size is 0 for " + targetChip.getName());
+		return false;
+	}
+
+	Log::Debug(__func__, "erasing " + targetChip.getName() + " (" + std::to_string(totalSize) + " bytes)");
+	if(!sendCommand(Update::Erase, 0, static_cast<uint32_t>(totalSize), [&](double progress) {
+		handler(icsneo::Device::OpenStatusType::Progress, currentString, progress);
+	}, std::chrono::milliseconds(45000))) {
+		Log::Error(__func__, "erase failed for " + targetChip.getName());
+		return false;
+	}
+
+	if(isSFPChip(targetChip)) {
+		// SFPs are not ready to write until 4 seconds after finishing erasing (for some reason)
+		Log::Trace(__func__, "SFP chip detected, waiting 4000ms after erase");
+		std::this_thread::sleep_for(std::chrono::milliseconds(4000));
+	}
+
+	currentString = "Updating " + targetChip.getName() + "...";
+	handler(icsneo::Device::OpenStatusType::Progress, currentString, std::nullopt);
+
+	uint32_t bytesTransferred = 0;
+	for(const auto& pair : sectorPairs) {
+		const auto& rawData = pair.second;
+		const uint32_t offset = pair.first * blockSize;
+		std::vector<uint8_t> processedData(rawData.begin(), rawData.end());
+		if(encrypted) {
+			if(rawData.size() % 8 != 0) {
+				Log::Error(__func__, "raw data size not aligned");
+				return false;
+			}
+			icsbl_encrypt_v1(device.getSerialNumber(), rawData.data(), rawData.size(), processedData.data());
+		}
+
+		if(!sendCommand(Update::Write, [](double) {}, offset, processedData)) {
+			Log::Error(__func__, "write failed at offset " + std::to_string(offset) + " for " + targetChip.getName());
+			return false;
+		}
+
+		bytesTransferred += static_cast<uint32_t>(rawData.size());
+		handler(icsneo::Device::OpenStatusType::Progress, currentString, double(bytesTransferred) / double(totalSize));
+	}
+	Log::Debug(__func__, "write complete, validating " + targetChip.getName());
+	bool ok = validateComponent();
+	if(!ok) {
+		Log::Error(__func__, "validation failed for " + targetChip.getName());
+	}
+	else {
+		Log::Debug(__func__, "completed successfully for " + targetChip.getName());
+	}
+	return ok;
+}
+
+bool Application::validateComponent() {
+	Log::Debug(__func__, "validating " + targetChip.getName());
+	bool ok = sendCommand(Update::ValidateComponent, [](double) {}, 0, {}, std::chrono::milliseconds(45000));
+	if(!ok) {
+		Log::Error(__func__, "validation failed for " + targetChip.getName());
+	}
+	return ok;
+}
+
+/**
+ * Send one SoftwareUpdate sub-command and wait for it to complete.
+ *
+ * The device answers the request with OK when it is already done, or OperationPending when it will
+ * finish later. For a pending command we poll Update::GetProgress (except for Write and
+ * ValidateComponent, which do not report progress) until the device sends a final OK or the timeout
+ * passes. Progress replies are OperationPending with a SoftwareUpdateCommandHeader whose
+ * commandSizeOrProgress holds the progress so far, or a GenericReturn with no progress.
+ */
+bool Application::sendCommand(Update command, uint32_t offset, uint32_t length, const StatusHandler& handler, std::chrono::milliseconds timeout, std::vector<uint8_t> args) {
+	bool finishedResponse = false;
+	std::condition_variable finishedResponseCV;
+	std::mutex finishedResponseMutex;
+
+	std::optional<uint32_t> progress;
+	std::condition_variable progressCV;
+	std::mutex progressMutex;
+
+	bool firstResponse = true;
+	// Register the callback before sending the command, so that if it goes from pending to finished quickly we will still catch it
+	const auto callback = std::make_shared<icsneo::MessageCallback>(std::make_shared<icsneo::MessageFilter>(icsneo::Message::Type::ExtendedResponse), [&](std::shared_ptr<icsneo::Message> msg) {
+		if(firstResponse) {
+			firstResponse = false;
+			return true; // let waitForMessageSync handle the first message
+		}
+		auto extMsg = std::static_pointer_cast<ExtendedResponseMessage>(msg);
+		if(extMsg->command != ExtendedCommand::SoftwareUpdate) {
+			Log::Error(__func__, "Got an extended response for a command other than SoftwareUpdate");
+			return false;
+		}
+		if(extMsg->response == ExtendedResponse::OK) {
+			{
+				std::scoped_lock lk(finishedResponseMutex);
+				finishedResponse = true;
+			}
+			finishedResponseCV.notify_one();
+		} else if(extMsg->response == ExtendedResponse::OperationPending) {
+			if(extMsg->data.size() < sizeof(ExtendedResponseMessage::ResponseHeader)) {
+				Log::Error(__func__, "The pending response is too short to contain a header");
+				return false;
+			}
+			ExtendedResponseMessage::ResponseHeader respHeader;
+			std::memcpy(&respHeader, extMsg->data.data(), sizeof(respHeader));
+			if(respHeader.command == ExtendedCommand::SoftwareUpdate) {
+				if(respHeader.length != sizeof(SoftwareUpdateCommandHeader) ||
+					extMsg->data.size() < sizeof(ExtendedResponseMessage::ResponseHeader) + sizeof(SoftwareUpdateCommandHeader)) {
+					Log::Error(__func__, "The progress response does not contain a SoftwareUpdate header");
+					return false;
+				}
+				SoftwareUpdateCommandHeader resp;
+				std::memcpy(&resp, extMsg->data.data() + sizeof(ExtendedResponseMessage::ResponseHeader), sizeof(resp));
+				{
+					std::scoped_lock lk(progressMutex);
+					progress.emplace(resp.commandSizeOrProgress);
+				}
+				progressCV.notify_one();
+			} else if(respHeader.command == ExtendedCommand::GenericReturn) {
+				// No progress information, the final OK comes later
+				{
+					std::scoped_lock lk(progressMutex);
+					progress.emplace(0);
+				}
+				progressCV.notify_one();
+			} else {
+				Log::Error(__func__, "The pending response is for an unexpected command");
+				return false;
+			}
+		} else {
+			Log::Error(__func__, "The device reported an error for the SoftwareUpdate command");
+			return false;
+		}
+		return true;
+	});
+	const auto finishedCallbackHandle = device.com->addMessageCallback(callback);
+	Lifetime statusCallbackCleanup([&] {
+		device.com->removeMessageCallback(finishedCallbackHandle);
+	});
+
+	SoftwareUpdateCommandHeader header = {};
+	header.componentIdentifier = static_cast<uint32_t>(targetChip.getID());
+	header.commandType = command;
+	header.offset = offset;
+	header.commandSizeOrProgress = length;
+	header.expansionSlot = targetChip.expansionSlot;
+	const auto headerBytes = reinterpret_cast<const uint8_t*>(&header);
+	args.insert(args.begin(), headerBytes, headerBytes + sizeof(header));
+
+	{
+		auto msg = device.com->waitForMessageSync([&] {
+			return device.com->sendCommand(ExtendedCommand::SoftwareUpdate, args);
+		}, std::make_shared<icsneo::MessageFilter>(icsneo::Message::Type::ExtendedResponse), timeout);
+
+		if(!msg) {
+			Log::Error(__func__, "No response to the SoftwareUpdate command");
+			return false;
+		}
+
+		auto extMsg = std::static_pointer_cast<ExtendedResponseMessage>(msg);
+		if(extMsg->command != ExtendedCommand::SoftwareUpdate) {
+			Log::Error(__func__, "Got an extended response for a command other than SoftwareUpdate");
+			return false;
+		}
+		if(extMsg->response == ExtendedResponse::OK) {
+			return true;
+		}
+		if(extMsg->response != ExtendedResponse::OperationPending) {
+			Log::Error(__func__, "The device rejected the SoftwareUpdate command");
+			return false;
+		}
+	}
+
+	SoftwareUpdateCommandHeader progressHeader = {};
+	progressHeader.componentIdentifier = static_cast<uint32_t>(targetChip.getID());
+	progressHeader.commandType = Update::GetProgress;
+	progressHeader.expansionSlot = targetChip.expansionSlot;
+	const auto progressHeaderBytes = reinterpret_cast<const uint8_t*>(&progressHeader);
+	const std::vector<uint8_t> progressArgs(progressHeaderBytes, progressHeaderBytes + sizeof(progressHeader));
+	const auto deadline = std::chrono::steady_clock::now() + timeout;
+	// Write and ValidateComponent do not report progress, just wait for the final OK
+	if(command != Update::Write && command != Update::ValidateComponent) {
+		while(std::chrono::steady_clock::now() < deadline) {
+			{
+				std::unique_lock lk(progressMutex);
+				progress.reset();
+				if(!device.com->sendCommand(ExtendedCommand::SoftwareUpdate, progressArgs)) {
+					Log::Error(__func__, "Failed to send progress request to the device");
+					return false;
+				}
+				if(!progressCV.wait_for(lk, std::chrono::milliseconds(5000), [&]{ return progress.has_value(); })) {
+					Log::Error(__func__, "No progress response from device");
+					return false;
+				}
+				handler(*progress / double(length));
+			}
+			{
+				std::scoped_lock lk(finishedResponseMutex);
+				if(finishedResponse) {
+					break;
+				}
+			}
+		}
+	}
+
+	std::unique_lock lk(finishedResponseMutex);
+	return finishedResponseCV.wait_until(lk, deadline, [&]{ return finishedResponse; });
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,14 @@
+#include "icsneo/device/extensions/bootloader/communication/communication.h"
+
+using namespace icsneo::Bootloader;
+
+uint32_t Communication::readLE32(const uint8_t* buf) {
+	return (uint32_t)buf[0] | ((uint32_t)buf[1] << 8) | ((uint32_t)buf[2] << 16) | ((uint32_t)buf[3] << 24);
+}
+
+void Communication::writeLE32(uint8_t* buf, uint32_t num) {
+	buf[0] = num & 0xFFu;
+	buf[1] = (num >> 8) & 0xFFu;
+	buf[2] = (num >> 16) & 0xFFu;
+	buf[3] = (num >> 24) & 0xFFu;
+}
@@ -0,0 +1,547 @@
+#include "icsneo/device/extensions/bootloader/communication/radcommunication.h"
+#include "icsneo/device/extensions/bootloader/communication/bootloaderversion.h"
+#include "icsneo/device/extensions/bootloader/parser/fwzip.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <algorithm>
+#include <cstring>
+#include <thread>
+
+#include <icsbl/icsbl.h>
+
+using namespace icsneo::Bootloader;
+
+RADCommunication::RADCommunication(icsneo::Device& dev, const ChipInfo& info)
+	: Communication(dev), targetChip(info) {}
+
+bool RADCommunication::supportsFlashBuffer() const {
+	switch(targetChip.getID()) {
+		case icsneo::ChipID::RADGigastar_USBZ_ZYNQ:
+		case icsneo::ChipID::RADGigastar_USBZ_Z7007S_ZYNQ:
+		case icsneo::ChipID::RADGigastar_USBZ_Z7010_ZYNQ: {
+			return true;
+		}
+		default:
+			return false;
+	}
+}
+
+RADCommunication::Request RADCommunication::makeRequest(Request::Type type, size_t payloadSize, size_t expectedResponseLen) {
+	const size_t headerSize = supportsZynqBinaryFlasher ? ZynqFlasherHeaderSize : 0;
+	const size_t packetSize = headerSize + 1 + payloadSize; // Header + command + payload
+
+	// This shouldn't cause any re-allocations since we already reserved the MaxMessageLength in initialize()
+	txBuffer.resize(packetSize, 0);
+
+	if(supportsZynqBinaryFlasher) {
+		std::copy(std::begin(ZynqFlasherSync), std::end(ZynqFlasherSync), txBuffer.begin());
+
+		// The length covers the command byte and the payload
+		const uint16_t payloadPlusCmd = static_cast<uint16_t>(payloadSize) + 1;
+		txBuffer[4] = payloadPlusCmd & 0xFFu;
+		txBuffer[5] = (payloadPlusCmd >> 8) & 0xFFu;
+	}
+
+	txBuffer[headerSize] = static_cast<uint8_t>(type);
+
+	Request newRequest;
+	newRequest.type = type;
+	newRequest.expectedResponseLen = expectedResponseLen;
+	if(payloadSize > 0) {
+		newRequest.payload = &txBuffer[headerSize + 1]; // First byte right after the command
+	}
+
+	return newRequest;
+}
+
+bool RADCommunication::sendRequestNoResponse() {
+	/**
+	 * Send our current packet, the payload was written to it if the user
+	 * of this function wrote to request.payload. The remaining details were
+	 * written when makeRequest() was called
+	*/
+	return device.com->sendPacket(txBuffer);
+}
+
+RADCommunication::Response& RADCommunication::sendRequest(const Request& request, std::chrono::milliseconds timeout) {
+	static constexpr size_t ResponseHeaderSize = 2;
+	const size_t rxSize = ResponseHeaderSize + request.expectedResponseLen;
+	/**
+	 * Clear previous response
+	*/
+	lastResponse = Response();
+
+	if(!sendRequestNoResponse()) {
+		Log::Error(__func__, "Failed to send request " + std::to_string(static_cast<uint8_t>(request.type)));
+		return lastResponse;
+	}
+
+	auto& rb = device.com->driver->getReadBuffer();
+	rb.clear();
+	auto result = device.com->driver->waitForRx(rxSize, timeout);
+
+	if(!result) {
+		Log::Error(__func__, "No response to request " + std::to_string(static_cast<uint8_t>(request.type)));
+		return lastResponse;
+	}
+
+	rb.read(rxBuffer.data(), 0, rxSize);
+	rb.clear();
+
+	lastResponse.done = true;
+
+	/**
+	 * Second byte is success/failure byte
+	*/
+	lastResponse.type = static_cast<Response::Type>(rxBuffer[1]);
+
+	/**
+	 * The rest is the payload, if we requested any
+	*/
+	if(request.expectedResponseLen > 0) {
+		lastResponse.payload = &rxBuffer[2];
+		lastResponse.size = request.expectedResponseLen;
+	}
+
+	return lastResponse;
+}
+
+bool RADCommunication::enterApplication() {
+	Log::Info(__func__, "sending EnterApplication request");
+	makeRequest(Request::Type::EnterApplication);
+	bool ok = sendRequestNoResponse();
+	if(!ok) {
+		Log::Error(__func__, "EnterApplication request failed");
+	}
+	return ok;
+}
+
+bool RADCommunication::close() {
+	device.com->resumeReads();
+	return true;
+}
+
+bool RADCommunication::open() {
+	device.com->pauseReads();
+
+	if(!initialize()) {
+		close();
+		return false;
+	}
+
+	if(!sanityCheck()) {
+		// Note: RAD-Gigastar on low power USB flash fails here for some reason, try another sanity check
+		if(!sanityCheck()) {
+			close();
+			return false;
+		}
+	}
+
+	if(!getBootloaderVersion()) {
+		// Try again, just like the sanity checks
+		if(!getBootloaderVersion()) {
+			close();
+			return false;
+		}
+	}
+
+	if(!sanityCheck()) {
+		// Note: RAD-Gigastar on low power USB flash fails here for some reason, try another sanity check
+		if(!sanityCheck()) {
+			close();
+			return false;
+		}
+	}
+
+	if(!authenticate()) {
+		close();
+		return false;
+	}
+
+	return true;
+}
+
+bool RADCommunication::initialize() {
+	auto& rb = device.com->driver->getReadBuffer();
+
+	rxBuffer = std::vector<uint8_t>(MaxMessageLength, 0);
+	txBuffer.reserve(MaxMessageLength);
+
+	// An EnterBootloader command on Main51, as a framed short packet (0xAA, then length << 4 | netid)
+	// with a trailing 0xAF, followed by the same command without the 0xAA framing
+	const uint8_t lengthAndNetID = (1 << 4) | static_cast<uint8_t>(icsneo::Network::NetID::Main51);
+	std::vector<uint8_t> pkt = {
+		0xAA,
+		lengthAndNetID,
+		static_cast<uint8_t>(icsneo::Command::EnterBootloader),
+		0xAF
+	};
+
+	rb.clear();
+	if(!device.com->sendPacket(pkt)) {
+		Log::Error(__func__, "Failed to send the framed enter bootloader command");
+		return false;
+	}
+
+	pkt = {
+		lengthAndNetID,
+		static_cast<uint8_t>(icsneo::Command::EnterBootloader)
+	};
+
+	if(!device.com->sendPacket(pkt)) {
+		Log::Error(__func__, "Failed to send the unframed enter bootloader command");
+		return false;
+	}
+
+	// The Zynq binary flasher answers with the command, Success, then ZynqFlasherSync
+	static constexpr size_t ZynqFlasherReplySize = 2 + sizeof(ZynqFlasherSync);
+	if(!device.com->driver->waitForRx(ZynqFlasherReplySize, std::chrono::milliseconds(1000))) {
+		Log::Error(__func__, "No response to the enter bootloader command");
+		return false;
+	}
+
+	const size_t rxLen = rb.size();
+	if(rxLen == ZynqFlasherReplySize) {
+		rb.read(rxBuffer.data(), 0, rxLen);
+	}
+	rb.clear();
+	supportsZynqBinaryFlasher =
+		rxLen == ZynqFlasherReplySize &&
+		rxBuffer[0] == static_cast<uint8_t>(icsneo::Command::EnterBootloader) &&
+		rxBuffer[1] == static_cast<uint8_t>(Response::Type::Success) &&
+		std::equal(std::begin(ZynqFlasherSync), std::end(ZynqFlasherSync), rxBuffer.begin() + 2);
+
+	return true;
+}
+
+bool RADCommunication::finalize() {
+	return true;
+}
+
+bool RADCommunication::hasFinalizationStep() const {
+	return false;
+}
+
+bool RADCommunication::sanityCheck() {
+	if(!supportsZynqBinaryFlasher) {
+		return true;
+	}
+
+	// Two numbered test patterns the bootloader must accept, the 8 byte replies are not checked
+	constexpr uint8_t PatternA[8] = {0xAA, 0x55, 0xAA, 0x55, 0xAA, 0xAA, 0x55, 0x55};
+	constexpr uint8_t PatternB[8] = {0x12, 0x21, 0x34, 0x43, 0x56, 0x65, 0x78, 0x87};
+
+	auto request = makeRequest(Request::Type::SanityCheck, 1 + sizeof(PatternA), sizeof(PatternA));
+
+	request.payload[0] = 0x01u;
+	std::copy(std::begin(PatternA), std::end(PatternA), request.payload + 1);
+
+	if(!sendRequest(request, std::chrono::milliseconds(1000))) {
+		return false;
+	}
+
+	request.payload[0] = 0x02u;
+	std::copy(std::begin(PatternB), std::end(PatternB), request.payload + 1);
+
+	return sendRequest(request, std::chrono::milliseconds(1000));
+}
+
+bool RADCommunication::getBootloaderVersion() {
+	auto request = makeRequest(Request::Type::BootloaderVersion, 0, sizeof(BootloaderVersionResponse));
+	auto response = sendRequest(request, std::chrono::milliseconds(1000));
+
+	if(!response) {
+		return false;
+	}
+
+	if(response.size < sizeof(BootloaderVersionResponse)) {
+		return false;
+	}
+
+	BootloaderVersionResponse version;
+	std::memcpy(&version, response.payload, sizeof(version));
+	targetChip.info.id = static_cast<ChipID>(version.zynqId);
+	return true;
+}
+
+bool RADCommunication::validateChipVersion(const icsneo::DeviceAppVersion& chipSrcVer) {
+	if(!supportsZynqBinaryFlasher) {
+		return true;
+	}
+
+	auto request = makeRequest(Request::Type::ValidateVersion, 2, 2);
+
+	request.payload[0] = chipSrcVer.major;
+	request.payload[1] = chipSrcVer.minor;
+
+	return sendRequest(request, std::chrono::milliseconds(1000));
+}
+
+bool RADCommunication::authenticate() {
+	icsbl_seed_v1 seed = {};
+	if(!icsbl_generate_seed_v1(device.getSerialNumber(), &seed)) {
+		Log::Error(__func__, "libicsbl could not generate an authentication challenge");
+		return false;
+	}
+
+	auto request = makeRequest(Request::Type::Authenticate, sizeof(seed.a), sizeof(seed.b));
+
+	writeLE32(&request.payload[0], seed.a[0]);
+	writeLE32(&request.payload[4], seed.a[1]);
+
+	auto response = sendRequest(request, std::chrono::milliseconds(2000));
+
+	if(!response) {
+		return false;
+	}
+
+	return seed.b[0] == readLE32(&response.payload[0]) && seed.b[1] == readLE32(&response.payload[4]);
+}
+
+bool RADCommunication::sendSoftware(const std::vector<uint8_t>& chipSoftware) {
+	Log::Debug(__func__, "starting for " + targetChip.getName() + " (" + std::to_string(chipSoftware.size()) + " bytes)");
+	static constexpr size_t MaxEthernetPayload = 1487;
+
+	if(supportsZynqBinaryFlasher && chipSoftware.size() < sizeof(uint32_t)) {
+		Log::Error(__func__, "firmware too short to contain a CRC for " + targetChip.getName());
+		return false;
+	}
+
+	Log::Trace(__func__, "sending BeginTransfer for " + targetChip.getName());
+	auto request = makeRequest(Request::Type::BeginTransfer, 0, 0);
+	auto response = sendRequest(request, std::chrono::milliseconds(10000));
+
+	if(!response) {
+		Log::Error(__func__, "BeginTransfer failed for " + targetChip.getName());
+		return false;
+	}
+
+	const size_t headerSize = 1 + (supportsZynqBinaryFlasher ? ZynqFlasherHeaderSize : 0); // Command byte plus the optional Zynq flasher header
+	const size_t maxPayloadSize = MaxEthernetPayload - headerSize;
+
+	size_t remainingBytes = chipSoftware.size();
+	size_t currentlyReading = 0;
+
+	logger(
+		icsneo::Device::OpenStatusType::Progress,
+		"Flashing " + targetChip.getName() + "...",
+		std::nullopt
+	);
+
+	while(remainingBytes > 0) {
+		const double progress = static_cast<double>(currentlyReading) / static_cast<double>(chipSoftware.size());
+
+		logger(
+			icsneo::Device::OpenStatusType::Progress,
+			"Flashing " + targetChip.getName() + "...",
+			progress
+		);
+
+		size_t numToSend = std::min<size_t>(maxPayloadSize, remainingBytes);
+		request = makeRequest(Request::Type::FWPayload, numToSend, supportsZynqBinaryFlasher ? 2 : 0);
+
+		std::copy(
+			chipSoftware.begin() + currentlyReading,
+			chipSoftware.begin() + currentlyReading + numToSend,
+			request.payload
+		);
+
+		if(supportsFlashBuffer()) {
+			if(!sendRequest(request, std::chrono::milliseconds(2000))) {
+				return false;
+			}
+		} else if(!sendRequestNoResponse()) {
+			return false;
+		}
+
+		currentlyReading += numToSend;
+		remainingBytes -= numToSend;
+		if(device.com->driver->isEthernet()) {
+			std::this_thread::sleep_for(std::chrono::milliseconds(1));
+		}
+	}
+
+	Log::Trace(__func__, "sending EndTransfer for " + targetChip.getName());
+	request = makeRequest(Request::Type::EndTransfer, 0, 0);
+	response = sendRequest(request, std::chrono::milliseconds(10000));
+
+	if(!response) {
+		Log::Error(__func__, "EndTransfer failed for " + targetChip.getName());
+		return false;
+	}
+
+	request = makeRequest(Request::Type::DownloadedBinInfo, 0, 4);
+	response = sendRequest(request, std::chrono::milliseconds(6000));
+
+	if(!response) {
+		Log::Error(__func__, "DownloadedBinInfo failed for " + targetChip.getName());
+		return false;
+	}
+
+	const uint32_t numDownloaded = readLE32(response.payload);
+
+	if(numDownloaded != static_cast<uint32_t>(chipSoftware.size())) {
+		Log::Error(__func__, "downloaded size mismatch for " + targetChip.getName() + ": expected " + std::to_string(chipSoftware.size()) + ", got " + std::to_string(numDownloaded));
+		return false;
+	}
+
+	if(supportsZynqBinaryFlasher) {
+		request = makeRequest(Request::Type::VerifyCRC, sizeof(uint32_t), 2);
+
+		/**
+		 * Copy CRC from end of the binary
+		*/
+		std::copy(chipSoftware.end() - sizeof(uint32_t), chipSoftware.end(), request.payload);
+
+		response = sendRequest(request, std::chrono::milliseconds(2000));
+
+		if(!response) {
+			return false;
+		}
+
+		// The first response byte is 1 when the CRC matched
+		if(response.payload[0] != 0x01) {
+			Log::Error(__func__, "CRC mismatch for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	logger(
+		icsneo::Device::OpenStatusType::Progress,
+		"Flashing " + targetChip.getName() + "...",
+		1.0
+	);
+
+	Log::Debug(__func__, "completed successfully for " + targetChip.getName());
+	return true;
+}
+
+bool RADCommunication::getProgrammingStatus(size_t sizeToValidate) {
+	Log::Debug(__func__, "starting for " + targetChip.getName());
+	auto request = makeRequest(Request::Type::ProgramFlash, 0, supportsZynqBinaryFlasher ? 2 : 0);
+
+	if(!sendRequest(request, std::chrono::milliseconds(2000))) {
+		Log::Error(__func__, "ProgramFlash failed for " + targetChip.getName());
+		return false;
+	}
+
+	request = makeRequest(Request::Type::ProgrammingStatus, 0, 4);
+
+	uint32_t status = 0;
+	const auto beginTime = std::chrono::steady_clock::now();
+
+	logger(
+		icsneo::Device::OpenStatusType::Progress,
+		"Programming " + targetChip.getName() + "...",
+		std::nullopt
+	);
+
+	while(status < static_cast<uint32_t>(sizeToValidate)) {
+		const double progress = static_cast<double>(status) / static_cast<double>(sizeToValidate);
+
+		logger(
+			icsneo::Device::OpenStatusType::Progress,
+			"Programming " + targetChip.getName() + "...",
+			progress
+		);
+
+		const auto& response = sendRequest(request, std::chrono::milliseconds(60000));
+		if(!response) {
+			return false;
+		}
+		status = readLE32(response.payload);
+
+		if(std::chrono::steady_clock::now() - beginTime >= std::chrono::milliseconds(180000)) {
+			return false;
+		}
+	}
+
+	logger(
+		icsneo::Device::OpenStatusType::Progress,
+		"Programming " + targetChip.getName() + "...",
+		1.0
+	);
+
+	Log::Debug(__func__, "completed successfully for " + targetChip.getName());
+	return true;
+}
+
+bool RADCommunication::loadZips(const FWRepo& fw, std::vector<uint8_t>& chipSoftware) {
+	if(const auto& segmentNames = targetChip.getMultiIEFName(); !segmentNames.empty()) {
+		std::vector<std::unique_ptr<FWZip>> zips;
+		zips.reserve(segmentNames.size());
+
+		size_t totalSize = 0;
+		for(const auto& name : segmentNames) {
+			std::vector<uint8_t> segment;
+			if(!fw.getFW(name, segment)) {
+				return false;
+			}
+
+			zips.push_back(std::make_unique<FWZip>(std::move(segment)));
+			auto& zip = zips.back();
+			if(!zip->size()) {
+				return false;
+			}
+			totalSize += *zip->size();
+		}
+		chipSoftware.resize(totalSize, 0);
+		size_t offset = 0;
+		for(auto& zip : zips) {
+			if(!zip->readAll(chipSoftware.data() + offset)) {
+				return false;
+			}
+			offset += *(zip->size());
+		}
+		return true;
+	} else if(!targetChip.getIEFName().empty()) {
+		std::vector<uint8_t> bin;
+		if(!fw.getFW(targetChip.getIEFName(), bin)) {
+			return false;
+		}
+		FWZip fwZip(std::move(bin));
+		if(!fwZip.readAll(chipSoftware)) {
+			return false;
+		}
+		return true;
+	}
+	// Should never happen
+	return false;
+}
+
+bool RADCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	Log::Info(__func__, "starting flash for " + targetChip.getName());
+	auto chipSrcVer = fw.getChipVersion(targetChip.getIEFName());
+	if(!chipSrcVer) {
+		Log::Error(__func__, "no chip version found for " + targetChip.getIEFName());
+		return false;
+	}
+
+	std::vector<uint8_t> chipSoftware;
+	if(!loadZips(fw, chipSoftware)) {
+		Log::Error(__func__, "loadZips failed for " + targetChip.getName());
+		return false;
+	}
+
+	logger = handler;
+	if(!validateChipVersion(*chipSrcVer)) {
+		Log::Error(__func__, "validateChipVersion failed for " + targetChip.getName());
+		return false;
+	}
+
+	if(!sendSoftware(chipSoftware)) {
+		Log::Error(__func__, "sendSoftware failed for " + targetChip.getName());
+		return false;
+	}
+
+	if(!supportsFlashBuffer()) {
+		if(!getProgrammingStatus(chipSoftware.size())) {
+			Log::Error(__func__, "getProgrammingStatus failed for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	Log::Info(__func__, "completed successfully for " + targetChip.getName());
+	return true;
+}
@@ -0,0 +1,144 @@
+#include "icsneo/device/extensions/bootloader/communication/radmultichipcommunication.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+#include "icsneo/device/extensions/bootloader/api.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <algorithm>
+#include <thread>
+
+using namespace icsneo::Bootloader;
+
+RADMultiChipCommunication::RADMultiChipCommunication(icsneo::Device& dev, const ChipInfo& chipToFlash, bool auth, uint8_t slot)
+	: RADCommunication(dev, chipToFlash), doAuthChecks(auth), slot(slot) {}
+
+bool RADMultiChipCommunication::authenticate() {
+	if(!doAuthChecks) {
+		Log::Trace(__func__, "auth checks disabled, skipping");
+		return true;
+	}
+	Log::Debug(__func__, "starting authentication");
+	if(!standardComm->authenticate()) {
+		Log::Warning(__func__, "standardComm auth failed, retrying with sanity check");
+		device.com->pauseReads();
+		if(!sanityCheck()) {
+			if(!sanityCheck()) {
+				device.com->resumeReads();
+				Log::Error(__func__, "sanity check failed after retries");
+				return false;
+			}
+		}
+
+		if(!RADCommunication::authenticate()) {
+			device.com->resumeReads();
+			Log::Error(__func__, "RADCommunication auth failed");
+			return false;
+		}
+
+		device.com->resumeReads();
+	}
+	Log::Debug(__func__, "authentication successful");
+	return true;
+}
+
+bool RADMultiChipCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	Log::Info(__func__, "starting flash for " + targetChip.getName());
+	auto chipSrcVer = fw.getChipVersion(targetChip.getIEFName());
+	if(!chipSrcVer) {
+		Log::Error(__func__, "no chip version found for " + targetChip.getIEFName());
+		return false;
+	}
+
+	if(!authenticate()) {
+		Log::Error(__func__, "authentication failed for " + targetChip.getName());
+		return false;
+	}
+
+	if(!standardComm->validateFirmware(*chipSrcVer)) {
+		Log::Error(__func__, "firmware validation failed for " + targetChip.getName());
+		handler(icsneo::Device::OpenStatusType::Failed, "Failed to validate firmware", std::nullopt);
+		return false;
+	}
+
+	if(targetChip.getFirmwareType() == FirmwareType::Zip) {
+		std::vector<uint8_t> chipSoftware;
+		if(!loadZips(fw, chipSoftware)) {
+			Log::Error(__func__, "loadZips failed for " + targetChip.getName());
+			return false;
+		}
+
+		if(!standardComm->sendSoftware(chipSoftware, handler)) {
+			return false;
+		}
+	} else {
+		std::vector<uint8_t> bin;
+		if(!fw.getFW(targetChip.getIEFName(), bin)) {
+			return false;
+		}
+
+		IEF ief;
+		if(!ief.load(std::move(bin))) {
+			return false;
+		}
+
+		// The supplied IEF is not for this product
+		if(ief.getVersion().prodId != static_cast<uint8_t>(device.getProductID()) && !isSFPIEF(ief)) {
+			Log::Error(__func__, "IEF product ID mismatch for " + targetChip.getName());
+			return false;
+		}
+
+		// The supplied IEF is for this product, but not for this chip
+		if(ief.getVersion().chipId != static_cast<uint8_t>(targetChip.getID())) {
+			Log::Error(__func__, "IEF chip ID mismatch for " + targetChip.getName());
+			return false;
+		}
+
+		if(!standardComm->sendSoftware(ief.getSectors(), ief.getBlockSize(), handler)) {
+			return false;
+		}
+	}
+	Log::Debug(__func__, "calling finalize");
+	if(!standardComm->finalize()) {
+		Log::Error(__func__, "finalize failed");
+		return false;
+	}
+	Log::Debug(__func__, "finalize successful, proceeding to reboot");
+	handler(icsneo::Device::OpenStatusType::Progress, "Rebooting device...", std::nullopt);
+	return true;
+}
+
+bool RADMultiChipCommunication::enterApplication() {
+	Log::Info(__func__, "starting");
+	if(!standardComm->enterApplication()) {
+		Log::Error(__func__, "reboot failed");
+		return false;
+	}
+	Log::Debug(__func__, "reboot sent, waiting 5000ms");
+	std::this_thread::sleep_for(std::chrono::milliseconds(5000));
+	return true;
+}
+
+bool RADMultiChipCommunication::open() {
+	const auto& components = device.getComponentVersions();
+	auto component = std::find_if(components.begin(), components.end(), [this](const auto& candidate) {
+		if(slot != UINT8_MAX && slot != candidate.expansionSlot) {
+			return false;
+		}
+		return targetChip.getID() == (ChipID)candidate.identifier;
+	});
+	if(component == components.end()) {
+		Log::Error(__func__, "no component found for " + targetChip.getName());
+		return false;
+	}
+	standardComm = std::make_unique<Application>(device, targetChip.info);
+	standardComm->setExpansionSlot(component->expansionSlot);
+	// Pause the read thread so it doesn't consume any responses
+	device.com->pauseReads();
+	const bool res = initialize();
+	device.com->resumeReads();
+	return res;
+}
+
+bool RADMultiChipCommunication::close() {
+	return true;
+}
@@ -0,0 +1,334 @@
+#include "icsneo/device/extensions/bootloader/communication/radperiphcommunication.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <cstddef>
+#include <thread>
+
+#include <icsbl/icsbl.h>
+
+using namespace icsneo::Bootloader;
+
+RADPeriphCommunication::RADPeriphCommunication(icsneo::Device& dev, const ChipInfo& chipToFlash)
+	: Communication(dev), targetChip(chipToFlash) {}
+
+RADPeriphCommunication::~RADPeriphCommunication() {
+	if(device.com->readsArePaused()) {
+		device.com->resumeReads();
+	}
+}
+
+bool RADPeriphCommunication::sendRequestNoResponse(Request req, std::vector<uint8_t>&& args) {
+	return sendRequestNoResponse(req, targetChip.getID(), std::move(args));
+}
+
+bool RADPeriphCommunication::sendRequestNoResponse(Request req, ChipID id, std::vector<uint8_t>&& args) {
+	args.insert(args.begin(), {
+		(uint8_t)id,
+		(uint8_t)req,
+	});
+	return device.com->sendCommand(icsneo::Command::PeripheralBootloader, args);
+}
+
+RADPeriphCommunication::Response RADPeriphCommunication::sendRequest(Request req, std::vector<uint8_t>&& args, std::chrono::milliseconds timeout) {
+	return sendRequest(req, targetChip.getID(), std::move(args), timeout);
+}
+
+RADPeriphCommunication::Response RADPeriphCommunication::sendRequest(Request req, ChipID id, std::vector<uint8_t>&& args, std::chrono::milliseconds timeout) {
+	// Total reply sizes, including the header bytes
+	size_t expectedResponseLength = 0;
+	bool checkBlAccepted = false;
+	switch(req) {
+		case Request::Mode:
+			expectedResponseLength = 6;
+			break;
+		case Request::Version:
+			expectedResponseLength = 24;
+			checkBlAccepted = true;
+			break;
+		case Request::Authenticate:
+			expectedResponseLength = 13;
+			checkBlAccepted = true;
+			break;
+		case Request::Echo:
+			expectedResponseLength = 3;
+			break;
+		case Request::Erase:
+		case Request::FirmwareValidate:
+		case Request::FlashSector:
+			expectedResponseLength = 3;
+			checkBlAccepted = true;
+			break;
+		default:
+			expectedResponseLength = 3;
+			break;
+	}
+
+	auto& rb = device.com->driver->getReadBuffer();
+	rb.clear();
+	if(!sendRequestNoResponse(req, id, std::move(args))) {
+		Log::Error(__func__, "Failed to send request " + std::to_string(static_cast<uint8_t>(req)));
+		return {};
+	}
+
+	auto result = device.com->driver->waitForRx(expectedResponseLength, timeout);
+	if(!result) {
+		Log::Error(__func__, "No response to request " + std::to_string(static_cast<uint8_t>(req)));
+		return {};
+	}
+
+	Response resp;
+	resp.data.resize(expectedResponseLength, 0);
+	rb.read(resp.data.data(), 0, expectedResponseLength);
+	resp.success = resp.data[ReplySuccessOffset] == ReplySuccess;
+	if(!resp.success) {
+		Log::Error(__func__, "The peripheral reported failure for request " + std::to_string(static_cast<uint8_t>(req)));
+		return resp;
+	}
+	if(checkBlAccepted && resp.data[ReplyAcceptedOffset] != ReplyAccepted) {
+		Log::Error(__func__, "The bootloader rejected request " + std::to_string(static_cast<uint8_t>(req)));
+		return {};
+	}
+
+	return resp;
+}
+
+RADPeriphCommunication::Mode RADPeriphCommunication::getMode() {
+	auto resp = sendRequest(Request::Mode, {}, std::chrono::milliseconds(2000));
+
+	if(!resp) {
+		return Mode::NoAnswer;
+	}
+	static constexpr size_t ModeOffset = 4;
+	return (Mode)resp.data[ModeOffset];
+}
+
+bool RADPeriphCommunication::sendPeriphTest() {
+	// Echo is sent to chip id 0, the reply carries the bitwise inverse of the test byte
+	const uint8_t testByte = 0x00;
+	auto resp = sendRequest(Request::Echo, (ChipID)0x00, {testByte}, std::chrono::milliseconds(2000));
+
+	if(!resp) {
+		return false;
+	}
+
+	if(resp.data[2] != static_cast<uint8_t>(~testByte)) {
+		Log::Error(__func__, "The peripheral echo reply did not match");
+		return false;
+	}
+
+	return true;
+}
+
+bool RADPeriphCommunication::readSerialNumber() {
+	auto resp = sendRequest(Request::Version, {0x00}, std::chrono::milliseconds(2000));
+	if(!resp) {
+		return false;
+	}
+
+	// The reply payload is the start of a BootloaderVersionResponse
+	static constexpr size_t SerialOffset = ReplyHeaderSize + offsetof(BootloaderVersionResponse, serialNum);
+	serialNumber = readLE32(resp.data.data() + SerialOffset);
+	return true;
+}
+
+bool RADPeriphCommunication::authenticate() {
+	icsbl_seed_v1 seed = {};
+	if(!icsbl_generate_seed_v1(serialNumber, &seed)) {
+		Log::Error(__func__, "libicsbl could not generate an authentication challenge");
+		return false;
+	}
+
+	std::vector<uint8_t> args(BootloaderArgsOffset + sizeof(seed.a), 0);
+	writeLE32(args.data() + BootloaderArgsOffset, seed.a[0]);
+	writeLE32(args.data() + BootloaderArgsOffset + 4, seed.a[1]);
+
+	auto resp = sendRequest(Request::Authenticate, std::move(args), std::chrono::milliseconds(3000));
+	if(!resp) {
+		return false;
+	}
+
+	// seed.b follows the header and one more byte
+	static constexpr size_t ReplyOffset = ReplyHeaderSize + 1;
+	return readLE32(resp.data.data() + ReplyOffset) == seed.b[0] &&
+		readLE32(resp.data.data() + ReplyOffset + 4) == seed.b[1];
+}
+
+bool RADPeriphCommunication::validateFirmware() {
+	return sendRequest(Request::FirmwareValidate, {0x00u}, std::chrono::milliseconds(2000));
+}
+
+bool RADPeriphCommunication::flashSector(const IEF::Sector& sector) {
+	if(sector.second.size() < FlashSectorFirstChunkSize) {
+		Log::Error(__func__, "Invalid sector length");
+		return false;
+	}
+
+	// The first request is the 32-bit little-endian address followed by the first chunk, encrypted
+	std::vector<uint8_t> args(BootloaderArgsOffset + sizeof(uint32_t) + FlashSectorFirstChunkSize, 0);
+	writeLE32(args.data() + BootloaderArgsOffset, sector.first);
+	icsbl_encrypt_v1(serialNumber, sector.second.begin(), FlashSectorFirstChunkSize, args.data() + BootloaderArgsOffset + sizeof(uint32_t));
+	if(!sendRequestNoResponse(Request::FlashSector, std::move(args))) {
+		return false;
+	}
+	std::this_thread::sleep_for(std::chrono::milliseconds(400));
+
+	// The second request is the rest of the sector, encrypted
+	const size_t bytesLeft = sector.second.size() - FlashSectorFirstChunkSize;
+	args = std::vector<uint8_t>(bytesLeft, 0);
+	icsbl_encrypt_v1(serialNumber, sector.second.begin() + FlashSectorFirstChunkSize, bytesLeft, args.data());
+	return sendRequest(Request::FlashSector, std::move(args), std::chrono::milliseconds(3000));
+}
+
+bool RADPeriphCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	// Validate the firmware before touching the device so a bad file can not leave it erased
+	std::vector<uint8_t> bin;
+	if(!fw.getFW(targetChip.getIEFName(), bin)) {
+		return false;
+	}
+
+	IEF ief;
+	if(!ief.load(std::move(bin))) {
+		return false;
+	}
+
+	// The supplied IEF is not for this product
+	if(ief.getVersion().prodId != static_cast<uint8_t>(device.getProductID())) {
+		Log::Error(__func__, "IEF product ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	// The supplied IEF is for this product, but not for this chip
+	if(ief.getVersion().chipId != static_cast<uint8_t>(targetChip.getID())) {
+		Log::Error(__func__, "IEF chip ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	const auto& sectors = ief.getSectors();
+	uint32_t totalSize = 0;
+	for(const auto& sector : sectors) {
+		if(sector.second.size() < FlashSectorFirstChunkSize) {
+			Log::Error(__func__, "Invalid sector length in IEF for " + targetChip.getName());
+			return false;
+		}
+		totalSize += static_cast<uint32_t>(sector.second.size());
+	}
+
+	if(!readSerialNumber()) {
+		return false;
+	}
+
+	if(!authenticate()) {
+		return false;
+	}
+
+	if(!sendRequest(Request::Erase)) {
+		Log::Error(__func__, "Failed to erase firmware");
+		return false;
+	}
+
+	handler(
+		icsneo::Device::OpenStatusType::Progress,
+		"Flashing " + targetChip.getName() + "...",
+		std::nullopt
+	);
+
+	uint32_t sizeFlashed = 0;
+
+	for(const auto& sector : sectors) {
+		if(!flashSector(sector)) {
+			return false;
+		}
+
+		sizeFlashed += static_cast<uint32_t>(sector.second.size());
+		handler(
+			icsneo::Device::OpenStatusType::Progress,
+			"Flashing " + targetChip.getName() + "...",
+			(double)sizeFlashed / (double)totalSize
+		);
+	}
+
+	return validateFirmware();
+}
+
+bool RADPeriphCommunication::waitForConnect(std::chrono::milliseconds timeout) {
+	const auto deadline = std::chrono::steady_clock::now() + timeout;
+	while(std::chrono::steady_clock::now() < deadline) {
+		if(sendPeriphTest()) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool RADPeriphCommunication::open() {
+	device.com->pauseReads();
+
+	int attempts = 3;
+	do {
+		mode = getMode();
+		if(mode == Mode::NoAnswer) {
+			std::this_thread::sleep_for(std::chrono::milliseconds(500));
+			mode = getMode();
+			if(mode == Mode::NoAnswer) {
+				return false;
+			}
+		}
+
+		if(mode == Mode::MainApplication) {
+			if(!sendRequestNoResponse(Request::SwitchToBootloader)) {
+				return false;
+			}
+			if(!device.reconnect(std::chrono::seconds(30))) {
+				return false;
+			}
+			if(!waitForConnect(std::chrono::seconds(30))) {
+				return false;
+			}
+		} else if(mode == Mode::Bootloader) {
+			return true;
+		}
+	} while(attempts--);
+
+	return false;
+}
+
+bool RADPeriphCommunication::close() {
+	if(mode != Mode::Bootloader) {
+		device.com->resumeReads();
+		return true;
+	}
+	if(!sendRequestNoResponse(Request::SwitchToApp)) {
+		return false;
+	}
+
+	std::this_thread::sleep_for(std::chrono::seconds(5)); // measured at 2s, 5s for buffer, yes this is needed
+
+	if(!device.reconnect(std::chrono::seconds(30))) {
+		return false;
+	}
+
+	if(!waitForConnect()) {
+		return false;
+	}
+
+	mode = getMode();
+	if(mode == Mode::MainApplication) {
+		device.com->resumeReads();
+		return true;
+	}
+	return false;
+}
+
+bool RADPeriphCommunication::enterApplication() {
+	return true;
+}
+
+bool RADPeriphCommunication::finalize() {
+	return true;
+}
+
+bool RADPeriphCommunication::hasFinalizationStep() const {
+	return false;
+}
@@ -0,0 +1,244 @@
+#include "icsneo/device/extensions/bootloader/communication/red.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <cstring>
+#include <optional>
+
+#include <icsbl/icsbl.h>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+REDCommunication::REDCommunication(icsneo::Device& dev, const ChipInfo& chip, bool auth, bool encryptWithDeviceKey)
+	: REDCommunicationBase(dev, chip), doAuthChecks(auth), encryptFirmwareWithDeviceKey(encryptWithDeviceKey) {}
+
+bool REDCommunication::open() {
+	device.com->pauseReads();
+
+	if(doAuthChecks) {
+		if(!authenticate()) {
+			return false;
+		}
+	}
+
+	return getVersion();
+}
+
+bool REDCommunication::authenticate(bool firstTime) {
+	icsbl_seed_v1 seed = {};
+	if(!icsbl_generate_seed_v1(device.getSerialNumber(), &seed)) {
+		Log::Error(__func__, "libicsbl could not generate an authentication challenge");
+		return false;
+	}
+
+	// The challenge is sent as: uint8_t 0x09, uint16_t 0 (a length on top of the protocol length, always zero here),
+	// one padding byte, then seed.a
+	std::vector<uint8_t> challenge(3 + sizeof(seed.a));
+	challenge[0] = 0x09;
+	std::memcpy(&challenge[3], &seed.a, sizeof(seed.a));
+
+	// Ask the bootloader to decode the seed
+	Log::Debug(__func__, "Authenticating");
+	if(!sendCommand(uint8_t(Command::Authenticate), challenge, std::chrono::seconds(1), false)) {
+		if(firstTime) {
+			// Attempt to flush out any buffers
+			Log::Debug(__func__, "Authentication failed, flushing buffers");
+			std::vector<uint8_t> flush(4096, PaddingByte);
+			device.com->sendPacket(flush);
+
+			// Allow any failure messages to come back
+			const bool any = waitForRx(std::chrono::milliseconds(100));
+			Log::Trace(__func__, any ? "A message came back" : "No communication came back");
+
+			lastData.clear();
+
+			// Now try again
+			return authenticate(false); // Either way, we don't need to continue authenticating
+		} else {
+			Log::Error(__func__, "The bootloader rejected the authentication challenge twice");
+			enterApplication();
+			return false;
+		}
+	}
+
+	// The reply is one byte followed by seed.b
+	if(lastData.back().data.size() < 1 + sizeof(seed.b)) {
+		Log::Error(__func__, "The authentication reply is too short");
+		enterApplication();
+		return false;
+	}
+	if(std::memcmp(&lastData.back().data[1], &seed.b, sizeof(seed.b)) != 0) {
+		Log::Error(__func__, "The authentication reply does not match, the device did not authenticate");
+		enterApplication();
+		return false;
+	}
+	lastData.clear();
+
+	return true;
+}
+
+bool REDCommunication::getVersion() {
+	if(!sendCommand(uint8_t(Command::GetVersion), std::chrono::seconds(1), false)) {
+		Log::Error(__func__, "The bootloader did not answer the version request");
+		enterApplication();
+		return false;
+	}
+
+	if(lastData.front().data.size() < VersionResponse::EncodedSize) {
+		Log::Error(__func__, "The bootloader version reply is too short");
+		enterApplication();
+		return false;
+	}
+
+	currentVersion = VersionResponse(lastData.front());
+	lastData.clear();
+
+	if(doAuthChecks) {
+		// Check that the serial number the bootloader reports is correct
+		uint8_t correctSerial[sizeof(VersionResponse::serial_num)] = {};
+		uint32_t devSerial = device.getSerialNumber();
+		std::memcpy(correctSerial, &devSerial, sizeof(devSerial));
+		if(std::memcmp(correctSerial, currentVersion.serial_num, sizeof(correctSerial))) {
+			Log::Error(__func__, "The serial number reported by the bootloader does not match the device");
+			enterApplication();
+			return false;
+		}
+	}
+
+	blockSize = currentVersion.block_size;
+	device.setBootloaderVersion({currentVersion.bl_major, currentVersion.bl_minor});
+	return true;
+}
+
+bool REDCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	const auto& srcVer = fw.getVersion();
+
+	std::vector<uint8_t> bin;
+	if(!fw.getFW(targetChip.getIEFName(), bin)) {
+		return false;
+	}
+
+	IEF ief;
+	if(!ief.load(std::move(bin))) {
+		return false;
+	}
+
+	// The supplied IEF is not for this product
+	if(ief.getVersion().prodId != static_cast<uint8_t>(device.getProductID())) {
+		Log::Error(__func__, "IEF product ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	// The supplied IEF is for this product, but not for this chip
+	if(ief.getVersion().chipId != static_cast<uint8_t>(targetChip.getID())) {
+		Log::Error(__func__, "IEF chip ID mismatch for " + targetChip.getName());
+		return false;
+	}
+
+	Log::Debug(__func__, "IEF version " + std::to_string(ief.getVersion().appMajor) + "." + std::to_string(ief.getVersion().appMinor)
+		+ ", " + std::to_string(ief.getSectors().size()) + " sectors");
+
+	if(doAuthChecks && device.supportsSwVersionValidate()) {
+		// Tell the bootloader what version of Vehicle Spy 3 this firmware is from.
+		// We check to make sure it approves, but also, some devices will not accept
+		// new firmware if we have not sent this.
+		// Sometimes new hardware revisions can not accept firmware which is too old.
+		if(!sendCommand(uint8_t(Command::ValidateSWVersion), {srcVer.major, srcVer.minor, srcVer.release, srcVer.build})) {
+			Log::Error(__func__, "SW version validation failed for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	handler(icsneo::Device::OpenStatusType::Progress,
+		"Preparing to update " + targetChip.getName() + "...", std::nullopt);
+	Log::Debug(__func__, "Erasing " + targetChip.getName());
+	if(!sendCommand(uint8_t(Command::Erase), std::chrono::seconds(45))) {
+		Log::Error(__func__, "Erase failed for " + targetChip.getName());
+		return false;
+	}
+
+	const auto& sectorPairs = ief.getSectors();
+	size_t sectorsFlashed = 0;
+	for(const auto& [id, sector] : sectorPairs) {
+		Log::Trace(__func__, "Flashing sector " + std::to_string(id));
+		handler(icsneo::Device::OpenStatusType::Progress,
+			"Updating " + targetChip.getName() + "...",
+			double(sectorsFlashed++) / sectorPairs.size());
+
+		if(sector.size() > blockSize) {
+			Log::Error(__func__, "Sector " + std::to_string(id) + " too large");
+			return false;
+		}
+
+		// Sectors smaller than the block size are padded out with zeros
+		std::vector<uint8_t> padded(sector.begin(), sector.end());
+		padded.resize(blockSize, 0);
+
+		std::vector<uint8_t> encrypted(padded.size());
+		if(encryptFirmwareWithDeviceKey)
+			icsbl_encrypt_v1(device.getSerialNumber(), padded.data(), padded.size(), encrypted.data());
+		else
+			encrypted = std::move(padded);
+
+		encrypted.insert(encrypted.begin(), {
+			0x00, 0x00, 0x00, // Padding bytes
+			// Address
+			uint8_t((id >> 0x00) & 0xFF),
+			uint8_t((id >> 0x08) & 0xFF),
+			uint8_t((id >> 0x10) & 0xFF),
+			uint8_t((id >> 0x18) & 0xFF),
+		});
+
+		// Unencrypted firmware is used for FIRE2 Zynq (and VNET) which also uses the top bit of the ID
+		// to denote whether the sector is flashed to chip A or chip B. That is indicated
+		// with a 1 (for chip B) or a 0 as the first byte of the flash packet payload.
+		if(!encryptFirmwareWithDeviceKey)
+			encrypted.insert(encrypted.begin(), uint8_t(id & (1u << 31) ? 1 : 0));
+
+		if(!sendCommand(uint8_t(Command::Flash), encrypted)) {
+			Log::Error(__func__, "Flash failed at sector " + std::to_string(id) + " for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	// Tell the application that we flashed 100%
+	handler(icsneo::Device::OpenStatusType::Progress,
+		"Updating " + targetChip.getName() + "...",
+		1.0);
+
+	handler(icsneo::Device::OpenStatusType::Progress, "Finalizing update...", std::nullopt);
+	if(!sendCommand(uint8_t(Command::ValidateFirmware))) {
+		Log::Error(__func__, "Firmware validation failed for " + targetChip.getName());
+		return false;
+	}
+	return true;
+}
+
+REDCommunication::VersionResponse::VersionResponse(const REDPacketizer::RxFrame& r) {
+	auto i = r.data.begin();
+	bl_major = *i++;
+	bl_minor = *i++;
+	app_major = *i++;
+	app_minor = *i++;
+	hardware_rev_major = *i++;
+	hardware_rev_minor = *i++;
+	flags = *i++;
+	block_size = *i++;
+	block_size |= uint16_t(*i++) << 8;
+	man_day = *i++;
+	man_month = *i++;
+	man_year = *i++;
+	man_year |= uint16_t(*i++) << 8;
+	for(size_t x = 0; x != sizeof(serial_num); ++x)
+		serial_num[x] = *i++;
+	prod_id = *i++;
+	last_error_code = *i++;
+	pad_byte = *i++;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,86 @@
+#include "icsneo/device/extensions/bootloader/communication/redbase.h"
+
+#include <limits>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+REDCommunicationBase::REDCommunicationBase(icsneo::Device& dev, const ChipInfo& chip)
+	: Communication(dev), targetChip(chip) {}
+
+bool REDCommunicationBase::open() {
+	device.com->pauseReads();
+	return true;
+}
+
+bool REDCommunicationBase::close() {
+	device.com->resumeReads();
+	return true;
+}
+
+bool REDCommunicationBase::handleData() {
+	auto& rb = device.com->driver->getReadBuffer();
+
+	if(rp.input(rb)) {
+		lastData = rp.output();
+		return true;
+	}
+
+	return false;
+}
+
+bool REDCommunicationBase::waitForRx(std::chrono::milliseconds timeout) {
+	return device.com->driver->waitForRx([this]() { return handleData(); }, timeout);
+}
+
+bool REDCommunicationBase::sendCommand(uint8_t cmd, std::vector<uint8_t> args, std::chrono::seconds timeout, bool clearLastResponse) {
+	lastData.clear();
+	device.com->driver->getReadBuffer().clear();
+
+	if(!sendCommandRaw(cmd, std::move(args)))
+		return false;
+
+	if(!waitForRx(std::chrono::duration_cast<std::chrono::milliseconds>(timeout)))
+		return false;
+
+	const bool ret = lastData.front().resp == REDPacketizer::Response::Accepted;
+
+	if(clearLastResponse) {
+		lastData.clear();
+	}
+	return ret;
+}
+
+bool REDCommunicationBase::sendCommandRaw(uint8_t cmd, std::vector<uint8_t> args) {
+	// For some reason, some devices need it padded to even total bytes, and some to odd total bytes
+	const bool padEven = device.getType() == DeviceType::FIRE2;
+
+	args.insert(args.begin(), uint8_t(cmd)); // Prepend the command byte to the arguments
+	if(args.size() > std::numeric_limits<uint16_t>::max())
+		return false;
+
+	uint16_t size = uint16_t(args.size());
+	// The header counts, and the header is 5 bytes, so we're checking for even inner size here
+	const bool padding = size % 2 != (padEven ? 0 : 1);
+	if(padding) // We will add padding, so make space for it
+		size++;
+
+	// Prepend the magic, 16-bit little-endian chip ID, and 16-bit little-endian size
+	const uint16_t chipID = uint16_t(targetChip.getID());
+	args.insert(args.begin(), {
+		REDPacketizer::Magic,
+		uint8_t(chipID & 0xFF), uint8_t(chipID >> 8),
+		uint8_t(size & 0xFF), uint8_t(size >> 8)
+	});
+
+	if(padding)
+		args.push_back(PaddingByte); // Ignored by the firmware
+
+	// Write it to the device
+	return device.com->sendPacket(args);
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,111 @@
+#include "icsneo/device/extensions/bootloader/communication/redcore.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <algorithm>
+#include <limits>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+bool REDCoreCommunication::flash(const FWRepo& fw, const icsneo::Device::OpenStatusHandler& handler) {
+	constexpr const size_t MaxSectorSize = 0x600;
+
+	std::vector<uint8_t> bin;
+	if(!fw.getFW(targetChip.getIEFName(), bin)) {
+		return false;
+	}
+
+	if(bin.size() > std::numeric_limits<uint32_t>::max()) {
+		Log::Error(__func__, "Firmware too large for " + targetChip.getName());
+		return false;
+	}
+
+	const std::string message = "Updating " + targetChip.getName() + "...";
+
+	// First send the firmware
+	const uint32_t fileSize = uint32_t(bin.size());
+	size_t sectorsFlashed = 0;
+	const size_t sectorCount = (fileSize / MaxSectorSize) + (fileSize % MaxSectorSize ? 1 : 0);
+	std::vector<uint8_t> sector;
+	for(size_t i = 0; i < fileSize; i += MaxSectorSize) {
+		Log::Trace(__func__, "Sending sector " + std::to_string(sectorsFlashed));
+		handler(icsneo::Device::OpenStatusType::Progress, message, double(sectorsFlashed++) / sectorCount);
+
+		sector.assign(bin.begin() + i, bin.begin() + i + std::min<size_t>(MaxSectorSize, fileSize - i));
+		if(!sendCommand(uint8_t(Command::SendFirmware), sector)) {
+			Log::Error(__func__, "Failed to send sector " + std::to_string(sectorsFlashed - 1) + " for " + targetChip.getName());
+			return false;
+		}
+	}
+
+	// Then flash it
+	Log::Debug(__func__, "Starting core flash for " + targetChip.getName());
+	handler(icsneo::Device::OpenStatusType::Progress, message, std::nullopt);
+
+	// There is a long timeout on the StartFirmwareFlash because the bootloader may block here,
+	// potentially for the entire duration of the flash
+	if(!sendCommand(uint8_t(Command::StartFirmwareFlash), {
+			uint8_t(fileSize & 0xFF), uint8_t((fileSize >> 8) & 0xFF),
+			uint8_t((fileSize >> 16) & 0xFF), uint8_t((fileSize >> 24) & 0xFF),
+		}, std::chrono::seconds(60))) {
+		Log::Error(__func__, "Failed to start core flash for " + targetChip.getName());
+		return false;
+	}
+
+	// Watch the responses to know when it's done
+	const auto endTime = std::chrono::steady_clock::now() + std::chrono::seconds(60);
+	uint32_t flashed = 0;
+	while(flashed < fileSize && std::chrono::steady_clock::now() < endTime) {
+		if(!sendCommandRaw(uint8_t(Command::GetFlashProgress))) {
+			Log::Error(__func__, "Failed to request flash progress for " + targetChip.getName());
+			return false;
+		}
+
+		if(!waitForRx(std::chrono::milliseconds(3000))) {
+			Log::Trace(__func__, "No flash progress packet within 3 seconds");
+			continue;
+		}
+
+		const uint32_t oldFlashed = flashed;
+		for(const auto& packet : lastData) {
+			if(packet.resp != REDPacketizer::Response::Accepted)
+				return false;
+			if(packet.data.size() != 4) {
+				Log::Trace(__func__, "Got a flash progress packet of length " + std::to_string(packet.data.size()));
+				continue;
+			}
+			const uint32_t newFlashed = readLE32(packet.data.data());
+			if(newFlashed >= flashed)
+				flashed = newFlashed;
+			else
+				Log::Trace(__func__, "Got a flash progress packet which went backwards " + std::to_string(newFlashed) + " " + std::to_string(flashed));
+
+			// After sending us the packet that confirms the flash, the flash position is cleared and will send us zeros.
+			// We don't need any of these other packets, in that case.
+			if(flashed >= fileSize)
+				break;
+		}
+		lastData.clear();
+
+		Log::Trace(__func__, "Flashed " + std::to_string(flashed) + " of " + std::to_string(fileSize));
+
+		if(flashed != oldFlashed)
+			handler(icsneo::Device::OpenStatusType::Progress, message, std::min(double(flashed) / fileSize, 1.0));
+	}
+
+	return flashed == fileSize;
+}
+
+bool REDCoreCommunication::sendCommandRaw(uint8_t cmd, std::vector<uint8_t> args) {
+	if(args.size() > std::numeric_limits<uint16_t>::max())
+		return false;
+	const uint16_t size = static_cast<uint16_t>(args.size());
+	args.insert(args.begin(), { CoreFlasherMagic, uint8_t(size & 0xFF), uint8_t((size >> 8) & 0xFF), cmd });
+	return REDCommunicationBase::sendCommandRaw(CoreFlasherCommand, std::move(args));
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,85 @@
+#include "icsneo/device/extensions/bootloader/communication/redpacketizer.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <algorithm>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+bool REDPacketizer::input(icsneo::RingBuffer& bytes) {
+	while(bytes.size() > 0) {
+		switch(state) {
+		case HEADER:
+			if(bytes[0] == Magic) {
+				working.emplace_back();
+				state = CMD;
+			} else {
+				Log::Trace(__func__, "Got bootloader unknown byte: " + std::to_string(bytes[0]));
+			}
+			bytes.pop_front();
+			break;
+		case CMD:
+			working.back().resp = Response(bytes[0]);
+			if(working.back().resp != Response::Accepted && working.back().resp != Response::Rejected) {
+				Log::Trace(__func__, "Got bootloader unknown response: " + std::to_string(bytes[0]));
+				working.pop_back();
+				state = HEADER;
+			} else {
+				state = LENGTH_LOWER;
+			}
+			bytes.pop_front();
+			break;
+		case LENGTH_LOWER:
+			working.back().len = bytes[0];
+			state = LENGTH_UPPER;
+			bytes.pop_front();
+			break;
+		case LENGTH_UPPER:
+			working.back().len |= uint16_t(bytes[0]) << 8;
+			if(working.back().len == 0) {
+				working.back().done = true;
+				state = HEADER;
+			} else {
+				state = DATA;
+			}
+			bytes.pop_front();
+			break;
+		case DATA: {
+			// The RingBuffer is not contiguous, so copy out with read() rather than taking a pointer
+			auto& frame = working.back();
+			const size_t dataToGo = frame.len - frame.data.size();
+			const size_t toCopy = std::min(bytes.size(), dataToGo);
+			const size_t oldSize = frame.data.size();
+			frame.data.resize(oldSize + toCopy);
+			bytes.read(frame.data.data() + oldSize, 0, toCopy);
+			bytes.pop(toCopy);
+			if(toCopy == dataToGo) {
+				frame.done = true;
+				state = HEADER;
+			}
+			break;
+		}
+		}
+	}
+
+	return std::any_of(working.begin(), working.end(), [](const RxFrame& rx) { return rx.done; });
+}
+
+std::vector<REDPacketizer::RxFrame> REDPacketizer::output() {
+	// Hand back the completed frames, anything still in progress stays in working
+	std::vector<RxFrame> done;
+	std::vector<RxFrame> pending;
+	for(auto& rx : working) {
+		if(rx.done)
+			done.push_back(std::move(rx));
+		else
+			pending.push_back(std::move(rx));
+	}
+	working = std::move(pending);
+	return done;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,249 @@
+#include "icsneo/device/extensions/bootloader/parser/fwbin.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+
+#include <unordered_map>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * fw.bin file format (all integers little-endian):
+ *
+ *   uint8_t  versionLength
+ *   char     version[versionLength]  Vehicle Spy 3 version, "major.minor.release.build"
+ *   uint8_t  hashLength
+ *   char     hash[hashLength]        Build hash, unused
+ *   Then tags until the end of the file:
+ *     uint32_t nameHash              HashDjb2() of the tag name, e.g. "fire2_core"
+ *     uint8_t  type                  TagData::Type
+ *     uint32_t length
+ *     uint8_t  data[length]
+ *
+ * Exactly one Signature tag is required, it uses the reserved name hash 0.
+ */
+
+uint32_t FWBin::HashDjb2(const std::string& tag) {
+	uint32_t retv = 5381;
+	for(char c : tag)
+		retv = ((retv << 5) + retv) + c;
+	return retv;
+}
+
+bool FWBin::load(const std::string& path) {
+	file.open(path, std::ios::binary);
+	if(!file.is_open() || file.fail() || file.eof()) {
+		Log::Error(__func__, "Could not open file at " + path);
+		return false;
+	}
+	// Read out the version string, it is a single byte length followed by a string
+	uint8_t size;
+	file.read((char*)&size, 1);
+	if(file.fail() || file.eof()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read the version length");
+		return false;
+	}
+	std::string unparsedVersion;
+	unparsedVersion.resize(size);
+	file.read(unparsedVersion.data(), size);
+	if(file.fail() || file.eof()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read the version string");
+		return false;
+	}
+
+	if(!version.load(unparsedVersion)) {
+		Log::Error(__func__, "The fw.bin version string is invalid: " + unparsedVersion);
+		return false;
+	}
+
+	// Read out the hash string, it is a single byte length followed by a string
+	file.read((char*)&size, 1);
+	if(file.fail() || file.eof()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read the hash length");
+		return false;
+	}
+
+	// The hash string is not used, skip over it
+	file.seekg(size, file.cur);
+	if(file.fail() || file.eof()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read the hash string");
+		return false;
+	}
+
+	while(true) {
+		uint32_t tagHash;
+		file.read((char*)&tagHash, sizeof(uint32_t));
+		if(file.eof()) {
+			break;
+		}
+		if(file.fail()) {
+			Log::Error(__func__, "The fw.bin is truncated, could not read a tag name hash");
+			return false;
+		}
+
+		if(tags.count(tagHash)) {
+			// Duplicate tag
+			Log::Error(__func__, "The fw.bin contains a duplicate tag");
+			return false;
+		}
+		TagData& current = tags[tagHash];
+
+		// Read the type field
+		file.read((char*)&current.type, sizeof(TagData::Type));
+		if(file.fail() || file.eof()) {
+			Log::Error(__func__, "The fw.bin is truncated, could not read a tag type");
+			return false;
+		}
+
+		switch(current.type) {
+			case TagData::Type::DataBytes:
+			case TagData::Type::DataLength:
+			case TagData::Type::IEFVersion:
+				if(tagHash == SignatureHash) {
+					Log::Error(__func__, "The fw.bin contains a data tag using the reserved signature name hash");
+					return false;
+				}
+				break;
+			case TagData::Type::Signature:
+				if(tagHash != SignatureHash) {
+					Log::Error(__func__, "The fw.bin contains a signature tag with a non-signature name hash");
+					return false;
+				}
+				break;
+			default: // Unknown type
+				Log::Error(__func__, "The fw.bin contains a tag of unknown type " + std::to_string(static_cast<int>(current.type)));
+				return false;
+		}
+
+		// Read the length field
+		file.read((char*)&current.arrayLength, sizeof(uint32_t));
+		if(file.fail() || file.eof()) {
+			Log::Error(__func__, "The fw.bin is truncated, could not read a tag length");
+			return false;
+		}
+
+		// Note the current position so we can jump back to it and read it later
+		current.arrayPosition = file.tellg();
+		file.seekg(current.arrayLength, file.cur);
+		if(file.fail()) {
+			Log::Error(__func__, "The fw.bin is truncated, a tag extends past the end of the file");
+			return false;
+		}
+	}
+	file.clear();
+
+	// The signature tag is required to be present, but it is not verified
+	if(tags.count(SignatureHash) == 0) {
+		Log::Error(__func__, "The fw.bin is missing its signature tag");
+		return false;
+	}
+	return true;
+}
+
+bool FWBin::readTag(const std::string& tag, std::vector<uint8_t>& out) const {
+	const auto hash = HashDjb2(tag);
+	if(hash == SignatureHash) {
+		Log::Error(__func__, "The signature tag can not be read as data");
+		return false;
+	}
+	const auto it = tags.find(hash);
+	if(it == tags.end()) {
+		Log::Error(__func__, "The fw.bin does not contain the tag " + tag);
+		return false;
+	}
+	return it->second.read(file, out);
+}
+
+bool FWBin::TagData::read(std::ifstream& stream, std::vector<uint8_t>& out) const {
+	stream.clear();
+	stream.seekg(arrayPosition, stream.beg);
+	out.resize(arrayLength);
+	stream.read((char*)out.data(), arrayLength);
+	if(stream.fail()) {
+		Log::Error(__func__, "The fw.bin is truncated, could not read tag data");
+		return false;
+	}
+	return true;
+}
+
+bool FWBin::getFW(const std::string& iefName, std::vector<uint8_t>& fw) const {
+	return readTag(iefName, fw);
+}
+
+FWBin::VersionTags FWBin::GetVersionTags(const std::string& iefName) {
+	static const std::unordered_map<std::string, VersionTags> VersionTable = {
+		{"fire2_core", {"fire2_core_version_major", "fire2_core_version_minor"}},
+		{"fire2_core_sg4", {"fire2_core_sg4_version_major", "fire2_core_sg4_version_minor"}},
+		{"RADA2B_SW_bin", {"RADA2B_SW_Version_Major", "RADA2B_SW_Version_Minor"}},
+		{"RADA2B_REVB_SW_bin", {"RADA2B_SW_Version_Major", "RADA2B_SW_Version_Minor"}},
+		{"RADComet_SW_bin", {"RADComet_SW_Version_Major", "RADComet_SW_Version_Minor"}},
+		{"RADComet3_SW_bin", {"RADComet3_SW_Version_Major", "RADComet3_SW_Version_Minor"}},
+		{"RADGalaxy_SG2_SW_bin", {"RADGalaxy_SG2_SW_Version_Major", "RADGalaxy_SG2_SW_Version_Minor"}},
+		{"RADGalaxy_SG2_FFG_SW_bin", {"RADGalaxy_SG2_FFG_SW_Version_Major", "RADGalaxy_SG2_SW_Version_Minor"}},
+		{"RADGalaxy2_SW_bin_p1", {"RADGalaxy2_SW_Version_Major", "RADGalaxy2_SW_Version_Minor"}},
+		{"RADGalaxy2_SW_bin_p2", {"RADGalaxy2_SW_Version_Major", "RADGalaxy2_SW_Version_Minor"}},
+		{"RADGigastar_SW_bin", {"RADGigastar_SW_Version_Major", "RADGigastar_SW_Version_Minor"}},
+		{"RADGigastar_FFG_SW_bin", {"RADGigastar_SW_Version_Major", "RADGigastar_SW_Version_Minor"}},
+		{"RADGigastar_USBz_SW_bin", {"RADGigastar_USBz_SW_Version_Major", "RADGigastar_USBz_SW_Version_Minor"}},
+		{"RADGigastar_USBz_Z7010_SW_bin", {"RADGigastar_USBz_SW_Version_Major", "RADGigastar_USBz_SW_Version_Minor"}},
+		{"RADGigastar_USBz_Z7007s_SW_bin", {"RADGigastar_USBz_SW_Version_Major", "RADGigastar_USBz_SW_Version_Minor"}},
+		{"RADGigastar2_T1S_LIN_SW_bin", {"RADGigastar2_T1S_LIN_SW_Version_Major", "RADGigastar2_T1S_LIN_SW_Version_Minor"}},
+		{"RADGigastar2_T1S_CAN_SW_bin", {"RADGigastar2_T1S_CAN_SW_Version_Major", "RADGigastar2_T1S_CAN_SW_Version_Minor"}},
+		{"RADMoon2_SW_bin", {"RADMoon2_SW_Version_Major", "RADMoon2_SW_Version_Minor"}},
+		{"RADMoon2_Z7010_SW_bin", {"RADMoon2_SW_Version_Major", "RADMoon2_SW_Version_Minor"}},
+		{"RADMoonT1S_SW_bin", {"RADMoonT1S_SW_Version_Major", "RADMoonT1S_SW_Version_Minor"}},
+		{"vcan44_core_ief", {"vcan44_core_version_major", "vcan44_core_version_minor"}}
+	};
+	auto iter = VersionTable.find(iefName);
+	return iter != VersionTable.end() ? iter->second : VersionTags();
+}
+
+std::optional<icsneo::DeviceAppVersion> FWBin::getChipVersion(const std::string& iefName) const {
+	auto versionTags = GetVersionTags(iefName);
+
+	if(versionTags) {
+		std::vector<uint8_t> majData;
+		std::vector<uint8_t> minData;
+
+		if(!readTag(versionTags.majorTag, majData)) {
+			return std::nullopt;
+		}
+
+		if(!readTag(versionTags.minorTag, minData)) {
+			return std::nullopt;
+		}
+
+		if(majData.size() != 1)
+			return std::nullopt;
+
+		if(minData.size() != 1)
+			return std::nullopt;
+
+		icsneo::DeviceAppVersion chipVersion;
+		chipVersion.major = majData[0];
+		chipVersion.minor = minData[0];
+		return chipVersion;
+	}
+
+	std::vector<uint8_t> buf;
+
+	if(!readTag(iefName, buf)) {
+		return std::nullopt;
+	}
+
+	IEF ief;
+
+	if(!ief.load(std::move(buf))) {
+		return std::nullopt;
+	}
+
+	icsneo::DeviceAppVersion chipVersion;
+	chipVersion.major = ief.getVersion().appMajor;
+	chipVersion.minor = ief.getVersion().appMinor;
+	return chipVersion;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,142 @@
+#include "icsneo/device/extensions/bootloader/parser/fwbundle.h"
+#include "icsneo/device/extensions/bootloader/parser/fwbin.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+#include "icsneo/core/crc32.h"
+#include <cstddef>
+#include <cstring>
+#include <fstream>
+#include <iterator>
+#include <limits>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * Firmware bundle file format (all integers little-endian):
+ *
+ *   FWBundleHeader
+ *   Then chips until the end of the file:
+ *     FWBundleChip
+ *     uint8_t data[FWBundleChip::length]
+ *
+ * The CRC32 covers the whole file with the crc field set to zero.
+ */
+#pragma pack(push, 1)
+struct FWBundleHeader {
+	char magic[2]; // "FW"
+	uint16_t fmtVersion;
+	uint32_t crc;
+	uint8_t build;
+	uint8_t maintenance;
+	uint8_t minor;
+	uint8_t major;
+	uint8_t type; // Build type, unused
+};
+
+struct FWBundleChip {
+	uint32_t hash; // FWBin::HashDjb2() of the chip's IEF name
+	uint8_t build;
+	uint8_t maintenance;
+	uint8_t minor;
+	uint8_t major;
+	uint32_t length;
+};
+#pragma pack(pop)
+
+bool FWBundle::IsFWBundle(const std::string& path) {
+	std::ifstream file(path, std::ios::binary);
+	if(!file.is_open())
+		return false;
+	// Only check the magic, so a truncated bundle is still reported as a bundle error by load()
+	char magic[sizeof(FWBundleHeader::magic)];
+	file.read(magic, sizeof(magic));
+	if(file.fail())
+		return false;
+	return magic[0] == 'F' && magic[1] == 'W';
+}
+
+bool FWBundle::load(const std::string& path) {
+	std::ifstream file(path, std::ios::binary);
+	if(!file.is_open()) {
+		Log::Error(__func__, "Could not open file at " + path);
+		return false;
+	}
+	std::vector<uint8_t> bytes((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+	if(file.bad()) {
+		Log::Error(__func__, "Could not read file at " + path);
+		return false;
+	}
+
+	if(bytes.size() < sizeof(FWBundleHeader) || bytes.size() > std::numeric_limits<uint32_t>::max()) {
+		Log::Error(__func__, "The firmware bundle is smaller than its header or larger than 4 GiB");
+		return false;
+	}
+
+	FWBundleHeader header;
+	std::memcpy(&header, bytes.data(), sizeof(header));
+	if(header.magic[0] != 'F' || header.magic[1] != 'W') {
+		Log::Error(__func__, "The file is not a firmware bundle, bad magic");
+		return false;
+	}
+
+	// The CRC is computed with the CRC field zeroed
+	std::memset(bytes.data() + offsetof(FWBundleHeader, crc), 0, sizeof(header.crc));
+	if(icsneo::crc32(0, bytes.data(), static_cast<uint32_t>(bytes.size())) != header.crc) {
+		Log::Error(__func__, "The firmware bundle failed CRC validation");
+		return false;
+	}
+
+	std::unordered_map<uint32_t, ChipBinary> parsed;
+	size_t offset = sizeof(FWBundleHeader);
+	while(offset < bytes.size()) {
+		if(bytes.size() - offset < sizeof(FWBundleChip)) {
+			Log::Error(__func__, "The firmware bundle is truncated, could not read a chip header");
+			return false;
+		}
+		FWBundleChip chip;
+		std::memcpy(&chip, bytes.data() + offset, sizeof(chip));
+		offset += sizeof(FWBundleChip);
+
+		if(bytes.size() - offset < chip.length) {
+			Log::Error(__func__, "The firmware bundle is truncated, a chip binary extends past the end of the file");
+			return false;
+		}
+
+		auto& bin = parsed[chip.hash];
+		bin.data.assign(bytes.begin() + offset, bytes.begin() + offset + chip.length);
+		bin.version.major = chip.major;
+		bin.version.minor = chip.minor;
+		bin.version.release = chip.maintenance;
+		bin.version.build = chip.build;
+		offset += chip.length;
+	}
+
+	version.major = header.major;
+	version.minor = header.minor;
+	version.release = header.maintenance;
+	version.build = header.build;
+	binaries = std::move(parsed);
+	return true;
+}
+
+bool FWBundle::getFW(const std::string& iefName, std::vector<uint8_t>& fw) const {
+	const auto it = binaries.find(FWBin::HashDjb2(iefName));
+	if(it == binaries.end()) {
+		Log::Error(__func__, "The chip binary could not be found");
+		return false;
+	}
+	fw = it->second.data;
+	return true;
+}
+
+std::optional<icsneo::DeviceAppVersion> FWBundle::getChipVersion(const std::string& iefName) const {
+	const auto it = binaries.find(FWBin::HashDjb2(iefName));
+	if(it == binaries.end())
+		return std::nullopt;
+	return icsneo::DeviceAppVersion(it->second.version.major, it->second.version.minor);
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,25 @@
+#include "icsneo/device/extensions/bootloader/parser/fwloader.h"
+#include "icsneo/device/extensions/bootloader/parser/fwbin.h"
+#include "icsneo/device/extensions/bootloader/parser/fwbundle.h"
+
+namespace icsneo {
+
+namespace Bootloader {
+
+std::unique_ptr<FWRepo> FWLoader::Load(const std::string& path) {
+	if(FWBundle::IsFWBundle(path)) {
+		auto bundle = std::make_unique<FWBundle>();
+		if(!bundle->load(path))
+			return nullptr;
+		return bundle;
+	}
+
+	auto bin = std::make_unique<FWBin>();
+	if(!bin->load(path))
+		return nullptr;
+	return bin;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,73 @@
+#include "icsneo/device/extensions/bootloader/parser/fwzip.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <miniz.h>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class ZipHandle {
+public:
+	ZipHandle() {
+		mz_zip_zero_struct(&handle);
+	}
+	~ZipHandle() {
+		mz_zip_reader_end(&handle);
+	}
+
+	operator mz_zip_archive*() {
+		return &handle;
+	}
+
+private:
+	mz_zip_archive handle;
+};
+
+// A zip firmware image holds a single entry, the raw binary to send to the device
+FWZip::FWZip(std::vector<uint8_t>&& tagData)
+	: handle(std::make_unique<ZipHandle>()), zipData(std::move(tagData)) {
+
+	if(!mz_zip_reader_init_mem(*handle, zipData.data(), zipData.size(), 0)) {
+		Log::Error(__func__, "The firmware zip could not be opened");
+		return;
+	}
+
+	mz_zip_archive_file_stat file;
+	if(!mz_zip_reader_file_stat(*handle, 0, &file)) {
+		Log::Error(__func__, "The firmware zip is empty or its first entry could not be read");
+	} else {
+		uncompressedSize = static_cast<size_t>(file.m_uncomp_size);
+	}
+}
+
+FWZip::~FWZip() = default;
+
+bool FWZip::readAll(uint8_t* out) {
+	if(!uncompressedSize) {
+		return false;
+	}
+
+	if(!out) {
+		Log::Error(__func__, "No output buffer for the firmware zip");
+		return false;
+	}
+
+	if(!mz_zip_reader_extract_to_mem(*handle, 0, out, *uncompressedSize, 0)) {
+		Log::Error(__func__, "The firmware zip could not be decompressed");
+		return false;
+	}
+	return true;
+}
+
+bool FWZip::readAll(std::vector<uint8_t>& out) {
+	if(!uncompressedSize) {
+		return false;
+	}
+	out = std::vector<uint8_t>(*uncompressedSize, 0);
+	return readAll(out.data());
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,74 @@
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <cstring>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * IEF file format (all integers little-endian):
+ *
+ *   uint8_t  magic                0xAA
+ *   Version  version
+ *   uint8_t  configLength
+ *   uint8_t  config[configLength] Unused
+ *   Then sectors until the end of the file:
+ *     uint8_t  magic              0xAA
+ *     uint32_t index              Sector index, see the communication for how this maps to an address
+ *     uint32_t length
+ *     uint8_t  data[length]
+ */
+bool IEF::load(std::vector<uint8_t>&& bytes) {
+	static constexpr uint8_t Magic = 0xAA;
+	// Magic, version, config byte count
+	static constexpr size_t FixedHeaderSize = 1 + sizeof(Version) + 1;
+	// Magic, index, size
+	static constexpr size_t SectorHeaderSize = 1 + sizeof(uint32_t) + sizeof(uint32_t);
+
+	data = std::move(bytes);
+	sectors.clear();
+	if(data.size() < FixedHeaderSize) {
+		Log::Error(__func__, "IEF too short");
+		return false;
+	}
+
+	if(data.front() != Magic) {
+		Log::Error(__func__, "Invalid IEF magic");
+		return false;
+	}
+
+	std::memcpy(&version, data.data() + 1, sizeof(Version));
+
+	const size_t headerSize = FixedHeaderSize + data[FixedHeaderSize - 1];
+	if(data.size() <= headerSize) {
+		Log::Error(__func__, "Invalid IEF config bytes");
+		return false;
+	}
+
+	size_t offset = headerSize;
+	while(data.size() - offset >= SectorHeaderSize) {
+		if(data[offset] != Magic) {
+			Log::Error(__func__, "Invalid IEF sector magic");
+			return false;
+		}
+		uint32_t index;
+		uint32_t size;
+		std::memcpy(&index, data.data() + offset + 1, sizeof(index));
+		std::memcpy(&size, data.data() + offset + 1 + sizeof(index), sizeof(size));
+		offset += SectorHeaderSize;
+		if(data.size() - offset < size) {
+			Log::Error(__func__, "Invalid IEF sector");
+			return false;
+		}
+
+		sectors.emplace_back(index, BytesView(data.data() + offset, size));
+		offset += size;
+	}
+	return true;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,57 @@
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <cstdlib>
+#include <iostream>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+namespace Log {
+
+// Set ICS_BOOTLOADER_LOG_LEVEL to 1 (error) through 5 (trace) to enable logging to stderr
+static int GetLogLevel() {
+	static const int level = [] {
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4996) // getenv
+#endif
+		const char* env = std::getenv("ICS_BOOTLOADER_LOG_LEVEL");
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+		return env ? std::atoi(env) : 0;
+	}();
+	return level;
+}
+
+static void Write(int level, const char* prefix, const std::string& subject, const std::string& msg) {
+	if(GetLogLevel() >= level)
+		std::cerr << prefix << subject << " - " << msg << std::endl;
+}
+
+void Trace(const std::string& subject, const std::string& msg) {
+	Write(5, "[TRACE] ", subject, msg);
+}
+
+void Debug(const std::string& subject, const std::string& msg) {
+	Write(4, "[DEBUG] ", subject, msg);
+}
+
+void Info(const std::string& subject, const std::string& msg) {
+	Write(3, "[INFO] ", subject, msg);
+}
+
+void Warning(const std::string& subject, const std::string& msg) {
+	Write(2, "[WARN] ", subject, msg);
+}
+
+void Error(const std::string& subject, const std::string& msg) {
+	Write(1, "[ERROR] ", subject, msg);
+}
+
+} // namespace Log
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -0,0 +1,50 @@
+#include "icsneo/device/extensions/bootloader/version.h"
+#include "icsneo/device/extensions/bootloader/platform/logging.h"
+
+#include <limits>
+#include <optional>
+#include <regex>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+bool FirmwareSourceVersion::load(const std::string& toParse) {
+	static const std::regex VersionRegex{"(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)"};
+	std::smatch match;
+	if(!std::regex_match(toParse, match, VersionRegex)) {
+		Log::Error(__func__, "Failed to parse version");
+		return false;
+	}
+
+	const auto parse = [](const std::string& input) -> std::optional<ValueType> {
+		// The regex guarantees only digits, limit the length so stoul can not overflow
+		if(input.size() > 3) {
+			return std::nullopt;
+		}
+		const auto value = std::stoul(input);
+		if(value > std::numeric_limits<ValueType>::max()) {
+			return std::nullopt;
+		}
+		return static_cast<ValueType>(value);
+	};
+
+	const auto parsedMajor = parse(match[1]);
+	const auto parsedMinor = parse(match[2]);
+	const auto parsedRelease = parse(match[3]);
+	const auto parsedBuild = parse(match[4]);
+	if(!parsedMajor || !parsedMinor || !parsedRelease || !parsedBuild) {
+		Log::Error(__func__, "Invalid sized version number");
+		return false;
+	}
+
+	major = *parsedMajor;
+	minor = *parsedMinor;
+	release = *parsedRelease;
+	build = *parsedBuild;
+	return true;
+}
+
+} // namespace Bootloader
+
+} // namespace icsneo
@@ -1113,3 +1113,177 @@ bool IDeviceSettings::setLinuxConfigurationPort(LinuxConfigurationPort port) {
 	(*os)->ethConfigurationPort = static_cast<uint8_t>(port);
 	return true;
 }
+
+namespace {
+
+void reportT1SUnavailable(const icsneo::device_eventhandler_t& report) {
+	report(APIEvent::Type::SettingNotAvaiableDevice, APIEvent::Severity::EventWarning);
+}
+
+std::optional<bool> t1sFlag(const ETHERNET10T1S_SETTINGS* t1s, uint8_t flag, const icsneo::device_eventhandler_t& report) {
+	if(t1s == nullptr) {
+		reportT1SUnavailable(report);
+		return std::nullopt;
+	}
+	return (t1s->flags & flag) != 0;
+}
+
+bool setT1SFlag(ETHERNET10T1S_SETTINGS* t1s, uint8_t flag, bool enable, const icsneo::device_eventhandler_t& report) {
+	if(t1s == nullptr) {
+		reportT1SUnavailable(report);
+		return false;
+	}
+	if(enable)
+		t1s->flags |= flag;
+	else
+		t1s->flags = static_cast<uint8_t>(t1s->flags & ~flag);
+	return true;
+}
+
+std::optional<uint8_t> t1sByte(const uint8_t* field, const icsneo::device_eventhandler_t& report) {
+	if(field == nullptr) {
+		reportT1SUnavailable(report);
+		return std::nullopt;
+	}
+	return *field;
+}
+
+bool setT1SByte(uint8_t* field, uint8_t value, const icsneo::device_eventhandler_t& report) {
+	if(field == nullptr) {
+		reportT1SUnavailable(report);
+		return false;
+	}
+	*field = value;
+	return true;
+}
+
+} // namespace
+
+std::optional<bool> IDeviceSettings::isT1SPLCAEnabledFor(Network net) const {
+	return t1sFlag(getT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA, report);
+}
+
+bool IDeviceSettings::setT1SPLCAFor(Network net, bool enable) {
+	return setT1SFlag(getMutableT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_ENABLE_PLCA, enable, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SLocalIDFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->local_id, report);
+}
+
+bool IDeviceSettings::setT1SLocalIDFor(Network net, uint8_t id) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->local_id, id, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SMaxNodesFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->max_num_nodes, report);
+}
+
+bool IDeviceSettings::setT1SMaxNodesFor(Network net, uint8_t nodes) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->max_num_nodes, nodes, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1STxOppTimerFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->to_timer, report);
+}
+
+bool IDeviceSettings::setT1STxOppTimerFor(Network net, uint8_t timer) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->to_timer, timer, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SMaxBurstFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->max_burst_count, report);
+}
+
+bool IDeviceSettings::setT1SMaxBurstFor(Network net, uint8_t burst) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->max_burst_count, burst, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SBurstTimerFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->burst_timer, report);
+}
+
+bool IDeviceSettings::setT1SBurstTimerFor(Network net, uint8_t timer) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->burst_timer, timer, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SLocalIDAlternateFor(Network net) const {
+	const auto* t1s = getT1SSettingsFor(net);
+	return t1sByte(t1s == nullptr ? nullptr : &t1s->local_id_alternate, report);
+}
+
+bool IDeviceSettings::setT1SLocalIDAlternateFor(Network net, uint8_t id) {
+	auto* t1s = getMutableT1SSettingsFor(net);
+	return setT1SByte(t1s == nullptr ? nullptr : &t1s->local_id_alternate, id, report);
+}
+
+std::optional<bool> IDeviceSettings::isT1STerminationEnabledFor(Network net) const {
+	return t1sFlag(getT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_TERMINATION, report);
+}
+
+bool IDeviceSettings::setT1STerminationFor(Network net, bool enable) {
+	return setT1SFlag(getMutableT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_TERMINATION, enable, report);
+}
+
+std::optional<bool> IDeviceSettings::isT1SBusDecodingBeaconsEnabledFor(Network net) const {
+	return t1sFlag(getT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS, report);
+}
+
+bool IDeviceSettings::setT1SBusDecodingBeaconsFor(Network net, bool enable) {
+	return setT1SFlag(getMutableT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_BEACONS, enable, report);
+}
+
+std::optional<bool> IDeviceSettings::isT1SBusDecodingAllEnabledFor(Network net) const {
+	return t1sFlag(getT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL, report);
+}
+
+bool IDeviceSettings::setT1SBusDecodingAllFor(Network net, bool enable) {
+	return setT1SFlag(getMutableT1SSettingsFor(net), ETHERNET10T1S_SETTINGS_FLAG_BUS_DECODING_ALL, enable, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SMultiIDEnableMaskFor(Network net) const {
+	const auto* ext = getT1SSettingsExtFor(net);
+	return t1sByte(ext == nullptr ? nullptr : &ext->enable_multi_id, report);
+}
+
+bool IDeviceSettings::setT1SMultiIDEnableMaskFor(Network net, uint8_t mask) {
+	auto* ext = getMutableT1SSettingsExtFor(net);
+	return setT1SByte(ext == nullptr ? nullptr : &ext->enable_multi_id, mask, report);
+}
+
+std::optional<uint8_t> IDeviceSettings::getT1SMultiIDFor(Network net, uint8_t index) const {
+	const auto* ext = getT1SSettingsExtFor(net);
+	if(ext == nullptr) {
+		reportT1SUnavailable(report);
+		return std::nullopt;
+	}
+	if(index >= sizeof(ext->multi_id)) {
+		report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+		return std::nullopt;
+	}
+	return ext->multi_id[index];
+}
+
+bool IDeviceSettings::setT1SMultiIDFor(Network net, uint8_t index, uint8_t id) {
+	auto* ext = getMutableT1SSettingsExtFor(net);
+	if(ext == nullptr) {
+		reportT1SUnavailable(report);
+		return false;
+	}
+	if(index >= sizeof(ext->multi_id)) {
+		report(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error);
+		return false;
+	}
+	ext->multi_id[index] = id;
+	return true;
+}
@@ -8,7 +8,6 @@ Dependencies
 The minimum requirements to build libicsneo are:
 - CMake version 3.12 or newer
 - A C++17 compiler
- libpcap on Linux and macOS


 Building library & examples
@@ -30,10 +29,3 @@ libicsneo supports being added as a sub-projects with CMake's
 #. Clone libicsneo into the desired location within the project
 #. Add ``add_subdirectory(path/to/libicsneo)`` to ``CMakeLists.txt``
 #. Link the project to libicsneo with ``target_link_libraries(app icsneocpp)``
-
-Linux udev Rules
-================
-
-Linux users may want to install the included udev rules to run libicsneo based
-applications without root, this can be done with:
-``cp 99-intrepidcs.rules /etc/udev/rules.d/``
@@ -107,3 +107,25 @@ Analog Output Control

 .. literalinclude:: ../../examples/python/analog_out/analog_out_basic.py
   :language: python
+
+ISO-TP CAN1 Loopback
+====================
+
+Two devices, CAN1 wired together. ``--raw`` checks the cable, ``--sf`` sends one
+firmware single frame, ``--both`` sends a segmented payload with firmware flow control.
+
+:download:`Download example <../../examples/python/iso15765/iso15765_loopback.py>`
+
+.. literalinclude:: ../../examples/python/iso15765/iso15765_loopback.py
+   :language: python
+
+Firmware Update
+===============
+
+Updates the first device found from a ``fw.bin`` or firmware bundle, see
+:doc:`firmware_update`.
+
+:download:`Download example <../../examples/python/bootloader/update.py>`
+
+.. literalinclude:: ../../examples/python/bootloader/update.py
+   :language: python
@@ -25,14 +25,3 @@ To upgrade an existing installation:
 .. code-block:: bash

   pip install --pre --upgrade icsneopy
-
-Linux udev Rules
-================
-
-Linux users may want to install the included udev rules to run icsneopy-based
-applications without root. The rules file can be found in the libicsneo source
-repository at https://github.com/intrepidcs/libicsneo/.
-
-.. code-block:: bash
-
-   sudo cp 99-intrepidcs.rules /etc/udev/rules.d/
@@ -15,17 +15,3 @@ communication library. The source code for libicsneo can be found on GitHub:
   icsneoc/index
   icsneoc2/index

-Linux Installation
-==================
-
-Applications that use raw Ethernet device discovery, such as PCAP-backed
-discovery, need permission to open raw network sockets. Instead of running your
-application with ``sudo``, grant the installed executable the required Linux
-capabilities:
-
-.. code-block:: bash
-
-   sudo setcap cap_net_raw,cap_net_admin=eip /usr/bin/your-app
-
-Replace ``/usr/bin/your-app`` with the full path to the application executable.
-
@@ -36,6 +36,7 @@ option(LIBICSNEO_BUILD_CPP_ANALOG_OUT_EXAMPLE "Build the analog output example."
 option(LIBICSNEO_BUILD_CPP_DISKFORMAT_EXAMPLE "Build the disk format example." ON)
 option(LIBICSNEO_BUILD_CPP_T1S_EXAMPLE "Build the T1S example." ON)
 option(LIBICSNEO_BUILD_CPP_GPTP_EXAMPLE "Build the C++ gPTP settings example." ON)
+option(LIBICSNEO_BUILD_CPP_ISO15765_LOOPBACK_EXAMPLE "Build the C++ ISO15765 two-device CAN1 loopback example." ON)

 add_compile_options(${LIBICSNEO_COMPILER_WARNINGS})

@@ -190,3 +191,7 @@ endif()
 if(LIBICSNEO_BUILD_CPP_GPTP_EXAMPLE)
 	add_subdirectory(cpp/gptp)
 endif()
+
+if(LIBICSNEO_BUILD_CPP_ISO15765_LOOPBACK_EXAMPLE)
+	add_subdirectory(cpp/iso15765_loopback)
+endif()
@@ -52,7 +52,7 @@ Although the example program will build without successfully completing the step

 First, we are going to build the icsneoc library into a .so file that we can later use in order to access the library functions.

-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to `libicsneo-examples/third-party/libicsneo` and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
@@ -72,8 +72,7 @@ Although the example program will build without successfully completing the step
    * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make` to build the library.
    * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Run `sudo ./libicsneoc-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Run `./libicsneoc-example` to run the example.

 ## macOS

@@ -52,7 +52,7 @@ Although the example program will build without successfully completing the step

 First, we are going to build the icsneoc library into a .so file that we can later use in order to access the library functions.

-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to `libicsneo-examples/third-party/libicsneo` and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
@@ -72,8 +72,7 @@ Although the example program will build without successfully completing the step
    * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make` to build the library.
    * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Run `sudo ./libicsneoc-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Run `./libicsneoc-example` to run the example.

 ## macOS

@@ -52,7 +52,7 @@ Although the example program will build without successfully completing the step

 First, we are going to build the icsneoc library into a .so file that we can later use in order to access the library functions.

-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to `libicsneo-examples/third-party/libicsneo` and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
@@ -72,8 +72,7 @@ Although the example program will build without successfully completing the step
    * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make` to build the library.
    * Hint! Speed up your build by using multiple processors! Use `make -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Run `sudo ./libicsneoc-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Run `./libicsneoc-example` to run the example.

 ## macOS

@@ -378,7 +378,7 @@ static int configure_t1s_port(icsneoc2_device_t* device, icsneoc2_netid_t netid,
 	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S TX opportunity timer", res);
 	res = icsneoc2_settings_t1s_burst_timer_set(device, netid, T1S_BURST_TIMER);
 	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S burst timer", res);
-	res = icsneoc2_settings_t1s_max_burst_timer_for_set(device, netid, T1S_MAX_BURST);
+	res = icsneoc2_settings_t1s_max_burst_set(device, netid, T1S_MAX_BURST);
 	if(res != icsneoc2_error_success) return print_error_code("Failed to set T1S max burst", res);

 	res = icsneoc2_settings_t1s_is_termination_enabled_for(device, netid, &termination);
@@ -32,15 +32,14 @@ If you haven't done this, `third-party/libicsneo` will be empty and you won't be

 ### Ubuntu 18.04 LTS

-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to your `libicsneo-examples/libicsneocpp-example` folder and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
    * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make libicsneocpp-interactive-example` to build.
    * Hint! Speed up your build by using multiple processors! Use `make libicsneocpp-interactive-example -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Now run `sudo ./libicsneocpp-interactive-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Now run `./libicsneocpp-interactive-example` to run the example.
 7. If you wish to run the simple example instead, replace any instances of "interactive" with "simple" in steps 5 and 6.

 ### macOS
@@ -0,0 +1,2 @@
+add_executable(libicsneocpp-iso15765-loopback src/ISO15765Loopback.cpp)
+target_link_libraries(libicsneocpp-iso15765-loopback icsneocpp)
@@ -0,0 +1,450 @@
+#include <cctype>
+#include <chrono>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <mutex>
+#include <optional>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "icsneo/icsneocpp.h"
+
+namespace {
+
+using namespace std::chrono_literals;
+
+enum class Mode {
+	None,
+	Raw,
+	SingleFrame,
+	Both,
+};
+
+struct Options {
+	Mode mode = Mode::None;
+	std::string testerSerial;
+	std::string ecuSerial;
+	int64_t baud = 500000;
+	bool keepBaud = false;
+	uint32_t txId = 0x7E0;
+	uint32_t fcId = 0x7E8;
+	std::optional<size_t> payloadBytes;
+	int listenMs = 2000;
+	uint8_t padding = 0x00;
+	uint16_t fsTimeoutMs = 75;
+	uint16_t fsWaitMs = 150;
+	uint16_t cfTimeoutMs = 150;
+};
+
+std::mutex gLogMutex;
+
+void logLine(const std::string& line) {
+	std::lock_guard<std::mutex> lk(gLogMutex);
+	std::cout << line << std::endl;
+}
+
+bool iequals(const std::string& a, const std::string& b) {
+	if(a.size() != b.size())
+		return false;
+	for(size_t i = 0; i < a.size(); i++) {
+		if(std::tolower(static_cast<unsigned char>(a[i])) != std::tolower(static_cast<unsigned char>(b[i])))
+			return false;
+	}
+	return true;
+}
+
+std::string hexBytes(const std::vector<uint8_t>& data) {
+	std::ostringstream oss;
+	oss << std::hex << std::setfill('0');
+	for(size_t i = 0; i < data.size(); i++) {
+		if(i)
+			oss << ' ';
+		oss << std::setw(2) << static_cast<unsigned>(data[i]);
+	}
+	return oss.str();
+}
+
+std::string pciDescribe(const std::vector<uint8_t>& data) {
+	if(data.empty())
+		return {};
+	const uint8_t pciType = static_cast<uint8_t>(data[0] >> 4);
+	const uint8_t pciLow = static_cast<uint8_t>(data[0] & 0x0F);
+	std::ostringstream oss;
+	switch(pciType) {
+		case 0x0:
+			if(pciLow > 7 || data.size() < static_cast<size_t>(1 + pciLow))
+				return {};
+			oss << "SF len=" << static_cast<unsigned>(pciLow);
+			break;
+		case 0x1: {
+			if(data.size() < 8)
+				return {};
+			const uint16_t len = static_cast<uint16_t>((pciLow << 8) | data[1]);
+			if(len < 8)
+				return {};
+			oss << "FF len=" << len;
+			break;
+		}
+		case 0x2:
+			if(data.size() < 2)
+				return {};
+			oss << "CF SN=" << static_cast<unsigned>(pciLow);
+			break;
+		case 0x3: {
+			if(data.size() < 3 || pciLow > 2)
+				return {};
+			static const char* fsName[] = { "CTS", "WAIT", "OVFLW" };
+			oss << "FC FS=" << fsName[pciLow];
+			oss << " BS=" << static_cast<unsigned>(data[1]);
+			oss << " STmin=0x" << std::hex << std::setw(2) << std::setfill('0')
+				<< static_cast<unsigned>(data[2]);
+			break;
+		}
+		default:
+			return {};
+	}
+	return oss.str();
+}
+
+void printUsage(const char* argv0) {
+	std::cerr
+		<< "Usage: " << argv0 << " --raw|--sf|--both [options]\n\n"
+		<< "Two Intrepid devices with CAN1 wired together (CANH/CANL, terminated).\n"
+		<< "Prints CAN1 frames with ISO-TP PCI decode (SF/FF/CF/FC).\n\n"
+		<< "Modes:\n"
+		<< "  --raw   Raw CAN ping-pong (cable check)\n"
+		<< "  --sf    Firmware ISO-TP single-frame TX from tester\n"
+		<< "  --both  Firmware ISO-TP TX on tester, firmware flow-control on ECU\n\n"
+		<< "Devices:\n"
+		<< "  --tester SERIAL   Tester (sender) serial\n"
+		<< "  --ecu SERIAL      ECU / peer serial\n"
+		<< "                    Optional if exactly two devices are found.\n\n"
+		<< "Optional:\n"
+		<< "  --baud N          CAN1 baud (default 500000, applied temporarily)\n"
+		<< "  --keep-baud       Do not change device baud\n"
+		<< "  --tx-id HEX       Tester ISO-TP CAN ID (default 0x7E0)\n"
+		<< "  --fc-id HEX       Flow-control CAN ID (default 0x7E8)\n"
+		<< "  --bytes N         ISO-TP payload size (sf default 5, both default 20)\n"
+		<< "  --listen-ms N     Time to listen after the action (default 2000)\n";
+}
+
+uint32_t parseU32(const std::string& s) {
+	return static_cast<uint32_t>(std::stoul(s, nullptr, 0));
+}
+
+bool parseArgs(int argc, char** argv, Options& opt) {
+	for(int i = 1; i < argc; i++) {
+		const std::string a = argv[i];
+		auto need = [&](const char* name) -> std::string {
+			if(i + 1 >= argc)
+				throw std::runtime_error(std::string("missing value for ") + name);
+			return argv[++i];
+		};
+		if(a == "--raw")
+			opt.mode = Mode::Raw;
+		else if(a == "--sf")
+			opt.mode = Mode::SingleFrame;
+		else if(a == "--both")
+			opt.mode = Mode::Both;
+		else if(a == "--tester")
+			opt.testerSerial = need("--tester");
+		else if(a == "--ecu")
+			opt.ecuSerial = need("--ecu");
+		else if(a == "--baud")
+			opt.baud = static_cast<int64_t>(std::stoll(need("--baud")));
+		else if(a == "--keep-baud")
+			opt.keepBaud = true;
+		else if(a == "--tx-id")
+			opt.txId = parseU32(need("--tx-id"));
+		else if(a == "--fc-id")
+			opt.fcId = parseU32(need("--fc-id"));
+		else if(a == "--bytes")
+			opt.payloadBytes = static_cast<size_t>(std::stoul(need("--bytes")));
+		else if(a == "--listen-ms")
+			opt.listenMs = std::stoi(need("--listen-ms"));
+		else if(a == "-h" || a == "--help") {
+			printUsage(argv[0]);
+			return false;
+		} else {
+			std::cerr << "Unknown argument: " << a << "\n";
+			printUsage(argv[0]);
+			return false;
+		}
+	}
+	if(opt.mode == Mode::None) {
+		printUsage(argv[0]);
+		return false;
+	}
+	return true;
+}
+
+size_t defaultPayloadSize(Mode mode) {
+	return mode == Mode::SingleFrame ? 5 : 20;
+}
+
+std::vector<uint8_t> makePayload(size_t n) {
+	std::vector<uint8_t> data(n);
+	for(size_t i = 0; i < n; i++)
+		data[i] = static_cast<uint8_t>(i & 0xFF);
+	return data;
+}
+
+bool isExtended(uint32_t id) {
+	return id > 0x7FFu;
+}
+
+void printApiResult(const char* what, bool ok) {
+	std::ostringstream oss;
+	oss << "  " << what << ": " << (ok ? "OK" : "FAIL");
+	if(!ok) {
+		const auto err = icsneo::GetLastError();
+		if(err.getType() != icsneo::APIEvent::Type::NoErrorFound)
+			oss << " [" << err << "]";
+	}
+	logLine(oss.str());
+}
+
+bool transmitCan(icsneo::Device& device, uint32_t arbId, std::vector<uint8_t> data) {
+	auto frame = std::make_shared<icsneo::CANMessage>();
+	frame->network = icsneo::Network::NetID::DWCAN_01;
+	frame->arbid = arbId;
+	frame->data = std::move(data);
+	frame->isExtended = isExtended(arbId);
+	frame->isCANFD = false;
+	const bool ok = device.transmit(frame);
+	if(!ok)
+		printApiResult("transmit CAN", ok);
+	return ok;
+}
+
+void fillIso15765(icsneo::Iso15765MessageArgs& msg, const Options& opt, const std::vector<uint8_t>& payload, bool rx) {
+	msg.setTxIndex(0);
+	msg.setArbId(icsneo::Iso15765MessageArgs::ArbId(opt.txId, isExtended(opt.txId)));
+	msg.setFlowControlArbId(icsneo::Iso15765MessageArgs::ArbId(opt.fcId, isExtended(opt.fcId)));
+	msg.setFlowControlArbIdMask(isExtended(opt.txId) ? 0x1FFFFFFFu : 0x7FFu);
+	msg.setIsCanFd(false);
+	msg.setIsBrsEnabled(false);
+	msg.setTxDl(8);
+	msg.setPaddingValue(opt.padding);
+	msg.setFsTimeout(opt.fsTimeoutMs);
+	msg.setFsWaitTimeout(opt.fsWaitMs);
+	msg.setCfTimeout(opt.cfTimeoutMs);
+	msg.setIsFlowControlEnabled(rx);
+	if(!payload.empty()) {
+		auto copy = payload;
+		msg.setData(std::move(copy));
+	}
+}
+
+struct Sniffer {
+	const char* tag = "";
+	std::optional<uint64_t> t0;
+	std::mutex t0Mutex;
+
+	void onCan(const std::shared_ptr<icsneo::CANMessage>& can) {
+		{
+			std::lock_guard<std::mutex> lk(t0Mutex);
+			if(!t0)
+				t0 = can->timestamp;
+		}
+
+		double relMs = 0.0;
+		{
+			std::lock_guard<std::mutex> lk(t0Mutex);
+			if(t0 && can->timestamp >= *t0)
+				relMs = static_cast<double>(can->timestamp - *t0) / 1e6;
+		}
+
+		std::ostringstream oss;
+		oss << "  [" << tag << (can->transmitted ? " TX" : " RX") << "] "
+			<< std::fixed << std::setprecision(3) << relMs << " ms  "
+			<< can->network << "  0x" << std::hex << std::uppercase
+			<< std::setw(isExtended(can->arbid) ? 8 : 3) << std::setfill('0') << can->arbid
+			<< std::dec << " [" << can->data.size() << "]  " << hexBytes(can->data);
+		const auto pci = pciDescribe(can->data);
+		if(!pci.empty())
+			oss << "  " << pci;
+		logLine(oss.str());
+	}
+};
+
+void addCanSniffer(icsneo::Device& device, Sniffer& sniffer) {
+	auto filter = std::make_shared<icsneo::MessageFilter>(icsneo::Network::NetID::DWCAN_01);
+	device.addMessageCallback(std::make_shared<icsneo::MessageCallback>(filter, [&sniffer](std::shared_ptr<icsneo::Message> message) {
+		if(message->type != icsneo::Message::Type::Frame)
+			return;
+		auto frame = std::static_pointer_cast<icsneo::Frame>(message);
+		if(frame->network.getType() != icsneo::Network::Type::CAN)
+			return;
+		sniffer.onCan(std::static_pointer_cast<icsneo::CANMessage>(message));
+	}));
+}
+
+bool openAndOnline(std::shared_ptr<icsneo::Device>& device, const Options& opt) {
+	logLine(std::string("Opening ") + device->describe() + " ...");
+	if(!device->open()) {
+		printApiResult("open", false);
+		return false;
+	}
+	if(!opt.keepBaud && device->settings) {
+		if(!device->settings->setBaudrateFor(icsneo::Network::NetID::DWCAN_01, opt.baud))
+			printApiResult("setBaudrateFor", false);
+		else if(!device->settings->apply(true))
+			printApiResult("settings->apply(temporary)", false);
+	}
+	if(!device->goOnline()) {
+		printApiResult("goOnline", false);
+		device->close();
+		return false;
+	}
+	return true;
+}
+
+void closeDevice(const std::shared_ptr<icsneo::Device>& device) {
+	if(!device)
+		return;
+	device->iso15765DisableAll();
+	if(device->isOnline())
+		device->goOffline();
+	if(device->isOpen())
+		device->close();
+}
+
+bool enableIso(icsneo::Device& device, const char* who) {
+	const bool ok = device.iso15765Enable(icsneo::Network(icsneo::Network::NetID::DWCAN_01));
+	printApiResult((std::string(who) + " ISO15765_Enable").c_str(), ok);
+	return ok;
+}
+
+bool receiveIso(icsneo::Device& device, const Options& opt) {
+	icsneo::Iso15765MessageArgs msg;
+	fillIso15765(msg, opt, {}, true);
+	const bool ok = device.iso15765SetupRxFlowControl(icsneo::Network(icsneo::Network::NetID::DWCAN_01), msg);
+	printApiResult("ECU ISO15765_ReceiveMessage", ok);
+	return ok;
+}
+
+bool transmitIso(icsneo::Device& device, const Options& opt, const std::vector<uint8_t>& payload) {
+	icsneo::Iso15765MessageArgs msg;
+	fillIso15765(msg, opt, payload, false);
+	const bool ok = device.iso15765TransmitMessage(
+		icsneo::Network(icsneo::Network::NetID::DWCAN_01), msg, std::chrono::milliseconds(0));
+	printApiResult("tester ISO15765_TransmitMessage", ok);
+	return ok;
+}
+
+std::shared_ptr<icsneo::Device> findBySerial(const std::vector<std::shared_ptr<icsneo::Device>>& devices, const std::string& serial) {
+	for(const auto& d : devices) {
+		if(iequals(d->getSerial(), serial))
+			return d;
+	}
+	return nullptr;
+}
+
+} // namespace
+
+int main(int argc, char** argv) {
+	Options opt;
+	try {
+		if(!parseArgs(argc, argv, opt))
+			return 1;
+	} catch(const std::exception& ex) {
+		std::cerr << ex.what() << std::endl;
+		return 1;
+	}
+
+	std::cout << "libicsneo " << icsneo::GetVersion() << std::endl;
+
+	auto devices = icsneo::FindAllDevices();
+	std::cout << "Found " << devices.size() << " device(s)\n";
+	for(const auto& d : devices)
+		std::cout << "  " << d->describe() << " serial=" << d->getSerial() << "\n";
+
+	if(devices.size() < 2) {
+		std::cerr << "Need two devices connected.\n";
+		return 1;
+	}
+
+	std::shared_ptr<icsneo::Device> tester;
+	std::shared_ptr<icsneo::Device> ecu;
+	if(opt.testerSerial.empty() && opt.ecuSerial.empty()) {
+		if(devices.size() != 2) {
+			std::cerr << "More than two devices found; pass --tester and --ecu serials.\n";
+			return 1;
+		}
+		tester = devices[0];
+		ecu = devices[1];
+		std::cout << "No serials given; using first as tester, second as ECU.\n";
+	} else {
+		if(opt.testerSerial.empty() || opt.ecuSerial.empty()) {
+			std::cerr << "Pass both --tester and --ecu, or neither.\n";
+			return 1;
+		}
+		tester = findBySerial(devices, opt.testerSerial);
+		ecu = findBySerial(devices, opt.ecuSerial);
+		if(!tester || !ecu) {
+			std::cerr << "Could not match tester/ECU serials.\n";
+			return 1;
+		}
+	}
+
+	const size_t payloadSize = opt.payloadBytes.value_or(defaultPayloadSize(opt.mode));
+	const auto payload = makePayload(payloadSize);
+
+	std::cout << "Tester: " << tester->describe() << "\n"
+			  << "ECU:    " << ecu->describe() << "\n";
+	if(opt.mode != Mode::Raw) {
+		std::ostringstream hdr;
+		hdr << "CAN1 TX 0x" << std::hex << std::uppercase << opt.txId
+			<< "  FC 0x" << opt.fcId << std::dec
+			<< "  payload " << payloadSize << " bytes";
+		std::cout << hdr.str() << "\n";
+	}
+	std::cout << std::endl;
+
+	if(!openAndOnline(tester, opt) || !openAndOnline(ecu, opt))
+		return 1;
+
+	Sniffer testerSniff;
+	testerSniff.tag = "TESTER";
+	Sniffer ecuSniff;
+	ecuSniff.tag = "ECU   ";
+	addCanSniffer(*tester, testerSniff);
+	addCanSniffer(*ecu, ecuSniff);
+
+	switch(opt.mode) {
+		case Mode::Raw:
+			logLine("Mode --raw: tester 0x123, then ECU 0x456");
+			transmitCan(*tester, 0x123, { 0x11, 0x22, 0x33, 0x44 });
+			std::this_thread::sleep_for(200ms);
+			transmitCan(*ecu, 0x456, { 0x55, 0x66, 0x77, 0x88 });
+			break;
+		case Mode::SingleFrame:
+			logLine("Mode --sf: firmware ISO-TP single frame from tester");
+			if(payload.size() > 7)
+				logLine("  warning: payload > 7 bytes will be a First Frame (no flow control in this mode)");
+			enableIso(*tester, "tester");
+			transmitIso(*tester, opt, payload);
+			break;
+		case Mode::Both:
+			logLine("Mode --both: firmware TX on tester, firmware flow-control on ECU");
+			enableIso(*tester, "tester");
+			enableIso(*ecu, "ECU");
+			receiveIso(*ecu, opt);
+			std::this_thread::sleep_for(100ms);
+			transmitIso(*tester, opt, payload);
+			break;
+		case Mode::None:
+			break;
+	}
+
+	std::this_thread::sleep_for(std::chrono::milliseconds(opt.listenMs));
+
+	closeDevice(tester);
+	closeDevice(ecu);
+	return 0;
+}
@@ -77,7 +77,7 @@ int main(int, char**) {
 	cfg.setTxEnable(true);

 	// Write config to the device
-	if(!device->writeMACsecConfig(cfg)) {
+	if(!device->writeMACsecConfig(cfg, icsneo::Network::NetID::AE_01)) {
 		std::cout << "Failed to write MACsec config" << std::endl;
 		std::cout << icsneo::GetLastError() << std::endl;
 		return -1;
@@ -32,15 +32,14 @@ If you haven't done this, `third-party/libicsneo` will be empty and you won't be

 ### Ubuntu 18.04 LTS

-1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake libpcap0.8-dev`
+1. Install dependencies with `sudo apt update` then `sudo apt install build-essential cmake`
 2. Change directories to your `libicsneo-examples/libicsneocpp-example` folder and create a build directory by running `mkdir -p build`
 3. Enter the build directory with `cd build`
 4. Run `cmake ..` to generate your Makefile.
    * Hint! Running `cmake -DCMAKE_BUILD_TYPE=Debug ..` will generate the proper scripts to build debug, and `cmake -DCMAKE_BUILD_TYPE=Release ..` will generate the proper scripts to build with all optimizations on.
 5. Run `make libicsneocpp-interactive-example` to build.
    * Hint! Speed up your build by using multiple processors! Use `make libicsneocpp-interactive-example -j#` where `#` is the number of cores/threads your system has plus one. For instance, on a standard 8 thread Intel i7, you might use `-j9` for an ~8x speedup.
-6. Now run `sudo ./libicsneocpp-interactive-example` to run the example.
-    * Hint! In order to run without sudo, you will need to set up the udev rules. Copy `libicsneo-examples/third-party/libicsneo/99-intrepidcs.rules` to `/etc/udev/rules.d`, then run `udevadm control --reload-rules && udevadm trigger` afterwards. While the program will still run without setting up these rules, it will fail to open any devices.
+6. Now run `./libicsneocpp-interactive-example` to run the example.
 7. If you wish to run the simple example instead, replace any instances of "interactive" with "simple" in steps 5 and 6.

 ### macOS
@@ -0,0 +1,49 @@
+import sys
+
+import icsneopy
+
+def update(firmware_path):
+	devices = icsneopy.find_all_devices()
+
+	if len(devices) == 0:
+		print("no devices found")
+		return False
+
+	device = devices[0]
+	print(f"selected {device}")
+
+	if not device.open():
+		print("unable to open device")
+		return False
+
+	fw = icsneopy.Bootloader.FWLoader.load(firmware_path)
+	if fw is None:
+		print(f"unable to load firmware from {firmware_path}")
+		return False
+
+	last_status = None
+
+	# repeated status messages overwrite the current line so progress updates in place
+	def logger(status_type, status, progress):
+		nonlocal last_status
+		if last_status not in (None, status):
+			print()
+		last_status = status
+		print(f"\r{status}" + (f" ({progress * 100:.1f}%)" if progress is not None else ""), end="", flush=True)
+		return icsneopy.Device.OpenDirective.Continue
+
+	# force_flash updates every chip, even those already at the version in the firmware file
+	ok = icsneopy.Bootloader.update(device, fw, logger, force_flash=True)
+	print()
+	if not ok:
+		print(f"update failed: {icsneopy.get_last_error()}")
+		return False
+
+	print("update complete")
+	return True
+
+if __name__ == "__main__":
+	if len(sys.argv) != 2:
+		print(f"usage: {sys.argv[0]} <fw.bin|bundle>")
+		sys.exit(1)
+	sys.exit(0 if update(sys.argv[1]) else 1)
@@ -0,0 +1,264 @@
+"""
+Two-device ISO-TP loopback on CAN1.
+
+Firmware segments the payload. This script sends it once and prints CAN1
+frames with the ISO-TP PCI nibble decoded (SF/FF/CF/FC).
+
+Wire CAN1 of two devices together (CANH/CANL, terminated).
+
+  python iso15765_loopback.py --raw
+  python iso15765_loopback.py --sf
+  python iso15765_loopback.py --both
+"""
+
+import argparse
+import threading
+import time
+from datetime import timedelta
+
+import icsneopy
+
+
+CAN1 = icsneopy.Network.NetID.DWCAN_01
+
+
+def pci_describe(data):
+	if not data:
+		return ""
+	pci_type = data[0] >> 4
+	pci_low = data[0] & 0x0F
+	if pci_type == 0x0:
+		if pci_low > 7 or len(data) < 1 + pci_low:
+			return ""
+		return f"SF len={pci_low}"
+	if pci_type == 0x1:
+		if len(data) < 8:
+			return ""
+		length = (pci_low << 8) | data[1]
+		if length < 8:
+			return ""
+		return f"FF len={length}"
+	if pci_type == 0x2:
+		if len(data) < 2:
+			return ""
+		return f"CF SN={pci_low}"
+	if pci_type == 0x3:
+		if len(data) < 3 or pci_low > 2:
+			return ""
+		fs_name = ("CTS", "WAIT", "OVFLW")[pci_low]
+		return f"FC FS={fs_name} BS={data[1]} STmin=0x{data[2]:02X}"
+	return ""
+
+
+def print_api_result(what, ok):
+	line = f"  {what}: {'OK' if ok else 'FAIL'}"
+	if not ok:
+		err = icsneopy.get_last_error()
+		if err.get_type() != icsneopy.APIEvent.Type.NoErrorFound:
+			line += f" [{err.describe()}]"
+	print(line)
+
+
+def is_extended(arb_id):
+	return arb_id > 0x7FF
+
+
+def make_args(tx_id, fc_id, payload, rx):
+	msg = icsneopy.Iso15765MessageArgs()
+	msg.tx_index = 0
+	msg.arb_id = icsneopy.Iso15765MessageArgs.ArbId(tx_id, is_extended(tx_id))
+	msg.flow_control_arb_id = icsneopy.Iso15765MessageArgs.ArbId(fc_id, is_extended(fc_id))
+	msg.flow_control_arb_id_mask = 0x1FFFFFFF if is_extended(tx_id) else 0x7FF
+	msg.is_can_fd = False
+	msg.is_brs_enabled = False
+	msg.tx_dl = 8
+	msg.padding_value = 0x00
+	msg.fs_timeout = 75
+	msg.fs_wait_timeout = 150
+	msg.cf_timeout = 150
+	msg.is_flow_control_enabled = rx
+	if payload:
+		msg.data = payload
+	return msg
+
+
+def transmit_can(device, arb_id, data):
+	frame = icsneopy.CANMessage()
+	frame.network = icsneopy.Network(CAN1)
+	frame.arbid = arb_id
+	# RawMessage.data is vector<uint8_t>: a list of ints, not bytes.
+	frame.data = list(data)
+	frame.isExtended = is_extended(arb_id)
+	frame.isCANFD = False
+	ok = device.transmit(frame)
+	if not ok:
+		print_api_result("transmit CAN", ok)
+	return ok
+
+
+class Sniffer:
+	def __init__(self, tag):
+		self.tag = tag
+		self.t0 = None
+		self.lock = threading.Lock()
+
+	def on_message(self, message):
+		if not isinstance(message, icsneopy.CANMessage):
+			return
+		if message.network.get_type() != icsneopy.Network.Type.CAN:
+			return
+		with self.lock:
+			if self.t0 is None:
+				self.t0 = message.timestamp
+			rel_ms = 0.0
+			if message.timestamp >= self.t0:
+				rel_ms = (message.timestamp - self.t0) / 1e6
+			direction = "TX" if message.transmitted else "RX"
+			width = 8 if is_extended(message.arbid) else 3
+			data = " ".join(f"{b:02X}" for b in message.data)
+			line = (
+				f"  [{self.tag} {direction}] {rel_ms:8.3f} ms  "
+				f"{message.network}  0x{message.arbid:0{width}X} "
+				f"[{len(message.data)}]  {data}"
+			)
+			pci = pci_describe(message.data)
+			if pci:
+				line += f"  {pci}"
+			print(line)
+
+
+def open_and_online(device, baud, keep_baud):
+	print(f"Opening {device.describe()} ...")
+	if not device.open():
+		print_api_result("open", False)
+		return False
+	if not keep_baud and device.settings is not None:
+		net = icsneopy.Network(CAN1)
+		if not device.settings.set_baudrate(net, baud):
+			print_api_result("set_baudrate", False)
+		elif not device.settings.apply(True):
+			print_api_result("settings.apply(temporary)", False)
+	if not device.go_online():
+		print_api_result("go_online", False)
+		device.close()
+		return False
+	return True
+
+
+def close_device(device):
+	if device is None:
+		return
+	device.iso15765_disable_all()
+	if device.is_online():
+		device.go_offline()
+	if device.is_open():
+		device.close()
+
+
+def find_by_serial(devices, serial):
+	for device in devices:
+		if device.get_serial().lower() == serial.lower():
+			return device
+	return None
+
+
+def parse_args():
+	parser = argparse.ArgumentParser(
+		description="Two Intrepid devices with CAN1 wired together (CANH/CANL, terminated)."
+	)
+	mode = parser.add_mutually_exclusive_group(required=True)
+	mode.add_argument("--raw", action="store_true", help="Raw CAN ping-pong (cable check)")
+	mode.add_argument("--sf", action="store_true", help="Firmware ISO-TP single-frame TX from tester")
+	mode.add_argument("--both", action="store_true", help="Firmware ISO-TP TX on tester, firmware flow-control on ECU")
+	parser.add_argument("--tester", default="", help="Tester (sender) serial. Optional if exactly two devices are found.")
+	parser.add_argument("--ecu", default="", help="ECU / peer serial. Optional if exactly two devices are found.")
+	parser.add_argument("--baud", type=int, default=500000, help="CAN1 baud, applied temporarily (default 500000)")
+	parser.add_argument("--keep-baud", action="store_true", help="Do not change device baud")
+	parser.add_argument("--tx-id", type=lambda s: int(s, 0), default=0x7E0, help="Tester ISO-TP CAN ID (default 0x7E0)")
+	parser.add_argument("--fc-id", type=lambda s: int(s, 0), default=0x7E8, help="Flow-control CAN ID (default 0x7E8)")
+	parser.add_argument("--bytes", type=int, default=None, help="ISO-TP payload size (sf default 5, both default 20)")
+	parser.add_argument("--listen-ms", type=int, default=2000, help="Time to listen after the action (default 2000)")
+	return parser.parse_args()
+
+
+def main():
+	args = parse_args()
+	print(f"libicsneo {icsneopy.get_version()}")
+
+	devices = icsneopy.find_all_devices()
+	print(f"Found {len(devices)} device(s)")
+	for device in devices:
+		print(f"  {device.describe()} serial={device.get_serial()}")
+	if len(devices) < 2:
+		raise SystemExit("Need two devices connected.")
+
+	if not args.tester and not args.ecu:
+		if len(devices) != 2:
+			raise SystemExit("More than two devices found; pass --tester and --ecu serials.")
+		tester, ecu = devices[0], devices[1]
+		print("No serials given; using first as tester, second as ECU.")
+	else:
+		if not args.tester or not args.ecu:
+			raise SystemExit("Pass both --tester and --ecu, or neither.")
+		tester = find_by_serial(devices, args.tester)
+		ecu = find_by_serial(devices, args.ecu)
+		if tester is None or ecu is None:
+			raise SystemExit("Could not match tester/ECU serials.")
+
+	payload_size = args.bytes if args.bytes is not None else (5 if args.sf else 20)
+	payload = [i & 0xFF for i in range(payload_size)]
+
+	print(f"Tester: {tester.describe()}")
+	print(f"ECU:    {ecu.describe()}")
+	if not args.raw:
+		print(f"CAN1 TX 0x{args.tx_id:X}  FC 0x{args.fc_id:X}  payload {payload_size} bytes")
+	print()
+
+	network = icsneopy.Network(CAN1)
+	try:
+		if not open_and_online(tester, args.baud, args.keep_baud):
+			return 1
+		if not open_and_online(ecu, args.baud, args.keep_baud):
+			return 1
+
+		for device, sniffer in ((tester, Sniffer("TESTER")), (ecu, Sniffer("ECU   "))):
+			callback = icsneopy.MessageCallback(sniffer.on_message, icsneopy.MessageFilter(CAN1))
+			device.add_message_callback(callback)
+
+		if args.raw:
+			print("Mode --raw: tester 0x123, then ECU 0x456")
+			transmit_can(tester, 0x123, [0x11, 0x22, 0x33, 0x44])
+			time.sleep(0.2)
+			transmit_can(ecu, 0x456, [0x55, 0x66, 0x77, 0x88])
+		elif args.sf:
+			print("Mode --sf: firmware ISO-TP single frame from tester")
+			if len(payload) > 7:
+				print("  warning: payload > 7 bytes will be a First Frame (no flow control in this mode)")
+			ok = tester.iso15765_enable(network)
+			print_api_result("tester iso15765_enable", ok)
+			msg = make_args(args.tx_id, args.fc_id, payload, rx=False)
+			ok = tester.iso15765_transmit_message(network, msg, timedelta(0))
+			print_api_result("tester iso15765_transmit_message", ok)
+		else:
+			print("Mode --both: firmware TX on tester, firmware flow-control on ECU")
+			ok = tester.iso15765_enable(network)
+			print_api_result("tester iso15765_enable", ok)
+			ok = ecu.iso15765_enable(network)
+			print_api_result("ECU iso15765_enable", ok)
+			msg = make_args(args.tx_id, args.fc_id, [], rx=True)
+			ok = ecu.iso15765_setup_rx_flow_control(network, msg)
+			print_api_result("ECU iso15765_setup_rx_flow_control", ok)
+			time.sleep(0.1)
+			msg = make_args(args.tx_id, args.fc_id, payload, rx=False)
+			ok = tester.iso15765_transmit_message(network, msg, timedelta(0))
+			print_api_result("tester iso15765_transmit_message", ok)
+
+		time.sleep(args.listen_ms / 1000.0)
+	finally:
+		close_device(tester)
+		close_device(ecu)
+	return 0
+
+
+if __name__ == "__main__":
+	raise SystemExit(main())
@@ -0,0 +1,45 @@
+import icsneopy
+import time
+
+#
+# Main51 messages are device-originated notifications from the firmware's Main51 processor.
+# This example filters for RX buffer overflow and TX FIFO overflow events.
+#
+def main51_filter():
+	devices = icsneopy.find_all_devices()
+
+	if len(devices) == 0:
+		print("no devices found")
+		return False
+
+	device = devices[0]
+	print(f"selected {device}")
+
+	def on_main51(message):
+		if not isinstance(message, icsneopy.Main51Message):
+			return
+		if message.command == icsneopy.Command.Main51RxBufferOverflow:
+			print("RX buffer overflow")
+		elif message.command == icsneopy.Command.Main51TxFifoOverflow:
+			print("TX FIFO overflow")
+		else:
+			print(f"Main51 command: {message.command}")
+
+	filter = icsneopy.Main51MessageFilter()
+	callback = icsneopy.MessageCallback(on_main51, filter)
+	device.add_message_callback(callback)
+
+	if not device.open():
+		print("unable to open device")
+		return False
+
+	if not device.go_online():
+		print("unable to go online")
+		return False
+
+	time.sleep(5)
+
+	return True
+
+if __name__ == "__main__":
+	main51_filter()
@@ -1,33 +1,133 @@
 #ifndef _J2534_H
 #define _J2534_H

+#include <cstdint>
+
+namespace icsneo {
+
 //J2534 Commands
 #define J1534_NUM_PERIOD_TX_MSGS 128
 #define J1534_NUM_PERIOD_RX_MSGS 128
-#define J2534NVCMD_SetISJ2534 0
-#define J2534NVCMD_SetISO5Baud 1
-#define J2534NVCMD_SetISOFastInit 2
-#define J2534NVCMD_SetISOCheckSum 3
-#define J2534NVCMD_SetISO9141Parms 4
-#define J2534NVCMD_GetISO9141Parms 5
-#define J2534NVCMD_ISO9141APIChkSum 6
-#define J2534NVCMD_SetNetworkBaudRate 7
-#define J2534NVCMD_GetNetworkBaudRate 8
-#define J2534NVCMD_EnableTransmitEvent 9
-#define J2534NVCMD_SetTransmitEvent 10
-#define J2534NVCMD_BlueEnableStopFilters 11
-#define J2534NVCMD_Blue15765HWSupport 12
-#define J2534NVCMD_GetTXBufferInfo 13
-#define J2534NVCMD_GetEncryptionKey 14
-#define J2534NVCMD_SetMiscIOForVBATT 15
-#define J2534NVCMD_EnableISO_KW_Network 16
-#define J2534NVCMD_SetJ1708CheckSum 17
-#define J2534NVCMD_GetTimestamp 18
-#define J2534NVCMD_GetCANFDRate 19
-#define J2534NVCMD_SetCANFDRate 20
-#define J2534NVCMD_GetCANFDTermination 21
-#define J2534NVCMD_SetCANFDTermination 22
-#define J2534NVCMD_GetCANFDFormat 23
-#define J2534NVCMD_SetCANFDFormat 24
+
+enum class J2534Command : uint8_t {
+    SetISJ2534 = 0,
+    SetISO5Baud = 1,
+    SetISOFastInit = 2,
+    SetISOCheckSum = 3,
+    SetISO9141Parms = 4,
+    GetISO9141Parms = 5,
+    ISO9141APIChkSum = 6,
+    SetNetworkBaudRate = 7,
+    GetNetworkBaudRate = 8,
+    EnableTransmitEvent = 9,
+    SetTransmitEvent = 10,
+    BlueEnableStopFilters = 11,
+    Blue15765HWSupport = 12,
+    GetTXBufferInfo = 13,
+    GetEncryptionKey = 14,
+    SetMiscIOForVBATT = 15,
+    EnableISO_KW_Network = 16,
+    SetJ1708CheckSum = 17,
+    GetTimestamp = 18,
+    GetCANFDRate = 19,
+    SetCANFDRate = 20,
+    GetCANFDTermination = 21,
+    SetCANFDTermination = 22,
+    GetCANFDFormat = 23,
+    SetCANFDFormat = 24
+};
+
+#pragma pack(push)
+#pragma pack(1)
+
+/**
+ * SubFrame Commands
+ */
+enum class J2534SubCommand : uint8_t {
+    Enable = 0,
+    SetupIso15765RxFilter = 1,
+    SetupIso15765TxMessageProperties = 2,
+    SetupIso15765TxMessageDataBytes = 3,
+    SetupCanRxFilter = 4,
+    SetupClearCanRxFilters = 5,
+    EnableFiltering = 6
+};
+
+typedef struct
+{
+	uint16_t uiFilterMask0;
+	uint16_t uiFilterID0;
+	uint16_t uiFilterMask1;
+	uint16_t uiFilterID1;
+	uint16_t uiFilterMask2;
+	uint16_t uiFilterID2;
+	union {
+		/** Mask and value words if rx filter is datalink filter*/
+		struct
+		{
+			uint16_t uiFilterMask3;
+			uint16_t uiFilterID3;
+			uint16_t uiFilterMask4;
+			uint16_t uiFilterID4;
+			uint16_t uiFilterMask5;
+			uint16_t uiFilterID5;
+			uint16_t uiFilterMask6;
+			uint16_t uiFilterID6;
+		} datalink;
+		/** Mask and value bytes if rx filter is datalink filter*/
+		struct
+		{
+			uint8_t uiFilterMask_DB0;
+			uint8_t uiFilterMask_DB1;
+			uint8_t uiFilterID_DB0;
+			uint8_t uiFilterID_DB1;
+			uint8_t uiFilterMask_DB2;
+			uint8_t uiFilterMask_DB3;
+			uint8_t uiFilterID_DB2;
+			uint8_t uiFilterID_DB3;
+			uint8_t uiFilterMask_DB4;
+			uint8_t uiFilterMask_DB5;
+			uint8_t uiFilterID_DB4;
+			uint8_t uiFilterID_DB5;
+			uint8_t uiFilterMask_DB6;
+			uint8_t uiFilterMask_DB7;
+			uint8_t uiFilterID_DB6;
+			uint8_t uiFilterID_DB7;
+		} datalinkBytes;
+		/** Mask and value bytes if rx filter is Iso15765-2*/
+		struct
+		{
+			uint8_t uiFilterMask_DB0;
+			uint8_t uiFilterID_DB0;
+			uint8_t uiFilterMask_DB1;
+			uint8_t uiFilterID_DB1;
+			uint8_t uiFilterMask_DB2;
+			uint8_t uiFilterID_DB2;
+			uint8_t uiFilterMask_DB3;
+			uint8_t uiFilterID_DB3;
+			uint8_t uiFilterMask_DB4;
+			uint8_t uiFilterID_DB4;
+			uint8_t uiFilterMask_DB5;
+			uint8_t uiFilterID_DB5;
+			uint8_t uiFilterMask_DB6;
+			uint8_t uiFilterID_DB6;
+			uint8_t uiFilterMask_DB7;
+			uint8_t uiFilterID_DB7;
+		} iso15Bytes;
+	} args;
+} MessageFilterBytes;
+
+typedef struct
+{
+	uint16_t idx;
+	uint16_t enabled;
+	uint16_t filterCount;
+	MessageFilterBytes fb;
+	uint16_t networkId;
+} J2534_RxCanFilter;
+
+#pragma pack(pop)
+
+} // namespace icsneo

 #endif
@@ -126,6 +126,9 @@ public:
 		SettingNotAvaiableDevice = 0x2057,
 		DiskFormatNotSupported = 0x2058,
 		DiskFormatInvalidCount = 0x2059,
+		TC10RequestFailed = 0x205A,
+		FirmwareUpdateNotSupported = 0x205B,
+		FirmwareUpdateFailed = 0x205C,

 		// Transport Events
 		FailedToRead = 0x3000,
@@ -167,6 +170,7 @@ public:
 		ServdNoDataError = ServdBindError + 9,
 		ServdJoinMulticastError = ServdBindError + 10,
 		ServdNotReachable = ServdBindError + 11,
+		ServdDisabled = ServdBindError + 12,

 		// DXX
 		DXXErrorSys = 0x6100,
@@ -31,7 +31,10 @@ enum class Command : uint8_t {
 	LoadCoreMini = 0x43,
 	GetRTC = 0x49,
 	SetRTC = 0x50,
+	PeripheralBootloader = 0x83,
+	EnterBootloader = 0xA0,
 	RequestSerialNumber = 0xA1,
+	ValidateDevice = 0xA2,
 	GetMainVersion = 0xA3, // Previously known as RED_CMD_APP_VERSION_REQ
 	SetSettings = 0xA4, // Previously known as RED_CMD_SET_BAUD_REQ, follow up with SaveSettings to write to EEPROM
 	//GetSettings = 0xA5, // Previously known as RED_CMD_READ_BAUD_REQ, now unused
@@ -43,6 +46,7 @@ enum class Command : uint8_t {
 	GetLogicalDiskInfo = 0xBB, // Previously known as RED_CMD_GET_SDCARD_INFO
 	RequestStatusUpdate = 0xBC,
 	ReadSettings = 0xC7, // Previously known as 3G_READ_SETTINGS_EX
+	J2534Command = 0xD7, // Previously known as RED_CMD_J2534_EXTENSION
 	SetVBattMonitor = 0xDB, // Previously known as RED_CMD_CM_VBATT_MONITOR
 	RequestBitSmash = 0xDC, // Previously known as RED_CMD_CM_BITSMASH
 	WiVICommand = 0xDD, // Previously known as RED_CMD_WIVI_COMM
@@ -73,8 +77,11 @@ enum class ExtendedCommand : uint16_t {
 	GetComponentVersions = 0x001A,
 	SoftwareUpdate = 0x001B,
 	Reboot = 0x001C,
+	ReadGenericAPIStatus = 0x001D,
 	SetRootFSEntryFlags = 0x0027,
 	TransmitCoreminiMessage = 0x0028,
+	ReadGenericAPIData = 0x002E,
+	WriteGenericAPICommand = 0x002F,
 	GenericBinaryInfo = 0x0030,
 	LiveData = 0x0035,
 	ExecuteSPIPortKeyOperation = 0x003C,
@@ -9,6 +9,7 @@
 #include <common/v1/proto_header.pb.h>
 #include <commands/generic/v1/client_id.pb.h>
 #include <commands/network/v1/mutex.pb.h>
+#include <settings/manufacturing/v1/mfg_config.pb.h>
 #ifdef _WIN32
 #pragma warning(pop)
 #endif
@@ -36,6 +37,11 @@ struct IDLookup {
 	constexpr static common::v1::ProtoId value = common::v1::ProtoId::PROTO_ID_UNSPECIFIED;
 };

+template <>
+struct IDLookup<settings::manufacturing::v1::MfgConfig> {
+	constexpr static common::v1::ProtoId value = common::v1::ProtoId::PROTO_ID_MFG_CONFIG;
+};
+
 template <>
 struct IDLookup<commands::network::v1::NetworkMutex> {
 	constexpr static common::v1::ProtoId value = common::v1::ProtoId::PROTO_ID_NETWORK_MUTEX;
@@ -8,6 +8,7 @@
 #include "icsneo/communication/packet.h"
 #include <vector>
 #include <memory>
+#include <optional>

 namespace icsneo {

@@ -17,13 +18,16 @@ namespace icsneo {
 #endif

 struct PhyMessage {
-	bool Enabled;
-	bool WriteEnable;
-	bool Clause45Enable;
-	uint8_t BusIndex;
-	uint8_t Version;
+	bool Enabled = false;
+	bool WriteEnable = false;
+	bool Clause45Enable = false;
+	uint8_t BusIndex = 0;
+	uint8_t Version = PhyPacketVersion;
+	// Unset on locally constructed messages; every decoded response sets the raw wire status.
+	// Ignored when sending. A value does not establish firmware error coverage.
+	std::optional<uint8_t> Status;
 	union {
-		Clause22Message Clause22;
+		Clause22Message Clause22{};
 		Clause45Message Clause45;
 	};
 };
@@ -0,0 +1,44 @@
+#ifndef __GENERICAPIDATAMESSAGE_H_
+#define __GENERICAPIDATAMESSAGE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/message.h"
+
+#include <vector>
+#include <memory>
+
+namespace icsneo {
+
+class GenericAPIDataMessage : public Message {
+public:
+	static constexpr size_t GENERIC_API_BUFFER_SIZE = 513;
+
+#pragma pack(push, 1)
+	struct GenericAPIDataHeader {
+		uint16_t bufferLength;
+		uint8_t apiIndex;
+		uint8_t instance;
+		uint8_t functionId;
+	};
+
+	struct GenericAPIDataPacket
+	{
+		GenericAPIDataHeader header;
+		uint8_t buffer[GENERIC_API_BUFFER_SIZE];
+	};
+#pragma pack(pop)
+
+	static std::shared_ptr<GenericAPIDataMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
+
+	GenericAPIDataMessage() : Message(Type::GenericAPIData) {}
+
+	uint8_t functionId;
+	std::vector<uint8_t> buffer;
+};
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __GENERICAPIDATAMESSAGE_H_
@@ -0,0 +1,40 @@
+#ifndef __GENERICAPISTATUSMESSAGE_H_
+#define __GENERICAPISTATUSMESSAGE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/message.h"
+
+#include <memory>
+
+namespace icsneo {
+
+class GenericAPIStatusMessage : public Message {
+public:
+#pragma pack(push, 2)
+	struct GenericAPIStatusResponsePacket
+	{
+		uint8_t apiIndex;
+		uint8_t instance;
+		uint8_t functionId;
+		uint8_t functionError;
+		uint8_t callbackError;
+		uint8_t finishedProcessing;
+	};
+#pragma pack(pop)
+
+	static std::shared_ptr<GenericAPIStatusMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
+
+	GenericAPIStatusMessage() : Message(Type::GenericAPIStatus) {}
+
+	uint8_t functionId;
+	bool finishedProcessing;
+	uint8_t functionError;
+	uint8_t callbackError;
+};
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __GENERICAPISTATUSMESSAGE_H_
@@ -0,0 +1,443 @@
+#ifndef __ISO_15765MESSAGE_H_
+#define __ISO_15765MESSAGE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/main51message.h"
+#include "icsneo/communication/command.h"
+#include "icsneo/J2534.h"
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace icsneo {
+
+class J2534CommandMessage : public Main51Message
+{
+public:
+	enum class J2534Command : uint8_t
+	{
+		Enable = 0,	//RED_CMD_J2534_EXTENSION_ENABLE,
+		SetupIso15765RxFilter = 1, //RED_CMD_J2534_EXTENSION_SETUP_ISO15_RX_FILTER,
+		SetupIso15765TxMessageProperties = 2, //RED_CMD_J2534_EXTENSION_SETUP_ISO15_TX_MESSAGE_PROPERTIES,
+		SetupIso15765TxMessageDataBytes = 3, //RED_CMD_J2534_EXTENSION_SETUP_ISO15_TX_MESSAGE_DATABYTES,
+		SetupCanRxFilter = 4, //RED_CMD_J2534_EXTENSION_SETUP_CAN_RX_FILTER,
+		SetupClearCanRxFilters = 5, //RED_CMD_J2534_EXTENSION_SETUP_CLEAR_CAN_RX_FILTERS,
+		EnableFiltering = 6, //RED_CMD_J2534_EXTENSION_ENABLE_FILTERING,
+	};
+
+	J2534CommandMessage(const J2534Command j2534Command, const std::vector<uint8_t>& arguments = {})
+		: Main51Message() {
+		command = Command::J2534Command;
+		argumentData.push_back((uint8_t)j2534Command);
+		argumentData.push_back(0);
+		setArgumentData(arguments);
+	}
+	virtual ~J2534CommandMessage(void) = default;
+
+    J2534Command getJ2534Command(void) const { return (J2534Command)argumentData[0]; }
+    void setJ2534Command(const J2534Command& j2534Command) { argumentData[0] = (uint8_t)j2534Command; }
+
+    const std::vector<uint8_t>& getArgumentData(void) const { return argumentData; }
+    void setArgumentData(const std::vector<uint8_t>& arguments) { argumentData.insert(argumentData.end(), arguments.begin(), arguments.end()); }
+
+	static std::shared_ptr<J2534CommandMessage> decodeToMessage(const std::vector<uint8_t>& data);
+
+protected:
+    std::vector<uint8_t> argumentData;
+
+	uint16_t read16LE(size_t o) const;
+	void write16LE(size_t o, uint16_t v);
+	uint16_t read16BE(size_t o) const;
+	void write16BE(size_t o, uint16_t v);
+	void writeBits16LE(size_t o, unsigned bitPos, unsigned bitCount, uint32_t value);
+	uint32_t read32LE(size_t o) const;
+	void write32LE(size_t o, uint32_t v);
+	uint32_t read32BE(size_t o) const;
+	void write32BE(size_t o, uint32_t v);
+};
+
+class J2534EnableMessage : public J2534CommandMessage {
+public:
+	J2534EnableMessage(const bool enable)
+		: J2534CommandMessage(J2534Command::Enable, { (uint8_t)enable }) {
+	}
+	bool getEnable(void) const { return (bool)argumentData[2]; }
+    void setEnable(bool enable) { argumentData[2] = (uint8_t)enable; }
+};
+
+class J2534EnableFilteringMessage : public J2534CommandMessage {
+public:
+	J2534EnableFilteringMessage(const bool enable)
+		: J2534CommandMessage(J2534Command::EnableFiltering, { (uint8_t)enable }) {
+	}
+	bool getEnable(void) const { return (bool)argumentData[2]; }
+	void setEnable(bool enable) { argumentData[2] = (uint8_t)enable; }
+};
+
+class J2534SetupCanRxFilteringMessage : public J2534CommandMessage {
+public:
+	J2534SetupCanRxFilteringMessage(const J2534_RxCanFilter& filter)
+		: J2534CommandMessage(J2534Command::SetupCanRxFilter) {
+        setRxCanFilter(filter);
+	}
+
+	J2534_RxCanFilter getRxCanFilter(void) const;
+
+	void setRxCanFilter(const J2534_RxCanFilter& filter);
+};
+
+class J2534SetupIso15765FlowControlMessage : public J2534CommandMessage
+{
+public:
+	J2534SetupIso15765FlowControlMessage();
+
+	uint16_t getIdx(void) const;
+	void setIdx(uint16_t idx);
+	uint16_t getCoreMiniId(void) const;
+	void setCoreMiniId(uint16_t coreMiniId);
+	uint8_t getPadding(void) const;
+	void setPadding(uint8_t padding);
+	uint32_t getId(void) const;
+	void setId(uint32_t id);
+	uint32_t getIdMask(void) const;
+	void setIdMask(uint32_t idMask);
+	uint32_t getFcId(void) const;
+	void setFcId(uint32_t fcId);
+	uint8_t getFlowControlExtendedAddress(void) const;
+	void setFlowControlExtendedAddress(uint8_t addr);
+	uint8_t getExtendedAddress(void) const;
+	void setExtendedAddress(uint8_t addr);
+	uint8_t getBlockSize(void) const;
+	void setBlockSize(uint8_t blockSize);
+	uint8_t getStMin(void) const;
+	void setStMin(uint8_t stMin);
+	uint16_t getCfTimeout(void) const;
+	void setCfTimeout(uint16_t cfTimeout);
+	uint32_t getFlags(void) const;
+	void setFlags(uint32_t flags);
+
+	bool getEnable(void) const;
+	void setEnable(bool enable);
+	bool getIs29BitEnabled(void) const;
+	void setIs29BitEnabled(bool enable);
+	bool getIsFc29BitEnabled(void) const;
+	void setIsFc29BitEnabled(bool enable);
+	bool getExtAddressEnabled(void) const;
+	void setExtAddressEnabled(bool enable);
+	bool getFcExtAddressEnabled(void) const;
+	void setFcExtAddressEnabled(bool enable);
+	bool getFlowControlTransmissionEnabled(void) const;
+	void setFlowControlTransmissionEnabled(bool enable);
+	bool getPaddingEnabled(void) const;
+	void setPaddingEnabled(bool enable);
+	bool getIsCanFd(void) const;
+	void setIsCanFd(bool enable);
+	bool getIsBrsEnabled(void) const;
+	void setIsBrsEnabled(bool enable);
+
+private:
+	// The legacy wire format was the raw memory of the (now-removed) J2534_RxFlowControlRequest
+	// struct copied into mArgumentData starting at offset 1 (overwriting the header pad byte).
+	// The struct was compiled with `#pragma pack(2)` on MSVC little-endian. All multi-byte
+	// scalars are therefore stored little-endian; the "flt" region reproduces the exact
+	// byte pattern produced by the old MessageBitsCAN bitfield writes.
+	//
+	// Byte layout (mArgumentData indices):
+	//   [0]      J2534 command header byte (set by base class)
+	//   [1]	  padding
+	//   [2..3]   idx (u16 LE)
+	//   [4..5]   iCoreMiniID (u16 LE)
+	//   [6]      padding (u8)
+	//   [7]      structure pad byte (unused)
+	//   [8..11]  id (u32 LE)
+	//   [12..15] id_mask (u32 LE)
+	//   [16..19] fc_id (u32 LE)
+	//   [20]     flowControlExtendedAddress (u8)
+	//   [21]     extendedAddress (u8)
+	//   [22]     blockSize (u8)
+	//   [23]     stMin (u8)
+	//   [24..25] cf_timeout (u16 LE)
+	//   [26..53] MessageFilterBytes flt (28 bytes) -- see RebuildFilterBytes for details
+	//   [54..57] flags (u32 LE) -- see kFcFlag* below
+	//
+	// Total wire size: 58 bytes.
+	static const size_t MessageSize = 58;
+	static const size_t IdxOffset = 2;
+	static const size_t CoreMiniOffset = 4;
+	static const size_t PaddingOffset = 6;
+	static const size_t IdOffset = 8;
+	static const size_t IdMaskOffset = 12;
+	static const size_t FcIdOffset = 16;
+	static const size_t FcExtAddrOffset = 20;
+	static const size_t ExtAddrOffset = 21;
+	static const size_t BlockSizeOffset = 22;
+	static const size_t StMinOffset = 23;
+	static const size_t CfTimeoutOffset = 24;
+	static const size_t FltOffset = 26; // 28 bytes
+	static const size_t FltSize = 28;
+	static const size_t FlagsOffset = 54;
+
+	// Bit positions inside the u32 LE flags word (matches the legacy bitfield layout).
+	static const uint32_t FlagEnable = 1u << 0;
+	static const uint32_t FlagId29BitEnable = 1u << 1;
+	static const uint32_t FlagFcId29BitEnable = 1u << 2;
+	static const uint32_t FlagExtAddressEnable = 1u << 3;
+	static const uint32_t FlagFcExtAddressEnable = 1u << 4;
+	static const uint32_t FlagEnableFlowControlTransmit = 1u << 5;
+	static const uint32_t FlagPaddingEnable = 1u << 6;
+	static const uint32_t FlagIsCanFd = 1u << 7;
+	static const uint32_t FlagIsBrsEnabled = 1u << 8;
+
+	// Rebuilds the filter bytes region of mArgumentData based on the current id / id_mask /
+	// id_29_bit_enable / ext_address_enable / extendedAddress state. Preserves the legacy
+	// (pre-existing) wire format bit-for-bit.
+	void rebuildFilterBytes(void);
+
+	void setFlagBit(uint32_t mask, bool enable);
+
+	bool getFlagBit(uint32_t mask) const;
+};
+
+class Iso15765TxSetupMessage : public J2534CommandMessage {
+public:
+	Iso15765TxSetupMessage()
+		: J2534CommandMessage(J2534Command::SetupIso15765TxMessageProperties) {
+		argumentData.resize(36);
+	}
+
+	uint16_t getIdx(void) const;
+	void setIdx(uint16_t idx);
+	uint16_t getCoreMiniId(void) const;
+	void setCoreMiniId(uint16_t coreMiniId);
+	uint32_t getMessageLength(void) const;
+	void setMessageLength(uint32_t messageLength);
+	uint8_t getPadding(void) const;
+	void setPadding(uint8_t padding);
+	uint8_t getTxDl(void) const;
+	void setTxDl(uint8_t txDl);
+	uint32_t getId(void) const;
+	void setId(uint32_t id);
+	uint32_t getFcId(void) const;
+	void setFcId(uint32_t fcId);
+	uint32_t getFcIdMask(void) const;
+	void setFcIdMask(uint32_t fcIdMask);
+	uint8_t getFlowControlExtendedAddress(void) const;
+	void setFlowControlExtendedAddress(uint8_t addr);
+	uint8_t getExtendedAddress(void) const;
+	void setExtendedAddress(uint8_t addr);
+	uint16_t getFsTimeout(void) const;
+	void setFsTimeout(uint16_t timeout);
+	uint16_t getFsWait(void) const;
+	void setFsWait(uint16_t wait);
+	uint32_t getFlags(void) const;
+	void setFlags(uint32_t flags);
+	uint8_t getStMin(void) const;
+	void setStMin(uint8_t stMin);
+	uint8_t getBlockSize(void) const;
+	void setBlockSize(uint8_t blockSize);
+
+	bool getIs29BitEnabled(void) const;
+	void setIs29BitEnabled(bool enable);
+	bool getIsFc29BitEnabled(void) const;
+	void setIsFc29BitEnabled(bool enable);
+	bool getExtAddressEnabled(void) const;
+	void setExtAddressEnabled(bool enable);
+	bool getFcExtAddressEnabled(void) const;
+	void setFcExtAddressEnabled(bool enable);
+	bool getOverrideStMin(void) const;
+	void setOverrideStMin(bool enable);
+	bool getOverrideBlockSize(void) const;
+	void setOverrideBlockSize(bool enable);
+	bool getPaddingEnabled(void) const;
+	void setPaddingEnabled(bool enable);
+	bool getIsCanFd(void) const;
+	void setIsCanFd(bool enable);
+	bool getIsBrsEnabled(void) const;
+	void setIsBrsEnabled(bool enable);
+
+private:
+	// Matches J2534_Iso15TxRequest (#pragma pack(2), little-endian) copied after the
+	// 2-byte J2534 command header, as sent by vspy3 J2534_Transaction.
+	//   [0..1]   J2534 command header (managed by base class)
+	//   [2..3]   idx           (u16 LE)
+	//   [4..5]   iCoreMiniID   (u16 LE)
+	//   [6..9]   messageLength (u32 LE)
+	//   [10]     padding
+	//   [11]     tx_dl
+	//   [12..15] id            (u32 LE)
+	//   [16..19] fc_id         (u32 LE)
+	//   [20..23] fc_id_mask    (u32 LE)
+	//   [24]     flowControlExtendedAddress
+	//   [25]     extendedAddress
+	//   [26..27] fs_timeout    (u16 LE)
+	//   [28..29] fs_wait       (u16 LE)
+	//   [30..33] flags         (u32 LE)
+	//   [34]     stMin
+	//   [35]     blockSize
+
+	static const size_t SetupIdxOffset = 2;
+	static const size_t SetupCoreMiniOffset = 4;
+	static const size_t SetupMsgLenOffset = 6;
+	static const size_t SetupPaddingOffset = 10;
+	static const size_t SetupTxDlOffset = 11;
+	static const size_t SetupIdOffset = 12;
+	static const size_t SetupFcIdOffset = 16;
+	static const size_t SetupFcIdMaskOffset = 20;
+	static const size_t SetupFcExtAddrOffset = 24;
+	static const size_t SetupExtAddrOffset = 25;
+	static const size_t SetupFsTimeoutOffset = 26;
+	static const size_t SetupFsWaitOffset = 28;
+	static const size_t SetupFlagsOffset = 30;
+	static const size_t SetupStMinOffset = 34;
+	static const size_t SetupBlockSizeOffset = 35;
+
+	// Flag bit positions within the 32-bit flags word.
+	static const uint32_t FlagId29BitEnable = 1u << 0;
+	static const uint32_t FlagFcId29BitEnable = 1u << 1;
+	static const uint32_t FlagExtAddressEnable = 1u << 2;
+	static const uint32_t FlagFcExtAddressEnable = 1u << 3;
+	static const uint32_t FlagOverrideStMin = 1u << 4;
+	static const uint32_t FlagOverrideBlockSize = 1u << 5;
+	static const uint32_t FlagPaddingEnable = 1u << 6;
+	static const uint32_t FlagIsCanFd = 1u << 7;
+	static const uint32_t FlagIsBrsEnabled = 1u << 8;
+
+	bool getFlagBit(uint32_t mask) const;
+	void setFlagBit(uint32_t mask, bool enable);
+};
+
+class Iso15765TxDataMessage : public J2534CommandMessage {
+public:
+	static constexpr uint16_t MaxDataLength = 500;
+
+	Iso15765TxDataMessage()
+		: J2534CommandMessage(J2534Command::SetupIso15765TxMessageDataBytes) {
+		argumentData.resize(10);
+	}
+
+	uint16_t getIdx(void) const;
+	void setIdx(uint16_t idx);
+	uint32_t getOffset(void) const;
+	void setOffset(uint32_t offset);
+	uint16_t getLen(void) const;
+	const uint8_t* getData(void) const;
+	void setData(const uint8_t* sourceData, uint16_t len);
+
+private:
+	// Matches J2534_Iso15TxDataRequest (#pragma pack(2), little-endian) after the
+	// 2-byte J2534 command header.
+	//   [0..1]  J2534 command header (managed by base class)
+	//   [2..3]  idx    (u16 LE)
+	//   [4..7]  offset (u32 LE)
+	//   [8..9]  len    (u16 LE)
+	//   [10..]  data
+	static const size_t DataIdxOffset = 2;
+	static const size_t DataOffsetOffset = 4;
+	static const size_t DataLenOffset = 8;
+	static const size_t DataPayloadOffset = 10;
+};
+
+class Iso15765MessageArgs {
+public:
+	struct ArbId {
+		bool Is29Bit;
+		uint32_t Id;
+
+        ArbId(uint32_t id = 0, bool is29Bit = false)
+            : Is29Bit(is29Bit)
+            , Id(id) {
+        }
+	};
+
+	Iso15765MessageArgs(void)
+		: networkId(0)
+        , txIndex(0)
+        , arbId({ false, 0 })
+        , flowControlArbId({ false, 0 })
+        , flowControlArbIdMask(0)
+        , isCanFd(false)
+        , isBrsEnabled(false)
+        , tx_DL(8)
+        , fs_Timeout(0)
+        , fs_WaitTimeout(0)
+        , cf_Timeout(0)
+        , isFlowControlEnabled(false) {
+	}
+
+	uint16_t getNetworkId(void) const { return networkId; }
+	void setNetworkId(uint16_t netId) { networkId = netId; }
+	uint8_t getTxIndex(void) const { return txIndex; }
+	void setTxIndex(uint8_t idx) { txIndex = idx; }
+
+	const ArbId& getArbId(void) const { return arbId; }
+	void setArbId(const ArbId& id) { arbId = id; }
+	const ArbId& getFlowControlArbId(void) const { return flowControlArbId; }
+	void setFlowControlArbId(const ArbId& id) { flowControlArbId = id; }
+	uint32_t getFlowControlArbIdMask(void) const { return flowControlArbIdMask; }
+	void setFlowControlArbIdMask(uint32_t mask) { flowControlArbIdMask = mask; }
+	bool getIsCanFd(void) const { return isCanFd; }
+	void setIsCanFd(bool value) { isCanFd = value; }
+	bool getIsBrsEnabled(void) const { return isBrsEnabled; }
+	void setIsBrsEnabled(bool value) { isBrsEnabled = value; }
+
+	uint8_t getTxDl(void) const { return tx_DL; }
+	void setTxDl(uint8_t txDl) { tx_DL = txDl; }
+	std::optional<uint8_t> getStMin(void) const { return stMin; }
+	void setStMin(std::optional<uint8_t> v) { stMin = v; }
+	std::optional<uint8_t> getBlockSize(void) const { return blockSize; }
+	void setBlockSize(std::optional<uint8_t> b) { blockSize = b; }
+	std::optional<uint8_t> getFlowControlExtendedAddress(void) const { return flowControlExtendedAddress; }
+	void setFlowControlExtendedAddress(std::optional<uint8_t> fcExtAddr) { flowControlExtendedAddress = fcExtAddr; }
+	std::optional<uint8_t> getExtendedAddress(void) const { return extendedAddress; }
+	void setExtendedAddress(std::optional<uint8_t> extAddr) { extendedAddress = extAddr; }
+	std::optional<uint8_t> getPaddingValue(void) const { return paddingValue; }
+	void setPaddingValue(std::optional<uint8_t> v) { paddingValue = v; }
+
+	uint16_t getFsTimeout(void) const { return fs_Timeout; }
+	void setFsTimeout(uint16_t timeout) { fs_Timeout = timeout; }
+	uint16_t getFsWaitTimeout(void) const { return fs_WaitTimeout; }
+	void setFsWaitTimeout(uint16_t timeout) { fs_WaitTimeout = timeout; }
+	uint16_t getCfTimeout(void) const { return cf_Timeout; }
+	void setCfTimeout(uint16_t timeout) { cf_Timeout = timeout; }
+
+	const std::vector<uint8_t>& getData(void) const { return data; }
+	void setData(std::vector<uint8_t>&& d) { data = std::move(d); }
+
+	bool getIsFlowControlEnabled(void) const { return isFlowControlEnabled; }
+	void setIsFlowControlEnabled(bool enabled) { isFlowControlEnabled = enabled; }
+
+protected:
+
+	uint16_t networkId;	// The netid of the message (determines which network to transmit on)
+	uint8_t txIndex;		// identifier for this transmit message
+
+	ArbId arbId;					// arbId of transmitted frames (CAN id to transmit to)
+	ArbId flowControlArbId;		// flow control arb id filter value (response id from receiver)
+	uint32_t flowControlArbIdMask; // The flow control arb id filter mask (response id from receiver)
+	bool isCanFd;
+	bool isBrsEnabled;
+
+	uint8_t tx_DL;										// Maximum CAN(FD) protocol length for transmitted frames (Valid values are 8, 12, 16, 20, 24, 32, 48, 64)
+	std::optional<uint8_t> stMin;						// Overrides the stMin that the receiver reports (Set to J2534's STMIN_TX if <= 0xFF)
+	std::optional<uint8_t> blockSize;					// Overrides the block size that the receiver reports (Set to J2534's BS_TX if <= 0xFF)
+	std::optional<uint8_t> flowControlExtendedAddress; // Expected Extended Address byte of response from receiver
+	std::optional<uint8_t> extendedAddress;			// Extended Address byte of transmitter
+	std::optional<uint8_t> paddingValue;				// The padding byte to use to fill the unused portion of transmitted CAN frames (single frame, first frame, consecutive frame)
+
+	uint16_t fs_Timeout;		// max timeout (ms) for waiting on flow control response (Set this to N_BS_MAX's value if J2534)
+	uint16_t fs_WaitTimeout;	// max timeout (ms) for waiting on flow control response after receiving flow control with flow status set to WAIT (Set this to N_BS_MAX's value if J2534)
+	uint16_t cf_Timeout;		// max timeout (ms) for waiting on consecutive frame (Set this to N_CR_MAX's value in J2534)
+
+	std::vector<uint8_t> data;
+
+	bool isFlowControlEnabled;	// Enables Flow Control frame transmission (Rx message; from neoVI to ECU)
+};
+
+
+}
+
+#endif // __cplusplus
+
+#endif
@@ -34,6 +34,7 @@ struct LINStatusFlags {
 	bool HasUpdatedResponderOnce = false;
 	bool BusRecovered = false;
 	bool BreakOnly = false;
+	bool WakeupRequest = false;
 };

 class LINMessage : public Frame {
@@ -45,7 +46,8 @@ public:
 		LIN_BREAK_ONLY = icsneoc2_lin_msg_type_break_only,
 		LIN_SYNC_ONLY = icsneoc2_lin_msg_type_sync_only,
 		LIN_UPDATE_RESPONDER = icsneoc2_lin_msg_type_update_responder,
-		LIN_ERROR = icsneoc2_lin_msg_type_error
+		LIN_ERROR = icsneoc2_lin_msg_type_error,
+		LIN_WAKEUP_REQUEST = icsneoc2_lin_msg_type_wakeup_request
 	};

 	static void calcChecksum(LINMessage& message);
@@ -49,6 +49,9 @@ public:
 		ClientId = 0x8017,
 		AllMACAddresses = 0x8018,
 		SPIPortKeyOperation = 0x8019,
+		GenericAPIData = 0x8020,
+		GenericAPIStatus = 0x8021,
+		MfgConfig = 0x8022,
 	};

 	Message(Type t) : type(t) {}
@@ -0,0 +1,56 @@
+#ifndef __MFGCONFIGMESSAGE_H_
+#define __MFGCONFIGMESSAGE_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/communication/message/message.h"
+#include "icsneo/communication/message/allmacaddressesmessage.h"
+#include "icsneo/device/chipid.h"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace icsneo {
+
+class MfgConfigMessage : public Message {
+public:
+	struct MfgDate {
+		uint32_t day = 0;
+		uint32_t month = 0;
+		uint32_t year = 0;
+	};
+
+	struct VersionNumber {
+		uint32_t major = 0;
+		uint32_t minor = 0;
+		std::optional<uint32_t> release;
+		std::optional<uint32_t> build;
+	};
+
+	MfgConfigMessage() : Message(Message::Type::MfgConfig) {}
+
+	static std::shared_ptr<MfgConfigMessage> DecodeToMessage(const std::vector<uint8_t>& bytestream);
+	static std::vector<uint8_t> EncodeArgumentsForGet();
+
+	std::optional<uint64_t> serialNumber;
+	std::optional<MfgDate> manufactureDate;
+	std::optional<VersionNumber> hardwareRev;
+	std::optional<uint8_t> productId;
+	std::optional<VersionNumber> bootloaderRev;
+	std::optional<std::string> usbDescriptor;
+	std::vector<MACAddress> macAddresses;
+	std::optional<std::string> pcbSerial;
+	std::optional<ChipID> chipId;
+	std::optional<uint64_t> imei;
+	std::optional<uint8_t> parentProductId;
+	std::optional<VersionNumber> softwareVersionLock;
+};
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __MFGCONFIGMESSAGE_H_
@@ -65,7 +65,7 @@ struct PhyRegisterPacket_t {
 #pragma pack(pop)

 static constexpr size_t MaxPhyEntries = 128u;
-static constexpr size_t MaxBytesPhyEntries = MaxPhyEntries * sizeof(PhyRegisterHeader_t);
+static constexpr size_t MaxBytesPhyEntries = MaxPhyEntries * sizeof(PhyRegisterPacket_t);
 static constexpr uint8_t PhyPacketVersion = 1u;
 static constexpr uint8_t FiveBits = 0x1Fu;

@@ -47,7 +47,8 @@ struct HardwareLINPacket {
 		uint16_t ResponderByteFerr : 1; //Framing error in one of our responder bytes.
 		uint16_t TxAborted : 1;//!< This transmit was aborted.
 		uint16_t BreakOnly : 1;
-		uint16_t : 2;
+		uint16_t WakeupRequest : 1; //!< LIN wakeup pulse.
+		uint16_t : 1;
 	} CoreMiniBitsLIN;

 	uint8_t data[8];
@@ -150,7 +150,6 @@ private:
 	uint8_t maxSecY;
 	uint8_t maxSa;
 	uint8_t maxRule;
-	uint16_t binIndex;
 	DeviceType type;

 	std::vector<MACsecRxRule> rxRule;
@@ -205,7 +204,6 @@ public:
 	void clear();
 	std::vector<uint8_t> serialize() const;
 	operator bool() const;
-	uint16_t getBinIndex() const;
 	DeviceType getType() const;
 	uint8_t getMaxNumRule() const;
 	uint8_t getMaxNumSecY() const;
@@ -91,9 +91,10 @@ struct FlashPhase : public BootloaderPhase {
 	bool authenticate = true;
 	bool encrypt = true;
 	bool checkOutOfDate = true;
+	uint8_t slot = UINT8_MAX;

-	FlashPhase(ChipID chip, BootloaderCommunication comm, bool authenticate = true, bool encrypt = true, bool checkOutOfDate = true) 
-		: chip(chip), comm(comm), authenticate(authenticate), encrypt(encrypt), checkOutOfDate(checkOutOfDate) {}
+	FlashPhase(ChipID chip, BootloaderCommunication comm, bool authenticate = true, bool encrypt = true, bool checkOutOfDate = true, uint8_t slot = UINT8_MAX) 
+		: chip(chip), comm(comm), authenticate(authenticate), encrypt(encrypt), checkOutOfDate(checkOutOfDate), slot(slot) {}
 };

 enum class BootloaderSetting {
@@ -138,7 +138,8 @@ enum class ChipID : icsneoc2_chip_id_t {
 	RADMOONT1S_ZCHIP = icsneoc2_chip_id_radmoont1s_zchip,
 	RADGigastar2_ZYNQ = icsneoc2_chip_id_radgigastar2_zynq,
 	SFPModule_ent11100_MCHIP = icsneoc2_chip_id_sfpmodule_ent11100_mchip,
-	RADGemini_MCHIP = icsneoc2_chip_id_radgemini_mchip,
+	RADArgos_MCHIP = icsneoc2_chip_id_radargos_mchip,
+	SFPModule_ad1101_MCHIP = icsneoc2_chip_id_sfpmodule_ad1101_mchip,
 	Invalid = icsneoc2_chip_id_invalid
 };

@@ -12,6 +12,7 @@
 #include <type_traits>
 #include <optional>
 #include <unordered_map>
+#include <map>
 #include <set>
 #include <unordered_set>
 #include <chrono>
@@ -47,6 +48,8 @@
 #include "icsneo/communication/message/livedatamessage.h"
 #include "icsneo/communication/message/tc10statusmessage.h"
 #include "icsneo/communication/message/spiportkeymessage.h"
+#include "icsneo/communication/message/genericapidatamessage.h"
+#include "icsneo/communication/message/genericapistatusmessage.h"
 #include "icsneo/core/macseccfg.h"
 #include "icsneo/communication/packet/genericbinarystatuspacket.h"
 #include "icsneo/communication/packet/livedatapacket.h"
@@ -61,6 +64,9 @@
 #include "icsneo/communication/message/gptpstatusmessage.h"
 #include "icsneo/communication/message/networkmutexmessage.h"
 #include "icsneo/communication/message/allmacaddressesmessage.h"
+#include "icsneo/communication/message/mfgconfigmessage.h"
+#include "icsneo/communication/message/iso15765message.h"
+#include "icsneo/J2534.h"

 #define ICSNEO_FINDABLE_DEVICE_BASE(className, type) \
 	static constexpr DeviceType::Enum DEVICE_TYPE = type; \
@@ -145,7 +151,8 @@ public:
 		RADMoonT1S = 56,
 		RADGigastar2 = 57,
 		SFPModule_ent11100 = 58,
-		RADGemini = 60,
+		RADArgos = 60,
+		SFPModule_ad1101 = 61,
 	};

 	virtual ProductID getProductID() const = 0;
@@ -343,6 +350,7 @@ public:
 	virtual Network getNetworkByNumber(Network::Type, size_t) const;

 	std::shared_ptr<HardwareInfo> getHardwareInfo(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));
+	std::shared_ptr<MfgConfigMessage> getMfgConfig();


 	/**
@@ -891,7 +899,8 @@ public:
 	std::optional<GPTPStatus> getGPTPStatus(std::chrono::milliseconds timeout = std::chrono::milliseconds(100));

 	/* MACsec support */
-	virtual bool writeMACsecConfig(const MACsecConfig& cfg);
+	std::vector<Network> getMACsecNetworks() const;
+	bool writeMACsecConfig(const MACsecConfig& cfg, Network::NetID network);

 	std::shared_ptr<DeviceExtension> getExtension(const std::string& name) const;
 	
@@ -905,7 +914,19 @@ public:
 	void stopHeartbeat();
 	void restartHeartbeat();

+	bool iso15765Enable(const Network& network);
+	bool iso15765DisableAll(void);
+	bool iso15765TransmitMessage(const Network& network, const Iso15765MessageArgs& msg, const std::chrono::milliseconds& timeout);
+	bool iso15765SetupRxFlowControl(const Network& network, const Iso15765MessageArgs& msg);
+
 protected:
+	using MACsecNetworkMap = std::map<Network::NetID, uint16_t>;
+
+	virtual const MACsecNetworkMap& getMACsecNetworkMap() const {
+		static const MACsecNetworkMap networks;
+		return networks;
+	}
+
 	bool online = false;
 	int messagePollingCallbackID = 0;
 	int internalHandlerCallbackID = 0;
@@ -1173,6 +1194,23 @@ private:

 	bool enableNetworkCommunication(bool enable, uint32_t timeout = 0);

+	bool J2534_Transaction(const Network& network, J2534CommandMessage&& msg, const std::chrono::milliseconds& timeout);
+	bool J2534_ClearRxFilters(const Network& network);
+	bool J2534_SetupCanRxFilter(const Network& network, const J2534_RxCanFilter& rxCanFilter);
+	bool J2534_EnableFiltering(const Network& network, const bool enable);
+
+	bool J2534_EnableIso15765(const Network& network, const bool enable);
+	bool J2534_ClearRxFilter(const Network& network, unsigned int iIndex);
+	bool J2534_EnableFirmwareUsbPassFilters(const Network& network, const bool enable);
+
+	struct NetworkHash {
+		size_t operator()(const Network& x) const {
+			return (size_t)x.getNetID();
+		}
+	};
+	std::unordered_map<Network, bool, NetworkHash> iso15765FirmwareEnabled;
+
+
 	// Keeponline (keepalive for online)
 	std::unique_ptr<Periodic> keeponline;
 	std::unique_ptr<Heartbeat> heartbeat;
@@ -62,7 +62,7 @@ public:
 		RADGigastar2 = icsneoc2_devicetype_rad_gigastar2,
 		FIRE3_T1S_LIN = icsneoc2_devicetype_fire3_t1s_lin,
 		FIRE3_T1S_SENT = icsneoc2_devicetype_fire3_t1s_sent,
-		RADGemini = icsneoc2_devicetype_rad_gemini,
+		RADArgos = icsneoc2_devicetype_rad_argos,
 		RED = icsneoc2_devicetype_red,
 		ECU = icsneoc2_devicetype_ecu,
 		IEVB = icsneoc2_devicetype_ievb,
@@ -153,8 +153,8 @@ public:
 				return "RAD-EpsilonXL";
 			case RADMoon3:
 				return "RAD-Moon 3";
-			case RADGemini:
-				return "RAD-Gemini";
+			case RADArgos:
+				return "RAD-Argos";
 			case RADComet2:
 				return "RAD-Comet 2";
 			case RED:
@@ -281,7 +281,7 @@ private:
 #define ICSNEO_DEVICETYPE_RADGIGASTAR2 ((devicetype_t)icsneoc2_devicetype_rad_gigastar2)
 #define ICSNEO_DEVICETYPE_FIRE3_T1S_LIN ((devicetype_t)icsneoc2_devicetype_fire3_t1s_lin)
 #define ICSNEO_DEVICETYPE_FIRE3_T1S_SENT ((devicetype_t)icsneoc2_devicetype_fire3_t1s_sent)
-#define ICSNEO_DEVICETYPE_RADGEMINI ((devicetype_t)icsneoc2_devicetype_rad_gemini)
+#define ICSNEO_DEVICETYPE_RADARGOS ((devicetype_t)icsneoc2_devicetype_rad_argos)
 #define ICSNEO_DEVICETYPE_RED ((devicetype_t)icsneoc2_devicetype_red)
 #define ICSNEO_DEVICETYPE_ECU ((devicetype_t)icsneoc2_devicetype_ecu)
 #define ICSNEO_DEVICETYPE_IEVB ((devicetype_t)icsneoc2_devicetype_ievb)
@@ -0,0 +1,42 @@
+#ifndef __BOOTLOADER_API_H_
+#define __BOOTLOADER_API_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/chip.h"
+#include "icsneo/device/extensions/bootloader/parser/fwrepo.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+#include "icsneo/device/device.h"
+
+#include <string>
+#include <optional>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+using Logger = icsneo::Device::OpenStatusHandler;
+
+bool requiresUpdate(icsneo::Device& device, const FWRepo& fw);
+bool update(
+	icsneo::Device& device,
+	const FWRepo& fw,
+	Logger logger = [](icsneo::Device::OpenStatusType, const std::string&, std::optional<double>) { return icsneo::Device::OpenDirective::Continue; },
+	bool alreadyInBootloader = false,
+	bool forceFlash = false
+);
+
+bool enterBootloader(icsneo::Device& device);
+bool exitBootloader(icsneo::Device& device, Logger logger, bool updatedChips);
+bool verifyConnection(icsneo::Device& device, Logger logger);
+
+bool isSFPChip(const icsneo::Bootloader::Chip& chip);
+bool isSFPIEF(const icsneo::Bootloader::IEF& ief);
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_API_H_
@@ -0,0 +1,48 @@
+#ifndef __BOOTLOADER_BYTESVIEW_H_
+#define __BOOTLOADER_BYTESVIEW_H_
+
+#ifdef __cplusplus
+
+#include <cstdint>
+#include <cstddef>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class BytesView {
+private:
+	const uint8_t* ptr = nullptr;
+	size_t length = 0;
+public:
+	BytesView() = default;
+	BytesView(const uint8_t* buf, size_t size) : ptr(buf), length(size) {}
+
+	const uint8_t* begin() const {
+		return ptr;
+	}
+
+	const uint8_t* end() const {
+		return ptr + length;
+	}
+
+	const uint8_t* data() const {
+		return ptr;
+	}
+
+	size_t size() const {
+		return length;
+	}
+
+	const uint8_t& operator[](size_t index) const {
+		return ptr[index];
+	}
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_BYTESVIEW_H_
@@ -0,0 +1,35 @@
+#ifndef __BOOTLOADER_CHIP_H_
+#define __BOOTLOADER_CHIP_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/chipinfo.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+struct Chip {
+	uint8_t expansionSlot = 0;
+	ChipInfo info;
+
+	Chip(const ChipInfo& info) : info(info) {}
+
+	ChipID getID() const { return info.id; }
+	std::string getName() const { return info.name ? info.name : ""; }
+	std::string getIEFName() const { return info.iefName ? info.iefName : ""; }
+	const std::vector<const char*>& getMultiIEFName() const { return info.iefSegments; }
+	FirmwareType getFirmwareType() const { return info.fwType; }
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_CHIP_H_
@@ -0,0 +1,92 @@
+#ifndef __BOOTLOADER_APPLICATION_H_
+#define __BOOTLOADER_APPLICATION_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/communication/communication.h"
+#include "icsneo/device/extensions/bootloader/parser/ief.h"
+
+#include <chrono>
+#include <cstdint>
+#include <functional>
+#include <vector>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+/**
+ * The software update protocol used with the application
+ * on RED devices, does not require entering the bootloader.
+ */
+class Application : public Communication {
+public:
+	Application(icsneo::Device& dev, const ChipInfo& chip, bool doAuthChecks = false, bool encrypt = false)
+		: Communication(dev), targetChip(chip), doAuthChecks(doAuthChecks), encrypted(encrypt) {}
+
+	void setExpansionSlot(uint8_t slot) { targetChip.expansionSlot = slot; }
+
+	bool enterApplication() override;
+	bool hasFinalizationStep() const override {
+		return true;
+	}
+	bool finalize() override;
+	bool flash(const FWRepo& repo, const icsneo::Device::OpenStatusHandler& handler) override;
+
+	bool open() override {
+		return true;
+	}
+
+	bool close() override {
+		return true;
+	}
+
+	bool authenticate();
+	bool sendSoftware(const std::vector<uint8_t>& bin, const icsneo::Device::OpenStatusHandler& handler);
+	bool sendSoftware(const std::vector<IEF::Sector>& sectors, uint32_t blockSize, const icsneo::Device::OpenStatusHandler& handler);
+	bool validateFirmware(const DeviceAppVersion& chipSrcVer);
+	bool validateComponent();
+
+private:
+	// Sub-commands of ExtendedCommand::SoftwareUpdate
+	enum class Update : uint8_t {
+		Write = 0,
+		Erase = 1,
+		GetProgress = 2,
+		CheckVersion = 5,
+		ValidateComponent = 6,
+		Finalize = 7,
+		CheckComponentVersion = 9
+	};
+
+	// Prefixes the arguments of every ExtendedCommand::SoftwareUpdate request, and is echoed back with progress
+#pragma pack(push, 2)
+	struct SoftwareUpdateCommandHeader {
+		uint32_t componentIdentifier; // unique id for the software component - analogous to what used to be "chip id"
+		Update commandType;
+		uint8_t expansionSlot;
+		uint32_t offset;
+		uint32_t commandSizeOrProgress; // size
+	};
+#pragma pack(pop)
+
+	Chip targetChip;
+	const bool doAuthChecks;
+	const bool encrypted;
+
+	using StatusHandler = std::function<void(double progress)>;
+	bool sendCommand(Update command, const StatusHandler& handler, uint32_t offset = 0,
+		const std::vector<uint8_t>& args = {}, std::chrono::milliseconds timeout = std::chrono::milliseconds(3000)) {
+		return sendCommand(command, offset, static_cast<uint32_t>(args.size()), handler, timeout, args);
+	}
+	bool sendCommand(Update command, uint32_t offset, uint32_t length, const StatusHandler& handler,
+		std::chrono::milliseconds timeout = std::chrono::milliseconds(3000), std::vector<uint8_t> args = {});
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_APPLICATION_H_
@@ -0,0 +1,37 @@
+#ifndef __BOOTLOADER_BOOTLOADERVERSION_H_
+#define __BOOTLOADER_BOOTLOADERVERSION_H_
+
+#ifdef __cplusplus
+
+#include <cstdint>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+#pragma pack(push, 1)
+struct BootloaderVersionResponse {
+	uint8_t blMajor;
+	uint8_t blMinor;
+	uint16_t reserved1;
+	uint8_t hwMajor;
+	uint8_t hwMinor;
+	uint8_t hwPlatform;
+	uint16_t reserved2;
+	uint8_t manDay;
+	uint8_t manMonth;
+	uint16_t manYear;
+	uint8_t serialNum[8];
+	uint8_t hwId;
+	uint8_t reserved3;
+	uint8_t zynqId;
+};
+#pragma pack(pop)
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_BOOTLOADERVERSION_H_
@@ -0,0 +1,49 @@
+#ifndef __BOOTLOADER_COMMUNICATION_H_
+#define __BOOTLOADER_COMMUNICATION_H_
+
+#ifdef __cplusplus
+
+#include "icsneo/device/extensions/bootloader/chip.h"
+#include "icsneo/device/device.h"
+
+#include <cstdint>
+
+namespace icsneo {
+
+namespace Bootloader {
+
+class FWRepo;
+
+/**
+ * A bootloader protocol for one chip.
+ *
+ * Authentication is a challenge/response handled by libicsbl: icsbl_generate_seed_v1() derives
+ * a challenge (seed.a) and the reply the device must send back (seed.b) from the serial number.
+ * Firmware is encrypted for a specific device with icsbl_encrypt_v1(), also keyed by the serial number.
+ */
+class Communication {
+public:
+	Communication(icsneo::Device& dev) : device(dev) {}
+	virtual ~Communication() = default;
+
+	virtual bool enterApplication() = 0;
+	virtual bool hasFinalizationStep() const = 0;
+	virtual bool finalize() = 0;
+	virtual bool flash(const FWRepo& repo, const icsneo::Device::OpenStatusHandler& handler) = 0;
+
+	virtual bool open() = 0;
+	virtual bool close() = 0;
+
+protected:
+	static uint32_t readLE32(const uint8_t* data);
+	static void writeLE32(uint8_t* data, uint32_t val);
+	icsneo::Device& device;
+};
+
+} // namespace Bootloader
+
+} // namespace icsneo
+
+#endif // __cplusplus
+
+#endif // __BOOTLOADER_COMMUNICATION_H_
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kyle Schwarz	dffb0bcefb	CI: Deploy: Also push git history	2026-11-01 18:04:33 -05:00
Kyle Schwarz	f4fe69f992	CI: Adjust twine upload args	2026-11-01 11:28:02 -05:00
Kyle Schwarz	7ff14ae86d	CI: Add tag upload & deploy	2026-10-31 11:24:38 -04:00
Kyle Schwarz	5c61a3b3c1	All: Remove deprecated Drivers	2026-10-29 12:33:38 -04:00
Max BrombachandKyle Schwarz	320fec74bd	Device: Add SFP-AD1101	2026-10-23 12:42:08 -04:00
Bryant JonesandKyle Schwarz	fd8f7b328f	Message: LIN: Fix checksum	2026-10-21 19:46:48 -04:00
Thomas StoddardandKyle Schwarz	6ac041cadc	Add bootloader extension	2026-10-21 19:22:50 -04:00
Thomas StoddardandKyle Schwarz	4db27aa187	Bindings: Python: Add ISO-TP	2026-10-20 21:15:12 -04:00
Thomas StoddardandKyle Schwarz	1d3039775d	Device: Refactor T1S settings	2026-10-06 15:16:33 -04:00
Max BrombachandKyle Schwarz	fb241dc5cd	EventManager: Fix potential ABBA deadlock if callback contains locks	2026-10-02 15:38:59 -04:00
Max BrombachandKyle Schwarz	3932b54947	Device: RAD-Gigastar and RAD-Gigastar 2: Fix bootloader pipeline	2026-10-02 14:28:40 -04:00
Nicholas ZamoraandKyle Schwarz	f4836f279f	Device: RAD-Gemini to RAD-Argos	2026-10-02 13:53:55 -04:00
Thomas StoddardandKyle Schwarz	7ef57e6737	Device: Improve TC10 message filtering	2026-09-30 13:07:13 -04:00
David RebbeandKyle Schwarz	4c0781190e	Message: EthPhyMessage: Add Status	2026-09-29 15:01:36 -04:00
Kyle Schwarz	0a67c9cf5d	Platform: Servd: Add address configuration	2026-09-28 12:02:40 -04:00
David RebbeandKyle Schwarz	f310938684	Message: Validate PHY register batches	2026-09-24 20:13:48 -04:00
Thomas StoddardandKyle Schwarz	f0b1341cdf	Device: Write MACsec configs by network ID	2026-09-24 19:49:23 -04:00
Max BrombachandKyle Schwarz	b54bf80c40	EventManager: Always run callbacks on event	2026-09-24 13:26:13 -04:00
Bryant JonesandKyle Schwarz	0164cef376	NeoVIFIRE3FlexRay: Fix incorrect FlexRay controllers	2026-09-23 16:46:37 -04:00
Thomas StoddardandKyle Schwarz	8cd907250d	Bindings: Python: Add Main51MessageFilter support	2026-09-21 13:39:27 -04:00
David RebbeandKyle Schwarz	bb892bfd9b	Bindings: Python: Support multi-config generators for stubgen	2026-09-17 11:27:23 -04:00
William SkellengerandKyle Schwarz	8801e949da	CI: Enable interruptible	2026-09-15 17:37:51 -04:00
Samuel BejkoandKyle Schwarz	d95a17b360	LIN: Add wakeup request	2026-09-14 17:13:23 -04:00
Kurt WachowskiandKyle Schwarz	3a6501d116	Device: Add ISO-15765 hardware acceleration	2026-09-10 20:52:01 -04:00
Bryant JonesandKyle Schwarz	34875129ee	Gigastar: Add FLEXRAY_01 network	2026-09-10 14:18:24 -04:00
Jonathan SchwartzandKyle Schwarz	236c6ad089	Device: Add manufacturing config message	2026-09-10 12:56:55 -04:00
Max Brombach	cf58f819cb	Platform: Darwin: Replace deprecate kIOMasterPortDefault with kIOMainPortDefault	2026-08-27 18:33:01 +00:00
Kyle Schwarz	07e4eca14a	Heartbeat: Include DeviceStatus	2026-08-17 15:34:16 -04:00
Max BrombachandKyle Schwarz	936566170f	Communication: Add GenericAPIDataMessage and GenericAPIStatusMessage types	2026-08-17 10:30:35 -04:00