mirror of
https://github.com/DarkFlippers/unleashed-firmware
synced 2024-12-02 17:29:14 +00:00
c1e0d02afc
* nfc: st25tb: rework async poller * nfc: st25tb: introduce sync poller * nfc: st25tb: add write support * nfc: st25tb: rewrite poller to use better states * nfc: st25tb: move to mode request state after success * nfc: st25tb: minor bug fixes * type wasn't properly set on ready event * sending NfcCustomEventPollerFailure on St25tbPollerEventTypeFailure caused poller to being freed and ultimately resulted in a thread crash Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
229 lines
7.8 KiB
C
229 lines
7.8 KiB
C
#include "st25tb_poller.h"
|
|
#include "st25tb_poller_i.h"
|
|
|
|
#include <nfc/protocols/nfc_poller_base.h>
|
|
|
|
#define TAG "ST25TBPoller"
|
|
|
|
typedef NfcCommand (*St25tbPollerStateHandler)(St25tbPoller* instance);
|
|
|
|
const St25tbData* st25tb_poller_get_data(St25tbPoller* instance) {
|
|
furi_assert(instance);
|
|
furi_assert(instance->data);
|
|
|
|
return instance->data;
|
|
}
|
|
|
|
static St25tbPoller* st25tb_poller_alloc(Nfc* nfc) {
|
|
furi_assert(nfc);
|
|
|
|
St25tbPoller* instance = malloc(sizeof(St25tbPoller));
|
|
instance->nfc = nfc;
|
|
instance->state = St25tbPollerStateSelect;
|
|
instance->tx_buffer = bit_buffer_alloc(ST25TB_POLLER_MAX_BUFFER_SIZE);
|
|
instance->rx_buffer = bit_buffer_alloc(ST25TB_POLLER_MAX_BUFFER_SIZE);
|
|
|
|
// RF configuration is the same as 14b
|
|
nfc_config(instance->nfc, NfcModePoller, NfcTechIso14443b);
|
|
nfc_set_guard_time_us(instance->nfc, ST25TB_GUARD_TIME_US);
|
|
nfc_set_fdt_poll_fc(instance->nfc, ST25TB_FDT_FC);
|
|
nfc_set_fdt_poll_poll_us(instance->nfc, ST25TB_POLL_POLL_MIN_US);
|
|
instance->data = st25tb_alloc();
|
|
|
|
instance->st25tb_event.data = &instance->st25tb_event_data;
|
|
instance->general_event.protocol = NfcProtocolSt25tb;
|
|
instance->general_event.event_data = &instance->st25tb_event;
|
|
instance->general_event.instance = instance;
|
|
|
|
return instance;
|
|
}
|
|
|
|
static void st25tb_poller_free(St25tbPoller* instance) {
|
|
furi_assert(instance);
|
|
|
|
furi_assert(instance->tx_buffer);
|
|
furi_assert(instance->rx_buffer);
|
|
furi_assert(instance->data);
|
|
|
|
bit_buffer_free(instance->tx_buffer);
|
|
bit_buffer_free(instance->rx_buffer);
|
|
st25tb_free(instance->data);
|
|
free(instance);
|
|
}
|
|
|
|
static void
|
|
st25tb_poller_set_callback(St25tbPoller* instance, NfcGenericCallback callback, void* context) {
|
|
furi_assert(instance);
|
|
furi_assert(callback);
|
|
|
|
instance->callback = callback;
|
|
instance->context = context;
|
|
}
|
|
|
|
static NfcCommand st25tb_poller_select_handler(St25tbPoller* instance) {
|
|
NfcCommand command = NfcCommandContinue;
|
|
|
|
do {
|
|
St25tbError error = st25tb_poller_select(instance, NULL);
|
|
if(error != St25tbErrorNone) {
|
|
instance->state = St25tbPollerStateFailure;
|
|
instance->st25tb_event_data.error = error;
|
|
break;
|
|
}
|
|
|
|
instance->st25tb_event.type = St25tbPollerEventTypeReady;
|
|
instance->st25tb_event.data->ready.type = instance->data->type;
|
|
command = instance->callback(instance->general_event, instance->context);
|
|
instance->state = St25tbPollerStateRequestMode;
|
|
} while(false);
|
|
|
|
return command;
|
|
}
|
|
|
|
static NfcCommand st25tb_poller_request_mode_handler(St25tbPoller* instance) {
|
|
NfcCommand command = NfcCommandContinue;
|
|
instance->st25tb_event.type = St25tbPollerEventTypeRequestMode;
|
|
command = instance->callback(instance->general_event, instance->context);
|
|
|
|
St25tbPollerEventDataModeRequest* mode_request_data =
|
|
&instance->st25tb_event_data.mode_request;
|
|
|
|
furi_assert(mode_request_data->mode < St25tbPollerModeNum);
|
|
|
|
if(mode_request_data->mode == St25tbPollerModeRead) {
|
|
instance->state = St25tbPollerStateRead;
|
|
instance->poller_ctx.read.current_block = 0;
|
|
} else {
|
|
instance->state = St25tbPollerStateWrite;
|
|
instance->poller_ctx.write.block_number =
|
|
mode_request_data->params.write_params.block_number;
|
|
instance->poller_ctx.write.block_data = mode_request_data->params.write_params.block_data;
|
|
}
|
|
|
|
return command;
|
|
}
|
|
|
|
static NfcCommand st25tb_poller_read_handler(St25tbPoller* instance) {
|
|
St25tbError error = St25tbErrorNone;
|
|
|
|
do {
|
|
uint8_t total_blocks = st25tb_get_block_count(instance->data->type);
|
|
uint8_t* current_block = &instance->poller_ctx.read.current_block;
|
|
if(*current_block == total_blocks) {
|
|
error = st25tb_poller_read_block(
|
|
instance, &instance->data->system_otp_block, ST25TB_SYSTEM_OTP_BLOCK);
|
|
if(error != St25tbErrorNone) {
|
|
FURI_LOG_E(TAG, "Failed to read OTP block");
|
|
instance->state = St25tbPollerStateFailure;
|
|
instance->st25tb_event_data.error = error;
|
|
break;
|
|
} else {
|
|
instance->state = St25tbPollerStateSuccess;
|
|
break;
|
|
}
|
|
} else {
|
|
error = st25tb_poller_read_block(
|
|
instance, &instance->data->blocks[*current_block], *current_block);
|
|
if(error != St25tbErrorNone) {
|
|
FURI_LOG_E(TAG, "Failed to read block %d", *current_block);
|
|
instance->state = St25tbPollerStateFailure;
|
|
instance->st25tb_event_data.error = error;
|
|
break;
|
|
}
|
|
|
|
*current_block += 1;
|
|
}
|
|
} while(false);
|
|
|
|
return NfcCommandContinue;
|
|
}
|
|
|
|
static NfcCommand st25tb_poller_write_handler(St25tbPoller* instance) {
|
|
St25tbPollerWriteContext* write_ctx = &instance->poller_ctx.write;
|
|
St25tbError error =
|
|
st25tb_poller_write_block(instance, write_ctx->block_data, write_ctx->block_number);
|
|
|
|
if(error == St25tbErrorNone) {
|
|
instance->state = St25tbPollerStateSuccess;
|
|
} else {
|
|
instance->state = St25tbPollerStateFailure;
|
|
instance->st25tb_event_data.error = error;
|
|
}
|
|
|
|
return NfcCommandContinue;
|
|
}
|
|
|
|
NfcCommand st25tb_poller_success_handler(St25tbPoller* instance) {
|
|
NfcCommand command = NfcCommandContinue;
|
|
instance->st25tb_event.type = St25tbPollerEventTypeSuccess;
|
|
command = instance->callback(instance->general_event, instance->context);
|
|
furi_delay_ms(100);
|
|
instance->state = St25tbPollerStateRequestMode;
|
|
|
|
return command;
|
|
}
|
|
|
|
NfcCommand st25tb_poller_failure_handler(St25tbPoller* instance) {
|
|
NfcCommand command = NfcCommandContinue;
|
|
instance->st25tb_event.type = St25tbPollerEventTypeFailure;
|
|
command = instance->callback(instance->general_event, instance->context);
|
|
furi_delay_ms(100);
|
|
instance->state = St25tbPollerStateSelect;
|
|
|
|
return command;
|
|
}
|
|
|
|
static St25tbPollerStateHandler st25tb_poller_state_handlers[St25tbPollerStateNum] = {
|
|
[St25tbPollerStateSelect] = st25tb_poller_select_handler,
|
|
[St25tbPollerStateRequestMode] = st25tb_poller_request_mode_handler,
|
|
[St25tbPollerStateRead] = st25tb_poller_read_handler,
|
|
[St25tbPollerStateWrite] = st25tb_poller_write_handler,
|
|
[St25tbPollerStateSuccess] = st25tb_poller_success_handler,
|
|
[St25tbPollerStateFailure] = st25tb_poller_failure_handler,
|
|
};
|
|
|
|
static NfcCommand st25tb_poller_run(NfcGenericEvent event, void* context) {
|
|
furi_assert(context);
|
|
furi_assert(event.protocol == NfcProtocolInvalid);
|
|
furi_assert(event.event_data);
|
|
|
|
St25tbPoller* instance = context;
|
|
NfcEvent* nfc_event = event.event_data;
|
|
NfcCommand command = NfcCommandContinue;
|
|
|
|
furi_assert(instance->state < St25tbPollerStateNum);
|
|
|
|
if(nfc_event->type == NfcEventTypePollerReady) {
|
|
command = st25tb_poller_state_handlers[instance->state](instance);
|
|
}
|
|
|
|
return command;
|
|
}
|
|
|
|
static bool st25tb_poller_detect(NfcGenericEvent event, void* context) {
|
|
furi_assert(context);
|
|
furi_assert(event.event_data);
|
|
furi_assert(event.instance);
|
|
furi_assert(event.protocol == NfcProtocolInvalid);
|
|
|
|
bool protocol_detected = false;
|
|
St25tbPoller* instance = context;
|
|
NfcEvent* nfc_event = event.event_data;
|
|
furi_assert(instance->state == St25tbPollerStateSelect);
|
|
|
|
if(nfc_event->type == NfcEventTypePollerReady) {
|
|
St25tbError error = st25tb_poller_initiate(instance, NULL);
|
|
protocol_detected = (error == St25tbErrorNone);
|
|
}
|
|
|
|
return protocol_detected;
|
|
}
|
|
|
|
const NfcPollerBase nfc_poller_st25tb = {
|
|
.alloc = (NfcPollerAlloc)st25tb_poller_alloc,
|
|
.free = (NfcPollerFree)st25tb_poller_free,
|
|
.set_callback = (NfcPollerSetCallback)st25tb_poller_set_callback,
|
|
.run = (NfcPollerRun)st25tb_poller_run,
|
|
.detect = (NfcPollerDetect)st25tb_poller_detect,
|
|
.get_data = (NfcPollerGetData)st25tb_poller_get_data,
|
|
};
|