1829 lines
66 KiB
C
1829 lines
66 KiB
C
/******************************************************************************
|
|
*
|
|
* Copyright (C) 2000-2012 Broadcom Corporation
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* This file contains functions that handle SCO connections. This includes
|
|
* operations such as connect, disconnect, change supported packet types.
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include <string.h>
|
|
#include "stack/bt_types.h"
|
|
#include "common/bt_target.h"
|
|
#include "stack/bt_types.h"
|
|
#include "stack/hcimsgs.h"
|
|
#include "stack/btu.h"
|
|
#include "stack/btm_api.h"
|
|
#include "osi/allocator.h"
|
|
#include "btm_int.h"
|
|
#include "stack/hcidefs.h"
|
|
//#include "bt_utils.h"
|
|
|
|
#if BTM_SCO_INCLUDED == TRUE
|
|
|
|
/********************************************************************************/
|
|
/* L O C A L D A T A D E F I N I T I O N S */
|
|
/********************************************************************************/
|
|
|
|
#define SCO_ST_UNUSED 0
|
|
#define SCO_ST_LISTENING 1
|
|
#define SCO_ST_W4_CONN_RSP 2
|
|
#define SCO_ST_CONNECTING 3
|
|
#define SCO_ST_CONNECTED 4
|
|
#define SCO_ST_DISCONNECTING 5
|
|
#define SCO_ST_PEND_UNPARK 6
|
|
#define SCO_ST_PEND_ROLECHANGE 7
|
|
|
|
/********************************************************************************/
|
|
/* L O C A L F U N C T I O N P R O T O T Y P E S */
|
|
/********************************************************************************/
|
|
|
|
static const tBTM_ESCO_PARAMS btm_esco_defaults = {
|
|
BTM_64KBITS_RATE, /* TX Bandwidth (64 kbits/sec) */
|
|
BTM_64KBITS_RATE, /* RX Bandwidth (64 kbits/sec) */
|
|
0x000a, /* 10 ms (HS/HF can use EV3, 2-EV3, 3-EV3) */
|
|
0x0060, /* Inp Linear, Air CVSD, 2s Comp, 16bit */
|
|
(BTM_SCO_PKT_TYPES_MASK_HV1 + /* Packet Types */
|
|
BTM_SCO_PKT_TYPES_MASK_HV2 +
|
|
BTM_SCO_PKT_TYPES_MASK_HV3 +
|
|
BTM_SCO_PKT_TYPES_MASK_EV3 +
|
|
BTM_SCO_PKT_TYPES_MASK_EV4 +
|
|
BTM_SCO_PKT_TYPES_MASK_EV5),
|
|
BTM_ESCO_RETRANS_POWER /* Retransmission Effort (Power) */
|
|
};
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_sco_flush_sco_data
|
|
**
|
|
** Description This function is called to flush the SCO data for this channel.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_sco_flush_sco_data(UINT16 sco_inx)
|
|
{
|
|
#if BTM_SCO_HCI_INCLUDED == TRUE
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p ;
|
|
BT_HDR *p_buf;
|
|
|
|
if (sco_inx < BTM_MAX_SCO_LINKS) {
|
|
p = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
while ((p_buf = (BT_HDR *)fixed_queue_dequeue(p->xmit_data_q, 0)) != NULL) {
|
|
osi_free(p_buf);
|
|
}
|
|
}
|
|
#else
|
|
UNUSED(sco_inx);
|
|
#endif
|
|
#else
|
|
UNUSED(sco_inx);
|
|
#endif
|
|
}
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_sco_init
|
|
**
|
|
** Description This function is called at BTM startup to initialize
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_sco_init (void)
|
|
{
|
|
#if 0 /* cleared in btm_init; put back in if called from anywhere else! */
|
|
memset (&btm_cb.sco_cb, 0, sizeof(tSCO_CB));
|
|
#endif
|
|
#if (BTM_SCO_HCI_INCLUDED == TRUE)
|
|
for (int i = 0; i < BTM_MAX_SCO_LINKS; i++) {
|
|
btm_cb.sco_cb.sco_db[i].xmit_data_q = fixed_queue_new(QUEUE_SIZE_MAX);
|
|
}
|
|
#endif
|
|
/* Initialize nonzero defaults */
|
|
btm_cb.sco_cb.sco_disc_reason = BTM_INVALID_SCO_DISC_REASON;
|
|
|
|
btm_cb.sco_cb.def_esco_parms = btm_esco_defaults; /* Initialize with defaults */
|
|
btm_cb.sco_cb.desired_sco_mode = BTM_DEFAULT_SCO_MODE;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_esco_conn_rsp
|
|
**
|
|
** Description This function is called upon receipt of an (e)SCO connection
|
|
** request event (BTM_ESCO_CONN_REQ_EVT) to accept or reject
|
|
** the request. Parameters used to negotiate eSCO links.
|
|
** If p_parms is NULL, then default values are used.
|
|
** If the link type of the incoming request is SCO, then only
|
|
** the tx_bw, max_latency, content format, and packet_types are
|
|
** valid. The hci_status parameter should be
|
|
** ([0x0] to accept, [0x0d..0x0f] to reject)
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
static void btm_esco_conn_rsp (UINT16 sco_inx, UINT8 hci_status, BD_ADDR bda,
|
|
tBTM_ESCO_PARAMS *p_parms)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p_sco = NULL;
|
|
tBTM_ESCO_PARAMS *p_setup;
|
|
UINT16 temp_pkt_types;
|
|
|
|
if (sco_inx < BTM_MAX_SCO_LINKS) {
|
|
p_sco = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
}
|
|
|
|
/* Reject the connect request if refused by caller or wrong state */
|
|
if (hci_status != HCI_SUCCESS || p_sco == NULL) {
|
|
if (p_sco) {
|
|
p_sco->state = (p_sco->state == SCO_ST_W4_CONN_RSP) ? SCO_ST_LISTENING
|
|
: SCO_ST_UNUSED;
|
|
}
|
|
|
|
if (!btm_cb.sco_cb.esco_supported) {
|
|
if (!btsnd_hcic_reject_conn (bda, hci_status)) {
|
|
BTM_TRACE_ERROR("Could not reject (e)SCO conn: No Buffer!!!");
|
|
}
|
|
} else {
|
|
if (!btsnd_hcic_reject_esco_conn (bda, hci_status)) {
|
|
BTM_TRACE_ERROR("Could not reject (e)SCO conn: No Buffer!!!");
|
|
}
|
|
}
|
|
} else { /* Connection is being accepted */
|
|
p_sco->state = SCO_ST_CONNECTING;
|
|
p_setup = &p_sco->esco.setup;
|
|
/* If parameters not specified use the default */
|
|
if (p_parms) {
|
|
*p_setup = *p_parms;
|
|
} else { /* Use the last setup passed thru BTM_SetEscoMode (or defaults) */
|
|
*p_setup = btm_cb.sco_cb.def_esco_parms;
|
|
}
|
|
|
|
temp_pkt_types = (p_setup->packet_types &
|
|
BTM_SCO_SUPPORTED_PKTS_MASK &
|
|
btm_cb.btm_sco_pkt_types_supported);
|
|
|
|
/* Make sure at least one eSCO packet type is sent, else might confuse peer */
|
|
/* Taking this out to confirm with BQB tests
|
|
** Real application would like to include this though, as many devices
|
|
** do not retry with SCO only if an eSCO connection fails.
|
|
if (!(temp_pkt_types & BTM_ESCO_LINK_ONLY_MASK))
|
|
{
|
|
temp_pkt_types |= BTM_SCO_PKT_TYPES_MASK_EV3;
|
|
}
|
|
*/
|
|
/* If SCO request, remove eSCO packet types (conformance) */
|
|
if (p_sco->esco.data.link_type == BTM_LINK_TYPE_SCO) {
|
|
temp_pkt_types &= BTM_SCO_LINK_ONLY_MASK;
|
|
temp_pkt_types |= BTM_SCO_EXCEPTION_PKTS_MASK;
|
|
} else {
|
|
/* OR in any exception packet types */
|
|
temp_pkt_types |= ((p_setup->packet_types & BTM_SCO_EXCEPTION_PKTS_MASK) |
|
|
(btm_cb.btm_sco_pkt_types_supported & BTM_SCO_EXCEPTION_PKTS_MASK));
|
|
}
|
|
|
|
if (btsnd_hcic_accept_esco_conn (bda, p_setup->tx_bw, p_setup->rx_bw,
|
|
p_setup->max_latency, p_setup->voice_contfmt,
|
|
p_setup->retrans_effort, temp_pkt_types)) {
|
|
p_setup->packet_types = temp_pkt_types;
|
|
} else {
|
|
BTM_TRACE_ERROR("Could not accept SCO conn: No Buffer!!!");
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
#if BTM_SCO_HCI_INCLUDED == TRUE
|
|
void btm_sco_process_num_bufs (UINT16 num_lm_sco_bufs)
|
|
{
|
|
BTM_TRACE_ERROR("%s, %d", __FUNCTION__, num_lm_sco_bufs);
|
|
btm_cb.sco_cb.num_lm_sco_bufs = btm_cb.sco_cb.xmit_window_size = num_lm_sco_bufs;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_ConfigScoPath
|
|
**
|
|
** Description This function enable/disable SCO over HCI and registers SCO
|
|
** data callback if SCO over HCI is enabled.
|
|
**
|
|
** Parameter path: SCO or HCI
|
|
** p_sco_data_cb: callback function or SCO data if path is set
|
|
** to transport.
|
|
** p_pcm_param: pointer to the PCM interface parameter. If a NULL
|
|
** pointer is used, PCM parameter maintained in
|
|
** the control block will be used; otherwise update
|
|
** control block value.
|
|
** err_data_rpt: Lisbon feature to enable the erronous data report
|
|
** or not.
|
|
**
|
|
** Returns BTM_SUCCESS if the successful.
|
|
** BTM_NO_RESOURCES: no rsource to start the command.
|
|
** BTM_ILLEGAL_VALUE: invalid callback function pointer.
|
|
** BTM_CMD_STARTED :Command sent. Waiting for command cmpl event.
|
|
**
|
|
**
|
|
*******************************************************************************/
|
|
//extern
|
|
tBTM_STATUS BTM_ConfigScoPath (tBTM_SCO_ROUTE_TYPE path,
|
|
tBTM_SCO_DATA_CB *p_sco_data_cb,
|
|
tBTM_SCO_PCM_PARAM *p_pcm_param,
|
|
BOOLEAN err_data_rpt)
|
|
{
|
|
UNUSED(err_data_rpt);
|
|
UNUSED(p_pcm_param);
|
|
btm_cb.sco_cb.sco_path = path;
|
|
if (path == BTM_SCO_ROUTE_PCM) {
|
|
return BTM_SUCCESS;
|
|
} else if (path == BTM_SCO_ROUTE_HCI) {
|
|
if (p_sco_data_cb) {
|
|
btm_cb.sco_cb.p_data_cb = p_sco_data_cb;
|
|
}
|
|
}
|
|
|
|
return BTM_SUCCESS;
|
|
}
|
|
|
|
static void hci_sco_data_to_lower(BT_HDR *p_buf)
|
|
{
|
|
p_buf->event = BT_EVT_TO_LM_HCI_SCO;
|
|
if (p_buf->offset == 0) {
|
|
BTM_TRACE_ERROR("offset cannot be 0");
|
|
osi_free(p_buf);
|
|
}
|
|
|
|
bte_main_hci_send(p_buf, (UINT16)(BT_EVT_TO_LM_HCI_SCO | LOCAL_BLE_CONTROLLER_ID));
|
|
}
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_sco_check_send_pkts
|
|
**
|
|
** Description This function is called to check if it can send packets
|
|
** to the Host Controller.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_sco_check_send_pkts (UINT16 sco_inx)
|
|
{
|
|
tSCO_CB *p_cb = &btm_cb.sco_cb;
|
|
tSCO_CONN *p_ccb = &p_cb->sco_db[sco_inx];
|
|
|
|
/* If there is data to send, send it now */
|
|
BT_HDR *p_buf;
|
|
while (p_cb->xmit_window_size != 0)
|
|
{
|
|
if ((p_buf = (BT_HDR *)fixed_queue_dequeue(p_ccb->xmit_data_q, 0)) == NULL) {
|
|
break;
|
|
}
|
|
#if BTM_SCO_HCI_DEBUG
|
|
BTM_TRACE_DEBUG("btm: [%d] buf in xmit_data_q",
|
|
fixed_queue_length(p_ccb->xmit_data_q) + 1);
|
|
#endif
|
|
/* Don't go negative */
|
|
p_cb->xmit_window_size -= 1;
|
|
p_ccb->sent_not_acked += 1;
|
|
|
|
// HCI_SCO_DATA_TO_LOWER(p_buf);
|
|
hci_sco_data_to_lower(p_buf);
|
|
}
|
|
}
|
|
|
|
void btm_sco_process_num_completed_pkts (UINT8 *p)
|
|
{
|
|
UINT8 num_handles, xx;
|
|
UINT16 handle;
|
|
UINT16 num_sent;
|
|
UINT16 sco_inx;
|
|
tSCO_CB *p_cb = &btm_cb.sco_cb;
|
|
tSCO_CONN * p_ccb;
|
|
STREAM_TO_UINT8 (num_handles, p);
|
|
for (xx = 0; xx < num_handles; xx++) {
|
|
STREAM_TO_UINT16 (handle, p);
|
|
STREAM_TO_UINT16 (num_sent, p);
|
|
if ((sco_inx = btm_find_scb_by_handle(handle)) == BTM_MAX_SCO_LINKS) {
|
|
continue;
|
|
}
|
|
BTM_TRACE_DEBUG("%s, %d, %u", __FUNCTION__, handle, p_cb->xmit_window_size); //debug
|
|
p_ccb = &p_cb->sco_db[sco_inx];
|
|
p_ccb->sent_not_acked -= num_sent;
|
|
// don't go negative
|
|
if (p_ccb->sent_not_acked < 0) {
|
|
BTM_TRACE_WARNING("SCO: un-acked underf: %u", p_ccb->sent_not_acked);
|
|
p_ccb->sent_not_acked = 0;
|
|
}
|
|
p_cb->xmit_window_size += num_sent;
|
|
if (p_cb->xmit_window_size > p_cb->num_lm_sco_bufs) {
|
|
BTM_TRACE_WARNING("SCO xwind: %d, max %d", p_cb->xmit_window_size, p_cb->num_lm_sco_bufs);
|
|
p_cb->xmit_window_size = p_cb->num_lm_sco_bufs;
|
|
}
|
|
btm_sco_check_send_pkts (sco_inx);
|
|
}
|
|
|
|
return;
|
|
}
|
|
#endif /* BTM_SCO_HCI_INCLUDED == TRUE */
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_route_sco_data
|
|
**
|
|
** Description Route received SCO data.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_route_sco_data(BT_HDR *p_msg)
|
|
{
|
|
#if BTM_SCO_HCI_INCLUDED == TRUE
|
|
UINT16 sco_inx, handle;
|
|
UINT8 *p = (UINT8 *)(p_msg + 1) + p_msg->offset;
|
|
UINT8 pkt_size = 0;
|
|
UINT8 pkt_status = 0;
|
|
|
|
/* Extract Packet_Status_Flag and handle */
|
|
STREAM_TO_UINT16 (handle, p);
|
|
pkt_status = HCID_GET_EVENT(handle);
|
|
handle = HCID_GET_HANDLE (handle);
|
|
|
|
STREAM_TO_UINT8 (pkt_size, p);
|
|
UNUSED(pkt_size);
|
|
if ((sco_inx = btm_find_scb_by_handle(handle)) != BTM_MAX_SCO_LINKS ) {
|
|
/* send data callback */
|
|
if (!btm_cb.sco_cb.p_data_cb )
|
|
/* if no data callback registered, just free the buffer */
|
|
{
|
|
osi_free (p_msg);
|
|
} else {
|
|
(*btm_cb.sco_cb.p_data_cb)(sco_inx, p_msg, (tBTM_SCO_DATA_FLAG) pkt_status);
|
|
}
|
|
} else { /* no mapping handle SCO connection is active, free the buffer */
|
|
osi_free (p_msg);
|
|
}
|
|
BTM_TRACE_DEBUG ("SCO: hdl %x, len %d, pkt_sz %d\n", handle, p_msg->len, pkt_size);
|
|
#else
|
|
osi_free(p_msg);
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_WriteScoData
|
|
**
|
|
** Description This function write SCO data to a specified instance. The data
|
|
** to be written p_buf needs to carry an offset of
|
|
** HCI_SCO_PREAMBLE_SIZE bytes, and the data length can not
|
|
** exceed BTM_SCO_DATA_SIZE_MAX bytes, whose default value is set
|
|
** to 60 and is configurable. Data longer than the maximum bytes
|
|
** will be truncated.
|
|
**
|
|
** Returns BTM_SUCCESS: data write is successful
|
|
** BTM_ILLEGAL_VALUE: SCO data contains illegal offset value.
|
|
** BTM_SCO_BAD_LENGTH: SCO data length exceeds the max SCO packet
|
|
** size.
|
|
** BTM_NO_RESOURCES: no resources.
|
|
** BTM_UNKNOWN_ADDR: unknown SCO connection handle, or SCO is not
|
|
** routed via HCI.
|
|
** BTM_ERR_PROCESSING: transmit queue overflow
|
|
**
|
|
**
|
|
*******************************************************************************/
|
|
tBTM_STATUS BTM_WriteScoData (UINT16 sco_inx, BT_HDR *p_buf)
|
|
{
|
|
APPL_TRACE_DEBUG("%s", __FUNCTION__);
|
|
#if (BTM_SCO_HCI_INCLUDED == TRUE) && (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p_ccb = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
UINT8 *p;
|
|
tBTM_STATUS status = BTM_SUCCESS;
|
|
|
|
if (sco_inx < BTM_MAX_SCO_LINKS && btm_cb.sco_cb.p_data_cb &&
|
|
p_ccb->state == SCO_ST_CONNECTED) {
|
|
/* Ensure we have enough space in the buffer for the SCO and HCI headers */
|
|
if (p_buf->offset < HCI_SCO_PREAMBLE_SIZE) {
|
|
BTM_TRACE_ERROR ("BTM SCO - cannot send buffer, offset: %d", p_buf->offset);
|
|
status = BTM_ILLEGAL_VALUE;
|
|
} else { /* write HCI header */
|
|
/* Step back 3 bytes to add the headers */
|
|
p_buf->offset -= HCI_SCO_PREAMBLE_SIZE;
|
|
/* Set the pointer to the beginning of the data */
|
|
p = (UINT8 *)(p_buf + 1) + p_buf->offset;
|
|
/* add HCI handle */
|
|
UINT16_TO_STREAM (p, p_ccb->hci_handle);
|
|
/* only sent the first BTM_SCO_DATA_SIZE_MAX bytes data if more than max,
|
|
and set warning status */
|
|
if (p_buf->len > BTM_SCO_DATA_SIZE_MAX) {
|
|
BTM_TRACE_WARNING ("BTM SCO hdl %x, bad len %u", p_ccb->hci_handle, p_buf->len);
|
|
p_buf->len = BTM_SCO_DATA_SIZE_MAX;
|
|
status = BTM_SCO_BAD_LENGTH;
|
|
}
|
|
|
|
UINT8_TO_STREAM (p, (UINT8)p_buf->len);
|
|
|
|
p_buf->len += HCI_SCO_PREAMBLE_SIZE;
|
|
|
|
if (fixed_queue_length(p_ccb->xmit_data_q) < BTM_SCO_XMIT_QUEUE_THRS) {
|
|
fixed_queue_enqueue(p_ccb->xmit_data_q, p_buf, FIXED_QUEUE_MAX_TIMEOUT);
|
|
btm_sco_check_send_pkts (sco_inx);
|
|
} else {
|
|
BTM_TRACE_WARNING ("SCO xmit Q overflow, pkt dropped");
|
|
status = BTM_ERR_PROCESSING;
|
|
}
|
|
}
|
|
} else {
|
|
BTM_TRACE_WARNING ("BTM_WriteScoData, invalid sco index: %d at state [%d]",
|
|
sco_inx, btm_cb.sco_cb.sco_db[sco_inx].state);
|
|
status = BTM_UNKNOWN_ADDR;
|
|
}
|
|
|
|
if (status != BTM_SUCCESS) {
|
|
BTM_TRACE_WARNING ("stat %d", status);
|
|
osi_free(p_buf);
|
|
}
|
|
return (status);
|
|
|
|
#else
|
|
UNUSED(sco_inx);
|
|
UNUSED(p_buf);
|
|
return (BTM_NO_RESOURCES);
|
|
#endif
|
|
}
|
|
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_send_connect_request
|
|
**
|
|
** Description This function is called to respond to SCO connect indications
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
static tBTM_STATUS btm_send_connect_request(UINT16 acl_handle,
|
|
tBTM_ESCO_PARAMS *p_setup)
|
|
{
|
|
UINT16 temp_pkt_types;
|
|
UINT8 xx;
|
|
tACL_CONN *p_acl;
|
|
|
|
/* Send connect request depending on version of spec */
|
|
if (!btm_cb.sco_cb.esco_supported) {
|
|
if (!btsnd_hcic_add_SCO_conn (acl_handle, BTM_ESCO_2_SCO(p_setup->packet_types))) {
|
|
return (BTM_NO_RESOURCES);
|
|
}
|
|
} else {
|
|
temp_pkt_types = (p_setup->packet_types & BTM_SCO_SUPPORTED_PKTS_MASK &
|
|
btm_cb.btm_sco_pkt_types_supported);
|
|
|
|
/* OR in any exception packet types */
|
|
temp_pkt_types |= ((p_setup->packet_types & BTM_SCO_EXCEPTION_PKTS_MASK) |
|
|
(btm_cb.btm_sco_pkt_types_supported & BTM_SCO_EXCEPTION_PKTS_MASK));
|
|
|
|
/* Finally, remove EDR eSCO if the remote device doesn't support it */
|
|
/* UPF25: Only SCO was brought up in this case */
|
|
btm_handle_to_acl_index(acl_handle);
|
|
if ((xx = btm_handle_to_acl_index(acl_handle)) < MAX_L2CAP_LINKS) {
|
|
p_acl = &btm_cb.acl_db[xx];
|
|
if (!HCI_EDR_ESCO_2MPS_SUPPORTED(p_acl->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) {
|
|
|
|
BTM_TRACE_WARNING("BTM Remote does not support 2-EDR eSCO");
|
|
temp_pkt_types |= (HCI_ESCO_PKT_TYPES_MASK_NO_2_EV3 |
|
|
HCI_ESCO_PKT_TYPES_MASK_NO_2_EV5);
|
|
}
|
|
if (!HCI_EDR_ESCO_3MPS_SUPPORTED(p_acl->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) {
|
|
|
|
BTM_TRACE_WARNING("BTM Remote does not support 3-EDR eSCO");
|
|
temp_pkt_types |= (HCI_ESCO_PKT_TYPES_MASK_NO_3_EV3 |
|
|
HCI_ESCO_PKT_TYPES_MASK_NO_3_EV5);
|
|
}
|
|
|
|
/* Check to see if BR/EDR Secure Connections is being used
|
|
** If so, we cannot use SCO-only packet types (HFP 1.7)
|
|
*/
|
|
if (BTM_BothEndsSupportSecureConnections(p_acl->remote_addr)) {
|
|
temp_pkt_types &= ~(BTM_SCO_PKT_TYPE_MASK);
|
|
BTM_TRACE_DEBUG("%s: SCO Conn: pkt_types after removing SCO (0x%04x)", __FUNCTION__,
|
|
temp_pkt_types);
|
|
|
|
/* Return error if no packet types left */
|
|
if (temp_pkt_types == 0) {
|
|
BTM_TRACE_ERROR("%s: SCO Conn (BR/EDR SC): No packet types available",
|
|
__FUNCTION__);
|
|
return (BTM_WRONG_MODE);
|
|
}
|
|
} else {
|
|
BTM_TRACE_DEBUG("%s: SCO Conn(BR/EDR SC):local or peer does not support BR/EDR SC",
|
|
__FUNCTION__);
|
|
}
|
|
}
|
|
|
|
|
|
BTM_TRACE_API(" txbw 0x%x, rxbw 0x%x, lat 0x%x, voice 0x%x, retrans 0x%02x, pkt 0x%04x",
|
|
p_setup->tx_bw, p_setup->rx_bw,
|
|
p_setup->max_latency, p_setup->voice_contfmt,
|
|
p_setup->retrans_effort, temp_pkt_types);
|
|
|
|
if (!btsnd_hcic_setup_esco_conn(acl_handle,
|
|
p_setup->tx_bw,
|
|
p_setup->rx_bw,
|
|
p_setup->max_latency,
|
|
p_setup->voice_contfmt,
|
|
p_setup->retrans_effort,
|
|
temp_pkt_types)) {
|
|
return (BTM_NO_RESOURCES);
|
|
} else {
|
|
p_setup->packet_types = temp_pkt_types;
|
|
}
|
|
}
|
|
|
|
return (BTM_CMD_STARTED);
|
|
}
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_set_sco_ind_cback
|
|
**
|
|
** Description This function is called to register for TCS SCO connect
|
|
** indications.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_set_sco_ind_cback( tBTM_SCO_IND_CBACK *sco_ind_cb )
|
|
{
|
|
btm_cb.sco_cb.app_sco_ind_cb = sco_ind_cb;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_accept_sco_link
|
|
**
|
|
** Description This function is called to respond to TCS SCO connect
|
|
** indications
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_accept_sco_link(UINT16 sco_inx, tBTM_ESCO_PARAMS *p_setup,
|
|
tBTM_SCO_CB *p_conn_cb, tBTM_SCO_CB *p_disc_cb)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p_sco;
|
|
|
|
if (sco_inx >= BTM_MAX_SCO_LINKS) {
|
|
BTM_TRACE_ERROR("btm_accept_sco_link: Invalid sco_inx(%d)", sco_inx);
|
|
return;
|
|
}
|
|
|
|
/* Link role is ignored in for this message */
|
|
p_sco = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
p_sco->p_conn_cb = p_conn_cb;
|
|
p_sco->p_disc_cb = p_disc_cb;
|
|
p_sco->esco.data.link_type = BTM_LINK_TYPE_ESCO; /* Accept with all supported types */
|
|
|
|
BTM_TRACE_DEBUG("TCS accept SCO: Packet Types 0x%04x", p_setup->packet_types);
|
|
|
|
btm_esco_conn_rsp(sco_inx, HCI_SUCCESS, p_sco->esco.data.bd_addr, p_setup);
|
|
#else
|
|
btm_reject_sco_link(sco_inx);
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_reject_sco_link
|
|
**
|
|
** Description This function is called to respond to SCO connect indications
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_reject_sco_link( UINT16 sco_inx )
|
|
{
|
|
btm_esco_conn_rsp(sco_inx, HCI_ERR_HOST_REJECT_RESOURCES,
|
|
btm_cb.sco_cb.sco_db[sco_inx].esco.data.bd_addr, NULL);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_CreateSco
|
|
**
|
|
** Description This function is called to create an SCO connection. If the
|
|
** "is_orig" flag is TRUE, the connection will be originated,
|
|
** otherwise BTM will wait for the other side to connect.
|
|
**
|
|
** NOTE: If BTM_IGNORE_SCO_PKT_TYPE is passed in the pkt_types
|
|
** parameter the default packet types is used.
|
|
**
|
|
** Returns BTM_UNKNOWN_ADDR if the ACL connection is not up
|
|
** BTM_BUSY if another SCO being set up to
|
|
** the same BD address
|
|
** BTM_NO_RESOURCES if the max SCO limit has been reached
|
|
** BTM_CMD_STARTED if the connection establishment is started.
|
|
** In this case, "*p_sco_inx" is filled in
|
|
** with the sco index used for the connection.
|
|
**
|
|
*******************************************************************************/
|
|
tBTM_STATUS BTM_CreateSco (BD_ADDR remote_bda, BOOLEAN is_orig, UINT16 pkt_types,
|
|
UINT16 *p_sco_inx, tBTM_SCO_CB *p_conn_cb,
|
|
tBTM_SCO_CB *p_disc_cb)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS > 0)
|
|
tBTM_ESCO_PARAMS *p_setup;
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
UINT16 xx;
|
|
UINT16 acl_handle = 0;
|
|
UINT16 temp_pkt_types;
|
|
tACL_CONN *p_acl;
|
|
|
|
#if (BTM_SCO_WAKE_PARKED_LINK == TRUE)
|
|
tBTM_PM_MODE md;
|
|
tBTM_PM_PWR_MD pm;
|
|
#else // BTM_SCO_WAKE_PARKED_LINK
|
|
UINT8 mode;
|
|
#endif // BTM_SCO_WAKE_PARKED_LINK
|
|
|
|
*p_sco_inx = BTM_INVALID_SCO_INDEX;
|
|
|
|
/* If originating, ensure that there is an ACL connection to the BD Address */
|
|
if (is_orig) {
|
|
if ((!remote_bda) || ((acl_handle = BTM_GetHCIConnHandle (remote_bda, BT_TRANSPORT_BR_EDR)) == 0xFFFF)) {
|
|
return (BTM_UNKNOWN_ADDR);
|
|
}
|
|
}
|
|
|
|
if (remote_bda) {
|
|
/* If any SCO is being established to the remote BD address, refuse this */
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if (((p->state == SCO_ST_CONNECTING) || (p->state == SCO_ST_LISTENING)
|
|
|| (p->state == SCO_ST_PEND_UNPARK))
|
|
&& (!memcmp (p->esco.data.bd_addr, remote_bda, BD_ADDR_LEN))) {
|
|
return (BTM_BUSY);
|
|
}
|
|
}
|
|
} else {
|
|
/* Support only 1 wildcard BD address at a time */
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if ((p->state == SCO_ST_LISTENING) && (!p->rem_bd_known)) {
|
|
return (BTM_BUSY);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Now, try to find an unused control block, and kick off the SCO establishment */
|
|
for (xx = 0, p = &btm_cb.sco_cb.sco_db[0]; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if (p->state == SCO_ST_UNUSED) {
|
|
if (remote_bda) {
|
|
if (is_orig) {
|
|
/* can not create SCO link if in park mode */
|
|
#if BTM_SCO_WAKE_PARKED_LINK == TRUE
|
|
if (BTM_ReadPowerMode(remote_bda, &md) == BTM_SUCCESS) {
|
|
if (md == BTM_PM_MD_PARK || md == BTM_PM_MD_SNIFF) {
|
|
memset( (void *)&pm, 0, sizeof(pm));
|
|
pm.mode = BTM_PM_MD_ACTIVE;
|
|
BTM_SetPowerMode(BTM_PM_SET_ONLY_ID, remote_bda, &pm);
|
|
p->state = SCO_ST_PEND_UNPARK;
|
|
}
|
|
}
|
|
#else // BTM_SCO_WAKE_PARKED_LINK
|
|
if ( (BTM_ReadPowerMode(remote_bda, &mode) == BTM_SUCCESS) && (mode == BTM_PM_MD_PARK) ) {
|
|
return (BTM_WRONG_MODE);
|
|
}
|
|
#endif // BTM_SCO_WAKE_PARKED_LINK
|
|
}
|
|
memcpy (p->esco.data.bd_addr, remote_bda, BD_ADDR_LEN);
|
|
p->rem_bd_known = TRUE;
|
|
} else {
|
|
p->rem_bd_known = FALSE;
|
|
}
|
|
|
|
/* Link role is ignored in for this message */
|
|
if (pkt_types == BTM_IGNORE_SCO_PKT_TYPE) {
|
|
pkt_types = btm_cb.sco_cb.def_esco_parms.packet_types;
|
|
}
|
|
|
|
p_setup = &p->esco.setup;
|
|
*p_setup = btm_cb.sco_cb.def_esco_parms;
|
|
p_setup->packet_types = (btm_cb.sco_cb.desired_sco_mode == BTM_LINK_TYPE_SCO)
|
|
? (pkt_types & BTM_SCO_LINK_ONLY_MASK) : pkt_types;
|
|
|
|
temp_pkt_types = (p_setup->packet_types & BTM_SCO_SUPPORTED_PKTS_MASK &
|
|
btm_cb.btm_sco_pkt_types_supported);
|
|
|
|
/* OR in any exception packet types */
|
|
if (btm_cb.sco_cb.desired_sco_mode == HCI_LINK_TYPE_ESCO) {
|
|
temp_pkt_types |= ((p_setup->packet_types & BTM_SCO_EXCEPTION_PKTS_MASK) |
|
|
(btm_cb.btm_sco_pkt_types_supported & BTM_SCO_EXCEPTION_PKTS_MASK));
|
|
} else { /* Only using SCO packet types; turn off EDR also */
|
|
temp_pkt_types |= BTM_SCO_EXCEPTION_PKTS_MASK;
|
|
}
|
|
|
|
p_setup->packet_types = temp_pkt_types;
|
|
p->p_conn_cb = p_conn_cb;
|
|
p->p_disc_cb = p_disc_cb;
|
|
p->hci_handle = BTM_INVALID_HCI_HANDLE;
|
|
p->is_orig = is_orig;
|
|
|
|
if ( p->state != SCO_ST_PEND_UNPARK ) {
|
|
if (is_orig) {
|
|
/* If role change is in progress, do not proceed with SCO setup
|
|
* Wait till role change is complete */
|
|
p_acl = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
|
|
if (p_acl && p_acl->switch_role_state != BTM_ACL_SWKEY_STATE_IDLE) {
|
|
BTM_TRACE_API("Role Change is in progress for ACL handle 0x%04x", acl_handle);
|
|
p->state = SCO_ST_PEND_ROLECHANGE;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( p->state != SCO_ST_PEND_UNPARK && p->state != SCO_ST_PEND_ROLECHANGE ) {
|
|
if (is_orig) {
|
|
BTM_TRACE_API("BTM_CreateSco -> (e)SCO Link for ACL handle 0x%04x, Desired Type %d",
|
|
acl_handle, btm_cb.sco_cb.desired_sco_mode);
|
|
|
|
if ((btm_send_connect_request(acl_handle, p_setup)) != BTM_CMD_STARTED) {
|
|
return (BTM_NO_RESOURCES);
|
|
}
|
|
|
|
p->state = SCO_ST_CONNECTING;
|
|
} else {
|
|
p->state = SCO_ST_LISTENING;
|
|
}
|
|
}
|
|
|
|
*p_sco_inx = xx;
|
|
|
|
return (BTM_CMD_STARTED);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
/* If here, all SCO blocks in use */
|
|
return (BTM_NO_RESOURCES);
|
|
}
|
|
|
|
#if (BTM_SCO_WAKE_PARKED_LINK == TRUE)
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_sco_chk_pend_unpark
|
|
**
|
|
** Description This function is called by BTIF when there is a mode change
|
|
** event to see if there are SCO commands waiting for the unpark.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_sco_chk_pend_unpark (UINT8 hci_status, UINT16 hci_handle)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
UINT16 xx;
|
|
UINT16 acl_handle;
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if ((p->state == SCO_ST_PEND_UNPARK) &&
|
|
((acl_handle = BTM_GetHCIConnHandle (p->esco.data.bd_addr, BT_TRANSPORT_BR_EDR)) == hci_handle))
|
|
|
|
{
|
|
BTM_TRACE_API("btm_sco_chk_pend_unpark -> (e)SCO Link for ACL handle 0x%04x, Desired Type %d, hci_status 0x%02x",
|
|
acl_handle, btm_cb.sco_cb.desired_sco_mode, hci_status);
|
|
|
|
if ((btm_send_connect_request(acl_handle, &p->esco.setup)) == BTM_CMD_STARTED) {
|
|
p->state = SCO_ST_CONNECTING;
|
|
}
|
|
}
|
|
}
|
|
#endif // BTM_MAX_SCO_LINKS
|
|
}
|
|
#endif // BTM_SCO_WAKE_PARKED_LINK
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_sco_chk_pend_rolechange
|
|
**
|
|
** Description This function is called by BTIF when there is a role change
|
|
** event to see if there are SCO commands waiting for the role change.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_sco_chk_pend_rolechange (UINT16 hci_handle)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
UINT16 xx;
|
|
UINT16 acl_handle;
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if ((p->state == SCO_ST_PEND_ROLECHANGE) &&
|
|
((acl_handle = BTM_GetHCIConnHandle (p->esco.data.bd_addr, BT_TRANSPORT_BR_EDR)) == hci_handle))
|
|
|
|
{
|
|
BTM_TRACE_API("btm_sco_chk_pend_rolechange -> (e)SCO Link for ACL handle 0x%04x", acl_handle);
|
|
|
|
if ((btm_send_connect_request(acl_handle, &p->esco.setup)) == BTM_CMD_STARTED) {
|
|
p->state = SCO_ST_CONNECTING;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_sco_conn_req
|
|
**
|
|
** Description This function is called by BTIF when an SCO connection
|
|
** request is received from a remote.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_sco_conn_req (BD_ADDR bda, DEV_CLASS dev_class, UINT8 link_type)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CB *p_sco = &btm_cb.sco_cb;
|
|
tSCO_CONN *p = &p_sco->sco_db[0];
|
|
UINT16 xx;
|
|
tBTM_ESCO_CONN_REQ_EVT_DATA evt_data;
|
|
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
/*
|
|
* If the sco state is in the SCO_ST_CONNECTING state, we still need
|
|
* to return accept sco to avoid race conditon for sco creation
|
|
*/
|
|
int rem_bd_matches = p->rem_bd_known &&
|
|
!memcmp (p->esco.data.bd_addr, bda, BD_ADDR_LEN);
|
|
if (((p->state == SCO_ST_CONNECTING) && rem_bd_matches) ||
|
|
((p->state == SCO_ST_LISTENING) && (rem_bd_matches || !p->rem_bd_known))) {
|
|
/* If this guy was a wildcard, he is not one any more */
|
|
p->rem_bd_known = TRUE;
|
|
p->esco.data.link_type = link_type;
|
|
p->state = SCO_ST_W4_CONN_RSP;
|
|
memcpy (p->esco.data.bd_addr, bda, BD_ADDR_LEN);
|
|
|
|
/* If no callback, auto-accept the connection if packet types match */
|
|
if (!p->esco.p_esco_cback) {
|
|
/* If requesting eSCO reject if default parameters are SCO only */
|
|
if ((link_type == BTM_LINK_TYPE_ESCO
|
|
&& !(p_sco->def_esco_parms.packet_types & BTM_ESCO_LINK_ONLY_MASK)
|
|
&& ((p_sco->def_esco_parms.packet_types & BTM_SCO_EXCEPTION_PKTS_MASK)
|
|
== BTM_SCO_EXCEPTION_PKTS_MASK))
|
|
|
|
/* Reject request if SCO is desired but no SCO packets delected */
|
|
|| (link_type == BTM_LINK_TYPE_SCO
|
|
&& !(p_sco->def_esco_parms.packet_types & BTM_SCO_LINK_ONLY_MASK))) {
|
|
btm_esco_conn_rsp(xx, HCI_ERR_HOST_REJECT_RESOURCES, bda, NULL);
|
|
} else { /* Accept the request */
|
|
btm_esco_conn_rsp(xx, HCI_SUCCESS, bda, NULL);
|
|
}
|
|
} else { /* Notify upper layer of connect indication */
|
|
memcpy(evt_data.bd_addr, bda, BD_ADDR_LEN);
|
|
memcpy(evt_data.dev_class, dev_class, DEV_CLASS_LEN);
|
|
evt_data.link_type = link_type;
|
|
evt_data.sco_inx = xx;
|
|
p->esco.p_esco_cback(BTM_ESCO_CONN_REQ_EVT, (tBTM_ESCO_EVT_DATA *)&evt_data);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* TCS usage */
|
|
if (btm_cb.sco_cb.app_sco_ind_cb) {
|
|
/* Now, try to find an unused control block */
|
|
for (xx = 0, p = &btm_cb.sco_cb.sco_db[0]; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if (p->state == SCO_ST_UNUSED) {
|
|
p->is_orig = FALSE;
|
|
p->state = SCO_ST_LISTENING;
|
|
|
|
p->esco.data.link_type = link_type;
|
|
memcpy (p->esco.data.bd_addr, bda, BD_ADDR_LEN);
|
|
p->rem_bd_known = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if ( xx < BTM_MAX_SCO_LINKS) {
|
|
btm_cb.sco_cb.app_sco_ind_cb(xx);
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
/* If here, no one wants the SCO connection. Reject it */
|
|
BTM_TRACE_WARNING("btm_sco_conn_req: No one wants this SCO connection; rejecting it");
|
|
btm_esco_conn_rsp(BTM_MAX_SCO_LINKS, HCI_ERR_HOST_REJECT_RESOURCES, bda, NULL);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_sco_connected
|
|
**
|
|
** Description This function is called by BTIF when an (e)SCO connection
|
|
** is connected.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_sco_connected (UINT8 hci_status, BD_ADDR bda, UINT16 hci_handle,
|
|
tBTM_ESCO_DATA *p_esco_data)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
UINT16 xx;
|
|
BOOLEAN spt = FALSE;
|
|
tBTM_CHG_ESCO_PARAMS parms;
|
|
#endif
|
|
|
|
btm_cb.sco_cb.sco_disc_reason = hci_status;
|
|
BTM_TRACE_ERROR("%s, handle %x", __FUNCTION__, hci_handle);
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if (((p->state == SCO_ST_CONNECTING) ||
|
|
(p->state == SCO_ST_LISTENING) ||
|
|
(p->state == SCO_ST_W4_CONN_RSP))
|
|
&& (p->rem_bd_known)
|
|
&& (!bda || !memcmp (p->esco.data.bd_addr, bda, BD_ADDR_LEN))) {
|
|
if (hci_status != HCI_SUCCESS) {
|
|
/* Report the error if originator, otherwise remain in Listen mode */
|
|
if (p->is_orig) {
|
|
/* If role switch is pending, we need try again after role switch is complete */
|
|
if (hci_status == HCI_ERR_ROLE_SWITCH_PENDING) {
|
|
BTM_TRACE_API("Role Change pending for HCI handle 0x%04x", hci_handle);
|
|
p->state = SCO_ST_PEND_ROLECHANGE;
|
|
}
|
|
/* avoid calling disconnect callback because of sco creation race */
|
|
else if (hci_status != HCI_ERR_LMP_ERR_TRANS_COLLISION) {
|
|
p->state = SCO_ST_UNUSED;
|
|
(*p->p_disc_cb)(xx);
|
|
}
|
|
} else {
|
|
/* Notify the upper layer that incoming sco connection has failed. */
|
|
if (p->state == SCO_ST_CONNECTING) {
|
|
p->state = SCO_ST_UNUSED;
|
|
(*p->p_disc_cb)(xx);
|
|
} else {
|
|
p->state = SCO_ST_LISTENING;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (p->state == SCO_ST_LISTENING) {
|
|
spt = TRUE;
|
|
}
|
|
#if BTM_SCO_HCI_INCLUDED == TRUE
|
|
p->sent_not_acked = 0;
|
|
#endif
|
|
p->state = SCO_ST_CONNECTED;
|
|
p->hci_handle = hci_handle;
|
|
|
|
if (!btm_cb.sco_cb.esco_supported) {
|
|
p->esco.data.link_type = BTM_LINK_TYPE_SCO;
|
|
if (spt) {
|
|
parms.packet_types = p->esco.setup.packet_types;
|
|
/* Keep the other parameters the same for SCO */
|
|
parms.max_latency = p->esco.setup.max_latency;
|
|
parms.retrans_effort = p->esco.setup.retrans_effort;
|
|
|
|
BTM_ChangeEScoLinkParms(xx, &parms);
|
|
}
|
|
} else {
|
|
if (p_esco_data) {
|
|
p->esco.data = *p_esco_data;
|
|
}
|
|
}
|
|
|
|
(*p->p_conn_cb)(xx);
|
|
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_find_scb_by_handle
|
|
**
|
|
** Description Look through all active SCO connection for a match based on the
|
|
** HCI handle.
|
|
**
|
|
** Returns index to matched SCO connection CB, or BTM_MAX_SCO_LINKS if
|
|
** no match.
|
|
**
|
|
*******************************************************************************/
|
|
UINT16 btm_find_scb_by_handle (UINT16 handle)
|
|
{
|
|
int xx;
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if ((p->state == SCO_ST_CONNECTED) && (p->hci_handle == handle)) {
|
|
return (xx);
|
|
}
|
|
}
|
|
|
|
/* If here, no match found */
|
|
return (xx);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_RemoveSco
|
|
**
|
|
** Description This function is called to remove a specific SCO connection.
|
|
**
|
|
** Returns status of the operation
|
|
**
|
|
*******************************************************************************/
|
|
tBTM_STATUS BTM_RemoveSco (UINT16 sco_inx)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
UINT16 tempstate;
|
|
|
|
/* Validity check */
|
|
if ((sco_inx >= BTM_MAX_SCO_LINKS) || (p->state == SCO_ST_UNUSED)) {
|
|
return (BTM_UNKNOWN_ADDR);
|
|
}
|
|
|
|
/* If no HCI handle, simply drop the connection and return */
|
|
if (p->hci_handle == BTM_INVALID_HCI_HANDLE || p->state == SCO_ST_PEND_UNPARK) {
|
|
p->hci_handle = BTM_INVALID_HCI_HANDLE;
|
|
p->state = SCO_ST_UNUSED;
|
|
p->esco.p_esco_cback = NULL; /* Deregister the eSCO event callback */
|
|
return (BTM_SUCCESS);
|
|
}
|
|
|
|
tempstate = p->state;
|
|
p->state = SCO_ST_DISCONNECTING;
|
|
|
|
if (!btsnd_hcic_disconnect (p->hci_handle, HCI_ERR_PEER_USER)) {
|
|
p->state = tempstate;
|
|
return (BTM_NO_RESOURCES);
|
|
}
|
|
|
|
return (BTM_CMD_STARTED);
|
|
#else
|
|
return (BTM_NO_RESOURCES);
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_remove_sco_links
|
|
**
|
|
** Description This function is called to remove all sco links for an ACL link.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_remove_sco_links (BD_ADDR bda)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
UINT16 xx;
|
|
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if (p->rem_bd_known && (!memcmp (p->esco.data.bd_addr, bda, BD_ADDR_LEN))) {
|
|
BTM_RemoveSco(xx);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_sco_removed
|
|
**
|
|
** Description This function is called by BTIF when an SCO connection
|
|
** is removed.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_sco_removed (UINT16 hci_handle, UINT8 reason)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
UINT16 xx;
|
|
#endif
|
|
|
|
btm_cb.sco_cb.sco_disc_reason = reason;
|
|
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
p = &btm_cb.sco_cb.sco_db[0];
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if ((p->state != SCO_ST_UNUSED) && (p->state != SCO_ST_LISTENING) && (p->hci_handle == hci_handle)) {
|
|
btm_sco_flush_sco_data(xx);
|
|
|
|
p->state = SCO_ST_UNUSED;
|
|
#if BTM_SCO_HCI_INCLUDED == TRUE
|
|
btm_cb.sco_cb.xmit_window_size += p->sent_not_acked;
|
|
/* avoid overflow */
|
|
if (btm_cb.sco_cb.xmit_window_size > btm_cb.sco_cb.num_lm_sco_bufs) {
|
|
btm_cb.sco_cb.xmit_window_size = btm_cb.sco_cb.num_lm_sco_bufs;
|
|
}
|
|
p->sent_not_acked = 0;
|
|
#endif
|
|
p->hci_handle = BTM_INVALID_HCI_HANDLE;
|
|
p->rem_bd_known = FALSE;
|
|
p->esco.p_esco_cback = NULL; /* Deregister eSCO callback */
|
|
(*p->p_disc_cb)(xx);
|
|
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_sco_acl_removed
|
|
**
|
|
** Description This function is called when an ACL connection is
|
|
** removed. If the BD address is NULL, it is assumed that
|
|
** the local device is down, and all SCO links are removed.
|
|
** If a specific BD address is passed, only SCO connections
|
|
** to that BD address are removed.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_sco_acl_removed (BD_ADDR bda)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
UINT16 xx;
|
|
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if (p->state != SCO_ST_UNUSED) {
|
|
if ((!bda) || (!memcmp (p->esco.data.bd_addr, bda, BD_ADDR_LEN) && p->rem_bd_known)) {
|
|
btm_sco_flush_sco_data(xx);
|
|
|
|
p->state = SCO_ST_UNUSED;
|
|
p->esco.p_esco_cback = NULL; /* Deregister eSCO callback */
|
|
(*p->p_disc_cb)(xx);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_SetScoPacketTypes
|
|
**
|
|
** Description This function is called to set the packet types used for
|
|
** a specific SCO connection,
|
|
**
|
|
** Parameters pkt_types - One or more of the following
|
|
** BTM_SCO_PKT_TYPES_MASK_HV1
|
|
** BTM_SCO_PKT_TYPES_MASK_HV2
|
|
** BTM_SCO_PKT_TYPES_MASK_HV3
|
|
** BTM_SCO_PKT_TYPES_MASK_EV3
|
|
** BTM_SCO_PKT_TYPES_MASK_EV4
|
|
** BTM_SCO_PKT_TYPES_MASK_EV5
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_2_EV3
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_3_EV3
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_2_EV5
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_3_EV5
|
|
**
|
|
** BTM_SCO_LINK_ALL_MASK - enables all supported types
|
|
**
|
|
** Returns status of the operation
|
|
**
|
|
*******************************************************************************/
|
|
tBTM_STATUS BTM_SetScoPacketTypes (UINT16 sco_inx, UINT16 pkt_types)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tBTM_CHG_ESCO_PARAMS parms;
|
|
tSCO_CONN *p;
|
|
|
|
/* Validity check */
|
|
if (sco_inx >= BTM_MAX_SCO_LINKS) {
|
|
return (BTM_UNKNOWN_ADDR);
|
|
}
|
|
|
|
p = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
parms.packet_types = pkt_types;
|
|
|
|
/* Keep the other parameters the same for SCO */
|
|
parms.max_latency = p->esco.setup.max_latency;
|
|
parms.retrans_effort = p->esco.setup.retrans_effort;
|
|
|
|
return (BTM_ChangeEScoLinkParms(sco_inx, &parms));
|
|
#else
|
|
return (BTM_UNKNOWN_ADDR);
|
|
#endif
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_ReadScoPacketTypes
|
|
**
|
|
** Description This function is read the packet types used for a specific
|
|
** SCO connection.
|
|
**
|
|
** Returns Packet types supported for the connection
|
|
** One or more of the following (bitmask):
|
|
** BTM_SCO_PKT_TYPES_MASK_HV1
|
|
** BTM_SCO_PKT_TYPES_MASK_HV2
|
|
** BTM_SCO_PKT_TYPES_MASK_HV3
|
|
** BTM_SCO_PKT_TYPES_MASK_EV3
|
|
** BTM_SCO_PKT_TYPES_MASK_EV4
|
|
** BTM_SCO_PKT_TYPES_MASK_EV5
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_2_EV3
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_3_EV3
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_2_EV5
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_3_EV5
|
|
**
|
|
*******************************************************************************/
|
|
UINT16 BTM_ReadScoPacketTypes (UINT16 sco_inx)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
|
|
/* Validity check */
|
|
if ((sco_inx < BTM_MAX_SCO_LINKS) && (p->state == SCO_ST_CONNECTED)) {
|
|
return (p->esco.setup.packet_types);
|
|
} else {
|
|
return (0);
|
|
}
|
|
#else
|
|
return (0);
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_ReadScoDiscReason
|
|
**
|
|
** Description This function is returns the reason why an (e)SCO connection
|
|
** has been removed. It contains the value until read, or until
|
|
** another (e)SCO connection has disconnected.
|
|
**
|
|
** Returns HCI reason or BTM_INVALID_SCO_DISC_REASON if not set.
|
|
**
|
|
*******************************************************************************/
|
|
UINT16 BTM_ReadScoDiscReason (void)
|
|
{
|
|
UINT16 res = btm_cb.sco_cb.sco_disc_reason;
|
|
btm_cb.sco_cb.sco_disc_reason = BTM_INVALID_SCO_DISC_REASON;
|
|
return (res);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_ReadDeviceScoPacketTypes
|
|
**
|
|
** Description This function is read the SCO packet types that
|
|
** the device supports.
|
|
**
|
|
** Returns Packet types supported by the device.
|
|
** One or more of the following (bitmask):
|
|
** BTM_SCO_PKT_TYPES_MASK_HV1
|
|
** BTM_SCO_PKT_TYPES_MASK_HV2
|
|
** BTM_SCO_PKT_TYPES_MASK_HV3
|
|
** BTM_SCO_PKT_TYPES_MASK_EV3
|
|
** BTM_SCO_PKT_TYPES_MASK_EV4
|
|
** BTM_SCO_PKT_TYPES_MASK_EV5
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_2_EV3
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_3_EV3
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_2_EV5
|
|
** BTM_SCO_PKT_TYPES_MASK_NO_3_EV5
|
|
**
|
|
*******************************************************************************/
|
|
UINT16 BTM_ReadDeviceScoPacketTypes (void)
|
|
{
|
|
return (btm_cb.btm_sco_pkt_types_supported);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_ReadScoHandle
|
|
**
|
|
** Description This function is used to read the HCI handle used for a specific
|
|
** SCO connection,
|
|
**
|
|
** Returns handle for the connection, or 0xFFFF if invalid SCO index.
|
|
**
|
|
*******************************************************************************/
|
|
UINT16 BTM_ReadScoHandle (UINT16 sco_inx)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
|
|
/* Validity check */
|
|
if ((sco_inx < BTM_MAX_SCO_LINKS) && (p->state == SCO_ST_CONNECTED)) {
|
|
return (p->hci_handle);
|
|
} else {
|
|
return (BTM_INVALID_HCI_HANDLE);
|
|
}
|
|
#else
|
|
return (BTM_INVALID_HCI_HANDLE);
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_ReadScoBdAddr
|
|
**
|
|
** Description This function is read the remote BD Address for a specific
|
|
** SCO connection,
|
|
**
|
|
** Returns pointer to BD address or NULL if not known
|
|
**
|
|
*******************************************************************************/
|
|
UINT8 *BTM_ReadScoBdAddr (UINT16 sco_inx)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
|
|
/* Validity check */
|
|
if ((sco_inx < BTM_MAX_SCO_LINKS) && (p->rem_bd_known)) {
|
|
return (p->esco.data.bd_addr);
|
|
} else {
|
|
return (NULL);
|
|
}
|
|
#else
|
|
return (NULL);
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_SetEScoMode
|
|
**
|
|
** Description This function sets up the negotiated parameters for SCO or
|
|
** eSCO, and sets as the default mode used for outgoing calls to
|
|
** BTM_CreateSco. It does not change any currently active (e)SCO links.
|
|
** Note: Incoming (e)SCO connections will always use packet types
|
|
** supported by the controller. If eSCO is not desired the
|
|
** feature should be disabled in the controller's feature mask.
|
|
**
|
|
** Returns BTM_SUCCESS if the successful.
|
|
** BTM_BUSY if there are one or more active (e)SCO links.
|
|
**
|
|
*******************************************************************************/
|
|
tBTM_STATUS BTM_SetEScoMode (tBTM_SCO_TYPE sco_mode, tBTM_ESCO_PARAMS *p_parms)
|
|
{
|
|
tSCO_CB *p_esco = &btm_cb.sco_cb;
|
|
tBTM_ESCO_PARAMS *p_def = &p_esco->def_esco_parms;
|
|
|
|
if (p_esco->esco_supported) {
|
|
if (p_parms) {
|
|
if (sco_mode == BTM_LINK_TYPE_ESCO) {
|
|
*p_def = *p_parms; /* Save as the default parameters */
|
|
} else { /* Load only the SCO packet types */
|
|
p_def->packet_types = p_parms->packet_types;
|
|
p_def->tx_bw = BTM_64KBITS_RATE;
|
|
p_def->rx_bw = BTM_64KBITS_RATE;
|
|
p_def->max_latency = 0x000a;
|
|
p_def->voice_contfmt = 0x0060;
|
|
p_def->retrans_effort = 0;
|
|
|
|
/* OR in any exception packet types */
|
|
p_def->packet_types |= BTM_SCO_EXCEPTION_PKTS_MASK;
|
|
}
|
|
}
|
|
p_esco->desired_sco_mode = sco_mode;
|
|
BTM_TRACE_API("BTM_SetEScoMode -> mode %d", sco_mode);
|
|
} else {
|
|
p_esco->desired_sco_mode = BTM_LINK_TYPE_SCO;
|
|
p_def->packet_types &= BTM_SCO_LINK_ONLY_MASK;
|
|
p_def->retrans_effort = 0;
|
|
BTM_TRACE_API("BTM_SetEScoMode -> mode SCO (eSCO not supported)");
|
|
}
|
|
|
|
BTM_TRACE_DEBUG(" txbw 0x%08x, rxbw 0x%08x, max_lat 0x%04x, voice 0x%04x, pkt 0x%04x, rtx effort 0x%02x",
|
|
p_def->tx_bw, p_def->rx_bw, p_def->max_latency,
|
|
p_def->voice_contfmt, p_def->packet_types,
|
|
p_def->retrans_effort);
|
|
|
|
return (BTM_SUCCESS);
|
|
}
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_RegForEScoEvts
|
|
**
|
|
** Description This function registers a SCO event callback with the
|
|
** specified instance. It should be used to received
|
|
** connection indication events and change of link parameter
|
|
** events.
|
|
**
|
|
** Returns BTM_SUCCESS if the successful.
|
|
** BTM_ILLEGAL_VALUE if there is an illegal sco_inx
|
|
** BTM_MODE_UNSUPPORTED if controller version is not BT1.2 or
|
|
** later or does not support eSCO.
|
|
**
|
|
*******************************************************************************/
|
|
tBTM_STATUS BTM_RegForEScoEvts (UINT16 sco_inx, tBTM_ESCO_CBACK *p_esco_cback)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
if (!btm_cb.sco_cb.esco_supported) {
|
|
btm_cb.sco_cb.sco_db[sco_inx].esco.p_esco_cback = NULL;
|
|
return (BTM_MODE_UNSUPPORTED);
|
|
}
|
|
|
|
if (sco_inx < BTM_MAX_SCO_LINKS &&
|
|
btm_cb.sco_cb.sco_db[sco_inx].state != SCO_ST_UNUSED) {
|
|
btm_cb.sco_cb.sco_db[sco_inx].esco.p_esco_cback = p_esco_cback;
|
|
return (BTM_SUCCESS);
|
|
}
|
|
return (BTM_ILLEGAL_VALUE);
|
|
#else
|
|
return (BTM_MODE_UNSUPPORTED);
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_ReadEScoLinkParms
|
|
**
|
|
** Description This function returns the current eSCO link parameters for
|
|
** the specified handle. This can be called anytime a connection
|
|
** is active, but is typically called after receiving the SCO
|
|
** opened callback.
|
|
**
|
|
** Note: If called over a 1.1 controller, only the packet types
|
|
** field has meaning.
|
|
**
|
|
** Returns BTM_SUCCESS if returned data is valid connection.
|
|
** BTM_WRONG_MODE if no connection with a peer device or bad sco_inx.
|
|
**
|
|
*******************************************************************************/
|
|
tBTM_STATUS BTM_ReadEScoLinkParms (UINT16 sco_inx, tBTM_ESCO_DATA *p_parms)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
UINT8 index;
|
|
|
|
BTM_TRACE_API("BTM_ReadEScoLinkParms -> sco_inx 0x%04x", sco_inx);
|
|
|
|
if (sco_inx < BTM_MAX_SCO_LINKS &&
|
|
btm_cb.sco_cb.sco_db[sco_inx].state >= SCO_ST_CONNECTED) {
|
|
*p_parms = btm_cb.sco_cb.sco_db[sco_inx].esco.data;
|
|
return (BTM_SUCCESS);
|
|
}
|
|
|
|
if (sco_inx == BTM_FIRST_ACTIVE_SCO_INDEX) {
|
|
for (index = 0; index < BTM_MAX_SCO_LINKS; index++) {
|
|
if (btm_cb.sco_cb.sco_db[index].state >= SCO_ST_CONNECTED) {
|
|
BTM_TRACE_API("BTM_ReadEScoLinkParms the first active SCO index is %d", index);
|
|
*p_parms = btm_cb.sco_cb.sco_db[index].esco.data;
|
|
return (BTM_SUCCESS);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
BTM_TRACE_API("BTM_ReadEScoLinkParms cannot find the SCO index!");
|
|
memset(p_parms, 0, sizeof(tBTM_ESCO_DATA));
|
|
return (BTM_WRONG_MODE);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_ChangeEScoLinkParms
|
|
**
|
|
** Description This function requests renegotiation of the parameters on
|
|
** the current eSCO Link. If any of the changes are accepted
|
|
** by the controllers, the BTM_ESCO_CHG_EVT event is sent in
|
|
** the tBTM_ESCO_CBACK function with the current settings of
|
|
** the link. The callback is registered through the call to
|
|
** BTM_SetEScoMode.
|
|
**
|
|
** Note: If called over a SCO link (including 1.1 controller),
|
|
** a change packet type request is sent out instead.
|
|
**
|
|
** Returns BTM_CMD_STARTED if command is successfully initiated.
|
|
** BTM_NO_RESOURCES - not enough resources to initiate command.
|
|
** BTM_WRONG_MODE if no connection with a peer device or bad sco_inx.
|
|
**
|
|
*******************************************************************************/
|
|
tBTM_STATUS BTM_ChangeEScoLinkParms (UINT16 sco_inx, tBTM_CHG_ESCO_PARAMS *p_parms)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tBTM_ESCO_PARAMS *p_setup;
|
|
tSCO_CONN *p_sco;
|
|
UINT16 temp_pkt_types;
|
|
|
|
/* Make sure sco handle is valid and on an active link */
|
|
if (sco_inx >= BTM_MAX_SCO_LINKS ||
|
|
btm_cb.sco_cb.sco_db[sco_inx].state != SCO_ST_CONNECTED) {
|
|
return (BTM_WRONG_MODE);
|
|
}
|
|
|
|
p_sco = &btm_cb.sco_cb.sco_db[sco_inx];
|
|
p_setup = &p_sco->esco.setup;
|
|
|
|
/* If SCO connection OR eSCO not supported just send change packet types */
|
|
if (p_sco->esco.data.link_type == BTM_LINK_TYPE_SCO ||
|
|
!btm_cb.sco_cb.esco_supported) {
|
|
p_setup->packet_types = p_parms->packet_types &
|
|
(btm_cb.btm_sco_pkt_types_supported & BTM_SCO_LINK_ONLY_MASK);
|
|
|
|
|
|
BTM_TRACE_API("BTM_ChangeEScoLinkParms -> SCO Link for handle 0x%04x, pkt 0x%04x",
|
|
p_sco->hci_handle, p_setup->packet_types);
|
|
|
|
if (!btsnd_hcic_change_conn_type (p_sco->hci_handle,
|
|
BTM_ESCO_2_SCO(p_setup->packet_types))) {
|
|
return (BTM_NO_RESOURCES);
|
|
}
|
|
} else {
|
|
temp_pkt_types = (p_parms->packet_types & BTM_SCO_SUPPORTED_PKTS_MASK &
|
|
btm_cb.btm_sco_pkt_types_supported);
|
|
|
|
/* OR in any exception packet types */
|
|
temp_pkt_types |= ((p_parms->packet_types & BTM_SCO_EXCEPTION_PKTS_MASK) |
|
|
(btm_cb.btm_sco_pkt_types_supported & BTM_SCO_EXCEPTION_PKTS_MASK));
|
|
|
|
BTM_TRACE_API("BTM_ChangeEScoLinkParms -> eSCO Link for handle 0x%04x", p_sco->hci_handle);
|
|
BTM_TRACE_API(" txbw 0x%x, rxbw 0x%x, lat 0x%x, voice 0x%x, retrans 0x%02x, pkt 0x%04x",
|
|
p_setup->tx_bw, p_setup->rx_bw, p_parms->max_latency,
|
|
p_setup->voice_contfmt, p_parms->retrans_effort, temp_pkt_types);
|
|
|
|
/* When changing an existing link, only change latency, retrans, and pkts */
|
|
if (!btsnd_hcic_setup_esco_conn(p_sco->hci_handle, p_setup->tx_bw,
|
|
p_setup->rx_bw, p_parms->max_latency,
|
|
p_setup->voice_contfmt,
|
|
p_parms->retrans_effort,
|
|
temp_pkt_types)) {
|
|
return (BTM_NO_RESOURCES);
|
|
} else {
|
|
p_parms->packet_types = temp_pkt_types;
|
|
}
|
|
}
|
|
|
|
return (BTM_CMD_STARTED);
|
|
#else
|
|
return (BTM_WRONG_MODE);
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_EScoConnRsp
|
|
**
|
|
** Description This function is called upon receipt of an (e)SCO connection
|
|
** request event (BTM_ESCO_CONN_REQ_EVT) to accept or reject
|
|
** the request. Parameters used to negotiate eSCO links.
|
|
** If p_parms is NULL, then values set through BTM_SetEScoMode
|
|
** are used.
|
|
** If the link type of the incoming request is SCO, then only
|
|
** the tx_bw, max_latency, content format, and packet_types are
|
|
** valid. The hci_status parameter should be
|
|
** ([0x0] to accept, [0x0d..0x0f] to reject)
|
|
**
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void BTM_EScoConnRsp (UINT16 sco_inx, UINT8 hci_status, tBTM_ESCO_PARAMS *p_parms)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
if (sco_inx < BTM_MAX_SCO_LINKS &&
|
|
btm_cb.sco_cb.sco_db[sco_inx].state == SCO_ST_W4_CONN_RSP) {
|
|
btm_esco_conn_rsp(sco_inx, hci_status,
|
|
btm_cb.sco_cb.sco_db[sco_inx].esco.data.bd_addr,
|
|
p_parms);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_read_def_esco_mode
|
|
**
|
|
** Description This function copies the current default esco settings into
|
|
** the return buffer.
|
|
**
|
|
** Returns tBTM_SCO_TYPE
|
|
**
|
|
*******************************************************************************/
|
|
tBTM_SCO_TYPE btm_read_def_esco_mode (tBTM_ESCO_PARAMS *p_parms)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
*p_parms = btm_cb.sco_cb.def_esco_parms;
|
|
return btm_cb.sco_cb.desired_sco_mode;
|
|
#else
|
|
return BTM_LINK_TYPE_SCO;
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_esco_proc_conn_chg
|
|
**
|
|
** Description This function is called by BTIF when an SCO connection
|
|
** is changed.
|
|
**
|
|
** Returns void
|
|
**
|
|
*******************************************************************************/
|
|
void btm_esco_proc_conn_chg (UINT8 status, UINT16 handle, UINT8 tx_interval,
|
|
UINT8 retrans_window, UINT16 rx_pkt_len,
|
|
UINT16 tx_pkt_len)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
tBTM_CHG_ESCO_EVT_DATA data;
|
|
UINT16 xx;
|
|
|
|
BTM_TRACE_EVENT("btm_esco_proc_conn_chg -> handle 0x%04x, status 0x%02x",
|
|
handle, status);
|
|
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if (p->state == SCO_ST_CONNECTED && handle == p->hci_handle) {
|
|
/* If upper layer wants notification */
|
|
if (p->esco.p_esco_cback) {
|
|
memcpy(data.bd_addr, p->esco.data.bd_addr, BD_ADDR_LEN);
|
|
data.hci_status = status;
|
|
data.sco_inx = xx;
|
|
data.rx_pkt_len = p->esco.data.rx_pkt_len = rx_pkt_len;
|
|
data.tx_pkt_len = p->esco.data.tx_pkt_len = tx_pkt_len;
|
|
data.tx_interval = p->esco.data.tx_interval = tx_interval;
|
|
data.retrans_window = p->esco.data.retrans_window = retrans_window;
|
|
|
|
(*p->esco.p_esco_cback)(BTM_ESCO_CHG_EVT,
|
|
(tBTM_ESCO_EVT_DATA *)&data);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_is_sco_active
|
|
**
|
|
** Description This function is called to see if a SCO handle is already in
|
|
** use.
|
|
**
|
|
** Returns BOOLEAN
|
|
**
|
|
*******************************************************************************/
|
|
BOOLEAN btm_is_sco_active (UINT16 handle)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
UINT16 xx;
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if (handle == p->hci_handle && p->state == SCO_ST_CONNECTED) {
|
|
return (TRUE);
|
|
}
|
|
}
|
|
#endif
|
|
return (FALSE);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function BTM_GetNumScoLinks
|
|
**
|
|
** Description This function returns the number of active sco links.
|
|
**
|
|
** Returns UINT8
|
|
**
|
|
*******************************************************************************/
|
|
UINT8 BTM_GetNumScoLinks (void)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
UINT16 xx;
|
|
UINT8 num_scos = 0;
|
|
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
switch (p->state) {
|
|
case SCO_ST_W4_CONN_RSP:
|
|
case SCO_ST_CONNECTING:
|
|
case SCO_ST_CONNECTED:
|
|
case SCO_ST_DISCONNECTING:
|
|
case SCO_ST_PEND_UNPARK:
|
|
num_scos++;
|
|
}
|
|
}
|
|
return (num_scos);
|
|
#else
|
|
return (0);
|
|
#endif
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
**
|
|
** Function btm_is_sco_active_by_bdaddr
|
|
**
|
|
** Description This function is called to see if a SCO active to a bd address.
|
|
**
|
|
** Returns BOOLEAN
|
|
**
|
|
*******************************************************************************/
|
|
BOOLEAN btm_is_sco_active_by_bdaddr (BD_ADDR remote_bda)
|
|
{
|
|
#if (BTM_MAX_SCO_LINKS>0)
|
|
UINT8 xx;
|
|
tSCO_CONN *p = &btm_cb.sco_cb.sco_db[0];
|
|
|
|
/* If any SCO is being established to the remote BD address, refuse this */
|
|
for (xx = 0; xx < BTM_MAX_SCO_LINKS; xx++, p++) {
|
|
if ((!memcmp (p->esco.data.bd_addr, remote_bda, BD_ADDR_LEN)) && (p->state == SCO_ST_CONNECTED)) {
|
|
return (TRUE);
|
|
}
|
|
}
|
|
#endif
|
|
return (FALSE);
|
|
}
|
|
#else /* SCO_EXCLUDED == TRUE (Link in stubs) */
|
|
|
|
tBTM_STATUS BTM_CreateSco (BD_ADDR remote_bda, BOOLEAN is_orig,
|
|
UINT16 pkt_types, UINT16 *p_sco_inx,
|
|
tBTM_SCO_CB *p_conn_cb,
|
|
tBTM_SCO_CB *p_disc_cb)
|
|
{
|
|
return (BTM_NO_RESOURCES);
|
|
}
|
|
tBTM_STATUS BTM_RemoveSco (UINT16 sco_inx)
|
|
{
|
|
return (BTM_NO_RESOURCES);
|
|
}
|
|
tBTM_STATUS BTM_SetScoPacketTypes (UINT16 sco_inx, UINT16 pkt_types)
|
|
{
|
|
return (BTM_NO_RESOURCES);
|
|
}
|
|
UINT16 BTM_ReadScoPacketTypes (UINT16 sco_inx)
|
|
{
|
|
return (0);
|
|
}
|
|
UINT16 BTM_ReadDeviceScoPacketTypes (void)
|
|
{
|
|
return (0);
|
|
}
|
|
UINT16 BTM_ReadScoHandle (UINT16 sco_inx)
|
|
{
|
|
return (BTM_INVALID_HCI_HANDLE);
|
|
}
|
|
UINT8 *BTM_ReadScoBdAddr(UINT16 sco_inx)
|
|
{
|
|
return ((UINT8 *) NULL);
|
|
}
|
|
UINT16 BTM_ReadScoDiscReason (void)
|
|
{
|
|
return (BTM_INVALID_SCO_DISC_REASON);
|
|
}
|
|
tBTM_STATUS BTM_SetEScoMode (tBTM_SCO_TYPE sco_mode, tBTM_ESCO_PARAMS *p_parms)
|
|
{
|
|
return (BTM_MODE_UNSUPPORTED);
|
|
}
|
|
tBTM_STATUS BTM_RegForEScoEvts (UINT16 sco_inx, tBTM_ESCO_CBACK *p_esco_cback)
|
|
{
|
|
return (BTM_ILLEGAL_VALUE);
|
|
}
|
|
tBTM_STATUS BTM_ReadEScoLinkParms (UINT16 sco_inx, tBTM_ESCO_DATA *p_parms)
|
|
{
|
|
return (BTM_MODE_UNSUPPORTED);
|
|
}
|
|
tBTM_STATUS BTM_ChangeEScoLinkParms (UINT16 sco_inx, tBTM_CHG_ESCO_PARAMS *p_parms)
|
|
{
|
|
return (BTM_MODE_UNSUPPORTED);
|
|
}
|
|
void BTM_EScoConnRsp (UINT16 sco_inx, UINT8 hci_status, tBTM_ESCO_PARAMS *p_parms) {}
|
|
UINT8 BTM_GetNumScoLinks (void)
|
|
{
|
|
return (0);
|
|
}
|
|
|
|
#endif /* If SCO is being used */
|