diff --git a/applications/main/nfc/nfc_cli.c b/applications/main/nfc/nfc_cli.c
index 87aa6748d..0fd8e1e14 100644
--- a/applications/main/nfc/nfc_cli.c
+++ b/applications/main/nfc/nfc_cli.c
@@ -74,15 +74,17 @@ static void nfc_cli_emulate(Cli* cli, FuriString* args) {
     FuriHalNfcDevData params = {
         .uid = {0x36, 0x9C, 0xe7, 0xb1, 0x0A, 0xC1, 0x34},
         .uid_len = 7,
-        .a_data = {
-            .atqa = {0x44, 0x00},
-            .sak = 0x00,
-        },
+        .a_data =
+            {
+                .atqa = {0x44, 0x00},
+                .sak = 0x00,
+            },
         .type = FuriHalNfcTypeA,
     };
 
     while(!cli_cmd_interrupt_received(cli)) {
-        if(furi_hal_nfc_listen(params.uid, params.uid_len, params.a_data.atqa, params.a_data.sak, false, 100)) {
+        if(furi_hal_nfc_listen(
+               params.uid, params.uid_len, params.a_data.atqa, params.a_data.sak, false, 100)) {
             printf("Reader detected\r\n");
             furi_hal_nfc_sleep();
         }
diff --git a/applications/main/nfc/scenes/nfc_scene_felica_read_success.c b/applications/main/nfc/scenes/nfc_scene_felica_read_success.c
index d63a04837..80548c09d 100644
--- a/applications/main/nfc/scenes/nfc_scene_felica_read_success.c
+++ b/applications/main/nfc/scenes/nfc_scene_felica_read_success.c
@@ -29,7 +29,8 @@ void nfc_scene_felica_read_success_on_enter(void* context) {
 
         FelicaSystem* current_system = felica_data->systems;
         while(current_system) {
-            furi_string_cat_printf(temp_str, "\nSystem %04X (#%d):", current_system->code, current_system->number);
+            furi_string_cat_printf(
+                temp_str, "\nSystem %04X (#%d):", current_system->code, current_system->number);
             furi_string_cat_printf(temp_str, "\nIDm:\n    ");
             for(size_t i = 0; i < 8; i++) {
                 furi_string_cat_printf(temp_str, "%02X", current_system->idm[i]);
diff --git a/applications/main/nfc/scenes/nfc_scene_nfc_data_info.c b/applications/main/nfc/scenes/nfc_scene_nfc_data_info.c
index 9586e247d..96dfcf4de 100644
--- a/applications/main/nfc/scenes/nfc_scene_nfc_data_info.c
+++ b/applications/main/nfc/scenes/nfc_scene_nfc_data_info.c
@@ -51,7 +51,8 @@ void nfc_scene_nfc_data_info_on_enter(void* context) {
     for(size_t i = 0; i < nfc_data->uid_len; i++) {
         furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
     }
-    furi_string_cat_printf(temp_str, "\nATQA: %02X %02X ", nfc_data->a_data.atqa[1], nfc_data->a_data.atqa[0]);
+    furi_string_cat_printf(
+        temp_str, "\nATQA: %02X %02X ", nfc_data->a_data.atqa[1], nfc_data->a_data.atqa[0]);
     furi_string_cat_printf(temp_str, " SAK: %02X", nfc_data->a_data.sak);
 
     // Set application specific data
diff --git a/applications/main/nfc/scenes/nfc_scene_nfca_read_success.c b/applications/main/nfc/scenes/nfc_scene_nfca_read_success.c
index 0e798452c..74fff367f 100644
--- a/applications/main/nfc/scenes/nfc_scene_nfca_read_success.c
+++ b/applications/main/nfc/scenes/nfc_scene_nfca_read_success.c
@@ -30,7 +30,8 @@ void nfc_scene_nfca_read_success_on_enter(void* context) {
     for(size_t i = 0; i < data->uid_len; i++) {
         furi_string_cat_printf(temp_str, " %02X", data->uid[i]);
     }
-    furi_string_cat_printf(temp_str, "\nATQA: %02X %02X ", data->a_data.atqa[1], data->a_data.atqa[0]);
+    furi_string_cat_printf(
+        temp_str, "\nATQA: %02X %02X ", data->a_data.atqa[1], data->a_data.atqa[0]);
     furi_string_cat_printf(temp_str, " SAK: %02X", data->a_data.sak);
 
     widget_add_text_scroll_element(widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
diff --git a/applications/main/nfc/scenes/nfc_scene_read_card_type.c b/applications/main/nfc/scenes/nfc_scene_read_card_type.c
index 94262aa1e..865b3f54b 100644
--- a/applications/main/nfc/scenes/nfc_scene_read_card_type.c
+++ b/applications/main/nfc/scenes/nfc_scene_read_card_type.c
@@ -7,6 +7,7 @@ enum SubmenuIndex {
     SubmenuIndexReadMfUltralight,
     SubmenuIndexReadEMV,
     SubmenuIndexReadNFCA,
+    SubmenuIndexReadFelica,
 };
 
 void nfc_scene_read_card_type_submenu_callback(void* context, uint32_t index) {
@@ -49,6 +50,12 @@ void nfc_scene_read_card_type_on_enter(void* context) {
         SubmenuIndexReadNFCA,
         nfc_scene_read_card_type_submenu_callback,
         nfc);
+    submenu_add_item(
+        submenu,
+        "Read FeliCa",
+        SubmenuIndexReadFelica,
+        nfc_scene_read_card_type_submenu_callback,
+        nfc);
     uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneReadCardType);
     submenu_set_selected_item(submenu, state);
 
@@ -85,6 +92,11 @@ bool nfc_scene_read_card_type_on_event(void* context, SceneManagerEvent event) {
             scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
             consumed = true;
         }
+        if(event.event == SubmenuIndexReadFelica) {
+            nfc->dev->dev_data.read_mode = NfcReadModeFelica;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
+            consumed = true;
+        }
         scene_manager_set_scene_state(nfc->scene_manager, NfcSceneReadCardType, event.event);
     }
     return consumed;
diff --git a/lib/nfc/helpers/reader_analyzer.c b/lib/nfc/helpers/reader_analyzer.c
index 87b9a4e6d..c2d97e191 100644
--- a/lib/nfc/helpers/reader_analyzer.c
+++ b/lib/nfc/helpers/reader_analyzer.c
@@ -43,10 +43,7 @@ const FuriHalNfcDevData reader_analyzer_nfc_data[] = {
          .type = FuriHalNfcTypeA,
          .uid_len = 7,
          .uid = {0x04, 0x77, 0x70, 0x2A, 0x23, 0x4F, 0x80},
-         .a_data = {
-            .sak = 0x08,
-            .atqa = {0x44, 0x00},
-            .cuid = 0x2A234F80}},
+         .a_data = {.sak = 0x08, .atqa = {0x44, 0x00}, .cuid = 0x2A234F80}},
 };
 
 void reader_analyzer_parse(ReaderAnalyzer* instance, uint8_t* buffer, size_t size) {
diff --git a/lib/nfc/nfc_device.c b/lib/nfc/nfc_device.c
index 1ada4d888..32dae3c15 100644
--- a/lib/nfc/nfc_device.c
+++ b/lib/nfc/nfc_device.c
@@ -1127,7 +1127,7 @@ static bool nfc_device_load_data(NfcDevice* dev, FuriString* path, bool show_dia
             cuid_start = &data->uid[3];
         }
         data->a_data.cuid = (cuid_start[0] << 24) | (cuid_start[1] << 16) | (cuid_start[2] << 8) |
-                     (cuid_start[3]);
+                            (cuid_start[3]);
         // Parse other data
         if(dev->format == NfcDeviceSaveFormatMifareUl) {
             if(!nfc_device_load_mifare_ul_data(file, dev)) break;
diff --git a/lib/nfc/nfc_device.h b/lib/nfc/nfc_device.h
index 75c73a42b..54c696ff9 100644
--- a/lib/nfc/nfc_device.h
+++ b/lib/nfc/nfc_device.h
@@ -61,7 +61,7 @@ typedef enum {
     NfcReadModeMfDesfire,
     NfcReadModeEMV,
     NfcReadModeNFCA,
-    NfcReadModeNFCF,
+    NfcReadModeFelica,
 } NfcReadMode;
 
 typedef struct {
diff --git a/lib/nfc/nfc_worker.c b/lib/nfc/nfc_worker.c
index efc99b5d3..3e4677a46 100644
--- a/lib/nfc/nfc_worker.c
+++ b/lib/nfc/nfc_worker.c
@@ -499,6 +499,17 @@ void nfc_worker_read_type(NfcWorker* nfc_worker) {
                     event = NfcWorkerEventReadUidNfcA;
                     break;
                 }
+            } else if(nfc_data->type == FuriHalNfcTypeF) {
+                if(read_mode == NfcReadModeFelica) {
+                    nfc_worker->dev_data->protocol = NfcDeviceProtocolFelica;
+                    if(nfc_worker_read_felica(nfc_worker, &tx_rx)) {
+                        nfc_worker->dev_data->protocol = NfcDeviceProtocolFelica;
+                        if(nfc_worker_read_felica(nfc_worker, &tx_rx)) {
+                            event = NfcWorkerEventReadFelica;
+                            break;
+                        }
+                    }
+                }
             } else {
                 if(!card_not_detected_notified) {
                     nfc_worker->callback(NfcWorkerEventNoCardDetected, nfc_worker->context);
diff --git a/lib/nfc/parsers/plantain_4k_parser.c b/lib/nfc/parsers/plantain_4k_parser.c
index be914ceee..2d48c9a6e 100644
--- a/lib/nfc/parsers/plantain_4k_parser.c
+++ b/lib/nfc/parsers/plantain_4k_parser.c
@@ -71,7 +71,8 @@ bool plantain_4k_parser_read(NfcWorker* nfc_worker, FuriHalNfcTxRxContext* tx_rx
 
     MfClassicReader reader = {};
     FuriHalNfcADevData* nfc_a_data = &nfc_worker->dev_data->nfc_data.a_data;
-    reader.type = mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
+    reader.type =
+        mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
     for(size_t i = 0; i < COUNT_OF(plantain_keys_4k); i++) {
         mf_classic_reader_add_sector(
             &reader,
diff --git a/lib/nfc/parsers/plantain_parser.c b/lib/nfc/parsers/plantain_parser.c
index f0c22a39a..b2cc1017f 100644
--- a/lib/nfc/parsers/plantain_parser.c
+++ b/lib/nfc/parsers/plantain_parser.c
@@ -46,7 +46,8 @@ bool plantain_parser_read(NfcWorker* nfc_worker, FuriHalNfcTxRxContext* tx_rx) {
 
     MfClassicReader reader = {};
     FuriHalNfcADevData* nfc_a_data = &nfc_worker->dev_data->nfc_data.a_data;
-    reader.type = mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
+    reader.type =
+        mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
     for(size_t i = 0; i < COUNT_OF(plantain_keys); i++) {
         mf_classic_reader_add_sector(
             &reader, plantain_keys[i].sector, plantain_keys[i].key_a, plantain_keys[i].key_b);
diff --git a/lib/nfc/parsers/troika_4k_parser.c b/lib/nfc/parsers/troika_4k_parser.c
index b468fa8b9..a94d69486 100644
--- a/lib/nfc/parsers/troika_4k_parser.c
+++ b/lib/nfc/parsers/troika_4k_parser.c
@@ -68,7 +68,8 @@ bool troika_4k_parser_read(NfcWorker* nfc_worker, FuriHalNfcTxRxContext* tx_rx)
 
     MfClassicReader reader = {};
     FuriHalNfcADevData* nfc_a_data = &nfc_worker->dev_data->nfc_data.a_data;
-    reader.type = mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
+    reader.type =
+        mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
     for(size_t i = 0; i < COUNT_OF(troika_4k_keys); i++) {
         mf_classic_reader_add_sector(
             &reader, troika_4k_keys[i].sector, troika_4k_keys[i].key_a, troika_4k_keys[i].key_b);
diff --git a/lib/nfc/parsers/troika_parser.c b/lib/nfc/parsers/troika_parser.c
index 2ab9476c2..569d83822 100644
--- a/lib/nfc/parsers/troika_parser.c
+++ b/lib/nfc/parsers/troika_parser.c
@@ -44,7 +44,8 @@ bool troika_parser_read(NfcWorker* nfc_worker, FuriHalNfcTxRxContext* tx_rx) {
 
     MfClassicReader reader = {};
     FuriHalNfcADevData* nfc_a_data = &nfc_worker->dev_data->nfc_data.a_data;
-    reader.type = mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
+    reader.type =
+        mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
 
     for(size_t i = 0; i < COUNT_OF(troika_keys); i++) {
         mf_classic_reader_add_sector(
diff --git a/lib/nfc/parsers/two_cities.c b/lib/nfc/parsers/two_cities.c
index 16c7d049a..e625e3e97 100644
--- a/lib/nfc/parsers/two_cities.c
+++ b/lib/nfc/parsers/two_cities.c
@@ -72,7 +72,8 @@ bool two_cities_parser_read(NfcWorker* nfc_worker, FuriHalNfcTxRxContext* tx_rx)
 
     MfClassicReader reader = {};
     FuriHalNfcADevData* nfc_a_data = &nfc_worker->dev_data->nfc_data.a_data;
-    reader.type = mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
+    reader.type =
+        mf_classic_get_classic_type(nfc_a_data->atqa[0], nfc_a_data->atqa[1], nfc_a_data->sak);
     for(size_t i = 0; i < COUNT_OF(two_cities_keys_4k); i++) {
         mf_classic_reader_add_sector(
             &reader,
diff --git a/lib/nfc/protocols/felica.c b/lib/nfc/protocols/felica.c
index 57b5fc7d5..5cfa42d19 100644
--- a/lib/nfc/protocols/felica.c
+++ b/lib/nfc/protocols/felica.c
@@ -12,49 +12,49 @@ bool felica_check_ic_type(uint8_t* PMm) {
     uint8_t rom_type = PMm[1];
 
     bool is_valid_ic = false;
-    if (ic_type == 0xff) { // RC-S967 in nfc-dep
+    if(ic_type == 0xff) { // RC-S967 in nfc-dep
         is_valid_ic = true;
-    } else if (ic_type == 0xf0 || ic_type == 0xf2) { // Lite(S)
+    } else if(ic_type == 0xf0 || ic_type == 0xf2) { // Lite(S)
         is_valid_ic = true;
-    } else if (ic_type == 0xe1) { // RC-S967 in plug mode
+    } else if(ic_type == 0xe1) { // RC-S967 in plug mode
         is_valid_ic = true;
-    } else if (ic_type == 0xe0) { // RC-S926
+    } else if(ic_type == 0xe0) { // RC-S926
         is_valid_ic = true;
-    } else if (ic_type >= 0x44 && ic_type <= 0x48) { // SD2
+    } else if(ic_type >= 0x44 && ic_type <= 0x48) { // SD2
         is_valid_ic = true;
-    } else if (ic_type == 0x3e && rom_type == 0x03) { // RC-SA08
+    } else if(ic_type == 0x3e && rom_type == 0x03) { // RC-SA08
         return true;
-    } else if (ic_type == 0x35) { // RC-SA01
+    } else if(ic_type == 0x35) { // RC-SA01
         is_valid_ic = true;
-    } else if (ic_type == 0x32) { // RC-SA00
+    } else if(ic_type == 0x32) { // RC-SA00
         is_valid_ic = true;
-    } else if (ic_type == 0x31) { // Suica/PASMO
+    } else if(ic_type == 0x31) { // Suica/PASMO
         is_valid_ic = true;
-    } else if (ic_type == 0x20) { // RC-S962
+    } else if(ic_type == 0x20) { // RC-S962
         is_valid_ic = true;
-    } else if (ic_type >= 0x10 && ic_type <= 0x1f) { // Mobile IC version 2/3
+    } else if(ic_type >= 0x10 && ic_type <= 0x1f) { // Mobile IC version 2/3
         is_valid_ic = true;
-    } else if (ic_type == 0x0d) { // RC-S960
+    } else if(ic_type == 0x0d) { // RC-S960
         is_valid_ic = true;
-    } else if (ic_type == 0x0c) { // RC-S954
+    } else if(ic_type == 0x0c) { // RC-S954
         is_valid_ic = true;
-    } else if (ic_type == 0x0b) { // Old Suica?
+    } else if(ic_type == 0x0b) { // Old Suica?
         is_valid_ic = true;
-    } else if (ic_type == 0x09) { // RC-S953
+    } else if(ic_type == 0x09) { // RC-S953
         is_valid_ic = true;
-    } else if (ic_type == 0x08) { // RC-S952
+    } else if(ic_type == 0x08) { // RC-S952
         is_valid_ic = true;
-    } else if (ic_type == 0x06 || ic_type == 0x07) { // Mobile IC version 1
+    } else if(ic_type == 0x06 || ic_type == 0x07) { // Mobile IC version 1
         is_valid_ic = true;
-    } else if (ic_type == 0x02) { // RC-S919
+    } else if(ic_type == 0x02) { // RC-S919
         is_valid_ic = true;
-    } else if (ic_type == 0x01) { // RC-S915
+    } else if(ic_type == 0x01) { // RC-S915
         is_valid_ic = true;
-    } else if (ic_type == 0x00) { // RC-S830
+    } else if(ic_type == 0x00) { // RC-S830
         is_valid_ic = true;
     }
 
-    if (!is_valid_ic) {
+    if(!is_valid_ic) {
         return false;
     }
 
@@ -71,11 +71,13 @@ bool felica_check_ic_type(uint8_t* PMm) {
 uint8_t felica_prepare_unencrypted_read(
     uint8_t* dest,
     const FelicaReader* reader,
-    const uint16_t* service_code_list, uint8_t service_count, 
-    const uint32_t* block_list, uint8_t block_count) {
+    const uint16_t* service_code_list,
+    uint8_t service_count,
+    const uint32_t* block_list,
+    uint8_t block_count) {
     dest[0] = FELICA_UNENCRYPTED_READ_CMD;
     memcpy(&dest[1], reader->current_idm, 8);
-    
+
     dest[9] = service_count;
     uint8_t msg_len = 10;
     for(int i = 0; i < service_count; i++) {
@@ -90,7 +92,7 @@ uint8_t felica_prepare_unencrypted_read(
         dest[msg_len++] = block_num & 0xFF;
         dest[msg_len++] = block_num >> 8;
     }
-    
+
     return msg_len;
 }
 
@@ -98,17 +100,16 @@ uint8_t felica_lite_prepare_unencrypted_read(
     uint8_t* dest,
     const FelicaReader* reader,
     bool is_read_only,
-    const uint8_t* block_list, uint8_t block_count) {
-
+    const uint8_t* block_list,
+    uint8_t block_count) {
     dest[0] = FELICA_UNENCRYPTED_READ_CMD;
     memcpy(&dest[1], reader->current_idm, 8);
-    
+
     dest[9] = 1;
     uint8_t msg_len = 10;
-    uint8_t service_code = RANDOM_TYPE_SERVICE_ATTRIBUTE | (
-        (is_read_only)
-        ? UNAUTH_RO_SERVICE_ATTRIBUTE
-        : UNAUTH_RW_SERVICE_ATTRIBUTE);
+    uint8_t service_code =
+        RANDOM_TYPE_SERVICE_ATTRIBUTE |
+        ((is_read_only) ? UNAUTH_RO_SERVICE_ATTRIBUTE : UNAUTH_RW_SERVICE_ATTRIBUTE);
 
     dest[msg_len++] = service_code & 0xFF;
     dest[msg_len++] = service_code >> 8;
@@ -118,14 +119,16 @@ uint8_t felica_lite_prepare_unencrypted_read(
         dest[msg_len++] = IS_2_BYTE_BLOCK_LIST_ELEMENT;
         dest[msg_len++] = block_list[i];
     }
-    
+
     return msg_len;
 }
 
 uint16_t felica_parse_unencrypted_read(
-    uint8_t* buf, uint8_t len,
+    uint8_t* buf,
+    uint8_t len,
     FelicaReader* reader,
-    uint8_t* out, uint16_t out_len) {
+    uint8_t* out,
+    uint16_t out_len) {
     if(len < 12) {
         return false;
     }
@@ -160,10 +163,10 @@ uint16_t felica_parse_unencrypted_read(
     len--;
     buf++;
 
-    if (len < data_length || out_len < data_length) {
+    if(len < data_length || out_len < data_length) {
         return 0;
     }
-    
+
     memcpy(out, buf, data_length);
 
     return data_length;
@@ -172,12 +175,14 @@ uint16_t felica_parse_unencrypted_read(
 uint8_t felica_prepare_unencrypted_write(
     uint8_t* dest,
     FelicaReader* reader,
-    const uint16_t* service_code_list, uint8_t service_count,
-    const uint32_t* block_list, uint8_t block_count,
+    const uint16_t* service_code_list,
+    uint8_t service_count,
+    const uint32_t* block_list,
+    uint8_t block_count,
     const uint8_t* block_data) {
     dest[0] = FELICA_UNENCRYPTED_WRITE_CMD;
     memcpy(&dest[1], reader->current_idm, 8);
-    
+
     dest[9] = service_count;
     uint8_t msg_len = 10;
     for(int i = 0; i < service_count; i++) {
@@ -192,7 +197,7 @@ uint8_t felica_prepare_unencrypted_write(
         dest[msg_len++] = block_num & 0xFF;
         dest[msg_len++] = block_num >> 8;
     }
-    
+
     uint16_t data_length = block_count * FELICA_BLOCK_SIZE;
     memcpy(dest + msg_len, block_data, data_length);
     msg_len += data_length;
@@ -202,12 +207,12 @@ uint8_t felica_prepare_unencrypted_write(
 uint8_t felica_lite_prepare_unencrypted_write(
     uint8_t* dest,
     const FelicaReader* reader,
-    const uint8_t* block_list, uint8_t block_count,
+    const uint8_t* block_list,
+    uint8_t block_count,
     const uint8_t* block_data) {
-
     dest[0] = FELICA_UNENCRYPTED_WRITE_CMD;
     memcpy(&dest[1], reader->current_idm, 8);
-    
+
     dest[9] = 1;
     uint8_t msg_len = 10;
     uint8_t service_code = RANDOM_TYPE_SERVICE_ATTRIBUTE | UNAUTH_RW_SERVICE_ATTRIBUTE;
@@ -226,9 +231,7 @@ uint8_t felica_lite_prepare_unencrypted_write(
     return msg_len;
 }
 
-bool felica_parse_unencrypted_write(
-    uint8_t* buf, uint8_t len,
-    FelicaReader* reader) {
+bool felica_parse_unencrypted_write(uint8_t* buf, uint8_t len, FelicaReader* reader) {
     if(len < 12) {
         return false;
     }
@@ -259,83 +262,82 @@ bool felica_parse_unencrypted_write(
     return true;
 }
 
-
 FelicaICType felica_get_ic_type(uint8_t* PMm) {
     uint8_t rom_type = PMm[0];
     uint8_t ic_type = PMm[1];
 
     UNUSED(rom_type);
     switch(ic_type) {
-        case 0xff:
-            return FelicaICTypeLink;
-        case 0xf2:
-            return FelicaICTypeLink;
-        case 0xf1:
-            return FelicaICTypeLiteS;
-        case 0xf0:
-            return FelicaICTypeLite;
-        case 0xe1:
-            return FelicaICTypeLink;
-        case 0xe0:
-            return FelicaICTypePlug;
-        case 0x48:
-            return FelicaICTypeSD2_6K;
-        case 0x47:
-            return FelicaICTypeRC_SA24_6K;
-        case 0x46:
-            return FelicaICTypeSD2_4K;
-        case 0x45:
-        case 0x44:
-            return FelicaICTypeSD2WithDES;
-        case 0x3e:
-            return FelicaICTypeRC_SA08;
-        case 0x35:
-            return FelicaICTypeSD1;
-        case 0x32:
-            return FelicaICTypeSD1WithDES;
-        case 0x31:
-            return FelicaICTypeSuica;
-        case 0x20:
-            return FelicaICTypeFRAM_4K;
-        case 0x1f:
-        case 0x1e:
-        case 0x1d:
-        case 0x1c:
-        case 0x1b:
-        case 0x1a:
-        case 0x19:
-        case 0x18:
-             return FelicaICTypeMobileIC_V4_1;
-        case 0x17:
-             return FelicaICTypeMobileIC_V4;
-        case 0x16:
-        case 0x15:
-        case 0x14:
-             return FelicaICTypeMobileIC_V3;
-        case 0x13:
-        case 0x12:
-        case 0x11:
-        case 0x10:
-             return FelicaICTypeMobileIC_V2;
-        case 0x0d:
-            return FelicaICTypeFRAM_9K;
-        case 0x0c:
-            return FelicaICTypeEMV_36K;
-        case 0x0b: // Old Suica?
-            return FelicaICTypeSuica;
-        case 0x09:
-            return FelicaICTypeEMV_16K;
-        case 0x08:
-            return FelicaICTypeEMV_32K;
-        case 0x07:
-        case 0x06:
-            return FelicaICTypeMobileIC_V1;
-        case 0x02:
-            return FelicaICType576B;
-        case 0x01:
-            return FelicaICType4K;
-        case 0x00:
-            return FelicaICType2K;
+    case 0xff:
+        return FelicaICTypeLink;
+    case 0xf2:
+        return FelicaICTypeLink;
+    case 0xf1:
+        return FelicaICTypeLiteS;
+    case 0xf0:
+        return FelicaICTypeLite;
+    case 0xe1:
+        return FelicaICTypeLink;
+    case 0xe0:
+        return FelicaICTypePlug;
+    case 0x48:
+        return FelicaICTypeSD2_6K;
+    case 0x47:
+        return FelicaICTypeRC_SA24_6K;
+    case 0x46:
+        return FelicaICTypeSD2_4K;
+    case 0x45:
+    case 0x44:
+        return FelicaICTypeSD2WithDES;
+    case 0x3e:
+        return FelicaICTypeRC_SA08;
+    case 0x35:
+        return FelicaICTypeSD1;
+    case 0x32:
+        return FelicaICTypeSD1WithDES;
+    case 0x31:
+        return FelicaICTypeSuica;
+    case 0x20:
+        return FelicaICTypeFRAM_4K;
+    case 0x1f:
+    case 0x1e:
+    case 0x1d:
+    case 0x1c:
+    case 0x1b:
+    case 0x1a:
+    case 0x19:
+    case 0x18:
+        return FelicaICTypeMobileIC_V4_1;
+    case 0x17:
+        return FelicaICTypeMobileIC_V4;
+    case 0x16:
+    case 0x15:
+    case 0x14:
+        return FelicaICTypeMobileIC_V3;
+    case 0x13:
+    case 0x12:
+    case 0x11:
+    case 0x10:
+        return FelicaICTypeMobileIC_V2;
+    case 0x0d:
+        return FelicaICTypeFRAM_9K;
+    case 0x0c:
+        return FelicaICTypeEMV_36K;
+    case 0x0b: // Old Suica?
+        return FelicaICTypeSuica;
+    case 0x09:
+        return FelicaICTypeEMV_16K;
+    case 0x08:
+        return FelicaICTypeEMV_32K;
+    case 0x07:
+    case 0x06:
+        return FelicaICTypeMobileIC_V1;
+    case 0x02:
+        return FelicaICType576B;
+    case 0x01:
+        return FelicaICType4K;
+    case 0x00:
+        return FelicaICType2K;
     }
 
     return FelicaICType2K;
@@ -370,7 +372,11 @@ void felica_define_normal_block(FelicaService* service, uint16_t number, uint8_t
     service->blocks[number] = block;
 }
 
-bool felica_read_lite_system(FuriHalNfcTxRxContext* tx_rx, FelicaReader* reader, FelicaData* data, FelicaSystem* system) {
+bool felica_read_lite_system(
+    FuriHalNfcTxRxContext* tx_rx,
+    FelicaReader* reader,
+    FelicaData* data,
+    FelicaSystem* system) {
     const uint8_t fixed_services[] = {
         SYS_CODE_LITE_BLOCK,
         RC_LITE_BLOCK,
@@ -380,24 +386,22 @@ bool felica_read_lite_system(FuriHalNfcTxRxContext* tx_rx, FelicaReader* reader,
         CARD_KEY_VER_LITE_BLOCK,
         MEM_CONFIG_LITE_BLOCK,
     };
-    
+
     uint8_t block_data[FELICA_BLOCK_SIZE * 4];
 
-    tx_rx->tx_bits = 8 * felica_lite_prepare_unencrypted_read(
-        tx_rx->tx_data,
-        reader,
-        true,
-        fixed_services, 1 
-    );
+    tx_rx->tx_bits =
+        8 * felica_lite_prepare_unencrypted_read(tx_rx->tx_data, reader, true, fixed_services, 1);
     if(!furi_hal_nfc_tx_rx_full(tx_rx)) {
         FURI_LOG_W(TAG, "Bad exchange verifying Lite system code");
         return false;
     }
-    if(felica_parse_unencrypted_read(tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) != FELICA_BLOCK_SIZE) {
+    if(felica_parse_unencrypted_read(
+           tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) !=
+       FELICA_BLOCK_SIZE) {
         FURI_LOG_W(TAG, "Bad response to Read without Encryption (SYS_C)");
         return false;
     }
-    if (block_data[0] != (LITE_SYSTEM_CODE >> 8) && block_data[1] != (LITE_SYSTEM_CODE & 0xFF)) {
+    if(block_data[0] != (LITE_SYSTEM_CODE >> 8) && block_data[1] != (LITE_SYSTEM_CODE & 0xFF)) {
         FURI_LOG_W(TAG, "Unexpected SYS_C value");
         return false;
     }
@@ -411,16 +415,12 @@ bool felica_read_lite_system(FuriHalNfcTxRxContext* tx_rx, FelicaReader* reader,
     for(int i = 0; i < service->block_count; i++) {
         service->blocks[i] = NULL;
     }
-    
+
     felica_define_normal_block(service, SYS_CODE_LITE_BLOCK, block_data);
 
     memset(block_data, 0, FELICA_BLOCK_SIZE);
     tx_rx->tx_bits = 8 * felica_lite_prepare_unencrypted_write(
-        tx_rx->tx_data,
-        reader,
-        &fixed_services[1], 1,
-        block_data
-    );
+                             tx_rx->tx_data, reader, &fixed_services[1], 1, block_data);
     if(!furi_hal_nfc_tx_rx_full(tx_rx)) {
         FURI_LOG_W(TAG, "Bad exchange writing random challenge");
         return false;
@@ -432,16 +432,14 @@ bool felica_read_lite_system(FuriHalNfcTxRxContext* tx_rx, FelicaReader* reader,
     felica_define_normal_block(service, RC_LITE_BLOCK, block_data);
 
     tx_rx->tx_bits = 8 * felica_lite_prepare_unencrypted_read(
-        tx_rx->tx_data,
-        reader,
-        true,
-        &fixed_services[2], 2 
-    );
+                             tx_rx->tx_data, reader, true, &fixed_services[2], 2);
     if(!furi_hal_nfc_tx_rx_full(tx_rx)) {
         FURI_LOG_W(TAG, "Bad exchange reading ID with MAC");
         return false;
     }
-    if(felica_parse_unencrypted_read(tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) != FELICA_BLOCK_SIZE * 2) {
+    if(felica_parse_unencrypted_read(
+           tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) !=
+       FELICA_BLOCK_SIZE * 2) {
         FURI_LOG_W(TAG, "Bad response to Read without Encryption (ID, MAC)");
         return false;
     }
@@ -457,47 +455,43 @@ bool felica_read_lite_system(FuriHalNfcTxRxContext* tx_rx, FelicaReader* reader,
     }
 
     tx_rx->tx_bits = 8 * felica_lite_prepare_unencrypted_read(
-        tx_rx->tx_data,
-        reader,
-        true,
-        &fixed_services[4], 3 
-    );
+                             tx_rx->tx_data, reader, true, &fixed_services[4], 3);
     if(!furi_hal_nfc_tx_rx_full(tx_rx)) {
         FURI_LOG_W(TAG, "Bad exchange reading blocks");
         return false;
     }
-    if(felica_parse_unencrypted_read(tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) != FELICA_BLOCK_SIZE * 3) {
+    if(felica_parse_unencrypted_read(
+           tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) !=
+       FELICA_BLOCK_SIZE * 3) {
         FURI_LOG_W(TAG, "Bad response to Read without Encryption (D_ID, CKV, MC)");
         return false;
     }
     felica_define_normal_block(service, DEVICE_ID_LITE_BLOCK, block_data);
     felica_define_normal_block(service, CARD_KEY_VER_LITE_BLOCK, block_data + FELICA_BLOCK_SIZE);
     felica_define_normal_block(service, MEM_CONFIG_LITE_BLOCK, block_data + FELICA_BLOCK_SIZE * 2);
-    
+
     // Read SPAD and REG accordingly to MC
     uint8_t* mc_data = block_data + (FELICA_BLOCK_SIZE * 2);
-    for (uint8_t block_number = 0; block_number <= REG_LITE_BLOCK; block_number++) {
+    for(uint8_t block_number = 0; block_number <= REG_LITE_BLOCK; block_number++) {
         if(!felica_lite_can_read_without_mac(mc_data + 6, block_number)) {
             continue;
         }
 
         tx_rx->tx_bits = 8 * felica_lite_prepare_unencrypted_read(
-            tx_rx->tx_data,
-            reader,
-            true,
-            &block_number, 1 
-        );
+                                 tx_rx->tx_data, reader, true, &block_number, 1);
         if(!furi_hal_nfc_tx_rx_full(tx_rx)) {
             FURI_LOG_W(TAG, "Bad exchange reading blocks");
             return false;
         }
-        if(felica_parse_unencrypted_read(tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) != FELICA_BLOCK_SIZE) {
+        if(felica_parse_unencrypted_read(
+               tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) !=
+           FELICA_BLOCK_SIZE) {
             FURI_LOG_W(TAG, "Bad response to Read without Encryption (block %d)", block_number);
             return false;
         }
         felica_define_normal_block(service, block_number, block_data);
     }
-    if (data->type == FelicaICTypeLiteS) {
+    if(data->type == FelicaICTypeLiteS) {
         const uint8_t fixed_s_services[] = {
             ID_LITE_BLOCK,
             MAC_A_LITE_BLOCK,
@@ -506,44 +500,44 @@ bool felica_read_lite_system(FuriHalNfcTxRxContext* tx_rx, FelicaReader* reader,
         };
 
         tx_rx->tx_bits = 8 * felica_lite_prepare_unencrypted_read(
-            tx_rx->tx_data,
-            reader,
-            true,
-            fixed_s_services, 2 
-        );
+                                 tx_rx->tx_data, reader, true, fixed_s_services, 2);
         if(!furi_hal_nfc_tx_rx_full(tx_rx)) {
             FURI_LOG_W(TAG, "Bad exchange reading ID with MAC_A");
             return false;
         }
-        if(felica_parse_unencrypted_read(tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) != FELICA_BLOCK_SIZE * 2) {
+        if(felica_parse_unencrypted_read(
+               tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) !=
+           FELICA_BLOCK_SIZE * 2) {
             FURI_LOG_W(TAG, "Bad response to Read without Encryption (ID, MAC_A)");
             return false;
         }
         felica_define_normal_block(service, ID_LITE_BLOCK, block_data);
         felica_define_normal_block(service, MAC_A_LITE_BLOCK, block_data + FELICA_BLOCK_SIZE);
-        
+
         tx_rx->tx_bits = 8 * felica_lite_prepare_unencrypted_read(
-            tx_rx->tx_data,
-            reader,
-            true,
-            &fixed_s_services[2], 2 
-        );
+                                 tx_rx->tx_data, reader, true, &fixed_s_services[2], 2);
         if(!furi_hal_nfc_tx_rx_full(tx_rx)) {
             FURI_LOG_W(TAG, "Bad exchange reading ID with MAC_A");
             return false;
         }
-        if(felica_parse_unencrypted_read(tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) != FELICA_BLOCK_SIZE * 2) {
+        if(felica_parse_unencrypted_read(
+               tx_rx->rx_data, tx_rx->rx_bits / 8, reader, block_data, sizeof(block_data)) !=
+           FELICA_BLOCK_SIZE * 2) {
             FURI_LOG_W(TAG, "Bad response to Read without Encryption (WC, CRC_CHECK)");
             return false;
         }
         felica_define_normal_block(service, WRITE_COUNT_LITE_BLOCK, block_data);
         felica_define_normal_block(service, CRC_CHECK_LITE_BLOCK, block_data + FELICA_BLOCK_SIZE);
     }
-    
+
     return true;
 }
 
-bool felica_read_card(FuriHalNfcTxRxContext* tx_rx, FelicaData* data, uint8_t* polled_idm, uint8_t* polled_pmm) {
+bool felica_read_card(
+    FuriHalNfcTxRxContext* tx_rx,
+    FelicaData* data,
+    uint8_t* polled_idm,
+    uint8_t* polled_pmm) {
     furi_assert(tx_rx);
     furi_assert(polled_idm);
     furi_assert(polled_pmm);
@@ -560,7 +554,7 @@ bool felica_read_card(FuriHalNfcTxRxContext* tx_rx, FelicaData* data, uint8_t* p
         felica_parse_system_info(current_system, polled_idm, polled_pmm);
         current_system->next = NULL;
 
-        if (data->type == FelicaICTypeLite || data->type == FelicaICTypeLiteS) {
+        if(data->type == FelicaICTypeLite || data->type == FelicaICTypeLiteS) {
             FURI_LOG_I(TAG, "Reading Felica Lite system");
             felica_read_lite_system(tx_rx, &reader, data, current_system);
             card_read = true;
diff --git a/lib/nfc/protocols/felica.h b/lib/nfc/protocols/felica.h
index 95020a86a..1f0912802 100644
--- a/lib/nfc/protocols/felica.h
+++ b/lib/nfc/protocols/felica.h
@@ -43,7 +43,7 @@
 
 #define RANDOM_TYPE_SERVICE_ATTRIBUTE (0b0010 << 2)
 #define CYCLIC_TYPE_SERVICE_ATTRIBUTE (0b0011 << 2)
-#define PURSE_TYPE_SERVICE_ATTRIBUTE  (0b010  << 3)
+#define PURSE_TYPE_SERVICE_ATTRIBUTE (0b010 << 3)
 
 #define AUTH_RW_SERVICE_ATTRIBUTE (0b00)
 #define UNAUTH_RW_SERVICE_ATTRIBUTE (0b01)
@@ -51,7 +51,7 @@
 #define UNAUTH_RO_SERVICE_ATTRIBUTE (0b11)
 
 #define AUTH_DIRECT_ACCESS_SERVICE_ATTRIBUTE (0b000)
-#define UNAUTH_DIRECT_ACCESS_SERVICE_ATTRIBUTE  (0b001)
+#define UNAUTH_DIRECT_ACCESS_SERVICE_ATTRIBUTE (0b001)
 #define AUTH_CASHBACK_DECREMENT_SERVICE_ATTRIBUTE (0b010)
 #define UNAUTH_CASHBACK_DECREMENT_SERVICE_ATTRIBUTE (0b011)
 #define AUTH_DECREMENT_SERVICE_ATTRIBUTE (0b100)
@@ -97,10 +97,10 @@ typedef enum {
 } FelicaICType;
 
 typedef struct {
-    uint8_t exponent: 2;
+    uint8_t exponent : 2;
     // Incremented at read
-    uint8_t real_a: 4;
-    uint8_t real_b: 4;
+    uint8_t real_a : 4;
+    uint8_t real_b : 4;
 } FelicaMRTParts;
 
 typedef enum {
@@ -150,7 +150,7 @@ typedef struct _FelicaSystem_t {
     FelicaMRTParameters maximum_response_times;
 
     FelicaService* services;
-    
+
     struct _FelicaSystem_t* next;
 } FelicaSystem;
 
@@ -170,4 +170,8 @@ typedef struct {
 
 bool felica_check_ic_type(uint8_t* PMm);
 FelicaICType felica_get_ic_type(uint8_t* PMm);
-bool felica_read_card(FuriHalNfcTxRxContext* tx_rx, FelicaData* data, uint8_t* polled_idm, uint8_t* polled_pmm);
\ No newline at end of file
+bool felica_read_card(
+    FuriHalNfcTxRxContext* tx_rx,
+    FelicaData* data,
+    uint8_t* polled_idm,
+    uint8_t* polled_pmm);
\ No newline at end of file