Merge pull request #3558 from nieldk/master

BWM: negotiate ESP/AT32 UART baud up from 460800
This commit is contained in:
Iceman authored and GitHub committed 2026-08-31 16:00:47 +07:00
commit b3c1ebaade
5 files changed
+183 -31

No files matched your search

+11 -3
View File
@@ -24,6 +24,7 @@
#include "usb_cdc_apis.h"
#ifdef WITH_BWM_FORWARD
#include "bwm_uart_at32.h"
#include "bwm_forward.h" // bwm_fwd_negotiate_baud()
#include "bwm_wifi.h"
#endif
#include "proxmark3_arm.h"
@@ -584,6 +585,9 @@ static void SendStatus(uint32_t wait) {
#endif
#if defined(PM5) && defined(WITH_BWM_STATUS)
bwm_print_battery_status();
#endif
#ifdef WITH_BWM_FORWARD
Dbprintf(" BWM link baud....... " _YELLOW_("%u") " bps", bwm_uart_get_baud());
#endif
printConnSpeed(wait);
DbpString(_CYAN_("Various"));
@@ -700,10 +704,11 @@ static void SendCapabilities(void) {
capabilities.baudrate = g_usart_baudrate;
#endif
#ifdef WITH_BWM_FORWARD
// BWM link runs at a fixed baud; report it so the client's timeout math
// (communication_delay: 12000000 / uart_speed) doesn't divide by zero.
// Report the negotiated link baud so the client's timeout math
// (communication_delay: 12000000 / uart_speed) matches reality and never
// divides by zero.
if (g_reply_via_fpc)
capabilities.baudrate = BWM_UART_BAUD;
capabilities.baudrate = bwm_uart_get_baud();
#endif
#ifdef RDV4
@@ -4011,6 +4016,9 @@ void __attribute__((noreturn)) AppMain(void) {
#ifdef WITH_BWM_FORWARD
bwm_uart_init(); // AT32 UART4 <-> BWM app_com link; AFTER usb_enable()
// Negotiate the link up from the boot baud; harmless no-op if the ESP is
// older or the target is unreachable (stays at BWM_UART_BAUD).
bwm_fwd_negotiate_baud(BWM_UART_BAUD_TARGET);
#endif
#ifdef WITH_BWM_CHARGERKICK
+68
View File
@@ -15,6 +15,7 @@
#include "bwm_uart_at32.h"
#include "pm3_cmd.h" // PM3_CMD_DATA_SIZE, PM3_* return codes
#include "ticks_apis.h" // SpinDelay
#include "string.h"
#ifndef MIN
@@ -54,6 +55,10 @@ static void bwm_pump(void); // fwd decl: TX gate pumps RX to collect forward-f
// We may send while it is below BWM_FC_WINDOW; at the cap we wait for an ack.
static volatile int16_t s_fwd_inflight = 0;
// Set true by the parser when a SLAVE_RESP echoing BWM_CMD_SET_UART_BAUD arrives
// (the ESP's ack for a baud-set request). Consumed by bwm_fwd_negotiate_baud().
static volatile bool s_baud_ack = false;
int bwm_fwd_writebuffer_sync(const uint8_t *data, size_t len) {
static uint8_t frame[BWM_TX_BUFSZ]; // single-threaded bare-metal: static OK
@@ -236,6 +241,9 @@ static void bwm_feed_byte(bwm_parser_t *p, uint8_t byte) {
if (s_fwd_inflight > 0) {
s_fwd_inflight--;
}
} else if ((p->is_bcast == false) && p->cmd == BWM_CMD_SET_UART_BAUD) {
// SLAVE_RESP ack for a baud-set request (see negotiate below)
s_baud_ack = true;
}
}
// valid non-DATA_FORWARD frames and CRC failures alike: just resync
@@ -309,3 +317,63 @@ uint32_t bwm_read_ng(uint8_t *data, size_t len) {
}
return out;
}
// ---------------------------------------------------------------------------
// Runtime baud negotiation.
// The ESP boots at BWM_UART_BAUD and accepts a HOST_CMD (cmd 1011) carrying a
// u32 LE target baud. Its handler test-switches, rolls back, acks at the OLD
// baud with a SLAVE_RESP echoing cmd 1011, then commits to the new baud. So we
// send the request at the current baud, wait for that ack, then switch our own
// UART4 to match. On timeout (old ESP without the command, or a lost ack) we
// leave the link at the boot baud - it keeps working, just slower.
// ---------------------------------------------------------------------------
#define BWM_BAUD_ACK_WAIT_MS 300 // per-attempt wait for the ESP ack
#define BWM_BAUD_ATTEMPTS 3 // resend attempts before giving up
bool bwm_fwd_negotiate_baud(uint32_t target) {
if (target == 0 || target == bwm_uart_get_baud()) {
return false;
}
// Build the SET_UART_BAUD host-command frame once (payload = u32 LE baud).
uint8_t frame[2 + 2 + 2 + 4 + 2];
size_t idx = 0;
frame[idx++] = BWM_HDR_HOST_CMD_1;
frame[idx++] = BWM_HDR_HOST_CMD_2;
frame[idx++] = (uint8_t)(BWM_CMD_SET_UART_BAUD & 0xFF);
frame[idx++] = (uint8_t)((BWM_CMD_SET_UART_BAUD >> 8) & 0xFF);
frame[idx++] = (uint8_t)(4 & 0xFF);
frame[idx++] = (uint8_t)((4 >> 8) & 0xFF);
frame[idx++] = (uint8_t)(target & 0xFF);
frame[idx++] = (uint8_t)((target >> 8) & 0xFF);
frame[idx++] = (uint8_t)((target >> 16) & 0xFF);
frame[idx++] = (uint8_t)((target >> 24) & 0xFF);
uint16_t crc = bwm_crc16(frame, idx, BWM_CRC16_INIT);
frame[idx++] = (uint8_t)(crc & 0xFF);
frame[idx++] = (uint8_t)((crc >> 8) & 0xFF);
for (int attempt = 0; attempt < BWM_BAUD_ATTEMPTS; attempt++) {
s_baud_ack = false;
s_p.state = S_IDLE; // drop any half-frame before we listen
bwm_uart_write(frame, idx);
for (int ms = 0; ms < BWM_BAUD_ACK_WAIT_MS; ms++) {
bwm_pump(); // parser sets s_baud_ack on the SLAVE_RESP
if (s_baud_ack) {
// ESP acked at the old baud and is committing to the new one.
// Switch our side and let both settle before any traffic.
bwm_uart_set_baud(target);
SpinDelay(5);
// Fresh start on the faster link: clear framer + de-fifo + window.
s_p.state = S_IDLE;
s_fifo_head = 0;
s_fifo_tail = 0;
s_fwd_inflight = 0;
return true;
}
SpinDelay(1);
}
}
return false; // no ack: stay at the boot baud, link still usable
}
+10
View File
@@ -47,6 +47,10 @@
#define BWM_CMD_SEND_FORWARD_DATA 5000 // host cmd: payload -> BLE/WiFi endpoint
#define BWM_CMD_DATA_FORWARD 8089 // slave bcast: payload came from endpoint
// System command: set the ESP<->AT32 UART baud (app_com_defs.h, enum @1000).
// SET is a HOST_CMD carrying u32 LE baud; the ESP replies with a SLAVE_RESP
// echoing this cmd (len 0) at the OLD baud, then commits to the new baud.
#define BWM_CMD_SET_UART_BAUD 1011
// Flow control (ack window) - ARM-side only, no BWM firmware change required.
// The ESP already replies to every forward frame with a SLAVE_RESP echoing
// cmd=SEND_FORWARD_DATA, and it sends that ack only *after* app_ble_send() has
@@ -77,4 +81,10 @@ uint32_t bwm_read_ng(uint8_t *data, size_t len);
// >0 when raw bytes are waiting on the FPC USART (gate for receive_ng()).
uint16_t bwm_fwd_rxdata_available(void);
// Negotiate the ESP<->AT32 UART up to `target` baud (app_com cmd 1011), then
// re-init UART4 to match. Returns true if the ESP acked and the link switched;
// false (link left at the boot baud) on timeout or an unsupported rate. Must be
// called once after bwm_uart_init(), before normal forward traffic starts.
bool bwm_fwd_negotiate_baud(uint32_t target);
#endif // __BWM_FORWARD_H
+76 -26
View File
@@ -9,6 +9,13 @@
// See LICENSE.txt for the text of the license.
//-----------------------------------------------------------------------------
// AT32F435 UART4 driver for the Proxmark5 BWM link - see bwm_uart_at32.h.
//
// RX is serviced by circular DMA (DMA1 channel 2) rather than a per-byte
// RX interrupt. The old RDBF ISR dropped bytes on overrun as soon as the
// main loop was busy (FPGA / USB) - fine at 460800, fatal at higher bauds,
// where the dropped byte becomes an app_com CRC-16 failure and a stall.
// Circular DMA lets the controller sink every byte independent of CPU load,
// so BWM_UART_BAUD can be raised to lift BLE/WiFi transfer rates.
//-----------------------------------------------------------------------------
#include "bwm_uart_at32.h"
@@ -18,10 +25,10 @@
#include "at32f435_437_crm.h"
#include "at32f435_437_gpio.h"
#include "at32f435_437_usart.h"
#include "at32f435_437_dma.h"
#include "at32f435_437_misc.h"
#define BWM_UART UART4
#define BWM_UART_IRQn UART4_IRQn
#define BWM_UART_GPIO GPIOA
#define BWM_UART_TX_PIN GPIO_PINS_0
#define BWM_UART_RX_PIN GPIO_PINS_1
@@ -29,20 +36,34 @@
#define BWM_UART_RX_SRC GPIO_PINS_SOURCE1
#define BWM_UART_MUX GPIO_MUX_8
// SSC already owns DMA1 channel 1 (see fpga_hw_at32.c); UART4 RX uses channel 2.
#define BWM_DMA_CHANNEL DMA1_CHANNEL2
#define BWM_DMA_MUX_CHANNEL DMA1MUX_CHANNEL2
// Power-of-two so head/tail wrap with a mask. DMA target buffer.
#define BWM_RX_RING_SZ 4096
static volatile uint8_t s_rx_ring[BWM_RX_RING_SZ];
static volatile uint16_t s_rx_head = 0;
static volatile uint16_t s_rx_tail = 0;
static volatile uint16_t s_rx_tail = 0; // software read cursor; head comes from DMA
static volatile bool s_inited = false;
static volatile bool s_inited = false;
static volatile uint32_t s_cur_baud = BWM_UART_BAUD;
void bwm_uart_init(void) {
if (s_inited) {
return;
}
// Bytes the DMA controller has written so far, wrapped into the ring.
// The channel's DTCNT counts DOWN from buffer_size and reloads to buffer_size
// at wrap (loop mode), so head = size - remaining, always in [0, size-1].
static inline uint16_t bwm_uart_rx_head(void) {
return (uint16_t)((BWM_RX_RING_SZ - dma_data_number_get(BWM_DMA_CHANNEL))
& (BWM_RX_RING_SZ - 1));
}
// Bring UART4 + circular RX DMA up at `baud`. Safe to call repeatedly: on a
// re-config it tears the channel down first, so the ring restarts empty (which
// also discards bytes straddling a baud switch). Mirrors the SSC RX setup in
// fpga_hw_at32.c.
static void bwm_uart_configure(uint32_t baud) {
crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
crm_periph_clock_enable(CRM_UART4_PERIPH_CLOCK, TRUE);
crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
gpio_init_type gpio_init_struct;
gpio_default_para_init(&gpio_init_struct);
@@ -55,34 +76,62 @@ void bwm_uart_init(void) {
gpio_pin_mux_config(BWM_UART_GPIO, BWM_UART_TX_SRC, BWM_UART_MUX);
gpio_pin_mux_config(BWM_UART_GPIO, BWM_UART_RX_SRC, BWM_UART_MUX);
usart_init(BWM_UART, BWM_UART_BAUD, USART_DATA_8BITS, USART_STOP_1_BIT);
// Quiesce before reconfiguring (matters on the re-config path).
dma_channel_enable(BWM_DMA_CHANNEL, FALSE);
usart_enable(BWM_UART, FALSE);
usart_init(BWM_UART, baud, USART_DATA_8BITS, USART_STOP_1_BIT);
usart_parity_selection_config(BWM_UART, USART_PARITY_NONE);
usart_transmitter_enable(BWM_UART, TRUE);
usart_receiver_enable(BWM_UART, TRUE);
s_rx_head = 0;
// --- RX via circular DMA ---
s_rx_tail = 0;
usart_interrupt_enable(BWM_UART, USART_RDBF_INT, TRUE);
nvic_irq_enable(BWM_UART_IRQn, 2, 0);
dma_reset(BWM_DMA_CHANNEL);
dma_init_type dma_init_struct;
dma_default_para_init(&dma_init_struct);
dma_init_struct.buffer_size = BWM_RX_RING_SZ;
dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
dma_init_struct.peripheral_base_addr = (uint32_t) & (BWM_UART->dt);
dma_init_struct.peripheral_inc_enable = FALSE;
dma_init_struct.memory_base_addr = (uint32_t)s_rx_ring;
dma_init_struct.memory_inc_enable = TRUE;
dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
dma_init_struct.loop_mode_enable = TRUE; // circular: reloads at count 0
// MEDIUM: single-byte requests, must not starve the SSC bulk channel (HIGH).
dma_init_struct.priority = DMA_PRIORITY_MEDIUM;
dma_init(BWM_DMA_CHANNEL, &dma_init_struct);
dmamux_enable(DMA1, TRUE);
dmamux_init(BWM_DMA_MUX_CHANNEL, DMAMUX_DMAREQ_ID_UART4_RX);
usart_dma_receiver_enable(BWM_UART, TRUE);
dma_channel_enable(BWM_DMA_CHANNEL, TRUE);
usart_enable(BWM_UART, TRUE);
s_cur_baud = baud;
}
void bwm_uart_init(void) {
if (s_inited) {
return;
}
bwm_uart_configure(BWM_UART_BAUD);
s_inited = true;
}
void UART4_IRQHandler(void) {
if (usart_flag_get(BWM_UART, USART_RDBF_FLAG) != RESET) {
uint8_t b = (uint8_t)usart_data_receive(BWM_UART);
uint16_t next = (uint16_t)((s_rx_head + 1) & (BWM_RX_RING_SZ - 1));
if (next != s_rx_tail) {
s_rx_ring[s_rx_head] = b;
s_rx_head = next;
}
}
if (usart_flag_get(BWM_UART, USART_ROERR_FLAG) != RESET) {
usart_flag_clear(BWM_UART, USART_ROERR_FLAG);
(void)usart_data_receive(BWM_UART);
void bwm_uart_set_baud(uint32_t baud) {
if (baud == 0 || baud == s_cur_baud) {
return;
}
bwm_uart_configure(baud);
}
uint32_t bwm_uart_get_baud(void) {
return s_cur_baud;
}
int bwm_uart_write(const uint8_t *data, size_t len) {
@@ -97,12 +146,13 @@ int bwm_uart_write(const uint8_t *data, size_t len) {
}
uint16_t bwm_uart_rx_available(void) {
return (uint16_t)((s_rx_head - s_rx_tail) & (BWM_RX_RING_SZ - 1));
return (uint16_t)((bwm_uart_rx_head() - s_rx_tail) & (BWM_RX_RING_SZ - 1));
}
uint32_t bwm_uart_read(uint8_t *data, size_t len) {
uint16_t head = bwm_uart_rx_head();
uint32_t n = 0;
while (n < len && s_rx_tail != s_rx_head) {
while (n < len && s_rx_tail != head) {
data[n++] = s_rx_ring[s_rx_tail];
s_rx_tail = (uint16_t)((s_rx_tail + 1) & (BWM_RX_RING_SZ - 1));
}
+18 -2
View File
@@ -14,11 +14,27 @@
#include "common.h"
#define BWM_UART_BAUD 460800
// Boot/default baud. Must match UART_BAUD_RATE_DEFAULT in the ESP firmware
// (Proxmark5_BWM_esp32). The link comes up here, then the ARM negotiates up to
// BWM_UART_BAUD_TARGET at runtime via app_com cmd 1011 - the ESP is designed to
// be told, not reflashed (the SET command is explicitly non-persistent).
#define BWM_UART_BAUD 460800
// Target baud to negotiate after link-up. 0 disables negotiation (stay at
// BWM_UART_BAUD). Bounded by the ESP's CONFIG_SOC_UART_BITRATE_MAX and PA0/PA1
// signal integrity; validate on hardware before raising further.
#ifndef BWM_UART_BAUD_TARGET
#define BWM_UART_BAUD_TARGET 921600
#endif
void bwm_uart_init(void);
void UART4_IRQHandler(void);
// Re-init UART4 + RX DMA at a new baud (used by the runtime baud negotiation).
// Discards any bytes already in the RX ring.
void bwm_uart_set_baud(uint32_t baud);
// Baud the link is currently running at (updated by bwm_uart_set_baud).
uint32_t bwm_uart_get_baud(void);
int bwm_uart_write(const uint8_t *data, size_t len);