bta_hl_main.cc revision cd1fd07f1306e08fe048682dd5918987e579f937
1/****************************************************************************** 2 * 3 * Copyright (C) 1998-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19/****************************************************************************** 20 * 21 * This file contains the HeaLth device profile main functions and state 22 * machine. 23 * 24 ******************************************************************************/ 25#include <string.h> 26 27#include "bt_target.h" 28#if (HL_INCLUDED == TRUE) 29 30#include "bt_common.h" 31#include "bta_hl_api.h" 32#include "bta_hl_int.h" 33#include "l2c_api.h" 34#include "mca_defs.h" 35#include "osi/include/osi.h" 36#include "utl.h" 37 38#if (BTA_HL_DEBUG == TRUE) 39static const char* bta_hl_cch_state_code(tBTA_HL_CCH_STATE state_code); 40static const char* bta_hl_dch_state_code(tBTA_HL_DCH_STATE state_code); 41#endif 42 43extern uint16_t L2CA_AllocateRandomPsm(void); 44extern uint16_t L2CA_AllocatePsm(void); 45/***************************************************************************** 46 * DCH State Table 47 ****************************************************************************/ 48/***************************************************************************** 49 * Constants and types 50 ****************************************************************************/ 51/* state machine action enumeration list for DCH */ 52/* The order of this enumeration must be the same as bta_hl_dch_act_tbl[] */ 53enum { 54 BTA_HL_DCH_MCA_CREATE, 55 BTA_HL_DCH_MCA_CREATE_CFM, 56 BTA_HL_DCH_MCA_CREATE_IND, 57 BTA_HL_DCH_MCA_OPEN_CFM, 58 BTA_HL_DCH_MCA_OPEN_IND, 59 BTA_HL_DCH_MCA_CLOSE, 60 BTA_HL_DCH_MCA_CLOSE_CFM, 61 BTA_HL_DCH_MCA_CLOSE_IND, 62 BTA_HL_DCH_CLOSE_CMPL, 63 BTA_HL_DCH_MCA_RCV_DATA, 64 65 BTA_HL_DCH_SDP_INIT, 66 BTA_HL_DCH_MCA_RECONNECT, 67 BTA_HL_DCH_MCA_RECONNECT_IND, 68 BTA_HL_DCH_MCA_RECONNECT_CFM, 69 BTA_HL_DCH_CLOSE_ECHO_TEST, 70 BTA_HL_DCH_CREATE_RSP, 71 BTA_HL_DCH_MCA_ABORT, 72 BTA_HL_DCH_MCA_ABORT_IND, 73 BTA_HL_DCH_MCA_ABORT_CFM, 74 BTA_HL_DCH_MCA_CONG_CHANGE, 75 76 BTA_HL_DCH_SDP_FAIL, 77 BTA_HL_DCH_SEND_DATA, 78 BTA_HL_DCH_CI_GET_TX_DATA, 79 BTA_HL_DCH_CI_PUT_RX_DATA, 80 BTA_HL_DCH_CI_GET_ECHO_DATA, 81 BTA_HL_DCH_ECHO_TEST, 82 BTA_HL_DCH_CI_PUT_ECHO_DATA, 83 BTA_HL_DCH_IGNORE 84}; 85 86typedef void (*tBTA_HL_DCH_ACTION)(uint8_t app_idx, uint8_t mcl_idx, 87 uint8_t mdl_idx, tBTA_HL_DATA* p_data); 88 89static const tBTA_HL_DCH_ACTION bta_hl_dch_action[] = { 90 bta_hl_dch_mca_create, bta_hl_dch_mca_create_cfm, 91 bta_hl_dch_mca_create_ind, bta_hl_dch_mca_open_cfm, 92 bta_hl_dch_mca_open_ind, bta_hl_dch_mca_close, 93 bta_hl_dch_mca_close_cfm, bta_hl_dch_mca_close_ind, 94 bta_hl_dch_close_cmpl, bta_hl_dch_mca_rcv_data, 95 96 bta_hl_dch_sdp_init, bta_hl_dch_mca_reconnect, 97 bta_hl_dch_mca_reconnect_ind, bta_hl_dch_mca_reconnect_cfm, 98 bta_hl_dch_close_echo_test, bta_hl_dch_create_rsp, 99 bta_hl_dch_mca_abort, bta_hl_dch_mca_abort_ind, 100 bta_hl_dch_mca_abort_cfm, bta_hl_dch_mca_cong_change, 101 102 bta_hl_dch_sdp_fail, bta_hl_dch_send_data, 103 bta_hl_dch_ci_get_tx_data, bta_hl_dch_ci_put_rx_data, 104 bta_hl_dch_ci_get_echo_data, bta_hl_dch_echo_test, 105 bta_hl_dch_ci_put_echo_data, 106}; 107 108/* state table information */ 109#define BTA_HL_DCH_ACTIONS 1 /* number of actions */ 110#define BTA_HL_DCH_ACTION_COL 0 /* position of action */ 111#define BTA_HL_DCH_NEXT_STATE 1 /* position of next state */ 112#define BTA_HL_DCH_NUM_COLS 2 /* number of columns in state tables */ 113 114/* state table for idle state */ 115static const uint8_t bta_hl_dch_st_idle[][BTA_HL_DCH_NUM_COLS] = { 116 /* Event Action 1 Next 117 state */ 118 /* BTA_HL_DCH_SDP_INIT_EVT */ {BTA_HL_DCH_SDP_INIT, 119 BTA_HL_DCH_OPENING_ST}, 120 /* BTA_HL_DCH_OPEN_EVT */ {BTA_HL_DCH_MCA_CREATE, 121 BTA_HL_DCH_OPENING_ST}, 122 /* BTA_HL_MCA_CREATE_IND_EVT */ {BTA_HL_DCH_MCA_CREATE_IND, 123 BTA_HL_DCH_OPENING_ST}, 124 /* BTA_HL_MCA_CREATE_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 125 /* BTA_HL_MCA_OPEN_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 126 127 /* BTA_HL_MCA_OPEN_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 128 /* BTA_HL_DCH_CLOSE_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 129 /* BTA_HL_MCA_CLOSE_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 130 /* BTA_HL_MCA_CLOSE_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 131 /* BTA_HL_API_SEND_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 132 133 /* BTA_HL_MCA_RCV_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 134 /* BTA_HL_DCH_CLOSE_CMPL_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 135 /* BTA_HL_DCH_RECONNECT_EVT */ {BTA_HL_DCH_MCA_RECONNECT, 136 BTA_HL_DCH_OPENING_ST}, 137 /* BTA_HL_DCH_SDP_FAIL_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 138 /* BTA_HL_MCA_RECONNECT_IND_EVT*/ {BTA_HL_DCH_MCA_RECONNECT_IND, 139 BTA_HL_DCH_OPENING_ST}, 140 141 /* BTA_HL_MCA_RECONNECT_CFM_EVT*/ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 142 /* BTA_HL_DCH_CLOSE_ECHO_TEST_EVT*/ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 143 /* BTA_HL_API_DCH_CREATE_RSP_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 144 /* BTA_HL_DCH_ABORT_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 145 /* BTA_HL_MCA_ABORT_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 146 147 /* BTA_HL_MCA_ABORT_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 148 /* BTA_HL_MCA_CONG_CHG_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 149 /* BTA_HL_CI_GET_TX_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 150 /* BTA_HL_CI_PUT_RX_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 151 /* BTA_HL_CI_GET_ECHO_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 152 /* BTA_HL_DCH_ECHO_TEST_EVT */ {BTA_HL_DCH_ECHO_TEST, 153 BTA_HL_DCH_OPENING_ST}, 154 /* BTA_HL_CI_PUT_ECHO_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}}; 155 156/* state table for opening state */ 157static const uint8_t bta_hl_dch_st_opening[][BTA_HL_DCH_NUM_COLS] = { 158 /* Event Action 1 Next 159 state */ 160 /* BTA_HL_DCH_SDP_INIT_EVT */ {BTA_HL_DCH_SDP_INIT, 161 BTA_HL_DCH_OPENING_ST}, 162 /* BTA_HL_DCH_OPEN_EVT */ {BTA_HL_DCH_MCA_CREATE, 163 BTA_HL_DCH_OPENING_ST}, 164 /* BTA_HL_MCA_CREATE_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPENING_ST}, 165 /* BTA_HL_MCA_CREATE_CFM_EVT */ {BTA_HL_DCH_MCA_CREATE_CFM, 166 BTA_HL_DCH_OPENING_ST}, 167 /* BTA_HL_MCA_OPEN_IND_EVT */ {BTA_HL_DCH_MCA_OPEN_IND, 168 BTA_HL_DCH_OPEN_ST}, 169 /* BTA_HL_MCA_OPEN_CFM_EVT */ {BTA_HL_DCH_MCA_OPEN_CFM, 170 BTA_HL_DCH_OPEN_ST}, 171 /* BTA_HL_DCH_CLOSE_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPENING_ST}, 172 /* BTA_HL_MCA_CLOSE_IND_EVT */ {BTA_HL_DCH_MCA_CLOSE_IND, 173 BTA_HL_DCH_CLOSING_ST}, 174 /* BTA_HL_MCA_CLOSE_CFM_EVT */ {BTA_HL_DCH_MCA_CLOSE_CFM, 175 BTA_HL_DCH_CLOSING_ST}, 176 /* BTA_HL_API_SEND_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 177 178 /* BTA_HL_MCA_RCV_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 179 /* BTA_HL_DCH_CLOSE_CMPL_EVT */ {BTA_HL_DCH_CLOSE_CMPL, BTA_HL_DCH_IDLE_ST}, 180 /* BTA_HL_DCH_RECONNECT_EVT */ {BTA_HL_DCH_MCA_RECONNECT, 181 BTA_HL_DCH_OPENING_ST}, 182 /* BTA_HL_DCH_SDP_FAIL_EVT */ {BTA_HL_DCH_SDP_FAIL, 183 BTA_HL_DCH_CLOSING_ST}, 184 /* BTA_HL_MCA_RECONNECT_IND_EVT*/ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_IDLE_ST}, 185 /* BTA_HL_MCA_RECONNECT_CFM_EVT*/ {BTA_HL_DCH_MCA_RECONNECT_CFM, 186 BTA_HL_DCH_OPENING_ST}, 187 /* BTA_HL_DCH_CLOSE_ECHO_TEST_EVT*/ {BTA_HL_DCH_IGNORE, 188 BTA_HL_DCH_OPENING_ST}, 189 /* BTA_HL_API_DCH_CREATE_RSP_EVT */ {BTA_HL_DCH_CREATE_RSP, 190 BTA_HL_DCH_OPENING_ST}, 191 /* BTA_HL_DCH_ABORT_EVT */ {BTA_HL_DCH_MCA_ABORT, BTA_HL_DCH_OPENING_ST}, 192 /* BTA_HL_MCA_ABORT_IND_EVT */ {BTA_HL_DCH_MCA_ABORT_IND, 193 BTA_HL_DCH_OPENING_ST}, 194 195 /* BTA_HL_MCA_ABORT_CFM_EVT */ {BTA_HL_DCH_MCA_ABORT_CFM, 196 BTA_HL_DCH_OPENING_ST}, 197 /* BTA_HL_MCA_CONG_CHG_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPENING_ST}, 198 /* BTA_HL_CI_GET_TX_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPENING_ST}, 199 /* BTA_HL_CI_PUT_RX_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPENING_ST}, 200 /* BTA_HL_CI_GET_ECHO_DATA_EVT */ {BTA_HL_DCH_CI_GET_ECHO_DATA, 201 BTA_HL_DCH_OPENING_ST}, 202 /* BTA_HL_DCH_ECHO_TEST_EVT */ {BTA_HL_DCH_ECHO_TEST, 203 BTA_HL_DCH_OPENING_ST}, 204 /* BTA_HL_CI_PUT_ECHO_DATA_EVT */ {BTA_HL_DCH_IGNORE, 205 BTA_HL_DCH_OPENING_ST}}; 206 207/* state table for open state */ 208static const uint8_t bta_hl_dch_st_open[][BTA_HL_DCH_NUM_COLS] = { 209 /* Event Action 1 Next 210 state */ 211 /* BTA_HL_DCH_SDP_INIT_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 212 /* BTA_HL_DCH_OPEN_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 213 /* BTA_HL_MCA_CREATE_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 214 /* BTA_HL_MCA_CREATE_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 215 /* BTA_HL_MCA_OPEN_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 216 /* BTA_HL_MCA_OPEN_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 217 /* BTA_HL_DCH_CLOSE_EVT */ {BTA_HL_DCH_MCA_CLOSE, 218 BTA_HL_DCH_CLOSING_ST}, 219 /* BTA_HL_MCA_CLOSE_IND_EVT */ {BTA_HL_DCH_MCA_CLOSE_IND, 220 BTA_HL_DCH_CLOSING_ST}, 221 /* BTA_HL_MCA_CLOSE_CFM_EVT */ {BTA_HL_DCH_MCA_CLOSE_CFM, 222 BTA_HL_DCH_CLOSING_ST}, 223 /* BTA_HL_API_SEND_DATA_EVT */ {BTA_HL_DCH_SEND_DATA, BTA_HL_DCH_OPEN_ST}, 224 225 /* BTA_HL_MCA_RCV_DATA_EVT */ {BTA_HL_DCH_MCA_RCV_DATA, 226 BTA_HL_DCH_OPEN_ST}, 227 /* BTA_HL_DCH_CLOSE_CMPL_EVT */ {BTA_HL_DCH_CLOSE_CMPL, BTA_HL_DCH_IDLE_ST}, 228 /* BTA_HL_DCH_RECONNECT_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 229 /* BTA_HL_DCH_SDP_FAIL_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 230 /* BTA_HL_MCA_RECONNECT_IND_EVT*/ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 231 /* BTA_HL_MCA_RECONNECT_CFM_EVT*/ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 232 /* BTA_HL_DCH_CLOSE_ECHO_TEST_EVT*/ {BTA_HL_DCH_CLOSE_ECHO_TEST, 233 BTA_HL_DCH_CLOSING_ST}, 234 /* BTA_HL_API_DCH_CREATE_RSP_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 235 /* BTA_HL_DCH_ABORT_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 236 /* BTA_HL_MCA_ABORT_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 237 238 /* BTA_HL_DCH_ABORT_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 239 /* BTA_HL_MCA_CONG_CHG_EVT */ {BTA_HL_DCH_MCA_CONG_CHANGE, 240 BTA_HL_DCH_OPEN_ST}, 241 /* BTA_HL_CI_GET_TX_DATA_EVT */ {BTA_HL_DCH_CI_GET_TX_DATA, 242 BTA_HL_DCH_OPEN_ST}, 243 /* BTA_HL_CI_PUT_RX_DATA_EVT */ {BTA_HL_DCH_CI_PUT_RX_DATA, 244 BTA_HL_DCH_OPEN_ST}, 245 /* BTA_HL_CI_GET_ECHO_DATA_EVT */ {BTA_HL_DCH_CI_GET_ECHO_DATA, 246 BTA_HL_DCH_OPEN_ST}, 247 /* BTA_HL_DCH_ECHO_TEST_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_OPEN_ST}, 248 /* BTA_HL_CI_PUT_ECHO_DATA_EVT */ {BTA_HL_DCH_CI_PUT_ECHO_DATA, 249 BTA_HL_DCH_OPEN_ST}}; 250 251/* state table for closing state */ 252static const uint8_t bta_hl_dch_st_closing[][BTA_HL_DCH_NUM_COLS] = { 253 /* Event Action 1 Next state */ 254 /* BTA_HL_DCH_SDP_INIT_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 255 /* BTA_HL_DCH_OPEN_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 256 /* BTA_HL_MCA_CREATE_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 257 /* BTA_HL_MCA_CREATE_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 258 /* BTA_HL_MCA_OPEN_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 259 /* BTA_HL_MCA_OPEN_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 260 /* BTA_HL_DCH_CLOSE_EVT */ {BTA_HL_DCH_MCA_CLOSE, 261 BTA_HL_DCH_CLOSING_ST}, 262 /* BTA_HL_MCA_CLOSE_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 263 /* BTA_HL_MCA_CLOSE_CFM_EVT */ {BTA_HL_DCH_MCA_CLOSE_CFM, 264 BTA_HL_DCH_CLOSING_ST}, 265 /* BTA_HL_API_SEND_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 266 267 /* BTA_HL_MCA_RCV_DATA_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 268 /* BTA_HL_DCH_CLOSE_CMPL_EVT */ {BTA_HL_DCH_CLOSE_CMPL, BTA_HL_DCH_IDLE_ST}, 269 /* BTA_HL_DCH_RECONNECT_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 270 /* BTA_HL_DCH_SDP_FAIL_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 271 /* BTA_HL_MCA_RECONNECT_IND_EVT*/ {BTA_HL_DCH_IGNORE, 272 BTA_HL_DCH_CLOSING_ST}, 273 /* BTA_HL_MCA_RECONNECT_CFM_EVT*/ {BTA_HL_DCH_IGNORE, 274 BTA_HL_DCH_CLOSING_ST}, 275 /* BTA_HL_DCH_CLOSE_ECHO_TEST_EVT*/ {BTA_HL_DCH_IGNORE, 276 BTA_HL_DCH_CLOSING_ST}, 277 /* BTA_HL_API_DCH_CREATE_RSP_EVT */ {BTA_HL_DCH_IGNORE, 278 BTA_HL_DCH_CLOSING_ST}, 279 /* BTA_HL_DCH_ABORT_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 280 /* BTA_HL_MCA_ABORT_IND_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 281 282 /* BTA_HL_DCH_ABORT_CFM_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 283 /* BTA_HL_MCA_CONG_CHG_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 284 /* BTA_HL_CI_GET_TX_DATA_EVT */ {BTA_HL_DCH_CI_GET_TX_DATA, 285 BTA_HL_DCH_CLOSING_ST}, 286 /* BTA_HL_CI_PUT_RX_DATA_EVT */ {BTA_HL_DCH_CI_PUT_RX_DATA, 287 BTA_HL_DCH_CLOSING_ST}, 288 /* BTA_HL_CI_GET_ECHO_DATA_EVT */ {BTA_HL_DCH_CI_GET_ECHO_DATA, 289 BTA_HL_DCH_CLOSING_ST}, 290 /* BTA_HL_DCH_ECHO_TEST_EVT */ {BTA_HL_DCH_IGNORE, BTA_HL_DCH_CLOSING_ST}, 291 /* BTA_HL_CI_PUT_ECHO_DATA_EVT */ {BTA_HL_DCH_CI_PUT_ECHO_DATA, 292 BTA_HL_DCH_CLOSING_ST}}; 293 294/* type for state table */ 295typedef const uint8_t (*tBTA_HL_DCH_ST_TBL)[BTA_HL_DCH_NUM_COLS]; 296 297/* state table */ 298const tBTA_HL_DCH_ST_TBL bta_hl_dch_st_tbl[] = { 299 bta_hl_dch_st_idle, bta_hl_dch_st_opening, bta_hl_dch_st_open, 300 bta_hl_dch_st_closing}; 301 302/***************************************************************************** 303 * CCH State Table 304 ****************************************************************************/ 305/***************************************************************************** 306 * Constants and types 307 ****************************************************************************/ 308/* state machine action enumeration list for CCH */ 309enum { 310 BTA_HL_CCH_SDP_INIT, 311 BTA_HL_CCH_MCA_OPEN, 312 BTA_HL_CCH_MCA_CLOSE, 313 BTA_HL_CCH_CLOSE_CMPL, 314 BTA_HL_CCH_MCA_CONNECT, 315 BTA_HL_CCH_MCA_DISCONNECT, 316 BTA_HL_CCH_MCA_RSP_TOUT, 317 BTA_HL_CCH_MCA_DISC_OPEN, 318 BTA_HL_CCH_IGNORE 319}; 320 321/* type for action functions */ 322typedef void (*tBTA_HL_CCH_ACTION)(uint8_t app_idx, uint8_t mcl_idx, 323 tBTA_HL_DATA* p_data); 324 325/* action function list for MAS */ 326const tBTA_HL_CCH_ACTION bta_hl_cch_action[] = { 327 bta_hl_cch_sdp_init, bta_hl_cch_mca_open, bta_hl_cch_mca_close, 328 bta_hl_cch_close_cmpl, bta_hl_cch_mca_connect, bta_hl_cch_mca_disconnect, 329 bta_hl_cch_mca_rsp_tout, bta_hl_cch_mca_disc_open}; 330 331/* state table information */ 332#define BTA_HL_CCH_ACTIONS 1 /* number of actions */ 333#define BTA_HL_CCH_NEXT_STATE 1 /* position of next state */ 334#define BTA_HL_CCH_NUM_COLS 2 /* number of columns in state tables */ 335 336/* state table for MAS idle state */ 337static const uint8_t bta_hl_cch_st_idle[][BTA_HL_CCH_NUM_COLS] = { 338 /* Event Action 1 Next state */ 339 /* BTA_HL_CCH_OPEN_EVT */ {BTA_HL_CCH_SDP_INIT, 340 BTA_HL_CCH_OPENING_ST}, 341 /* BTA_HL_CCH_SDP_OK_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_IDLE_ST}, 342 /* BTA_HL_CCH_SDP_FAIL_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_IDLE_ST}, 343 /* BTA_HL_MCA_CONNECT_IND_EVT */ {BTA_HL_CCH_MCA_CONNECT, 344 BTA_HL_CCH_OPEN_ST}, 345 /* BTA_HL_MCA_DISCONNECT_IND_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_IDLE_ST}, 346 /* BTA_HL_CCH_CLOSE_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_IDLE_ST}, 347 /* BTA_HL_CCH_CLOSE_CMPL_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_IDLE_ST}, 348 /* BTA_HL_CCH_CLOSE_CMPL_EVT */ {BTA_HL_CCH_IGNORE, 349 BTA_HL_CCH_IDLE_ST}}; 350 351/* state table for obex/rfcomm connection state */ 352static const uint8_t bta_hl_cch_st_opening[][BTA_HL_CCH_NUM_COLS] = { 353 /* Event Action 1 Next state */ 354 /* BTA_HL_CCH_OPEN_EVT */ {BTA_HL_CCH_IGNORE, 355 BTA_HL_CCH_OPENING_ST}, 356 /* BTA_HL_CCH_SDP_OK_EVT */ {BTA_HL_CCH_MCA_OPEN, 357 BTA_HL_CCH_OPENING_ST}, 358 /* BTA_HL_CCH_SDP_FAIL_EVT */ {BTA_HL_CCH_CLOSE_CMPL, 359 BTA_HL_CCH_IDLE_ST}, 360 /* BTA_HL_MCA_CONNECT_IND_EVT */ {BTA_HL_CCH_MCA_CONNECT, 361 BTA_HL_CCH_OPEN_ST}, 362 /* BTA_HL_MCA_DISCONNECT_IND_EVT */ {BTA_HL_CCH_MCA_DISCONNECT, 363 BTA_HL_CCH_CLOSING_ST}, 364 /* BTA_HL_CCH_CLOSE_EVT */ {BTA_HL_CCH_MCA_CLOSE, 365 BTA_HL_CCH_CLOSING_ST}, 366 /* BTA_HL_CCH_CLOSE_CMPL_EVT */ {BTA_HL_CCH_CLOSE_CMPL, 367 BTA_HL_CCH_IDLE_ST}, 368 /* BTA_HL_MCA_RSP_TOUT_IND_EVT */ {BTA_HL_CCH_MCA_RSP_TOUT, 369 BTA_HL_CCH_CLOSING_ST}}; 370 371/* state table for open state */ 372static const uint8_t bta_hl_cch_st_open[][BTA_HL_CCH_NUM_COLS] = { 373 /* Event Action 1 Next state */ 374 /* BTA_HL_CCH_OPEN_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_OPEN_ST}, 375 /* BTA_HL_CCH_SDP_OK_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_OPEN_ST}, 376 /* BTA_HL_CCH_SDP_FAIL_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_OPEN_ST}, 377 /* BTA_HL_MCA_CONNECT_IND_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_OPEN_ST}, 378 /* BTA_HL_MCA_DISCONNECT_IND_EVT */ {BTA_HL_CCH_MCA_DISCONNECT, 379 BTA_HL_CCH_CLOSING_ST}, 380 /* BTA_HL_CCH_CLOSE_EVT */ {BTA_HL_CCH_MCA_CLOSE, 381 BTA_HL_CCH_CLOSING_ST}, 382 /* BTA_HL_CCH_CLOSE_CMPL_EVT */ {BTA_HL_CCH_IGNORE, BTA_HL_CCH_OPEN_ST}, 383 /* BTA_HL_MCA_RSP_TOUT_IND_EVT */ {BTA_HL_CCH_MCA_RSP_TOUT, 384 BTA_HL_CCH_CLOSING_ST}}; 385 386/* state table for closing state */ 387static const uint8_t bta_hl_cch_st_closing[][BTA_HL_CCH_NUM_COLS] = { 388 /* Event Action 1 Next state */ 389 /* BTA_HL_CCH_OPEN_EVT */ {BTA_HL_CCH_IGNORE, 390 BTA_HL_CCH_CLOSING_ST}, 391 /* BTA_HL_CCH_SDP_OK_EVT */ {BTA_HL_CCH_CLOSE_CMPL, 392 BTA_HL_CCH_IDLE_ST}, 393 /* BTA_HL_CCH_SDP_FAIL_EVT */ {BTA_HL_CCH_CLOSE_CMPL, 394 BTA_HL_CCH_IDLE_ST}, 395 /* BTA_HL_MCA_CONNECT_IND_EVT */ {BTA_HL_CCH_MCA_DISC_OPEN, 396 BTA_HL_CCH_CLOSING_ST}, 397 /* BTA_HL_MCA_DISCONNECT_IND_EVT */ {BTA_HL_CCH_MCA_DISCONNECT, 398 BTA_HL_CCH_CLOSING_ST}, 399 /* BTA_HL_CCH_CLOSE_EVT */ {BTA_HL_CCH_MCA_CLOSE, 400 BTA_HL_CCH_CLOSING_ST}, 401 /* BTA_HL_CCH_CLOSE_CMPL_EVT */ {BTA_HL_CCH_CLOSE_CMPL, 402 BTA_HL_CCH_IDLE_ST}, 403 /* BTA_HL_MCA_RSP_TOUT_IND_EVT */ {BTA_HL_CCH_IGNORE, 404 BTA_HL_CCH_CLOSING_ST}}; 405 406/* type for state table CCH */ 407typedef const uint8_t (*tBTA_HL_CCH_ST_TBL)[BTA_HL_CCH_NUM_COLS]; 408 409/* MAS state table */ 410const tBTA_HL_CCH_ST_TBL bta_hl_cch_st_tbl[] = { 411 bta_hl_cch_st_idle, bta_hl_cch_st_opening, bta_hl_cch_st_open, 412 bta_hl_cch_st_closing}; 413 414/***************************************************************************** 415 * Global data 416 ****************************************************************************/ 417 418/* HL control block */ 419tBTA_HL_CB bta_hl_cb; 420 421/******************************************************************************* 422 * 423 * Function bta_hl_cch_sm_execute 424 * 425 * Description State machine event handling function for CCH 426 * 427 * Returns void 428 * 429 ******************************************************************************/ 430void bta_hl_cch_sm_execute(uint8_t app_idx, uint8_t mcl_idx, uint16_t event, 431 tBTA_HL_DATA* p_data) { 432 tBTA_HL_CCH_ST_TBL state_table; 433 uint8_t action; 434 int i; 435 tBTA_HL_MCL_CB* p_cb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 436 437#if (BTA_HL_DEBUG == TRUE) 438 tBTA_HL_CCH_STATE in_state = p_cb->cch_state; 439 uint16_t cur_evt = event; 440 APPL_TRACE_DEBUG("HDP CCH Event Handler: State 0x%02x [%s], Event [%s]", 441 in_state, bta_hl_cch_state_code(in_state), 442 bta_hl_evt_code(cur_evt)); 443#endif 444 445 /* look up the state table for the current state */ 446 state_table = bta_hl_cch_st_tbl[p_cb->cch_state]; 447 448 event &= 0x00FF; 449 450 /* set next state */ 451 p_cb->cch_state = state_table[event][BTA_HL_CCH_NEXT_STATE]; 452 453 for (i = 0; i < BTA_HL_CCH_ACTIONS; i++) { 454 if ((action = state_table[event][i]) != BTA_HL_CCH_IGNORE) { 455 (*bta_hl_cch_action[action])(app_idx, mcl_idx, p_data); 456 } else { 457 /* discard HDP data */ 458 bta_hl_discard_data(p_data->hdr.event, p_data); 459 break; 460 } 461 } 462#if (BTA_HL_DEBUG == TRUE) 463 if (in_state != p_cb->cch_state) { 464 APPL_TRACE_DEBUG("HL CCH State Change: [%s] -> [%s] after [%s]", 465 bta_hl_cch_state_code(in_state), 466 bta_hl_cch_state_code(p_cb->cch_state), 467 bta_hl_evt_code(cur_evt)); 468 } 469#endif 470} 471 472/******************************************************************************* 473 * 474 * Function bta_hl_dch_sm_execute 475 * 476 * Description State machine event handling function for DCH 477 * 478 * Returns void 479 * 480 ******************************************************************************/ 481void bta_hl_dch_sm_execute(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx, 482 uint16_t event, tBTA_HL_DATA* p_data) { 483 tBTA_HL_DCH_ST_TBL state_table; 484 uint8_t action; 485 int i; 486 tBTA_HL_MDL_CB* p_cb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 487 488#if (BTA_HL_DEBUG == TRUE) 489 tBTA_HL_DCH_STATE in_state = p_cb->dch_state; 490 uint16_t cur_evt = event; 491 APPL_TRACE_DEBUG("HDP DCH Event Handler: State 0x%02x [%s], Event [%s]", 492 in_state, bta_hl_dch_state_code(in_state), 493 bta_hl_evt_code(cur_evt)); 494#endif 495 496 /* look up the state table for the current state */ 497 state_table = bta_hl_dch_st_tbl[p_cb->dch_state]; 498 event -= BTA_HL_DCH_EVT_MIN; 499 500 /* set next state */ 501 p_cb->dch_state = state_table[event][BTA_HL_DCH_NEXT_STATE]; 502 503 for (i = 0; i < BTA_HL_DCH_ACTIONS; i++) { 504 if ((action = state_table[event][i]) != BTA_HL_DCH_IGNORE) { 505 (*bta_hl_dch_action[action])(app_idx, mcl_idx, mdl_idx, p_data); 506 } else { 507 /* discard mas data */ 508 bta_hl_discard_data(p_data->hdr.event, p_data); 509 break; 510 } 511 } 512 513#if (BTA_HL_DEBUG == TRUE) 514 if (in_state != p_cb->dch_state) { 515 APPL_TRACE_DEBUG("HL DCH State Change: [%s] -> [%s] after [%s]", 516 bta_hl_dch_state_code(in_state), 517 bta_hl_dch_state_code(p_cb->dch_state), 518 bta_hl_evt_code(cur_evt)); 519 } 520#endif 521} 522/******************************************************************************* 523 * 524 * Function bta_hl_api_enable 525 * 526 * Description Process the API enable request to enable the HL subsystem 527 * 528 * Returns void 529 * 530 ******************************************************************************/ 531static void bta_hl_api_enable(tBTA_HL_CB* p_cb, tBTA_HL_DATA* p_data) { 532 tBTA_HL_CTRL evt_data; 533 534 /* If already enabled then reject this request */ 535 if (p_cb->enable) { 536 APPL_TRACE_ERROR("HL is already enabled"); 537 evt_data.enable_cfm.status = BTA_HL_STATUS_FAIL; 538 if (p_data->api_enable.p_cback) 539 p_data->api_enable.p_cback(BTA_HL_CTRL_ENABLE_CFM_EVT, 540 (tBTA_HL_CTRL*)&evt_data); 541 return; 542 } 543 544 /* Done with checking. now perform the enable oepration*/ 545 /* initialize control block */ 546 memset(p_cb, 0, sizeof(tBTA_HL_CB)); 547 p_cb->enable = true; 548 p_cb->p_ctrl_cback = p_data->api_enable.p_cback; 549 evt_data.enable_cfm.status = BTA_HL_STATUS_OK; 550 if (p_data->api_enable.p_cback) 551 p_data->api_enable.p_cback(BTA_HL_CTRL_ENABLE_CFM_EVT, 552 (tBTA_HL_CTRL*)&evt_data); 553} 554/******************************************************************************* 555 * 556 * Function bta_hl_api_disable 557 * 558 * Description Process the API disable request to disable the HL subsystem 559 * 560 * Returns void 561 * 562 ******************************************************************************/ 563static void bta_hl_api_disable(tBTA_HL_CB* p_cb, tBTA_HL_DATA* p_data) { 564 tBTA_HL_CTRL evt_data; 565 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 566 567 if (p_cb->enable) { 568 p_cb->disabling = true; 569 bta_hl_check_disable(p_data); 570 } else { 571 status = BTA_HL_STATUS_FAIL; 572 evt_data.disable_cfm.status = status; 573 if (p_cb->p_ctrl_cback) 574 p_cb->p_ctrl_cback(BTA_HL_CTRL_DISABLE_CFM_EVT, (tBTA_HL_CTRL*)&evt_data); 575 } 576 577#if (BTA_HL_DEBUG == TRUE) 578 if (status != BTA_HL_STATUS_OK) { 579 APPL_TRACE_DEBUG("bta_hl_api_disable status =%s", 580 bta_hl_status_code(status)); 581 } 582#endif 583} 584 585/******************************************************************************* 586 * 587 * Function bta_hl_api_update 588 * 589 * Description Process the API registration request to register an HDP 590 *applciation 591 * 592 * Returns void 593 * 594 ******************************************************************************/ 595static void bta_hl_api_update(tBTA_HL_CB* p_cb, tBTA_HL_DATA* p_data) { 596 tBTA_HL evt_data; 597 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(0); 598 tBTA_HL_STATUS status = BTA_HL_STATUS_FAIL; 599 600 APPL_TRACE_DEBUG("bta_hl_api_update"); 601 if (p_cb->enable) { 602 status = bta_hl_app_update(p_data->api_update.app_id, 603 p_data->api_update.is_register); 604 if (!p_data->api_update.is_register) { 605 APPL_TRACE_DEBUG("Deregister"); 606 memset(&evt_data, 0, sizeof(tBTA_HL)); 607 evt_data.dereg_cfm.status = status; 608 evt_data.dereg_cfm.app_id = p_data->api_update.app_id; 609 if (status == BTA_HL_STATUS_OK) 610 evt_data.dereg_cfm.app_handle = p_acb->app_handle; 611 if (p_acb->p_cback) { 612 p_acb->p_cback(BTA_HL_DEREGISTER_CFM_EVT, (tBTA_HL*)&evt_data); 613 } 614 return; 615 } 616 } 617 618 if (status != BTA_HL_STATUS_OK) { 619 if ((status != BTA_HL_STATUS_DUPLICATE_APP_ID) && 620 (status != BTA_HL_STATUS_NO_RESOURCE)) { 621 if (p_acb) memset(p_acb, 0, sizeof(tBTA_HL_APP_CB)); 622 } 623 } 624#if (BTA_HL_DEBUG == TRUE) 625 if (status != BTA_HL_STATUS_OK) { 626 APPL_TRACE_DEBUG("bta_hl_api_register status =%s", 627 bta_hl_status_code(status)); 628 } 629#endif 630 631 memset(&evt_data, 0, sizeof(tBTA_HL)); 632 evt_data.reg_cfm.status = status; 633 evt_data.reg_cfm.app_id = p_data->api_update.app_id; 634 if (status == BTA_HL_STATUS_OK) 635 evt_data.reg_cfm.app_handle = p_acb->app_handle; 636 if (p_data->api_reg.p_cback) { 637 p_data->api_reg.p_cback(BTA_HL_REGISTER_CFM_EVT, (tBTA_HL*)&evt_data); 638 } 639 640 if (status == BTA_HL_STATUS_OK) { 641 evt_data.sdp_info_ind.app_handle = p_acb->app_handle; 642 evt_data.sdp_info_ind.ctrl_psm = p_acb->ctrl_psm; 643 evt_data.sdp_info_ind.data_psm = p_acb->data_psm; 644 evt_data.sdp_info_ind.data_x_spec = BTA_HL_SDP_IEEE_11073_20601; 645 evt_data.sdp_info_ind.mcap_sup_procs = BTA_HL_MCAP_SUP_PROC_MASK; 646 647 if (p_data->api_reg.p_cback) { 648 p_data->api_reg.p_cback(BTA_HL_SDP_INFO_IND_EVT, (tBTA_HL*)&evt_data); 649 } 650 } 651} 652 653/******************************************************************************* 654 * 655 * Function bta_hl_api_register 656 * 657 * Description Process the API registration request to register an HDP 658 *applciation 659 * 660 * Returns void 661 * 662 ******************************************************************************/ 663static void bta_hl_api_register(tBTA_HL_CB* p_cb, tBTA_HL_DATA* p_data) { 664 tBTA_HL evt_data; 665 uint8_t app_idx; 666 tBTA_HL_APP_CB* p_acb = NULL; 667 tBTA_HL_STATUS status = BTA_HL_STATUS_FAIL; 668 669 if (p_cb->enable) { 670 if (!bta_hl_is_a_duplicate_id(p_data->api_reg.app_id)) { 671 if (bta_hl_find_avail_app_idx(&app_idx)) { 672 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 673 p_acb->in_use = true; 674 p_acb->app_id = p_data->api_reg.app_id; 675 p_acb->p_cback = p_data->api_reg.p_cback; 676 p_acb->sec_mask = p_data->api_reg.sec_mask; 677 p_acb->dev_type = p_data->api_reg.dev_type; 678 strlcpy(p_acb->srv_name, p_data->api_reg.srv_name, 679 BTA_SERVICE_NAME_LEN); 680 strlcpy(p_acb->srv_desp, p_data->api_reg.srv_desp, 681 BTA_SERVICE_DESP_LEN); 682 strlcpy(p_acb->provider_name, p_data->api_reg.provider_name, 683 BTA_PROVIDER_NAME_LEN); 684 bta_hl_cb.p_alloc_psm = L2CA_AllocatePSM; 685 p_acb->ctrl_psm = bta_hl_cb.p_alloc_psm(); 686 p_acb->data_psm = bta_hl_cb.p_alloc_psm(); 687 p_acb->p_mcap_cback = bta_hl_mcap_ctrl_cback; 688 status = bta_hl_app_registration(app_idx); 689 } else { 690 status = BTA_HL_STATUS_NO_RESOURCE; 691 } 692 } else { 693 status = BTA_HL_STATUS_DUPLICATE_APP_ID; 694 } 695 } 696 697 if (status != BTA_HL_STATUS_OK) { 698 if ((status != BTA_HL_STATUS_DUPLICATE_APP_ID) && 699 (status != BTA_HL_STATUS_NO_RESOURCE)) { 700 if (p_acb) memset(p_acb, 0, sizeof(tBTA_HL_APP_CB)); 701 } 702 } 703#if (BTA_HL_DEBUG == TRUE) 704 if (status != BTA_HL_STATUS_OK) { 705 APPL_TRACE_DEBUG("bta_hl_api_register status =%s", 706 bta_hl_status_code(status)); 707 } 708#endif 709 710 memset(&evt_data, 0, sizeof(tBTA_HL)); 711 evt_data.reg_cfm.status = status; 712 evt_data.reg_cfm.app_id = p_data->api_reg.app_id; 713 if (status == BTA_HL_STATUS_OK) 714 evt_data.reg_cfm.app_handle = p_acb->app_handle; 715 if (p_data->api_reg.p_cback) { 716 p_data->api_reg.p_cback(BTA_HL_REGISTER_CFM_EVT, (tBTA_HL*)&evt_data); 717 } 718 719 if (status == BTA_HL_STATUS_OK) { 720 evt_data.sdp_info_ind.app_handle = p_acb->app_handle; 721 evt_data.sdp_info_ind.ctrl_psm = p_acb->ctrl_psm; 722 evt_data.sdp_info_ind.data_psm = p_acb->data_psm; 723 evt_data.sdp_info_ind.data_x_spec = BTA_HL_SDP_IEEE_11073_20601; 724 evt_data.sdp_info_ind.mcap_sup_procs = BTA_HL_MCAP_SUP_PROC_MASK; 725 726 if (p_data->api_reg.p_cback) { 727 p_data->api_reg.p_cback(BTA_HL_SDP_INFO_IND_EVT, (tBTA_HL*)&evt_data); 728 } 729 } 730} 731 732/******************************************************************************* 733 * 734 * Function bta_hl_api_deregister 735 * 736 * Description Process the API de-registration request 737 * 738 * Returns void 739 * 740 ******************************************************************************/ 741static void bta_hl_api_deregister(UNUSED_ATTR tBTA_HL_CB* p_cb, 742 tBTA_HL_DATA* p_data) { 743 uint8_t app_idx; 744 tBTA_HL_APP_CB* p_acb; 745 746 if (bta_hl_find_app_idx_using_handle(p_data->api_dereg.app_handle, 747 &app_idx)) { 748 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 749 p_acb->deregistering = true; 750 bta_hl_check_deregistration(app_idx, p_data); 751 } else { 752 APPL_TRACE_ERROR("Invalid app_handle=%d", p_data->api_dereg.app_handle); 753 } 754} 755 756/******************************************************************************* 757 * 758 * Function bta_hl_api_cch_open 759 * 760 * Description Process the API CCH open request 761 * 762 * Returns void 763 * 764 ******************************************************************************/ 765static void bta_hl_api_cch_open(UNUSED_ATTR tBTA_HL_CB* p_cb, 766 tBTA_HL_DATA* p_data) { 767 tBTA_HL evt_data; 768 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 769 uint8_t app_idx, mcl_idx; 770 tBTA_HL_APP_CB* p_acb; 771 tBTA_HL_MCL_CB* p_mcb; 772 773 if (bta_hl_find_app_idx_using_handle(p_data->api_cch_open.app_handle, 774 &app_idx)) { 775 if (!bta_hl_find_mcl_idx(app_idx, p_data->api_cch_open.bd_addr, &mcl_idx)) { 776 if (bta_hl_find_avail_mcl_idx(app_idx, &mcl_idx)) { 777 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 778 p_mcb->in_use = true; 779 p_mcb->req_ctrl_psm = p_data->api_cch_open.ctrl_psm; 780 p_mcb->sec_mask = p_data->api_cch_open.sec_mask; 781 bdcpy(p_mcb->bd_addr, p_data->api_cch_open.bd_addr); 782 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_OPEN; 783 } else { 784 status = BTA_HL_STATUS_NO_RESOURCE; 785 } 786 } else { 787 /* Only one MCL per BD_ADDR */ 788 status = BTA_HL_STATUS_DUPLICATE_CCH_OPEN; 789 APPL_TRACE_DEBUG("bta_hl_api_cch_open: CCH already open: status =%d", 790 status) 791 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 792 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 793 if (p_acb->p_cback) { 794 bta_hl_build_cch_open_cfm(&evt_data, p_data->api_cch_open.app_id, 795 p_data->api_cch_open.app_handle, 796 p_mcb->mcl_handle, 797 p_data->api_cch_open.bd_addr, status); 798 p_acb->p_cback(BTA_HL_CCH_OPEN_CFM_EVT, (tBTA_HL*)&evt_data); 799 } else { 800 APPL_TRACE_ERROR("bta_hl_api_cch_open Null Callback"); 801 } 802 return; 803 } 804 } else { 805 status = BTA_HL_STATUS_INVALID_APP_HANDLE; 806 } 807#if (BTA_HL_DEBUG == TRUE) 808 if (status != BTA_HL_STATUS_OK) { 809 APPL_TRACE_DEBUG("bta_hl_api_cch_open status =%s", 810 bta_hl_status_code(status)); 811 } 812#endif 813 switch (status) { 814 case BTA_HL_STATUS_OK: 815 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_OPEN_EVT, p_data); 816 break; 817 case BTA_HL_STATUS_NO_RESOURCE: 818 case BTA_HL_STATUS_FAIL: 819 820 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 821 if (p_acb->p_cback) { 822 bta_hl_build_cch_open_cfm(&evt_data, p_data->api_cch_open.app_id, 823 p_data->api_cch_open.app_handle, 0, 824 p_data->api_cch_open.bd_addr, status); 825 p_acb->p_cback(BTA_HL_CCH_OPEN_CFM_EVT, (tBTA_HL*)&evt_data); 826 } else { 827 APPL_TRACE_ERROR("bta_hl_api_cch_open Null Callback"); 828 } 829 break; 830 default: 831 APPL_TRACE_ERROR("status code=%d", status); 832 break; 833 } 834} 835 836/******************************************************************************* 837 * 838 * Function bta_hl_api_cch_close 839 * 840 * Description Process the API CCH close request 841 * 842 * Returns void 843 * 844 ******************************************************************************/ 845static void bta_hl_api_cch_close(UNUSED_ATTR tBTA_HL_CB* p_cb, 846 tBTA_HL_DATA* p_data) { 847 tBTA_HL evt_data; 848 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 849 uint8_t app_idx, mcl_idx; 850 tBTA_HL_APP_CB* p_acb; 851 tBTA_HL_MCL_CB* p_mcb; 852 853 if (bta_hl_find_mcl_idx_using_handle(p_data->api_cch_close.mcl_handle, 854 &app_idx, &mcl_idx)) { 855 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 856 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE; 857 } else { 858 status = BTA_HL_STATUS_INVALID_MCL_HANDLE; 859 } 860#if (BTA_HL_DEBUG == TRUE) 861 if (status != BTA_HL_STATUS_OK) { 862 APPL_TRACE_DEBUG("bta_hl_api_cch_close status =%s", 863 bta_hl_status_code(status)); 864 } 865#endif 866 switch (status) { 867 case BTA_HL_STATUS_OK: 868 bta_hl_check_cch_close(app_idx, mcl_idx, p_data, true); 869 break; 870 871 case BTA_HL_STATUS_INVALID_MCL_HANDLE: 872 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 873 if (p_acb->p_cback) { 874 bta_hl_build_cch_close_cfm(&evt_data, p_acb->app_handle, 875 p_data->api_cch_close.mcl_handle, status); 876 p_acb->p_cback(BTA_HL_CCH_CLOSE_CFM_EVT, (tBTA_HL*)&evt_data); 877 } else { 878 APPL_TRACE_ERROR("bta_hl_api_cch_close Null Callback"); 879 } 880 break; 881 default: 882 APPL_TRACE_ERROR("status code=%d", status); 883 break; 884 } 885} 886 887/******************************************************************************* 888 * 889 * Function bta_hl_api_dch_open 890 * 891 * Description Process the API DCH open request 892 * 893 * Returns void 894 * 895 ******************************************************************************/ 896static void bta_hl_api_dch_open(UNUSED_ATTR tBTA_HL_CB* p_cb, 897 tBTA_HL_DATA* p_data) { 898 tBTA_HL evt_data; 899 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 900 uint8_t app_idx, mcl_idx, mdl_idx; 901 tBTA_HL_APP_CB* p_acb; 902 tBTA_HL_MCL_CB* p_mcb = NULL; 903 tBTA_HL_MDL_CB* p_dcb; 904 tBTA_HL_MDEP_CFG* p_mdep_cfg; 905 uint8_t mdep_cfg_idx; 906 907 if (bta_hl_find_mcl_idx_using_handle(p_data->api_dch_open.mcl_handle, 908 &app_idx, &mcl_idx)) { 909 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 910 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 911 912 APPL_TRACE_DEBUG( 913 "bta_hl_api_dch_open: app_ix=%d, mcl_idx=%d, cch_state=%d, " 914 "mcl_handle=%d", 915 app_idx, mcl_idx, p_mcb->cch_state, p_data->api_dch_open.mcl_handle); 916 if (p_mcb->cch_state == BTA_HL_CCH_OPEN_ST) { 917 if (bta_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) { 918 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 919 920 if (bta_hl_find_mdep_cfg_idx( 921 app_idx, p_data->api_dch_open.local_mdep_id, &mdep_cfg_idx)) { 922 if (mdep_cfg_idx && 923 (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role == 924 BTA_HL_MDEP_ROLE_SINK)) { 925 p_data->api_dch_open.local_cfg = BTA_HL_DCH_CFG_NO_PREF; 926 } 927 928 if ((status = bta_hl_chk_local_cfg(app_idx, mcl_idx, mdep_cfg_idx, 929 p_data->api_dch_open.local_cfg)) == 930 BTA_HL_STATUS_OK) { 931 if (p_data->api_dch_open.local_mdep_id != 932 BTA_HL_ECHO_TEST_MDEP_ID) { 933 if (bta_hl_set_ctrl_psm_for_dch(app_idx, mcl_idx, mdl_idx, 934 p_data->api_dch_open.ctrl_psm)) { 935 p_mdep_cfg = BTA_HL_GET_MDEP_CFG_PTR(app_idx, mdep_cfg_idx); 936 p_dcb->in_use = true; 937 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_OPEN; 938 p_dcb->sec_mask = p_data->api_dch_open.sec_mask; 939 p_dcb->local_mdep_id = p_data->api_dch_open.local_mdep_id; 940 p_dcb->peer_mdep_id = p_data->api_dch_open.peer_mdep_id; 941 942 if (p_mdep_cfg->mdep_role == BTA_HL_MDEP_ROLE_SINK) { 943 p_dcb->peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE; 944 } else { 945 p_dcb->peer_mdep_role = BTA_HL_MDEP_ROLE_SINK; 946 } 947 948 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx; 949 p_dcb->local_cfg = p_data->api_dch_open.local_cfg; 950 951 bta_hl_find_rxtx_apdu_size(app_idx, mdep_cfg_idx, 952 &p_dcb->max_rx_apdu_size, 953 &p_dcb->max_tx_apdu_size); 954 p_dcb->mdl_id = 955 bta_hl_allocate_mdl_id(app_idx, mcl_idx, mdl_idx); 956 p_dcb->mdl_cfg_idx_included = false; 957 } else { 958 status = BTA_HL_STATUS_INVALID_CTRL_PSM; 959 } 960 961 } else { 962 status = BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID; 963 } 964 } 965 } else { 966 status = BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID; 967 } 968 } else { 969 status = BTA_HL_STATUS_NO_RESOURCE; 970 } 971 } else { 972 status = BTA_HL_STATUS_NO_CCH; 973 } 974 } else { 975 status = BTA_HL_STATUS_INVALID_MCL_HANDLE; 976 } 977 978#if (BTA_HL_DEBUG == TRUE) 979 if (status != BTA_HL_STATUS_OK) { 980 APPL_TRACE_DEBUG("bta_hl_api_dch_open status =%s", 981 bta_hl_status_code(status)); 982 } 983#endif 984 switch (status) { 985 case BTA_HL_STATUS_OK: 986 if (p_mcb->sdp.num_recs) { 987 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_OPEN_EVT, 988 p_data); 989 } else { 990 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, 991 BTA_HL_DCH_SDP_INIT_EVT, p_data); 992 } 993 break; 994 case BTA_HL_STATUS_INVALID_DCH_CFG: 995 case BTA_HL_STATUS_NO_FIRST_RELIABLE: 996 case BTA_HL_STATUS_NO_CCH: 997 case BTA_HL_STATUS_NO_RESOURCE: 998 case BTA_HL_STATUS_FAIL: 999 case BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID: 1000 case BTA_HL_STATUS_INVALID_CTRL_PSM: 1001 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1002 if (p_acb->p_cback) { 1003 bta_hl_build_dch_open_cfm( 1004 &evt_data, p_acb->app_handle, p_data->api_dch_open.mcl_handle, 1005 BTA_HL_INVALID_MDL_HANDLE, 0, 0, 0, 0, 0, status); 1006 p_acb->p_cback(BTA_HL_DCH_OPEN_CFM_EVT, (tBTA_HL*)&evt_data); 1007 } else { 1008 APPL_TRACE_ERROR("bta_hl_api_dch_open Null Callback"); 1009 } 1010 1011 break; 1012 default: 1013 APPL_TRACE_ERROR("Status code=%d", status); 1014 break; 1015 } 1016} 1017/******************************************************************************* 1018 * 1019 * Function bta_hl_api_dch_close 1020 * 1021 * Description Process the API DCH close request 1022 * 1023 * Returns void 1024 * 1025 ******************************************************************************/ 1026static void bta_hl_api_dch_close(UNUSED_ATTR tBTA_HL_CB* p_cb, 1027 tBTA_HL_DATA* p_data) { 1028 tBTA_HL evt_data; 1029 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 1030 uint8_t app_idx, mcl_idx, mdl_idx; 1031 tBTA_HL_APP_CB* p_acb; 1032 tBTA_HL_MCL_CB* p_mcb; 1033 tBTA_HL_MDL_CB* p_dcb; 1034 1035 if (bta_hl_find_mdl_idx_using_handle(p_data->api_dch_close.mdl_handle, 1036 &app_idx, &mcl_idx, &mdl_idx)) { 1037 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 1038 if (p_dcb->dch_state != BTA_HL_DCH_OPEN_ST) { 1039 status = BTA_HL_STATUS_FAIL; 1040 } 1041 } else { 1042 status = BTA_HL_STATUS_INVALID_MDL_HANDLE; 1043 } 1044 1045#if (BTA_HL_DEBUG == TRUE) 1046 if (status != BTA_HL_STATUS_OK) { 1047 APPL_TRACE_DEBUG("bta_hl_api_dch_close status =%s", 1048 bta_hl_status_code(status)); 1049 } 1050#endif 1051 1052 switch (status) { 1053 case BTA_HL_STATUS_OK: 1054 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT, 1055 p_data); 1056 break; 1057 case BTA_HL_STATUS_FAIL: 1058 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1059 if (p_acb->p_cback) { 1060 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1061 bta_hl_build_dch_close_cfm(&evt_data, p_acb->app_handle, 1062 p_mcb->mcl_handle, 1063 p_data->api_dch_close.mdl_handle, status); 1064 1065 p_acb->p_cback(BTA_HL_DCH_CLOSE_CFM_EVT, (tBTA_HL*)&evt_data); 1066 } else { 1067 APPL_TRACE_ERROR("bta_hl_api_dch_close Null Callback"); 1068 } 1069 break; 1070 default: 1071 APPL_TRACE_ERROR("Status code=%d", status); 1072 break; 1073 } 1074} 1075 1076/******************************************************************************* 1077 * 1078 * Function bta_hl_api_dch_reconnect 1079 * 1080 * Description Process the API DCH reconnect request 1081 * 1082 * Returns void 1083 * 1084 ******************************************************************************/ 1085static void bta_hl_api_dch_reconnect(UNUSED_ATTR tBTA_HL_CB* p_cb, 1086 tBTA_HL_DATA* p_data) { 1087 tBTA_HL evt_data; 1088 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 1089 uint8_t app_idx, mcl_idx, mdl_idx; 1090 tBTA_HL_APP_CB* p_acb; 1091 tBTA_HL_MCL_CB* p_mcb = NULL; 1092 tBTA_HL_MDL_CB* p_dcb; 1093 uint8_t mdep_cfg_idx; 1094 uint8_t mdl_cfg_idx; 1095 tBTA_HL_MDEP_CFG* p_mdep_cfg; 1096 1097 if (bta_hl_find_mcl_idx_using_handle(p_data->api_dch_reconnect.mcl_handle, 1098 &app_idx, &mcl_idx)) { 1099 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1100 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1101 if (p_mcb->cch_state == BTA_HL_CCH_OPEN_ST) { 1102 if (bta_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) { 1103 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 1104 if (bta_hl_validate_reconnect_params(app_idx, mcl_idx, 1105 &(p_data->api_dch_reconnect), 1106 &mdep_cfg_idx, &mdl_cfg_idx)) { 1107 if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx) && 1108 (p_acb->mdl_cfg[mdl_cfg_idx].dch_mode != 1109 BTA_HL_DCH_MODE_RELIABLE)) { 1110 status = BTA_HL_STATUS_NO_FIRST_RELIABLE; 1111 } else { 1112 if (bta_hl_set_ctrl_psm_for_dch(app_idx, mcl_idx, mdl_idx, 1113 p_data->api_dch_open.ctrl_psm)) { 1114 p_dcb->in_use = true; 1115 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_RECONNECT; 1116 p_dcb->sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT); 1117 p_dcb->local_mdep_id = p_acb->mdl_cfg[mdl_cfg_idx].local_mdep_id; 1118 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx; 1119 p_dcb->local_cfg = BTA_HL_DCH_CFG_UNKNOWN; 1120 p_dcb->mdl_id = p_data->api_dch_reconnect.mdl_id; 1121 p_dcb->mdl_cfg_idx_included = true; 1122 p_dcb->mdl_cfg_idx = mdl_cfg_idx; 1123 p_dcb->dch_mode = p_acb->mdl_cfg[mdl_cfg_idx].dch_mode; 1124 1125 p_mdep_cfg = BTA_HL_GET_MDEP_CFG_PTR(app_idx, mdep_cfg_idx); 1126 1127 if (p_mdep_cfg->mdep_role == BTA_HL_MDEP_ROLE_SINK) { 1128 p_dcb->peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE; 1129 APPL_TRACE_DEBUG("peer mdep role = SOURCE "); 1130 } else { 1131 p_dcb->peer_mdep_role = BTA_HL_MDEP_ROLE_SINK; 1132 APPL_TRACE_DEBUG("peer mdep role = SINK "); 1133 } 1134 1135 bta_hl_find_rxtx_apdu_size(app_idx, mdep_cfg_idx, 1136 &p_dcb->max_rx_apdu_size, 1137 &p_dcb->max_tx_apdu_size); 1138 } else { 1139 status = BTA_HL_STATUS_INVALID_CTRL_PSM; 1140 } 1141 } 1142 } else { 1143 status = BTA_HL_STATUS_INVALID_RECONNECT_CFG; 1144 } 1145 } else { 1146 status = BTA_HL_STATUS_NO_RESOURCE; 1147 } 1148 } else { 1149 status = BTA_HL_STATUS_NO_CCH; 1150 } 1151 } else { 1152 status = BTA_HL_STATUS_INVALID_MCL_HANDLE; 1153 } 1154 1155#if (BTA_HL_DEBUG == TRUE) 1156 if (status != BTA_HL_STATUS_OK) { 1157 APPL_TRACE_DEBUG("bta_hl_api_dch_reconnect status=%s", 1158 bta_hl_status_code(status)); 1159 } 1160#endif 1161 1162 switch (status) { 1163 case BTA_HL_STATUS_OK: 1164 if (p_mcb->sdp.num_recs) { 1165 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, 1166 BTA_HL_DCH_RECONNECT_EVT, p_data); 1167 } else { 1168 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, 1169 BTA_HL_DCH_SDP_INIT_EVT, p_data); 1170 } 1171 break; 1172 case BTA_HL_STATUS_INVALID_RECONNECT_CFG: 1173 case BTA_HL_STATUS_NO_FIRST_RELIABLE: 1174 case BTA_HL_STATUS_NO_CCH: 1175 case BTA_HL_STATUS_NO_RESOURCE: 1176 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1177 if (p_acb->p_cback) { 1178 bta_hl_build_dch_open_cfm( 1179 &evt_data, p_acb->app_handle, p_data->api_dch_reconnect.mcl_handle, 1180 BTA_HL_INVALID_MDL_HANDLE, 0, p_data->api_dch_reconnect.mdl_id, 0, 1181 0, 0, status); 1182 p_acb->p_cback(BTA_HL_DCH_RECONNECT_CFM_EVT, (tBTA_HL*)&evt_data); 1183 } else { 1184 APPL_TRACE_ERROR("bta_hl_api_dch_reconnect Null Callback"); 1185 } 1186 break; 1187 default: 1188 APPL_TRACE_ERROR("Status code=%d", status); 1189 break; 1190 } 1191} 1192 1193/******************************************************************************* 1194 * 1195 * Function bta_hl_api_dch_echo_test 1196 * 1197 * Description Process the API Echo test request 1198 * 1199 * Returns void 1200 * 1201 ******************************************************************************/ 1202static void bta_hl_api_dch_echo_test(UNUSED_ATTR tBTA_HL_CB* p_cb, 1203 tBTA_HL_DATA* p_data) { 1204 tBTA_HL evt_data; 1205 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 1206 uint8_t app_idx, mcl_idx, mdl_idx; 1207 tBTA_HL_APP_CB* p_acb; 1208 tBTA_HL_MCL_CB* p_mcb = NULL; 1209 tBTA_HL_MDL_CB* p_dcb; 1210 tBTA_HL_ECHO_CFG* p_echo_cfg; 1211 1212 if (bta_hl_find_mcl_idx_using_handle(p_data->api_dch_echo_test.mcl_handle, 1213 &app_idx, &mcl_idx)) { 1214 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1215 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1216 if (p_mcb->cch_state == BTA_HL_CCH_OPEN_ST) { 1217 if (!p_mcb->echo_test) { 1218 if (bta_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) { 1219 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 1220 1221 if ((p_data->api_dch_echo_test.local_cfg == 1222 BTA_HL_DCH_CFG_RELIABLE) || 1223 (p_data->api_dch_echo_test.local_cfg == 1224 BTA_HL_DCH_CFG_STREAMING)) { 1225 bool fcs_use = 1226 (bool)(p_dcb->chnl_cfg.fcs & BTA_HL_MCA_FCS_USE_MASK); 1227 if ((p_dcb->p_echo_tx_pkt = bta_hl_get_buf( 1228 p_data->api_dch_echo_test.pkt_size, fcs_use)) != NULL) { 1229 if (bta_hl_set_ctrl_psm_for_dch(app_idx, mcl_idx, mdl_idx, 1230 p_data->api_dch_open.ctrl_psm)) { 1231 p_dcb->in_use = true; 1232 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_OPEN; 1233 p_dcb->sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT); 1234 p_dcb->local_mdep_cfg_idx = BTA_HL_ECHO_TEST_MDEP_CFG_IDX; 1235 p_dcb->local_cfg = p_data->api_dch_echo_test.local_cfg; 1236 p_dcb->local_mdep_id = BTA_HL_ECHO_TEST_MDEP_ID; 1237 p_dcb->peer_mdep_id = BTA_HL_ECHO_TEST_MDEP_ID; 1238 p_dcb->mdl_id = 1239 bta_hl_allocate_mdl_id(app_idx, mcl_idx, mdl_idx); 1240 p_dcb->mdl_cfg_idx_included = false; 1241 p_echo_cfg = BTA_HL_GET_ECHO_CFG_PTR(app_idx); 1242 p_dcb->max_rx_apdu_size = p_echo_cfg->max_rx_apdu_size; 1243 p_dcb->max_tx_apdu_size = p_echo_cfg->max_tx_apdu_size; 1244 p_mcb->echo_test = true; 1245 p_mcb->echo_mdl_idx = mdl_idx; 1246 } else { 1247 status = BTA_HL_STATUS_INVALID_CTRL_PSM; 1248 } 1249 } else { 1250 status = BTA_HL_STATUS_NO_RESOURCE; 1251 } 1252 } else { 1253 status = BTA_HL_STATUS_INVALID_DCH_CFG; 1254 } 1255 } else { 1256 status = BTA_HL_STATUS_NO_RESOURCE; 1257 } 1258 } else { 1259 status = BTA_HL_STATUS_ECHO_TEST_BUSY; 1260 } 1261 } else { 1262 status = BTA_HL_STATUS_NO_CCH; 1263 } 1264 } else { 1265 status = BTA_HL_STATUS_NO_MCL; 1266 } 1267 1268#if (BTA_HL_DEBUG == TRUE) 1269 if (status != BTA_HL_STATUS_OK) { 1270 APPL_TRACE_DEBUG("bta_hl_api_dch_echo_test status=%s", 1271 bta_hl_status_code(status)); 1272 } 1273#endif 1274 1275 switch (status) { 1276 case BTA_HL_STATUS_OK: 1277 if (p_mcb->sdp.num_recs) { 1278 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, 1279 BTA_HL_DCH_ECHO_TEST_EVT, p_data); 1280 } else { 1281 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, 1282 BTA_HL_DCH_SDP_INIT_EVT, p_data); 1283 } 1284 break; 1285 case BTA_HL_STATUS_ECHO_TEST_BUSY: 1286 case BTA_HL_STATUS_NO_RESOURCE: 1287 case BTA_HL_STATUS_INVALID_DCH_CFG: 1288 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1289 if (p_acb->p_cback) { 1290 bta_hl_build_echo_test_cfm(&evt_data, p_acb->app_handle, 1291 p_mcb->mcl_handle, status); 1292 p_acb->p_cback(BTA_HL_DCH_ECHO_TEST_CFM_EVT, (tBTA_HL*)&evt_data); 1293 } else { 1294 APPL_TRACE_ERROR("bta_hl_api_dch_echo_test Null Callback"); 1295 } 1296 break; 1297 1298 default: 1299 APPL_TRACE_ERROR("Status code=%s", status); 1300 break; 1301 } 1302} 1303 1304/******************************************************************************* 1305 * 1306 * Function bta_hl_api_sdp_query 1307 * 1308 * Description Process the API SDP query request 1309 * 1310 * Returns void 1311 * 1312 ******************************************************************************/ 1313static void bta_hl_api_sdp_query(UNUSED_ATTR tBTA_HL_CB* p_cb, 1314 tBTA_HL_DATA* p_data) { 1315 tBTA_HL evt_data; 1316 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 1317 uint8_t app_idx, mcl_idx; 1318 tBTA_HL_APP_CB* p_acb; 1319 tBTA_HL_MCL_CB* p_mcb; 1320 1321 if (bta_hl_find_app_idx_using_handle(p_data->api_sdp_query.app_handle, 1322 &app_idx)) { 1323 if (!bta_hl_find_mcl_idx(app_idx, p_data->api_sdp_query.bd_addr, 1324 &mcl_idx)) { 1325 if (bta_hl_find_avail_mcl_idx(app_idx, &mcl_idx)) { 1326 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1327 p_mcb->in_use = true; 1328 bdcpy(p_mcb->bd_addr, p_data->api_sdp_query.bd_addr); 1329 APPL_TRACE_DEBUG( 1330 "bta_hl_api_sdp_query p_mcb->app_id %d app_idx %d mcl_idx %d", 1331 p_mcb->app_id, app_idx, mcl_idx); 1332 p_mcb->app_id = p_data->api_sdp_query.app_id; 1333 p_mcb->sdp_oper = BTA_HL_SDP_OP_SDP_QUERY_NEW; 1334 } else { 1335 status = BTA_HL_STATUS_NO_RESOURCE; 1336 } 1337 } else { 1338 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1339 p_mcb->app_id = p_data->api_sdp_query.app_id; 1340 if (p_mcb->sdp_oper != BTA_HL_SDP_OP_NONE) { 1341 status = BTA_HL_STATUS_SDP_NO_RESOURCE; 1342 } else { 1343 p_mcb->sdp_oper = BTA_HL_SDP_OP_SDP_QUERY_CURRENT; 1344 } 1345 } 1346 } else { 1347 status = BTA_HL_STATUS_INVALID_APP_HANDLE; 1348 } 1349 1350 if (status == BTA_HL_STATUS_OK) { 1351 status = bta_hl_init_sdp(p_mcb->sdp_oper, app_idx, mcl_idx, 0xFF); 1352 if ((status != BTA_HL_STATUS_OK) && 1353 (p_mcb->sdp_oper == BTA_HL_SDP_OP_SDP_QUERY_NEW)) { 1354 memset(p_mcb, 0, sizeof(tBTA_HL_MCL_CB)); 1355 } 1356 } 1357#if (BTA_HL_DEBUG == TRUE) 1358 if (status != BTA_HL_STATUS_OK) { 1359 APPL_TRACE_DEBUG("bta_hl_api_sdp_query status=%s", 1360 bta_hl_status_code(status)); 1361 } 1362#endif 1363 switch (status) { 1364 case BTA_HL_STATUS_NO_RESOURCE: 1365 case BTA_HL_STATUS_FAIL: 1366 case BTA_HL_STATUS_SDP_NO_RESOURCE: 1367 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1368 if (p_acb->p_cback) { 1369 bta_hl_build_sdp_query_cfm(&evt_data, p_data->api_sdp_query.app_id, 1370 p_data->api_sdp_query.app_handle, 1371 p_data->api_sdp_query.bd_addr, NULL, status); 1372 p_acb->p_cback(BTA_HL_SDP_QUERY_CFM_EVT, (tBTA_HL*)&evt_data); 1373 } else { 1374 APPL_TRACE_ERROR("bta_hl_api_sdp_query Null Callback"); 1375 } 1376 break; 1377 case BTA_HL_STATUS_OK: 1378 break; 1379 default: 1380 APPL_TRACE_ERROR("Status code=%d", status); 1381 break; 1382 } 1383} 1384 1385/******************************************************************************* 1386 * 1387 * Function bta_hl_sdp_query_results 1388 * 1389 * Description Process the SDP query results 1390 * 1391 * Returns void 1392 * 1393 ******************************************************************************/ 1394static void bta_hl_sdp_query_results(UNUSED_ATTR tBTA_HL_CB* p_cb, 1395 tBTA_HL_DATA* p_data) { 1396 tBTA_HL evt_data; 1397 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 1398 uint8_t app_idx = p_data->cch_sdp.app_idx; 1399 uint8_t mcl_idx = p_data->cch_sdp.mcl_idx; 1400 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1401 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1402 tBTA_HL_SDP* p_sdp = NULL; 1403 uint16_t event; 1404 bool release_sdp_buf = false; 1405 1406 event = p_data->hdr.event; 1407 1408 if (event == BTA_HL_SDP_QUERY_OK_EVT) { 1409 p_sdp = (tBTA_HL_SDP*)osi_malloc(sizeof(tBTA_HL_SDP)); 1410 memcpy(p_sdp, &p_mcb->sdp, sizeof(tBTA_HL_SDP)); 1411 release_sdp_buf = true; 1412 } else { 1413 status = BTA_HL_STATUS_SDP_FAIL; 1414 } 1415 1416#if (BTA_HL_DEBUG == TRUE) 1417 if (status != BTA_HL_STATUS_OK) { 1418 APPL_TRACE_DEBUG("bta_hl_sdp_query_results status=%s", 1419 bta_hl_status_code(status)); 1420 } 1421#endif 1422 1423 APPL_TRACE_DEBUG( 1424 "bta_hl_sdp_query_results p_mcb->app_id %d app_idx %d mcl_idx %d", 1425 p_mcb->app_id, app_idx, mcl_idx); 1426 bta_hl_build_sdp_query_cfm(&evt_data, p_mcb->app_id, p_acb->app_handle, 1427 p_mcb->bd_addr, p_sdp, status); 1428 p_acb->p_cback(BTA_HL_SDP_QUERY_CFM_EVT, (tBTA_HL*)&evt_data); 1429 1430 if (release_sdp_buf) osi_free_and_reset((void**)&p_sdp); 1431 1432 if (p_data->cch_sdp.release_mcl_cb) { 1433 memset(p_mcb, 0, sizeof(tBTA_HL_MCL_CB)); 1434 } else { 1435 if (p_mcb->close_pending) 1436 bta_hl_check_cch_close(app_idx, mcl_idx, p_data, true); 1437 1438 if (!p_mcb->ctrl_psm) { 1439 /* Control channel acceptor: do not store the SDP records */ 1440 memset(&p_mcb->sdp, 0, sizeof(tBTA_HL_SDP)); 1441 } 1442 } 1443} 1444 1445/******************************************************************************* 1446 * 1447 * Function bta_hl_api_delete_mdl 1448 * 1449 * Description Process the API DELETE MDL request 1450 * 1451 * Returns void 1452 * 1453 ******************************************************************************/ 1454static void bta_hl_api_delete_mdl(UNUSED_ATTR tBTA_HL_CB* p_cb, 1455 tBTA_HL_DATA* p_data) { 1456 tBTA_HL evt_data; 1457 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 1458 uint8_t app_idx, mcl_idx; 1459 tBTA_HL_APP_CB* p_acb; 1460 tBTA_HL_MCL_CB* p_mcb; 1461 1462 if (bta_hl_find_mcl_idx_using_handle(p_data->api_delete_mdl.mcl_handle, 1463 &app_idx, &mcl_idx)) { 1464 if (bta_hl_is_mdl_value_valid(p_data->api_delete_mdl.mdl_id)) { 1465 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1466 if (bta_hl_is_mdl_exsit_in_mcl(app_idx, p_mcb->bd_addr, 1467 p_data->api_delete_mdl.mdl_id)) { 1468 p_mcb->delete_mdl.mcl_handle = p_data->api_delete_mdl.mcl_handle; 1469 p_mcb->delete_mdl.mdl_id = p_data->api_delete_mdl.mdl_id; 1470 p_mcb->delete_mdl.delete_req_pending = true; 1471 1472 if (MCA_Delete((tMCA_CL)p_mcb->mcl_handle, 1473 p_data->api_delete_mdl.mdl_id) != MCA_SUCCESS) { 1474 status = BTA_HL_STATUS_FAIL; 1475 memset(&p_mcb->delete_mdl, 0, sizeof(tBTA_HL_DELETE_MDL)); 1476 } 1477 } else { 1478 status = BTA_HL_STATUS_NO_MDL_ID_FOUND; 1479 } 1480 } else { 1481 status = BTA_HL_STATUS_INVALID_MDL_ID; 1482 } 1483 } else { 1484 status = BTA_HL_STATUS_INVALID_MCL_HANDLE; 1485 } 1486 1487#if (BTA_HL_DEBUG == TRUE) 1488 if (status != BTA_HL_STATUS_OK) { 1489 APPL_TRACE_DEBUG("bta_hl_api_delete_mdl status=%s", 1490 bta_hl_status_code(status)); 1491 } 1492#endif 1493 switch (status) { 1494 case BTA_HL_STATUS_OK: 1495 break; 1496 case BTA_HL_STATUS_FAIL: 1497 case BTA_HL_STATUS_NO_MDL_ID_FOUND: 1498 case BTA_HL_STATUS_INVALID_MDL_ID: 1499 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1500 if (p_acb->p_cback) { 1501 bta_hl_build_delete_mdl_cfm(&evt_data, p_acb->app_handle, 1502 p_data->api_delete_mdl.mcl_handle, 1503 p_data->api_delete_mdl.mdl_id, status); 1504 p_acb->p_cback(BTA_HL_DELETE_MDL_CFM_EVT, (tBTA_HL*)&evt_data); 1505 } else { 1506 APPL_TRACE_ERROR("bta_hl_api_delete_mdl Null Callback"); 1507 } 1508 break; 1509 default: 1510 APPL_TRACE_ERROR("status code =%d", status); 1511 break; 1512 } 1513} 1514 1515/******************************************************************************* 1516 * 1517 * Function bta_hl_mca_delete_mdl_cfm 1518 * 1519 * Description Process the DELETE MDL confirmation event 1520 * 1521 * Returns void 1522 * 1523 ******************************************************************************/ 1524static void bta_hl_mca_delete_mdl_cfm(UNUSED_ATTR tBTA_HL_CB* p_cb, 1525 tBTA_HL_DATA* p_data) { 1526 tBTA_HL evt_data; 1527 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 1528 uint8_t app_idx, mcl_idx; 1529 tMCA_RSP_EVT* p_delete_cfm = &p_data->mca_evt.mca_data.delete_cfm; 1530 tBTA_HL_MCL_CB* p_mcb; 1531 bool send_cfm_evt = true; 1532 tBTA_HL_APP_CB* p_acb; 1533 1534 if (bta_hl_find_mcl_idx_using_handle(p_data->mca_evt.mcl_handle, &app_idx, 1535 &mcl_idx)) { 1536 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1537 if (p_mcb->delete_mdl.delete_req_pending) { 1538 if (p_delete_cfm->rsp_code == MCA_RSP_SUCCESS) { 1539 if (!bta_hl_delete_mdl_cfg(app_idx, p_mcb->bd_addr, 1540 p_delete_cfm->mdl_id)) { 1541 status = BTA_HL_STATUS_FAIL; 1542 } 1543 } else { 1544 status = BTA_HL_STATUS_FAIL; 1545 } 1546 1547 memset(&p_mcb->delete_mdl, 0, sizeof(tBTA_HL_DELETE_MDL)); 1548 } else { 1549 send_cfm_evt = false; 1550 } 1551 } else { 1552 send_cfm_evt = false; 1553 } 1554 1555#if (BTA_HL_DEBUG == TRUE) 1556 if (status != BTA_HL_STATUS_OK) { 1557 APPL_TRACE_DEBUG("bta_hl_api_delete_mdl status=%s", 1558 bta_hl_status_code(status)); 1559 } 1560#endif 1561 1562 if (send_cfm_evt) { 1563 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1564 if (p_acb->p_cback) { 1565 bta_hl_build_delete_mdl_cfm(&evt_data, p_acb->app_handle, 1566 p_mcb->mcl_handle, p_delete_cfm->mdl_id, 1567 status); 1568 1569 p_acb->p_cback(BTA_HL_DELETE_MDL_CFM_EVT, (tBTA_HL*)&evt_data); 1570 } else { 1571 APPL_TRACE_ERROR("bta_hl_mca_delete_mdl_cfm Null Callback"); 1572 } 1573 } 1574} 1575 1576/******************************************************************************* 1577 * 1578 * Function bta_hl_mca_delete_mdl_ind 1579 * 1580 * Description Process the DELETE MDL indication event 1581 * 1582 * Returns void 1583 * 1584 ******************************************************************************/ 1585static void bta_hl_mca_delete_mdl_ind(UNUSED_ATTR tBTA_HL_CB* p_cb, 1586 tBTA_HL_DATA* p_data) { 1587 tBTA_HL evt_data; 1588 uint8_t app_idx, mcl_idx, mdl_idx; 1589 tMCA_EVT_HDR* p_delete_ind = &p_data->mca_evt.mca_data.delete_ind; 1590 tBTA_HL_MCL_CB* p_mcb; 1591 tBTA_HL_MDL_CB* p_dcb; 1592 bool send_ind_evt = false; 1593 tBTA_HL_APP_CB* p_acb; 1594 1595 if (bta_hl_find_mcl_idx_using_handle(p_data->mca_evt.mcl_handle, &app_idx, 1596 &mcl_idx)) { 1597 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1598 1599 if (bta_hl_find_mdl_idx(app_idx, mcl_idx, p_delete_ind->mdl_id, &mdl_idx)) { 1600 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 1601 p_dcb->dch_oper = BTA_HL_DCH_OP_REMOTE_DELETE; 1602 } 1603 if (bta_hl_delete_mdl_cfg(app_idx, p_mcb->bd_addr, p_delete_ind->mdl_id)) { 1604 send_ind_evt = true; 1605 } 1606 } 1607 1608#if (BTA_HL_DEBUG == TRUE) 1609 if (!send_ind_evt) { 1610 APPL_TRACE_DEBUG("bta_hl_mca_delete_mdl_ind is_send_ind_evt =%d", 1611 send_ind_evt); 1612 } 1613#endif 1614 1615 if (send_ind_evt) { 1616 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1617 if (p_acb->p_cback) { 1618 evt_data.delete_mdl_ind.mcl_handle = p_mcb->mcl_handle; 1619 evt_data.delete_mdl_ind.app_handle = p_acb->app_handle; 1620 evt_data.delete_mdl_ind.mdl_id = p_delete_ind->mdl_id; 1621 p_acb->p_cback(BTA_HL_DELETE_MDL_IND_EVT, (tBTA_HL*)&evt_data); 1622 } else { 1623 APPL_TRACE_ERROR("bta_hl_mca_delete_mdl_ind Null Callback"); 1624 } 1625 } 1626} 1627 1628/******************************************************************************* 1629 * 1630 * Function bta_hl_api_dch_abort 1631 * 1632 * Description Process the API DCH abort request 1633 * 1634 * Returns void 1635 * 1636 ******************************************************************************/ 1637static void bta_hl_api_dch_abort(UNUSED_ATTR tBTA_HL_CB* p_cb, 1638 tBTA_HL_DATA* p_data) { 1639 tBTA_HL_STATUS status = BTA_HL_STATUS_OK; 1640 uint8_t app_idx, mcl_idx, mdl_idx; 1641 tBTA_HL_APP_CB* p_acb; 1642 tBTA_HL_MCL_CB* p_mcb; 1643 tBTA_HL_MDL_CB* p_dcb; 1644 tBTA_HL evt_data; 1645 1646 if (bta_hl_find_mcl_idx_using_handle(p_data->api_dch_abort.mcl_handle, 1647 &app_idx, &mcl_idx)) { 1648 if (!bta_hl_find_dch_setup_mdl_idx(app_idx, mcl_idx, &mdl_idx)) { 1649 status = BTA_HL_STATUS_NO_MDL_ID_FOUND; 1650 } else { 1651 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx); 1652 if (p_dcb->abort_oper) { 1653 /* abort already in progress*/ 1654 status = BTA_HL_STATUS_FAIL; 1655 } else { 1656 p_dcb->abort_oper = BTA_HL_ABORT_LOCAL_MASK; 1657 } 1658 } 1659 } else { 1660 status = BTA_HL_STATUS_INVALID_MCL_HANDLE; 1661 } 1662 1663#if (BTA_HL_DEBUG == TRUE) 1664 if (status != BTA_HL_STATUS_OK) { 1665 APPL_TRACE_DEBUG("bta_hl_api_dch_abort status=%s", 1666 bta_hl_status_code(status)); 1667 } 1668#endif 1669 switch (status) { 1670 case BTA_HL_STATUS_OK: 1671 1672 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT, 1673 p_data); 1674 break; 1675 case BTA_HL_STATUS_NO_MDL_ID_FOUND: 1676 case BTA_HL_STATUS_FAIL: 1677 1678 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx); 1679 if (p_acb->p_cback) { 1680 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx); 1681 bta_hl_build_abort_cfm(&evt_data, 1682 1683 p_acb->app_handle, p_mcb->mcl_handle, 1684 BTA_HL_STATUS_FAIL); 1685 p_acb->p_cback(BTA_HL_DCH_ABORT_CFM_EVT, (tBTA_HL*)&evt_data); 1686 } else { 1687 APPL_TRACE_ERROR("bta_hl_api_dch_abort Null Callback"); 1688 } 1689 break; 1690 default: 1691 APPL_TRACE_ERROR("Status code=%d", status); 1692 break; 1693 } 1694} 1695 1696/******************************************************************************* 1697 * 1698 * Function bta_hl_hdl_event 1699 * 1700 * Description HL main event handling function. 1701 * 1702 * Returns void 1703 * 1704 ******************************************************************************/ 1705bool bta_hl_hdl_event(BT_HDR* p_msg) { 1706 uint8_t app_idx, mcl_idx, mdl_idx; 1707 bool success = true; 1708 1709#if (BTA_HL_DEBUG == TRUE) 1710 APPL_TRACE_DEBUG("BTA HL Event Handler: Event [%s]", 1711 bta_hl_evt_code(p_msg->event)); 1712#endif 1713 1714 switch (p_msg->event) { 1715 case BTA_HL_API_ENABLE_EVT: 1716 bta_hl_api_enable(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1717 break; 1718 case BTA_HL_API_DISABLE_EVT: 1719 bta_hl_api_disable(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1720 break; 1721 case BTA_HL_API_UPDATE_EVT: 1722 bta_hl_api_update(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1723 break; 1724 case BTA_HL_API_REGISTER_EVT: 1725 bta_hl_api_register(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1726 break; 1727 case BTA_HL_API_DEREGISTER_EVT: 1728 bta_hl_api_deregister(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1729 break; 1730 case BTA_HL_API_CCH_OPEN_EVT: 1731 bta_hl_api_cch_open(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1732 break; 1733 case BTA_HL_API_CCH_CLOSE_EVT: 1734 bta_hl_api_cch_close(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1735 break; 1736 case BTA_HL_API_DCH_OPEN_EVT: 1737 bta_hl_api_dch_open(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1738 break; 1739 case BTA_HL_API_DCH_CLOSE_EVT: 1740 bta_hl_api_dch_close(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1741 break; 1742 case BTA_HL_API_DELETE_MDL_EVT: 1743 bta_hl_api_delete_mdl(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1744 break; 1745 case BTA_HL_API_DCH_RECONNECT_EVT: 1746 bta_hl_api_dch_reconnect(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1747 break; 1748 1749 case BTA_HL_API_DCH_ECHO_TEST_EVT: 1750 bta_hl_api_dch_echo_test(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1751 break; 1752 1753 case BTA_HL_API_SDP_QUERY_EVT: 1754 bta_hl_api_sdp_query(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1755 break; 1756 1757 case BTA_HL_MCA_DELETE_CFM_EVT: 1758 bta_hl_mca_delete_mdl_cfm(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1759 break; 1760 1761 case BTA_HL_MCA_DELETE_IND_EVT: 1762 bta_hl_mca_delete_mdl_ind(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1763 break; 1764 1765 case BTA_HL_SDP_QUERY_OK_EVT: 1766 case BTA_HL_SDP_QUERY_FAIL_EVT: 1767 bta_hl_sdp_query_results(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1768 break; 1769 case BTA_HL_API_DCH_ABORT_EVT: 1770 bta_hl_api_dch_abort(&bta_hl_cb, (tBTA_HL_DATA*)p_msg); 1771 break; 1772 1773 default: 1774 if (p_msg->event < BTA_HL_DCH_EVT_MIN) { 1775 if (bta_hl_find_cch_cb_indexes((tBTA_HL_DATA*)p_msg, &app_idx, 1776 &mcl_idx)) { 1777 bta_hl_cch_sm_execute(app_idx, mcl_idx, p_msg->event, 1778 (tBTA_HL_DATA*)p_msg); 1779 } else { 1780#if (BTA_HL_DEBUG == TRUE) 1781 APPL_TRACE_ERROR( 1782 "unable to find control block indexes for CCH: [event=%s]", 1783 bta_hl_evt_code(p_msg->event)); 1784#else 1785 APPL_TRACE_ERROR( 1786 "unable to find control block indexes for CCH: [event=%d]", 1787 p_msg->event); 1788#endif 1789 success = false; 1790 } 1791 } else { 1792 if (bta_hl_find_dch_cb_indexes((tBTA_HL_DATA*)p_msg, &app_idx, &mcl_idx, 1793 &mdl_idx)) { 1794 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, p_msg->event, 1795 (tBTA_HL_DATA*)p_msg); 1796 } else { 1797#if (BTA_HL_DEBUG == TRUE) 1798 APPL_TRACE_ERROR( 1799 "unable to find control block indexes for DCH : [event=%s]", 1800 bta_hl_evt_code(p_msg->event)); 1801#else 1802 APPL_TRACE_ERROR( 1803 "unable to find control block indexes for DCH: [event=%d]", 1804 p_msg->event); 1805#endif 1806 success = false; 1807 } 1808 } 1809 1810 break; 1811 } 1812 1813 return (success); 1814} 1815 1816/***************************************************************************** 1817 * Debug Functions 1818 ****************************************************************************/ 1819#if (BTA_HL_DEBUG == TRUE) 1820 1821/******************************************************************************* 1822 * 1823 * Function bta_hl_cch_state_code 1824 * 1825 * Description Map CCH state code to the corresponding state string 1826 * 1827 * Returns string pointer for the associated state name 1828 * 1829 ******************************************************************************/ 1830static const char* bta_hl_cch_state_code(tBTA_HL_CCH_STATE state_code) { 1831 switch (state_code) { 1832 case BTA_HL_CCH_IDLE_ST: 1833 return "BTA_HL_CCH_IDLE_ST"; 1834 case BTA_HL_CCH_OPENING_ST: 1835 return "BTA_HL_CCH_OPENING_ST"; 1836 case BTA_HL_CCH_OPEN_ST: 1837 return "BTA_HL_CCH_OPEN_ST"; 1838 case BTA_HL_CCH_CLOSING_ST: 1839 return "BTA_HL_CCH_CLOSING_ST"; 1840 default: 1841 return "Unknown CCH state code"; 1842 } 1843} 1844 1845/******************************************************************************* 1846 * 1847 * Function bta_hl_dch_state_code 1848 * 1849 * Description Map DCH state code to the corresponding state string 1850 * 1851 * Returns string pointer for the associated state name 1852 * 1853 ******************************************************************************/ 1854static const char* bta_hl_dch_state_code(tBTA_HL_DCH_STATE state_code) { 1855 switch (state_code) { 1856 case BTA_HL_DCH_IDLE_ST: 1857 return "BTA_HL_DCH_IDLE_ST"; 1858 case BTA_HL_DCH_OPENING_ST: 1859 return "BTA_HL_DCH_OPENING_ST"; 1860 case BTA_HL_DCH_OPEN_ST: 1861 return "BTA_HL_DCH_OPEN_ST"; 1862 case BTA_HL_DCH_CLOSING_ST: 1863 return "BTA_HL_DCH_CLOSING_ST"; 1864 default: 1865 return "Unknown DCH state code"; 1866 } 1867} 1868#endif /* Debug Functions */ 1869#endif /* HL_INCLUDED */ 1870