Fix compiler warning (#1827)

* Fix compiler warning

* Fix compiler warning

* Friggin C-lang

.github/workflows/create_nightly_release.yml

@@ -71,11 +71,11 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          CHANGELOG=$(python3 .github/workflows/changelog.py)
-          CHANGELOG="${CHANGELOG//'%'/'%25'}"
-          CHANGELOG="${CHANGELOG//$'\n'/'%0A'}"
-          CHANGELOG="${CHANGELOG//$'\r'/'%0D'}"
-          echo "content=$CHANGELOG" >> $GITHUB_OUTPUT
+          {
+            echo 'content<<EOF'
+            python3 .github/workflows/changelog.py
+            echo EOF
+          } >> "$GITHUB_OUTPUT"
         id: changelog
       - name: Create Release
         id: create_release

.github/workflows/create_stable_release.yml

@@ -55,11 +55,11 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          CHANGELOG=$(python3 .github/workflows/changelog.py ${{ steps.past_version.outputs.past_version }})
-          CHANGELOG="${CHANGELOG//'%'/'%25'}"
-          CHANGELOG="${CHANGELOG//$'\n'/'%0A'}"
-          CHANGELOG="${CHANGELOG//$'\r'/'%0D'}"
-          echo "content=$CHANGELOG" >> $GITHUB_OUTPUT
+          {
+            echo 'content<<EOF'
+            python3 .github/workflows/changelog.py ${{ steps.past_version.outputs.past_version }}
+            echo EOF
+          } >> "$GITHUB_OUTPUT"
         id: changelog
       - name: Create Release
         id: create_release

firmware/application/apps/soundboard_app.cpp

@@ -80,7 +80,13 @@ void SoundBoardView::file_error() {
 }
 
 void SoundBoardView::start_tx(const uint32_t id) {
+    if (file_list.empty()) {
+        file_error();
+        return;
+    }
+
     auto reader = std::make_unique<WAVFileReader>();
+
     uint32_t tone_key_index = options_tone_key.selected_index();
     uint32_t sample_rate;
 
@@ -110,11 +116,11 @@ void SoundBoardView::start_tx(const uint32_t id) {
 
     // TODO: Delete all this and use tx model.
     baseband::set_audiotx_config(
-        1536000 / 20,  // Update vu-meter at 20Hz
+        TONES_SAMPLERATE / 20,  // Update vu-meter at 20Hz
         transmitter_model.channel_bandwidth(),
         0,  // Gain is unused
         8,  // shift_bits_s16, default 8 bits, but  also unused
-        TONES_F2D(tone_key_frequency(tone_key_index), 1536000),
+        TONES_F2D(tone_key_frequency(tone_key_index), TONES_SAMPLERATE),
         0,  // AM
         0,  // DSB
         0,  // USB
@@ -126,7 +132,8 @@ void SoundBoardView::start_tx(const uint32_t id) {
 
     tx_view.set_transmitting(true);
 
-    audio::output::start();
+    if (tone_key_index == 0)
+        audio::output::start();
 }
 
 /*void SoundBoardView::show_infos() {
@@ -232,6 +239,7 @@ SoundBoardView::SoundBoardView(
                   //&text_duration,
                   //&progressbar,
                   &field_volume,
+                  &text_volume_disabled,
                   &page_info,
                   &check_loop,
                   &check_random,
@@ -257,6 +265,13 @@ SoundBoardView::SoundBoardView(
     tone_keys_populate(options_tone_key);
     options_tone_key.set_selected_index(0);
 
+    text_volume_disabled.hidden(true);
+    options_tone_key.on_change = [this](size_t index, OptionsField::value_t) {
+        bool tone_key_enabled = (index != 0);
+        text_volume_disabled.hidden(!tone_key_enabled);
+        field_volume.hidden(tone_key_enabled);
+    };
+
     check_loop.set_value(false);
     check_random.set_value(false);
 

firmware/application/apps/soundboard_app.hpp

@@ -128,6 +128,9 @@ class SoundBoardView : public View {
 
     AudioVolumeField field_volume{
         {28 * 8, 180}};
+    Text text_volume_disabled{
+        {28 * 8, 180, 3 * 8, 16},
+        "--"};
 
     Checkbox check_loop{
         {0, 25 * 8 + 4},

firmware/application/apps/ui_aprs_rx.cpp

@@ -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);
         }
     };
 

firmware/application/apps/ui_aprs_rx.hpp

@@ -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},

firmware/application/apps/ui_flash_utility.cpp

@@ -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() {

firmware/application/apps/ui_flash_utility.hpp

@@ -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);
 };
 

firmware/application/config_mode.cpp

@@ -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() {

firmware/application/config_mode.hpp

@@ -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();

firmware/application/external/pacman/playfield.hpp

@@ -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) {

firmware/application/hw/max283x.hpp

@@ -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 */
 
 /*************************************************************************/

firmware/application/radio.cpp

@@ -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);

firmware/application/rf_path.hpp

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

firmware/application/string_format.cpp

@@ -185,7 +185,7 @@ std::string to_string_freq(const uint64_t f) {
 
 // right-justified frequency in MHz, rounded to 4 decimal places, always 9 characters
 std::string to_string_short_freq(const uint64_t f) {
-    auto final_str = to_string_dec_int(f / 1000000, 4) + "." + to_string_dec_int(((f + 50) / 100) % 10000, 4, '0');
+    auto final_str = to_string_dec_int((f + 50) / 1000000, 4) + "." + to_string_dec_int(((f + 50) / 100) % 10000, 4, '0');
     return final_str;
 }
 
@@ -210,7 +210,7 @@ std::string to_string_rounded_freq(const uint64_t f, int8_t precision) {
 
         uint32_t divisor = pow10[6 - precision];
 
-        final_str = to_string_dec_uint(f / 1000000) + "." + to_string_dec_int(((f + (divisor / 2)) / divisor) % pow10[precision], precision, '0');
+        final_str = to_string_dec_uint((f + (divisor / 2)) / 1000000) + "." + to_string_dec_int(((f + (divisor / 2)) / divisor) % pow10[precision], precision, '0');
     }
     return final_str;
 }

firmware/application/tone_key.cpp

@@ -85,7 +85,7 @@ const tone_key_t tone_keys = {
     {"Senn. 32.768k", F2Ix100(32768.0)}};
 
 std::string fx100_string(uint32_t f) {
-    return to_string_dec_uint(f / 100) + "." + to_string_dec_uint(((f + 5) / 10) % 10);
+    return to_string_dec_uint((f + 5) / 100) + "." + to_string_dec_uint(((f + 5) / 10) % 10);
 }
 
 float tone_key_frequency(tone_index index) {

firmware/application/tuning.cpp

@@ -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)) {

firmware/application/ui/ui_geomap.cpp

@@ -498,12 +498,13 @@ void GeoMap::draw_scale(Painter& painter) {
     if (m < 1000) {
         km_string = to_string_dec_uint(m) + "m";
     } else {
+        m += 50;  // (add rounding factor for div by 100 below)
         uint32_t km = m / 1000;
         m -= km * 1000;
         if (m == 0) {
             km_string = to_string_dec_uint(km) + " km";
         } else {
-            km_string = to_string_dec_uint(km) + "." + to_string_dec_uint((m + 50) / 100, 1) + "km";
+            km_string = to_string_dec_uint(km) + "." + to_string_dec_uint(m / 100, 1) + "km";
         }
     }
 

firmware/application/ui_external_items_menu_loader.cpp

@@ -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;
 }

firmware/application/ui_external_items_menu_loader.hpp

@@ -29,6 +29,8 @@
 
 #include "file.hpp"
 
+#define EXT_APP_EXPECTED_CHECKSUM 0x00000000
+
 namespace ui {
 
 template <size_t Width, size_t Height>

firmware/application/ui_navigation.cpp

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

firmware/application/ui_navigation.hpp

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

firmware/application/usb_serial_descriptor.c

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

firmware/application/usb_serial_shell.cpp

@@ -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[]) {

firmware/baseband/audio_dma.cpp

@@ -215,9 +215,12 @@ void disable() {
     gpdma_channel_i2s0_rx.disable();
 }
 
-void shrink_tx_buffer() {
-    single_tx_buffer = true;
-    lli_tx_loop[0].lli = lli_pointer(&lli_tx_loop[0]);
+void shrink_tx_buffer(bool shrink) {
+    single_tx_buffer = shrink;
+    if (single_tx_buffer)
+        lli_tx_loop[0].lli = lli_pointer(&lli_tx_loop[0]);
+    else
+        lli_tx_loop[0].lli = lli_pointer(&lli_tx_loop[1]);
 }
 
 buffer_t tx_empty_buffer() {

firmware/baseband/audio_dma.hpp

@@ -47,7 +47,7 @@ void init();
 void configure();
 void enable();
 void disable();
-void shrink_tx_buffer();
+void shrink_tx_buffer(bool shrink);
 
 audio::buffer_t tx_empty_buffer();
 audio::buffer_t rx_empty_buffer();

firmware/baseband/audio_output.cpp

@@ -32,34 +32,34 @@
 #include <cstddef>
 #include <array>
 
-void AudioOutput::configure(
-    const bool do_proc) {
+void AudioOutput::configure(const bool do_proc) {
     do_processing = do_proc;
 }
 
-void AudioOutput::configure(
-    const iir_biquad_config_t& hpf_config,
-    const iir_biquad_config_t& deemph_config,
-    const float squelch_threshold) {
+void AudioOutput::configure(const iir_biquad_config_t& hpf_config, const iir_biquad_config_t& deemph_config, const float squelch_threshold) {
     hpf.configure(hpf_config);
     deemph.configure(deemph_config);
     squelch.set_threshold(squelch_threshold);
 }
 
-void AudioOutput::write(
-    const buffer_s16_t& audio) {
+void AudioOutput::write_unprocessed(const buffer_s16_t& audio) {
+    block_buffer_s16.feed(
+        audio,
+        [this](const buffer_s16_t& buffer) {
+            audio_present = true;
+            fill_audio_buffer(buffer, audio_present);
+        });
+}
+
+void AudioOutput::write(const buffer_s16_t& audio) {
     std::array<float, 32> audio_f;
     for (size_t i = 0; i < audio.count; i++) {
         audio_f[i] = audio.p[i] * ki;
     }
-    write(buffer_f32_t{
-        audio_f.data(),
-        audio.count,
-        audio.sampling_rate});
+    write(buffer_f32_t{audio_f.data(), audio.count, audio.sampling_rate});
 }
 
-void AudioOutput::write(
-    const buffer_f32_t& audio) {
+void AudioOutput::write(const buffer_f32_t& audio) {
     block_buffer.feed(
         audio,
         [this](const buffer_f32_t& buffer) {
@@ -67,8 +67,7 @@ void AudioOutput::write(
         });
 }
 
-void AudioOutput::on_block(
-    const buffer_f32_t& audio) {
+void AudioOutput::on_block(const buffer_f32_t& audio) {
     if (do_processing) {
         const auto audio_present_now = squelch.execute(audio);
 
@@ -93,6 +92,18 @@ bool AudioOutput::is_squelched() {
     return !audio_present;
 }
 
+void AudioOutput::fill_audio_buffer(const buffer_s16_t& audio, const bool send_to_fifo) {
+    auto audio_buffer = audio::dma::tx_empty_buffer();
+    for (size_t i = 0; i < audio_buffer.count; i++) {
+        audio_buffer.p[i].left = audio_buffer.p[i].right = audio.p[i];
+    }
+    if (stream && send_to_fifo) {
+        stream->write(audio.p, audio_buffer.count * sizeof(int16_t));
+    }
+
+    feed_audio_stats(audio);
+}
+
 void AudioOutput::fill_audio_buffer(const buffer_f32_t& audio, const bool send_to_fifo) {
     std::array<int16_t, 32> audio_int;
 
@@ -110,6 +121,15 @@ void AudioOutput::fill_audio_buffer(const buffer_f32_t& audio, const bool send_t
     feed_audio_stats(audio);
 }
 
+void AudioOutput::feed_audio_stats(const buffer_s16_t& audio) {
+    audio_stats.feed(
+        audio,
+        [](const AudioStatistics& statistics) {
+            const AudioStatisticsMessage audio_stats_message{statistics};
+            shared_memory.application_queue.push(audio_stats_message);
+        });
+}
+
 void AudioOutput::feed_audio_stats(const buffer_f32_t& audio) {
     audio_stats.feed(
         audio,

firmware/baseband/audio_output.hpp

@@ -44,6 +44,7 @@ class AudioOutput {
         const iir_biquad_config_t& deemph_config = iir_config_passthrough,
         const float squelch_threshold = 0.0f);
 
+    void write_unprocessed(const buffer_s16_t& audio);
     void write(const buffer_s16_t& audio);
     void write(const buffer_f32_t& audio);
 
@@ -57,6 +58,7 @@ class AudioOutput {
     static constexpr float k = 32768.0f;
     static constexpr float ki = 1.0f / k;
 
+    BlockDecimator<int16_t, 32> block_buffer_s16{1};
     BlockDecimator<float, 32> block_buffer{1};
 
     IIRBiquadFilter hpf{};
@@ -73,7 +75,11 @@ class AudioOutput {
     bool do_processing = true;
 
     void on_block(const buffer_f32_t& audio);
+
+    void fill_audio_buffer(const buffer_s16_t& audio, const bool send_to_fifo);
     void fill_audio_buffer(const buffer_f32_t& audio, const bool send_to_fifo);
+
+    void feed_audio_stats(const buffer_s16_t& audio);
     void feed_audio_stats(const buffer_f32_t& audio);
 };
 

firmware/baseband/audio_stats_collector.cpp

@@ -23,6 +23,19 @@
 
 #include "utility.hpp"
 
+void AudioStatsCollector::consume_audio_buffer(const buffer_s16_t& src) {
+    auto src_p = src.p;
+    const auto src_end = &src.p[src.count];
+    while (src_p < src_end) {
+        const auto sample = *(src_p++);
+        const auto sample_squared = sample * sample;
+        squared_sum += sample_squared;
+        if (sample_squared > max_squared) {
+            max_squared = sample_squared;
+        }
+    }
+}
+
 void AudioStatsCollector::consume_audio_buffer(const buffer_f32_t& src) {
     auto src_p = src.p;
     const auto src_end = &src.p[src.count];
@@ -56,6 +69,12 @@ bool AudioStatsCollector::update_stats(const size_t sample_count, const size_t s
     }
 }
 
+bool AudioStatsCollector::feed(const buffer_s16_t& src) {
+    consume_audio_buffer(src);
+
+    return update_stats(src.count, src.sampling_rate);
+}
+
 bool AudioStatsCollector::feed(const buffer_f32_t& src) {
     consume_audio_buffer(src);
 

firmware/baseband/audio_stats_collector.hpp

@@ -30,6 +30,13 @@
 
 class AudioStatsCollector {
    public:
+    template <typename Callback>
+    void feed(const buffer_s16_t& src, Callback callback) {
+        if (feed(src)) {
+            callback(statistics);
+        }
+    }
+
     template <typename Callback>
     void feed(const buffer_f32_t& src, Callback callback) {
         if (feed(src)) {
@@ -52,10 +59,12 @@ class AudioStatsCollector {
 
     AudioStatistics statistics{};
 
+    void consume_audio_buffer(const buffer_s16_t& src);
     void consume_audio_buffer(const buffer_f32_t& src);
 
     bool update_stats(const size_t sample_count, const size_t sampling_rate);
 
+    bool feed(const buffer_s16_t& src);
     bool feed(const buffer_f32_t& src);
     bool mute(const size_t sample_count, const size_t sampling_rate);
 };

firmware/baseband/proc_audiotx.cpp

@@ -41,13 +41,17 @@ void AudioTXProcessor::execute(const buffer_c8_t& buffer) {
             }
         }
 
-        // Output to speaker too
-        uint32_t imod32 = i & (AUDIO_OUTPUT_BUFFER_SIZE - 1);
-        audio_data[imod32] = ((int16_t)audio_sample - 0x80) * (1.0f / 128.0f);
-        if (imod32 == (AUDIO_OUTPUT_BUFFER_SIZE - 1))
-            audio_output.write(audio_buffer);
+        sample = audio_sample - 0x80;
 
-        sample = tone_gen.process(audio_sample - 0x80);
+        // Output to speaker too
+        if (!tone_key_enabled) {
+            uint32_t imod32 = i & (AUDIO_OUTPUT_BUFFER_SIZE - 1);
+            audio_data[imod32] = sample * 256;
+            if (imod32 == (AUDIO_OUTPUT_BUFFER_SIZE - 1))
+                audio_output.write_unprocessed(audio_buffer);
+        }
+
+        sample = tone_gen.process(sample);
 
         // FM
         delta = sample * fm_delta;
@@ -102,7 +106,9 @@ void AudioTXProcessor::audio_config(const AudioTXConfigMessage& message) {
     progress_interval_samples = message.divider;
     resample_acc = 0;
     audio_output.configure(false);
-    audio::dma::shrink_tx_buffer();
+
+    tone_key_enabled = (message.tone_key_delta != 0);
+    audio::dma::shrink_tx_buffer(!tone_key_enabled);
 }
 
 void AudioTXProcessor::replay_config(const ReplayConfigMessage& message) {

firmware/baseband/proc_audiotx.hpp

@@ -52,14 +52,15 @@ class AudioTXProcessor : public BasebandProcessor {
     int32_t sample{0}, delta{};
     int8_t re{0}, im{0};
 
-    float audio_data[AUDIO_OUTPUT_BUFFER_SIZE];
-    buffer_f32_t audio_buffer{audio_data, AUDIO_OUTPUT_BUFFER_SIZE, 48000};
+    int16_t audio_data[AUDIO_OUTPUT_BUFFER_SIZE];
+    buffer_s16_t audio_buffer{audio_data, AUDIO_OUTPUT_BUFFER_SIZE, 48000};
     AudioOutput audio_output{};
 
     size_t progress_interval_samples = 0, progress_samples = 0;
 
     bool configured{false};
     uint32_t bytes_read{0};
+    bool tone_key_enabled{false};
 
     void sample_rate_config(const SampleRateConfigMessage& message);
     void audio_config(const AudioTXConfigMessage& message);

firmware/common/external_app.hpp

@@ -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);
 

firmware/common/portapack_persistent_memory.cpp

@@ -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]");
 

firmware/common/portapack_persistent_memory.hpp

@@ -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();

firmware/common/untar.hpp

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

firmware/common/utility.cpp

@@ -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;
+}

firmware/common/utility.hpp

@@ -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__*/

firmware/tools/export_external_apps.py

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

firmware/tools/make_spi_image.py

@@ -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, "%)")

firmware/tools/simple_checksum.py

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