diff --git a/core/embed/ble_zephyr_fw/CMakeLists.txt b/core/embed/ble_zephyr_fw/CMakeLists.txt index bd2187f9b..64273c31d 100644 --- a/core/embed/ble_zephyr_fw/CMakeLists.txt +++ b/core/embed/ble_zephyr_fw/CMakeLists.txt @@ -15,9 +15,11 @@ target_sources(app PRIVATE src/main.c src/connection.c src/advertising.c + src/events.c src/uart.c src/spi.c src/int_comm.c + src/oob.c src/pb_comm.c src/trz_nus.c src/protob/messages.pb.c diff --git a/core/embed/ble_zephyr_fw/prj.conf b/core/embed/ble_zephyr_fw/prj.conf index 685acd23f..cc00decbe 100644 --- a/core/embed/ble_zephyr_fw/prj.conf +++ b/core/embed/ble_zephyr_fw/prj.conf @@ -21,6 +21,9 @@ CONFIG_GPIO=y CONFIG_HEAP_MEM_POOL_SIZE=2048 + + + CONFIG_BT=y CONFIG_BT_PERIPHERAL=y CONFIG_BT_DEVICE_NAME="TrezorZephyr" @@ -28,10 +31,14 @@ CONFIG_BT_DEVICE_APPEARANCE=833 CONFIG_BT_MAX_CONN=1 CONFIG_BT_MAX_PAIRED=8 CONFIG_BT_SMP=y +# CONFIG_BT_SMP_APP_PAIRING_ACCEPT=y +CONFIG_BT_SMP_ENFORCE_MITM=y CONFIG_BT_SMP_SC_ONLY=y CONFIG_BT_FILTER_ACCEPT_LIST=y +CONFIG_BT_BONDING_REQUIRED=y CONFIG_BT_PRIVACY=y -# CONFIG_BT_LL_SW_SPLIT=y +#CONFIG_BT_TINYCRYPT_ECC=y +#CONFIG_BT_LL_SW_SPLIT=y #PHY update needed for updating PHY request CONFIG_BT_USER_PHY_UPDATE=y @@ -57,10 +64,30 @@ CONFIG_DK_LIBRARY=y # This example requires more stack CONFIG_MAIN_STACK_SIZE=1152 -CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=2048 +CONFIG_SYSTEM_WORKQUEUE_STACK_SIZE=4096 + +# NFC +CONFIG_NFC_T4T_NRFXLIB=y + +CONFIG_NFC_NDEF=y +CONFIG_NFC_NDEF_MSG=y +CONFIG_NFC_NDEF_RECORD=y +CONFIG_NFC_NDEF_LE_OOB_REC=y +CONFIG_NFC_NDEF_CH_MSG=y + +CONFIG_NFC_NDEF_TNEP_RECORD=y +CONFIG_NFC_TNEP_TAG=y +CONFIG_NFC_NDEF_PARSER=y +CONFIG_NFC_NDEF_CH_PARSER=y +CONFIG_NFC_NDEF_LE_OOB_REC_PARSER=y +CONFIG_NFC_TNEP_CH=y + +CONFIG_POLL=y # Config logger CONFIG_LOG=y +CONFIG_RTT_CONSOLE=y +CONFIG_UART_CONSOLE=n CONFIG_USE_SEGGER_RTT=y CONFIG_LOG_BACKEND_RTT=y CONFIG_LOG_BACKEND_UART=n diff --git a/core/embed/ble_zephyr_fw/src/advertising.c b/core/embed/ble_zephyr_fw/src/advertising.c index 19a9909fd..697310ba5 100644 --- a/core/embed/ble_zephyr_fw/src/advertising.c +++ b/core/embed/ble_zephyr_fw/src/advertising.c @@ -9,6 +9,7 @@ #include "int_comm.h" #include "connection.h" +#include "oob.h" #define LOG_MODULE_NAME fw_int_advertising @@ -89,6 +90,10 @@ void advertising_start(bool wl){ } advertising = true; advertising_wl = wl; + + + oob_fetch_addr(); + send_status_event(); } diff --git a/core/embed/ble_zephyr_fw/src/connection.c b/core/embed/ble_zephyr_fw/src/connection.c index 89222c7b3..cd919a5a9 100644 --- a/core/embed/ble_zephyr_fw/src/connection.c +++ b/core/embed/ble_zephyr_fw/src/connection.c @@ -15,6 +15,7 @@ #include "advertising.h" #include "int_comm.h" #include "pb_comm.h" +#include "oob.h" #define CON_STATUS_LED DK_LED2 @@ -146,12 +147,17 @@ void auth_cancel(struct bt_conn *conn) } + void pairing_complete(struct bt_conn *conn, bool bonded) { char addr[BT_ADDR_LE_STR_LEN]; bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + oob_signal(); + bt_le_oob_set_sc_flag(false); + bt_le_oob_set_legacy_flag(false); + if (bonded) { advertising_setup_wl(); } @@ -166,5 +172,9 @@ void pairing_failed(struct bt_conn *conn, enum bt_security_err reason) bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); + oob_signal(); + bt_le_oob_set_sc_flag(false); + bt_le_oob_set_legacy_flag(false); + LOG_INF("Pairing failed conn: %s, reason %d", addr, reason); } diff --git a/core/embed/ble_zephyr_fw/src/events.c b/core/embed/ble_zephyr_fw/src/events.c new file mode 100644 index 000000000..4715477fc --- /dev/null +++ b/core/embed/ble_zephyr_fw/src/events.c @@ -0,0 +1,21 @@ + + + +#include + +#define K_POOL_EVENTS_CNT (4) + + +static struct k_poll_event events[K_POOL_EVENTS_CNT]; + +void events_poll(void){ + k_poll(events, ARRAY_SIZE(events), K_FOREVER); +} + +void events_init(void){ + +} + +struct k_poll_event * events_get(int idx){ + return &events[idx]; +} diff --git a/core/embed/ble_zephyr_fw/src/events.h b/core/embed/ble_zephyr_fw/src/events.h new file mode 100644 index 000000000..4fce19edf --- /dev/null +++ b/core/embed/ble_zephyr_fw/src/events.h @@ -0,0 +1,11 @@ + + +#include + +#define INT_COMM_EVENT_NUM 3 + +void events_poll(void); + +void events_init(void); + +struct k_poll_event * events_get(int idx); diff --git a/core/embed/ble_zephyr_fw/src/int_comm.c b/core/embed/ble_zephyr_fw/src/int_comm.c index 5f564a27f..a57be4b46 100644 --- a/core/embed/ble_zephyr_fw/src/int_comm.c +++ b/core/embed/ble_zephyr_fw/src/int_comm.c @@ -13,6 +13,7 @@ #include "connection.h" #include "advertising.h" #include "pb_comm.h" +#include "events.h" #define LOG_MODULE_NAME fw_int_comm LOG_MODULE_REGISTER(LOG_MODULE_NAME); @@ -111,16 +112,22 @@ void int_comm_start(void) void int_comm_thread(void) { /* Don't go any further until BLE is initialized */ - k_sem_take(&int_comm_ok, K_FOREVER); +// k_sem_take(&int_comm_ok, K_FOREVER); - for (;;) { - /* Wait indefinitely for data to process */ - uart_data_t *buf = uart_get_data_int(); +// for (;;) { - process_command(buf->data, buf->len); + if (events_get(INT_COMM_EVENT_NUM)->state == K_POLL_STATE_SIGNALED) { - k_free(buf); - } + uart_data_t *buf = uart_get_data_int(); + process_command(buf->data, buf->len); + k_free(buf); + + k_poll_signal_reset(events_get(INT_COMM_EVENT_NUM)->signal); + events_get(INT_COMM_EVENT_NUM)->state = K_POLL_STATE_NOT_READY; + } + + +// } } //K_THREAD_DEFINE(int_comm_thread_id, CONFIG_BT_NUS_THREAD_STACK_SIZE, int_comm_thread, NULL, NULL, diff --git a/core/embed/ble_zephyr_fw/src/main.c b/core/embed/ble_zephyr_fw/src/main.c index 6b52a11e5..a51789e74 100644 --- a/core/embed/ble_zephyr_fw/src/main.c +++ b/core/embed/ble_zephyr_fw/src/main.c @@ -20,6 +20,7 @@ #include #include #include +#include #include @@ -35,6 +36,8 @@ #include "pb_comm.h" #include "advertising.h" #include "trz_nus.h" +#include "oob.h" +#include "events.h" #define LOG_MODULE_NAME fw LOG_MODULE_REGISTER(LOG_MODULE_NAME); @@ -48,14 +51,10 @@ LOG_MODULE_REGISTER(LOG_MODULE_NAME); #define FW_RUNNING_SIG DK_LED3 -#define KEY_PASSKEY_ACCEPT DK_BTN1_MSK -#define KEY_PASSKEY_REJECT DK_BTN2_MSK - static K_SEM_DEFINE(ble_init_ok, 0, 1); static K_SEM_DEFINE(led_init_ok, 0, 1); - - +#define AUTH_SC_FLAG 0x08 static void security_changed(struct bt_conn *conn, bt_security_t level, @@ -79,10 +78,23 @@ BT_CONN_CB_DEFINE(conn_callbacks) = { .security_changed = security_changed, }; +//static enum bt_security_err pairing_accept(struct bt_conn *conn, +// const struct bt_conn_pairing_feat *const feat) +//{ +// if (feat->oob_data_flag && (!(feat->auth_req & AUTH_SC_FLAG))) { +// bt_le_oob_set_legacy_flag(true); +// } +// +// return BT_SECURITY_ERR_SUCCESS; +// +//} + static struct bt_conn_auth_cb conn_auth_callbacks = { +// .pairing_accept = pairing_accept, .passkey_display = auth_passkey_display, .passkey_confirm = auth_passkey_confirm, + .oob_data_request = auth_oob_data_request, .cancel = auth_cancel, }; @@ -194,15 +206,23 @@ int main(void) bt_set_name("TrezorGAP"); + events_init(); advertising_init(); int_comm_start(); pb_comm_start(); dk_set_led(FW_RUNNING_SIG, 1); send_status_event(); + oob_init(); + k_sem_give(&led_init_ok); for (;;) { + printk("Event occurred\n"); + + events_poll(); + + oob_process(); int_comm_thread(); } } @@ -240,6 +260,5 @@ void led_thread(void) K_THREAD_DEFINE(ble_write_thread_id, STACKSIZE, ble_write_thread, NULL, NULL, NULL, PRIORITY, 0, 0); - K_THREAD_DEFINE(led_thread_id, STACKSIZE, led_thread, NULL, NULL, NULL, PRIORITY, 0, 0); diff --git a/core/embed/ble_zephyr_fw/src/oob.c b/core/embed/ble_zephyr_fw/src/oob.c new file mode 100644 index 000000000..65e518759 --- /dev/null +++ b/core/embed/ble_zephyr_fw/src/oob.c @@ -0,0 +1,547 @@ + +#include + +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include + +#include +#include + +#include "events.h" + +#define NDEF_MSG_BUF_SIZE 256 +#define AUTH_SC_FLAG 0x08 + +//#define NFC_FIELD_LED DK_LED2 +//#define CON_STATUS_LED DK_LED1 +// +//#define KEY_BOND_REMOVE_MASK DK_BTN4_MSK + +#define NFC_NDEF_LE_OOB_REC_PARSER_BUFF_SIZE 150 +#define NFC_TNEP_BUFFER_SIZE 1024 + + +static struct bt_le_oob oob_local; +static struct k_work adv_work; +static uint8_t conn_cnt; +static uint8_t tk_value[NFC_NDEF_LE_OOB_REC_TK_LEN]; +static uint8_t remote_tk_value[NFC_NDEF_LE_OOB_REC_TK_LEN]; +static struct bt_le_oob oob_remote; + +/* Bonded address queue. */ +K_MSGQ_DEFINE(bonds_queue, +sizeof(bt_addr_le_t), +CONFIG_BT_MAX_PAIRED, +4); + +static struct k_poll_signal pair_signal; +static uint8_t tnep_buffer[NFC_TNEP_BUFFER_SIZE]; +static uint8_t tnep_swap_buffer[NFC_TNEP_BUFFER_SIZE]; +static bool use_remote_tk; +static bool adv_permission; + + + +static int tk_value_generate(void) +{ + int err; + + err = bt_rand(tk_value, sizeof(tk_value)); + if (err) { + printk("Random TK value generation failed: %d\n", err); + } + + return err; +} + +static void pair_key_generate_init(void) +{ + k_poll_signal_init(&pair_signal); + k_poll_event_init(events_get(NFC_TNEP_EVENTS_NUMBER), + K_POLL_TYPE_SIGNAL, K_POLL_MODE_NOTIFY_ONLY, + &pair_signal); +} + +static int paring_key_generate(void) +{ + int err; + + printk("Generating new pairing keys\n"); + + err = bt_le_oob_get_local(BT_ID_DEFAULT, &oob_local); + if (err) { + printk("Error while fetching local OOB data: %d\n", err); + } + + return tk_value_generate(); +} + +static void paring_key_process(void) +{ + int err; + + if (events_get(NFC_TNEP_EVENTS_NUMBER)->state == K_POLL_STATE_SIGNALED) { + err = paring_key_generate(); + if (err) { + printk("Pairing key generation error: %d\n", err); + } + + k_poll_signal_reset(events_get(NFC_TNEP_EVENTS_NUMBER)->signal); + events_get(NFC_TNEP_EVENTS_NUMBER)->state = K_POLL_STATE_NOT_READY; + } +} + +static void bond_find(const struct bt_bond_info *info, void *user_data) +{ + int err; + struct bt_conn *conn; + + /* Filter already connected peers. */ + conn = bt_conn_lookup_addr_le(BT_ID_DEFAULT, &info->addr); + if (conn) { + bt_conn_unref(conn); + return; + } + + err = k_msgq_put(&bonds_queue, (void *) &info->addr, K_NO_WAIT); + if (err) { + printk("No space in the queue for the bond\n"); + } +} + + +/** + * @brief Callback function for handling NFC events. + */ +static void nfc_callback(void *context, + nfc_t4t_event_t event, + const uint8_t *data, + size_t data_length, + uint32_t flags) +{ + ARG_UNUSED(context); + ARG_UNUSED(data); + ARG_UNUSED(flags); + + switch (event) { + case NFC_T4T_EVENT_FIELD_ON: + printk("NFC callback 1\n"); + nfc_tnep_tag_on_selected(); + //dk_set_led_on(NFC_FIELD_LED); + + //adv_permission = true; + + break; + + case NFC_T4T_EVENT_FIELD_OFF: + printk("NFC callback 2\n"); + nfc_tnep_tag_on_selected(); + //dk_set_led_off(NFC_FIELD_LED); + break; + + case NFC_T4T_EVENT_NDEF_READ: + printk("NFC callback 3\n"); +// if (adv_permission) { +// advertising_start(); +// adv_permission = false; +// } + + break; + + case NFC_T4T_EVENT_NDEF_UPDATED: + printk("NFC callback 4\n"); + if (data_length > 0) { + nfc_tnep_tag_rx_msg_indicate(nfc_t4t_ndef_file_msg_get(data), + data_length); + } + + default: + break; + } +} + + +/** .. include_startingpoint_pair_msg_rst */ +static int tnep_initial_msg_encode(struct nfc_ndef_msg_desc *msg) +{ + int err; + struct nfc_ndef_ch_msg_records ch_records; + static struct nfc_ndef_le_oob_rec_payload_desc rec_payload; + + + NFC_NDEF_LE_OOB_RECORD_DESC_DEF(oob_rec, '0', &rec_payload); + NFC_NDEF_CH_AC_RECORD_DESC_DEF(oob_ac, NFC_AC_CPS_ACTIVE, 1, "0", 0); + NFC_NDEF_CH_HS_RECORD_DESC_DEF(hs_rec, NFC_NDEF_CH_MSG_MAJOR_VER, + NFC_NDEF_CH_MSG_MINOR_VER, 1); + + memset(&rec_payload, 0, sizeof(rec_payload)); + + rec_payload.addr = &oob_local.addr; + rec_payload.le_sc_data = &oob_local.le_sc_data; + rec_payload.tk_value = tk_value; + rec_payload.local_name = bt_get_name(); + rec_payload.le_role = NFC_NDEF_LE_OOB_REC_LE_ROLE( + NFC_NDEF_LE_OOB_REC_LE_ROLE_PERIPH_ONLY); + rec_payload.appearance = NFC_NDEF_LE_OOB_REC_APPEARANCE( + CONFIG_BT_DEVICE_APPEARANCE); + rec_payload.flags = NFC_NDEF_LE_OOB_REC_FLAGS(BT_LE_AD_NO_BREDR); + + ch_records.ac = &NFC_NDEF_CH_AC_RECORD_DESC(oob_ac); + ch_records.carrier = &NFC_NDEF_LE_OOB_RECORD_DESC(oob_rec); + ch_records.cnt = 1; + + err = nfc_ndef_ch_msg_hs_create(msg, + &NFC_NDEF_CH_RECORD_DESC(hs_rec), + &ch_records); + + + printk("mac0: %X:%X:%X:%X:%X:%X\n", + rec_payload.addr->a.val[5], + rec_payload.addr->a.val[4], + rec_payload.addr->a.val[3], + rec_payload.addr->a.val[2], + rec_payload.addr->a.val[1], + rec_payload.addr->a.val[0]); + + if (err) { + return err; + } + + return nfc_tnep_initial_msg_encode(msg, NULL, 0); +} +/** .. include_endpoint_pair_msg_rst */ + +static int check_oob_carrier(const struct nfc_tnep_ch_record *ch_record, + const struct nfc_ndef_record_desc **oob_data) +{ + const struct nfc_ndef_ch_ac_rec *ac_rec = NULL; + + for (size_t i = 0; i < ch_record->count; i++) { + if (nfc_ndef_le_oob_rec_check(ch_record->carrier[i])) { + *oob_data = ch_record->carrier[i]; + } + } + + if (!oob_data) { + printk("Connection Handover Requester not supporting OOB BLE\n"); + return -EINVAL; + } + + /* Look for the corresponding Alternative Carrier Record. */ + for (size_t i = 0; i < ch_record->count; i++) { + if (((*oob_data)->id_length == ch_record->ac[i].carrier_data_ref.length) && + (memcmp((*oob_data)->id, + ch_record->ac[i].carrier_data_ref.data, + (*oob_data)->id_length) == 0)) { + ac_rec = &ch_record->ac[i]; + } + } + + if (!ac_rec) { + printk("No Alternative Carrier Record for OOB LE carrier\n"); + return -EINVAL; + } + + /* Check carrier state */ + if ((ac_rec->cps != NFC_AC_CPS_ACTIVE) && + (ac_rec->cps != NFC_AC_CPS_ACTIVATING)) { + printk("LE OBB Carrier inactive\n"); + return -EINVAL; + } + + return 0; +} + + +static void lesc_oob_data_set(struct bt_conn *conn, + struct bt_conn_oob_info *oob_info) +{ + int err; + char addr[BT_ADDR_LE_STR_LEN]; + struct bt_conn_info info; + + err = bt_conn_get_info(conn, &info); + if (err) { + return; + } + + struct bt_le_oob_sc_data *oob_data_local = + oob_info->lesc.oob_config != BT_CONN_OOB_REMOTE_ONLY + ? &oob_local.le_sc_data + : NULL; + struct bt_le_oob_sc_data *oob_data_remote = + oob_info->lesc.oob_config != BT_CONN_OOB_LOCAL_ONLY + ? &oob_remote.le_sc_data + : NULL; + + if (oob_data_remote && + bt_addr_le_cmp(info.le.remote, &oob_remote.addr)) { + bt_addr_le_to_str(info.le.remote, addr, sizeof(addr)); + printk("No OOB data available for remote %s", addr); + bt_conn_auth_cancel(conn); + return; + } + + if (oob_data_local && + bt_addr_le_cmp(info.le.local, &oob_local.addr)) { + bt_addr_le_to_str(info.le.local, addr, sizeof(addr)); + printk("No OOB data available for local %s", addr); + bt_conn_auth_cancel(conn); + return; + } + + err = bt_le_oob_set_sc_data(conn, oob_data_local, oob_data_remote); + if (err) { + printk("Error while setting OOB data: %d\n", err); + } +} + +//static void legacy_tk_value_set(struct bt_conn *conn) +//{ +// int err; +// const uint8_t *tk = use_remote_tk ? remote_tk_value : tk_value; +// +// err = bt_le_oob_set_legacy_tk(conn, tk); +// if (err) { +// printk("TK value set error: %d\n", err); +// } +// +// use_remote_tk = false; +//} + +void auth_oob_data_request(struct bt_conn *conn, + struct bt_conn_oob_info *info) +{ + printk("OOB data requested\n"); + + if (info->type == BT_CONN_OOB_LE_SC) { + printk("LESC OOB data requested\n"); + lesc_oob_data_set(conn, info); + } + +// if (info->type == BT_CONN_OOB_LE_LEGACY) { +// printk("Legacy TK value requested\n"); +// legacy_tk_value_set(conn); +// } +} + + +static int oob_le_data_handle(const struct nfc_ndef_record_desc *rec, + bool request) +{ + int err; + const struct nfc_ndef_le_oob_rec_payload_desc *oob; + uint8_t desc_buf[NFC_NDEF_LE_OOB_REC_PARSER_BUFF_SIZE]; + uint32_t desc_buf_len = sizeof(desc_buf); + + err = nfc_ndef_le_oob_rec_parse(rec, desc_buf, + &desc_buf_len); + if (err) { + printk("Error during NDEF LE OOB Record parsing, err: %d.\n", + err); + } + + oob = (struct nfc_ndef_le_oob_rec_payload_desc *) desc_buf; + + nfc_ndef_le_oob_rec_printout(oob); + + if ((*oob->le_role != NFC_NDEF_LE_OOB_REC_LE_ROLE_CENTRAL_ONLY) && + (*oob->le_role != NFC_NDEF_LE_OOB_REC_LE_ROLE_CENTRAL_PREFFERED)) { + printk("Unsupported Device LE Role\n"); + return -EINVAL; + } + + if (oob->le_sc_data) { + bt_le_oob_set_sc_flag(true); + oob_remote.le_sc_data = *oob->le_sc_data; + bt_addr_le_copy(&oob_remote.addr, oob->addr); + } + + if (oob->tk_value) { + bt_le_oob_set_legacy_flag(true); + memcpy(remote_tk_value, oob->tk_value, sizeof(remote_tk_value)); + use_remote_tk = request; + } + + //advertising_start(); + + return 0; +} + +/** .. include_startingpoint_nfc_tnep_ch_tag_rst */ +static int carrier_prepare(void) +{ + static struct nfc_ndef_le_oob_rec_payload_desc rec_payload; + + NFC_NDEF_LE_OOB_RECORD_DESC_DEF(oob_rec, '0', &rec_payload); + NFC_NDEF_CH_AC_RECORD_DESC_DEF(oob_ac, NFC_AC_CPS_ACTIVE, 1, "0", 0); + + memset(&rec_payload, 0, sizeof(rec_payload)); + + rec_payload.addr = &oob_local.addr; + rec_payload.le_sc_data = &oob_local.le_sc_data; + rec_payload.tk_value = tk_value; + rec_payload.local_name = bt_get_name(); + rec_payload.le_role = NFC_NDEF_LE_OOB_REC_LE_ROLE( + NFC_NDEF_LE_OOB_REC_LE_ROLE_PERIPH_ONLY); + rec_payload.appearance = NFC_NDEF_LE_OOB_REC_APPEARANCE( + CONFIG_BT_DEVICE_APPEARANCE); + rec_payload.flags = NFC_NDEF_LE_OOB_REC_FLAGS(BT_LE_AD_NO_BREDR); + + return nfc_tnep_ch_carrier_set(&NFC_NDEF_CH_AC_RECORD_DESC(oob_ac), + &NFC_NDEF_LE_OOB_RECORD_DESC(oob_rec), + 1); +} + +#if defined(CONFIG_NFC_TAG_CH_REQUESTER) +static int tnep_ch_request_prepare(void) +{ + bt_le_adv_stop(); + return carrier_prepare(); +} + +static int tnep_ch_select_received(const struct nfc_tnep_ch_record *ch_select, + bool inactive) +{ + int err; + const struct nfc_ndef_record_desc *oob_data = NULL; + + if (!ch_select->count) { + return -EINVAL; + } + + /* All alternative carrier are inactive */ + if (inactive) { + /* Try send request again. */ + return carrier_prepare(); + } + + err = check_oob_carrier(ch_select, &oob_data); + if (err) { + return err; + } + + err = oob_le_data_handle(oob_data, false); + if (err) { + return err; + } + + return 0; + +} +#endif /* defined(CONFIG_NFC_TAG_CH_REQUESTER) */ + +static int tnep_ch_request_received(const struct nfc_tnep_ch_request *ch_req) +{ + int err; + const struct nfc_ndef_record_desc *oob_data = NULL; + + if (!ch_req->ch_record.count) { + return -EINVAL; + } + + err = check_oob_carrier(&ch_req->ch_record, &oob_data); + if (err) { + return err; + } + + bt_le_adv_stop(); + + err = oob_le_data_handle(oob_data, true); + if (err) { + return err; + } + + return carrier_prepare(); +} + +static struct nfc_tnep_ch_cb ch_cb = { +#if defined(CONFIG_NFC_TAG_CH_REQUESTER) + .request_msg_prepare = tnep_ch_request_prepare, + .select_msg_recv = tnep_ch_select_received, +#endif + .request_msg_recv = tnep_ch_request_received +}; +/** .. include_endpoint_nfc_tnep_ch_tag_rst */ + +static void nfc_init(void) +{ + int err; + + /* TNEP init */ + err = nfc_tnep_tag_tx_msg_buffer_register(tnep_buffer, tnep_swap_buffer, + sizeof(tnep_buffer)); + if (err) { + printk("Cannot register tnep buffer, err: %d\n", err); + return; + } + + err = nfc_tnep_tag_init(events_get(0), NFC_TNEP_EVENTS_NUMBER, + nfc_t4t_ndef_rwpayload_set); + if (err) { + printk("Cannot initialize TNEP protocol, err: %d\n", err); + return; + } + + /* Set up NFC */ + err = nfc_t4t_setup(nfc_callback, NULL); + if (err) { + printk("Cannot setup NFC T4T library!\n"); + return; + } + + err = nfc_tnep_tag_initial_msg_create(2, tnep_initial_msg_encode); + if (err) { + printk("Cannot create initial TNEP message, err: %d\n", err); + } + + err = nfc_tnep_ch_service_init(&ch_cb); + if (err) { + printk("TNEP CH Service init error: %d\n", err); + return; + } + + /* Start sensing NFC field */ + err = nfc_t4t_emulation_start(); + if (err) { + printk("Cannot start emulation!\n"); + return; + } + + printk("NFC configuration done\n"); +} + + +void oob_init(void) { + paring_key_generate(); + pair_key_generate_init(); + nfc_init(); +} + +void oob_process(void) { + nfc_tnep_tag_process(); + paring_key_process(); +} + +//K_THREAD_DEFINE(oob_thread_id, CONFIG_BT_NUS_THREAD_STACK_SIZE, oob_thread, NULL, NULL, +// NULL, 7, 0, 0); + +void oob_signal(void) { + k_poll_signal_raise(&pair_signal, 0); +} + + +void oob_fetch_addr(void) { + bt_le_oob_get_local(BT_ID_DEFAULT, &oob_local); +} diff --git a/core/embed/ble_zephyr_fw/src/oob.h b/core/embed/ble_zephyr_fw/src/oob.h new file mode 100644 index 000000000..2672a79ce --- /dev/null +++ b/core/embed/ble_zephyr_fw/src/oob.h @@ -0,0 +1,16 @@ + + +#include +#include + +void auth_oob_data_request(struct bt_conn *conn, + struct bt_conn_oob_info *info); + + +void oob_init(void); + +void oob_signal(void); + +void oob_process(void); + +void oob_fetch_addr(void); diff --git a/core/embed/ble_zephyr_fw/src/uart.c b/core/embed/ble_zephyr_fw/src/uart.c index 2dcdb5c43..b4a0e5fd6 100644 --- a/core/embed/ble_zephyr_fw/src/uart.c +++ b/core/embed/ble_zephyr_fw/src/uart.c @@ -13,6 +13,7 @@ #include "uart.h" #include "int_comm.h" #include "int_comm_defs.h" +#include "events.h" #define LOG_MODULE_NAME fw_uart LOG_MODULE_REGISTER(LOG_MODULE_NAME); @@ -28,6 +29,9 @@ static K_FIFO_DEFINE(fifo_uart_rx_data_int); static K_FIFO_DEFINE(fifo_uart_rx_data_pb); +static struct k_poll_signal fifo_uart_rx_data_int_signal; + + static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data) { ARG_UNUSED(dev); @@ -199,6 +203,7 @@ static void uart_cb(const struct device *dev, struct uart_event *evt, void *user } else if (rx_msg_type == INTERNAL_EVENT) { k_fifo_put(&fifo_uart_rx_data_int, buf); + k_poll_signal_raise(&fifo_uart_rx_data_int_signal, 0); } else { k_fifo_put(&fifo_uart_rx_data_pb, buf); @@ -238,10 +243,17 @@ int uart_init(void) int err; uart_data_t *rx; + + if (!device_is_ready(uart)) { return -ENODEV; } + k_poll_signal_init(&fifo_uart_rx_data_int_signal); + k_poll_event_init(events_get(INT_COMM_EVENT_NUM), + K_POLL_TYPE_SIGNAL, K_POLL_MODE_NOTIFY_ONLY, + &fifo_uart_rx_data_int_signal); + struct uart_config cfg = { .baudrate = 1000000, .parity = UART_CFG_PARITY_NONE, @@ -291,7 +303,7 @@ uart_data_t *uart_get_data_ext(void) uart_data_t *uart_get_data_int(void) { - return k_fifo_get(&fifo_uart_rx_data_int, K_FOREVER); + return k_fifo_get(&fifo_uart_rx_data_int, K_NO_WAIT); } uart_data_t *uart_get_data_pb(void)