Compare commits

..
75 Commits
Author SHA1 Message Date
Ben Meadors 948c867db5 Merge branch 'develop' into pioarduino 2026-05-14 18:40:51 -05:00
Austin 4bc1078cfb Merge branch 'develop' into pioarduino 2026-05-13 17:40:25 -04:00
vidplace7 9af3d74023 Elecrows: Delete problematic variant.cpp
Not needed after USE_ETHERNET_DEFAULT
2026-05-13 17:39:57 -04:00
Ben Meadors 23065a145e More idiomatic default ethernet that doesn't break the build 2026-05-13 15:29:30 -05:00
Ben Meadors 05e6a7e5eb Fix variant headers 2026-05-13 14:18:57 -05:00
copilot-swe-agent[bot]andthebentern c360815c0e Merge branch 'develop' into pioarduino
Resolve conflict in src/nimble/NimbleBluetooth.cpp by keeping
pioarduino's Arduino BLE API (onPassKeyNotify callback, passkey
set via pSecurity->setPassKey at setup time). Develop's changes
(variable rename + showSimpleBanner) target the old NimBLE-Arduino
API which pioarduino no longer uses.

Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>
2026-05-13 16:27:07 +00:00
Austin f0a30f72ff Merge branch 'develop' into pioarduino 2026-05-13 11:13:38 -04:00
Austin 20eaefe706 Merge branch 'develop' into pioarduino 2026-05-13 10:05:51 -04:00
Austin 9a63eb729d Merge branch 'develop' into pioarduino 2026-05-10 07:40:46 -04:00
Austin 0bb89644f9 Merge branch 'develop' into pioarduino 2026-05-05 09:10:28 -04:00
Manuel aef13bef89 Merge branch 'develop' into pioarduino 2026-04-28 20:47:04 +01:00
Manuel 6d31915e57 use adc_channel_t in variant.h 2026-04-28 21:46:01 +02:00
Austin aa89faa619 Merge branch 'develop' into pioarduino 2026-04-27 20:15:22 -04:00
Manuel ee796c75c9 Refactor watchdog timer initialization and handling 2026-04-27 16:24:01 +02:00
Austin Lane a0a7209229 Use mverch's iram_memset hack for all OG-ESP32 2026-04-25 14:29:36 -04:00
Austin 16f2ff8c9e Merge branch 'develop' into pioarduino 2026-04-25 13:37:03 -04:00
Austin 894a2f43bd Merge branch 'develop' into pioarduino 2026-04-25 07:34:26 -04:00
Austin Lane e470723811 tlora-c6: Disable Screen
MESHTASTIC_EXCLUDE_SCREEN=1 on tlora-c6.

It doesn't have a screen, and this gets it compiling again (saving flash).
2026-04-24 22:44:11 -04:00
Austin LaneandCopilot 13ee648e3d Fix ESP32-C6 linker errors.
Align .text.handler_execute section to 4 bytes and update watchdog timer core mask configuration

Co-authored-by: Copilot <copilot@github.com>
2026-04-24 20:59:49 -04:00
AustinandCopilot bec00b0a57 platformio-custom: Modify mtjson target dependency to prevent fake-success. (#10291)
Co-authored-by: Copilot <copilot@github.com>
2026-04-24 19:52:23 -04:00
ManuelandCopilot 025630937c BLEDevice::deinit() added
Co-authored-by: Copilot <copilot@github.com>
2026-04-24 21:02:01 +02:00
Manuel 527e2dc7f7 ignore trunk 2026-04-24 19:24:55 +02:00
Manuel 095838f375 trunk fmt 2026-04-24 18:28:53 +02:00
ManuelandCopilot e66fcde7e3 robot tbeam cache error fix
Co-authored-by: Copilot <copilot@github.com>
2026-04-24 16:14:58 +02:00
Manuel dc478d2163 hackaday fix 2026-04-24 09:46:48 +02:00
Manuel f85ed3e59e Merge branch 'develop' into pioarduino 2026-04-24 09:07:26 +02:00
Manuel acb7ac6e3d sensecap indicator fixes after upgrade arduino-esp & lovyanGFX libs 2026-04-23 23:21:01 +02:00
Austin Lane c6282d3a3c Re-add tool-mklittlefs 2026-04-22 20:57:17 -04:00
Austin Lane 3f35f2c6d7 Re-enable littlefs json manifest
This works locally again :)
Not sure what changed
2026-04-22 19:12:56 -04:00
Catalin Patulea 6847f232a7 Build ESP32 original with NimBLE ('custom_sdkconfig' approach). (#10235) 2026-04-22 18:33:53 -04:00
Austin Lane f586824435 Fix Power.cpp check warning
Local variable 'config' shadows outer variable [shadowVariable]
2026-04-22 17:25:34 -04:00
mverch67 b0d7440bad fix infinite loop 2026-04-22 22:45:53 +02:00
mverch67 8dc82c45b8 fix linker error using response file (p4 only) 2026-04-22 22:39:38 +02:00
Austin Lane 96538b492a I thought I fixed this 2026-04-22 16:39:32 -04:00
Austin 41df7ef0bf Merge branch 'develop' into pioarduino 2026-04-22 12:47:46 -04:00
mverch67 e49dab1f08 update p4 esp_hosted for BT 2026-04-22 14:04:12 +02:00
Manuel 74f7d9ce3c Merge branch 'develop' into pioarduino 2026-04-22 14:01:13 +02:00
Austin Lane 6c74052ec3 InkHUD: Fix type casting for message size in saveToFlash method
inkhud compiles again!
2026-04-21 17:56:35 -04:00
Austin Lane fb7d34afb9 Cleanup: Fix ADC channels on new variants 2026-04-21 17:08:29 -04:00
Austin Lane 814773f50e ESP32: Disable classic bluetooth 2026-04-21 16:17:15 -04:00
Austin Lane 621aeb29b5 Cleanup after merge 2026-04-21 11:23:47 -04:00
copilot-swe-agent[bot]andvidplace7 6f1d611c34 Merge branch 'develop' into pioarduino (resolve conflicts favoring pioarduino)
Co-authored-by: vidplace7 <1779290+vidplace7@users.noreply.github.com>
2026-04-21 13:40:59 +00:00
Austin Lane fc871f42e4 Add extension from pioarduino nag
"Jason2866.esp-decoder"
2026-04-21 09:15:09 -04:00
AustinandCatalin Patulea 9da0ee9c51 NimBLE-Arduino -> Arduino "BLE" (3.3.x) migration (#10164)
* NimBLE-Arduino -> Arduino "BLE" (3.3.x) migration

* More NimBLE

* Fix Device Name in ATT Read Request (0x2A00).

Device Name is exposed in two places:

- Advertisement data: this is set properly in startAdvertising.
- GATT attribute Device Name (0x2A00). This one is handled internally in NimBLE
  and comes from ble_svc_gap_device_name_set. This is set initially, but then
  BLEDevice::createServer calls ble_svc_gap_init which resets the device name.
  This causes the device to apparently "change name after pairing":

< ACL Data TX:... flags 0x00 dlen 7  #113 [hci0] 14.241149
      ATT: Read Request (0x0a) len 2
        Handle: 0x0003 Type: Device Name (0x2a00)
> ACL Data RX: Handle 2048 flags 0x02 dlen 11             #115 [hci0] 14.269050
      ATT: Read Response (0x0b) len 6
        Value[6]: 6e696d626c65   # "nimble"

Workaround this by setting the device name once again after
BLEDevice::createServer.

* Temporarily lower CORE_DEBUG_LEVEL to INFO to avoid triggering an apparent ESP-IDF Bluetooth bug when re-connecting to Pixel 8 Android devices.

Initial pairing works, but after ESP32 is rebooted, phone fails to reconnect. Meshtastic app shows it as disconnecting immediately. LightBlue shows a more detailed error "Peripheral Connection - Warning: onConnectionStatusChange: status 61" (0x3D - MIC Failure).

Bug report to Espresssif: https://github.com/espressif/esp-idf/issues/18126#issuecomment-4286197744

* Temporarily disable ble_gap_set_data_len, causes crash with Pixel 8 Android reconnect.

Crash looks like this:
  [ 11966][E][BLEAdvertising.cpp:341] setScanResponseData(): ble_gap_adv_rsp_set_data: 22
  [ 11975][E][BLEAdvertising.cpp:1554] start(): Host reset, wait for sync.
  ERROR | ??:??:?? 11 BLE failed to start advertising
  Guru Meditation Error: Core  0 panic'ed (LoadProhibited). Exception was unhandled.

  Core  0 register dump:
  PC      : 0x420e6190  PS      : 0x00060730  A0      : 0x820e158b  A1      : 0x3fce50c0
  A2      : 0x00000000  A3      : 0x3fcb8600  A4      : 0x3fcb85cc  A5      : 0x00000000
  A6      : 0x00000000  A7      : 0x00000c03  A8      : 0x00000000  A9      : 0x3fce50b0
  A10     : 0x0000000e  A11     : 0x00000000  A12     : 0x00000010  A13     : 0x3fce50e0
  A14     : 0x00000c03  A15     : 0x00000001  SAR     : 0x0000001e  EXCCAUSE: 0x0000001c
  EXCVADDR: 0x00000000  LBEG    : 0x400570e8  LEND    : 0x400570f3  LCOUNT  : 0x00000000

  Backtrace: 0x420e618d:0x3fce50c0 0x420e1588:0x3fce5110 0x420dfe87:0x3fce5200 0x420dfefb:0x3fce5220 0x420dff3f:0x3fce5240 0x4219602b:0x3fce5260 0x4037b0e5:0x3fce5280 0x4201edf3:0x3fce52a0

Connection seems fast enough even without this. We'll investigate the
reason for the crash and re-enable once it's safe.

---------

Co-authored-by: Catalin Patulea <cronos586@gmail.com>
2026-04-21 09:07:53 -04:00
Austin Lane 61bab08d9e Pioarduino 55.03.38-1 2026-04-14 18:04:06 -04:00
Manuel e85ebc6859 enable esp_hosted for esp32-p4 (experimental) 2026-04-13 21:31:45 +02:00
Manuel c9fc1edb4f revert a6f6175, update to 3.3.8 2026-04-13 21:30:32 +02:00
Manuel 483bb33749 Merge branch 'develop' into pioarduino 2026-04-13 21:27:36 +02:00
Manuel e22a22b325 fix/workaround SDMMC 2026-04-09 17:19:49 +02:00
Manuel 35e4a877ee Merge branch 'develop' into pioarduino 2026-04-09 17:02:38 +02:00
Manuel a6f6175535 config for MUI 2026-04-09 00:05:54 +02:00
Manuel 3e5f95f8ed don't ignore esp_lcd 2026-04-09 00:02:26 +02:00
Austin Lane edb975d886 Switch to meshtastic/esp32_https_server fork (idf5 branch) 2026-03-30 13:55:38 -04:00
Austin 8d649e9a0b Merge branch 'develop' into pioarduino 2026-03-30 13:42:13 -04:00
Austin 5c1e5f3dd6 Merge branch 'develop' into pioarduino 2026-03-02 09:54:36 -05:00
Manuel 6bde1d5fbb esp32-p4 specific adaptations 2026-02-03 22:44:57 +01:00
Manuel bc311616a3 check for esp32 w/ wifi 2026-02-03 22:26:53 +01:00
Manuel 9fdeec173e fix esp32p4.ini 2026-02-03 22:26:20 +01:00
Austin Lane b24a6676a6 Update lovyangfx from develop commit to 1.2.19 2026-01-23 14:20:10 -05:00
Austin a3f39de4b9 Merge branch 'develop' into pioarduino 2026-01-23 14:10:12 -05:00
Austin d235d3f933 Merge branch 'develop' into pioarduino 2026-01-22 10:54:52 -05:00
Austin Lane 67726f9e3a pioarduino: use legacy esptoolpy naming (forward-compatible) 2026-01-21 21:50:25 -05:00
Austin Lane 3cbc9c91cb pioarduino: disable network provisioning (wifiprov) 2026-01-21 21:09:32 -05:00
Austin Lane 5c2afbf8ce pioarduino: T-Beam 1W CDC mode 2026-01-21 19:43:33 -05:00
Austin Lane f1ca363efe pioarduino: Fix OG ESP32 duplicate libs 2026-01-21 18:39:15 -05:00
Austin Lane 814dc2db1b pioarduino 3.3.6 *release*
chasing the release
2026-01-21 18:20:51 -05:00
Austin Lane fbeabe29ed pioarduino 3.3.6 2026-01-21 18:09:36 -05:00
Austin Lane 7235afec2f pioarduino: Update LovyanGFX
Includes Manuel's recent commit
2026-01-20 19:51:10 -05:00
mverch67 ef7036e9ed preliminary esp32p4.ini 2026-01-21 01:10:12 +01:00
Austin c997e3bb65 Merge branch 'develop' into pioarduino 2026-01-20 19:03:57 -05:00
Austin 028f781ea5 Merge branch 'develop' into pioarduino 2026-01-13 12:05:06 -05:00
Austin Lane 86cdff463b Use pioarduino develop
The latest fixes and the latest bugs!
2026-01-13 10:59:05 -05:00
Austin 778090a269 Merge branch 'develop' into pioarduino 2026-01-05 17:35:48 -05:00
Austin Lane 14e9cb0fc3 ESP32c6 align text.handler_execute same as C3 2026-01-02 10:17:41 -05:00
Austin Lane aa506ce4ab Migrate esp32 families to pioarduino platform 2025-12-30 10:37:19 -05:00
187 changed files with 1199 additions and 11265 deletions
-7
View File
@@ -62,10 +62,3 @@ userPrefs.jsonc.mcp-session-bak
# compiled .proto outputs are ephemeral build artifacts.
build/fixtures/
bin/_generated/
# Build artifacts: anything compiling .o/.a outside .pio/ is accidental.
# Explicit exceptions for vendored binaries (Morse Micro mm-iot-esp32 SDK).
*.o
*.a
!lib/MorseWlan/lib/**/*.a
!lib/MorseWlan/src/*.mbin.o
+1 -1
View File
@@ -38,4 +38,4 @@ cp bin/device-install.* $OUTDIR/
cp bin/device-update.* $OUTDIR/
echo "Copying manifest"
cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json || true
cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json
+8 -4
View File
@@ -293,9 +293,12 @@ if ("HAS_TFT", 1) in env.get("CPPDEFINES", []):
board_arch = infer_architecture(env.BoardConfig())
should_skip_manifest = board_arch is None
# For host/native envs, avoid depending on 'buildprog' (some targets don't define it)
mtjson_deps = [] if should_skip_manifest else ["buildprog"]
if not should_skip_manifest and platform.name == "espressif32":
# Most platforms can generate the manifest as part of the default 'buildprog' target.
# Typically this passes success/failure properly.
mtjson_deps = ["buildprog"]
if platform.name == "espressif32":
# On ESP32, we need to explicitly depend upon the binary to prevent fake-success upon failure.
mtjson_deps = ["$BUILD_DIR/${PROGNAME}.bin"]
# Build littlefs image as part of mtjson target
# Equivalent to `pio run -t buildfs`
target_lfs = env.DataToBin(
@@ -309,7 +312,8 @@ if should_skip_manifest:
env.AddCustomTarget(
name="mtjson",
dependencies=mtjson_deps,
# For host/native envs, avoid depending on 'buildprog' (some targets don't define it)
dependencies=[],
actions=[skip_manifest],
title="Meshtastic Manifest (skipped)",
description="mtjson generation is skipped for native environments",
+1 -1
View File
@@ -7,7 +7,7 @@
"extra_flags": [
"-D CDEBYTE_EORA_S3",
"-D ARDUINO_USB_CDC_ON_BOOT=1",
"-D ARDUINO_USB_MODE=0",
"-D ARDUINO_USB_MODE=1",
"-D ARDUINO_RUNNING_CORE=1",
"-D ARDUINO_EVENT_RUNNING_CORE=1",
"-D BOARD_HAS_PSRAM"
+1 -1
View File
@@ -6,7 +6,7 @@
"core": "esp32",
"extra_flags": [
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1",
"-DBOARD_HAS_PSRAM"
+1 -1
View File
@@ -8,7 +8,7 @@
"extra_flags": [
"-DBOARD_HAS_PSRAM",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+1 -1
View File
@@ -9,7 +9,7 @@
"extra_flags": [
"-DBOARD_HAS_PSRAM",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+1 -1
View File
@@ -9,7 +9,7 @@
"extra_flags": [
"-DBOARD_HAS_PSRAM",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+1 -1
View File
@@ -9,7 +9,7 @@
"extra_flags": [
"-DBOARD_HAS_PSRAM",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+1 -1
View File
@@ -8,7 +8,7 @@
"extra_flags": [
"-DHELTEC_WIRELESS_TRACKER",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+1 -1
View File
@@ -7,7 +7,7 @@
"core": "esp32",
"extra_flags": [
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+1 -1
View File
@@ -8,7 +8,7 @@
"extra_flags": [
"-DBOARD_HAS_PSRAM",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=0"
],
+1 -1
View File
@@ -9,7 +9,7 @@
"-DBOARD_HAS_PSRAM",
"-DLILYGO_TBEAM_1W",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+1 -1
View File
@@ -8,7 +8,7 @@
"extra_flags": [
"-DBOARD_HAS_PSRAM",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+1 -1
View File
@@ -8,7 +8,7 @@
"-DBOARD_HAS_PSRAM",
"-DLILYGO_TBEAM_S3_CORE",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+1 -1
View File
@@ -7,7 +7,7 @@
"extra_flags": [
"-DLILYGO_T3S3_V1",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1",
"-DBOARD_HAS_PSRAM"
+1 -1
View File
@@ -10,7 +10,7 @@
"-DBOARD_HAS_PSRAM",
"-DUNPHONE_SPIN=9",
"-DARDUINO_USB_CDC_ON_BOOT=1",
"-DARDUINO_USB_MODE=0",
"-DARDUINO_USB_MODE=1",
"-DARDUINO_RUNNING_CORE=1",
"-DARDUINO_EVENT_RUNNING_CORE=1"
],
+7
View File
@@ -0,0 +1,7 @@
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x5000,
otadata, data, ota, 0xe000, 0x2000,
app0, app, ota_0, 0x10000, 0x640000,
app1, app, ota_1, 0x650000,0x640000,
spiffs, data, spiffs, 0xc90000,0x360000,
coredump, data, coredump,0xFF0000,0x10000,
1 # Name Type SubType Offset Size Flags
2 nvs data nvs 0x9000 0x5000
3 otadata data ota 0xe000 0x2000
4 app0 app ota_0 0x10000 0x640000
5 app1 app ota_1 0x650000 0x640000
6 spiffs data spiffs 0xc90000 0x360000
7 coredump data coredump 0xFF0000 0x10000
+7
View File
@@ -0,0 +1,7 @@
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x5000,
otadata, data, ota, 0xe000, 0x2000,
app0, app, ota_0, 0x10000, 0x330000,
app1, app, ota_1, 0x340000,0x330000,
spiffs, data, spiffs, 0x670000,0x180000,
coredump, data, coredump,0x7F0000,0x10000,
1 # Name Type SubType Offset Size Flags
2 nvs data nvs 0x9000 0x5000
3 otadata data ota 0xe000 0x2000
4 app0 app ota_0 0x10000 0x330000
5 app1 app ota_1 0x340000 0x330000
6 spiffs data spiffs 0x670000 0x180000
7 coredump data coredump 0x7F0000 0x10000
+3 -27
View File
@@ -70,30 +70,6 @@ def esp32_create_combined_bin(source, target, env):
env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", esp32_create_combined_bin)
esp32_kind = env.GetProjectOption("custom_esp32_kind")
if esp32_kind == "esp32":
# Free up some IRAM by removing auxiliary SPI flash chip drivers.
# Wrapped stub symbols are defined in src/platform/esp32/iram-quirk.c.
env.Append(
LINKFLAGS=[
"-Wl,--wrap=esp_flash_chip_gd",
"-Wl,--wrap=esp_flash_chip_issi",
"-Wl,--wrap=esp_flash_chip_winbond",
]
)
else:
# For newer ESP32 targets, using newlib nano works better. Skip on
# variants that explicitly opt out — the IDF 5.1 framework override the
# HaLow variant uses already includes nano.specs, so re-adding it triggers
# a duplicate spec definition error at link time.
cppdefines = env.get("CPPDEFINES", [])
if not any(
(isinstance(d, str) and d == "MESHTASTIC_SKIP_NANO_SPECS")
or (
isinstance(d, (list, tuple))
and len(d) > 0
and d[0] == "MESHTASTIC_SKIP_NANO_SPECS"
)
for d in cppdefines
):
env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])
# Enable Newlib Nano formatting to save space
# ...but allow printf float support (compromise)
env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])
+23
View File
@@ -0,0 +1,23 @@
#!/usr/bin/env python3
# trunk-ignore-all(ruff/F821)
# trunk-ignore-all(flake8/F821): For SConstruct imports
# force linker response file instead of command line arguments
Import("env")
def wrap_with_tempfile(command_key):
command = env.get(command_key)
if not command or not isinstance(command, str):
return
if "TEMPFILE(" in command:
return
env.Replace(**{command_key: "${TEMPFILE('%s')}" % command})
# Force SCons to spill long commands into response files on this target.
env.Replace(MAXLINELENGTH=8192)
for key in ("LINKCOM", "CXXLINKCOM", "SHLINKCOM", "SHCXXLINKCOM"):
wrap_with_tempfile(key)
-28
View File
@@ -1,28 +0,0 @@
"""
PlatformIO doesn't natively link .o files vendored inside a library directory.
The Morse Micro SDK ships the chip firmware (mm6108.mbin.o) and per-region BCF
(bcf_mf08651_us.mbin.o) as pre-built object files containing data sections.
This script appends them to LINKFLAGS so they land in the final ELF.
US region only for now — when we add EU/JP/KR variants, gate the BCF here on a
build flag and pick the matching .o file.
"""
import os
Import("env", "projenv")
LIB_DIR = os.path.join(env.subst("$PROJECT_DIR"), "lib", "MorseWlan")
mbin_objects = [
os.path.join(LIB_DIR, "src", "mm6108.mbin.o"),
os.path.join(LIB_DIR, "src", "bcf_mf08651_us.mbin.o"),
]
# Only add objects that actually exist; missing ones surface as link errors,
# not silent corruption.
for obj in mbin_objects:
if not os.path.isfile(obj):
print("warning: mm-iot-esp32 blob missing: %s" % obj)
env.Append(LINKFLAGS=mbin_objects)
-77
View File
@@ -1,77 +0,0 @@
/*
* Copyright 2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @defgroup MBIN Morse BINary Loader API
*
* This file defines the structure of the @c MBIN file.
*
* @{
*/
#pragma once
#ifndef PACKED
/** Macro for the compiler packed attribute */
#define PACKED __attribute__((packed))
#endif
/** Enumeration of TLV field types */
enum mbin_tlv_types {
FIELD_TYPE_FW_TLV_BCF_ADDR = 0x0001,
FIELD_TYPE_MAGIC = 0x8000,
FIELD_TYPE_FW_SEGMENT = 0x8001,
FIELD_TYPE_FW_SEGMENT_DEFLATED = 0x8002,
FIELD_TYPE_BCF_BOARD_CONFIG = 0x8100,
FIELD_TYPE_BCF_REGDOM = 0x8101,
FIELD_TYPE_BCF_BOARD_DESC = 0x8102,
FIELD_TYPE_BCF_BUILD_VER = 0x8103,
FIELD_TYPE_SW_SEGMENT = 0x8201,
FIELD_TYPE_SW_SEGMENT_DEFLATED = 0x8202,
FIELD_TYPE_EOF = 0x8f00,
FIELD_TYPE_EOF_WITH_SIGNATURE = 0x8f01,
};
/** TLV header data structure. */
struct PACKED mbin_tlv_hdr {
/** Type (see mbin_tlv_types). */
uint16_t type;
/** Length of payload (excludes header). */
uint16_t len;
};
/** Data header in a FIELD_TYPE_XX_SEGMENT field. */
struct PACKED mbin_segment_hdr {
/** Destination base address at which the data should be loaded. */
uint32_t base_address;
};
/** Data header in a FIELD_TYPE_XX_SEGMENT_DEFLATED field. */
struct PACKED mbin_deflated_segment_hdr {
/** Destination base address at which the data should be loaded. */
uint32_t base_address;
/** Size of deflated data, infer size of compressed data from TLV length */
uint16_t chunk_size;
/** ZLib header */
uint8_t zlib_header[2];
};
/** Data header in a @c FIELD_TYPE_BCF_REGDOM field. */
struct PACKED mbin_regdom_hdr {
/** Country code that this @c regdom applies to. */
uint8_t country_code[2];
/** Reserved */
uint16_t reserved;
};
/** Expected value of the magic field for a SW image @c MMSW. */
#define MBIN_SW_MAGIC_NUMBER (0x57534d4d)
/** Expected value of the magic field for a firmware image @c MMFW. */
#define MBIN_FW_MAGIC_NUMBER (0x57464d4d)
/** Expected value of the magic field for a BCF @c MMBC. */
#define MBIN_BCF_MAGIC_NUMBER (0x43424d4d)
/** @} */
-124
View File
@@ -1,124 +0,0 @@
/*
* Copyright 2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/*
* This file should be included from the application mbedtls_config.h file to ensure that
* the mbedTLS features necessary for morselib functionality are enabled.
*
* It is recommended to include this file at the _end_ of the application mbedtls_config.h file
* to avoid redefinition of macros.
*/
/* Cipher modes */
#ifndef MBEDTLS_CIPHER_MODE_CBC
#define MBEDTLS_CIPHER_MODE_CBC
#endif
#ifndef MBEDTLS_CIPHER_MODE_CTR
#define MBEDTLS_CIPHER_MODE_CTR
#endif
/* EC curves */
#ifndef MBEDTLS_ECP_DP_SECP256R1_ENABLED
#define MBEDTLS_ECP_DP_SECP256R1_ENABLED
#endif
#ifndef MBEDTLS_ECP_DP_SECP384R1_ENABLED
#define MBEDTLS_ECP_DP_SECP384R1_ENABLED
#endif
#ifndef MBEDTLS_ECP_DP_SECP521R1_ENABLED
#define MBEDTLS_ECP_DP_SECP521R1_ENABLED
#endif
/* Features */
#ifndef MBEDTLS_AES_C
#define MBEDTLS_AES_C
#endif
#ifndef MBEDTLS_ASN1_PARSE_C
#define MBEDTLS_ASN1_PARSE_C
#endif
#ifndef MBEDTLS_ASN1_WRITE_C
#define MBEDTLS_ASN1_WRITE_C
#endif
#ifndef MBEDTLS_BIGNUM_C
#define MBEDTLS_BIGNUM_C
#endif
#ifndef MBEDTLS_CIPHER_C
#define MBEDTLS_CIPHER_C
#endif
#ifndef MBEDTLS_CMAC_C
#define MBEDTLS_CMAC_C
#endif
#ifndef MBEDTLS_CTR_DRBG_C
#define MBEDTLS_CTR_DRBG_C
#endif
#ifndef MBEDTLS_ECDH_C
#define MBEDTLS_ECDH_C
#endif
#ifndef MBEDTLS_ECP_C
#define MBEDTLS_ECP_C
#endif
#ifndef MBEDTLS_ENTROPY_C
#define MBEDTLS_ENTROPY_C
#endif
#ifndef MBEDTLS_MD_C
#define MBEDTLS_MD_C
#endif
#ifndef MBEDTLS_NIST_KW_C
#define MBEDTLS_NIST_KW_C
#endif
#ifndef MBEDTLS_OID_C
#define MBEDTLS_OID_C
#endif
#ifndef MBEDTLS_PK_C
#define MBEDTLS_PK_C
#endif
#ifndef MBEDTLS_PK_PARSE_C
#define MBEDTLS_PK_PARSE_C
#endif
#ifndef MBEDTLS_PK_WRITE_C
#define MBEDTLS_PK_WRITE_C
#endif
#ifndef MBEDTLS_PKCS5_C
#define MBEDTLS_PKCS5_C
#endif
#ifndef MBEDTLS_SHA1_C
#define MBEDTLS_SHA1_C
#endif
#ifndef MBEDTLS_SHA224_C
#define MBEDTLS_SHA224_C
#endif
#ifndef MBEDTLS_SHA256_C
#define MBEDTLS_SHA256_C
#endif
#ifndef MBEDTLS_SHA384_C
#define MBEDTLS_SHA384_C
#endif
#ifndef MBEDTLS_SHA512_C
#define MBEDTLS_SHA512_C
#endif
-331
View File
@@ -1,331 +0,0 @@
/*
* Copyright 2021-2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @defgroup MMHAL Morse Micro Hardware Abstraction Layer (mmhal) API
*
* This API provides abstraction from the underlying hardware/BSP.
*
* @{
*/
#pragma once
#include "mmhal_flash.h"
#include "mmhal_wlan.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <time.h>
#ifdef __cplusplus
extern "C" {
#endif
/** Initialization before RTOS scheduler starts. */
void mmhal_early_init(void);
/** Initialization after RTOS scheduler started. */
void mmhal_init(void);
/** Enumeration of ISR states (i.e., whether in ISR or not). */
enum mmhal_isr_state {
MMHAL_NOT_IN_ISR, /**< The function was not executed from ISR context. */
MMHAL_IN_ISR, /**< The function was executed from ISR context. */
MMHAL_ISR_STATE_UNKNOWN, /**< The HAL does not support checking ISR state. */
};
/**
* Enumeration for different LED's on the board.
*
* @note Some of these LED's may not be available on all boards and some of these values
* may refer to the same LED.
*/
enum mmhal_led_id { LED_RED, LED_GREEN, LED_BLUE, LED_WHITE };
/** Enumeration of MCU sleep state. */
enum mmhal_sleep_state {
MMHAL_SLEEP_DISABLED, /**< Disable MCU sleep. */
MMHAL_SLEEP_SHALLOW, /**< MCU to enter shallow sleep. */
MMHAL_SLEEP_DEEP, /**< MCU can enter deep sleep. */
};
/** A value of 0 turns OFF an LED */
#define LED_OFF 0
/**
* A value of 255 turns an LED ON fully.
*
* Some boards support varying an LED's brightness. For these boards a value between 1 and 255
* will result in proportionately varying levels of brightness. LED's that do not have a
* brightness control feature will just turn ON fully for any non zero value.
*/
#define LED_ON 255
/**
* Get the current ISR state (i.e., whether in ISR or not).
*
* @returns the current ISR state, or @c MMHAL_ISR_STATE_UNKNOWN if the HAL does not support
* checking ISR state.
*/
enum mmhal_isr_state mmhal_get_isr_state(void);
/**
* Write to the debug log.
*
* It is assumed the caller will have mechanisms in place to prevent concurrent access.
*
* @param data Buffer containing data to write.
* @param len Length of data in buffer.
*/
void mmhal_log_write(const uint8_t *data, size_t len);
/**
* Flush the debug log before returning.
*
* @warning Implementations of this function must support being invoked with interrupts disabled.
*/
void mmhal_log_flush(void);
/**
* Generate a random 32 bit integer within the given range.
*
* @param min Minimum value (inclusive).
* @param max Maximum value (inclusive).
*
* @returns a randomly generated integer (min <= i <= max).
*/
uint32_t mmhal_random_u32(uint32_t min, uint32_t max);
/** Reset the microcontroller. */
void mmhal_reset(void);
/**
* Set the specified LED to the requested level. Do nothing if the requested LED does not exist.
*
* @param led The LED to set, if the platform supports it. See @ref mmhal_led_id
* @param level The level to set it to. 0 means OFF and non-zero means ON. If the platform supports
* brightness levels then 255 is full. Defines @ref LED_ON and @ref LED_OFF are
* provided for ease of use.
*/
void mmhal_set_led(uint8_t led, uint8_t level);
/**
* Set the error LED to the requested state.
*
* @note This function is called by the bootloader and so needs to do all the initialization
* required to set the LED's as the bootloader does not use the regular BSP initialization
* located in main.c for configuring @c GPIO's and setting clock gates as required.
*
* @param state Set to true if the LED needs to be turned on,
* or false if the led needs to be turned off.
*/
void mmhal_set_error_led(bool state);
/**
* Enumeration for buttons on the board.
*
* @note The support for each button is platform dependent.
*/
enum mmhal_button_id { BUTTON_ID_USER0 };
/**
* Enumeration for button states
*/
enum mmhal_button_state { BUTTON_RELEASED, BUTTON_PRESSED };
/** Button state callback function prototype. */
typedef void (*mmhal_button_state_cb_t)(enum mmhal_button_id button_id, enum mmhal_button_state button_state);
/**
* Registers a callback handler for button state changes.
*
* @note The callback will be executed in an Interrupt Service Routine context
*
* @param button_id The button whose state should be reported to the callback
* @param button_state_cb The function to call on button state change, or NULL to disable.
* @returns True if the callback is registered successfully, False if not supported
*/
bool mmhal_set_button_callback(enum mmhal_button_id button_id, mmhal_button_state_cb_t button_state_cb);
/**
* Returns the registered callback handler for button state changes.
*
* @param button_id The button whose callback should be returned
* @returns The registered callback or NULL if no callback registered
*/
mmhal_button_state_cb_t mmhal_get_button_callback(enum mmhal_button_id button_id);
/**
* Reads the state of the specified button.
*
* @param button_id The button state to read
* @returns The current button state, or BUTTON_RELEASED if not supported
*/
enum mmhal_button_state mmhal_get_button(enum mmhal_button_id button_id);
/**
* Reads information that can be used to identify the hardware platform, such as
* hardware ID and version number, in the form of a user readable string.
*
* This function attempts to detect the correct hardware and version.
* The actual means of detecting the correct hardware and version will vary from
* implementation to implementation and may use means such as identification
* information stored in EEPROM or devices detected on GPIO, SPI or I2C interfaces.
* Returns false if the hardware could not be identified correctly.
*
* @param version_buffer The pre-allocated buffer to return the hardware ID and version in.
* @param version_buffer_length The length of the pre-allocated buffer.
* @returns True if the hardware was correctly identified and returned.
*/
bool mmhal_get_hardware_version(char *version_buffer, size_t version_buffer_length);
/**
* Macro to simplify debug pin mask/value definition.
*
* @param _pin_num The pin number to set in the mask. Must be 0-31 (inclusive).
*
* Example:
*
* mmhal_set_debug_pins(MMHAL_DEBUG_PIN(0), MMHAL_DEBUG_PIN(0));
*/
#define MMHAL_DEBUG_PIN(_pin_num) (1ul << (_pin_num))
/** Bit mask with all debug pins selected. */
#define MMHAL_ALL_DEBUG_PINS (UINT32_MAX)
/**
* Set the value one or more debug pins.
*
* Each platform can define up to 32 GPIOs for application use. If a GPIO is not supported
* by a platform then attempts to set it will be silently ignored. These GPIOs are intended
* for debug/test purposes.
*
* @param mask Mask of GPIOs to modify. Each bit in this mask that is set will result in
* the corresponding GPIO being being set to the corresponding value given in
* @p values.
* @param values Bit field, where each bit corresponds to a GPIO, specifying the direction
* to drive each GPIO with 1 meaning drive high and 0 meaning drive low.
* Only GPIOs with the corresponding bit set in @p mask will be modified.
*
* @sa MM_DEBUG_PIN_MASK
*/
void mmhal_set_debug_pins(uint32_t mask, uint32_t values);
/**
* Returns the time of day as set in the RTC.
* Time is in UTC.
*
* @return Epoch time (seconds since 1 Jan 1970) or 0 on failure.
*/
time_t mmhal_get_time();
/**
* Sets the RTC to the specified time in UTC.
*
* @note While Unix epoch time supports years from 1970, most Real Time Clock
* chips support years from 2000 only as they store the year as years
* from 2000. So do not attempt to set any years below 2000 as this could cause
* the year to wrap around to an unreasonably high value. Definitely do not do:
* @code
* mmhal_set_time(0);
* @endcode
*
* @param epoch Time in Unix epoch time (seconds since 1 Jan 1970).
*/
void mmhal_set_time(time_t epoch);
/**
* Function to prepare MCU to enter sleep.
* This will halt the timer that generates the RTOS tick.
*
* @param expected_idle_time_ms Expected time to sleep in milliseconds.
*
* @returns the type of sleep permitted by the current system state.
*/
enum mmhal_sleep_state mmhal_sleep_prepare(uint32_t expected_idle_time_ms);
/**
* Function to enter MCU sleep.
*
* @param sleep_state Sleep state to enter into.
* @param expected_idle_time_ms Expected time to sleep in milliseconds.
*
* @returns Elapsed sleep time in milliseconds.
*/
uint32_t mmhal_sleep(enum mmhal_sleep_state sleep_state, uint32_t expected_idle_time_ms);
/**
* Function to abort the MCU sleep state.
*
* @note This must only be invoked after @ref mmhal_sleep_prepare()
* and before @ref mmhal_sleep().
*
* @param sleep_state Sleep state to abort.
*/
void mmhal_sleep_abort(enum mmhal_sleep_state sleep_state);
/**
* Function to cleanup on exit from the MCU sleep state.
*/
void mmhal_sleep_cleanup(void);
/** Enumeration of veto_id ranges for use with @ref mmhal_set_deep_sleep_veto() and
* @ref mmhal_clear_deep_sleep_veto(). */
enum mmhal_veto_id {
/** Start of deep sleep veto ID range that is available for application use. */
MMHAL_VETO_ID_APP_MIN = 0,
/** End of deep sleep veto ID range that is available for application use. */
MMHAL_VETO_ID_APP_MAX = 7,
/** Start of deep sleep veto ID range that is available for HAL use. */
MMHAL_VETO_ID_HAL_MIN = 8,
/** End of deep sleep veto ID range that is available for HAL use. */
MMHAL_VETO_ID_HAL_MAX = 15,
/** Start of deep sleep veto ID range that is allocated for morselib use. Note that this
* must not be changed as it is built into morselib. */
MMHAL_VETO_ID_MORSELIB_MIN = 16,
/** End of deep sleep veto ID range that is allocated for morselib use. Note that this must not
* be changed as it is built into morselib. */
MMHAL_VETO_ID_MORSELIB_MAX = 19,
/** Deep sleep veto ID for data-link subsystem. */
MMHAL_VETO_ID_DATALINK = 20,
/** Deep sleep veto ID allocated to @ref MMCONFIG. */
MMHAL_VETO_ID_MMCONFIG = 21,
/** Start of deep sleep veto ID range reserved for future use. */
MMHAL_VETO_ID_RESERVED_MIN = 22,
/** End of deep sleep veto ID range reserved for future use. */
MMHAL_VETO_ID_RESERVED_MAX = 31,
};
/**
* Sets a deep sleep veto that will prevent the device from entering deep sleep. The device
* will not enter deep sleep until there are no vetoes remaining. This veto can be cleared
* by a call to @ref mmhal_clear_deep_sleep_veto() with the same veto_id.
*
* Up to 32 vetoes are supported (ID numbers 0-31). Each veto should be used exclusively by
* a given aspect of the system (e.g., to prevent deep sleep when a DMA transfer is in progress,
* or to prevent deep sleep when there is log data buffered for transmit, etc.).
*
* @param veto_id The veto identifier. Valid values are 0-31, and these are split up into ranges
* for use by different subsystems -- see @ref mmhal_veto_id.
*/
void mmhal_set_deep_sleep_veto(uint8_t veto_id);
/**
* Clears a deep sleep veto that was preventing the device from entering deep sleep (see
* @ref mmhal_set_deep_sleep_veto()). If the given veto was not already set then this has
* no effect.
*
* @param veto_id The veto identifier. Valid values are 0-31, and these are split up into ranges
* for use by different subsystems -- see @ref mmhal_veto_id.
*/
void mmhal_clear_deep_sleep_veto(uint8_t veto_id);
#ifdef __cplusplus
}
#endif
/** @} */
-145
View File
@@ -1,145 +0,0 @@
/*
* Copyright 2021-2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @ingroup MMHAL Morse Micro Flash Hardware Abstraction Layer (mmhal_flash) API
*
* This API provides abstraction from the underlying flash hardware/.
*
* @{
*/
#pragma once
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* This is the value erased flash bytes are set to. This shall be @c 0xFF as this is the
* value that hardware flash erases to.
*/
#define MMHAL_FLASH_ERASE_VALUE 0xFF
/** LittleFS configuration structure. Include @c lfs.h for definition. */
struct lfs_config;
/**
* Flash partition configuration structure
*
* This should be initialized using @c MMHAL_FLASH_PARTITION_CONFIG_DEFAULT.
* For example:
*
* @code{.c}
* struct mmhal_flash_partition_config partition = MMHAL_FLASH_PARTITION_CONFIG_DEFAULT;
* @endcode
*/
struct mmhal_flash_partition_config {
/** The start address of the partition, this may be a physical address
* or a relative address depending on implementation
*/
uint32_t partition_start;
/** The size of the partition */
uint32_t partition_size;
/**
* If true, then the partition is not memory mapped and cannot be directly accessed
* at the physical @c partition_start address
*/
bool not_memory_mapped;
};
/** Initial values for @ref mmhal_flash_partition_config. */
#define MMHAL_FLASH_PARTITION_CONFIG_DEFAULT \
{ \
0, 0, false \
}
/**
* Get MMCONFIG flash partition configuration.
*
* MMCONFIG initialization is done by @c mmconfig_init() in @c mmconfig.c.
* which in turn calls this function to fetch the partition configuration for config store
* from the HAL layer. If config store is not supported by the platform then we just
* return NULL. This function returns a static pointer to
* @c struct @c mmhal_flash_partition_config.
*
* @return A static pointer to the partition config for MMCONFIG, or NULL if not supported.
*/
const struct mmhal_flash_partition_config *mmhal_get_mmconfig_partition(void);
/**
* Erases a block of Flash pointed to by the block_address.
*
* The block address may be anywhere within the block to erase. The entire block gets erased.
* Once erased all bytes in the block shall be @c MMHAL_FLASH_ERASE_VALUE (@c 0xFF).
*
* @param block_address The address of the block of Flash to erase.
* @return 0 on success, negative number on failure
*/
int mmhal_flash_erase(uint32_t block_address);
/**
* Returns the size of the Flash block at the specified address.
*
* @param block_address The address of the Flash block.
* @return The size of the Flash block in bytes.
* Returns 0 if an invalid address is specified.
*/
uint32_t mmhal_flash_getblocksize(uint32_t block_address);
/**
* Read a block of data from the specified Flash address into the buffer.
*
* @param read_address The address in Flash to read from.
* @param buf The buffer to read into.
* @param size The number of bytes to read.
* @return 0 on success, or a negative number on failure.
*/
int mmhal_flash_read(uint32_t read_address, uint8_t *buf, size_t size);
/**
* Write a block of data to the specified Flash address.
*
* There is no alignment or minimum size requirement. This function will
* take care of aligning the data and merging with existing Flash contents.
* The Flash block is not erased, it is up to the application to determine
* if the block needs to be erased before programming.
*
* @param write_address The address in Flash to write to.
* @param data A pointer to the block of data to write.
* @param size The number of bytes to write.
* @return 0 on success, or a negative number on failure.
*/
int mmhal_flash_write(uint32_t write_address, const uint8_t *data, size_t size);
/**
* Get LittleFS configuration.
*
* LittleFS initialization is done by @c littlefs_init() in @c mmosal_shim_fileio.c.
* which in turn calls this function to fetch the hardware configuration for LittleFS
* from the HAL layer. The LittleFS configuration will vary from platform to platform.
* If LittleFS is not supported by the platform then we just return NULL. This function
* returns a static pointer to @c struct @c lfs_config which is defined in @c lfs.h.
*
* See @c mmhal_littlefs.c for the full HAL layer implementation for your platform.
* See @c mmosal_shim_fileio.c for the @c libc shims for LittleFS.
* See @c README.md in the @c src/littlefs folder for detailed information on LittleFS.
*
* @return A static pointer to the LittleFS config structure, or NULL if not supported.
*/
const struct lfs_config *mmhal_get_littlefs_config(void);
#ifdef __cplusplus
}
#endif
/** @} */
-89
View File
@@ -1,89 +0,0 @@
/*
* Copyright 2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @ingroup MMHAL
* @defgroup MMHAL_UART Morse Micro Abstraction Layer API for UART
*
* This provides an abstraction layer for a UART. This is used by MM-IoT-SDK example
* applications.
*
* This is a very simple API and leaves UART configuration to the HAL.
*
* @{
*/
#pragma once
#include "mmhal.h"
#include "mmosal.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* Function type for UART RX callback.
*
* @note The UART HAL must not invoke this function from interrupt context. However, the
* implementation should not block for long periods of time or received data may be lost.
*
* @param data The received data.
* @param length Length of the received data.
* @param arg Opaque argument (as passed in to @ref mmhal_uart_init()).
*/
typedef void (*mmhal_uart_rx_cb_t)(const uint8_t *data, size_t length, void *arg);
/**
* Initialize the UART HAL and perform any setup necessary.
*
* @param rx_cb Optional callback to be invoked on receive (may be NULL).
* This callback may be invoked from interrupt context so should return
* quickly.
* @param rx_cb_arg Optional opaque argument to be passed to the RX callback. May be NULL.
*/
void mmhal_uart_init(mmhal_uart_rx_cb_t rx_cb, void *rx_cb_arg);
/**
* Deinitialize the UART HAL, and disable the UART.
*/
void mmhal_uart_deinit(void);
/**
* Transmit data on the UART. This will block until all data is buffered for transmit (but may
* return before transmission has completed).
*
* @param data Data to transmit.
* @param length Length of @p data.
*/
void mmhal_uart_tx(const uint8_t *data, size_t length);
/** Enumeration of deep sleep modes for the UART HAL. */
enum mmhal_uart_deep_sleep_mode {
/** Deep sleep mode is disabled. */
MMHAL_UART_DEEP_SLEEP_DISABLED,
/** Enable deep sleep until activity occurs on data-link transport. */
MMHAL_UART_DEEP_SLEEP_ONE_SHOT,
};
/**
* Set the deep sleep mode for the UART. See @ref mmhal_uart_deep_sleep_mode for possible deep
* sleep modes. Note that a given platform may not support all modes.
*
* @param mode The deep sleep mode to set.
*
* @returns true if the mode was set successfully; false on failure (e.g., unsupported mode).
*/
bool mmhal_uart_set_deep_sleep_mode(enum mmhal_uart_deep_sleep_mode mode);
#ifdef __cplusplus
}
#endif
/** @} */
-640
View File
@@ -1,640 +0,0 @@
/*
* Copyright 2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @ingroup MMHAL
* @defgroup MMHAL_WLAN WLAN HAL
*
* API for communicating with the WLAN transceiver.
*
* There are different interfaces supported for communicating with the transceiver:
*
* * @ref MMHAL_WLAN_SDIO
* * @ref MMHAL_WLAN_SPI
*
* @warning These functions shall not be called directly by the end application they are for use
* by Morselib.
*
* @{
*/
#pragma once
#include "mmpkt.h"
#include "mmwlan.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <time.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* Function prototype for interrupt handler callbacks.
*/
typedef void (*mmhal_irq_handler_t)(void);
/**
* Initialize the WLAN HAL.
*
* Things to do here may include:
* * Enable SPI peripheral
* * Configure GPIOs
* * Enable power to the Morse Micro transceiver
*
* @note If enabling power for the Morse Micro transceiver in this function you may need to add a
* blocking delay to allow the power rail to stabilize. This is hardware specific so is not
* accounted for in the calling function.
*/
void mmhal_wlan_init(void);
/**
* Deinitialize the WLAN HAL.
*
* Things to do here may include:
* * Disable SPI peripheral
* * Disable GPIOs
* * Disable power to the Morse Micro transceiver
*/
void mmhal_wlan_deinit(void);
/**
* Get MAC address override.
*
* This function allows the HAL to override the MAC address to be used by the device. The
* MAC address override should be written to @p mac_addr. If no override is required then
* @p mac_addr should be left untouched.
*
* @param[out] mac_addr Location where the MAC address will be stored. This will be initialized
* to zero the first time this function is invoked, and to the previously
* configured MAC address on subsequent invocations.
*/
void mmhal_read_mac_addr(uint8_t *mac_addr);
/**
* Assert the WLAN wake pin.
*/
void mmhal_wlan_wake_assert(void);
/**
* Deassert the WLAN wake pin.
*/
void mmhal_wlan_wake_deassert(void);
/**
* Tests whether the busy pin is currently asserted.
*
* @note This is whether it is logically asserted and does not necessarily
* represent the level of the GPIO pin.
*
* @returns @c true if asserted, else @c false.
*/
bool mmhal_wlan_busy_is_asserted(void);
/**
* Register a handler for busy interrupts.
*
* @param handler The handler to register.
*/
void mmhal_wlan_register_busy_irq_handler(mmhal_irq_handler_t handler);
/**
* Sets whether the busy interrupt is enabled.
*
* @warning The interrupt handler function must be configured using
* mmhal_wlan_register_busy_irq_handler() before enabling the interrupt.
*
* @param enabled @c true to enable or @c false to disable.
*/
void mmhal_wlan_set_busy_irq_enabled(bool enabled);
/**
* Read-only buffer data structure.
*
* The design of this data structure allows the buffer to exist either in statically or
* dynamically allocated memory.
*
* For statically allocated memory, the field @c free_cb may be set to @c NULL and @c free_arg
* ignored. For example:
*
* @code{.c}
* const uint8_t some_data[] = { 0x00, 0x01, 0x02 };
*
* void put_some_data_into_buf(struct mmhal_robuf *robuf)
* {
* robuf->buf = some_data;
* robuf->len = sizeof(some_data);
* robuf->free_cb = NULL;
* }
* @endcode
*
* For dynamically allocated memory, the field @c free_cb is set to the appropriate function to
* free the buffer and @c free_arg is an opaque argument to the free function. This approach might
* be used, for example, when reading into a temporary buffer from storage that is not memory
* mapped. For example:
*
* @code{.c}
* #define SOME_DATA_MAXLEN (64)
*
* void put_some_data_into_buf(struct mmhal_robuf *robuf)
* {
* uint8_t *buf = malloc(SOME_DATA_MAXLEN);
* robuf->buf = buf;
* if (robuf->buf == NULL)
* return;
*
* // HERE: copy data into buf and set robuf->len as appropriate
*
* robuf->free_cb = free;
* robuf->free_arg = buf;
* }
* @endcode
*
*/
struct mmhal_robuf {
/** Pointer to the start of the read-only buffer. May be NULL only if @c len is zero. */
const uint8_t *buf;
/** Length of the buffer contents. */
uint32_t len;
/**
* Optional callback to be invoked by the consumer to release the buffer when it is
* no longer required. If not required, set to @c NULL.
*
* @note The values of @c buf and @c len in this structure may be modified before
* @c free_cb() is invoked. However, the value of @c free_arg will be passed
* to @c free_cb().
*/
void (*free_cb)(void *arg);
/** Optional argument to @c free_cb. Ignored if @c free_cb is @c NULL. */
void *free_arg;
};
/** Minimum length of data to be returned by @ref mmhal_wlan_read_bcf_file() and
* @ref mmhal_wlan_read_fw_file(). */
#define MMHAL_WLAN_FW_BCF_MIN_READ_LENGTH (4)
/**
* Retrieves the content of the Morse Micro Board Configuration File and places it into the given
* buffer.
*
* @param offset Offset from which to start reading the bcf
* @param requested_len Length of data we would like to read. The length of the data returned
* by this function may be less than @p requested_len, but must be at
* least @ref MMHAL_WLAN_FW_BCF_MIN_READ_LENGTH.
* @param robuf Read-only buffer data structure to be filled out by this function.
*
* @note On error, this function should set @c robuf->buf to @c NULL.
* @note The caller must zero @p robuf before invoking the function.
* @note The BCF must be in mbin format.
*
* @warning The caller is responsible for checking @c robuf->free_cb and calling when the buffer is
* no longer required. Ignored if @c robuf->free_cb is @c NULL.
*/
void mmhal_wlan_read_bcf_file(uint32_t offset, uint32_t requested_len, struct mmhal_robuf *robuf);
/**
* Retrieves the content of the Morse Micro Chip Firmware and places it into the given buffer.
*
* @param offset Offset from which to start reading the bcf
* @param requested_len Length of data we would like to read. The length of the data returned
* by this function may be less than @p requested_len, but must be at
* least @ref MMHAL_WLAN_FW_BCF_MIN_READ_LENGTH.
* @param robuf Read-only buffer data structure to be filled out by this function.
*
* @note On error, this function should set @c robuf->buf to @c NULL.
* @note The caller must zero @p robuf before invoking the function.
* @note The firmware must be in mbin format.
*
* @warning The caller is responsible for checking @c robuf->free_cb and calling when the buffer
* is no longer required. Ignored if @c robuf->free_cb is @c NULL.
*/
void mmhal_wlan_read_fw_file(uint32_t offset, uint32_t requested_len, struct mmhal_robuf *robuf);
/**
* @defgroup MMHAL_WLAN_SPI WLAN HAL API for SPI interface
*
* API for communicating with the WLAN transceiver over an SPI interface.
*
* @note These functions should only be implemented if using a SPI interface. They are not
* required when using the @ref MMHAL_WLAN_SDIO.
*
* @warning These functions shall not be called directly by the end application they are for use
* by Morselib.
*
* @{
*/
/**
* Assert the WLAN SPI chip select pin.
*/
void mmhal_wlan_spi_cs_assert(void);
/**
* Deassert the WLAN SPI chip select pin.
*/
void mmhal_wlan_spi_cs_deassert(void);
/**
* Simultaneously read and write on the SPI bus.
*
* @param data Data to be written.
*
* @return the value that was read.
*/
uint8_t mmhal_wlan_spi_rw(uint8_t data);
/**
* Receive multiple octets of data from SPI bus.
*
* @param buf The buffer to receive into.
* @param len The number of octets to receive.
*/
void mmhal_wlan_spi_read_buf(uint8_t *buf, unsigned len);
/**
* Transmit multiple octets of data to SPI bus.
*
* @param buf The buffer to transmit from.
* @param len The number of octets to transmit.
*
* @note Blocks until transfer complete.
*/
void mmhal_wlan_spi_write_buf(const uint8_t *buf, unsigned len);
/**
* Hard reset the chip by asserting and then releasing the reset pin.
*
* @warning This function must return with the chip in a fully booted state. i.e only return once
* the reset_n line has been high for at least the boot time specified in the data sheet.
* Failure to do so may lead to undefined behavior.
*/
void mmhal_wlan_hard_reset(void);
/**
* Invoked by the driver to check whether the external crystal initialization sequence is required.
*
* Implementation of this function is optional if the external crystal initialization sequence
* is not required. If this function is not implemented then the external crystal initialization
* sequence will be disabled. Refer to the data sheet for your module to check if this initialization
* is required.
*
* @returns true if the external crystal initialization sequence is required else false.
*/
bool mmhal_wlan_ext_xtal_init_is_required(void);
/**
* Issue the training sequence required to put the transceiver into SPI mode.
*/
void mmhal_wlan_send_training_seq(void);
/**
* Register a handler for SPI interrupts.
*
* @param handler The handler to register.
*/
void mmhal_wlan_register_spi_irq_handler(mmhal_irq_handler_t handler);
/**
* Sets whether the SPI interrupt is enabled.
*
* @warning The interrupt handler function must be configured using
* @ref mmhal_wlan_register_spi_irq_handler() before enabling the interrupt.
*
* @param enabled @c true to enable or @c false to disable.
*/
void mmhal_wlan_set_spi_irq_enabled(bool enabled);
/**
* Tests whether the SPI interrupt pin is currently asserted.
*
* @note This is whether it is logically asserted and does not necessarily
* represent the level of the GPIO pin.
*
* @returns @c true if asserted, else @c false.
*/
bool mmhal_wlan_spi_irq_is_asserted(void);
/**
* Clear the SPI IRQ.
*
* @deprecated Do not invoke this function because it is deprecated and will be removed from the
* mmhal API in a future release. This function need not be implemented as a weak
* stub is used in morselib.
*/
void mmhal_wlan_clear_spi_irq(void);
/** @} */
/**
* @defgroup MMHAL_WLAN_PKT WLAN HAL API for packet memory allocation
*
* API for allocating and freeing packet memory.
*
* @warning These functions shall not be called directly by the end application they are for use
* by Morselib.
*
* @{
*/
/**
* Flow control callback that can be invoked by the transmit packet memory manager to pause
* and resume the data path in response to resource availability.
*
* @param state Current flow control state.
*/
typedef void (*mmhal_wlan_pktmem_tx_flow_control_cb_t)(enum mmwlan_tx_flow_control_state state);
/** Initialization arguments passed to @ref mmhal_wlan_pktmem_init(). */
struct mmhal_wlan_pktmem_init_args {
/** Flow control callback that can be used by the transmit packet memory manager. */
mmhal_wlan_pktmem_tx_flow_control_cb_t tx_flow_control_cb;
};
/**
* Invoked by the driver to initialize the packet memory in the HAL.
*
* @param args Initialization arguments.
*/
void mmhal_wlan_pktmem_init(struct mmhal_wlan_pktmem_init_args *args);
/**
* Invoked by the driver to deinitialize the packet memory in the HAL.
*
* This can free reserved memory and check for memory leaks.
*/
void mmhal_wlan_pktmem_deinit(void);
/**
* Enumeration of packet classes used by @ref mmhal_wlan_alloc_mmpkt_for_tx().
* These definitions must match the corresponding values in @c mmdrv_pkt_class.
*/
enum mmhal_wlan_pkt_class {
MMHAL_WLAN_PKT_DATA_TID0, /**< Data TID0 */
MMHAL_WLAN_PKT_DATA_TID1, /**< Data TID1 */
MMHAL_WLAN_PKT_DATA_TID2, /**< Data TID2 */
MMHAL_WLAN_PKT_DATA_TID3, /**< Data TID3 */
MMHAL_WLAN_PKT_DATA_TID4, /**< Data TID4 */
MMHAL_WLAN_PKT_DATA_TID5, /**< Data TID5 */
MMHAL_WLAN_PKT_DATA_TID6, /**< Data TID6 */
MMHAL_WLAN_PKT_DATA_TID7, /**< Data TID7 */
MMHAL_WLAN_PKT_MANAGEMENT, /**< 802.11 Management and other important frames */
MMHAL_WLAN_PKT_COMMAND, /**< Commands from driver to chip */
};
/**
* Allocates an mmpkt for transmission.
*
* When the pool of mmpkt buffers available for TX is exhausted, the HAL should pause the TX
* path using the flow control callback that was registered when @ref mmhal_wlan_pktmem_init()
* was invoked. Similarly, when the buffers become available again (and assuming the TX path is
* not otherwise blocked) the driver should unpause the TX path.
*
* @param pkt_class The class of packet (to allow for prioritization).
* @param space_at_start Amount of space to allocate at start of mmpkt (for prepend).
* @param space_at_end Amount of space to allocate at end of mmpkt (for append).
* @param metadata_length Amount of space to allocate for metadata (used internally by the
* Morse driver).
*
* @returns a pointer to the allocated packet on success or @c NULL on allocation failure.
*/
struct mmpkt *mmhal_wlan_alloc_mmpkt_for_tx(uint8_t pkt_class, uint32_t space_at_start, uint32_t space_at_end,
uint32_t metadata_length);
/**
* Allocates an mmpkt for reception.
*
* @param capacity Amount of space to allocate for data.
* @param metadata_length Amount of space to allocate for metadata (used internally by the
* Morse driver).
*
* @returns a pointer to the allocated packet on success or @c NULL on allocation failure.
*/
struct mmpkt *mmhal_wlan_alloc_mmpkt_for_rx(uint32_t capacity, uint32_t metadata_length);
/** @} */
/**
* @defgroup MMHAL_WLAN_SDIO WLAN HAL API for SDIO interface
*
* API for communicating with the WLAN transceiver over an SDIO interface
*
* @warning These functions shall not be called directly by the end application they are for use
* by Morselib.
*
* @{
*/
/** Enumeration of error codes that may be returned from @c mmhal_wlan_sdio_XXX() functions. */
enum mmhal_sdio_error_codes {
/** Invalid argument given (e.g., incorrect buffer alignment). */
MMHAL_SDIO_INVALID_ARGUMENT = -1,
/** Local hardware error (e.g., issue with SDIO controller). */
MMHAL_SDIO_HW_ERROR = -2,
/** Timeout executing SDIO command. */
MMHAL_SDIO_CMD_TIMEOUT = -3,
/** CRC error executing SDIO command. */
MMHAL_SDIO_CMD_CRC_ERROR = -4,
/** Timeout transferring data. */
MMHAL_SDIO_DATA_TIMEOUT = -5,
/** CRC error transferring data. */
MMHAL_SDIO_DATA_CRC_ERROR = -6,
/** Underflow filling SDIO controller FIFO. */
MMHAL_SDIO_DATA_UNDERFLOW = -7,
/** Overflow reading from SDIO controller FIFO. */
MMHAL_SDIO_DATA_OVERRUN = -8,
/** Another error not covered by the above error codes. */
MMHAL_SDIO_OTHER_ERROR = -9,
};
/**
* Perform transport specific startup.
*
* @returns 0 on success, an error code from @ref mmhal_sdio_error_codes on failure.
*/
int mmhal_wlan_sdio_startup(void);
/**
* Execute an SDIO command without data.
*
* @param[in] cmd_idx The Command Index.
* @param[in] arg Command argument. This corresponds to the 32 bits of the command between
* the Command Index field and the CRC7 field.
* @param[out] rsp The contents of the command response between the Command Index field
* and the CRC7 field. May be @c NULL if the response is not required.
* The returned value is undefined if the return code is not zero.
*
* @returns 0 on success, an error code from @ref mmhal_sdio_error_codes on failure.
*/
int mmhal_wlan_sdio_cmd(uint8_t cmd_idx, uint32_t arg, uint32_t *rsp);
/**
* Arguments structure for @ref mmhal_wlan_sdio_cmd53_write().
*/
struct mmhal_wlan_sdio_cmd53_write_args {
/** The SDIO argument. This corresponds to the 32 bits of the command between
* the Command Index field and the CRC7 field. */
uint32_t sdio_arg;
/** Pointer to the data buffer. 32 bit word aligned. */
const uint8_t *data;
/** Transfer length measured in blocks if block_size is non-zero otherwise in bytes.
* If transfer_length is measured in bytes, it will be a multiple of 4. */
uint16_t transfer_length;
/**
* If non-zero this indicates that the data should be transferred in block mode with
* the given block size. If zero then the data should be transferred in byte mode and
* @c transfer_length is guaranteed to not exceed the block size of the function.
*/
uint16_t block_size;
};
/**
* Execute an SDIO CMD53 write.
*
* @param args The write arguments.
*
* @returns 0 on success, an error code from @ref mmhal_sdio_error_codes on failure.
*/
int mmhal_wlan_sdio_cmd53_write(const struct mmhal_wlan_sdio_cmd53_write_args *args);
/**
* Arguments structure for @ref mmhal_wlan_sdio_cmd53_read().
*/
struct mmhal_wlan_sdio_cmd53_read_args {
/** The SDIO argument. This corresponds to the 32 bits of the command between
* the Command Index field and the CRC7 field. */
uint32_t sdio_arg;
/** Pointer to the data buffer to receive the data. 32 bit word aligned. */
uint8_t *data;
/** Transfer length measured in blocks if block_size is non-zero otherwise in bytes.
* If transfer_length is measured in bytes, it will be a multiple of 4. */
uint16_t transfer_length;
/**
* If non-zero this indicates that the data should be transferred in block mode with
* the given block size. If zero then the data should be transferred in byte mode and
* @c transfer_length is guaranteed to not exceed the block size of the function.
*/
uint16_t block_size;
};
/**
* Execute an SDIO CMD53 read.
*
* @param args The read arguments.
*
* @returns 0 on success, an error code from @ref mmhal_sdio_error_codes on failure.
*/
int mmhal_wlan_sdio_cmd53_read(const struct mmhal_wlan_sdio_cmd53_read_args *args);
/**
* @defgroup MMHAL_WLAN_SDIO_UTILS SDIO Utilities
*
* Useful macros and inline utilities function for use by SDIO and SPI HALs.
*
* @{
*/
/*
* SDIO argument definition, per SDIO Specification Version 4.10, Part E1, Section 5.3.
*/
/** SDIO CMD52/CMD53 R/W flag. */
enum mmhal_sdio_rw {
MMHAL_SDIO_READ = 0, /**< Read operation */
MMHAL_SDIO_WRITE = (1ul << 31), /**< Write operation */
};
/** SDIO CMD52/CMD53 function number. */
enum mmhal_sdio_function {
MMHAL_SDIO_FUNCTION_0 = 0, /** Function 0 */
MMHAL_SDIO_FUNCTION_1 = (1ul << 28), /** Function 1 */
MMHAL_SDIO_FUNCTION_2 = (2ul << 28), /** Function 2 */
};
/** SDIO CMD53 block mode*/
enum mmhal_sdio_mode {
MMHAL_SDIO_MODE_BYTE = 0, /** Byte mode */
MMHAL_SDIO_MODE_BLOCK = (1ul << 27), /** Block mode */
};
/** SDIO CMD53 OP code */
enum mmhal_sdio_opcode {
/** Operate on a single, fixed address. */
MMHAL_SDIO_OPCODE_FIXED_ADDR = 0,
/** Increment address by 1 after each byte. */
MMHAL_SDIO_OPCODE_INC_ADDR = (1ul << 26),
};
/** CMD52/53 Register Address (17 bit) offset. */
#define MMHAL_SDIO_ADDRESS_OFFSET (9)
/** CMD52/53 Register Address maximum value. */
#define MMHAL_SDIO_ADDRESS_MAX ((1ul << 18) - 1)
/** CMD53 Byte/block count offset (9 bit). */
#define MMHAL_SDIO_COUNT_OFFSET (0)
/**CMD53 Byte/block count maximum value. */
#define MMHAL_SDIO_COUNT_MAX ((1ul << 10) - 1)
/** CMD52 Data (8 bit) offset */
#define MMHAL_SDIO_CMD52_DATA_OFFSET (0)
/**
* Construct an SDIO CMD52 argument based on the given arguments.
*
* @param rw Flag indication direction (read or write).
* @param fn The applicable function.
* @param address The address to read/write. Must be <= @c MMHAL_SDIO_ADDRESS_MAX.
* @param write_data The data to write if this is a write operation. Should be set to zero
* for a read operation.
*
* @return the SDIO CMD52 argument generated based on the given arguments.
*/
static inline uint32_t mmhal_make_cmd52_arg(enum mmhal_sdio_rw rw, enum mmhal_sdio_function fn, uint32_t address,
uint8_t write_data)
{
uint32_t arg;
arg = rw | fn;
arg |= (address << MMHAL_SDIO_ADDRESS_OFFSET);
arg |= (write_data << MMHAL_SDIO_CMD52_DATA_OFFSET);
return arg;
}
/**
* Construct an SDIO CMD53 argument based on the given arguments.
*
* @param rw Flag indication direction (read or write).
* @param fn The applicable function.
* @param mode Selects between byte and block mode.
* @param address The address to read/write. Must be <= @c MMHAL_SDIO_ADDRESS_MAX.
* @param count The count of bytes/blocks (depending on @p mode) to transfer. Must
* be <= @c MMHAL_SDIO_COUNT_MAX.
*
* @note OP Code 1 (incrementing address) is assumed. See also @ref MMHAL_SDIO_OPCODE_INC_ADDR.
*
* @return the SDIO CMD53 argument generated based on the given arguments.
*/
static inline uint32_t mmhal_make_cmd53_arg(enum mmhal_sdio_rw rw, enum mmhal_sdio_function fn, enum mmhal_sdio_mode mode,
uint32_t address, uint16_t count)
{
uint32_t arg;
arg = rw | fn | MMHAL_SDIO_OPCODE_INC_ADDR | mode;
arg |= (address << MMHAL_SDIO_ADDRESS_OFFSET);
arg |= (count << MMHAL_SDIO_COUNT_OFFSET);
return arg;
}
/** @} */
/** @} */
#ifdef __cplusplus
}
#endif
/** @} */
-383
View File
@@ -1,383 +0,0 @@
/*
* Copyright 2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @defgroup MMIPAL Morse Micro IP Stack Abstraction Layer (MMIPAL) API
*
* This API provides a layer of abstraction from the underlying IP stack for common operations
* such as configuring the link and getting link status.
*
* @{
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stdbool.h>
#include <stdint.h>
/** Maximum length of an IP address string, including null-terminator. */
#ifndef MMIPAL_IPADDR_STR_MAXLEN
#define MMIPAL_IPADDR_STR_MAXLEN (48)
#endif
/** Maximum number of IPv6 addresses supported. */
#ifndef MMIPAL_MAX_IPV6_ADDRESSES
#define MMIPAL_MAX_IPV6_ADDRESSES (3)
#endif
/** Enumeration of status codes returned by MMIPAL functions. */
enum mmipal_status {
/** Completed successfully. */
MMIPAL_SUCCESS,
/** One or more arguments were invalid. */
MMIPAL_INVALID_ARGUMENT,
/** The operation could not complete because the link is not up. */
MMIPAL_NO_LINK,
/** Failed due to memory allocation failure. */
MMIPAL_NO_MEM,
/** This functionality is not supported (e.g., due to build configuration). */
MMIPAL_NOT_SUPPORTED,
};
/** Enumeration of link states. */
enum mmipal_link_state {
/** Link is down. */
MMIPAL_LINK_DOWN,
/** Link is up. */
MMIPAL_LINK_UP,
};
/** Enumeration of IP address allocation modes. */
enum mmipal_addr_mode {
/** Disabled. */
MMIPAL_DISABLED,
/** Static IP address. */
MMIPAL_STATIC,
/** IP address allocated via DHCP. @c LWIP_DHCP must be set to 1 if using LWIP. */
MMIPAL_DHCP,
/** IP address allocated via AutoIP. @c LWIP_DHCP must be set to 1 if using LWIP. */
MMIPAL_AUTOIP,
/** DHCP offloaded to chip. */
MMIPAL_DHCP_OFFLOAD,
};
/** IP address string type. */
typedef char mmipal_ip_addr_t[MMIPAL_IPADDR_STR_MAXLEN];
/**
* IPv4 configuration structure.
*
* This should be initialized using @c MMIPAL_IP_CONFIG_DEFAULT.
* For example:
*
* @code{.c}
* struct mmipal_ip_config config = MMIPAL_IP_CONFIG_DEAFULT;
* @endcode
*/
struct mmipal_ip_config {
/** IP address allocation mode. */
enum mmipal_addr_mode mode;
/** local IP address */
mmipal_ip_addr_t ip_addr;
/** Netmask address */
mmipal_ip_addr_t netmask;
/** Gateway address */
mmipal_ip_addr_t gateway_addr;
};
/** Initializer for @ref mmipal_ip_config. */
#define MMIPAL_IP_CONFIG_DEFAULT \
{ \
MMIPAL_DHCP, "", "", "", \
}
/** Enumeration of IPv6 address allocation modes. */
enum mmipal_ip6_addr_mode {
/** Disabled. */
MMIPAL_IP6_DISABLED,
/** Static IPv6 addresses. */
MMIPAL_IP6_STATIC,
/** IPv6 address allocated via autoconfiguration.
* @c LWIP_IPV6_AUTOCONFIG must be set to 1 if using LWIP. */
MMIPAL_IP6_AUTOCONFIG,
/** IPv6 address allocated via stateless DHCPv6.
* @c LWIP_IPV6_DHCP6_STATELESS must be set to 1 if using LWIP. */
MMIPAL_IP6_DHCP6_STATELESS,
};
/**
* IPv6 configuration structure.
*
* This should be initialized using @c MMIPAL_IP6_CONFIG_DEFAULT.
* For example:
*
* @code{.c}
* struct mmipal_ip6_config config = MMIPAL_IP6_CONFIG_DEFAULT;
* @endcode
*/
struct mmipal_ip6_config {
/** IPv6 addresses allocation mode. */
enum mmipal_ip6_addr_mode ip6_mode;
/** Array of IPv6 addresses. */
mmipal_ip_addr_t ip6_addr[MMIPAL_MAX_IPV6_ADDRESSES];
};
/** Initializer for @ref mmipal_ip6_config. */
#define MMIPAL_IP6_CONFIG_DEFAULT \
{ \
MMIPAL_IP6_AUTOCONFIG \
}
/**
* Initialize arguments structure.
*
* This should be initialized using @c MMIPAL_INIT_ARGS_DEFAULT.
* For example:
*
* @code{.c}
* struct mmipal_init_args args = MMIPAL_INIT_ARGS_DEFAULT;
* @endcode
*/
struct mmipal_init_args {
/** IP address allocation mode to use. */
enum mmipal_addr_mode mode;
/** IP address to use (if @c mode is @c MMIPAL_STATIC). */
mmipal_ip_addr_t ip_addr;
/** Netmask to use (if @c mode is @c MMIPAL_STATIC). */
mmipal_ip_addr_t netmask;
/** Gateway IP address to use (if @c mode is @c MMIPAL_STATIC). */
mmipal_ip_addr_t gateway_addr;
/** IPv6 address allocation mode to use. */
enum mmipal_ip6_addr_mode ip6_mode;
/** IPv6 address to use (if @c ip6_mode is @c MMIPAL_IP6_STATIC). */
mmipal_ip_addr_t ip6_addr;
/** Flag requesting ARP response offload feature */
bool offload_arp_response;
/** ARP refresh offload interval in seconds */
uint32_t offload_arp_refresh_s;
};
/**
* Default values for @ref mmipal_init_args. This should be used when initializing the
* @ref mmipal_init_args structure.
*/
#define MMIPAL_INIT_ARGS_DEFAULT \
{ \
MMIPAL_DHCP, {0}, {0}, {0}, MMIPAL_IP6_DISABLED, {0}, false, 0 \
}
/**
* Initialize the IP stack and enable the MMWLAN interface.
*
* This will implicitly initialize and boot MMWLAN, and will block until this has completed.
*
* @note This function will boot the Morse Micro transceiver using @ref mmwlan_boot() in order
* to read the MAC address. It is the responsibility of the caller to shut down the
* transceiver using @ref mmwlan_shutdown() as required.
*
* @warning @ref mmwlan_init() must be called before invoking this function.
*
* @param args Initialization arguments.
*
* @return @c MMIPAL_SUCCESS on success. otherwise a vendor specific error code.
*/
enum mmipal_status mmipal_init(const struct mmipal_init_args *args);
/**
* Structure representing the current status of the link.
*/
struct mmipal_link_status {
/** State of the link (up/down). */
enum mmipal_link_state link_state;
/** Current IP address. */
mmipal_ip_addr_t ip_addr;
/** Current netmask. */
mmipal_ip_addr_t netmask;
/** Current gateway IP address. */
mmipal_ip_addr_t gateway;
};
/**
* Prototype for callback function invoked on link status changes.
*
* @param link_status The current link status.
*/
typedef void (*mmipal_link_status_cb_fn_t)(const struct mmipal_link_status *link_status);
/**
* Sets the callback function to be invoked on link status changes.
*
* This will be used when DHCP is enabled.
*
* @note This is for IPv4 only. To get IPv6 status use @c mmipal_get_ip6_config.
* @note If an opaque argument is required then use @ref mmipal_set_ext_link_status_callback()
* instead.
*
* @param fn Function pointer to the callback function.
*/
void mmipal_set_link_status_callback(mmipal_link_status_cb_fn_t fn);
/**
* Prototype for callback function invoked on link status changes.
*
* This is similar to @ref mmipal_link_status_cb_fn_t but with the addition of the @p arg
* parameter.
*
* @param link_status The current link status.
* @param arg Opaque argument that was provided when the callback was registered.
*/
typedef void (*mmipal_ext_link_status_cb_fn_t)(const struct mmipal_link_status *link_status, void *arg);
/**
* Sets the extended link status callback function to be invoked on link status changes.
* This is similar to @ref mmipal_set_link_status_callback() with the exception that
* an opaque argument may also be specified.
*
* This will be used when DHCP is enabled.
*
* @note This is for IPv4 only. To get IPv6 status use @c mmipal_get_ip6_config.
*
* @param fn Function pointer to the callback function.
* @param arg Opaque argument to be passed to the callback.
*/
void mmipal_set_ext_link_status_callback(mmipal_ext_link_status_cb_fn_t fn, void *arg);
/**
* Get the total number of transmitted and received packets on the MMWLAN interface
*
* @note If using LWIP, this function requires LWIP_STATS to be defined in your application,
* otherwise packet counters will always return as 0.
*
* @param tx_packets Pointer to location to store total tx packets
* @param rx_packets Pointer to location to store total rx packets
*/
void mmipal_get_link_packet_counts(uint32_t *tx_packets, uint32_t *rx_packets);
/**
* Set the QoS Traffic ID to use when transmitting.
*
* @param tid The QoS TID to use (0 - @ref MMWLAN_MAX_QOS_TID).
*/
void mmipal_set_tx_qos_tid(uint8_t tid);
/**
* Gets the local address for the MMWLAN interface that is appropriate for a given
* destination address.
*
* The following table shows how the returned @c local_addr is selected:
*
* | @p dest_addr | @c local_addr returned |
* |--------------|---------------------------|
* | type is IPv4 | IPv4 address |
* | type is IPv6 | An IPv6 source address selected from interface's IPv6 addresses or ERR_CONN |
*
* (X = don't care)
*
* If the given parameters would result in a @p local_addr type of IPv4 and IPv4 is not enabled,
* or IPv6 and IPv6 is not enabled, then @c MMIPAL_INVALID_ARGUMENT will be returned.
*
* @param[out] local_addr Output local address for the MMWLAN interface, as noted above.
* @param[in] dest_addr Destination address.
*
* @return @c MMIPAL_SUCESS if @p local_addr successfully set. otherwise an
* appropriate error code.
*/
enum mmipal_status mmipal_get_local_addr(mmipal_ip_addr_t local_addr, const mmipal_ip_addr_t dest_addr);
/**
* Get the IP configurations.
*
* This can be used to get the local IP configurations.
*
* @param config Pointer to the IP configurations.
*
* @returns @c MMIPAL_SUCCESS on success, @c MMIPAL_NOT_SUPPORTED if IPv4 is not supported.
*/
enum mmipal_status mmipal_get_ip_config(struct mmipal_ip_config *config);
/**
* Set the IP configurations.
*
* This can be used to set the local IP configurations.
*
* @param config Pointer to the IP configurations.
*
* @returns @c MMIPAL_SUCCESS on success, @c MMIPAL_NOT_SUPPORTED if IPv4 is not supported.
*/
enum mmipal_status mmipal_set_ip_config(const struct mmipal_ip_config *config);
/**
* Gets the current IPv4 broadcast address.
*
* @param[out] broadcast_addr Buffer to receive the broadcast address as a string.
*
* @returns @c MMIPAL_SUCCESS on success, @c MMIPAL_NOT_SUPPORTED if IPv4 is not supported.
*/
enum mmipal_status mmipal_get_ip_broadcast_addr(mmipal_ip_addr_t broadcast_addr);
/**
* Get the IP configurations.
*
* This can be used to get the local IP configurations.
*
* @param config Pointer to the IP configurations.
*
* @returns @c MMIPAL_SUCCESS on success, @c MMIPAL_NOT_SUPPORTED if IPv6 is not supported..
*/
enum mmipal_status mmipal_get_ip6_config(struct mmipal_ip6_config *config);
/**
* Set the IPv6 configurations.
*
* This can be used to set the local IPv6 configurations.
*
* @param config Pointer to the IPv6 configurations.
*
* @returns @c MMIPAL_SUCCESS on success, @c MMIPAL_NOT_SUPPORTED if IPv6 is not supported.
*/
enum mmipal_status mmipal_set_ip6_config(const struct mmipal_ip6_config *config);
/**
* Get current IPv4 link state.
*
* @returns the current IPv4 link state (up or down).
*/
enum mmipal_link_state mmipal_get_link_state(void);
/**
* Set the DNS server at the given index.
*
* @warning Depending on IP stack implementation, this setting may be overridden by DHCP.
*
* @param[in] index Index of the DNS server to set.
* @param[out] addr Address of the DNS server to set.
*
* @returns @c MMIPAL_SUCCESS on success, @c MMIPAL_INVALID_ARGUMENT if an invalid index or IP
* address was given.
*/
enum mmipal_status mmipal_set_dns_server(uint8_t index, const mmipal_ip_addr_t addr);
/**
* Get the DNS server at the given index.
*
* @param[in] index Index of the DNS server to set.
* @param[out] addr IP address buffer to receive the IP address of the DNS server at the given
* index. Will be set to empty string if no server at the given index.
*
* @returns @c MMIPAL_SUCCESS on success.
*/
enum mmipal_status mmipal_get_dns_server(uint8_t index, mmipal_ip_addr_t addr);
#ifdef __cplusplus
}
#endif
/** @} */
-64
View File
@@ -1,64 +0,0 @@
/*
* Morse logging API
*
* Copyright 2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include <stddef.h>
#include <stdint.h>
/**
* Macro for printing a @c uint64_t as two separate @c uint32_t values. This is to allow printing of
* these values even when the @c printf implementation doesn't support it.
*/
#define MM_X64_VAL(value) ((uint32_t)(value >> 32)), ((uint32_t)value)
/** Macro for format specifier to print @ref MM_X64_VAL */
#define MM_X64_FMT "%08lx%08lx"
/**
* Macro for printing a MAC address. This saves writing it out by hand.
*
* Must be used in conjunction with @ref MM_MAC_ADDR_FMT. For example:
*
* @code
* uint8_t mac_addr[] = { 0, 1, 2, 3, 4, 5 };
* printf("MAC address: " MM_MAC_ADDR_FMT "\n", MM_MAC_ADDR_VAL(mac_addr));
* @endcode
*/
#define MM_MAC_ADDR_VAL(value) ((value)[0]), ((value)[1]), ((value)[2]), ((value)[3]), ((value)[4]), ((value)[5])
/** Macro for format specifier to print @ref MM_MAC_ADDR_VAL */
#define MM_MAC_ADDR_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
/**
* Initialize Morse logging API.
*
* This should be invoked after OS initialization since it will create a mutex for
* logging.
*/
void mm_logging_init(void);
/**
* Dumps a binary buffer in hex.
*
* @param level A single character indicating log level.
* @param function Name of function this was invoked from.
* @param line_number Line number this was invoked from.
* @param title Title of the buffer.
* @param buf The buffer to dump.
* @param len Length of the buffer.
*/
void mm_hexdump(char level, const char *function, unsigned line_number, const char *title, const uint8_t *buf, size_t len);
#ifdef __cplusplus
}
#endif
File diff suppressed because it is too large Load Diff
-515
View File
@@ -1,515 +0,0 @@
/*
* Copyright 2022-2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @defgroup MMPKT Morse Micro Packet Buffer (mmpkt) API
*
* This API provides support for buffers tailored towards packets.
*
* @{
*/
#pragma once
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "mmosal.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* Round @p x up to the next multiple of @p m (where @p m is a power of 2).
*
* @warning @p m must be a power of 2.
*/
#ifndef MM_FAST_ROUND_UP
#define MM_FAST_ROUND_UP(x, m) ((((x)-1) | ((m)-1)) + 1)
#endif
struct mmdrv_cmd_metadata;
struct mmdrv_tx_metadata;
struct mmdrv_rx_metadata;
struct mmpkt_ops;
/**
* Union of pointer types for mmpkt metadata.
*
* The metadata is accessed through one of these pointers, depending on which context the packet
* is being used in.
*/
union mmpkt_metadata_ptr {
/** Opaque pointer for contexts which are unaware of the specific metadata structure. */
void *opaque;
/** Metadata for a packet which is being transmitted. */
struct mmdrv_tx_metadata *tx;
/** Metadata for a packet which is being received. */
struct mmdrv_rx_metadata *rx;
/** Control block for a command response sent to the host. */
struct mmdrv_cmd_metadata *cmd;
};
/**
* Core mmpkt data structure.
*
* @note The contents of this data structure should never need to be accessed directly. Rather
* the various functions provided as part of this API should be used.
*
* @code
* +----------------------------------------------------------+--------------+
* | RESERVED | Data | RESERVED | METADATA |
* +----------------------------------------------------------+--------------+
* ^ ^ ^ ^
* | | | |
* | |<-----------data_len--------->| |
* | start_offset |
* | |
* |<-----------------------buf_len-------------------------->|
* buf
* @endcode
*/
struct mmpkt {
/** The buffer where data is stored. */
uint8_t *buf;
/** Length of the buffer. */
uint32_t buf_len;
/** Offset where actual data starts in the buffer. */
uint32_t start_offset;
/** Length of actual data in the buffer. */
uint32_t data_len;
/** Packet metadata used by driver (context dependent). */
union mmpkt_metadata_ptr metadata;
/** Reference to operations data structure for this mmpkt. */
const struct mmpkt_ops *ops;
/** Pointer that can be used to construct linked lists. */
struct mmpkt *volatile next;
};
/** Operations data structure for mmpkt. */
struct mmpkt_ops {
/** Free the given mmpkt. */
void (*free_mmpkt)(void *mmpkt);
};
/**
* Opened view of an mmpkt.
*
* In this implementation, this structure does not actually exist. We only use it as a pointer type
* which is incompatible with @ref mmpkt, to distinguish between functions which operate on opened
* packet views versus functions which can operate on unopened packets.
*
* In other implementations of this API, packets must be "opened" (mapped into memory) before their
* contents can be accessed. Thus the distinction between opened and unopened packets is important
* for those implementations.
*/
struct mmpktview;
/**
* Initialize an mmpkt header with the given values.
*
* @param mmpkt mmpkt to initialize.
* @param buf Pointer to buffer.
* @param buf_len Length of @p buf.
* @param data_start_offset Initial value for @c start_offset.
* @param ops Operations data structure.
*/
static inline void mmpkt_init(struct mmpkt *mmpkt, uint8_t *buf, uint32_t buf_len, uint32_t data_start_offset,
const struct mmpkt_ops *ops)
{
memset(mmpkt, 0, sizeof(*mmpkt));
mmpkt->buf = buf;
mmpkt->buf_len = buf_len;
mmpkt->start_offset = data_start_offset;
mmpkt->ops = ops;
}
/**
* Initialize an mmpkt in a single buffer using the given values.
*
* @param buf Pointer to buffer.
* @param buf_len Length of @p buf.
* @param space_at_start Amount of space to reserve at start of buffer.
* @param space_at_end Amount of space to reserve at end of buffer.
* @param metadata_size Size of metadata (0 for no metadata).
*
* @param ops Operations data structure.
*
* @note @p buf_len must be large enough to contain the @c mmkpt header, the data buffer
* (rounded up to the nearest 4 bytes) and metadata (rounded up to the nearest 4 bytes).
*
* @returns a pointer to the initialized @c mmpkt (will be the same address as @p buf) or @c NULL
* on error (@p buf length too short).
*/
static inline struct mmpkt *mmpkt_init_buf(uint8_t *buf, uint32_t buf_len, uint32_t space_at_start, uint32_t space_at_end,
uint32_t metadata_size, const struct mmpkt_ops *ops)
{
struct mmpkt *mmpkt = (struct mmpkt *)buf;
uint8_t *data_start;
uint32_t header_size = MM_FAST_ROUND_UP(sizeof(*mmpkt), 4);
uint32_t data_len = MM_FAST_ROUND_UP(space_at_start + space_at_end, 4);
metadata_size = MM_FAST_ROUND_UP(metadata_size, 4);
if (header_size + data_len + metadata_size > buf_len) {
return NULL;
}
data_start = ((uint8_t *)mmpkt) + header_size;
mmpkt_init(mmpkt, data_start, data_len, space_at_start, ops);
if (metadata_size != 0) {
mmpkt->metadata.opaque = data_start + data_len;
memset(mmpkt->metadata.opaque, 0, metadata_size);
}
return mmpkt;
}
/**
* Allocate a new mmpkt on the heap (using @ref mmosal_malloc()).
*
* @param space_at_start Amount of space to reserve at start of buffer.
* @param space_at_end Amount of space to reserve at end of buffer.
* @param metadata_size Size of metadata (0 for no metadata).
*
* @note @c start_offset will be set to @p space_at_start, and @c buf_len will be the sum
* of @p space_at_start and @p space_at_end (rounded up to a multiple of 4).
*
* @returns newly allocated mmpkt on success or @c NULL on failure.
*/
struct mmpkt *mmpkt_alloc_on_heap(uint32_t space_at_start, uint32_t space_at_end, uint32_t metadata_size);
/**
* Release a reference to the given mmpkt. If this was the last reference (@c addition_ref_cnt
* was 0) then the mmpkt will be freed using the appropriate op callback.
*
* @param mmpkt The mmpkt to release reference to. May be @c NULL.
*/
void mmpkt_release(struct mmpkt *mmpkt);
/**
* Open a view of the given mmpkt.
*
* Packets must be opened before the contents of their buffer can be accessed. Most of the
* functions below expect to be passed an opened view of a packet to operate on.
*
* The view must be closed by calling @ref mmpkt_close() before the packet is released by
* @ref mmpkt_release().
*
* @param mmpkt The mmpkt to be opened.
*
* @returns a pointer representing the opened view.
*/
static inline struct mmpktview *mmpkt_open(struct mmpkt *mmpkt)
{
return (struct mmpktview *)mmpkt;
}
/**
* Close the given view.
*
* @param[in,out] view Pointer to a variable holding the view to be closed.
* This will be modified to indicate it is no longer valid.
*/
static inline void mmpkt_close(struct mmpktview **view)
{
(void)(view);
}
/**
* Get the underlying mmpkt from an opened view.
*
* @param view View of an mmpkt.
*
* @returns the underlying mmpkt.
*/
static inline struct mmpkt *mmpkt_from_view(struct mmpktview *view)
{
return (struct mmpkt *)view;
}
/**
* Gets a pointer to the start of the data in the mmpkt.
*
* @param view The opened mmpkt to operate on.
*
* @returns a pointer to the start of the data in the mmpkt.
*/
static inline uint8_t *mmpkt_get_data_start(struct mmpktview *view)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
return mmpkt->buf + mmpkt->start_offset;
}
/**
* Gets a pointer to the end of the data in the mmpkt.
*
* @param view The opened mmpkt to operate on.
*
* @returns a pointer to the end of the data in the mmpkt.
*/
static inline uint8_t *mmpkt_get_data_end(struct mmpktview *view)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
return mmpkt->buf + mmpkt->start_offset + mmpkt->data_len;
}
/**
* Peek the length of the data currently from an unopened mmpkt.
*
* @param mmpkt The unopened mmpkt to operate on.
*
* @returns the length of the data currently in the mmpkt (note that this is different from the
* length of the available buffer space).
*/
static inline uint32_t mmpkt_peek_data_length(struct mmpkt *mmpkt)
{
return mmpkt->data_len;
}
/**
* Gets the length of the data currently in the mmpkt.
*
* @param view The opened mmpkt to operate on.
*
* @returns the length of the data currently in the mmpkt (note that this is different from the
* length of the available buffer space).
*/
static inline uint32_t mmpkt_get_data_length(struct mmpktview *view)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
return mmpkt->data_len;
}
/**
* Returns the amount of space available for prepending to the data in the buffer.
*
* @param view The opened mmpkt to operate on.
*
* @returns the available space in bytes.
*/
static inline uint32_t mmpkt_available_space_at_start(struct mmpktview *view)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
return mmpkt->start_offset;
}
/**
* Returns the amount of space available for appending to the data in the buffer.
*
* @param view The opened mmpkt to operate on.
*
* @returns the available space in bytes.
*/
static inline uint32_t mmpkt_available_space_at_end(struct mmpktview *view)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
return mmpkt->buf_len - (mmpkt->start_offset + mmpkt->data_len);
}
/**
* Reserves space immediately before the data currently in the given mmpkt and returns
* a pointer to this space.
*
* For a function that also copies data in, see @ref mmpkt_prepend_data().
*
* @warning @p len must be less than or equal to @ref mmpkt_available_space_at_start().
*
* @param view The opened mmpkt to operate on.
* @param len Length of data to be prepended.
*
* @returns a pointer to the place in the buffer where the data should be put.
*/
static inline uint8_t *mmpkt_prepend(struct mmpktview *view, uint32_t len)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
MMOSAL_ASSERT(len <= mmpkt_available_space_at_start(view));
mmpkt->start_offset -= len;
mmpkt->data_len += len;
return mmpkt->buf + mmpkt->start_offset;
}
/**
* Prepends the given data to the data already in the mmpkt.
*
* @warning @p len must be less than or equal to @ref mmpkt_available_space_at_start().
*
* @warning The memory area pointed to by data must not overlap with the mmpkt data.
*
* @param view The opened mmpkt to operate on.
* @param data The data to be prepended.
* @param len Length of data to be prepended.
*/
static inline void mmpkt_prepend_data(struct mmpktview *view, const uint8_t *data, uint32_t len)
{
uint8_t *dest = mmpkt_prepend(view, len);
memcpy(dest, data, len);
}
/**
* Reserves space immediately after the data currently in the given mmpkt and returns
* a pointer to this space.
*
* For a function that also copies data in, see @ref mmpkt_append_data().
*
* @warning @p len must be less than or equal to @ref mmpkt_available_space_at_end().
*
* @param view The opened mmpkt to operate on.
* @param len Length of data to be append.
*
* @returns a pointer to the place in the buffer where the data should be put.
*/
static inline uint8_t *mmpkt_append(struct mmpktview *view, uint32_t len)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
uint8_t *ret = mmpkt_get_data_end(view);
MMOSAL_ASSERT(len <= mmpkt_available_space_at_end(view));
mmpkt->data_len += len;
return ret;
}
/**
* Appends the given data to the data already in the mmpkt.
*
* @warning @p len must be less than or equal to @ref mmpkt_available_space_at_start().
*
* @param view The opened mmpkt to operate on.
* @param data The data to be prepended.
* @param len Length of data to be prepended.
*/
static inline void mmpkt_append_data(struct mmpktview *view, const uint8_t *data, uint32_t len)
{
uint8_t *dest = mmpkt_append(view, len);
memcpy(dest, data, len);
}
/**
* Retrieve a reference to the metadata associated with the given mmpkt.
*
* @param mmpkt The mmpkt to operate on.
*
* @returns a reference to the mmpkt metadata.
*/
static inline union mmpkt_metadata_ptr mmpkt_get_metadata(struct mmpkt *mmpkt)
{
return mmpkt->metadata;
}
/**
* Remove data from the start of the mmpkt.
*
* @param view The opened mmpkt to operate on.
* @param len Length of data to remove.
*
* @returns a pointer to the removed data or NULL if the mmpkt data length was less than @p len.
*/
static inline uint8_t *mmpkt_remove_from_start(struct mmpktview *view, uint32_t len)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
uint8_t *ret;
if (mmpkt_get_data_length(view) < len) {
return NULL;
}
ret = mmpkt_get_data_start(view);
mmpkt->start_offset += len;
mmpkt->data_len -= len;
return ret;
}
/**
* Remove data from the end of the mmpkt.
*
* @param view The opened mmpkt to operate on.
* @param len Length of data to remove.
*
* @returns a pointer to the removed data or NULL if the mmpkt data length was less than @p len.
*/
static inline uint8_t *mmpkt_remove_from_end(struct mmpktview *view, uint32_t len)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
uint8_t *ret;
if (mmpkt_get_data_length(view) < len) {
return NULL;
}
ret = mmpkt_get_data_end(view) - len;
mmpkt->data_len -= len;
return ret;
}
/**
* Truncate the mmpkt data to the given length.
*
* @param mmpkt mmpkt to operate on.
* @param len New data length. (Must be less than or equal to the data length
* of the mmpkt).
*/
static inline void mmpkt_truncate(struct mmpkt *mmpkt, uint32_t len)
{
MMOSAL_ASSERT(len <= mmpkt->data_len);
mmpkt->data_len = len;
}
/**
* Get the `next` pointer embedded in the mmpkt.
*
* Used by the mmpkt_list structure for making linked lists of mmpkts.
*
* @param mmpkt The mmpkt to operate on.
*
* @returns pointer to the next mmpkt in the chain (may be NULL).
*/
static inline struct mmpkt *mmpkt_get_next(struct mmpkt *mmpkt)
{
return mmpkt->next;
}
/**
* Set the `next` pointer embedded in the mmpkt.
*
* Used by the mmpkt_list structure for making linked lists of mmpkts.
*
* @param mmpkt The mmpkt to operate on.
* @param next The next mmpkt in the chain.
*/
static inline void mmpkt_set_next(struct mmpkt *mmpkt, struct mmpkt *next)
{
mmpkt->next = next;
}
/**
* Check whether the given pointer is pointing inside the mmpkt's buffer.
*
* @note This checks against the full buffer, which includes any unused regions at the beginning and
* end of the buffer which do not contain valid packet data.
*
* @param view The opened mmpkt to operate on.
* @param ptr The pointer to check.
*
* @returns true if the pointer points into the buffer.
*/
static inline bool mmpkt_contains_ptr(struct mmpktview *view, const void *ptr)
{
struct mmpkt *mmpkt = (struct mmpkt *)view;
return ((const uint8_t *)ptr >= &mmpkt->buf[0] && (const uint8_t *)ptr < &mmpkt->buf[mmpkt->buf_len]);
}
#ifdef __cplusplus
}
#endif
/** @} */
-172
View File
@@ -1,172 +0,0 @@
/*
* Copyright 2022-2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @ingroup MMPKT
*
* @{
*/
#pragma once
#include <stddef.h>
#include "mmpkt.h"
#ifdef __cplusplus
extern "C" {
#endif
/** Structure that can be used as the head of a linked list of mmpkts that counts its length. */
struct mmpkt_list {
/** First mmpkt in the list. */
struct mmpkt *volatile head;
/** Last mmpkt in the list. */
struct mmpkt *volatile tail;
/** Length of the list. */
volatile uint32_t len;
};
/** Static initializer for @ref mmpkt_list. */
#define MMPKT_LIST_INIT \
{ \
NULL, NULL, 0 \
}
/**
* Initialization function for @ref mmpkt_list, for cases where @c MMPKT_LIST_INIT
* cannot be used.
*
* @param list The mmpkt_list to init.
*/
static inline void mmpkt_list_init(struct mmpkt_list *list)
{
list->head = NULL;
list->tail = NULL;
list->len = 0;
}
/**
* Add an mmpkt to the start of an mmpkt list.
*
* @param list The list to prepend to.
* @param mmpkt The mmpkt to prepend.
*/
void mmpkt_list_prepend(struct mmpkt_list *list, struct mmpkt *mmpkt);
/**
* Add an mmpkt to the end of an mmpkt list.
*
* @param list The list to append to.
* @param mmpkt The mmpkt to append.
*/
void mmpkt_list_append(struct mmpkt_list *list, struct mmpkt *mmpkt);
/**
* Remove an mmpkt from an mmpkt list.
*
* @param list The list to remove from.
* @param mmpkt The mmpkt to remove.
*/
void mmpkt_list_remove(struct mmpkt_list *list, struct mmpkt *mmpkt);
/**
* Remove the mmpkt at the head of the list and return it.
*
* @param list The list to dequeue from.
*
* @returns the dequeued mmpkt, or @c NULL if the list is empty.
*/
struct mmpkt *mmpkt_list_dequeue(struct mmpkt_list *list);
/**
* Remove the mmpkt at the tail of the list and return it.
*
* @param list The list to dequeue from.
*
* @returns the dequeued mmpkt, or @c NULL if the list is empty.
*/
struct mmpkt *mmpkt_list_dequeue_tail(struct mmpkt_list *list);
/**
* Remove all mmpkts from the list and return as a linked list.
*
* @param list The list to dequeue from.
*
* @returns the dequeued mmpkts, or @c NULL if the list is empty.
*/
static inline struct mmpkt *mmpkt_list_dequeue_all(struct mmpkt_list *list)
{
struct mmpkt *head = list->head;
list->head = NULL;
list->tail = NULL;
list->len = 0;
return head;
}
/**
* Checks whether the given mmpkt list is empty.
*
* @param list The list to check.
*
* @returns @c true if the list is empty, else @c false.
*/
static inline bool mmpkt_list_is_empty(struct mmpkt_list *list)
{
return (list->head == NULL);
}
/**
* Returns the head of the mmpkt list.
*
* @param list The list to peek into.
*
* @returns the mmpkt at the head of the list.
*/
static inline struct mmpkt *mmpkt_list_peek(struct mmpkt_list *list)
{
return list->head;
}
/**
* Returns the tail of the mmpkt list.
*
* @param list The list to peek into.
*
* @returns the mmpkt at the tail of the list.
*/
static inline struct mmpkt *mmpkt_list_peek_tail(struct mmpkt_list *list)
{
return list->tail;
}
/**
* Free all the packets in the given list and reset the list to empty state.
*
* @param list The list to clear.
*/
void mmpkt_list_clear(struct mmpkt_list *list);
/**
* Safely walk the mmpkt list.
*
* @warning This macro cannot be used following an if statement with no parentheses if there
* is an else clause. For example, do not do:
* `if (x) MMPKT_LIST_WALK(a,b,c) else foo();` -- instead:
* `if (x) { MMPKT_LIST_WALK(a,b,c) } else foo();`
*/
#define MMPKT_LIST_WALK(_lst, _wlk, _nxt) \
if ((_lst)->head != NULL) /* NOLINT(readability/braces) */ \
for (_wlk = (_lst)->head, _nxt = mmpkt_get_next(_wlk); _wlk != NULL; \
_wlk = _nxt, _nxt = _wlk ? mmpkt_get_next(_wlk) : NULL)
#ifdef __cplusplus
}
#endif
/**
* @}
*/
File diff suppressed because it is too large Load Diff
-302
View File
@@ -1,302 +0,0 @@
/*
*
* Copyright 2022-2023 Morse Micro
*/
/**
* @ingroup MMWLAN_REGDB
* @defgroup MMWLAN_REGDB_TEMPLATE Template S1G regulatory database
*
* \{
*
* @section MMWLAN_REGDB_TEMPLATE_DISCLAIMER Disclaimer
*
* While every effort has been made to maintain accuracy of this database, no guarantee is
* given as to the accuracy of the information contained herein.
*
* @section MMWLAN_REGDB_TEMPLATE_COUNTRIES Country code list
*
* | Country Code | Country |
* | ------------ | ------- |
* | AU | Australia |
* | EU | EU |
* | IN | India |
* | JP | Japan |
* | KR | South Korea |
* | NZ | New Zealand |
* | SG | Singapore |
* | US | USA |
*/
#include "mmwlan.h"
/** List of valid S1G channels for Australia. */
static const struct mmwlan_s1g_channel s1g_channels_AU[] = {
/* Ctr Freq (Hz), Duty Cycle (%/100), Omit Control Response, Global Op Class, S1G Op Class, S1G Chan #, Op BW, Max Tx EIRP (dBm), Min Packet Spacing Window (microsec), airtime_min (microsec), airtime_max (microsec) */
{ 915500000, 10000, false, 68, 22, 27, 1, 30, 0, 0, 0 },
{ 916500000, 10000, false, 68, 22, 29, 1, 30, 0, 0, 0 },
{ 917500000, 10000, false, 68, 22, 31, 1, 30, 0, 0, 0 },
{ 918500000, 10000, false, 68, 22, 33, 1, 30, 0, 0, 0 },
{ 919500000, 10000, false, 68, 22, 35, 1, 30, 0, 0, 0 },
{ 920500000, 10000, false, 68, 22, 37, 1, 30, 0, 0, 0 },
{ 921500000, 10000, false, 68, 22, 39, 1, 30, 0, 0, 0 },
{ 922500000, 10000, false, 68, 22, 41, 1, 30, 0, 0, 0 },
{ 923500000, 10000, false, 68, 22, 43, 1, 30, 0, 0, 0 },
{ 924500000, 10000, false, 68, 22, 45, 1, 30, 0, 0, 0 },
{ 925500000, 10000, false, 68, 22, 47, 1, 30, 0, 0, 0 },
{ 926500000, 10000, false, 68, 22, 49, 1, 30, 0, 0, 0 },
{ 927500000, 10000, false, 68, 22, 51, 1, 30, 0, 0, 0 },
{ 917000000, 10000, false, 69, 23, 30, 2, 30, 0, 0, 0 },
{ 919000000, 10000, false, 69, 23, 34, 2, 30, 0, 0, 0 },
{ 921000000, 10000, false, 69, 23, 38, 2, 30, 0, 0, 0 },
{ 923000000, 10000, false, 69, 23, 42, 2, 30, 0, 0, 0 },
{ 925000000, 10000, false, 69, 23, 46, 2, 30, 0, 0, 0 },
{ 927000000, 10000, false, 69, 23, 50, 2, 30, 0, 0, 0 },
{ 918000000, 10000, false, 70, 24, 32, 4, 30, 0, 0, 0 },
{ 922000000, 10000, false, 70, 24, 40, 4, 30, 0, 0, 0 },
{ 926000000, 10000, false, 70, 24, 48, 4, 30, 0, 0, 0 },
{ 924000000, 10000, false, 71, 25, 44, 8, 30, 0, 0, 0 },
};
/** Channel list structure for Australia. */
static const struct mmwlan_s1g_channel_list s1g_channel_list_AU = {
.country_code = "AU",
.num_channels = (sizeof(s1g_channels_AU)/sizeof(s1g_channels_AU[0])),
.channels = s1g_channels_AU,
};
/** List of valid S1G channels for EU. */
static const struct mmwlan_s1g_channel s1g_channels_EU[] = {
/* Ctr Freq (Hz), Duty Cycle (%/100), Omit Control Response, Global Op Class, S1G Op Class, S1G Chan #, Op BW, Max Tx EIRP (dBm), Min Packet Spacing Window (microsec), airtime_min (microsec), airtime_max (microsec) */
{ 863500000, 280, false, 66, 6, 1, 1, 16, 0, 0, 0 },
{ 864500000, 280, false, 66, 6, 3, 1, 16, 0, 0, 0 },
{ 865500000, 280, false, 66, 6, 5, 1, 16, 0, 0, 0 },
{ 866500000, 280, false, 66, 6, 7, 1, 16, 0, 0, 0 },
{ 867500000, 280, false, 66, 6, 9, 1, 16, 0, 0, 0 },
};
/** Channel list structure for EU. */
static const struct mmwlan_s1g_channel_list s1g_channel_list_EU = {
.country_code = "EU",
.num_channels = (sizeof(s1g_channels_EU)/sizeof(s1g_channels_EU[0])),
.channels = s1g_channels_EU,
};
/** List of valid S1G channels for India. */
static const struct mmwlan_s1g_channel s1g_channels_IN[] = {
/* Ctr Freq (Hz), Duty Cycle (%/100), Omit Control Response, Global Op Class, S1G Op Class, S1G Chan #, Op BW, Max Tx EIRP (dBm), Min Packet Spacing Window (microsec), airtime_min (microsec), airtime_max (microsec) */
{ 865500000, 280, false, 66, 6, 5, 1, 16, 0, 0, 0 },
{ 866500000, 280, false, 66, 6, 7, 1, 16, 0, 0, 0 },
{ 867500000, 280, false, 66, 6, 9, 1, 16, 0, 0, 0 },
};
/** Channel list structure for India. */
static const struct mmwlan_s1g_channel_list s1g_channel_list_IN = {
.country_code = "IN",
.num_channels = (sizeof(s1g_channels_IN)/sizeof(s1g_channels_IN[0])),
.channels = s1g_channels_IN,
};
/** List of valid S1G channels for Japan. */
static const struct mmwlan_s1g_channel s1g_channels_JP[] = {
/* Ctr Freq (Hz), Duty Cycle (%/100), Omit Control Response, Global Op Class, S1G Op Class, S1G Chan #, Op BW, Max Tx EIRP (dBm), Min Packet Spacing Window (microsec), airtime_min (microsec), airtime_max (microsec) */
{ 921000000, 1000, true, 73, 8, 9, 1, 16, 2000, 2000, 100000 },
{ 923000000, 1000, true, 73, 8, 13, 1, 16, 2000, 2000, 100000 },
{ 924000000, 1000, true, 73, 8, 15, 1, 16, 2000, 2000, 100000 },
{ 925000000, 1000, true, 73, 8, 17, 1, 16, 2000, 2000, 100000 },
{ 926000000, 1000, true, 73, 8, 19, 1, 16, 2000, 2000, 100000 },
{ 927000000, 1000, true, 73, 8, 21, 1, 16, 2000, 2000, 100000 },
{ 923500000, 1000, true, 64, 9, 2, 2, 16, 2000, 2000, 100000 },
{ 924500000, 1000, true, 64, 10, 4, 2, 16, 2000, 2000, 100000 },
{ 925500000, 1000, true, 64, 9, 6, 2, 16, 2000, 2000, 100000 },
{ 926500000, 1000, true, 64, 10, 8, 2, 16, 2000, 2000, 100000 },
{ 924500000, 1000, true, 65, 11, 36, 4, 16, 2000, 2000, 100000 },
{ 925500000, 1000, true, 65, 12, 38, 4, 16, 2000, 2000, 100000 },
};
/** Channel list structure for Japan. */
static const struct mmwlan_s1g_channel_list s1g_channel_list_JP = {
.country_code = "JP",
.num_channels = (sizeof(s1g_channels_JP)/sizeof(s1g_channels_JP[0])),
.channels = s1g_channels_JP,
};
/** List of valid S1G channels for South Korea. */
static const struct mmwlan_s1g_channel s1g_channels_KR[] = {
/* Ctr Freq (Hz), Duty Cycle (%/100), Omit Control Response, Global Op Class, S1G Op Class, S1G Chan #, Op BW, Max Tx EIRP (dBm), Min Packet Spacing Window (microsec), airtime_min (microsec), airtime_max (microsec) */
{ 918000000, 10000, false, 74, 14, 1, 1, 4, 50000, 0, 4000000 },
{ 919000000, 10000, false, 74, 14, 3, 1, 4, 50000, 0, 4000000 },
{ 920000000, 10000, false, 74, 14, 5, 1, 4, 50000, 0, 4000000 },
{ 921000000, 10000, false, 74, 14, 7, 1, 4, 50000, 0, 4000000 },
{ 922000000, 10000, false, 74, 14, 9, 1, 10, 50000, 0, 4000000 },
{ 923000000, 10000, false, 74, 14, 11, 1, 10, 50000, 0, 4000000 },
{ 918500000, 10000, false, 75, 15, 2, 2, 4, 50000, 0, 4000000 },
{ 920500000, 10000, false, 75, 15, 6, 2, 4, 50000, 0, 4000000 },
{ 922500000, 10000, false, 75, 15, 10, 2, 10, 50000, 0, 4000000 },
{ 921500000, 10000, false, 76, 16, 8, 4, 4, 50000, 0, 4000000 },
{ 926500000, 10000, false, 74, 14, 18, 1, 17, 264, 0, 220000 }, /* Warning: regulatory requirements may not be met */
{ 927500000, 10000, false, 74, 14, 20, 1, 17, 264, 0, 220000 }, /* Warning: regulatory requirements may not be met */
{ 928500000, 10000, false, 74, 14, 22, 1, 17, 264, 0, 220000 }, /* Warning: regulatory requirements may not be met */
{ 929500000, 10000, false, 74, 14, 24, 1, 17, 264, 0, 220000 }, /* Warning: regulatory requirements may not be met */
{ 927000000, 10000, false, 75, 15, 19, 2, 20, 264, 0, 220000 }, /* Warning: regulatory requirements may not be met */
{ 929000000, 10000, false, 75, 15, 23, 2, 20, 264, 0, 220000 }, /* Warning: regulatory requirements may not be met */
};
/** Channel list structure for South Korea. */
static const struct mmwlan_s1g_channel_list s1g_channel_list_KR = {
.country_code = "KR",
.num_channels = (sizeof(s1g_channels_KR)/sizeof(s1g_channels_KR[0])),
.channels = s1g_channels_KR,
};
/** List of valid S1G channels for New Zealand. */
static const struct mmwlan_s1g_channel s1g_channels_NZ[] = {
/* Ctr Freq (Hz), Duty Cycle (%/100), Omit Control Response, Global Op Class, S1G Op Class, S1G Chan #, Op BW, Max Tx EIRP (dBm), Min Packet Spacing Window (microsec), airtime_min (microsec), airtime_max (microsec) */
{ 915500000, 10000, false, 68, 26, 27, 1, 30, 0, 0, 0 },
{ 916500000, 10000, false, 68, 26, 29, 1, 30, 0, 0, 0 },
{ 917500000, 10000, false, 68, 26, 31, 1, 30, 0, 0, 0 },
{ 918500000, 10000, false, 68, 26, 33, 1, 30, 0, 0, 0 },
{ 919500000, 10000, false, 68, 26, 35, 1, 30, 0, 0, 0 },
{ 920500000, 10000, false, 68, 26, 37, 1, 36, 0, 0, 0 },
{ 921500000, 10000, false, 68, 26, 39, 1, 36, 0, 0, 0 },
{ 922500000, 10000, false, 68, 26, 41, 1, 36, 0, 0, 0 },
{ 923500000, 10000, false, 68, 26, 43, 1, 36, 0, 0, 0 },
{ 924500000, 10000, false, 68, 26, 45, 1, 36, 0, 0, 0 },
{ 925500000, 10000, false, 68, 26, 47, 1, 36, 0, 0, 0 },
{ 926500000, 10000, false, 68, 26, 49, 1, 36, 0, 0, 0 },
{ 927500000, 10000, false, 68, 26, 51, 1, 36, 0, 0, 0 },
{ 917000000, 10000, false, 69, 27, 30, 2, 30, 0, 0, 0 },
{ 919000000, 10000, false, 69, 27, 34, 2, 30, 0, 0, 0 },
{ 921000000, 10000, false, 69, 27, 38, 2, 36, 0, 0, 0 },
{ 923000000, 10000, false, 69, 27, 42, 2, 36, 0, 0, 0 },
{ 925000000, 10000, false, 69, 27, 46, 2, 36, 0, 0, 0 },
{ 927000000, 10000, false, 69, 27, 50, 2, 36, 0, 0, 0 },
{ 918000000, 10000, false, 70, 28, 32, 4, 30, 0, 0, 0 },
{ 922000000, 10000, false, 70, 28, 40, 4, 36, 0, 0, 0 },
{ 926000000, 10000, false, 70, 28, 48, 4, 36, 0, 0, 0 },
{ 924000000, 10000, false, 71, 29, 44, 8, 36, 0, 0, 0 },
};
/** Channel list structure for New Zealand. */
static const struct mmwlan_s1g_channel_list s1g_channel_list_NZ = {
.country_code = "NZ",
.num_channels = (sizeof(s1g_channels_NZ)/sizeof(s1g_channels_NZ[0])),
.channels = s1g_channels_NZ,
};
/** List of valid S1G channels for Singapore. */
static const struct mmwlan_s1g_channel s1g_channels_SG[] = {
/* Ctr Freq (Hz), Duty Cycle (%/100), Omit Control Response, Global Op Class, S1G Op Class, S1G Chan #, Op BW, Max Tx EIRP (dBm), Min Packet Spacing Window (microsec), airtime_min (microsec), airtime_max (microsec) */
{ 866500000, 277, false, 66, 17, 7, 1, 29, 100000, 0, 1000000 },
{ 867500000, 277, false, 66, 17, 9, 1, 29, 100000, 0, 1000000 },
{ 868500000, 277, false, 66, 17, 11, 1, 29, 100000, 0, 1000000 },
{ 868000000, 277, false, 67, 19, 10, 2, 29, 100000, 0, 1000000 },
{ 920500000, 10000, false, 68, 18, 37, 1, 22, 0, 0, 0 },
{ 921500000, 10000, false, 68, 18, 39, 1, 22, 0, 0, 0 },
{ 922500000, 10000, false, 68, 18, 41, 1, 22, 0, 0, 0 },
{ 923500000, 10000, false, 68, 18, 43, 1, 22, 0, 0, 0 },
{ 924500000, 10000, false, 68, 18, 45, 1, 22, 0, 0, 0 },
{ 921000000, 10000, false, 69, 20, 38, 2, 22, 0, 0, 0 },
{ 923000000, 10000, false, 69, 20, 42, 2, 22, 0, 0, 0 },
{ 922000000, 10000, false, 70, 21, 40, 4, 22, 0, 0, 0 },
};
/** Channel list structure for Singapore. */
static const struct mmwlan_s1g_channel_list s1g_channel_list_SG = {
.country_code = "SG",
.num_channels = (sizeof(s1g_channels_SG)/sizeof(s1g_channels_SG[0])),
.channels = s1g_channels_SG,
};
/** List of valid S1G channels for USA. */
static const struct mmwlan_s1g_channel s1g_channels_US[] = {
/* Ctr Freq (Hz), Duty Cycle (%/100), Omit Control Response, Global Op Class, S1G Op Class, S1G Chan #, Op BW, Max Tx EIRP (dBm), Min Packet Spacing Window (microsec), airtime_min (microsec), airtime_max (microsec) */
{ 902500000, 10000, false, 68, 1, 1, 1, 36, 0, 0, 0 }, /* Warning: regulatory requirements may not be met */
{ 903500000, 10000, false, 68, 1, 3, 1, 36, 0, 0, 0 },
{ 904500000, 10000, false, 68, 1, 5, 1, 36, 0, 0, 0 },
{ 905500000, 10000, false, 68, 1, 7, 1, 36, 0, 0, 0 },
{ 906500000, 10000, false, 68, 1, 9, 1, 36, 0, 0, 0 },
{ 907500000, 10000, false, 68, 1, 11, 1, 36, 0, 0, 0 },
{ 908500000, 10000, false, 68, 1, 13, 1, 36, 0, 0, 0 },
{ 909500000, 10000, false, 68, 1, 15, 1, 36, 0, 0, 0 },
{ 910500000, 10000, false, 68, 1, 17, 1, 36, 0, 0, 0 },
{ 911500000, 10000, false, 68, 1, 19, 1, 36, 0, 0, 0 },
{ 912500000, 10000, false, 68, 1, 21, 1, 36, 0, 0, 0 },
{ 913500000, 10000, false, 68, 1, 23, 1, 36, 0, 0, 0 },
{ 914500000, 10000, false, 68, 1, 25, 1, 36, 0, 0, 0 },
{ 915500000, 10000, false, 68, 1, 27, 1, 36, 0, 0, 0 },
{ 916500000, 10000, false, 68, 1, 29, 1, 36, 0, 0, 0 },
{ 917500000, 10000, false, 68, 1, 31, 1, 36, 0, 0, 0 },
{ 918500000, 10000, false, 68, 1, 33, 1, 36, 0, 0, 0 },
{ 919500000, 10000, false, 68, 1, 35, 1, 36, 0, 0, 0 },
{ 920500000, 10000, false, 68, 1, 37, 1, 36, 0, 0, 0 },
{ 921500000, 10000, false, 68, 1, 39, 1, 36, 0, 0, 0 },
{ 922500000, 10000, false, 68, 1, 41, 1, 36, 0, 0, 0 },
{ 923500000, 10000, false, 68, 1, 43, 1, 36, 0, 0, 0 },
{ 924500000, 10000, false, 68, 1, 45, 1, 36, 0, 0, 0 },
{ 925500000, 10000, false, 68, 1, 47, 1, 36, 0, 0, 0 },
{ 926500000, 10000, false, 68, 1, 49, 1, 36, 0, 0, 0 },
{ 927500000, 10000, false, 68, 1, 51, 1, 36, 0, 0, 0 },
{ 903000000, 10000, false, 69, 2, 2, 2, 36, 0, 0, 0 }, /* Warning: regulatory requirements may not be met */
{ 905000000, 10000, false, 69, 2, 6, 2, 36, 0, 0, 0 },
{ 907000000, 10000, false, 69, 2, 10, 2, 36, 0, 0, 0 },
{ 909000000, 10000, false, 69, 2, 14, 2, 36, 0, 0, 0 },
{ 911000000, 10000, false, 69, 2, 18, 2, 36, 0, 0, 0 },
{ 913000000, 10000, false, 69, 2, 22, 2, 36, 0, 0, 0 },
{ 915000000, 10000, false, 69, 2, 26, 2, 36, 0, 0, 0 },
{ 917000000, 10000, false, 69, 2, 30, 2, 36, 0, 0, 0 },
{ 919000000, 10000, false, 69, 2, 34, 2, 36, 0, 0, 0 },
{ 921000000, 10000, false, 69, 2, 38, 2, 36, 0, 0, 0 },
{ 923000000, 10000, false, 69, 2, 42, 2, 36, 0, 0, 0 },
{ 925000000, 10000, false, 69, 2, 46, 2, 36, 0, 0, 0 },
{ 927000000, 10000, false, 69, 2, 50, 2, 36, 0, 0, 0 },
{ 906000000, 10000, false, 70, 3, 8, 4, 36, 0, 0, 0 },
{ 910000000, 10000, false, 70, 3, 16, 4, 36, 0, 0, 0 },
{ 914000000, 10000, false, 70, 3, 24, 4, 36, 0, 0, 0 },
{ 918000000, 10000, false, 70, 3, 32, 4, 36, 0, 0, 0 },
{ 922000000, 10000, false, 70, 3, 40, 4, 36, 0, 0, 0 },
{ 926000000, 10000, false, 70, 3, 48, 4, 36, 0, 0, 0 },
{ 908000000, 10000, false, 71, 4, 12, 8, 36, 0, 0, 0 },
{ 916000000, 10000, false, 71, 4, 28, 8, 36, 0, 0, 0 },
{ 924000000, 10000, false, 71, 4, 44, 8, 36, 0, 0, 0 },
};
/** Channel list structure for USA. */
static const struct mmwlan_s1g_channel_list s1g_channel_list_US = {
.country_code = "US",
.num_channels = (sizeof(s1g_channels_US)/sizeof(s1g_channels_US[0])),
.channels = s1g_channels_US,
};
/** Array of all channel list structs used for the regulatory database. */
static const struct mmwlan_s1g_channel_list *regulatory_db_domains[] = {
&s1g_channel_list_AU,
&s1g_channel_list_EU,
&s1g_channel_list_IN,
&s1g_channel_list_JP,
&s1g_channel_list_KR,
&s1g_channel_list_NZ,
&s1g_channel_list_SG,
&s1g_channel_list_US,
};
/** Regulatory database. */
static const struct mmwlan_regulatory_db regulatory_db = {
.num_domains = (sizeof(regulatory_db_domains)/sizeof(regulatory_db_domains[0])),
.domains = regulatory_db_domains,
};
/**
* Get a pointer to regulatory_db. This function isn't strictly necessary, since regulatory_db
* can be accessed directly, but will prevent the compiler from generated warnings about
* regulatory_db being unused.
*
* @return Reference to the regulatory database
*/
static inline const struct mmwlan_regulatory_db *get_regulatory_db(void)
{
return &regulatory_db;
}
/** \} */
Binary file not shown.
-14
View File
@@ -1,14 +0,0 @@
{
"name": "MorseWlan",
"version": "0.1.0",
"description": "Morse Micro mm-iot-esp32 SDK vendored for Meshtastic HaLow transport. Static morselib (Apache-2.0) + open-source shims.",
"frameworks": ["arduino", "espidf"],
"platforms": ["espressif32"],
"build": {
"srcDir": "src",
"srcFilter": ["+<*.c>"],
"includeDir": "include",
"libArchive": false,
"extraScript": "extra_script.py"
}
}
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
-148
View File
@@ -1,148 +0,0 @@
/*
* Copyright 2022-2024 Morse Micro
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
#include <stdint.h>
/*
* ----
* Endianness operations
* ----
*/
#ifdef __big_endian__
#define __BYTE_ORDER __BIG_ENDIAN
#else
#define __BYTE_ORDER __LITTLE_ENDIAN
#endif
#define bswap_16(x) __builtin_bswap16(x)
#define bswap_32(x) __builtin_bswap32(x)
#define INET_ADDRSTRLEN 16
#define INET6_ADDRSTRLEN 46
/* Protocol families. */
#define PF_INET 2 /* IP protocol family. */
#define PF_INET6 10 /* IP version 6. */
/* Address families. */
#define AF_INET PF_INET
#define AF_INET6 PF_INET6
/*
* ----
* Type definitions
* ----
*/
typedef signed char __s8;
typedef unsigned char __u8;
typedef signed short __s16;
typedef unsigned short __u16;
typedef signed int __s32;
typedef unsigned int __u32;
struct in_addr {
__u32 s_addr;
};
struct in6_addr {
union {
__u32 u32_addr[4];
__u8 u8_addr[16];
} un;
#define s6_addr un.u8_addr
};
/* Stub function declaration for inet_ntop which is called from write_ipv4_info
* function in robust_av.c. Since they are not used we will create a dummy
* function declarion here.
*/
const char *inet_ntop(int __af, const void *__cp, char *__buf, int __len);
/* Rename crypto functions to match symbol name mangling in morselib for avoidance of namespace
* collisions. */
#define aes_decrypt mmint_aes_decrypt
#define aes_decrypt_deinit mmint_aes_decrypt_deinit
#define aes_decrypt_init mmint_aes_decrypt_init
#define crypto_bignum_add mmint_crypto_bignum_add
#define crypto_bignum_addmod mmint_crypto_bignum_addmod
#define crypto_bignum_cmp mmint_crypto_bignum_cmp
#define crypto_bignum_deinit mmint_crypto_bignum_deinit
#define crypto_bignum_div mmint_crypto_bignum_div
#define crypto_bignum_exptmod mmint_crypto_bignum_exptmod
#define crypto_bignum_init mmint_crypto_bignum_init
#define crypto_bignum_init_set mmint_crypto_bignum_init_set
#define crypto_bignum_init_uint mmint_crypto_bignum_init_uint
#define crypto_bignum_inverse mmint_crypto_bignum_inverse
#define crypto_bignum_is_odd mmint_crypto_bignum_is_odd
#define crypto_bignum_is_one mmint_crypto_bignum_is_one
#define crypto_bignum_is_zero mmint_crypto_bignum_is_zero
#define crypto_bignum_legendre mmint_crypto_bignum_legendre
#define crypto_bignum_mod mmint_crypto_bignum_mod
#define crypto_bignum_mulmod mmint_crypto_bignum_mulmod
#define crypto_bignum_rand mmint_crypto_bignum_rand
#define crypto_bignum_rshift mmint_crypto_bignum_rshift
#define crypto_bignum_sqrmod mmint_crypto_bignum_sqrmod
#define crypto_bignum_sub mmint_crypto_bignum_sub
#define crypto_bignum_to_bin mmint_crypto_bignum_to_bin
#define crypto_ec_deinit mmint_crypto_ec_deinit
#define crypto_ec_get_a mmint_crypto_ec_get_a
#define crypto_ec_get_b mmint_crypto_ec_get_b
#define crypto_ec_get_generator mmint_crypto_ec_get_generator
#define crypto_ec_get_order mmint_crypto_ec_get_order
#define crypto_ec_get_prime mmint_crypto_ec_get_prime
#define crypto_ec_init mmint_crypto_ec_init
#define crypto_ec_order_len mmint_crypto_ec_order_len
#define crypto_ec_point_add mmint_crypto_ec_point_add
#define crypto_ec_point_cmp mmint_crypto_ec_point_cmp
#define crypto_ec_point_x mmint_crypto_ec_point_x
#define crypto_ec_point_compute_y_sqr mmint_crypto_ec_point_compute_y_sqr
#define crypto_ec_point_deinit mmint_crypto_ec_point_deinit
#define crypto_ec_point_from_bin mmint_crypto_ec_point_from_bin
#define crypto_ec_point_init mmint_crypto_ec_point_init
#define crypto_ec_point_invert mmint_crypto_ec_point_invert
#define crypto_ec_point_is_at_infinity mmint_crypto_ec_point_is_at_infinity
#define crypto_ec_point_is_on_curve mmint_crypto_ec_point_is_on_curve
#define crypto_ec_point_mul mmint_crypto_ec_point_mul
#define crypto_ec_point_to_bin mmint_crypto_ec_point_to_bin
#define crypto_ec_prime_len mmint_crypto_ec_prime_len
#define crypto_ec_prime_len_bits mmint_crypto_ec_prime_len_bits
#define crypto_ecdh_deinit mmint_crypto_ecdh_deinit
#define crypto_ecdh_get_pubkey mmint_crypto_ecdh_get_pubkey
#define crypto_ecdh_init mmint_crypto_ecdh_init
#define crypto_ecdh_init2 mmint_crypto_ecdh_init2
#define crypto_ecdh_set_peerkey mmint_crypto_ecdh_set_peerkey
#define crypto_ecdh_prime_len mmint_crypto_ecdh_prime_len
#define crypto_get_random mmint_crypto_get_random
#define crypto_unload mmint_crypto_unload
#define hmac_md5 mmint_hmac_md5
#define hmac_sha1 mmint_hmac_sha1
#define hmac_sha1_vector mmint_hmac_sha1_vector
#define hmac_sha256 mmint_hmac_sha256
#define hmac_sha256_vector mmint_hmac_sha256_vector
#define hmac_sha384 mmint_hmac_sha384
#define hmac_sha384_vector mmint_hmac_sha384_vector
#define hmac_sha512 mmint_hmac_sha512
#define hmac_sha512_vector mmint_hmac_sha512_vector
#define omac1_aes_vector mmint_omac1_aes_vector
#define omac1_aes_128 mmint_omac1_aes_128
#define pbkdf2_sha1 mmint_pbkdf2_sha1
#define sha1_prf mmint_sha1_prf
#define sha1_vector mmint_sha1_vector
#define sha256_prf mmint_sha256_prf
#define sha256_prf_bits mmint_sha256_prf_bits
#define sha256_vector mmint_sha256_vector
#define sha384_prf mmint_sha384_prf
#define sha384_vector mmint_sha384_vector
#define sha512_prf mmint_sha512_prf
#define sha512_vector mmint_sha512_vector
#define wpabuf_alloc mmint_wpabuf_alloc
#define wpabuf_alloc_copy mmint_wpabuf_alloc_copy
#define wpabuf_clear_free mmint_wpabuf_clear_free
#define wpabuf_put mmint_wpabuf_put
-27
View File
@@ -1,27 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Stubs for LWIP netif callback API that Arduino-ESP32's prebuilt LWIP omits
* (CONFIG_LWIP_NETIF_STATUS_CALLBACK / _LINK_CALLBACK are disabled in its
* sdkconfig, so the real functions are absent from the static library).
*
* mmipal calls these once during init to register a single callback for
* link-up / IP-configured events. With these stubs, the callback never fires —
* mmwlan_register_link_state_cb (driven by the radio firmware) remains the
* authoritative source of link state, so this only costs us LWIP-level
* notifications (e.g. "DHCP got an address"). HaLowInterface polls
* mmipal_get_ip_config when it needs to know.
*/
#include "lwip/netif.h"
void __attribute__((weak)) netif_set_link_callback(struct netif *netif, netif_status_callback_fn link_callback)
{
(void)netif;
(void)link_callback;
}
void __attribute__((weak)) netif_set_status_callback(struct netif *netif, netif_status_callback_fn status_callback)
{
(void)netif;
(void)status_callback;
}
#endif
Binary file not shown.
-216
View File
@@ -1,216 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*
*/
#include "mmbuf.h"
#include "mmosal.h"
#include "mmutils.h"
static const struct mmbuf_ops mmbuf_heap_ops = {.free_mmbuf = mmosal_free};
struct mmbuf *mmbuf_alloc_on_heap(uint32_t space_at_start, uint32_t space_at_end)
{
struct mmbuf *mmbuf;
uint8_t *buf;
uint32_t alloc_len = MM_FAST_ROUND_UP(sizeof(*mmbuf), 4) + MM_FAST_ROUND_UP(space_at_start + space_at_end, 4);
mmbuf = (struct mmbuf *)mmosal_malloc(alloc_len);
if (mmbuf == NULL) {
return NULL;
}
/* We zero the buffer as a defensive measure to reduce the likelihood of unintentionally
* leaking information. */
memset((uint8_t *)mmbuf, 0, alloc_len);
buf = ((uint8_t *)mmbuf) + MM_FAST_ROUND_UP(sizeof(*mmbuf), 4);
mmbuf_init(mmbuf, buf, MM_FAST_ROUND_UP(space_at_start + space_at_end, 4), space_at_start, &mmbuf_heap_ops);
return mmbuf;
}
struct mmbuf *mmbuf_make_copy_on_heap(struct mmbuf *original)
{
struct mmbuf *mmbuf;
uint8_t *buf;
uint32_t alloc_len = MM_FAST_ROUND_UP(sizeof(*original), 4) + original->buf_len;
mmbuf = (struct mmbuf *)mmosal_malloc(alloc_len);
if (mmbuf == NULL) {
return NULL;
}
buf = ((uint8_t *)mmbuf) + MM_FAST_ROUND_UP(sizeof(*mmbuf), 4);
mmbuf_init(mmbuf, buf, original->buf_len, original->start_offset, &mmbuf_heap_ops);
mmbuf->data_len = original->data_len;
if (original->data_len) {
memcpy(mmbuf_get_data_start(mmbuf), mmbuf_get_data_start(original), mmbuf_get_data_length(original));
}
return mmbuf;
}
void mmbuf_release(struct mmbuf *mmbuf)
{
if (mmbuf == NULL) {
return;
}
MMOSAL_ASSERT(mmbuf->ops != NULL && mmbuf->ops->free_mmbuf != NULL);
mmbuf->ops->free_mmbuf(mmbuf);
}
#ifdef MMBUF_SANITY
static void mmbuf_list_sanity_check(struct mmbuf_list *list)
{
unsigned cnt = 0;
struct mmbuf *walk;
struct mmbuf *prev = NULL;
for (walk = list->head; walk != NULL; walk = walk->next) {
cnt++;
prev = walk;
}
MMOSAL_ASSERT(cnt == list->len);
MMOSAL_ASSERT(prev == list->tail);
}
#endif
void mmbuf_list_prepend(struct mmbuf_list *list, struct mmbuf *mmbuf)
{
mmbuf->next = list->head;
list->head = mmbuf;
list->len++;
if (list->tail == NULL) {
list->tail = list->head;
}
#ifdef MMBUF_SANITY
mmbuf_list_sanity_check(list);
#endif
}
void mmbuf_list_append(struct mmbuf_list *list, struct mmbuf *mmbuf)
{
mmbuf->next = NULL;
if (list->head == NULL) {
list->head = mmbuf;
list->tail = mmbuf;
} else {
list->tail->next = mmbuf;
list->tail = mmbuf;
}
list->len++;
#ifdef MMBUF_SANITY
mmbuf_list_sanity_check(list);
#endif
}
static struct mmbuf *mmbuf_find_prev(struct mmbuf_list *list, struct mmbuf *mmbuf)
{
struct mmbuf *walk, *next;
for (walk = list->head, next = walk->next; next != NULL; walk = next, next = walk->next) {
if (next == mmbuf) {
return walk;
}
}
return NULL;
}
bool mmbuf_list_remove(struct mmbuf_list *list, struct mmbuf *mmbuf)
{
struct mmbuf *prev = NULL;
if (list->head == NULL) {
return false;
}
if (list->head == mmbuf) {
list->head = mmbuf->next;
} else {
prev = mmbuf_find_prev(list, mmbuf);
if (prev == NULL) {
return false;
}
prev->next = mmbuf->next;
}
if (list->tail == mmbuf) {
list->tail = prev;
}
list->len--;
mmbuf->next = NULL;
#ifdef MMBUF_SANITY
mmbuf_list_sanity_check(list);
#endif
return true;
}
struct mmbuf *mmbuf_list_dequeue(struct mmbuf_list *list)
{
if (list->head == NULL) {
return NULL;
} else {
struct mmbuf *mmbuf = list->head;
list->head = mmbuf->next;
list->len--;
if (list->tail == mmbuf) {
list->tail = NULL;
}
#ifdef MMBUF_SANITY
mmbuf_list_sanity_check(list);
#endif
if (mmbuf != NULL) {
mmbuf->next = NULL;
}
return mmbuf;
}
}
struct mmbuf *mmbuf_list_dequeue_tail(struct mmbuf_list *list)
{
if (list->tail == NULL) {
return NULL;
}
struct mmbuf *mmbuf = list->tail;
mmbuf_list_remove(list, mmbuf);
return mmbuf;
}
void mmbuf_list_clear(struct mmbuf_list *list)
{
struct mmbuf *walk;
struct mmbuf *next;
#ifdef MMBUF_SANITY
mmbuf_list_sanity_check(list);
#endif
if (list->head == NULL) {
return;
}
for (walk = list->head, next = walk->next; walk != NULL; walk = next, next = walk ? walk->next : NULL) {
mmbuf_release(walk);
}
list->len = 0;
list->head = NULL;
list->tail = NULL;
}
#endif /* USE_MM_IOT_ESP32 */
-457
View File
@@ -1,457 +0,0 @@
/*
* Copyright 2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @defgroup MMBUF Morse Micro Buffer (mmbuf) API
*
* This API provides support for buffers tailored towards packet-like data that has
* headers and trailers that are applied at subsequent layers.
*
* It is designed to support various backends for memory allocation. The default
* is allocation on the heap, but other methods could be used due to the flexible API.
*
* @{
*/
#pragma once
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "mmosal.h"
#ifdef __cplusplus
extern "C" {
#endif
struct mmbuf_ops;
/**
* Core mmbuf data structure.
*
* @note The contents of this data structure should never need to be accessed directly. Rather
* the various functions provided as part of this API should be used.
*
* @code
* +----------------------------------------------------------+
* | RESERVED | Data | RESERVED |
* +----------------------------------------------------------+
* ^ ^ ^ ^
* | | | |
* | |<-----------data_len--------->| |
* | start_offset |
* | |
* |<-----------------------buf_len-------------------------->|
* buf
* @endcode
*/
struct mmbuf {
/** The buffer where data is stored. */
uint8_t *buf;
/** Length of the buffer. */
uint32_t buf_len;
/** Offset where actual data starts in the buffer. */
uint32_t start_offset;
/** Length of actual data in the buffer. */
uint32_t data_len;
/** Reference to operations data structure for this mmbuf. */
const struct mmbuf_ops *ops;
/** Pointer that can be used to construct linked lists. */
struct mmbuf *volatile next;
};
/** Operations data structure for mmbuf. */
struct mmbuf_ops {
/** Free the given mmbuf. */
void (*free_mmbuf)(void *mmbuf);
};
/**
* Initialize an mmbuf header with the given values.
*
* @param mmbuf mmbuf to initialize.
* @param buf Pointer to buffer.
* @param buf_len Length of @p buf.
* @param data_start_offset Initial value for @c start_offset.
* @param ops Operations data structure.
*/
static inline void mmbuf_init(struct mmbuf *mmbuf, uint8_t *buf, uint32_t buf_len, uint32_t data_start_offset,
const struct mmbuf_ops *ops)
{
memset(mmbuf, 0, sizeof(*mmbuf));
mmbuf->buf = buf;
mmbuf->buf_len = buf_len;
mmbuf->start_offset = data_start_offset;
mmbuf->ops = ops;
}
/**
* Allocate a new mmbuf on the heap (using @ref mmosal_malloc()).
*
* @param space_at_start Amount of space to reserve at start of buffer.
* @param space_at_end Amount of space to reserve at end of buffer.
*
* @note @c start_offset will be set to @p space_at_start, and @c buf_len will be the sum
* of @p space_at_start and @p space_at_end (rounded up to a multiple of 4).
*
* @returns newly allocated mmbuf on success or @c NULL on failure.
*/
struct mmbuf *mmbuf_alloc_on_heap(uint32_t space_at_start, uint32_t space_at_end);
/**
* Make a copy of the given mmbuf. Note that regardless of the backend that allocated
* @p original, the newly allocated mmbuf will be allocated on the heap using
* @ref mmbuf_alloc_on_heap().
*
* @param original mmbuf to copy.
*
* @returns newly allocated mmbuf on success or @c NULL on failure.
*/
struct mmbuf *mmbuf_make_copy_on_heap(struct mmbuf *original);
/**
* Release a reference to the given mmbuf. If this was the last reference (@c addition_ref_cnt
* was 0) then the mmbuf will be freed using the appropriate op callback.
*
* @param mmbuf The mmbuf to release reference to. May be @c NULL.
*/
void mmbuf_release(struct mmbuf *mmbuf);
/**
* Gets a pointer to the start of the data in the mmbuf.
*
* @param mmbuf The mmbuf to operate on.
*
* @returns a pointer to the start of the data in the mmbuf.
*/
static inline uint8_t *mmbuf_get_data_start(struct mmbuf *mmbuf)
{
return mmbuf->buf + mmbuf->start_offset;
}
/**
* Gets a pointer to the end of the data in the mmbuf.
*
* @param mmbuf The mmbuf to operate on.
*
* @returns a pointer to the end of the data in the mmbuf.
*/
static inline uint8_t *mmbuf_get_data_end(struct mmbuf *mmbuf)
{
return mmbuf->buf + mmbuf->start_offset + mmbuf->data_len;
}
/**
* Gets the length of the data currently in the mmbuf.
*
* @param mmbuf The mmbuf to operate on.
*
* @returns the length of the data currently in the mmbuf (note that this is different from the
* length of the available buffer space).
*/
static inline uint32_t mmbuf_get_data_length(struct mmbuf *mmbuf)
{
return mmbuf->data_len;
}
/**
* Returns the amount of space available for prepending to the data in the buffer.
*
* @param mmbuf The mmbuf to operate on.
*
* @returns the available space in bytes.
*/
static inline uint32_t mmbuf_available_space_at_start(struct mmbuf *mmbuf)
{
return mmbuf->start_offset;
}
/**
* Returns the amount of space available for appending to the data in the buffer.
*
* @param mmbuf The mmbuf to operate on.
*
* @returns the available space in bytes.
*/
static inline uint32_t mmbuf_available_space_at_end(struct mmbuf *mmbuf)
{
return mmbuf->buf_len - (mmbuf->start_offset + mmbuf->data_len);
}
/**
* Reserves space immediately before the data currently in the given mmbuf and returns
* a pointer to this space.
*
* For a function that also copies data in, see @ref mmbuf_prepend_data().
*
* @warning @p len must be less than or equal to @ref mmbuf_available_space_at_start().
*
* @param mmbuf The mmbuf to operate on.
* @param len Length of data to be prepended.
*
* @returns a pointer to the place in the buffer where the data should be put.
*/
static inline uint8_t *mmbuf_prepend(struct mmbuf *mmbuf, uint32_t len)
{
MMOSAL_ASSERT(len <= mmbuf_available_space_at_start(mmbuf));
mmbuf->start_offset -= len;
mmbuf->data_len += len;
return mmbuf->buf + mmbuf->start_offset;
}
/**
* Prepends the given data to the data already in the mmbuf.
*
* @warning @p len must be less than or equal to @ref mmbuf_available_space_at_start().
*
* @warning The memory area pointed to by data must not overlap with the mmbuf data.
*
* @param mmbuf The mmbuf to operate on.
* @param data The data to be prepended.
* @param len Length of data to be prepended.
*/
static inline void mmbuf_prepend_data(struct mmbuf *mmbuf, const uint8_t *data, uint32_t len)
{
uint8_t *dest = mmbuf_prepend(mmbuf, len);
memcpy(dest, data, len);
}
/**
* Reserves space immediately after the data currently in the given mmbuf and returns
* a pointer to this space.
*
* For a function that also copies data in, see @ref mmbuf_append_data().
*
* @warning @p len must be less than or equal to @ref mmbuf_available_space_at_end().
*
* @param mmbuf The mmbuf to operate on.
* @param len Length of data to be append.
*
* @returns a pointer to the place in the buffer where the data should be put.
*/
static inline uint8_t *mmbuf_append(struct mmbuf *mmbuf, uint32_t len)
{
uint8_t *ret = mmbuf_get_data_end(mmbuf);
MMOSAL_ASSERT(len <= mmbuf_available_space_at_end(mmbuf));
mmbuf->data_len += len;
return ret;
}
/**
* Appends the given data to the data already in the mmbuf.
*
* @warning @p len must be less than or equal to @ref mmbuf_available_space_at_start().
*
* @param mmbuf The mmbuf to operate on.
* @param data The data to be prepended.
* @param len Length of data to be prepended.
*/
static inline void mmbuf_append_data(struct mmbuf *mmbuf, const uint8_t *data, uint32_t len)
{
uint8_t *dest = mmbuf_append(mmbuf, len);
memcpy(dest, data, len);
}
/**
* Remove data from the start of the mmbuf.
*
* @param mmbuf mmbuf to operate on.
* @param len Length of data to remove.
*
* @returns a pointer to the removed data or NULL if the mmbuf data length was less than @p len.
*/
static inline uint8_t *mmbuf_remove_from_start(struct mmbuf *mmbuf, uint32_t len)
{
uint8_t *ret;
if (mmbuf_get_data_length(mmbuf) < len) {
return NULL;
}
ret = mmbuf_get_data_start(mmbuf);
mmbuf->start_offset += len;
mmbuf->data_len -= len;
return ret;
}
/**
* Remove data from the end of the mmbuf.
*
* @param mmbuf mmbuf to operate on.
* @param len Length of data to remove.
*
* @returns a pointer to the removed data or NULL if the mmbuf data length was less than @p len.
*/
static inline uint8_t *mmbuf_remove_from_end(struct mmbuf *mmbuf, uint32_t len)
{
uint8_t *ret;
if (mmbuf_get_data_length(mmbuf) < len) {
return NULL;
}
ret = mmbuf_get_data_end(mmbuf) - len;
mmbuf->data_len -= len;
return ret;
}
/**
* Truncate the mmbuf data to the given length.
*
* @param mmbuf mmbuf to operate on.
* @param len New data length. (Must be less than or equal to the data length
* of the mmbuf).
*/
static inline void mmbuf_truncate(struct mmbuf *mmbuf, uint32_t len)
{
MMOSAL_ASSERT(len <= mmbuf->data_len);
mmbuf->data_len = len;
}
/* --------------------------------------------------------------------------------------------- */
/** Structure that can be used as the head of a linked list of mmbufs that counts its length. */
struct mmbuf_list {
/** First mmbuf in the list. */
struct mmbuf *volatile head;
/** Last mmbuf in the list. */
struct mmbuf *volatile tail;
/** Length of the list. */
volatile uint32_t len;
};
/** Static initializer for @ref mmbuf_list. */
#define MMBUF_LIST_INIT \
{ \
NULL, NULL, 0 \
}
/**
* Initialization function for @ref mmbuf_list, for cases where @c MMBUF_LIST_INIT
* cannot be used.
*
* @param list The mmbuf_list to init.
*/
static inline void mmbuf_list_init(struct mmbuf_list *list)
{
list->head = NULL;
list->tail = NULL;
list->len = 0;
}
/**
* Add an mmbuf to the start of an mmbuf list.
*
* @param list The list to prepend to.
* @param mmbuf The mmbuf to prepend.
*/
void mmbuf_list_prepend(struct mmbuf_list *list, struct mmbuf *mmbuf);
/**
* Add an mmbuf to the end of an mmbuf list.
*
* @param list The list to append to.
* @param mmbuf The mmbuf to append.
*/
void mmbuf_list_append(struct mmbuf_list *list, struct mmbuf *mmbuf);
/**
* Remove an mmbuf from an mmbuf list.
*
* @param list The list to remove from.
* @param mmbuf The mmbuf to remove.
*
* @returns @c true if the given @c mmbuf was present in @c list, else @c fase.
*/
bool mmbuf_list_remove(struct mmbuf_list *list, struct mmbuf *mmbuf);
/**
* Remove the mmbuf at the head of the list and return it.
*
* @param list The list to dequeue from.
*
* @returns the dequeued mmbuf, or @c NULL if the list is empty.
*/
struct mmbuf *mmbuf_list_dequeue(struct mmbuf_list *list);
/**
* Remove the mmbuf at the tail of the list and return it.
*
* @param list The list to dequeue from.
*
* @returns the dequeued mmbuf, or @c NULL if the list is empty.
*/
struct mmbuf *mmbuf_list_dequeue_tail(struct mmbuf_list *list);
/**
* Remove all mmbufs from the list and return as a linked list.
*
* @param list The list to dequeue from.
*
* @returns the dequeued mmbufs, or @c NULL if the list is empty.
*/
static inline struct mmbuf *mmbuf_list_dequeue_all(struct mmbuf_list *list)
{
struct mmbuf *head = list->head;
list->head = NULL;
list->tail = NULL;
list->len = 0;
return head;
}
/**
* Checks whether the given mmbuf list is empty.
*
* @param list The list to check.
*
* @returns @c true if the list is empty, else @c false.
*/
static inline bool mmbuf_list_is_empty(struct mmbuf_list *list)
{
return (list->head == NULL);
}
/**
* Returns the head of the mmbuf list.
*
* @param list The list to peek into.
*
* @returns the mmbuf at the head of the list.
*/
static inline struct mmbuf *mmbuf_list_peek(struct mmbuf_list *list)
{
return list->head;
}
/**
* Returns the tail of the mmbuf list.
*
* @param list The list to peek into.
*
* @returns the mmbuf at the tail of the list.
*/
static inline struct mmbuf *mmbuf_list_peek_tail(struct mmbuf_list *list)
{
return list->tail;
}
/**
* Free all the packets in the given list and reset the list to empty state.
*
* @param list The list to clear.
*/
void mmbuf_list_clear(struct mmbuf_list *list);
#ifdef __cplusplus
}
#endif
/** @} */
-50
View File
@@ -1,50 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "mmcrc.h"
/**
* Static table used for the table_driven implementation.
*/
static const uint16_t crc16_xmodem_lookup_table[256] = {
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce,
0xf1ef, 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c,
0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee,
0xf5cf, 0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738,
0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed, 0xe98e,
0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc,
0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae,
0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e,
0xe16f, 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c,
0xe37f, 0xf35e, 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e,
0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8,
0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e,
0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, 0xcb7d, 0xdb5c,
0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e,
0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1,
0x1ef0};
/**
* @note This implementation(with a few modifications) and corresponding table was generated using
* pycrc v0.9.2 (MIT) using the XMODEM model. https://pycrc.org/. The code generated by pycrc
* is not considered a substantial portion of the software, therefore the licence does not
* cover the generated code, and the author of pycrc will not claim any copyright on the
* generated code (https://pypi.org/project/pycrc/0.9.2/).
*/
uint16_t mmcrc_16_xmodem(uint16_t crc, const void *data, size_t data_len)
{
const uint8_t *d = (const uint8_t *)data;
while (data_len--) {
crc = (crc16_xmodem_lookup_table[((crc >> 8) ^ *d++)] ^ (crc << 8));
}
return crc;
}
#endif /* USE_MM_IOT_ESP32 */
-40
View File
@@ -1,40 +0,0 @@
/*
* Copyright 2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @defgroup MMCRC Morse Micro Cyclic Redundancy Check (mmcrc) API
*
* This API provides support for CRC algorithms used by Morse Micro code.
*
* @{
*/
#pragma once
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Compute the CRC-16 for the data buffer using the XMODEM model.
*
* @param crc Seed for CRC calc, zero in most cases this is zero (0). If chaining calls
* then this is the output from the previous invocation.
* @param data Pointer to the start of the data to calculate the crc over.
* @param data_len Length of the data array in bytes.
*
* @return Returns the CRC value.
*/
uint16_t mmcrc_16_xmodem(uint16_t crc, const void *data, size_t data_len);
#ifdef __cplusplus
}
#endif
/** @} */
-100
View File
@@ -1,100 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2021-2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "mmhal.h"
#include "mmosal.h"
#include "mmutils.h"
#include "mmwlan.h"
#include "driver/gpio.h"
#include "esp_random.h"
#include "esp_system.h"
#include "sdkconfig.h"
void mmhal_init(void)
{
/* We initialise the MM_RESET_N Pin here so that we can hold the MM6108 in reset regardless of
* whether the mmhal_wlan_init/deinit function have been called. This allows us to ensure the
* chip is in its lowest power state. You may want to revise this depending on your particular
* hardware configuration. */
gpio_config_t io_conf = {};
io_conf.intr_type = GPIO_INTR_DISABLE;
io_conf.mode = GPIO_MODE_OUTPUT;
io_conf.pin_bit_mask = (1 << CONFIG_MM_RESET_N);
io_conf.pull_down_en = 0;
io_conf.pull_up_en = 0;
gpio_config(&io_conf);
gpio_set_level(CONFIG_MM_RESET_N, 0);
/* Initialise the gpio ISR handler service. This allows per-pin GPIO interrupt handlers and is
* what is used to register all the wlan related interrupt. */
gpio_install_isr_service(0);
}
void mmhal_log_write(const uint8_t *data, size_t length)
{
while (length--) {
putc(*data++, stdout);
}
}
void mmhal_log_flush(void) {}
void mmhal_read_mac_addr(uint8_t *mac_addr)
{
/* We do not override the MAC address here. Therefore the driver will attempt to read it from
* the chip and failing that will assign a randomly generated address. */
(void)(mac_addr);
}
uint32_t mmhal_random_u32(uint32_t min, uint32_t max)
{
/* Note: the below implementation does not guarantee a uniform distribution. */
uint32_t random_value = esp_random();
if (min == 0 && max == UINT32_MAX) {
return random_value;
} else {
/* Calculate the range and shift required to fit within [min, max] */
return (random_value % (max - min + 1)) + min;
}
}
void mmhal_reset(void)
{
esp_restart();
while (1) {
}
}
void mmhal_set_deep_sleep_veto(uint8_t veto_id)
{
MM_UNUSED(veto_id);
}
void mmhal_clear_deep_sleep_veto(uint8_t veto_id)
{
MM_UNUSED(veto_id);
}
void mmhal_set_led(uint8_t led, uint8_t level)
{
MM_UNUSED(led);
MM_UNUSED(level);
}
bool mmhal_get_hardware_version(char *version_buffer, size_t version_buffer_length)
{
/* Note: You need to identify the correct hardware and or version
* here using whatever means available (GPIO's, version number stored in EEPROM, etc)
* and return the correct string here. */
return !mmosal_safer_strcpy(version_buffer, "MM-ESP32S3 V1.0", version_buffer_length);
}
#endif /* USE_MM_IOT_ESP32 */
-72
View File
@@ -1,72 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2021-2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "mmhal_wlan.h"
#include "mmosal.h"
/*
* ---------------------------------------------------------------------------------------------
* BCF Retrieval
* ---------------------------------------------------------------------------------------------
*/
/*
* The following implementation reads the BCF File from the config store.
*/
void mmhal_wlan_read_bcf_file(uint32_t offset, uint32_t requested_len, struct mmhal_robuf *robuf)
{
/** Points to the start of the BCF binary image. Defined as part of the Makefile */
extern uint8_t bcf_binary_start;
/** Points to the end of the BCF binary image. Defined as part of the Makefile */
extern uint8_t bcf_binary_end;
size_t bcf_len = &bcf_binary_end - &bcf_binary_start;
/* Initialise robuf */
robuf->buf = NULL;
robuf->len = 0;
robuf->free_arg = NULL;
robuf->free_cb = NULL;
/* Sanity check */
if (bcf_len < offset) {
printf("Detected an attempt to start reading off the end of the bcf file.\n");
return;
}
robuf->buf = (uint8_t *)&bcf_binary_start + offset;
robuf->len = bcf_len - offset;
robuf->len = (robuf->len < requested_len) ? robuf->len : requested_len;
}
/*
* ---------------------------------------------------------------------------------------------
* Firmware Retrieval
* ---------------------------------------------------------------------------------------------
*/
/** Points to the start of the firmware binary image. Defined as part of the Makefile */
extern uint8_t firmware_binary_start;
/** Points to the end of the firmware binary image. Defined as part of the Makefile */
extern uint8_t firmware_binary_end;
void mmhal_wlan_read_fw_file(uint32_t offset, uint32_t requested_len, struct mmhal_robuf *robuf)
{
uint32_t firmware_len = &firmware_binary_end - &firmware_binary_start;
if (offset > firmware_len) {
printf("Detected an attempt to start read off the end of the firmware file.\n");
robuf->buf = NULL;
return;
}
robuf->buf = (&firmware_binary_start + offset);
firmware_len -= offset;
robuf->len = (firmware_len < requested_len) ? firmware_len : requested_len;
}
#endif /* USE_MM_IOT_ESP32 */
-726
View File
@@ -1,726 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2021-2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "mmipal.h"
#include "mmnetif.h"
#include "mmosal.h"
#include "mmutils.h"
#include "mmwlan.h"
#include "lwip/api.h"
#include "lwip/autoip.h"
#include "lwip/def.h"
#include "lwip/dhcp.h"
#include "lwip/dhcp6.h"
#include "lwip/dns.h"
#include "lwip/etharp.h"
#include "lwip/ethip6.h"
#include "lwip/igmp.h"
#include "lwip/inet.h"
#include "lwip/ip4_frag.h"
#include "lwip/ip6_frag.h"
#include "lwip/ip_addr.h"
#include "lwip/mem.h"
#include "lwip/sockets.h"
#include "lwip/stats.h"
#include "lwip/tcp.h"
#include "lwip/tcpip.h"
#include "lwip/udp.h"
static struct mmipal_data {
struct netif lwip_mmnetif;
/** This stores the IPv4 link state for the IP stack. I.e., do we have an IP address or not. */
enum mmipal_link_state ip_link_state;
/** Flag requesting ARP response offload feature */
bool offload_arp_response;
/** ARP refresh offload interval in seconds */
uint32_t offload_arp_refresh_s;
bool dhcp_offload_init_complete;
/** The link status callback function that has been registered. */
mmipal_link_status_cb_fn_t link_status_callback;
/** The extended link status callback function that has been registered. */
mmipal_ext_link_status_cb_fn_t ext_link_status_callback;
/** Argument for the extended link status callback function that has been registered. */
void *ext_link_status_callback_arg;
#if LWIP_IPV4
enum mmipal_addr_mode ip4_mode;
#endif
#if LWIP_IPV6
enum mmipal_ip6_addr_mode ip6_mode;
#endif
} mmipal_data = {};
/** Getter function to retrieve the global mmipal data structure.*/
static inline struct mmipal_data *mmipal_get_data(void)
{
return &mmipal_data;
}
static void netif_status_callback(struct netif *netif);
#if LWIP_IPV4
/**
* DHCP Lease update callback, invoked when we get a new DHCP lease.
*
* @param lease_info The new DHCP lease.
*/
static void mmipal_dhcp_lease_updated(const struct mmwlan_dhcp_lease_info *lease_info, void *arg)
{
struct mmipal_data *data = mmipal_get_data();
ip4_addr_t ip_addr, netmask, gateway;
ip_addr_t dns_addr = ip_addr_any;
MM_UNUSED(arg);
data->dhcp_offload_init_complete = true;
ip4_addr_set_u32(&ip_addr, lease_info->ip4_addr);
ip4_addr_set_u32(&netmask, lease_info->mask4_addr);
ip4_addr_set_u32(&gateway, lease_info->gw4_addr);
ip4_addr_set_u32(ip_2_ip4(&dns_addr), lease_info->dns4_addr);
LOCK_TCPIP_CORE();
netif_set_addr(&data->lwip_mmnetif, &ip_addr, &netmask, &gateway);
dns_setserver(0, &dns_addr);
UNLOCK_TCPIP_CORE();
netif_status_callback(&data->lwip_mmnetif);
}
enum mmipal_status mmipal_get_ip_config(struct mmipal_ip_config *config)
{
struct mmipal_data *data = mmipal_get_data();
char *result;
config->mode = data->ip4_mode;
result = ipaddr_ntoa_r(&data->lwip_mmnetif.ip_addr, config->ip_addr, sizeof(config->ip_addr));
LWIP_ASSERT("IP buf too short", result != NULL);
result = ipaddr_ntoa_r(&data->lwip_mmnetif.netmask, config->netmask, sizeof(config->netmask));
LWIP_ASSERT("IP buf too short", result != NULL);
result = ipaddr_ntoa_r(&data->lwip_mmnetif.gw, config->gateway_addr, sizeof(config->gateway_addr));
LWIP_ASSERT("IP buf too short", result != NULL);
return MMIPAL_SUCCESS;
}
enum mmipal_status mmipal_set_ip_config(const struct mmipal_ip_config *config)
{
struct mmipal_data *data = mmipal_get_data();
int result;
ip_addr_t ip_addr = ip_addr_any;
ip_addr_t netmask = ip_addr_any;
ip_addr_t gateway = ip_addr_any;
struct netif *netif = &data->lwip_mmnetif;
if (config->mode != MMIPAL_DHCP_OFFLOAD && data->ip4_mode == MMIPAL_DHCP_OFFLOAD) {
printf("Once enabled DHCP offload mode cannot be disabled\n");
return MMIPAL_NOT_SUPPORTED;
}
switch (config->mode) {
case MMIPAL_DISABLED:
printf("%s mode not supported\n", "DISABLED");
return MMIPAL_INVALID_ARGUMENT;
case MMIPAL_AUTOIP:
printf("%s mode not supported\n", "AutoIP");
return MMIPAL_INVALID_ARGUMENT;
case MMIPAL_DHCP_OFFLOAD:
/* Currently we only support enabling DHCP offload when initialising */
printf("%s mode not supported\n", "DHCP_OFFLOAD");
return MMIPAL_INVALID_ARGUMENT;
case MMIPAL_STATIC:
result = ipaddr_aton(config->ip_addr, &ip_addr);
if (!result) {
return MMIPAL_INVALID_ARGUMENT;
}
result = ipaddr_aton(config->netmask, &netmask);
if (!result) {
return MMIPAL_INVALID_ARGUMENT;
}
result = ipaddr_aton(config->gateway_addr, &gateway);
if (!result) {
return MMIPAL_INVALID_ARGUMENT;
}
break;
case MMIPAL_DHCP:
break;
}
LOCK_TCPIP_CORE();
if (config->mode != MMIPAL_DHCP && data->ip4_mode == MMIPAL_DHCP) {
/* Stop DHCP if it was started earlier before setting static IP */
dhcp_stop(netif);
}
data->ip4_mode = config->mode;
netif_set_addr(netif, ip_2_ip4(&ip_addr), ip_2_ip4(&netmask), ip_2_ip4(&gateway));
if (data->ip4_mode == MMIPAL_DHCP) {
result = dhcp_start(netif);
LWIP_ASSERT("DHCP start error", result == ERR_OK);
}
UNLOCK_TCPIP_CORE();
return MMIPAL_SUCCESS;
}
enum mmipal_status mmipal_get_ip_broadcast_addr(mmipal_ip_addr_t broadcast_addr)
{
struct mmipal_data *data = mmipal_get_data();
char *result;
uint32_t ip_addr = ip_addr_get_ip4_u32(&data->lwip_mmnetif.ip_addr);
uint32_t netmask = ip_addr_get_ip4_u32(&data->lwip_mmnetif.netmask);
uint32_t broadcast_u32 = (ip_addr & netmask) | (0xffffffff & ~netmask);
ip_addr_t broadcast_ip_addr;
ip_addr_t *_broadcast_ip_addr = &broadcast_ip_addr;
ip_addr_set_ip4_u32(_broadcast_ip_addr, broadcast_u32);
result = ipaddr_ntoa_r(&broadcast_ip_addr, broadcast_addr, MMIPAL_IPADDR_STR_MAXLEN);
LWIP_ASSERT("IP buf too short", result != NULL);
return MMIPAL_SUCCESS;
}
#else
enum mmipal_status mmipal_get_ip_config(struct mmipal_ip_config *config)
{
MM_UNUSED(config);
LWIP_ASSERT("IPv4 not enabled", false);
return MMIPAL_NOT_SUPPORTED;
}
enum mmipal_status mmipal_set_ip_config(const struct mmipal_ip_config *config)
{
MM_UNUSED(config);
LWIP_ASSERT("IPv4 not enabled", false);
return MMIPAL_NOT_SUPPORTED;
}
enum mmipal_status mmipal_get_ip_broadcast_addr(mmipal_ip_addr_t broadcast_addr)
{
MM_UNUSED(broadcast_addr);
LWIP_ASSERT("IPv4 not enabled", false);
return MMIPAL_NOT_SUPPORTED;
}
#endif
#if LWIP_IPV6
enum mmipal_status mmipal_get_ip6_config(struct mmipal_ip6_config *config)
{
struct mmipal_data *data = mmipal_get_data();
unsigned ii;
struct netif *netif = &data->lwip_mmnetif;
if (config == NULL) {
return MMIPAL_INVALID_ARGUMENT;
}
config->ip6_mode = data->ip6_mode;
for (ii = 0; ii < LWIP_IPV6_NUM_ADDRESSES; ii++) {
char *result;
const ip_addr_t *addr = &ip6_addr_any;
if (ip6_addr_isvalid(netif_ip6_addr_state(netif, ii))) {
addr = &data->lwip_mmnetif.ip6_addr[ii];
}
result = ipaddr_ntoa_r(addr, config->ip6_addr[ii], sizeof(config->ip6_addr[ii]));
LWIP_ASSERT("IP buf too short", result != NULL);
}
return MMIPAL_SUCCESS;
}
enum mmipal_status mmipal_set_ip6_config(const struct mmipal_ip6_config *config)
{
struct mmipal_data *data = mmipal_get_data();
struct netif *netif = &data->lwip_mmnetif;
err_t result;
unsigned ii;
ip_addr_t ip6_addr[LWIP_IPV6_NUM_ADDRESSES];
for (ii = 0; ii < LWIP_IPV6_NUM_ADDRESSES; ii++) {
int result = ipaddr_aton(config->ip6_addr[ii], &ip6_addr[ii]);
if (!result) {
return MMIPAL_INVALID_ARGUMENT;
}
}
LOCK_TCPIP_CORE();
if (config->ip6_mode == MMIPAL_IP6_STATIC) {
if (data->ip6_mode != MMIPAL_IP6_STATIC) {
#if LWIP_IPV6_DHCP6
dhcp6_disable(netif);
#endif
netif_set_ip6_autoconfig_enabled(netif, 0);
data->ip6_mode = MMIPAL_IP6_STATIC;
}
if (!ip6_addr_islinklocal(ip_2_ip6(&(ip6_addr[0])))) {
printf("First address must be linklocal address (address start with fe80)\n");
}
for (ii = 0; ii < LWIP_IPV6_NUM_ADDRESSES; ii++) {
if (ip_addr_isany_val(ip6_addr[ii])) {
netif_ip6_addr_set(netif, ii, IP6_ADDR_ANY6);
netif_ip6_addr_set_state(netif, ii, IP6_ADDR_INVALID);
} else {
netif_ip6_addr_set(netif, ii, ip_2_ip6(&(ip6_addr[ii])));
netif_ip6_addr_set_state(netif, ii, IP6_ADDR_TENTATIVE);
netif_ip6_addr_set_valid_life(netif, ii, IP6_ADDR_LIFE_STATIC);
}
}
} else {
if (data->ip6_mode == MMIPAL_IP6_STATIC) {
for (ii = 0; ii < LWIP_IPV6_NUM_ADDRESSES; ii++) {
netif_ip6_addr_set(netif, ii, IP6_ADDR_ANY6);
netif_ip6_addr_set_state(netif, ii, IP6_ADDR_INVALID);
}
}
netif_set_ip6_autoconfig_enabled(netif, 1);
netif_create_ip6_linklocal_address(netif, 1);
data->ip6_mode = MMIPAL_IP6_AUTOCONFIG;
}
if (config->ip6_mode == MMIPAL_IP6_DHCP6_STATELESS)
#if LWIP_IPV6_DHCP6
{
result = dhcp6_enable_stateless(netif);
LWIP_ASSERT("Stateless DHCP6 start error", result == ERR_OK);
data->ip6_mode = MMIPAL_IP6_DHCP6_STATELESS;
} else {
dhcp6_disable(netif);
}
#else
{
printf("LWIP_IPV6_DHCP6 is not enabled\n");
}
#endif
UNLOCK_TCPIP_CORE();
return MMIPAL_SUCCESS;
}
#else
enum mmipal_status mmipal_get_ip6_config(struct mmipal_ip6_config *config)
{
MM_UNUSED(config);
LWIP_ASSERT("IPv6 not enabled", false);
return MMIPAL_NOT_SUPPORTED;
}
enum mmipal_status mmipal_set_ip6_config(const struct mmipal_ip6_config *config)
{
MM_UNUSED(config);
LWIP_ASSERT("IPv6 not enabled", false);
return MMIPAL_NOT_SUPPORTED;
}
#endif
static bool mmipal_link_status_check(struct netif *netif)
{
bool ip4_addr_check = true;
#if LWIP_IPV4
ip4_addr_check = !ip_addr_isany(&(netif->ip_addr));
#endif
return ip4_addr_check && netif_is_link_up(netif);
}
/** Handler for @c netif status callbacks from LWIP. */
static void netif_status_callback(struct netif *netif)
{
struct mmipal_data *data = mmipal_get_data();
enum mmipal_link_state new_link_state = MMIPAL_LINK_DOWN;
#if LWIP_IPV4
if (data->ip4_mode == MMIPAL_DHCP_OFFLOAD) {
/* Initialize DHCP offload on link up */
if (mmwlan_enable_dhcp_offload(mmipal_dhcp_lease_updated, NULL) != MMWLAN_SUCCESS) {
printf("Failed to enable DHCP offload!\n");
}
if (!data->dhcp_offload_init_complete) {
/* This just prevents a spurious 'Link Up' message on very first call */
return;
}
}
#endif
if (mmipal_link_status_check(netif)) {
new_link_state = MMIPAL_LINK_UP;
}
if (data->ip_link_state != new_link_state) {
data->ip_link_state = new_link_state;
if (data->link_status_callback || data->ext_link_status_callback) {
struct mmipal_link_status link_status;
memset(&link_status, 0, sizeof(link_status));
link_status.link_state = data->ip_link_state;
#if LWIP_IPV4
char *result = ipaddr_ntoa_r(&netif->ip_addr, link_status.ip_addr, sizeof(link_status.ip_addr));
LWIP_ASSERT("IP buf too short", result != NULL);
result = ipaddr_ntoa_r(&netif->netmask, link_status.netmask, sizeof(link_status.netmask));
LWIP_ASSERT("IP buf too short", result != NULL);
result = ipaddr_ntoa_r(&netif->gw, link_status.gateway, sizeof(link_status.gateway));
LWIP_ASSERT("IP buf too short", result != NULL);
if (data->ip_link_state == MMIPAL_LINK_UP) {
/* Check if ARP response offload feature is enabled */
if (data->offload_arp_response) {
mmwlan_enable_arp_response_offload(ip4_addr_get_u32(netif_ip4_addr(netif)));
}
/* Check if ARP refresh offload feature is enabled */
if (data->offload_arp_refresh_s > 0) {
mmwlan_enable_arp_refresh_offload(data->offload_arp_refresh_s, ip4_addr_get_u32(netif_ip4_gw(netif)), true);
}
}
#endif
if (data->link_status_callback) {
data->link_status_callback(&link_status);
}
if (data->ext_link_status_callback) {
data->ext_link_status_callback(&link_status, data->ext_link_status_callback_arg);
}
}
}
}
void mmipal_set_link_status_callback(mmipal_link_status_cb_fn_t fn)
{
struct mmipal_data *data = mmipal_get_data();
data->link_status_callback = fn;
}
void mmipal_set_ext_link_status_callback(mmipal_ext_link_status_cb_fn_t fn, void *arg)
{
struct mmipal_data *data = mmipal_get_data();
data->ext_link_status_callback = fn;
data->ext_link_status_callback_arg = arg;
}
static volatile bool tcpip_init_done = false;
struct lwip_init_args {
enum mmipal_addr_mode mode;
enum mmipal_ip6_addr_mode ip6_mode;
ip_addr_t ip_addr;
ip_addr_t netmask;
ip_addr_t gateway_addr;
ip_addr_t ip6_addr;
};
static void tcpip_init_done_handler(void *arg)
{
struct mmipal_data *data = mmipal_get_data();
struct netif *netif = &data->lwip_mmnetif;
struct lwip_init_args *args = (struct lwip_init_args *)arg;
netif_add_noaddr(netif, NULL, mmnetif_init, tcpip_input);
netif_set_default(netif);
netif_set_up(netif);
#if LWIP_IPV4
err_t result;
data->ip4_mode = args->mode;
if (args->mode == MMIPAL_DHCP) {
result = dhcp_start(netif);
LWIP_ASSERT("DHCP start error", result == ERR_OK);
} else if (args->mode == MMIPAL_STATIC) {
netif_set_addr(netif, ip_2_ip4(&(args->ip_addr)), ip_2_ip4(&(args->netmask)), ip_2_ip4(&(args->gateway_addr)));
}
#endif
netif_set_link_callback(netif, netif_status_callback);
netif_set_status_callback(netif, netif_status_callback);
#if LWIP_IPV6
err_t result6;
data->ip6_mode = args->ip6_mode;
if (args->ip6_mode == MMIPAL_IP6_STATIC) {
netif_ip6_addr_set(netif, 0, ip_2_ip6(&(args->ip6_addr)));
netif_ip6_addr_set_state(netif, 0, IP6_ADDR_TENTATIVE);
} else if (data->ip6_mode == MMIPAL_IP6_AUTOCONFIG) {
netif_set_ip6_autoconfig_enabled(netif, 1);
netif_create_ip6_linklocal_address(netif, 1);
} else if (data->ip6_mode == MMIPAL_IP6_DHCP6_STATELESS)
#if LWIP_IPV6_DHCP6
{
result6 = dhcp6_enable_stateless(netif);
LWIP_ASSERT("Stateless DHCP6 start error", result6 == ERR_OK);
}
#else
{
printf("LWIP_IPV6_DHCP6 is not enabled\n");
}
#endif
#endif
mmosal_free(args);
tcpip_init_done = true;
}
enum mmipal_status mmipal_init(const struct mmipal_init_args *args)
{
struct mmipal_data *data = mmipal_get_data();
enum mmipal_status status = MMIPAL_INVALID_ARGUMENT;
int result;
struct lwip_init_args *lwip_args = (struct lwip_init_args *)mmosal_malloc(sizeof(*lwip_args));
if (lwip_args == NULL) {
printf("malloc failure\n");
return MMIPAL_NO_MEM;
}
memset(lwip_args, 0, sizeof(*lwip_args));
lwip_args->mode = args->mode;
lwip_args->ip6_mode = args->ip6_mode;
data->link_status_callback = NULL;
data->offload_arp_response = args->offload_arp_response;
data->offload_arp_refresh_s = args->offload_arp_refresh_s;
/* Validate arguments */
#if LWIP_IPV4
switch (args->mode) {
case MMIPAL_DISABLED:
printf("%s mode not supported\n", "DISABLED");
goto exit;
case MMIPAL_DHCP_OFFLOAD:
case MMIPAL_STATIC:
result = ipaddr_aton(args->ip_addr, &lwip_args->ip_addr);
if (!result) {
goto exit;
}
result = ipaddr_aton(args->netmask, &lwip_args->netmask);
if (!result) {
goto exit;
}
result = ipaddr_aton(args->gateway_addr, &lwip_args->gateway_addr);
if (!result) {
goto exit;
}
if (ip_addr_isany_val(lwip_args->ip_addr)) {
printf("IP address not specified\n");
goto exit;
}
break;
case MMIPAL_DHCP:
if (LWIP_DHCP == 0) {
printf("DHCP not compiled in\n");
goto exit;
}
break;
case MMIPAL_AUTOIP:
printf("%s mode not supported\n", "AutoIP");
break;
}
#endif
#if LWIP_IPV6
switch (args->ip6_mode) {
case MMIPAL_IP6_DISABLED:
break;
case MMIPAL_IP6_STATIC:
result = ipaddr_aton(args->ip6_addr, &lwip_args->ip6_addr);
if (!result) {
goto exit;
}
if (ip_addr_isany_val(lwip_args->ip6_addr)) {
printf("IP address not specified\n");
goto exit;
}
break;
case MMIPAL_IP6_AUTOCONFIG:
if (LWIP_IPV6_AUTOCONFIG == 0) {
printf("AUTOCONFIG not compiled in\n");
goto exit;
}
break;
case MMIPAL_IP6_DHCP6_STATELESS:
if (LWIP_IPV6_DHCP6_STATELESS == 0) {
printf("DHCP6_STATELESS not compiled in\n");
goto exit;
}
break;
}
#endif
tcpip_init(tcpip_init_done_handler, lwip_args);
/* Block until initialisation is complete */
while (!tcpip_init_done) {
mmosal_task_sleep(10);
}
return MMIPAL_SUCCESS;
exit:
mmosal_free(lwip_args);
return status;
}
void mmipal_get_link_packet_counts(uint32_t *tx_packets, uint32_t *rx_packets)
{
#if LWIP_STATS
*tx_packets = lwip_stats.link.xmit;
*rx_packets = lwip_stats.link.recv;
#else
*tx_packets = 0;
*rx_packets = 0;
#endif
}
void mmipal_set_tx_qos_tid(uint8_t tid)
{
struct mmipal_data *data = mmipal_get_data();
bool ok = tcpip_init_done;
MMOSAL_ASSERT(ok);
mmnetif_set_tx_qos_tid(&data->lwip_mmnetif, tid);
}
enum mmipal_link_state mmipal_get_link_state(void)
{
struct mmipal_data *data = mmipal_get_data();
return data->ip_link_state;
}
static enum mmipal_status mmipal_get_local_addr_(ip_addr_t *local_addr, const ip_addr_t *dest_addr)
{
struct mmipal_data *data = mmipal_get_data();
struct netif *netif = &data->lwip_mmnetif;
#if LWIP_IPV6
if (IP_IS_V6(dest_addr)) {
const ip_addr_t *src_addr = ip6_select_source_address(netif, ip_2_ip6(dest_addr));
if (src_addr == NULL) {
return MMIPAL_NO_LINK;
}
ip_addr_copy(*local_addr, *src_addr);
return MMIPAL_SUCCESS;
} else {
MM_UNUSED(dest_addr);
}
#endif
#if LWIP_IPV4
if (IP_IS_V4(dest_addr)) {
ip_addr_copy(*local_addr, netif->ip_addr);
return MMIPAL_SUCCESS;
} else {
MM_UNUSED(dest_addr);
}
#endif
#if !LWIP_IPV4 && !LWIP_IPV6
MM_UNUSED(local_addr);
MM_UNUSED(dest_addr);
#endif
return MMIPAL_INVALID_ARGUMENT;
}
enum mmipal_status mmipal_get_local_addr(mmipal_ip_addr_t local_addr, const mmipal_ip_addr_t dest_addr)
{
ip_addr_t lwip_dest_addr;
ip_addr_t lwip_local_addr;
int ok;
enum mmipal_status status;
if (dest_addr == NULL) {
return MMIPAL_INVALID_ARGUMENT;
}
ok = ipaddr_aton(dest_addr, &lwip_dest_addr);
if (!ok) {
return MMIPAL_INVALID_ARGUMENT;
}
status = mmipal_get_local_addr_(&lwip_local_addr, &lwip_dest_addr);
if (status != 0) {
return status;
}
if (ipaddr_ntoa_r(&lwip_local_addr, local_addr, MMIPAL_IPADDR_STR_MAXLEN) == NULL) {
return MMIPAL_NO_MEM;
} else {
return MMIPAL_SUCCESS;
}
}
enum mmipal_status mmipal_set_dns_server(uint8_t index, const mmipal_ip_addr_t addr)
{
ip_addr_t dns_addr;
int ok;
if (index >= DNS_MAX_SERVERS) {
return MMIPAL_INVALID_ARGUMENT;
}
ok = ipaddr_aton(addr, &dns_addr);
if (!ok) {
return MMIPAL_INVALID_ARGUMENT;
}
dns_setserver(index, &dns_addr);
return MMIPAL_SUCCESS;
}
enum mmipal_status mmipal_get_dns_server(uint8_t index, mmipal_ip_addr_t addr)
{
const ip_addr_t *dns_addr;
if (index >= DNS_MAX_SERVERS) {
return MMIPAL_INVALID_ARGUMENT;
}
dns_addr = dns_getserver(index);
#if LWIP_IPV4
/* dns_getserver() returns ip_addr_any if no address configured. */
if (!memcmp(dns_addr, &ip_addr_any, sizeof(*dns_addr))) {
addr[0] = '\0';
return MMIPAL_SUCCESS;
}
#endif
if (ipaddr_ntoa_r(dns_addr, addr, MMIPAL_IPADDR_STR_MAXLEN) == NULL) {
return MMIPAL_NO_MEM;
} else {
return MMIPAL_SUCCESS;
}
}
#endif
-218
View File
@@ -1,218 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2021-2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "mmnetif.h"
#include "mmosal.h"
#include "mmwlan.h"
#include "lwip/etharp.h"
#include "lwip/ethip6.h"
#include "lwip/tcpip.h"
#if LWIP_SNMP
#include "lwip/snmp.h"
#endif
struct netif_state {
volatile uint8_t tx_qos_tid;
};
static struct netif_state *get_netif_state(struct netif *netif)
{
MMOSAL_ASSERT(netif->state != NULL);
return (struct netif_state *)netif->state;
}
/** pbuf wrapper around an mmpkt. */
struct mmpkt_pbuf_wrapper {
struct pbuf_custom p;
struct mmpkt *pkt;
struct mmpktview *pktview;
};
LWIP_MEMPOOL_DECLARE(RX_POOL, MMPKTMEM_RX_POOL_N_BLOCKS, sizeof(struct mmpkt_pbuf_wrapper), "mmpkt_rx");
static void mmpkt_pbuf_wrapper_free(struct pbuf *p)
{
struct mmpkt_pbuf_wrapper *pbuf = (struct mmpkt_pbuf_wrapper *)p;
if (p == NULL) {
return;
}
mmpkt_close(&pbuf->pktview);
mmpkt_release(pbuf->pkt);
LWIP_MEMPOOL_FREE(RX_POOL, pbuf);
}
static void mmnetif_rx(struct mmpkt *rxpkt, void *arg)
{
struct netif *netif = (struct netif *)arg;
LWIP_ASSERT("arg NULL", netif != NULL);
LWIP_DEBUGF(NETIF_DEBUG, ("mmnetif: packet received\n"));
struct mmpkt_pbuf_wrapper *pbuf = (struct mmpkt_pbuf_wrapper *)LWIP_MEMPOOL_ALLOC(RX_POOL);
if (pbuf != NULL) {
struct pbuf *p;
pbuf->p.custom_free_function = mmpkt_pbuf_wrapper_free;
pbuf->pkt = rxpkt;
pbuf->pktview = mmpkt_open(pbuf->pkt);
p = pbuf_alloced_custom(PBUF_RAW, mmpkt_get_data_length(pbuf->pktview), PBUF_REF, &pbuf->p,
mmpkt_get_data_start(pbuf->pktview), mmpkt_get_data_length(pbuf->pktview));
int ret = tcpip_input(p, netif);
if (ret == ERR_OK) {
LINK_STATS_INC(link.recv);
} else {
LWIP_DEBUGF(NETIF_DEBUG, ("mmnetif: input error\n"));
pbuf_free(p);
LINK_STATS_INC(link.memerr);
LINK_STATS_INC(link.drop);
}
} else {
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mmnetif: alloc error\n"));
LINK_STATS_INC(link.memerr);
mmpkt_release(rxpkt);
}
}
static void mmnetif_link_state(enum mmwlan_link_state link_state, void *arg)
{
struct netif *netif = (struct netif *)arg;
LWIP_ASSERT("arg NULL", netif != NULL);
LOCK_TCPIP_CORE();
if (link_state == MMWLAN_LINK_DOWN) {
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_LEVEL_ALL, ("mmnetif: link down\n"));
/* Note: we cast netif_set_link_down to tcpip_callback_fn since the tcpip_callback_fn
* has a "void *" parameter and netif_set_link_down has "struct netif *". */
err_t err = tcpip_callback_with_block((tcpip_callback_fn)netif_set_link_down, netif, 0);
LWIP_ASSERT("sched callback failed", err == ERR_OK);
} else {
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_LEVEL_ALL, ("mmnetif: link up\n"));
/* Note: we cast netif_set_link_down to tcpip_callback_fn since the tcpip_callback_fn
* has a "void *" parameter and netif_set_link_down has "struct netif *". */
err_t err = tcpip_callback_with_block((tcpip_callback_fn)netif_set_link_up, netif, 0);
LWIP_ASSERT("sched callback failed", err == ERR_OK);
}
UNLOCK_TCPIP_CORE();
}
static err_t mmnetif_tx(struct netif *netif, struct pbuf *p)
{
struct mmpkt *pkt;
struct mmpktview *pktview;
enum mmwlan_status status;
struct pbuf *walk;
struct mmwlan_tx_metadata metadata = {
.tid = get_netif_state(netif)->tx_qos_tid,
};
status = mmwlan_tx_wait_until_ready(1000);
if (status != MMWLAN_SUCCESS) {
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mmnetif: transmit blocked\n"));
LINK_STATS_INC(link.drop);
return ERR_BUF;
}
pkt = mmwlan_alloc_mmpkt_for_tx(p->tot_len, metadata.tid);
if (pkt == NULL) {
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mmnetif: allocation failure\n"));
LINK_STATS_INC(link.memerr);
return ERR_MEM;
}
pktview = mmpkt_open(pkt);
for (walk = p; walk != NULL; walk = walk->next) {
mmpkt_append_data(pktview, (const uint8_t *)walk->payload, walk->len);
}
mmpkt_close(&pktview);
status = mmwlan_tx_pkt(pkt, &metadata);
if (status != MMWLAN_SUCCESS) {
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mmnetif: error sending packet\n"));
LINK_STATS_INC(link.drop);
return ERR_BUF;
}
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_LEVEL_ALL, ("mmnetif: packet sent\n"));
LINK_STATS_INC(link.xmit);
return ERR_OK;
}
err_t mmnetif_init(struct netif *netif)
{
static bool initialised = false;
if (initialised) {
return ERR_IF;
}
LWIP_MEMPOOL_INIT(RX_POOL);
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_LEVEL_ALL, ("mmnetif: initialising mmnetif\n"));
#if LWIP_SNMP
NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 1000000UL);
#endif
enum mmwlan_status status;
/* Boot the transceiver so that we can read the MAC address. */
struct mmwlan_boot_args boot_args = MMWLAN_BOOT_ARGS_INIT;
status = mmwlan_boot(&boot_args);
if (status != MMWLAN_SUCCESS) {
LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mmwlan_boot failed with code %d\n", status));
}
MMOSAL_ASSERT(status == MMWLAN_SUCCESS);
/* Set MAC hardware address */
netif->hwaddr_len = MMWLAN_MAC_ADDR_LEN;
status = mmwlan_get_mac_addr(netif->hwaddr);
MMOSAL_ASSERT(status == MMWLAN_SUCCESS);
netif->mtu = 1500;
#if LWIP_IPV4 && !LWIP_IPV6
netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP;
#else
netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP | NETIF_FLAG_MLD6;
#endif
netif->state = NULL;
netif->name[0] = 'M';
netif->name[1] = 'M';
#if LWIP_IPV4
netif->output = etharp_output;
#endif
#if LWIP_IPV6
netif->output_ip6 = ethip6_output;
#endif
netif->linkoutput = mmnetif_tx;
struct netif_state *state = (struct netif_state *)mmosal_malloc(sizeof(*state));
MMOSAL_ASSERT(state != NULL);
state->tx_qos_tid = MMWLAN_TX_DEFAULT_QOS_TID;
netif->state = state;
status = mmwlan_register_rx_pkt_cb(mmnetif_rx, netif);
MMOSAL_ASSERT(status == MMWLAN_SUCCESS);
status = mmwlan_register_link_state_cb(mmnetif_link_state, netif);
MMOSAL_ASSERT(status == MMWLAN_SUCCESS);
printf("Morse LwIP interface initialised. MAC address %02x:%02x:%02x:%02x:%02x:%02x\n", netif->hwaddr[0], netif->hwaddr[1],
netif->hwaddr[2], netif->hwaddr[3], netif->hwaddr[4], netif->hwaddr[5]);
initialised = true;
return ERR_OK;
}
void mmnetif_set_tx_qos_tid(struct netif *netif, uint8_t tid)
{
MMOSAL_ASSERT(tid <= MMWLAN_MAX_QOS_TID);
get_netif_state(netif)->tx_qos_tid = tid;
}
#endif
-29
View File
@@ -1,29 +0,0 @@
/*
* Copyright 2021-2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include "lwip/err.h"
#include "lwip/netif.h"
#ifdef __cplusplus
extern "C" {
#endif
/** Initializer for the Morse Micro network interface */
err_t mmnetif_init(struct netif *netif);
/**
* Configure the QoS TID for the @c netif. QoS data will be sent using this TID.
*
* @param netif The @c netif to configure.
* @param tid The TID value to set.
*/
void mmnetif_set_tx_qos_tid(struct netif *netif, uint8_t tid);
#ifdef __cplusplus
}
#endif
@@ -1,563 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2021-2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "esp_debug_helpers.h"
#include "esp_private/startup_internal.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/semphr.h"
#include "freertos/task.h"
#include "freertos/timers.h"
#include "rom/ets_sys.h"
#include "mmhal.h"
#include "mmosal.h"
/* --------------------------------------------------------------------------------------------- */
/** Maximum number of failure records to store (must be a power of 2). */
#define MAX_FAILURE_RECORDS 4
/** Fast implementation of _x % _m where _m is a power of 2. */
#define FAST_MOD(_x, _m) ((_x) & ((_m)-1))
/** Duration to delay before resetting the device on assert. */
#define DELAY_BEFORE_RESET_MS 1000
/** Data structure for assertion information to be preserved. */
struct mmosal_preserved_failure_info {
/** Magic number, to check if the info is valid. */
uint32_t magic;
/** Number of failures recorded. */
uint32_t failure_count;
/** Number of most recently displayed failure. */
uint32_t displayed_failure_count;
/** Preserved information from the most recent failure(s). */
struct mmosal_failure_info info[MAX_FAILURE_RECORDS];
};
/** Magic number to put in @c mmosal_assert_info.magic to indicate that the assertion info
* is valid. */
#define ASSERT_INFO_MAGIC (0xabcd1234)
/* Persistent assertion info. Linker script should put this into memory that is not
* zeroed on boot. Be careful to update linker script if renaming. */
struct mmosal_preserved_failure_info preserved_failure_info __attribute__((section(".noinit")));
void mmosal_log_failure_info(const struct mmosal_failure_info *info)
{
uint32_t record_num;
if (preserved_failure_info.magic != ASSERT_INFO_MAGIC) {
preserved_failure_info.failure_count = 0;
preserved_failure_info.displayed_failure_count = 0;
}
preserved_failure_info.magic = ASSERT_INFO_MAGIC;
record_num = FAST_MOD(preserved_failure_info.failure_count, MAX_FAILURE_RECORDS);
preserved_failure_info.failure_count++;
memcpy(&preserved_failure_info.info[record_num], info, sizeof(*info));
}
static void mmosal_dump_failure_info(void)
{
unsigned first_failure_num = preserved_failure_info.displayed_failure_count;
unsigned new_failure_count = preserved_failure_info.failure_count - preserved_failure_info.displayed_failure_count;
unsigned failure_offset;
if (new_failure_count >= MAX_FAILURE_RECORDS) {
first_failure_num = FAST_MOD(preserved_failure_info.failure_count, MAX_FAILURE_RECORDS);
new_failure_count = MAX_FAILURE_RECORDS;
}
for (failure_offset = 0; failure_offset < new_failure_count; failure_offset++) {
unsigned ii;
unsigned idx = FAST_MOD(first_failure_num + failure_offset, MAX_FAILURE_RECORDS);
struct mmosal_failure_info *info = &preserved_failure_info.info[idx];
ets_printf("Failure %u logged at pc 0x%08lx, lr 0x%08lx, line %ld in %08lx\n", first_failure_num + failure_offset,
info->pc, info->lr, info->line, info->fileid);
for (ii = 0; ii < sizeof(info->platform_info) / sizeof(info->platform_info[0]); ii++) {
ets_printf(" 0x%08lx\n", info->platform_info[ii]);
}
}
preserved_failure_info.displayed_failure_count = preserved_failure_info.failure_count;
}
void mmosal_impl_assert(void)
{
ets_printf("MMOSAL Assert, CPU %d (current core) backtrace", xPortGetCoreID());
(void)esp_backtrace_print(100);
#ifdef HALT_ON_ASSERT
if (preserved_failure_info.magic == ASSERT_INFO_MAGIC) {
mmosal_dump_failure_info();
}
mmosal_disable_interrupts();
mmhal_log_flush();
MMPORT_BREAKPOINT();
#else
mmosal_task_sleep(DELAY_BEFORE_RESET_MS);
mmhal_reset();
#endif
while (1) {
}
}
/* Function to be called as part of the secondary initialization. See [System
* Initialization](https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-guides/startup.html#system-initialization)
* for more information. */
ESP_SYSTEM_INIT_FN(mmosal_dump_failure_info, BIT(0), 999)
{
if (preserved_failure_info.magic == ASSERT_INFO_MAGIC) {
mmosal_dump_failure_info();
}
return ESP_OK;
}
/* --------------------------------------------------------------------------------------------- */
void *mmosal_malloc_(size_t size)
{
return pvPortMalloc(size);
}
#ifdef MMOSAL_TRACK_ALLOCATIONS
void *mmosal_malloc_dbg(size_t size, const char *name, unsigned line_number)
{
return pvPortMalloc_dbg(size, name, line_number);
}
#else
void *mmosal_malloc_dbg(size_t size, const char *name, unsigned line_number)
{
(void)name;
(void)line_number;
return pvPortMalloc(size);
}
#endif
void mmosal_free(void *p)
{
vPortFree(p);
}
void *mmosal_realloc(void *ptr, size_t size)
{
return realloc(ptr, size);
}
void *mmosal_calloc(size_t nitems, size_t size)
{
void *ptr = pvPortMalloc(nitems * size);
if (ptr == NULL) {
return NULL;
}
memset(ptr, 0, nitems * size);
return ptr;
}
/* --------------------------------------------------------------------------------------------- */
struct mmosal_task_arg {
mmosal_task_fn_t task_fn;
void *task_fn_arg;
};
void mmosal_task_main(void *arg)
{
struct mmosal_task_arg task_arg = *(struct mmosal_task_arg *)arg;
mmosal_free(arg);
task_arg.task_fn(task_arg.task_fn_arg);
mmosal_task_delete(NULL);
}
struct mmosal_task *mmosal_task_create(mmosal_task_fn_t task_fn, void *argument, enum mmosal_task_priority priority,
unsigned stack_size_u32, const char *name)
{
TaskHandle_t handle;
UBaseType_t freertos_priority = tskIDLE_PRIORITY + priority;
struct mmosal_task_arg *task_arg = (struct mmosal_task_arg *)mmosal_malloc(sizeof(*task_arg));
if (task_arg == NULL) {
return NULL;
}
task_arg->task_fn = task_fn;
task_arg->task_fn_arg = argument;
BaseType_t result = xTaskCreate(mmosal_task_main, name, stack_size_u32 * 4, task_arg, freertos_priority, &handle);
if (result == pdFAIL) {
mmosal_free(task_arg);
return NULL;
}
return (struct mmosal_task *)handle;
}
void mmosal_task_delete(struct mmosal_task *task)
{
vTaskDelete((TaskHandle_t)task);
}
/*
* Warning: this function should not be used since eTaskGetState() is not a reliable
* means of testing whether a task has completed.
*
* This function will be removed in future.
*/
void mmosal_task_join(struct mmosal_task *task)
{
while (eTaskGetState((TaskHandle_t)task) != eDeleted) {
mmosal_task_sleep(10);
}
}
struct mmosal_task *mmosal_task_get_active(void)
{
return (struct mmosal_task *)xTaskGetCurrentTaskHandle();
}
void mmosal_task_yield(void)
{
taskYIELD();
}
void mmosal_task_sleep(uint32_t duration_ms)
{
vTaskDelay(duration_ms / portTICK_PERIOD_MS);
}
static portMUX_TYPE task_spinlock = portMUX_INITIALIZER_UNLOCKED;
void mmosal_task_enter_critical(void)
{
taskENTER_CRITICAL(&task_spinlock);
}
void mmosal_task_exit_critical(void)
{
taskEXIT_CRITICAL(&task_spinlock);
}
void mmosal_disable_interrupts(void)
{
taskDISABLE_INTERRUPTS();
}
void mmosal_enable_interrupts(void)
{
taskENABLE_INTERRUPTS();
}
const char *mmosal_task_name(void)
{
TaskHandle_t t = xTaskGetCurrentTaskHandle();
return pcTaskGetName(t);
}
bool mmosal_task_wait_for_notification(uint32_t timeout_ms)
{
TickType_t wait = portMAX_DELAY;
if (timeout_ms < UINT32_MAX) {
wait = pdMS_TO_TICKS(timeout_ms);
}
uint32_t ret = ulTaskNotifyTake(pdTRUE, /* Act as binary semaphore */
wait);
return (ret != 0);
}
void mmosal_task_notify(struct mmosal_task *task)
{
xTaskNotifyGive((TaskHandle_t)task);
}
void mmosal_task_notify_from_isr(struct mmosal_task *task)
{
BaseType_t higher_priority_task_woken = pdFALSE;
vTaskNotifyGiveFromISR((TaskHandle_t)task, &higher_priority_task_woken);
portYIELD_FROM_ISR(higher_priority_task_woken);
}
/* --------------------------------------------------------------------------------------------- */
struct mmosal_mutex *mmosal_mutex_create(const char *name)
{
struct mmosal_mutex *mutex = (struct mmosal_mutex *)xSemaphoreCreateMutex();
#if (configUSE_TRACE_FACILITY == 1) && defined(ENABLE_TRACEALYZER) && ENABLE_TRACEALYZER
if (name != NULL) {
vTraceSetMutexName(mutex, name);
}
#else
(void)name;
#endif
return mutex;
}
void mmosal_mutex_delete(struct mmosal_mutex *mutex)
{
if (mutex != NULL) {
vQueueDelete((SemaphoreHandle_t)mutex);
}
}
bool mmosal_mutex_get(struct mmosal_mutex *mutex, uint32_t timeout_ms)
{
uint32_t timeout_ticks = portMAX_DELAY;
if (timeout_ms != UINT32_MAX) {
timeout_ticks = timeout_ms / portTICK_PERIOD_MS;
}
return (xSemaphoreTake((SemaphoreHandle_t)mutex, timeout_ticks) == pdPASS);
}
bool mmosal_mutex_release(struct mmosal_mutex *mutex)
{
return (xSemaphoreGive((SemaphoreHandle_t)mutex) == pdPASS);
}
bool mmosal_mutex_is_held_by_active_task(struct mmosal_mutex *mutex)
{
return xSemaphoreGetMutexHolder((SemaphoreHandle_t)mutex) == xTaskGetCurrentTaskHandle();
}
/* --------------------------------------------------------------------------------------------- */
struct mmosal_sem *mmosal_sem_create(unsigned max_count, unsigned initial_count, const char *name)
{
struct mmosal_sem *sem = (struct mmosal_sem *)xSemaphoreCreateCounting(max_count, initial_count);
#if (configUSE_TRACE_FACILITY == 1) && defined(ENABLE_TRACEALYZER) && ENABLE_TRACEALYZER
if (name != NULL) {
vTraceSetSemaphoreName(sem, name);
}
#else
(void)name;
#endif
return sem;
}
void mmosal_sem_delete(struct mmosal_sem *sem)
{
vQueueDelete((SemaphoreHandle_t)sem);
}
bool mmosal_sem_give(struct mmosal_sem *sem)
{
return xSemaphoreGive((SemaphoreHandle_t)sem);
}
bool mmosal_sem_give_from_isr(struct mmosal_sem *sem)
{
BaseType_t task_woken = false;
BaseType_t ret = xSemaphoreGiveFromISR((SemaphoreHandle_t)sem, &task_woken);
if (ret == pdPASS) {
portYIELD_FROM_ISR(task_woken);
return true;
} else {
return false;
}
}
bool mmosal_sem_wait(struct mmosal_sem *sem, uint32_t timeout_ms)
{
uint32_t timeout_ticks = portMAX_DELAY;
if (timeout_ms != UINT32_MAX) {
timeout_ticks = timeout_ms / portTICK_PERIOD_MS;
}
return (xSemaphoreTake((SemaphoreHandle_t)sem, timeout_ticks) == pdPASS);
}
uint32_t mmosal_sem_get_count(struct mmosal_sem *sem)
{
return uxSemaphoreGetCount((SemaphoreHandle_t)sem);
}
/* --------------------------------------------------------------------------------------------- */
struct mmosal_semb *mmosal_semb_create(const char *name)
{
struct mmosal_semb *semb = (struct mmosal_semb *)xSemaphoreCreateBinary();
#if (configUSE_TRACE_FACILITY == 1) && defined(ENABLE_TRACEALYZER) && ENABLE_TRACEALYZER
if (name != NULL) {
vTraceSetSemaphoreName(semb, name);
}
#else
(void)name;
#endif
return semb;
}
void mmosal_semb_delete(struct mmosal_semb *semb)
{
vQueueDelete((SemaphoreHandle_t)semb);
}
bool mmosal_semb_give(struct mmosal_semb *semb)
{
return (xSemaphoreGive((SemaphoreHandle_t)semb) == pdPASS);
}
bool mmosal_semb_give_from_isr(struct mmosal_semb *semb)
{
BaseType_t task_woken = pdFALSE;
BaseType_t ret = xSemaphoreGiveFromISR((SemaphoreHandle_t)semb, &task_woken);
if (ret == pdPASS) {
portYIELD_FROM_ISR(task_woken);
return true;
} else {
return false;
}
}
bool mmosal_semb_wait(struct mmosal_semb *semb, uint32_t timeout_ms)
{
uint32_t timeout_ticks = portMAX_DELAY;
if (timeout_ms != UINT32_MAX) {
timeout_ticks = timeout_ms / portTICK_PERIOD_MS;
}
return (xSemaphoreTake((SemaphoreHandle_t)semb, timeout_ticks) == pdPASS);
}
/* --------------------------------------------------------------------------------------------- */
struct mmosal_queue *mmosal_queue_create(size_t num_items, size_t item_size, const char *name)
{
struct mmosal_queue *queue = (struct mmosal_queue *)xQueueCreate(num_items, item_size);
#if (configUSE_TRACE_FACILITY == 1) && defined(ENABLE_TRACEALYZER) && ENABLE_TRACEALYZER
if (name != NULL) {
vTraceSetQueueName(queue, name);
}
#else
(void)name;
#endif
return queue;
}
void mmosal_queue_delete(struct mmosal_queue *queue)
{
vQueueDelete((SemaphoreHandle_t)queue);
}
bool mmosal_queue_pop(struct mmosal_queue *queue, void *item, uint32_t timeout_ms)
{
uint32_t timeout_ticks = portMAX_DELAY;
if (timeout_ms != UINT32_MAX) {
timeout_ticks = timeout_ms / portTICK_PERIOD_MS;
}
return (xQueueReceive((SemaphoreHandle_t)queue, item, timeout_ticks) == pdPASS);
}
bool mmosal_queue_push(struct mmosal_queue *queue, const void *item, uint32_t timeout_ms)
{
uint32_t timeout_ticks = portMAX_DELAY;
if (timeout_ms != UINT32_MAX) {
timeout_ticks = timeout_ms / portTICK_PERIOD_MS;
}
return (xQueueSendToBack((SemaphoreHandle_t)queue, item, timeout_ticks) == pdPASS);
}
bool mmosal_queue_pop_from_isr(struct mmosal_queue *queue, void *item)
{
BaseType_t task_woken = pdFALSE;
if (xQueueReceiveFromISR((SemaphoreHandle_t)queue, item, &task_woken) == pdTRUE) {
portYIELD_FROM_ISR(task_woken);
return true;
} else {
return false;
}
}
bool mmosal_queue_push_from_isr(struct mmosal_queue *queue, const void *item)
{
BaseType_t task_woken = pdFALSE;
if (xQueueSendToBackFromISR((SemaphoreHandle_t)queue, item, &task_woken) == pdTRUE) {
portYIELD_FROM_ISR(task_woken);
return true;
} else {
return false;
}
}
/* --------------------------------------------------------------------------------------------- */
uint32_t mmosal_get_time_ms(void)
{
return xTaskGetTickCount() * portTICK_PERIOD_MS;
}
uint32_t mmosal_get_time_ticks(void)
{
return xTaskGetTickCount();
}
uint32_t mmosal_ticks_per_second(void)
{
return portTICK_PERIOD_MS * 1000;
}
/* --------------------------------------------------------------------------------------------- */
struct mmosal_timer *mmosal_timer_create(const char *name, uint32_t timer_period, bool auto_reload, void *arg,
timer_callback_t callback)
{
/*
* The software timer callback functions execute in the context of a task that is
* created automatically when the FreeRTOS scheduler is started. Therefore, it is essential that
* software timer callback functions never call FreeRTOS API functions that will result in the
* calling task entering the Blocked state. It is ok to call functions such as xQueueReceive(), but
* only if the function’s xTicksToWait parameter (which specifies the function’s block time) is set
* to 0. It is not ok to call functions such as vTaskDelay(), as calling vTaskDelay() will always
* place the calling task into the Blocked state.
*/
return (struct mmosal_timer *)xTimerCreate(name, pdMS_TO_TICKS(timer_period), (UBaseType_t)auto_reload, arg,
(TimerCallbackFunction_t)callback);
}
void mmosal_timer_delete(struct mmosal_timer *timer)
{
if (timer != NULL) {
BaseType_t ret = xTimerDelete((TimerHandle_t)timer, 0);
configASSERT(ret == pdPASS);
}
}
bool mmosal_timer_start(struct mmosal_timer *timer)
{
BaseType_t ret = xTimerStart((TimerHandle_t)timer, 0);
return (ret == pdPASS);
}
bool mmosal_timer_stop(struct mmosal_timer *timer)
{
BaseType_t ret = xTimerStop((TimerHandle_t)timer, 0);
return (ret == pdPASS);
}
bool mmosal_timer_change_period(struct mmosal_timer *timer, uint32_t new_period)
{
BaseType_t ret = xTimerChangePeriod((TimerHandle_t)timer, pdMS_TO_TICKS(new_period), 0);
return (ret == pdPASS);
}
void *mmosal_timer_get_arg(struct mmosal_timer *timer)
{
return pvTimerGetTimerID((TimerHandle_t)timer);
}
bool mmosal_is_timer_active(struct mmosal_timer *timer)
{
BaseType_t ret = xTimerIsTimerActive((TimerHandle_t)timer);
return (ret != pdFALSE);
}
#endif /* USE_MM_IOT_ESP32 */
-245
View File
@@ -1,245 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdatomic.h>
#include <stdint.h>
#include "mmhal.h"
#include "mmosal.h"
#include "mmpkt.h"
#include "mmpkt_list.h"
#include "mmutils.h"
/* MMPKTMEM_TX_POOL_N_BLOCKS and MMPKTMEM_RX_POOL_N_BLOCKS provide an upper bound on the number
* of packets we will allocate in the transmit and receive directions respectively. */
#ifndef MMPKTMEM_TX_POOL_N_BLOCKS
#error MMPKTMEM_TX_POOL_N_BLOCKS not defined
#endif
#ifndef MMPKTMEM_RX_POOL_N_BLOCKS
#error MMPKTMEM_RX_POOL_N_BLOCKS not defined
#endif
/* Packet pool for data/management frames configuration. */
#define TX_DATA_POOL_UNPAUSE_THRESHOLD (MMPKTMEM_TX_POOL_N_BLOCKS - 2)
#define TX_DATA_POOL_PAUSE_THRESHOLD (MMPKTMEM_TX_POOL_N_BLOCKS - 1)
/* Packet pool for commands configuration. */
#define TX_COMMAND_POOL_BLOCK_SIZE (256)
#define TX_COMMAND_POOL_N_BLOCKS (2)
#ifndef MMPKT_LOG
#define MMPKT_LOG(...) printf(__VA_ARGS__)
#endif
struct pktmem_data {
/** Count of allocated tx packets (excluding command pool -- see below). */
volatile atomic_int_least32_t tx_data_pool_allocated;
/** Boolean tracking whether the data path is currently paused. */
volatile atomic_uint_fast8_t tx_data_pool_tx_paused;
/** Count of allocated rx packets. */
volatile atomic_int_least32_t rx_pool_allocated;
/** Command pool free (unallocated) packet list. */
struct mmpkt_list tx_command_pool_free_list;
/** Statically allocated memory for the command pool. */
uint8_t tx_command_pool[TX_COMMAND_POOL_BLOCK_SIZE * TX_COMMAND_POOL_N_BLOCKS];
/** Flow control callback function pointer. */
mmhal_wlan_pktmem_tx_flow_control_cb_t tx_flow_control_cb;
};
static struct pktmem_data pktmem;
void mmhal_wlan_pktmem_init(struct mmhal_wlan_pktmem_init_args *args)
{
unsigned ii;
memset(&pktmem, 0, sizeof(pktmem));
pktmem.tx_flow_control_cb = args->tx_flow_control_cb;
/* Initialize the free (unallocated) packet list of the transmit command pool. */
for (ii = 0; ii < TX_COMMAND_POOL_N_BLOCKS; ii++) {
size_t offset = TX_COMMAND_POOL_BLOCK_SIZE * ii;
mmpkt_list_append(&pktmem.tx_command_pool_free_list, (struct mmpkt *)(pktmem.tx_command_pool + offset));
}
}
void mmhal_wlan_pktmem_deinit(void)
{
size_t ii;
/* If there is still memory allocated, allow some time for other threads to clean up. */
for (ii = 0; ii < 100; ii++) {
if ((pktmem.tx_command_pool_free_list.len | pktmem.tx_data_pool_allocated | pktmem.tx_data_pool_allocated) == 0) {
break;
}
mmosal_task_sleep(10);
}
/* Check for memory leaks. */
if (pktmem.tx_data_pool_allocated != 0) {
MMPKT_LOG("Potential memory leak: %d %s pool allocations at deinit\n", (int)pktmem.tx_data_pool_allocated, "data");
}
if (pktmem.tx_command_pool_free_list.len != TX_COMMAND_POOL_N_BLOCKS) {
MMPKT_LOG("Potential memory leak: %d %s pool allocations at deinit\n",
TX_COMMAND_POOL_N_BLOCKS - (int)pktmem.tx_command_pool_free_list.len, "command");
}
}
/*
* --------------------------------------------------------------------------------------
* Command pool
* --------------------------------------------------------------------------------------
*/
static void tx_command_reserved_free(void *mmpkt)
{
struct mmpkt *pkt = (struct mmpkt *)mmpkt;
MMOSAL_TASK_ENTER_CRITICAL();
mmpkt_list_append(&pktmem.tx_command_pool_free_list, pkt);
MMOSAL_TASK_EXIT_CRITICAL();
}
static const struct mmpkt_ops tx_command_pool_ops = {
.free_mmpkt = tx_command_reserved_free,
};
static struct mmpkt *alloc_pkt_from_list(struct mmpkt_list *list, uint32_t pktbufsize, uint32_t space_at_start,
uint32_t space_at_end, uint32_t metadata_length)
{
struct mmpkt *mmpkt_buf;
struct mmpkt *mmpkt;
MMOSAL_TASK_ENTER_CRITICAL();
mmpkt_buf = mmpkt_list_dequeue(list);
MMOSAL_TASK_EXIT_CRITICAL();
if (mmpkt_buf == NULL) {
return NULL;
}
mmpkt = mmpkt_init_buf((uint8_t *)mmpkt_buf, pktbufsize, space_at_start, space_at_end, metadata_length, &tx_command_pool_ops);
if (mmpkt == NULL) {
/* Command was too big for the reserved buffer. Return the reserved buffer. */
tx_command_reserved_free(mmpkt_buf);
}
return mmpkt;
}
static struct mmpkt *command_pool_alloc(uint32_t space_at_start, uint32_t space_at_end, uint32_t metadata_length)
{
return alloc_pkt_from_list(&pktmem.tx_command_pool_free_list, TX_COMMAND_POOL_BLOCK_SIZE, space_at_start, space_at_end,
metadata_length);
}
/*
* --------------------------------------------------------------------------------------
* Data pool
* --------------------------------------------------------------------------------------
*/
static void tx_data_pool_pkt_free(void *mmpkt)
{
atomic_int_least32_t old_value = atomic_fetch_sub(&pktmem.tx_data_pool_allocated, 1);
MMOSAL_ASSERT(old_value > 0);
mmosal_free(mmpkt);
if (pktmem.tx_data_pool_allocated < TX_DATA_POOL_UNPAUSE_THRESHOLD) {
atomic_uint_fast8_t old_tx_paused = atomic_exchange(&pktmem.tx_data_pool_tx_paused, 0);
if (old_tx_paused) {
pktmem.tx_flow_control_cb(MMWLAN_TX_READY);
}
}
}
static const struct mmpkt_ops tx_data_pool_pkt_ops = {
.free_mmpkt = tx_data_pool_pkt_free,
};
struct mmpkt *mmhal_wlan_alloc_mmpkt_for_tx(uint8_t pkt_class, uint32_t space_at_start, uint32_t space_at_end,
uint32_t metadata_length)
{
atomic_int_least32_t old_value;
struct mmpkt *mmpkt;
/* For command packets, try allocating from the command pool first. If that fails then
* we proceed to allocate from the data pool. */
if (pkt_class == MMHAL_WLAN_PKT_COMMAND) {
mmpkt = command_pool_alloc(space_at_start, space_at_end, metadata_length);
if (mmpkt != NULL) {
return mmpkt;
}
}
old_value = atomic_fetch_add(&pktmem.tx_data_pool_allocated, 1);
if (old_value >= MMPKTMEM_TX_POOL_N_BLOCKS) {
/* Maximum allocations reached. Do not attempt to increase further. */
atomic_fetch_sub(&pktmem.tx_data_pool_allocated, 1);
return NULL;
}
mmpkt = mmpkt_alloc_on_heap(space_at_start, space_at_end, metadata_length);
if (mmpkt == NULL) {
atomic_fetch_sub(&pktmem.tx_data_pool_allocated, 1);
return NULL;
}
mmpkt->ops = &tx_data_pool_pkt_ops;
if (pktmem.tx_data_pool_allocated > TX_DATA_POOL_PAUSE_THRESHOLD) {
atomic_uint_fast8_t old_tx_paused = atomic_exchange(&pktmem.tx_data_pool_tx_paused, 1);
if (!old_tx_paused) {
pktmem.tx_flow_control_cb(MMWLAN_TX_PAUSED);
}
}
return mmpkt;
}
static void rx_pkt_free(void *mmpkt)
{
if (mmpkt != NULL) {
atomic_fetch_sub(&pktmem.rx_pool_allocated, 1);
mmosal_free(mmpkt);
}
}
static const struct mmpkt_ops mmpkt_rx_ops = {.free_mmpkt = rx_pkt_free};
struct mmpkt *mmhal_wlan_alloc_mmpkt_for_rx(uint32_t capacity, uint32_t metadata_length)
{
atomic_int_least32_t old_value;
struct mmpkt *mmpkt;
old_value = atomic_fetch_add(&pktmem.rx_pool_allocated, 1);
if (old_value >= MMPKTMEM_RX_POOL_N_BLOCKS) {
/* Maximum allocations reached. Do not attempt to increase further. */
atomic_fetch_sub(&pktmem.rx_pool_allocated, 1);
return NULL;
}
/* For now we do not put an explicit limit on the of packets buffers on the RX path. */
mmpkt = mmpkt_alloc_on_heap(0, capacity, metadata_length);
if (mmpkt == NULL) {
atomic_fetch_sub(&pktmem.rx_pool_allocated, 1);
return NULL;
}
/* Override packet ops to use a custom free function that also decrements the
* allocation count. */
mmpkt->ops = &mmpkt_rx_ops;
return mmpkt;
}
#endif
-12
View File
@@ -1,12 +0,0 @@
/*
* Copyright 2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#define MMPORT_BREAKPOINT() while (1)
#define MMPORT_GET_LR() (__builtin_return_address(0))
#define MMPORT_GET_PC(_a) ((_a) = 0) // TODO
#define MMPORT_MEM_SYNC() __sync_synchronize()
-301
View File
@@ -1,301 +0,0 @@
/*
* Copyright 2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @defgroup MMUTILS Morse Micro Utilities
*
* Utility macros and functions to improve quality of life.
*
* @{
*/
#pragma once
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* Get the minimum of 2 values.
*
* Note that this macro is not ideal and should be used with caution. Caveats include:
* * The two parameters may be evaluated more than once, so should be constant values that
* do not have side effects. For example, do NOT do `MM_MIN(a++, b)`.
* * There are no explicit constraints on types, so be careful of comparing different integer
* types, etc.
*
* @param _x The first value to compare.
* @param _y The second value to compare.
*
* @returns the minimum of @p _x and @p _y.
*/
#define MM_MIN(_x, _y) (((_x) < (_y)) ? (_x) : (_y))
/**
* Get the maximum of 2 values.
*
* Note that this macro is not ideal and should be used with caution. Caveats include:
* * The two parameters may be evaluated more than once, so should be constant values that
* do not have side effects. For example, do NOT do `MM_MAX(a++, b)`.
* * There are no explicit constraints on types, so be careful of comparing different integer
* types, etc.
*
* @param _x The first value to compare.
* @param _y The second value to compare.
*
* @returns the maximum of @p _x and @p _y.
*/
#define MM_MAX(_x, _y) (((_x) > (_y)) ? (_x) : (_y))
/**
* Round @p x up to the next multiple of @p m (where @p m is a power of 2).
*
* @warning @p m must be a power of 2.
*/
#ifndef MM_FAST_ROUND_UP
#define MM_FAST_ROUND_UP(x, m) ((((x)-1) | ((m)-1)) + 1)
#endif
/** Casts the given expression to void to avoid "unused" warnings from the compiler. */
#define MM_UNUSED(_x) (void)(_x)
/** Tells the compiler to pack the structure. */
#ifndef MM_PACKED
#define MM_PACKED __attribute__((packed))
#endif
/** Used to declare a weak symbol. */
#ifndef MM_WEAK
#define MM_WEAK __attribute__((weak))
#endif
#ifndef MM_STATIC_ASSERT
/**
* Assertion check that is evaluated at compile time.
*
* The constant expression, @p _expression, is evaluted at compile time. If zero then
* it triggers a compilation error and @p _message is displayed. If non-zero, no code
* is emitted.
*
* @param _expression Constant expression to evaluate. If zero then a compilation error
* is triggered.
* @param _message Message to display on error.
*/
#define MM_STATIC_ASSERT(_expression, _message) _Static_assert((_expression), _message)
#endif
/**
* Return the number of elements in the given array.
*
* @param _a The array to get the element count for. Note that this must be an _array_
* and not a pointer. Beware that array-type function arguments are
* actually treated as pointers by the compiler. Must not be NULL.
*
* @returns the count of elements in the given array.
*/
#define MM_ARRAY_COUNT(_a) (sizeof(_a) / sizeof((_a)[0]))
/**
* Convert the least significant 4 bits of the given argument to a character representing their
* hexadecimal value.
*
* For example, for input 0xde this will return 'E', for 0x01 it will return '1'.
*
* @param nibble The input nibble (upper 4 bits will be discarded).
*
* @return The character that represents the hexadecimal value of the lower 4 bits of @p nibble.
* Values greater than 0x09 will be represented with upper case characters.
*/
static inline char mm_nibble_to_hex_char(uint8_t nibble)
{
nibble &= 0x0f;
if (nibble < 0x0a) {
return '0' + nibble;
} else {
return 'A' + nibble - 0x0a;
}
}
/**
* @defgroup MMUTILS_WLAN WLAN Utilities
*
* Utility macros and functions relating to WLAN.
*
* @{
*/
/** Enumeration of Authentication Key Management (AKM) Suite OUIs as BE32 integers. */
enum mm_akm_suite_oui {
/** Open (no security) */
MM_AKM_SUITE_NONE = 0,
/** Pre-shared key (WFA OUI) */
MM_AKM_SUITE_PSK = 0x506f9a02,
/** Simultaneous Authentication of Equals (SAE) */
MM_AKM_SUITE_SAE = 0x000fac08,
/** OWE */
MM_AKM_SUITE_OWE = 0x000fac12,
/** Another suite not in this enum */
MM_AKM_SUITE_OTHER = 1,
};
/** Enumeration of Cipher Suite OUIs as BE32 integers. */
enum mm_cipher_suite_oui {
/** Open (no security) */
MM_CIPHER_SUITE_AES_CCM = 0x000fac04,
/** Another cipher suite not in this enum */
MM_CIPHER_SUITE_OTHER = 1,
};
/** Maximum number of pairwise cipher suites our parser will process. */
#ifndef MM_RSN_INFORMATION_MAX_PAIRWISE_CIPHER_SUITES
#define MM_RSN_INFORMATION_MAX_PAIRWISE_CIPHER_SUITES (2)
#endif
/** Maximum number of AKM suites our parser will process. */
#ifndef MM_RSN_INFORMATION_MAX_AKM_SUITES
#define MM_RSN_INFORMATION_MAX_AKM_SUITES (2)
#endif
/** Tag number of the RSN information element, in which we can find security details of the AP. */
#define MM_RSN_INFORMATION_IE_TYPE (48)
/** Tag number of the Vendor Specific information element. */
#define MM_VENDOR_SPECIFIC_IE_TYPE (221)
/** Explicitly defined errno values to obviate the need to include errno.h. MM prefix to
* avoid namespace collision in case errno.h gets included. */
enum mm_errno {
MM_ENOMEM = 12,
MM_EFAULT = 14,
MM_ENODEV = 19,
MM_EINVAL = 22,
MM_ETIMEDOUT = 110,
};
/**
* Data structure to represent information extracted from an RSN information element.
*
* All integers in host order.
*/
struct mm_rsn_information {
/** The group cipher suite OUI. */
uint32_t group_cipher_suite;
/** Pairwise cipher suite OUIs. Count given by @c num_pairwise_cipher_suites. */
uint32_t pairwise_cipher_suites[MM_RSN_INFORMATION_MAX_PAIRWISE_CIPHER_SUITES];
/** AKM suite OUIs. Count given by @c num_akm_suites. */
uint32_t akm_suites[MM_RSN_INFORMATION_MAX_AKM_SUITES];
/** Number of pairwise cipher suites in @c pairwise_cipher_suites. */
uint16_t num_pairwise_cipher_suites;
/** Number of AKM suites in @c akm_suites. */
uint16_t num_akm_suites;
/** Version number of the RSN IE. */
uint16_t version;
/** RSN Capabilities field of the RSN IE (in host order). */
uint16_t rsn_capabilities;
};
/**
* Get the name of the given AKM Suite as a string.
*
* @param akm_suite_oui The OUI of the AKM suite as a big endian integer.
*
* @returns the string representation.
*/
const char *mm_akm_suite_to_string(uint32_t akm_suite_oui);
/**
* Search a list of Information Elements (IEs) from the given starting offset and find the first
* instance of matching the given type.
*
* @warning A @p search_offset that is not aligned to the start of an IE header will result in
* undefined behaviour.
*
* @param ies Buffer containing the information elements.
* @param ies_len Length of @p ies
* @param search_offset Offset to start searching from. This **must** point to a IE header.
* @param ie_type The type of the IE to look for.
*
* @return If the information element is found, the offset of the start of the IE within @p ies; if
* no match is found then -1; if the IE is found but is malformed then -2.
*/
int mm_find_ie_from_offset(const uint8_t *ies, uint32_t ies_len, uint32_t search_offset, uint8_t ie_type);
/**
* Search a list of Information Elements (IEs) and find the first instance of matching the
* given type.
*
* @param ies Buffer containing the information elements.
* @param ies_len Length of @p ies
* @param ie_type The type of the IE to look for.
*
* @return If the information element is found, the offset of the start of the IE within @p ies;
* if no match is found then -1; if the IE is found but is malformed then -2.
*/
static inline int mm_find_ie(const uint8_t *ies, uint32_t ies_len, uint8_t ie_type)
{
return mm_find_ie_from_offset(ies, ies_len, 0, ie_type);
}
/**
* Search through the given list of Information Elements (IEs) from the given starting offset to
* find the first Vendor Specific IE that matches the given id.
*
* @warning A @p search_offset that is not aligned to the start of an IE header will result in
* undefined behaviour.
*
* @param[in] ies Buffer containing the information elements.
* @param[in] ies_len Length of @p ies
* @param[in] search_offset Offset to start searching from. This **must** point to a IE header.
* @param[in] id Buffer containing the IE ID, usually OUI+TYPE.
* @param[in] id_len Length of the ID.
*
* @return If the information element is found, the offset of the start of the IE within @p ies; if
* no match is found then -1; if the IE is found but is malformed then -2.
*/
int mm_find_vendor_specific_ie_from_offset(const uint8_t *ies, uint32_t ies_len, uint32_t search_offset, const uint8_t *id,
size_t id_len);
/**
* Search through the given list of Information Elements (IEs) to find the first Vendor Specific IE
* that matches the given id.
*
* @param[in] ies Buffer containing the information elements.
* @param[in] ies_len Length of @p ies
* @param[in] id Buffer containing the IE ID, usually OUI+TYPE.
* @param[in] id_len Length of the ID.
*
* @return If the information element is found, the offset of the start of the IE within @p ies; if
* no match is found then -1; if the IE is found but is malformed then -2.
*/
static inline int mm_find_vendor_specific_ie(const uint8_t *ies, uint32_t ies_len, const uint8_t *id, size_t id_len)
{
return mm_find_vendor_specific_ie_from_offset(ies, ies_len, 0, id, id_len);
}
/**
* Search through the given list of information elements to find the RSN IE then parse it
* to extract relevant information into an instance of @ref mm_rsn_information.
*
* @param[in] ies Buffer containing the information elements.
* @param[in] ies_len Length of @p ies
* @param[out] output Pointer to an instance of @ref mm_rsn_information to receive output.
*
* @returns -2 on parse error, -1 if the RSN IE was not found, 0 if the RSN IE was found.
*/
int mm_parse_rsn_information(const uint8_t *ies, uint32_t ies_len, struct mm_rsn_information *output);
/** @} */
#ifdef __cplusplus
}
#endif
/** @} */
-163
View File
@@ -1,163 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2024 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdio.h>
#include "mmutils.h"
const char *mm_akm_suite_to_string(uint32_t akm_suite_oui)
{
switch (akm_suite_oui) {
case MM_AKM_SUITE_NONE:
return "None";
case MM_AKM_SUITE_PSK:
return "PSK";
case MM_AKM_SUITE_SAE:
return "SAE";
case MM_AKM_SUITE_OWE:
return "OWE";
default:
return "Other";
}
}
int mm_find_ie_from_offset(const uint8_t *ies, uint32_t ies_len, uint32_t search_offset, uint8_t ie_type)
{
while ((search_offset + 2) <= ies_len) {
uint8_t type = ies[search_offset];
uint8_t length = ies[search_offset + 1];
if (type == ie_type) {
if ((search_offset + 2 + length) > ies_len) {
return -2;
}
return search_offset;
}
search_offset += 2 + length;
}
return -1;
}
int mm_find_vendor_specific_ie_from_offset(const uint8_t *ies, uint32_t ies_len, uint32_t search_offset, const uint8_t *id,
size_t id_len)
{
int offset = 0;
while ((search_offset + id_len) <= ies_len) {
offset = mm_find_ie_from_offset(ies, ies_len, search_offset, MM_VENDOR_SPECIFIC_IE_TYPE);
if (offset < 0) {
return offset;
}
uint8_t ie_type = ies[offset];
uint8_t ie_length = ies[offset + 1];
const uint8_t *ie_data = ies + (offset + 2);
if (ie_type == MM_VENDOR_SPECIFIC_IE_TYPE && id_len <= ie_length && (memcmp(id, ie_data, id_len) == 0)) {
if (((uint32_t)offset + 2 + ie_length) > ies_len) {
return -2;
}
return offset;
}
search_offset = 2 + ie_length + (uint32_t)offset;
}
return -1;
}
int mm_parse_rsn_information(const uint8_t *ies, uint32_t ies_len, struct mm_rsn_information *output)
{
uint8_t length;
uint16_t num_pairwise_cipher_suites;
uint16_t num_akm_suites;
uint16_t ii;
int offset = mm_find_ie(ies, ies_len, MM_RSN_INFORMATION_IE_TYPE);
memset(output, 0, sizeof(*output));
if (offset < 0) {
return offset;
}
/* Note that we rely on mm_find_ie() to validate that the IE does not extend past the end
* of the given buffer. */
length = ies[offset + 1];
offset += 2;
if (length < 8) {
printf("*WRN* RSN IE too short\n");
return -2;
}
/* Skip version field */
output->version = ies[offset] | ies[offset + 1] << 8;
offset += 2;
length -= 2;
output->group_cipher_suite = ies[offset] << 24 | ies[offset + 1] << 16 | ies[offset + 2] << 8 | ies[offset + 3];
offset += 4;
length -= 4;
num_pairwise_cipher_suites = ies[offset] | ies[offset + 1] << 8;
offset += 2;
length -= 2;
output->num_pairwise_cipher_suites = num_pairwise_cipher_suites;
if (num_pairwise_cipher_suites > MM_RSN_INFORMATION_MAX_PAIRWISE_CIPHER_SUITES) {
output->num_pairwise_cipher_suites = MM_RSN_INFORMATION_MAX_PAIRWISE_CIPHER_SUITES;
}
if (length < 4 * num_pairwise_cipher_suites + 2) {
printf("*WRN* RSN IE too short\n");
return -2;
}
for (ii = 0; ii < num_pairwise_cipher_suites; ii++) {
if (ii < output->num_pairwise_cipher_suites) {
output->pairwise_cipher_suites[ii] =
ies[offset] << 24 | ies[offset + 1] << 16 | ies[offset + 2] << 8 | ies[offset + 3];
}
offset += 4;
length -= 4;
}
num_akm_suites = ies[offset] | ies[offset + 1] << 8;
offset += 2;
length -= 2;
output->num_akm_suites = num_akm_suites;
if (num_akm_suites > MM_RSN_INFORMATION_MAX_AKM_SUITES) {
output->num_akm_suites = MM_RSN_INFORMATION_MAX_AKM_SUITES;
}
if (length < 4 * num_akm_suites + 2) {
printf("*WRN* RSN IE too short\n");
return -2;
}
for (ii = 0; ii < num_akm_suites; ii++) {
if (ii < output->num_akm_suites) {
output->akm_suites[ii] = ies[offset] << 24 | ies[offset + 1] << 16 | ies[offset + 2] << 8 | ies[offset + 3];
}
offset += 4;
length -= 4;
}
output->rsn_capabilities = ies[offset] | ies[offset + 1] << 8;
return 0;
}
#endif /* USE_MM_IOT_ESP32 */
-267
View File
@@ -1,267 +0,0 @@
#ifdef USE_MM_IOT_ESP32
/*
* Copyright 2021-2023 Morse Micro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mmhal.h"
#include "mmosal.h"
#include "driver/gpio.h"
#include "driver/spi_common.h"
#include "driver/spi_master.h"
#include "esp_random.h"
#include "esp_system.h"
/** 10x8bit training seq */
#define BYTE_TRAIN 16
/** SPI hw interrupt handler. Must be set before enabling irq */
static mmhal_irq_handler_t spi_irq_handler = NULL;
/** busy interrupt handler. Must be set before enabling irq */
static mmhal_irq_handler_t busy_irq_handler = NULL;
static spi_device_handle_t spi_handle;
static void wlan_hal_gpio_init(void)
{
gpio_config_t io_conf = {};
io_conf.intr_type = GPIO_INTR_DISABLE;
io_conf.mode = GPIO_MODE_OUTPUT;
io_conf.pin_bit_mask = ((1ull << CONFIG_MM_WAKE) | (1ull << CONFIG_MM_SPI_CS));
io_conf.pull_down_en = 0;
io_conf.pull_up_en = 0;
gpio_config(&io_conf);
gpio_set_level(CONFIG_MM_WAKE, 0);
gpio_set_level(CONFIG_MM_SPI_CS, 0);
io_conf.intr_type = GPIO_INTR_DISABLE;
io_conf.mode = GPIO_MODE_INPUT;
io_conf.pin_bit_mask = (1ull << CONFIG_MM_BUSY);
io_conf.pull_down_en = 1;
gpio_config(&io_conf);
io_conf.intr_type = GPIO_INTR_DISABLE;
io_conf.mode = GPIO_MODE_INPUT;
io_conf.pin_bit_mask = (1ull << CONFIG_MM_SPI_IRQ);
io_conf.pull_down_en = 0;
gpio_config(&io_conf);
}
static void wlan_hal_spi_init(void)
{
esp_err_t ret;
spi_bus_config_t buscfg = {
.miso_io_num = CONFIG_MM_SPI_MISO,
.mosi_io_num = CONFIG_MM_SPI_MOSI,
.sclk_io_num = CONFIG_MM_SPI_SCK,
.quadwp_io_num = -1,
.quadhd_io_num = -1,
/* max_transfer_sz defaults to 4092 if 0 when DMA enabled, or to SOC_SPI_MAXIMUM_BUFFER_SIZE
* if DMA is disabled. */
.max_transfer_sz = 0,
.flags = SPICOMMON_BUSFLAG_MASTER,
};
ret = spi_bus_initialize(SPI2_HOST, &buscfg, SPI_DMA_CH_AUTO);
if (ret != ESP_OK) {
printf("spi_bus_initialize failed\n");
}
/* Selected the highest available SPI clock speed that is still below the MM6108's maximum of
* 50MHz */
spi_device_interface_config_t dev_cfg = {
.clock_speed_hz = SPI_MASTER_FREQ_40M,
.mode = 0,
.spics_io_num = -1,
.queue_size = 1,
};
ret = spi_bus_add_device(SPI2_HOST, &dev_cfg, &spi_handle);
if (ret != ESP_OK) {
printf("spi_bus_add_device failed\n");
}
/* The actual clock frequency may not be the one that was set as it is re-calculated by the
* driver to the nearest hardware-compatible number. Importantly it is the "nearest", so it could be above
* the value set. */
int actual_freq_khz = 0;
spi_device_get_actual_freq(spi_handle, &actual_freq_khz);
printf("Actual SPI CLK %dkHz\n", actual_freq_khz);
}
static void wlan_hal_spi_deinit(void)
{
esp_err_t ret = spi_bus_remove_device(spi_handle);
if (ret != ESP_OK) {
printf("spi_bus_remove_device failed\n");
}
ret = spi_bus_free(SPI2_HOST);
if (ret != ESP_OK) {
printf("spi_bus_initialize failed\n");
}
}
/**
* Minium transfer length in bytes before interrupt based transactions are used. This is because
* there is some setup time associated with using the interrupt based method when compared to the
* polling method. In the cases where the difference in setup time exceeds the transaction duration
* it is more efficient to uses the polling method instead of the interrupt based one. The below
* equation was used to calculate this.
*
* (DMA_TRANSACTION_DURATION - POLL_TRANSACTION_DURATION) / (8/SPI_FREQ)
*
* The typical duration for the ESP32 can be found in the [transaction
* duration](https://docs.espressif.com/projects/esp-idf/en/v5.1.1/esp32s3/api-reference/peripherals/spi_master.html#transaction-duration)
* section of the docs.
*/
#define INTERRUPT_TRANSFER_MIN_LENGTH 75
static void spi_master_rw(const uint8_t *w_data, uint8_t *r_data, size_t len)
{
spi_transaction_t trans_desc = {
.rx_buffer = r_data,
.tx_buffer = w_data,
.length = (len * 8),
.flags = 0,
};
esp_err_t err;
if (len < INTERRUPT_TRANSFER_MIN_LENGTH) {
err = spi_device_polling_transmit(spi_handle, &trans_desc);
} else {
err = spi_device_transmit(spi_handle, &trans_desc);
}
if (err != ESP_OK) {
printf("SPI rw error = %x\n", err);
}
}
void mmhal_wlan_hard_reset(void)
{
gpio_set_level(CONFIG_MM_RESET_N, 0);
mmosal_task_sleep(5);
gpio_set_level(CONFIG_MM_RESET_N, 1);
mmosal_task_sleep(20);
}
void mmhal_wlan_spi_cs_assert(void)
{
gpio_set_level(CONFIG_MM_SPI_CS, 0);
}
void mmhal_wlan_spi_cs_deassert(void)
{
gpio_set_level(CONFIG_MM_SPI_CS, 1);
}
uint8_t mmhal_wlan_spi_rw(uint8_t data)
{
uint8_t readval;
spi_master_rw(&data, &readval, 1);
return readval;
}
void mmhal_wlan_spi_read_buf(uint8_t *buf, unsigned len)
{
spi_master_rw(NULL, buf, len);
}
void mmhal_wlan_spi_write_buf(const uint8_t *buf, unsigned len)
{
spi_master_rw(buf, NULL, len);
}
void mmhal_wlan_send_training_seq(void)
{
mmhal_wlan_spi_cs_deassert();
/* Send >74 clock pulses to card to stabilize CLK.
* This method of stacking up the TX data is described in RM0090 rev 19 Figure 253.
* It results is a reduction in the time between bytes of ~85% (316ns -> 48ns).
* Could not get this to work for the other transactions however.
*/
uint8_t buf[BYTE_TRAIN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
spi_master_rw(buf, NULL, BYTE_TRAIN);
}
void mmhal_wlan_register_spi_irq_handler(mmhal_irq_handler_t handler)
{
spi_irq_handler = handler;
gpio_isr_handler_add(CONFIG_MM_SPI_IRQ, (gpio_isr_t)spi_irq_handler, NULL);
}
bool mmhal_wlan_spi_irq_is_asserted(void)
{
return !gpio_get_level(CONFIG_MM_SPI_IRQ);
}
void mmhal_wlan_set_spi_irq_enabled(bool enabled)
{
if (enabled) {
gpio_set_intr_type(CONFIG_MM_SPI_IRQ, GPIO_INTR_LOW_LEVEL);
} else {
gpio_set_intr_type(CONFIG_MM_SPI_IRQ, GPIO_INTR_DISABLE);
}
}
void mmhal_wlan_init(void)
{
wlan_hal_gpio_init();
wlan_hal_spi_init();
/* Raise the RESET_N line to enable the WLAN transceiver. */
gpio_set_level(CONFIG_MM_RESET_N, 1);
}
void mmhal_wlan_deinit(void)
{
/* Lower the RESET_N line to disable the WLAN transceiver. This will put the transceiver in its
* lowest power state. */
gpio_set_level(CONFIG_MM_RESET_N, 0);
wlan_hal_spi_deinit();
/* Clean up any ISR handlers that have been added. These will be added again if the WLAN
* interface is brought back up. */
gpio_isr_handler_remove(CONFIG_MM_SPI_IRQ);
gpio_isr_handler_remove(CONFIG_MM_BUSY);
}
void mmhal_wlan_wake_assert(void)
{
gpio_set_level(CONFIG_MM_WAKE, 1);
}
void mmhal_wlan_wake_deassert(void)
{
gpio_set_level(CONFIG_MM_WAKE, 0);
}
bool mmhal_wlan_busy_is_asserted(void)
{
return gpio_get_level(CONFIG_MM_BUSY);
}
void mmhal_wlan_register_busy_irq_handler(mmhal_irq_handler_t handler)
{
busy_irq_handler = handler;
gpio_isr_handler_add(CONFIG_MM_BUSY, (gpio_isr_t)busy_irq_handler, NULL);
}
void mmhal_wlan_set_busy_irq_enabled(bool enabled)
{
if (enabled) {
gpio_set_intr_type(CONFIG_MM_BUSY, GPIO_INTR_POSEDGE);
} else {
gpio_set_intr_type(CONFIG_MM_BUSY, GPIO_INTR_DISABLE);
}
}
#endif /* USE_MM_IOT_ESP32 */
+1 -1
View File
@@ -2,7 +2,7 @@
; https://docs.platformio.org/page/projectconf.html
[platformio]
default_envs = tbeam
default_envs = heltec-v3
extra_configs =
variants/*/*.ini
+2 -3
View File
@@ -158,9 +158,8 @@ extern "C" void logLegacy(const char *level, const char *fmt, ...);
#include <RAK13800_W5100S.h>
#endif // HAS_ETHERNET
#if HAS_ETHERNET && defined(USE_WS5500)
#include <ETHClass2.h>
#define ETH ETH2
#if HAS_ETHERNET && defined(ARCH_ESP32)
#include <ETH.h>
#endif // HAS_ETHERNET
#if HAS_WIFI
+1 -1
View File
@@ -277,7 +277,7 @@ void fsInit()
*/
void setupSDCard()
{
#if defined(HAS_SDCARD) && !defined(SDCARD_USE_SOFT_SPI)
#if defined(HAS_SDCARD) && !defined(SDCARD_USE_SOFT_SPI) && !defined(HAS_SD_MMC)
concurrency::LockGuard g(spiLock);
SDHandler.begin(SPI_SCK, SPI_MISO, SPI_MOSI);
if (!SD.begin(SDCARD_CS, SDHandler, SD_SPI_FREQUENCY)) {
+126 -83
View File
@@ -24,6 +24,13 @@
#include "meshUtils.h"
#include "power/PowerHAL.h"
#include "sleep.h"
#ifdef ARCH_ESP32
// #include <driver/adc.h>
#include <esp_adc/adc_cali.h>
#include <esp_adc/adc_cali_scheme.h>
#include <esp_adc/adc_oneshot.h>
#include <esp_err.h>
#endif
#if defined(ARCH_PORTDUINO)
#include "api/WiFiServerAPI.h"
@@ -63,9 +70,8 @@
#include <WiFi.h>
#endif
#if HAS_ETHERNET && defined(USE_WS5500)
#include <ETHClass2.h>
#define ETH ETH2
#if HAS_ETHERNET && defined(ARCH_ESP32)
#include <ETH.h>
#endif // HAS_ETHERNET
#endif
@@ -77,21 +83,86 @@
#if defined(BATTERY_PIN) && defined(ARCH_ESP32)
#ifndef BAT_MEASURE_ADC_UNIT // ADC1 is default
static const adc1_channel_t adc_channel = ADC_CHANNEL;
static const adc_channel_t adc_channel = ADC_CHANNEL;
static const adc_unit_t unit = ADC_UNIT_1;
#else // ADC2
static const adc2_channel_t adc_channel = ADC_CHANNEL;
#else // ADC2
static const adc_channel_t adc_channel = ADC_CHANNEL;
static const adc_unit_t unit = ADC_UNIT_2;
RTC_NOINIT_ATTR uint64_t RTC_reg_b;
#endif // BAT_MEASURE_ADC_UNIT
esp_adc_cal_characteristics_t *adc_characs = (esp_adc_cal_characteristics_t *)calloc(1, sizeof(esp_adc_cal_characteristics_t));
static adc_oneshot_unit_handle_t adc_handle = nullptr;
static adc_cali_handle_t adc_cali_handle = nullptr;
static bool adc_calibrated = false;
#ifndef ADC_ATTENUATION
static const adc_atten_t atten = ADC_ATTEN_DB_12;
#else
static const adc_atten_t atten = ADC_ATTENUATION;
#endif
#ifdef ADC_BITWIDTH
static const adc_bitwidth_t adc_width = ADC_BITWIDTH;
#else
static const adc_bitwidth_t adc_width = ADC_BITWIDTH_DEFAULT;
#endif
static int adcBitWidthToBits(adc_bitwidth_t width)
{
switch (width) {
case ADC_BITWIDTH_9:
return 9;
case ADC_BITWIDTH_10:
return 10;
case ADC_BITWIDTH_11:
return 11;
case ADC_BITWIDTH_12:
return 12;
#ifdef ADC_BITWIDTH_13
case ADC_BITWIDTH_13:
return 13;
#endif
default:
return 12;
}
}
static bool initAdcCalibration()
{
#if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
adc_cali_curve_fitting_config_t cali_config = {
.unit_id = unit,
.atten = atten,
.bitwidth = adc_width,
};
esp_err_t ret = adc_cali_create_scheme_curve_fitting(&cali_config, &adc_cali_handle);
if (ret == ESP_OK) {
LOG_INFO("ADC calibration: curve fitting enabled");
return true;
}
if (ret != ESP_ERR_NOT_SUPPORTED) {
LOG_WARN("ADC calibration: curve fitting failed: %s", esp_err_to_name(ret));
}
#endif
#if ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
adc_cali_line_fitting_config_t cali_config = {
.unit_id = unit,
.atten = atten,
.bitwidth = adc_width,
.default_vref = DEFAULT_VREF,
};
esp_err_t ret = adc_cali_create_scheme_line_fitting(&cali_config, &adc_cali_handle);
if (ret == ESP_OK) {
LOG_INFO("ADC calibration: line fitting enabled");
return true;
}
if (ret != ESP_ERR_NOT_SUPPORTED) {
LOG_WARN("ADC calibration: line fitting failed: %s", esp_err_to_name(ret));
}
#endif
LOG_INFO("ADC calibration not supported; using approximate scaling");
return false;
}
#endif // BATTERY_PIN && ARCH_ESP32
#ifdef EXT_PWR_DETECT
@@ -367,8 +438,20 @@ class AnalogBatteryLevel : public HasBatteryLevel
scaled *= operativeAdcMultiplier;
#elif defined(ARCH_ESP32) // ADC block for espressif platforms
raw = espAdcRead();
scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
scaled *= operativeAdcMultiplier;
int voltage_mv = 0;
if (adc_calibrated && adc_cali_handle) {
if (adc_cali_raw_to_voltage(adc_cali_handle, raw, &voltage_mv) != ESP_OK) {
LOG_WARN("ADC calibration read failed; using raw value");
voltage_mv = 0;
}
}
if (voltage_mv == 0) {
// Fallback approximate conversion without calibration
const int bits = adcBitWidthToBits(adc_width);
const float max_code = powf(2.0f, bits) - 1.0f;
voltage_mv = (int)((raw / max_code) * DEFAULT_VREF);
}
scaled = voltage_mv * operativeAdcMultiplier;
#else // block for all other platforms
#ifdef ARCH_NRF52
concurrency::LockGuard saadcGuard(concurrency::nrf52SaadcLock);
@@ -410,51 +493,22 @@ class AnalogBatteryLevel : public HasBatteryLevel
uint32_t raw = 0;
uint8_t raw_c = 0; // raw reading counter
#ifndef BAT_MEASURE_ADC_UNIT // ADC1
if (!adc_handle) {
LOG_ERROR("ADC oneshot handle not initialized");
return 0;
}
for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
int val_ = adc1_get_raw(adc_channel);
if (val_ >= 0) { // save only valid readings
raw += val_;
int val = 0;
esp_err_t err = adc_oneshot_read(adc_handle, adc_channel, &val);
if (err == ESP_OK) {
raw += val;
raw_c++;
}
// delayMicroseconds(100);
}
#else // ADC2
#ifdef CONFIG_IDF_TARGET_ESP32S3 // ESP32S3
// ADC2 wifi bug workaround not required, breaks compile
// On ESP32S3, ADC2 can take turns with Wifi (?)
int32_t adc_buf;
esp_err_t read_result;
// Multiple samples
for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
adc_buf = 0;
read_result = -1;
read_result = adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
if (read_result == ESP_OK) {
raw += adc_buf;
raw_c++; // Count valid samples
} else {
LOG_DEBUG("An attempt to sample ADC2 failed");
LOG_DEBUG("ADC read failed: %s", esp_err_to_name(err));
}
}
#else // Other ESP32
int32_t adc_buf = 0;
for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
// ADC2 wifi bug workaround, see
// https://github.com/espressif/arduino-esp32/issues/102
WRITE_PERI_REG(SENS_SAR_READ_CTRL2_REG, RTC_reg_b);
SET_PERI_REG_MASK(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_DATA_INV);
adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
raw += adc_buf;
raw_c++;
}
#endif // BAT_MEASURE_ADC_UNIT
#endif // End BAT_MEASURE_ADC_UNIT
return (raw / (raw_c < 1 ? 1 : raw_c));
}
#endif
@@ -666,42 +720,31 @@ bool Power::analogInit()
#ifdef ARCH_STM32WL
analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
#elif defined(ARCH_ESP32) // ESP32 needs special analog stuff
adc_oneshot_unit_init_cfg_t init_config = {
.unit_id = unit,
};
#ifndef ADC_WIDTH // max resolution by default
static const adc_bits_width_t width = ADC_WIDTH_BIT_12;
#else
static const adc_bits_width_t width = ADC_WIDTH;
#endif
#ifndef BAT_MEASURE_ADC_UNIT // ADC1
adc1_config_width(width);
adc1_config_channel_atten(adc_channel, atten);
#else // ADC2
adc2_config_channel_atten(adc_channel, atten);
#ifndef CONFIG_IDF_TARGET_ESP32S3
// ADC2 wifi bug workaround
// Not required with ESP32S3, breaks compile
RTC_reg_b = READ_PERI_REG(SENS_SAR_READ_CTRL2_REG);
#endif
#endif
// calibrate ADC
esp_adc_cal_value_t val_type = esp_adc_cal_characterize(unit, atten, width, DEFAULT_VREF, adc_characs);
// show ADC characterization base
if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) {
LOG_INFO("ADC config based on Two Point values stored in eFuse");
} else if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) {
LOG_INFO("ADC config based on reference voltage stored in eFuse");
if (!adc_handle) {
esp_err_t err = adc_oneshot_new_unit(&init_config, &adc_handle);
if (err != ESP_OK) {
LOG_ERROR("ADC oneshot init failed: %s", esp_err_to_name(err));
return false;
}
}
#ifdef CONFIG_IDF_TARGET_ESP32S3
// ESP32S3
else if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP_FIT) {
LOG_INFO("ADC config based on Two Point values and fitting curve "
"coefficients stored in eFuse");
adc_oneshot_chan_cfg_t chan_cfg = {
.atten = atten,
.bitwidth = adc_width,
};
esp_err_t err = adc_oneshot_config_channel(adc_handle, adc_channel, &chan_cfg);
if (err != ESP_OK) {
LOG_ERROR("ADC channel config failed: %s", esp_err_to_name(err));
return false;
}
#endif
else {
LOG_INFO("ADC config based on default reference voltage");
}
#endif // ARCH_ESP32
adc_calibrated = initAdcCalibration();
#endif // ARCH_ESP32
// NRF52 ADC init moved to powerHAL_init in nrf52 platform
+4
View File
@@ -561,5 +561,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define HAS_SCREEN 0
#endif
#ifndef USE_ETHERNET_DEFAULT
#define USE_ETHERNET_DEFAULT 0
#endif
#include "DebugConfiguration.h"
#include "RF95Configuration.h"
+5 -4
View File
@@ -53,10 +53,11 @@ void InkHUD::MessageStore::saveToFlash()
f.write(reinterpret_cast<const uint8_t *>(&m.timestamp), sizeof(m.timestamp)); // Write timestamp. 4 bytes
f.write(reinterpret_cast<const uint8_t *>(&m.sender), sizeof(m.sender)); // Write sender NodeId. 4 Bytes
f.write(reinterpret_cast<const uint8_t *>(&m.channelIndex), sizeof(m.channelIndex)); // Write channel index. 1 Byte
f.write(reinterpret_cast<const uint8_t *>(m.text.c_str()), min(MAX_MESSAGE_SIZE, m.text.size())); // Write message text
f.write('\0'); // Append null term
LOG_DEBUG("Wrote message %u, length %u, text \"%s\"", static_cast<uint32_t>(i), min(MAX_MESSAGE_SIZE, m.text.size()),
m.text.c_str());
f.write(reinterpret_cast<const uint8_t *>(m.text.c_str()),
min((size_t)MAX_MESSAGE_SIZE, m.text.size())); // Write message text
f.write('\0'); // Append null term
LOG_DEBUG("Wrote message %u, length %u, text \"%s\"", static_cast<uint32_t>(i),
min((size_t)MAX_MESSAGE_SIZE, m.text.size()), m.text.c_str());
}
// Release firmware's SPI lock, because SafeFile::close needs it
+2
View File
@@ -13,6 +13,8 @@
#ifdef INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE
// REVISIT esp_adc_cal.h
// "legacy adc calibration driver is deprecated, please migrate to use esp_adc/adc_cali.h and esp_adc/adc_cali_scheme.h"
#include <esp_adc_cal.h>
#include <soc/adc_channel.h>
+2 -2
View File
@@ -68,7 +68,7 @@ TLoraPagerKeyboard::TLoraPagerKeyboard()
: TCA8418KeyboardBase(_TCA8418_ROWS, _TCA8418_COLS), modifierFlag(0), last_modifier_time(0), last_key(UINT8_MAX),
next_key(UINT8_MAX), last_tap(0L), char_idx(0), tap_interval(0)
{
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
ledcAttach(KB_BL_PIN, LEDC_BACKLIGHT_FREQ, LEDC_BACKLIGHT_BIT_WIDTH);
#else
ledcSetup(LEDC_BACKLIGHT_CHANNEL, LEDC_BACKLIGHT_FREQ, LEDC_BACKLIGHT_BIT_WIDTH);
@@ -108,7 +108,7 @@ void TLoraPagerKeyboard::setBacklight(bool on)
uint32_t _brightness = 0;
if (on)
_brightness = brightness;
#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
ledcWrite(KB_BL_PIN, _brightness);
#else
ledcWrite(LEDC_BACKLIGHT_CHANNEL, _brightness);
+1 -9
View File
@@ -801,15 +801,7 @@ void setup()
#endif
#else
// ESP32
#if defined(USE_HALOW_RADIO) && !defined(USE_SX1262) && !defined(USE_RF95) && !defined(USE_LR11X0)
// HaLow-only ESP32 variant: Morse's wlan_hal claims SPI2_HOST itself via
// ESP-IDF's spi_bus_initialize() (lib/MorseWlan/src/wlan_hal.c). Calling
// Arduino SPI.begin() on the default LORA_* pins both (a) collides on
// SPI2_HOST and (b) reconfigures GPIO 5 as SPI clock, clobbering the
// HaLow BUSY input. Skip Arduino's bus init — there's no LoRa, no
// display, no SD card on this board.
LOG_DEBUG("Skipping Arduino SPI.begin() — HaLow owns SPI2_HOST");
#elif defined(HW_SPI1_DEVICE)
#if defined(HW_SPI1_DEVICE)
SPI1.begin(LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS);
LOG_DEBUG("SPI1.begin(SCK=%d, MISO=%d, MOSI=%d, NSS=%d)", LORA_SCK, LORA_MISO, LORA_MOSI, LORA_CS);
SPI1.setFrequency(4000000);
+4
View File
@@ -961,6 +961,10 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
config.network.wifi_enabled = USERPREFS_NETWORK_WIFI_ENABLED;
#endif
#if USE_ETHERNET_DEFAULT
config.network.eth_enabled = true;
#endif
#ifdef USERPREFS_NETWORK_WIFI_SSID
strncpy(config.network.wifi_ssid, USERPREFS_NETWORK_WIFI_SSID, sizeof(config.network.wifi_ssid));
#endif
-75
View File
@@ -1,75 +0,0 @@
#include "PositionPrecision.h"
#include "Channels.h"
#include "mesh-pb-constants.h"
#include <Arduino.h>
uint32_t getPositionPrecisionForChannel(uint8_t channelIndex)
{
const meshtastic_Channel &channel = channels.getByIndex(channelIndex);
if (channel.settings.has_module_settings) {
return channel.settings.module_settings.position_precision;
} else if (channel.role == meshtastic_Channel_Role_PRIMARY) {
return 32;
} else {
return 0;
}
}
static int32_t truncateCoordinate(int32_t coordinate, uint32_t precision)
{
uint32_t coordinateBits = static_cast<uint32_t>(coordinate);
uint32_t truncated = coordinateBits & (UINT32_MAX << (32 - precision));
// Use the middle of the possible location, not the low edge of the bucket.
truncated += (1UL << (31 - precision));
return static_cast<int32_t>(truncated);
}
void applyPositionPrecision(meshtastic_Position &position, uint32_t precision)
{
if (precision == 0) {
uint32_t time = position.time;
position = meshtastic_Position_init_default;
position.time = time;
return;
}
uint32_t effectivePrecision = precision > 32 ? 32 : precision;
position.precision_bits = effectivePrecision;
if (effectivePrecision < 32) {
position.latitude_i = truncateCoordinate(position.latitude_i, effectivePrecision);
position.longitude_i = truncateCoordinate(position.longitude_i, effectivePrecision);
}
}
bool applyPositionPrecision(meshtastic_MeshPacket &packet, uint32_t precision)
{
if (packet.which_payload_variant != meshtastic_MeshPacket_decoded_tag ||
packet.decoded.portnum != meshtastic_PortNum_POSITION_APP) {
return true;
}
meshtastic_Position position = meshtastic_Position_init_default;
if (!pb_decode_from_bytes(packet.decoded.payload.bytes, packet.decoded.payload.size, &meshtastic_Position_msg, &position)) {
return false;
}
applyPositionPrecision(position, precision);
packet.decoded.payload.size = pb_encode_to_bytes(packet.decoded.payload.bytes, sizeof(packet.decoded.payload.bytes),
&meshtastic_Position_msg, &position);
return true;
}
bool applyPositionPrecisionForChannel(meshtastic_MeshPacket &packet, uint8_t channelIndex)
{
if (packet.which_payload_variant != meshtastic_MeshPacket_decoded_tag ||
packet.decoded.portnum != meshtastic_PortNum_POSITION_APP) {
return true;
}
return applyPositionPrecision(packet, getPositionPrecisionForChannel(channelIndex));
}
-9
View File
@@ -1,9 +0,0 @@
#pragma once
#include "meshtastic/mesh.pb.h"
#include <stdint.h>
uint32_t getPositionPrecisionForChannel(uint8_t channelIndex);
void applyPositionPrecision(meshtastic_Position &position, uint32_t precision);
bool applyPositionPrecision(meshtastic_MeshPacket &packet, uint32_t precision);
bool applyPositionPrecisionForChannel(meshtastic_MeshPacket &packet, uint8_t channelIndex);
-20
View File
@@ -34,10 +34,6 @@
#include "STM32WLE5JCInterface.h"
#endif
#ifdef USE_HALOW_RADIO
#include "halow/HaLowInterface.h"
#endif
static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_STD[] = {
meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW,
meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW, meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST,
@@ -524,22 +520,6 @@ std::unique_ptr<RadioInterface> initLoRa()
rebootAtMsec = millis() + 5000;
}
}
#ifdef USE_HALOW_RADIO
// HaLow is the only radio on the dedicated XIAO+HaLow variant, so we only
// try it when no LoRa chip claimed the slot. The interface itself stubs
// out cleanly when USE_MM_IOT_ESP32 is not yet wired in (Phase 0 of plan).
if (!rIf) {
auto halowIf = std::unique_ptr<HaLowInterface>(new HaLowInterface());
if (!halowIf->init()) {
LOG_WARN("HaLow init failed (stub or SDK not present)");
} else {
LOG_INFO("HaLow init success");
rIf = std::move(halowIf);
}
}
#endif
return rIf;
}
-6
View File
@@ -4,7 +4,6 @@
#include "MeshRadio.h"
#include "MeshService.h"
#include "NodeDB.h"
#include "PositionPrecision.h"
#include "RTC.h"
#include "configuration.h"
@@ -368,11 +367,6 @@ ErrorCode Router::send(meshtastic_MeshPacket *p)
}
fixPriority(p); // Before encryption, fix the priority if it's unset
if (!applyPositionPrecisionForChannel(*p, p->channel)) {
LOG_ERROR("Dropping malformed position packet before send");
packetPool.release(p);
return meshtastic_Routing_Error_BAD_REQUEST;
}
// If the packet is not yet encrypted, do so now
if (p->which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
+2 -3
View File
@@ -3,9 +3,8 @@
#include "ServerAPI.h"
#include <WiFi.h>
#if HAS_ETHERNET && defined(USE_WS5500)
#include <ETHClass2.h>
#define ETH ETH2
#if HAS_ETHERNET && defined(ARCH_ESP32)
#include <ETH.h>
#endif // HAS_ETHERNET
/**
+4 -41
View File
@@ -163,41 +163,6 @@ typedef struct _meshtastic_LockdownAuth {
connection-level admin authorization, and reboot the device into
the locked state. Always honoured regardless of current lock state. */
bool lock_now;
/* Optional per-boot uptime cap on the unlocked session, in seconds.
0 = unlimited (token-only enforcement, suitable for unattended
tower / infrastructure nodes).
When non-zero, the firmware arms an uptime timer at unlock. On
each expiry, while there is still boot-count budget, the firmware
decrements the on-flash boot count in place, revokes per-
connection admin auth (clients must re-authenticate to see
content), re-engages the screen lock, and re-arms the timer
without rebooting. Mesh routing keeps running across session
boundaries; only when the boot-count budget reaches zero does
the device hard-lock and reboot.
Total exposure ceiling = ((resolved boot count) + 1) * max_session_seconds.
The +1 accounts for the initial passphrase-unlocked session
itself, since boots_remaining is the number of subsequent
session rolls (each consuming one boot from the rollback ledger).
The resolved boot count is the value the firmware writes into the
token at unlock time: the client-supplied boots_remaining when
non-zero, otherwise the firmware default (TOKEN_DEFAULT_BOOTS).
Note that boots_remaining == 0 in this message means "use firmware
default", NOT "zero boots" — a client computing the ceiling for
display should mirror that resolution rather than multiplying the
raw request value.
The cap is persisted in the token, so it survives token-based
auto-unlock across reboots. Explicit operator Lock Now still
deletes the token and forces passphrase re-entry.
Uses millis() (CPU uptime), not wall-clock time, so the cap is
immune to GPS spoofing, RTC backup-battery removal, and Faraday
cage isolation — none of those move the uptime counter. The only
way to reset the session clock is a reboot, which costs a boot
from the on-flash, HMAC-bound counter. */
uint32_t max_session_seconds;
} meshtastic_LockdownAuth;
/* Parameters for setting up Meshtastic for ameteur radio usage */
@@ -521,7 +486,7 @@ extern "C" {
#define meshtastic_AdminMessage_init_default {0, {0}, {0, {0}}}
#define meshtastic_AdminMessage_InputEvent_init_default {0, 0, 0, 0}
#define meshtastic_AdminMessage_OTAEvent_init_default {_meshtastic_OTAMode_MIN, {0, {0}}}
#define meshtastic_LockdownAuth_init_default {{0, {0}}, 0, 0, 0, 0}
#define meshtastic_LockdownAuth_init_default {{0, {0}}, 0, 0, 0}
#define meshtastic_HamParameters_init_default {"", 0, 0, ""}
#define meshtastic_NodeRemoteHardwarePinsResponse_init_default {0, {meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default, meshtastic_NodeRemoteHardwarePin_init_default}}
#define meshtastic_SharedContact_init_default {0, false, meshtastic_User_init_default, 0, 0}
@@ -534,7 +499,7 @@ extern "C" {
#define meshtastic_AdminMessage_init_zero {0, {0}, {0, {0}}}
#define meshtastic_AdminMessage_InputEvent_init_zero {0, 0, 0, 0}
#define meshtastic_AdminMessage_OTAEvent_init_zero {_meshtastic_OTAMode_MIN, {0, {0}}}
#define meshtastic_LockdownAuth_init_zero {{0, {0}}, 0, 0, 0, 0}
#define meshtastic_LockdownAuth_init_zero {{0, {0}}, 0, 0, 0}
#define meshtastic_HamParameters_init_zero {"", 0, 0, ""}
#define meshtastic_NodeRemoteHardwarePinsResponse_init_zero {0, {meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero, meshtastic_NodeRemoteHardwarePin_init_zero}}
#define meshtastic_SharedContact_init_zero {0, false, meshtastic_User_init_zero, 0, 0}
@@ -556,7 +521,6 @@ extern "C" {
#define meshtastic_LockdownAuth_boots_remaining_tag 2
#define meshtastic_LockdownAuth_valid_until_epoch_tag 3
#define meshtastic_LockdownAuth_lock_now_tag 4
#define meshtastic_LockdownAuth_max_session_seconds_tag 5
#define meshtastic_HamParameters_call_sign_tag 1
#define meshtastic_HamParameters_tx_power_tag 2
#define meshtastic_HamParameters_frequency_tag 3
@@ -753,8 +717,7 @@ X(a, STATIC, SINGULAR, BYTES, ota_hash, 2)
X(a, STATIC, SINGULAR, BYTES, passphrase, 1) \
X(a, STATIC, SINGULAR, UINT32, boots_remaining, 2) \
X(a, STATIC, SINGULAR, UINT32, valid_until_epoch, 3) \
X(a, STATIC, SINGULAR, BOOL, lock_now, 4) \
X(a, STATIC, SINGULAR, UINT32, max_session_seconds, 5)
X(a, STATIC, SINGULAR, BOOL, lock_now, 4)
#define meshtastic_LockdownAuth_CALLBACK NULL
#define meshtastic_LockdownAuth_DEFAULT NULL
@@ -869,7 +832,7 @@ extern const pb_msgdesc_t meshtastic_SHTXX_config_msg;
#define meshtastic_AdminMessage_size 511
#define meshtastic_HamParameters_size 31
#define meshtastic_KeyVerificationAdmin_size 25
#define meshtastic_LockdownAuth_size 54
#define meshtastic_LockdownAuth_size 48
#define meshtastic_NodeRemoteHardwarePinsResponse_size 496
#define meshtastic_SCD30_config_size 27
#define meshtastic_SCD4X_config_size 29
-18
View File
@@ -1,18 +0,0 @@
#pragma once
#include <stddef.h>
#include <stdint.h>
// IEEE 802 Local Experimental EtherType 1, valid on private LANs. Carries a
// Meshtastic RadioBuffer (PacketHeader + payload, ≤255 bytes) end-to-end so the
// LoRa wire format is preserved on HaLow.
static constexpr uint16_t ETHERTYPE_MESHTASTIC_HALOW = 0x88B5;
static constexpr uint8_t HALOW_BROADCAST_MAC[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
struct __attribute__((packed)) HaLowEthFrameHeader {
uint8_t dst[6];
uint8_t src[6];
uint16_t ethertype; // network byte order on the wire
};
static_assert(sizeof(HaLowEthFrameHeader) == 14, "HaLow ethernet header must be 14 bytes");
-287
View File
@@ -1,287 +0,0 @@
#include "configuration.h"
#ifdef USE_HALOW_RADIO
#include "HaLowFrame.h"
#include "HaLowInterface.h"
#include "MeshTypes.h"
#include "RTC.h" // getValidTime / RTCQualityFromNet
#include <string.h>
#if HAS_UDP_MULTICAST
#include "main.h" // for `udpHandler`
#include "mesh/generated/meshtastic/config.pb.h"
#endif
#ifdef USE_MM_IOT_ESP32
extern "C" {
#include "mmhal.h"
#include "mmipal.h"
#include "mmwlan.h"
#include "mmwlan_regdb.def"
}
#ifndef HALOW_COUNTRY_CODE
#define HALOW_COUNTRY_CODE "US"
#endif
// SSID/PSK supplied at build time. Empty SSID means "don't auto-associate" —
// the chip boots and idles, useful for testing without an AP nearby.
#ifndef HALOW_SSID
#define HALOW_SSID ""
#endif
#ifndef HALOW_PASSPHRASE
#define HALOW_PASSPHRASE ""
#endif
#endif
HaLowInterface::HaLowInterface() : concurrency::OSThread("HaLow") {}
#ifdef USE_MM_IOT_ESP32
// Static glue so the C callbacks can reach into the (non-static) instance.
// Only one HaLowInterface exists, owned by Router::iface or constructed at
// boot, so a single pointer is sufficient.
static HaLowInterface *s_instance = nullptr;
static void halow_link_state_cb(enum mmwlan_link_state link_state, void *arg)
{
(void)arg;
if (link_state == MMWLAN_LINK_UP) {
struct mmipal_ip_config ipcfg = {};
if (mmipal_get_ip_config(&ipcfg) == MMIPAL_SUCCESS) {
LOG_INFO("HaLow: link UP, ip=%s netmask=%s gw=%s", ipcfg.ip_addr, ipcfg.netmask, ipcfg.gateway_addr);
} else {
LOG_INFO("HaLow: link UP (no IP yet)");
}
int32_t rssi = mmwlan_get_rssi();
if (rssi != INT32_MIN) {
LOG_INFO("HaLow: AP RSSI %ld dBm", (long)rssi);
}
} else {
LOG_INFO("HaLow: link DOWN");
}
}
// mmwlan delivers Ethernet-framed packets here: 14-byte 802.3 header + payload.
// The payload is whatever EtherType we used on the TX side — we filter for our
// own marker and decode the inner RadioBuffer.
void HaLowInterface::rxTrampoline(uint8_t *header, unsigned header_len, uint8_t *payload, unsigned payload_len, void *arg)
{
HaLowInterface *self = static_cast<HaLowInterface *>(arg);
if (!self || header_len < sizeof(HaLowEthFrameHeader)) {
return;
}
// EtherType is big-endian in the header (bytes 12-13).
uint16_t et = ((uint16_t)header[12] << 8) | header[13];
if (et != ETHERTYPE_MESHTASTIC_HALOW) {
return;
}
self->onFrameReceived(payload, payload_len, /*rssi*/ 0);
}
#endif
HaLowInterface::~HaLowInterface() = default;
bool HaLowInterface::init()
{
RadioInterface::init();
#ifdef USE_MM_IOT_ESP32
LOG_INFO("HaLow: mmhal_init()");
mmhal_init();
LOG_INFO("HaLow: mmwlan_init()");
mmwlan_init();
const struct mmwlan_s1g_channel_list *channel_list = mmwlan_lookup_regulatory_domain(get_regulatory_db(), HALOW_COUNTRY_CODE);
if (!channel_list) {
LOG_ERROR("HaLow: country %s not in regdb", HALOW_COUNTRY_CODE);
return false;
}
if (mmwlan_set_channel_list(channel_list) != MMWLAN_SUCCESS) {
LOG_ERROR("HaLow: set_channel_list failed");
return false;
}
struct mmwlan_boot_args boot_args = MMWLAN_BOOT_ARGS_INIT;
enum mmwlan_status st = mmwlan_boot(&boot_args);
if (st != MMWLAN_SUCCESS) {
LOG_ERROR("HaLow: mmwlan_boot failed (%d) — firmware load or SPI wiring", (int)st);
return false;
}
struct mmwlan_version version;
if (mmwlan_get_version(&version) == MMWLAN_SUCCESS) {
LOG_INFO("HaLow: chip 0x%lx, fw %s, lib %s", (unsigned long)version.morse_chip_id, version.morse_fw_version,
version.morselib_version);
}
// Bring up the LWIP netif (DHCP by default). mmipal plugs into the
// Arduino-ESP32 framework's LWIP — no separate stack.
struct mmipal_init_args ipal_args = MMIPAL_INIT_ARGS_DEFAULT;
if (mmipal_init(&ipal_args) != MMIPAL_SUCCESS) {
LOG_ERROR("HaLow: mmipal_init failed");
return false;
}
if (HALOW_SSID[0] == '\0') {
LOG_INFO("HaLow: no SSID configured, chip will idle (set -DHALOW_SSID=...)");
return false;
}
struct mmwlan_sta_args sta_args = MMWLAN_STA_ARGS_INIT;
sta_args.ssid_len = strnlen(HALOW_SSID, sizeof(sta_args.ssid));
memcpy(sta_args.ssid, HALOW_SSID, sta_args.ssid_len);
sta_args.passphrase_len = strnlen(HALOW_PASSPHRASE, sizeof(sta_args.passphrase));
memcpy(sta_args.passphrase, HALOW_PASSPHRASE, sta_args.passphrase_len);
sta_args.security_type = (sta_args.passphrase_len > 0) ? MMWLAN_SAE : MMWLAN_OPEN;
s_instance = this;
mmwlan_register_link_state_cb(halow_link_state_cb, NULL);
if (mmwlan_register_rx_cb(rxTrampoline, this) != MMWLAN_SUCCESS) {
LOG_ERROR("HaLow: register_rx_cb failed");
return false;
}
LOG_INFO("HaLow: associating with SSID '%s'", HALOW_SSID);
if (mmwlan_sta_enable(&sta_args, NULL) != MMWLAN_SUCCESS) {
LOG_ERROR("HaLow: mmwlan_sta_enable failed");
return false;
}
// From here on out, HaLow is the radio. send() encodes packets as 802.3
// frames addressed to broadcast MAC with EtherType 0x88B5; the AP relays
// them to all associated STAs (Phase 3 closes the AP-less gap).
return true;
#else
LOG_WARN("HaLow: built without USE_MM_IOT_ESP32, transport is a stub");
return false;
#endif
}
bool HaLowInterface::reconfigure()
{
return true;
}
bool HaLowInterface::sleep()
{
return true;
}
bool HaLowInterface::canSleep()
{
return true;
}
ErrorCode HaLowInterface::send(meshtastic_MeshPacket *p)
{
if (!p) {
return ERRNO_UNKNOWN;
}
#ifdef USE_MM_IOT_ESP32
// beginSending() serializes the MeshPacket into radioBuffer (PacketHeader
// + payload). We then prepend a 14-byte 802.3 header so mmwlan can wrap
// it as an 802.11 data frame and ship it through the AP.
size_t encoded = beginSending(p);
if (encoded == 0) {
packetPool.release(p);
return ERRNO_UNKNOWN;
}
uint8_t txbuf[sizeof(HaLowEthFrameHeader) + sizeof(RadioBuffer)];
if (encoded > sizeof(RadioBuffer)) {
LOG_ERROR("HaLow: encoded %u > radioBuffer", (unsigned)encoded);
packetPool.release(p);
return ERRNO_UNKNOWN;
}
// Ethernet header: DA(6) || SA(6) || EtherType(2, big-endian).
memcpy(txbuf, HALOW_BROADCAST_MAC, 6);
if (mmwlan_get_mac_addr(txbuf + 6) != MMWLAN_SUCCESS) {
memset(txbuf + 6, 0, 6); // fallback so the frame still goes out
}
txbuf[12] = (uint8_t)(ETHERTYPE_MESHTASTIC_HALOW >> 8);
txbuf[13] = (uint8_t)(ETHERTYPE_MESHTASTIC_HALOW & 0xFF);
memcpy(txbuf + sizeof(HaLowEthFrameHeader), &radioBuffer, encoded);
enum mmwlan_status st = mmwlan_tx(txbuf, sizeof(HaLowEthFrameHeader) + encoded);
packetPool.release(p);
sendingPacket = NULL;
return (st == MMWLAN_SUCCESS) ? ERRNO_OK : ERRNO_UNKNOWN;
#else
packetPool.release(p);
return ERRNO_DISABLED;
#endif
}
meshtastic_QueueStatus HaLowInterface::getQueueStatus()
{
meshtastic_QueueStatus qs = meshtastic_QueueStatus_init_zero;
qs.free = 16;
qs.maxlen = 16;
return qs;
}
uint32_t HaLowInterface::getPacketTime(uint32_t totalPacketLen, bool /*received*/)
{
// bytes * 8 bits / (HALOW_NOMINAL_KBPS * 1000 bits/sec) * 1000 ms/sec.
// Floor to 1 ms so the slot-time math upstream never divides by zero.
uint32_t ms = (totalPacketLen * 8u + HALOW_NOMINAL_KBPS - 1u) / HALOW_NOMINAL_KBPS;
return ms ? ms : 1u;
}
int32_t HaLowInterface::runOnce()
{
return 1000; // nothing to do until the SDK is wired in
}
void HaLowInterface::onFrameReceived(const uint8_t *payload, size_t payload_len, int8_t rssi)
{
if (!payload || payload_len < sizeof(PacketHeader)) {
return;
}
// Cap at our RadioBuffer size — anything larger is malformed for our wire
// format and we drop it rather than corrupt memory.
if (payload_len > sizeof(RadioBuffer)) {
LOG_WARN("HaLow: rx %u > RadioBuffer, dropping", (unsigned)payload_len);
return;
}
meshtastic_MeshPacket *p = packetPool.allocZeroed();
if (!p) {
return;
}
// Unpack the RadioBuffer into a MeshPacket (mirrors the LoRa RX decode).
const PacketHeader *h = reinterpret_cast<const PacketHeader *>(payload);
p->from = h->from;
p->to = h->to;
p->id = h->id;
p->channel = h->channel;
p->hop_limit = h->flags & PACKET_FLAGS_HOP_LIMIT_MASK;
p->want_ack = !!(h->flags & PACKET_FLAGS_WANT_ACK_MASK);
p->via_mqtt = !!(h->flags & PACKET_FLAGS_VIA_MQTT_MASK);
p->hop_start = (h->flags & PACKET_FLAGS_HOP_START_MASK) >> PACKET_FLAGS_HOP_START_SHIFT;
p->relay_node = h->relay_node;
p->next_hop = h->next_hop;
size_t payload_only = payload_len - sizeof(PacketHeader);
if (payload_only > sizeof(p->encrypted.bytes)) {
packetPool.release(p);
return;
}
memcpy(p->encrypted.bytes, payload + sizeof(PacketHeader), payload_only);
p->encrypted.size = payload_only;
p->which_payload_variant = meshtastic_MeshPacket_encrypted_tag;
// mmwlan's rx callback doesn't carry per-frame RSSI on this SDK version —
// fall back to the connection-level RSSI for visibility in the phone UI.
(void)rssi;
int32_t link_rssi = mmwlan_get_rssi();
p->rx_rssi = (link_rssi == INT32_MIN) ? 0 : (int8_t)link_rssi;
p->rx_snr = 0;
p->rx_time = getValidTime(RTCQualityFromNet);
deliverToReceiver(p);
}
#endif // USE_HALOW_RADIO
-56
View File
@@ -1,56 +0,0 @@
#pragma once
#ifdef USE_HALOW_RADIO
#include "RadioInterface.h"
#include "concurrency/OSThread.h"
/**
* HaLow (802.11ah) transport. Derives directly from RadioInterface because
* RadioLib has no MM6108 driver and the model doesn't fit — mmwlan is a
* frame-level API, not a register-level SPI interface.
*
* Frames go out as Ethernet payloads (broadcast MAC, EtherType 0x88B5) carrying
* the same RadioBuffer the LoRa path builds via beginSending(), so the
* Meshtastic wire format is unchanged.
*
* True peer-broadcast requires MAC-layer support that mm-iot-esp32 does not
* currently expose (no 802.11s / IBSS / monitor mode). Until that gap closes,
* the send path is a no-op and packets must travel over UDP multicast via the
* existing UdpMulticastHandler path (HaLow operating as a STA against an AP).
* See the plan for the SDK-side workstream.
*/
class HaLowInterface : public RadioInterface, private concurrency::OSThread
{
public:
HaLowInterface();
~HaLowInterface() override;
bool init() override;
bool reconfigure() override;
bool sleep() override;
bool canSleep() override;
ErrorCode send(meshtastic_MeshPacket *p) override;
meshtastic_QueueStatus getQueueStatus() override;
uint32_t getPacketTime(uint32_t totalPacketLen, bool received = false) override;
protected:
int32_t runOnce() override;
private:
void onFrameReceived(const uint8_t *payload, size_t payload_len, int8_t rssi);
#ifdef USE_MM_IOT_ESP32
// Trampoline registered with mmwlan_register_rx_cb. The callback hands us
// the 802.3 header and payload separately.
static void rxTrampoline(uint8_t *header, unsigned header_len, uint8_t *payload, unsigned payload_len, void *arg);
#endif
// Approximate bytes-per-millisecond at the configured channel width / MCS.
// HaLow is 150 kbps to 32.5 Mbps depending on configuration — picking a
// single value is fiction, but airtime accounting needs *something*, and
// duty cycle isn't the constraint on HaLow that it is on LoRa.
static constexpr uint32_t HALOW_NOMINAL_KBPS = 1000; // 1 Mbps, 2 MHz MCS3 ballpark
};
#endif // USE_HALOW_RADIO
+2 -3
View File
@@ -13,9 +13,8 @@
#include <WebServer.h>
#include <WiFi.h>
#if HAS_ETHERNET && defined(USE_WS5500)
#include <ETHClass2.h>
#define ETH ETH2
#if HAS_ETHERNET && defined(ARCH_ESP32)
#include <ETH.h>
#endif // HAS_ETHERNET
#ifdef ARCH_ESP32
+2 -3
View File
@@ -12,9 +12,8 @@
#include <AsyncUDP.h>
#if HAS_ETHERNET && defined(USE_WS5500)
#include <ETHClass2.h>
#define ETH ETH2
#if HAS_ETHERNET && defined(ARCH_ESP32)
#include <ETH.h>
#endif // HAS_ETHERNET
#define UDP_MULTICAST_DEFAUL_PORT 4403 // Default port for UDP multicast is same as TCP api server
-53
View File
@@ -1,53 +0,0 @@
#include "configuration.h"
#ifdef USE_HALOW_WIFI
#include "HaLowWiFi.h"
#ifdef USE_MM_IOT_ESP32
extern "C" {
#include "mmwlan.h"
}
#endif
namespace halow
{
HaLowWiFiClass HaLowWiFi;
void HaLowWiFiClass::begin(const char *ssid, const char *passphrase)
{
(void)ssid;
(void)passphrase;
#ifdef USE_MM_IOT_ESP32
// Phase 1: mmwlan_sta_connect(ssid, passphrase, ...).
#endif
}
uint8_t HaLowWiFiClass::status()
{
#ifdef USE_MM_IOT_ESP32
// Phase 1: translate mmwlan link state to the Arduino-WiFi-compat enum.
return HALOW_WL_DISCONNECTED;
#else
return HALOW_WL_DISCONNECTED;
#endif
}
IPAddress HaLowWiFiClass::localIP()
{
return IPAddress(0, 0, 0, 0);
}
String HaLowWiFiClass::macAddress()
{
return String("00:00:00:00:00:00");
}
bool HaLowWiFiClass::isConnected()
{
return status() == HALOW_WL_CONNECTED;
}
} // namespace halow
#endif // USE_HALOW_WIFI
-47
View File
@@ -1,47 +0,0 @@
#pragma once
#ifdef USE_HALOW_WIFI
#include <IPAddress.h>
#include <WString.h>
#include <stdint.h>
// Subset of the Arduino WiFi API that WiFiAPClient.cpp and UdpMulticastHandler
// touch, backed by Morse Micro mmwlan STA-mode association. Lets the existing
// mesh-over-IP path ride HaLow with no changes to call sites — required while
// the peer-broadcast HaLowInterface remains gated on SDK work.
namespace halow
{
enum WiFiStatusCompat : uint8_t {
HALOW_WL_IDLE_STATUS = 0,
HALOW_WL_NO_SSID_AVAIL = 1,
HALOW_WL_CONNECTED = 3,
HALOW_WL_DISCONNECTED = 6,
};
class HaLowWiFiClass
{
public:
void begin(const char *ssid, const char *passphrase);
uint8_t status();
IPAddress localIP();
String macAddress();
bool isConnected();
};
extern HaLowWiFiClass HaLowWiFi;
} // namespace halow
// When the HaLow variant is being built, redirect the Arduino WiFi handle
// expected by call sites to the HaLow shim. Including this header in the
// preprocessor-conditional places that currently #include <WiFi.h> is enough
// to swap the implementation at build time.
#define WiFi ::halow::HaLowWiFi
#define WL_CONNECTED ::halow::HALOW_WL_CONNECTED
#define WL_NO_SSID_AVAIL ::halow::HALOW_WL_NO_SSID_AVAIL
#define WL_DISCONNECTED ::halow::HALOW_WL_DISCONNECTED
#define WL_IDLE_STATUS ::halow::HALOW_WL_IDLE_STATUS
#endif // USE_HALOW_WIFI
+2 -3
View File
@@ -10,9 +10,8 @@
#include "target_specific.h"
#include <WiFi.h>
#if HAS_ETHERNET && defined(USE_WS5500)
#include <ETHClass2.h>
#define ETH ETH2
#if HAS_ETHERNET && defined(ARCH_ESP32)
#include <ETH.h>
#endif // HAS_ETHERNET
#if HAS_ETHERNET && defined(USE_CH390D)
+2 -3
View File
@@ -9,9 +9,8 @@
#include <WiFi.h>
#endif
#if HAS_ETHERNET && defined(USE_WS5500)
#include <ETHClass2.h>
#define ETH ETH2
#if HAS_ETHERNET && defined(ARCH_ESP32)
#include <ETH.h>
#endif // HAS_ETHERNET
extern bool needReconnect;
+1 -1
View File
@@ -262,7 +262,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
break;
}
case meshtastic_AdminMessage_ota_request_tag: {
#if defined(ARCH_ESP32)
#if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_WIFI
LOG_INFO("OTA Requested");
if (r->ota_request.ota_hash.size != 32) {
+34 -14
View File
@@ -4,7 +4,6 @@
#include "GPS.h"
#include "MeshService.h"
#include "NodeDB.h"
#include "PositionPrecision.h"
#include "RTC.h"
#include "Router.h"
#include "TransmitHistory.h"
@@ -108,7 +107,13 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
}
nodeDB->updatePosition(getFrom(&mp), p);
precision = getPositionPrecisionForChannel(mp.channel);
if (channels.getByIndex(mp.channel).settings.has_module_settings) {
precision = channels.getByIndex(mp.channel).settings.module_settings.position_precision;
} else if (channels.getByIndex(mp.channel).role == meshtastic_Channel_Role_PRIMARY) {
precision = 32;
} else {
precision = 0;
}
return false; // Let others look at this message also if they want
}
@@ -116,12 +121,15 @@ bool PositionModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, mes
void PositionModule::alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic_Position *p)
{
// Phone position packets need to be truncated to the channel precision
if (isFromUs(&mp)) {
if (precision == 0)
LOG_DEBUG("Strip phone position due to channel precision 0");
else if (precision < 32)
LOG_DEBUG("Truncate phone position to channel precision %i", precision);
applyPositionPrecision(*p, precision);
if (isFromUs(&mp) && (precision < 32 && precision > 0)) {
LOG_DEBUG("Truncate phone position to channel precision %i", precision);
p->latitude_i = p->latitude_i & (UINT32_MAX << (32 - precision));
p->longitude_i = p->longitude_i & (UINT32_MAX << (32 - precision));
// We want the imprecise position to be the middle of the possible location, not
p->latitude_i += (1 << (31 - precision));
p->longitude_i += (1 << (31 - precision));
mp.decoded.payload.size =
pb_encode_to_bytes(mp.decoded.payload.bytes, sizeof(mp.decoded.payload.bytes), &meshtastic_Position_msg, p);
}
@@ -198,11 +206,20 @@ meshtastic_MeshPacket *PositionModule::allocPositionPacket()
// lat/lon are unconditionally included - IF AVAILABLE!
LOG_DEBUG("Send location with precision %i", precision);
p.latitude_i = localPosition.latitude_i;
p.longitude_i = localPosition.longitude_i;
if (precision < 32 && precision > 0) {
p.latitude_i = localPosition.latitude_i & (UINT32_MAX << (32 - precision));
p.longitude_i = localPosition.longitude_i & (UINT32_MAX << (32 - precision));
// We want the imprecise position to be the middle of the possible location, not
p.latitude_i += (1 << (31 - precision));
p.longitude_i += (1 << (31 - precision));
} else {
p.latitude_i = localPosition.latitude_i;
p.longitude_i = localPosition.longitude_i;
}
p.precision_bits = precision;
p.has_latitude_i = true;
p.has_longitude_i = true;
applyPositionPrecision(p, precision);
// Always use NTP / GPS time if available
if (getValidTime(RTCQualityNTP) > 0) {
p.time = getValidTime(RTCQualityNTP);
@@ -333,7 +350,8 @@ void PositionModule::sendOurPosition()
// If we changed channels, ask everyone else for their latest info
LOG_INFO("Send pos@%x:6 to mesh (wantReplies=%d)", localPosition.timestamp, requestReplies);
for (uint8_t channelNum = 0; channelNum < 8; channelNum++) {
if (getPositionPrecisionForChannel(channelNum) != 0) {
if (channels.getByIndex(channelNum).settings.has_module_settings &&
channels.getByIndex(channelNum).settings.module_settings.position_precision != 0) {
sendOurPosition(NODENUM_BROADCAST, requestReplies, channelNum);
return;
}
@@ -351,8 +369,10 @@ void PositionModule::sendOurPosition(NodeNum dest, bool wantReplies, uint8_t cha
if (prevPacketId) // if we wrap around to zero, we'll simply fail to cancel in that rare case (no big deal)
service->cancelSending(prevPacketId);
// Set the class precision value for this particular packet.
precision = getPositionPrecisionForChannel(channel);
// Set's the class precision value for this particular packet
if (channels.getByIndex(channel).settings.has_module_settings) {
precision = channels.getByIndex(channel).settings.module_settings.position_precision;
}
meshtastic_MeshPacket *p = allocPositionPacket();
if (p == nullptr) {
+2 -2
View File
@@ -90,8 +90,8 @@ int32_t PaxcounterModule::runOnce()
configuration.blecounter = 1;
configuration.blescantime = 0; // infinite
configuration.wificounter = 1;
configuration.wifi_channel_map = WIFI_CHANNEL_ALL;
configuration.wifi_channel_switch_interval = 50;
// configuration.wifi_channel_map = WIFI_CHANNEL_ALL;
// configuration.wifi_channel_switch_interval = 50;
configuration.wifi_rssi_threshold = Default::getConfiguredOrDefault(moduleConfig.paxcounter.wifi_threshold, -80);
configuration.ble_rssi_threshold = Default::getConfiguredOrDefault(moduleConfig.paxcounter.ble_threshold, -80);
libpax_update_config(&configuration);
+2 -6
View File
@@ -19,12 +19,8 @@
#include "mesh/wifi/WiFiAPClient.h"
#include <WiFi.h>
#endif
#if HAS_ETHERNET && defined(USE_WS5500)
#include <ETHClass2.h>
#define ETH ETH2
#elif HAS_ETHERNET && defined(USE_CH390D)
#include "ESP32_CH390.h"
#define ETH CH390
#if HAS_ETHERNET && defined(ARCH_ESP32)
#include <ETH.h>
#endif // HAS_ETHERNET
#include "Default.h"
#if !defined(ARCH_NRF52) || NRF52_USE_JSON
+189 -248
View File
@@ -10,23 +10,18 @@
#include "mesh/PhoneAPI.h"
#include "mesh/mesh-pb-constants.h"
#include "sleep.h"
#include <NimBLEDevice.h>
#include <BLE2904.h>
#include <BLEAdvertising.h>
#include <BLEDevice.h>
#include <BLESecurity.h>
#include <BLEUtils.h>
#include <atomic>
#include <mutex>
#ifdef NIMBLE_TWO
#include "NimBLEAdvertising.h"
#include "NimBLEExtAdvertising.h"
#include "PowerStatus.h"
#endif
#if defined(CONFIG_NIMBLE_CPP_IDF)
#include "host/ble_gap.h"
#else
#include "nimble/nimble/host/include/host/ble_gap.h"
#endif
#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6)
#include "host/ble_store.h"
namespace
{
@@ -34,7 +29,6 @@ constexpr uint16_t kPreferredBleMtu = 517;
constexpr uint16_t kPreferredBleTxOctets = 251;
constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
} // namespace
#endif
// Debugging options: careful, they slow things down quite a bit!
// #define DEBUG_NIMBLE_ON_READ_TIMING // uncomment to time onRead duration
@@ -44,10 +38,10 @@ constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
#define NIMBLE_BLUETOOTH_TO_PHONE_QUEUE_SIZE 3
#define NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE 3
NimBLECharacteristic *fromNumCharacteristic;
NimBLECharacteristic *BatteryCharacteristic;
NimBLECharacteristic *logRadioCharacteristic;
NimBLEServer *bleServer;
BLECharacteristic *fromNumCharacteristic;
BLECharacteristic *BatteryCharacteristic;
BLECharacteristic *logRadioCharacteristic;
BLEServer *bleServer;
static bool passkeyShowing;
static std::atomic<uint16_t> nimbleBluetoothConnHandle{BLE_HS_CONN_HANDLE_NONE}; // BLE_HS_CONN_HANDLE_NONE means "no connection"
@@ -118,7 +112,8 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
- Yes, we have to do some copy operations on pop because of this, but it's worth it to avoid cross-task memory management.
NOTIFY IS BROKEN:
- Adding NIMBLE_PROPERTY::NOTIFY to FromRadioCharacteristic appears to break things. It is NOT backwards compatible.
- Adding BLECharacteristic::PROPERTY_NOTIFY to FromRadioCharacteristic appears to break things. It is NOT backwards
compatible.
ZERO-SIZE READS:
- Returning a zero-size read from onRead breaks some clients during the config phase. So we have to block onRead until we
@@ -139,7 +134,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
std::mutex fromPhoneMutex;
std::atomic<size_t> fromPhoneQueueSize{0};
// We use array here (and pay the cost of memcpy) to avoid dynamic memory allocations and frees across FreeRTOS tasks.
std::array<NimBLEAttValue, NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE> fromPhoneQueue{};
std::array<BLEValue, NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE> fromPhoneQueue{};
/* Packets to phone (BLE onRead callback) */
std::mutex toPhoneMutex;
@@ -301,7 +296,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
LOG_DEBUG("NimbleBluetooth: handling ToRadio packet, fromPhoneQueueSize=%u", fromPhoneQueueSize.load());
// Pop the front of fromPhoneQueue, holding the mutex only briefly while we pop.
NimBLEAttValue val;
BLEValue val;
{ // scope for fromPhoneMutex mutex
std::lock_guard<std::mutex> guard(fromPhoneMutex);
val = fromPhoneQueue[0];
@@ -316,7 +311,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
fromPhoneQueueSize--;
}
handleToRadio(val.data(), val.length());
handleToRadio(val.getData(), val.getLength());
}
}
@@ -328,9 +323,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
PhoneAPI::onNowHasData(fromRadioNum);
#ifdef DEBUG_NIMBLE_NOTIFY
int currentNotifyCount = notifyCount.fetch_add(1);
uint8_t cc = bleServer->getConnectedCount();
// This logging slows things down when there are lots of packets going to the phone, like initial connection:
LOG_DEBUG("BLE notify(%d) fromNum: %d connections: %d", currentNotifyCount, fromRadioNum, cc);
@@ -340,13 +333,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
put_le32(val, fromRadioNum);
fromNumCharacteristic->setValue(val, sizeof(val));
#ifdef NIMBLE_TWO
// NOTE: I don't have any NIMBLE_TWO devices, but this line makes me suspicious, and I suspect it needs to just be
// notify().
fromNumCharacteristic->notify(val, sizeof(val), BLE_HS_CONN_HANDLE_NONE);
#else
fromNumCharacteristic->notify();
#endif
}
/// Check the current underlying physical link to see if the client is currently connected
@@ -409,14 +396,9 @@ static BluetoothPhoneAPI *bluetoothPhoneAPI;
// Last ToRadio value received from the phone
static uint8_t lastToRadio[MAX_TO_FROM_RADIO_SIZE];
class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks
class NimbleBluetoothToRadioCallback : public BLECharacteristicCallbacks
{
#ifdef NIMBLE_TWO
virtual void onWrite(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo) override
#else
virtual void onWrite(NimBLECharacteristic *pCharacteristic) override
#endif
void onWrite(BLECharacteristic *pCharacteristic) override
{
// CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.
// Assumption: onWrite is serialized by NimBLE, so we don't need to lock here against multiple concurrent onWrite calls.
@@ -428,15 +410,17 @@ class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks
LOG_DEBUG("BLE onWrite(%d): start millis=%d", currentWriteCount, startMillis);
#endif
auto val = pCharacteristic->getValue();
// Create a BLEValue and populate it with the received data
BLEValue val;
val.setValue(pCharacteristic->getData(), pCharacteristic->getLength());
if (memcmp(lastToRadio, val.data(), val.length()) != 0) {
if (memcmp(lastToRadio, val.getData(), val.getLength()) != 0) {
if (bluetoothPhoneAPI->fromPhoneQueueSize < NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE) {
// Note: the comparison above is safe without a mutex because we are the only method that *increases*
// fromPhoneQueueSize. (It's okay if fromPhoneQueueSize *decreases* in the main task meanwhile.)
memcpy(lastToRadio, val.data(), val.length());
memcpy(lastToRadio, val.getData(), val.getLength());
{ // scope for fromPhoneMutex mutex
{ // scope for fromPhoneMutex mutexv, pCharacteristic->getLen
// Append to fromPhoneQueue, protected by fromPhoneMutex. Hold the mutex as briefly as possible.
std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->fromPhoneMutex);
bluetoothPhoneAPI->fromPhoneQueue.at(bluetoothPhoneAPI->fromPhoneQueueSize) = val;
@@ -450,24 +434,21 @@ class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks
#ifdef DEBUG_NIMBLE_ON_WRITE_TIMING
int finishMillis = millis();
LOG_DEBUG("BLE onWrite(%d): append to fromPhoneQueue took %u ms. numBytes=%d", currentWriteCount,
finishMillis - startMillis, val.length());
finishMillis - startMillis, val.getLength());
#endif
} else {
LOG_WARN("BLE onWrite(%d): Drop ToRadio packet, fromPhoneQueue full (%u bytes)", currentWriteCount, val.length());
LOG_WARN("BLE onWrite(%d): Drop ToRadio packet, fromPhoneQueue full (%u bytes)", currentWriteCount,
val.getLength());
}
} else {
LOG_DEBUG("BLE onWrite(%d): Drop duplicate ToRadio packet (%u bytes)", currentWriteCount, val.length());
LOG_DEBUG("BLE onWrite(%d): Drop duplicate ToRadio packet (%u bytes)", currentWriteCount, val.getLength());
}
}
};
class NimbleBluetoothFromRadioCallback : public NimBLECharacteristicCallbacks
class NimbleBluetoothFromRadioCallback : public BLECharacteristicCallbacks
{
#ifdef NIMBLE_TWO
virtual void onRead(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo) override
#else
virtual void onRead(NimBLECharacteristic *pCharacteristic) override
#endif
void onRead(BLECharacteristic *pCharacteristic) override
{
// CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.
@@ -573,51 +554,46 @@ class NimbleBluetoothFromRadioCallback : public NimBLECharacteristicCallbacks
}
};
class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks
{
#ifdef NIMBLE_TWO
public:
NimbleBluetoothServerCallback(NimbleBluetooth *ble) { this->ble = ble; }
private:
NimbleBluetooth *ble;
virtual uint32_t onPassKeyDisplay() override
#else
virtual uint32_t onPassKeyRequest() override
#endif
void onPassKeyNotify(uint32_t passkey) override
{
uint32_t configuredPasskey = config.bluetooth.fixed_pin;
if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
LOG_INFO("Use random passkey");
// This is the passkey to be entered on peer - we pick a number >100,000 to ensure 6 digits
configuredPasskey = random(100000, 999999);
}
LOG_INFO("*** Enter passkey %d on the peer side ***", configuredPasskey);
LOG_INFO("*** Enter passkey %06u on the peer side ***", passkey);
powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
std::string passkey = std::to_string(configuredPasskey);
meshtastic::BluetoothStatus newStatus(passkey);
meshtastic::BluetoothStatus newStatus(std::to_string(passkey));
bluetoothStatus->updateStatus(&newStatus);
#if HAS_SCREEN // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
#if HAS_SCREEN
if (screen) {
screen->startAlert([passkey](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
char btPIN[16] = "888888";
snprintf(btPIN, sizeof(btPIN), "%06u", passkey);
int x_offset = display->width() / 2;
int y_offset = display->height() <= 80 ? 0 : 12;
display->setTextAlignment(TEXT_ALIGN_CENTER);
display->setFont(FONT_MEDIUM);
display->drawString(x_offset + x, y_offset + y, "Bluetooth");
#if !defined(M5STACK_UNITC6L)
display->setFont(FONT_SMALL);
y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_MEDIUM - 4 : y_offset + FONT_HEIGHT_MEDIUM + 5;
display->drawString(x_offset + x, y_offset + y, "Enter this code");
#endif
display->setFont(FONT_LARGE);
char pin[8];
snprintf(pin, sizeof(pin), "%.3s %.3s", btPIN, btPIN + 3);
y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_SMALL - 5 : y_offset + FONT_HEIGHT_SMALL + 5;
display->drawString(x_offset + x, y_offset + y, pin);
std::string ble_message = "Bluetooth\nPIN\n[M]" + passkey.substr(0, 3) + " " + passkey.substr(3, 6);
screen->showSimpleBanner(ble_message.c_str(), 30000);
display->setFont(FONT_SMALL);
char deviceName[64];
snprintf(deviceName, sizeof(deviceName), "Name: %s", getDeviceName());
y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_LARGE - 6 : y_offset + FONT_HEIGHT_LARGE + 5;
display->drawString(x_offset + x, y_offset + y, deviceName);
});
}
#endif
passkeyShowing = true;
return configuredPasskey;
}
#ifdef NIMBLE_TWO
virtual void onAuthenticationComplete(NimBLEConnInfo &connInfo) override
#else
virtual void onAuthenticationComplete(ble_gap_conn_desc *desc) override
#endif
void onAuthenticationComplete(ble_gap_conn_desc *desc) override
{
LOG_INFO("BLE authentication complete");
@@ -625,58 +601,47 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
bluetoothStatus->updateStatus(&newStatus);
clearPairingDisplay();
// Store the connection handle for future use
#ifdef NIMBLE_TWO
nimbleBluetoothConnHandle = connInfo.getConnHandle();
#else
nimbleBluetoothConnHandle = desc->conn_handle;
#endif
}
};
#ifdef NIMBLE_TWO
virtual void onConnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo) override
class NimbleBluetoothServerCallback : public BLEServerCallbacks
{
public:
explicit NimbleBluetoothServerCallback(NimbleBluetooth *ble) : ble(ble) {}
private:
NimbleBluetooth *ble;
void onConnect(BLEServer *pServer, struct ble_gap_conn_desc *desc)
{
LOG_INFO("BLE incoming connection %s", connInfo.getAddress().toString().c_str());
BLEAddress peer_addr(desc->peer_id_addr);
LOG_INFO("BLE incoming connection %s", peer_addr.toString().c_str());
const uint16_t connHandle = connInfo.getConnHandle();
#if NIMBLE_ENABLE_2M_PHY && (defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6))
int phyResult =
ble_gap_set_prefered_le_phy(connHandle, BLE_GAP_LE_PHY_2M_MASK, BLE_GAP_LE_PHY_2M_MASK, BLE_GAP_LE_PHY_CODED_ANY);
if (phyResult == 0) {
LOG_INFO("BLE conn %u requested 2M PHY", connHandle);
} else {
LOG_WARN("Failed to prefer 2M PHY for conn %u, rc=%d", connHandle, phyResult);
}
#endif
const uint16_t connHandle = desc->conn_handle;
// With Google Pixel 8 Android devices, this causes ESP32 device crash
// when phone reconnects. Disable this to make progress on the
// Arduino v3 migration while we investigate the Android compatibility
// issue.
#if 0
int dataLenResult = ble_gap_set_data_len(connHandle, kPreferredBleTxOctets, kPreferredBleTxTimeUs);
if (dataLenResult == 0) {
LOG_INFO("BLE conn %u requested data length %u bytes", connHandle, kPreferredBleTxOctets);
} else {
LOG_WARN("Failed to raise data length for conn %u, rc=%d", connHandle, dataLenResult);
}
#endif
LOG_INFO("BLE conn %u initial MTU %u (target %u)", connHandle, connInfo.getMTU(), kPreferredBleMtu);
LOG_INFO("BLE conn %u peer MTU %u (target %u)", connHandle, pServer->getPeerMTU(connHandle), kPreferredBleMtu);
pServer->updateConnParams(connHandle, 6, 12, 0, 200);
}
#endif
#ifdef NIMBLE_TWO
virtual void onDisconnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo, int reason) override
void onDisconnect(BLEServer *pServer, struct ble_gap_conn_desc *desc)
{
LOG_INFO("BLE disconnect reason: %d", reason);
#else
virtual void onDisconnect(NimBLEServer *pServer, ble_gap_conn_desc *desc) override
{
LOG_INFO("BLE disconnect");
#endif
#ifdef NIMBLE_TWO
LOG_INFO("BLE disconnected");
if (ble->isDeInit)
return;
#else
if (nimbleBluetooth && nimbleBluetooth->isDeInit)
return;
#endif
meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
bluetoothStatus->updateStatus(&newStatus);
@@ -701,43 +666,51 @@ class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
bluetoothPhoneAPI->writeCount = 0;
}
// Clear the last ToRadio packet buffer to avoid rejecting first packet from new connection
memset(lastToRadio, 0, sizeof(lastToRadio));
nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE; // BLE_HS_CONN_HANDLE_NONE means "no connection"
nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE;
#ifdef NIMBLE_TWO
// Restart Advertising
ble->startAdvertising();
#else
NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
if (!pAdvertising->start(0)) {
if (pAdvertising->isAdvertising()) {
LOG_DEBUG("BLE advertising already running");
} else {
LOG_ERROR("BLE failed to restart advertising");
}
}
#endif
}
};
static NimbleBluetoothToRadioCallback *toRadioCallbacks;
static NimbleBluetoothFromRadioCallback *fromRadioCallbacks;
void NimbleBluetooth::startAdvertising()
{
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
pAdvertising->stop();
pAdvertising->reset();
pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
// if (powerStatus->getHasBattery() == 1) {
// pAdvertising->addServiceUUID(BLEUUID((uint16_t)0x180f));
// }
BLEAdvertisementData scan = BLEAdvertisementData();
scan.setName(getDeviceName());
pAdvertising->setScanResponseData(scan);
pAdvertising->setMinPreferred(0x06); // functions that help with iPhone connections issue
pAdvertising->setMaxPreferred(0x12);
if (!pAdvertising->start(0)) {
LOG_ERROR("BLE failed to start advertising");
} else {
LOG_DEBUG("BLE Advertising started");
}
}
void NimbleBluetooth::shutdown()
{
// No measurable power saving for ESP32 during light-sleep(?)
#ifndef ARCH_ESP32
// Shutdown bluetooth for minimum power draw
LOG_INFO("Disable bluetooth");
NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
pAdvertising->reset();
pAdvertising->stop();
#endif
}
// Proper shutdown for ESP32. Needs reboot to reverse.
void NimbleBluetooth::deinit()
{
#ifdef ARCH_ESP32
@@ -747,21 +720,19 @@ void NimbleBluetooth::deinit()
#ifdef BLE_LED
digitalWrite(BLE_LED, LED_STATE_OFF);
#endif
#ifndef NIMBLE_TWO
NimBLEDevice::deinit();
#endif
BLEDevice::deinit(true);
#endif
}
// Has initial setup been completed
bool NimbleBluetooth::isActive()
{
return bleServer;
return bleServer != nullptr;
}
bool NimbleBluetooth::isConnected()
{
return bleServer->getConnectedCount() > 0;
return bleServer && bleServer->getConnectedCount() > 0;
}
int NimbleBluetooth::getRssi()
@@ -774,9 +745,9 @@ int NimbleBluetooth::getRssi()
uint16_t connHandle = nimbleBluetoothConnHandle.load();
if (connHandle == BLE_HS_CONN_HANDLE_NONE) {
const auto peers = bleServer->getPeerDevices();
const auto peers = bleServer->getPeerDevices(true);
if (!peers.empty()) {
connHandle = peers.front();
connHandle = peers.begin()->first;
nimbleBluetoothConnHandle = connHandle;
}
}
@@ -804,74 +775,84 @@ void NimbleBluetooth::setup()
LOG_INFO("Init the NimBLE bluetooth module");
NimBLEDevice::init(getDeviceName());
NimBLEDevice::setPower(ESP_PWR_LVL_P9);
BLEDevice::init(getDeviceName());
BLEDevice::setPower(ESP_PWR_LVL_P9);
#if NIMBLE_ENABLE_2M_PHY && (defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6))
int mtuResult = NimBLEDevice::setMTU(kPreferredBleMtu);
int mtuResult = BLEDevice::setMTU(kPreferredBleMtu);
if (mtuResult == 0) {
LOG_INFO("BLE MTU request set to %u", kPreferredBleMtu);
} else {
LOG_WARN("Unable to request MTU %u, rc=%d", kPreferredBleMtu, mtuResult);
}
int phyResult = ble_gap_set_prefered_default_le_phy(BLE_GAP_LE_PHY_2M_MASK, BLE_GAP_LE_PHY_2M_MASK);
if (phyResult == 0) {
LOG_INFO("BLE default PHY preference set to 2M");
} else {
LOG_WARN("Failed to prefer 2M PHY by default, rc=%d", phyResult);
}
int dataLenResult = ble_gap_write_sugg_def_data_len(kPreferredBleTxOctets, kPreferredBleTxTimeUs);
if (dataLenResult == 0) {
LOG_INFO("BLE suggested data length set to %u bytes", kPreferredBleTxOctets);
} else {
LOG_WARN("Failed to raise suggested data length (%u/%u), rc=%d", kPreferredBleTxOctets, kPreferredBleTxTimeUs,
dataLenResult);
}
#endif
BLESecurity *pSecurity = new BLESecurity();
pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
pSecurity->setRespEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
if (config.bluetooth.mode != meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
NimBLEDevice::setSecurityAuth(BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM | BLE_SM_PAIR_AUTHREQ_SC);
NimBLEDevice::setSecurityInitKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
NimBLEDevice::setSecurityRespKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY);
// Set IO capability to DisplayOnly for MITM authentication
pSecurity->setCapability(ESP_IO_CAP_OUT);
// Set the passkey
if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
LOG_INFO("Use random passkey");
pSecurity->setPassKey(false); // generate a random passkey
} else {
LOG_INFO("Use fixed passkey");
pSecurity->setPassKey(true, config.bluetooth.fixed_pin);
}
// Enable authorization requirements:
// - bonding: true (for persistent storage of the keys)
// - MITM: true (enables Man-In-The-Middle protection for password prompts)
// - secure connection: true (enables secure connection for encryption)
pSecurity->setAuthenticationMode(true, true, true);
} else {
// No IO capability for no PIN mode
pSecurity->setCapability(ESP_IO_CAP_NONE);
// No PIN mode: no MITM protection
pSecurity->setAuthenticationMode(true, false, false);
}
bleServer = NimBLEDevice::createServer();
#ifdef NIMBLE_TWO
NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback(this);
#else
NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback();
#endif
bleServer->setCallbacks(serverCallbacks, true);
// Set the security callbacks
BLEDevice::setSecurityCallbacks(new NimbleBluetoothSecurityCallback());
bleServer = BLEDevice::createServer();
// BLEDevice::createServer calls ble_svc_gap_init, which resets the device
// name to default, so set it again.
int nameRc = ble_svc_gap_device_name_set(BLEDevice::getDeviceName().c_str());
if (nameRc != 0) {
LOG_ERROR("ble_svc_gap_device_name_set: rc=%d %s", nameRc, BLEUtils::returnCodeToString(nameRc));
}
bleServer->setCallbacks(new NimbleBluetoothServerCallback(this));
setupService();
startAdvertising();
}
void NimbleBluetooth::setupService()
{
NimBLEService *bleService = bleServer->createService(MESH_SERVICE_UUID);
NimBLECharacteristic *ToRadioCharacteristic;
NimBLECharacteristic *FromRadioCharacteristic;
BLEService *bleService = bleServer->createService(MESH_SERVICE_UUID);
BLECharacteristic *ToRadioCharacteristic;
BLECharacteristic *FromRadioCharacteristic;
// Define the characteristics that the app is looking for
if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, NIMBLE_PROPERTY::WRITE);
ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE);
// Allow notifications so phones can stream FromRadio without polling.
FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, NIMBLE_PROPERTY::READ);
fromNumCharacteristic = bleService->createCharacteristic(FROMNUM_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ);
logRadioCharacteristic =
bleService->createCharacteristic(LOGRADIO_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ, 512U);
} else {
ToRadioCharacteristic = bleService->createCharacteristic(
TORADIO_UUID, NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_AUTHEN | NIMBLE_PROPERTY::WRITE_ENC);
FromRadioCharacteristic = bleService->createCharacteristic(
FROMRADIO_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ);
fromNumCharacteristic =
bleService->createCharacteristic(FROMNUM_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ |
NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
bleService->createCharacteristic(FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ);
logRadioCharacteristic = bleService->createCharacteristic(LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY |
BLECharacteristic::PROPERTY_READ);
} else {
ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE |
BLECharacteristic::PROPERTY_WRITE_AUTHEN |
BLECharacteristic::PROPERTY_WRITE_ENC);
FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_READ_AUTHEN |
BLECharacteristic::PROPERTY_READ_ENC);
fromNumCharacteristic = bleService->createCharacteristic(
FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
logRadioCharacteristic = bleService->createCharacteristic(
LOGRADIO_UUID,
NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC, 512U);
LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
}
bluetoothPhoneAPI = new BluetoothPhoneAPI();
@@ -884,76 +865,31 @@ void NimbleBluetooth::setupService()
bleService->start();
// Setup the battery service
NimBLEService *batteryService = bleServer->createService(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
BatteryCharacteristic = batteryService->createCharacteristic( // 0x2A19 is the Battery Level characteristic)
(uint16_t)0x2a19, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY, 1);
#ifdef NIMBLE_TWO
NimBLE2904 *batteryLevelDescriptor = BatteryCharacteristic->create2904();
#else
NimBLE2904 *batteryLevelDescriptor = (NimBLE2904 *)BatteryCharacteristic->createDescriptor((uint16_t)0x2904);
#endif
batteryLevelDescriptor->setFormat(NimBLE2904::FORMAT_UINT8);
BLEService *batteryService = bleServer->createService(BLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
BLE2904 *batteryLevelDescriptor = new BLE2904();
batteryLevelDescriptor->setFormat(BLE2904::FORMAT_UINT8);
batteryLevelDescriptor->setNamespace(1);
batteryLevelDescriptor->setUnit(0x27ad);
BatteryCharacteristic = batteryService->createCharacteristic( // 0x2A19 is the Battery Level characteristic)
(uint16_t)0x2a19, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
BatteryCharacteristic->addDescriptor(batteryLevelDescriptor);
batteryService->start();
}
void NimbleBluetooth::startAdvertising()
{
#ifdef NIMBLE_TWO
NimBLEExtAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
NimBLEExtAdvertisement legacyAdvertising;
legacyAdvertising.setLegacyAdvertising(true);
legacyAdvertising.setScannable(true);
legacyAdvertising.setConnectable(true);
legacyAdvertising.setFlags(BLE_HS_ADV_F_DISC_GEN);
if (powerStatus->getHasBattery() == 1) {
legacyAdvertising.setCompleteServices(NimBLEUUID((uint16_t)0x180f));
}
legacyAdvertising.setCompleteServices(NimBLEUUID(MESH_SERVICE_UUID));
legacyAdvertising.setMinInterval(500);
legacyAdvertising.setMaxInterval(1000);
NimBLEExtAdvertisement legacyScanResponse;
legacyScanResponse.setLegacyAdvertising(true);
legacyScanResponse.setConnectable(true);
legacyScanResponse.setName(getDeviceName());
if (!pAdvertising->setInstanceData(0, legacyAdvertising)) {
LOG_ERROR("BLE failed to set legacyAdvertising");
} else if (!pAdvertising->setScanResponseData(0, legacyScanResponse)) {
LOG_ERROR("BLE failed to set legacyScanResponse");
} else if (!pAdvertising->start(0, 0, 0)) {
LOG_ERROR("BLE failed to start legacyAdvertising");
}
#else
NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
pAdvertising->reset();
pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
pAdvertising->addServiceUUID(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
pAdvertising->start(0);
#endif
}
/// Given a level between 0-100, update the BLE attribute
void updateBatteryLevel(uint8_t level)
{
if ((config.bluetooth.enabled == true) && bleServer && nimbleBluetooth->isConnected()) {
BatteryCharacteristic->setValue(&level, 1);
#ifdef NIMBLE_TWO
BatteryCharacteristic->notify(&level, 1, BLE_HS_CONN_HANDLE_NONE);
#else
BatteryCharacteristic->notify();
#endif
}
}
void NimbleBluetooth::clearBonds()
{
LOG_INFO("Clearing bluetooth bonds!");
NimBLEDevice::deleteAllBonds();
ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
}
void NimbleBluetooth::sendLog(const uint8_t *logMessage, size_t length)
@@ -961,11 +897,16 @@ void NimbleBluetooth::sendLog(const uint8_t *logMessage, size_t length)
if (!bleServer || !isConnected() || length > 512) {
return;
}
#ifdef NIMBLE_TWO
logRadioCharacteristic->notify(logMessage, length, BLE_HS_CONN_HANDLE_NONE);
#else
logRadioCharacteristic->notify(logMessage, length, true);
#endif
logRadioCharacteristic->setValue(logMessage, length);
logRadioCharacteristic->notify();
}
void clearNVS()
{
ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
#ifdef ARCH_ESP32
ESP.restart();
#endif
}
#endif
-5
View File
@@ -12,16 +12,11 @@ class NimbleBluetooth : BluetoothApi
bool isConnected();
int getRssi();
void sendLog(const uint8_t *logMessage, size_t length);
#if defined(NIMBLE_TWO)
void startAdvertising();
#endif
bool isDeInit = false;
private:
void setupService();
#if !defined(NIMBLE_TWO)
void startAdvertising();
#endif
};
void setBluetoothEnable(bool enable);
+42
View File
@@ -0,0 +1,42 @@
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "esp_attr.h"
#ifdef ESP32_FORCE_IRAM_MEMSET
/*
* T-Beam/classic ESP32 boot workaround
* ------------------------------------
* During early flash operations the ESP32 disables cache, but some IRAM flash
* code paths still reach libc memcpy/memset. If those resolve to flash-resident
* implementations, startup can panic with cache-disabled access errors.
*
* We wrap memcpy/memset for the T-Beam environment. Fast path uses the
* normal libc routines when cache is enabled; slow path uses IRAM-safe byte
* loops when cache is disabled.
*/
extern void *__real_memcpy(void *dst, const void *src, size_t n);
static inline bool IRAM_ATTR cache_is_enabled(void)
{
return (*(volatile uint32_t *)0x3FF00040u) & (1u << 3);
}
extern void *IRAM_ATTR __wrap_memcpy(void *dst, const void *src, size_t n)
{
if (cache_is_enabled()) {
return __real_memcpy(dst, src, n);
}
uint8_t *d = (uint8_t *)dst;
const uint8_t *s = (const uint8_t *)src;
while (n--) {
*d++ = *s++;
}
return dst;
}
#endif
+42
View File
@@ -0,0 +1,42 @@
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "esp_attr.h"
#ifdef ESP32_FORCE_IRAM_MEMSET
/*
* T-Beam/classic ESP32 boot workaround
* ------------------------------------
* During early flash operations the ESP32 disables cache, but some IRAM flash
* code paths still reach libc memcpy/memset. If those resolve to flash-resident
* implementations, startup can panic with cache-disabled access errors.
*
* We wrap memcpy/memset for the T-Beam environment. Fast path uses the
* normal libc routines when cache is enabled; slow path uses IRAM-safe byte
* loops when cache is disabled.
*/
extern void *__real_memset(void *dst, int c, size_t n);
static inline bool IRAM_ATTR cache_is_enabled(void)
{
return (*(volatile uint32_t *)0x3FF00040u) & (1u << 3);
}
extern void *IRAM_ATTR __wrap_memset(void *dst, int c, size_t n)
{
if (cache_is_enabled()) {
return __real_memset(dst, c, n);
}
uint8_t *ptr = (uint8_t *)dst;
const uint8_t fill = (uint8_t)c;
while (n--) {
*ptr++ = fill;
}
return dst;
}
#endif
@@ -0,0 +1,11 @@
/* Arduino fix: catch esp_event's orphaned .text.handler_execute section and align to 4 bytes */
SECTIONS
{
.text.handler_execute ALIGN(4) :
{
KEEP(*(.text.handler_execute))
KEEP(*(.text.handler_execute.*))
. = ALIGN(4);
}
}
INSERT AFTER .flash.text;
+21 -6
View File
@@ -165,17 +165,30 @@ void esp32Setup()
// #define APP_WATCHDOG_SECS 45
#define APP_WATCHDOG_SECS 90
#if defined(CONFIG_IDF_TARGET_ESP32C6) || (defined(ESP_IDF_VERSION) && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0))
esp_task_wdt_config_t *wdt_config = (esp_task_wdt_config_t *)malloc(sizeof(esp_task_wdt_config_t));
wdt_config->timeout_ms = APP_WATCHDOG_SECS * 1000;
wdt_config->trigger_panic = true;
res = esp_task_wdt_init(wdt_config);
#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
const esp_task_wdt_config_t wdt_config = {
.timeout_ms = APP_WATCHDOG_SECS * 1000,
.idle_core_mask = (1U << CONFIG_FREERTOS_NUMBER_OF_CORES) - 1U,
.trigger_panic = true,
};
res = esp_task_wdt_init(&wdt_config);
if (res == ESP_ERR_INVALID_STATE) {
LOG_WARN("Task watchdog already initialized, reconfiguring existing instance");
res = esp_task_wdt_reconfigure(&wdt_config);
}
assert(res == ESP_OK);
#else
res = esp_task_wdt_init(APP_WATCHDOG_SECS, true);
if (res == ESP_ERR_INVALID_STATE) {
LOG_WARN("Task watchdog already initialized, reusing existing instance");
res = ESP_OK;
}
assert(res == ESP_OK);
#endif
res = esp_task_wdt_add(NULL);
res = esp_task_wdt_status(NULL);
if (res == ESP_ERR_NOT_FOUND) {
res = esp_task_wdt_add(NULL);
}
assert(res == ESP_OK);
#if HAS_32768HZ
@@ -258,8 +271,10 @@ void cpuDeepSleep(uint32_t msecToWake)
#endif
variant_shutdown();
#if SOC_PM_SUPPORT_RTC_PERIPH_PD
// We want RTC peripherals to stay on
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
#endif
esp_sleep_enable_timer_wakeup(msecToWake * 1000ULL); // call expects usecs
esp_deep_sleep_start(); // TBD mA sleep current (battery)
+4 -7
View File
@@ -4,8 +4,10 @@
#include "configuration.h"
#ifdef ARCH_ESP32
// "legacy adc calibration driver is deprecated, please migrate to use esp_adc/adc_cali.h and esp_adc/adc_cali_scheme.h
#include <esp_adc_cal.h>
// #include <driver/adc.h>
#include <esp_adc/adc_cali.h>
#include <esp_adc/adc_cali_scheme.h>
#include <esp_adc/adc_oneshot.h>
#include <soc/adc_channel.h>
#endif
@@ -28,11 +30,6 @@
#define NUM_CELLS 1
#endif
#ifdef BAT_MEASURE_ADC_UNIT
extern RTC_NOINIT_ATTR uint64_t RTC_reg_b;
#include "soc/sens_reg.h" // needed for adc pin reset
#endif
#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
#include "modules/Telemetry/Sensor/nullSensor.h"
#if __has_include(<Adafruit_INA219.h>)
+30 -12
View File
@@ -18,8 +18,6 @@
#include "target_specific.h"
#ifdef ARCH_ESP32
// "esp_pm_config_esp32_t is deprecated, please include esp_pm.h and use esp_pm_config_t instead"
#include "esp32/pm.h"
#include "esp_pm.h"
#if HAS_WIFI
#include "mesh/wifi/WiFiAPClient.h"
@@ -146,15 +144,31 @@ void initDeepSleep()
// If we booted because our timer ran out or the user pressed reset, send those as fake events
RESET_REASON hwReason = rtc_get_reset_reason(0);
#ifdef CONFIG_IDF_TARGET_ESP32P4
if (hwReason == BROWN_OUT_RESET)
reason = "brownout";
else if (hwReason == HP_CORE_HP_WDT_RESET)
reason = "taskWatchdog";
else if (hwReason == HP_CORE_LP_WDT_RESET)
reason = "intWatchdog";
else if (hwReason == CHIP_LP_WDT_RESET)
reason = "chipWatchdog";
else if (hwReason == SUPER_WDT_RESET)
reason = "superWatchdog";
else if (hwReason == HP_SYS_HP_WDT_RESET)
reason = "systemWatchdog";
else if (hwReason == HP_SYS_LP_WDT_RESET)
reason = "systemLowPowerWatchdog";
#else
if (hwReason == RTCWDT_BROWN_OUT_RESET)
reason = "brownout";
if (hwReason == TG0WDT_SYS_RESET)
else if (hwReason == RTCWDT_RTC_RESET)
reason = "rtcWatchdog";
else if (hwReason == TG0WDT_SYS_RESET)
reason = "taskWatchdog";
if (hwReason == TG1WDT_SYS_RESET)
else if (hwReason == TG1WDT_SYS_RESET)
reason = "intWatchdog";
#endif
LOG_INFO("Booted, wake cause %d (boot count %d), reset_reason=%s", wakeCause, bootCount, reason);
#endif
@@ -397,8 +411,10 @@ esp_sleep_wakeup_cause_t doLightSleep(uint64_t sleepMsec) // FIXME, use a more r
// NOTE! ESP docs say we must disable bluetooth and wifi before light sleep
#if SOC_PM_SUPPORT_RTC_PERIPH_PD
// We want RTC peripherals to stay on
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
#endif
#if defined(BUTTON_PIN) && defined(BUTTON_NEED_PULLUP)
gpio_pullup_en((gpio_num_t)BUTTON_PIN);
@@ -532,11 +548,7 @@ esp_sleep_wakeup_cause_t doLightSleep(uint64_t sleepMsec) // FIXME, use a more r
*/
void enableModemSleep()
{
#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
static esp_pm_config_t esp32_config; // filled with zeros because bss
#else
static esp_pm_config_esp32_t esp32_config; // filled with zeros because bss
#endif
#if CONFIG_IDF_TARGET_ESP32S3
esp32_config.max_freq_mhz = CONFIG_ESP32S3_DEFAULT_CPU_FREQ_MHZ;
#elif CONFIG_IDF_TARGET_ESP32S2
@@ -545,6 +557,12 @@ void enableModemSleep()
esp32_config.max_freq_mhz = CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ;
#elif CONFIG_IDF_TARGET_ESP32C3
esp32_config.max_freq_mhz = CONFIG_ESP32C3_DEFAULT_CPU_FREQ_MHZ;
#elif CONFIG_IDF_TARGET_ESP32P4
#if CONFIG_ESP32P4_REV_MIN_FULL < 300
esp32_config.max_freq_mhz = 360;
#else
esp32_config.max_freq_mhz = 400;
#endif
#else
esp32_config.max_freq_mhz = CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ;
#endif
@@ -562,8 +580,8 @@ bool shouldLoraWake(uint32_t msecToWake)
void enableLoraInterrupt()
{
esp_err_t res;
#if SOC_PM_SUPPORT_EXT_WAKEUP && defined(LORA_DIO1) && (LORA_DIO1 != RADIOLIB_NC)
esp_err_t res;
res = gpio_pulldown_en((gpio_num_t)LORA_DIO1);
if (res != ESP_OK) {
LOG_ERROR("gpio_pulldown_en(LORA_DIO1) result %d", res);

Some files were not shown because too many files have changed in this diff Show More