1 /****************************************************************************** 2 * 3 * Copyright 2002-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 the action functions associated with the stream 22 * control block state machine. 23 * 24 ******************************************************************************/ 25 26 #include <string.h> 27 #include "a2dp_codec_api.h" 28 #include "avdt_api.h" 29 #include "avdt_int.h" 30 #include "avdtc_api.h" 31 #include "bt_common.h" 32 #include "bt_target.h" 33 #include "bt_types.h" 34 #include "bt_utils.h" 35 #include "btu.h" 36 #include "osi/include/osi.h" 37 38 /* This table is used to lookup the callback event that matches a particular 39 * state machine API request event. Note that state machine API request 40 * events are at the beginning of the event list starting at zero, thus 41 * allowing for this table. 42 */ 43 const uint8_t avdt_scb_cback_evt[] = { 44 0, /* API_REMOVE_EVT (no event) */ 45 AVDT_WRITE_CFM_EVT, /* API_WRITE_REQ_EVT */ 46 0, /* API_GETCONFIG_REQ_EVT (no event) */ 47 0, /* API_DELAY_RPT_REQ_EVT (no event) */ 48 AVDT_OPEN_CFM_EVT, /* API_SETCONFIG_REQ_EVT */ 49 AVDT_OPEN_CFM_EVT, /* API_OPEN_REQ_EVT */ 50 AVDT_CLOSE_CFM_EVT, /* API_CLOSE_REQ_EVT */ 51 AVDT_RECONFIG_CFM_EVT, /* API_RECONFIG_REQ_EVT */ 52 AVDT_SECURITY_CFM_EVT, /* API_SECURITY_REQ_EVT */ 53 0 /* API_ABORT_REQ_EVT (no event) */ 54 }; 55 56 /******************************************************************************* 57 * 58 * Function avdt_scb_gen_ssrc 59 * 60 * Description This function generates a SSRC number unique to the stream. 61 * 62 * Returns SSRC value. 63 * 64 ******************************************************************************/ 65 uint32_t avdt_scb_gen_ssrc(AvdtpScb* p_scb) { 66 /* combine the value of the media type and codec type of the SCB */ 67 return ((uint32_t)(p_scb->stream_config.cfg.codec_info[1] | 68 p_scb->stream_config.cfg.codec_info[2])); 69 } 70 71 /******************************************************************************* 72 * 73 * Function avdt_scb_hdl_abort_cmd 74 * 75 * Description This function sends the SCB an AVDT_SCB_API_ABORT_RSP_EVT 76 * to initiate sending of an abort response message. 77 * 78 * Returns Nothing. 79 * 80 ******************************************************************************/ 81 void avdt_scb_hdl_abort_cmd(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 82 p_scb->role = AVDT_CLOSE_ACP; 83 avdt_scb_event(p_scb, AVDT_SCB_API_ABORT_RSP_EVT, p_data); 84 } 85 86 /******************************************************************************* 87 * 88 * Function avdt_scb_hdl_abort_rsp 89 * 90 * Description This function is an empty function; it serves as a 91 * placeholder for a conformance API action function. 92 * 93 * Returns Nothing. 94 * 95 ******************************************************************************/ 96 void avdt_scb_hdl_abort_rsp(UNUSED_ATTR AvdtpScb* p_scb, 97 UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 98 return; 99 } 100 101 /******************************************************************************* 102 * 103 * Function avdt_scb_hdl_close_cmd 104 * 105 * Description This function sends the SCB an AVDT_SCB_API_CLOSE_RSP_EVT 106 * to initiate sending of a close response message. 107 * 108 * Returns Nothing. 109 * 110 ******************************************************************************/ 111 void avdt_scb_hdl_close_cmd(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 112 p_scb->role = AVDT_CLOSE_ACP; 113 avdt_scb_event(p_scb, AVDT_SCB_API_CLOSE_RSP_EVT, p_data); 114 } 115 116 /******************************************************************************* 117 * 118 * Function avdt_scb_hdl_close_rsp 119 * 120 * Description This function sets the close_code variable to the error 121 * code returned in the close response. 122 * 123 * Returns Nothing. 124 * 125 ******************************************************************************/ 126 void avdt_scb_hdl_close_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 127 p_scb->close_code = p_data->msg.hdr.err_code; 128 } 129 130 /******************************************************************************* 131 * 132 * Function avdt_scb_hdl_getconfig_cmd 133 * 134 * Description This function retrieves the configuration parameters of 135 * the SCB and sends the SCB an AVDT_SCB_API_GETCONFIG_RSP_EVT 136 * to initiate sending of a get configuration response message. 137 * 138 * Returns Nothing. 139 * 140 ******************************************************************************/ 141 void avdt_scb_hdl_getconfig_cmd(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 142 p_data->msg.svccap.p_cfg = &p_scb->curr_cfg; 143 144 avdt_scb_event(p_scb, AVDT_SCB_API_GETCONFIG_RSP_EVT, p_data); 145 } 146 147 /******************************************************************************* 148 * 149 * Function avdt_scb_hdl_getconfig_rsp 150 * 151 * Description This function is an empty function; it serves as a 152 * placeholder for a conformance API action function. 153 * 154 * Returns Nothing. 155 * 156 ******************************************************************************/ 157 void avdt_scb_hdl_getconfig_rsp(UNUSED_ATTR AvdtpScb* p_scb, 158 UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 159 return; 160 } 161 162 /******************************************************************************* 163 * 164 * Function avdt_scb_hdl_open_cmd 165 * 166 * Description This function sends the SCB an AVDT_SCB_API_OPEN_RSP_EVT 167 * to initiate sending of an open response message. 168 * 169 * Returns Nothing. 170 * 171 ******************************************************************************/ 172 void avdt_scb_hdl_open_cmd(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 173 avdt_scb_event(p_scb, AVDT_SCB_API_OPEN_RSP_EVT, p_data); 174 } 175 176 /******************************************************************************* 177 * 178 * Function avdt_scb_hdl_open_rej 179 * 180 * Description This function calls the application callback function 181 * indicating the open request has failed. It initializes 182 * certain SCB variables and sends a AVDT_CCB_UL_CLOSE_EVT 183 * to the CCB. 184 * 185 * Returns Nothing. 186 * 187 ******************************************************************************/ 188 void avdt_scb_hdl_open_rej(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 189 /* do exactly same as setconfig reject */ 190 avdt_scb_hdl_setconfig_rej(p_scb, p_data); 191 } 192 193 /******************************************************************************* 194 * 195 * Function avdt_scb_hdl_open_rsp 196 * 197 * Description This function calls avdt_ad_open_req() to initiate 198 * connection of the transport channel for this stream. 199 * 200 * Returns Nothing. 201 * 202 ******************************************************************************/ 203 void avdt_scb_hdl_open_rsp(AvdtpScb* p_scb, UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 204 /* initiate opening of trans channels for this SEID */ 205 p_scb->role = AVDT_OPEN_INT; 206 avdt_ad_open_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, AVDT_INT); 207 208 /* start tc connect timer */ 209 alarm_set_on_mloop(p_scb->transport_channel_timer, 210 AVDT_SCB_TC_CONN_TIMEOUT_MS, 211 avdt_scb_transport_channel_timer_timeout, p_scb); 212 } 213 214 /******************************************************************************* 215 * 216 * Function avdt_scb_hdl_pkt_no_frag 217 * 218 * Description 219 * 220 * Returns Nothing. 221 * 222 ******************************************************************************/ 223 void avdt_scb_hdl_pkt_no_frag(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 224 uint8_t *p, *p_start; 225 uint8_t o_v, o_p, o_x, o_cc; 226 uint8_t m_pt; 227 uint8_t marker; 228 uint16_t seq; 229 uint32_t time_stamp; 230 uint16_t offset; 231 uint16_t ex_len; 232 uint8_t pad_len = 0; 233 234 p = p_start = (uint8_t*)(p_data->p_pkt + 1) + p_data->p_pkt->offset; 235 236 /* parse media packet header */ 237 AVDT_MSG_PRS_OCTET1(p, o_v, o_p, o_x, o_cc); 238 AVDT_MSG_PRS_M_PT(p, m_pt, marker); 239 BE_STREAM_TO_UINT16(seq, p); 240 BE_STREAM_TO_UINT32(time_stamp, p); 241 p += 4; 242 243 /* skip over any csrc's in packet */ 244 p += o_cc * 4; 245 246 /* check for and skip over extension header */ 247 if (o_x) { 248 p += 2; 249 BE_STREAM_TO_UINT16(ex_len, p); 250 p += ex_len * 4; 251 } 252 253 /* save our new offset */ 254 offset = (uint16_t)(p - p_start); 255 256 /* adjust length for any padding at end of packet */ 257 if (o_p) { 258 /* padding length in last byte of packet */ 259 pad_len = *(p_start + p_data->p_pkt->len); 260 } 261 262 /* do sanity check */ 263 if ((offset > p_data->p_pkt->len) || 264 ((pad_len + offset) > p_data->p_pkt->len)) { 265 AVDT_TRACE_WARNING("Got bad media packet"); 266 osi_free_and_reset((void**)&p_data->p_pkt); 267 } 268 /* adjust offset and length and send it up */ 269 else { 270 p_data->p_pkt->len -= (offset + pad_len); 271 p_data->p_pkt->offset += offset; 272 273 if (p_scb->stream_config.p_sink_data_cback != NULL) { 274 /* report sequence number */ 275 p_data->p_pkt->layer_specific = seq; 276 (*p_scb->stream_config.p_sink_data_cback)( 277 avdt_scb_to_hdl(p_scb), p_data->p_pkt, time_stamp, 278 (uint8_t)(m_pt | (marker << 7))); 279 } else { 280 osi_free_and_reset((void**)&p_data->p_pkt); 281 } 282 } 283 } 284 285 /******************************************************************************* 286 * 287 * Function avdt_scb_hdl_report 288 * 289 * Description 290 * 291 * Returns Nothing. 292 * 293 ******************************************************************************/ 294 uint8_t* avdt_scb_hdl_report(AvdtpScb* p_scb, uint8_t* p, uint16_t len) { 295 uint16_t result = AVDT_SUCCESS; 296 uint8_t* p_start = p; 297 uint32_t ssrc; 298 uint8_t o_v, o_p, o_cc; 299 AVDT_REPORT_TYPE pt; 300 tAVDT_REPORT_DATA report; 301 302 AVDT_TRACE_DEBUG("%s", __func__); 303 if (p_scb->stream_config.p_report_cback) { 304 /* parse report packet header */ 305 AVDT_MSG_PRS_RPT_OCTET1(p, o_v, o_p, o_cc); 306 pt = *p++; 307 p += 2; 308 BE_STREAM_TO_UINT32(ssrc, p); 309 310 switch (pt) { 311 case AVDT_RTCP_PT_SR: /* the packet type - SR (Sender Report) */ 312 BE_STREAM_TO_UINT32(report.sr.ntp_sec, p); 313 BE_STREAM_TO_UINT32(report.sr.ntp_frac, p); 314 BE_STREAM_TO_UINT32(report.sr.rtp_time, p); 315 BE_STREAM_TO_UINT32(report.sr.pkt_count, p); 316 BE_STREAM_TO_UINT32(report.sr.octet_count, p); 317 break; 318 319 case AVDT_RTCP_PT_RR: /* the packet type - RR (Receiver Report) */ 320 report.rr.frag_lost = *p; 321 BE_STREAM_TO_UINT32(report.rr.packet_lost, p); 322 report.rr.packet_lost &= 0xFFFFFF; 323 BE_STREAM_TO_UINT32(report.rr.seq_num_rcvd, p); 324 BE_STREAM_TO_UINT32(report.rr.jitter, p); 325 BE_STREAM_TO_UINT32(report.rr.lsr, p); 326 BE_STREAM_TO_UINT32(report.rr.dlsr, p); 327 break; 328 329 case AVDT_RTCP_PT_SDES: /* the packet type - SDES (Source Description) */ 330 uint8_t sdes_type; 331 BE_STREAM_TO_UINT8(sdes_type, p); 332 if (sdes_type == AVDT_RTCP_SDES_CNAME) { 333 uint8_t name_length; 334 BE_STREAM_TO_UINT8(name_length, p); 335 if (name_length > len - 2 || name_length > AVDT_MAX_CNAME_SIZE) { 336 result = AVDT_BAD_PARAMS; 337 } else { 338 BE_STREAM_TO_ARRAY(p, &(report.cname[0]), name_length); 339 } 340 } else { 341 AVDT_TRACE_WARNING(" - SDES SSRC=0x%08x sc=%d %d len=%d %s", ssrc, 342 o_cc, *p, *(p + 1), p + 2); 343 result = AVDT_BUSY; 344 } 345 break; 346 347 default: 348 AVDT_TRACE_ERROR("Bad Report pkt - packet type: %d", pt); 349 result = AVDT_BAD_PARAMS; 350 } 351 352 if (result == AVDT_SUCCESS) 353 (*p_scb->stream_config.p_report_cback)(avdt_scb_to_hdl(p_scb), pt, 354 &report); 355 } 356 p_start += len; 357 return p_start; 358 } 359 360 /******************************************************************************* 361 * 362 * Function avdt_scb_hdl_pkt 363 * 364 * Description 365 * 366 * Returns Nothing. 367 * 368 ******************************************************************************/ 369 void avdt_scb_hdl_pkt(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 370 if (p_data->p_pkt->layer_specific == AVDT_CHAN_REPORT) { 371 uint8_t* p = (uint8_t*)(p_data->p_pkt + 1) + p_data->p_pkt->offset; 372 avdt_scb_hdl_report(p_scb, p, p_data->p_pkt->len); 373 osi_free_and_reset((void**)&p_data->p_pkt); 374 } else { 375 avdt_scb_hdl_pkt_no_frag(p_scb, p_data); 376 } 377 } 378 379 /******************************************************************************* 380 * 381 * Function avdt_scb_drop_pkt 382 * 383 * Description Drop an incoming media packet. This function is called if 384 * a media packet is received in any state besides streaming. 385 * 386 * Returns Nothing. 387 * 388 ******************************************************************************/ 389 void avdt_scb_drop_pkt(UNUSED_ATTR AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 390 AVDT_TRACE_ERROR("%s dropped incoming media packet", __func__); 391 osi_free_and_reset((void**)&p_data->p_pkt); 392 } 393 394 /******************************************************************************* 395 * 396 * Function avdt_scb_hdl_reconfig_cmd 397 * 398 * Description This function calls the application callback function 399 * with a reconfiguration indication. 400 * 401 * Returns Nothing. 402 * 403 ******************************************************************************/ 404 void avdt_scb_hdl_reconfig_cmd(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 405 /* if command not supported */ 406 if (p_scb->stream_config.nsc_mask & AvdtpStreamConfig::AVDT_NSC_RECONFIG) { 407 /* send reject */ 408 p_data->msg.hdr.err_code = AVDT_ERR_NSC; 409 p_data->msg.hdr.err_param = 0; 410 avdt_scb_event(p_scb, AVDT_SCB_API_RECONFIG_RSP_EVT, p_data); 411 } else { 412 /* store requested configuration */ 413 p_scb->req_cfg = *p_data->msg.reconfig_cmd.p_cfg; 414 415 /* call application callback */ 416 (*p_scb->stream_config.p_avdt_ctrl_cback)( 417 avdt_scb_to_hdl(p_scb), RawAddress::kEmpty, AVDT_RECONFIG_IND_EVT, 418 (tAVDT_CTRL*)&p_data->msg.reconfig_cmd, p_scb->stream_config.scb_index); 419 } 420 } 421 422 /******************************************************************************* 423 * 424 * Function avdt_scb_hdl_reconfig_rsp 425 * 426 * Description This function calls the application callback function 427 * with a reconfiguration confirm. 428 * 429 * Returns Nothing. 430 * 431 ******************************************************************************/ 432 void avdt_scb_hdl_reconfig_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 433 if (p_data->msg.hdr.err_code == 0) { 434 /* store new configuration */ 435 if (p_scb->req_cfg.num_codec > 0) { 436 p_scb->curr_cfg.num_codec = p_scb->req_cfg.num_codec; 437 memcpy(p_scb->curr_cfg.codec_info, p_scb->req_cfg.codec_info, 438 AVDT_CODEC_SIZE); 439 } 440 if (p_scb->req_cfg.num_protect > 0) { 441 p_scb->curr_cfg.num_protect = p_scb->req_cfg.num_protect; 442 memcpy(p_scb->curr_cfg.protect_info, p_scb->req_cfg.protect_info, 443 AVDT_PROTECT_SIZE); 444 } 445 } 446 447 p_data->msg.svccap.p_cfg = &p_scb->curr_cfg; 448 449 /* call application callback */ 450 (*p_scb->stream_config.p_avdt_ctrl_cback)( 451 avdt_scb_to_hdl(p_scb), RawAddress::kEmpty, AVDT_RECONFIG_CFM_EVT, 452 (tAVDT_CTRL*)&p_data->msg.svccap, p_scb->stream_config.scb_index); 453 } 454 455 /******************************************************************************* 456 * 457 * Function avdt_scb_hdl_security_cmd 458 * 459 * Description This function calls the application callback with a 460 * security indication. 461 * 462 * Returns Nothing. 463 * 464 ******************************************************************************/ 465 void avdt_scb_hdl_security_cmd(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 466 /* if command not supported */ 467 if (p_scb->stream_config.nsc_mask & AvdtpStreamConfig::AVDT_NSC_SECURITY) { 468 /* send reject */ 469 p_data->msg.hdr.err_code = AVDT_ERR_NSC; 470 avdt_scb_event(p_scb, AVDT_SCB_API_SECURITY_RSP_EVT, p_data); 471 } else { 472 /* call application callback */ 473 (*p_scb->stream_config.p_avdt_ctrl_cback)( 474 avdt_scb_to_hdl(p_scb), RawAddress::kEmpty, AVDT_SECURITY_IND_EVT, 475 (tAVDT_CTRL*)&p_data->msg.security_cmd, p_scb->stream_config.scb_index); 476 } 477 } 478 479 /******************************************************************************* 480 * 481 * Function avdt_scb_hdl_security_rsp 482 * 483 * Description This function calls the application callback with a 484 * security confirm. 485 * 486 * Returns Nothing. 487 * 488 ******************************************************************************/ 489 void avdt_scb_hdl_security_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 490 /* call application callback */ 491 (*p_scb->stream_config.p_avdt_ctrl_cback)( 492 avdt_scb_to_hdl(p_scb), RawAddress::kEmpty, AVDT_SECURITY_CFM_EVT, 493 (tAVDT_CTRL*)&p_data->msg.security_cmd, p_scb->stream_config.scb_index); 494 } 495 496 /******************************************************************************* 497 * 498 * Function avdt_scb_hdl_setconfig_cmd 499 * 500 * Description This function marks the SCB as in use and copies the 501 * configuration and peer SEID to the SCB. It then calls 502 * the application callback with a configuration indication. 503 * 504 * Returns Nothing. 505 * 506 ******************************************************************************/ 507 void avdt_scb_hdl_setconfig_cmd(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 508 AVDT_TRACE_DEBUG("%s: p_scb->in_use=%d p_avdt_scb=%p scb_index=%d", __func__, 509 p_scb->in_use, p_scb, p_scb->stream_config.scb_index); 510 511 if (!p_scb->in_use) { 512 AVDT_TRACE_DEBUG( 513 "%s: codec: %s", __func__, 514 A2DP_CodecInfoString(p_scb->stream_config.cfg.codec_info).c_str()); 515 AVDT_TRACE_DEBUG( 516 "%s: codec: %s", __func__, 517 A2DP_CodecInfoString(p_data->msg.config_cmd.p_cfg->codec_info).c_str()); 518 AvdtpSepConfig* p_cfg = p_data->msg.config_cmd.p_cfg; 519 if (A2DP_GetCodecType(p_scb->stream_config.cfg.codec_info) == 520 A2DP_GetCodecType(p_cfg->codec_info)) { 521 /* copy info to scb */ 522 AvdtpCcb* p_ccb = avdt_ccb_by_idx(p_data->msg.config_cmd.hdr.ccb_idx); 523 if (p_scb->p_ccb != p_ccb) { 524 AVDT_TRACE_ERROR( 525 "%s: mismatch in AVDTP SCB/CCB state: (p_scb->p_ccb=%p != " 526 "p_ccb=%p): " 527 "p_scb=%p scb_handle=%d ccb_idx=%d", 528 __func__, p_scb->p_ccb, p_ccb, p_scb, p_scb->ScbHandle(), 529 p_data->msg.config_cmd.hdr.ccb_idx); 530 avdt_scb_rej_not_in_use(p_scb, p_data); 531 return; 532 } 533 /* set sep as in use */ 534 p_scb->in_use = true; 535 536 p_scb->peer_seid = p_data->msg.config_cmd.int_seid; 537 p_scb->req_cfg = *p_cfg; 538 /* call app callback */ 539 /* handle of scb- which is same as sep handle of bta_av_cb.p_scb*/ 540 (*p_scb->stream_config.p_avdt_ctrl_cback)( 541 avdt_scb_to_hdl(p_scb), 542 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, 543 AVDT_CONFIG_IND_EVT, (tAVDT_CTRL*)&p_data->msg.config_cmd, 544 p_scb->stream_config.scb_index); 545 } else { 546 p_data->msg.hdr.err_code = AVDT_ERR_UNSUP_CFG; 547 p_data->msg.hdr.err_param = 0; 548 avdt_msg_send_rej(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx), 549 p_data->msg.hdr.sig_id, &p_data->msg); 550 } 551 } else { 552 AVDT_TRACE_DEBUG("%s: calling avdt_scb_rej_in_use()", __func__); 553 avdt_scb_rej_in_use(p_scb, p_data); 554 } 555 } 556 557 /******************************************************************************* 558 * 559 * Function avdt_scb_hdl_setconfig_rej 560 * 561 * Description This function marks the SCB as not in use and calls the 562 * application callback with an open confirm indicating 563 * failure. 564 * 565 * Returns Nothing. 566 * 567 ******************************************************************************/ 568 void avdt_scb_hdl_setconfig_rej(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 569 /* clear scb variables */ 570 avdt_scb_clr_vars(p_scb, p_data); 571 572 /* tell ccb we're done with signaling channel */ 573 avdt_ccb_event(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx), 574 AVDT_CCB_UL_CLOSE_EVT, NULL); 575 576 /* call application callback */ 577 (*p_scb->stream_config.p_avdt_ctrl_cback)( 578 avdt_scb_to_hdl(p_scb), RawAddress::kEmpty, AVDT_OPEN_CFM_EVT, 579 (tAVDT_CTRL*)&p_data->msg.hdr, p_scb->stream_config.scb_index); 580 } 581 582 /******************************************************************************* 583 * 584 * Function avdt_scb_hdl_setconfig_rsp 585 * 586 * Description This function sends the SCB an AVDT_SCB_API_OPEN_REQ_EVT 587 * to initiate sending of an open command message. 588 * 589 * Returns Nothing. 590 * 591 ******************************************************************************/ 592 void avdt_scb_hdl_setconfig_rsp(AvdtpScb* p_scb, 593 UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 594 tAVDT_EVT_HDR single; 595 596 if (p_scb->p_ccb != NULL) { 597 /* save configuration */ 598 p_scb->curr_cfg = p_scb->req_cfg; 599 600 /* initiate open */ 601 single.seid = p_scb->peer_seid; 602 tAVDT_SCB_EVT avdt_scb_evt; 603 avdt_scb_evt.msg.single = single; 604 avdt_scb_event(p_scb, AVDT_SCB_API_OPEN_REQ_EVT, &avdt_scb_evt); 605 } 606 } 607 608 /******************************************************************************* 609 * 610 * Function avdt_scb_hdl_start_cmd 611 * 612 * Description This function calls the application callback with a 613 * start indication. 614 * 615 * Returns Nothing. 616 * 617 ******************************************************************************/ 618 void avdt_scb_hdl_start_cmd(AvdtpScb* p_scb, 619 UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 620 (*p_scb->stream_config.p_avdt_ctrl_cback)( 621 avdt_scb_to_hdl(p_scb), 622 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, 623 AVDT_START_IND_EVT, NULL, p_scb->stream_config.scb_index); 624 } 625 626 /******************************************************************************* 627 * 628 * Function avdt_scb_hdl_start_rsp 629 * 630 * Description This function calls the application callback with a 631 * start confirm. 632 * 633 * Returns Nothing. 634 * 635 ******************************************************************************/ 636 void avdt_scb_hdl_start_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 637 (*p_scb->stream_config.p_avdt_ctrl_cback)( 638 avdt_scb_to_hdl(p_scb), 639 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, 640 AVDT_START_CFM_EVT, (tAVDT_CTRL*)&p_data->msg.hdr, 641 p_scb->stream_config.scb_index); 642 } 643 644 /******************************************************************************* 645 * 646 * Function avdt_scb_hdl_suspend_cmd 647 * 648 * Description This function calls the application callback with a suspend 649 * indication. 650 * 651 * Returns Nothing. 652 * 653 ******************************************************************************/ 654 void avdt_scb_hdl_suspend_cmd(AvdtpScb* p_scb, 655 UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 656 (*p_scb->stream_config.p_avdt_ctrl_cback)( 657 avdt_scb_to_hdl(p_scb), 658 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, 659 AVDT_SUSPEND_IND_EVT, NULL, p_scb->stream_config.scb_index); 660 } 661 662 /******************************************************************************* 663 * 664 * Function avdt_scb_hdl_suspend_rsp 665 * 666 * Description This function calls the application callback with a suspend 667 * confirm. 668 * 669 * Returns Nothing. 670 * 671 ******************************************************************************/ 672 void avdt_scb_hdl_suspend_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 673 (*p_scb->stream_config.p_avdt_ctrl_cback)( 674 avdt_scb_to_hdl(p_scb), 675 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, 676 AVDT_SUSPEND_CFM_EVT, (tAVDT_CTRL*)&p_data->msg.hdr, 677 p_scb->stream_config.scb_index); 678 } 679 680 /******************************************************************************* 681 * 682 * Function avdt_scb_hdl_tc_close 683 * 684 * Description This function is called when the transport channel is 685 * closed. It marks the SCB as not in use and 686 * initializes certain SCB parameters. It then sends 687 * an AVDT_CCB_UL_CLOSE_EVT to the CCB if the SCB 688 * initiated the close. It then checks to see if the SCB 689 * is to be removed. If it is it deallocates the SCB. 690 * Finally, it calls the application callback with a close 691 * indication. 692 * 693 * Returns Nothing. 694 * 695 ******************************************************************************/ 696 void avdt_scb_hdl_tc_close(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 697 uint8_t hdl = avdt_scb_to_hdl(p_scb); 698 tAVDT_CTRL_CBACK* p_avdt_ctrl_cback = p_scb->stream_config.p_avdt_ctrl_cback; 699 tAVDT_CTRL avdt_ctrl; 700 uint8_t event; 701 AvdtpCcb* p_ccb = p_scb->p_ccb; 702 RawAddress remote_addr = p_ccb->peer_addr; 703 uint8_t scb_index = p_scb->stream_config.scb_index; 704 705 /* set up hdr */ 706 avdt_ctrl.hdr.err_code = p_scb->close_code; 707 708 /* clear sep variables */ 709 avdt_scb_clr_vars(p_scb, p_data); 710 p_scb->media_seq = 0; 711 p_scb->cong = false; 712 713 /* free pkt we're holding, if any */ 714 osi_free_and_reset((void**)&p_scb->p_pkt); 715 716 alarm_cancel(p_scb->transport_channel_timer); 717 718 if ((p_scb->role == AVDT_CLOSE_INT) || (p_scb->role == AVDT_OPEN_INT)) { 719 /* tell ccb we're done with signaling channel */ 720 avdt_ccb_event(p_ccb, AVDT_CCB_UL_CLOSE_EVT, NULL); 721 } 722 event = 723 (p_scb->role == AVDT_CLOSE_INT) ? AVDT_CLOSE_CFM_EVT : AVDT_CLOSE_IND_EVT; 724 p_scb->role = AVDT_CLOSE_ACP; 725 726 if (p_scb->remove) { 727 avdt_scb_dealloc(p_scb, NULL); 728 } 729 730 /* call app callback */ 731 (*p_avdt_ctrl_cback)(hdl, remote_addr, event, &avdt_ctrl, scb_index); 732 } 733 734 /******************************************************************************* 735 * 736 * Function avdt_scb_snd_delay_rpt_req 737 * 738 * Description This function calls the application callback with a delay 739 * report. 740 * 741 * Returns Nothing. 742 * 743 ******************************************************************************/ 744 void avdt_scb_snd_delay_rpt_req(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 745 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_DELAY_RPT, 746 (tAVDT_MSG*)&p_data->apidelay); 747 } 748 749 /******************************************************************************* 750 * 751 * Function avdt_scb_hdl_delay_rpt_cmd 752 * 753 * Description This function calls the application callback with a delay 754 * report. 755 * 756 * Returns Nothing. 757 * 758 ******************************************************************************/ 759 void avdt_scb_hdl_delay_rpt_cmd(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 760 (*p_scb->stream_config.p_avdt_ctrl_cback)( 761 avdt_scb_to_hdl(p_scb), 762 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, 763 AVDT_DELAY_REPORT_EVT, (tAVDT_CTRL*)&p_data->msg.hdr, 764 p_scb->stream_config.scb_index); 765 766 if (p_scb->p_ccb) 767 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_DELAY_RPT, &p_data->msg); 768 else 769 avdt_scb_rej_not_in_use(p_scb, p_data); 770 } 771 772 /******************************************************************************* 773 * 774 * Function avdt_scb_hdl_delay_rpt_rsp 775 * 776 * Description This function calls the application callback with a delay 777 * report. 778 * 779 * Returns Nothing. 780 * 781 ******************************************************************************/ 782 void avdt_scb_hdl_delay_rpt_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 783 (*p_scb->stream_config.p_avdt_ctrl_cback)( 784 avdt_scb_to_hdl(p_scb), 785 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, 786 AVDT_DELAY_REPORT_CFM_EVT, (tAVDT_CTRL*)&p_data->msg.hdr, 787 p_scb->stream_config.scb_index); 788 } 789 790 /******************************************************************************* 791 * 792 * Function avdt_scb_hdl_tc_close_sto 793 * 794 * Description This function is called when a channel is closed in OPEN 795 * state. Check the channel type and process accordingly. 796 * 797 * Returns Nothing. 798 * 799 ******************************************************************************/ 800 void avdt_scb_hdl_tc_close_sto(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 801 tAVDT_CTRL avdt_ctrl; 802 /* AVDT_CHAN_SIG does not visit this action */ 803 if (p_data && p_data->close.type != AVDT_CHAN_MEDIA) { 804 /* it's reporting or recovery channel, 805 * the channel close in open state means the peer does not support it */ 806 if (p_data->close.old_tc_state == AVDT_AD_ST_OPEN) { 807 avdt_ctrl.hdr.err_code = 0; 808 avdt_ctrl.hdr.err_param = 0; 809 /* call app callback */ 810 (*p_scb->stream_config.p_avdt_ctrl_cback)( 811 avdt_scb_to_hdl(p_scb), 812 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, 813 AVDT_REPORT_DISCONN_EVT, &avdt_ctrl, p_scb->stream_config.scb_index); 814 } 815 } else { 816 /* must be in OPEN state. need to go back to idle */ 817 avdt_scb_event(p_scb, AVDT_SCB_MSG_ABORT_RSP_EVT, NULL); 818 avdt_scb_hdl_tc_close(p_scb, p_data); 819 } 820 } 821 822 /******************************************************************************* 823 * 824 * Function avdt_scb_hdl_tc_open 825 * 826 * Description This function is called when the transport channel is 827 * opened while in the opening state. It calls the 828 * application callback with an open indication or open 829 * confirm depending on who initiated the open procedure. 830 * 831 * Returns Nothing. 832 * 833 ******************************************************************************/ 834 void avdt_scb_hdl_tc_open(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 835 uint8_t event; 836 uint8_t role; 837 838 alarm_cancel(p_scb->transport_channel_timer); 839 840 event = 841 (p_scb->role == AVDT_OPEN_INT) ? AVDT_OPEN_CFM_EVT : AVDT_OPEN_IND_EVT; 842 p_data->open.hdr.err_code = 0; 843 844 AVDT_TRACE_DEBUG("%s: psc_mask: cfg: 0x%x, req:0x%x, cur: 0x%x", __func__, 845 p_scb->stream_config.cfg.psc_mask, p_scb->req_cfg.psc_mask, 846 p_scb->curr_cfg.psc_mask); 847 if (p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT) { 848 /* open the reporting channel, if both devices support it */ 849 role = (p_scb->role == AVDT_OPEN_INT) ? AVDT_INT : AVDT_ACP; 850 avdt_ad_open_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb, role); 851 } 852 853 /* call app callback */ 854 (*p_scb->stream_config.p_avdt_ctrl_cback)( 855 avdt_scb_to_hdl(p_scb), 856 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, event, 857 (tAVDT_CTRL*)&p_data->open, p_scb->stream_config.scb_index); 858 } 859 860 /******************************************************************************* 861 * 862 * Function avdt_scb_hdl_tc_open_sto 863 * 864 * Description This function is called when the transport channel is 865 * opened while in the opening state. It calls the 866 * application callback with an open indication or open 867 * confirm depending on who initiated the open procedure. 868 * 869 * Returns Nothing. 870 * 871 ******************************************************************************/ 872 void avdt_scb_hdl_tc_open_sto(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 873 tAVDT_CTRL avdt_ctrl; 874 /* open reporting channel here, when it is implemented */ 875 876 /* call app callback */ 877 if (p_data->open.hdr.err_code == AVDT_CHAN_REPORT) { 878 avdt_ctrl.hdr.err_code = 0; 879 avdt_ctrl.hdr.err_param = 1; 880 (*p_scb->stream_config.p_avdt_ctrl_cback)( 881 avdt_scb_to_hdl(p_scb), 882 p_scb->p_ccb ? p_scb->p_ccb->peer_addr : RawAddress::kEmpty, 883 AVDT_REPORT_CONN_EVT, &avdt_ctrl, p_scb->stream_config.scb_index); 884 } 885 } 886 887 /******************************************************************************* 888 * 889 * Function avdt_scb_hdl_write_req 890 * 891 * Description This function frees the media packet currently stored in 892 * the SCB, if any. Then it builds a new media packet from 893 * with the passed in buffer and stores it in the SCB. 894 * 895 * Returns Nothing. 896 * 897 ******************************************************************************/ 898 void avdt_scb_hdl_write_req(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 899 uint8_t* p; 900 uint32_t ssrc; 901 bool add_rtp_header = !(p_data->apiwrite.opt & AVDT_DATA_OPT_NO_RTP); 902 903 /* free packet we're holding, if any; to be replaced with new */ 904 if (p_scb->p_pkt != NULL) { 905 /* this shouldn't be happening */ 906 AVDT_TRACE_WARNING("Dropped media packet; congested"); 907 } 908 osi_free_and_reset((void**)&p_scb->p_pkt); 909 910 /* Recompute only if the RTP header wasn't disabled by the API */ 911 if (add_rtp_header) { 912 bool is_content_protection = (p_scb->curr_cfg.num_protect > 0); 913 add_rtp_header = 914 A2DP_UsesRtpHeader(is_content_protection, p_scb->curr_cfg.codec_info); 915 } 916 917 /* Build a media packet, and add an RTP header if required. */ 918 if (add_rtp_header) { 919 ssrc = avdt_scb_gen_ssrc(p_scb); 920 921 p_data->apiwrite.p_buf->len += AVDT_MEDIA_HDR_SIZE; 922 p_data->apiwrite.p_buf->offset -= AVDT_MEDIA_HDR_SIZE; 923 p_scb->media_seq++; 924 p = (uint8_t*)(p_data->apiwrite.p_buf + 1) + p_data->apiwrite.p_buf->offset; 925 926 UINT8_TO_BE_STREAM(p, AVDT_MEDIA_OCTET1); 927 UINT8_TO_BE_STREAM(p, p_data->apiwrite.m_pt); 928 UINT16_TO_BE_STREAM(p, p_scb->media_seq); 929 UINT32_TO_BE_STREAM(p, p_data->apiwrite.time_stamp); 930 UINT32_TO_BE_STREAM(p, ssrc); 931 } 932 933 /* store it */ 934 p_scb->p_pkt = p_data->apiwrite.p_buf; 935 } 936 937 /******************************************************************************* 938 * 939 * Function avdt_scb_snd_abort_req 940 * 941 * Description This function sends an abort command message. 942 * 943 * Returns Nothing. 944 * 945 ******************************************************************************/ 946 void avdt_scb_snd_abort_req(AvdtpScb* p_scb, 947 UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 948 tAVDT_EVT_HDR hdr; 949 950 AVDT_TRACE_DEBUG("%s: p_scb->p_ccb=%p", __func__, p_scb->p_ccb); 951 952 if (p_scb->p_ccb != NULL) { 953 p_scb->role = AVDT_CLOSE_INT; 954 955 hdr.seid = p_scb->peer_seid; 956 957 tAVDT_MSG avdt_msg; 958 avdt_msg.hdr = hdr; 959 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_ABORT, &avdt_msg); 960 } 961 } 962 963 /******************************************************************************* 964 * 965 * Function avdt_scb_snd_abort_rsp 966 * 967 * Description This function sends an abort response message. 968 * 969 * Returns Nothing. 970 * 971 ******************************************************************************/ 972 void avdt_scb_snd_abort_rsp(UNUSED_ATTR AvdtpScb* p_scb, 973 tAVDT_SCB_EVT* p_data) { 974 avdt_msg_send_rsp(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx), AVDT_SIG_ABORT, 975 &p_data->msg); 976 } 977 978 /******************************************************************************* 979 * 980 * Function avdt_scb_snd_close_req 981 * 982 * Description This function sends a close command message. 983 * 984 * Returns Nothing. 985 * 986 ******************************************************************************/ 987 void avdt_scb_snd_close_req(AvdtpScb* p_scb, 988 UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 989 tAVDT_EVT_HDR hdr; 990 991 p_scb->role = AVDT_CLOSE_INT; 992 993 hdr.seid = p_scb->peer_seid; 994 995 tAVDT_MSG avdt_msg; 996 avdt_msg.hdr = hdr; 997 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_CLOSE, &avdt_msg); 998 } 999 1000 /******************************************************************************* 1001 * 1002 * Function avdt_scb_snd_stream_close 1003 * 1004 * Description This function sends a close command message. 1005 * 1006 * Returns Nothing. 1007 * 1008 ******************************************************************************/ 1009 void avdt_scb_snd_stream_close(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1010 osi_free_and_reset((void**)&p_scb->p_pkt); 1011 avdt_scb_snd_close_req(p_scb, p_data); 1012 } 1013 1014 /******************************************************************************* 1015 * 1016 * Function avdt_scb_snd_close_rsp 1017 * 1018 * Description This function sends a close response message. 1019 * 1020 * Returns Nothing. 1021 * 1022 ******************************************************************************/ 1023 void avdt_scb_snd_close_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1024 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_CLOSE, &p_data->msg); 1025 } 1026 1027 /******************************************************************************* 1028 * 1029 * Function avdt_scb_snd_getconfig_req 1030 * 1031 * Description This function sends a get configuration command message. 1032 * 1033 * Returns Nothing. 1034 * 1035 ******************************************************************************/ 1036 void avdt_scb_snd_getconfig_req(AvdtpScb* p_scb, 1037 UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 1038 tAVDT_EVT_HDR hdr; 1039 1040 hdr.seid = p_scb->peer_seid; 1041 1042 tAVDT_MSG avdt_msg; 1043 avdt_msg.hdr = hdr; 1044 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_GETCONFIG, &avdt_msg); 1045 } 1046 1047 /******************************************************************************* 1048 * 1049 * Function avdt_scb_snd_getconfig_rsp 1050 * 1051 * Description This function sends a get configuration response message. 1052 * 1053 * Returns Nothing. 1054 * 1055 ******************************************************************************/ 1056 void avdt_scb_snd_getconfig_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1057 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_GETCONFIG, &p_data->msg); 1058 } 1059 1060 /******************************************************************************* 1061 * 1062 * Function avdt_scb_snd_open_req 1063 * 1064 * Description This function sends an open command message. 1065 * 1066 * Returns Nothing. 1067 * 1068 ******************************************************************************/ 1069 void avdt_scb_snd_open_req(AvdtpScb* p_scb, UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 1070 tAVDT_EVT_HDR hdr; 1071 1072 hdr.seid = p_scb->peer_seid; 1073 1074 tAVDT_MSG avdt_msg; 1075 avdt_msg.hdr = hdr; 1076 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_OPEN, &avdt_msg); 1077 } 1078 1079 /******************************************************************************* 1080 * 1081 * Function avdt_scb_snd_open_rsp 1082 * 1083 * Description This function sends an open response message. It also 1084 * calls avdt_ad_open_req() to accept a transport channel 1085 * connection. 1086 * 1087 * Returns Nothing. 1088 * 1089 ******************************************************************************/ 1090 void avdt_scb_snd_open_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1091 /* notify adaption that we're waiting for transport channel open */ 1092 p_scb->role = AVDT_OPEN_ACP; 1093 avdt_ad_open_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, AVDT_ACP); 1094 1095 /* send response */ 1096 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_OPEN, &p_data->msg); 1097 1098 alarm_set_on_mloop(p_scb->transport_channel_timer, 1099 AVDT_SCB_TC_CONN_TIMEOUT_MS, 1100 avdt_scb_transport_channel_timer_timeout, p_scb); 1101 } 1102 1103 /******************************************************************************* 1104 * 1105 * Function avdt_scb_snd_reconfig_req 1106 * 1107 * Description This function stores the configuration parameters in the 1108 * SCB and sends a reconfiguration command message. 1109 * 1110 * Returns Nothing. 1111 * 1112 ******************************************************************************/ 1113 void avdt_scb_snd_reconfig_req(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1114 AVDT_TRACE_DEBUG("%s: p_scb->peer_seid=%d p_data->msg.hdr.seid=%d", __func__, 1115 p_scb->peer_seid, p_data->msg.hdr.seid); 1116 AVDT_TRACE_DEBUG( 1117 "%s: codec: %s", __func__, 1118 A2DP_CodecInfoString(p_data->msg.config_cmd.p_cfg->codec_info).c_str()); 1119 1120 p_scb->req_cfg = *p_data->msg.config_cmd.p_cfg; 1121 p_data->msg.hdr.seid = p_scb->peer_seid; 1122 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_RECONFIG, &p_data->msg); 1123 } 1124 1125 /******************************************************************************* 1126 * 1127 * Function avdt_scb_snd_reconfig_rsp 1128 * 1129 * Description This function stores the configuration parameters in the 1130 * SCB and sends a reconfiguration response message. 1131 * 1132 * Returns Nothing. 1133 * 1134 ******************************************************************************/ 1135 void avdt_scb_snd_reconfig_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1136 if (p_data->msg.hdr.err_code == 0) { 1137 /* store new configuration */ 1138 if (p_scb->req_cfg.num_codec > 0) { 1139 p_scb->curr_cfg.num_codec = p_scb->req_cfg.num_codec; 1140 memcpy(p_scb->curr_cfg.codec_info, p_scb->req_cfg.codec_info, 1141 AVDT_CODEC_SIZE); 1142 } 1143 if (p_scb->req_cfg.num_protect > 0) { 1144 p_scb->curr_cfg.num_protect = p_scb->req_cfg.num_protect; 1145 memcpy(p_scb->curr_cfg.protect_info, p_scb->req_cfg.protect_info, 1146 AVDT_PROTECT_SIZE); 1147 } 1148 1149 /* send response */ 1150 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_RECONFIG, &p_data->msg); 1151 } else { 1152 /* send reject */ 1153 avdt_msg_send_rej(p_scb->p_ccb, AVDT_SIG_RECONFIG, &p_data->msg); 1154 } 1155 } 1156 1157 /******************************************************************************* 1158 * 1159 * Function avdt_scb_snd_security_req 1160 * 1161 * Description This function sends a security command message. 1162 * 1163 * Returns Nothing. 1164 * 1165 ******************************************************************************/ 1166 void avdt_scb_snd_security_req(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1167 p_data->msg.hdr.seid = p_scb->peer_seid; 1168 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_SECURITY, &p_data->msg); 1169 } 1170 1171 /******************************************************************************* 1172 * 1173 * Function avdt_scb_snd_security_rsp 1174 * 1175 * Description This function sends a security response message. 1176 * 1177 * Returns Nothing. 1178 * 1179 ******************************************************************************/ 1180 void avdt_scb_snd_security_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1181 if (p_data->msg.hdr.err_code == 0) { 1182 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_SECURITY, &p_data->msg); 1183 } else { 1184 avdt_msg_send_rej(p_scb->p_ccb, AVDT_SIG_SECURITY, &p_data->msg); 1185 } 1186 } 1187 1188 /******************************************************************************* 1189 * 1190 * Function avdt_scb_snd_setconfig_rej 1191 * 1192 * Description This function marks the SCB as not in use and sends a 1193 * set configuration reject message. 1194 * 1195 * Returns Nothing. 1196 * 1197 ******************************************************************************/ 1198 void avdt_scb_snd_setconfig_rej(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1199 if (p_scb->p_ccb != NULL) { 1200 avdt_msg_send_rej(p_scb->p_ccb, AVDT_SIG_SETCONFIG, &p_data->msg); 1201 1202 /* clear scb variables */ 1203 avdt_scb_clr_vars(p_scb, p_data); 1204 } 1205 } 1206 1207 /******************************************************************************* 1208 * 1209 * Function avdt_scb_snd_setconfig_req 1210 * 1211 * Description This function marks the SCB as in use and copies the 1212 * configuration parameters to the SCB. Then the function 1213 * sends a set configuration command message and initiates 1214 * opening of the signaling channel. 1215 * 1216 * Returns Nothing. 1217 * 1218 ******************************************************************************/ 1219 void avdt_scb_snd_setconfig_req(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1220 AvdtpSepConfig *p_req, *p_cfg; 1221 1222 AVDT_TRACE_DEBUG( 1223 "%s: codec: %s", __func__, 1224 A2DP_CodecInfoString(p_data->msg.config_cmd.p_cfg->codec_info).c_str()); 1225 1226 /* copy API parameters to scb, set scb as in use */ 1227 1228 AvdtpCcb* p_ccb = avdt_ccb_by_idx(p_data->msg.config_cmd.hdr.ccb_idx); 1229 if (p_scb->p_ccb != p_ccb) { 1230 AVDT_TRACE_ERROR( 1231 "%s: mismatch in AVDTP SCB/CCB state: (p_scb->p_ccb=%p != p_ccb=%p): " 1232 "p_scb=%p scb_handle=%d ccb_idx=%d", 1233 __func__, p_scb->p_ccb, p_ccb, p_scb, p_scb->ScbHandle(), 1234 p_data->msg.config_cmd.hdr.ccb_idx); 1235 avdt_scb_rej_not_in_use(p_scb, p_data); 1236 return; 1237 } 1238 p_scb->in_use = true; 1239 p_scb->peer_seid = p_data->msg.config_cmd.hdr.seid; 1240 p_req = p_data->msg.config_cmd.p_cfg; 1241 p_cfg = &p_scb->stream_config.cfg; 1242 p_scb->req_cfg = *p_data->msg.config_cmd.p_cfg; 1243 1244 avdt_msg_send_cmd(p_scb->p_ccb, p_scb, AVDT_SIG_SETCONFIG, &p_data->msg); 1245 1246 /* tell ccb to open channel */ 1247 avdt_ccb_event(p_scb->p_ccb, AVDT_CCB_UL_OPEN_EVT, NULL); 1248 } 1249 1250 /******************************************************************************* 1251 * 1252 * Function avdt_scb_snd_setconfig_rsp 1253 * 1254 * Description This function copies the requested configuration into the 1255 * current configuration and sends a set configuration 1256 * response message. 1257 * 1258 * Returns Nothing. 1259 * 1260 ******************************************************************************/ 1261 void avdt_scb_snd_setconfig_rsp(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1262 if (p_scb->p_ccb != NULL) { 1263 p_scb->curr_cfg = p_scb->req_cfg; 1264 1265 avdt_msg_send_rsp(p_scb->p_ccb, AVDT_SIG_SETCONFIG, &p_data->msg); 1266 } 1267 } 1268 1269 /******************************************************************************* 1270 * 1271 * Function avdt_scb_snd_tc_close 1272 * 1273 * Description This function calls avdt_ad_close_req() to close the 1274 * transport channel for this SCB. 1275 * 1276 * Returns Nothing. 1277 * 1278 ******************************************************************************/ 1279 void avdt_scb_snd_tc_close(AvdtpScb* p_scb, UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 1280 if (p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT) 1281 avdt_ad_close_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb); 1282 avdt_ad_close_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb); 1283 } 1284 1285 /******************************************************************************* 1286 * 1287 * Function avdt_scb_cb_err 1288 * 1289 * Description This function calls the application callback function 1290 * indicating an error. 1291 * 1292 * Returns Nothing. 1293 * 1294 ******************************************************************************/ 1295 void avdt_scb_cb_err(AvdtpScb* p_scb, UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 1296 tAVDT_CTRL avdt_ctrl; 1297 1298 /* set error code and parameter */ 1299 avdt_ctrl.hdr.err_code = AVDT_ERR_BAD_STATE; 1300 avdt_ctrl.hdr.err_param = 0; 1301 1302 /* call callback, using lookup table to get callback event */ 1303 (*p_scb->stream_config.p_avdt_ctrl_cback)( 1304 avdt_scb_to_hdl(p_scb), RawAddress::kEmpty, 1305 avdt_scb_cback_evt[p_scb->curr_evt], &avdt_ctrl, 1306 p_scb->stream_config.scb_index); 1307 } 1308 1309 /******************************************************************************* 1310 * 1311 * Function avdt_scb_cong_state 1312 * 1313 * Description This function sets the congestion state of the SCB media 1314 * transport channel. 1315 * 1316 * Returns Nothing. 1317 * 1318 ******************************************************************************/ 1319 void avdt_scb_cong_state(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1320 p_scb->cong = p_data->llcong; 1321 } 1322 1323 /******************************************************************************* 1324 * 1325 * Function avdt_scb_rej_state 1326 * 1327 * Description This function sends a reject message to the peer indicating 1328 * incorrect state for the received command message. 1329 * 1330 * Returns Nothing. 1331 * 1332 ******************************************************************************/ 1333 void avdt_scb_rej_state(UNUSED_ATTR AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1334 p_data->msg.hdr.err_code = AVDT_ERR_BAD_STATE; 1335 p_data->msg.hdr.err_param = 0; 1336 avdt_msg_send_rej(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx), 1337 p_data->msg.hdr.sig_id, &p_data->msg); 1338 } 1339 1340 /******************************************************************************* 1341 * 1342 * Function avdt_scb_rej_in_use 1343 * 1344 * Description This function sends a reject message to the peer indicating 1345 * the stream is in use. 1346 * 1347 * Returns Nothing. 1348 * 1349 ******************************************************************************/ 1350 void avdt_scb_rej_in_use(UNUSED_ATTR AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1351 p_data->msg.hdr.err_code = AVDT_ERR_IN_USE; 1352 p_data->msg.hdr.err_param = 0; 1353 avdt_msg_send_rej(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx), 1354 p_data->msg.hdr.sig_id, &p_data->msg); 1355 } 1356 1357 /******************************************************************************* 1358 * 1359 * Function avdt_scb_rej_not_in_use 1360 * 1361 * Description This function sends a reject message to the peer indicating 1362 * the stream is in use. 1363 * 1364 * Returns Nothing. 1365 * 1366 ******************************************************************************/ 1367 void avdt_scb_rej_not_in_use(UNUSED_ATTR AvdtpScb* p_scb, 1368 tAVDT_SCB_EVT* p_data) { 1369 p_data->msg.hdr.err_code = AVDT_ERR_NOT_IN_USE; 1370 p_data->msg.hdr.err_param = 0; 1371 avdt_msg_send_rej(avdt_ccb_by_idx(p_data->msg.hdr.ccb_idx), 1372 p_data->msg.hdr.sig_id, &p_data->msg); 1373 } 1374 1375 /******************************************************************************* 1376 * 1377 * Function avdt_scb_set_remove 1378 * 1379 * Description This function marks an SCB to be removed. 1380 * 1381 * Returns Nothing. 1382 * 1383 ******************************************************************************/ 1384 void avdt_scb_set_remove(AvdtpScb* p_scb, UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 1385 p_scb->remove = true; 1386 } 1387 1388 /******************************************************************************* 1389 * 1390 * Function avdt_scb_free_pkt 1391 * 1392 * Description This function frees the media packet passed in. 1393 * 1394 * Returns Nothing. 1395 * 1396 ******************************************************************************/ 1397 void avdt_scb_free_pkt(AvdtpScb* p_scb, tAVDT_SCB_EVT* p_data) { 1398 tAVDT_CTRL avdt_ctrl; 1399 1400 /* set error code and parameter */ 1401 avdt_ctrl.hdr.err_code = AVDT_ERR_BAD_STATE; 1402 avdt_ctrl.hdr.err_param = 0; 1403 1404 osi_free_and_reset((void**)&p_data->apiwrite.p_buf); 1405 1406 AVDT_TRACE_WARNING("Dropped media packet"); 1407 1408 /* we need to call callback to keep data flow going */ 1409 (*p_scb->stream_config.p_avdt_ctrl_cback)( 1410 avdt_scb_to_hdl(p_scb), RawAddress::kEmpty, AVDT_WRITE_CFM_EVT, 1411 &avdt_ctrl, p_scb->stream_config.scb_index); 1412 } 1413 1414 /******************************************************************************* 1415 * 1416 * Function avdt_scb_clr_pkt 1417 * 1418 * Description This function frees the media packet stored in the SCB. 1419 * 1420 * Returns Nothing. 1421 * 1422 ******************************************************************************/ 1423 void avdt_scb_clr_pkt(AvdtpScb* p_scb, UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 1424 tAVDT_CTRL avdt_ctrl; 1425 AvdtpCcb* p_ccb; 1426 uint8_t tcid; 1427 uint16_t lcid; 1428 1429 /* set error code and parameter */ 1430 avdt_ctrl.hdr.err_code = AVDT_ERR_BAD_STATE; 1431 avdt_ctrl.hdr.err_param = 0; 1432 /* flush the media data queued at L2CAP */ 1433 p_ccb = p_scb->p_ccb; 1434 if (p_ccb != NULL) { 1435 /* get tcid from type, scb */ 1436 tcid = avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb); 1437 1438 lcid = avdtp_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid; 1439 L2CA_FlushChannel(lcid, L2CAP_FLUSH_CHANS_ALL); 1440 } 1441 1442 if (p_scb->p_pkt != NULL) { 1443 osi_free_and_reset((void**)&p_scb->p_pkt); 1444 1445 AVDT_TRACE_DEBUG("Dropped stored media packet"); 1446 1447 /* we need to call callback to keep data flow going */ 1448 (*p_scb->stream_config.p_avdt_ctrl_cback)( 1449 avdt_scb_to_hdl(p_scb), RawAddress::kEmpty, AVDT_WRITE_CFM_EVT, 1450 &avdt_ctrl, p_scb->stream_config.scb_index); 1451 } 1452 } 1453 1454 /******************************************************************************* 1455 * 1456 * Function avdt_scb_chk_snd_pkt 1457 * 1458 * Description This function checks if the SCB is congested, and if not 1459 * congested it sends a stored media packet, if any. After it 1460 * sends the packet it calls the application callback function 1461 * with a write confirm. 1462 * 1463 * Returns Nothing. 1464 * 1465 ******************************************************************************/ 1466 void avdt_scb_chk_snd_pkt(AvdtpScb* p_scb, UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 1467 tAVDT_CTRL avdt_ctrl; 1468 BT_HDR* p_pkt; 1469 1470 avdt_ctrl.hdr.err_code = 0; 1471 1472 if (!p_scb->cong) { 1473 if (p_scb->p_pkt != NULL) { 1474 p_pkt = p_scb->p_pkt; 1475 p_scb->p_pkt = NULL; 1476 avdt_ad_write_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, p_pkt); 1477 1478 (*p_scb->stream_config.p_avdt_ctrl_cback)( 1479 avdt_scb_to_hdl(p_scb), RawAddress::kEmpty, AVDT_WRITE_CFM_EVT, 1480 &avdt_ctrl, p_scb->stream_config.scb_index); 1481 } 1482 } 1483 } 1484 1485 /******************************************************************************* 1486 * 1487 * Function avdt_scb_transport_channel_timer 1488 * 1489 * Description This function is called to start a timer when the peer 1490 * initiates closing of the stream. The timer verifies that 1491 * the peer disconnects the transport channel. 1492 * 1493 * Returns Nothing. 1494 * 1495 ******************************************************************************/ 1496 void avdt_scb_transport_channel_timer(AvdtpScb* p_scb, 1497 UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 1498 alarm_set_on_mloop(p_scb->transport_channel_timer, 1499 AVDT_SCB_TC_DISC_TIMEOUT_MS, 1500 avdt_scb_transport_channel_timer_timeout, p_scb); 1501 } 1502 1503 /******************************************************************************* 1504 * 1505 * Function avdt_scb_clr_vars 1506 * 1507 * Description This function initializes certain SCB variables. 1508 * 1509 * Returns Nothing. 1510 * 1511 ******************************************************************************/ 1512 void avdt_scb_clr_vars(AvdtpScb* p_scb, UNUSED_ATTR tAVDT_SCB_EVT* p_data) { 1513 p_scb->in_use = false; 1514 p_scb->peer_seid = 0; 1515 } 1516
