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