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