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 a port of the 22 * RFCOMM unit 23 * 24 ******************************************************************************/ 25 #include <string.h> 26 #include "bt_target.h" 27 #include "gki.h" 28 #include "rfcdefs.h" 29 #include "btm_api.h" 30 #include "btm_int.h" 31 #include "port_api.h" 32 #include "port_int.h" 33 #include "rfc_int.h" 34 #include "bt_utils.h" 35 36 /********************************************************************************/ 37 /* L O C A L F U N C T I O N P R O T O T Y P E S */ 38 /********************************************************************************/ 39 static void rfc_port_sm_state_closed (tPORT *p_port, UINT16 event, void *p_data); 40 static void rfc_port_sm_sabme_wait_ua (tPORT *p_port, UINT16 event, void *p_data); 41 static void rfc_port_sm_opened (tPORT *p_port, UINT16 event, void *p_data); 42 static void rfc_port_sm_orig_wait_sec_check (tPORT *p_port, UINT16 event, void *p_data); 43 static void rfc_port_sm_term_wait_sec_check (tPORT *p_port, UINT16 event, void *p_data); 44 static void rfc_port_sm_disc_wait_ua (tPORT *p_port, UINT16 event, void *p_data); 45 46 static void rfc_port_uplink_data (tPORT *p_port, BT_HDR *p_buf); 47 48 static void rfc_set_port_state(tPORT_STATE *port_pars, MX_FRAME *p_frame); 49 50 51 /******************************************************************************* 52 ** 53 ** Function rfc_port_sm_execute 54 ** 55 ** Description This function sends port events through the state 56 ** machine. 57 ** 58 ** Returns void 59 ** 60 *******************************************************************************/ 61 void rfc_port_sm_execute (tPORT *p_port, UINT16 event, void *p_data) 62 { 63 if (!p_port) 64 { 65 RFCOMM_TRACE_WARNING ("NULL port event %d", event); 66 return; 67 } 68 69 switch (p_port->rfc.state) 70 { 71 case RFC_STATE_CLOSED: 72 rfc_port_sm_state_closed (p_port, event, p_data); 73 break; 74 75 case RFC_STATE_SABME_WAIT_UA: 76 rfc_port_sm_sabme_wait_ua (p_port, event, p_data); 77 break; 78 79 case RFC_STATE_ORIG_WAIT_SEC_CHECK: 80 rfc_port_sm_orig_wait_sec_check (p_port, event, p_data); 81 break; 82 83 case RFC_STATE_TERM_WAIT_SEC_CHECK: 84 rfc_port_sm_term_wait_sec_check (p_port, event, p_data); 85 break; 86 87 case RFC_STATE_OPENED: 88 rfc_port_sm_opened (p_port, event, p_data); 89 break; 90 91 case RFC_STATE_DISC_WAIT_UA: 92 rfc_port_sm_disc_wait_ua (p_port, event, p_data); 93 break; 94 } 95 } 96 97 98 /******************************************************************************* 99 ** 100 ** Function rfc_port_sm_state_closed 101 ** 102 ** Description This function handles events when the port is in 103 ** CLOSED state. This state exists when port is 104 ** being initially established. 105 ** 106 ** Returns void 107 ** 108 *******************************************************************************/ 109 void rfc_port_sm_state_closed (tPORT *p_port, UINT16 event, void *p_data) 110 { 111 switch (event) 112 { 113 case RFC_EVENT_OPEN: 114 p_port->rfc.state = RFC_STATE_ORIG_WAIT_SEC_CHECK; 115 btm_sec_mx_access_request (p_port->rfc.p_mcb->bd_addr, BT_PSM_RFCOMM, TRUE, 116 BTM_SEC_PROTO_RFCOMM, (UINT32)(p_port->dlci / 2), 117 &rfc_sec_check_complete, p_port); 118 return; 119 120 case RFC_EVENT_CLOSE: 121 break; 122 123 case RFC_EVENT_CLEAR: 124 return; 125 126 case RFC_EVENT_DATA: 127 GKI_freebuf (p_data); 128 break; 129 130 case RFC_EVENT_SABME: 131 /* make sure the multiplexer disconnect timer is not running (reconnect case) */ 132 rfc_timer_stop(p_port->rfc.p_mcb ); 133 134 /* Open will be continued after security checks are passed */ 135 p_port->rfc.state = RFC_STATE_TERM_WAIT_SEC_CHECK; 136 btm_sec_mx_access_request (p_port->rfc.p_mcb->bd_addr, BT_PSM_RFCOMM, FALSE, 137 BTM_SEC_PROTO_RFCOMM, (UINT32)(p_port->dlci / 2), 138 &rfc_sec_check_complete, p_port); 139 return; 140 141 case RFC_EVENT_UA: 142 return; 143 144 case RFC_EVENT_DM: 145 rfc_port_closed (p_port); 146 return; 147 148 case RFC_EVENT_UIH: 149 GKI_freebuf (p_data); 150 rfc_send_dm (p_port->rfc.p_mcb, p_port->dlci, FALSE); 151 return; 152 153 case RFC_EVENT_DISC: 154 rfc_send_dm (p_port->rfc.p_mcb, p_port->dlci, FALSE); 155 return; 156 157 case RFC_EVENT_TIMEOUT: 158 Port_TimeOutCloseMux( p_port->rfc.p_mcb ) ; 159 RFCOMM_TRACE_ERROR ("Port error state %d event %d", p_port->rfc.state, event); 160 return; 161 } 162 163 RFCOMM_TRACE_WARNING ("Port state closed Event ignored %d", event); 164 return; 165 } 166 167 /******************************************************************************* 168 ** 169 ** Function rfc_port_sm_sabme_wait_ua 170 ** 171 ** Description This function handles events when SABME on the DLC was 172 ** sent and SM is waiting for UA or DM. 173 ** 174 ** Returns void 175 ** 176 *******************************************************************************/ 177 void rfc_port_sm_sabme_wait_ua (tPORT *p_port, UINT16 event, void *p_data) 178 { 179 switch (event) 180 { 181 case RFC_EVENT_OPEN: 182 case RFC_EVENT_ESTABLISH_RSP: 183 RFCOMM_TRACE_ERROR ("Port error state %d event %d", p_port->rfc.state, event); 184 return; 185 186 case RFC_EVENT_CLOSE: 187 rfc_port_timer_start (p_port, RFC_DISC_TIMEOUT); 188 rfc_send_disc (p_port->rfc.p_mcb, p_port->dlci); 189 p_port->rfc.expected_rsp = 0; 190 p_port->rfc.state = RFC_STATE_DISC_WAIT_UA; 191 return; 192 193 case RFC_EVENT_CLEAR: 194 rfc_port_closed (p_port); 195 return; 196 197 case RFC_EVENT_DATA: 198 GKI_freebuf (p_data); 199 break; 200 201 case RFC_EVENT_UA: 202 rfc_port_timer_stop (p_port); 203 p_port->rfc.state = RFC_STATE_OPENED; 204 PORT_DlcEstablishCnf (p_port->rfc.p_mcb, p_port->dlci, p_port->rfc.p_mcb->peer_l2cap_mtu, RFCOMM_SUCCESS); 205 return; 206 207 case RFC_EVENT_DM: 208 p_port->rfc.p_mcb->is_disc_initiator = TRUE; 209 PORT_DlcEstablishCnf (p_port->rfc.p_mcb, p_port->dlci, p_port->rfc.p_mcb->peer_l2cap_mtu, RFCOMM_ERROR); 210 rfc_port_closed (p_port); 211 return; 212 213 case RFC_EVENT_DISC: 214 rfc_send_ua (p_port->rfc.p_mcb, p_port->dlci); 215 PORT_DlcEstablishCnf (p_port->rfc.p_mcb, p_port->dlci, p_port->rfc.p_mcb->peer_l2cap_mtu, RFCOMM_ERROR); 216 rfc_port_closed (p_port); 217 return; 218 219 case RFC_EVENT_SABME: 220 /* Continue to wait for the UA the SABME this side sent */ 221 rfc_send_ua (p_port->rfc.p_mcb, p_port->dlci); 222 return; 223 224 case RFC_EVENT_UIH: 225 GKI_freebuf (p_data); 226 return; 227 228 case RFC_EVENT_TIMEOUT: 229 p_port->rfc.state = RFC_STATE_CLOSED; 230 PORT_DlcEstablishCnf (p_port->rfc.p_mcb, p_port->dlci, p_port->rfc.p_mcb->peer_l2cap_mtu, RFCOMM_ERROR); 231 return; 232 } 233 RFCOMM_TRACE_WARNING ("Port state sabme_wait_ua Event ignored %d", event); 234 } 235 236 237 /******************************************************************************* 238 ** 239 ** Function rfc_port_sm_term_wait_sec_check 240 ** 241 ** Description This function handles events for the port in the 242 ** WAIT_SEC_CHECK state. SABME has been received from the 243 ** peer and Security Manager verifes BD_ADDR, before we can 244 ** send ESTABLISH_IND to the Port entity 245 ** 246 ** Returns void 247 ** 248 *******************************************************************************/ 249 void rfc_port_sm_term_wait_sec_check (tPORT *p_port, UINT16 event, void *p_data) 250 { 251 switch (event) 252 { 253 case RFC_EVENT_SEC_COMPLETE: 254 if (*((UINT8 *)p_data) != BTM_SUCCESS) 255 { 256 /* Authentication/authorization failed. If link is still */ 257 /* up send DM and check if we need to start inactive timer */ 258 if (p_port->rfc.p_mcb) 259 { 260 rfc_send_dm (p_port->rfc.p_mcb, p_port->dlci, TRUE); 261 p_port->rfc.p_mcb->is_disc_initiator = TRUE; 262 port_rfc_closed (p_port, PORT_SEC_FAILED); 263 } 264 } 265 else 266 { 267 PORT_DlcEstablishInd (p_port->rfc.p_mcb, p_port->dlci, p_port->rfc.p_mcb->peer_l2cap_mtu); 268 } 269 return; 270 271 case RFC_EVENT_OPEN: 272 case RFC_EVENT_CLOSE: 273 RFCOMM_TRACE_ERROR ("Port error state %d event %d", p_port->rfc.state, event); 274 return; 275 276 case RFC_EVENT_CLEAR: 277 btm_sec_abort_access_req (p_port->rfc.p_mcb->bd_addr); 278 rfc_port_closed (p_port); 279 return; 280 281 case RFC_EVENT_DATA: 282 RFCOMM_TRACE_ERROR ("Port error state Term Wait Sec event Data"); 283 GKI_freebuf (p_data); 284 return; 285 286 case RFC_EVENT_SABME: 287 /* Ignore SABME retransmission if client dares to do so */ 288 return; 289 290 case RFC_EVENT_DISC: 291 btm_sec_abort_access_req (p_port->rfc.p_mcb->bd_addr); 292 p_port->rfc.state = RFC_STATE_CLOSED; 293 rfc_send_ua (p_port->rfc.p_mcb, p_port->dlci); 294 295 PORT_DlcReleaseInd (p_port->rfc.p_mcb, p_port->dlci); 296 return; 297 298 case RFC_EVENT_UIH: 299 GKI_freebuf (p_data); 300 return; 301 302 case RFC_EVENT_ESTABLISH_RSP: 303 if (*((UINT8 *)p_data) != RFCOMM_SUCCESS) 304 { 305 if (p_port->rfc.p_mcb) 306 rfc_send_dm (p_port->rfc.p_mcb, p_port->dlci, TRUE); 307 } 308 else 309 { 310 rfc_send_ua (p_port->rfc.p_mcb, p_port->dlci); 311 p_port->rfc.state = RFC_STATE_OPENED; 312 } 313 return; 314 } 315 RFCOMM_TRACE_WARNING ("Port state term_wait_sec_check Event ignored %d", event); 316 } 317 318 319 /******************************************************************************* 320 ** 321 ** Function rfc_port_sm_orig_wait_sec_check 322 ** 323 ** Description This function handles events for the port in the 324 ** ORIG_WAIT_SEC_CHECK state. RFCOMM is waiting for Security 325 ** manager to finish before sending SABME to the peer 326 ** 327 ** Returns void 328 ** 329 *******************************************************************************/ 330 void rfc_port_sm_orig_wait_sec_check (tPORT *p_port, UINT16 event, void *p_data) 331 { 332 switch (event) 333 { 334 case RFC_EVENT_SEC_COMPLETE: 335 if (*((UINT8 *)p_data) != BTM_SUCCESS) 336 { 337 p_port->rfc.p_mcb->is_disc_initiator = TRUE; 338 PORT_DlcEstablishCnf (p_port->rfc.p_mcb, p_port->dlci, 0, RFCOMM_SECURITY_ERR); 339 rfc_port_closed (p_port); 340 return; 341 } 342 rfc_send_sabme (p_port->rfc.p_mcb, p_port->dlci); 343 rfc_port_timer_start (p_port, RFC_PORT_T1_TIMEOUT); 344 p_port->rfc.state = RFC_STATE_SABME_WAIT_UA; 345 return; 346 347 case RFC_EVENT_OPEN: 348 case RFC_EVENT_SABME: /* Peer should not use the same dlci */ 349 RFCOMM_TRACE_ERROR ("Port error state %d event %d", p_port->rfc.state, event); 350 return; 351 352 case RFC_EVENT_CLOSE: 353 btm_sec_abort_access_req (p_port->rfc.p_mcb->bd_addr); 354 rfc_port_closed (p_port); 355 return; 356 357 case RFC_EVENT_DATA: 358 RFCOMM_TRACE_ERROR ("Port error state Orig Wait Sec event Data"); 359 GKI_freebuf (p_data); 360 return; 361 362 case RFC_EVENT_UIH: 363 GKI_freebuf (p_data); 364 return; 365 } 366 RFCOMM_TRACE_WARNING ("Port state orig_wait_sec_check Event ignored %d", event); 367 } 368 369 370 /******************************************************************************* 371 ** 372 ** Function rfc_port_sm_opened 373 ** 374 ** Description This function handles events for the port in the OPENED 375 ** state 376 ** 377 ** Returns void 378 ** 379 *******************************************************************************/ 380 void rfc_port_sm_opened (tPORT *p_port, UINT16 event, void *p_data) 381 { 382 switch (event) 383 { 384 case RFC_EVENT_OPEN: 385 RFCOMM_TRACE_ERROR ("Port error state %d event %d", p_port->rfc.state, event); 386 return; 387 388 case RFC_EVENT_CLOSE: 389 rfc_port_timer_start (p_port, RFC_DISC_TIMEOUT); 390 rfc_send_disc (p_port->rfc.p_mcb, p_port->dlci); 391 p_port->rfc.expected_rsp = 0; 392 p_port->rfc.state = RFC_STATE_DISC_WAIT_UA; 393 return; 394 395 case RFC_EVENT_CLEAR: 396 rfc_port_closed (p_port); 397 return; 398 399 case RFC_EVENT_DATA: 400 /* Send credits in the frame. Pass them in the layer specific member of the hdr. */ 401 /* There might be an initial case when we reduced rx_max and credit_rx is still */ 402 /* bigger. Make sure that we do not send 255 */ 403 if ((p_port->rfc.p_mcb->flow == PORT_FC_CREDIT) 404 && (((BT_HDR *)p_data)->len < p_port->peer_mtu) 405 && (!p_port->rx.user_fc) 406 && (p_port->credit_rx_max > p_port->credit_rx)) 407 { 408 ((BT_HDR *)p_data)->layer_specific = (UINT8) (p_port->credit_rx_max - p_port->credit_rx); 409 p_port->credit_rx = p_port->credit_rx_max; 410 } 411 else 412 { 413 ((BT_HDR *)p_data)->layer_specific = 0; 414 } 415 rfc_send_buf_uih (p_port->rfc.p_mcb, p_port->dlci, (BT_HDR *)p_data); 416 rfc_dec_credit (p_port); 417 return; 418 419 case RFC_EVENT_UA: 420 return; 421 422 case RFC_EVENT_SABME: 423 rfc_send_ua (p_port->rfc.p_mcb, p_port->dlci); 424 return; 425 426 case RFC_EVENT_DM: 427 PORT_DlcReleaseInd (p_port->rfc.p_mcb, p_port->dlci); 428 rfc_port_closed (p_port); 429 return; 430 431 case RFC_EVENT_DISC: 432 p_port->rfc.state = RFC_STATE_CLOSED; 433 rfc_send_ua (p_port->rfc.p_mcb, p_port->dlci); 434 if(p_port->rx.queue.count) 435 { 436 /* give a chance to upper stack to close port properly */ 437 RFCOMM_TRACE_DEBUG("port queue is not empty"); 438 rfc_port_timer_start (p_port, RFC_DISC_TIMEOUT); 439 } 440 else 441 PORT_DlcReleaseInd (p_port->rfc.p_mcb, p_port->dlci); 442 return; 443 444 case RFC_EVENT_UIH: 445 rfc_port_uplink_data (p_port, (BT_HDR *)p_data); 446 return; 447 448 case RFC_EVENT_TIMEOUT: 449 Port_TimeOutCloseMux( p_port->rfc.p_mcb ) ; 450 RFCOMM_TRACE_ERROR ("Port error state %d event %d", p_port->rfc.state, event); 451 return; 452 } 453 RFCOMM_TRACE_WARNING ("Port state opened Event ignored %d", event); 454 } 455 456 457 /******************************************************************************* 458 ** 459 ** Function rfc_port_sm_disc_wait_ua 460 ** 461 ** Description This function handles events when DISC on the DLC was 462 ** sent and SM is waiting for UA or DM. 463 ** 464 ** Returns void 465 ** 466 *******************************************************************************/ 467 void rfc_port_sm_disc_wait_ua (tPORT *p_port, UINT16 event, void *p_data) 468 { 469 switch (event) 470 { 471 case RFC_EVENT_OPEN: 472 case RFC_EVENT_ESTABLISH_RSP: 473 RFCOMM_TRACE_ERROR ("Port error state %d event %d", p_port->rfc.state, event); 474 return; 475 476 case RFC_EVENT_CLEAR: 477 rfc_port_closed (p_port); 478 return; 479 480 case RFC_EVENT_DATA: 481 GKI_freebuf (p_data); 482 return; 483 484 case RFC_EVENT_UA: 485 p_port->rfc.p_mcb->is_disc_initiator = TRUE; 486 /* Case falls through */ 487 488 case RFC_EVENT_DM: 489 rfc_port_closed (p_port); 490 return; 491 492 case RFC_EVENT_SABME: 493 rfc_send_dm (p_port->rfc.p_mcb, p_port->dlci, TRUE); 494 return; 495 496 case RFC_EVENT_DISC: 497 rfc_send_dm (p_port->rfc.p_mcb, p_port->dlci, TRUE); 498 return; 499 500 case RFC_EVENT_UIH: 501 GKI_freebuf (p_data); 502 rfc_send_dm (p_port->rfc.p_mcb, p_port->dlci, FALSE); 503 return; 504 505 case RFC_EVENT_TIMEOUT: 506 rfc_port_closed (p_port); 507 return; 508 } 509 510 RFCOMM_TRACE_WARNING ("Port state disc_wait_ua Event ignored %d", event); 511 } 512 513 514 /******************************************************************************* 515 ** 516 ** Function rfc_port_uplink_data 517 ** 518 ** Description This function handles uplink information data frame. 519 ** 520 *******************************************************************************/ 521 void rfc_port_uplink_data (tPORT *p_port, BT_HDR *p_buf) 522 { 523 PORT_DataInd (p_port->rfc.p_mcb, p_port->dlci, p_buf); 524 } 525 526 527 /******************************************************************************* 528 ** 529 ** Function rfc_process_pn 530 ** 531 ** Description This function handles DLC parameter negotiation frame. 532 ** Record MTU and pass indication to the upper layer. 533 ** 534 *******************************************************************************/ 535 void rfc_process_pn (tRFC_MCB *p_mcb, BOOLEAN is_command, MX_FRAME *p_frame) 536 { 537 tPORT *p_port; 538 UINT8 dlci = p_frame->dlci; 539 540 if (is_command) 541 { 542 /* Ignore if Multiplexer is being shut down */ 543 if (p_mcb->state != RFC_MX_STATE_DISC_WAIT_UA) 544 { 545 PORT_ParNegInd (p_mcb, dlci, p_frame->u.pn.mtu, 546 p_frame->u.pn.conv_layer, p_frame->u.pn.k); 547 } 548 else 549 { 550 rfc_send_dm(p_mcb, dlci, FALSE); 551 RFCOMM_TRACE_WARNING("***** MX PN while disconnecting *****"); 552 } 553 554 return; 555 } 556 /* If we are not awaiting response just ignore it */ 557 p_port = port_find_mcb_dlci_port (p_mcb, dlci); 558 if ((p_port == NULL) || !(p_port->rfc.expected_rsp & RFC_RSP_PN)) 559 return; 560 561 p_port->rfc.expected_rsp &= ~RFC_RSP_PN; 562 563 rfc_port_timer_stop (p_port); 564 565 PORT_ParNegCnf (p_mcb, dlci, p_frame->u.pn.mtu, 566 p_frame->u.pn.conv_layer, p_frame->u.pn.k); 567 } 568 569 570 /******************************************************************************* 571 ** 572 ** Function rfc_process_rpn 573 ** 574 ** Description This function handles Remote DLC parameter negotiation 575 ** command/response. Pass command to the user. 576 ** 577 *******************************************************************************/ 578 void rfc_process_rpn (tRFC_MCB *p_mcb, BOOLEAN is_command, 579 BOOLEAN is_request, MX_FRAME *p_frame) 580 { 581 tPORT_STATE port_pars; 582 tPORT *p_port; 583 584 if ((p_port = port_find_mcb_dlci_port (p_mcb, p_frame->dlci)) == NULL) 585 { 586 /* This is the first command on the port */ 587 if (is_command) 588 { 589 590 memset(&port_pars, 0, sizeof(tPORT_STATE)); 591 rfc_set_port_state(&port_pars, p_frame); 592 593 PORT_PortNegInd(p_mcb, p_frame->dlci, &port_pars, p_frame->u.rpn.param_mask); 594 } 595 return; 596 } 597 598 if (is_command && is_request) 599 { 600 /* This is the special situation when peer just request local pars */ 601 port_pars = p_port->peer_port_pars; 602 rfc_send_rpn (p_mcb, p_frame->dlci, FALSE, &p_port->peer_port_pars, 0); 603 return; 604 } 605 606 port_pars = p_port->peer_port_pars; 607 608 rfc_set_port_state(&port_pars, p_frame); 609 610 if (is_command) 611 { 612 PORT_PortNegInd (p_mcb, p_frame->dlci, &port_pars, p_frame->u.rpn.param_mask); 613 return; 614 } 615 616 /* If we are not awaiting response just ignore it */ 617 p_port = port_find_mcb_dlci_port (p_mcb, p_frame->dlci); 618 if ((p_port == NULL) || !(p_port->rfc.expected_rsp & (RFC_RSP_RPN | RFC_RSP_RPN_REPLY))) 619 return; 620 621 /* If we sent a request for port parameters to the peer he is replying with */ 622 /* mask 0. */ 623 rfc_port_timer_stop (p_port); 624 625 if (p_port->rfc.expected_rsp & RFC_RSP_RPN_REPLY) 626 { 627 p_port->rfc.expected_rsp &= ~RFC_RSP_RPN_REPLY; 628 629 p_port->peer_port_pars = port_pars; 630 631 if ((port_pars.fc_type == (RFCOMM_FC_RTR_ON_INPUT | RFCOMM_FC_RTR_ON_OUTPUT)) 632 || (port_pars.fc_type == (RFCOMM_FC_RTC_ON_INPUT | RFCOMM_FC_RTC_ON_OUTPUT))) 633 { 634 /* This is satisfactory port parameters. Set mask as it was Ok */ 635 p_frame->u.rpn.param_mask = RFCOMM_RPN_PM_MASK; 636 } 637 else 638 { 639 /* Current peer parameters are not good, try to fix them */ 640 p_port->peer_port_pars.fc_type = (RFCOMM_FC_RTR_ON_INPUT | RFCOMM_FC_RTR_ON_OUTPUT); 641 642 p_port->rfc.expected_rsp |= RFC_RSP_RPN; 643 rfc_send_rpn (p_mcb, p_frame->dlci, TRUE, &p_port->peer_port_pars, 644 RFCOMM_RPN_PM_RTR_ON_INPUT | RFCOMM_RPN_PM_RTR_ON_OUTPUT); 645 rfc_port_timer_start (p_port, RFC_T2_TIMEOUT) ; 646 return; 647 } 648 } 649 else 650 p_port->rfc.expected_rsp &= ~RFC_RSP_RPN; 651 652 /* Check if all suggested parameters were accepted */ 653 if (((p_frame->u.rpn.param_mask & (RFCOMM_RPN_PM_RTR_ON_INPUT | RFCOMM_RPN_PM_RTR_ON_OUTPUT)) == 654 (RFCOMM_RPN_PM_RTR_ON_INPUT | RFCOMM_RPN_PM_RTR_ON_OUTPUT)) 655 || ((p_frame->u.rpn.param_mask & (RFCOMM_RPN_PM_RTC_ON_INPUT | RFCOMM_RPN_PM_RTC_ON_OUTPUT)) == 656 (RFCOMM_RPN_PM_RTC_ON_INPUT | RFCOMM_RPN_PM_RTC_ON_OUTPUT))) 657 { 658 PORT_PortNegCnf (p_mcb, p_port->dlci, &port_pars, RFCOMM_SUCCESS); 659 return; 660 } 661 662 /* If we were proposing RTR flow control try RTC flow control */ 663 /* If we were proposing RTC flow control try no flow control */ 664 /* otherwise drop the connection */ 665 if (p_port->peer_port_pars.fc_type == (RFCOMM_FC_RTR_ON_INPUT | RFCOMM_FC_RTR_ON_OUTPUT)) 666 { 667 /* Current peer parameters are not good, try to fix them */ 668 p_port->peer_port_pars.fc_type = (RFCOMM_FC_RTC_ON_INPUT | RFCOMM_FC_RTC_ON_OUTPUT); 669 670 p_port->rfc.expected_rsp |= RFC_RSP_RPN; 671 672 rfc_send_rpn (p_mcb, p_frame->dlci, TRUE, &p_port->peer_port_pars, 673 RFCOMM_RPN_PM_RTC_ON_INPUT | RFCOMM_RPN_PM_RTC_ON_OUTPUT); 674 rfc_port_timer_start (p_port, RFC_T2_TIMEOUT) ; 675 return; 676 } 677 678 /* Other side does not support flow control */ 679 if (p_port->peer_port_pars.fc_type == (RFCOMM_FC_RTC_ON_INPUT | RFCOMM_FC_RTC_ON_OUTPUT)) 680 { 681 p_port->peer_port_pars.fc_type = RFCOMM_FC_OFF; 682 PORT_PortNegCnf (p_mcb, p_port->dlci, &port_pars, RFCOMM_SUCCESS); 683 } 684 } 685 686 687 /******************************************************************************* 688 ** 689 ** Function rfc_process_msc 690 ** 691 ** Description This function handles Modem Status Command. 692 ** Pass command to the user. 693 ** 694 *******************************************************************************/ 695 void rfc_process_msc (tRFC_MCB *p_mcb, BOOLEAN is_command, MX_FRAME *p_frame) 696 { 697 tPORT_CTRL pars; 698 tPORT *p_port; 699 UINT8 modem_signals = p_frame->u.msc.signals; 700 BOOLEAN new_peer_fc = FALSE; 701 702 p_port = port_find_mcb_dlci_port (p_mcb, p_frame->dlci); 703 if (p_port == NULL) 704 return; 705 706 pars.modem_signal = 0; 707 708 if (modem_signals & RFCOMM_MSC_RTC) 709 pars.modem_signal |= MODEM_SIGNAL_DTRDSR; 710 711 if (modem_signals & RFCOMM_MSC_RTR) 712 pars.modem_signal |= MODEM_SIGNAL_RTSCTS; 713 714 if (modem_signals & RFCOMM_MSC_IC) 715 pars.modem_signal |= MODEM_SIGNAL_RI; 716 717 if (modem_signals & RFCOMM_MSC_DV) 718 pars.modem_signal |= MODEM_SIGNAL_DCD; 719 720 pars.fc = ((modem_signals & RFCOMM_MSC_FC) == RFCOMM_MSC_FC); 721 722 pars.break_signal = (p_frame->u.msc.break_present) ? 723 p_frame->u.msc.break_duration : 0; 724 pars.discard_buffers = 0; 725 pars.break_signal_seq = RFCOMM_CTRL_BREAK_IN_SEQ; /* this is default */ 726 727 /* Check if this command is passed only to indicate flow control */ 728 if (is_command) 729 { 730 rfc_send_msc (p_mcb, p_frame->dlci, FALSE, &pars); 731 732 if (p_port->rfc.p_mcb->flow != PORT_FC_CREDIT) 733 { 734 /* Spec 1.1 indicates that only FC bit is used for flow control */ 735 p_port->peer_ctrl.fc = new_peer_fc = pars.fc; 736 737 if (new_peer_fc != p_port->tx.peer_fc) 738 PORT_FlowInd (p_mcb, p_frame->dlci, (BOOLEAN)!new_peer_fc); 739 } 740 741 PORT_ControlInd (p_mcb, p_frame->dlci, &pars); 742 743 return; 744 } 745 746 /* If we are not awaiting response just ignore it */ 747 if (!(p_port->rfc.expected_rsp & RFC_RSP_MSC)) 748 return; 749 750 p_port->rfc.expected_rsp &= ~RFC_RSP_MSC; 751 752 rfc_port_timer_stop (p_port); 753 754 PORT_ControlCnf (p_port->rfc.p_mcb, p_port->dlci, &pars); 755 } 756 757 758 /******************************************************************************* 759 ** 760 ** Function rfc_process_rls 761 ** 762 ** Description This function handles Remote Line Status command. 763 ** Pass command to the user. 764 ** 765 *******************************************************************************/ 766 void rfc_process_rls (tRFC_MCB *p_mcb, BOOLEAN is_command, MX_FRAME *p_frame) 767 { 768 tPORT *p_port; 769 770 if (is_command) 771 { 772 PORT_LineStatusInd (p_mcb, p_frame->dlci, p_frame->u.rls.line_status); 773 rfc_send_rls (p_mcb, p_frame->dlci, FALSE, p_frame->u.rls.line_status); 774 } 775 else 776 { 777 p_port = port_find_mcb_dlci_port (p_mcb, p_frame->dlci); 778 779 /* If we are not awaiting response just ignore it */ 780 if (!p_port || !(p_port->rfc.expected_rsp & RFC_RSP_RLS)) 781 return; 782 783 p_port->rfc.expected_rsp &= ~RFC_RSP_RLS; 784 785 rfc_port_timer_stop (p_port); 786 } 787 } 788 789 790 /******************************************************************************* 791 ** 792 ** Function rfc_process_nsc 793 ** 794 ** Description This function handles None Supported Command frame. 795 ** 796 *******************************************************************************/ 797 void rfc_process_nsc (tRFC_MCB *p_mcb, MX_FRAME *p_frame) 798 { 799 UNUSED(p_mcb); 800 UNUSED(p_frame); 801 } 802 803 804 /******************************************************************************* 805 ** 806 ** Function rfc_process_test 807 ** 808 ** Description This function handles Test frame. If this is a command 809 ** reply to it. Otherwise pass response to the user. 810 ** 811 *******************************************************************************/ 812 void rfc_process_test_rsp (tRFC_MCB *p_mcb, BT_HDR *p_buf) 813 { 814 UNUSED(p_mcb); 815 816 GKI_freebuf (p_buf); 817 } 818 819 820 /******************************************************************************* 821 ** 822 ** Function rfc_process_fcon 823 ** 824 ** Description This function handles FCON frame. The peer entity is able 825 ** to receive new information 826 ** 827 *******************************************************************************/ 828 void rfc_process_fcon (tRFC_MCB *p_mcb, BOOLEAN is_command) 829 { 830 if (is_command) 831 { 832 rfc_cb.rfc.peer_rx_disabled = FALSE; 833 834 rfc_send_fcon (p_mcb, FALSE); 835 836 if (!p_mcb->l2cap_congested) 837 PORT_FlowInd (p_mcb, 0, TRUE); 838 } 839 } 840 841 /******************************************************************************* 842 ** 843 ** Function rfc_process_fcoff 844 ** 845 ** Description This function handles FCOFF frame. The peer entity is unable 846 ** to receive new information 847 ** 848 *******************************************************************************/ 849 void rfc_process_fcoff (tRFC_MCB *p_mcb, BOOLEAN is_command) 850 { 851 if (is_command) 852 { 853 rfc_cb.rfc.peer_rx_disabled = TRUE; 854 855 if (!p_mcb->l2cap_congested) 856 PORT_FlowInd (p_mcb, 0, FALSE); 857 858 rfc_send_fcoff (p_mcb, FALSE); 859 } 860 } 861 862 863 /******************************************************************************* 864 ** 865 ** Function rfc_process_l2cap_congestion 866 ** 867 ** Description This function handles L2CAP congestion messages 868 ** 869 *******************************************************************************/ 870 void rfc_process_l2cap_congestion (tRFC_MCB *p_mcb, BOOLEAN is_congested) 871 { 872 p_mcb->l2cap_congested = is_congested; 873 874 if (!is_congested) 875 { 876 rfc_check_send_cmd(p_mcb, NULL); 877 } 878 879 if (!rfc_cb.rfc.peer_rx_disabled) 880 { 881 if (!is_congested) 882 PORT_FlowInd (p_mcb, 0, TRUE); 883 else 884 PORT_FlowInd (p_mcb, 0, FALSE); 885 } 886 } 887 888 /******************************************************************************* 889 ** 890 ** Function rfc_set_port_pars 891 ** 892 ** Description This function sets the tPORT_STATE structure given a p_frame. 893 ** 894 *******************************************************************************/ 895 896 void rfc_set_port_state(tPORT_STATE *port_pars, MX_FRAME *p_frame) 897 { 898 if (p_frame->u.rpn.param_mask & RFCOMM_RPN_PM_BIT_RATE) 899 port_pars->baud_rate = p_frame->u.rpn.baud_rate; 900 if (p_frame->u.rpn.param_mask & RFCOMM_RPN_PM_DATA_BITS) 901 port_pars->byte_size = p_frame->u.rpn.byte_size; 902 if (p_frame->u.rpn.param_mask & RFCOMM_RPN_PM_STOP_BITS) 903 port_pars->stop_bits = p_frame->u.rpn.stop_bits; 904 if (p_frame->u.rpn.param_mask & RFCOMM_RPN_PM_PARITY) 905 port_pars->parity = p_frame->u.rpn.parity; 906 if (p_frame->u.rpn.param_mask & RFCOMM_RPN_PM_PARITY_TYPE) 907 port_pars->parity_type = p_frame->u.rpn.parity_type; 908 if (p_frame->u.rpn.param_mask & (RFCOMM_RPN_PM_XONXOFF_ON_INPUT | 909 RFCOMM_RPN_PM_XONXOFF_ON_OUTPUT | 910 RFCOMM_RPN_PM_RTR_ON_INPUT | 911 RFCOMM_RPN_PM_RTR_ON_OUTPUT | 912 RFCOMM_RPN_PM_RTC_ON_INPUT | 913 RFCOMM_RPN_PM_RTC_ON_OUTPUT)) 914 port_pars->fc_type = p_frame->u.rpn.fc_type; 915 if (p_frame->u.rpn.param_mask & RFCOMM_RPN_PM_XON_CHAR) 916 port_pars->xon_char = p_frame->u.rpn.xon_char; 917 if (p_frame->u.rpn.param_mask & RFCOMM_RPN_PM_XOFF_CHAR) 918 port_pars->xoff_char = p_frame->u.rpn.xoff_char; 919 } 920 921
