848 lines
28 KiB
C
848 lines
28 KiB
C
/******************************************************************************
|
|
*
|
|
* Copyright (C) 2003-2012 Broadcom Corporation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* This AVCTP module interfaces to L2CAP
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include <string.h>
|
|
#include "bt_types.h"
|
|
#include "bt_target.h"
|
|
#include "bt_utils.h"
|
|
#include "avct_api.h"
|
|
#include "avct_int.h"
|
|
#include "l2c_api.h"
|
|
#include "l2cdefs.h"
|
|
|
|
/* Configuration flags. */
|
|
#define AVCT_L2C_CFG_IND_DONE (1<<0)
|
|
#define AVCT_L2C_CFG_CFM_DONE (1<<1)
|
|
|
|
/*L2CAP Browsing Parameter */
|
|
#define AVCT_L2C_TX_WINDOW_SIZE 1
|
|
#define AVCT_L2C_MAX_TRANSMISSION 20
|
|
#define AVCT_L2C_RETRANS_TIMEOUT 2000
|
|
#define AVCT_L2C_MONITOR_TIMEOUT 12000
|
|
#define AVCT_L2C_MPS_SEGMENT_SIZE 1000
|
|
|
|
/* callback function declarations */
|
|
void avct_l2c_connect_ind_cback(BD_ADDR bd_addr, UINT16 lcid, UINT16 psm, UINT8 id);
|
|
void avct_l2c_connect_cfm_cback(UINT16 lcid, UINT16 result);
|
|
void avct_l2c_config_cfm_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg);
|
|
void avct_l2c_config_ind_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg);
|
|
void avct_l2c_disconnect_ind_cback(UINT16 lcid, BOOLEAN ack_needed);
|
|
void avct_l2c_disconnect_cfm_cback(UINT16 lcid, UINT16 result);
|
|
void avct_l2c_congestion_ind_cback(UINT16 lcid, BOOLEAN is_congested);
|
|
void avct_l2c_data_ind_cback(UINT16 lcid, BT_HDR *p_buf);
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
const tL2CAP_FCR_OPTS avct_l2c_br_fcr_opts_def =
|
|
{
|
|
L2CAP_FCR_ERTM_MODE, /* Mandatory for Browsing */
|
|
AVCT_L2C_TX_WINDOW_SIZE, /* Tx window size to be #define in bt_target.h*/
|
|
AVCT_L2C_MAX_TRANSMISSION, /* Maximum transmissions before disconnecting */
|
|
AVCT_L2C_RETRANS_TIMEOUT, /* Retransmission timeout (2 secs) */
|
|
AVCT_L2C_MONITOR_TIMEOUT, /* Monitor timeout (12 secs) */
|
|
AVCT_L2C_MPS_SEGMENT_SIZE /* MPS segment size */
|
|
};
|
|
#endif
|
|
|
|
|
|
/* L2CAP callback function structure */
|
|
const tL2CAP_APPL_INFO avct_l2c_appl = {
|
|
avct_l2c_connect_ind_cback,
|
|
avct_l2c_connect_cfm_cback,
|
|
NULL,
|
|
avct_l2c_config_ind_cback,
|
|
avct_l2c_config_cfm_cback,
|
|
avct_l2c_disconnect_ind_cback,
|
|
avct_l2c_disconnect_cfm_cback,
|
|
NULL,
|
|
avct_l2c_data_ind_cback,
|
|
avct_l2c_congestion_ind_cback,
|
|
NULL /* tL2CA_TX_COMPLETE_CB */
|
|
};
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
/* L2CAP Callback function for Browsing AVRCP 1.4 structure */
|
|
|
|
/* callback function declarations */
|
|
/* callback function declarations */
|
|
void avct_l2c_br_connect_ind_cback(BD_ADDR bd_addr, UINT16 lcid, UINT16 psm, UINT8 id);
|
|
void avct_l2c_br_connect_cfm_cback(UINT16 lcid, UINT16 result);
|
|
void avct_l2c_br_config_cfm_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg);
|
|
void avct_l2c_br_config_ind_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg);
|
|
void avct_l2c_br_disconnect_ind_cback(UINT16 lcid, BOOLEAN ack_needed);
|
|
void avct_l2c_br_disconnect_cfm_cback(UINT16 lcid, UINT16 result);
|
|
void avct_l2c_br_congestion_ind_cback(UINT16 lcid, BOOLEAN is_congested);
|
|
void avct_l2c_br_data_ind_cback(UINT16 lcid, BT_HDR *p_buf);
|
|
|
|
|
|
|
|
const tL2CAP_APPL_INFO avct_l2c_br_appl = {
|
|
avct_l2c_br_connect_ind_cback,
|
|
avct_l2c_br_connect_cfm_cback,
|
|
NULL,
|
|
avct_l2c_br_config_ind_cback,
|
|
avct_l2c_br_config_cfm_cback,
|
|
avct_l2c_br_disconnect_ind_cback,
|
|
avct_l2c_br_disconnect_cfm_cback,
|
|
NULL,
|
|
avct_l2c_br_data_ind_cback,
|
|
avct_l2c_br_congestion_ind_cback,
|
|
NULL /* tL2CA_TX_COMPLETE_CB */
|
|
};
|
|
#endif
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_is_passive
|
|
**
|
|
** Description check is the CCB associated with the given LCB was created
|
|
** as passive
|
|
**
|
|
** Returns TRUE, if the given LCB is created as AVCT_PASSIVE
|
|
**
|
|
*******************************************************************************/
|
|
static BOOLEAN avct_l2c_is_passive (tAVCT_LCB *p_lcb)
|
|
{
|
|
BOOLEAN is_passive = FALSE;
|
|
tAVCT_CCB *p_ccb = &avct_cb.ccb[0];
|
|
int i;
|
|
|
|
for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
|
|
{
|
|
if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb))
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_is_ct control:x%x", p_ccb->cc.control);
|
|
if (p_ccb->cc.control & AVCT_PASSIVE)
|
|
{
|
|
is_passive = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return is_passive;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_connect_ind_cback
|
|
**
|
|
** Description This is the L2CAP connect indication callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void avct_l2c_connect_ind_cback(BD_ADDR bd_addr, UINT16 lcid, UINT16 psm, UINT8 id)
|
|
{
|
|
tAVCT_LCB *p_lcb;
|
|
UINT16 result = L2CAP_CONN_OK;
|
|
tL2CAP_CFG_INFO cfg;
|
|
UNUSED(psm);
|
|
|
|
/* do we already have a channel for this peer? */
|
|
if ((p_lcb = avct_lcb_by_bd(bd_addr)) == NULL)
|
|
{
|
|
/* no, allocate lcb */
|
|
if ((p_lcb = avct_lcb_alloc(bd_addr)) == NULL)
|
|
{
|
|
/* no ccb available, reject L2CAP connection */
|
|
result = L2CAP_CONN_NO_RESOURCES;
|
|
}
|
|
}
|
|
/* else we already have a channel for this peer */
|
|
else
|
|
{
|
|
if (!avct_l2c_is_passive (p_lcb) || (p_lcb->ch_state == AVCT_CH_OPEN))
|
|
{
|
|
/* this LCB included CT role - reject */
|
|
result = L2CAP_CONN_NO_RESOURCES;
|
|
}
|
|
else
|
|
{
|
|
/* TG role only - accept the connection from CT. move the channel ID to the conflict list */
|
|
p_lcb->conflict_lcid = p_lcb->ch_lcid;
|
|
AVCT_TRACE_DEBUG("avct_l2c_connect_ind_cback conflict_lcid:0x%x", p_lcb->conflict_lcid);
|
|
}
|
|
}
|
|
|
|
if(p_lcb)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_connect_ind_cback: 0x%x, res: %d, ch_state: %d",
|
|
lcid, result, p_lcb->ch_state);
|
|
}
|
|
/* Send L2CAP connect rsp */
|
|
L2CA_ConnectRsp(bd_addr, id, lcid, result, 0);
|
|
|
|
/* if result ok, proceed with connection */
|
|
if (result == L2CAP_CONN_OK)
|
|
{
|
|
/* store LCID */
|
|
p_lcb->ch_lcid = lcid;
|
|
|
|
/* transition to configuration state */
|
|
p_lcb->ch_state = AVCT_CH_CFG;
|
|
|
|
/* Send L2CAP config req */
|
|
memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
|
|
cfg.mtu_present = TRUE;
|
|
cfg.mtu = avct_cb.mtu;
|
|
L2CA_ConfigReq(lcid, &cfg);
|
|
AVCT_TRACE_DEBUG("avct_l2c snd Cfg Req");
|
|
}
|
|
|
|
#if (BT_USE_TRACES == TRUE)
|
|
if(p_lcb)
|
|
AVCT_TRACE_DEBUG("ch_state cni: %d ", p_lcb->ch_state);
|
|
#endif
|
|
}
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_br_connect_ind_cback
|
|
**
|
|
** Description This is the L2CAP connect indication callback function.
|
|
**
|
|
** Return void
|
|
**
|
|
*******************************************************************************/
|
|
void avct_l2c_br_connect_ind_cback(BD_ADDR bd_addr, UINT16 lcid, UINT16 psm, UINT8 id)
|
|
{
|
|
tAVCT_BCB *p_bcb = &avct_cb.bcb[0] ;
|
|
tAVCT_LCB *p_lcb = NULL;
|
|
UINT16 result = L2CAP_CONN_OK;
|
|
tL2CAP_ERTM_INFO ertm_info;
|
|
tL2CAP_ERTM_INFO *p_ertm_info = NULL;
|
|
tL2CAP_CFG_INFO cfg;
|
|
UINT8 index;
|
|
|
|
AVCT_TRACE_DEBUG("avct_l2c_br_connect_ind_cback lcid:%x, psm:%x, id:%x",
|
|
lcid , psm , id);
|
|
|
|
/*Check for associated lcb*/
|
|
if ((p_lcb = avct_lcb_by_bd(bd_addr)) == NULL)
|
|
{
|
|
AVCT_TRACE_ERROR("### LCB not found");
|
|
result = L2CAP_CONN_NO_RESOURCES;
|
|
L2CA_ErtmConnectRsp (bd_addr, id, lcid, result, L2CAP_CONN_OK, p_ertm_info);
|
|
}
|
|
else
|
|
{
|
|
/* We will only support one browsing connection.
|
|
* Second incoming BR conn is rejected.*/
|
|
for (index = 0; index < AVCT_NUM_LINKS; index++)
|
|
{
|
|
p_bcb = &avct_cb.bcb[index];
|
|
if (p_bcb && p_bcb->allocated)
|
|
{
|
|
AVCT_TRACE_ERROR("Browsing already connected to other device");
|
|
AVCT_TRACE_ERROR("Reject Browsing connection:%d", p_bcb->allocated);
|
|
result = L2CAP_CONN_NO_RESOURCES;
|
|
L2CA_ErtmConnectRsp (bd_addr, id, lcid, result, L2CAP_CONN_OK, &ertm_info);
|
|
return;
|
|
}
|
|
}
|
|
index = (UINT8) (p_lcb - &avct_cb.lcb[0]); //calculate offset.
|
|
AVCT_TRACE_DEBUG("index value = %d",index);
|
|
p_bcb = &avct_cb.bcb[index];
|
|
if (p_bcb == NULL)
|
|
{
|
|
/*Disconnect as browsing channel = NULL */
|
|
AVCT_TRACE_ERROR("### BCB NULL");
|
|
result = L2CAP_CONN_NO_RESOURCES;
|
|
L2CA_ErtmConnectRsp (bd_addr, id, lcid, result, L2CAP_CONN_OK, &ertm_info);
|
|
}
|
|
else
|
|
{
|
|
p_bcb->allocated = index +1 ;
|
|
for (index = 0; index < AVCT_NUM_CONN; ++index)
|
|
{
|
|
if (avct_cb.ccb[index].p_lcb == p_lcb)
|
|
{
|
|
AVCT_TRACE_ERROR("index value = %d",index);
|
|
avct_cb.ccb[index].p_bcb = p_bcb ;
|
|
avct_cb.ccb[index].allocated = AVCT_ALOC_BCB ;
|
|
}
|
|
|
|
}
|
|
AVCT_TRACE_DEBUG("Channel RSP");
|
|
p_bcb->ch_lcid = lcid; /*Updadate LCID so that on config associated bcb could be found*/
|
|
ertm_info.preferred_mode = L2CAP_FCR_ERTM_MODE;
|
|
ertm_info.allowed_modes = L2CAP_FCR_CHAN_OPT_ERTM;
|
|
ertm_info.user_rx_buf_size = AVCT_BR_USER_RX_BUF_SIZE;
|
|
ertm_info.user_tx_buf_size = AVCT_BR_USER_TX_BUF_SIZE;
|
|
ertm_info.fcr_rx_buf_size = AVCT_BR_FCR_RX_BUF_SIZE;
|
|
ertm_info.fcr_tx_buf_size = AVCT_BR_FCR_TX_BUF_SIZE;
|
|
p_ertm_info = &ertm_info;
|
|
L2CA_ErtmConnectRsp (bd_addr, id, lcid, result, L2CAP_CONN_OK, p_ertm_info);
|
|
}
|
|
/*Send L2CAP Channel Rsp if result = ok
|
|
* proceed with connection
|
|
*/
|
|
if (result == L2CAP_CONN_OK)
|
|
{
|
|
/* transition to configuration state */
|
|
p_bcb->ch_state = AVCT_CH_CFG;
|
|
/* Send L2CAP config req */
|
|
memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
|
|
cfg.mtu_present = TRUE;
|
|
cfg.mtu = avct_cb.mtu_br; //As per initial config it's 1008
|
|
cfg.fcr_present = TRUE;
|
|
memcpy(&cfg.fcr, &avct_l2c_br_fcr_opts_def, sizeof (tL2CAP_FCR_OPTS));
|
|
/*Send Configue Request*/
|
|
L2CA_ConfigReq(lcid, &cfg);
|
|
AVCT_TRACE_DEBUG("Browse Channel mtu size = %d",cfg.mtu);
|
|
}
|
|
// Send L2CAP Config Rsp
|
|
}
|
|
|
|
#if (BT_USE_TRACES == TRUE)
|
|
if (p_bcb)
|
|
AVCT_TRACE_DEBUG("ch_state cni: %d ", p_bcb->ch_state);
|
|
#endif
|
|
}
|
|
|
|
#endif
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_connect_cfm_cback
|
|
**
|
|
** Description This is the L2CAP connect confirm callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void avct_l2c_connect_cfm_cback(UINT16 lcid, UINT16 result)
|
|
{
|
|
tAVCT_LCB *p_lcb;
|
|
tL2CAP_CFG_INFO cfg;
|
|
|
|
/* look up lcb for this channel */
|
|
if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback lcid:0x%x result: %d ch_state: %d, conflict_lcid:0x%x",
|
|
lcid, result, p_lcb->ch_state, p_lcb->conflict_lcid);
|
|
/* if in correct state */
|
|
if (p_lcb->ch_state == AVCT_CH_CONN)
|
|
{
|
|
/* if result successful */
|
|
if (result == L2CAP_CONN_OK)
|
|
{
|
|
/* set channel state */
|
|
p_lcb->ch_state = AVCT_CH_CFG;
|
|
|
|
/* Send L2CAP config req */
|
|
memset(&cfg, 0, sizeof(tL2CAP_CFG_INFO));
|
|
cfg.mtu_present = TRUE;
|
|
cfg.mtu = avct_cb.mtu;
|
|
L2CA_ConfigReq(lcid, &cfg);
|
|
AVCT_TRACE_DEBUG("avct_l2c snd Cfg Req");
|
|
}
|
|
/* else failure */
|
|
else
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback conflict_lcid:0x%x", p_lcb->conflict_lcid);
|
|
if (p_lcb->conflict_lcid == lcid)
|
|
p_lcb->conflict_lcid = 0;
|
|
else
|
|
avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &result);
|
|
}
|
|
}
|
|
else if (p_lcb->conflict_lcid == lcid)
|
|
{
|
|
/* we must be in AVCT_CH_CFG state for the ch_lcid channel */
|
|
AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback ch_state: %d, conflict_lcid:0x%x", p_lcb->ch_state, p_lcb->conflict_lcid);
|
|
if (result == L2CAP_CONN_OK)
|
|
{
|
|
/* just in case the peer also accepts our connection - Send L2CAP disconnect req */
|
|
L2CA_DisconnectReq(lcid);
|
|
}
|
|
p_lcb->conflict_lcid = 0;
|
|
}
|
|
AVCT_TRACE_DEBUG("ch_state cnc: %d ", p_lcb->ch_state);
|
|
}
|
|
}
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
/********************************************************************************
|
|
** Function avct_l2c_br_connect_cfm_cback
|
|
** Description Function is not expected to be called
|
|
** as browsing is initiated by remote device.
|
|
**
|
|
*********************************************************************************/
|
|
|
|
void avct_l2c_br_connect_cfm_cback(UINT16 lcid, UINT16 result)
|
|
{
|
|
AVCT_TRACE_ERROR("avct_l2c_br_connect_cfm_cback %x: lcid , %x: result", lcid, result );
|
|
}
|
|
#endif
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_config_cfm_cback
|
|
**
|
|
** Description This is the L2CAP config confirm callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void avct_l2c_config_cfm_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
|
|
{
|
|
tAVCT_LCB *p_lcb;
|
|
|
|
/* look up lcb for this channel */
|
|
if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_config_cfm_cback: 0x%x, ch_state: %d, res: %d",
|
|
lcid, p_lcb->ch_state, p_cfg->result);
|
|
/* if in correct state */
|
|
if (p_lcb->ch_state == AVCT_CH_CFG)
|
|
{
|
|
/* if result successful */
|
|
if (p_cfg->result == L2CAP_CFG_OK)
|
|
{
|
|
/* update flags */
|
|
p_lcb->ch_flags |= AVCT_L2C_CFG_CFM_DONE;
|
|
|
|
/* if configuration complete */
|
|
if (p_lcb->ch_flags & AVCT_L2C_CFG_IND_DONE)
|
|
{
|
|
p_lcb->ch_state = AVCT_CH_OPEN;
|
|
avct_lcb_event(p_lcb, AVCT_LCB_LL_OPEN_EVT, NULL);
|
|
}
|
|
}
|
|
/* else failure */
|
|
else
|
|
{
|
|
AVCT_TRACE_ERROR("ERROR avct_l2c_config_cfm_cback L2CA_DisconnectReq = %d ", p_lcb->ch_state);
|
|
/* store result value */
|
|
p_lcb->ch_result = p_cfg->result;
|
|
|
|
/* Send L2CAP disconnect req */
|
|
L2CA_DisconnectReq(lcid);
|
|
}
|
|
}
|
|
AVCT_TRACE_DEBUG("ch_state cfc: %d ", p_lcb->ch_state);
|
|
}
|
|
}
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
/*************************************************************************
|
|
** Function : avct_l2c_br_config_cfm_cback
|
|
**
|
|
** Description: This is the L2CAP config confirm callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*************************************************************************/
|
|
|
|
void avct_l2c_br_config_cfm_cback(UINT16 lcid, tL2CAP_CFG_INFO * p_cfg)
|
|
{
|
|
tAVCT_BCB *p_bcb;
|
|
AVCT_TRACE_DEBUG("avct_l2c_br_config_cfm_cback lcid : %x",lcid);
|
|
|
|
/*lookup for bcb channel, for given lcid there
|
|
* should be a bcb associated
|
|
*/
|
|
if ((p_bcb = avct_bcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_br_config_cfm_cback: 0x%x, ch_state: %d, res: %d, ch_flags",
|
|
lcid, p_bcb->ch_state, p_cfg->result ,p_bcb->ch_flags );
|
|
AVCT_TRACE_DEBUG("MTU :%x ",p_cfg->mtu);
|
|
/*Check for the state , it should be in config*/
|
|
if (p_bcb->ch_state == AVCT_CH_CFG)
|
|
{
|
|
/*Check for remote l2cap response */
|
|
if (p_cfg->result == L2CAP_CFG_OK)
|
|
{
|
|
/*Update BCB ch_flags ,either IND_DONE , CFM_DONE */
|
|
p_bcb->ch_flags |= AVCT_L2C_CFG_CFM_DONE;
|
|
/* Check for Configuraiton Flag , if configuration complete*/
|
|
if (p_bcb->ch_flags & AVCT_L2C_CFG_IND_DONE)
|
|
{
|
|
p_bcb->ch_state = AVCT_CH_OPEN;
|
|
p_bcb->state = 0;
|
|
avct_bcb_event(p_bcb, AVCT_LCB_LL_OPEN_EVT, NULL);
|
|
}
|
|
}
|
|
/*IF L2CAP response result is != L2CAP_CFG_OK*/
|
|
else
|
|
{
|
|
AVCT_TRACE_ERROR("###config_cfm_cback error, ch_state:%d ", p_bcb->ch_state);
|
|
/* store result value */
|
|
p_bcb->ch_result = p_cfg->result;
|
|
/* Send L2CAP disconnect req */
|
|
L2CA_DisconnectReq(lcid);
|
|
}
|
|
}
|
|
AVCT_TRACE_DEBUG("ch_state cfc: %d ", p_bcb->ch_state);
|
|
}
|
|
else
|
|
{
|
|
AVCT_TRACE_ERROR("### BCB NULL");
|
|
L2CA_DisconnectReq(lcid);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_config_ind_cback
|
|
**
|
|
** Description This is the L2CAP config indication callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void avct_l2c_config_ind_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
|
|
{
|
|
tAVCT_LCB *p_lcb;
|
|
|
|
/* look up lcb for this channel */
|
|
if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_config_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state);
|
|
/* store the mtu in tbl */
|
|
if (p_cfg->mtu_present)
|
|
{
|
|
p_lcb->peer_mtu = p_cfg->mtu;
|
|
}
|
|
else
|
|
{
|
|
p_lcb->peer_mtu = L2CAP_DEFAULT_MTU;
|
|
}
|
|
|
|
/* send L2CAP configure response */
|
|
memset(p_cfg, 0, sizeof(tL2CAP_CFG_INFO));
|
|
p_cfg->result = L2CAP_CFG_OK;
|
|
L2CA_ConfigRsp(lcid, p_cfg);
|
|
|
|
/* if first config ind */
|
|
if ((p_lcb->ch_flags & AVCT_L2C_CFG_IND_DONE) == 0)
|
|
{
|
|
/* update flags */
|
|
p_lcb->ch_flags |= AVCT_L2C_CFG_IND_DONE;
|
|
|
|
/* if configuration complete */
|
|
if (p_lcb->ch_flags & AVCT_L2C_CFG_CFM_DONE)
|
|
{
|
|
p_lcb->ch_state = AVCT_CH_OPEN;
|
|
avct_lcb_event(p_lcb, AVCT_LCB_LL_OPEN_EVT, NULL);
|
|
}
|
|
}
|
|
AVCT_TRACE_DEBUG("ch_state cfi: %d ", p_lcb->ch_state);
|
|
}
|
|
else
|
|
{
|
|
AVCT_TRACE_ERROR("%s: p_lcb is null",__func__);
|
|
L2CA_DisconnectReq(lcid);
|
|
}
|
|
}
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
/**************************************************************************
|
|
** Function : avct_l2c_config_ind_cback
|
|
**
|
|
** Description: This is the L2CAP config indication callback function.
|
|
**
|
|
**
|
|
** Returns: void
|
|
**
|
|
****************************************************************************/
|
|
void avct_l2c_br_config_ind_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
|
|
{
|
|
tAVCT_BCB *p_bcb;
|
|
|
|
AVCT_TRACE_DEBUG("config_ind_cback tx_win_sz:%x, max_transmit:%x, rtrans:%x,mon_tout : %x",p_cfg->fcr.tx_win_sz ,\
|
|
p_cfg->fcr.max_transmit , p_cfg->fcr.rtrans_tout , p_cfg->fcr.mon_tout);
|
|
|
|
if ((p_bcb = avct_bcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_br_config_ind_cback: 0x%x, ch_state: %d", lcid, p_bcb->ch_state);
|
|
/* store the mtu in tbl Start from here */
|
|
AVCT_TRACE_DEBUG("avct_l2c_br_config_ind_cback mtu_present: 0x%x, peer mtu: %d", p_cfg->mtu_present, p_cfg->mtu);
|
|
if (p_cfg->mtu_present)
|
|
{
|
|
AVCT_TRACE_DEBUG("PEER MTU: 0x%x", p_bcb->peer_mtu);
|
|
p_bcb->peer_mtu = p_cfg->mtu;
|
|
}
|
|
else
|
|
{
|
|
p_bcb->peer_mtu = L2CAP_DEFAULT_MTU;
|
|
}
|
|
/* send L2CAP configure response */
|
|
memset(p_cfg, 0, sizeof(tL2CAP_CFG_INFO));
|
|
p_cfg->result = L2CAP_CFG_OK;
|
|
L2CA_ConfigRsp(lcid, p_cfg);
|
|
/* if first config ind */
|
|
if ((p_bcb->ch_flags & AVCT_L2C_CFG_IND_DONE) == 0)
|
|
{
|
|
/* update flags */
|
|
p_bcb->ch_flags |= AVCT_L2C_CFG_IND_DONE;
|
|
|
|
/* if configuration complete */
|
|
if (p_bcb->ch_flags & AVCT_L2C_CFG_CFM_DONE)
|
|
{
|
|
p_bcb->ch_state = AVCT_CH_OPEN;
|
|
avct_bcb_event(p_bcb, AVCT_LCB_LL_OPEN_EVT, NULL);
|
|
}
|
|
}
|
|
AVCT_TRACE_DEBUG("ch_state cfi: %d ", p_bcb->ch_state);
|
|
}
|
|
else
|
|
{
|
|
AVCT_TRACE_ERROR("### BCB= NULL");
|
|
L2CA_DisconnectReq(lcid);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_disconnect_ind_cback
|
|
**
|
|
** Description This is the L2CAP disconnect indication callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void avct_l2c_disconnect_ind_cback(UINT16 lcid, BOOLEAN ack_needed)
|
|
{
|
|
tAVCT_LCB *p_lcb;
|
|
UINT16 result = AVCT_RESULT_FAIL;
|
|
|
|
/* look up lcb for this channel */
|
|
if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_disconnect_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state);
|
|
if (ack_needed)
|
|
{
|
|
/* send L2CAP disconnect response */
|
|
L2CA_DisconnectRsp(lcid);
|
|
}
|
|
|
|
avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &result);
|
|
AVCT_TRACE_DEBUG("ch_state di: %d ", p_lcb->ch_state);
|
|
}
|
|
}
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
/********************************************************************************************
|
|
** Function: avct_l2c_br_disconnect_ind_cback
|
|
**
|
|
** Description: This is the L2CAP disconnect indication callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
********************************************************************************************/
|
|
void avct_l2c_br_disconnect_ind_cback(UINT16 lcid, BOOLEAN ack_needed)
|
|
{
|
|
tAVCT_BCB *p_bcb;
|
|
UINT16 result = AVCT_RESULT_FAIL;
|
|
AVCT_TRACE_DEBUG("avct_l2c_br_disconnect_ind_cback lcid : %d ", lcid);
|
|
//Lookup BCB for this event
|
|
if ((p_bcb = avct_bcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_disconnect_ind_cback: 0x%x, ch_state: %d",\
|
|
lcid, p_bcb->ch_state);
|
|
if (ack_needed)
|
|
{
|
|
/* send L2CAP disconnect response */
|
|
L2CA_DisconnectRsp(lcid);
|
|
}
|
|
avct_bcb_event(p_bcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &result);
|
|
}
|
|
else
|
|
{
|
|
AVCT_TRACE_ERROR("###BCB NULL");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_disconnect_cfm_cback
|
|
**
|
|
** Description This is the L2CAP disconnect confirm callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void avct_l2c_disconnect_cfm_cback(UINT16 lcid, UINT16 result)
|
|
{
|
|
tAVCT_LCB *p_lcb;
|
|
UINT16 res;
|
|
|
|
/* look up lcb for this channel */
|
|
if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_disconnect_cfm_cback: 0x%x, ch_state: %d, res: %d",
|
|
lcid, p_lcb->ch_state, result);
|
|
/* result value may be previously stored */
|
|
res = (p_lcb->ch_result != 0) ? p_lcb->ch_result : result;
|
|
p_lcb->ch_result = 0;
|
|
|
|
avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &res);
|
|
AVCT_TRACE_DEBUG("ch_state dc: %d ", p_lcb->ch_state);
|
|
}
|
|
}
|
|
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
/*********************************************************************************
|
|
**
|
|
** Function avct_l2c_br_disconnect_cfm_cback
|
|
**
|
|
** Description This is the L2CAP disconnect Confirmation callback function
|
|
**
|
|
**
|
|
** Returns Void
|
|
**
|
|
***********************************************************************************/
|
|
void avct_l2c_br_disconnect_cfm_cback(UINT16 lcid, UINT16 result)
|
|
{
|
|
tAVCT_BCB *p_bcb;
|
|
AVCT_TRACE_DEBUG("avct_l2c_br_disconnect_cfm_cback lcid : %d ", lcid);
|
|
|
|
if ((p_bcb = avct_bcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
AVCT_TRACE_DEBUG("avct_l2c_disconnect_cfm_cback: 0x%x, ch_state: %d, res: %d",
|
|
lcid, p_bcb->ch_state, result);
|
|
p_bcb->ch_result = 0;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_congestion_ind_cback
|
|
**
|
|
** Description This is the L2CAP congestion indication callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void avct_l2c_congestion_ind_cback(UINT16 lcid, BOOLEAN is_congested)
|
|
{
|
|
tAVCT_LCB *p_lcb;
|
|
|
|
AVCT_TRACE_DEBUG("avct_l2c_congestion_ind_cback: 0x%x", lcid);
|
|
/* look up lcb for this channel */
|
|
if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
avct_lcb_event(p_lcb, AVCT_LCB_LL_CONG_EVT, (tAVCT_LCB_EVT *) &is_congested);
|
|
}
|
|
}
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
|
|
/*********************************************************************************
|
|
** Function avct_l2c_br_congestion_ind_cback
|
|
**
|
|
** Description This is the L2CAP congestion indication callback function.
|
|
**
|
|
** Returns void
|
|
****************************************************************************/
|
|
void avct_l2c_br_congestion_ind_cback(UINT16 lcid, BOOLEAN is_congested)
|
|
{
|
|
tAVCT_BCB *p_bcb = NULL;
|
|
AVCT_TRACE_DEBUG("avct_l2c_br_congestion_ind_cback lcid:%d, congestion:%d",
|
|
lcid,is_congested);
|
|
|
|
/* look up for Browse Control Block for this channel */
|
|
p_bcb = avct_bcb_by_lcid(lcid);
|
|
if (p_bcb != NULL)
|
|
{
|
|
avct_bcb_event(p_bcb, AVCT_LCB_LL_CONG_EVT, (tAVCT_LCB_EVT *) &is_congested);
|
|
}
|
|
else
|
|
{
|
|
AVCT_TRACE_ERROR("### No BCB associated with lcid");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function avct_l2c_data_ind_cback
|
|
**
|
|
** Description This is the L2CAP data indication callback function.
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void avct_l2c_data_ind_cback(UINT16 lcid, BT_HDR *p_buf)
|
|
{
|
|
tAVCT_LCB *p_lcb;
|
|
|
|
AVCT_TRACE_DEBUG("avct_l2c_data_ind_cback: 0x%x", lcid);
|
|
/* look up lcb for this channel */
|
|
if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
avct_lcb_event(p_lcb, AVCT_LCB_LL_MSG_EVT, (tAVCT_LCB_EVT *) &p_buf);
|
|
}
|
|
else /* prevent buffer leak */
|
|
{
|
|
AVCT_TRACE_WARNING("ERROR -> avct_l2c_data_ind_cback drop buffer");
|
|
osi_free(p_buf);
|
|
}
|
|
}
|
|
|
|
#if (AVCT_BROWSE_INCLUDED == TRUE)
|
|
/*****************************************************************************
|
|
**
|
|
** Function avct_l2c_br_data_ind_cback
|
|
**
|
|
** Description This is the L2CAP data indication callback function.
|
|
**
|
|
** Returns void
|
|
**
|
|
*****************************************************************************/
|
|
void avct_l2c_br_data_ind_cback(UINT16 lcid, BT_HDR *p_buf)
|
|
{
|
|
tAVCT_BCB *p_bcb;
|
|
|
|
AVCT_TRACE_DEBUG("avct_l2c_br_data_ind_cback lcid : %d ", lcid);
|
|
AVCT_TRACE_DEBUG("BT_HDR event: %x , len: %x , offset: %x, layer_spec: %x ", p_buf->event,
|
|
p_buf->len,p_buf->offset , p_buf->layer_specific );
|
|
if ((p_bcb = avct_bcb_by_lcid(lcid)) != NULL)
|
|
{
|
|
avct_bcb_event(p_bcb, AVCT_LCB_LL_MSG_EVT, (tAVCT_LCB_EVT *) &p_buf);
|
|
}
|
|
else /* prevent buffer leak */
|
|
{
|
|
AVCT_TRACE_WARNING("avct_l2c_br_data_ind_cback drop buffer");
|
|
osi_free_and_reset((void**)&p_buf);
|
|
}
|
|
|
|
}
|
|
#endif
|