Merge branch 'ofw-dev' into dev

2026-05-13 05:38:35 -07:00 · 2023-05-29 20:33:12 +03:00
parent b3aaffc95d 8d2ea14f06
commit 0ab530e750
64 changed files with 1335 additions and 433 deletions
--- a/firmware/targets/f7/api_symbols.csv
+++ b/firmware/targets/f7/api_symbols.csv
@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,27.0,,
+Version,+,28.1,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/cli/cli.h,,
 Header,+,applications/services/cli/cli_vcp.h,,
@@ -36,8 +36,10 @@ Header,+,applications/services/notification/notification_messages.h,,
 Header,+,applications/services/power/power_service/power.h,,
 Header,+,applications/services/rpc/rpc_app.h,,
 Header,+,applications/services/storage/storage.h,,
+Header,+,firmware/targets/f7/furi_hal/furi_hal_bus.h,,
 Header,+,firmware/targets/f7/furi_hal/furi_hal_clock.h,,
 Header,+,firmware/targets/f7/furi_hal/furi_hal_console.h,,
+Header,+,firmware/targets/f7/furi_hal/furi_hal_dma.h,,
 Header,+,firmware/targets/f7/furi_hal/furi_hal_flash.h,,
 Header,+,firmware/targets/f7/furi_hal/furi_hal_gpio.h,,
 Header,+,firmware/targets/f7/furi_hal/furi_hal_i2c_config.h,,
@@ -1090,6 +1092,12 @@ Function,+,furi_hal_bt_stop_tone_tx,void,
 Function,+,furi_hal_bt_unlock_core2,void,
 Function,+,furi_hal_bt_update_battery_level,void,uint8_t
 Function,+,furi_hal_bt_update_power_state,void,
+Function,+,furi_hal_bus_deinit_early,void,
+Function,+,furi_hal_bus_disable,void,FuriHalBus
+Function,+,furi_hal_bus_enable,void,FuriHalBus
+Function,+,furi_hal_bus_init_early,void,
+Function,+,furi_hal_bus_is_enabled,_Bool,FuriHalBus
+Function,+,furi_hal_bus_reset,void,FuriHalBus
 Function,+,furi_hal_cdc_get_ctrl_line_state,uint8_t,uint8_t
 Function,+,furi_hal_cdc_get_port_settings,usb_cdc_line_coding*,uint8_t
 Function,+,furi_hal_cdc_receive,int32_t,"uint8_t, uint8_t*, uint16_t"
@@ -1132,6 +1140,8 @@ Function,+,furi_hal_debug_disable,void,
 Function,+,furi_hal_debug_enable,void,
 Function,+,furi_hal_debug_is_gdb_session_active,_Bool,
 Function,-,furi_hal_deinit_early,void,
+Function,+,furi_hal_dma_deinit_early,void,
+Function,+,furi_hal_dma_init_early,void,
 Function,-,furi_hal_flash_erase,void,uint8_t
 Function,-,furi_hal_flash_get_base,size_t,
 Function,-,furi_hal_flash_get_cycles_count,size_t,
@@ -1300,6 +1310,7 @@ Function,+,furi_hal_pwm_start,void,"FuriHalPwmOutputId, uint32_t, uint8_t"
 Function,+,furi_hal_pwm_stop,void,FuriHalPwmOutputId
 Function,+,furi_hal_random_fill_buf,void,"uint8_t*, uint32_t"
 Function,+,furi_hal_random_get,uint32_t,
+Function,+,furi_hal_random_init,void,
 Function,+,furi_hal_region_get,const FuriHalRegion*,
 Function,+,furi_hal_region_get_band,const FuriHalRegionBand*,uint32_t
 Function,+,furi_hal_region_get_name,const char*,
@@ -1310,35 +1321,29 @@ Function,-,furi_hal_resources_deinit_early,void,
 Function,+,furi_hal_resources_get_ext_pin_number,int32_t,const GpioPin*
 Function,-,furi_hal_resources_init,void,
 Function,-,furi_hal_resources_init_early,void,
-Function,+,furi_hal_rfid_change_read_config,void,"float, float"
 Function,+,furi_hal_rfid_comp_set_callback,void,"FuriHalRfidCompCallback, void*"
 Function,+,furi_hal_rfid_comp_start,void,
 Function,+,furi_hal_rfid_comp_stop,void,
 Function,-,furi_hal_rfid_init,void,
 Function,+,furi_hal_rfid_pin_pull_pulldown,void,
 Function,+,furi_hal_rfid_pin_pull_release,void,
-Function,+,furi_hal_rfid_pins_emulate,void,
-Function,+,furi_hal_rfid_pins_read,void,
 Function,+,furi_hal_rfid_pins_reset,void,
-Function,+,furi_hal_rfid_set_emulate_period,void,uint32_t
-Function,+,furi_hal_rfid_set_emulate_pulse,void,uint32_t
 Function,+,furi_hal_rfid_set_read_period,void,uint32_t
 Function,+,furi_hal_rfid_set_read_pulse,void,uint32_t
-Function,+,furi_hal_rfid_tim_emulate,void,float
 Function,+,furi_hal_rfid_tim_emulate_dma_start,void,"uint32_t*, uint32_t*, size_t, FuriHalRfidDMACallback, void*"
 Function,+,furi_hal_rfid_tim_emulate_dma_stop,void,
-Function,+,furi_hal_rfid_tim_emulate_start,void,"FuriHalRfidEmulateCallback, void*"
-Function,+,furi_hal_rfid_tim_emulate_stop,void,
-Function,+,furi_hal_rfid_tim_read,void,"float, float"
 Function,+,furi_hal_rfid_tim_read_capture_start,void,"FuriHalRfidReadCaptureCallback, void*"
 Function,+,furi_hal_rfid_tim_read_capture_stop,void,
-Function,+,furi_hal_rfid_tim_read_start,void,
+Function,+,furi_hal_rfid_tim_read_continue,void,
+Function,+,furi_hal_rfid_tim_read_pause,void,
+Function,+,furi_hal_rfid_tim_read_start,void,"float, float"
 Function,+,furi_hal_rfid_tim_read_stop,void,
-Function,+,furi_hal_rfid_tim_reset,void,
 Function,+,furi_hal_rtc_datetime_to_timestamp,uint32_t,FuriHalRtcDateTime*
 Function,-,furi_hal_rtc_deinit_early,void,
 Function,+,furi_hal_rtc_get_boot_mode,FuriHalRtcBootMode,
 Function,+,furi_hal_rtc_get_datetime,void,FuriHalRtcDateTime*
+Function,+,furi_hal_rtc_get_days_per_month,uint8_t,"_Bool, uint8_t"
+Function,+,furi_hal_rtc_get_days_per_year,uint16_t,uint16_t
 Function,+,furi_hal_rtc_get_fault_data,uint32_t,
 Function,+,furi_hal_rtc_get_heap_track_mode,FuriHalRtcHeapTrackMode,
 Function,+,furi_hal_rtc_get_locale_dateformat,FuriHalRtcLocaleDateFormat,
@@ -1351,6 +1356,7 @@ Function,+,furi_hal_rtc_get_timestamp,uint32_t,
 Function,-,furi_hal_rtc_init,void,
 Function,-,furi_hal_rtc_init_early,void,
 Function,+,furi_hal_rtc_is_flag_set,_Bool,FuriHalRtcFlag
+Function,+,furi_hal_rtc_is_leap_year,_Bool,uint16_t
 Function,+,furi_hal_rtc_reset_flag,void,FuriHalRtcFlag
 Function,+,furi_hal_rtc_set_boot_mode,void,FuriHalRtcBootMode
 Function,+,furi_hal_rtc_set_datetime,void,FuriHalRtcDateTime*
@@ -2039,6 +2045,8 @@ Function,-,mf_df_cat_key_settings,void,"MifareDesfireKeySettings*, FuriString*"
 Function,-,mf_df_cat_version,void,"MifareDesfireVersion*, FuriString*"
 Function,-,mf_df_check_card_type,_Bool,"uint8_t, uint8_t, uint8_t"
 Function,-,mf_df_clear,void,MifareDesfireData*
+Function,-,mf_df_get_application,MifareDesfireApplication*,"MifareDesfireData*, const uint8_t[3]*"
+Function,-,mf_df_get_file,MifareDesfireFile*,"MifareDesfireApplication*, uint8_t"
 Function,-,mf_df_parse_get_application_ids_response,_Bool,"uint8_t*, uint16_t, MifareDesfireApplication**"
 Function,-,mf_df_parse_get_file_ids_response,_Bool,"uint8_t*, uint16_t, MifareDesfireFile**"
 Function,-,mf_df_parse_get_file_settings_response,_Bool,"uint8_t*, uint16_t, MifareDesfireFile*"
@@ -3539,6 +3547,8 @@ Function,+,version_get,const Version*,
 Function,+,version_get_builddate,const char*,const Version*
 Function,+,version_get_custom_name,const char*,const Version*
 Function,+,version_get_dirty_flag,_Bool,const Version*
+Function,+,version_get_firmware_origin,const char*,const Version*
+Function,+,version_get_git_origin,const char*,const Version*
 Function,+,version_get_gitbranch,const char*,const Version*
 Function,+,version_get_gitbranchnum,const char*,const Version*
 Function,+,version_get_githash,const char*,const Version*
--- a/firmware/targets/f7/furi_hal/furi_hal.c
+++ b/firmware/targets/f7/furi_hal/furi_hal.c
@@ -9,6 +9,8 @@
 void furi_hal_init_early() {
    furi_hal_cortex_init_early();
    furi_hal_clock_init_early();
+    furi_hal_bus_init_early();
+    furi_hal_dma_init_early();
    furi_hal_resources_init_early();
    furi_hal_os_init();
    furi_hal_spi_config_init_early();
@@ -22,12 +24,15 @@ void furi_hal_deinit_early() {
    furi_hal_i2c_deinit_early();
    furi_hal_spi_config_deinit_early();
    furi_hal_resources_deinit_early();
+    furi_hal_dma_deinit_early();
+    furi_hal_bus_deinit_early();
    furi_hal_clock_deinit_early();
 }

 void furi_hal_init() {
    furi_hal_mpu_init();
    furi_hal_clock_init();
+    furi_hal_random_init();
    furi_hal_console_init();
    furi_hal_rtc_init();
    furi_hal_interrupt_init();
--- a/firmware/targets/f7/furi_hal/furi_hal_bt.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_bt.c
@@ -7,6 +7,7 @@
 #include <furi_hal_version.h>
 #include <furi_hal_bt_hid.h>
 #include <furi_hal_bt_serial.h>
+#include <furi_hal_bus.c>
 #include "battery_service.h"

 #include <furi.h>
@@ -80,6 +81,11 @@ FuriHalBtProfileConfig profile_config[FuriHalBtProfileNumber] = {
 FuriHalBtProfileConfig* current_profile = NULL;

 void furi_hal_bt_init() {
+    furi_hal_bus_enable(FuriHalBusHSEM);
+    furi_hal_bus_enable(FuriHalBusIPCC);
+    furi_hal_bus_enable(FuriHalBusAES2);
+    furi_hal_bus_enable(FuriHalBusPKA);
+
    if(!furi_hal_bt_core2_mtx) {
        furi_hal_bt_core2_mtx = furi_mutex_alloc(FuriMutexTypeNormal);
        furi_assert(furi_hal_bt_core2_mtx);
@@ -269,6 +275,11 @@ void furi_hal_bt_reinit() {
    furi_delay_ms(100);
    ble_glue_thread_stop();

+    furi_hal_bus_disable(FuriHalBusHSEM);
+    furi_hal_bus_disable(FuriHalBusIPCC);
+    furi_hal_bus_disable(FuriHalBusAES2);
+    furi_hal_bus_disable(FuriHalBusPKA);
+
    FURI_LOG_I(TAG, "Start BT initialization");
    furi_hal_bt_init();

--- a/firmware/targets/f7/furi_hal/furi_hal_bus.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_bus.c
@@ -0,0 +1,302 @@
+#include <furi_hal_bus.h>
+#include <furi.h>
+
+#include <stm32wbxx_ll_bus.h>
+
+/* Bus bitmask definitions */
+#define FURI_HAL_BUS_IGNORE (0x0U)
+
+#define FURI_HAL_BUS_AHB1_GRP1                                                           \
+    (LL_AHB1_GRP1_PERIPH_DMA1 | LL_AHB1_GRP1_PERIPH_DMA2 | LL_AHB1_GRP1_PERIPH_DMAMUX1 | \
+     LL_AHB1_GRP1_PERIPH_CRC | LL_AHB1_GRP1_PERIPH_TSC)
+
+#if defined(ADC_SUPPORT_5_MSPS)
+#define FURI_HAL_BUS_AHB2_GRP1                                                           \
+    (LL_AHB2_GRP1_PERIPH_GPIOA | LL_AHB2_GRP1_PERIPH_GPIOB | LL_AHB2_GRP1_PERIPH_GPIOC | \
+     LL_AHB2_GRP1_PERIPH_GPIOD | LL_AHB2_GRP1_PERIPH_GPIOE | LL_AHB2_GRP1_PERIPH_GPIOH | \
+     LL_AHB2_GRP1_PERIPH_ADC | LL_AHB2_GRP1_PERIPH_AES1)
+
+#define FURI_HAL_BUS_APB2_GRP1                                                          \
+    (LL_APB2_GRP1_PERIPH_TIM1 | LL_APB2_GRP1_PERIPH_SPI1 | LL_APB2_GRP1_PERIPH_USART1 | \
+     LL_APB2_GRP1_PERIPH_TIM16 | LL_APB2_GRP1_PERIPH_TIM17 | LL_APB2_GRP1_PERIPH_SAI1)
+#else
+#define FURI_HAL_BUS_AHB2_GRP1                                                           \
+    (LL_AHB2_GRP1_PERIPH_GPIOA | LL_AHB2_GRP1_PERIPH_GPIOB | LL_AHB2_GRP1_PERIPH_GPIOC | \
+     LL_AHB2_GRP1_PERIPH_GPIOD | LL_AHB2_GRP1_PERIPH_GPIOE | LL_AHB2_GRP1_PERIPH_GPIOH | \
+     LL_AHB2_GRP1_PERIPH_AES1)
+
+#define FURI_HAL_BUS_APB2_GRP1                                                            \
+    (LL_APB2_GRP1_PERIPH_ADC | LL_APB2_GRP1_PERIPH_TIM1 | LL_APB2_GRP1_PERIPH_SPI1 |      \
+     LL_APB2_GRP1_PERIPH_USART1 | LL_APB2_GRP1_PERIPH_TIM16 | LL_APB2_GRP1_PERIPH_TIM17 | \
+     LL_APB2_GRP1_PERIPH_SAI1)
+#endif
+
+#define FURI_HAL_BUS_AHB3_GRP1                                                          \
+    (LL_AHB3_GRP1_PERIPH_QUADSPI | LL_AHB3_GRP1_PERIPH_PKA | LL_AHB3_GRP1_PERIPH_AES2 | \
+     LL_AHB3_GRP1_PERIPH_RNG | LL_AHB3_GRP1_PERIPH_HSEM | LL_AHB3_GRP1_PERIPH_IPCC)
+//   LL_AHB3_GRP1_PERIPH_FLASH enabled by default
+
+#define FURI_HAL_BUS_APB1_GRP1                                                         \
+    (LL_APB1_GRP1_PERIPH_TIM2 | LL_APB1_GRP1_PERIPH_LCD | LL_APB1_GRP1_PERIPH_RTCAPB | \
+     LL_APB1_GRP1_PERIPH_SPI2 | LL_APB1_GRP1_PERIPH_I2C1 | LL_APB1_GRP1_PERIPH_I2C3 |  \
+     LL_APB1_GRP1_PERIPH_CRS | LL_APB1_GRP1_PERIPH_USB | LL_APB1_GRP1_PERIPH_LPTIM1)
+
+#define FURI_HAL_BUS_APB1_GRP2 (LL_APB1_GRP2_PERIPH_LPUART1 | LL_APB1_GRP2_PERIPH_LPTIM2)
+#define FURI_HAL_BUS_APB3_GRP1 (LL_APB3_GRP1_PERIPH_RF)
+
+/* Test macro definitions */
+#define FURI_HAL_BUS_IS_ALL_CLEAR(reg, value) (READ_BIT((reg), (value)) == 0UL)
+#define FURI_HAL_BUS_IS_ALL_SET(reg, value) (READ_BIT((reg), (value)) == (value))
+
+#define FURI_HAL_BUS_IS_CLOCK_ENABLED(bus, value, ...) \
+    (FURI_HAL_BUS_IS_ALL_SET(RCC->bus##ENR##__VA_ARGS__, (value)))
+#define FURI_HAL_BUS_IS_CLOCK_DISABLED(bus, value, ...) \
+    (FURI_HAL_BUS_IS_ALL_CLEAR(RCC->bus##ENR##__VA_ARGS__, (value)))
+
+#define FURI_HAL_BUS_IS_RESET_ASSERTED(bus, value, ...) \
+    (FURI_HAL_BUS_IS_ALL_SET(RCC->bus##RSTR##__VA_ARGS__, (value)))
+#define FURI_HAL_BUS_IS_RESET_DEASSERTED(bus, value, ...) \
+    (FURI_HAL_BUS_IS_ALL_CLEAR(RCC->bus##RSTR##__VA_ARGS__, (value)))
+
+#define FURI_HAL_BUS_IS_PERIPH_ENABLED(bus, value, ...)             \
+    (FURI_HAL_BUS_IS_RESET_DEASSERTED(bus, (value), __VA_ARGS__) && \
+     FURI_HAL_BUS_IS_CLOCK_ENABLED(bus, (value), __VA_ARGS__))
+
+#define FURI_HAL_BUS_IS_PERIPH_DISABLED(bus, value, ...)          \
+    (FURI_HAL_BUS_IS_CLOCK_DISABLED(bus, (value), __VA_ARGS__) && \
+     FURI_HAL_BUS_IS_RESET_ASSERTED(bus, (value), __VA_ARGS__))
+
+/* Control macro definitions */
+#define FURI_HAL_BUS_RESET_ASSERT(bus, value, grp) LL_##bus##_GRP##grp##_ForceReset(value)
+#define FURI_HAL_BUS_RESET_DEASSERT(bus, value, grp) LL_##bus##_GRP##grp##_ReleaseReset(value)
+
+#define FURI_HAL_BUS_CLOCK_ENABLE(bus, value, grp) LL_##bus##_GRP##grp##_EnableClock(value)
+#define FURI_HAL_BUS_CLOCK_DISABLE(bus, value, grp) LL_##bus##_GRP##grp##_DisableClock(value)
+
+#define FURI_HAL_BUS_PERIPH_ENABLE(bus, value, grp) \
+    FURI_HAL_BUS_CLOCK_ENABLE(bus, value, grp);     \
+    FURI_HAL_BUS_RESET_DEASSERT(bus, value, grp)
+
+#define FURI_HAL_BUS_PERIPH_DISABLE(bus, value, grp) \
+    FURI_HAL_BUS_RESET_ASSERT(bus, value, grp);      \
+    FURI_HAL_BUS_CLOCK_DISABLE(bus, value, grp)
+
+#define FURI_HAL_BUS_PERIPH_RESET(bus, value, grp) \
+    FURI_HAL_BUS_RESET_ASSERT(bus, value, grp);    \
+    FURI_HAL_BUS_RESET_DEASSERT(bus, value, grp)
+
+static const uint32_t furi_hal_bus[] = {
+    [FuriHalBusAHB1_GRP1] = FURI_HAL_BUS_AHB1_GRP1,
+    [FuriHalBusDMA1] = LL_AHB1_GRP1_PERIPH_DMA1,
+    [FuriHalBusDMA2] = LL_AHB1_GRP1_PERIPH_DMA2,
+    [FuriHalBusDMAMUX1] = LL_AHB1_GRP1_PERIPH_DMAMUX1,
+    [FuriHalBusCRC] = LL_AHB1_GRP1_PERIPH_CRC,
+    [FuriHalBusTSC] = LL_AHB1_GRP1_PERIPH_TSC,
+
+    [FuriHalBusAHB2_GRP1] = FURI_HAL_BUS_AHB2_GRP1,
+    [FuriHalBusGPIOA] = LL_AHB2_GRP1_PERIPH_GPIOA,
+    [FuriHalBusGPIOB] = LL_AHB2_GRP1_PERIPH_GPIOB,
+    [FuriHalBusGPIOC] = LL_AHB2_GRP1_PERIPH_GPIOC,
+    [FuriHalBusGPIOD] = LL_AHB2_GRP1_PERIPH_GPIOD,
+    [FuriHalBusGPIOE] = LL_AHB2_GRP1_PERIPH_GPIOE,
+    [FuriHalBusGPIOH] = LL_AHB2_GRP1_PERIPH_GPIOH,
+#if defined(ADC_SUPPORT_5_MSPS)
+    [FuriHalBusADC] = LL_AHB2_GRP1_PERIPH_ADC,
+#endif
+    [FuriHalBusAES1] = LL_AHB2_GRP1_PERIPH_AES1,
+
+    [FuriHalBusAHB3_GRP1] = FURI_HAL_BUS_AHB3_GRP1,
+    [FuriHalBusQUADSPI] = LL_AHB3_GRP1_PERIPH_QUADSPI,
+    [FuriHalBusPKA] = LL_AHB3_GRP1_PERIPH_PKA,
+    [FuriHalBusAES2] = LL_AHB3_GRP1_PERIPH_AES2,
+    [FuriHalBusRNG] = LL_AHB3_GRP1_PERIPH_RNG,
+    [FuriHalBusHSEM] = LL_AHB3_GRP1_PERIPH_HSEM,
+    [FuriHalBusIPCC] = LL_AHB3_GRP1_PERIPH_IPCC,
+    [FuriHalBusFLASH] = LL_AHB3_GRP1_PERIPH_FLASH,
+
+    [FuriHalBusAPB1_GRP1] = FURI_HAL_BUS_APB1_GRP1,
+    [FuriHalBusTIM2] = LL_APB1_GRP1_PERIPH_TIM2,
+    [FuriHalBusLCD] = LL_APB1_GRP1_PERIPH_LCD,
+    [FuriHalBusSPI2] = LL_APB1_GRP1_PERIPH_SPI2,
+    [FuriHalBusI2C1] = LL_APB1_GRP1_PERIPH_I2C1,
+    [FuriHalBusI2C3] = LL_APB1_GRP1_PERIPH_I2C3,
+    [FuriHalBusCRS] = LL_APB1_GRP1_PERIPH_CRS,
+    [FuriHalBusUSB] = LL_APB1_GRP1_PERIPH_USB,
+    [FuriHalBusLPTIM1] = LL_APB1_GRP1_PERIPH_LPTIM1,
+
+    [FuriHalBusAPB1_GRP2] = FURI_HAL_BUS_APB1_GRP2,
+    [FuriHalBusLPUART1] = LL_APB1_GRP2_PERIPH_LPUART1,
+    [FuriHalBusLPTIM2] = LL_APB1_GRP2_PERIPH_LPTIM2,
+
+    [FuriHalBusAPB2_GRP1] = FURI_HAL_BUS_APB2_GRP1,
+#if defined(ADC_SUPPORT_2_5_MSPS)
+    [FuriHalBusADC] = LL_APB2_GRP1_PERIPH_ADC,
+#endif
+    [FuriHalBusTIM1] = LL_APB2_GRP1_PERIPH_TIM1,
+    [FuriHalBusSPI1] = LL_APB2_GRP1_PERIPH_SPI1,
+    [FuriHalBusUSART1] = LL_APB2_GRP1_PERIPH_USART1,
+    [FuriHalBusTIM16] = LL_APB2_GRP1_PERIPH_TIM16,
+    [FuriHalBusTIM17] = LL_APB2_GRP1_PERIPH_TIM17,
+    [FuriHalBusSAI1] = LL_APB2_GRP1_PERIPH_SAI1,
+
+    [FuriHalBusAPB3_GRP1] = FURI_HAL_BUS_IGNORE, // APB3_GRP1 clocking cannot be changed
+    [FuriHalBusRF] = LL_APB3_GRP1_PERIPH_RF,
+};
+
+void furi_hal_bus_init_early() {
+    FURI_CRITICAL_ENTER();
+
+    FURI_HAL_BUS_PERIPH_DISABLE(AHB1, FURI_HAL_BUS_AHB1_GRP1, 1);
+    FURI_HAL_BUS_PERIPH_DISABLE(AHB2, FURI_HAL_BUS_AHB2_GRP1, 1);
+    FURI_HAL_BUS_PERIPH_DISABLE(AHB3, FURI_HAL_BUS_AHB3_GRP1, 1);
+    FURI_HAL_BUS_PERIPH_DISABLE(APB1, FURI_HAL_BUS_APB1_GRP1, 1);
+    FURI_HAL_BUS_PERIPH_DISABLE(APB1, FURI_HAL_BUS_APB1_GRP2, 2);
+    FURI_HAL_BUS_PERIPH_DISABLE(APB2, FURI_HAL_BUS_APB2_GRP1, 1);
+
+    FURI_HAL_BUS_RESET_ASSERT(APB3, FURI_HAL_BUS_APB3_GRP1, 1);
+
+    FURI_CRITICAL_EXIT();
+}
+
+void furi_hal_bus_deinit_early() {
+    FURI_CRITICAL_ENTER();
+
+    FURI_HAL_BUS_PERIPH_ENABLE(AHB1, FURI_HAL_BUS_AHB1_GRP1, 1);
+    FURI_HAL_BUS_PERIPH_ENABLE(AHB2, FURI_HAL_BUS_AHB2_GRP1, 1);
+    FURI_HAL_BUS_PERIPH_ENABLE(AHB3, FURI_HAL_BUS_AHB3_GRP1, 1);
+    FURI_HAL_BUS_PERIPH_ENABLE(APB1, FURI_HAL_BUS_APB1_GRP1, 1);
+    FURI_HAL_BUS_PERIPH_ENABLE(APB1, FURI_HAL_BUS_APB1_GRP2, 2);
+    FURI_HAL_BUS_PERIPH_ENABLE(APB2, FURI_HAL_BUS_APB2_GRP1, 1);
+
+    FURI_HAL_BUS_RESET_DEASSERT(APB3, FURI_HAL_BUS_APB3_GRP1, 1);
+
+    FURI_CRITICAL_EXIT();
+}
+
+void furi_hal_bus_enable(FuriHalBus bus) {
+    furi_check(bus < FuriHalBusMAX);
+    const uint32_t value = furi_hal_bus[bus];
+    if(!value) {
+        return;
+    }
+
+    FURI_CRITICAL_ENTER();
+    if(bus < FuriHalBusAHB2_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_DISABLED(AHB1, value));
+        FURI_HAL_BUS_PERIPH_ENABLE(AHB1, value, 1);
+    } else if(bus < FuriHalBusAHB3_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_DISABLED(AHB2, value));
+        FURI_HAL_BUS_PERIPH_ENABLE(AHB2, value, 1);
+    } else if(bus < FuriHalBusAPB1_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_DISABLED(AHB3, value));
+        FURI_HAL_BUS_PERIPH_ENABLE(AHB3, value, 1);
+    } else if(bus < FuriHalBusAPB1_GRP2) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_DISABLED(APB1, value, 1));
+        FURI_HAL_BUS_PERIPH_ENABLE(APB1, value, 1);
+    } else if(bus < FuriHalBusAPB2_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_DISABLED(APB1, value, 2));
+        FURI_HAL_BUS_PERIPH_ENABLE(APB1, value, 2);
+    } else if(bus < FuriHalBusAPB3_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_DISABLED(APB2, value));
+        FURI_HAL_BUS_PERIPH_ENABLE(APB2, value, 1);
+    } else {
+        furi_check(FURI_HAL_BUS_IS_RESET_ASSERTED(APB3, value));
+        FURI_HAL_BUS_RESET_DEASSERT(APB3, FURI_HAL_BUS_APB3_GRP1, 1);
+    }
+    FURI_CRITICAL_EXIT();
+}
+
+void furi_hal_bus_reset(FuriHalBus bus) {
+    furi_check(bus < FuriHalBusMAX);
+    const uint32_t value = furi_hal_bus[bus];
+    if(!value) {
+        return;
+    }
+
+    FURI_CRITICAL_ENTER();
+    if(bus < FuriHalBusAHB2_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(AHB1, value));
+        FURI_HAL_BUS_PERIPH_RESET(AHB1, value, 1);
+    } else if(bus < FuriHalBusAHB3_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(AHB2, value));
+        FURI_HAL_BUS_PERIPH_RESET(AHB2, value, 1);
+    } else if(bus < FuriHalBusAPB1_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(AHB3, value));
+        FURI_HAL_BUS_PERIPH_RESET(AHB3, value, 1);
+    } else if(bus < FuriHalBusAPB1_GRP2) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(APB1, value, 1));
+        FURI_HAL_BUS_PERIPH_RESET(APB1, value, 1);
+    } else if(bus < FuriHalBusAPB2_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(APB1, value, 2));
+        FURI_HAL_BUS_PERIPH_RESET(APB1, value, 2);
+    } else if(bus < FuriHalBusAPB3_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(APB2, value));
+        FURI_HAL_BUS_PERIPH_RESET(APB2, value, 1);
+    } else {
+        furi_check(FURI_HAL_BUS_IS_RESET_DEASSERTED(APB3, value));
+        FURI_HAL_BUS_PERIPH_RESET(APB3, value, 1);
+    }
+    FURI_CRITICAL_EXIT();
+}
+
+void furi_hal_bus_disable(FuriHalBus bus) {
+    furi_check(bus < FuriHalBusMAX);
+    const uint32_t value = furi_hal_bus[bus];
+    if(!value) {
+        return;
+    }
+
+    FURI_CRITICAL_ENTER();
+    if(bus < FuriHalBusAHB2_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(AHB1, value));
+        FURI_HAL_BUS_PERIPH_DISABLE(AHB1, value, 1);
+    } else if(bus < FuriHalBusAHB3_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(AHB2, value));
+        FURI_HAL_BUS_PERIPH_DISABLE(AHB2, value, 1);
+    } else if(bus < FuriHalBusAPB1_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(AHB3, value));
+        FURI_HAL_BUS_PERIPH_DISABLE(AHB3, value, 1);
+    } else if(bus < FuriHalBusAPB1_GRP2) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(APB1, value, 1));
+        FURI_HAL_BUS_PERIPH_DISABLE(APB1, value, 1);
+    } else if(bus < FuriHalBusAPB2_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(APB1, value, 2));
+        FURI_HAL_BUS_PERIPH_DISABLE(APB1, value, 2);
+    } else if(bus < FuriHalBusAPB3_GRP1) {
+        furi_check(FURI_HAL_BUS_IS_PERIPH_ENABLED(APB2, value));
+        FURI_HAL_BUS_PERIPH_DISABLE(APB2, value, 1);
+    } else {
+        furi_check(FURI_HAL_BUS_IS_RESET_DEASSERTED(APB3, value));
+        FURI_HAL_BUS_RESET_ASSERT(APB3, FURI_HAL_BUS_APB3_GRP1, 1);
+    }
+    FURI_CRITICAL_EXIT();
+}
+
+bool furi_hal_bus_is_enabled(FuriHalBus bus) {
+    furi_check(bus < FuriHalBusMAX);
+    const uint32_t value = furi_hal_bus[bus];
+    if(value == FURI_HAL_BUS_IGNORE) {
+        return true;
+    }
+
+    bool ret = false;
+    FURI_CRITICAL_ENTER();
+    if(bus < FuriHalBusAHB2_GRP1) {
+        ret = FURI_HAL_BUS_IS_PERIPH_ENABLED(AHB1, value);
+    } else if(bus < FuriHalBusAHB3_GRP1) {
+        ret = FURI_HAL_BUS_IS_PERIPH_ENABLED(AHB2, value);
+    } else if(bus < FuriHalBusAPB1_GRP1) {
+        ret = FURI_HAL_BUS_IS_PERIPH_ENABLED(AHB3, value);
+    } else if(bus < FuriHalBusAPB1_GRP2) {
+        ret = FURI_HAL_BUS_IS_PERIPH_ENABLED(APB1, value, 1);
+    } else if(bus < FuriHalBusAPB2_GRP1) {
+        ret = FURI_HAL_BUS_IS_PERIPH_ENABLED(APB1, value, 2);
+    } else if(bus < FuriHalBusAPB3_GRP1) {
+        ret = FURI_HAL_BUS_IS_PERIPH_ENABLED(APB2, value);
+    } else {
+        ret = FURI_HAL_BUS_IS_RESET_DEASSERTED(APB3, value);
+    }
+    FURI_CRITICAL_EXIT();
+
+    return ret;
+}
--- a/firmware/targets/f7/furi_hal/furi_hal_bus.h
+++ b/firmware/targets/f7/furi_hal/furi_hal_bus.h
@@ -0,0 +1,112 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "stm32wbxx.h"
+#include "stdbool.h"
+
+typedef enum {
+    FuriHalBusAHB1_GRP1,
+    FuriHalBusDMA1,
+    FuriHalBusDMA2,
+    FuriHalBusDMAMUX1,
+    FuriHalBusCRC,
+    FuriHalBusTSC,
+
+    FuriHalBusAHB2_GRP1,
+    FuriHalBusGPIOA,
+    FuriHalBusGPIOB,
+    FuriHalBusGPIOC,
+    FuriHalBusGPIOD,
+    FuriHalBusGPIOE,
+    FuriHalBusGPIOH,
+#if defined(ADC_SUPPORT_5_MSPS)
+    FuriHalBusADC,
+#endif
+    FuriHalBusAES1,
+
+    FuriHalBusAHB3_GRP1,
+    FuriHalBusQUADSPI,
+    FuriHalBusPKA,
+    FuriHalBusAES2,
+    FuriHalBusRNG,
+    FuriHalBusHSEM,
+    FuriHalBusIPCC,
+    FuriHalBusFLASH,
+
+    FuriHalBusAPB1_GRP1,
+    FuriHalBusTIM2,
+    FuriHalBusLCD,
+    FuriHalBusSPI2,
+    FuriHalBusI2C1,
+    FuriHalBusI2C3,
+    FuriHalBusCRS,
+    FuriHalBusUSB,
+    FuriHalBusLPTIM1,
+
+    FuriHalBusAPB1_GRP2,
+    FuriHalBusLPUART1,
+    FuriHalBusLPTIM2,
+
+    FuriHalBusAPB2_GRP1,
+#if defined(ADC_SUPPORT_2_5_MSPS)
+    FuriHalBusADC,
+#endif
+    FuriHalBusTIM1,
+    FuriHalBusSPI1,
+    FuriHalBusUSART1,
+    FuriHalBusTIM16,
+    FuriHalBusTIM17,
+    FuriHalBusSAI1,
+
+    FuriHalBusAPB3_GRP1,
+    FuriHalBusRF,
+
+    FuriHalBusMAX,
+} FuriHalBus;
+
+/** Early initialization */
+void furi_hal_bus_init_early();
+
+/** Early de-initialization */
+void furi_hal_bus_deinit_early();
+
+/**
+ * Enable a peripheral by turning the clocking on and deasserting the reset.
+ * @param [in] bus Peripheral to be enabled.
+ * @warning Peripheral must be in disabled state in order to be enabled.
+ */
+void furi_hal_bus_enable(FuriHalBus bus);
+
+/**
+ * Reset a peripheral by sequentially asserting and deasserting the reset.
+ * @param [in] bus Peripheral to be reset.
+ * @warning Peripheral must be in enabled state in order to be reset.
+ */
+void furi_hal_bus_reset(FuriHalBus bus);
+
+/**
+ * Disable a peripheral by turning the clocking off and asserting the reset.
+ * @param [in] bus Peripheral to be disabled.
+ * @warning Peripheral must be in enabled state in order to be disabled.
+ */
+void furi_hal_bus_disable(FuriHalBus bus);
+
+/** Check if peripheral is enabled
+ *
+ * @warning    FuriHalBusAPB3_GRP1 is a special group of shared peripherals, for
+ *             core1 its clock is always on and the only status we can report is
+ *             peripheral reset status. Check code and Reference Manual for
+ *             details.
+ *
+ * @param[in]  bus   The peripheral to check
+ *
+ * @return     true if enabled or always enabled, false otherwise
+ */
+bool furi_hal_bus_is_enabled(FuriHalBus bus);
+
+#ifdef __cplusplus
+}
+#endif
--- a/firmware/targets/f7/furi_hal/furi_hal_clock.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_clock.c
@@ -6,7 +6,6 @@
 #include <stm32wbxx_ll_rcc.h>
 #include <stm32wbxx_ll_utils.h>
 #include <stm32wbxx_ll_cortex.h>
-#include <stm32wbxx_ll_bus.h>

 #define TAG "FuriHalClock"

@@ -19,36 +18,9 @@
 void furi_hal_clock_init_early() {
    LL_SetSystemCoreClock(CPU_CLOCK_HZ_EARLY);
    LL_Init1msTick(SystemCoreClock);
-
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOA);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOB);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOC);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOD);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOE);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOH);
-
-    LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SPI1);
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_SPI2);
-
-    LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_LPTIM2);
-
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_I2C1);
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_I2C3);
 }

 void furi_hal_clock_deinit_early() {
-    LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_I2C1);
-    LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_I2C3);
-
-    LL_APB2_GRP1_DisableClock(LL_APB2_GRP1_PERIPH_SPI1);
-    LL_APB1_GRP1_DisableClock(LL_APB1_GRP1_PERIPH_SPI2);
-
-    LL_AHB2_GRP1_DisableClock(LL_AHB2_GRP1_PERIPH_GPIOA);
-    LL_AHB2_GRP1_DisableClock(LL_AHB2_GRP1_PERIPH_GPIOB);
-    LL_AHB2_GRP1_DisableClock(LL_AHB2_GRP1_PERIPH_GPIOC);
-    LL_AHB2_GRP1_DisableClock(LL_AHB2_GRP1_PERIPH_GPIOD);
-    LL_AHB2_GRP1_DisableClock(LL_AHB2_GRP1_PERIPH_GPIOE);
-    LL_AHB2_GRP1_DisableClock(LL_AHB2_GRP1_PERIPH_GPIOH);
 }

 void furi_hal_clock_init() {
@@ -137,68 +109,12 @@ void furi_hal_clock_init() {
        SysTick_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), TICK_INT_PRIORITY, 0));
    NVIC_EnableIRQ(SysTick_IRQn);

-    LL_RCC_SetUSARTClockSource(LL_RCC_USART1_CLKSOURCE_PCLK2);
-    LL_RCC_SetLPUARTClockSource(LL_RCC_LPUART1_CLKSOURCE_PCLK1);
-    LL_RCC_SetADCClockSource(LL_RCC_ADC_CLKSOURCE_PLLSAI1);
-    LL_RCC_SetI2CClockSource(LL_RCC_I2C1_CLKSOURCE_PCLK1);
-    LL_RCC_SetRNGClockSource(LL_RCC_RNG_CLKSOURCE_CLK48);
-    LL_RCC_SetUSBClockSource(LL_RCC_USB_CLKSOURCE_PLLSAI1);
    LL_RCC_SetCLK48ClockSource(LL_RCC_CLK48_CLKSOURCE_PLLSAI1);
    LL_RCC_HSI_EnableInStopMode(); // Ensure that MR is capable of work in STOP0
    LL_RCC_SetSMPSClockSource(LL_RCC_SMPS_CLKSOURCE_HSE);
    LL_RCC_SetSMPSPrescaler(LL_RCC_SMPS_DIV_1);
    LL_RCC_SetRFWKPClockSource(LL_RCC_RFWKP_CLKSOURCE_LSE);

-    // AHB1 GRP1
-    LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1);
-    LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA2);
-    LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMAMUX1);
-    LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_CRC);
-    // LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_TSC);
-
-    // AHB2 GRP1
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOA);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOB);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOC);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOD);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOE);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_GPIOH);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_ADC);
-    LL_AHB2_GRP1_EnableClock(LL_AHB2_GRP1_PERIPH_AES1);
-
-    // AHB3 GRP1
-    // LL_AHB3_GRP1_EnableClock(LL_AHB3_GRP1_PERIPH_QUADSPI);
-    LL_AHB3_GRP1_EnableClock(LL_AHB3_GRP1_PERIPH_PKA);
-    LL_AHB3_GRP1_EnableClock(LL_AHB3_GRP1_PERIPH_AES2);
-    LL_AHB3_GRP1_EnableClock(LL_AHB3_GRP1_PERIPH_RNG);
-    LL_AHB3_GRP1_EnableClock(LL_AHB3_GRP1_PERIPH_HSEM);
-    LL_AHB3_GRP1_EnableClock(LL_AHB3_GRP1_PERIPH_IPCC);
-    LL_AHB3_GRP1_EnableClock(LL_AHB3_GRP1_PERIPH_FLASH);
-
-    // APB1 GRP1
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_TIM2);
-    // LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_LCD);
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_RTCAPB);
-    // LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_WWDG);
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_SPI2);
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_I2C1);
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_I2C3);
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_CRS);
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_USB);
-    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_LPTIM1);
-
-    // APB1 GRP2
-    LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_LPUART1);
-
-    // APB2
-    // LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC);
-    LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM1);
-    LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SPI1);
-    LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_USART1);
-    LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM16);
-    LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_TIM17);
-    // LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_SAI1);
-
    FURI_LOG_I(TAG, "Init OK");
 }

--- a/firmware/targets/f7/furi_hal/furi_hal_crypto.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_crypto.c
@@ -1,8 +1,9 @@
 #include <furi_hal_crypto.h>
 #include <furi_hal_bt.h>
 #include <furi_hal_random.h>
+#include <furi_hal_bus.h>
+
 #include <stm32wbxx_ll_cortex.h>
-#include <stm32wbxx_ll_bus.h>
 #include <furi.h>
 #include <interface/patterns/ble_thread/shci/shci.h>

@@ -241,6 +242,8 @@ bool furi_hal_crypto_store_load_key(uint8_t slot, const uint8_t* iv) {
    furi_assert(furi_hal_crypto_mutex);
    furi_check(furi_mutex_acquire(furi_hal_crypto_mutex, FuriWaitForever) == FuriStatusOk);

+    furi_hal_bus_enable(FuriHalBusAES1);
+
    if(!furi_hal_bt_is_alive()) {
        return false;
    }
@@ -267,10 +270,7 @@ bool furi_hal_crypto_store_unload_key(uint8_t slot) {
    SHCI_CmdStatus_t shci_state = SHCI_C2_FUS_UnloadUsrKey(slot);
    furi_assert(shci_state == SHCI_Success);

-    FURI_CRITICAL_ENTER();
-    LL_AHB2_GRP1_ForceReset(LL_AHB2_GRP1_PERIPH_AES1);
-    LL_AHB2_GRP1_ReleaseReset(LL_AHB2_GRP1_PERIPH_AES1);
-    FURI_CRITICAL_EXIT();
+    furi_hal_bus_disable(FuriHalBusAES1);

    furi_check(furi_mutex_release(furi_hal_crypto_mutex) == FuriStatusOk);
    return (shci_state == SHCI_Success);
--- a/firmware/targets/f7/furi_hal/furi_hal_dma.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_dma.c
@@ -0,0 +1,14 @@
+#include <furi_hal_dma.h>
+#include <furi_hal_bus.h>
+
+void furi_hal_dma_init_early() {
+    furi_hal_bus_enable(FuriHalBusDMA1);
+    furi_hal_bus_enable(FuriHalBusDMA2);
+    furi_hal_bus_enable(FuriHalBusDMAMUX1);
+}
+
+void furi_hal_dma_deinit_early() {
+    furi_hal_bus_disable(FuriHalBusDMA1);
+    furi_hal_bus_disable(FuriHalBusDMA2);
+    furi_hal_bus_disable(FuriHalBusDMAMUX1);
+}
--- a/firmware/targets/f7/furi_hal/furi_hal_dma.h
+++ b/firmware/targets/f7/furi_hal/furi_hal_dma.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Early initialization */
+void furi_hal_dma_init_early();
+
+/** Early de-initialization */
+void furi_hal_dma_deinit_early();
+
+#ifdef __cplusplus
+}
+#endif
--- a/firmware/targets/f7/furi_hal/furi_hal_flash.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_flash.c
@@ -11,20 +11,20 @@
 #define TAG "FuriHalFlash"

 #define FURI_HAL_CRITICAL_MSG "Critical flash operation fail"
-#define FURI_HAL_FLASH_READ_BLOCK 8
-#define FURI_HAL_FLASH_WRITE_BLOCK 8
-#define FURI_HAL_FLASH_PAGE_SIZE 4096
-#define FURI_HAL_FLASH_CYCLES_COUNT 10000
-#define FURI_HAL_FLASH_TIMEOUT 1000
-#define FURI_HAL_FLASH_KEY1 0x45670123U
-#define FURI_HAL_FLASH_KEY2 0xCDEF89ABU
-#define FURI_HAL_FLASH_TOTAL_PAGES 256
+#define FURI_HAL_FLASH_READ_BLOCK (8U)
+#define FURI_HAL_FLASH_WRITE_BLOCK (8U)
+#define FURI_HAL_FLASH_PAGE_SIZE (4096U)
+#define FURI_HAL_FLASH_CYCLES_COUNT (10000U)
+#define FURI_HAL_FLASH_TIMEOUT (1000U)
+#define FURI_HAL_FLASH_KEY1 (0x45670123U)
+#define FURI_HAL_FLASH_KEY2 (0xCDEF89ABU)
+#define FURI_HAL_FLASH_TOTAL_PAGES (256U)
 #define FURI_HAL_FLASH_SR_ERRORS                                                               \
    (FLASH_SR_OPERR | FLASH_SR_PROGERR | FLASH_SR_WRPERR | FLASH_SR_PGAERR | FLASH_SR_SIZERR | \
     FLASH_SR_PGSERR | FLASH_SR_MISERR | FLASH_SR_FASTERR | FLASH_SR_RDERR | FLASH_SR_OPTVERR)

-#define FURI_HAL_FLASH_OPT_KEY1 0x08192A3B
-#define FURI_HAL_FLASH_OPT_KEY2 0x4C5D6E7F
+#define FURI_HAL_FLASH_OPT_KEY1 (0x08192A3BU)
+#define FURI_HAL_FLASH_OPT_KEY2 (0x4C5D6E7FU)
 #define FURI_HAL_FLASH_OB_TOTAL_WORDS (0x80 / (sizeof(uint32_t) * 2))

 /* STM32CubeWB/Projects/P-NUCLEO-WB55.Nucleo/Applications/BLE/BLE_RfWithFlash/Core/Src/flash_driver.c
@@ -35,7 +35,7 @@
  > If for any reason this test is never passed, this means there is a failure in the system and there is no other
  > way to recover than applying a device reset. 
 */
-#define FURI_HAL_FLASH_C2_LOCK_TIMEOUT_MS 3000u /* 3 seconds */
+#define FURI_HAL_FLASH_C2_LOCK_TIMEOUT_MS (3000U) /* 3 seconds */

 #define IS_ADDR_ALIGNED_64BITS(__VALUE__) (((__VALUE__)&0x7U) == (0x00UL))
 #define IS_FLASH_PROGRAM_ADDRESS(__VALUE__)                                             \
--- a/firmware/targets/f7/furi_hal/furi_hal_i2c_config.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_i2c_config.c
@@ -1,7 +1,8 @@
 #include <furi_hal_i2c_config.h>
 #include <furi_hal_resources.h>
 #include <furi_hal_version.h>
-#include <stm32wbxx_ll_bus.h>
+#include <furi_hal_bus.h>
+
 #include <stm32wbxx_ll_rcc.h>

 /** Timing register value is computed with the STM32CubeMX Tool,
@@ -21,17 +22,9 @@ FuriMutex* furi_hal_i2c_bus_power_mutex = NULL;
 static void furi_hal_i2c_bus_power_event(FuriHalI2cBus* bus, FuriHalI2cBusEvent event) {
    if(event == FuriHalI2cBusEventInit) {
        furi_hal_i2c_bus_power_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
-        FURI_CRITICAL_ENTER();
-        LL_RCC_SetI2CClockSource(LL_RCC_I2C1_CLKSOURCE_PCLK1);
-        LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C1);
-        FURI_CRITICAL_EXIT();
        bus->current_handle = NULL;
    } else if(event == FuriHalI2cBusEventDeinit) {
        furi_mutex_free(furi_hal_i2c_bus_power_mutex);
-        FURI_CRITICAL_ENTER();
-        LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C1);
-        LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_I2C1);
-        FURI_CRITICAL_EXIT();
    } else if(event == FuriHalI2cBusEventLock) {
        furi_check(
            furi_mutex_acquire(furi_hal_i2c_bus_power_mutex, FuriWaitForever) == FuriStatusOk);
@@ -39,12 +32,11 @@ static void furi_hal_i2c_bus_power_event(FuriHalI2cBus* bus, FuriHalI2cBusEvent
        furi_check(furi_mutex_release(furi_hal_i2c_bus_power_mutex) == FuriStatusOk);
    } else if(event == FuriHalI2cBusEventActivate) {
        FURI_CRITICAL_ENTER();
-        LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_I2C1);
+        furi_hal_bus_enable(FuriHalBusI2C1);
+        LL_RCC_SetI2CClockSource(LL_RCC_I2C1_CLKSOURCE_PCLK1);
        FURI_CRITICAL_EXIT();
    } else if(event == FuriHalI2cBusEventDeactivate) {
-        FURI_CRITICAL_ENTER();
-        LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C1);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_disable(FuriHalBusI2C1);
    }
 }

@@ -58,17 +50,9 @@ FuriMutex* furi_hal_i2c_bus_external_mutex = NULL;
 static void furi_hal_i2c_bus_external_event(FuriHalI2cBus* bus, FuriHalI2cBusEvent event) {
    if(event == FuriHalI2cBusEventInit) {
        furi_hal_i2c_bus_external_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
-        FURI_CRITICAL_ENTER();
-        LL_RCC_SetI2CClockSource(LL_RCC_I2C3_CLKSOURCE_PCLK1);
-        LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C3);
-        FURI_CRITICAL_EXIT();
        bus->current_handle = NULL;
    } else if(event == FuriHalI2cBusEventDeinit) {
        furi_mutex_free(furi_hal_i2c_bus_external_mutex);
-        FURI_CRITICAL_ENTER();
-        LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C3);
-        LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_I2C3);
-        FURI_CRITICAL_EXIT();
    } else if(event == FuriHalI2cBusEventLock) {
        furi_check(
            furi_mutex_acquire(furi_hal_i2c_bus_external_mutex, FuriWaitForever) == FuriStatusOk);
@@ -76,13 +60,11 @@ static void furi_hal_i2c_bus_external_event(FuriHalI2cBus* bus, FuriHalI2cBusEve
        furi_check(furi_mutex_release(furi_hal_i2c_bus_external_mutex) == FuriStatusOk);
    } else if(event == FuriHalI2cBusEventActivate) {
        FURI_CRITICAL_ENTER();
+        furi_hal_bus_enable(FuriHalBusI2C3);
        LL_RCC_SetI2CClockSource(LL_RCC_I2C3_CLKSOURCE_PCLK1);
-        LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_I2C3);
        FURI_CRITICAL_EXIT();
    } else if(event == FuriHalI2cBusEventDeactivate) {
-        FURI_CRITICAL_ENTER();
-        LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C3);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_disable(FuriHalBusI2C3);
    }
 }

--- a/firmware/targets/f7/furi_hal/furi_hal_ibutton.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_ibutton.c
@@ -1,14 +1,15 @@
 #include <furi_hal_ibutton.h>
 #include <furi_hal_interrupt.h>
 #include <furi_hal_resources.h>
+#include <furi_hal_bus.h>

 #include <stm32wbxx_ll_tim.h>
-#include <stm32wbxx_ll_exti.h>

 #include <furi.h>

 #define TAG "FuriHalIbutton"
 #define FURI_HAL_IBUTTON_TIMER TIM1
+#define FURI_HAL_IBUTTON_TIMER_BUS FuriHalBusTIM1
 #define FURI_HAL_IBUTTON_TIMER_IRQ FuriHalInterruptIdTim1UpTim16

 typedef enum {
@@ -49,9 +50,7 @@ void furi_hal_ibutton_emulate_start(
    furi_hal_ibutton->callback = callback;
    furi_hal_ibutton->context = context;

-    FURI_CRITICAL_ENTER();
-    LL_TIM_DeInit(FURI_HAL_IBUTTON_TIMER);
-    FURI_CRITICAL_EXIT();
+    furi_hal_bus_enable(FURI_HAL_IBUTTON_TIMER_BUS);

    furi_hal_interrupt_set_isr(FURI_HAL_IBUTTON_TIMER_IRQ, furi_hal_ibutton_emulate_isr, NULL);

@@ -81,10 +80,7 @@ void furi_hal_ibutton_emulate_stop() {
        furi_hal_ibutton->state = FuriHalIbuttonStateIdle;
        LL_TIM_DisableCounter(FURI_HAL_IBUTTON_TIMER);

-        FURI_CRITICAL_ENTER();
-        LL_TIM_DeInit(FURI_HAL_IBUTTON_TIMER);
-        FURI_CRITICAL_EXIT();
-
+        furi_hal_bus_disable(FURI_HAL_IBUTTON_TIMER_BUS);
        furi_hal_interrupt_set_isr(FURI_HAL_IBUTTON_TIMER_IRQ, NULL, NULL);

        furi_hal_ibutton->callback = NULL;
--- a/firmware/targets/f7/furi_hal/furi_hal_idle_timer.h
+++ b/firmware/targets/f7/furi_hal/furi_hal_idle_timer.h
@@ -1,8 +1,10 @@
 #pragma once

 #include <stm32wbxx_ll_lptim.h>
-#include <stm32wbxx_ll_bus.h>
 #include <stm32wbxx_ll_rcc.h>
+#include <stm32wbxx_ll_bus.h>
+
+#include <furi_hal_bus.h>

 // Timer used for tickless idle
 #define FURI_HAL_IDLE_TIMER_MAX 0xFFFF
@@ -10,6 +12,7 @@
 #define FURI_HAL_IDLE_TIMER_IRQ LPTIM1_IRQn

 static inline void furi_hal_idle_timer_init() {
+    furi_hal_bus_enable(FuriHalBusLPTIM1);
    // Configure clock source
    LL_RCC_SetLPTIMClockSource(LL_RCC_LPTIM1_CLKSOURCE_LSE);
    // There is a theoretical possibility that we need it
@@ -40,7 +43,7 @@ static inline void furi_hal_idle_timer_start(uint32_t count) {
 static inline void furi_hal_idle_timer_reset() {
    // Hard reset timer
    // THE ONLY RELIABLE WAY to stop it according to errata
-    LL_LPTIM_DeInit(FURI_HAL_IDLE_TIMER);
+    furi_hal_bus_reset(FuriHalBusLPTIM1);
    // Prevent IRQ handler call
    NVIC_ClearPendingIRQ(FURI_HAL_IDLE_TIMER_IRQ);
 }
--- a/firmware/targets/f7/furi_hal/furi_hal_info.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_info.c
@@ -26,7 +26,7 @@ void furi_hal_info_get(PropertyValueCallback out, char sep, void* context) {
        property_value_out(&property_context, NULL, 2, "format", "minor", "1");
    } else {
        property_value_out(&property_context, NULL, 3, "device", "info", "major", "2");
-        property_value_out(&property_context, NULL, 3, "device", "info", "minor", "1");
+        property_value_out(&property_context, NULL, 3, "device", "info", "minor", "2");
    }

    // Model name
@@ -173,6 +173,24 @@ void furi_hal_info_get(PropertyValueCallback out, char sep, void* context) {
            &property_context, "%d", 3, "firmware", "api", "major", api_version_major);
        property_value_out(
            &property_context, "%d", 3, "firmware", "api", "minor", api_version_minor);
+
+        property_value_out(
+            &property_context,
+            NULL,
+            3,
+            "firmware",
+            "origin",
+            "fork",
+            version_get_firmware_origin(firmware_version));
+
+        property_value_out(
+            &property_context,
+            NULL,
+            3,
+            "firmware",
+            "origin",
+            "git",
+            version_get_git_origin(firmware_version));
    }

    if(furi_hal_bt_is_alive()) {
--- a/firmware/targets/f7/furi_hal/furi_hal_pwm.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_pwm.c
@@ -1,8 +1,7 @@
 #include <furi_hal_pwm.h>
-#include <core/check.h>
 #include <furi_hal_resources.h>
+#include <furi_hal_bus.h>

-#include <stdint.h>
 #include <stm32wbxx_ll_tim.h>
 #include <stm32wbxx_ll_lptim.h>
 #include <stm32wbxx_ll_rcc.h>
@@ -29,9 +28,7 @@ void furi_hal_pwm_start(FuriHalPwmOutputId channel, uint32_t freq, uint8_t duty)
            GpioSpeedVeryHigh,
            GpioAltFn1TIM1);

-        FURI_CRITICAL_ENTER();
-        LL_TIM_DeInit(TIM1);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_enable(FuriHalBusTIM1);

        LL_TIM_SetCounterMode(TIM1, LL_TIM_COUNTERMODE_UP);
        LL_TIM_SetRepetitionCounter(TIM1, 0);
@@ -58,9 +55,7 @@ void furi_hal_pwm_start(FuriHalPwmOutputId channel, uint32_t freq, uint8_t duty)
            GpioSpeedVeryHigh,
            GpioAltFn14LPTIM2);

-        FURI_CRITICAL_ENTER();
-        LL_LPTIM_DeInit(LPTIM2);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_enable(FuriHalBusLPTIM2);

        LL_LPTIM_SetUpdateMode(LPTIM2, LL_LPTIM_UPDATE_MODE_ENDOFPERIOD);
        LL_RCC_SetLPTIMClockSource(LL_RCC_LPTIM2_CLKSOURCE_PCLK1);
@@ -80,14 +75,10 @@ void furi_hal_pwm_start(FuriHalPwmOutputId channel, uint32_t freq, uint8_t duty)
 void furi_hal_pwm_stop(FuriHalPwmOutputId channel) {
    if(channel == FuriHalPwmOutputIdTim1PA7) {
        furi_hal_gpio_init_simple(&gpio_ext_pa7, GpioModeAnalog);
-        FURI_CRITICAL_ENTER();
-        LL_TIM_DeInit(TIM1);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_disable(FuriHalBusTIM1);
    } else if(channel == FuriHalPwmOutputIdLptim2PA4) {
        furi_hal_gpio_init_simple(&gpio_ext_pa4, GpioModeAnalog);
-        FURI_CRITICAL_ENTER();
-        LL_LPTIM_DeInit(LPTIM2);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_disable(FuriHalBusLPTIM2);
    }
 }

--- a/firmware/targets/f7/furi_hal/furi_hal_random.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_random.c
@@ -1,8 +1,9 @@
 #include <furi_hal_random.h>
+#include <furi_hal_bus.h>
 #include <furi.h>
-#include <furi_hal.h>

 #include <stm32wbxx_ll_rng.h>
+#include <stm32wbxx_ll_rcc.h>
 #include <stm32wbxx_ll_hsem.h>

 #include <hw_conf.h>
@@ -32,6 +33,11 @@ static uint32_t furi_hal_random_read_rng() {
    return LL_RNG_ReadRandData32(RNG);
 }

+void furi_hal_random_init() {
+    furi_hal_bus_enable(FuriHalBusRNG);
+    LL_RCC_SetRNGClockSource(LL_RCC_RNG_CLKSOURCE_CLK48);
+}
+
 uint32_t furi_hal_random_get() {
    while(LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID))
        ;
@@ -40,6 +46,7 @@ uint32_t furi_hal_random_get() {
    const uint32_t random_val = furi_hal_random_read_rng();

    LL_RNG_Disable(RNG);
+    ;
    LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);

    return random_val;
--- a/firmware/targets/f7/furi_hal/furi_hal_resources.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_resources.c
@@ -1,4 +1,5 @@
 #include <furi_hal_resources.h>
+#include <furi_hal_bus.h>
 #include <furi.h>

 #include <stm32wbxx_ll_rcc.h>
@@ -111,6 +112,13 @@ static void furi_hal_resources_init_input_pins(GpioMode mode) {
 }

 void furi_hal_resources_init_early() {
+    furi_hal_bus_enable(FuriHalBusGPIOA);
+    furi_hal_bus_enable(FuriHalBusGPIOB);
+    furi_hal_bus_enable(FuriHalBusGPIOC);
+    furi_hal_bus_enable(FuriHalBusGPIOD);
+    furi_hal_bus_enable(FuriHalBusGPIOE);
+    furi_hal_bus_enable(FuriHalBusGPIOH);
+
    furi_hal_resources_init_input_pins(GpioModeInput);

    // SD Card stepdown control
@@ -155,6 +163,12 @@ void furi_hal_resources_init_early() {

 void furi_hal_resources_deinit_early() {
    furi_hal_resources_init_input_pins(GpioModeAnalog);
+    furi_hal_bus_disable(FuriHalBusGPIOA);
+    furi_hal_bus_disable(FuriHalBusGPIOB);
+    furi_hal_bus_disable(FuriHalBusGPIOC);
+    furi_hal_bus_disable(FuriHalBusGPIOD);
+    furi_hal_bus_disable(FuriHalBusGPIOE);
+    furi_hal_bus_disable(FuriHalBusGPIOH);
 }

 void furi_hal_resources_init() {
--- a/firmware/targets/f7/furi_hal/furi_hal_rfid.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_rfid.c
@@ -2,6 +2,7 @@
 #include <furi_hal_ibutton.h>
 #include <furi_hal_interrupt.h>
 #include <furi_hal_resources.h>
+#include <furi_hal_bus.h>
 #include <furi.h>

 #include <stm32wbxx_ll_tim.h>
@@ -9,15 +10,18 @@
 #include <stm32wbxx_ll_dma.h>

 #define FURI_HAL_RFID_READ_TIMER TIM1
+#define FURI_HAL_RFID_READ_TIMER_BUS FuriHalBusTIM1
 #define FURI_HAL_RFID_READ_TIMER_CHANNEL LL_TIM_CHANNEL_CH1N
 // We can't use N channel for LL_TIM_OC_Init, so...
 #define FURI_HAL_RFID_READ_TIMER_CHANNEL_CONFIG LL_TIM_CHANNEL_CH1

 #define FURI_HAL_RFID_EMULATE_TIMER TIM2
+#define FURI_HAL_RFID_EMULATE_TIMER_BUS FuriHalBusTIM2
 #define FURI_HAL_RFID_EMULATE_TIMER_IRQ FuriHalInterruptIdTIM2
 #define FURI_HAL_RFID_EMULATE_TIMER_CHANNEL LL_TIM_CHANNEL_CH3

 #define RFID_CAPTURE_TIM TIM2
+#define RFID_CAPTURE_TIM_BUS FuriHalBusTIM2
 #define RFID_CAPTURE_IND_CH LL_TIM_CHANNEL_CH3
 #define RFID_CAPTURE_DIR_CH LL_TIM_CHANNEL_CH4

@@ -30,7 +34,6 @@
 #define RFID_DMA_CH2_DEF RFID_DMA, RFID_DMA_CH2_CHANNEL

 typedef struct {
-    FuriHalRfidEmulateCallback callback;
    FuriHalRfidDMACallback dma_callback;
    FuriHalRfidReadCaptureCallback read_capture_callback;
    void* context;
@@ -56,11 +59,7 @@ void furi_hal_rfid_init() {
    COMP_InitStruct.InputPlus = LL_COMP_INPUT_PLUS_IO1;
    COMP_InitStruct.InputMinus = LL_COMP_INPUT_MINUS_1_2VREFINT;
    COMP_InitStruct.InputHysteresis = LL_COMP_HYSTERESIS_HIGH;
-#ifdef INVERT_RFID_IN
-    COMP_InitStruct.OutputPolarity = LL_COMP_OUTPUTPOL_INVERTED;
-#else
    COMP_InitStruct.OutputPolarity = LL_COMP_OUTPUTPOL_NONINVERTED;
-#endif
    COMP_InitStruct.OutputBlankingSource = LL_COMP_BLANKINGSRC_NONE;
    LL_COMP_Init(COMP1, &COMP_InitStruct);
    LL_COMP_SetCommonWindowMode(__LL_COMP_COMMON_INSTANCE(COMP1), LL_COMP_WINDOWMODE_DISABLE);
@@ -92,7 +91,7 @@ void furi_hal_rfid_pins_reset() {
    furi_hal_gpio_init(&gpio_rfid_data_in, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
 }

-void furi_hal_rfid_pins_emulate() {
+static void furi_hal_rfid_pins_emulate() {
    // ibutton low
    furi_hal_ibutton_pin_configure();
    furi_hal_ibutton_pin_write(false);
@@ -113,7 +112,7 @@ void furi_hal_rfid_pins_emulate() {
        &gpio_rfid_carrier, GpioModeAltFunctionPushPull, GpioPullNo, GpioSpeedLow, GpioAltFn2TIM2);
 }

-void furi_hal_rfid_pins_read() {
+static void furi_hal_rfid_pins_read() {
    // ibutton low
    furi_hal_ibutton_pin_configure();
    furi_hal_ibutton_pin_write(false);
@@ -142,10 +141,10 @@ void furi_hal_rfid_pin_pull_pulldown() {
    furi_hal_gpio_write(&gpio_nfc_irq_rfid_pull, false);
 }

-void furi_hal_rfid_tim_read(float freq, float duty_cycle) {
-    FURI_CRITICAL_ENTER();
-    LL_TIM_DeInit(FURI_HAL_RFID_READ_TIMER);
-    FURI_CRITICAL_EXIT();
+void furi_hal_rfid_tim_read_start(float freq, float duty_cycle) {
+    furi_hal_bus_enable(FURI_HAL_RFID_READ_TIMER_BUS);
+
+    furi_hal_rfid_pins_read();

    LL_TIM_InitTypeDef TIM_InitStruct = {0};
    TIM_InitStruct.Autoreload = (SystemCoreClock / freq) - 1;
@@ -160,23 +159,23 @@ void furi_hal_rfid_tim_read(float freq, float duty_cycle) {
        FURI_HAL_RFID_READ_TIMER, FURI_HAL_RFID_READ_TIMER_CHANNEL_CONFIG, &TIM_OC_InitStruct);

    LL_TIM_EnableCounter(FURI_HAL_RFID_READ_TIMER);
+
+    furi_hal_rfid_tim_read_continue();
 }

-void furi_hal_rfid_tim_read_start() {
+void furi_hal_rfid_tim_read_continue() {
    LL_TIM_EnableAllOutputs(FURI_HAL_RFID_READ_TIMER);
 }

-void furi_hal_rfid_tim_read_stop() {
+void furi_hal_rfid_tim_read_pause() {
    LL_TIM_DisableAllOutputs(FURI_HAL_RFID_READ_TIMER);
 }

-void furi_hal_rfid_tim_emulate(float freq) {
-    UNUSED(freq); // FIXME
-    // basic PWM setup with needed freq and internal clock
-    FURI_CRITICAL_ENTER();
-    LL_TIM_DeInit(FURI_HAL_RFID_EMULATE_TIMER);
-    FURI_CRITICAL_EXIT();
+void furi_hal_rfid_tim_read_stop() {
+    furi_hal_bus_disable(FURI_HAL_RFID_READ_TIMER_BUS);
+}

+static void furi_hal_rfid_tim_emulate() {
    LL_TIM_SetPrescaler(FURI_HAL_RFID_EMULATE_TIMER, 0);
    LL_TIM_SetCounterMode(FURI_HAL_RFID_EMULATE_TIMER, LL_TIM_COUNTERMODE_UP);
    LL_TIM_SetAutoReload(FURI_HAL_RFID_EMULATE_TIMER, 1);
@@ -201,32 +200,6 @@ void furi_hal_rfid_tim_emulate(float freq) {
    LL_TIM_GenerateEvent_UPDATE(FURI_HAL_RFID_EMULATE_TIMER);
 }

-static void furi_hal_rfid_emulate_isr() {
-    if(LL_TIM_IsActiveFlag_UPDATE(FURI_HAL_RFID_EMULATE_TIMER)) {
-        LL_TIM_ClearFlag_UPDATE(FURI_HAL_RFID_EMULATE_TIMER);
-        furi_hal_rfid->callback(furi_hal_rfid->context);
-    }
-}
-
-void furi_hal_rfid_tim_emulate_start(FuriHalRfidEmulateCallback callback, void* context) {
-    furi_assert(furi_hal_rfid);
-
-    furi_hal_rfid->callback = callback;
-    furi_hal_rfid->context = context;
-
-    furi_hal_interrupt_set_isr(FURI_HAL_RFID_EMULATE_TIMER_IRQ, furi_hal_rfid_emulate_isr, NULL);
-
-    LL_TIM_EnableIT_UPDATE(FURI_HAL_RFID_EMULATE_TIMER);
-    LL_TIM_EnableAllOutputs(FURI_HAL_RFID_EMULATE_TIMER);
-    LL_TIM_EnableCounter(FURI_HAL_RFID_EMULATE_TIMER);
-}
-
-void furi_hal_rfid_tim_emulate_stop() {
-    LL_TIM_DisableCounter(FURI_HAL_RFID_EMULATE_TIMER);
-    LL_TIM_DisableAllOutputs(FURI_HAL_RFID_EMULATE_TIMER);
-    furi_hal_interrupt_set_isr(FURI_HAL_RFID_EMULATE_TIMER_IRQ, NULL, NULL);
-}
-
 static void furi_hal_capture_dma_isr(void* context) {
    UNUSED(context);

@@ -247,15 +220,13 @@ static void furi_hal_capture_dma_isr(void* context) {
 }

 void furi_hal_rfid_tim_read_capture_start(FuriHalRfidReadCaptureCallback callback, void* context) {
-    FURI_CRITICAL_ENTER();
-    LL_TIM_DeInit(RFID_CAPTURE_TIM);
-    FURI_CRITICAL_EXIT();
-
    furi_assert(furi_hal_rfid);

    furi_hal_rfid->read_capture_callback = callback;
    furi_hal_rfid->context = context;

+    furi_hal_bus_enable(RFID_CAPTURE_TIM_BUS);
+
    // Timer: base
    LL_TIM_InitTypeDef TIM_InitStruct = {0};
    TIM_InitStruct.Prescaler = 64 - 1;
@@ -303,10 +274,7 @@ void furi_hal_rfid_tim_read_capture_stop() {
    furi_hal_rfid_comp_stop();

    furi_hal_interrupt_set_isr(FURI_HAL_RFID_EMULATE_TIMER_IRQ, NULL, NULL);
-
-    FURI_CRITICAL_ENTER();
-    LL_TIM_DeInit(RFID_CAPTURE_TIM);
-    FURI_CRITICAL_EXIT();
+    furi_hal_bus_disable(RFID_CAPTURE_TIM_BUS);
 }

 static void furi_hal_rfid_dma_isr() {
@@ -341,7 +309,8 @@ void furi_hal_rfid_tim_emulate_dma_start(
    furi_hal_rfid_pins_emulate();

    // configure timer
-    furi_hal_rfid_tim_emulate(125000);
+    furi_hal_bus_enable(FURI_HAL_RFID_EMULATE_TIMER_BUS);
+    furi_hal_rfid_tim_emulate();
    LL_TIM_OC_SetPolarity(
        FURI_HAL_RFID_EMULATE_TIMER, FURI_HAL_RFID_EMULATE_TIMER_CHANNEL, LL_TIM_OCPOLARITY_HIGH);
    LL_TIM_EnableDMAReq_UPDATE(FURI_HAL_RFID_EMULATE_TIMER);
@@ -405,32 +374,12 @@ void furi_hal_rfid_tim_emulate_dma_stop() {

    LL_DMA_DeInit(RFID_DMA_CH1_DEF);
    LL_DMA_DeInit(RFID_DMA_CH2_DEF);
-    LL_TIM_DeInit(FURI_HAL_RFID_EMULATE_TIMER);
+
+    furi_hal_bus_disable(FURI_HAL_RFID_EMULATE_TIMER_BUS);

    FURI_CRITICAL_EXIT();
 }

-void furi_hal_rfid_tim_reset() {
-    FURI_CRITICAL_ENTER();
-
-    LL_TIM_DeInit(FURI_HAL_RFID_READ_TIMER);
-    LL_TIM_DeInit(FURI_HAL_RFID_EMULATE_TIMER);
-
-    FURI_CRITICAL_EXIT();
-}
-
-void furi_hal_rfid_set_emulate_period(uint32_t period) {
-    LL_TIM_SetAutoReload(FURI_HAL_RFID_EMULATE_TIMER, period);
-}
-
-void furi_hal_rfid_set_emulate_pulse(uint32_t pulse) {
-#if FURI_HAL_RFID_EMULATE_TIMER_CHANNEL == LL_TIM_CHANNEL_CH3
-    LL_TIM_OC_SetCompareCH3(FURI_HAL_RFID_EMULATE_TIMER, pulse);
-#else
-#error Update this code. Would you kindly?
-#endif
-}
-
 void furi_hal_rfid_set_read_period(uint32_t period) {
    LL_TIM_SetAutoReload(FURI_HAL_RFID_READ_TIMER, period);
 }
@@ -443,12 +392,6 @@ void furi_hal_rfid_set_read_pulse(uint32_t pulse) {
 #endif
 }

-void furi_hal_rfid_change_read_config(float freq, float duty_cycle) {
-    uint32_t period = (uint32_t)((SystemCoreClock) / freq) - 1;
-    furi_hal_rfid_set_read_period(period);
-    furi_hal_rfid_set_read_pulse(period * duty_cycle);
-}
-
 void furi_hal_rfid_comp_start() {
    LL_COMP_Enable(COMP1);
    // Magic
@@ -483,4 +426,4 @@ void COMP_IRQHandler() {
            (LL_COMP_ReadOutputLevel(COMP1) == LL_COMP_OUTPUT_LEVEL_LOW),
            furi_hal_rfid_comp_callback_context);
    }
-}
+}
--- a/firmware/targets/f7/furi_hal/furi_hal_rfid.h
+++ b/firmware/targets/f7/furi_hal/furi_hal_rfid.h
@@ -21,14 +21,6 @@ void furi_hal_rfid_init();
 */
 void furi_hal_rfid_pins_reset();

-/** Config rfid pins to emulate state
- */
-void furi_hal_rfid_pins_emulate();
-
-/** Config rfid pins to read state
- */
-void furi_hal_rfid_pins_read();
-
 /** Release rfid pull pin
 */
 void furi_hal_rfid_pin_pull_release();
@@ -37,33 +29,24 @@ void furi_hal_rfid_pin_pull_release();
 */
 void furi_hal_rfid_pin_pull_pulldown();

-/** Config rfid timer to read state
- *
+/** Start read timer
 * @param      freq        timer frequency
 * @param      duty_cycle  timer duty cycle, 0.0-1.0
 */
-void furi_hal_rfid_tim_read(float freq, float duty_cycle);
+void furi_hal_rfid_tim_read_start(float freq, float duty_cycle);

-/** Start read timer
+/** Pause read timer, to be able to continue later
 */
-void furi_hal_rfid_tim_read_start();
+void furi_hal_rfid_tim_read_pause();
+
+/** Continue read timer
+ */
+void furi_hal_rfid_tim_read_continue();

 /** Stop read timer
 */
 void furi_hal_rfid_tim_read_stop();

-/** Config rfid timer to emulate state
- *
- * @param      freq  timer frequency
- */
-void furi_hal_rfid_tim_emulate(float freq);
-
-typedef void (*FuriHalRfidEmulateCallback)(void* context);
-
-/** Start emulation timer
- */
-void furi_hal_rfid_tim_emulate_start(FuriHalRfidEmulateCallback callback, void* context);
-
 typedef void (*FuriHalRfidReadCaptureCallback)(bool level, uint32_t duration, void* context);

 void furi_hal_rfid_tim_read_capture_start(FuriHalRfidReadCaptureCallback callback, void* context);
@@ -81,26 +64,6 @@ void furi_hal_rfid_tim_emulate_dma_start(

 void furi_hal_rfid_tim_emulate_dma_stop();

-/** Stop emulation timer
- */
-void furi_hal_rfid_tim_emulate_stop();
-
-/** Config rfid timers to reset state
- */
-void furi_hal_rfid_tim_reset();
-
-/** Set emulation timer period
- *
- * @param      period  overall duration
- */
-void furi_hal_rfid_set_emulate_period(uint32_t period);
-
-/** Set emulation timer pulse
- *
- * @param      pulse  duration of high level
- */
-void furi_hal_rfid_set_emulate_pulse(uint32_t pulse);
-
 /** Set read timer period
 *
 * @param      period  overall duration
@@ -113,13 +76,6 @@ void furi_hal_rfid_set_read_period(uint32_t period);
 */
 void furi_hal_rfid_set_read_pulse(uint32_t pulse);

-/** Сhanges the configuration of the RFID timer "on a fly"
- *
- * @param      freq        new frequency
- * @param      duty_cycle  new duty cycle
- */
-void furi_hal_rfid_change_read_config(float freq, float duty_cycle);
-
 /** Start/Enable comparator */
 void furi_hal_rfid_comp_start();

--- a/firmware/targets/f7/furi_hal/furi_hal_rtc.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_rtc.c
@@ -2,8 +2,8 @@
 #include <furi_hal_light.h>
 #include <furi_hal_debug.h>

-#include <stm32wbxx_ll_bus.h>
 #include <stm32wbxx_ll_pwr.h>
+#include <stm32wbxx_ll_bus.h>
 #include <stm32wbxx_ll_rcc.h>
 #include <stm32wbxx_ll_rtc.h>
 #include <stm32wbxx_ll_utils.h>
@@ -44,10 +44,8 @@ _Static_assert(sizeof(SystemReg) == 4, "SystemReg size mismatch");
 #define FURI_HAL_RTC_SECONDS_PER_DAY (FURI_HAL_RTC_SECONDS_PER_HOUR * 24)
 #define FURI_HAL_RTC_MONTHS_COUNT 12
 #define FURI_HAL_RTC_EPOCH_START_YEAR 1970
-#define FURI_HAL_RTC_IS_LEAP_YEAR(year) \
-    ((((year) % 4 == 0) && ((year) % 100 != 0)) || ((year) % 400 == 0))

-static const uint8_t furi_hal_rtc_days_per_month[][FURI_HAL_RTC_MONTHS_COUNT] = {
+static const uint8_t furi_hal_rtc_days_per_month[2][FURI_HAL_RTC_MONTHS_COUNT] = {
    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
    {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};

@@ -395,7 +393,7 @@ uint32_t furi_hal_rtc_datetime_to_timestamp(FuriHalRtcDateTime* datetime) {
    uint8_t leap_years = 0;

    for(uint16_t y = FURI_HAL_RTC_EPOCH_START_YEAR; y < datetime->year; y++) {
-        if(FURI_HAL_RTC_IS_LEAP_YEAR(y)) {
+        if(furi_hal_rtc_is_leap_year(y)) {
            leap_years++;
        } else {
            years++;
@@ -406,10 +404,10 @@ uint32_t furi_hal_rtc_datetime_to_timestamp(FuriHalRtcDateTime* datetime) {
        ((years * furi_hal_rtc_days_per_year[0]) + (leap_years * furi_hal_rtc_days_per_year[1])) *
        FURI_HAL_RTC_SECONDS_PER_DAY;

-    uint8_t year_index = (FURI_HAL_RTC_IS_LEAP_YEAR(datetime->year)) ? 1 : 0;
+    bool leap_year = furi_hal_rtc_is_leap_year(datetime->year);

-    for(uint8_t m = 0; m < (datetime->month - 1); m++) {
-        timestamp += furi_hal_rtc_days_per_month[year_index][m] * FURI_HAL_RTC_SECONDS_PER_DAY;
+    for(uint8_t m = 1; m < datetime->month; m++) {
+        timestamp += furi_hal_rtc_get_days_per_month(leap_year, m) * FURI_HAL_RTC_SECONDS_PER_DAY;
    }

    timestamp += (datetime->day - 1) * FURI_HAL_RTC_SECONDS_PER_DAY;
@@ -419,3 +417,15 @@ uint32_t furi_hal_rtc_datetime_to_timestamp(FuriHalRtcDateTime* datetime) {

    return timestamp;
 }
+
+uint16_t furi_hal_rtc_get_days_per_year(uint16_t year) {
+    return furi_hal_rtc_days_per_year[furi_hal_rtc_is_leap_year(year) ? 1 : 0];
+}
+
+bool furi_hal_rtc_is_leap_year(uint16_t year) {
+    return (((year) % 4 == 0) && ((year) % 100 != 0)) || ((year) % 400 == 0);
+}
+
+uint8_t furi_hal_rtc_get_days_per_month(bool leap_year, uint8_t month) {
+    return furi_hal_rtc_days_per_month[leap_year ? 1 : 0][month - 1];
+}
--- a/firmware/targets/f7/furi_hal/furi_hal_speaker.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_speaker.c
@@ -2,6 +2,7 @@
 #include <furi_hal_gpio.h>
 #include <furi_hal_resources.h>
 #include <furi_hal_power.h>
+#include <furi_hal_bus.h>

 #include <stm32wbxx_ll_tim.h>
 #include <furi_hal_cortex.h>
@@ -20,16 +21,11 @@ static FuriMutex* furi_hal_speaker_mutex = NULL;
 void furi_hal_speaker_init() {
    furi_assert(furi_hal_speaker_mutex == NULL);
    furi_hal_speaker_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
-    FURI_CRITICAL_ENTER();
-    LL_TIM_DeInit(FURI_HAL_SPEAKER_TIMER);
-    FURI_CRITICAL_EXIT();
    FURI_LOG_I(TAG, "Init OK");
 }

 void furi_hal_speaker_deinit() {
    furi_check(furi_hal_speaker_mutex != NULL);
-    LL_TIM_DeInit(FURI_HAL_SPEAKER_TIMER);
-    furi_hal_gpio_init(&gpio_speaker, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
    furi_mutex_free(furi_hal_speaker_mutex);
    furi_hal_speaker_mutex = NULL;
 }
@@ -39,6 +35,7 @@ bool furi_hal_speaker_acquire(uint32_t timeout) {

    if(furi_mutex_acquire(furi_hal_speaker_mutex, timeout) == FuriStatusOk) {
        furi_hal_power_insomnia_enter();
+        furi_hal_bus_enable(FuriHalBusTIM16);
        furi_hal_gpio_init_ex(
            &gpio_speaker, GpioModeAltFunctionPushPull, GpioPullNo, GpioSpeedLow, GpioAltFn14TIM16);
        return true;
@@ -53,6 +50,8 @@ void furi_hal_speaker_release() {

    furi_hal_speaker_stop();
    furi_hal_gpio_init(&gpio_speaker, GpioModeAnalog, GpioPullDown, GpioSpeedLow);
+
+    furi_hal_bus_disable(FuriHalBusTIM16);
    furi_hal_power_insomnia_exit();

    furi_check(furi_mutex_release(furi_hal_speaker_mutex) == FuriStatusOk);
--- a/firmware/targets/f7/furi_hal/furi_hal_spi_config.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_spi_config.c
@@ -1,6 +1,7 @@
 #include <furi_hal_spi_config.h>
 #include <furi_hal_resources.h>
 #include <furi_hal_spi.h>
+#include <furi_hal_bus.h>
 #include <furi.h>
 #include <furi_hal_subghz.h>

@@ -101,28 +102,17 @@ void furi_hal_spi_config_init() {
 static void furi_hal_spi_bus_r_event_callback(FuriHalSpiBus* bus, FuriHalSpiBusEvent event) {
    if(event == FuriHalSpiBusEventInit) {
        furi_hal_spi_bus_r_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
-        FURI_CRITICAL_ENTER();
-        LL_APB2_GRP1_ForceReset(LL_APB2_GRP1_PERIPH_SPI1);
-        FURI_CRITICAL_EXIT();
        bus->current_handle = NULL;
    } else if(event == FuriHalSpiBusEventDeinit) {
        furi_mutex_free(furi_hal_spi_bus_r_mutex);
-        FURI_CRITICAL_ENTER();
-        LL_APB2_GRP1_ForceReset(LL_APB2_GRP1_PERIPH_SPI1);
-        LL_APB2_GRP1_ReleaseReset(LL_APB2_GRP1_PERIPH_SPI1);
-        FURI_CRITICAL_EXIT();
    } else if(event == FuriHalSpiBusEventLock) {
        furi_check(furi_mutex_acquire(furi_hal_spi_bus_r_mutex, FuriWaitForever) == FuriStatusOk);
    } else if(event == FuriHalSpiBusEventUnlock) {
        furi_check(furi_mutex_release(furi_hal_spi_bus_r_mutex) == FuriStatusOk);
    } else if(event == FuriHalSpiBusEventActivate) {
-        FURI_CRITICAL_ENTER();
-        LL_APB2_GRP1_ReleaseReset(LL_APB2_GRP1_PERIPH_SPI1);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_enable(FuriHalBusSPI1);
    } else if(event == FuriHalSpiBusEventDeactivate) {
-        FURI_CRITICAL_ENTER();
-        LL_APB2_GRP1_ForceReset(LL_APB2_GRP1_PERIPH_SPI1);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_disable(FuriHalBusSPI1);
    }
 }

@@ -136,28 +126,17 @@ FuriMutex* furi_hal_spi_bus_d_mutex = NULL;
 static void furi_hal_spi_bus_d_event_callback(FuriHalSpiBus* bus, FuriHalSpiBusEvent event) {
    if(event == FuriHalSpiBusEventInit) {
        furi_hal_spi_bus_d_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
-        FURI_CRITICAL_ENTER();
-        LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_SPI2);
-        FURI_CRITICAL_EXIT();
        bus->current_handle = NULL;
    } else if(event == FuriHalSpiBusEventDeinit) {
        furi_mutex_free(furi_hal_spi_bus_d_mutex);
-        FURI_CRITICAL_ENTER();
-        LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_SPI2);
-        LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_SPI2);
-        FURI_CRITICAL_EXIT();
    } else if(event == FuriHalSpiBusEventLock) {
        furi_check(furi_mutex_acquire(furi_hal_spi_bus_d_mutex, FuriWaitForever) == FuriStatusOk);
    } else if(event == FuriHalSpiBusEventUnlock) {
        furi_check(furi_mutex_release(furi_hal_spi_bus_d_mutex) == FuriStatusOk);
    } else if(event == FuriHalSpiBusEventActivate) {
-        FURI_CRITICAL_ENTER();
-        LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_SPI2);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_enable(FuriHalBusSPI2);
    } else if(event == FuriHalSpiBusEventDeactivate) {
-        FURI_CRITICAL_ENTER();
-        LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_SPI2);
-        FURI_CRITICAL_EXIT();
+        furi_hal_bus_disable(FuriHalBusSPI2);
    }
 }

--- a/firmware/targets/f7/furi_hal/furi_hal_spi_types.h
+++ b/firmware/targets/f7/furi_hal/furi_hal_spi_types.h
@@ -6,8 +6,6 @@
 #include <furi_hal_gpio.h>

 #include <stm32wbxx_ll_spi.h>
-#include <stm32wbxx_ll_rcc.h>
-#include <stm32wbxx_ll_bus.h>

 #ifdef __cplusplus
 extern "C" {
--- a/firmware/targets/f7/furi_hal/furi_hal_uart.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_uart.c
@@ -4,6 +4,7 @@
 #include <stm32wbxx_ll_usart.h>
 #include <stm32wbxx_ll_rcc.h>
 #include <furi_hal_resources.h>
+#include <furi_hal_bus.h>

 #include <furi.h>

@@ -13,6 +14,9 @@ static void (*irq_cb[2])(uint8_t ev, uint8_t data, void* context);
 static void* irq_ctx[2];

 static void furi_hal_usart_init(uint32_t baud) {
+    furi_hal_bus_enable(FuriHalBusUSART1);
+    LL_RCC_SetUSARTClockSource(LL_RCC_USART1_CLKSOURCE_PCLK2);
+
    furi_hal_gpio_init_ex(
        &gpio_usart_tx,
        GpioModeAltFunctionPushPull,
@@ -50,6 +54,9 @@ static void furi_hal_usart_init(uint32_t baud) {
 }

 static void furi_hal_lpuart_init(uint32_t baud) {
+    furi_hal_bus_enable(FuriHalBusLPUART1);
+    LL_RCC_SetLPUARTClockSource(LL_RCC_LPUART1_CLKSOURCE_PCLK1);
+
    furi_hal_gpio_init_ex(
        &gpio_ext_pc0,
        GpioModeAltFunctionPushPull,
@@ -86,10 +93,11 @@ static void furi_hal_lpuart_init(uint32_t baud) {
 }

 void furi_hal_uart_init(FuriHalUartId ch, uint32_t baud) {
-    if(ch == FuriHalUartIdLPUART1)
+    if(ch == FuriHalUartIdLPUART1) {
        furi_hal_lpuart_init(baud);
-    else if(ch == FuriHalUartIdUSART1)
+    } else if(ch == FuriHalUartIdUSART1) {
        furi_hal_usart_init(baud);
+    }
 }

 void furi_hal_uart_set_br(FuriHalUartId ch, uint32_t baud) {
@@ -126,11 +134,15 @@ void furi_hal_uart_set_br(FuriHalUartId ch, uint32_t baud) {
 void furi_hal_uart_deinit(FuriHalUartId ch) {
    furi_hal_uart_set_irq_cb(ch, NULL, NULL);
    if(ch == FuriHalUartIdUSART1) {
-        LL_USART_Disable(USART1);
+        if(furi_hal_bus_is_enabled(FuriHalBusUSART1)) {
+            furi_hal_bus_disable(FuriHalBusUSART1);
+        }
        furi_hal_gpio_init(&gpio_usart_tx, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
        furi_hal_gpio_init(&gpio_usart_rx, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
    } else if(ch == FuriHalUartIdLPUART1) {
-        LL_LPUART_Disable(LPUART1);
+        if(furi_hal_bus_is_enabled(FuriHalBusLPUART1)) {
+            furi_hal_bus_disable(FuriHalBusLPUART1);
+        }
        furi_hal_gpio_init(&gpio_ext_pc0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
        furi_hal_gpio_init(&gpio_ext_pc1, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
    }
--- a/firmware/targets/f7/furi_hal/furi_hal_usb.c
+++ b/firmware/targets/f7/furi_hal/furi_hal_usb.c
@@ -2,7 +2,9 @@
 #include <furi_hal_usb_i.h>
 #include <furi_hal_usb.h>
 #include <furi_hal_power.h>
+
 #include <stm32wbxx_ll_pwr.h>
+#include <stm32wbxx_ll_rcc.h>
 #include <furi.h>
 #include <toolbox/api_lock.h>

@@ -86,6 +88,8 @@ static void wkup_evt(usbd_device* dev, uint8_t event, uint8_t ep);

 /* Low-level init */
 void furi_hal_usb_init(void) {
+    LL_RCC_SetUSBClockSource(LL_RCC_USB_CLKSOURCE_PLLSAI1);
+
    LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
    LL_PWR_EnableVddUSB();

@@ -98,7 +102,10 @@ void furi_hal_usb_init(void) {
    LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    usbd_init(&udev, &usbd_hw, USB_EP0_SIZE, ubuf, sizeof(ubuf));
+
+    FURI_CRITICAL_ENTER();
    usbd_enable(&udev, true);
+    FURI_CRITICAL_EXIT();

    usbd_reg_descr(&udev, usb_descriptor_get);
    usbd_reg_event(&udev, usbd_evt_susp, susp_evt);
@@ -359,8 +366,10 @@ static void usb_process_mode_reinit() {
    usbd_connect(&udev, false);
    usb.enabled = false;

+    FURI_CRITICAL_ENTER();
    usbd_enable(&udev, false);
    usbd_enable(&udev, true);
+    FURI_CRITICAL_EXIT();

    furi_delay_ms(USB_RECONNECT_DELAY);
    usb_process_mode_start(usb.interface, usb.interface_context);
--- a/firmware/targets/f7/src/update.c
+++ b/firmware/targets/f7/src/update.c
@@ -38,6 +38,12 @@ static bool flipper_update_mount_sd() {
 }

 static bool flipper_update_init() {
+    // TODO: Configure missing peripherals properly
+    furi_hal_bus_enable(FuriHalBusHSEM);
+    furi_hal_bus_enable(FuriHalBusIPCC);
+    furi_hal_bus_enable(FuriHalBusRNG);
+    furi_hal_bus_enable(FuriHalBusUSART1);
+
    furi_hal_clock_init();
    furi_hal_rtc_init();
    furi_hal_interrupt_init();