webadmin/pico-keys-sdk
1
0
Fork 0
mirror of https://github.com/polhenarejos/pico-keys-sdk synced 2026-05-28 17:11:23 +02:00
Code Issues Packages Projects Releases Wiki Activity

Fix emulation build.

Browse Source 
Signed-off-by: Pol Henarejos <pol.henarejos@cttc.es>
This commit is contained in:
Pol Henarejos
2024-08-23 14:24:17 +02:00
parent 65fea84df1
commit 90842bb8f7
6 changed files with 154 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
pico_keys_sdk_import.cmake
View File

@@ -175,7 +175,7 @@ set(INCLUDES ${INCLUDES}
${CMAKE_CURRENT_LIST_DIR}/mbedtls/library ${CMAKE_CURRENT_LIST_DIR}/mbedtls/library
) )
if(USB_ITF_HID OR ENABLE_EMULATION) if(USB_ITF_HID)
set(MBEDTLS_SOURCES ${MBEDTLS_SOURCES} set(MBEDTLS_SOURCES ${MBEDTLS_SOURCES}
${CMAKE_CURRENT_LIST_DIR}/mbedtls/library/x509write_crt.c ${CMAKE_CURRENT_LIST_DIR}/mbedtls/library/x509write_crt.c
${CMAKE_CURRENT_LIST_DIR}/mbedtls/library/x509_create.c ${CMAKE_CURRENT_LIST_DIR}/mbedtls/library/x509_create.c
@@ -195,6 +195,15 @@ if(USB_ITF_HID OR ENABLE_EMULATION)
) )
endif() endif()
if (USB_ITF_CCID)
set(SOURCES ${SOURCES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/ccid/ccid.c
)
set(INCLUDES ${INCLUDES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/ccid
)
endif()
set(LIBRARIES set(LIBRARIES
pico_stdlib pico_stdlib
pico_multicore pico_multicore
@@ -250,14 +259,6 @@ if (ENABLE_EMULATION)
${CMAKE_CURRENT_LIST_DIR}/src/usb/emulation ${CMAKE_CURRENT_LIST_DIR}/src/usb/emulation
) )
else() else()
if (${USB_ITF_CCID})
set(SOURCES ${SOURCES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/ccid/ccid.c
)
set(INCLUDES ${INCLUDES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/ccid
)
endif()
set(SOURCES ${SOURCES} set(SOURCES ${SOURCES}
${CMAKE_CURRENT_LIST_DIR}/src/usb/usb_descriptors.c ${CMAKE_CURRENT_LIST_DIR}/src/usb/usb_descriptors.c

49
src/usb/ccid/ccid.c
View File

@@ -19,15 +19,18 @@
#include "pico_keys.h" #include "pico_keys.h"
#if !defined(ENABLE_EMULATION) && !defined(ESP_PLATFORM) #if !defined(ENABLE_EMULATION) && !defined(ESP_PLATFORM)
#include "hardware/rtc.h" #include "hardware/rtc.h"
#endif
#ifndef ESP_PLATFORM
#include "bsp/board.h" #include "bsp/board.h"
#else #endif
#ifdef ESP_PLATFORM
static portMUX_TYPE mutex = portMUX_INITIALIZER_UNLOCKED; static portMUX_TYPE mutex = portMUX_INITIALIZER_UNLOCKED;
#endif #endif
#ifndef ENABLE_EMULATION
#include "tusb.h" #include "tusb.h"
#include "ccid.h"
#include "device/usbd_pvt.h" #include "device/usbd_pvt.h"
#else
#include "emulation.h"
#endif
#include "ccid.h"
#include "usb_descriptors.h" #include "usb_descriptors.h"
#include "apdu.h" #include "apdu.h"
#include "usb.h" #include "usb.h"
@@ -142,9 +145,9 @@ void tud_vendor_rx_cb(uint8_t itf) {
tlen = 0xFFFF; tlen = 0xFFFF;
} }
else { else {
tlen = len; tlen = (uint16_t)len;
} }
tlen = tud_vendor_n_read(itf, ccid_rx[itf].buffer + ccid_rx[itf].w_ptr, tlen); tlen = (uint16_t)tud_vendor_n_read(itf, ccid_rx[itf].buffer + ccid_rx[itf].w_ptr, tlen);
ccid_rx[itf].w_ptr += tlen; ccid_rx[itf].w_ptr += tlen;
driver_process_usb_packet_ccid(itf, tlen); driver_process_usb_packet_ccid(itf, tlen);
len -= tlen; len -= tlen;
@@ -160,7 +163,7 @@ void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes) {
last_write_result[itf] = WRITE_SUCCESS; last_write_result[itf] = WRITE_SUCCESS;
ccid_header_t *lresp = &ccid_response_last[itf]; ccid_header_t *lresp = &ccid_response_last[itf];
if (lresp->bMessageType != CCID_DATA_BLOCK_RET || lresp->dwLength != 0 || lresp->bSlot != 0 || lresp->abRFU0 != CCID_CMD_STATUS_TIMEEXT) { if (lresp->bMessageType != CCID_DATA_BLOCK_RET || lresp->dwLength != 0 || lresp->bSlot != 0 || lresp->abRFU0 != CCID_CMD_STATUS_TIMEEXT) {
ccid_tx[itf].r_ptr += sent_bytes; ccid_tx[itf].r_ptr += (uint16_t)sent_bytes;
} }
} }
if (ccid_tx[itf].r_ptr >= ccid_tx[itf].w_ptr) { if (ccid_tx[itf].r_ptr >= ccid_tx[itf].w_ptr) {
@@ -185,15 +188,19 @@ int driver_write_ccid(uint8_t itf, const uint8_t *tx_buffer, uint16_t buffer_siz
if (r == buffer_size) { if (r == buffer_size) {
r = tud_vendor_n_flush(itf); r = tud_vendor_n_flush(itf);
} }
#ifdef ENABLE_EMULATION
tud_vendor_tx_cb(itf, r);
#endif
return r; return r;
} }
int driver_process_usb_packet_ccid(uint8_t itf, uint16_t rx_read) { int driver_process_usb_packet_ccid(uint8_t itf, uint16_t rx_read) {
(void) rx_read;
if (ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr >= 10) { if (ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr >= 10) {
driver_init_ccid(itf); driver_init_ccid(itf);
//printf("ccid_process %ld %d %x %x %d\n",ccid_header[itf]->dwLength,rx_read-10,ccid_header[itf]->bMessageType,ccid_header[itf]->bSeq,ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr - 10); //printf("ccid_process %ld %d %x %x %d\n",ccid_header[itf]->dwLength,rx_read-10,ccid_header[itf]->bMessageType,ccid_header[itf]->bSeq,ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr - 10);
if (ccid_header[itf]->dwLength <= ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr - 10){ if (ccid_header[itf]->dwLength <= (uint32_t)(ccid_rx[itf].w_ptr - ccid_rx[itf].r_ptr - 10)){
ccid_rx[itf].r_ptr += ccid_header[itf]->dwLength + 10; ccid_rx[itf].r_ptr += (uint16_t)(ccid_header[itf]->dwLength + 10);
if (ccid_rx[itf].r_ptr >= ccid_rx[itf].w_ptr) { if (ccid_rx[itf].r_ptr >= ccid_rx[itf].w_ptr) {
ccid_rx[itf].r_ptr = ccid_rx[itf].w_ptr = 0; ccid_rx[itf].r_ptr = ccid_rx[itf].w_ptr = 0;
} }
@@ -214,7 +221,7 @@ int driver_process_usb_packet_ccid(uint8_t itf, uint16_t rx_read) {
else if (ccid_header[itf]->bMessageType == CCID_POWER_ON) { else if (ccid_header[itf]->bMessageType == CCID_POWER_ON) {
size_t size_atr = (ccid_atr ? ccid_atr[0] : 0); size_t size_atr = (ccid_atr ? ccid_atr[0] : 0);
ccid_resp_fast[itf]->bMessageType = CCID_DATA_BLOCK_RET; ccid_resp_fast[itf]->bMessageType = CCID_DATA_BLOCK_RET;
ccid_resp_fast[itf]->dwLength = size_atr; ccid_resp_fast[itf]->dwLength = (uint32_t)size_atr;
ccid_resp_fast[itf]->bSlot = 0; ccid_resp_fast[itf]->bSlot = 0;
ccid_resp_fast[itf]->bSeq = ccid_header[itf]->bSeq; ccid_resp_fast[itf]->bSeq = ccid_header[itf]->bSeq;
ccid_resp_fast[itf]->abRFU0 = 0; ccid_resp_fast[itf]->abRFU0 = 0;
@@ -225,7 +232,7 @@ int driver_process_usb_packet_ccid(uint8_t itf, uint16_t rx_read) {
//card_start(apdu_thread); //card_start(apdu_thread);
} }
ccid_status = 0; ccid_status = 0;
driver_write_ccid(itf, (const uint8_t *)ccid_resp_fast[itf], size_atr + 10); driver_write_ccid(itf, (const uint8_t *)ccid_resp_fast[itf], (uint16_t)(size_atr + 10));
} }
else if (ccid_header[itf]->bMessageType == CCID_POWER_OFF) { else if (ccid_header[itf]->bMessageType == CCID_POWER_OFF) {
if (ccid_status == 0) { if (ccid_status == 0) {
@@ -264,22 +271,20 @@ int driver_process_usb_packet_ccid(uint8_t itf, uint16_t rx_read) {
} }
else if (ccid_header[itf]->bMessageType == CCID_XFR_BLOCK) { else if (ccid_header[itf]->bMessageType == CCID_XFR_BLOCK) {
apdu.rdata = &ccid_response[itf]->apdu; apdu.rdata = &ccid_response[itf]->apdu;
apdu_sent = apdu_process(itf, &ccid_header[itf]->apdu, ccid_header[itf]->dwLength); apdu_sent = apdu_process(itf, &ccid_header[itf]->apdu, (uint16_t)ccid_header[itf]->dwLength);
#ifndef ENABLE_EMULATION
if (apdu_sent > 0) { if (apdu_sent > 0) {
card_start(sc_itf_to_usb_itf(itf), apdu_thread); card_start(sc_itf_to_usb_itf(itf), apdu_thread);
usb_send_event(EV_CMD_AVAILABLE); usb_send_event(EV_CMD_AVAILABLE);
} }
#endif
} }
return apdu_sent; return (uint16_t)apdu_sent;
} }
} }
return 0; return 0;
} }
bool driver_mounted_ccid(uint8_t itf) {
return tud_vendor_n_mounted(itf);
}
void driver_exec_timeout_ccid(uint8_t itf) { void driver_exec_timeout_ccid(uint8_t itf) {
ccid_resp_fast[itf]->bMessageType = CCID_DATA_BLOCK_RET; ccid_resp_fast[itf]->bMessageType = CCID_DATA_BLOCK_RET;
ccid_resp_fast[itf]->dwLength = 0; ccid_resp_fast[itf]->dwLength = 0;
@@ -306,6 +311,12 @@ void driver_exec_finished_cont_ccid(uint8_t itf, uint16_t size_next, uint16_t of
} }
void ccid_task() { void ccid_task() {
#ifdef ENABLE_EMULATION
uint16_t rx_len = emul_read(ITF_CCID);
if (rx_len) {
tud_vendor_rx_cb(ITF_CCID);
}
#else
for (int itf = 0; itf < ITF_SC_TOTAL; itf++) { for (int itf = 0; itf < ITF_SC_TOTAL; itf++) {
int status = card_status(sc_itf_to_usb_itf(itf)); int status = card_status(sc_itf_to_usb_itf(itf));
if (status == CCID_OK) { if (status == CCID_OK) {
@@ -320,8 +331,11 @@ void ccid_task() {
} }
} }
} }
#endif
} }
#ifndef ENABLE_EMULATION
#define USB_CONFIG_ATT_ONE TU_BIT(7) #define USB_CONFIG_ATT_ONE TU_BIT(7)
#define MAX_USB_POWER 1 #define MAX_USB_POWER 1
@@ -429,3 +443,4 @@ usbd_class_driver_t const *usbd_app_driver_get_cb(uint8_t *driver_count) {
*driver_count = 1; *driver_count = 1;
return &ccid_driver; return &ccid_driver;
} }
#endif

92
src/usb/emulation/emulation.c
View File

@@ -164,16 +164,6 @@ int emul_init(char *host, uint16_t port) {
return 0; return 0;
} }
uint8_t *driver_prepare_response_emul(uint8_t itf) {
apdu.rdata = usb_get_tx(itf);
#ifdef USB_ITF_HID
if (itf == ITF_HID) {
apdu.rdata += 7;
}
#endif
return apdu.rdata;
}
socket_t get_sock_itf(uint8_t itf) { socket_t get_sock_itf(uint8_t itf) {
#ifdef USB_ITF_CCID #ifdef USB_ITF_CCID
if (itf == ITF_CCID) { if (itf == ITF_CCID) {
@@ -188,11 +178,6 @@ socket_t get_sock_itf(uint8_t itf) {
return INVALID_SOCKET; return INVALID_SOCKET;
} }
extern void tud_hid_report_complete_cb(uint8_t instance, uint8_t const *report, uint16_t len);
const uint8_t *complete_report = NULL;
uint16_t complete_len = 0;
extern uint8_t last_write_result[ITF_TOTAL];
extern uint16_t send_buffer_size[ITF_TOTAL];
uint16_t driver_write_emul(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size) { uint16_t driver_write_emul(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size) {
uint16_t size = htons(buffer_size); uint16_t size = htons(buffer_size);
socket_t sock = get_sock_itf(itf); socket_t sock = get_sock_itf(itf);
@@ -210,28 +195,10 @@ uint16_t driver_write_emul(uint8_t itf, const uint8_t *buffer, uint16_t buffer_s
msleep(10); msleep(10);
} }
} while (ret <= 0); } while (ret <= 0);
#ifdef USB_ITF_HID emul_tx_size = buffer_size;
if (itf == ITF_HID) {
last_write_result[itf] = WRITE_PENDING;
complete_report = buffer;
complete_len = buffer_size;
}
#endif
return buffer_size; return buffer_size;
} }
uint32_t emul_write_offset(uint8_t itf, uint16_t size, uint16_t offset) {
if (size > 0) {
//DEBUG_PAYLOAD(usb_get_tx(itf)+offset, size);
return usb_write_offset(itf, size, offset);
}
return 0;
}
uint32_t emul_write(uint8_t itf, uint16_t size) {
return emul_write_offset(itf, size, 0);
}
void driver_exec_finished_cont_emul(uint8_t itf, uint16_t size_next, uint16_t offset) { void driver_exec_finished_cont_emul(uint8_t itf, uint16_t size_next, uint16_t offset) {
#ifdef USB_ITF_HID #ifdef USB_ITF_HID
if (itf == ITF_HID) { if (itf == ITF_HID) {
@@ -240,62 +207,14 @@ void driver_exec_finished_cont_emul(uint8_t itf, uint16_t size_next, uint16_t of
#endif #endif
#ifdef USB_ITF_CCID #ifdef USB_ITF_CCID
if (itf == ITF_CCID) { if (itf == ITF_CCID) {
emul_write_offset(itf, size_next, offset); driver_exec_finished_cont_ccid(itf, size_next, offset);
} }
#endif #endif
} }
int driver_process_usb_packet_emul(uint8_t itf, uint16_t len) {
if (len > 0) {
#ifdef USB_ITF_CCID
if (itf == ITF_CCID) {
uint8_t *data = usb_get_rx(itf);
if (len == 1) {
uint8_t c = data[0];
if (c == 4) {
driver_write_emul(itf, ccid_atr ? ccid_atr + 1 : NULL, ccid_atr ? ccid_atr[0] : 0);
}
}
else {
uint16_t sent = 0;
DEBUG_PAYLOAD(data, len);
if ((sent = apdu_process(itf, data, len)) > 0) {
process_apdu();
apdu_finish();
}
if (sent > 0) {
uint16_t ret = apdu_next();
DEBUG_PAYLOAD(apdu.rdata, ret);
emul_write(itf, ret);
}
}
}
#endif
#ifdef USB_ITF_HID
if (itf == ITF_HID) {
if (driver_process_usb_packet_hid(len) > 0) {
if (thread_type == 1) {
process_apdu();
apdu_finish();
finished_data_size = apdu_next();
}
else if (thread_type == 2) {
apdu.sw = cbor_parse(cmd, cbor_data, cbor_len);
if (apdu.sw == 0) {
DEBUG_DATA(res_APDU + 1, res_APDU_size);
}
finished_data_size = res_APDU_size + 1;
}
driver_exec_finished_hid(finished_data_size);
}
}
#endif
}
usb_clear_rx(itf);
return 0;
}
uint8_t emul_rx[USB_BUFFER_SIZE];
uint16_t emul_rx_size = 0, emul_tx_size = 0;
uint16_t emul_read(uint8_t itf) { uint16_t emul_read(uint8_t itf) {
/* First we look for a client */ /* First we look for a client */
#ifdef USB_ITF_HID #ifdef USB_ITF_HID
@@ -359,8 +278,9 @@ uint16_t emul_read(uint8_t itf) {
len = ntohs(len); len = ntohs(len);
if (len > 0) { if (len > 0) {
while (true) { while (true) {
valread = recv(sock, (char *)usb_get_rx(itf), len, 0); valread = recv(sock, (char *)emul_rx, len, 0);
if (valread > 0) { if (valread > 0) {
emul_rx_size = valread;
return (uint16_t)valread; return (uint16_t)valread;
} }
msleep(10); msleep(10);

49
src/usb/emulation/emulation.h
View File

@@ -19,6 +19,55 @@
#define _EMULATION_H_ #define _EMULATION_H_
#include <stdint.h> #include <stdint.h>
#include <stdlib.h>
#include "usb.h"
#ifdef _MSC_VER
#include <windows.h>
#endif
extern int emul_init(char *host, uint16_t port); extern int emul_init(char *host, uint16_t port);
extern uint8_t emul_rx[USB_BUFFER_SIZE];
extern uint16_t emul_rx_size, emul_tx_size;
extern uint16_t driver_write_emul(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size);
extern uint16_t emul_read(uint8_t itf);
#ifdef USB_ITF_HID
typedef uint8_t hid_report_type_t;
#endif
#ifdef USB_ITF_CCID
static inline uint32_t tud_vendor_n_available(uint8_t itf) {
(void) itf;
return emul_rx_size;
}
static inline uint32_t tud_vendor_n_read(uint8_t itf, uint8_t *buffer, uint32_t n) {
(void) itf;
if (n > emul_rx_size) {
n = emul_rx_size;
}
memcpy(buffer, emul_rx, n);
emul_rx_size = 0;
return n;
}
extern void tud_vendor_tx_cb(uint8_t itf, uint32_t sent_bytes);
static inline uint32_t tud_vendor_n_write(uint8_t itf, const uint8_t *buffer, uint32_t n) {
uint16_t ret = driver_write_emul(ITF_CCID, buffer, (uint16_t)n);
tud_vendor_tx_cb(itf, ret);
return ret;
}
static inline uint32_t tud_vendor_n_flush(uint8_t itf) {
(void) itf;
return emul_tx_size;
}
#endif
#ifdef USB_ITF_HID
extern void tud_hid_report_complete_cb(uint8_t instance, uint8_t const *report, uint16_t len);
static inline bool tud_hid_n_report(uint8_t itf, uint8_t report_id, const uint8_t *buffer, uint32_t n) {
(void) itf;
(void) report_id;
uint16_t ret = driver_write_emul(ITF_HID, buffer, (uint16_t)n);
return ret > 0;
}
#endif
#endif // _EMULATION_H_ #endif // _EMULATION_H_

111
src/usb/hid/hid.c
View File

@@ -22,6 +22,8 @@
#else #else
static portMUX_TYPE mutex = portMUX_INITIALIZER_UNLOCKED; static portMUX_TYPE mutex = portMUX_INITIALIZER_UNLOCKED;
#endif #endif
#else
#include "emulation.h"
#endif #endif
#include "ctap_hid.h" #include "ctap_hid.h"
#include "pico_keys.h" #include "pico_keys.h"
@@ -95,18 +97,12 @@ uint16_t *get_send_buffer_size(uint8_t itf) {
// USB HID // USB HID
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
#ifndef ENABLE_EMULATION
uint16_t (*hid_get_report_cb)(uint8_t, uint8_t, hid_report_type_t, uint8_t *, uint16_t) = NULL; uint16_t (*hid_get_report_cb)(uint8_t, uint8_t, hid_report_type_t, uint8_t *, uint16_t) = NULL;
// Invoked when received GET_REPORT control request // Invoked when received GET_REPORT control request
// Application must fill buffer report's content and return its length. // Application must fill buffer report's content and return its length.
// Return zero will cause the stack to STALL request // Return zero will cause the stack to STALL request
uint16_t tud_hid_get_report_cb(uint8_t itf, uint16_t tud_hid_get_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t report_type, uint8_t *buffer, uint16_t reqlen) {
uint8_t report_id,
hid_report_type_t report_type,
uint8_t *buffer,
uint16_t reqlen) {
// TODO not Implemented // TODO not Implemented
(void) itf; (void) itf;
(void) report_id; (void) report_id;
@@ -120,7 +116,6 @@ uint16_t tud_hid_get_report_cb(uint8_t itf,
} }
return reqlen; return reqlen;
} }
#endif
uint32_t hid_write_offset(uint16_t size, uint16_t offset) { uint32_t hid_write_offset(uint16_t size, uint16_t offset) {
if (hid_tx[ITF_HID_CTAP].buffer[offset] != 0x81) { if (hid_tx[ITF_HID_CTAP].buffer[offset] != 0x81) {
@@ -201,45 +196,6 @@ static void send_hid_report(uint8_t report_id) {
default: break; default: break;
} }
} }
void hid_task() {
int proc_pkt = 0;
if (hid_rx[ITF_HID_CTAP].w_ptr - hid_rx[ITF_HID_CTAP].r_ptr >= 64) {
//proc_pkt = driver_process_usb_packet_hid(64);
}
if (proc_pkt == 0) {
driver_process_usb_nopacket_hid();
}
int status = card_status(ITF_HID);
if (status == CCID_OK) {
driver_exec_finished_hid(finished_data_size);
}
else if (status == CCID_ERR_BLOCKED) {
send_keepalive();
}
if (hid_tx[ITF_HID_CTAP].w_ptr > hid_tx[ITF_HID_CTAP].r_ptr && last_write_result[ITF_HID_CTAP] != WRITE_PENDING) {
if (driver_write_hid(ITF_HID_CTAP, hid_tx[ITF_HID_CTAP].buffer + hid_tx[ITF_HID_CTAP].r_ptr, 64) > 0) {
}
}
/* Keyboard ITF */
// Poll every 10ms
const uint32_t interval_ms = 10;
static uint32_t start_ms = 0;
if (board_millis() - start_ms < interval_ms) {
return;
}
start_ms += interval_ms;
// Remote wakeup
if (tud_suspended() && keyboard_buffer_len > 0) {
tud_remote_wakeup();
}
else {
send_hid_report(REPORT_ID_KEYBOARD);
}
}
#endif #endif
void tud_hid_report_complete_cb(uint8_t instance, uint8_t const *report, uint16_t len) { void tud_hid_report_complete_cb(uint8_t instance, uint8_t const *report, uint16_t len) {
@@ -284,7 +240,6 @@ void tud_hid_report_complete_cb(uint8_t instance, uint8_t const *report, uint16_
} }
} }
#ifndef ENABLE_EMULATION
int driver_write_hid(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size) { int driver_write_hid(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size) {
if (last_write_result[itf] == WRITE_PENDING) { if (last_write_result[itf] == WRITE_PENDING) {
return 0; return 0;
@@ -294,11 +249,11 @@ int driver_write_hid(uint8_t itf, const uint8_t *buffer, uint16_t buffer_size) {
if (last_write_result[itf] == WRITE_FAILED) { if (last_write_result[itf] == WRITE_FAILED) {
return 0; return 0;
} }
#ifdef ENABLE_EMULATION
tud_hid_report_complete_cb(ITF_HID, buffer, buffer_size);
#endif
return MIN(64, buffer_size); return MIN(64, buffer_size);
} }
#endif
#ifndef ENABLE_EMULATION
int (*hid_set_report_cb)(uint8_t, uint8_t, hid_report_type_t, uint8_t const *, uint16_t) = NULL; int (*hid_set_report_cb)(uint8_t, uint8_t, hid_report_type_t, uint8_t const *, uint16_t) = NULL;
// Invoked when received SET_REPORT control request or // Invoked when received SET_REPORT control request or
@@ -320,7 +275,6 @@ void tud_hid_set_report_cb(uint8_t itf, uint8_t report_id, hid_report_type_t rep
} }
} }
} }
#endif
uint32_t last_cmd_time = 0, last_packet_time = 0; uint32_t last_cmd_time = 0, last_packet_time = 0;
int ctap_error(uint8_t error) { int ctap_error(uint8_t error) {
@@ -523,9 +477,7 @@ int driver_process_usb_packet_hid(uint16_t read) {
else { else {
select_app(u2f_aid + 1, u2f_aid[0]); select_app(u2f_aid + 1, u2f_aid[0]);
} }
//if (thread_type != 1)
#ifndef ENABLE_EMULATION
#endif
thread_type = 1; thread_type = 1;
if (msg_packet.current_len == msg_packet.len && msg_packet.len > 0) { if (msg_packet.current_len == msg_packet.len && msg_packet.len > 0) {
@@ -571,6 +523,7 @@ int driver_process_usb_packet_hid(uint16_t read) {
// echo back anything we received from host // echo back anything we received from host
//tud_hid_report(0, buffer, bufsize); //tud_hid_report(0, buffer, bufsize);
//printf("END\n"); //printf("END\n");
#ifndef ENABLE_EMULATION
if (apdu_sent > 0) { if (apdu_sent > 0) {
if (apdu_sent == 1) { if (apdu_sent == 1) {
card_start(ITF_HID, apdu_thread); card_start(ITF_HID, apdu_thread);
@@ -580,6 +533,7 @@ int driver_process_usb_packet_hid(uint16_t read) {
} }
usb_send_event(EV_CMD_AVAILABLE); usb_send_event(EV_CMD_AVAILABLE);
} }
#endif
} }
return apdu_sent; return apdu_sent;
} }
@@ -625,3 +579,50 @@ void driver_exec_finished_cont_hid(uint8_t itf, uint16_t size_next, uint16_t off
//send_buffer_size[ITF_HID_CTAP] -= MIN(64 - 7, send_buffer_size[ITF_HID_CTAP]); //send_buffer_size[ITF_HID_CTAP] -= MIN(64 - 7, send_buffer_size[ITF_HID_CTAP]);
} }
} }
void hid_task() {
#ifdef ENABLE_EMULATION
uint16_t rx_len = emul_read(ITF_HID);
if (rx_len) {
tud_hid_set_report_cb(ITF_HID, 0, 0, emul_rx, rx_len);
}
#else
int proc_pkt = 0;
if (hid_rx[ITF_HID_CTAP].w_ptr - hid_rx[ITF_HID_CTAP].r_ptr >= 64) {
//proc_pkt = driver_process_usb_packet_hid(64);
}
if (proc_pkt == 0) {
driver_process_usb_nopacket_hid();
}
int status = card_status(ITF_HID);
if (status == CCID_OK) {
driver_exec_finished_hid(finished_data_size);
}
else if (status == CCID_ERR_BLOCKED) {
send_keepalive();
}
if (hid_tx[ITF_HID_CTAP].w_ptr > hid_tx[ITF_HID_CTAP].r_ptr && last_write_result[ITF_HID_CTAP] != WRITE_PENDING) {
if (driver_write_hid(ITF_HID_CTAP, hid_tx[ITF_HID_CTAP].buffer + hid_tx[ITF_HID_CTAP].r_ptr, 64) > 0) {
}
}
/* Keyboard ITF */
// Poll every 10ms
const uint32_t interval_ms = 10;
static uint32_t start_ms = 0;
if (board_millis() - start_ms < interval_ms) {
return;
}
start_ms += interval_ms;
// Remote wakeup
if (tud_suspended() && keyboard_buffer_len > 0) {
tud_remote_wakeup();
}
else {
send_hid_report(REPORT_ID_KEYBOARD);
}
#endif
}

1
src/usb/usb.h
View File

@@ -113,6 +113,7 @@ extern void driver_exec_finished_cont_emul(uint8_t itf, uint16_t size_next, uint
#endif #endif
#define USB_BUFFER_SIZE 2048 // Size of USB buffer" #define USB_BUFFER_SIZE 2048 // Size of USB buffer"
PACK( PACK(
typedef struct { typedef struct {
uint8_t buffer[USB_BUFFER_SIZE]; uint8_t buffer[USB_BUFFER_SIZE];