Bug/big frequency (#3247)

* fix(ui): BigFrequency ignores set_dirty() when frequency is unchanged

paint() gated its entire body behind a frequency-changed check (_previous_frequency cache), so calling set_dirty() without changing the value (e.g. forcing a repaint after a style/theme change) silently did nothing. Moved the change check into set() instead, so paint() always redraws when called and set_dirty() behaves as expected.

* accidental deletion

firmware/application/CMakeLists.txt

@@ -279,16 +279,12 @@ set(CPPSRC
 	ui/ui_tone_key.cpp
 	ui/ui_transmitter.cpp
 	ui/ui_bmpview.cpp
-	apps/ais_app.cpp
 	apps/analog_audio_app.cpp
 	apps/ble_rx_app.cpp
 	apps/ble_tx_app.cpp
 	apps/capture_app.cpp
 	apps/pocsag_app.cpp
 	apps/ui_about_simple.cpp
-	apps/ui_adsb_rx.cpp
-	apps/ui_aprs_rx.cpp
-	apps/ui_aprs_tx.cpp
 	apps/ui_battinfo.cpp
 	apps/ui_bmp_file_viewer.cpp
 	apps/ui_btle_rx.cpp
@@ -516,4 +512,4 @@ add_custom_target(
 	DEPENDS ${PROJECT_NAME}.bin
 )
 
-add_dependencies(${PROJECT_NAME} baseband)
+add_dependencies(${PROJECT_NAME} baseband)

firmware/application/apps/analog_audio_app.cpp

@@ -280,6 +280,12 @@ AnalogAudioView::AnalogAudioView(
     field_frequency.on_show_options = [this]() {
         this->on_show_options_frequency();
     };
+    field_frequency.changing = [this](rf::Frequency frequency) {
+        return this->on_frequency_changed(frequency);
+    };
+    field_frequency.entered = [this](rf::Frequency frequency) {
+        this->set_frequency_absolute(frequency);
+    };
 
     field_lna.on_show_options = [this]() {
         this->on_show_options_rf_gain();
@@ -308,8 +314,10 @@ AnalogAudioView::AnalogAudioView(
     };
 
     waterfall.on_select = [this](int32_t offset) {
-        field_frequency.set_value(receiver_model.target_frequency() + offset);
+        field_frequency.set_value(
+            field_frequency.value() + offset * receiver_model.frequency_step());
     };
+    waterfall.set_live_tuning(true);
 
 #ifdef PRALINE
     button_pro.on_select = [this](Button&) { this->on_show_options_praline(); };
@@ -319,6 +327,7 @@ AnalogAudioView::AnalogAudioView(
 
     // This call starts the correct baseband image to run
     // and sets the radio up as necessary for the given modulation.
+    sliding_center_frequency = receiver_model.target_frequency();
     on_modulation_changed(modulation);
 }
 
@@ -328,7 +337,7 @@ AnalogAudioView::AnalogAudioView(
     : AnalogAudioView(nav) {
     // Settings to override when launched from another app (versus from AppSettings .ini file)
     // TODO: Which other settings make sense to override?
-    field_frequency.set_value(override.frequency_app_override);
+    set_frequency_absolute(override.frequency_app_override);
     on_frequency_step_changed(override.frequency_step);
     options_modulation.set_by_value(toUType(override.mode));
 }
@@ -573,10 +582,14 @@ void AnalogAudioView::update_modulation(ReceiverModel::Mode modulation) {
     receiver_model.set_sampling_rate(is_wideband_spectrum_mode ? spec_bw : 3072000);
     receiver_model.set_baseband_bandwidth(is_wideband_spectrum_mode ? spec_bw / 2 : 1750000);
 
-    receiver_model.set_hidden_offset(modulation == ReceiverModel::Mode::AMAudioFMApt ? -2200 : 0);  // wefax needs to be shifted, see wefax rx app.
+    reset_sliding_frequency(modulation);
 
     receiver_model.enable();
 
+    if (sliding_enabled) {
+        baseband::set_audio_ddc_frequency(0);
+    }
+
     // TODO: This doesn't belong here! There's a better way.
     size_t sampling_rate = 0;
     switch (modulation) {
@@ -610,7 +623,64 @@ void AnalogAudioView::handle_coded_squelch(uint32_t value) {
 }
 
 void AnalogAudioView::on_freqchg(int64_t freq) {
-    field_frequency.set_value(freq);
+    set_frequency_absolute(freq);
+}
+
+void AnalogAudioView::set_frequency_absolute(rf::Frequency frequency) {
+    if (!sliding_enabled) {
+        field_frequency.set_value(frequency);
+        return;
+    }
+
+    sliding_center_frequency = frequency;
+
+    /* set_value() does not call on_change when the displayed frequency is
+     * already equal, so reset the hardware and DDC explicitly in that case. */
+    if (field_frequency.value() == frequency) {
+        receiver_model.set_target_frequency_with_hidden_offset(frequency, 0);
+        baseband::set_audio_ddc_frequency(0);
+    } else {
+        field_frequency.set_value(frequency);
+    }
+}
+
+int32_t AnalogAudioView::sliding_limit() const {
+    const bool zoom_x2 =
+        receiver_model.modulation() == ReceiverModel::Mode::AMAudio &&
+        previous_zoom != 0;
+    return zoom_x2 ? sliding_limit_zoom_x2 : sliding_limit_zoom_x1;
+}
+
+void AnalogAudioView::reset_sliding_frequency(ReceiverModel::Mode modulation) {
+    sliding_enabled =
+        modulation == ReceiverModel::Mode::AMAudio ||
+        modulation == ReceiverModel::Mode::NarrowbandFMAudio;
+    sliding_center_frequency = receiver_model.target_frequency();
+
+    /* AMFM keeps its existing Wefax offset; sliding applies to AM and NFM. */
+    receiver_model.set_hidden_offset(
+        modulation == ReceiverModel::Mode::AMAudioFMApt ? -2200 : 0);
+}
+
+bool AnalogAudioView::on_frequency_changed(rf::Frequency frequency) {
+    if (!sliding_enabled)
+        return false;
+
+    const auto limit = sliding_limit();
+    int64_t offset = frequency - sliding_center_frequency;
+    if (offset > limit) {
+        sliding_center_frequency = frequency - limit;
+        offset = limit;
+    } else if (offset < -limit) {
+        sliding_center_frequency = frequency + limit;
+        offset = -limit;
+    }
+
+    /* Store the displayed frequency and retune the hardware centre atomically. */
+    receiver_model.set_target_frequency_with_hidden_offset(
+        frequency, sliding_center_frequency - frequency);
+    baseband::set_audio_ddc_frequency(static_cast<int32_t>(offset));
+    return true;
 }
 
 #ifdef PRALINE

firmware/application/apps/analog_audio_app.hpp

@@ -269,6 +269,10 @@ class AnalogAudioView : public View {
     uint8_t zoom_factor_amfm{0};             // initial zoom factor in AMFM mode
     uint8_t previous_AM_mode_option{0};      // GUI 5 AM modes :  (0..4 ) (DSB9K, DSB6K, USB,LSB, CW). Used to select proper FIR filter (0..11) AM mode  + offset 0 (zoom+1) or +6 (if zoom+2)
     uint8_t previous_zoom{0};                // GUI ZOOM+1, ZOOM+2 , equivalent to two values offset 0 (zoom+1) or +6 (if zoom+2)
+    static constexpr int32_t sliding_limit_zoom_x1 = 50000;
+    static constexpr int32_t sliding_limit_zoom_x2 = 30000;
+    rf::Frequency sliding_center_frequency{0};
+    bool sliding_enabled{false};
 
     app_settings::SettingsManager settings_{
         "rx_audio",
@@ -354,6 +358,10 @@ class AnalogAudioView : public View {
     void handle_coded_squelch(uint32_t value);
 
     void on_freqchg(int64_t freq);
+    bool on_frequency_changed(rf::Frequency frequency);
+    void set_frequency_absolute(rf::Frequency frequency);
+    int32_t sliding_limit() const;
+    void reset_sliding_frequency(ReceiverModel::Mode modulation);
 
     MessageHandlerRegistration message_handler_coded_squelch{
         Message::ID::CodedSquelch,

firmware/application/apps/ui_subghzd.cpp

@@ -74,7 +74,7 @@ void SubGhzDRecentEntryDetailView::update_data() {
             console.writeln("Action: 0x" + to_string_hex(func_code));
     }
 
-    if (entry_.sensorType == FPS_KEELOQ) {
+    if (entry_.sensorType == FPS_KEELOQ || entry_.sensorType == FPS_SUPERROLLO) {
         console.writeln("Fix: " + to_string_hex(fix));
         console.writeln("Encrypted: " + to_string_hex(encrypted));
         console.writeln("Manufacturer: " + mf_name);
@@ -243,6 +243,8 @@ const char* SubGhzDView::getSensorTypeName(FPROTO_SUBGHZD_SENSOR type) {
             return "Ido 11x";
         case FPS_INTERTECHNOV3:
             return "InterTehcno v3";
+        case FPS_SUPERROLLO:
+            return "Superrollo";
         case FPS_KEELOQ:
             return "KeeLoq";
         case FPS_KINGGATESSTYLO4K:
@@ -671,7 +673,7 @@ void SubGhzDRecentEntryDetailView::parseProtocol() {
         return;
     }
 
-    if (entry_.sensorType == FPS_KEELOQ) {
+    if (entry_.sensorType == FPS_KEELOQ || entry_.sensorType == FPS_SUPERROLLO) {
         uint64_t data_rev = FProtoGeneral::subghz_protocol_blocks_reverse_key(entry_.data, 64);
 
         btn = data_rev >> 60;

firmware/application/baseband_api.cpp

@@ -32,10 +32,6 @@
 
 #include "core_control.hpp"
 
-/* Set true to enable additional checks to ensure
- * M4 and M0 are synchronized before passing messages. */
-static constexpr bool enforce_core_sync = true;
-
 /* Set true to enable check for baseband messages getting stuck.
  * This implies the baseband thread is not dequeuing and has probably stalled.
  * NB: This check adds a small amout of overhead to the message sending code
@@ -343,6 +339,11 @@ void set_spectrum(
     send_message(&message);
 }
 
+void set_audio_ddc_frequency(int32_t frequency) {
+    const AudioDDCConfigMessage message{frequency};
+    send_message(&message);
+}
+
 void set_time_sink(
     const size_t sampling_rate,
     const size_t trigger) {
@@ -469,7 +470,7 @@ bool is_image_running() {
     return baseband_image_running;
 }
 
-void run_image(const spi_flash::image_tag_t image_tag) {
+void run_image(const spi_flash::image_tag_t image_tag, bool enforce_core_sync) {
     if (baseband_image_running) {
         chDbgPanic("BBRunning");
     }
@@ -482,7 +483,7 @@ void run_image(const spi_flash::image_tag_t image_tag) {
 
     creg::m4txevent::enable();
 
-    if constexpr (enforce_core_sync) {
+    if (enforce_core_sync) {
         // Wait up to 3 seconds for baseband to start handling events.
         auto count = 3'000u;
         while (!shared_memory.baseband_ready && --count)
@@ -493,7 +494,7 @@ void run_image(const spi_flash::image_tag_t image_tag) {
     }
 }
 
-void run_prepared_image(const uint32_t m4_code) {
+void run_prepared_image(const uint32_t m4_code, bool enforce_core_sync) {
     if (baseband_image_running) {
         chDbgPanic("BBRunning");
     }
@@ -506,7 +507,7 @@ void run_prepared_image(const uint32_t m4_code) {
 
     creg::m4txevent::enable();
 
-    if constexpr (enforce_core_sync) {
+    if (enforce_core_sync) {
         // Wait up to 3 seconds for baseband to start handling events.
         auto count = 3'000u;
         while (!shared_memory.baseband_ready && --count)

firmware/application/baseband_api.hpp

@@ -100,6 +100,7 @@ void set_rds_data(const uint16_t message_length);
 void set_spectrum(
     const size_t sampling_rate,
     const size_t trigger);
+void set_audio_ddc_frequency(int32_t frequency);
 void set_time_sink(
     const size_t sampling_rate,
     const size_t trigger);
@@ -130,8 +131,8 @@ void request_beep_stop();
 void request_audio_beep(uint32_t freq, uint32_t sample_rate, uint32_t duration_ms);
 
 bool is_image_running();
-void run_image(const portapack::spi_flash::image_tag_t image_tag);
-void run_prepared_image(const uint32_t m4_code);
+void run_image(const portapack::spi_flash::image_tag_t image_tag, bool enforce_core_sync = true);
+void run_prepared_image(const uint32_t m4_code, bool enforce_core_sync = true);
 void shutdown();
 
 void spectrum_streaming_start();

firmware/application/external/adsbrx/main.cpp

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2026 PortaPack Mayhem
+ *
+ * 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.
+ */
+
+#include "ui_adsb_rx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::adsbrx {
+
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<ADSBRxView>();
+}
+
+}  // namespace ui::external_app::adsbrx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_adsbrx.application_information"), used)) application_information_t _application_information_adsbrx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::adsbrx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "ADS-B",
+    /*.bitmap_data = */ {
+        0x80,
+        0x01,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xE0,
+        0x07,
+        0xF8,
+        0x1F,
+        0xFE,
+        0x7F,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xC0,
+        0x03,
+        0xE0,
+        0x07,
+        0xF0,
+        0x0F,
+        0xF8,
+        0x1F,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_adsbrx */ {'P', 'A', 'D', 'R'},
+    /*.m4_app_offset = */ 0x00000000,
+};
+
+}  // extern "C"

firmware/application/external/adsbrx/ui_adsb_rx.cpp

@@ -38,7 +38,7 @@ using namespace portapack;
 
 namespace pmem = portapack::persistent_memory;
 
-namespace ui {
+namespace ui::external_app::adsbrx {
 
 static const char speed_type_msg[][6] = {" Spd:", " IAS:", " TAS:"};
 
@@ -46,13 +46,19 @@ static std::string get_map_tag(const AircraftRecentEntry& entry) {
     return trimr(entry.callsign.empty() ? entry.icao_str : entry.callsign);
 }
 
+}  // namespace ui::external_app::adsbrx
+
+namespace ui {
+
 template <>
-void RecentEntriesTable<AircraftRecentEntries>::draw(
+void RecentEntriesTable<external_app::adsbrx::AircraftRecentEntries>::draw(
     const Entry& entry,
     const Rect& target_rect,
     Painter& painter,
     const Style& style,
     RecentEntriesColumns& columns) {
+    using namespace external_app::adsbrx;
+
     Color target_color;
     std::string entry_string;
 
@@ -107,6 +113,10 @@ void RecentEntriesTable<AircraftRecentEntries>::draw(
                             bitmap_target, target_color, style.background);
 }
 
+}  // namespace ui
+
+namespace ui::external_app::adsbrx {
+
 /* ADSBLogger ********************************************/
 
 void ADSBLogger::log(const ADSBLogEntry& log_entry) {
@@ -828,4 +838,4 @@ void ADSBRxView::remove_expired_entries() {
     recent.erase(it.base(), recent.end());
 }
 
-} /* namespace ui */
+}  // namespace ui::external_app::adsbrx

firmware/application/external/adsbrx/ui_adsb_rx.hpp

@@ -39,7 +39,7 @@
 
 using namespace adsb;
 
-namespace ui {
+namespace ui::external_app::adsbrx {
 #define AIRCRAFT_ID_L 1  // aircraft ID message type (lowest type id)
 #define AIRCRAFT_ID_H 4  // aircraft ID message type (highest type id)
 
@@ -491,4 +491,4 @@ class ADSBRxView : public View {
         }};
 };
 
-} /* namespace ui */
+}  // namespace ui::external_app::adsbrx

firmware/application/external/ais_rx/ais_app.cpp

@@ -35,7 +35,8 @@ using namespace portapack;
 
 namespace pmem = portapack::persistent_memory;
 
-namespace ais {
+namespace ui::external_app::ais_rx {
+
 namespace format {
 
 static std::string latlon_abs_normalized(const int32_t normalized, const char suffixes[2]) {
@@ -47,7 +48,7 @@ static std::string latlon_abs_normalized(const int32_t normalized, const char su
     return to_string_dec_uint(degrees) + "." + to_string_dec_uint(fraction, 6, '0') + suffix;
 }
 
-static std::string latlon(const Latitude latitude, const Longitude longitude) {
+static std::string latlon(const ais::Latitude latitude, const ais::Longitude longitude) {
     if (latitude.is_valid() && longitude.is_valid()) {
         return latlon_abs_normalized(latitude.normalized(), "SN") + " " + latlon_abs_normalized(longitude.normalized(), "WE");
     } else if (latitude.is_not_available() && longitude.is_not_available()) {
@@ -128,7 +129,7 @@ static std::string navigational_status(const unsigned int value) {
     }
 }
 
-static std::string rate_of_turn(const RateOfTurn value) {
+static std::string rate_of_turn(const ais::RateOfTurn value) {
     switch (value) {
         case -128:
             return "not available";
@@ -149,7 +150,7 @@ static std::string rate_of_turn(const RateOfTurn value) {
     }
 }
 
-static std::string speed_over_ground(const SpeedOverGround value) {
+static std::string speed_over_ground(const ais::SpeedOverGround value) {
     if (value == 1023) {
         return "not available";
     } else if (value == 1022) {
@@ -159,7 +160,7 @@ static std::string speed_over_ground(const SpeedOverGround value) {
     }
 }
 
-static std::string course_over_ground(const CourseOverGround value) {
+static std::string course_over_ground(const ais::CourseOverGround value) {
     if (value > 3600) {
         return "invalid";
     } else if (value == 3600) {
@@ -169,7 +170,7 @@ static std::string course_over_ground(const CourseOverGround value) {
     }
 }
 
-static std::string true_heading(const TrueHeading value) {
+static std::string true_heading(const ais::TrueHeading value) {
     if (value == 511) {
         return "not available";
     } else if (value > 359) {
@@ -180,7 +181,6 @@ static std::string true_heading(const TrueHeading value) {
 }
 
 } /* namespace format */
-} /* namespace ais */
 
 void AISLogger::on_packet(const ais::Packet& packet) {
     // TODO: Unstuff here, not in baseband!
@@ -265,25 +265,33 @@ void AISRecentEntry::update(const ais::Packet& packet) {
     }
 }
 
+}  // namespace ui::external_app::ais_rx
+
 namespace ui {
 
 template <>
-void RecentEntriesTable<AISRecentEntries>::draw(
+void RecentEntriesTable<external_app::ais_rx::AISRecentEntries>::draw(
     const Entry& entry,
     const Rect& target_rect,
     Painter& painter,
     const Style& style,
     RecentEntriesColumns&) {
-    std::string line = ais::format::mmsi(entry.mmsi) + " ";
+    using namespace external_app::ais_rx;
+
+    std::string line = format::mmsi(entry.mmsi) + " ";
     if (!entry.name.empty()) {
-        line += ais::format::text(entry.name);
+        line += format::text(entry.name);
     } else {
-        line += ais::format::text(entry.call_sign);
+        line += format::text(entry.call_sign);
     }
     line.resize(target_rect.width() / 8, ' ');
     painter.draw_string(target_rect.location(), style, line);
 }
 
+}  // namespace ui
+
+namespace ui::external_app::ais_rx {
+
 AISRecentEntryDetailView::AISRecentEntryDetailView(NavigationView& nav) {
     add_children({
         &button_done,
@@ -298,12 +306,12 @@ AISRecentEntryDetailView::AISRecentEntryDetailView(NavigationView& nav) {
 
     button_see_map.on_select = [this, &nav](Button&) {
         geomap_view = nav.push<GeoMapView>(
-            ais::format::text(entry_.name),
+            format::text(entry_.name),
             0,
             GeoPos::alt_unit::METERS,
             GeoPos::spd_unit::KNOTS,
-            ais::format::latlon_float(entry_.last_position.latitude.normalized()),
-            ais::format::latlon_float(entry_.last_position.longitude.normalized()),
+            format::latlon_float(entry_.last_position.latitude.normalized()),
+            format::latlon_float(entry_.last_position.longitude.normalized()),
             entry_.last_position.true_heading,
             [this]() {
                 send_updates = false;
@@ -324,14 +332,14 @@ AISRecentEntryDetailView& AISRecentEntryDetailView::operator=(const AISRecentEnt
 
 void AISRecentEntryDetailView::update_position() {
     if (send_updates)
-        geomap_view->update_position(ais::format::latlon_float(entry_.last_position.latitude.normalized()), ais::format::latlon_float(entry_.last_position.longitude.normalized()), (float)entry_.last_position.true_heading, 0, entry_.last_position.speed_over_ground > 1022 ? 0 : entry_.last_position.speed_over_ground / 10);
+        geomap_view->update_position(format::latlon_float(entry_.last_position.latitude.normalized()), format::latlon_float(entry_.last_position.longitude.normalized()), (float)entry_.last_position.true_heading, 0, entry_.last_position.speed_over_ground > 1022 ? 0 : entry_.last_position.speed_over_ground / 10);
 }
 
 bool AISRecentEntryDetailView::add_map_marker(const AISRecentEntry& entry) {
     if (geomap_view && send_updates) {
         GeoMarker marker{};
-        marker.lon = ais::format::latlon_float(entry.last_position.longitude.normalized());
-        marker.lat = ais::format::latlon_float(entry.last_position.latitude.normalized());
+        marker.lon = format::latlon_float(entry.last_position.longitude.normalized());
+        marker.lat = format::latlon_float(entry.last_position.latitude.normalized());
         marker.angle = entry.last_position.true_heading;
         marker.tag = entry.call_sign.empty() ? to_string_dec_uint(entry.mmsi) : entry.call_sign;
         auto markerStored = geomap_view->store_marker(marker);
@@ -377,18 +385,18 @@ void AISRecentEntryDetailView::paint(Painter& painter) {
 
     auto field_rect = Rect{rect.left(), rect.top() + 16, rect.width(), 16};
 
-    field_rect = draw_field(painter, field_rect, s, "MMSI", ais::format::mmsi(entry_.mmsi));
-    field_rect = draw_field(painter, field_rect, s, "Ctry", ais::format::mid(entry_.mmsi));
-    field_rect = draw_field(painter, field_rect, s, "Name", ais::format::text(entry_.name));
-    field_rect = draw_field(painter, field_rect, s, "Call", ais::format::text(entry_.call_sign));
-    field_rect = draw_field(painter, field_rect, s, "Dest", ais::format::text(entry_.destination));
+    field_rect = draw_field(painter, field_rect, s, "MMSI", format::mmsi(entry_.mmsi));
+    field_rect = draw_field(painter, field_rect, s, "Ctry", format::mid(entry_.mmsi));
+    field_rect = draw_field(painter, field_rect, s, "Name", format::text(entry_.name));
+    field_rect = draw_field(painter, field_rect, s, "Call", format::text(entry_.call_sign));
+    field_rect = draw_field(painter, field_rect, s, "Dest", format::text(entry_.destination));
     field_rect = draw_field(painter, field_rect, s, "Last", to_string_datetime(entry_.last_position.timestamp));
-    field_rect = draw_field(painter, field_rect, s, "Pos ", ais::format::latlon(entry_.last_position.latitude, entry_.last_position.longitude));
-    field_rect = draw_field(painter, field_rect, s, "Stat", ais::format::navigational_status(entry_.navigational_status));
-    field_rect = draw_field(painter, field_rect, s, "RoT ", ais::format::rate_of_turn(entry_.last_position.rate_of_turn));
-    field_rect = draw_field(painter, field_rect, s, "SoG ", ais::format::speed_over_ground(entry_.last_position.speed_over_ground));
-    field_rect = draw_field(painter, field_rect, s, "CoG ", ais::format::course_over_ground(entry_.last_position.course_over_ground));
-    field_rect = draw_field(painter, field_rect, s, "Head", ais::format::true_heading(entry_.last_position.true_heading));
+    field_rect = draw_field(painter, field_rect, s, "Pos ", format::latlon(entry_.last_position.latitude, entry_.last_position.longitude));
+    field_rect = draw_field(painter, field_rect, s, "Stat", format::navigational_status(entry_.navigational_status));
+    field_rect = draw_field(painter, field_rect, s, "RoT ", format::rate_of_turn(entry_.last_position.rate_of_turn));
+    field_rect = draw_field(painter, field_rect, s, "SoG ", format::speed_over_ground(entry_.last_position.speed_over_ground));
+    field_rect = draw_field(painter, field_rect, s, "CoG ", format::course_over_ground(entry_.last_position.course_over_ground));
+    field_rect = draw_field(painter, field_rect, s, "Head", format::true_heading(entry_.last_position.true_heading));
     field_rect = draw_field(painter, field_rect, s, "Rx #", to_string_dec_uint(entry_.received_count));
 }
 
@@ -504,4 +512,4 @@ void AISAppView::on_show_detail(const AISRecentEntry& entry) {
     recent_entry_detail_view.update_map_markers(recent);
 }
 
-} /* namespace ui */
+}  // namespace ui::external_app::ais_rx

firmware/application/external/ais_rx/ais_app.hpp

@@ -50,6 +50,8 @@ using namespace lpc43xx;
 
 #include "recent_entries.hpp"
 
+namespace ui::external_app::ais_rx {
+
 struct AISPosition {
     rtc::RTC timestamp{};
     ais::Latitude latitude{};
@@ -109,8 +111,6 @@ class AISLogger {
     LogFile log_file{};
 };
 
-namespace ui {
-
 using AISRecentEntriesView = RecentEntriesView<AISRecentEntries>;
 
 class AISRecentEntryDetailView : public View {
@@ -239,6 +239,6 @@ class AISAppView : public View {
     void on_tick_second();
 };
 
-} /* namespace ui */
+}  // namespace ui::external_app::ais_rx
 
 #endif /*__AIS_APP_H__*/

firmware/application/external/ais_rx/main.cpp

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2026 PortaPack Mayhem
+ *
+ * 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.
+ */
+
+#include "ais_app.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::ais_rx {
+
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<AISAppView>();
+}
+
+}  // namespace ui::external_app::ais_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_ais_rx.application_information"), used)) application_information_t _application_information_ais_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::ais_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "AIS Boats",
+    /*.bitmap_data = */ {
+        0x00,
+        0x01,
+        0x80,
+        0x01,
+        0xC0,
+        0x01,
+        0xC0,
+        0x0D,
+        0xE0,
+        0x3D,
+        0xF0,
+        0x3D,
+        0xF8,
+        0x7D,
+        0xFC,
+        0x7D,
+        0xFC,
+        0x7D,
+        0xFE,
+        0x7D,
+        0xFF,
+        0x7D,
+        0x00,
+        0x00,
+        0xF8,
+        0x7F,
+        0xF8,
+        0x3F,
+        0xF0,
+        0x0F,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_ais */ {'P', 'A', 'I', 'S'},
+    /*.m4_app_offset = */ 0x00000000,
+};
+
+}  // extern "C"

firmware/application/external/aprs_rx/main.cpp

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2026 PortaPack Mayhem
+ *
+ * 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.
+ */
+
+#include "ui_aprs_rx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::aprs_rx {
+
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<APRSRXView>();
+}
+
+}  // namespace ui::external_app::aprs_rx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_aprs_rx.application_information"), used)) application_information_t _application_information_aprs_rx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::aprs_rx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "APRS",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xF0,
+        0x0F,
+        0x4C,
+        0x32,
+        0xFE,
+        0x7F,
+        0x25,
+        0xA4,
+        0x25,
+        0xA4,
+        0xFF,
+        0xFF,
+        0x25,
+        0xA4,
+        0x25,
+        0xA4,
+        0xFE,
+        0x7F,
+        0x4C,
+        0x32,
+        0xF0,
+        0x0F,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::RX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_aprs_rx */ {'P', 'A', 'P', 'R'},
+    /*.m4_app_offset = */ 0x00000000,
+};
+
+}  // extern "C"

firmware/application/external/aprs_rx/ui_aprs_rx.cpp

@@ -31,19 +31,25 @@
 
 using namespace portapack;
 
+namespace ui::external_app::aprs_rx {
+
 void APRSLogger::log_raw_data(const std::string& data) {
     log_file.write_entry(data);
 }
 
+}  // namespace ui::external_app::aprs_rx
+
 namespace ui {
 
 template <>
-void RecentEntriesTable<APRSRecentEntries>::draw(
+void RecentEntriesTable<external_app::aprs_rx::APRSRecentEntries>::draw(
     const Entry& entry,
     const Rect& target_rect,
     Painter& painter,
     const Style& style,
     RecentEntriesColumns& columns) {
+    using namespace external_app::aprs_rx;
+
     Color target_color;
     // auto entry_age = entry.age;
 
@@ -68,6 +74,10 @@ void RecentEntriesTable<APRSRecentEntries>::draw(
     }
 }
 
+}  // namespace ui
+
+namespace ui::external_app::aprs_rx {
+
 void APRSRxView::focus() {
     options_region.focus();
 }
@@ -402,4 +412,4 @@ void APRSRXView::focus() {
 
 APRSRXView::~APRSRXView() {
 }
-} /* namespace ui */
+}  // namespace ui::external_app::aprs_rx

firmware/application/external/aprs_rx/ui_aprs_rx.hpp

@@ -38,6 +38,8 @@
 #include "utility.hpp"
 #include "file_path.hpp"
 
+namespace ui::external_app::aprs_rx {
+
 class APRSLogger {
    public:
     Optional<File::Error> append(const std::filesystem::path& filename) {
@@ -50,8 +52,6 @@ class APRSLogger {
     LogFile log_file{};
 };
 
-namespace ui {
-
 struct APRSRecentEntry {
     using Key = uint64_t;
 
@@ -290,6 +290,6 @@ class APRSRXView : public View {
         }};
 };
 
-} /* namespace ui */
+}  // namespace ui::external_app::aprs_rx
 
 #endif /*__UI_APRS_RX_H__*/

firmware/application/external/aprs_tx/main.cpp

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2026 PortaPack Mayhem
+ *
+ * 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.
+ */
+
+#include "ui_aprs_tx.hpp"
+#include "ui_navigation.hpp"
+#include "external_app.hpp"
+
+namespace ui::external_app::aprs_tx {
+
+void initialize_app(ui::NavigationView& nav) {
+    nav.push<APRSTXView>();
+}
+
+}  // namespace ui::external_app::aprs_tx
+
+extern "C" {
+
+__attribute__((section(".external_app.app_aprs_tx.application_information"), used)) application_information_t _application_information_aprs_tx = {
+    /*.memory_location = */ (uint8_t*)0x00000000,
+    /*.externalAppEntry = */ ui::external_app::aprs_tx::initialize_app,
+    /*.header_version = */ CURRENT_HEADER_VERSION,
+    /*.app_version = */ VERSION_MD5,
+
+    /*.app_name = */ "APRS TX",
+    /*.bitmap_data = */ {
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0xF0,
+        0x0F,
+        0x4C,
+        0x32,
+        0xFE,
+        0x7F,
+        0x25,
+        0xA4,
+        0x25,
+        0xA4,
+        0xFF,
+        0xFF,
+        0x25,
+        0xA4,
+        0x25,
+        0xA4,
+        0xFE,
+        0x7F,
+        0x4C,
+        0x32,
+        0xF0,
+        0x0F,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+    },
+    /*.icon_color = */ ui::Color::green().v,
+    /*.menu_location = */ app_location_t::TX,
+    /*.desired_menu_position = */ -1,
+
+    /*.m4_app_tag = portapack::spi_flash::image_tag_afsk */ {'P', 'A', 'F', 'T'},
+    /*.m4_app_offset = */ 0x00000000,
+};
+
+}  // extern "C"

firmware/application/external/aprs_tx/ui_aprs_tx.cpp

@@ -37,7 +37,7 @@
 using namespace aprs;
 using namespace portapack;
 
-namespace ui {
+namespace ui::external_app::aprs_tx {
 
 void APRSTXView::focus() {
     tx_view.focus();
@@ -242,4 +242,4 @@ APRSTXView::APRSTXView(NavigationView& nav) {
     // process_coordinates(last_lat, last_lon); //don't load last, so won't confuse users
 }
 
-} /* namespace ui */
+}  // namespace ui::external_app::aprs_tx

firmware/application/external/aprs_tx/ui_aprs_tx.hpp

@@ -33,7 +33,7 @@
 #include "radio_state.hpp"
 #include "portapack.hpp"
 
-namespace ui {
+namespace ui::external_app::aprs_tx {
 
 class APRSTXView : public View {
    public:
@@ -161,4 +161,4 @@ class APRSTXView : public View {
         }};
 };
 
-} /* namespace ui */
+}  // namespace ui::external_app::aprs_tx

firmware/application/external/external.cmake

@@ -391,6 +391,26 @@ set(EXTCPPSRC
 	external/tetra_rx/tetra_rcpc.cpp
 	external/tetra_rx/tetra_viterbi.cpp
 
+	#adsb rx
+	external/adsbrx/main.cpp
+	external/adsbrx/ui_adsb_rx.cpp
+
+	#ais rx
+	external/ais_rx/main.cpp
+	external/ais_rx/ais_app.cpp
+
+	#aprs rx
+	external/aprs_rx/main.cpp
+	external/aprs_rx/ui_aprs_rx.cpp
+
+	#aprs tx
+	external/aprs_tx/main.cpp
+	external/aprs_tx/ui_aprs_tx.cpp
+
+	#sd over usb
+	external/sdusb/main.cpp
+	external/sdusb/ui_sd_over_usb.cpp
+
 )
 
 set(EXTAPPLIST
@@ -485,14 +505,9 @@ set(EXTAPPLIST
 	secplustx
   signal_hunter
 	tetra_rx
+	adsbrx
+	ais_rx
+	aprs_rx
+	aprs_tx
+	sdusb
 )
-
-# sdusb has type conflicts with PRALINE (HackRF Pro) - add only for non-PRALINE builds
-if(NOT BOARD STREQUAL "PRALINE")
-       list(APPEND EXTCPPSRC
-               external/sdusb/main.cpp
-               external/sdusb/ui_sd_over_usb.cpp
-       )
-       list(APPEND EXTAPPLIST sdusb)
-endif()
-

firmware/application/external/external.ld

@@ -115,6 +115,10 @@ MEMORY
     ram_external_app_vor_tx                (rwx) : org = 0xAE0A0000, len = 32k
     ram_external_app_signal_hunter         (rwx) : org = 0xAE0B0000, len = 32k
     ram_external_app_tetra_rx              (rwx) : org = 0xAE0C0000, len = 32k
+    ram_external_app_adsbrx                (rwx) : org = 0xAE0D0000, len = 32k
+    ram_external_app_ais_rx                (rwx) : org = 0xAE0E0000, len = 32k
+    ram_external_app_aprs_rx               (rwx) : org = 0xAE0F0000, len = 32k
+    ram_external_app_aprs_tx               (rwx) : org = 0xAE100000, len = 32k
 }
 
 SECTIONS
@@ -671,6 +675,30 @@ SECTIONS
         */external/tetra_rx/*(*ui*external_app*tetra_rx*);
     } > ram_external_app_tetra_rx
 
+    .external_app_adsbrx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_adsbrx.application_information));
+        *(*ui*external_app*adsbrx*);
+    } > ram_external_app_adsbrx
+
+    .external_app_ais_rx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_ais_rx.application_information));
+        *(*ui*external_app*ais_rx*);
+    } > ram_external_app_ais_rx
+
+    .external_app_aprs_rx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_aprs_rx.application_information));
+        *(*ui*external_app*aprs_rx*);
+    } > ram_external_app_aprs_rx
+
+    .external_app_aprs_tx : ALIGN(4) SUBALIGN(4)
+    {
+        KEEP(*(.external_app.app_aprs_tx.application_information));
+        *(*ui*external_app*aprs_tx*);
+    } > ram_external_app_aprs_tx
+
 
 
 }

firmware/application/external/keeloqtx/ui_keeloqtx.cpp

@@ -34,7 +34,7 @@ void KeeloqTXView::update_hop() {
 
         hop = data.btn << 28 | (apri_serial & 0xFFF) << 16 | data.counter;
     } else if (
-        data.mf_name == "DTM_Neo" || data.mf_name == "FAAC_RC,XT" || data.mf_name == "Mutanco_Mutancode" || data.mf_name == "Came_Space" || data.mf_name == "Genius_Bravo" || data.mf_name == "GSN" || data.mf_name == "Rosh" || data.mf_name == "Rossi" || data.mf_name == "Peccinin" || data.mf_name == "Steelmate" || data.mf_name == "Cardin_S449") {
+        data.mf_name == "DTM_Neo" || data.mf_name == "FAAC_RC,XT" || data.mf_name == "Mutanco_Mutancode" || data.mf_name == "Came_Space" || data.mf_name == "Genius_Bravo" || data.mf_name == "GSN" || data.mf_name == "Rosh" || data.mf_name == "Rossi" || data.mf_name == "Peccinin" || data.mf_name == "Steelmate" || data.mf_name == "Cardin_S449" || data.mf_name == "Superrollo") {
         hop = data.btn << 28 | (data.serial & 0xFFF) << 16 | data.counter;
     } else if (
         data.mf_name == "NICE_Smilo" || data.mf_name == "NICE_MHOUSE" || data.mf_name == "JCM_Tech") {
@@ -75,6 +75,12 @@ void KeeloqTXView::update_payload() {
         }
     }
 
+    if (data.mf_name == "Superrollo") {
+        text_payload.set(to_string_hex((uint64_t)(uint32_t)encrypt));
+        encode_data_gw60((uint32_t)encrypt);
+        return;
+    }
+
     payload = (uint64_t)fix << 32 | encrypt;
 
     uint64_t preview_payload = FProtoGeneral::subghz_protocol_blocks_reverse_key(payload, 64);
@@ -83,6 +89,34 @@ void KeeloqTXView::update_payload() {
     encode_data();
 }
 
+// Superrollo GW60 (HCS361) 67-bit OOK frame at Te=450us.
+void KeeloqTXView::encode_data_gw60(uint32_t hop_enc) {
+    int bits[67];
+    for (uint32_t i = 0; i < 32; i++) bits[i] = (hop_enc >> i) & 1;
+    for (uint32_t i = 0; i < 28; i++) bits[32 + i] = (data.serial >> i) & 1;
+    for (uint32_t i = 0; i < 4; i++) bits[60 + i] = (data.btn >> i) & 1;
+    bits[64] = 1;
+
+    int crc0 = 0, crc1 = 0;
+    for (uint32_t i = 0; i < 65; i++) {
+        int new_crc1 = crc0 ^ bits[i];
+        int new_crc0 = new_crc1 ^ crc1;
+        crc0 = new_crc0 & 1;
+        crc1 = new_crc1 & 1;
+    }
+    bits[65] = crc0;
+    bits[66] = crc1;
+
+    std::string s{};
+    for (int i = 0; i < 9; i++) s += "100";
+    s += "11111111110000000000";
+    for (int i = 0; i < 67; i++) s += keeloq_fragments[bits[i]];
+    for (int i = 0; i < 18; i++) s += "0";
+
+    encoded_data = s;
+    pause_duration = 0;
+}
+
 void KeeloqTXView::encode_data() {
     std::string fragments{};
 
@@ -206,9 +240,11 @@ void KeeloqTXView::start_tx() {
 
     transmitter_model.enable();
 
+    const double te_us = (data.mf_name == "Superrollo") ? 450.0 : 400.0;
+
     baseband::set_ook_data(
         bitstream_length,
-        OOK_SAMPLERATE * (400.0 / 1000000.0),
+        OOK_SAMPLERATE * (te_us / 1000000.0),
         repeat,
         pause_duration);
 }

firmware/application/external/keeloqtx/ui_keeloqtx.hpp

@@ -106,6 +106,7 @@ class KeeloqTXView : public View {
     std::string encoded_data{};
 
     void encode_data();
+    void encode_data_gw60(uint32_t hop_enc);
 
     uint32_t repeat = 4;
     uint32_t pause_duration = 0;

firmware/application/external/sdusb/ui_sd_over_usb.cpp

@@ -46,7 +46,7 @@ SdOverUsbView::SdOverUsbView(NavigationView& nav)
         sdcStop(&SDCD1);
 
         portapack::shutdown(true, false);
-        baseband::run_prepared_image(portapack::memory::map::m4_code.base());
+        baseband::run_prepared_image(portapack::memory::map::m4_code.base(), false);
         m0_halt();
         /* will not return*/
     };

firmware/application/receiver_model.cpp

@@ -88,6 +88,15 @@ void ReceiverModel::set_target_frequency(rf::Frequency f) {
     update_tuning_frequency();
 }
 
+void ReceiverModel::set_target_frequency_with_hidden_offset(
+    rf::Frequency f,
+    rf::Frequency offset) {
+    persistent_memory::set_target_frequency(f);
+    settings_.frequency_app_override = f;
+    hidden_offset = offset;
+    update_tuning_frequency();
+}
+
 uint32_t ReceiverModel::baseband_bandwidth() const {
     return settings_.baseband_bandwidth;
 }

firmware/application/receiver_model.hpp

@@ -66,6 +66,7 @@ class ReceiverModel {
     /* The frequency to receive (no offset). */
     rf::Frequency target_frequency() const;
     void set_target_frequency(rf::Frequency f);
+    void set_target_frequency_with_hidden_offset(rf::Frequency f, rf::Frequency offset);
 
     uint32_t baseband_bandwidth() const;
     void set_baseband_bandwidth(uint32_t v);

firmware/application/ui/ui_freq_field.hpp

@@ -39,6 +39,8 @@ class BoundFrequencyField : public FrequencyField {
 
    public:
     decltype(FrequencyField::on_change) updated{};
+    std::function<bool(rf::Frequency)> changing{};
+    std::function<void(rf::Frequency)> entered{};
 
     BoundFrequencyField(Point parent_pos, NavigationView& nav)
         : FrequencyField(parent_pos) {
@@ -47,7 +49,8 @@ class BoundFrequencyField : public FrequencyField {
         set_value(model->target_frequency());
 
         on_change = [this](rf::Frequency f) {
-            model->set_target_frequency(f);
+            if (!changing || !changing(f))
+                model->set_target_frequency(f);
             if (updated)
                 updated(f);
         };
@@ -57,7 +60,10 @@ class BoundFrequencyField : public FrequencyField {
                 on_edit_shown();
             auto freq_view = nav.push<FrequencyKeypadView>(model->target_frequency());
             freq_view->on_changed = [this](rf::Frequency f) {
-                set_value(f);
+                if (entered)
+                    entered(f);
+                else
+                    set_value(f);
             };
             nav.set_on_pop([this]() {
                 if (on_edit_hidden)
@@ -76,4 +82,4 @@ using TxFrequencyField = BoundFrequencyField<TransmitterModel, &portapack::trans
 
 }  // namespace ui
 
-#endif  // __UI_FREQ_FIELD_H__
+#endif  // __UI_FREQ_FIELD_H__

firmware/application/ui/ui_geomap.cpp

@@ -46,10 +46,12 @@ GeoPos::GeoPos(
                   &field_speed,
                   &text_alt_unit,
                   &text_speed_unit,
+                  &field_lat_hemisphere,
                   &field_lat_degrees,
                   &field_lat_minutes,
                   &field_lat_seconds,
                   &text_lat_decimal,
+                  &field_lon_hemisphere,
                   &field_lon_degrees,
                   &field_lon_minutes,
                   &field_lon_seconds,
@@ -73,8 +75,14 @@ GeoPos::GeoPos(
             on_change(altitude(), lat_value, lon_value, speed());
     };
 
+    const auto changed_hemisphere_fn = [changed_fn](size_t, OptionsField::value_t) {
+        changed_fn(0);
+    };
+
     field_altitude.on_change = changed_fn;
     field_speed.on_change = changed_fn;
+    field_lat_hemisphere.on_change = changed_hemisphere_fn;
+    field_lon_hemisphere.on_change = changed_hemisphere_fn;
     field_lat_degrees.on_change = changed_fn;
     field_lat_minutes.on_change = changed_fn;
     field_lat_seconds.on_change = changed_fn;
@@ -83,19 +91,37 @@ GeoPos::GeoPos(
     field_lon_seconds.on_change = changed_fn;
 
     const auto wrapped_lat_seconds = [this](int32_t v) {
+        const auto old_minutes = field_lat_minutes.value();
         field_lat_minutes.on_encoder(v);
+        if (field_lat_minutes.value() == old_minutes) {
+            field_lat_seconds.set_value((v > 0) ? 59 : 0);
+        }
     };
 
+    // Degrees now holds a magnitude, so a minutes wrap always carries in the
+    // same direction regardless of hemisphere.
     const auto wrapped_lat_minutes = [this](int32_t v) {
-        field_lat_degrees.on_encoder((field_lat_degrees.value() >= 0) ? v : -v);
+        const auto old_degrees = field_lat_degrees.value();
+        field_lat_degrees.on_encoder(v);
+        if (field_lat_degrees.value() == old_degrees) {
+            field_lat_minutes.set_value((v > 0) ? 59 : 0);
+        }
     };
 
     const auto wrapped_lon_seconds = [this](int32_t v) {
+        const auto old_minutes = field_lon_minutes.value();
         field_lon_minutes.on_encoder(v);
+        if (field_lon_minutes.value() == old_minutes) {
+            field_lon_seconds.set_value((v > 0) ? 59 : 0);
+        }
     };
 
     const auto wrapped_lon_minutes = [this](int32_t v) {
-        field_lon_degrees.on_encoder((field_lon_degrees.value() >= 0) ? v : -v);
+        const auto old_degrees = field_lon_degrees.value();
+        field_lon_degrees.on_encoder(v);
+        if (field_lon_degrees.value() == old_degrees) {
+            field_lon_minutes.set_value((v > 0) ? 59 : 0);
+        }
     };
 
     field_lat_seconds.on_wrap = wrapped_lat_seconds;
@@ -146,31 +172,31 @@ void GeoPos::set_speed(int32_t speed) {
 }
 
 void GeoPos::set_lat(float lat) {
-    field_lat_degrees.set_value(lat);
-    field_lat_minutes.set_value((uint32_t)abs(lat / (1.0 / 60)) % 60);
-    field_lat_seconds.set_value((uint32_t)abs(lat / (1.0 / 3600)) % 60);
+    bool south = lat < 0;
+    float magnitude = south ? -lat : lat;
+    field_lat_hemisphere.set_by_value(south ? 1 : 0);
+    field_lat_degrees.set_value((int32_t)magnitude);
+    field_lat_minutes.set_value((uint32_t)(magnitude * 60) % 60);
+    field_lat_seconds.set_value((uint32_t)(magnitude * 3600) % 60);
 }
 
 void GeoPos::set_lon(float lon) {
-    field_lon_degrees.set_value(lon);
-    field_lon_minutes.set_value((uint32_t)abs(lon / (1.0 / 60)) % 60);
-    field_lon_seconds.set_value((uint32_t)abs(lon / (1.0 / 3600)) % 60);
+    bool west = lon < 0;
+    float magnitude = west ? -lon : lon;
+    field_lon_hemisphere.set_by_value(west ? 1 : 0);
+    field_lon_degrees.set_value((int32_t)magnitude);
+    field_lon_minutes.set_value((uint32_t)(magnitude * 60) % 60);
+    field_lon_seconds.set_value((uint32_t)(magnitude * 3600) % 60);
 }
 
 float GeoPos::lat() {
-    if (field_lat_degrees.value() < 0) {
-        return -1 * (-1 * field_lat_degrees.value() + (field_lat_minutes.value() / 60.0) + (field_lat_seconds.value() / 3600.0));
-    } else {
-        return field_lat_degrees.value() + (field_lat_minutes.value() / 60.0) + (field_lat_seconds.value() / 3600.0);
-    }
+    float magnitude = field_lat_degrees.value() + (field_lat_minutes.value() / 60.0) + (field_lat_seconds.value() / 3600.0);
+    return (field_lat_hemisphere.selected_index_value() != 0) ? -magnitude : magnitude;
 };
 
 float GeoPos::lon() {
-    if (field_lon_degrees.value() < 0) {
-        return -1 * (-1 * field_lon_degrees.value() + (field_lon_minutes.value() / 60.0) + (field_lon_seconds.value() / 3600.0));
-    } else {
-        return field_lon_degrees.value() + (field_lon_minutes.value() / 60.0) + (field_lon_seconds.value() / 3600.0);
-    }
+    float magnitude = field_lon_degrees.value() + (field_lon_minutes.value() / 60.0) + (field_lon_seconds.value() / 3600.0);
+    return (field_lon_hemisphere.selected_index_value() != 0) ? -magnitude : magnitude;
 };
 
 int32_t GeoPos::altitude() {

firmware/application/ui/ui_geomap.hpp

@@ -239,12 +239,21 @@ class GeoPos : public View {
         {25 * 8, UI_POS_Y(0), 5 * 8, 16},
         ""};
 
-    NumberField field_lat_degrees{
+    // Sign is held by the hemisphere field, not by the degrees field: an
+    // int32_t degrees field has no negative zero, so a coordinate in
+    // (-1, 0) could not otherwise be represented (see issue #3234).
+    OptionsField field_lat_hemisphere{
         {5 * 8, 1 * 16},
-        4,
-        {-90, 90},
         1,
-        ' '};
+        {{"N", 0},
+         {"S", 1}}};
+    NumberField field_lat_degrees{
+        {6 * 8, 1 * 16},
+        3,
+        {0, 90},
+        1,
+        ' ',
+        false};
     NumberField field_lat_minutes{
         {10 * 8, 1 * 16},
         2,
@@ -263,12 +272,18 @@ class GeoPos : public View {
         {17 * 8, 1 * 16, 13 * 8, 1 * 16},
         ""};
 
-    NumberField field_lon_degrees{
+    OptionsField field_lon_hemisphere{
         {5 * 8, 2 * 16},
-        4,
-        {-180, 180},
         1,
-        ' '};
+        {{"E", 0},
+         {"W", 1}}};
+    NumberField field_lon_degrees{
+        {6 * 8, 2 * 16},
+        3,
+        {0, 180},
+        1,
+        ' ',
+        false};
     NumberField field_lon_minutes{
         {10 * 8, 2 * 16},
         2,

firmware/application/ui/ui_spectrum.cpp

@@ -88,16 +88,29 @@ void FrequencyScale::set_spectrum_sampling_rate(const int new_sampling_rate) {
 }
 
 void FrequencyScale::set_channel_filter(
+    const int offset,
     const int low_frequency,
     const int high_frequency,
     const int transition) {
-    if ((channel_filter_low_frequency != low_frequency) ||
+    const bool shape_changed =
+        (channel_filter_low_frequency != low_frequency) ||
         (channel_filter_high_frequency != high_frequency) ||
-        (channel_filter_transition != transition)) {
+        (channel_filter_transition != transition);
+    const bool offset_changed = channel_filter_offset != offset;
+
+    if (shape_changed) {
+        channel_filter_offset = offset;
         channel_filter_low_frequency = low_frequency;
         channel_filter_high_frequency = high_frequency;
         channel_filter_transition = transition;
         set_dirty();
+    } else if (offset_changed) {
+        const auto old_offset = channel_filter_offset;
+        channel_filter_offset = offset;
+        if (live_tuning && spectrum_sampling_rate && drawn())
+            redraw_filter_cursor(old_offset);
+        else
+            set_dirty();
     }
 }
 
@@ -123,12 +136,14 @@ void FrequencyScale::paint(Painter& painter) {
     draw_filter_ranges(painter, r);
     draw_frequency_ticks(painter, r);
 
-    const Rect r_cursor{
-        (screen_width / 2 - 2) + cursor_position, r.bottom() - filter_band_height,
-        5, filter_band_height};
-    painter.fill_rectangle(
-        r_cursor,
-        Color::red());
+    if (!live_tuning) {
+        const Rect r_cursor{
+            (screen_width / 2 - 2) + cursor_position, r.bottom() - filter_band_height,
+            5, filter_band_height};
+        painter.fill_rectangle(
+            r_cursor,
+            Color::red());
+    }
 }
 
 void FrequencyScale::clear() {
@@ -184,9 +199,79 @@ void FrequencyScale::draw_frequency_ticks(Painter& painter, const Rect r) {
     }
 }
 
+void FrequencyScale::redraw_filter_cursor(const int old_offset) {
+    const auto r = screen_rect();
+    const auto x_center = r.width() / 2;
+    const auto trans =
+        channel_filter_transition * spectrum_bins / spectrum_sampling_rate;
+
+    const auto cursor_left = [&](const int offset) {
+        return r.left() + x_center +
+               (offset + channel_filter_low_frequency) *
+                   spectrum_bins / spectrum_sampling_rate -
+               trans;
+    };
+    const auto cursor_right = [&](const int offset) {
+        return r.left() + x_center +
+               (offset + channel_filter_high_frequency) *
+                   spectrum_bins / spectrum_sampling_rate +
+               trans;
+    };
+
+    const auto dirty_left =
+        std::min(cursor_left(old_offset), cursor_left(channel_filter_offset)) - 1;
+    const auto dirty_right =
+        std::max(cursor_right(old_offset), cursor_right(channel_filter_offset)) + 1;
+    const Rect dirty{
+        dirty_left,
+        r.bottom() - filter_band_height,
+        dirty_right - dirty_left,
+        filter_band_height};
+
+    Painter painter;
+    painter.fill_rectangle(dirty, Theme::getInstance()->bg_darkest->background);
+    draw_filter_ranges(painter, r);
+    restore_tick_lines(painter, r, dirty);
+}
+
+void FrequencyScale::restore_tick_lines(
+    Painter& painter,
+    const Rect r,
+    const Rect dirty) {
+    const auto draw_if_dirty = [&](const Coord x) {
+        if (x >= dirty.left() && x < dirty.right()) {
+            painter.fill_rectangle(
+                {x, dirty.top(), 1, dirty.height()},
+                Theme::getInstance()->bg_darkest->foreground);
+        }
+    };
+
+    const auto x_center = r.left() + r.width() / 2;
+    draw_if_dirty(x_center);
+
+    constexpr int tick_count_max = 4;
+    float rough_tick_interval = float(spectrum_sampling_rate) / tick_count_max;
+    int magnitude = 1;
+    while (rough_tick_interval >= 10.0f) {
+        rough_tick_interval /= 10;
+        magnitude *= 10;
+    }
+
+    const int tick_interval = std::ceil(rough_tick_interval);
+    auto tick_offset = tick_interval;
+    while ((tick_offset * magnitude) < spectrum_sampling_rate / 2) {
+        const Dim pixel_offset =
+            tick_offset * magnitude * spectrum_bins / spectrum_sampling_rate;
+        draw_if_dirty(x_center - pixel_offset);
+        draw_if_dirty(x_center + pixel_offset);
+        tick_offset += tick_interval;
+    }
+}
+
 void FrequencyScale::draw_filter_ranges(Painter& painter, const Rect r) {
     if (channel_filter_low_frequency != channel_filter_high_frequency) {
-        const auto x_center = r.width() / 2;
+        const auto x_center = r.width() / 2 +
+                              channel_filter_offset * spectrum_bins / spectrum_sampling_rate;
 
         const auto x_low = x_center + channel_filter_low_frequency * spectrum_bins / spectrum_sampling_rate;
         const auto x_high = x_center + channel_filter_high_frequency * spectrum_bins / spectrum_sampling_rate;
@@ -220,6 +305,11 @@ void FrequencyScale::on_blur() {
 }
 
 bool FrequencyScale::on_encoder(const EncoderEvent delta) {
+    if (live_tuning) {
+        if (on_select) on_select(delta);
+        return true;
+    }
+
     cursor_position += delta;
 
     cursor_position = std::min<int32_t>(cursor_position, screen_width / 2 - 1);
@@ -326,9 +416,11 @@ WaterfallView::WaterfallView(const bool cursor) {
         frequency_scale.focus();  // focus on frequency scale to show cursor
 
         if (sampling_rate) {
-            // screen x to frequency scale x, NB we need two widgets align
-            int32_t cursor_position = x - (screen_width / 2);
-            frequency_scale.set_cursor_position(cursor_position);
+            const int32_t cursor_position = x - (screen_width / 2);
+            if (!frequency_scale.is_live_tuning()) {
+                // screen x to frequency scale x, NB we need two widgets align
+                frequency_scale.set_cursor_position(cursor_position);
+            }
         }
     };
 
@@ -405,6 +497,7 @@ void WaterfallView::on_channel_spectrum(const ChannelSpectrum& spectrum) {
     sampling_rate = spectrum.sampling_rate;
     frequency_scale.set_spectrum_sampling_rate(sampling_rate);
     frequency_scale.set_channel_filter(
+        spectrum.channel_filter_offset,
         spectrum.channel_filter_low_frequency,
         spectrum.channel_filter_high_frequency,
         spectrum.channel_filter_transition);

firmware/application/ui/ui_spectrum.hpp

@@ -72,6 +72,8 @@ class AudioSpectrumView : public View {
 
 class FrequencyScale : public Widget {
    public:
+    /* Receives a frequency offset in Hz for key/touch selection. With live
+     * tuning enabled, encoder events instead pass the raw encoder delta. */
     std::function<void(int32_t offset)> on_select{};
 
     void on_show() override;
@@ -83,8 +85,10 @@ class FrequencyScale : public Widget {
     bool on_touch(const TouchEvent touch) override;
 
     void set_spectrum_sampling_rate(const int new_sampling_rate);
-    void set_channel_filter(const int low_frequency, const int high_frequency, const int transition);
+    void set_channel_filter(const int offset, const int low_frequency, const int high_frequency, const int transition);
     void set_cursor_position(const int32_t position);
+    void set_live_tuning(const bool enabled) { live_tuning = enabled; }
+    bool is_live_tuning() const { return live_tuning; }
 
     void paint(Painter& painter) override;
 
@@ -94,15 +98,19 @@ class FrequencyScale : public Widget {
     int32_t cursor_position{0};
     int spectrum_sampling_rate{0};
     const int spectrum_bins = std::tuple_size<decltype(ChannelSpectrum::db)>::value;
+    int channel_filter_offset{0};
     int channel_filter_low_frequency{0};
     int channel_filter_high_frequency{0};
     int channel_filter_transition{0};
+    bool live_tuning{false};
 
     void clear();
     void clear_background(Painter& painter, const Rect r);
 
     void draw_frequency_ticks(Painter& painter, const Rect r);
     void draw_filter_ranges(Painter& painter, const Rect r);
+    void redraw_filter_cursor(const int old_offset);
+    void restore_tick_lines(Painter& painter, const Rect r, const Rect dirty);
 };
 
 /* NB: These visualizations rely on having a baseband image running.
@@ -147,6 +155,7 @@ class WaterfallView : public View {
     void set_parent_rect(const Rect new_parent_rect) override;
     void show_audio_spectrum_view(const bool show);
     void load_gradient();
+    void set_live_tuning(const bool enabled) { frequency_scale.set_live_tuning(enabled); }
 
    private:
     void update_widgets_rect();

firmware/application/ui_navigation.cpp

@@ -30,9 +30,6 @@
 #include "portapack.hpp"
 
 #include "ui_about_simple.hpp"
-#include "ui_adsb_rx.hpp"
-#include "ui_aprs_rx.hpp"
-#include "ui_aprs_tx.hpp"
 #include "ui_btle_rx.hpp"
 #include "ui_debug.hpp"
 #include "ui_encoders.hpp"
@@ -60,7 +57,6 @@
 #include "ui_battinfo.hpp"
 #include "ui_external_items_menu_loader.hpp"
 
-#include "ais_app.hpp"
 #include "analog_audio_app.hpp"
 #include "ble_rx_app.hpp"
 #include "ble_tx_app.hpp"
@@ -99,9 +95,6 @@ const NavigationView::AppList NavigationView::appList = {
     {nullptr, "Games", HOME, Color::cyan(), &bitmap_icon_games, new ViewFactory<GamesMenuView>()},
     {nullptr, "Settings", HOME, Color::cyan(), &bitmap_icon_setup, new ViewFactory<SettingsMenuView>()},
     /* RX ********************************************************************/
-    {"adsbrx", "ADS-B", RX, Color::green(), &bitmap_icon_adsb, new ViewFactory<ADSBRxView>()},
-    {"ais", "AIS Boats", RX, Color::green(), &bitmap_icon_ais, new ViewFactory<AISAppView>()},
-    {"aprsrx", "APRS", RX, Color::green(), &bitmap_icon_aprs, new ViewFactory<APRSRXView>()},
     {"audio", "Audio", RX, Color::green(), &bitmap_icon_speaker, new ViewFactory<AnalogAudioView>()},
     {"blerx", "BLE Rx", RX, Color::green(), &bitmap_icon_btle, new ViewFactory<BLERxView>()},
     {"pocsag", "POCSAG", RX, Color::green(), &bitmap_icon_pocsag, new ViewFactory<POCSAGAppView>()},
@@ -110,7 +103,6 @@ const NavigationView::AppList NavigationView::appList = {
     {"subghzd", "SubGhzD", RX, Color::yellow(), &bitmap_icon_remote, new ViewFactory<SubGhzDView>()},
     {"weather", "Weather", RX, Color::green(), &bitmap_icon_thermometer, new ViewFactory<WeatherView>()},
     /* TX ********************************************************************/
-    {"aprstx", "APRS TX", TX, ui::Color::green(), &bitmap_icon_aprs, new ViewFactory<APRSTXView>()},
     {"bletx", "BLE Tx", TX, ui::Color::green(), &bitmap_icon_btle, new ViewFactory<BLETxView>()},
     {"ooktx", "OOK", TX, ui::Color::yellow(), &bitmap_icon_remote, new ViewFactory<EncodersView>()},
     {"rdstx", "RDS", TX, ui::Color::green(), &bitmap_icon_rds, new ViewFactory<RDSView>()},

firmware/baseband/CMakeLists.txt

@@ -124,6 +124,7 @@ set(CPPSRC
 	dsp_goertzel.cpp
 	matched_filter.cpp
 	spectrum_collector.cpp
+	filtered_spectrum_collector.cpp
 	tv_collector.cpp
 	stream_input.cpp
 	stream_output.cpp
@@ -747,13 +748,6 @@ set(MODE_CPPSRC
 )
 DeclareTargets(PRTT rtty_tx)
 
-### SD over USB
-
-set(MODE_INCDIR
-	${HACKRF_PATH}/firmware
-	${HACKRF_PATH}/firmware/common
-	${HACKRF_PATH}/firmware/libopencm3/include
-)
 
 ### Morse TX
 
@@ -793,6 +787,15 @@ set(MODE_CPPSRC
 )
 DeclareTargets(PTET tetra_rx)
 
+### SD over USB
+
+set(MODE_INCDIR
+	${HACKRF_PATH}/firmware
+	${HACKRF_PATH}/firmware/common
+	${HACKRF_PATH}/firmware/libopencm3/include
+	${HACKRF_PATH}/firmware/hackrf_usb
+	sd_over_usb/
+)
 
 set(MODE_CPPSRC
 	sd_over_usb/proc_sd_over_usb.cpp
@@ -801,7 +804,9 @@ set(MODE_CPPSRC
 	sd_over_usb/diskio.c
 	sd_over_usb/sd_over_usb.c
 	sd_over_usb/usb_descriptor.c
-	sd_over_usb/hackrf_core.c
+	sd_over_usb/usb_api_transceiver.c
+	sd_over_usb/cpu_clock.c
+	sd_over_usb/pins.c
 
 	${HACKRF_PATH}/firmware/common/adc.c
 	${HACKRF_PATH}/firmware/common/selftest.c
@@ -828,6 +833,15 @@ set(MODE_CPPSRC
 	${HACKRF_PATH}/firmware/common/rffc5071_spi.c
 	${HACKRF_PATH}/firmware/common/rffc5071.c
 	${HACKRF_PATH}/firmware/common/gpdma.c
+	${HACKRF_PATH}/firmware/common/clock_gen.c
+	${HACKRF_PATH}/firmware/common/cpld_jtag.c
+	${HACKRF_PATH}/firmware/common/leds.c
+	${HACKRF_PATH}/firmware/common/power.c
+	${HACKRF_PATH}/firmware/common/clock_io.c
+	${HACKRF_PATH}/firmware/common/rom_iap.c
+	${HACKRF_PATH}/firmware/common/w25q80bv.c
+	${HACKRF_PATH}/firmware/common/w25q80bv_target.c
+	
 
 	${HACKRF_PATH}/firmware/libopencm3/lib/cm3/nvic.c
 	${HACKRF_PATH}/firmware/libopencm3/lib/cm3/sync.c
@@ -835,10 +849,7 @@ set(MODE_CPPSRC
 	${HACKRF_PATH}/firmware/libopencm3/lib/lpc43xx/timer.c
 	${HACKRF_PATH}/firmware/libopencm3/lib/lpc43xx/i2c.c
 )
-# sd_over_usb has type conflicts with PRALINE (HackRF Pro) - disable for now
-if(NOT BOARD STREQUAL "PRALINE")
 DeclareTargets(PUSB sd_over_usb)
-endif()
 
 
 ### HackRF "factory" firmware

firmware/baseband/dsp_decimate.cpp

@@ -337,6 +337,66 @@ buffer_c16_t FIRC16xR16x16Decim2::execute(
         src.sampling_rate / decimation_factor};
 }
 
+// FIRC16xR16x63HalfbandDecim2 ////////////////////////////////////////////
+
+void FIRC16xR16x63HalfbandDecim2::configure(
+    const std::array<int16_t, taps_count>& taps) {
+    std::copy(taps.cbegin(), taps.cend(), taps_.begin());
+    reset();
+}
+
+void FIRC16xR16x63HalfbandDecim2::reset() {
+    samples_.fill({});
+    samples_head_ = 0;
+}
+
+buffer_c16_t FIRC16xR16x63HalfbandDecim2::execute(
+    const buffer_c16_t& src,
+    const buffer_c16_t& dst) {
+    auto* dst_p = reinterpret_cast<uint32_t*>(dst.p);
+
+    for (size_t output = 0; output < src.count / decimation_factor; ++output) {
+        for (size_t i = 0; i < decimation_factor; ++i) {
+            const auto sample = src.p[output * decimation_factor + i];
+            samples_[samples_head_] = sample;
+            samples_[samples_head_ + taps_count] = sample;
+            if (++samples_head_ == taps_count)
+                samples_head_ = 0;
+        }
+
+        int64_t real = 0;
+        int64_t imag = 0;
+        for (size_t tap = 0; tap < taps_count; tap += 4) {
+            const auto sample_0 =
+                *reinterpret_cast<const uint32_t*>(&samples_[samples_head_ + tap]);
+            const auto sample_1 =
+                *reinterpret_cast<const uint32_t*>(&samples_[samples_head_ + tap + 2]);
+            const auto real_pair = __PKHBT(sample_0, sample_1, 16);
+            const auto imag_pair = __PKHTB(sample_1, sample_0, 16);
+            const auto taps_pair = uint32_t(uint16_t(taps_[tap])) |
+                                   (uint32_t(uint16_t(taps_[tap + 2])) << 16);
+            real = __SMLALD(real_pair, taps_pair, real);
+            imag = __SMLALD(imag_pair, taps_pair, imag);
+        }
+
+        const auto center =
+            *reinterpret_cast<const uint32_t*>(&samples_[samples_head_ + taps_count / 2]);
+        real += int16_t(center) * taps_[taps_count / 2];
+        imag += int16_t(center >> 16) * taps_[taps_count / 2];
+
+        const auto real_s16 =
+            __SSAT((real + (real >= 0 ? 32768 : -32768)) / 65536, 16);
+        const auto imag_s16 =
+            __SSAT((imag + (imag >= 0 ? 32768 : -32768)) / 65536, 16);
+        *(dst_p++) = __PKHBT(real_s16, imag_s16, 16);
+    }
+
+    return {
+        dst.p,
+        src.count / decimation_factor,
+        src.sampling_rate / decimation_factor};
+}
+
 // FIRC16xR16x32Decim8 ////////////////////////////////////////////////////
 
 void FIRC16xR16x32Decim8::configure(
@@ -625,10 +685,13 @@ buffer_s16_t FIR64AndDecimateBy2Real::execute(
 void FIRAndDecimateComplex::configure_common(
     const size_t taps_count,
     const size_t decimation_factor) {
-    samples_ = std::make_unique<samples_t>(taps_count);
+    /* Mirror the delay line so a convolution always sees one contiguous
+     * taps_count window, even when the logical head wraps. */
+    samples_ = std::make_unique<samples_t>(taps_count * 2);
     taps_reversed_ = std::make_unique<taps_t>(taps_count);
     taps_count_ = taps_count;
     decimation_factor_ = decimation_factor;
+    samples_head_ = 0;
 }
 
 buffer_c16_t FIRAndDecimateComplex::execute(
@@ -647,15 +710,18 @@ buffer_c16_t FIRAndDecimateComplex::execute(
     const void* src_p = src.p;
     size_t outer_count = output_samples;
     while (outer_count > 0) {
-        /* Put new samples into delay buffer */
-        void* z_new_p = &samples_[taps_count_ - decimation_factor_];
+        /* Put new samples into both halves of the mirrored ring. */
         for (size_t i = 0; i < decimation_factor_; i++) {
-            *__SIMD32(z_new_p)++ = *__SIMD32(src_p)++;
+            const uint32_t sample = *__SIMD32(src_p)++;
+            *reinterpret_cast<uint32_t*>(&samples_[samples_head_]) = sample;
+            *reinterpret_cast<uint32_t*>(&samples_[samples_head_ + taps_count_]) = sample;
+            if (++samples_head_ == taps_count_)
+                samples_head_ = 0;
         }
 
         size_t loop_count = taps_count_ / 8;
         void* t_p = &taps_reversed_[0];
-        void* z_p = &samples_[0];
+        void* z_p = &samples_[samples_head_];
 
         int64_t t_real = 0;
         int64_t t_imag = 0;
@@ -712,27 +778,6 @@ buffer_c16_t FIRAndDecimateComplex::execute(
             i_sat,
             16);
 
-        /* Shift sample buffer left/down by decimation factor. */
-        const size_t unroll_factor = 4;
-        size_t shift_count = (taps_count_ - decimation_factor_) / unroll_factor;
-
-        void* t = &samples_[0];
-        const void* s = &samples_[decimation_factor_];
-
-        while (shift_count > 0) {
-            *__SIMD32(t)++ = *__SIMD32(s)++;
-            *__SIMD32(t)++ = *__SIMD32(s)++;
-            *__SIMD32(t)++ = *__SIMD32(s)++;
-            *__SIMD32(t)++ = *__SIMD32(s)++;
-            shift_count--;
-        }
-
-        shift_count = (taps_count_ - decimation_factor_) % unroll_factor;
-        while (shift_count > 0) {
-            *__SIMD32(t)++ = *__SIMD32(s)++;
-            shift_count--;
-        }
-
         outer_count--;
     }
 

firmware/baseband/dsp_decimate.hpp

@@ -170,6 +170,24 @@ class FIRC16xR16x16Decim2 {
     int32_t output_scale = 0;
 };
 
+class FIRC16xR16x63HalfbandDecim2 {
+   public:
+    static constexpr size_t taps_count = 63;
+    static constexpr size_t decimation_factor = 2;
+
+    void configure(const std::array<int16_t, taps_count>& taps);
+    void reset();
+
+    buffer_c16_t execute(
+        const buffer_c16_t& src,
+        const buffer_c16_t& dst);
+
+   private:
+    alignas(4) std::array<complex16_t, taps_count * 2> samples_{};
+    alignas(4) std::array<int16_t, taps_count> taps_{};
+    size_t samples_head_{0};
+};
+
 class FIRC16xR16x32Decim8 {
    public:
     static constexpr size_t taps_count = 32;
@@ -210,6 +228,23 @@ class FIRAndDecimateComplex {
         configure(taps.data(), taps.size(), decimation_factor);
     }
 
+    template <size_t N>
+    void configure(
+        const std::array<int16_t, N>& taps,
+        const size_t decimation_factor) {
+        configure_common(N, decimation_factor);
+        for (size_t i = 0; i < N; ++i) {
+            taps_reversed_[i] = {taps[N - 1 - i], 0};
+        }
+    }
+
+    template <size_t N>
+    void set_taps(const std::array<complex16_t, N>& taps) {
+        if (N == taps_count_) {
+            std::reverse_copy(taps.begin(), taps.end(), &taps_reversed_[0]);
+        }
+    }
+
     buffer_c16_t execute(
         const buffer_c16_t& src,
         const buffer_c16_t& dst);
@@ -221,6 +256,7 @@ class FIRAndDecimateComplex {
     std::unique_ptr<taps_t> taps_reversed_{};
     size_t taps_count_{0};
     size_t decimation_factor_{1};
+    size_t samples_head_{0};
 
     template <typename T>
     void configure(

firmware/baseband/dsp_frequency_xlator.hpp

@@ -0,0 +1,472 @@
+/*
+ * Copyright (C) 2026
+ *
+ * This file is part of PortaPack.
+ */
+
+#ifndef __DSP_FREQUENCY_XLATOR_H__
+#define __DSP_FREQUENCY_XLATOR_H__
+
+#include "dsp_decimate.hpp"
+#include "dsp_types.hpp"
+
+#include <array>
+#include <cstdint>
+
+namespace dsp {
+
+/* Fixed-point complex mixer for the Audio RX channelizer. */
+class FrequencyTranslator {
+   public:
+    FrequencyTranslator() {
+        for (size_t i = 0; i < oscillator_q15_.size(); ++i) {
+            oscillator_q15_[i] =
+                static_cast<uint16_t>(sine_q15_[static_cast<uint8_t>(i + 64)]) |
+                (static_cast<uint32_t>(
+                     static_cast<uint16_t>(sine_q15_[i]))
+                 << 16);
+        }
+    }
+
+    void set_sample_rate(const uint32_t sampling_rate) {
+        sampling_rate_ = sampling_rate;
+        update_phase_increment();
+    }
+
+    void set_frequency(const int32_t frequency) {
+        frequency_ = frequency;
+        update_phase_increment();
+    }
+
+    buffer_c16_t execute(const buffer_c16_t& src, const buffer_c16_t& dst) {
+        auto phase = phase_;
+        for (size_t i = 0; i < src.count; ++i) {
+            const uint8_t index = phase >> 24;
+            const uint8_t next = index + 1;
+            const int32_t fraction = (phase >> 16) & 0xff;
+            const uint32_t oscillator_first = oscillator_q15_[index];
+            const uint32_t oscillator_next = oscillator_q15_[next];
+            const int32_t sine_first =
+                static_cast<int16_t>(oscillator_first >> 16);
+            const int32_t cosine_first =
+                static_cast<int16_t>(oscillator_first);
+            const int32_t sine =
+                sine_first +
+                (((static_cast<int16_t>(oscillator_next >> 16) -
+                   sine_first) *
+                  fraction) >>
+                 8);
+            const int32_t cosine =
+                cosine_first +
+                (((static_cast<int16_t>(oscillator_next) -
+                   cosine_first) *
+                  fraction) >>
+                 8);
+            const uint32_t oscillator =
+                static_cast<uint16_t>(cosine) |
+                (static_cast<uint32_t>(
+                     static_cast<uint16_t>(sine))
+                 << 16);
+            const uint32_t sample =
+                *reinterpret_cast<const uint32_t*>(&src.p[i]);
+
+            /* Two packed dual-16-bit multiplies implement
+             * (I+jQ) * (cos-j sin). */
+            const int32_t out_i =
+                rounded_shift(__SMUAD(sample, oscillator), 15);
+            const int32_t out_q =
+                rounded_shift(__SMUSDX(oscillator, sample), 15);
+            *reinterpret_cast<uint32_t*>(&dst.p[i]) =
+                __PKHBT(__SSAT(out_i, 16), __SSAT(out_q, 16), 16);
+            phase += phase_increment_;
+        }
+        phase_ = phase;
+        return {dst.p, src.count, src.sampling_rate};
+    }
+
+   private:
+    friend class FrequencyTranslatingDecimator32By8;
+
+    static constexpr int32_t rounded_shift(
+        const int32_t value,
+        const uint32_t bits) {
+        const int32_t rounding = int32_t{1} << (bits - 1);
+        return value >= 0
+                   ? (value + rounding) >> bits
+                   : -((-value + rounding) >> bits);
+    }
+
+    void update_phase_increment() {
+        if (sampling_rate_) {
+            phase_increment_ = static_cast<uint32_t>(
+                (static_cast<int64_t>(frequency_) * (int64_t{1} << 32)) /
+                sampling_rate_);
+        }
+    }
+
+    static constexpr std::array<int16_t, 256> sine_q15_{{
+        0,
+        804,
+        1608,
+        2410,
+        3212,
+        4011,
+        4808,
+        5602,
+        6393,
+        7179,
+        7962,
+        8739,
+        9512,
+        10278,
+        11039,
+        11793,
+        12539,
+        13279,
+        14010,
+        14732,
+        15446,
+        16151,
+        16846,
+        17530,
+        18204,
+        18868,
+        19519,
+        20159,
+        20787,
+        21403,
+        22005,
+        22594,
+        23170,
+        23731,
+        24279,
+        24811,
+        25329,
+        25832,
+        26319,
+        26790,
+        27245,
+        27683,
+        28105,
+        28510,
+        28898,
+        29268,
+        29621,
+        29956,
+        30273,
+        30571,
+        30852,
+        31113,
+        31356,
+        31580,
+        31785,
+        31971,
+        32137,
+        32285,
+        32412,
+        32521,
+        32609,
+        32678,
+        32728,
+        32757,
+        32767,
+        32757,
+        32728,
+        32678,
+        32609,
+        32521,
+        32412,
+        32285,
+        32137,
+        31971,
+        31785,
+        31580,
+        31356,
+        31113,
+        30852,
+        30571,
+        30273,
+        29956,
+        29621,
+        29268,
+        28898,
+        28510,
+        28105,
+        27683,
+        27245,
+        26790,
+        26319,
+        25832,
+        25329,
+        24811,
+        24279,
+        23731,
+        23170,
+        22594,
+        22005,
+        21403,
+        20787,
+        20159,
+        19519,
+        18868,
+        18204,
+        17530,
+        16846,
+        16151,
+        15446,
+        14732,
+        14010,
+        13279,
+        12539,
+        11793,
+        11039,
+        10278,
+        9512,
+        8739,
+        7962,
+        7179,
+        6393,
+        5602,
+        4808,
+        4011,
+        3212,
+        2410,
+        1608,
+        804,
+        0,
+        -804,
+        -1608,
+        -2410,
+        -3212,
+        -4011,
+        -4808,
+        -5602,
+        -6393,
+        -7179,
+        -7962,
+        -8739,
+        -9512,
+        -10278,
+        -11039,
+        -11793,
+        -12539,
+        -13279,
+        -14010,
+        -14732,
+        -15446,
+        -16151,
+        -16846,
+        -17530,
+        -18204,
+        -18868,
+        -19519,
+        -20159,
+        -20787,
+        -21403,
+        -22005,
+        -22594,
+        -23170,
+        -23731,
+        -24279,
+        -24811,
+        -25329,
+        -25832,
+        -26319,
+        -26790,
+        -27245,
+        -27683,
+        -28105,
+        -28510,
+        -28898,
+        -29268,
+        -29621,
+        -29956,
+        -30273,
+        -30571,
+        -30852,
+        -31113,
+        -31356,
+        -31580,
+        -31785,
+        -31971,
+        -32137,
+        -32285,
+        -32412,
+        -32521,
+        -32609,
+        -32678,
+        -32728,
+        -32757,
+        -32767,
+        -32757,
+        -32728,
+        -32678,
+        -32609,
+        -32521,
+        -32412,
+        -32285,
+        -32137,
+        -31971,
+        -31785,
+        -31580,
+        -31356,
+        -31113,
+        -30852,
+        -30571,
+        -30273,
+        -29956,
+        -29621,
+        -29268,
+        -28898,
+        -28510,
+        -28105,
+        -27683,
+        -27245,
+        -26790,
+        -26319,
+        -25832,
+        -25329,
+        -24811,
+        -24279,
+        -23731,
+        -23170,
+        -22594,
+        -22005,
+        -21403,
+        -20787,
+        -20159,
+        -19519,
+        -18868,
+        -18204,
+        -17530,
+        -16846,
+        -16151,
+        -15446,
+        -14732,
+        -14010,
+        -13279,
+        -12539,
+        -11793,
+        -11039,
+        -10278,
+        -9512,
+        -8739,
+        -7962,
+        -7179,
+        -6393,
+        -5602,
+        -4808,
+        -4011,
+        -3212,
+        -2410,
+        -1608,
+        -804,
+    }};
+
+    std::array<uint32_t, 256> oscillator_q15_{};
+    uint32_t phase_{0};
+    uint32_t phase_increment_{0};
+    uint32_t sampling_rate_{192000};
+    int32_t frequency_{0};
+};
+
+/*
+ * Frequency-translating 32-tap FIR decimator.  Frequency translation is
+ * split between coefficients modulated when tuning changes and a cheap
+ * output-rate phase rotation.  This avoids running an NCO at the 384kHz
+ * input rate.
+ */
+class FrequencyTranslatingDecimator32By8 {
+   public:
+    static constexpr size_t decimation_factor = 8;
+    static constexpr size_t taps_count = 32;
+
+    void configure(
+        const std::array<int16_t, taps_count>& taps,
+        const uint32_t input_sampling_rate) {
+        taps_ = taps;
+        input_sampling_rate_ = input_sampling_rate;
+        decimator_.configure(complex_taps_, decimation_factor);
+        output_xlator_.set_sample_rate(input_sampling_rate / decimation_factor);
+        update_taps();
+    }
+
+    void set_frequency(const int32_t frequency) {
+        frequency_ = frequency;
+        output_xlator_.set_frequency(frequency);
+        update_taps();
+    }
+
+    buffer_c16_t execute(
+        const buffer_c16_t& src,
+        const buffer_c16_t& dst) {
+        const auto filtered = decimator_.execute(src, dst);
+        return output_xlator_.execute(filtered, dst);
+    }
+
+   private:
+    static void oscillator(
+        const uint32_t phase,
+        int32_t& sine,
+        int32_t& cosine) {
+        const uint8_t index = phase >> 24;
+        const uint8_t next = index + 1;
+        const uint8_t cosine_index = index + 64;
+        const uint8_t cosine_next = cosine_index + 1;
+        const int32_t fraction = (phase >> 16) & 0xff;
+        const int32_t sine_first = FrequencyTranslator::sine_q15_[index];
+        const int32_t cosine_first = FrequencyTranslator::sine_q15_[cosine_index];
+        sine = sine_first +
+               (((FrequencyTranslator::sine_q15_[next] - sine_first) * fraction) >> 8);
+        cosine = cosine_first +
+                 (((FrequencyTranslator::sine_q15_[cosine_next] - cosine_first) * fraction) >> 8);
+    }
+
+    void update_taps() {
+        if (!input_sampling_rate_)
+            return;
+
+        const uint32_t tap_phase_increment = static_cast<uint32_t>(
+            (static_cast<int64_t>(frequency_) * (int64_t{1} << 32)) /
+            input_sampling_rate_);
+
+        /* Centre the modulation on the FIR midpoint.  Besides changing
+         * only a constant output phase, this makes the two coefficients
+         * in each symmetric pair complex conjugates.  That property is
+         * important after quantization: starting at tap zero accumulated
+         * a one-sided phase and rounding error across the whole filter. */
+        uint32_t phase = static_cast<uint32_t>(
+            -((static_cast<int64_t>(
+                   static_cast<int32_t>(tap_phase_increment)) *
+               static_cast<int64_t>(taps_count - 1)) /
+              2));
+        for (size_t i = 0; i < taps_count; ++i) {
+            int32_t sine;
+            int32_t cosine;
+            oscillator(phase, sine, cosine);
+            /* FIRAndDecimateComplex uses Q16 coefficients; the source
+             * real-tap filters use Q15 coefficients. */
+            const int32_t tap = taps_[i];
+            complex_taps_[i] = {
+                static_cast<int16_t>(
+                    FrequencyTranslator::rounded_shift(
+                        tap * cosine, 14)),
+                static_cast<int16_t>(
+                    FrequencyTranslator::rounded_shift(
+                        tap * sine, 14))};
+            phase += tap_phase_increment;
+        }
+        decimator_.set_taps(complex_taps_);
+    }
+
+    std::array<int16_t, taps_count> taps_{};
+    std::array<complex16_t, taps_count> complex_taps_{};
+    decimate::FIRAndDecimateComplex decimator_{};
+    FrequencyTranslator output_xlator_{};
+    uint32_t input_sampling_rate_{0};
+    int32_t frequency_{0};
+};
+
+} /* namespace dsp */
+
+#endif /*__DSP_FREQUENCY_XLATOR_H__*/

firmware/baseband/filtered_spectrum_collector.cpp

@@ -0,0 +1,90 @@
+/*
+ * 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.
+ */
+
+#include "filtered_spectrum_collector.hpp"
+
+#include "dsp_fir_taps.hpp"
+#include "event_m4.hpp"
+
+#include <algorithm>
+
+void FilteredSpectrumCollector::on_message(const Message* const message) {
+    if (message->id == Message::ID::UpdateSpectrum) {
+        update();
+    }
+    SpectrumCollector::on_message(message);
+}
+
+void FilteredSpectrumCollector::start_capture(
+    const size_t decimation_factor) {
+    capture_decimation_ = decimation_factor;
+    capture_count_ = 0;
+    capture_ready_ = false;
+}
+
+bool FilteredSpectrumCollector::feed(
+    const buffer_c16_t& channel,
+    const int32_t filter_low_frequency,
+    const int32_t filter_high_frequency,
+    const int32_t filter_transition) {
+    set_filter(
+        filter_low_frequency,
+        filter_high_frequency,
+        filter_transition);
+
+    const size_t required_samples = 256 * capture_decimation_;
+    const size_t copy_count = std::min(
+        channel.count, required_samples - capture_count_);
+    std::copy_n(
+        channel.p,
+        copy_count,
+        capture_.begin() + capture_count_);
+    capture_count_ += copy_count;
+
+    if (capture_count_ == required_samples) {
+        sampling_rate_ = channel.sampling_rate / capture_decimation_;
+        capture_ready_ = true;
+        EventDispatcher::events_flag(EVT_MASK_SPECTRUM);
+        if (is_streaming()) {
+            capture_ready_ = true;
+            EventDispatcher::events_flag(EVT_MASK_SPECTRUM);
+        } else {
+            capture_ready_ = false;
+        }
+        return true;
+    }
+    return false;
+}
+
+void FilteredSpectrumCollector::update() {
+    if (!capture_ready_) {
+        return;
+    }
+
+    decim_0_.configure(taps_audio_spectrum_halfband.taps);
+    const buffer_c16_t capture{
+        capture_.data(),
+        256 * capture_decimation_,
+        sampling_rate_ * capture_decimation_};
+    const buffer_c16_t stage_0{
+        stage_0_.data(),
+        stage_0_.size()};
+    const auto filtered = decim_0_.execute(capture, stage_0);
+
+    if (capture_decimation_ == 4) {
+        decim_1_.configure(taps_audio_spectrum_halfband.taps);
+        const buffer_c16_t stage_1{
+            stage_1_.data(),
+            stage_1_.size()};
+        post_message(decim_1_.execute(filtered, stage_1));
+    } else {
+        post_message(filtered);
+    }
+    capture_ready_ = false;
+}

firmware/baseband/filtered_spectrum_collector.hpp

@@ -0,0 +1,43 @@
+/*
+ * 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.
+ */
+
+#ifndef __FILTERED_SPECTRUM_COLLECTOR_H__
+#define __FILTERED_SPECTRUM_COLLECTOR_H__
+
+#include "dsp_decimate.hpp"
+#include "spectrum_collector.hpp"
+
+#include <array>
+
+class FilteredSpectrumCollector : public SpectrumCollector {
+   public:
+    void on_message(const Message* const message);
+
+    void start_capture(const size_t decimation_factor);
+    bool feed(
+        const buffer_c16_t& channel,
+        const int32_t filter_low_frequency,
+        const int32_t filter_high_frequency,
+        const int32_t filter_transition);
+
+   private:
+    std::array<complex16_t, 1024> capture_{};
+    std::array<complex16_t, 512> stage_0_{};
+    std::array<complex16_t, 256> stage_1_{};
+    dsp::decimate::FIRC16xR16x63HalfbandDecim2 decim_0_{};
+    dsp::decimate::FIRC16xR16x63HalfbandDecim2 decim_1_{};
+    size_t capture_count_{0};
+    size_t capture_decimation_{1};
+    uint32_t sampling_rate_{0};
+    bool capture_ready_{false};
+
+    void update();
+};
+
+#endif /*__FILTERED_SPECTRUM_COLLECTOR_H__*/

firmware/baseband/fprotos/s-superrollo.hpp

@@ -0,0 +1,124 @@
+
+#ifndef __FPROTO_SUPERROLLO_H__
+#define __FPROTO_SUPERROLLO_H__
+
+#include "subghzdbase.hpp"
+
+// Superrollo GW60 (HCS361) 67-bit OOK decoder. Reports FPS_SUPERROLLO; SubGhzD
+// treats FPS_SUPERROLLO like KeeLoq for decrypt/display (see ui_subghzd.cpp), so
+// the "Superrollo" keystore key decrypts it while it stays identifiable in logs.
+
+typedef enum : uint8_t {
+    SuperrolloStepReset = 0,
+    SuperrolloStepPreambleLow,
+    SuperrolloStepSyncLow,
+    SuperrolloStepSaveDuration,
+    SuperrolloStepCheckDuration,
+} SuperrolloDecoderStep;
+
+class FProtoSubGhzDSuperrollo : public FProtoSubGhzDBase {
+   public:
+    FProtoSubGhzDSuperrollo() {
+        sensorType = FPS_SUPERROLLO;
+        te_short = 450;
+        te_long = 900;
+        te_delta = 200;
+        min_count_bit_for_found = 64;
+    }
+
+    void feed(bool level, uint32_t duration) {
+        switch (parser_step) {
+            case SuperrolloStepReset:
+                if (level) {
+                    if (DURATION_DIFF(duration, te_short) < te_delta) {
+                        header_count++;
+                        parser_step = SuperrolloStepPreambleLow;
+                    } else if (
+                        (header_count >= 4) &&
+                        (DURATION_DIFF(duration, te_short * 10) < te_delta * 10)) {
+                        parser_step = SuperrolloStepSyncLow;
+                    } else {
+                        header_count = 0;
+                    }
+                } else {
+                    header_count = 0;
+                }
+                break;
+
+            case SuperrolloStepPreambleLow:
+                if ((!level) && (DURATION_DIFF(duration, te_long) < te_delta)) {
+                    parser_step = SuperrolloStepReset;
+                } else {
+                    parser_step = SuperrolloStepReset;
+                    header_count = 0;
+                }
+                break;
+
+            case SuperrolloStepSyncLow:
+                if ((!level) && (DURATION_DIFF(duration, te_short * 10) < te_delta * 10)) {
+                    parser_step = SuperrolloStepSaveDuration;
+                    decode_data = 0;
+                    decode_count_bit = 0;
+                } else {
+                    parser_step = SuperrolloStepReset;
+                    header_count = 0;
+                }
+                break;
+
+            case SuperrolloStepSaveDuration:
+                if (level) {
+                    te_last = duration;
+                    parser_step = SuperrolloStepCheckDuration;
+                } else if (duration >= te_short * 12) {
+                    endFrame();
+                }
+                break;
+
+            case SuperrolloStepCheckDuration:
+                if (!level) {
+                    if ((DURATION_DIFF(te_last, te_short) < te_delta) &&
+                        (DURATION_DIFF(duration, te_long) < te_delta)) {
+                        if (decode_count_bit < min_count_bit_for_found)
+                            subghz_protocol_blocks_add_bit(1);
+                        else
+                            decode_count_bit++;
+                        parser_step = SuperrolloStepSaveDuration;
+                    } else if (
+                        (DURATION_DIFF(te_last, te_long) < te_delta) &&
+                        (DURATION_DIFF(duration, te_short) < te_delta)) {
+                        if (decode_count_bit < min_count_bit_for_found)
+                            subghz_protocol_blocks_add_bit(0);
+                        else
+                            decode_count_bit++;
+                        parser_step = SuperrolloStepSaveDuration;
+                    } else if (duration >= te_short * 12) {
+                        endFrame();
+                    } else {
+                        parser_step = SuperrolloStepReset;
+                        header_count = 0;
+                    }
+                } else {
+                    parser_step = SuperrolloStepReset;
+                    header_count = 0;
+                }
+                break;
+        }
+    }
+
+    uint16_t header_count = 0;
+
+   private:
+    void endFrame() {
+        if ((decode_count_bit >= min_count_bit_for_found) &&
+            (decode_count_bit <= min_count_bit_for_found + 3)) {
+            data_count_bit = min_count_bit_for_found;
+            if (callback) callback(this);
+        }
+        parser_step = SuperrolloStepReset;
+        decode_data = 0;
+        decode_count_bit = 0;
+        header_count = 0;
+    }
+};
+
+#endif

firmware/baseband/fprotos/subghzdprotos.hpp

@@ -29,6 +29,7 @@ So include here the .hpp, and add a new element to the protos vector in the cons
 #include "s-ido.hpp"
 #include "s-intertechnov3.hpp"
 #include "s-keeloq.hpp"
+#include "s-superrollo.hpp"
 #include "s-kinggates_stylo_4k.hpp"
 #include "s-linear.hpp"
 #include "s-linear_delta3.hpp"
@@ -85,6 +86,7 @@ class SubGhzDProtos : public FProtoListGeneral {
         protos[FPS_IDO] = new FProtoSubGhzDIdo();
         protos[FPS_INTERTECHNOV3] = new FProtoSubGhzDIntertechnoV3();
         protos[FPS_KEELOQ] = new FProtoSubGhzDKeeLoq();
+        protos[FPS_SUPERROLLO] = new FProtoSubGhzDSuperrollo();
         protos[FPS_KINGGATESSTYLO4K] = new FProtoSubGhzDKinggatesStylo4K();
         protos[FPS_LINEAR] = new FProtoSubGhzDLinear();
         protos[FPS_LINEARDELTA3] = new FProtoSubGhzDLinearDelta3();

firmware/baseband/fprotos/subghztypes.hpp

@@ -60,6 +60,7 @@ enum FPROTO_SUBGHZD_SENSOR : uint8_t {
     FPS_MARANTEC24,
     FPS_HOLTEKHT6P20B,
     FPS_RESTAURANT_PAGER,
+    FPS_SUPERROLLO,
     FPS_COUNT
 };
 

firmware/baseband/proc_am_audio.cpp

@@ -45,10 +45,26 @@ void NarrowbandAMAudio::execute(const buffer_c8_t& buffer) {
     }
 
     const auto decim_0_out = decim_0.execute(buffer, dst_buffer);
-    const auto decim_1_out = decim_1.execute(decim_0_out, dst_buffer);
+    const auto audio_decim_0_out = audio_decim_0.execute(decim_0_out, dst_buffer);
 
-    channel_spectrum.feed(decim_1_out, channel_filter_low_f, channel_filter_high_f, channel_filter_transition);
+    spectrum_samples += decim_0_out.count;
+    if (!spectrum_capture_active &&
+        spectrum_samples >= spectrum_interval_samples) {
+        spectrum_samples -= spectrum_interval_samples;
+        channel_spectrum.start_capture(spectrum_zoom_x2 ? 4 : 2);
+        spectrum_capture_active = true;
+    }
 
+    if (spectrum_capture_active &&
+        channel_spectrum.feed(
+            audio_decim_0_out,
+            channel_filter_low_f,
+            channel_filter_high_f,
+            channel_filter_transition)) {
+        spectrum_capture_active = false;
+    }
+
+    const auto decim_1_out = translating_decim_1.execute(audio_decim_0_out, dst_buffer);
     const auto decim_2_out = decim_2.execute(decim_1_out, dst_buffer);
     const auto channel_out = channel_filter.execute(decim_2_out, dst_buffer);
 
@@ -97,6 +113,10 @@ void NarrowbandAMAudio::on_message(const Message* const message) {
             capture_config(*reinterpret_cast<const CaptureConfigMessage*>(message));
             break;
 
+        case Message::ID::AudioDDCConfig:
+            ddc_config(*reinterpret_cast<const AudioDDCConfigMessage*>(message));
+            break;
+
         default:
             break;
     }
@@ -106,17 +126,19 @@ void NarrowbandAMAudio::configure(const AMConfigureMessage& message) {
     constexpr size_t decim_0_input_fs = baseband_fs;
     constexpr size_t decim_0_output_fs = decim_0_input_fs / decim_0.decimation_factor;
 
-    constexpr size_t decim_1_input_fs = decim_0_output_fs;
-    constexpr size_t decim_1_output_fs = decim_1_input_fs / decim_1.decimation_factor;
-
+    constexpr size_t audio_decim_0_output_fs = decim_0_output_fs / 2;
+    constexpr size_t decim_1_output_fs =
+        audio_decim_0_output_fs / translating_decim_1.decimation_factor;
     constexpr size_t decim_2_input_fs = decim_1_output_fs;
     constexpr size_t decim_2_output_fs = decim_2_input_fs / decim_2_decimation_factor;
 
     constexpr size_t channel_filter_input_fs = decim_2_output_fs;
     // const size_t channel_filter_output_fs = channel_filter_input_fs / channel_filter_decimation_factor;
 
-    decim_0.configure(message.decim_0_filter.taps);
-    decim_1.configure(message.decim_1_filter.taps);
+    decim_0.configure(message.decim_0_filter.taps, 33554432);
+    audio_decim_0.configure(taps_audio_wide_halfband_0.taps);
+    translating_decim_1.configure(
+        message.decim_1_filter.taps, audio_decim_0_output_fs);
     decim_2.configure(message.decim_2_filter.taps, decim_2_decimation_factor);
     channel_filter.configure(message.channel_filter.taps, channel_filter_decimation_factor);
     channel_filter_low_f = message.channel_filter.low_frequency_normalized * channel_filter_input_fs;
@@ -124,12 +146,20 @@ void NarrowbandAMAudio::configure(const AMConfigureMessage& message) {
     channel_filter_transition = message.channel_filter.transition_normalized * channel_filter_input_fs;
 
     modulation_ssb = (int)message.modulation;  // now sending by message , 3 types of AM demod :   enum class Modulation : int32_t {DSB = 0, SSB = 1, SSB_FM = 2}
-    channel_spectrum.set_decimation_factor(message.channel_spectrum_decimation_factor);
+    spectrum_zoom_x2 = message.channel_spectrum_decimation_factor == 2;
+    channel_spectrum.set_decimation_factor(1);
+    spectrum_interval_samples =
+        decim_0_output_fs / spectrum_rate_hz;
     audio_output.configure(message.audio_hpf_lpf_config);  // hpf in all AM demod modes (AM-6K/9K, USB/LSB,DSB), except Wefax (lpf there).
 
     configured = true;
 }
 
+void NarrowbandAMAudio::ddc_config(const AudioDDCConfigMessage& message) {
+    translating_decim_1.set_frequency(message.frequency);
+    channel_spectrum.set_channel_filter_offset(message.frequency);
+}
+
 void NarrowbandAMAudio::capture_config(const CaptureConfigMessage& message) {
     if (message.config) {
         audio_output.set_stream(std::make_unique<StreamInput>(message.config));

firmware/baseband/proc_am_audio.hpp

@@ -28,10 +28,11 @@
 
 #include "dsp_decimate.hpp"
 #include "dsp_demodulate.hpp"
+#include "dsp_frequency_xlator.hpp"
 #include "audio_compressor.hpp"
 
 #include "audio_output.hpp"
-#include "spectrum_collector.hpp"
+#include "filtered_spectrum_collector.hpp"
 
 #include <cstdint>
 
@@ -44,6 +45,7 @@ class NarrowbandAMAudio : public BasebandProcessor {
 
    private:
     static constexpr size_t baseband_fs = 3072000;
+    static constexpr auto spectrum_rate_hz = 30.0f;
     static constexpr size_t decim_2_decimation_factor = 4;
     static constexpr size_t channel_filter_decimation_factor = 1;
 
@@ -56,14 +58,19 @@ class NarrowbandAMAudio : public BasebandProcessor {
         audio.data(),
         audio.size()};
 
-    dsp::decimate::FIRC8xR16x24FS4Decim8 decim_0{};
-    dsp::decimate::FIRC16xR16x32Decim8 decim_1{};
+    dsp::decimate::FIRC8xR16x24FS4Decim4 decim_0{};
+    dsp::decimate::FIRC16xR16x16Decim2 audio_decim_0{};
+    dsp::FrequencyTranslatingDecimator32By8 translating_decim_1{};
     dsp::decimate::FIRAndDecimateComplex decim_2{};
     dsp::decimate::FIRAndDecimateComplex channel_filter{};
     int32_t channel_filter_low_f = 0;
     int32_t channel_filter_high_f = 0;
     int32_t channel_filter_transition = 0;
     bool configured{false};
+    size_t spectrum_interval_samples{0};
+    size_t spectrum_samples{0};
+    bool spectrum_capture_active{false};
+    bool spectrum_zoom_x2{false};
 
     // bool modulation_ssb = false;  // Origianlly we only had 2 AM demod types {DSB = 0, SSB = 1} , and we could handle it with bool var , 1 bit.
     int8_t modulation_ssb = 0;  // Now we have 3 AM demod types we will send now index integer  {DSB = 0, SSB = 1, SSB_FM = 2}
@@ -73,7 +80,7 @@ class NarrowbandAMAudio : public BasebandProcessor {
     FeedForwardCompressor audio_compressor{};
     AudioOutput audio_output{};
 
-    SpectrumCollector channel_spectrum{};
+    FilteredSpectrumCollector channel_spectrum{};
 
     /* NB: Threads should be the last members in the class definition. */
 #ifdef PRALINE
@@ -86,6 +93,7 @@ class NarrowbandAMAudio : public BasebandProcessor {
 #endif
 
     void configure(const AMConfigureMessage& message);
+    void ddc_config(const AudioDDCConfigMessage& message);
     void capture_config(const CaptureConfigMessage& message);
 
     buffer_f32_t demodulate(const buffer_c16_t& channel);

firmware/baseband/proc_nfm_audio.cpp

@@ -51,10 +51,26 @@ void NarrowbandFMAudio::execute(const buffer_c8_t& buffer) {
     }
 
     const auto decim_0_out = decim_0.execute(buffer, dst_buffer);
-    const auto decim_1_out = decim_1.execute(decim_0_out, dst_buffer);
+    const auto audio_decim_0_out = audio_decim_0.execute(decim_0_out, dst_buffer);
 
-    channel_spectrum.feed(decim_1_out, channel_filter_low_f, channel_filter_high_f, channel_filter_transition);
+    spectrum_samples += decim_0_out.count;
+    if (!spectrum_capture_active &&
+        spectrum_samples >= spectrum_interval_samples) {
+        spectrum_samples -= spectrum_interval_samples;
+        channel_spectrum.start_capture(2);
+        spectrum_capture_active = true;
+    }
 
+    if (spectrum_capture_active &&
+        channel_spectrum.feed(
+            audio_decim_0_out,
+            channel_filter_low_f,
+            channel_filter_high_f,
+            channel_filter_transition)) {
+        spectrum_capture_active = false;
+    }
+
+    const auto decim_1_out = translating_decim_1.execute(audio_decim_0_out, dst_buffer);
     const auto channel_out = channel_filter.execute(decim_1_out, dst_buffer);
 
     feed_channel_stats(channel_out);
@@ -141,6 +157,10 @@ void NarrowbandFMAudio::on_message(const Message* const message) {
             pitch_rssi_config(*reinterpret_cast<const PitchRSSIConfigureMessage*>(message));
             break;
 
+        case Message::ID::AudioDDCConfig:
+            ddc_config(*reinterpret_cast<const AudioDDCConfigMessage*>(message));
+            break;
+
         default:
             break;
     }
@@ -150,22 +170,26 @@ void NarrowbandFMAudio::configure(const NBFMConfigureMessage& message) {
     constexpr size_t decim_0_input_fs = baseband_fs;
     constexpr size_t decim_0_output_fs = decim_0_input_fs / decim_0.decimation_factor;
 
-    constexpr size_t decim_1_input_fs = decim_0_output_fs;
-    constexpr size_t decim_1_output_fs = decim_1_input_fs / decim_1.decimation_factor;
-
+    constexpr size_t audio_decim_0_output_fs = decim_0_output_fs / 2;
+    constexpr size_t decim_1_output_fs =
+        audio_decim_0_output_fs / translating_decim_1.decimation_factor;
     constexpr size_t channel_filter_input_fs = decim_1_output_fs;
     const size_t channel_filter_output_fs = channel_filter_input_fs / message.channel_decimation;
 
     const size_t demod_input_fs = channel_filter_output_fs;
 
-    decim_0.configure(message.decim_0_filter.taps);
-    decim_1.configure(message.decim_1_filter.taps);
+    decim_0.configure(message.decim_0_filter.taps, 33554432);
+    audio_decim_0.configure(taps_audio_wide_halfband_0.taps);
+    translating_decim_1.configure(
+        message.decim_1_filter.taps, audio_decim_0_output_fs);
     channel_filter.configure(message.channel_filter.taps, message.channel_decimation);
     demod.configure(demod_input_fs, message.deviation);
     channel_filter_low_f = message.channel_filter.low_frequency_normalized * channel_filter_input_fs;
     channel_filter_high_f = message.channel_filter.high_frequency_normalized * channel_filter_input_fs;
     channel_filter_transition = message.channel_filter.transition_normalized * channel_filter_input_fs;
-    channel_spectrum.set_decimation_factor(1.0f);
+    channel_spectrum.set_decimation_factor(1);
+    spectrum_interval_samples =
+        decim_0_output_fs / spectrum_rate_hz;
     audio_output.configure(message.audio_hpf_config, message.audio_deemph_config, (float)message.squelch_level / 100.0);
 
     hpf.configure(audio_24k_hpf_30hz_config);
@@ -174,6 +198,11 @@ void NarrowbandFMAudio::configure(const NBFMConfigureMessage& message) {
     configured = true;
 }
 
+void NarrowbandFMAudio::ddc_config(const AudioDDCConfigMessage& message) {
+    translating_decim_1.set_frequency(message.frequency);
+    channel_spectrum.set_channel_filter_offset(message.frequency);
+}
+
 void NarrowbandFMAudio::pitch_rssi_config(const PitchRSSIConfigureMessage& message) {
     pitch_rssi_enabled = message.enabled;
     tone_delta = (message.rssi + 1000) * ((1ULL << 32) / 24000);

firmware/baseband/proc_nfm_audio.hpp

@@ -29,10 +29,11 @@
 
 #include "dsp_decimate.hpp"
 #include "dsp_demodulate.hpp"
+#include "dsp_frequency_xlator.hpp"
 #include "dsp_iir.hpp"
 
 #include "audio_output.hpp"
-#include "spectrum_collector.hpp"
+#include "filtered_spectrum_collector.hpp"
 
 #include <cstdint>
 
@@ -50,6 +51,7 @@ class NarrowbandFMAudio : public BasebandProcessor {
 
    private:
     static constexpr size_t baseband_fs = 3072000;
+    static constexpr auto spectrum_rate_hz = 30.0f;
 
     std::array<complex16_t, 512> dst{};
     const buffer_c16_t dst_buffer{
@@ -69,8 +71,9 @@ class NarrowbandFMAudio : public BasebandProcessor {
         (int16_t*)tone.data(),
         sizeof(tone) / sizeof(int16_t)};
 
-    dsp::decimate::FIRC8xR16x24FS4Decim8 decim_0{};
-    dsp::decimate::FIRC16xR16x32Decim8 decim_1{};
+    dsp::decimate::FIRC8xR16x24FS4Decim4 decim_0{};
+    dsp::decimate::FIRC16xR16x16Decim2 audio_decim_0{};
+    dsp::FrequencyTranslatingDecimator32By8 translating_decim_1{};
     dsp::decimate::FIRAndDecimateComplex channel_filter{};
     int32_t channel_filter_low_f = 0;
     int32_t channel_filter_high_f = 0;
@@ -84,7 +87,10 @@ class NarrowbandFMAudio : public BasebandProcessor {
 
     AudioOutput audio_output{};
 
-    SpectrumCollector channel_spectrum{};
+    FilteredSpectrumCollector channel_spectrum{};
+    size_t spectrum_interval_samples{0};
+    size_t spectrum_samples{0};
+    bool spectrum_capture_active{false};
 
     uint32_t tone_phase{0};
     uint32_t tone_delta{0};
@@ -113,6 +119,7 @@ class NarrowbandFMAudio : public BasebandProcessor {
     void pitch_rssi_config(const PitchRSSIConfigureMessage& message);
     void configure(const NBFMConfigureMessage& message);
     void capture_config(const CaptureConfigMessage& message);
+    void ddc_config(const AudioDDCConfigMessage& message);
 };
 
 #endif /*__PROC_NFM_AUDIO_H__*/

firmware/baseband/sd_over_usb/cpu_clock.c

@@ -0,0 +1,263 @@
+/*
+ * Copyright 2026 Great Scott Gadgets <info@greatscottgadgets.com>
+ *
+ * This file is part of HackRF.
+ *
+ * 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.
+ */
+
+#include "cpu_clock.h"
+
+#include <stdint.h>
+
+#include <libopencm3/lpc43xx/cgu.h>
+#if defined(IS_JAWBREAKER) || defined(IS_HACKRF_ONE) || defined(IS_PRALINE)
+#include <libopencm3/lpc43xx/ccu.h>
+#endif
+
+#include "delay.h"
+#include "i2c_bus.h"
+#include "i2c_lpc.h"
+#include "si5351c.h"
+
+/* We start with the CPU clock at 96MHz */
+unsigned int cpu_clock_mhz = 96;
+
+/*
+Configure PLL1 (Main MCU Clock) to max speed (204MHz).
+Note: PLL1 clock is used by M4/M0 core, Peripheral, APB1.
+This function shall be called after cpu_clock_init().
+*/
+static void cpu_clock_pll1_max_speed(void) {
+    uint32_t reg_val;
+
+    /* This function implements the sequence recommended in:
+     * UM10503 Rev 2.4 (Aug 2018), section 13.2.1.1, page 167. */
+
+    /* 1. Select the IRC as BASE_M4_CLK source. */
+    reg_val = CGU_BASE_M4_CLK;
+    reg_val &= ~CGU_BASE_M4_CLK_CLK_SEL_MASK;
+    reg_val |= CGU_BASE_M4_CLK_CLK_SEL(CGU_SRC_IRC) | CGU_BASE_M4_CLK_AUTOBLOCK(1);
+    CGU_BASE_M4_CLK = reg_val;
+
+    /* CPU is now at 12MHz */
+    cpu_clock_mhz = 12;
+
+    /* 2. Enable the crystal oscillator. */
+    CGU_XTAL_OSC_CTRL &= ~CGU_XTAL_OSC_CTRL_ENABLE_MASK;
+
+    /* 3. Wait 250us. */
+    delay_us(250);
+
+    /* 4. Set the AUTOBLOCK bit. */
+    CGU_PLL1_CTRL |= CGU_PLL1_CTRL_AUTOBLOCK(1);
+
+    /* 5. Reconfigure PLL1 to produce the final output frequency, with the
+     *    crystal oscillator as clock source. */
+    reg_val = CGU_PLL1_CTRL;
+    // clang-format off
+	reg_val &= ~( CGU_PLL1_CTRL_CLK_SEL_MASK |
+	              CGU_PLL1_CTRL_PD_MASK |
+	              CGU_PLL1_CTRL_FBSEL_MASK |
+	              CGU_PLL1_CTRL_BYPASS_MASK |
+	              CGU_PLL1_CTRL_DIRECT_MASK |
+	              CGU_PLL1_CTRL_PSEL_MASK |
+	              CGU_PLL1_CTRL_MSEL_MASK |
+	              CGU_PLL1_CTRL_NSEL_MASK );
+	/* Set PLL1 up to 12MHz * 17 = 204MHz.
+	 * Direct mode: FCLKOUT = FCCO = M*(FCLKIN/N) */
+	reg_val |= CGU_PLL1_CTRL_CLK_SEL(CGU_SRC_XTAL) |
+	           CGU_PLL1_CTRL_PSEL(0) |
+	           CGU_PLL1_CTRL_NSEL(0) |
+	           CGU_PLL1_CTRL_MSEL(16) |
+	           CGU_PLL1_CTRL_FBSEL(0) |
+	           CGU_PLL1_CTRL_DIRECT(1);
+    // clang-format on
+    CGU_PLL1_CTRL = reg_val;
+
+    /* 6. Wait for PLL1 to lock. */
+    while (!(CGU_PLL1_STAT & CGU_PLL1_STAT_LOCK_MASK)) {
+    }
+
+    /* 7. Set the PLL1 P-divider to divide by 2 (DIRECT=0, PSEL=0). */
+    CGU_PLL1_CTRL &= ~CGU_PLL1_CTRL_DIRECT_MASK;
+
+    /* 8. Select PLL1 as BASE_M4_CLK source. */
+    reg_val = CGU_BASE_M4_CLK;
+    reg_val &= ~CGU_BASE_M4_CLK_CLK_SEL_MASK;
+    reg_val |= CGU_BASE_M4_CLK_CLK_SEL(CGU_SRC_PLL1);
+    CGU_BASE_M4_CLK = reg_val;
+
+    /* CPU is now at 102MHz */
+    cpu_clock_mhz = 102;
+
+    /* 9. Wait 50us. */
+    delay_us(50);
+
+    /* 10. Set the PLL1 P-divider to direct output mode (DIRECT=1). */
+    CGU_PLL1_CTRL |= CGU_PLL1_CTRL_DIRECT_MASK;
+
+    /* CPU is now at 204MHz */
+    cpu_clock_mhz = 204;
+}
+
+/* clock startup for LPC4320 configure PLL1 to max speed (204MHz).
+Note: PLL1 clock is used by M4/M0 core, Peripheral, APB1. */
+void cpu_clock_init(void) {
+    /* use IRC as clock source for APB1 (including I2C0) */
+    CGU_BASE_APB1_CLK = CGU_BASE_APB1_CLK_CLK_SEL(CGU_SRC_IRC);
+
+    /* use IRC as clock source for APB3 */
+    CGU_BASE_APB3_CLK = CGU_BASE_APB3_CLK_CLK_SEL(CGU_SRC_IRC);
+
+    // FIXME disable I2C
+    /* Kick I2C0 down to 400kHz when we switch over to APB1 clock = 204MHz */
+    i2c_bus_start(si5351c.bus, &i2c_config_fast_clock);
+
+    /*
+     * 12MHz clock is entering LPC XTAL1/OSC input now.
+     * On HackRF One and Jawbreaker, there is a 12 MHz crystal at the LPC.
+     * Set up PLL1 to run from XTAL1 input.
+     */
+
+    // FIXME a lot of the details here should be in a CGU driver
+
+    /* set xtal oscillator to low frequency mode */
+    CGU_XTAL_OSC_CTRL &= ~CGU_XTAL_OSC_CTRL_HF_MASK;
+
+    cpu_clock_pll1_max_speed();
+
+    /* use XTAL_OSC as clock source for APB1 */
+    CGU_BASE_APB1_CLK =
+        CGU_BASE_APB1_CLK_AUTOBLOCK(1) | CGU_BASE_APB1_CLK_CLK_SEL(CGU_SRC_XTAL);
+
+    /* use XTAL_OSC as clock source for APB3 */
+    CGU_BASE_APB3_CLK =
+        CGU_BASE_APB3_CLK_AUTOBLOCK(1) | CGU_BASE_APB3_CLK_CLK_SEL(CGU_SRC_XTAL);
+
+    /* use XTAL_OSC as clock source for PLL0USB */
+    CGU_PLL0USB_CTRL = CGU_PLL0USB_CTRL_PD(1) | CGU_PLL0USB_CTRL_AUTOBLOCK(1) |
+                       CGU_PLL0USB_CTRL_CLK_SEL(CGU_SRC_XTAL);
+    while (CGU_PLL0USB_STAT & CGU_PLL0USB_STAT_LOCK_MASK) {
+    }
+
+    /* configure PLL0USB to produce 480 MHz clock from 12 MHz XTAL_OSC */
+    /* Values from User Manual v1.4 Table 94, for 12MHz oscillator. */
+    CGU_PLL0USB_MDIV = 0x06167FFA;
+    CGU_PLL0USB_NP_DIV = 0x00302062;
+    CGU_PLL0USB_CTRL |=
+        (CGU_PLL0USB_CTRL_PD(1) | CGU_PLL0USB_CTRL_DIRECTI(1) |
+         CGU_PLL0USB_CTRL_DIRECTO(1) | CGU_PLL0USB_CTRL_CLKEN(1));
+
+    /* power on PLL0USB and wait until stable */
+    CGU_PLL0USB_CTRL &= ~CGU_PLL0USB_CTRL_PD_MASK;
+    while (!(CGU_PLL0USB_STAT & CGU_PLL0USB_STAT_LOCK_MASK)) {
+    }
+
+    /* use PLL0USB as clock source for USB0 */
+    CGU_BASE_USB0_CLK = CGU_BASE_USB0_CLK_AUTOBLOCK(1) |
+                        CGU_BASE_USB0_CLK_CLK_SEL(CGU_SRC_PLL0USB);
+
+    /* Switch peripheral clock over to use PLL1 (204MHz) */
+    CGU_BASE_PERIPH_CLK = CGU_BASE_PERIPH_CLK_AUTOBLOCK(1) |
+                          CGU_BASE_PERIPH_CLK_CLK_SEL(CGU_SRC_PLL1);
+
+    /* Switch APB1 clock over to use PLL1 (204MHz) */
+    CGU_BASE_APB1_CLK =
+        CGU_BASE_APB1_CLK_AUTOBLOCK(1) | CGU_BASE_APB1_CLK_CLK_SEL(CGU_SRC_PLL1);
+
+    /* Switch APB3 clock over to use PLL1 (204MHz) */
+    CGU_BASE_APB3_CLK =
+        CGU_BASE_APB3_CLK_AUTOBLOCK(1) | CGU_BASE_APB3_CLK_CLK_SEL(CGU_SRC_PLL1);
+
+    CGU_BASE_SSP0_CLK =
+        CGU_BASE_SSP0_CLK_AUTOBLOCK(1) | CGU_BASE_SSP0_CLK_CLK_SEL(CGU_SRC_PLL1);
+
+    CGU_BASE_SSP1_CLK =
+        CGU_BASE_SSP1_CLK_AUTOBLOCK(1) | CGU_BASE_SSP1_CLK_CLK_SEL(CGU_SRC_PLL1);
+
+#ifdef IS_NOT_RAD1O
+    if (IS_NOT_RAD1O) {
+        /* Disable unused clocks */
+        /* Start with PLLs */
+        CGU_PLL0AUDIO_CTRL = CGU_PLL0AUDIO_CTRL_PD(1);
+
+        /* Dividers */
+        CGU_IDIVA_CTRL = CGU_IDIVA_CTRL_PD(1);
+        CGU_IDIVB_CTRL = CGU_IDIVB_CTRL_PD(1);
+        CGU_IDIVC_CTRL = CGU_IDIVC_CTRL_PD(1);
+        CGU_IDIVD_CTRL = CGU_IDIVD_CTRL_PD(1);
+        CGU_IDIVE_CTRL = CGU_IDIVE_CTRL_PD(1);
+
+        /* Base clocks */
+        CGU_BASE_SPIFI_CLK =
+            CGU_BASE_SPIFI_CLK_PD(1); /* SPIFI is only used at boot */
+        CGU_BASE_USB1_CLK =
+            CGU_BASE_USB1_CLK_PD(1); /* USB1 is not exposed on HackRF */
+        CGU_BASE_PHY_RX_CLK = CGU_BASE_PHY_RX_CLK_PD(1);
+        CGU_BASE_PHY_TX_CLK = CGU_BASE_PHY_TX_CLK_PD(1);
+        CGU_BASE_LCD_CLK = CGU_BASE_LCD_CLK_PD(1);
+        CGU_BASE_VADC_CLK = CGU_BASE_VADC_CLK_PD(1);
+        CGU_BASE_SDIO_CLK = CGU_BASE_SDIO_CLK_PD(0) | CGU_BASE_SDIO_CLK_AUTOBLOCK(1) | CGU_BASE_SDIO_CLK_CLK_SEL(0x09);
+        CGU_BASE_UART0_CLK = CGU_BASE_UART0_CLK_PD(1);
+        CGU_BASE_UART1_CLK = CGU_BASE_UART1_CLK_PD(1);
+        CGU_BASE_UART2_CLK = CGU_BASE_UART2_CLK_PD(1);
+        CGU_BASE_UART3_CLK = CGU_BASE_UART3_CLK_PD(1);
+        CGU_BASE_OUT_CLK = CGU_BASE_OUT_CLK_PD(1);
+        CGU_BASE_AUDIO_CLK = CGU_BASE_AUDIO_CLK_PD(1);
+        CGU_BASE_CGU_OUT0_CLK = CGU_BASE_CGU_OUT0_CLK_PD(1);
+        CGU_BASE_CGU_OUT1_CLK = CGU_BASE_CGU_OUT1_CLK_PD(1);
+
+        /* Disable unused peripheral clocks */
+        CCU1_CLK_APB1_CAN1_CFG = 0;
+        CCU1_CLK_APB1_I2S_CFG = 0;
+        CCU1_CLK_APB1_MOTOCONPWM_CFG = 0;
+        // CCU1_CLK_APB3_ADC0_CFG = 0;
+        CCU1_CLK_APB3_ADC1_CFG = 0;
+        CCU1_CLK_APB3_CAN0_CFG = 0;
+        CCU1_CLK_APB3_DAC_CFG = 0;
+        // CCU1_CLK_M4_DMA_CFG = 0;
+        CCU1_CLK_M4_EMC_CFG = 0;
+        CCU1_CLK_M4_EMCDIV_CFG = 0;
+        CCU1_CLK_M4_ETHERNET_CFG = 0;
+        CCU1_CLK_M4_LCD_CFG = 0;
+        CCU1_CLK_M4_QEI_CFG = 0;
+        CCU1_CLK_M4_RITIMER_CFG = 0;
+        // CCU1_CLK_M4_SCT_CFG = 0;
+        // CCU1_CLK_M4_SDIO_CFG = 1;
+        CCU1_CLK_M4_SPIFI_CFG = 0;
+        CCU1_CLK_M4_TIMER0_CFG = 0;
+        // CCU1_CLK_M4_TIMER1_CFG = 0;
+        // CCU1_CLK_M4_TIMER2_CFG = 0;
+        CCU1_CLK_M4_TIMER3_CFG = 0;
+        CCU1_CLK_M4_UART1_CFG = 0;
+        CCU1_CLK_M4_USART0_CFG = 0;
+        CCU1_CLK_M4_USART2_CFG = 0;
+        CCU1_CLK_M4_USART3_CFG = 0;
+        CCU1_CLK_M4_USB1_CFG = 0;
+        CCU1_CLK_M4_VADC_CFG = 0;
+        // CCU1_CLK_SPIFI_CFG = 0;
+        // CCU1_CLK_USB1_CFG = 0;
+        // CCU1_CLK_VADC_CFG = 0;
+        // CCU2_CLK_APB0_UART1_CFG = 0;
+        // CCU2_CLK_APB0_USART0_CFG = 0;
+        // CCU2_CLK_APB2_USART2_CFG = 0;
+        // CCU2_CLK_APB2_USART3_CFG = 0;
+        // CCU2_CLK_APLL_CFG = 0;
+        // CCU2_CLK_SDIO_CFG = 0;
+    }
+#endif
+}

firmware/baseband/sd_over_usb/flashsize.h

@@ -0,0 +1 @@
+#pragma once

firmware/baseband/sd_over_usb/pins.c

@@ -0,0 +1,254 @@
+/*
+ * Copyright 2012-2026 Great Scott Gadgets <info@greatscottgadgets.com>
+ * Copyright 2012 Jared Boone <jared@sharebrained.com>
+ * Copyright 2013 Benjamin Vernoux <titanmkd@gmail.com>
+ *
+ * This file is part of HackRF.
+ *
+ * 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.
+ */
+
+#include "pins.h"
+
+#include <libopencm3/lpc43xx/scu.h>
+
+#include "gpio.h"
+#include "leds.h"
+#include "platform_detect.h"
+#include "platform_gpio.h"
+#include "platform_scu.h"
+#include "power.h"
+#ifdef IS_PRALINE
+#include "clock_io.h"
+#endif
+
+void pins_shutdown(void) {
+    /* Configure all GPIO as Input (safe state) */
+    // gpio_init();
+
+    /* Detect Platform */
+    const platform_gpio_t* gpio = platform_gpio();
+    const platform_scu_t* scu = platform_scu();
+
+    /* TDI and TMS pull-ups are required in all JTAG-compliant devices.
+     *
+     * The HackRF CPLD is always present, so let the CPLD pull up its TDI and TMS.
+     *
+     * The PortaPack may not be present, so pull up the PortaPack TMS pin from the
+     * microcontroller.
+     *
+     * TCK is recommended to be held low, so use microcontroller pull-down.
+     *
+     * TDO is undriven except when in Shift-IR or Shift-DR phases.
+     * Use the microcontroller to pull down to keep from floating.
+     *
+     * LPC43xx pull-up and pull-down resistors are approximately 53K.
+     */
+#ifdef IS_EXPANSION_COMPATIBLE
+    if (IS_EXPANSION_COMPATIBLE) {
+        scu_pinmux(scu->PINMUX_PP_TMS, SCU_GPIO_PUP | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->PINMUX_PP_TDO, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+    }
+#endif
+    scu_pinmux(scu->PINMUX_CPLD_TCK, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+#ifdef IS_NOT_PRALINE
+    if (IS_NOT_PRALINE) {
+        scu_pinmux(scu->PINMUX_CPLD_TMS, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->PINMUX_CPLD_TDI, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->PINMUX_CPLD_TDO, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+    }
+#endif
+
+    /* Configure SCU Pin Mux as GPIO */
+    scu_pinmux(scu->PINMUX_LED1, SCU_GPIO_NOPULL);
+    scu_pinmux(scu->PINMUX_LED2, SCU_GPIO_NOPULL);
+    scu_pinmux(scu->PINMUX_LED3, SCU_GPIO_NOPULL);
+#ifdef IS_RAD1O
+    if (IS_RAD1O) {
+        scu_pinmux(scu->PINMUX_LED4, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION4);
+    }
+#endif
+#ifdef IS_PRALINE
+    if (IS_PRALINE) {
+        scu_pinmux(scu->PINMUX_LED4, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
+    }
+#endif
+
+    /* Configure USB indicators */
+#ifdef IS_JAWBREAKER
+    if (IS_JAWBREAKER) {
+        scu_pinmux(scu->PINMUX_USB_LED0, SCU_CONF_FUNCTION3);
+        scu_pinmux(scu->PINMUX_USB_LED1, SCU_CONF_FUNCTION3);
+    }
+#endif
+
+#ifdef IS_PRALINE
+    if (IS_PRALINE) {
+        // disable_1v2_power();
+        // disable_3v3aux_power();
+        // gpio_output(gpio->gpio_1v2_enable);
+        // gpio_output(gpio->gpio_3v3aux_enable_n);
+        // scu_pinmux(scu->PINMUX_EN1V2, SCU_GPIO_FAST | SCU_CONF_FUNCTION0);
+        // scu_pinmux(scu->PINMUX_EN3V3_AUX_N, SCU_GPIO_FAST | SCU_CONF_FUNCTION4);
+    }
+#endif
+
+#ifdef IS_NOT_PRALINE
+    if (IS_NOT_PRALINE) {
+        disable_1v8_power();
+#ifdef IS_H1_R9
+        if (IS_H1_R9) {
+            gpio_output(gpio->h1r9_1v8_enable);
+            scu_pinmux(scu->H1R9_EN1V8, SCU_GPIO_FAST | SCU_CONF_FUNCTION0);
+        }
+#endif
+#ifdef IS_NOT_H1_R9
+        if (IS_NOT_H1_R9) {
+            gpio_output(gpio->gpio_1v8_enable);
+            scu_pinmux(scu->PINMUX_EN1V8, SCU_GPIO_FAST | SCU_CONF_FUNCTION0);
+        }
+#endif
+    }
+#endif
+
+#ifdef IS_H1_OR_PRALINE
+    if (IS_H1_OR_PRALINE) {
+        /* Safe state: start with VAA turned off: */
+        disable_rf_power();
+
+        /* Configure RF power supply (VAA) switch control signal as output */
+#ifdef IS_H1_R9
+        if (IS_H1_R9) {
+            gpio_output(gpio->h1r9_vaa_disable);
+        }
+#endif
+#ifdef IS_NOT_H1_R9
+        if (IS_NOT_H1_R9) {
+            gpio_output(gpio->vaa_disable);
+        }
+#endif
+    }
+#endif
+
+#ifdef IS_RAD1O
+    if (IS_RAD1O) {
+        /* Safe state: start with VAA turned off: */
+        disable_rf_power();
+
+        /* Configure RF power supply (VAA) switch control signal as output */
+        gpio_output(gpio->vaa_enable);
+
+        /* Disable unused clock outputs. They generate noise. */
+        scu_pinmux(CLK0, SCU_CLK_IN | SCU_CONF_FUNCTION7);
+        scu_pinmux(CLK2, SCU_CLK_IN | SCU_CONF_FUNCTION7);
+
+        scu_pinmux(scu->PINMUX_GPIO3_10, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->PINMUX_GPIO3_11, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+    }
+#endif
+
+#ifdef IS_PRALINE
+    if (IS_PRALINE) {
+        scu_pinmux(scu->P2_CTRL0, scu->P2_CTRL0_PINCFG);
+        scu_pinmux(scu->P2_CTRL1, scu->P2_CTRL1_PINCFG);
+        scu_pinmux(scu->P1_CTRL0, scu->P1_CTRL0_PINCFG);
+        scu_pinmux(scu->P1_CTRL1, scu->P1_CTRL1_PINCFG);
+        scu_pinmux(scu->P1_CTRL2, scu->P1_CTRL2_PINCFG);
+        scu_pinmux(scu->CLKIN_CTRL, scu->CLKIN_CTRL_PINCFG);
+        scu_pinmux(scu->AA_EN, scu->AA_EN_PINCFG);
+        scu_pinmux(scu->TRIGGER_IN, scu->TRIGGER_IN_PINCFG);
+        scu_pinmux(scu->TRIGGER_OUT, scu->TRIGGER_OUT_PINCFG);
+        scu_pinmux(scu->PPS_OUT, scu->PPS_OUT_PINCFG);
+        scu_pinmux(scu->SCT_CLK, scu->SCT_CLK_PINCFG);
+
+        scu_pinmux(scu->PINMUX_FPGA_CRESET, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->PINMUX_FPGA_CDONE, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+        scu_pinmux(scu->PINMUX_FPGA_SPI_CS, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+
+        scu_pinmux(scu->SSP1_CIPO, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->SSP1_COPI, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->SSP1_SCK, SCU_GPIO_PDN | SCU_CONF_FUNCTION2);
+
+        scu_pinmux(scu->XCVR_ENABLE, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+        scu_pinmux(scu->XCVR_RXENABLE, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+        scu_pinmux(scu->XCVR_CS, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+        scu_pinmux(scu->XCVR_RXHP, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+        scu_pinmux(scu->XCVR_LD, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+
+        scu_pinmux(scu->MIXER_LD, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+        scu_pinmux(scu->MIXER_SCLK, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+        scu_pinmux(scu->MIXER_SDATA, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->MIXER_ENX, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->MIXER_RESETX, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+        scu_pinmux(scu->MIXER_ENBL, SCU_GPIO_PDN | SCU_CONF_FUNCTION0);
+
+        scu_pinmux(scu->AD_CS, SCU_GPIO_PDN | SCU_CONF_FUNCTION4);
+
+        p2_ctrl_set(P2_SIGNAL_CLK3);
+        p1_ctrl_set(P1_SIGNAL_CLKIN);
+        clkin_ctrl_set(CLKIN_SIGNAL_P1);
+
+        gpio_output(gpio->p2_ctrl0);
+        gpio_output(gpio->p2_ctrl1);
+        gpio_output(gpio->p1_ctrl0);
+        gpio_output(gpio->p1_ctrl1);
+        gpio_output(gpio->p1_ctrl2);
+        gpio_output(gpio->clkin_ctrl);
+        gpio_output(gpio->pps_out);
+        gpio_input(gpio->trigger_in);
+        gpio_input(gpio->trigger_out);
+        gpio_clear(gpio->fpga_cfg_spi_cs);
+        gpio_output(gpio->fpga_cfg_spi_cs);
+        gpio_clear(gpio->fpga_cfg_creset);
+        gpio_output(gpio->fpga_cfg_creset);
+        gpio_input(gpio->fpga_cfg_cdone);
+        gpio_input(gpio->max5864_select);
+    }
+#endif
+
+    /* enable input on SCL and SDA pins */
+    SCU_SFSI2C0 = SCU_I2C0_NOMINAL;
+}
+
+/* Run after pins_shutdown() and prior to enabling power supplies. */
+void pins_setup(void) {
+    /* Detect Platform */
+    const platform_gpio_t* gpio = platform_gpio();
+    const platform_scu_t* scu = platform_scu();
+
+    /* Configure LEDs */
+    led_off(0);
+    led_off(1);
+    led_off(2);
+#ifdef IS_FOUR_LEDS
+    if (IS_FOUR_LEDS) {
+        led_off(3);
+    }
+#endif
+
+    gpio_output(gpio->led[0]);
+    gpio_output(gpio->led[1]);
+    gpio_output(gpio->led[2]);
+
+#ifdef IS_FOUR_LEDS
+    if (IS_FOUR_LEDS) {
+        gpio_output(gpio->led[3]);
+    }
+#endif
+
+    /* Configure external clock in */
+    scu_pinmux(scu->PINMUX_GP_CLKIN, SCU_CLK_IN | SCU_CONF_FUNCTION1);
+}

firmware/baseband/sd_over_usb/proc_sd_over_usb.cpp

@@ -44,11 +44,11 @@ CH_IRQ_HANDLER(Vector60) {
 }
 
 int main() {
+    start_usb();
+
     sdcStart(&SDCD1, nullptr);
     if (sdcConnect(&SDCD1) == CH_FAILED) chDbgPanic("no sd card #1");
 
-    start_usb();
-
     while (true) {
         usb_transfer();
     }

firmware/baseband/sd_over_usb/scsi.c

@@ -23,14 +23,35 @@
 #include "scsi.h"
 #include "diskio.h"
 #include "gpio_lpc.h"
+#include "delay.h"
 #include <libopencm3/lpc43xx/scu.h>
 #include <libopencm3/lpc43xx/rgu.h>
 #include <libopencm3/lpc43xx/wwdt.h>
 #include "string.h"
 
+/* Maximum number of 512-byte blocks transferred per SD command / USB bulk
+ * transfer. The data region of usb_bulk_buffer is 16 KiB (0x0000..0x3FFF),
+ * so this must be <= 32. It is split into two equal halves for double
+ * buffering. */
+#define MAX_BLOCKS_PER_TRANSFER 32
+#define HALF_BLOCKS (MAX_BLOCKS_PER_TRANSFER / 2)
+
 volatile bool usb_bulk_block_done = false;
 
-void delay(uint32_t duration);
+/* Per-buffer-half completion flags for the asynchronous (double-buffered)
+ * bulk transfers. Index 0 = usb_bulk_buffer[0], index 1 = second half. */
+volatile bool usb_bulk_block_done_async[2] = {false, false};
+
+static uint32_t usb_bulk_buffer_index(const void* const data) {
+    return (data == &usb_bulk_buffer[HALF_BLOCKS * 512]) ? 1 : 0;
+}
+
+void usb_bulk_block_cb_async(void* user_data, unsigned int bytes_transferred) {
+    const uint32_t idx = (uint32_t)(uintptr_t)user_data;
+    usb_bulk_block_done_async[idx] = true;
+
+    (void)bytes_transferred;
+}
 
 void usb_bulk_block_cb(void* user_data, unsigned int bytes_transferred) {
     usb_bulk_block_done = true;
@@ -65,6 +86,49 @@ void usb_receive_bulk(void* const data, const uint32_t maximum_length) {
     while (!usb_bulk_block_done);
 }
 
+/* Schedule a bulk IN transfer without waiting for it to complete. The caller
+ * must later call usb_send_bulk_wait_finish() with the same buffer before
+ * reusing it. */
+void usb_send_bulk_start(void* const data, const uint32_t maximum_length) {
+    const uint32_t idx = usb_bulk_buffer_index(data);
+    usb_bulk_block_done_async[idx] = false;
+
+    usb_transfer_schedule_block(
+        &usb_endpoint_bulk_in,
+        data,
+        maximum_length,
+        usb_bulk_block_cb_async,
+        (void*)(uintptr_t)idx);
+}
+
+/* Wait for a bulk IN transfer scheduled by usb_send_bulk_start() to finish. */
+void usb_send_bulk_wait_finish(void* const data) {
+    const uint32_t idx = usb_bulk_buffer_index(data);
+    while (!usb_bulk_block_done_async[idx]);
+}
+
+/* Schedule a bulk OUT transfer without waiting for it to complete. The caller
+ * must later call usb_receive_bulk_finish() with the same buffer before
+ * reading from it. */
+void usb_receive_bulk_start(void* const data, const uint32_t maximum_length) {
+    const uint32_t idx = usb_bulk_buffer_index(data);
+    usb_bulk_block_done_async[idx] = false;
+
+    usb_transfer_schedule_block(
+        &usb_endpoint_bulk_out,
+        data,
+        maximum_length,
+        usb_bulk_block_cb_async,
+        (void*)(uintptr_t)idx);
+}
+
+/* Wait for a bulk OUT transfer scheduled by usb_receive_bulk_start() to
+ * finish. */
+void usb_receive_bulk_finish(void* const data) {
+    const uint32_t idx = usb_bulk_buffer_index(data);
+    while (!usb_bulk_block_done_async[idx]);
+}
+
 void usb_send_csw(msd_cbw_t* msd_cbw_data, uint8_t status) {
     msd_csw_t csw = {
         .signature = MSD_CSW_SIGNATURE,
@@ -213,22 +277,95 @@ static data_request_t decode_data_request(const uint8_t* cmd) {
 uint8_t data_read10(msd_cbw_t* msd_cbw_data) {
     data_request_t req = decode_data_request(msd_cbw_data->cmd_data);
 
-    for (size_t block_index = 0; block_index < req.blk_cnt; block_index++) {
-        read_block(req.first_lba + block_index, &usb_bulk_buffer[0], 1 /* n blocks */);
-        usb_send_bulk(&usb_bulk_buffer[0], 512);
+    uint32_t lba = req.first_lba;
+    uint32_t remaining = req.blk_cnt;
+    uint8_t* buf[2] = {&usb_bulk_buffer[0], &usb_bulk_buffer[HALF_BLOCKS * 512]};
+    uint32_t buf_idx = 0;
+    uint8_t* in_flight = NULL;
+
+    if (remaining == 0)
+        return 0;
+
+    /* Read the first chunk and start sending it. */
+    uint32_t n = (remaining > HALF_BLOCKS) ? HALF_BLOCKS : remaining;
+    if (read_block(lba, buf[0], n))
+        return 1;
+    usb_send_bulk_start(buf[0], n * 512);
+    in_flight = buf[0];
+    lba += n;
+    remaining -= n;
+
+    /* While USB sends the previous chunk, read the next one into the other
+     * half of the buffer. */
+    while (remaining > 0) {
+        buf_idx ^= 1;
+        n = (remaining > HALF_BLOCKS) ? HALF_BLOCKS : remaining;
+
+        if (read_block(lba, buf[buf_idx], n)) {
+            usb_send_bulk_wait_finish(in_flight);
+            return 1;
+        }
+
+        usb_send_bulk_wait_finish(in_flight);
+        usb_send_bulk_start(buf[buf_idx], n * 512);
+        in_flight = buf[buf_idx];
+
+        lba += n;
+        remaining -= n;
     }
 
+    usb_send_bulk_wait_finish(in_flight);
     return 0;
 }
 
 uint8_t data_write10(msd_cbw_t* msd_cbw_data) {
     data_request_t req = decode_data_request(msd_cbw_data->cmd_data);
 
-    for (size_t block_index = 0; block_index < req.blk_cnt; block_index++) {
-        usb_receive_bulk(&usb_bulk_buffer[0], 512);
-        write_block(req.first_lba + block_index, &usb_bulk_buffer[0], 1 /* n blocks */);
+    uint32_t lba = req.first_lba;
+    uint32_t remaining = req.blk_cnt;
+    uint8_t* buf[2] = {&usb_bulk_buffer[0], &usb_bulk_buffer[HALF_BLOCKS * 512]};
+    uint32_t buf_idx = 0;
+    uint8_t* pending_buf = NULL;
+    uint32_t pending_lba = 0;
+    uint32_t pending_n = 0;
+
+    if (remaining == 0)
+        return 0;
+
+    /* Start receiving the first chunk. */
+    uint32_t n = (remaining > HALF_BLOCKS) ? HALF_BLOCKS : remaining;
+    usb_receive_bulk_start(buf[0], n * 512);
+    pending_buf = buf[0];
+    pending_lba = lba;
+    pending_n = n;
+    lba += n;
+    remaining -= n;
+
+    /* While USB receives the next chunk, write the previous one to the SD
+     * card. */
+    while (remaining > 0) {
+        buf_idx ^= 1;
+        n = (remaining > HALF_BLOCKS) ? HALF_BLOCKS : remaining;
+
+        usb_receive_bulk_start(buf[buf_idx], n * 512);
+
+        usb_receive_bulk_finish(pending_buf);
+        if (write_block(pending_lba, pending_buf, pending_n)) {
+            usb_receive_bulk_finish(buf[buf_idx]);
+            return 1;
+        }
+
+        pending_buf = buf[buf_idx];
+        pending_lba = lba;
+        pending_n = n;
+        lba += n;
+        remaining -= n;
     }
 
+    usb_receive_bulk_finish(pending_buf);
+    if (write_block(pending_lba, pending_buf, pending_n))
+        return 1;
+
     return 0;
 }
 
@@ -293,7 +430,7 @@ void scsi_command(msd_cbw_t* msd_cbw_data) {
             gpio_output(&dfu);
             gpio_clear(&dfu);
 
-            delay(50 * 40800);
+            delay_ms(50);
 
             RESET_CTRL0 = (1 << 0);
             break;

firmware/baseband/sd_over_usb/sd_over_usb.c

@@ -23,6 +23,8 @@
 #include "sd_over_usb.h"
 #include "scsi.h"
 #include "usb_descriptor.h"
+#include <rom_iap.h>
+#include "delay.h"
 
 #include <string.h>
 
@@ -36,8 +38,14 @@
 extern usb_configuration_t* usb_configurations[];
 
 static const usb_device_t usb_device_sd_over_usb = {
-    .descriptor = usb_descriptor_device,
-    .descriptor_strings = usb_descriptor_strings,
+#ifdef IS_NOT_PRALINE
+    .descriptor = usb_descriptor_device_hackrf,
+    .descriptor_strings = usb_descriptor_strings_hackrf_one,
+#endif
+#ifdef IS_PRALINE
+    .descriptor = usb_descriptor_device_hackrf,
+    .descriptor_strings = usb_descriptor_strings_praline,
+#endif
     .qualifier_descriptor = usb_descriptor_device_qualifier,
     .configurations = &usb_configurations,
     .configuration = 0,
@@ -91,16 +99,83 @@ void usb_configuration_changed(usb_device_t* const device) {
     usb_endpoint_init(&usb_endpoint_bulk_out, false);
 }
 
+void usb_set_descriptor_by_serial_number(void) {
+    iap_cmd_res_t iap_cmd_res;
+
+    /* Read IAP Serial Number Identification */
+    iap_cmd_res.cmd_param.command_code = IAP_CMD_READ_SERIAL_NO;
+    iap_cmd_call(&iap_cmd_res);
+
+    if (iap_cmd_res.status_res.status_ret == CMD_SUCCESS) {
+        usb_descriptor_string_serial_number[0] =
+            USB_DESCRIPTOR_STRING_SERIAL_BUF_LEN;
+        usb_descriptor_string_serial_number[1] = USB_DESCRIPTOR_TYPE_STRING;
+
+        /* 32 characters of serial number, convert to UTF-16LE */
+        for (size_t i = 0; i < USB_DESCRIPTOR_STRING_SERIAL_LEN; i++) {
+            const uint_fast8_t nibble =
+                (iap_cmd_res.status_res.iap_result[i >> 3] >>
+                 (28 - (i & 7) * 4)) &
+                0xf;
+            const char c =
+                (nibble > 9) ? ('a' + nibble - 10) : ('0' + nibble);
+            usb_descriptor_string_serial_number[2 + i * 2] = c;
+            usb_descriptor_string_serial_number[3 + i * 2] = 0x00;
+        }
+    } else {
+        usb_descriptor_string_serial_number[0] = 2;
+        usb_descriptor_string_serial_number[1] = USB_DESCRIPTOR_TYPE_STRING;
+    }
+}
+
 void start_usb(void) {
+    // Detect hardware platform before we do anything else.
     detect_hardware_platform();
-    pin_setup();
+    board_id_t board_id = detected_platform();
+
+    pins_shutdown();
+    sgpio_pin_shutdown(&sgpio_config);
+    rf_path_pin_shutdown();
+    if (board_id != BOARD_ID_RAD1O) {
+        clock_gen_shutdown();
+    }
+    delay_ms(10);
+    pins_setup();
+    cpld_jtag_pin_setup();
+
     cpu_clock_init();
 
-    memcpy(&usb_device, &usb_device_sd_over_usb, sizeof(usb_device_sd_over_usb));
+#ifndef DFU_MODE
+    usb_set_descriptor_by_serial_number();
+#endif
 
     usb_set_configuration_changed_cb(usb_configuration_changed);
     usb_peripheral_reset();
 
+#ifdef IS_HACKRF_ONE
+    if (IS_HACKRF_ONE) {
+        memcpy(&usb_device,
+               &usb_device_sd_over_usb,
+               sizeof(usb_device_sd_over_usb));
+    }
+#endif
+#ifdef IS_JAWBREAKER
+    if (IS_JAWBREAKER) {
+        memcpy(&usb_device,
+               &usb_device_jawbreaker,
+               sizeof(usb_device_jawbreaker));
+    }
+#endif
+#ifdef IS_RAD1O
+    if (IS_RAD1O) {
+        memcpy(&usb_device, &usb_device_rad1o, sizeof(usb_device_rad1o));
+    }
+#endif
+#ifdef IS_PRALINE
+    if (IS_PRALINE) {
+        memcpy(&usb_device, &usb_device_sd_over_usb, sizeof(usb_device_sd_over_usb));
+    }
+#endif
     usb_device_init(0, &usb_device);
 
     usb_queue_init(&usb_endpoint_control_out_queue);
@@ -109,9 +184,6 @@ void start_usb(void) {
     usb_queue_init(&usb_endpoint_bulk_in_queue);
 
     usb_endpoint_init(&usb_endpoint_control_out, false);
-    /* Match the new usb_endpoint_init() contract introduced upstream by
-     * db73ecbf, control IN needs ZLP for transfers whose length is a
-     * multiple of the EP0 max packet size, otherwise the host hangs. */
     usb_endpoint_init(&usb_endpoint_control_in, true);
 
     nvic_set_priority(NVIC_USB0_IRQ, 255);

firmware/baseband/sd_over_usb/usb_api_transceiver.c

@@ -0,0 +1,766 @@
+/*
+ * Copyright 2012-2022 Great Scott Gadgets <info@greatscottgadgets.com>
+ * Copyright 2012 Jared Boone
+ * Copyright 2013 Benjamin Vernoux
+ * Copyright 2024 Bernd Herzog
+ *
+ * This file is part of HackRF.
+ *
+ * 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.
+ */
+
+#include "usb_api_transceiver.h"
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#include <libopencm3/cm3/nvic.h>
+#include <libopencm3/lpc43xx/gpdma.h>
+#include <libopencm3/lpc43xx/usb.h>
+
+#include <clock_gen.h>
+#include <fixed_point.h>
+#include <gpdma.h>
+#include <hackrf_ui.h>
+#include <leds.h>
+#include <m0_state.h>
+#include <operacake_sctimer.h>
+#include <platform_detect.h>
+#include <radio.h>
+#include <sgpio.h>
+#include <streaming.h>
+#include <transceiver_mode.h>
+#include "common/usb.h"
+#include <usb_queue.h>
+#include <usb_request.h>
+#include <usb_type.h>
+
+#include "usb_buffer.h"
+#include "usb_endpoint.h"
+
+#define USB_TRANSFER_SIZE 0x4000
+#define DMA_TRANSFER_SIZE 0x2000
+
+#define BUF_HALF_MASK (USB_SAMP_BUFFER_SIZE >> 1)
+
+// Unless we know the host knows our buffer size, we'll avoid leaving TX
+// until we've transmitted all bytes sent by the host. This flag is cleared
+// when the host requests our buffer size.
+bool auto_tx_flush = true;
+
+volatile uint32_t dma_started, dma_pending, usb_started, usb_completed;
+
+typedef struct {
+    uint32_t freq_mhz;
+    uint32_t freq_hz;
+} set_freq_params_t;
+
+set_freq_params_t set_freq_params;
+
+struct set_freq_explicit_params {
+    uint64_t if_freq_hz; /* intermediate frequency */
+    uint64_t lo_freq_hz; /* front-end local oscillator frequency */
+    uint8_t path;        /* image rejection filter path */
+};
+
+struct set_freq_explicit_params explicit_params;
+
+typedef struct {
+    uint32_t freq_hz;
+    uint32_t divider;
+} set_sample_r_params_t;
+
+set_sample_r_params_t set_sample_r_params;
+
+void transceiver_dma_setup(void);
+
+usb_request_status_t usb_vendor_request_set_baseband_filter_bandwidth(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        const uint32_t bandwidth =
+            (endpoint->setup.index << 16) | endpoint->setup.value;
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_BB_BANDWIDTH_TX,
+            bandwidth);
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_BB_BANDWIDTH_RX,
+            bandwidth);
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_freq(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        usb_transfer_schedule_block(
+            endpoint->out,
+            &set_freq_params,
+            sizeof(set_freq_params_t),
+            NULL,
+            NULL);
+    } else if (stage == USB_TRANSFER_STAGE_DATA) {
+        const uint64_t freq =
+            set_freq_params.freq_mhz * 1000000ULL + set_freq_params.freq_hz;
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_FREQUENCY_RF,
+            freq * FP_ONE_HZ);
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_FREQUENCY_IF,
+            RADIO_UNSET);
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_FREQUENCY_LO,
+            RADIO_UNSET);
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_IMAGE_REJECT,
+            RADIO_UNSET);
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_freq_explicit(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        usb_transfer_schedule_block(
+            endpoint->out,
+            &explicit_params,
+            sizeof(struct set_freq_explicit_params),
+            NULL,
+            NULL);
+    } else if (stage == USB_TRANSFER_STAGE_DATA) {
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_FREQUENCY_IF,
+            explicit_params.if_freq_hz * FP_ONE_HZ);
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_FREQUENCY_LO,
+            explicit_params.lo_freq_hz * FP_ONE_HZ);
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_IMAGE_REJECT,
+            explicit_params.path);
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+/*
+ * Convert fractional sample rate to units of 1/(2**36) Hz.
+ */
+static inline fp_28_36_t round_sample_rate(uint64_t num, uint32_t denom) {
+    uint64_t q1, r1, q2, r2, q3;
+
+    if (denom == 0) {
+        denom = 1;
+    }
+
+    q1 = num / denom;
+    r1 = num % denom;
+
+    q2 = (r1 << 32) / denom;
+    r2 = (r1 << 32) % denom;
+
+    q3 = ((r2 << 4) + (denom >> 1)) / denom;
+
+    return (q1 << 36) + (q2 << 4) + q3;
+}
+
+usb_request_status_t usb_vendor_request_set_sample_rate_frac(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        usb_transfer_schedule_block(
+            endpoint->out,
+            &set_sample_r_params,
+            sizeof(set_sample_r_params_t),
+            NULL,
+            NULL);
+    } else if (stage == USB_TRANSFER_STAGE_DATA) {
+        uint32_t numerator = set_sample_r_params.freq_hz;
+        uint32_t denominator = set_sample_r_params.divider;
+        uint64_t value = round_sample_rate(numerator, denominator);
+        radio_reg_write(&radio, RADIO_BANK_REQUESTED, RADIO_SAMPLE_RATE, value);
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_amp_enable(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_GAIN_TX_RF,
+            endpoint->setup.value);
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_GAIN_RX_RF,
+            endpoint->setup.value);
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_lna_gain(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        uint8_t gain = endpoint->setup.index;
+        radio_reg_write(&radio, RADIO_BANK_REQUESTED, RADIO_GAIN_RX_IF, gain);
+        endpoint->buffer[0] = RADIO_OK;
+        usb_transfer_schedule_block(
+            endpoint->in,
+            &endpoint->buffer,
+            1,
+            NULL,
+            NULL);
+        usb_transfer_schedule_ack(endpoint->out);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_vga_gain(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        uint8_t gain = endpoint->setup.index;
+        radio_reg_write(&radio, RADIO_BANK_REQUESTED, RADIO_GAIN_RX_BB, gain);
+        endpoint->buffer[0] = RADIO_OK;
+        usb_transfer_schedule_block(
+            endpoint->in,
+            &endpoint->buffer,
+            1,
+            NULL,
+            NULL);
+        usb_transfer_schedule_ack(endpoint->out);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_txvga_gain(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        uint8_t gain = endpoint->setup.index;
+        radio_reg_write(&radio, RADIO_BANK_REQUESTED, RADIO_GAIN_TX_IF, gain);
+        endpoint->buffer[0] = RADIO_OK;
+        usb_transfer_schedule_block(
+            endpoint->in,
+            &endpoint->buffer,
+            1,
+            NULL,
+            NULL);
+        usb_transfer_schedule_ack(endpoint->out);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_antenna_enable(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    switch (detected_platform()) {
+        case BOARD_ID_HACKRF1_OG:
+        case BOARD_ID_HACKRF1_R9:
+        case BOARD_ID_PRALINE:
+            // supported
+            break;
+        default:
+            return USB_REQUEST_STATUS_STALL;
+    }
+
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_BIAS_TEE,
+            endpoint->setup.value);
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+static volatile uint32_t _tx_underrun_limit;
+static volatile uint32_t _rx_overrun_limit;
+
+volatile transceiver_request_t transceiver_request = {
+    .mode = TRANSCEIVER_MODE_OFF,
+    .seq = 0,
+};
+
+void transceiver_usb_setup_complete(usb_endpoint_t* const endpoint) {
+    if (transceiver_request.mode == TRANSCEIVER_MODE_TX &&
+        endpoint->setup.request == 1 && auto_tx_flush) {
+        // This is a request to leave TX mode. Do so but NAK for now.
+        request_transceiver_mode(endpoint->setup.value);
+    } else {
+        usb_setup_complete(endpoint);
+    }
+}
+
+// Must be called from an atomic context (normally USB ISR)
+void request_transceiver_mode(transceiver_mode_t mode) {
+    usb_endpoint_flush(&usb_endpoint_bulk_in);
+    usb_endpoint_flush(&usb_endpoint_bulk_out);
+
+    transceiver_request.mode = mode;
+    transceiver_request.seq++;
+}
+
+void transceiver_shutdown(void) {
+    baseband_streaming_disable(&sgpio_config);
+    operacake_sctimer_reset_state();
+
+    usb_endpoint_flush(&usb_endpoint_bulk_in);
+    usb_endpoint_flush(&usb_endpoint_bulk_out);
+
+    led_off(LED2);
+    led_off(LED3);
+    radio_switch_opmode(&radio, TRANSCEIVER_MODE_OFF);
+    m0_set_mode(M0_MODE_IDLE);
+}
+
+void transceiver_startup(const transceiver_mode_t mode) {
+    dma_started = 0;
+    dma_pending = 0;
+    usb_started = 0;
+    usb_completed = 0;
+
+    transceiver_dma_setup();
+
+    radio_switch_opmode(&radio, mode);
+
+    switch (mode) {
+        case TRANSCEIVER_MODE_RX_SWEEP:
+        case TRANSCEIVER_MODE_RX:
+            led_off(LED3);
+            led_on(LED2);
+            m0_set_mode(M0_MODE_RX);
+            m0_state.shortfall_limit = _rx_overrun_limit;
+            break;
+        case TRANSCEIVER_MODE_TX:
+            led_off(LED2);
+            led_on(LED3);
+            m0_set_mode(M0_MODE_TX_START);
+            m0_state.shortfall_limit = _tx_underrun_limit;
+            break;
+        default:
+            break;
+    }
+
+    activate_best_clock_source();
+}
+
+usb_request_status_t usb_vendor_request_set_transceiver_mode(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        switch (endpoint->setup.value) {
+            case TRANSCEIVER_MODE_OFF:
+            case TRANSCEIVER_MODE_RX:
+            case TRANSCEIVER_MODE_TX:
+            case TRANSCEIVER_MODE_RX_SWEEP:
+            case TRANSCEIVER_MODE_CPLD_UPDATE:
+                request_transceiver_mode(endpoint->setup.value);
+                usb_transfer_schedule_ack(endpoint->in);
+                return USB_REQUEST_STATUS_OK;
+            default:
+                return USB_REQUEST_STATUS_STALL;
+        }
+    } else {
+        return USB_REQUEST_STATUS_OK;
+    }
+}
+
+usb_request_status_t usb_vendor_request_set_hw_sync_mode(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        radio_reg_write(
+            &radio,
+            RADIO_BANK_REQUESTED,
+            RADIO_TRIGGER,
+            endpoint->setup.value);
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_tx_underrun_limit(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        uint32_t value = (endpoint->setup.index << 16) + endpoint->setup.value;
+        _tx_underrun_limit = value;
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_rx_overrun_limit(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        uint32_t value = (endpoint->setup.index << 16) + endpoint->setup.value;
+        _rx_overrun_limit = value;
+        usb_transfer_schedule_ack(endpoint->in);
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_get_buffer_size(
+    usb_endpoint_t* const endpoint,
+    const usb_transfer_stage_t stage) {
+    if (stage == USB_TRANSFER_STAGE_SETUP) {
+        uint32_t value = USB_SAMP_BUFFER_SIZE + USB_BULK_BUFFER_SIZE;
+        endpoint->buffer[0] = value & 0xff;
+        endpoint->buffer[1] = (value & 0xff00) >> 8;
+        endpoint->buffer[2] = (value & 0xff0000) >> 16;
+        endpoint->buffer[3] = (value & 0xff000000) >> 24;
+        usb_transfer_schedule_block(
+            endpoint->in,
+            &endpoint->buffer,
+            4,
+            NULL,
+            NULL);
+        usb_transfer_schedule_ack(endpoint->out);
+
+        // We now know the host is aware of our buffer size, so it
+        // can make its own decisions about flushing the buffer.
+        auto_tx_flush = false;
+
+        return USB_REQUEST_STATUS_OK;
+    }
+    return USB_REQUEST_STATUS_OK;
+}
+
+/* clang-format off */
+
+// Which GPDMA channel to use.
+const uint32_t DMA_CHANNEL = 1;
+
+// GPDMA CCONFIG register setting.
+const uint32_t DMA_CONFIG =
+	  GPDMA_CCONFIG_FLOWCNTRL(0) // memory-to-memory
+	| GPDMA_CCONFIG_IE(0)        // no error interrupt
+	| GPDMA_CCONFIG_ITC(1)       // terminal count interrupt
+	| GPDMA_CCONFIG_L(0)         // do not lock
+	| GPDMA_CCONFIG_H(0);        // do not halt
+
+// GPDMA CCONTROL register setting (excluding TRANSFERSIZE field).
+const uint32_t DMA_CONTROL =
+	  GPDMA_CCONTROL_SBSIZE(7) // 256-transfer src bursts
+	| GPDMA_CCONTROL_DBSIZE(7) // 256-transfer dst bursts
+	| GPDMA_CCONTROL_SWIDTH(2) // 32-bit src transfers
+	| GPDMA_CCONTROL_DWIDTH(2) // 32-bit dst transfers
+	| GPDMA_CCONTROL_S(0)      // AHB Master 0
+	| GPDMA_CCONTROL_D(1)      // AHB Master 1
+	| GPDMA_CCONTROL_SI(1)     // increment source
+	| GPDMA_CCONTROL_DI(1)     // increment destination
+	| GPDMA_CCONTROL_PROT1(0)  // user mode
+	| GPDMA_CCONTROL_PROT2(0)  // not bufferable
+	| GPDMA_CCONTROL_PROT3(0)  // not cacheable
+	| GPDMA_CCONTROL_I(1);     // interrupt enabled
+
+/* clang-format on */
+
+// Called before any sequence of DMA transfers.
+void transceiver_dma_setup(void) {
+    gpdma_controller_enable();
+    GPDMA_CCONFIG(DMA_CHANNEL) = DMA_CONFIG;
+    GPDMA_CCONTROL(DMA_CHANNEL) = DMA_CONTROL;
+    GPDMA_CLLI(DMA_CHANNEL) = 0;
+    GPDMA_INTTCCLEAR = (1 << DMA_CHANNEL);
+    nvic_enable_irq(NVIC_DMA_IRQ);
+}
+
+// Called to start each DMA transfer.
+void transceiver_start_dma(void* src, void* dest, size_t size) {
+    uint32_t num_transfers = size >> 2;
+    GPDMA_CCONTROL(DMA_CHANNEL) = DMA_CONTROL | num_transfers;
+    GPDMA_CSRCADDR(DMA_CHANNEL) = (uint32_t)src;
+    GPDMA_CDESTADDR(DMA_CHANNEL) = (uint32_t)dest;
+    dma_pending = size;
+    gpdma_channel_enable(DMA_CHANNEL);
+}
+
+// Called when a DMA transfer completes.
+void dma_isr(void) {
+    gpdma_channel_disable(DMA_CHANNEL);
+    GPDMA_INTTCCLEAR = (1 << DMA_CHANNEL);
+    m0_state.m4_count += dma_pending;
+    dma_pending = 0;
+}
+
+void transceiver_bulk_transfer_complete(void* user_data, unsigned int bytes_transferred) {
+    (void)user_data;
+    usb_completed += bytes_transferred;
+}
+
+typedef enum {
+    DIRECTION_RX,
+    DIRECTION_TX,
+} direction_t;
+
+void start_dma_if_possible(direction_t direction, size_t size) {
+    if (dma_pending) {
+        return;
+    }
+
+    uint32_t sampling_completed = m0_state.m0_count;
+    uint32_t dma_completed = m0_state.m4_count;
+    uint32_t samp_offset = dma_started & USB_SAMP_BUFFER_MASK;
+    uint32_t bulk_offset = dma_started & USB_BULK_BUFFER_MASK;
+    uint32_t data_available, space_in_use, space_available, samp_buf_margin;
+    uint8_t *dest, *src;
+
+    if (direction == DIRECTION_RX) {
+        data_available = sampling_completed - dma_started;
+        space_in_use = usb_completed - dma_completed;
+        space_available = USB_BULK_BUFFER_SIZE - space_in_use;
+        samp_buf_margin = USB_SAMP_BUFFER_SIZE - data_available;
+        src = &usb_samp_buffer[samp_offset];
+        dest = &usb_bulk_buffer[bulk_offset];
+    } else {
+        data_available = usb_completed - dma_started;
+        space_in_use = dma_completed - sampling_completed;
+        space_available = USB_SAMP_BUFFER_SIZE - space_in_use;
+        samp_buf_margin = space_in_use;
+        src = &usb_bulk_buffer[bulk_offset];
+        dest = &usb_samp_buffer[samp_offset];
+    }
+
+    if (data_available < size || size > space_available) {
+        return;
+    }
+
+    uint32_t m0_buf_half = sampling_completed & BUF_HALF_MASK;
+    uint32_t dma_buf_half = dma_started & BUF_HALF_MASK;
+    bool same_buf_half = m0_buf_half == dma_buf_half;
+
+    if (same_buf_half && samp_buf_margin >= (USB_SAMP_BUFFER_SIZE / 2)) {
+        return;
+    }
+
+    transceiver_start_dma(src, dest, size);
+
+    dma_started += size;
+}
+
+void start_usb_if_possible(direction_t direction) {
+    uint32_t bulk_offset = usb_started & USB_BULK_BUFFER_MASK;
+    uint32_t dma_completed = m0_state.m4_count;
+    uint32_t bytes_available;
+    usb_endpoint_t* usb_endpoint;
+
+    if (direction == DIRECTION_RX) {
+        bytes_available = dma_completed - usb_started;
+        usb_endpoint = &usb_endpoint_bulk_in;
+    } else {
+        uint32_t space_used = usb_started - dma_completed;
+        bytes_available = USB_BULK_BUFFER_SIZE - space_used;
+        usb_endpoint = &usb_endpoint_bulk_out;
+    }
+
+    if (bytes_available < USB_TRANSFER_SIZE) {
+        return;
+    }
+
+    usb_transfer_schedule_block(
+        usb_endpoint,
+        &usb_bulk_buffer[bulk_offset],
+        USB_TRANSFER_SIZE,
+        transceiver_bulk_transfer_complete,
+        NULL);
+
+    usb_started += USB_TRANSFER_SIZE;
+}
+
+int8_t saturation_buffer = 0;
+uint64_t saturation_buffer_time = 0;
+volatile uint64_t systick_counter = 0;
+
+void sys_tick_handler(void) {
+    systick_counter++;
+}
+
+void rx_mode(uint32_t seq) {
+    transceiver_startup(TRANSCEIVER_MODE_RX);
+
+    baseband_streaming_enable(&sgpio_config);
+
+    while (transceiver_request.seq == seq) {
+        start_dma_if_possible(DIRECTION_RX, DMA_TRANSFER_SIZE);
+        start_usb_if_possible(DIRECTION_RX);
+
+        int8_t sample_value = *(
+            int8_t*)&usb_samp_buffer[m0_state.m0_count & USB_SAMP_BUFFER_MASK];
+
+        if (sample_value > saturation_buffer)
+            saturation_buffer = sample_value;
+
+        if (-sample_value > saturation_buffer)
+            saturation_buffer = -sample_value;
+
+        if (saturation_buffer_time + 4 < systick_counter) {
+            saturation_buffer_time = systick_counter;
+            hackrf_ui()->set_saturation(saturation_buffer);
+            saturation_buffer = 0;
+        }
+
+        radio_update(&radio);
+    }
+
+    transceiver_shutdown();
+}
+
+void tx_mode(uint32_t seq) {
+    transceiver_startup(TRANSCEIVER_MODE_TX);
+
+    // First, make transfers directly into the sample buffer to fill it.
+    for (int i = 0; i < (USB_SAMP_BUFFER_SIZE / USB_TRANSFER_SIZE); i++) {
+        // Set up transfer.
+        usb_transfer_schedule_block(
+            &usb_endpoint_bulk_out,
+            &usb_samp_buffer[usb_started],
+            USB_TRANSFER_SIZE,
+            transceiver_bulk_transfer_complete,
+            NULL);
+        usb_started += USB_TRANSFER_SIZE;
+
+        // Wait for the transfer to complete.
+        while (usb_completed < usb_started) {
+            // Handle the host switching modes before filling the buffer.
+            if (transceiver_request.seq != seq) {
+                transceiver_shutdown();
+                return;
+            }
+
+            radio_update(&radio);
+        }
+    }
+
+    // Sample buffer is now full. Update DMA counters accordingly.
+    dma_started = USB_SAMP_BUFFER_SIZE;
+    m0_state.m4_count = USB_SAMP_BUFFER_SIZE;
+
+    // Start transmitting samples.
+    baseband_streaming_enable(&sgpio_config);
+
+    // Continue feeding samples to the sample buffer.
+    while (transceiver_request.seq == seq) {
+        start_dma_if_possible(DIRECTION_TX, DMA_TRANSFER_SIZE);
+        start_usb_if_possible(DIRECTION_TX);
+        radio_update(&radio);
+    }
+
+    // Host has now requested to stop TX. If we're not auto-flushing, we
+    // should now stop TX immediately.
+
+    if (!auto_tx_flush) {
+        transceiver_shutdown();
+        return;
+    }
+
+    // Otherwise, we should now ensure all bytes sent by the host are
+    // transmitted before we leave TX. First, we should make sure all data
+    // currently in the USB bulk buffer reaches the sample buffer.
+
+    if ((usb_started - usb_completed) > 0) {
+        // We were part way through a 16KB firmware-side transfer when
+        // the transceiver mode change request to stop TX was received.
+        //
+        // We want to include the contents of that partial transfer in
+        // the data we move to the sample buffer.
+        //
+        // The transfer was already stopped by usb_endpoint_flush(),
+        // which was called from request_transceiver_mode().
+        //
+        // We will not have had a callback, and the transfer descriptor
+        // (dTD) will not have been updated, since the transfer did not
+        // complete.
+        //
+        // However, as long as we haven't started a new transfer, we
+        // can retrieve the partial byte count from the transfer
+        // overlay in the endpoint queue head (dQH) (UM10503 25.9.1).
+
+        usb_queue_head_t* const qh =
+            usb_queue_head(usb_endpoint_bulk_out.address);
+        unsigned int bytes_remaining =
+            (qh->total_bytes & USB_TD_DTD_TOKEN_TOTAL_BYTES_MASK) >>
+            USB_TD_DTD_TOKEN_TOTAL_BYTES_SHIFT;
+        unsigned int bytes_transferred = USB_TRANSFER_SIZE - bytes_remaining;
+        usb_completed += bytes_transferred;
+    }
+
+    // Feed the remaining data from the bulk buffer to the sample buffer.
+    // At this point, we also need to handle the case where there is less data
+    // to be transferred to the sample buffer than a full-sized DMA transfer.
+
+    // Any remainder of less than 4 bytes will be ignored; this is the chunk
+    // size of our DMA transfers.
+    while ((usb_completed - m0_state.m4_count) >= 4) {
+        uint32_t data_available = usb_completed - dma_started;
+        if (data_available > DMA_TRANSFER_SIZE) {
+            start_dma_if_possible(DIRECTION_TX, DMA_TRANSFER_SIZE);
+        } else {
+            start_dma_if_possible(DIRECTION_TX, data_available);
+        }
+        radio_update(&radio);
+    }
+
+    // Wait for the data in the sample buffer to be transmitted.
+
+    // Any remainder of less than 32 bytes will be ignored; this is
+    // the chunk size used by the M0 core to transfer samples to SGPIO.
+    while ((m0_state.m4_count - m0_state.m0_count) >= 32) {
+        radio_update(&radio);
+    }
+
+    // All data received from the host has now been transmitted.
+    // Now we can ACK the control request that took us out of TX mode.
+    usb_transfer_schedule_ack(usb_endpoint_control_in.in);
+
+    transceiver_shutdown();
+}
+
+void off_mode(uint32_t seq) {
+    while (transceiver_request.seq == seq) {
+        radio_update(&radio);
+    }
+}

firmware/baseband/sd_over_usb/usb_descriptor.c

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2022 Great Scott Gadgets <info@greatscottgadgets.com>
+ * Copyright 2012-2026 Great Scott Gadgets <info@greatscottgadgets.com>
  * Copyright 2012 Jared Boone
  *
  * This file is part of HackRF.
@@ -20,22 +20,13 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <stdint.h>
-
-#include "usb_type.h"
 #include "usb_descriptor.h"
 
-#define USB_VENDOR_ID (0x0781) /* SanDisk Corp. */
+#include <stdint.h>
 
-#ifdef HACKRF_ONE
-#define USB_PRODUCT_ID (0xa7a8) /* SD card reader */
-#elif JAWBREAKER
-#define USB_PRODUCT_ID (0x604B)
-#elif RAD1O
-#define USB_PRODUCT_ID (0xCC15)
-#else
-#define USB_PRODUCT_ID (0xFFFF)
-#endif
+#include <usb_type.h>
+
+#define USB_VENDOR_ID (0x0781) /* SanDisk Corp. */
 
 #define USB_API_VERSION (0x0127) /* hardware revision */
 
@@ -50,7 +41,8 @@
 
 #define USB_STRING_LANGID (0x0409)
 
-uint8_t usb_descriptor_device[] = {
+#if defined(IS_HACKRF_ONE) || defined(IS_PRALINE)
+uint8_t usb_descriptor_device_hackrf[] = {
     18,                          // bLength
     USB_DESCRIPTOR_TYPE_DEVICE,  // bDescriptorType
     USB_WORD(0x0200),            // bcdUSB
@@ -59,13 +51,50 @@ uint8_t usb_descriptor_device[] = {
     0x00,                        // bDeviceProtocol
     USB_MAX_PACKET0,             // bMaxPacketSize0
     USB_WORD(USB_VENDOR_ID),     // idVendor
-    USB_WORD(USB_PRODUCT_ID),    // idProduct
+    USB_WORD(0xa7a8),            // idProduct /* SD card reader */
     USB_WORD(USB_API_VERSION),   // bcdDevice
     0x01,                        // iManufacturer
     0x02,                        // iProduct
     0x04,                        // iSerialNumber
     0x01                         // bNumConfigurations
 };
+#endif
+#ifdef IS_JAWBREAKER
+uint8_t usb_descriptor_device_jawbreaker[] = {
+    18,                          // bLength
+    USB_DESCRIPTOR_TYPE_DEVICE,  // bDescriptorType
+    USB_WORD(0x0200),            // bcdUSB
+    0x00,                        // bDeviceClass
+    0x00,                        // bDeviceSubClass
+    0x00,                        // bDeviceProtocol
+    USB_MAX_PACKET0,             // bMaxPacketSize0
+    USB_WORD(USB_VENDOR_ID),     // idVendor
+    USB_WORD(0x604B),            // idProduct
+    USB_WORD(USB_API_VERSION),   // bcdDevice
+    0x01,                        // iManufacturer
+    0x02,                        // iProduct
+    0x04,                        // iSerialNumber
+    0x01                         // bNumConfigurations
+};
+#endif
+#ifdef IS_RAD1O
+uint8_t usb_descriptor_device_rad1o[] = {
+    18,                          // bLength
+    USB_DESCRIPTOR_TYPE_DEVICE,  // bDescriptorType
+    USB_WORD(0x0200),            // bcdUSB
+    0x00,                        // bDeviceClass
+    0x00,                        // bDeviceSubClass
+    0x00,                        // bDeviceProtocol
+    USB_MAX_PACKET0,             // bMaxPacketSize0
+    USB_WORD(USB_VENDOR_ID),     // idVendor
+    USB_WORD(0xCC15),            // idProduct
+    USB_WORD(USB_API_VERSION),   // bcdDevice
+    0x01,                        // iManufacturer
+    0x02,                        // iProduct
+    0x04,                        // iSerialNumber
+    0x01                         // bNumConfigurations
+};
+#endif
 
 uint8_t usb_descriptor_device_qualifier[] = {
     10,                                    // bLength
@@ -161,162 +190,213 @@ uint8_t usb_descriptor_string_languages[] = {
 
 // clang-format off
 uint8_t usb_descriptor_string_manufacturer[] = {
-	40,                         // bLength
-	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
-	'G', 0x00,
-	'r', 0x00,
-	'e', 0x00,
-	'a', 0x00,
-	't', 0x00,
-	' ', 0x00,
-	'S', 0x00,
-	'c', 0x00,
-	'o', 0x00,
-	't', 0x00,
-	't', 0x00,
-	' ', 0x00,
-	'G', 0x00,
-	'a', 0x00,
-	'd', 0x00,
-	'g', 0x00,
-	'e', 0x00,
-	't', 0x00,
-	's', 0x00,
+    40,                         // bLength
+    USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+    'G', 0x00,
+    'r', 0x00,
+    'e', 0x00,
+    'a', 0x00,
+    't', 0x00,
+    ' ', 0x00,
+    'S', 0x00,
+    'c', 0x00,
+    'o', 0x00,
+    't', 0x00,
+    't', 0x00,
+    ' ', 0x00,
+    'G', 0x00,
+    'a', 0x00,
+    'd', 0x00,
+    'g', 0x00,
+    'e', 0x00,
+    't', 0x00,
+    's', 0x00,
 };
 
-uint8_t usb_descriptor_string_product[] = {
-#ifdef HACKRF_ONE
-	34,                         // bLength
-	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
-	'P', 0x00,
-	'o', 0x00,
-	'r', 0x00,
-	't', 0x00,
-	'a', 0x00,
-	'P', 0x00,
-	'a', 0x00,
-	'c', 0x00,
-	'k', 0x00,
-	' ', 0x00,
+#ifdef IS_HACKRF_ONE
+uint8_t usb_descriptor_string_product_hackrf_one[] = {
+    34,                         // bLength
+    USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+    'P', 0x00,
+    'o', 0x00,
+    'r', 0x00,
+    't', 0x00,
+    'a', 0x00,
+    'P', 0x00,
+    'a', 0x00,
+    'c', 0x00,
+    'k', 0x00,
+    ' ', 0x00,
 
-	'M', 0x00,
-	'a', 0x00,
-	'y', 0x00,
-	'h', 0x00,
-	'e', 0x00,
-	'm', 0x00,
-
-#elif JAWBREAKER
-	36,                         // bLength
-	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
-	'H', 0x00,
-	'a', 0x00,
-	'c', 0x00,
-	'k', 0x00,
-	'R', 0x00,
-	'F', 0x00,
-	' ', 0x00,
-	'J', 0x00,
-	'a', 0x00,
-	'w', 0x00,
-	'b', 0x00,
-	'r', 0x00,
-	'e', 0x00,
-	'a', 0x00,
-	'k', 0x00,
-	'e', 0x00,
-	'r', 0x00,
-#elif RAD1O
-	12,                         // bLength
-	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
-	'r', 0x00,
-	'a', 0x00,
-	'd', 0x00,
-	'1', 0x00,
-	'o', 0x00,
-#else
-	14,                         // bLength
-	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
-	'H', 0x00,
-	'a', 0x00,
-	'c', 0x00,
-	'k', 0x00,
-	'R', 0x00,
-	'F', 0x00,
+    'M', 0x00,
+    'a', 0x00,
+    'y', 0x00,
+    'h', 0x00,
+    'e', 0x00,
+    'm', 0x00,
+};
 #endif
+#ifdef IS_PRALINE
+uint8_t usb_descriptor_string_product_praline[] = {
+    34,                         // bLength
+    USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+    'P', 0x00,
+    'o', 0x00,
+    'r', 0x00,
+    't', 0x00,
+    'a', 0x00,
+    'P', 0x00,
+    'a', 0x00,
+    'c', 0x00,
+    'k', 0x00,
+    ' ', 0x00,
+
+    'M', 0x00,
+    'a', 0x00,
+    'y', 0x00,
+    'h', 0x00,
+    'e', 0x00,
+    'm', 0x00,
 };
+#endif
+#ifdef IS_JAWBREAKER
+uint8_t usb_descriptor_string_product_jawbreaker[] = {
+    36,                         // bLength
+    USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+    'H', 0x00,
+    'a', 0x00,
+    'c', 0x00,
+    'k', 0x00,
+    'R', 0x00,
+    'F', 0x00,
+    ' ', 0x00,
+    'J', 0x00,
+    'a', 0x00,
+    'w', 0x00,
+    'b', 0x00,
+    'r', 0x00,
+    'e', 0x00,
+    'a', 0x00,
+    'k', 0x00,
+    'e', 0x00,
+    'r', 0x00,
+};
+#endif
+#ifdef IS_RAD1O
+uint8_t usb_descriptor_string_product_rad1o[] = {
+    12,                         // bLength
+    USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+    'r', 0x00,
+    'a', 0x00,
+    'd', 0x00,
+    '1', 0x00,
+    'o', 0x00,
+};
+#endif
 
 uint8_t usb_descriptor_string_config_description[] = {
-	24,                         // bLength
-	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
-	'T', 0x00,
-	'r', 0x00,
-	'a', 0x00,
-	'n', 0x00,
-	's', 0x00,
-	'c', 0x00,
-	'e', 0x00,
-	'i', 0x00,
-	'v', 0x00,
-	'e', 0x00,
-	'r', 0x00,
+    24,                         // bLength
+    USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+    'T', 0x00,
+    'r', 0x00,
+    'a', 0x00,
+    'n', 0x00,
+    's', 0x00,
+    'c', 0x00,
+    'e', 0x00,
+    'i', 0x00,
+    'v', 0x00,
+    'e', 0x00,
+    'r', 0x00,
 };
 
 #ifdef DFU_MODE
 uint8_t usb_descriptor_string_serial_number[] = {
-	30,                         // bLength
-	USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
-	'R', 0x00,
-	'u', 0x00,
-	'n', 0x00,
-	'n', 0x00,
-	'i', 0x00,
-	'n', 0x00,
-	'g', 0x00,
-	'F', 0x00,
-	'r', 0x00,
-	'o', 0x00,
-	'm', 0x00,
-	'R', 0x00,
-	'A', 0x00,
-	'M', 0x00,
+    30,                         // bLength
+    USB_DESCRIPTOR_TYPE_STRING, // bDescriptorType
+    'R', 0x00,
+    'u', 0x00,
+    'n', 0x00,
+    'n', 0x00,
+    'i', 0x00,
+    'n', 0x00,
+    'g', 0x00,
+    'F', 0x00,
+    'r', 0x00,
+    'o', 0x00,
+    'm', 0x00,
+    'R', 0x00,
+    'A', 0x00,
+    'M', 0x00,
 };
 #else
 uint8_t usb_descriptor_string_serial_number[USB_DESCRIPTOR_STRING_SERIAL_BUF_LEN];
 #endif
 
-uint8_t* usb_descriptor_strings[] = {
-	usb_descriptor_string_languages,
-	usb_descriptor_string_manufacturer,
-	usb_descriptor_string_product,
-	usb_descriptor_string_config_description,
-	usb_descriptor_string_serial_number,
-	0, // TERMINATOR
+#ifdef IS_HACKRF_ONE
+uint8_t* usb_descriptor_strings_hackrf_one[] = {
+    usb_descriptor_string_languages,
+    usb_descriptor_string_manufacturer,
+    usb_descriptor_string_product_hackrf_one,
+    usb_descriptor_string_config_description,
+    usb_descriptor_string_serial_number,
+    0, // TERMINATOR
 };
+#endif
+#ifdef IS_PRALINE
+uint8_t* usb_descriptor_strings_praline[] = {
+    usb_descriptor_string_languages,
+    usb_descriptor_string_manufacturer,
+    usb_descriptor_string_product_praline,
+    usb_descriptor_string_config_description,
+    usb_descriptor_string_serial_number,
+    0, // TERMINATOR
+};
+#endif
+#ifdef IS_JAWBREAKER
+uint8_t* usb_descriptor_strings_jawbreaker[] = {
+    usb_descriptor_string_languages,
+    usb_descriptor_string_manufacturer,
+    usb_descriptor_string_product_jawbreaker,
+    usb_descriptor_string_config_description,
+    usb_descriptor_string_serial_number,
+    0, // TERMINATOR
+};
+#endif
+#ifdef IS_RAD1O
+uint8_t* usb_descriptor_strings_rad1o[] = {
+    usb_descriptor_string_languages,
+    usb_descriptor_string_manufacturer,
+    usb_descriptor_string_product_rad1o,
+    usb_descriptor_string_config_description,
+    usb_descriptor_string_serial_number,
+    0, // TERMINATOR
+};
+#endif
 
 uint8_t wcid_string_descriptor[] = {
-	18,                          // bLength
-	USB_DESCRIPTOR_TYPE_STRING,  // bDescriptorType
-	'M', 0x00,
-	'S', 0x00,
-	'F', 0x00,
-	'T', 0x00,
-	'1', 0x00,
-	'0', 0x00,
-	'0', 0x00,
-	USB_WCID_VENDOR_REQ, // vendor request code for further descriptor
-	0x00
+    18,                          // bLength
+    USB_DESCRIPTOR_TYPE_STRING,  // bDescriptorType
+    'M', 0x00,
+    'S', 0x00,
+    'F', 0x00,
+    'T', 0x00,
+    '1', 0x00,
+    '0', 0x00,
+    '0', 0x00,
+    USB_WCID_VENDOR_REQ, // vendor request code for further descriptor
+    0x00
 };
 
 uint8_t wcid_feature_descriptor[] = {
-	0x28, 0x00, 0x00, 0x00,                  // bLength
-	USB_WORD(0x0100),                        // WCID version
-	USB_WORD(0x0004),                        // WICD descriptor index
-	0x01,                                    // bNumSections
-	0x00,0x00,0x00,0x00,0x00,0x00,0x00,      // Reserved
-	0x00,                                    // bInterfaceNumber
-	0x01,                                    // Reserved
-	'W', 'I', 'N', 'U', 'S', 'B', 0x00,0x00, // Compatible ID, padded with zeros
-	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Sub-compatible ID
-	0x00,0x00,0x00,0x00,0x00,0x00            // Reserved
-};
+    0x28, 0x00, 0x00, 0x00,                  // bLength
+    USB_WORD(0x0100),                        // WCID version
+    USB_WORD(0x0004),                        // WICD descriptor index
+    0x01,                                    // bNumSections
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,      // Reserved
+    0x00,                                    // bInterfaceNumber
+    0x01,                                    // Reserved
+    'W', 'I', 'N', 'U', 'S', 'B', 0x00,0x00, // Compatible ID, padded with zeros
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // Sub-compatible ID
+    0x00,0x00,0x00,0x00,0x00,0x00            // Reserved
+};

firmware/baseband/sd_over_usb/usb_descriptor.h

@@ -20,22 +20,46 @@
  * Boston, MA 02110-1301, USA.
  */
 
+#pragma once
+
 #include <stdint.h>
 
-extern uint8_t usb_descriptor_device[];
+#if defined(IS_HACKRF_ONE) || defined(IS_PRALINE)
+extern uint8_t usb_descriptor_device_hackrf[];
+#endif
+#ifdef IS_JAWBREAKER
+extern uint8_t usb_descriptor_device_jawbreaker[];
+#endif
+#ifdef IS_RAD1O
+extern uint8_t usb_descriptor_device_rad1o[];
+#endif
 extern uint8_t usb_descriptor_device_qualifier[];
 extern uint8_t usb_descriptor_configuration_full_speed[];
 extern uint8_t usb_descriptor_configuration_high_speed[];
 extern uint8_t usb_descriptor_string_languages[];
 extern uint8_t usb_descriptor_string_manufacturer[];
-extern uint8_t usb_descriptor_string_product[];
+#ifdef IS_HACKRF_ONE
+extern uint8_t usb_descriptor_string_product_hackrf_one[];
+#endif
+#ifdef IS_PRALINE
+extern uint8_t usb_descriptor_string_product_praline[];
+#endif
+#ifdef IS_JAWBREAKER
+extern uint8_t usb_descriptor_string_product_jawbreaker[];
+#endif
+#ifdef IS_RAD1O
+extern uint8_t usb_descriptor_string_product_rad1o[];
+#endif
 
 #define USB_DESCRIPTOR_STRING_SERIAL_LEN 32
 #define USB_DESCRIPTOR_STRING_SERIAL_BUF_LEN \
     (USB_DESCRIPTOR_STRING_SERIAL_LEN * 2 + 2) /* UTF-16LE */
 extern uint8_t usb_descriptor_string_serial_number[];
 
-extern uint8_t* usb_descriptor_strings[];
+extern uint8_t* usb_descriptor_strings_hackrf_one[];
+extern uint8_t* usb_descriptor_strings_jawbreaker[];
+extern uint8_t* usb_descriptor_strings_rad1o[];
+extern uint8_t* usb_descriptor_strings_praline[];
 
 #define USB_WCID_VENDOR_REQ 0x19
 extern uint8_t wcid_string_descriptor[];

firmware/baseband/spectrum_collector.cpp

@@ -73,21 +73,34 @@ void SpectrumCollector::set_decimation_factor(
  * perform the deferred task on the buffer of data we prepared.
  */
 
-void SpectrumCollector::feed(
+bool SpectrumCollector::feed(
     const buffer_c16_t& channel,
     const int32_t filter_low_frequency,
     const int32_t filter_high_frequency,
     const int32_t filter_transition) {
     // Called from baseband processing thread.
+    set_filter(
+        filter_low_frequency,
+        filter_high_frequency,
+        filter_transition);
+
+    bool block_completed = false;
+    channel_spectrum_decimator.feed(
+        channel,
+        [this, &block_completed](const buffer_c16_t& data) {
+            this->post_message(data);
+            block_completed = true;
+        });
+    return block_completed;
+}
+
+void SpectrumCollector::set_filter(
+    const int32_t filter_low_frequency,
+    const int32_t filter_high_frequency,
+    const int32_t filter_transition) {
     channel_filter_low_frequency = filter_low_frequency;
     channel_filter_high_frequency = filter_high_frequency;
     channel_filter_transition = filter_transition;
-
-    channel_spectrum_decimator.feed(
-        channel,
-        [this](const buffer_c16_t& data) {
-            this->post_message(data);
-        });
 }
 
 void SpectrumCollector::post_message(const buffer_c16_t& data) {
@@ -136,6 +149,7 @@ void SpectrumCollector::update() {
 
         ChannelSpectrum spectrum;
         spectrum.sampling_rate = channel_spectrum_sampling_rate;
+        spectrum.channel_filter_offset = channel_filter_offset;
         spectrum.channel_filter_low_frequency = channel_filter_low_frequency;
         spectrum.channel_filter_high_frequency = channel_filter_high_frequency;
         spectrum.channel_filter_transition = channel_filter_transition;

firmware/baseband/spectrum_collector.hpp

@@ -40,13 +40,24 @@ class SpectrumCollector {
     void on_message(const Message* const message);
 
     void set_decimation_factor(const size_t decimation_factor);
+    void set_channel_filter_offset(const int32_t offset) {
+        channel_filter_offset = offset;
+    }
 
-    void feed(
+    bool feed(
         const buffer_c16_t& channel,
         const int32_t filter_low_frequency,
         const int32_t filter_high_frequency,
         const int32_t filter_transition);
 
+   protected:
+    bool is_streaming() const { return streaming; }
+    void set_filter(
+        const int32_t filter_low_frequency,
+        const int32_t filter_high_frequency,
+        const int32_t filter_transition);
+    void post_message(const buffer_c16_t& data);
+
    private:
     BlockDecimator<complex16_t, 256> channel_spectrum_decimator{1};
     ChannelSpectrum fifo_data[1 << ChannelSpectrumConfigMessage::fifo_k]{};
@@ -59,8 +70,7 @@ class SpectrumCollector {
     int32_t channel_filter_low_frequency{0};
     int32_t channel_filter_high_frequency{0};
     int32_t channel_filter_transition{0};
-
-    void post_message(const buffer_c16_t& data);
+    int32_t channel_filter_offset{0};
 
     void set_state(const SpectrumStreamingConfigMessage& message);
     void start();

firmware/common/dsp_fir_taps.hpp

@@ -44,6 +44,111 @@ struct fir_taps_complex {
     std::array<complex16_t, N> taps;
 };
 
+/*
+ * 768kHz -> 384kHz half-band prefilter. The broad 80...304kHz
+ * transition makes this stage inexpensive while protecting the useful band.
+ */
+constexpr fir_taps_real<16> taps_audio_wide_halfband_0{
+    .low_frequency_normalized = -80000.0f / 768000.0f,
+    .high_frequency_normalized = 80000.0f / 768000.0f,
+    .transition_normalized = 224000.0f / 768000.0f,
+    .taps = {{
+        -171,
+        0,
+        1144,
+        0,
+        -4481,
+        0,
+        19892,
+        32767,
+        19892,
+        0,
+        -4481,
+        0,
+        1144,
+        0,
+        -171,
+        0,
+    }},
+};
+
+/*
+ * Spectrum capture anti-alias half-band filter. It is run only while a
+ * contiguous 256-sample FFT frame is being collected:
+ *   384kHz -> 192kHz (Zoom x1)
+ *   192kHz ->  96kHz (additional stage for Zoom x2)
+ */
+constexpr fir_taps_real<63> taps_audio_spectrum_halfband{
+    .low_frequency_normalized = -0.23f,
+    .high_frequency_normalized = 0.23f,
+    .transition_normalized = 0.04f,
+    .taps = {{
+        -15,
+        0,
+        37,
+        0,
+        -70,
+        0,
+        117,
+        0,
+        -184,
+        0,
+        274,
+        0,
+        -393,
+        0,
+        548,
+        0,
+        -751,
+        0,
+        1018,
+        0,
+        -1374,
+        0,
+        1872,
+        0,
+        -2622,
+        0,
+        3910,
+        0,
+        -6794,
+        0,
+        20812,
+        32767,
+        20812,
+        0,
+        -6794,
+        0,
+        3910,
+        0,
+        -2622,
+        0,
+        1872,
+        0,
+        -1374,
+        0,
+        1018,
+        0,
+        -751,
+        0,
+        548,
+        0,
+        -393,
+        0,
+        274,
+        0,
+        -184,
+        0,
+        117,
+        0,
+        -70,
+        0,
+        37,
+        0,
+        -16,
+    }},
+};
+
 // NBFM 16K0F3E emission type /////////////////////////////////////////////
 
 // IFIR image-reject filter: fs=3072000, pass=8000, stop=344000, decim=8, fout=384000

firmware/common/message.hpp

@@ -170,6 +170,7 @@ class Message {
         HunterStop = 112,
         TetraBsch = 113,
         TetraDnb = 114,
+        AudioDDCConfig = 115,
         MAX
     };
 
@@ -310,6 +311,16 @@ class SpectrumStreamingConfigMessage : public Message {
     Mode mode{Mode::Stopped};
 };
 
+class AudioDDCConfigMessage : public Message {
+   public:
+    constexpr AudioDDCConfigMessage(int32_t frequency)
+        : Message{ID::AudioDDCConfig},
+          frequency{frequency} {
+    }
+
+    int32_t frequency{0};
+};
+
 class WidebandSpectrumConfigMessage : public Message {
    public:
     constexpr WidebandSpectrumConfigMessage(
@@ -357,6 +368,7 @@ class AudioSpectrumMessage : public Message {
 struct ChannelSpectrum {
     std::array<uint8_t, 256> db{{0}};
     uint32_t sampling_rate{0};
+    int32_t channel_filter_offset{0};
     int32_t channel_filter_low_frequency{0};
     int32_t channel_filter_high_frequency{0};
     int32_t channel_filter_transition{0};

firmware/common/ui_widget.cpp

@@ -564,16 +564,14 @@ void LiveDateTime::set_seconds_enabled(bool new_value) {
 
 /* BigFrequency **********************************************************/
 
-BigFrequency::BigFrequency(
-    Rect parent_rect,
-    rf::Frequency frequency)
-    : Widget{parent_rect},
-      _frequency{frequency} {
-}
+BigFrequency::BigFrequency(Rect parent_rect, rf::Frequency frequency)
+    : Widget{parent_rect}, _frequency{frequency} {}
 
 void BigFrequency::set(const rf::Frequency frequency) {
-    _frequency = frequency;
-    set_dirty();
+    if (_frequency != frequency) {
+        _frequency = frequency;
+        set_dirty();
+    }
 }
 
 void BigFrequency::paint(Painter& painter) {
@@ -583,63 +581,59 @@ void BigFrequency::paint(Painter& painter) {
     Point digit_pos;
     ui::Color segment_color;
 
-    if (_frequency != _previous_frequency) {
-        _previous_frequency = _frequency;
+    rf::Frequency frequency{_frequency};
+    const auto rect = screen_rect();  // why not use screen_rect() directly for width, ...? it may be too small, but ...
 
-        rf::Frequency frequency{_frequency};
-        const auto rect = screen_rect();  // why not use screen_rect() directly for width, ...? it may be too small, but ...
+    // Erase
+    painter.fill_rectangle(
+        {{0, rect.location().y()}, {screen_width, 52}},
+        Theme::getInstance()->bg_darkest->background);
 
-        // Erase
-        painter.fill_rectangle(
-            {{0, rect.location().y()}, {screen_width, 52}},
-            Theme::getInstance()->bg_darkest->background);
+    // Prepare digits
+    if (!frequency) {
+        digits.fill(10);  // ----.---
+        digit_pos = {(screen_width - ((7 * digit_width) + 8)) / 2, rect.location().y()};
+    } else {
+        frequency /= 1000;  // GMMM.KKK(uuu)
 
-        // Prepare digits
-        if (!frequency) {
-            digits.fill(10);  // ----.---
-            digit_pos = {(screen_width - ((7 * digit_width) + 8)) / 2, rect.location().y()};
-        } else {
-            frequency /= 1000;  // GMMM.KKK(uuu)
-
-            for (i = 0; i < 7; i++) {
-                digits[6 - i] = frequency % 10;
-                frequency /= 10;
-            }
-
-            // Remove leading zeros
-            for (i = 0; i < 3; i++) {
-                if (!digits[i])
-                    digits[i] = 16;  // "Don't draw" code
-                else
-                    break;
-            }
-
-            digit_pos = {(Coord)(screen_width - ((7 * digit_width) + 8) - (i * digit_width)) / 2, rect.location().y()};
+        for (i = 0; i < 7; i++) {
+            digits[6 - i] = frequency % 10;
+            frequency /= 10;
         }
 
-        segment_color = style().foreground;
+        // Remove leading zeros
+        for (i = 0; i < 3; i++) {
+            if (!digits[i])
+                digits[i] = 16;  // "Don't draw" code
+            else
+                break;
+        }
 
-        // Draw
-        for (i = 0; i < 7; i++) {
-            digit = digits[i];
+        digit_pos = {(Coord)(screen_width - ((7 * digit_width) + 8) - (i * digit_width)) / 2, rect.location().y()};
+    }
 
-            if (digit < 16) {
-                digit_def = segment_font[(uint8_t)digit];
+    segment_color = style().foreground;
 
-                for (size_t s = 0; s < 7; s++) {
-                    if (digit_def & 1)
-                        painter.fill_rectangle({digit_pos + segments[s].location(), segments[s].size()}, segment_color);
-                    digit_def >>= 1;
-                }
+    // Draw
+    for (i = 0; i < 7; i++) {
+        digit = digits[i];
+
+        if (digit < 16) {
+            digit_def = segment_font[(uint8_t)digit];
+
+            for (size_t s = 0; s < 7; s++) {
+                if (digit_def & 1)
+                    painter.fill_rectangle({digit_pos + segments[s].location(), segments[s].size()}, segment_color);
+                digit_def >>= 1;
             }
+        }
 
-            if (i == 3) {
-                // Dot
-                painter.fill_rectangle({digit_pos + Point(34, 48), {4, 4}}, segment_color);
-                digit_pos += {(digit_width + 8), 0};
-            } else {
-                digit_pos += {digit_width, 0};
-            }
+        if (i == 3) {
+            // Dot
+            painter.fill_rectangle({digit_pos + Point(34, 48), {4, 4}}, segment_color);
+            digit_pos += {(digit_width + 8), 0};
+        } else {
+            digit_pos += {digit_width, 0};
         }
     }
 }

firmware/common/ui_widget.hpp

@@ -297,7 +297,6 @@ class BigFrequency : public Widget {
 
    private:
     rf::Frequency _frequency;
-    rf::Frequency _previous_frequency{~0LL};
 
     static constexpr Dim digit_width = 32;
 

firmware/tools/external_app_info.py

@@ -21,7 +21,8 @@
 # Boston, MA 02110-1301, USA.
 #
 
-# external app address ranges below must match those in linker file "external.ld"
+# External app address ranges below must match those in linker file "external.ld".
+# The end address is exclusive.
 maximum_application_size = 32*1024
 external_apps_address_start = 0xADB00000
-external_apps_address_end = 0xAE0B0000
+external_apps_address_end = 0xAE108000

sdcard/KEELOQREMOTES/GW60_DOWN.KEELOQ

@@ -0,0 +1 @@
+Superrollo;BADBEEF;1;5

sdcard/KEELOQREMOTES/GW60_STOP.KEELOQ

@@ -0,0 +1 @@
+Superrollo;BADBEEF;1;7

sdcard/KEELOQREMOTES/GW60_UP.KEELOQ

@@ -0,0 +1 @@
+Superrollo;BADBEEF;1;3