stack/avdt/avdt_ccb_act.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2006-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /******************************************************************************
  20  *
  21  *  This module contains the action functions associated with the channel
  22  *  control block state machine.
  23  *
  24  ******************************************************************************/
  25
  26 #include <string.h>
  27 #include "bt_types.h"
  28 #include "bt_target.h"
  29 #include "bt_utils.h"
  30 #include "avdt_api.h"
  31 #include "avdtc_api.h"
  32 #include "avdt_int.h"
  33 #include "bt_common.h"
  34 #include "btu.h"
  35 #include "btm_api.h"
  36
  37 extern fixed_queue_t *btu_general_alarm_queue;
  38
  39 /*******************************************************************************
  40 **
  41 ** Function         avdt_ccb_clear_ccb
  42 **
  43 ** Description      This function clears out certain buffers, queues, and
  44 **                  other data elements of a ccb.
  45 **
  46 **
  47 ** Returns          void.
  48 **
  49 *******************************************************************************/
  50 static void avdt_ccb_clear_ccb(tAVDT_CCB *p_ccb)
  51 {
  52     BT_HDR          *p_buf;
  53
  54     /* clear certain ccb variables */
  55     p_ccb->cong = FALSE;
  56     p_ccb->ret_count = 0;
  57
  58     /* free message being fragmented */
  59     osi_free_and_reset((void **)&p_ccb->p_curr_msg);
  60
  61     /* free message being reassembled */
  62     osi_free_and_reset((void **)&p_ccb->p_rx_msg);
  63
  64     /* clear out response queue */
  65     while ((p_buf = (BT_HDR *) fixed_queue_try_dequeue(p_ccb->rsp_q)) != NULL)
  66         osi_free(p_buf);
  67 }
  68
  69 /*******************************************************************************
  70 **
  71 ** Function         avdt_ccb_chan_open
  72 **
  73 ** Description      This function calls avdt_ad_open_req() to
  74 **                  initiate a signaling channel connection.
  75 **
  76 **
  77 ** Returns          void.
  78 **
  79 *******************************************************************************/
  80 void avdt_ccb_chan_open(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
  81 {
  82     UNUSED(p_data);
  83
  84     BTM_SetOutService(p_ccb->peer_addr, BTM_SEC_SERVICE_AVDTP, AVDT_CHAN_SIG);
  85     avdt_ad_open_req(AVDT_CHAN_SIG, p_ccb, NULL, AVDT_INT);
  86 }
  87
  88 /*******************************************************************************
  89 **
  90 ** Function         avdt_ccb_chan_close
  91 **
  92 ** Description      This function calls avdt_ad_close_req() to close a
  93 **                  signaling channel connection.
  94 **
  95 **
  96 ** Returns          void.
  97 **
  98 *******************************************************************************/
  99 void avdt_ccb_chan_close(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 100 {
 101     UNUSED(p_data);
 102
 103     /* close the transport channel used by this CCB */
 104     avdt_ad_close_req(AVDT_CHAN_SIG, p_ccb, NULL);
 105 }
 106
 107 /*******************************************************************************
 108 **
 109 ** Function         avdt_ccb_chk_close
 110 **
 111 ** Description      This function checks for active streams on this CCB.
 112 **                  If there are none, it starts an idle timer.
 113 **
 114 **
 115 ** Returns          void.
 116 **
 117 *******************************************************************************/
 118 void avdt_ccb_chk_close(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 119 {
 120     int         i;
 121     tAVDT_SCB   *p_scb = &avdt_cb.scb[0];
 122     UNUSED(p_data);
 123
 124     /* see if there are any active scbs associated with this ccb */
 125     for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
 126     {
 127         if ((p_scb->allocated) && (p_scb->p_ccb == p_ccb))
 128         {
 129             break;
 130         }
 131     }
 132
 133     /* if no active scbs start idle timer */
 134     if (i == AVDT_NUM_SEPS)
 135     {
 136         alarm_cancel(p_ccb->ret_ccb_timer);
 137         alarm_cancel(p_ccb->rsp_ccb_timer);
 138         period_ms_t interval_ms = avdt_cb.rcb.idle_tout * 1000;
 139         alarm_set_on_queue(p_ccb->idle_ccb_timer, interval_ms,
 140                            avdt_ccb_idle_ccb_timer_timeout, p_ccb,
 141                            btu_general_alarm_queue);
 142     }
 143 }
 144
 145 /*******************************************************************************
 146 **
 147 ** Function         avdt_ccb_hdl_discover_cmd
 148 **
 149 ** Description      This function is called when a discover command is
 150 **                  received from the peer.  It gathers up the stream
 151 **                  information for all allocated streams and initiates
 152 **                  sending of a discover response.
 153 **
 154 **
 155 ** Returns          void.
 156 **
 157 *******************************************************************************/
 158 void avdt_ccb_hdl_discover_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 159 {
 160     tAVDT_SEP_INFO      sep_info[AVDT_NUM_SEPS];
 161     tAVDT_SCB           *p_scb = &avdt_cb.scb[0];
 162     int                 i;
 163
 164     p_data->msg.discover_rsp.p_sep_info = sep_info;
 165     p_data->msg.discover_rsp.num_seps = 0;
 166
 167     /* for all allocated scbs */
 168     for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
 169     {
 170         if (p_scb->allocated)
 171         {
 172             /* copy sep info */
 173             sep_info[p_data->msg.discover_rsp.num_seps].in_use = p_scb->in_use;
 174             sep_info[p_data->msg.discover_rsp.num_seps].seid = i + 1;
 175             sep_info[p_data->msg.discover_rsp.num_seps].media_type = p_scb->cs.media_type;
 176             sep_info[p_data->msg.discover_rsp.num_seps].tsep = p_scb->cs.tsep;
 177
 178             p_data->msg.discover_rsp.num_seps++;
 179         }
 180     }
 181
 182     /* send response */
 183     avdt_ccb_event(p_ccb, AVDT_CCB_API_DISCOVER_RSP_EVT, p_data);
 184 }
 185
 186 /*******************************************************************************
 187 **
 188 ** Function         avdt_ccb_hdl_discover_rsp
 189 **
 190 ** Description      This function is called when a discover response or
 191 **                  reject is received from the peer.  It calls the application
 192 **                  callback function with the results.
 193 **
 194 **
 195 ** Returns          void.
 196 **
 197 *******************************************************************************/
 198 void avdt_ccb_hdl_discover_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 199 {
 200     /* we're done with procedure */
 201     p_ccb->proc_busy = FALSE;
 202
 203     /* call app callback with results */
 204     (*p_ccb->proc_cback)(0, p_ccb->peer_addr, AVDT_DISCOVER_CFM_EVT,
 205                          (tAVDT_CTRL *)(&p_data->msg.discover_rsp));
 206 }
 207
 208 /*******************************************************************************
 209 **
 210 ** Function         avdt_ccb_hdl_getcap_cmd
 211 **
 212 ** Description      This function is called when a get capabilities command
 213 **                  is received from the peer.  It retrieves the stream
 214 **                  configuration for the requested stream and initiates
 215 **                  sending of a get capabilities response.
 216 **
 217 **
 218 ** Returns          void.
 219 **
 220 *******************************************************************************/
 221 void avdt_ccb_hdl_getcap_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 222 {
 223     tAVDT_SCB       *p_scb;
 224
 225     /* look up scb for seid sent to us */
 226     p_scb = avdt_scb_by_hdl(p_data->msg.single.seid);
 227
 228     p_data->msg.svccap.p_cfg = &p_scb->cs.cfg;
 229
 230     avdt_ccb_event(p_ccb, AVDT_CCB_API_GETCAP_RSP_EVT, p_data);
 231 }
 232
 233 /*******************************************************************************
 234 **
 235 ** Function         avdt_ccb_hdl_getcap_rsp
 236 **
 237 ** Description      This function is called with a get capabilities response
 238 **                  or reject is received from the peer.  It calls the
 239 **                  application callback function with the results.
 240 **
 241 **
 242 ** Returns          void.
 243 **
 244 *******************************************************************************/
 245 void avdt_ccb_hdl_getcap_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 246 {
 247     /* we're done with procedure */
 248     p_ccb->proc_busy = FALSE;
 249
 250     /* call app callback with results */
 251     (*p_ccb->proc_cback)(0, p_ccb->peer_addr, AVDT_GETCAP_CFM_EVT,
 252                          (tAVDT_CTRL *)(&p_data->msg.svccap));
 253 }
 254
 255 /*******************************************************************************
 256 **
 257 ** Function         avdt_ccb_hdl_start_cmd
 258 **
 259 ** Description      This function is called when a start command is received
 260 **                  from the peer.  It verifies that all requested streams
 261 **                  are in the proper state.  If so, it initiates sending of
 262 **                  a start response.  Otherwise it sends a start reject.
 263 **
 264 **
 265 ** Returns          void.
 266 **
 267 *******************************************************************************/
 268 void avdt_ccb_hdl_start_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 269 {
 270     UINT8   err_code = 0;
 271
 272     /* verify all streams in the right state */
 273     UINT8 seid = avdt_scb_verify(p_ccb, AVDT_VERIFY_START, p_data->msg.multi.seid_list,
 274                                  p_data->msg.multi.num_seps, &err_code);
 275     if (seid == 0 && err_code == 0)
 276     {
 277         /* we're ok, send response */
 278         avdt_ccb_event(p_ccb, AVDT_CCB_API_START_RSP_EVT, p_data);
 279     } else {
 280         /* not ok, send reject */
 281         p_data->msg.hdr.err_code = err_code;
 282         p_data->msg.hdr.err_param = seid;
 283         avdt_msg_send_rej(p_ccb, AVDT_SIG_START, &p_data->msg);
 284     }
 285 }
 286
 287 /*******************************************************************************
 288 **
 289 ** Function         avdt_ccb_hdl_start_rsp
 290 **
 291 ** Description      This function is called when a start response or reject
 292 **                  is received from the peer.  Using the SEIDs stored in the
 293 **                  current command message, it sends a start response or start
 294 **                  reject event to each SCB associated with the command.
 295 **
 296 **
 297 ** Returns          void.
 298 **
 299 *******************************************************************************/
 300 void avdt_ccb_hdl_start_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 301 {
 302     UINT8       event;
 303     int         i;
 304     UINT8       *p;
 305     tAVDT_SCB   *p_scb;
 306
 307     /* determine rsp or rej event */
 308     event = (p_data->msg.hdr.err_code == 0) ?
 309             AVDT_SCB_MSG_START_RSP_EVT : AVDT_SCB_MSG_START_REJ_EVT;
 310
 311     /* get to where seid's are stashed in current cmd */
 312     p = (UINT8 *)(p_ccb->p_curr_cmd + 1);
 313
 314     /* little trick here; length of current command equals number of streams */
 315     for (i = 0; i < p_ccb->p_curr_cmd->len; i++)
 316     {
 317         if ((p_scb = avdt_scb_by_hdl(p[i])) != NULL)
 318         {
 319             avdt_scb_event(p_scb, event, (tAVDT_SCB_EVT *) &p_data->msg);
 320         }
 321     }
 322 }
 323
 324 /*******************************************************************************
 325 **
 326 ** Function         avdt_ccb_hdl_suspend_cmd
 327 **
 328 ** Description      This function is called when a suspend command is received
 329 **                  from the peer.  It verifies that all requested streams are
 330 **                  in the proper state.  If so, it initiates sending of a
 331 **                  suspend response.  Otherwise it sends a suspend reject.
 332
 333 **
 334 **
 335 ** Returns          void.
 336 **
 337 *******************************************************************************/
 338 void avdt_ccb_hdl_suspend_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 339 {
 340     UINT8   seid;
 341     UINT8   err_code = 0;
 342
 343     /* verify all streams in the right state */
 344     if ((seid = avdt_scb_verify(p_ccb, AVDT_VERIFY_SUSPEND, p_data->msg.multi.seid_list,
 345                                 p_data->msg.multi.num_seps, &err_code)) == 0 &&
 346                                 err_code == 0)
 347     {
 348         /* we're ok, send response */
 349         avdt_ccb_event(p_ccb, AVDT_CCB_API_SUSPEND_RSP_EVT, p_data);
 350     }
 351     else
 352     {
 353         /* not ok, send reject */
 354         p_data->msg.hdr.err_code = err_code;
 355         p_data->msg.hdr.err_param = seid;
 356         avdt_msg_send_rej(p_ccb, AVDT_SIG_SUSPEND, &p_data->msg);
 357     }
 358 }
 359
 360 /*******************************************************************************
 361 **
 362 ** Function         avdt_ccb_hdl_suspend_rsp
 363 **
 364 ** Description      This function is called when a suspend response or reject
 365 **                  is received from the peer.  Using the SEIDs stored in the
 366 **                  current command message, it sends a suspend response or
 367 **                  suspend reject event to each SCB associated with the command.
 368 **
 369 **
 370 **
 371 ** Returns          void.
 372 **
 373 *******************************************************************************/
 374 void avdt_ccb_hdl_suspend_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 375 {
 376     UINT8       event;
 377     int         i;
 378     UINT8       *p;
 379     tAVDT_SCB   *p_scb;
 380
 381     /* determine rsp or rej event */
 382     event = (p_data->msg.hdr.err_code == 0) ?
 383             AVDT_SCB_MSG_SUSPEND_RSP_EVT : AVDT_SCB_MSG_SUSPEND_REJ_EVT;
 384
 385     /* get to where seid's are stashed in current cmd */
 386     p = (UINT8 *)(p_ccb->p_curr_cmd + 1);
 387
 388     /* little trick here; length of current command equals number of streams */
 389     for (i = 0; i < p_ccb->p_curr_cmd->len; i++)
 390     {
 391         if ((p_scb = avdt_scb_by_hdl(p[i])) != NULL)
 392         {
 393             avdt_scb_event(p_scb, event, (tAVDT_SCB_EVT *) &p_data->msg);
 394         }
 395     }
 396 }
 397
 398 /*******************************************************************************
 399 **
 400 ** Function         avdt_ccb_snd_discover_cmd
 401 **
 402 ** Description      This function is called to send a discover command to the
 403 **                  peer.  It copies variables needed for the procedure from
 404 **                  the event to the CCB.  It marks the CCB as busy and then
 405 **                  sends a discover command.
 406 **
 407 **
 408 ** Returns          void.
 409 **
 410 *******************************************************************************/
 411 void avdt_ccb_snd_discover_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 412 {
 413     /* store info in ccb struct */
 414     p_ccb->p_proc_data = p_data->discover.p_sep_info;
 415     p_ccb->proc_cback = p_data->discover.p_cback;
 416     p_ccb->proc_param = p_data->discover.num_seps;
 417
 418     /* we're busy */
 419     p_ccb->proc_busy = TRUE;
 420
 421     /* build and queue discover req */
 422     avdt_msg_send_cmd(p_ccb, NULL, AVDT_SIG_DISCOVER, NULL);
 423 }
 424
 425 /*******************************************************************************
 426 **
 427 ** Function         avdt_ccb_snd_discover_rsp
 428 **
 429 ** Description      This function is called to send a discover response to
 430 **                  the peer.  It takes the stream information passed in the
 431 **                  event and sends a discover response.
 432 **
 433 **
 434 ** Returns          void.
 435 **
 436 *******************************************************************************/
 437 void avdt_ccb_snd_discover_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 438 {
 439     /* send response */
 440     avdt_msg_send_rsp(p_ccb, AVDT_SIG_DISCOVER, &p_data->msg);
 441 }
 442
 443 /*******************************************************************************
 444 **
 445 ** Function         avdt_ccb_snd_getcap_cmd
 446 **
 447 ** Description      This function is called to send a get capabilities command
 448 **                  to the peer.  It copies variables needed for the procedure
 449 **                  from the event to the CCB.  It marks the CCB as busy and
 450 **                  then sends a get capabilities command.
 451 **
 452 **
 453 ** Returns          void.
 454 **
 455 *******************************************************************************/
 456 void avdt_ccb_snd_getcap_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 457 {
 458     UINT8 sig_id = AVDT_SIG_GETCAP;
 459
 460     /* store info in ccb struct */
 461     p_ccb->p_proc_data = p_data->getcap.p_cfg;
 462     p_ccb->proc_cback = p_data->getcap.p_cback;
 463
 464     /* we're busy */
 465     p_ccb->proc_busy = TRUE;
 466
 467     /* build and queue discover req */
 468     if (p_data->msg.hdr.sig_id == AVDT_SIG_GET_ALLCAP)
 469         sig_id = AVDT_SIG_GET_ALLCAP;
 470
 471     avdt_msg_send_cmd(p_ccb, NULL, sig_id, (tAVDT_MSG *) &p_data->getcap.single);
 472 }
 473
 474 /*******************************************************************************
 475 **
 476 ** Function         avdt_ccb_snd_getcap_rsp
 477 **
 478 ** Description      This function is called to send a get capabilities response
 479 **                  to the peer.  It takes the stream information passed in the
 480 **                  event and sends a get capabilities response.
 481 **
 482 **
 483 ** Returns          void.
 484 **
 485 *******************************************************************************/
 486 void avdt_ccb_snd_getcap_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 487 {
 488     UINT8 sig_id = AVDT_SIG_GETCAP;
 489
 490     if (p_data->msg.hdr.sig_id == AVDT_SIG_GET_ALLCAP)
 491         sig_id = AVDT_SIG_GET_ALLCAP;
 492
 493     /* send response */
 494     avdt_msg_send_rsp(p_ccb, sig_id, &p_data->msg);
 495 }
 496
 497 /*******************************************************************************
 498 **
 499 ** Function         avdt_ccb_snd_start_cmd
 500 **
 501 ** Description      This function is called to send a start command to the
 502 **                  peer.  It verifies that all requested streams are in the
 503 **                  proper state.  If so, it sends a start command.  Otherwise
 504 **                  send ourselves back a start reject.
 505 **
 506 **
 507 ** Returns          void.
 508 **
 509 *******************************************************************************/
 510 void avdt_ccb_snd_start_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 511 {
 512     int             i;
 513     tAVDT_SCB       *p_scb;
 514     tAVDT_MSG       avdt_msg;
 515     UINT8           seid_list[AVDT_NUM_SEPS];
 516
 517     /* make copy of our seid list */
 518     memcpy(seid_list, p_data->msg.multi.seid_list, p_data->msg.multi.num_seps);
 519
 520     /* verify all streams in the right state */
 521     if ((avdt_msg.hdr.err_param = avdt_scb_verify(p_ccb, AVDT_VERIFY_OPEN, p_data->msg.multi.seid_list,
 522                                          p_data->msg.multi.num_seps, &avdt_msg.hdr.err_code)) == 0)
 523     {
 524         /* set peer seid list in messsage */
 525         avdt_scb_peer_seid_list(&p_data->msg.multi);
 526
 527         /* send command */
 528         avdt_msg_send_cmd(p_ccb, seid_list, AVDT_SIG_START, &p_data->msg);
 529     }
 530     else
 531     {
 532         /* failed; send ourselves a reject for each stream */
 533         for (i = 0; i < p_data->msg.multi.num_seps; i++)
 534         {
 535             if ((p_scb = avdt_scb_by_hdl(seid_list[i])) != NULL)
 536             {
 537                 avdt_scb_event(p_scb, AVDT_SCB_MSG_START_REJ_EVT, (tAVDT_SCB_EVT *) &avdt_msg.hdr);
 538             }
 539         }
 540     }
 541 }
 542
 543 /*******************************************************************************
 544 **
 545 ** Function         avdt_ccb_snd_start_rsp
 546 **
 547 ** Description      This function is called to send a start response to the
 548 **                  peer.  It takes the stream information passed in the event
 549 **                  and sends a start response.  Then it sends a start event
 550 **                  to the SCB for each stream.
 551 **
 552 **
 553 ** Returns          void.
 554 **
 555 *******************************************************************************/
 556 void avdt_ccb_snd_start_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 557 {
 558     tAVDT_SCB *p_scb;
 559     int i;
 560
 561     /* send response message */
 562     avdt_msg_send_rsp(p_ccb, AVDT_SIG_START, &p_data->msg);
 563
 564     /* send start event to each scb */
 565     for (i = 0; i < p_data->msg.multi.num_seps; i++)
 566     {
 567         if ((p_scb = avdt_scb_by_hdl(p_data->msg.multi.seid_list[i])) != NULL)
 568         {
 569             avdt_scb_event(p_scb, AVDT_SCB_MSG_START_CMD_EVT, NULL);
 570         }
 571     }
 572 }
 573
 574 /*******************************************************************************
 575 **
 576 ** Function         avdt_ccb_snd_suspend_cmd
 577 **
 578 ** Description      This function is called to send a suspend command to the
 579 **                  peer.  It verifies that all requested streams are in the
 580 **                  proper state.  If so, it sends a suspend command.
 581 **                  Otherwise it calls the callback function for each requested
 582 **                  stream and sends a suspend confirmation with failure.
 583 **
 584 **
 585 ** Returns          void.
 586 **
 587 *******************************************************************************/
 588 void avdt_ccb_snd_suspend_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 589 {
 590     int             i;
 591     tAVDT_SCB       *p_scb;
 592     tAVDT_MSG       avdt_msg;
 593     UINT8           seid_list[AVDT_NUM_SEPS];
 594
 595     /* make copy of our seid list */
 596     memcpy(seid_list, p_data->msg.multi.seid_list, p_data->msg.multi.num_seps);
 597
 598     /* verify all streams in the right state */
 599     if ((avdt_msg.hdr.err_param = avdt_scb_verify(p_ccb, AVDT_VERIFY_STREAMING, p_data->msg.multi.seid_list,
 600                                          p_data->msg.multi.num_seps, &avdt_msg.hdr.err_code)) == 0)
 601     {
 602         /* set peer seid list in messsage */
 603         avdt_scb_peer_seid_list(&p_data->msg.multi);
 604
 605         /* send command */
 606         avdt_msg_send_cmd(p_ccb, seid_list, AVDT_SIG_SUSPEND, &p_data->msg);
 607     }
 608     else
 609     {
 610         /* failed; send ourselves a reject for each stream */
 611         for (i = 0; i < p_data->msg.multi.num_seps; i++)
 612         {
 613             if ((p_scb = avdt_scb_by_hdl(seid_list[i])) != NULL)
 614             {
 615                 avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_REJ_EVT, (tAVDT_SCB_EVT *) &avdt_msg.hdr);
 616             }
 617         }
 618     }
 619 }
 620
 621 /*******************************************************************************
 622 **
 623 ** Function         avdt_ccb_snd_suspend_rsp
 624 **
 625 ** Description      This function is called to send a suspend response to the
 626 **                  peer.  It takes the stream information passed in the event
 627 **                  and sends a suspend response.  Then it sends a suspend event
 628 **                  to the SCB for each stream.
 629 **
 630 **
 631 ** Returns          void.
 632 **
 633 *******************************************************************************/
 634 void avdt_ccb_snd_suspend_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 635 {
 636     tAVDT_SCB *p_scb;
 637     int i;
 638
 639     /* send response message */
 640     avdt_msg_send_rsp(p_ccb, AVDT_SIG_SUSPEND, &p_data->msg);
 641
 642     /* send start event to each scb */
 643     for (i = 0; i < p_data->msg.multi.num_seps; i++)
 644     {
 645         if ((p_scb = avdt_scb_by_hdl(p_data->msg.multi.seid_list[i])) != NULL)
 646         {
 647             avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_CMD_EVT, NULL);
 648         }
 649     }
 650 }
 651
 652 /*******************************************************************************
 653 **
 654 ** Function         avdt_ccb_clear_cmds
 655 **
 656 ** Description      This function is called when the signaling channel is
 657 **                  closed to clean up any pending commands.  For each pending
 658 **                  command in the command queue, it frees the command and
 659 **                  calls the application callback function indicating failure.
 660 **                  Certain CCB variables are also initialized.
 661 **
 662 **
 663 ** Returns          void.
 664 **
 665 *******************************************************************************/
 666 void avdt_ccb_clear_cmds(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 667 {
 668     int             i;
 669     tAVDT_SCB       *p_scb = &avdt_cb.scb[0];
 670     UINT8           err_code = AVDT_ERR_CONNECT;
 671     UNUSED(p_data);
 672
 673     /* clear the ccb */
 674     avdt_ccb_clear_ccb(p_ccb);
 675
 676     /* clear out command queue; this is a little tricky here; we need
 677     ** to handle the case where there is a command on deck in p_curr_cmd,
 678     ** plus we need to clear out the queue
 679     */
 680     do
 681     {
 682         /* we know p_curr_cmd = NULL after this */
 683         avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT *) &err_code);
 684
 685         /* set up next message */
 686         p_ccb->p_curr_cmd = (BT_HDR *) fixed_queue_try_dequeue(p_ccb->cmd_q);
 687
 688     } while (p_ccb->p_curr_cmd != NULL);
 689
 690     /* send a CC_CLOSE_EVT any active scbs associated with this ccb */
 691     for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
 692     {
 693         if ((p_scb->allocated) && (p_scb->p_ccb == p_ccb))
 694         {
 695             avdt_scb_event(p_scb, AVDT_SCB_CC_CLOSE_EVT, NULL);
 696         }
 697     }
 698 }
 699
 700 /*******************************************************************************
 701 **
 702 ** Function         avdt_ccb_cmd_fail
 703 **
 704 ** Description      This function is called when there is a response timeout.
 705 **                  The currently pending command is freed and we fake a
 706 **                  reject message back to ourselves.
 707 **
 708 **
 709 ** Returns          void.
 710 **
 711 *******************************************************************************/
 712 void avdt_ccb_cmd_fail(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 713 {
 714     tAVDT_MSG       msg;
 715     UINT8           evt;
 716     tAVDT_SCB       *p_scb;
 717
 718     if (p_ccb->p_curr_cmd != NULL)
 719     {
 720         /* set up data */
 721         msg.hdr.err_code = p_data->err_code;
 722         msg.hdr.err_param = 0;
 723         msg.hdr.ccb_idx = avdt_ccb_to_idx(p_ccb);
 724
 725         /* pretend that we received a rej message */
 726         evt = avdt_msg_rej_2_evt[p_ccb->p_curr_cmd->event - 1];
 727
 728         if (evt & AVDT_CCB_MKR)
 729         {
 730             avdt_ccb_event(p_ccb, (UINT8) (evt & ~AVDT_CCB_MKR), (tAVDT_CCB_EVT *) &msg);
 731         }
 732         else
 733         {
 734             /* we get the scb out of the current cmd */
 735             p_scb = avdt_scb_by_hdl(*((UINT8 *)(p_ccb->p_curr_cmd + 1)));
 736             if (p_scb != NULL)
 737             {
 738                 avdt_scb_event(p_scb, evt, (tAVDT_SCB_EVT *) &msg);
 739             }
 740         }
 741
 742         osi_free_and_reset((void **)&p_ccb->p_curr_cmd);
 743     }
 744 }
 745
 746 /*******************************************************************************
 747 **
 748 ** Function         avdt_ccb_free_cmd
 749 **
 750 ** Description      This function is called when a response is received for a
 751 **                  currently pending command.  The command is freed.
 752 **
 753 **
 754 ** Returns          void.
 755 **
 756 *******************************************************************************/
 757 void avdt_ccb_free_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 758 {
 759     UNUSED(p_data);
 760     osi_free_and_reset((void **)&p_ccb->p_curr_cmd);
 761 }
 762
 763 /*******************************************************************************
 764 **
 765 ** Function         avdt_ccb_cong_state
 766 **
 767 ** Description      This function is called to set the congestion state for
 768 **                  the CCB.
 769 **
 770 **
 771 ** Returns          void.
 772 **
 773 *******************************************************************************/
 774 void avdt_ccb_cong_state(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 775 {
 776     p_ccb->cong = p_data->llcong;
 777 }
 778
 779 /*******************************************************************************
 780 **
 781 ** Function         avdt_ccb_ret_cmd
 782 **
 783 ** Description      This function is called to retransmit the currently
 784 **                  pending command.  The retransmission count is incremented.
 785 **                  If the count reaches the maximum number of retransmissions,
 786 **                  the event is treated as a response timeout.
 787 **
 788 **
 789 ** Returns          void.
 790 **
 791 *******************************************************************************/
 792 void avdt_ccb_ret_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 793 {
 794     UINT8   err_code = AVDT_ERR_TIMEOUT;
 795
 796     p_ccb->ret_count++;
 797     if (p_ccb->ret_count == AVDT_RET_MAX)
 798     {
 799         /* command failed */
 800         p_ccb->ret_count = 0;
 801         avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT *) &err_code);
 802
 803         /* go to next queued command */
 804         avdt_ccb_snd_cmd(p_ccb, p_data);
 805     }
 806     else
 807     {
 808         /* if command pending and we're not congested and not sending a fragment */
 809         if ((!p_ccb->cong) && (p_ccb->p_curr_msg == NULL) && (p_ccb->p_curr_cmd != NULL))
 810         {
 811             /* make copy of message in p_curr_cmd and send it */
 812             BT_HDR *p_msg = (BT_HDR *)osi_malloc(AVDT_CMD_BUF_SIZE);
 813             memcpy(p_msg, p_ccb->p_curr_cmd,
 814                    (sizeof(BT_HDR) + p_ccb->p_curr_cmd->offset + p_ccb->p_curr_cmd->len));
 815             avdt_msg_send(p_ccb, p_msg);
 816         }
 817
 818         /* restart ret timer */
 819         alarm_cancel(p_ccb->idle_ccb_timer);
 820         alarm_cancel(p_ccb->rsp_ccb_timer);
 821         period_ms_t interval_ms = avdt_cb.rcb.ret_tout * 1000;
 822         alarm_set_on_queue(p_ccb->ret_ccb_timer, interval_ms,
 823                            avdt_ccb_ret_ccb_timer_timeout, p_ccb,
 824                            btu_general_alarm_queue);
 825     }
 826 }
 827
 828 /*******************************************************************************
 829 **
 830 ** Function         avdt_ccb_snd_cmd
 831 **
 832 ** Description      This function is called the send the next command,
 833 **                  if any, in the command queue.
 834 **
 835 **
 836 ** Returns          void.
 837 **
 838 *******************************************************************************/
 839 void avdt_ccb_snd_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 840 {
 841     BT_HDR  *p_msg;
 842     UNUSED(p_data);
 843
 844     /* do we have commands to send?  send next command;  make sure we're clear;
 845     ** not congested, not sending fragment, not waiting for response
 846     */
 847     if ((!p_ccb->cong) && (p_ccb->p_curr_msg == NULL) && (p_ccb->p_curr_cmd == NULL))
 848     {
 849         if ((p_msg = (BT_HDR *) fixed_queue_try_dequeue(p_ccb->cmd_q)) != NULL)
 850         {
 851             /* make a copy of buffer in p_curr_cmd */
 852             p_ccb->p_curr_cmd = (BT_HDR *)osi_malloc(AVDT_CMD_BUF_SIZE);
 853             memcpy(p_ccb->p_curr_cmd, p_msg,
 854                    (sizeof(BT_HDR) + p_msg->offset + p_msg->len));
 855             avdt_msg_send(p_ccb, p_msg);
 856         }
 857     }
 858 }
 859
 860 /*******************************************************************************
 861 **
 862 ** Function         avdt_ccb_snd_msg
 863 **
 864 ** Description
 865 **
 866 **
 867 ** Returns          void.
 868 **
 869 *******************************************************************************/
 870 void avdt_ccb_snd_msg(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 871 {
 872     BT_HDR      *p_msg;
 873     UNUSED(p_data);
 874
 875     /* if not congested */
 876     if (!p_ccb->cong)
 877     {
 878         /* are we sending a fragmented message? continue sending fragment */
 879         if (p_ccb->p_curr_msg != NULL)
 880         {
 881             avdt_msg_send(p_ccb, NULL);
 882         }
 883         /* do we have responses to send?  send them */
 884         else if (!fixed_queue_is_empty(p_ccb->rsp_q))
 885         {
 886             while ((p_msg = (BT_HDR *)fixed_queue_try_dequeue(p_ccb->rsp_q)) != NULL)
 887             {
 888                 if (avdt_msg_send(p_ccb, p_msg) == TRUE)
 889                 {
 890                     /* break out if congested */
 891                     break;
 892                 }
 893             }
 894         }
 895
 896         /* do we have commands to send?  send next command */
 897         avdt_ccb_snd_cmd(p_ccb, NULL);
 898     }
 899 }
 900
 901 /*******************************************************************************
 902 **
 903 ** Function         avdt_ccb_set_reconn
 904 **
 905 ** Description      This function is called to enable a reconnect attempt when
 906 **                  a channel transitions from closing to idle state.  It sets
 907 **                  the reconn variable to TRUE.
 908 **
 909 **
 910 ** Returns          void.
 911 **
 912 *******************************************************************************/
 913 void avdt_ccb_set_reconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 914 {
 915     UNUSED(p_data);
 916
 917     p_ccb->reconn = TRUE;
 918 }
 919
 920 /*******************************************************************************
 921 **
 922 ** Function         avdt_ccb_clr_reconn
 923 **
 924 ** Description      This function is called to clear the reconn variable.
 925 **
 926 **
 927 ** Returns          void.
 928 **
 929 *******************************************************************************/
 930 void avdt_ccb_clr_reconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 931 {
 932     UNUSED(p_data);
 933
 934     p_ccb->reconn = FALSE;
 935 }
 936
 937 /*******************************************************************************
 938 **
 939 ** Function         avdt_ccb_chk_reconn
 940 **
 941 ** Description      This function is called to check if a reconnect attempt
 942 **                  is enabled.  If enabled, it sends an AVDT_CCB_UL_OPEN_EVT
 943 **                  to the CCB.  If disabled, the CCB is deallocated.
 944 **
 945 **
 946 ** Returns          void.
 947 **
 948 *******************************************************************************/
 949 void avdt_ccb_chk_reconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 950 {
 951     UINT8   err_code = AVDT_ERR_CONNECT;
 952     UNUSED(p_data);
 953
 954     if (p_ccb->reconn)
 955     {
 956         p_ccb->reconn = FALSE;
 957
 958         /* clear out ccb */
 959         avdt_ccb_clear_ccb(p_ccb);
 960
 961         /* clear out current command, if any */
 962         avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT *) &err_code);
 963
 964         /* reopen the signaling channel */
 965         avdt_ccb_event(p_ccb, AVDT_CCB_UL_OPEN_EVT, NULL);
 966     }
 967     else
 968     {
 969         avdt_ccb_ll_closed(p_ccb, NULL);
 970     }
 971 }
 972
 973 /*******************************************************************************
 974 **
 975 ** Function         avdt_ccb_chk_timer
 976 **
 977 ** Description      This function stops the CCB timer if the idle timer is
 978 **                  running.
 979 **
 980 **
 981 ** Returns          void.
 982 **
 983 *******************************************************************************/
 984 void avdt_ccb_chk_timer(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 985 {
 986     UNUSED(p_data);
 987
 988     alarm_cancel(p_ccb->idle_ccb_timer);
 989 }
 990
 991 /*******************************************************************************
 992 **
 993 ** Function         avdt_ccb_set_conn
 994 **
 995 ** Description      Set CCB variables associated with AVDT_ConnectReq().
 996 **
 997 **
 998 ** Returns          void.
 999 **
1000 *******************************************************************************/
1001 void avdt_ccb_set_conn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
1002 {
1003     /* save callback */
1004     p_ccb->p_conn_cback = p_data->connect.p_cback;
1005
1006     /* set security level */
1007     BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_AVDTP, p_data->connect.sec_mask,
1008                          AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_SIG);
1009 }
1010
1011 /*******************************************************************************
1012 **
1013 ** Function         avdt_ccb_set_disconn
1014 **
1015 ** Description      Set CCB variables associated with AVDT_DisconnectReq().
1016 **
1017 **
1018 ** Returns          void.
1019 **
1020 *******************************************************************************/
1021 void avdt_ccb_set_disconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
1022 {
1023     /*
1024     AVDT_TRACE_EVENT("avdt_ccb_set_disconn:conn:x%x, api:x%x",
1025         p_ccb->p_conn_cback, p_data->disconnect.p_cback);
1026         */
1027     /* save callback */
1028     if (p_data->disconnect.p_cback)
1029         p_ccb->p_conn_cback = p_data->disconnect.p_cback;
1030 }
1031
1032 /*******************************************************************************
1033 **
1034 ** Function         avdt_ccb_do_disconn
1035 **
1036 ** Description      Do action associated with AVDT_DisconnectReq().
1037 **
1038 **
1039 ** Returns          void.
1040 **
1041 *******************************************************************************/
1042 void avdt_ccb_do_disconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
1043 {
1044     UNUSED(p_data);
1045
1046     /* clear any pending commands */
1047     avdt_ccb_clear_cmds(p_ccb, NULL);
1048
1049     /* close channel */
1050     avdt_ccb_chan_close(p_ccb, NULL);
1051 }
1052
1053 /*******************************************************************************
1054 **
1055 ** Function         avdt_ccb_ll_closed
1056 **
1057 ** Description      Clear commands from and deallocate CCB.
1058 **
1059 **
1060 ** Returns          void.
1061 **
1062 *******************************************************************************/
1063 void avdt_ccb_ll_closed(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
1064 {
1065     tAVDT_CTRL_CBACK    *p_cback;
1066     BD_ADDR             bd_addr;
1067     tAVDT_CTRL          avdt_ctrl;
1068     UNUSED(p_data);
1069
1070     /* clear any pending commands */
1071     avdt_ccb_clear_cmds(p_ccb, NULL);
1072
1073     /* save callback pointer, bd addr */
1074     p_cback = p_ccb->p_conn_cback;
1075     if (!p_cback)
1076         p_cback = avdt_cb.p_conn_cback;
1077     memcpy(bd_addr, p_ccb->peer_addr, BD_ADDR_LEN);
1078
1079     /* dealloc ccb */
1080     avdt_ccb_dealloc(p_ccb, NULL);
1081
1082     /* call callback */
1083     if (p_cback)
1084     {
1085         avdt_ctrl.hdr.err_code = 0;
1086         (*p_cback)(0, bd_addr, AVDT_DISCONNECT_IND_EVT, &avdt_ctrl);
1087     }
1088 }
1089
1090 /*******************************************************************************
1091 **
1092 ** Function         avdt_ccb_ll_opened
1093 **
1094 ** Description      Call callback on open.
1095 **
1096 **
1097 ** Returns          void.
1098 **
1099 *******************************************************************************/
1100 void avdt_ccb_ll_opened(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
1101 {
1102     tAVDT_CTRL          avdt_ctrl;
1103
1104     p_ccb->ll_opened = TRUE;
1105
1106     if (!p_ccb->p_conn_cback)
1107         p_ccb->p_conn_cback = avdt_cb.p_conn_cback;
1108
1109     /* call callback */
1110     if (p_ccb->p_conn_cback)
1111     {
1112         avdt_ctrl.hdr.err_code = 0;
1113         avdt_ctrl.hdr.err_param = p_data->msg.hdr.err_param;
1114         (*p_ccb->p_conn_cback)(0, p_ccb->peer_addr, AVDT_CONNECT_IND_EVT, &avdt_ctrl);
1115     }
1116 }