Google Git
Sign in
android / platform / system / nfc / 2d8445c0f5b4f6d963fa87ec54d95fc8f2f7a58c / . / src / nfc / llcp / llcp_api.cc
blob: 0ea8c8c4f997bedbb2cce612097e5b8c7bc64432 [file] [log] [blame]
/******************************************************************************
*
* 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 API code
*
******************************************************************************/
#include <android-base/stringprintf.h>
#include <base/logging.h>
#include "gki.h"
#include "llcp_api.h"
#include "llcp_int.h"
using android::base::StringPrintf;
extern bool nfc_debug_enabled;
#if (LLCP_TEST_INCLUDED == TRUE) /* this is for LLCP testing */
tLLCP_TEST_PARAMS llcp_test_params = {
LLCP_VERSION_VALUE, 0, /* not override */
};
/*******************************************************************************
**
** Function LLCP_SetTestParams
**
** Description Set test parameters for LLCP
**
**
** Returns void
**
*******************************************************************************/
void LLCP_SetTestParams(uint8_t version, uint16_t wks) {
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("version:0x%02X, wks:0x%04X", version, wks);
if (version != 0xFF) llcp_test_params.version = version;
if (wks != 0xFFFF) llcp_test_params.wks = wks;
}
#endif
/*******************************************************************************
**
** Function LLCP_RegisterDtaCback
**
** Description Register callback function for LLCP DTA testing
**
**
** Returns void
**
*******************************************************************************/
void LLCP_RegisterDtaCback(tLLCP_DTA_CBACK* p_dta_cback) {
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
llcp_cb.p_dta_cback = p_dta_cback;
}
/*******************************************************************************
**
** Function LLCP_SetConfig
**
** Description Set configuration parameters for LLCP
** - Local Link MIU
** - Option parameter
** - Response Waiting Time Index
** - Local Link Timeout
** - Inactivity Timeout as initiator role
** - Inactivity Timeout as target role
** - Delay SYMM response
** - Data link connection timeout
** - Delay timeout to send first PDU as initiator
**
** Returns void
**
*******************************************************************************/
void LLCP_SetConfig(uint16_t link_miu, uint8_t opt, uint8_t wt,
uint16_t link_timeout, uint16_t inact_timeout_init,
uint16_t inact_timeout_target, uint16_t symm_delay,
uint16_t data_link_timeout,
uint16_t delay_first_pdu_timeout) {
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("link_miu:%d, opt:0x%02X, wt:%d, link_timeout:%d",
link_miu, opt, wt, link_timeout);
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
" inact_timeout (init:%d,target:%d), symm_delay:%d, "
"data_link_timeout:%d",
inact_timeout_init, inact_timeout_target, symm_delay, data_link_timeout);
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
" delay_first_pdu_timeout:%d", delay_first_pdu_timeout);
if (link_miu < LLCP_DEFAULT_MIU) {
LOG(ERROR) << StringPrintf(
"link_miu shall not be smaller than "
"LLCP_DEFAULT_MIU (%d)",
LLCP_DEFAULT_MIU);
link_miu = LLCP_DEFAULT_MIU;
} else if (link_miu > LLCP_MAX_MIU) {
LOG(ERROR) << StringPrintf(
"link_miu shall not be bigger than LLCP_MAX_MIU "
"(%d)",
LLCP_MAX_MIU);
link_miu = LLCP_MAX_MIU;
}
/* if Link MIU is bigger than GKI buffer */
if (link_miu > LLCP_MIU) {
LOG(ERROR) << StringPrintf(
"link_miu shall not be bigger than LLCP_MIU (%zu)", LLCP_MIU);
llcp_cb.lcb.local_link_miu = LLCP_MIU;
} else
llcp_cb.lcb.local_link_miu = link_miu;
llcp_cb.lcb.local_opt = opt;
llcp_cb.lcb.local_wt = wt;
if (link_timeout < LLCP_LTO_UNIT) {
LOG(ERROR) << StringPrintf(
"link_timeout shall not be smaller than "
"LLCP_LTO_UNIT (%d ms)",
LLCP_LTO_UNIT);
llcp_cb.lcb.local_lto = LLCP_DEFAULT_LTO_IN_MS;
} else if (link_timeout > LLCP_MAX_LTO_IN_MS) {
LOG(ERROR) << StringPrintf(
"link_timeout shall not be bigger than "
"LLCP_MAX_LTO_IN_MS (%d ms)",
LLCP_MAX_LTO_IN_MS);
llcp_cb.lcb.local_lto = LLCP_MAX_LTO_IN_MS;
} else
llcp_cb.lcb.local_lto = link_timeout;
llcp_cb.lcb.inact_timeout_init = inact_timeout_init;
llcp_cb.lcb.inact_timeout_target = inact_timeout_target;
llcp_cb.lcb.symm_delay = symm_delay;
llcp_cb.lcb.data_link_timeout = data_link_timeout;
llcp_cb.lcb.delay_first_pdu_timeout = delay_first_pdu_timeout;
}
/*******************************************************************************
**
** Function LLCP_GetConfig
**
** Description Get configuration parameters for LLCP
** - Local Link MIU
** - Option parameter
** - Response Waiting Time Index
** - Local Link Timeout
** - Inactivity Timeout as initiator role
** - Inactivity Timeout as target role
** - Delay SYMM response
** - Data link connection timeout
** - Delay timeout to send first PDU as initiator
**
** Returns void
**
*******************************************************************************/
void LLCP_GetConfig(uint16_t* p_link_miu, uint8_t* p_opt, uint8_t* p_wt,
uint16_t* p_link_timeout, uint16_t* p_inact_timeout_init,
uint16_t* p_inact_timeout_target, uint16_t* p_symm_delay,
uint16_t* p_data_link_timeout,
uint16_t* p_delay_first_pdu_timeout) {
*p_link_miu = llcp_cb.lcb.local_link_miu;
*p_opt = llcp_cb.lcb.local_opt;
*p_wt = llcp_cb.lcb.local_wt;
*p_link_timeout = llcp_cb.lcb.local_lto;
*p_inact_timeout_init = llcp_cb.lcb.inact_timeout_init;
*p_inact_timeout_target = llcp_cb.lcb.inact_timeout_target;
*p_symm_delay = llcp_cb.lcb.symm_delay;
*p_data_link_timeout = llcp_cb.lcb.data_link_timeout;
*p_delay_first_pdu_timeout = llcp_cb.lcb.delay_first_pdu_timeout;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("link_miu:%d, opt:0x%02X, wt:%d, link_timeout:%d",
*p_link_miu, *p_opt, *p_wt, *p_link_timeout);
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"inact_timeout (init:%d, target:%d), symm_delay:%d, data_link_timeout:%d",
*p_inact_timeout_init, *p_inact_timeout_target, *p_symm_delay,
*p_data_link_timeout);
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("delay_first_pdu_timeout:%d", *p_delay_first_pdu_timeout);
}
/*******************************************************************************
**
** Function LLCP_GetDiscoveryConfig
**
** Description Returns discovery config for ISO 18092 MAC link activation
** This function is called to get general bytes for
** NFC_PMID_ATR_REQ_GEN_BYTES or NFC_PMID_ATR_RES_GEN_BYTES
** before starting discovery.
**
** wt:Waiting time 0 - 8, only for listen
** p_gen_bytes: pointer to store LLCP magic number and
** paramters
** p_gen_bytes_len: length of buffer for gen bytes as input
** (NOTE:it must be bigger than
** LLCP_MIN_GEN_BYTES) actual gen bytes size
** as output
**
** Restrictions on the use of ISO 18092
** 1. The DID features shall not be used.
** 2. the NAD features shall not be used.
** 3. Frame waiting time extentions (WTX) shall not be used.
**
** Returns None
**
*******************************************************************************/
void LLCP_GetDiscoveryConfig(uint8_t* p_wt, uint8_t* p_gen_bytes,
uint8_t* p_gen_bytes_len) {
uint8_t* p = p_gen_bytes;
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if (*p_gen_bytes_len < LLCP_MIN_GEN_BYTES) {
LOG(ERROR) << StringPrintf(
"GenBytes length shall not be smaller than "
"LLCP_MIN_GEN_BYTES (%d)",
LLCP_MIN_GEN_BYTES);
*p_gen_bytes_len = 0;
return;
}
*p_wt = llcp_cb.lcb.local_wt;
UINT8_TO_BE_STREAM(p, LLCP_MAGIC_NUMBER_BYTE0);
UINT8_TO_BE_STREAM(p, LLCP_MAGIC_NUMBER_BYTE1);
UINT8_TO_BE_STREAM(p, LLCP_MAGIC_NUMBER_BYTE2);
#if (LLCP_TEST_INCLUDED == TRUE) /* this is for LLCP testing */
UINT8_TO_BE_STREAM(p, LLCP_VERSION_TYPE);
UINT8_TO_BE_STREAM(p, LLCP_VERSION_LEN);
UINT8_TO_BE_STREAM(p, llcp_test_params.version);
UINT8_TO_BE_STREAM(p, LLCP_MIUX_TYPE);
UINT8_TO_BE_STREAM(p, LLCP_MIUX_LEN);
UINT16_TO_BE_STREAM(p, (llcp_cb.lcb.local_link_miu - LLCP_DEFAULT_MIU));
UINT8_TO_BE_STREAM(p, LLCP_WKS_TYPE);
UINT8_TO_BE_STREAM(p, LLCP_WKS_LEN);
if (llcp_test_params.wks == 0) /* not override */
{
UINT16_TO_BE_STREAM(p, llcp_cb.lcb.wks);
} else {
UINT16_TO_BE_STREAM(p, llcp_test_params.wks);
}
#else
UINT8_TO_BE_STREAM(p, LLCP_VERSION_TYPE);
UINT8_TO_BE_STREAM(p, LLCP_VERSION_LEN);
UINT8_TO_BE_STREAM(p, LLCP_VERSION_VALUE);
UINT8_TO_BE_STREAM(p, LLCP_MIUX_TYPE);
UINT8_TO_BE_STREAM(p, LLCP_MIUX_LEN);
UINT16_TO_BE_STREAM(p, (llcp_cb.lcb.local_link_miu - LLCP_DEFAULT_MIU));
UINT8_TO_BE_STREAM(p, LLCP_WKS_TYPE);
UINT8_TO_BE_STREAM(p, LLCP_WKS_LEN);
UINT16_TO_BE_STREAM(p, llcp_cb.lcb.wks);
#endif
UINT8_TO_BE_STREAM(p, LLCP_LTO_TYPE);
UINT8_TO_BE_STREAM(p, LLCP_LTO_LEN);
UINT8_TO_BE_STREAM(p, (llcp_cb.lcb.local_lto / LLCP_LTO_UNIT));
UINT8_TO_BE_STREAM(p, LLCP_OPT_TYPE);
UINT8_TO_BE_STREAM(p, LLCP_OPT_LEN);
UINT8_TO_BE_STREAM(p, llcp_cb.lcb.local_opt);
*p_gen_bytes_len = (uint8_t)(p - p_gen_bytes);
}
/*******************************************************************************
**
** Function LLCP_ActivateLink
**
** Description This function will activate LLCP link with LR, WT and Gen
** Bytes in activation NTF from NFCC.
**
** LLCP_LINK_ACTIVATION_COMPLETE_EVT will be returned through
** callback function if successful.
** Otherwise, LLCP_LINK_ACTIVATION_FAILED_EVT will be returned.
**
** Returns LLCP_STATUS_SUCCESS if success
**
*******************************************************************************/
tLLCP_STATUS LLCP_ActivateLink(tLLCP_ACTIVATE_CONFIG config,
tLLCP_LINK_CBACK* p_link_cback) {
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("link_state = %d", llcp_cb.lcb.link_state);
if ((llcp_cb.lcb.link_state == LLCP_LINK_STATE_DEACTIVATED) &&
(p_link_cback)) {
llcp_cb.lcb.p_link_cback = p_link_cback;
return (llcp_link_activate(&config));
} else
return LLCP_STATUS_FAIL;
}
/*******************************************************************************
**
** Function LLCP_DeactivateLink
**
** Description Deactivate LLCP link
**
** LLCP_LINK_DEACTIVATED_EVT will be returned through callback
** when LLCP link is deactivated. Then NFC link may be
** deactivated.
**
** Returns LLCP_STATUS_SUCCESS if success
**
*******************************************************************************/
tLLCP_STATUS LLCP_DeactivateLink(void) {
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("link_state = %d", llcp_cb.lcb.link_state);
if (llcp_cb.lcb.link_state != LLCP_LINK_STATE_DEACTIVATED) {
llcp_link_deactivate(LLCP_LINK_LOCAL_INITIATED);
return LLCP_STATUS_SUCCESS;
} else
return LLCP_STATUS_FAIL;
}
/*******************************************************************************
**
** Function LLCP_RegisterServer
**
** Description Register server and callback function
**
** reg_sap : Well-Known SAP except LM and SDP (0x02 - 0x0F)
** Advertized by SDP (0x10 - 0x1F)
** LLCP_INVALID_SAP, LLCP will allocate between 0x10
** and 0x1F
** link_type : LLCP_LINK_TYPE_LOGICAL_DATA_LINK
** and/or LLCP_LINK_TYPE_DATA_LINK_CONNECTION
** p_service_name : Null-terminated string up to
** LLCP_MAX_SN_LEN
**
** Returns SAP between 0x02 and 0x1F, if success
** LLCP_INVALID_SAP, otherwise
**
*******************************************************************************/
uint8_t LLCP_RegisterServer(uint8_t reg_sap, uint8_t link_type,
std::string p_service_name,
tLLCP_APP_CBACK* p_app_cback) {
uint8_t sap;
uint16_t length;
tLLCP_APP_CB* p_app_cb = {
nullptr,
};
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"SAP:0x%x, link_type:0x%x, ServiceName:<%s>", reg_sap, link_type,
((p_service_name.empty()) ? "" : p_service_name.c_str()));
if (!p_app_cback) {
LOG(ERROR) << StringPrintf("Callback must be provided");
return LLCP_INVALID_SAP;
} else if (((link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) == 0x00) &&
((link_type & LLCP_LINK_TYPE_DATA_LINK_CONNECTION) == 0x00)) {
LOG(ERROR) << StringPrintf("link type (0x%x) must be specified", link_type);
return LLCP_INVALID_SAP;
}
if (reg_sap == LLCP_INVALID_SAP) {
/* allocate a SAP between 0x10 and 0x1F */
for (sap = 0; sap < LLCP_MAX_SERVER; sap++) {
if (llcp_cb.server_cb[sap].p_app_cback == nullptr) {
p_app_cb = &llcp_cb.server_cb[sap];
reg_sap = LLCP_LOWER_BOUND_SDP_SAP + sap;
break;
}
}
if (reg_sap == LLCP_INVALID_SAP) {
LOG(ERROR) << StringPrintf("out of resource");
return LLCP_INVALID_SAP;
}
} else if (reg_sap == LLCP_SAP_LM) {
LOG(ERROR) << StringPrintf("SAP (0x%x) is for link manager", reg_sap);
return LLCP_INVALID_SAP;
} else if (reg_sap <= LLCP_UPPER_BOUND_WK_SAP) {
if (reg_sap >= LLCP_MAX_WKS) {
LOG(ERROR) << StringPrintf("out of resource for SAP (0x%x)", reg_sap);
return LLCP_INVALID_SAP;
} else if (llcp_cb.wks_cb[reg_sap].p_app_cback) {
LOG(ERROR) << StringPrintf("SAP (0x%x) is already registered", reg_sap);
return LLCP_INVALID_SAP;
} else {
p_app_cb = &llcp_cb.wks_cb[reg_sap];
}
} else if (reg_sap <= LLCP_UPPER_BOUND_SDP_SAP) {
if (reg_sap - LLCP_LOWER_BOUND_SDP_SAP >= LLCP_MAX_SERVER) {
LOG(ERROR) << StringPrintf("out of resource for SAP (0x%x)", reg_sap);
return LLCP_INVALID_SAP;
} else if (llcp_cb.server_cb[reg_sap - LLCP_LOWER_BOUND_SDP_SAP]
.p_app_cback) {
LOG(ERROR) << StringPrintf("SAP (0x%x) is already registered", reg_sap);
return LLCP_INVALID_SAP;
} else {
p_app_cb = &llcp_cb.server_cb[reg_sap - LLCP_LOWER_BOUND_SDP_SAP];
}
} else if (reg_sap >= LLCP_LOWER_BOUND_LOCAL_SAP) {
LOG(ERROR) << StringPrintf("SAP (0x%x) must be less than 0x%x", reg_sap,
LLCP_LOWER_BOUND_LOCAL_SAP);
return LLCP_INVALID_SAP;
}
memset(p_app_cb, 0x00, sizeof(tLLCP_APP_CB));
if (!p_service_name.empty()) {
length = p_service_name.length();
if (length > LLCP_MAX_SN_LEN) {
LOG(ERROR) << StringPrintf("Service Name (%d bytes) is too long", length);
return LLCP_INVALID_SAP;
}
p_app_cb->p_service_name = (char*)GKI_getbuf((uint16_t)(length + 1));
if (p_app_cb->p_service_name == nullptr) {
LOG(ERROR) << StringPrintf("Out of resource");
return LLCP_INVALID_SAP;
}
strlcpy(p_app_cb->p_service_name, p_service_name.c_str(), length + 1);
p_app_cb->p_service_name[length] = 0;
} else
p_app_cb->p_service_name = nullptr;
p_app_cb->p_app_cback = p_app_cback;
p_app_cb->link_type = link_type;
if (reg_sap <= LLCP_UPPER_BOUND_WK_SAP) {
llcp_cb.lcb.wks |= (1 << reg_sap);
}
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("Registered SAP = 0x%02X", reg_sap);
if (link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) {
llcp_cb.num_logical_data_link++;
llcp_util_adjust_ll_congestion();
}
return reg_sap;
}
/*******************************************************************************
**
** Function LLCP_RegisterClient
**
** Description Register client and callback function
**
** link_type : LLCP_LINK_TYPE_LOGICAL_DATA_LINK
** and/or LLCP_LINK_TYPE_DATA_LINK_CONNECTION
**
** Returns SAP between 0x20 and 0x3F, if success
** LLCP_INVALID_SAP, otherwise
**
*******************************************************************************/
uint8_t LLCP_RegisterClient(uint8_t link_type, tLLCP_APP_CBACK* p_app_cback) {
uint8_t reg_sap = LLCP_INVALID_SAP;
uint8_t sap;
tLLCP_APP_CB* p_app_cb;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("link_type = 0x%x", link_type);
if (!p_app_cback) {
LOG(ERROR) << StringPrintf("Callback must be provided");
return LLCP_INVALID_SAP;
} else if (((link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) == 0x00) &&
((link_type & LLCP_LINK_TYPE_DATA_LINK_CONNECTION) == 0x00)) {
LOG(ERROR) << StringPrintf("link type (0x%x) must be specified", link_type);
return LLCP_INVALID_SAP;
}
/* allocate a SAP between 0x20 and 0x3F */
for (sap = 0; sap < LLCP_MAX_CLIENT; sap++) {
if (llcp_cb.client_cb[sap].p_app_cback == nullptr) {
p_app_cb = &llcp_cb.client_cb[sap];
memset(p_app_cb, 0x00, sizeof(tLLCP_APP_CB));
reg_sap = LLCP_LOWER_BOUND_LOCAL_SAP + sap;
break;
}
}
if (reg_sap == LLCP_INVALID_SAP) {
LOG(ERROR) << StringPrintf("out of resource");
return LLCP_INVALID_SAP;
}
p_app_cb->p_app_cback = p_app_cback;
p_app_cb->p_service_name = nullptr;
p_app_cb->link_type = link_type;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("Registered SAP = 0x%02X", reg_sap);
if (link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) {
llcp_cb.num_logical_data_link++;
llcp_util_adjust_ll_congestion();
}
return reg_sap;
}
/*******************************************************************************
**
** Function LLCP_Deregister
**
** Description Deregister server or client
**
**
** Returns LLCP_STATUS_SUCCESS if success
**
*******************************************************************************/
tLLCP_STATUS LLCP_Deregister(uint8_t local_sap) {
uint8_t idx;
tLLCP_APP_CB* p_app_cb;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("SAP:0x%x", local_sap);
p_app_cb = llcp_util_get_app_cb(local_sap);
if ((!p_app_cb) || (p_app_cb->p_app_cback == nullptr)) {
LOG(ERROR) << StringPrintf("SAP (0x%x) is not registered", local_sap);
return LLCP_STATUS_FAIL;
}
if (p_app_cb->p_service_name) GKI_freebuf(p_app_cb->p_service_name);
/* update WKS bit map */
if (local_sap <= LLCP_UPPER_BOUND_WK_SAP) {
llcp_cb.lcb.wks &= ~(1 << local_sap);
}
/* discard any received UI PDU on this SAP */
LLCP_FlushLogicalLinkRxData(local_sap);
llcp_cb.total_rx_ui_pdu = 0;
/* deallocate any data link connection on this SAP */
for (idx = 0; idx < LLCP_MAX_DATA_LINK; idx++) {
if ((llcp_cb.dlcb[idx].state != LLCP_DLC_STATE_IDLE) &&
(llcp_cb.dlcb[idx].local_sap == local_sap)) {
llcp_util_deallocate_data_link(&llcp_cb.dlcb[idx]);
}
}
p_app_cb->p_app_cback = nullptr;
/* discard any pending tx UI PDU from this SAP */
while (p_app_cb->ui_xmit_q.p_first) {
GKI_freebuf(GKI_dequeue(&p_app_cb->ui_xmit_q));
llcp_cb.total_tx_ui_pdu--;
}
if (p_app_cb->link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) {
llcp_cb.num_logical_data_link--;
llcp_util_adjust_ll_congestion();
}
/* check rx congestion status */
llcp_util_check_rx_congested_status();
return LLCP_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function LLCP_IsLogicalLinkCongested
**
** Description Check if logical link is congested
**
**
** Returns TRUE if congested
**
*******************************************************************************/
bool LLCP_IsLogicalLinkCongested(uint8_t local_sap, uint8_t num_pending_ui_pdu,
uint8_t total_pending_ui_pdu,
uint8_t total_pending_i_pdu) {
tLLCP_APP_CB* p_app_cb;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"Local SAP:0x%x, pending = (%d, %d, %d)", local_sap, num_pending_ui_pdu,
total_pending_ui_pdu, total_pending_i_pdu);
p_app_cb = llcp_util_get_app_cb(local_sap);
if ((llcp_cb.lcb.link_state != LLCP_LINK_STATE_ACTIVATED) ||
(p_app_cb == nullptr) || (p_app_cb->p_app_cback == nullptr) ||
((p_app_cb->link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) == 0) ||
(p_app_cb->is_ui_tx_congested)) {
return true;
} else if ((num_pending_ui_pdu + p_app_cb->ui_xmit_q.count >=
llcp_cb.ll_tx_congest_start) ||
(total_pending_ui_pdu + llcp_cb.total_tx_ui_pdu >=
llcp_cb.max_num_ll_tx_buff) ||
(total_pending_ui_pdu + total_pending_i_pdu +
llcp_cb.total_tx_ui_pdu + llcp_cb.total_tx_i_pdu >=
llcp_cb.max_num_tx_buff)) {
/* set flag so LLCP can notify uncongested status later */
p_app_cb->is_ui_tx_congested = true;
return true;
}
return false;
}
/*******************************************************************************
**
** Function LLCP_SendUI
**
** Description Send connnectionless data to DSAP
**
**
** Returns LLCP_STATUS_SUCCESS if success
** LLCP_STATUS_CONGESTED if logical link is congested
** LLCP_STATUS_FAIL, otherwise
**
*******************************************************************************/
tLLCP_STATUS LLCP_SendUI(uint8_t ssap, uint8_t dsap, NFC_HDR* p_buf) {
tLLCP_STATUS status = LLCP_STATUS_FAIL;
tLLCP_APP_CB* p_app_cb;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("SSAP=0x%x, DSAP=0x%x", ssap, dsap);
p_app_cb = llcp_util_get_app_cb(ssap);
if ((p_app_cb == nullptr) || (p_app_cb->p_app_cback == nullptr)) {
LOG(ERROR) << StringPrintf("SSAP (0x%x) is not registered", ssap);
} else if ((p_app_cb->link_type & LLCP_LINK_TYPE_LOGICAL_DATA_LINK) == 0) {
LOG(ERROR) << StringPrintf("Logical link on SSAP (0x%x) is not enabled",
ssap);
} else if (llcp_cb.lcb.link_state != LLCP_LINK_STATE_ACTIVATED) {
LOG(ERROR) << StringPrintf("LLCP link is not activated");
} else if ((llcp_cb.lcb.peer_opt == LLCP_LSC_UNKNOWN) ||
(llcp_cb.lcb.peer_opt & LLCP_LSC_1)) {
if (p_buf->len <= llcp_cb.lcb.peer_miu) {
if (p_buf->offset >= LLCP_MIN_OFFSET) {
status = llcp_util_send_ui(ssap, dsap, p_app_cb, p_buf);
} else {
LOG(ERROR) << StringPrintf("offset (%d) must be %d at least",
p_buf->offset, LLCP_MIN_OFFSET);
}
} else {
LOG(ERROR) << StringPrintf(
"Data length shall not be bigger than peer's link "
"MIU");
}
} else {
LOG(ERROR) << StringPrintf("Peer doesn't support connectionless link");
}
if (status == LLCP_STATUS_FAIL) {
GKI_freebuf(p_buf);
}
return status;
}
/*******************************************************************************
**
** Function LLCP_ReadLogicalLinkData
**
** Description Read information of UI PDU for local SAP
**
** - Remote SAP who sent UI PDU is returned.
** - Information of UI PDU up to max_data_len is copied into
** p_data.
** - Information of next UI PDU is not concatenated.
** - Recommended max_data_len is link MIU of local device
**
** Returns TRUE if more information of UI PDU or more UI PDU in queue
**
*******************************************************************************/
bool LLCP_ReadLogicalLinkData(uint8_t local_sap, uint32_t max_data_len,
uint8_t* p_remote_sap, uint32_t* p_data_len,
uint8_t* p_data) {
tLLCP_APP_CB* p_app_cb;
NFC_HDR* p_buf;
uint8_t* p_ui_pdu;
uint16_t pdu_hdr, ui_pdu_length;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("Local SAP:0x%x", local_sap);
*p_data_len = 0;
p_app_cb = llcp_util_get_app_cb(local_sap);
/* if application is registered */
if ((p_app_cb) && (p_app_cb->p_app_cback)) {
/* if any UI PDU in rx queue */
if (p_app_cb->ui_rx_q.p_first) {
p_buf = (NFC_HDR*)p_app_cb->ui_rx_q.p_first;
p_ui_pdu = (uint8_t*)(p_buf + 1) + p_buf->offset;
/* get length of UI PDU */
BE_STREAM_TO_UINT16(ui_pdu_length, p_ui_pdu);
/* get remote SAP from LLCP header */
BE_STREAM_TO_UINT16(pdu_hdr, p_ui_pdu);
*p_remote_sap = LLCP_GET_SSAP(pdu_hdr);
/* layer_specific has the offset to read within UI PDU */
p_ui_pdu += p_buf->layer_specific;
/* copy data up to max_data_len */
if (max_data_len >= (uint32_t)(ui_pdu_length - LLCP_PDU_HEADER_SIZE -
p_buf->layer_specific)) {
/* copy information without LLCP header */
*p_data_len = (uint32_t)(ui_pdu_length - LLCP_PDU_HEADER_SIZE -
p_buf->layer_specific);
/* move to next UI PDU if any */
p_buf->layer_specific =
0; /* reset offset to read from the first byte of next UI PDU */
p_buf->offset += LLCP_PDU_AGF_LEN_SIZE + ui_pdu_length;
p_buf->len -= LLCP_PDU_AGF_LEN_SIZE + ui_pdu_length;
} else {
*p_data_len = max_data_len;
/* update offset to read from remaining UI PDU next time */
p_buf->layer_specific += max_data_len;
}
memcpy(p_data, p_ui_pdu, *p_data_len);
/* if read all of UI PDU */
if (p_buf->len == 0) {
GKI_dequeue(&p_app_cb->ui_rx_q);
GKI_freebuf(p_buf);
/* decrease number of received UI PDU in in all of ui_rx_q and check rx
* congestion status */
llcp_cb.total_rx_ui_pdu--;
llcp_util_check_rx_congested_status();
}
}
/* if there is more UI PDU in rx queue */
if (p_app_cb->ui_rx_q.p_first) {
return true;
} else {
return false;
}
} else {
LOG(ERROR) << StringPrintf("Unregistered SAP:0x%x", local_sap);
return false;
}
}
/*******************************************************************************
**
** Function LLCP_FlushLogicalLinkRxData
**
** Description Discard received data in logical data link of local SAP
**
**
** Returns length of data flushed
**
*******************************************************************************/
uint32_t LLCP_FlushLogicalLinkRxData(uint8_t local_sap) {
NFC_HDR* p_buf;
uint32_t flushed_length = 0;
tLLCP_APP_CB* p_app_cb;
uint8_t* p_ui_pdu;
uint16_t ui_pdu_length;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("Local SAP:0x%x", local_sap);
p_app_cb = llcp_util_get_app_cb(local_sap);
/* if application is registered */
if ((p_app_cb) && (p_app_cb->p_app_cback)) {
/* if any UI PDU in rx queue */
while (p_app_cb->ui_rx_q.p_first) {
p_buf = (NFC_HDR*)p_app_cb->ui_rx_q.p_first;
p_ui_pdu = (uint8_t*)(p_buf + 1) + p_buf->offset;
/* get length of UI PDU */
BE_STREAM_TO_UINT16(ui_pdu_length, p_ui_pdu);
flushed_length += (uint32_t)(ui_pdu_length - LLCP_PDU_HEADER_SIZE -
p_buf->layer_specific);
/* move to next UI PDU if any */
p_buf->layer_specific = 0; /* offset */
p_buf->offset += LLCP_PDU_AGF_LEN_SIZE + ui_pdu_length;
p_buf->len -= LLCP_PDU_AGF_LEN_SIZE + ui_pdu_length;
/* if read all of UI PDU */
if (p_buf->len == 0) {
GKI_dequeue(&p_app_cb->ui_rx_q);
GKI_freebuf(p_buf);
llcp_cb.total_rx_ui_pdu--;
}
}
/* number of received UI PDU is decreased so check rx congestion status */
llcp_util_check_rx_congested_status();
} else {
LOG(ERROR) << StringPrintf("Unregistered SAP:0x%x", local_sap);
}
return (flushed_length);
}
/*******************************************************************************
**
** Function LLCP_ConnectReq
**
** Description Create data link connection between registered SAP and DSAP
** in peer LLCP,
**
**
** Returns LLCP_STATUS_SUCCESS if success
** LLCP_STATUS_FAIL, otherwise
**
*******************************************************************************/
tLLCP_STATUS LLCP_ConnectReq(uint8_t reg_sap, uint8_t dsap,
tLLCP_CONNECTION_PARAMS* p_params) {
tLLCP_DLCB* p_dlcb;
tLLCP_STATUS status;
tLLCP_APP_CB* p_app_cb;
tLLCP_CONNECTION_PARAMS params;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("reg_sap=0x%x, DSAP=0x%x", reg_sap, dsap);
if ((llcp_cb.lcb.peer_opt != LLCP_LSC_UNKNOWN) &&
((llcp_cb.lcb.peer_opt & LLCP_LSC_2) == 0)) {
LOG(ERROR) << StringPrintf("Peer doesn't support connection-oriented link");
return LLCP_STATUS_FAIL;
}
if (!p_params) {
params.miu = LLCP_DEFAULT_MIU;
params.rw = LLCP_DEFAULT_RW;
params.sn[0] = 0;
p_params = &params;
}
p_app_cb = llcp_util_get_app_cb(reg_sap);
/* if application is registered */
if ((p_app_cb == nullptr) || (p_app_cb->p_app_cback == nullptr)) {
LOG(ERROR) << StringPrintf("SSAP (0x%x) is not registered", reg_sap);
return LLCP_STATUS_FAIL;
}
if (dsap == LLCP_SAP_LM) {
LOG(ERROR) << StringPrintf("DSAP (0x%x) must not be link manager SAP",
dsap);
return LLCP_STATUS_FAIL;
}
if (dsap == LLCP_SAP_SDP) {
if (strlen(p_params->sn) > LLCP_MAX_SN_LEN) {
LOG(ERROR) << StringPrintf("Service Name (%zu bytes) is too long",
strlen(p_params->sn));
return LLCP_STATUS_FAIL;
}
}
if ((p_params) && (p_params->miu > llcp_cb.lcb.local_link_miu)) {
LOG(ERROR) << StringPrintf(
"Data link MIU shall not be bigger than local link "
"MIU");
return LLCP_STATUS_FAIL;
}
/* check if any pending connection request on this reg_sap */
p_dlcb = llcp_dlc_find_dlcb_by_sap(reg_sap, LLCP_INVALID_SAP);
if (p_dlcb) {
/*
** Accepting LLCP may change SAP in CC, so we cannot find right data
** link connection if there is multiple pending connection request on
** the same local SAP.
*/
LOG(ERROR) << StringPrintf(
"There is pending connect request on this reg_sap");
return LLCP_STATUS_FAIL;
}
p_dlcb = llcp_util_allocate_data_link(reg_sap, dsap);
if (p_dlcb) {
status =
llcp_dlsm_execute(p_dlcb, LLCP_DLC_EVENT_API_CONNECT_REQ, p_params);
if (status != LLCP_STATUS_SUCCESS) {
LOG(ERROR) << StringPrintf("Error in state machine");
llcp_util_deallocate_data_link(p_dlcb);
return LLCP_STATUS_FAIL;
}
} else {
return LLCP_STATUS_FAIL;
}
return LLCP_STATUS_SUCCESS;
}
/*******************************************************************************
**
** Function LLCP_ConnectCfm
**
** Description Accept connection request from peer LLCP
**
**
** Returns LLCP_STATUS_SUCCESS if success
** LLCP_STATUS_FAIL, otherwise
**
*******************************************************************************/
tLLCP_STATUS LLCP_ConnectCfm(uint8_t local_sap, uint8_t remote_sap,
tLLCP_CONNECTION_PARAMS* p_params) {
tLLCP_STATUS status;
tLLCP_DLCB* p_dlcb;
tLLCP_CONNECTION_PARAMS params;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"Local SAP:0x%x, Remote SAP:0x%x)", local_sap, remote_sap);
if (!p_params) {
params.miu = LLCP_DEFAULT_MIU;
params.rw = LLCP_DEFAULT_RW;
params.sn[0] = 0;
p_params = &params;
}
if (p_params->miu > llcp_cb.lcb.local_link_miu) {
LOG(ERROR) << StringPrintf(
"Data link MIU shall not be bigger than local link "
"MIU");
return LLCP_STATUS_FAIL;
}
p_dlcb = llcp_dlc_find_dlcb_by_sap(local_sap, remote_sap);
if (p_dlcb) {
status =
llcp_dlsm_execute(p_dlcb, LLCP_DLC_EVENT_API_CONNECT_CFM, p_params);
} else {
LOG(ERROR) << StringPrintf("No data link");
status = LLCP_STATUS_FAIL;
}
return status;
}
/*******************************************************************************
**
** Function LLCP_ConnectReject
**
** Description Reject connection request from peer LLCP
**
** reason : LLCP_SAP_DM_REASON_APP_REJECTED
** LLCP_SAP_DM_REASON_PERM_REJECT_THIS
** LLCP_SAP_DM_REASON_PERM_REJECT_ANY
** LLCP_SAP_DM_REASON_TEMP_REJECT_THIS
** LLCP_SAP_DM_REASON_TEMP_REJECT_ANY
**
** Returns LLCP_STATUS_SUCCESS if success
** LLCP_STATUS_FAIL, otherwise
**
*******************************************************************************/
tLLCP_STATUS LLCP_ConnectReject(uint8_t local_sap, uint8_t remote_sap,
uint8_t reason) {
tLLCP_STATUS status;
tLLCP_DLCB* p_dlcb;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("Local SAP:0x%x, Remote SAP:0x%x, reason:0x%x", local_sap,
remote_sap, reason);
p_dlcb = llcp_dlc_find_dlcb_by_sap(local_sap, remote_sap);
if (p_dlcb) {
status =
llcp_dlsm_execute(p_dlcb, LLCP_DLC_EVENT_API_CONNECT_REJECT, &reason);
llcp_util_deallocate_data_link(p_dlcb);
} else {
LOG(ERROR) << StringPrintf("No data link");
status = LLCP_STATUS_FAIL;
}
return status;
}
/*******************************************************************************
**
** Function LLCP_IsDataLinkCongested
**
** Description Check if data link connection is congested
**
**
** Returns TRUE if congested
**
*******************************************************************************/
bool LLCP_IsDataLinkCongested(uint8_t local_sap, uint8_t remote_sap,
uint8_t num_pending_i_pdu,
uint8_t total_pending_ui_pdu,
uint8_t total_pending_i_pdu) {
tLLCP_DLCB* p_dlcb;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"Local SAP:0x%x, Remote SAP:0x%x, pending = "
"(%d, %d, %d)",
local_sap, remote_sap, num_pending_i_pdu, total_pending_ui_pdu,
total_pending_i_pdu);
p_dlcb = llcp_dlc_find_dlcb_by_sap(local_sap, remote_sap);
if (p_dlcb) {
if ((p_dlcb->is_tx_congested) || (p_dlcb->remote_busy)) {
return true;
} else if ((num_pending_i_pdu + p_dlcb->i_xmit_q.count >=
p_dlcb->remote_rw) ||
(total_pending_ui_pdu + total_pending_i_pdu +
llcp_cb.total_tx_ui_pdu + llcp_cb.total_tx_i_pdu >=
llcp_cb.max_num_tx_buff)) {
/* set flag so LLCP can notify uncongested status later */
p_dlcb->is_tx_congested = true;
return true;
}
return false;
}
return true;
}
/*******************************************************************************
**
** Function LLCP_SendData
**
** Description Send connection-oriented data
**
**
** Returns LLCP_STATUS_SUCCESS if success
** LLCP_STATUS_CONGESTED if data link is congested
**
*******************************************************************************/
tLLCP_STATUS LLCP_SendData(uint8_t local_sap, uint8_t remote_sap,
NFC_HDR* p_buf) {
tLLCP_STATUS status = LLCP_STATUS_FAIL;
tLLCP_DLCB* p_dlcb;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("Local SAP:0x%x, Remote SAP:0x%x", local_sap, remote_sap);
p_dlcb = llcp_dlc_find_dlcb_by_sap(local_sap, remote_sap);
if (p_dlcb) {
if (p_dlcb->remote_miu >= p_buf->len) {
if (p_buf->offset >= LLCP_MIN_OFFSET) {
status = llcp_dlsm_execute(p_dlcb, LLCP_DLC_EVENT_API_DATA_REQ, p_buf);
} else {
LOG(ERROR) << StringPrintf("offset (%d) must be %d at least",
p_buf->offset, LLCP_MIN_OFFSET);
}
} else {
LOG(ERROR) << StringPrintf(
"Information (%d bytes) cannot be more than peer "
"MIU (%d bytes)",
p_buf->len, p_dlcb->remote_miu);
}
} else {
LOG(ERROR) << StringPrintf("No data link");
}
if (status == LLCP_STATUS_FAIL) {
GKI_freebuf(p_buf);
}
return status;
}
/*******************************************************************************
**
** Function LLCP_ReadDataLinkData
**
** Description Read information of I PDU for data link connection
**
** - Information of I PDU up to max_data_len is copied into
** p_data.
** - Information of next I PDU is not concatenated.
** - Recommended max_data_len is data link connection MIU of
** local end point
**
** Returns TRUE if more data in queue
**
*******************************************************************************/
bool LLCP_ReadDataLinkData(uint8_t local_sap, uint8_t remote_sap,
uint32_t max_data_len, uint32_t* p_data_len,
uint8_t* p_data) {
tLLCP_DLCB* p_dlcb;
NFC_HDR* p_buf;
uint8_t* p_i_pdu;
uint16_t i_pdu_length;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("Local SAP:0x%x, Remote SAP:0x%x", local_sap, remote_sap);
p_dlcb = llcp_dlc_find_dlcb_by_sap(local_sap, remote_sap);
*p_data_len = 0;
if (p_dlcb) {
/* if any I PDU in rx queue */
if (p_dlcb->i_rx_q.p_first) {
p_buf = (NFC_HDR*)p_dlcb->i_rx_q.p_first;
p_i_pdu = (uint8_t*)(p_buf + 1) + p_buf->offset;
/* get length of I PDU */
BE_STREAM_TO_UINT16(i_pdu_length, p_i_pdu);
/* layer_specific has the offset to read within I PDU */
p_i_pdu += p_buf->layer_specific;
/* copy data up to max_data_len */
if (max_data_len >= (uint32_t)(i_pdu_length - p_buf->layer_specific)) {
/* copy information */
*p_data_len = (uint32_t)(i_pdu_length - p_buf->layer_specific);
/* move to next I PDU if any */
p_buf->layer_specific =
0; /* reset offset to read from the first byte of next I PDU */
p_buf->offset += LLCP_PDU_AGF_LEN_SIZE + i_pdu_length;
p_buf->len -= LLCP_PDU_AGF_LEN_SIZE + i_pdu_length;
} else {
*p_data_len = max_data_len;
/* update offset to read from remaining I PDU next time */
p_buf->layer_specific += max_data_len;
}
memcpy(p_data, p_i_pdu, *p_data_len);
if (p_buf->layer_specific == 0) {
p_dlcb->num_rx_i_pdu--;
}
/* if read all of I PDU */
if (p_buf->len == 0) {
GKI_dequeue(&p_dlcb->i_rx_q);
GKI_freebuf(p_buf);
/* decrease number of received I PDU in in all of ui_rx_q and check rx
* congestion status */
llcp_cb.total_rx_i_pdu--;
llcp_util_check_rx_congested_status();
}
}
/* if getting out of rx congestion */
if ((!p_dlcb->local_busy) && (p_dlcb->is_rx_congested) &&
(p_dlcb->num_rx_i_pdu <= p_dlcb->rx_congest_threshold / 2)) {
/* send RR */
p_dlcb->is_rx_congested = false;
p_dlcb->flags |= LLCP_DATA_LINK_FLAG_PENDING_RR_RNR;
}
/* if there is more I PDU in rx queue */
if (p_dlcb->i_rx_q.p_first) {
return true;
} else {
return false;
}
} else {
LOG(ERROR) << StringPrintf("No data link connection");
return false;
}
}
/*******************************************************************************
**
** Function LLCP_FlushDataLinkRxData
**
** Description Discard received data in data link connection
**
**
** Returns length of rx data flushed
**
*******************************************************************************/
uint32_t LLCP_FlushDataLinkRxData(uint8_t local_sap, uint8_t remote_sap) {
tLLCP_DLCB* p_dlcb;
NFC_HDR* p_buf;
uint32_t flushed_length = 0;
uint8_t* p_i_pdu;
uint16_t i_pdu_length;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("Local SAP:0x%x, Remote SAP:0x%x", local_sap, remote_sap);
p_dlcb = llcp_dlc_find_dlcb_by_sap(local_sap, remote_sap);
if (p_dlcb) {
/* if any I PDU in rx queue */
while (p_dlcb->i_rx_q.p_first) {
p_buf = (NFC_HDR*)p_dlcb->i_rx_q.p_first;
p_i_pdu = (uint8_t*)(p_buf + 1) + p_buf->offset;
/* get length of I PDU */
BE_STREAM_TO_UINT16(i_pdu_length, p_i_pdu);
flushed_length += (uint32_t)(i_pdu_length - p_buf->layer_specific);
/* move to next I PDU if any */
p_buf->layer_specific = 0; /* offset */
p_buf->offset += LLCP_PDU_AGF_LEN_SIZE + i_pdu_length;
p_buf->len -= LLCP_PDU_AGF_LEN_SIZE + i_pdu_length;
/* if read all of I PDU */
if (p_buf->len == 0) {
GKI_dequeue(&p_dlcb->i_rx_q);
GKI_freebuf(p_buf);
llcp_cb.total_rx_i_pdu--;
}
}
p_dlcb->num_rx_i_pdu = 0;
/* if getting out of rx congestion */
if ((!p_dlcb->local_busy) && (p_dlcb->is_rx_congested)) {
/* send RR */
p_dlcb->is_rx_congested = false;
p_dlcb->flags |= LLCP_DATA_LINK_FLAG_PENDING_RR_RNR;
}
/* number of received I PDU is decreased so check rx congestion status */
llcp_util_check_rx_congested_status();
} else {
LOG(ERROR) << StringPrintf("No data link connection");
}
return (flushed_length);
}
/*******************************************************************************
**
** Function LLCP_DisconnectReq
**
** Description Disconnect data link
** discard any pending data if flush is set to TRUE
**
** Returns LLCP_STATUS_SUCCESS if success
**
*******************************************************************************/
tLLCP_STATUS LLCP_DisconnectReq(uint8_t local_sap, uint8_t remote_sap,
bool flush) {
tLLCP_STATUS status;
tLLCP_DLCB* p_dlcb;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("Local SAP:0x%x, Remote SAP:0x%x, flush=%d", local_sap,
remote_sap, flush);
p_dlcb = llcp_dlc_find_dlcb_by_sap(local_sap, remote_sap);
if (p_dlcb) {
status =
llcp_dlsm_execute(p_dlcb, LLCP_DLC_EVENT_API_DISCONNECT_REQ, &flush);
} else {
LOG(ERROR) << StringPrintf("No data link");
status = LLCP_STATUS_FAIL;
}
return status;
}
/*******************************************************************************
**
** Function LLCP_SetTxCompleteNtf
**
** Description This function is called to get LLCP_SERVICE_TX_COMPLETE
** when Tx queue is empty and all PDU is acked.
** This is one time event, so upper layer shall call this
** function again to get next LLCP_SERVICE_TX_COMPLETE.
**
** Returns LLCP_STATUS_SUCCESS if success
**
*******************************************************************************/
tLLCP_STATUS LLCP_SetTxCompleteNtf(uint8_t local_sap, uint8_t remote_sap) {
tLLCP_STATUS status;
tLLCP_DLCB* p_dlcb;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("Local SAP:0x%x, Remote SAP:0x%x", local_sap, remote_sap);
p_dlcb = llcp_dlc_find_dlcb_by_sap(local_sap, remote_sap);
if (p_dlcb) {
/* set flag to notify upper later when tx complete */
p_dlcb->flags |= LLCP_DATA_LINK_FLAG_NOTIFY_TX_DONE;
status = LLCP_STATUS_SUCCESS;
} else {
LOG(ERROR) << StringPrintf("No data link");
status = LLCP_STATUS_FAIL;
}
return status;
}
/*******************************************************************************
**
** Function LLCP_SetLocalBusyStatus
**
** Description Set local busy status
**
**
** Returns LLCP_STATUS_SUCCESS if success
**
*******************************************************************************/
tLLCP_STATUS LLCP_SetLocalBusyStatus(uint8_t local_sap, uint8_t remote_sap,
bool is_busy) {
tLLCP_STATUS status;
tLLCP_DLCB* p_dlcb;
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("Local SAP:0x%x, is_busy=%d", local_sap, is_busy);
p_dlcb = llcp_dlc_find_dlcb_by_sap(local_sap, remote_sap);
if (p_dlcb) {
if (p_dlcb->local_busy != is_busy) {
p_dlcb->local_busy = is_busy;
/* send RR or RNR with valid sequence */
p_dlcb->flags |= LLCP_DATA_LINK_FLAG_PENDING_RR_RNR;
if (is_busy == false) {
if (p_dlcb->i_rx_q.count) {
llcp_dlsm_execute(p_dlcb, LLCP_DLC_EVENT_PEER_DATA_IND, nullptr);
}
}
}
status = LLCP_STATUS_SUCCESS;
} else {
LOG(ERROR) << StringPrintf("No data link");
status = LLCP_STATUS_FAIL;
}
return status;
}
/*******************************************************************************
**
** Function LLCP_GetRemoteWKS
**
** Description Return well-known service bitmap of connected device
**
**
** Returns WKS bitmap if success
**
*******************************************************************************/
uint16_t LLCP_GetRemoteWKS(void) {
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"WKS:0x%04x", (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATED)
? llcp_cb.lcb.peer_wks
: 0);
if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATED)
return (llcp_cb.lcb.peer_wks);
else
return (0);
}
/*******************************************************************************
**
** Function LLCP_GetRemoteLSC
**
** Description Return link service class of connected device
**
**
** Returns link service class
**
*******************************************************************************/
uint8_t LLCP_GetRemoteLSC(void) {
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"LSC:0x%x", (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATED)
? llcp_cb.lcb.peer_opt & (LLCP_LSC_1 | LLCP_LSC_2)
: 0);
if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATED)
return (llcp_cb.lcb.peer_opt & (LLCP_LSC_1 | LLCP_LSC_2));
else
return (LLCP_LSC_UNKNOWN);
}
/*******************************************************************************
**
** Function LLCP_GetRemoteVersion
**
** Description Return LLCP version of connected device
**
**
** Returns LLCP version
**
*******************************************************************************/
uint8_t LLCP_GetRemoteVersion(void) {
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
"Version: 0x%x", (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATED)
? llcp_cb.lcb.peer_version
: 0);
if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATED)
return (llcp_cb.lcb.peer_version);
else
return 0;
}
/*******************************************************************************
**
** Function LLCP_GetLinkMIU
**
** Description Return local and remote link MIU
**
**
** Returns None
**
*******************************************************************************/
void LLCP_GetLinkMIU(uint16_t* p_local_link_miu, uint16_t* p_remote_link_miu) {
DLOG_IF(INFO, nfc_debug_enabled) << __func__;
if (llcp_cb.lcb.link_state == LLCP_LINK_STATE_ACTIVATED) {
*p_local_link_miu = llcp_cb.lcb.local_link_miu;
*p_remote_link_miu = llcp_cb.lcb.effective_miu;
} else {
*p_local_link_miu = 0;
*p_remote_link_miu = 0;
}
DLOG_IF(INFO, nfc_debug_enabled)
<< StringPrintf("local_link_miu = %d, remote_link_miu = %d",
*p_local_link_miu, *p_remote_link_miu);
}
/*******************************************************************************
**
** Function LLCP_DiscoverService
**
** Description Return SAP of service name in connected device through
** callback
**
**
** Returns LLCP_STATUS_SUCCESS if success
**
*******************************************************************************/
tLLCP_STATUS LLCP_DiscoverService(char* p_name, tLLCP_SDP_CBACK* p_cback,
uint8_t* p_tid) {
tLLCP_STATUS status;
uint8_t i;
DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("Service Name:%s", p_name);
if (llcp_cb.lcb.link_state != LLCP_LINK_STATE_ACTIVATED) {
LOG(ERROR) << StringPrintf("Link is not activated");
return LLCP_STATUS_FAIL;
}
if (!p_cback) {
LOG(ERROR) << StringPrintf("Callback must be provided.");
return LLCP_STATUS_FAIL;
}
/* if peer version is less than V1.1 then SNL is not supported */
if ((llcp_cb.lcb.agreed_major_version == 0x01) &&
(llcp_cb.lcb.agreed_minor_version < 0x01)) {
LOG(ERROR) << StringPrintf("Peer doesn't support SNL");
return LLCP_STATUS_FAIL;
}
for (i = 0; i < LLCP_MAX_SDP_TRANSAC; i++) {
if (!llcp_cb.sdp_cb.transac[i].p_cback) {
llcp_cb.sdp_cb.transac[i].tid = llcp_cb.sdp_cb.next_tid;
llcp_cb.sdp_cb.next_tid++;
llcp_cb.sdp_cb.transac[i].p_cback = p_cback;
status = llcp_sdp_send_sdreq(llcp_cb.sdp_cb.transac[i].tid, p_name);
if (status == LLCP_STATUS_FAIL) {
llcp_cb.sdp_cb.transac[i].p_cback = nullptr;
}
*p_tid = llcp_cb.sdp_cb.transac[i].tid;
return (status);
}
}
LOG(ERROR) << StringPrintf("Out of resource");
return LLCP_STATUS_FAIL;
}