1 /****************************************************************************** 2 * 3 * Copyright (C) 2009-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 /****************************************************************************** 20 * 21 * This is the implementation file for the MCAP Control Channel Action 22 * Functions. 23 * 24 ******************************************************************************/ 25 #include <string.h> 26 #include "bt_target.h" 27 #include "bt_utils.h" 28 #include "bt_common.h" 29 #include "btm_api.h" 30 #include "mca_api.h" 31 #include "mca_defs.h" 32 #include "mca_int.h" 33 34 35 #include "btu.h" 36 37 extern fixed_queue_t *btu_general_alarm_queue; 38 39 /***************************************************************************** 40 ** constants 41 *****************************************************************************/ 42 /******************************************************************************* 43 ** 44 ** Function mca_ccb_rsp_tout 45 ** 46 ** Description This function processes the response timeout. 47 ** 48 ** Returns void. 49 ** 50 *******************************************************************************/ 51 void mca_ccb_rsp_tout(tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 52 { 53 tMCA_CTRL evt_data; 54 UNUSED(p_data); 55 56 mca_ccb_report_event(p_ccb, MCA_RSP_TOUT_IND_EVT, &evt_data); 57 } 58 59 /******************************************************************************* 60 ** 61 ** Function mca_ccb_report_event 62 ** 63 ** Description This function reports the given event. 64 ** 65 ** Returns void. 66 ** 67 *******************************************************************************/ 68 void mca_ccb_report_event(tMCA_CCB *p_ccb, UINT8 event, tMCA_CTRL *p_data) 69 { 70 if (p_ccb && p_ccb->p_rcb && p_ccb->p_rcb->p_cback) 71 (*p_ccb->p_rcb->p_cback)(mca_rcb_to_handle(p_ccb->p_rcb), mca_ccb_to_hdl(p_ccb), event, p_data); 72 } 73 74 /******************************************************************************* 75 ** 76 ** Function mca_ccb_free_msg 77 ** 78 ** Description This function frees the received message. 79 ** 80 ** Returns void. 81 ** 82 *******************************************************************************/ 83 void mca_ccb_free_msg(tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 84 { 85 UNUSED(p_ccb); 86 osi_free(p_data); 87 } 88 89 /******************************************************************************* 90 ** 91 ** Function mca_ccb_snd_req 92 ** 93 ** Description This function builds a request and sends it to the peer. 94 ** 95 ** Returns void. 96 ** 97 *******************************************************************************/ 98 void mca_ccb_snd_req(tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 99 { 100 tMCA_CCB_MSG *p_msg = (tMCA_CCB_MSG *)p_data; 101 UINT8 *p, *p_start; 102 BOOLEAN is_abort = FALSE; 103 tMCA_DCB *p_dcb; 104 105 MCA_TRACE_DEBUG ("mca_ccb_snd_req cong=%d req=%d", p_ccb->cong, p_msg->op_code); 106 /* check for abort request */ 107 if ((p_ccb->status == MCA_CCB_STAT_PENDING) && (p_msg->op_code == MCA_OP_MDL_ABORT_REQ)) 108 { 109 p_dcb = mca_dcb_by_hdl(p_ccb->p_tx_req->dcb_idx); 110 /* the Abort API does not have the associated mdl_id. 111 * Get the mdl_id in dcb to compose the request */ 112 p_msg->mdl_id = p_dcb->mdl_id; 113 mca_dcb_event(p_dcb, MCA_DCB_API_CLOSE_EVT, NULL); 114 osi_free_and_reset((void **)&p_ccb->p_tx_req); 115 p_ccb->status = MCA_CCB_STAT_NORM; 116 is_abort = TRUE; 117 } 118 119 /* no pending outgoing messages or it's an abort request for a pending data channel */ 120 if ((!p_ccb->p_tx_req) || is_abort) 121 { 122 p_ccb->p_tx_req = p_msg; 123 if (!p_ccb->cong) 124 { 125 BT_HDR *p_pkt = (BT_HDR *)osi_malloc(MCA_CTRL_MTU); 126 127 p_pkt->offset = L2CAP_MIN_OFFSET; 128 p = p_start = (UINT8*)(p_pkt + 1) + L2CAP_MIN_OFFSET; 129 *p++ = p_msg->op_code; 130 UINT16_TO_BE_STREAM (p, p_msg->mdl_id); 131 if (p_msg->op_code == MCA_OP_MDL_CREATE_REQ) { 132 *p++ = p_msg->mdep_id; 133 *p++ = p_msg->param; 134 } 135 p_msg->hdr.layer_specific = TRUE; /* mark this message as sent */ 136 p_pkt->len = p - p_start; 137 L2CA_DataWrite (p_ccb->lcid, p_pkt); 138 period_ms_t interval_ms = p_ccb->p_rcb->reg.rsp_tout * 1000; 139 alarm_set_on_queue(p_ccb->mca_ccb_timer, interval_ms, 140 mca_ccb_timer_timeout, p_ccb, 141 btu_general_alarm_queue); 142 } 143 /* else the L2CAP channel is congested. keep the message to be sent later */ 144 } 145 else 146 { 147 MCA_TRACE_WARNING ("dropping api req"); 148 osi_free(p_data); 149 } 150 } 151 152 /******************************************************************************* 153 ** 154 ** Function mca_ccb_snd_rsp 155 ** 156 ** Description This function builds a response and sends it to 157 ** the peer. 158 ** 159 ** Returns void. 160 ** 161 *******************************************************************************/ 162 void mca_ccb_snd_rsp(tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 163 { 164 tMCA_CCB_MSG *p_msg = (tMCA_CCB_MSG *)p_data; 165 UINT8 *p, *p_start; 166 BOOLEAN chk_mdl = FALSE; 167 BT_HDR *p_pkt = (BT_HDR *)osi_malloc(MCA_CTRL_MTU); 168 169 MCA_TRACE_DEBUG("%s cong=%d req=%d", __func__, p_ccb->cong, p_msg->op_code); 170 /* assume that API functions verified the parameters */ 171 172 p_pkt->offset = L2CAP_MIN_OFFSET; 173 p = p_start = (UINT8*)(p_pkt + 1) + L2CAP_MIN_OFFSET; 174 *p++ = p_msg->op_code; 175 *p++ = p_msg->rsp_code; 176 UINT16_TO_BE_STREAM (p, p_msg->mdl_id); 177 if (p_msg->op_code == MCA_OP_MDL_CREATE_RSP) { 178 *p++ = p_msg->param; 179 chk_mdl = TRUE; 180 } 181 else if (p_msg->op_code == MCA_OP_MDL_RECONNECT_RSP) { 182 chk_mdl = TRUE; 183 } 184 185 if (chk_mdl && p_msg->rsp_code == MCA_RSP_SUCCESS) { 186 mca_dcb_by_hdl(p_msg->dcb_idx); 187 BTM_SetSecurityLevel(FALSE, "", BTM_SEC_SERVICE_MCAP_DATA, 188 p_ccb->sec_mask, 189 p_ccb->p_rcb->reg.data_psm, BTM_SEC_PROTO_MCA, 190 p_msg->dcb_idx); 191 p_ccb->status = MCA_CCB_STAT_PENDING; 192 /* set p_tx_req to block API_REQ/API_RSP before DL is up */ 193 osi_free_and_reset((void **)&p_ccb->p_tx_req); 194 p_ccb->p_tx_req = p_ccb->p_rx_msg; 195 p_ccb->p_rx_msg = NULL; 196 p_ccb->p_tx_req->dcb_idx = p_msg->dcb_idx; 197 } 198 osi_free_and_reset((void **)&p_ccb->p_rx_msg); 199 p_pkt->len = p - p_start; 200 L2CA_DataWrite(p_ccb->lcid, p_pkt); 201 } 202 203 /******************************************************************************* 204 ** 205 ** Function mca_ccb_do_disconn 206 ** 207 ** Description This function closes a control channel. 208 ** 209 ** Returns void. 210 ** 211 *******************************************************************************/ 212 void mca_ccb_do_disconn (tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 213 { 214 UNUSED(p_data); 215 216 mca_dcb_close_by_mdl_id (p_ccb, MCA_ALL_MDL_ID); 217 L2CA_DisconnectReq(p_ccb->lcid); 218 } 219 220 /******************************************************************************* 221 ** 222 ** Function mca_ccb_cong 223 ** 224 ** Description This function sets the congestion state for the CCB. 225 ** 226 ** Returns void. 227 ** 228 *******************************************************************************/ 229 void mca_ccb_cong(tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 230 { 231 MCA_TRACE_DEBUG ("mca_ccb_cong cong=%d/%d", p_ccb->cong, p_data->llcong); 232 p_ccb->cong = p_data->llcong; 233 if (!p_ccb->cong) 234 { 235 /* if there's a held packet, send it now */ 236 if (p_ccb->p_tx_req && !p_ccb->p_tx_req->hdr.layer_specific) 237 { 238 p_data = (tMCA_CCB_EVT *)p_ccb->p_tx_req; 239 p_ccb->p_tx_req = NULL; 240 mca_ccb_snd_req (p_ccb, p_data); 241 } 242 } 243 } 244 245 /******************************************************************************* 246 ** 247 ** Function mca_ccb_hdl_req 248 ** 249 ** Description This function is called when a MCAP request is received from 250 ** the peer. It calls the application callback function to 251 ** report the event. 252 ** 253 ** Returns void. 254 ** 255 *******************************************************************************/ 256 void mca_ccb_hdl_req(tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 257 { 258 BT_HDR *p_pkt = &p_data->hdr; 259 UINT8 *p, *p_start; 260 tMCA_DCB *p_dcb; 261 tMCA_CTRL evt_data; 262 tMCA_CCB_MSG *p_rx_msg = NULL; 263 UINT8 reject_code = MCA_RSP_NO_RESOURCE; 264 BOOLEAN send_rsp = FALSE; 265 BOOLEAN check_req = FALSE; 266 UINT8 reject_opcode; 267 268 MCA_TRACE_DEBUG ("mca_ccb_hdl_req status:%d", p_ccb->status); 269 p_rx_msg = (tMCA_CCB_MSG *)p_pkt; 270 p = (UINT8 *)(p_pkt + 1) + p_pkt->offset; 271 evt_data.hdr.op_code = *p++; 272 BE_STREAM_TO_UINT16 (evt_data.hdr.mdl_id, p); 273 reject_opcode = evt_data.hdr.op_code+1; 274 275 MCA_TRACE_DEBUG ("received mdl id: %d ", evt_data.hdr.mdl_id); 276 if (p_ccb->status == MCA_CCB_STAT_PENDING) 277 { 278 MCA_TRACE_DEBUG ("received req inpending state"); 279 /* allow abort in pending state */ 280 if ((p_ccb->status == MCA_CCB_STAT_PENDING) && (evt_data.hdr.op_code == MCA_OP_MDL_ABORT_REQ)) 281 { 282 reject_code = MCA_RSP_SUCCESS; 283 send_rsp = TRUE; 284 /* clear the pending status */ 285 p_ccb->status = MCA_CCB_STAT_NORM; 286 if (p_ccb->p_tx_req && ((p_dcb = mca_dcb_by_hdl(p_ccb->p_tx_req->dcb_idx))!= NULL)) 287 { 288 mca_dcb_dealloc(p_dcb, NULL); 289 osi_free_and_reset((void **)&p_ccb->p_tx_req); 290 } 291 } 292 else 293 reject_code = MCA_RSP_BAD_OP; 294 } 295 else if (p_ccb->p_rx_msg) 296 { 297 MCA_TRACE_DEBUG ("still handling prev req"); 298 /* still holding previous message, reject this new one ?? */ 299 300 } 301 else if (p_ccb->p_tx_req) 302 { 303 MCA_TRACE_DEBUG ("still waiting for a response ctrl_vpsm:0x%x", p_ccb->ctrl_vpsm); 304 /* sent a request; waiting for response */ 305 if (p_ccb->ctrl_vpsm == 0) 306 { 307 MCA_TRACE_DEBUG ("local is ACP. accept the cmd from INT"); 308 /* local is acceptor, need to handle the request */ 309 check_req = TRUE; 310 reject_code = MCA_RSP_SUCCESS; 311 /* drop the previous request */ 312 if ((p_ccb->p_tx_req->op_code == MCA_OP_MDL_CREATE_REQ) && 313 ((p_dcb = mca_dcb_by_hdl(p_ccb->p_tx_req->dcb_idx)) != NULL)) 314 { 315 mca_dcb_dealloc(p_dcb, NULL); 316 } 317 osi_free_and_reset((void **)&p_ccb->p_tx_req); 318 mca_stop_timer(p_ccb); 319 } 320 else 321 { 322 /* local is initiator, ignore the req */ 323 osi_free(p_pkt); 324 return; 325 } 326 } 327 else if (p_pkt->layer_specific != MCA_RSP_SUCCESS) 328 { 329 330 reject_code = (UINT8)p_pkt->layer_specific; 331 if (((evt_data.hdr.op_code >= MCA_NUM_STANDARD_OPCODE) && 332 (evt_data.hdr.op_code < MCA_FIRST_SYNC_OP)) || 333 (evt_data.hdr.op_code > MCA_LAST_SYNC_OP)) 334 { 335 /* invalid op code */ 336 reject_opcode = MCA_OP_ERROR_RSP; 337 evt_data.hdr.mdl_id = 0; 338 } 339 } 340 else 341 { 342 check_req = TRUE; 343 reject_code = MCA_RSP_SUCCESS; 344 } 345 346 if (check_req) 347 { 348 if (reject_code == MCA_RSP_SUCCESS) 349 { 350 reject_code = MCA_RSP_BAD_MDL; 351 if (MCA_IS_VALID_MDL_ID(evt_data.hdr.mdl_id) || 352 ((evt_data.hdr.mdl_id == MCA_ALL_MDL_ID) && (evt_data.hdr.op_code == MCA_OP_MDL_DELETE_REQ))) 353 { 354 reject_code = MCA_RSP_SUCCESS; 355 /* mdl_id is valid according to the spec */ 356 switch (evt_data.hdr.op_code) 357 { 358 case MCA_OP_MDL_CREATE_REQ: 359 evt_data.create_ind.dep_id = *p++; 360 evt_data.create_ind.cfg = *p++; 361 p_rx_msg->mdep_id = evt_data.create_ind.dep_id; 362 if (!mca_is_valid_dep_id(p_ccb->p_rcb, p_rx_msg->mdep_id)) 363 { 364 MCA_TRACE_ERROR ("not a valid local mdep id"); 365 reject_code = MCA_RSP_BAD_MDEP; 366 } 367 else if (mca_ccb_uses_mdl_id(p_ccb, evt_data.hdr.mdl_id)) 368 { 369 MCA_TRACE_DEBUG ("the mdl_id is currently used in the CL(create)"); 370 mca_dcb_close_by_mdl_id(p_ccb, evt_data.hdr.mdl_id); 371 } 372 else 373 { 374 /* check if this dep still have MDL available */ 375 if (mca_dep_free_mdl(p_ccb, evt_data.create_ind.dep_id) == 0) 376 { 377 MCA_TRACE_ERROR ("the mdep is currently using max_mdl"); 378 reject_code = MCA_RSP_MDEP_BUSY; 379 } 380 } 381 break; 382 383 case MCA_OP_MDL_RECONNECT_REQ: 384 if (mca_ccb_uses_mdl_id(p_ccb, evt_data.hdr.mdl_id)) 385 { 386 MCA_TRACE_ERROR ("the mdl_id is currently used in the CL(reconn)"); 387 reject_code = MCA_RSP_MDL_BUSY; 388 } 389 break; 390 391 case MCA_OP_MDL_ABORT_REQ: 392 reject_code = MCA_RSP_BAD_OP; 393 break; 394 395 case MCA_OP_MDL_DELETE_REQ: 396 /* delete the associated mdl */ 397 mca_dcb_close_by_mdl_id(p_ccb, evt_data.hdr.mdl_id); 398 send_rsp = TRUE; 399 break; 400 } 401 } 402 } 403 } 404 405 if (((reject_code != MCA_RSP_SUCCESS) && (evt_data.hdr.op_code != MCA_OP_SYNC_INFO_IND)) 406 || send_rsp) { 407 BT_HDR *p_buf = (BT_HDR *)osi_malloc(MCA_CTRL_MTU); 408 p_buf->offset = L2CAP_MIN_OFFSET; 409 p = p_start = (UINT8*)(p_buf + 1) + L2CAP_MIN_OFFSET; 410 *p++ = reject_opcode; 411 *p++ = reject_code; 412 UINT16_TO_BE_STREAM(p, evt_data.hdr.mdl_id); 413 /* 414 if (((*p_start) == MCA_OP_MDL_CREATE_RSP) && (reject_code == MCA_RSP_SUCCESS)) 415 { 416 *p++ = evt_data.create_ind.cfg; 417 } 418 */ 419 420 p_buf->len = p - p_start; 421 L2CA_DataWrite (p_ccb->lcid, p_buf); 422 } 423 424 if (reject_code == MCA_RSP_SUCCESS) 425 { 426 /* use the received GKI buffer to store information to double check response API */ 427 p_rx_msg->op_code = evt_data.hdr.op_code; 428 p_rx_msg->mdl_id = evt_data.hdr.mdl_id; 429 p_ccb->p_rx_msg = p_rx_msg; 430 if (send_rsp) 431 { 432 osi_free(p_pkt); 433 p_ccb->p_rx_msg = NULL; 434 } 435 mca_ccb_report_event(p_ccb, evt_data.hdr.op_code, &evt_data); 436 } 437 else 438 osi_free(p_pkt); 439 } 440 441 /******************************************************************************* 442 ** 443 ** Function mca_ccb_hdl_rsp 444 ** 445 ** Description This function is called when a MCAP response is received from 446 ** the peer. It calls the application callback function with 447 ** the results. 448 ** 449 ** Returns void. 450 ** 451 *******************************************************************************/ 452 void mca_ccb_hdl_rsp(tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 453 { 454 BT_HDR *p_pkt = &p_data->hdr; 455 UINT8 *p; 456 tMCA_CTRL evt_data; 457 BOOLEAN chk_mdl = FALSE; 458 tMCA_DCB *p_dcb; 459 tMCA_RESULT result = MCA_BAD_HANDLE; 460 tMCA_TC_TBL *p_tbl; 461 462 if (p_ccb->p_tx_req) 463 { 464 /* verify that the received response matches the sent request */ 465 p = (UINT8 *)(p_pkt + 1) + p_pkt->offset; 466 evt_data.hdr.op_code = *p++; 467 if ((evt_data.hdr.op_code == 0) || 468 ((p_ccb->p_tx_req->op_code + 1) == evt_data.hdr.op_code)) 469 { 470 evt_data.rsp.rsp_code = *p++; 471 mca_stop_timer(p_ccb); 472 BE_STREAM_TO_UINT16 (evt_data.hdr.mdl_id, p); 473 if (evt_data.hdr.op_code == MCA_OP_MDL_CREATE_RSP) 474 { 475 evt_data.create_cfm.cfg = *p++; 476 chk_mdl = TRUE; 477 } 478 else if (evt_data.hdr.op_code == MCA_OP_MDL_RECONNECT_RSP) 479 chk_mdl = TRUE; 480 481 if (chk_mdl) 482 { 483 p_dcb = mca_dcb_by_hdl(p_ccb->p_tx_req->dcb_idx); 484 if (evt_data.rsp.rsp_code == MCA_RSP_SUCCESS) 485 { 486 if (evt_data.hdr.mdl_id != p_dcb->mdl_id) 487 { 488 MCA_TRACE_ERROR ("peer's mdl_id=%d != our mdl_id=%d", evt_data.hdr.mdl_id, p_dcb->mdl_id); 489 /* change the response code to be an error */ 490 if (evt_data.rsp.rsp_code == MCA_RSP_SUCCESS) 491 { 492 evt_data.rsp.rsp_code = MCA_RSP_BAD_MDL; 493 /* send Abort */ 494 p_ccb->status = MCA_CCB_STAT_PENDING; 495 MCA_Abort(mca_ccb_to_hdl(p_ccb)); 496 } 497 } 498 else if (p_dcb->p_chnl_cfg) 499 { 500 /* the data channel configuration is known. Proceed with data channel initiation */ 501 BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_MCAP_DATA, p_ccb->sec_mask, 502 p_ccb->data_vpsm, BTM_SEC_PROTO_MCA, p_ccb->p_tx_req->dcb_idx); 503 p_dcb->lcid = mca_l2c_open_req(p_ccb->peer_addr, p_ccb->data_vpsm, p_dcb->p_chnl_cfg); 504 if (p_dcb->lcid) 505 { 506 p_tbl = mca_tc_tbl_dalloc(p_dcb); 507 if (p_tbl) 508 { 509 p_tbl->state = MCA_TC_ST_CONN; 510 p_ccb->status = MCA_CCB_STAT_PENDING; 511 result = MCA_SUCCESS; 512 } 513 } 514 } 515 else 516 { 517 /* mark this MCL as pending and wait for MCA_DataChnlCfg */ 518 p_ccb->status = MCA_CCB_STAT_PENDING; 519 result = MCA_SUCCESS; 520 } 521 } 522 523 if (result != MCA_SUCCESS && p_dcb) 524 { 525 mca_dcb_dealloc(p_dcb, NULL); 526 } 527 } /* end of chk_mdl */ 528 529 if (p_ccb->status != MCA_CCB_STAT_PENDING) 530 osi_free_and_reset((void **)&p_ccb->p_tx_req); 531 mca_ccb_report_event(p_ccb, evt_data.hdr.op_code, &evt_data); 532 } 533 /* else a bad response is received */ 534 } 535 else 536 { 537 /* not expecting any response. drop it */ 538 MCA_TRACE_WARNING ("dropping received rsp (not expecting a response)"); 539 } 540 osi_free(p_data); 541 } 542 543 /******************************************************************************* 544 ** 545 ** Function mca_ccb_ll_open 546 ** 547 ** Description This function is called to report MCA_CONNECT_IND_EVT event. 548 ** It also clears the congestion flag (ccb.cong). 549 ** 550 ** Returns void. 551 ** 552 *******************************************************************************/ 553 void mca_ccb_ll_open (tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 554 { 555 tMCA_CTRL evt_data; 556 p_ccb->cong = FALSE; 557 evt_data.connect_ind.mtu = p_data->open.peer_mtu; 558 memcpy (evt_data.connect_ind.bd_addr, p_ccb->peer_addr, BD_ADDR_LEN); 559 mca_ccb_report_event (p_ccb, MCA_CONNECT_IND_EVT, &evt_data); 560 } 561 562 /******************************************************************************* 563 ** 564 ** Function mca_ccb_dl_open 565 ** 566 ** Description This function is called when data channel is open. 567 ** It clears p_tx_req to allow other message exchage on this CL. 568 ** 569 ** Returns void. 570 ** 571 *******************************************************************************/ 572 void mca_ccb_dl_open (tMCA_CCB *p_ccb, tMCA_CCB_EVT *p_data) 573 { 574 UNUSED(p_data); 575 576 osi_free_and_reset((void **)&p_ccb->p_tx_req); 577 osi_free_and_reset((void **)&p_ccb->p_rx_msg); 578 p_ccb->status = MCA_CCB_STAT_NORM; 579 } 580 581
