cleanup by prefixing methods with project name

ccid.c

@@ -18,7 +18,7 @@ uint8_t getSequence() {
     return sequence++;
 }
 
-size_t addLRC(uint8_t* data, size_t len) {
+size_t seader_ccid_add_lrc(uint8_t* data, size_t len) {
     uint8_t lrc = 0;
     for(size_t i = 0; i < len; i++) {
         lrc ^= data[i];
@@ -42,11 +42,11 @@ void PC_to_RDR_IccPowerOn(SeaderUartBridge* seader_uart) {
     seader_uart->tx_buf[2 + 6] = getSequence();
     seader_uart->tx_buf[2 + 7] = 2; //power
 
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10);
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
 
-void check_for_sam(SeaderUartBridge* seader_uart) {
+void seader_ccid_check_for_sam(SeaderUartBridge* seader_uart) {
     hasSAM = false; // If someone is calling this, reset sam state
     powered = false;
     PC_to_RDR_GetSlotStatus(seader_uart);
@@ -61,7 +61,7 @@ void PC_to_RDR_GetSlotStatus(SeaderUartBridge* seader_uart) {
     seader_uart->tx_buf[2 + 5] = slot;
     seader_uart->tx_buf[2 + 6] = getSequence();
 
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10);
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
 
@@ -78,7 +78,7 @@ void PC_to_RDR_SetParameters(SeaderUartBridge* seader_uart) {
     seader_uart->tx_buf[2 + 8] = 0;
     seader_uart->tx_buf[2 + 9] = 0;
 
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10);
 
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
@@ -95,7 +95,7 @@ void PC_to_RDR_GetParameters(SeaderUartBridge* seader_uart) {
     seader_uart->tx_buf[2 + 8] = 0;
     seader_uart->tx_buf[2 + 9] = 0;
 
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10);
 
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
@@ -113,13 +113,13 @@ void PC_to_RDR_XfrBlock(SeaderUartBridge* seader_uart, uint8_t* data, size_t len
     seader_uart->tx_buf[2 + 9] = 0;
 
     memcpy(seader_uart->tx_buf + 2 + 10, data, len);
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10 + len);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10 + len);
     // FURI_LOG_I(TAG, "PC_to_RDR_XfrBlock %d bytes", seader_uart->tx_len);
 
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
 
-size_t processCCID(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len) {
+size_t seader_ccid_process(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     CCID_Message message;
     message.consumed = 0;

ccid.h

@@ -82,10 +82,10 @@ struct CCID_Message {
     size_t consumed;
 };
 
-void check_for_sam(SeaderUartBridge* seader_uart);
+void seader_ccid_check_for_sam(SeaderUartBridge* seader_uart);
 void PC_to_RDR_IccPowerOn(SeaderUartBridge* seader_uart);
 void PC_to_RDR_GetSlotStatus(SeaderUartBridge* seader_uart);
 void PC_to_RDR_SetParameters(SeaderUartBridge* seader_uart);
 void PC_to_RDR_GetParameters(SeaderUartBridge* seader_uart);
 void PC_to_RDR_XfrBlock(SeaderUartBridge* seader_uart, uint8_t* data, size_t len);
-size_t processCCID(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len);
+size_t seader_ccid_process(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len);

seader_worker.c

@@ -21,7 +21,7 @@ char asn1_log[SEADER_UART_RX_BUF_SIZE] = {0};
 bool requestPacs = true;
 
 // Forward declaration
-void sendCardDetected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails);
+void seader_send_card_detected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails);
 
 static void seader_worker_enable_field() {
     furi_hal_nfc_ll_txrx_on();
@@ -109,17 +109,17 @@ void* calloc(size_t count, size_t size) {
     return malloc(count * size);
 }
 
-void nfc_scene_field_on_enter() {
+void seader_nfc_scene_field_on_enter() {
     furi_hal_nfc_field_on();
     furi_hal_nfc_exit_sleep();
 }
 
-void nfc_scene_field_on_exit() {
+void seader_nfc_scene_field_on_exit() {
     furi_hal_nfc_sleep();
     furi_hal_nfc_field_off();
 }
 
-bool sendAPDU(
+bool seader_send_apdu(
     SeaderUartBridge* seader_uart,
     uint8_t CLA,
     uint8_t INS,
@@ -145,7 +145,7 @@ bool sendAPDU(
     return true;
 }
 
-static int toString(const void* buffer, size_t size, void* app_key) {
+static int seader_asn_to_string(const void* buffer, size_t size, void* app_key) {
     if(app_key) {
         char* str = (char*)app_key;
         size_t next = strlen(str);
@@ -157,11 +157,11 @@ static int toString(const void* buffer, size_t size, void* app_key) {
     return 0;
 }
 
-bool mf_df_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
+bool seader_mf_df_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
     return ATQA0 == 0x44 && ATQA1 == 0x03 && SAK == 0x20;
 }
 
-bool mf_classic_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
+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)) {
@@ -174,7 +174,7 @@ bool mf_classic_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
     }
 }
 
-bool read_nfc(SeaderUartBridge* seader_uart) {
+bool seader_read_nfc(SeaderUartBridge* seader_uart) {
     FuriHalNfcDevData nfc_data = {};
     bool rtn = false;
     if(furi_hal_nfc_detect(&nfc_data, 300)) {
@@ -195,24 +195,24 @@ bool read_nfc(SeaderUartBridge* seader_uart) {
 
             uint8_t fake_seos_ats[] = {0x78, 0x77, 0x80, 0x02};
             uint8_t fake_desfire_ats[] = {0x75, 0x77, 0x81, 0x02, 0x80};
-            if(mf_df_check_card_type(nfc_data.atqa[0], nfc_data.atqa[1], nfc_data.sak)) {
+            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;
-                sendCardDetected(seader_uart, cardDetails);
+                seader_send_card_detected(seader_uart, cardDetails);
                 rtn = true;
-            } else if(mf_classic_check_card_type(
+            } else if(seader_mf_classic_check_card_type(
                           nfc_data.atqa[0], nfc_data.atqa[1], nfc_data.sak)) {
                 FURI_LOG_D(TAG, "MFC");
                 OCTET_STRING_t atqa = {.buf = nfc_data.atqa, .size = sizeof(nfc_data.atqa)};
                 cardDetails->atqa = &atqa;
-                sendCardDetected(seader_uart, cardDetails);
+                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;
-                sendCardDetected(seader_uart, cardDetails);
+                seader_send_card_detected(seader_uart, cardDetails);
                 rtn = true;
             }
             ASN_STRUCT_FREE(asn_DEF_CardDetails, cardDetails);
@@ -221,12 +221,12 @@ bool read_nfc(SeaderUartBridge* seader_uart) {
     return rtn;
 }
 
-bool detect_nfc(SeaderWorker* seader_worker) {
+bool seader_detect_nfc(SeaderWorker* seader_worker) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
 
     while(seader_worker->state == SeaderWorkerStateRead14a) {
         // Card found
-        if(read_nfc(seader_uart)) {
+        if(seader_read_nfc(seader_uart)) {
             return true;
         }
 
@@ -235,7 +235,7 @@ bool detect_nfc(SeaderWorker* seader_worker) {
     return false;
 }
 
-void sendPayload(
+void seader_send_payload(
     SeaderUartBridge* seader_uart,
     Payload_t* payload,
     uint8_t to,
@@ -249,7 +249,8 @@ void sendPayload(
 #ifdef ASN1_DEBUG
     if(er.encoded > -1) {
         memset(payloadDebug, 0, sizeof(payloadDebug));
-        (&asn_DEF_Payload)->op->print_struct(&asn_DEF_Payload, payload, 1, toString, payloadDebug);
+        (&asn_DEF_Payload)
+            ->op->print_struct(&asn_DEF_Payload, payload, 1, seader_asn_to_string, payloadDebug);
         if(strlen(payloadDebug) > 0) {
             FURI_LOG_D(TAG, "Sending payload: %s", payloadDebug);
         }
@@ -261,10 +262,10 @@ void sendPayload(
     rBuffer[1] = from;
     rBuffer[2] = replyTo;
 
-    sendAPDU(seader_uart, 0xA0, 0xDA, 0x02, 0x63, rBuffer, 6 + er.encoded);
+    seader_send_apdu(seader_uart, 0xA0, 0xDA, 0x02, 0x63, rBuffer, 6 + er.encoded);
 }
 
-void sendResponse(
+void seader_send_response(
     SeaderUartBridge* seader_uart,
     Response_t* response,
     uint8_t to,
@@ -277,7 +278,7 @@ void sendResponse(
     payload->present = Payload_PR_response;
     payload->choice.response = *response;
 
-    sendPayload(seader_uart, payload, to, from, replyTo);
+    seader_send_payload(seader_uart, payload, to, from, replyTo);
 
     ASN_STRUCT_FREE(asn_DEF_Payload, payload);
 }
@@ -303,7 +304,7 @@ void sendRequestPacs(SeaderUartBridge* seader_uart) {
     payload->present = Payload_PR_samCommand;
     payload->choice.samCommand = *samCommand;
 
-    sendPayload(seader_uart, payload, 0x44, 0x0a, 0x44);
+    seader_send_payload(seader_uart, payload, 0x44, 0x0a, 0x44);
 
     ASN_STRUCT_FREE(asn_DEF_RequestPacs, requestPacs);
     ASN_STRUCT_FREE(asn_DEF_SamCommand, samCommand);
@@ -325,13 +326,13 @@ void seader_worker_send_version(SeaderWorker* seader_worker) {
     payload->present = Payload_PR_samCommand;
     payload->choice.samCommand = *samCommand;
 
-    sendPayload(seader_uart, payload, 0x44, 0x0a, 0x44);
+    seader_send_payload(seader_uart, payload, 0x44, 0x0a, 0x44);
 
     ASN_STRUCT_FREE(asn_DEF_SamCommand, samCommand);
     ASN_STRUCT_FREE(asn_DEF_Payload, payload);
 }
 
-void sendCardDetected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails) {
+void seader_send_card_detected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails) {
     CardDetected_t* cardDetected = 0;
     cardDetected = calloc(1, sizeof *cardDetected);
     assert(cardDetected);
@@ -352,14 +353,14 @@ void sendCardDetected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails)
     payload->present = Payload_PR_samCommand;
     payload->choice.samCommand = *samCommand;
 
-    sendPayload(seader_uart, payload, 0x44, 0x0a, 0x44);
+    seader_send_payload(seader_uart, payload, 0x44, 0x0a, 0x44);
 
     ASN_STRUCT_FREE(asn_DEF_CardDetected, cardDetected);
     ASN_STRUCT_FREE(asn_DEF_SamCommand, samCommand);
     ASN_STRUCT_FREE(asn_DEF_Payload, payload);
 }
 
-bool unpack_pacs(
+bool seader_unpack_pacs(
     SeaderWorker* seader_worker,
     SeaderCredential* seader_credential,
     uint8_t* buf,
@@ -373,7 +374,7 @@ bool unpack_pacs(
 
     if(rval.code == RC_OK) {
         char pacDebug[384] = {0};
-        (&asn_DEF_PAC)->op->print_struct(&asn_DEF_PAC, pac, 1, toString, pacDebug);
+        (&asn_DEF_PAC)->op->print_struct(&asn_DEF_PAC, pac, 1, seader_asn_to_string, pacDebug);
         if(strlen(pacDebug) > 0) {
             FURI_LOG_D(TAG, "Received pac: %s", pacDebug);
 
@@ -409,7 +410,7 @@ bool unpack_pacs(
 
 //    800201298106683d052026b6820101
 //300F800201298106683D052026B6820101
-bool parseVersion(SeaderWorker* seader_worker, uint8_t* buf, size_t size) {
+bool seader_parse_version(SeaderWorker* seader_worker, uint8_t* buf, size_t size) {
     SamVersion_t* version = 0;
     version = calloc(1, sizeof *version);
     assert(version);
@@ -431,7 +432,8 @@ bool parseVersion(SeaderWorker* seader_worker, uint8_t* buf, size_t size) {
     if(rval.code == RC_OK) {
         char versionDebug[128] = {0};
         (&asn_DEF_SamVersion)
-            ->op->print_struct(&asn_DEF_SamVersion, version, 1, toString, versionDebug);
+            ->op->print_struct(
+                &asn_DEF_SamVersion, version, 1, seader_asn_to_string, versionDebug);
         if(strlen(versionDebug) > 0) {
             FURI_LOG_D(TAG, "Received version: %s", versionDebug);
         }
@@ -446,7 +448,7 @@ bool parseVersion(SeaderWorker* seader_worker, uint8_t* buf, size_t size) {
     return rtn;
 }
 
-bool parseSamResponse(SeaderWorker* seader_worker, SamResponse_t* samResponse) {
+bool seader_parse_sam_response(SeaderWorker* seader_worker, SamResponse_t* samResponse) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     SeaderCredential* credential = seader_worker->credential;
 
@@ -461,9 +463,9 @@ bool parseSamResponse(SeaderWorker* seader_worker, SamResponse_t* samResponse) {
                 seader_worker->callback(SeaderWorkerEventFail, seader_worker->context);
             }
         }
-    } else if(parseVersion(seader_worker, samResponse->buf, samResponse->size)) {
+    } else if(seader_parse_version(seader_worker, samResponse->buf, samResponse->size)) {
         // no-op
-    } else if(unpack_pacs(seader_worker, credential, samResponse->buf, samResponse->size)) {
+    } else if(seader_unpack_pacs(seader_worker, credential, samResponse->buf, samResponse->size)) {
         if(seader_worker->callback) {
             seader_worker->callback(SeaderWorkerEventSuccess, seader_worker->context);
         }
@@ -478,10 +480,10 @@ bool parseSamResponse(SeaderWorker* seader_worker, SamResponse_t* samResponse) {
     return false;
 }
 
-bool parseResponse(SeaderWorker* seader_worker, Response_t* response) {
+bool seader_parse_response(SeaderWorker* seader_worker, Response_t* response) {
     switch(response->present) {
     case Response_PR_samResponse:
-        parseSamResponse(seader_worker, &response->choice.samResponse);
+        seader_parse_sam_response(seader_worker, &response->choice.samResponse);
         break;
     default:
         break;
@@ -489,7 +491,7 @@ bool parseResponse(SeaderWorker* seader_worker, Response_t* response) {
     return false;
 }
 
-void sendNFCRx(SeaderUartBridge* seader_uart, uint8_t* buffer, size_t len) {
+void seader_send_nfc_rx(SeaderUartBridge* seader_uart, uint8_t* buffer, size_t len) {
     OCTET_STRING_t rxData = {.buf = buffer, .size = len};
     uint8_t status[] = {0x00, 0x00};
     RfStatus_t rfStatus = {.buf = status, .size = 2};
@@ -515,14 +517,14 @@ void sendNFCRx(SeaderUartBridge* seader_uart, uint8_t* buffer, size_t len) {
     response->present = Response_PR_nfcResponse;
     response->choice.nfcResponse = *nfcResponse;
 
-    sendResponse(seader_uart, response, 0x14, 0x0a, 0x0);
+    seader_send_response(seader_uart, response, 0x14, 0x0a, 0x0);
 
     ASN_STRUCT_FREE(asn_DEF_NFCRx, nfcRx);
     ASN_STRUCT_FREE(asn_DEF_NFCResponse, nfcResponse);
     ASN_STRUCT_FREE(asn_DEF_Response, response);
 }
 
-bool iso14443aTransmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len) {
+bool seader_iso14443a_transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     FuriHalNfcTxRxContext tx_rx = {.tx_rx_type = FuriHalNfcTxRxTypeDefault};
     memcpy(&tx_rx.tx_data, buffer, len);
@@ -536,7 +538,7 @@ bool iso14443aTransmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len)
             snprintf(display + (i * 2), sizeof(display), "%02x", tx_rx.rx_data[i]);
         }
         // FURI_LOG_D(TAG, "NFC Response %d: %s", length, display);
-        sendNFCRx(seader_uart, tx_rx.rx_data, length);
+        seader_send_nfc_rx(seader_uart, tx_rx.rx_data, length);
     } else {
         FURI_LOG_W(TAG, "Bad exchange");
         if(seader_worker->callback) {
@@ -552,7 +554,11 @@ uint8_t read4Block9[] = {0x06, 0x09, 0xB2, 0xAE};
 uint8_t read4Block10[] = {0x06, 0x0A, 0x29, 0x9C};
 uint8_t read4Block13[] = {0x06, 0x0D, 0x96, 0xE8};
 
-void handleSIO(uint8_t* buffer, size_t len, uint8_t* rxBuffer, SeaderCredential* credential) {
+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) {
@@ -564,7 +570,7 @@ void handleSIO(uint8_t* buffer, size_t len, uint8_t* rxBuffer, SeaderCredential*
     }
 }
 
-bool iso15693Transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len) {
+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};
@@ -582,18 +588,18 @@ bool iso15693Transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len)
             snprintf(display + (i * 2), sizeof(display), "%02x", rxBuffer[i]);
         }
         // FURI_LOG_D(TAG, "Result %d %s", recvLen, display);
-        handleSIO(buffer, len, rxBuffer, credential);
+        seader_capture_sio(buffer, len, rxBuffer, credential);
 
-        sendNFCRx(seader_uart, rxBuffer, recvLen);
+        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);
-        handleSIO(buffer, len, rxBuffer, credential);
+        seader_capture_sio(buffer, len, rxBuffer, credential);
 
-        sendNFCRx(seader_uart, rxBuffer, recvLen);
+        seader_send_nfc_rx(seader_uart, rxBuffer, recvLen);
 
         // Act as if it was OK
         return true;
@@ -608,7 +614,7 @@ bool iso15693Transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len)
     return ret == FuriHalNfcReturnOk;
 }
 
-bool parseNfcCommandTransmit(SeaderWorker* seader_worker, NFCSend_t* nfcSend) {
+bool seader_parse_nfc_command_transmit(SeaderWorker* seader_worker, NFCSend_t* nfcSend) {
     long timeOut = nfcSend->timeOut;
     Protocol_t protocol = nfcSend->protocol;
     FrameProtocol_t frameProtocol = protocol.buf[1];
@@ -621,7 +627,8 @@ bool parseNfcCommandTransmit(SeaderWorker* seader_worker, NFCSend_t* nfcSend) {
 
     char protocolName[8] = {0};
     (&asn_DEF_FrameProtocol)
-        ->op->print_struct(&asn_DEF_FrameProtocol, &frameProtocol, 1, toString, protocolName);
+        ->op->print_struct(
+            &asn_DEF_FrameProtocol, &frameProtocol, 1, seader_asn_to_string, protocolName);
 
     FURI_LOG_D(
         TAG,
@@ -635,17 +642,17 @@ bool parseNfcCommandTransmit(SeaderWorker* seader_worker, NFCSend_t* nfcSend) {
 #endif
 
     if(frameProtocol == FrameProtocol_iclass) {
-        return iso15693Transmit(seader_worker, nfcSend->data.buf, nfcSend->data.size);
+        return seader_iso15693_transmit(seader_worker, nfcSend->data.buf, nfcSend->data.size);
     } else if(frameProtocol == FrameProtocol_nfc) {
-        return iso14443aTransmit(seader_worker, nfcSend->data.buf, nfcSend->data.size);
+        return seader_iso14443a_transmit(seader_worker, nfcSend->data.buf, nfcSend->data.size);
     }
     return false;
 }
 
-bool parseNfcOff(SeaderUartBridge* seader_uart) {
+bool seader_parse_nfc_off(SeaderUartBridge* seader_uart) {
     FURI_LOG_D(TAG, "Set Field Off");
     seader_worker_disable_field(ERR_NONE);
-    nfc_scene_field_on_exit();
+    seader_nfc_scene_field_on_exit();
 
     NFCResponse_t* nfcResponse = 0;
     nfcResponse = calloc(1, sizeof *nfcResponse);
@@ -660,7 +667,7 @@ bool parseNfcOff(SeaderUartBridge* seader_uart) {
     response->present = Response_PR_nfcResponse;
     response->choice.nfcResponse = *nfcResponse;
 
-    sendResponse(seader_uart, response, 0x44, 0x0a, 0);
+    seader_send_response(seader_uart, response, 0x44, 0x0a, 0);
 
     ASN_STRUCT_FREE(asn_DEF_Response, response);
     ASN_STRUCT_FREE(asn_DEF_NFCResponse, nfcResponse);
@@ -668,14 +675,14 @@ bool parseNfcOff(SeaderUartBridge* seader_uart) {
     return false;
 }
 
-bool parseNfcCommand(SeaderWorker* seader_worker, NFCCommand_t* nfcCommand) {
+bool seader_parse_nfc_command(SeaderWorker* seader_worker, NFCCommand_t* nfcCommand) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     switch(nfcCommand->present) {
     case NFCCommand_PR_nfcSend:
-        parseNfcCommandTransmit(seader_worker, &nfcCommand->choice.nfcSend);
+        seader_parse_nfc_command_transmit(seader_worker, &nfcCommand->choice.nfcSend);
         break;
     case NFCCommand_PR_nfcOff:
-        parseNfcOff(seader_uart);
+        seader_parse_nfc_off(seader_uart);
         break;
     default:
         FURI_LOG_W(TAG, "unparsed NFCCommand");
@@ -685,13 +692,13 @@ bool parseNfcCommand(SeaderWorker* seader_worker, NFCCommand_t* nfcCommand) {
     return false;
 }
 
-bool stateMachine(SeaderWorker* seader_worker, Payload_t* payload) {
+bool seader_worker_state_machine(SeaderWorker* seader_worker, Payload_t* payload) {
     switch(payload->present) {
     case Payload_PR_response:
-        parseResponse(seader_worker, &payload->choice.response);
+        seader_parse_response(seader_worker, &payload->choice.response);
         break;
     case Payload_PR_nfcCommand:
-        parseNfcCommand(seader_worker, &payload->choice.nfcCommand);
+        seader_parse_nfc_command(seader_worker, &payload->choice.nfcCommand);
         break;
     case Payload_PR_errorResponse:
         // TODO: screen saying this was a failure, or maybe start over?
@@ -707,7 +714,7 @@ bool stateMachine(SeaderWorker* seader_worker, Payload_t* payload) {
     return false;
 }
 
-bool processSuccessResponse(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
+bool seader_process_success_response(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
     Payload_t* payload = 0;
     payload = calloc(1, sizeof *payload);
     assert(payload);
@@ -717,19 +724,20 @@ bool processSuccessResponse(SeaderWorker* seader_worker, uint8_t* apdu, size_t l
     if(rval.code == RC_OK) {
 #ifdef ASN1_DEBUG
         memset(payloadDebug, 0, sizeof(payloadDebug));
-        (&asn_DEF_Payload)->op->print_struct(&asn_DEF_Payload, payload, 1, toString, payloadDebug);
+        (&asn_DEF_Payload)
+            ->op->print_struct(&asn_DEF_Payload, payload, 1, seader_asn_to_string, payloadDebug);
         if(strlen(payloadDebug) > 0) {
             FURI_LOG_D(TAG, "Received payload: %s", payloadDebug);
         }
 #endif
-        stateMachine(seader_worker, payload);
+        seader_worker_state_machine(seader_worker, payload);
     }
 
     ASN_STRUCT_FREE(asn_DEF_Payload, payload);
     return (rval.code == RC_OK);
 }
 
-bool processAPDU(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
+bool seader_process_apdu(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     if(len < 2) {
         return false;
@@ -756,7 +764,7 @@ bool processAPDU(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
     case 0x90:
         if(SW2 == 0x00) {
             if(len > 2) {
-                return processSuccessResponse(seader_worker, apdu, len - 2);
+                return seader_process_success_response(seader_worker, apdu, len - 2);
             }
         }
         break;
@@ -765,7 +773,7 @@ bool processAPDU(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
     return false;
 }
 
-ReturnCode picopass_card_init(SeaderWorker* seader_worker) {
+ReturnCode seader_picopass_card_init(SeaderWorker* seader_worker) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     SeaderCredential* credential = seader_worker->credential;
     rfalPicoPassIdentifyRes idRes;
@@ -803,13 +811,13 @@ ReturnCode picopass_card_init(SeaderWorker* seader_worker) {
 
     memcpy(credential->diversifier, selRes.CSN, RFAL_PICOPASS_MAX_BLOCK_LEN);
 
-    sendCardDetected(seader_uart, cardDetails);
+    seader_send_card_detected(seader_uart, cardDetails);
 
     ASN_STRUCT_FREE(asn_DEF_CardDetails, cardDetails);
     return ERR_NONE;
 }
 
-ReturnCode picopass_card_detect() {
+ReturnCode seader_picopass_card_detect() {
     ReturnCode err;
 
     err = rfalPicoPassPollerInitialize();
@@ -835,13 +843,13 @@ ReturnCode picopass_card_detect() {
     return ERR_NONE;
 }
 
-ReturnCode picopass_card_read(SeaderWorker* seader_worker) {
+ReturnCode seader_picopass_card_read(SeaderWorker* seader_worker) {
     ReturnCode err = ERR_TIMEOUT;
 
     while(seader_worker->state == SeaderWorkerStateReadPicopass) {
         // Card found
-        if(picopass_card_detect() == ERR_NONE) {
-            err = picopass_card_init(seader_worker);
+        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);
             }
@@ -855,7 +863,7 @@ ReturnCode picopass_card_read(SeaderWorker* seader_worker) {
 }
 
 void seader_worker_process_message(SeaderWorker* seader_worker, CCID_Message* message) {
-    if(processAPDU(seader_worker, message->payload, message->dwLength)) {
+    if(seader_process_apdu(seader_worker, message->payload, message->dwLength)) {
         // no-op
     } else {
         memset(display, 0, sizeof(display));
@@ -876,14 +884,14 @@ int32_t seader_worker_task(void* context) {
 
     if(seader_worker->state == SeaderWorkerStateCheckSam) {
         furi_delay_ms(1000);
-        check_for_sam(seader_uart);
+        seader_ccid_check_for_sam(seader_uart);
     } else if(seader_worker->state == SeaderWorkerStateReadPicopass) {
         FURI_LOG_D(TAG, "Read Picopass");
         requestPacs = true;
         seader_credential_clear(seader_worker->credential);
         seader_worker->credential->type = SeaderCredentialTypePicopass;
         seader_worker_enable_field();
-        if(picopass_card_read(seader_worker) != ERR_NONE) {
+        if(seader_picopass_card_read(seader_worker) != ERR_NONE) {
             // Turn off if cancelled / no card found
             seader_worker_disable_field(ERR_NONE);
         }
@@ -892,10 +900,10 @@ int32_t seader_worker_task(void* context) {
         requestPacs = true;
         seader_credential_clear(seader_worker->credential);
         seader_worker->credential->type = SeaderCredentialType14A;
-        nfc_scene_field_on_enter();
-        if(!detect_nfc(seader_worker)) {
+        seader_nfc_scene_field_on_enter();
+        if(!seader_detect_nfc(seader_worker)) {
             // Turn off if cancelled / no card found
-            nfc_scene_field_on_exit();
+            seader_nfc_scene_field_on_exit();
         }
     }
     FURI_LOG_D(TAG, "Worker Task Complete");

uart.c

@@ -47,7 +47,7 @@ size_t seader_uart_process_buffer(Seader* seader, uint8_t* cmd, size_t cmd_len)
 
     size_t consumed = 0;
     do {
-        consumed = processCCID(seader_worker, cmd, cmd_len);
+        consumed = seader_ccid_process(seader_worker, cmd, cmd_len);
 
         if(consumed > 0) {
             memset(cmd, 0, consumed);