| /****************************************************************************** |
| * |
| * Copyright (C) 2010-2014 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 LLCP Link Management |
| * |
| ******************************************************************************/ |
| |
| #include <string.h> |
| #include "gki.h" |
| #include "nfc_target.h" |
| #include "bt_types.h" |
| #include "trace_api.h" |
| #include "llcp_int.h" |
| #include "llcp_defs.h" |
| #include "nfc_int.h" |
| |
| const UINT16 llcp_link_rwt[15] = /* RWT = (302us)*2**WT; 302us = 256*16/fc; fc = 13.56MHz */ |
| { |
| 1, /* WT=0, 302us */ |
| 1, /* WT=1, 604us */ |
| 2, /* WT=2, 1208us */ |
| 3, /* WT=3, 2.4ms */ |
| 5, /* WT=4, 4.8ms */ |
| 10, /* WT=5, 9.7ms */ |
| 20, /* WT=6, 19.3ms */ |
| 39, /* WT=7, 38.7ms */ |
| 78, /* WT=8, 77.3ms */ |
| 155, /* WT=9, 154.6ms */ |
| 310, /* WT=10, 309.2ms */ |
| 619, /* WT=11, 618.5ms */ |
| 1237, /* WT=12, 1237.0ms */ |
| 2474, /* WT=13, 2474.0ms */ |
| 4948, /* WT=14, 4948.0ms */ |
| }; |
| |
| static BOOLEAN llcp_link_parse_gen_bytes (UINT8 gen_bytes_len, UINT8 *p_gen_bytes); |
| static BOOLEAN llcp_link_version_agreement (void); |
| |
| static void llcp_link_send_SYMM (void); |
| static void llcp_link_update_status (BOOLEAN is_activated); |
| static void llcp_link_check_congestion (void); |
| static void llcp_link_check_uncongested (void); |
| static void llcp_link_proc_ui_pdu (UINT8 local_sap, UINT8 remote_sap, UINT16 ui_pdu_length, UINT8 *p_ui_pdu, BT_HDR *p_msg); |
| static void llcp_link_proc_agf_pdu (BT_HDR *p_msg); |
| static void llcp_link_proc_rx_pdu (UINT8 dsap, UINT8 ptype, UINT8 ssap, BT_HDR *p_msg); |
| static void llcp_link_proc_rx_data (BT_HDR *p_msg); |
| |
| static BT_HDR *llcp_link_get_next_pdu (BOOLEAN length_only, UINT16 *p_next_pdu_length); |
| static BT_HDR *llcp_link_build_next_pdu (BT_HDR *p_agf); |
| static void llcp_link_send_to_lower (BT_HDR *p_msg); |
| |
| #if (LLCP_TEST_INCLUDED == TRUE) /* this is for LLCP testing */ |
| extern tLLCP_TEST_PARAMS llcp_test_params; |
| #endif |
| |
| /* debug functions type */ |
| #if (BT_TRACE_VERBOSE == TRUE) |
| static char *llcp_pdu_type (UINT8 ptype); |
| #endif |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_start_inactivity_timer |
| ** |
| ** Description This function start LLCP link inactivity timer. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_start_inactivity_timer (void) |
| { |
| if ( (llcp_cb.lcb.inact_timer.in_use == FALSE) |
| &&(llcp_cb.lcb.inact_timeout > 0) ) |
| { |
| LLCP_TRACE_DEBUG1 ("Start inactivity_timer: %d ms", llcp_cb.lcb.inact_timeout); |
| |
| nfc_start_quick_timer (&llcp_cb.lcb.inact_timer, NFC_TTYPE_LLCP_LINK_INACT, |
| ((UINT32) llcp_cb.lcb.inact_timeout) * QUICK_TIMER_TICKS_PER_SEC / 1000); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_stop_inactivity_timer |
| ** |
| ** Description This function stop LLCP link inactivity timer. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_stop_inactivity_timer (void) |
| { |
| if (llcp_cb.lcb.inact_timer.in_use) |
| { |
| LLCP_TRACE_DEBUG0 ("Stop inactivity_timer"); |
| |
| nfc_stop_quick_timer (&llcp_cb.lcb.inact_timer); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_start_link_timer |
| ** |
| ** Description This function starts LLCP link timer (LTO or delay response). |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_start_link_timer (void) |
| { |
| if (llcp_cb.lcb.symm_state == LLCP_LINK_SYMM_LOCAL_XMIT_NEXT) |
| { |
| /* wait for application layer sending data */ |
| nfc_start_quick_timer (&llcp_cb.lcb.timer, NFC_TTYPE_LLCP_LINK_MANAGER, |
| (((UINT32) llcp_cb.lcb.symm_delay) * QUICK_TIMER_TICKS_PER_SEC) / 1000); |
| } |
| else |
| { |
| /* wait for data to receive from remote */ |
| nfc_start_quick_timer (&llcp_cb.lcb.timer, NFC_TTYPE_LLCP_LINK_MANAGER, |
| ((UINT32) llcp_cb.lcb.peer_lto) * QUICK_TIMER_TICKS_PER_SEC / 1000); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_stop_link_timer |
| ** |
| ** Description This function stop LLCP link timer (LTO or delay response). |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_stop_link_timer (void) |
| { |
| nfc_stop_quick_timer (&llcp_cb.lcb.timer); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_activate |
| ** |
| ** Description Activate LLCP link |
| ** |
| ** Returns tLLCP_STATUS |
| ** |
| *******************************************************************************/ |
| tLLCP_STATUS llcp_link_activate (tLLCP_ACTIVATE_CONFIG *p_config) |
| { |
| LLCP_TRACE_DEBUG0 ("llcp_link_activate ()"); |
| |
| /* At this point, MAC link activation procedure has been successfully completed */ |
| |
| /* The Length Reduction values LRi and LRt MUST be 11b. (254bytes) */ |
| if (p_config->max_payload_size != LLCP_NCI_MAX_PAYL_SIZE) |
| { |
| LLCP_TRACE_WARNING2 ("llcp_link_activate (): max payload size (%d) must be %d bytes", |
| p_config->max_payload_size, LLCP_NCI_MAX_PAYL_SIZE); |
| } |
| |
| /* Processing the parametes that have been received with the MAC link activation */ |
| if (llcp_link_parse_gen_bytes (p_config->gen_bytes_len, |
| p_config->p_gen_bytes ) == FALSE) |
| { |
| LLCP_TRACE_ERROR0 ("llcp_link_activate (): Failed to parse general bytes"); |
| (*llcp_cb.lcb.p_link_cback) (LLCP_LINK_ACTIVATION_FAILED_EVT, LLCP_LINK_BAD_GEN_BYTES); |
| |
| if (p_config->is_initiator == FALSE) |
| { |
| /* repond to any incoming PDU with invalid LLCP PDU */ |
| llcp_cb.lcb.link_state = LLCP_LINK_STATE_ACTIVATION_FAILED; |
| NFC_SetStaticRfCback (llcp_link_connection_cback); |
| } |
| return LLCP_STATUS_FAIL; |
| } |
| |
| /* |
| ** For the Target device, the scaled value of RWT MUST be less than or equal to the |
| ** scaled value of the LLC Link Timeout (LTO). |
| */ |
| if ((p_config->is_initiator) && (llcp_link_rwt[p_config->waiting_time] > llcp_cb.lcb.peer_lto)) |
| { |
| LLCP_TRACE_WARNING3 ("llcp_link_activate (): WT (%d, %dms) must be less than or equal to LTO (%dms)", |
| p_config->waiting_time, |
| llcp_link_rwt[p_config->waiting_time], |
| llcp_cb.lcb.peer_lto); |
| } |
| |
| /* extend LTO as much as internally required processing time and propagation delays */ |
| llcp_cb.lcb.peer_lto += LLCP_INTERNAL_TX_DELAY + LLCP_INTERNAL_RX_DELAY; |
| |
| /* LLCP version number agreement */ |
| if (llcp_link_version_agreement () == FALSE) |
| { |
| LLCP_TRACE_ERROR0 ("llcp_link_activate (): Failed to agree version"); |
| (*llcp_cb.lcb.p_link_cback) (LLCP_LINK_ACTIVATION_FAILED_EVT, LLCP_LINK_VERSION_FAILED); |
| |
| if (p_config->is_initiator == FALSE) |
| { |
| /* repond to any incoming PDU with invalid LLCP PDU */ |
| llcp_cb.lcb.link_state = LLCP_LINK_STATE_ACTIVATION_FAILED; |
| NFC_SetStaticRfCback (llcp_link_connection_cback); |
| } |
| return LLCP_STATUS_FAIL; |
| } |
| |
| llcp_cb.lcb.received_first_packet = FALSE; |
| llcp_cb.lcb.is_initiator = p_config->is_initiator; |
| |
| /* reset internal flags */ |
| llcp_cb.lcb.flags = 0x00; |
| |
| /* set tx MIU to MIN (MIU of local LLCP, MIU of peer LLCP) */ |
| |
| if (llcp_cb.lcb.local_link_miu >= llcp_cb.lcb.peer_miu) |
| llcp_cb.lcb.effective_miu = llcp_cb.lcb.peer_miu; |
| else |
| llcp_cb.lcb.effective_miu = llcp_cb.lcb.local_link_miu; |
| |
| /* |
| ** When entering the normal operation phase, LLCP shall initialize the symmetry |
| ** procedure. |
| */ |
| if (llcp_cb.lcb.is_initiator) |
| { |
| LLCP_TRACE_DEBUG0 ("llcp_link_activate (): Connected as Initiator"); |
| |
| llcp_cb.lcb.inact_timeout = llcp_cb.lcb.inact_timeout_init; |
| llcp_cb.lcb.symm_state = LLCP_LINK_SYMM_LOCAL_XMIT_NEXT; |
| |
| if (llcp_cb.lcb.delay_first_pdu_timeout > 0) |
| { |
| /* give a chance to upper layer to send PDU if need */ |
| nfc_start_quick_timer (&llcp_cb.lcb.timer, NFC_TTYPE_LLCP_DELAY_FIRST_PDU, |
| (((UINT32) llcp_cb.lcb.delay_first_pdu_timeout) * QUICK_TIMER_TICKS_PER_SEC) / 1000); |
| } |
| else |
| { |
| llcp_link_send_SYMM (); |
| } |
| } |
| else |
| { |
| LLCP_TRACE_DEBUG0 ("llcp_link_activate (): Connected as Target"); |
| llcp_cb.lcb.inact_timeout = llcp_cb.lcb.inact_timeout_target; |
| llcp_cb.lcb.symm_state = LLCP_LINK_SYMM_REMOTE_XMIT_NEXT; |
| |
| /* wait for data to receive from remote */ |
| llcp_link_start_link_timer (); |
| } |
| |
| |
| /* |
| ** Set state to LLCP_LINK_STATE_ACTIVATED and notify activation before set data callback |
| ** because LLCP PDU could be in NCI queue. |
| */ |
| llcp_cb.lcb.link_state = LLCP_LINK_STATE_ACTIVATED; |
| |
| /* LLCP Link Activation completed */ |
| (*llcp_cb.lcb.p_link_cback) (LLCP_LINK_ACTIVATION_COMPLETE_EVT, LLCP_LINK_SUCCESS); |
| |
| /* Update link status to service layer */ |
| llcp_link_update_status (TRUE); |
| |
| NFC_SetStaticRfCback (llcp_link_connection_cback); |
| |
| return (LLCP_STATUS_SUCCESS); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_deactivate_cleanup |
| ** |
| ** Description Clean up for link deactivation |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_deactivate_cleanup (UINT8 reason) |
| { |
| /* report SDP failure for any pending request */ |
| llcp_sdp_proc_deactivation (); |
| |
| /* Update link status to service layer */ |
| llcp_link_update_status (FALSE); |
| |
| /* We had sent out DISC */ |
| llcp_cb.lcb.link_state = LLCP_LINK_STATE_DEACTIVATED; |
| |
| llcp_link_stop_link_timer (); |
| |
| /* stop inactivity timer */ |
| llcp_link_stop_inactivity_timer (); |
| |
| /* Let upper layer deactivate local link */ |
| (*llcp_cb.lcb.p_link_cback) (LLCP_LINK_DEACTIVATED_EVT, reason); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_process_link_timeout |
| ** |
| ** Description Process timeout events for LTO, SYMM and deactivating |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void llcp_link_process_link_timeout (void) |
| { |
| if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATED) |
| { |
| if ((llcp_cb.lcb.symm_delay > 0) && (llcp_cb.lcb.symm_state == LLCP_LINK_SYMM_LOCAL_XMIT_NEXT)) |
| { |
| /* upper layer doesn't have anything to send */ |
| LLCP_TRACE_DEBUG0 ("llcp_link_process_link_timeout (): LEVT_TIMEOUT in state of LLCP_LINK_SYMM_LOCAL_XMIT_NEXT"); |
| llcp_link_send_SYMM (); |
| |
| /* wait for data to receive from remote */ |
| llcp_link_start_link_timer (); |
| |
| /* start inactivity timer */ |
| if (llcp_cb.num_data_link_connection == 0) |
| { |
| llcp_link_start_inactivity_timer (); |
| } |
| } |
| else |
| { |
| LLCP_TRACE_ERROR0 ("llcp_link_process_link_timeout (): LEVT_TIMEOUT in state of LLCP_LINK_SYMM_REMOTE_XMIT_NEXT"); |
| llcp_link_deactivate (LLCP_LINK_TIMEOUT); |
| } |
| } |
| else if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_DEACTIVATING) |
| { |
| llcp_deactivate_cleanup (llcp_cb.lcb.link_deact_reason); |
| |
| NFC_SetStaticRfCback (NULL); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_deactivate |
| ** |
| ** Description Deactivate LLCP link |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void llcp_link_deactivate (UINT8 reason) |
| { |
| UINT8 local_sap, idx; |
| tLLCP_DLCB *p_dlcb; |
| tLLCP_APP_CB *p_app_cb; |
| |
| LLCP_TRACE_DEBUG1 ("llcp_link_deactivate () reason = 0x%x", reason); |
| |
| /* Release any held buffers in signaling PDU queue */ |
| while (llcp_cb.lcb.sig_xmit_q.p_first) |
| GKI_freebuf (GKI_dequeue (&llcp_cb.lcb.sig_xmit_q)); |
| |
| /* Release any held buffers in UI PDU queue */ |
| for (local_sap = LLCP_SAP_SDP + 1; local_sap < LLCP_NUM_SAPS; local_sap++) |
| { |
| p_app_cb = llcp_util_get_app_cb (local_sap); |
| |
| if ( (p_app_cb) |
| &&(p_app_cb->p_app_cback) ) |
| { |
| while (p_app_cb->ui_xmit_q.p_first) |
| GKI_freebuf (GKI_dequeue (&p_app_cb->ui_xmit_q)); |
| |
| p_app_cb->is_ui_tx_congested = FALSE; |
| |
| while (p_app_cb->ui_rx_q.p_first) |
| GKI_freebuf (GKI_dequeue (&p_app_cb->ui_rx_q)); |
| } |
| } |
| |
| llcp_cb.total_tx_ui_pdu = 0; |
| llcp_cb.total_rx_ui_pdu = 0; |
| |
| /* Notify all of data link */ |
| for (idx = 0; idx < LLCP_MAX_DATA_LINK; idx++) |
| { |
| if (llcp_cb.dlcb[idx].state != LLCP_DLC_STATE_IDLE) |
| { |
| p_dlcb = &(llcp_cb.dlcb[idx]); |
| |
| llcp_dlsm_execute (p_dlcb, LLCP_DLC_EVENT_LINK_ERROR, NULL); |
| } |
| } |
| llcp_cb.total_tx_i_pdu = 0; |
| llcp_cb.total_rx_i_pdu = 0; |
| |
| llcp_cb.overall_tx_congested = FALSE; |
| llcp_cb.overall_rx_congested = FALSE; |
| |
| if ( (reason == LLCP_LINK_FRAME_ERROR) |
| ||(reason == LLCP_LINK_LOCAL_INITIATED) ) |
| { |
| /* get rid of the data pending in NFC tx queue, so DISC PDU can be sent ASAP */ |
| NFC_FlushData (NFC_RF_CONN_ID); |
| |
| llcp_util_send_disc (LLCP_SAP_LM, LLCP_SAP_LM); |
| |
| /* Wait until DISC is sent to peer */ |
| LLCP_TRACE_DEBUG0 ("llcp_link_deactivate (): Wait until DISC is sent to peer"); |
| |
| llcp_cb.lcb.link_state = LLCP_LINK_STATE_DEACTIVATING; |
| |
| if (llcp_cb.lcb.sig_xmit_q.count == 0) |
| { |
| /* if DISC is sent to NFCC, wait for short period for NFCC to send it to peer */ |
| nfc_start_quick_timer (&llcp_cb.lcb.timer, NFC_TTYPE_LLCP_LINK_MANAGER, |
| ((UINT32) 50) * QUICK_TIMER_TICKS_PER_SEC / 1000); |
| } |
| |
| llcp_cb.lcb.link_deact_reason = reason; |
| return; |
| } |
| else if ( (reason == LLCP_LINK_REMOTE_INITIATED) |
| &&(!llcp_cb.lcb.is_initiator) ) |
| { |
| /* if received DISC to deactivate LLCP link as target role, send SYMM PDU */ |
| llcp_link_send_SYMM (); |
| } |
| else /* for link timeout and interface error */ |
| { |
| /* if got RF link loss receiving no LLC PDU from peer */ |
| if ( (reason == LLCP_LINK_RF_LINK_LOSS_ERR) |
| &&(!(llcp_cb.lcb.flags & LLCP_LINK_FLAGS_RX_ANY_LLC_PDU))) |
| { |
| reason = LLCP_LINK_RF_LINK_LOSS_NO_RX_LLC; |
| } |
| |
| NFC_FlushData (NFC_RF_CONN_ID); |
| } |
| |
| llcp_deactivate_cleanup (reason); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_parse_gen_bytes |
| ** |
| ** Description Check LLCP magic number and get parameters in general bytes |
| ** |
| ** Returns TRUE if success |
| ** |
| *******************************************************************************/ |
| static BOOLEAN llcp_link_parse_gen_bytes (UINT8 gen_bytes_len, UINT8 *p_gen_bytes) |
| { |
| UINT8 *p = p_gen_bytes + LLCP_MAGIC_NUMBER_LEN; |
| UINT8 length = gen_bytes_len - LLCP_MAGIC_NUMBER_LEN; |
| |
| if ( (gen_bytes_len >= LLCP_MAGIC_NUMBER_LEN) |
| &&(*(p_gen_bytes) == LLCP_MAGIC_NUMBER_BYTE0) |
| &&(*(p_gen_bytes + 1) == LLCP_MAGIC_NUMBER_BYTE1) |
| &&(*(p_gen_bytes + 2) == LLCP_MAGIC_NUMBER_BYTE2) ) |
| { |
| /* in case peer didn't include these */ |
| llcp_cb.lcb.peer_miu = LLCP_DEFAULT_MIU; |
| llcp_cb.lcb.peer_lto = LLCP_DEFAULT_LTO_IN_MS; |
| |
| return (llcp_util_parse_link_params (length, p)); |
| } |
| else /* if this is not LLCP */ |
| { |
| return (FALSE); |
| } |
| |
| return (TRUE); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_version_agreement |
| ** |
| ** Description LLCP version number agreement |
| ** |
| ** Returns TRUE if success |
| ** |
| *******************************************************************************/ |
| static BOOLEAN llcp_link_version_agreement (void) |
| { |
| UINT8 peer_major_version, peer_minor_version; |
| |
| peer_major_version = LLCP_GET_MAJOR_VERSION (llcp_cb.lcb.peer_version); |
| peer_minor_version = LLCP_GET_MINOR_VERSION (llcp_cb.lcb.peer_version); |
| |
| if (peer_major_version < LLCP_MIN_MAJOR_VERSION) |
| { |
| LLCP_TRACE_ERROR1("llcp_link_version_agreement(): unsupported peer version number. Peer Major Version:%d", peer_major_version); |
| return FALSE; |
| } |
| else |
| { |
| if (peer_major_version == LLCP_VERSION_MAJOR) |
| { |
| llcp_cb.lcb.agreed_major_version = LLCP_VERSION_MAJOR; |
| if (peer_minor_version >= LLCP_VERSION_MINOR) |
| { |
| llcp_cb.lcb.agreed_minor_version = LLCP_VERSION_MINOR; |
| } |
| else |
| { |
| llcp_cb.lcb.agreed_minor_version = peer_minor_version; |
| } |
| } |
| else if (peer_major_version < LLCP_VERSION_MAJOR) |
| { |
| /* so far we can support backward compatibility */ |
| llcp_cb.lcb.agreed_major_version = peer_major_version; |
| llcp_cb.lcb.agreed_minor_version = peer_minor_version; |
| } |
| else |
| { |
| /* let peer (higher major version) decide it */ |
| llcp_cb.lcb.agreed_major_version = LLCP_VERSION_MAJOR; |
| llcp_cb.lcb.agreed_minor_version = LLCP_VERSION_MINOR; |
| } |
| |
| LLCP_TRACE_DEBUG6 ("local version:%d.%d, remote version:%d.%d, agreed version:%d.%d", |
| LLCP_VERSION_MAJOR, LLCP_VERSION_MINOR, |
| peer_major_version, peer_minor_version, |
| llcp_cb.lcb.agreed_major_version, llcp_cb.lcb.agreed_minor_version); |
| |
| return (TRUE); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_update_status |
| ** |
| ** Description Notify all of service layer client link status change |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_update_status (BOOLEAN is_activated) |
| { |
| tLLCP_SAP_CBACK_DATA data; |
| tLLCP_APP_CB *p_app_cb; |
| UINT8 sap; |
| |
| data.link_status.event = LLCP_SAP_EVT_LINK_STATUS; |
| data.link_status.is_activated = is_activated; |
| data.link_status.is_initiator = llcp_cb.lcb.is_initiator; |
| |
| /* notify all SAP so they can create connection while link is activated */ |
| for (sap = LLCP_SAP_SDP + 1; sap < LLCP_NUM_SAPS; sap++) |
| { |
| p_app_cb = llcp_util_get_app_cb (sap); |
| |
| if ( (p_app_cb) |
| &&(p_app_cb->p_app_cback) ) |
| { |
| data.link_status.local_sap = sap; |
| p_app_cb->p_app_cback (&data); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_check_congestion |
| ** |
| ** Description Check overall congestion status |
| ** Notify to all of upper layer if congested |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_check_congestion (void) |
| { |
| tLLCP_SAP_CBACK_DATA data; |
| tLLCP_APP_CB *p_app_cb; |
| UINT8 sap, idx; |
| |
| if (llcp_cb.overall_tx_congested) |
| { |
| /* already congested so no need to check again */ |
| return; |
| } |
| |
| if (llcp_cb.total_tx_ui_pdu + llcp_cb.total_tx_i_pdu >= llcp_cb.max_num_tx_buff) |
| { |
| /* overall buffer usage is high */ |
| llcp_cb.overall_tx_congested = TRUE; |
| |
| LLCP_TRACE_WARNING2 ("overall tx congestion start: total_tx_ui_pdu=%d, total_tx_i_pdu=%d", |
| llcp_cb.total_tx_ui_pdu, llcp_cb.total_tx_i_pdu); |
| |
| data.congest.event = LLCP_SAP_EVT_CONGEST; |
| data.congest.is_congested = TRUE; |
| |
| /* notify logical data link congestion status */ |
| data.congest.remote_sap = LLCP_INVALID_SAP; |
| data.congest.link_type = LLCP_LINK_TYPE_LOGICAL_DATA_LINK; |
| |
| for (sap = LLCP_SAP_SDP + 1; sap < LLCP_NUM_SAPS; sap++) |
| { |
| p_app_cb = llcp_util_get_app_cb (sap); |
| |
| if ( (p_app_cb) |
| &&(p_app_cb->p_app_cback) |
| &&(p_app_cb->link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) ) |
| { |
| /* if already congested then no need to notify again */ |
| if (!p_app_cb->is_ui_tx_congested) |
| { |
| p_app_cb->is_ui_tx_congested = TRUE; |
| |
| LLCP_TRACE_WARNING2 ("Logical link (SAP=0x%X) congestion start: count=%d", |
| sap, p_app_cb->ui_xmit_q.count); |
| |
| data.congest.local_sap = sap; |
| p_app_cb->p_app_cback (&data); |
| } |
| } |
| } |
| |
| /* notify data link connection congestion status */ |
| data.congest.link_type = LLCP_LINK_TYPE_DATA_LINK_CONNECTION; |
| |
| for (idx = 0; idx < LLCP_MAX_DATA_LINK; idx++ ) |
| { |
| if ( (llcp_cb.dlcb[idx].state == LLCP_DLC_STATE_CONNECTED) |
| &&(llcp_cb.dlcb[idx].remote_busy == FALSE) |
| &&(llcp_cb.dlcb[idx].is_tx_congested == FALSE) ) |
| { |
| llcp_cb.dlcb[idx].is_tx_congested = TRUE; |
| |
| LLCP_TRACE_WARNING3 ("Data link (SSAP:DSAP=0x%X:0x%X) congestion start: count=%d", |
| llcp_cb.dlcb[idx].local_sap, llcp_cb.dlcb[idx].remote_sap, |
| llcp_cb.dlcb[idx].i_xmit_q.count); |
| |
| data.congest.local_sap = llcp_cb.dlcb[idx].local_sap; |
| data.congest.remote_sap = llcp_cb.dlcb[idx].remote_sap; |
| |
| (*llcp_cb.dlcb[idx].p_app_cb->p_app_cback) (&data); |
| } |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_check_uncongested |
| ** |
| ** Description Check overall congestion status, logical data link and |
| ** data link connection congestion status |
| ** Notify to each upper layer if uncongested |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_check_uncongested (void) |
| { |
| tLLCP_SAP_CBACK_DATA data; |
| tLLCP_APP_CB *p_app_cb; |
| UINT8 xx, sap, idx; |
| |
| if (llcp_cb.overall_tx_congested) |
| { |
| if (llcp_cb.total_tx_ui_pdu + llcp_cb.total_tx_i_pdu <= llcp_cb.max_num_tx_buff / 2) |
| { |
| /* overall congestion is cleared */ |
| llcp_cb.overall_tx_congested = FALSE; |
| |
| LLCP_TRACE_WARNING2 ("overall tx congestion end: total_tx_ui_pdu=%d, total_tx_i_pdu=%d", |
| llcp_cb.total_tx_ui_pdu, llcp_cb.total_tx_i_pdu); |
| } |
| else |
| { |
| /* wait until more data packets are sent out */ |
| return; |
| } |
| } |
| |
| data.congest.event = LLCP_SAP_EVT_CONGEST; |
| data.congest.is_congested = FALSE; |
| |
| /* if total number of UI PDU is below threshold */ |
| if (llcp_cb.total_tx_ui_pdu < llcp_cb.max_num_ll_tx_buff) |
| { |
| /* check and notify logical data link congestion status */ |
| data.congest.remote_sap = LLCP_INVALID_SAP; |
| data.congest.link_type = LLCP_LINK_TYPE_LOGICAL_DATA_LINK; |
| |
| /* |
| ** start point of uncongested status notification is in round robin |
| ** so each logical data link has equal chance of transmitting. |
| */ |
| sap = llcp_cb.ll_tx_uncongest_ntf_start_sap; |
| |
| for (xx = LLCP_SAP_SDP + 1; xx < LLCP_NUM_SAPS; xx++) |
| { |
| /* no logical data link on LM and SDP */ |
| if (sap > LLCP_SAP_SDP) |
| { |
| p_app_cb = llcp_util_get_app_cb (sap); |
| |
| if ( (p_app_cb) |
| &&(p_app_cb->p_app_cback) |
| &&(p_app_cb->link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) |
| &&(p_app_cb->is_ui_tx_congested) |
| &&(p_app_cb->ui_xmit_q.count <= llcp_cb.ll_tx_congest_end) ) |
| { |
| /* if it was congested but now tx queue count is below threshold */ |
| p_app_cb->is_ui_tx_congested = FALSE; |
| |
| LLCP_TRACE_DEBUG2 ("Logical link (SAP=0x%X) congestion end: count=%d", |
| sap, p_app_cb->ui_xmit_q.count); |
| |
| data.congest.local_sap = sap; |
| p_app_cb->p_app_cback (&data); |
| } |
| } |
| |
| sap = (sap + 1) % LLCP_NUM_SAPS; |
| } |
| |
| /* move start point for next logical data link */ |
| for (xx = 0; xx < LLCP_NUM_SAPS; xx++) |
| { |
| sap = (llcp_cb.ll_tx_uncongest_ntf_start_sap + 1) % LLCP_NUM_SAPS; |
| |
| if (sap > LLCP_SAP_SDP) |
| { |
| p_app_cb = llcp_util_get_app_cb (sap); |
| |
| if ( (p_app_cb) |
| &&(p_app_cb->p_app_cback) |
| &&(p_app_cb->link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) ) |
| { |
| llcp_cb.ll_tx_uncongest_ntf_start_sap = sap; |
| break; |
| } |
| } |
| } |
| } |
| |
| /* notify data link connection congestion status */ |
| data.congest.link_type = LLCP_LINK_TYPE_DATA_LINK_CONNECTION; |
| |
| /* |
| ** start point of uncongested status notification is in round robin |
| ** so each data link connection has equal chance of transmitting. |
| */ |
| idx = llcp_cb.dl_tx_uncongest_ntf_start_idx; |
| |
| for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++ ) |
| { |
| /* if it was congested but now tx queue is below threshold (receiving window) */ |
| if ( (llcp_cb.dlcb[idx].state == LLCP_DLC_STATE_CONNECTED) |
| &&(llcp_cb.dlcb[idx].is_tx_congested) |
| &&(llcp_cb.dlcb[idx].i_xmit_q.count <= llcp_cb.dlcb[idx].remote_rw / 2) ) |
| { |
| llcp_cb.dlcb[idx].is_tx_congested = FALSE; |
| |
| if (llcp_cb.dlcb[idx].remote_busy == FALSE) |
| { |
| LLCP_TRACE_DEBUG3 ("Data link (SSAP:DSAP=0x%X:0x%X) congestion end: count=%d", |
| llcp_cb.dlcb[idx].local_sap, llcp_cb.dlcb[idx].remote_sap, |
| llcp_cb.dlcb[idx].i_xmit_q.count); |
| |
| data.congest.local_sap = llcp_cb.dlcb[idx].local_sap; |
| data.congest.remote_sap = llcp_cb.dlcb[idx].remote_sap; |
| |
| (*llcp_cb.dlcb[idx].p_app_cb->p_app_cback) (&data); |
| } |
| } |
| idx = (idx + 1) % LLCP_MAX_DATA_LINK; |
| } |
| |
| /* move start point for next data link connection */ |
| for (xx = 0; xx < LLCP_MAX_DATA_LINK; xx++ ) |
| { |
| idx = (llcp_cb.dl_tx_uncongest_ntf_start_idx + 1) % LLCP_MAX_DATA_LINK; |
| if (llcp_cb.dlcb[idx].state == LLCP_DLC_STATE_CONNECTED) |
| { |
| llcp_cb.dl_tx_uncongest_ntf_start_idx = idx; |
| break; |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_send_SYMM |
| ** |
| ** Description Send SYMM PDU |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_send_SYMM (void) |
| { |
| BT_HDR *p_msg; |
| UINT8 *p; |
| |
| p_msg = (BT_HDR*) GKI_getpoolbuf (LLCP_POOL_ID); |
| |
| if (p_msg) |
| { |
| p_msg->len = LLCP_PDU_SYMM_SIZE; |
| p_msg->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; |
| |
| p = (UINT8 *) (p_msg + 1) + p_msg->offset; |
| UINT16_TO_BE_STREAM (p, LLCP_GET_PDU_HEADER (LLCP_SAP_LM, LLCP_PDU_SYMM_TYPE, LLCP_SAP_LM )); |
| |
| llcp_link_send_to_lower (p_msg); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_send_invalid_pdu |
| ** |
| ** Description Send invalid LLC PDU in LLCP_LINK_STATE_ACTIVATION_FAILED |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_send_invalid_pdu (void) |
| { |
| BT_HDR *p_msg; |
| UINT8 *p; |
| |
| p_msg = (BT_HDR*) GKI_getpoolbuf (LLCP_POOL_ID); |
| |
| if (p_msg) |
| { |
| /* send one byte of 0x00 as invalid LLC PDU */ |
| p_msg->len = 1; |
| p_msg->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; |
| |
| p = (UINT8 *) (p_msg + 1) + p_msg->offset; |
| *p = 0x00; |
| |
| NFC_SendData (NFC_RF_CONN_ID, p_msg); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_check_send_data |
| ** |
| ** Description Send PDU to peer |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void llcp_link_check_send_data (void) |
| { |
| BT_HDR *p_pdu; |
| |
| /* don't re-enter while processing to prevent out of sequence */ |
| if (llcp_cb.lcb.is_sending_data) |
| return; |
| else |
| llcp_cb.lcb.is_sending_data = TRUE; |
| |
| /* |
| ** check overall congestion due to high usage of buffer pool |
| ** if congested then notify all of upper layers not to send any more data |
| */ |
| llcp_link_check_congestion (); |
| |
| if (llcp_cb.lcb.symm_state == LLCP_LINK_SYMM_LOCAL_XMIT_NEXT) |
| { |
| LLCP_TRACE_DEBUG0 ("llcp_link_check_send_data () in state of LLCP_LINK_SYMM_LOCAL_XMIT_NEXT"); |
| |
| p_pdu = llcp_link_build_next_pdu (NULL); |
| |
| /* |
| ** For data link connection, |
| ** V(RA) was updated and N(R) was set to V(RA), if I PDU was added in this transmission. |
| ** If there was no I PDU to carry V(RA) and V(RA) is not V(R) and it's not congested, |
| ** then RR PDU will be sent. |
| ** If there was no I PDU to carry V(RA) and V(RA) is not V(R) and it's congested, |
| ** then RNR PDU will be sent. |
| ** If local busy state has been changed then RR or RNR PDU may be sent. |
| */ |
| llcp_dlc_check_to_send_rr_rnr (); |
| |
| /* add RR/RNR PDU to be sent if any */ |
| p_pdu = llcp_link_build_next_pdu (p_pdu); |
| |
| if (p_pdu != NULL) |
| { |
| llcp_link_send_to_lower (p_pdu); |
| |
| /* stop inactivity timer */ |
| llcp_link_stop_inactivity_timer (); |
| |
| /* check congestion status after sending out some data */ |
| llcp_link_check_uncongested (); |
| } |
| else |
| { |
| /* There is no data to send, so send SYMM */ |
| if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATED) |
| { |
| if (llcp_cb.lcb.symm_delay > 0) |
| { |
| /* wait for application layer sending data */ |
| llcp_link_start_link_timer (); |
| llcp_cb.lcb.is_sending_data = FALSE; |
| return; |
| } |
| else |
| { |
| llcp_link_send_SYMM (); |
| |
| /* start inactivity timer */ |
| if (llcp_cb.num_data_link_connection == 0) |
| { |
| llcp_link_start_inactivity_timer (); |
| } |
| } |
| } |
| else |
| { |
| llcp_cb.lcb.is_sending_data = FALSE; |
| return; |
| } |
| } |
| |
| if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_DEACTIVATING) |
| { |
| /* wait for short period for NFCC to send DISC */ |
| nfc_start_quick_timer (&llcp_cb.lcb.timer, NFC_TTYPE_LLCP_LINK_MANAGER, |
| ((UINT32) 50) * QUICK_TIMER_TICKS_PER_SEC / 1000); |
| } |
| else |
| { |
| /* wait for data to receive from remote */ |
| llcp_link_start_link_timer (); |
| } |
| } |
| |
| llcp_cb.lcb.is_sending_data = FALSE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_proc_ui_pdu |
| ** |
| ** Description Process UI PDU from peer device |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| static void llcp_link_proc_ui_pdu (UINT8 local_sap, |
| UINT8 remote_sap, |
| UINT16 ui_pdu_length, |
| UINT8 *p_ui_pdu, |
| BT_HDR *p_msg) |
| { |
| BOOLEAN appended; |
| BT_HDR *p_last_buf; |
| UINT16 available_bytes; |
| UINT8 *p_dst; |
| tLLCP_APP_CB *p_app_cb; |
| tLLCP_SAP_CBACK_DATA data; |
| tLLCP_DLCB *p_dlcb; |
| |
| p_app_cb = llcp_util_get_app_cb (local_sap); |
| /*if UI PDU sent to SAP with data link connection*/ |
| if ((p_dlcb = llcp_dlc_find_dlcb_by_sap (local_sap, remote_sap))) |
| { |
| llcp_util_send_frmr (p_dlcb, LLCP_FRMR_W_ERROR_FLAG, LLCP_PDU_UI_TYPE, 0); |
| llcp_dlsm_execute (p_dlcb, LLCP_DLC_EVENT_FRAME_ERROR, NULL); |
| if (p_msg) |
| { |
| GKI_freebuf (p_msg); |
| } |
| return; |
| } |
| |
| /* if application is registered and expecting UI PDU on logical data link */ |
| if ( (p_app_cb) |
| &&(p_app_cb->p_app_cback) |
| &&(p_app_cb->link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) ) |
| { |
| LLCP_TRACE_DEBUG2 ("llcp_link_proc_ui_pdu () Local SAP:0x%x, Remote SAP:0x%x", local_sap, remote_sap); |
| |
| /* if this is not from AGF PDU */ |
| if (p_msg) |
| { |
| ui_pdu_length = p_msg->len; /* including LLCP header */ |
| p_ui_pdu = (UINT8*) (p_msg + 1) + p_msg->offset; |
| } |
| |
| appended = FALSE; |
| |
| /* get last buffer in rx queue */ |
| p_last_buf = (BT_HDR *) GKI_getlast (&p_app_cb->ui_rx_q); |
| |
| if (p_last_buf) |
| { |
| /* get max length to append at the end of buffer */ |
| available_bytes = GKI_get_buf_size (p_last_buf) - BT_HDR_SIZE - p_last_buf->offset - p_last_buf->len; |
| |
| /* if new UI PDU with length can be attached at the end of buffer */ |
| if (available_bytes >= LLCP_PDU_AGF_LEN_SIZE + ui_pdu_length) |
| { |
| p_dst = (UINT8*) (p_last_buf + 1) + p_last_buf->offset + p_last_buf->len; |
| |
| /* add length of UI PDU */ |
| UINT16_TO_BE_STREAM (p_dst, ui_pdu_length); |
| |
| /* copy UI PDU with LLCP header */ |
| memcpy (p_dst, p_ui_pdu, ui_pdu_length); |
| |
| p_last_buf->len += LLCP_PDU_AGF_LEN_SIZE + ui_pdu_length; |
| |
| if (p_msg) |
| GKI_freebuf (p_msg); |
| |
| appended = TRUE; |
| } |
| } |
| |
| /* if it is not available to append */ |
| if (!appended) |
| { |
| /* if it's not from AGF PDU */ |
| if (p_msg) |
| { |
| /* add length of PDU in front of UI PDU (reuse room for NCI header) */ |
| p_ui_pdu -= LLCP_PDU_AGF_LEN_SIZE; |
| UINT16_TO_BE_STREAM (p_ui_pdu, ui_pdu_length); |
| |
| p_msg->offset -= LLCP_PDU_AGF_LEN_SIZE; |
| p_msg->len += LLCP_PDU_AGF_LEN_SIZE; |
| p_msg->layer_specific = 0; |
| } |
| else |
| { |
| p_msg = (BT_HDR *) GKI_getpoolbuf (LLCP_POOL_ID); |
| |
| if (p_msg) |
| { |
| p_dst = (UINT8*) (p_msg + 1); |
| |
| /* add length of PDU in front of UI PDU */ |
| UINT16_TO_BE_STREAM (p_dst, ui_pdu_length); |
| |
| memcpy (p_dst, p_ui_pdu, ui_pdu_length); |
| |
| p_msg->offset = 0; |
| p_msg->len = LLCP_PDU_AGF_LEN_SIZE + ui_pdu_length; |
| p_msg->layer_specific = 0; |
| } |
| else |
| { |
| LLCP_TRACE_ERROR0 ("llcp_link_proc_ui_pdu (): out of buffer"); |
| } |
| } |
| |
| /* insert UI PDU in rx queue */ |
| if (p_msg) |
| { |
| GKI_enqueue (&p_app_cb->ui_rx_q, p_msg); |
| llcp_cb.total_rx_ui_pdu++; |
| } |
| } |
| |
| if (p_app_cb->ui_rx_q.count > llcp_cb.ll_rx_congest_start) |
| { |
| LLCP_TRACE_WARNING2 ("llcp_link_proc_ui_pdu (): SAP:0x%x, rx link is congested (%d), discard oldest UI PDU", |
| local_sap, p_app_cb->ui_rx_q.count); |
| |
| GKI_freebuf (GKI_dequeue (&p_app_cb->ui_rx_q)); |
| llcp_cb.total_rx_ui_pdu--; |
| } |
| |
| if ((p_app_cb->ui_rx_q.count == 1) && (appended == FALSE)) |
| { |
| data.data_ind.event = LLCP_SAP_EVT_DATA_IND; |
| data.data_ind.local_sap = local_sap; |
| data.data_ind.remote_sap = remote_sap; |
| data.data_ind.link_type = LLCP_LINK_TYPE_LOGICAL_DATA_LINK; |
| (*p_app_cb->p_app_cback) (&data); |
| } |
| } |
| else |
| { |
| LLCP_TRACE_ERROR1 ("llcp_link_proc_ui_pdu (): Unregistered SAP:0x%x", local_sap); |
| |
| if (p_msg) |
| { |
| GKI_freebuf (p_msg); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_proc_agf_pdu |
| ** |
| ** Description Process AGF PDU from peer device |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_proc_agf_pdu (BT_HDR *p_agf) |
| { |
| UINT16 agf_length; |
| UINT8 *p, *p_info, *p_pdu_length; |
| UINT16 pdu_hdr, pdu_length; |
| UINT8 dsap, ptype, ssap; |
| |
| p_agf->len -= LLCP_PDU_HEADER_SIZE; |
| p_agf->offset += LLCP_PDU_HEADER_SIZE; |
| |
| /* |
| ** check integrity of AGF PDU and get number of PDUs in AGF PDU |
| */ |
| agf_length = p_agf->len; |
| p = (UINT8 *) (p_agf + 1) + p_agf->offset; |
| |
| while (agf_length > 0) |
| { |
| if (agf_length > LLCP_PDU_AGF_LEN_SIZE) |
| { |
| BE_STREAM_TO_UINT16 (pdu_length, p); |
| agf_length -= LLCP_PDU_AGF_LEN_SIZE; |
| } |
| else |
| { |
| break; |
| } |
| |
| if (pdu_length <= agf_length) |
| { |
| p += pdu_length; |
| agf_length -= pdu_length; |
| } |
| else |
| { |
| break; |
| } |
| } |
| |
| if (agf_length != 0) |
| { |
| LLCP_TRACE_ERROR0 ("llcp_link_proc_agf_pdu (): Received invalid AGF PDU"); |
| GKI_freebuf (p_agf); |
| return; |
| } |
| |
| /* |
| ** Process PDUs in AGF |
| */ |
| agf_length = p_agf->len; |
| p = (UINT8 *) (p_agf + 1) + p_agf->offset; |
| |
| while (agf_length > 0) |
| { |
| /* get length of PDU */ |
| p_pdu_length = p; |
| BE_STREAM_TO_UINT16 (pdu_length, p); |
| agf_length -= LLCP_PDU_AGF_LEN_SIZE; |
| |
| /* get DSAP/PTYPE/SSAP */ |
| p_info = p; |
| BE_STREAM_TO_UINT16 (pdu_hdr, p_info ); |
| |
| dsap = LLCP_GET_DSAP (pdu_hdr); |
| ptype = (UINT8) (LLCP_GET_PTYPE (pdu_hdr)); |
| ssap = LLCP_GET_SSAP (pdu_hdr); |
| |
| #if (BT_TRACE_VERBOSE == TRUE) |
| LLCP_TRACE_DEBUG4 ("llcp_link_proc_agf_pdu (): Rx DSAP:0x%x, PTYPE:%s (0x%x), SSAP:0x%x in AGF", |
| dsap, llcp_pdu_type (ptype), ptype, ssap); |
| #endif |
| |
| if ( (ptype == LLCP_PDU_DISC_TYPE) |
| &&(dsap == LLCP_SAP_LM) |
| &&(ssap == LLCP_SAP_LM) ) |
| { |
| GKI_freebuf (p_agf); |
| llcp_link_deactivate (LLCP_LINK_REMOTE_INITIATED); |
| return; |
| } |
| else if (ptype == LLCP_PDU_SYMM_TYPE) |
| { |
| LLCP_TRACE_ERROR0 ("llcp_link_proc_agf_pdu (): SYMM PDU exchange shall not be in AGF"); |
| } |
| else if (ptype == LLCP_PDU_PAX_TYPE) |
| { |
| LLCP_TRACE_ERROR0 ("llcp_link_proc_agf_pdu (): PAX PDU exchange shall not be used"); |
| } |
| else if (ptype == LLCP_PDU_SNL_TYPE) |
| { |
| llcp_sdp_proc_snl ((UINT16) (pdu_length - LLCP_PDU_HEADER_SIZE), p_info); |
| } |
| else if ((ptype == LLCP_PDU_UI_TYPE) && (pdu_length > LLCP_PDU_HEADER_SIZE)) |
| { |
| llcp_link_proc_ui_pdu (dsap, ssap, pdu_length, p, NULL); |
| } |
| else if (ptype == LLCP_PDU_I_TYPE) |
| { |
| llcp_dlc_proc_i_pdu (dsap, ssap, pdu_length, p, NULL); |
| } |
| else /* let data link connection handle PDU */ |
| { |
| llcp_dlc_proc_rx_pdu (dsap, ptype, ssap, (UINT16) (pdu_length - LLCP_PDU_HEADER_SIZE), p_info); |
| } |
| |
| p += pdu_length; |
| agf_length -= pdu_length; |
| } |
| |
| GKI_freebuf (p_agf); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_proc_rx_pdu |
| ** |
| ** Description Process received PDU from peer device |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_proc_rx_pdu (UINT8 dsap, UINT8 ptype, UINT8 ssap, BT_HDR *p_msg) |
| { |
| BOOLEAN free_buffer = TRUE; |
| UINT8 *p_data; |
| |
| switch (ptype) |
| { |
| case LLCP_PDU_PAX_TYPE: |
| LLCP_TRACE_ERROR0 ("llcp_link_proc_rx_pdu (); PAX PDU exchange shall not be used"); |
| break; |
| |
| case LLCP_PDU_DISC_TYPE: |
| if ((dsap == LLCP_SAP_LM) && (ssap == LLCP_SAP_LM)) |
| { |
| llcp_link_deactivate (LLCP_LINK_REMOTE_INITIATED); |
| } |
| else |
| { |
| p_data = (UINT8 *) (p_msg + 1) + p_msg->offset + LLCP_PDU_HEADER_SIZE; |
| llcp_dlc_proc_rx_pdu (dsap, ptype, ssap, (UINT16) (p_msg->len - LLCP_PDU_HEADER_SIZE), p_data); |
| } |
| break; |
| |
| case LLCP_PDU_SNL_TYPE: |
| p_data = (UINT8 *) (p_msg + 1) + p_msg->offset + LLCP_PDU_HEADER_SIZE; |
| llcp_sdp_proc_snl ((UINT16) (p_msg->len - LLCP_PDU_HEADER_SIZE), p_data); |
| break; |
| |
| case LLCP_PDU_AGF_TYPE: |
| llcp_link_proc_agf_pdu (p_msg); |
| free_buffer = FALSE; |
| break; |
| |
| case LLCP_PDU_UI_TYPE: |
| llcp_link_proc_ui_pdu (dsap, ssap, 0, NULL, p_msg); |
| free_buffer = FALSE; |
| break; |
| |
| case LLCP_PDU_I_TYPE: |
| llcp_dlc_proc_i_pdu (dsap, ssap, 0, NULL, p_msg); |
| free_buffer = FALSE; |
| break; |
| |
| default: |
| p_data = (UINT8 *) (p_msg + 1) + p_msg->offset + LLCP_PDU_HEADER_SIZE; |
| llcp_dlc_proc_rx_pdu (dsap, ptype, ssap, (UINT16) (p_msg->len - LLCP_PDU_HEADER_SIZE), p_data); |
| break; |
| } |
| |
| if (free_buffer) |
| GKI_freebuf (p_msg); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_proc_rx_data |
| ** |
| ** Description Process received data from NFCC and maintain symmetry state |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_proc_rx_data (BT_HDR *p_msg) |
| { |
| UINT8 *p; |
| UINT16 pdu_hdr, info_length = 0; |
| UINT8 dsap, ptype, ssap; |
| BOOLEAN free_buffer = TRUE; |
| BOOLEAN frame_error = FALSE; |
| |
| if (llcp_cb.lcb.symm_state == LLCP_LINK_SYMM_REMOTE_XMIT_NEXT) |
| { |
| llcp_link_stop_link_timer (); |
| |
| if (llcp_cb.lcb.received_first_packet == FALSE) |
| { |
| llcp_cb.lcb.received_first_packet = TRUE; |
| (*llcp_cb.lcb.p_link_cback) (LLCP_LINK_FIRST_PACKET_RECEIVED_EVT, LLCP_LINK_SUCCESS); |
| } |
| if ( (llcp_cb.lcb.link_state == LLCP_LINK_STATE_DEACTIVATING) |
| &&(llcp_cb.lcb.sig_xmit_q.count == 0) ) |
| { |
| /* this indicates that DISC PDU had been sent out to peer */ |
| /* initiator may wait for SYMM PDU */ |
| llcp_link_process_link_timeout (); |
| } |
| else |
| { |
| if (p_msg->len < LLCP_PDU_HEADER_SIZE) |
| { |
| LLCP_TRACE_ERROR1 ("Received too small PDU: got %d bytes", p_msg->len); |
| frame_error = TRUE; |
| } |
| else |
| { |
| p = (UINT8 *) (p_msg + 1) + p_msg->offset; |
| BE_STREAM_TO_UINT16 (pdu_hdr, p ); |
| |
| dsap = LLCP_GET_DSAP (pdu_hdr); |
| ptype = (UINT8) (LLCP_GET_PTYPE (pdu_hdr)); |
| ssap = LLCP_GET_SSAP (pdu_hdr); |
| |
| /* get length of information per PDU type */ |
| if ( (ptype == LLCP_PDU_I_TYPE) |
| ||(ptype == LLCP_PDU_RR_TYPE) |
| ||(ptype == LLCP_PDU_RNR_TYPE) ) |
| { |
| if (p_msg->len >= LLCP_PDU_HEADER_SIZE + LLCP_SEQUENCE_SIZE) |
| { |
| info_length = p_msg->len - LLCP_PDU_HEADER_SIZE - LLCP_SEQUENCE_SIZE; |
| } |
| else |
| { |
| LLCP_TRACE_ERROR0 ("Received I/RR/RNR PDU without sequence"); |
| frame_error = TRUE; |
| } |
| } |
| else |
| { |
| info_length = p_msg->len - LLCP_PDU_HEADER_SIZE; |
| } |
| |
| /* check if length of information is bigger than link MIU */ |
| if ((!frame_error) && (info_length > llcp_cb.lcb.local_link_miu)) |
| { |
| LLCP_TRACE_ERROR2 ("Received exceeding MIU (%d): got %d bytes SDU", |
| llcp_cb.lcb.local_link_miu, info_length); |
| |
| frame_error = TRUE; |
| } |
| else |
| { |
| #if (BT_TRACE_VERBOSE == TRUE) |
| LLCP_TRACE_DEBUG4 ("llcp_link_proc_rx_data (): DSAP:0x%x, PTYPE:%s (0x%x), SSAP:0x%x", |
| dsap, llcp_pdu_type (ptype), ptype, ssap); |
| #endif |
| |
| if (ptype == LLCP_PDU_SYMM_TYPE) |
| { |
| if (info_length > 0) |
| { |
| LLCP_TRACE_ERROR1 ("Received extra data (%d bytes) in SYMM PDU", info_length); |
| frame_error = TRUE; |
| } |
| } |
| else |
| { |
| /* received other than SYMM */ |
| llcp_link_stop_inactivity_timer (); |
| |
| llcp_link_proc_rx_pdu (dsap, ptype, ssap, p_msg); |
| free_buffer = FALSE; |
| } |
| } |
| } |
| |
| llcp_cb.lcb.symm_state = LLCP_LINK_SYMM_LOCAL_XMIT_NEXT; |
| |
| /* check if any pending packet */ |
| llcp_link_check_send_data (); |
| } |
| } |
| else |
| { |
| LLCP_TRACE_ERROR0 ("Received PDU in state of SYMM_MUST_XMIT_NEXT"); |
| } |
| |
| if (free_buffer) |
| GKI_freebuf (p_msg); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_get_next_pdu |
| ** |
| ** Description Get next PDU from link manager or data links w/wo dequeue |
| ** |
| ** Returns pointer of a PDU to send if length_only is FALSE |
| ** NULL otherwise |
| ** |
| *******************************************************************************/ |
| static BT_HDR *llcp_link_get_next_pdu (BOOLEAN length_only, UINT16 *p_next_pdu_length) |
| { |
| BT_HDR *p_msg; |
| int count, xx; |
| tLLCP_APP_CB *p_app_cb; |
| |
| /* processing signalling PDU first */ |
| if (llcp_cb.lcb.sig_xmit_q.p_first) |
| { |
| if (length_only) |
| { |
| p_msg = (BT_HDR*) llcp_cb.lcb.sig_xmit_q.p_first; |
| *p_next_pdu_length = p_msg->len; |
| return NULL; |
| } |
| else |
| p_msg = (BT_HDR*) GKI_dequeue (&llcp_cb.lcb.sig_xmit_q); |
| |
| return p_msg; |
| } |
| else |
| { |
| /* transmitting logical data link and data link connection equaly */ |
| for (xx = 0; xx < 2; xx++) |
| { |
| if (!llcp_cb.lcb.ll_served) |
| { |
| /* Get one from logical link connection */ |
| for (count = 0; count < LLCP_NUM_SAPS; count++) |
| { |
| /* round robin schedule without priority */ |
| p_app_cb = llcp_util_get_app_cb (llcp_cb.lcb.ll_idx); |
| |
| if ( (p_app_cb) |
| &&(p_app_cb->p_app_cback) |
| &&(p_app_cb->ui_xmit_q.count) ) |
| { |
| if (length_only) |
| { |
| /* don't alternate next data link to return the same length of PDU */ |
| p_msg = (BT_HDR *) p_app_cb->ui_xmit_q.p_first; |
| *p_next_pdu_length = p_msg->len; |
| return NULL; |
| } |
| else |
| { |
| /* check data link connection first in next time */ |
| llcp_cb.lcb.ll_served = !llcp_cb.lcb.ll_served; |
| |
| p_msg = (BT_HDR*) GKI_dequeue (&p_app_cb->ui_xmit_q); |
| llcp_cb.total_tx_ui_pdu--; |
| |
| /* this logical link has been served, so start from next logical link next time */ |
| llcp_cb.lcb.ll_idx = (llcp_cb.lcb.ll_idx + 1) % LLCP_NUM_SAPS; |
| |
| return p_msg; |
| } |
| } |
| else |
| { |
| /* check next logical link connection */ |
| llcp_cb.lcb.ll_idx = (llcp_cb.lcb.ll_idx + 1) % LLCP_NUM_SAPS; |
| } |
| } |
| |
| /* no data, so check data link connection if not checked yet */ |
| llcp_cb.lcb.ll_served = !llcp_cb.lcb.ll_served; |
| } |
| else |
| { |
| /* Get one from data link connection */ |
| for (count = 0; count < LLCP_MAX_DATA_LINK; count++) |
| { |
| /* round robin schedule without priority */ |
| if (llcp_cb.dlcb[llcp_cb.lcb.dl_idx].state != LLCP_DLC_STATE_IDLE) |
| { |
| if (length_only) |
| { |
| *p_next_pdu_length = llcp_dlc_get_next_pdu_length (&llcp_cb.dlcb[llcp_cb.lcb.dl_idx]); |
| |
| if (*p_next_pdu_length > 0 ) |
| { |
| /* don't change data link connection to return the same length of PDU */ |
| return NULL; |
| } |
| else |
| { |
| /* no data, so check next data link connection */ |
| llcp_cb.lcb.dl_idx = (llcp_cb.lcb.dl_idx + 1) % LLCP_MAX_DATA_LINK; |
| } |
| } |
| else |
| { |
| p_msg = llcp_dlc_get_next_pdu (&llcp_cb.dlcb[llcp_cb.lcb.dl_idx]); |
| |
| /* this data link has been served, so start from next data link next time */ |
| llcp_cb.lcb.dl_idx = (llcp_cb.lcb.dl_idx + 1) % LLCP_MAX_DATA_LINK; |
| |
| if (p_msg) |
| { |
| /* serve logical data link next time */ |
| llcp_cb.lcb.ll_served = !llcp_cb.lcb.ll_served; |
| return p_msg; |
| } |
| } |
| } |
| else |
| { |
| /* check next data link connection */ |
| llcp_cb.lcb.dl_idx = (llcp_cb.lcb.dl_idx + 1) % LLCP_MAX_DATA_LINK; |
| } |
| } |
| |
| /* if all of data link connection doesn't have data to send */ |
| if (count >= LLCP_MAX_DATA_LINK) |
| { |
| llcp_cb.lcb.ll_served = !llcp_cb.lcb.ll_served; |
| } |
| } |
| } |
| } |
| |
| /* nothing to send */ |
| *p_next_pdu_length = 0; |
| return NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_build_next_pdu |
| ** |
| ** Description Build a PDU from Link Manager and Data Link |
| ** Perform aggregation procedure if necessary |
| ** |
| ** Returns BT_HDR* if sent any PDU |
| ** |
| *******************************************************************************/ |
| static BT_HDR *llcp_link_build_next_pdu (BT_HDR *p_pdu) |
| { |
| BT_HDR *p_agf = NULL, *p_msg = NULL, *p_next_pdu; |
| UINT8 *p, ptype; |
| UINT16 next_pdu_length, pdu_hdr; |
| |
| LLCP_TRACE_DEBUG0 ("llcp_link_build_next_pdu ()"); |
| |
| /* add any pending SNL PDU into sig_xmit_q for transmitting */ |
| llcp_sdp_check_send_snl (); |
| |
| if (p_pdu) |
| { |
| /* get PDU type */ |
| p = (UINT8 *) (p_pdu + 1) + p_pdu->offset; |
| BE_STREAM_TO_UINT16 (pdu_hdr, p); |
| |
| ptype = (UINT8) (LLCP_GET_PTYPE (pdu_hdr)); |
| |
| if (ptype == LLCP_PDU_AGF_TYPE) |
| { |
| /* add more PDU into this AGF PDU */ |
| p_agf = p_pdu; |
| } |
| else |
| { |
| p_msg = p_pdu; |
| } |
| } |
| else |
| { |
| /* Get a PDU from link manager or data links */ |
| p_msg = llcp_link_get_next_pdu (FALSE, &next_pdu_length); |
| |
| if (!p_msg) |
| { |
| return NULL; |
| } |
| } |
| |
| /* Get length of next PDU from link manager or data links without dequeue */ |
| llcp_link_get_next_pdu (TRUE, &next_pdu_length); |
| while (next_pdu_length > 0) |
| { |
| /* if it's first visit */ |
| if (!p_agf) |
| { |
| /* if next PDU fits into MIU, allocate AGF PDU and copy the first PDU */ |
| if (2 + p_msg->len + 2 + next_pdu_length <= llcp_cb.lcb.effective_miu) |
| { |
| p_agf = (BT_HDR*) GKI_getpoolbuf (LLCP_POOL_ID); |
| if (p_agf) |
| { |
| p_agf->offset = NCI_MSG_OFFSET_SIZE + NCI_DATA_HDR_SIZE; |
| |
| p = (UINT8 *) (p_agf + 1) + p_agf->offset; |
| |
| UINT16_TO_BE_STREAM (p, LLCP_GET_PDU_HEADER (LLCP_SAP_LM, LLCP_PDU_AGF_TYPE, LLCP_SAP_LM )); |
| UINT16_TO_BE_STREAM (p, p_msg->len); |
| memcpy(p, (UINT8 *) (p_msg + 1) + p_msg->offset, p_msg->len); |
| |
| p_agf->len = LLCP_PDU_HEADER_SIZE + 2 + p_msg->len; |
| |
| GKI_freebuf (p_msg); |
| p_msg = p_agf; |
| } |
| else |
| { |
| LLCP_TRACE_ERROR0 ("llcp_link_build_next_pdu (): Out of buffer"); |
| return p_msg; |
| } |
| } |
| else |
| { |
| break; |
| } |
| } |
| |
| /* if next PDU fits into MIU, copy the next PDU into AGF */ |
| if (p_agf->len - LLCP_PDU_HEADER_SIZE + 2 + next_pdu_length <= llcp_cb.lcb.effective_miu) |
| { |
| /* Get a next PDU from link manager or data links */ |
| p_next_pdu = llcp_link_get_next_pdu (FALSE, &next_pdu_length); |
| |
| p = (UINT8 *) (p_agf + 1) + p_agf->offset + p_agf->len; |
| |
| UINT16_TO_BE_STREAM (p, p_next_pdu->len); |
| memcpy (p, (UINT8 *) (p_next_pdu + 1) + p_next_pdu->offset, p_next_pdu->len); |
| |
| p_agf->len += 2 + p_next_pdu->len; |
| |
| GKI_freebuf (p_next_pdu); |
| |
| /* Get next PDU length from link manager or data links without dequeue */ |
| llcp_link_get_next_pdu (TRUE, &next_pdu_length); |
| } |
| else |
| { |
| break; |
| } |
| } |
| |
| if (p_agf) |
| return p_agf; |
| else |
| return p_msg; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_send_to_lower |
| ** |
| ** Description Send PDU to lower layer |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| static void llcp_link_send_to_lower (BT_HDR *p_pdu) |
| { |
| #if (BT_TRACE_PROTOCOL == TRUE) |
| DispLLCP (p_pdu, FALSE); |
| #endif |
| |
| llcp_cb.lcb.symm_state = LLCP_LINK_SYMM_REMOTE_XMIT_NEXT; |
| |
| NFC_SendData (NFC_RF_CONN_ID, p_pdu); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function llcp_link_connection_cback |
| ** |
| ** Description processing incoming data |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void llcp_link_connection_cback (UINT8 conn_id, tNFC_CONN_EVT event, tNFC_CONN *p_data) |
| { |
| if (event == NFC_DATA_CEVT) |
| { |
| #if (BT_TRACE_PROTOCOL == TRUE) |
| DispLLCP ((BT_HDR *)p_data->data.p_data, TRUE); |
| #endif |
| if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_DEACTIVATED) |
| { |
| /* respoding SYMM while LLCP is deactivated but RF link is not deactivated yet */ |
| llcp_link_send_SYMM (); |
| GKI_freebuf ((BT_HDR *) p_data->data.p_data); |
| } |
| else if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATION_FAILED) |
| { |
| /* respoding with invalid LLC PDU until initiator deactivates RF link after LLCP activation was failed, |
| ** so that initiator knows LLCP link activation was failed. |
| */ |
| llcp_link_send_invalid_pdu (); |
| GKI_freebuf ((BT_HDR *) p_data->data.p_data); |
| } |
| else |
| { |
| llcp_cb.lcb.flags |= LLCP_LINK_FLAGS_RX_ANY_LLC_PDU; |
| llcp_link_proc_rx_data ((BT_HDR *) p_data->data.p_data); |
| } |
| } |
| else if (event == NFC_ERROR_CEVT) |
| { |
| /* RF interface specific status code */ |
| llcp_link_deactivate (*(UINT8*) p_data); |
| } |
| else if (event == NFC_DEACTIVATE_CEVT) |
| { |
| if ( (llcp_cb.lcb.link_state == LLCP_LINK_STATE_DEACTIVATING) |
| &&(!llcp_cb.lcb.is_initiator) ) |
| { |
| /* peer initiates NFC link deactivation before timeout */ |
| llcp_link_stop_link_timer (); |
| llcp_link_process_link_timeout (); |
| } |
| else if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATION_FAILED) |
| { |
| /* do not notify to upper layer because activation failure was already notified */ |
| NFC_FlushData (NFC_RF_CONN_ID); |
| llcp_cb.lcb.link_state = LLCP_LINK_STATE_DEACTIVATED; |
| } |
| else if (llcp_cb.lcb.link_state != LLCP_LINK_STATE_DEACTIVATED) |
| { |
| llcp_link_deactivate (LLCP_LINK_RF_LINK_LOSS_ERR); |
| } |
| |
| NFC_SetStaticRfCback (NULL); |
| } |
| else if (event == NFC_DATA_START_CEVT) |
| { |
| if (llcp_cb.lcb.symm_state == LLCP_LINK_SYMM_REMOTE_XMIT_NEXT) |
| { |
| /* LLCP shall stop LTO timer when receiving the first bit of LLC PDU */ |
| llcp_link_stop_link_timer (); |
| } |
| } |
| |
| /* LLCP ignores the following events |
| |
| NFC_CONN_CREATE_CEVT |
| NFC_CONN_CLOSE_CEVT |
| */ |
| } |
| |
| #if (BT_TRACE_VERBOSE == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function llcp_pdu_type |
| ** |
| ** Description |
| ** |
| ** Returns string of PDU type |
| ** |
| *******************************************************************************/ |
| static char *llcp_pdu_type (UINT8 ptype) |
| { |
| switch(ptype) |
| { |
| case LLCP_PDU_SYMM_TYPE: |
| return "SYMM"; |
| case LLCP_PDU_PAX_TYPE: |
| return "PAX"; |
| case LLCP_PDU_AGF_TYPE: |
| return "AGF"; |
| case LLCP_PDU_UI_TYPE: |
| return "UI"; |
| case LLCP_PDU_CONNECT_TYPE: |
| return "CONNECT"; |
| case LLCP_PDU_DISC_TYPE: |
| return "DISC"; |
| case LLCP_PDU_CC_TYPE: |
| return "CC"; |
| case LLCP_PDU_DM_TYPE: |
| return "DM"; |
| case LLCP_PDU_FRMR_TYPE: |
| return "FRMR"; |
| case LLCP_PDU_SNL_TYPE: |
| return "SNL"; |
| case LLCP_PDU_I_TYPE: |
| return "I"; |
| case LLCP_PDU_RR_TYPE: |
| return "RR"; |
| case LLCP_PDU_RNR_TYPE: |
| return "RNR"; |
| |
| default: |
| return "RESERVED"; |
| } |
| } |
| |
| #endif |
| |
