1 /******************************************************************************
2 *
3 * Copyright (C) 2003-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 module contains the link control state machine and functions which
22 * operate on the link control block.
23 *
24 ******************************************************************************/
25
26 #include <string.h>
27 #include "avct_api.h"
28 #include "avct_int.h"
29 #include "bt_common.h"
30 #include "bt_target.h"
31 #include "bt_types.h"
32 #include "bt_utils.h"
33 #include "osi/include/osi.h"
34
35 /*****************************************************************************
36 * state machine constants and types
37 ****************************************************************************/
38
39 /* verbose state strings for trace */
40 const char* const avct_lcb_st_str[] = {"LCB_IDLE_ST", "LCB_OPENING_ST",
41 "LCB_OPEN_ST", "LCB_CLOSING_ST"};
42
43 /* verbose event strings for trace */
44 const char* const avct_lcb_evt_str[] = {
45 "UL_BIND_EVT", "UL_UNBIND_EVT", "UL_MSG_EVT", "INT_CLOSE_EVT",
46 "LL_OPEN_EVT", "LL_CLOSE_EVT", "LL_MSG_EVT", "LL_CONG_EVT"};
47
48 /* lcb state machine states */
49 enum {
50 AVCT_LCB_IDLE_ST,
51 AVCT_LCB_OPENING_ST,
52 AVCT_LCB_OPEN_ST,
53 AVCT_LCB_CLOSING_ST
54 };
55
56 /* state machine action enumeration list */
57 enum {
58 AVCT_LCB_CHNL_OPEN,
59 AVCT_LCB_CHNL_DISC,
60 AVCT_LCB_SEND_MSG,
61 AVCT_LCB_OPEN_IND,
62 AVCT_LCB_OPEN_FAIL,
63 AVCT_LCB_CLOSE_IND,
64 AVCT_LCB_CLOSE_CFM,
65 AVCT_LCB_MSG_IND,
66 AVCT_LCB_CONG_IND,
67 AVCT_LCB_BIND_CONN,
68 AVCT_LCB_BIND_FAIL,
69 AVCT_LCB_UNBIND_DISC,
70 AVCT_LCB_CHK_DISC,
71 AVCT_LCB_DISCARD_MSG,
72 AVCT_LCB_DEALLOC,
73 AVCT_LCB_FREE_MSG_IND,
74 AVCT_LCB_NUM_ACTIONS
75 };
76
77 #define AVCT_LCB_IGNORE AVCT_LCB_NUM_ACTIONS
78
79 /* type for action functions */
80 typedef void (*tAVCT_LCB_ACTION)(tAVCT_LCB* p_ccb, tAVCT_LCB_EVT* p_data);
81
82 /* action function list */
83 const tAVCT_LCB_ACTION avct_lcb_action[] = {
84 avct_lcb_chnl_open, avct_lcb_chnl_disc, avct_lcb_send_msg,
85 avct_lcb_open_ind, avct_lcb_open_fail, avct_lcb_close_ind,
86 avct_lcb_close_cfm, avct_lcb_msg_ind, avct_lcb_cong_ind,
87 avct_lcb_bind_conn, avct_lcb_bind_fail, avct_lcb_unbind_disc,
88 avct_lcb_chk_disc, avct_lcb_discard_msg, avct_lcb_dealloc,
89 avct_lcb_free_msg_ind};
90
91 /* state table information */
92 #define AVCT_LCB_ACTIONS 2 /* number of actions */
93 #define AVCT_LCB_NEXT_STATE 2 /* position of next state */
94 #define AVCT_LCB_NUM_COLS 3 /* number of columns in state tables */
95
96 /* state table for idle state */
97 const uint8_t avct_lcb_st_idle[][AVCT_LCB_NUM_COLS] = {
98 /* Event Action 1 Action 2 Next state */
99 /* UL_BIND */ {AVCT_LCB_CHNL_OPEN, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
100 /* UL_UNBIND */ {AVCT_LCB_UNBIND_DISC, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
101 /* UL_MSG */ {AVCT_LCB_DISCARD_MSG, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
102 /* INT_CLOSE */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
103 /* LL_OPEN */ {AVCT_LCB_OPEN_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
104 /* LL_CLOSE */ {AVCT_LCB_CLOSE_IND, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
105 /* LL_MSG */ {AVCT_LCB_FREE_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST},
106 /* LL_CONG */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_IDLE_ST}};
107
108 /* state table for opening state */
109 const uint8_t avct_lcb_st_opening[][AVCT_LCB_NUM_COLS] = {
110 /* Event Action 1 Action 2 Next state */
111 /* UL_BIND */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
112 /* UL_UNBIND */ {AVCT_LCB_UNBIND_DISC, AVCT_LCB_IGNORE,
113 AVCT_LCB_OPENING_ST},
114 /* UL_MSG */ {AVCT_LCB_DISCARD_MSG, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
115 /* INT_CLOSE */ {AVCT_LCB_CHNL_DISC, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
116 /* LL_OPEN */ {AVCT_LCB_OPEN_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
117 /* LL_CLOSE */ {AVCT_LCB_OPEN_FAIL, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
118 /* LL_MSG */ {AVCT_LCB_FREE_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST},
119 /* LL_CONG */ {AVCT_LCB_CONG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPENING_ST}};
120
121 /* state table for open state */
122 const uint8_t avct_lcb_st_open[][AVCT_LCB_NUM_COLS] = {
123 /* Event Action 1 Action 2 Next state */
124 /* UL_BIND */ {AVCT_LCB_BIND_CONN, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
125 /* UL_UNBIND */ {AVCT_LCB_CHK_DISC, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
126 /* UL_MSG */ {AVCT_LCB_SEND_MSG, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
127 /* INT_CLOSE */ {AVCT_LCB_CHNL_DISC, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
128 /* LL_OPEN */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
129 /* LL_CLOSE */ {AVCT_LCB_CLOSE_IND, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
130 /* LL_MSG */ {AVCT_LCB_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST},
131 /* LL_CONG */ {AVCT_LCB_CONG_IND, AVCT_LCB_IGNORE, AVCT_LCB_OPEN_ST}};
132
133 /* state table for closing state */
134 const uint8_t avct_lcb_st_closing[][AVCT_LCB_NUM_COLS] = {
135 /* Event Action 1 Action 2 Next state */
136 /* UL_BIND */ {AVCT_LCB_BIND_FAIL, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
137 /* UL_UNBIND */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
138 /* UL_MSG */ {AVCT_LCB_DISCARD_MSG, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
139 /* INT_CLOSE */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
140 /* LL_OPEN */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
141 /* LL_CLOSE */ {AVCT_LCB_CLOSE_CFM, AVCT_LCB_DEALLOC, AVCT_LCB_IDLE_ST},
142 /* LL_MSG */ {AVCT_LCB_FREE_MSG_IND, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST},
143 /* LL_CONG */ {AVCT_LCB_IGNORE, AVCT_LCB_IGNORE, AVCT_LCB_CLOSING_ST}};
144
145 /* type for state table */
146 typedef const uint8_t (*tAVCT_LCB_ST_TBL)[AVCT_LCB_NUM_COLS];
147
148 /* state table */
149 const tAVCT_LCB_ST_TBL avct_lcb_st_tbl[] = {
150 avct_lcb_st_idle, avct_lcb_st_opening, avct_lcb_st_open,
151 avct_lcb_st_closing};
152
153 /*******************************************************************************
154 *
155 * Function avct_lcb_event
156 *
157 * Description State machine event handling function for lcb
158 *
159 *
160 * Returns Nothing.
161 *
162 ******************************************************************************/
avct_lcb_event(tAVCT_LCB * p_lcb,uint8_t event,tAVCT_LCB_EVT * p_data)163 void avct_lcb_event(tAVCT_LCB* p_lcb, uint8_t event, tAVCT_LCB_EVT* p_data) {
164 tAVCT_LCB_ST_TBL state_table;
165 uint8_t action;
166 int i;
167
168 AVCT_TRACE_EVENT("LCB lcb=%d event=%s state=%s", p_lcb->allocated,
169 avct_lcb_evt_str[event], avct_lcb_st_str[p_lcb->state]);
170
171 /* look up the state table for the current state */
172 state_table = avct_lcb_st_tbl[p_lcb->state];
173
174 /* set next state */
175 p_lcb->state = state_table[event][AVCT_LCB_NEXT_STATE];
176
177 /* execute action functions */
178 for (i = 0; i < AVCT_LCB_ACTIONS; i++) {
179 action = state_table[event][i];
180 if (action != AVCT_LCB_IGNORE) {
181 (*avct_lcb_action[action])(p_lcb, p_data);
182 } else {
183 break;
184 }
185 }
186 }
187
188 /*******************************************************************************
189 *
190 * Function avct_bcb_event
191 *
192 * Description State machine event handling function for lcb
193 *
194 *
195 * Returns Nothing.
196 *
197 ******************************************************************************/
avct_bcb_event(tAVCT_BCB * p_bcb,uint8_t event,tAVCT_LCB_EVT * p_data)198 void avct_bcb_event(tAVCT_BCB* p_bcb, uint8_t event, tAVCT_LCB_EVT* p_data) {
199 tAVCT_LCB_ST_TBL state_table;
200 uint8_t action;
201 int i;
202
203 AVCT_TRACE_EVENT("BCB lcb=%d event=%s state=%s", p_bcb->allocated,
204 avct_lcb_evt_str[event], avct_lcb_st_str[p_bcb->state]);
205
206 /* look up the state table for the current state */
207 state_table = avct_lcb_st_tbl[p_bcb->state];
208
209 /* set next state */
210 p_bcb->state = state_table[event][AVCT_LCB_NEXT_STATE];
211
212 /* execute action functions */
213 for (i = 0; i < AVCT_LCB_ACTIONS; i++) {
214 action = state_table[event][i];
215 if (action != AVCT_LCB_IGNORE) {
216 (*avct_bcb_action[action])(p_bcb, p_data);
217 } else {
218 break;
219 }
220 }
221 }
222
223 /*******************************************************************************
224 *
225 * Function avct_lcb_by_bd
226 *
227 * Description This lookup function finds the lcb for a BD address.
228 *
229 *
230 * Returns pointer to the lcb, or NULL if none found.
231 *
232 ******************************************************************************/
avct_lcb_by_bd(BD_ADDR bd_addr)233 tAVCT_LCB* avct_lcb_by_bd(BD_ADDR bd_addr) {
234 tAVCT_LCB* p_lcb = &avct_cb.lcb[0];
235 int i;
236
237 for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++) {
238 /* if allocated lcb has matching lcb */
239 if (p_lcb->allocated && (!memcmp(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN))) {
240 break;
241 }
242 }
243
244 if (i == AVCT_NUM_LINKS) {
245 /* if no lcb found */
246 p_lcb = NULL;
247
248 AVCT_TRACE_DEBUG("No lcb for addr %02x-%02x-%02x-%02x-%02x-%02x",
249 bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4],
250 bd_addr[5]);
251 }
252 return p_lcb;
253 }
254
255 /*******************************************************************************
256 *
257 * Function avct_lcb_alloc
258 *
259 * Description Allocate a link control block.
260 *
261 *
262 * Returns pointer to the lcb, or NULL if none could be allocated.
263 *
264 ******************************************************************************/
avct_lcb_alloc(BD_ADDR bd_addr)265 tAVCT_LCB* avct_lcb_alloc(BD_ADDR bd_addr) {
266 tAVCT_LCB* p_lcb = &avct_cb.lcb[0];
267 int i;
268
269 for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++) {
270 if (!p_lcb->allocated) {
271 p_lcb->allocated = (uint8_t)(i + 1);
272 memcpy(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN);
273 AVCT_TRACE_DEBUG("avct_lcb_alloc %d", p_lcb->allocated);
274 p_lcb->tx_q = fixed_queue_new(SIZE_MAX);
275 break;
276 }
277 }
278
279 if (i == AVCT_NUM_LINKS) {
280 /* out of lcbs */
281 p_lcb = NULL;
282 AVCT_TRACE_WARNING("Out of lcbs");
283 }
284 return p_lcb;
285 }
286
287 /*******************************************************************************
288 *
289 * Function avct_lcb_dealloc
290 *
291 * Description Deallocate a link control block.
292 *
293 *
294 * Returns void.
295 *
296 ******************************************************************************/
avct_lcb_dealloc(tAVCT_LCB * p_lcb,UNUSED_ATTR tAVCT_LCB_EVT * p_data)297 void avct_lcb_dealloc(tAVCT_LCB* p_lcb, UNUSED_ATTR tAVCT_LCB_EVT* p_data) {
298 AVCT_TRACE_DEBUG("%s allocated: %d", __func__, p_lcb->allocated);
299
300 // Check if the LCB is still referenced
301
302 tAVCT_CCB* p_ccb = &avct_cb.ccb[0];
303 for (size_t i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
304 if (p_ccb->allocated && p_ccb->p_lcb == p_lcb) {
305 AVCT_TRACE_DEBUG("%s LCB in use; lcb index: %d", __func__, i);
306 return;
307 }
308 }
309
310 // If not, de-allocate now...
311
312 AVCT_TRACE_DEBUG("%s Freeing LCB", __func__);
313 osi_free(p_lcb->p_rx_msg);
314 fixed_queue_free(p_lcb->tx_q, NULL);
315 memset(p_lcb, 0, sizeof(tAVCT_LCB));
316 }
317
318 /*******************************************************************************
319 *
320 * Function avct_lcb_by_lcid
321 *
322 * Description Find the LCB associated with the L2CAP LCID
323 *
324 *
325 * Returns pointer to the lcb, or NULL if none found.
326 *
327 ******************************************************************************/
avct_lcb_by_lcid(uint16_t lcid)328 tAVCT_LCB* avct_lcb_by_lcid(uint16_t lcid) {
329 tAVCT_LCB* p_lcb = &avct_cb.lcb[0];
330 int i;
331
332 for (i = 0; i < AVCT_NUM_LINKS; i++, p_lcb++) {
333 if (p_lcb->allocated &&
334 ((p_lcb->ch_lcid == lcid) || (p_lcb->conflict_lcid == lcid))) {
335 break;
336 }
337 }
338
339 if (i == AVCT_NUM_LINKS) {
340 /* out of lcbs */
341 p_lcb = NULL;
342 AVCT_TRACE_WARNING("No lcb for lcid %x", lcid);
343 }
344
345 return p_lcb;
346 }
347
348 /*******************************************************************************
349 *
350 * Function avct_lcb_has_pid
351 *
352 * Description See if any ccbs on this lcb have a particular pid.
353 *
354 *
355 * Returns Pointer to CCB if PID found, NULL otherwise.
356 *
357 ******************************************************************************/
avct_lcb_has_pid(tAVCT_LCB * p_lcb,uint16_t pid)358 tAVCT_CCB* avct_lcb_has_pid(tAVCT_LCB* p_lcb, uint16_t pid) {
359 tAVCT_CCB* p_ccb = &avct_cb.ccb[0];
360 int i;
361
362 for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
363 if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb->cc.pid == pid)) {
364 return p_ccb;
365 }
366 }
367 return NULL;
368 }
369
370 /*******************************************************************************
371 *
372 * Function avct_lcb_last_ccb
373 *
374 * Description See if given ccb is only one on the lcb.
375 *
376 *
377 * Returns true if ccb is last, false otherwise.
378 *
379 ******************************************************************************/
avct_lcb_last_ccb(tAVCT_LCB * p_lcb,tAVCT_CCB * p_ccb_last)380 bool avct_lcb_last_ccb(tAVCT_LCB* p_lcb, tAVCT_CCB* p_ccb_last) {
381 tAVCT_CCB* p_ccb = &avct_cb.ccb[0];
382 int i;
383
384 AVCT_TRACE_WARNING("avct_lcb_last_ccb");
385 for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++) {
386 AVCT_TRACE_WARNING("%x: aloc:%d, lcb:0x%x/0x%x, ccb:0x%x/0x%x", i,
387 p_ccb->allocated, p_ccb->p_lcb, p_lcb, p_ccb,
388 p_ccb_last);
389 if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb != p_ccb_last)) {
390 return false;
391 }
392 }
393 return true;
394 }
395