[FL-3666] NFC API improvements (#3214)

* drivers: expose st25r3916 driver API * nfc poller: add start with custom callback * mf classic: rework sync API with poller custom start * mf ultralight: rework sync API with poller custom start * iso14443_3a poller: remove unused col res state * nfc: rework nfc poller custom start * mf ultralight: rename sync API * mf classic: rename sync API * iso14443-3a: rename sync API * nfc: remove async prefix in internal functions * nfc: expose internal API * nfc: fix sync api include and docs * targets: fix f18 build * nfc: rework NfcGenericEventEx type * nfc poller: add documentation * iso14443-3a poller: add documentation * felica poller: add documentation * iso14443_3b poller: add documentation * so14443_4a poller: add documentation * iso14443_4b poller: add documentation * iso15693 poller: add documentation * slix poller: add documentation * mf desfire poller: add documentation * mf ultralight poller: fix API and add documentation * mf classic poller: add documentation Co-authored-by: あく <alleteam@gmail.com>
2023-11-15 17:32:45 +09:00
parent d0b9a3a4ae
commit c00776ca22
62 changed files with 1708 additions and 719 deletions
@@ -61,7 +61,7 @@ static NfcCommand mf_desfire_poller_handler_idle(MfDesfirePoller* instance) {
 }

 static NfcCommand mf_desfire_poller_handler_read_version(MfDesfirePoller* instance) {
-    instance->error = mf_desfire_poller_async_read_version(instance, &instance->data->version);
+    instance->error = mf_desfire_poller_read_version(instance, &instance->data->version);
    if(instance->error == MfDesfireErrorNone) {
        FURI_LOG_D(TAG, "Read version success");
        instance->state = MfDesfirePollerStateReadFreeMemory;
@@ -75,8 +75,7 @@ static NfcCommand mf_desfire_poller_handler_read_version(MfDesfirePoller* instan
 }

 static NfcCommand mf_desfire_poller_handler_read_free_memory(MfDesfirePoller* instance) {
-    instance->error =
-        mf_desfire_poller_async_read_free_memory(instance, &instance->data->free_memory);
+    instance->error = mf_desfire_poller_read_free_memory(instance, &instance->data->free_memory);
    if(instance->error == MfDesfireErrorNone) {
        FURI_LOG_D(TAG, "Read free memory success");
        instance->state = MfDesfirePollerStateReadMasterKeySettings;
@@ -91,7 +90,7 @@ static NfcCommand mf_desfire_poller_handler_read_free_memory(MfDesfirePoller* in

 static NfcCommand mf_desfire_poller_handler_read_master_key_settings(MfDesfirePoller* instance) {
    instance->error =
-        mf_desfire_poller_async_read_key_settings(instance, &instance->data->master_key_settings);
+        mf_desfire_poller_read_key_settings(instance, &instance->data->master_key_settings);
    if(instance->error == MfDesfireErrorNone) {
        FURI_LOG_D(TAG, "Read master key settings success");
        instance->state = MfDesfirePollerStateReadMasterKeyVersion;
@@ -105,7 +104,7 @@ static NfcCommand mf_desfire_poller_handler_read_master_key_settings(MfDesfirePo
 }

 static NfcCommand mf_desfire_poller_handler_read_master_key_version(MfDesfirePoller* instance) {
-    instance->error = mf_desfire_poller_async_read_key_versions(
+    instance->error = mf_desfire_poller_read_key_versions(
        instance,
        instance->data->master_key_versions,
        instance->data->master_key_settings.max_keys);
@@ -123,7 +122,7 @@ static NfcCommand mf_desfire_poller_handler_read_master_key_version(MfDesfirePol

 static NfcCommand mf_desfire_poller_handler_read_application_ids(MfDesfirePoller* instance) {
    instance->error =
-        mf_desfire_poller_async_read_application_ids(instance, instance->data->application_ids);
+        mf_desfire_poller_read_application_ids(instance, instance->data->application_ids);
    if(instance->error == MfDesfireErrorNone) {
        FURI_LOG_D(TAG, "Read application ids success");
        instance->state = MfDesfirePollerStateReadApplications;
@@ -137,7 +136,7 @@ static NfcCommand mf_desfire_poller_handler_read_application_ids(MfDesfirePoller
 }

 static NfcCommand mf_desfire_poller_handler_read_applications(MfDesfirePoller* instance) {
-    instance->error = mf_desfire_poller_async_read_applications(
+    instance->error = mf_desfire_poller_read_applications(
        instance, instance->data->application_ids, instance->data->applications);
    if(instance->error == MfDesfireErrorNone) {
        FURI_LOG_D(TAG, "Read applications success");
@@ -227,7 +226,7 @@ static bool mf_desfire_poller_detect(NfcGenericEvent event, void* context) {

    if(iso14443_4a_event->type == Iso14443_4aPollerEventTypeReady) {
        MfDesfireVersion version = {};
-        const MfDesfireError error = mf_desfire_poller_async_read_version(instance, &version);
+        const MfDesfireError error = mf_desfire_poller_read_version(instance, &version);
        protocol_detected = (error == MfDesfireErrorNone);
    }

@@ -8,24 +8,267 @@
 extern "C" {
 #endif

+/**
+ * @brief MfDesfirePoller opaque type definition.
+ */
 typedef struct MfDesfirePoller MfDesfirePoller;

+/**
+ * @brief Enumeration of possible MfDesfire poller event types.
+ */
 typedef enum {
-    MfDesfirePollerEventTypeReadSuccess,
-    MfDesfirePollerEventTypeReadFailed,
+    MfDesfirePollerEventTypeReadSuccess, /**< Card was read successfully. */
+    MfDesfirePollerEventTypeReadFailed, /**< Poller failed to read card. */
 } MfDesfirePollerEventType;

-typedef struct {
-    union {
-        MfDesfireError error;
-    };
+/**
+ * @brief MfDesfire poller event data.
+ */
+typedef union {
+    MfDesfireError error; /**< Error code indicating card reading fail reason. */
 } MfDesfirePollerEventData;

+/**
+ * @brief MfDesfire poller event structure.
+ *
+ * Upon emission of an event, an instance of this struct will be passed to the callback.
+ */
 typedef struct {
-    MfDesfirePollerEventType type;
-    MfDesfirePollerEventData* data;
+    MfDesfirePollerEventType type; /**< Type of emmitted event. */
+    MfDesfirePollerEventData* data; /**< Pointer to event specific data. */
 } MfDesfirePollerEvent;

+/**
+ * @brief Transmit and receive MfDesfire chunks in poller mode.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * The rx_buffer will be filled with any data received as a response to data
+ * sent from tx_buffer, with a timeout defined by the fwt parameter.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[in] tx_buffer pointer to the buffer containing the data to be transmitted.
+ * @param[out] rx_buffer pointer to the buffer to be filled with received data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_send_chunks(
+    MfDesfirePoller* instance,
+    const BitBuffer* tx_buffer,
+    BitBuffer* rx_buffer);
+
+/**
+ * @brief Read MfDesfire card version.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[out] data pointer to the MfDesfireVersion structure to be filled with version data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_version(MfDesfirePoller* instance, MfDesfireVersion* data);
+
+/**
+ * @brief Read free memory available on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[out] data pointer to the MfDesfireFreeMemory structure to be filled with free memory data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError
+    mf_desfire_poller_read_free_memory(MfDesfirePoller* instance, MfDesfireFreeMemory* data);
+
+/**
+ * @brief Read key settings on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[out] data pointer to the MfDesfireKeySettings structure to be filled with key settings data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError
+    mf_desfire_poller_read_key_settings(MfDesfirePoller* instance, MfDesfireKeySettings* data);
+
+/**
+ * @brief Read key versions on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[out] data pointer to the SimpleArray structure to be filled with key versions data.
+ * @param[in] count number of key versions to read.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_key_versions(
+    MfDesfirePoller* instance,
+    SimpleArray* data,
+    uint32_t count);
+
+/**
+ * @brief Read applications IDs on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[out] data pointer to the SimpleArray structure to be filled with application ids data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError
+    mf_desfire_poller_read_application_ids(MfDesfirePoller* instance, SimpleArray* data);
+
+/**
+ * @brief Select application on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[in] id pointer to the MfDesfireApplicationId structure with application id to select.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_select_application(
+    MfDesfirePoller* instance,
+    const MfDesfireApplicationId* id);
+
+/**
+ * @brief Read file IDs for selected application on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[out] data pointer to the SimpleArray structure to be filled with file ids data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_file_ids(MfDesfirePoller* instance, SimpleArray* data);
+
+/**
+ * @brief Read file settings on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[in] id file id to read settings for.
+ * @param[out] data pointer to the MfDesfireFileSettings structure to be filled with file settings data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_file_settings(
+    MfDesfirePoller* instance,
+    MfDesfireFileId id,
+    MfDesfireFileSettings* data);
+
+/**
+ * @brief Read multiple file settings on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[in] file_ids pointer to the SimpleArray structure array with file ids to read settings for.
+ * @param[out] data pointer to the SimpleArray structure array to be filled with file settings data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_file_settings_multi(
+    MfDesfirePoller* instance,
+    const SimpleArray* file_ids,
+    SimpleArray* data);
+
+/**
+ * @brief Read file data on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[in] id file id to read data from.
+ * @param[in] offset offset in bytes to start reading from.
+ * @param[in] size number of bytes to read.
+ * @param[out] data pointer to the MfDesfireFileData structure to be filled with file data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_file_data(
+    MfDesfirePoller* instance,
+    MfDesfireFileId id,
+    uint32_t offset,
+    size_t size,
+    MfDesfireFileData* data);
+
+/**
+ * @brief Read file value on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[in] id file id to read value from.
+ * @param[out] data pointer to the MfDesfireFileData structure to be filled with file value.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_file_value(
+    MfDesfirePoller* instance,
+    MfDesfireFileId id,
+    MfDesfireFileData* data);
+
+/**
+ * @brief Read file records on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[in] id file id to read data from.
+ * @param[in] offset offset in bytes to start reading from.
+ * @param[in] size number of bytes to read.
+ * @param[out] data pointer to the MfDesfireFileData structure to be filled with file records data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_file_records(
+    MfDesfirePoller* instance,
+    MfDesfireFileId id,
+    uint32_t offset,
+    size_t size,
+    MfDesfireFileData* data);
+
+/**
+ * @brief Read data from multiple files on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[in] file_ids pointer to the SimpleArray structure array with files ids to read data from.
+ * @param[in] file_settings pointer to the SimpleArray structure array with files settings to read data from.
+ * @param[out] data pointer to the SimpleArray structure array to be filled with files data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_file_data_multi(
+    MfDesfirePoller* instance,
+    const SimpleArray* file_ids,
+    const SimpleArray* file_settings,
+    SimpleArray* data);
+
+/**
+ * @brief Read application data for selected application on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[out] data pointer to the MfDesfireApplication structure to be filled with application data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError
+    mf_desfire_poller_read_application(MfDesfirePoller* instance, MfDesfireApplication* data);
+
+/**
+ * @brief Read multiple applications data on MfDesfire card.
+ *
+ * Must ONLY be used inside the callback function.
+ *
+ * @param[in, out] instance pointer to the instance to be used in the transaction.
+ * @param[in] app_ids pointer to the SimpleArray structure array with application ids to read data from.
+ * @param[out] data pointer to the SimpleArray structure array to be filled with applications data.
+ * @return MfDesfireErrorNone on success, an error code on failure.
+ */
+MfDesfireError mf_desfire_poller_read_applications(
+    MfDesfirePoller* instance,
+    const SimpleArray* app_ids,
+    SimpleArray* data);
+
 #ifdef __cplusplus
 }
 #endif
@@ -74,8 +74,7 @@ MfDesfireError mf_desfire_send_chunks(
    return error;
 }

-MfDesfireError
-    mf_desfire_poller_async_read_version(MfDesfirePoller* instance, MfDesfireVersion* data) {
+MfDesfireError mf_desfire_poller_read_version(MfDesfirePoller* instance, MfDesfireVersion* data) {
    furi_assert(instance);

    bit_buffer_reset(instance->input_buffer);
@@ -97,7 +96,7 @@ MfDesfireError
 }

 MfDesfireError
-    mf_desfire_poller_async_read_free_memory(MfDesfirePoller* instance, MfDesfireFreeMemory* data) {
+    mf_desfire_poller_read_free_memory(MfDesfirePoller* instance, MfDesfireFreeMemory* data) {
    furi_assert(instance);

    bit_buffer_reset(instance->input_buffer);
@@ -118,9 +117,8 @@ MfDesfireError
    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_key_settings(
-    MfDesfirePoller* instance,
-    MfDesfireKeySettings* data) {
+MfDesfireError
+    mf_desfire_poller_read_key_settings(MfDesfirePoller* instance, MfDesfireKeySettings* data) {
    furi_assert(instance);

    bit_buffer_reset(instance->input_buffer);
@@ -141,7 +139,7 @@ MfDesfireError mf_desfire_poller_async_read_key_settings(
    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_key_versions(
+MfDesfireError mf_desfire_poller_read_key_versions(
    MfDesfirePoller* instance,
    SimpleArray* data,
    uint32_t count) {
@@ -172,7 +170,7 @@ MfDesfireError mf_desfire_poller_async_read_key_versions(
 }

 MfDesfireError
-    mf_desfire_poller_async_read_application_ids(MfDesfirePoller* instance, SimpleArray* data) {
+    mf_desfire_poller_read_application_ids(MfDesfirePoller* instance, SimpleArray* data) {
    furi_assert(instance);

    bit_buffer_reset(instance->input_buffer);
@@ -203,7 +201,7 @@ MfDesfireError
    return error;
 }

-MfDesfireError mf_desfire_poller_async_select_application(
+MfDesfireError mf_desfire_poller_select_application(
    MfDesfirePoller* instance,
    const MfDesfireApplicationId* id) {
    furi_assert(instance);
@@ -219,8 +217,7 @@ MfDesfireError mf_desfire_poller_async_select_application(
    return error;
 }

-MfDesfireError
-    mf_desfire_poller_async_read_file_ids(MfDesfirePoller* instance, SimpleArray* data) {
+MfDesfireError mf_desfire_poller_read_file_ids(MfDesfirePoller* instance, SimpleArray* data) {
    furi_assert(instance);

    bit_buffer_reset(instance->input_buffer);
@@ -250,7 +247,7 @@ MfDesfireError
    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_file_settings(
+MfDesfireError mf_desfire_poller_read_file_settings(
    MfDesfirePoller* instance,
    MfDesfireFileId id,
    MfDesfireFileSettings* data) {
@@ -275,7 +272,7 @@ MfDesfireError mf_desfire_poller_async_read_file_settings(
    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_file_settings_multi(
+MfDesfireError mf_desfire_poller_read_file_settings_multi(
    MfDesfirePoller* instance,
    const SimpleArray* file_ids,
    SimpleArray* data) {
@@ -290,15 +287,14 @@ MfDesfireError mf_desfire_poller_async_read_file_settings_multi(

    for(uint32_t i = 0; i < file_id_count; ++i) {
        const MfDesfireFileId file_id = *(const MfDesfireFileId*)simple_array_cget(file_ids, i);
-        error = mf_desfire_poller_async_read_file_settings(
-            instance, file_id, simple_array_get(data, i));
+        error = mf_desfire_poller_read_file_settings(instance, file_id, simple_array_get(data, i));
        if(error != MfDesfireErrorNone) break;
    }

    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_file_data(
+MfDesfireError mf_desfire_poller_read_file_data(
    MfDesfirePoller* instance,
    MfDesfireFileId id,
    uint32_t offset,
@@ -327,7 +323,7 @@ MfDesfireError mf_desfire_poller_async_read_file_data(
    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_file_value(
+MfDesfireError mf_desfire_poller_read_file_value(
    MfDesfirePoller* instance,
    MfDesfireFileId id,
    MfDesfireFileData* data) {
@@ -352,7 +348,7 @@ MfDesfireError mf_desfire_poller_async_read_file_value(
    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_file_records(
+MfDesfireError mf_desfire_poller_read_file_records(
    MfDesfirePoller* instance,
    MfDesfireFileId id,
    uint32_t offset,
@@ -381,7 +377,7 @@ MfDesfireError mf_desfire_poller_async_read_file_records(
    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_file_data_multi(
+MfDesfireError mf_desfire_poller_read_file_data_multi(
    MfDesfirePoller* instance,
    const SimpleArray* file_ids,
    const SimpleArray* file_settings,
@@ -404,14 +400,14 @@ MfDesfireError mf_desfire_poller_async_read_file_data_multi(
        MfDesfireFileData* file_data = simple_array_get(data, i);

        if(file_type == MfDesfireFileTypeStandard || file_type == MfDesfireFileTypeBackup) {
-            error = mf_desfire_poller_async_read_file_data(
+            error = mf_desfire_poller_read_file_data(
                instance, file_id, 0, file_settings_cur->data.size, file_data);
        } else if(file_type == MfDesfireFileTypeValue) {
-            error = mf_desfire_poller_async_read_file_value(instance, file_id, file_data);
+            error = mf_desfire_poller_read_file_value(instance, file_id, file_data);
        } else if(
            file_type == MfDesfireFileTypeLinearRecord ||
            file_type == MfDesfireFileTypeCyclicRecord) {
-            error = mf_desfire_poller_async_read_file_records(
+            error = mf_desfire_poller_read_file_records(
                instance, file_id, 0, file_settings_cur->data.size, file_data);
        }

@@ -421,30 +417,29 @@ MfDesfireError mf_desfire_poller_async_read_file_data_multi(
    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_application(
-    MfDesfirePoller* instance,
-    MfDesfireApplication* data) {
+MfDesfireError
+    mf_desfire_poller_read_application(MfDesfirePoller* instance, MfDesfireApplication* data) {
    furi_assert(instance);
    furi_assert(data);

    MfDesfireError error;

    do {
-        error = mf_desfire_poller_async_read_key_settings(instance, &data->key_settings);
+        error = mf_desfire_poller_read_key_settings(instance, &data->key_settings);
        if(error != MfDesfireErrorNone) break;

-        error = mf_desfire_poller_async_read_key_versions(
+        error = mf_desfire_poller_read_key_versions(
            instance, data->key_versions, data->key_settings.max_keys);
        if(error != MfDesfireErrorNone) break;

-        error = mf_desfire_poller_async_read_file_ids(instance, data->file_ids);
+        error = mf_desfire_poller_read_file_ids(instance, data->file_ids);
        if(error != MfDesfireErrorNone) break;

-        error = mf_desfire_poller_async_read_file_settings_multi(
+        error = mf_desfire_poller_read_file_settings_multi(
            instance, data->file_ids, data->file_settings);
        if(error != MfDesfireErrorNone) break;

-        error = mf_desfire_poller_async_read_file_data_multi(
+        error = mf_desfire_poller_read_file_data_multi(
            instance, data->file_ids, data->file_settings, data->file_data);
        if(error != MfDesfireErrorNone) break;

@@ -453,7 +448,7 @@ MfDesfireError mf_desfire_poller_async_read_application(
    return error;
 }

-MfDesfireError mf_desfire_poller_async_read_applications(
+MfDesfireError mf_desfire_poller_read_applications(
    MfDesfirePoller* instance,
    const SimpleArray* app_ids,
    SimpleArray* data) {
@@ -468,12 +463,11 @@ MfDesfireError mf_desfire_poller_async_read_applications(

    for(uint32_t i = 0; i < app_id_count; ++i) {
        do {
-            error = mf_desfire_poller_async_select_application(
-                instance, simple_array_cget(app_ids, i));
+            error = mf_desfire_poller_select_application(instance, simple_array_cget(app_ids, i));
            if(error != MfDesfireErrorNone) break;

            MfDesfireApplication* current_app = simple_array_get(data, i);
-            error = mf_desfire_poller_async_read_application(instance, current_app);
+            error = mf_desfire_poller_read_application(instance, current_app);

        } while(false);
    }
@@ -49,78 +49,6 @@ MfDesfireError mf_desfire_process_error(Iso14443_4aError error);

 const MfDesfireData* mf_desfire_poller_get_data(MfDesfirePoller* instance);

-MfDesfireError mf_desfire_send_chunks(
-    MfDesfirePoller* instance,
-    const BitBuffer* tx_buffer,
-    BitBuffer* rx_buffer);
-
-MfDesfireError
-    mf_desfire_poller_async_read_version(MfDesfirePoller* instance, MfDesfireVersion* data);
-
-MfDesfireError
-    mf_desfire_poller_async_read_free_memory(MfDesfirePoller* instance, MfDesfireFreeMemory* data);
-
-MfDesfireError mf_desfire_poller_async_read_key_settings(
-    MfDesfirePoller* instance,
-    MfDesfireKeySettings* data);
-
-MfDesfireError mf_desfire_poller_async_read_key_versions(
-    MfDesfirePoller* instance,
-    SimpleArray* data,
-    uint32_t count);
-
-MfDesfireError
-    mf_desfire_poller_async_read_application_ids(MfDesfirePoller* instance, SimpleArray* data);
-
-MfDesfireError mf_desfire_poller_async_select_application(
-    MfDesfirePoller* instance,
-    const MfDesfireApplicationId* id);
-
-MfDesfireError mf_desfire_poller_async_read_file_ids(MfDesfirePoller* instance, SimpleArray* data);
-
-MfDesfireError mf_desfire_poller_async_read_file_settings(
-    MfDesfirePoller* instance,
-    MfDesfireFileId id,
-    MfDesfireFileSettings* data);
-
-MfDesfireError mf_desfire_poller_async_read_file_settings_multi(
-    MfDesfirePoller* instance,
-    const SimpleArray* file_ids,
-    SimpleArray* data);
-
-MfDesfireError mf_desfire_poller_async_read_file_data(
-    MfDesfirePoller* instance,
-    MfDesfireFileId id,
-    uint32_t offset,
-    size_t size,
-    MfDesfireFileData* data);
-
-MfDesfireError mf_desfire_poller_async_read_file_value(
-    MfDesfirePoller* instance,
-    MfDesfireFileId id,
-    MfDesfireFileData* data);
-
-MfDesfireError mf_desfire_poller_async_read_file_records(
-    MfDesfirePoller* instance,
-    MfDesfireFileId id,
-    uint32_t offset,
-    size_t size,
-    MfDesfireFileData* data);
-
-MfDesfireError mf_desfire_poller_async_read_file_data_multi(
-    MfDesfirePoller* instance,
-    const SimpleArray* file_ids,
-    const SimpleArray* file_settings,
-    SimpleArray* data);
-
-MfDesfireError
-    mf_desfire_poller_async_read_application(MfDesfirePoller* instance, MfDesfireApplication* data);
-
-MfDesfireError mf_desfire_poller_async_read_applications(
-    MfDesfirePoller* instance,
-    const SimpleArray* app_ids,
-    SimpleArray* data);
-
 #ifdef __cplusplus
 }
 #endif