[FL-3629] fbt: reworked assets & resources handling (#3160)
* fbt: reworking targets & assets handling WIP * fbt: dist fixes * fbt: moved SD card resources to owning apps * unit_tests: moved resources to app folder * github: updated unit_tests paths * github: packaging fixes * unit_tests: fixes * fbt: assets: internal cleanup * fbt: reworked assets handling * github: unit_tests: reintroducing fixes * minor cleanup * fbt: naming changes to reflect private nature of scons tools * fbt: resources: fixed dist archive paths * docs: updated paths * docs: updated more paths * docs: included "resources" parameter in app manifest docs; updated assets readme * updated gitignore for assets * github: updated action versions * unit_tests: restored timeout; scripts: assets: logging changes * gh: don't upload desktop animations for unit test run Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
hedger
@@ -0,0 +1,72 @@
|
||||
#include <furi_hal.h>
|
||||
#include <furi_hal_mpu.h>
|
||||
#include <furi_hal_memory.h>
|
||||
|
||||
#include <stm32wbxx_ll_cortex.h>
|
||||
|
||||
#define TAG "FuriHal"
|
||||
|
||||
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();
|
||||
furi_hal_i2c_init_early();
|
||||
furi_hal_light_init();
|
||||
furi_hal_rtc_init_early();
|
||||
}
|
||||
|
||||
void furi_hal_deinit_early() {
|
||||
furi_hal_rtc_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();
|
||||
furi_hal_flash_init();
|
||||
furi_hal_resources_init();
|
||||
furi_hal_version_init();
|
||||
furi_hal_region_init();
|
||||
furi_hal_spi_config_init();
|
||||
furi_hal_spi_dma_init();
|
||||
furi_hal_ibutton_init();
|
||||
furi_hal_speaker_init();
|
||||
furi_hal_crypto_init();
|
||||
furi_hal_i2c_init();
|
||||
furi_hal_power_init();
|
||||
furi_hal_light_init();
|
||||
furi_hal_bt_init();
|
||||
furi_hal_memory_init();
|
||||
|
||||
#ifndef FURI_RAM_EXEC
|
||||
furi_hal_usb_init();
|
||||
furi_hal_vibro_init();
|
||||
furi_hal_subghz_init();
|
||||
furi_hal_nfc_init();
|
||||
furi_hal_rfid_init();
|
||||
#endif
|
||||
}
|
||||
|
||||
void furi_hal_switch(void* address) {
|
||||
__set_BASEPRI(0);
|
||||
asm volatile("ldr r3, [%0] \n"
|
||||
"msr msp, r3 \n"
|
||||
"ldr r3, [%1] \n"
|
||||
"mov pc, r3 \n"
|
||||
:
|
||||
: "r"(address), "r"(address + 0x4)
|
||||
: "r3");
|
||||
}
|
||||
@@ -0,0 +1,494 @@
|
||||
#include <furi_hal_bt.h>
|
||||
|
||||
#include <ble/ble.h>
|
||||
#include <interface/patterns/ble_thread/shci/shci.h>
|
||||
|
||||
#include <stm32wbxx.h>
|
||||
#include <stm32wbxx_ll_hsem.h>
|
||||
|
||||
#include <hsem_map.h>
|
||||
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_power.h>
|
||||
#include <furi_hal_bt_hid.h>
|
||||
#include <furi_hal_bt_serial.h>
|
||||
#include <furi_hal_bus.c>
|
||||
#include <services/battery_service.h>
|
||||
#include <furi.h>
|
||||
|
||||
#define TAG "FuriHalBt"
|
||||
|
||||
#define FURI_HAL_BT_DEFAULT_MAC_ADDR \
|
||||
{ 0x6c, 0x7a, 0xd8, 0xac, 0x57, 0x72 }
|
||||
|
||||
/* Time, in ms, to wait for mode transition before crashing */
|
||||
#define C2_MODE_SWITCH_TIMEOUT 10000
|
||||
|
||||
#define FURI_HAL_BT_HARDFAULT_INFO_MAGIC 0x1170FD0F
|
||||
|
||||
typedef struct {
|
||||
FuriMutex* core2_mtx;
|
||||
FuriTimer* hardfault_check_timer;
|
||||
FuriHalBtStack stack;
|
||||
} FuriHalBt;
|
||||
|
||||
static FuriHalBt furi_hal_bt = {
|
||||
.core2_mtx = NULL,
|
||||
.hardfault_check_timer = NULL,
|
||||
.stack = FuriHalBtStackUnknown,
|
||||
};
|
||||
|
||||
typedef void (*FuriHalBtProfileStart)(void);
|
||||
typedef void (*FuriHalBtProfileStop)(void);
|
||||
|
||||
typedef struct {
|
||||
FuriHalBtProfileStart start;
|
||||
FuriHalBtProfileStart stop;
|
||||
GapConfig config;
|
||||
uint16_t appearance_char;
|
||||
uint16_t advertise_service_uuid;
|
||||
} FuriHalBtProfileConfig;
|
||||
|
||||
FuriHalBtProfileConfig profile_config[FuriHalBtProfileNumber] = {
|
||||
[FuriHalBtProfileSerial] =
|
||||
{
|
||||
.start = furi_hal_bt_serial_start,
|
||||
.stop = furi_hal_bt_serial_stop,
|
||||
.config =
|
||||
{
|
||||
.adv_service_uuid = 0x3080,
|
||||
.appearance_char = 0x8600,
|
||||
.bonding_mode = true,
|
||||
.pairing_method = GapPairingPinCodeShow,
|
||||
.mac_address = FURI_HAL_BT_DEFAULT_MAC_ADDR,
|
||||
.conn_param =
|
||||
{
|
||||
.conn_int_min = 0x18, // 30 ms
|
||||
.conn_int_max = 0x24, // 45 ms
|
||||
.slave_latency = 0,
|
||||
.supervisor_timeout = 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
[FuriHalBtProfileHidKeyboard] =
|
||||
{
|
||||
.start = furi_hal_bt_hid_start,
|
||||
.stop = furi_hal_bt_hid_stop,
|
||||
.config =
|
||||
{
|
||||
.adv_service_uuid = HUMAN_INTERFACE_DEVICE_SERVICE_UUID,
|
||||
.appearance_char = GAP_APPEARANCE_KEYBOARD,
|
||||
.bonding_mode = true,
|
||||
.pairing_method = GapPairingPinCodeVerifyYesNo,
|
||||
.mac_address = FURI_HAL_BT_DEFAULT_MAC_ADDR,
|
||||
.conn_param =
|
||||
{
|
||||
.conn_int_min = 0x18, // 30 ms
|
||||
.conn_int_max = 0x24, // 45 ms
|
||||
.slave_latency = 0,
|
||||
.supervisor_timeout = 0,
|
||||
},
|
||||
},
|
||||
},
|
||||
};
|
||||
FuriHalBtProfileConfig* current_profile = NULL;
|
||||
|
||||
static void furi_hal_bt_hardfault_check(void* context) {
|
||||
UNUSED(context);
|
||||
if(furi_hal_bt_get_hardfault_info()) {
|
||||
furi_crash("ST(R) Copro(R) HardFault");
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_bt_init() {
|
||||
furi_hal_bus_enable(FuriHalBusHSEM);
|
||||
furi_hal_bus_enable(FuriHalBusIPCC);
|
||||
furi_hal_bus_enable(FuriHalBusAES2);
|
||||
furi_hal_bus_enable(FuriHalBusPKA);
|
||||
furi_hal_bus_enable(FuriHalBusCRC);
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
// Explicitly tell that we are in charge of CLK48 domain
|
||||
furi_check(LL_HSEM_1StepLock(HSEM, CFG_HW_CLK48_CONFIG_SEMID) == 0);
|
||||
|
||||
// Start Core2
|
||||
ble_glue_init();
|
||||
}
|
||||
|
||||
void furi_hal_bt_lock_core2() {
|
||||
furi_assert(furi_hal_bt.core2_mtx);
|
||||
furi_check(furi_mutex_acquire(furi_hal_bt.core2_mtx, FuriWaitForever) == FuriStatusOk);
|
||||
}
|
||||
|
||||
void furi_hal_bt_unlock_core2() {
|
||||
furi_assert(furi_hal_bt.core2_mtx);
|
||||
furi_check(furi_mutex_release(furi_hal_bt.core2_mtx) == FuriStatusOk);
|
||||
}
|
||||
|
||||
static bool furi_hal_bt_radio_stack_is_supported(const BleGlueC2Info* info) {
|
||||
bool supported = false;
|
||||
if(info->StackType == INFO_STACK_TYPE_BLE_LIGHT) {
|
||||
if(info->VersionMajor >= FURI_HAL_BT_STACK_VERSION_MAJOR &&
|
||||
info->VersionMinor >= FURI_HAL_BT_STACK_VERSION_MINOR) {
|
||||
furi_hal_bt.stack = FuriHalBtStackLight;
|
||||
supported = true;
|
||||
}
|
||||
} 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) {
|
||||
furi_hal_bt.stack = FuriHalBtStackFull;
|
||||
supported = true;
|
||||
}
|
||||
} else {
|
||||
furi_hal_bt.stack = FuriHalBtStackUnknown;
|
||||
}
|
||||
return supported;
|
||||
}
|
||||
|
||||
bool furi_hal_bt_start_radio_stack() {
|
||||
bool res = false;
|
||||
furi_assert(furi_hal_bt.core2_mtx);
|
||||
|
||||
furi_mutex_acquire(furi_hal_bt.core2_mtx, FuriWaitForever);
|
||||
|
||||
// Explicitly tell that we are in charge of CLK48 domain
|
||||
furi_check(LL_HSEM_1StepLock(HSEM, CFG_HW_CLK48_CONFIG_SEMID) == 0);
|
||||
|
||||
do {
|
||||
// Wait until C2 is started or timeout
|
||||
if(!ble_glue_wait_for_c2_start(FURI_HAL_BT_C2_START_TIMEOUT)) {
|
||||
FURI_LOG_E(TAG, "Core2 start failed");
|
||||
ble_glue_thread_stop();
|
||||
break;
|
||||
}
|
||||
|
||||
// If C2 is running, start radio stack fw
|
||||
if(!furi_hal_bt_ensure_c2_mode(BleGlueC2ModeStack)) {
|
||||
break;
|
||||
}
|
||||
|
||||
// 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)) {
|
||||
FURI_LOG_E(TAG, "Unsupported radio stack");
|
||||
// Don't stop SHCI for crypto enclave support
|
||||
break;
|
||||
}
|
||||
// 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);
|
||||
furi_mutex_release(furi_hal_bt.core2_mtx);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
FuriHalBtStack furi_hal_bt_get_radio_stack() {
|
||||
return furi_hal_bt.stack;
|
||||
}
|
||||
|
||||
bool furi_hal_bt_is_ble_gatt_gap_supported() {
|
||||
if(furi_hal_bt.stack == FuriHalBtStackLight || furi_hal_bt.stack == FuriHalBtStackFull) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_bt_is_testing_supported() {
|
||||
if(furi_hal_bt.stack == FuriHalBtStackFull) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_bt_start_app(FuriHalBtProfile profile, GapEventCallback event_cb, void* context) {
|
||||
furi_assert(event_cb);
|
||||
furi_assert(profile < FuriHalBtProfileNumber);
|
||||
bool ret = false;
|
||||
|
||||
do {
|
||||
if(!ble_glue_is_radio_stack_ready()) {
|
||||
FURI_LOG_E(TAG, "Can't start BLE App - radio stack did not start");
|
||||
break;
|
||||
}
|
||||
if(!furi_hal_bt_is_ble_gatt_gap_supported()) {
|
||||
FURI_LOG_E(TAG, "Can't start Ble App - unsupported radio stack");
|
||||
break;
|
||||
}
|
||||
// Set mac address
|
||||
memcpy(
|
||||
profile_config[profile].config.mac_address,
|
||||
furi_hal_version_get_ble_mac(),
|
||||
sizeof(profile_config[profile].config.mac_address));
|
||||
// Set advertise name
|
||||
strlcpy(
|
||||
profile_config[profile].config.adv_name,
|
||||
furi_hal_version_get_ble_local_device_name_ptr(),
|
||||
FURI_HAL_VERSION_DEVICE_NAME_LENGTH);
|
||||
// Configure GAP
|
||||
GapConfig* config = &profile_config[profile].config;
|
||||
if(profile == FuriHalBtProfileSerial) {
|
||||
config->adv_service_uuid |= furi_hal_version_get_hw_color();
|
||||
} else if(profile == FuriHalBtProfileHidKeyboard) {
|
||||
// Change MAC address for HID profile
|
||||
config->mac_address[2]++;
|
||||
// Change name Flipper -> Control
|
||||
const char* clicker_str = "Control";
|
||||
memcpy(&config->adv_name[1], clicker_str, strlen(clicker_str));
|
||||
}
|
||||
if(!gap_init(config, event_cb, context)) {
|
||||
gap_thread_stop();
|
||||
FURI_LOG_E(TAG, "Failed to init GAP");
|
||||
break;
|
||||
}
|
||||
// Start selected profile services
|
||||
if(furi_hal_bt_is_ble_gatt_gap_supported()) {
|
||||
profile_config[profile].start();
|
||||
}
|
||||
ret = true;
|
||||
} while(false);
|
||||
current_profile = &profile_config[profile];
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void furi_hal_bt_reinit() {
|
||||
furi_hal_power_insomnia_enter();
|
||||
FURI_LOG_I(TAG, "Disconnect and stop advertising");
|
||||
furi_hal_bt_stop_advertising();
|
||||
|
||||
FURI_LOG_I(TAG, "Stop current profile services");
|
||||
current_profile->stop();
|
||||
|
||||
// Magic happens here
|
||||
hci_reset();
|
||||
|
||||
FURI_LOG_I(TAG, "Stop BLE related RTOS threads");
|
||||
ble_app_thread_stop();
|
||||
gap_thread_stop();
|
||||
|
||||
FURI_LOG_I(TAG, "Reset SHCI");
|
||||
furi_check(ble_glue_reinit_c2());
|
||||
|
||||
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_hal_bus_disable(FuriHalBusCRC);
|
||||
|
||||
FURI_LOG_I(TAG, "Start BT initialization");
|
||||
furi_hal_bt_init();
|
||||
|
||||
furi_hal_bt_start_radio_stack();
|
||||
furi_hal_power_insomnia_exit();
|
||||
}
|
||||
|
||||
bool furi_hal_bt_change_app(FuriHalBtProfile profile, GapEventCallback event_cb, void* context) {
|
||||
furi_assert(event_cb);
|
||||
furi_assert(profile < FuriHalBtProfileNumber);
|
||||
bool ret = true;
|
||||
|
||||
furi_hal_bt_reinit();
|
||||
|
||||
ret = furi_hal_bt_start_app(profile, event_cb, context);
|
||||
if(ret) {
|
||||
current_profile = &profile_config[profile];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool furi_hal_bt_is_active() {
|
||||
return gap_get_state() > GapStateIdle;
|
||||
}
|
||||
|
||||
void furi_hal_bt_start_advertising() {
|
||||
if(gap_get_state() == GapStateIdle) {
|
||||
gap_start_advertising();
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_bt_stop_advertising() {
|
||||
if(furi_hal_bt_is_active()) {
|
||||
gap_stop_advertising();
|
||||
while(furi_hal_bt_is_active()) {
|
||||
furi_delay_tick(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_bt_update_battery_level(uint8_t battery_level) {
|
||||
if(battery_svc_is_started()) {
|
||||
battery_svc_update_level(battery_level);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_bt_update_power_state() {
|
||||
if(battery_svc_is_started()) {
|
||||
battery_svc_update_power_state();
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
void furi_hal_bt_set_key_storage_change_callback(
|
||||
BleGlueKeyStorageChangedCallback callback,
|
||||
void* context) {
|
||||
furi_assert(callback);
|
||||
ble_glue_set_key_storage_changed_callback(callback, context);
|
||||
}
|
||||
|
||||
void furi_hal_bt_nvm_sram_sem_acquire() {
|
||||
while(LL_HSEM_1StepLock(HSEM, CFG_HW_BLE_NVM_SRAM_SEMID)) {
|
||||
furi_thread_yield();
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_bt_nvm_sram_sem_release() {
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_BLE_NVM_SRAM_SEMID, 0);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
void furi_hal_bt_dump_state(FuriString* buffer) {
|
||||
if(furi_hal_bt_is_alive()) {
|
||||
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(
|
||||
&HCI_Version, &HCI_Revision, &LMP_PAL_Version, &Manufacturer_Name, &LMP_PAL_Subversion);
|
||||
|
||||
furi_string_cat_printf(
|
||||
buffer,
|
||||
"Ret: %d, HCI_Version: %d, HCI_Revision: %d, LMP_PAL_Version: %d, Manufacturer_Name: %d, LMP_PAL_Subversion: %d",
|
||||
ret,
|
||||
HCI_Version,
|
||||
HCI_Revision,
|
||||
LMP_PAL_Version,
|
||||
Manufacturer_Name,
|
||||
LMP_PAL_Subversion);
|
||||
} else {
|
||||
furi_string_cat_printf(buffer, "BLE not ready");
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_bt_is_alive() {
|
||||
return ble_glue_is_alive();
|
||||
}
|
||||
|
||||
void furi_hal_bt_start_tone_tx(uint8_t channel, uint8_t power) {
|
||||
aci_hal_set_tx_power_level(0, power);
|
||||
aci_hal_tone_start(channel, 0);
|
||||
}
|
||||
|
||||
void furi_hal_bt_stop_tone_tx() {
|
||||
aci_hal_tone_stop();
|
||||
}
|
||||
|
||||
void furi_hal_bt_start_packet_tx(uint8_t channel, uint8_t pattern, uint8_t datarate) {
|
||||
hci_le_enhanced_transmitter_test(channel, 0x25, pattern, datarate);
|
||||
}
|
||||
|
||||
void furi_hal_bt_start_packet_rx(uint8_t channel, uint8_t datarate) {
|
||||
hci_le_enhanced_receiver_test(channel, datarate, 0);
|
||||
}
|
||||
|
||||
uint16_t furi_hal_bt_stop_packet_test() {
|
||||
uint16_t num_of_packets = 0;
|
||||
hci_le_test_end(&num_of_packets);
|
||||
return num_of_packets;
|
||||
}
|
||||
|
||||
void furi_hal_bt_start_rx(uint8_t channel) {
|
||||
aci_hal_rx_start(channel);
|
||||
}
|
||||
|
||||
float furi_hal_bt_get_rssi() {
|
||||
float val;
|
||||
uint8_t rssi_raw[3];
|
||||
|
||||
if(aci_hal_read_raw_rssi(rssi_raw) != BLE_STATUS_SUCCESS) {
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
// Some ST magic with rssi
|
||||
uint8_t agc = rssi_raw[2] & 0xFF;
|
||||
int rssi = (((int)rssi_raw[1] << 8) & 0xFF00) + (rssi_raw[0] & 0xFF);
|
||||
if(rssi == 0 || agc > 11) {
|
||||
val = -127.0;
|
||||
} else {
|
||||
val = agc * 6.0f - 127.0f;
|
||||
while(rssi > 30) {
|
||||
val += 6.0;
|
||||
rssi >>= 1;
|
||||
}
|
||||
val += (float)((417 * rssi + 18080) >> 10);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
uint32_t furi_hal_bt_get_transmitted_packets() {
|
||||
uint32_t packets = 0;
|
||||
aci_hal_le_tx_test_packet_number(&packets);
|
||||
return packets;
|
||||
}
|
||||
|
||||
void furi_hal_bt_stop_rx() {
|
||||
aci_hal_rx_stop();
|
||||
}
|
||||
|
||||
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
|
||||
furi_delay_ms(C2_MODE_SWITCH_TIMEOUT);
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
@@ -0,0 +1,289 @@
|
||||
#include <furi_hal_bt_hid.h>
|
||||
#include <furi_hal_usb_hid.h>
|
||||
#include <services/dev_info_service.h>
|
||||
#include <services/battery_service.h>
|
||||
#include <services/hid_service.h>
|
||||
|
||||
#include <furi.h>
|
||||
#include <usb_hid.h>
|
||||
|
||||
#define FURI_HAL_BT_INFO_BASE_USB_SPECIFICATION (0x0101)
|
||||
#define FURI_HAL_BT_INFO_COUNTRY_CODE (0x00)
|
||||
#define FURI_HAL_BT_HID_INFO_FLAG_REMOTE_WAKE_MSK (0x01)
|
||||
#define FURI_HAL_BT_HID_INFO_FLAG_NORMALLY_CONNECTABLE_MSK (0x02)
|
||||
|
||||
#define FURI_HAL_BT_HID_KB_MAX_KEYS 6
|
||||
#define FURI_HAL_BT_HID_CONSUMER_MAX_KEYS 1
|
||||
|
||||
// Report ids cant be 0
|
||||
enum HidReportId {
|
||||
ReportIdKeyboard = 1,
|
||||
ReportIdMouse = 2,
|
||||
ReportIdConsumer = 3,
|
||||
};
|
||||
// Report numbers corresponded to the report id with an offset of 1
|
||||
enum HidInputNumber {
|
||||
ReportNumberKeyboard = 0,
|
||||
ReportNumberMouse = 1,
|
||||
ReportNumberConsumer = 2,
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
uint8_t mods;
|
||||
uint8_t reserved;
|
||||
uint8_t key[FURI_HAL_BT_HID_KB_MAX_KEYS];
|
||||
} __attribute__((__packed__)) FuriHalBtHidKbReport;
|
||||
|
||||
typedef struct {
|
||||
uint8_t btn;
|
||||
int8_t x;
|
||||
int8_t y;
|
||||
int8_t wheel;
|
||||
} __attribute__((__packed__)) FuriHalBtHidMouseReport;
|
||||
|
||||
typedef struct {
|
||||
uint16_t key[FURI_HAL_BT_HID_CONSUMER_MAX_KEYS];
|
||||
} __attribute__((__packed__)) FuriHalBtHidConsumerReport;
|
||||
|
||||
// keyboard+mouse+consumer hid report
|
||||
static const uint8_t furi_hal_bt_hid_report_map_data[] = {
|
||||
// Keyboard Report
|
||||
HID_USAGE_PAGE(HID_PAGE_DESKTOP),
|
||||
HID_USAGE(HID_DESKTOP_KEYBOARD),
|
||||
HID_COLLECTION(HID_APPLICATION_COLLECTION),
|
||||
HID_REPORT_ID(ReportIdKeyboard),
|
||||
HID_USAGE_PAGE(HID_DESKTOP_KEYPAD),
|
||||
HID_USAGE_MINIMUM(HID_KEYBOARD_L_CTRL),
|
||||
HID_USAGE_MAXIMUM(HID_KEYBOARD_R_GUI),
|
||||
HID_LOGICAL_MINIMUM(0),
|
||||
HID_LOGICAL_MAXIMUM(1),
|
||||
HID_REPORT_SIZE(1),
|
||||
HID_REPORT_COUNT(8),
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
HID_REPORT_COUNT(1),
|
||||
HID_REPORT_SIZE(8),
|
||||
HID_INPUT(HID_IOF_CONSTANT | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
HID_USAGE_PAGE(HID_PAGE_LED),
|
||||
HID_REPORT_COUNT(8),
|
||||
HID_REPORT_SIZE(1),
|
||||
HID_USAGE_MINIMUM(1),
|
||||
HID_USAGE_MAXIMUM(8),
|
||||
HID_OUTPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
HID_REPORT_COUNT(FURI_HAL_BT_HID_KB_MAX_KEYS),
|
||||
HID_REPORT_SIZE(8),
|
||||
HID_LOGICAL_MINIMUM(0),
|
||||
HID_LOGICAL_MAXIMUM(101),
|
||||
HID_USAGE_PAGE(HID_DESKTOP_KEYPAD),
|
||||
HID_USAGE_MINIMUM(0),
|
||||
HID_USAGE_MAXIMUM(101),
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
|
||||
HID_END_COLLECTION,
|
||||
// Mouse Report
|
||||
HID_USAGE_PAGE(HID_PAGE_DESKTOP),
|
||||
HID_USAGE(HID_DESKTOP_MOUSE),
|
||||
HID_COLLECTION(HID_APPLICATION_COLLECTION),
|
||||
HID_USAGE(HID_DESKTOP_POINTER),
|
||||
HID_COLLECTION(HID_PHYSICAL_COLLECTION),
|
||||
HID_REPORT_ID(ReportIdMouse),
|
||||
HID_USAGE_PAGE(HID_PAGE_BUTTON),
|
||||
HID_USAGE_MINIMUM(1),
|
||||
HID_USAGE_MAXIMUM(3),
|
||||
HID_LOGICAL_MINIMUM(0),
|
||||
HID_LOGICAL_MAXIMUM(1),
|
||||
HID_REPORT_COUNT(3),
|
||||
HID_REPORT_SIZE(1),
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
HID_REPORT_SIZE(1),
|
||||
HID_REPORT_COUNT(5),
|
||||
HID_INPUT(HID_IOF_CONSTANT | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
HID_USAGE_PAGE(HID_PAGE_DESKTOP),
|
||||
HID_USAGE(HID_DESKTOP_X),
|
||||
HID_USAGE(HID_DESKTOP_Y),
|
||||
HID_USAGE(HID_DESKTOP_WHEEL),
|
||||
HID_LOGICAL_MINIMUM(-127),
|
||||
HID_LOGICAL_MAXIMUM(127),
|
||||
HID_REPORT_SIZE(8),
|
||||
HID_REPORT_COUNT(3),
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
|
||||
HID_END_COLLECTION,
|
||||
HID_END_COLLECTION,
|
||||
// Consumer Report
|
||||
HID_USAGE_PAGE(HID_PAGE_CONSUMER),
|
||||
HID_USAGE(HID_CONSUMER_CONTROL),
|
||||
HID_COLLECTION(HID_APPLICATION_COLLECTION),
|
||||
HID_REPORT_ID(ReportIdConsumer),
|
||||
HID_LOGICAL_MINIMUM(0),
|
||||
HID_RI_LOGICAL_MAXIMUM(16, 0x3FF),
|
||||
HID_USAGE_MINIMUM(0),
|
||||
HID_RI_USAGE_MAXIMUM(16, 0x3FF),
|
||||
HID_REPORT_COUNT(FURI_HAL_BT_HID_CONSUMER_MAX_KEYS),
|
||||
HID_REPORT_SIZE(16),
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
|
||||
HID_END_COLLECTION,
|
||||
};
|
||||
FuriHalBtHidKbReport* kb_report = NULL;
|
||||
FuriHalBtHidMouseReport* mouse_report = NULL;
|
||||
FuriHalBtHidConsumerReport* consumer_report = NULL;
|
||||
|
||||
void furi_hal_bt_hid_start() {
|
||||
// Start device info
|
||||
if(!dev_info_svc_is_started()) {
|
||||
dev_info_svc_start();
|
||||
}
|
||||
// Start battery service
|
||||
if(!battery_svc_is_started()) {
|
||||
battery_svc_start();
|
||||
}
|
||||
// Start HID service
|
||||
if(!hid_svc_is_started()) {
|
||||
hid_svc_start();
|
||||
}
|
||||
// Configure HID Keyboard
|
||||
kb_report = malloc(sizeof(FuriHalBtHidKbReport));
|
||||
mouse_report = malloc(sizeof(FuriHalBtHidMouseReport));
|
||||
consumer_report = malloc(sizeof(FuriHalBtHidConsumerReport));
|
||||
// Configure Report Map characteristic
|
||||
hid_svc_update_report_map(
|
||||
furi_hal_bt_hid_report_map_data, sizeof(furi_hal_bt_hid_report_map_data));
|
||||
// Configure HID Information characteristic
|
||||
uint8_t hid_info_val[4] = {
|
||||
FURI_HAL_BT_INFO_BASE_USB_SPECIFICATION & 0x00ff,
|
||||
(FURI_HAL_BT_INFO_BASE_USB_SPECIFICATION & 0xff00) >> 8,
|
||||
FURI_HAL_BT_INFO_COUNTRY_CODE,
|
||||
FURI_HAL_BT_HID_INFO_FLAG_REMOTE_WAKE_MSK |
|
||||
FURI_HAL_BT_HID_INFO_FLAG_NORMALLY_CONNECTABLE_MSK,
|
||||
};
|
||||
hid_svc_update_info(hid_info_val);
|
||||
}
|
||||
|
||||
void furi_hal_bt_hid_stop() {
|
||||
furi_assert(kb_report);
|
||||
furi_assert(mouse_report);
|
||||
furi_assert(consumer_report);
|
||||
// Stop all services
|
||||
if(dev_info_svc_is_started()) {
|
||||
dev_info_svc_stop();
|
||||
}
|
||||
if(battery_svc_is_started()) {
|
||||
battery_svc_stop();
|
||||
}
|
||||
if(hid_svc_is_started()) {
|
||||
hid_svc_stop();
|
||||
}
|
||||
free(kb_report);
|
||||
free(mouse_report);
|
||||
free(consumer_report);
|
||||
kb_report = NULL;
|
||||
mouse_report = NULL;
|
||||
consumer_report = NULL;
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_kb_press(uint16_t button) {
|
||||
furi_assert(kb_report);
|
||||
for(uint8_t i = 0; i < FURI_HAL_BT_HID_KB_MAX_KEYS; i++) {
|
||||
if(kb_report->key[i] == 0) {
|
||||
kb_report->key[i] = button & 0xFF;
|
||||
break;
|
||||
}
|
||||
}
|
||||
kb_report->mods |= (button >> 8);
|
||||
return hid_svc_update_input_report(
|
||||
ReportNumberKeyboard, (uint8_t*)kb_report, sizeof(FuriHalBtHidKbReport));
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_kb_release(uint16_t button) {
|
||||
furi_assert(kb_report);
|
||||
for(uint8_t i = 0; i < FURI_HAL_BT_HID_KB_MAX_KEYS; i++) {
|
||||
if(kb_report->key[i] == (button & 0xFF)) {
|
||||
kb_report->key[i] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
kb_report->mods &= ~(button >> 8);
|
||||
return hid_svc_update_input_report(
|
||||
ReportNumberKeyboard, (uint8_t*)kb_report, sizeof(FuriHalBtHidKbReport));
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_kb_release_all() {
|
||||
furi_assert(kb_report);
|
||||
for(uint8_t i = 0; i < FURI_HAL_BT_HID_KB_MAX_KEYS; i++) {
|
||||
kb_report->key[i] = 0;
|
||||
}
|
||||
kb_report->mods = 0;
|
||||
return hid_svc_update_input_report(
|
||||
ReportNumberKeyboard, (uint8_t*)kb_report, sizeof(FuriHalBtHidKbReport));
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_consumer_key_press(uint16_t button) {
|
||||
furi_assert(consumer_report);
|
||||
for(uint8_t i = 0; i < FURI_HAL_BT_HID_CONSUMER_MAX_KEYS; i++) { //-V1008
|
||||
if(consumer_report->key[i] == 0) {
|
||||
consumer_report->key[i] = button;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return hid_svc_update_input_report(
|
||||
ReportNumberConsumer, (uint8_t*)consumer_report, sizeof(FuriHalBtHidConsumerReport));
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_consumer_key_release(uint16_t button) {
|
||||
furi_assert(consumer_report);
|
||||
for(uint8_t i = 0; i < FURI_HAL_BT_HID_CONSUMER_MAX_KEYS; i++) { //-V1008
|
||||
if(consumer_report->key[i] == button) {
|
||||
consumer_report->key[i] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return hid_svc_update_input_report(
|
||||
ReportNumberConsumer, (uint8_t*)consumer_report, sizeof(FuriHalBtHidConsumerReport));
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_consumer_key_release_all() {
|
||||
furi_assert(consumer_report);
|
||||
for(uint8_t i = 0; i < FURI_HAL_BT_HID_CONSUMER_MAX_KEYS; i++) { //-V1008
|
||||
consumer_report->key[i] = 0;
|
||||
}
|
||||
return hid_svc_update_input_report(
|
||||
ReportNumberConsumer, (uint8_t*)consumer_report, sizeof(FuriHalBtHidConsumerReport));
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_mouse_move(int8_t dx, int8_t dy) {
|
||||
furi_assert(mouse_report);
|
||||
mouse_report->x = dx;
|
||||
mouse_report->y = dy;
|
||||
bool state = hid_svc_update_input_report(
|
||||
ReportNumberMouse, (uint8_t*)mouse_report, sizeof(FuriHalBtHidMouseReport));
|
||||
mouse_report->x = 0;
|
||||
mouse_report->y = 0;
|
||||
return state;
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_mouse_press(uint8_t button) {
|
||||
furi_assert(mouse_report);
|
||||
mouse_report->btn |= button;
|
||||
return hid_svc_update_input_report(
|
||||
ReportNumberMouse, (uint8_t*)mouse_report, sizeof(FuriHalBtHidMouseReport));
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_mouse_release(uint8_t button) {
|
||||
furi_assert(mouse_report);
|
||||
mouse_report->btn &= ~button;
|
||||
return hid_svc_update_input_report(
|
||||
ReportNumberMouse, (uint8_t*)mouse_report, sizeof(FuriHalBtHidMouseReport));
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_mouse_release_all() {
|
||||
furi_assert(mouse_report);
|
||||
mouse_report->btn = 0;
|
||||
return hid_svc_update_input_report(
|
||||
ReportNumberMouse, (uint8_t*)mouse_report, sizeof(FuriHalBtHidMouseReport));
|
||||
}
|
||||
|
||||
bool furi_hal_bt_hid_mouse_scroll(int8_t delta) {
|
||||
furi_assert(mouse_report);
|
||||
mouse_report->wheel = delta;
|
||||
bool state = hid_svc_update_input_report(
|
||||
ReportNumberMouse, (uint8_t*)mouse_report, sizeof(FuriHalBtHidMouseReport));
|
||||
mouse_report->wheel = 0;
|
||||
return state;
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
#include <furi_hal_bt_serial.h>
|
||||
#include <services/dev_info_service.h>
|
||||
#include <services/battery_service.h>
|
||||
#include <services/serial_service.h>
|
||||
|
||||
#include <furi.h>
|
||||
|
||||
void furi_hal_bt_serial_start() {
|
||||
// Start device info
|
||||
if(!dev_info_svc_is_started()) {
|
||||
dev_info_svc_start();
|
||||
}
|
||||
// Start battery service
|
||||
if(!battery_svc_is_started()) {
|
||||
battery_svc_start();
|
||||
}
|
||||
// Start Serial service
|
||||
if(!serial_svc_is_started()) {
|
||||
serial_svc_start();
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_bt_serial_set_event_callback(
|
||||
uint16_t buff_size,
|
||||
FuriHalBtSerialCallback callback,
|
||||
void* context) {
|
||||
serial_svc_set_callbacks(buff_size, callback, context);
|
||||
}
|
||||
|
||||
void furi_hal_bt_serial_notify_buffer_is_empty() {
|
||||
serial_svc_notify_buffer_is_empty();
|
||||
}
|
||||
|
||||
void furi_hal_bt_serial_set_rpc_status(FuriHalBtSerialRpcStatus status) {
|
||||
SerialServiceRpcStatus st;
|
||||
if(status == FuriHalBtSerialRpcStatusActive) {
|
||||
st = SerialServiceRpcStatusActive;
|
||||
} else {
|
||||
st = SerialServiceRpcStatusNotActive;
|
||||
}
|
||||
serial_svc_set_rpc_status(st);
|
||||
}
|
||||
|
||||
bool furi_hal_bt_serial_tx(uint8_t* data, uint16_t size) {
|
||||
if(size > FURI_HAL_BT_SERIAL_PACKET_SIZE_MAX) {
|
||||
return false;
|
||||
}
|
||||
return serial_svc_update_tx(data, size);
|
||||
}
|
||||
|
||||
void furi_hal_bt_serial_stop() {
|
||||
// Stop all services
|
||||
if(dev_info_svc_is_started()) {
|
||||
dev_info_svc_stop();
|
||||
}
|
||||
// Start battery service
|
||||
if(battery_svc_is_started()) {
|
||||
battery_svc_stop();
|
||||
}
|
||||
// Start Serial service
|
||||
if(serial_svc_is_started()) {
|
||||
serial_svc_stop();
|
||||
}
|
||||
}
|
||||
@@ -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_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_IGNORE,
|
||||
[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_IGNORE,
|
||||
[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_IGNORE,
|
||||
[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;
|
||||
}
|
||||
@@ -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
|
||||
@@ -0,0 +1,279 @@
|
||||
#include <furi_hal_clock.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi.h>
|
||||
|
||||
#include <stm32wbxx_ll_pwr.h>
|
||||
#include <stm32wbxx_ll_rcc.h>
|
||||
#include <stm32wbxx_ll_hsem.h>
|
||||
#include <stm32wbxx_ll_utils.h>
|
||||
#include <stm32wbxx_ll_cortex.h>
|
||||
|
||||
#include <hsem_map.h>
|
||||
#include <interface/patterns/ble_thread/shci/shci.h>
|
||||
|
||||
#define TAG "FuriHalClock"
|
||||
|
||||
#define CPU_CLOCK_EARLY_HZ 4000000
|
||||
#define CPU_CLOCK_HSI16_HZ 16000000
|
||||
#define CPU_CLOCK_HSE_HZ 32000000
|
||||
#define CPU_CLOCK_PLL_HZ 64000000
|
||||
|
||||
#define TICK_INT_PRIORITY 15U
|
||||
#define HS_CLOCK_IS_READY() (LL_RCC_HSE_IsReady() && LL_RCC_HSI_IsReady())
|
||||
#define LS_CLOCK_IS_READY() (LL_RCC_LSE_IsReady() && LL_RCC_LSI1_IsReady())
|
||||
|
||||
void furi_hal_clock_init_early() {
|
||||
LL_SetSystemCoreClock(CPU_CLOCK_EARLY_HZ);
|
||||
LL_Init1msTick(SystemCoreClock);
|
||||
}
|
||||
|
||||
void furi_hal_clock_deinit_early() {
|
||||
}
|
||||
|
||||
void furi_hal_clock_init() {
|
||||
/* HSE and HSI configuration and activation */
|
||||
LL_RCC_HSE_SetCapacitorTuning(0x26);
|
||||
LL_RCC_HSE_Enable();
|
||||
LL_RCC_HSI_Enable();
|
||||
while(!HS_CLOCK_IS_READY())
|
||||
;
|
||||
/* Select HSI as system clock source after Wake Up from Stop mode
|
||||
* Must be set before enabling CSS */
|
||||
LL_RCC_SetClkAfterWakeFromStop(LL_RCC_STOP_WAKEUPCLOCK_HSI);
|
||||
|
||||
LL_RCC_HSE_EnableCSS();
|
||||
|
||||
/* LSE and LSI1 configuration and activation */
|
||||
LL_PWR_EnableBkUpAccess();
|
||||
LL_RCC_LSE_SetDriveCapability(LL_RCC_LSEDRIVE_HIGH);
|
||||
LL_RCC_LSE_Enable();
|
||||
LL_RCC_LSI1_Enable();
|
||||
while(!LS_CLOCK_IS_READY())
|
||||
;
|
||||
|
||||
LL_EXTI_EnableIT_0_31(
|
||||
LL_EXTI_LINE_18); /* Why? Because that's why. See RM0434, Table 61. CPU1 vector table. */
|
||||
LL_EXTI_EnableRisingTrig_0_31(LL_EXTI_LINE_18);
|
||||
LL_RCC_EnableIT_LSECSS();
|
||||
/* ES0394, extended case of 2.2.2 */
|
||||
if(!LL_RCC_IsActiveFlag_BORRST()) {
|
||||
LL_RCC_LSE_EnableCSS();
|
||||
}
|
||||
|
||||
/* Main PLL configuration and activation */
|
||||
LL_RCC_PLL_ConfigDomain_SYS(LL_RCC_PLLSOURCE_HSE, LL_RCC_PLLM_DIV_2, 8, LL_RCC_PLLR_DIV_2);
|
||||
LL_RCC_PLL_Enable();
|
||||
LL_RCC_PLL_EnableDomain_SYS();
|
||||
while(LL_RCC_PLL_IsReady() != 1)
|
||||
;
|
||||
|
||||
LL_RCC_PLLSAI1_ConfigDomain_48M(
|
||||
LL_RCC_PLLSOURCE_HSE, LL_RCC_PLLM_DIV_2, 6, LL_RCC_PLLSAI1Q_DIV_2);
|
||||
LL_RCC_PLLSAI1_ConfigDomain_ADC(
|
||||
LL_RCC_PLLSOURCE_HSE, LL_RCC_PLLM_DIV_2, 6, LL_RCC_PLLSAI1R_DIV_2);
|
||||
LL_RCC_PLLSAI1_Enable();
|
||||
LL_RCC_PLLSAI1_EnableDomain_48M();
|
||||
LL_RCC_PLLSAI1_EnableDomain_ADC();
|
||||
while(LL_RCC_PLLSAI1_IsReady() != 1)
|
||||
;
|
||||
|
||||
/* Sysclk activation on the main PLL */
|
||||
/* Set CPU1 prescaler */
|
||||
LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);
|
||||
|
||||
/* Set CPU2 prescaler, from this point we are not allowed to touch it. */
|
||||
LL_C2_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_2);
|
||||
|
||||
/* Prepare Flash memory for work on 64MHz system clock */
|
||||
LL_FLASH_SetLatency(LL_FLASH_LATENCY_3);
|
||||
while(LL_FLASH_GetLatency() != LL_FLASH_LATENCY_3)
|
||||
;
|
||||
|
||||
LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_PLL);
|
||||
while(LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_PLL)
|
||||
;
|
||||
|
||||
/* Set AHB SHARED prescaler*/
|
||||
LL_RCC_SetAHB4Prescaler(LL_RCC_SYSCLK_DIV_1);
|
||||
|
||||
/* Set APB1 prescaler*/
|
||||
LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);
|
||||
|
||||
/* Set APB2 prescaler*/
|
||||
LL_RCC_SetAPB2Prescaler(LL_RCC_APB2_DIV_1);
|
||||
|
||||
/* Disable MSI */
|
||||
LL_RCC_MSI_Disable();
|
||||
while(LL_RCC_MSI_IsReady() != 0)
|
||||
;
|
||||
|
||||
/* Update CMSIS variable (which can be updated also through SystemCoreClockUpdate function) */
|
||||
LL_SetSystemCoreClock(CPU_CLOCK_PLL_HZ);
|
||||
|
||||
/* Update the time base */
|
||||
LL_Init1msTick(SystemCoreClock);
|
||||
LL_SYSTICK_EnableIT();
|
||||
NVIC_SetPriority(
|
||||
SysTick_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), TICK_INT_PRIORITY, 0));
|
||||
NVIC_EnableIRQ(SysTick_IRQn);
|
||||
|
||||
LL_RCC_SetCLK48ClockSource(LL_RCC_CLK48_CLKSOURCE_PLLSAI1);
|
||||
LL_RCC_SetSMPSClockSource(LL_RCC_SMPS_CLKSOURCE_HSI);
|
||||
LL_RCC_SetSMPSPrescaler(LL_RCC_SMPS_DIV_1);
|
||||
LL_RCC_SetRFWKPClockSource(LL_RCC_RFWKP_CLKSOURCE_LSE);
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
void furi_hal_clock_switch_hse2hsi() {
|
||||
LL_RCC_HSI_Enable();
|
||||
|
||||
while(!LL_RCC_HSI_IsReady())
|
||||
;
|
||||
|
||||
LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_HSI);
|
||||
furi_assert(LL_RCC_GetSMPSClockSelection() == LL_RCC_SMPS_CLKSOURCE_HSI);
|
||||
|
||||
while(LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_HSI)
|
||||
;
|
||||
|
||||
LL_FLASH_SetLatency(LL_FLASH_LATENCY_0);
|
||||
while(LL_FLASH_GetLatency() != LL_FLASH_LATENCY_0)
|
||||
;
|
||||
}
|
||||
|
||||
void furi_hal_clock_switch_hsi2hse() {
|
||||
#ifdef FURI_HAL_CLOCK_TRACK_STARTUP
|
||||
uint32_t clock_start_time = DWT->CYCCNT;
|
||||
#endif
|
||||
|
||||
LL_RCC_HSE_Enable();
|
||||
while(!LL_RCC_HSE_IsReady())
|
||||
;
|
||||
|
||||
LL_FLASH_SetLatency(LL_FLASH_LATENCY_1);
|
||||
while(LL_FLASH_GetLatency() != LL_FLASH_LATENCY_1)
|
||||
;
|
||||
|
||||
LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_HSE);
|
||||
|
||||
while(LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_HSE)
|
||||
;
|
||||
|
||||
#ifdef FURI_HAL_CLOCK_TRACK_STARTUP
|
||||
uint32_t total = DWT->CYCCNT - clock_start_time;
|
||||
if(total > (20 * 0x148)) {
|
||||
furi_crash("Slow HSE/PLL startup");
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
bool furi_hal_clock_switch_hse2pll() {
|
||||
furi_assert(LL_RCC_GetSysClkSource() == LL_RCC_SYS_CLKSOURCE_STATUS_HSE);
|
||||
|
||||
LL_RCC_PLL_Enable();
|
||||
LL_RCC_PLLSAI1_Enable();
|
||||
|
||||
while(!LL_RCC_PLL_IsReady())
|
||||
;
|
||||
while(!LL_RCC_PLLSAI1_IsReady())
|
||||
;
|
||||
|
||||
if(SHCI_C2_SetSystemClock(SET_SYSTEM_CLOCK_HSE_TO_PLL) != SHCI_Success) {
|
||||
return false;
|
||||
}
|
||||
|
||||
furi_check(LL_RCC_GetSysClkSource() == LL_RCC_SYS_CLKSOURCE_STATUS_PLL);
|
||||
|
||||
LL_SetSystemCoreClock(CPU_CLOCK_PLL_HZ);
|
||||
SysTick->LOAD = (uint32_t)((SystemCoreClock / 1000) - 1UL);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool furi_hal_clock_switch_pll2hse() {
|
||||
furi_assert(LL_RCC_GetSysClkSource() == LL_RCC_SYS_CLKSOURCE_STATUS_PLL);
|
||||
|
||||
LL_RCC_HSE_Enable();
|
||||
while(!LL_RCC_HSE_IsReady())
|
||||
;
|
||||
|
||||
if(SHCI_C2_SetSystemClock(SET_SYSTEM_CLOCK_PLL_ON_TO_HSE) != SHCI_Success) {
|
||||
return false;
|
||||
}
|
||||
|
||||
furi_check(LL_RCC_GetSysClkSource() == LL_RCC_SYS_CLKSOURCE_STATUS_HSE);
|
||||
|
||||
LL_SetSystemCoreClock(CPU_CLOCK_HSE_HZ);
|
||||
SysTick->LOAD = (uint32_t)((SystemCoreClock / 1000) - 1UL);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void furi_hal_clock_suspend_tick() {
|
||||
CLEAR_BIT(SysTick->CTRL, SysTick_CTRL_ENABLE_Msk);
|
||||
}
|
||||
|
||||
void furi_hal_clock_resume_tick() {
|
||||
SET_BIT(SysTick->CTRL, SysTick_CTRL_ENABLE_Msk);
|
||||
}
|
||||
|
||||
void furi_hal_clock_mco_enable(FuriHalClockMcoSourceId source, FuriHalClockMcoDivisorId div) {
|
||||
if(source == FuriHalClockMcoLse) {
|
||||
LL_RCC_ConfigMCO(LL_RCC_MCO1SOURCE_LSE, div);
|
||||
} else if(source == FuriHalClockMcoSysclk) {
|
||||
LL_RCC_ConfigMCO(LL_RCC_MCO1SOURCE_SYSCLK, div);
|
||||
} else {
|
||||
LL_RCC_MSI_Enable();
|
||||
while(LL_RCC_MSI_IsReady() != 1)
|
||||
;
|
||||
switch(source) {
|
||||
case FuriHalClockMcoMsi100k:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_0);
|
||||
break;
|
||||
case FuriHalClockMcoMsi200k:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_1);
|
||||
break;
|
||||
case FuriHalClockMcoMsi400k:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_2);
|
||||
break;
|
||||
case FuriHalClockMcoMsi800k:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_3);
|
||||
break;
|
||||
case FuriHalClockMcoMsi1m:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_4);
|
||||
break;
|
||||
case FuriHalClockMcoMsi2m:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_5);
|
||||
break;
|
||||
case FuriHalClockMcoMsi4m:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_6);
|
||||
break;
|
||||
case FuriHalClockMcoMsi8m:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_7);
|
||||
break;
|
||||
case FuriHalClockMcoMsi16m:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_8);
|
||||
break;
|
||||
case FuriHalClockMcoMsi24m:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_9);
|
||||
break;
|
||||
case FuriHalClockMcoMsi32m:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_10);
|
||||
break;
|
||||
case FuriHalClockMcoMsi48m:
|
||||
LL_RCC_MSI_SetRange(LL_RCC_MSIRANGE_11);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
LL_RCC_ConfigMCO(LL_RCC_MCO1SOURCE_MSI, div);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_clock_mco_disable() {
|
||||
LL_RCC_ConfigMCO(LL_RCC_MCO1SOURCE_NOCLOCK, FuriHalClockMcoDiv1);
|
||||
LL_RCC_MSI_Disable();
|
||||
while(LL_RCC_MSI_IsReady() != 0)
|
||||
;
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
#pragma once
|
||||
|
||||
#include <stm32wbxx_ll_rcc.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
FuriHalClockMcoLse,
|
||||
FuriHalClockMcoSysclk,
|
||||
FuriHalClockMcoMsi100k,
|
||||
FuriHalClockMcoMsi200k,
|
||||
FuriHalClockMcoMsi400k,
|
||||
FuriHalClockMcoMsi800k,
|
||||
FuriHalClockMcoMsi1m,
|
||||
FuriHalClockMcoMsi2m,
|
||||
FuriHalClockMcoMsi4m,
|
||||
FuriHalClockMcoMsi8m,
|
||||
FuriHalClockMcoMsi16m,
|
||||
FuriHalClockMcoMsi24m,
|
||||
FuriHalClockMcoMsi32m,
|
||||
FuriHalClockMcoMsi48m,
|
||||
} FuriHalClockMcoSourceId;
|
||||
|
||||
typedef enum {
|
||||
FuriHalClockMcoDiv1 = LL_RCC_MCO1_DIV_1,
|
||||
FuriHalClockMcoDiv2 = LL_RCC_MCO1_DIV_2,
|
||||
FuriHalClockMcoDiv4 = LL_RCC_MCO1_DIV_4,
|
||||
FuriHalClockMcoDiv8 = LL_RCC_MCO1_DIV_8,
|
||||
FuriHalClockMcoDiv16 = LL_RCC_MCO1_DIV_16,
|
||||
} FuriHalClockMcoDivisorId;
|
||||
|
||||
/** Early initialization */
|
||||
void furi_hal_clock_init_early();
|
||||
|
||||
/** Early deinitialization */
|
||||
void furi_hal_clock_deinit_early();
|
||||
|
||||
/** Initialize clocks */
|
||||
void furi_hal_clock_init();
|
||||
|
||||
/** Switch clock from HSE to HSI */
|
||||
void furi_hal_clock_switch_hse2hsi();
|
||||
|
||||
/** Switch clock from HSI to HSE */
|
||||
void furi_hal_clock_switch_hsi2hse();
|
||||
|
||||
/** Switch clock from HSE to PLL
|
||||
*
|
||||
* @return true if changed, false if failed or not possible at this moment
|
||||
*/
|
||||
bool furi_hal_clock_switch_hse2pll();
|
||||
|
||||
/** Switch clock from PLL to HSE
|
||||
*
|
||||
* @return true if changed, false if failed or not possible at this moment
|
||||
*/
|
||||
bool furi_hal_clock_switch_pll2hse();
|
||||
|
||||
/** Stop SysTick counter without resetting */
|
||||
void furi_hal_clock_suspend_tick();
|
||||
|
||||
/** Continue SysTick counter operation */
|
||||
void furi_hal_clock_resume_tick();
|
||||
|
||||
/** Enable clock output on MCO pin
|
||||
*
|
||||
* @param source MCO clock source
|
||||
* @param div MCO clock division
|
||||
*/
|
||||
void furi_hal_clock_mco_enable(FuriHalClockMcoSourceId source, FuriHalClockMcoDivisorId div);
|
||||
|
||||
/** Disable clock output on MCO pin */
|
||||
void furi_hal_clock_mco_disable();
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,99 @@
|
||||
#include <furi_hal_console.h>
|
||||
#include <furi_hal_uart.h>
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stm32wbxx_ll_gpio.h>
|
||||
#include <stm32wbxx_ll_usart.h>
|
||||
|
||||
#include <furi.h>
|
||||
|
||||
#define TAG "FuriHalConsole"
|
||||
|
||||
#ifdef HEAP_PRINT_DEBUG
|
||||
#define CONSOLE_BAUDRATE 1843200
|
||||
#else
|
||||
#define CONSOLE_BAUDRATE 230400
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
bool alive;
|
||||
FuriHalConsoleTxCallback tx_callback;
|
||||
void* tx_callback_context;
|
||||
} FuriHalConsole;
|
||||
|
||||
FuriHalConsole furi_hal_console = {
|
||||
.alive = false,
|
||||
.tx_callback = NULL,
|
||||
.tx_callback_context = NULL,
|
||||
};
|
||||
|
||||
void furi_hal_console_init() {
|
||||
furi_hal_uart_init(FuriHalUartIdUSART1, CONSOLE_BAUDRATE);
|
||||
furi_hal_console.alive = true;
|
||||
}
|
||||
|
||||
void furi_hal_console_enable() {
|
||||
furi_hal_uart_set_irq_cb(FuriHalUartIdUSART1, NULL, NULL);
|
||||
while(!LL_USART_IsActiveFlag_TC(USART1))
|
||||
;
|
||||
furi_hal_uart_set_br(FuriHalUartIdUSART1, CONSOLE_BAUDRATE);
|
||||
furi_hal_console.alive = true;
|
||||
}
|
||||
|
||||
void furi_hal_console_disable() {
|
||||
while(!LL_USART_IsActiveFlag_TC(USART1))
|
||||
;
|
||||
furi_hal_console.alive = false;
|
||||
}
|
||||
|
||||
void furi_hal_console_set_tx_callback(FuriHalConsoleTxCallback callback, void* context) {
|
||||
FURI_CRITICAL_ENTER();
|
||||
furi_hal_console.tx_callback = callback;
|
||||
furi_hal_console.tx_callback_context = context;
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_console_tx(const uint8_t* buffer, size_t buffer_size) {
|
||||
if(!furi_hal_console.alive) return;
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
// Transmit data
|
||||
|
||||
if(furi_hal_console.tx_callback) {
|
||||
furi_hal_console.tx_callback(buffer, buffer_size, furi_hal_console.tx_callback_context);
|
||||
}
|
||||
|
||||
furi_hal_uart_tx(FuriHalUartIdUSART1, (uint8_t*)buffer, buffer_size);
|
||||
// Wait for TC flag to be raised for last char
|
||||
while(!LL_USART_IsActiveFlag_TC(USART1))
|
||||
;
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_console_tx_with_new_line(const uint8_t* buffer, size_t buffer_size) {
|
||||
if(!furi_hal_console.alive) return;
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
// Transmit data
|
||||
furi_hal_uart_tx(FuriHalUartIdUSART1, (uint8_t*)buffer, buffer_size);
|
||||
// Transmit new line symbols
|
||||
furi_hal_uart_tx(FuriHalUartIdUSART1, (uint8_t*)"\r\n", 2);
|
||||
// Wait for TC flag to be raised for last char
|
||||
while(!LL_USART_IsActiveFlag_TC(USART1))
|
||||
;
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_console_printf(const char format[], ...) {
|
||||
FuriString* string;
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
string = furi_string_alloc_vprintf(format, args);
|
||||
va_end(args);
|
||||
furi_hal_console_tx((const uint8_t*)furi_string_get_cstr(string), furi_string_size(string));
|
||||
furi_string_free(string);
|
||||
}
|
||||
|
||||
void furi_hal_console_puts(const char* data) {
|
||||
furi_hal_console_tx((const uint8_t*)data, strlen(data));
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
#pragma once
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef void (*FuriHalConsoleTxCallback)(const uint8_t* buffer, size_t size, void* context);
|
||||
|
||||
void furi_hal_console_init();
|
||||
|
||||
void furi_hal_console_enable();
|
||||
|
||||
void furi_hal_console_disable();
|
||||
|
||||
void furi_hal_console_set_tx_callback(FuriHalConsoleTxCallback callback, void* context);
|
||||
|
||||
void furi_hal_console_tx(const uint8_t* buffer, size_t buffer_size);
|
||||
|
||||
void furi_hal_console_tx_with_new_line(const uint8_t* buffer, size_t buffer_size);
|
||||
|
||||
/**
|
||||
* Printf-like plain uart interface
|
||||
* @warning Will not work in ISR context
|
||||
* @param format
|
||||
* @param ...
|
||||
*/
|
||||
void furi_hal_console_printf(const char format[], ...) _ATTRIBUTE((__format__(__printf__, 1, 2)));
|
||||
|
||||
void furi_hal_console_puts(const char* data);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,114 @@
|
||||
#include <furi_hal_cortex.h>
|
||||
#include <furi.h>
|
||||
|
||||
#include <stm32wbxx.h>
|
||||
|
||||
#define FURI_HAL_CORTEX_INSTRUCTIONS_PER_MICROSECOND (SystemCoreClock / 1000000)
|
||||
|
||||
void furi_hal_cortex_init_early() {
|
||||
CoreDebug->DEMCR |= (CoreDebug_DEMCR_TRCENA_Msk | CoreDebug_DEMCR_MON_EN_Msk);
|
||||
DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
|
||||
DWT->CYCCNT = 0U;
|
||||
|
||||
/* Enable instruction prefetch */
|
||||
SET_BIT(FLASH->ACR, FLASH_ACR_PRFTEN);
|
||||
}
|
||||
|
||||
void furi_hal_cortex_delay_us(uint32_t microseconds) {
|
||||
furi_check(microseconds < (UINT32_MAX / FURI_HAL_CORTEX_INSTRUCTIONS_PER_MICROSECOND));
|
||||
|
||||
uint32_t start = DWT->CYCCNT;
|
||||
uint32_t time_ticks = FURI_HAL_CORTEX_INSTRUCTIONS_PER_MICROSECOND * microseconds;
|
||||
|
||||
while((DWT->CYCCNT - start) < time_ticks) {
|
||||
};
|
||||
}
|
||||
|
||||
uint32_t furi_hal_cortex_instructions_per_microsecond() {
|
||||
return FURI_HAL_CORTEX_INSTRUCTIONS_PER_MICROSECOND;
|
||||
}
|
||||
|
||||
FuriHalCortexTimer furi_hal_cortex_timer_get(uint32_t timeout_us) {
|
||||
furi_check(timeout_us < (UINT32_MAX / FURI_HAL_CORTEX_INSTRUCTIONS_PER_MICROSECOND));
|
||||
|
||||
FuriHalCortexTimer cortex_timer = {0};
|
||||
cortex_timer.start = DWT->CYCCNT;
|
||||
cortex_timer.value = FURI_HAL_CORTEX_INSTRUCTIONS_PER_MICROSECOND * timeout_us;
|
||||
return cortex_timer;
|
||||
}
|
||||
|
||||
bool furi_hal_cortex_timer_is_expired(FuriHalCortexTimer cortex_timer) {
|
||||
return !((DWT->CYCCNT - cortex_timer.start) < cortex_timer.value);
|
||||
}
|
||||
|
||||
void furi_hal_cortex_timer_wait(FuriHalCortexTimer cortex_timer) {
|
||||
while(!furi_hal_cortex_timer_is_expired(cortex_timer))
|
||||
;
|
||||
}
|
||||
|
||||
// Duck ST
|
||||
#undef COMP0
|
||||
#undef COMP1
|
||||
#undef COMP2
|
||||
#undef COMP3
|
||||
|
||||
void furi_hal_cortex_comp_enable(
|
||||
FuriHalCortexComp comp,
|
||||
FuriHalCortexCompFunction function,
|
||||
uint32_t value,
|
||||
uint32_t mask,
|
||||
FuriHalCortexCompSize size) {
|
||||
uint32_t function_reg = (uint32_t)function | ((uint32_t)size << 10);
|
||||
|
||||
switch(comp) {
|
||||
case FuriHalCortexComp0:
|
||||
(DWT->COMP0) = value;
|
||||
(DWT->MASK0) = mask;
|
||||
(DWT->FUNCTION0) = function_reg;
|
||||
break;
|
||||
case FuriHalCortexComp1:
|
||||
(DWT->COMP1) = value;
|
||||
(DWT->MASK1) = mask;
|
||||
(DWT->FUNCTION1) = function_reg;
|
||||
break;
|
||||
case FuriHalCortexComp2:
|
||||
(DWT->COMP2) = value;
|
||||
(DWT->MASK2) = mask;
|
||||
(DWT->FUNCTION2) = function_reg;
|
||||
break;
|
||||
case FuriHalCortexComp3:
|
||||
(DWT->COMP3) = value;
|
||||
(DWT->MASK3) = mask;
|
||||
(DWT->FUNCTION3) = function_reg;
|
||||
break;
|
||||
default:
|
||||
furi_crash("Invalid parameter");
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_cortex_comp_reset(FuriHalCortexComp comp) {
|
||||
switch(comp) {
|
||||
case FuriHalCortexComp0:
|
||||
(DWT->COMP0) = 0;
|
||||
(DWT->MASK0) = 0;
|
||||
(DWT->FUNCTION0) = 0;
|
||||
break;
|
||||
case FuriHalCortexComp1:
|
||||
(DWT->COMP1) = 0;
|
||||
(DWT->MASK1) = 0;
|
||||
(DWT->FUNCTION1) = 0;
|
||||
break;
|
||||
case FuriHalCortexComp2:
|
||||
(DWT->COMP2) = 0;
|
||||
(DWT->MASK2) = 0;
|
||||
(DWT->FUNCTION2) = 0;
|
||||
break;
|
||||
case FuriHalCortexComp3:
|
||||
(DWT->COMP3) = 0;
|
||||
(DWT->MASK3) = 0;
|
||||
(DWT->FUNCTION3) = 0;
|
||||
break;
|
||||
default:
|
||||
furi_crash("Invalid parameter");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,732 @@
|
||||
#include <furi_hal_crypto.h>
|
||||
#include <furi_hal_cortex.h>
|
||||
#include <furi_hal_bt.h>
|
||||
#include <furi_hal_random.h>
|
||||
#include <furi_hal_bus.h>
|
||||
|
||||
#include <stm32wbxx_ll_cortex.h>
|
||||
#include <furi.h>
|
||||
#include <interface/patterns/ble_thread/shci/shci.h>
|
||||
|
||||
#define TAG "FuriHalCrypto"
|
||||
|
||||
#define ENCLAVE_FACTORY_KEY_SLOTS 10
|
||||
#define ENCLAVE_SIGNATURE_SIZE 16
|
||||
|
||||
#define CRYPTO_BLK_LEN (4 * sizeof(uint32_t))
|
||||
#define CRYPTO_TIMEOUT_US (1000000)
|
||||
|
||||
#define CRYPTO_MODE_ENCRYPT 0U
|
||||
#define CRYPTO_MODE_INIT (AES_CR_MODE_0)
|
||||
#define CRYPTO_MODE_DECRYPT (AES_CR_MODE_1)
|
||||
#define CRYPTO_MODE_DECRYPT_INIT (AES_CR_MODE_0 | AES_CR_MODE_1)
|
||||
|
||||
#define CRYPTO_DATATYPE_32B 0U
|
||||
#define CRYPTO_KEYSIZE_256B (AES_CR_KEYSIZE)
|
||||
#define CRYPTO_AES_CBC (AES_CR_CHMOD_0)
|
||||
|
||||
#define CRYPTO_AES_CTR (AES_CR_CHMOD_1)
|
||||
#define CRYPTO_CTR_IV_LEN (12U)
|
||||
#define CRYPTO_CTR_CTR_LEN (4U)
|
||||
|
||||
#define CRYPTO_AES_GCM (AES_CR_CHMOD_1 | AES_CR_CHMOD_0)
|
||||
#define CRYPTO_GCM_IV_LEN (12U)
|
||||
#define CRYPTO_GCM_CTR_LEN (4U)
|
||||
#define CRYPTO_GCM_TAG_LEN (16U)
|
||||
#define CRYPTO_GCM_PH_INIT (0x0U << AES_CR_GCMPH_Pos)
|
||||
#define CRYPTO_GCM_PH_HEADER (AES_CR_GCMPH_0)
|
||||
#define CRYPTO_GCM_PH_PAYLOAD (AES_CR_GCMPH_1)
|
||||
#define CRYPTO_GCM_PH_FINAL (AES_CR_GCMPH_1 | AES_CR_GCMPH_0)
|
||||
|
||||
static FuriMutex* furi_hal_crypto_mutex = NULL;
|
||||
static bool furi_hal_crypto_mode_init_done = false;
|
||||
|
||||
static const uint8_t enclave_signature_iv[ENCLAVE_FACTORY_KEY_SLOTS][16] = {
|
||||
{0xac, 0x5d, 0x68, 0xb8, 0x79, 0x74, 0xfc, 0x7f, 0x45, 0x02, 0x82, 0xf1, 0x48, 0x7e, 0x75, 0x8a},
|
||||
{0x38, 0xe6, 0x6a, 0x90, 0x5e, 0x5b, 0x8a, 0xa6, 0x70, 0x30, 0x04, 0x72, 0xc2, 0x42, 0xea, 0xaf},
|
||||
{0x73, 0xd5, 0x8e, 0xfb, 0x0f, 0x4b, 0xa9, 0x79, 0x0f, 0xde, 0x0e, 0x53, 0x44, 0x7d, 0xaa, 0xfd},
|
||||
{0x3c, 0x9a, 0xf4, 0x43, 0x2b, 0xfe, 0xea, 0xae, 0x8c, 0xc6, 0xd1, 0x60, 0xd2, 0x96, 0x64, 0xa9},
|
||||
{0x10, 0xac, 0x7b, 0x63, 0x03, 0x7f, 0x43, 0x18, 0xec, 0x9d, 0x9c, 0xc4, 0x01, 0xdc, 0x35, 0xa7},
|
||||
{0x26, 0x21, 0x64, 0xe6, 0xd0, 0xf2, 0x47, 0x49, 0xdc, 0x36, 0xcd, 0x68, 0x0c, 0x91, 0x03, 0x44},
|
||||
{0x7a, 0xbd, 0xce, 0x9c, 0x24, 0x7a, 0x2a, 0xb1, 0x3c, 0x4f, 0x5a, 0x7d, 0x80, 0x3e, 0xfc, 0x0d},
|
||||
{0xcd, 0xdd, 0xd3, 0x02, 0x85, 0x65, 0x43, 0x83, 0xf9, 0xac, 0x75, 0x2f, 0x21, 0xef, 0x28, 0x6b},
|
||||
{0xab, 0x73, 0x70, 0xe8, 0xe2, 0x56, 0x0f, 0x58, 0xab, 0x29, 0xa5, 0xb1, 0x13, 0x47, 0x5e, 0xe8},
|
||||
{0x4f, 0x3c, 0x43, 0x77, 0xde, 0xed, 0x79, 0xa1, 0x8d, 0x4c, 0x1f, 0xfd, 0xdb, 0x96, 0x87, 0x2e},
|
||||
};
|
||||
|
||||
static const uint8_t enclave_signature_input[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
|
||||
{0x9f, 0x5c, 0xb1, 0x43, 0x17, 0x53, 0x18, 0x8c, 0x66, 0x3d, 0x39, 0x45, 0x90, 0x13, 0xa9, 0xde},
|
||||
{0xc5, 0x98, 0xe9, 0x17, 0xb8, 0x97, 0x9e, 0x03, 0x33, 0x14, 0x13, 0x8f, 0xce, 0x74, 0x0d, 0x54},
|
||||
{0x34, 0xba, 0x99, 0x59, 0x9f, 0x70, 0x67, 0xe9, 0x09, 0xee, 0x64, 0x0e, 0xb3, 0xba, 0xfb, 0x75},
|
||||
{0xdc, 0xfa, 0x6c, 0x9a, 0x6f, 0x0a, 0x3e, 0xdc, 0x42, 0xf6, 0xae, 0x0d, 0x3c, 0xf7, 0x83, 0xaf},
|
||||
{0xea, 0x2d, 0xe3, 0x1f, 0x02, 0x99, 0x1a, 0x7e, 0x6d, 0x93, 0x4c, 0xb5, 0x42, 0xf0, 0x7a, 0x9b},
|
||||
{0x53, 0x5e, 0x04, 0xa2, 0x49, 0xa0, 0x73, 0x49, 0x56, 0xb0, 0x88, 0x8c, 0x12, 0xa0, 0xe4, 0x18},
|
||||
{0x7d, 0xa7, 0xc5, 0x21, 0x7f, 0x12, 0x95, 0xdd, 0x4d, 0x77, 0x01, 0xfa, 0x71, 0x88, 0x2b, 0x7f},
|
||||
{0xdc, 0x9b, 0xc5, 0xa7, 0x6b, 0x84, 0x5c, 0x37, 0x7c, 0xec, 0x05, 0xa1, 0x9f, 0x91, 0x17, 0x3b},
|
||||
{0xea, 0xcf, 0xd9, 0x9b, 0x86, 0xcd, 0x2b, 0x43, 0x54, 0x45, 0x82, 0xc6, 0xfe, 0x73, 0x1a, 0x1a},
|
||||
{0x77, 0xb8, 0x1b, 0x90, 0xb4, 0xb7, 0x32, 0x76, 0x8f, 0x8a, 0x57, 0x06, 0xc7, 0xdd, 0x08, 0x90},
|
||||
};
|
||||
|
||||
static const uint8_t enclave_signature_expected[ENCLAVE_FACTORY_KEY_SLOTS][ENCLAVE_SIGNATURE_SIZE] = {
|
||||
{0xe9, 0x9a, 0xce, 0xe9, 0x4d, 0xe1, 0x7f, 0x55, 0xcb, 0x8a, 0xbf, 0xf2, 0x4d, 0x98, 0x27, 0x67},
|
||||
{0x34, 0x27, 0xa7, 0xea, 0xa8, 0x98, 0x66, 0x9b, 0xed, 0x43, 0xd3, 0x93, 0xb5, 0xa2, 0x87, 0x8e},
|
||||
{0x6c, 0xf3, 0x01, 0x78, 0x53, 0x1b, 0x11, 0x32, 0xf0, 0x27, 0x2f, 0xe3, 0x7d, 0xa6, 0xe2, 0xfd},
|
||||
{0xdf, 0x7f, 0x37, 0x65, 0x2f, 0xdb, 0x7c, 0xcf, 0x5b, 0xb6, 0xe4, 0x9c, 0x63, 0xc5, 0x0f, 0xe0},
|
||||
{0x9b, 0x5c, 0xee, 0x44, 0x0e, 0xd1, 0xcb, 0x5f, 0x28, 0x9f, 0x12, 0x17, 0x59, 0x64, 0x40, 0xbb},
|
||||
{0x94, 0xc2, 0x09, 0x98, 0x62, 0xa7, 0x2b, 0x93, 0xed, 0x36, 0x1f, 0x10, 0xbc, 0x26, 0xbd, 0x41},
|
||||
{0x4d, 0xb2, 0x2b, 0xc5, 0x96, 0x47, 0x61, 0xf4, 0x16, 0xe0, 0x81, 0xc3, 0x8e, 0xb9, 0x9c, 0x9b},
|
||||
{0xc3, 0x6b, 0x83, 0x55, 0x90, 0x38, 0x0f, 0xea, 0xd1, 0x65, 0xbf, 0x32, 0x4f, 0x8e, 0x62, 0x5b},
|
||||
{0x8d, 0x5e, 0x27, 0xbc, 0x14, 0x4f, 0x08, 0xa8, 0x2b, 0x14, 0x89, 0x5e, 0xdf, 0x77, 0x04, 0x31},
|
||||
{0xc9, 0xf7, 0x03, 0xf1, 0x6c, 0x65, 0xad, 0x49, 0x74, 0xbe, 0x00, 0x54, 0xfd, 0xa6, 0x9c, 0x32},
|
||||
};
|
||||
|
||||
void furi_hal_crypto_init() {
|
||||
furi_hal_crypto_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_generate_unique_keys(uint8_t start_slot, uint8_t end_slot) {
|
||||
FuriHalCryptoKey key;
|
||||
uint8_t key_data[32];
|
||||
FURI_LOG_I(TAG, "Generating keys %u..%u", start_slot, end_slot);
|
||||
for(uint8_t slot = start_slot; slot <= end_slot; slot++) {
|
||||
key.type = FuriHalCryptoKeyTypeSimple;
|
||||
key.size = FuriHalCryptoKeySize256;
|
||||
key.data = key_data;
|
||||
furi_hal_random_fill_buf(key_data, 32);
|
||||
if(!furi_hal_crypto_enclave_store_key(&key, &slot)) {
|
||||
FURI_LOG_E(TAG, "Error writing key to slot %u", slot);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_enclave_ensure_key(uint8_t key_slot) {
|
||||
uint8_t keys_nb = 0;
|
||||
uint8_t valid_keys_nb = 0;
|
||||
uint8_t last_valid_slot = ENCLAVE_FACTORY_KEY_SLOTS;
|
||||
uint8_t empty_iv[16] = {0};
|
||||
furi_hal_crypto_enclave_verify(&keys_nb, &valid_keys_nb);
|
||||
if(key_slot <= ENCLAVE_FACTORY_KEY_SLOTS) { // It's a factory key
|
||||
if(key_slot > keys_nb) return false;
|
||||
} else { // Unique key
|
||||
if(keys_nb < ENCLAVE_FACTORY_KEY_SLOTS) // Some factory keys are missing
|
||||
return false;
|
||||
for(uint8_t i = key_slot; i > ENCLAVE_FACTORY_KEY_SLOTS; i--) {
|
||||
if(furi_hal_crypto_enclave_load_key(i, empty_iv)) {
|
||||
last_valid_slot = i;
|
||||
furi_hal_crypto_enclave_unload_key(i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(last_valid_slot == key_slot)
|
||||
return true;
|
||||
else // Generate missing unique keys
|
||||
return furi_hal_crypto_generate_unique_keys(last_valid_slot + 1, key_slot);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_enclave_verify(uint8_t* keys_nb, uint8_t* valid_keys_nb) {
|
||||
furi_assert(keys_nb);
|
||||
furi_assert(valid_keys_nb);
|
||||
uint8_t keys = 0;
|
||||
uint8_t keys_valid = 0;
|
||||
uint8_t buffer[ENCLAVE_SIGNATURE_SIZE];
|
||||
for(size_t key_slot = 0; key_slot < ENCLAVE_FACTORY_KEY_SLOTS; key_slot++) {
|
||||
if(furi_hal_crypto_enclave_load_key(key_slot + 1, enclave_signature_iv[key_slot])) {
|
||||
keys++;
|
||||
if(furi_hal_crypto_encrypt(
|
||||
enclave_signature_input[key_slot], buffer, ENCLAVE_SIGNATURE_SIZE)) {
|
||||
keys_valid +=
|
||||
memcmp(buffer, enclave_signature_expected[key_slot], ENCLAVE_SIGNATURE_SIZE) ==
|
||||
0;
|
||||
}
|
||||
furi_hal_crypto_enclave_unload_key(key_slot + 1);
|
||||
}
|
||||
}
|
||||
*keys_nb = keys;
|
||||
*valid_keys_nb = keys_valid;
|
||||
if(*valid_keys_nb == ENCLAVE_FACTORY_KEY_SLOTS)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_enclave_store_key(FuriHalCryptoKey* key, uint8_t* slot) {
|
||||
furi_assert(key);
|
||||
furi_assert(slot);
|
||||
|
||||
furi_check(furi_mutex_acquire(furi_hal_crypto_mutex, FuriWaitForever) == FuriStatusOk);
|
||||
|
||||
if(!furi_hal_bt_is_alive()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SHCI_C2_FUS_StoreUsrKey_Cmd_Param_t pParam;
|
||||
size_t key_data_size = 0;
|
||||
|
||||
if(key->type == FuriHalCryptoKeyTypeMaster) {
|
||||
pParam.KeyType = KEYTYPE_MASTER;
|
||||
} else if(key->type == FuriHalCryptoKeyTypeSimple) {
|
||||
pParam.KeyType = KEYTYPE_SIMPLE;
|
||||
} else if(key->type == FuriHalCryptoKeyTypeEncrypted) {
|
||||
pParam.KeyType = KEYTYPE_ENCRYPTED;
|
||||
key_data_size += 12;
|
||||
} else {
|
||||
furi_crash("Incorrect key type");
|
||||
}
|
||||
|
||||
if(key->size == FuriHalCryptoKeySize128) {
|
||||
pParam.KeySize = KEYSIZE_16;
|
||||
key_data_size += 16;
|
||||
} else if(key->size == FuriHalCryptoKeySize256) {
|
||||
pParam.KeySize = KEYSIZE_32;
|
||||
key_data_size += 32;
|
||||
} else {
|
||||
furi_crash("Incorrect key size");
|
||||
}
|
||||
|
||||
memcpy(pParam.KeyData, key->data, key_data_size);
|
||||
|
||||
SHCI_CmdStatus_t shci_state = SHCI_C2_FUS_StoreUsrKey(&pParam, slot);
|
||||
furi_check(furi_mutex_release(furi_hal_crypto_mutex) == FuriStatusOk);
|
||||
return (shci_state == SHCI_Success);
|
||||
}
|
||||
|
||||
static void crypto_key_init(uint32_t* key, uint32_t* iv) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
MODIFY_REG(
|
||||
AES1->CR,
|
||||
AES_CR_DATATYPE | AES_CR_KEYSIZE | AES_CR_CHMOD,
|
||||
CRYPTO_DATATYPE_32B | CRYPTO_KEYSIZE_256B | CRYPTO_AES_CBC);
|
||||
|
||||
if(key != NULL) {
|
||||
AES1->KEYR7 = key[0];
|
||||
AES1->KEYR6 = key[1];
|
||||
AES1->KEYR5 = key[2];
|
||||
AES1->KEYR4 = key[3];
|
||||
AES1->KEYR3 = key[4];
|
||||
AES1->KEYR2 = key[5];
|
||||
AES1->KEYR1 = key[6];
|
||||
AES1->KEYR0 = key[7];
|
||||
}
|
||||
|
||||
AES1->IVR3 = iv[0];
|
||||
AES1->IVR2 = iv[1];
|
||||
AES1->IVR1 = iv[2];
|
||||
AES1->IVR0 = iv[3];
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_wait_flag(uint32_t flag) {
|
||||
FuriHalCortexTimer timer = furi_hal_cortex_timer_get(CRYPTO_TIMEOUT_US);
|
||||
while(!READ_BIT(AES1->SR, flag)) {
|
||||
if(furi_hal_cortex_timer_is_expired(timer)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool crypto_process_block(uint32_t* in, uint32_t* out, uint8_t blk_len) {
|
||||
furi_check((blk_len <= 4) && (blk_len > 0));
|
||||
|
||||
for(uint8_t i = 0; i < 4; i++) {
|
||||
if(i < blk_len) {
|
||||
AES1->DINR = in[i];
|
||||
} else {
|
||||
AES1->DINR = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if(!furi_hal_crypto_wait_flag(AES_SR_CCF)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SET_BIT(AES1->CR, AES_CR_CCFC);
|
||||
|
||||
uint32_t out_temp[4];
|
||||
for(uint8_t i = 0; i < 4; i++) {
|
||||
out_temp[i] = AES1->DOUTR;
|
||||
}
|
||||
|
||||
memcpy(out, out_temp, blk_len * sizeof(uint32_t));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_enclave_load_key(uint8_t slot, const uint8_t* iv) {
|
||||
furi_assert(slot > 0 && slot <= 100);
|
||||
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;
|
||||
}
|
||||
|
||||
furi_hal_crypto_mode_init_done = false;
|
||||
crypto_key_init(NULL, (uint32_t*)iv);
|
||||
|
||||
if(SHCI_C2_FUS_LoadUsrKey(slot) == SHCI_Success) {
|
||||
return true;
|
||||
} else {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
furi_check(furi_mutex_release(furi_hal_crypto_mutex) == FuriStatusOk);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_enclave_unload_key(uint8_t slot) {
|
||||
if(!furi_hal_bt_is_alive()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
SHCI_CmdStatus_t shci_state = SHCI_C2_FUS_UnloadUsrKey(slot);
|
||||
furi_assert(shci_state == SHCI_Success);
|
||||
|
||||
furi_hal_bus_disable(FuriHalBusAES1);
|
||||
|
||||
furi_check(furi_mutex_release(furi_hal_crypto_mutex) == FuriStatusOk);
|
||||
return (shci_state == SHCI_Success);
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_load_key(const uint8_t* key, 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);
|
||||
|
||||
furi_hal_crypto_mode_init_done = false;
|
||||
crypto_key_init((uint32_t*)key, (uint32_t*)iv);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_unload_key(void) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
furi_hal_bus_disable(FuriHalBusAES1);
|
||||
|
||||
furi_check(furi_mutex_release(furi_hal_crypto_mutex) == FuriStatusOk);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_encrypt(const uint8_t* input, uint8_t* output, size_t size) {
|
||||
bool state = false;
|
||||
|
||||
SET_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
MODIFY_REG(AES1->CR, AES_CR_MODE, CRYPTO_MODE_ENCRYPT);
|
||||
|
||||
for(size_t i = 0; i < size; i += CRYPTO_BLK_LEN) {
|
||||
size_t blk_len = size - i;
|
||||
if(blk_len > CRYPTO_BLK_LEN) {
|
||||
blk_len = CRYPTO_BLK_LEN;
|
||||
}
|
||||
state = crypto_process_block((uint32_t*)&input[i], (uint32_t*)&output[i], blk_len / 4);
|
||||
if(state == false) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
return state;
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_decrypt(const uint8_t* input, uint8_t* output, size_t size) {
|
||||
bool state = false;
|
||||
|
||||
if(!furi_hal_crypto_mode_init_done) {
|
||||
MODIFY_REG(AES1->CR, AES_CR_MODE, CRYPTO_MODE_INIT);
|
||||
|
||||
SET_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
if(!furi_hal_crypto_wait_flag(AES_SR_CCF)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SET_BIT(AES1->CR, AES_CR_CCFC);
|
||||
|
||||
furi_hal_crypto_mode_init_done = true;
|
||||
}
|
||||
|
||||
MODIFY_REG(AES1->CR, AES_CR_MODE, CRYPTO_MODE_DECRYPT);
|
||||
SET_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
for(size_t i = 0; i < size; i += CRYPTO_BLK_LEN) {
|
||||
size_t blk_len = size - i;
|
||||
if(blk_len > CRYPTO_BLK_LEN) {
|
||||
blk_len = CRYPTO_BLK_LEN;
|
||||
}
|
||||
state = crypto_process_block((uint32_t*)&input[i], (uint32_t*)&output[i], blk_len / 4);
|
||||
if(state == false) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
return state;
|
||||
}
|
||||
|
||||
static void crypto_key_init_bswap(uint32_t* key, uint32_t* iv, uint32_t chaining_mode) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
MODIFY_REG(
|
||||
AES1->CR,
|
||||
AES_CR_DATATYPE | AES_CR_KEYSIZE | AES_CR_CHMOD,
|
||||
CRYPTO_DATATYPE_32B | CRYPTO_KEYSIZE_256B | chaining_mode);
|
||||
|
||||
if(key != NULL) {
|
||||
AES1->KEYR7 = __builtin_bswap32(key[0]);
|
||||
AES1->KEYR6 = __builtin_bswap32(key[1]);
|
||||
AES1->KEYR5 = __builtin_bswap32(key[2]);
|
||||
AES1->KEYR4 = __builtin_bswap32(key[3]);
|
||||
AES1->KEYR3 = __builtin_bswap32(key[4]);
|
||||
AES1->KEYR2 = __builtin_bswap32(key[5]);
|
||||
AES1->KEYR1 = __builtin_bswap32(key[6]);
|
||||
AES1->KEYR0 = __builtin_bswap32(key[7]);
|
||||
}
|
||||
|
||||
AES1->IVR3 = __builtin_bswap32(iv[0]);
|
||||
AES1->IVR2 = __builtin_bswap32(iv[1]);
|
||||
AES1->IVR1 = __builtin_bswap32(iv[2]);
|
||||
AES1->IVR0 = __builtin_bswap32(iv[3]);
|
||||
}
|
||||
|
||||
static bool
|
||||
furi_hal_crypto_load_key_bswap(const uint8_t* key, const uint8_t* iv, uint32_t chaining_mode) {
|
||||
furi_assert(furi_hal_crypto_mutex);
|
||||
furi_check(furi_mutex_acquire(furi_hal_crypto_mutex, FuriWaitForever) == FuriStatusOk);
|
||||
|
||||
furi_hal_bus_enable(FuriHalBusAES1);
|
||||
|
||||
crypto_key_init_bswap((uint32_t*)key, (uint32_t*)iv, chaining_mode);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool wait_for_crypto(void) {
|
||||
if(!furi_hal_crypto_wait_flag(AES_SR_CCF)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SET_BIT(AES1->CR, AES_CR_CCFC);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_process_block_bswap(const uint8_t* in, uint8_t* out, size_t bytes) {
|
||||
uint32_t block[CRYPTO_BLK_LEN / 4];
|
||||
memset(block, 0, sizeof(block));
|
||||
|
||||
memcpy(block, in, bytes);
|
||||
|
||||
block[0] = __builtin_bswap32(block[0]);
|
||||
block[1] = __builtin_bswap32(block[1]);
|
||||
block[2] = __builtin_bswap32(block[2]);
|
||||
block[3] = __builtin_bswap32(block[3]);
|
||||
|
||||
if(!crypto_process_block(block, block, CRYPTO_BLK_LEN / 4)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
block[0] = __builtin_bswap32(block[0]);
|
||||
block[1] = __builtin_bswap32(block[1]);
|
||||
block[2] = __builtin_bswap32(block[2]);
|
||||
block[3] = __builtin_bswap32(block[3]);
|
||||
|
||||
memcpy(out, block, bytes);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_process_block_no_read_bswap(const uint8_t* in, size_t bytes) {
|
||||
uint32_t block[CRYPTO_BLK_LEN / 4];
|
||||
memset(block, 0, sizeof(block));
|
||||
|
||||
memcpy(block, in, bytes);
|
||||
|
||||
AES1->DINR = __builtin_bswap32(block[0]);
|
||||
AES1->DINR = __builtin_bswap32(block[1]);
|
||||
AES1->DINR = __builtin_bswap32(block[2]);
|
||||
AES1->DINR = __builtin_bswap32(block[3]);
|
||||
|
||||
return wait_for_crypto();
|
||||
}
|
||||
|
||||
static void furi_hal_crypto_ctr_prep_iv(uint8_t* iv) {
|
||||
/* append counter to IV */
|
||||
iv[CRYPTO_CTR_IV_LEN] = 0;
|
||||
iv[CRYPTO_CTR_IV_LEN + 1] = 0;
|
||||
iv[CRYPTO_CTR_IV_LEN + 2] = 0;
|
||||
iv[CRYPTO_CTR_IV_LEN + 3] = 1;
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_ctr_payload(const uint8_t* input, uint8_t* output, size_t length) {
|
||||
SET_BIT(AES1->CR, AES_CR_EN);
|
||||
MODIFY_REG(AES1->CR, AES_CR_MODE, CRYPTO_MODE_ENCRYPT);
|
||||
|
||||
size_t last_block_bytes = length % CRYPTO_BLK_LEN;
|
||||
|
||||
size_t i;
|
||||
for(i = 0; i < length - last_block_bytes; i += CRYPTO_BLK_LEN) {
|
||||
if(!furi_hal_crypto_process_block_bswap(&input[i], &output[i], CRYPTO_BLK_LEN)) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if(last_block_bytes > 0) {
|
||||
if(!furi_hal_crypto_process_block_bswap(&input[i], &output[i], last_block_bytes)) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_ctr(
|
||||
const uint8_t* key,
|
||||
const uint8_t* iv,
|
||||
const uint8_t* input,
|
||||
uint8_t* output,
|
||||
size_t length) {
|
||||
/* prepare IV and counter */
|
||||
uint8_t iv_and_counter[CRYPTO_CTR_IV_LEN + CRYPTO_CTR_CTR_LEN];
|
||||
memcpy(iv_and_counter, iv, CRYPTO_CTR_IV_LEN); //-V1086
|
||||
furi_hal_crypto_ctr_prep_iv(iv_and_counter);
|
||||
|
||||
/* load key and IV and set the mode to CTR */
|
||||
if(!furi_hal_crypto_load_key_bswap(key, iv_and_counter, CRYPTO_AES_CTR)) {
|
||||
furi_hal_crypto_unload_key();
|
||||
return false;
|
||||
}
|
||||
|
||||
/* process the input and write to output */
|
||||
bool state = furi_hal_crypto_ctr_payload(input, output, length);
|
||||
|
||||
furi_hal_crypto_unload_key();
|
||||
|
||||
return state;
|
||||
}
|
||||
|
||||
static void furi_hal_crypto_gcm_prep_iv(uint8_t* iv) {
|
||||
/* append counter to IV */
|
||||
iv[CRYPTO_GCM_IV_LEN] = 0;
|
||||
iv[CRYPTO_GCM_IV_LEN + 1] = 0;
|
||||
iv[CRYPTO_GCM_IV_LEN + 2] = 0;
|
||||
iv[CRYPTO_GCM_IV_LEN + 3] = 2;
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_gcm_init(bool decrypt) {
|
||||
/* GCM init phase */
|
||||
|
||||
MODIFY_REG(AES1->CR, AES_CR_GCMPH, CRYPTO_GCM_PH_INIT);
|
||||
if(decrypt) {
|
||||
MODIFY_REG(AES1->CR, AES_CR_MODE, CRYPTO_MODE_DECRYPT);
|
||||
} else {
|
||||
MODIFY_REG(AES1->CR, AES_CR_MODE, CRYPTO_MODE_ENCRYPT);
|
||||
}
|
||||
|
||||
SET_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
if(!wait_for_crypto()) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_gcm_header(const uint8_t* aad, size_t aad_length) {
|
||||
/* GCM header phase */
|
||||
|
||||
MODIFY_REG(AES1->CR, AES_CR_GCMPH, CRYPTO_GCM_PH_HEADER);
|
||||
SET_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
size_t last_block_bytes = aad_length % CRYPTO_BLK_LEN;
|
||||
|
||||
size_t i;
|
||||
for(i = 0; i < aad_length - last_block_bytes; i += CRYPTO_BLK_LEN) {
|
||||
if(!furi_hal_crypto_process_block_no_read_bswap(&aad[i], CRYPTO_BLK_LEN)) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if(last_block_bytes > 0) {
|
||||
if(!furi_hal_crypto_process_block_no_read_bswap(&aad[i], last_block_bytes)) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_gcm_payload(
|
||||
const uint8_t* input,
|
||||
uint8_t* output,
|
||||
size_t length,
|
||||
bool decrypt) {
|
||||
/* GCM payload phase */
|
||||
|
||||
MODIFY_REG(AES1->CR, AES_CR_GCMPH, CRYPTO_GCM_PH_PAYLOAD);
|
||||
SET_BIT(AES1->CR, AES_CR_EN);
|
||||
|
||||
size_t last_block_bytes = length % CRYPTO_BLK_LEN;
|
||||
|
||||
size_t i;
|
||||
for(i = 0; i < length - last_block_bytes; i += CRYPTO_BLK_LEN) {
|
||||
if(!furi_hal_crypto_process_block_bswap(&input[i], &output[i], CRYPTO_BLK_LEN)) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if(last_block_bytes > 0) {
|
||||
if(!decrypt) {
|
||||
MODIFY_REG(
|
||||
AES1->CR, AES_CR_NPBLB, (CRYPTO_BLK_LEN - last_block_bytes) << AES_CR_NPBLB_Pos);
|
||||
}
|
||||
if(!furi_hal_crypto_process_block_bswap(&input[i], &output[i], last_block_bytes)) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_gcm_finish(size_t aad_length, size_t payload_length, uint8_t* tag) {
|
||||
/* GCM final phase */
|
||||
|
||||
MODIFY_REG(AES1->CR, AES_CR_GCMPH, CRYPTO_GCM_PH_FINAL);
|
||||
|
||||
uint32_t last_block[CRYPTO_BLK_LEN / 4];
|
||||
memset(last_block, 0, sizeof(last_block));
|
||||
last_block[1] = __builtin_bswap32((uint32_t)(aad_length * 8));
|
||||
last_block[3] = __builtin_bswap32((uint32_t)(payload_length * 8));
|
||||
|
||||
if(!furi_hal_crypto_process_block_bswap((uint8_t*)&last_block[0], tag, CRYPTO_BLK_LEN)) {
|
||||
CLEAR_BIT(AES1->CR, AES_CR_EN);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool furi_hal_crypto_gcm_compare_tag(const uint8_t* tag1, const uint8_t* tag2) {
|
||||
uint8_t diff = 0;
|
||||
|
||||
size_t i;
|
||||
for(i = 0; i < CRYPTO_GCM_TAG_LEN; i++) {
|
||||
diff |= tag1[i] ^ tag2[i];
|
||||
}
|
||||
|
||||
return (diff == 0);
|
||||
}
|
||||
|
||||
bool furi_hal_crypto_gcm(
|
||||
const uint8_t* key,
|
||||
const uint8_t* iv,
|
||||
const uint8_t* aad,
|
||||
size_t aad_length,
|
||||
const uint8_t* input,
|
||||
uint8_t* output,
|
||||
size_t length,
|
||||
uint8_t* tag,
|
||||
bool decrypt) {
|
||||
/* GCM init phase */
|
||||
|
||||
/* prepare IV and counter */
|
||||
uint8_t iv_and_counter[CRYPTO_GCM_IV_LEN + CRYPTO_GCM_CTR_LEN];
|
||||
memcpy(iv_and_counter, iv, CRYPTO_GCM_IV_LEN); //-V1086
|
||||
furi_hal_crypto_gcm_prep_iv(iv_and_counter);
|
||||
|
||||
/* load key and IV and set the mode to CTR */
|
||||
if(!furi_hal_crypto_load_key_bswap(key, iv_and_counter, CRYPTO_AES_GCM)) {
|
||||
furi_hal_crypto_unload_key();
|
||||
return false;
|
||||
}
|
||||
|
||||
if(!furi_hal_crypto_gcm_init(decrypt)) {
|
||||
furi_hal_crypto_unload_key();
|
||||
return false;
|
||||
}
|
||||
|
||||
/* GCM header phase */
|
||||
|
||||
if(aad_length > 0) {
|
||||
if(!furi_hal_crypto_gcm_header(aad, aad_length)) {
|
||||
furi_hal_crypto_unload_key();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/* GCM payload phase */
|
||||
|
||||
if(!furi_hal_crypto_gcm_payload(input, output, length, decrypt)) {
|
||||
furi_hal_crypto_unload_key();
|
||||
return false;
|
||||
}
|
||||
|
||||
/* GCM final phase */
|
||||
|
||||
if(!furi_hal_crypto_gcm_finish(aad_length, length, tag)) {
|
||||
furi_hal_crypto_unload_key();
|
||||
return false;
|
||||
}
|
||||
|
||||
furi_hal_crypto_unload_key();
|
||||
return true;
|
||||
}
|
||||
|
||||
FuriHalCryptoGCMState furi_hal_crypto_gcm_encrypt_and_tag(
|
||||
const uint8_t* key,
|
||||
const uint8_t* iv,
|
||||
const uint8_t* aad,
|
||||
size_t aad_length,
|
||||
const uint8_t* input,
|
||||
uint8_t* output,
|
||||
size_t length,
|
||||
uint8_t* tag) {
|
||||
if(!furi_hal_crypto_gcm(key, iv, aad, aad_length, input, output, length, tag, false)) {
|
||||
memset(output, 0, length);
|
||||
memset(tag, 0, CRYPTO_GCM_TAG_LEN);
|
||||
return FuriHalCryptoGCMStateError;
|
||||
}
|
||||
|
||||
return FuriHalCryptoGCMStateOk;
|
||||
}
|
||||
|
||||
FuriHalCryptoGCMState furi_hal_crypto_gcm_decrypt_and_verify(
|
||||
const uint8_t* key,
|
||||
const uint8_t* iv,
|
||||
const uint8_t* aad,
|
||||
size_t aad_length,
|
||||
const uint8_t* input,
|
||||
uint8_t* output,
|
||||
size_t length,
|
||||
const uint8_t* tag) {
|
||||
uint8_t dtag[CRYPTO_GCM_TAG_LEN];
|
||||
|
||||
if(!furi_hal_crypto_gcm(key, iv, aad, aad_length, input, output, length, dtag, true)) {
|
||||
memset(output, 0, length);
|
||||
return FuriHalCryptoGCMStateError;
|
||||
}
|
||||
|
||||
if(!furi_hal_crypto_gcm_compare_tag(dtag, tag)) {
|
||||
memset(output, 0, length);
|
||||
return FuriHalCryptoGCMStateAuthFailure;
|
||||
}
|
||||
|
||||
return FuriHalCryptoGCMStateOk;
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
#include <furi_hal_debug.h>
|
||||
|
||||
#include <stm32wbxx_ll_exti.h>
|
||||
#include <stm32wbxx_ll_system.h>
|
||||
|
||||
#include <furi_hal_gpio.h>
|
||||
#include <furi_hal_resources.h>
|
||||
|
||||
volatile bool furi_hal_debug_gdb_session_active = false;
|
||||
|
||||
void furi_hal_debug_enable() {
|
||||
// Low power mode debug
|
||||
LL_DBGMCU_EnableDBGSleepMode();
|
||||
LL_DBGMCU_EnableDBGStopMode();
|
||||
LL_DBGMCU_EnableDBGStandbyMode();
|
||||
LL_EXTI_EnableIT_32_63(LL_EXTI_LINE_48);
|
||||
// SWD GPIO
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_swdio,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullUp,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn0JTMS_SWDIO);
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_swclk, GpioModeAltFunctionPushPull, GpioPullDown, GpioSpeedLow, GpioAltFn0JTCK_SWCLK);
|
||||
}
|
||||
|
||||
void furi_hal_debug_disable() {
|
||||
// Low power mode debug
|
||||
LL_DBGMCU_DisableDBGSleepMode();
|
||||
LL_DBGMCU_DisableDBGStopMode();
|
||||
LL_DBGMCU_DisableDBGStandbyMode();
|
||||
LL_EXTI_DisableIT_32_63(LL_EXTI_LINE_48);
|
||||
// SWD GPIO
|
||||
furi_hal_gpio_init_simple(&gpio_swdio, GpioModeAnalog);
|
||||
furi_hal_gpio_init_simple(&gpio_swclk, GpioModeAnalog);
|
||||
}
|
||||
|
||||
bool furi_hal_debug_is_gdb_session_active() {
|
||||
return furi_hal_debug_gdb_session_active;
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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
|
||||
@@ -0,0 +1,560 @@
|
||||
#include <furi_hal_flash.h>
|
||||
#include <furi_hal_bt.h>
|
||||
#include <furi_hal_power.h>
|
||||
#include <furi_hal_cortex.h>
|
||||
#include <furi.h>
|
||||
#include <ble/ble.h>
|
||||
#include <interface/patterns/ble_thread/shci/shci.h>
|
||||
|
||||
#include <stm32wbxx.h>
|
||||
#include <stm32wbxx_ll_hsem.h>
|
||||
|
||||
#include <hsem_map.h>
|
||||
|
||||
#define TAG "FuriHalFlash"
|
||||
|
||||
#define FURI_HAL_CRITICAL_MSG "Critical flash operation fail"
|
||||
#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 (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
|
||||
* ProcessSingleFlashOperation, quote:
|
||||
> In most BLE application, the flash should not be blocked by the CPU2 longer than FLASH_TIMEOUT_VALUE (1000ms)
|
||||
> However, it could be that for some marginal application, this time is longer.
|
||||
> ... there is no other way than waiting the operation to be completed.
|
||||
> 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 IS_ADDR_ALIGNED_64BITS(__VALUE__) (((__VALUE__)&0x7U) == (0x00UL))
|
||||
#define IS_FLASH_PROGRAM_ADDRESS(__VALUE__) \
|
||||
(((__VALUE__) >= FLASH_BASE) && ((__VALUE__) <= (FLASH_BASE + FLASH_SIZE - 8UL)) && \
|
||||
(((__VALUE__) % 8UL) == 0UL))
|
||||
|
||||
/* Free flash space borders, exported by linker */
|
||||
extern const void __free_flash_start__;
|
||||
|
||||
size_t furi_hal_flash_get_base() {
|
||||
return FLASH_BASE;
|
||||
}
|
||||
|
||||
size_t furi_hal_flash_get_read_block_size() {
|
||||
return FURI_HAL_FLASH_READ_BLOCK;
|
||||
}
|
||||
|
||||
size_t furi_hal_flash_get_write_block_size() {
|
||||
return FURI_HAL_FLASH_WRITE_BLOCK;
|
||||
}
|
||||
|
||||
size_t furi_hal_flash_get_page_size() {
|
||||
return FURI_HAL_FLASH_PAGE_SIZE;
|
||||
}
|
||||
|
||||
size_t furi_hal_flash_get_cycles_count() {
|
||||
return FURI_HAL_FLASH_CYCLES_COUNT;
|
||||
}
|
||||
|
||||
const void* furi_hal_flash_get_free_start_address() {
|
||||
return &__free_flash_start__;
|
||||
}
|
||||
|
||||
const void* furi_hal_flash_get_free_end_address() {
|
||||
uint32_t sfr_reg_val = READ_REG(FLASH->SFR);
|
||||
uint32_t sfsa = (READ_BIT(sfr_reg_val, FLASH_SFR_SFSA) >> FLASH_SFR_SFSA_Pos);
|
||||
return (const void*)((sfsa * FURI_HAL_FLASH_PAGE_SIZE) + FLASH_BASE);
|
||||
}
|
||||
|
||||
size_t furi_hal_flash_get_free_page_start_address() {
|
||||
size_t start = (size_t)furi_hal_flash_get_free_start_address();
|
||||
size_t page_start = start - start % FURI_HAL_FLASH_PAGE_SIZE;
|
||||
if(page_start != start) {
|
||||
page_start += FURI_HAL_FLASH_PAGE_SIZE;
|
||||
}
|
||||
return page_start;
|
||||
}
|
||||
|
||||
size_t furi_hal_flash_get_free_page_count() {
|
||||
size_t end = (size_t)furi_hal_flash_get_free_end_address();
|
||||
size_t page_start = (size_t)furi_hal_flash_get_free_page_start_address();
|
||||
return (end - page_start) / FURI_HAL_FLASH_PAGE_SIZE;
|
||||
}
|
||||
|
||||
void furi_hal_flash_init() {
|
||||
/* Errata 2.2.9, Flash OPTVERR flag is always set after system reset */
|
||||
// WRITE_REG(FLASH->SR, FLASH_SR_OPTVERR);
|
||||
/* Actually, reset all error flags on start */
|
||||
if(READ_BIT(FLASH->SR, FURI_HAL_FLASH_SR_ERRORS)) {
|
||||
FURI_LOG_E(TAG, "FLASH->SR 0x%08lX", FLASH->SR);
|
||||
WRITE_REG(FLASH->SR, FURI_HAL_FLASH_SR_ERRORS);
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_flash_unlock() {
|
||||
/* verify Flash is locked */
|
||||
furi_check(READ_BIT(FLASH->CR, FLASH_CR_LOCK) != 0U);
|
||||
|
||||
/* Authorize the FLASH Registers access */
|
||||
WRITE_REG(FLASH->KEYR, FURI_HAL_FLASH_KEY1);
|
||||
__ISB();
|
||||
WRITE_REG(FLASH->KEYR, FURI_HAL_FLASH_KEY2);
|
||||
|
||||
/* verify Flash is unlocked */
|
||||
furi_check(READ_BIT(FLASH->CR, FLASH_CR_LOCK) == 0U);
|
||||
}
|
||||
|
||||
static void furi_hal_flash_lock(void) {
|
||||
/* verify Flash is unlocked */
|
||||
furi_check(READ_BIT(FLASH->CR, FLASH_CR_LOCK) == 0U);
|
||||
|
||||
/* Set the LOCK Bit to lock the FLASH Registers access */
|
||||
/* @Note The lock and unlock procedure is done only using CR registers even from CPU2 */
|
||||
SET_BIT(FLASH->CR, FLASH_CR_LOCK);
|
||||
|
||||
/* verify Flash is locked */
|
||||
furi_check(READ_BIT(FLASH->CR, FLASH_CR_LOCK) != 0U);
|
||||
}
|
||||
|
||||
static void furi_hal_flash_begin_with_core2(bool erase_flag) {
|
||||
furi_hal_power_insomnia_enter();
|
||||
/* Take flash controller ownership */
|
||||
while(LL_HSEM_1StepLock(HSEM, CFG_HW_FLASH_SEMID) != 0) {
|
||||
furi_thread_yield();
|
||||
}
|
||||
|
||||
/* Unlock flash operation */
|
||||
furi_hal_flash_unlock();
|
||||
|
||||
/* Erase activity notification */
|
||||
if(erase_flag) SHCI_C2_FLASH_EraseActivity(ERASE_ACTIVITY_ON);
|
||||
|
||||
/* 64mHz 5us core2 flag protection */
|
||||
for(volatile uint32_t i = 0; i < 35; i++)
|
||||
;
|
||||
|
||||
FuriHalCortexTimer timer = furi_hal_cortex_timer_get(FURI_HAL_FLASH_C2_LOCK_TIMEOUT_MS * 1000);
|
||||
while(true) {
|
||||
/* Wait till flash controller become usable */
|
||||
while(LL_FLASH_IsActiveFlag_OperationSuspended()) {
|
||||
furi_check(!furi_hal_cortex_timer_is_expired(timer));
|
||||
furi_thread_yield();
|
||||
};
|
||||
|
||||
/* Just a little more love */
|
||||
taskENTER_CRITICAL();
|
||||
|
||||
/* Actually we already have mutex for it, but specification is specification */
|
||||
if(LL_HSEM_IsSemaphoreLocked(HSEM, CFG_HW_BLOCK_FLASH_REQ_BY_CPU1_SEMID)) {
|
||||
taskEXIT_CRITICAL();
|
||||
furi_check(!furi_hal_cortex_timer_is_expired(timer));
|
||||
furi_thread_yield();
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Take sempahopre and prevent core2 from anything funky */
|
||||
if(LL_HSEM_1StepLock(HSEM, CFG_HW_BLOCK_FLASH_REQ_BY_CPU2_SEMID) != 0) {
|
||||
taskEXIT_CRITICAL();
|
||||
furi_check(!furi_hal_cortex_timer_is_expired(timer));
|
||||
furi_thread_yield();
|
||||
continue;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_flash_begin(bool erase_flag) {
|
||||
/* Acquire dangerous ops mutex */
|
||||
furi_hal_bt_lock_core2();
|
||||
|
||||
/* If Core2 is running use IPC locking */
|
||||
if(furi_hal_bt_is_alive()) {
|
||||
furi_hal_flash_begin_with_core2(erase_flag);
|
||||
} else {
|
||||
furi_hal_flash_unlock();
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_flash_end_with_core2(bool erase_flag) {
|
||||
/* Funky ops are ok at this point */
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_BLOCK_FLASH_REQ_BY_CPU2_SEMID, 0);
|
||||
|
||||
/* Task switching is ok */
|
||||
taskEXIT_CRITICAL();
|
||||
|
||||
/* Doesn't make much sense, does it? */
|
||||
while(READ_BIT(FLASH->SR, FLASH_SR_BSY)) {
|
||||
furi_thread_yield();
|
||||
}
|
||||
|
||||
/* Erase activity over, core2 can continue */
|
||||
if(erase_flag) SHCI_C2_FLASH_EraseActivity(ERASE_ACTIVITY_OFF);
|
||||
|
||||
/* Lock flash controller */
|
||||
furi_hal_flash_lock();
|
||||
|
||||
/* Release flash controller ownership */
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_FLASH_SEMID, 0);
|
||||
furi_hal_power_insomnia_exit();
|
||||
}
|
||||
|
||||
static void furi_hal_flash_end(bool erase_flag) {
|
||||
/* If Core2 is running - use IPC locking */
|
||||
if(furi_hal_bt_is_alive()) {
|
||||
furi_hal_flash_end_with_core2(erase_flag);
|
||||
} else {
|
||||
furi_hal_flash_lock();
|
||||
}
|
||||
|
||||
/* Release dangerous ops mutex */
|
||||
furi_hal_bt_unlock_core2();
|
||||
}
|
||||
|
||||
static void furi_hal_flush_cache(void) {
|
||||
/* Flush instruction cache */
|
||||
if(READ_BIT(FLASH->ACR, FLASH_ACR_ICEN) == FLASH_ACR_ICEN) {
|
||||
/* Disable instruction cache */
|
||||
LL_FLASH_DisableInstCache();
|
||||
/* Reset instruction cache */
|
||||
LL_FLASH_EnableInstCacheReset();
|
||||
LL_FLASH_DisableInstCacheReset();
|
||||
/* Enable instruction cache */
|
||||
LL_FLASH_EnableInstCache();
|
||||
}
|
||||
|
||||
/* Flush data cache */
|
||||
if(READ_BIT(FLASH->ACR, FLASH_ACR_DCEN) == FLASH_ACR_DCEN) {
|
||||
/* Disable data cache */
|
||||
LL_FLASH_DisableDataCache();
|
||||
/* Reset data cache */
|
||||
LL_FLASH_EnableDataCacheReset();
|
||||
LL_FLASH_DisableDataCacheReset();
|
||||
/* Enable data cache */
|
||||
LL_FLASH_EnableDataCache();
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_flash_wait_last_operation(uint32_t timeout) {
|
||||
uint32_t error = 0;
|
||||
|
||||
/* Wait for the FLASH operation to complete by polling on BUSY flag to be reset.
|
||||
Even if the FLASH operation fails, the BUSY flag will be reset and an error
|
||||
flag will be set */
|
||||
FuriHalCortexTimer timer = furi_hal_cortex_timer_get(timeout * 1000);
|
||||
while(READ_BIT(FLASH->SR, FLASH_SR_BSY)) {
|
||||
if(furi_hal_cortex_timer_is_expired(timer)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/* Check FLASH operation error flags */
|
||||
error = FLASH->SR;
|
||||
|
||||
/* Check FLASH End of Operation flag */
|
||||
if((error & FLASH_SR_EOP) != 0U) {
|
||||
/* Clear FLASH End of Operation pending bit */
|
||||
CLEAR_BIT(FLASH->SR, FLASH_SR_EOP);
|
||||
}
|
||||
|
||||
/* Now update error variable to only error value */
|
||||
error &= FURI_HAL_FLASH_SR_ERRORS;
|
||||
|
||||
furi_check(error == 0);
|
||||
|
||||
/* clear error flags */
|
||||
CLEAR_BIT(FLASH->SR, error);
|
||||
|
||||
/* Wait for control register to be written */
|
||||
timer = furi_hal_cortex_timer_get(timeout * 1000);
|
||||
while(READ_BIT(FLASH->SR, FLASH_SR_CFGBSY)) {
|
||||
if(furi_hal_cortex_timer_is_expired(timer)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void furi_hal_flash_erase(uint8_t page) {
|
||||
furi_hal_flash_begin(true);
|
||||
|
||||
/* Ensure that controller state is valid */
|
||||
furi_check(FLASH->SR == 0);
|
||||
|
||||
/* Verify that next operation can be proceed */
|
||||
furi_check(furi_hal_flash_wait_last_operation(FURI_HAL_FLASH_TIMEOUT));
|
||||
|
||||
/* Select page and start operation */
|
||||
MODIFY_REG(
|
||||
FLASH->CR, FLASH_CR_PNB, ((page << FLASH_CR_PNB_Pos) | FLASH_CR_PER | FLASH_CR_STRT));
|
||||
|
||||
/* Wait for last operation to be completed */
|
||||
furi_check(furi_hal_flash_wait_last_operation(FURI_HAL_FLASH_TIMEOUT));
|
||||
|
||||
/* If operation is completed or interrupted, disable the Page Erase Bit */
|
||||
CLEAR_BIT(FLASH->CR, (FLASH_CR_PER | FLASH_CR_PNB));
|
||||
|
||||
/* Flush the caches to be sure of the data consistency */
|
||||
furi_hal_flush_cache();
|
||||
|
||||
furi_hal_flash_end(true);
|
||||
}
|
||||
|
||||
static inline void furi_hal_flash_write_dword_internal_nowait(size_t address, uint64_t* data) {
|
||||
/* Program first word */
|
||||
*(uint32_t*)address = (uint32_t)*data;
|
||||
|
||||
/* Barrier to ensure programming is performed in 2 steps, in right order
|
||||
(independently of compiler optimization behavior) */
|
||||
__ISB();
|
||||
|
||||
/* Program second word */
|
||||
*(uint32_t*)(address + 4U) = (uint32_t)(*data >> 32U);
|
||||
}
|
||||
|
||||
static inline void furi_hal_flash_write_dword_internal(size_t address, uint64_t* data) {
|
||||
furi_hal_flash_write_dword_internal_nowait(address, data);
|
||||
|
||||
/* Wait for last operation to be completed */
|
||||
furi_check(furi_hal_flash_wait_last_operation(FURI_HAL_FLASH_TIMEOUT));
|
||||
}
|
||||
|
||||
void furi_hal_flash_write_dword(size_t address, uint64_t data) {
|
||||
furi_hal_flash_begin(false);
|
||||
|
||||
/* Ensure that controller state is valid */
|
||||
furi_check(FLASH->SR == 0);
|
||||
|
||||
/* Check the parameters */
|
||||
furi_check(IS_ADDR_ALIGNED_64BITS(address));
|
||||
furi_check(IS_FLASH_PROGRAM_ADDRESS(address));
|
||||
|
||||
/* Set PG bit */
|
||||
SET_BIT(FLASH->CR, FLASH_CR_PG);
|
||||
|
||||
/* Do the thing */
|
||||
furi_hal_flash_write_dword_internal(address, &data);
|
||||
|
||||
/* If the program operation is completed, disable the PG or FSTPG Bit */
|
||||
CLEAR_BIT(FLASH->CR, FLASH_CR_PG);
|
||||
|
||||
furi_hal_flash_end(false);
|
||||
|
||||
/* Wait for last operation to be completed */
|
||||
furi_check(furi_hal_flash_wait_last_operation(FURI_HAL_FLASH_TIMEOUT));
|
||||
}
|
||||
|
||||
static size_t furi_hal_flash_get_page_address(uint8_t page) {
|
||||
return furi_hal_flash_get_base() + page * FURI_HAL_FLASH_PAGE_SIZE;
|
||||
}
|
||||
|
||||
void furi_hal_flash_program_page(const uint8_t page, const uint8_t* data, uint16_t _length) {
|
||||
uint16_t length = _length;
|
||||
furi_check(length <= FURI_HAL_FLASH_PAGE_SIZE);
|
||||
|
||||
furi_hal_flash_erase(page);
|
||||
|
||||
furi_hal_flash_begin(false);
|
||||
|
||||
furi_check(furi_hal_flash_wait_last_operation(FURI_HAL_FLASH_TIMEOUT));
|
||||
|
||||
/* Ensure that controller state is valid */
|
||||
furi_check(FLASH->SR == 0);
|
||||
|
||||
size_t page_start_address = furi_hal_flash_get_page_address(page);
|
||||
|
||||
size_t length_written = 0;
|
||||
|
||||
const uint16_t FAST_PROG_BLOCK_SIZE = 512;
|
||||
const uint8_t DWORD_PROG_BLOCK_SIZE = 8;
|
||||
|
||||
/* Write as much data as we can in fast mode */
|
||||
if(length >= FAST_PROG_BLOCK_SIZE) {
|
||||
taskENTER_CRITICAL();
|
||||
/* Enable fast flash programming mode */
|
||||
SET_BIT(FLASH->CR, FLASH_CR_FSTPG);
|
||||
|
||||
while(length_written < (length / FAST_PROG_BLOCK_SIZE * FAST_PROG_BLOCK_SIZE)) {
|
||||
/* No context switch in the middle of the operation */
|
||||
furi_hal_flash_write_dword_internal_nowait(
|
||||
page_start_address + length_written, (uint64_t*)(data + length_written));
|
||||
length_written += DWORD_PROG_BLOCK_SIZE;
|
||||
|
||||
if((length_written % FAST_PROG_BLOCK_SIZE) == 0) {
|
||||
/* Wait for block operation to be completed */
|
||||
furi_check(furi_hal_flash_wait_last_operation(FURI_HAL_FLASH_TIMEOUT));
|
||||
}
|
||||
}
|
||||
CLEAR_BIT(FLASH->CR, FLASH_CR_FSTPG);
|
||||
taskEXIT_CRITICAL();
|
||||
}
|
||||
|
||||
/* Enable regular (dword) programming mode */
|
||||
SET_BIT(FLASH->CR, FLASH_CR_PG);
|
||||
if((length % FAST_PROG_BLOCK_SIZE) != 0) {
|
||||
/* Write tail in regular, dword mode */
|
||||
while(length_written < (length / DWORD_PROG_BLOCK_SIZE * DWORD_PROG_BLOCK_SIZE)) {
|
||||
furi_hal_flash_write_dword_internal(
|
||||
page_start_address + length_written, (uint64_t*)&data[length_written]);
|
||||
length_written += DWORD_PROG_BLOCK_SIZE;
|
||||
}
|
||||
}
|
||||
|
||||
if((length % DWORD_PROG_BLOCK_SIZE) != 0) {
|
||||
/* there are more bytes, not fitting into dwords */
|
||||
uint64_t tail_data = 0;
|
||||
for(int32_t tail_i = 0; tail_i < (length % DWORD_PROG_BLOCK_SIZE); ++tail_i) {
|
||||
tail_data |= (((uint64_t)data[length_written + tail_i]) << (tail_i * 8));
|
||||
}
|
||||
|
||||
furi_hal_flash_write_dword_internal(page_start_address + length_written, &tail_data);
|
||||
}
|
||||
/* Disable the PG Bit */
|
||||
CLEAR_BIT(FLASH->CR, FLASH_CR_PG);
|
||||
|
||||
furi_hal_flash_end(false);
|
||||
}
|
||||
|
||||
int16_t furi_hal_flash_get_page_number(size_t address) {
|
||||
const size_t flash_base = furi_hal_flash_get_base();
|
||||
if((address < flash_base) ||
|
||||
(address > flash_base + FURI_HAL_FLASH_TOTAL_PAGES * FURI_HAL_FLASH_PAGE_SIZE)) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return (address - flash_base) / FURI_HAL_FLASH_PAGE_SIZE;
|
||||
}
|
||||
|
||||
uint32_t furi_hal_flash_ob_get_word(size_t word_idx, bool complementary) {
|
||||
furi_check(word_idx <= FURI_HAL_FLASH_OB_TOTAL_WORDS);
|
||||
const uint32_t* ob_data = (const uint32_t*)(OPTION_BYTE_BASE);
|
||||
size_t raw_word_idx = word_idx * 2;
|
||||
if(complementary) {
|
||||
raw_word_idx += 1;
|
||||
}
|
||||
return ob_data[raw_word_idx];
|
||||
}
|
||||
|
||||
void furi_hal_flash_ob_unlock() {
|
||||
furi_check(READ_BIT(FLASH->CR, FLASH_CR_OPTLOCK) != 0U);
|
||||
furi_hal_flash_begin(true);
|
||||
WRITE_REG(FLASH->OPTKEYR, FURI_HAL_FLASH_OPT_KEY1);
|
||||
__ISB();
|
||||
WRITE_REG(FLASH->OPTKEYR, FURI_HAL_FLASH_OPT_KEY2);
|
||||
/* verify OB area is unlocked */
|
||||
furi_check(READ_BIT(FLASH->CR, FLASH_CR_OPTLOCK) == 0U);
|
||||
}
|
||||
|
||||
void furi_hal_flash_ob_lock() {
|
||||
furi_check(READ_BIT(FLASH->CR, FLASH_CR_OPTLOCK) == 0U);
|
||||
SET_BIT(FLASH->CR, FLASH_CR_OPTLOCK);
|
||||
furi_hal_flash_end(true);
|
||||
furi_check(READ_BIT(FLASH->CR, FLASH_CR_OPTLOCK) != 0U);
|
||||
}
|
||||
|
||||
typedef enum {
|
||||
FuriHalFlashObInvalid,
|
||||
FuriHalFlashObRegisterUserRead,
|
||||
FuriHalFlashObRegisterPCROP1AStart,
|
||||
FuriHalFlashObRegisterPCROP1AEnd,
|
||||
FuriHalFlashObRegisterWRPA,
|
||||
FuriHalFlashObRegisterWRPB,
|
||||
FuriHalFlashObRegisterPCROP1BStart,
|
||||
FuriHalFlashObRegisterPCROP1BEnd,
|
||||
FuriHalFlashObRegisterIPCCMail,
|
||||
FuriHalFlashObRegisterSecureFlash,
|
||||
FuriHalFlashObRegisterC2Opts,
|
||||
} FuriHalFlashObRegister;
|
||||
|
||||
typedef struct {
|
||||
FuriHalFlashObRegister ob_reg;
|
||||
uint32_t* ob_register_address;
|
||||
} FuriHalFlashObMapping;
|
||||
|
||||
#define OB_REG_DEF(INDEX, REG) \
|
||||
{ .ob_reg = INDEX, .ob_register_address = (uint32_t*)(REG) }
|
||||
|
||||
static const FuriHalFlashObMapping furi_hal_flash_ob_reg_map[FURI_HAL_FLASH_OB_TOTAL_WORDS] = {
|
||||
OB_REG_DEF(FuriHalFlashObRegisterUserRead, (&FLASH->OPTR)),
|
||||
OB_REG_DEF(FuriHalFlashObRegisterPCROP1AStart, (&FLASH->PCROP1ASR)),
|
||||
OB_REG_DEF(FuriHalFlashObRegisterPCROP1AEnd, (&FLASH->PCROP1AER)),
|
||||
OB_REG_DEF(FuriHalFlashObRegisterWRPA, (&FLASH->WRP1AR)),
|
||||
OB_REG_DEF(FuriHalFlashObRegisterWRPB, (&FLASH->WRP1BR)),
|
||||
OB_REG_DEF(FuriHalFlashObRegisterPCROP1BStart, (&FLASH->PCROP1BSR)),
|
||||
OB_REG_DEF(FuriHalFlashObRegisterPCROP1BEnd, (&FLASH->PCROP1BER)),
|
||||
|
||||
OB_REG_DEF(FuriHalFlashObInvalid, (NULL)),
|
||||
OB_REG_DEF(FuriHalFlashObInvalid, (NULL)),
|
||||
OB_REG_DEF(FuriHalFlashObInvalid, (NULL)),
|
||||
OB_REG_DEF(FuriHalFlashObInvalid, (NULL)),
|
||||
OB_REG_DEF(FuriHalFlashObInvalid, (NULL)),
|
||||
OB_REG_DEF(FuriHalFlashObInvalid, (NULL)),
|
||||
|
||||
OB_REG_DEF(FuriHalFlashObRegisterIPCCMail, (&FLASH->IPCCBR)),
|
||||
OB_REG_DEF(FuriHalFlashObRegisterSecureFlash, (NULL)),
|
||||
OB_REG_DEF(FuriHalFlashObRegisterC2Opts, (NULL)),
|
||||
};
|
||||
#undef OB_REG_DEF
|
||||
|
||||
void furi_hal_flash_ob_apply() {
|
||||
furi_hal_flash_ob_unlock();
|
||||
/* OBL_LAUNCH: When set to 1, this bit forces the option byte reloading.
|
||||
* It cannot be written if OPTLOCK is set */
|
||||
SET_BIT(FLASH->CR, FLASH_CR_OBL_LAUNCH);
|
||||
furi_check(furi_hal_flash_wait_last_operation(FURI_HAL_FLASH_TIMEOUT));
|
||||
furi_hal_flash_ob_lock();
|
||||
}
|
||||
|
||||
bool furi_hal_flash_ob_set_word(size_t word_idx, const uint32_t value) {
|
||||
furi_check(word_idx < FURI_HAL_FLASH_OB_TOTAL_WORDS);
|
||||
|
||||
const FuriHalFlashObMapping* reg_def = &furi_hal_flash_ob_reg_map[word_idx];
|
||||
if(reg_def->ob_register_address == NULL) {
|
||||
FURI_LOG_E(TAG, "Attempt to set RO OB word %d", word_idx);
|
||||
return false;
|
||||
}
|
||||
|
||||
FURI_LOG_W(
|
||||
TAG,
|
||||
"Setting OB reg %d for word %d (addr 0x%08lX) to 0x%08lX",
|
||||
reg_def->ob_reg,
|
||||
word_idx,
|
||||
(uint32_t)reg_def->ob_register_address,
|
||||
value);
|
||||
|
||||
/* 1. Clear OPTLOCK option lock bit with the clearing sequence */
|
||||
furi_hal_flash_ob_unlock();
|
||||
|
||||
/* 2. Write the desired options value in the options registers */
|
||||
*reg_def->ob_register_address = value;
|
||||
|
||||
/* 3. Check that no Flash memory operation is on going by checking the BSY && PESD */
|
||||
furi_check(furi_hal_flash_wait_last_operation(FURI_HAL_FLASH_TIMEOUT));
|
||||
while(LL_FLASH_IsActiveFlag_OperationSuspended()) {
|
||||
furi_thread_yield();
|
||||
};
|
||||
|
||||
/* 4. Set the Options start bit OPTSTRT */
|
||||
SET_BIT(FLASH->CR, FLASH_CR_OPTSTRT);
|
||||
|
||||
/* 5. Wait for the BSY bit to be cleared. */
|
||||
furi_check(furi_hal_flash_wait_last_operation(FURI_HAL_FLASH_TIMEOUT));
|
||||
furi_hal_flash_ob_lock();
|
||||
return true;
|
||||
}
|
||||
|
||||
const FuriHalFlashRawOptionByteData* furi_hal_flash_ob_get_raw_ptr() {
|
||||
return (const FuriHalFlashRawOptionByteData*)OPTION_BYTE_BASE;
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define FURI_HAL_FLASH_OB_RAW_SIZE_BYTES 0x80
|
||||
#define FURI_HAL_FLASH_OB_SIZE_WORDS (FURI_HAL_FLASH_OB_RAW_SIZE_BYTES / sizeof(uint32_t))
|
||||
#define FURI_HAL_FLASH_OB_TOTAL_VALUES (FURI_HAL_FLASH_OB_SIZE_WORDS / 2)
|
||||
|
||||
typedef union {
|
||||
uint8_t bytes[FURI_HAL_FLASH_OB_RAW_SIZE_BYTES];
|
||||
union {
|
||||
struct {
|
||||
uint32_t base;
|
||||
uint32_t complementary_value;
|
||||
} values;
|
||||
uint64_t dword;
|
||||
} obs[FURI_HAL_FLASH_OB_TOTAL_VALUES];
|
||||
} FuriHalFlashRawOptionByteData;
|
||||
|
||||
_Static_assert(
|
||||
sizeof(FuriHalFlashRawOptionByteData) == FURI_HAL_FLASH_OB_RAW_SIZE_BYTES,
|
||||
"UpdateManifestOptionByteData size error");
|
||||
|
||||
/** Init flash, applying necessary workarounds
|
||||
*/
|
||||
void furi_hal_flash_init();
|
||||
|
||||
/** Get flash base address
|
||||
*
|
||||
* @return pointer to flash base
|
||||
*/
|
||||
size_t furi_hal_flash_get_base();
|
||||
|
||||
/** Get flash read block size
|
||||
*
|
||||
* @return size in bytes
|
||||
*/
|
||||
size_t furi_hal_flash_get_read_block_size();
|
||||
|
||||
/** Get flash write block size
|
||||
*
|
||||
* @return size in bytes
|
||||
*/
|
||||
size_t furi_hal_flash_get_write_block_size();
|
||||
|
||||
/** Get flash page size
|
||||
*
|
||||
* @return size in bytes
|
||||
*/
|
||||
size_t furi_hal_flash_get_page_size();
|
||||
|
||||
/** Get expected flash cycles count
|
||||
*
|
||||
* @return count of erase-write operations
|
||||
*/
|
||||
size_t furi_hal_flash_get_cycles_count();
|
||||
|
||||
/** Get free flash start address
|
||||
*
|
||||
* @return pointer to free region start
|
||||
*/
|
||||
const void* furi_hal_flash_get_free_start_address();
|
||||
|
||||
/** Get free flash end address
|
||||
*
|
||||
* @return pointer to free region end
|
||||
*/
|
||||
const void* furi_hal_flash_get_free_end_address();
|
||||
|
||||
/** Get first free page start address
|
||||
*
|
||||
* @return first free page memory address
|
||||
*/
|
||||
size_t furi_hal_flash_get_free_page_start_address();
|
||||
|
||||
/** Get free page count
|
||||
*
|
||||
* @return free page count
|
||||
*/
|
||||
size_t furi_hal_flash_get_free_page_count();
|
||||
|
||||
/** Erase Flash
|
||||
*
|
||||
* @warning locking operation with critical section, stalls execution
|
||||
*
|
||||
* @param page The page to erase
|
||||
*/
|
||||
void furi_hal_flash_erase(uint8_t page);
|
||||
|
||||
/** Write double word (64 bits)
|
||||
*
|
||||
* @warning locking operation with critical section, stalls execution
|
||||
*
|
||||
* @param address destination address, must be double word aligned.
|
||||
* @param data data to write
|
||||
*/
|
||||
void furi_hal_flash_write_dword(size_t address, uint64_t data);
|
||||
|
||||
/** Write aligned page data (up to page size)
|
||||
*
|
||||
* @warning locking operation with critical section, stalls execution
|
||||
*
|
||||
* @param address destination address, must be page aligned.
|
||||
* @param data data to write
|
||||
* @param length data length
|
||||
*/
|
||||
void furi_hal_flash_program_page(const uint8_t page, const uint8_t* data, uint16_t length);
|
||||
|
||||
/** Get flash page number for address
|
||||
*
|
||||
* @return page number, -1 for invalid address
|
||||
*/
|
||||
int16_t furi_hal_flash_get_page_number(size_t address);
|
||||
|
||||
/** Writes OB word, using non-compl. index of register in Flash, OPTION_BYTE_BASE
|
||||
*
|
||||
* @warning locking operation with critical section, stalls execution
|
||||
*
|
||||
* @param word_idx OB word number
|
||||
* @param value data to write
|
||||
* @return true if value was written, false for read-only word
|
||||
*/
|
||||
bool furi_hal_flash_ob_set_word(size_t word_idx, const uint32_t value);
|
||||
|
||||
/** Forces a reload of OB data from flash to registers
|
||||
*
|
||||
* @warning Initializes system restart
|
||||
*
|
||||
*/
|
||||
void furi_hal_flash_ob_apply();
|
||||
|
||||
/** Get raw OB storage data
|
||||
*
|
||||
* @return pointer to read-only data of OB (raw + complementary values)
|
||||
*/
|
||||
const FuriHalFlashRawOptionByteData* furi_hal_flash_ob_get_raw_ptr();
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,309 @@
|
||||
#include <furi.h>
|
||||
#include <furi_hal_gpio.h>
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <stm32wbxx_ll_comp.h>
|
||||
|
||||
#define GET_SYSCFG_EXTI_PORT(gpio) \
|
||||
(((gpio) == (GPIOA)) ? LL_SYSCFG_EXTI_PORTA : \
|
||||
((gpio) == (GPIOB)) ? LL_SYSCFG_EXTI_PORTB : \
|
||||
((gpio) == (GPIOC)) ? LL_SYSCFG_EXTI_PORTC : \
|
||||
((gpio) == (GPIOD)) ? LL_SYSCFG_EXTI_PORTD : \
|
||||
((gpio) == (GPIOE)) ? LL_SYSCFG_EXTI_PORTE : \
|
||||
LL_SYSCFG_EXTI_PORTH)
|
||||
|
||||
#define GPIO_PIN_MAP(pin, prefix) \
|
||||
(((pin) == (LL_GPIO_PIN_0)) ? prefix##0 : \
|
||||
((pin) == (LL_GPIO_PIN_1)) ? prefix##1 : \
|
||||
((pin) == (LL_GPIO_PIN_2)) ? prefix##2 : \
|
||||
((pin) == (LL_GPIO_PIN_3)) ? prefix##3 : \
|
||||
((pin) == (LL_GPIO_PIN_4)) ? prefix##4 : \
|
||||
((pin) == (LL_GPIO_PIN_5)) ? prefix##5 : \
|
||||
((pin) == (LL_GPIO_PIN_6)) ? prefix##6 : \
|
||||
((pin) == (LL_GPIO_PIN_7)) ? prefix##7 : \
|
||||
((pin) == (LL_GPIO_PIN_8)) ? prefix##8 : \
|
||||
((pin) == (LL_GPIO_PIN_9)) ? prefix##9 : \
|
||||
((pin) == (LL_GPIO_PIN_10)) ? prefix##10 : \
|
||||
((pin) == (LL_GPIO_PIN_11)) ? prefix##11 : \
|
||||
((pin) == (LL_GPIO_PIN_12)) ? prefix##12 : \
|
||||
((pin) == (LL_GPIO_PIN_13)) ? prefix##13 : \
|
||||
((pin) == (LL_GPIO_PIN_14)) ? prefix##14 : \
|
||||
prefix##15)
|
||||
|
||||
#define GET_SYSCFG_EXTI_LINE(pin) GPIO_PIN_MAP(pin, LL_SYSCFG_EXTI_LINE)
|
||||
#define GET_EXTI_LINE(pin) GPIO_PIN_MAP(pin, LL_EXTI_LINE_)
|
||||
|
||||
static volatile GpioInterrupt gpio_interrupt[GPIO_NUMBER];
|
||||
|
||||
static uint8_t furi_hal_gpio_get_pin_num(const GpioPin* gpio) {
|
||||
uint8_t pin_num = 0;
|
||||
for(pin_num = 0; pin_num < GPIO_NUMBER; pin_num++) {
|
||||
if(gpio->pin & (1 << pin_num)) break;
|
||||
}
|
||||
return pin_num;
|
||||
}
|
||||
|
||||
void furi_hal_gpio_init_simple(const GpioPin* gpio, const GpioMode mode) {
|
||||
furi_hal_gpio_init(gpio, mode, GpioPullNo, GpioSpeedLow);
|
||||
}
|
||||
|
||||
void furi_hal_gpio_init(
|
||||
const GpioPin* gpio,
|
||||
const GpioMode mode,
|
||||
const GpioPull pull,
|
||||
const GpioSpeed speed) {
|
||||
// we cannot set alternate mode in this function
|
||||
furi_check(mode != GpioModeAltFunctionPushPull);
|
||||
furi_check(mode != GpioModeAltFunctionOpenDrain);
|
||||
|
||||
furi_hal_gpio_init_ex(gpio, mode, pull, speed, GpioAltFnUnused);
|
||||
}
|
||||
|
||||
void furi_hal_gpio_init_ex(
|
||||
const GpioPin* gpio,
|
||||
const GpioMode mode,
|
||||
const GpioPull pull,
|
||||
const GpioSpeed speed,
|
||||
const GpioAltFn alt_fn) {
|
||||
uint32_t sys_exti_port = GET_SYSCFG_EXTI_PORT(gpio->port);
|
||||
uint32_t sys_exti_line = GET_SYSCFG_EXTI_LINE(gpio->pin);
|
||||
uint32_t exti_line = GET_EXTI_LINE(gpio->pin);
|
||||
|
||||
// Configure gpio with interrupts disabled
|
||||
FURI_CRITICAL_ENTER();
|
||||
|
||||
// Set gpio speed
|
||||
switch(speed) {
|
||||
case GpioSpeedLow:
|
||||
LL_GPIO_SetPinSpeed(gpio->port, gpio->pin, LL_GPIO_SPEED_FREQ_LOW);
|
||||
break;
|
||||
case GpioSpeedMedium:
|
||||
LL_GPIO_SetPinSpeed(gpio->port, gpio->pin, LL_GPIO_SPEED_FREQ_MEDIUM);
|
||||
break;
|
||||
case GpioSpeedHigh:
|
||||
LL_GPIO_SetPinSpeed(gpio->port, gpio->pin, LL_GPIO_SPEED_FREQ_HIGH);
|
||||
break;
|
||||
case GpioSpeedVeryHigh:
|
||||
LL_GPIO_SetPinSpeed(gpio->port, gpio->pin, LL_GPIO_SPEED_FREQ_VERY_HIGH);
|
||||
break;
|
||||
}
|
||||
|
||||
// Set gpio pull mode
|
||||
switch(pull) {
|
||||
case GpioPullNo:
|
||||
LL_GPIO_SetPinPull(gpio->port, gpio->pin, LL_GPIO_PULL_NO);
|
||||
break;
|
||||
case GpioPullUp:
|
||||
LL_GPIO_SetPinPull(gpio->port, gpio->pin, LL_GPIO_PULL_UP);
|
||||
break;
|
||||
case GpioPullDown:
|
||||
LL_GPIO_SetPinPull(gpio->port, gpio->pin, LL_GPIO_PULL_DOWN);
|
||||
break;
|
||||
}
|
||||
|
||||
// Set gpio mode
|
||||
if(mode >= GpioModeInterruptRise) {
|
||||
// Set pin in interrupt mode
|
||||
LL_GPIO_SetPinMode(gpio->port, gpio->pin, LL_GPIO_MODE_INPUT);
|
||||
LL_SYSCFG_SetEXTISource(sys_exti_port, sys_exti_line);
|
||||
if(mode == GpioModeInterruptRise || mode == GpioModeInterruptRiseFall) {
|
||||
LL_EXTI_EnableIT_0_31(exti_line);
|
||||
LL_EXTI_EnableRisingTrig_0_31(exti_line);
|
||||
}
|
||||
if(mode == GpioModeInterruptFall || mode == GpioModeInterruptRiseFall) {
|
||||
LL_EXTI_EnableIT_0_31(exti_line);
|
||||
LL_EXTI_EnableFallingTrig_0_31(exti_line);
|
||||
}
|
||||
if(mode == GpioModeEventRise || mode == GpioModeEventRiseFall) {
|
||||
LL_EXTI_EnableEvent_0_31(exti_line);
|
||||
LL_EXTI_EnableRisingTrig_0_31(exti_line);
|
||||
}
|
||||
if(mode == GpioModeEventFall || mode == GpioModeEventRiseFall) {
|
||||
LL_EXTI_EnableEvent_0_31(exti_line);
|
||||
LL_EXTI_EnableFallingTrig_0_31(exti_line);
|
||||
}
|
||||
} else {
|
||||
// Disable interrupts if set
|
||||
if(LL_SYSCFG_GetEXTISource(sys_exti_line) == sys_exti_port &&
|
||||
LL_EXTI_IsEnabledIT_0_31(exti_line)) {
|
||||
LL_EXTI_DisableIT_0_31(exti_line);
|
||||
LL_EXTI_DisableRisingTrig_0_31(exti_line);
|
||||
LL_EXTI_DisableFallingTrig_0_31(exti_line);
|
||||
}
|
||||
|
||||
// Prepare alternative part if any
|
||||
if(mode == GpioModeAltFunctionPushPull || mode == GpioModeAltFunctionOpenDrain) {
|
||||
// set alternate function
|
||||
if(furi_hal_gpio_get_pin_num(gpio) < 8) {
|
||||
LL_GPIO_SetAFPin_0_7(gpio->port, gpio->pin, alt_fn);
|
||||
} else {
|
||||
LL_GPIO_SetAFPin_8_15(gpio->port, gpio->pin, alt_fn);
|
||||
}
|
||||
}
|
||||
|
||||
// Set not interrupt pin modes
|
||||
switch(mode) {
|
||||
case GpioModeInput:
|
||||
LL_GPIO_SetPinMode(gpio->port, gpio->pin, LL_GPIO_MODE_INPUT);
|
||||
break;
|
||||
case GpioModeOutputPushPull:
|
||||
LL_GPIO_SetPinOutputType(gpio->port, gpio->pin, LL_GPIO_OUTPUT_PUSHPULL);
|
||||
LL_GPIO_SetPinMode(gpio->port, gpio->pin, LL_GPIO_MODE_OUTPUT);
|
||||
break;
|
||||
case GpioModeAltFunctionPushPull:
|
||||
LL_GPIO_SetPinOutputType(gpio->port, gpio->pin, LL_GPIO_OUTPUT_PUSHPULL);
|
||||
LL_GPIO_SetPinMode(gpio->port, gpio->pin, LL_GPIO_MODE_ALTERNATE);
|
||||
break;
|
||||
case GpioModeOutputOpenDrain:
|
||||
LL_GPIO_SetPinOutputType(gpio->port, gpio->pin, LL_GPIO_OUTPUT_OPENDRAIN);
|
||||
LL_GPIO_SetPinMode(gpio->port, gpio->pin, LL_GPIO_MODE_OUTPUT);
|
||||
break;
|
||||
case GpioModeAltFunctionOpenDrain:
|
||||
LL_GPIO_SetPinOutputType(gpio->port, gpio->pin, LL_GPIO_OUTPUT_OPENDRAIN);
|
||||
LL_GPIO_SetPinMode(gpio->port, gpio->pin, LL_GPIO_MODE_ALTERNATE);
|
||||
break;
|
||||
case GpioModeAnalog:
|
||||
LL_GPIO_SetPinMode(gpio->port, gpio->pin, LL_GPIO_MODE_ANALOG);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_gpio_add_int_callback(const GpioPin* gpio, GpioExtiCallback cb, void* ctx) {
|
||||
furi_assert(gpio);
|
||||
furi_assert(cb);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
uint8_t pin_num = furi_hal_gpio_get_pin_num(gpio);
|
||||
furi_check(gpio_interrupt[pin_num].callback == NULL);
|
||||
gpio_interrupt[pin_num].callback = cb;
|
||||
gpio_interrupt[pin_num].context = ctx;
|
||||
gpio_interrupt[pin_num].ready = true;
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_gpio_enable_int_callback(const GpioPin* gpio) {
|
||||
furi_assert(gpio);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
uint8_t pin_num = furi_hal_gpio_get_pin_num(gpio);
|
||||
if(gpio_interrupt[pin_num].callback) {
|
||||
gpio_interrupt[pin_num].ready = true;
|
||||
}
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_gpio_disable_int_callback(const GpioPin* gpio) {
|
||||
furi_assert(gpio);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
uint8_t pin_num = furi_hal_gpio_get_pin_num(gpio);
|
||||
gpio_interrupt[pin_num].ready = false;
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_gpio_remove_int_callback(const GpioPin* gpio) {
|
||||
furi_assert(gpio);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
uint8_t pin_num = furi_hal_gpio_get_pin_num(gpio);
|
||||
gpio_interrupt[pin_num].callback = NULL;
|
||||
gpio_interrupt[pin_num].context = NULL;
|
||||
gpio_interrupt[pin_num].ready = false;
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
static void furi_hal_gpio_int_call(uint16_t pin_num) {
|
||||
if(gpio_interrupt[pin_num].callback && gpio_interrupt[pin_num].ready) {
|
||||
gpio_interrupt[pin_num].callback(gpio_interrupt[pin_num].context);
|
||||
}
|
||||
}
|
||||
|
||||
/* Interrupt handlers */
|
||||
void EXTI0_IRQHandler(void) {
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_0)) {
|
||||
furi_hal_gpio_int_call(0);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_0);
|
||||
}
|
||||
}
|
||||
|
||||
void EXTI1_IRQHandler(void) {
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_1)) {
|
||||
furi_hal_gpio_int_call(1);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_1);
|
||||
}
|
||||
}
|
||||
|
||||
void EXTI2_IRQHandler(void) {
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_2)) {
|
||||
furi_hal_gpio_int_call(2);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_2);
|
||||
}
|
||||
}
|
||||
|
||||
void EXTI3_IRQHandler(void) {
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_3)) {
|
||||
furi_hal_gpio_int_call(3);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_3);
|
||||
}
|
||||
}
|
||||
|
||||
void EXTI4_IRQHandler(void) {
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_4)) {
|
||||
furi_hal_gpio_int_call(4);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_4);
|
||||
}
|
||||
}
|
||||
|
||||
void EXTI9_5_IRQHandler(void) {
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_5)) {
|
||||
furi_hal_gpio_int_call(5);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_5);
|
||||
}
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_6)) {
|
||||
furi_hal_gpio_int_call(6);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_6);
|
||||
}
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_7)) {
|
||||
furi_hal_gpio_int_call(7);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_7);
|
||||
}
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_8)) {
|
||||
furi_hal_gpio_int_call(8);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_8);
|
||||
}
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_9)) {
|
||||
furi_hal_gpio_int_call(9);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_9);
|
||||
}
|
||||
}
|
||||
|
||||
void EXTI15_10_IRQHandler(void) {
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_10)) {
|
||||
furi_hal_gpio_int_call(10);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_10);
|
||||
}
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_11)) {
|
||||
furi_hal_gpio_int_call(11);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_11);
|
||||
}
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_12)) {
|
||||
furi_hal_gpio_int_call(12);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_12);
|
||||
}
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_13)) {
|
||||
furi_hal_gpio_int_call(13);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_13);
|
||||
}
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_14)) {
|
||||
furi_hal_gpio_int_call(14);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_14);
|
||||
}
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_15)) {
|
||||
furi_hal_gpio_int_call(15);
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_15);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,287 @@
|
||||
#pragma once
|
||||
#include "stdbool.h"
|
||||
#include <stm32wbxx_ll_gpio.h>
|
||||
#include <stm32wbxx_ll_system.h>
|
||||
#include <stm32wbxx_ll_exti.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Number of gpio on one port
|
||||
*/
|
||||
#define GPIO_NUMBER (16U)
|
||||
|
||||
/**
|
||||
* Interrupt callback prototype
|
||||
*/
|
||||
typedef void (*GpioExtiCallback)(void* ctx);
|
||||
|
||||
/**
|
||||
* Gpio interrupt type
|
||||
*/
|
||||
typedef struct {
|
||||
GpioExtiCallback callback;
|
||||
void* context;
|
||||
volatile bool ready;
|
||||
} GpioInterrupt;
|
||||
|
||||
/**
|
||||
* Gpio modes
|
||||
*/
|
||||
typedef enum {
|
||||
GpioModeInput,
|
||||
GpioModeOutputPushPull,
|
||||
GpioModeOutputOpenDrain,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioModeAltFunctionOpenDrain,
|
||||
GpioModeAnalog,
|
||||
GpioModeInterruptRise,
|
||||
GpioModeInterruptFall,
|
||||
GpioModeInterruptRiseFall,
|
||||
GpioModeEventRise,
|
||||
GpioModeEventFall,
|
||||
GpioModeEventRiseFall,
|
||||
} GpioMode;
|
||||
|
||||
/**
|
||||
* Gpio pull modes
|
||||
*/
|
||||
typedef enum {
|
||||
GpioPullNo,
|
||||
GpioPullUp,
|
||||
GpioPullDown,
|
||||
} GpioPull;
|
||||
|
||||
/**
|
||||
* Gpio speed modes
|
||||
*/
|
||||
typedef enum {
|
||||
GpioSpeedLow,
|
||||
GpioSpeedMedium,
|
||||
GpioSpeedHigh,
|
||||
GpioSpeedVeryHigh,
|
||||
} GpioSpeed;
|
||||
|
||||
/**
|
||||
* Gpio alternate functions
|
||||
*/
|
||||
typedef enum {
|
||||
GpioAltFn0MCO = 0, /*!< MCO Alternate Function mapping */
|
||||
GpioAltFn0LSCO = 0, /*!< LSCO Alternate Function mapping */
|
||||
GpioAltFn0JTMS_SWDIO = 0, /*!< JTMS-SWDIO Alternate Function mapping */
|
||||
GpioAltFn0JTCK_SWCLK = 0, /*!< JTCK-SWCLK Alternate Function mapping */
|
||||
GpioAltFn0JTDI = 0, /*!< JTDI Alternate Function mapping */
|
||||
GpioAltFn0RTC_OUT = 0, /*!< RCT_OUT Alternate Function mapping */
|
||||
GpioAltFn0JTD_TRACE = 0, /*!< JTDO-TRACESWO Alternate Function mapping */
|
||||
GpioAltFn0NJTRST = 0, /*!< NJTRST Alternate Function mapping */
|
||||
GpioAltFn0RTC_REFIN = 0, /*!< RTC_REFIN Alternate Function mapping */
|
||||
GpioAltFn0TRACED0 = 0, /*!< TRACED0 Alternate Function mapping */
|
||||
GpioAltFn0TRACED1 = 0, /*!< TRACED1 Alternate Function mapping */
|
||||
GpioAltFn0TRACED2 = 0, /*!< TRACED2 Alternate Function mapping */
|
||||
GpioAltFn0TRACED3 = 0, /*!< TRACED3 Alternate Function mapping */
|
||||
GpioAltFn0TRIG_INOUT = 0, /*!< TRIG_INOUT Alternate Function mapping */
|
||||
GpioAltFn0TRACECK = 0, /*!< TRACECK Alternate Function mapping */
|
||||
GpioAltFn0SYS = 0, /*!< System Function mapping */
|
||||
|
||||
GpioAltFn1TIM1 = 1, /*!< TIM1 Alternate Function mapping */
|
||||
GpioAltFn1TIM2 = 1, /*!< TIM2 Alternate Function mapping */
|
||||
GpioAltFn1LPTIM1 = 1, /*!< LPTIM1 Alternate Function mapping */
|
||||
|
||||
GpioAltFn2TIM2 = 2, /*!< TIM2 Alternate Function mapping */
|
||||
GpioAltFn2TIM1 = 2, /*!< TIM1 Alternate Function mapping */
|
||||
|
||||
GpioAltFn3SAI1 = 3, /*!< SAI1_CK1 Alternate Function mapping */
|
||||
GpioAltFn3SPI2 = 3, /*!< SPI2 Alternate Function mapping */
|
||||
GpioAltFn3TIM1 = 3, /*!< TIM1 Alternate Function mapping */
|
||||
|
||||
GpioAltFn4I2C1 = 4, /*!< I2C1 Alternate Function mapping */
|
||||
GpioAltFn4I2C3 = 4, /*!< I2C3 Alternate Function mapping */
|
||||
|
||||
GpioAltFn5SPI1 = 5, /*!< SPI1 Alternate Function mapping */
|
||||
GpioAltFn5SPI2 = 5, /*!< SPI2 Alternate Function mapping */
|
||||
|
||||
GpioAltFn6MCO = 6, /*!< MCO Alternate Function mapping */
|
||||
GpioAltFn6LSCO = 6, /*!< LSCO Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB0 = 6, /*!< RF_DTB0 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB1 = 6, /*!< RF_DTB1 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB2 = 6, /*!< RF_DTB2 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB3 = 6, /*!< RF_DTB3 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB4 = 6, /*!< RF_DTB4 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB5 = 6, /*!< RF_DTB5 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB6 = 6, /*!< RF_DTB6 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB7 = 6, /*!< RF_DTB7 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB8 = 6, /*!< RF_DTB8 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB9 = 6, /*!< RF_DTB9 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB10 = 6, /*!< RF_DTB10 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB11 = 6, /*!< RF_DTB11 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB12 = 6, /*!< RF_DTB12 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB13 = 6, /*!< RF_DTB13 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB14 = 6, /*!< RF_DTB14 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB15 = 6, /*!< RF_DTB15 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB16 = 6, /*!< RF_DTB16 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB17 = 6, /*!< RF_DTB17 Alternate Function mapping */
|
||||
GpioAltFn6RF_DTB18 = 6, /*!< RF_DTB18 Alternate Function mapping */
|
||||
GpioAltFn6RF_MISO = 6, /*!< RF_MISO Alternate Function mapping */
|
||||
GpioAltFn6RF_MOSI = 6, /*!< RF_MOSI Alternate Function mapping */
|
||||
GpioAltFn6RF_SCK = 6, /*!< RF_SCK Alternate Function mapping */
|
||||
GpioAltFn6RF_NSS = 6, /*!< RF_NSS Alternate Function mapping */
|
||||
|
||||
GpioAltFn7USART1 = 7, /*!< USART1 Alternate Function mapping */
|
||||
|
||||
GpioAltFn8LPUART1 = 8, /*!< LPUART1 Alternate Function mapping */
|
||||
GpioAltFn8IR = 8, /*!< IR Alternate Function mapping */
|
||||
|
||||
GpioAltFn9TSC = 9, /*!< TSC Alternate Function mapping */
|
||||
|
||||
GpioAltFn10QUADSPI = 10, /*!< QUADSPI Alternate Function mapping */
|
||||
GpioAltFn10USB = 10, /*!< USB Alternate Function mapping */
|
||||
|
||||
GpioAltFn11LCD = 11, /*!< LCD Alternate Function mapping */
|
||||
|
||||
GpioAltFn12COMP1 = 12, /*!< COMP1 Alternate Function mapping */
|
||||
GpioAltFn12COMP2 = 12, /*!< COMP2 Alternate Function mapping */
|
||||
GpioAltFn12TIM1 = 12, /*!< TIM1 Alternate Function mapping */
|
||||
|
||||
GpioAltFn13SAI1 = 13, /*!< SAI1 Alternate Function mapping */
|
||||
|
||||
GpioAltFn14TIM2 = 14, /*!< TIM2 Alternate Function mapping */
|
||||
GpioAltFn14TIM16 = 14, /*!< TIM16 Alternate Function mapping */
|
||||
GpioAltFn14TIM17 = 14, /*!< TIM17 Alternate Function mapping */
|
||||
GpioAltFn14LPTIM2 = 14, /*!< LPTIM2 Alternate Function mapping */
|
||||
|
||||
GpioAltFn15EVENTOUT = 15, /*!< EVENTOUT Alternate Function mapping */
|
||||
|
||||
GpioAltFnUnused = 16, /*!< just dummy value */
|
||||
} GpioAltFn;
|
||||
|
||||
/**
|
||||
* Gpio structure
|
||||
*/
|
||||
typedef struct {
|
||||
GPIO_TypeDef* port;
|
||||
uint16_t pin;
|
||||
} GpioPin;
|
||||
|
||||
/**
|
||||
* GPIO initialization function, simple version
|
||||
* @param gpio GpioPin
|
||||
* @param mode GpioMode
|
||||
*/
|
||||
void furi_hal_gpio_init_simple(const GpioPin* gpio, const GpioMode mode);
|
||||
|
||||
/**
|
||||
* GPIO initialization function, normal version
|
||||
* @param gpio GpioPin
|
||||
* @param mode GpioMode
|
||||
* @param pull GpioPull
|
||||
* @param speed GpioSpeed
|
||||
*/
|
||||
void furi_hal_gpio_init(
|
||||
const GpioPin* gpio,
|
||||
const GpioMode mode,
|
||||
const GpioPull pull,
|
||||
const GpioSpeed speed);
|
||||
|
||||
/**
|
||||
* GPIO initialization function, extended version
|
||||
* @param gpio GpioPin
|
||||
* @param mode GpioMode
|
||||
* @param pull GpioPull
|
||||
* @param speed GpioSpeed
|
||||
* @param alt_fn GpioAltFn
|
||||
*/
|
||||
void furi_hal_gpio_init_ex(
|
||||
const GpioPin* gpio,
|
||||
const GpioMode mode,
|
||||
const GpioPull pull,
|
||||
const GpioSpeed speed,
|
||||
const GpioAltFn alt_fn);
|
||||
|
||||
/**
|
||||
* Add and enable interrupt
|
||||
* @param gpio GpioPin
|
||||
* @param cb GpioExtiCallback
|
||||
* @param ctx context for callback
|
||||
*/
|
||||
void furi_hal_gpio_add_int_callback(const GpioPin* gpio, GpioExtiCallback cb, void* ctx);
|
||||
|
||||
/**
|
||||
* Enable interrupt
|
||||
* @param gpio GpioPin
|
||||
*/
|
||||
void furi_hal_gpio_enable_int_callback(const GpioPin* gpio);
|
||||
|
||||
/**
|
||||
* Disable interrupt
|
||||
* @param gpio GpioPin
|
||||
*/
|
||||
void furi_hal_gpio_disable_int_callback(const GpioPin* gpio);
|
||||
|
||||
/**
|
||||
* Remove interrupt
|
||||
* @param gpio GpioPin
|
||||
*/
|
||||
void furi_hal_gpio_remove_int_callback(const GpioPin* gpio);
|
||||
|
||||
/**
|
||||
* GPIO write pin
|
||||
* @param gpio GpioPin
|
||||
* @param state true / false
|
||||
*/
|
||||
static inline void furi_hal_gpio_write(const GpioPin* gpio, const bool state) {
|
||||
// writing to BSSR is an atomic operation
|
||||
if(state == true) {
|
||||
gpio->port->BSRR = gpio->pin;
|
||||
} else {
|
||||
gpio->port->BSRR = (uint32_t)gpio->pin << GPIO_NUMBER;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* GPIO read pin
|
||||
* @param port GPIO port
|
||||
* @param pin pin mask
|
||||
* @return true / false
|
||||
*/
|
||||
static inline void
|
||||
furi_hal_gpio_write_port_pin(GPIO_TypeDef* port, uint16_t pin, const bool state) {
|
||||
// writing to BSSR is an atomic operation
|
||||
if(state == true) {
|
||||
port->BSRR = pin;
|
||||
} else {
|
||||
port->BSRR = pin << GPIO_NUMBER;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* GPIO read pin
|
||||
* @param gpio GpioPin
|
||||
* @return true / false
|
||||
*/
|
||||
static inline bool furi_hal_gpio_read(const GpioPin* gpio) {
|
||||
if((gpio->port->IDR & gpio->pin) != 0x00U) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* GPIO read pin
|
||||
* @param port GPIO port
|
||||
* @param pin pin mask
|
||||
* @return true / false
|
||||
*/
|
||||
static inline bool furi_hal_gpio_read_port_pin(GPIO_TypeDef* port, uint16_t pin) {
|
||||
if((port->IDR & pin) != 0x00U) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,416 @@
|
||||
#include <furi_hal_i2c.h>
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_power.h>
|
||||
#include <furi_hal_cortex.h>
|
||||
|
||||
#include <stm32wbxx_ll_i2c.h>
|
||||
#include <stm32wbxx_ll_gpio.h>
|
||||
#include <furi.h>
|
||||
|
||||
#define TAG "FuriHalI2c"
|
||||
|
||||
void furi_hal_i2c_init_early() {
|
||||
furi_hal_i2c_bus_power.callback(&furi_hal_i2c_bus_power, FuriHalI2cBusEventInit);
|
||||
}
|
||||
|
||||
void furi_hal_i2c_deinit_early() {
|
||||
furi_hal_i2c_bus_power.callback(&furi_hal_i2c_bus_power, FuriHalI2cBusEventDeinit);
|
||||
}
|
||||
|
||||
void furi_hal_i2c_init() {
|
||||
furi_hal_i2c_bus_external.callback(&furi_hal_i2c_bus_external, FuriHalI2cBusEventInit);
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
void furi_hal_i2c_acquire(FuriHalI2cBusHandle* handle) {
|
||||
furi_hal_power_insomnia_enter();
|
||||
// Lock bus access
|
||||
handle->bus->callback(handle->bus, FuriHalI2cBusEventLock);
|
||||
// Ensure that no active handle set
|
||||
furi_check(handle->bus->current_handle == NULL);
|
||||
// Set current handle
|
||||
handle->bus->current_handle = handle;
|
||||
// Activate bus
|
||||
handle->bus->callback(handle->bus, FuriHalI2cBusEventActivate);
|
||||
// Activate handle
|
||||
handle->callback(handle, FuriHalI2cBusHandleEventActivate);
|
||||
}
|
||||
|
||||
void furi_hal_i2c_release(FuriHalI2cBusHandle* handle) {
|
||||
// Ensure that current handle is our handle
|
||||
furi_check(handle->bus->current_handle == handle);
|
||||
// Deactivate handle
|
||||
handle->callback(handle, FuriHalI2cBusHandleEventDeactivate);
|
||||
// Deactivate bus
|
||||
handle->bus->callback(handle->bus, FuriHalI2cBusEventDeactivate);
|
||||
// Reset current handle
|
||||
handle->bus->current_handle = NULL;
|
||||
// Unlock bus
|
||||
handle->bus->callback(handle->bus, FuriHalI2cBusEventUnlock);
|
||||
furi_hal_power_insomnia_exit();
|
||||
}
|
||||
|
||||
static bool
|
||||
furi_hal_i2c_wait_for_idle(I2C_TypeDef* i2c, FuriHalI2cBegin begin, FuriHalCortexTimer timer) {
|
||||
do {
|
||||
if(furi_hal_cortex_timer_is_expired(timer)) {
|
||||
return false;
|
||||
}
|
||||
} while(begin == FuriHalI2cBeginStart && LL_I2C_IsActiveFlag_BUSY(i2c));
|
||||
// Only check if the bus is busy if starting a new transaction, if not we already control the bus
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
furi_hal_i2c_wait_for_end(I2C_TypeDef* i2c, FuriHalI2cEnd end, FuriHalCortexTimer timer) {
|
||||
// If ending the transaction with a stop condition, wait for it to be detected, otherwise wait for a transfer complete flag
|
||||
bool wait_for_stop = end == FuriHalI2cEndStop;
|
||||
uint32_t end_mask = (wait_for_stop) ? I2C_ISR_STOPF : (I2C_ISR_TC | I2C_ISR_TCR);
|
||||
|
||||
while((i2c->ISR & end_mask) == 0) {
|
||||
if(furi_hal_cortex_timer_is_expired(timer)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static uint32_t
|
||||
furi_hal_i2c_get_start_signal(FuriHalI2cBegin begin, bool ten_bit_address, bool read) {
|
||||
switch(begin) {
|
||||
case FuriHalI2cBeginRestart:
|
||||
if(read) {
|
||||
return ten_bit_address ? LL_I2C_GENERATE_RESTART_10BIT_READ :
|
||||
LL_I2C_GENERATE_RESTART_7BIT_READ;
|
||||
} else {
|
||||
return ten_bit_address ? LL_I2C_GENERATE_RESTART_10BIT_WRITE :
|
||||
LL_I2C_GENERATE_RESTART_7BIT_WRITE;
|
||||
}
|
||||
case FuriHalI2cBeginResume:
|
||||
return LL_I2C_GENERATE_NOSTARTSTOP;
|
||||
case FuriHalI2cBeginStart:
|
||||
default:
|
||||
return read ? LL_I2C_GENERATE_START_READ : LL_I2C_GENERATE_START_WRITE;
|
||||
}
|
||||
}
|
||||
|
||||
static uint32_t furi_hal_i2c_get_end_signal(FuriHalI2cEnd end) {
|
||||
switch(end) {
|
||||
case FuriHalI2cEndAwaitRestart:
|
||||
return LL_I2C_MODE_SOFTEND;
|
||||
case FuriHalI2cEndPause:
|
||||
return LL_I2C_MODE_RELOAD;
|
||||
case FuriHalI2cEndStop:
|
||||
default:
|
||||
return LL_I2C_MODE_AUTOEND;
|
||||
}
|
||||
}
|
||||
|
||||
static bool furi_hal_i2c_transfer_is_aborted(I2C_TypeDef* i2c) {
|
||||
return LL_I2C_IsActiveFlag_STOP(i2c) &&
|
||||
!(LL_I2C_IsActiveFlag_TC(i2c) || LL_I2C_IsActiveFlag_TCR(i2c));
|
||||
}
|
||||
|
||||
static bool furi_hal_i2c_transfer(
|
||||
I2C_TypeDef* i2c,
|
||||
uint8_t* data,
|
||||
uint32_t size,
|
||||
FuriHalI2cEnd end,
|
||||
bool read,
|
||||
FuriHalCortexTimer timer) {
|
||||
bool ret = true;
|
||||
|
||||
while(size > 0) {
|
||||
bool should_stop = furi_hal_cortex_timer_is_expired(timer) ||
|
||||
furi_hal_i2c_transfer_is_aborted(i2c);
|
||||
|
||||
// Modifying the data pointer's data is UB if read is true
|
||||
if(read && LL_I2C_IsActiveFlag_RXNE(i2c)) {
|
||||
*data = LL_I2C_ReceiveData8(i2c);
|
||||
data++;
|
||||
size--;
|
||||
} else if(!read && LL_I2C_IsActiveFlag_TXIS(i2c)) {
|
||||
LL_I2C_TransmitData8(i2c, *data);
|
||||
data++;
|
||||
size--;
|
||||
}
|
||||
|
||||
// Exit on timeout or premature stop, probably caused by a nacked address or byte
|
||||
if(should_stop) {
|
||||
ret = size == 0; // If the transfer was over, still a success
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(ret) {
|
||||
ret = furi_hal_i2c_wait_for_end(i2c, end, timer);
|
||||
}
|
||||
|
||||
LL_I2C_ClearFlag_STOP(i2c);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool furi_hal_i2c_transaction(
|
||||
I2C_TypeDef* i2c,
|
||||
uint16_t address,
|
||||
bool ten_bit,
|
||||
uint8_t* data,
|
||||
size_t size,
|
||||
FuriHalI2cBegin begin,
|
||||
FuriHalI2cEnd end,
|
||||
bool read,
|
||||
FuriHalCortexTimer timer) {
|
||||
uint32_t addr_size = ten_bit ? LL_I2C_ADDRSLAVE_10BIT : LL_I2C_ADDRSLAVE_7BIT;
|
||||
uint32_t start_signal = furi_hal_i2c_get_start_signal(begin, ten_bit, read);
|
||||
|
||||
if(!furi_hal_i2c_wait_for_idle(i2c, begin, timer)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
do {
|
||||
uint8_t transfer_size = size;
|
||||
FuriHalI2cEnd transfer_end = end;
|
||||
|
||||
if(size > 255) {
|
||||
transfer_size = 255;
|
||||
transfer_end = FuriHalI2cEndPause;
|
||||
}
|
||||
|
||||
uint32_t end_signal = furi_hal_i2c_get_end_signal(transfer_end);
|
||||
|
||||
LL_I2C_HandleTransfer(i2c, address, addr_size, transfer_size, end_signal, start_signal);
|
||||
|
||||
if(!furi_hal_i2c_transfer(i2c, data, transfer_size, transfer_end, read, timer)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
size -= transfer_size;
|
||||
data += transfer_size;
|
||||
start_signal = LL_I2C_GENERATE_NOSTARTSTOP;
|
||||
} while(size > 0);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_rx_ext(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint16_t address,
|
||||
bool ten_bit,
|
||||
uint8_t* data,
|
||||
size_t size,
|
||||
FuriHalI2cBegin begin,
|
||||
FuriHalI2cEnd end,
|
||||
uint32_t timeout) {
|
||||
furi_check(handle->bus->current_handle == handle);
|
||||
|
||||
FuriHalCortexTimer timer = furi_hal_cortex_timer_get(timeout * 1000);
|
||||
|
||||
return furi_hal_i2c_transaction(
|
||||
handle->bus->i2c, address, ten_bit, data, size, begin, end, true, timer);
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_tx_ext(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint16_t address,
|
||||
bool ten_bit,
|
||||
const uint8_t* data,
|
||||
size_t size,
|
||||
FuriHalI2cBegin begin,
|
||||
FuriHalI2cEnd end,
|
||||
uint32_t timeout) {
|
||||
furi_check(handle->bus->current_handle == handle);
|
||||
|
||||
FuriHalCortexTimer timer = furi_hal_cortex_timer_get(timeout * 1000);
|
||||
|
||||
return furi_hal_i2c_transaction(
|
||||
handle->bus->i2c, address, ten_bit, (uint8_t*)data, size, begin, end, false, timer);
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_tx(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint8_t address,
|
||||
const uint8_t* data,
|
||||
size_t size,
|
||||
uint32_t timeout) {
|
||||
furi_assert(timeout > 0);
|
||||
|
||||
return furi_hal_i2c_tx_ext(
|
||||
handle, address, false, data, size, FuriHalI2cBeginStart, FuriHalI2cEndStop, timeout);
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_rx(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint8_t address,
|
||||
uint8_t* data,
|
||||
size_t size,
|
||||
uint32_t timeout) {
|
||||
furi_assert(timeout > 0);
|
||||
|
||||
return furi_hal_i2c_rx_ext(
|
||||
handle, address, false, data, size, FuriHalI2cBeginStart, FuriHalI2cEndStop, timeout);
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_trx(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint8_t address,
|
||||
const uint8_t* tx_data,
|
||||
size_t tx_size,
|
||||
uint8_t* rx_data,
|
||||
size_t rx_size,
|
||||
uint32_t timeout) {
|
||||
return furi_hal_i2c_tx_ext(
|
||||
handle,
|
||||
address,
|
||||
false,
|
||||
tx_data,
|
||||
tx_size,
|
||||
FuriHalI2cBeginStart,
|
||||
FuriHalI2cEndStop,
|
||||
timeout) &&
|
||||
furi_hal_i2c_rx_ext(
|
||||
handle,
|
||||
address,
|
||||
false,
|
||||
rx_data,
|
||||
rx_size,
|
||||
FuriHalI2cBeginStart,
|
||||
FuriHalI2cEndStop,
|
||||
timeout);
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_is_device_ready(FuriHalI2cBusHandle* handle, uint8_t i2c_addr, uint32_t timeout) {
|
||||
furi_check(handle);
|
||||
furi_check(handle->bus->current_handle == handle);
|
||||
furi_assert(timeout > 0);
|
||||
|
||||
bool ret = true;
|
||||
FuriHalCortexTimer timer = furi_hal_cortex_timer_get(timeout * 1000);
|
||||
|
||||
if(!furi_hal_i2c_wait_for_idle(handle->bus->i2c, FuriHalI2cBeginStart, timer)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
LL_I2C_HandleTransfer(
|
||||
handle->bus->i2c,
|
||||
i2c_addr,
|
||||
LL_I2C_ADDRSLAVE_7BIT,
|
||||
0,
|
||||
LL_I2C_MODE_AUTOEND,
|
||||
LL_I2C_GENERATE_START_WRITE);
|
||||
|
||||
if(!furi_hal_i2c_wait_for_end(handle->bus->i2c, FuriHalI2cEndStop, timer)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
ret = !LL_I2C_IsActiveFlag_NACK(handle->bus->i2c);
|
||||
|
||||
LL_I2C_ClearFlag_NACK(handle->bus->i2c);
|
||||
LL_I2C_ClearFlag_STOP(handle->bus->i2c);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_read_reg_8(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint8_t i2c_addr,
|
||||
uint8_t reg_addr,
|
||||
uint8_t* data,
|
||||
uint32_t timeout) {
|
||||
furi_check(handle);
|
||||
|
||||
return furi_hal_i2c_trx(handle, i2c_addr, ®_addr, 1, data, 1, timeout);
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_read_reg_16(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint8_t i2c_addr,
|
||||
uint8_t reg_addr,
|
||||
uint16_t* data,
|
||||
uint32_t timeout) {
|
||||
furi_check(handle);
|
||||
|
||||
uint8_t reg_data[2];
|
||||
bool ret = furi_hal_i2c_trx(handle, i2c_addr, ®_addr, 1, reg_data, 2, timeout);
|
||||
*data = (reg_data[0] << 8) | (reg_data[1]);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_read_mem(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint8_t i2c_addr,
|
||||
uint8_t mem_addr,
|
||||
uint8_t* data,
|
||||
size_t len,
|
||||
uint32_t timeout) {
|
||||
furi_check(handle);
|
||||
|
||||
return furi_hal_i2c_trx(handle, i2c_addr, &mem_addr, 1, data, len, timeout);
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_write_reg_8(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint8_t i2c_addr,
|
||||
uint8_t reg_addr,
|
||||
uint8_t data,
|
||||
uint32_t timeout) {
|
||||
furi_check(handle);
|
||||
|
||||
const uint8_t tx_data[2] = {
|
||||
reg_addr,
|
||||
data,
|
||||
};
|
||||
|
||||
return furi_hal_i2c_tx(handle, i2c_addr, tx_data, 2, timeout);
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_write_reg_16(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint8_t i2c_addr,
|
||||
uint8_t reg_addr,
|
||||
uint16_t data,
|
||||
uint32_t timeout) {
|
||||
furi_check(handle);
|
||||
|
||||
const uint8_t tx_data[3] = {
|
||||
reg_addr,
|
||||
(data >> 8) & 0xFF,
|
||||
data & 0xFF,
|
||||
};
|
||||
|
||||
return furi_hal_i2c_tx(handle, i2c_addr, tx_data, 3, timeout);
|
||||
}
|
||||
|
||||
bool furi_hal_i2c_write_mem(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
uint8_t i2c_addr,
|
||||
uint8_t mem_addr,
|
||||
const uint8_t* data,
|
||||
size_t len,
|
||||
uint32_t timeout) {
|
||||
furi_check(handle);
|
||||
furi_check(handle->bus->current_handle == handle);
|
||||
furi_assert(timeout > 0);
|
||||
|
||||
return furi_hal_i2c_tx_ext(
|
||||
handle,
|
||||
i2c_addr,
|
||||
false,
|
||||
&mem_addr,
|
||||
1,
|
||||
FuriHalI2cBeginStart,
|
||||
FuriHalI2cEndPause,
|
||||
timeout) &&
|
||||
furi_hal_i2c_tx_ext(
|
||||
handle,
|
||||
i2c_addr,
|
||||
false,
|
||||
data,
|
||||
len,
|
||||
FuriHalI2cBeginResume,
|
||||
FuriHalI2cEndStop,
|
||||
timeout);
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
#include <furi_hal_i2c_config.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_bus.h>
|
||||
|
||||
#include <stm32wbxx_ll_rcc.h>
|
||||
|
||||
/** Timing register value is computed with the STM32CubeMX Tool,
|
||||
* Standard Mode @100kHz with I2CCLK = 64 MHz,
|
||||
* rise time = 0ns, fall time = 0ns
|
||||
*/
|
||||
#define FURI_HAL_I2C_CONFIG_POWER_I2C_TIMINGS_100 0x10707DBC
|
||||
|
||||
/** Timing register value is computed with the STM32CubeMX Tool,
|
||||
* Fast Mode @400kHz with I2CCLK = 64 MHz,
|
||||
* rise time = 0ns, fall time = 0ns
|
||||
*/
|
||||
#define FURI_HAL_I2C_CONFIG_POWER_I2C_TIMINGS_400 0x00602173
|
||||
|
||||
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);
|
||||
bus->current_handle = NULL;
|
||||
} else if(event == FuriHalI2cBusEventDeinit) {
|
||||
furi_mutex_free(furi_hal_i2c_bus_power_mutex);
|
||||
} else if(event == FuriHalI2cBusEventLock) {
|
||||
furi_check(
|
||||
furi_mutex_acquire(furi_hal_i2c_bus_power_mutex, FuriWaitForever) == FuriStatusOk);
|
||||
} else if(event == FuriHalI2cBusEventUnlock) {
|
||||
furi_check(furi_mutex_release(furi_hal_i2c_bus_power_mutex) == FuriStatusOk);
|
||||
} else if(event == FuriHalI2cBusEventActivate) {
|
||||
FURI_CRITICAL_ENTER();
|
||||
furi_hal_bus_enable(FuriHalBusI2C1);
|
||||
LL_RCC_SetI2CClockSource(LL_RCC_I2C1_CLKSOURCE_PCLK1);
|
||||
FURI_CRITICAL_EXIT();
|
||||
} else if(event == FuriHalI2cBusEventDeactivate) {
|
||||
furi_hal_bus_disable(FuriHalBusI2C1);
|
||||
}
|
||||
}
|
||||
|
||||
FuriHalI2cBus furi_hal_i2c_bus_power = {
|
||||
.i2c = I2C1,
|
||||
.callback = furi_hal_i2c_bus_power_event,
|
||||
};
|
||||
|
||||
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);
|
||||
bus->current_handle = NULL;
|
||||
} else if(event == FuriHalI2cBusEventDeinit) {
|
||||
furi_mutex_free(furi_hal_i2c_bus_external_mutex);
|
||||
} else if(event == FuriHalI2cBusEventLock) {
|
||||
furi_check(
|
||||
furi_mutex_acquire(furi_hal_i2c_bus_external_mutex, FuriWaitForever) == FuriStatusOk);
|
||||
} else if(event == FuriHalI2cBusEventUnlock) {
|
||||
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);
|
||||
FURI_CRITICAL_EXIT();
|
||||
} else if(event == FuriHalI2cBusEventDeactivate) {
|
||||
furi_hal_bus_disable(FuriHalBusI2C3);
|
||||
}
|
||||
}
|
||||
|
||||
FuriHalI2cBus furi_hal_i2c_bus_external = {
|
||||
.i2c = I2C3,
|
||||
.callback = furi_hal_i2c_bus_external_event,
|
||||
};
|
||||
|
||||
void furi_hal_i2c_bus_handle_power_event(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
FuriHalI2cBusHandleEvent event) {
|
||||
if(event == FuriHalI2cBusHandleEventActivate) {
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_i2c_power_sda,
|
||||
GpioModeAltFunctionOpenDrain,
|
||||
GpioPullNo,
|
||||
GpioSpeedLow,
|
||||
GpioAltFn4I2C1);
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_i2c_power_scl,
|
||||
GpioModeAltFunctionOpenDrain,
|
||||
GpioPullNo,
|
||||
GpioSpeedLow,
|
||||
GpioAltFn4I2C1);
|
||||
|
||||
LL_I2C_InitTypeDef I2C_InitStruct;
|
||||
I2C_InitStruct.PeripheralMode = LL_I2C_MODE_I2C;
|
||||
I2C_InitStruct.AnalogFilter = LL_I2C_ANALOGFILTER_ENABLE;
|
||||
I2C_InitStruct.DigitalFilter = 0;
|
||||
I2C_InitStruct.OwnAddress1 = 0;
|
||||
I2C_InitStruct.TypeAcknowledge = LL_I2C_ACK;
|
||||
I2C_InitStruct.OwnAddrSize = LL_I2C_OWNADDRESS1_7BIT;
|
||||
if(furi_hal_version_get_hw_version() > 10) {
|
||||
I2C_InitStruct.Timing = FURI_HAL_I2C_CONFIG_POWER_I2C_TIMINGS_400;
|
||||
} else {
|
||||
I2C_InitStruct.Timing = FURI_HAL_I2C_CONFIG_POWER_I2C_TIMINGS_100;
|
||||
}
|
||||
LL_I2C_Init(handle->bus->i2c, &I2C_InitStruct);
|
||||
// I2C is enabled at this point
|
||||
LL_I2C_EnableAutoEndMode(handle->bus->i2c);
|
||||
LL_I2C_SetOwnAddress2(handle->bus->i2c, 0, LL_I2C_OWNADDRESS2_NOMASK);
|
||||
LL_I2C_DisableOwnAddress2(handle->bus->i2c);
|
||||
LL_I2C_DisableGeneralCall(handle->bus->i2c);
|
||||
LL_I2C_EnableClockStretching(handle->bus->i2c);
|
||||
} else if(event == FuriHalI2cBusHandleEventDeactivate) {
|
||||
LL_I2C_Disable(handle->bus->i2c);
|
||||
furi_hal_gpio_write(&gpio_i2c_power_sda, 1);
|
||||
furi_hal_gpio_write(&gpio_i2c_power_scl, 1);
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_i2c_power_sda, GpioModeAnalog, GpioPullNo, GpioSpeedLow, GpioAltFnUnused);
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_i2c_power_scl, GpioModeAnalog, GpioPullNo, GpioSpeedLow, GpioAltFnUnused);
|
||||
}
|
||||
}
|
||||
|
||||
FuriHalI2cBusHandle furi_hal_i2c_handle_power = {
|
||||
.bus = &furi_hal_i2c_bus_power,
|
||||
.callback = furi_hal_i2c_bus_handle_power_event,
|
||||
};
|
||||
|
||||
void furi_hal_i2c_bus_handle_external_event(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
FuriHalI2cBusHandleEvent event) {
|
||||
if(event == FuriHalI2cBusHandleEventActivate) {
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_ext_pc0, GpioModeAltFunctionOpenDrain, GpioPullNo, GpioSpeedLow, GpioAltFn4I2C3);
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_ext_pc1, GpioModeAltFunctionOpenDrain, GpioPullNo, GpioSpeedLow, GpioAltFn4I2C3);
|
||||
|
||||
LL_I2C_InitTypeDef I2C_InitStruct;
|
||||
I2C_InitStruct.PeripheralMode = LL_I2C_MODE_I2C;
|
||||
I2C_InitStruct.AnalogFilter = LL_I2C_ANALOGFILTER_ENABLE;
|
||||
I2C_InitStruct.DigitalFilter = 0;
|
||||
I2C_InitStruct.OwnAddress1 = 0;
|
||||
I2C_InitStruct.TypeAcknowledge = LL_I2C_ACK;
|
||||
I2C_InitStruct.OwnAddrSize = LL_I2C_OWNADDRESS1_7BIT;
|
||||
I2C_InitStruct.Timing = FURI_HAL_I2C_CONFIG_POWER_I2C_TIMINGS_100;
|
||||
LL_I2C_Init(handle->bus->i2c, &I2C_InitStruct);
|
||||
// I2C is enabled at this point
|
||||
LL_I2C_EnableAutoEndMode(handle->bus->i2c);
|
||||
LL_I2C_SetOwnAddress2(handle->bus->i2c, 0, LL_I2C_OWNADDRESS2_NOMASK);
|
||||
LL_I2C_DisableOwnAddress2(handle->bus->i2c);
|
||||
LL_I2C_DisableGeneralCall(handle->bus->i2c);
|
||||
LL_I2C_EnableClockStretching(handle->bus->i2c);
|
||||
} else if(event == FuriHalI2cBusHandleEventDeactivate) {
|
||||
LL_I2C_Disable(handle->bus->i2c);
|
||||
furi_hal_gpio_write(&gpio_ext_pc0, 1);
|
||||
furi_hal_gpio_write(&gpio_ext_pc1, 1);
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_ext_pc0, GpioModeAnalog, GpioPullNo, GpioSpeedLow, GpioAltFnUnused);
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_ext_pc1, GpioModeAnalog, GpioPullNo, GpioSpeedLow, GpioAltFnUnused);
|
||||
}
|
||||
}
|
||||
|
||||
FuriHalI2cBusHandle furi_hal_i2c_handle_external = {
|
||||
.bus = &furi_hal_i2c_bus_external,
|
||||
.callback = furi_hal_i2c_bus_handle_external_event,
|
||||
};
|
||||
@@ -0,0 +1,31 @@
|
||||
#pragma once
|
||||
|
||||
#include <furi_hal_i2c_types.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** Internal(power) i2c bus, I2C1, under reset when not used */
|
||||
extern FuriHalI2cBus furi_hal_i2c_bus_power;
|
||||
|
||||
/** External i2c bus, I2C3, under reset when not used */
|
||||
extern FuriHalI2cBus furi_hal_i2c_bus_external;
|
||||
|
||||
/** Handle for internal(power) i2c bus
|
||||
* Bus: furi_hal_i2c_bus_external
|
||||
* Pins: PA9(SCL) / PA10(SDA), float on release
|
||||
* Params: 400khz
|
||||
*/
|
||||
extern FuriHalI2cBusHandle furi_hal_i2c_handle_power;
|
||||
|
||||
/** Handle for external i2c bus
|
||||
* Bus: furi_hal_i2c_bus_external
|
||||
* Pins: PC0(SCL) / PC1(SDA), float on release
|
||||
* Params: 100khz
|
||||
*/
|
||||
extern FuriHalI2cBusHandle furi_hal_i2c_handle_external;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,51 @@
|
||||
#pragma once
|
||||
|
||||
#include <stm32wbxx_ll_i2c.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct FuriHalI2cBus FuriHalI2cBus;
|
||||
typedef struct FuriHalI2cBusHandle FuriHalI2cBusHandle;
|
||||
|
||||
/** FuriHal i2c bus states */
|
||||
typedef enum {
|
||||
FuriHalI2cBusEventInit, /**< Bus initialization event, called on system start */
|
||||
FuriHalI2cBusEventDeinit, /**< Bus deinitialization event, called on system stop */
|
||||
FuriHalI2cBusEventLock, /**< Bus lock event, called before activation */
|
||||
FuriHalI2cBusEventUnlock, /**< Bus unlock event, called after deactivation */
|
||||
FuriHalI2cBusEventActivate, /**< Bus activation event, called before handle activation */
|
||||
FuriHalI2cBusEventDeactivate, /**< Bus deactivation event, called after handle deactivation */
|
||||
} FuriHalI2cBusEvent;
|
||||
|
||||
/** FuriHal i2c bus event callback */
|
||||
typedef void (*FuriHalI2cBusEventCallback)(FuriHalI2cBus* bus, FuriHalI2cBusEvent event);
|
||||
|
||||
/** FuriHal i2c bus */
|
||||
struct FuriHalI2cBus {
|
||||
I2C_TypeDef* i2c;
|
||||
FuriHalI2cBusHandle* current_handle;
|
||||
FuriHalI2cBusEventCallback callback;
|
||||
};
|
||||
|
||||
/** FuriHal i2c handle states */
|
||||
typedef enum {
|
||||
FuriHalI2cBusHandleEventActivate, /**< Handle activate: connect gpio and apply bus config */
|
||||
FuriHalI2cBusHandleEventDeactivate, /**< Handle deactivate: disconnect gpio and reset bus config */
|
||||
} FuriHalI2cBusHandleEvent;
|
||||
|
||||
/** FuriHal i2c handle event callback */
|
||||
typedef void (*FuriHalI2cBusHandleEventCallback)(
|
||||
FuriHalI2cBusHandle* handle,
|
||||
FuriHalI2cBusHandleEvent event);
|
||||
|
||||
/** FuriHal i2c handle */
|
||||
struct FuriHalI2cBusHandle {
|
||||
FuriHalI2cBus* bus;
|
||||
FuriHalI2cBusHandleEventCallback callback;
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,103 @@
|
||||
#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 <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 {
|
||||
FuriHalIbuttonStateIdle,
|
||||
FuriHalIbuttonStateRunning,
|
||||
} FuriHalIbuttonState;
|
||||
|
||||
typedef struct {
|
||||
FuriHalIbuttonState state;
|
||||
FuriHalIbuttonEmulateCallback callback;
|
||||
void* context;
|
||||
} FuriHalIbutton;
|
||||
|
||||
FuriHalIbutton* furi_hal_ibutton = NULL;
|
||||
|
||||
static void furi_hal_ibutton_emulate_isr() {
|
||||
if(LL_TIM_IsActiveFlag_UPDATE(FURI_HAL_IBUTTON_TIMER)) {
|
||||
LL_TIM_ClearFlag_UPDATE(FURI_HAL_IBUTTON_TIMER);
|
||||
furi_hal_ibutton->callback(furi_hal_ibutton->context);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_ibutton_init() {
|
||||
furi_hal_ibutton = malloc(sizeof(FuriHalIbutton));
|
||||
furi_hal_ibutton->state = FuriHalIbuttonStateIdle;
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
void furi_hal_ibutton_emulate_start(
|
||||
uint32_t period,
|
||||
FuriHalIbuttonEmulateCallback callback,
|
||||
void* context) {
|
||||
furi_assert(furi_hal_ibutton);
|
||||
furi_assert(furi_hal_ibutton->state == FuriHalIbuttonStateIdle);
|
||||
|
||||
furi_hal_ibutton->state = FuriHalIbuttonStateRunning;
|
||||
furi_hal_ibutton->callback = callback;
|
||||
furi_hal_ibutton->context = context;
|
||||
|
||||
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);
|
||||
|
||||
LL_TIM_SetPrescaler(FURI_HAL_IBUTTON_TIMER, 0);
|
||||
LL_TIM_SetCounterMode(FURI_HAL_IBUTTON_TIMER, LL_TIM_COUNTERMODE_UP);
|
||||
LL_TIM_SetAutoReload(FURI_HAL_IBUTTON_TIMER, period);
|
||||
LL_TIM_DisableARRPreload(FURI_HAL_IBUTTON_TIMER);
|
||||
LL_TIM_SetRepetitionCounter(FURI_HAL_IBUTTON_TIMER, 0);
|
||||
|
||||
LL_TIM_SetClockDivision(FURI_HAL_IBUTTON_TIMER, LL_TIM_CLOCKDIVISION_DIV1);
|
||||
LL_TIM_SetClockSource(FURI_HAL_IBUTTON_TIMER, LL_TIM_CLOCKSOURCE_INTERNAL);
|
||||
LL_TIM_GenerateEvent_UPDATE(FURI_HAL_IBUTTON_TIMER);
|
||||
|
||||
LL_TIM_EnableIT_UPDATE(FURI_HAL_IBUTTON_TIMER);
|
||||
|
||||
LL_TIM_EnableCounter(FURI_HAL_IBUTTON_TIMER);
|
||||
}
|
||||
|
||||
void furi_hal_ibutton_emulate_set_next(uint32_t period) {
|
||||
LL_TIM_SetAutoReload(FURI_HAL_IBUTTON_TIMER, period);
|
||||
}
|
||||
|
||||
void furi_hal_ibutton_emulate_stop() {
|
||||
furi_assert(furi_hal_ibutton);
|
||||
|
||||
if(furi_hal_ibutton->state == FuriHalIbuttonStateRunning) {
|
||||
furi_hal_ibutton->state = FuriHalIbuttonStateIdle;
|
||||
LL_TIM_DisableCounter(FURI_HAL_IBUTTON_TIMER);
|
||||
|
||||
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;
|
||||
furi_hal_ibutton->context = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_ibutton_pin_configure() {
|
||||
furi_hal_gpio_write(&gpio_ibutton, true);
|
||||
furi_hal_gpio_init(&gpio_ibutton, GpioModeOutputOpenDrain, GpioPullNo, GpioSpeedLow);
|
||||
}
|
||||
|
||||
void furi_hal_ibutton_pin_reset() {
|
||||
furi_hal_gpio_write(&gpio_ibutton, true);
|
||||
furi_hal_gpio_init(&gpio_ibutton, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
}
|
||||
|
||||
void furi_hal_ibutton_pin_write(const bool state) {
|
||||
furi_hal_gpio_write(&gpio_ibutton, state);
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* @file furi_hal_ibutton.h
|
||||
* iButton HAL API
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef void (*FuriHalIbuttonEmulateCallback)(void* context);
|
||||
|
||||
/** Initialize */
|
||||
void furi_hal_ibutton_init();
|
||||
|
||||
/**
|
||||
* Start emulation timer
|
||||
* @param period timer period
|
||||
* @param callback timer callback
|
||||
* @param context callback context
|
||||
*/
|
||||
void furi_hal_ibutton_emulate_start(
|
||||
uint32_t period,
|
||||
FuriHalIbuttonEmulateCallback callback,
|
||||
void* context);
|
||||
|
||||
/**
|
||||
* Update emulation timer period
|
||||
* @param period new timer period
|
||||
*/
|
||||
void furi_hal_ibutton_emulate_set_next(uint32_t period);
|
||||
|
||||
/**
|
||||
* Stop emulation timer
|
||||
*/
|
||||
void furi_hal_ibutton_emulate_stop();
|
||||
|
||||
/**
|
||||
* Set the pin to normal mode (open collector), and sets it to float
|
||||
*/
|
||||
void furi_hal_ibutton_pin_configure();
|
||||
|
||||
/**
|
||||
* Sets the pin to analog mode, and sets it to float
|
||||
*/
|
||||
void furi_hal_ibutton_pin_reset();
|
||||
|
||||
/**
|
||||
* iButton write pin
|
||||
* @param state true / false
|
||||
*/
|
||||
void furi_hal_ibutton_pin_write(const bool state);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,59 @@
|
||||
#pragma once
|
||||
|
||||
#include <stm32wbxx_ll_lptim.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
|
||||
#define FURI_HAL_IDLE_TIMER LPTIM1
|
||||
#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
|
||||
LL_APB1_GRP1_EnableClockSleep(LL_APB1_GRP1_PERIPH_LPTIM1);
|
||||
// Set interrupt priority and enable them
|
||||
NVIC_SetPriority(
|
||||
FURI_HAL_IDLE_TIMER_IRQ, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 15, 0));
|
||||
NVIC_EnableIRQ(FURI_HAL_IDLE_TIMER_IRQ);
|
||||
}
|
||||
|
||||
static inline void furi_hal_idle_timer_start(uint32_t count) {
|
||||
count--;
|
||||
// Enable timer
|
||||
LL_LPTIM_Enable(FURI_HAL_IDLE_TIMER);
|
||||
while(!LL_LPTIM_IsEnabled(FURI_HAL_IDLE_TIMER))
|
||||
;
|
||||
|
||||
// Enable compare match interrupt
|
||||
LL_LPTIM_EnableIT_CMPM(FURI_HAL_IDLE_TIMER);
|
||||
|
||||
// Set compare, autoreload and start counter
|
||||
// Include some marging to workaround ARRM behaviour
|
||||
LL_LPTIM_SetCompare(FURI_HAL_IDLE_TIMER, count - 3);
|
||||
LL_LPTIM_SetAutoReload(FURI_HAL_IDLE_TIMER, count);
|
||||
LL_LPTIM_StartCounter(FURI_HAL_IDLE_TIMER, LL_LPTIM_OPERATING_MODE_ONESHOT);
|
||||
}
|
||||
|
||||
static inline void furi_hal_idle_timer_reset() {
|
||||
// Hard reset timer
|
||||
// THE ONLY RELIABLE WAY to stop it according to errata
|
||||
furi_hal_bus_reset(FuriHalBusLPTIM1);
|
||||
// Prevent IRQ handler call
|
||||
NVIC_ClearPendingIRQ(FURI_HAL_IDLE_TIMER_IRQ);
|
||||
}
|
||||
|
||||
static inline uint32_t furi_hal_idle_timer_get_cnt() {
|
||||
uint32_t counter = LL_LPTIM_GetCounter(FURI_HAL_IDLE_TIMER);
|
||||
uint32_t counter_shadow = LL_LPTIM_GetCounter(FURI_HAL_IDLE_TIMER);
|
||||
while(counter != counter_shadow) {
|
||||
counter = counter_shadow;
|
||||
counter_shadow = LL_LPTIM_GetCounter(FURI_HAL_IDLE_TIMER);
|
||||
}
|
||||
return counter;
|
||||
}
|
||||
@@ -0,0 +1,366 @@
|
||||
#include <furi_hal_info.h>
|
||||
#include <furi_hal_region.h>
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_bt.h>
|
||||
#include <furi_hal_crypto.h>
|
||||
#include <furi_hal_rtc.h>
|
||||
|
||||
#include <interface/patterns/ble_thread/shci/shci.h>
|
||||
#include <furi.h>
|
||||
#include <protobuf_version.h>
|
||||
|
||||
FURI_WEAK void furi_hal_info_get_api_version(uint16_t* major, uint16_t* minor) {
|
||||
*major = 0;
|
||||
*minor = 0;
|
||||
}
|
||||
|
||||
void furi_hal_info_get(PropertyValueCallback out, char sep, void* context) {
|
||||
FuriString* key = furi_string_alloc();
|
||||
FuriString* value = furi_string_alloc();
|
||||
|
||||
PropertyValueContext property_context = {
|
||||
.key = key, .value = value, .out = out, .sep = sep, .last = false, .context = context};
|
||||
|
||||
// Device Info version
|
||||
if(sep == '.') {
|
||||
property_value_out(&property_context, NULL, 2, "format", "major", "3");
|
||||
property_value_out(&property_context, NULL, 2, "format", "minor", "3");
|
||||
} else {
|
||||
property_value_out(&property_context, NULL, 3, "device", "info", "major", "2");
|
||||
property_value_out(&property_context, NULL, 3, "device", "info", "minor", "4");
|
||||
}
|
||||
|
||||
// Model name
|
||||
property_value_out(
|
||||
&property_context, NULL, 2, "hardware", "model", furi_hal_version_get_model_name());
|
||||
|
||||
// Unique ID
|
||||
furi_string_reset(value);
|
||||
const uint8_t* uid = furi_hal_version_uid();
|
||||
for(size_t i = 0; i < furi_hal_version_uid_size(); i++) {
|
||||
furi_string_cat_printf(value, "%02X", uid[i]);
|
||||
}
|
||||
property_value_out(&property_context, NULL, 2, "hardware", "uid", furi_string_get_cstr(value));
|
||||
|
||||
// OTP Revision
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "hardware", "otp", "ver", furi_hal_version_get_otp_version());
|
||||
property_value_out(
|
||||
&property_context, "%lu", 2, "hardware", "timestamp", furi_hal_version_get_hw_timestamp());
|
||||
|
||||
// Board Revision
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "hardware", "ver", furi_hal_version_get_hw_version());
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "hardware", "target", furi_hal_version_get_hw_target());
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "hardware", "body", furi_hal_version_get_hw_body());
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "hardware", "connect", furi_hal_version_get_hw_connect());
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "hardware", "display", furi_hal_version_get_hw_display());
|
||||
|
||||
// Board Personification
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "hardware", "color", furi_hal_version_get_hw_color());
|
||||
|
||||
if(sep == '.') {
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
3,
|
||||
"hardware",
|
||||
"region",
|
||||
"builtin",
|
||||
furi_hal_version_get_hw_region());
|
||||
} else {
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "hardware", "region", furi_hal_version_get_hw_region());
|
||||
}
|
||||
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
3,
|
||||
"hardware",
|
||||
"region",
|
||||
"provisioned",
|
||||
furi_hal_region_get_name());
|
||||
|
||||
const char* name = furi_hal_version_get_name_ptr();
|
||||
if(name) {
|
||||
property_value_out(&property_context, NULL, 2, "hardware", "name", name);
|
||||
}
|
||||
|
||||
// Firmware version
|
||||
const Version* firmware_version = furi_hal_version_get_firmware_version();
|
||||
if(firmware_version) {
|
||||
if(sep == '.') {
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
3,
|
||||
"firmware",
|
||||
"commit",
|
||||
"hash",
|
||||
version_get_githash(firmware_version));
|
||||
} else {
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
2,
|
||||
"firmware",
|
||||
"commit",
|
||||
version_get_githash(firmware_version));
|
||||
}
|
||||
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
3,
|
||||
"firmware",
|
||||
"commit",
|
||||
"dirty",
|
||||
version_get_dirty_flag(firmware_version) ? "true" : "false");
|
||||
|
||||
if(sep == '.') {
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
3,
|
||||
"firmware",
|
||||
"branch",
|
||||
"name",
|
||||
version_get_gitbranch(firmware_version));
|
||||
} else {
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
2,
|
||||
"firmware",
|
||||
"branch",
|
||||
version_get_gitbranch(firmware_version));
|
||||
}
|
||||
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
3,
|
||||
"firmware",
|
||||
"branch",
|
||||
"num",
|
||||
version_get_gitbranchnum(firmware_version));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
2,
|
||||
"firmware",
|
||||
"version",
|
||||
version_get_version(firmware_version));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
3,
|
||||
"firmware",
|
||||
"build",
|
||||
"date",
|
||||
version_get_builddate(firmware_version));
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "firmware", "target", version_get_target(firmware_version));
|
||||
|
||||
uint16_t api_version_major, api_version_minor;
|
||||
furi_hal_info_get_api_version(&api_version_major, &api_version_minor);
|
||||
property_value_out(
|
||||
&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()) {
|
||||
const BleGlueC2Info* ble_c2_info = ble_glue_get_c2_info();
|
||||
property_value_out(&property_context, NULL, 2, "radio", "alive", "true");
|
||||
property_value_out(
|
||||
&property_context,
|
||||
NULL,
|
||||
2,
|
||||
"radio",
|
||||
"mode",
|
||||
ble_c2_info->mode == BleGlueC2ModeFUS ? "FUS" : "Stack");
|
||||
|
||||
// FUS Info
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "radio", "fus", "major", ble_c2_info->FusVersionMajor);
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "radio", "fus", "minor", ble_c2_info->FusVersionMinor);
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "radio", "fus", "sub", ble_c2_info->FusVersionSub);
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%dK",
|
||||
3,
|
||||
"radio",
|
||||
"fus",
|
||||
"sram2b",
|
||||
ble_c2_info->FusMemorySizeSram2B);
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%dK",
|
||||
3,
|
||||
"radio",
|
||||
"fus",
|
||||
"sram2a",
|
||||
ble_c2_info->FusMemorySizeSram2A);
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%dK",
|
||||
3,
|
||||
"radio",
|
||||
"fus",
|
||||
"flash",
|
||||
ble_c2_info->FusMemorySizeFlash * 4);
|
||||
|
||||
// Stack Info
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "radio", "stack", "type", ble_c2_info->StackType);
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "radio", "stack", "major", ble_c2_info->VersionMajor);
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "radio", "stack", "minor", ble_c2_info->VersionMinor);
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "radio", "stack", "sub", ble_c2_info->VersionSub);
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "radio", "stack", "branch", ble_c2_info->VersionBranch);
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
3,
|
||||
"radio",
|
||||
"stack",
|
||||
"release",
|
||||
ble_c2_info->VersionReleaseType);
|
||||
property_value_out(
|
||||
&property_context, "%dK", 3, "radio", "stack", "sram2b", ble_c2_info->MemorySizeSram2B);
|
||||
property_value_out(
|
||||
&property_context, "%dK", 3, "radio", "stack", "sram2a", ble_c2_info->MemorySizeSram2A);
|
||||
property_value_out(
|
||||
&property_context, "%dK", 3, "radio", "stack", "sram1", ble_c2_info->MemorySizeSram1);
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%dK",
|
||||
3,
|
||||
"radio",
|
||||
"stack",
|
||||
"flash",
|
||||
ble_c2_info->MemorySizeFlash * 4);
|
||||
|
||||
// Mac address
|
||||
furi_string_reset(value);
|
||||
const uint8_t* ble_mac = furi_hal_version_get_ble_mac();
|
||||
for(size_t i = 0; i < 6; i++) {
|
||||
furi_string_cat_printf(value, "%02X", ble_mac[i]);
|
||||
}
|
||||
property_value_out(
|
||||
&property_context, NULL, 3, "radio", "ble", "mac", furi_string_get_cstr(value));
|
||||
|
||||
// Signature verification
|
||||
uint8_t enclave_keys = 0;
|
||||
uint8_t enclave_valid_keys = 0;
|
||||
bool enclave_valid = furi_hal_crypto_enclave_verify(&enclave_keys, &enclave_valid_keys);
|
||||
if(sep == '.') {
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "enclave", "keys", "valid", enclave_valid_keys);
|
||||
} else {
|
||||
property_value_out(
|
||||
&property_context, "%d", 3, "enclave", "valid", "keys", enclave_valid_keys);
|
||||
}
|
||||
|
||||
property_value_out(
|
||||
&property_context, NULL, 2, "enclave", "valid", enclave_valid ? "true" : "false");
|
||||
} else {
|
||||
property_value_out(&property_context, NULL, 2, "radio", "alive", "false");
|
||||
}
|
||||
|
||||
// RTC flags
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%u",
|
||||
2,
|
||||
"system",
|
||||
"debug",
|
||||
furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug));
|
||||
property_value_out(
|
||||
&property_context, "%u", 2, "system", "lock", furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%u",
|
||||
2,
|
||||
"system",
|
||||
"orient",
|
||||
furi_hal_rtc_is_flag_set(FuriHalRtcFlagHandOrient));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%u",
|
||||
3,
|
||||
"system",
|
||||
"sleep",
|
||||
"legacy",
|
||||
furi_hal_rtc_is_flag_set(FuriHalRtcFlagLegacySleep));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%u",
|
||||
2,
|
||||
"system",
|
||||
"stealth",
|
||||
furi_hal_rtc_is_flag_set(FuriHalRtcFlagStealthMode));
|
||||
|
||||
property_value_out(
|
||||
&property_context, "%u", 3, "system", "heap", "track", furi_hal_rtc_get_heap_track_mode());
|
||||
property_value_out(&property_context, "%u", 2, "system", "boot", furi_hal_rtc_get_boot_mode());
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%u",
|
||||
3,
|
||||
"system",
|
||||
"locale",
|
||||
"time",
|
||||
furi_hal_rtc_get_locale_timeformat());
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%u",
|
||||
3,
|
||||
"system",
|
||||
"locale",
|
||||
"date",
|
||||
furi_hal_rtc_get_locale_dateformat());
|
||||
property_value_out(
|
||||
&property_context, "%u", 3, "system", "locale", "unit", furi_hal_rtc_get_locale_units());
|
||||
property_value_out(
|
||||
&property_context, "%u", 3, "system", "log", "level", furi_hal_rtc_get_log_level());
|
||||
|
||||
property_value_out(
|
||||
&property_context, "%u", 3, "protobuf", "version", "major", PROTOBUF_MAJOR_VERSION);
|
||||
property_context.last = true;
|
||||
property_value_out(
|
||||
&property_context, "%u", 3, "protobuf", "version", "minor", PROTOBUF_MINOR_VERSION);
|
||||
|
||||
furi_string_free(key);
|
||||
furi_string_free(value);
|
||||
}
|
||||
@@ -0,0 +1,686 @@
|
||||
#include <furi_hal_infrared.h>
|
||||
#include <furi_hal_interrupt.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_bus.h>
|
||||
|
||||
#include <stm32wbxx_ll_tim.h>
|
||||
#include <stm32wbxx_ll_dma.h>
|
||||
|
||||
#include <furi.h>
|
||||
#include <math.h>
|
||||
|
||||
// #define INFRARED_TX_DEBUG
|
||||
|
||||
#if defined INFRARED_TX_DEBUG
|
||||
#define gpio_infrared_tx gpio_ext_pa7
|
||||
#endif
|
||||
|
||||
#define INFRARED_TIM_TX_DMA_BUFFER_SIZE 200
|
||||
#define INFRARED_POLARITY_SHIFT 1
|
||||
|
||||
#define INFRARED_TX_CCMR_HIGH \
|
||||
(TIM_CCMR2_OC3PE | LL_TIM_OCMODE_PWM2) /* Mark time - enable PWM2 mode */
|
||||
#define INFRARED_TX_CCMR_LOW \
|
||||
(TIM_CCMR2_OC3PE | LL_TIM_OCMODE_FORCED_INACTIVE) /* Space time - force low */
|
||||
|
||||
/* DMA Channels definition */
|
||||
#define INFRARED_DMA DMA2
|
||||
#define INFRARED_DMA_CH1_CHANNEL LL_DMA_CHANNEL_1
|
||||
#define INFRARED_DMA_CH2_CHANNEL LL_DMA_CHANNEL_2
|
||||
#define INFRARED_DMA_CH1_IRQ FuriHalInterruptIdDma2Ch1
|
||||
#define INFRARED_DMA_CH2_IRQ FuriHalInterruptIdDma2Ch2
|
||||
#define INFRARED_DMA_CH1_DEF INFRARED_DMA, INFRARED_DMA_CH1_CHANNEL
|
||||
#define INFRARED_DMA_CH2_DEF INFRARED_DMA, INFRARED_DMA_CH2_CHANNEL
|
||||
|
||||
/* Timers definition */
|
||||
#define INFRARED_RX_TIMER TIM2
|
||||
#define INFRARED_DMA_TIMER TIM1
|
||||
#define INFRARED_RX_TIMER_BUS FuriHalBusTIM2
|
||||
#define INFRARED_DMA_TIMER_BUS FuriHalBusTIM1
|
||||
|
||||
/* Misc */
|
||||
#define INFRARED_RX_GPIO_ALT GpioAltFn1TIM2
|
||||
#define INFRARED_RX_IRQ FuriHalInterruptIdTIM2
|
||||
|
||||
typedef struct {
|
||||
FuriHalInfraredRxCaptureCallback capture_callback;
|
||||
void* capture_context;
|
||||
FuriHalInfraredRxTimeoutCallback timeout_callback;
|
||||
void* timeout_context;
|
||||
} InfraredTimRx;
|
||||
|
||||
typedef struct {
|
||||
uint8_t* polarity;
|
||||
uint16_t* data;
|
||||
size_t size;
|
||||
bool packet_end;
|
||||
bool last_packet_end;
|
||||
} InfraredTxBuf;
|
||||
|
||||
typedef struct {
|
||||
float cycle_duration;
|
||||
FuriHalInfraredTxGetDataISRCallback data_callback;
|
||||
FuriHalInfraredTxSignalSentISRCallback signal_sent_callback;
|
||||
void* data_context;
|
||||
void* signal_sent_context;
|
||||
InfraredTxBuf buffer[2];
|
||||
FuriSemaphore* stop_semaphore;
|
||||
uint32_t
|
||||
tx_timing_rest_duration; /** if timing is too long (> 0xFFFF), send it in few iterations */
|
||||
bool tx_timing_rest_level;
|
||||
FuriHalInfraredTxGetDataState tx_timing_rest_status;
|
||||
} InfraredTimTx;
|
||||
|
||||
typedef enum {
|
||||
InfraredStateIdle, /** Furi Hal Infrared is ready to start RX or TX */
|
||||
InfraredStateAsyncRx, /** Async RX started */
|
||||
InfraredStateAsyncTx, /** Async TX started, DMA and timer is on */
|
||||
InfraredStateAsyncTxStopReq, /** Async TX started, async stop request received */
|
||||
InfraredStateAsyncTxStopInProgress, /** Async TX started, stop request is processed and we wait for last data to be sent */
|
||||
InfraredStateAsyncTxStopped, /** Async TX complete, cleanup needed */
|
||||
InfraredStateMAX,
|
||||
} InfraredState;
|
||||
|
||||
static volatile InfraredState furi_hal_infrared_state = InfraredStateIdle;
|
||||
static InfraredTimTx infrared_tim_tx;
|
||||
static InfraredTimRx infrared_tim_rx;
|
||||
|
||||
static void furi_hal_infrared_tx_fill_buffer(uint8_t buf_num, uint8_t polarity_shift);
|
||||
static void furi_hal_infrared_async_tx_free_resources(void);
|
||||
static void furi_hal_infrared_tx_dma_set_polarity(uint8_t buf_num, uint8_t polarity_shift);
|
||||
static void furi_hal_infrared_tx_dma_set_buffer(uint8_t buf_num);
|
||||
static void furi_hal_infrared_tx_fill_buffer_last(uint8_t buf_num);
|
||||
static uint8_t furi_hal_infrared_get_current_dma_tx_buffer(void);
|
||||
static void furi_hal_infrared_tx_dma_polarity_isr();
|
||||
static void furi_hal_infrared_tx_dma_isr();
|
||||
|
||||
static void furi_hal_infrared_tim_rx_isr() {
|
||||
static uint32_t previous_captured_ch2 = 0;
|
||||
|
||||
/* Timeout */
|
||||
if(LL_TIM_IsActiveFlag_CC3(INFRARED_RX_TIMER)) {
|
||||
LL_TIM_ClearFlag_CC3(INFRARED_RX_TIMER);
|
||||
furi_assert(furi_hal_infrared_state == InfraredStateAsyncRx);
|
||||
|
||||
/* Timers CNT register starts to counting from 0 to ARR, but it is
|
||||
* reseted when Channel 1 catches interrupt. It is not reseted by
|
||||
* channel 2, though, so we have to distract it's values (see TimerIRQSourceCCI1 ISR).
|
||||
* This can cause false timeout: when time is over, but we started
|
||||
* receiving new signal few microseconds ago, because CNT register
|
||||
* is reseted once per period, not per sample. */
|
||||
if(LL_GPIO_IsInputPinSet(gpio_infrared_rx.port, gpio_infrared_rx.pin) != 0) {
|
||||
if(infrared_tim_rx.timeout_callback)
|
||||
infrared_tim_rx.timeout_callback(infrared_tim_rx.timeout_context);
|
||||
}
|
||||
}
|
||||
|
||||
/* Rising Edge */
|
||||
if(LL_TIM_IsActiveFlag_CC1(INFRARED_RX_TIMER)) {
|
||||
LL_TIM_ClearFlag_CC1(INFRARED_RX_TIMER);
|
||||
furi_assert(furi_hal_infrared_state == InfraredStateAsyncRx);
|
||||
|
||||
if(READ_BIT(INFRARED_RX_TIMER->CCMR1, TIM_CCMR1_CC1S)) {
|
||||
/* Low pin level is a Mark state of INFRARED signal. Invert level for further processing. */
|
||||
uint32_t duration = LL_TIM_IC_GetCaptureCH1(INFRARED_RX_TIMER) - previous_captured_ch2;
|
||||
if(infrared_tim_rx.capture_callback)
|
||||
infrared_tim_rx.capture_callback(infrared_tim_rx.capture_context, 1, duration);
|
||||
} else {
|
||||
furi_assert(0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Falling Edge */
|
||||
if(LL_TIM_IsActiveFlag_CC2(INFRARED_RX_TIMER)) {
|
||||
LL_TIM_ClearFlag_CC2(INFRARED_RX_TIMER);
|
||||
furi_assert(furi_hal_infrared_state == InfraredStateAsyncRx);
|
||||
|
||||
if(READ_BIT(INFRARED_RX_TIMER->CCMR1, TIM_CCMR1_CC2S)) {
|
||||
/* High pin level is a Space state of INFRARED signal. Invert level for further processing. */
|
||||
uint32_t duration = LL_TIM_IC_GetCaptureCH2(INFRARED_RX_TIMER);
|
||||
previous_captured_ch2 = duration;
|
||||
if(infrared_tim_rx.capture_callback)
|
||||
infrared_tim_rx.capture_callback(infrared_tim_rx.capture_context, 0, duration);
|
||||
} else {
|
||||
furi_assert(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_rx_start(void) {
|
||||
furi_assert(furi_hal_infrared_state == InfraredStateIdle);
|
||||
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_infrared_rx,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedLow,
|
||||
INFRARED_RX_GPIO_ALT);
|
||||
|
||||
furi_hal_bus_enable(INFRARED_RX_TIMER_BUS);
|
||||
|
||||
LL_TIM_InitTypeDef TIM_InitStruct = {0};
|
||||
TIM_InitStruct.Prescaler = 64 - 1;
|
||||
TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
|
||||
TIM_InitStruct.Autoreload = 0x7FFFFFFE;
|
||||
TIM_InitStruct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
|
||||
LL_TIM_Init(INFRARED_RX_TIMER, &TIM_InitStruct);
|
||||
|
||||
LL_TIM_SetClockSource(INFRARED_RX_TIMER, LL_TIM_CLOCKSOURCE_INTERNAL);
|
||||
LL_TIM_DisableARRPreload(INFRARED_RX_TIMER);
|
||||
LL_TIM_SetTriggerInput(INFRARED_RX_TIMER, LL_TIM_TS_TI1FP1);
|
||||
LL_TIM_SetSlaveMode(INFRARED_RX_TIMER, LL_TIM_SLAVEMODE_RESET);
|
||||
LL_TIM_CC_DisableChannel(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH2);
|
||||
LL_TIM_IC_SetFilter(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH2, LL_TIM_IC_FILTER_FDIV1);
|
||||
LL_TIM_IC_SetPolarity(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH2, LL_TIM_IC_POLARITY_FALLING);
|
||||
LL_TIM_DisableIT_TRIG(INFRARED_RX_TIMER);
|
||||
LL_TIM_DisableDMAReq_TRIG(INFRARED_RX_TIMER);
|
||||
LL_TIM_SetTriggerOutput(INFRARED_RX_TIMER, LL_TIM_TRGO_RESET);
|
||||
LL_TIM_EnableMasterSlaveMode(INFRARED_RX_TIMER);
|
||||
LL_TIM_IC_SetActiveInput(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH1, LL_TIM_ACTIVEINPUT_DIRECTTI);
|
||||
LL_TIM_IC_SetPrescaler(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH1, LL_TIM_ICPSC_DIV1);
|
||||
LL_TIM_IC_SetFilter(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH1, LL_TIM_IC_FILTER_FDIV1);
|
||||
LL_TIM_IC_SetPolarity(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH1, LL_TIM_IC_POLARITY_RISING);
|
||||
LL_TIM_IC_SetActiveInput(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH2, LL_TIM_ACTIVEINPUT_INDIRECTTI);
|
||||
LL_TIM_IC_SetPrescaler(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH2, LL_TIM_ICPSC_DIV1);
|
||||
|
||||
furi_hal_interrupt_set_isr(INFRARED_RX_IRQ, furi_hal_infrared_tim_rx_isr, NULL);
|
||||
furi_hal_infrared_state = InfraredStateAsyncRx;
|
||||
|
||||
LL_TIM_EnableIT_CC1(INFRARED_RX_TIMER);
|
||||
LL_TIM_EnableIT_CC2(INFRARED_RX_TIMER);
|
||||
LL_TIM_CC_EnableChannel(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH1);
|
||||
LL_TIM_CC_EnableChannel(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH2);
|
||||
|
||||
LL_TIM_SetCounter(INFRARED_RX_TIMER, 0);
|
||||
LL_TIM_EnableCounter(INFRARED_RX_TIMER);
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_rx_stop(void) {
|
||||
furi_assert(furi_hal_infrared_state == InfraredStateAsyncRx);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
furi_hal_bus_disable(INFRARED_RX_TIMER_BUS);
|
||||
furi_hal_interrupt_set_isr(INFRARED_RX_IRQ, NULL, NULL);
|
||||
furi_hal_infrared_state = InfraredStateIdle;
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_rx_set_timeout(uint32_t timeout_us) {
|
||||
LL_TIM_OC_SetCompareCH3(INFRARED_RX_TIMER, timeout_us);
|
||||
LL_TIM_OC_SetMode(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH3, LL_TIM_OCMODE_ACTIVE);
|
||||
LL_TIM_CC_EnableChannel(INFRARED_RX_TIMER, LL_TIM_CHANNEL_CH3);
|
||||
LL_TIM_EnableIT_CC3(INFRARED_RX_TIMER);
|
||||
}
|
||||
|
||||
bool furi_hal_infrared_is_busy(void) {
|
||||
return furi_hal_infrared_state != InfraredStateIdle;
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_rx_set_capture_isr_callback(
|
||||
FuriHalInfraredRxCaptureCallback callback,
|
||||
void* ctx) {
|
||||
infrared_tim_rx.capture_callback = callback;
|
||||
infrared_tim_rx.capture_context = ctx;
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_rx_set_timeout_isr_callback(
|
||||
FuriHalInfraredRxTimeoutCallback callback,
|
||||
void* ctx) {
|
||||
infrared_tim_rx.timeout_callback = callback;
|
||||
infrared_tim_rx.timeout_context = ctx;
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_tx_dma_terminate(void) {
|
||||
LL_DMA_DisableIT_TC(INFRARED_DMA_CH1_DEF);
|
||||
LL_DMA_DisableIT_HT(INFRARED_DMA_CH2_DEF);
|
||||
LL_DMA_DisableIT_TC(INFRARED_DMA_CH2_DEF);
|
||||
|
||||
furi_assert(furi_hal_infrared_state == InfraredStateAsyncTxStopInProgress);
|
||||
|
||||
LL_DMA_DisableIT_TC(INFRARED_DMA_CH1_DEF);
|
||||
LL_DMA_DisableChannel(INFRARED_DMA_CH2_DEF);
|
||||
LL_DMA_DisableChannel(INFRARED_DMA_CH1_DEF);
|
||||
LL_TIM_DisableCounter(INFRARED_DMA_TIMER);
|
||||
FuriStatus status = furi_semaphore_release(infrared_tim_tx.stop_semaphore);
|
||||
furi_check(status == FuriStatusOk);
|
||||
furi_hal_infrared_state = InfraredStateAsyncTxStopped;
|
||||
}
|
||||
|
||||
static uint8_t furi_hal_infrared_get_current_dma_tx_buffer(void) {
|
||||
uint8_t buf_num = 0;
|
||||
uint32_t buffer_adr = LL_DMA_GetMemoryAddress(INFRARED_DMA_CH2_DEF);
|
||||
if(buffer_adr == (uint32_t)infrared_tim_tx.buffer[0].data) {
|
||||
buf_num = 0;
|
||||
} else if(buffer_adr == (uint32_t)infrared_tim_tx.buffer[1].data) {
|
||||
buf_num = 1;
|
||||
} else {
|
||||
furi_assert(0);
|
||||
}
|
||||
return buf_num;
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_tx_dma_polarity_isr() {
|
||||
#if INFRARED_DMA_CH1_CHANNEL == LL_DMA_CHANNEL_1
|
||||
if(LL_DMA_IsActiveFlag_TE1(INFRARED_DMA)) {
|
||||
LL_DMA_ClearFlag_TE1(INFRARED_DMA);
|
||||
furi_crash(NULL);
|
||||
}
|
||||
if(LL_DMA_IsActiveFlag_TC1(INFRARED_DMA) && LL_DMA_IsEnabledIT_TC(INFRARED_DMA_CH1_DEF)) {
|
||||
LL_DMA_ClearFlag_TC1(INFRARED_DMA);
|
||||
|
||||
furi_check(
|
||||
(furi_hal_infrared_state == InfraredStateAsyncTx) ||
|
||||
(furi_hal_infrared_state == InfraredStateAsyncTxStopReq) ||
|
||||
(furi_hal_infrared_state == InfraredStateAsyncTxStopInProgress));
|
||||
/* actually TC2 is processed and buffer is next buffer */
|
||||
uint8_t next_buf_num = furi_hal_infrared_get_current_dma_tx_buffer();
|
||||
furi_hal_infrared_tx_dma_set_polarity(next_buf_num, 0);
|
||||
}
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_tx_dma_isr() {
|
||||
#if INFRARED_DMA_CH2_CHANNEL == LL_DMA_CHANNEL_2
|
||||
if(LL_DMA_IsActiveFlag_TE2(INFRARED_DMA)) {
|
||||
LL_DMA_ClearFlag_TE2(INFRARED_DMA);
|
||||
furi_crash(NULL);
|
||||
}
|
||||
if(LL_DMA_IsActiveFlag_HT2(INFRARED_DMA) && LL_DMA_IsEnabledIT_HT(INFRARED_DMA_CH2_DEF)) {
|
||||
LL_DMA_ClearFlag_HT2(INFRARED_DMA);
|
||||
uint8_t buf_num = furi_hal_infrared_get_current_dma_tx_buffer();
|
||||
uint8_t next_buf_num = !buf_num;
|
||||
if(infrared_tim_tx.buffer[buf_num].last_packet_end) {
|
||||
LL_DMA_DisableIT_HT(INFRARED_DMA_CH2_DEF);
|
||||
} else if(
|
||||
!infrared_tim_tx.buffer[buf_num].packet_end ||
|
||||
(furi_hal_infrared_state == InfraredStateAsyncTx)) {
|
||||
furi_hal_infrared_tx_fill_buffer(next_buf_num, 0);
|
||||
if(infrared_tim_tx.buffer[next_buf_num].last_packet_end) {
|
||||
LL_DMA_DisableIT_HT(INFRARED_DMA_CH2_DEF);
|
||||
}
|
||||
} else if(furi_hal_infrared_state == InfraredStateAsyncTxStopReq) {
|
||||
/* fallthrough */
|
||||
} else {
|
||||
furi_crash(NULL);
|
||||
}
|
||||
}
|
||||
if(LL_DMA_IsActiveFlag_TC2(INFRARED_DMA) && LL_DMA_IsEnabledIT_TC(INFRARED_DMA_CH2_DEF)) {
|
||||
LL_DMA_ClearFlag_TC2(INFRARED_DMA);
|
||||
furi_check(
|
||||
(furi_hal_infrared_state == InfraredStateAsyncTxStopInProgress) ||
|
||||
(furi_hal_infrared_state == InfraredStateAsyncTxStopReq) ||
|
||||
(furi_hal_infrared_state == InfraredStateAsyncTx));
|
||||
|
||||
uint8_t buf_num = furi_hal_infrared_get_current_dma_tx_buffer();
|
||||
uint8_t next_buf_num = !buf_num;
|
||||
if(furi_hal_infrared_state == InfraredStateAsyncTxStopInProgress) {
|
||||
furi_hal_infrared_tx_dma_terminate();
|
||||
} else if(
|
||||
infrared_tim_tx.buffer[buf_num].last_packet_end ||
|
||||
(infrared_tim_tx.buffer[buf_num].packet_end &&
|
||||
(furi_hal_infrared_state == InfraredStateAsyncTxStopReq))) {
|
||||
furi_hal_infrared_state = InfraredStateAsyncTxStopInProgress;
|
||||
furi_hal_infrared_tx_fill_buffer_last(next_buf_num);
|
||||
furi_hal_infrared_tx_dma_set_buffer(next_buf_num);
|
||||
} else {
|
||||
/* if it's not end of the packet - continue receiving */
|
||||
furi_hal_infrared_tx_dma_set_buffer(next_buf_num);
|
||||
}
|
||||
if(infrared_tim_tx.signal_sent_callback && infrared_tim_tx.buffer[buf_num].packet_end &&
|
||||
(furi_hal_infrared_state != InfraredStateAsyncTxStopped)) {
|
||||
infrared_tim_tx.signal_sent_callback(infrared_tim_tx.signal_sent_context);
|
||||
}
|
||||
}
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_configure_tim_pwm_tx(uint32_t freq, float duty_cycle) {
|
||||
LL_TIM_DisableCounter(INFRARED_DMA_TIMER);
|
||||
LL_TIM_SetRepetitionCounter(INFRARED_DMA_TIMER, 0);
|
||||
LL_TIM_SetCounter(INFRARED_DMA_TIMER, 0);
|
||||
LL_TIM_SetPrescaler(INFRARED_DMA_TIMER, 0);
|
||||
LL_TIM_SetCounterMode(INFRARED_DMA_TIMER, LL_TIM_COUNTERMODE_UP);
|
||||
LL_TIM_EnableARRPreload(INFRARED_DMA_TIMER);
|
||||
LL_TIM_SetAutoReload(
|
||||
INFRARED_DMA_TIMER,
|
||||
__LL_TIM_CALC_ARR(SystemCoreClock, LL_TIM_GetPrescaler(INFRARED_DMA_TIMER), freq));
|
||||
#if defined INFRARED_TX_DEBUG
|
||||
LL_TIM_OC_SetCompareCH1(
|
||||
INFRARED_DMA_TIMER, ((LL_TIM_GetAutoReload(INFRARED_DMA_TIMER) + 1) * (1 - duty_cycle)));
|
||||
LL_TIM_OC_EnablePreload(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH1);
|
||||
/* LL_TIM_OCMODE_PWM2 set by DMA */
|
||||
LL_TIM_OC_SetMode(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH1, LL_TIM_OCMODE_FORCED_INACTIVE);
|
||||
LL_TIM_OC_SetPolarity(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH1N, LL_TIM_OCPOLARITY_HIGH);
|
||||
LL_TIM_OC_DisableFast(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH1);
|
||||
LL_TIM_CC_EnableChannel(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH1N);
|
||||
LL_TIM_DisableIT_CC1(INFRARED_DMA_TIMER);
|
||||
#else
|
||||
LL_TIM_OC_SetCompareCH3(
|
||||
INFRARED_DMA_TIMER, ((LL_TIM_GetAutoReload(INFRARED_DMA_TIMER) + 1) * (1 - duty_cycle)));
|
||||
LL_TIM_OC_EnablePreload(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH3);
|
||||
/* LL_TIM_OCMODE_PWM2 set by DMA */
|
||||
LL_TIM_OC_SetMode(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH3, LL_TIM_OCMODE_FORCED_INACTIVE);
|
||||
LL_TIM_OC_SetPolarity(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH3N, LL_TIM_OCPOLARITY_HIGH);
|
||||
LL_TIM_OC_DisableFast(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH3);
|
||||
LL_TIM_CC_EnableChannel(INFRARED_DMA_TIMER, LL_TIM_CHANNEL_CH3N);
|
||||
LL_TIM_DisableIT_CC3(INFRARED_DMA_TIMER);
|
||||
#endif
|
||||
LL_TIM_DisableMasterSlaveMode(INFRARED_DMA_TIMER);
|
||||
LL_TIM_EnableAllOutputs(INFRARED_DMA_TIMER);
|
||||
LL_TIM_DisableIT_UPDATE(INFRARED_DMA_TIMER);
|
||||
LL_TIM_EnableDMAReq_UPDATE(INFRARED_DMA_TIMER);
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_configure_tim_cmgr2_dma_tx(void) {
|
||||
LL_DMA_InitTypeDef dma_config = {0};
|
||||
#if defined INFRARED_TX_DEBUG
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (INFRARED_DMA_TIMER->CCMR1);
|
||||
#else
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (INFRARED_DMA_TIMER->CCMR2);
|
||||
#endif
|
||||
dma_config.MemoryOrM2MDstAddress = (uint32_t)NULL;
|
||||
dma_config.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
||||
dma_config.Mode = LL_DMA_MODE_NORMAL;
|
||||
dma_config.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
||||
dma_config.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
||||
/* fill word to have other bits set to 0 */
|
||||
dma_config.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
|
||||
dma_config.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_BYTE;
|
||||
dma_config.NbData = 0;
|
||||
dma_config.PeriphRequest = LL_DMAMUX_REQ_TIM1_UP;
|
||||
dma_config.Priority = LL_DMA_PRIORITY_VERYHIGH;
|
||||
LL_DMA_Init(INFRARED_DMA_CH1_DEF, &dma_config);
|
||||
|
||||
#if INFRARED_DMA_CH1_CHANNEL == LL_DMA_CHANNEL_1
|
||||
LL_DMA_ClearFlag_TE1(INFRARED_DMA);
|
||||
LL_DMA_ClearFlag_TC1(INFRARED_DMA);
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
|
||||
LL_DMA_EnableIT_TE(INFRARED_DMA_CH1_DEF);
|
||||
LL_DMA_EnableIT_TC(INFRARED_DMA_CH1_DEF);
|
||||
|
||||
furi_hal_interrupt_set_isr_ex(
|
||||
INFRARED_DMA_CH1_IRQ, 4, furi_hal_infrared_tx_dma_polarity_isr, NULL);
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_configure_tim_rcr_dma_tx(void) {
|
||||
LL_DMA_InitTypeDef dma_config = {0};
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (INFRARED_DMA_TIMER->RCR);
|
||||
dma_config.MemoryOrM2MDstAddress = (uint32_t)NULL;
|
||||
dma_config.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
||||
dma_config.Mode = LL_DMA_MODE_NORMAL;
|
||||
dma_config.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
||||
dma_config.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
||||
dma_config.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_HALFWORD;
|
||||
dma_config.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_HALFWORD;
|
||||
dma_config.NbData = 0;
|
||||
dma_config.PeriphRequest = LL_DMAMUX_REQ_TIM1_UP;
|
||||
dma_config.Priority = LL_DMA_PRIORITY_MEDIUM;
|
||||
LL_DMA_Init(INFRARED_DMA_CH2_DEF, &dma_config);
|
||||
|
||||
#if INFRARED_DMA_CH2_CHANNEL == LL_DMA_CHANNEL_2
|
||||
LL_DMA_ClearFlag_TC2(INFRARED_DMA);
|
||||
LL_DMA_ClearFlag_HT2(INFRARED_DMA);
|
||||
LL_DMA_ClearFlag_TE2(INFRARED_DMA);
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
|
||||
LL_DMA_EnableIT_TC(INFRARED_DMA_CH2_DEF);
|
||||
LL_DMA_EnableIT_HT(INFRARED_DMA_CH2_DEF);
|
||||
LL_DMA_EnableIT_TE(INFRARED_DMA_CH2_DEF);
|
||||
|
||||
furi_hal_interrupt_set_isr_ex(INFRARED_DMA_CH2_IRQ, 5, furi_hal_infrared_tx_dma_isr, NULL);
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_tx_fill_buffer_last(uint8_t buf_num) {
|
||||
furi_assert(buf_num < 2);
|
||||
furi_assert(furi_hal_infrared_state != InfraredStateAsyncRx);
|
||||
furi_assert(furi_hal_infrared_state < InfraredStateMAX);
|
||||
furi_assert(infrared_tim_tx.data_callback);
|
||||
InfraredTxBuf* buffer = &infrared_tim_tx.buffer[buf_num];
|
||||
furi_assert(buffer->data != NULL);
|
||||
(void)buffer->data;
|
||||
furi_assert(buffer->polarity != NULL);
|
||||
(void)buffer->polarity;
|
||||
|
||||
infrared_tim_tx.buffer[buf_num].data[0] = 0; // 1 pulse
|
||||
infrared_tim_tx.buffer[buf_num].polarity[0] = INFRARED_TX_CCMR_LOW;
|
||||
infrared_tim_tx.buffer[buf_num].data[1] = 0; // 1 pulse
|
||||
infrared_tim_tx.buffer[buf_num].polarity[1] = INFRARED_TX_CCMR_LOW;
|
||||
infrared_tim_tx.buffer[buf_num].size = 2;
|
||||
infrared_tim_tx.buffer[buf_num].last_packet_end = true;
|
||||
infrared_tim_tx.buffer[buf_num].packet_end = true;
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_tx_fill_buffer(uint8_t buf_num, uint8_t polarity_shift) {
|
||||
furi_assert(buf_num < 2);
|
||||
furi_assert(furi_hal_infrared_state != InfraredStateAsyncRx);
|
||||
furi_assert(furi_hal_infrared_state < InfraredStateMAX);
|
||||
furi_assert(infrared_tim_tx.data_callback);
|
||||
InfraredTxBuf* buffer = &infrared_tim_tx.buffer[buf_num];
|
||||
furi_assert(buffer->data != NULL);
|
||||
furi_assert(buffer->polarity != NULL);
|
||||
|
||||
FuriHalInfraredTxGetDataState status = FuriHalInfraredTxGetDataStateOk;
|
||||
uint32_t duration = 0;
|
||||
bool level = 0;
|
||||
size_t* size = &buffer->size;
|
||||
size_t polarity_counter = 0;
|
||||
while(polarity_shift--) {
|
||||
buffer->polarity[polarity_counter++] = INFRARED_TX_CCMR_LOW;
|
||||
}
|
||||
|
||||
for(*size = 0; (*size < INFRARED_TIM_TX_DMA_BUFFER_SIZE) &&
|
||||
(status == FuriHalInfraredTxGetDataStateOk);) {
|
||||
if(infrared_tim_tx.tx_timing_rest_duration > 0) {
|
||||
if(infrared_tim_tx.tx_timing_rest_duration > 0xFFFF) {
|
||||
buffer->data[*size] = 0xFFFF;
|
||||
status = FuriHalInfraredTxGetDataStateOk;
|
||||
} else {
|
||||
buffer->data[*size] = infrared_tim_tx.tx_timing_rest_duration;
|
||||
status = infrared_tim_tx.tx_timing_rest_status;
|
||||
}
|
||||
infrared_tim_tx.tx_timing_rest_duration -= buffer->data[*size];
|
||||
buffer->polarity[polarity_counter] = infrared_tim_tx.tx_timing_rest_level ?
|
||||
INFRARED_TX_CCMR_HIGH :
|
||||
INFRARED_TX_CCMR_LOW;
|
||||
++(*size);
|
||||
++polarity_counter;
|
||||
continue;
|
||||
}
|
||||
|
||||
status = infrared_tim_tx.data_callback(infrared_tim_tx.data_context, &duration, &level);
|
||||
|
||||
uint32_t num_of_impulses = roundf(duration / infrared_tim_tx.cycle_duration);
|
||||
|
||||
if(num_of_impulses == 0) {
|
||||
if((*size == 0) && (status == FuriHalInfraredTxGetDataStateDone)) {
|
||||
/* if this is one sample in current buffer, but we
|
||||
* have more to send - continue
|
||||
*/
|
||||
status = FuriHalInfraredTxGetDataStateOk;
|
||||
}
|
||||
} else if((num_of_impulses - 1) > 0xFFFF) {
|
||||
infrared_tim_tx.tx_timing_rest_duration = num_of_impulses - 1;
|
||||
infrared_tim_tx.tx_timing_rest_status = status;
|
||||
infrared_tim_tx.tx_timing_rest_level = level;
|
||||
status = FuriHalInfraredTxGetDataStateOk;
|
||||
} else {
|
||||
buffer->polarity[polarity_counter] = level ? INFRARED_TX_CCMR_HIGH :
|
||||
INFRARED_TX_CCMR_LOW;
|
||||
buffer->data[*size] = num_of_impulses - 1;
|
||||
++(*size);
|
||||
++polarity_counter;
|
||||
}
|
||||
}
|
||||
|
||||
buffer->last_packet_end = (status == FuriHalInfraredTxGetDataStateLastDone);
|
||||
buffer->packet_end = buffer->last_packet_end || (status == FuriHalInfraredTxGetDataStateDone);
|
||||
|
||||
if(*size == 0) {
|
||||
buffer->data[0] = 0; // 1 pulse
|
||||
buffer->polarity[0] = INFRARED_TX_CCMR_LOW;
|
||||
buffer->size = 1;
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_tx_dma_set_polarity(uint8_t buf_num, uint8_t polarity_shift) {
|
||||
furi_assert(buf_num < 2);
|
||||
furi_assert(furi_hal_infrared_state < InfraredStateMAX);
|
||||
InfraredTxBuf* buffer = &infrared_tim_tx.buffer[buf_num];
|
||||
furi_assert(buffer->polarity != NULL);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
bool channel_enabled = LL_DMA_IsEnabledChannel(INFRARED_DMA_CH1_DEF);
|
||||
if(channel_enabled) {
|
||||
LL_DMA_DisableChannel(INFRARED_DMA_CH1_DEF);
|
||||
}
|
||||
LL_DMA_SetMemoryAddress(INFRARED_DMA_CH1_DEF, (uint32_t)buffer->polarity);
|
||||
LL_DMA_SetDataLength(INFRARED_DMA_CH1_DEF, buffer->size + polarity_shift);
|
||||
if(channel_enabled) {
|
||||
LL_DMA_EnableChannel(INFRARED_DMA_CH1_DEF);
|
||||
}
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_tx_dma_set_buffer(uint8_t buf_num) {
|
||||
furi_assert(buf_num < 2);
|
||||
furi_assert(furi_hal_infrared_state < InfraredStateMAX);
|
||||
InfraredTxBuf* buffer = &infrared_tim_tx.buffer[buf_num];
|
||||
furi_assert(buffer->data != NULL);
|
||||
|
||||
/* non-circular mode requires disabled channel before setup */
|
||||
FURI_CRITICAL_ENTER();
|
||||
bool channel_enabled = LL_DMA_IsEnabledChannel(INFRARED_DMA_CH2_DEF);
|
||||
if(channel_enabled) {
|
||||
LL_DMA_DisableChannel(INFRARED_DMA_CH2_DEF);
|
||||
}
|
||||
LL_DMA_SetMemoryAddress(INFRARED_DMA_CH2_DEF, (uint32_t)buffer->data);
|
||||
LL_DMA_SetDataLength(INFRARED_DMA_CH2_DEF, buffer->size);
|
||||
if(channel_enabled) {
|
||||
LL_DMA_EnableChannel(INFRARED_DMA_CH2_DEF);
|
||||
}
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
static void furi_hal_infrared_async_tx_free_resources(void) {
|
||||
furi_assert(
|
||||
(furi_hal_infrared_state == InfraredStateIdle) ||
|
||||
(furi_hal_infrared_state == InfraredStateAsyncTxStopped));
|
||||
|
||||
furi_hal_gpio_init(&gpio_infrared_tx, GpioModeAnalog, GpioPullDown, GpioSpeedLow);
|
||||
furi_hal_interrupt_set_isr(INFRARED_DMA_CH1_IRQ, NULL, NULL);
|
||||
furi_hal_interrupt_set_isr(INFRARED_DMA_CH2_IRQ, NULL, NULL);
|
||||
|
||||
furi_hal_bus_disable(INFRARED_DMA_TIMER_BUS);
|
||||
|
||||
furi_semaphore_free(infrared_tim_tx.stop_semaphore);
|
||||
free(infrared_tim_tx.buffer[0].data);
|
||||
free(infrared_tim_tx.buffer[1].data);
|
||||
free(infrared_tim_tx.buffer[0].polarity);
|
||||
free(infrared_tim_tx.buffer[1].polarity);
|
||||
|
||||
infrared_tim_tx.buffer[0].data = NULL;
|
||||
infrared_tim_tx.buffer[1].data = NULL;
|
||||
infrared_tim_tx.buffer[0].polarity = NULL;
|
||||
infrared_tim_tx.buffer[1].polarity = NULL;
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_tx_start(uint32_t freq, float duty_cycle) {
|
||||
if((duty_cycle > 1) || (duty_cycle <= 0) || (freq > INFRARED_MAX_FREQUENCY) ||
|
||||
(freq < INFRARED_MIN_FREQUENCY) || (infrared_tim_tx.data_callback == NULL)) {
|
||||
furi_crash(NULL);
|
||||
}
|
||||
|
||||
furi_assert(furi_hal_infrared_state == InfraredStateIdle);
|
||||
furi_assert(infrared_tim_tx.buffer[0].data == NULL);
|
||||
furi_assert(infrared_tim_tx.buffer[1].data == NULL);
|
||||
furi_assert(infrared_tim_tx.buffer[0].polarity == NULL);
|
||||
furi_assert(infrared_tim_tx.buffer[1].polarity == NULL);
|
||||
|
||||
size_t alloc_size_data = INFRARED_TIM_TX_DMA_BUFFER_SIZE * sizeof(uint16_t);
|
||||
infrared_tim_tx.buffer[0].data = malloc(alloc_size_data);
|
||||
infrared_tim_tx.buffer[1].data = malloc(alloc_size_data);
|
||||
|
||||
size_t alloc_size_polarity =
|
||||
(INFRARED_TIM_TX_DMA_BUFFER_SIZE + INFRARED_POLARITY_SHIFT) * sizeof(uint8_t);
|
||||
infrared_tim_tx.buffer[0].polarity = malloc(alloc_size_polarity);
|
||||
infrared_tim_tx.buffer[1].polarity = malloc(alloc_size_polarity);
|
||||
|
||||
infrared_tim_tx.stop_semaphore = furi_semaphore_alloc(1, 0);
|
||||
infrared_tim_tx.cycle_duration = 1000000.0 / freq;
|
||||
infrared_tim_tx.tx_timing_rest_duration = 0;
|
||||
|
||||
furi_hal_infrared_tx_fill_buffer(0, INFRARED_POLARITY_SHIFT);
|
||||
|
||||
furi_hal_bus_enable(INFRARED_DMA_TIMER_BUS);
|
||||
|
||||
furi_hal_infrared_configure_tim_pwm_tx(freq, duty_cycle);
|
||||
furi_hal_infrared_configure_tim_cmgr2_dma_tx();
|
||||
furi_hal_infrared_configure_tim_rcr_dma_tx();
|
||||
furi_hal_infrared_tx_dma_set_polarity(0, INFRARED_POLARITY_SHIFT);
|
||||
furi_hal_infrared_tx_dma_set_buffer(0);
|
||||
|
||||
furi_hal_infrared_state = InfraredStateAsyncTx;
|
||||
|
||||
LL_TIM_ClearFlag_UPDATE(INFRARED_DMA_TIMER);
|
||||
LL_DMA_EnableChannel(INFRARED_DMA_CH1_DEF);
|
||||
LL_DMA_EnableChannel(INFRARED_DMA_CH2_DEF);
|
||||
furi_delay_us(5);
|
||||
LL_TIM_GenerateEvent_UPDATE(INFRARED_DMA_TIMER); /* DMA -> TIMx_RCR */
|
||||
furi_delay_us(5);
|
||||
LL_GPIO_ResetOutputPin(
|
||||
gpio_infrared_tx.port, gpio_infrared_tx.pin); /* when disable it prevents false pulse */
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_infrared_tx, GpioModeAltFunctionPushPull, GpioPullUp, GpioSpeedHigh, GpioAltFn1TIM1);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
LL_TIM_GenerateEvent_UPDATE(INFRARED_DMA_TIMER); /* TIMx_RCR -> Repetition counter */
|
||||
LL_TIM_EnableCounter(INFRARED_DMA_TIMER);
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_tx_wait_termination(void) {
|
||||
furi_assert(furi_hal_infrared_state >= InfraredStateAsyncTx);
|
||||
furi_assert(furi_hal_infrared_state < InfraredStateMAX);
|
||||
|
||||
FuriStatus status;
|
||||
status = furi_semaphore_acquire(infrared_tim_tx.stop_semaphore, FuriWaitForever);
|
||||
furi_check(status == FuriStatusOk);
|
||||
furi_hal_infrared_async_tx_free_resources();
|
||||
furi_hal_infrared_state = InfraredStateIdle;
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_tx_stop(void) {
|
||||
furi_assert(furi_hal_infrared_state >= InfraredStateAsyncTx);
|
||||
furi_assert(furi_hal_infrared_state < InfraredStateMAX);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
if(furi_hal_infrared_state == InfraredStateAsyncTx)
|
||||
furi_hal_infrared_state = InfraredStateAsyncTxStopReq;
|
||||
FURI_CRITICAL_EXIT();
|
||||
|
||||
furi_hal_infrared_async_tx_wait_termination();
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_tx_set_data_isr_callback(
|
||||
FuriHalInfraredTxGetDataISRCallback callback,
|
||||
void* context) {
|
||||
furi_assert(furi_hal_infrared_state == InfraredStateIdle);
|
||||
infrared_tim_tx.data_callback = callback;
|
||||
infrared_tim_tx.data_context = context;
|
||||
}
|
||||
|
||||
void furi_hal_infrared_async_tx_set_signal_sent_isr_callback(
|
||||
FuriHalInfraredTxSignalSentISRCallback callback,
|
||||
void* context) {
|
||||
infrared_tim_tx.signal_sent_callback = callback;
|
||||
infrared_tim_tx.signal_sent_context = context;
|
||||
}
|
||||
@@ -0,0 +1,330 @@
|
||||
#include <furi_hal_interrupt.h>
|
||||
#include <furi_hal_os.h>
|
||||
|
||||
#include <furi.h>
|
||||
|
||||
#include <stm32wbxx.h>
|
||||
#include <stm32wbxx_ll_tim.h>
|
||||
#include <stm32wbxx_ll_rcc.h>
|
||||
#include <stm32wbxx_ll_cortex.h>
|
||||
|
||||
#define TAG "FuriHalInterrupt"
|
||||
|
||||
#define FURI_HAL_INTERRUPT_DEFAULT_PRIORITY 5
|
||||
|
||||
typedef struct {
|
||||
FuriHalInterruptISR isr;
|
||||
void* context;
|
||||
} FuriHalInterruptISRPair;
|
||||
|
||||
FuriHalInterruptISRPair furi_hal_interrupt_isr[FuriHalInterruptIdMax] = {0};
|
||||
|
||||
const IRQn_Type furi_hal_interrupt_irqn[FuriHalInterruptIdMax] = {
|
||||
// TIM1, TIM16, TIM17
|
||||
[FuriHalInterruptIdTim1TrgComTim17] = TIM1_TRG_COM_TIM17_IRQn,
|
||||
[FuriHalInterruptIdTim1Cc] = TIM1_CC_IRQn,
|
||||
[FuriHalInterruptIdTim1UpTim16] = TIM1_UP_TIM16_IRQn,
|
||||
|
||||
// TIM2
|
||||
[FuriHalInterruptIdTIM2] = TIM2_IRQn,
|
||||
|
||||
// DMA1
|
||||
[FuriHalInterruptIdDma1Ch1] = DMA1_Channel1_IRQn,
|
||||
[FuriHalInterruptIdDma1Ch2] = DMA1_Channel2_IRQn,
|
||||
[FuriHalInterruptIdDma1Ch3] = DMA1_Channel3_IRQn,
|
||||
[FuriHalInterruptIdDma1Ch4] = DMA1_Channel4_IRQn,
|
||||
[FuriHalInterruptIdDma1Ch5] = DMA1_Channel5_IRQn,
|
||||
[FuriHalInterruptIdDma1Ch6] = DMA1_Channel6_IRQn,
|
||||
[FuriHalInterruptIdDma1Ch7] = DMA1_Channel7_IRQn,
|
||||
|
||||
// DMA2
|
||||
[FuriHalInterruptIdDma2Ch1] = DMA2_Channel1_IRQn,
|
||||
[FuriHalInterruptIdDma2Ch2] = DMA2_Channel2_IRQn,
|
||||
[FuriHalInterruptIdDma2Ch3] = DMA2_Channel3_IRQn,
|
||||
[FuriHalInterruptIdDma2Ch4] = DMA2_Channel4_IRQn,
|
||||
[FuriHalInterruptIdDma2Ch5] = DMA2_Channel5_IRQn,
|
||||
[FuriHalInterruptIdDma2Ch6] = DMA2_Channel6_IRQn,
|
||||
[FuriHalInterruptIdDma2Ch7] = DMA2_Channel7_IRQn,
|
||||
|
||||
// RCC
|
||||
[FuriHalInterruptIdRcc] = RCC_IRQn,
|
||||
|
||||
// COMP
|
||||
[FuriHalInterruptIdCOMP] = COMP_IRQn,
|
||||
|
||||
// HSEM
|
||||
[FuriHalInterruptIdHsem] = HSEM_IRQn,
|
||||
|
||||
// LPTIMx
|
||||
[FuriHalInterruptIdLpTim1] = LPTIM1_IRQn,
|
||||
[FuriHalInterruptIdLpTim2] = LPTIM2_IRQn,
|
||||
};
|
||||
|
||||
__attribute__((always_inline)) static inline void
|
||||
furi_hal_interrupt_call(FuriHalInterruptId index) {
|
||||
furi_check(furi_hal_interrupt_isr[index].isr);
|
||||
furi_hal_interrupt_isr[index].isr(furi_hal_interrupt_isr[index].context);
|
||||
}
|
||||
|
||||
__attribute__((always_inline)) static inline void
|
||||
furi_hal_interrupt_enable(FuriHalInterruptId index, uint16_t priority) {
|
||||
NVIC_SetPriority(
|
||||
furi_hal_interrupt_irqn[index],
|
||||
NVIC_EncodePriority(NVIC_GetPriorityGrouping(), priority, 0));
|
||||
NVIC_EnableIRQ(furi_hal_interrupt_irqn[index]);
|
||||
}
|
||||
|
||||
__attribute__((always_inline)) static inline void
|
||||
furi_hal_interrupt_clear_pending(FuriHalInterruptId index) {
|
||||
NVIC_ClearPendingIRQ(furi_hal_interrupt_irqn[index]);
|
||||
}
|
||||
|
||||
__attribute__((always_inline)) static inline void
|
||||
furi_hal_interrupt_get_pending(FuriHalInterruptId index) {
|
||||
NVIC_GetPendingIRQ(furi_hal_interrupt_irqn[index]);
|
||||
}
|
||||
|
||||
__attribute__((always_inline)) static inline void
|
||||
furi_hal_interrupt_set_pending(FuriHalInterruptId index) {
|
||||
NVIC_SetPendingIRQ(furi_hal_interrupt_irqn[index]);
|
||||
}
|
||||
|
||||
__attribute__((always_inline)) static inline void
|
||||
furi_hal_interrupt_disable(FuriHalInterruptId index) {
|
||||
NVIC_DisableIRQ(furi_hal_interrupt_irqn[index]);
|
||||
}
|
||||
|
||||
void furi_hal_interrupt_init() {
|
||||
NVIC_SetPriority(
|
||||
TAMP_STAMP_LSECSS_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 0, 0));
|
||||
NVIC_EnableIRQ(TAMP_STAMP_LSECSS_IRQn);
|
||||
|
||||
NVIC_SetPriority(PendSV_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 15, 0));
|
||||
|
||||
NVIC_SetPriority(FPU_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 15, 0));
|
||||
NVIC_EnableIRQ(FPU_IRQn);
|
||||
|
||||
LL_SYSCFG_DisableIT_FPU_IOC();
|
||||
LL_SYSCFG_DisableIT_FPU_DZC();
|
||||
LL_SYSCFG_DisableIT_FPU_UFC();
|
||||
LL_SYSCFG_DisableIT_FPU_OFC();
|
||||
LL_SYSCFG_DisableIT_FPU_IDC();
|
||||
LL_SYSCFG_DisableIT_FPU_IXC();
|
||||
|
||||
LL_HANDLER_EnableFault(LL_HANDLER_FAULT_USG);
|
||||
LL_HANDLER_EnableFault(LL_HANDLER_FAULT_BUS);
|
||||
LL_HANDLER_EnableFault(LL_HANDLER_FAULT_MEM);
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
void furi_hal_interrupt_set_isr(FuriHalInterruptId index, FuriHalInterruptISR isr, void* context) {
|
||||
furi_hal_interrupt_set_isr_ex(index, FURI_HAL_INTERRUPT_DEFAULT_PRIORITY, isr, context);
|
||||
}
|
||||
|
||||
void furi_hal_interrupt_set_isr_ex(
|
||||
FuriHalInterruptId index,
|
||||
uint16_t priority,
|
||||
FuriHalInterruptISR isr,
|
||||
void* context) {
|
||||
furi_check(index < FuriHalInterruptIdMax);
|
||||
furi_check(priority <= 15);
|
||||
|
||||
if(isr) {
|
||||
// Pre ISR set
|
||||
furi_check(furi_hal_interrupt_isr[index].isr == NULL);
|
||||
} else {
|
||||
// Pre ISR clear
|
||||
furi_hal_interrupt_disable(index);
|
||||
furi_hal_interrupt_clear_pending(index);
|
||||
}
|
||||
|
||||
furi_hal_interrupt_isr[index].isr = isr;
|
||||
furi_hal_interrupt_isr[index].context = context;
|
||||
__DMB();
|
||||
|
||||
if(isr) {
|
||||
// Post ISR set
|
||||
furi_hal_interrupt_clear_pending(index);
|
||||
furi_hal_interrupt_enable(index, priority);
|
||||
} else {
|
||||
// Post ISR clear
|
||||
}
|
||||
}
|
||||
|
||||
/* Timer 2 */
|
||||
void TIM2_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdTIM2);
|
||||
}
|
||||
|
||||
/* Timer 1 Update */
|
||||
void TIM1_UP_TIM16_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdTim1UpTim16);
|
||||
}
|
||||
|
||||
void TIM1_TRG_COM_TIM17_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdTim1TrgComTim17);
|
||||
}
|
||||
|
||||
void TIM1_CC_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdTim1Cc);
|
||||
}
|
||||
|
||||
/* DMA 1 */
|
||||
void DMA1_Channel1_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma1Ch1);
|
||||
}
|
||||
|
||||
void DMA1_Channel2_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma1Ch2);
|
||||
}
|
||||
|
||||
void DMA1_Channel3_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma1Ch3);
|
||||
}
|
||||
|
||||
void DMA1_Channel4_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma1Ch4);
|
||||
}
|
||||
|
||||
void DMA1_Channel5_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma1Ch5);
|
||||
}
|
||||
|
||||
void DMA1_Channel6_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma1Ch6);
|
||||
}
|
||||
|
||||
void DMA1_Channel7_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma1Ch7);
|
||||
}
|
||||
|
||||
/* DMA 2 */
|
||||
void DMA2_Channel1_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma2Ch1);
|
||||
}
|
||||
|
||||
void DMA2_Channel2_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma2Ch2);
|
||||
}
|
||||
|
||||
void DMA2_Channel3_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma2Ch3);
|
||||
}
|
||||
|
||||
void DMA2_Channel4_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma2Ch4);
|
||||
}
|
||||
|
||||
void DMA2_Channel5_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma2Ch5);
|
||||
}
|
||||
|
||||
void DMA2_Channel6_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma2Ch6);
|
||||
}
|
||||
|
||||
void DMA2_Channel7_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdDma2Ch7);
|
||||
}
|
||||
|
||||
void HSEM_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdHsem);
|
||||
}
|
||||
|
||||
void TAMP_STAMP_LSECSS_IRQHandler(void) {
|
||||
if(LL_RCC_IsActiveFlag_LSECSS()) {
|
||||
LL_RCC_ClearFlag_LSECSS();
|
||||
if(!LL_RCC_LSE_IsReady()) {
|
||||
FURI_LOG_E(TAG, "LSE CSS fired: resetting system");
|
||||
NVIC_SystemReset();
|
||||
} else {
|
||||
FURI_LOG_E(TAG, "LSE CSS fired: but LSE is alive");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void RCC_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdRcc);
|
||||
}
|
||||
|
||||
void NMI_Handler() {
|
||||
if(LL_RCC_IsActiveFlag_HSECSS()) {
|
||||
LL_RCC_ClearFlag_HSECSS();
|
||||
FURI_LOG_E(TAG, "HSE CSS fired: resetting system");
|
||||
NVIC_SystemReset();
|
||||
}
|
||||
}
|
||||
|
||||
void HardFault_Handler() {
|
||||
furi_crash("HardFault");
|
||||
}
|
||||
|
||||
void MemManage_Handler() {
|
||||
if(FURI_BIT(SCB->CFSR, SCB_CFSR_MMARVALID_Pos)) {
|
||||
uint32_t memfault_address = SCB->MMFAR;
|
||||
if(memfault_address < (1024 * 1024)) {
|
||||
// from 0x00 to 1MB, see FuriHalMpuRegionNULL
|
||||
furi_crash("NULL pointer dereference");
|
||||
} else {
|
||||
// write or read of MPU region 1 (FuriHalMpuRegionStack)
|
||||
furi_crash("MPU fault, possibly stack overflow");
|
||||
}
|
||||
} else if(FURI_BIT(SCB->CFSR, SCB_CFSR_MSTKERR_Pos)) {
|
||||
// push to stack on MPU region 1 (FuriHalMpuRegionStack)
|
||||
furi_crash("MemManage fault, possibly stack overflow");
|
||||
}
|
||||
|
||||
furi_crash("MemManage");
|
||||
}
|
||||
|
||||
void BusFault_Handler() {
|
||||
furi_crash("BusFault");
|
||||
}
|
||||
|
||||
void UsageFault_Handler() {
|
||||
furi_crash("UsageFault");
|
||||
}
|
||||
|
||||
void DebugMon_Handler() {
|
||||
}
|
||||
|
||||
#include "usbd_core.h"
|
||||
|
||||
extern usbd_device udev;
|
||||
|
||||
extern void HW_IPCC_Tx_Handler();
|
||||
extern void HW_IPCC_Rx_Handler();
|
||||
|
||||
void SysTick_Handler() {
|
||||
furi_hal_os_tick();
|
||||
}
|
||||
|
||||
void USB_LP_IRQHandler() {
|
||||
#ifndef FURI_RAM_EXEC
|
||||
usbd_poll(&udev);
|
||||
#endif
|
||||
}
|
||||
|
||||
void USB_HP_IRQHandler() {
|
||||
}
|
||||
|
||||
void IPCC_C1_TX_IRQHandler() {
|
||||
HW_IPCC_Tx_Handler();
|
||||
}
|
||||
|
||||
void IPCC_C1_RX_IRQHandler() {
|
||||
HW_IPCC_Rx_Handler();
|
||||
}
|
||||
|
||||
void FPU_IRQHandler() {
|
||||
furi_crash("FpuFault");
|
||||
}
|
||||
|
||||
void LPTIM1_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdLpTim1);
|
||||
}
|
||||
|
||||
void LPTIM2_IRQHandler() {
|
||||
furi_hal_interrupt_call(FuriHalInterruptIdLpTim2);
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
#pragma once
|
||||
|
||||
#include <stm32wbxx_ll_tim.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** Timer ISR */
|
||||
typedef void (*FuriHalInterruptISR)(void* context);
|
||||
|
||||
typedef enum {
|
||||
// TIM1, TIM16, TIM17
|
||||
FuriHalInterruptIdTim1TrgComTim17,
|
||||
FuriHalInterruptIdTim1Cc,
|
||||
FuriHalInterruptIdTim1UpTim16,
|
||||
|
||||
// TIM2
|
||||
FuriHalInterruptIdTIM2,
|
||||
|
||||
// DMA1
|
||||
FuriHalInterruptIdDma1Ch1,
|
||||
FuriHalInterruptIdDma1Ch2,
|
||||
FuriHalInterruptIdDma1Ch3,
|
||||
FuriHalInterruptIdDma1Ch4,
|
||||
FuriHalInterruptIdDma1Ch5,
|
||||
FuriHalInterruptIdDma1Ch6,
|
||||
FuriHalInterruptIdDma1Ch7,
|
||||
|
||||
// DMA2
|
||||
FuriHalInterruptIdDma2Ch1,
|
||||
FuriHalInterruptIdDma2Ch2,
|
||||
FuriHalInterruptIdDma2Ch3,
|
||||
FuriHalInterruptIdDma2Ch4,
|
||||
FuriHalInterruptIdDma2Ch5,
|
||||
FuriHalInterruptIdDma2Ch6,
|
||||
FuriHalInterruptIdDma2Ch7,
|
||||
|
||||
// RCC
|
||||
FuriHalInterruptIdRcc,
|
||||
|
||||
// Comp
|
||||
FuriHalInterruptIdCOMP,
|
||||
|
||||
// HSEM
|
||||
FuriHalInterruptIdHsem,
|
||||
|
||||
// LPTIMx
|
||||
FuriHalInterruptIdLpTim1,
|
||||
FuriHalInterruptIdLpTim2,
|
||||
|
||||
// Service value
|
||||
FuriHalInterruptIdMax,
|
||||
} FuriHalInterruptId;
|
||||
|
||||
/** Initialize interrupt subsystem */
|
||||
void furi_hal_interrupt_init();
|
||||
|
||||
/** Set ISR and enable interrupt with default priority
|
||||
* We don't clear interrupt flags for you, do it by your self.
|
||||
* @param index - interrupt ID
|
||||
* @param isr - your interrupt service routine or use NULL to clear
|
||||
* @param context - isr context
|
||||
*/
|
||||
void furi_hal_interrupt_set_isr(FuriHalInterruptId index, FuriHalInterruptISR isr, void* context);
|
||||
|
||||
/** Set ISR and enable interrupt with custom priority
|
||||
* We don't clear interrupt flags for you, do it by your self.
|
||||
* @param index - interrupt ID
|
||||
* @param priority - 0 to 15, 0 highest
|
||||
* @param isr - your interrupt service routine or use NULL to clear
|
||||
* @param context - isr context
|
||||
*/
|
||||
void furi_hal_interrupt_set_isr_ex(
|
||||
FuriHalInterruptId index,
|
||||
uint16_t priority,
|
||||
FuriHalInterruptISR isr,
|
||||
void* context);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,116 @@
|
||||
#include <core/common_defines.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_light.h>
|
||||
#include <lp5562.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#define LED_CURRENT_RED 50
|
||||
#define LED_CURRENT_GREEN 50
|
||||
#define LED_CURRENT_BLUE 50
|
||||
#define LED_CURRENT_WHITE 150
|
||||
|
||||
void furi_hal_light_init() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
|
||||
lp5562_reset(&furi_hal_i2c_handle_power);
|
||||
|
||||
lp5562_set_channel_current(&furi_hal_i2c_handle_power, LP5562ChannelRed, LED_CURRENT_RED);
|
||||
lp5562_set_channel_current(&furi_hal_i2c_handle_power, LP5562ChannelGreen, LED_CURRENT_GREEN);
|
||||
lp5562_set_channel_current(&furi_hal_i2c_handle_power, LP5562ChannelBlue, LED_CURRENT_BLUE);
|
||||
lp5562_set_channel_current(&furi_hal_i2c_handle_power, LP5562ChannelWhite, LED_CURRENT_WHITE);
|
||||
|
||||
lp5562_set_channel_value(&furi_hal_i2c_handle_power, LP5562ChannelRed, 0x00);
|
||||
lp5562_set_channel_value(&furi_hal_i2c_handle_power, LP5562ChannelGreen, 0x00);
|
||||
lp5562_set_channel_value(&furi_hal_i2c_handle_power, LP5562ChannelBlue, 0x00);
|
||||
lp5562_set_channel_value(&furi_hal_i2c_handle_power, LP5562ChannelWhite, 0x00);
|
||||
|
||||
lp5562_enable(&furi_hal_i2c_handle_power);
|
||||
lp5562_configure(&furi_hal_i2c_handle_power);
|
||||
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
|
||||
void furi_hal_light_set(Light light, uint8_t value) {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
if(light & LightRed) {
|
||||
lp5562_set_channel_value(&furi_hal_i2c_handle_power, LP5562ChannelRed, value);
|
||||
}
|
||||
if(light & LightGreen) {
|
||||
lp5562_set_channel_value(&furi_hal_i2c_handle_power, LP5562ChannelGreen, value);
|
||||
}
|
||||
if(light & LightBlue) {
|
||||
lp5562_set_channel_value(&furi_hal_i2c_handle_power, LP5562ChannelBlue, value);
|
||||
}
|
||||
if(light & LightBacklight) {
|
||||
uint8_t prev = lp5562_get_channel_value(&furi_hal_i2c_handle_power, LP5562ChannelWhite);
|
||||
lp5562_execute_ramp(
|
||||
&furi_hal_i2c_handle_power, LP5562Engine1, LP5562ChannelWhite, prev, value, 100);
|
||||
}
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
|
||||
void furi_hal_light_blink_start(Light light, uint8_t brightness, uint16_t on_time, uint16_t period) {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
lp5562_set_channel_src(
|
||||
&furi_hal_i2c_handle_power,
|
||||
LP5562ChannelRed | LP5562ChannelGreen | LP5562ChannelBlue,
|
||||
LP5562Direct);
|
||||
LP5562Channel led_ch = 0;
|
||||
if(light & LightRed) led_ch |= LP5562ChannelRed;
|
||||
if(light & LightGreen) led_ch |= LP5562ChannelGreen;
|
||||
if(light & LightBlue) led_ch |= LP5562ChannelBlue;
|
||||
lp5562_execute_blink(
|
||||
&furi_hal_i2c_handle_power, LP5562Engine2, led_ch, on_time, period, brightness);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
|
||||
void furi_hal_light_blink_stop() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
lp5562_set_channel_src(
|
||||
&furi_hal_i2c_handle_power,
|
||||
LP5562ChannelRed | LP5562ChannelGreen | LP5562ChannelBlue,
|
||||
LP5562Direct);
|
||||
lp5562_stop_program(&furi_hal_i2c_handle_power, LP5562Engine2);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
|
||||
void furi_hal_light_blink_set_color(Light light) {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
LP5562Channel led_ch = 0;
|
||||
lp5562_set_channel_src(
|
||||
&furi_hal_i2c_handle_power,
|
||||
LP5562ChannelRed | LP5562ChannelGreen | LP5562ChannelBlue,
|
||||
LP5562Direct);
|
||||
if(light & LightRed) led_ch |= LP5562ChannelRed;
|
||||
if(light & LightGreen) led_ch |= LP5562ChannelGreen;
|
||||
if(light & LightBlue) led_ch |= LP5562ChannelBlue;
|
||||
lp5562_set_channel_src(&furi_hal_i2c_handle_power, led_ch, LP5562Engine2);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
|
||||
void furi_hal_light_sequence(const char* sequence) {
|
||||
do {
|
||||
if(*sequence == 'R') {
|
||||
furi_hal_light_set(LightRed, 0xFF);
|
||||
} else if(*sequence == 'r') {
|
||||
furi_hal_light_set(LightRed, 0x00);
|
||||
} else if(*sequence == 'G') {
|
||||
furi_hal_light_set(LightGreen, 0xFF);
|
||||
} else if(*sequence == 'g') {
|
||||
furi_hal_light_set(LightGreen, 0x00);
|
||||
} else if(*sequence == 'B') {
|
||||
furi_hal_light_set(LightBlue, 0xFF);
|
||||
} else if(*sequence == 'b') {
|
||||
furi_hal_light_set(LightBlue, 0x00);
|
||||
} else if(*sequence == 'W') {
|
||||
furi_hal_light_set(LightBacklight, 0xFF);
|
||||
} else if(*sequence == 'w') {
|
||||
furi_hal_light_set(LightBacklight, 0x00);
|
||||
} else if(*sequence == '.') {
|
||||
furi_delay_ms(250);
|
||||
} else if(*sequence == '-') {
|
||||
furi_delay_ms(500);
|
||||
}
|
||||
sequence++;
|
||||
} while(*sequence != 0);
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
#include <furi_hal.h>
|
||||
#include <furi_hal_memory.h>
|
||||
#include <furi_hal_rtc.h>
|
||||
|
||||
#define TAG "FuriHalMemory"
|
||||
|
||||
typedef enum {
|
||||
SRAM_A,
|
||||
SRAM_B,
|
||||
SRAM_MAX,
|
||||
} SRAM;
|
||||
|
||||
typedef struct {
|
||||
void* start;
|
||||
uint32_t size;
|
||||
} FuriHalMemoryRegion;
|
||||
|
||||
typedef struct {
|
||||
FuriHalMemoryRegion region[SRAM_MAX];
|
||||
} FuriHalMemory;
|
||||
|
||||
static FuriHalMemory* furi_hal_memory = NULL;
|
||||
|
||||
extern const void __sram2a_start__;
|
||||
extern const void __sram2a_free__;
|
||||
extern const void __sram2b_start__;
|
||||
|
||||
void furi_hal_memory_init() {
|
||||
if(furi_hal_rtc_get_boot_mode() != FuriHalRtcBootModeNormal) {
|
||||
return;
|
||||
}
|
||||
|
||||
FuriHalMemory* memory = malloc(sizeof(FuriHalMemory));
|
||||
|
||||
uint32_t sbrsa = (FLASH->SRRVR & FLASH_SRRVR_SBRSA_Msk) >> FLASH_SRRVR_SBRSA_Pos;
|
||||
uint32_t snbrsa = (FLASH->SRRVR & FLASH_SRRVR_SNBRSA_Msk) >> FLASH_SRRVR_SNBRSA_Pos;
|
||||
|
||||
// STM(TM) Copro(TM) bug(TM): SNBRSA is incorrect if stack version is higher than 1.13 and lower than 1.17.2+
|
||||
// Radio core started, but not yet ready, so we'll try to guess
|
||||
// This will be true only if BLE light radio stack used,
|
||||
// 0x0D is known to be incorrect, 0x0B is known to be correct since 1.17.2+
|
||||
// Lower value by 2 pages to match real memory layout
|
||||
if(snbrsa > 0x0B) {
|
||||
FURI_LOG_E(TAG, "SNBRSA workaround");
|
||||
snbrsa -= 2;
|
||||
}
|
||||
|
||||
uint32_t sram2a_busy_size = (uint32_t)&__sram2a_free__ - (uint32_t)&__sram2a_start__;
|
||||
uint32_t sram2a_unprotected_size = (sbrsa)*1024;
|
||||
uint32_t sram2b_unprotected_size = (snbrsa)*1024;
|
||||
|
||||
memory->region[SRAM_A].start = (uint8_t*)&__sram2a_free__;
|
||||
memory->region[SRAM_B].start = (uint8_t*)&__sram2b_start__;
|
||||
|
||||
if(sram2a_unprotected_size > sram2a_busy_size) {
|
||||
memory->region[SRAM_A].size = sram2a_unprotected_size - sram2a_busy_size;
|
||||
} else {
|
||||
memory->region[SRAM_A].size = 0;
|
||||
}
|
||||
memory->region[SRAM_B].size = sram2b_unprotected_size;
|
||||
|
||||
FURI_LOG_I(
|
||||
TAG, "SRAM2A: 0x%p, %lu", memory->region[SRAM_A].start, memory->region[SRAM_A].size);
|
||||
FURI_LOG_I(
|
||||
TAG, "SRAM2B: 0x%p, %lu", memory->region[SRAM_B].start, memory->region[SRAM_B].size);
|
||||
|
||||
if((memory->region[SRAM_A].size > 0) || (memory->region[SRAM_B].size > 0)) {
|
||||
if((memory->region[SRAM_A].size > 0)) {
|
||||
FURI_LOG_I(TAG, "SRAM2A clear");
|
||||
memset(memory->region[SRAM_A].start, 0, memory->region[SRAM_A].size);
|
||||
}
|
||||
if((memory->region[SRAM_B].size > 0)) {
|
||||
FURI_LOG_I(TAG, "SRAM2B clear");
|
||||
memset(memory->region[SRAM_B].start, 0, memory->region[SRAM_B].size);
|
||||
}
|
||||
furi_hal_memory = memory;
|
||||
FURI_LOG_I(TAG, "Enabled");
|
||||
} else {
|
||||
free(memory);
|
||||
FURI_LOG_E(TAG, "No SRAM2 available");
|
||||
}
|
||||
}
|
||||
|
||||
void* furi_hal_memory_alloc(size_t size) {
|
||||
if(FURI_IS_IRQ_MODE()) {
|
||||
furi_crash("memmgt in ISR");
|
||||
}
|
||||
|
||||
if(furi_hal_memory == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void* allocated_memory = NULL;
|
||||
FURI_CRITICAL_ENTER();
|
||||
for(int i = 0; i < SRAM_MAX; i++) {
|
||||
if(furi_hal_memory->region[i].size >= size) {
|
||||
void* ptr = furi_hal_memory->region[i].start;
|
||||
furi_hal_memory->region[i].start += size;
|
||||
furi_hal_memory->region[i].size -= size;
|
||||
allocated_memory = ptr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
FURI_CRITICAL_EXIT();
|
||||
|
||||
return allocated_memory;
|
||||
}
|
||||
|
||||
size_t furi_hal_memory_get_free() {
|
||||
if(furi_hal_memory == NULL) return 0;
|
||||
|
||||
size_t free = 0;
|
||||
for(int i = 0; i < SRAM_MAX; i++) {
|
||||
free += furi_hal_memory->region[i].size;
|
||||
}
|
||||
return free;
|
||||
}
|
||||
|
||||
size_t furi_hal_memory_max_pool_block() {
|
||||
if(furi_hal_memory == NULL) return 0;
|
||||
|
||||
size_t max = 0;
|
||||
for(int i = 0; i < SRAM_MAX; i++) {
|
||||
if(furi_hal_memory->region[i].size > max) {
|
||||
max = furi_hal_memory->region[i].size;
|
||||
}
|
||||
}
|
||||
return max;
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
#include <furi_hal_mpu.h>
|
||||
#include <stm32wbxx_ll_cortex.h>
|
||||
|
||||
#define FURI_HAL_MPU_ATTRIBUTES \
|
||||
(LL_MPU_ACCESS_BUFFERABLE | LL_MPU_ACCESS_CACHEABLE | LL_MPU_ACCESS_SHAREABLE | \
|
||||
LL_MPU_TEX_LEVEL1 | LL_MPU_INSTRUCTION_ACCESS_ENABLE)
|
||||
|
||||
#define FURI_HAL_MPU_STACK_PROTECT_REGION FuriHalMPURegionSize32B
|
||||
|
||||
void furi_hal_mpu_init() {
|
||||
furi_hal_mpu_enable();
|
||||
|
||||
// NULL pointer dereference protection
|
||||
furi_hal_mpu_protect_no_access(FuriHalMpuRegionNULL, 0x00, FuriHalMPURegionSize1MB);
|
||||
}
|
||||
|
||||
void furi_hal_mpu_enable() {
|
||||
LL_MPU_Enable(LL_MPU_CTRL_PRIVILEGED_DEFAULT);
|
||||
}
|
||||
|
||||
void furi_hal_mpu_disable() {
|
||||
LL_MPU_Disable();
|
||||
}
|
||||
|
||||
void furi_hal_mpu_protect_no_access(
|
||||
FuriHalMpuRegion region,
|
||||
uint32_t address,
|
||||
FuriHalMPURegionSize size) {
|
||||
uint32_t size_ll = size;
|
||||
size_ll = size_ll << MPU_RASR_SIZE_Pos;
|
||||
|
||||
furi_hal_mpu_disable();
|
||||
LL_MPU_ConfigRegion(
|
||||
region, 0x00, address, FURI_HAL_MPU_ATTRIBUTES | LL_MPU_REGION_NO_ACCESS | size_ll);
|
||||
furi_hal_mpu_enable();
|
||||
}
|
||||
|
||||
void furi_hal_mpu_protect_read_only(
|
||||
FuriHalMpuRegion region,
|
||||
uint32_t address,
|
||||
FuriHalMPURegionSize size) {
|
||||
uint32_t size_ll = size;
|
||||
size_ll = size_ll << MPU_RASR_SIZE_Pos;
|
||||
|
||||
furi_hal_mpu_disable();
|
||||
LL_MPU_ConfigRegion(
|
||||
region, 0x00, address, FURI_HAL_MPU_ATTRIBUTES | LL_MPU_REGION_PRIV_RO_URO | size_ll);
|
||||
furi_hal_mpu_enable();
|
||||
}
|
||||
|
||||
void furi_hal_mpu_protect_disable(FuriHalMpuRegion region) {
|
||||
furi_hal_mpu_disable();
|
||||
LL_MPU_DisableRegion(region);
|
||||
furi_hal_mpu_enable();
|
||||
}
|
||||
|
||||
void furi_hal_mpu_set_stack_protection(uint32_t* stack) {
|
||||
// Protection area address must be aligned to region size
|
||||
uint32_t stack_ptr = (uint32_t)stack;
|
||||
uint32_t mask = ((1 << (FURI_HAL_MPU_STACK_PROTECT_REGION + 2)) - 1);
|
||||
stack_ptr &= ~mask;
|
||||
if(stack_ptr < (uint32_t)stack) stack_ptr += (mask + 1);
|
||||
|
||||
furi_hal_mpu_protect_read_only(
|
||||
FuriHalMpuRegionStack, stack_ptr, FURI_HAL_MPU_STACK_PROTECT_REGION);
|
||||
}
|
||||
@@ -0,0 +1,621 @@
|
||||
#include "furi_hal_nfc_i.h"
|
||||
#include "furi_hal_nfc_tech_i.h"
|
||||
|
||||
#include <lib/drivers/st25r3916.h>
|
||||
|
||||
#include <furi.h>
|
||||
#include <furi_hal_spi.h>
|
||||
|
||||
#define TAG "FuriHalNfc"
|
||||
|
||||
const FuriHalNfcTechBase* furi_hal_nfc_tech[FuriHalNfcTechNum] = {
|
||||
[FuriHalNfcTechIso14443a] = &furi_hal_nfc_iso14443a,
|
||||
[FuriHalNfcTechIso14443b] = &furi_hal_nfc_iso14443b,
|
||||
[FuriHalNfcTechIso15693] = &furi_hal_nfc_iso15693,
|
||||
[FuriHalNfcTechFelica] = &furi_hal_nfc_felica,
|
||||
// Add new technologies here
|
||||
};
|
||||
|
||||
FuriHalNfc furi_hal_nfc;
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_turn_on_osc(FuriHalSpiBusHandle* handle) {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
furi_hal_nfc_event_start();
|
||||
|
||||
if(!st25r3916_check_reg(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
ST25R3916_REG_OP_CONTROL_en,
|
||||
ST25R3916_REG_OP_CONTROL_en)) {
|
||||
st25r3916_mask_irq(handle, ~ST25R3916_IRQ_MASK_OSC);
|
||||
st25r3916_set_reg_bits(handle, ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_en);
|
||||
furi_hal_nfc_event_wait_for_specific_irq(handle, ST25R3916_IRQ_MASK_OSC, 10);
|
||||
}
|
||||
// Disable IRQs
|
||||
st25r3916_mask_irq(handle, ST25R3916_IRQ_MASK_ALL);
|
||||
|
||||
bool osc_on = st25r3916_check_reg(
|
||||
handle,
|
||||
ST25R3916_REG_AUX_DISPLAY,
|
||||
ST25R3916_REG_AUX_DISPLAY_osc_ok,
|
||||
ST25R3916_REG_AUX_DISPLAY_osc_ok);
|
||||
if(!osc_on) {
|
||||
error = FuriHalNfcErrorOscillator;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_is_hal_ready() {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
|
||||
do {
|
||||
error = furi_hal_nfc_acquire();
|
||||
if(error != FuriHalNfcErrorNone) break;
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
uint8_t chip_id = 0;
|
||||
st25r3916_read_reg(handle, ST25R3916_REG_IC_IDENTITY, &chip_id);
|
||||
if((chip_id & ST25R3916_REG_IC_IDENTITY_ic_type_mask) !=
|
||||
ST25R3916_REG_IC_IDENTITY_ic_type_st25r3916) {
|
||||
FURI_LOG_E(TAG, "Wrong chip id");
|
||||
error = FuriHalNfcErrorCommunication;
|
||||
}
|
||||
|
||||
furi_hal_nfc_release();
|
||||
} while(false);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_init() {
|
||||
furi_assert(furi_hal_nfc.mutex == NULL);
|
||||
|
||||
furi_hal_nfc.mutex = furi_mutex_alloc(FuriMutexTypeNormal);
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
|
||||
furi_hal_nfc_event_init();
|
||||
furi_hal_nfc_event_start();
|
||||
|
||||
do {
|
||||
error = furi_hal_nfc_acquire();
|
||||
if(error != FuriHalNfcErrorNone) {
|
||||
furi_hal_nfc_low_power_mode_start();
|
||||
}
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
// Set default state
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_SET_DEFAULT);
|
||||
// Increase IO driver strength of MISO and IRQ
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_IO_CONF2, ST25R3916_REG_IO_CONF2_io_drv_lvl);
|
||||
// Check chip ID
|
||||
uint8_t chip_id = 0;
|
||||
st25r3916_read_reg(handle, ST25R3916_REG_IC_IDENTITY, &chip_id);
|
||||
if((chip_id & ST25R3916_REG_IC_IDENTITY_ic_type_mask) !=
|
||||
ST25R3916_REG_IC_IDENTITY_ic_type_st25r3916) {
|
||||
FURI_LOG_E(TAG, "Wrong chip id");
|
||||
error = FuriHalNfcErrorCommunication;
|
||||
furi_hal_nfc_low_power_mode_start();
|
||||
furi_hal_nfc_release();
|
||||
break;
|
||||
}
|
||||
// Clear interrupts
|
||||
st25r3916_get_irq(handle);
|
||||
// Mask all interrupts
|
||||
st25r3916_mask_irq(handle, ST25R3916_IRQ_MASK_ALL);
|
||||
// Enable interrupts
|
||||
furi_hal_nfc_init_gpio_isr();
|
||||
// Disable internal overheat protection
|
||||
st25r3916_change_test_reg_bits(handle, 0x04, 0x10, 0x10);
|
||||
|
||||
error = furi_hal_nfc_turn_on_osc(handle);
|
||||
if(error != FuriHalNfcErrorNone) {
|
||||
furi_hal_nfc_low_power_mode_start();
|
||||
furi_hal_nfc_release();
|
||||
break;
|
||||
}
|
||||
|
||||
// Measure voltage
|
||||
// Set measure power supply voltage source
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_REGULATOR_CONTROL,
|
||||
ST25R3916_REG_REGULATOR_CONTROL_mpsv_mask,
|
||||
ST25R3916_REG_REGULATOR_CONTROL_mpsv_vdd);
|
||||
// Enable timer and interrupt register
|
||||
st25r3916_mask_irq(handle, ~ST25R3916_IRQ_MASK_DCT);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_MEASURE_VDD);
|
||||
furi_hal_nfc_event_wait_for_specific_irq(handle, ST25R3916_IRQ_MASK_DCT, 100);
|
||||
st25r3916_mask_irq(handle, ST25R3916_IRQ_MASK_ALL);
|
||||
uint8_t ad_res = 0;
|
||||
st25r3916_read_reg(handle, ST25R3916_REG_AD_RESULT, &ad_res);
|
||||
uint16_t mV = ((uint16_t)ad_res) * 23U;
|
||||
mV += (((((uint16_t)ad_res) * 4U) + 5U) / 10U);
|
||||
|
||||
if(mV < 3600) {
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_IO_CONF2,
|
||||
ST25R3916_REG_IO_CONF2_sup3V,
|
||||
ST25R3916_REG_IO_CONF2_sup3V_3V);
|
||||
} else {
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_IO_CONF2,
|
||||
ST25R3916_REG_IO_CONF2_sup3V,
|
||||
ST25R3916_REG_IO_CONF2_sup3V_5V);
|
||||
}
|
||||
|
||||
// Disable MCU CLK
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_IO_CONF1,
|
||||
ST25R3916_REG_IO_CONF1_out_cl_mask | ST25R3916_REG_IO_CONF1_lf_clk_off,
|
||||
0x07);
|
||||
// Disable MISO pull-down
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_IO_CONF2,
|
||||
ST25R3916_REG_IO_CONF2_miso_pd1 | ST25R3916_REG_IO_CONF2_miso_pd2,
|
||||
0x00);
|
||||
// Set tx driver resistance to 1 Om
|
||||
st25r3916_change_reg_bits(
|
||||
handle, ST25R3916_REG_TX_DRIVER, ST25R3916_REG_TX_DRIVER_d_res_mask, 0x00);
|
||||
// Use minimum non-overlap
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_RES_AM_MOD,
|
||||
ST25R3916_REG_RES_AM_MOD_fa3_f,
|
||||
ST25R3916_REG_RES_AM_MOD_fa3_f);
|
||||
|
||||
// Set activation threashold
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_ACTV,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_mask,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_ACTV_trg_105mV);
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_ACTV,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_mask,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_ACTV_rfe_105mV);
|
||||
// Set deactivation threashold
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_DEACTV,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_mask,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_DEACTV_trg_75mV);
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_DEACTV,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_mask,
|
||||
ST25R3916_REG_FIELD_THRESHOLD_DEACTV_rfe_75mV);
|
||||
// Enable external load modulation
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_AUX_MOD,
|
||||
ST25R3916_REG_AUX_MOD_lm_ext,
|
||||
ST25R3916_REG_AUX_MOD_lm_ext);
|
||||
// Enable internal load modulation
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_AUX_MOD,
|
||||
ST25R3916_REG_AUX_MOD_lm_dri,
|
||||
ST25R3916_REG_AUX_MOD_lm_dri);
|
||||
// Adjust FDT
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_PASSIVE_TARGET,
|
||||
ST25R3916_REG_PASSIVE_TARGET_fdel_mask,
|
||||
(5U << ST25R3916_REG_PASSIVE_TARGET_fdel_shift));
|
||||
// Reduce RFO resistance in Modulated state
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_PT_MOD,
|
||||
ST25R3916_REG_PT_MOD_ptm_res_mask | ST25R3916_REG_PT_MOD_pt_res_mask,
|
||||
0x0f);
|
||||
// Enable RX start on first 4 bits
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_EMD_SUP_CONF,
|
||||
ST25R3916_REG_EMD_SUP_CONF_rx_start_emv,
|
||||
ST25R3916_REG_EMD_SUP_CONF_rx_start_emv_on);
|
||||
// Set antena tunning
|
||||
st25r3916_change_reg_bits(handle, ST25R3916_REG_ANT_TUNE_A, 0xff, 0x82);
|
||||
st25r3916_change_reg_bits(handle, ST25R3916_REG_ANT_TUNE_B, 0xff, 0x82);
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
ST25R3916_REG_OP_CONTROL_en_fd_mask,
|
||||
ST25R3916_REG_OP_CONTROL_en_fd_auto_efd);
|
||||
|
||||
// Perform calibration
|
||||
if(st25r3916_check_reg(
|
||||
handle,
|
||||
ST25R3916_REG_REGULATOR_CONTROL,
|
||||
ST25R3916_REG_REGULATOR_CONTROL_reg_s,
|
||||
0x00)) {
|
||||
FURI_LOG_I(TAG, "Adjusting regulators");
|
||||
// Reset logic
|
||||
st25r3916_set_reg_bits(
|
||||
handle, ST25R3916_REG_REGULATOR_CONTROL, ST25R3916_REG_REGULATOR_CONTROL_reg_s);
|
||||
st25r3916_clear_reg_bits(
|
||||
handle, ST25R3916_REG_REGULATOR_CONTROL, ST25R3916_REG_REGULATOR_CONTROL_reg_s);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_ADJUST_REGULATORS);
|
||||
furi_delay_ms(6);
|
||||
}
|
||||
|
||||
furi_hal_nfc_low_power_mode_start();
|
||||
furi_hal_nfc_release();
|
||||
} while(false);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
static bool furi_hal_nfc_is_mine() {
|
||||
return (furi_mutex_get_owner(furi_hal_nfc.mutex) == furi_thread_get_current_id());
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_acquire() {
|
||||
furi_check(furi_hal_nfc.mutex);
|
||||
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_nfc);
|
||||
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
if(furi_mutex_acquire(furi_hal_nfc.mutex, 100) != FuriStatusOk) {
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_nfc);
|
||||
error = FuriHalNfcErrorBusy;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_release() {
|
||||
furi_check(furi_hal_nfc.mutex);
|
||||
furi_check(furi_hal_nfc_is_mine());
|
||||
furi_check(furi_mutex_release(furi_hal_nfc.mutex) == FuriStatusOk);
|
||||
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_nfc);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_low_power_mode_start() {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_STOP);
|
||||
st25r3916_clear_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
(ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_rx_en |
|
||||
ST25R3916_REG_OP_CONTROL_wu | ST25R3916_REG_OP_CONTROL_tx_en |
|
||||
ST25R3916_REG_OP_CONTROL_en_fd_mask));
|
||||
furi_hal_nfc_deinit_gpio_isr();
|
||||
furi_hal_nfc_timers_deinit();
|
||||
furi_hal_nfc_event_stop();
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_low_power_mode_stop() {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
do {
|
||||
furi_hal_nfc_init_gpio_isr();
|
||||
furi_hal_nfc_timers_init();
|
||||
error = furi_hal_nfc_turn_on_osc(handle);
|
||||
if(error != FuriHalNfcErrorNone) break;
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
ST25R3916_REG_OP_CONTROL_en_fd_mask,
|
||||
ST25R3916_REG_OP_CONTROL_en_fd_auto_efd);
|
||||
|
||||
} while(false);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_poller_init_common(FuriHalSpiBusHandle* handle) {
|
||||
// Disable wake up
|
||||
st25r3916_clear_reg_bits(handle, ST25R3916_REG_OP_CONTROL, ST25R3916_REG_OP_CONTROL_wu);
|
||||
// Enable correlator
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_AUX,
|
||||
ST25R3916_REG_AUX_dis_corr,
|
||||
ST25R3916_REG_AUX_dis_corr_correlator);
|
||||
|
||||
st25r3916_change_reg_bits(handle, ST25R3916_REG_ANT_TUNE_A, 0xff, 0x82);
|
||||
st25r3916_change_reg_bits(handle, ST25R3916_REG_ANT_TUNE_B, 0xFF, 0x82);
|
||||
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_OVERSHOOT_CONF1, 0x00);
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_OVERSHOOT_CONF2, 0x00);
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_UNDERSHOOT_CONF1, 0x00);
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_UNDERSHOOT_CONF2, 0x00);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_listener_init_common(FuriHalSpiBusHandle* handle) {
|
||||
UNUSED(handle);
|
||||
// No common listener configuration
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_set_mode(FuriHalNfcMode mode, FuriHalNfcTech tech) {
|
||||
furi_assert(mode < FuriHalNfcModeNum);
|
||||
furi_assert(tech < FuriHalNfcTechNum);
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
|
||||
if(mode == FuriHalNfcModePoller) {
|
||||
do {
|
||||
error = furi_hal_nfc_poller_init_common(handle);
|
||||
if(error != FuriHalNfcErrorNone) break;
|
||||
error = furi_hal_nfc_tech[tech]->poller.init(handle);
|
||||
} while(false);
|
||||
|
||||
} else if(mode == FuriHalNfcModeListener) {
|
||||
do {
|
||||
error = furi_hal_nfc_listener_init_common(handle);
|
||||
if(error != FuriHalNfcErrorNone) break;
|
||||
error = furi_hal_nfc_tech[tech]->listener.init(handle);
|
||||
} while(false);
|
||||
}
|
||||
|
||||
furi_hal_nfc.mode = mode;
|
||||
furi_hal_nfc.tech = tech;
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_reset_mode() {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_STOP);
|
||||
|
||||
const FuriHalNfcMode mode = furi_hal_nfc.mode;
|
||||
const FuriHalNfcTech tech = furi_hal_nfc.tech;
|
||||
if(mode == FuriHalNfcModePoller) {
|
||||
error = furi_hal_nfc_tech[tech]->poller.deinit(handle);
|
||||
} else if(mode == FuriHalNfcModeListener) {
|
||||
error = furi_hal_nfc_tech[tech]->listener.deinit(handle);
|
||||
}
|
||||
// Set default value in mode register
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_MODE, ST25R3916_REG_MODE_om0);
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_STREAM_MODE, 0);
|
||||
st25r3916_clear_reg_bits(handle, ST25R3916_REG_AUX, ST25R3916_REG_AUX_no_crc_rx);
|
||||
st25r3916_clear_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_BIT_RATE,
|
||||
ST25R3916_REG_BIT_RATE_txrate_mask | ST25R3916_REG_BIT_RATE_rxrate_mask);
|
||||
|
||||
// Write default values
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_RX_CONF1, 0);
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_RX_CONF2,
|
||||
ST25R3916_REG_RX_CONF2_sqm_dyn | ST25R3916_REG_RX_CONF2_agc_en |
|
||||
ST25R3916_REG_RX_CONF2_agc_m);
|
||||
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_CORR_CONF1,
|
||||
ST25R3916_REG_CORR_CONF1_corr_s7 | ST25R3916_REG_CORR_CONF1_corr_s4 |
|
||||
ST25R3916_REG_CORR_CONF1_corr_s1 | ST25R3916_REG_CORR_CONF1_corr_s0);
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_CORR_CONF2, 0);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_field_detect_start() {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_en_fd_mask);
|
||||
st25r3916_write_reg(
|
||||
handle, ST25R3916_REG_MODE, ST25R3916_REG_MODE_targ | ST25R3916_REG_MODE_om0);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_field_detect_stop() {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
st25r3916_clear_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
(ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_en_fd_mask));
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
bool furi_hal_nfc_field_is_present() {
|
||||
bool is_present = false;
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
if(st25r3916_check_reg(
|
||||
handle,
|
||||
ST25R3916_REG_AUX_DISPLAY,
|
||||
ST25R3916_REG_AUX_DISPLAY_efd_o,
|
||||
ST25R3916_REG_AUX_DISPLAY_efd_o)) {
|
||||
is_present = true;
|
||||
}
|
||||
|
||||
return is_present;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_poller_field_on() {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
if(!st25r3916_check_reg(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
ST25R3916_REG_OP_CONTROL_tx_en,
|
||||
ST25R3916_REG_OP_CONTROL_tx_en)) {
|
||||
// Set min guard time
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_FIELD_ON_GT, 0);
|
||||
// Enable tx rx
|
||||
st25r3916_set_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
(ST25R3916_REG_OP_CONTROL_rx_en | ST25R3916_REG_OP_CONTROL_tx_en));
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_poller_tx_common(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
const uint8_t* tx_data,
|
||||
size_t tx_bits) {
|
||||
furi_assert(tx_data);
|
||||
|
||||
FuriHalNfcError err = FuriHalNfcErrorNone;
|
||||
|
||||
// Prepare tx
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_CLEAR_FIFO);
|
||||
st25r3916_clear_reg_bits(
|
||||
handle, ST25R3916_REG_TIMER_EMV_CONTROL, ST25R3916_REG_TIMER_EMV_CONTROL_nrt_emv);
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_ISO14443A_NFC,
|
||||
(ST25R3916_REG_ISO14443A_NFC_no_tx_par | ST25R3916_REG_ISO14443A_NFC_no_rx_par),
|
||||
(ST25R3916_REG_ISO14443A_NFC_no_tx_par_off | ST25R3916_REG_ISO14443A_NFC_no_rx_par_off));
|
||||
uint32_t interrupts =
|
||||
(ST25R3916_IRQ_MASK_FWL | ST25R3916_IRQ_MASK_TXE | ST25R3916_IRQ_MASK_RXS |
|
||||
ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_CRC |
|
||||
ST25R3916_IRQ_MASK_ERR1 | ST25R3916_IRQ_MASK_ERR2 | ST25R3916_IRQ_MASK_NRE);
|
||||
// Clear interrupts
|
||||
st25r3916_get_irq(handle);
|
||||
// Enable interrupts
|
||||
st25r3916_mask_irq(handle, ~interrupts);
|
||||
|
||||
st25r3916_write_fifo(handle, tx_data, tx_bits);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_TRANSMIT_WITHOUT_CRC);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_common_fifo_tx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
const uint8_t* tx_data,
|
||||
size_t tx_bits) {
|
||||
FuriHalNfcError err = FuriHalNfcErrorNone;
|
||||
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_CLEAR_FIFO);
|
||||
st25r3916_write_fifo(handle, tx_data, tx_bits);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_TRANSMIT_WITHOUT_CRC);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_poller_tx(const uint8_t* tx_data, size_t tx_bits) {
|
||||
furi_assert(furi_hal_nfc.mode == FuriHalNfcModePoller);
|
||||
furi_assert(furi_hal_nfc.tech < FuriHalNfcTechNum);
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
return furi_hal_nfc_tech[furi_hal_nfc.tech]->poller.tx(handle, tx_data, tx_bits);
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_poller_rx(uint8_t* rx_data, size_t rx_data_size, size_t* rx_bits) {
|
||||
furi_assert(furi_hal_nfc.mode == FuriHalNfcModePoller);
|
||||
furi_assert(furi_hal_nfc.tech < FuriHalNfcTechNum);
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
return furi_hal_nfc_tech[furi_hal_nfc.tech]->poller.rx(handle, rx_data, rx_data_size, rx_bits);
|
||||
}
|
||||
|
||||
FuriHalNfcEvent furi_hal_nfc_poller_wait_event(uint32_t timeout_ms) {
|
||||
furi_assert(furi_hal_nfc.mode == FuriHalNfcModePoller);
|
||||
furi_assert(furi_hal_nfc.tech < FuriHalNfcTechNum);
|
||||
|
||||
return furi_hal_nfc_tech[furi_hal_nfc.tech]->poller.wait_event(timeout_ms);
|
||||
}
|
||||
|
||||
FuriHalNfcEvent furi_hal_nfc_listener_wait_event(uint32_t timeout_ms) {
|
||||
furi_assert(furi_hal_nfc.mode == FuriHalNfcModeListener);
|
||||
furi_assert(furi_hal_nfc.tech < FuriHalNfcTechNum);
|
||||
|
||||
return furi_hal_nfc_tech[furi_hal_nfc.tech]->listener.wait_event(timeout_ms);
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_listener_tx(const uint8_t* tx_data, size_t tx_bits) {
|
||||
furi_assert(tx_data);
|
||||
|
||||
furi_assert(furi_hal_nfc.mode == FuriHalNfcModeListener);
|
||||
furi_assert(furi_hal_nfc.tech < FuriHalNfcTechNum);
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
return furi_hal_nfc_tech[furi_hal_nfc.tech]->listener.tx(handle, tx_data, tx_bits);
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_common_fifo_rx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
uint8_t* rx_data,
|
||||
size_t rx_data_size,
|
||||
size_t* rx_bits) {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
|
||||
if(!st25r3916_read_fifo(handle, rx_data, rx_data_size, rx_bits)) {
|
||||
error = FuriHalNfcErrorBufferOverflow;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_listener_rx(uint8_t* rx_data, size_t rx_data_size, size_t* rx_bits) {
|
||||
furi_assert(rx_data);
|
||||
furi_assert(rx_bits);
|
||||
|
||||
furi_assert(furi_hal_nfc.mode == FuriHalNfcModeListener);
|
||||
furi_assert(furi_hal_nfc.tech < FuriHalNfcTechNum);
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
return furi_hal_nfc_tech[furi_hal_nfc.tech]->listener.rx(
|
||||
handle, rx_data, rx_data_size, rx_bits);
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_trx_reset() {
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_STOP);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_listener_sleep() {
|
||||
furi_assert(furi_hal_nfc.mode == FuriHalNfcModeListener);
|
||||
furi_assert(furi_hal_nfc.tech < FuriHalNfcTechNum);
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
return furi_hal_nfc_tech[furi_hal_nfc.tech]->listener.sleep(handle);
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_listener_idle() {
|
||||
furi_assert(furi_hal_nfc.mode == FuriHalNfcModeListener);
|
||||
furi_assert(furi_hal_nfc.tech < FuriHalNfcTechNum);
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
return furi_hal_nfc_tech[furi_hal_nfc.tech]->listener.idle(handle);
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_listener_enable_rx() {
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_UNMASK_RECEIVE_DATA);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
#include <furi_hal_nfc_i.h>
|
||||
|
||||
FuriHalNfcEventInternal* furi_hal_nfc_event = NULL;
|
||||
|
||||
void furi_hal_nfc_event_init() {
|
||||
furi_hal_nfc_event = malloc(sizeof(FuriHalNfcEventInternal));
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_event_start() {
|
||||
furi_assert(furi_hal_nfc_event);
|
||||
|
||||
furi_hal_nfc_event->thread = furi_thread_get_current_id();
|
||||
furi_thread_flags_clear(FURI_HAL_NFC_EVENT_INTERNAL_ALL);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_event_stop() {
|
||||
furi_assert(furi_hal_nfc_event);
|
||||
|
||||
furi_hal_nfc_event->thread = NULL;
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
void furi_hal_nfc_event_set(FuriHalNfcEventInternalType event) {
|
||||
furi_assert(furi_hal_nfc_event);
|
||||
|
||||
if(furi_hal_nfc_event->thread) {
|
||||
furi_thread_flags_set(furi_hal_nfc_event->thread, event);
|
||||
}
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_abort() {
|
||||
furi_hal_nfc_event_set(FuriHalNfcEventInternalTypeAbort);
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
FuriHalNfcEvent furi_hal_nfc_wait_event_common(uint32_t timeout_ms) {
|
||||
furi_assert(furi_hal_nfc_event);
|
||||
furi_assert(furi_hal_nfc_event->thread);
|
||||
|
||||
FuriHalNfcEvent event = 0;
|
||||
uint32_t event_timeout = timeout_ms == FURI_HAL_NFC_EVENT_WAIT_FOREVER ? FuriWaitForever :
|
||||
timeout_ms;
|
||||
uint32_t event_flag =
|
||||
furi_thread_flags_wait(FURI_HAL_NFC_EVENT_INTERNAL_ALL, FuriFlagWaitAny, event_timeout);
|
||||
if(event_flag != (unsigned)FuriFlagErrorTimeout) {
|
||||
if(event_flag & FuriHalNfcEventInternalTypeIrq) {
|
||||
furi_thread_flags_clear(FuriHalNfcEventInternalTypeIrq);
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
uint32_t irq = furi_hal_nfc_get_irq(handle);
|
||||
if(irq & ST25R3916_IRQ_MASK_OSC) {
|
||||
event |= FuriHalNfcEventOscOn;
|
||||
}
|
||||
if(irq & ST25R3916_IRQ_MASK_TXE) {
|
||||
event |= FuriHalNfcEventTxEnd;
|
||||
}
|
||||
if(irq & ST25R3916_IRQ_MASK_RXS) {
|
||||
event |= FuriHalNfcEventRxStart;
|
||||
}
|
||||
if(irq & ST25R3916_IRQ_MASK_RXE) {
|
||||
event |= FuriHalNfcEventRxEnd;
|
||||
}
|
||||
if(irq & ST25R3916_IRQ_MASK_COL) {
|
||||
event |= FuriHalNfcEventCollision;
|
||||
}
|
||||
if(irq & ST25R3916_IRQ_MASK_EON) {
|
||||
event |= FuriHalNfcEventFieldOn;
|
||||
}
|
||||
if(irq & ST25R3916_IRQ_MASK_EOF) {
|
||||
event |= FuriHalNfcEventFieldOff;
|
||||
}
|
||||
if(irq & ST25R3916_IRQ_MASK_WU_A) {
|
||||
event |= FuriHalNfcEventListenerActive;
|
||||
}
|
||||
if(irq & ST25R3916_IRQ_MASK_WU_A_X) {
|
||||
event |= FuriHalNfcEventListenerActive;
|
||||
}
|
||||
}
|
||||
if(event_flag & FuriHalNfcEventInternalTypeTimerFwtExpired) {
|
||||
event |= FuriHalNfcEventTimerFwtExpired;
|
||||
furi_thread_flags_clear(FuriHalNfcEventInternalTypeTimerFwtExpired);
|
||||
}
|
||||
if(event_flag & FuriHalNfcEventInternalTypeTimerBlockTxExpired) {
|
||||
event |= FuriHalNfcEventTimerBlockTxExpired;
|
||||
furi_thread_flags_clear(FuriHalNfcEventInternalTypeTimerBlockTxExpired);
|
||||
}
|
||||
if(event_flag & FuriHalNfcEventInternalTypeAbort) {
|
||||
event |= FuriHalNfcEventAbortRequest;
|
||||
furi_thread_flags_clear(FuriHalNfcEventInternalTypeAbort);
|
||||
}
|
||||
} else {
|
||||
event = FuriHalNfcEventTimeout;
|
||||
}
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
bool furi_hal_nfc_event_wait_for_specific_irq(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
uint32_t mask,
|
||||
uint32_t timeout_ms) {
|
||||
furi_assert(furi_hal_nfc_event);
|
||||
furi_assert(furi_hal_nfc_event->thread);
|
||||
|
||||
bool irq_received = false;
|
||||
uint32_t event_flag =
|
||||
furi_thread_flags_wait(FuriHalNfcEventInternalTypeIrq, FuriFlagWaitAny, timeout_ms);
|
||||
if(event_flag == FuriHalNfcEventInternalTypeIrq) {
|
||||
uint32_t irq = furi_hal_nfc_get_irq(handle);
|
||||
irq_received = ((irq & mask) == mask);
|
||||
furi_thread_flags_clear(FuriHalNfcEventInternalTypeIrq);
|
||||
}
|
||||
|
||||
return irq_received;
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
#include "furi_hal_nfc_i.h"
|
||||
#include "furi_hal_nfc_tech_i.h"
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_felica_poller_init(FuriHalSpiBusHandle* handle) {
|
||||
// Enable Felica mode, AM modulation
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_MODE,
|
||||
ST25R3916_REG_MODE_om_mask | ST25R3916_REG_MODE_tr_am,
|
||||
ST25R3916_REG_MODE_om_felica | ST25R3916_REG_MODE_tr_am_am);
|
||||
|
||||
// 10% ASK modulation
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_TX_DRIVER,
|
||||
ST25R3916_REG_TX_DRIVER_am_mod_mask,
|
||||
ST25R3916_REG_TX_DRIVER_am_mod_10percent);
|
||||
|
||||
// Use regulator AM, resistive AM disabled
|
||||
st25r3916_clear_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_AUX_MOD,
|
||||
ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am);
|
||||
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_BIT_RATE,
|
||||
ST25R3916_REG_BIT_RATE_txrate_mask | ST25R3916_REG_BIT_RATE_rxrate_mask,
|
||||
ST25R3916_REG_BIT_RATE_txrate_212 | ST25R3916_REG_BIT_RATE_rxrate_212);
|
||||
|
||||
// Receive configuration
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_RX_CONF1,
|
||||
ST25R3916_REG_RX_CONF1_lp0 | ST25R3916_REG_RX_CONF1_hz_12_80khz);
|
||||
|
||||
// Correlator setup
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_CORR_CONF1,
|
||||
ST25R3916_REG_CORR_CONF1_corr_s6 | ST25R3916_REG_CORR_CONF1_corr_s4 |
|
||||
ST25R3916_REG_CORR_CONF1_corr_s3);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_felica_poller_deinit(FuriHalSpiBusHandle* handle) {
|
||||
UNUSED(handle);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
const FuriHalNfcTechBase furi_hal_nfc_felica = {
|
||||
.poller =
|
||||
{
|
||||
.compensation =
|
||||
{
|
||||
.fdt = FURI_HAL_NFC_POLLER_FDT_COMP_FC,
|
||||
.fwt = FURI_HAL_NFC_POLLER_FWT_COMP_FC,
|
||||
},
|
||||
.init = furi_hal_nfc_felica_poller_init,
|
||||
.deinit = furi_hal_nfc_felica_poller_deinit,
|
||||
.wait_event = furi_hal_nfc_wait_event_common,
|
||||
.tx = furi_hal_nfc_poller_tx_common,
|
||||
.rx = furi_hal_nfc_common_fifo_rx,
|
||||
},
|
||||
|
||||
.listener = {},
|
||||
};
|
||||
@@ -0,0 +1,191 @@
|
||||
/**
|
||||
* @file furi_hal_nfc_i.h
|
||||
* @brief NFC HAL library (private definitions).
|
||||
*
|
||||
* This file is an implementation detail. It must not be included in
|
||||
* any public API-related headers.
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include <furi.h>
|
||||
#include <furi_hal_nfc.h>
|
||||
#include <furi_hal_spi.h>
|
||||
|
||||
#include <drivers/st25r3916.h>
|
||||
#include <drivers/st25r3916_reg.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** @brief Common frame delay time compensation for pollers. */
|
||||
#define FURI_HAL_NFC_POLLER_FDT_COMP_FC (-500)
|
||||
/** @brief Common frame wait time compensation for pollers. */
|
||||
#define FURI_HAL_NFC_POLLER_FWT_COMP_FC (FURI_HAL_NFC_POLLER_FDT_COMP_FC)
|
||||
|
||||
/**
|
||||
* @brief Enumeration containing bitmask values for NFC HAL internal events.
|
||||
*/
|
||||
typedef enum {
|
||||
FuriHalNfcEventInternalTypeAbort = (1U << 0), /**< Abort waiting for hardware events. */
|
||||
FuriHalNfcEventInternalTypeIrq = (1U << 1), /**< NFC hardware interrupt has occurred. */
|
||||
FuriHalNfcEventInternalTypeTimerFwtExpired =
|
||||
(1U << 2), /**< Frame wait time timeout has expired. */
|
||||
FuriHalNfcEventInternalTypeTimerBlockTxExpired =
|
||||
(1U << 3), /**< Transmission block timeout has expired. */
|
||||
FuriHalNfcEventInternalTypeTransparentDataReceived =
|
||||
(1U << 4), /**< Data was received in transparent mode. */
|
||||
} FuriHalNfcEventInternalType;
|
||||
|
||||
/** @brief Special bitmask value of all internal events. */
|
||||
#define FURI_HAL_NFC_EVENT_INTERNAL_ALL \
|
||||
((FuriHalNfcEventInternalTypeAbort | FuriHalNfcEventInternalTypeIrq | \
|
||||
FuriHalNfcEventInternalTypeTimerFwtExpired | \
|
||||
FuriHalNfcEventInternalTypeTimerBlockTxExpired | \
|
||||
FuriHalNfcEventInternalTypeTransparentDataReceived))
|
||||
|
||||
/**
|
||||
* @brief NFC HAL internal event structure.
|
||||
*/
|
||||
typedef struct {
|
||||
FuriThreadId thread; /**< Identifier of the thread that will be receiving events. */
|
||||
void* context; /**< Pointer to the user-provided context (will be passed to the event callback). */
|
||||
} FuriHalNfcEventInternal;
|
||||
|
||||
/**
|
||||
* @brief NFC HAL global state structure.
|
||||
*/
|
||||
typedef struct {
|
||||
FuriMutex* mutex; /**< Pointer to the mutex serving as global NFC HAL lock. */
|
||||
FuriHalNfcMode mode; /**< Currently selected operating mode. */
|
||||
FuriHalNfcTech tech; /**< Currently selected NFC technology. */
|
||||
} FuriHalNfc;
|
||||
|
||||
/**
|
||||
* @brief NFC HAL global state object declaration.
|
||||
*/
|
||||
extern FuriHalNfc furi_hal_nfc;
|
||||
|
||||
/**
|
||||
* @brief Initialise NFC HAL event system.
|
||||
*/
|
||||
void furi_hal_nfc_event_init();
|
||||
|
||||
/**
|
||||
* @brief Forcibly emit (a) particular internal event(s).
|
||||
*
|
||||
* @param[in] event bitmask of one or more events to be emitted.
|
||||
*/
|
||||
void furi_hal_nfc_event_set(FuriHalNfcEventInternalType event);
|
||||
|
||||
/**
|
||||
* @brief Initialise GPIO to generate an interrupt from the NFC hardware.
|
||||
*/
|
||||
void furi_hal_nfc_init_gpio_isr();
|
||||
|
||||
/**
|
||||
* @brief Disable interrupts from the NFC hardware.
|
||||
*/
|
||||
void furi_hal_nfc_deinit_gpio_isr();
|
||||
|
||||
/**
|
||||
* @brief Initialise all NFC timers.
|
||||
*/
|
||||
void furi_hal_nfc_timers_init();
|
||||
|
||||
/**
|
||||
* @brief Disable all NFC timers.
|
||||
*/
|
||||
void furi_hal_nfc_timers_deinit();
|
||||
|
||||
/**
|
||||
* @brief Get the interrupt bitmask from the NFC hardware.
|
||||
*
|
||||
* @param[in,out] handle pointer to the SPI handle associated with the NFC chip.
|
||||
* @returns bitmask of zero or more occurred interrupts.
|
||||
*/
|
||||
uint32_t furi_hal_nfc_get_irq(FuriHalSpiBusHandle* handle);
|
||||
|
||||
/**
|
||||
* @brief Wait until a specified type of interrupt occurs.
|
||||
*
|
||||
* @param[in,out] handle pointer to the SPI handle associated with the NFC chip.
|
||||
* @param[in] mask bitmask of one or more interrupts to wait for.
|
||||
* @param[in] timeout_ms maximum time to wait for an interrupt, in milliseconds.
|
||||
* @returns true if specified interrupt(s) have occured within timeout, false otherwise.
|
||||
*/
|
||||
bool furi_hal_nfc_event_wait_for_specific_irq(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
uint32_t mask,
|
||||
uint32_t timeout_ms);
|
||||
|
||||
/**
|
||||
* @brief Wait for any event to occur.
|
||||
*
|
||||
* This function is common to all technologies.
|
||||
*
|
||||
* @param[in] timeout_ms maximum time to wait for an event, in milliseconds.
|
||||
* @returns bitmask of zero or more occurred events.
|
||||
*/
|
||||
FuriHalNfcEvent furi_hal_nfc_wait_event_common(uint32_t timeout_ms);
|
||||
|
||||
/**
|
||||
* @brief Start reception in listener mode.
|
||||
*
|
||||
* This function is common to all technologies.
|
||||
*
|
||||
* @param[in,out] handle pointer to the SPI handle associated with the NFC chip.
|
||||
* @returns FuriHalNfcErrorNone on success, any other error code on failure.
|
||||
*/
|
||||
FuriHalNfcError furi_hal_nfc_common_listener_rx_start(FuriHalSpiBusHandle* handle);
|
||||
|
||||
/**
|
||||
* @brief Transmit data using on-chip FIFO.
|
||||
*
|
||||
* This function is common to all technologies.
|
||||
*
|
||||
* @param[in,out] handle pointer to the SPI handle associated with the NFC chip.
|
||||
* @param[in] tx_data pointer to a byte array containing the data to be transmitted.
|
||||
* @param[in] tx_bits transmit data size, in bits.
|
||||
* @returns FuriHalNfcErrorNone on success, any other error code on failure.
|
||||
*/
|
||||
FuriHalNfcError furi_hal_nfc_common_fifo_tx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
const uint8_t* tx_data,
|
||||
size_t tx_bits);
|
||||
|
||||
/**
|
||||
* @brief Receive data using on-chip FIFO.
|
||||
*
|
||||
* This function is common to all technologies.
|
||||
*
|
||||
* @param[in,out] handle pointer to the SPI handle associated with the NFC chip.
|
||||
* @param[out] rx_data pointer to a byte array to be filled with received data.
|
||||
* @param[in] rx_data_size maximum received data size, in bytes.
|
||||
* @param[out] rx_bits pointer to the variable to contain the received data size, in bits.
|
||||
* @returns FuriHalNfcErrorNone on success, any other error code on failure.
|
||||
*/
|
||||
FuriHalNfcError furi_hal_nfc_common_fifo_rx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
uint8_t* rx_data,
|
||||
size_t rx_data_size,
|
||||
size_t* rx_bits);
|
||||
|
||||
/**
|
||||
* @brief Transmit data in poller mode.
|
||||
*
|
||||
* This function is common to all technologies.
|
||||
*
|
||||
* @param[in,out] handle pointer to the SPI handle associated with the NFC chip.
|
||||
* @param[in] tx_data pointer to a byte array containing the data to be transmitted.
|
||||
* @param[in] tx_bits transmit data size, in bits.
|
||||
* @returns FuriHalNfcErrorNone on success, any other error code on failure.
|
||||
*/
|
||||
FuriHalNfcError furi_hal_nfc_poller_tx_common(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
const uint8_t* tx_data,
|
||||
size_t tx_bits);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,28 @@
|
||||
#include "furi_hal_nfc_i.h"
|
||||
|
||||
#include <lib/drivers/st25r3916.h>
|
||||
#include <furi_hal_resources.h>
|
||||
|
||||
static void furi_hal_nfc_int_callback() {
|
||||
furi_hal_nfc_event_set(FuriHalNfcEventInternalTypeIrq);
|
||||
}
|
||||
|
||||
uint32_t furi_hal_nfc_get_irq(FuriHalSpiBusHandle* handle) {
|
||||
uint32_t irq = 0;
|
||||
while(furi_hal_gpio_read_port_pin(gpio_nfc_irq_rfid_pull.port, gpio_nfc_irq_rfid_pull.pin)) {
|
||||
irq |= st25r3916_get_irq(handle);
|
||||
}
|
||||
return irq;
|
||||
}
|
||||
|
||||
void furi_hal_nfc_init_gpio_isr() {
|
||||
furi_hal_gpio_init(
|
||||
&gpio_nfc_irq_rfid_pull, GpioModeInterruptRise, GpioPullDown, GpioSpeedVeryHigh);
|
||||
furi_hal_gpio_add_int_callback(&gpio_nfc_irq_rfid_pull, furi_hal_nfc_int_callback, NULL);
|
||||
furi_hal_gpio_enable_int_callback(&gpio_nfc_irq_rfid_pull);
|
||||
}
|
||||
|
||||
void furi_hal_nfc_deinit_gpio_isr() {
|
||||
furi_hal_gpio_remove_int_callback(&gpio_nfc_irq_rfid_pull);
|
||||
furi_hal_gpio_init(&gpio_nfc_irq_rfid_pull, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
}
|
||||
@@ -0,0 +1,356 @@
|
||||
#include "furi_hal_nfc_i.h"
|
||||
#include "furi_hal_nfc_tech_i.h"
|
||||
|
||||
#include <furi.h>
|
||||
#include <furi_hal_resources.h>
|
||||
|
||||
#include <digital_signal/presets/nfc/iso14443_3a_signal.h>
|
||||
|
||||
#define TAG "FuriHalIso14443a"
|
||||
|
||||
// Prevent FDT timer from starting
|
||||
#define FURI_HAL_NFC_ISO14443A_LISTENER_FDT_COMP_FC (INT32_MAX)
|
||||
|
||||
static Iso14443_3aSignal* iso14443_3a_signal = NULL;
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso14443a_common_init(FuriHalSpiBusHandle* handle) {
|
||||
// Common NFC-A settings, 106 kbps
|
||||
|
||||
// 1st stage zero = 600kHz, 3rd stage zero = 200 kHz
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_RX_CONF1, ST25R3916_REG_RX_CONF1_z600k);
|
||||
// AGC enabled, ratio 3:1, squelch after TX
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_RX_CONF2,
|
||||
ST25R3916_REG_RX_CONF2_agc6_3 | ST25R3916_REG_RX_CONF2_agc_m |
|
||||
ST25R3916_REG_RX_CONF2_agc_en | ST25R3916_REG_RX_CONF2_sqm_dyn);
|
||||
// HF operation, full gain on AM and PM channels
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_RX_CONF3, 0x00);
|
||||
// No gain reduction on AM and PM channels
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_RX_CONF4, 0x00);
|
||||
// Correlator config
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_CORR_CONF1,
|
||||
ST25R3916_REG_CORR_CONF1_corr_s0 | ST25R3916_REG_CORR_CONF1_corr_s4 |
|
||||
ST25R3916_REG_CORR_CONF1_corr_s6);
|
||||
// Sleep mode disable, 424kHz mode off
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_CORR_CONF2, 0x00);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso14443a_poller_init(FuriHalSpiBusHandle* handle) {
|
||||
// Enable ISO14443A mode, OOK modulation
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_MODE,
|
||||
ST25R3916_REG_MODE_om_mask | ST25R3916_REG_MODE_tr_am,
|
||||
ST25R3916_REG_MODE_om_iso14443a | ST25R3916_REG_MODE_tr_am_ook);
|
||||
|
||||
// Overshoot protection - is this necessary here?
|
||||
st25r3916_change_reg_bits(handle, ST25R3916_REG_OVERSHOOT_CONF1, 0xff, 0x40);
|
||||
st25r3916_change_reg_bits(handle, ST25R3916_REG_OVERSHOOT_CONF2, 0xff, 0x03);
|
||||
st25r3916_change_reg_bits(handle, ST25R3916_REG_UNDERSHOOT_CONF1, 0xff, 0x40);
|
||||
st25r3916_change_reg_bits(handle, ST25R3916_REG_UNDERSHOOT_CONF2, 0xff, 0x03);
|
||||
|
||||
return furi_hal_nfc_iso14443a_common_init(handle);
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso14443a_poller_deinit(FuriHalSpiBusHandle* handle) {
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_ISO14443A_NFC,
|
||||
(ST25R3916_REG_ISO14443A_NFC_no_tx_par | ST25R3916_REG_ISO14443A_NFC_no_rx_par),
|
||||
(ST25R3916_REG_ISO14443A_NFC_no_tx_par_off | ST25R3916_REG_ISO14443A_NFC_no_rx_par_off));
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso14443a_listener_init(FuriHalSpiBusHandle* handle) {
|
||||
furi_check(iso14443_3a_signal == NULL);
|
||||
iso14443_3a_signal = iso14443_3a_signal_alloc(&gpio_spi_r_mosi);
|
||||
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
ST25R3916_REG_OP_CONTROL_en | ST25R3916_REG_OP_CONTROL_rx_en |
|
||||
ST25R3916_REG_OP_CONTROL_en_fd_auto_efd);
|
||||
st25r3916_write_reg(
|
||||
handle, ST25R3916_REG_MODE, ST25R3916_REG_MODE_targ_targ | ST25R3916_REG_MODE_om0);
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_PASSIVE_TARGET,
|
||||
ST25R3916_REG_PASSIVE_TARGET_fdel_2 | ST25R3916_REG_PASSIVE_TARGET_fdel_0 |
|
||||
ST25R3916_REG_PASSIVE_TARGET_d_ac_ap2p | ST25R3916_REG_PASSIVE_TARGET_d_212_424_1r);
|
||||
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_MASK_RX_TIMER, 0x02);
|
||||
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_STOP);
|
||||
uint32_t interrupts =
|
||||
(ST25R3916_IRQ_MASK_FWL | ST25R3916_IRQ_MASK_TXE | ST25R3916_IRQ_MASK_RXS |
|
||||
ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_CRC |
|
||||
ST25R3916_IRQ_MASK_ERR1 | ST25R3916_IRQ_MASK_ERR2 | ST25R3916_IRQ_MASK_NRE |
|
||||
ST25R3916_IRQ_MASK_EON | ST25R3916_IRQ_MASK_EOF | ST25R3916_IRQ_MASK_WU_A_X |
|
||||
ST25R3916_IRQ_MASK_WU_A);
|
||||
// Clear interrupts
|
||||
st25r3916_get_irq(handle);
|
||||
// Enable interrupts
|
||||
st25r3916_mask_irq(handle, ~interrupts);
|
||||
// Enable auto collision resolution
|
||||
st25r3916_clear_reg_bits(
|
||||
handle, ST25R3916_REG_PASSIVE_TARGET, ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_GOTO_SENSE);
|
||||
|
||||
return furi_hal_nfc_iso14443a_common_init(handle);
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso14443a_listener_deinit(FuriHalSpiBusHandle* handle) {
|
||||
UNUSED(handle);
|
||||
|
||||
if(iso14443_3a_signal) {
|
||||
iso14443_3a_signal_free(iso14443_3a_signal);
|
||||
iso14443_3a_signal = NULL;
|
||||
}
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static FuriHalNfcEvent furi_hal_nfc_iso14443_3a_listener_wait_event(uint32_t timeout_ms) {
|
||||
FuriHalNfcEvent event = furi_hal_nfc_wait_event_common(timeout_ms);
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
if(event & FuriHalNfcEventListenerActive) {
|
||||
st25r3916_set_reg_bits(
|
||||
handle, ST25R3916_REG_PASSIVE_TARGET, ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a);
|
||||
}
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_iso14443a_poller_trx_short_frame(FuriHalNfcaShortFrame frame) {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
// Disable crc check
|
||||
st25r3916_set_reg_bits(handle, ST25R3916_REG_AUX, ST25R3916_REG_AUX_no_crc_rx);
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_ISO14443A_NFC,
|
||||
(ST25R3916_REG_ISO14443A_NFC_no_tx_par | ST25R3916_REG_ISO14443A_NFC_no_rx_par),
|
||||
(ST25R3916_REG_ISO14443A_NFC_no_tx_par_off | ST25R3916_REG_ISO14443A_NFC_no_rx_par_off));
|
||||
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_NUM_TX_BYTES2, 0);
|
||||
uint32_t interrupts =
|
||||
(ST25R3916_IRQ_MASK_FWL | ST25R3916_IRQ_MASK_TXE | ST25R3916_IRQ_MASK_RXS |
|
||||
ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_CRC |
|
||||
ST25R3916_IRQ_MASK_ERR1 | ST25R3916_IRQ_MASK_ERR2 | ST25R3916_IRQ_MASK_NRE);
|
||||
// Clear interrupts
|
||||
st25r3916_get_irq(handle);
|
||||
// Enable interrupts
|
||||
st25r3916_mask_irq(handle, ~interrupts);
|
||||
if(frame == FuriHalNfcaShortFrameAllReq) {
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_TRANSMIT_REQA);
|
||||
} else {
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_TRANSMIT_WUPA);
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_iso14443a_tx_sdd_frame(const uint8_t* tx_data, size_t tx_bits) {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
// No anticollision is supported in this version of library
|
||||
error = furi_hal_nfc_poller_tx(tx_data, tx_bits);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError
|
||||
furi_hal_nfc_iso14443a_rx_sdd_frame(uint8_t* rx_data, size_t rx_data_size, size_t* rx_bits) {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
UNUSED(rx_data);
|
||||
UNUSED(rx_bits);
|
||||
UNUSED(rx_data_size);
|
||||
|
||||
error = furi_hal_nfc_poller_rx(rx_data, rx_data_size, rx_bits);
|
||||
// No anticollision is supported in this version of library
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError
|
||||
furi_hal_nfc_iso14443a_poller_tx_custom_parity(const uint8_t* tx_data, size_t tx_bits) {
|
||||
furi_assert(tx_data);
|
||||
|
||||
FuriHalNfcError err = FuriHalNfcErrorNone;
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
// Prepare tx
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_CLEAR_FIFO);
|
||||
st25r3916_clear_reg_bits(
|
||||
handle, ST25R3916_REG_TIMER_EMV_CONTROL, ST25R3916_REG_TIMER_EMV_CONTROL_nrt_emv);
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_ISO14443A_NFC,
|
||||
(ST25R3916_REG_ISO14443A_NFC_no_tx_par | ST25R3916_REG_ISO14443A_NFC_no_rx_par),
|
||||
(ST25R3916_REG_ISO14443A_NFC_no_tx_par | ST25R3916_REG_ISO14443A_NFC_no_rx_par));
|
||||
uint32_t interrupts =
|
||||
(ST25R3916_IRQ_MASK_FWL | ST25R3916_IRQ_MASK_TXE | ST25R3916_IRQ_MASK_RXS |
|
||||
ST25R3916_IRQ_MASK_RXE | ST25R3916_IRQ_MASK_PAR | ST25R3916_IRQ_MASK_CRC |
|
||||
ST25R3916_IRQ_MASK_ERR1 | ST25R3916_IRQ_MASK_ERR2 | ST25R3916_IRQ_MASK_NRE);
|
||||
// Clear interrupts
|
||||
st25r3916_get_irq(handle);
|
||||
// Enable interrupts
|
||||
st25r3916_mask_irq(handle, ~interrupts);
|
||||
|
||||
st25r3916_write_fifo(handle, tx_data, tx_bits);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_TRANSMIT_WITHOUT_CRC);
|
||||
return err;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_iso14443a_listener_set_col_res_data(
|
||||
uint8_t* uid,
|
||||
uint8_t uid_len,
|
||||
uint8_t* atqa,
|
||||
uint8_t sak) {
|
||||
furi_assert(uid);
|
||||
furi_assert(atqa);
|
||||
UNUSED(uid_len);
|
||||
UNUSED(sak);
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
// Set 4 or 7 bytes UID
|
||||
if(uid_len == 4) {
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_AUX,
|
||||
ST25R3916_REG_AUX_nfc_id_mask,
|
||||
ST25R3916_REG_AUX_nfc_id_4bytes);
|
||||
} else {
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_AUX,
|
||||
ST25R3916_REG_AUX_nfc_id_mask,
|
||||
ST25R3916_REG_AUX_nfc_id_7bytes);
|
||||
}
|
||||
// Write PT Memory
|
||||
uint8_t pt_memory[15] = {};
|
||||
memcpy(pt_memory, uid, uid_len);
|
||||
pt_memory[10] = atqa[0];
|
||||
pt_memory[11] = atqa[1];
|
||||
if(uid_len == 4) {
|
||||
pt_memory[12] = sak & ~0x04;
|
||||
} else {
|
||||
pt_memory[12] = 0x04;
|
||||
}
|
||||
pt_memory[13] = sak & ~0x04;
|
||||
pt_memory[14] = sak & ~0x04;
|
||||
|
||||
st25r3916_write_pta_mem(handle, pt_memory, sizeof(pt_memory));
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_iso4443a_listener_tx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
const uint8_t* tx_data,
|
||||
size_t tx_bits) {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
|
||||
do {
|
||||
error = furi_hal_nfc_common_fifo_tx(handle, tx_data, tx_bits);
|
||||
if(error != FuriHalNfcErrorNone) break;
|
||||
|
||||
bool tx_end = furi_hal_nfc_event_wait_for_specific_irq(handle, ST25R3916_IRQ_MASK_TXE, 10);
|
||||
if(!tx_end) {
|
||||
error = FuriHalNfcErrorCommunicationTimeout;
|
||||
break;
|
||||
}
|
||||
|
||||
} while(false);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_iso14443a_listener_tx_custom_parity(
|
||||
const uint8_t* tx_data,
|
||||
const uint8_t* tx_parity,
|
||||
size_t tx_bits) {
|
||||
furi_assert(tx_data);
|
||||
furi_assert(tx_parity);
|
||||
|
||||
furi_assert(iso14443_3a_signal);
|
||||
|
||||
FuriHalSpiBusHandle* handle = &furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_TRANSPARENT_MODE);
|
||||
// Reconfigure gpio for Transparent mode
|
||||
furi_hal_spi_bus_handle_deinit(&furi_hal_spi_bus_handle_nfc);
|
||||
|
||||
// Send signal
|
||||
iso14443_3a_signal_tx(iso14443_3a_signal, tx_data, tx_parity, tx_bits);
|
||||
|
||||
// Exit transparent mode
|
||||
furi_hal_gpio_write(&gpio_spi_r_mosi, false);
|
||||
|
||||
// Configure gpio back to SPI and exit transparent
|
||||
furi_hal_spi_bus_handle_init(&furi_hal_spi_bus_handle_nfc);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_UNMASK_RECEIVE_DATA);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_iso14443_3a_listener_sleep(FuriHalSpiBusHandle* handle) {
|
||||
// Enable auto collision resolution
|
||||
st25r3916_clear_reg_bits(
|
||||
handle, ST25R3916_REG_PASSIVE_TARGET, ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_STOP);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_GOTO_SLEEP);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_iso14443_3a_listener_idle(FuriHalSpiBusHandle* handle) {
|
||||
// Enable auto collision resolution
|
||||
st25r3916_clear_reg_bits(
|
||||
handle, ST25R3916_REG_PASSIVE_TARGET, ST25R3916_REG_PASSIVE_TARGET_d_106_ac_a);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_STOP);
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_GOTO_SENSE);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
const FuriHalNfcTechBase furi_hal_nfc_iso14443a = {
|
||||
.poller =
|
||||
{
|
||||
.compensation =
|
||||
{
|
||||
.fdt = FURI_HAL_NFC_POLLER_FDT_COMP_FC,
|
||||
.fwt = FURI_HAL_NFC_POLLER_FWT_COMP_FC,
|
||||
},
|
||||
.init = furi_hal_nfc_iso14443a_poller_init,
|
||||
.deinit = furi_hal_nfc_iso14443a_poller_deinit,
|
||||
.wait_event = furi_hal_nfc_wait_event_common,
|
||||
.tx = furi_hal_nfc_poller_tx_common,
|
||||
.rx = furi_hal_nfc_common_fifo_rx,
|
||||
},
|
||||
|
||||
.listener =
|
||||
{
|
||||
.compensation =
|
||||
{
|
||||
.fdt = FURI_HAL_NFC_ISO14443A_LISTENER_FDT_COMP_FC,
|
||||
},
|
||||
.init = furi_hal_nfc_iso14443a_listener_init,
|
||||
.deinit = furi_hal_nfc_iso14443a_listener_deinit,
|
||||
.wait_event = furi_hal_nfc_iso14443_3a_listener_wait_event,
|
||||
.tx = furi_hal_nfc_iso4443a_listener_tx,
|
||||
.rx = furi_hal_nfc_common_fifo_rx,
|
||||
.sleep = furi_hal_nfc_iso14443_3a_listener_sleep,
|
||||
.idle = furi_hal_nfc_iso14443_3a_listener_idle,
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,108 @@
|
||||
#include "furi_hal_nfc_i.h"
|
||||
#include "furi_hal_nfc_tech_i.h"
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso14443b_common_init(FuriHalSpiBusHandle* handle) {
|
||||
// Common NFC-B settings, 106kbps
|
||||
|
||||
// 1st stage zero = 60kHz, 3rd stage zero = 200 kHz
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_RX_CONF1, ST25R3916_REG_RX_CONF1_h200);
|
||||
|
||||
// Enable AGC
|
||||
// AGC Ratio 6
|
||||
// AGC algorithm with RESET (recommended for ISO14443-B)
|
||||
// AGC operation during complete receive period
|
||||
// Squelch ratio 6/3 (recommended for ISO14443-B)
|
||||
// Squelch automatic activation on TX end
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_RX_CONF2,
|
||||
ST25R3916_REG_RX_CONF2_agc6_3 | ST25R3916_REG_RX_CONF2_agc_alg |
|
||||
ST25R3916_REG_RX_CONF2_agc_m | ST25R3916_REG_RX_CONF2_agc_en |
|
||||
ST25R3916_REG_RX_CONF2_pulz_61 | ST25R3916_REG_RX_CONF2_sqm_dyn);
|
||||
|
||||
// HF operation, full gain on AM and PM channels
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_RX_CONF3, 0x00);
|
||||
// No gain reduction on AM and PM channels
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_RX_CONF4, 0x00);
|
||||
|
||||
// Subcarrier end detector enabled
|
||||
// Subcarrier end detection level = 66%
|
||||
// BPSK start 33 pilot pulses
|
||||
// AM & PM summation before digitizing on
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_CORR_CONF1,
|
||||
ST25R3916_REG_CORR_CONF1_corr_s0 | ST25R3916_REG_CORR_CONF1_corr_s1 |
|
||||
ST25R3916_REG_CORR_CONF1_corr_s3 | ST25R3916_REG_CORR_CONF1_corr_s4);
|
||||
// Sleep mode disable, 424kHz mode off
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_CORR_CONF2, 0x00);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso14443b_poller_init(FuriHalSpiBusHandle* handle) {
|
||||
// Enable ISO14443B mode, AM modulation
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_MODE,
|
||||
ST25R3916_REG_MODE_om_mask | ST25R3916_REG_MODE_tr_am,
|
||||
ST25R3916_REG_MODE_om_iso14443b | ST25R3916_REG_MODE_tr_am_am);
|
||||
|
||||
// 10% ASK modulation
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_TX_DRIVER,
|
||||
ST25R3916_REG_TX_DRIVER_am_mod_mask,
|
||||
ST25R3916_REG_TX_DRIVER_am_mod_10percent);
|
||||
|
||||
// Use regulator AM, resistive AM disabled
|
||||
st25r3916_clear_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_AUX_MOD,
|
||||
ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am);
|
||||
|
||||
// EGT = 0 etu
|
||||
// SOF = 10 etu LOW + 2 etu HIGH
|
||||
// EOF = 10 etu
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_ISO14443B_1,
|
||||
ST25R3916_REG_ISO14443B_1_egt_mask | ST25R3916_REG_ISO14443B_1_sof_mask |
|
||||
ST25R3916_REG_ISO14443B_1_eof,
|
||||
(0U << ST25R3916_REG_ISO14443B_1_egt_shift) | ST25R3916_REG_ISO14443B_1_sof_0_10etu |
|
||||
ST25R3916_REG_ISO14443B_1_sof_1_2etu | ST25R3916_REG_ISO14443B_1_eof_10etu);
|
||||
|
||||
// TR1 = 80 / fs
|
||||
// B' mode off (no_sof & no_eof = 0)
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_ISO14443B_2,
|
||||
ST25R3916_REG_ISO14443B_2_tr1_mask | ST25R3916_REG_ISO14443B_2_no_sof |
|
||||
ST25R3916_REG_ISO14443B_2_no_eof,
|
||||
ST25R3916_REG_ISO14443B_2_tr1_80fs80fs);
|
||||
|
||||
return furi_hal_nfc_iso14443b_common_init(handle);
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso14443b_poller_deinit(FuriHalSpiBusHandle* handle) {
|
||||
UNUSED(handle);
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
const FuriHalNfcTechBase furi_hal_nfc_iso14443b = {
|
||||
.poller =
|
||||
{
|
||||
.compensation =
|
||||
{
|
||||
.fdt = FURI_HAL_NFC_POLLER_FDT_COMP_FC,
|
||||
.fwt = FURI_HAL_NFC_POLLER_FWT_COMP_FC,
|
||||
},
|
||||
.init = furi_hal_nfc_iso14443b_poller_init,
|
||||
.deinit = furi_hal_nfc_iso14443b_poller_deinit,
|
||||
.wait_event = furi_hal_nfc_wait_event_common,
|
||||
.tx = furi_hal_nfc_poller_tx_common,
|
||||
.rx = furi_hal_nfc_common_fifo_rx,
|
||||
},
|
||||
|
||||
.listener = {},
|
||||
};
|
||||
@@ -0,0 +1,463 @@
|
||||
#include "furi_hal_nfc_i.h"
|
||||
#include "furi_hal_nfc_tech_i.h"
|
||||
|
||||
#include <digital_signal/presets/nfc/iso15693_signal.h>
|
||||
#include <signal_reader/parsers/iso15693/iso15693_parser.h>
|
||||
|
||||
#include <furi_hal_resources.h>
|
||||
|
||||
#define FURI_HAL_NFC_ISO15693_MAX_FRAME_SIZE (1024U)
|
||||
#define FURI_HAL_NFC_ISO15693_POLLER_MAX_BUFFER_SIZE (64)
|
||||
|
||||
#define FURI_HAL_NFC_ISO15693_RESP_SOF_SIZE (5)
|
||||
#define FURI_HAL_NFC_ISO15693_RESP_EOF_SIZE (5)
|
||||
#define FURI_HAL_NFC_ISO15693_RESP_SOF_MASK (0x1FU)
|
||||
#define FURI_HAL_NFC_ISO15693_RESP_SOF_PATTERN (0x17U)
|
||||
#define FURI_HAL_NFC_ISO15693_RESP_EOF_PATTERN (0x1DU)
|
||||
|
||||
#define FURI_HAL_NFC_ISO15693_RESP_PATTERN_MASK (0x03U)
|
||||
#define FURI_HAL_NFC_ISO15693_RESP_PATTERN_0 (0x01U)
|
||||
#define FURI_HAL_NFC_ISO15693_RESP_PATTERN_1 (0x02U)
|
||||
|
||||
// Derived experimentally
|
||||
#define FURI_HAL_NFC_ISO15693_POLLER_FWT_COMP_FC (-1300)
|
||||
#define FURI_HAL_NFC_ISO15693_LISTENER_FDT_COMP_FC (2850)
|
||||
|
||||
#define BITS_IN_BYTE (8U)
|
||||
|
||||
#define TAG "FuriHalIso15693"
|
||||
|
||||
typedef struct {
|
||||
Iso15693Signal* signal;
|
||||
Iso15693Parser* parser;
|
||||
} FuriHalNfcIso15693Listener;
|
||||
|
||||
typedef struct {
|
||||
// 4 bits per data bit on transmit
|
||||
uint8_t fifo_buf[FURI_HAL_NFC_ISO15693_POLLER_MAX_BUFFER_SIZE * 4];
|
||||
size_t fifo_buf_bits;
|
||||
uint8_t frame_buf[FURI_HAL_NFC_ISO15693_POLLER_MAX_BUFFER_SIZE * 2];
|
||||
size_t frame_buf_bits;
|
||||
} FuriHalNfcIso15693Poller;
|
||||
|
||||
static FuriHalNfcIso15693Listener* furi_hal_nfc_iso15693_listener = NULL;
|
||||
static FuriHalNfcIso15693Poller* furi_hal_nfc_iso15693_poller = NULL;
|
||||
|
||||
static FuriHalNfcIso15693Listener* furi_hal_nfc_iso15693_listener_alloc() {
|
||||
FuriHalNfcIso15693Listener* instance = malloc(sizeof(FuriHalNfcIso15693Listener));
|
||||
|
||||
instance->signal = iso15693_signal_alloc(&gpio_spi_r_mosi);
|
||||
instance->parser =
|
||||
iso15693_parser_alloc(&gpio_nfc_irq_rfid_pull, FURI_HAL_NFC_ISO15693_MAX_FRAME_SIZE);
|
||||
|
||||
return instance;
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_iso15693_listener_free(FuriHalNfcIso15693Listener* instance) {
|
||||
furi_assert(instance);
|
||||
|
||||
iso15693_signal_free(instance->signal);
|
||||
iso15693_parser_free(instance->parser);
|
||||
|
||||
free(instance);
|
||||
}
|
||||
|
||||
static FuriHalNfcIso15693Poller* furi_hal_nfc_iso15693_poller_alloc() {
|
||||
FuriHalNfcIso15693Poller* instance = malloc(sizeof(FuriHalNfcIso15693Poller));
|
||||
|
||||
return instance;
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_iso15693_poller_free(FuriHalNfcIso15693Poller* instance) {
|
||||
furi_assert(instance);
|
||||
|
||||
free(instance);
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso15693_common_init(FuriHalSpiBusHandle* handle) {
|
||||
// Common NFC-V settings, 26.48 kbps
|
||||
|
||||
// 1st stage zero = 12 kHz, 3rd stage zero = 80 kHz, low-pass = 600 kHz
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_RX_CONF1,
|
||||
ST25R3916_REG_RX_CONF1_z12k | ST25R3916_REG_RX_CONF1_h80 |
|
||||
ST25R3916_REG_RX_CONF1_lp_600khz);
|
||||
|
||||
// Enable AGC
|
||||
// AGC Ratio 6
|
||||
// AGC algorithm with RESET (recommended for ISO15693)
|
||||
// AGC operation during complete receive period
|
||||
// Squelch automatic activation on TX end
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_RX_CONF2,
|
||||
ST25R3916_REG_RX_CONF2_agc6_3 | ST25R3916_REG_RX_CONF2_agc_m |
|
||||
ST25R3916_REG_RX_CONF2_agc_en | ST25R3916_REG_RX_CONF2_sqm_dyn);
|
||||
|
||||
// HF operation, full gain on AM and PM channels
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_RX_CONF3, 0x00);
|
||||
// No gain reduction on AM and PM channels
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_RX_CONF4, 0x00);
|
||||
|
||||
// Collision detection level 53%
|
||||
// AM & PM summation before digitizing on
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_CORR_CONF1,
|
||||
ST25R3916_REG_CORR_CONF1_corr_s0 | ST25R3916_REG_CORR_CONF1_corr_s1 |
|
||||
ST25R3916_REG_CORR_CONF1_corr_s4);
|
||||
// 424 kHz subcarrier stream mode on
|
||||
st25r3916_write_reg(handle, ST25R3916_REG_CORR_CONF2, ST25R3916_REG_CORR_CONF2_corr_s8);
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso15693_poller_init(FuriHalSpiBusHandle* handle) {
|
||||
furi_assert(furi_hal_nfc_iso15693_poller == NULL);
|
||||
|
||||
furi_hal_nfc_iso15693_poller = furi_hal_nfc_iso15693_poller_alloc();
|
||||
|
||||
// Enable Subcarrier Stream mode, OOK modulation
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_MODE,
|
||||
ST25R3916_REG_MODE_om_mask | ST25R3916_REG_MODE_tr_am,
|
||||
ST25R3916_REG_MODE_om_subcarrier_stream | ST25R3916_REG_MODE_tr_am_ook);
|
||||
|
||||
// Subcarrier 424 kHz mode
|
||||
// 8 sub-carrier pulses in report period
|
||||
st25r3916_write_reg(
|
||||
handle,
|
||||
ST25R3916_REG_STREAM_MODE,
|
||||
ST25R3916_REG_STREAM_MODE_scf_sc424 | ST25R3916_REG_STREAM_MODE_stx_106 |
|
||||
ST25R3916_REG_STREAM_MODE_scp_8pulses);
|
||||
|
||||
// Use regulator AM, resistive AM disabled
|
||||
st25r3916_clear_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_AUX_MOD,
|
||||
ST25R3916_REG_AUX_MOD_dis_reg_am | ST25R3916_REG_AUX_MOD_res_am);
|
||||
|
||||
return furi_hal_nfc_iso15693_common_init(handle);
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso15693_poller_deinit(FuriHalSpiBusHandle* handle) {
|
||||
UNUSED(handle);
|
||||
furi_assert(furi_hal_nfc_iso15693_poller);
|
||||
|
||||
furi_hal_nfc_iso15693_poller_free(furi_hal_nfc_iso15693_poller);
|
||||
furi_hal_nfc_iso15693_poller = NULL;
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static void iso15693_3_poller_encode_frame(
|
||||
const uint8_t* tx_data,
|
||||
size_t tx_bits,
|
||||
uint8_t* frame_buf,
|
||||
size_t frame_buf_size,
|
||||
size_t* frame_buf_bits) {
|
||||
static const uint8_t bit_patterns_1_out_of_4[] = {0x02, 0x08, 0x20, 0x80};
|
||||
size_t frame_buf_size_calc = (tx_bits / 2) + 2;
|
||||
furi_assert(frame_buf_size >= frame_buf_size_calc);
|
||||
|
||||
// Add SOF 1 out of 4
|
||||
frame_buf[0] = 0x21;
|
||||
|
||||
size_t byte_pos = 1;
|
||||
for(size_t i = 0; i < tx_bits / BITS_IN_BYTE; ++i) {
|
||||
for(size_t j = 0; j < BITS_IN_BYTE; j += (BITS_IN_BYTE) / 4) {
|
||||
const uint8_t bit_pair = (tx_data[i] >> j) & 0x03;
|
||||
frame_buf[byte_pos++] = bit_patterns_1_out_of_4[bit_pair];
|
||||
}
|
||||
}
|
||||
// Add EOF
|
||||
frame_buf[byte_pos++] = 0x04;
|
||||
*frame_buf_bits = byte_pos * BITS_IN_BYTE;
|
||||
}
|
||||
|
||||
static FuriHalNfcError iso15693_3_poller_decode_frame(
|
||||
const uint8_t* buf,
|
||||
size_t buf_bits,
|
||||
uint8_t* buf_decoded,
|
||||
size_t buf_decoded_size,
|
||||
size_t* buf_decoded_bits) {
|
||||
FuriHalNfcError ret = FuriHalNfcErrorDataFormat;
|
||||
size_t bit_pos = 0;
|
||||
memset(buf_decoded, 0, buf_decoded_size);
|
||||
|
||||
do {
|
||||
if(buf_bits == 0) break;
|
||||
// Check SOF
|
||||
if((buf[0] & FURI_HAL_NFC_ISO15693_RESP_SOF_MASK) !=
|
||||
FURI_HAL_NFC_ISO15693_RESP_SOF_PATTERN)
|
||||
break;
|
||||
|
||||
if(buf_bits == BITS_IN_BYTE) {
|
||||
ret = FuriHalNfcErrorIncompleteFrame;
|
||||
break;
|
||||
}
|
||||
|
||||
// 2 response bits = 1 data bit
|
||||
for(uint32_t i = FURI_HAL_NFC_ISO15693_RESP_SOF_SIZE;
|
||||
i < buf_bits - FURI_HAL_NFC_ISO15693_RESP_SOF_SIZE;
|
||||
i += BITS_IN_BYTE / 4) {
|
||||
const size_t byte_index = i / BITS_IN_BYTE;
|
||||
const size_t bit_offset = i % BITS_IN_BYTE;
|
||||
const uint8_t resp_byte = (buf[byte_index] >> bit_offset) |
|
||||
(buf[byte_index + 1] << (BITS_IN_BYTE - bit_offset));
|
||||
|
||||
// Check EOF
|
||||
if(resp_byte == FURI_HAL_NFC_ISO15693_RESP_EOF_PATTERN) {
|
||||
ret = FuriHalNfcErrorNone;
|
||||
break;
|
||||
}
|
||||
|
||||
const uint8_t bit_pattern = resp_byte & FURI_HAL_NFC_ISO15693_RESP_PATTERN_MASK;
|
||||
|
||||
if(bit_pattern == FURI_HAL_NFC_ISO15693_RESP_PATTERN_0) {
|
||||
bit_pos++;
|
||||
} else if(bit_pattern == FURI_HAL_NFC_ISO15693_RESP_PATTERN_1) {
|
||||
buf_decoded[bit_pos / BITS_IN_BYTE] |= 1 << (bit_pos % BITS_IN_BYTE);
|
||||
bit_pos++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
if(bit_pos / BITS_IN_BYTE > buf_decoded_size) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
} while(false);
|
||||
|
||||
if(ret == FuriHalNfcErrorNone) {
|
||||
*buf_decoded_bits = bit_pos;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso15693_poller_tx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
const uint8_t* tx_data,
|
||||
size_t tx_bits) {
|
||||
FuriHalNfcIso15693Poller* instance = furi_hal_nfc_iso15693_poller;
|
||||
iso15693_3_poller_encode_frame(
|
||||
tx_data,
|
||||
tx_bits,
|
||||
instance->frame_buf,
|
||||
sizeof(instance->frame_buf),
|
||||
&instance->frame_buf_bits);
|
||||
return furi_hal_nfc_poller_tx_common(handle, instance->frame_buf, instance->frame_buf_bits);
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso15693_poller_rx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
uint8_t* rx_data,
|
||||
size_t rx_data_size,
|
||||
size_t* rx_bits) {
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
FuriHalNfcIso15693Poller* instance = furi_hal_nfc_iso15693_poller;
|
||||
|
||||
do {
|
||||
error = furi_hal_nfc_common_fifo_rx(
|
||||
handle, instance->fifo_buf, sizeof(instance->fifo_buf), &instance->fifo_buf_bits);
|
||||
if(error != FuriHalNfcErrorNone) break;
|
||||
|
||||
error = iso15693_3_poller_decode_frame(
|
||||
instance->fifo_buf,
|
||||
instance->fifo_buf_bits,
|
||||
instance->frame_buf,
|
||||
sizeof(instance->frame_buf),
|
||||
&instance->frame_buf_bits);
|
||||
if(error != FuriHalNfcErrorNone) break;
|
||||
|
||||
if(rx_data_size < instance->frame_buf_bits / BITS_IN_BYTE) {
|
||||
error = FuriHalNfcErrorBufferOverflow;
|
||||
break;
|
||||
}
|
||||
|
||||
memcpy(rx_data, instance->frame_buf, instance->frame_buf_bits / BITS_IN_BYTE);
|
||||
*rx_bits = instance->frame_buf_bits;
|
||||
} while(false);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_iso15693_listener_transparent_mode_enter(FuriHalSpiBusHandle* handle) {
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_TRANSPARENT_MODE);
|
||||
|
||||
furi_hal_spi_bus_handle_deinit(handle);
|
||||
furi_hal_nfc_deinit_gpio_isr();
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_iso15693_listener_transparent_mode_exit(FuriHalSpiBusHandle* handle) {
|
||||
// Configure gpio back to SPI and exit transparent mode
|
||||
furi_hal_nfc_init_gpio_isr();
|
||||
furi_hal_spi_bus_handle_init(handle);
|
||||
|
||||
st25r3916_direct_cmd(handle, ST25R3916_CMD_UNMASK_RECEIVE_DATA);
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso15693_listener_init(FuriHalSpiBusHandle* handle) {
|
||||
furi_assert(furi_hal_nfc_iso15693_listener == NULL);
|
||||
|
||||
furi_hal_nfc_iso15693_listener = furi_hal_nfc_iso15693_listener_alloc();
|
||||
|
||||
// Set default operation mode
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_MODE,
|
||||
ST25R3916_REG_MODE_om_mask | ST25R3916_REG_MODE_tr_am,
|
||||
ST25R3916_REG_MODE_om_targ_nfca | ST25R3916_REG_MODE_tr_am_ook);
|
||||
|
||||
st25r3916_change_reg_bits(
|
||||
handle,
|
||||
ST25R3916_REG_OP_CONTROL,
|
||||
ST25R3916_REG_OP_CONTROL_rx_en,
|
||||
ST25R3916_REG_OP_CONTROL_rx_en);
|
||||
|
||||
// Enable passive target mode
|
||||
st25r3916_change_reg_bits(
|
||||
handle, ST25R3916_REG_MODE, ST25R3916_REG_MODE_targ, ST25R3916_REG_MODE_targ_targ);
|
||||
|
||||
FuriHalNfcError error = furi_hal_nfc_iso15693_common_init(handle);
|
||||
|
||||
furi_hal_nfc_iso15693_listener_transparent_mode_enter(handle);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso15693_listener_deinit(FuriHalSpiBusHandle* handle) {
|
||||
furi_assert(furi_hal_nfc_iso15693_listener);
|
||||
|
||||
furi_hal_nfc_iso15693_listener_transparent_mode_exit(handle);
|
||||
|
||||
furi_hal_nfc_iso15693_listener_free(furi_hal_nfc_iso15693_listener);
|
||||
furi_hal_nfc_iso15693_listener = NULL;
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static FuriHalNfcError
|
||||
furi_hal_nfc_iso15693_listener_tx_transparent(const uint8_t* data, size_t data_size) {
|
||||
iso15693_signal_tx(
|
||||
furi_hal_nfc_iso15693_listener->signal, Iso15693SignalDataRateHi, data, data_size);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_iso15693_parser_callback(Iso15693ParserEvent event, void* context) {
|
||||
furi_assert(context);
|
||||
|
||||
if(event == Iso15693ParserEventDataReceived) {
|
||||
FuriThreadId thread_id = context;
|
||||
furi_thread_flags_set(thread_id, FuriHalNfcEventInternalTypeTransparentDataReceived);
|
||||
}
|
||||
}
|
||||
|
||||
static FuriHalNfcEvent furi_hal_nfc_iso15693_wait_event(uint32_t timeout_ms) {
|
||||
FuriHalNfcEvent event = 0;
|
||||
|
||||
FuriThreadId thread_id = furi_thread_get_current_id();
|
||||
iso15693_parser_start(
|
||||
furi_hal_nfc_iso15693_listener->parser, furi_hal_nfc_iso15693_parser_callback, thread_id);
|
||||
|
||||
while(true) {
|
||||
uint32_t flag = furi_thread_flags_wait(
|
||||
FuriHalNfcEventInternalTypeAbort | FuriHalNfcEventInternalTypeTransparentDataReceived,
|
||||
FuriFlagWaitAny,
|
||||
timeout_ms);
|
||||
furi_thread_flags_clear(flag);
|
||||
|
||||
if(flag & FuriHalNfcEventInternalTypeAbort) {
|
||||
event = FuriHalNfcEventAbortRequest;
|
||||
break;
|
||||
}
|
||||
if(flag & FuriHalNfcEventInternalTypeTransparentDataReceived) {
|
||||
if(iso15693_parser_run(furi_hal_nfc_iso15693_listener->parser)) {
|
||||
event = FuriHalNfcEventRxEnd;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
iso15693_parser_stop(furi_hal_nfc_iso15693_listener->parser);
|
||||
|
||||
return event;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso15693_listener_tx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
const uint8_t* tx_data,
|
||||
size_t tx_bits) {
|
||||
UNUSED(handle);
|
||||
furi_assert(furi_hal_nfc_iso15693_listener);
|
||||
|
||||
FuriHalNfcError error = FuriHalNfcErrorNone;
|
||||
|
||||
error = furi_hal_nfc_iso15693_listener_tx_transparent(tx_data, tx_bits / BITS_IN_BYTE);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_iso15693_listener_tx_sof() {
|
||||
iso15693_signal_tx_sof(furi_hal_nfc_iso15693_listener->signal, Iso15693SignalDataRateHi);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
static FuriHalNfcError furi_hal_nfc_iso15693_listener_rx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
uint8_t* rx_data,
|
||||
size_t rx_data_size,
|
||||
size_t* rx_bits) {
|
||||
furi_assert(furi_hal_nfc_iso15693_listener);
|
||||
UNUSED(handle);
|
||||
|
||||
if(rx_data_size <
|
||||
iso15693_parser_get_data_size_bytes(furi_hal_nfc_iso15693_listener->parser)) {
|
||||
return FuriHalNfcErrorBufferOverflow;
|
||||
}
|
||||
|
||||
iso15693_parser_get_data(
|
||||
furi_hal_nfc_iso15693_listener->parser, rx_data, rx_data_size, rx_bits);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
FuriHalNfcError furi_hal_nfc_iso15693_listener_sleep(FuriHalSpiBusHandle* handle) {
|
||||
UNUSED(handle);
|
||||
|
||||
return FuriHalNfcErrorNone;
|
||||
}
|
||||
|
||||
const FuriHalNfcTechBase furi_hal_nfc_iso15693 = {
|
||||
.poller =
|
||||
{
|
||||
.compensation =
|
||||
{
|
||||
.fdt = FURI_HAL_NFC_POLLER_FDT_COMP_FC,
|
||||
.fwt = FURI_HAL_NFC_ISO15693_POLLER_FWT_COMP_FC,
|
||||
},
|
||||
.init = furi_hal_nfc_iso15693_poller_init,
|
||||
.deinit = furi_hal_nfc_iso15693_poller_deinit,
|
||||
.wait_event = furi_hal_nfc_wait_event_common,
|
||||
.tx = furi_hal_nfc_iso15693_poller_tx,
|
||||
.rx = furi_hal_nfc_iso15693_poller_rx,
|
||||
},
|
||||
|
||||
.listener =
|
||||
{
|
||||
.compensation =
|
||||
{
|
||||
.fdt = FURI_HAL_NFC_ISO15693_LISTENER_FDT_COMP_FC,
|
||||
},
|
||||
.init = furi_hal_nfc_iso15693_listener_init,
|
||||
.deinit = furi_hal_nfc_iso15693_listener_deinit,
|
||||
.wait_event = furi_hal_nfc_iso15693_wait_event,
|
||||
.tx = furi_hal_nfc_iso15693_listener_tx,
|
||||
.rx = furi_hal_nfc_iso15693_listener_rx,
|
||||
.sleep = furi_hal_nfc_iso15693_listener_sleep,
|
||||
.idle = furi_hal_nfc_iso15693_listener_sleep,
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,167 @@
|
||||
/**
|
||||
* @file furi_hal_nfc_tech_i.h
|
||||
* @brief NFC HAL technology-related private definitions.
|
||||
*
|
||||
* This file is an implementation detail. It must not be included in
|
||||
* any public API-related headers.
|
||||
*
|
||||
* This file is to be changed in an unlikely event of adding support
|
||||
* for a new NFC technology.
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include <furi_hal_nfc.h>
|
||||
#include <furi_hal_spi.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Configure the NFC chip for use with this technology.
|
||||
*
|
||||
* Used for init() and deinit() functions.
|
||||
*
|
||||
* @param[in,out] handle pointer to the NFC chip SPI handle.
|
||||
* @returns FuriHalNfcErrorNone on success, any other error code on failure.
|
||||
*/
|
||||
typedef FuriHalNfcError (*FuriHalNfcChipConfig)(FuriHalSpiBusHandle* handle);
|
||||
|
||||
/**
|
||||
* @brief Transmit data using technology-specific framing and timings.
|
||||
*
|
||||
* @param[in,out] handle pointer to the NFC chip SPI handle.
|
||||
* @param[in] tx_data pointer to a byte array containing the data to be transmitted.
|
||||
* @param[in] tx_bits transmit data size, in bits.
|
||||
* @returns FuriHalNfcErrorNone on success, any other error code on failure.
|
||||
*/
|
||||
typedef FuriHalNfcError (
|
||||
*FuriHalNfcTx)(FuriHalSpiBusHandle* handle, const uint8_t* tx_data, size_t tx_bits);
|
||||
|
||||
/**
|
||||
* @brief Receive data using technology-specific framing and timings.
|
||||
*
|
||||
* @param[in,out] handle pointer to the NFC chip SPI handle.
|
||||
* @param[out] rx_data pointer to a byte array to be filled with received data.
|
||||
* @param[in] rx_data_size maximum received data length, in bytes.
|
||||
* @param[out] rx_bits pointer to a variable to contain received data length, in bits.
|
||||
* @returns FuriHalNfcErrorNone on success, any other error code on failure.
|
||||
*/
|
||||
typedef FuriHalNfcError (*FuriHalNfcRx)(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
uint8_t* rx_data,
|
||||
size_t rx_data_size,
|
||||
size_t* rx_bits);
|
||||
|
||||
/**
|
||||
* @brief Wait for an event using technology-specific method.
|
||||
*
|
||||
* @param[in] timeout_ms maximum time to wait, in milliseconds.
|
||||
* @return bitmask of occurred events.
|
||||
*/
|
||||
typedef FuriHalNfcEvent (*FuriHalNfcWaitEvent)(uint32_t timeout_ms);
|
||||
|
||||
/**
|
||||
* @brief Go to sleep in listener mode.
|
||||
*
|
||||
* Puts the passive target logic into Sleep (Halt) state.
|
||||
*
|
||||
* @param[in,out] handle pointer to the NFC chip SPI handle.
|
||||
* @returns FuriHalNfcErrorNone on success, any other error code on failure.
|
||||
*/
|
||||
typedef FuriHalNfcError (*FuriHalNfcSleep)(FuriHalSpiBusHandle* handle);
|
||||
|
||||
/**
|
||||
* @brief Go to idle in listener mode.
|
||||
*
|
||||
* Puts the passive target logic into Sense (Idle) state.
|
||||
*
|
||||
* @param[in,out] handle pointer to the NFC chip SPI handle.
|
||||
* @returns FuriHalNfcErrorNone on success, any other error code on failure.
|
||||
*/
|
||||
typedef FuriHalNfcError (*FuriHalNfcIdle)(FuriHalSpiBusHandle* handle);
|
||||
|
||||
/**
|
||||
* @brief Technology-specific compenstaion values for pollers.
|
||||
*
|
||||
* Timing compensations are needed due to execution delays not accounted for
|
||||
* in standards, they are usually found out experimentally.
|
||||
*
|
||||
* The compensation value will be subtracted from the respective timer running
|
||||
* time, so positive values shorten timeouts, and negative ones make them longer.
|
||||
*/
|
||||
typedef struct {
|
||||
int32_t fdt; /**< Frame delay time compensation, in carrier cycles. */
|
||||
int32_t fwt; /**< Frame wait time compensaton, in carrier cycles. */
|
||||
} FuriHalNfcPollerCompensation;
|
||||
|
||||
/**
|
||||
* @brief Abstract technology-specific poller structure.
|
||||
*/
|
||||
typedef struct {
|
||||
FuriHalNfcPollerCompensation compensation; /**< Compensation values in poller mode. */
|
||||
FuriHalNfcChipConfig init; /**< Pointer to the init() function. */
|
||||
FuriHalNfcChipConfig deinit; /**< Pointer to the deinit() function. */
|
||||
FuriHalNfcWaitEvent wait_event; /**< Pointer to the wait_event() function. */
|
||||
FuriHalNfcTx tx; /**< Pointer to the tx() function. */
|
||||
FuriHalNfcRx rx; /**< Pointer to the rx() function. */
|
||||
} FuriHalNfcTechPollerBase;
|
||||
|
||||
/**
|
||||
* @brief Technology-specific compenstaion values for listeners.
|
||||
*
|
||||
* Same considerations apply as with FuriHalNfcPollerCompensation.
|
||||
*/
|
||||
typedef struct {
|
||||
int32_t fdt; /**< Frame delay time compensation, in carrier cycles. */
|
||||
} FuriHalNfcListenerCompensation;
|
||||
|
||||
/**
|
||||
* @brief Abstract technology-specific listener structure.
|
||||
*
|
||||
* If the listener operating mode is not supported for a particular
|
||||
* technology, fill this structure with zeroes.
|
||||
*/
|
||||
typedef struct {
|
||||
FuriHalNfcListenerCompensation compensation; /**< Compensation values in listener mode. */
|
||||
FuriHalNfcChipConfig init; /**< Pointer to the init() function. */
|
||||
FuriHalNfcChipConfig deinit; /**< Pointer to the deinit() function. */
|
||||
FuriHalNfcWaitEvent wait_event; /**< Pointer to the wait_event() function. */
|
||||
FuriHalNfcTx tx; /**< Pointer to the tx() function. */
|
||||
FuriHalNfcRx rx; /**< Pointer to the rx() function. */
|
||||
FuriHalNfcSleep sleep; /**< Pointer to the sleep() function. */
|
||||
FuriHalNfcIdle idle; /**< Pointer to the idle() function. */
|
||||
} FuriHalNfcTechListenerBase;
|
||||
|
||||
/**
|
||||
* @brief Abstract NFC technology definition structure.
|
||||
*
|
||||
* Each concrete technology implementation must fill this structure
|
||||
* with its proper functions and constants.
|
||||
*/
|
||||
typedef struct {
|
||||
FuriHalNfcTechPollerBase poller; /**< Structure containing the poller definition. */
|
||||
FuriHalNfcTechListenerBase listener; /**< Structure containing the listener definition. */
|
||||
} FuriHalNfcTechBase;
|
||||
|
||||
/** @brief Technology declaration for ISO14443 (Type A). */
|
||||
extern const FuriHalNfcTechBase furi_hal_nfc_iso14443a;
|
||||
/** @brief Technology declaration for ISO14443 (Type B). */
|
||||
extern const FuriHalNfcTechBase furi_hal_nfc_iso14443b;
|
||||
/** @brief Technology declaration for ISO15693. */
|
||||
extern const FuriHalNfcTechBase furi_hal_nfc_iso15693;
|
||||
/** @brief Technology declaration for FeliCa. */
|
||||
extern const FuriHalNfcTechBase furi_hal_nfc_felica;
|
||||
/* Declare new tehcnologies here. */
|
||||
|
||||
/**
|
||||
* @brief Array of pointers to every supported technology.
|
||||
*
|
||||
* This variable is defined in furi_hal_nfc.c. It will need to be modified
|
||||
* in case when a new technology is to be added.
|
||||
*/
|
||||
extern const FuriHalNfcTechBase* furi_hal_nfc_tech[];
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,229 @@
|
||||
#include "furi_hal_nfc_i.h"
|
||||
#include "furi_hal_nfc_tech_i.h"
|
||||
|
||||
#include <stm32wbxx_ll_tim.h>
|
||||
|
||||
#include <furi_hal_interrupt.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_bus.h>
|
||||
|
||||
#define TAG "FuriHalNfcTimer"
|
||||
|
||||
#define FURI_HAL_NFC_TIMER_US_IN_S (1000000UL)
|
||||
|
||||
/**
|
||||
* To enable timer debug output on GPIO, define the FURI_HAL_NFC_TIMER_DEBUG macro
|
||||
* Example: ./fbt --extra-define=FURI_HAL_NFC_TIMER_DEBUG
|
||||
*/
|
||||
|
||||
typedef enum {
|
||||
FuriHalNfcTimerFwt,
|
||||
FuriHalNfcTimerBlockTx,
|
||||
FuriHalNfcTimerCount,
|
||||
} FuriHalNfcTimer;
|
||||
|
||||
typedef struct {
|
||||
TIM_TypeDef* timer;
|
||||
FuriHalBus bus;
|
||||
uint32_t prescaler;
|
||||
uint32_t freq_khz;
|
||||
FuriHalNfcEventInternalType event;
|
||||
FuriHalInterruptId irq_id;
|
||||
IRQn_Type irq_type;
|
||||
#ifdef FURI_HAL_NFC_TIMER_DEBUG
|
||||
const GpioPin* pin;
|
||||
#endif
|
||||
} FuriHalNfcTimerConfig;
|
||||
|
||||
static const FuriHalNfcTimerConfig furi_hal_nfc_timers[FuriHalNfcTimerCount] = {
|
||||
[FuriHalNfcTimerFwt] =
|
||||
{
|
||||
.timer = TIM1,
|
||||
.bus = FuriHalBusTIM1,
|
||||
.event = FuriHalNfcEventInternalTypeTimerFwtExpired,
|
||||
.irq_id = FuriHalInterruptIdTim1UpTim16,
|
||||
.irq_type = TIM1_UP_TIM16_IRQn,
|
||||
#ifdef FURI_HAL_NFC_TIMER_DEBUG
|
||||
.pin = &gpio_ext_pa7,
|
||||
#endif
|
||||
},
|
||||
[FuriHalNfcTimerBlockTx] =
|
||||
{
|
||||
.timer = TIM17,
|
||||
.bus = FuriHalBusTIM17,
|
||||
.event = FuriHalNfcEventInternalTypeTimerBlockTxExpired,
|
||||
.irq_id = FuriHalInterruptIdTim1TrgComTim17,
|
||||
.irq_type = TIM1_TRG_COM_TIM17_IRQn,
|
||||
#ifdef FURI_HAL_NFC_TIMER_DEBUG
|
||||
.pin = &gpio_ext_pa6,
|
||||
#endif
|
||||
},
|
||||
};
|
||||
|
||||
static void furi_hal_nfc_timer_irq_callback(void* context) {
|
||||
// Returning removed const-ness
|
||||
const FuriHalNfcTimerConfig* config = context;
|
||||
if(LL_TIM_IsActiveFlag_UPDATE(config->timer)) {
|
||||
LL_TIM_ClearFlag_UPDATE(config->timer);
|
||||
furi_hal_nfc_event_set(config->event);
|
||||
#ifdef FURI_HAL_NFC_TIMER_DEBUG
|
||||
furi_hal_gpio_write(timer_config->pin, false);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_timer_init(FuriHalNfcTimer timer) {
|
||||
const FuriHalNfcTimerConfig* config = &furi_hal_nfc_timers[timer];
|
||||
|
||||
furi_hal_bus_enable(config->bus);
|
||||
|
||||
LL_TIM_SetOnePulseMode(config->timer, LL_TIM_ONEPULSEMODE_SINGLE);
|
||||
LL_TIM_EnableUpdateEvent(config->timer);
|
||||
LL_TIM_SetCounterMode(config->timer, LL_TIM_COUNTERMODE_UP);
|
||||
LL_TIM_SetClockSource(config->timer, LL_TIM_CLOCKSOURCE_INTERNAL);
|
||||
|
||||
furi_hal_interrupt_set_isr(
|
||||
config->irq_id,
|
||||
furi_hal_nfc_timer_irq_callback,
|
||||
// Warning: casting const-ness away
|
||||
(FuriHalNfcTimerConfig*)config);
|
||||
NVIC_SetPriority(config->irq_type, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_EnableIRQ(config->irq_type);
|
||||
#ifdef FURI_HAL_NFC_TIMER_DEBUG
|
||||
furi_hal_gpio_init(config->pin, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
|
||||
furi_hal_gpio_write(config->pin, false);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_timer_deinit(FuriHalNfcTimer timer) {
|
||||
const FuriHalNfcTimerConfig* config = &furi_hal_nfc_timers[timer];
|
||||
|
||||
LL_TIM_ClearFlag_UPDATE(config->timer);
|
||||
furi_hal_interrupt_set_isr(config->irq_id, NULL, NULL);
|
||||
NVIC_DisableIRQ(config->irq_type);
|
||||
|
||||
if(furi_hal_bus_is_enabled(config->bus)) {
|
||||
furi_hal_bus_disable(config->bus);
|
||||
}
|
||||
#ifdef FURI_HAL_NFC_TIMER_DEBUG
|
||||
furi_hal_gpio_init_simple(config->pin, GpioModeAnalog);
|
||||
furi_hal_gpio_write(config->pin, false);
|
||||
#endif
|
||||
}
|
||||
|
||||
static int32_t furi_hal_nfc_timer_get_compensation(FuriHalNfcTimer timer) {
|
||||
const FuriHalNfcTechBase* current_tech = furi_hal_nfc_tech[furi_hal_nfc.tech];
|
||||
|
||||
if(furi_hal_nfc.mode == FuriHalNfcModePoller) {
|
||||
const FuriHalNfcPollerCompensation* comp = ¤t_tech->poller.compensation;
|
||||
if(timer == FuriHalNfcTimerFwt)
|
||||
return comp->fwt;
|
||||
else if(timer == FuriHalNfcTimerBlockTx)
|
||||
return comp->fdt;
|
||||
|
||||
} else if(furi_hal_nfc.mode == FuriHalNfcModeListener) {
|
||||
const FuriHalNfcListenerCompensation* comp = ¤t_tech->listener.compensation;
|
||||
if(timer == FuriHalNfcTimerBlockTx) return comp->fdt;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline bool furi_hal_nfc_timer_is_running(FuriHalNfcTimer timer) {
|
||||
return LL_TIM_IsEnabledCounter(furi_hal_nfc_timers[timer].timer) != 0;
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_timer_start_core_ticks(FuriHalNfcTimer timer, uint64_t core_ticks) {
|
||||
furi_check(!furi_hal_nfc_timer_is_running(timer));
|
||||
|
||||
const FuriHalNfcTimerConfig* config = &furi_hal_nfc_timers[timer];
|
||||
furi_check(furi_hal_bus_is_enabled(config->bus));
|
||||
|
||||
const uint32_t prescaler = (core_ticks - 1) / UINT16_MAX;
|
||||
furi_check(prescaler <= UINT16_MAX);
|
||||
|
||||
const uint32_t arr_reg = core_ticks / (prescaler + 1);
|
||||
furi_check(arr_reg <= UINT16_MAX);
|
||||
|
||||
LL_TIM_DisableIT_UPDATE(config->timer);
|
||||
|
||||
LL_TIM_SetPrescaler(config->timer, prescaler);
|
||||
LL_TIM_SetAutoReload(config->timer, arr_reg);
|
||||
|
||||
LL_TIM_GenerateEvent_UPDATE(config->timer);
|
||||
while(!LL_TIM_IsActiveFlag_UPDATE(config->timer))
|
||||
;
|
||||
LL_TIM_ClearFlag_UPDATE(config->timer);
|
||||
|
||||
LL_TIM_EnableIT_UPDATE(config->timer);
|
||||
LL_TIM_EnableCounter(config->timer);
|
||||
#ifdef FURI_HAL_NFC_TIMER_DEBUG
|
||||
furi_hal_gpio_write(config->pin, true);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_timer_start_us(FuriHalNfcTimer timer, uint32_t time_us) {
|
||||
furi_hal_nfc_timer_start_core_ticks(
|
||||
timer, SystemCoreClock / FURI_HAL_NFC_TIMER_US_IN_S * time_us);
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_timer_start_fc(FuriHalNfcTimer timer, uint32_t time_fc) {
|
||||
const int32_t comp_fc = furi_hal_nfc_timer_get_compensation(timer);
|
||||
// Not starting the timer if the compensation value is greater than the requested delay
|
||||
if(comp_fc >= (int32_t)time_fc) return;
|
||||
|
||||
furi_hal_nfc_timer_start_core_ticks(
|
||||
timer, ((uint64_t)SystemCoreClock * (time_fc - comp_fc)) / FURI_HAL_NFC_CARRIER_HZ);
|
||||
}
|
||||
|
||||
static void furi_hal_nfc_timer_stop(FuriHalNfcTimer timer) {
|
||||
const FuriHalNfcTimerConfig* config = &furi_hal_nfc_timers[timer];
|
||||
|
||||
LL_TIM_DisableIT_UPDATE(config->timer);
|
||||
LL_TIM_DisableCounter(config->timer);
|
||||
LL_TIM_SetCounter(config->timer, 0);
|
||||
LL_TIM_SetAutoReload(config->timer, 0);
|
||||
|
||||
if(LL_TIM_IsActiveFlag_UPDATE(config->timer)) {
|
||||
LL_TIM_ClearFlag_UPDATE(config->timer);
|
||||
}
|
||||
#ifdef FURI_HAL_NFC_TIMER_DEBUG
|
||||
furi_hal_gpio_write(config->pin, false);
|
||||
#endif
|
||||
}
|
||||
|
||||
void furi_hal_nfc_timers_init() {
|
||||
for(size_t i = 0; i < FuriHalNfcTimerCount; i++) {
|
||||
furi_hal_nfc_timer_init(i);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_nfc_timers_deinit() {
|
||||
for(size_t i = 0; i < FuriHalNfcTimerCount; i++) {
|
||||
furi_hal_nfc_timer_deinit(i);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_nfc_timer_fwt_start(uint32_t time_fc) {
|
||||
furi_hal_nfc_timer_start_fc(FuriHalNfcTimerFwt, time_fc);
|
||||
}
|
||||
|
||||
void furi_hal_nfc_timer_fwt_stop() {
|
||||
furi_hal_nfc_timer_stop(FuriHalNfcTimerFwt);
|
||||
}
|
||||
|
||||
void furi_hal_nfc_timer_block_tx_start(uint32_t time_fc) {
|
||||
furi_hal_nfc_timer_start_fc(FuriHalNfcTimerBlockTx, time_fc);
|
||||
}
|
||||
|
||||
void furi_hal_nfc_timer_block_tx_start_us(uint32_t time_us) {
|
||||
furi_hal_nfc_timer_start_us(FuriHalNfcTimerBlockTx, time_us);
|
||||
}
|
||||
|
||||
void furi_hal_nfc_timer_block_tx_stop() {
|
||||
furi_hal_nfc_timer_stop(FuriHalNfcTimerBlockTx);
|
||||
}
|
||||
|
||||
bool furi_hal_nfc_timer_block_tx_is_running() {
|
||||
return furi_hal_nfc_timer_is_running(FuriHalNfcTimerBlockTx);
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
#include <furi_hal_os.h>
|
||||
#include <furi_hal_clock.h>
|
||||
#include <furi_hal_console.h>
|
||||
#include <furi_hal_power.h>
|
||||
#include <furi_hal_gpio.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_idle_timer.h>
|
||||
|
||||
#include <stm32wbxx_ll_cortex.h>
|
||||
|
||||
#include <furi.h>
|
||||
|
||||
#define TAG "FuriHalOs"
|
||||
|
||||
#define FURI_HAL_IDLE_TIMER_CLK_HZ 32768
|
||||
#define FURI_HAL_OS_TICK_HZ configTICK_RATE_HZ
|
||||
|
||||
#define FURI_HAL_OS_IDLE_CNT_TO_TICKS(x) (((x)*FURI_HAL_OS_TICK_HZ) / FURI_HAL_IDLE_TIMER_CLK_HZ)
|
||||
#define FURI_HAL_OS_TICKS_TO_IDLE_CNT(x) (((x)*FURI_HAL_IDLE_TIMER_CLK_HZ) / FURI_HAL_OS_TICK_HZ)
|
||||
|
||||
#define FURI_HAL_IDLE_TIMER_TICK_PER_EPOCH (FURI_HAL_OS_IDLE_CNT_TO_TICKS(FURI_HAL_IDLE_TIMER_MAX))
|
||||
#define FURI_HAL_OS_MAX_SLEEP (FURI_HAL_IDLE_TIMER_TICK_PER_EPOCH - 1)
|
||||
|
||||
#define FURI_HAL_OS_NVIC_IS_PENDING() (NVIC->ISPR[0] || NVIC->ISPR[1])
|
||||
#define FURI_HAL_OS_EXTI_LINE_0_31 0
|
||||
#define FURI_HAL_OS_EXTI_LINE_32_63 1
|
||||
|
||||
// Arbitrary (but small) number for better tick consistency
|
||||
#define FURI_HAL_OS_EXTRA_CNT 3
|
||||
|
||||
#ifndef FURI_HAL_OS_DEBUG_AWAKE_GPIO
|
||||
#define FURI_HAL_OS_DEBUG_AWAKE_GPIO (&gpio_ext_pa7)
|
||||
#endif
|
||||
|
||||
#ifndef FURI_HAL_OS_DEBUG_TICK_GPIO
|
||||
#define FURI_HAL_OS_DEBUG_TICK_GPIO (&gpio_ext_pa6)
|
||||
#endif
|
||||
|
||||
#ifndef FURI_HAL_OS_DEBUG_SECOND_GPIO
|
||||
#define FURI_HAL_OS_DEBUG_SECOND_GPIO (&gpio_ext_pa4)
|
||||
#endif
|
||||
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
#include <stm32wbxx_ll_gpio.h>
|
||||
|
||||
void furi_hal_os_timer_callback() {
|
||||
furi_hal_gpio_write(
|
||||
FURI_HAL_OS_DEBUG_SECOND_GPIO, !furi_hal_gpio_read(FURI_HAL_OS_DEBUG_SECOND_GPIO));
|
||||
}
|
||||
#endif
|
||||
|
||||
extern void xPortSysTickHandler();
|
||||
|
||||
static volatile uint32_t furi_hal_os_skew;
|
||||
|
||||
void furi_hal_os_init() {
|
||||
furi_hal_idle_timer_init();
|
||||
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
furi_hal_gpio_init_simple(FURI_HAL_OS_DEBUG_AWAKE_GPIO, GpioModeOutputPushPull);
|
||||
furi_hal_gpio_init_simple(FURI_HAL_OS_DEBUG_TICK_GPIO, GpioModeOutputPushPull);
|
||||
furi_hal_gpio_init_simple(FURI_HAL_OS_DEBUG_SECOND_GPIO, GpioModeOutputPushPull);
|
||||
furi_hal_gpio_write(FURI_HAL_OS_DEBUG_AWAKE_GPIO, 1);
|
||||
|
||||
FuriTimer* second_timer =
|
||||
furi_timer_alloc(furi_hal_os_timer_callback, FuriTimerTypePeriodic, NULL);
|
||||
furi_timer_start(second_timer, FURI_HAL_OS_TICK_HZ);
|
||||
#endif
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
void furi_hal_os_tick() {
|
||||
if(xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) {
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
furi_hal_gpio_write(
|
||||
FURI_HAL_OS_DEBUG_TICK_GPIO, !furi_hal_gpio_read(FURI_HAL_OS_DEBUG_TICK_GPIO));
|
||||
#endif
|
||||
xPortSysTickHandler();
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
// Find out the IRQ number while debugging
|
||||
static void furi_hal_os_nvic_dbg_trap() {
|
||||
for(int32_t i = WWDG_IRQn; i <= DMAMUX1_OVR_IRQn; i++) {
|
||||
if(NVIC_GetPendingIRQ(i)) {
|
||||
(void)i;
|
||||
// Break here
|
||||
__NOP();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Find out the EXTI line number while debugging
|
||||
static void furi_hal_os_exti_dbg_trap(uint32_t exti, uint32_t val) {
|
||||
for(uint32_t i = 0; val; val >>= 1U, ++i) {
|
||||
if(val & 1U) {
|
||||
(void)exti;
|
||||
(void)i;
|
||||
// Break here
|
||||
__NOP();
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline bool furi_hal_os_is_pending_irq() {
|
||||
if(FURI_HAL_OS_NVIC_IS_PENDING()) {
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
furi_hal_os_nvic_dbg_trap();
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
uint32_t exti_lines_active;
|
||||
if((exti_lines_active = LL_EXTI_ReadFlag_0_31(LL_EXTI_LINE_ALL_0_31))) {
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
furi_hal_os_exti_dbg_trap(FURI_HAL_OS_EXTI_LINE_0_31, exti_lines_active);
|
||||
#endif
|
||||
return true;
|
||||
} else if((exti_lines_active = LL_EXTI_ReadFlag_32_63(LL_EXTI_LINE_ALL_32_63))) {
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
furi_hal_os_exti_dbg_trap(FURI_HAL_OS_EXTI_LINE_32_63, exti_lines_active);
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline uint32_t furi_hal_os_sleep(TickType_t expected_idle_ticks) {
|
||||
// Stop ticks
|
||||
furi_hal_clock_suspend_tick();
|
||||
|
||||
// Start wakeup timer
|
||||
furi_hal_idle_timer_start(FURI_HAL_OS_TICKS_TO_IDLE_CNT(expected_idle_ticks));
|
||||
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
furi_hal_gpio_write(FURI_HAL_OS_DEBUG_AWAKE_GPIO, 0);
|
||||
#endif
|
||||
|
||||
// Go to sleep mode
|
||||
furi_hal_power_sleep();
|
||||
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
furi_hal_gpio_write(FURI_HAL_OS_DEBUG_AWAKE_GPIO, 1);
|
||||
#endif
|
||||
|
||||
// Calculate how much time we spent in the sleep
|
||||
uint32_t after_cnt = furi_hal_idle_timer_get_cnt() + furi_hal_os_skew + FURI_HAL_OS_EXTRA_CNT;
|
||||
uint32_t after_tick = FURI_HAL_OS_IDLE_CNT_TO_TICKS(after_cnt);
|
||||
furi_hal_os_skew = after_cnt - FURI_HAL_OS_TICKS_TO_IDLE_CNT(after_tick);
|
||||
|
||||
bool cmpm = LL_LPTIM_IsActiveFlag_CMPM(FURI_HAL_IDLE_TIMER);
|
||||
bool arrm = LL_LPTIM_IsActiveFlag_ARRM(FURI_HAL_IDLE_TIMER);
|
||||
if(cmpm && arrm) after_tick += expected_idle_ticks;
|
||||
|
||||
// Prepare tick timer for new round
|
||||
furi_hal_idle_timer_reset();
|
||||
|
||||
// Resume ticks
|
||||
furi_hal_clock_resume_tick();
|
||||
return after_tick;
|
||||
}
|
||||
|
||||
void vPortSuppressTicksAndSleep(TickType_t expected_idle_ticks) {
|
||||
if(!furi_hal_power_sleep_available()) {
|
||||
__WFI();
|
||||
return;
|
||||
}
|
||||
|
||||
// Core2 shenanigans takes extra time, so we want to compensate tick skew by reducing sleep duration by 1 tick
|
||||
TickType_t unexpected_idle_ticks = expected_idle_ticks - 1;
|
||||
|
||||
// Limit amount of ticks to maximum that timer can count
|
||||
if(unexpected_idle_ticks > FURI_HAL_OS_MAX_SLEEP) {
|
||||
unexpected_idle_ticks = FURI_HAL_OS_MAX_SLEEP;
|
||||
}
|
||||
|
||||
// Stop IRQ handling, no one should disturb us till we finish
|
||||
__disable_irq();
|
||||
do {
|
||||
// Confirm OS that sleep is still possible
|
||||
if(eTaskConfirmSleepModeStatus() == eAbortSleep || furi_hal_os_is_pending_irq()) {
|
||||
break;
|
||||
}
|
||||
|
||||
// Sleep and track how much ticks we spent sleeping
|
||||
uint32_t completed_ticks = furi_hal_os_sleep(unexpected_idle_ticks);
|
||||
// Notify system about time spent in sleep
|
||||
if(completed_ticks > 0) {
|
||||
if(completed_ticks > expected_idle_ticks) {
|
||||
#ifdef FURI_HAL_OS_DEBUG
|
||||
furi_hal_console_printf(">%lu\r\n", completed_ticks - expected_idle_ticks);
|
||||
#endif
|
||||
completed_ticks = expected_idle_ticks;
|
||||
}
|
||||
vTaskStepTick(completed_ticks);
|
||||
}
|
||||
} while(0);
|
||||
// Reenable IRQ
|
||||
__enable_irq();
|
||||
}
|
||||
|
||||
void vApplicationStackOverflowHook(TaskHandle_t xTask, char* pcTaskName) {
|
||||
UNUSED(xTask);
|
||||
furi_hal_console_puts("\r\n\r\n stack overflow in ");
|
||||
furi_hal_console_puts(pcTaskName);
|
||||
furi_hal_console_puts("\r\n\r\n");
|
||||
furi_crash("StackOverflow");
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Initialize OS helpers
|
||||
* Configure and start tick timer
|
||||
*/
|
||||
void furi_hal_os_init();
|
||||
|
||||
/* Advance OS tick counter
|
||||
*/
|
||||
void furi_hal_os_tick();
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,720 @@
|
||||
#include <furi_hal_power.h>
|
||||
#include <furi_hal_clock.h>
|
||||
#include <furi_hal_bt.h>
|
||||
#include <furi_hal_vibro.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_uart.h>
|
||||
#include <furi_hal_rtc.h>
|
||||
#include <furi_hal_debug.h>
|
||||
|
||||
#include <stm32wbxx_ll_rcc.h>
|
||||
#include <stm32wbxx_ll_pwr.h>
|
||||
#include <stm32wbxx_ll_hsem.h>
|
||||
#include <stm32wbxx_ll_cortex.h>
|
||||
#include <stm32wbxx_ll_gpio.h>
|
||||
|
||||
#include <hsem_map.h>
|
||||
#include <bq27220.h>
|
||||
#include <bq27220_data_memory.h>
|
||||
#include <bq25896.h>
|
||||
|
||||
#include <furi.h>
|
||||
|
||||
#define TAG "FuriHalPower"
|
||||
|
||||
#ifndef FURI_HAL_POWER_DEBUG_WFI_GPIO
|
||||
#define FURI_HAL_POWER_DEBUG_WFI_GPIO (&gpio_ext_pb2)
|
||||
#endif
|
||||
|
||||
#ifndef FURI_HAL_POWER_DEBUG_STOP_GPIO
|
||||
#define FURI_HAL_POWER_DEBUG_STOP_GPIO (&gpio_ext_pc3)
|
||||
#endif
|
||||
|
||||
#ifndef FURI_HAL_POWER_STOP_MODE
|
||||
#define FURI_HAL_POWER_STOP_MODE (LL_PWR_MODE_STOP2)
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
volatile uint8_t insomnia;
|
||||
volatile uint8_t suppress_charge;
|
||||
|
||||
bool gauge_ok;
|
||||
bool charger_ok;
|
||||
} FuriHalPower;
|
||||
|
||||
static volatile FuriHalPower furi_hal_power = {
|
||||
.insomnia = 0,
|
||||
.suppress_charge = 0,
|
||||
.gauge_ok = false,
|
||||
.charger_ok = false,
|
||||
};
|
||||
|
||||
extern const BQ27220DMData furi_hal_power_gauge_data_memory[];
|
||||
|
||||
void furi_hal_power_init() {
|
||||
#ifdef FURI_HAL_POWER_DEBUG
|
||||
furi_hal_gpio_init_simple(FURI_HAL_POWER_DEBUG_WFI_GPIO, GpioModeOutputPushPull);
|
||||
furi_hal_gpio_init_simple(FURI_HAL_POWER_DEBUG_STOP_GPIO, GpioModeOutputPushPull);
|
||||
furi_hal_gpio_write(FURI_HAL_POWER_DEBUG_WFI_GPIO, 0);
|
||||
furi_hal_gpio_write(FURI_HAL_POWER_DEBUG_STOP_GPIO, 0);
|
||||
#endif
|
||||
|
||||
LL_PWR_SetRegulVoltageScaling(LL_PWR_REGU_VOLTAGE_SCALE1);
|
||||
LL_PWR_SMPS_SetMode(LL_PWR_SMPS_STEP_DOWN);
|
||||
|
||||
LL_PWR_SetPowerMode(FURI_HAL_POWER_STOP_MODE);
|
||||
LL_C2_PWR_SetPowerMode(FURI_HAL_POWER_STOP_MODE);
|
||||
|
||||
#if FURI_HAL_POWER_STOP_MODE == LL_PWR_MODE_STOP0
|
||||
LL_RCC_HSI_EnableInStopMode(); // Ensure that MR is capable of work in STOP0
|
||||
#endif
|
||||
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
// Find and init gauge
|
||||
if(bq27220_init(&furi_hal_i2c_handle_power)) {
|
||||
furi_hal_power.gauge_ok = bq27220_apply_data_memory(
|
||||
&furi_hal_i2c_handle_power, furi_hal_power_gauge_data_memory);
|
||||
}
|
||||
// Find and init charger
|
||||
furi_hal_power.charger_ok = bq25896_init(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
bool furi_hal_power_gauge_is_ok() {
|
||||
bool ret = true;
|
||||
|
||||
BatteryStatus battery_status;
|
||||
OperationStatus operation_status;
|
||||
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
|
||||
if(!bq27220_get_battery_status(&furi_hal_i2c_handle_power, &battery_status) ||
|
||||
!bq27220_get_operation_status(&furi_hal_i2c_handle_power, &operation_status)) {
|
||||
ret = false;
|
||||
} else {
|
||||
ret &= battery_status.BATTPRES;
|
||||
ret &= operation_status.INITCOMP;
|
||||
ret &= furi_hal_power.gauge_ok;
|
||||
}
|
||||
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool furi_hal_power_is_shutdown_requested() {
|
||||
bool ret = false;
|
||||
|
||||
BatteryStatus battery_status;
|
||||
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
|
||||
if(bq27220_get_battery_status(&furi_hal_i2c_handle_power, &battery_status) != BQ27220_ERROR) {
|
||||
ret = battery_status.SYSDWN;
|
||||
}
|
||||
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint16_t furi_hal_power_insomnia_level() {
|
||||
return furi_hal_power.insomnia;
|
||||
}
|
||||
|
||||
void furi_hal_power_insomnia_enter() {
|
||||
FURI_CRITICAL_ENTER();
|
||||
furi_assert(furi_hal_power.insomnia < UINT8_MAX);
|
||||
furi_hal_power.insomnia++;
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_power_insomnia_exit() {
|
||||
FURI_CRITICAL_ENTER();
|
||||
furi_assert(furi_hal_power.insomnia > 0);
|
||||
furi_hal_power.insomnia--;
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
bool furi_hal_power_sleep_available() {
|
||||
return furi_hal_power.insomnia == 0;
|
||||
}
|
||||
|
||||
static inline bool furi_hal_power_deep_sleep_available() {
|
||||
return furi_hal_bt_is_alive() && !furi_hal_rtc_is_flag_set(FuriHalRtcFlagLegacySleep) &&
|
||||
!furi_hal_debug_is_gdb_session_active();
|
||||
}
|
||||
|
||||
static inline void furi_hal_power_light_sleep() {
|
||||
__WFI();
|
||||
}
|
||||
|
||||
static inline void furi_hal_power_suspend_aux_periphs() {
|
||||
// Disable USART
|
||||
furi_hal_uart_suspend(FuriHalUartIdUSART1);
|
||||
furi_hal_uart_suspend(FuriHalUartIdLPUART1);
|
||||
}
|
||||
|
||||
static inline void furi_hal_power_resume_aux_periphs() {
|
||||
// Re-enable USART
|
||||
furi_hal_uart_resume(FuriHalUartIdUSART1);
|
||||
furi_hal_uart_resume(FuriHalUartIdLPUART1);
|
||||
}
|
||||
|
||||
static inline void furi_hal_power_deep_sleep() {
|
||||
furi_hal_power_suspend_aux_periphs();
|
||||
|
||||
if(!furi_hal_clock_switch_pll2hse()) {
|
||||
// Hello core2 my old friend
|
||||
return;
|
||||
}
|
||||
|
||||
while(LL_HSEM_1StepLock(HSEM, CFG_HW_RCC_SEMID))
|
||||
;
|
||||
|
||||
if(!LL_HSEM_1StepLock(HSEM, CFG_HW_ENTRY_STOP_MODE_SEMID)) {
|
||||
if(LL_PWR_IsActiveFlag_C2DS() || LL_PWR_IsActiveFlag_C2SB()) {
|
||||
// Release ENTRY_STOP_MODE semaphore
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_ENTRY_STOP_MODE_SEMID, 0);
|
||||
|
||||
// The switch on HSI before entering Stop Mode is required
|
||||
furi_hal_clock_switch_hse2hsi();
|
||||
}
|
||||
} else {
|
||||
/**
|
||||
* The switch on HSI before entering Stop Mode is required
|
||||
*/
|
||||
furi_hal_clock_switch_hse2hsi();
|
||||
}
|
||||
|
||||
/* Release RCC semaphore */
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_RCC_SEMID, 0);
|
||||
|
||||
// Prepare deep sleep
|
||||
LL_LPM_EnableDeepSleep();
|
||||
|
||||
#if defined(__CC_ARM)
|
||||
// Force store operations
|
||||
__force_stores();
|
||||
#endif
|
||||
|
||||
__WFI();
|
||||
|
||||
LL_LPM_EnableSleep();
|
||||
|
||||
/* Release ENTRY_STOP_MODE semaphore */
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_ENTRY_STOP_MODE_SEMID, 0);
|
||||
|
||||
while(LL_HSEM_1StepLock(HSEM, CFG_HW_RCC_SEMID))
|
||||
;
|
||||
|
||||
if(LL_RCC_GetSysClkSource() == LL_RCC_SYS_CLKSOURCE_STATUS_HSI) {
|
||||
furi_hal_clock_switch_hsi2hse();
|
||||
} else {
|
||||
// Ensure that we are already on HSE
|
||||
furi_check(LL_RCC_GetSysClkSource() == LL_RCC_SYS_CLKSOURCE_STATUS_HSE);
|
||||
}
|
||||
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_RCC_SEMID, 0);
|
||||
|
||||
furi_check(furi_hal_clock_switch_hse2pll());
|
||||
|
||||
furi_hal_power_resume_aux_periphs();
|
||||
furi_hal_rtc_sync_shadow();
|
||||
}
|
||||
|
||||
void furi_hal_power_sleep() {
|
||||
if(furi_hal_power_deep_sleep_available()) {
|
||||
#ifdef FURI_HAL_POWER_DEBUG
|
||||
furi_hal_gpio_write(FURI_HAL_POWER_DEBUG_STOP_GPIO, 1);
|
||||
#endif
|
||||
furi_hal_power_deep_sleep();
|
||||
#ifdef FURI_HAL_POWER_DEBUG
|
||||
furi_hal_gpio_write(FURI_HAL_POWER_DEBUG_STOP_GPIO, 0);
|
||||
#endif
|
||||
} else {
|
||||
#ifdef FURI_HAL_POWER_DEBUG
|
||||
furi_hal_gpio_write(FURI_HAL_POWER_DEBUG_WFI_GPIO, 1);
|
||||
#endif
|
||||
furi_hal_power_light_sleep();
|
||||
#ifdef FURI_HAL_POWER_DEBUG
|
||||
furi_hal_gpio_write(FURI_HAL_POWER_DEBUG_WFI_GPIO, 0);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t furi_hal_power_get_pct() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
uint8_t ret = bq27220_get_state_of_charge(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint8_t furi_hal_power_get_bat_health_pct() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
uint8_t ret = bq27220_get_state_of_health(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool furi_hal_power_is_charging() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
bool ret = bq25896_is_charging(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool furi_hal_power_is_charging_done() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
bool ret = bq25896_is_charging_done(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void furi_hal_power_shutdown() {
|
||||
furi_hal_power_insomnia_enter();
|
||||
|
||||
furi_hal_bt_reinit();
|
||||
|
||||
while(LL_HSEM_1StepLock(HSEM, CFG_HW_RCC_SEMID))
|
||||
;
|
||||
|
||||
if(!LL_HSEM_1StepLock(HSEM, CFG_HW_ENTRY_STOP_MODE_SEMID)) {
|
||||
if(LL_PWR_IsActiveFlag_C2DS() || LL_PWR_IsActiveFlag_C2SB()) {
|
||||
// Release ENTRY_STOP_MODE semaphore
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_ENTRY_STOP_MODE_SEMID, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// Prepare Wakeup pin
|
||||
LL_PWR_SetWakeUpPinPolarityLow(LL_PWR_WAKEUP_PIN2);
|
||||
LL_PWR_EnableWakeUpPin(LL_PWR_WAKEUP_PIN2);
|
||||
LL_C2_PWR_EnableWakeUpPin(LL_PWR_WAKEUP_PIN2);
|
||||
|
||||
/* Release RCC semaphore */
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_RCC_SEMID, 0);
|
||||
|
||||
LL_PWR_DisableBootC2();
|
||||
LL_PWR_SetPowerMode(LL_PWR_MODE_SHUTDOWN);
|
||||
LL_C2_PWR_SetPowerMode(LL_PWR_MODE_SHUTDOWN);
|
||||
LL_LPM_EnableDeepSleep();
|
||||
|
||||
__WFI();
|
||||
furi_crash("Insomniac core2");
|
||||
}
|
||||
|
||||
void furi_hal_power_off() {
|
||||
// Crutch: shutting down with ext 3V3 off is causing LSE to stop
|
||||
furi_hal_power_enable_external_3_3v();
|
||||
furi_hal_vibro_on(true);
|
||||
furi_delay_us(50000);
|
||||
// Send poweroff to charger
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
bq25896_poweroff(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
furi_hal_vibro_on(false);
|
||||
}
|
||||
|
||||
void furi_hal_power_reset() {
|
||||
NVIC_SystemReset();
|
||||
}
|
||||
|
||||
bool furi_hal_power_enable_otg() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
bq25896_set_boost_lim(&furi_hal_i2c_handle_power, BoostLim_2150);
|
||||
bq25896_enable_otg(&furi_hal_i2c_handle_power);
|
||||
furi_delay_ms(30);
|
||||
bool ret = bq25896_is_otg_enabled(&furi_hal_i2c_handle_power);
|
||||
bq25896_set_boost_lim(&furi_hal_i2c_handle_power, BoostLim_1400);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void furi_hal_power_disable_otg() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
bq25896_disable_otg(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
|
||||
bool furi_hal_power_is_otg_enabled() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
bool ret = bq25896_is_otg_enabled(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
float furi_hal_power_get_battery_charge_voltage_limit() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
float ret = (float)bq25896_get_vreg_voltage(&furi_hal_i2c_handle_power) / 1000.0f;
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void furi_hal_power_set_battery_charge_voltage_limit(float voltage) {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
// Adding 0.0005 is necessary because 4.016f is 4.015999794000, which gets truncated
|
||||
bq25896_set_vreg_voltage(&furi_hal_i2c_handle_power, (uint16_t)(voltage * 1000.0f + 0.0005f));
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
|
||||
bool furi_hal_power_check_otg_fault() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
bool ret = bq25896_check_otg_fault(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void furi_hal_power_check_otg_status() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
if(bq25896_check_otg_fault(&furi_hal_i2c_handle_power))
|
||||
bq25896_disable_otg(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
|
||||
uint32_t furi_hal_power_get_battery_remaining_capacity() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
uint32_t ret = bq27220_get_remaining_capacity(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint32_t furi_hal_power_get_battery_full_capacity() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
uint32_t ret = bq27220_get_full_charge_capacity(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint32_t furi_hal_power_get_battery_design_capacity() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
uint32_t ret = bq27220_get_design_capacity(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
float furi_hal_power_get_battery_voltage(FuriHalPowerIC ic) {
|
||||
float ret = 0.0f;
|
||||
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
if(ic == FuriHalPowerICCharger) {
|
||||
ret = (float)bq25896_get_vbat_voltage(&furi_hal_i2c_handle_power) / 1000.0f;
|
||||
} else if(ic == FuriHalPowerICFuelGauge) {
|
||||
ret = (float)bq27220_get_voltage(&furi_hal_i2c_handle_power) / 1000.0f;
|
||||
}
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
float furi_hal_power_get_battery_current(FuriHalPowerIC ic) {
|
||||
float ret = 0.0f;
|
||||
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
if(ic == FuriHalPowerICCharger) {
|
||||
ret = (float)bq25896_get_vbat_current(&furi_hal_i2c_handle_power) / 1000.0f;
|
||||
} else if(ic == FuriHalPowerICFuelGauge) {
|
||||
ret = (float)bq27220_get_current(&furi_hal_i2c_handle_power) / 1000.0f;
|
||||
}
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static float furi_hal_power_get_battery_temperature_internal(FuriHalPowerIC ic) {
|
||||
float ret = 0.0f;
|
||||
|
||||
if(ic == FuriHalPowerICCharger) {
|
||||
// Linear approximation, +/- 5 C
|
||||
ret = (71.0f - (float)bq25896_get_ntc_mpct(&furi_hal_i2c_handle_power) / 1000) / 0.6f;
|
||||
} else if(ic == FuriHalPowerICFuelGauge) {
|
||||
ret = ((float)bq27220_get_temperature(&furi_hal_i2c_handle_power) - 2731.0f) / 10.0f;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
float furi_hal_power_get_battery_temperature(FuriHalPowerIC ic) {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
float ret = furi_hal_power_get_battery_temperature_internal(ic);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
float furi_hal_power_get_usb_voltage() {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
float ret = (float)bq25896_get_vbus_voltage(&furi_hal_i2c_handle_power) / 1000.0f;
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void furi_hal_power_enable_external_3_3v() {
|
||||
furi_hal_gpio_write(&gpio_periph_power, 1);
|
||||
}
|
||||
|
||||
void furi_hal_power_disable_external_3_3v() {
|
||||
furi_hal_gpio_write(&gpio_periph_power, 0);
|
||||
}
|
||||
|
||||
void furi_hal_power_suppress_charge_enter() {
|
||||
vTaskSuspendAll();
|
||||
bool disable_charging = furi_hal_power.suppress_charge == 0;
|
||||
furi_hal_power.suppress_charge++;
|
||||
xTaskResumeAll();
|
||||
|
||||
if(disable_charging) {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
bq25896_disable_charging(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_power_suppress_charge_exit() {
|
||||
vTaskSuspendAll();
|
||||
furi_hal_power.suppress_charge--;
|
||||
bool enable_charging = furi_hal_power.suppress_charge == 0;
|
||||
xTaskResumeAll();
|
||||
|
||||
if(enable_charging) {
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
bq25896_enable_charging(&furi_hal_i2c_handle_power);
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_power_info_get(PropertyValueCallback out, char sep, void* context) {
|
||||
furi_assert(out);
|
||||
|
||||
FuriString* value = furi_string_alloc();
|
||||
FuriString* key = furi_string_alloc();
|
||||
|
||||
PropertyValueContext property_context = {
|
||||
.key = key, .value = value, .out = out, .sep = sep, .last = false, .context = context};
|
||||
|
||||
if(sep == '.') {
|
||||
property_value_out(&property_context, NULL, 2, "format", "major", "2");
|
||||
property_value_out(&property_context, NULL, 2, "format", "minor", "1");
|
||||
} else {
|
||||
property_value_out(&property_context, NULL, 3, "power", "info", "major", "2");
|
||||
property_value_out(&property_context, NULL, 3, "power", "info", "minor", "1");
|
||||
}
|
||||
|
||||
uint8_t charge = furi_hal_power_get_pct();
|
||||
property_value_out(&property_context, "%u", 2, "charge", "level", charge);
|
||||
|
||||
const char* charge_state;
|
||||
if(furi_hal_power_is_charging()) {
|
||||
if((charge < 100) && (!furi_hal_power_is_charging_done())) {
|
||||
charge_state = "charging";
|
||||
} else {
|
||||
charge_state = "charged";
|
||||
}
|
||||
} else {
|
||||
charge_state = "discharging";
|
||||
}
|
||||
|
||||
property_value_out(&property_context, NULL, 2, "charge", "state", charge_state);
|
||||
uint16_t charge_voltage_limit =
|
||||
(uint16_t)(furi_hal_power_get_battery_charge_voltage_limit() * 1000.f);
|
||||
property_value_out(
|
||||
&property_context, "%u", 3, "charge", "voltage", "limit", charge_voltage_limit);
|
||||
uint16_t voltage =
|
||||
(uint16_t)(furi_hal_power_get_battery_voltage(FuriHalPowerICFuelGauge) * 1000.f);
|
||||
property_value_out(&property_context, "%u", 2, "battery", "voltage", voltage);
|
||||
int16_t current =
|
||||
(int16_t)(furi_hal_power_get_battery_current(FuriHalPowerICFuelGauge) * 1000.f);
|
||||
property_value_out(&property_context, "%d", 2, "battery", "current", current);
|
||||
int16_t temperature = (int16_t)furi_hal_power_get_battery_temperature(FuriHalPowerICFuelGauge);
|
||||
property_value_out(&property_context, "%d", 2, "battery", "temp", temperature);
|
||||
property_value_out(
|
||||
&property_context, "%u", 2, "battery", "health", furi_hal_power_get_bat_health_pct());
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%lu",
|
||||
2,
|
||||
"capacity",
|
||||
"remain",
|
||||
furi_hal_power_get_battery_remaining_capacity());
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%lu",
|
||||
2,
|
||||
"capacity",
|
||||
"full",
|
||||
furi_hal_power_get_battery_full_capacity());
|
||||
property_context.last = true;
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%lu",
|
||||
2,
|
||||
"capacity",
|
||||
"design",
|
||||
furi_hal_power_get_battery_design_capacity());
|
||||
|
||||
furi_string_free(key);
|
||||
furi_string_free(value);
|
||||
}
|
||||
|
||||
void furi_hal_power_debug_get(PropertyValueCallback out, void* context) {
|
||||
furi_assert(out);
|
||||
|
||||
FuriString* value = furi_string_alloc();
|
||||
FuriString* key = furi_string_alloc();
|
||||
|
||||
PropertyValueContext property_context = {
|
||||
.key = key, .value = value, .out = out, .sep = '.', .last = false, .context = context};
|
||||
|
||||
BatteryStatus battery_status;
|
||||
OperationStatus operation_status;
|
||||
|
||||
furi_hal_i2c_acquire(&furi_hal_i2c_handle_power);
|
||||
|
||||
// Power Debug version
|
||||
property_value_out(&property_context, NULL, 2, "format", "major", "1");
|
||||
property_value_out(&property_context, NULL, 2, "format", "minor", "0");
|
||||
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
2,
|
||||
"charger",
|
||||
"vbus",
|
||||
bq25896_get_vbus_voltage(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
2,
|
||||
"charger",
|
||||
"vsys",
|
||||
bq25896_get_vsys_voltage(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
2,
|
||||
"charger",
|
||||
"vbat",
|
||||
bq25896_get_vbat_voltage(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
2,
|
||||
"charger",
|
||||
"vreg",
|
||||
bq25896_get_vreg_voltage(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
2,
|
||||
"charger",
|
||||
"current",
|
||||
bq25896_get_vbat_current(&furi_hal_i2c_handle_power));
|
||||
|
||||
const uint32_t ntc_mpct = bq25896_get_ntc_mpct(&furi_hal_i2c_handle_power);
|
||||
|
||||
if(bq27220_get_battery_status(&furi_hal_i2c_handle_power, &battery_status) &&
|
||||
bq27220_get_operation_status(&furi_hal_i2c_handle_power, &operation_status)) {
|
||||
property_value_out(&property_context, "%lu", 2, "charger", "ntc", ntc_mpct);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "calmd", operation_status.CALMD);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "sec", operation_status.SEC);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "edv2", operation_status.EDV2);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "vdq", operation_status.VDQ);
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "gauge", "initcomp", operation_status.INITCOMP);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "smth", operation_status.SMTH);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "btpint", operation_status.BTPINT);
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "gauge", "cfgupdate", operation_status.CFGUPDATE);
|
||||
|
||||
// Battery status register, part 1
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "chginh", battery_status.CHGINH);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "fc", battery_status.FC);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "otd", battery_status.OTD);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "otc", battery_status.OTC);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "sleep", battery_status.SLEEP);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "ocvfail", battery_status.OCVFAIL);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "ocvcomp", battery_status.OCVCOMP);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "fd", battery_status.FD);
|
||||
|
||||
// Battery status register, part 2
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "dsg", battery_status.DSG);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "sysdwn", battery_status.SYSDWN);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "tda", battery_status.TDA);
|
||||
property_value_out(
|
||||
&property_context, "%d", 2, "gauge", "battpres", battery_status.BATTPRES);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "authgd", battery_status.AUTH_GD);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "ocvgd", battery_status.OCVGD);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "tca", battery_status.TCA);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "rsvd", battery_status.RSVD);
|
||||
|
||||
// Voltage and current info
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
3,
|
||||
"gauge",
|
||||
"capacity",
|
||||
"full",
|
||||
bq27220_get_full_charge_capacity(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
3,
|
||||
"gauge",
|
||||
"capacity",
|
||||
"design",
|
||||
bq27220_get_design_capacity(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
3,
|
||||
"gauge",
|
||||
"capacity",
|
||||
"remain",
|
||||
bq27220_get_remaining_capacity(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
3,
|
||||
"gauge",
|
||||
"state",
|
||||
"charge",
|
||||
bq27220_get_state_of_charge(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
3,
|
||||
"gauge",
|
||||
"state",
|
||||
"health",
|
||||
bq27220_get_state_of_health(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
2,
|
||||
"gauge",
|
||||
"voltage",
|
||||
bq27220_get_voltage(&furi_hal_i2c_handle_power));
|
||||
property_value_out(
|
||||
&property_context,
|
||||
"%d",
|
||||
2,
|
||||
"gauge",
|
||||
"current",
|
||||
bq27220_get_current(&furi_hal_i2c_handle_power));
|
||||
|
||||
property_context.last = true;
|
||||
const int battery_temp =
|
||||
(int)furi_hal_power_get_battery_temperature_internal(FuriHalPowerICFuelGauge);
|
||||
property_value_out(&property_context, "%d", 2, "gauge", "temperature", battery_temp);
|
||||
} else {
|
||||
property_context.last = true;
|
||||
property_value_out(&property_context, "%lu", 2, "charger", "ntc", ntc_mpct);
|
||||
}
|
||||
|
||||
furi_string_free(key);
|
||||
furi_string_free(value);
|
||||
|
||||
furi_hal_i2c_release(&furi_hal_i2c_handle_power);
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
#include <bq27220_data_memory.h>
|
||||
|
||||
const BQ27220DMGaugingConfig furi_hal_power_gauge_data_memory_gauging_config = {
|
||||
.CCT = 1,
|
||||
.CSYNC = 0,
|
||||
.EDV_CMP = 0,
|
||||
.SC = 1,
|
||||
.FIXED_EDV0 = 1,
|
||||
.FCC_LIM = 1,
|
||||
.FC_FOR_VDQ = 1,
|
||||
.IGNORE_SD = 1,
|
||||
.SME0 = 0,
|
||||
};
|
||||
|
||||
const BQ27220DMData furi_hal_power_gauge_data_memory[] = {
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1GaugingConfig,
|
||||
.type = BQ27220DMTypePtr16,
|
||||
.value.u32 = (uint32_t)&furi_hal_power_gauge_data_memory_gauging_config,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1FullChargeCapacity,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 2100,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1DesignCapacity,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 2100,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1EMF,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3679,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1C0,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 430,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1R0,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 334,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1T0,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 4626,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1R1,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 408,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1TC,
|
||||
.type = BQ27220DMTypeU8,
|
||||
.value.u8 = 11,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1C1,
|
||||
.type = BQ27220DMTypeU8,
|
||||
.value.u8 = 0,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD0,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 4044,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD10,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3905,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD20,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3807,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD30,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3718,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD40,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3642,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD50,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3585,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD60,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3546,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD70,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3514,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD80,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3477,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD90,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3411,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1StartDOD100,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3299,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1EDV0,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3300,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1EDV1,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3321,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressGasGaugingCEDVProfile1EDV2,
|
||||
.type = BQ27220DMTypeU16,
|
||||
.value.u16 = 3355,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressCalibrationCurrentDeadband,
|
||||
.type = BQ27220DMTypeU8,
|
||||
.value.u8 = 1,
|
||||
},
|
||||
{
|
||||
.address = BQ27220DMAddressConfigurationPowerSleepCurrent,
|
||||
.type = BQ27220DMTypeI16,
|
||||
.value.i16 = 1,
|
||||
},
|
||||
{
|
||||
.type = BQ27220DMTypeEnd,
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,138 @@
|
||||
#include <furi_hal_pwm.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_bus.h>
|
||||
|
||||
#include <stm32wbxx_ll_tim.h>
|
||||
#include <stm32wbxx_ll_lptim.h>
|
||||
#include <stm32wbxx_ll_rcc.h>
|
||||
|
||||
#include <furi.h>
|
||||
|
||||
const uint32_t lptim_psc_table[] = {
|
||||
LL_LPTIM_PRESCALER_DIV1,
|
||||
LL_LPTIM_PRESCALER_DIV2,
|
||||
LL_LPTIM_PRESCALER_DIV4,
|
||||
LL_LPTIM_PRESCALER_DIV8,
|
||||
LL_LPTIM_PRESCALER_DIV16,
|
||||
LL_LPTIM_PRESCALER_DIV32,
|
||||
LL_LPTIM_PRESCALER_DIV64,
|
||||
LL_LPTIM_PRESCALER_DIV128,
|
||||
};
|
||||
|
||||
void furi_hal_pwm_start(FuriHalPwmOutputId channel, uint32_t freq, uint8_t duty) {
|
||||
if(channel == FuriHalPwmOutputIdTim1PA7) {
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_ext_pa7,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn1TIM1);
|
||||
|
||||
furi_hal_bus_enable(FuriHalBusTIM1);
|
||||
|
||||
LL_TIM_SetCounterMode(TIM1, LL_TIM_COUNTERMODE_UP);
|
||||
LL_TIM_SetRepetitionCounter(TIM1, 0);
|
||||
LL_TIM_SetClockDivision(TIM1, LL_TIM_CLOCKDIVISION_DIV1);
|
||||
LL_TIM_SetClockSource(TIM1, LL_TIM_CLOCKSOURCE_INTERNAL);
|
||||
LL_TIM_EnableARRPreload(TIM1);
|
||||
|
||||
LL_TIM_OC_EnablePreload(TIM1, LL_TIM_CHANNEL_CH1);
|
||||
LL_TIM_OC_SetMode(TIM1, LL_TIM_CHANNEL_CH1, LL_TIM_OCMODE_PWM1);
|
||||
LL_TIM_OC_SetPolarity(TIM1, LL_TIM_CHANNEL_CH1N, LL_TIM_OCPOLARITY_HIGH);
|
||||
LL_TIM_OC_DisableFast(TIM1, LL_TIM_CHANNEL_CH1);
|
||||
LL_TIM_CC_EnableChannel(TIM1, LL_TIM_CHANNEL_CH1N);
|
||||
|
||||
LL_TIM_EnableAllOutputs(TIM1);
|
||||
|
||||
furi_hal_pwm_set_params(channel, freq, duty);
|
||||
|
||||
LL_TIM_EnableCounter(TIM1);
|
||||
} else if(channel == FuriHalPwmOutputIdLptim2PA4) {
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_ext_pa4,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn14LPTIM2);
|
||||
|
||||
furi_hal_bus_enable(FuriHalBusLPTIM2);
|
||||
|
||||
LL_LPTIM_SetUpdateMode(LPTIM2, LL_LPTIM_UPDATE_MODE_ENDOFPERIOD);
|
||||
LL_RCC_SetLPTIMClockSource(LL_RCC_LPTIM2_CLKSOURCE_PCLK1);
|
||||
LL_LPTIM_SetClockSource(LPTIM2, LL_LPTIM_CLK_SOURCE_INTERNAL);
|
||||
LL_LPTIM_ConfigOutput(
|
||||
LPTIM2, LL_LPTIM_OUTPUT_WAVEFORM_PWM, LL_LPTIM_OUTPUT_POLARITY_INVERSE);
|
||||
LL_LPTIM_SetCounterMode(LPTIM2, LL_LPTIM_COUNTER_MODE_INTERNAL);
|
||||
|
||||
LL_LPTIM_Enable(LPTIM2);
|
||||
|
||||
furi_hal_pwm_set_params(channel, freq, duty);
|
||||
|
||||
LL_LPTIM_StartCounter(LPTIM2, LL_LPTIM_OPERATING_MODE_CONTINUOUS);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_pwm_stop(FuriHalPwmOutputId channel) {
|
||||
if(channel == FuriHalPwmOutputIdTim1PA7) {
|
||||
furi_hal_gpio_init_simple(&gpio_ext_pa7, GpioModeAnalog);
|
||||
furi_hal_bus_disable(FuriHalBusTIM1);
|
||||
} else if(channel == FuriHalPwmOutputIdLptim2PA4) {
|
||||
furi_hal_gpio_init_simple(&gpio_ext_pa4, GpioModeAnalog);
|
||||
furi_hal_bus_disable(FuriHalBusLPTIM2);
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_pwm_is_running(FuriHalPwmOutputId channel) {
|
||||
if(channel == FuriHalPwmOutputIdTim1PA7) {
|
||||
return furi_hal_bus_is_enabled(FuriHalBusTIM1);
|
||||
} else if(channel == FuriHalPwmOutputIdLptim2PA4) {
|
||||
return furi_hal_bus_is_enabled(FuriHalBusLPTIM2);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void furi_hal_pwm_set_params(FuriHalPwmOutputId channel, uint32_t freq, uint8_t duty) {
|
||||
furi_assert(freq > 0);
|
||||
uint32_t freq_div = 64000000LU / freq;
|
||||
|
||||
if(channel == FuriHalPwmOutputIdTim1PA7) {
|
||||
uint32_t prescaler = freq_div / 0x10000LU;
|
||||
uint32_t period = freq_div / (prescaler + 1);
|
||||
uint32_t compare = period * duty / 100;
|
||||
|
||||
LL_TIM_SetPrescaler(TIM1, prescaler);
|
||||
LL_TIM_SetAutoReload(TIM1, period - 1);
|
||||
LL_TIM_OC_SetCompareCH1(TIM1, compare);
|
||||
} else if(channel == FuriHalPwmOutputIdLptim2PA4) {
|
||||
uint32_t prescaler = 0;
|
||||
uint32_t period = 0;
|
||||
|
||||
bool clock_lse = false;
|
||||
|
||||
do {
|
||||
period = freq_div / (1UL << prescaler);
|
||||
if(period <= 0xFFFF) {
|
||||
break;
|
||||
}
|
||||
prescaler++;
|
||||
if(prescaler > 7) {
|
||||
prescaler = 0;
|
||||
clock_lse = true;
|
||||
period = 32768LU / freq;
|
||||
break;
|
||||
}
|
||||
} while(1);
|
||||
|
||||
uint32_t compare = period * duty / 100;
|
||||
|
||||
LL_LPTIM_SetPrescaler(LPTIM2, lptim_psc_table[prescaler]);
|
||||
LL_LPTIM_SetAutoReload(LPTIM2, period);
|
||||
LL_LPTIM_SetCompare(LPTIM2, compare);
|
||||
|
||||
if(clock_lse) {
|
||||
LL_RCC_SetLPTIMClockSource(LL_RCC_LPTIM2_CLKSOURCE_LSE);
|
||||
} else {
|
||||
LL_RCC_SetLPTIMClockSource(LL_RCC_LPTIM2_CLKSOURCE_PCLK1);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* @file furi_hal_pwm.h
|
||||
* PWM contol HAL
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef enum {
|
||||
FuriHalPwmOutputIdTim1PA7,
|
||||
FuriHalPwmOutputIdLptim2PA4,
|
||||
} FuriHalPwmOutputId;
|
||||
|
||||
/** Enable PWM channel and set parameters
|
||||
*
|
||||
* @param[in] channel PWM channel (FuriHalPwmOutputId)
|
||||
* @param[in] freq Frequency in Hz
|
||||
* @param[in] duty Duty cycle value in %
|
||||
*/
|
||||
void furi_hal_pwm_start(FuriHalPwmOutputId channel, uint32_t freq, uint8_t duty);
|
||||
|
||||
/** Disable PWM channel
|
||||
*
|
||||
* @param[in] channel PWM channel (FuriHalPwmOutputId)
|
||||
*/
|
||||
void furi_hal_pwm_stop(FuriHalPwmOutputId channel);
|
||||
|
||||
/** Set PWM channel parameters
|
||||
*
|
||||
* @param[in] channel PWM channel (FuriHalPwmOutputId)
|
||||
* @param[in] freq Frequency in Hz
|
||||
* @param[in] duty Duty cycle value in %
|
||||
*/
|
||||
void furi_hal_pwm_set_params(FuriHalPwmOutputId channel, uint32_t freq, uint8_t duty);
|
||||
|
||||
/** Is PWM channel running?
|
||||
*
|
||||
* @param[in] channel PWM channel (FuriHalPwmOutputId)
|
||||
* @return bool - true if running
|
||||
*/
|
||||
bool furi_hal_pwm_is_running(FuriHalPwmOutputId channel);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,80 @@
|
||||
#include <furi_hal_random.h>
|
||||
#include <furi_hal_bus.h>
|
||||
#include <furi.h>
|
||||
|
||||
#include <stm32wbxx_ll_rng.h>
|
||||
#include <stm32wbxx_ll_rcc.h>
|
||||
#include <stm32wbxx_ll_hsem.h>
|
||||
|
||||
#include <hsem_map.h>
|
||||
|
||||
#define TAG "FuriHalRandom"
|
||||
|
||||
static uint32_t furi_hal_random_read_rng() {
|
||||
while(LL_RNG_IsActiveFlag_CECS(RNG) && LL_RNG_IsActiveFlag_SECS(RNG) &&
|
||||
!LL_RNG_IsActiveFlag_DRDY(RNG)) {
|
||||
/* Error handling as described in RM0434, pg. 582-583 */
|
||||
if(LL_RNG_IsActiveFlag_CECS(RNG)) {
|
||||
/* Clock error occurred */
|
||||
LL_RNG_ClearFlag_CEIS(RNG);
|
||||
}
|
||||
|
||||
if(LL_RNG_IsActiveFlag_SECS(RNG)) {
|
||||
/* Noise source error occurred */
|
||||
LL_RNG_ClearFlag_SEIS(RNG);
|
||||
|
||||
for(uint32_t i = 0; i < 12; ++i) {
|
||||
const volatile uint32_t discard = LL_RNG_ReadRandData32(RNG);
|
||||
UNUSED(discard);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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))
|
||||
;
|
||||
LL_RNG_Enable(RNG);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
void furi_hal_random_fill_buf(uint8_t* buf, uint32_t len) {
|
||||
while(LL_HSEM_1StepLock(HSEM, CFG_HW_RNG_SEMID))
|
||||
;
|
||||
LL_RNG_Enable(RNG);
|
||||
|
||||
for(uint32_t i = 0; i < len; i += 4) {
|
||||
const uint32_t random_val = furi_hal_random_read_rng();
|
||||
uint8_t len_cur = ((i + 4) < len) ? (4) : (len - i);
|
||||
memcpy(&buf[i], &random_val, len_cur);
|
||||
}
|
||||
|
||||
LL_RNG_Disable(RNG);
|
||||
LL_HSEM_ReleaseLock(HSEM, CFG_HW_RNG_SEMID, 0);
|
||||
}
|
||||
|
||||
void srand(unsigned seed) {
|
||||
UNUSED(seed);
|
||||
}
|
||||
|
||||
int rand() {
|
||||
return (furi_hal_random_get() & RAND_MAX);
|
||||
}
|
||||
|
||||
long random() {
|
||||
return (furi_hal_random_get() & RAND_MAX);
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
#include <furi_hal_region.h>
|
||||
#include <furi_hal_version.h>
|
||||
|
||||
const FuriHalRegion furi_hal_region_zero = {
|
||||
.country_code = "00",
|
||||
.bands_count = 1,
|
||||
.bands = {
|
||||
{
|
||||
.start = 0,
|
||||
.end = 1000000000,
|
||||
.power_limit = 12,
|
||||
.duty_cycle = 50,
|
||||
},
|
||||
}};
|
||||
|
||||
const FuriHalRegion furi_hal_region_eu_ru = {
|
||||
.country_code = "EU",
|
||||
.bands_count = 2,
|
||||
.bands = {
|
||||
{
|
||||
.start = 433050000,
|
||||
.end = 434790000,
|
||||
.power_limit = 12,
|
||||
.duty_cycle = 50,
|
||||
},
|
||||
{
|
||||
.start = 868150000,
|
||||
.end = 868550000,
|
||||
.power_limit = 12,
|
||||
.duty_cycle = 50,
|
||||
}}};
|
||||
|
||||
const FuriHalRegion furi_hal_region_us_ca_au = {
|
||||
.country_code = "US",
|
||||
.bands_count = 3,
|
||||
.bands = {
|
||||
{
|
||||
.start = 304100000,
|
||||
.end = 321950000,
|
||||
.power_limit = 12,
|
||||
.duty_cycle = 50,
|
||||
},
|
||||
{
|
||||
.start = 433050000,
|
||||
.end = 434790000,
|
||||
.power_limit = 12,
|
||||
.duty_cycle = 50,
|
||||
},
|
||||
{
|
||||
.start = 915000000,
|
||||
.end = 928000000,
|
||||
.power_limit = 12,
|
||||
.duty_cycle = 50,
|
||||
}}};
|
||||
|
||||
const FuriHalRegion furi_hal_region_jp = {
|
||||
.country_code = "JP",
|
||||
.bands_count = 2,
|
||||
.bands = {
|
||||
{
|
||||
.start = 312000000,
|
||||
.end = 315250000,
|
||||
.power_limit = 12,
|
||||
.duty_cycle = 50,
|
||||
},
|
||||
{
|
||||
.start = 920500000,
|
||||
.end = 923500000,
|
||||
.power_limit = 12,
|
||||
.duty_cycle = 50,
|
||||
}}};
|
||||
|
||||
static const FuriHalRegion* furi_hal_region = NULL;
|
||||
|
||||
void furi_hal_region_init() {
|
||||
FuriHalVersionRegion region = furi_hal_version_get_hw_region();
|
||||
|
||||
if(region == FuriHalVersionRegionUnknown) {
|
||||
furi_hal_region = &furi_hal_region_zero;
|
||||
} else if(region == FuriHalVersionRegionEuRu) {
|
||||
furi_hal_region = &furi_hal_region_eu_ru;
|
||||
} else if(region == FuriHalVersionRegionUsCaAu) {
|
||||
furi_hal_region = &furi_hal_region_us_ca_au;
|
||||
} else if(region == FuriHalVersionRegionJp) {
|
||||
furi_hal_region = &furi_hal_region_jp;
|
||||
}
|
||||
}
|
||||
|
||||
const FuriHalRegion* furi_hal_region_get() {
|
||||
return furi_hal_region;
|
||||
}
|
||||
|
||||
void furi_hal_region_set(FuriHalRegion* region) {
|
||||
furi_hal_region = region;
|
||||
}
|
||||
|
||||
bool furi_hal_region_is_provisioned() {
|
||||
return furi_hal_region != NULL;
|
||||
}
|
||||
|
||||
const char* furi_hal_region_get_name() {
|
||||
if(furi_hal_region) {
|
||||
return furi_hal_region->country_code;
|
||||
} else {
|
||||
return "--";
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_region_is_frequency_allowed(uint32_t frequency) {
|
||||
if(!furi_hal_region) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const FuriHalRegionBand* band = furi_hal_region_get_band(frequency);
|
||||
if(!band) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
const FuriHalRegionBand* furi_hal_region_get_band(uint32_t frequency) {
|
||||
if(!furi_hal_region) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for(size_t i = 0; i < furi_hal_region->bands_count; i++) {
|
||||
if(furi_hal_region->bands[i].start <= frequency &&
|
||||
furi_hal_region->bands[i].end >= frequency) {
|
||||
return &furi_hal_region->bands[i];
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
@@ -0,0 +1,230 @@
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_bus.h>
|
||||
#include <furi.h>
|
||||
|
||||
#include <stm32wbxx_ll_rcc.h>
|
||||
#include <stm32wbxx_ll_pwr.h>
|
||||
|
||||
#define TAG "FuriHalResources"
|
||||
|
||||
const GpioPin gpio_swdio = {.port = GPIOA, .pin = LL_GPIO_PIN_13};
|
||||
const GpioPin gpio_swclk = {.port = GPIOA, .pin = LL_GPIO_PIN_14};
|
||||
|
||||
const GpioPin gpio_vibro = {.port = VIBRO_GPIO_Port, .pin = VIBRO_Pin};
|
||||
const GpioPin gpio_ibutton = {.port = iBTN_GPIO_Port, .pin = iBTN_Pin};
|
||||
|
||||
const GpioPin gpio_cc1101_g0 = {.port = CC1101_G0_GPIO_Port, .pin = CC1101_G0_Pin};
|
||||
const GpioPin gpio_rf_sw_0 = {.port = RF_SW_0_GPIO_Port, .pin = RF_SW_0_Pin};
|
||||
|
||||
const GpioPin gpio_subghz_cs = {.port = CC1101_CS_GPIO_Port, .pin = CC1101_CS_Pin};
|
||||
const GpioPin gpio_display_cs = {.port = DISPLAY_CS_GPIO_Port, .pin = DISPLAY_CS_Pin};
|
||||
const GpioPin gpio_display_rst_n = {.port = DISPLAY_RST_GPIO_Port, .pin = DISPLAY_RST_Pin};
|
||||
const GpioPin gpio_display_di = {.port = DISPLAY_DI_GPIO_Port, .pin = DISPLAY_DI_Pin};
|
||||
const GpioPin gpio_sdcard_cs = {.port = SD_CS_GPIO_Port, .pin = SD_CS_Pin};
|
||||
const GpioPin gpio_sdcard_cd = {.port = SD_CD_GPIO_Port, .pin = SD_CD_Pin};
|
||||
const GpioPin gpio_nfc_cs = {.port = NFC_CS_GPIO_Port, .pin = NFC_CS_Pin};
|
||||
|
||||
const GpioPin gpio_button_up = {.port = GPIOB, .pin = LL_GPIO_PIN_10};
|
||||
const GpioPin gpio_button_down = {.port = GPIOC, .pin = LL_GPIO_PIN_6};
|
||||
const GpioPin gpio_button_right = {.port = GPIOB, .pin = LL_GPIO_PIN_12};
|
||||
const GpioPin gpio_button_left = {.port = GPIOB, .pin = LL_GPIO_PIN_11};
|
||||
const GpioPin gpio_button_ok = {.port = GPIOH, .pin = LL_GPIO_PIN_3};
|
||||
const GpioPin gpio_button_back = {.port = GPIOC, .pin = LL_GPIO_PIN_13};
|
||||
|
||||
const GpioPin gpio_spi_d_miso = {.port = SPI_D_MISO_GPIO_Port, .pin = SPI_D_MISO_Pin};
|
||||
const GpioPin gpio_spi_d_mosi = {.port = SPI_D_MOSI_GPIO_Port, .pin = SPI_D_MOSI_Pin};
|
||||
const GpioPin gpio_spi_d_sck = {.port = SPI_D_SCK_GPIO_Port, .pin = SPI_D_SCK_Pin};
|
||||
const GpioPin gpio_spi_r_miso = {.port = SPI_R_MISO_GPIO_Port, .pin = SPI_R_MISO_Pin};
|
||||
const GpioPin gpio_spi_r_mosi = {.port = SPI_R_MOSI_GPIO_Port, .pin = SPI_R_MOSI_Pin};
|
||||
const GpioPin gpio_spi_r_sck = {.port = SPI_R_SCK_GPIO_Port, .pin = SPI_R_SCK_Pin};
|
||||
|
||||
const GpioPin gpio_ext_pc0 = {.port = GPIOC, .pin = LL_GPIO_PIN_0};
|
||||
const GpioPin gpio_ext_pc1 = {.port = GPIOC, .pin = LL_GPIO_PIN_1};
|
||||
const GpioPin gpio_ext_pc3 = {.port = GPIOC, .pin = LL_GPIO_PIN_3};
|
||||
const GpioPin gpio_ext_pb2 = {.port = GPIOB, .pin = LL_GPIO_PIN_2};
|
||||
const GpioPin gpio_ext_pb3 = {.port = GPIOB, .pin = LL_GPIO_PIN_3};
|
||||
const GpioPin gpio_ext_pa4 = {.port = GPIOA, .pin = LL_GPIO_PIN_4};
|
||||
const GpioPin gpio_ext_pa6 = {.port = GPIOA, .pin = LL_GPIO_PIN_6};
|
||||
const GpioPin gpio_ext_pa7 = {.port = GPIOA, .pin = LL_GPIO_PIN_7};
|
||||
|
||||
const GpioPin gpio_nfc_irq_rfid_pull = {.port = RFID_PULL_GPIO_Port, .pin = RFID_PULL_Pin};
|
||||
const GpioPin gpio_rfid_carrier_out = {.port = RFID_OUT_GPIO_Port, .pin = RFID_OUT_Pin};
|
||||
const GpioPin gpio_rfid_data_in = {.port = RFID_RF_IN_GPIO_Port, .pin = RFID_RF_IN_Pin};
|
||||
const GpioPin gpio_rfid_carrier = {.port = RFID_CARRIER_GPIO_Port, .pin = RFID_CARRIER_Pin};
|
||||
|
||||
const GpioPin gpio_infrared_rx = {.port = IR_RX_GPIO_Port, .pin = IR_RX_Pin};
|
||||
const GpioPin gpio_infrared_tx = {.port = IR_TX_GPIO_Port, .pin = IR_TX_Pin};
|
||||
|
||||
const GpioPin gpio_usart_tx = {.port = USART1_TX_Port, .pin = USART1_TX_Pin};
|
||||
const GpioPin gpio_usart_rx = {.port = USART1_RX_Port, .pin = USART1_RX_Pin};
|
||||
|
||||
const GpioPin gpio_i2c_power_sda = {.port = GPIOA, .pin = LL_GPIO_PIN_10};
|
||||
const GpioPin gpio_i2c_power_scl = {.port = GPIOA, .pin = LL_GPIO_PIN_9};
|
||||
|
||||
const GpioPin gpio_speaker = {.port = GPIOB, .pin = LL_GPIO_PIN_8};
|
||||
|
||||
const GpioPin gpio_periph_power = {.port = GPIOA, .pin = LL_GPIO_PIN_3};
|
||||
|
||||
const GpioPin gpio_usb_dm = {.port = GPIOA, .pin = LL_GPIO_PIN_11};
|
||||
const GpioPin gpio_usb_dp = {.port = GPIOA, .pin = LL_GPIO_PIN_12};
|
||||
|
||||
const GpioPinRecord gpio_pins[] = {
|
||||
// 5V: 1
|
||||
{.pin = &gpio_ext_pa7, .name = "PA7", .number = 2, .debug = false},
|
||||
{.pin = &gpio_ext_pa6, .name = "PA6", .number = 3, .debug = false},
|
||||
{.pin = &gpio_ext_pa4, .name = "PA4", .number = 4, .debug = false},
|
||||
{.pin = &gpio_ext_pb3, .name = "PB3", .number = 5, .debug = false},
|
||||
{.pin = &gpio_ext_pb2, .name = "PB2", .number = 6, .debug = false},
|
||||
{.pin = &gpio_ext_pc3, .name = "PC3", .number = 7, .debug = false},
|
||||
// GND: 8
|
||||
// Space
|
||||
// 3v3: 9
|
||||
{.pin = &gpio_swclk, .name = "PA14", .number = 10, .debug = true},
|
||||
// GND: 11
|
||||
{.pin = &gpio_swdio, .name = "PA13", .number = 12, .debug = true},
|
||||
{.pin = &gpio_usart_tx, .name = "PB6", .number = 13, .debug = true},
|
||||
{.pin = &gpio_usart_rx, .name = "PB7", .number = 14, .debug = true},
|
||||
{.pin = &gpio_ext_pc1, .name = "PC1", .number = 15, .debug = false},
|
||||
{.pin = &gpio_ext_pc0, .name = "PC0", .number = 16, .debug = false},
|
||||
{.pin = &gpio_ibutton, .name = "PB14", .number = 17, .debug = true},
|
||||
// GND: 18
|
||||
|
||||
/* Dangerous pins, may damage hardware */
|
||||
{.pin = &gpio_speaker, .name = "PB8", .debug = true},
|
||||
{.pin = &gpio_infrared_tx, .name = "PB9", .debug = true},
|
||||
};
|
||||
|
||||
const size_t gpio_pins_count = COUNT_OF(gpio_pins);
|
||||
|
||||
const InputPin input_pins[] = {
|
||||
{.gpio = &gpio_button_up, .key = InputKeyUp, .inverted = true, .name = "Up"},
|
||||
{.gpio = &gpio_button_down, .key = InputKeyDown, .inverted = true, .name = "Down"},
|
||||
{.gpio = &gpio_button_right, .key = InputKeyRight, .inverted = true, .name = "Right"},
|
||||
{.gpio = &gpio_button_left, .key = InputKeyLeft, .inverted = true, .name = "Left"},
|
||||
{.gpio = &gpio_button_ok, .key = InputKeyOk, .inverted = false, .name = "OK"},
|
||||
{.gpio = &gpio_button_back, .key = InputKeyBack, .inverted = true, .name = "Back"},
|
||||
};
|
||||
|
||||
const size_t input_pins_count = COUNT_OF(input_pins);
|
||||
|
||||
static void furi_hal_resources_init_input_pins(GpioMode mode) {
|
||||
for(size_t i = 0; i < input_pins_count; i++) {
|
||||
furi_hal_gpio_init(
|
||||
input_pins[i].gpio,
|
||||
mode,
|
||||
(input_pins[i].inverted) ? GpioPullUp : GpioPullDown,
|
||||
GpioSpeedLow);
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_resources_init_gpio_pins(GpioMode mode) {
|
||||
for(size_t i = 0; i < gpio_pins_count; i++) {
|
||||
if(!gpio_pins[i].debug) {
|
||||
furi_hal_gpio_init(gpio_pins[i].pin, mode, GpioPullNo, GpioSpeedLow);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
// Explicit, surviving reset, pulls
|
||||
LL_PWR_EnablePUPDCfg();
|
||||
LL_PWR_EnableGPIOPullDown(LL_PWR_GPIO_A, LL_PWR_GPIO_BIT_8); // gpio_vibro
|
||||
LL_PWR_EnableGPIOPullDown(LL_PWR_GPIO_B, LL_PWR_GPIO_BIT_8); // gpio_speaker
|
||||
LL_PWR_EnableGPIOPullDown(LL_PWR_GPIO_B, LL_PWR_GPIO_BIT_9); // gpio_infrared_tx
|
||||
|
||||
// SD Card stepdown control
|
||||
furi_hal_gpio_write(&gpio_periph_power, 1);
|
||||
furi_hal_gpio_init(&gpio_periph_power, GpioModeOutputOpenDrain, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
// Display pins
|
||||
furi_hal_gpio_write(&gpio_display_rst_n, 0);
|
||||
furi_hal_gpio_init_simple(&gpio_display_rst_n, GpioModeOutputPushPull);
|
||||
LL_PWR_EnableGPIOPullUp(LL_PWR_GPIO_B, LL_PWR_GPIO_BIT_0); // gpio_display_rst_n
|
||||
furi_hal_gpio_write(&gpio_display_di, 0);
|
||||
furi_hal_gpio_init_simple(&gpio_display_di, GpioModeOutputPushPull);
|
||||
LL_PWR_EnableGPIOPullDown(LL_PWR_GPIO_B, LL_PWR_GPIO_BIT_1); // gpio_display_di
|
||||
|
||||
// Hard reset USB
|
||||
furi_hal_gpio_write(&gpio_usb_dm, 1);
|
||||
furi_hal_gpio_write(&gpio_usb_dp, 1);
|
||||
furi_hal_gpio_init_simple(&gpio_usb_dm, GpioModeOutputOpenDrain);
|
||||
furi_hal_gpio_init_simple(&gpio_usb_dp, GpioModeOutputOpenDrain);
|
||||
furi_hal_gpio_write(&gpio_usb_dm, 0);
|
||||
furi_hal_gpio_write(&gpio_usb_dp, 0);
|
||||
furi_delay_us(5); // Device Driven disconnect: 2.5us + extra to compensate cables
|
||||
furi_hal_gpio_write(&gpio_usb_dm, 1);
|
||||
furi_hal_gpio_write(&gpio_usb_dp, 1);
|
||||
furi_hal_gpio_init_simple(&gpio_usb_dm, GpioModeAnalog);
|
||||
furi_hal_gpio_init_simple(&gpio_usb_dp, GpioModeAnalog);
|
||||
furi_hal_gpio_write(&gpio_usb_dm, 0);
|
||||
furi_hal_gpio_write(&gpio_usb_dp, 0);
|
||||
|
||||
// External header pins
|
||||
furi_hal_resources_init_gpio_pins(GpioModeAnalog);
|
||||
}
|
||||
|
||||
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() {
|
||||
// Button pins
|
||||
furi_hal_resources_init_input_pins(GpioModeInterruptRiseFall);
|
||||
|
||||
// SD pins
|
||||
furi_hal_gpio_init(&gpio_sdcard_cd, GpioModeInput, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_write(&gpio_sdcard_cd, 0);
|
||||
|
||||
furi_hal_gpio_init(&gpio_ibutton, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
furi_hal_gpio_init(&gpio_nfc_irq_rfid_pull, GpioModeInterruptRise, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
furi_hal_gpio_init(&gpio_rf_sw_0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
NVIC_SetPriority(EXTI0_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_EnableIRQ(EXTI0_IRQn);
|
||||
|
||||
NVIC_SetPriority(EXTI1_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_EnableIRQ(EXTI1_IRQn);
|
||||
|
||||
NVIC_SetPriority(EXTI2_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_EnableIRQ(EXTI2_IRQn);
|
||||
|
||||
NVIC_SetPriority(EXTI3_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_EnableIRQ(EXTI3_IRQn);
|
||||
|
||||
NVIC_SetPriority(EXTI4_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_EnableIRQ(EXTI4_IRQn);
|
||||
|
||||
NVIC_SetPriority(EXTI9_5_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_EnableIRQ(EXTI9_5_IRQn);
|
||||
|
||||
NVIC_SetPriority(EXTI15_10_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_EnableIRQ(EXTI15_10_IRQn);
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
int32_t furi_hal_resources_get_ext_pin_number(const GpioPin* gpio) {
|
||||
for(size_t i = 0; i < gpio_pins_count; i++) {
|
||||
if(gpio_pins[i].pin == gpio) {
|
||||
return gpio_pins[i].number;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
#pragma once
|
||||
|
||||
#include <furi.h>
|
||||
|
||||
#include <stm32wbxx.h>
|
||||
#include <stm32wbxx_ll_gpio.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Input Related Constants */
|
||||
#define INPUT_DEBOUNCE_TICKS 4
|
||||
|
||||
/* Input Keys */
|
||||
typedef enum {
|
||||
InputKeyUp,
|
||||
InputKeyDown,
|
||||
InputKeyRight,
|
||||
InputKeyLeft,
|
||||
InputKeyOk,
|
||||
InputKeyBack,
|
||||
InputKeyMAX, /**< Special value */
|
||||
} InputKey;
|
||||
|
||||
/* Light */
|
||||
typedef enum {
|
||||
LightRed = (1 << 0),
|
||||
LightGreen = (1 << 1),
|
||||
LightBlue = (1 << 2),
|
||||
LightBacklight = (1 << 3),
|
||||
} Light;
|
||||
|
||||
typedef struct {
|
||||
const GpioPin* gpio;
|
||||
const InputKey key;
|
||||
const bool inverted;
|
||||
const char* name;
|
||||
} InputPin;
|
||||
|
||||
typedef struct {
|
||||
const GpioPin* pin;
|
||||
const char* name;
|
||||
const uint8_t number;
|
||||
const bool debug;
|
||||
} GpioPinRecord;
|
||||
|
||||
extern const InputPin input_pins[];
|
||||
extern const size_t input_pins_count;
|
||||
|
||||
extern const GpioPinRecord gpio_pins[];
|
||||
extern const size_t gpio_pins_count;
|
||||
|
||||
extern const GpioPin gpio_swdio;
|
||||
extern const GpioPin gpio_swclk;
|
||||
|
||||
extern const GpioPin gpio_vibro;
|
||||
extern const GpioPin gpio_ibutton;
|
||||
|
||||
extern const GpioPin gpio_cc1101_g0;
|
||||
extern const GpioPin gpio_rf_sw_0;
|
||||
|
||||
extern const GpioPin gpio_subghz_cs;
|
||||
extern const GpioPin gpio_display_cs;
|
||||
extern const GpioPin gpio_display_rst_n;
|
||||
extern const GpioPin gpio_display_di;
|
||||
extern const GpioPin gpio_sdcard_cs;
|
||||
extern const GpioPin gpio_sdcard_cd;
|
||||
extern const GpioPin gpio_nfc_cs;
|
||||
|
||||
extern const GpioPin gpio_button_up;
|
||||
extern const GpioPin gpio_button_down;
|
||||
extern const GpioPin gpio_button_right;
|
||||
extern const GpioPin gpio_button_left;
|
||||
extern const GpioPin gpio_button_ok;
|
||||
extern const GpioPin gpio_button_back;
|
||||
|
||||
extern const GpioPin gpio_spi_d_miso;
|
||||
extern const GpioPin gpio_spi_d_mosi;
|
||||
extern const GpioPin gpio_spi_d_sck;
|
||||
extern const GpioPin gpio_spi_r_miso;
|
||||
extern const GpioPin gpio_spi_r_mosi;
|
||||
extern const GpioPin gpio_spi_r_sck;
|
||||
|
||||
extern const GpioPin gpio_ext_pc0;
|
||||
extern const GpioPin gpio_ext_pc1;
|
||||
extern const GpioPin gpio_ext_pc3;
|
||||
extern const GpioPin gpio_ext_pb2;
|
||||
extern const GpioPin gpio_ext_pb3;
|
||||
extern const GpioPin gpio_ext_pa4;
|
||||
extern const GpioPin gpio_ext_pa6;
|
||||
extern const GpioPin gpio_ext_pa7;
|
||||
|
||||
extern const GpioPin gpio_nfc_irq_rfid_pull;
|
||||
extern const GpioPin gpio_rfid_carrier_out;
|
||||
extern const GpioPin gpio_rfid_data_in;
|
||||
extern const GpioPin gpio_rfid_carrier;
|
||||
|
||||
extern const GpioPin gpio_infrared_rx;
|
||||
extern const GpioPin gpio_infrared_tx;
|
||||
|
||||
extern const GpioPin gpio_usart_tx;
|
||||
extern const GpioPin gpio_usart_rx;
|
||||
extern const GpioPin gpio_i2c_power_sda;
|
||||
extern const GpioPin gpio_i2c_power_scl;
|
||||
|
||||
extern const GpioPin gpio_speaker;
|
||||
|
||||
extern const GpioPin gpio_periph_power;
|
||||
|
||||
extern const GpioPin gpio_usb_dm;
|
||||
extern const GpioPin gpio_usb_dp;
|
||||
|
||||
#define BUTTON_BACK_GPIO_Port GPIOC
|
||||
#define BUTTON_BACK_Pin LL_GPIO_PIN_13
|
||||
#define BUTTON_DOWN_GPIO_Port GPIOC
|
||||
#define BUTTON_DOWN_Pin LL_GPIO_PIN_6
|
||||
#define BUTTON_LEFT_GPIO_Port GPIOB
|
||||
#define BUTTON_LEFT_Pin LL_GPIO_PIN_11
|
||||
#define BUTTON_OK_GPIO_Port GPIOH
|
||||
#define BUTTON_OK_Pin LL_GPIO_PIN_3
|
||||
#define BUTTON_RIGHT_GPIO_Port GPIOB
|
||||
#define BUTTON_RIGHT_Pin LL_GPIO_PIN_12
|
||||
#define BUTTON_UP_GPIO_Port GPIOB
|
||||
#define BUTTON_UP_Pin LL_GPIO_PIN_10
|
||||
|
||||
#define CC1101_CS_GPIO_Port GPIOD
|
||||
#define CC1101_CS_Pin LL_GPIO_PIN_0
|
||||
#define CC1101_G0_GPIO_Port GPIOA
|
||||
#define CC1101_G0_Pin LL_GPIO_PIN_1
|
||||
|
||||
#define DISPLAY_CS_GPIO_Port GPIOC
|
||||
#define DISPLAY_CS_Pin LL_GPIO_PIN_11
|
||||
#define DISPLAY_DI_GPIO_Port GPIOB
|
||||
#define DISPLAY_DI_Pin LL_GPIO_PIN_1
|
||||
#define DISPLAY_RST_GPIO_Port GPIOB
|
||||
#define DISPLAY_RST_Pin LL_GPIO_PIN_0
|
||||
|
||||
#define IR_RX_GPIO_Port GPIOA
|
||||
#define IR_RX_Pin LL_GPIO_PIN_0
|
||||
#define IR_TX_GPIO_Port GPIOB
|
||||
#define IR_TX_Pin LL_GPIO_PIN_9
|
||||
|
||||
#define NFC_CS_GPIO_Port GPIOE
|
||||
#define NFC_CS_Pin LL_GPIO_PIN_4
|
||||
|
||||
#define PA4_GPIO_Port GPIOA
|
||||
#define PA4_Pin LL_GPIO_PIN_4
|
||||
#define PA6_GPIO_Port GPIOA
|
||||
#define PA6_Pin LL_GPIO_PIN_6
|
||||
#define PA7_GPIO_Port GPIOA
|
||||
#define PA7_Pin LL_GPIO_PIN_7
|
||||
#define PB2_GPIO_Port GPIOB
|
||||
#define PB2_Pin LL_GPIO_PIN_2
|
||||
#define PB3_GPIO_Port GPIOB
|
||||
#define PB3_Pin LL_GPIO_PIN_3
|
||||
#define PC0_GPIO_Port GPIOC
|
||||
#define PC0_Pin LL_GPIO_PIN_0
|
||||
#define PC1_GPIO_Port GPIOC
|
||||
#define PC1_Pin LL_GPIO_PIN_1
|
||||
#define PC3_GPIO_Port GPIOC
|
||||
#define PC3_Pin LL_GPIO_PIN_3
|
||||
|
||||
#define QUARTZ_32MHZ_IN_GPIO_Port GPIOC
|
||||
#define QUARTZ_32MHZ_IN_Pin LL_GPIO_PIN_14
|
||||
#define QUARTZ_32MHZ_OUT_GPIO_Port GPIOC
|
||||
#define QUARTZ_32MHZ_OUT_Pin LL_GPIO_PIN_15
|
||||
|
||||
#define RFID_OUT_GPIO_Port GPIOB
|
||||
#define RFID_OUT_Pin LL_GPIO_PIN_13
|
||||
#define RFID_PULL_GPIO_Port GPIOA
|
||||
#define RFID_PULL_Pin LL_GPIO_PIN_2
|
||||
#define RFID_RF_IN_GPIO_Port GPIOC
|
||||
#define RFID_RF_IN_Pin LL_GPIO_PIN_5
|
||||
#define RFID_CARRIER_GPIO_Port GPIOA
|
||||
#define RFID_CARRIER_Pin LL_GPIO_PIN_15
|
||||
|
||||
#define RF_SW_0_GPIO_Port GPIOC
|
||||
#define RF_SW_0_Pin LL_GPIO_PIN_4
|
||||
|
||||
#define SD_CD_GPIO_Port GPIOC
|
||||
#define SD_CD_Pin LL_GPIO_PIN_10
|
||||
#define SD_CS_GPIO_Port GPIOC
|
||||
#define SD_CS_Pin LL_GPIO_PIN_12
|
||||
|
||||
#define SPEAKER_GPIO_Port GPIOB
|
||||
#define SPEAKER_Pin LL_GPIO_PIN_8
|
||||
|
||||
#define VIBRO_GPIO_Port GPIOA
|
||||
#define VIBRO_Pin LL_GPIO_PIN_8
|
||||
|
||||
#define iBTN_GPIO_Port GPIOB
|
||||
#define iBTN_Pin LL_GPIO_PIN_14
|
||||
|
||||
#define USART1_TX_Pin LL_GPIO_PIN_6
|
||||
#define USART1_TX_Port GPIOB
|
||||
#define USART1_RX_Pin LL_GPIO_PIN_7
|
||||
#define USART1_RX_Port GPIOB
|
||||
|
||||
#define SPI_D_MISO_GPIO_Port GPIOC
|
||||
#define SPI_D_MISO_Pin LL_GPIO_PIN_2
|
||||
#define SPI_D_MOSI_GPIO_Port GPIOB
|
||||
#define SPI_D_MOSI_Pin LL_GPIO_PIN_15
|
||||
#define SPI_D_SCK_GPIO_Port GPIOD
|
||||
#define SPI_D_SCK_Pin LL_GPIO_PIN_1
|
||||
|
||||
#define SPI_R_MISO_GPIO_Port GPIOB
|
||||
#define SPI_R_MISO_Pin LL_GPIO_PIN_4
|
||||
#define SPI_R_MOSI_GPIO_Port GPIOB
|
||||
#define SPI_R_MOSI_Pin LL_GPIO_PIN_5
|
||||
#define SPI_R_SCK_GPIO_Port GPIOA
|
||||
#define SPI_R_SCK_Pin LL_GPIO_PIN_5
|
||||
|
||||
#define NFC_IRQ_Pin RFID_PULL_Pin
|
||||
#define NFC_IRQ_GPIO_Port RFID_PULL_GPIO_Port
|
||||
|
||||
void furi_hal_resources_init_early();
|
||||
|
||||
void furi_hal_resources_deinit_early();
|
||||
|
||||
void furi_hal_resources_init();
|
||||
|
||||
/**
|
||||
* Get a corresponding external connector pin number for a gpio
|
||||
* @param gpio GpioPin
|
||||
* @return pin number or -1 if gpio is not on the external connector
|
||||
*/
|
||||
int32_t furi_hal_resources_get_ext_pin_number(const GpioPin* gpio);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,588 @@
|
||||
#include <furi_hal_rfid.h>
|
||||
#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>
|
||||
#include <stm32wbxx_ll_comp.h>
|
||||
#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
|
||||
|
||||
// Field presence detection
|
||||
#define FURI_HAL_RFID_FIELD_FREQUENCY_MIN 80000
|
||||
#define FURI_HAL_RFID_FIELD_FREQUENCY_MAX 200000
|
||||
|
||||
#define FURI_HAL_RFID_FIELD_COUNTER_TIMER TIM2
|
||||
#define FURI_HAL_RFID_FIELD_COUNTER_TIMER_BUS FuriHalBusTIM2
|
||||
#define FURI_HAL_RFID_FIELD_COUNTER_TIMER_CHANNEL LL_TIM_CHANNEL_CH3
|
||||
|
||||
#define FURI_HAL_RFID_FIELD_TIMEOUT_TIMER TIM1
|
||||
#define FURI_HAL_RFID_FIELD_TIMEOUT_TIMER_BUS FuriHalBusTIM1
|
||||
|
||||
#define FURI_HAL_RFID_FIELD_DMAMUX_DMA LL_DMAMUX_REQ_TIM1_UP
|
||||
|
||||
/* DMA Channels definition */
|
||||
#define RFID_DMA DMA2
|
||||
#define RFID_DMA_CH1_CHANNEL LL_DMA_CHANNEL_1
|
||||
#define RFID_DMA_CH2_CHANNEL LL_DMA_CHANNEL_2
|
||||
#define RFID_DMA_CH1_IRQ FuriHalInterruptIdDma2Ch1
|
||||
#define RFID_DMA_CH1_DEF RFID_DMA, RFID_DMA_CH1_CHANNEL
|
||||
#define RFID_DMA_CH2_DEF RFID_DMA, RFID_DMA_CH2_CHANNEL
|
||||
|
||||
typedef struct {
|
||||
uint32_t counter;
|
||||
uint32_t set_tim_counter_cnt;
|
||||
} FuriHalRfidField;
|
||||
|
||||
typedef struct {
|
||||
FuriHalRfidDMACallback dma_callback;
|
||||
FuriHalRfidReadCaptureCallback read_capture_callback;
|
||||
void* context;
|
||||
FuriHalRfidField field;
|
||||
} FuriHalRfid;
|
||||
|
||||
FuriHalRfid* furi_hal_rfid = NULL;
|
||||
|
||||
#define LFRFID_LL_READ_TIM TIM1
|
||||
#define LFRFID_LL_READ_CONFIG_CHANNEL LL_TIM_CHANNEL_CH1
|
||||
#define LFRFID_LL_READ_CHANNEL LL_TIM_CHANNEL_CH1N
|
||||
|
||||
#define LFRFID_LL_EMULATE_TIM TIM2
|
||||
#define LFRFID_LL_EMULATE_CHANNEL LL_TIM_CHANNEL_CH3
|
||||
|
||||
void furi_hal_rfid_init() {
|
||||
furi_assert(furi_hal_rfid == NULL);
|
||||
furi_hal_rfid = malloc(sizeof(FuriHalRfid));
|
||||
furi_hal_rfid->field.counter = 0;
|
||||
furi_hal_rfid->field.set_tim_counter_cnt = 0;
|
||||
|
||||
furi_hal_rfid_pins_reset();
|
||||
|
||||
LL_COMP_InitTypeDef COMP_InitStruct = {0};
|
||||
COMP_InitStruct.PowerMode = LL_COMP_POWERMODE_MEDIUMSPEED;
|
||||
COMP_InitStruct.InputPlus = LL_COMP_INPUT_PLUS_IO1;
|
||||
COMP_InitStruct.InputMinus = LL_COMP_INPUT_MINUS_1_2VREFINT;
|
||||
COMP_InitStruct.InputHysteresis = LL_COMP_HYSTERESIS_HIGH;
|
||||
COMP_InitStruct.OutputPolarity = LL_COMP_OUTPUTPOL_NONINVERTED;
|
||||
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);
|
||||
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_20);
|
||||
LL_EXTI_EnableFallingTrig_0_31(LL_EXTI_LINE_20);
|
||||
LL_EXTI_EnableRisingTrig_0_31(LL_EXTI_LINE_20);
|
||||
LL_EXTI_DisableEvent_0_31(LL_EXTI_LINE_20);
|
||||
LL_EXTI_EnableIT_0_31(LL_EXTI_LINE_20);
|
||||
|
||||
NVIC_SetPriority(COMP_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_EnableIRQ(COMP_IRQn);
|
||||
}
|
||||
|
||||
void furi_hal_rfid_pins_reset() {
|
||||
// ibutton bus disable
|
||||
furi_hal_ibutton_pin_reset();
|
||||
|
||||
// pulldown rfid antenna
|
||||
furi_hal_gpio_init(&gpio_rfid_carrier_out, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_write(&gpio_rfid_carrier_out, false);
|
||||
|
||||
// from both sides
|
||||
furi_hal_gpio_init(&gpio_nfc_irq_rfid_pull, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_write(&gpio_nfc_irq_rfid_pull, true);
|
||||
|
||||
furi_hal_gpio_init_simple(&gpio_rfid_carrier, GpioModeAnalog);
|
||||
|
||||
furi_hal_gpio_init(&gpio_rfid_data_in, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
}
|
||||
|
||||
static void furi_hal_rfid_pins_emulate() {
|
||||
// ibutton low
|
||||
furi_hal_ibutton_pin_configure();
|
||||
furi_hal_ibutton_pin_write(false);
|
||||
|
||||
// pull pin to timer out
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_nfc_irq_rfid_pull,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedLow,
|
||||
GpioAltFn1TIM2);
|
||||
|
||||
// pull rfid antenna from carrier side
|
||||
furi_hal_gpio_init(&gpio_rfid_carrier_out, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_write(&gpio_rfid_carrier_out, false);
|
||||
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_rfid_carrier, GpioModeAltFunctionPushPull, GpioPullNo, GpioSpeedLow, GpioAltFn2TIM2);
|
||||
}
|
||||
|
||||
static void furi_hal_rfid_pins_read() {
|
||||
// ibutton low
|
||||
furi_hal_ibutton_pin_configure();
|
||||
furi_hal_ibutton_pin_write(false);
|
||||
|
||||
// dont pull rfid antenna
|
||||
furi_hal_gpio_init(&gpio_nfc_irq_rfid_pull, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_write(&gpio_nfc_irq_rfid_pull, false);
|
||||
|
||||
// carrier pin to timer out
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_rfid_carrier_out,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedLow,
|
||||
GpioAltFn1TIM1);
|
||||
|
||||
// comparator in
|
||||
furi_hal_gpio_init(&gpio_rfid_data_in, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
}
|
||||
|
||||
static void furi_hal_rfid_pins_field() {
|
||||
// ibutton low
|
||||
furi_hal_ibutton_pin_configure();
|
||||
furi_hal_ibutton_pin_write(false);
|
||||
|
||||
// pull pin to timer out
|
||||
furi_hal_gpio_init(&gpio_nfc_irq_rfid_pull, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_write(&gpio_nfc_irq_rfid_pull, false);
|
||||
|
||||
// pull rfid antenna from carrier side
|
||||
furi_hal_gpio_init(&gpio_rfid_carrier_out, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_write(&gpio_rfid_carrier_out, false);
|
||||
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_rfid_carrier, GpioModeAltFunctionPushPull, GpioPullNo, GpioSpeedLow, GpioAltFn2TIM2);
|
||||
}
|
||||
|
||||
void furi_hal_rfid_pin_pull_release() {
|
||||
furi_hal_gpio_write(&gpio_nfc_irq_rfid_pull, true);
|
||||
}
|
||||
|
||||
void furi_hal_rfid_pin_pull_pulldown() {
|
||||
furi_hal_gpio_write(&gpio_nfc_irq_rfid_pull, false);
|
||||
}
|
||||
|
||||
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;
|
||||
LL_TIM_Init(FURI_HAL_RFID_READ_TIMER, &TIM_InitStruct);
|
||||
LL_TIM_DisableARRPreload(FURI_HAL_RFID_READ_TIMER);
|
||||
|
||||
LL_TIM_OC_InitTypeDef TIM_OC_InitStruct = {0};
|
||||
TIM_OC_InitStruct.OCMode = LL_TIM_OCMODE_PWM1;
|
||||
TIM_OC_InitStruct.OCNState = LL_TIM_OCSTATE_ENABLE;
|
||||
TIM_OC_InitStruct.CompareValue = TIM_InitStruct.Autoreload * duty_cycle;
|
||||
LL_TIM_OC_Init(
|
||||
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_continue() {
|
||||
LL_TIM_EnableAllOutputs(FURI_HAL_RFID_READ_TIMER);
|
||||
}
|
||||
|
||||
void furi_hal_rfid_tim_read_pause() {
|
||||
LL_TIM_DisableAllOutputs(FURI_HAL_RFID_READ_TIMER);
|
||||
}
|
||||
|
||||
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);
|
||||
LL_TIM_DisableARRPreload(FURI_HAL_RFID_EMULATE_TIMER);
|
||||
LL_TIM_SetRepetitionCounter(FURI_HAL_RFID_EMULATE_TIMER, 0);
|
||||
|
||||
LL_TIM_SetClockDivision(FURI_HAL_RFID_EMULATE_TIMER, LL_TIM_CLOCKDIVISION_DIV1);
|
||||
LL_TIM_SetClockSource(FURI_HAL_RFID_EMULATE_TIMER, LL_TIM_CLOCKSOURCE_EXT_MODE2);
|
||||
LL_TIM_ConfigETR(
|
||||
FURI_HAL_RFID_EMULATE_TIMER,
|
||||
LL_TIM_ETR_POLARITY_INVERTED,
|
||||
LL_TIM_ETR_PRESCALER_DIV1,
|
||||
LL_TIM_ETR_FILTER_FDIV1);
|
||||
|
||||
LL_TIM_OC_InitTypeDef TIM_OC_InitStruct = {0};
|
||||
TIM_OC_InitStruct.OCMode = LL_TIM_OCMODE_PWM1;
|
||||
TIM_OC_InitStruct.OCState = LL_TIM_OCSTATE_ENABLE;
|
||||
TIM_OC_InitStruct.CompareValue = 1;
|
||||
LL_TIM_OC_Init(
|
||||
FURI_HAL_RFID_EMULATE_TIMER, FURI_HAL_RFID_EMULATE_TIMER_CHANNEL, &TIM_OC_InitStruct);
|
||||
|
||||
LL_TIM_GenerateEvent_UPDATE(FURI_HAL_RFID_EMULATE_TIMER);
|
||||
}
|
||||
|
||||
static void furi_hal_capture_dma_isr(void* context) {
|
||||
UNUSED(context);
|
||||
|
||||
// Channel 3, positive level
|
||||
if(LL_TIM_IsActiveFlag_CC3(RFID_CAPTURE_TIM)) {
|
||||
LL_TIM_ClearFlag_CC3(RFID_CAPTURE_TIM);
|
||||
furi_hal_rfid->read_capture_callback(
|
||||
true, LL_TIM_IC_GetCaptureCH3(RFID_CAPTURE_TIM), furi_hal_rfid->context);
|
||||
}
|
||||
|
||||
// Channel 4, overall level
|
||||
if(LL_TIM_IsActiveFlag_CC4(RFID_CAPTURE_TIM)) {
|
||||
LL_TIM_ClearFlag_CC4(RFID_CAPTURE_TIM);
|
||||
LL_TIM_SetCounter(RFID_CAPTURE_TIM, 0);
|
||||
furi_hal_rfid->read_capture_callback(
|
||||
false, LL_TIM_IC_GetCaptureCH4(RFID_CAPTURE_TIM), furi_hal_rfid->context);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_rfid_tim_read_capture_start(FuriHalRfidReadCaptureCallback callback, void* context) {
|
||||
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;
|
||||
TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
|
||||
TIM_InitStruct.Autoreload = UINT32_MAX;
|
||||
TIM_InitStruct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
|
||||
LL_TIM_Init(RFID_CAPTURE_TIM, &TIM_InitStruct);
|
||||
|
||||
// Timer: advanced
|
||||
LL_TIM_SetClockSource(RFID_CAPTURE_TIM, LL_TIM_CLOCKSOURCE_INTERNAL);
|
||||
LL_TIM_DisableARRPreload(RFID_CAPTURE_TIM);
|
||||
LL_TIM_SetTriggerInput(RFID_CAPTURE_TIM, LL_TIM_TS_TI2FP2);
|
||||
LL_TIM_SetSlaveMode(RFID_CAPTURE_TIM, LL_TIM_SLAVEMODE_DISABLED);
|
||||
LL_TIM_SetTriggerOutput(RFID_CAPTURE_TIM, LL_TIM_TRGO_RESET);
|
||||
LL_TIM_EnableMasterSlaveMode(RFID_CAPTURE_TIM);
|
||||
LL_TIM_DisableDMAReq_TRIG(RFID_CAPTURE_TIM);
|
||||
LL_TIM_DisableIT_TRIG(RFID_CAPTURE_TIM);
|
||||
LL_TIM_SetRemap(RFID_CAPTURE_TIM, LL_TIM_TIM2_TI4_RMP_COMP1);
|
||||
|
||||
// Timer: channel 3 indirect
|
||||
LL_TIM_IC_SetActiveInput(RFID_CAPTURE_TIM, RFID_CAPTURE_IND_CH, LL_TIM_ACTIVEINPUT_INDIRECTTI);
|
||||
LL_TIM_IC_SetPrescaler(RFID_CAPTURE_TIM, RFID_CAPTURE_IND_CH, LL_TIM_ICPSC_DIV1);
|
||||
LL_TIM_IC_SetPolarity(RFID_CAPTURE_TIM, RFID_CAPTURE_IND_CH, LL_TIM_IC_POLARITY_FALLING);
|
||||
LL_TIM_IC_SetFilter(RFID_CAPTURE_TIM, RFID_CAPTURE_IND_CH, LL_TIM_IC_FILTER_FDIV1);
|
||||
|
||||
// Timer: channel 4 direct
|
||||
LL_TIM_IC_SetActiveInput(RFID_CAPTURE_TIM, RFID_CAPTURE_DIR_CH, LL_TIM_ACTIVEINPUT_DIRECTTI);
|
||||
LL_TIM_IC_SetPrescaler(RFID_CAPTURE_TIM, RFID_CAPTURE_DIR_CH, LL_TIM_ICPSC_DIV1);
|
||||
LL_TIM_IC_SetPolarity(RFID_CAPTURE_TIM, RFID_CAPTURE_DIR_CH, LL_TIM_IC_POLARITY_RISING);
|
||||
LL_TIM_IC_SetFilter(RFID_CAPTURE_TIM, RFID_CAPTURE_DIR_CH, LL_TIM_IC_FILTER_FDIV1);
|
||||
|
||||
furi_hal_interrupt_set_isr(FURI_HAL_RFID_EMULATE_TIMER_IRQ, furi_hal_capture_dma_isr, NULL);
|
||||
|
||||
LL_TIM_EnableIT_CC3(RFID_CAPTURE_TIM);
|
||||
LL_TIM_EnableIT_CC4(RFID_CAPTURE_TIM);
|
||||
LL_TIM_CC_EnableChannel(RFID_CAPTURE_TIM, RFID_CAPTURE_IND_CH);
|
||||
LL_TIM_CC_EnableChannel(RFID_CAPTURE_TIM, RFID_CAPTURE_DIR_CH);
|
||||
LL_TIM_SetCounter(RFID_CAPTURE_TIM, 0);
|
||||
LL_TIM_EnableCounter(RFID_CAPTURE_TIM);
|
||||
|
||||
furi_hal_rfid_comp_start();
|
||||
}
|
||||
|
||||
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_hal_bus_disable(RFID_CAPTURE_TIM_BUS);
|
||||
}
|
||||
|
||||
static void furi_hal_rfid_dma_isr() {
|
||||
#if RFID_DMA_CH1_CHANNEL == LL_DMA_CHANNEL_1
|
||||
if(LL_DMA_IsActiveFlag_HT1(RFID_DMA)) {
|
||||
LL_DMA_ClearFlag_HT1(RFID_DMA);
|
||||
furi_hal_rfid->dma_callback(true, furi_hal_rfid->context);
|
||||
}
|
||||
|
||||
if(LL_DMA_IsActiveFlag_TC1(RFID_DMA)) {
|
||||
LL_DMA_ClearFlag_TC1(RFID_DMA);
|
||||
furi_hal_rfid->dma_callback(false, furi_hal_rfid->context);
|
||||
}
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
}
|
||||
|
||||
void furi_hal_rfid_tim_emulate_dma_start(
|
||||
uint32_t* duration,
|
||||
uint32_t* pulse,
|
||||
size_t length,
|
||||
FuriHalRfidDMACallback callback,
|
||||
void* context) {
|
||||
furi_assert(furi_hal_rfid);
|
||||
|
||||
// setup interrupts
|
||||
furi_hal_rfid->dma_callback = callback;
|
||||
furi_hal_rfid->context = context;
|
||||
|
||||
// setup pins
|
||||
furi_hal_rfid_pins_emulate();
|
||||
|
||||
// configure timer
|
||||
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);
|
||||
|
||||
// configure DMA "mem -> ARR" channel
|
||||
LL_DMA_InitTypeDef dma_config = {0};
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (FURI_HAL_RFID_EMULATE_TIMER->ARR);
|
||||
dma_config.MemoryOrM2MDstAddress = (uint32_t)duration;
|
||||
dma_config.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
||||
dma_config.Mode = LL_DMA_MODE_CIRCULAR;
|
||||
dma_config.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
||||
dma_config.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
||||
dma_config.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
|
||||
dma_config.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
|
||||
dma_config.NbData = length;
|
||||
dma_config.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
|
||||
dma_config.Priority = LL_DMA_MODE_NORMAL;
|
||||
LL_DMA_Init(RFID_DMA_CH1_DEF, &dma_config);
|
||||
LL_DMA_EnableChannel(RFID_DMA_CH1_DEF);
|
||||
|
||||
// configure DMA "mem -> CCR3" channel
|
||||
#if FURI_HAL_RFID_EMULATE_TIMER_CHANNEL == LL_TIM_CHANNEL_CH3
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (FURI_HAL_RFID_EMULATE_TIMER->CCR3);
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
dma_config.MemoryOrM2MDstAddress = (uint32_t)pulse;
|
||||
dma_config.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
||||
dma_config.Mode = LL_DMA_MODE_CIRCULAR;
|
||||
dma_config.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
||||
dma_config.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
||||
dma_config.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
|
||||
dma_config.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
|
||||
dma_config.NbData = length;
|
||||
dma_config.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
|
||||
dma_config.Priority = LL_DMA_MODE_NORMAL;
|
||||
LL_DMA_Init(RFID_DMA_CH2_DEF, &dma_config);
|
||||
LL_DMA_EnableChannel(RFID_DMA_CH2_DEF);
|
||||
|
||||
// attach interrupt to one of DMA channels
|
||||
furi_hal_interrupt_set_isr(RFID_DMA_CH1_IRQ, furi_hal_rfid_dma_isr, NULL);
|
||||
LL_DMA_EnableIT_TC(RFID_DMA_CH1_DEF);
|
||||
LL_DMA_EnableIT_HT(RFID_DMA_CH1_DEF);
|
||||
|
||||
// start
|
||||
LL_TIM_EnableAllOutputs(FURI_HAL_RFID_EMULATE_TIMER);
|
||||
|
||||
LL_TIM_SetCounter(FURI_HAL_RFID_EMULATE_TIMER, 0);
|
||||
LL_TIM_EnableCounter(FURI_HAL_RFID_EMULATE_TIMER);
|
||||
}
|
||||
|
||||
void furi_hal_rfid_tim_emulate_dma_stop() {
|
||||
LL_TIM_DisableCounter(FURI_HAL_RFID_EMULATE_TIMER);
|
||||
LL_TIM_DisableAllOutputs(FURI_HAL_RFID_EMULATE_TIMER);
|
||||
|
||||
furi_hal_interrupt_set_isr(RFID_DMA_CH1_IRQ, NULL, NULL);
|
||||
LL_DMA_DisableIT_TC(RFID_DMA_CH1_DEF);
|
||||
LL_DMA_DisableIT_HT(RFID_DMA_CH1_DEF);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
|
||||
LL_DMA_DeInit(RFID_DMA_CH1_DEF);
|
||||
LL_DMA_DeInit(RFID_DMA_CH2_DEF);
|
||||
|
||||
furi_hal_bus_disable(FURI_HAL_RFID_EMULATE_TIMER_BUS);
|
||||
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_rfid_set_read_period(uint32_t period) {
|
||||
LL_TIM_SetAutoReload(FURI_HAL_RFID_READ_TIMER, period);
|
||||
}
|
||||
|
||||
void furi_hal_rfid_set_read_pulse(uint32_t pulse) {
|
||||
#if FURI_HAL_RFID_READ_TIMER_CHANNEL == LL_TIM_CHANNEL_CH1N
|
||||
LL_TIM_OC_SetCompareCH1(FURI_HAL_RFID_READ_TIMER, pulse);
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
}
|
||||
|
||||
void furi_hal_rfid_comp_start() {
|
||||
LL_COMP_Enable(COMP1);
|
||||
// Magic
|
||||
uint32_t wait_loop_index = ((80 / 10UL) * ((SystemCoreClock / (100000UL * 2UL)) + 1UL));
|
||||
while(wait_loop_index) {
|
||||
wait_loop_index--;
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_rfid_comp_stop() {
|
||||
LL_COMP_Disable(COMP1);
|
||||
}
|
||||
|
||||
FuriHalRfidCompCallback furi_hal_rfid_comp_callback = NULL;
|
||||
void* furi_hal_rfid_comp_callback_context = NULL;
|
||||
|
||||
void furi_hal_rfid_comp_set_callback(FuriHalRfidCompCallback callback, void* context) {
|
||||
FURI_CRITICAL_ENTER();
|
||||
furi_hal_rfid_comp_callback = callback;
|
||||
furi_hal_rfid_comp_callback_context = context;
|
||||
__DMB();
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
/* Comparator trigger event */
|
||||
void COMP_IRQHandler() {
|
||||
if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_20)) {
|
||||
LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_20);
|
||||
}
|
||||
if(furi_hal_rfid_comp_callback) {
|
||||
furi_hal_rfid_comp_callback(
|
||||
(LL_COMP_ReadOutputLevel(COMP1) == LL_COMP_OUTPUT_LEVEL_LOW),
|
||||
furi_hal_rfid_comp_callback_context);
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_rfid_field_tim_setup() {
|
||||
// setup timer counter
|
||||
furi_hal_bus_enable(FURI_HAL_RFID_FIELD_COUNTER_TIMER_BUS);
|
||||
|
||||
LL_TIM_SetPrescaler(FURI_HAL_RFID_FIELD_COUNTER_TIMER, 0);
|
||||
LL_TIM_SetCounterMode(FURI_HAL_RFID_FIELD_COUNTER_TIMER, LL_TIM_COUNTERMODE_UP);
|
||||
LL_TIM_SetAutoReload(FURI_HAL_RFID_FIELD_COUNTER_TIMER, 0xFFFFFFFF);
|
||||
LL_TIM_DisableARRPreload(FURI_HAL_RFID_FIELD_COUNTER_TIMER);
|
||||
LL_TIM_SetRepetitionCounter(FURI_HAL_RFID_FIELD_COUNTER_TIMER, 0);
|
||||
|
||||
LL_TIM_SetClockDivision(FURI_HAL_RFID_FIELD_COUNTER_TIMER, LL_TIM_CLOCKDIVISION_DIV1);
|
||||
LL_TIM_SetClockSource(FURI_HAL_RFID_FIELD_COUNTER_TIMER, LL_TIM_CLOCKSOURCE_EXT_MODE2);
|
||||
LL_TIM_ConfigETR(
|
||||
FURI_HAL_RFID_FIELD_COUNTER_TIMER,
|
||||
LL_TIM_ETR_POLARITY_INVERTED,
|
||||
LL_TIM_ETR_PRESCALER_DIV1,
|
||||
LL_TIM_ETR_FILTER_FDIV1);
|
||||
|
||||
LL_TIM_OC_InitTypeDef TIM_OC_InitStruct = {0};
|
||||
TIM_OC_InitStruct.OCMode = LL_TIM_OCMODE_PWM1;
|
||||
TIM_OC_InitStruct.OCState = LL_TIM_OCSTATE_ENABLE;
|
||||
TIM_OC_InitStruct.CompareValue = 1;
|
||||
LL_TIM_OC_Init(
|
||||
FURI_HAL_RFID_FIELD_COUNTER_TIMER,
|
||||
FURI_HAL_RFID_FIELD_COUNTER_TIMER_CHANNEL,
|
||||
&TIM_OC_InitStruct);
|
||||
|
||||
LL_TIM_GenerateEvent_UPDATE(FURI_HAL_RFID_FIELD_COUNTER_TIMER);
|
||||
LL_TIM_OC_SetPolarity(
|
||||
FURI_HAL_RFID_FIELD_COUNTER_TIMER,
|
||||
FURI_HAL_RFID_FIELD_COUNTER_TIMER_CHANNEL,
|
||||
LL_TIM_OCPOLARITY_HIGH);
|
||||
LL_TIM_EnableDMAReq_UPDATE(FURI_HAL_RFID_FIELD_COUNTER_TIMER);
|
||||
|
||||
// setup timer timeouts dma
|
||||
furi_hal_bus_enable(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER_BUS);
|
||||
|
||||
LL_TIM_SetPrescaler(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER, 64000 - 1);
|
||||
LL_TIM_SetCounterMode(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER, LL_TIM_COUNTERMODE_UP);
|
||||
LL_TIM_SetAutoReload(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER, 100 - 1); // 100 ms
|
||||
LL_TIM_SetClockDivision(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER, LL_TIM_CLOCKDIVISION_DIV1);
|
||||
LL_TIM_SetClockSource(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER, LL_TIM_CLOCKSOURCE_INTERNAL);
|
||||
|
||||
LL_TIM_DisableARRPreload(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER);
|
||||
|
||||
LL_TIM_EnableDMAReq_UPDATE(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER);
|
||||
LL_TIM_GenerateEvent_UPDATE(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER);
|
||||
}
|
||||
|
||||
void furi_hal_rfid_field_detect_start(void) {
|
||||
// setup pins
|
||||
furi_hal_rfid_pins_field();
|
||||
|
||||
// configure timer
|
||||
furi_hal_rfid_field_tim_setup();
|
||||
|
||||
// configure DMA "TIM_COUNTER_CNT -> counter"
|
||||
LL_DMA_SetMemoryAddress(RFID_DMA_CH1_DEF, (uint32_t) & (furi_hal_rfid->field.counter));
|
||||
LL_DMA_SetPeriphAddress(
|
||||
RFID_DMA_CH1_DEF, (uint32_t) & (FURI_HAL_RFID_FIELD_COUNTER_TIMER->CNT));
|
||||
LL_DMA_ConfigTransfer(
|
||||
RFID_DMA_CH1_DEF,
|
||||
LL_DMA_DIRECTION_PERIPH_TO_MEMORY | LL_DMA_MODE_CIRCULAR | LL_DMA_PERIPH_NOINCREMENT |
|
||||
LL_DMA_MEMORY_NOINCREMENT | LL_DMA_PDATAALIGN_WORD | LL_DMA_MDATAALIGN_WORD |
|
||||
LL_DMA_PRIORITY_MEDIUM);
|
||||
LL_DMA_SetDataLength(RFID_DMA_CH1_DEF, 1);
|
||||
LL_DMA_SetPeriphRequest(RFID_DMA_CH1_DEF, FURI_HAL_RFID_FIELD_DMAMUX_DMA);
|
||||
LL_DMA_EnableChannel(RFID_DMA_CH1_DEF);
|
||||
|
||||
// configure DMA "mem -> TIM_COUNTER_CNT"
|
||||
LL_DMA_SetMemoryAddress(
|
||||
RFID_DMA_CH2_DEF, (uint32_t) & (furi_hal_rfid->field.set_tim_counter_cnt));
|
||||
LL_DMA_SetPeriphAddress(
|
||||
RFID_DMA_CH2_DEF, (uint32_t) & (FURI_HAL_RFID_FIELD_COUNTER_TIMER->CNT));
|
||||
LL_DMA_ConfigTransfer(
|
||||
RFID_DMA_CH2_DEF,
|
||||
LL_DMA_DIRECTION_MEMORY_TO_PERIPH | LL_DMA_MODE_CIRCULAR | LL_DMA_PERIPH_NOINCREMENT |
|
||||
LL_DMA_MEMORY_NOINCREMENT | LL_DMA_PDATAALIGN_WORD | LL_DMA_MDATAALIGN_WORD |
|
||||
LL_DMA_PRIORITY_LOW);
|
||||
LL_DMA_SetDataLength(RFID_DMA_CH2_DEF, 1);
|
||||
LL_DMA_SetPeriphRequest(RFID_DMA_CH2_DEF, FURI_HAL_RFID_FIELD_DMAMUX_DMA);
|
||||
LL_DMA_EnableChannel(RFID_DMA_CH2_DEF);
|
||||
|
||||
// start tim counter
|
||||
LL_TIM_EnableAllOutputs(FURI_HAL_RFID_FIELD_COUNTER_TIMER);
|
||||
|
||||
LL_TIM_SetCounter(FURI_HAL_RFID_FIELD_COUNTER_TIMER, 0);
|
||||
LL_TIM_EnableCounter(FURI_HAL_RFID_FIELD_COUNTER_TIMER);
|
||||
|
||||
// start tim timeout
|
||||
LL_TIM_SetCounter(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER, 0);
|
||||
LL_TIM_EnableCounter(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER);
|
||||
LL_TIM_EnableIT_UPDATE(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER);
|
||||
}
|
||||
|
||||
void furi_hal_rfid_field_detect_stop(void) {
|
||||
LL_TIM_DisableCounter(FURI_HAL_RFID_FIELD_COUNTER_TIMER);
|
||||
LL_TIM_DisableAllOutputs(FURI_HAL_RFID_FIELD_COUNTER_TIMER);
|
||||
|
||||
LL_TIM_DisableCounter(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
|
||||
LL_DMA_DeInit(RFID_DMA_CH1_DEF);
|
||||
LL_DMA_DeInit(RFID_DMA_CH2_DEF);
|
||||
|
||||
furi_hal_bus_disable(FURI_HAL_RFID_FIELD_COUNTER_TIMER_BUS);
|
||||
furi_hal_bus_disable(FURI_HAL_RFID_FIELD_TIMEOUT_TIMER_BUS);
|
||||
|
||||
furi_hal_rfid_pins_reset();
|
||||
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
bool furi_hal_rfid_field_is_present(uint32_t* frequency) {
|
||||
*frequency = furi_hal_rfid->field.counter * 10;
|
||||
return (
|
||||
(*frequency >= FURI_HAL_RFID_FIELD_FREQUENCY_MIN) &&
|
||||
(*frequency <= FURI_HAL_RFID_FIELD_FREQUENCY_MAX));
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
/**
|
||||
* @file furi_hal_rfid.h
|
||||
* RFID HAL API
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** Initialize RFID subsystem
|
||||
*/
|
||||
void furi_hal_rfid_init();
|
||||
|
||||
/** Config rfid pins to reset state
|
||||
*/
|
||||
void furi_hal_rfid_pins_reset();
|
||||
|
||||
/** Release rfid pull pin
|
||||
*/
|
||||
void furi_hal_rfid_pin_pull_release();
|
||||
|
||||
/** Pulldown rfid pull pin
|
||||
*/
|
||||
void furi_hal_rfid_pin_pull_pulldown();
|
||||
|
||||
/** Start read timer
|
||||
* @param freq timer frequency
|
||||
* @param duty_cycle timer duty cycle, 0.0-1.0
|
||||
*/
|
||||
void furi_hal_rfid_tim_read_start(float freq, float duty_cycle);
|
||||
|
||||
/** Pause read timer, to be able to continue later
|
||||
*/
|
||||
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();
|
||||
|
||||
typedef void (*FuriHalRfidReadCaptureCallback)(bool level, uint32_t duration, void* context);
|
||||
|
||||
void furi_hal_rfid_tim_read_capture_start(FuriHalRfidReadCaptureCallback callback, void* context);
|
||||
|
||||
void furi_hal_rfid_tim_read_capture_stop();
|
||||
|
||||
typedef void (*FuriHalRfidDMACallback)(bool half, void* context);
|
||||
|
||||
void furi_hal_rfid_tim_emulate_dma_start(
|
||||
uint32_t* duration,
|
||||
uint32_t* pulse,
|
||||
size_t length,
|
||||
FuriHalRfidDMACallback callback,
|
||||
void* context);
|
||||
|
||||
void furi_hal_rfid_tim_emulate_dma_stop();
|
||||
|
||||
/** Set read timer period
|
||||
*
|
||||
* @param period overall duration
|
||||
*/
|
||||
void furi_hal_rfid_set_read_period(uint32_t period);
|
||||
|
||||
/** Set read timer pulse
|
||||
*
|
||||
* @param pulse duration of high level
|
||||
*/
|
||||
void furi_hal_rfid_set_read_pulse(uint32_t pulse);
|
||||
|
||||
/** Start/Enable comparator */
|
||||
void furi_hal_rfid_comp_start();
|
||||
|
||||
/** Stop/Disable comparator */
|
||||
void furi_hal_rfid_comp_stop();
|
||||
|
||||
typedef void (*FuriHalRfidCompCallback)(bool level, void* context);
|
||||
|
||||
/** Set comparator callback */
|
||||
void furi_hal_rfid_comp_set_callback(FuriHalRfidCompCallback callback, void* context);
|
||||
|
||||
/** Start/Enable Field Presence detect */
|
||||
void furi_hal_rfid_field_detect_start();
|
||||
|
||||
/** Stop/Disable Field Presence detect */
|
||||
void furi_hal_rfid_field_detect_stop();
|
||||
|
||||
/** Check Field Presence
|
||||
*
|
||||
* @param[out] frequency pointer to frequency value to be set if filed detected
|
||||
*
|
||||
* @return true if field is present, false if not
|
||||
*/
|
||||
bool furi_hal_rfid_field_is_present(uint32_t* frequency);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,431 @@
|
||||
#include <furi_hal_rtc.h>
|
||||
#include <furi_hal_light.h>
|
||||
#include <furi_hal_debug.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>
|
||||
|
||||
#include <furi.h>
|
||||
|
||||
#define TAG "FuriHalRtc"
|
||||
|
||||
#define FURI_HAL_RTC_LSE_STARTUP_TIME 300
|
||||
|
||||
#define FURI_HAL_RTC_CLOCK_IS_READY() (LL_RCC_LSE_IsReady() && LL_RCC_LSI1_IsReady())
|
||||
|
||||
#define FURI_HAL_RTC_HEADER_MAGIC 0x10F1
|
||||
#define FURI_HAL_RTC_HEADER_VERSION 0
|
||||
|
||||
typedef struct {
|
||||
uint16_t magic;
|
||||
uint8_t version;
|
||||
uint8_t unused;
|
||||
} FuriHalRtcHeader;
|
||||
|
||||
typedef struct {
|
||||
uint8_t log_level : 4;
|
||||
uint8_t log_reserved : 4;
|
||||
uint8_t flags;
|
||||
FuriHalRtcBootMode boot_mode : 4;
|
||||
FuriHalRtcHeapTrackMode heap_track_mode : 2;
|
||||
FuriHalRtcLocaleUnits locale_units : 1;
|
||||
FuriHalRtcLocaleTimeFormat locale_timeformat : 1;
|
||||
FuriHalRtcLocaleDateFormat locale_dateformat : 2;
|
||||
uint8_t reserved : 6;
|
||||
} SystemReg;
|
||||
|
||||
_Static_assert(sizeof(SystemReg) == 4, "SystemReg size mismatch");
|
||||
|
||||
#define FURI_HAL_RTC_SECONDS_PER_MINUTE 60
|
||||
#define FURI_HAL_RTC_SECONDS_PER_HOUR (FURI_HAL_RTC_SECONDS_PER_MINUTE * 60)
|
||||
#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
|
||||
|
||||
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}};
|
||||
|
||||
static const uint16_t furi_hal_rtc_days_per_year[] = {365, 366};
|
||||
|
||||
static void furi_hal_rtc_reset() {
|
||||
LL_RCC_ForceBackupDomainReset();
|
||||
LL_RCC_ReleaseBackupDomainReset();
|
||||
}
|
||||
|
||||
static bool furi_hal_rtc_start_clock_and_switch() {
|
||||
// Clock operation require access to Backup Domain
|
||||
LL_PWR_EnableBkUpAccess();
|
||||
|
||||
// Enable LSI and LSE
|
||||
LL_RCC_LSI1_Enable();
|
||||
LL_RCC_LSE_SetDriveCapability(LL_RCC_LSEDRIVE_HIGH);
|
||||
LL_RCC_LSE_Enable();
|
||||
|
||||
// Wait for LSI and LSE startup
|
||||
uint32_t c = 0;
|
||||
while(!FURI_HAL_RTC_CLOCK_IS_READY() && c < FURI_HAL_RTC_LSE_STARTUP_TIME) {
|
||||
LL_mDelay(1);
|
||||
c++;
|
||||
}
|
||||
|
||||
if(FURI_HAL_RTC_CLOCK_IS_READY()) {
|
||||
LL_RCC_SetRTCClockSource(LL_RCC_RTC_CLKSOURCE_LSE);
|
||||
LL_RCC_EnableRTC();
|
||||
return LL_RCC_GetRTCClockSource() == LL_RCC_RTC_CLKSOURCE_LSE;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_rtc_recover() {
|
||||
FuriHalRtcDateTime datetime = {0};
|
||||
|
||||
// Handle fixable LSE failure
|
||||
if(LL_RCC_LSE_IsCSSDetected()) {
|
||||
furi_hal_light_sequence("rgb B");
|
||||
// Shutdown LSE and LSECSS
|
||||
LL_RCC_LSE_DisableCSS();
|
||||
LL_RCC_LSE_Disable();
|
||||
} else {
|
||||
furi_hal_light_sequence("rgb R");
|
||||
}
|
||||
|
||||
// Temporary switch to LSI
|
||||
LL_RCC_SetRTCClockSource(LL_RCC_RTC_CLKSOURCE_LSI);
|
||||
if(LL_RCC_GetRTCClockSource() == LL_RCC_RTC_CLKSOURCE_LSI) {
|
||||
// Get datetime before RTC Domain reset
|
||||
furi_hal_rtc_get_datetime(&datetime);
|
||||
}
|
||||
|
||||
// Reset RTC Domain
|
||||
furi_hal_rtc_reset();
|
||||
|
||||
// Start Clock
|
||||
if(!furi_hal_rtc_start_clock_and_switch()) {
|
||||
// Plan C: reset RTC and restart
|
||||
furi_hal_light_sequence("rgb R.r.R.r.R.r");
|
||||
furi_hal_rtc_reset();
|
||||
NVIC_SystemReset();
|
||||
}
|
||||
|
||||
// Set date if it valid
|
||||
if(datetime.year != 0) {
|
||||
furi_hal_rtc_set_datetime(&datetime);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_rtc_init_early() {
|
||||
// Enable RTCAPB clock
|
||||
LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_RTCAPB);
|
||||
|
||||
// Prepare clock
|
||||
if(!furi_hal_rtc_start_clock_and_switch()) {
|
||||
// Plan B: try to recover
|
||||
furi_hal_rtc_recover();
|
||||
}
|
||||
|
||||
// Verify header register
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterHeader);
|
||||
FuriHalRtcHeader* data = (FuriHalRtcHeader*)&data_reg;
|
||||
if(data->magic != FURI_HAL_RTC_HEADER_MAGIC || data->version != FURI_HAL_RTC_HEADER_VERSION) {
|
||||
// Reset all our registers to ensure consistency
|
||||
for(size_t i = 0; i < FuriHalRtcRegisterMAX; i++) {
|
||||
furi_hal_rtc_set_register(i, 0);
|
||||
}
|
||||
data->magic = FURI_HAL_RTC_HEADER_MAGIC;
|
||||
data->version = FURI_HAL_RTC_HEADER_VERSION;
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterHeader, data_reg);
|
||||
}
|
||||
|
||||
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
|
||||
furi_hal_debug_enable();
|
||||
} else {
|
||||
furi_hal_debug_disable();
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_rtc_deinit_early() {
|
||||
}
|
||||
|
||||
void furi_hal_rtc_init() {
|
||||
LL_RTC_InitTypeDef RTC_InitStruct;
|
||||
RTC_InitStruct.HourFormat = LL_RTC_HOURFORMAT_24HOUR;
|
||||
RTC_InitStruct.AsynchPrescaler = 127;
|
||||
RTC_InitStruct.SynchPrescaler = 255;
|
||||
LL_RTC_Init(RTC, &RTC_InitStruct);
|
||||
|
||||
furi_log_set_level(furi_hal_rtc_get_log_level());
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
void furi_hal_rtc_sync_shadow() {
|
||||
if(!LL_RTC_IsShadowRegBypassEnabled(RTC)) {
|
||||
LL_RTC_ClearFlag_RS(RTC);
|
||||
while(!LL_RTC_IsActiveFlag_RS(RTC)) {
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t furi_hal_rtc_get_register(FuriHalRtcRegister reg) {
|
||||
return LL_RTC_BAK_GetRegister(RTC, reg);
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_register(FuriHalRtcRegister reg, uint32_t value) {
|
||||
LL_RTC_BAK_SetRegister(RTC, reg, value);
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_log_level(uint8_t level) {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
data->log_level = level;
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterSystem, data_reg);
|
||||
furi_log_set_level(level);
|
||||
}
|
||||
|
||||
uint8_t furi_hal_rtc_get_log_level() {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
return data->log_level;
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_flag(FuriHalRtcFlag flag) {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
data->flags |= flag;
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterSystem, data_reg);
|
||||
|
||||
if(flag & FuriHalRtcFlagDebug) {
|
||||
furi_hal_debug_enable();
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_rtc_reset_flag(FuriHalRtcFlag flag) {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
data->flags &= ~flag;
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterSystem, data_reg);
|
||||
|
||||
if(flag & FuriHalRtcFlagDebug) {
|
||||
furi_hal_debug_disable();
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_rtc_is_flag_set(FuriHalRtcFlag flag) {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
return data->flags & flag;
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_boot_mode(FuriHalRtcBootMode mode) {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
data->boot_mode = mode;
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterSystem, data_reg);
|
||||
}
|
||||
|
||||
FuriHalRtcBootMode furi_hal_rtc_get_boot_mode() {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
return data->boot_mode;
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_heap_track_mode(FuriHalRtcHeapTrackMode mode) {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
data->heap_track_mode = mode;
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterSystem, data_reg);
|
||||
}
|
||||
|
||||
FuriHalRtcHeapTrackMode furi_hal_rtc_get_heap_track_mode() {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
return data->heap_track_mode;
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_locale_units(FuriHalRtcLocaleUnits value) {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
data->locale_units = value;
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterSystem, data_reg);
|
||||
}
|
||||
|
||||
FuriHalRtcLocaleUnits furi_hal_rtc_get_locale_units() {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
return data->locale_units;
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_locale_timeformat(FuriHalRtcLocaleTimeFormat value) {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
data->locale_timeformat = value;
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterSystem, data_reg);
|
||||
}
|
||||
|
||||
FuriHalRtcLocaleTimeFormat furi_hal_rtc_get_locale_timeformat() {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
return data->locale_timeformat;
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_locale_dateformat(FuriHalRtcLocaleDateFormat value) {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
data->locale_dateformat = value;
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterSystem, data_reg);
|
||||
}
|
||||
|
||||
FuriHalRtcLocaleDateFormat furi_hal_rtc_get_locale_dateformat() {
|
||||
uint32_t data_reg = furi_hal_rtc_get_register(FuriHalRtcRegisterSystem);
|
||||
SystemReg* data = (SystemReg*)&data_reg;
|
||||
return data->locale_dateformat;
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_datetime(FuriHalRtcDateTime* datetime) {
|
||||
furi_check(!FURI_IS_IRQ_MODE());
|
||||
furi_assert(datetime);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
/* Disable write protection */
|
||||
LL_RTC_DisableWriteProtection(RTC);
|
||||
|
||||
/* Enter Initialization mode and wait for INIT flag to be set */
|
||||
LL_RTC_EnableInitMode(RTC);
|
||||
while(!LL_RTC_IsActiveFlag_INIT(RTC)) {
|
||||
}
|
||||
|
||||
/* Set time */
|
||||
LL_RTC_TIME_Config(
|
||||
RTC,
|
||||
LL_RTC_TIME_FORMAT_AM_OR_24,
|
||||
__LL_RTC_CONVERT_BIN2BCD(datetime->hour),
|
||||
__LL_RTC_CONVERT_BIN2BCD(datetime->minute),
|
||||
__LL_RTC_CONVERT_BIN2BCD(datetime->second));
|
||||
|
||||
/* Set date */
|
||||
LL_RTC_DATE_Config(
|
||||
RTC,
|
||||
datetime->weekday,
|
||||
__LL_RTC_CONVERT_BIN2BCD(datetime->day),
|
||||
__LL_RTC_CONVERT_BIN2BCD(datetime->month),
|
||||
__LL_RTC_CONVERT_BIN2BCD(datetime->year - 2000));
|
||||
|
||||
/* Exit Initialization mode */
|
||||
LL_RTC_DisableInitMode(RTC);
|
||||
|
||||
furi_hal_rtc_sync_shadow();
|
||||
|
||||
/* Enable write protection */
|
||||
LL_RTC_EnableWriteProtection(RTC);
|
||||
FURI_CRITICAL_EXIT();
|
||||
}
|
||||
|
||||
void furi_hal_rtc_get_datetime(FuriHalRtcDateTime* datetime) {
|
||||
furi_check(!FURI_IS_IRQ_MODE());
|
||||
furi_assert(datetime);
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
uint32_t time = LL_RTC_TIME_Get(RTC); // 0x00HHMMSS
|
||||
uint32_t date = LL_RTC_DATE_Get(RTC); // 0xWWDDMMYY
|
||||
FURI_CRITICAL_EXIT();
|
||||
|
||||
datetime->second = __LL_RTC_CONVERT_BCD2BIN((time >> 0) & 0xFF);
|
||||
datetime->minute = __LL_RTC_CONVERT_BCD2BIN((time >> 8) & 0xFF);
|
||||
datetime->hour = __LL_RTC_CONVERT_BCD2BIN((time >> 16) & 0xFF);
|
||||
datetime->year = __LL_RTC_CONVERT_BCD2BIN((date >> 0) & 0xFF) + 2000;
|
||||
datetime->month = __LL_RTC_CONVERT_BCD2BIN((date >> 8) & 0xFF);
|
||||
datetime->day = __LL_RTC_CONVERT_BCD2BIN((date >> 16) & 0xFF);
|
||||
datetime->weekday = __LL_RTC_CONVERT_BCD2BIN((date >> 24) & 0xFF);
|
||||
}
|
||||
|
||||
bool furi_hal_rtc_validate_datetime(FuriHalRtcDateTime* datetime) {
|
||||
bool invalid = false;
|
||||
|
||||
invalid |= (datetime->second > 59);
|
||||
invalid |= (datetime->minute > 59);
|
||||
invalid |= (datetime->hour > 23);
|
||||
|
||||
invalid |= (datetime->year < 2000);
|
||||
invalid |= (datetime->year > 2099);
|
||||
|
||||
invalid |= (datetime->month == 0);
|
||||
invalid |= (datetime->month > 12);
|
||||
|
||||
invalid |= (datetime->day == 0);
|
||||
invalid |= (datetime->day > 31);
|
||||
|
||||
invalid |= (datetime->weekday == 0);
|
||||
invalid |= (datetime->weekday > 7);
|
||||
|
||||
return !invalid;
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_fault_data(uint32_t value) {
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterFaultData, value);
|
||||
}
|
||||
|
||||
uint32_t furi_hal_rtc_get_fault_data() {
|
||||
return furi_hal_rtc_get_register(FuriHalRtcRegisterFaultData);
|
||||
}
|
||||
|
||||
void furi_hal_rtc_set_pin_fails(uint32_t value) {
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterPinFails, value);
|
||||
}
|
||||
|
||||
uint32_t furi_hal_rtc_get_pin_fails() {
|
||||
return furi_hal_rtc_get_register(FuriHalRtcRegisterPinFails);
|
||||
}
|
||||
|
||||
uint32_t furi_hal_rtc_get_timestamp() {
|
||||
FuriHalRtcDateTime datetime = {0};
|
||||
furi_hal_rtc_get_datetime(&datetime);
|
||||
return furi_hal_rtc_datetime_to_timestamp(&datetime);
|
||||
}
|
||||
|
||||
uint32_t furi_hal_rtc_datetime_to_timestamp(FuriHalRtcDateTime* datetime) {
|
||||
uint32_t timestamp = 0;
|
||||
uint8_t years = 0;
|
||||
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)) {
|
||||
leap_years++;
|
||||
} else {
|
||||
years++;
|
||||
}
|
||||
}
|
||||
|
||||
timestamp +=
|
||||
((years * furi_hal_rtc_days_per_year[0]) + (leap_years * furi_hal_rtc_days_per_year[1])) *
|
||||
FURI_HAL_RTC_SECONDS_PER_DAY;
|
||||
|
||||
bool leap_year = furi_hal_rtc_is_leap_year(datetime->year);
|
||||
|
||||
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;
|
||||
timestamp += datetime->hour * FURI_HAL_RTC_SECONDS_PER_HOUR;
|
||||
timestamp += datetime->minute * FURI_HAL_RTC_SECONDS_PER_MINUTE;
|
||||
timestamp += datetime->second;
|
||||
|
||||
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];
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,139 @@
|
||||
#include <furi_hal_speaker.h>
|
||||
#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>
|
||||
|
||||
#define TAG "FuriHalSpeaker"
|
||||
|
||||
#define FURI_HAL_SPEAKER_TIMER TIM16
|
||||
#define FURI_HAL_SPEAKER_CHANNEL LL_TIM_CHANNEL_CH1
|
||||
#define FURI_HAL_SPEAKER_PRESCALER 500
|
||||
#define FURI_HAL_SPEAKER_MAX_VOLUME 60
|
||||
|
||||
static FuriMutex* furi_hal_speaker_mutex = NULL;
|
||||
|
||||
// #define FURI_HAL_SPEAKER_NEW_VOLUME
|
||||
|
||||
void furi_hal_speaker_init() {
|
||||
furi_assert(furi_hal_speaker_mutex == NULL);
|
||||
furi_hal_speaker_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
void furi_hal_speaker_deinit() {
|
||||
furi_check(furi_hal_speaker_mutex != NULL);
|
||||
furi_mutex_free(furi_hal_speaker_mutex);
|
||||
furi_hal_speaker_mutex = NULL;
|
||||
}
|
||||
|
||||
bool furi_hal_speaker_acquire(uint32_t timeout) {
|
||||
furi_check(!FURI_IS_IRQ_MODE());
|
||||
|
||||
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;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_speaker_release() {
|
||||
furi_check(!FURI_IS_IRQ_MODE());
|
||||
furi_check(furi_hal_speaker_is_mine());
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
bool furi_hal_speaker_is_mine() {
|
||||
return (FURI_IS_IRQ_MODE()) ||
|
||||
(furi_mutex_get_owner(furi_hal_speaker_mutex) == furi_thread_get_current_id());
|
||||
}
|
||||
|
||||
static inline uint32_t furi_hal_speaker_calculate_autoreload(float frequency) {
|
||||
uint32_t autoreload = (SystemCoreClock / FURI_HAL_SPEAKER_PRESCALER / frequency) - 1;
|
||||
if(autoreload < 2) {
|
||||
autoreload = 2;
|
||||
} else if(autoreload > UINT16_MAX) {
|
||||
autoreload = UINT16_MAX;
|
||||
}
|
||||
|
||||
return autoreload;
|
||||
}
|
||||
|
||||
static inline uint32_t furi_hal_speaker_calculate_compare(float volume) {
|
||||
if(volume < 0) volume = 0;
|
||||
if(volume > 1) volume = 1;
|
||||
volume = volume * volume * volume;
|
||||
|
||||
#ifdef FURI_HAL_SPEAKER_NEW_VOLUME
|
||||
uint32_t compare_value = volume * FURI_HAL_SPEAKER_MAX_VOLUME;
|
||||
uint32_t clip_value = volume * LL_TIM_GetAutoReload(FURI_HAL_SPEAKER_TIMER) / 2;
|
||||
if(compare_value > clip_value) {
|
||||
compare_value = clip_value;
|
||||
}
|
||||
#else
|
||||
uint32_t compare_value = volume * LL_TIM_GetAutoReload(FURI_HAL_SPEAKER_TIMER) / 2;
|
||||
#endif
|
||||
|
||||
if(compare_value == 0) {
|
||||
compare_value = 1;
|
||||
}
|
||||
|
||||
return compare_value;
|
||||
}
|
||||
|
||||
void furi_hal_speaker_start(float frequency, float volume) {
|
||||
furi_check(furi_hal_speaker_is_mine());
|
||||
|
||||
if(volume <= 0) {
|
||||
furi_hal_speaker_stop();
|
||||
return;
|
||||
}
|
||||
|
||||
LL_TIM_InitTypeDef TIM_InitStruct = {0};
|
||||
TIM_InitStruct.Prescaler = FURI_HAL_SPEAKER_PRESCALER - 1;
|
||||
TIM_InitStruct.Autoreload = furi_hal_speaker_calculate_autoreload(frequency);
|
||||
LL_TIM_Init(FURI_HAL_SPEAKER_TIMER, &TIM_InitStruct);
|
||||
|
||||
LL_TIM_OC_InitTypeDef TIM_OC_InitStruct = {0};
|
||||
TIM_OC_InitStruct.OCMode = LL_TIM_OCMODE_PWM1;
|
||||
TIM_OC_InitStruct.OCState = LL_TIM_OCSTATE_ENABLE;
|
||||
TIM_OC_InitStruct.CompareValue = furi_hal_speaker_calculate_compare(volume);
|
||||
LL_TIM_OC_Init(FURI_HAL_SPEAKER_TIMER, FURI_HAL_SPEAKER_CHANNEL, &TIM_OC_InitStruct);
|
||||
|
||||
LL_TIM_EnableAllOutputs(FURI_HAL_SPEAKER_TIMER);
|
||||
LL_TIM_EnableCounter(FURI_HAL_SPEAKER_TIMER);
|
||||
}
|
||||
|
||||
void furi_hal_speaker_set_volume(float volume) {
|
||||
furi_check(furi_hal_speaker_is_mine());
|
||||
if(volume <= 0) {
|
||||
furi_hal_speaker_stop();
|
||||
return;
|
||||
}
|
||||
|
||||
#if FURI_HAL_SPEAKER_CHANNEL == LL_TIM_CHANNEL_CH1
|
||||
LL_TIM_OC_SetCompareCH1(FURI_HAL_SPEAKER_TIMER, furi_hal_speaker_calculate_compare(volume));
|
||||
#else
|
||||
#error Invalid channel
|
||||
#endif
|
||||
}
|
||||
|
||||
void furi_hal_speaker_stop() {
|
||||
furi_check(furi_hal_speaker_is_mine());
|
||||
LL_TIM_DisableAllOutputs(FURI_HAL_SPEAKER_TIMER);
|
||||
LL_TIM_DisableCounter(FURI_HAL_SPEAKER_TIMER);
|
||||
}
|
||||
@@ -0,0 +1,376 @@
|
||||
#include <furi.h>
|
||||
#include <furi_hal_spi.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_power.h>
|
||||
#include <furi_hal_interrupt.h>
|
||||
|
||||
#include <stm32wbxx_ll_dma.h>
|
||||
#include <stm32wbxx_ll_spi.h>
|
||||
#include <stm32wbxx_ll_utils.h>
|
||||
#include <stm32wbxx_ll_cortex.h>
|
||||
|
||||
#define TAG "FuriHalSpi"
|
||||
|
||||
#define SPI_DMA DMA2
|
||||
#define SPI_DMA_RX_CHANNEL LL_DMA_CHANNEL_6
|
||||
#define SPI_DMA_TX_CHANNEL LL_DMA_CHANNEL_7
|
||||
#define SPI_DMA_RX_IRQ FuriHalInterruptIdDma2Ch6
|
||||
#define SPI_DMA_TX_IRQ FuriHalInterruptIdDma2Ch7
|
||||
#define SPI_DMA_RX_DEF SPI_DMA, SPI_DMA_RX_CHANNEL
|
||||
#define SPI_DMA_TX_DEF SPI_DMA, SPI_DMA_TX_CHANNEL
|
||||
|
||||
// For simplicity, I assume that only one SPI DMA transaction can occur at a time.
|
||||
static FuriSemaphore* spi_dma_lock = NULL;
|
||||
static FuriSemaphore* spi_dma_completed = NULL;
|
||||
|
||||
void furi_hal_spi_dma_init() {
|
||||
spi_dma_lock = furi_semaphore_alloc(1, 1);
|
||||
spi_dma_completed = furi_semaphore_alloc(1, 1);
|
||||
}
|
||||
|
||||
void furi_hal_spi_bus_init(FuriHalSpiBus* bus) {
|
||||
furi_assert(bus);
|
||||
bus->callback(bus, FuriHalSpiBusEventInit);
|
||||
}
|
||||
|
||||
void furi_hal_spi_bus_deinit(FuriHalSpiBus* bus) {
|
||||
furi_assert(bus);
|
||||
bus->callback(bus, FuriHalSpiBusEventDeinit);
|
||||
}
|
||||
|
||||
void furi_hal_spi_bus_handle_init(FuriHalSpiBusHandle* handle) {
|
||||
furi_assert(handle);
|
||||
handle->callback(handle, FuriHalSpiBusHandleEventInit);
|
||||
}
|
||||
|
||||
void furi_hal_spi_bus_handle_deinit(FuriHalSpiBusHandle* handle) {
|
||||
furi_assert(handle);
|
||||
handle->callback(handle, FuriHalSpiBusHandleEventDeinit);
|
||||
}
|
||||
|
||||
void furi_hal_spi_acquire(FuriHalSpiBusHandle* handle) {
|
||||
furi_assert(handle);
|
||||
|
||||
furi_hal_power_insomnia_enter();
|
||||
|
||||
handle->bus->callback(handle->bus, FuriHalSpiBusEventLock);
|
||||
handle->bus->callback(handle->bus, FuriHalSpiBusEventActivate);
|
||||
|
||||
furi_assert(handle->bus->current_handle == NULL);
|
||||
|
||||
handle->bus->current_handle = handle;
|
||||
handle->callback(handle, FuriHalSpiBusHandleEventActivate);
|
||||
}
|
||||
|
||||
void furi_hal_spi_release(FuriHalSpiBusHandle* handle) {
|
||||
furi_assert(handle);
|
||||
furi_assert(handle->bus->current_handle == handle);
|
||||
|
||||
// Handle event and unset handle
|
||||
handle->callback(handle, FuriHalSpiBusHandleEventDeactivate);
|
||||
handle->bus->current_handle = NULL;
|
||||
|
||||
// Bus events
|
||||
handle->bus->callback(handle->bus, FuriHalSpiBusEventDeactivate);
|
||||
handle->bus->callback(handle->bus, FuriHalSpiBusEventUnlock);
|
||||
|
||||
furi_hal_power_insomnia_exit();
|
||||
}
|
||||
|
||||
static void furi_hal_spi_bus_end_txrx(FuriHalSpiBusHandle* handle, uint32_t timeout) {
|
||||
UNUSED(timeout); // FIXME
|
||||
while(LL_SPI_GetTxFIFOLevel(handle->bus->spi) != LL_SPI_TX_FIFO_EMPTY)
|
||||
;
|
||||
while(LL_SPI_IsActiveFlag_BSY(handle->bus->spi))
|
||||
;
|
||||
while(LL_SPI_GetRxFIFOLevel(handle->bus->spi) != LL_SPI_RX_FIFO_EMPTY) {
|
||||
LL_SPI_ReceiveData8(handle->bus->spi);
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_spi_bus_rx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
uint8_t* buffer,
|
||||
size_t size,
|
||||
uint32_t timeout) {
|
||||
furi_assert(handle);
|
||||
furi_assert(handle->bus->current_handle == handle);
|
||||
furi_assert(buffer);
|
||||
furi_assert(size > 0);
|
||||
|
||||
return furi_hal_spi_bus_trx(handle, buffer, buffer, size, timeout);
|
||||
}
|
||||
|
||||
bool furi_hal_spi_bus_tx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
const uint8_t* buffer,
|
||||
size_t size,
|
||||
uint32_t timeout) {
|
||||
furi_assert(handle);
|
||||
furi_assert(handle->bus->current_handle == handle);
|
||||
furi_assert(buffer);
|
||||
furi_assert(size > 0);
|
||||
bool ret = true;
|
||||
|
||||
while(size > 0) {
|
||||
if(LL_SPI_IsActiveFlag_TXE(handle->bus->spi)) {
|
||||
LL_SPI_TransmitData8(handle->bus->spi, *buffer);
|
||||
buffer++;
|
||||
size--;
|
||||
}
|
||||
}
|
||||
|
||||
furi_hal_spi_bus_end_txrx(handle, timeout);
|
||||
LL_SPI_ClearFlag_OVR(handle->bus->spi);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool furi_hal_spi_bus_trx(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
const uint8_t* tx_buffer,
|
||||
uint8_t* rx_buffer,
|
||||
size_t size,
|
||||
uint32_t timeout) {
|
||||
furi_assert(handle);
|
||||
furi_assert(handle->bus->current_handle == handle);
|
||||
furi_assert(size > 0);
|
||||
|
||||
bool ret = true;
|
||||
size_t tx_size = size;
|
||||
bool tx_allowed = true;
|
||||
|
||||
while(size > 0) {
|
||||
if(tx_size > 0 && LL_SPI_IsActiveFlag_TXE(handle->bus->spi) && tx_allowed) {
|
||||
if(tx_buffer) {
|
||||
LL_SPI_TransmitData8(handle->bus->spi, *tx_buffer);
|
||||
tx_buffer++;
|
||||
} else {
|
||||
LL_SPI_TransmitData8(handle->bus->spi, 0xFF);
|
||||
}
|
||||
tx_size--;
|
||||
tx_allowed = false;
|
||||
}
|
||||
|
||||
if(LL_SPI_IsActiveFlag_RXNE(handle->bus->spi)) {
|
||||
if(rx_buffer) {
|
||||
*rx_buffer = LL_SPI_ReceiveData8(handle->bus->spi);
|
||||
rx_buffer++;
|
||||
} else {
|
||||
LL_SPI_ReceiveData8(handle->bus->spi);
|
||||
}
|
||||
size--;
|
||||
tx_allowed = true;
|
||||
}
|
||||
}
|
||||
|
||||
furi_hal_spi_bus_end_txrx(handle, timeout);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void spi_dma_isr() {
|
||||
#if SPI_DMA_RX_CHANNEL == LL_DMA_CHANNEL_6
|
||||
if(LL_DMA_IsActiveFlag_TC6(SPI_DMA) && LL_DMA_IsEnabledIT_TC(SPI_DMA_RX_DEF)) {
|
||||
LL_DMA_ClearFlag_TC6(SPI_DMA);
|
||||
furi_check(furi_semaphore_release(spi_dma_completed) == FuriStatusOk);
|
||||
}
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
|
||||
#if SPI_DMA_TX_CHANNEL == LL_DMA_CHANNEL_7
|
||||
if(LL_DMA_IsActiveFlag_TC7(SPI_DMA) && LL_DMA_IsEnabledIT_TC(SPI_DMA_TX_DEF)) {
|
||||
LL_DMA_ClearFlag_TC7(SPI_DMA);
|
||||
furi_check(furi_semaphore_release(spi_dma_completed) == FuriStatusOk);
|
||||
}
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
}
|
||||
|
||||
bool furi_hal_spi_bus_trx_dma(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
uint8_t* tx_buffer,
|
||||
uint8_t* rx_buffer,
|
||||
size_t size,
|
||||
uint32_t timeout_ms) {
|
||||
furi_assert(handle);
|
||||
furi_assert(handle->bus->current_handle == handle);
|
||||
furi_assert(size > 0);
|
||||
|
||||
// If scheduler is not running, use blocking mode
|
||||
if(xTaskGetSchedulerState() != taskSCHEDULER_RUNNING) {
|
||||
return furi_hal_spi_bus_trx(handle, tx_buffer, rx_buffer, size, timeout_ms);
|
||||
}
|
||||
|
||||
// Lock DMA
|
||||
furi_check(furi_semaphore_acquire(spi_dma_lock, FuriWaitForever) == FuriStatusOk);
|
||||
|
||||
const uint32_t dma_dummy_u32 = 0xFFFFFFFF;
|
||||
|
||||
bool ret = true;
|
||||
SPI_TypeDef* spi = handle->bus->spi;
|
||||
uint32_t dma_rx_req;
|
||||
uint32_t dma_tx_req;
|
||||
|
||||
if(spi == SPI1) {
|
||||
dma_rx_req = LL_DMAMUX_REQ_SPI1_RX;
|
||||
dma_tx_req = LL_DMAMUX_REQ_SPI1_TX;
|
||||
} else if(spi == SPI2) {
|
||||
dma_rx_req = LL_DMAMUX_REQ_SPI2_RX;
|
||||
dma_tx_req = LL_DMAMUX_REQ_SPI2_TX;
|
||||
} else {
|
||||
furi_crash(NULL);
|
||||
}
|
||||
|
||||
if(rx_buffer == NULL) {
|
||||
// Only TX mode, do not use RX channel
|
||||
|
||||
LL_DMA_InitTypeDef dma_config = {0};
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (spi->DR);
|
||||
dma_config.MemoryOrM2MDstAddress = (uint32_t)tx_buffer;
|
||||
dma_config.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
||||
dma_config.Mode = LL_DMA_MODE_NORMAL;
|
||||
dma_config.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
||||
dma_config.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
||||
dma_config.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_BYTE;
|
||||
dma_config.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_BYTE;
|
||||
dma_config.NbData = size;
|
||||
dma_config.PeriphRequest = dma_tx_req;
|
||||
dma_config.Priority = LL_DMA_PRIORITY_MEDIUM;
|
||||
LL_DMA_Init(SPI_DMA_TX_DEF, &dma_config);
|
||||
|
||||
#if SPI_DMA_TX_CHANNEL == LL_DMA_CHANNEL_7
|
||||
LL_DMA_ClearFlag_TC7(SPI_DMA);
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
|
||||
furi_hal_interrupt_set_isr(SPI_DMA_TX_IRQ, spi_dma_isr, NULL);
|
||||
|
||||
bool dma_tx_was_enabled = LL_SPI_IsEnabledDMAReq_TX(spi);
|
||||
if(!dma_tx_was_enabled) {
|
||||
LL_SPI_EnableDMAReq_TX(spi);
|
||||
}
|
||||
|
||||
// acquire semaphore before enabling DMA
|
||||
furi_check(furi_semaphore_acquire(spi_dma_completed, timeout_ms) == FuriStatusOk);
|
||||
|
||||
LL_DMA_EnableIT_TC(SPI_DMA_TX_DEF);
|
||||
LL_DMA_EnableChannel(SPI_DMA_TX_DEF);
|
||||
|
||||
// and wait for it to be released (DMA transfer complete)
|
||||
if(furi_semaphore_acquire(spi_dma_completed, timeout_ms) != FuriStatusOk) {
|
||||
ret = false;
|
||||
FURI_LOG_E(TAG, "DMA timeout\r\n");
|
||||
}
|
||||
// release semaphore, because we are using it as a flag
|
||||
furi_semaphore_release(spi_dma_completed);
|
||||
|
||||
LL_DMA_DisableIT_TC(SPI_DMA_TX_DEF);
|
||||
LL_DMA_DisableChannel(SPI_DMA_TX_DEF);
|
||||
if(!dma_tx_was_enabled) {
|
||||
LL_SPI_DisableDMAReq_TX(spi);
|
||||
}
|
||||
furi_hal_interrupt_set_isr(SPI_DMA_TX_IRQ, NULL, NULL);
|
||||
|
||||
LL_DMA_DeInit(SPI_DMA_TX_DEF);
|
||||
} else {
|
||||
// TRX or RX mode, use both channels
|
||||
uint32_t tx_mem_increase_mode;
|
||||
|
||||
if(tx_buffer == NULL) {
|
||||
// RX mode, use dummy data instead of TX buffer
|
||||
tx_buffer = (uint8_t*)&dma_dummy_u32;
|
||||
tx_mem_increase_mode = LL_DMA_MEMORY_NOINCREMENT;
|
||||
} else {
|
||||
tx_mem_increase_mode = LL_DMA_MEMORY_INCREMENT;
|
||||
}
|
||||
|
||||
LL_DMA_InitTypeDef dma_config = {0};
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (spi->DR);
|
||||
dma_config.MemoryOrM2MDstAddress = (uint32_t)tx_buffer;
|
||||
dma_config.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
||||
dma_config.Mode = LL_DMA_MODE_NORMAL;
|
||||
dma_config.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
||||
dma_config.MemoryOrM2MDstIncMode = tx_mem_increase_mode;
|
||||
dma_config.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_BYTE;
|
||||
dma_config.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_BYTE;
|
||||
dma_config.NbData = size;
|
||||
dma_config.PeriphRequest = dma_tx_req;
|
||||
dma_config.Priority = LL_DMA_PRIORITY_MEDIUM;
|
||||
LL_DMA_Init(SPI_DMA_TX_DEF, &dma_config);
|
||||
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (spi->DR);
|
||||
dma_config.MemoryOrM2MDstAddress = (uint32_t)rx_buffer;
|
||||
dma_config.Direction = LL_DMA_DIRECTION_PERIPH_TO_MEMORY;
|
||||
dma_config.Mode = LL_DMA_MODE_NORMAL;
|
||||
dma_config.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
||||
dma_config.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
||||
dma_config.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_BYTE;
|
||||
dma_config.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_BYTE;
|
||||
dma_config.NbData = size;
|
||||
dma_config.PeriphRequest = dma_rx_req;
|
||||
dma_config.Priority = LL_DMA_PRIORITY_MEDIUM;
|
||||
LL_DMA_Init(SPI_DMA_RX_DEF, &dma_config);
|
||||
|
||||
#if SPI_DMA_RX_CHANNEL == LL_DMA_CHANNEL_6
|
||||
LL_DMA_ClearFlag_TC6(SPI_DMA);
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
|
||||
furi_hal_interrupt_set_isr(SPI_DMA_RX_IRQ, spi_dma_isr, NULL);
|
||||
|
||||
bool dma_tx_was_enabled = LL_SPI_IsEnabledDMAReq_TX(spi);
|
||||
bool dma_rx_was_enabled = LL_SPI_IsEnabledDMAReq_RX(spi);
|
||||
|
||||
if(!dma_tx_was_enabled) {
|
||||
LL_SPI_EnableDMAReq_TX(spi);
|
||||
}
|
||||
|
||||
if(!dma_rx_was_enabled) {
|
||||
LL_SPI_EnableDMAReq_RX(spi);
|
||||
}
|
||||
|
||||
// acquire semaphore before enabling DMA
|
||||
furi_check(furi_semaphore_acquire(spi_dma_completed, timeout_ms) == FuriStatusOk);
|
||||
|
||||
LL_DMA_EnableIT_TC(SPI_DMA_RX_DEF);
|
||||
LL_DMA_EnableChannel(SPI_DMA_RX_DEF);
|
||||
LL_DMA_EnableChannel(SPI_DMA_TX_DEF);
|
||||
|
||||
// and wait for it to be released (DMA transfer complete)
|
||||
if(furi_semaphore_acquire(spi_dma_completed, timeout_ms) != FuriStatusOk) {
|
||||
ret = false;
|
||||
FURI_LOG_E(TAG, "DMA timeout\r\n");
|
||||
}
|
||||
// release semaphore, because we are using it as a flag
|
||||
furi_semaphore_release(spi_dma_completed);
|
||||
|
||||
LL_DMA_DisableIT_TC(SPI_DMA_RX_DEF);
|
||||
|
||||
LL_DMA_DisableChannel(SPI_DMA_TX_DEF);
|
||||
LL_DMA_DisableChannel(SPI_DMA_RX_DEF);
|
||||
|
||||
if(!dma_tx_was_enabled) {
|
||||
LL_SPI_DisableDMAReq_TX(spi);
|
||||
}
|
||||
|
||||
if(!dma_rx_was_enabled) {
|
||||
LL_SPI_DisableDMAReq_RX(spi);
|
||||
}
|
||||
|
||||
furi_hal_interrupt_set_isr(SPI_DMA_RX_IRQ, NULL, NULL);
|
||||
|
||||
LL_DMA_DeInit(SPI_DMA_TX_DEF);
|
||||
LL_DMA_DeInit(SPI_DMA_RX_DEF);
|
||||
}
|
||||
|
||||
furi_hal_spi_bus_end_txrx(handle, timeout_ms);
|
||||
|
||||
furi_check(furi_semaphore_release(spi_dma_lock) == FuriStatusOk);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,437 @@
|
||||
#include <furi_hal_spi_config.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_spi.h>
|
||||
#include <furi_hal_bus.h>
|
||||
#include <furi.h>
|
||||
|
||||
#define TAG "FuriHalSpiConfig"
|
||||
|
||||
/* SPI Presets */
|
||||
|
||||
const LL_SPI_InitTypeDef furi_hal_spi_preset_2edge_low_8m = {
|
||||
.Mode = LL_SPI_MODE_MASTER,
|
||||
.TransferDirection = LL_SPI_FULL_DUPLEX,
|
||||
.DataWidth = LL_SPI_DATAWIDTH_8BIT,
|
||||
.ClockPolarity = LL_SPI_POLARITY_LOW,
|
||||
.ClockPhase = LL_SPI_PHASE_2EDGE,
|
||||
.NSS = LL_SPI_NSS_SOFT,
|
||||
.BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV8,
|
||||
.BitOrder = LL_SPI_MSB_FIRST,
|
||||
.CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE,
|
||||
.CRCPoly = 7,
|
||||
};
|
||||
|
||||
const LL_SPI_InitTypeDef furi_hal_spi_preset_1edge_low_8m = {
|
||||
.Mode = LL_SPI_MODE_MASTER,
|
||||
.TransferDirection = LL_SPI_FULL_DUPLEX,
|
||||
.DataWidth = LL_SPI_DATAWIDTH_8BIT,
|
||||
.ClockPolarity = LL_SPI_POLARITY_LOW,
|
||||
.ClockPhase = LL_SPI_PHASE_1EDGE,
|
||||
.NSS = LL_SPI_NSS_SOFT,
|
||||
.BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV8,
|
||||
.BitOrder = LL_SPI_MSB_FIRST,
|
||||
.CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE,
|
||||
.CRCPoly = 7,
|
||||
};
|
||||
|
||||
const LL_SPI_InitTypeDef furi_hal_spi_preset_1edge_low_4m = {
|
||||
.Mode = LL_SPI_MODE_MASTER,
|
||||
.TransferDirection = LL_SPI_FULL_DUPLEX,
|
||||
.DataWidth = LL_SPI_DATAWIDTH_8BIT,
|
||||
.ClockPolarity = LL_SPI_POLARITY_LOW,
|
||||
.ClockPhase = LL_SPI_PHASE_1EDGE,
|
||||
.NSS = LL_SPI_NSS_SOFT,
|
||||
.BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV16,
|
||||
.BitOrder = LL_SPI_MSB_FIRST,
|
||||
.CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE,
|
||||
.CRCPoly = 7,
|
||||
};
|
||||
|
||||
const LL_SPI_InitTypeDef furi_hal_spi_preset_1edge_low_16m = {
|
||||
.Mode = LL_SPI_MODE_MASTER,
|
||||
.TransferDirection = LL_SPI_FULL_DUPLEX,
|
||||
.DataWidth = LL_SPI_DATAWIDTH_8BIT,
|
||||
.ClockPolarity = LL_SPI_POLARITY_LOW,
|
||||
.ClockPhase = LL_SPI_PHASE_1EDGE,
|
||||
.NSS = LL_SPI_NSS_SOFT,
|
||||
.BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV2,
|
||||
.BitOrder = LL_SPI_MSB_FIRST,
|
||||
.CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE,
|
||||
.CRCPoly = 7,
|
||||
};
|
||||
|
||||
const LL_SPI_InitTypeDef furi_hal_spi_preset_1edge_low_2m = {
|
||||
.Mode = LL_SPI_MODE_MASTER,
|
||||
.TransferDirection = LL_SPI_FULL_DUPLEX,
|
||||
.DataWidth = LL_SPI_DATAWIDTH_8BIT,
|
||||
.ClockPolarity = LL_SPI_POLARITY_LOW,
|
||||
.ClockPhase = LL_SPI_PHASE_1EDGE,
|
||||
.NSS = LL_SPI_NSS_SOFT,
|
||||
.BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV32,
|
||||
.BitOrder = LL_SPI_MSB_FIRST,
|
||||
.CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE,
|
||||
.CRCPoly = 7,
|
||||
};
|
||||
|
||||
/* SPI Buses */
|
||||
|
||||
FuriMutex* furi_hal_spi_bus_r_mutex = NULL;
|
||||
|
||||
void furi_hal_spi_config_init_early() {
|
||||
furi_hal_spi_bus_init(&furi_hal_spi_bus_d);
|
||||
furi_hal_spi_bus_handle_init(&furi_hal_spi_bus_handle_display);
|
||||
}
|
||||
|
||||
void furi_hal_spi_config_deinit_early() {
|
||||
furi_hal_spi_bus_handle_deinit(&furi_hal_spi_bus_handle_display);
|
||||
furi_hal_spi_bus_deinit(&furi_hal_spi_bus_d);
|
||||
}
|
||||
|
||||
void furi_hal_spi_config_init() {
|
||||
furi_hal_spi_bus_init(&furi_hal_spi_bus_r);
|
||||
|
||||
furi_hal_spi_bus_handle_init(&furi_hal_spi_bus_handle_subghz);
|
||||
furi_hal_spi_bus_handle_init(&furi_hal_spi_bus_handle_nfc);
|
||||
furi_hal_spi_bus_handle_init(&furi_hal_spi_bus_handle_sd_fast);
|
||||
furi_hal_spi_bus_handle_init(&furi_hal_spi_bus_handle_sd_slow);
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
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);
|
||||
bus->current_handle = NULL;
|
||||
} else if(event == FuriHalSpiBusEventDeinit) {
|
||||
furi_mutex_free(furi_hal_spi_bus_r_mutex);
|
||||
} 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_hal_bus_enable(FuriHalBusSPI1);
|
||||
} else if(event == FuriHalSpiBusEventDeactivate) {
|
||||
furi_hal_bus_disable(FuriHalBusSPI1);
|
||||
}
|
||||
}
|
||||
|
||||
FuriHalSpiBus furi_hal_spi_bus_r = {
|
||||
.spi = SPI1,
|
||||
.callback = furi_hal_spi_bus_r_event_callback,
|
||||
};
|
||||
|
||||
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);
|
||||
bus->current_handle = NULL;
|
||||
} else if(event == FuriHalSpiBusEventDeinit) {
|
||||
furi_mutex_free(furi_hal_spi_bus_d_mutex);
|
||||
} 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_hal_bus_enable(FuriHalBusSPI2);
|
||||
} else if(event == FuriHalSpiBusEventDeactivate) {
|
||||
furi_hal_bus_disable(FuriHalBusSPI2);
|
||||
}
|
||||
}
|
||||
|
||||
FuriHalSpiBus furi_hal_spi_bus_d = {
|
||||
.spi = SPI2,
|
||||
.callback = furi_hal_spi_bus_d_event_callback,
|
||||
};
|
||||
|
||||
/* SPI Bus Handles */
|
||||
|
||||
inline static void furi_hal_spi_bus_r_handle_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event,
|
||||
const LL_SPI_InitTypeDef* preset) {
|
||||
if(event == FuriHalSpiBusHandleEventInit) {
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
furi_hal_gpio_init(handle->cs, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
|
||||
} else if(event == FuriHalSpiBusHandleEventDeinit) {
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
furi_hal_gpio_init(handle->cs, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
} else if(event == FuriHalSpiBusHandleEventActivate) {
|
||||
LL_SPI_Init(handle->bus->spi, (LL_SPI_InitTypeDef*)preset);
|
||||
LL_SPI_SetRxFIFOThreshold(handle->bus->spi, LL_SPI_RX_FIFO_TH_QUARTER);
|
||||
LL_SPI_Enable(handle->bus->spi);
|
||||
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->miso,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->mosi,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->sck,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
|
||||
furi_hal_gpio_write(handle->cs, false);
|
||||
} else if(event == FuriHalSpiBusHandleEventDeactivate) {
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
|
||||
furi_hal_gpio_init(handle->miso, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_init(handle->mosi, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_init(handle->sck, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
LL_SPI_Disable(handle->bus->spi);
|
||||
}
|
||||
}
|
||||
|
||||
inline static void furi_hal_spi_bus_external_handle_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event,
|
||||
const LL_SPI_InitTypeDef* preset) {
|
||||
if(event == FuriHalSpiBusHandleEventInit) {
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
furi_hal_gpio_init(handle->cs, GpioModeOutputPushPull, GpioPullUp, GpioSpeedVeryHigh);
|
||||
} else if(event == FuriHalSpiBusHandleEventDeinit) {
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
furi_hal_gpio_init(handle->cs, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
} else if(event == FuriHalSpiBusHandleEventActivate) {
|
||||
LL_SPI_Init(handle->bus->spi, (LL_SPI_InitTypeDef*)preset);
|
||||
LL_SPI_SetRxFIFOThreshold(handle->bus->spi, LL_SPI_RX_FIFO_TH_QUARTER);
|
||||
LL_SPI_Enable(handle->bus->spi);
|
||||
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->miso,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullDown,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->mosi,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullDown,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->sck,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullDown,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
|
||||
furi_hal_gpio_write(handle->cs, false);
|
||||
} else if(event == FuriHalSpiBusHandleEventDeactivate) {
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
|
||||
furi_hal_gpio_init(handle->miso, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_init(handle->mosi, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_init(handle->sck, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
LL_SPI_Disable(handle->bus->spi);
|
||||
}
|
||||
}
|
||||
|
||||
inline static void furi_hal_spi_bus_nfc_handle_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event,
|
||||
const LL_SPI_InitTypeDef* preset) {
|
||||
if(event == FuriHalSpiBusHandleEventInit) {
|
||||
// Configure GPIOs in normal SPI mode
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->miso,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->mosi,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->sck,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
furi_hal_gpio_init(handle->cs, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
|
||||
} else if(event == FuriHalSpiBusHandleEventDeinit) {
|
||||
// Configure GPIOs for st25r3916 Transparent mode
|
||||
furi_hal_gpio_init(handle->sck, GpioModeInput, GpioPullUp, GpioSpeedLow);
|
||||
furi_hal_gpio_init(handle->miso, GpioModeInput, GpioPullUp, GpioSpeedLow);
|
||||
furi_hal_gpio_init(handle->cs, GpioModeInput, GpioPullUp, GpioSpeedLow);
|
||||
furi_hal_gpio_write(handle->mosi, false);
|
||||
furi_hal_gpio_init(handle->mosi, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
|
||||
} else if(event == FuriHalSpiBusHandleEventActivate) {
|
||||
LL_SPI_Init(handle->bus->spi, (LL_SPI_InitTypeDef*)preset);
|
||||
LL_SPI_SetRxFIFOThreshold(handle->bus->spi, LL_SPI_RX_FIFO_TH_QUARTER);
|
||||
LL_SPI_Enable(handle->bus->spi);
|
||||
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->miso,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->mosi,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->sck,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI1);
|
||||
|
||||
} else if(event == FuriHalSpiBusHandleEventDeactivate) {
|
||||
furi_hal_gpio_init(handle->miso, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_init(handle->mosi, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_init(handle->sck, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
LL_SPI_Disable(handle->bus->spi);
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_spi_bus_handle_subghz_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event) {
|
||||
furi_hal_spi_bus_r_handle_event_callback(handle, event, &furi_hal_spi_preset_1edge_low_8m);
|
||||
}
|
||||
|
||||
FuriHalSpiBusHandle furi_hal_spi_bus_handle_subghz = {
|
||||
.bus = &furi_hal_spi_bus_r,
|
||||
.callback = furi_hal_spi_bus_handle_subghz_event_callback,
|
||||
.miso = &gpio_spi_r_miso,
|
||||
.mosi = &gpio_spi_r_mosi,
|
||||
.sck = &gpio_spi_r_sck,
|
||||
.cs = &gpio_subghz_cs,
|
||||
};
|
||||
|
||||
static void furi_hal_spi_bus_handle_nfc_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event) {
|
||||
furi_hal_spi_bus_nfc_handle_event_callback(handle, event, &furi_hal_spi_preset_2edge_low_8m);
|
||||
}
|
||||
|
||||
FuriHalSpiBusHandle furi_hal_spi_bus_handle_nfc = {
|
||||
.bus = &furi_hal_spi_bus_r,
|
||||
.callback = furi_hal_spi_bus_handle_nfc_event_callback,
|
||||
.miso = &gpio_spi_r_miso,
|
||||
.mosi = &gpio_spi_r_mosi,
|
||||
.sck = &gpio_spi_r_sck,
|
||||
.cs = &gpio_nfc_cs,
|
||||
};
|
||||
|
||||
static void furi_hal_spi_bus_handle_external_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event) {
|
||||
furi_hal_spi_bus_external_handle_event_callback(
|
||||
handle, event, &furi_hal_spi_preset_1edge_low_2m);
|
||||
}
|
||||
|
||||
FuriHalSpiBusHandle furi_hal_spi_bus_handle_external = {
|
||||
.bus = &furi_hal_spi_bus_r,
|
||||
.callback = furi_hal_spi_bus_handle_external_event_callback,
|
||||
.miso = &gpio_ext_pa6,
|
||||
.mosi = &gpio_ext_pa7,
|
||||
.sck = &gpio_ext_pb3,
|
||||
.cs = &gpio_ext_pa4,
|
||||
};
|
||||
|
||||
inline static void furi_hal_spi_bus_d_handle_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event,
|
||||
const LL_SPI_InitTypeDef* preset) {
|
||||
if(event == FuriHalSpiBusHandleEventInit) {
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
furi_hal_gpio_init(handle->cs, GpioModeOutputPushPull, GpioPullUp, GpioSpeedVeryHigh);
|
||||
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->miso,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI2);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->mosi,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI2);
|
||||
furi_hal_gpio_init_ex(
|
||||
handle->sck,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn5SPI2);
|
||||
|
||||
} else if(event == FuriHalSpiBusHandleEventDeinit) {
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
furi_hal_gpio_init(handle->cs, GpioModeAnalog, GpioPullUp, GpioSpeedLow);
|
||||
} else if(event == FuriHalSpiBusHandleEventActivate) {
|
||||
LL_SPI_Init(handle->bus->spi, (LL_SPI_InitTypeDef*)preset);
|
||||
LL_SPI_SetRxFIFOThreshold(handle->bus->spi, LL_SPI_RX_FIFO_TH_QUARTER);
|
||||
LL_SPI_Enable(handle->bus->spi);
|
||||
furi_hal_gpio_write(handle->cs, false);
|
||||
} else if(event == FuriHalSpiBusHandleEventDeactivate) {
|
||||
furi_hal_gpio_write(handle->cs, true);
|
||||
LL_SPI_Disable(handle->bus->spi);
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_spi_bus_handle_display_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event) {
|
||||
furi_hal_spi_bus_d_handle_event_callback(handle, event, &furi_hal_spi_preset_1edge_low_4m);
|
||||
}
|
||||
|
||||
FuriHalSpiBusHandle furi_hal_spi_bus_handle_display = {
|
||||
.bus = &furi_hal_spi_bus_d,
|
||||
.callback = furi_hal_spi_bus_handle_display_event_callback,
|
||||
.miso = &gpio_spi_d_miso,
|
||||
.mosi = &gpio_spi_d_mosi,
|
||||
.sck = &gpio_spi_d_sck,
|
||||
.cs = &gpio_display_cs,
|
||||
};
|
||||
|
||||
static void furi_hal_spi_bus_handle_sd_fast_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event) {
|
||||
furi_hal_spi_bus_d_handle_event_callback(handle, event, &furi_hal_spi_preset_1edge_low_16m);
|
||||
}
|
||||
|
||||
FuriHalSpiBusHandle furi_hal_spi_bus_handle_sd_fast = {
|
||||
.bus = &furi_hal_spi_bus_d,
|
||||
.callback = furi_hal_spi_bus_handle_sd_fast_event_callback,
|
||||
.miso = &gpio_spi_d_miso,
|
||||
.mosi = &gpio_spi_d_mosi,
|
||||
.sck = &gpio_spi_d_sck,
|
||||
.cs = &gpio_sdcard_cs,
|
||||
};
|
||||
|
||||
static void furi_hal_spi_bus_handle_sd_slow_event_callback(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event) {
|
||||
furi_hal_spi_bus_d_handle_event_callback(handle, event, &furi_hal_spi_preset_1edge_low_2m);
|
||||
}
|
||||
|
||||
FuriHalSpiBusHandle furi_hal_spi_bus_handle_sd_slow = {
|
||||
.bus = &furi_hal_spi_bus_d,
|
||||
.callback = furi_hal_spi_bus_handle_sd_slow_event_callback,
|
||||
.miso = &gpio_spi_d_miso,
|
||||
.mosi = &gpio_spi_d_mosi,
|
||||
.sck = &gpio_spi_d_sck,
|
||||
.cs = &gpio_sdcard_cs,
|
||||
};
|
||||
@@ -0,0 +1,61 @@
|
||||
#pragma once
|
||||
|
||||
#include <furi_hal_spi_types.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** Preset for ST25R916 */
|
||||
extern const LL_SPI_InitTypeDef furi_hal_spi_preset_2edge_low_8m;
|
||||
|
||||
/** Preset for CC1101 */
|
||||
extern const LL_SPI_InitTypeDef furi_hal_spi_preset_1edge_low_8m;
|
||||
|
||||
/** Preset for ST7567 (Display) */
|
||||
extern const LL_SPI_InitTypeDef furi_hal_spi_preset_1edge_low_4m;
|
||||
|
||||
/** Preset for SdCard in fast mode */
|
||||
extern const LL_SPI_InitTypeDef furi_hal_spi_preset_1edge_low_16m;
|
||||
|
||||
/** Preset for SdCard in slow mode */
|
||||
extern const LL_SPI_InitTypeDef furi_hal_spi_preset_1edge_low_2m;
|
||||
|
||||
/** Furi Hal Spi Bus R (Radio: CC1101, Nfc, External)*/
|
||||
extern FuriHalSpiBus furi_hal_spi_bus_r;
|
||||
|
||||
/** Furi Hal Spi Bus D (Display, SdCard) */
|
||||
extern FuriHalSpiBus furi_hal_spi_bus_d;
|
||||
|
||||
/** CC1101 on `furi_hal_spi_bus_r` */
|
||||
extern FuriHalSpiBusHandle furi_hal_spi_bus_handle_subghz;
|
||||
|
||||
/** ST25R3916 on `furi_hal_spi_bus_r` */
|
||||
extern FuriHalSpiBusHandle furi_hal_spi_bus_handle_nfc;
|
||||
|
||||
/** External on `furi_hal_spi_bus_r`
|
||||
* Preset: `furi_hal_spi_preset_1edge_low_2m`
|
||||
*
|
||||
* miso: pa6
|
||||
* mosi: pa7
|
||||
* sck: pb3
|
||||
* cs: pa4 (software controlled)
|
||||
*
|
||||
* @warning not initialized by default, call `furi_hal_spi_bus_handle_init` to initialize
|
||||
* Bus pins are floating on inactive state, CS high after initialization
|
||||
*
|
||||
*/
|
||||
extern FuriHalSpiBusHandle furi_hal_spi_bus_handle_external;
|
||||
|
||||
/** ST7567(Display) on `furi_hal_spi_bus_d` */
|
||||
extern FuriHalSpiBusHandle furi_hal_spi_bus_handle_display;
|
||||
|
||||
/** SdCard in fast mode on `furi_hal_spi_bus_d` */
|
||||
extern FuriHalSpiBusHandle furi_hal_spi_bus_handle_sd_fast;
|
||||
|
||||
/** SdCard in slow mode on `furi_hal_spi_bus_d` */
|
||||
extern FuriHalSpiBusHandle furi_hal_spi_bus_handle_sd_slow;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,62 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#include <furi_hal_gpio.h>
|
||||
|
||||
#include <stm32wbxx_ll_spi.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct FuriHalSpiBus FuriHalSpiBus;
|
||||
typedef struct FuriHalSpiBusHandle FuriHalSpiBusHandle;
|
||||
|
||||
/** FuriHal spi bus states */
|
||||
typedef enum {
|
||||
FuriHalSpiBusEventInit, /**< Bus initialization event, called on system start */
|
||||
FuriHalSpiBusEventDeinit, /**< Bus deinitialization event, called on system stop */
|
||||
FuriHalSpiBusEventLock, /**< Bus lock event, called before activation */
|
||||
FuriHalSpiBusEventUnlock, /**< Bus unlock event, called after deactivation */
|
||||
FuriHalSpiBusEventActivate, /**< Bus activation event, called before handle activation */
|
||||
FuriHalSpiBusEventDeactivate, /**< Bus deactivation event, called after handle deactivation */
|
||||
} FuriHalSpiBusEvent;
|
||||
|
||||
/** FuriHal spi bus event callback */
|
||||
typedef void (*FuriHalSpiBusEventCallback)(FuriHalSpiBus* bus, FuriHalSpiBusEvent event);
|
||||
|
||||
/** FuriHal spi bus */
|
||||
struct FuriHalSpiBus {
|
||||
SPI_TypeDef* spi;
|
||||
FuriHalSpiBusEventCallback callback;
|
||||
FuriHalSpiBusHandle* current_handle;
|
||||
};
|
||||
|
||||
/** FuriHal spi handle states */
|
||||
typedef enum {
|
||||
FuriHalSpiBusHandleEventInit, /**< Handle init, called on system start, initialize gpio for idle state */
|
||||
FuriHalSpiBusHandleEventDeinit, /**< Handle deinit, called on system stop, deinitialize gpio for default state */
|
||||
FuriHalSpiBusHandleEventActivate, /**< Handle activate: connect gpio and apply bus config */
|
||||
FuriHalSpiBusHandleEventDeactivate, /**< Handle deactivate: disconnect gpio and reset bus config */
|
||||
} FuriHalSpiBusHandleEvent;
|
||||
|
||||
/** FuriHal spi handle event callback */
|
||||
typedef void (*FuriHalSpiBusHandleEventCallback)(
|
||||
FuriHalSpiBusHandle* handle,
|
||||
FuriHalSpiBusHandleEvent event);
|
||||
|
||||
/** FuriHal spi handle */
|
||||
struct FuriHalSpiBusHandle {
|
||||
FuriHalSpiBus* bus;
|
||||
FuriHalSpiBusHandleEventCallback callback;
|
||||
const GpioPin* miso;
|
||||
const GpioPin* mosi;
|
||||
const GpioPin* sck;
|
||||
const GpioPin* cs;
|
||||
};
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,769 @@
|
||||
#include <furi_hal_subghz.h>
|
||||
#include <lib/subghz/devices/cc1101_configs.h>
|
||||
#include <furi_hal_region.h>
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_rtc.h>
|
||||
#include <furi_hal_spi.h>
|
||||
#include <furi_hal_interrupt.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_bus.h>
|
||||
|
||||
#include <stm32wbxx_ll_dma.h>
|
||||
|
||||
#include <furi.h>
|
||||
#include <cc1101.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define TAG "FuriHalSubGhz"
|
||||
|
||||
static uint32_t furi_hal_subghz_debug_gpio_buff[2];
|
||||
|
||||
/* DMA Channels definition */
|
||||
#define SUBGHZ_DMA DMA2
|
||||
#define SUBGHZ_DMA_CH1_CHANNEL LL_DMA_CHANNEL_1
|
||||
#define SUBGHZ_DMA_CH2_CHANNEL LL_DMA_CHANNEL_2
|
||||
#define SUBGHZ_DMA_CH1_IRQ FuriHalInterruptIdDma2Ch1
|
||||
#define SUBGHZ_DMA_CH1_DEF SUBGHZ_DMA, SUBGHZ_DMA_CH1_CHANNEL
|
||||
#define SUBGHZ_DMA_CH2_DEF SUBGHZ_DMA, SUBGHZ_DMA_CH2_CHANNEL
|
||||
|
||||
/** SubGhz state */
|
||||
typedef enum {
|
||||
SubGhzStateInit, /**< Init pending */
|
||||
|
||||
SubGhzStateIdle, /**< Idle, energy save mode */
|
||||
|
||||
SubGhzStateAsyncRx, /**< Async RX started */
|
||||
|
||||
SubGhzStateAsyncTx, /**< Async TX started, DMA and timer is on */
|
||||
SubGhzStateAsyncTxLast, /**< Async TX continue, DMA completed and timer got last value to go */
|
||||
SubGhzStateAsyncTxEnd, /**< Async TX complete, cleanup needed */
|
||||
|
||||
} SubGhzState;
|
||||
|
||||
/** SubGhz regulation, receive transmission on the current frequency for the
|
||||
* region */
|
||||
typedef enum {
|
||||
SubGhzRegulationOnlyRx, /**only Rx*/
|
||||
SubGhzRegulationTxRx, /**TxRx*/
|
||||
} SubGhzRegulation;
|
||||
|
||||
typedef struct {
|
||||
volatile SubGhzState state;
|
||||
volatile SubGhzRegulation regulation;
|
||||
const GpioPin* async_mirror_pin;
|
||||
} FuriHalSubGhz;
|
||||
|
||||
volatile FuriHalSubGhz furi_hal_subghz = {
|
||||
.state = SubGhzStateInit,
|
||||
.regulation = SubGhzRegulationTxRx,
|
||||
.async_mirror_pin = NULL,
|
||||
};
|
||||
|
||||
void furi_hal_subghz_set_async_mirror_pin(const GpioPin* pin) {
|
||||
furi_hal_subghz.async_mirror_pin = pin;
|
||||
}
|
||||
|
||||
const GpioPin* furi_hal_subghz_get_data_gpio() {
|
||||
return &gpio_cc1101_g0;
|
||||
}
|
||||
|
||||
void furi_hal_subghz_init() {
|
||||
furi_assert(furi_hal_subghz.state == SubGhzStateInit);
|
||||
furi_hal_subghz.state = SubGhzStateIdle;
|
||||
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
|
||||
#ifdef FURI_HAL_SUBGHZ_TX_GPIO
|
||||
furi_hal_gpio_init(&FURI_HAL_SUBGHZ_TX_GPIO, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
#endif
|
||||
|
||||
// Reset
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
cc1101_reset(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG0, CC1101IocfgHighImpedance);
|
||||
|
||||
// Prepare GD0 for power on self test
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
// GD0 low
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG0, CC1101IocfgHW);
|
||||
while(furi_hal_gpio_read(&gpio_cc1101_g0) != false)
|
||||
;
|
||||
|
||||
// GD0 high
|
||||
cc1101_write_reg(
|
||||
&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG0, CC1101IocfgHW | CC1101_IOCFG_INV);
|
||||
while(furi_hal_gpio_read(&gpio_cc1101_g0) != true)
|
||||
;
|
||||
|
||||
// Reset GD0 to floating state
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG0, CC1101IocfgHighImpedance);
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
// RF switches
|
||||
furi_hal_gpio_init(&gpio_rf_sw_0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG2, CC1101IocfgHW);
|
||||
|
||||
// Go to sleep
|
||||
cc1101_shutdown(&furi_hal_spi_bus_handle_subghz);
|
||||
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
void furi_hal_subghz_sleep() {
|
||||
furi_assert(furi_hal_subghz.state == SubGhzStateIdle);
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
|
||||
cc1101_switch_to_idle(&furi_hal_spi_bus_handle_subghz);
|
||||
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG0, CC1101IocfgHighImpedance);
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
cc1101_shutdown(&furi_hal_spi_bus_handle_subghz);
|
||||
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_dump_state() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
printf(
|
||||
"[furi_hal_subghz] cc1101 chip %d, version %d\r\n",
|
||||
cc1101_get_partnumber(&furi_hal_spi_bus_handle_subghz),
|
||||
cc1101_get_version(&furi_hal_spi_bus_handle_subghz));
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_load_custom_preset(const uint8_t* preset_data) {
|
||||
//load config
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_reset(&furi_hal_spi_bus_handle_subghz);
|
||||
uint32_t i = 0;
|
||||
uint8_t pa[8] = {0};
|
||||
while(preset_data[i]) {
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, preset_data[i], preset_data[i + 1]);
|
||||
i += 2;
|
||||
}
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
|
||||
//load pa table
|
||||
memcpy(&pa[0], &preset_data[i + 2], 8);
|
||||
furi_hal_subghz_load_patable(pa);
|
||||
|
||||
//show debug
|
||||
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
|
||||
i = 0;
|
||||
FURI_LOG_D(TAG, "Loading custom preset");
|
||||
while(preset_data[i]) {
|
||||
FURI_LOG_D(TAG, "Reg[%lu]: %02X=%02X", i, preset_data[i], preset_data[i + 1]);
|
||||
i += 2;
|
||||
}
|
||||
for(uint8_t y = i; y < i + 10; y++) {
|
||||
FURI_LOG_D(TAG, "PA[%u]: %02X", y, preset_data[y]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_subghz_load_registers(const uint8_t* data) {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_reset(&furi_hal_spi_bus_handle_subghz);
|
||||
uint32_t i = 0;
|
||||
while(data[i]) {
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, data[i], data[i + 1]);
|
||||
i += 2;
|
||||
}
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_load_patable(const uint8_t data[8]) {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_set_pa_table(&furi_hal_spi_bus_handle_subghz, data);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_write_packet(const uint8_t* data, uint8_t size) {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_flush_tx(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, CC1101_FIFO, size);
|
||||
cc1101_write_fifo(&furi_hal_spi_bus_handle_subghz, data, size);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_flush_rx() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_flush_rx(&furi_hal_spi_bus_handle_subghz);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_flush_tx() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_flush_tx(&furi_hal_spi_bus_handle_subghz);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
bool furi_hal_subghz_rx_pipe_not_empty() {
|
||||
CC1101RxBytes status[1];
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_read_reg(
|
||||
&furi_hal_spi_bus_handle_subghz, (CC1101_STATUS_RXBYTES) | CC1101_BURST, (uint8_t*)status);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
if(status->NUM_RXBYTES > 0) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_subghz_is_rx_data_crc_valid() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
uint8_t data[1];
|
||||
cc1101_read_reg(&furi_hal_spi_bus_handle_subghz, CC1101_STATUS_LQI | CC1101_BURST, data);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
if(((data[0] >> 7) & 0x01)) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_subghz_read_packet(uint8_t* data, uint8_t* size) {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_read_fifo(&furi_hal_spi_bus_handle_subghz, data, size);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_shutdown() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
// Reset and shutdown
|
||||
cc1101_shutdown(&furi_hal_spi_bus_handle_subghz);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_reset() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
cc1101_switch_to_idle(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_reset(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG0, CC1101IocfgHighImpedance);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_idle() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_switch_to_idle(&furi_hal_spi_bus_handle_subghz);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
void furi_hal_subghz_rx() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_switch_to_rx(&furi_hal_spi_bus_handle_subghz);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
bool furi_hal_subghz_tx() {
|
||||
if(furi_hal_subghz.regulation != SubGhzRegulationTxRx) return false;
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
cc1101_switch_to_tx(&furi_hal_spi_bus_handle_subghz);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
return true;
|
||||
}
|
||||
|
||||
float furi_hal_subghz_get_rssi() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
int32_t rssi_dec = cc1101_get_rssi(&furi_hal_spi_bus_handle_subghz);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
|
||||
float rssi = rssi_dec;
|
||||
if(rssi_dec >= 128) {
|
||||
rssi = ((rssi - 256.0f) / 2.0f) - 74.0f;
|
||||
} else {
|
||||
rssi = (rssi / 2.0f) - 74.0f;
|
||||
}
|
||||
|
||||
return rssi;
|
||||
}
|
||||
|
||||
uint8_t furi_hal_subghz_get_lqi() {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
uint8_t data[1];
|
||||
cc1101_read_reg(&furi_hal_spi_bus_handle_subghz, CC1101_STATUS_LQI | CC1101_BURST, data);
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
return data[0] & 0x7F;
|
||||
}
|
||||
|
||||
bool furi_hal_subghz_is_frequency_valid(uint32_t value) {
|
||||
if(!(value >= 299999755 && value <= 348000335) &&
|
||||
!(value >= 386999938 && value <= 464000000) &&
|
||||
!(value >= 778999847 && value <= 928000000)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
uint32_t furi_hal_subghz_set_frequency_and_path(uint32_t value) {
|
||||
value = furi_hal_subghz_set_frequency(value);
|
||||
if(value >= 299999755 && value <= 348000335) {
|
||||
furi_hal_subghz_set_path(FuriHalSubGhzPath315);
|
||||
} else if(value >= 386999938 && value <= 464000000) {
|
||||
furi_hal_subghz_set_path(FuriHalSubGhzPath433);
|
||||
} else if(value >= 778999847 && value <= 928000000) {
|
||||
furi_hal_subghz_set_path(FuriHalSubGhzPath868);
|
||||
} else {
|
||||
furi_crash("SubGhz: Incorrect frequency during set.");
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
uint32_t furi_hal_subghz_set_frequency(uint32_t value) {
|
||||
if(furi_hal_region_is_frequency_allowed(value)) {
|
||||
furi_hal_subghz.regulation = SubGhzRegulationTxRx;
|
||||
} else {
|
||||
furi_hal_subghz.regulation = SubGhzRegulationOnlyRx;
|
||||
}
|
||||
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
uint32_t real_frequency = cc1101_set_frequency(&furi_hal_spi_bus_handle_subghz, value);
|
||||
cc1101_calibrate(&furi_hal_spi_bus_handle_subghz);
|
||||
|
||||
while(true) {
|
||||
CC1101Status status = cc1101_get_status(&furi_hal_spi_bus_handle_subghz);
|
||||
if(status.STATE == CC1101StateIDLE) break;
|
||||
}
|
||||
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
return real_frequency;
|
||||
}
|
||||
|
||||
void furi_hal_subghz_set_path(FuriHalSubGhzPath path) {
|
||||
furi_hal_spi_acquire(&furi_hal_spi_bus_handle_subghz);
|
||||
if(path == FuriHalSubGhzPath433) {
|
||||
furi_hal_gpio_write(&gpio_rf_sw_0, 0);
|
||||
cc1101_write_reg(
|
||||
&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG2, CC1101IocfgHW | CC1101_IOCFG_INV);
|
||||
} else if(path == FuriHalSubGhzPath315) {
|
||||
furi_hal_gpio_write(&gpio_rf_sw_0, 1);
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG2, CC1101IocfgHW);
|
||||
} else if(path == FuriHalSubGhzPath868) {
|
||||
furi_hal_gpio_write(&gpio_rf_sw_0, 1);
|
||||
cc1101_write_reg(
|
||||
&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG2, CC1101IocfgHW | CC1101_IOCFG_INV);
|
||||
} else if(path == FuriHalSubGhzPathIsolate) {
|
||||
furi_hal_gpio_write(&gpio_rf_sw_0, 0);
|
||||
cc1101_write_reg(&furi_hal_spi_bus_handle_subghz, CC1101_IOCFG2, CC1101IocfgHW);
|
||||
} else {
|
||||
furi_crash("SubGhz: Incorrect path during set.");
|
||||
}
|
||||
furi_hal_spi_release(&furi_hal_spi_bus_handle_subghz);
|
||||
}
|
||||
|
||||
static bool furi_hal_subghz_start_debug() {
|
||||
bool ret = false;
|
||||
if(furi_hal_subghz.async_mirror_pin != NULL) {
|
||||
furi_hal_gpio_init(
|
||||
furi_hal_subghz.async_mirror_pin,
|
||||
GpioModeOutputPushPull,
|
||||
GpioPullNo,
|
||||
GpioSpeedVeryHigh);
|
||||
ret = true;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool furi_hal_subghz_stop_debug() {
|
||||
bool ret = false;
|
||||
if(furi_hal_subghz.async_mirror_pin != NULL) {
|
||||
furi_hal_gpio_init(
|
||||
furi_hal_subghz.async_mirror_pin, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
ret = true;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
volatile uint32_t furi_hal_subghz_capture_delta_duration = 0;
|
||||
volatile FuriHalSubGhzCaptureCallback furi_hal_subghz_capture_callback = NULL;
|
||||
volatile void* furi_hal_subghz_capture_callback_context = NULL;
|
||||
|
||||
static void furi_hal_subghz_capture_ISR() {
|
||||
// Channel 1
|
||||
if(LL_TIM_IsActiveFlag_CC1(TIM2)) {
|
||||
LL_TIM_ClearFlag_CC1(TIM2);
|
||||
furi_hal_subghz_capture_delta_duration = LL_TIM_IC_GetCaptureCH1(TIM2);
|
||||
if(furi_hal_subghz_capture_callback) {
|
||||
if(furi_hal_subghz.async_mirror_pin != NULL)
|
||||
furi_hal_gpio_write(furi_hal_subghz.async_mirror_pin, false);
|
||||
|
||||
furi_hal_subghz_capture_callback(
|
||||
true,
|
||||
furi_hal_subghz_capture_delta_duration,
|
||||
(void*)furi_hal_subghz_capture_callback_context);
|
||||
}
|
||||
}
|
||||
// Channel 2
|
||||
if(LL_TIM_IsActiveFlag_CC2(TIM2)) {
|
||||
LL_TIM_ClearFlag_CC2(TIM2);
|
||||
if(furi_hal_subghz_capture_callback) {
|
||||
if(furi_hal_subghz.async_mirror_pin != NULL)
|
||||
furi_hal_gpio_write(furi_hal_subghz.async_mirror_pin, true);
|
||||
|
||||
furi_hal_subghz_capture_callback(
|
||||
false,
|
||||
LL_TIM_IC_GetCaptureCH2(TIM2) - furi_hal_subghz_capture_delta_duration,
|
||||
(void*)furi_hal_subghz_capture_callback_context);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_subghz_start_async_rx(FuriHalSubGhzCaptureCallback callback, void* context) {
|
||||
furi_assert(furi_hal_subghz.state == SubGhzStateIdle);
|
||||
furi_hal_subghz.state = SubGhzStateAsyncRx;
|
||||
|
||||
furi_hal_subghz_capture_callback = callback;
|
||||
furi_hal_subghz_capture_callback_context = context;
|
||||
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_cc1101_g0, GpioModeAltFunctionPushPull, GpioPullNo, GpioSpeedLow, GpioAltFn1TIM2);
|
||||
|
||||
furi_hal_bus_enable(FuriHalBusTIM2);
|
||||
|
||||
// Timer: base
|
||||
LL_TIM_InitTypeDef TIM_InitStruct = {0};
|
||||
TIM_InitStruct.Prescaler = 64 - 1;
|
||||
TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
|
||||
TIM_InitStruct.Autoreload = 0x7FFFFFFE;
|
||||
TIM_InitStruct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV4; // Clock division for capture filter
|
||||
LL_TIM_Init(TIM2, &TIM_InitStruct);
|
||||
|
||||
// Timer: advanced
|
||||
LL_TIM_SetClockSource(TIM2, LL_TIM_CLOCKSOURCE_INTERNAL);
|
||||
LL_TIM_DisableARRPreload(TIM2);
|
||||
LL_TIM_SetTriggerInput(TIM2, LL_TIM_TS_TI2FP2);
|
||||
LL_TIM_SetSlaveMode(TIM2, LL_TIM_SLAVEMODE_RESET);
|
||||
LL_TIM_SetTriggerOutput(TIM2, LL_TIM_TRGO_RESET);
|
||||
LL_TIM_EnableMasterSlaveMode(TIM2);
|
||||
LL_TIM_DisableDMAReq_TRIG(TIM2);
|
||||
LL_TIM_DisableIT_TRIG(TIM2);
|
||||
|
||||
// Timer: channel 1 indirect
|
||||
LL_TIM_IC_SetActiveInput(TIM2, LL_TIM_CHANNEL_CH1, LL_TIM_ACTIVEINPUT_INDIRECTTI);
|
||||
LL_TIM_IC_SetPrescaler(TIM2, LL_TIM_CHANNEL_CH1, LL_TIM_ICPSC_DIV1);
|
||||
LL_TIM_IC_SetPolarity(TIM2, LL_TIM_CHANNEL_CH1, LL_TIM_IC_POLARITY_FALLING);
|
||||
|
||||
// Timer: channel 2 direct
|
||||
LL_TIM_IC_SetActiveInput(TIM2, LL_TIM_CHANNEL_CH2, LL_TIM_ACTIVEINPUT_DIRECTTI);
|
||||
LL_TIM_IC_SetPrescaler(TIM2, LL_TIM_CHANNEL_CH2, LL_TIM_ICPSC_DIV1);
|
||||
LL_TIM_IC_SetPolarity(TIM2, LL_TIM_CHANNEL_CH2, LL_TIM_IC_POLARITY_RISING);
|
||||
LL_TIM_IC_SetFilter(
|
||||
TIM2,
|
||||
LL_TIM_CHANNEL_CH2,
|
||||
LL_TIM_IC_FILTER_FDIV32_N8); // Capture filter: 1/(64000000/64/4/32*8) = 16us
|
||||
|
||||
// ISR setup
|
||||
furi_hal_interrupt_set_isr(FuriHalInterruptIdTIM2, furi_hal_subghz_capture_ISR, NULL);
|
||||
|
||||
// Interrupts and channels
|
||||
LL_TIM_EnableIT_CC1(TIM2);
|
||||
LL_TIM_EnableIT_CC2(TIM2);
|
||||
LL_TIM_CC_EnableChannel(TIM2, LL_TIM_CHANNEL_CH1);
|
||||
LL_TIM_CC_EnableChannel(TIM2, LL_TIM_CHANNEL_CH2);
|
||||
|
||||
// Start timer
|
||||
LL_TIM_SetCounter(TIM2, 0);
|
||||
LL_TIM_EnableCounter(TIM2);
|
||||
|
||||
// Start debug
|
||||
furi_hal_subghz_start_debug();
|
||||
|
||||
// Switch to RX
|
||||
furi_hal_subghz_rx();
|
||||
|
||||
//Clear the variable after the end of the session
|
||||
furi_hal_subghz_capture_delta_duration = 0;
|
||||
}
|
||||
|
||||
void furi_hal_subghz_stop_async_rx() {
|
||||
furi_assert(furi_hal_subghz.state == SubGhzStateAsyncRx);
|
||||
furi_hal_subghz.state = SubGhzStateIdle;
|
||||
|
||||
// Shutdown radio
|
||||
furi_hal_subghz_idle();
|
||||
|
||||
FURI_CRITICAL_ENTER();
|
||||
furi_hal_bus_disable(FuriHalBusTIM2);
|
||||
|
||||
// Stop debug
|
||||
furi_hal_subghz_stop_debug();
|
||||
|
||||
FURI_CRITICAL_EXIT();
|
||||
furi_hal_interrupt_set_isr(FuriHalInterruptIdTIM2, NULL, NULL);
|
||||
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
uint32_t* buffer;
|
||||
LevelDuration carry_ld;
|
||||
FuriHalSubGhzAsyncTxCallback callback;
|
||||
void* callback_context;
|
||||
uint64_t duty_high;
|
||||
uint64_t duty_low;
|
||||
} FuriHalSubGhzAsyncTx;
|
||||
|
||||
static FuriHalSubGhzAsyncTx furi_hal_subghz_async_tx = {0};
|
||||
|
||||
static void furi_hal_subghz_async_tx_refill(uint32_t* buffer, size_t samples) {
|
||||
furi_assert(furi_hal_subghz.state == SubGhzStateAsyncTx);
|
||||
while(samples > 0) {
|
||||
bool is_odd = samples % 2;
|
||||
LevelDuration ld;
|
||||
if(level_duration_is_reset(furi_hal_subghz_async_tx.carry_ld)) {
|
||||
ld = furi_hal_subghz_async_tx.callback(furi_hal_subghz_async_tx.callback_context);
|
||||
} else {
|
||||
ld = furi_hal_subghz_async_tx.carry_ld;
|
||||
furi_hal_subghz_async_tx.carry_ld = level_duration_reset();
|
||||
}
|
||||
|
||||
if(level_duration_is_wait(ld)) {
|
||||
*buffer = API_HAL_SUBGHZ_ASYNC_TX_GUARD_TIME;
|
||||
buffer++;
|
||||
samples--;
|
||||
} else if(level_duration_is_reset(ld)) {
|
||||
*buffer = 0;
|
||||
buffer++;
|
||||
samples--;
|
||||
LL_DMA_DisableIT_HT(SUBGHZ_DMA_CH1_DEF);
|
||||
LL_DMA_DisableIT_TC(SUBGHZ_DMA_CH1_DEF);
|
||||
LL_TIM_EnableIT_UPDATE(TIM2);
|
||||
break;
|
||||
} else {
|
||||
bool level = level_duration_get_level(ld);
|
||||
|
||||
// Inject guard time if level is incorrect
|
||||
if(is_odd != level) {
|
||||
*buffer = API_HAL_SUBGHZ_ASYNC_TX_GUARD_TIME;
|
||||
buffer++;
|
||||
samples--;
|
||||
if(is_odd) {
|
||||
furi_hal_subghz_async_tx.duty_high += API_HAL_SUBGHZ_ASYNC_TX_GUARD_TIME;
|
||||
} else {
|
||||
furi_hal_subghz_async_tx.duty_low += API_HAL_SUBGHZ_ASYNC_TX_GUARD_TIME;
|
||||
}
|
||||
|
||||
// Special case: prevent buffer overflow if sample is last
|
||||
if(samples == 0) {
|
||||
furi_hal_subghz_async_tx.carry_ld = ld;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t duration = level_duration_get_duration(ld);
|
||||
furi_assert(duration > 0);
|
||||
*buffer = duration;
|
||||
buffer++;
|
||||
samples--;
|
||||
|
||||
if(is_odd) {
|
||||
furi_hal_subghz_async_tx.duty_high += duration;
|
||||
} else {
|
||||
furi_hal_subghz_async_tx.duty_low += duration;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void furi_hal_subghz_async_tx_dma_isr() {
|
||||
furi_assert(furi_hal_subghz.state == SubGhzStateAsyncTx);
|
||||
|
||||
#if SUBGHZ_DMA_CH1_CHANNEL == LL_DMA_CHANNEL_1
|
||||
if(LL_DMA_IsActiveFlag_HT1(SUBGHZ_DMA)) {
|
||||
LL_DMA_ClearFlag_HT1(SUBGHZ_DMA);
|
||||
furi_hal_subghz_async_tx_refill(
|
||||
furi_hal_subghz_async_tx.buffer, API_HAL_SUBGHZ_ASYNC_TX_BUFFER_HALF);
|
||||
}
|
||||
if(LL_DMA_IsActiveFlag_TC1(SUBGHZ_DMA)) {
|
||||
LL_DMA_ClearFlag_TC1(SUBGHZ_DMA);
|
||||
furi_hal_subghz_async_tx_refill(
|
||||
furi_hal_subghz_async_tx.buffer + API_HAL_SUBGHZ_ASYNC_TX_BUFFER_HALF,
|
||||
API_HAL_SUBGHZ_ASYNC_TX_BUFFER_HALF);
|
||||
}
|
||||
#else
|
||||
#error Update this code. Would you kindly?
|
||||
#endif
|
||||
}
|
||||
|
||||
static void furi_hal_subghz_async_tx_timer_isr() {
|
||||
if(LL_TIM_IsActiveFlag_UPDATE(TIM2)) {
|
||||
LL_TIM_ClearFlag_UPDATE(TIM2);
|
||||
if(LL_TIM_GetAutoReload(TIM2) == 0) {
|
||||
if(furi_hal_subghz.state == SubGhzStateAsyncTx) {
|
||||
furi_hal_subghz.state = SubGhzStateAsyncTxLast;
|
||||
LL_DMA_DisableChannel(SUBGHZ_DMA_CH1_DEF);
|
||||
} else if(furi_hal_subghz.state == SubGhzStateAsyncTxLast) {
|
||||
furi_hal_subghz.state = SubGhzStateAsyncTxEnd;
|
||||
//forcibly pulls the pin to the ground so that there is no carrier
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullDown, GpioSpeedLow);
|
||||
LL_TIM_DisableCounter(TIM2);
|
||||
} else {
|
||||
furi_crash(NULL);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_subghz_start_async_tx(FuriHalSubGhzAsyncTxCallback callback, void* context) {
|
||||
furi_assert(furi_hal_subghz.state == SubGhzStateIdle);
|
||||
furi_assert(callback);
|
||||
|
||||
//If transmission is prohibited by regional settings
|
||||
if(furi_hal_subghz.regulation != SubGhzRegulationTxRx) return false;
|
||||
|
||||
furi_hal_subghz_async_tx.callback = callback;
|
||||
furi_hal_subghz_async_tx.callback_context = context;
|
||||
|
||||
furi_hal_subghz.state = SubGhzStateAsyncTx;
|
||||
|
||||
furi_hal_subghz_async_tx.duty_low = 0;
|
||||
furi_hal_subghz_async_tx.duty_high = 0;
|
||||
|
||||
furi_hal_subghz_async_tx.buffer =
|
||||
malloc(API_HAL_SUBGHZ_ASYNC_TX_BUFFER_FULL * sizeof(uint32_t));
|
||||
|
||||
// Connect CC1101_GD0 to TIM2 as output
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_cc1101_g0, GpioModeAltFunctionPushPull, GpioPullDown, GpioSpeedLow, GpioAltFn1TIM2);
|
||||
|
||||
// Configure DMA
|
||||
LL_DMA_InitTypeDef dma_config = {0};
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (TIM2->ARR);
|
||||
dma_config.MemoryOrM2MDstAddress = (uint32_t)furi_hal_subghz_async_tx.buffer;
|
||||
dma_config.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
||||
dma_config.Mode = LL_DMA_MODE_CIRCULAR;
|
||||
dma_config.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
||||
dma_config.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
||||
dma_config.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
|
||||
dma_config.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
|
||||
dma_config.NbData = API_HAL_SUBGHZ_ASYNC_TX_BUFFER_FULL;
|
||||
dma_config.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
|
||||
dma_config.Priority = LL_DMA_MODE_NORMAL;
|
||||
LL_DMA_Init(SUBGHZ_DMA_CH1_DEF, &dma_config);
|
||||
furi_hal_interrupt_set_isr(SUBGHZ_DMA_CH1_IRQ, furi_hal_subghz_async_tx_dma_isr, NULL);
|
||||
LL_DMA_EnableIT_TC(SUBGHZ_DMA_CH1_DEF);
|
||||
LL_DMA_EnableIT_HT(SUBGHZ_DMA_CH1_DEF);
|
||||
LL_DMA_EnableChannel(SUBGHZ_DMA_CH1_DEF);
|
||||
|
||||
furi_hal_bus_enable(FuriHalBusTIM2);
|
||||
|
||||
// Configure TIM2
|
||||
LL_TIM_InitTypeDef TIM_InitStruct = {0};
|
||||
TIM_InitStruct.Prescaler = 64 - 1;
|
||||
TIM_InitStruct.CounterMode = LL_TIM_COUNTERMODE_UP;
|
||||
TIM_InitStruct.Autoreload = 1000;
|
||||
TIM_InitStruct.ClockDivision = LL_TIM_CLOCKDIVISION_DIV1;
|
||||
LL_TIM_Init(TIM2, &TIM_InitStruct);
|
||||
LL_TIM_SetClockSource(TIM2, LL_TIM_CLOCKSOURCE_INTERNAL);
|
||||
LL_TIM_EnableARRPreload(TIM2);
|
||||
|
||||
// Configure TIM2 CH2
|
||||
LL_TIM_OC_InitTypeDef TIM_OC_InitStruct = {0};
|
||||
TIM_OC_InitStruct.OCMode = LL_TIM_OCMODE_TOGGLE;
|
||||
TIM_OC_InitStruct.OCState = LL_TIM_OCSTATE_DISABLE;
|
||||
TIM_OC_InitStruct.OCNState = LL_TIM_OCSTATE_DISABLE;
|
||||
TIM_OC_InitStruct.CompareValue = 0;
|
||||
TIM_OC_InitStruct.OCPolarity = LL_TIM_OCPOLARITY_LOW;
|
||||
LL_TIM_OC_Init(TIM2, LL_TIM_CHANNEL_CH2, &TIM_OC_InitStruct);
|
||||
LL_TIM_OC_DisableFast(TIM2, LL_TIM_CHANNEL_CH2);
|
||||
LL_TIM_DisableMasterSlaveMode(TIM2);
|
||||
|
||||
furi_hal_interrupt_set_isr(FuriHalInterruptIdTIM2, furi_hal_subghz_async_tx_timer_isr, NULL);
|
||||
|
||||
furi_hal_subghz_async_tx_refill(
|
||||
furi_hal_subghz_async_tx.buffer, API_HAL_SUBGHZ_ASYNC_TX_BUFFER_FULL);
|
||||
|
||||
LL_TIM_EnableDMAReq_UPDATE(TIM2);
|
||||
LL_TIM_CC_EnableChannel(TIM2, LL_TIM_CHANNEL_CH2);
|
||||
|
||||
// Start counter
|
||||
LL_TIM_GenerateEvent_UPDATE(TIM2);
|
||||
#ifdef FURI_HAL_SUBGHZ_TX_GPIO
|
||||
furi_hal_gpio_write(&FURI_HAL_SUBGHZ_TX_GPIO, true);
|
||||
#endif
|
||||
furi_hal_subghz_tx();
|
||||
|
||||
LL_TIM_SetCounter(TIM2, 0);
|
||||
LL_TIM_EnableCounter(TIM2);
|
||||
|
||||
// Start debug
|
||||
if(furi_hal_subghz_start_debug()) {
|
||||
const GpioPin* gpio = furi_hal_subghz.async_mirror_pin;
|
||||
furi_hal_subghz_debug_gpio_buff[0] = (uint32_t)gpio->pin << GPIO_NUMBER;
|
||||
furi_hal_subghz_debug_gpio_buff[1] = gpio->pin;
|
||||
|
||||
dma_config.MemoryOrM2MDstAddress = (uint32_t)furi_hal_subghz_debug_gpio_buff;
|
||||
dma_config.PeriphOrM2MSrcAddress = (uint32_t) & (gpio->port->BSRR);
|
||||
dma_config.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
|
||||
dma_config.Mode = LL_DMA_MODE_CIRCULAR;
|
||||
dma_config.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
|
||||
dma_config.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
|
||||
dma_config.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
|
||||
dma_config.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
|
||||
dma_config.NbData = 2;
|
||||
dma_config.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
|
||||
dma_config.Priority = LL_DMA_PRIORITY_VERYHIGH;
|
||||
LL_DMA_Init(SUBGHZ_DMA_CH2_DEF, &dma_config);
|
||||
LL_DMA_SetDataLength(SUBGHZ_DMA_CH2_DEF, 2);
|
||||
LL_DMA_EnableChannel(SUBGHZ_DMA_CH2_DEF);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool furi_hal_subghz_is_async_tx_complete() {
|
||||
return furi_hal_subghz.state == SubGhzStateAsyncTxEnd;
|
||||
}
|
||||
|
||||
void furi_hal_subghz_stop_async_tx() {
|
||||
furi_assert(
|
||||
furi_hal_subghz.state == SubGhzStateAsyncTx ||
|
||||
furi_hal_subghz.state == SubGhzStateAsyncTxLast ||
|
||||
furi_hal_subghz.state == SubGhzStateAsyncTxEnd);
|
||||
|
||||
// Shutdown radio
|
||||
furi_hal_subghz_idle();
|
||||
#ifdef FURI_HAL_SUBGHZ_TX_GPIO
|
||||
furi_hal_gpio_write(&FURI_HAL_SUBGHZ_TX_GPIO, false);
|
||||
#endif
|
||||
|
||||
// Deinitialize Timer
|
||||
FURI_CRITICAL_ENTER();
|
||||
furi_hal_bus_disable(FuriHalBusTIM2);
|
||||
furi_hal_interrupt_set_isr(FuriHalInterruptIdTIM2, NULL, NULL);
|
||||
|
||||
// Deinitialize DMA
|
||||
LL_DMA_DeInit(SUBGHZ_DMA_CH1_DEF);
|
||||
|
||||
furi_hal_interrupt_set_isr(SUBGHZ_DMA_CH1_IRQ, NULL, NULL);
|
||||
|
||||
// Deinitialize GPIO
|
||||
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
|
||||
|
||||
// Stop debug
|
||||
if(furi_hal_subghz_stop_debug()) {
|
||||
LL_DMA_DisableChannel(SUBGHZ_DMA_CH2_DEF);
|
||||
}
|
||||
|
||||
FURI_CRITICAL_EXIT();
|
||||
|
||||
free(furi_hal_subghz_async_tx.buffer);
|
||||
|
||||
float duty_cycle =
|
||||
100.0f * (float)furi_hal_subghz_async_tx.duty_high /
|
||||
((float)furi_hal_subghz_async_tx.duty_low + (float)furi_hal_subghz_async_tx.duty_high);
|
||||
FURI_LOG_D(
|
||||
TAG,
|
||||
"Async TX Radio stats: on %0.0fus, off %0.0fus, DutyCycle: %0.0f%%",
|
||||
(double)furi_hal_subghz_async_tx.duty_high,
|
||||
(double)furi_hal_subghz_async_tx.duty_low,
|
||||
(double)duty_cycle);
|
||||
|
||||
furi_hal_subghz.state = SubGhzStateIdle;
|
||||
}
|
||||
@@ -0,0 +1,224 @@
|
||||
/**
|
||||
* @file furi_hal_subghz.h
|
||||
* SubGhz HAL API
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <lib/subghz/devices/preset.h>
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <toolbox/level_duration.h>
|
||||
#include <furi_hal_gpio.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** Low level buffer dimensions and guard times */
|
||||
#define API_HAL_SUBGHZ_ASYNC_TX_BUFFER_FULL (256)
|
||||
#define API_HAL_SUBGHZ_ASYNC_TX_BUFFER_HALF (API_HAL_SUBGHZ_ASYNC_TX_BUFFER_FULL / 2)
|
||||
#define API_HAL_SUBGHZ_ASYNC_TX_GUARD_TIME 999
|
||||
|
||||
/** Switchable Radio Paths */
|
||||
typedef enum {
|
||||
FuriHalSubGhzPathIsolate, /**< Isolate Radio from antenna */
|
||||
FuriHalSubGhzPath433, /**< Center Frequency: 433MHz. Path 1: SW1RF1-SW2RF2, LCLCL */
|
||||
FuriHalSubGhzPath315, /**< Center Frequency: 315MHz. Path 2: SW1RF2-SW2RF1, LCLCLCL */
|
||||
FuriHalSubGhzPath868, /**< Center Frequency: 868MHz. Path 3: SW1RF3-SW2RF3, LCLC */
|
||||
} FuriHalSubGhzPath;
|
||||
|
||||
/* Mirror RX/TX async modulation signal to specified pin
|
||||
*
|
||||
* @warning Configures pin to output mode. Make sure it is not connected
|
||||
* directly to power or ground.
|
||||
*
|
||||
* @param[in] pin pointer to the gpio pin structure or NULL to disable
|
||||
*/
|
||||
void furi_hal_subghz_set_async_mirror_pin(const GpioPin* pin);
|
||||
|
||||
/** Get data GPIO
|
||||
*
|
||||
* @return pointer to the gpio pin structure
|
||||
*/
|
||||
const GpioPin* furi_hal_subghz_get_data_gpio();
|
||||
|
||||
/** Initialize and switch to power save mode Used by internal API-HAL
|
||||
* initialization routine Can be used to reinitialize device to safe state and
|
||||
* send it to sleep
|
||||
*/
|
||||
void furi_hal_subghz_init();
|
||||
|
||||
/** Send device to sleep mode
|
||||
*/
|
||||
void furi_hal_subghz_sleep();
|
||||
|
||||
/** Dump info to stdout
|
||||
*/
|
||||
void furi_hal_subghz_dump_state();
|
||||
|
||||
/** Load custom registers from preset
|
||||
*
|
||||
* @param preset_data registers to load
|
||||
*/
|
||||
void furi_hal_subghz_load_custom_preset(const uint8_t* preset_data);
|
||||
|
||||
/** Load registers
|
||||
*
|
||||
* @param data Registers data
|
||||
*/
|
||||
void furi_hal_subghz_load_registers(const uint8_t* data);
|
||||
|
||||
/** Load PATABLE
|
||||
*
|
||||
* @param data 8 uint8_t values
|
||||
*/
|
||||
void furi_hal_subghz_load_patable(const uint8_t data[8]);
|
||||
|
||||
/** Write packet to FIFO
|
||||
*
|
||||
* @param data bytes array
|
||||
* @param size size
|
||||
*/
|
||||
void furi_hal_subghz_write_packet(const uint8_t* data, uint8_t size);
|
||||
|
||||
/** Check if receive pipe is not empty
|
||||
*
|
||||
* @return true if not empty
|
||||
*/
|
||||
bool furi_hal_subghz_rx_pipe_not_empty();
|
||||
|
||||
/** Check if received data crc is valid
|
||||
*
|
||||
* @return true if valid
|
||||
*/
|
||||
bool furi_hal_subghz_is_rx_data_crc_valid();
|
||||
|
||||
/** Read packet from FIFO
|
||||
*
|
||||
* @param data pointer
|
||||
* @param size size
|
||||
*/
|
||||
void furi_hal_subghz_read_packet(uint8_t* data, uint8_t* size);
|
||||
|
||||
/** Flush rx FIFO buffer
|
||||
*/
|
||||
void furi_hal_subghz_flush_rx();
|
||||
|
||||
/** Flush tx FIFO buffer
|
||||
*/
|
||||
void furi_hal_subghz_flush_tx();
|
||||
|
||||
/** Shutdown Issue SPWD command
|
||||
* @warning registers content will be lost
|
||||
*/
|
||||
void furi_hal_subghz_shutdown();
|
||||
|
||||
/** Reset Issue reset command
|
||||
* @warning registers content will be lost
|
||||
*/
|
||||
void furi_hal_subghz_reset();
|
||||
|
||||
/** Switch to Idle
|
||||
*/
|
||||
void furi_hal_subghz_idle();
|
||||
|
||||
/** Switch to Receive
|
||||
*/
|
||||
void furi_hal_subghz_rx();
|
||||
|
||||
/** Switch to Transmit
|
||||
*
|
||||
* @return true if the transfer is allowed by belonging to the region
|
||||
*/
|
||||
bool furi_hal_subghz_tx();
|
||||
|
||||
/** Get RSSI value in dBm
|
||||
*
|
||||
* @return RSSI value
|
||||
*/
|
||||
float furi_hal_subghz_get_rssi();
|
||||
|
||||
/** Get LQI
|
||||
*
|
||||
* @return LQI value
|
||||
*/
|
||||
uint8_t furi_hal_subghz_get_lqi();
|
||||
|
||||
/** Check if frequency is in valid range
|
||||
*
|
||||
* @param value frequency in Hz
|
||||
*
|
||||
* @return true if frequency is valid, otherwise false
|
||||
*/
|
||||
bool furi_hal_subghz_is_frequency_valid(uint32_t value);
|
||||
|
||||
/** Set frequency and path This function automatically selects antenna matching
|
||||
* network
|
||||
*
|
||||
* @param value frequency in Hz
|
||||
*
|
||||
* @return real frequency in Hz
|
||||
*/
|
||||
uint32_t furi_hal_subghz_set_frequency_and_path(uint32_t value);
|
||||
|
||||
/** Set frequency
|
||||
*
|
||||
* @param value frequency in Hz
|
||||
*
|
||||
* @return real frequency in Hz
|
||||
*/
|
||||
uint32_t furi_hal_subghz_set_frequency(uint32_t value);
|
||||
|
||||
/** Set path
|
||||
*
|
||||
* @param path path to use
|
||||
*/
|
||||
void furi_hal_subghz_set_path(FuriHalSubGhzPath path);
|
||||
|
||||
/* High Level API */
|
||||
|
||||
/** Signal Timings Capture callback */
|
||||
typedef void (*FuriHalSubGhzCaptureCallback)(bool level, uint32_t duration, void* context);
|
||||
|
||||
/** Enable signal timings capture Initializes GPIO and TIM2 for timings capture
|
||||
*
|
||||
* @param callback FuriHalSubGhzCaptureCallback
|
||||
* @param context callback context
|
||||
*/
|
||||
void furi_hal_subghz_start_async_rx(FuriHalSubGhzCaptureCallback callback, void* context);
|
||||
|
||||
/** Disable signal timings capture Resets GPIO and TIM2
|
||||
*/
|
||||
void furi_hal_subghz_stop_async_rx();
|
||||
|
||||
/** Async TX callback type
|
||||
* @param context callback context
|
||||
* @return LevelDuration
|
||||
*/
|
||||
typedef LevelDuration (*FuriHalSubGhzAsyncTxCallback)(void* context);
|
||||
|
||||
/** Start async TX Initializes GPIO, TIM2 and DMA1 for signal output
|
||||
*
|
||||
* @param callback FuriHalSubGhzAsyncTxCallback
|
||||
* @param context callback context
|
||||
*
|
||||
* @return true if the transfer is allowed by belonging to the region
|
||||
*/
|
||||
bool furi_hal_subghz_start_async_tx(FuriHalSubGhzAsyncTxCallback callback, void* context);
|
||||
|
||||
/** Wait for async transmission to complete
|
||||
*
|
||||
* @return true if TX complete
|
||||
*/
|
||||
bool furi_hal_subghz_is_async_tx_complete();
|
||||
|
||||
/** Stop async transmission and cleanup resources Resets GPIO, TIM2, and DMA1
|
||||
*/
|
||||
void furi_hal_subghz_stop_async_tx();
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,6 @@
|
||||
#pragma once
|
||||
|
||||
#include <furi_hal_subghz.h>
|
||||
#include <furi_hal_ibutton.h>
|
||||
#include <furi_hal_rfid.h>
|
||||
#include <furi_hal_nfc.h>
|
||||
@@ -0,0 +1,244 @@
|
||||
#include <furi_hal_uart.h>
|
||||
#include <stdbool.h>
|
||||
#include <stm32wbxx_ll_lpuart.h>
|
||||
#include <stm32wbxx_ll_usart.h>
|
||||
#include <stm32wbxx_ll_rcc.h>
|
||||
#include <furi_hal_resources.h>
|
||||
#include <furi_hal_bus.h>
|
||||
|
||||
#include <furi.h>
|
||||
|
||||
static bool furi_hal_usart_prev_enabled[2];
|
||||
|
||||
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,
|
||||
GpioPullUp,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn7USART1);
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_usart_rx,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullUp,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn7USART1);
|
||||
|
||||
LL_USART_InitTypeDef USART_InitStruct;
|
||||
USART_InitStruct.PrescalerValue = LL_USART_PRESCALER_DIV1;
|
||||
USART_InitStruct.BaudRate = baud;
|
||||
USART_InitStruct.DataWidth = LL_USART_DATAWIDTH_8B;
|
||||
USART_InitStruct.StopBits = LL_USART_STOPBITS_1;
|
||||
USART_InitStruct.Parity = LL_USART_PARITY_NONE;
|
||||
USART_InitStruct.TransferDirection = LL_USART_DIRECTION_TX_RX;
|
||||
USART_InitStruct.HardwareFlowControl = LL_USART_HWCONTROL_NONE;
|
||||
USART_InitStruct.OverSampling = LL_USART_OVERSAMPLING_16;
|
||||
LL_USART_Init(USART1, &USART_InitStruct);
|
||||
LL_USART_EnableFIFO(USART1);
|
||||
LL_USART_ConfigAsyncMode(USART1);
|
||||
|
||||
LL_USART_Enable(USART1);
|
||||
|
||||
while(!LL_USART_IsActiveFlag_TEACK(USART1) || !LL_USART_IsActiveFlag_REACK(USART1))
|
||||
;
|
||||
|
||||
LL_USART_DisableIT_ERROR(USART1);
|
||||
|
||||
NVIC_SetPriority(USART1_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
}
|
||||
|
||||
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,
|
||||
GpioPullUp,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn8LPUART1);
|
||||
furi_hal_gpio_init_ex(
|
||||
&gpio_ext_pc1,
|
||||
GpioModeAltFunctionPushPull,
|
||||
GpioPullUp,
|
||||
GpioSpeedVeryHigh,
|
||||
GpioAltFn8LPUART1);
|
||||
|
||||
LL_LPUART_InitTypeDef LPUART_InitStruct;
|
||||
LPUART_InitStruct.PrescalerValue = LL_LPUART_PRESCALER_DIV1;
|
||||
LPUART_InitStruct.BaudRate = 115200;
|
||||
LPUART_InitStruct.DataWidth = LL_LPUART_DATAWIDTH_8B;
|
||||
LPUART_InitStruct.StopBits = LL_LPUART_STOPBITS_1;
|
||||
LPUART_InitStruct.Parity = LL_LPUART_PARITY_NONE;
|
||||
LPUART_InitStruct.TransferDirection = LL_LPUART_DIRECTION_TX_RX;
|
||||
LPUART_InitStruct.HardwareFlowControl = LL_LPUART_HWCONTROL_NONE;
|
||||
LL_LPUART_Init(LPUART1, &LPUART_InitStruct);
|
||||
LL_LPUART_EnableFIFO(LPUART1);
|
||||
|
||||
LL_LPUART_Enable(LPUART1);
|
||||
|
||||
while(!LL_LPUART_IsActiveFlag_TEACK(LPUART1) || !LL_LPUART_IsActiveFlag_REACK(LPUART1))
|
||||
;
|
||||
|
||||
furi_hal_uart_set_br(FuriHalUartIdLPUART1, baud);
|
||||
LL_LPUART_DisableIT_ERROR(LPUART1);
|
||||
|
||||
NVIC_SetPriority(LPUART1_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
}
|
||||
|
||||
void furi_hal_uart_init(FuriHalUartId ch, uint32_t baud) {
|
||||
if(ch == FuriHalUartIdLPUART1) {
|
||||
furi_hal_lpuart_init(baud);
|
||||
} else if(ch == FuriHalUartIdUSART1) {
|
||||
furi_hal_usart_init(baud);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_uart_set_br(FuriHalUartId ch, uint32_t baud) {
|
||||
if(ch == FuriHalUartIdUSART1) {
|
||||
if(LL_USART_IsEnabled(USART1)) {
|
||||
// Wait for transfer complete flag
|
||||
while(!LL_USART_IsActiveFlag_TC(USART1))
|
||||
;
|
||||
LL_USART_Disable(USART1);
|
||||
uint32_t uartclk = LL_RCC_GetUSARTClockFreq(LL_RCC_USART1_CLKSOURCE);
|
||||
LL_USART_SetBaudRate(
|
||||
USART1, uartclk, LL_USART_PRESCALER_DIV1, LL_USART_OVERSAMPLING_16, baud);
|
||||
LL_USART_Enable(USART1);
|
||||
}
|
||||
} else if(ch == FuriHalUartIdLPUART1) {
|
||||
if(LL_LPUART_IsEnabled(LPUART1)) {
|
||||
// Wait for transfer complete flag
|
||||
while(!LL_LPUART_IsActiveFlag_TC(LPUART1))
|
||||
;
|
||||
LL_LPUART_Disable(LPUART1);
|
||||
uint32_t uartclk = LL_RCC_GetLPUARTClockFreq(LL_RCC_LPUART1_CLKSOURCE);
|
||||
if(uartclk / baud > 4095) {
|
||||
LL_LPUART_SetPrescaler(LPUART1, LL_LPUART_PRESCALER_DIV32);
|
||||
LL_LPUART_SetBaudRate(LPUART1, uartclk, LL_LPUART_PRESCALER_DIV32, baud);
|
||||
} else {
|
||||
LL_LPUART_SetPrescaler(LPUART1, LL_LPUART_PRESCALER_DIV1);
|
||||
LL_LPUART_SetBaudRate(LPUART1, uartclk, LL_LPUART_PRESCALER_DIV1, baud);
|
||||
}
|
||||
LL_LPUART_Enable(LPUART1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_uart_deinit(FuriHalUartId ch) {
|
||||
furi_hal_uart_set_irq_cb(ch, NULL, NULL);
|
||||
if(ch == FuriHalUartIdUSART1) {
|
||||
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) {
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_uart_suspend(FuriHalUartId channel) {
|
||||
if(channel == FuriHalUartIdLPUART1 && LL_LPUART_IsEnabled(LPUART1)) {
|
||||
LL_LPUART_Disable(LPUART1);
|
||||
furi_hal_usart_prev_enabled[channel] = true;
|
||||
} else if(channel == FuriHalUartIdUSART1 && LL_USART_IsEnabled(USART1)) {
|
||||
LL_USART_Disable(USART1);
|
||||
furi_hal_usart_prev_enabled[channel] = true;
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_uart_resume(FuriHalUartId channel) {
|
||||
if(!furi_hal_usart_prev_enabled[channel]) {
|
||||
return;
|
||||
} else if(channel == FuriHalUartIdLPUART1) {
|
||||
LL_LPUART_Enable(LPUART1);
|
||||
} else if(channel == FuriHalUartIdUSART1) {
|
||||
LL_USART_Enable(USART1);
|
||||
}
|
||||
|
||||
furi_hal_usart_prev_enabled[channel] = false;
|
||||
}
|
||||
|
||||
void furi_hal_uart_tx(FuriHalUartId ch, uint8_t* buffer, size_t buffer_size) {
|
||||
if(ch == FuriHalUartIdUSART1) {
|
||||
if(LL_USART_IsEnabled(USART1) == 0) return;
|
||||
|
||||
while(buffer_size > 0) {
|
||||
while(!LL_USART_IsActiveFlag_TXE(USART1))
|
||||
;
|
||||
|
||||
LL_USART_TransmitData8(USART1, *buffer);
|
||||
buffer++;
|
||||
buffer_size--;
|
||||
}
|
||||
|
||||
} else if(ch == FuriHalUartIdLPUART1) {
|
||||
if(LL_LPUART_IsEnabled(LPUART1) == 0) return;
|
||||
|
||||
while(buffer_size > 0) {
|
||||
while(!LL_LPUART_IsActiveFlag_TXE(LPUART1))
|
||||
;
|
||||
|
||||
LL_LPUART_TransmitData8(LPUART1, *buffer);
|
||||
|
||||
buffer++;
|
||||
buffer_size--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_uart_set_irq_cb(
|
||||
FuriHalUartId ch,
|
||||
void (*cb)(UartIrqEvent ev, uint8_t data, void* ctx),
|
||||
void* ctx) {
|
||||
if(cb == NULL) {
|
||||
if(ch == FuriHalUartIdUSART1) {
|
||||
NVIC_DisableIRQ(USART1_IRQn);
|
||||
LL_USART_DisableIT_RXNE_RXFNE(USART1);
|
||||
} else if(ch == FuriHalUartIdLPUART1) {
|
||||
NVIC_DisableIRQ(LPUART1_IRQn);
|
||||
LL_LPUART_DisableIT_RXNE_RXFNE(LPUART1);
|
||||
}
|
||||
irq_cb[ch] = cb;
|
||||
irq_ctx[ch] = ctx;
|
||||
} else {
|
||||
irq_ctx[ch] = ctx;
|
||||
irq_cb[ch] = cb;
|
||||
if(ch == FuriHalUartIdUSART1) {
|
||||
NVIC_EnableIRQ(USART1_IRQn);
|
||||
LL_USART_EnableIT_RXNE_RXFNE(USART1);
|
||||
} else if(ch == FuriHalUartIdLPUART1) {
|
||||
NVIC_EnableIRQ(LPUART1_IRQn);
|
||||
LL_LPUART_EnableIT_RXNE_RXFNE(LPUART1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LPUART1_IRQHandler(void) {
|
||||
if(LL_LPUART_IsActiveFlag_RXNE_RXFNE(LPUART1)) {
|
||||
uint8_t data = LL_LPUART_ReceiveData8(LPUART1);
|
||||
irq_cb[FuriHalUartIdLPUART1](UartIrqEventRXNE, data, irq_ctx[FuriHalUartIdLPUART1]);
|
||||
} else if(LL_LPUART_IsActiveFlag_ORE(LPUART1)) {
|
||||
LL_LPUART_ClearFlag_ORE(LPUART1);
|
||||
}
|
||||
}
|
||||
|
||||
void USART1_IRQHandler(void) {
|
||||
if(LL_USART_IsActiveFlag_RXNE_RXFNE(USART1)) {
|
||||
uint8_t data = LL_USART_ReceiveData8(USART1);
|
||||
irq_cb[FuriHalUartIdUSART1](UartIrqEventRXNE, data, irq_ctx[FuriHalUartIdUSART1]);
|
||||
} else if(LL_USART_IsActiveFlag_ORE(USART1)) {
|
||||
LL_USART_ClearFlag_ORE(USART1);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
/**
|
||||
* @file furi_hal_uart.h
|
||||
* @version 1.0
|
||||
* @date 2021-11-19
|
||||
*
|
||||
* UART HAL api interface
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* UART channels
|
||||
*/
|
||||
typedef enum {
|
||||
FuriHalUartIdUSART1,
|
||||
FuriHalUartIdLPUART1,
|
||||
} FuriHalUartId;
|
||||
|
||||
/**
|
||||
* UART events
|
||||
*/
|
||||
typedef enum {
|
||||
UartIrqEventRXNE,
|
||||
} UartIrqEvent;
|
||||
|
||||
/**
|
||||
* Init UART
|
||||
* Configures GPIO to UART function, сonfigures UART hardware, enables UART hardware
|
||||
* @param channel UART channel
|
||||
* @param baud baudrate
|
||||
*/
|
||||
void furi_hal_uart_init(FuriHalUartId channel, uint32_t baud);
|
||||
|
||||
/**
|
||||
* Deinit UART
|
||||
* Configures GPIO to analog, clears callback and callback context, disables UART hardware
|
||||
* @param channel UART channel
|
||||
*/
|
||||
void furi_hal_uart_deinit(FuriHalUartId channel);
|
||||
|
||||
/**
|
||||
* Suspend UART operation
|
||||
* Disables UART hardware, settings and callbacks are preserved
|
||||
* @param channel UART channel
|
||||
*/
|
||||
void furi_hal_uart_suspend(FuriHalUartId channel);
|
||||
|
||||
/**
|
||||
* Resume UART operation
|
||||
* Resumes UART hardware from suspended state
|
||||
* @param channel UART channel
|
||||
*/
|
||||
void furi_hal_uart_resume(FuriHalUartId channel);
|
||||
|
||||
/**
|
||||
* Changes UART baudrate
|
||||
* @param channel UART channel
|
||||
* @param baud baudrate
|
||||
*/
|
||||
void furi_hal_uart_set_br(FuriHalUartId channel, uint32_t baud);
|
||||
|
||||
/**
|
||||
* Transmits data
|
||||
* @param channel UART channel
|
||||
* @param buffer data
|
||||
* @param buffer_size data size (in bytes)
|
||||
*/
|
||||
void furi_hal_uart_tx(FuriHalUartId channel, uint8_t* buffer, size_t buffer_size);
|
||||
|
||||
/**
|
||||
* Sets UART event callback
|
||||
* @param channel UART channel
|
||||
* @param callback callback pointer
|
||||
* @param context callback context
|
||||
*/
|
||||
void furi_hal_uart_set_irq_cb(
|
||||
FuriHalUartId channel,
|
||||
void (*callback)(UartIrqEvent event, uint8_t data, void* context),
|
||||
void* context);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,480 @@
|
||||
#include <furi_hal_version.h>
|
||||
#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>
|
||||
|
||||
#include "usb.h"
|
||||
|
||||
#define TAG "FuriHalUsb"
|
||||
|
||||
#define USB_RECONNECT_DELAY 500
|
||||
|
||||
typedef enum {
|
||||
UsbApiEventTypeSetConfig,
|
||||
UsbApiEventTypeGetConfig,
|
||||
UsbApiEventTypeLock,
|
||||
UsbApiEventTypeUnlock,
|
||||
UsbApiEventTypeIsLocked,
|
||||
UsbApiEventTypeEnable,
|
||||
UsbApiEventTypeDisable,
|
||||
UsbApiEventTypeReinit,
|
||||
UsbApiEventTypeSetStateCallback,
|
||||
} UsbApiEventType;
|
||||
|
||||
typedef struct {
|
||||
FuriHalUsbStateCallback callback;
|
||||
void* context;
|
||||
} UsbApiEventDataStateCallback;
|
||||
|
||||
typedef struct {
|
||||
FuriHalUsbInterface* interface;
|
||||
void* context;
|
||||
} UsbApiEventDataInterface;
|
||||
|
||||
typedef union {
|
||||
UsbApiEventDataStateCallback state_callback;
|
||||
UsbApiEventDataInterface interface;
|
||||
} UsbApiEventData;
|
||||
|
||||
typedef union {
|
||||
bool bool_value;
|
||||
void* void_value;
|
||||
} UsbApiEventReturnData;
|
||||
|
||||
typedef struct {
|
||||
FuriApiLock lock;
|
||||
UsbApiEventType type;
|
||||
UsbApiEventData data;
|
||||
UsbApiEventReturnData* return_data;
|
||||
} UsbApiEventMessage;
|
||||
|
||||
typedef struct {
|
||||
FuriThread* thread;
|
||||
FuriMessageQueue* queue;
|
||||
bool enabled;
|
||||
bool connected;
|
||||
bool mode_lock;
|
||||
bool request_pending;
|
||||
FuriHalUsbInterface* interface;
|
||||
void* interface_context;
|
||||
FuriHalUsbStateCallback callback;
|
||||
void* callback_context;
|
||||
} UsbSrv;
|
||||
|
||||
typedef enum {
|
||||
UsbEventReset = (1 << 0),
|
||||
UsbEventRequest = (1 << 1),
|
||||
UsbEventMessage = (1 << 2),
|
||||
} UsbEvent;
|
||||
|
||||
#define USB_SRV_ALL_EVENTS (UsbEventReset | UsbEventRequest | UsbEventMessage)
|
||||
|
||||
PLACE_IN_SECTION("MB_MEM2") static UsbSrv usb = {0};
|
||||
PLACE_IN_SECTION("MB_MEM2") static uint32_t ubuf[0x20];
|
||||
PLACE_IN_SECTION("MB_MEM2") usbd_device udev;
|
||||
|
||||
static const struct usb_string_descriptor dev_lang_desc = USB_ARRAY_DESC(USB_LANGID_ENG_US);
|
||||
|
||||
static int32_t furi_hal_usb_thread(void* context);
|
||||
static usbd_respond usb_descriptor_get(usbd_ctlreq* req, void** address, uint16_t* length);
|
||||
static void reset_evt(usbd_device* dev, uint8_t event, uint8_t ep);
|
||||
static void susp_evt(usbd_device* dev, uint8_t event, uint8_t ep);
|
||||
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();
|
||||
|
||||
GPIO_InitStruct.Pin = LL_GPIO_PIN_11 | LL_GPIO_PIN_12;
|
||||
GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
|
||||
GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH;
|
||||
GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
|
||||
GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
|
||||
GPIO_InitStruct.Alternate = LL_GPIO_AF_10;
|
||||
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);
|
||||
usbd_reg_event(&udev, usbd_evt_wkup, wkup_evt);
|
||||
// Reset callback will be enabled after first mode change to avoid getting false reset events
|
||||
|
||||
usb.enabled = false;
|
||||
usb.interface = NULL;
|
||||
NVIC_SetPriority(USB_LP_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 5, 0));
|
||||
NVIC_SetPriority(USB_HP_IRQn, NVIC_EncodePriority(NVIC_GetPriorityGrouping(), 15, 0));
|
||||
NVIC_EnableIRQ(USB_LP_IRQn);
|
||||
NVIC_EnableIRQ(USB_HP_IRQn);
|
||||
|
||||
usb.queue = furi_message_queue_alloc(1, sizeof(UsbApiEventMessage));
|
||||
usb.thread = furi_thread_alloc_ex("UsbDriver", 1024, furi_hal_usb_thread, NULL);
|
||||
furi_thread_mark_as_service(usb.thread);
|
||||
furi_thread_start(usb.thread);
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
static void furi_hal_usb_send_message(UsbApiEventMessage* message) {
|
||||
furi_message_queue_put(usb.queue, message, FuriWaitForever);
|
||||
furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventMessage);
|
||||
api_lock_wait_unlock_and_free(message->lock);
|
||||
}
|
||||
|
||||
bool furi_hal_usb_set_config(FuriHalUsbInterface* new_if, void* ctx) {
|
||||
UsbApiEventReturnData return_data = {
|
||||
.bool_value = false,
|
||||
};
|
||||
|
||||
UsbApiEventMessage msg = {
|
||||
.lock = api_lock_alloc_locked(),
|
||||
.type = UsbApiEventTypeSetConfig,
|
||||
.data.interface =
|
||||
{
|
||||
.interface = new_if,
|
||||
.context = ctx,
|
||||
},
|
||||
.return_data = &return_data,
|
||||
};
|
||||
|
||||
furi_hal_usb_send_message(&msg);
|
||||
return return_data.bool_value;
|
||||
}
|
||||
|
||||
FuriHalUsbInterface* furi_hal_usb_get_config() {
|
||||
UsbApiEventReturnData return_data = {
|
||||
.void_value = NULL,
|
||||
};
|
||||
|
||||
UsbApiEventMessage msg = {
|
||||
.lock = api_lock_alloc_locked(),
|
||||
.type = UsbApiEventTypeGetConfig,
|
||||
.return_data = &return_data,
|
||||
};
|
||||
|
||||
furi_hal_usb_send_message(&msg);
|
||||
return return_data.void_value;
|
||||
}
|
||||
|
||||
void furi_hal_usb_lock() {
|
||||
UsbApiEventMessage msg = {
|
||||
.lock = api_lock_alloc_locked(),
|
||||
.type = UsbApiEventTypeLock,
|
||||
};
|
||||
|
||||
furi_hal_usb_send_message(&msg);
|
||||
}
|
||||
|
||||
void furi_hal_usb_unlock() {
|
||||
UsbApiEventMessage msg = {
|
||||
.lock = api_lock_alloc_locked(),
|
||||
.type = UsbApiEventTypeUnlock,
|
||||
};
|
||||
|
||||
furi_hal_usb_send_message(&msg);
|
||||
}
|
||||
|
||||
bool furi_hal_usb_is_locked() {
|
||||
UsbApiEventReturnData return_data = {
|
||||
.bool_value = false,
|
||||
};
|
||||
|
||||
UsbApiEventMessage msg = {
|
||||
.lock = api_lock_alloc_locked(),
|
||||
.type = UsbApiEventTypeIsLocked,
|
||||
.return_data = &return_data,
|
||||
};
|
||||
|
||||
furi_hal_usb_send_message(&msg);
|
||||
return return_data.bool_value;
|
||||
}
|
||||
|
||||
void furi_hal_usb_disable() {
|
||||
UsbApiEventMessage msg = {
|
||||
.lock = api_lock_alloc_locked(),
|
||||
.type = UsbApiEventTypeDisable,
|
||||
};
|
||||
|
||||
furi_hal_usb_send_message(&msg);
|
||||
}
|
||||
|
||||
void furi_hal_usb_enable() {
|
||||
UsbApiEventMessage msg = {
|
||||
.lock = api_lock_alloc_locked(),
|
||||
.type = UsbApiEventTypeEnable,
|
||||
};
|
||||
|
||||
furi_hal_usb_send_message(&msg);
|
||||
}
|
||||
|
||||
void furi_hal_usb_reinit() {
|
||||
UsbApiEventMessage msg = {
|
||||
.lock = api_lock_alloc_locked(),
|
||||
.type = UsbApiEventTypeReinit,
|
||||
};
|
||||
|
||||
furi_hal_usb_send_message(&msg);
|
||||
}
|
||||
|
||||
void furi_hal_usb_set_state_callback(FuriHalUsbStateCallback cb, void* ctx) {
|
||||
UsbApiEventMessage msg = {
|
||||
.lock = api_lock_alloc_locked(),
|
||||
.type = UsbApiEventTypeSetStateCallback,
|
||||
.data.state_callback =
|
||||
{
|
||||
.callback = cb,
|
||||
.context = ctx,
|
||||
},
|
||||
};
|
||||
|
||||
furi_hal_usb_send_message(&msg);
|
||||
}
|
||||
|
||||
/* Get device / configuration descriptors */
|
||||
static usbd_respond usb_descriptor_get(usbd_ctlreq* req, void** address, uint16_t* length) {
|
||||
const uint8_t dtype = req->wValue >> 8;
|
||||
const uint8_t dnumber = req->wValue & 0xFF;
|
||||
const void* desc;
|
||||
uint16_t len = 0;
|
||||
if(usb.interface == NULL) return usbd_fail;
|
||||
|
||||
switch(dtype) {
|
||||
case USB_DTYPE_DEVICE:
|
||||
furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventRequest);
|
||||
if(usb.callback != NULL) {
|
||||
usb.callback(FuriHalUsbStateEventDescriptorRequest, usb.callback_context);
|
||||
}
|
||||
desc = usb.interface->dev_descr;
|
||||
break;
|
||||
case USB_DTYPE_CONFIGURATION:
|
||||
desc = usb.interface->cfg_descr;
|
||||
len = ((struct usb_string_descriptor*)(usb.interface->cfg_descr))->wString[0];
|
||||
break;
|
||||
case USB_DTYPE_STRING:
|
||||
if(dnumber == UsbDevLang) {
|
||||
desc = &dev_lang_desc;
|
||||
} else if((dnumber == UsbDevManuf) && (usb.interface->str_manuf_descr != NULL)) {
|
||||
desc = usb.interface->str_manuf_descr;
|
||||
} else if((dnumber == UsbDevProduct) && (usb.interface->str_prod_descr != NULL)) {
|
||||
desc = usb.interface->str_prod_descr;
|
||||
} else if((dnumber == UsbDevSerial) && (usb.interface->str_serial_descr != NULL)) {
|
||||
desc = usb.interface->str_serial_descr;
|
||||
} else
|
||||
return usbd_fail;
|
||||
break;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
if(desc == NULL) return usbd_fail;
|
||||
|
||||
if(len == 0) {
|
||||
len = ((struct usb_header_descriptor*)desc)->bLength;
|
||||
}
|
||||
*address = (void*)desc;
|
||||
*length = len;
|
||||
return usbd_ack;
|
||||
}
|
||||
|
||||
static void reset_evt(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
UNUSED(event);
|
||||
UNUSED(ep);
|
||||
furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventReset);
|
||||
if(usb.callback != NULL) {
|
||||
usb.callback(FuriHalUsbStateEventReset, usb.callback_context);
|
||||
}
|
||||
}
|
||||
|
||||
static void susp_evt(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
UNUSED(event);
|
||||
UNUSED(ep);
|
||||
if((usb.interface != NULL) && (usb.connected == true)) {
|
||||
usb.connected = false;
|
||||
usb.interface->suspend(&udev);
|
||||
|
||||
furi_hal_power_insomnia_exit();
|
||||
}
|
||||
if(usb.callback != NULL) {
|
||||
usb.callback(FuriHalUsbStateEventSuspend, usb.callback_context);
|
||||
}
|
||||
}
|
||||
|
||||
static void wkup_evt(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
UNUSED(event);
|
||||
UNUSED(ep);
|
||||
if((usb.interface != NULL) && (usb.connected == false)) {
|
||||
usb.connected = true;
|
||||
usb.interface->wakeup(&udev);
|
||||
|
||||
furi_hal_power_insomnia_enter();
|
||||
}
|
||||
if(usb.callback != NULL) {
|
||||
usb.callback(FuriHalUsbStateEventWakeup, usb.callback_context);
|
||||
}
|
||||
}
|
||||
|
||||
static void usb_process_mode_start(FuriHalUsbInterface* interface, void* context) {
|
||||
if(usb.interface != NULL) {
|
||||
usb.interface->deinit(&udev);
|
||||
}
|
||||
|
||||
__disable_irq();
|
||||
usb.interface = interface;
|
||||
usb.interface_context = context;
|
||||
__enable_irq();
|
||||
|
||||
if(interface != NULL) {
|
||||
interface->init(&udev, interface, context);
|
||||
usbd_reg_event(&udev, usbd_evt_reset, reset_evt);
|
||||
FURI_LOG_I(TAG, "USB Mode change done");
|
||||
usb.enabled = true;
|
||||
}
|
||||
}
|
||||
|
||||
static void usb_process_mode_change(FuriHalUsbInterface* interface, void* context) {
|
||||
if((interface != usb.interface) || (context != usb.interface_context)) {
|
||||
if(usb.enabled) {
|
||||
// Disable current interface
|
||||
susp_evt(&udev, 0, 0);
|
||||
usbd_connect(&udev, false);
|
||||
usb.enabled = false;
|
||||
furi_delay_ms(USB_RECONNECT_DELAY);
|
||||
}
|
||||
usb_process_mode_start(interface, context);
|
||||
}
|
||||
}
|
||||
|
||||
static void usb_process_mode_reinit() {
|
||||
// Temporary disable callback to avoid getting false reset events
|
||||
usbd_reg_event(&udev, usbd_evt_reset, NULL);
|
||||
FURI_LOG_I(TAG, "USB Reinit");
|
||||
susp_evt(&udev, 0, 0);
|
||||
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);
|
||||
}
|
||||
|
||||
static bool usb_process_set_config(FuriHalUsbInterface* interface, void* context) {
|
||||
if(usb.mode_lock) {
|
||||
return false;
|
||||
} else {
|
||||
usb_process_mode_change(interface, context);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
static void usb_process_enable(bool enable) {
|
||||
if(enable) {
|
||||
if((!usb.enabled) && (usb.interface != NULL)) {
|
||||
usbd_connect(&udev, true);
|
||||
usb.enabled = true;
|
||||
FURI_LOG_I(TAG, "USB Enable");
|
||||
}
|
||||
} else {
|
||||
if(usb.enabled) {
|
||||
susp_evt(&udev, 0, 0);
|
||||
usbd_connect(&udev, false);
|
||||
usb.enabled = false;
|
||||
usb.request_pending = false;
|
||||
FURI_LOG_I(TAG, "USB Disable");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void usb_process_message(UsbApiEventMessage* message) {
|
||||
switch(message->type) {
|
||||
case UsbApiEventTypeSetConfig:
|
||||
message->return_data->bool_value = usb_process_set_config(
|
||||
message->data.interface.interface, message->data.interface.context);
|
||||
break;
|
||||
case UsbApiEventTypeGetConfig:
|
||||
message->return_data->void_value = usb.interface;
|
||||
break;
|
||||
case UsbApiEventTypeLock:
|
||||
FURI_LOG_I(TAG, "Mode lock");
|
||||
usb.mode_lock = true;
|
||||
break;
|
||||
case UsbApiEventTypeUnlock:
|
||||
FURI_LOG_I(TAG, "Mode unlock");
|
||||
usb.mode_lock = false;
|
||||
break;
|
||||
case UsbApiEventTypeIsLocked:
|
||||
message->return_data->bool_value = usb.mode_lock;
|
||||
break;
|
||||
case UsbApiEventTypeDisable:
|
||||
usb_process_enable(false);
|
||||
break;
|
||||
case UsbApiEventTypeEnable:
|
||||
usb_process_enable(true);
|
||||
break;
|
||||
case UsbApiEventTypeReinit:
|
||||
usb_process_mode_reinit();
|
||||
break;
|
||||
case UsbApiEventTypeSetStateCallback:
|
||||
usb.callback = message->data.state_callback.callback;
|
||||
usb.callback_context = message->data.state_callback.context;
|
||||
break;
|
||||
}
|
||||
|
||||
api_lock_unlock(message->lock);
|
||||
}
|
||||
|
||||
static int32_t furi_hal_usb_thread(void* context) {
|
||||
UNUSED(context);
|
||||
uint8_t usb_wait_time = 0;
|
||||
|
||||
if(furi_message_queue_get_count(usb.queue) > 0) {
|
||||
furi_thread_flags_set(furi_thread_get_id(usb.thread), UsbEventMessage);
|
||||
}
|
||||
|
||||
while(true) {
|
||||
uint32_t flags = furi_thread_flags_wait(USB_SRV_ALL_EVENTS, FuriFlagWaitAny, 500);
|
||||
|
||||
{
|
||||
UsbApiEventMessage message;
|
||||
if(furi_message_queue_get(usb.queue, &message, 0) == FuriStatusOk) {
|
||||
usb_process_message(&message);
|
||||
}
|
||||
}
|
||||
|
||||
if((flags & FuriFlagError) == 0) {
|
||||
if(flags & UsbEventReset) {
|
||||
if(usb.enabled) {
|
||||
usb.request_pending = true;
|
||||
usb_wait_time = 0;
|
||||
}
|
||||
}
|
||||
if(flags & UsbEventRequest) {
|
||||
usb.request_pending = false;
|
||||
}
|
||||
} else if(usb.request_pending) {
|
||||
usb_wait_time++;
|
||||
if(usb_wait_time > 4) {
|
||||
usb_process_mode_reinit();
|
||||
usb.request_pending = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,536 @@
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_usb_i.h>
|
||||
#include <furi_hal_usb.h>
|
||||
#include <furi_hal_usb_ccid.h>
|
||||
#include <furi.h>
|
||||
|
||||
#include "usb.h"
|
||||
#include "usb_ccid.h"
|
||||
|
||||
static const uint8_t USB_DEVICE_NO_CLASS = 0x0;
|
||||
static const uint8_t USB_DEVICE_NO_SUBCLASS = 0x0;
|
||||
static const uint8_t USB_DEVICE_NO_PROTOCOL = 0x0;
|
||||
|
||||
#define FIXED_CONTROL_ENDPOINT_SIZE 8
|
||||
#define IF_NUM_MAX 1
|
||||
|
||||
#define CCID_VID_DEFAULT 0x1234
|
||||
#define CCID_PID_DEFAULT 0xABCD
|
||||
#define CCID_TOTAL_SLOTS 1
|
||||
#define CCID_SLOT_INDEX 0
|
||||
|
||||
#define CCID_DATABLOCK_SIZE 256
|
||||
|
||||
#define ENDPOINT_DIR_IN 0x80
|
||||
#define ENDPOINT_DIR_OUT 0x00
|
||||
|
||||
#define INTERFACE_ID_CCID 0
|
||||
|
||||
#define CCID_IN_EPADDR (ENDPOINT_DIR_IN | 2)
|
||||
|
||||
/** Endpoint address of the CCID data OUT endpoint, for host-to-device data transfers. */
|
||||
#define CCID_OUT_EPADDR (ENDPOINT_DIR_OUT | 1)
|
||||
|
||||
/** Endpoint size in bytes of the CCID data being sent between IN and OUT endpoints. */
|
||||
#define CCID_EPSIZE 64
|
||||
|
||||
struct CcidIntfDescriptor {
|
||||
struct usb_interface_descriptor ccid;
|
||||
struct usb_ccid_descriptor ccid_desc;
|
||||
struct usb_endpoint_descriptor ccid_bulk_in;
|
||||
struct usb_endpoint_descriptor ccid_bulk_out;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct CcidConfigDescriptor {
|
||||
struct usb_config_descriptor config;
|
||||
struct CcidIntfDescriptor intf_0;
|
||||
} __attribute__((packed));
|
||||
|
||||
enum CCID_Features_Auto_t {
|
||||
CCID_Features_Auto_None = 0x0,
|
||||
CCID_Features_Auto_ParameterConfiguration = 0x2,
|
||||
CCID_Features_Auto_ICCActivation = 0x4,
|
||||
CCID_Features_Auto_VoltageSelection = 0x8,
|
||||
|
||||
CCID_Features_Auto_ICCClockFrequencyChange = 0x10,
|
||||
CCID_Features_Auto_ICCBaudRateChange = 0x20,
|
||||
CCID_Features_Auto_ParameterNegotiation = 0x40,
|
||||
CCID_Features_Auto_PPS = 0x80,
|
||||
};
|
||||
|
||||
enum CCID_Features_ExchangeLevel_t {
|
||||
CCID_Features_ExchangeLevel_TPDU = 0x00010000,
|
||||
CCID_Features_ExchangeLevel_ShortAPDU = 0x00020000,
|
||||
CCID_Features_ExchangeLevel_ShortExtendedAPDU = 0x00040000
|
||||
};
|
||||
|
||||
/* Device descriptor */
|
||||
static struct usb_device_descriptor ccid_device_desc = {
|
||||
.bLength = sizeof(struct usb_device_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_DEVICE,
|
||||
.bcdUSB = VERSION_BCD(2, 0, 0),
|
||||
.bDeviceClass = USB_DEVICE_NO_CLASS,
|
||||
.bDeviceSubClass = USB_DEVICE_NO_SUBCLASS,
|
||||
.bDeviceProtocol = USB_DEVICE_NO_PROTOCOL,
|
||||
.bMaxPacketSize0 = FIXED_CONTROL_ENDPOINT_SIZE,
|
||||
.idVendor = CCID_VID_DEFAULT,
|
||||
.idProduct = CCID_PID_DEFAULT,
|
||||
.bcdDevice = VERSION_BCD(1, 0, 0),
|
||||
.iManufacturer = UsbDevManuf,
|
||||
.iProduct = UsbDevProduct,
|
||||
.iSerialNumber = UsbDevSerial,
|
||||
.bNumConfigurations = 1,
|
||||
};
|
||||
|
||||
/* Device configuration descriptor*/
|
||||
static const struct CcidConfigDescriptor ccid_cfg_desc = {
|
||||
.config =
|
||||
{
|
||||
.bLength = sizeof(struct usb_config_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_CONFIGURATION,
|
||||
.wTotalLength = sizeof(struct CcidConfigDescriptor),
|
||||
.bNumInterfaces = 1,
|
||||
|
||||
.bConfigurationValue = 1,
|
||||
.iConfiguration = NO_DESCRIPTOR,
|
||||
.bmAttributes = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
|
||||
.bMaxPower = USB_CFG_POWER_MA(100),
|
||||
},
|
||||
.intf_0 =
|
||||
{
|
||||
.ccid =
|
||||
{.bLength = sizeof(struct usb_interface_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFACE,
|
||||
|
||||
.bInterfaceNumber = INTERFACE_ID_CCID,
|
||||
.bAlternateSetting = 0x00,
|
||||
.bNumEndpoints = 2,
|
||||
|
||||
.bInterfaceClass = USB_CLASS_CCID,
|
||||
.bInterfaceSubClass = 0,
|
||||
.bInterfaceProtocol = 0,
|
||||
|
||||
.iInterface = NO_DESCRIPTOR
|
||||
|
||||
},
|
||||
.ccid_desc =
|
||||
{.bLength = sizeof(struct usb_ccid_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_CCID_FUNCTIONAL,
|
||||
.bcdCCID = CCID_CURRENT_SPEC_RELEASE_NUMBER,
|
||||
.bMaxSlotIndex = 0x00,
|
||||
.bVoltageSupport = CCID_VOLTAGESUPPORT_5V,
|
||||
.dwProtocols = 0x01, //T0
|
||||
.dwDefaultClock = 16000, //16MHz
|
||||
.dwMaximumClock = 16000, //16MHz
|
||||
.bNumClockSupported = 0,
|
||||
.dwDataRate = 307200,
|
||||
.dwMaxDataRate = 307200,
|
||||
.bNumDataRatesSupported = 0,
|
||||
.dwMaxIFSD = 2038,
|
||||
.dwSynchProtocols = 0,
|
||||
.dwMechanical = 0,
|
||||
.dwFeatures = CCID_Features_ExchangeLevel_ShortAPDU |
|
||||
CCID_Features_Auto_ParameterConfiguration |
|
||||
CCID_Features_Auto_ICCActivation |
|
||||
CCID_Features_Auto_VoltageSelection,
|
||||
.dwMaxCCIDMessageLength = 0x0c00,
|
||||
.bClassGetResponse = 0xff,
|
||||
.bClassEnvelope = 0xff,
|
||||
.wLcdLayout = 0,
|
||||
.bPINSupport = 0,
|
||||
.bMaxCCIDBusySlots = 1},
|
||||
.ccid_bulk_in =
|
||||
{.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CCID_IN_EPADDR,
|
||||
.bmAttributes = USB_EPTYPE_BULK,
|
||||
.wMaxPacketSize = CCID_EPSIZE,
|
||||
.bInterval = 0x05
|
||||
|
||||
},
|
||||
.ccid_bulk_out =
|
||||
{.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CCID_OUT_EPADDR,
|
||||
.bmAttributes = USB_EPTYPE_BULK,
|
||||
.wMaxPacketSize = CCID_EPSIZE,
|
||||
.bInterval = 0x05},
|
||||
},
|
||||
};
|
||||
|
||||
static void ccid_init(usbd_device* dev, FuriHalUsbInterface* intf, void* ctx);
|
||||
static void ccid_deinit(usbd_device* dev);
|
||||
static void ccid_on_wakeup(usbd_device* dev);
|
||||
static void ccid_on_suspend(usbd_device* dev);
|
||||
|
||||
FuriHalUsbInterface usb_ccid = {
|
||||
.init = ccid_init,
|
||||
.deinit = ccid_deinit,
|
||||
.wakeup = ccid_on_wakeup,
|
||||
.suspend = ccid_on_suspend,
|
||||
|
||||
.dev_descr = (struct usb_device_descriptor*)&ccid_device_desc,
|
||||
|
||||
.str_manuf_descr = NULL,
|
||||
.str_prod_descr = NULL,
|
||||
.str_serial_descr = NULL,
|
||||
|
||||
.cfg_descr = (void*)&ccid_cfg_desc,
|
||||
};
|
||||
|
||||
static usbd_respond ccid_ep_config(usbd_device* dev, uint8_t cfg);
|
||||
static usbd_respond ccid_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback);
|
||||
static usbd_device* usb_dev;
|
||||
static bool connected = false;
|
||||
static bool smartcard_inserted = true;
|
||||
static CcidCallbacks* callbacks[CCID_TOTAL_SLOTS] = {NULL};
|
||||
|
||||
static void* ccid_set_string_descr(char* str) {
|
||||
furi_assert(str);
|
||||
|
||||
size_t len = strlen(str);
|
||||
struct usb_string_descriptor* dev_str_desc = malloc(len * 2 + 2);
|
||||
dev_str_desc->bLength = len * 2 + 2;
|
||||
dev_str_desc->bDescriptorType = USB_DTYPE_STRING;
|
||||
for(size_t i = 0; i < len; i++) dev_str_desc->wString[i] = str[i];
|
||||
|
||||
return dev_str_desc;
|
||||
}
|
||||
|
||||
static void ccid_init(usbd_device* dev, FuriHalUsbInterface* intf, void* ctx) {
|
||||
UNUSED(intf);
|
||||
|
||||
FuriHalUsbCcidConfig* cfg = (FuriHalUsbCcidConfig*)ctx;
|
||||
|
||||
usb_dev = dev;
|
||||
|
||||
usb_ccid.dev_descr->iManufacturer = 0;
|
||||
usb_ccid.dev_descr->iProduct = 0;
|
||||
usb_ccid.str_manuf_descr = NULL;
|
||||
usb_ccid.str_prod_descr = NULL;
|
||||
usb_ccid.dev_descr->idVendor = CCID_VID_DEFAULT;
|
||||
usb_ccid.dev_descr->idProduct = CCID_PID_DEFAULT;
|
||||
|
||||
if(cfg != NULL) {
|
||||
usb_ccid.dev_descr->idVendor = cfg->vid;
|
||||
usb_ccid.dev_descr->idProduct = cfg->pid;
|
||||
|
||||
if(cfg->manuf[0] != '\0') {
|
||||
usb_ccid.str_manuf_descr = ccid_set_string_descr(cfg->manuf);
|
||||
usb_ccid.dev_descr->iManufacturer = UsbDevManuf;
|
||||
}
|
||||
|
||||
if(cfg->product[0] != '\0') {
|
||||
usb_ccid.str_prod_descr = ccid_set_string_descr(cfg->product);
|
||||
usb_ccid.dev_descr->iProduct = UsbDevProduct;
|
||||
}
|
||||
}
|
||||
|
||||
usbd_reg_config(dev, ccid_ep_config);
|
||||
usbd_reg_control(dev, ccid_control);
|
||||
|
||||
usbd_connect(dev, true);
|
||||
}
|
||||
|
||||
static void ccid_deinit(usbd_device* dev) {
|
||||
usbd_reg_config(dev, NULL);
|
||||
usbd_reg_control(dev, NULL);
|
||||
|
||||
free(usb_ccid.str_prod_descr);
|
||||
free(usb_ccid.str_serial_descr);
|
||||
}
|
||||
|
||||
static void ccid_on_wakeup(usbd_device* dev) {
|
||||
UNUSED(dev);
|
||||
connected = true;
|
||||
}
|
||||
|
||||
static void ccid_on_suspend(usbd_device* dev) {
|
||||
UNUSED(dev);
|
||||
connected = false;
|
||||
}
|
||||
|
||||
typedef struct ccid_bulk_message_header {
|
||||
uint8_t bMessageType;
|
||||
uint32_t dwLength;
|
||||
uint8_t bSlot;
|
||||
uint8_t bSeq;
|
||||
} __attribute__((packed)) ccid_bulk_message_header_t;
|
||||
|
||||
uint8_t SendBuffer[sizeof(ccid_bulk_message_header_t) + CCID_DATABLOCK_SIZE];
|
||||
|
||||
//stores the data p
|
||||
uint8_t ReceiveBuffer[sizeof(ccid_bulk_message_header_t) + CCID_DATABLOCK_SIZE];
|
||||
|
||||
void CALLBACK_CCID_GetSlotStatus(
|
||||
uint8_t slot,
|
||||
uint8_t seq,
|
||||
struct rdr_to_pc_slot_status* responseSlotStatus) {
|
||||
responseSlotStatus->bMessageType = RDR_TO_PC_SLOTSTATUS;
|
||||
|
||||
responseSlotStatus->bSlot = slot;
|
||||
responseSlotStatus->bSeq = seq;
|
||||
responseSlotStatus->bClockStatus = 0;
|
||||
|
||||
responseSlotStatus->dwLength = 0;
|
||||
|
||||
if(responseSlotStatus->bSlot == CCID_SLOT_INDEX) {
|
||||
responseSlotStatus->bError = CCID_ERROR_NOERROR;
|
||||
if(smartcard_inserted) {
|
||||
responseSlotStatus->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_PRESENTANDACTIVE;
|
||||
} else {
|
||||
responseSlotStatus->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_NOICCPRESENT;
|
||||
}
|
||||
} else {
|
||||
responseSlotStatus->bError = CCID_ERROR_SLOTNOTFOUND;
|
||||
responseSlotStatus->bStatus = CCID_COMMANDSTATUS_FAILED | CCID_ICCSTATUS_NOICCPRESENT;
|
||||
}
|
||||
}
|
||||
|
||||
void CALLBACK_CCID_SetParametersT0(
|
||||
struct pc_to_rdr_set_parameters_t0* requestSetParametersT0,
|
||||
struct rdr_to_pc_parameters_t0* responseSetParametersT0) {
|
||||
furi_assert(requestSetParametersT0->bProtocolNum == 0x00); //T0
|
||||
responseSetParametersT0->bMessageType = RDR_TO_PC_PARAMETERS;
|
||||
responseSetParametersT0->bSlot = requestSetParametersT0->bSlot;
|
||||
responseSetParametersT0->bSeq = requestSetParametersT0->bSeq;
|
||||
|
||||
responseSetParametersT0->dwLength =
|
||||
sizeof(struct pc_to_rdr_set_parameters_t0) - sizeof(ccid_bulk_message_header_t);
|
||||
|
||||
if(responseSetParametersT0->bSlot == CCID_SLOT_INDEX) {
|
||||
responseSetParametersT0->bError = CCID_ERROR_NOERROR;
|
||||
if(smartcard_inserted) {
|
||||
responseSetParametersT0->bProtocolNum = requestSetParametersT0->bProtocolNum;
|
||||
responseSetParametersT0->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_PRESENTANDACTIVE;
|
||||
} else {
|
||||
responseSetParametersT0->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_NOICCPRESENT;
|
||||
}
|
||||
} else {
|
||||
responseSetParametersT0->bError = CCID_ERROR_SLOTNOTFOUND;
|
||||
responseSetParametersT0->bStatus = CCID_COMMANDSTATUS_FAILED | CCID_ICCSTATUS_NOICCPRESENT;
|
||||
}
|
||||
}
|
||||
|
||||
void CALLBACK_CCID_IccPowerOn(
|
||||
uint8_t slot,
|
||||
uint8_t seq,
|
||||
struct rdr_to_pc_data_block* responseDataBlock) {
|
||||
responseDataBlock->bMessageType = RDR_TO_PC_DATABLOCK;
|
||||
responseDataBlock->dwLength = 0;
|
||||
responseDataBlock->bSlot = slot;
|
||||
responseDataBlock->bSeq = seq;
|
||||
|
||||
if(responseDataBlock->bSlot == CCID_SLOT_INDEX) {
|
||||
responseDataBlock->bError = CCID_ERROR_NOERROR;
|
||||
if(smartcard_inserted) {
|
||||
if(callbacks[CCID_SLOT_INDEX] != NULL) {
|
||||
callbacks[CCID_SLOT_INDEX]->icc_power_on_callback(
|
||||
responseDataBlock->abData, &responseDataBlock->dwLength, NULL);
|
||||
responseDataBlock->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_PRESENTANDACTIVE;
|
||||
} else {
|
||||
responseDataBlock->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_PRESENTANDINACTIVE;
|
||||
}
|
||||
} else {
|
||||
responseDataBlock->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_NOICCPRESENT;
|
||||
}
|
||||
} else {
|
||||
responseDataBlock->bError = CCID_ERROR_SLOTNOTFOUND;
|
||||
responseDataBlock->bStatus = CCID_COMMANDSTATUS_FAILED | CCID_ICCSTATUS_NOICCPRESENT;
|
||||
}
|
||||
}
|
||||
|
||||
void CALLBACK_CCID_XfrBlock(
|
||||
struct pc_to_rdr_xfr_block* receivedXfrBlock,
|
||||
struct rdr_to_pc_data_block* responseDataBlock) {
|
||||
responseDataBlock->bMessageType = RDR_TO_PC_DATABLOCK;
|
||||
responseDataBlock->bSlot = receivedXfrBlock->bSlot;
|
||||
responseDataBlock->bSeq = receivedXfrBlock->bSeq;
|
||||
responseDataBlock->bChainParameter = 0;
|
||||
|
||||
if(responseDataBlock->bSlot == CCID_SLOT_INDEX) {
|
||||
responseDataBlock->bError = CCID_ERROR_NOERROR;
|
||||
if(smartcard_inserted) {
|
||||
if(callbacks[CCID_SLOT_INDEX] != NULL) {
|
||||
callbacks[CCID_SLOT_INDEX]->xfr_datablock_callback(
|
||||
(const uint8_t*)receivedXfrBlock->abData,
|
||||
receivedXfrBlock->dwLength,
|
||||
responseDataBlock->abData,
|
||||
&responseDataBlock->dwLength,
|
||||
NULL);
|
||||
responseDataBlock->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_PRESENTANDACTIVE;
|
||||
} else {
|
||||
responseDataBlock->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_PRESENTANDINACTIVE;
|
||||
}
|
||||
} else {
|
||||
responseDataBlock->bStatus = CCID_COMMANDSTATUS_PROCESSEDWITHOUTERROR |
|
||||
CCID_ICCSTATUS_NOICCPRESENT;
|
||||
}
|
||||
} else {
|
||||
responseDataBlock->bError = CCID_ERROR_SLOTNOTFOUND;
|
||||
responseDataBlock->bStatus = CCID_COMMANDSTATUS_FAILED | CCID_ICCSTATUS_NOICCPRESENT;
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_ccid_ccid_insert_smartcard() {
|
||||
smartcard_inserted = true;
|
||||
}
|
||||
|
||||
void furi_hal_ccid_ccid_remove_smartcard() {
|
||||
smartcard_inserted = false;
|
||||
}
|
||||
|
||||
void furi_hal_ccid_set_callbacks(CcidCallbacks* cb) {
|
||||
callbacks[CCID_SLOT_INDEX] = cb;
|
||||
}
|
||||
|
||||
static void ccid_rx_ep_callback(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
UNUSED(event);
|
||||
UNUSED(ep);
|
||||
}
|
||||
|
||||
static void ccid_tx_ep_callback(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
|
||||
if(event == usbd_evt_eprx) {
|
||||
if(connected == false) return;
|
||||
|
||||
//read initial CCID message header
|
||||
|
||||
int32_t bytes_read = usbd_ep_read(
|
||||
usb_dev, ep, &ReceiveBuffer, sizeof(ccid_bulk_message_header_t) + CCID_DATABLOCK_SIZE);
|
||||
//minimum request size is header size
|
||||
furi_assert((uint16_t)bytes_read >= sizeof(ccid_bulk_message_header_t));
|
||||
ccid_bulk_message_header_t* message = (ccid_bulk_message_header_t*)&ReceiveBuffer; //-V641
|
||||
|
||||
if(message->bMessageType == PC_TO_RDR_ICCPOWERON) {
|
||||
struct pc_to_rdr_icc_power_on* requestDataBlock =
|
||||
(struct pc_to_rdr_icc_power_on*)message; //-V641
|
||||
struct rdr_to_pc_data_block* responseDataBlock =
|
||||
(struct rdr_to_pc_data_block*)&SendBuffer;
|
||||
|
||||
CALLBACK_CCID_IccPowerOn(
|
||||
requestDataBlock->bSlot, requestDataBlock->bSeq, responseDataBlock);
|
||||
|
||||
usbd_ep_write(
|
||||
usb_dev,
|
||||
CCID_IN_EPADDR,
|
||||
responseDataBlock,
|
||||
sizeof(struct rdr_to_pc_data_block) +
|
||||
(sizeof(uint8_t) * responseDataBlock->dwLength));
|
||||
} else if(message->bMessageType == PC_TO_RDR_ICCPOWEROFF) {
|
||||
struct pc_to_rdr_icc_power_off* requestIccPowerOff =
|
||||
(struct pc_to_rdr_icc_power_off*)message; //-V641
|
||||
struct rdr_to_pc_slot_status* responseSlotStatus =
|
||||
(struct rdr_to_pc_slot_status*)&SendBuffer; //-V641
|
||||
|
||||
CALLBACK_CCID_GetSlotStatus(
|
||||
requestIccPowerOff->bSlot, requestIccPowerOff->bSeq, responseSlotStatus);
|
||||
|
||||
usbd_ep_write(
|
||||
usb_dev, CCID_IN_EPADDR, responseSlotStatus, sizeof(struct rdr_to_pc_slot_status));
|
||||
} else if(message->bMessageType == PC_TO_RDR_GETSLOTSTATUS) {
|
||||
struct pc_to_rdr_get_slot_status* requestSlotStatus =
|
||||
(struct pc_to_rdr_get_slot_status*)message; //-V641
|
||||
struct rdr_to_pc_slot_status* responseSlotStatus =
|
||||
(struct rdr_to_pc_slot_status*)&SendBuffer; //-V641
|
||||
|
||||
CALLBACK_CCID_GetSlotStatus(
|
||||
requestSlotStatus->bSlot, requestSlotStatus->bSeq, responseSlotStatus);
|
||||
|
||||
usbd_ep_write(
|
||||
usb_dev, CCID_IN_EPADDR, responseSlotStatus, sizeof(struct rdr_to_pc_slot_status));
|
||||
} else if(message->bMessageType == PC_TO_RDR_XFRBLOCK) {
|
||||
struct pc_to_rdr_xfr_block* receivedXfrBlock = (struct pc_to_rdr_xfr_block*)message;
|
||||
struct rdr_to_pc_data_block* responseDataBlock =
|
||||
(struct rdr_to_pc_data_block*)&SendBuffer;
|
||||
|
||||
furi_assert(receivedXfrBlock->dwLength <= CCID_DATABLOCK_SIZE);
|
||||
furi_assert(
|
||||
(uint16_t)bytes_read >=
|
||||
sizeof(ccid_bulk_message_header_t) + receivedXfrBlock->dwLength);
|
||||
|
||||
CALLBACK_CCID_XfrBlock(receivedXfrBlock, responseDataBlock);
|
||||
|
||||
furi_assert(responseDataBlock->dwLength <= CCID_DATABLOCK_SIZE);
|
||||
|
||||
usbd_ep_write(
|
||||
usb_dev,
|
||||
CCID_IN_EPADDR,
|
||||
responseDataBlock,
|
||||
sizeof(struct rdr_to_pc_data_block) +
|
||||
(sizeof(uint8_t) * responseDataBlock->dwLength));
|
||||
} else if(message->bMessageType == PC_TO_RDR_SETPARAMETERS) {
|
||||
struct pc_to_rdr_set_parameters_t0* requestSetParametersT0 =
|
||||
(struct pc_to_rdr_set_parameters_t0*)message; //-V641
|
||||
struct rdr_to_pc_parameters_t0* responseSetParametersT0 =
|
||||
(struct rdr_to_pc_parameters_t0*)&SendBuffer; //-V641
|
||||
|
||||
furi_assert(requestSetParametersT0->dwLength <= CCID_DATABLOCK_SIZE);
|
||||
furi_assert(
|
||||
(uint16_t)bytes_read >=
|
||||
sizeof(ccid_bulk_message_header_t) + requestSetParametersT0->dwLength);
|
||||
|
||||
CALLBACK_CCID_SetParametersT0(requestSetParametersT0, responseSetParametersT0);
|
||||
|
||||
usbd_ep_write(
|
||||
usb_dev,
|
||||
CCID_IN_EPADDR,
|
||||
responseSetParametersT0,
|
||||
sizeof(struct rdr_to_pc_parameters_t0));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Configure endpoints */
|
||||
static usbd_respond ccid_ep_config(usbd_device* dev, uint8_t cfg) {
|
||||
switch(cfg) {
|
||||
case 0:
|
||||
/* deconfiguring device */
|
||||
usbd_ep_deconfig(dev, CCID_IN_EPADDR);
|
||||
usbd_ep_deconfig(dev, CCID_OUT_EPADDR);
|
||||
usbd_reg_endpoint(dev, CCID_IN_EPADDR, 0);
|
||||
usbd_reg_endpoint(dev, CCID_OUT_EPADDR, 0);
|
||||
return usbd_ack;
|
||||
case 1:
|
||||
/* configuring device */
|
||||
usbd_ep_config(dev, CCID_IN_EPADDR, USB_EPTYPE_BULK, CCID_EPSIZE);
|
||||
usbd_ep_config(dev, CCID_OUT_EPADDR, USB_EPTYPE_BULK, CCID_EPSIZE);
|
||||
usbd_reg_endpoint(dev, CCID_IN_EPADDR, ccid_rx_ep_callback);
|
||||
usbd_reg_endpoint(dev, CCID_OUT_EPADDR, ccid_tx_ep_callback);
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
|
||||
/* Control requests handler */
|
||||
static usbd_respond ccid_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback) {
|
||||
UNUSED(callback);
|
||||
/* CDC control requests */
|
||||
if(((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
|
||||
(USB_REQ_INTERFACE | USB_REQ_CLASS) &&
|
||||
(req->wIndex == 0 || req->wIndex == 2)) {
|
||||
switch(req->bRequest) {
|
||||
case CCID_ABORT:
|
||||
return usbd_fail;
|
||||
case CCID_GET_CLOCK_FREQUENCIES:
|
||||
dev->status.data_ptr = (void*)&(ccid_cfg_desc.intf_0.ccid_desc.dwDefaultClock);
|
||||
dev->status.data_count = sizeof(ccid_cfg_desc.intf_0.ccid_desc.dwDefaultClock);
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
return usbd_fail;
|
||||
}
|
||||
@@ -0,0 +1,675 @@
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_usb_i.h>
|
||||
#include <furi_hal_usb.h>
|
||||
#include <furi_hal_usb_cdc.h>
|
||||
#include <furi.h>
|
||||
|
||||
#include "usb.h"
|
||||
#include "usb_cdc.h"
|
||||
|
||||
#define CDC0_RXD_EP 0x01
|
||||
#define CDC0_TXD_EP 0x82
|
||||
#define CDC0_NTF_EP 0x83
|
||||
|
||||
#define CDC1_RXD_EP 0x04
|
||||
#define CDC1_TXD_EP 0x85
|
||||
#define CDC1_NTF_EP 0x86
|
||||
|
||||
#define CDC_NTF_SZ 0x08
|
||||
|
||||
#define IF_NUM_MAX 2
|
||||
|
||||
struct CdcIadDescriptor {
|
||||
struct usb_iad_descriptor comm_iad;
|
||||
struct usb_interface_descriptor comm;
|
||||
struct usb_cdc_header_desc cdc_hdr;
|
||||
struct usb_cdc_call_mgmt_desc cdc_mgmt;
|
||||
struct usb_cdc_acm_desc cdc_acm;
|
||||
struct usb_cdc_union_desc cdc_union;
|
||||
struct usb_endpoint_descriptor comm_ep;
|
||||
struct usb_interface_descriptor data;
|
||||
struct usb_endpoint_descriptor data_eprx;
|
||||
struct usb_endpoint_descriptor data_eptx;
|
||||
};
|
||||
|
||||
struct CdcConfigDescriptorSingle {
|
||||
struct usb_config_descriptor config;
|
||||
struct CdcIadDescriptor iad_0;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct CdcConfigDescriptorDual {
|
||||
struct usb_config_descriptor config;
|
||||
struct CdcIadDescriptor iad_0;
|
||||
struct CdcIadDescriptor iad_1;
|
||||
} __attribute__((packed));
|
||||
|
||||
static const struct usb_string_descriptor dev_manuf_desc = USB_STRING_DESC("Flipper Devices Inc.");
|
||||
|
||||
/* Device descriptor */
|
||||
static const struct usb_device_descriptor cdc_device_desc = {
|
||||
.bLength = sizeof(struct usb_device_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_DEVICE,
|
||||
.bcdUSB = VERSION_BCD(2, 0, 0),
|
||||
.bDeviceClass = USB_CLASS_IAD,
|
||||
.bDeviceSubClass = USB_SUBCLASS_IAD,
|
||||
.bDeviceProtocol = USB_PROTO_IAD,
|
||||
.bMaxPacketSize0 = USB_EP0_SIZE,
|
||||
.idVendor = 0x0483,
|
||||
.idProduct = 0x5740,
|
||||
.bcdDevice = VERSION_BCD(1, 0, 0),
|
||||
.iManufacturer = UsbDevManuf,
|
||||
.iProduct = UsbDevProduct,
|
||||
.iSerialNumber = UsbDevSerial,
|
||||
.bNumConfigurations = 1,
|
||||
};
|
||||
|
||||
/* Device configuration descriptor - single mode*/
|
||||
static const struct CdcConfigDescriptorSingle cdc_cfg_desc_single = {
|
||||
.config =
|
||||
{
|
||||
.bLength = sizeof(struct usb_config_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_CONFIGURATION,
|
||||
.wTotalLength = sizeof(struct CdcConfigDescriptorSingle),
|
||||
.bNumInterfaces = 2,
|
||||
|
||||
.bConfigurationValue = 1,
|
||||
.iConfiguration = NO_DESCRIPTOR,
|
||||
.bmAttributes = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
|
||||
.bMaxPower = USB_CFG_POWER_MA(100),
|
||||
},
|
||||
.iad_0 =
|
||||
{
|
||||
.comm_iad =
|
||||
{
|
||||
.bLength = sizeof(struct usb_iad_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFASEASSOC,
|
||||
.bFirstInterface = 0,
|
||||
.bInterfaceCount = 2,
|
||||
.bFunctionClass = USB_CLASS_CDC,
|
||||
.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
|
||||
.bFunctionProtocol = USB_PROTO_NONE,
|
||||
.iFunction = NO_DESCRIPTOR,
|
||||
},
|
||||
.comm =
|
||||
{
|
||||
.bLength = sizeof(struct usb_interface_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFACE,
|
||||
.bInterfaceNumber = 0,
|
||||
.bAlternateSetting = 0,
|
||||
.bNumEndpoints = 1,
|
||||
.bInterfaceClass = USB_CLASS_CDC,
|
||||
.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
|
||||
.bInterfaceProtocol = USB_PROTO_NONE,
|
||||
.iInterface = NO_DESCRIPTOR,
|
||||
},
|
||||
.cdc_hdr =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_header_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_HEADER,
|
||||
.bcdCDC = VERSION_BCD(1, 1, 0),
|
||||
},
|
||||
.cdc_mgmt =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_call_mgmt_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_CALL_MANAGEMENT,
|
||||
.bmCapabilities = 0,
|
||||
.bDataInterface = 1,
|
||||
},
|
||||
.cdc_acm =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_acm_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_ACM,
|
||||
.bmCapabilities = 0,
|
||||
},
|
||||
.cdc_union =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_union_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_UNION,
|
||||
.bMasterInterface0 = 0,
|
||||
.bSlaveInterface0 = 1,
|
||||
},
|
||||
.comm_ep =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CDC0_NTF_EP,
|
||||
.bmAttributes = USB_EPTYPE_INTERRUPT,
|
||||
.wMaxPacketSize = CDC_NTF_SZ,
|
||||
.bInterval = 0xFF,
|
||||
},
|
||||
.data =
|
||||
{
|
||||
.bLength = sizeof(struct usb_interface_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFACE,
|
||||
.bInterfaceNumber = 1,
|
||||
.bAlternateSetting = 0,
|
||||
.bNumEndpoints = 2,
|
||||
.bInterfaceClass = USB_CLASS_CDC_DATA,
|
||||
.bInterfaceSubClass = USB_SUBCLASS_NONE,
|
||||
.bInterfaceProtocol = USB_PROTO_NONE,
|
||||
.iInterface = NO_DESCRIPTOR,
|
||||
},
|
||||
.data_eprx =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CDC0_RXD_EP,
|
||||
.bmAttributes = USB_EPTYPE_BULK,
|
||||
.wMaxPacketSize = CDC_DATA_SZ,
|
||||
.bInterval = 0x01,
|
||||
},
|
||||
.data_eptx =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CDC0_TXD_EP,
|
||||
.bmAttributes = USB_EPTYPE_BULK,
|
||||
.wMaxPacketSize = CDC_DATA_SZ,
|
||||
.bInterval = 0x01,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
/* Device configuration descriptor - dual mode*/
|
||||
static const struct CdcConfigDescriptorDual
|
||||
cdc_cfg_desc_dual =
|
||||
{
|
||||
.config =
|
||||
{
|
||||
.bLength = sizeof(struct usb_config_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_CONFIGURATION,
|
||||
.wTotalLength = sizeof(struct CdcConfigDescriptorDual),
|
||||
.bNumInterfaces = 4,
|
||||
|
||||
.bConfigurationValue = 1,
|
||||
.iConfiguration = NO_DESCRIPTOR,
|
||||
.bmAttributes = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
|
||||
.bMaxPower = USB_CFG_POWER_MA(100),
|
||||
},
|
||||
.iad_0 =
|
||||
{
|
||||
.comm_iad =
|
||||
{
|
||||
.bLength = sizeof(struct usb_iad_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFASEASSOC,
|
||||
.bFirstInterface = 0,
|
||||
.bInterfaceCount = 2,
|
||||
.bFunctionClass = USB_CLASS_CDC,
|
||||
.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
|
||||
.bFunctionProtocol = USB_PROTO_NONE,
|
||||
.iFunction = NO_DESCRIPTOR,
|
||||
},
|
||||
.comm =
|
||||
{
|
||||
.bLength = sizeof(struct usb_interface_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFACE,
|
||||
.bInterfaceNumber = 0,
|
||||
.bAlternateSetting = 0,
|
||||
.bNumEndpoints = 1,
|
||||
.bInterfaceClass = USB_CLASS_CDC,
|
||||
.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
|
||||
.bInterfaceProtocol = USB_PROTO_NONE,
|
||||
.iInterface = NO_DESCRIPTOR,
|
||||
},
|
||||
.cdc_hdr =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_header_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_HEADER,
|
||||
.bcdCDC = VERSION_BCD(1, 1, 0),
|
||||
},
|
||||
.cdc_mgmt =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_call_mgmt_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_CALL_MANAGEMENT,
|
||||
.bmCapabilities = 0,
|
||||
.bDataInterface = 1,
|
||||
},
|
||||
.cdc_acm =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_acm_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_ACM,
|
||||
.bmCapabilities = 0,
|
||||
},
|
||||
.cdc_union =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_union_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_UNION,
|
||||
.bMasterInterface0 = 0,
|
||||
.bSlaveInterface0 = 1,
|
||||
},
|
||||
.comm_ep =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CDC0_NTF_EP,
|
||||
.bmAttributes = USB_EPTYPE_INTERRUPT,
|
||||
.wMaxPacketSize = CDC_NTF_SZ,
|
||||
.bInterval = 0xFF,
|
||||
},
|
||||
.data =
|
||||
{
|
||||
.bLength = sizeof(struct usb_interface_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFACE,
|
||||
.bInterfaceNumber = 1,
|
||||
.bAlternateSetting = 0,
|
||||
.bNumEndpoints = 2,
|
||||
.bInterfaceClass = USB_CLASS_CDC_DATA,
|
||||
.bInterfaceSubClass = USB_SUBCLASS_NONE,
|
||||
.bInterfaceProtocol = USB_PROTO_NONE,
|
||||
.iInterface = NO_DESCRIPTOR,
|
||||
},
|
||||
.data_eprx =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CDC0_RXD_EP,
|
||||
.bmAttributes = USB_EPTYPE_BULK,
|
||||
.wMaxPacketSize = CDC_DATA_SZ,
|
||||
.bInterval = 0x01,
|
||||
},
|
||||
.data_eptx =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CDC0_TXD_EP,
|
||||
.bmAttributes = USB_EPTYPE_BULK,
|
||||
.wMaxPacketSize = CDC_DATA_SZ,
|
||||
.bInterval = 0x01,
|
||||
},
|
||||
},
|
||||
.iad_1 =
|
||||
{
|
||||
.comm_iad =
|
||||
{
|
||||
.bLength = sizeof(struct usb_iad_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFASEASSOC,
|
||||
.bFirstInterface = 2,
|
||||
.bInterfaceCount = 2,
|
||||
.bFunctionClass = USB_CLASS_CDC,
|
||||
.bFunctionSubClass = USB_CDC_SUBCLASS_ACM,
|
||||
.bFunctionProtocol = USB_PROTO_NONE,
|
||||
.iFunction = NO_DESCRIPTOR,
|
||||
},
|
||||
.comm =
|
||||
{
|
||||
.bLength = sizeof(struct usb_interface_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFACE,
|
||||
.bInterfaceNumber = 2 + 0,
|
||||
.bAlternateSetting = 0,
|
||||
.bNumEndpoints = 1,
|
||||
.bInterfaceClass = USB_CLASS_CDC,
|
||||
.bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
|
||||
.bInterfaceProtocol = USB_PROTO_NONE,
|
||||
.iInterface = NO_DESCRIPTOR,
|
||||
},
|
||||
.cdc_hdr =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_header_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_HEADER,
|
||||
.bcdCDC = VERSION_BCD(1, 1, 0),
|
||||
},
|
||||
.cdc_mgmt =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_call_mgmt_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_CALL_MANAGEMENT,
|
||||
.bmCapabilities = 0,
|
||||
.bDataInterface = 2 + 1,
|
||||
},
|
||||
.cdc_acm =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_acm_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_ACM,
|
||||
.bmCapabilities = 0,
|
||||
},
|
||||
.cdc_union =
|
||||
{
|
||||
.bFunctionLength = sizeof(struct usb_cdc_union_desc),
|
||||
.bDescriptorType = USB_DTYPE_CS_INTERFACE,
|
||||
.bDescriptorSubType = USB_DTYPE_CDC_UNION,
|
||||
.bMasterInterface0 = 2 + 0,
|
||||
.bSlaveInterface0 = 2 + 1,
|
||||
},
|
||||
.comm_ep =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CDC1_NTF_EP,
|
||||
.bmAttributes = USB_EPTYPE_INTERRUPT,
|
||||
.wMaxPacketSize = CDC_NTF_SZ,
|
||||
.bInterval = 0xFF,
|
||||
},
|
||||
.data =
|
||||
{
|
||||
.bLength = sizeof(struct usb_interface_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFACE,
|
||||
.bInterfaceNumber = 2 + 1,
|
||||
.bAlternateSetting = 0,
|
||||
.bNumEndpoints = 2,
|
||||
.bInterfaceClass = USB_CLASS_CDC_DATA,
|
||||
.bInterfaceSubClass = USB_SUBCLASS_NONE,
|
||||
.bInterfaceProtocol = USB_PROTO_NONE,
|
||||
.iInterface = NO_DESCRIPTOR,
|
||||
},
|
||||
.data_eprx =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CDC1_RXD_EP,
|
||||
.bmAttributes = USB_EPTYPE_BULK,
|
||||
.wMaxPacketSize = CDC_DATA_SZ,
|
||||
.bInterval = 0x01,
|
||||
},
|
||||
.data_eptx =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = CDC1_TXD_EP,
|
||||
.bmAttributes = USB_EPTYPE_BULK,
|
||||
.wMaxPacketSize = CDC_DATA_SZ,
|
||||
.bInterval = 0x01,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
static struct usb_cdc_line_coding cdc_config[IF_NUM_MAX] = {};
|
||||
static uint8_t cdc_ctrl_line_state[IF_NUM_MAX];
|
||||
|
||||
static void cdc_init(usbd_device* dev, FuriHalUsbInterface* intf, void* ctx);
|
||||
static void cdc_deinit(usbd_device* dev);
|
||||
static void cdc_on_wakeup(usbd_device* dev);
|
||||
static void cdc_on_suspend(usbd_device* dev);
|
||||
|
||||
static usbd_respond cdc_ep_config(usbd_device* dev, uint8_t cfg);
|
||||
static usbd_respond cdc_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback);
|
||||
static usbd_device* usb_dev;
|
||||
static FuriHalUsbInterface* cdc_if_cur = NULL;
|
||||
static bool connected = false;
|
||||
static CdcCallbacks* callbacks[IF_NUM_MAX] = {NULL};
|
||||
static void* cb_ctx[IF_NUM_MAX];
|
||||
|
||||
FuriHalUsbInterface usb_cdc_single = {
|
||||
.init = cdc_init,
|
||||
.deinit = cdc_deinit,
|
||||
.wakeup = cdc_on_wakeup,
|
||||
.suspend = cdc_on_suspend,
|
||||
|
||||
.dev_descr = (struct usb_device_descriptor*)&cdc_device_desc,
|
||||
|
||||
.str_manuf_descr = (void*)&dev_manuf_desc,
|
||||
.str_prod_descr = NULL,
|
||||
.str_serial_descr = NULL,
|
||||
|
||||
.cfg_descr = (void*)&cdc_cfg_desc_single,
|
||||
};
|
||||
|
||||
FuriHalUsbInterface usb_cdc_dual = {
|
||||
.init = cdc_init,
|
||||
.deinit = cdc_deinit,
|
||||
.wakeup = cdc_on_wakeup,
|
||||
.suspend = cdc_on_suspend,
|
||||
|
||||
.dev_descr = (struct usb_device_descriptor*)&cdc_device_desc,
|
||||
|
||||
.str_manuf_descr = (void*)&dev_manuf_desc,
|
||||
.str_prod_descr = NULL,
|
||||
.str_serial_descr = NULL,
|
||||
|
||||
.cfg_descr = (void*)&cdc_cfg_desc_dual,
|
||||
};
|
||||
|
||||
static void cdc_init(usbd_device* dev, FuriHalUsbInterface* intf, void* ctx) {
|
||||
UNUSED(ctx);
|
||||
usb_dev = dev;
|
||||
cdc_if_cur = intf;
|
||||
|
||||
char* name = (char*)furi_hal_version_get_device_name_ptr();
|
||||
uint8_t len = (name == NULL) ? (0) : (strlen(name));
|
||||
struct usb_string_descriptor* dev_prod_desc = malloc(len * 2 + 2);
|
||||
dev_prod_desc->bLength = len * 2 + 2;
|
||||
dev_prod_desc->bDescriptorType = USB_DTYPE_STRING;
|
||||
for(uint8_t i = 0; i < len; i++) dev_prod_desc->wString[i] = name[i];
|
||||
|
||||
name = (char*)furi_hal_version_get_name_ptr();
|
||||
len = (name == NULL) ? (0) : (strlen(name));
|
||||
struct usb_string_descriptor* dev_serial_desc = malloc((len + 5) * 2 + 2);
|
||||
dev_serial_desc->bLength = (len + 5) * 2 + 2;
|
||||
dev_serial_desc->bDescriptorType = USB_DTYPE_STRING;
|
||||
memcpy(dev_serial_desc->wString, "f\0l\0i\0p\0_\0", 5 * 2);
|
||||
for(uint8_t i = 0; i < len; i++) dev_serial_desc->wString[i + 5] = name[i];
|
||||
|
||||
cdc_if_cur->str_prod_descr = dev_prod_desc;
|
||||
cdc_if_cur->str_serial_descr = dev_serial_desc;
|
||||
|
||||
usbd_reg_config(dev, cdc_ep_config);
|
||||
usbd_reg_control(dev, cdc_control);
|
||||
|
||||
usbd_connect(dev, true);
|
||||
}
|
||||
|
||||
static void cdc_deinit(usbd_device* dev) {
|
||||
usbd_reg_config(dev, NULL);
|
||||
usbd_reg_control(dev, NULL);
|
||||
|
||||
free(cdc_if_cur->str_prod_descr);
|
||||
free(cdc_if_cur->str_serial_descr);
|
||||
|
||||
cdc_if_cur = NULL;
|
||||
}
|
||||
|
||||
void furi_hal_cdc_set_callbacks(uint8_t if_num, CdcCallbacks* cb, void* context) {
|
||||
furi_assert(if_num < IF_NUM_MAX);
|
||||
|
||||
if(callbacks[if_num] != NULL) {
|
||||
if(callbacks[if_num]->state_callback != NULL) {
|
||||
if(connected == true) callbacks[if_num]->state_callback(cb_ctx[if_num], 0);
|
||||
}
|
||||
}
|
||||
|
||||
callbacks[if_num] = cb;
|
||||
cb_ctx[if_num] = context;
|
||||
|
||||
if(callbacks[if_num] != NULL) {
|
||||
if(callbacks[if_num]->state_callback != NULL) {
|
||||
if(connected == true) callbacks[if_num]->state_callback(cb_ctx[if_num], 1);
|
||||
}
|
||||
if(callbacks[if_num]->ctrl_line_callback != NULL) {
|
||||
callbacks[if_num]->ctrl_line_callback(cb_ctx[if_num], cdc_ctrl_line_state[if_num]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct usb_cdc_line_coding* furi_hal_cdc_get_port_settings(uint8_t if_num) {
|
||||
furi_assert(if_num < IF_NUM_MAX);
|
||||
return &cdc_config[if_num];
|
||||
}
|
||||
|
||||
uint8_t furi_hal_cdc_get_ctrl_line_state(uint8_t if_num) {
|
||||
furi_assert(if_num < IF_NUM_MAX);
|
||||
return cdc_ctrl_line_state[if_num];
|
||||
}
|
||||
|
||||
void furi_hal_cdc_send(uint8_t if_num, uint8_t* buf, uint16_t len) {
|
||||
if(if_num == 0)
|
||||
usbd_ep_write(usb_dev, CDC0_TXD_EP, buf, len);
|
||||
else
|
||||
usbd_ep_write(usb_dev, CDC1_TXD_EP, buf, len);
|
||||
}
|
||||
|
||||
int32_t furi_hal_cdc_receive(uint8_t if_num, uint8_t* buf, uint16_t max_len) {
|
||||
int32_t len = 0;
|
||||
if(if_num == 0)
|
||||
len = usbd_ep_read(usb_dev, CDC0_RXD_EP, buf, max_len);
|
||||
else
|
||||
len = usbd_ep_read(usb_dev, CDC1_RXD_EP, buf, max_len);
|
||||
return ((len < 0) ? 0 : len);
|
||||
}
|
||||
|
||||
static void cdc_on_wakeup(usbd_device* dev) {
|
||||
UNUSED(dev);
|
||||
connected = true;
|
||||
for(uint8_t i = 0; i < IF_NUM_MAX; i++) {
|
||||
if(callbacks[i] != NULL) {
|
||||
if(callbacks[i]->state_callback != NULL) callbacks[i]->state_callback(cb_ctx[i], 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void cdc_on_suspend(usbd_device* dev) {
|
||||
UNUSED(dev);
|
||||
connected = false;
|
||||
for(uint8_t i = 0; i < IF_NUM_MAX; i++) {
|
||||
cdc_ctrl_line_state[i] = 0;
|
||||
if(callbacks[i] != NULL) {
|
||||
if(callbacks[i]->state_callback != NULL) callbacks[i]->state_callback(cb_ctx[i], 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void cdc_rx_ep_callback(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
UNUSED(event);
|
||||
uint8_t if_num = 0;
|
||||
if(ep == CDC0_RXD_EP)
|
||||
if_num = 0;
|
||||
else
|
||||
if_num = 1;
|
||||
|
||||
if(callbacks[if_num] != NULL) {
|
||||
if(callbacks[if_num]->rx_ep_callback != NULL)
|
||||
callbacks[if_num]->rx_ep_callback(cb_ctx[if_num]);
|
||||
}
|
||||
}
|
||||
|
||||
static void cdc_tx_ep_callback(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
UNUSED(event);
|
||||
uint8_t if_num = 0;
|
||||
if(ep == CDC0_TXD_EP)
|
||||
if_num = 0;
|
||||
else
|
||||
if_num = 1;
|
||||
|
||||
if(callbacks[if_num] != NULL) {
|
||||
if(callbacks[if_num]->tx_ep_callback != NULL)
|
||||
callbacks[if_num]->tx_ep_callback(cb_ctx[if_num]);
|
||||
}
|
||||
}
|
||||
|
||||
static void cdc_txrx_ep_callback(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
if(event == usbd_evt_eptx) {
|
||||
cdc_tx_ep_callback(dev, event, ep);
|
||||
} else {
|
||||
cdc_rx_ep_callback(dev, event, ep);
|
||||
}
|
||||
}
|
||||
|
||||
/* Configure endpoints */
|
||||
static usbd_respond cdc_ep_config(usbd_device* dev, uint8_t cfg) {
|
||||
uint8_t if_cnt = ((struct usb_config_descriptor*)(cdc_if_cur->cfg_descr))->bNumInterfaces;
|
||||
switch(cfg) {
|
||||
case 0:
|
||||
/* deconfiguring device */
|
||||
if(if_cnt == 4) {
|
||||
usbd_ep_deconfig(dev, CDC1_NTF_EP);
|
||||
usbd_ep_deconfig(dev, CDC1_TXD_EP);
|
||||
usbd_ep_deconfig(dev, CDC1_RXD_EP);
|
||||
usbd_reg_endpoint(dev, CDC1_RXD_EP, 0);
|
||||
usbd_reg_endpoint(dev, CDC1_TXD_EP, 0);
|
||||
}
|
||||
usbd_ep_deconfig(dev, CDC0_NTF_EP);
|
||||
usbd_ep_deconfig(dev, CDC0_TXD_EP);
|
||||
usbd_ep_deconfig(dev, CDC0_RXD_EP);
|
||||
usbd_reg_endpoint(dev, CDC0_RXD_EP, 0);
|
||||
usbd_reg_endpoint(dev, CDC0_TXD_EP, 0);
|
||||
return usbd_ack;
|
||||
case 1:
|
||||
/* configuring device */
|
||||
if((CDC0_TXD_EP & 0x7F) != (CDC0_RXD_EP & 0x7F)) {
|
||||
// 2x unidirectional endpoint mode with dualbuf
|
||||
usbd_ep_config(dev, CDC0_RXD_EP, USB_EPTYPE_BULK | USB_EPTYPE_DBLBUF, CDC_DATA_SZ);
|
||||
usbd_ep_config(dev, CDC0_TXD_EP, USB_EPTYPE_BULK | USB_EPTYPE_DBLBUF, CDC_DATA_SZ);
|
||||
usbd_ep_config(dev, CDC0_NTF_EP, USB_EPTYPE_INTERRUPT, CDC_NTF_SZ);
|
||||
usbd_reg_endpoint(dev, CDC0_RXD_EP, cdc_rx_ep_callback);
|
||||
usbd_reg_endpoint(dev, CDC0_TXD_EP, cdc_tx_ep_callback);
|
||||
} else {
|
||||
// 1x bidirectional endpoint mode
|
||||
usbd_ep_config(dev, CDC0_RXD_EP, USB_EPTYPE_BULK, CDC_DATA_SZ);
|
||||
usbd_ep_config(dev, CDC0_TXD_EP, USB_EPTYPE_BULK, CDC_DATA_SZ);
|
||||
usbd_ep_config(dev, CDC0_NTF_EP, USB_EPTYPE_INTERRUPT, CDC_NTF_SZ);
|
||||
usbd_reg_endpoint(dev, CDC0_RXD_EP, cdc_txrx_ep_callback);
|
||||
usbd_reg_endpoint(dev, CDC0_TXD_EP, cdc_txrx_ep_callback);
|
||||
}
|
||||
usbd_ep_write(dev, CDC0_TXD_EP, 0, 0);
|
||||
|
||||
if(if_cnt == 4) {
|
||||
if((CDC1_TXD_EP & 0x7F) != (CDC1_RXD_EP & 0x7F)) {
|
||||
usbd_ep_config(dev, CDC1_RXD_EP, USB_EPTYPE_BULK | USB_EPTYPE_DBLBUF, CDC_DATA_SZ);
|
||||
usbd_ep_config(dev, CDC1_TXD_EP, USB_EPTYPE_BULK | USB_EPTYPE_DBLBUF, CDC_DATA_SZ);
|
||||
usbd_ep_config(dev, CDC1_NTF_EP, USB_EPTYPE_INTERRUPT, CDC_NTF_SZ);
|
||||
usbd_reg_endpoint(dev, CDC1_RXD_EP, cdc_rx_ep_callback);
|
||||
usbd_reg_endpoint(dev, CDC1_TXD_EP, cdc_tx_ep_callback);
|
||||
} else {
|
||||
usbd_ep_config(dev, CDC1_RXD_EP, USB_EPTYPE_BULK, CDC_DATA_SZ);
|
||||
usbd_ep_config(dev, CDC1_TXD_EP, USB_EPTYPE_BULK, CDC_DATA_SZ);
|
||||
usbd_ep_config(dev, CDC1_NTF_EP, USB_EPTYPE_INTERRUPT, CDC_NTF_SZ);
|
||||
usbd_reg_endpoint(dev, CDC1_RXD_EP, cdc_txrx_ep_callback);
|
||||
usbd_reg_endpoint(dev, CDC1_TXD_EP, cdc_txrx_ep_callback);
|
||||
}
|
||||
usbd_ep_write(dev, CDC1_TXD_EP, 0, 0);
|
||||
}
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
|
||||
/* Control requests handler */
|
||||
static usbd_respond cdc_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback) {
|
||||
UNUSED(callback);
|
||||
/* CDC control requests */
|
||||
uint8_t if_num = 0;
|
||||
if(((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
|
||||
(USB_REQ_INTERFACE | USB_REQ_CLASS) &&
|
||||
(req->wIndex == 0 || req->wIndex == 2)) {
|
||||
if(req->wIndex == 0)
|
||||
if_num = 0;
|
||||
else
|
||||
if_num = 1;
|
||||
|
||||
switch(req->bRequest) {
|
||||
case USB_CDC_SET_CONTROL_LINE_STATE:
|
||||
if(callbacks[if_num] != NULL) {
|
||||
cdc_ctrl_line_state[if_num] = req->wValue;
|
||||
if(callbacks[if_num]->ctrl_line_callback != NULL)
|
||||
callbacks[if_num]->ctrl_line_callback(
|
||||
cb_ctx[if_num], cdc_ctrl_line_state[if_num]);
|
||||
}
|
||||
return usbd_ack;
|
||||
case USB_CDC_SET_LINE_CODING:
|
||||
memcpy(&cdc_config[if_num], req->data, sizeof(cdc_config[0]));
|
||||
if(callbacks[if_num] != NULL) {
|
||||
if(callbacks[if_num]->config_callback != NULL)
|
||||
callbacks[if_num]->config_callback(cb_ctx[if_num], &cdc_config[if_num]);
|
||||
}
|
||||
return usbd_ack;
|
||||
case USB_CDC_GET_LINE_CODING:
|
||||
dev->status.data_ptr = &cdc_config[if_num];
|
||||
dev->status.data_count = sizeof(cdc_config[0]);
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
return usbd_fail;
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include "usb_cdc.h"
|
||||
|
||||
#define CDC_DATA_SZ 64
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
void (*tx_ep_callback)(void* context);
|
||||
void (*rx_ep_callback)(void* context);
|
||||
void (*state_callback)(void* context, uint8_t state);
|
||||
void (*ctrl_line_callback)(void* context, uint8_t state);
|
||||
void (*config_callback)(void* context, struct usb_cdc_line_coding* config);
|
||||
} CdcCallbacks;
|
||||
|
||||
void furi_hal_cdc_set_callbacks(uint8_t if_num, CdcCallbacks* cb, void* context);
|
||||
|
||||
struct usb_cdc_line_coding* furi_hal_cdc_get_port_settings(uint8_t if_num);
|
||||
|
||||
uint8_t furi_hal_cdc_get_ctrl_line_state(uint8_t if_num);
|
||||
|
||||
void furi_hal_cdc_send(uint8_t if_num, uint8_t* buf, uint16_t len);
|
||||
|
||||
int32_t furi_hal_cdc_receive(uint8_t if_num, uint8_t* buf, uint16_t max_len);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,543 @@
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_usb_i.h>
|
||||
#include <furi_hal_usb.h>
|
||||
#include <furi_hal_usb_hid.h>
|
||||
#include <furi.h>
|
||||
|
||||
#include "usb.h"
|
||||
#include "usb_hid.h"
|
||||
|
||||
#define HID_EP_IN 0x81
|
||||
#define HID_EP_SZ 0x10
|
||||
|
||||
#define HID_INTERVAL 2
|
||||
|
||||
#define HID_VID_DEFAULT 0x046D
|
||||
#define HID_PID_DEFAULT 0xC529
|
||||
|
||||
struct HidIntfDescriptor {
|
||||
struct usb_interface_descriptor hid;
|
||||
struct usb_hid_descriptor hid_desc;
|
||||
struct usb_endpoint_descriptor hid_ep_in;
|
||||
};
|
||||
|
||||
struct HidConfigDescriptor {
|
||||
struct usb_config_descriptor config;
|
||||
struct HidIntfDescriptor intf_0;
|
||||
} __attribute__((packed));
|
||||
|
||||
enum HidReportId {
|
||||
ReportIdKeyboard = 1,
|
||||
ReportIdMouse = 2,
|
||||
ReportIdConsumer = 3,
|
||||
};
|
||||
|
||||
/* HID report descriptor: keyboard + mouse + consumer control */
|
||||
static const uint8_t hid_report_desc[] = {
|
||||
// clang-format off
|
||||
HID_USAGE_PAGE(HID_PAGE_DESKTOP),
|
||||
HID_USAGE(HID_DESKTOP_KEYBOARD),
|
||||
HID_COLLECTION(HID_APPLICATION_COLLECTION),
|
||||
HID_REPORT_ID(ReportIdKeyboard),
|
||||
// Keyboard report
|
||||
HID_USAGE_PAGE(HID_DESKTOP_KEYPAD),
|
||||
HID_USAGE_MINIMUM(HID_KEYBOARD_L_CTRL),
|
||||
HID_USAGE_MAXIMUM(HID_KEYBOARD_R_GUI),
|
||||
HID_LOGICAL_MINIMUM(0),
|
||||
HID_LOGICAL_MAXIMUM(1),
|
||||
HID_REPORT_SIZE(1),
|
||||
HID_REPORT_COUNT(8),
|
||||
// Input - Modifier keys byte
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
|
||||
HID_REPORT_COUNT(1),
|
||||
HID_REPORT_SIZE(8),
|
||||
// Input - Reserved byte
|
||||
HID_INPUT(HID_IOF_CONSTANT | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
|
||||
HID_USAGE_PAGE(HID_PAGE_LED),
|
||||
HID_REPORT_COUNT(8),
|
||||
HID_REPORT_SIZE(1),
|
||||
HID_USAGE_MINIMUM(1),
|
||||
HID_USAGE_MAXIMUM(8),
|
||||
// Output - LEDs
|
||||
HID_OUTPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
|
||||
HID_REPORT_COUNT(HID_KB_MAX_KEYS),
|
||||
HID_REPORT_SIZE(8),
|
||||
HID_LOGICAL_MINIMUM(0),
|
||||
HID_LOGICAL_MAXIMUM(101),
|
||||
HID_USAGE_PAGE(HID_DESKTOP_KEYPAD),
|
||||
HID_USAGE_MINIMUM(0),
|
||||
HID_USAGE_MAXIMUM(101),
|
||||
// Input - Key codes
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
|
||||
HID_END_COLLECTION,
|
||||
|
||||
HID_USAGE_PAGE(HID_PAGE_DESKTOP),
|
||||
HID_USAGE(HID_DESKTOP_MOUSE),
|
||||
HID_COLLECTION(HID_APPLICATION_COLLECTION),
|
||||
HID_USAGE(HID_DESKTOP_POINTER),
|
||||
HID_COLLECTION(HID_PHYSICAL_COLLECTION),
|
||||
HID_REPORT_ID(ReportIdMouse),
|
||||
// Mouse report
|
||||
HID_USAGE_PAGE(HID_PAGE_BUTTON),
|
||||
HID_USAGE_MINIMUM(1),
|
||||
HID_USAGE_MAXIMUM(3),
|
||||
HID_LOGICAL_MINIMUM(0),
|
||||
HID_LOGICAL_MAXIMUM(1),
|
||||
HID_REPORT_COUNT(3),
|
||||
HID_REPORT_SIZE(1),
|
||||
// Input - Mouse keys
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
|
||||
HID_REPORT_SIZE(1),
|
||||
HID_REPORT_COUNT(5),
|
||||
// Input - Mouse keys padding
|
||||
HID_INPUT(HID_IOF_CONSTANT | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
|
||||
HID_USAGE_PAGE(HID_PAGE_DESKTOP),
|
||||
HID_USAGE(HID_DESKTOP_X),
|
||||
HID_USAGE(HID_DESKTOP_Y),
|
||||
HID_USAGE(HID_DESKTOP_WHEEL),
|
||||
HID_LOGICAL_MINIMUM(-127),
|
||||
HID_LOGICAL_MAXIMUM(127),
|
||||
HID_REPORT_SIZE(8),
|
||||
HID_REPORT_COUNT(3),
|
||||
// Input - Mouse movement data (x, y, scroll)
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
|
||||
HID_END_COLLECTION,
|
||||
HID_END_COLLECTION,
|
||||
|
||||
HID_USAGE_PAGE(HID_PAGE_CONSUMER),
|
||||
HID_USAGE(HID_CONSUMER_CONTROL),
|
||||
HID_COLLECTION(HID_APPLICATION_COLLECTION),
|
||||
HID_REPORT_ID(ReportIdConsumer),
|
||||
// Consumer report
|
||||
HID_LOGICAL_MINIMUM(0),
|
||||
HID_RI_LOGICAL_MAXIMUM(16, 0x3FF),
|
||||
HID_USAGE_MINIMUM(0),
|
||||
HID_RI_USAGE_MAXIMUM(16, 0x3FF),
|
||||
HID_REPORT_COUNT(HID_CONSUMER_MAX_KEYS),
|
||||
HID_REPORT_SIZE(16),
|
||||
// Input - Consumer control keys
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
|
||||
HID_END_COLLECTION,
|
||||
// clang-format on
|
||||
};
|
||||
|
||||
/* Device descriptor */
|
||||
static struct usb_device_descriptor hid_device_desc = {
|
||||
.bLength = sizeof(struct usb_device_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_DEVICE,
|
||||
.bcdUSB = VERSION_BCD(2, 0, 0),
|
||||
.bDeviceClass = USB_CLASS_PER_INTERFACE,
|
||||
.bDeviceSubClass = USB_SUBCLASS_NONE,
|
||||
.bDeviceProtocol = USB_PROTO_NONE,
|
||||
.bMaxPacketSize0 = USB_EP0_SIZE,
|
||||
.idVendor = HID_VID_DEFAULT,
|
||||
.idProduct = HID_PID_DEFAULT,
|
||||
.bcdDevice = VERSION_BCD(1, 0, 0),
|
||||
.iManufacturer = 0,
|
||||
.iProduct = 0,
|
||||
.iSerialNumber = 0,
|
||||
.bNumConfigurations = 1,
|
||||
};
|
||||
|
||||
/* Device configuration descriptor */
|
||||
static const struct HidConfigDescriptor hid_cfg_desc = {
|
||||
.config =
|
||||
{
|
||||
.bLength = sizeof(struct usb_config_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_CONFIGURATION,
|
||||
.wTotalLength = sizeof(struct HidConfigDescriptor),
|
||||
.bNumInterfaces = 1,
|
||||
.bConfigurationValue = 1,
|
||||
.iConfiguration = NO_DESCRIPTOR,
|
||||
.bmAttributes = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
|
||||
.bMaxPower = USB_CFG_POWER_MA(100),
|
||||
},
|
||||
.intf_0 =
|
||||
{
|
||||
.hid =
|
||||
{
|
||||
.bLength = sizeof(struct usb_interface_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFACE,
|
||||
.bInterfaceNumber = 0,
|
||||
.bAlternateSetting = 0,
|
||||
.bNumEndpoints = 1,
|
||||
.bInterfaceClass = USB_CLASS_HID,
|
||||
.bInterfaceSubClass = USB_HID_SUBCLASS_BOOT,
|
||||
.bInterfaceProtocol = USB_HID_PROTO_KEYBOARD,
|
||||
.iInterface = NO_DESCRIPTOR,
|
||||
},
|
||||
.hid_desc =
|
||||
{
|
||||
.bLength = sizeof(struct usb_hid_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_HID,
|
||||
.bcdHID = VERSION_BCD(1, 0, 0),
|
||||
.bCountryCode = USB_HID_COUNTRY_NONE,
|
||||
.bNumDescriptors = 1,
|
||||
.bDescriptorType0 = USB_DTYPE_HID_REPORT,
|
||||
.wDescriptorLength0 = sizeof(hid_report_desc),
|
||||
},
|
||||
.hid_ep_in =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = HID_EP_IN,
|
||||
.bmAttributes = USB_EPTYPE_INTERRUPT,
|
||||
.wMaxPacketSize = HID_EP_SZ,
|
||||
.bInterval = HID_INTERVAL,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
struct HidReportMouse {
|
||||
uint8_t report_id;
|
||||
uint8_t btn;
|
||||
int8_t x;
|
||||
int8_t y;
|
||||
int8_t wheel;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct HidReportKB {
|
||||
uint8_t report_id;
|
||||
struct {
|
||||
uint8_t mods;
|
||||
uint8_t reserved;
|
||||
uint8_t btn[HID_KB_MAX_KEYS];
|
||||
} boot;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct HidReportConsumer {
|
||||
uint8_t report_id;
|
||||
uint16_t btn[HID_CONSUMER_MAX_KEYS];
|
||||
} __attribute__((packed));
|
||||
|
||||
struct HidReportLED {
|
||||
uint8_t report_id;
|
||||
uint8_t led_state;
|
||||
} __attribute__((packed));
|
||||
|
||||
static struct HidReport {
|
||||
struct HidReportKB keyboard;
|
||||
struct HidReportMouse mouse;
|
||||
struct HidReportConsumer consumer;
|
||||
} __attribute__((packed)) hid_report;
|
||||
|
||||
static void hid_init(usbd_device* dev, FuriHalUsbInterface* intf, void* ctx);
|
||||
static void hid_deinit(usbd_device* dev);
|
||||
static void hid_on_wakeup(usbd_device* dev);
|
||||
static void hid_on_suspend(usbd_device* dev);
|
||||
|
||||
FuriHalUsbInterface usb_hid = {
|
||||
.init = hid_init,
|
||||
.deinit = hid_deinit,
|
||||
.wakeup = hid_on_wakeup,
|
||||
.suspend = hid_on_suspend,
|
||||
|
||||
.dev_descr = (struct usb_device_descriptor*)&hid_device_desc,
|
||||
|
||||
.str_manuf_descr = NULL,
|
||||
.str_prod_descr = NULL,
|
||||
.str_serial_descr = NULL,
|
||||
|
||||
.cfg_descr = (void*)&hid_cfg_desc,
|
||||
};
|
||||
|
||||
static bool hid_send_report(uint8_t report_id);
|
||||
static usbd_respond hid_ep_config(usbd_device* dev, uint8_t cfg);
|
||||
static usbd_respond hid_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback);
|
||||
static usbd_device* usb_dev;
|
||||
static FuriSemaphore* hid_semaphore = NULL;
|
||||
static bool hid_connected = false;
|
||||
static HidStateCallback callback;
|
||||
static void* cb_ctx;
|
||||
static uint8_t led_state;
|
||||
static bool boot_protocol = false;
|
||||
|
||||
bool furi_hal_hid_is_connected() {
|
||||
return hid_connected;
|
||||
}
|
||||
|
||||
uint8_t furi_hal_hid_get_led_state() {
|
||||
return led_state;
|
||||
}
|
||||
|
||||
void furi_hal_hid_set_state_callback(HidStateCallback cb, void* ctx) {
|
||||
if(callback != NULL) {
|
||||
if(hid_connected == true) callback(false, cb_ctx);
|
||||
}
|
||||
|
||||
callback = cb;
|
||||
cb_ctx = ctx;
|
||||
|
||||
if(callback != NULL) {
|
||||
if(hid_connected == true) callback(true, cb_ctx);
|
||||
}
|
||||
}
|
||||
|
||||
bool furi_hal_hid_kb_press(uint16_t button) {
|
||||
for(uint8_t key_nb = 0; key_nb < HID_KB_MAX_KEYS; key_nb++) {
|
||||
if(hid_report.keyboard.boot.btn[key_nb] == 0) {
|
||||
hid_report.keyboard.boot.btn[key_nb] = button & 0xFF;
|
||||
break;
|
||||
}
|
||||
}
|
||||
hid_report.keyboard.boot.mods |= (button >> 8);
|
||||
return hid_send_report(ReportIdKeyboard);
|
||||
}
|
||||
|
||||
bool furi_hal_hid_kb_release(uint16_t button) {
|
||||
for(uint8_t key_nb = 0; key_nb < HID_KB_MAX_KEYS; key_nb++) {
|
||||
if(hid_report.keyboard.boot.btn[key_nb] == (button & 0xFF)) {
|
||||
hid_report.keyboard.boot.btn[key_nb] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
hid_report.keyboard.boot.mods &= ~(button >> 8);
|
||||
return hid_send_report(ReportIdKeyboard);
|
||||
}
|
||||
|
||||
bool furi_hal_hid_kb_release_all() {
|
||||
for(uint8_t key_nb = 0; key_nb < HID_KB_MAX_KEYS; key_nb++) {
|
||||
hid_report.keyboard.boot.btn[key_nb] = 0;
|
||||
}
|
||||
hid_report.keyboard.boot.mods = 0;
|
||||
return hid_send_report(ReportIdKeyboard);
|
||||
}
|
||||
|
||||
bool furi_hal_hid_mouse_move(int8_t dx, int8_t dy) {
|
||||
hid_report.mouse.x = dx;
|
||||
hid_report.mouse.y = dy;
|
||||
bool state = hid_send_report(ReportIdMouse);
|
||||
hid_report.mouse.x = 0;
|
||||
hid_report.mouse.y = 0;
|
||||
return state;
|
||||
}
|
||||
|
||||
bool furi_hal_hid_mouse_press(uint8_t button) {
|
||||
hid_report.mouse.btn |= button;
|
||||
return hid_send_report(ReportIdMouse);
|
||||
}
|
||||
|
||||
bool furi_hal_hid_mouse_release(uint8_t button) {
|
||||
hid_report.mouse.btn &= ~button;
|
||||
return hid_send_report(ReportIdMouse);
|
||||
}
|
||||
|
||||
bool furi_hal_hid_mouse_scroll(int8_t delta) {
|
||||
hid_report.mouse.wheel = delta;
|
||||
bool state = hid_send_report(ReportIdMouse);
|
||||
hid_report.mouse.wheel = 0;
|
||||
return state;
|
||||
}
|
||||
|
||||
bool furi_hal_hid_consumer_key_press(uint16_t button) {
|
||||
for(uint8_t key_nb = 0; key_nb < HID_CONSUMER_MAX_KEYS; key_nb++) {
|
||||
if(hid_report.consumer.btn[key_nb] == 0) {
|
||||
hid_report.consumer.btn[key_nb] = button;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return hid_send_report(ReportIdConsumer);
|
||||
}
|
||||
|
||||
bool furi_hal_hid_consumer_key_release(uint16_t button) {
|
||||
for(uint8_t key_nb = 0; key_nb < HID_CONSUMER_MAX_KEYS; key_nb++) {
|
||||
if(hid_report.consumer.btn[key_nb] == button) {
|
||||
hid_report.consumer.btn[key_nb] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return hid_send_report(ReportIdConsumer);
|
||||
}
|
||||
|
||||
static void* hid_set_string_descr(char* str) {
|
||||
furi_assert(str);
|
||||
|
||||
size_t len = strlen(str);
|
||||
struct usb_string_descriptor* dev_str_desc = malloc(len * 2 + 2);
|
||||
dev_str_desc->bLength = len * 2 + 2;
|
||||
dev_str_desc->bDescriptorType = USB_DTYPE_STRING;
|
||||
for(size_t i = 0; i < len; i++) dev_str_desc->wString[i] = str[i];
|
||||
|
||||
return dev_str_desc;
|
||||
}
|
||||
|
||||
static void hid_init(usbd_device* dev, FuriHalUsbInterface* intf, void* ctx) {
|
||||
UNUSED(intf);
|
||||
FuriHalUsbHidConfig* cfg = (FuriHalUsbHidConfig*)ctx;
|
||||
if(hid_semaphore == NULL) hid_semaphore = furi_semaphore_alloc(1, 1);
|
||||
usb_dev = dev;
|
||||
hid_report.keyboard.report_id = ReportIdKeyboard;
|
||||
hid_report.mouse.report_id = ReportIdMouse;
|
||||
hid_report.consumer.report_id = ReportIdConsumer;
|
||||
|
||||
usb_hid.dev_descr->iManufacturer = 0;
|
||||
usb_hid.dev_descr->iProduct = 0;
|
||||
usb_hid.str_manuf_descr = NULL;
|
||||
usb_hid.str_prod_descr = NULL;
|
||||
usb_hid.dev_descr->idVendor = HID_VID_DEFAULT;
|
||||
usb_hid.dev_descr->idProduct = HID_PID_DEFAULT;
|
||||
|
||||
if(cfg != NULL) {
|
||||
usb_hid.dev_descr->idVendor = cfg->vid;
|
||||
usb_hid.dev_descr->idProduct = cfg->pid;
|
||||
|
||||
if(cfg->manuf[0] != '\0') {
|
||||
usb_hid.str_manuf_descr = hid_set_string_descr(cfg->manuf);
|
||||
usb_hid.dev_descr->iManufacturer = UsbDevManuf;
|
||||
}
|
||||
|
||||
if(cfg->product[0] != '\0') {
|
||||
usb_hid.str_prod_descr = hid_set_string_descr(cfg->product);
|
||||
usb_hid.dev_descr->iProduct = UsbDevProduct;
|
||||
}
|
||||
}
|
||||
|
||||
usbd_reg_config(dev, hid_ep_config);
|
||||
usbd_reg_control(dev, hid_control);
|
||||
|
||||
usbd_connect(dev, true);
|
||||
}
|
||||
|
||||
static void hid_deinit(usbd_device* dev) {
|
||||
usbd_reg_config(dev, NULL);
|
||||
usbd_reg_control(dev, NULL);
|
||||
|
||||
free(usb_hid.str_manuf_descr);
|
||||
free(usb_hid.str_prod_descr);
|
||||
}
|
||||
|
||||
static void hid_on_wakeup(usbd_device* dev) {
|
||||
UNUSED(dev);
|
||||
if(!hid_connected) {
|
||||
hid_connected = true;
|
||||
if(callback != NULL) {
|
||||
callback(true, cb_ctx);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void hid_on_suspend(usbd_device* dev) {
|
||||
UNUSED(dev);
|
||||
if(hid_connected) {
|
||||
hid_connected = false;
|
||||
furi_semaphore_release(hid_semaphore);
|
||||
if(callback != NULL) {
|
||||
callback(false, cb_ctx);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool hid_send_report(uint8_t report_id) {
|
||||
if((hid_semaphore == NULL) || (hid_connected == false)) return false;
|
||||
if((boot_protocol == true) && (report_id != ReportIdKeyboard)) return false;
|
||||
|
||||
FuriStatus status = furi_semaphore_acquire(hid_semaphore, HID_INTERVAL * 2);
|
||||
if(status == FuriStatusErrorTimeout) {
|
||||
return false;
|
||||
}
|
||||
furi_check(status == FuriStatusOk);
|
||||
if(hid_connected == false) {
|
||||
return false;
|
||||
}
|
||||
if(boot_protocol == true) {
|
||||
usbd_ep_write(
|
||||
usb_dev, HID_EP_IN, &hid_report.keyboard.boot, sizeof(hid_report.keyboard.boot));
|
||||
} else {
|
||||
if(report_id == ReportIdKeyboard)
|
||||
usbd_ep_write(usb_dev, HID_EP_IN, &hid_report.keyboard, sizeof(hid_report.keyboard));
|
||||
else if(report_id == ReportIdMouse)
|
||||
usbd_ep_write(usb_dev, HID_EP_IN, &hid_report.mouse, sizeof(hid_report.mouse));
|
||||
else if(report_id == ReportIdConsumer)
|
||||
usbd_ep_write(usb_dev, HID_EP_IN, &hid_report.consumer, sizeof(hid_report.consumer));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static void hid_txrx_ep_callback(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
if(event == usbd_evt_eptx) {
|
||||
furi_semaphore_release(hid_semaphore);
|
||||
} else if(boot_protocol == true) {
|
||||
usbd_ep_read(usb_dev, ep, &led_state, sizeof(led_state));
|
||||
} else {
|
||||
struct HidReportLED leds;
|
||||
usbd_ep_read(usb_dev, ep, &leds, sizeof(leds));
|
||||
led_state = leds.led_state;
|
||||
}
|
||||
}
|
||||
|
||||
/* Configure endpoints */
|
||||
static usbd_respond hid_ep_config(usbd_device* dev, uint8_t cfg) {
|
||||
switch(cfg) {
|
||||
case 0:
|
||||
/* deconfiguring device */
|
||||
usbd_ep_deconfig(dev, HID_EP_IN);
|
||||
usbd_reg_endpoint(dev, HID_EP_IN, 0);
|
||||
return usbd_ack;
|
||||
case 1:
|
||||
/* configuring device */
|
||||
usbd_ep_config(dev, HID_EP_IN, USB_EPTYPE_INTERRUPT, HID_EP_SZ);
|
||||
usbd_reg_endpoint(dev, HID_EP_IN, hid_txrx_ep_callback);
|
||||
usbd_ep_write(dev, HID_EP_IN, 0, 0);
|
||||
boot_protocol = false; /* BIOS will SET_PROTOCOL if it wants this */
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
|
||||
/* Control requests handler */
|
||||
static usbd_respond hid_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback) {
|
||||
UNUSED(callback);
|
||||
/* HID control requests */
|
||||
if(((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
|
||||
(USB_REQ_INTERFACE | USB_REQ_CLASS) &&
|
||||
req->wIndex == 0) {
|
||||
switch(req->bRequest) {
|
||||
case USB_HID_SETIDLE:
|
||||
return usbd_ack;
|
||||
case USB_HID_GETREPORT:
|
||||
if(boot_protocol == true) {
|
||||
dev->status.data_ptr = &hid_report.keyboard.boot;
|
||||
dev->status.data_count = sizeof(hid_report.keyboard.boot);
|
||||
} else {
|
||||
dev->status.data_ptr = &hid_report;
|
||||
dev->status.data_count = sizeof(hid_report);
|
||||
}
|
||||
return usbd_ack;
|
||||
case USB_HID_SETPROTOCOL:
|
||||
if(req->wValue == 0)
|
||||
boot_protocol = true;
|
||||
else if(req->wValue == 1)
|
||||
boot_protocol = false;
|
||||
else
|
||||
return usbd_fail;
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
if(((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
|
||||
(USB_REQ_INTERFACE | USB_REQ_STANDARD) &&
|
||||
req->wIndex == 0 && req->bRequest == USB_STD_GET_DESCRIPTOR) {
|
||||
switch(req->wValue >> 8) {
|
||||
case USB_DTYPE_HID:
|
||||
dev->status.data_ptr = (uint8_t*)&(hid_cfg_desc.intf_0.hid_desc);
|
||||
dev->status.data_count = sizeof(hid_cfg_desc.intf_0.hid_desc);
|
||||
return usbd_ack;
|
||||
case USB_DTYPE_HID_REPORT:
|
||||
boot_protocol = false; /* BIOS does not read this */
|
||||
dev->status.data_ptr = (uint8_t*)hid_report_desc;
|
||||
dev->status.data_count = sizeof(hid_report_desc);
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
return usbd_fail;
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
#pragma once
|
||||
|
||||
#include "usb.h"
|
||||
|
||||
#define USB_EP0_SIZE 8
|
||||
|
||||
/* String descriptors */
|
||||
enum UsbDevDescStr {
|
||||
UsbDevLang = 0,
|
||||
UsbDevManuf = 1,
|
||||
UsbDevProduct = 2,
|
||||
UsbDevSerial = 3,
|
||||
};
|
||||
@@ -0,0 +1,322 @@
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_usb_i.h>
|
||||
#include <furi_hal_usb_hid_u2f.h>
|
||||
#include <furi_hal_usb.h>
|
||||
#include <furi.h>
|
||||
#include "usb.h"
|
||||
#include "usb_hid.h"
|
||||
|
||||
#define HID_PAGE_FIDO 0xF1D0
|
||||
#define HID_FIDO_U2F 0x01
|
||||
#define HID_FIDO_INPUT 0x20
|
||||
#define HID_FIDO_OUTPUT 0x21
|
||||
|
||||
#define HID_EP_IN 0x81
|
||||
#define HID_EP_OUT 0x01
|
||||
|
||||
struct HidIadDescriptor {
|
||||
struct usb_iad_descriptor hid_iad;
|
||||
struct usb_interface_descriptor hid;
|
||||
struct usb_hid_descriptor hid_desc;
|
||||
struct usb_endpoint_descriptor hid_ep_in;
|
||||
struct usb_endpoint_descriptor hid_ep_out;
|
||||
};
|
||||
|
||||
struct HidConfigDescriptor {
|
||||
struct usb_config_descriptor config;
|
||||
struct HidIadDescriptor iad_0;
|
||||
} __attribute__((packed));
|
||||
|
||||
/* HID report: FIDO U2F */
|
||||
static const uint8_t hid_u2f_report_desc[] = {
|
||||
HID_RI_USAGE_PAGE(16, HID_PAGE_FIDO),
|
||||
HID_USAGE(HID_FIDO_U2F),
|
||||
HID_COLLECTION(HID_APPLICATION_COLLECTION),
|
||||
HID_USAGE(HID_FIDO_INPUT),
|
||||
HID_LOGICAL_MINIMUM(0x00),
|
||||
HID_RI_LOGICAL_MAXIMUM(16, 0xFF),
|
||||
HID_REPORT_SIZE(8),
|
||||
HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
|
||||
HID_INPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
HID_USAGE(HID_FIDO_OUTPUT),
|
||||
HID_LOGICAL_MINIMUM(0x00),
|
||||
HID_RI_LOGICAL_MAXIMUM(16, 0xFF),
|
||||
HID_REPORT_SIZE(8),
|
||||
HID_REPORT_COUNT(HID_U2F_PACKET_LEN),
|
||||
HID_OUTPUT(HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
|
||||
HID_END_COLLECTION,
|
||||
};
|
||||
|
||||
static const struct usb_string_descriptor dev_manuf_desc = USB_STRING_DESC("Flipper Devices Inc.");
|
||||
static const struct usb_string_descriptor dev_prod_desc = USB_STRING_DESC("U2F Token");
|
||||
|
||||
/* Device descriptor */
|
||||
static const struct usb_device_descriptor hid_u2f_device_desc = {
|
||||
.bLength = sizeof(struct usb_device_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_DEVICE,
|
||||
.bcdUSB = VERSION_BCD(2, 0, 0),
|
||||
.bDeviceClass = USB_CLASS_IAD,
|
||||
.bDeviceSubClass = USB_SUBCLASS_IAD,
|
||||
.bDeviceProtocol = USB_PROTO_IAD,
|
||||
.bMaxPacketSize0 = USB_EP0_SIZE,
|
||||
.idVendor = 0x0483,
|
||||
.idProduct = 0x5741,
|
||||
.bcdDevice = VERSION_BCD(1, 0, 0),
|
||||
.iManufacturer = UsbDevManuf,
|
||||
.iProduct = UsbDevProduct,
|
||||
.iSerialNumber = 0,
|
||||
.bNumConfigurations = 1,
|
||||
};
|
||||
|
||||
/* Device configuration descriptor */
|
||||
static const struct HidConfigDescriptor hid_u2f_cfg_desc = {
|
||||
.config =
|
||||
{
|
||||
.bLength = sizeof(struct usb_config_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_CONFIGURATION,
|
||||
.wTotalLength = sizeof(struct HidConfigDescriptor),
|
||||
.bNumInterfaces = 1,
|
||||
.bConfigurationValue = 1,
|
||||
.iConfiguration = NO_DESCRIPTOR,
|
||||
.bmAttributes = USB_CFG_ATTR_RESERVED | USB_CFG_ATTR_SELFPOWERED,
|
||||
.bMaxPower = USB_CFG_POWER_MA(100),
|
||||
},
|
||||
.iad_0 =
|
||||
{
|
||||
.hid_iad =
|
||||
{
|
||||
.bLength = sizeof(struct usb_iad_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFASEASSOC,
|
||||
.bFirstInterface = 0,
|
||||
.bInterfaceCount = 1,
|
||||
.bFunctionClass = USB_CLASS_PER_INTERFACE,
|
||||
.bFunctionSubClass = USB_SUBCLASS_NONE,
|
||||
.bFunctionProtocol = USB_PROTO_NONE,
|
||||
.iFunction = NO_DESCRIPTOR,
|
||||
},
|
||||
.hid =
|
||||
{
|
||||
.bLength = sizeof(struct usb_interface_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_INTERFACE,
|
||||
.bInterfaceNumber = 0,
|
||||
.bAlternateSetting = 0,
|
||||
.bNumEndpoints = 2,
|
||||
.bInterfaceClass = USB_CLASS_HID,
|
||||
.bInterfaceSubClass = USB_HID_SUBCLASS_NONBOOT,
|
||||
.bInterfaceProtocol = USB_HID_PROTO_NONBOOT,
|
||||
.iInterface = NO_DESCRIPTOR,
|
||||
},
|
||||
.hid_desc =
|
||||
{
|
||||
.bLength = sizeof(struct usb_hid_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_HID,
|
||||
.bcdHID = VERSION_BCD(1, 0, 0),
|
||||
.bCountryCode = USB_HID_COUNTRY_NONE,
|
||||
.bNumDescriptors = 1,
|
||||
.bDescriptorType0 = USB_DTYPE_HID_REPORT,
|
||||
.wDescriptorLength0 = sizeof(hid_u2f_report_desc),
|
||||
},
|
||||
.hid_ep_in =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = HID_EP_IN,
|
||||
.bmAttributes = USB_EPTYPE_INTERRUPT,
|
||||
.wMaxPacketSize = HID_U2F_PACKET_LEN,
|
||||
.bInterval = 5,
|
||||
},
|
||||
.hid_ep_out =
|
||||
{
|
||||
.bLength = sizeof(struct usb_endpoint_descriptor),
|
||||
.bDescriptorType = USB_DTYPE_ENDPOINT,
|
||||
.bEndpointAddress = HID_EP_OUT,
|
||||
.bmAttributes = USB_EPTYPE_INTERRUPT,
|
||||
.wMaxPacketSize = HID_U2F_PACKET_LEN,
|
||||
.bInterval = 5,
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
static void hid_u2f_init(usbd_device* dev, FuriHalUsbInterface* intf, void* ctx);
|
||||
static void hid_u2f_deinit(usbd_device* dev);
|
||||
static void hid_u2f_on_wakeup(usbd_device* dev);
|
||||
static void hid_u2f_on_suspend(usbd_device* dev);
|
||||
|
||||
//static bool hid_u2f_send_report(uint8_t report_id);
|
||||
static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg);
|
||||
static usbd_respond
|
||||
hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback);
|
||||
static usbd_device* usb_dev;
|
||||
static FuriSemaphore* hid_u2f_semaphore = NULL;
|
||||
static bool hid_u2f_connected = false;
|
||||
|
||||
static HidU2fCallback callback;
|
||||
static void* cb_ctx;
|
||||
|
||||
bool furi_hal_hid_u2f_is_connected() {
|
||||
return hid_u2f_connected;
|
||||
}
|
||||
|
||||
void furi_hal_hid_u2f_set_callback(HidU2fCallback cb, void* ctx) {
|
||||
if(callback != NULL) {
|
||||
if(hid_u2f_connected == true) {
|
||||
callback(HidU2fDisconnected, cb_ctx);
|
||||
}
|
||||
}
|
||||
|
||||
callback = cb;
|
||||
cb_ctx = ctx;
|
||||
|
||||
if(callback != NULL) {
|
||||
if(hid_u2f_connected == true) {
|
||||
callback(HidU2fConnected, cb_ctx);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
FuriHalUsbInterface usb_hid_u2f = {
|
||||
.init = hid_u2f_init,
|
||||
.deinit = hid_u2f_deinit,
|
||||
.wakeup = hid_u2f_on_wakeup,
|
||||
.suspend = hid_u2f_on_suspend,
|
||||
|
||||
.dev_descr = (struct usb_device_descriptor*)&hid_u2f_device_desc,
|
||||
|
||||
.str_manuf_descr = (void*)&dev_manuf_desc,
|
||||
.str_prod_descr = (void*)&dev_prod_desc,
|
||||
.str_serial_descr = NULL,
|
||||
|
||||
.cfg_descr = (void*)&hid_u2f_cfg_desc,
|
||||
};
|
||||
|
||||
static void hid_u2f_init(usbd_device* dev, FuriHalUsbInterface* intf, void* ctx) {
|
||||
UNUSED(intf);
|
||||
UNUSED(ctx);
|
||||
if(hid_u2f_semaphore == NULL) {
|
||||
hid_u2f_semaphore = furi_semaphore_alloc(1, 1);
|
||||
}
|
||||
usb_dev = dev;
|
||||
|
||||
usbd_reg_config(dev, hid_u2f_ep_config);
|
||||
usbd_reg_control(dev, hid_u2f_control);
|
||||
|
||||
usbd_connect(dev, true);
|
||||
}
|
||||
|
||||
static void hid_u2f_deinit(usbd_device* dev) {
|
||||
usbd_reg_config(dev, NULL);
|
||||
usbd_reg_control(dev, NULL);
|
||||
}
|
||||
|
||||
static void hid_u2f_on_wakeup(usbd_device* dev) {
|
||||
UNUSED(dev);
|
||||
hid_u2f_connected = true;
|
||||
if(callback != NULL) {
|
||||
callback(HidU2fConnected, cb_ctx);
|
||||
}
|
||||
}
|
||||
|
||||
static void hid_u2f_on_suspend(usbd_device* dev) {
|
||||
UNUSED(dev);
|
||||
if(hid_u2f_connected) {
|
||||
hid_u2f_connected = false;
|
||||
furi_semaphore_release(hid_u2f_semaphore);
|
||||
if(callback != NULL) {
|
||||
callback(HidU2fDisconnected, cb_ctx);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_hid_u2f_send_response(uint8_t* data, uint8_t len) {
|
||||
if((hid_u2f_semaphore == NULL) || (hid_u2f_connected == false)) return;
|
||||
furi_check(furi_semaphore_acquire(hid_u2f_semaphore, FuriWaitForever) == FuriStatusOk);
|
||||
if(hid_u2f_connected == true) {
|
||||
usbd_ep_write(usb_dev, HID_EP_OUT, data, len);
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t furi_hal_hid_u2f_get_request(uint8_t* data) {
|
||||
int32_t len = usbd_ep_read(usb_dev, HID_EP_IN, data, HID_U2F_PACKET_LEN);
|
||||
return ((len < 0) ? 0 : len);
|
||||
}
|
||||
|
||||
static void hid_u2f_rx_ep_callback(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
UNUSED(event);
|
||||
UNUSED(ep);
|
||||
if(callback != NULL) {
|
||||
callback(HidU2fRequest, cb_ctx);
|
||||
}
|
||||
}
|
||||
|
||||
static void hid_u2f_tx_ep_callback(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
UNUSED(dev);
|
||||
UNUSED(event);
|
||||
UNUSED(ep);
|
||||
furi_semaphore_release(hid_u2f_semaphore);
|
||||
}
|
||||
|
||||
static void hid_u2f_txrx_ep_callback(usbd_device* dev, uint8_t event, uint8_t ep) {
|
||||
if(event == usbd_evt_eptx) {
|
||||
hid_u2f_tx_ep_callback(dev, event, ep);
|
||||
} else {
|
||||
hid_u2f_rx_ep_callback(dev, event, ep);
|
||||
}
|
||||
}
|
||||
|
||||
/* Configure endpoints */
|
||||
static usbd_respond hid_u2f_ep_config(usbd_device* dev, uint8_t cfg) {
|
||||
switch(cfg) {
|
||||
case 0:
|
||||
/* deconfiguring device */
|
||||
usbd_ep_deconfig(dev, HID_EP_OUT);
|
||||
usbd_ep_deconfig(dev, HID_EP_IN);
|
||||
usbd_reg_endpoint(dev, HID_EP_OUT, 0);
|
||||
usbd_reg_endpoint(dev, HID_EP_IN, 0);
|
||||
return usbd_ack;
|
||||
case 1:
|
||||
/* configuring device */
|
||||
usbd_ep_config(dev, HID_EP_IN, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
|
||||
usbd_ep_config(dev, HID_EP_OUT, USB_EPTYPE_INTERRUPT, HID_U2F_PACKET_LEN);
|
||||
usbd_reg_endpoint(dev, HID_EP_IN, hid_u2f_txrx_ep_callback);
|
||||
usbd_reg_endpoint(dev, HID_EP_OUT, hid_u2f_txrx_ep_callback);
|
||||
usbd_ep_write(dev, HID_U2F_PACKET_LEN, 0, 0);
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
|
||||
/* Control requests handler */
|
||||
static usbd_respond
|
||||
hid_u2f_control(usbd_device* dev, usbd_ctlreq* req, usbd_rqc_callback* callback) {
|
||||
UNUSED(callback);
|
||||
/* HID control requests */
|
||||
if(((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
|
||||
(USB_REQ_INTERFACE | USB_REQ_CLASS) &&
|
||||
req->wIndex == 0) {
|
||||
switch(req->bRequest) {
|
||||
case USB_HID_SETIDLE:
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
if(((USB_REQ_RECIPIENT | USB_REQ_TYPE) & req->bmRequestType) ==
|
||||
(USB_REQ_INTERFACE | USB_REQ_STANDARD) &&
|
||||
req->wIndex == 0 && req->bRequest == USB_STD_GET_DESCRIPTOR) {
|
||||
switch(req->wValue >> 8) {
|
||||
case USB_DTYPE_HID:
|
||||
dev->status.data_ptr = (uint8_t*)&(hid_u2f_cfg_desc.iad_0.hid_desc);
|
||||
dev->status.data_count = sizeof(hid_u2f_cfg_desc.iad_0.hid_desc);
|
||||
return usbd_ack;
|
||||
case USB_DTYPE_HID_REPORT:
|
||||
dev->status.data_ptr = (uint8_t*)hid_u2f_report_desc;
|
||||
dev->status.data_count = sizeof(hid_u2f_report_desc);
|
||||
return usbd_ack;
|
||||
default:
|
||||
return usbd_fail;
|
||||
}
|
||||
}
|
||||
return usbd_fail;
|
||||
}
|
||||
@@ -0,0 +1,295 @@
|
||||
#include <furi_hal_version.h>
|
||||
#include <furi_hal_rtc.h>
|
||||
|
||||
#include <furi.h>
|
||||
#include <stm32wbxx.h>
|
||||
#include <stm32wbxx_ll_rtc.h>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ble/ble.h>
|
||||
|
||||
#define TAG "FuriHalVersion"
|
||||
|
||||
#define FURI_HAL_VERSION_OTP_HEADER_MAGIC 0xBABE
|
||||
#define FURI_HAL_VERSION_OTP_ADDRESS OTP_AREA_BASE
|
||||
|
||||
/** OTP V0 Structure: prototypes and early EVT */
|
||||
typedef struct {
|
||||
uint8_t board_version;
|
||||
uint8_t board_target;
|
||||
uint8_t board_body;
|
||||
uint8_t board_connect;
|
||||
uint32_t header_timestamp;
|
||||
char name[FURI_HAL_VERSION_NAME_LENGTH];
|
||||
} FuriHalVersionOTPv0;
|
||||
|
||||
/** OTP V1 Structure: late EVT, DVT */
|
||||
typedef struct {
|
||||
/* First 64 bits: header */
|
||||
uint16_t header_magic;
|
||||
uint8_t header_version;
|
||||
uint8_t header_reserved;
|
||||
uint32_t header_timestamp;
|
||||
|
||||
/* Second 64 bits: board info */
|
||||
uint8_t board_version; /** Board version */
|
||||
uint8_t board_target; /** Board target firmware */
|
||||
uint8_t board_body; /** Board body */
|
||||
uint8_t board_connect; /** Board interconnect */
|
||||
uint8_t board_color; /** Board color */
|
||||
uint8_t board_region; /** Board region */
|
||||
uint16_t board_reserved; /** Reserved for future use, 0x0000 */
|
||||
|
||||
/* Third 64 bits: Unique Device Name */
|
||||
char name[FURI_HAL_VERSION_NAME_LENGTH]; /** Unique Device Name */
|
||||
} FuriHalVersionOTPv1;
|
||||
|
||||
/** OTP V2 Structure: DVT2, PVT, Production */
|
||||
typedef struct {
|
||||
/* Early First 64 bits: header */
|
||||
uint16_t header_magic;
|
||||
uint8_t header_version;
|
||||
uint8_t header_reserved;
|
||||
uint32_t header_timestamp;
|
||||
|
||||
/* Early Second 64 bits: board info */
|
||||
uint8_t board_version; /** Board version */
|
||||
uint8_t board_target; /** Board target firmware */
|
||||
uint8_t board_body; /** Board body */
|
||||
uint8_t board_connect; /** Board interconnect */
|
||||
uint8_t board_display; /** Board display */
|
||||
uint8_t board_reserved2_0; /** Reserved for future use, 0x00 */
|
||||
uint16_t board_reserved2_1; /** Reserved for future use, 0x0000 */
|
||||
|
||||
/* Late Third 64 bits: device info */
|
||||
uint8_t board_color; /** Board color */
|
||||
uint8_t board_region; /** Board region */
|
||||
uint16_t board_reserved3_0; /** Reserved for future use, 0x0000 */
|
||||
uint32_t board_reserved3_1; /** Reserved for future use, 0x00000000 */
|
||||
|
||||
/* Late Fourth 64 bits: Unique Device Name */
|
||||
char name[FURI_HAL_VERSION_NAME_LENGTH]; /** Unique Device Name */
|
||||
} FuriHalVersionOTPv2;
|
||||
|
||||
/** Represenation Model: */
|
||||
typedef struct {
|
||||
uint32_t timestamp;
|
||||
|
||||
uint8_t board_version; /** Board version */
|
||||
uint8_t board_target; /** Board target firmware */
|
||||
uint8_t board_body; /** Board body */
|
||||
uint8_t board_connect; /** Board interconnect */
|
||||
uint8_t board_color; /** Board color */
|
||||
uint8_t board_region; /** Board region */
|
||||
uint8_t board_display; /** Board display */
|
||||
|
||||
char name[FURI_HAL_VERSION_ARRAY_NAME_LENGTH]; /** \0 terminated name */
|
||||
char device_name[FURI_HAL_VERSION_DEVICE_NAME_LENGTH]; /** device name for special needs */
|
||||
uint8_t ble_mac[6];
|
||||
} FuriHalVersion;
|
||||
|
||||
static FuriHalVersion furi_hal_version = {0};
|
||||
|
||||
static void furi_hal_version_set_name(const char* name) {
|
||||
if(name != NULL) {
|
||||
strlcpy(furi_hal_version.name, name, FURI_HAL_VERSION_ARRAY_NAME_LENGTH);
|
||||
snprintf(
|
||||
furi_hal_version.device_name,
|
||||
FURI_HAL_VERSION_DEVICE_NAME_LENGTH,
|
||||
"xFlipper %s",
|
||||
furi_hal_version.name);
|
||||
} else {
|
||||
snprintf(furi_hal_version.device_name, FURI_HAL_VERSION_DEVICE_NAME_LENGTH, "xFlipper");
|
||||
}
|
||||
|
||||
furi_hal_version.device_name[0] = AD_TYPE_COMPLETE_LOCAL_NAME;
|
||||
|
||||
// BLE Mac address
|
||||
uint32_t udn = LL_FLASH_GetUDN();
|
||||
uint32_t company_id = LL_FLASH_GetSTCompanyID();
|
||||
uint32_t device_id = LL_FLASH_GetDeviceID();
|
||||
furi_hal_version.ble_mac[0] = (uint8_t)(udn & 0x000000FF);
|
||||
furi_hal_version.ble_mac[1] = (uint8_t)((udn & 0x0000FF00) >> 8);
|
||||
furi_hal_version.ble_mac[2] = (uint8_t)((udn & 0x00FF0000) >> 16);
|
||||
furi_hal_version.ble_mac[3] = (uint8_t)device_id;
|
||||
furi_hal_version.ble_mac[4] = (uint8_t)(company_id & 0x000000FF);
|
||||
furi_hal_version.ble_mac[5] = (uint8_t)((company_id & 0x0000FF00) >> 8);
|
||||
}
|
||||
|
||||
static void furi_hal_version_load_otp_default() {
|
||||
furi_hal_version_set_name(NULL);
|
||||
}
|
||||
|
||||
static void furi_hal_version_load_otp_v0() {
|
||||
const FuriHalVersionOTPv0* otp = (FuriHalVersionOTPv0*)FURI_HAL_VERSION_OTP_ADDRESS;
|
||||
|
||||
furi_hal_version.timestamp = otp->header_timestamp;
|
||||
furi_hal_version.board_version = otp->board_version;
|
||||
furi_hal_version.board_target = otp->board_target;
|
||||
furi_hal_version.board_body = otp->board_body;
|
||||
furi_hal_version.board_connect = otp->board_connect;
|
||||
|
||||
furi_hal_version_set_name(otp->name);
|
||||
}
|
||||
|
||||
static void furi_hal_version_load_otp_v1() {
|
||||
const FuriHalVersionOTPv1* otp = (FuriHalVersionOTPv1*)FURI_HAL_VERSION_OTP_ADDRESS;
|
||||
|
||||
furi_hal_version.timestamp = otp->header_timestamp;
|
||||
furi_hal_version.board_version = otp->board_version;
|
||||
furi_hal_version.board_target = otp->board_target;
|
||||
furi_hal_version.board_body = otp->board_body;
|
||||
furi_hal_version.board_connect = otp->board_connect;
|
||||
furi_hal_version.board_color = otp->board_color;
|
||||
furi_hal_version.board_region = otp->board_region;
|
||||
|
||||
furi_hal_version_set_name(otp->name);
|
||||
}
|
||||
|
||||
static void furi_hal_version_load_otp_v2() {
|
||||
const FuriHalVersionOTPv2* otp = (FuriHalVersionOTPv2*)FURI_HAL_VERSION_OTP_ADDRESS;
|
||||
|
||||
// 1st block, programmed afer baking
|
||||
furi_hal_version.timestamp = otp->header_timestamp;
|
||||
|
||||
// 2nd block, programmed afer baking
|
||||
furi_hal_version.board_version = otp->board_version;
|
||||
furi_hal_version.board_target = otp->board_target;
|
||||
furi_hal_version.board_body = otp->board_body;
|
||||
furi_hal_version.board_connect = otp->board_connect;
|
||||
furi_hal_version.board_display = otp->board_display;
|
||||
|
||||
// 3rd and 4th blocks, programmed on FATP stage
|
||||
if(otp->board_color != 0xFF) {
|
||||
furi_hal_version.board_color = otp->board_color;
|
||||
furi_hal_version.board_region = otp->board_region;
|
||||
furi_hal_version_set_name(otp->name);
|
||||
} else {
|
||||
furi_hal_version.board_color = 0;
|
||||
furi_hal_version.board_region = 0;
|
||||
furi_hal_version_set_name(NULL);
|
||||
}
|
||||
}
|
||||
|
||||
void furi_hal_version_init() {
|
||||
switch(furi_hal_version_get_otp_version()) {
|
||||
case FuriHalVersionOtpVersionUnknown:
|
||||
case FuriHalVersionOtpVersionEmpty:
|
||||
furi_hal_version_load_otp_default();
|
||||
break;
|
||||
case FuriHalVersionOtpVersion0:
|
||||
furi_hal_version_load_otp_v0();
|
||||
break;
|
||||
case FuriHalVersionOtpVersion1:
|
||||
furi_hal_version_load_otp_v1();
|
||||
break;
|
||||
case FuriHalVersionOtpVersion2:
|
||||
furi_hal_version_load_otp_v2();
|
||||
break;
|
||||
default:
|
||||
furi_crash(NULL);
|
||||
}
|
||||
|
||||
furi_hal_rtc_set_register(FuriHalRtcRegisterVersion, (uint32_t)version_get());
|
||||
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
FuriHalVersionOtpVersion furi_hal_version_get_otp_version() {
|
||||
if(*(uint64_t*)FURI_HAL_VERSION_OTP_ADDRESS == 0xFFFFFFFF) {
|
||||
return FuriHalVersionOtpVersionEmpty;
|
||||
} else {
|
||||
if(((FuriHalVersionOTPv1*)FURI_HAL_VERSION_OTP_ADDRESS)->header_magic ==
|
||||
FURI_HAL_VERSION_OTP_HEADER_MAGIC) {
|
||||
// Version 1+
|
||||
uint8_t version = ((FuriHalVersionOTPv1*)FURI_HAL_VERSION_OTP_ADDRESS)->header_version;
|
||||
if(version >= FuriHalVersionOtpVersion1 && version <= FuriHalVersionOtpVersion2) {
|
||||
return version;
|
||||
} else {
|
||||
return FuriHalVersionOtpVersionUnknown;
|
||||
}
|
||||
} else if(((FuriHalVersionOTPv0*)FURI_HAL_VERSION_OTP_ADDRESS)->board_version <= 10) {
|
||||
// Version 0
|
||||
return FuriHalVersionOtpVersion0;
|
||||
} else {
|
||||
// Version Unknown
|
||||
return FuriHalVersionOtpVersionUnknown;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t furi_hal_version_get_hw_version() {
|
||||
return furi_hal_version.board_version;
|
||||
}
|
||||
|
||||
uint8_t furi_hal_version_get_hw_target() {
|
||||
return furi_hal_version.board_target;
|
||||
}
|
||||
|
||||
uint8_t furi_hal_version_get_hw_body() {
|
||||
return furi_hal_version.board_body;
|
||||
}
|
||||
|
||||
FuriHalVersionColor furi_hal_version_get_hw_color() {
|
||||
return furi_hal_version.board_color;
|
||||
}
|
||||
|
||||
uint8_t furi_hal_version_get_hw_connect() {
|
||||
return furi_hal_version.board_connect;
|
||||
}
|
||||
|
||||
FuriHalVersionRegion furi_hal_version_get_hw_region() {
|
||||
return furi_hal_version.board_region;
|
||||
}
|
||||
|
||||
const char* furi_hal_version_get_hw_region_name() {
|
||||
switch(furi_hal_version_get_hw_region()) {
|
||||
case FuriHalVersionRegionUnknown:
|
||||
return "R00";
|
||||
case FuriHalVersionRegionEuRu:
|
||||
return "R01";
|
||||
case FuriHalVersionRegionUsCaAu:
|
||||
return "R02";
|
||||
case FuriHalVersionRegionJp:
|
||||
return "R03";
|
||||
case FuriHalVersionRegionWorld:
|
||||
return "R04";
|
||||
}
|
||||
return "R??";
|
||||
}
|
||||
|
||||
FuriHalVersionDisplay furi_hal_version_get_hw_display() {
|
||||
return furi_hal_version.board_display;
|
||||
}
|
||||
|
||||
uint32_t furi_hal_version_get_hw_timestamp() {
|
||||
return furi_hal_version.timestamp;
|
||||
}
|
||||
|
||||
const char* furi_hal_version_get_name_ptr() {
|
||||
return *furi_hal_version.name == 0x00 ? NULL : furi_hal_version.name;
|
||||
}
|
||||
|
||||
const char* furi_hal_version_get_device_name_ptr() {
|
||||
return furi_hal_version.device_name + 1;
|
||||
}
|
||||
|
||||
const char* furi_hal_version_get_ble_local_device_name_ptr() {
|
||||
return furi_hal_version.device_name;
|
||||
}
|
||||
|
||||
const uint8_t* furi_hal_version_get_ble_mac() {
|
||||
return furi_hal_version.ble_mac;
|
||||
}
|
||||
|
||||
const struct Version* furi_hal_version_get_firmware_version(void) {
|
||||
return version_get();
|
||||
}
|
||||
|
||||
size_t furi_hal_version_uid_size() {
|
||||
return 64 / 8;
|
||||
}
|
||||
|
||||
const uint8_t* furi_hal_version_uid() {
|
||||
return (const uint8_t*)UID64_BASE;
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
#include <furi_hal_version.h>
|
||||
|
||||
bool furi_hal_version_do_i_belong_here() {
|
||||
return (furi_hal_version_get_hw_target() == 7) || (furi_hal_version_get_hw_target() == 0);
|
||||
}
|
||||
|
||||
const char* furi_hal_version_get_model_name() {
|
||||
return "Flipper Zero";
|
||||
}
|
||||
|
||||
const char* furi_hal_version_get_model_code() {
|
||||
return "FZ.1";
|
||||
}
|
||||
|
||||
const char* furi_hal_version_get_fcc_id() {
|
||||
return "2A2V6-FZ";
|
||||
}
|
||||
|
||||
const char* furi_hal_version_get_ic_id() {
|
||||
return "27624-FZ";
|
||||
}
|
||||
|
||||
const char* furi_hal_version_get_mic_id() {
|
||||
return "210-175991";
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
#include <furi_hal_vibro.h>
|
||||
#include <furi_hal_gpio.h>
|
||||
|
||||
#define TAG "FuriHalVibro"
|
||||
|
||||
void furi_hal_vibro_init() {
|
||||
furi_hal_gpio_init(&gpio_vibro, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
||||
furi_hal_gpio_write(&gpio_vibro, false);
|
||||
FURI_LOG_I(TAG, "Init OK");
|
||||
}
|
||||
|
||||
void furi_hal_vibro_on(bool value) {
|
||||
furi_hal_gpio_write(&gpio_vibro, value);
|
||||
}
|
||||
Reference in New Issue
Block a user