1 /****************************************************************************** 2 * 3 * Copyright (C) 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 API of the audio/video distribution transport 22 * protocol. 23 * 24 ******************************************************************************/ 25 26 #include <string.h> 27 #include "data_types.h" 28 #include "bt_target.h" 29 #include "avdt_api.h" 30 #include "avdtc_api.h" 31 #include "avdt_int.h" 32 #include "l2c_api.h" 33 #include "btm_api.h" 34 #include "btu.h" 35 36 37 #if (defined BTTRC_INCLUDED && BTTRC_INCLUDED == TRUE) 38 #include "bttrc_str_ids.h" 39 #endif 40 41 /* Control block for AVDT */ 42 #if AVDT_DYNAMIC_MEMORY == FALSE 43 tAVDT_CB avdt_cb; 44 #endif 45 46 47 /******************************************************************************* 48 ** 49 ** Function avdt_process_timeout 50 ** 51 ** Description This function is called by BTU when an AVDTP timer 52 ** expires. The function sends a timer event to the 53 ** appropriate CCB or SCB state machine. 54 ** 55 ** This function is for use internal to the stack only. 56 ** 57 ** 58 ** Returns void 59 ** 60 *******************************************************************************/ 61 void avdt_process_timeout(TIMER_LIST_ENT *p_tle) 62 { 63 UINT8 event = 0; 64 UINT8 err_code = AVDT_ERR_TIMEOUT; 65 66 switch (p_tle->event) 67 { 68 case BTU_TTYPE_AVDT_CCB_RET: 69 event = AVDT_CCB_RET_TOUT_EVT + AVDT_CCB_MKR; 70 break; 71 72 case BTU_TTYPE_AVDT_CCB_RSP: 73 event = AVDT_CCB_RSP_TOUT_EVT + AVDT_CCB_MKR; 74 break; 75 76 case BTU_TTYPE_AVDT_CCB_IDLE: 77 event = AVDT_CCB_IDLE_TOUT_EVT + AVDT_CCB_MKR; 78 break; 79 80 case BTU_TTYPE_AVDT_SCB_TC: 81 event = AVDT_SCB_TC_TOUT_EVT; 82 break; 83 84 default: 85 break; 86 } 87 88 if (event & AVDT_CCB_MKR) 89 { 90 avdt_ccb_event((tAVDT_CCB *) p_tle->param, (UINT8) (event & ~AVDT_CCB_MKR), 91 (tAVDT_CCB_EVT *) &err_code); 92 } 93 else 94 { 95 avdt_scb_event((tAVDT_SCB *) p_tle->param, event, NULL); 96 } 97 } 98 99 /******************************************************************************* 100 ** 101 ** Function AVDT_Register 102 ** 103 ** Description This is the system level registration function for the 104 ** AVDTP protocol. This function initializes AVDTP and 105 ** prepares the protocol stack for its use. This function 106 ** must be called once by the system or platform using AVDTP 107 ** before the other functions of the API an be used. 108 ** 109 ** 110 ** Returns void 111 ** 112 *******************************************************************************/ 113 void AVDT_Register(tAVDT_REG *p_reg, tAVDT_CTRL_CBACK *p_cback) 114 { 115 116 BTTRC_AVDT_API0(AVDT_TRACE_API_REGISTER); 117 118 /* register PSM with L2CAP */ 119 L2CA_Register(AVDT_PSM, (tL2CAP_APPL_INFO *) &avdt_l2c_appl); 120 121 /* set security level */ 122 BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_AVDTP, p_reg->sec_mask, 123 AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_SIG); 124 BTM_SetSecurityLevel(FALSE, "", BTM_SEC_SERVICE_AVDTP, p_reg->sec_mask, 125 AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_SIG); 126 127 /* do not use security on the media channel */ 128 BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_AVDTP_NOSEC, BTM_SEC_NONE, 129 AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_MEDIA); 130 BTM_SetSecurityLevel(FALSE, "", BTM_SEC_SERVICE_AVDTP_NOSEC, BTM_SEC_NONE, 131 AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_MEDIA); 132 133 #if AVDT_REPORTING == TRUE 134 /* do not use security on the reporting channel */ 135 BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_AVDTP_NOSEC, BTM_SEC_NONE, 136 AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_REPORT); 137 BTM_SetSecurityLevel(FALSE, "", BTM_SEC_SERVICE_AVDTP_NOSEC, BTM_SEC_NONE, 138 AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_REPORT); 139 #endif 140 141 /* initialize AVDTP data structures */ 142 avdt_scb_init(); 143 avdt_ccb_init(); 144 avdt_ad_init(); 145 #if defined(AVDT_INITIAL_TRACE_LEVEL) 146 avdt_cb.trace_level = AVDT_INITIAL_TRACE_LEVEL; 147 #else 148 avdt_cb.trace_level = BT_TRACE_LEVEL_NONE; 149 #endif 150 151 /* copy registration struct */ 152 memcpy(&avdt_cb.rcb, p_reg, sizeof(tAVDT_REG)); 153 avdt_cb.p_conn_cback = p_cback; 154 } 155 156 /******************************************************************************* 157 ** 158 ** Function AVDT_Deregister 159 ** 160 ** Description This function is called to deregister use AVDTP protocol. 161 ** It is called when AVDTP is no longer being used by any 162 ** application in the system. Before this function can be 163 ** called, all streams must be removed with AVDT_RemoveStream(). 164 ** 165 ** 166 ** Returns void 167 ** 168 *******************************************************************************/ 169 void AVDT_Deregister(void) 170 { 171 BTTRC_AVDT_API0(AVDT_TRACE_API_DEREGISTER); 172 173 /* deregister PSM with L2CAP */ 174 L2CA_Deregister(AVDT_PSM); 175 } 176 177 /******************************************************************************* 178 ** 179 ** Function AVDT_CreateStream 180 ** 181 ** Description Create a stream endpoint. After a stream endpoint is 182 ** created an application can initiate a connection between 183 ** this endpoint and an endpoint on a peer device. In 184 ** addition, a peer device can discover, get the capabilities, 185 ** and connect to this endpoint. 186 ** 187 ** 188 ** Returns AVDT_SUCCESS if successful, otherwise error. 189 ** 190 *******************************************************************************/ 191 UINT16 AVDT_CreateStream(UINT8 *p_handle, tAVDT_CS *p_cs) 192 { 193 UINT16 result = AVDT_SUCCESS; 194 tAVDT_SCB *p_scb; 195 196 BTTRC_AVDT_API0(AVDT_TRACE_API_CREATESTREAM); 197 198 /* Verify parameters; if invalid, return failure */ 199 if (((p_cs->cfg.psc_mask & (~AVDT_PSC)) != 0) || (p_cs->p_ctrl_cback == NULL)) 200 { 201 result = AVDT_BAD_PARAMS; 202 } 203 /* Allocate scb; if no scbs, return failure */ 204 else if ((p_scb = avdt_scb_alloc(p_cs)) == NULL) 205 { 206 result = AVDT_NO_RESOURCES; 207 } 208 else 209 { 210 *p_handle = avdt_scb_to_hdl(p_scb); 211 } 212 return result; 213 } 214 215 /******************************************************************************* 216 ** 217 ** Function AVDT_RemoveStream 218 ** 219 ** Description Remove a stream endpoint. This function is called when 220 ** the application is no longer using a stream endpoint. 221 ** If this function is called when the endpoint is connected 222 ** the connection is closed and then the stream endpoint 223 ** is removed. 224 ** 225 ** 226 ** Returns AVDT_SUCCESS if successful, otherwise error. 227 ** 228 *******************************************************************************/ 229 UINT16 AVDT_RemoveStream(UINT8 handle) 230 { 231 UINT16 result = AVDT_SUCCESS; 232 tAVDT_SCB *p_scb; 233 234 235 BTTRC_AVDT_API0(AVDT_TRACE_API_REMOVESTREAM); 236 237 /* look up scb */ 238 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 239 { 240 result = AVDT_BAD_HANDLE; 241 } 242 else 243 { 244 /* send remove event to scb */ 245 avdt_scb_event(p_scb, AVDT_SCB_API_REMOVE_EVT, NULL); 246 } 247 return result; 248 } 249 250 /******************************************************************************* 251 ** 252 ** Function AVDT_DiscoverReq 253 ** 254 ** Description This function initiates a connection to the AVDTP service 255 ** on the peer device, if not already present, and discovers 256 ** the stream endpoints on the peer device. (Please note 257 ** that AVDTP discovery is unrelated to SDP discovery). 258 ** This function can be called at any time regardless of whether 259 ** there is an AVDTP connection to the peer device. 260 ** 261 ** When discovery is complete, an AVDT_DISCOVER_CFM_EVT 262 ** is sent to the application via its callback function. 263 ** The application must not call AVDT_GetCapReq() or 264 ** AVDT_DiscoverReq() again to the same device until 265 ** discovery is complete. 266 ** 267 ** The memory addressed by sep_info is allocated by the 268 ** application. This memory is written to by AVDTP as part 269 ** of the discovery procedure. This memory must remain 270 ** accessible until the application receives the 271 ** AVDT_DISCOVER_CFM_EVT. 272 ** 273 ** Returns AVDT_SUCCESS if successful, otherwise error. 274 ** 275 *******************************************************************************/ 276 UINT16 AVDT_DiscoverReq(BD_ADDR bd_addr, tAVDT_SEP_INFO *p_sep_info, 277 UINT8 max_seps, tAVDT_CTRL_CBACK *p_cback) 278 { 279 tAVDT_CCB *p_ccb; 280 UINT16 result = AVDT_SUCCESS; 281 tAVDT_CCB_EVT evt; 282 283 BTTRC_AVDT_API0(AVDT_TRACE_API_DISCOVER_REQ); 284 285 /* find channel control block for this bd addr; if none, allocate one */ 286 if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) 287 { 288 if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) 289 { 290 /* could not allocate channel control block */ 291 result = AVDT_NO_RESOURCES; 292 } 293 } 294 295 if (result == AVDT_SUCCESS) 296 { 297 /* make sure no discovery or get capabilities req already in progress */ 298 if (p_ccb->proc_busy) 299 { 300 result = AVDT_BUSY; 301 } 302 /* send event to ccb */ 303 else 304 { 305 evt.discover.p_sep_info = p_sep_info; 306 evt.discover.num_seps = max_seps; 307 evt.discover.p_cback = p_cback; 308 avdt_ccb_event(p_ccb, AVDT_CCB_API_DISCOVER_REQ_EVT, &evt); 309 } 310 } 311 return result; 312 } 313 314 /******************************************************************************* 315 ** 316 ** Function avdt_get_cap_req 317 ** 318 ** Description internal function to serve both AVDT_GetCapReq and 319 ** AVDT_GetAllCapReq 320 ** 321 ** Returns AVDT_SUCCESS if successful, otherwise error. 322 ** 323 *******************************************************************************/ 324 static UINT16 avdt_get_cap_req(BD_ADDR bd_addr, tAVDT_CCB_API_GETCAP *p_evt) 325 { 326 tAVDT_CCB *p_ccb = NULL; 327 UINT16 result = AVDT_SUCCESS; 328 329 /* verify SEID */ 330 if ((p_evt->single.seid < AVDT_SEID_MIN) || (p_evt->single.seid > AVDT_SEID_MAX)) 331 { 332 AVDT_TRACE_ERROR1("seid: %d", p_evt->single.seid); 333 result = AVDT_BAD_PARAMS; 334 } 335 /* find channel control block for this bd addr; if none, allocate one */ 336 else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) 337 { 338 if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) 339 { 340 /* could not allocate channel control block */ 341 result = AVDT_NO_RESOURCES; 342 } 343 } 344 345 if (result == AVDT_SUCCESS) 346 { 347 /* make sure no discovery or get capabilities req already in progress */ 348 if (p_ccb->proc_busy) 349 { 350 result = AVDT_BUSY; 351 } 352 /* send event to ccb */ 353 else 354 { 355 avdt_ccb_event(p_ccb, AVDT_CCB_API_GETCAP_REQ_EVT, (tAVDT_CCB_EVT *)p_evt); 356 } 357 } 358 return result; 359 } 360 361 /******************************************************************************* 362 ** 363 ** Function AVDT_GetCapReq 364 ** 365 ** Description This function initiates a connection to the AVDTP service 366 ** on the peer device, if not already present, and gets the 367 ** capabilities of a stream endpoint on the peer device. 368 ** This function can be called at any time regardless of 369 ** whether there is an AVDTP connection to the peer device. 370 ** 371 ** When the procedure is complete, an AVDT_GETCAP_CFM_EVT is 372 ** sent to the application via its callback function. The 373 ** application must not call AVDT_GetCapReq() or 374 ** AVDT_DiscoverReq() again until the procedure is complete. 375 ** 376 ** The memory pointed to by p_cfg is allocated by the 377 ** application. This memory is written to by AVDTP as part 378 ** of the get capabilities procedure. This memory must 379 ** remain accessible until the application receives 380 ** the AVDT_GETCAP_CFM_EVT. 381 ** 382 ** Returns AVDT_SUCCESS if successful, otherwise error. 383 ** 384 *******************************************************************************/ 385 UINT16 AVDT_GetCapReq(BD_ADDR bd_addr, UINT8 seid, tAVDT_CFG *p_cfg, tAVDT_CTRL_CBACK *p_cback) 386 { 387 tAVDT_CCB_API_GETCAP getcap; 388 389 BTTRC_AVDT_API1(AVDT_TRACE_API_GETCAP_REQ, BTTRC_PARAM_UINT8, seid); 390 391 getcap.single.seid = seid; 392 getcap.single.sig_id = AVDT_SIG_GETCAP; 393 getcap.p_cfg = p_cfg; 394 getcap.p_cback = p_cback; 395 return avdt_get_cap_req (bd_addr, &getcap); 396 } 397 398 /******************************************************************************* 399 ** 400 ** Function AVDT_GetAllCapReq 401 ** 402 ** Description This function initiates a connection to the AVDTP service 403 ** on the peer device, if not already present, and gets the 404 ** capabilities of a stream endpoint on the peer device. 405 ** This function can be called at any time regardless of 406 ** whether there is an AVDTP connection to the peer device. 407 ** 408 ** When the procedure is complete, an AVDT_GETCAP_CFM_EVT is 409 ** sent to the application via its callback function. The 410 ** application must not call AVDT_GetCapReq() or 411 ** AVDT_DiscoverReq() again until the procedure is complete. 412 ** 413 ** The memory pointed to by p_cfg is allocated by the 414 ** application. This memory is written to by AVDTP as part 415 ** of the get capabilities procedure. This memory must 416 ** remain accessible until the application receives 417 ** the AVDT_GETCAP_CFM_EVT. 418 ** 419 ** Returns AVDT_SUCCESS if successful, otherwise error. 420 ** 421 *******************************************************************************/ 422 UINT16 AVDT_GetAllCapReq(BD_ADDR bd_addr, UINT8 seid, tAVDT_CFG *p_cfg, tAVDT_CTRL_CBACK *p_cback) 423 { 424 tAVDT_CCB_API_GETCAP getcap; 425 426 BTTRC_AVDT_API1(AVDT_TRACE_API_GET_ALLCAP_REQ, BTTRC_PARAM_UINT8, seid); 427 428 getcap.single.seid = seid; 429 getcap.single.sig_id = AVDT_SIG_GET_ALLCAP; 430 getcap.p_cfg = p_cfg; 431 getcap.p_cback = p_cback; 432 return avdt_get_cap_req (bd_addr, &getcap); 433 } 434 435 /******************************************************************************* 436 ** 437 ** Function AVDT_DelayReport 438 ** 439 ** Description This functions sends a Delay Report to the peer device 440 ** that is associated with a particular SEID. 441 ** This function is called by SNK device. 442 ** 443 ** Returns AVDT_SUCCESS if successful, otherwise error. 444 ** 445 *******************************************************************************/ 446 UINT16 AVDT_DelayReport(UINT8 handle, UINT8 seid, UINT16 delay) 447 { 448 tAVDT_SCB *p_scb; 449 UINT16 result = AVDT_SUCCESS; 450 tAVDT_SCB_EVT evt; 451 452 BTTRC_AVDT_API0(AVDT_TRACE_API_DELAY_REPORT); 453 454 /* map handle to scb */ 455 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 456 { 457 result = AVDT_BAD_HANDLE; 458 } 459 else 460 /* send event to scb */ 461 { 462 evt.apidelay.hdr.seid = seid; 463 evt.apidelay.delay = delay; 464 avdt_scb_event(p_scb, AVDT_SCB_API_DELAY_RPT_REQ_EVT, &evt); 465 } 466 467 return result; 468 } 469 470 /******************************************************************************* 471 ** 472 ** Function AVDT_OpenReq 473 ** 474 ** Description This function initiates a connection to the AVDTP service 475 ** on the peer device, if not already present, and connects 476 ** to a stream endpoint on a peer device. When the connection 477 ** is completed, an AVDT_OPEN_CFM_EVT is sent to the 478 ** application via the control callback function for this handle. 479 ** 480 ** Returns AVDT_SUCCESS if successful, otherwise error. 481 ** 482 *******************************************************************************/ 483 UINT16 AVDT_OpenReq(UINT8 handle, BD_ADDR bd_addr, UINT8 seid, tAVDT_CFG *p_cfg) 484 { 485 tAVDT_CCB *p_ccb = NULL; 486 tAVDT_SCB *p_scb = NULL; 487 UINT16 result = AVDT_SUCCESS; 488 tAVDT_SCB_EVT evt; 489 490 BTTRC_AVDT_API0(AVDT_TRACE_API_OPEN_REQ); 491 492 493 /* verify SEID */ 494 if ((seid < AVDT_SEID_MIN) || (seid > AVDT_SEID_MAX)) 495 { 496 result = AVDT_BAD_PARAMS; 497 } 498 /* map handle to scb */ 499 else if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 500 { 501 result = AVDT_BAD_HANDLE; 502 } 503 /* find channel control block for this bd addr; if none, allocate one */ 504 else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) 505 { 506 if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) 507 { 508 /* could not allocate channel control block */ 509 result = AVDT_NO_RESOURCES; 510 } 511 } 512 513 /* send event to scb */ 514 if (result == AVDT_SUCCESS) 515 { 516 evt.msg.config_cmd.hdr.seid = seid; 517 evt.msg.config_cmd.hdr.ccb_idx = avdt_ccb_to_idx(p_ccb); 518 evt.msg.config_cmd.int_seid = handle; 519 evt.msg.config_cmd.p_cfg = p_cfg; 520 avdt_scb_event(p_scb, AVDT_SCB_API_SETCONFIG_REQ_EVT, &evt); 521 } 522 return result; 523 } 524 525 /******************************************************************************* 526 ** 527 ** Function AVDT_ConfigRsp 528 ** 529 ** Description Respond to a configure request from the peer device. This 530 ** function must be called if the application receives an 531 ** AVDT_CONFIG_IND_EVT through its control callback. 532 ** 533 ** 534 ** Returns AVDT_SUCCESS if successful, otherwise error. 535 ** 536 *******************************************************************************/ 537 UINT16 AVDT_ConfigRsp(UINT8 handle, UINT8 label, UINT8 error_code, UINT8 category) 538 { 539 tAVDT_SCB *p_scb; 540 tAVDT_SCB_EVT evt; 541 UINT16 result = AVDT_SUCCESS; 542 UINT8 event_code; 543 544 BTTRC_AVDT_API0(AVDT_TRACE_API_CONFIG_RSP); 545 546 /* map handle to scb */ 547 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 548 { 549 result = AVDT_BAD_HANDLE; 550 } 551 /* handle special case when this function is called but peer has not send 552 ** a configuration cmd; ignore and return error result 553 */ 554 else if (!p_scb->in_use) 555 { 556 result = AVDT_BAD_HANDLE; 557 } 558 /* send event to scb */ 559 else 560 { 561 evt.msg.hdr.err_code = error_code; 562 evt.msg.hdr.err_param = category; 563 evt.msg.hdr.label = label; 564 if (error_code == 0) 565 { 566 event_code = AVDT_SCB_API_SETCONFIG_RSP_EVT; 567 } 568 else 569 { 570 event_code = AVDT_SCB_API_SETCONFIG_REJ_EVT; 571 } 572 avdt_scb_event(p_scb, event_code, &evt); 573 } 574 575 return result; 576 } 577 578 /******************************************************************************* 579 ** 580 ** Function AVDT_StartReq 581 ** 582 ** Description Start one or more stream endpoints. This initiates the 583 ** transfer of media packets for the streams. All stream 584 ** endpoints must previously be opened. When the streams 585 ** are started, an AVDT_START_CFM_EVT is sent to the 586 ** application via the control callback function for each stream. 587 ** 588 ** 589 ** Returns AVDT_SUCCESS if successful, otherwise error. 590 ** 591 *******************************************************************************/ 592 UINT16 AVDT_StartReq(UINT8 *p_handles, UINT8 num_handles) 593 { 594 tAVDT_SCB *p_scb = NULL; 595 tAVDT_CCB_EVT evt; 596 UINT16 result = AVDT_SUCCESS; 597 int i; 598 599 BTTRC_AVDT_API0(AVDT_TRACE_API_START_REQ); 600 601 if ((num_handles == 0) || (num_handles > AVDT_NUM_SEPS)) 602 { 603 result = AVDT_BAD_PARAMS; 604 } 605 else 606 { 607 /* verify handles */ 608 for (i = 0; i < num_handles; i++) 609 { 610 if ((p_scb = avdt_scb_by_hdl(p_handles[i])) == NULL) 611 { 612 result = AVDT_BAD_HANDLE; 613 break; 614 } 615 } 616 } 617 618 if (result == AVDT_SUCCESS) 619 { 620 if (p_scb->p_ccb == NULL) 621 { 622 result = AVDT_BAD_HANDLE; 623 } 624 else 625 { 626 /* send event to ccb */ 627 memcpy(evt.msg.multi.seid_list, p_handles, num_handles); 628 evt.msg.multi.num_seps = num_handles; 629 avdt_ccb_event(p_scb->p_ccb, AVDT_CCB_API_START_REQ_EVT, &evt); 630 } 631 } 632 return result; 633 } 634 635 /******************************************************************************* 636 ** 637 ** Function AVDT_SuspendReq 638 ** 639 ** Description Suspend one or more stream endpoints. This suspends the 640 ** transfer of media packets for the streams. All stream 641 ** endpoints must previously be open and started. When the 642 ** streams are suspended, an AVDT_SUSPEND_CFM_EVT is sent to 643 ** the application via the control callback function for 644 ** each stream. 645 ** 646 ** 647 ** Returns AVDT_SUCCESS if successful, otherwise error. 648 ** 649 *******************************************************************************/ 650 UINT16 AVDT_SuspendReq(UINT8 *p_handles, UINT8 num_handles) 651 { 652 tAVDT_SCB *p_scb = NULL; 653 tAVDT_CCB_EVT evt; 654 UINT16 result = AVDT_SUCCESS; 655 int i; 656 657 BTTRC_AVDT_API0(AVDT_TRACE_API_SUSPEND_REQ); 658 659 if ((num_handles == 0) || (num_handles > AVDT_NUM_SEPS)) 660 { 661 result = AVDT_BAD_PARAMS; 662 } 663 else 664 { 665 /* verify handles */ 666 for (i = 0; i < num_handles; i++) 667 { 668 if ((p_scb = avdt_scb_by_hdl(p_handles[i])) == NULL) 669 { 670 result = AVDT_BAD_HANDLE; 671 break; 672 } 673 } 674 } 675 676 if (result == AVDT_SUCCESS) 677 { 678 if (p_scb->p_ccb == NULL) 679 { 680 result = AVDT_BAD_HANDLE; 681 } 682 else 683 { 684 /* send event to ccb */ 685 memcpy(evt.msg.multi.seid_list, p_handles, num_handles); 686 evt.msg.multi.num_seps = num_handles; 687 avdt_ccb_event(p_scb->p_ccb, AVDT_CCB_API_SUSPEND_REQ_EVT, &evt); 688 } 689 } 690 691 return result; 692 } 693 694 /******************************************************************************* 695 ** 696 ** Function AVDT_CloseReq 697 ** 698 ** Description Close a stream endpoint. This stops the transfer of media 699 ** packets and closes the transport channel associated with 700 ** this stream endpoint. When the stream is closed, an 701 ** AVDT_CLOSE_CFM_EVT is sent to the application via the 702 ** control callback function for this handle. 703 ** 704 ** 705 ** Returns AVDT_SUCCESS if successful, otherwise error. 706 ** 707 *******************************************************************************/ 708 UINT16 AVDT_CloseReq(UINT8 handle) 709 { 710 tAVDT_SCB *p_scb; 711 UINT16 result = AVDT_SUCCESS; 712 713 BTTRC_AVDT_API0(AVDT_TRACE_API_CLOSE_REQ); 714 715 /* map handle to scb */ 716 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 717 { 718 result = AVDT_BAD_HANDLE; 719 } 720 else 721 /* send event to scb */ 722 { 723 avdt_scb_event(p_scb, AVDT_SCB_API_CLOSE_REQ_EVT, NULL); 724 } 725 726 return result; 727 } 728 729 /******************************************************************************* 730 ** 731 ** Function AVDT_ReconfigReq 732 ** 733 ** Description Reconfigure a stream endpoint. This allows the application 734 ** to change the codec or content protection capabilities of 735 ** a stream endpoint after it has been opened. This function 736 ** can only be called if the stream is opened but not started 737 ** or if the stream has been suspended. When the procedure 738 ** is completed, an AVDT_RECONFIG_CFM_EVT is sent to the 739 ** application via the control callback function for this handle. 740 ** 741 ** 742 ** Returns AVDT_SUCCESS if successful, otherwise error. 743 ** 744 *******************************************************************************/ 745 UINT16 AVDT_ReconfigReq(UINT8 handle, tAVDT_CFG *p_cfg) 746 { 747 tAVDT_SCB *p_scb; 748 UINT16 result = AVDT_SUCCESS; 749 tAVDT_SCB_EVT evt; 750 751 BTTRC_AVDT_API0(AVDT_TRACE_API_RECONFIG_REQ); 752 753 /* map handle to scb */ 754 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 755 { 756 result = AVDT_BAD_HANDLE; 757 } 758 /* send event to scb */ 759 else 760 { 761 /* force psc_mask to zero */ 762 p_cfg->psc_mask = 0; 763 764 evt.msg.reconfig_cmd.p_cfg = p_cfg; 765 avdt_scb_event(p_scb, AVDT_SCB_API_RECONFIG_REQ_EVT, &evt); 766 } 767 return result; 768 } 769 770 /******************************************************************************* 771 ** 772 ** Function AVDT_ReconfigRsp 773 ** 774 ** Description Respond to a reconfigure request from the peer device. 775 ** This function must be called if the application receives 776 ** an AVDT_RECONFIG_IND_EVT through its control callback. 777 ** 778 ** 779 ** Returns AVDT_SUCCESS if successful, otherwise error. 780 ** 781 *******************************************************************************/ 782 UINT16 AVDT_ReconfigRsp(UINT8 handle, UINT8 label, UINT8 error_code, UINT8 category) 783 { 784 tAVDT_SCB *p_scb; 785 tAVDT_SCB_EVT evt; 786 UINT16 result = AVDT_SUCCESS; 787 788 BTTRC_AVDT_API0(AVDT_TRACE_API_RECONFIG_RSP); 789 790 /* map handle to scb */ 791 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 792 { 793 result = AVDT_BAD_HANDLE; 794 } 795 /* send event to scb */ 796 else 797 { 798 evt.msg.hdr.err_code = error_code; 799 evt.msg.hdr.err_param = category; 800 evt.msg.hdr.label = label; 801 avdt_scb_event(p_scb, AVDT_SCB_API_RECONFIG_RSP_EVT, &evt); 802 } 803 804 return result; 805 } 806 807 /******************************************************************************* 808 ** 809 ** Function AVDT_SecurityReq 810 ** 811 ** Description Send a security request to the peer device. When the 812 ** security procedure is completed, an AVDT_SECURITY_CFM_EVT 813 ** is sent to the application via the control callback function 814 ** for this handle. (Please note that AVDTP security procedures 815 ** are unrelated to Bluetooth link level security.) 816 ** 817 ** 818 ** Returns AVDT_SUCCESS if successful, otherwise error. 819 ** 820 *******************************************************************************/ 821 UINT16 AVDT_SecurityReq(UINT8 handle, UINT8 *p_data, UINT16 len) 822 { 823 tAVDT_SCB *p_scb; 824 UINT16 result = AVDT_SUCCESS; 825 tAVDT_SCB_EVT evt; 826 827 BTTRC_AVDT_API0(AVDT_TRACE_API_SECURITY_REQ); 828 829 /* map handle to scb */ 830 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 831 { 832 result = AVDT_BAD_HANDLE; 833 } 834 /* send event to scb */ 835 else 836 { 837 evt.msg.security_rsp.p_data = p_data; 838 evt.msg.security_rsp.len = len; 839 avdt_scb_event(p_scb, AVDT_SCB_API_SECURITY_REQ_EVT, &evt); 840 } 841 return result; 842 } 843 844 /******************************************************************************* 845 ** 846 ** Function AVDT_SecurityRsp 847 ** 848 ** Description Respond to a security request from the peer device. 849 ** This function must be called if the application receives 850 ** an AVDT_SECURITY_IND_EVT through its control callback. 851 ** (Please note that AVDTP security procedures are unrelated 852 ** to Bluetooth link level security.) 853 ** 854 ** 855 ** Returns AVDT_SUCCESS if successful, otherwise error. 856 ** 857 *******************************************************************************/ 858 UINT16 AVDT_SecurityRsp(UINT8 handle, UINT8 label, UINT8 error_code, 859 UINT8 *p_data, UINT16 len) 860 { 861 tAVDT_SCB *p_scb; 862 UINT16 result = AVDT_SUCCESS; 863 tAVDT_SCB_EVT evt; 864 865 BTTRC_AVDT_API0(AVDT_TRACE_API_SECURITY_RSP); 866 867 /* map handle to scb */ 868 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 869 { 870 result = AVDT_BAD_HANDLE; 871 } 872 /* send event to scb */ 873 else 874 { 875 evt.msg.security_rsp.hdr.err_code = error_code; 876 evt.msg.security_rsp.hdr.label = label; 877 evt.msg.security_rsp.p_data = p_data; 878 evt.msg.security_rsp.len = len; 879 avdt_scb_event(p_scb, AVDT_SCB_API_SECURITY_RSP_EVT, &evt); 880 } 881 return result; 882 } 883 884 /******************************************************************************* 885 ** 886 ** Function AVDT_WriteReqOpt 887 ** 888 ** Description Send a media packet to the peer device. The stream must 889 ** be started before this function is called. Also, this 890 ** function can only be called if the stream is a SRC. 891 ** 892 ** When AVDTP has sent the media packet and is ready for the 893 ** next packet, an AVDT_WRITE_CFM_EVT is sent to the 894 ** application via the control callback. The application must 895 ** wait for the AVDT_WRITE_CFM_EVT before it makes the next 896 ** call to AVDT_WriteReq(). If the applications calls 897 ** AVDT_WriteReq() before it receives the event the packet 898 ** will not be sent. The application may make its first call 899 ** to AVDT_WriteReq() after it receives an AVDT_START_CFM_EVT 900 ** or AVDT_START_IND_EVT. 901 ** 902 ** The application passes the packet using the BT_HDR structure. 903 ** This structure is described in section 2.1. The offset 904 ** field must be equal to or greater than AVDT_MEDIA_OFFSET 905 ** (if NO_RTP is specified, L2CAP_MIN_OFFSET can be used). 906 ** This allows enough space in the buffer for the L2CAP and 907 ** AVDTP headers. 908 ** 909 ** The memory pointed to by p_pkt must be a GKI buffer 910 ** allocated by the application. This buffer will be freed 911 ** by the protocol stack; the application must not free 912 ** this buffer. 913 ** 914 ** The opt parameter allows passing specific options like: 915 ** - NO_RTP : do not add the RTP header to buffer 916 ** 917 ** Returns AVDT_SUCCESS if successful, otherwise error. 918 ** 919 *******************************************************************************/ 920 UINT16 AVDT_WriteReqOpt(UINT8 handle, BT_HDR *p_pkt, UINT32 time_stamp, UINT8 m_pt, tAVDT_DATA_OPT_MASK opt) 921 { 922 tAVDT_SCB *p_scb; 923 tAVDT_SCB_EVT evt; 924 UINT16 result = AVDT_SUCCESS; 925 926 BTTRC_AVDT_API0(AVDT_TRACE_API_WRITE_REQ); 927 928 /* map handle to scb */ 929 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 930 { 931 result = AVDT_BAD_HANDLE; 932 } 933 else 934 { 935 evt.apiwrite.p_buf = p_pkt; 936 evt.apiwrite.time_stamp = time_stamp; 937 evt.apiwrite.m_pt = m_pt; 938 evt.apiwrite.opt = opt; 939 #if AVDT_MULTIPLEXING == TRUE 940 GKI_init_q (&evt.apiwrite.frag_q); 941 #endif 942 avdt_scb_event(p_scb, AVDT_SCB_API_WRITE_REQ_EVT, &evt); 943 } 944 945 return result; 946 } 947 948 /******************************************************************************* 949 ** 950 ** Function AVDT_WriteReq 951 ** 952 ** Description Send a media packet to the peer device. The stream must 953 ** be started before this function is called. Also, this 954 ** function can only be called if the stream is a SRC. 955 ** 956 ** When AVDTP has sent the media packet and is ready for the 957 ** next packet, an AVDT_WRITE_CFM_EVT is sent to the 958 ** application via the control callback. The application must 959 ** wait for the AVDT_WRITE_CFM_EVT before it makes the next 960 ** call to AVDT_WriteReq(). If the applications calls 961 ** AVDT_WriteReq() before it receives the event the packet 962 ** will not be sent. The application may make its first call 963 ** to AVDT_WriteReq() after it receives an AVDT_START_CFM_EVT 964 ** or AVDT_START_IND_EVT. 965 ** 966 ** The application passes the packet using the BT_HDR structure. 967 ** This structure is described in section 2.1. The offset 968 ** field must be equal to or greater than AVDT_MEDIA_OFFSET. 969 ** This allows enough space in the buffer for the L2CAP and 970 ** AVDTP headers. 971 ** 972 ** The memory pointed to by p_pkt must be a GKI buffer 973 ** allocated by the application. This buffer will be freed 974 ** by the protocol stack; the application must not free 975 ** this buffer. 976 ** 977 ** 978 ** Returns AVDT_SUCCESS if successful, otherwise error. 979 ** 980 *******************************************************************************/ 981 UINT16 AVDT_WriteReq(UINT8 handle, BT_HDR *p_pkt, UINT32 time_stamp, UINT8 m_pt) 982 { 983 return AVDT_WriteReqOpt(handle, p_pkt, time_stamp, m_pt, AVDT_DATA_OPT_NONE); 984 } 985 986 /******************************************************************************* 987 ** 988 ** Function AVDT_ConnectReq 989 ** 990 ** Description This function initiates an AVDTP signaling connection 991 ** to the peer device. When the connection is completed, an 992 ** AVDT_CONNECT_IND_EVT is sent to the application via its 993 ** control callback function. If the connection attempt fails 994 ** an AVDT_DISCONNECT_IND_EVT is sent. The security mask 995 ** parameter overrides the outgoing security mask set in 996 ** AVDT_Register(). 997 ** 998 ** Returns AVDT_SUCCESS if successful, otherwise error. 999 ** 1000 *******************************************************************************/ 1001 UINT16 AVDT_ConnectReq(BD_ADDR bd_addr, UINT8 sec_mask, tAVDT_CTRL_CBACK *p_cback) 1002 { 1003 tAVDT_CCB *p_ccb = NULL; 1004 UINT16 result = AVDT_SUCCESS; 1005 tAVDT_CCB_EVT evt; 1006 1007 BTTRC_AVDT_API0(AVDT_TRACE_API_CONNECT_REQ); 1008 1009 /* find channel control block for this bd addr; if none, allocate one */ 1010 if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) 1011 { 1012 if ((p_ccb = avdt_ccb_alloc(bd_addr)) == NULL) 1013 { 1014 /* could not allocate channel control block */ 1015 result = AVDT_NO_RESOURCES; 1016 } 1017 } 1018 else if (p_ccb->ll_opened == FALSE) 1019 { 1020 AVDT_TRACE_WARNING0("AVDT_ConnectReq: CCB LL is in the middle of opening"); 1021 1022 /* ccb was already allocated for the incoming signalling. */ 1023 result = AVDT_BUSY; 1024 } 1025 1026 if (result == AVDT_SUCCESS) 1027 { 1028 /* send event to ccb */ 1029 evt.connect.p_cback = p_cback; 1030 evt.connect.sec_mask = sec_mask; 1031 avdt_ccb_event(p_ccb, AVDT_CCB_API_CONNECT_REQ_EVT, &evt); 1032 } 1033 return result; 1034 } 1035 1036 /******************************************************************************* 1037 ** 1038 ** Function AVDT_DisconnectReq 1039 ** 1040 ** Description This function disconnect an AVDTP signaling connection 1041 ** to the peer device. When disconnected an 1042 ** AVDT_DISCONNECT_IND_EVT is sent to the application via its 1043 ** control callback function. 1044 ** 1045 ** Returns AVDT_SUCCESS if successful, otherwise error. 1046 ** 1047 *******************************************************************************/ 1048 UINT16 AVDT_DisconnectReq(BD_ADDR bd_addr, tAVDT_CTRL_CBACK *p_cback) 1049 { 1050 tAVDT_CCB *p_ccb = NULL; 1051 UINT16 result = AVDT_SUCCESS; 1052 tAVDT_CCB_EVT evt; 1053 1054 BTTRC_AVDT_API0(AVDT_TRACE_API_DISCONNECT_REQ); 1055 1056 1057 /* find channel control block for this bd addr; if none, error */ 1058 if ((p_ccb = avdt_ccb_by_bd(bd_addr)) == NULL) 1059 { 1060 result = AVDT_BAD_PARAMS; 1061 } 1062 1063 if (result == AVDT_SUCCESS) 1064 { 1065 /* send event to ccb */ 1066 evt.disconnect.p_cback = p_cback; 1067 avdt_ccb_event(p_ccb, AVDT_CCB_API_DISCONNECT_REQ_EVT, &evt); 1068 } 1069 return result; 1070 } 1071 1072 /******************************************************************************* 1073 ** 1074 ** Function AVDT_GetL2CapChannel 1075 ** 1076 ** Description Get the L2CAP CID used by the handle. 1077 ** 1078 ** Returns CID if successful, otherwise 0. 1079 ** 1080 *******************************************************************************/ 1081 UINT16 AVDT_GetL2CapChannel(UINT8 handle) 1082 { 1083 tAVDT_SCB *p_scb; 1084 tAVDT_CCB *p_ccb; 1085 UINT8 tcid; 1086 UINT16 lcid = 0; 1087 1088 /* map handle to scb */ 1089 if (((p_scb = avdt_scb_by_hdl(handle)) != NULL) 1090 && ((p_ccb = p_scb->p_ccb) != NULL)) 1091 { 1092 /* get tcid from type, scb */ 1093 tcid = avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb); 1094 1095 lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid; 1096 } 1097 1098 BTTRC_AVDT_API1(AVDT_TRACE_API_GET_L2CAP_CHAN, BTTRC_PARAM_UINT16, lcid); 1099 1100 return (lcid); 1101 } 1102 1103 /******************************************************************************* 1104 ** 1105 ** Function AVDT_GetSignalChannel 1106 ** 1107 ** Description Get the L2CAP CID used by the signal channel of the given handle. 1108 ** 1109 ** Returns CID if successful, otherwise 0. 1110 ** 1111 *******************************************************************************/ 1112 UINT16 AVDT_GetSignalChannel(UINT8 handle, BD_ADDR bd_addr) 1113 { 1114 tAVDT_SCB *p_scb; 1115 tAVDT_CCB *p_ccb; 1116 UINT8 tcid = 0; /* tcid is always 0 for signal channel */ 1117 UINT16 lcid = 0; 1118 1119 /* map handle to scb */ 1120 if (((p_scb = avdt_scb_by_hdl(handle)) != NULL) 1121 && ((p_ccb = p_scb->p_ccb) != NULL)) 1122 { 1123 lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid; 1124 } 1125 else if ((p_ccb = avdt_ccb_by_bd(bd_addr)) != NULL) 1126 { 1127 lcid = avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid; 1128 } 1129 1130 BTTRC_AVDT_API1(AVDT_TRACE_API_GET_SIGNAL_CHAN, BTTRC_PARAM_UINT16, lcid); 1131 1132 return (lcid); 1133 } 1134 1135 #if AVDT_MULTIPLEXING == TRUE 1136 /******************************************************************************* 1137 ** 1138 ** Function AVDT_WriteDataReq 1139 ** 1140 ** Description Send a media packet to the peer device. The stream must 1141 ** be started before this function is called. Also, this 1142 ** function can only be called if the stream is a SRC. 1143 ** 1144 ** When AVDTP has sent the media packet and is ready for the 1145 ** next packet, an AVDT_WRITE_CFM_EVT is sent to the 1146 ** application via the control callback. The application must 1147 ** wait for the AVDT_WRITE_CFM_EVT before it makes the next 1148 ** call to AVDT_WriteDataReq(). If the applications calls 1149 ** AVDT_WriteDataReq() before it receives the event the packet 1150 ** will not be sent. The application may make its first call 1151 ** to AVDT_WriteDataReq() after it receives an 1152 ** AVDT_START_CFM_EVT or AVDT_START_IND_EVT. 1153 ** 1154 ** Returns AVDT_SUCCESS if successful, otherwise error. 1155 ** 1156 *******************************************************************************/ 1157 AVDT_API extern UINT16 AVDT_WriteDataReq(UINT8 handle, UINT8 *p_data, UINT32 data_len, 1158 UINT32 time_stamp, UINT8 m_pt, UINT8 marker) 1159 { 1160 1161 tAVDT_SCB *p_scb; 1162 tAVDT_SCB_EVT evt; 1163 UINT16 result = AVDT_SUCCESS; 1164 1165 BTTRC_AVDT_API1(AVDT_TRACE_API_WRITE_DATA_REQ, BTTRC_PARAM_UINT32, data_len); 1166 1167 do 1168 { 1169 /* check length of media frame */ 1170 if(data_len > AVDT_MAX_MEDIA_SIZE) 1171 { 1172 result = AVDT_BAD_PARAMS; 1173 break; 1174 } 1175 /* map handle to scb */ 1176 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 1177 { 1178 result = AVDT_BAD_HANDLE; 1179 break; 1180 } 1181 AVDT_TRACE_WARNING1("mux_tsid_media:%d", p_scb->curr_cfg.mux_tsid_media); 1182 1183 if (p_scb->p_pkt != NULL 1184 || p_scb->p_ccb == NULL 1185 || !GKI_queue_is_empty(&p_scb->frag_q) 1186 || p_scb->frag_off != 0 1187 || p_scb->curr_cfg.mux_tsid_media == 0) 1188 { 1189 result = AVDT_ERR_BAD_STATE; 1190 AVDT_TRACE_WARNING4("p_scb->p_pkt=%x, p_scb->p_ccb=%x, IsQueueEmpty=%x, p_scb->frag_off=%x", 1191 p_scb->p_pkt, p_scb->p_ccb, GKI_queue_is_empty(&p_scb->frag_q), p_scb->frag_off); 1192 break; 1193 } 1194 evt.apiwrite.p_buf = 0; /* it will indicate using of fragments queue frag_q */ 1195 /* create queue of media fragments */ 1196 GKI_init_q (&evt.apiwrite.frag_q); 1197 1198 /* compose fragments from media payload and put fragments into gueue */ 1199 avdt_scb_queue_frags(p_scb, &p_data, &data_len, &evt.apiwrite.frag_q); 1200 1201 if(GKI_queue_is_empty(&evt.apiwrite.frag_q)) 1202 { 1203 AVDT_TRACE_WARNING0("AVDT_WriteDataReq out of GKI buffers"); 1204 result = AVDT_ERR_RESOURCE; 1205 break; 1206 } 1207 evt.apiwrite.data_len = data_len; 1208 evt.apiwrite.p_data = p_data; 1209 1210 /* process the fragments queue */ 1211 evt.apiwrite.time_stamp = time_stamp; 1212 evt.apiwrite.m_pt = m_pt | (marker<<7); 1213 avdt_scb_event(p_scb, AVDT_SCB_API_WRITE_REQ_EVT, &evt); 1214 } while (0); 1215 1216 #if (BT_USE_TRACES == TRUE) 1217 if(result != AVDT_SUCCESS) 1218 { 1219 AVDT_TRACE_WARNING1("*** AVDT_WriteDataReq failed result=%d",result); 1220 } 1221 #endif 1222 return result; 1223 } 1224 #endif 1225 1226 #if AVDT_MULTIPLEXING == TRUE 1227 /******************************************************************************* 1228 ** 1229 ** Function AVDT_SetMediaBuf 1230 ** 1231 ** Description Assigns buffer for media packets or forbids using of assigned 1232 ** buffer if argument p_buf is NULL. This function can only 1233 ** be called if the stream is a SNK. 1234 ** 1235 ** AVDTP uses this buffer to reassemble fragmented media packets. 1236 ** When AVDTP receives a complete media packet, it calls the 1237 ** p_media_cback assigned by AVDT_CreateStream(). 1238 ** This function can be called during callback to assign a 1239 ** different buffer for next media packet or can leave the current 1240 ** buffer for next packet. 1241 ** 1242 ** Returns AVDT_SUCCESS if successful, otherwise error. 1243 ** 1244 *******************************************************************************/ 1245 AVDT_API extern UINT16 AVDT_SetMediaBuf(UINT8 handle, UINT8 *p_buf, UINT32 buf_len) 1246 { 1247 tAVDT_SCB *p_scb; 1248 UINT16 result = AVDT_SUCCESS; 1249 1250 BTTRC_AVDT_API0(AVDT_TRACE_API_SET_MEDIABUF); 1251 1252 /* map handle to scb */ 1253 if ((p_scb = avdt_scb_by_hdl(handle)) == NULL) 1254 { 1255 result = AVDT_BAD_HANDLE; 1256 } 1257 else 1258 { 1259 if(p_buf && p_scb->cs.p_media_cback == NULL) 1260 result = AVDT_NO_RESOURCES; 1261 else 1262 { 1263 p_scb->p_media_buf = p_buf; 1264 p_scb->media_buf_len = buf_len; 1265 } 1266 } 1267 1268 return result; 1269 } 1270 #endif 1271 1272 #if AVDT_REPORTING == TRUE 1273 /******************************************************************************* 1274 ** 1275 ** Function AVDT_SendReport 1276 ** 1277 ** Description 1278 ** 1279 ** 1280 ** 1281 ** Returns 1282 ** 1283 *******************************************************************************/ 1284 UINT16 AVDT_SendReport(UINT8 handle, AVDT_REPORT_TYPE type, 1285 tAVDT_REPORT_DATA *p_data) 1286 { 1287 tAVDT_SCB *p_scb; 1288 UINT16 result = AVDT_BAD_PARAMS; 1289 BT_HDR *p_pkt; 1290 tAVDT_TC_TBL *p_tbl; 1291 UINT8 *p, *plen, *pm1, *p_end; 1292 #if AVDT_MULTIPLEXING == TRUE 1293 UINT8 *p_al=NULL, u; 1294 #endif 1295 UINT32 ssrc; 1296 UINT16 len; 1297 1298 BTTRC_AVDT_API0(AVDT_TRACE_API_SEND_REPORT); 1299 1300 /* map handle to scb && verify parameters */ 1301 if (((p_scb = avdt_scb_by_hdl(handle)) != NULL) 1302 && (p_scb->p_ccb != NULL) 1303 && (((type == AVDT_RTCP_PT_SR) && (p_scb->cs.tsep == AVDT_TSEP_SRC)) || 1304 ((type == AVDT_RTCP_PT_RR) && (p_scb->cs.tsep == AVDT_TSEP_SNK)) || 1305 (type == AVDT_RTCP_PT_SDES)) ) 1306 { 1307 result = AVDT_NO_RESOURCES; 1308 1309 /* build SR - assume fit in one packet */ 1310 p_tbl = avdt_ad_tc_tbl_by_type(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb); 1311 if((p_tbl->state == AVDT_AD_ST_OPEN) && 1312 (p_pkt = (BT_HDR *)GKI_getbuf(p_tbl->peer_mtu)) != NULL) 1313 { 1314 p_pkt->offset = L2CAP_MIN_OFFSET; 1315 p = (UINT8 *)(p_pkt + 1) + p_pkt->offset; 1316 #if AVDT_MULTIPLEXING == TRUE 1317 if(p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX) 1318 { 1319 /* Adaptation Layer header later */ 1320 p_al = p; 1321 p += 2; 1322 } 1323 #endif 1324 pm1 = p; 1325 *p++ = AVDT_MEDIA_OCTET1 | 1; 1326 *p++ = type; 1327 /* save the location for length */ 1328 plen = p; 1329 p+= 2; 1330 ssrc = avdt_scb_gen_ssrc(p_scb); 1331 UINT32_TO_BE_STREAM(p, ssrc); 1332 1333 switch(type) 1334 { 1335 case AVDT_RTCP_PT_SR: /* Sender Report */ 1336 *pm1 = AVDT_MEDIA_OCTET1; 1337 UINT32_TO_BE_STREAM(p, p_data->sr.ntp_sec); 1338 UINT32_TO_BE_STREAM(p, p_data->sr.ntp_frac); 1339 UINT32_TO_BE_STREAM(p, p_data->sr.rtp_time); 1340 UINT32_TO_BE_STREAM(p, p_data->sr.pkt_count); 1341 UINT32_TO_BE_STREAM(p, p_data->sr.octet_count); 1342 break; 1343 1344 case AVDT_RTCP_PT_RR: /* Receiver Report */ 1345 *p++ = p_data->rr.frag_lost; 1346 AVDT_TRACE_API1("packet_lost: %d", p_data->rr.packet_lost); 1347 p_data->rr.packet_lost &= 0xFFFFFF; 1348 AVDT_TRACE_API1("packet_lost: %d", p_data->rr.packet_lost); 1349 UINT24_TO_BE_STREAM(p, p_data->rr.packet_lost); 1350 UINT32_TO_BE_STREAM(p, p_data->rr.seq_num_rcvd); 1351 UINT32_TO_BE_STREAM(p, p_data->rr.jitter); 1352 UINT32_TO_BE_STREAM(p, p_data->rr.lsr); 1353 UINT32_TO_BE_STREAM(p, p_data->rr.dlsr); 1354 break; 1355 1356 case AVDT_RTCP_PT_SDES: /* Source Description */ 1357 *p++ = AVDT_RTCP_SDES_CNAME; 1358 len = strlen((char *)p_data->cname); 1359 if(len > AVDT_MAX_CNAME_SIZE) 1360 len = AVDT_MAX_CNAME_SIZE; 1361 *p++ = (UINT8)len; 1362 BCM_STRNCPY_S((char *)p, len+1, (char *)p_data->cname, len+1); 1363 p += len; 1364 break; 1365 } 1366 p_end = p; 1367 len = p - pm1 - 1; 1368 UINT16_TO_BE_STREAM(plen, len); 1369 1370 #if AVDT_MULTIPLEXING == TRUE 1371 if(p_scb->curr_cfg.psc_mask & AVDT_PSC_MUX) 1372 { 1373 /* Adaptation Layer header */ 1374 p = p_al; 1375 len++; 1376 UINT16_TO_BE_STREAM(p_al, len ); 1377 /* TSID, no-fragment bit and coding of length(9-bit length field) */ 1378 u = *p; 1379 *p = (p_scb->curr_cfg.mux_tsid_report<<3) | AVDT_ALH_LCODE_9BITM0; 1380 if(u) 1381 *p |= AVDT_ALH_LCODE_9BITM1; 1382 } 1383 #endif 1384 1385 /* set the actual payload length */ 1386 p_pkt->len = p_end - p; 1387 /* send the packet */ 1388 if(L2CAP_DW_FAILED != avdt_ad_write_req(AVDT_CHAN_REPORT, p_scb->p_ccb, p_scb, p_pkt)) 1389 result = AVDT_SUCCESS; 1390 } 1391 } 1392 1393 return result; 1394 } 1395 #endif 1396 1397 /****************************************************************************** 1398 ** 1399 ** Function AVDT_SetTraceLevel 1400 ** 1401 ** Description Sets the trace level for AVDT. If 0xff is passed, the 1402 ** current trace level is returned. 1403 ** 1404 ** Input Parameters: 1405 ** new_level: The level to set the AVDT tracing to: 1406 ** 0xff-returns the current setting. 1407 ** 0-turns off tracing. 1408 ** >= 1-Errors. 1409 ** >= 2-Warnings. 1410 ** >= 3-APIs. 1411 ** >= 4-Events. 1412 ** >= 5-Debug. 1413 ** 1414 ** Returns The new trace level or current trace level if 1415 ** the input parameter is 0xff. 1416 ** 1417 ******************************************************************************/ 1418 UINT8 AVDT_SetTraceLevel (UINT8 new_level) 1419 { 1420 if (new_level != 0xFF) 1421 avdt_cb.trace_level = new_level; 1422 1423 return (avdt_cb.trace_level); 1424 } 1425 1426
