FW check for recovery mode

src/ds5/ds5-device.cpp

@@ -330,13 +330,16 @@ namespace librealsense
 
     bool ds5_device::check_fw_compatibility(const std::vector<uint8_t>& image) const
     {
-        std::string fw_version = extract_firmware_version_string((const void*)image.data(), image.size());
+        std::string fw_version = extract_firmware_version_string(image);
 
         auto it = ds::device_to_fw_min_version.find(_pid);
         if (it == ds::device_to_fw_min_version.end())
-            throw std::runtime_error("Minimum firmware version has not been defined for this device!");
+            throw librealsense::invalid_value_exception(to_string() << "Min and Max firmware versions have not been defined for this device: " << std::hex << _pid);
+        bool result = (firmware_version(fw_version) >= firmware_version(it->second));
+        if (!result)
+            LOG_ERROR(fw_version);
 
-        return (firmware_version(fw_version) >= firmware_version(it->second));
+        return result;
     }
 
     class ds5_depth_sensor : public synthetic_sensor, public video_sensor_interface, public depth_stereo_sensor, public roi_sensor_base

src/ds5/ds5-fw-update-device.cpp

@@ -19,6 +19,19 @@ namespace librealsense
         update_device::update(fw_image, fw_image_size, callback);
     }
 
+    bool ds_update_device::check_fw_compatibility(const std::vector<uint8_t>& image) const
+    {
+        std::string fw_version = extract_firmware_version_string(image);
+        auto it = ds::device_to_fw_min_version.find(_usb_device->get_info().pid);
+        if (it == ds::device_to_fw_min_version.end())
+            throw librealsense::invalid_value_exception(to_string() << "Min and Max firmware versions have not been defined for this device: " << std::hex << _pid);
+        bool result = (firmware_version(fw_version) >= firmware_version(it->second));
+        if (!result)
+            LOG_ERROR(fw_version);
+
+        return result;
+    }
+
     std::string ds_update_device::parse_serial_number(const std::vector<uint8_t>& buffer) const
     {
         if (buffer.size() != sizeof(serial_number_data))

src/ds5/ds5-fw-update-device.h

@@ -14,6 +14,7 @@ namespace librealsense
         virtual ~ds_update_device() = default;
 
         void update(const void* fw_image, int fw_image_size, update_progress_callback_ptr = nullptr) const override;
+        virtual bool check_fw_compatibility(const std::vector<uint8_t>& image) const override;
 
     protected:
         virtual const std::string& get_name() const override { return _name; }

src/fw-update/fw-update-device-interface.h

@@ -9,38 +9,35 @@
 
 namespace librealsense
 {
-    class updatable
+    class firmware_check_interface
     {
     public:
-        virtual void enter_update_state() const = 0;
-        virtual std::vector<uint8_t> backup_flash(update_progress_callback_ptr callback) = 0;
-        virtual void update_flash(const std::vector<uint8_t>& image, update_progress_callback_ptr callback, int update_mode) = 0;
         virtual bool check_fw_compatibility(const std::vector<uint8_t>& image) const = 0;
-        std::string extract_firmware_version_string(const void* fw_image, size_t fw_image_size) const
+        static std::string extract_firmware_version_string(const std::vector<uint8_t>& fw_image)
         {
-            if (!fw_image)
-                throw std::runtime_error("Firmware binary image might be corrupted - null pointer");
-
             auto version_offset = offsetof(platform::dfu_header, bcdDevice);
+            if (fw_image.size() < (version_offset + sizeof(size_t)))
+                throw std::runtime_error("Firmware binary image might be corrupted - size is only: " + fw_image.size());
 
-            if (fw_image_size < (version_offset + sizeof(size_t)))
-                throw std::runtime_error("Firmware binary image might be corrupted - size is only: " + fw_image_size);
-
-            uint32_t version{};
-
-            memcpy(reinterpret_cast<char*>(&version), reinterpret_cast<const char*>(fw_image) +
-                version_offset, sizeof(version));
-
-            uint8_t major = (version & 0xFF000000) >> 24;
-            uint8_t minor = (version & 0x00FF0000) >> 16;
-            uint8_t patch = (version & 0x0000FF00) >> 8;
-            uint8_t build = version & 0x000000FF;
+            auto version = fw_image.data() + version_offset;
+            uint8_t major = *(version + 3);
+            uint8_t minor = *(version + 2);
+            uint8_t patch = *(version + 1);
+            uint8_t build = *(version);
 
             return std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch) + "." + std::to_string(build);
         }
     };
 
-    class update_device_interface : public device_interface
+    class updatable : public firmware_check_interface
+    {
+    public:
+        virtual void enter_update_state() const = 0;
+        virtual std::vector<uint8_t> backup_flash(update_progress_callback_ptr callback) = 0;
+        virtual void update_flash(const std::vector<uint8_t>& image, update_progress_callback_ptr callback, int update_mode) = 0;
+    };
+
+    class update_device_interface : public device_interface, public firmware_check_interface 
     {
     public:
         virtual void update(const void* fw_image, int fw_image_size, update_progress_callback_ptr = nullptr) const = 0;

src/fw-update/fw-update-device.cpp

@@ -138,6 +138,11 @@ namespace librealsense
 
     void update_device::update(const void* fw_image, int fw_image_size, update_progress_callback_ptr update_progress_callback) const
     {
+        // checking fw compatibility (covering the case of recovery device with wrong product line fw )
+        std::vector<uint8_t> buffer((uint8_t*)fw_image, (uint8_t*)fw_image + fw_image_size);
+        if (!check_fw_compatibility(buffer))
+            throw librealsense::invalid_value_exception("Device: " + get_serial_number() + " failed to update firmware\nImage is unsupported for this device or corrupted");
+
         auto messenger = _usb_device->open(FW_UPDATE_INTERFACE_NUMBER);
 
         const size_t transfer_size = 1024;

src/ivcam/sr300-fw-update-device.cpp

@@ -2,10 +2,12 @@
 // Copyright(c) 2019 Intel Corporation. All Rights Reserved.
 
 #include "sr300-fw-update-device.h"
+#include "sr300.h"
 #include "ivcam-private.h"
 #include <chrono>
 #include <thread>
 
+
 namespace librealsense
 {
     sr300_update_device::sr300_update_device(std::shared_ptr<context> ctx, bool register_device_notifications, std::shared_ptr<platform::usb_device> usb_device)
@@ -22,6 +24,27 @@ namespace librealsense
         std::this_thread::sleep_for(std::chrono::seconds(10));
     }
 
+    bool sr300_update_device::check_fw_compatibility(const std::vector<uint8_t>& image) const
+    {
+        std::string fw_version = extract_firmware_version_string(image);
+        auto min_max_fw_it = device_to_fw_min_max_version.find(_usb_device->get_info().pid);
+        if (min_max_fw_it == device_to_fw_min_max_version.end())
+            throw librealsense::invalid_value_exception(to_string() << "Min and Max firmware versions have not been defined for this device: " << std::hex << _pid);
+
+        // check FW size as well, because on SR3xx it is not enough to use heuristic based on FW version
+        if (image.size() != signed_sr300_size)
+            throw librealsense::invalid_value_exception(to_string() << "Unsupported firmware binary image provided - " << image.size() << " bytes");
+
+        // advanced SR3XX devices do not fit the "old" fw versions and 
+        // legacy SR3XX devices do not fit the "new" fw versions
+        bool result = (firmware_version(fw_version) >= firmware_version(min_max_fw_it->second.first)) &&
+            (firmware_version(fw_version) <= firmware_version(min_max_fw_it->second.second));
+        if (!result)
+            LOG_ERROR(fw_version);
+
+        return result;
+    }
+
     std::string sr300_update_device::parse_serial_number(const std::vector<uint8_t>& buffer) const
     {
         if (buffer.size() != sizeof(serial_number_data))

src/ivcam/sr300-fw-update-device.h

@@ -13,6 +13,7 @@ namespace librealsense
         sr300_update_device(std::shared_ptr<context> ctx, bool register_device_notifications, std::shared_ptr<platform::usb_device> usb_device);
         virtual ~sr300_update_device() = default;
         virtual void update(const void* fw_image, int fw_image_size, update_progress_callback_ptr = nullptr) const override;
+        virtual bool check_fw_compatibility(const std::vector<uint8_t>& image) const override;
 
     protected:
         virtual const std::string& get_name() const override { return _name; }

src/ivcam/sr300.cpp

@@ -584,16 +584,20 @@ namespace librealsense
 
     bool sr3xx_camera::check_fw_compatibility(const std::vector<uint8_t>& image) const
     {
-        std::string fw_version = extract_firmware_version_string((const void*)image.data(), image.size());
+        std::string fw_version = extract_firmware_version_string(image);
 
         auto min_max_fw_it = device_to_fw_min_max_version.find(_pid);
         if (min_max_fw_it == device_to_fw_min_max_version.end())
-            throw std::runtime_error("Min and Max firmware versions have not been defined for this device!");
+            throw librealsense::invalid_value_exception(to_string() << "Min and Max firmware versions have not been defined for this device: " << std::hex << _pid);
 
         // advanced SR3XX devices do not fit the "old" fw versions and 
         // legacy SR3XX devices do not fit the "new" fw versions
-        return (firmware_version(fw_version) >= firmware_version(min_max_fw_it->second.first)) &&
+        bool result = (firmware_version(fw_version) >= firmware_version(min_max_fw_it->second.first)) &&
             (firmware_version(fw_version) <= firmware_version(min_max_fw_it->second.second));
+        if (!result)
+            LOG_ERROR(fw_version);
+
+        return result;
     }
 
     void sr3xx_camera::create_snapshot(std::shared_ptr<debug_interface>& snapshot) const

src/ivcam/sr300.h

@@ -38,10 +38,10 @@ namespace librealsense
 
     static std::map<uint16_t, std::pair<std::string, std::string>> device_to_fw_min_max_version = {
             { SR300_PID,        {"3.21.0.0", "3.26.3.0"}},
-            { SR300v2_PID,      {"3.27.0.0", "99.99.99.99"}},
-            { SR306_PID,        {"3.28.3.0", "99.99.99.99"}},
-            { SR306_PID_DBG,    {"3.28.3.0", "99.99.99.99"}},
-            { SR300_RECOVERY,   {"3.21.0.0", "99.99.99.99"}}
+            { SR300v2_PID,      {"3.27.0.0", "4.99.99.99"}},
+            { SR306_PID,        {"3.28.3.0", "4.99.99.99"}},
+            { SR306_PID_DBG,    {"3.28.3.0", "4.99.99.99"}},
+            { SR300_RECOVERY,   {"3.21.0.0", "4.99.99.99"}}
     };
 
     class sr300_timestamp_reader : public frame_timestamp_reader

src/l500/l500-device.cpp

@@ -692,15 +692,19 @@ namespace librealsense
 
     bool l500_device::check_fw_compatibility(const std::vector<uint8_t>& image) const
     {
-        std::string fw_version = extract_firmware_version_string((const void*)image.data(), image.size());
+        std::string fw_version = extract_firmware_version_string(image);
 
         auto min_max_fw_it = ivcam2::device_to_fw_min_max_version.find(_pid);
         if (min_max_fw_it == ivcam2::device_to_fw_min_max_version.end())
-            throw std::runtime_error("Min and Max firmware versions have not been defined for this device!");
+            throw librealsense::invalid_value_exception(to_string() << "Min and Max firmware versions have not been defined for this device: " << std::hex << _pid);
 
         // Limit L515 to FW versions within the 1.5.1.3-1.99.99.99 range to differenciate from the other products
-        return (firmware_version(fw_version) >= firmware_version(min_max_fw_it->second.first)) &&
-               (firmware_version(fw_version) <= firmware_version(min_max_fw_it->second.second));
+        bool result = (firmware_version(fw_version) >= firmware_version(min_max_fw_it->second.first)) &&
+            (firmware_version(fw_version) <= firmware_version(min_max_fw_it->second.second));
+        if (!result)
+            LOG_ERROR(fw_version);
+
+        return result;
 
     }
 

src/l500/l500-fw-update-device.cpp

@@ -4,6 +4,7 @@
 #include "l500-fw-update-device.h"
 #include "l500-private.h"
 
+
 namespace librealsense
 {
     l500_update_device::l500_update_device(std::shared_ptr<context> ctx, bool register_device_notifications, std::shared_ptr<platform::usb_device> usb_device)
@@ -19,6 +20,22 @@ namespace librealsense
         update_device::update(fw_image, fw_image_size, callback);
     }
 
+    bool l500_update_device::check_fw_compatibility(const std::vector<uint8_t>& image) const
+    {
+        std::string fw_version = extract_firmware_version_string(image);
+        auto min_max_fw_it = ivcam2::device_to_fw_min_max_version.find(_usb_device->get_info().pid);
+        if (min_max_fw_it == ivcam2::device_to_fw_min_max_version.end())
+            throw librealsense::invalid_value_exception(to_string() << "Min and Max firmware versions have not been defined for this device: " << std::hex << _pid);
+
+        // Limit L515 to FW versions within the 1.5.1.3-1.99.99.99 range to differenciate from the other products
+        bool result = (firmware_version(fw_version) >= firmware_version(min_max_fw_it->second.first)) &&
+            (firmware_version(fw_version) <= firmware_version(min_max_fw_it->second.second));
+        if (!result)
+            LOG_ERROR(fw_version);
+
+        return result;
+    }
+
     std::string l500_update_device::parse_serial_number(const std::vector<uint8_t>& buffer) const
     {
         // Note that we are using a specific serial_number_data struct then the generic one.

src/l500/l500-fw-update-device.h

@@ -25,6 +25,7 @@ namespace librealsense
         virtual ~l500_update_device() = default;
 
         void update(const void* fw_image, int fw_image_size, update_progress_callback_ptr = nullptr) const override;
+        virtual bool check_fw_compatibility(const std::vector<uint8_t>& image) const override;
 
     protected:
         virtual const std::string& get_name() const override { return _name; }