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 module contains functions for port emulation entity and RFCOMM 22 * communications 23 * 24 ******************************************************************************/ 25 #include <string.h> 26 27 #include "osi/include/mutex.h" 28 #include "osi/include/osi.h" 29 30 #include "bt_common.h" 31 #include "bt_target.h" 32 #include "bt_utils.h" 33 #include "btm_api.h" 34 #include "btm_int.h" 35 #include "port_api.h" 36 #include "port_int.h" 37 #include "rfc_int.h" 38 #include "rfcdefs.h" 39 40 /* 41 * Local function definitions 42 */ 43 uint32_t port_rfc_send_tx_data(tPORT* p_port); 44 void port_rfc_closed(tPORT* p_port, uint8_t res); 45 void port_get_credits(tPORT* p_port, uint8_t k); 46 47 /******************************************************************************* 48 * 49 * Function port_open_continue 50 * 51 * Description This function is called after security manager completes 52 * required security checks. 53 * 54 * Returns void 55 * 56 ******************************************************************************/ 57 int port_open_continue(tPORT* p_port) { 58 tRFC_MCB* p_mcb; 59 60 RFCOMM_TRACE_EVENT("port_open_continue, p_port:%p", p_port); 61 62 /* Check if multiplexer channel has already been established */ 63 p_mcb = rfc_alloc_multiplexer_channel(p_port->bd_addr, true); 64 if (p_mcb == NULL) { 65 RFCOMM_TRACE_WARNING("port_open_continue no mx channel"); 66 port_release_port(p_port); 67 return (PORT_NO_RESOURCES); 68 } 69 70 p_port->rfc.p_mcb = p_mcb; 71 72 p_mcb->port_inx[p_port->dlci] = p_port->inx; 73 74 /* Connection is up and we know local and remote features, select MTU */ 75 port_select_mtu(p_port); 76 77 if (p_mcb->state == RFC_MX_STATE_CONNECTED) { 78 RFCOMM_ParNegReq(p_mcb, p_port->dlci, p_port->mtu); 79 } else if ((p_mcb->state == RFC_MX_STATE_IDLE) || 80 (p_mcb->state == RFC_MX_STATE_DISC_WAIT_UA)) { 81 /* In RFC_MX_STATE_IDLE state, MX state machine will create connection */ 82 /* In RFC_MX_STATE_DISC_WAIT_UA state, MX state machine will recreate 83 * connection */ 84 /* after disconnecting is completed */ 85 RFCOMM_StartReq(p_mcb); 86 } else { 87 /* MX state machine ignores RFC_MX_EVENT_START_REQ in these states */ 88 /* When it enters RFC_MX_STATE_CONNECTED, it will check any openning ports 89 */ 90 RFCOMM_TRACE_DEBUG( 91 "port_open_continue: mx state(%d) mx channel is openning", 92 p_mcb->state); 93 } 94 return (PORT_SUCCESS); 95 } 96 97 /******************************************************************************* 98 * 99 * Function port_start_control 100 * 101 * Description This function is called in the BTU_TASK context to 102 * send control information 103 * 104 * Returns void 105 * 106 ******************************************************************************/ 107 void port_start_control(tPORT* p_port) { 108 tRFC_MCB* p_mcb = p_port->rfc.p_mcb; 109 110 if (p_mcb == NULL) return; 111 112 RFCOMM_ControlReq(p_mcb, p_port->dlci, &p_port->local_ctrl); 113 } 114 115 /******************************************************************************* 116 * 117 * Function port_start_par_neg 118 * 119 * Description This function is called in the BTU_TASK context to 120 * send configuration information 121 * 122 * Returns void 123 * 124 ******************************************************************************/ 125 void port_start_par_neg(tPORT* p_port) { 126 tRFC_MCB* p_mcb = p_port->rfc.p_mcb; 127 128 if (p_mcb == NULL) return; 129 130 RFCOMM_PortNegReq(p_mcb, p_port->dlci, &p_port->user_port_pars); 131 } 132 133 /******************************************************************************* 134 * 135 * Function port_start_close 136 * 137 * Description This function is called in the BTU_TASK context to 138 * release DLC 139 * 140 * Returns void 141 * 142 ******************************************************************************/ 143 void port_start_close(tPORT* p_port) { 144 tRFC_MCB* p_mcb = p_port->rfc.p_mcb; 145 uint8_t old_signals; 146 uint32_t events = 0; 147 148 /* At first indicate to the user that signals on the connection were dropped 149 */ 150 p_port->line_status |= LINE_STATUS_FAILED; 151 old_signals = p_port->peer_ctrl.modem_signal; 152 153 p_port->peer_ctrl.modem_signal &= 154 ~(PORT_DTRDSR_ON | PORT_CTSRTS_ON | PORT_DCD_ON); 155 156 events |= port_get_signal_changes(p_port, old_signals, 157 p_port->peer_ctrl.modem_signal); 158 159 if (p_port->ev_mask & PORT_EV_CONNECT_ERR) events |= PORT_EV_CONNECT_ERR; 160 161 if (p_port->ev_mask & PORT_EV_ERR) events |= PORT_EV_ERR; 162 163 if ((p_port->p_callback != NULL) && events) 164 p_port->p_callback(events, p_port->inx); 165 166 /* Check if RFCOMM side has been closed while the message was queued */ 167 if ((p_mcb == NULL) || (p_port->rfc.state == RFC_STATE_CLOSED)) { 168 /* Call management callback function before calling port_release_port() to 169 * clear tPort */ 170 if (p_port->p_mgmt_callback) 171 p_port->p_mgmt_callback(PORT_CLOSED, p_port->inx); 172 173 port_release_port(p_port); 174 } else { 175 RFCOMM_DlcReleaseReq(p_mcb, p_port->dlci); 176 } 177 } 178 179 /******************************************************************************* 180 * 181 * Function PORT_StartCnf 182 * 183 * Description This function is called from the RFCOMM layer when 184 * establishing of the multiplexer channel is completed. 185 * Continue establishing of the connection for all ports that 186 * are in the OPENING state 187 * 188 ******************************************************************************/ 189 void PORT_StartCnf(tRFC_MCB* p_mcb, uint16_t result) { 190 tPORT* p_port; 191 int i; 192 bool no_ports_up = true; 193 194 RFCOMM_TRACE_EVENT("PORT_StartCnf result:%d", result); 195 196 p_port = &rfc_cb.port.port[0]; 197 for (i = 0; i < MAX_RFC_PORTS; i++, p_port++) { 198 if (p_port->rfc.p_mcb == p_mcb) { 199 no_ports_up = false; 200 201 if (result == RFCOMM_SUCCESS) 202 RFCOMM_ParNegReq(p_mcb, p_port->dlci, p_port->mtu); 203 else { 204 RFCOMM_TRACE_WARNING("PORT_StartCnf failed result:%d", result); 205 206 /* Warning: result is also set to 4 when l2cap connection 207 fails due to l2cap connect cnf (no_resources) */ 208 if (result == HCI_ERR_PAGE_TIMEOUT) 209 p_port->error = PORT_PAGE_TIMEOUT; 210 else 211 p_port->error = PORT_START_FAILED; 212 213 rfc_release_multiplexer_channel(p_mcb); 214 215 /* Send event to the application */ 216 if (p_port->p_callback && (p_port->ev_mask & PORT_EV_CONNECT_ERR)) 217 (p_port->p_callback)(PORT_EV_CONNECT_ERR, p_port->inx); 218 219 if (p_port->p_mgmt_callback) 220 p_port->p_mgmt_callback(PORT_START_FAILED, p_port->inx); 221 222 port_release_port(p_port); 223 } 224 } 225 } 226 227 /* There can be a situation when after starting connection, user closes the */ 228 /* port, we can catch it here to close multiplexor channel */ 229 if (no_ports_up) { 230 rfc_check_mcb_active(p_mcb); 231 } 232 } 233 234 /******************************************************************************* 235 * 236 * Function PORT_StartInd 237 * 238 * Description This function is called from the RFCOMM layer when 239 * some peer device wants to establish a multiplexer 240 * connection. Check if there are any ports open with this 241 * or not assigned multiplexer. 242 * 243 ******************************************************************************/ 244 void PORT_StartInd(tRFC_MCB* p_mcb) { 245 tPORT* p_port; 246 int i; 247 248 RFCOMM_TRACE_EVENT("PORT_StartInd"); 249 250 p_port = &rfc_cb.port.port[0]; 251 for (i = 0; i < MAX_RFC_PORTS; i++, p_port++) { 252 if ((p_port->rfc.p_mcb == NULL) || (p_port->rfc.p_mcb == p_mcb)) { 253 RFCOMM_TRACE_DEBUG( 254 "PORT_StartInd, RFCOMM_StartRsp RFCOMM_SUCCESS: p_mcb:%p", p_mcb); 255 RFCOMM_StartRsp(p_mcb, RFCOMM_SUCCESS); 256 return; 257 } 258 } 259 RFCOMM_StartRsp(p_mcb, RFCOMM_ERROR); 260 } 261 262 /******************************************************************************* 263 * 264 * Function PORT_ParNegInd 265 * 266 * Description This function is called from the RFCOMM layer to change 267 * DLCI parameters (currently only MTU is negotiated). 268 * If can not find the port do not accept the request. 269 * Otherwise save the MTU size supported by the peer. 270 * 271 ******************************************************************************/ 272 void PORT_ParNegInd(tRFC_MCB* p_mcb, uint8_t dlci, uint16_t mtu, uint8_t cl, 273 uint8_t k) { 274 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 275 uint8_t our_cl; 276 uint8_t our_k; 277 278 RFCOMM_TRACE_EVENT("PORT_ParNegInd dlci:%d mtu:%d", dlci, mtu); 279 280 if (!p_port) { 281 /* This can be a first request for this port */ 282 p_port = port_find_dlci_port(dlci); 283 if (!p_port) { 284 /* If the port cannot be opened, send a DM. Per Errata 1205 */ 285 rfc_send_dm(p_mcb, dlci, false); 286 /* check if this is the last port open, some headsets have 287 problem, they don't disconnect if we send DM */ 288 rfc_check_mcb_active(p_mcb); 289 RFCOMM_TRACE_EVENT("PORT_ParNegInd: port not found"); 290 return; 291 } 292 p_mcb->port_inx[dlci] = p_port->inx; 293 } 294 295 memcpy(p_port->bd_addr, p_mcb->bd_addr, BD_ADDR_LEN); 296 297 /* Connection is up and we know local and remote features, select MTU */ 298 port_select_mtu(p_port); 299 300 p_port->rfc.p_mcb = p_mcb; 301 p_port->mtu = (p_port->mtu < mtu) ? p_port->mtu : mtu; 302 p_port->peer_mtu = p_port->mtu; 303 304 /* Negotiate the flow control mechanism. If flow control mechanism for */ 305 /* mux has not been set yet, set it now. If either we or peer wants TS 07.10, 306 */ 307 /* use that. Otherwise both must want credit based, so use that. If flow is 308 */ 309 /* already defined for this mux, we respond with that value. */ 310 if (p_mcb->flow == PORT_FC_UNDEFINED) { 311 if ((PORT_FC_DEFAULT == PORT_FC_TS710) || 312 (cl == RFCOMM_PN_CONV_LAYER_TYPE_1)) { 313 p_mcb->flow = PORT_FC_TS710; 314 } else { 315 p_mcb->flow = PORT_FC_CREDIT; 316 } 317 } 318 319 /* Regardless of our flow control mechanism, if the PN cl is zero, we must */ 320 /* respond with zero. "A responding implementation must set this field to 14 321 */ 322 /* if (and only if) the PN request was 15." This could happen if a PN is sent 323 */ 324 /* after the DLCI is already established-- the PN in that case must have cl = 325 * 0. */ 326 /* See RFCOMM spec 5.5.3 */ 327 if (cl == RFCOMM_PN_CONV_LAYER_TYPE_1) { 328 our_cl = RFCOMM_PN_CONV_LAYER_TYPE_1; 329 our_k = 0; 330 } else if (p_mcb->flow == PORT_FC_CREDIT) { 331 /* get credits */ 332 port_get_credits(p_port, k); 333 334 /* Set convergence layer and number of credits (k) */ 335 our_cl = RFCOMM_PN_CONV_LAYER_CBFC_R; 336 our_k = (p_port->credit_rx_max < RFCOMM_K_MAX) ? p_port->credit_rx_max 337 : RFCOMM_K_MAX; 338 p_port->credit_rx = our_k; 339 } else { 340 /* must not be using credit based flow control; use TS 7.10 */ 341 our_cl = RFCOMM_PN_CONV_LAYER_TYPE_1; 342 our_k = 0; 343 } 344 RFCOMM_ParNegRsp(p_mcb, dlci, p_port->mtu, our_cl, our_k); 345 } 346 347 /******************************************************************************* 348 * 349 * Function PORT_ParNegCnf 350 * 351 * Description This function is called from the RFCOMM layer to change 352 * DLCI parameters (currently only MTU is negotiated). 353 * Save the MTU size supported by the peer. 354 * If the confirmation is received during the port opening 355 * procedure send EstablishRequest to continue. 356 * 357 ******************************************************************************/ 358 void PORT_ParNegCnf(tRFC_MCB* p_mcb, uint8_t dlci, uint16_t mtu, uint8_t cl, 359 uint8_t k) { 360 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 361 362 RFCOMM_TRACE_EVENT("PORT_ParNegCnf dlci:%d mtu:%d cl: %d k: %d", dlci, mtu, 363 cl, k); 364 365 if (!p_port) return; 366 367 /* Flow control mechanism not set yet. Negotiate flow control mechanism. */ 368 if (p_mcb->flow == PORT_FC_UNDEFINED) { 369 /* Our stack is configured for TS07.10 and they responded with credit-based. 370 */ 371 /* This is illegal-- negotiation fails. */ 372 if ((PORT_FC_DEFAULT == PORT_FC_TS710) && 373 (cl == RFCOMM_PN_CONV_LAYER_CBFC_R)) { 374 rfc_send_disc(p_mcb, p_port->dlci); 375 rfc_port_closed(p_port); 376 return; 377 } 378 /* Our stack is configured for credit-based and they responded with 379 credit-based. */ 380 else if (cl == RFCOMM_PN_CONV_LAYER_CBFC_R) { 381 p_mcb->flow = PORT_FC_CREDIT; 382 } 383 /* They responded with any other value. Treat this as negotiation to 384 TS07.10. */ 385 else { 386 p_mcb->flow = PORT_FC_TS710; 387 } 388 } 389 /* If mux flow control mechanism set, we honor that setting regardless of */ 390 /* the CL value in their response. This allows us to gracefully accept any */ 391 /* illegal PN negotiation scenarios. */ 392 393 p_port->mtu = (p_port->mtu < mtu) ? p_port->mtu : mtu; 394 p_port->peer_mtu = p_port->mtu; 395 396 if (p_mcb->flow == PORT_FC_CREDIT) { 397 port_get_credits(p_port, k); 398 } 399 400 if (p_port->state == PORT_STATE_OPENING) 401 RFCOMM_DlcEstablishReq(p_mcb, p_port->dlci, p_port->mtu); 402 } 403 404 /******************************************************************************* 405 * 406 * Function PORT_DlcEstablishInd 407 * 408 * Description This function is called from the RFCOMM layer when peer 409 * device wants to establish a new DLC. If this is not the 410 * first message in the establishment procedure port_handle 411 * has a handle to the port control block otherwise the control 412 * block should be found based on the muliplexer channel and 413 * dlci. The block should be allocated allocated before 414 * meaning that application already made open. 415 * 416 ******************************************************************************/ 417 void PORT_DlcEstablishInd(tRFC_MCB* p_mcb, uint8_t dlci, uint16_t mtu) { 418 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 419 420 RFCOMM_TRACE_DEBUG( 421 "PORT_DlcEstablishInd p_mcb:%p, dlci:%d mtu:%di, p_port:%p", p_mcb, dlci, 422 mtu, p_port); 423 RFCOMM_TRACE_DEBUG( 424 "PORT_DlcEstablishInd p_mcb addr:%02x:%02x:%02x:%02x:%02x:%02x", 425 p_mcb->bd_addr[0], p_mcb->bd_addr[1], p_mcb->bd_addr[2], 426 p_mcb->bd_addr[3], p_mcb->bd_addr[4], p_mcb->bd_addr[5]); 427 428 if (!p_port) { 429 /* This can be a first request for this port */ 430 p_port = port_find_dlci_port(dlci); 431 if (!p_port) { 432 RFCOMM_DlcEstablishRsp(p_mcb, dlci, 0, RFCOMM_ERROR); 433 return; 434 } 435 p_mcb->port_inx[dlci] = p_port->inx; 436 } 437 438 /* If L2CAP's mtu less then RFCOMM's take it */ 439 if (mtu && (mtu < p_port->peer_mtu)) p_port->peer_mtu = mtu; 440 441 /* If there was an inactivity timer running for MCB stop it */ 442 rfc_timer_stop(p_mcb); 443 444 RFCOMM_DlcEstablishRsp(p_mcb, dlci, p_port->mtu, RFCOMM_SUCCESS); 445 446 /* This is the server side. If application wants to know when connection */ 447 /* is established, thats the place */ 448 if (p_port->p_callback && (p_port->ev_mask & PORT_EV_CONNECTED)) 449 (p_port->p_callback)(PORT_EV_CONNECTED, p_port->inx); 450 451 if (p_port->p_mgmt_callback) 452 p_port->p_mgmt_callback(PORT_SUCCESS, p_port->inx); 453 454 p_port->state = PORT_STATE_OPENED; 455 } 456 457 /******************************************************************************* 458 * 459 * Function PORT_DlcEstablishCnf 460 * 461 * Description This function is called from the RFCOMM layer when peer 462 * acknowledges establish procedure (SABME/UA). Send reply 463 * to the user and set state to OPENED if result was 464 * successfull. 465 * 466 ******************************************************************************/ 467 void PORT_DlcEstablishCnf(tRFC_MCB* p_mcb, uint8_t dlci, uint16_t mtu, 468 uint16_t result) { 469 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 470 471 RFCOMM_TRACE_EVENT("PORT_DlcEstablishCnf dlci:%d mtu:%d result:%d", dlci, mtu, 472 result); 473 474 if (!p_port) return; 475 476 if (result != RFCOMM_SUCCESS) { 477 p_port->error = PORT_START_FAILED; 478 port_rfc_closed(p_port, PORT_START_FAILED); 479 return; 480 } 481 482 /* If L2CAP's mtu less then RFCOMM's take it */ 483 if (mtu && (mtu < p_port->peer_mtu)) p_port->peer_mtu = mtu; 484 485 /* If there was an inactivity timer running for MCB stop it */ 486 rfc_timer_stop(p_mcb); 487 488 if (p_port->p_callback && (p_port->ev_mask & PORT_EV_CONNECTED)) 489 (p_port->p_callback)(PORT_EV_CONNECTED, p_port->inx); 490 491 if (p_port->p_mgmt_callback) 492 p_port->p_mgmt_callback(PORT_SUCCESS, p_port->inx); 493 494 p_port->state = PORT_STATE_OPENED; 495 496 /* RPN is required only if we want to tell DTE how the port should be opened 497 */ 498 if ((p_port->uuid == UUID_SERVCLASS_DIALUP_NETWORKING) || 499 (p_port->uuid == UUID_SERVCLASS_FAX)) 500 RFCOMM_PortNegReq(p_port->rfc.p_mcb, p_port->dlci, NULL); 501 else 502 RFCOMM_ControlReq(p_port->rfc.p_mcb, p_port->dlci, &p_port->local_ctrl); 503 } 504 505 /******************************************************************************* 506 * 507 * Function PORT_PortNegInd 508 * 509 * Description This function is called from the RFCOMM layer when peer 510 * device wants to set parameters of the port. As per the spec 511 * this message has to be sent before the first data packet 512 * and can be sent before establish. The block should be 513 * allocated before meaning that application already made open. 514 * 515 ******************************************************************************/ 516 void PORT_PortNegInd(tRFC_MCB* p_mcb, uint8_t dlci, tPORT_STATE* p_pars, 517 uint16_t param_mask) { 518 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 519 520 RFCOMM_TRACE_EVENT("PORT_PortNegInd"); 521 522 if (!p_port) { 523 /* This can be a first request for this port */ 524 p_port = port_find_dlci_port(dlci); 525 if (!p_port) { 526 RFCOMM_PortNegRsp(p_mcb, dlci, p_pars, 0); 527 return; 528 } 529 p_mcb->port_inx[dlci] = p_port->inx; 530 } 531 532 /* Check if the flow control is acceptable on local side */ 533 p_port->peer_port_pars = *p_pars; 534 RFCOMM_PortNegRsp(p_mcb, dlci, p_pars, param_mask); 535 } 536 537 /******************************************************************************* 538 * 539 * Function PORT_PortNegCnf 540 * 541 * Description This function is called from the RFCOMM layer to change 542 * state for the port. Propagate change to the user. 543 * 544 ******************************************************************************/ 545 void PORT_PortNegCnf(tRFC_MCB* p_mcb, uint8_t dlci, 546 UNUSED_ATTR tPORT_STATE* p_pars, uint16_t result) { 547 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 548 549 RFCOMM_TRACE_EVENT("PORT_PortNegCnf"); 550 551 if (!p_port) { 552 RFCOMM_TRACE_WARNING("PORT_PortNegCnf no port"); 553 return; 554 } 555 /* Port negotiation failed. Drop the connection */ 556 if (result != RFCOMM_SUCCESS) { 557 p_port->error = PORT_PORT_NEG_FAILED; 558 559 RFCOMM_DlcReleaseReq(p_mcb, p_port->dlci); 560 561 port_rfc_closed(p_port, PORT_PORT_NEG_FAILED); 562 return; 563 } 564 565 if (!(p_port->port_ctrl & PORT_CTRL_REQ_SENT)) { 566 RFCOMM_ControlReq(p_port->rfc.p_mcb, p_port->dlci, &p_port->local_ctrl); 567 } else { 568 RFCOMM_TRACE_WARNING("PORT_PortNegCnf Control Already sent"); 569 } 570 } 571 572 /******************************************************************************* 573 * 574 * Function PORT_ControlInd 575 * 576 * Description This function is called from the RFCOMM layer on the modem 577 * signal change. Propagate change to the user. 578 * 579 ******************************************************************************/ 580 void PORT_ControlInd(tRFC_MCB* p_mcb, uint8_t dlci, tPORT_CTRL* p_pars) { 581 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 582 uint32_t event; 583 uint8_t old_signals; 584 585 RFCOMM_TRACE_EVENT("PORT_ControlInd"); 586 587 if (!p_port) return; 588 589 old_signals = p_port->peer_ctrl.modem_signal; 590 591 event = port_get_signal_changes(p_port, old_signals, p_pars->modem_signal); 592 593 p_port->peer_ctrl = *p_pars; 594 595 if (!(p_port->port_ctrl & PORT_CTRL_REQ_SENT)) 596 RFCOMM_ControlReq(p_port->rfc.p_mcb, p_port->dlci, &p_port->local_ctrl); 597 else { 598 /* If this is the first time we received control RFCOMM is connected */ 599 if (!(p_port->port_ctrl & PORT_CTRL_IND_RECEIVED)) { 600 event |= (PORT_EV_CONNECTED & p_port->ev_mask); 601 } 602 603 if (p_port->port_ctrl & PORT_CTRL_REQ_CONFIRMED) { 604 event |= port_rfc_send_tx_data(p_port); 605 } 606 } 607 608 p_port->port_ctrl |= (PORT_CTRL_IND_RECEIVED | PORT_CTRL_IND_RESPONDED); 609 610 if (p_pars->break_signal) event |= (PORT_EV_BREAK & p_port->ev_mask); 611 612 /* execute call back function only if the application is registered for events 613 */ 614 if (event && p_port->p_callback) (p_port->p_callback)(event, p_port->inx); 615 616 RFCOMM_TRACE_EVENT( 617 "PORT_ControlInd DTR_DSR : %d, RTS_CTS : %d, RI : %d, DCD : %d", 618 ((p_port->peer_ctrl.modem_signal & MODEM_SIGNAL_DTRDSR) ? 1 : 0), 619 ((p_port->peer_ctrl.modem_signal & MODEM_SIGNAL_RTSCTS) ? 1 : 0), 620 ((p_port->peer_ctrl.modem_signal & MODEM_SIGNAL_RI) ? 1 : 0), 621 ((p_port->peer_ctrl.modem_signal & MODEM_SIGNAL_DCD) ? 1 : 0)); 622 } 623 624 /******************************************************************************* 625 * 626 * Function PORT_ControlCnf 627 * 628 * Description This function is called from the RFCOMM layer when 629 * peer acknowleges change of the modem signals. 630 * 631 ******************************************************************************/ 632 void PORT_ControlCnf(tRFC_MCB* p_mcb, uint8_t dlci, 633 UNUSED_ATTR tPORT_CTRL* p_pars) { 634 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 635 uint32_t event = 0; 636 637 RFCOMM_TRACE_EVENT("PORT_ControlCnf"); 638 639 if (!p_port) return; 640 641 if (!(p_port->port_ctrl & PORT_CTRL_REQ_CONFIRMED)) { 642 p_port->port_ctrl |= PORT_CTRL_REQ_CONFIRMED; 643 644 if (p_port->port_ctrl & PORT_CTRL_IND_RECEIVED) 645 event = (p_port->ev_mask & PORT_EV_CONNECTED); 646 } 647 648 if (p_port->port_ctrl & PORT_CTRL_IND_RECEIVED) { 649 event |= port_rfc_send_tx_data(p_port); 650 } 651 652 /* execute call back function only if the application is registered for events 653 */ 654 if (event && p_port->p_callback) (p_port->p_callback)(event, p_port->inx); 655 } 656 657 /******************************************************************************* 658 * 659 * Function PORT_LineStatusInd 660 * 661 * Description This function is called from the RFCOMM layer when 662 * peer indicates change in the line status 663 * 664 ******************************************************************************/ 665 void PORT_LineStatusInd(tRFC_MCB* p_mcb, uint8_t dlci, uint8_t line_status) { 666 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 667 uint32_t event = 0; 668 669 RFCOMM_TRACE_EVENT("PORT_LineStatusInd"); 670 671 if (!p_port) return; 672 673 p_port->line_status |= line_status; 674 675 if (line_status & PORT_ERR_OVERRUN) event |= PORT_EV_OVERRUN; 676 677 if (line_status & PORT_ERR_BREAK) event |= PORT_EV_BREAK; 678 679 if (line_status & ~(PORT_ERR_OVERRUN | PORT_ERR_BREAK)) event |= PORT_EV_ERR; 680 681 if ((p_port->p_callback != NULL) && (p_port->ev_mask & event)) 682 p_port->p_callback((p_port->ev_mask & event), p_port->inx); 683 } 684 685 /******************************************************************************* 686 * 687 * Function PORT_DlcReleaseInd 688 * 689 * Description This function is called from the RFCOMM layer when 690 * DLC connection is released. 691 * 692 ******************************************************************************/ 693 void PORT_DlcReleaseInd(tRFC_MCB* p_mcb, uint8_t dlci) { 694 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 695 696 RFCOMM_TRACE_EVENT("PORT_DlcReleaseInd"); 697 698 if (!p_port) return; 699 700 port_rfc_closed(p_port, PORT_CLOSED); 701 } 702 703 /******************************************************************************* 704 * 705 * Function PORT_CloseInd 706 * 707 * Description This function is called from the RFCOMM layer when 708 * multiplexer connection is released. 709 * 710 ******************************************************************************/ 711 void PORT_CloseInd(tRFC_MCB* p_mcb) { 712 tPORT* p_port; 713 int i; 714 715 RFCOMM_TRACE_EVENT("PORT_CloseInd"); 716 717 p_port = &rfc_cb.port.port[0]; 718 for (i = 0; i < MAX_RFC_PORTS; i++, p_port++) { 719 if (p_port->rfc.p_mcb == p_mcb) { 720 port_rfc_closed(p_port, PORT_PEER_CONNECTION_FAILED); 721 } 722 } 723 rfc_release_multiplexer_channel(p_mcb); 724 } 725 726 /******************************************************************************* 727 * 728 * Function Port_TimeOutCloseMux 729 * 730 * Description This function is called when RFCOMM timesout on a command 731 * as a result multiplexer connection is closed. 732 * 733 ******************************************************************************/ 734 void Port_TimeOutCloseMux(tRFC_MCB* p_mcb) { 735 tPORT* p_port; 736 int i; 737 738 RFCOMM_TRACE_EVENT("Port_TimeOutCloseMux"); 739 740 p_port = &rfc_cb.port.port[0]; 741 for (i = 0; i < MAX_RFC_PORTS; i++, p_port++) { 742 if (p_port->rfc.p_mcb == p_mcb) { 743 port_rfc_closed(p_port, PORT_PEER_TIMEOUT); 744 } 745 } 746 } 747 748 /******************************************************************************* 749 * 750 * Function PORT_DataInd 751 * 752 * Description This function is called from the RFCOMM layer when data 753 * buffer is received from the peer. 754 * 755 ******************************************************************************/ 756 void PORT_DataInd(tRFC_MCB* p_mcb, uint8_t dlci, BT_HDR* p_buf) { 757 tPORT* p_port = port_find_mcb_dlci_port(p_mcb, dlci); 758 uint8_t rx_char1; 759 uint32_t events = 0; 760 uint8_t* p; 761 int i; 762 763 RFCOMM_TRACE_EVENT( 764 "PORT_DataInd with data length %d, p_mcb:%p,p_port:%p,dlci:%d", 765 p_buf->len, p_mcb, p_port, dlci); 766 if (!p_port) { 767 osi_free(p_buf); 768 return; 769 } 770 /* If client registered callout callback with flow control we can just deliver 771 * receive data */ 772 if (p_port->p_data_co_callback) { 773 /* Another packet is delivered to user. Send credits to peer if required */ 774 if (p_port->p_data_co_callback(p_port->inx, (uint8_t*)p_buf, -1, 775 DATA_CO_CALLBACK_TYPE_INCOMING)) { 776 port_flow_control_peer(p_port, true, 1); 777 } else { 778 port_flow_control_peer(p_port, false, 0); 779 } 780 // osi_free(p_buf); 781 return; 782 } 783 /* If client registered callback we can just deliver receive data */ 784 if (p_port->p_data_callback) { 785 /* Another packet is delivered to user. Send credits to peer if required */ 786 port_flow_control_peer(p_port, true, 1); 787 p_port->p_data_callback(p_port->inx, (uint8_t*)(p_buf + 1) + p_buf->offset, 788 p_buf->len); 789 osi_free(p_buf); 790 return; 791 } 792 /* Check if rx queue exceeds the limit */ 793 if ((p_port->rx.queue_size + p_buf->len > PORT_RX_CRITICAL_WM) || 794 (fixed_queue_length(p_port->rx.queue) + 1 > p_port->rx_buf_critical)) { 795 RFCOMM_TRACE_EVENT("PORT_DataInd. Buffer over run. Dropping the buffer"); 796 osi_free(p_buf); 797 RFCOMM_LineStatusReq(p_mcb, dlci, LINE_STATUS_OVERRUN); 798 return; 799 } 800 /* If user registered to receive notification when a particular byte is */ 801 /* received we mast check all received bytes */ 802 if (((rx_char1 = p_port->user_port_pars.rx_char1) != 0) && 803 (p_port->ev_mask & PORT_EV_RXFLAG)) { 804 for (i = 0, p = (uint8_t*)(p_buf + 1) + p_buf->offset; i < p_buf->len; 805 i++) { 806 if (*p++ == rx_char1) { 807 events |= PORT_EV_RXFLAG; 808 break; 809 } 810 } 811 } 812 813 mutex_global_lock(); 814 815 fixed_queue_enqueue(p_port->rx.queue, p_buf); 816 p_port->rx.queue_size += p_buf->len; 817 818 mutex_global_unlock(); 819 820 /* perform flow control procedures if necessary */ 821 port_flow_control_peer(p_port, false, 0); 822 823 /* If user indicated flow control can not deliver any notifications to him */ 824 if (p_port->rx.user_fc) { 825 if (events & PORT_EV_RXFLAG) { 826 p_port->rx_flag_ev_pending = true; 827 } 828 return; 829 } 830 831 events |= PORT_EV_RXCHAR; 832 833 /* Mask out all events that are not of interest to user */ 834 events &= p_port->ev_mask; 835 836 if (p_port->p_callback && events) p_port->p_callback(events, p_port->inx); 837 } 838 839 /******************************************************************************* 840 * 841 * Function PORT_FlowInd 842 * 843 * Description This function is called from the RFCOMM layer on the flow 844 * control signal change. Propagate change to the user. 845 * 846 ******************************************************************************/ 847 void PORT_FlowInd(tRFC_MCB* p_mcb, uint8_t dlci, bool enable_data) { 848 tPORT* p_port = (tPORT*)NULL; 849 uint32_t events = 0; 850 int i; 851 852 RFCOMM_TRACE_EVENT("PORT_FlowInd fc:%d", enable_data); 853 854 if (dlci == 0) { 855 p_mcb->peer_ready = enable_data; 856 } else { 857 p_port = port_find_mcb_dlci_port(p_mcb, dlci); 858 if (p_port == NULL) return; 859 860 p_port->tx.peer_fc = !enable_data; 861 } 862 863 for (i = 0; i < MAX_RFC_PORTS; i++) { 864 /* If DLCI is 0 event applies to all ports */ 865 if (dlci == 0) { 866 p_port = &rfc_cb.port.port[i]; 867 if (!p_port->in_use || (p_port->rfc.p_mcb != p_mcb) || 868 (p_port->rfc.state != RFC_STATE_OPENED)) 869 continue; 870 } 871 events = 0; 872 873 /* Check if flow of data is still enabled */ 874 events |= port_flow_control_user(p_port); 875 876 /* Check if data can be sent and send it */ 877 events |= port_rfc_send_tx_data(p_port); 878 879 /* Mask out all events that are not of interest to user */ 880 events &= p_port->ev_mask; 881 882 /* Send event to the application */ 883 if (p_port->p_callback && events) (p_port->p_callback)(events, p_port->inx); 884 885 /* If DLCI is not 0 event applies to one port only */ 886 if (dlci != 0) break; 887 } 888 } 889 890 /******************************************************************************* 891 * 892 * Function port_rfc_send_tx_data 893 * 894 * Description This function is when forward data can be sent to the peer 895 * 896 ******************************************************************************/ 897 uint32_t port_rfc_send_tx_data(tPORT* p_port) { 898 uint32_t events = 0; 899 BT_HDR* p_buf; 900 901 /* if there is data to be sent */ 902 if (p_port->tx.queue_size > 0) { 903 /* while the rfcomm peer is not flow controlling us, and peer is ready */ 904 while (!p_port->tx.peer_fc && p_port->rfc.p_mcb && 905 p_port->rfc.p_mcb->peer_ready) { 906 /* get data from tx queue and send it */ 907 mutex_global_lock(); 908 909 p_buf = (BT_HDR*)fixed_queue_try_dequeue(p_port->tx.queue); 910 if (p_buf != NULL) { 911 p_port->tx.queue_size -= p_buf->len; 912 913 mutex_global_unlock(); 914 915 RFCOMM_TRACE_DEBUG("Sending RFCOMM_DataReq tx.queue_size=%d", 916 p_port->tx.queue_size); 917 918 RFCOMM_DataReq(p_port->rfc.p_mcb, p_port->dlci, p_buf); 919 920 events |= PORT_EV_TXCHAR; 921 922 if (p_port->tx.queue_size == 0) { 923 events |= PORT_EV_TXEMPTY; 924 break; 925 } 926 } 927 /* queue is empty-- all data sent */ 928 else { 929 mutex_global_unlock(); 930 931 events |= PORT_EV_TXEMPTY; 932 break; 933 } 934 } 935 /* If we flow controlled user based on the queue size enable data again */ 936 events |= port_flow_control_user(p_port); 937 } 938 return (events & p_port->ev_mask); 939 } 940 941 /******************************************************************************* 942 * 943 * Function port_rfc_closed 944 * 945 * Description This function when RFCOMM side of port is closed 946 * 947 ******************************************************************************/ 948 void port_rfc_closed(tPORT* p_port, uint8_t res) { 949 uint8_t old_signals; 950 uint32_t events = 0; 951 tRFC_MCB* p_mcb = p_port->rfc.p_mcb; 952 953 if ((p_port->state == PORT_STATE_OPENING) && (p_port->is_server)) { 954 /* The servr side has not been informed that connection is up, ignore */ 955 RFCOMM_TRACE_EVENT("port_rfc_closed in OPENING state ignored"); 956 957 rfc_port_timer_stop(p_port); 958 p_port->rfc.state = RFC_STATE_CLOSED; 959 960 if (p_mcb) { 961 p_mcb->port_inx[p_port->dlci] = 0; 962 963 /* If there are no more ports opened on this MCB release it */ 964 rfc_check_mcb_active(p_mcb); 965 p_port->rfc.p_mcb = NULL; 966 } 967 968 /* Need to restore DLCI to listening state 969 * if the server was on the initiating RFC 970 */ 971 p_port->dlci &= 0xfe; 972 973 return; 974 } 975 976 if ((p_port->state != PORT_STATE_CLOSING) && 977 (p_port->state != PORT_STATE_CLOSED)) { 978 p_port->line_status |= LINE_STATUS_FAILED; 979 980 old_signals = p_port->peer_ctrl.modem_signal; 981 982 p_port->peer_ctrl.modem_signal &= 983 ~(PORT_DTRDSR_ON | PORT_CTSRTS_ON | PORT_DCD_ON); 984 985 events |= port_get_signal_changes(p_port, old_signals, 986 p_port->peer_ctrl.modem_signal); 987 988 if (p_port->ev_mask & PORT_EV_CONNECT_ERR) events |= PORT_EV_CONNECT_ERR; 989 } 990 RFCOMM_TRACE_EVENT("port_rfc_closed state:%d sending events:%x", 991 p_port->state, events); 992 993 if ((p_port->p_callback != NULL) && events) 994 p_port->p_callback(events, p_port->inx); 995 996 if (p_port->p_mgmt_callback) p_port->p_mgmt_callback(res, p_port->inx); 997 998 p_port->rfc.state = RFC_STATE_CLOSED; 999 1000 RFCOMM_TRACE_WARNING("%s RFCOMM connection in state %d closed: %s (res: %d)", 1001 __func__, p_port->state, PORT_GetResultString(res), res); 1002 1003 port_release_port(p_port); 1004 } 1005 1006 /******************************************************************************* 1007 * 1008 * Function port_get_credits 1009 * 1010 * Description Set initial values for credits. 1011 * Adjust max number of rx credits based on negotiated MTU. 1012 * Check max allowed num of bytes, max allowed num buffers, 1013 * should be less then 255 1014 * 1015 ******************************************************************************/ 1016 void port_get_credits(tPORT* p_port, uint8_t k) { 1017 p_port->credit_tx = k; 1018 if (p_port->credit_tx == 0) p_port->tx.peer_fc = true; 1019 } 1020
