Fix compiler warning (#1827 )

* Fix compiler warning * Fix compiler warning * Friggin C-lang
Call the flasher app when flashing from serial (#1825 )
2026-09-14 18:43:01 +00:00 · 2024-01-29 18:07:32 -06:00 · 2024-01-29 20:52:35 +01:00 · 2024-01-29 00:54:13 +08:00 · 2024-01-28 10:02:11 -06:00 · 2024-01-27 19:33:08 +01:00
26 changed files with 340 additions and 114 deletions
@@ -101,6 +101,8 @@ APRSRxView::APRSRxView(NavigationView& nav, Rect parent_rect)
            field_frequency.set_value(145175000);
        } else if (i == 3) {
            field_frequency.set_value(144575000);
+        } else if (i == 4) {
+            field_frequency.set_value(145825000);
        }
    };

@@ -221,7 +221,8 @@ class APRSRxView : public View {
        {{"NA ", 0},
         {"EUR", 1},
         {"AUS", 2},
-         {"NZ ", 3}}};
+         {"NZ ", 3},
+         {"ISS", 4}}};

    RxFrequencyField field_frequency{
        {3 * 8, 0 * 16},
@@ -21,6 +21,7 @@
 */

 #include "ui_flash_utility.hpp"
+#include "ui_styles.hpp"
 #include "portapack_shared_memory.hpp"

 namespace ui {
@@ -30,6 +31,30 @@ static const char16_t* firmware_folder = u"/FIRMWARE";
 Thread* FlashUtilityView::thread{nullptr};
 static constexpr size_t max_filename_length = 26;

+bool valid_firmware_file(std::filesystem::path::string_type path) {
+    File firmware_file;
+    uint32_t read_buffer[128];
+    uint32_t checksum{(uint32_t)~FLASH_EXPECTED_CHECKSUM};  // initializing to invalid checksum in case file can't be read
+
+    // test read of the whole file just to validate checksum (baseband flash code will re-read when flashing)
+    auto result = firmware_file.open(path.c_str());
+    if (!result.is_valid()) {
+        checksum = 0;
+        for (uint32_t i = 0; i < FLASH_ROM_SIZE / sizeof(read_buffer); i++) {
+            auto readResult = firmware_file.read(&read_buffer, sizeof(read_buffer));
+
+            // if file is smaller than 1MB, assume it's a downgrade to an old FW version and ignore the checksum
+            if ((!readResult) || (readResult.value() != sizeof(read_buffer))) {
+                checksum = FLASH_EXPECTED_CHECKSUM;
+                break;
+            }
+
+            checksum += simple_checksum((uint32_t)read_buffer, sizeof(read_buffer));
+        }
+    }
+    return (checksum == FLASH_EXPECTED_CHECKSUM);
+}
+
 FlashUtilityView::FlashUtilityView(NavigationView& nav)
    : nav_(nav) {
    add_children({&labels,
@@ -85,9 +110,8 @@ bool FlashUtilityView::endsWith(const std::u16string& str, const std::u16string&
    }
 }

-std::filesystem::path FlashUtilityView::extract_tar(std::filesystem::path::string_type path) {
+std::filesystem::path FlashUtilityView::extract_tar(std::filesystem::path::string_type path, ui::Painter& painter) {
    //
-    ui::Painter painter;
    painter.fill_rectangle(
        {0, 0, portapack::display.width(), portapack::display.height()},
        ui::Color::black());
@@ -98,22 +122,22 @@ std::filesystem::path FlashUtilityView::extract_tar(std::filesystem::path::strin
        painter.fill_rectangle({0, 50, portapack::display.width(), 90}, ui::Color::black());
        painter.draw_string({0, 60}, this->nav_.style(), fileName);
    });
-    if (res.string().empty()) {
-        ui::Painter painter;
-        painter.fill_rectangle({0, 50, portapack::display.width(), 90}, ui::Color::black());
-        painter.draw_string({0, 60}, this->nav_.style(), "BAD TAR FILE");
-        chThdSleepMilliseconds(5000);
-    }
    return res;
 }

-void FlashUtilityView::flash_firmware(std::filesystem::path::string_type path) {
+bool FlashUtilityView::flash_firmware(std::filesystem::path::string_type path) {
+    ui::Painter painter;
    if (endsWith(path, u".tar")) {
        // extract, then update
-        path = extract_tar(u'/' + path).native();
-        if (path.empty()) return;
+        path = extract_tar(u'/' + path, painter).native();
+    }
+
+    if (path.empty() || !valid_firmware_file(path.c_str())) {
+        painter.fill_rectangle({0, 50, portapack::display.width(), 90}, ui::Color::black());
+        painter.draw_string({0, 60}, Styles::red, "BAD FIRMWARE FILE");
+        chThdSleepMilliseconds(5000);
+        return false;
    }
-    ui::Painter painter;
    painter.fill_rectangle(
        {0, 0, portapack::display.width(), portapack::display.height()},
        ui::Color::black());
@@ -126,6 +150,7 @@ void FlashUtilityView::flash_firmware(std::filesystem::path::string_type path) {
    std::memcpy(&shared_memory.bb_data.data[0], path.c_str(), (path.length() + 1) * 2);
    m4_init(portapack::spi_flash::image_tag_flash_utility, portapack::memory::map::m4_code, false);
    m0_halt();
+    return true;  // fixes compiler warning (line should not be reached due to halt)
 }

 void FlashUtilityView::focus() {
@@ -32,8 +32,14 @@
 #include "untar.hpp"
 #include <cstdint>

+#define FLASH_ROM_SIZE 1048576
+#define FLASH_STARTING_ADDRESS 0x00000000
+#define FLASH_EXPECTED_CHECKSUM 0x00000000
+
 namespace ui {

+bool valid_firmware_file(std::filesystem::path::string_type path);
+
 class FlashUtilityView : public View {
   public:
    FlashUtilityView(NavigationView& nav);
@@ -41,6 +47,7 @@ class FlashUtilityView : public View {
    void focus() override;

    std::string title() const override { return "Flash Utility"; };
+    bool flash_firmware(std::filesystem::path::string_type path);

   private:
    NavigationView& nav_;
@@ -55,9 +62,9 @@ class FlashUtilityView : public View {
        {0, 2 * 8, 240, 26 * 8},
        true};

-    std::filesystem::path extract_tar(std::filesystem::path::string_type path);  // extracts the tar file, and returns the firmware.bin path from it. empty string if no fw
+    std::filesystem::path extract_tar(std::filesystem::path::string_type path, ui::Painter& painter);  // extracts the tar file, and returns the firmware.bin path from it. empty string if no fw
    void firmware_selected(std::filesystem::path::string_type path);
-    void flash_firmware(std::filesystem::path::string_type path);
+
    bool endsWith(const std::u16string& str, const std::u16string& suffix);
 };

@@ -27,14 +27,19 @@
 void config_mode_blink_until_dfu();

 void config_mode_set() {
-    portapack::persistent_memory::set_config_mode_storage_direct(CONFIG_MODE_GUARD_VALUE);
+    uint32_t cms = portapack::persistent_memory::config_mode_storage_direct();
+    if ((cms >= CONFIG_MODE_GUARD_VALUE) && (cms < CONFIG_MODE_LIMIT_VALUE))
+        cms += 1;
+    else
+        cms = CONFIG_MODE_GUARD_VALUE;
+    portapack::persistent_memory::set_config_mode_storage_direct(cms);
 }

 bool config_mode_should_enter() {
    if (portapack::persistent_memory::config_disable_config_mode_direct())
        return false;
    else
-        return portapack::persistent_memory::config_mode_storage_direct() == CONFIG_MODE_GUARD_VALUE;
+        return portapack::persistent_memory::config_mode_storage_direct() == CONFIG_MODE_LIMIT_VALUE;
 }

 void config_mode_clear() {
@@ -28,6 +28,13 @@
 #include "portapack_shared_memory.hpp"
 #include "portapack_persistent_memory.hpp"

+// number of boot failures before entering config menu mode
+#define BOOT_FAILURES_BEFORE_CONFIG_MODE 3
+
+#define CONFIG_MODE_GUARD_VALUE 0xbadb0000
+#define CONFIG_MODE_LIMIT_VALUE (CONFIG_MODE_GUARD_VALUE + BOOT_FAILURES_BEFORE_CONFIG_MODE - 1)
+#define CONFIG_MODE_NORMAL_VALUE 0x000007cf
+
 void config_mode_set();
 bool config_mode_should_enter();
 void config_mode_clear();
@@ -13,8 +13,8 @@ typedef uint8_t byte;
 typedef uint32_t word;

 byte SPEED = 2;
-byte MAXLIFES = 5;
-byte LIFES = START_LIFES;
+byte MAXLIFES = 20;
+size_t LIFES = START_LIFES;
 byte GAMEWIN = 0;
 byte GAMEOVER = 0;
 byte DEMO = 1;
@@ -25,6 +25,9 @@ byte GAMEPAUSED = 0;

 byte PACMANFALLBACK = 0;

+bool cheat_level = false;
+bool cheat_lifes = false;
+
 #include "DrawIndexedMap.h"

 /******************************************************************************/
@@ -901,14 +904,15 @@ class Playfield {

    void PackmanDied() {  // Noooo... PACMAN DIED :(

-        if (LIFES <= 0) {
+        if (LIFES <= 0 && !cheat_lifes) {
            GAMEOVER = 1;
            LEVEL = START_LEVEL;
            LIFES = START_LIFES;
            DEMO = 1;
            Init();
        } else {
-            LIFES--;
+            if (!cheat_lifes)
+                LIFES--;

            _inited = true;
            _state = ReadyState;
@@ -934,8 +938,14 @@ class Playfield {
                _icons[13 - i] = BONUSICON + i;
            }

-            for (byte i = 0; i < LIFES; i++) {
-                _icons[0 + i] = PACMANICON;
+            if (!cheat_lifes) {
+                for (byte i = 0; i < LIFES; i++) {
+                    _icons[0 + i] = PACMANICON;
+                }
+            } else {
+                for (byte i = 0; i < 14; i++) {
+                    _icons[0 + i] = PACMANICON;
+                }
            }

            // Draw LIFE and BONUS Icons
@@ -1177,8 +1187,13 @@ class Playfield {
        if (GAMEWIN == 1) {
            GAMEWIN = 0;
        } else {
-            LEVEL = START_LEVEL;
-            LIFES = START_LIFES;
+            if (!cheat_level) {
+                LEVEL = START_LEVEL;
+            }
+            if (!cheat_lifes) {
+                LIFES = START_LIFES;
+            }
+
            ACTUALBONUS = 0;  // actual bonus icon
            ACTIVEBONUS = 0;  // status of bonus

@@ -1215,8 +1230,14 @@ class Playfield {
        }

        // SET Lifes icons
-        for (byte i = 0; i < LIFES; i++) {
-            _icons[0 + i] = PACMANICON;
+        if (cheat_lifes) {
+            for (byte i = 0; i < 14; i++) {  // cuz 14 lives full fills PP's screen
+                _icons[0 + i] = PACMANICON;
+            }
+        } else {
+            for (byte i = 0; i < LIFES; i++) {
+                _icons[0 + i] = PACMANICON;
+            }
        }

        // Draw LIFE and BONUS Icons
@@ -1243,21 +1264,45 @@ class Playfield {
    }

    void Step() {
-        int16_t keys = 0;
-
        if (GAMEWIN == 1) {
+            cheat_level = false;
+            cheat_lifes = false;
            LEVEL++;
            Init();
        }

        // Start GAME
-        if (but_A && DEMO == 1 && GAMEPAUSED == 0) {
+        if (but_A && DEMO == 1 && GAMEPAUSED == 0) {  // start
            but_A = false;
-            DEMO = 0;
            Init();
-        } else if (but_A && DEMO == 0 && GAMEPAUSED == 0) {  // Or PAUSE GAME
+            DEMO = 0;
+        } else if (but_A && DEMO == 0 && GAMEPAUSED == 0) {  // pause
            but_A = false;
            GAMEPAUSED = 1;
+        } else if (but_LEFT && DEMO == 1 && GAMEPAUSED == 0) {  // -level
+            cheat_level = true;
+            but_LEFT = false;
+            if (LEVEL > 1) {
+                LEVEL--;
+            }
+            Init();
+        } else if (but_RIGHT && DEMO == 1 && GAMEPAUSED == 0) {  // +level
+            cheat_level = true;
+            but_RIGHT = false;
+            if (LEVEL < 255) {
+                LEVEL++;
+            }
+            Init();
+        } else if (but_UP && DEMO == 1 && GAMEPAUSED == 0) {  // full of lifes
+            cheat_lifes = true;
+            but_UP = false;
+            Init();
+        } else if (but_DOWN && DEMO == 1 && GAMEPAUSED == 0) {  // reset
+            cheat_level = false;
+            cheat_lifes = false;
+            but_DOWN = false;
+            LIFES = START_LIFES;
+            Init();
        }

        if (GAMEPAUSED && but_A && DEMO == 0) {
@@ -33,10 +33,10 @@ namespace max283x {
 namespace lo {

 constexpr std::array<rf::FrequencyRange, 4> band{{
-    {2300000000, 2400000000},
+    {2170000000, 2400000000},
    {2400000000, 2500000000},
    {2500000000, 2600000000},
-    {2600000000, 2700000000},
+    {2600000000, 2740000000},
 }};

 } /* namespace lo */
@@ -48,11 +48,6 @@ namespace lna {
 constexpr range_t<int8_t> gain_db_range{0, 40};
 constexpr int8_t gain_db_step = 8;

-constexpr std::array<rf::FrequencyRange, 2> band{{
-    {2300000000, 2500000000},
-    {2500000000, 2700000000},
-}};
-
 } /* namespace lna */

 /*************************************************************************/
@@ -184,11 +184,13 @@ bool set_tuning_frequency(const rf::Frequency frequency) {
    if (tuning_config.is_valid()) {
        first_if.disable();

+        // Program first local oscillator frequency (if there is one) into RFFC507x
        if (tuning_config.first_lo_frequency) {
            first_if.set_frequency(tuning_config.first_lo_frequency);
            first_if.enable();
        }

+        // Program second local oscillator frequency into MAX283x
        const auto result_second_if = second_if->set_frequency(tuning_config.second_lo_frequency);

        rf_path.set_band(tuning_config.rf_path_band);
@@ -39,8 +39,8 @@ enum class Direction {

 namespace path {

-constexpr FrequencyRange band_low{0, 2170000000};
-constexpr FrequencyRange band_high{2740000000, 7250000000};
+constexpr FrequencyRange band_low{0, 2170'000'000};
+constexpr FrequencyRange band_high{2740'000'000, 7250'000'000};
 constexpr FrequencyRange band_mid{band_low.maximum, band_high.minimum};

 enum class Band {
@@ -26,44 +26,43 @@
 namespace tuning {
 namespace config {

-namespace {
-
+// Low band <2170 Mhz:
 constexpr rf::Frequency low_band_second_lo_frequency(const rf::Frequency target_frequency) {
-    return 2650000000 - (target_frequency / 7);
-}
-
-constexpr rf::Frequency high_band_second_lo_regions_2_and_3(const rf::Frequency target_frequency) {
-    return (target_frequency < 5100000000)
-               ? (2350000000 + ((target_frequency - 3600000000) / 5))
-               : (2500000000 + ((target_frequency - 5100000000) / 9));
-}
-
-constexpr rf::Frequency high_band_second_lo_frequency(const rf::Frequency target_frequency) {
-    return (target_frequency < 3600000000)
-               ? (2170000000 + (((target_frequency - 2740000000) * 57) / 86))
-               : high_band_second_lo_regions_2_and_3(target_frequency);
+    return 2650'000'000 - (target_frequency / 7);
 }

 Config low_band(const rf::Frequency target_frequency) {
-    const rf::Frequency first_lo_frequency = target_frequency + low_band_second_lo_frequency(target_frequency);
-    const rf::Frequency second_lo_frequency = first_lo_frequency - target_frequency;
+    const rf::Frequency second_lo_frequency = low_band_second_lo_frequency(target_frequency);
+    const rf::Frequency first_lo_frequency = target_frequency + second_lo_frequency;
    const bool mixer_invert = true;
    return {first_lo_frequency, second_lo_frequency, rf::path::Band::Low, mixer_invert};
 }

+// Mid band 2170-2740 Mhz:
 Config mid_band(const rf::Frequency target_frequency) {
-    return {0, target_frequency, rf::path::Band::Mid, false};
+    const rf::Frequency second_lo_frequency = target_frequency;
+    const rf::Frequency first_lo_frequency = 0;
+    const bool mixer_invert = false;
+    return {first_lo_frequency, second_lo_frequency, rf::path::Band::Mid, mixer_invert};
+}
+
+// High band >2740 Mhz:
+constexpr rf::Frequency high_band_second_lo_frequency(const rf::Frequency target_frequency) {
+    if (target_frequency < 3600'000'000)
+        return (2170'000'000 + (((target_frequency - 2740'000'000) * 57) / 86));
+    else if (target_frequency < 5100'000'000)
+        return (2350'000'000 + ((target_frequency - 3600'000'000) / 5));
+    else
+        return (2500'000'000 + ((target_frequency - 5100'000'000) / 9));
 }

 Config high_band(const rf::Frequency target_frequency) {
-    const rf::Frequency first_lo_frequency = target_frequency - high_band_second_lo_frequency(target_frequency);
-    const rf::Frequency second_lo_frequency = target_frequency - first_lo_frequency;
+    const rf::Frequency second_lo_frequency = high_band_second_lo_frequency(target_frequency);
+    const rf::Frequency first_lo_frequency = target_frequency - second_lo_frequency;
    const bool mixer_invert = false;
    return {first_lo_frequency, second_lo_frequency, rf::path::Band::High, mixer_invert};
 }

-} /* namespace */
-
 Config create(const rf::Frequency target_frequency) {
    /* TODO: This is some lame code. */
    if (rf::path::band_low.contains(target_frequency)) {
@@ -107,6 +107,7 @@ namespace ui {

 /* static */ bool ExternalItemsMenuLoader::run_external_app(ui::NavigationView& nav, std::filesystem::path filePath) {
    File app;
+    uint32_t checksum{0};

    auto openError = app.open(filePath);
    if (openError)
@@ -115,7 +116,6 @@ namespace ui {
    application_information_t application_information = {};

    auto readResult = app.read(&application_information, sizeof(application_information_t));
-
    if (!readResult)
        return false;

@@ -135,6 +135,8 @@ namespace ui {
            if (!readResult)
                return false;

+            checksum += simple_checksum((uint32_t)&application_information.memory_location[file_read_index], readResult.value());
+
            if (readResult.value() < std::filesystem::max_file_block_size)
                break;
        }
@@ -156,6 +158,8 @@ namespace ui {
            if (!readResult)
                return false;

+            checksum += simple_checksum((uint32_t)target_memory, readResult.value());
+
            if (readResult.value() != bytes_to_read)
                break;
        }
@@ -168,11 +172,16 @@ namespace ui {
            if (!readResult)
                return false;

+            checksum += simple_checksum((uint32_t)&application_information.memory_location[file_read_index], readResult.value());
+
            if (readResult.value() < std::filesystem::max_file_block_size)
                break;
        }
    }

+    if (checksum != EXT_APP_EXPECTED_CHECKSUM)
+        return false;
+
    application_information.externalAppEntry(nav);
    return true;
 }
@@ -29,6 +29,8 @@

 #include "file.hpp"

+#define EXT_APP_EXPECTED_CHECKSUM 0x00000000
+
 namespace ui {

 template <size_t Width, size_t Height>
@@ -503,8 +503,8 @@ void SystemStatusView::rtc_battery_workaround() {
            month = (timestamp.FAT_date >> 5) & 0xF;
            day = timestamp.FAT_date & 0x1F;

-            // bump to next month at 28 days for simplicity
-            if (++day > 28) {
+            // bump to next month
+            if (++day > rtc_time::days_per_month(year, month)) {
                day = 1;
                if (++month > 12) {
                    month = 1;
@@ -547,16 +547,16 @@ InformationView::InformationView(
                  &ltime});

 #if GCC_VERSION_MISMATCH
-    static constexpr Style style_gcc_warning{
-        .font = font::fixed_8x16,
-        .background = {33, 33, 33},
-        .foreground = Color::yellow(),
-    };
-    version.set_style(&style_gcc_warning);
+    version.set_style(&Styles::yellow);
 #else
    version.set_style(&style_infobar);
 #endif

+    if (firmware_checksum_error()) {
+        version.set("FLASH ERROR");
+        version.set_style(&Styles::red);
+    }
+
    ltime.set_style(&style_infobar);
    refresh();
    set_dirty();
@@ -568,6 +568,17 @@ void InformationView::refresh() {
    ltime.set_date_enabled(pmem::clock_with_date());
 }

+bool InformationView::firmware_checksum_error() {
+    static bool fw_checksum_checked{false};
+    static bool fw_checksum_error{false};
+
+    // only checking firmware checksum once per boot
+    if (!fw_checksum_checked) {
+        fw_checksum_error = (simple_checksum(FLASH_STARTING_ADDRESS, FLASH_ROM_SIZE) != FLASH_EXPECTED_CHECKSUM);
+    }
+    return fw_checksum_error;
+}
+
 /* Navigation ************************************************************/

 bool NavigationView::is_top() const {
@@ -286,6 +286,7 @@ class InformationView : public View {
   public:
    InformationView(NavigationView& nav);
    void refresh();
+    bool firmware_checksum_error();

   private:
    // static constexpr auto version_string = "v1.4.4"; // This is commented out as we are now setting the version via ENV (VERSION_STRING=v1.0.0)
@@ -118,7 +118,7 @@ uint8_t usb_descriptor_configuration_full_speed[] = {
    USB_INT_IN_EP_ADDR,            // bEndpointAddress
    0x03,                          // bmAttributes: BULK
    USB_WORD(16),                  // wMaxPacketSize
-    0xFF,                          // bInterval: no NAK
+    0x20,                          // bInterval: no NAK

    9,                              // bLength
    USB_DESCRIPTOR_TYPE_INTERFACE,  // bDescriptorType
@@ -203,7 +203,7 @@ uint8_t usb_descriptor_configuration_high_speed[] = {
    USB_INT_IN_EP_ADDR,            // bEndpointAddress
    0x03,                          // bmAttributes: BULK
    USB_WORD(16),                  // wMaxPacketSize
-    0xFF,                          // bInterval: no NAK
+    0x20,                          // bInterval: no NAK

    9,                              // bLength
    USB_DESCRIPTOR_TYPE_INTERFACE,  // bDescriptorType
@@ -41,6 +41,7 @@
 #include "chprintf.h"
 #include "chqueues.h"
 #include "ui_external_items_menu_loader.hpp"
+#include "ui_flash_utility.hpp"
 #include "untar.hpp"
 #include "ui_widget.hpp"

@@ -151,39 +152,15 @@ static void cmd_flash(BaseSequentialStream* chp, int argc, char* argv[]) {
    if (!top_widget) return;
    auto nav = static_cast<ui::SystemView*>(top_widget)->get_navigation_view();
    if (!nav) return;
-    nav->display_modal("Flashing", "Flashing from serial.\r\nPlease wait!\r\nDevice will restart.");
-    // check file extensions
-    if (strEndsWith(path.native(), u".ppfw.tar")) {
-        // extract tar
-        chprintf(chp, "Extracting TAR file.\r\n");
-        auto res = UnTar::untar(
-            path.native(), [chp](const std::string fileName) {
-                chprintf(chp, fileName.c_str());
-                chprintf(chp, "\r\n");
-            });
-        if (res.empty()) {
-            chprintf(chp, "error bad TAR file.\r\n");
-            nav->pop();
-            return;
-        }
-        path = res;  // it will contain the last bin file in tar
-    } else if (strEndsWith(path.native(), u".bin")) {
-        // nothing to do for this case yet.
-    } else {
-        chprintf(chp, "error only .bin or .ppfw.tar files canbe flashed.\r\n");
-        nav->pop();
-        return;
-    }
+    nav->home(false);

-    chprintf(chp, "Flashing: ");
-    chprintf(chp, path.string().c_str());
-    chprintf(chp, "\r\n");
-    chThdSleepMilliseconds(50);
-    std::memcpy(&shared_memory.bb_data.data[0], path.native().c_str(), (path.native().length() + 1) * 2);
-    m4_request_shutdown();
-    chThdSleepMilliseconds(50);
-    m4_init(portapack::spi_flash::image_tag_flash_utility, portapack::memory::map::m4_code, false);
-    m0_halt();
+    // call nav with flash
+    auto open_view = nav->push<ui::FlashUtilityView>();
+    chprintf(chp, "Flashing started\r\n");
+    chThdSleepMilliseconds(150);  // to give display some time to paint the screen
+    if (!open_view->flash_firmware(path.native())) {
+        chprintf(chp, "error\r\n");
+    }
 }

 static void cmd_screenshot(BaseSequentialStream* chp, int argc, char* argv[]) {
@@ -26,7 +26,8 @@
 #include "ui_navigation.hpp"
 #include "spi_image.hpp"

-#define CURRENT_HEADER_VERSION 0x00000001
+#define CURRENT_HEADER_VERSION 0x00000002
+#define MIN_HEADER_VERSION_FOR_CHECKSUM 0x00000002

 typedef void (*externalAppEntry_t)(ui::NavigationView& nav);

@@ -32,6 +32,7 @@
 #include "string_format.hpp"
 #include "ui_styles.hpp"
 #include "ui_painter.hpp"
+#include "ui_flash_utility.hpp"
 #include "utility.hpp"
 #include "rtc_time.hpp"

@@ -1051,6 +1052,9 @@ bool debug_dump() {
    pmem_dump_file.write_line("Ext APPS version req'd: 0x" + to_string_hex(VERSION_MD5));
    pmem_dump_file.write_line("GCC version: " + to_string_dec_int(__GNUC__) + "." + to_string_dec_int(__GNUC_MINOR__) + "." + to_string_dec_int(__GNUC_PATCHLEVEL__));

+    // firmware checksum
+    pmem_dump_file.write_line("Firmware calculated checksum: 0x" + to_string_hex(simple_checksum(FLASH_STARTING_ADDRESS, FLASH_ROM_SIZE), 8));
+
    // write persistent memory
    pmem_dump_file.write_line("\n[Persistent Memory]");

@@ -32,6 +32,7 @@
 #include "modems.hpp"
 #include "serializer.hpp"
 #include "volume.hpp"
+#include "config_mode.hpp"

 // persistent memory from/to sdcard flag file
 #define PMEM_FILEFLAG u"/SETTINGS/PMEM_FILEFLAG"
@@ -242,8 +243,6 @@ void set_disable_touchscreen(bool v);
 uint8_t config_encoder_dial_sensitivity();
 void set_encoder_dial_sensitivity(uint8_t v);

-#define CONFIG_MODE_GUARD_VALUE 0x000007d1
-#define CONFIG_MODE_NORMAL_VALUE 0x000007cf
 uint32_t config_mode_storage_direct();
 void set_config_mode_storage_direct(uint32_t v);
 bool config_disable_config_mode_direct();
@@ -6,6 +6,8 @@
 #include <string.h>
 #include "string_format.hpp"
 #include "file.hpp"
+#include "utility.hpp"
+#include "ui_external_items_menu_loader.hpp"

 class UnTar {
   public:
@@ -86,6 +88,10 @@ class UnTar {
        std::string binfile = "";
        std::string fn = "";
        int filesize;
+        uint32_t app_checksum;
+        bool app_file;
+        bool first_read;
+        bool corrupt_file{false};
        for (;;) {
            auto readres = a->read(buff, 512);
            if (!readres.is_ok()) return "";
@@ -132,20 +138,49 @@ class UnTar {
                delete_file(fn);
                auto fres = f.open(fn, false, true);
                if (!fres.value().ok()) return "";
+                app_file = (fn.substr(fn.size() - 5) == ".ppma");
+                first_read = true;
+                app_checksum = 0;
+                corrupt_file = false;
            }
            while (filesize > 0) {
                readres = a->read(buff, 512);
-                if (!readres.is_ok()) return "";
+                if (!readres.is_ok()) {
+                    corrupt_file = true;
+                    break;
+                }
                bytes_read = readres.value();
                if (bytes_read < 512) {
-                    return "";
+                    corrupt_file = true;
+                    break;
                }
                if (filesize < 512)
                    bytes_read = filesize;
+                if (app_file && first_read) {
+                    // Check app file header for min version for checksum support
+                    struct application_information_t* app_info = (struct application_information_t*)buff;
+                    if (app_info->header_version < MIN_HEADER_VERSION_FOR_CHECKSUM)
+                        app_file = false;
+                    first_read = false;
+                }
+                if (app_file) {
+                    app_checksum += simple_checksum((uint32_t)buff, bytes_read);
+                }
                auto fwres = f.write(buff, bytes_read);
-                if (!fwres.is_ok()) return "";
+                if (!fwres.is_ok()) {
+                    corrupt_file = true;
+                    break;
+                }
                filesize -= bytes_read;
                f.sync();
+                if ((filesize == 0) && app_file && (app_checksum != EXT_APP_EXPECTED_CHECKSUM)) {
+                    corrupt_file = true;
+                    break;
+                }
+            }
+            if (corrupt_file) {
+                delete_file(fn);
+                return "";
            }
        }
        return binfile;
@@ -235,3 +235,10 @@ std::string join(char c, std::initializer_list<std::string_view> strings) {

    return result;
 }
+
+uint32_t simple_checksum(uint32_t buffer_address, uint32_t length) {
+    uint32_t checksum = 0;
+    for (uint32_t i = 0; i < length; i += 4)
+        checksum += *(uint32_t*)(buffer_address + i);
+    return checksum;
+}
@@ -217,4 +217,6 @@ struct range_t {

 std::string join(char c, std::initializer_list<std::string_view> strings);

+uint32_t simple_checksum(uint32_t buffer_address, uint32_t length);
+
 #endif /*__UTILITY_H__*/
@@ -104,6 +104,14 @@ for external_image_prefix in sys.argv[4:]:
 		external_application_image = patch_image(external_application_image, search_address, replace_address)
 		external_application_image[memory_location_header_position:memory_location_header_position+4] = replace_address.to_bytes(4, byteorder='little')

+		checksum = 0
+		for i in range(0, len(external_application_image), 4):
+			checksum += external_application_image[i] + (external_application_image[i + 1] << 8) + (external_application_image[i + 2] << 16) + (external_application_image[i + 3] << 24)
+
+		final_checksum = 0
+		checksum = (final_checksum - checksum) & 0xFFFFFFFF
+		external_application_image += checksum.to_bytes(4, 'little')
+
 		write_image(external_application_image, "{}/{}.ppma".format(binary_dir, external_image_prefix))
 		continue

@@ -127,5 +135,13 @@ for external_image_prefix in sys.argv[4:]:
 		print("application {} can not exceed 32kb: {} bytes used".format(external_image_prefix, len(external_application_image)))
 		sys.exit(-1)

+	checksum = 0
+	for i in range(0, len(external_application_image), 4):
+		checksum += external_application_image[i] + (external_application_image[i + 1] << 8) + (external_application_image[i + 2] << 16) + (external_application_image[i + 3] << 24)
+
+	final_checksum = 0
+	checksum = (final_checksum - checksum) & 0xFFFFFFFF
+	external_application_image += checksum.to_bytes(4, 'little')
+
 	# write .ppma (portapack mayhem application)
 	write_image(external_application_image, "{}/{}.ppma".format(binary_dir, external_image_prefix))
@@ -74,7 +74,24 @@ for image in images:
 	padded_data = image['data'] + (spi_image_default_byte * pad_size)
 	spi_image += padded_data

-if len(spi_image) > spi_size:
-	raise RuntimeError('SPI flash image size of %d exceeds device size of %d bytes' % (len(spi_image), spi_size))
+if len(spi_image) > spi_size - 4:
+	raise RuntimeError('SPI flash image size of %d exceeds device size of %d bytes' % (len(spi_image) + 4, spi_size))
+
+pad_size = spi_size - 4 - len(spi_image)
+for i in range(pad_size):
+	spi_image += spi_image_default_byte
+
+# quick "add up the words" checksum:
+checksum = 0
+for i in range(0, len(spi_image), 4):
+	checksum += (spi_image[i] + (spi_image[i + 1] << 8) + (spi_image[i + 2] << 16) + (spi_image[i + 3] << 24))
+
+final_checksum = 0
+checksum = (final_checksum - checksum) & 0xFFFFFFFF
+
+spi_image += checksum.to_bytes(4, 'little')

 write_image(spi_image, output_path)
+
+percent_remaining = round(1000 * pad_size / spi_size) / 10;
+print ("Space remaining in flash ROM:", pad_size, "bytes (", percent_remaining, "%)")
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+
+#
+# Copyright (C) 2024 Mark Thompson
+#
+# This file is part of PortaPack.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+import sys
+import struct
+
+usage_message = """
+PortaPack ROM image checksum checker
+
+Usage: <command> <input-file>
+"""
+
+def read_image(path):
+	f = open(path, 'rb')
+	data = f.read()
+	f.close()
+	return data
+
+def write_image(data, path):
+	f = open(path, 'wb')
+	f.write(data)
+	f.close()
+
+if len(sys.argv) != 2:
+	print(usage_message)
+	sys.exit(-1)
+
+image = read_image(sys.argv[1])
+image = bytearray(image)
+
+# simple "add up the words" checksum:
+checksum = 0
+for i in range(0, len(image), 4):
+	checksum += (image[i] + (image[i + 1] << 8) + (image[i + 2] << 16) + (image[i + 3] << 24))
+
+checksum &= 0xFFFFFFFF
+print ("Simple checksum =", checksum)
Author	SHA1	Message	Date
Mark Thompson	a4f6bbda5e	Fix compiler warning (#1827 ) * Fix compiler warning * Fix compiler warning * Friggin C-lang	2024-01-29 18:07:32 -06:00
Totoo	8b2598fdac	Call the flasher app when flashing from serial (#1825 )	2024-01-29 20:52:35 +01:00
sommermoregentraum	c36fe78bd5	pacman: cheat lifes and cheat skip level (#1821 ) cheat lives and cheat skip level and fixed review issue. Thanks @NotherNgineer	2024-01-29 00:54:13 +08:00
Mark Thompson	bd8385464e	Tuner code readability (no functional change) (#1820 )	2024-01-28 10:02:11 -06:00
Totoo	8c996b5bc6	Embedded friendly usb (#1817 )	2024-01-27 19:33:08 +01:00
Mark Thompson	d1901939e1	Fix tuning of 2170-2300 and 2700-2740 MHz (#1819 )	2024-01-27 13:30:32 +01:00
Mark Thompson	41ec11fb66	Check app checksums during untar (#1815 )	2024-01-27 13:29:24 +01:00
Mark Thompson	df47490d85	Allow 3 boot failures before Config Mode starts (#1816 ) * Allow 3 boot attempts before Config Mode starts * Add files via upload	2024-01-26 21:02:52 +13:00
Totoo	a2f6d14b15	ISS for aprs, for the request #1810 (#1814 )	2024-01-25 21:10:43 +01:00
Mark Thompson	6a6c6d6502	Add Checksums to Firmware & External App images (#1809 ) * Pad image to 1MB and add simple checksum * Test code to verify firmware checksum * Comment out unneeded zlib * Add files via upload * Print space remaining in ROM * Append checksum to external apps too * Check external app checksums when loading * Is it 2024 already?! * Validate firmware checksum before flashing * Add files via upload * Added flash error warning to nav screen * Clang * Replaced some hard-coded values with #defines * Check FW checksum before USB serial flash too * Add files via upload	2024-01-24 16:37:21 -06:00