/***************************************************************************** ** ** Function rw_t1t_handle_rid_rsp ** ** Description Handles response to RID: Collects HR, UID, notify up the ** stack ** ** Returns event to notify application ** *****************************************************************************/ static tRW_EVENT rw_t1t_handle_rid_rsp (BT_HDR *p_pkt) { tRW_T1T_CB *p_t1t = &rw_cb.tcb.t1t; tRW_DATA evt_data; UINT8 *p_rid_rsp; evt_data.status = NFC_STATUS_OK; evt_data.data.p_data = p_pkt; /* Assume the data is just the response byte sequence */ p_rid_rsp = (UINT8 *) (p_pkt + 1) + p_pkt->offset; /* Response indicates tag is present */ if (p_t1t->state == RW_T1T_STATE_CHECK_PRESENCE) { /* If checking for the presence of the tag then just notify */ return RW_T1T_PRESENCE_CHECK_EVT; } /* Extract HR and UID from response */ STREAM_TO_ARRAY (p_t1t->hr, p_rid_rsp, T1T_HR_LEN); #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_DEBUG2 ("hr0:0x%x, hr1:0x%x", p_t1t->hr[0], p_t1t->hr[1]); RW_TRACE_DEBUG4 ("rw_t1t_handle_rid_rsp (): UID0-3=%02x%02x%02x%02x", p_rid_rsp[0], p_rid_rsp[1], p_rid_rsp[2], p_rid_rsp[3]); #else RW_TRACE_DEBUG0 ("rw_t1t_handle_rid_rsp ()"); #endif /* Fetch UID0-3 from RID response message */ STREAM_TO_ARRAY (p_t1t->mem, p_rid_rsp, T1T_CMD_UID_LEN); /* Notify RID response Event */ return RW_T1T_RID_EVT; }
/******************************************************************************* ** ** 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_update_file ** ** Description Send UpdateBinary Command to peer ** ** Returns TRUE if success ** *******************************************************************************/ static BOOLEAN rw_t4t_update_file (void) { tRW_T4T_CB *p_t4t = &rw_cb.tcb.t4t; BT_HDR *p_c_apdu; UINT8 *p; UINT16 length; RW_TRACE_DEBUG2 ("rw_t4t_update_file () rw_offset:%d, rw_length:%d", p_t4t->rw_offset, p_t4t->rw_length); p_c_apdu = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID); if (!p_c_apdu) { RW_TRACE_ERROR0 ("rw_t4t_write_file (): Cannot allocate buffer"); return FALSE; } /* try to send all of remaining data */ length = p_t4t->rw_length; /* adjust updating length if payload is bigger than max size per single command */ if (length > p_t4t->max_update_size) { length = (UINT8) (p_t4t->max_update_size); } 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, p_t4t->rw_offset); UINT8_TO_BE_STREAM (p, length); memcpy (p, p_t4t->p_update_data, length); p_c_apdu->len = T4T_CMD_MAX_HDR_SIZE + length; if (!rw_t4t_send_to_lower (p_c_apdu)) { return FALSE; } /* adjust offset, length and pointer for remaining data */ p_t4t->rw_offset += length; p_t4t->rw_length -= length; p_t4t->p_update_data += length; return TRUE; }
/******************************************************************************* ** ** Function rw_t2t_proc_data ** ** Description This function handles data evt received from NFC Controller. ** ** Returns none ** *******************************************************************************/ static void rw_t2t_proc_data (UINT8 conn_id, tNFC_DATA_CEVT *p_data) { tRW_EVENT rw_event = RW_RAW_FRAME_EVT; tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; BT_HDR *p_pkt = p_data->p_data; BOOLEAN b_notify = TRUE; BOOLEAN b_release = TRUE; UINT8 *p; tRW_READ_DATA evt_data = {0}; 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; #if (BT_TRACE_VERBOSE == TRUE) UINT8 begin_state = p_t2t->state; #endif if ( (p_t2t->state == RW_T2T_STATE_IDLE) ||(p_cmd_rsp_info == NULL) ) { #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_DEBUG2 ("RW T2T Raw Frame: Len [0x%X] Status [%s]", p_pkt->len, NFC_GetStatusName (p_data->status)); #else RW_TRACE_DEBUG2 ("RW T2T Raw Frame: Len [0x%X] Status [0x%X]", p_pkt->len, p_data->status); #endif evt_data.status = p_data->status; evt_data.p_data = p_pkt; (*rw_cb.p_cback) (RW_T2T_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 /* Stop timer as response is received */ nfc_stop_quick_timer (&p_t2t->t2_timer); RW_TRACE_EVENT2 ("RW RECV [%s]:0x%x RSP", t2t_info_to_str (p_cmd_rsp_info), p_cmd_rsp_info->opcode); if ( ( (p_pkt->len != p_cmd_rsp_info->rsp_len) &&(p_pkt->len != p_cmd_rsp_info->nack_rsp_len) &&(p_t2t->substate != RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR) ) ||(p_t2t->state == RW_T2T_STATE_HALT) ) { #if (BT_TRACE_VERBOSE == TRUE) RW_TRACE_ERROR1 ("T2T Frame error. state=%s ", rw_t2t_get_state_name (p_t2t->state)); #else RW_TRACE_ERROR1 ("T2T Frame error. state=0x%02X command=0x%02X ", p_t2t->state); #endif if (p_t2t->state != RW_T2T_STATE_HALT) { /* Retrasmit the last sent command if retry-count < max retry */ rw_t2t_process_frame_error (); p_t2t->check_tag_halt = FALSE; } GKI_freebuf (p_pkt); return; } rw_cb.cur_retry = 0; /* Assume the data is just the response byte sequence */ p = (UINT8 *) (p_pkt + 1) + p_pkt->offset; RW_TRACE_EVENT4 ("rw_t2t_proc_data State: %u conn_id: %u len: %u data[0]: 0x%02x", p_t2t->state, conn_id, p_pkt->len, *p); evt_data.p_data = NULL; if (p_t2t->substate == RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR_SUPPORT) { /* The select process happens in two steps */ if ((*p & 0x0f) == T2T_RSP_ACK) { if (rw_t2t_sector_change (p_t2t->select_sector) == NFC_STATUS_OK) b_notify = FALSE; else evt_data.status = NFC_STATUS_FAILED; } else { RW_TRACE_EVENT1 ("rw_t2t_proc_data - Received NACK response(0x%x) to SEC-SELCT CMD", (*p & 0x0f)); evt_data.status = NFC_STATUS_REJECTED; } } else if (p_t2t->substate == RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR) { evt_data.status = NFC_STATUS_FAILED; } else if ( (p_pkt->len != p_cmd_rsp_info->rsp_len) ||((p_cmd_rsp_info->opcode == T2T_CMD_WRITE) && ((*p & 0x0f) != T2T_RSP_ACK)) ) { /* Received NACK response */ evt_data.p_data = p_pkt; if (p_t2t->state == RW_T2T_STATE_READ) b_release = FALSE; RW_TRACE_EVENT1 ("rw_t2t_proc_data - Received NACK response(0x%x)", (*p & 0x0f)); if (!p_t2t->check_tag_halt) { /* Just received first NACK. Retry just one time to find if tag went in to HALT State */ b_notify = FALSE; rw_t2t_process_error (); /* Assume Tag is in HALT State, untill we get response to retry command */ p_t2t->check_tag_halt = TRUE; } else { p_t2t->check_tag_halt = FALSE; /* Got consecutive NACK so tag not really halt after first NACK, but current operation failed */ evt_data.status = NFC_STATUS_FAILED; } } else { /* If the response length indicates positive response or cannot be known from length then assume success */ evt_data.status = NFC_STATUS_OK; p_t2t->check_tag_halt = FALSE; /* The response data depends on what the current operation was */ switch (p_t2t->state) { case RW_T2T_STATE_CHECK_PRESENCE: b_notify = FALSE; rw_t2t_handle_presence_check_rsp (NFC_STATUS_OK); break; case RW_T2T_STATE_READ: evt_data.p_data = p_pkt; b_release = FALSE; if (p_t2t->block_read == 0) { p_t2t->b_read_hdr = TRUE; memcpy (p_t2t->tag_hdr, p, T2T_READ_DATA_LEN); #if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE) /* On Ultralight - C tag, if CC is corrupt, correct it */ if ( (p_t2t->tag_hdr[0] == TAG_MIFARE_MID) &&(p_t2t->tag_hdr[T2T_CC2_TMS_BYTE] >= T2T_INVALID_CC_TMS_VAL0) &&(p_t2t->tag_hdr[T2T_CC2_TMS_BYTE] <= T2T_INVALID_CC_TMS_VAL1) ) { p_t2t->tag_hdr[T2T_CC2_TMS_BYTE] = T2T_CC2_TMS_MULC; } #endif } break; case RW_T2T_STATE_WRITE: /* Write operation completed successfully */ break; default: /* NDEF/other Tlv Operation/Format-Tag/Config Tag as Read only */ b_notify = FALSE; rw_t2t_handle_rsp (p); break; } } if (b_notify) { rw_event = rw_t2t_info_to_event (p_cmd_rsp_info); 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; /* Move back to idle state */ rw_t2t_handle_op_complete (); (*rw_cb.p_cback) (rw_event, (tRW_DATA *) &ndef_data); } else { /* Move back to idle state */ rw_t2t_handle_op_complete (); (*rw_cb.p_cback) (rw_event, (tRW_DATA *) &evt_data); } } if (b_release) GKI_freebuf (p_pkt); #if (BT_TRACE_VERBOSE == TRUE) if (begin_state != p_t2t->state) { RW_TRACE_DEBUG2 ("RW T2T state changed:<%s> -> <%s>", rw_t2t_get_state_name (begin_state), rw_t2t_get_state_name (p_t2t->state)); } #endif }
/******************************************************************************* ** ** 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_t2t_conn_cback ** ** Description This callback function receives events/data from NFCC. ** ** Returns none ** *******************************************************************************/ void rw_t2t_conn_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data) { tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; tRW_READ_DATA evt_data; RW_TRACE_DEBUG2 ("rw_t2t_conn_cback: conn_id=%i, evt=%i", conn_id, event); /* Only handle static conn_id */ if (conn_id != NFC_RF_CONN_ID) { return; } switch (event) { case NFC_CONN_CREATE_CEVT: case NFC_CONN_CLOSE_CEVT: break; case NFC_DEACTIVATE_CEVT: #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) /* Display stats */ rw_main_log_stats (); #endif /* Stop t2t timer (if started) */ nfc_stop_quick_timer (&p_t2t->t2_timer); /* Free cmd buf for retransmissions */ if (p_t2t->p_cur_cmd_buf) { GKI_freebuf (p_t2t->p_cur_cmd_buf); p_t2t->p_cur_cmd_buf = NULL; } /* Free cmd buf used to hold command before sector change */ if (p_t2t->p_sec_cmd_buf) { GKI_freebuf (p_t2t->p_sec_cmd_buf); p_t2t->p_sec_cmd_buf = NULL; } p_t2t->state = RW_T2T_STATE_NOT_ACTIVATED; NFC_SetStaticRfCback (NULL); break; case NFC_DATA_CEVT: if ( (p_data != NULL) &&( (p_data->data.status == NFC_STATUS_OK) ||(p_data->data.status == NFC_STATUS_CONTINUE) ) ) { rw_t2t_proc_data (conn_id, &(p_data->data)); break; } /* Data event with error status...fall through to NFC_ERROR_CEVT case */ case NFC_ERROR_CEVT: if ( (p_t2t->state == RW_T2T_STATE_NOT_ACTIVATED) ||(p_t2t->state == RW_T2T_STATE_IDLE) ||(p_t2t->state == RW_T2T_STATE_HALT) ) { #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) rw_main_update_trans_error_stats (); #endif /* RW_STATS_INCLUDED */ if (event == NFC_ERROR_CEVT) evt_data.status = (tNFC_STATUS) (*(UINT8*) p_data); else if (p_data) evt_data.status = p_data->status; else evt_data.status = NFC_STATUS_FAILED; evt_data.p_data = NULL; (*rw_cb.p_cback) (RW_T2T_INTF_ERROR_EVT, (tRW_DATA *) &evt_data); break; } nfc_stop_quick_timer (&p_t2t->t2_timer); #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) rw_main_update_trans_error_stats (); #endif if (p_t2t->state == RW_T2T_STATE_CHECK_PRESENCE) { if (p_t2t->check_tag_halt) { p_t2t->state = RW_T2T_STATE_HALT; rw_t2t_handle_presence_check_rsp (NFC_STATUS_REJECTED); } else { /* Move back to idle state */ rw_t2t_handle_presence_check_rsp (NFC_STATUS_FAILED); } } else { rw_t2t_process_error (); } #if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE) /* Free the response buffer in case of invalid response*/ if (p_data != NULL) { GKI_freebuf((BT_HDR *) (p_data->data.p_data)); } #endif break; default: break; } }
/******************************************************************************* ** ** 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_t1t_conn_cback ** ** Description This callback function receives the events/data from NFCC. ** ** Returns none ** *******************************************************************************/ void rw_t1t_conn_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data) { tRW_T1T_CB *p_t1t = &rw_cb.tcb.t1t; tRW_READ_DATA evt_data; RW_TRACE_DEBUG2 ("rw_t1t_conn_cback: conn_id=%i, evt=0x%x", conn_id, event); /* Only handle static conn_id */ if (conn_id != NFC_RF_CONN_ID) { RW_TRACE_WARNING1 ("rw_t1t_conn_cback - Not static connection id: =%i", conn_id); return; } switch (event) { case NFC_CONN_CREATE_CEVT: case NFC_CONN_CLOSE_CEVT: break; case NFC_DEACTIVATE_CEVT: #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) /* Display stats */ rw_main_log_stats (); #endif /* RW_STATS_INCLUDED */ /* Stop t1t timer (if started) */ nfc_stop_quick_timer (&p_t1t->timer); /* Free cmd buf for retransmissions */ if (p_t1t->p_cur_cmd_buf) { GKI_freebuf (p_t1t->p_cur_cmd_buf); p_t1t->p_cur_cmd_buf = NULL; } p_t1t->state = RW_T1T_STATE_NOT_ACTIVATED; NFC_SetStaticRfCback (NULL); break; case NFC_DATA_CEVT: if ( (p_data != NULL) &&(p_data->data.status == NFC_STATUS_OK) ) { rw_t1t_data_cback (conn_id, event, p_data); break; } /* Data event with error status...fall through to NFC_ERROR_CEVT case */ case NFC_ERROR_CEVT: if ( (p_t1t->state == RW_T1T_STATE_NOT_ACTIVATED) ||(p_t1t->state == RW_T1T_STATE_IDLE) ) { #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) rw_main_update_trans_error_stats (); #endif /* RW_STATS_INCLUDED */ if (event == NFC_ERROR_CEVT) evt_data.status = (tNFC_STATUS) (*(UINT8*) p_data); else if (p_data) evt_data.status = p_data->status; else evt_data.status = NFC_STATUS_FAILED; evt_data.p_data = NULL; (*rw_cb.p_cback) (RW_T1T_INTF_ERROR_EVT, (tRW_DATA *) &evt_data); break; } nfc_stop_quick_timer (&p_t1t->timer); #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) rw_main_update_trans_error_stats (); #endif /* RW_STATS_INCLUDED */ if (p_t1t->state == RW_T1T_STATE_CHECK_PRESENCE) { rw_t1t_handle_presence_check_rsp (NFC_STATUS_FAILED); } else { rw_t1t_process_error (); } break; default: break; } }
/******************************************************************************* ** ** 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 }