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