WIP

rfal_picopass.c

@@ -1,88 +0,0 @@
-#include "seader_i.h"
-
-#define RFAL_PICOPASS_TXRX_FLAGS                                                    \
-    (FURI_HAL_NFC_LL_TXRX_FLAGS_CRC_TX_MANUAL | FURI_HAL_NFC_LL_TXRX_FLAGS_AGC_ON | \
-     FURI_HAL_NFC_LL_TXRX_FLAGS_PAR_RX_REMV | FURI_HAL_NFC_LL_TXRX_FLAGS_CRC_RX_KEEP)
-
-#define TAG "RFAL_PICOPASS"
-
-typedef struct {
-    uint8_t CMD;
-    uint8_t CSN[RFAL_PICOPASS_UID_LEN];
-} rfalPicoPassSelectReq;
-
-FuriHalNfcReturn rfalPicoPassPollerInitialize(void) {
-    FuriHalNfcReturn ret;
-
-    ret = furi_hal_nfc_ll_set_mode(
-        FuriHalNfcModePollPicopass, FuriHalNfcBitrate26p48, FuriHalNfcBitrate26p48);
-    if(ret != FuriHalNfcReturnOk) {
-        return ret;
-    };
-
-    furi_hal_nfc_ll_set_error_handling(FuriHalNfcErrorHandlingNfc);
-    furi_hal_nfc_ll_set_guard_time(FURI_HAL_NFC_LL_GT_PICOPASS);
-    furi_hal_nfc_ll_set_fdt_listen(FURI_HAL_NFC_LL_FDT_LISTEN_PICOPASS_POLLER);
-    furi_hal_nfc_ll_set_fdt_poll(FURI_HAL_NFC_LL_FDT_POLL_PICOPASS_POLLER);
-
-    return FuriHalNfcReturnOk;
-}
-
-FuriHalNfcReturn rfalPicoPassPollerCheckPresence(void) {
-    FuriHalNfcReturn ret;
-    uint8_t txBuf[1] = {RFAL_PICOPASS_CMD_ACTALL};
-    uint8_t rxBuf[32] = {0};
-    uint16_t recvLen = 0;
-    uint32_t flags = RFAL_PICOPASS_TXRX_FLAGS;
-    uint32_t fwt = furi_hal_nfc_ll_ms2fc(20);
-
-    ret = furi_hal_nfc_ll_txrx(txBuf, 1, rxBuf, 32, &recvLen, flags, fwt);
-    return ret;
-}
-
-FuriHalNfcReturn rfalPicoPassPollerIdentify(rfalPicoPassIdentifyRes* idRes) {
-    FuriHalNfcReturn ret;
-
-    uint8_t txBuf[1] = {RFAL_PICOPASS_CMD_IDENTIFY};
-    uint16_t recvLen = 0;
-    uint32_t flags = RFAL_PICOPASS_TXRX_FLAGS;
-    uint32_t fwt = furi_hal_nfc_ll_ms2fc(20);
-
-    ret = furi_hal_nfc_ll_txrx(
-        txBuf,
-        sizeof(txBuf),
-        (uint8_t*)idRes,
-        sizeof(rfalPicoPassIdentifyRes),
-        &recvLen,
-        flags,
-        fwt);
-    // printf("identify rx: %d %s\n", recvLen, hex2Str(idRes->CSN, RFAL_PICOPASS_UID_LEN));
-
-    return ret;
-}
-
-FuriHalNfcReturn rfalPicoPassPollerSelect(uint8_t* csn, rfalPicoPassSelectRes* selRes) {
-    FuriHalNfcReturn ret;
-
-    rfalPicoPassSelectReq selReq;
-    selReq.CMD = RFAL_PICOPASS_CMD_SELECT;
-    memcpy(selReq.CSN, csn, RFAL_PICOPASS_UID_LEN);
-    uint16_t recvLen = 0;
-    uint32_t flags = RFAL_PICOPASS_TXRX_FLAGS;
-    uint32_t fwt = furi_hal_nfc_ll_ms2fc(20);
-
-    ret = furi_hal_nfc_ll_txrx(
-        (uint8_t*)&selReq,
-        sizeof(rfalPicoPassSelectReq),
-        (uint8_t*)selRes,
-        sizeof(rfalPicoPassSelectRes),
-        &recvLen,
-        flags,
-        fwt);
-    // printf("select rx: %d %s\n", recvLen, hex2Str(selRes->CSN, RFAL_PICOPASS_UID_LEN));
-    if(ret == FuriHalNfcReturnTimeout) {
-        return FuriHalNfcReturnOk;
-    }
-
-    return ret;
-}

rfal_picopass.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <furi_hal_nfc.h>
-
-#define RFAL_PICOPASS_UID_LEN 8
-#define RFAL_PICOPASS_MAX_BLOCK_LEN 8
-
-enum {
-    RFAL_PICOPASS_CMD_ACTALL = 0x0A,
-    RFAL_PICOPASS_CMD_IDENTIFY = 0x0C,
-    RFAL_PICOPASS_CMD_SELECT = 0x81,
-    RFAL_PICOPASS_CMD_READCHECK = 0x88,
-    RFAL_PICOPASS_CMD_CHECK = 0x05,
-    RFAL_PICOPASS_CMD_READ4 = 0x06,
-    RFAL_PICOPASS_CMD_READ = 0x0C,
-    RFAL_PICOPASS_CMD_WRITE = 0x87,
-};
-
-typedef struct {
-    uint8_t CSN[RFAL_PICOPASS_UID_LEN]; // Anti-collision CSN
-    uint8_t crc[2];
-} rfalPicoPassIdentifyRes;
-
-typedef struct {
-    uint8_t CSN[RFAL_PICOPASS_UID_LEN]; // Real CSN
-    uint8_t crc[2];
-} rfalPicoPassSelectRes;
-
-FuriHalNfcReturn rfalPicoPassPollerInitialize(void);
-FuriHalNfcReturn rfalPicoPassPollerCheckPresence(void);
-FuriHalNfcReturn rfalPicoPassPollerIdentify(rfalPicoPassIdentifyRes* idRes);
-FuriHalNfcReturn rfalPicoPassPollerSelect(uint8_t* csn, rfalPicoPassSelectRes* selRes);

scenes/seader_scene_config.h

@@ -14,4 +14,3 @@ ADD_SCENE(seader, delete, Delete)
 ADD_SCENE(seader, delete_success, DeleteSuccess)
 ADD_SCENE(seader, credential_info, CredentialInfo)
 ADD_SCENE(seader, sam_info, SamInfo)
-ADD_SCENE(seader, uart, Uart)

scenes/seader_scene_read_14a.c

@@ -18,13 +18,8 @@ void seader_scene_read_14a_on_enter(void* context) {
 
     // Start worker
     view_dispatcher_switch_to_view(seader->view_dispatcher, SeaderViewPopup);
-    seader_worker_start(
-        seader->worker,
-        SeaderWorkerStateRead14a,
-        seader->uart,
-        seader->credential,
-        seader_read_14a_worker_callback,
-        seader);
+
+    seader->poller = nfc_poller_alloc(seader->nfc, NfcProtocolIso14443_4a);
 
     seader_blink_start(seader);
 }
@@ -35,19 +30,27 @@ bool seader_scene_read_14a_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SeaderCustomEventWorkerExit) {
+            nfc_poller_stop(seader->poller);
+            nfc_poller_free(seader->poller);
             seader->credential->type = SeaderCredentialType14A;
             scene_manager_next_scene(seader->scene_manager, SeaderSceneReadCardSuccess);
             consumed = true;
         }
+    } else if(event.type == SceneManagerEventTypeBack) {
+        nfc_poller_stop(seader->poller);
+        nfc_poller_free(seader->poller);
+        static const uint32_t possible_scenes[] = {SeaderSceneStart};
+        scene_manager_search_and_switch_to_previous_scene_one_of(
+            seader->scene_manager, possible_scenes, COUNT_OF(possible_scenes));
+        consumed = true;
     }
+
     return consumed;
 }
 
 void seader_scene_read_14a_on_exit(void* context) {
     Seader* seader = context;
 
-    // Stop worker
-    seader_worker_stop(seader->worker);
     // Clear view
     popup_reset(seader->popup);
 

scenes/seader_scene_sam_present.c

@@ -66,28 +66,14 @@ bool seader_scene_sam_present_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == SubmenuIndexReadPicopass) {
-            if(seader->is_debug_enabled) {
-                seader->credential->type = SeaderCredentialTypePicopass;
-                scene_manager_set_scene_state(
-                    seader->scene_manager, SeaderSceneSamPresent, SubmenuIndexReadPicopass);
-                scene_manager_next_scene(seader->scene_manager, SeaderSceneUart);
-            } else {
                 scene_manager_set_scene_state(
                     seader->scene_manager, SeaderSceneSamPresent, SubmenuIndexReadPicopass);
                 scene_manager_next_scene(seader->scene_manager, SeaderSceneReadPicopass);
-            }
             consumed = true;
         } else if(event.event == SubmenuIndexRead14a) {
-            if(seader->is_debug_enabled) {
-                seader->credential->type = SeaderCredentialType14A;
-                scene_manager_set_scene_state(
-                    seader->scene_manager, SeaderSceneSamPresent, SubmenuIndexRead14a);
-                scene_manager_next_scene(seader->scene_manager, SeaderSceneUart);
-            } else {
                 scene_manager_set_scene_state(
                     seader->scene_manager, SeaderSceneSamPresent, SubmenuIndexRead14a);
                 scene_manager_next_scene(seader->scene_manager, SeaderSceneRead14a);
-            }
             consumed = true;
         } else if(event.event == SubmenuIndexSamInfo) {
             scene_manager_set_scene_state(

scenes/seader_scene_uart.c

@@ -1,101 +0,0 @@
-#include "../seader_i.h"
-#include "../seader_bridge.h"
-#define TAG "SeaderSceneUart"
-
-typedef struct {
-    SeaderUartConfig cfg;
-    SeaderUartState state;
-} SceneUartBridge;
-
-static SceneUartBridge* scene_uart;
-
-void seader_uart_worker_callback(SeaderWorkerEvent event, void* context) {
-    UNUSED(event);
-    Seader* seader = context;
-    view_dispatcher_send_custom_event(seader->view_dispatcher, SeaderCustomEventWorkerExit);
-}
-
-void seader_scene_uart_callback(SeaderCustomEvent event, void* context) {
-    furi_assert(context);
-    Seader* app = context;
-    view_dispatcher_send_custom_event(app->view_dispatcher, event);
-}
-
-void seader_scene_uart_on_enter(void* context) {
-    Seader* app = context;
-    uint32_t prev_state = scene_manager_get_scene_state(app->scene_manager, SeaderViewUart);
-    if(prev_state == 0) {
-        scene_uart = malloc(sizeof(SceneUartBridge));
-        scene_uart->cfg.uart_ch = 0;
-        scene_uart->cfg.flow_pins = 0;
-        scene_uart->cfg.baudrate_mode = 0;
-        scene_uart->cfg.baudrate = 0;
-    }
-
-    seader_uart_get_config(app->uart, &scene_uart->cfg);
-    seader_uart_get_state(app->uart, &scene_uart->state);
-
-    seader_uart_view_set_callback(app->seader_uart_view, seader_scene_uart_callback, app);
-    scene_manager_set_scene_state(app->scene_manager, SeaderSceneUart, 0);
-    view_dispatcher_switch_to_view(app->view_dispatcher, SeaderViewUart);
-    notification_message(app->notifications, &sequence_display_backlight_enforce_on);
-
-    Seader* seader = app;
-
-    if(seader->credential->type == SeaderCredentialTypePicopass) {
-        seader_worker_start(
-            seader->worker,
-            SeaderWorkerStateReadPicopass,
-            seader->uart,
-            seader->credential,
-            seader_uart_worker_callback,
-            seader);
-    } else if(seader->credential->type == SeaderCredentialType14A) {
-        seader_worker_start(
-            seader->worker,
-            SeaderWorkerStateRead14a,
-            seader->uart,
-            seader->credential,
-            seader_uart_worker_callback,
-            seader);
-    }
-}
-
-bool seader_scene_uart_on_event(void* context, SceneManagerEvent event) {
-    Seader* app = context;
-    Seader* seader = context;
-    bool consumed = false;
-
-    if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == SeaderCustomEventWorkerExit) {
-            scene_manager_next_scene(seader->scene_manager, SeaderSceneReadCardSuccess);
-            consumed = true;
-        } else if(event.type == SceneManagerEventTypeTick) {
-            scene_manager_set_scene_state(app->scene_manager, SeaderSceneUart, 1);
-            consumed = true;
-        }
-    } else if(event.type == SceneManagerEventTypeTick) {
-        uint32_t tx_cnt_last = scene_uart->state.tx_cnt;
-        uint32_t rx_cnt_last = scene_uart->state.rx_cnt;
-        seader_uart_get_state(app->uart, &scene_uart->state);
-        if(seader->credential->type == SeaderCredentialTypePicopass) {
-            scene_uart->state.protocol = FrameProtocol_iclass;
-        } else if(seader->credential->type == SeaderCredentialType14A) {
-            scene_uart->state.protocol = FrameProtocol_nfc;
-        }
-        seader_uart_view_update_state(app->seader_uart_view, &scene_uart->cfg, &scene_uart->state);
-        if(tx_cnt_last != scene_uart->state.tx_cnt) {
-            notification_message(app->notifications, &sequence_blink_blue_10);
-        }
-        if(rx_cnt_last != scene_uart->state.rx_cnt) {
-            notification_message(app->notifications, &sequence_blink_green_10);
-        }
-    }
-    return consumed;
-}
-
-void seader_scene_uart_on_exit(void* context) {
-    Seader* app = context;
-    seader_worker_stop(app->worker);
-    notification_message(app->notifications, &sequence_display_backlight_enforce_auto);
-}

seader.c

@@ -45,6 +45,12 @@ Seader* seader_alloc() {
 
     seader->credential = seader_credential_alloc();
 
+    seader->nfc = nfc_alloc();
+
+    // Nfc device
+    seader->nfc_device = nfc_device_alloc();
+    nfc_device_set_loading_callback(seader->nfc_device, seader_show_loading_popup, seader);
+
     // Open GUI record
     seader->gui = furi_record_open(RECORD_GUI);
     view_dispatcher_attach_to_gui(
@@ -78,12 +84,6 @@ Seader* seader_alloc() {
     view_dispatcher_add_view(
         seader->view_dispatcher, SeaderViewWidget, widget_get_view(seader->widget));
 
-    seader->seader_uart_view = seader_uart_view_alloc();
-    view_dispatcher_add_view(
-        seader->view_dispatcher,
-        SeaderViewUart,
-        seader_uart_view_get_view(seader->seader_uart_view));
-
     return seader;
 }
 
@@ -100,6 +100,11 @@ void seader_free(Seader* seader) {
     seader_credential_free(seader->credential);
     seader->credential = NULL;
 
+    nfc_free(seader->nfc);
+
+    // Nfc device
+    nfc_device_free(seader->nfc_device);
+
     // Submenu
     view_dispatcher_remove_view(seader->view_dispatcher, SeaderViewMenu);
     submenu_free(seader->submenu);
@@ -120,9 +125,6 @@ void seader_free(Seader* seader) {
     view_dispatcher_remove_view(seader->view_dispatcher, SeaderViewWidget);
     widget_free(seader->widget);
 
-    view_dispatcher_remove_view(seader->view_dispatcher, SeaderViewUart);
-    seader_uart_view_free(seader->seader_uart_view);
-
     // Worker
     seader_worker_stop(seader->worker);
     seader_worker_free(seader->worker);

seader_custom_event.h

@@ -1,5 +0,0 @@
-#pragma once
-
-typedef enum {
-    SeaderStartEventNone = 0,
-} SeaderCustomEvent;

seader_i.h

@@ -22,6 +22,17 @@
 
 #include <input/input.h>
 
+#include <lib/nfc/nfc.h>
+#include <lib/nfc/protocols/iso14443_3a/iso14443_3a.h>
+#include <lib/nfc/protocols/iso14443_3a/iso14443_3a_listener.h>
+#include <lib/nfc/protocols/mf_ultralight/mf_ultralight_listener.h>
+
+#include <nfc/nfc_poller.h>
+#include <nfc/nfc_scanner.h>
+
+#include <nfc/nfc_device.h>
+#include <nfc/helpers/nfc_data_generator.h>
+
 // ASN1
 #include <asn_system.h>
 #include <asn_internal.h>
@@ -33,13 +44,11 @@
 #include <FrameProtocol.h>
 
 #include "scenes/seader_scene.h"
-#include "views/seader_uart_view.h"
 
 #include "seader_bridge.h"
 #include "seader.h"
 #include "ccid.h"
 #include "uart.h"
-#include "rfal_picopass.h"
 #include "seader_worker.h"
 #include "seader_credential.h"
 
@@ -95,8 +104,11 @@ struct Seader {
     TextInput* text_input;
     Widget* widget;
 
-    //Custom views
-    SeaderUartView* seader_uart_view;
+    Nfc* nfc;
+    NfcPoller* poller;
+    NfcScanner* scanner;
+
+    NfcDevice* nfc_device;
 };
 
 typedef enum {

seader_worker.c

@@ -1,7 +1,6 @@
 #include "seader_worker_i.h"
 
 #include <flipper_format/flipper_format.h>
-#include <lib/nfc/protocols/nfc_util.h>
 #include <lib/lfrfid/tools/bit_lib.h>
 
 #define TAG "SeaderWorker"
@@ -25,45 +24,6 @@ bool requestPacs = true;
 // Forward declaration
 void seader_send_card_detected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails);
 
-static void seader_worker_enable_field() {
-    furi_hal_nfc_ll_txrx_on();
-    furi_hal_nfc_acquire();
-    furi_hal_nfc_ll_poll();
-}
-
-static ReturnCode seader_worker_disable_field(ReturnCode rc) {
-    furi_hal_nfc_ll_txrx_off();
-    furi_hal_nfc_field_detect_stop();
-    furi_hal_nfc_release();
-    return rc;
-}
-
-static uint16_t seader_worker_picopass_update_ccitt(uint16_t crcSeed, uint8_t dataByte) {
-    uint16_t crc = crcSeed;
-    uint8_t dat = dataByte;
-
-    dat ^= (uint8_t)(crc & 0xFFU);
-    dat ^= (dat << 4);
-
-    crc = (crc >> 8) ^ (((uint16_t)dat) << 8) ^ (((uint16_t)dat) << 3) ^ (((uint16_t)dat) >> 4);
-
-    return crc;
-}
-
-static uint16_t seader_worker_picopass_calculate_ccitt(
-    uint16_t preloadValue,
-    const uint8_t* buf,
-    uint16_t length) {
-    uint16_t crc = preloadValue;
-    uint16_t index;
-
-    for(index = 0; index < length; index++) {
-        crc = seader_worker_picopass_update_ccitt(crc, buf[index]);
-    }
-
-    return crc;
-}
-
 /***************************** Seader Worker API *******************************/
 
 SeaderWorker* seader_worker_alloc() {
@@ -122,7 +82,7 @@ void seader_worker_stop(SeaderWorker* seader_worker) {
        seader_worker->state == SeaderWorkerStateReady) {
         return;
     }
-    seader_worker_disable_field(ERR_NONE);
+    // seader_worker_disable_field();
 
     seader_worker_change_state(seader_worker, SeaderWorkerStateStop);
     furi_thread_join(seader_worker->thread);
@@ -138,15 +98,7 @@ void* calloc(size_t count, size_t size) {
     return malloc(count * size);
 }
 
-void seader_nfc_scene_field_on_enter() {
-    furi_hal_nfc_field_on();
-    furi_hal_nfc_acquire();
-}
 
-void seader_nfc_scene_field_on_exit() {
-    furi_hal_nfc_sleep();
-    furi_hal_nfc_field_off();
-}
 
 bool seader_send_apdu(
     SeaderUartBridge* seader_uart,
@@ -186,66 +138,9 @@ static int seader_asn_to_string(const void* buffer, size_t size, void* app_key)
     return 0;
 }
 
-bool seader_mf_df_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
-    return ATQA0 == 0x44 && ATQA1 == 0x03 && SAK == 0x20;
-}
-
-bool seader_mf_classic_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
-    if((ATQA0 == 0x44 || ATQA0 == 0x04) && (SAK == 0x08 || SAK == 0x88 || SAK == 0x09)) {
-        return true;
-    } else if((ATQA0 == 0x01) && (ATQA1 == 0x0F) && (SAK == 0x01)) {
-        //skylanders support
-        return true;
-    } else if((ATQA0 == 0x42 || ATQA0 == 0x02) && (SAK == 0x18)) {
-        return true;
-    } else {
-        return false;
-    }
-}
-
 bool seader_read_nfc(SeaderUartBridge* seader_uart) {
-    FuriHalNfcDevData nfc_data = {};
-    bool rtn = false;
-    if(furi_hal_nfc_detect(&nfc_data, 300)) {
-        // Process first found device
-        if(nfc_data.type == FuriHalNfcTypeA) {
-            FURI_LOG_D(TAG, "NFC-A detected");
-            CardDetails_t* cardDetails = 0;
-            cardDetails = calloc(1, sizeof *cardDetails);
-            assert(cardDetails);
-
-            OCTET_STRING_fromBuf(&cardDetails->csn, (const char*)nfc_data.uid, nfc_data.uid_len);
-            uint8_t protocolBytes[] = {0x00, FrameProtocol_nfc};
-            OCTET_STRING_fromBuf(
-                &cardDetails->protocol, (const char*)protocolBytes, sizeof(protocolBytes));
-
-            OCTET_STRING_t sak = {.buf = &(nfc_data.sak), .size = 1};
-            cardDetails->sak = &sak;
-
-            uint8_t fake_seos_ats[] = {0x78, 0x77, 0x80, 0x02};
-            uint8_t fake_desfire_ats[] = {0x75, 0x77, 0x81, 0x02, 0x80};
-            if(seader_mf_df_check_card_type(nfc_data.atqa[0], nfc_data.atqa[1], nfc_data.sak)) {
-                FURI_LOG_D(TAG, "Desfire");
-                OCTET_STRING_t atqa = {.buf = fake_desfire_ats, .size = sizeof(fake_desfire_ats)};
-                cardDetails->atqa = &atqa;
-                seader_send_card_detected(seader_uart, cardDetails);
-                rtn = true;
-            } else if(seader_mf_classic_check_card_type(
-                          nfc_data.atqa[0], nfc_data.atqa[1], nfc_data.sak)) {
-                FURI_LOG_D(TAG, "MFC");
-                seader_send_card_detected(seader_uart, cardDetails);
-                rtn = true;
-            } else if(nfc_data.interface == FuriHalNfcInterfaceIsoDep) {
-                FURI_LOG_D(TAG, "ISO-DEP");
-                OCTET_STRING_t atqa = {.buf = fake_seos_ats, .size = sizeof(fake_seos_ats)};
-                cardDetails->atqa = &atqa;
-                seader_send_card_detected(seader_uart, cardDetails);
-                rtn = true;
-            }
-            ASN_STRUCT_FREE(asn_DEF_CardDetails, cardDetails);
-        }
-    }
-    return rtn;
+  UNUSED(seader_uart);
+    return false;
 }
 
 bool seader_detect_nfc(SeaderWorker* seader_worker) {
@@ -551,203 +446,8 @@ void seader_send_nfc_rx(SeaderUartBridge* seader_uart, uint8_t* buffer, size_t l
     ASN_STRUCT_FREE(asn_DEF_Response, response);
 }
 
-bool seader_iso14443a_transmit(
-    SeaderWorker* seader_worker,
-    uint8_t* buffer,
-    size_t len,
-    uint16_t timeout,
-    uint8_t format[3]) {
-    SeaderUartBridge* seader_uart = seader_worker->uart;
-    FuriHalNfcTxRxContext tx_rx = {.tx_rx_type = FuriHalNfcTxRxTypeDefault};
-
-    memcpy(&tx_rx.tx_data, buffer, len);
-    tx_rx.tx_bits = len * 8;
-
-    if(format[0] == 0x00 && format[1] == 0xC0 && format[2] == 0x00) {
-        tx_rx.tx_rx_type = FuriHalNfcTxRxTypeRxNoCrc;
-        tx_rx.tx_bits -= 16;
-    } else if(
-        (format[0] == 0x00 && format[1] == 0x00 && format[2] == 0x40) ||
-        (format[0] == 0x00 && format[1] == 0x00 && format[2] == 0x24) ||
-        (format[0] == 0x00 && format[1] == 0x00 && format[2] == 0x44)) {
-        tx_rx.tx_rx_type = FuriHalNfcTxRxTypeRaw;
-        tx_rx.tx_bits -= 8;
-        tx_rx.tx_parity[0] = 0;
-
-        // Don't forget to swap the bits of buffer[8]
-        for(size_t i = 0; i < 8 + 1; i++) {
-            bit_lib_reverse_bits(buffer + i, 0, 8);
-        }
-
-        // Pull out parity bits
-        for(size_t i = 0; i < 8; i++) {
-            bool val = bit_lib_get_bit(buffer + i + 1, i);
-            bit_lib_set_bit(tx_rx.tx_parity, i, val);
-        }
-
-        for(size_t i = 0; i < 8; i++) {
-            buffer[i] = (buffer[i] << i) | (buffer[i + 1] >> (8 - i));
-        }
-
-        for(size_t i = 0; i < 8; i++) {
-            bit_lib_reverse_bits(buffer + i, 0, 8);
-            tx_rx.tx_data[i] = buffer[i];
-        }
-    }
-
-    if(furi_hal_nfc_tx_rx(&tx_rx, timeout)) {
-        furi_delay_ms(1);
-        size_t length = tx_rx.rx_bits / 8;
-        memset(display, 0, sizeof(display));
-        for(uint8_t i = 0; i < length; i++) {
-            snprintf(display + (i * 2), sizeof(display), "%02x", tx_rx.rx_data[i]);
-        }
-        FURI_LOG_D(TAG, "NFC Response %d: %s [%02x]", length, display, tx_rx.rx_parity[0]);
-
-        if(tx_rx.tx_rx_type == FuriHalNfcTxRxTypeRaw) {
-            for(size_t i = 0; i < length; i++) {
-                bit_lib_reverse_bits(tx_rx.rx_data + i, 0, 8);
-            }
-
-            uint8_t with_parity[FURI_HAL_NFC_DATA_BUFF_SIZE];
-            memset(with_parity, 0, sizeof(with_parity));
-            length = length + (length / 8) + 1;
-
-            uint8_t parts = 1 + length / 9;
-            for(size_t p = 0; p < parts; p++) {
-                uint8_t doffset = p * 9;
-                uint8_t soffset = p * 8;
-
-                for(size_t i = 0; i < 9; i++) {
-                    with_parity[i + doffset] = tx_rx.rx_data[i + soffset] >> i;
-                    if(i > 0) {
-                        with_parity[i + doffset] |= tx_rx.rx_data[i + soffset - 1] << (9 - i);
-                    }
-
-                    if(i > 0) {
-                        bool val = bit_lib_get_bit(tx_rx.rx_parity, i - 1);
-                        bit_lib_set_bit(with_parity + i, i - 1, val);
-                    }
-                }
-            }
-
-            memcpy(tx_rx.rx_data, with_parity, length);
-
-            for(size_t i = 0; i < length; i++) {
-                bit_lib_reverse_bits(tx_rx.rx_data + i, 0, 8);
-            }
-
-            memset(display, 0, sizeof(display));
-
-            for(uint8_t i = 0; i < length; i++) {
-                snprintf(display + (i * 2), sizeof(display), "%02x", tx_rx.rx_data[i]);
-            }
-            FURI_LOG_D(
-                TAG, "Mutated NFC Response %d: %s [%02x]", length, display, tx_rx.rx_parity[0]);
-        }
-
-        seader_send_nfc_rx(seader_uart, tx_rx.rx_data, length);
-    } else {
-        FURI_LOG_W(TAG, "Bad exchange");
-        if(seader_worker->callback) {
-            seader_worker->callback(SeaderWorkerEventFail, seader_worker->context);
-        }
-    }
-
-    return false;
-}
-
-uint8_t read4Block6[] = {0x06, 0x06, 0x45, 0x56};
-uint8_t read4Block9[] = {0x06, 0x09, 0xB2, 0xAE};
-uint8_t read4Block10[] = {0x06, 0x0A, 0x29, 0x9C};
-uint8_t read4Block13[] = {0x06, 0x0D, 0x96, 0xE8};
-uint8_t updateBlock2[] = {0x87, 0x02};
-
-void seader_capture_sio(
-    uint8_t* buffer,
-    size_t len,
-    uint8_t* rxBuffer,
-    SeaderCredential* credential) {
-    if(memcmp(buffer, read4Block6, len) == 0 && rxBuffer[0] == 0x30) {
-        memcpy(credential->sio, rxBuffer, 32);
-    } else if(memcmp(buffer, read4Block10, len) == 0 && rxBuffer[0] == 0x30) {
-        memcpy(credential->sio, rxBuffer, 32);
-    } else if(memcmp(buffer, read4Block9, len) == 0) {
-        memcpy(credential->sio + 32, rxBuffer + 8, 24);
-    } else if(memcmp(buffer, read4Block13, len) == 0) {
-        memcpy(credential->sio + 32, rxBuffer + 8, 24);
-    }
-}
-
-FuriHalNfcReturn
-    seader_worker_fake_epurse_update(uint8_t* buffer, uint8_t* rxBuffer, uint16_t* recvLen) {
-    uint8_t fake_response[10];
-    memset(fake_response, 0, sizeof(fake_response));
-    memcpy(fake_response + 0, buffer + 6, 4);
-    memcpy(fake_response + 4, buffer + 2, 4);
-
-    uint16_t crc = seader_worker_picopass_calculate_ccitt(0xE012, fake_response, 8);
-    memcpy(fake_response + 8, &crc, sizeof(uint16_t));
-
-    memcpy(rxBuffer, fake_response, sizeof(fake_response));
-    *recvLen = sizeof(fake_response);
-
-    memset(display, 0, sizeof(display));
-    for(uint8_t i = 0; i < sizeof(fake_response); i++) {
-        snprintf(display + (i * 2), sizeof(display), "%02x", fake_response[i]);
-    }
-    FURI_LOG_I(TAG, "Fake update E-Purse response: %s", display);
-    return FuriHalNfcReturnOk;
-}
-
-bool seader_iso15693_transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len) {
-    SeaderUartBridge* seader_uart = seader_worker->uart;
-    SeaderCredential* credential = seader_worker->credential;
-    char display[SEADER_UART_RX_BUF_SIZE * 2 + 1] = {0};
-    FuriHalNfcReturn ret;
-    uint16_t recvLen = 0;
-    uint32_t flags = RFAL_PICOPASS_TXRX_FLAGS;
-    uint32_t fwt = furi_hal_nfc_ll_ms2fc(20);
-
-    uint8_t rxBuffer[64] = {0};
-
-    if(memcmp(buffer, updateBlock2, sizeof(updateBlock2)) == 0) {
-        ret = seader_worker_fake_epurse_update(buffer, rxBuffer, &recvLen);
-    } else {
-        ret = furi_hal_nfc_ll_txrx(buffer, len, rxBuffer, sizeof(rxBuffer), &recvLen, flags, fwt);
-    }
-
-    if(ret == FuriHalNfcReturnOk) {
-        memset(display, 0, sizeof(display));
-        for(uint8_t i = 0; i < recvLen; i++) {
-            snprintf(display + (i * 2), sizeof(display), "%02x", rxBuffer[i]);
-        }
-        // FURI_LOG_D(TAG, "Result %d %s", recvLen, display);
-        seader_capture_sio(buffer, len, rxBuffer, credential);
-        seader_send_nfc_rx(seader_uart, rxBuffer, recvLen);
-    } else if(ret == FuriHalNfcReturnCrc) {
-        memset(display, 0, sizeof(display));
-        for(uint8_t i = 0; i < recvLen; i++) {
-            snprintf(display + (i * 2), sizeof(display), "%02x", rxBuffer[i]);
-        }
-        // FURI_LOG_D(TAG, "[CRC error] Result %d %s", recvLen, display);
-        seader_capture_sio(buffer, len, rxBuffer, credential);
-        seader_send_nfc_rx(seader_uart, rxBuffer, recvLen);
-
-        // Act as if it was OK
-        return true;
-    } else {
-        FURI_LOG_E(TAG, "furi_hal_nfc_ll_txrx Error %d", ret);
-
-        if(seader_worker->callback) {
-            seader_worker->callback(SeaderWorkerEventFail, seader_worker->context);
-        }
-    }
-
-    return ret == FuriHalNfcReturnOk;
-}
-
 bool seader_parse_nfc_command_transmit(SeaderWorker* seader_worker, NFCSend_t* nfcSend) {
+  UNUSED(seader_worker);
     long timeOut = nfcSend->timeOut;
     Protocol_t protocol = nfcSend->protocol;
     FrameProtocol_t frameProtocol = protocol.buf[1];
@@ -774,22 +474,17 @@ bool seader_parse_nfc_command_transmit(SeaderWorker* seader_worker, NFCSend_t* n
 #endif
 
     if(frameProtocol == FrameProtocol_iclass) {
-        return seader_iso15693_transmit(seader_worker, nfcSend->data.buf, nfcSend->data.size);
+      // TODO
     } else if(frameProtocol == FrameProtocol_nfc) {
-        return seader_iso14443a_transmit(
-            seader_worker,
-            nfcSend->data.buf,
-            nfcSend->data.size,
-            (uint16_t)timeOut,
-            nfcSend->format->buf);
+      // TODO
     }
     return false;
 }
 
 bool seader_parse_nfc_off(SeaderUartBridge* seader_uart) {
     FURI_LOG_D(TAG, "Set Field Off");
-    seader_worker_disable_field(ERR_NONE);
-    seader_nfc_scene_field_on_exit();
+    // seader_worker_disable_field();
+    // seader_nfc_scene_field_on_exit();
 
     NFCResponse_t* nfcResponse = 0;
     nfcResponse = calloc(1, sizeof *nfcResponse);
@@ -910,95 +605,6 @@ bool seader_process_apdu(SeaderWorker* seader_worker, uint8_t* apdu, size_t len)
     return false;
 }
 
-ReturnCode seader_picopass_card_init(SeaderWorker* seader_worker) {
-    SeaderUartBridge* seader_uart = seader_worker->uart;
-    SeaderCredential* credential = seader_worker->credential;
-    rfalPicoPassIdentifyRes idRes;
-    rfalPicoPassSelectRes selRes;
-
-    ReturnCode err;
-
-    err = rfalPicoPassPollerIdentify(&idRes);
-    if(err != ERR_NONE) {
-        FURI_LOG_E(TAG, "rfalPicoPassPollerIdentify error %d", err);
-        return err;
-    }
-
-    err = rfalPicoPassPollerSelect(idRes.CSN, &selRes);
-    if(err != ERR_NONE) {
-        FURI_LOG_E(TAG, "rfalPicoPassPollerSelect error %d", err);
-        return err;
-    }
-
-    memset(display, 0, sizeof(display));
-    for(uint8_t i = 0; i < RFAL_PICOPASS_MAX_BLOCK_LEN; i++) {
-        snprintf(display + (i * 2), sizeof(display), "%02x", selRes.CSN[i]);
-    }
-
-    FURI_LOG_D(TAG, "Sending card detected info: %s", display);
-
-    CardDetails_t* cardDetails = 0;
-    cardDetails = calloc(1, sizeof *cardDetails);
-    assert(cardDetails);
-
-    uint8_t protocolBytes[] = {0x00, FrameProtocol_iclass};
-    OCTET_STRING_fromBuf(
-        &cardDetails->protocol, (const char*)protocolBytes, sizeof(protocolBytes));
-    OCTET_STRING_fromBuf(&cardDetails->csn, (const char*)selRes.CSN, RFAL_PICOPASS_MAX_BLOCK_LEN);
-
-    memcpy(credential->diversifier, selRes.CSN, RFAL_PICOPASS_MAX_BLOCK_LEN);
-
-    seader_send_card_detected(seader_uart, cardDetails);
-
-    ASN_STRUCT_FREE(asn_DEF_CardDetails, cardDetails);
-    return ERR_NONE;
-}
-
-ReturnCode seader_picopass_card_detect() {
-    ReturnCode err;
-
-    err = rfalPicoPassPollerInitialize();
-    if(err != ERR_NONE) {
-        FURI_LOG_E(TAG, "rfalPicoPassPollerInitialize error %d", err);
-        return err;
-    }
-
-    err = rfalFieldOnAndStartGT();
-    if(err != ERR_NONE) {
-        FURI_LOG_E(TAG, "rfalFieldOnAndStartGT error %d", err);
-        return err;
-    }
-
-    err = rfalPicoPassPollerCheckPresence();
-    if(err != ERR_RF_COLLISION) {
-        if(err != ERR_TIMEOUT) {
-            FURI_LOG_E(TAG, "rfalPicoPassPollerCheckPresence error %d", err);
-        }
-        return err;
-    }
-
-    return ERR_NONE;
-}
-
-ReturnCode seader_picopass_card_read(SeaderWorker* seader_worker) {
-    ReturnCode err = ERR_TIMEOUT;
-
-    while(seader_worker->state == SeaderWorkerStateReadPicopass) {
-        // Card found
-        if(seader_picopass_card_detect() == ERR_NONE) {
-            err = seader_picopass_card_init(seader_worker);
-            if(err != ERR_NONE) {
-                FURI_LOG_E(TAG, "picopass_card_init error %d", err);
-            }
-            break;
-        }
-
-        furi_delay_ms(100);
-    }
-
-    return err;
-}
-
 void seader_worker_process_sam_message(SeaderWorker* seader_worker, CCID_Message* message) {
     if(seader_process_apdu(seader_worker, message->payload, message->dwLength)) {
         // no-op
@@ -1026,20 +632,16 @@ int32_t seader_worker_task(void* context) {
         requestPacs = true;
         seader_credential_clear(seader_worker->credential);
         seader_worker->credential->type = SeaderCredentialTypePicopass;
-        seader_worker_enable_field();
-        if(seader_picopass_card_read(seader_worker) != ERR_NONE) {
-            // Turn off if cancelled / no card found
-            seader_worker_disable_field(ERR_NONE);
-        }
+        // TODO
     } else if(seader_worker->state == SeaderWorkerStateRead14a) {
         FURI_LOG_D(TAG, "Read 14a");
         requestPacs = true;
         seader_credential_clear(seader_worker->credential);
         seader_worker->credential->type = SeaderCredentialType14A;
-        seader_nfc_scene_field_on_enter();
+        // seader_nfc_scene_field_on_enter();
         if(!seader_detect_nfc(seader_worker)) {
             // Turn off if cancelled / no card found
-            seader_nfc_scene_field_on_exit();
+            // seader_nfc_scene_field_on_exit();
         }
     }
     FURI_LOG_D(TAG, "Worker Task Complete");

seader_worker_i.h

@@ -9,16 +9,13 @@
 #include <furi_hal.h>
 
 #include <stdlib.h>
-#include <rfal_rf.h>
 
-#include <platform.h>
 #include <PAC.h>
 #include <SamVersion.h>
 
 struct SeaderWorker {
     FuriThread* thread;
     Storage* storage;
-    Stream* dict_stream;
     uint8_t sam_version[2];
 
     SeaderUartBridge* uart;

views/seader_uart_view.c

@@ -1,152 +0,0 @@
-#include "../seader_bridge.h"
-#include "../seader_i.h"
-#include <furi_hal.h>
-#include <gui/elements.h>
-
-struct SeaderUartView {
-    View* view;
-    SeaderUartViewCallback callback;
-    void* context;
-};
-
-typedef struct {
-    uint32_t tx_cnt;
-    uint32_t rx_cnt;
-    bool tx_active;
-    bool rx_active;
-    uint8_t protocol;
-} SeaderUartViewModel;
-
-static void seader_uart_view_draw_callback(Canvas* canvas, void* _model) {
-    SeaderUartViewModel* model = _model;
-    char temp_str[18];
-
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str_aligned(canvas, 64, 0, AlignCenter, AlignTop, "PICC <=> SAM");
-    canvas_draw_str(canvas, 3, 25, "TX:");
-    canvas_draw_str(canvas, 3, 42, "RX:");
-
-    if(model->protocol == FrameProtocol_iclass) {
-        canvas_draw_str_aligned(canvas, 64, 62, AlignCenter, AlignBottom, "Detecting picopass");
-    } else if(model->protocol == FrameProtocol_nfc) {
-        canvas_draw_str_aligned(canvas, 64, 62, AlignCenter, AlignBottom, "Detecting 14a");
-    }
-
-    if(model->tx_cnt < 100000000) {
-        canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(canvas, 127, 24, AlignRight, AlignBottom, "B.");
-        canvas_set_font(canvas, FontKeyboard);
-        snprintf(temp_str, 18, "%lu", model->tx_cnt);
-        canvas_draw_str_aligned(canvas, 116, 24, AlignRight, AlignBottom, temp_str);
-    } else {
-        canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(canvas, 127, 24, AlignRight, AlignBottom, "KiB.");
-        canvas_set_font(canvas, FontKeyboard);
-        snprintf(temp_str, 18, "%lu", model->tx_cnt / 1024);
-        canvas_draw_str_aligned(canvas, 111, 24, AlignRight, AlignBottom, temp_str);
-    }
-
-    if(model->rx_cnt < 100000000) {
-        canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(canvas, 127, 41, AlignRight, AlignBottom, "B.");
-        canvas_set_font(canvas, FontKeyboard);
-        snprintf(temp_str, 18, "%lu", model->rx_cnt);
-        canvas_draw_str_aligned(canvas, 116, 41, AlignRight, AlignBottom, temp_str);
-    } else {
-        canvas_set_font(canvas, FontSecondary);
-        canvas_draw_str_aligned(canvas, 127, 41, AlignRight, AlignBottom, "KiB.");
-        canvas_set_font(canvas, FontKeyboard);
-        snprintf(temp_str, 18, "%lu", model->rx_cnt / 1024);
-        canvas_draw_str_aligned(canvas, 111, 41, AlignRight, AlignBottom, temp_str);
-    }
-
-    if(model->tx_active) {
-        canvas_draw_icon(canvas, 48, 14, &I_ArrowUpFilled_14x15);
-    } else {
-        canvas_draw_icon(canvas, 48, 14, &I_ArrowUpEmpty_14x15);
-    }
-
-    if(model->rx_active) {
-        canvas_draw_icon_ex(canvas, 48, 34, &I_ArrowUpFilled_14x15, IconRotation180);
-    } else {
-        canvas_draw_icon_ex(canvas, 48, 34, &I_ArrowUpEmpty_14x15, IconRotation180);
-    }
-}
-
-static bool seader_uart_view_input_callback(InputEvent* event, void* context) {
-    furi_assert(context);
-    SeaderUartView* seader_uart_view = context;
-    bool consumed = false;
-
-    if(event->type == InputTypeShort) {
-        if(event->key == InputKeyLeft) {
-            consumed = true;
-            furi_assert(seader_uart_view->callback);
-            // seader_uart_view->callback(SeaderUartViewEventConfig, seader_uart_view->context);
-        }
-    }
-
-    return consumed;
-}
-
-SeaderUartView* seader_uart_view_alloc() {
-    SeaderUartView* seader_uart_view = malloc(sizeof(SeaderUartView));
-
-    seader_uart_view->view = view_alloc();
-    view_allocate_model(seader_uart_view->view, ViewModelTypeLocking, sizeof(SeaderUartViewModel));
-    view_set_context(seader_uart_view->view, seader_uart_view);
-    view_set_draw_callback(seader_uart_view->view, seader_uart_view_draw_callback);
-    view_set_input_callback(seader_uart_view->view, seader_uart_view_input_callback);
-
-    return seader_uart_view;
-}
-
-void seader_uart_view_free(SeaderUartView* seader_uart_view) {
-    furi_assert(seader_uart_view);
-    view_free(seader_uart_view->view);
-    free(seader_uart_view);
-}
-
-View* seader_uart_view_get_view(SeaderUartView* seader_uart_view) {
-    furi_assert(seader_uart_view);
-    return seader_uart_view->view;
-}
-
-void seader_uart_view_set_callback(
-    SeaderUartView* seader_uart_view,
-    SeaderUartViewCallback callback,
-    void* context) {
-    furi_assert(seader_uart_view);
-    furi_assert(callback);
-
-    with_view_model(
-        seader_uart_view->view,
-        SeaderUartViewModel * model,
-        {
-            UNUSED(model);
-            seader_uart_view->callback = callback;
-            seader_uart_view->context = context;
-        },
-        false);
-}
-
-void seader_uart_view_update_state(
-    SeaderUartView* instance,
-    SeaderUartConfig* cfg,
-    SeaderUartState* st) {
-    furi_assert(instance);
-    furi_assert(cfg);
-    furi_assert(st);
-
-    with_view_model(
-        instance->view,
-        SeaderUartViewModel * model,
-        {
-            model->tx_active = (model->tx_cnt != st->tx_cnt);
-            model->rx_active = (model->rx_cnt != st->rx_cnt);
-            model->tx_cnt = st->tx_cnt;
-            model->rx_cnt = st->rx_cnt;
-            model->protocol = st->protocol;
-        },
-        true);
-}

views/seader_uart_view.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <gui/view.h>
-#include "../seader_custom_event.h"
-#include "../seader_bridge.h"
-
-typedef struct SeaderUartView SeaderUartView;
-typedef void (*SeaderUartViewCallback)(SeaderCustomEvent event, void* context);
-
-SeaderUartView* seader_uart_view_alloc();
-
-void seader_uart_view_free(SeaderUartView* seader_uart_view);
-
-View* seader_uart_view_get_view(SeaderUartView* seader_uart_view);
-
-void seader_uart_view_set_callback(
-    SeaderUartView* seader_uart_view,
-    SeaderUartViewCallback callback,
-    void* context);
-
-void seader_uart_view_update_state(
-    SeaderUartView* instance,
-    SeaderUartConfig* cfg,
-    SeaderUartState* st);