/******************************************************************************* ** ** Function rw_t4t_update_nlen ** ** Description Send UpdateBinary Command to update NLEN to peer ** ** Returns TRUE if success ** *******************************************************************************/ static BOOLEAN rw_t4t_update_nlen (UINT16 ndef_len) { BT_HDR *p_c_apdu; UINT8 *p; RW_TRACE_DEBUG1 ("rw_t4t_update_nlen () NLEN:%d", ndef_len); p_c_apdu = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID); if (!p_c_apdu) { RW_TRACE_ERROR0 ("rw_t4t_update_nlen (): Cannot allocate buffer"); return FALSE; } p_c_apdu->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; p = (UINT8 *) (p_c_apdu + 1) + p_c_apdu->offset; UINT8_TO_BE_STREAM (p, T4T_CMD_CLASS); UINT8_TO_BE_STREAM (p, T4T_CMD_INS_UPDATE_BINARY); UINT16_TO_BE_STREAM (p, 0x0000); /* offset for NLEN */ UINT8_TO_BE_STREAM (p, T4T_FILE_LENGTH_SIZE); UINT16_TO_BE_STREAM (p, ndef_len); p_c_apdu->len = T4T_CMD_MAX_HDR_SIZE + T4T_FILE_LENGTH_SIZE; if (!rw_t4t_send_to_lower (p_c_apdu)) { return FALSE; } return TRUE; }
/******************************************************************************* ** ** Function rw_main_log_stats ** ** Description Dump stats ** ** Returns void ** *******************************************************************************/ void rw_main_log_stats (void) { UINT32 ticks, elapsed_ms; ticks = GKI_get_tick_count () - rw_cb.stats.start_tick; elapsed_ms = GKI_TICKS_TO_MS (ticks); RW_TRACE_DEBUG5 ("NFC tx stats: cmds:%i, retries:%i, aborted: %i, tx_errs: %i, bytes sent:%i", rw_cb.stats.num_ops, rw_cb.stats.num_retries, rw_cb.stats.num_fail, rw_cb.stats.num_trans_err, rw_cb.stats.bytes_sent); RW_TRACE_DEBUG2 (" rx stats: rx-crc errors %i, bytes received: %i", rw_cb.stats.num_crc, rw_cb.stats.bytes_received); RW_TRACE_DEBUG1 (" time activated %i ms", elapsed_ms); }
/******************************************************************************* ** ** Function rw_t4t_select_application ** ** Description Select Application ** ** NDEF Tag Application Select - C-APDU ** ** CLA INS P1 P2 Lc Data(AID) Le ** V1.0: 00 A4 04 00 07 D2760000850100 - ** V2.0: 00 A4 04 00 07 D2760000850101 00 ** ** Returns TRUE if success ** *******************************************************************************/ static BOOLEAN rw_t4t_select_application (UINT8 version) { BT_HDR *p_c_apdu; UINT8 *p; RW_TRACE_DEBUG1 ("rw_t4t_select_application () version:0x%X", version); p_c_apdu = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID); if (!p_c_apdu) { RW_TRACE_ERROR0 ("rw_t4t_select_application (): Cannot allocate buffer"); return FALSE; } p_c_apdu->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; p = (UINT8 *) (p_c_apdu + 1) + p_c_apdu->offset; UINT8_TO_BE_STREAM (p, T4T_CMD_CLASS); UINT8_TO_BE_STREAM (p, T4T_CMD_INS_SELECT); UINT8_TO_BE_STREAM (p, T4T_CMD_P1_SELECT_BY_NAME); UINT8_TO_BE_STREAM (p, T4T_CMD_P2_FIRST_OR_ONLY_00H); if (version == T4T_VERSION_1_0) /* this is for V1.0 */ { UINT8_TO_BE_STREAM (p, T4T_V10_NDEF_TAG_AID_LEN); memcpy (p, t4t_v10_ndef_tag_aid, T4T_V10_NDEF_TAG_AID_LEN); p_c_apdu->len = T4T_CMD_MAX_HDR_SIZE + T4T_V10_NDEF_TAG_AID_LEN; } else if (version == T4T_VERSION_2_0) /* this is for V2.0 */ { UINT8_TO_BE_STREAM (p, T4T_V20_NDEF_TAG_AID_LEN); memcpy (p, t4t_v20_ndef_tag_aid, T4T_V20_NDEF_TAG_AID_LEN); p += T4T_V20_NDEF_TAG_AID_LEN; UINT8_TO_BE_STREAM (p, 0x00); /* Le set to 0x00 */ p_c_apdu->len = T4T_CMD_MAX_HDR_SIZE + T4T_V20_NDEF_TAG_AID_LEN + 1; } else { return FALSE; } if (!rw_t4t_send_to_lower (p_c_apdu)) { return FALSE; } return TRUE; }
/******************************************************************************* ** ** Function rw_t4t_process_timeout ** ** Description process timeout event ** ** Returns none ** *******************************************************************************/ void rw_t4t_process_timeout (TIMER_LIST_ENT *p_tle) { RW_TRACE_DEBUG1 ("rw_t4t_process_timeout () event=%d", p_tle->event); if (p_tle->event == NFC_TTYPE_RW_T4T_RESPONSE) { rw_t4t_handle_error (NFC_STATUS_TIMEOUT, 0, 0); } else { RW_TRACE_ERROR1 ("rw_t4t_process_timeout () unknown event=%d", p_tle->event); } }
/******************************************************************************* ** ** Function rw_t4t_select_file ** ** Description Send Select Command (by File ID) to peer ** ** Returns TRUE if success ** *******************************************************************************/ static BOOLEAN rw_t4t_select_file (UINT16 file_id) { BT_HDR *p_c_apdu; UINT8 *p; RW_TRACE_DEBUG1 ("rw_t4t_select_file (): File ID:0x%04X", file_id); p_c_apdu = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID); if (!p_c_apdu) { RW_TRACE_ERROR0 ("rw_t4t_select_file (): Cannot allocate buffer"); return FALSE; } p_c_apdu->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; p = (UINT8 *) (p_c_apdu + 1) + p_c_apdu->offset; UINT8_TO_BE_STREAM (p, T4T_CMD_CLASS); UINT8_TO_BE_STREAM (p, T4T_CMD_INS_SELECT); UINT8_TO_BE_STREAM (p, T4T_CMD_P1_SELECT_BY_FILE_ID); /* if current version mapping is V2.0 */ if (rw_cb.tcb.t4t.version == T4T_VERSION_2_0) { UINT8_TO_BE_STREAM (p, T4T_CMD_P2_FIRST_OR_ONLY_0CH); } else /* version 1.0 */ { UINT8_TO_BE_STREAM (p, T4T_CMD_P2_FIRST_OR_ONLY_00H); } UINT8_TO_BE_STREAM (p, T4T_FILE_ID_SIZE); UINT16_TO_BE_STREAM (p, file_id); p_c_apdu->len = T4T_CMD_MAX_HDR_SIZE + T4T_FILE_ID_SIZE; if (!rw_t4t_send_to_lower (p_c_apdu)) { return FALSE; } return TRUE; }
/******************************************************************************* ** ** Function rw_t2t_process_error ** ** Description Process error including Timeout, Frame error. This function ** will retry atleast till RW_MAX_RETRIES before give up and ** sending negative notification to upper layer ** ** Returns none ** *******************************************************************************/ static void rw_t2t_process_error (void) { tRW_READ_DATA evt_data; tRW_EVENT rw_event; BT_HDR *p_cmd_buf; tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; tT2T_CMD_RSP_INFO *p_cmd_rsp_info = (tT2T_CMD_RSP_INFO *) rw_cb.tcb.t2t.p_cmd_rsp_info; tRW_DETECT_NDEF_DATA ndef_data; RW_TRACE_DEBUG1 ("rw_t2t_process_error () State: %u", p_t2t->state); /* Retry sending command if retry-count < max */ if ( (!p_t2t->check_tag_halt) &&(rw_cb.cur_retry < RW_MAX_RETRIES) ) { /* retry sending the command */ rw_cb.cur_retry++; RW_TRACE_DEBUG2 ("T2T retransmission attempt %i of %i", rw_cb.cur_retry, RW_MAX_RETRIES); /* allocate a new buffer for message */ if ((p_cmd_buf = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID)) != NULL) { memcpy (p_cmd_buf, p_t2t->p_cur_cmd_buf, sizeof (BT_HDR) + p_t2t->p_cur_cmd_buf->offset + p_t2t->p_cur_cmd_buf->len); #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) /* Update stats */ rw_main_update_tx_stats (p_cmd_buf->len, TRUE); #endif if (NFC_SendData (NFC_RF_CONN_ID, p_cmd_buf) == NFC_STATUS_OK) { /* Start timer for waiting for response */ nfc_start_quick_timer (&p_t2t->t2_timer, NFC_TTYPE_RW_T2T_RESPONSE, (RW_T2T_TOUT_RESP * QUICK_TIMER_TICKS_PER_SEC) / 1000); return; } } } else { if (p_t2t->check_tag_halt) { RW_TRACE_DEBUG0 ("T2T Went to HALT State!"); } else { RW_TRACE_DEBUG1 ("T2T maximum retransmission attempts reached (%i)", RW_MAX_RETRIES); } } rw_event = rw_t2t_info_to_event (p_cmd_rsp_info); #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) /* update failure count */ rw_main_update_fail_stats (); #endif if (p_t2t->check_tag_halt) { evt_data.status = NFC_STATUS_REJECTED; p_t2t->state = RW_T2T_STATE_HALT; } else { evt_data.status = NFC_STATUS_TIMEOUT; } if (rw_event == RW_T2T_NDEF_DETECT_EVT) { ndef_data.status = evt_data.status; ndef_data.protocol = NFC_PROTOCOL_T2T; ndef_data.flags = RW_NDEF_FL_UNKNOWN; if (p_t2t->substate == RW_T2T_SUBSTATE_WAIT_READ_LOCKS) ndef_data.flags = RW_NDEF_FL_FORMATED; ndef_data.max_size = 0; ndef_data.cur_size = 0; /* If not Halt move to idle state */ rw_t2t_handle_op_complete (); (*rw_cb.p_cback) (rw_event, (tRW_DATA *) &ndef_data); } else { evt_data.p_data = NULL; /* If activated and not Halt move to idle state */ if (p_t2t->state != RW_T2T_STATE_NOT_ACTIVATED) rw_t2t_handle_op_complete (); p_t2t->substate = RW_T2T_SUBSTATE_NONE; (*rw_cb.p_cback) (rw_event, (tRW_DATA *) &evt_data); } }
/******************************************************************************* ** ** Function rw_t1t_data_cback ** ** Description This callback function handles data from NFCC. ** ** Returns none ** *******************************************************************************/ static void rw_t1t_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data) { tRW_T1T_CB *p_t1t = &rw_cb.tcb.t1t; tRW_EVENT rw_event = RW_RAW_FRAME_EVT; BOOLEAN b_notify = TRUE; tRW_DATA evt_data; BT_HDR *p_pkt; UINT8 *p; tT1T_CMD_RSP_INFO *p_cmd_rsp_info = (tT1T_CMD_RSP_INFO *) rw_cb.tcb.t1t.p_cmd_rsp_info; #if (BT_TRACE_VERBOSE == TRUE) UINT8 begin_state = p_t1t->state; #endif p_pkt = (BT_HDR *) (p_data->data.p_data); if (p_pkt == NULL) return; /* Assume the data is just the response byte sequence */ p = (UINT8 *) (p_pkt + 1) + p_pkt->offset; #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_DEBUG2 ("rw_t1t_data_cback (): state:%s (%d)", rw_t1t_get_state_name (p_t1t->state), p_t1t->state); #else RW_TRACE_DEBUG1 ("rw_t1t_data_cback (): state=%d", p_t1t->state); #endif evt_data.status = NFC_STATUS_OK; if( (p_t1t->state == RW_T1T_STATE_IDLE) ||(!p_cmd_rsp_info) ) { /* If previous command was retransmitted and if response is pending to previous command retransmission, * check if lenght and ADD/ADD8/ADDS field matches the expected value of previous * retransmited command response. However, ignore ADD field if the command was RALL/RID */ if ( (p_t1t->prev_cmd_rsp_info.pend_retx_rsp) &&(p_t1t->prev_cmd_rsp_info.rsp_len == p_pkt->len) &&((p_t1t->prev_cmd_rsp_info.op_code == T1T_CMD_RID) || (p_t1t->prev_cmd_rsp_info.op_code == T1T_CMD_RALL) || (p_t1t->prev_cmd_rsp_info.addr == *p)) ) { /* Response to previous command retransmission */ RW_TRACE_ERROR2 ("T1T Response to previous command in Idle state. command=0x%02x, Remaining max retx rsp:0x%02x ", p_t1t->prev_cmd_rsp_info.op_code, p_t1t->prev_cmd_rsp_info.pend_retx_rsp - 1); p_t1t->prev_cmd_rsp_info.pend_retx_rsp--; GKI_freebuf (p_pkt); } else { /* Raw frame event */ evt_data.data.p_data = p_pkt; (*rw_cb.p_cback) (RW_T1T_RAW_FRAME_EVT, (tRW_DATA *) &evt_data); } return; } #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) /* Update rx stats */ rw_main_update_rx_stats (p_pkt->len); #endif /* RW_STATS_INCLUDED */ if ( (p_pkt->len != p_cmd_rsp_info->rsp_len) ||((p_cmd_rsp_info->opcode != T1T_CMD_RALL) && (p_cmd_rsp_info->opcode != T1T_CMD_RID) && (*p != p_t1t->addr)) ) { /* If previous command was retransmitted and if response is pending to previous command retransmission, * then check if lenght and ADD/ADD8/ADDS field matches the expected value of previous * retransmited command response. However, ignore ADD field if the command was RALL/RID */ if ( (p_t1t->prev_cmd_rsp_info.pend_retx_rsp) &&(p_t1t->prev_cmd_rsp_info.rsp_len == p_pkt->len) &&((p_t1t->prev_cmd_rsp_info.op_code == T1T_CMD_RID) || (p_t1t->prev_cmd_rsp_info.op_code == T1T_CMD_RALL) || (p_t1t->prev_cmd_rsp_info.addr == *p)) ) { RW_TRACE_ERROR2 ("T1T Response to previous command. command=0x%02x, Remaining max retx rsp:0x%02x", p_t1t->prev_cmd_rsp_info.op_code, p_t1t->prev_cmd_rsp_info.pend_retx_rsp - 1); p_t1t->prev_cmd_rsp_info.pend_retx_rsp--; } else { /* Stop timer as some response to current command is received */ nfc_stop_quick_timer (&p_t1t->timer); /* Retrasmit the last sent command if retry-count < max retry */ #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_ERROR2 ("T1T Frame error. state=%s command (opcode) = 0x%02x", rw_t1t_get_state_name (p_t1t->state), p_cmd_rsp_info->opcode); #else RW_TRACE_ERROR2 ("T1T Frame error. state=0x%02x command = 0x%02x ", p_t1t->state, p_cmd_rsp_info->opcode); #endif rw_t1t_process_frame_error (); } GKI_freebuf (p_pkt); return; } /* Stop timer as response to current command is received */ nfc_stop_quick_timer (&p_t1t->timer); RW_TRACE_EVENT2 ("RW RECV [%s]:0x%x RSP", t1t_info_to_str (p_cmd_rsp_info), p_cmd_rsp_info->opcode); /* If we did not receive response to all retransmitted previous command, * dont expect that as response have come for the current command itself. */ if (p_t1t->prev_cmd_rsp_info.pend_retx_rsp) memset (&(p_t1t->prev_cmd_rsp_info), 0, sizeof (tRW_T1T_PREV_CMD_RSP_INFO)); if (rw_cb.cur_retry) { /* If the current command was retransmitted to get this response, we might get response later to all or some of the retrasnmission of the current command */ p_t1t->prev_cmd_rsp_info.addr = ((p_cmd_rsp_info->opcode != T1T_CMD_RALL) && (p_cmd_rsp_info->opcode != T1T_CMD_RID))? p_t1t->addr:0; p_t1t->prev_cmd_rsp_info.rsp_len = p_cmd_rsp_info->rsp_len; p_t1t->prev_cmd_rsp_info.op_code = p_cmd_rsp_info->opcode; p_t1t->prev_cmd_rsp_info.pend_retx_rsp = (UINT8) rw_cb.cur_retry; } rw_cb.cur_retry = 0; if (p_cmd_rsp_info->opcode == T1T_CMD_RID) { rw_event = rw_t1t_handle_rid_rsp (p_pkt); } else { rw_event = rw_t1t_handle_rsp (p_cmd_rsp_info, &b_notify, p, &evt_data.status); } if (b_notify) { if( (p_t1t->state != RW_T1T_STATE_READ) &&(p_t1t->state != RW_T1T_STATE_WRITE) ) { GKI_freebuf (p_pkt); evt_data.data.p_data = NULL; } else { evt_data.data.p_data = p_pkt; } rw_t1t_handle_op_complete (); (*rw_cb.p_cback) (rw_event, (tRW_DATA *) &evt_data); } else GKI_freebuf (p_pkt); #if (BT_TRACE_VERBOSE == TRUE) if (begin_state != p_t1t->state) { RW_TRACE_DEBUG2 ("RW T1T state changed:<%s> -> <%s>", rw_t1t_get_state_name (begin_state), rw_t1t_get_state_name (p_t1t->state)); } #endif }
/******************************************************************************* ** ** Function rw_t1t_process_error ** ** Description process timeout event ** ** Returns none ** *******************************************************************************/ static void rw_t1t_process_error (void) { tRW_READ_DATA evt_data; tRW_EVENT rw_event; BT_HDR *p_cmd_buf; tRW_T1T_CB *p_t1t = &rw_cb.tcb.t1t; tT1T_CMD_RSP_INFO *p_cmd_rsp_info = (tT1T_CMD_RSP_INFO *) rw_cb.tcb.t1t.p_cmd_rsp_info; tRW_DETECT_NDEF_DATA ndef_data; RW_TRACE_DEBUG1 ("rw_t1t_process_error () State: %u", p_t1t->state); /* Retry sending command if retry-count < max */ if (rw_cb.cur_retry < RW_MAX_RETRIES) { /* retry sending the command */ rw_cb.cur_retry++; RW_TRACE_DEBUG2 ("T1T retransmission attempt %i of %i", rw_cb.cur_retry, RW_MAX_RETRIES); /* allocate a new buffer for message */ if ((p_cmd_buf = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID)) != NULL) { memcpy (p_cmd_buf, p_t1t->p_cur_cmd_buf, sizeof (BT_HDR) + p_t1t->p_cur_cmd_buf->offset + p_t1t->p_cur_cmd_buf->len); #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) /* Update stats */ rw_main_update_tx_stats (p_cmd_buf->len, TRUE); #endif /* RW_STATS_INCLUDED */ if (NFC_SendData (NFC_RF_CONN_ID, p_cmd_buf) == NFC_STATUS_OK) { /* Start timer for waiting for response */ nfc_start_quick_timer (&p_t1t->timer, NFC_TTYPE_RW_T1T_RESPONSE, (RW_T1T_TOUT_RESP * QUICK_TIMER_TICKS_PER_SEC)/1000); return; } } } else { /* we might get response later to all or some of the retrasnmission * of the current command, update previous command response information */ RW_TRACE_DEBUG1 ("T1T maximum retransmission attempts reached (%i)", RW_MAX_RETRIES); p_t1t->prev_cmd_rsp_info.addr = ((p_cmd_rsp_info->opcode != T1T_CMD_RALL) && (p_cmd_rsp_info->opcode != T1T_CMD_RID))? p_t1t->addr:0; p_t1t->prev_cmd_rsp_info.rsp_len = p_cmd_rsp_info->rsp_len; p_t1t->prev_cmd_rsp_info.op_code = p_cmd_rsp_info->opcode; p_t1t->prev_cmd_rsp_info.pend_retx_rsp = RW_MAX_RETRIES; } #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) /* update failure count */ rw_main_update_fail_stats (); #endif /* RW_STATS_INCLUDED */ rw_event = rw_t1t_info_to_event (p_cmd_rsp_info); if (p_t1t->state != RW_T1T_STATE_NOT_ACTIVATED) rw_t1t_handle_op_complete (); evt_data.status = NFC_STATUS_TIMEOUT; if (rw_event == RW_T2T_NDEF_DETECT_EVT) { ndef_data.status = evt_data.status; ndef_data.protocol = NFC_PROTOCOL_T1T; ndef_data.flags = RW_NDEF_FL_UNKNOWN; ndef_data.max_size = 0; ndef_data.cur_size = 0; (*rw_cb.p_cback) (rw_event, (tRW_DATA *) &ndef_data); } else { evt_data.p_data = NULL; (*rw_cb.p_cback) (rw_event, (tRW_DATA *) &evt_data); } }
/******************************************************************************* ** ** Function rw_t4t_sm_update_ndef ** ** Description State machine for NDEF update procedure ** ** Returns none ** *******************************************************************************/ static void rw_t4t_sm_update_ndef (BT_HDR *p_r_apdu) { tRW_T4T_CB *p_t4t = &rw_cb.tcb.t4t; UINT8 *p; UINT16 status_words; tRW_DATA rw_data; #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_DEBUG2 ("rw_t4t_sm_update_ndef (): sub_state:%s (%d)", rw_t4t_get_sub_state_name (p_t4t->sub_state), p_t4t->sub_state); #else RW_TRACE_DEBUG1 ("rw_t4t_sm_update_ndef (): sub_state=%d", p_t4t->sub_state); #endif /* Get status words */ p = (UINT8 *) (p_r_apdu + 1) + p_r_apdu->offset; p += (p_r_apdu->len - T4T_RSP_STATUS_WORDS_SIZE); BE_STREAM_TO_UINT16 (status_words, p); if (status_words != T4T_RSP_CMD_CMPLTED) { rw_t4t_handle_error (NFC_STATUS_CMD_NOT_CMPLTD, *(p-2), *(p-1)); return; } switch (p_t4t->sub_state) { case RW_T4T_SUBSTATE_WAIT_UPDATE_NLEN: /* NLEN has been updated */ /* if need to update data */ if (p_t4t->p_update_data) { p_t4t->sub_state = RW_T4T_SUBSTATE_WAIT_UPDATE_RESP; if (!rw_t4t_update_file ()) { rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); p_t4t->p_update_data = NULL; } } else { p_t4t->state = RW_T4T_STATE_IDLE; /* just finished last step of updating (updating NLEN) */ if (rw_cb.p_cback) { rw_data.status = NFC_STATUS_OK; (*(rw_cb.p_cback)) (RW_T4T_NDEF_UPDATE_CPLT_EVT, &rw_data); RW_TRACE_DEBUG0 ("rw_t4t_sm_update_ndef (): Sent RW_T4T_NDEF_UPDATE_CPLT_EVT"); } } break; case RW_T4T_SUBSTATE_WAIT_UPDATE_RESP: /* if updating is not completed */ if (p_t4t->rw_length > 0) { if (!rw_t4t_update_file ()) { rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); p_t4t->p_update_data = NULL; } } else { p_t4t->p_update_data = NULL; /* update NLEN as last step of updating file */ if (!rw_t4t_update_nlen (p_t4t->ndef_length)) { rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); } else { p_t4t->sub_state = RW_T4T_SUBSTATE_WAIT_UPDATE_NLEN; } } break; default: RW_TRACE_ERROR1 ("rw_t4t_sm_update_ndef (): unknown sub_state = %d", p_t4t->sub_state); rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); break; } }
/******************************************************************************* ** ** Function rw_t4t_sm_read_ndef ** ** Description State machine for NDEF read procedure ** ** Returns none ** *******************************************************************************/ static void rw_t4t_sm_read_ndef (BT_HDR *p_r_apdu) { tRW_T4T_CB *p_t4t = &rw_cb.tcb.t4t; UINT8 *p; UINT16 status_words; tRW_DATA rw_data; #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_DEBUG2 ("rw_t4t_sm_read_ndef (): sub_state:%s (%d)", rw_t4t_get_sub_state_name (p_t4t->sub_state), p_t4t->sub_state); #else RW_TRACE_DEBUG1 ("rw_t4t_sm_read_ndef (): sub_state=%d", p_t4t->sub_state); #endif /* get status words */ p = (UINT8 *) (p_r_apdu + 1) + p_r_apdu->offset; p += (p_r_apdu->len - T4T_RSP_STATUS_WORDS_SIZE); BE_STREAM_TO_UINT16 (status_words, p); if (status_words != T4T_RSP_CMD_CMPLTED) { rw_t4t_handle_error (NFC_STATUS_CMD_NOT_CMPLTD, *(p-2), *(p-1)); GKI_freebuf (p_r_apdu); return; } switch (p_t4t->sub_state) { case RW_T4T_SUBSTATE_WAIT_READ_RESP: /* Read partial or complete data */ p_r_apdu->len -= T4T_RSP_STATUS_WORDS_SIZE; if ((p_r_apdu->len > 0) && (p_r_apdu->len <= p_t4t->rw_length)) { p_t4t->rw_length -= p_r_apdu->len; p_t4t->rw_offset += p_r_apdu->len; if (rw_cb.p_cback) { rw_data.data.status = NFC_STATUS_OK; rw_data.data.p_data = p_r_apdu; /* if need to read more data */ if (p_t4t->rw_length > 0) { (*(rw_cb.p_cback)) (RW_T4T_NDEF_READ_EVT, &rw_data); if (!rw_t4t_read_file (p_t4t->rw_offset, p_t4t->rw_length, TRUE)) { rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); } } else { p_t4t->state = RW_T4T_STATE_IDLE; (*(rw_cb.p_cback)) (RW_T4T_NDEF_READ_CPLT_EVT, &rw_data); RW_TRACE_DEBUG0 ("rw_t4t_sm_read_ndef (): Sent RW_T4T_NDEF_READ_CPLT_EVT"); } p_r_apdu = NULL; } else { p_t4t->rw_length = 0; p_t4t->state = RW_T4T_STATE_IDLE; } } else { RW_TRACE_ERROR2 ("rw_t4t_sm_read_ndef (): invalid payload length (%d), rw_length (%d)", p_r_apdu->len, p_t4t->rw_length); rw_t4t_handle_error (NFC_STATUS_BAD_RESP, 0, 0); } break; default: RW_TRACE_ERROR1 ("rw_t4t_sm_read_ndef (): unknown sub_state = %d", p_t4t->sub_state); rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); break; } if (p_r_apdu) GKI_freebuf (p_r_apdu); }
/******************************************************************************* ** ** Function rw_t4t_sm_detect_ndef ** ** Description State machine for NDEF detection procedure ** ** Returns none ** *******************************************************************************/ static void rw_t4t_sm_detect_ndef (BT_HDR *p_r_apdu) { tRW_T4T_CB *p_t4t = &rw_cb.tcb.t4t; UINT8 *p, type, length; UINT16 status_words, nlen; tRW_DATA rw_data; #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_DEBUG2 ("rw_t4t_sm_detect_ndef (): sub_state:%s (%d)", rw_t4t_get_sub_state_name (p_t4t->sub_state), p_t4t->sub_state); #else RW_TRACE_DEBUG1 ("rw_t4t_sm_detect_ndef (): sub_state=%d", p_t4t->sub_state); #endif /* get status words */ p = (UINT8 *) (p_r_apdu + 1) + p_r_apdu->offset; p += (p_r_apdu->len - T4T_RSP_STATUS_WORDS_SIZE); BE_STREAM_TO_UINT16 (status_words, p); if (status_words != T4T_RSP_CMD_CMPLTED) { /* try V1.0 after failing of V2.0 */ if ( (p_t4t->sub_state == RW_T4T_SUBSTATE_WAIT_SELECT_APP) &&(p_t4t->version == T4T_VERSION_2_0) ) { p_t4t->version = T4T_VERSION_1_0; RW_TRACE_DEBUG1 ("rw_t4t_sm_detect_ndef (): retry with version=0x%02X", p_t4t->version); if (!rw_t4t_select_application (T4T_VERSION_1_0)) { rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); } return; } p_t4t->ndef_status &= ~ (RW_T4T_NDEF_STATUS_NDEF_DETECTED); rw_t4t_handle_error (NFC_STATUS_CMD_NOT_CMPLTD, *(p-2), *(p-1)); return; } switch (p_t4t->sub_state) { case RW_T4T_SUBSTATE_WAIT_SELECT_APP: /* NDEF Tag application has been selected then select CC file */ if (!rw_t4t_select_file (T4T_CC_FILE_ID)) { rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); } else { p_t4t->sub_state = RW_T4T_SUBSTATE_WAIT_SELECT_CC; } break; case RW_T4T_SUBSTATE_WAIT_SELECT_CC: /* CC file has been selected then read mandatory part of CC file */ if (!rw_t4t_read_file (0x00, T4T_CC_FILE_MIN_LEN, FALSE)) { rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); } else { p_t4t->sub_state = RW_T4T_SUBSTATE_WAIT_CC_FILE; } break; case RW_T4T_SUBSTATE_WAIT_CC_FILE: /* CC file has been read then validate and select mandatory NDEF file */ if (p_r_apdu->len >= T4T_CC_FILE_MIN_LEN + T4T_RSP_STATUS_WORDS_SIZE) { p = (UINT8 *) (p_r_apdu + 1) + p_r_apdu->offset; BE_STREAM_TO_UINT16 (p_t4t->cc_file.cclen, p); BE_STREAM_TO_UINT8 (p_t4t->cc_file.version, p); BE_STREAM_TO_UINT16 (p_t4t->cc_file.max_le, p); BE_STREAM_TO_UINT16 (p_t4t->cc_file.max_lc, p); BE_STREAM_TO_UINT8 (type, p); BE_STREAM_TO_UINT8 (length, p); if ( (type == T4T_NDEF_FILE_CONTROL_TYPE) &&(length == T4T_FILE_CONTROL_LENGTH) ) { BE_STREAM_TO_UINT16 (p_t4t->cc_file.ndef_fc.file_id, p); BE_STREAM_TO_UINT16 (p_t4t->cc_file.ndef_fc.max_file_size, p); BE_STREAM_TO_UINT8 (p_t4t->cc_file.ndef_fc.read_access, p); BE_STREAM_TO_UINT8 (p_t4t->cc_file.ndef_fc.write_access, p); #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_DEBUG0 ("Capability Container (CC) file"); RW_TRACE_DEBUG1 (" CCLEN: 0x%04X", p_t4t->cc_file.cclen); RW_TRACE_DEBUG1 (" Version:0x%02X", p_t4t->cc_file.version); RW_TRACE_DEBUG1 (" MaxLe: 0x%04X", p_t4t->cc_file.max_le); RW_TRACE_DEBUG1 (" MaxLc: 0x%04X", p_t4t->cc_file.max_lc); RW_TRACE_DEBUG0 (" NDEF File Control TLV"); RW_TRACE_DEBUG1 (" FileID: 0x%04X", p_t4t->cc_file.ndef_fc.file_id); RW_TRACE_DEBUG1 (" MaxFileSize: 0x%04X", p_t4t->cc_file.ndef_fc.max_file_size); RW_TRACE_DEBUG1 (" ReadAccess: 0x%02X", p_t4t->cc_file.ndef_fc.read_access); RW_TRACE_DEBUG1 (" WriteAccess: 0x%02X", p_t4t->cc_file.ndef_fc.write_access); #endif if (rw_t4t_validate_cc_file ()) { if (!rw_t4t_select_file (p_t4t->cc_file.ndef_fc.file_id)) { rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); } else { p_t4t->sub_state = RW_T4T_SUBSTATE_WAIT_SELECT_NDEF_FILE; } break; } } } /* invalid response or CC file */ p_t4t->ndef_status &= ~ (RW_T4T_NDEF_STATUS_NDEF_DETECTED); rw_t4t_handle_error (NFC_STATUS_BAD_RESP, 0, 0); break; case RW_T4T_SUBSTATE_WAIT_SELECT_NDEF_FILE: /* NDEF file has been selected then read the first 2 bytes (NLEN) */ if (!rw_t4t_read_file (0, T4T_FILE_LENGTH_SIZE, FALSE)) { rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); } else { p_t4t->sub_state = RW_T4T_SUBSTATE_WAIT_READ_NLEN; } break; case RW_T4T_SUBSTATE_WAIT_READ_NLEN: /* NLEN has been read then report upper layer */ if (p_r_apdu->len == T4T_FILE_LENGTH_SIZE + T4T_RSP_STATUS_WORDS_SIZE) { /* get length of NDEF */ p = (UINT8 *) (p_r_apdu + 1) + p_r_apdu->offset; BE_STREAM_TO_UINT16 (nlen, p); if (nlen <= p_t4t->cc_file.ndef_fc.max_file_size - T4T_FILE_LENGTH_SIZE) { p_t4t->ndef_status = RW_T4T_NDEF_STATUS_NDEF_DETECTED; if (p_t4t->cc_file.ndef_fc.write_access != T4T_FC_WRITE_ACCESS) { p_t4t->ndef_status |= RW_T4T_NDEF_STATUS_NDEF_READ_ONLY; } /* Get max bytes to read per command */ if (p_t4t->cc_file.max_le >= RW_T4T_MAX_DATA_PER_READ) { p_t4t->max_read_size = RW_T4T_MAX_DATA_PER_READ; } else { p_t4t->max_read_size = p_t4t->cc_file.max_le; } /* Le: valid range is 0x01 to 0xFF */ if (p_t4t->max_read_size >= T4T_MAX_LENGTH_LE) { p_t4t->max_read_size = T4T_MAX_LENGTH_LE; } /* Get max bytes to update per command */ if (p_t4t->cc_file.max_lc >= RW_T4T_MAX_DATA_PER_WRITE) { p_t4t->max_update_size = RW_T4T_MAX_DATA_PER_WRITE; } else { p_t4t->max_update_size = p_t4t->cc_file.max_lc; } /* Lc: valid range is 0x01 to 0xFF */ if (p_t4t->max_update_size >= T4T_MAX_LENGTH_LC) { p_t4t->max_update_size = T4T_MAX_LENGTH_LC; } p_t4t->ndef_length = nlen; p_t4t->state = RW_T4T_STATE_IDLE; if (rw_cb.p_cback) { rw_data.ndef.status = NFC_STATUS_OK; rw_data.ndef.protocol = NFC_PROTOCOL_ISO_DEP; rw_data.ndef.max_size = (UINT32) (p_t4t->cc_file.ndef_fc.max_file_size - (UINT16) T4T_FILE_LENGTH_SIZE); rw_data.ndef.cur_size = nlen; rw_data.ndef.flags = RW_NDEF_FL_SUPPORTED | RW_NDEF_FL_FORMATED; if (p_t4t->cc_file.ndef_fc.write_access != T4T_FC_WRITE_ACCESS) { rw_data.ndef.flags |= RW_NDEF_FL_READ_ONLY; } (*(rw_cb.p_cback)) (RW_T4T_NDEF_DETECT_EVT, &rw_data); RW_TRACE_DEBUG0 ("rw_t4t_sm_detect_ndef (): Sent RW_T4T_NDEF_DETECT_EVT"); } } else { /* NLEN should be less than max file size */ RW_TRACE_ERROR2 ("rw_t4t_sm_detect_ndef (): NLEN (%d) + 2 must be <= max file size (%d)", nlen, p_t4t->cc_file.ndef_fc.max_file_size); p_t4t->ndef_status &= ~ (RW_T4T_NDEF_STATUS_NDEF_DETECTED); rw_t4t_handle_error (NFC_STATUS_BAD_RESP, 0, 0); } } else { /* response payload size should be T4T_FILE_LENGTH_SIZE */ RW_TRACE_ERROR2 ("rw_t4t_sm_detect_ndef (): Length (%d) of R-APDU must be %d", p_r_apdu->len, T4T_FILE_LENGTH_SIZE + T4T_RSP_STATUS_WORDS_SIZE); p_t4t->ndef_status &= ~ (RW_T4T_NDEF_STATUS_NDEF_DETECTED); rw_t4t_handle_error (NFC_STATUS_BAD_RESP, 0, 0); } break; default: RW_TRACE_ERROR1 ("rw_t4t_sm_detect_ndef (): unknown sub_state=%d", p_t4t->sub_state); rw_t4t_handle_error (NFC_STATUS_FAILED, 0, 0); break; } }
/******************************************************************************* ** ** Function rw_t4t_data_cback ** ** Description This callback function receives the data from NFCC. ** ** Returns none ** *******************************************************************************/ static void rw_t4t_data_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data) { tRW_T4T_CB *p_t4t = &rw_cb.tcb.t4t; BT_HDR *p_r_apdu = (BT_HDR *) p_data->data.p_data; tRW_DATA rw_data; #if (BT_TRACE_VERBOSE == TRUE) UINT8 begin_state = p_t4t->state; #endif RW_TRACE_DEBUG1 ("rw_t4t_data_cback () event = 0x%X", event); nfc_stop_quick_timer (&p_t4t->timer); switch (event) { case NFC_DEACTIVATE_CEVT: NFC_SetStaticRfCback (NULL); p_t4t->state = RW_T4T_STATE_NOT_ACTIVATED; return; case NFC_ERROR_CEVT: if (p_t4t->state == RW_T4T_STATE_PRESENCE_CHECK) { p_t4t->state = RW_T4T_STATE_IDLE; rw_data.status = NFC_STATUS_FAILED; (*(rw_cb.p_cback)) (RW_T4T_PRESENCE_CHECK_EVT, &rw_data); } else { p_t4t->state = RW_T4T_STATE_IDLE; rw_data.status = (tNFC_STATUS) (*(UINT8*) p_data); (*(rw_cb.p_cback)) (RW_T4T_INTF_ERROR_EVT, &rw_data); } return; case NFC_DATA_CEVT: break; default: return; } #if (BT_TRACE_PROTOCOL == TRUE) DispRWT4Tags (p_r_apdu, TRUE); #endif #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_DEBUG2 ("RW T4T state: <%s (%d)>", rw_t4t_get_state_name (p_t4t->state), p_t4t->state); #else RW_TRACE_DEBUG1 ("RW T4T state: %d", p_t4t->state); #endif switch (p_t4t->state) { case RW_T4T_STATE_IDLE: /* Unexpected R-APDU, it should be raw frame response */ /* forward to upper layer without parsing */ if (rw_cb.p_cback) { rw_data.raw_frame.status = NFC_STATUS_OK; rw_data.raw_frame.p_data = p_r_apdu; (*(rw_cb.p_cback)) (RW_T4T_RAW_FRAME_EVT, &rw_data); p_r_apdu = NULL; } else { GKI_freebuf (p_r_apdu); } break; case RW_T4T_STATE_DETECT_NDEF: rw_t4t_sm_detect_ndef (p_r_apdu); GKI_freebuf (p_r_apdu); break; case RW_T4T_STATE_READ_NDEF: rw_t4t_sm_read_ndef (p_r_apdu); /* p_r_apdu may send upper lyaer */ break; case RW_T4T_STATE_UPDATE_NDEF: rw_t4t_sm_update_ndef (p_r_apdu); GKI_freebuf (p_r_apdu); break; case RW_T4T_STATE_PRESENCE_CHECK: /* if any response, send presence check with ok */ rw_data.status = NFC_STATUS_OK; p_t4t->state = RW_T4T_STATE_IDLE; (*(rw_cb.p_cback)) (RW_T4T_PRESENCE_CHECK_EVT, &rw_data); GKI_freebuf (p_r_apdu); break; default: RW_TRACE_ERROR1 ("rw_t4t_data_cback (): invalid state=%d", p_t4t->state); GKI_freebuf (p_r_apdu); break; } #if (BT_TRACE_VERBOSE == TRUE) if (begin_state != p_t4t->state) { RW_TRACE_DEBUG2 ("RW T4T state changed:<%s> -> <%s>", rw_t4t_get_state_name (begin_state), rw_t4t_get_state_name (p_t4t->state)); } #endif }