versions

core/embed/ble_firmware/int_comm.c

@@ -7,13 +7,13 @@
 #include "ble_nus.h"
 #include "connection.h"
 #include "messages.pb.h"
+#include "nrf_dfu_types.h"
 #include "nrf_drv_spi.h"
 #include "nrf_log.h"
 #include "pm.h"
 #include "protob_helpers.h"
 #include "stdint.h"
 #include "trezor_t3w1_d1_NRF.h"
-#include "nrf_dfu_types.h"
 
 #define SPI_INSTANCE 0 /**< SPI instance index. */
 
@@ -29,13 +29,10 @@ static const nrf_drv_spi_t spi =
 static volatile bool spi_xfer_done = true; /**< Flag used to indicate that SPI
                                        instance completed the transfer. */
 
-
-#define CODE_PAGE_SIZE            (MBR_PAGE_SIZE_IN_WORDS * sizeof(uint32_t))
-#define BOOTLOADER_SETTINGS_PAGE_SIZE       (CODE_PAGE_SIZE)
+#define CODE_PAGE_SIZE (MBR_PAGE_SIZE_IN_WORDS * sizeof(uint32_t))
+#define BOOTLOADER_SETTINGS_PAGE_SIZE (CODE_PAGE_SIZE)
 uint8_t m_dfu_settings_buffer[BOOTLOADER_SETTINGS_PAGE_SIZE]
-        __attribute__((section(".bootloader_settings_page")))
-        __attribute__((used));
-
+    __attribute__((section(".bootloader_settings_page"))) __attribute__((used));
 
 /**
  * @brief SPI user event handler.
@@ -362,27 +359,24 @@ void nus_data_handler(ble_nus_evt_t *p_evt) {
 /**@snippet [Handling the data received over BLE] */
 
 void send_status_event(void) {
-
-  ble_version_t version ={0};
-  nrf_dfu_settings_t * settins= (nrf_dfu_settings_t *)m_dfu_settings_buffer;
+  ble_version_t version = {0};
+  nrf_dfu_settings_t *settins = (nrf_dfu_settings_t *)m_dfu_settings_buffer;
 
   sd_ble_version_get(&version);
 
-
-
   event_status_msg_t msg = {0};
   msg.msg_id = INTERNAL_EVENT_STATUS;
-  msg.connected =     (get_connection_handle() != BLE_CONN_HANDLE_INVALID) ? 1 : 0;
+  msg.connected = (get_connection_handle() != BLE_CONN_HANDLE_INVALID) ? 1 : 0;
   msg.advertising = is_advertising() ? 1 : 0;
-  msg.advertising_whitelist =   is_advertising_wl() ? 1 : 0;
-  msg.peer_count =   pm_peer_count();
+  msg.advertising_whitelist = is_advertising_wl() ? 1 : 0;
+  msg.peer_count = pm_peer_count();
   msg.sd_version_number = version.version_number;
   msg.sd_company_id = version.company_id;
   msg.sd_subversion_number = version.subversion_number;
   msg.app_version = settins->app_version;
   msg.bld_version = settins->bootloader_version;
 
-  send_packet(INTERNAL_EVENT, (uint8_t*) &msg, sizeof(msg));
+  send_packet(INTERNAL_EVENT, (uint8_t *)&msg, sizeof(msg));
 }
 
 void send_success_event(void) {

core/embed/firmware/main.c

@@ -87,7 +87,9 @@
 #include "rng.h"
 #include "supervise.h"
 #ifdef USE_SECP256K1_ZKP
+#include "ble/messages.h"
 #include "zkp_context.h"
+
 #endif
 
 // from util.s
@@ -172,6 +174,8 @@ int main(void) {
 #ifdef USE_BLE
   dfu_init();
   ble_comm_init();
+  send_state_request();
+  wait_for_answer();
 #endif
 
 #if !defined TREZOR_MODEL_1

core/embed/lib/ble/int_comm_defs.h

@@ -15,24 +15,23 @@
 #define EXTERNAL_MESSAGE (0xA1)
 #define INTERNAL_MESSAGE (0xA0)
 
-
 typedef struct {
-    uint8_t msg_id;
-    uint8_t connected;
-    uint8_t advertising;
-    uint8_t advertising_whitelist;
+  uint8_t msg_id;
+  uint8_t connected;
+  uint8_t advertising;
+  uint8_t advertising_whitelist;
 
-    uint8_t peer_count;
-    uint8_t reserved[2];
-    uint8_t sd_version_number;
+  uint8_t peer_count;
+  uint8_t reserved[2];
+  uint8_t sd_version_number;
 
-    uint16_t sd_company_id;
-    uint16_t sd_subversion_number;
+  uint16_t sd_company_id;
+  uint16_t sd_subversion_number;
 
-    uint32_t app_version;
-    uint32_t bld_version;
+  uint32_t app_version;
+  uint32_t bld_version;
 
-}event_status_msg_t;
+} event_status_msg_t;
 
 typedef enum {
   INTERNAL_EVENT_STATUS = 0x01,

core/embed/lib/ble/messages.c

@@ -1,10 +1,54 @@
 
 #include <stdint.h>
+#include <string.h>
 
 #include "ble.h"
 #include "common.h"
 #include "int_comm_defs.h"
 #include "messages.h"
+#include "state.h"
+
+void process_poll(uint8_t *data, uint32_t len) {
+  uint8_t cmd = data[0];
+
+  switch (cmd) {
+    //    case INTERNAL_EVENT_INITIALIZED: {
+    //      set_connected(false);
+    //      set_initialized(true);
+    //      break;
+    //    }
+    case INTERNAL_EVENT_STATUS: {
+      event_status_msg_t *msg = (event_status_msg_t *)data;
+      set_status(msg);
+      set_initialized(true);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+bool wait_for_answer(void) {
+  uint8_t buf[64] = {0};
+
+  uint32_t ticks_start = hal_ticks_ms();
+  int len = 0;
+
+  while (len == 0) {
+    if (hal_ticks_ms() - ticks_start > 1000) {
+      // timeout
+      return false;
+    }
+
+    len = ble_int_event_receive(buf, sizeof(buf));
+
+    if (len > 0) {
+      process_poll(buf, len);
+    }
+  }
+
+  return true;
+}
 
 void send_state_request(void) {
   uint8_t cmd = INTERNAL_CMD_SEND_STATE;

core/embed/lib/ble/messages.h

@@ -3,6 +3,10 @@
 
 #include <stdbool.h>
 
+bool wait_for_answer(void);
+
+void process_poll(uint8_t *data, uint32_t len);
+
 void send_state_request(void);
 
 void send_advertising_on(bool whitelist);

core/embed/lib/ble/state.c

@@ -19,22 +19,21 @@ bool ble_connected(void) {
 
 void set_connected(bool connected) {}
 
-void set_status(bool connected, bool advertising, bool whitelist,
-                uint8_t count) {
-  if (ble_state_connected != connected) {
-    ble_advertising_wanted = count > 0;
+void set_status(event_status_msg_t *msg) {
+  if (ble_state_connected != msg->connected) {
+    ble_advertising_wanted = msg->peer_count > 0;
     ble_advertising_wl_wanted = true;
   }
-  ble_state_connected = connected;
+  ble_state_connected = msg->connected;
 
-  ble_peer_count = count;
-  if (count > 0 && !ble_initialized()) {
+  ble_peer_count = msg->peer_count;
+  if (msg->peer_count > 0 && !ble_initialized()) {
     ble_advertising_wanted = true;
     ble_advertising_wl_wanted = true;
   }
 
-  if (ble_advertising_wanted != advertising ||
-      (ble_advertising_wl_wanted != whitelist)) {
+  if (ble_advertising_wanted != msg->advertising ||
+      (ble_advertising_wl_wanted != msg->advertising_whitelist)) {
     if (ble_advertising_wanted) {
       send_advertising_on(ble_advertising_wl_wanted);
     }
@@ -42,8 +41,8 @@ void set_status(bool connected, bool advertising, bool whitelist,
       send_advertising_off();
     }
   }
-  ble_advertising = advertising;
-  ble_advertising_wl = whitelist;
+  ble_advertising = msg->advertising;
+  ble_advertising_wl = msg->advertising_whitelist;
 }
 
 void set_initialized(bool initialized) { ble_state_initialized = initialized; }

core/embed/lib/ble/state.h

@@ -5,14 +5,15 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "int_comm_defs.h"
+
 bool ble_initialized(void);
 
 void set_initialized(bool initialized);
 
 bool ble_connected(void);
 
-void set_status(bool connected, bool advertising, bool whitelist,
-                uint8_t count);
+void set_status(event_status_msg_t *msg);
 
 void start_advertising(bool whitelist);
 

core/embed/trezorhal/stm32f4/ble.c

@@ -196,25 +196,6 @@ void ble_int_comm_send(uint8_t *data, uint32_t len, uint8_t message_type) {
   HAL_UART_Transmit(&urt, &eom, 1, 1);
 }
 
-void process_poll(uint8_t *data, uint32_t len) {
-  uint8_t cmd = data[0];
-
-  switch (cmd) {
-      //    case INTERNAL_EVENT_INITIALIZED: {
-      //      set_connected(false);
-      //      set_initialized(true);
-      //      break;
-      //    }
-    case INTERNAL_EVENT_STATUS: {
-      set_status(data[1], data[2], data[3], data[4]);
-      set_initialized(true);
-      break;
-    }
-    default:
-      break;
-  }
-}
-
 void flush_line(void) {
   while (urt.Instance->SR & USART_SR_RXNE) {
     (void)urt.Instance->DR;