/*******************************************************************************
**
** 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
}
