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/********************************************************************************/ 39static void rfc_port_sm_state_closed (tPORT *p_port, UINT16 event, void *p_data); 40static void rfc_port_sm_sabme_wait_ua (tPORT *p_port, UINT16 event, void *p_data); 41static void rfc_port_sm_opened (tPORT *p_port, UINT16 event, void *p_data); 42static void rfc_port_sm_orig_wait_sec_check (tPORT *p_port, UINT16 event, void *p_data); 43static void rfc_port_sm_term_wait_sec_check (tPORT *p_port, UINT16 event, void *p_data); 44static void rfc_port_sm_disc_wait_ua (tPORT *p_port, UINT16 event, void *p_data); 45 46static void rfc_port_uplink_data (tPORT *p_port, BT_HDR *p_buf); 47 48static 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*******************************************************************************/ 61void 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*******************************************************************************/ 109void 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*******************************************************************************/ 177void 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*******************************************************************************/ 249void 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*******************************************************************************/ 330void 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*******************************************************************************/ 380void 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*******************************************************************************/ 467void 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*******************************************************************************/ 521void 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*******************************************************************************/ 535void 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*******************************************************************************/ 578void 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*******************************************************************************/ 695void 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*******************************************************************************/ 766void 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*******************************************************************************/ 797void 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*******************************************************************************/ 812void 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*******************************************************************************/ 828void 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*******************************************************************************/ 849void 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*******************************************************************************/ 870void 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 896void 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