1 /******************************************************************************
2 *
3 * Copyright 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)
39 static const char* bta_hl_cch_state_code(tBTA_HL_CCH_STATE state_code);
40 static const char* bta_hl_dch_state_code(tBTA_HL_DCH_STATE state_code);
41 #endif
42
43 extern uint16_t L2CA_AllocateRandomPsm(void);
44 extern 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[] */
53 enum {
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
86 typedef void (*tBTA_HL_DCH_ACTION)(uint8_t app_idx, uint8_t mcl_idx,
87 uint8_t mdl_idx, tBTA_HL_DATA* p_data);
88
89 static 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 */
115 static 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 */
157 static 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 */
208 static 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 */
252 static 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 */
295 typedef const uint8_t (*tBTA_HL_DCH_ST_TBL)[BTA_HL_DCH_NUM_COLS];
296
297 /* state table */
298 const 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 */
309 enum {
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 */
322 typedef 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 */
326 const 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 */
337 static 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 */
352 static 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 */
372 static 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 */
387 static 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 */
407 typedef const uint8_t (*tBTA_HL_CCH_ST_TBL)[BTA_HL_CCH_NUM_COLS];
408
409 /* MAS state table */
410 const 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 */
419 tBTA_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 ******************************************************************************/
bta_hl_cch_sm_execute(uint8_t app_idx,uint8_t mcl_idx,uint16_t event,tBTA_HL_DATA * p_data)430 void 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 action = state_table[event][i];
455 if (action != BTA_HL_CCH_IGNORE) {
456 (*bta_hl_cch_action[action])(app_idx, mcl_idx, p_data);
457 } else {
458 /* discard HDP data */
459 bta_hl_discard_data(p_data->hdr.event, p_data);
460 break;
461 }
462 }
463 #if (BTA_HL_DEBUG == TRUE)
464 if (in_state != p_cb->cch_state) {
465 APPL_TRACE_DEBUG("HL CCH State Change: [%s] -> [%s] after [%s]",
466 bta_hl_cch_state_code(in_state),
467 bta_hl_cch_state_code(p_cb->cch_state),
468 bta_hl_evt_code(cur_evt));
469 }
470 #endif
471 }
472
473 /*******************************************************************************
474 *
475 * Function bta_hl_dch_sm_execute
476 *
477 * Description State machine event handling function for DCH
478 *
479 * Returns void
480 *
481 ******************************************************************************/
bta_hl_dch_sm_execute(uint8_t app_idx,uint8_t mcl_idx,uint8_t mdl_idx,uint16_t event,tBTA_HL_DATA * p_data)482 void bta_hl_dch_sm_execute(uint8_t app_idx, uint8_t mcl_idx, uint8_t mdl_idx,
483 uint16_t event, tBTA_HL_DATA* p_data) {
484 tBTA_HL_DCH_ST_TBL state_table;
485 uint8_t action;
486 int i;
487 tBTA_HL_MDL_CB* p_cb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
488
489 #if (BTA_HL_DEBUG == TRUE)
490 tBTA_HL_DCH_STATE in_state = p_cb->dch_state;
491 uint16_t cur_evt = event;
492 APPL_TRACE_DEBUG("HDP DCH Event Handler: State 0x%02x [%s], Event [%s]",
493 in_state, bta_hl_dch_state_code(in_state),
494 bta_hl_evt_code(cur_evt));
495 #endif
496
497 /* look up the state table for the current state */
498 state_table = bta_hl_dch_st_tbl[p_cb->dch_state];
499 event -= BTA_HL_DCH_EVT_MIN;
500
501 /* set next state */
502 p_cb->dch_state = state_table[event][BTA_HL_DCH_NEXT_STATE];
503
504 for (i = 0; i < BTA_HL_DCH_ACTIONS; i++) {
505 action = state_table[event][i];
506 if (action != BTA_HL_DCH_IGNORE) {
507 (*bta_hl_dch_action[action])(app_idx, mcl_idx, mdl_idx, p_data);
508 } else {
509 /* discard mas data */
510 bta_hl_discard_data(p_data->hdr.event, p_data);
511 break;
512 }
513 }
514
515 #if (BTA_HL_DEBUG == TRUE)
516 if (in_state != p_cb->dch_state) {
517 APPL_TRACE_DEBUG("HL DCH State Change: [%s] -> [%s] after [%s]",
518 bta_hl_dch_state_code(in_state),
519 bta_hl_dch_state_code(p_cb->dch_state),
520 bta_hl_evt_code(cur_evt));
521 }
522 #endif
523 }
524 /*******************************************************************************
525 *
526 * Function bta_hl_api_enable
527 *
528 * Description Process the API enable request to enable the HL subsystem
529 *
530 * Returns void
531 *
532 ******************************************************************************/
bta_hl_api_enable(tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)533 static void bta_hl_api_enable(tBTA_HL_CB* p_cb, tBTA_HL_DATA* p_data) {
534 tBTA_HL_CTRL evt_data;
535
536 /* If already enabled then reject this request */
537 if (p_cb->enable) {
538 APPL_TRACE_ERROR("HL is already enabled");
539 evt_data.enable_cfm.status = BTA_HL_STATUS_FAIL;
540 if (p_data->api_enable.p_cback)
541 p_data->api_enable.p_cback(BTA_HL_CTRL_ENABLE_CFM_EVT,
542 (tBTA_HL_CTRL*)&evt_data);
543 return;
544 }
545
546 /* Done with checking. now perform the enable oepration*/
547 /* initialize control block */
548 memset(p_cb, 0, sizeof(tBTA_HL_CB));
549 p_cb->enable = true;
550 p_cb->p_ctrl_cback = p_data->api_enable.p_cback;
551 evt_data.enable_cfm.status = BTA_HL_STATUS_OK;
552 if (p_data->api_enable.p_cback)
553 p_data->api_enable.p_cback(BTA_HL_CTRL_ENABLE_CFM_EVT,
554 (tBTA_HL_CTRL*)&evt_data);
555 }
556 /*******************************************************************************
557 *
558 * Function bta_hl_api_disable
559 *
560 * Description Process the API disable request to disable the HL subsystem
561 *
562 * Returns void
563 *
564 ******************************************************************************/
bta_hl_api_disable(tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)565 static void bta_hl_api_disable(tBTA_HL_CB* p_cb, tBTA_HL_DATA* p_data) {
566 tBTA_HL_CTRL evt_data;
567 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
568
569 if (p_cb->enable) {
570 p_cb->disabling = true;
571 bta_hl_check_disable(p_data);
572 } else {
573 status = BTA_HL_STATUS_FAIL;
574 evt_data.disable_cfm.status = status;
575 if (p_cb->p_ctrl_cback)
576 p_cb->p_ctrl_cback(BTA_HL_CTRL_DISABLE_CFM_EVT, (tBTA_HL_CTRL*)&evt_data);
577 }
578
579 #if (BTA_HL_DEBUG == TRUE)
580 if (status != BTA_HL_STATUS_OK) {
581 APPL_TRACE_DEBUG("bta_hl_api_disable status =%s",
582 bta_hl_status_code(status));
583 }
584 #endif
585 }
586
587 /*******************************************************************************
588 *
589 * Function bta_hl_api_update
590 *
591 * Description Process the API registration request to register an HDP
592 * application
593 *
594 * Returns void
595 *
596 ******************************************************************************/
bta_hl_api_update(tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)597 static void bta_hl_api_update(tBTA_HL_CB* p_cb, tBTA_HL_DATA* p_data) {
598 tBTA_HL evt_data;
599 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(0);
600 tBTA_HL_STATUS status = BTA_HL_STATUS_FAIL;
601
602 APPL_TRACE_DEBUG("bta_hl_api_update");
603 if (p_cb->enable) {
604 status = bta_hl_app_update(p_data->api_update.app_id,
605 p_data->api_update.is_register);
606 if (!p_data->api_update.is_register) {
607 APPL_TRACE_DEBUG("Deregister");
608 memset(&evt_data, 0, sizeof(tBTA_HL));
609 evt_data.dereg_cfm.status = status;
610 evt_data.dereg_cfm.app_id = p_data->api_update.app_id;
611 if (status == BTA_HL_STATUS_OK)
612 evt_data.dereg_cfm.app_handle = p_acb->app_handle;
613 if (p_acb->p_cback) {
614 p_acb->p_cback(BTA_HL_DEREGISTER_CFM_EVT, (tBTA_HL*)&evt_data);
615 }
616 return;
617 }
618 }
619
620 if (status != BTA_HL_STATUS_OK) {
621 if ((status != BTA_HL_STATUS_DUPLICATE_APP_ID) &&
622 (status != BTA_HL_STATUS_NO_RESOURCE)) {
623 if (p_acb) memset(p_acb, 0, sizeof(tBTA_HL_APP_CB));
624 }
625 }
626 #if (BTA_HL_DEBUG == TRUE)
627 if (status != BTA_HL_STATUS_OK) {
628 APPL_TRACE_DEBUG("bta_hl_api_register status =%s",
629 bta_hl_status_code(status));
630 }
631 #endif
632
633 memset(&evt_data, 0, sizeof(tBTA_HL));
634 evt_data.reg_cfm.status = status;
635 evt_data.reg_cfm.app_id = p_data->api_update.app_id;
636 if (status == BTA_HL_STATUS_OK)
637 evt_data.reg_cfm.app_handle = p_acb->app_handle;
638 if (p_data->api_reg.p_cback) {
639 p_data->api_reg.p_cback(BTA_HL_REGISTER_CFM_EVT, (tBTA_HL*)&evt_data);
640 }
641
642 if (status == BTA_HL_STATUS_OK) {
643 evt_data.sdp_info_ind.app_handle = p_acb->app_handle;
644 evt_data.sdp_info_ind.ctrl_psm = p_acb->ctrl_psm;
645 evt_data.sdp_info_ind.data_psm = p_acb->data_psm;
646 evt_data.sdp_info_ind.data_x_spec = BTA_HL_SDP_IEEE_11073_20601;
647 evt_data.sdp_info_ind.mcap_sup_procs = BTA_HL_MCAP_SUP_PROC_MASK;
648
649 if (p_data->api_reg.p_cback) {
650 p_data->api_reg.p_cback(BTA_HL_SDP_INFO_IND_EVT, (tBTA_HL*)&evt_data);
651 }
652 }
653 }
654
655 /*******************************************************************************
656 *
657 * Function bta_hl_api_register
658 *
659 * Description Process the API registration request to register an HDP
660 * application
661 *
662 * Returns void
663 *
664 ******************************************************************************/
bta_hl_api_register(tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)665 static void bta_hl_api_register(tBTA_HL_CB* p_cb, tBTA_HL_DATA* p_data) {
666 tBTA_HL evt_data;
667 uint8_t app_idx;
668 tBTA_HL_APP_CB* p_acb = NULL;
669 tBTA_HL_STATUS status = BTA_HL_STATUS_FAIL;
670
671 if (p_cb->enable) {
672 if (!bta_hl_is_a_duplicate_id(p_data->api_reg.app_id)) {
673 if (bta_hl_find_avail_app_idx(&app_idx)) {
674 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
675 p_acb->in_use = true;
676 p_acb->app_id = p_data->api_reg.app_id;
677 p_acb->p_cback = p_data->api_reg.p_cback;
678 p_acb->sec_mask = p_data->api_reg.sec_mask;
679 p_acb->dev_type = p_data->api_reg.dev_type;
680 strlcpy(p_acb->srv_name, p_data->api_reg.srv_name,
681 BTA_SERVICE_NAME_LEN);
682 strlcpy(p_acb->srv_desp, p_data->api_reg.srv_desp,
683 BTA_SERVICE_DESP_LEN);
684 strlcpy(p_acb->provider_name, p_data->api_reg.provider_name,
685 BTA_PROVIDER_NAME_LEN);
686 bta_hl_cb.p_alloc_psm = L2CA_AllocatePSM;
687 p_acb->ctrl_psm = bta_hl_cb.p_alloc_psm();
688 p_acb->data_psm = bta_hl_cb.p_alloc_psm();
689 p_acb->p_mcap_cback = bta_hl_mcap_ctrl_cback;
690 status = bta_hl_app_registration(app_idx);
691 } else {
692 status = BTA_HL_STATUS_NO_RESOURCE;
693 }
694 } else {
695 status = BTA_HL_STATUS_DUPLICATE_APP_ID;
696 }
697 }
698
699 if (status != BTA_HL_STATUS_OK) {
700 if ((status != BTA_HL_STATUS_DUPLICATE_APP_ID) &&
701 (status != BTA_HL_STATUS_NO_RESOURCE)) {
702 if (p_acb) memset(p_acb, 0, sizeof(tBTA_HL_APP_CB));
703 }
704 }
705 #if (BTA_HL_DEBUG == TRUE)
706 if (status != BTA_HL_STATUS_OK) {
707 APPL_TRACE_DEBUG("bta_hl_api_register status =%s",
708 bta_hl_status_code(status));
709 }
710 #endif
711
712 memset(&evt_data, 0, sizeof(tBTA_HL));
713 evt_data.reg_cfm.status = status;
714 evt_data.reg_cfm.app_id = p_data->api_reg.app_id;
715 if (status == BTA_HL_STATUS_OK)
716 evt_data.reg_cfm.app_handle = p_acb->app_handle;
717 if (p_data->api_reg.p_cback) {
718 p_data->api_reg.p_cback(BTA_HL_REGISTER_CFM_EVT, (tBTA_HL*)&evt_data);
719 }
720
721 if (status == BTA_HL_STATUS_OK) {
722 evt_data.sdp_info_ind.app_handle = p_acb->app_handle;
723 evt_data.sdp_info_ind.ctrl_psm = p_acb->ctrl_psm;
724 evt_data.sdp_info_ind.data_psm = p_acb->data_psm;
725 evt_data.sdp_info_ind.data_x_spec = BTA_HL_SDP_IEEE_11073_20601;
726 evt_data.sdp_info_ind.mcap_sup_procs = BTA_HL_MCAP_SUP_PROC_MASK;
727
728 if (p_data->api_reg.p_cback) {
729 p_data->api_reg.p_cback(BTA_HL_SDP_INFO_IND_EVT, (tBTA_HL*)&evt_data);
730 }
731 }
732 }
733
734 /*******************************************************************************
735 *
736 * Function bta_hl_api_deregister
737 *
738 * Description Process the API de-registration request
739 *
740 * Returns void
741 *
742 ******************************************************************************/
bta_hl_api_deregister(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)743 static void bta_hl_api_deregister(UNUSED_ATTR tBTA_HL_CB* p_cb,
744 tBTA_HL_DATA* p_data) {
745 uint8_t app_idx;
746 tBTA_HL_APP_CB* p_acb;
747
748 if (bta_hl_find_app_idx_using_handle(p_data->api_dereg.app_handle,
749 &app_idx)) {
750 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
751 p_acb->deregistering = true;
752 bta_hl_check_deregistration(app_idx, p_data);
753 } else {
754 APPL_TRACE_ERROR("Invalid app_handle=%d", p_data->api_dereg.app_handle);
755 }
756 }
757
758 /*******************************************************************************
759 *
760 * Function bta_hl_api_cch_open
761 *
762 * Description Process the API CCH open request
763 *
764 * Returns void
765 *
766 ******************************************************************************/
bta_hl_api_cch_open(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)767 static void bta_hl_api_cch_open(UNUSED_ATTR tBTA_HL_CB* p_cb,
768 tBTA_HL_DATA* p_data) {
769 tBTA_HL evt_data;
770 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
771 uint8_t app_idx, mcl_idx;
772 tBTA_HL_APP_CB* p_acb;
773 tBTA_HL_MCL_CB* p_mcb;
774
775 if (bta_hl_find_app_idx_using_handle(p_data->api_cch_open.app_handle,
776 &app_idx)) {
777 if (!bta_hl_find_mcl_idx(app_idx, p_data->api_cch_open.bd_addr, &mcl_idx)) {
778 if (bta_hl_find_avail_mcl_idx(app_idx, &mcl_idx)) {
779 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
780 p_mcb->in_use = true;
781 p_mcb->req_ctrl_psm = p_data->api_cch_open.ctrl_psm;
782 p_mcb->sec_mask = p_data->api_cch_open.sec_mask;
783 p_mcb->bd_addr = p_data->api_cch_open.bd_addr;
784 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_OPEN;
785 } else {
786 status = BTA_HL_STATUS_NO_RESOURCE;
787 }
788 } else {
789 /* Only one MCL per BD_ADDR */
790 status = BTA_HL_STATUS_DUPLICATE_CCH_OPEN;
791 APPL_TRACE_DEBUG("bta_hl_api_cch_open: CCH already open: status =%d",
792 status)
793 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
794 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
795 if (p_acb->p_cback) {
796 bta_hl_build_cch_open_cfm(&evt_data, p_data->api_cch_open.app_id,
797 p_data->api_cch_open.app_handle,
798 p_mcb->mcl_handle,
799 p_data->api_cch_open.bd_addr, status);
800 p_acb->p_cback(BTA_HL_CCH_OPEN_CFM_EVT, (tBTA_HL*)&evt_data);
801 } else {
802 APPL_TRACE_ERROR("bta_hl_api_cch_open Null Callback");
803 }
804 return;
805 }
806 } else {
807 status = BTA_HL_STATUS_INVALID_APP_HANDLE;
808 }
809 #if (BTA_HL_DEBUG == TRUE)
810 if (status != BTA_HL_STATUS_OK) {
811 APPL_TRACE_DEBUG("bta_hl_api_cch_open status =%s",
812 bta_hl_status_code(status));
813 }
814 #endif
815 switch (status) {
816 case BTA_HL_STATUS_OK:
817 bta_hl_cch_sm_execute(app_idx, mcl_idx, BTA_HL_CCH_OPEN_EVT, p_data);
818 break;
819 case BTA_HL_STATUS_NO_RESOURCE:
820 case BTA_HL_STATUS_FAIL:
821
822 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
823 if (p_acb->p_cback) {
824 bta_hl_build_cch_open_cfm(&evt_data, p_data->api_cch_open.app_id,
825 p_data->api_cch_open.app_handle, 0,
826 p_data->api_cch_open.bd_addr, status);
827 p_acb->p_cback(BTA_HL_CCH_OPEN_CFM_EVT, (tBTA_HL*)&evt_data);
828 } else {
829 APPL_TRACE_ERROR("bta_hl_api_cch_open Null Callback");
830 }
831 break;
832 default:
833 APPL_TRACE_ERROR("status code=%d", status);
834 break;
835 }
836 }
837
838 /*******************************************************************************
839 *
840 * Function bta_hl_api_cch_close
841 *
842 * Description Process the API CCH close request
843 *
844 * Returns void
845 *
846 ******************************************************************************/
bta_hl_api_cch_close(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)847 static void bta_hl_api_cch_close(UNUSED_ATTR tBTA_HL_CB* p_cb,
848 tBTA_HL_DATA* p_data) {
849 tBTA_HL evt_data;
850 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
851 uint8_t app_idx, mcl_idx;
852 tBTA_HL_APP_CB* p_acb;
853 tBTA_HL_MCL_CB* p_mcb;
854
855 if (bta_hl_find_mcl_idx_using_handle(p_data->api_cch_close.mcl_handle,
856 &app_idx, &mcl_idx)) {
857 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
858 p_mcb->cch_oper = BTA_HL_CCH_OP_LOCAL_CLOSE;
859 } else {
860 status = BTA_HL_STATUS_INVALID_MCL_HANDLE;
861 }
862 #if (BTA_HL_DEBUG == TRUE)
863 if (status != BTA_HL_STATUS_OK) {
864 APPL_TRACE_DEBUG("bta_hl_api_cch_close status =%s",
865 bta_hl_status_code(status));
866 }
867 #endif
868 switch (status) {
869 case BTA_HL_STATUS_OK:
870 bta_hl_check_cch_close(app_idx, mcl_idx, p_data, true);
871 break;
872
873 case BTA_HL_STATUS_INVALID_MCL_HANDLE:
874 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
875 if (p_acb->p_cback) {
876 bta_hl_build_cch_close_cfm(&evt_data, p_acb->app_handle,
877 p_data->api_cch_close.mcl_handle, status);
878 p_acb->p_cback(BTA_HL_CCH_CLOSE_CFM_EVT, (tBTA_HL*)&evt_data);
879 } else {
880 APPL_TRACE_ERROR("bta_hl_api_cch_close Null Callback");
881 }
882 break;
883 default:
884 APPL_TRACE_ERROR("status code=%d", status);
885 break;
886 }
887 }
888
889 /*******************************************************************************
890 *
891 * Function bta_hl_api_dch_open
892 *
893 * Description Process the API DCH open request
894 *
895 * Returns void
896 *
897 ******************************************************************************/
bta_hl_api_dch_open(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)898 static void bta_hl_api_dch_open(UNUSED_ATTR tBTA_HL_CB* p_cb,
899 tBTA_HL_DATA* p_data) {
900 tBTA_HL evt_data;
901 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
902 uint8_t app_idx, mcl_idx, mdl_idx;
903 tBTA_HL_APP_CB* p_acb;
904 tBTA_HL_MCL_CB* p_mcb = NULL;
905 tBTA_HL_MDL_CB* p_dcb;
906 tBTA_HL_MDEP_CFG* p_mdep_cfg;
907 uint8_t mdep_cfg_idx;
908
909 if (bta_hl_find_mcl_idx_using_handle(p_data->api_dch_open.mcl_handle,
910 &app_idx, &mcl_idx)) {
911 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
912 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
913
914 APPL_TRACE_DEBUG(
915 "bta_hl_api_dch_open: app_ix=%d, mcl_idx=%d, cch_state=%d, "
916 "mcl_handle=%d",
917 app_idx, mcl_idx, p_mcb->cch_state, p_data->api_dch_open.mcl_handle);
918 if (p_mcb->cch_state == BTA_HL_CCH_OPEN_ST) {
919 if (bta_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) {
920 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
921
922 if (bta_hl_find_mdep_cfg_idx(
923 app_idx, p_data->api_dch_open.local_mdep_id, &mdep_cfg_idx)) {
924 if (mdep_cfg_idx &&
925 (p_acb->sup_feature.mdep[mdep_cfg_idx].mdep_cfg.mdep_role ==
926 BTA_HL_MDEP_ROLE_SINK)) {
927 p_data->api_dch_open.local_cfg = BTA_HL_DCH_CFG_NO_PREF;
928 }
929
930 status = bta_hl_chk_local_cfg(app_idx, mcl_idx, mdep_cfg_idx,
931 p_data->api_dch_open.local_cfg);
932 if (status == BTA_HL_STATUS_OK) {
933 if (p_data->api_dch_open.local_mdep_id !=
934 BTA_HL_ECHO_TEST_MDEP_ID) {
935 if (bta_hl_set_ctrl_psm_for_dch(app_idx, mcl_idx, mdl_idx,
936 p_data->api_dch_open.ctrl_psm)) {
937 p_mdep_cfg = BTA_HL_GET_MDEP_CFG_PTR(app_idx, mdep_cfg_idx);
938 p_dcb->in_use = true;
939 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_OPEN;
940 p_dcb->sec_mask = p_data->api_dch_open.sec_mask;
941 p_dcb->local_mdep_id = p_data->api_dch_open.local_mdep_id;
942 p_dcb->peer_mdep_id = p_data->api_dch_open.peer_mdep_id;
943
944 if (p_mdep_cfg->mdep_role == BTA_HL_MDEP_ROLE_SINK) {
945 p_dcb->peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE;
946 } else {
947 p_dcb->peer_mdep_role = BTA_HL_MDEP_ROLE_SINK;
948 }
949
950 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
951 p_dcb->local_cfg = p_data->api_dch_open.local_cfg;
952
953 bta_hl_find_rxtx_apdu_size(app_idx, mdep_cfg_idx,
954 &p_dcb->max_rx_apdu_size,
955 &p_dcb->max_tx_apdu_size);
956 p_dcb->mdl_id =
957 bta_hl_allocate_mdl_id(app_idx, mcl_idx, mdl_idx);
958 p_dcb->mdl_cfg_idx_included = false;
959 } else {
960 status = BTA_HL_STATUS_INVALID_CTRL_PSM;
961 }
962
963 } else {
964 status = BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID;
965 }
966 }
967 } else {
968 status = BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID;
969 }
970 } else {
971 status = BTA_HL_STATUS_NO_RESOURCE;
972 }
973 } else {
974 status = BTA_HL_STATUS_NO_CCH;
975 }
976 } else {
977 status = BTA_HL_STATUS_INVALID_MCL_HANDLE;
978 }
979
980 #if (BTA_HL_DEBUG == TRUE)
981 if (status != BTA_HL_STATUS_OK) {
982 APPL_TRACE_DEBUG("bta_hl_api_dch_open status =%s",
983 bta_hl_status_code(status));
984 }
985 #endif
986 switch (status) {
987 case BTA_HL_STATUS_OK:
988 if (p_mcb->sdp.num_recs) {
989 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_OPEN_EVT,
990 p_data);
991 } else {
992 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
993 BTA_HL_DCH_SDP_INIT_EVT, p_data);
994 }
995 break;
996 case BTA_HL_STATUS_INVALID_DCH_CFG:
997 case BTA_HL_STATUS_NO_FIRST_RELIABLE:
998 case BTA_HL_STATUS_NO_CCH:
999 case BTA_HL_STATUS_NO_RESOURCE:
1000 case BTA_HL_STATUS_FAIL:
1001 case BTA_HL_STATUS_INVALID_LOCAL_MDEP_ID:
1002 case BTA_HL_STATUS_INVALID_CTRL_PSM:
1003 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1004 if (p_acb->p_cback) {
1005 bta_hl_build_dch_open_cfm(
1006 &evt_data, p_acb->app_handle, p_data->api_dch_open.mcl_handle,
1007 BTA_HL_INVALID_MDL_HANDLE, 0, 0, 0, 0, 0, status);
1008 p_acb->p_cback(BTA_HL_DCH_OPEN_CFM_EVT, (tBTA_HL*)&evt_data);
1009 } else {
1010 APPL_TRACE_ERROR("bta_hl_api_dch_open Null Callback");
1011 }
1012
1013 break;
1014 default:
1015 APPL_TRACE_ERROR("Status code=%d", status);
1016 break;
1017 }
1018 }
1019 /*******************************************************************************
1020 *
1021 * Function bta_hl_api_dch_close
1022 *
1023 * Description Process the API DCH close request
1024 *
1025 * Returns void
1026 *
1027 ******************************************************************************/
bta_hl_api_dch_close(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)1028 static void bta_hl_api_dch_close(UNUSED_ATTR tBTA_HL_CB* p_cb,
1029 tBTA_HL_DATA* p_data) {
1030 tBTA_HL evt_data;
1031 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1032 uint8_t app_idx, mcl_idx, mdl_idx;
1033 tBTA_HL_APP_CB* p_acb;
1034 tBTA_HL_MCL_CB* p_mcb;
1035 tBTA_HL_MDL_CB* p_dcb;
1036
1037 if (bta_hl_find_mdl_idx_using_handle(p_data->api_dch_close.mdl_handle,
1038 &app_idx, &mcl_idx, &mdl_idx)) {
1039 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1040 if (p_dcb->dch_state != BTA_HL_DCH_OPEN_ST) {
1041 status = BTA_HL_STATUS_FAIL;
1042 }
1043 } else {
1044 status = BTA_HL_STATUS_INVALID_MDL_HANDLE;
1045 }
1046
1047 #if (BTA_HL_DEBUG == TRUE)
1048 if (status != BTA_HL_STATUS_OK) {
1049 APPL_TRACE_DEBUG("bta_hl_api_dch_close status =%s",
1050 bta_hl_status_code(status));
1051 }
1052 #endif
1053
1054 switch (status) {
1055 case BTA_HL_STATUS_OK:
1056 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_CLOSE_EVT,
1057 p_data);
1058 break;
1059 case BTA_HL_STATUS_FAIL:
1060 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1061 if (p_acb->p_cback) {
1062 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1063 bta_hl_build_dch_close_cfm(&evt_data, p_acb->app_handle,
1064 p_mcb->mcl_handle,
1065 p_data->api_dch_close.mdl_handle, status);
1066
1067 p_acb->p_cback(BTA_HL_DCH_CLOSE_CFM_EVT, (tBTA_HL*)&evt_data);
1068 } else {
1069 APPL_TRACE_ERROR("bta_hl_api_dch_close Null Callback");
1070 }
1071 break;
1072 default:
1073 APPL_TRACE_ERROR("Status code=%d", status);
1074 break;
1075 }
1076 }
1077
1078 /*******************************************************************************
1079 *
1080 * Function bta_hl_api_dch_reconnect
1081 *
1082 * Description Process the API DCH reconnect request
1083 *
1084 * Returns void
1085 *
1086 ******************************************************************************/
bta_hl_api_dch_reconnect(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)1087 static void bta_hl_api_dch_reconnect(UNUSED_ATTR tBTA_HL_CB* p_cb,
1088 tBTA_HL_DATA* p_data) {
1089 tBTA_HL evt_data;
1090 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1091 uint8_t app_idx, mcl_idx, mdl_idx;
1092 tBTA_HL_APP_CB* p_acb;
1093 tBTA_HL_MCL_CB* p_mcb = NULL;
1094 tBTA_HL_MDL_CB* p_dcb;
1095 uint8_t mdep_cfg_idx;
1096 uint8_t mdl_cfg_idx;
1097 tBTA_HL_MDEP_CFG* p_mdep_cfg;
1098
1099 if (bta_hl_find_mcl_idx_using_handle(p_data->api_dch_reconnect.mcl_handle,
1100 &app_idx, &mcl_idx)) {
1101 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1102 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1103 if (p_mcb->cch_state == BTA_HL_CCH_OPEN_ST) {
1104 if (bta_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) {
1105 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1106 if (bta_hl_validate_reconnect_params(app_idx, mcl_idx,
1107 &(p_data->api_dch_reconnect),
1108 &mdep_cfg_idx, &mdl_cfg_idx)) {
1109 if (!bta_hl_is_the_first_reliable_existed(app_idx, mcl_idx) &&
1110 (p_acb->mdl_cfg[mdl_cfg_idx].dch_mode !=
1111 BTA_HL_DCH_MODE_RELIABLE)) {
1112 status = BTA_HL_STATUS_NO_FIRST_RELIABLE;
1113 } else {
1114 if (bta_hl_set_ctrl_psm_for_dch(app_idx, mcl_idx, mdl_idx,
1115 p_data->api_dch_open.ctrl_psm)) {
1116 p_dcb->in_use = true;
1117 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_RECONNECT;
1118 p_dcb->sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
1119 p_dcb->local_mdep_id = p_acb->mdl_cfg[mdl_cfg_idx].local_mdep_id;
1120 p_dcb->local_mdep_cfg_idx = mdep_cfg_idx;
1121 p_dcb->local_cfg = BTA_HL_DCH_CFG_UNKNOWN;
1122 p_dcb->mdl_id = p_data->api_dch_reconnect.mdl_id;
1123 p_dcb->mdl_cfg_idx_included = true;
1124 p_dcb->mdl_cfg_idx = mdl_cfg_idx;
1125 p_dcb->dch_mode = p_acb->mdl_cfg[mdl_cfg_idx].dch_mode;
1126
1127 p_mdep_cfg = BTA_HL_GET_MDEP_CFG_PTR(app_idx, mdep_cfg_idx);
1128
1129 if (p_mdep_cfg->mdep_role == BTA_HL_MDEP_ROLE_SINK) {
1130 p_dcb->peer_mdep_role = BTA_HL_MDEP_ROLE_SOURCE;
1131 APPL_TRACE_DEBUG("peer mdep role = SOURCE ");
1132 } else {
1133 p_dcb->peer_mdep_role = BTA_HL_MDEP_ROLE_SINK;
1134 APPL_TRACE_DEBUG("peer mdep role = SINK ");
1135 }
1136
1137 bta_hl_find_rxtx_apdu_size(app_idx, mdep_cfg_idx,
1138 &p_dcb->max_rx_apdu_size,
1139 &p_dcb->max_tx_apdu_size);
1140 } else {
1141 status = BTA_HL_STATUS_INVALID_CTRL_PSM;
1142 }
1143 }
1144 } else {
1145 status = BTA_HL_STATUS_INVALID_RECONNECT_CFG;
1146 }
1147 } else {
1148 status = BTA_HL_STATUS_NO_RESOURCE;
1149 }
1150 } else {
1151 status = BTA_HL_STATUS_NO_CCH;
1152 }
1153 } else {
1154 status = BTA_HL_STATUS_INVALID_MCL_HANDLE;
1155 }
1156
1157 #if (BTA_HL_DEBUG == TRUE)
1158 if (status != BTA_HL_STATUS_OK) {
1159 APPL_TRACE_DEBUG("bta_hl_api_dch_reconnect status=%s",
1160 bta_hl_status_code(status));
1161 }
1162 #endif
1163
1164 switch (status) {
1165 case BTA_HL_STATUS_OK:
1166 if (p_mcb->sdp.num_recs) {
1167 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1168 BTA_HL_DCH_RECONNECT_EVT, p_data);
1169 } else {
1170 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1171 BTA_HL_DCH_SDP_INIT_EVT, p_data);
1172 }
1173 break;
1174 case BTA_HL_STATUS_INVALID_RECONNECT_CFG:
1175 case BTA_HL_STATUS_NO_FIRST_RELIABLE:
1176 case BTA_HL_STATUS_NO_CCH:
1177 case BTA_HL_STATUS_NO_RESOURCE:
1178 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1179 if (p_acb->p_cback) {
1180 bta_hl_build_dch_open_cfm(
1181 &evt_data, p_acb->app_handle, p_data->api_dch_reconnect.mcl_handle,
1182 BTA_HL_INVALID_MDL_HANDLE, 0, p_data->api_dch_reconnect.mdl_id, 0,
1183 0, 0, status);
1184 p_acb->p_cback(BTA_HL_DCH_RECONNECT_CFM_EVT, (tBTA_HL*)&evt_data);
1185 } else {
1186 APPL_TRACE_ERROR("bta_hl_api_dch_reconnect Null Callback");
1187 }
1188 break;
1189 default:
1190 APPL_TRACE_ERROR("Status code=%d", status);
1191 break;
1192 }
1193 }
1194
1195 /*******************************************************************************
1196 *
1197 * Function bta_hl_api_dch_echo_test
1198 *
1199 * Description Process the API Echo test request
1200 *
1201 * Returns void
1202 *
1203 ******************************************************************************/
bta_hl_api_dch_echo_test(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)1204 static void bta_hl_api_dch_echo_test(UNUSED_ATTR tBTA_HL_CB* p_cb,
1205 tBTA_HL_DATA* p_data) {
1206 tBTA_HL evt_data;
1207 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1208 uint8_t app_idx, mcl_idx, mdl_idx;
1209 tBTA_HL_APP_CB* p_acb;
1210 tBTA_HL_MCL_CB* p_mcb = NULL;
1211 tBTA_HL_MDL_CB* p_dcb;
1212 tBTA_HL_ECHO_CFG* p_echo_cfg;
1213
1214 if (bta_hl_find_mcl_idx_using_handle(p_data->api_dch_echo_test.mcl_handle,
1215 &app_idx, &mcl_idx)) {
1216 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1217 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1218 if (p_mcb->cch_state == BTA_HL_CCH_OPEN_ST) {
1219 if (!p_mcb->echo_test) {
1220 if (bta_hl_find_avail_mdl_idx(app_idx, mcl_idx, &mdl_idx)) {
1221 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1222
1223 if ((p_data->api_dch_echo_test.local_cfg ==
1224 BTA_HL_DCH_CFG_RELIABLE) ||
1225 (p_data->api_dch_echo_test.local_cfg ==
1226 BTA_HL_DCH_CFG_STREAMING)) {
1227 bool fcs_use =
1228 (bool)(p_dcb->chnl_cfg.fcs & BTA_HL_MCA_FCS_USE_MASK);
1229 p_dcb->p_echo_tx_pkt =
1230 bta_hl_get_buf(p_data->api_dch_echo_test.pkt_size, fcs_use);
1231 if (p_dcb->p_echo_tx_pkt != NULL) {
1232 if (bta_hl_set_ctrl_psm_for_dch(app_idx, mcl_idx, mdl_idx,
1233 p_data->api_dch_open.ctrl_psm)) {
1234 p_dcb->in_use = true;
1235 p_dcb->dch_oper = BTA_HL_DCH_OP_LOCAL_OPEN;
1236 p_dcb->sec_mask = (BTA_SEC_AUTHENTICATE | BTA_SEC_ENCRYPT);
1237 p_dcb->local_mdep_cfg_idx = BTA_HL_ECHO_TEST_MDEP_CFG_IDX;
1238 p_dcb->local_cfg = p_data->api_dch_echo_test.local_cfg;
1239 p_dcb->local_mdep_id = BTA_HL_ECHO_TEST_MDEP_ID;
1240 p_dcb->peer_mdep_id = BTA_HL_ECHO_TEST_MDEP_ID;
1241 p_dcb->mdl_id =
1242 bta_hl_allocate_mdl_id(app_idx, mcl_idx, mdl_idx);
1243 p_dcb->mdl_cfg_idx_included = false;
1244 p_echo_cfg = BTA_HL_GET_ECHO_CFG_PTR(app_idx);
1245 p_dcb->max_rx_apdu_size = p_echo_cfg->max_rx_apdu_size;
1246 p_dcb->max_tx_apdu_size = p_echo_cfg->max_tx_apdu_size;
1247 p_mcb->echo_test = true;
1248 p_mcb->echo_mdl_idx = mdl_idx;
1249 } else {
1250 status = BTA_HL_STATUS_INVALID_CTRL_PSM;
1251 }
1252 } else {
1253 status = BTA_HL_STATUS_NO_RESOURCE;
1254 }
1255 } else {
1256 status = BTA_HL_STATUS_INVALID_DCH_CFG;
1257 }
1258 } else {
1259 status = BTA_HL_STATUS_NO_RESOURCE;
1260 }
1261 } else {
1262 status = BTA_HL_STATUS_ECHO_TEST_BUSY;
1263 }
1264 } else {
1265 status = BTA_HL_STATUS_NO_CCH;
1266 }
1267 } else {
1268 status = BTA_HL_STATUS_NO_MCL;
1269 }
1270
1271 #if (BTA_HL_DEBUG == TRUE)
1272 if (status != BTA_HL_STATUS_OK) {
1273 APPL_TRACE_DEBUG("bta_hl_api_dch_echo_test status=%s",
1274 bta_hl_status_code(status));
1275 }
1276 #endif
1277
1278 switch (status) {
1279 case BTA_HL_STATUS_OK:
1280 if (p_mcb->sdp.num_recs) {
1281 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1282 BTA_HL_DCH_ECHO_TEST_EVT, p_data);
1283 } else {
1284 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx,
1285 BTA_HL_DCH_SDP_INIT_EVT, p_data);
1286 }
1287 break;
1288 case BTA_HL_STATUS_ECHO_TEST_BUSY:
1289 case BTA_HL_STATUS_NO_RESOURCE:
1290 case BTA_HL_STATUS_INVALID_DCH_CFG:
1291 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1292 if (p_acb->p_cback) {
1293 bta_hl_build_echo_test_cfm(&evt_data, p_acb->app_handle,
1294 p_mcb->mcl_handle, status);
1295 p_acb->p_cback(BTA_HL_DCH_ECHO_TEST_CFM_EVT, (tBTA_HL*)&evt_data);
1296 } else {
1297 APPL_TRACE_ERROR("bta_hl_api_dch_echo_test Null Callback");
1298 }
1299 break;
1300
1301 default:
1302 APPL_TRACE_ERROR("Status code=%s", status);
1303 break;
1304 }
1305 }
1306
1307 /*******************************************************************************
1308 *
1309 * Function bta_hl_api_sdp_query
1310 *
1311 * Description Process the API SDP query request
1312 *
1313 * Returns void
1314 *
1315 ******************************************************************************/
bta_hl_api_sdp_query(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)1316 static void bta_hl_api_sdp_query(UNUSED_ATTR tBTA_HL_CB* p_cb,
1317 tBTA_HL_DATA* p_data) {
1318 tBTA_HL evt_data;
1319 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1320 uint8_t app_idx, mcl_idx;
1321 tBTA_HL_APP_CB* p_acb;
1322 tBTA_HL_MCL_CB* p_mcb;
1323
1324 if (bta_hl_find_app_idx_using_handle(p_data->api_sdp_query.app_handle,
1325 &app_idx)) {
1326 if (!bta_hl_find_mcl_idx(app_idx, p_data->api_sdp_query.bd_addr,
1327 &mcl_idx)) {
1328 if (bta_hl_find_avail_mcl_idx(app_idx, &mcl_idx)) {
1329 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1330 p_mcb->in_use = true;
1331 p_mcb->bd_addr = p_data->api_sdp_query.bd_addr;
1332 APPL_TRACE_DEBUG(
1333 "bta_hl_api_sdp_query p_mcb->app_id %d app_idx %d mcl_idx %d",
1334 p_mcb->app_id, app_idx, mcl_idx);
1335 p_mcb->app_id = p_data->api_sdp_query.app_id;
1336 p_mcb->sdp_oper = BTA_HL_SDP_OP_SDP_QUERY_NEW;
1337 } else {
1338 status = BTA_HL_STATUS_NO_RESOURCE;
1339 }
1340 } else {
1341 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1342 p_mcb->app_id = p_data->api_sdp_query.app_id;
1343 if (p_mcb->sdp_oper != BTA_HL_SDP_OP_NONE) {
1344 status = BTA_HL_STATUS_SDP_NO_RESOURCE;
1345 } else {
1346 p_mcb->sdp_oper = BTA_HL_SDP_OP_SDP_QUERY_CURRENT;
1347 }
1348 }
1349 } else {
1350 status = BTA_HL_STATUS_INVALID_APP_HANDLE;
1351 }
1352
1353 if (status == BTA_HL_STATUS_OK) {
1354 status = bta_hl_init_sdp(p_mcb->sdp_oper, app_idx, mcl_idx, 0xFF);
1355 if ((status != BTA_HL_STATUS_OK) &&
1356 (p_mcb->sdp_oper == BTA_HL_SDP_OP_SDP_QUERY_NEW)) {
1357 memset(p_mcb, 0, sizeof(tBTA_HL_MCL_CB));
1358 }
1359 }
1360 #if (BTA_HL_DEBUG == TRUE)
1361 if (status != BTA_HL_STATUS_OK) {
1362 APPL_TRACE_DEBUG("bta_hl_api_sdp_query status=%s",
1363 bta_hl_status_code(status));
1364 }
1365 #endif
1366 switch (status) {
1367 case BTA_HL_STATUS_NO_RESOURCE:
1368 case BTA_HL_STATUS_FAIL:
1369 case BTA_HL_STATUS_SDP_NO_RESOURCE:
1370 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1371 if (p_acb->p_cback) {
1372 bta_hl_build_sdp_query_cfm(&evt_data, p_data->api_sdp_query.app_id,
1373 p_data->api_sdp_query.app_handle,
1374 p_data->api_sdp_query.bd_addr, NULL, status);
1375 p_acb->p_cback(BTA_HL_SDP_QUERY_CFM_EVT, (tBTA_HL*)&evt_data);
1376 } else {
1377 APPL_TRACE_ERROR("bta_hl_api_sdp_query Null Callback");
1378 }
1379 break;
1380 case BTA_HL_STATUS_OK:
1381 break;
1382 default:
1383 APPL_TRACE_ERROR("Status code=%d", status);
1384 break;
1385 }
1386 }
1387
1388 /*******************************************************************************
1389 *
1390 * Function bta_hl_sdp_query_results
1391 *
1392 * Description Process the SDP query results
1393 *
1394 * Returns void
1395 *
1396 ******************************************************************************/
bta_hl_sdp_query_results(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)1397 static void bta_hl_sdp_query_results(UNUSED_ATTR tBTA_HL_CB* p_cb,
1398 tBTA_HL_DATA* p_data) {
1399 tBTA_HL evt_data;
1400 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1401 uint8_t app_idx = p_data->cch_sdp.app_idx;
1402 uint8_t mcl_idx = p_data->cch_sdp.mcl_idx;
1403 tBTA_HL_APP_CB* p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1404 tBTA_HL_MCL_CB* p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1405 tBTA_HL_SDP* p_sdp = NULL;
1406 uint16_t event;
1407 bool release_sdp_buf = false;
1408
1409 event = p_data->hdr.event;
1410
1411 if (event == BTA_HL_SDP_QUERY_OK_EVT) {
1412 p_sdp = (tBTA_HL_SDP*)osi_malloc(sizeof(tBTA_HL_SDP));
1413 memcpy(p_sdp, &p_mcb->sdp, sizeof(tBTA_HL_SDP));
1414 release_sdp_buf = true;
1415 } else {
1416 status = BTA_HL_STATUS_SDP_FAIL;
1417 }
1418
1419 #if (BTA_HL_DEBUG == TRUE)
1420 if (status != BTA_HL_STATUS_OK) {
1421 APPL_TRACE_DEBUG("bta_hl_sdp_query_results status=%s",
1422 bta_hl_status_code(status));
1423 }
1424 #endif
1425
1426 APPL_TRACE_DEBUG(
1427 "bta_hl_sdp_query_results p_mcb->app_id %d app_idx %d mcl_idx %d",
1428 p_mcb->app_id, app_idx, mcl_idx);
1429 bta_hl_build_sdp_query_cfm(&evt_data, p_mcb->app_id, p_acb->app_handle,
1430 p_mcb->bd_addr, p_sdp, status);
1431 p_acb->p_cback(BTA_HL_SDP_QUERY_CFM_EVT, (tBTA_HL*)&evt_data);
1432
1433 if (release_sdp_buf) osi_free_and_reset((void**)&p_sdp);
1434
1435 if (p_data->cch_sdp.release_mcl_cb) {
1436 memset(p_mcb, 0, sizeof(tBTA_HL_MCL_CB));
1437 } else {
1438 if (p_mcb->close_pending)
1439 bta_hl_check_cch_close(app_idx, mcl_idx, p_data, true);
1440
1441 if (!p_mcb->ctrl_psm) {
1442 /* Control channel acceptor: do not store the SDP records */
1443 memset(&p_mcb->sdp, 0, sizeof(tBTA_HL_SDP));
1444 }
1445 }
1446 }
1447
1448 /*******************************************************************************
1449 *
1450 * Function bta_hl_api_delete_mdl
1451 *
1452 * Description Process the API DELETE MDL request
1453 *
1454 * Returns void
1455 *
1456 ******************************************************************************/
bta_hl_api_delete_mdl(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)1457 static void bta_hl_api_delete_mdl(UNUSED_ATTR tBTA_HL_CB* p_cb,
1458 tBTA_HL_DATA* p_data) {
1459 tBTA_HL evt_data;
1460 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1461 uint8_t app_idx, mcl_idx;
1462 tBTA_HL_APP_CB* p_acb;
1463 tBTA_HL_MCL_CB* p_mcb;
1464
1465 if (bta_hl_find_mcl_idx_using_handle(p_data->api_delete_mdl.mcl_handle,
1466 &app_idx, &mcl_idx)) {
1467 if (bta_hl_is_mdl_value_valid(p_data->api_delete_mdl.mdl_id)) {
1468 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1469 if (bta_hl_is_mdl_exsit_in_mcl(app_idx, p_mcb->bd_addr,
1470 p_data->api_delete_mdl.mdl_id)) {
1471 p_mcb->delete_mdl.mcl_handle = p_data->api_delete_mdl.mcl_handle;
1472 p_mcb->delete_mdl.mdl_id = p_data->api_delete_mdl.mdl_id;
1473 p_mcb->delete_mdl.delete_req_pending = true;
1474
1475 if (MCA_Delete((tMCA_CL)p_mcb->mcl_handle,
1476 p_data->api_delete_mdl.mdl_id) != MCA_SUCCESS) {
1477 status = BTA_HL_STATUS_FAIL;
1478 memset(&p_mcb->delete_mdl, 0, sizeof(tBTA_HL_DELETE_MDL));
1479 }
1480 } else {
1481 status = BTA_HL_STATUS_NO_MDL_ID_FOUND;
1482 }
1483 } else {
1484 status = BTA_HL_STATUS_INVALID_MDL_ID;
1485 }
1486 } else {
1487 status = BTA_HL_STATUS_INVALID_MCL_HANDLE;
1488 }
1489
1490 #if (BTA_HL_DEBUG == TRUE)
1491 if (status != BTA_HL_STATUS_OK) {
1492 APPL_TRACE_DEBUG("bta_hl_api_delete_mdl status=%s",
1493 bta_hl_status_code(status));
1494 }
1495 #endif
1496 switch (status) {
1497 case BTA_HL_STATUS_OK:
1498 break;
1499 case BTA_HL_STATUS_FAIL:
1500 case BTA_HL_STATUS_NO_MDL_ID_FOUND:
1501 case BTA_HL_STATUS_INVALID_MDL_ID:
1502 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1503 if (p_acb->p_cback) {
1504 bta_hl_build_delete_mdl_cfm(&evt_data, p_acb->app_handle,
1505 p_data->api_delete_mdl.mcl_handle,
1506 p_data->api_delete_mdl.mdl_id, status);
1507 p_acb->p_cback(BTA_HL_DELETE_MDL_CFM_EVT, (tBTA_HL*)&evt_data);
1508 } else {
1509 APPL_TRACE_ERROR("bta_hl_api_delete_mdl Null Callback");
1510 }
1511 break;
1512 default:
1513 APPL_TRACE_ERROR("status code =%d", status);
1514 break;
1515 }
1516 }
1517
1518 /*******************************************************************************
1519 *
1520 * Function bta_hl_mca_delete_mdl_cfm
1521 *
1522 * Description Process the DELETE MDL confirmation event
1523 *
1524 * Returns void
1525 *
1526 ******************************************************************************/
bta_hl_mca_delete_mdl_cfm(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)1527 static void bta_hl_mca_delete_mdl_cfm(UNUSED_ATTR tBTA_HL_CB* p_cb,
1528 tBTA_HL_DATA* p_data) {
1529 tBTA_HL evt_data;
1530 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1531 uint8_t app_idx, mcl_idx;
1532 tMCA_RSP_EVT* p_delete_cfm = &p_data->mca_evt.mca_data.delete_cfm;
1533 tBTA_HL_MCL_CB* p_mcb;
1534 bool send_cfm_evt = true;
1535 tBTA_HL_APP_CB* p_acb;
1536
1537 if (bta_hl_find_mcl_idx_using_handle(p_data->mca_evt.mcl_handle, &app_idx,
1538 &mcl_idx)) {
1539 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1540 if (p_mcb->delete_mdl.delete_req_pending) {
1541 if (p_delete_cfm->rsp_code == MCA_RSP_SUCCESS) {
1542 if (!bta_hl_delete_mdl_cfg(app_idx, p_mcb->bd_addr,
1543 p_delete_cfm->mdl_id)) {
1544 status = BTA_HL_STATUS_FAIL;
1545 }
1546 } else {
1547 status = BTA_HL_STATUS_FAIL;
1548 }
1549
1550 memset(&p_mcb->delete_mdl, 0, sizeof(tBTA_HL_DELETE_MDL));
1551 } else {
1552 send_cfm_evt = false;
1553 }
1554 } else {
1555 send_cfm_evt = false;
1556 }
1557
1558 #if (BTA_HL_DEBUG == TRUE)
1559 if (status != BTA_HL_STATUS_OK) {
1560 APPL_TRACE_DEBUG("bta_hl_api_delete_mdl status=%s",
1561 bta_hl_status_code(status));
1562 }
1563 #endif
1564
1565 if (send_cfm_evt) {
1566 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1567 if (p_acb->p_cback) {
1568 bta_hl_build_delete_mdl_cfm(&evt_data, p_acb->app_handle,
1569 p_mcb->mcl_handle, p_delete_cfm->mdl_id,
1570 status);
1571
1572 p_acb->p_cback(BTA_HL_DELETE_MDL_CFM_EVT, (tBTA_HL*)&evt_data);
1573 } else {
1574 APPL_TRACE_ERROR("bta_hl_mca_delete_mdl_cfm Null Callback");
1575 }
1576 }
1577 }
1578
1579 /*******************************************************************************
1580 *
1581 * Function bta_hl_mca_delete_mdl_ind
1582 *
1583 * Description Process the DELETE MDL indication event
1584 *
1585 * Returns void
1586 *
1587 ******************************************************************************/
bta_hl_mca_delete_mdl_ind(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)1588 static void bta_hl_mca_delete_mdl_ind(UNUSED_ATTR tBTA_HL_CB* p_cb,
1589 tBTA_HL_DATA* p_data) {
1590 tBTA_HL evt_data;
1591 uint8_t app_idx, mcl_idx, mdl_idx;
1592 tMCA_EVT_HDR* p_delete_ind = &p_data->mca_evt.mca_data.delete_ind;
1593 tBTA_HL_MCL_CB* p_mcb;
1594 tBTA_HL_MDL_CB* p_dcb;
1595 bool send_ind_evt = false;
1596 tBTA_HL_APP_CB* p_acb;
1597
1598 if (bta_hl_find_mcl_idx_using_handle(p_data->mca_evt.mcl_handle, &app_idx,
1599 &mcl_idx)) {
1600 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1601
1602 if (bta_hl_find_mdl_idx(app_idx, mcl_idx, p_delete_ind->mdl_id, &mdl_idx)) {
1603 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1604 p_dcb->dch_oper = BTA_HL_DCH_OP_REMOTE_DELETE;
1605 }
1606 if (bta_hl_delete_mdl_cfg(app_idx, p_mcb->bd_addr, p_delete_ind->mdl_id)) {
1607 send_ind_evt = true;
1608 }
1609 }
1610
1611 #if (BTA_HL_DEBUG == TRUE)
1612 if (!send_ind_evt) {
1613 APPL_TRACE_DEBUG("bta_hl_mca_delete_mdl_ind is_send_ind_evt =%d",
1614 send_ind_evt);
1615 }
1616 #endif
1617
1618 if (send_ind_evt) {
1619 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1620 if (p_acb->p_cback) {
1621 evt_data.delete_mdl_ind.mcl_handle = p_mcb->mcl_handle;
1622 evt_data.delete_mdl_ind.app_handle = p_acb->app_handle;
1623 evt_data.delete_mdl_ind.mdl_id = p_delete_ind->mdl_id;
1624 p_acb->p_cback(BTA_HL_DELETE_MDL_IND_EVT, (tBTA_HL*)&evt_data);
1625 } else {
1626 APPL_TRACE_ERROR("bta_hl_mca_delete_mdl_ind Null Callback");
1627 }
1628 }
1629 }
1630
1631 /*******************************************************************************
1632 *
1633 * Function bta_hl_api_dch_abort
1634 *
1635 * Description Process the API DCH abort request
1636 *
1637 * Returns void
1638 *
1639 ******************************************************************************/
bta_hl_api_dch_abort(UNUSED_ATTR tBTA_HL_CB * p_cb,tBTA_HL_DATA * p_data)1640 static void bta_hl_api_dch_abort(UNUSED_ATTR tBTA_HL_CB* p_cb,
1641 tBTA_HL_DATA* p_data) {
1642 tBTA_HL_STATUS status = BTA_HL_STATUS_OK;
1643 uint8_t app_idx, mcl_idx, mdl_idx;
1644 tBTA_HL_APP_CB* p_acb;
1645 tBTA_HL_MCL_CB* p_mcb;
1646 tBTA_HL_MDL_CB* p_dcb;
1647 tBTA_HL evt_data;
1648
1649 if (bta_hl_find_mcl_idx_using_handle(p_data->api_dch_abort.mcl_handle,
1650 &app_idx, &mcl_idx)) {
1651 if (!bta_hl_find_dch_setup_mdl_idx(app_idx, mcl_idx, &mdl_idx)) {
1652 status = BTA_HL_STATUS_NO_MDL_ID_FOUND;
1653 } else {
1654 p_dcb = BTA_HL_GET_MDL_CB_PTR(app_idx, mcl_idx, mdl_idx);
1655 if (p_dcb->abort_oper) {
1656 /* abort already in progress*/
1657 status = BTA_HL_STATUS_FAIL;
1658 } else {
1659 p_dcb->abort_oper = BTA_HL_ABORT_LOCAL_MASK;
1660 }
1661 }
1662 } else {
1663 status = BTA_HL_STATUS_INVALID_MCL_HANDLE;
1664 }
1665
1666 #if (BTA_HL_DEBUG == TRUE)
1667 if (status != BTA_HL_STATUS_OK) {
1668 APPL_TRACE_DEBUG("bta_hl_api_dch_abort status=%s",
1669 bta_hl_status_code(status));
1670 }
1671 #endif
1672 switch (status) {
1673 case BTA_HL_STATUS_OK:
1674
1675 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, BTA_HL_DCH_ABORT_EVT,
1676 p_data);
1677 break;
1678 case BTA_HL_STATUS_NO_MDL_ID_FOUND:
1679 case BTA_HL_STATUS_FAIL:
1680
1681 p_acb = BTA_HL_GET_APP_CB_PTR(app_idx);
1682 if (p_acb->p_cback) {
1683 p_mcb = BTA_HL_GET_MCL_CB_PTR(app_idx, mcl_idx);
1684 bta_hl_build_abort_cfm(&evt_data,
1685
1686 p_acb->app_handle, p_mcb->mcl_handle,
1687 BTA_HL_STATUS_FAIL);
1688 p_acb->p_cback(BTA_HL_DCH_ABORT_CFM_EVT, (tBTA_HL*)&evt_data);
1689 } else {
1690 APPL_TRACE_ERROR("bta_hl_api_dch_abort Null Callback");
1691 }
1692 break;
1693 default:
1694 APPL_TRACE_ERROR("Status code=%d", status);
1695 break;
1696 }
1697 }
1698
1699 /*******************************************************************************
1700 *
1701 * Function bta_hl_hdl_event
1702 *
1703 * Description HL main event handling function.
1704 *
1705 * Returns void
1706 *
1707 ******************************************************************************/
bta_hl_hdl_event(BT_HDR * p_msg)1708 bool bta_hl_hdl_event(BT_HDR* p_msg) {
1709 uint8_t app_idx, mcl_idx, mdl_idx;
1710 bool success = true;
1711
1712 #if (BTA_HL_DEBUG == TRUE)
1713 APPL_TRACE_DEBUG("BTA HL Event Handler: Event [%s]",
1714 bta_hl_evt_code(p_msg->event));
1715 #endif
1716
1717 switch (p_msg->event) {
1718 case BTA_HL_API_ENABLE_EVT:
1719 bta_hl_api_enable(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1720 break;
1721 case BTA_HL_API_DISABLE_EVT:
1722 bta_hl_api_disable(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1723 break;
1724 case BTA_HL_API_UPDATE_EVT:
1725 bta_hl_api_update(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1726 break;
1727 case BTA_HL_API_REGISTER_EVT:
1728 bta_hl_api_register(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1729 break;
1730 case BTA_HL_API_DEREGISTER_EVT:
1731 bta_hl_api_deregister(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1732 break;
1733 case BTA_HL_API_CCH_OPEN_EVT:
1734 bta_hl_api_cch_open(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1735 break;
1736 case BTA_HL_API_CCH_CLOSE_EVT:
1737 bta_hl_api_cch_close(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1738 break;
1739 case BTA_HL_API_DCH_OPEN_EVT:
1740 bta_hl_api_dch_open(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1741 break;
1742 case BTA_HL_API_DCH_CLOSE_EVT:
1743 bta_hl_api_dch_close(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1744 break;
1745 case BTA_HL_API_DELETE_MDL_EVT:
1746 bta_hl_api_delete_mdl(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1747 break;
1748 case BTA_HL_API_DCH_RECONNECT_EVT:
1749 bta_hl_api_dch_reconnect(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1750 break;
1751
1752 case BTA_HL_API_DCH_ECHO_TEST_EVT:
1753 bta_hl_api_dch_echo_test(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1754 break;
1755
1756 case BTA_HL_API_SDP_QUERY_EVT:
1757 bta_hl_api_sdp_query(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1758 break;
1759
1760 case BTA_HL_MCA_DELETE_CFM_EVT:
1761 bta_hl_mca_delete_mdl_cfm(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1762 break;
1763
1764 case BTA_HL_MCA_DELETE_IND_EVT:
1765 bta_hl_mca_delete_mdl_ind(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1766 break;
1767
1768 case BTA_HL_SDP_QUERY_OK_EVT:
1769 case BTA_HL_SDP_QUERY_FAIL_EVT:
1770 bta_hl_sdp_query_results(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1771 break;
1772 case BTA_HL_API_DCH_ABORT_EVT:
1773 bta_hl_api_dch_abort(&bta_hl_cb, (tBTA_HL_DATA*)p_msg);
1774 break;
1775
1776 default:
1777 if (p_msg->event < BTA_HL_DCH_EVT_MIN) {
1778 if (bta_hl_find_cch_cb_indexes((tBTA_HL_DATA*)p_msg, &app_idx,
1779 &mcl_idx)) {
1780 bta_hl_cch_sm_execute(app_idx, mcl_idx, p_msg->event,
1781 (tBTA_HL_DATA*)p_msg);
1782 } else {
1783 #if (BTA_HL_DEBUG == TRUE)
1784 APPL_TRACE_ERROR(
1785 "unable to find control block indexes for CCH: [event=%s]",
1786 bta_hl_evt_code(p_msg->event));
1787 #else
1788 APPL_TRACE_ERROR(
1789 "unable to find control block indexes for CCH: [event=%d]",
1790 p_msg->event);
1791 #endif
1792 success = false;
1793 }
1794 } else {
1795 if (bta_hl_find_dch_cb_indexes((tBTA_HL_DATA*)p_msg, &app_idx, &mcl_idx,
1796 &mdl_idx)) {
1797 bta_hl_dch_sm_execute(app_idx, mcl_idx, mdl_idx, p_msg->event,
1798 (tBTA_HL_DATA*)p_msg);
1799 } else {
1800 #if (BTA_HL_DEBUG == TRUE)
1801 APPL_TRACE_ERROR(
1802 "unable to find control block indexes for DCH : [event=%s]",
1803 bta_hl_evt_code(p_msg->event));
1804 #else
1805 APPL_TRACE_ERROR(
1806 "unable to find control block indexes for DCH: [event=%d]",
1807 p_msg->event);
1808 #endif
1809 success = false;
1810 }
1811 }
1812
1813 break;
1814 }
1815
1816 return (success);
1817 }
1818
1819 /*****************************************************************************
1820 * Debug Functions
1821 ****************************************************************************/
1822 #if (BTA_HL_DEBUG == TRUE)
1823
1824 /*******************************************************************************
1825 *
1826 * Function bta_hl_cch_state_code
1827 *
1828 * Description Map CCH state code to the corresponding state string
1829 *
1830 * Returns string pointer for the associated state name
1831 *
1832 ******************************************************************************/
bta_hl_cch_state_code(tBTA_HL_CCH_STATE state_code)1833 static const char* bta_hl_cch_state_code(tBTA_HL_CCH_STATE state_code) {
1834 switch (state_code) {
1835 case BTA_HL_CCH_IDLE_ST:
1836 return "BTA_HL_CCH_IDLE_ST";
1837 case BTA_HL_CCH_OPENING_ST:
1838 return "BTA_HL_CCH_OPENING_ST";
1839 case BTA_HL_CCH_OPEN_ST:
1840 return "BTA_HL_CCH_OPEN_ST";
1841 case BTA_HL_CCH_CLOSING_ST:
1842 return "BTA_HL_CCH_CLOSING_ST";
1843 default:
1844 return "Unknown CCH state code";
1845 }
1846 }
1847
1848 /*******************************************************************************
1849 *
1850 * Function bta_hl_dch_state_code
1851 *
1852 * Description Map DCH state code to the corresponding state string
1853 *
1854 * Returns string pointer for the associated state name
1855 *
1856 ******************************************************************************/
bta_hl_dch_state_code(tBTA_HL_DCH_STATE state_code)1857 static const char* bta_hl_dch_state_code(tBTA_HL_DCH_STATE state_code) {
1858 switch (state_code) {
1859 case BTA_HL_DCH_IDLE_ST:
1860 return "BTA_HL_DCH_IDLE_ST";
1861 case BTA_HL_DCH_OPENING_ST:
1862 return "BTA_HL_DCH_OPENING_ST";
1863 case BTA_HL_DCH_OPEN_ST:
1864 return "BTA_HL_DCH_OPEN_ST";
1865 case BTA_HL_DCH_CLOSING_ST:
1866 return "BTA_HL_DCH_CLOSING_ST";
1867 default:
1868 return "Unknown DCH state code";
1869 }
1870 }
1871 #endif /* Debug Functions */
1872 #endif /* HL_INCLUDED */
1873