1 /******************************************************************************
2 *
3 * Copyright (C) 1999-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 state machine and action routines for multiplexer
22 * channel of the RFCOMM unit
23 *
24 ******************************************************************************/
25 #include <string.h>
26 #include "stack/bt_types.h"
27 #include "stack/rfcdefs.h"
28 #include "stack/l2cdefs.h"
29 #include "stack/port_api.h"
30 #include "port_int.h"
31 #include "stack/l2c_api.h"
32 #include "rfc_int.h"
33 #include "common/bt_defs.h"
34 #include "osi/allocator.h"
35 #include "osi/mutex.h"
36 #include "common/bt_target.h"
37 #if (defined RFCOMM_INCLUDED && RFCOMM_INCLUDED == TRUE)
38
39 #define L2CAP_SUCCESS 0
40 #define L2CAP_ERROR 1
41
42 static tL2CAP_ERTM_INFO rfc_l2c_etm_opt =
43 {
44 L2CAP_FCR_ERTM_MODE,
45 L2CAP_FCR_CHAN_OPT_ERTM|L2CAP_FCR_CHAN_OPT_BASIC, /* Some devices do not support ERTM */
46 L2CAP_USER_RX_BUF_SIZE,
47 L2CAP_USER_TX_BUF_SIZE,
48 L2CAP_FCR_RX_BUF_SIZE,
49 L2CAP_FCR_TX_BUF_SIZE
50 };
51
52 static tL2CAP_FCR_OPTS rfc_l2c_fcr_opts_def =
53 {
54 L2CAP_FCR_ERTM_MODE,
55 RFC_FCR_OPT_TX_WINDOW_SIZE, /* Tx window size */
56 RFC_FCR_OPT_MAX_TX_B4_DISCNT, /* Maximum transmissions before disconnecting */
57 RFC_FCR_OPT_RETX_TOUT, /* Retransmission timeout (2 secs) */
58 RFC_FCR_OPT_MONITOR_TOUT, /* Monitor timeout (12 secs) */
59 RFC_FCR_OPT_MAX_PDU_SIZE /* MPS segment size */
60 };
61
62 /********************************************************************************/
63 /* L O C A L F U N C T I O N P R O T O T Y P E S */
64 /********************************************************************************/
65 static void rfc_mx_sm_state_idle (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
66 static void rfc_mx_sm_state_wait_conn_cnf (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
67 static void rfc_mx_sm_state_configure (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
68 static void rfc_mx_sm_sabme_wait_ua (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
69 static void rfc_mx_sm_state_wait_sabme (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
70 static void rfc_mx_sm_state_connected (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
71 static void rfc_mx_sm_state_disc_wait_ua (tRFC_MCB *p_mcb, UINT16 event, void *p_data);
72
73 static void rfc_mx_send_config_req (tRFC_MCB *p_mcb);
74 static void rfc_mx_conf_ind (tRFC_MCB *p_mcb, tL2CAP_CFG_INFO *p_cfg);
75 static void rfc_mx_conf_cnf (tRFC_MCB *p_mcb, tL2CAP_CFG_INFO *p_cfg);
76
77
78
79 /*******************************************************************************
80 **
81 ** Function rfc_mx_sm_execute
82 **
83 ** Description This function sends multiplexor events through the state
84 ** machine.
85 **
86 ** Returns void
87 **
88 *******************************************************************************/
rfc_mx_sm_execute(tRFC_MCB * p_mcb,UINT16 event,void * p_data)89 void rfc_mx_sm_execute (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
90 {
91 RFCOMM_TRACE_DEBUG("%s st:%d, evt:%d\n", __func__, p_mcb->state, event);
92
93 switch (p_mcb->state) {
94 case RFC_MX_STATE_IDLE:
95 rfc_mx_sm_state_idle (p_mcb, event, p_data);
96 break;
97
98 case RFC_MX_STATE_WAIT_CONN_CNF:
99 rfc_mx_sm_state_wait_conn_cnf (p_mcb, event, p_data);
100 break;
101
102 case RFC_MX_STATE_CONFIGURE:
103 rfc_mx_sm_state_configure (p_mcb, event, p_data);
104 break;
105
106 case RFC_MX_STATE_SABME_WAIT_UA:
107 rfc_mx_sm_sabme_wait_ua (p_mcb, event, p_data);
108 break;
109
110 case RFC_MX_STATE_WAIT_SABME:
111 rfc_mx_sm_state_wait_sabme (p_mcb, event, p_data);
112 break;
113
114 case RFC_MX_STATE_CONNECTED:
115 rfc_mx_sm_state_connected (p_mcb, event, p_data);
116 break;
117
118 case RFC_MX_STATE_DISC_WAIT_UA:
119 rfc_mx_sm_state_disc_wait_ua (p_mcb, event, p_data);
120 break;
121
122 }
123 }
124
125
126 /*******************************************************************************
127 **
128 ** Function rfc_mx_sm_state_idle
129 **
130 ** Description This function handles events when the multiplexer is in
131 ** IDLE state. This state exists when connection is being
132 ** initially established.
133 **
134 ** Returns void
135 **
136 *******************************************************************************/
rfc_mx_sm_state_idle(tRFC_MCB * p_mcb,UINT16 event,void * p_data)137 void rfc_mx_sm_state_idle (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
138 {
139 tL2CAP_ERTM_INFO *ertm_opt = NULL;
140
141 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_idle - evt:%d", event);
142
143 switch (event) {
144 case RFC_MX_EVENT_START_REQ:
145
146 /* Initialize L2CAP MTU */
147 p_mcb->peer_l2cap_mtu = L2CAP_DEFAULT_MTU - RFCOMM_MIN_OFFSET - 1;
148
149 ertm_opt = rfc_cb.port.enable_l2cap_ertm ? &rfc_l2c_etm_opt : NULL;
150 p_mcb->lcid = L2CA_ErtmConnectReq (BT_PSM_RFCOMM, p_mcb->bd_addr, ertm_opt);
151
152 if (p_mcb->lcid == 0) {
153 PORT_StartCnf (p_mcb, RFCOMM_ERROR);
154 return;
155 }
156 /* Save entry for quicker access to mcb based on the LCID */
157 rfc_save_lcid_mcb (p_mcb, p_mcb->lcid);
158
159 p_mcb->state = RFC_MX_STATE_WAIT_CONN_CNF;
160 return;
161
162 case RFC_MX_EVENT_START_RSP:
163 case RFC_MX_EVENT_CONN_CNF:
164 case RFC_MX_EVENT_CONF_IND:
165 case RFC_MX_EVENT_CONF_CNF:
166 RFCOMM_TRACE_ERROR ("Mx error state %d event %d", p_mcb->state, event);
167 return;
168
169 case RFC_MX_EVENT_CONN_IND:
170
171 rfc_timer_start (p_mcb, RFCOMM_CONN_TIMEOUT);
172 ertm_opt = rfc_cb.port.enable_l2cap_ertm ? &rfc_l2c_etm_opt : NULL;
173 L2CA_ErtmConnectRsp (p_mcb->bd_addr, *((UINT8 *)p_data), p_mcb->lcid, L2CAP_CONN_OK, 0, ertm_opt);
174
175 rfc_mx_send_config_req (p_mcb);
176
177 p_mcb->state = RFC_MX_STATE_CONFIGURE;
178 return;
179
180 case RFC_EVENT_SABME:
181 break;
182
183 case RFC_EVENT_UA:
184 case RFC_EVENT_DM:
185 return;
186
187 case RFC_EVENT_DISC:
188 rfc_send_dm (p_mcb, RFCOMM_MX_DLCI, TRUE);
189 return;
190
191 case RFC_EVENT_UIH:
192 rfc_send_dm (p_mcb, RFCOMM_MX_DLCI, FALSE);
193 return;
194 }
195 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
196 }
197
198
199 /*******************************************************************************
200 **
201 ** Function rfc_mx_sm_state_wait_conn_cnf
202 **
203 ** Description This function handles events when the multiplexer is
204 ** waiting for Connection Confirm from L2CAP.
205 **
206 ** Returns void
207 **
208 *******************************************************************************/
rfc_mx_sm_state_wait_conn_cnf(tRFC_MCB * p_mcb,UINT16 event,void * p_data)209 void rfc_mx_sm_state_wait_conn_cnf (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
210 {
211 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_wait_conn_cnf - evt:%d", event);
212 switch (event) {
213 case RFC_MX_EVENT_START_REQ:
214 RFCOMM_TRACE_ERROR ("Mx error state %d event %d", p_mcb->state, event);
215 return;
216
217 /* There is some new timing so that Config Ind comes before security is completed
218 so we are still waiting fo the confirmation. */
219 case RFC_MX_EVENT_CONF_IND:
220 rfc_mx_conf_ind (p_mcb, (tL2CAP_CFG_INFO *)p_data);
221 return;
222
223 case RFC_MX_EVENT_CONN_CNF:
224 if (*((UINT16 *)p_data) != L2CAP_SUCCESS) {
225 p_mcb->state = RFC_MX_STATE_IDLE;
226
227 PORT_StartCnf (p_mcb, *((UINT16 *)p_data));
228 return;
229 }
230 p_mcb->state = RFC_MX_STATE_CONFIGURE;
231 rfc_mx_send_config_req (p_mcb);
232 return;
233
234 case RFC_MX_EVENT_DISC_IND:
235 p_mcb->state = RFC_MX_STATE_IDLE;
236 PORT_CloseInd (p_mcb);
237 return;
238
239 case RFC_EVENT_TIMEOUT:
240 p_mcb->state = RFC_MX_STATE_IDLE;
241 L2CA_DisconnectReq (p_mcb->lcid);
242
243 /* we gave up outgoing connection request then try peer's request */
244 if (p_mcb->pending_lcid) {
245 UINT16 i;
246 UINT8 idx;
247
248 RFCOMM_TRACE_DEBUG ("RFCOMM MX retry as acceptor in collision case - evt:%d in state:%d", event, p_mcb->state);
249
250 rfc_save_lcid_mcb (NULL, p_mcb->lcid);
251 p_mcb->lcid = p_mcb->pending_lcid;
252 rfc_save_lcid_mcb (p_mcb, p_mcb->lcid);
253
254 p_mcb->is_initiator = FALSE;
255
256 /* update direction bit */
257 for (i = 0; i < RFCOMM_MAX_DLCI; i += 2) {
258 if ((idx = p_mcb->port_inx[i]) != 0) {
259 p_mcb->port_inx[i] = 0;
260 p_mcb->port_inx[i + 1] = idx;
261 rfc_cb.port.port[idx - 1].dlci += 1;
262 RFCOMM_TRACE_DEBUG ("RFCOMM MX - DLCI:%d -> %d", i, rfc_cb.port.port[idx - 1].dlci);
263 }
264 }
265
266 rfc_mx_sm_execute (p_mcb, RFC_MX_EVENT_CONN_IND, &(p_mcb->pending_id));
267 } else {
268 PORT_CloseInd (p_mcb);
269 }
270 return;
271 }
272 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
273 }
274
275
276 /*******************************************************************************
277 **
278 ** Function rfc_mx_sm_state_configure
279 **
280 ** Description This function handles events when the multiplexer in the
281 ** configuration state.
282 **
283 ** Returns void
284 **
285 *******************************************************************************/
rfc_mx_sm_state_configure(tRFC_MCB * p_mcb,UINT16 event,void * p_data)286 void rfc_mx_sm_state_configure (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
287 {
288 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_configure - evt:%d", event);
289 switch (event) {
290 case RFC_MX_EVENT_START_REQ:
291 case RFC_MX_EVENT_CONN_CNF:
292
293 RFCOMM_TRACE_ERROR ("Mx error state %d event %d", p_mcb->state, event);
294 return;
295
296 case RFC_MX_EVENT_CONF_IND:
297 rfc_mx_conf_ind (p_mcb, (tL2CAP_CFG_INFO *)p_data);
298 return;
299
300 case RFC_MX_EVENT_CONF_CNF:
301 rfc_mx_conf_cnf (p_mcb, (tL2CAP_CFG_INFO *)p_data);
302 return;
303
304 case RFC_MX_EVENT_DISC_IND:
305 p_mcb->state = RFC_MX_STATE_IDLE;
306 PORT_CloseInd (p_mcb);
307 return;
308
309 case RFC_EVENT_TIMEOUT:
310 p_mcb->state = RFC_MX_STATE_IDLE;
311 L2CA_DisconnectReq (p_mcb->lcid);
312
313 PORT_StartCnf (p_mcb, RFCOMM_ERROR);
314 return;
315 }
316 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
317 }
318
319
320 /*******************************************************************************
321 **
322 ** Function rfc_mx_sm_sabme_wait_ua
323 **
324 ** Description This function handles events when the multiplexer sent
325 ** SABME and is waiting for UA reply.
326 **
327 ** Returns void
328 **
329 *******************************************************************************/
rfc_mx_sm_sabme_wait_ua(tRFC_MCB * p_mcb,UINT16 event,void * p_data)330 void rfc_mx_sm_sabme_wait_ua (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
331 {
332 UNUSED(p_data);
333
334 RFCOMM_TRACE_EVENT ("rfc_mx_sm_sabme_wait_ua - evt:%d", event);
335 switch (event) {
336 case RFC_MX_EVENT_START_REQ:
337 case RFC_MX_EVENT_CONN_CNF:
338 RFCOMM_TRACE_ERROR ("Mx error state %d event %d", p_mcb->state, event);
339 return;
340
341 /* workaround: we don't support reconfig */
342 /* commented out until we support reconfig
343 case RFC_MX_EVENT_CONF_IND:
344 rfc_mx_conf_ind (p_mcb, (tL2CAP_CFG_INFO *)p_data);
345 return;
346
347 case RFC_MX_EVENT_CONF_CNF:
348 rfc_mx_conf_cnf (p_mcb, (tL2CAP_CFG_INFO *)p_data);
349 return;
350 */
351
352 case RFC_MX_EVENT_DISC_IND:
353 p_mcb->state = RFC_MX_STATE_IDLE;
354 PORT_CloseInd (p_mcb);
355 return;
356
357 case RFC_EVENT_UA:
358 rfc_timer_stop (p_mcb);
359
360 p_mcb->state = RFC_MX_STATE_CONNECTED;
361 p_mcb->peer_ready = TRUE;
362
363 PORT_StartCnf (p_mcb, RFCOMM_SUCCESS);
364 return;
365
366 case RFC_EVENT_DM:
367 rfc_timer_stop (p_mcb);
368 /* Case falls through */
369
370 case RFC_MX_EVENT_CONF_IND: /* workaround: we don't support reconfig */
371 case RFC_MX_EVENT_CONF_CNF: /* workaround: we don't support reconfig */
372 case RFC_EVENT_TIMEOUT:
373 p_mcb->state = RFC_MX_STATE_IDLE;
374 L2CA_DisconnectReq (p_mcb->lcid);
375
376 PORT_StartCnf (p_mcb, RFCOMM_ERROR);
377 return;
378 }
379 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
380 }
381
382 /*******************************************************************************
383 **
384 ** Function rfc_mx_sm_state_wait_sabme
385 **
386 ** Description This function handles events when the multiplexer is
387 ** waiting for SABME on the acceptor side after configuration
388 **
389 ** Returns void
390 **
391 *******************************************************************************/
rfc_mx_sm_state_wait_sabme(tRFC_MCB * p_mcb,UINT16 event,void * p_data)392 void rfc_mx_sm_state_wait_sabme (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
393 {
394 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_wait_sabme - evt:%d", event);
395 switch (event) {
396 case RFC_MX_EVENT_DISC_IND:
397 p_mcb->state = RFC_MX_STATE_IDLE;
398 PORT_CloseInd (p_mcb);
399 return;
400
401 case RFC_EVENT_SABME:
402 /* if we gave up outgoing connection request */
403 if (p_mcb->pending_lcid) {
404 p_mcb->pending_lcid = 0;
405
406 rfc_send_ua (p_mcb, RFCOMM_MX_DLCI);
407
408 rfc_timer_stop (p_mcb);
409 p_mcb->state = RFC_MX_STATE_CONNECTED;
410 p_mcb->peer_ready = TRUE;
411
412 /* MX channel collision has been resolved, continue to open ports */
413 PORT_StartCnf (p_mcb, RFCOMM_SUCCESS);
414 } else {
415 rfc_timer_stop (p_mcb);
416 PORT_StartInd (p_mcb);
417 }
418 return;
419
420 case RFC_MX_EVENT_START_RSP:
421 if (*((UINT16 *)p_data) != RFCOMM_SUCCESS) {
422 rfc_send_dm (p_mcb, RFCOMM_MX_DLCI, TRUE);
423 } else {
424 rfc_send_ua (p_mcb, RFCOMM_MX_DLCI);
425
426 p_mcb->state = RFC_MX_STATE_CONNECTED;
427 p_mcb->peer_ready = TRUE;
428 }
429 return;
430
431 case RFC_MX_EVENT_CONF_IND: /* workaround: we don't support reconfig */
432 case RFC_MX_EVENT_CONF_CNF: /* workaround: we don't support reconfig */
433 case RFC_EVENT_TIMEOUT:
434 p_mcb->state = RFC_MX_STATE_IDLE;
435 L2CA_DisconnectReq (p_mcb->lcid);
436
437 PORT_CloseInd (p_mcb);
438 return;
439 }
440 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
441 }
442
443
444 /*******************************************************************************
445 **
446 ** Function rfc_mx_sm_state_connected
447 **
448 ** Description This function handles events when the multiplexer is
449 ** in the CONNECTED state
450 **
451 ** Returns void
452 **
453 *******************************************************************************/
rfc_mx_sm_state_connected(tRFC_MCB * p_mcb,UINT16 event,void * p_data)454 void rfc_mx_sm_state_connected (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
455 {
456 UNUSED(p_data);
457
458 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_connected - evt:%d", event);
459
460 switch (event) {
461 case RFC_EVENT_TIMEOUT:
462 case RFC_MX_EVENT_CLOSE_REQ:
463 rfc_timer_start (p_mcb, RFC_DISC_TIMEOUT);
464 p_mcb->state = RFC_MX_STATE_DISC_WAIT_UA;
465 rfc_send_disc (p_mcb, RFCOMM_MX_DLCI);
466 return;
467
468 case RFC_MX_EVENT_DISC_IND:
469 p_mcb->state = RFC_MX_STATE_IDLE;
470 PORT_CloseInd (p_mcb);
471 return;
472
473 case RFC_EVENT_DISC:
474 /* Reply with UA. If initiator bring down L2CAP connection */
475 /* If server wait for some time if client decide to reinitiate channel */
476 rfc_send_ua (p_mcb, RFCOMM_MX_DLCI);
477 if (p_mcb->is_initiator) {
478 L2CA_DisconnectReq (p_mcb->lcid);
479 }
480 /* notify all ports that connection is gone */
481 PORT_CloseInd (p_mcb);
482 return;
483 }
484 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
485 }
486
487
488 /*******************************************************************************
489 **
490 ** Function rfc_mx_sm_state_disc_wait_ua
491 **
492 ** Description This function handles events when the multiplexer sent
493 ** DISC and is waiting for UA reply.
494 **
495 ** Returns void
496 **
497 *******************************************************************************/
rfc_mx_sm_state_disc_wait_ua(tRFC_MCB * p_mcb,UINT16 event,void * p_data)498 void rfc_mx_sm_state_disc_wait_ua (tRFC_MCB *p_mcb, UINT16 event, void *p_data)
499 {
500 BT_HDR *p_buf;
501
502 RFCOMM_TRACE_EVENT ("rfc_mx_sm_state_disc_wait_ua - evt:%d", event);
503 switch (event) {
504 case RFC_EVENT_UA:
505 case RFC_EVENT_DM:
506 case RFC_EVENT_TIMEOUT:
507 L2CA_DisconnectReq (p_mcb->lcid);
508
509 if (p_mcb->restart_required) {
510 tL2CAP_ERTM_INFO *ertm_opt = rfc_cb.port.enable_l2cap_ertm ? &rfc_l2c_etm_opt : NULL;
511 /* Start Request was received while disconnecting. Execute it again */
512 p_mcb->lcid = L2CA_ErtmConnectReq(BT_PSM_RFCOMM, p_mcb->bd_addr, ertm_opt);
513
514 if (p_mcb->lcid == 0) {
515 PORT_StartCnf (p_mcb, RFCOMM_ERROR);
516 return;
517 }
518 /* Save entry for quicker access to mcb based on the LCID */
519 rfc_save_lcid_mcb (p_mcb, p_mcb->lcid);
520
521 /* clean up before reuse it */
522 while ((p_buf = (BT_HDR *)fixed_queue_dequeue(p_mcb->cmd_q, 0)) != NULL) {
523 osi_free(p_buf);
524 }
525
526 rfc_timer_start (p_mcb, RFC_MCB_INIT_INACT_TIMER);
527
528 p_mcb->is_initiator = TRUE;
529 p_mcb->restart_required = FALSE;
530 p_mcb->local_cfg_sent = FALSE;
531 p_mcb->peer_cfg_rcvd = FALSE;
532
533 p_mcb->state = RFC_MX_STATE_WAIT_CONN_CNF;
534 return;
535 }
536 rfc_release_multiplexer_channel (p_mcb);
537 return;
538
539 case RFC_EVENT_DISC:
540 rfc_send_ua (p_mcb, RFCOMM_MX_DLCI);
541 return;
542
543 case RFC_EVENT_UIH:
544 osi_free (p_data);
545 rfc_send_dm (p_mcb, RFCOMM_MX_DLCI, FALSE);
546 return;
547
548 case RFC_MX_EVENT_START_REQ:
549 p_mcb->restart_required = TRUE;
550 return;
551
552 case RFC_MX_EVENT_DISC_IND:
553 p_mcb->state = RFC_MX_STATE_IDLE;
554 PORT_CloseInd (p_mcb);
555 return;
556
557 case RFC_MX_EVENT_CLOSE_REQ:
558 return;
559
560 case RFC_MX_EVENT_QOS_VIOLATION_IND:
561 break;
562 }
563 RFCOMM_TRACE_EVENT ("RFCOMM MX ignored - evt:%d in state:%d", event, p_mcb->state);
564 }
565
566
567 /*******************************************************************************
568 **
569 ** Function rfc_mx_send_config_req
570 **
571 ** Description This function handles L2CA_ConnectInd message from the
572 ** L2CAP. Accept connection.
573 **
574 *******************************************************************************/
rfc_mx_send_config_req(tRFC_MCB * p_mcb)575 static void rfc_mx_send_config_req (tRFC_MCB *p_mcb)
576 {
577 tL2CAP_CFG_INFO cfg;
578
579 RFCOMM_TRACE_EVENT ("rfc_mx_send_config_req");
580
581 memset (&cfg, 0, sizeof (tL2CAP_CFG_INFO));
582
583 cfg.mtu_present = TRUE;
584 cfg.mtu = L2CAP_MTU_SIZE;
585
586 if (rfc_cb.port.enable_l2cap_ertm) {
587 cfg.fcr_present = TRUE;
588 cfg.fcr = rfc_l2c_fcr_opts_def;
589 }
590
591 /* Defaults set by memset
592 cfg.flush_to_present = FALSE;
593 cfg.qos_present = FALSE;
594 cfg.fcr_present = FALSE;
595 cfg.fcr.mode = L2CAP_FCR_BASIC_MODE;
596 cfg.fcs_present = FALSE;
597 cfg.fcs = N/A when fcs_present is FALSE;
598 */
599 L2CA_ConfigReq (p_mcb->lcid, &cfg);
600 }
601
602
603 /*******************************************************************************
604 **
605 ** Function rfc_mx_conf_cnf
606 **
607 ** Description This function handles L2CA_ConfigCnf message from the
608 ** L2CAP. If result is not success tell upper layer that
609 ** start has not been accepted. If initiator send SABME
610 ** on DLCI 0. T1 is still running.
611 **
612 *******************************************************************************/
rfc_mx_conf_cnf(tRFC_MCB * p_mcb,tL2CAP_CFG_INFO * p_cfg)613 static void rfc_mx_conf_cnf (tRFC_MCB *p_mcb, tL2CAP_CFG_INFO *p_cfg)
614 {
615 // RFCOMM_TRACE_EVENT ("rfc_mx_conf_cnf p_cfg:%08x res:%d ", p_cfg, (p_cfg) ? p_cfg->result : 0);
616
617 if (p_cfg->result != L2CAP_CFG_OK) {
618 if (p_mcb->is_initiator) {
619 PORT_StartCnf (p_mcb, p_cfg->result);
620 L2CA_DisconnectReq (p_mcb->lcid);
621 }
622 rfc_release_multiplexer_channel (p_mcb);
623 return;
624 }
625
626 p_mcb->local_cfg_sent = TRUE;
627 if ((p_mcb->state == RFC_MX_STATE_CONFIGURE) && p_mcb->peer_cfg_rcvd) {
628 if (p_mcb->is_initiator) {
629 p_mcb->state = RFC_MX_STATE_SABME_WAIT_UA;
630 rfc_send_sabme (p_mcb, RFCOMM_MX_DLCI);
631 rfc_timer_start (p_mcb, RFC_T1_TIMEOUT);
632 } else {
633 p_mcb->state = RFC_MX_STATE_WAIT_SABME;
634 rfc_timer_start (p_mcb, RFCOMM_CONN_TIMEOUT); /* - increased from T2=20 to CONN=120
635 to allow the user more than 10 sec to type in the
636 pin which can be e.g. 16 digits */
637 }
638 }
639 }
640
641
642 /*******************************************************************************
643 **
644 ** Function rfc_mx_conf_ind
645 **
646 ** Description This function handles L2CA_ConfigInd message from the
647 ** L2CAP. Send the L2CA_ConfigRsp message.
648 **
649 *******************************************************************************/
rfc_mx_conf_ind(tRFC_MCB * p_mcb,tL2CAP_CFG_INFO * p_cfg)650 static void rfc_mx_conf_ind (tRFC_MCB *p_mcb, tL2CAP_CFG_INFO *p_cfg)
651 {
652 /* Save peer L2CAP MTU if present */
653 /* RFCOMM adds 3-4 bytes in the beginning and 1 bytes FCS */
654 if (p_cfg->mtu_present) {
655 p_mcb->peer_l2cap_mtu = p_cfg->mtu - RFCOMM_MIN_OFFSET - 1;
656 } else {
657 p_mcb->peer_l2cap_mtu = L2CAP_DEFAULT_MTU - RFCOMM_MIN_OFFSET - 1;
658 }
659
660 p_cfg->mtu_present = FALSE;
661 p_cfg->flush_to_present = FALSE;
662 p_cfg->qos_present = FALSE;
663
664 p_cfg->result = L2CAP_CFG_OK;
665
666 L2CA_ConfigRsp (p_mcb->lcid, p_cfg);
667
668 p_mcb->peer_cfg_rcvd = TRUE;
669 if ((p_mcb->state == RFC_MX_STATE_CONFIGURE) && p_mcb->local_cfg_sent) {
670 if (p_mcb->is_initiator) {
671 p_mcb->state = RFC_MX_STATE_SABME_WAIT_UA;
672 rfc_send_sabme (p_mcb, RFCOMM_MX_DLCI);
673 rfc_timer_start (p_mcb, RFC_T1_TIMEOUT);
674 } else {
675 p_mcb->state = RFC_MX_STATE_WAIT_SABME;
676 rfc_timer_start (p_mcb, RFCOMM_CONN_TIMEOUT); /* - increased from T2=20 to CONN=120
677 to allow the user more than 10 sec to type in the
678 pin which can be e.g. 16 digits */
679 }
680 }
681 }
682
683 #endif ///(defined RFCOMM_INCLUDED && RFCOMM_INCLUDED == TRUE)
684
