2022-01-05 19:10:18 +03:00
|
|
|
#include <furi_hal_bt.h>
|
2022-08-22 20:06:17 +03:00
|
|
|
|
|
|
|
#include <ble/ble.h>
|
|
|
|
#include <interface/patterns/ble_thread/shci/shci.h>
|
2021-05-18 12:23:14 +03:00
|
|
|
#include <stm32wbxx.h>
|
2021-10-12 19:41:42 +03:00
|
|
|
|
2022-01-05 19:10:18 +03:00
|
|
|
#include <furi_hal_version.h>
|
|
|
|
#include <furi_hal_bt_hid.h>
|
|
|
|
#include <furi_hal_bt_serial.h>
|
2023-05-29 19:05:57 +03:00
|
|
|
#include <furi_hal_bus.c>
|
2023-06-14 03:18:24 +03:00
|
|
|
#include "battery_service.h"
|
|
|
|
|
2021-10-12 19:41:42 +03:00
|
|
|
#include <furi.h>
|
2021-05-18 12:23:14 +03:00
|
|
|
|
2021-11-13 05:41:54 +03:00
|
|
|
#define TAG "FuriHalBt"
|
|
|
|
|
2022-04-27 18:53:48 +03:00
|
|
|
/* Time, in ms, to wait for mode transition before crashing */
|
|
|
|
#define C2_MODE_SWITCH_TIMEOUT 10000
|
|
|
|
|
2023-05-09 01:31:39 +03:00
|
|
|
#define FURI_HAL_BT_HARDFAULT_INFO_MAGIC 0x1170FD0F
|
|
|
|
|
2023-06-30 12:52:43 +03:00
|
|
|
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,
|
|
|
|
};
|
2021-11-04 20:26:41 +03:00
|
|
|
|
2021-12-08 14:28:01 +03:00
|
|
|
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] = {
|
2022-01-05 19:10:18 +03:00
|
|
|
[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,
|
2022-01-21 20:32:03 +03:00
|
|
|
.conn_param =
|
|
|
|
{
|
2022-03-31 17:57:23 +03:00
|
|
|
.conn_int_min = 0x18, // 30 ms
|
|
|
|
.conn_int_max = 0x24, // 45 ms
|
2022-01-21 20:32:03 +03:00
|
|
|
.slave_latency = 0,
|
2022-02-09 15:03:27 +03:00
|
|
|
.supervisor_timeout = 0,
|
2022-01-21 20:32:03 +03:00
|
|
|
},
|
2022-01-05 19:10:18 +03:00
|
|
|
},
|
2021-12-08 14:28:01 +03:00
|
|
|
},
|
2022-01-05 19:10:18 +03:00
|
|
|
[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,
|
2022-01-21 20:32:03 +03:00
|
|
|
.conn_param =
|
|
|
|
{
|
2022-03-31 17:57:23 +03:00
|
|
|
.conn_int_min = 0x18, // 30 ms
|
|
|
|
.conn_int_max = 0x24, // 45 ms
|
|
|
|
.slave_latency = 0,
|
|
|
|
.supervisor_timeout = 0,
|
2022-01-21 20:32:03 +03:00
|
|
|
},
|
2022-01-05 19:10:18 +03:00
|
|
|
},
|
2021-12-08 14:28:01 +03:00
|
|
|
},
|
|
|
|
};
|
|
|
|
FuriHalBtProfileConfig* current_profile = NULL;
|
|
|
|
|
2023-06-30 12:52:43 +03:00
|
|
|
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");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
void furi_hal_bt_init() {
|
2023-05-29 19:05:57 +03:00
|
|
|
furi_hal_bus_enable(FuriHalBusHSEM);
|
|
|
|
furi_hal_bus_enable(FuriHalBusIPCC);
|
|
|
|
furi_hal_bus_enable(FuriHalBusAES2);
|
|
|
|
furi_hal_bus_enable(FuriHalBusPKA);
|
2023-06-02 23:59:19 +03:00
|
|
|
furi_hal_bus_enable(FuriHalBusCRC);
|
2023-05-29 19:05:57 +03:00
|
|
|
|
2023-06-30 12:52:43 +03:00
|
|
|
if(!furi_hal_bt.core2_mtx) {
|
|
|
|
furi_hal_bt.core2_mtx = furi_mutex_alloc(FuriMutexTypeNormal);
|
|
|
|
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);
|
2021-12-08 14:28:01 +03:00
|
|
|
}
|
2021-11-13 05:41:54 +03:00
|
|
|
|
|
|
|
// Explicitly tell that we are in charge of CLK48 domain
|
2023-04-25 23:11:42 +03:00
|
|
|
furi_check(LL_HSEM_1StepLock(HSEM, CFG_HW_CLK48_CONFIG_SEMID) == 0);
|
2021-11-13 05:41:54 +03:00
|
|
|
|
|
|
|
// Start Core2
|
|
|
|
ble_glue_init();
|
2021-11-04 20:26:41 +03:00
|
|
|
}
|
|
|
|
|
2021-11-10 12:53:00 +03:00
|
|
|
void furi_hal_bt_lock_core2() {
|
2023-06-30 12:52:43 +03:00
|
|
|
furi_assert(furi_hal_bt.core2_mtx);
|
|
|
|
furi_check(furi_mutex_acquire(furi_hal_bt.core2_mtx, FuriWaitForever) == FuriStatusOk);
|
2021-11-10 12:53:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void furi_hal_bt_unlock_core2() {
|
2023-06-30 12:52:43 +03:00
|
|
|
furi_assert(furi_hal_bt.core2_mtx);
|
|
|
|
furi_check(furi_mutex_release(furi_hal_bt.core2_mtx) == FuriStatusOk);
|
2021-11-10 12:53:00 +03:00
|
|
|
}
|
|
|
|
|
2022-04-27 18:53:48 +03:00
|
|
|
static bool furi_hal_bt_radio_stack_is_supported(const BleGlueC2Info* info) {
|
2022-01-03 01:36:42 +03:00
|
|
|
bool supported = false;
|
2022-06-09 12:07:42 +03:00
|
|
|
if(info->StackType == INFO_STACK_TYPE_BLE_LIGHT) {
|
2022-01-03 01:36:42 +03:00
|
|
|
if(info->VersionMajor >= FURI_HAL_BT_STACK_VERSION_MAJOR &&
|
|
|
|
info->VersionMinor >= FURI_HAL_BT_STACK_VERSION_MINOR) {
|
2023-06-30 12:52:43 +03:00
|
|
|
furi_hal_bt.stack = FuriHalBtStackLight;
|
2022-01-03 01:36:42 +03:00
|
|
|
supported = true;
|
2022-01-05 19:10:18 +03:00
|
|
|
}
|
2022-06-09 12:07:42 +03:00
|
|
|
} else if(info->StackType == INFO_STACK_TYPE_BLE_FULL) {
|
|
|
|
if(info->VersionMajor >= FURI_HAL_BT_STACK_VERSION_MAJOR &&
|
|
|
|
info->VersionMinor >= FURI_HAL_BT_STACK_VERSION_MINOR) {
|
2023-06-30 12:52:43 +03:00
|
|
|
furi_hal_bt.stack = FuriHalBtStackFull;
|
2022-06-09 12:07:42 +03:00
|
|
|
supported = true;
|
|
|
|
}
|
2022-01-03 01:36:42 +03:00
|
|
|
} else {
|
2023-06-30 12:52:43 +03:00
|
|
|
furi_hal_bt.stack = FuriHalBtStackUnknown;
|
2022-01-03 01:36:42 +03:00
|
|
|
}
|
|
|
|
return supported;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool furi_hal_bt_start_radio_stack() {
|
|
|
|
bool res = false;
|
2023-06-30 12:52:43 +03:00
|
|
|
furi_assert(furi_hal_bt.core2_mtx);
|
2021-11-04 20:26:41 +03:00
|
|
|
|
2023-06-30 12:52:43 +03:00
|
|
|
furi_mutex_acquire(furi_hal_bt.core2_mtx, FuriWaitForever);
|
2022-01-03 01:36:42 +03:00
|
|
|
|
2021-05-18 12:23:14 +03:00
|
|
|
// Explicitly tell that we are in charge of CLK48 domain
|
2023-04-25 23:11:42 +03:00
|
|
|
furi_check(LL_HSEM_1StepLock(HSEM, CFG_HW_CLK48_CONFIG_SEMID) == 0);
|
2022-01-03 01:36:42 +03:00
|
|
|
|
|
|
|
do {
|
2022-04-27 18:53:48 +03:00
|
|
|
// 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");
|
2022-01-03 01:36:42 +03:00
|
|
|
ble_glue_thread_stop();
|
|
|
|
break;
|
|
|
|
}
|
2022-04-27 18:53:48 +03:00
|
|
|
|
|
|
|
// If C2 is running, start radio stack fw
|
|
|
|
if(!furi_hal_bt_ensure_c2_mode(BleGlueC2ModeStack)) {
|
|
|
|
break;
|
2022-01-14 11:39:41 +03:00
|
|
|
}
|
2022-04-27 18:53:48 +03:00
|
|
|
|
|
|
|
// Check whether we support radio stack
|
|
|
|
const BleGlueC2Info* c2_info = ble_glue_get_c2_info();
|
|
|
|
if(!furi_hal_bt_radio_stack_is_supported(c2_info)) {
|
2022-01-03 01:36:42 +03:00
|
|
|
FURI_LOG_E(TAG, "Unsupported radio stack");
|
2022-01-14 11:39:41 +03:00
|
|
|
// Don't stop SHCI for crypto enclave support
|
2022-01-05 19:10:18 +03:00
|
|
|
break;
|
2022-01-03 01:36:42 +03:00
|
|
|
}
|
|
|
|
// Starting radio stack
|
|
|
|
if(!ble_glue_start()) {
|
|
|
|
FURI_LOG_E(TAG, "Failed to start radio stack");
|
|
|
|
ble_glue_thread_stop();
|
|
|
|
ble_app_thread_stop();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
res = true;
|
|
|
|
} while(false);
|
2023-06-30 12:52:43 +03:00
|
|
|
furi_mutex_release(furi_hal_bt.core2_mtx);
|
2021-11-13 05:41:54 +03:00
|
|
|
|
2022-01-03 01:36:42 +03:00
|
|
|
return res;
|
2021-05-18 12:23:14 +03:00
|
|
|
}
|
|
|
|
|
2022-01-03 01:36:42 +03:00
|
|
|
FuriHalBtStack furi_hal_bt_get_radio_stack() {
|
2023-06-30 12:52:43 +03:00
|
|
|
return furi_hal_bt.stack;
|
2022-01-03 01:36:42 +03:00
|
|
|
}
|
|
|
|
|
2022-06-09 12:07:42 +03:00
|
|
|
bool furi_hal_bt_is_ble_gatt_gap_supported() {
|
2023-06-30 12:52:43 +03:00
|
|
|
if(furi_hal_bt.stack == FuriHalBtStackLight || furi_hal_bt.stack == FuriHalBtStackFull) {
|
2022-06-09 12:07:42 +03:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool furi_hal_bt_is_testing_supported() {
|
2023-06-30 12:52:43 +03:00
|
|
|
if(furi_hal_bt.stack == FuriHalBtStackFull) {
|
2022-06-09 12:07:42 +03:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-03 01:36:42 +03:00
|
|
|
bool furi_hal_bt_start_app(FuriHalBtProfile profile, GapEventCallback event_cb, void* context) {
|
2021-12-08 14:28:01 +03:00
|
|
|
furi_assert(event_cb);
|
|
|
|
furi_assert(profile < FuriHalBtProfileNumber);
|
2022-01-03 01:36:42 +03:00
|
|
|
bool ret = false;
|
2021-12-08 14:28:01 +03:00
|
|
|
|
|
|
|
do {
|
2022-01-03 01:36:42 +03:00
|
|
|
if(!ble_glue_is_radio_stack_ready()) {
|
|
|
|
FURI_LOG_E(TAG, "Can't start BLE App - radio stack did not start");
|
|
|
|
break;
|
|
|
|
}
|
2022-06-09 12:07:42 +03:00
|
|
|
if(!furi_hal_bt_is_ble_gatt_gap_supported()) {
|
2022-01-03 01:36:42 +03:00
|
|
|
FURI_LOG_E(TAG, "Can't start Ble App - unsupported radio stack");
|
2021-12-08 14:28:01 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
GapConfig* config = &profile_config[profile].config;
|
2023-05-13 00:14:22 +03:00
|
|
|
// Configure GAP
|
2021-12-08 14:28:01 +03:00
|
|
|
if(profile == FuriHalBtProfileSerial) {
|
2023-05-13 00:14:22 +03:00
|
|
|
// Set mac address
|
|
|
|
memcpy(
|
|
|
|
config->mac_address, furi_hal_version_get_ble_mac(), sizeof(config->mac_address));
|
2023-07-05 15:04:56 +03:00
|
|
|
// Set advertise name
|
|
|
|
strlcpy(
|
|
|
|
config->adv_name,
|
|
|
|
furi_hal_version_get_ble_local_device_name_ptr(),
|
|
|
|
FURI_HAL_BT_ADV_NAME_LENGTH);
|
2023-05-13 00:14:22 +03:00
|
|
|
|
2021-12-08 14:28:01 +03:00
|
|
|
config->adv_service_uuid |= furi_hal_version_get_hw_color();
|
|
|
|
} else if(profile == FuriHalBtProfileHidKeyboard) {
|
|
|
|
// Change MAC address for HID profile
|
2023-05-13 00:14:22 +03:00
|
|
|
const uint8_t* normal_mac = furi_hal_version_get_ble_mac();
|
2023-07-05 14:41:28 +03:00
|
|
|
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) {
|
2023-05-13 00:14:22 +03:00
|
|
|
memcpy(config->mac_address, normal_mac, sizeof(config->mac_address));
|
|
|
|
config->mac_address[2]++;
|
|
|
|
}
|
2022-07-08 15:36:34 +03:00
|
|
|
// Change name Flipper -> Control
|
2023-07-05 14:41:28 +03:00
|
|
|
if(strnlen(config->adv_name, FURI_HAL_BT_ADV_NAME_LENGTH) < 2 ||
|
|
|
|
strnlen(config->adv_name + 1, FURI_HAL_BT_ADV_NAME_LENGTH - 1) < 1) {
|
2023-05-13 00:14:22 +03:00
|
|
|
snprintf(
|
|
|
|
config->adv_name,
|
2023-07-05 14:41:28 +03:00
|
|
|
FURI_HAL_BT_ADV_NAME_LENGTH,
|
2023-05-13 00:14:22 +03:00
|
|
|
"%cControl %s",
|
2023-07-05 14:41:28 +03:00
|
|
|
AD_TYPE_COMPLETE_LOCAL_NAME,
|
|
|
|
furi_hal_version_get_name_ptr());
|
2023-05-13 00:14:22 +03:00
|
|
|
}
|
2021-12-08 14:28:01 +03:00
|
|
|
}
|
2022-01-03 01:36:42 +03:00
|
|
|
if(!gap_init(config, event_cb, context)) {
|
2021-12-08 14:28:01 +03:00
|
|
|
gap_thread_stop();
|
|
|
|
FURI_LOG_E(TAG, "Failed to init GAP");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Start selected profile services
|
2022-06-09 12:07:42 +03:00
|
|
|
if(furi_hal_bt_is_ble_gatt_gap_supported()) {
|
2022-01-03 01:36:42 +03:00
|
|
|
profile_config[profile].start();
|
|
|
|
}
|
|
|
|
ret = true;
|
2021-12-08 14:28:01 +03:00
|
|
|
} while(false);
|
|
|
|
current_profile = &profile_config[profile];
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
void furi_hal_bt_reinit() {
|
|
|
|
FURI_LOG_I(TAG, "Disconnect and stop advertising");
|
|
|
|
furi_hal_bt_stop_advertising();
|
2021-12-08 14:28:01 +03:00
|
|
|
|
|
|
|
FURI_LOG_I(TAG, "Stop current profile services");
|
|
|
|
current_profile->stop();
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
|
|
|
|
// Magic happens here
|
|
|
|
hci_reset();
|
|
|
|
|
2021-12-08 14:28:01 +03:00
|
|
|
FURI_LOG_I(TAG, "Stop BLE related RTOS threads");
|
|
|
|
ble_app_thread_stop();
|
|
|
|
gap_thread_stop();
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
|
2021-12-08 14:28:01 +03:00
|
|
|
FURI_LOG_I(TAG, "Reset SHCI");
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
furi_check(ble_glue_reinit_c2());
|
|
|
|
|
2022-07-20 13:56:33 +03:00
|
|
|
furi_delay_ms(100);
|
2021-12-08 14:28:01 +03:00
|
|
|
ble_glue_thread_stop();
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
|
2023-05-29 19:05:57 +03:00
|
|
|
furi_hal_bus_disable(FuriHalBusHSEM);
|
|
|
|
furi_hal_bus_disable(FuriHalBusIPCC);
|
|
|
|
furi_hal_bus_disable(FuriHalBusAES2);
|
|
|
|
furi_hal_bus_disable(FuriHalBusPKA);
|
2023-06-02 23:59:19 +03:00
|
|
|
furi_hal_bus_disable(FuriHalBusCRC);
|
2023-05-29 19:05:57 +03:00
|
|
|
|
2021-12-08 14:28:01 +03:00
|
|
|
FURI_LOG_I(TAG, "Start BT initialization");
|
|
|
|
furi_hal_bt_init();
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
|
2022-01-03 01:36:42 +03:00
|
|
|
furi_hal_bt_start_radio_stack();
|
[FL-2399, FL-2261] Tickless sleep shenanigans (#1168)
* Disable USART in sleep
* Restore UART state on suspend/resume
* FuriHal: Enable stop mode and add insomnia to I2C and SPI
* Remove IDLE interrupt
* FuriHal: add FPU isr and disable all FPU interrupt, add core2 stop mode configuration on deep sleep
* FuriHal: tie stop mode debug with debug rtc flag
* FuriHal: adjust flash latency on clock switch, tie mcu debug with RTC debug flag
* FuriHal: move resource init to early stage
* Add EXTI pending check, enable debug traps with compile-time flag
* Wrap sleep debug functions in conditional compilation
* Remove erroneous changed
* Do not use CSS, remove it from everywhere
* Enable/disable USB on VBUS connect (prototype)
* FuriHal: add LPMS and DEEPSLEEP magic, workaround state inconsistency between cores
* FuriHal: honor c1 LMPS
* USB mode switch fix
* Applications: add flags and insomnia bypass system
* Correct spelling
* FuriHal: cleanup insomnia usage, reset sleep flags on wakeup, add shutdown api
* FuriHal: extra check on reinit request
* FuriHal: rename gpio_display_rst pin to gpio_display_rst_n
* FuriHal: add debug HAL
* FuriHal: add some magic to core2 reload procedure, fix issue with crash on ble keyboard exit
* FuriHal: cleanup ble glue, add BLE_GLUE_DEBUG flag
* FuriHal: ble reinit API, move os timer to LPTIM1 for deep sleep capability, shutdown that works
* FuriHal: take insomnia while shutdown
* Remove USB switch on/off on VBUS change
* Better tick skew handling
* Improve tick consistency under load
* Add USB_HP dummy IRQ handler
* Move interrupt check closer to sleep
* Clean up includes
* Re-enable Insomnia globally
* FuriHal: enable CSS
* FuriHal: remove questionable core2 clock shenanigans
* FuriHal: use core1 RCC registers in idle timer config
* FuriHal: return back CSS handlers, add lptim isr dispatching
Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: nminaylov <nm29719@gmail.com>
2022-04-29 16:29:51 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
bool furi_hal_bt_change_app(FuriHalBtProfile profile, GapEventCallback event_cb, void* context) {
|
|
|
|
furi_assert(event_cb);
|
|
|
|
furi_assert(profile < FuriHalBtProfileNumber);
|
|
|
|
bool ret = true;
|
|
|
|
|
|
|
|
furi_hal_bt_reinit();
|
|
|
|
|
2021-12-08 14:28:01 +03:00
|
|
|
ret = furi_hal_bt_start_app(profile, event_cb, context);
|
|
|
|
if(ret) {
|
|
|
|
current_profile = &profile_config[profile];
|
|
|
|
}
|
|
|
|
return ret;
|
2021-05-18 12:23:14 +03:00
|
|
|
}
|
|
|
|
|
2022-02-07 16:37:56 +03:00
|
|
|
bool furi_hal_bt_is_active() {
|
2022-01-03 01:36:42 +03:00
|
|
|
return gap_get_state() > GapStateIdle;
|
|
|
|
}
|
|
|
|
|
2023-05-13 00:14:22 +03:00
|
|
|
bool furi_hal_bt_is_connected() {
|
|
|
|
return gap_get_state() == GapStateConnected;
|
|
|
|
}
|
|
|
|
|
2021-09-15 19:58:32 +03:00
|
|
|
void furi_hal_bt_start_advertising() {
|
|
|
|
if(gap_get_state() == GapStateIdle) {
|
|
|
|
gap_start_advertising();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void furi_hal_bt_stop_advertising() {
|
2021-09-16 19:12:07 +03:00
|
|
|
if(furi_hal_bt_is_active()) {
|
2021-09-15 19:58:32 +03:00
|
|
|
gap_stop_advertising();
|
2021-09-21 12:48:08 +03:00
|
|
|
while(furi_hal_bt_is_active()) {
|
2022-07-20 13:56:33 +03:00
|
|
|
furi_delay_tick(1);
|
2021-09-21 12:48:08 +03:00
|
|
|
}
|
2021-09-15 19:58:32 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-08 14:28:01 +03:00
|
|
|
void furi_hal_bt_update_battery_level(uint8_t battery_level) {
|
|
|
|
if(battery_svc_is_started()) {
|
|
|
|
battery_svc_update_level(battery_level);
|
2021-10-12 19:41:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-24 16:42:02 +03:00
|
|
|
void furi_hal_bt_update_power_state() {
|
|
|
|
if(battery_svc_is_started()) {
|
|
|
|
battery_svc_update_power_state();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-13 05:41:54 +03:00
|
|
|
void furi_hal_bt_get_key_storage_buff(uint8_t** key_buff_addr, uint16_t* key_buff_size) {
|
|
|
|
ble_app_get_key_storage_buff(key_buff_addr, key_buff_size);
|
2021-11-04 20:26:41 +03:00
|
|
|
}
|
|
|
|
|
2022-01-05 19:10:18 +03:00
|
|
|
void furi_hal_bt_set_key_storage_change_callback(
|
|
|
|
BleGlueKeyStorageChangedCallback callback,
|
|
|
|
void* context) {
|
2021-11-04 20:26:41 +03:00
|
|
|
furi_assert(callback);
|
|
|
|
ble_glue_set_key_storage_changed_callback(callback, context);
|
|
|
|
}
|
|
|
|
|
|
|
|
void furi_hal_bt_nvm_sram_sem_acquire() {
|
2022-03-29 20:37:23 +03:00
|
|
|
while(LL_HSEM_1StepLock(HSEM, CFG_HW_BLE_NVM_SRAM_SEMID)) {
|
2022-06-20 17:54:48 +03:00
|
|
|
furi_thread_yield();
|
2021-11-04 20:26:41 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void furi_hal_bt_nvm_sram_sem_release() {
|
2022-03-29 20:37:23 +03:00
|
|
|
LL_HSEM_ReleaseLock(HSEM, CFG_HW_BLE_NVM_SRAM_SEMID, 0);
|
2021-11-04 20:26:41 +03:00
|
|
|
}
|
|
|
|
|
2022-01-21 20:32:03 +03:00
|
|
|
bool furi_hal_bt_clear_white_list() {
|
|
|
|
furi_hal_bt_nvm_sram_sem_acquire();
|
|
|
|
tBleStatus status = aci_gap_clear_security_db();
|
|
|
|
if(status) {
|
|
|
|
FURI_LOG_E(TAG, "Clear while list failed with status %d", status);
|
|
|
|
}
|
|
|
|
furi_hal_bt_nvm_sram_sem_release();
|
|
|
|
return status != BLE_STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
void furi_hal_bt_dump_state(FuriString* buffer) {
|
2022-01-05 19:10:18 +03:00
|
|
|
if(furi_hal_bt_is_alive()) {
|
2021-05-18 12:23:14 +03:00
|
|
|
uint8_t HCI_Version;
|
|
|
|
uint16_t HCI_Revision;
|
|
|
|
uint8_t LMP_PAL_Version;
|
|
|
|
uint16_t Manufacturer_Name;
|
|
|
|
uint16_t LMP_PAL_Subversion;
|
|
|
|
|
|
|
|
tBleStatus ret = hci_read_local_version_information(
|
2022-01-05 19:10:18 +03:00
|
|
|
&HCI_Version, &HCI_Revision, &LMP_PAL_Version, &Manufacturer_Name, &LMP_PAL_Subversion);
|
2021-05-18 12:23:14 +03:00
|
|
|
|
2022-10-05 18:15:23 +03:00
|
|
|
furi_string_cat_printf(
|
2022-01-05 19:10:18 +03:00
|
|
|
buffer,
|
2021-05-18 12:23:14 +03:00
|
|
|
"Ret: %d, HCI_Version: %d, HCI_Revision: %d, LMP_PAL_Version: %d, Manufacturer_Name: %d, LMP_PAL_Subversion: %d",
|
2022-01-05 19:10:18 +03:00
|
|
|
ret,
|
|
|
|
HCI_Version,
|
|
|
|
HCI_Revision,
|
|
|
|
LMP_PAL_Version,
|
|
|
|
Manufacturer_Name,
|
|
|
|
LMP_PAL_Subversion);
|
2021-05-18 12:23:14 +03:00
|
|
|
} else {
|
2022-10-05 18:15:23 +03:00
|
|
|
furi_string_cat_printf(buffer, "BLE not ready");
|
2021-05-18 12:23:14 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
bool furi_hal_bt_is_alive() {
|
2021-11-13 05:41:54 +03:00
|
|
|
return ble_glue_is_alive();
|
2021-09-16 19:12:07 +03:00
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
void furi_hal_bt_start_tone_tx(uint8_t channel, uint8_t power) {
|
2021-05-18 12:23:14 +03:00
|
|
|
aci_hal_set_tx_power_level(0, power);
|
2021-05-29 01:57:11 +03:00
|
|
|
aci_hal_tone_start(channel, 0);
|
2021-05-18 12:23:14 +03:00
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
void furi_hal_bt_stop_tone_tx() {
|
2021-05-18 12:23:14 +03:00
|
|
|
aci_hal_tone_stop();
|
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
void furi_hal_bt_start_packet_tx(uint8_t channel, uint8_t pattern, uint8_t datarate) {
|
2021-05-29 01:57:11 +03:00
|
|
|
hci_le_enhanced_transmitter_test(channel, 0x25, pattern, datarate);
|
2021-05-18 12:23:14 +03:00
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
void furi_hal_bt_start_packet_rx(uint8_t channel, uint8_t datarate) {
|
2021-05-29 01:57:11 +03:00
|
|
|
hci_le_enhanced_receiver_test(channel, datarate, 0);
|
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
uint16_t furi_hal_bt_stop_packet_test() {
|
2021-09-02 02:22:40 +03:00
|
|
|
uint16_t num_of_packets = 0;
|
2021-05-18 12:23:14 +03:00
|
|
|
hci_le_test_end(&num_of_packets);
|
2021-05-29 01:57:11 +03:00
|
|
|
return num_of_packets;
|
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
void furi_hal_bt_start_rx(uint8_t channel) {
|
2021-05-29 01:57:11 +03:00
|
|
|
aci_hal_rx_start(channel);
|
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
float furi_hal_bt_get_rssi() {
|
2021-05-29 01:57:11 +03:00
|
|
|
float val;
|
|
|
|
uint8_t rssi_raw[3];
|
2021-07-07 00:23:59 +03:00
|
|
|
|
2022-01-05 19:10:18 +03:00
|
|
|
if(aci_hal_read_raw_rssi(rssi_raw) != BLE_STATUS_SUCCESS) {
|
2021-07-07 00:23:59 +03:00
|
|
|
return 0.0f;
|
|
|
|
}
|
2021-05-29 01:57:11 +03:00
|
|
|
|
|
|
|
// Some ST magic with rssi
|
|
|
|
uint8_t agc = rssi_raw[2] & 0xFF;
|
2021-07-07 00:23:59 +03:00
|
|
|
int rssi = (((int)rssi_raw[1] << 8) & 0xFF00) + (rssi_raw[0] & 0xFF);
|
2021-05-29 01:57:11 +03:00
|
|
|
if(rssi == 0 || agc > 11) {
|
2021-06-02 17:09:02 +03:00
|
|
|
val = -127.0;
|
2021-05-29 01:57:11 +03:00
|
|
|
} else {
|
|
|
|
val = agc * 6.0f - 127.0f;
|
|
|
|
while(rssi > 30) {
|
|
|
|
val += 6.0;
|
2022-01-05 19:10:18 +03:00
|
|
|
rssi >>= 1;
|
2021-05-29 01:57:11 +03:00
|
|
|
}
|
2022-12-26 15:13:30 +03:00
|
|
|
val += (float)((417 * rssi + 18080) >> 10);
|
2021-05-29 01:57:11 +03:00
|
|
|
}
|
|
|
|
return val;
|
2021-05-18 12:23:14 +03:00
|
|
|
}
|
|
|
|
|
2023-05-13 00:14:22 +03:00
|
|
|
/** fill the RSSI of the remote host of the bt connection and returns the last
|
|
|
|
* time the RSSI was updated
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
uint32_t furi_hal_bt_get_conn_rssi(uint8_t* rssi) {
|
|
|
|
int8_t ret_rssi = 0;
|
|
|
|
uint32_t since = gap_get_remote_conn_rssi(&ret_rssi);
|
|
|
|
|
|
|
|
if(ret_rssi == 127 || since == 0) return 0;
|
|
|
|
|
|
|
|
*rssi = (uint8_t)abs(ret_rssi);
|
|
|
|
|
|
|
|
return since;
|
|
|
|
}
|
|
|
|
|
2023-07-05 14:41:28 +03:00
|
|
|
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++) {
|
|
|
|
tmp = mac_addr[i];
|
|
|
|
mac_addr[i] = mac_addr[GAP_MAC_ADDR_SIZE - 1 - i];
|
|
|
|
mac_addr[GAP_MAC_ADDR_SIZE - 1 - i] = tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-05-13 00:14:22 +03:00
|
|
|
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) {
|
2023-07-05 14:41:28 +03:00
|
|
|
memset(&(profile_config[profile].config.adv_name[1]), 0, FURI_HAL_BT_ADV_NAME_LENGTH - 1);
|
2023-05-13 00:14:22 +03:00
|
|
|
} else {
|
|
|
|
profile_config[profile].config.adv_name[0] = AD_TYPE_COMPLETE_LOCAL_NAME;
|
2023-07-05 14:41:28 +03:00
|
|
|
strlcpy(
|
|
|
|
&(profile_config[profile].config.adv_name[1]),
|
|
|
|
name,
|
|
|
|
FURI_HAL_BT_ADV_NAME_LENGTH - 1 /* BLE symbol */);
|
2023-05-13 00:14:22 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
uint32_t furi_hal_bt_get_transmitted_packets() {
|
2021-05-29 01:57:11 +03:00
|
|
|
uint32_t packets = 0;
|
|
|
|
aci_hal_le_tx_test_packet_number(&packets);
|
|
|
|
return packets;
|
2021-05-18 12:23:14 +03:00
|
|
|
}
|
|
|
|
|
2021-08-08 21:03:25 +03:00
|
|
|
void furi_hal_bt_stop_rx() {
|
2021-05-18 12:23:14 +03:00
|
|
|
aci_hal_rx_stop();
|
|
|
|
}
|
2022-01-03 01:36:42 +03:00
|
|
|
|
2022-04-27 18:53:48 +03:00
|
|
|
bool furi_hal_bt_ensure_c2_mode(BleGlueC2Mode mode) {
|
|
|
|
BleGlueCommandResult fw_start_res = ble_glue_force_c2_mode(mode);
|
|
|
|
if(fw_start_res == BleGlueCommandResultOK) {
|
|
|
|
return true;
|
|
|
|
} else if(fw_start_res == BleGlueCommandResultRestartPending) {
|
|
|
|
// Do nothing and wait for system reset
|
2022-07-20 13:56:33 +03:00
|
|
|
furi_delay_ms(C2_MODE_SWITCH_TIMEOUT);
|
2022-04-27 18:53:48 +03:00
|
|
|
furi_crash("Waiting for FUS->radio stack transition");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
FURI_LOG_E(TAG, "Failed to switch C2 mode: %d", fw_start_res);
|
|
|
|
return false;
|
|
|
|
}
|
2023-05-09 01:31:39 +03:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|