| /****************************************************************************** |
| * |
| * Copyright (C) 2010-2012 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| /****************************************************************************** |
| * |
| * This file contains the implementation for Type 2 tag in Reader/Writer |
| * mode. |
| * |
| ******************************************************************************/ |
| #include <string.h> |
| #include "nfc_target.h" |
| #include "bt_types.h" |
| |
| #if (NFC_INCLUDED == TRUE) |
| #include "nfc_api.h" |
| #include "nci_hmsgs.h" |
| #include "rw_api.h" |
| #include "rw_int.h" |
| #include "nfc_int.h" |
| #include "gki.h" |
| |
| /* Static local functions */ |
| static void rw_t2t_proc_data (UINT8 conn_id, tNFC_CONN_EVT event, BT_HDR *p_pkt); |
| static tNFC_STATUS rw_t2t_send_cmd (UINT8 opcode, UINT8 *p_dat); |
| static void rw_t2t_process_error (void); |
| static void rw_t2t_process_frame_error (void); |
| static void rw_t2t_handle_presence_check_rsp (tNFC_STATUS status); |
| static void rw_t2t_resume_op (void); |
| |
| #if (BT_TRACE_VERBOSE == TRUE) |
| static char *rw_t2t_get_state_name (UINT8 state); |
| static char *rw_t2t_get_substate_name (UINT8 substate); |
| #endif |
| |
| /******************************************************************************* |
| ** |
| ** 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_CONN_EVT event, BT_HDR *p_pkt) |
| { |
| tRW_EVENT rw_event = RW_RAW_FRAME_EVT; |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| 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 ( (p_t2t->state == RW_T2T_STATE_IDLE) |
| ||(p_cmd_rsp_info == NULL) ) |
| { |
| RW_TRACE_DEBUG2 ("rw_t2t_proc_data - Raw frame event! state: IDLE, conn_id: %u event: %u", |
| conn_id, event); |
| |
| evt_data.status = NFC_STATUS_OK; |
| 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) ) |
| { |
| #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 |
| /* Retrasmit the last sent command if retry-count < max retry */ |
| rw_t2t_process_frame_error (); |
| 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_EVENT5 ("rw_t2t_proc_data State: %u conn_id: %u event: %u len: %u data[0]: 0x%02x", |
| p_t2t->state, conn_id, event, 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 |
| { |
| evt_data.status = NFC_STATUS_FAILED; |
| } |
| } |
| 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) |
| { |
| /* If the response length indicates positive response or cannot be known from length then assume success */ |
| evt_data.status = NFC_STATUS_OK; |
| |
| /* 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); |
| |
| /* 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; |
| } |
| } |
| break; |
| |
| case RW_T2T_STATE_WRITE: |
| /* Check positive or negative acknowledgment */ |
| if ((*p & 0x0f) != T2T_RSP_ACK) |
| evt_data.status = NFC_STATUS_FAILED; |
| break; |
| |
| default: |
| /* NDEF/other Tlv Operation/Format Tag/Config Tag as Read only |
| * Check if Positive response to previous write command */ |
| if ( (p_cmd_rsp_info->opcode == T2T_CMD_WRITE) |
| &&((*p & 0x0f) != T2T_RSP_ACK) ) |
| evt_data.status = NFC_STATUS_FAILED; |
| else |
| { |
| b_notify = FALSE; |
| rw_t2t_handle_rsp (p); |
| } |
| break; |
| } |
| } |
| else |
| { |
| evt_data.p_data = p_pkt; |
| if (p_t2t->state == RW_T2T_STATE_READ) |
| b_release = FALSE; |
| |
| /* Negative response to the command sent */ |
| evt_data.status = NFC_STATUS_FAILED; |
| } |
| |
| if (b_notify) |
| { |
| rw_event = rw_t2t_info_to_event (p_cmd_rsp_info); |
| /* Move back to idle state */ |
| rw_t2t_handle_op_complete (); |
| 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; |
| ndef_data.max_size = 0; |
| ndef_data.cur_size = 0; |
| (*rw_cb.p_cback) (rw_event, (tRW_DATA *) &ndef_data); |
| } |
| else |
| (*rw_cb.p_cback) (rw_event, (tRW_DATA *) &evt_data); |
| } |
| |
| if (b_release) |
| GKI_freebuf (p_pkt); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** 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) ) |
| { |
| rw_t2t_proc_data (conn_id, event, (BT_HDR *) (p_data->data.p_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) ) |
| { |
| #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) |
| { |
| rw_t2t_handle_presence_check_rsp (NFC_STATUS_FAILED); |
| } |
| else |
| { |
| rw_t2t_process_error (); |
| } |
| break; |
| |
| default: |
| break; |
| |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function rw_t2t_send_cmd |
| ** |
| ** Description This function composes a Type 2 Tag command and send it via |
| ** NCI to NFCC. |
| ** |
| ** Returns NFC_STATUS_OK if the command is successfuly sent to NCI |
| ** otherwise, error status |
| ** |
| *******************************************************************************/ |
| tNFC_STATUS rw_t2t_send_cmd (UINT8 opcode, UINT8 *p_dat) |
| { |
| tNFC_STATUS status = NFC_STATUS_FAILED; |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| const tT2T_CMD_RSP_INFO *p_cmd_rsp_info = t2t_cmd_to_rsp_info (opcode); |
| BT_HDR *p_data; |
| UINT8 *p; |
| |
| if (p_cmd_rsp_info) |
| { |
| /* a valid opcode for RW */ |
| p_data = (BT_HDR *) GKI_getpoolbuf (NFC_RW_POOL_ID); |
| if (p_data) |
| { |
| p_t2t->p_cmd_rsp_info = (tT2T_CMD_RSP_INFO *) p_cmd_rsp_info; |
| p_data->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; |
| p = (UINT8 *) (p_data + 1) + p_data->offset; |
| |
| UINT8_TO_STREAM (p, opcode); |
| |
| if (p_dat) |
| { |
| ARRAY_TO_STREAM (p, p_dat, (p_cmd_rsp_info->cmd_len - 1)); |
| } |
| |
| p_data->len = p_cmd_rsp_info->cmd_len; |
| |
| /* Indicate first attempt to send command, back up cmd buffer in case needed for retransmission */ |
| rw_cb.cur_retry = 0; |
| memcpy (p_t2t->p_cur_cmd_buf, p_data, sizeof (BT_HDR) + p_data->offset + p_data->len); |
| |
| #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) |
| /* Update stats */ |
| rw_main_update_tx_stats (p_data->len, FALSE); |
| #endif |
| RW_TRACE_EVENT2 ("RW SENT [%s]:0x%x CMD", t2t_info_to_str (p_cmd_rsp_info), p_cmd_rsp_info->opcode); |
| |
| if ((status = NFC_SendData (NFC_RF_CONN_ID, p_data)) == NFC_STATUS_OK) |
| { |
| nfc_start_quick_timer (&p_t2t->t2_timer, NFC_TTYPE_RW_T2T_RESPONSE, |
| (RW_T2T_TOUT_RESP*QUICK_TIMER_TICKS_PER_SEC) / 1000); |
| } |
| else |
| { |
| #if (BT_TRACE_VERBOSE == TRUE) |
| RW_TRACE_ERROR2 ("T2T NFC Send data failed. state=%s substate=%s ", rw_t2t_get_state_name (p_t2t->state), rw_t2t_get_substate_name (p_t2t->substate)); |
| #else |
| RW_TRACE_ERROR2 ("T2T NFC Send data failed. state=0x%02X substate=0x%02X ", p_t2t->state, p_t2t->substate); |
| #endif |
| } |
| } |
| else |
| { |
| status = NFC_STATUS_NO_BUFFERS; |
| } |
| } |
| return status; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function rw_t2t_process_timeout |
| ** |
| ** Description handles timeout event |
| ** |
| ** Returns none |
| ** |
| *******************************************************************************/ |
| void rw_t2t_process_timeout (TIMER_LIST_ENT *p_tle) |
| { |
| tRW_READ_DATA evt_data; |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| |
| if (p_t2t->state == RW_T2T_STATE_CHECK_PRESENCE) |
| { |
| /* Move back to idle state */ |
| rw_t2t_handle_presence_check_rsp (NFC_STATUS_FAILED); |
| return; |
| } |
| |
| if (p_t2t->substate == RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR) |
| { |
| p_t2t->sector = p_t2t->select_sector; |
| /* Here timeout is an acknowledgment for successfull sector change */ |
| if (p_t2t->state == RW_T2T_STATE_SELECT_SECTOR) |
| { |
| /* Notify that select sector op is successfull */ |
| rw_t2t_handle_op_complete (); |
| evt_data.status = NFC_STATUS_OK; |
| evt_data.p_data = NULL; |
| (*rw_cb.p_cback) (RW_T2T_SELECT_CPLT_EVT, (tRW_DATA *) &evt_data); |
| } |
| else |
| { |
| /* Resume operation from where we stopped before sector change */ |
| rw_t2t_resume_op (); |
| } |
| } |
| else if (p_t2t->state != RW_T2T_STATE_IDLE) |
| { |
| #if (BT_TRACE_VERBOSE == TRUE) |
| RW_TRACE_ERROR1 ("T2T timeout. state=%s ", rw_t2t_get_state_name (p_t2t->state)); |
| #else |
| RW_TRACE_ERROR1 ("T2T timeout. state=0x%02X ", p_t2t->state); |
| #endif |
| /* Handle timeout error as no response to the command sent */ |
| rw_t2t_process_error (); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function rw_t2t_process_frame_error |
| ** |
| ** Description handles frame crc error |
| ** |
| ** Returns none |
| ** |
| *******************************************************************************/ |
| static void rw_t2t_process_frame_error (void) |
| { |
| #if (defined (RW_STATS_INCLUDED) && (RW_STATS_INCLUDED == TRUE)) |
| /* Update stats */ |
| rw_main_update_crc_error_stats (); |
| #endif |
| /* Process the error */ |
| rw_t2t_process_error (); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** 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 (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 |
| { |
| 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 not activated remain in non activated state, otherwise 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; |
| 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; |
| 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_t2t_handle_presence_check_rsp |
| ** |
| ** Description Handle response to presence check |
| ** |
| ** Returns Nothing |
| ** |
| *****************************************************************************/ |
| void rw_t2t_handle_presence_check_rsp (tNFC_STATUS status) |
| { |
| tRW_READ_DATA evt_data; |
| |
| /* Notify, Tag is present or not */ |
| evt_data.status = status; |
| rw_t2t_handle_op_complete (); |
| |
| (*rw_cb.p_cback) (RW_T2T_PRESENCE_CHECK_EVT, (tRW_DATA *) &evt_data); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function rw_t2t_resume_op |
| ** |
| ** Description This function will continue operation after moving to new |
| ** sector |
| ** |
| ** Returns tNFC_STATUS |
| ** |
| *******************************************************************************/ |
| static void rw_t2t_resume_op (void) |
| { |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| tRW_READ_DATA evt_data; |
| BT_HDR *p_cmd_buf; |
| tRW_EVENT event; |
| const tT2T_CMD_RSP_INFO *p_cmd_rsp_info = (tT2T_CMD_RSP_INFO *) rw_cb.tcb.t2t.p_cmd_rsp_info; |
| UINT8 *p; |
| |
| /* Move back to the substate where we were before changing sector */ |
| p_t2t->substate = p_t2t->prev_substate; |
| |
| p = (UINT8 *) (p_t2t->p_sec_cmd_buf + 1) + p_t2t->p_sec_cmd_buf->offset; |
| p_cmd_rsp_info = t2t_cmd_to_rsp_info ((UINT8) *p); |
| p_t2t->p_cmd_rsp_info = (tT2T_CMD_RSP_INFO *) p_cmd_rsp_info; |
| |
| /* 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_sec_cmd_buf, sizeof (BT_HDR) + p_t2t->p_sec_cmd_buf->offset + p_t2t->p_sec_cmd_buf->len); |
| memcpy (p_t2t->p_cur_cmd_buf, p_t2t->p_sec_cmd_buf, sizeof (BT_HDR) + p_t2t->p_sec_cmd_buf->offset + p_t2t->p_sec_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); |
| } |
| else |
| { |
| /* failure - could not send buffer */ |
| evt_data.p_data = NULL; |
| evt_data.status = NFC_STATUS_FAILED; |
| event = rw_t2t_info_to_event (p_cmd_rsp_info); |
| rw_t2t_handle_op_complete (); |
| (*rw_cb.p_cback) (event, (tRW_DATA *) &evt_data); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** 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_t2t_read |
| ** |
| ** Description This function issues Type 2 Tag READ command for the |
| ** specified block. If the specified block is in different |
| ** sector then it first sends command to move to new sector |
| ** and after the tag moves to new sector it issues the read |
| ** command for the block. |
| ** |
| ** Returns tNFC_STATUS |
| ** |
| *******************************************************************************/ |
| tNFC_STATUS rw_t2t_read (UINT16 block) |
| { |
| tNFC_STATUS status; |
| UINT8 *p; |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| UINT8 sector_byte2[1]; |
| UINT8 read_cmd[1]; |
| |
| |
| read_cmd[0] = block % T2T_BLOCKS_PER_SECTOR; |
| if (p_t2t->sector != block/T2T_BLOCKS_PER_SECTOR) |
| { |
| sector_byte2[0] = 0xFF; |
| /* First Move to new sector before sending Read command */ |
| if ((status = rw_t2t_send_cmd (T2T_CMD_SEC_SEL,sector_byte2)) == NFC_STATUS_OK) |
| { |
| /* Prepare command that needs to be sent after sector change op is completed */ |
| p_t2t->select_sector = (UINT8) (block/T2T_BLOCKS_PER_SECTOR); |
| p_t2t->p_sec_cmd_buf->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; |
| |
| p = (UINT8 *) (p_t2t->p_sec_cmd_buf + 1) + p_t2t->p_sec_cmd_buf->offset; |
| UINT8_TO_BE_STREAM (p, T2T_CMD_READ); |
| UINT8_TO_BE_STREAM (p, read_cmd[0]); |
| p_t2t->p_sec_cmd_buf->len = 2; |
| p_t2t->block_read = block; |
| |
| /* Backup the current substate to move back to this substate after changing sector */ |
| p_t2t->prev_substate = p_t2t->substate; |
| p_t2t->substate = RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR_SUPPORT; |
| return NFC_STATUS_OK; |
| } |
| return NFC_STATUS_FAILED; |
| } |
| |
| /* Send Read command as sector change is not needed */ |
| if ((status = rw_t2t_send_cmd (T2T_CMD_READ, (UINT8 *) read_cmd)) == NFC_STATUS_OK) |
| { |
| p_t2t->block_read = block; |
| RW_TRACE_EVENT1 ("rw_t2t_read Sent Command for Block: %u", block); |
| } |
| |
| return status; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function rw_t2t_write |
| ** |
| ** Description This function issues Type 2 Tag WRITE command for the |
| ** specified block. If the specified block is in different |
| ** sector then it first sends command to move to new sector |
| ** and after the tag moves to new sector it issues the write |
| ** command for the block. |
| ** |
| ** Returns tNFC_STATUS |
| ** |
| *******************************************************************************/ |
| tNFC_STATUS rw_t2t_write (UINT16 block, UINT8 *p_write_data) |
| { |
| tNFC_STATUS status; |
| UINT8 *p; |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| UINT8 write_cmd[T2T_WRITE_DATA_LEN + 1]; |
| UINT8 sector_byte2[1]; |
| |
| p_t2t->block_written = block; |
| write_cmd[0] = (UINT8) (block%T2T_BLOCKS_PER_SECTOR); |
| memcpy (&write_cmd[1], p_write_data, T2T_WRITE_DATA_LEN); |
| |
| if (p_t2t->sector != block/T2T_BLOCKS_PER_SECTOR) |
| { |
| sector_byte2[0] = 0xFF; |
| /* First Move to new sector before sending Write command */ |
| if ((status = rw_t2t_send_cmd (T2T_CMD_SEC_SEL, sector_byte2)) == NFC_STATUS_OK) |
| { |
| /* Prepare command that needs to be sent after sector change op is completed */ |
| p_t2t->select_sector = (UINT8) (block/T2T_BLOCKS_PER_SECTOR); |
| p_t2t->p_sec_cmd_buf->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; |
| p = (UINT8 *) (p_t2t->p_sec_cmd_buf + 1) + p_t2t->p_sec_cmd_buf->offset; |
| UINT8_TO_BE_STREAM (p, T2T_CMD_WRITE); |
| memcpy (p, write_cmd, T2T_WRITE_DATA_LEN + 1); |
| p_t2t->p_sec_cmd_buf->len = 2 + T2T_WRITE_DATA_LEN; |
| p_t2t->block_written = block; |
| |
| /* Backup the current substate to move back to this substate after changing sector */ |
| p_t2t->prev_substate = p_t2t->substate; |
| p_t2t->substate = RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR_SUPPORT; |
| return NFC_STATUS_OK; |
| } |
| return NFC_STATUS_FAILED; |
| } |
| |
| /* Send Write command as sector change is not needed */ |
| if ((status = rw_t2t_send_cmd (T2T_CMD_WRITE, write_cmd)) == NFC_STATUS_OK) |
| { |
| RW_TRACE_EVENT1 ("rw_t2t_write Sent Command for Block: %u", block); |
| } |
| |
| return status; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** 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 (); |
| |
| return NFC_STATUS_OK; |
| } |
| |
| /***************************************************************************** |
| ** |
| ** Function rw_t2t_handle_op_complete |
| ** |
| ** Description Reset to IDLE state |
| ** |
| ** Returns Nothing |
| ** |
| *****************************************************************************/ |
| void rw_t2t_handle_op_complete (void) |
| { |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| |
| p_t2t->state = RW_T2T_STATE_IDLE; |
| p_t2t->substate = RW_T2T_SUBSTATE_NONE; |
| return; |
| } |
| |
| /***************************************************************************** |
| ** |
| ** Function RW_T2tPresenceCheck |
| ** |
| ** Description |
| ** Check if the tag is still in the field. |
| ** |
| ** The RW_T2T_PRESENCE_CHECK_EVT w/ status is used to indicate presence |
| ** or non-presence. |
| ** |
| ** Returns |
| ** NFC_STATUS_OK, if raw data frame sent |
| ** NFC_STATUS_NO_BUFFERS: unable to allocate a buffer for this operation |
| ** NFC_STATUS_FAILED: other error |
| ** |
| *****************************************************************************/ |
| tNFC_STATUS RW_T2tPresenceCheck (void) |
| { |
| tNFC_STATUS retval = NFC_STATUS_OK; |
| tRW_DATA evt_data; |
| tRW_CB *p_rw_cb = &rw_cb; |
| UINT8 sector_blk = 0; /* block 0 of current sector */ |
| |
| RW_TRACE_API0 ("RW_T2tPresenceCheck"); |
| |
| /* If RW_SelectTagType was not called (no conn_callback) return failure */ |
| if (!p_rw_cb->p_cback) |
| { |
| retval = NFC_STATUS_FAILED; |
| } |
| /* If we are not activated, then RW_T2T_PRESENCE_CHECK_EVT status=FAIL */ |
| else if (p_rw_cb->tcb.t2t.state == RW_T2T_STATE_NOT_ACTIVATED) |
| { |
| evt_data.status = NFC_STATUS_FAILED; |
| (*p_rw_cb->p_cback) (RW_T2T_PRESENCE_CHECK_EVT, &evt_data); |
| } |
| /* If command is pending, assume tag is still present */ |
| else if (p_rw_cb->tcb.t2t.state != RW_T2T_STATE_IDLE) |
| { |
| evt_data.status = NFC_STATUS_OK; |
| (*p_rw_cb->p_cback) (RW_T2T_PRESENCE_CHECK_EVT, &evt_data); |
| } |
| else |
| { |
| /* IDLE state: send a READ command to block 0 of the current sector */ |
| if((retval = rw_t2t_send_cmd (T2T_CMD_READ, §or_blk))== NFC_STATUS_OK) |
| { |
| p_rw_cb->tcb.t2t.state = RW_T2T_STATE_CHECK_PRESENCE; |
| } |
| } |
| |
| return (retval); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function RW_T2tRead |
| ** |
| ** Description This function issues the Type 2 Tag READ command. When the |
| ** operation is complete the callback function will be called |
| ** with a RW_T2T_READ_EVT. |
| ** |
| ** Returns tNFC_STATUS |
| ** |
| *******************************************************************************/ |
| tNFC_STATUS RW_T2tRead (UINT16 block) |
| { |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| tNFC_STATUS status; |
| |
| if (p_t2t->state != RW_T2T_STATE_IDLE) |
| { |
| RW_TRACE_ERROR1 ("Error: Type 2 tag not activated or Busy - State: %u", p_t2t->state); |
| return (NFC_STATUS_FAILED); |
| } |
| |
| if ((status = rw_t2t_read (block)) == NFC_STATUS_OK) |
| { |
| p_t2t->state = RW_T2T_STATE_READ; |
| RW_TRACE_EVENT0 ("RW_T2tRead Sent Read command"); |
| } |
| |
| return status; |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function RW_T2tWrite |
| ** |
| ** Description This function issues the Type 2 Tag WRITE command. When the |
| ** operation is complete the callback function will be called |
| ** with a RW_T2T_WRITE_EVT. |
| ** |
| ** p_new_bytes points to the array of 4 bytes to be written |
| ** |
| ** Returns tNFC_STATUS |
| ** |
| *******************************************************************************/ |
| tNFC_STATUS RW_T2tWrite (UINT16 block, UINT8 *p_write_data) |
| { |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| tNFC_STATUS status; |
| |
| if (p_t2t->state != RW_T2T_STATE_IDLE) |
| { |
| RW_TRACE_ERROR1 ("Error: Type 2 tag not activated or Busy - State: %u", p_t2t->state); |
| return (NFC_STATUS_FAILED); |
| } |
| |
| if ((status = rw_t2t_write (block, p_write_data)) == NFC_STATUS_OK) |
| { |
| p_t2t->state = RW_T2T_STATE_WRITE; |
| if (block < T2T_FIRST_DATA_BLOCK) |
| p_t2t->b_read_hdr = FALSE; |
| else if (block < (T2T_FIRST_DATA_BLOCK + T2T_READ_BLOCKS)) |
| p_t2t->b_read_data = FALSE; |
| RW_TRACE_EVENT0 ("RW_T2tWrite Sent Write command"); |
| } |
| |
| return status; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function RW_T2tSectorSelect |
| ** |
| ** Description This function issues the Type 2 Tag SECTOR-SELECT command |
| ** packet 1. If a NACK is received as the response, the callback |
| ** function will be called with a RW_T2T_SECTOR_SELECT_EVT. If |
| ** an ACK is received as the response, the command packet 2 with |
| ** the given sector number is sent to the peer device. When the |
| ** response for packet 2 is received, the callback function will |
| ** be called with a RW_T2T_SECTOR_SELECT_EVT. |
| ** |
| ** A sector is 256 contiguous blocks (1024 bytes). |
| ** |
| ** Returns tNFC_STATUS |
| ** |
| *******************************************************************************/ |
| tNFC_STATUS RW_T2tSectorSelect (UINT8 sector) |
| { |
| tNFC_STATUS status; |
| tRW_T2T_CB *p_t2t = &rw_cb.tcb.t2t; |
| UINT8 sector_byte2[1]; |
| |
| if (p_t2t->state != RW_T2T_STATE_IDLE) |
| { |
| RW_TRACE_ERROR1 ("Error: Type 2 tag not activated or Busy - State: %u", p_t2t->state); |
| return (NFC_STATUS_FAILED); |
| } |
| |
| if (sector >= T2T_MAX_SECTOR) |
| { |
| RW_TRACE_ERROR2 ("RW_T2tSectorSelect - Invalid sector: %u, T2 Max supported sector value: %u", sector, T2T_MAX_SECTOR - 1); |
| return (NFC_STATUS_FAILED); |
| } |
| |
| sector_byte2[0] = 0xFF; |
| |
| if ((status = rw_t2t_send_cmd (T2T_CMD_SEC_SEL, sector_byte2)) == NFC_STATUS_OK) |
| { |
| p_t2t->state = RW_T2T_STATE_SELECT_SECTOR; |
| p_t2t->select_sector = sector; |
| p_t2t->substate = RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR_SUPPORT; |
| |
| RW_TRACE_EVENT0 ("RW_T2tSectorSelect Sent Sector select first command"); |
| } |
| |
| return status; |
| } |
| |
| #if (BT_TRACE_VERBOSE == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function rw_t2t_get_state_name |
| ** |
| ** Description This function returns the state name. |
| ** |
| ** NOTE conditionally compiled to save memory. |
| ** |
| ** Returns pointer to the name |
| ** |
| *******************************************************************************/ |
| static char *rw_t2t_get_state_name (UINT8 state) |
| { |
| switch (state) |
| { |
| case RW_T2T_STATE_NOT_ACTIVATED: |
| return ("NOT_ACTIVATED"); |
| case RW_T2T_STATE_IDLE: |
| return ("IDLE"); |
| case RW_T2T_STATE_READ: |
| return ("APP_READ"); |
| case RW_T2T_STATE_WRITE: |
| return ("APP_WRITE"); |
| case RW_T2T_STATE_SELECT_SECTOR: |
| return ("SECTOR_SELECT"); |
| case RW_T2T_STATE_DETECT_TLV: |
| return ("TLV_DETECT"); |
| case RW_T2T_STATE_READ_NDEF: |
| return ("READ_NDEF"); |
| case RW_T2T_STATE_WRITE_NDEF: |
| return ("WRITE_NDEF"); |
| case RW_T2T_STATE_SET_TAG_RO: |
| return ("SET_TAG_RO"); |
| case RW_T2T_STATE_CHECK_PRESENCE: |
| return ("CHECK_PRESENCE"); |
| default: |
| return ("???? UNKNOWN STATE"); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function rw_t2t_get_substate_name |
| ** |
| ** Description This function returns the substate name. |
| ** |
| ** NOTE conditionally compiled to save memory. |
| ** |
| ** Returns pointer to the name |
| ** |
| *******************************************************************************/ |
| static char *rw_t2t_get_substate_name (UINT8 substate) |
| { |
| switch (substate) |
| { |
| case RW_T2T_SUBSTATE_NONE: |
| return ("RW_T2T_SUBSTATE_NONE"); |
| case RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR_SUPPORT: |
| return ("RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR_SUPPORT"); |
| case RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR: |
| return ("RW_T2T_SUBSTATE_WAIT_SELECT_SECTOR"); |
| case RW_T2T_SUBSTATE_WAIT_READ_CC: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_CC"); |
| case RW_T2T_SUBSTATE_WAIT_TLV_DETECT: |
| return ("RW_T2T_SUBSTATE_WAIT_TLV_DETECT"); |
| case RW_T2T_SUBSTATE_WAIT_FIND_LEN_FIELD_LEN: |
| return ("RW_T2T_SUBSTATE_WAIT_FIND_LEN_FIELD_LEN"); |
| case RW_T2T_SUBSTATE_WAIT_READ_TLV_LEN0: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_TLV_LEN0"); |
| case RW_T2T_SUBSTATE_WAIT_READ_TLV_LEN1: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_TLV_LEN1"); |
| case RW_T2T_SUBSTATE_WAIT_READ_TLV_VALUE: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_TLV_VALUE"); |
| case RW_T2T_SUBSTATE_WAIT_READ_LOCKS: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_LOCKS"); |
| case RW_T2T_SUBSTATE_WAIT_READ_NDEF_FIRST_BLOCK: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_NDEF_FIRST_BLOCK"); |
| case RW_T2T_SUBSTATE_WAIT_READ_NDEF_LAST_BLOCK: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_NDEF_LAST_BLOCK"); |
| case RW_T2T_SUBSTATE_WAIT_READ_TERM_TLV_BLOCK: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_TERM_TLV_BLOCK"); |
| case RW_T2T_SUBSTATE_WAIT_READ_NDEF_NEXT_BLOCK: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_NDEF_NEXT_BLOCK"); |
| case RW_T2T_SUBSTATE_WAIT_WRITE_NDEF_NEXT_BLOCK: |
| return ("RW_T2T_SUBSTATE_WAIT_WRITE_NDEF_NEXT_BLOCK"); |
| case RW_T2T_SUBSTATE_WAIT_WRITE_NDEF_LAST_BLOCK: |
| return ("RW_T2T_SUBSTATE_WAIT_WRITE_NDEF_LAST_BLOCK"); |
| case RW_T2T_SUBSTATE_WAIT_READ_NDEF_LEN_BLOCK: |
| return ("RW_T2T_SUBSTATE_WAIT_READ_NDEF_LEN_BLOCK"); |
| case RW_T2T_SUBSTATE_WAIT_WRITE_NDEF_LEN_BLOCK: |
| return ("RW_T2T_SUBSTATE_WAIT_WRITE_NDEF_LEN_BLOCK"); |
| case RW_T2T_SUBSTATE_WAIT_WRITE_NDEF_LEN_NEXT_BLOCK: |
| return ("RW_T2T_SUBSTATE_WAIT_WRITE_NDEF_LEN_NEXT_BLOCK"); |
| case RW_T2T_SUBSTATE_WAIT_WRITE_TERM_TLV_CMPLT: |
| return ("RW_T2T_SUBSTATE_WAIT_WRITE_TERM_TLV_CMPLT"); |
| default: |
| return ("???? UNKNOWN SUBSTATE"); |
| } |
| } |
| |
| #endif /* (BT_TRACE_VERBOSE == TRUE) */ |
| |
| #endif /* NFC_INCLUDED == TRUE*/ |
