/*******************************************************************************
**
** Function rw_t2t_select
**
** Description This function selects type 2 tag.
**
** Returns Tag selection status
**
*******************************************************************************/
tNFC_STATUS rw_t2t_select (void)
{
tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t;
p_t2t->state = RW_T2T_STATE_IDLE;
p_t2t->ndef_status = T2T_NDEF_NOT_DETECTED;
/* Alloc cmd buf for retransmissions */
if (p_t2t->p_cur_cmd_buf == NULL)
{
if ((p_t2t->p_cur_cmd_buf = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID)) == NULL)
{
RW_TRACE_ERROR0 ("rw_t2t_select: unable to allocate buffer for retransmission");
return (NFC_STATUS_FAILED);
}
}
/* Alloc cmd buf for holding a command untill sector changes */
if (p_t2t->p_sec_cmd_buf == NULL)
{
if ((p_t2t->p_sec_cmd_buf = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID)) == NULL)
{
RW_TRACE_ERROR0 ("rw_t2t_select: unable to allocate buffer used during sector change");
return (NFC_STATUS_FAILED);
}
}
NFC_SetStaticRfCback (rw_t2t_conn_cback);
rw_t2t_handle_op_complete ();
p_t2t->check_tag_halt = FALSE;
return NFC_STATUS_OK;
}
/*******************************************************************************
**
** Function RW_T4tUpdateNDef
**
** Description This function performs NDEF update procedure
** Note: RW_T4tDetectNDef () must be called before using this
** Updating data must not be removed until returning event
**
** The following event will be returned
** RW_T4T_NDEF_UPDATE_CPLT_EVT for complete
** RW_T4T_NDEF_UPDATE_FAIL_EVT for failure
**
** Returns NFC_STATUS_OK if success
** NFC_STATUS_FAILED if T4T is busy or other error
**
*******************************************************************************/
tNFC_STATUS RW_T4tUpdateNDef (UINT16 length, UINT8 *p_data)
{
RW_TRACE_API1 ("RW_T4tUpdateNDef () length:%d", length);
if (rw_cb.tcb.t4t.state != RW_T4T_STATE_IDLE)
{
RW_TRACE_ERROR1 ("RW_T4tUpdateNDef ():Unable to start command at state (0x%X)",
rw_cb.tcb.t4t.state);
return NFC_STATUS_FAILED;
}
/* if NDEF has been detected */
if (rw_cb.tcb.t4t.ndef_status & RW_T4T_NDEF_STATUS_NDEF_DETECTED)
{
/* if read-only */
if (rw_cb.tcb.t4t.ndef_status & RW_T4T_NDEF_STATUS_NDEF_READ_ONLY)
{
RW_TRACE_ERROR0 ("RW_T4tUpdateNDef ():NDEF is read-only");
return NFC_STATUS_FAILED;
}
if (rw_cb.tcb.t4t.cc_file.ndef_fc.max_file_size < length + T4T_FILE_LENGTH_SIZE)
{
RW_TRACE_ERROR2 ("RW_T4tUpdateNDef ():data (%d bytes) plus NLEN is more than max file size (%d)",
length, rw_cb.tcb.t4t.cc_file.ndef_fc.max_file_size);
return NFC_STATUS_FAILED;
}
/* store NDEF length and data */
rw_cb.tcb.t4t.ndef_length = length;
rw_cb.tcb.t4t.p_update_data = p_data;
rw_cb.tcb.t4t.rw_offset = T4T_FILE_LENGTH_SIZE;
rw_cb.tcb.t4t.rw_length = length;
/* set NLEN to 0x0000 for the first step */
if (!rw_t4t_update_nlen (0x0000))
{
return NFC_STATUS_FAILED;
}
rw_cb.tcb.t4t.state = RW_T4T_STATE_UPDATE_NDEF;
rw_cb.tcb.t4t.sub_state = RW_T4T_SUBSTATE_WAIT_UPDATE_NLEN;
return NFC_STATUS_OK;
}
else
{
RW_TRACE_ERROR0 ("RW_T4tUpdateNDef ():No NDEF detected");
return NFC_STATUS_FAILED;
}
}
/*******************************************************************************
**
** Function rw_t1t_select
**
** Description This function will set the callback function to
** receive data from lower layers and also send rid command
**
** Returns none
**
*******************************************************************************/
tNFC_STATUS rw_t1t_select (UINT8 hr[T1T_HR_LEN], UINT8 uid[T1T_CMD_UID_LEN])
{
tNFC_STATUS status = NFC_STATUS_FAILED;
tRW_T1T_CB *p_t1t = &rw_cb.tcb.t1t;
p_t1t->state = RW_T1T_STATE_NOT_ACTIVATED;
/* Alloc cmd buf for retransmissions */
if (p_t1t->p_cur_cmd_buf == NULL)
{
if ((p_t1t->p_cur_cmd_buf = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID)) == NULL)
{
RW_TRACE_ERROR0 ("rw_t1t_select: unable to allocate buffer for retransmission");
return status;
}
}
memcpy (p_t1t->hr, hr, T1T_HR_LEN);
memcpy (p_t1t->mem, uid, T1T_CMD_UID_LEN);
NFC_SetStaticRfCback (rw_t1t_conn_cback);
p_t1t->state = RW_T1T_STATE_IDLE;
return NFC_STATUS_OK;
}
/*******************************************************************************
**
** 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_T4tReadNDef
**
** Description This function performs NDEF read procedure
** Note: RW_T4tDetectNDef () must be called before using this
**
** The following event will be returned
** RW_T4T_NDEF_READ_EVT for each segmented NDEF message
** RW_T4T_NDEF_READ_CPLT_EVT for the last segment or complete NDEF
** RW_T4T_NDEF_READ_FAIL_EVT for failure
**
** Returns NFC_STATUS_OK if success
** NFC_STATUS_FAILED if T4T is busy or other error
**
*******************************************************************************/
tNFC_STATUS RW_T4tReadNDef (void)
{
RW_TRACE_API0 ("RW_T4tReadNDef ()");
if (rw_cb.tcb.t4t.state != RW_T4T_STATE_IDLE)
{
RW_TRACE_ERROR1 ("RW_T4tReadNDef ():Unable to start command at state (0x%X)",
rw_cb.tcb.t4t.state);
return NFC_STATUS_FAILED;
}
/* if NDEF has been detected */
if (rw_cb.tcb.t4t.ndef_status & RW_T4T_NDEF_STATUS_NDEF_DETECTED)
{
/* start reading NDEF */
if (!rw_t4t_read_file (T4T_FILE_LENGTH_SIZE, rw_cb.tcb.t4t.ndef_length, FALSE))
{
return NFC_STATUS_FAILED;
}
rw_cb.tcb.t4t.state = RW_T4T_STATE_READ_NDEF;
rw_cb.tcb.t4t.sub_state = RW_T4T_SUBSTATE_WAIT_READ_RESP;
return NFC_STATUS_OK;
}
else
{
RW_TRACE_ERROR0 ("RW_T4tReadNDef ():No NDEF detected");
return NFC_STATUS_FAILED;
}
}
/*******************************************************************************
**
** 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_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_t4t_read_file
**
** Description Send ReadBinary Command to peer
**
** Returns TRUE if success
**
*******************************************************************************/
static BOOLEAN rw_t4t_read_file (UINT16 offset, UINT16 length, BOOLEAN is_continue)
{
tRW_T4T_CB *p_t4t = &rw_cb.tcb.t4t;
BT_HDR *p_c_apdu;
UINT8 *p;
RW_TRACE_DEBUG3 ("rw_t4t_read_file () offset:%d, length:%d, is_continue:%d, ",
offset, length, is_continue);
p_c_apdu = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID);
if (!p_c_apdu)
{
RW_TRACE_ERROR0 ("rw_t4t_read_file (): Cannot allocate buffer");
return FALSE;
}
/* if this is the first reading */
if (is_continue == FALSE)
{
/* initialise starting offset and total length */
/* these will be updated when receiving response */
p_t4t->rw_offset = offset;
p_t4t->rw_length = length;
}
/* adjust reading length if payload is bigger than max size per single command */
if (length > p_t4t->max_read_size)
{
length = (UINT8) (p_t4t->max_read_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_READ_BINARY);
UINT16_TO_BE_STREAM (p, offset);
UINT8_TO_BE_STREAM (p, length); /* Le */
p_c_apdu->len = T4T_CMD_MIN_HDR_SIZE + 1; /* adding Le */
if (!rw_t4t_send_to_lower (p_c_apdu))
{
return FALSE;
}
return TRUE;
}
/*******************************************************************************
**
** Function rw_t4t_send_to_lower
**
** Description Send C-APDU to lower layer
**
** Returns TRUE if success
**
*******************************************************************************/
static BOOLEAN rw_t4t_send_to_lower (BT_HDR *p_c_apdu)
{
#if (BT_TRACE_PROTOCOL == TRUE)
DispRWT4Tags (p_c_apdu, FALSE);
#endif
if (NFC_SendData (NFC_RF_CONN_ID, p_c_apdu) != NFC_STATUS_OK)
{
RW_TRACE_ERROR0 ("rw_t4t_send_to_lower (): NFC_SendData () failed");
return FALSE;
}
nfc_start_quick_timer (&rw_cb.tcb.t4t.timer, NFC_TTYPE_RW_T4T_RESPONSE,
(RW_T4T_TOUT_RESP * QUICK_TIMER_TICKS_PER_SEC) / 1000);
return TRUE;
}
/*******************************************************************************
**
** 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_T1tWriteNoErase
**
** Description This function sends a WRITE-NE command for Reader/Writer mode.
**
** Returns tNFC_STATUS
**
*******************************************************************************/
tNFC_STATUS RW_T1tWriteNoErase (UINT8 block, UINT8 byte, UINT8 new_byte)
{
tNFC_STATUS status = NFC_STATUS_FAILED;
tRW_T1T_CB *p_t1t = &rw_cb.tcb.t1t;
UINT8 addr;
if (p_t1t->state != RW_T1T_STATE_IDLE)
{
RW_TRACE_WARNING1 ("RW_T1tWriteNoErase - Busy - State: %u", p_t1t->state);
return (NFC_STATUS_BUSY);
}
if ( (p_t1t->tag_attribute == RW_T1_TAG_ATTRB_READ_ONLY)
&&(block != T1T_CC_BLOCK)
&&(byte != T1T_CC_RWA_OFFSET) )
{
RW_TRACE_ERROR0 ("RW_T1tWriteErase - Tag is in Read only state");
return (NFC_STATUS_REFUSED);
}
if ( (block >= T1T_STATIC_BLOCKS)
||(byte >= T1T_BLOCK_SIZE ) )
{
RW_TRACE_ERROR2 ("RW_T1tWriteErase - Invalid Block/byte: %u / %u", block, byte);
return (NFC_STATUS_REFUSED);
}
if( (block == T1T_UID_BLOCK)
||(block == T1T_RES_BLOCK) )
{
RW_TRACE_WARNING1 ("RW_T1tWriteNoErase - Cannot write to Locked block: %u", block);
return (NFC_STATUS_REFUSED);
}
/* send WRITE-NE command */
RW_T1T_BLD_ADD ((addr), (block), (byte));
if ((status = rw_t1t_send_static_cmd (T1T_CMD_WRITE_NE, addr, new_byte)) == NFC_STATUS_OK)
{
p_t1t->state = RW_T1T_STATE_WRITE;
if (block < T1T_BLOCKS_PER_SEGMENT)
{
p_t1t->b_update = FALSE;
p_t1t->b_rseg = FALSE;
}
}
return status;
}
/*******************************************************************************
**
** Function rw_t2t_sector_change
**
** Description This function issues Type 2 Tag SECTOR-SELECT command
** packet 1.
**
** Returns tNFC_STATUS
**
*******************************************************************************/
tNFC_STATUS rw_t2t_sector_change (UINT8 sector)
{
tNFC_STATUS status;
BT_HDR *p_data;
UINT8 *p;
tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t;
if ((p_data = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID)) == NULL)
{
RW_TRACE_ERROR0 ("rw_t2t_sector_change - No buffer");
return (NFC_STATUS_NO_BUFFERS);
}
p_data->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE;
p = (UINT8 *) (p_data + 1) + p_data->offset;
UINT8_TO_BE_STREAM (p, sector);
UINT8_TO_BE_STREAM (p, 0x00);
UINT8_TO_BE_STREAM (p, 0x00);
UINT8_TO_BE_STREAM (p, 0x00);
p_data->len = 4;
if ((status = NFC_SendData (NFC_RF_CONN_ID , p_data)) == NFC_STATUS_OK)
{
/* Passive rsp command and suppose not to get response to this command */
p_t2t->p_cmd_rsp_info = NULL;
p_t2t->substate = RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR;
RW_TRACE_EVENT0 ("rw_t2t_sector_change Sent Second Command");
nfc_start_quick_timer (&p_t2t->t2_timer, NFC_TTYPE_RW_T2T_RESPONSE,
(RW_T2T_SEC_SEL_TOUT_RESP * QUICK_TIMER_TICKS_PER_SEC) / 1000);
}
else
{
RW_TRACE_ERROR1 ("rw_t2t_sector_change Send failed at rw_t2t_send_cmd, error: %u", status);
}
return status;
}
/*******************************************************************************
**
** Function RW_T1tWriteNoErase8
**
** Description This function sends a WRITE-NE8 command for Reader/Writer mode.
**
** Returns tNFC_STATUS
**
*******************************************************************************/
tNFC_STATUS RW_T1tWriteNoErase8 (UINT8 block, UINT8 *p_new_dat)
{
tNFC_STATUS status = NFC_STATUS_FAILED;
tRW_T1T_CB *p_t1t= &rw_cb.tcb.t1t;
if (p_t1t->state != RW_T1T_STATE_IDLE)
{
RW_TRACE_WARNING1 ("RW_T1tWriteNoErase8 - Busy - State: %u", p_t1t->state);
return (NFC_STATUS_BUSY);
}
if ( (p_t1t->tag_attribute == RW_T1_TAG_ATTRB_READ_ONLY)
&&(block != T1T_CC_BLOCK) )
{
RW_TRACE_ERROR0 ("RW_T1tWriteNoErase8 - Tag is in Read only state");
return (NFC_STATUS_REFUSED);
}
if( (block == T1T_UID_BLOCK)
||(block == T1T_RES_BLOCK) )
{
RW_TRACE_WARNING1 ("RW_T1tWriteNoErase8 - Cannot write to Locked block: %u", block);
return (NFC_STATUS_REFUSED);
}
if (rw_cb.tcb.t1t.hr[0] != T1T_STATIC_HR0 || rw_cb.tcb.t1t.hr[1] >= RW_T1T_HR1_MIN)
{
/* send WRITE-NE command */
if ((status = rw_t1t_send_dyn_cmd (T1T_CMD_WRITE_NE8, block, p_new_dat)) == NFC_STATUS_OK)
{
p_t1t->state = RW_T1T_STATE_WRITE;
if (block < T1T_BLOCKS_PER_SEGMENT)
{
p_t1t->b_update = FALSE;
p_t1t->b_rseg = FALSE;
}
}
}
return status;
}
/*******************************************************************************
**
** Function RW_SetActivatedTagType
**
** Description This function selects the tag type for Reader/Writer mode.
**
** Returns tNFC_STATUS
**
*******************************************************************************/
tNFC_STATUS RW_SetActivatedTagType (tNFC_ACTIVATE_DEVT *p_activate_params, tRW_CBACK *p_cback)
{
tNFC_STATUS status = NFC_STATUS_FAILED;
/* check for null cback here / remove checks from rw_t?t */
RW_TRACE_DEBUG3 ("RW_SetActivatedTagType protocol:%d, technology:%d, SAK:%d", p_activate_params->protocol, p_activate_params->rf_tech_param.mode, p_activate_params->rf_tech_param.param.pa.sel_rsp);
if (p_cback == NULL)
{
RW_TRACE_ERROR0 ("RW_SetActivatedTagType called with NULL callback");
return (NFC_STATUS_FAILED);
}
/* Reset tag-specific area of control block */
memset (&rw_cb.tcb, 0, sizeof (tRW_TCB));
#if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE))
/* Reset RW stats */
rw_main_reset_stats ();
#endif /* RW_STATS_INCLUDED */
rw_cb.p_cback = p_cback;
switch (p_activate_params->protocol)
{
/* not a tag NFC_PROTOCOL_NFCIP1: NFCDEP/LLCP - NFC-A or NFC-F */
case NFC_PROTOCOL_T1T: /* Type1Tag - NFC-A */
if (p_activate_params->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A)
{
status = rw_t1t_select (p_activate_params->rf_tech_param.param.pa.hr,
p_activate_params->rf_tech_param.param.pa.nfcid1);
}
break;
case NFC_PROTOCOL_T2T: /* Type2Tag - NFC-A */
if (p_activate_params->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A)
{
if (p_activate_params->rf_tech_param.param.pa.sel_rsp == NFC_SEL_RES_NFC_FORUM_T2T)
status = rw_t2t_select ();
}
break;
case NFC_PROTOCOL_T3T: /* Type3Tag - NFC-F */
if (p_activate_params->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_F)
{
status = rw_t3t_select (p_activate_params->rf_tech_param.param.pf.nfcid2,
p_activate_params->rf_tech_param.param.pf.mrti_check,
p_activate_params->rf_tech_param.param.pf.mrti_update);
}
break;
case NFC_PROTOCOL_ISO_DEP: /* ISODEP/4A,4B- NFC-A or NFC-B */
#if(NFC_NXP_NOT_OPEN_INCLUDED == TRUE)
case NFC_PROTOCOL_T3BT:
#endif
if ( (p_activate_params->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_B)
||(p_activate_params->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_A) )
{
status = rw_t4t_select ();
}
break;
case NFC_PROTOCOL_15693: /* ISO 15693 */
if (p_activate_params->rf_tech_param.mode == NFC_DISCOVERY_TYPE_POLL_ISO15693)
{
status = rw_i93_select (p_activate_params->rf_tech_param.param.pi93.uid);
}
break;
/* TODO set up callback for proprietary protocol */
default:
RW_TRACE_ERROR0 ("RW_SetActivatedTagType Invalid protocol");
}
if (status != NFC_STATUS_OK)
rw_cb.p_cback = NULL;
return status;
}