Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-22 05:14:46 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev' of https://github.com/flipperdevices/flipperzero-firmware into xfw-dev

Browse Source
This commit is contained in:
Willy-JL
2024-02-16 11:27:05 +00:00
parent 7288499d13 60a9d7e6cf
commit ef3cfea721
91 changed files with 3578 additions and 2228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

321
targets/f7/furi_hal/furi_hal_bt.c
View File

@@ -1,8 +1,13 @@
#include "ble_glue.h"
#include <core/check.h>
#include <gap.h>
#include <furi_hal_bt.h>
#include <furi_ble/profile_interface.h>
#include <ble/ble.h>
#include <interface/patterns/ble_thread/shci/shci.h>
#include <stdbool.h>
#include <stm32wbxx.h>
#include <stm32wbxx_ll_hsem.h>
@@ -10,94 +15,30 @@
#include <furi_hal_version.h>
#include <furi_hal_power.h>
#include <furi_hal_bt_hid.h>
#include <furi_hal_bt_serial.h>
#include <furi_hal_bus.c>
#include <services/battery_service.h>
#include <furi.h>
#define TAG "FuriHalBt"
#define furi_hal_bt_DEFAULT_MAC_ADDR \
{ 0x6c, 0x7a, 0xd8, 0xac, 0x57, 0x72 }
/* Time, in ms, to wait for mode transition before crashing */
#define C2_MODE_SWITCH_TIMEOUT 10000
#define FURI_HAL_BT_HARDFAULT_INFO_MAGIC 0x1170FD0F
typedef struct {
FuriMutex* core2_mtx;
FuriTimer* hardfault_check_timer;
FuriHalBtStack stack;
} FuriHalBt;
static FuriHalBt furi_hal_bt = {
.core2_mtx = NULL,
.hardfault_check_timer = NULL,
.stack = FuriHalBtStackUnknown,
};
typedef void (*FuriHalBtProfileStart)(void);
typedef void (*FuriHalBtProfileStop)(void);
typedef struct {
FuriHalBtProfileStart start;
FuriHalBtProfileStart stop;
GapConfig config;
uint16_t appearance_char;
uint16_t advertise_service_uuid;
} FuriHalBtProfileConfig;
FuriHalBtProfileConfig profile_config[FuriHalBtProfileNumber] = {
[FuriHalBtProfileSerial] =
{
.start = furi_hal_bt_serial_start,
.stop = furi_hal_bt_serial_stop,
.config =
{
.adv_service_uuid = 0x3080,
.appearance_char = 0x8600,
.bonding_mode = true,
.pairing_method = GapPairingPinCodeShow,
.mac_address = FURI_HAL_BT_DEFAULT_MAC_ADDR,
.conn_param =
{
.conn_int_min = 0x18, // 30 ms
.conn_int_max = 0x24, // 45 ms
.slave_latency = 0,
.supervisor_timeout = 0,
},
},
},
[FuriHalBtProfileHidKeyboard] =
{
.start = furi_hal_bt_hid_start,
.stop = furi_hal_bt_hid_stop,
.config =
{
.adv_service_uuid = HUMAN_INTERFACE_DEVICE_SERVICE_UUID,
.appearance_char = GAP_APPEARANCE_KEYBOARD,
.bonding_mode = true,
.pairing_method = GapPairingPinCodeVerifyYesNo,
.mac_address = FURI_HAL_BT_DEFAULT_MAC_ADDR,
.conn_param =
{
.conn_int_min = 0x18, // 30 ms
.conn_int_max = 0x24, // 45 ms
.slave_latency = 0,
.supervisor_timeout = 0,
},
},
},
};
FuriHalBtProfileConfig* current_profile = NULL;
static void furi_hal_bt_hardfault_check(void* context) {
UNUSED(context);
if(furi_hal_bt_get_hardfault_info()) {
furi_crash("ST(R) Copro(R) HardFault");
}
}
void furi_hal_bt_init() {
FURI_LOG_I(TAG, "Start BT initialization");
furi_hal_bus_enable(FuriHalBusHSEM);
furi_hal_bus_enable(FuriHalBusIPCC);
furi_hal_bus_enable(FuriHalBusAES2);
@@ -109,12 +50,6 @@ void furi_hal_bt_init() {
furi_assert(furi_hal_bt.core2_mtx);
}
if(!furi_hal_bt.hardfault_check_timer) {
furi_hal_bt.hardfault_check_timer =
furi_timer_alloc(furi_hal_bt_hardfault_check, FuriTimerTypePeriodic, NULL);
furi_timer_start(furi_hal_bt.hardfault_check_timer, 5000);
}
// Explicitly tell that we are in charge of CLK48 domain
furi_check(LL_HSEM_1StepLock(HSEM, CFG_HW_CLK48_CONFIG_SEMID) == 0);
@@ -165,7 +100,6 @@ bool furi_hal_bt_start_radio_stack() {
// Wait until C2 is started or timeout
if(!ble_glue_wait_for_c2_start(FURI_HAL_BT_C2_START_TIMEOUT)) {
FURI_LOG_E(TAG, "Core2 start failed");
ble_glue_thread_stop();
break;
}
@@ -184,14 +118,15 @@ bool furi_hal_bt_start_radio_stack() {
// Starting radio stack
if(!ble_glue_start()) {
FURI_LOG_E(TAG, "Failed to start radio stack");
ble_glue_thread_stop();
ble_app_thread_stop();
ble_app_deinit();
ble_glue_stop();
break;
}
res = true;
} while(false);
furi_mutex_release(furi_hal_bt.core2_mtx);
gap_extra_beacon_init();
return res;
}
@@ -199,7 +134,7 @@ FuriHalBtStack furi_hal_bt_get_radio_stack() {
return furi_hal_bt.stack;
}
bool furi_hal_bt_is_ble_gatt_gap_supported() {
bool furi_hal_bt_is_gatt_gap_supported() {
if(furi_hal_bt.stack == FuriHalBtStackLight || furi_hal_bt.stack == FuriHalBtStackFull) {
return true;
} else {
@@ -215,69 +150,52 @@ bool furi_hal_bt_is_testing_supported() {
}
}
bool furi_hal_bt_start_app(FuriHalBtProfile profile, GapEventCallback event_cb, void* context) {
static FuriHalBleProfileBase* current_profile = NULL;
static GapConfig current_config = {0};
bool furi_hal_bt_check_profile_type(
FuriHalBleProfileBase* profile,
const FuriHalBleProfileTemplate* profile_template) {
if(!profile || !profile_template) {
return false;
}
return profile->config == profile_template;
}
FuriHalBleProfileBase* furi_hal_bt_start_app(
const FuriHalBleProfileTemplate* profile_template,
FuriHalBleProfileParams params,
GapEventCallback event_cb,
void* context) {
furi_assert(event_cb);
furi_assert(profile < FuriHalBtProfileNumber);
bool ret = false;
furi_check(profile_template);
furi_check(current_profile == NULL);
do {
if(!ble_glue_is_radio_stack_ready()) {
FURI_LOG_E(TAG, "Can't start BLE App - radio stack did not start");
break;
}
if(!furi_hal_bt_is_ble_gatt_gap_supported()) {
if(!furi_hal_bt_is_gatt_gap_supported()) {
FURI_LOG_E(TAG, "Can't start Ble App - unsupported radio stack");
break;
}
GapConfig* config = &profile_config[profile].config;
// Configure GAP
if(profile == FuriHalBtProfileSerial) {
// Set mac address
memcpy(
config->mac_address, furi_hal_version_get_ble_mac(), sizeof(config->mac_address));
// Set advertise name
strlcpy(
config->adv_name,
furi_hal_version_get_ble_local_device_name_ptr(),
FURI_HAL_VERSION_DEVICE_NAME_LENGTH);
config->adv_service_uuid |= furi_hal_version_get_hw_color();
} else if(profile == FuriHalBtProfileHidKeyboard) {
// Change MAC address for HID profile
const uint8_t* normal_mac = furi_hal_version_get_ble_mac();
uint8_t empty_mac[sizeof(config->mac_address)] = FURI_HAL_BT_EMPTY_MAC_ADDR;
uint8_t default_mac[sizeof(config->mac_address)] = FURI_HAL_BT_DEFAULT_MAC_ADDR;
if(memcmp(config->mac_address, empty_mac, sizeof(config->mac_address)) == 0 ||
memcmp(config->mac_address, normal_mac, sizeof(config->mac_address)) == 0 ||
memcmp(config->mac_address, default_mac, sizeof(config->mac_address)) == 0) {
memcpy(config->mac_address, normal_mac, sizeof(config->mac_address));
config->mac_address[2]++;
}
// Change name Flipper -> Control
if(strnlen(config->adv_name, FURI_HAL_VERSION_DEVICE_NAME_LENGTH) < 2 ||
strnlen(config->adv_name + 1, FURI_HAL_VERSION_DEVICE_NAME_LENGTH - 1) < 1) {
snprintf(
config->adv_name,
FURI_HAL_VERSION_DEVICE_NAME_LENGTH,
"%cControl %s",
AD_TYPE_COMPLETE_LOCAL_NAME,
furi_hal_version_get_name_ptr());
}
}
if(!gap_init(config, event_cb, context)) {
profile_template->get_gap_config(&current_config, params);
if(!gap_init(&current_config, event_cb, context)) {
gap_thread_stop();
FURI_LOG_E(TAG, "Failed to init GAP");
break;
}
// Start selected profile services
if(furi_hal_bt_is_ble_gatt_gap_supported()) {
profile_config[profile].start();
if(furi_hal_bt_is_gatt_gap_supported()) {
current_profile = profile_template->start(params);
}
ret = true;
} while(false);
current_profile = &profile_config[profile];
return ret;
return current_profile;
}
void furi_hal_bt_reinit() {
@@ -285,21 +203,25 @@ void furi_hal_bt_reinit() {
FURI_LOG_I(TAG, "Disconnect and stop advertising");
furi_hal_bt_stop_advertising();
FURI_LOG_I(TAG, "Stop current profile services");
current_profile->stop();
if(current_profile) {
FURI_LOG_I(TAG, "Stop current profile services");
current_profile->config->stop(current_profile);
current_profile = NULL;
}
// Magic happens here
hci_reset();
FURI_LOG_I(TAG, "Stop BLE related RTOS threads");
ble_app_thread_stop();
gap_thread_stop();
ble_app_deinit();
FURI_LOG_I(TAG, "Reset SHCI");
furi_check(ble_glue_reinit_c2());
ble_glue_stop();
// enterprise delay
furi_delay_ms(100);
ble_glue_thread_stop();
furi_hal_bus_disable(FuriHalBusHSEM);
furi_hal_bus_disable(FuriHalBusIPCC);
@@ -307,25 +229,20 @@ void furi_hal_bt_reinit() {
furi_hal_bus_disable(FuriHalBusPKA);
furi_hal_bus_disable(FuriHalBusCRC);
FURI_LOG_I(TAG, "Start BT initialization");
furi_hal_bt_init();
furi_hal_bt_start_radio_stack();
furi_hal_power_insomnia_exit();
}
bool furi_hal_bt_change_app(FuriHalBtProfile profile, GapEventCallback event_cb, void* context) {
FuriHalBleProfileBase* furi_hal_bt_change_app(
const FuriHalBleProfileTemplate* profile_template,
FuriHalBleProfileParams profile_params,
GapEventCallback event_cb,
void* context) {
furi_assert(event_cb);
furi_assert(profile < FuriHalBtProfileNumber);
bool ret = true;
furi_hal_bt_reinit();
ret = furi_hal_bt_start_app(profile, event_cb, context);
if(ret) {
current_profile = &profile_config[profile];
}
return ret;
return furi_hal_bt_start_app(profile_template, profile_params, event_cb, context);
}
bool furi_hal_bt_is_active() {
@@ -352,15 +269,11 @@ void furi_hal_bt_stop_advertising() {
}
void furi_hal_bt_update_battery_level(uint8_t battery_level) {
if(battery_svc_is_started()) {
battery_svc_update_level(battery_level);
}
ble_svc_battery_state_update(&battery_level, NULL);
}
void furi_hal_bt_update_power_state() {
if(battery_svc_is_started()) {
battery_svc_update_power_state();
}
void furi_hal_bt_update_power_state(bool charging) {
ble_svc_battery_state_update(NULL, &charging);
}
void furi_hal_bt_get_key_storage_buff(uint8_t** key_buff_addr, uint16_t* key_buff_size) {
@@ -489,50 +402,6 @@ uint32_t furi_hal_bt_get_conn_rssi(uint8_t* rssi) {
return since;
}
bool furi_hal_bt_custom_adv_set(const uint8_t* adv_data, size_t adv_len) {
tBleStatus status = aci_gap_additional_beacon_set_data(adv_len, adv_data);
if(status) {
FURI_LOG_E(TAG, "custom_adv_set failed %d", status);
return false;
} else {
FURI_LOG_D(TAG, "custom_adv_set success");
return true;
}
}
bool furi_hal_bt_custom_adv_start(
uint16_t min_interval,
uint16_t max_interval,
uint8_t mac_type,
const uint8_t mac_addr[GAP_MAC_ADDR_SIZE],
uint8_t power_amp_level) {
tBleStatus status = aci_gap_additional_beacon_start(
min_interval / 0.625, // Millis to gap time
max_interval / 0.625, // Millis to gap time
0b00000111, // All 3 channels
mac_type,
mac_addr,
power_amp_level);
if(status) {
FURI_LOG_E(TAG, "custom_adv_start failed %d", status);
return false;
} else {
FURI_LOG_D(TAG, "custom_adv_start success");
return true;
}
}
bool furi_hal_bt_custom_adv_stop() {
tBleStatus status = aci_gap_additional_beacon_stop();
if(status) {
FURI_LOG_E(TAG, "custom_adv_stop failed %d", status);
return false;
} else {
FURI_LOG_D(TAG, "custom_adv_stop success");
return true;
}
}
void furi_hal_bt_reverse_mac_addr(uint8_t mac_addr[GAP_MAC_ADDR_SIZE]) {
uint8_t tmp;
for(size_t i = 0; i < GAP_MAC_ADDR_SIZE / 2; i++) {
@@ -542,49 +411,6 @@ void furi_hal_bt_reverse_mac_addr(uint8_t mac_addr[GAP_MAC_ADDR_SIZE]) {
}
}
void furi_hal_bt_set_profile_adv_name(
FuriHalBtProfile profile,
const char name[FURI_HAL_BT_ADV_NAME_LENGTH]) {
furi_assert(profile < FuriHalBtProfileNumber);
furi_assert(name);
if(strlen(name) == 0) {
memset(&(profile_config[profile].config.adv_name[1]), 0, FURI_HAL_BT_ADV_NAME_LENGTH);
} else {
profile_config[profile].config.adv_name[0] = AD_TYPE_COMPLETE_LOCAL_NAME;
strlcpy(&(profile_config[profile].config.adv_name[1]), name, FURI_HAL_BT_ADV_NAME_LENGTH);
}
}
const char* furi_hal_bt_get_profile_adv_name(FuriHalBtProfile profile) {
furi_assert(profile < FuriHalBtProfileNumber);
return &(profile_config[profile].config.adv_name[1]);
}
void furi_hal_bt_set_profile_mac_addr(
FuriHalBtProfile profile,
const uint8_t mac_addr[GAP_MAC_ADDR_SIZE]) {
furi_assert(profile < FuriHalBtProfileNumber);
furi_assert(mac_addr);
memcpy(profile_config[profile].config.mac_address, mac_addr, GAP_MAC_ADDR_SIZE);
}
const uint8_t* furi_hal_bt_get_profile_mac_addr(FuriHalBtProfile profile) {
furi_assert(profile < FuriHalBtProfileNumber);
return profile_config[profile].config.mac_address;
}
void furi_hal_bt_set_profile_pairing_method(FuriHalBtProfile profile, GapPairing pairing_method) {
furi_assert(profile < FuriHalBtProfileNumber);
profile_config[profile].config.pairing_method = pairing_method;
}
GapPairing furi_hal_bt_get_profile_pairing_method(FuriHalBtProfile profile) {
furi_assert(profile < FuriHalBtProfileNumber);
return profile_config[profile].config.pairing_method;
}
uint32_t furi_hal_bt_get_transmitted_packets() {
uint32_t packets = 0;
aci_hal_le_tx_test_packet_number(&packets);
@@ -610,11 +436,30 @@ bool furi_hal_bt_ensure_c2_mode(BleGlueC2Mode mode) {
return false;
}
const FuriHalBtHardfaultInfo* furi_hal_bt_get_hardfault_info() {
/* AN5289, 4.8.2 */
const FuriHalBtHardfaultInfo* info = (FuriHalBtHardfaultInfo*)(SRAM2A_BASE);
if(info->magic != FURI_HAL_BT_HARDFAULT_INFO_MAGIC) {
return NULL;
}
return info;
bool furi_hal_bt_extra_beacon_set_data(const uint8_t* data, uint8_t len) {
return gap_extra_beacon_set_data(data, len);
}
uint8_t furi_hal_bt_extra_beacon_get_data(uint8_t* data) {
return gap_extra_beacon_get_data(data);
}
bool furi_hal_bt_extra_beacon_set_config(const GapExtraBeaconConfig* config) {
return gap_extra_beacon_set_config(config);
}
const GapExtraBeaconConfig* furi_hal_bt_extra_beacon_get_config() {
return gap_extra_beacon_get_config();
}
bool furi_hal_bt_extra_beacon_start() {
return gap_extra_beacon_start();
}
bool furi_hal_bt_extra_beacon_stop() {
return gap_extra_beacon_stop();
}
bool furi_hal_bt_extra_beacon_is_active() {
return gap_extra_beacon_get_state() == GapExtraBeaconStateStarted;
}