1 /******************************************************************************
2 *
3 * Copyright (C) 2009-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 is the implementation file for the MCAP Control channel state
22 * machine.
23 *
24 ******************************************************************************/
25 #include <string.h>
26
27 #include "bt_target.h"
28 #include "mca_api.h"
29 #include "mca_defs.h"
30 #include "mca_int.h"
31 #include "btu.h"
32
33 /*****************************************************************************
34 ** data channel state machine constants and types
35 *****************************************************************************/
36 enum
37 {
38 MCA_CCB_FREE_MSG,
39 MCA_CCB_SND_REQ,
40 MCA_CCB_SND_RSP,
41 MCA_CCB_DO_DISCONN,
42 MCA_CCB_CONG,
43 MCA_CCB_HDL_REQ,
44 MCA_CCB_HDL_RSP,
45 MCA_CCB_LL_OPEN,
46 MCA_CCB_DL_OPEN,
47 MCA_CCB_DEALLOC,
48 MCA_CCB_RSP_TOUT,
49 MCA_CCB_NUM_ACTIONS
50 };
51 #define MCA_CCB_IGNORE MCA_CCB_NUM_ACTIONS
52
53 /* action function list */
54 const tMCA_CCB_ACTION mca_ccb_action[] = {
55 mca_ccb_free_msg,
56 mca_ccb_snd_req,
57 mca_ccb_snd_rsp,
58 mca_ccb_do_disconn,
59 mca_ccb_cong,
60 mca_ccb_hdl_req,
61 mca_ccb_hdl_rsp,
62 mca_ccb_ll_open,
63 mca_ccb_dl_open,
64 mca_ccb_dealloc,
65 mca_ccb_rsp_tout,
66 };
67
68 /* state table information */
69 #define MCA_CCB_ACTIONS 1 /* number of actions */
70 #define MCA_CCB_ACT_COL 0 /* position of action function */
71 #define MCA_CCB_NEXT_STATE 1 /* position of next state */
72 #define MCA_CCB_NUM_COLS 2 /* number of columns in state tables */
73
74 /* state table for opening state */
75 const UINT8 mca_ccb_st_opening[][MCA_CCB_NUM_COLS] = {
76 /* Event Action Next State */
77 /* MCA_CCB_API_CONNECT_EVT */ {MCA_CCB_IGNORE, MCA_CCB_OPENING_ST},
78 /* MCA_CCB_API_DISCONNECT_EVT */ {MCA_CCB_DO_DISCONN, MCA_CCB_CLOSING_ST},
79 /* MCA_CCB_API_REQ_EVT */ {MCA_CCB_FREE_MSG, MCA_CCB_OPENING_ST},
80 /* MCA_CCB_API_RSP_EVT */ {MCA_CCB_IGNORE, MCA_CCB_OPENING_ST},
81 /* MCA_CCB_MSG_REQ_EVT */ {MCA_CCB_FREE_MSG, MCA_CCB_OPENING_ST},
82 /* MCA_CCB_MSG_RSP_EVT */ {MCA_CCB_FREE_MSG, MCA_CCB_OPENING_ST},
83 /* MCA_CCB_DL_OPEN_EVT */ {MCA_CCB_IGNORE, MCA_CCB_OPENING_ST},
84 /* MCA_CCB_LL_OPEN_EVT */ {MCA_CCB_LL_OPEN, MCA_CCB_OPEN_ST},
85 /* MCA_CCB_LL_CLOSE_EVT */ {MCA_CCB_DEALLOC, MCA_CCB_NULL_ST},
86 /* MCA_CCB_LL_CONG_EVT */ {MCA_CCB_CONG, MCA_CCB_OPENING_ST},
87 /* MCA_CCB_RSP_TOUT_EVT */ {MCA_CCB_IGNORE, MCA_CCB_OPENING_ST}
88 };
89
90 /* state table for open state */
91 const UINT8 mca_ccb_st_open[][MCA_CCB_NUM_COLS] = {
92 /* Event Action Next State */
93 /* MCA_CCB_API_CONNECT_EVT */ {MCA_CCB_IGNORE, MCA_CCB_OPEN_ST},
94 /* MCA_CCB_API_DISCONNECT_EVT */ {MCA_CCB_DO_DISCONN, MCA_CCB_CLOSING_ST},
95 /* MCA_CCB_API_REQ_EVT */ {MCA_CCB_SND_REQ, MCA_CCB_OPEN_ST},
96 /* MCA_CCB_API_RSP_EVT */ {MCA_CCB_SND_RSP, MCA_CCB_OPEN_ST},
97 /* MCA_CCB_MSG_REQ_EVT */ {MCA_CCB_HDL_REQ, MCA_CCB_OPEN_ST},
98 /* MCA_CCB_MSG_RSP_EVT */ {MCA_CCB_HDL_RSP, MCA_CCB_OPEN_ST},
99 /* MCA_CCB_DL_OPEN_EVT */ {MCA_CCB_DL_OPEN, MCA_CCB_OPEN_ST},
100 /* MCA_CCB_LL_OPEN_EVT */ {MCA_CCB_IGNORE, MCA_CCB_OPEN_ST},
101 /* MCA_CCB_LL_CLOSE_EVT */ {MCA_CCB_DEALLOC, MCA_CCB_NULL_ST},
102 /* MCA_CCB_LL_CONG_EVT */ {MCA_CCB_CONG, MCA_CCB_OPEN_ST},
103 /* MCA_CCB_RSP_TOUT_EVT */ {MCA_CCB_RSP_TOUT, MCA_CCB_OPEN_ST}
104 };
105
106 /* state table for closing state */
107 const UINT8 mca_ccb_st_closing[][MCA_CCB_NUM_COLS] = {
108 /* Event Action Next State */
109 /* MCA_CCB_API_CONNECT_EVT */ {MCA_CCB_IGNORE, MCA_CCB_CLOSING_ST},
110 /* MCA_CCB_API_DISCONNECT_EVT */ {MCA_CCB_IGNORE, MCA_CCB_CLOSING_ST},
111 /* MCA_CCB_API_REQ_EVT */ {MCA_CCB_FREE_MSG, MCA_CCB_CLOSING_ST},
112 /* MCA_CCB_API_RSP_EVT */ {MCA_CCB_IGNORE, MCA_CCB_CLOSING_ST},
113 /* MCA_CCB_MSG_REQ_EVT */ {MCA_CCB_FREE_MSG, MCA_CCB_CLOSING_ST},
114 /* MCA_CCB_MSG_RSP_EVT */ {MCA_CCB_FREE_MSG, MCA_CCB_CLOSING_ST},
115 /* MCA_CCB_DL_OPEN_EVT */ {MCA_CCB_IGNORE, MCA_CCB_CLOSING_ST},
116 /* MCA_CCB_LL_OPEN_EVT */ {MCA_CCB_IGNORE, MCA_CCB_CLOSING_ST},
117 /* MCA_CCB_LL_CLOSE_EVT */ {MCA_CCB_DEALLOC, MCA_CCB_NULL_ST},
118 /* MCA_CCB_LL_CONG_EVT */ {MCA_CCB_IGNORE, MCA_CCB_CLOSING_ST},
119 /* MCA_CCB_RSP_TOUT_EVT */ {MCA_CCB_IGNORE, MCA_CCB_CLOSING_ST}
120 };
121
122 /* type for state table */
123 typedef const UINT8 (*tMCA_CCB_ST_TBL)[MCA_CCB_NUM_COLS];
124
125 /* state table */
126 const tMCA_CCB_ST_TBL mca_ccb_st_tbl[] = {
127 mca_ccb_st_opening,
128 mca_ccb_st_open,
129 mca_ccb_st_closing
130 };
131
132 #if (BT_TRACE_VERBOSE == TRUE)
133 /* verbose event strings for trace */
134 static const char * const mca_ccb_evt_str[] = {
135 "API_CONNECT_EVT",
136 "API_DISCONNECT_EVT",
137 "API_REQ_EVT",
138 "API_RSP_EVT",
139 "MSG_REQ_EVT",
140 "MSG_RSP_EVT",
141 "DL_OPEN_EVT",
142 "LL_OPEN_EVT",
143 "LL_CLOSE_EVT",
144 "LL_CONG_EVT",
145 "RSP_TOUT_EVT"
146 };
147 /* verbose state strings for trace */
148 static const char * const mca_ccb_st_str[] = {
149 "NULL_ST",
150 "OPENING_ST",
151 "OPEN_ST",
152 "CLOSING_ST"
153 };
154 #endif
155
156 /*******************************************************************************
157 **
158 ** Function mca_stop_timer
159 **
160 ** Description This function is stop a MCAP timer
161 **
162 ** This function is for use internal to MCAP only.
163 **
164 ** Returns void
165 **
166 *******************************************************************************/
mca_stop_timer(tMCA_CCB * p_ccb)167 void mca_stop_timer(tMCA_CCB *p_ccb)
168 {
169 alarm_cancel(p_ccb->mca_ccb_timer);
170 }
171
172 /*******************************************************************************
173 **
174 ** Function mca_ccb_event
175 **
176 ** Description This function is the CCB state machine main function.
177 ** It uses the state and action function tables to execute
178 ** action functions.
179 **
180 ** Returns void.
181 **
182 *******************************************************************************/
mca_ccb_event(tMCA_CCB * p_ccb,UINT8 event,tMCA_CCB_EVT * p_data)183 void mca_ccb_event(tMCA_CCB *p_ccb, UINT8 event, tMCA_CCB_EVT *p_data)
184 {
185 tMCA_CCB_ST_TBL state_table;
186 UINT8 action;
187
188 #if (BT_TRACE_VERBOSE == TRUE)
189 MCA_TRACE_EVENT("CCB ccb=%d event=%s state=%s", mca_ccb_to_hdl(p_ccb), mca_ccb_evt_str[event], mca_ccb_st_str[p_ccb->state]);
190 #else
191 MCA_TRACE_EVENT("CCB ccb=%d event=%d state=%d", mca_ccb_to_hdl(p_ccb), event, p_ccb->state);
192 #endif
193
194 /* look up the state table for the current state */
195 state_table = mca_ccb_st_tbl[p_ccb->state - 1];
196
197 /* set next state */
198 p_ccb->state = state_table[event][MCA_CCB_NEXT_STATE];
199
200 /* execute action functions */
201 if ((action = state_table[event][MCA_CCB_ACT_COL]) != MCA_CCB_IGNORE)
202 {
203 (*mca_ccb_action[action])(p_ccb, p_data);
204 }
205 }
206
207 /*******************************************************************************
208 **
209 ** Function mca_ccb_by_bd
210 **
211 ** Description This function looks up the CCB based on the BD address.
212 ** It returns a pointer to the CCB.
213 ** If no CCB is found it returns NULL.
214 **
215 ** Returns void.
216 **
217 *******************************************************************************/
mca_ccb_by_bd(tMCA_HANDLE handle,BD_ADDR bd_addr)218 tMCA_CCB *mca_ccb_by_bd(tMCA_HANDLE handle, BD_ADDR bd_addr)
219 {
220 tMCA_CCB *p_ccb = NULL;
221 tMCA_RCB *p_rcb = mca_rcb_by_handle(handle);
222 tMCA_CCB *p_ccb_tmp;
223 int i;
224
225 if (p_rcb)
226 {
227 i = handle-1;
228 p_ccb_tmp = &mca_cb.ccb[i*MCA_NUM_LINKS];
229 for (i=0; i<MCA_NUM_LINKS; i++, p_ccb_tmp++)
230 {
231 if (p_ccb_tmp->state != MCA_CCB_NULL_ST && memcmp(p_ccb_tmp->peer_addr, bd_addr, BD_ADDR_LEN) == 0)
232 {
233 p_ccb = p_ccb_tmp;
234 break;
235 }
236 }
237 }
238 return p_ccb;
239 }
240
241 /*******************************************************************************
242 **
243 ** Function mca_ccb_alloc
244 **
245 ** Description This function allocates a CCB and copies the BD address to
246 ** the CCB. It returns a pointer to the CCB. If no CCB can
247 ** be allocated it returns NULL.
248 **
249 ** Returns void.
250 **
251 *******************************************************************************/
mca_ccb_alloc(tMCA_HANDLE handle,BD_ADDR bd_addr)252 tMCA_CCB *mca_ccb_alloc(tMCA_HANDLE handle, BD_ADDR bd_addr)
253 {
254 tMCA_CCB *p_ccb = NULL;
255 tMCA_RCB *p_rcb = mca_rcb_by_handle(handle);
256 tMCA_CCB *p_ccb_tmp;
257 int i;
258
259 MCA_TRACE_DEBUG("mca_ccb_alloc handle:0x%x", handle);
260 if (p_rcb)
261 {
262 i = handle-1;
263 p_ccb_tmp = &mca_cb.ccb[i*MCA_NUM_LINKS];
264 for (i=0; i<MCA_NUM_LINKS; i++, p_ccb_tmp++)
265 {
266 if (p_ccb_tmp->state == MCA_CCB_NULL_ST)
267 {
268 p_ccb_tmp->p_rcb = p_rcb;
269 p_ccb_tmp->mca_ccb_timer = alarm_new("mca.mca_ccb_timer");
270 p_ccb_tmp->state = MCA_CCB_OPENING_ST;
271 p_ccb_tmp->cong = TRUE;
272 memcpy(p_ccb_tmp->peer_addr, bd_addr, BD_ADDR_LEN);
273 p_ccb = p_ccb_tmp;
274 break;
275 }
276 }
277 }
278 return p_ccb;
279 }
280
281
282 /*******************************************************************************
283 **
284 ** Function mca_ccb_dealloc
285 **
286 ** Description This function deallocates a CCB.
287 **
288 ** Returns void.
289 **
290 *******************************************************************************/
mca_ccb_dealloc(tMCA_CCB * p_ccb,tMCA_CCB_EVT * p_data)291 void mca_ccb_dealloc(tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data)
292 {
293 tMCA_CTRL evt_data;
294
295 MCA_TRACE_DEBUG("mca_ccb_dealloc ctrl_vpsm:0x%x", p_ccb->ctrl_vpsm);
296 mca_dcb_close_by_mdl_id (p_ccb, MCA_ALL_MDL_ID);
297 if (p_ccb->ctrl_vpsm)
298 {
299 L2CA_Deregister (p_ccb->ctrl_vpsm);
300 }
301 if (p_ccb->data_vpsm)
302 {
303 L2CA_Deregister (p_ccb->data_vpsm);
304 }
305 osi_free_and_reset((void **)&p_ccb->p_rx_msg);
306 osi_free_and_reset((void **)&p_ccb->p_tx_req);
307 mca_stop_timer(p_ccb);
308
309 if (p_data)
310 {
311 /* non-NULL -> an action function -> report disconnect event */
312 memcpy (evt_data.disconnect_ind.bd_addr, p_ccb->peer_addr, BD_ADDR_LEN);
313 evt_data.disconnect_ind.reason = p_data->close.reason;
314 mca_ccb_report_event(p_ccb, MCA_DISCONNECT_IND_EVT, &evt_data);
315 }
316 mca_free_tc_tbl_by_lcid (p_ccb->lcid);
317 alarm_free(p_ccb->mca_ccb_timer);
318 memset(p_ccb, 0, sizeof(tMCA_CCB));
319 }
320
321 /*******************************************************************************
322 **
323 ** Function mca_ccb_to_hdl
324 **
325 ** Description This function converts a pointer to a CCB to a tMCA_CL
326 ** and returns the value.
327 **
328 ** Returns void.
329 **
330 *******************************************************************************/
mca_ccb_to_hdl(tMCA_CCB * p_ccb)331 tMCA_CL mca_ccb_to_hdl(tMCA_CCB *p_ccb)
332 {
333 return (UINT8) (p_ccb - mca_cb.ccb + 1);
334 }
335
336 /*******************************************************************************
337 **
338 ** Function mca_ccb_by_hdl
339 **
340 ** Description This function converts an index value to a CCB. It returns
341 ** a pointer to the CCB. If no valid CCB matches the index it
342 ** returns NULL.
343 **
344 ** Returns void.
345 **
346 *******************************************************************************/
mca_ccb_by_hdl(tMCA_CL mcl)347 tMCA_CCB *mca_ccb_by_hdl(tMCA_CL mcl)
348 {
349 tMCA_CCB * p_ccb = NULL;
350 if (mcl && mcl <= MCA_NUM_CCBS && mca_cb.ccb[mcl-1].state)
351 p_ccb = &mca_cb.ccb[mcl-1];
352 return p_ccb;
353 }
354
355
356 /*******************************************************************************
357 **
358 ** Function mca_ccb_uses_mdl_id
359 **
360 ** Description This function checkes if a given mdl_id is in use.
361 **
362 ** Returns TRUE, if the given mdl_id is currently used in the MCL.
363 **
364 *******************************************************************************/
mca_ccb_uses_mdl_id(tMCA_CCB * p_ccb,UINT16 mdl_id)365 BOOLEAN mca_ccb_uses_mdl_id(tMCA_CCB *p_ccb, UINT16 mdl_id)
366 {
367 BOOLEAN uses = FALSE;
368 tMCA_DCB *p_dcb;
369 int i;
370
371 i = mca_ccb_to_hdl(p_ccb)-1;
372 p_dcb = &mca_cb.dcb[i*MCA_NUM_MDLS];
373 for (i=0; i<MCA_NUM_MDLS; i++, p_dcb++)
374 {
375 if (p_dcb->state != MCA_DCB_NULL_ST && p_dcb->mdl_id == mdl_id)
376 {
377 uses = TRUE;
378 break;
379 }
380 }
381
382 return uses;
383 }
384