Home | History | Annotate | Download | only in avdt
      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 the AVDTP adaption layer.
     22  *
     23  ******************************************************************************/
     24 
     25 #include <assert.h>
     26 #include <string.h>
     27 
     28 #include "bt_types.h"
     29 #include "bt_target.h"
     30 #include "bt_utils.h"
     31 #include "avdt_api.h"
     32 #include "avdtc_api.h"
     33 #include "avdt_int.h"
     34 #include "l2c_api.h"
     35 #include "l2cdefs.h"
     36 
     37 
     38 /*******************************************************************************
     39 **
     40 ** Function         avdt_ad_type_to_tcid
     41 **
     42 ** Description      Derives the TCID from the channel type and SCB.
     43 **
     44 **
     45 ** Returns          TCID value.
     46 **
     47 *******************************************************************************/
     48 UINT8 avdt_ad_type_to_tcid(UINT8 type, tAVDT_SCB *p_scb)
     49 {
     50     UINT8 scb_idx;
     51 
     52     if (type == AVDT_CHAN_SIG)
     53     {
     54         return 0;
     55     }
     56     else
     57     {
     58         scb_idx = avdt_scb_to_hdl(p_scb) - 1;
     59         /*
     60         AVDT_TRACE_DEBUG("type: %d, tcid: %d", type, ((scb_idx * (AVDT_CHAN_NUM_TYPES - 1)) + type));
     61         */
     62         return ((scb_idx * (AVDT_CHAN_NUM_TYPES - 1)) + type);
     63     }
     64 }
     65 
     66 /*******************************************************************************
     67 **
     68 ** Function         avdt_ad_tcid_to_type
     69 **
     70 ** Description      Derives the channel type from the TCID.
     71 **
     72 **
     73 ** Returns          Channel type value.
     74 **
     75 *******************************************************************************/
     76 static UINT8 avdt_ad_tcid_to_type(UINT8 tcid)
     77 {
     78     UINT8 type;
     79 
     80     if (tcid == 0)
     81     {
     82         type = AVDT_CHAN_SIG;
     83     }
     84     else
     85     {
     86         /* tcid translates to type based on number of channels, as follows:
     87         ** only media channel   :  tcid=1,2,3,4,5,6...  type=1,1,1,1,1,1...
     88         ** media and report     :  tcid=1,2,3,4,5,6...  type=1,2,1,2,1,2...
     89         ** media, report, recov :  tcid=1,2,3,4,5,6...  type=1,2,3,1,2,3...
     90         */
     91         type = ((tcid + AVDT_CHAN_NUM_TYPES - 2) % (AVDT_CHAN_NUM_TYPES - 1)) + 1;
     92     }
     93     AVDT_TRACE_DEBUG("tcid: %d, type: %d", tcid, type);
     94     return type;
     95 }
     96 
     97 
     98 /*******************************************************************************
     99 **
    100 ** Function         avdt_ad_init
    101 **
    102 ** Description      Initialize adaption layer.
    103 **
    104 **
    105 ** Returns          Nothing.
    106 **
    107 *******************************************************************************/
    108 void avdt_ad_init(void)
    109 {
    110     int             i;
    111     tAVDT_TC_TBL    *p_tbl = avdt_cb.ad.tc_tbl;
    112     memset(&avdt_cb.ad, 0, sizeof(tAVDT_AD));
    113 
    114     /* make sure the peer_mtu is a valid value */
    115     for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
    116     {
    117         p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
    118     }
    119 }
    120 
    121 
    122 /*******************************************************************************
    123 **
    124 ** Function         avdt_ad_tc_tbl_by_st
    125 **
    126 ** Description      Find adaption layer transport channel table entry matching
    127 **                  the given state.
    128 **
    129 **
    130 ** Returns          Pointer to matching entry.  For control channel it returns
    131 **                  the matching entry.  For media or other it returns the
    132 **                  first matching entry (there could be more than one).
    133 **
    134 *******************************************************************************/
    135 tAVDT_TC_TBL *avdt_ad_tc_tbl_by_st(UINT8 type, tAVDT_CCB *p_ccb, UINT8 state)
    136 {
    137     int             i;
    138     tAVDT_TC_TBL    *p_tbl = avdt_cb.ad.tc_tbl;
    139     UINT8           ccb_idx;
    140 
    141     if (p_ccb == NULL)
    142     {
    143         /* resending security req */
    144         for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
    145         {
    146             /* must be AVDT_CHAN_SIG - tcid always zero */
    147             if ((p_tbl->tcid == 0) &&
    148                 (p_tbl->state == state))
    149             {
    150                 break;
    151             }
    152         }
    153     }
    154     else
    155     {
    156         ccb_idx = avdt_ccb_to_idx(p_ccb);
    157 
    158         for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
    159         {
    160             if (type == AVDT_CHAN_SIG)
    161             {
    162                 /* if control channel, tcid always zero */
    163                 if ((p_tbl->tcid == 0) &&
    164                     (p_tbl->ccb_idx == ccb_idx) &&
    165                     (p_tbl->state == state))
    166                 {
    167                     break;
    168                 }
    169             }
    170             else
    171             {
    172                 /* if other channel, tcid is always > zero */
    173                 if ((p_tbl->tcid > 0) &&
    174                     (p_tbl->ccb_idx == ccb_idx) &&
    175                     (p_tbl->state == state))
    176                 {
    177                     break;
    178                 }
    179             }
    180         }
    181     }
    182 
    183     /* if nothing found return null */
    184     if (i == AVDT_NUM_TC_TBL)
    185     {
    186         p_tbl = NULL;
    187     }
    188 
    189     return p_tbl;
    190 }
    191 
    192 
    193 /*******************************************************************************
    194 **
    195 ** Function         avdt_ad_tc_tbl_by_lcid
    196 **
    197 ** Description      Find adaption layer transport channel table entry by LCID.
    198 **
    199 **
    200 ** Returns          Pointer to entry.
    201 **
    202 *******************************************************************************/
    203 tAVDT_TC_TBL *avdt_ad_tc_tbl_by_lcid(UINT16 lcid)
    204 {
    205     UINT8 idx;
    206 
    207     idx = avdt_cb.ad.lcid_tbl[lcid - L2CAP_BASE_APPL_CID];
    208 
    209     if (idx < AVDT_NUM_TC_TBL)
    210     {
    211         return &avdt_cb.ad.tc_tbl[idx];
    212     }
    213     else
    214     {
    215         return NULL;
    216     }
    217 }
    218 
    219 
    220 /*******************************************************************************
    221 **
    222 ** Function         avdt_ad_tc_tbl_by_type
    223 **
    224 ** Description      This function retrieves the transport channel table entry
    225 **                  for a particular channel.
    226 **
    227 **
    228 ** Returns          Pointer to transport channel table entry.
    229 **
    230 *******************************************************************************/
    231 tAVDT_TC_TBL *avdt_ad_tc_tbl_by_type(UINT8 type, tAVDT_CCB *p_ccb, tAVDT_SCB *p_scb)
    232 {
    233     UINT8           tcid;
    234     int             i;
    235     tAVDT_TC_TBL    *p_tbl = avdt_cb.ad.tc_tbl;
    236     UINT8           ccb_idx = avdt_ccb_to_idx(p_ccb);
    237 
    238     /* get tcid from type, scb */
    239     tcid = avdt_ad_type_to_tcid(type, p_scb);
    240 
    241     for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
    242     {
    243         if ((p_tbl->tcid == tcid) && (p_tbl->ccb_idx == ccb_idx))
    244         {
    245             break;
    246         }
    247     }
    248 
    249     assert(i != AVDT_NUM_TC_TBL);
    250 
    251     return p_tbl;
    252 }
    253 
    254 
    255 /*******************************************************************************
    256 **
    257 ** Function         avdt_ad_tc_tbl_alloc
    258 **
    259 ** Description      Allocate an entry in the traffic channel table.
    260 **
    261 **
    262 ** Returns          Pointer to entry.
    263 **
    264 *******************************************************************************/
    265 tAVDT_TC_TBL *avdt_ad_tc_tbl_alloc(tAVDT_CCB *p_ccb)
    266 {
    267     int             i;
    268     tAVDT_TC_TBL    *p_tbl = avdt_cb.ad.tc_tbl;
    269 
    270     /* find next free entry in tc table */
    271     for (i = 0; i < AVDT_NUM_TC_TBL; i++, p_tbl++)
    272     {
    273         if (p_tbl->state == AVDT_AD_ST_UNUSED)
    274         {
    275             break;
    276         }
    277     }
    278 
    279     /* sanity check */
    280     assert(i != AVDT_NUM_TC_TBL);
    281 
    282 
    283     /* initialize entry */
    284     p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
    285     p_tbl->cfg_flags = 0;
    286     p_tbl->ccb_idx = avdt_ccb_to_idx(p_ccb);
    287     p_tbl->state = AVDT_AD_ST_IDLE;
    288     return p_tbl;
    289 
    290 }
    291 
    292 /*******************************************************************************
    293 **
    294 ** Function         avdt_ad_tc_tbl_to_idx
    295 **
    296 ** Description      Convert a transport channel table entry to an index.
    297 **
    298 **
    299 ** Returns          Index value.
    300 **
    301 *******************************************************************************/
    302 UINT8 avdt_ad_tc_tbl_to_idx(tAVDT_TC_TBL *p_tbl)
    303 {
    304     AVDT_TRACE_DEBUG("avdt_ad_tc_tbl_to_idx: %d", (p_tbl - avdt_cb.ad.tc_tbl));
    305     /* use array arithmetic to determine index */
    306     return (UINT8) (p_tbl - avdt_cb.ad.tc_tbl);
    307 }
    308 
    309 /*******************************************************************************
    310 **
    311 ** Function         avdt_ad_tc_close_ind
    312 **
    313 ** Description      This function is called by the L2CAP interface when the
    314 **                  L2CAP channel is closed.  It looks up the CCB or SCB for
    315 **                  the channel and sends it a close event.  The reason
    316 **                  parameter is the same value passed by the L2CAP
    317 **                  callback function.
    318 **
    319 **
    320 ** Returns          Nothing.
    321 **
    322 *******************************************************************************/
    323 void avdt_ad_tc_close_ind(tAVDT_TC_TBL *p_tbl, UINT16 reason)
    324 {
    325     tAVDT_CCB   *p_ccb;
    326     tAVDT_SCB   *p_scb;
    327     tAVDT_SCB_TC_CLOSE  close;
    328     UNUSED(reason);
    329 
    330     close.old_tc_state = p_tbl->state;
    331     /* clear avdt_ad_tc_tbl entry */
    332     p_tbl->state = AVDT_AD_ST_UNUSED;
    333     p_tbl->cfg_flags = 0;
    334     p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
    335 
    336     AVDT_TRACE_DEBUG("avdt_ad_tc_close_ind tcid: %d, old: %d",
    337         p_tbl->tcid, close.old_tc_state);
    338     /* if signaling channel, notify ccb that channel open */
    339     if (p_tbl->tcid == 0)
    340     {
    341         p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
    342         avdt_ccb_event(p_ccb, AVDT_CCB_LL_CLOSE_EVT, NULL);
    343     }
    344     /* if media or other channel, notify scb that channel close */
    345     else
    346     {
    347         /* look up scb in stream routing table by ccb, tcid */
    348         p_scb = avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
    349         if (p_scb != NULL)
    350         {
    351             close.tcid = p_tbl->tcid;
    352             close.type = avdt_ad_tcid_to_type(p_tbl->tcid);
    353             avdt_scb_event(p_scb, AVDT_SCB_TC_CLOSE_EVT, (tAVDT_SCB_EVT *)&close);
    354         }
    355     }
    356 }
    357 
    358 /*******************************************************************************
    359 **
    360 ** Function         avdt_ad_tc_open_ind
    361 **
    362 ** Description      This function is called by the L2CAP interface when
    363 **                  the L2CAP channel is opened.  It looks up the CCB or SCB
    364 **                  for the channel and sends it an open event.
    365 **
    366 **
    367 ** Returns          Nothing.
    368 **
    369 *******************************************************************************/
    370 void avdt_ad_tc_open_ind(tAVDT_TC_TBL *p_tbl)
    371 {
    372     tAVDT_CCB   *p_ccb;
    373     tAVDT_SCB   *p_scb;
    374     tAVDT_OPEN  open;
    375     tAVDT_EVT_HDR evt;
    376 
    377     p_tbl->state = AVDT_AD_ST_OPEN;
    378 
    379     /* if signaling channel, notify ccb that channel open */
    380     if (p_tbl->tcid == 0)
    381     {
    382         /* set the signal channel to use high priority within the ACL link */
    383         L2CA_SetTxPriority(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][AVDT_CHAN_SIG].lcid, L2CAP_CHNL_PRIORITY_HIGH);
    384 
    385         p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
    386         /* use err_param to indicate the role of connection.
    387          * AVDT_ACP, if ACP */
    388         evt.err_param = AVDT_INT;
    389         if(p_tbl->cfg_flags & AVDT_L2C_CFG_CONN_ACP)
    390         {
    391             evt.err_param = AVDT_ACP;
    392         }
    393         avdt_ccb_event(p_ccb, AVDT_CCB_LL_OPEN_EVT, (tAVDT_CCB_EVT *)&evt);
    394     }
    395     /* if media or other channel, notify scb that channel open */
    396     else
    397     {
    398         /* look up scb in stream routing table by ccb, tcid */
    399         p_scb = avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
    400 
    401         /* put lcid in event data */
    402         if (p_scb != NULL)
    403         {
    404             open.peer_mtu = p_tbl->peer_mtu;
    405             open.lcid = avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].lcid;
    406             open.hdr.err_code = avdt_ad_tcid_to_type(p_tbl->tcid);
    407             avdt_scb_event(p_scb, AVDT_SCB_TC_OPEN_EVT, (tAVDT_SCB_EVT *) &open);
    408         }
    409     }
    410 }
    411 
    412 
    413 /*******************************************************************************
    414 **
    415 ** Function         avdt_ad_tc_cong_ind
    416 **
    417 ** Description      This function is called by the L2CAP interface layer when
    418 **                  L2CAP calls the congestion callback.  It looks up the CCB
    419 **                  or SCB for the channel and sends it a congestion event.
    420 **                  The is_congested parameter is the same value passed by
    421 **                  the L2CAP callback function.
    422 **
    423 **
    424 ** Returns          Nothing.
    425 **
    426 *******************************************************************************/
    427 void avdt_ad_tc_cong_ind(tAVDT_TC_TBL *p_tbl, BOOLEAN is_congested)
    428 {
    429     tAVDT_CCB   *p_ccb;
    430     tAVDT_SCB   *p_scb;
    431 
    432     /* if signaling channel, notify ccb of congestion */
    433     if (p_tbl->tcid == 0)
    434     {
    435         p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
    436         avdt_ccb_event(p_ccb, AVDT_CCB_LL_CONG_EVT, (tAVDT_CCB_EVT *) &is_congested);
    437     }
    438     /* if media or other channel, notify scb that channel open */
    439     else
    440     {
    441         /* look up scb in stream routing table by ccb, tcid */
    442         p_scb = avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
    443         if (p_scb != NULL)
    444         {
    445             avdt_scb_event(p_scb, AVDT_SCB_TC_CONG_EVT, (tAVDT_SCB_EVT *) &is_congested);
    446         }
    447     }
    448 }
    449 
    450 
    451 /*******************************************************************************
    452 **
    453 ** Function         avdt_ad_tc_data_ind
    454 **
    455 ** Description      This function is called by the L2CAP interface layer when
    456 **                  incoming data is received from L2CAP.  It looks up the CCB
    457 **                  or SCB for the channel and routes the data accordingly.
    458 **
    459 **
    460 ** Returns          Nothing.
    461 **
    462 *******************************************************************************/
    463 void avdt_ad_tc_data_ind(tAVDT_TC_TBL *p_tbl, BT_HDR *p_buf)
    464 {
    465     tAVDT_CCB   *p_ccb;
    466     tAVDT_SCB   *p_scb;
    467 
    468     /* store type (media, recovery, reporting) */
    469     p_buf->layer_specific = avdt_ad_tcid_to_type(p_tbl->tcid);
    470 
    471 
    472     /* if signaling channel, handle control message */
    473     if (p_tbl->tcid == 0)
    474     {
    475         p_ccb = avdt_ccb_by_idx(p_tbl->ccb_idx);
    476         avdt_msg_ind(p_ccb, p_buf);
    477     }
    478     /* if media or other channel, send event to scb */
    479     else
    480     {
    481         p_scb = avdt_scb_by_hdl(avdt_cb.ad.rt_tbl[p_tbl->ccb_idx][p_tbl->tcid].scb_hdl);
    482         if (p_scb != NULL)
    483         {
    484             avdt_scb_event(p_scb, AVDT_SCB_TC_DATA_EVT, (tAVDT_SCB_EVT *) &p_buf);
    485         }
    486         else
    487         {
    488             osi_free(p_buf);
    489             AVDT_TRACE_ERROR(" avdt_ad_tc_data_ind buffer freed");
    490         }
    491     }
    492 }
    493 
    494 /*******************************************************************************
    495 **
    496 ** Function         avdt_ad_write_req
    497 **
    498 ** Description      This function is called by a CCB or SCB to send data to a
    499 **                  transport channel.  It looks up the LCID of the channel
    500 **                  based on the type, CCB, and SCB (if present).  Then it
    501 **                  passes the data to L2CA_DataWrite().
    502 **
    503 **
    504 ** Returns          AVDT_AD_SUCCESS, if data accepted, else FALSE
    505 **                  AVDT_AD_CONGESTED, if data accepted and the channel is congested
    506 **                  AVDT_AD_FAILED, if error
    507 **
    508 *******************************************************************************/
    509 UINT8 avdt_ad_write_req(UINT8 type, tAVDT_CCB *p_ccb, tAVDT_SCB *p_scb, BT_HDR *p_buf)
    510 {
    511     UINT8   tcid;
    512 
    513     /* get tcid from type, scb */
    514     tcid = avdt_ad_type_to_tcid(type, p_scb);
    515 
    516 
    517     return L2CA_DataWrite(avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid, p_buf);
    518 }
    519 
    520 
    521 /*******************************************************************************
    522 **
    523 ** Function         avdt_ad_open_req
    524 **
    525 ** Description      This function is called by a CCB or SCB to open a transport
    526 **                  channel.  This function allocates and initializes a
    527 **                  transport channel table entry.  The channel can be opened
    528 **                  in two roles:  as an initiator or acceptor.  When opened
    529 **                  as an initiator the function will start an L2CAP connection.
    530 **                  When opened as an acceptor the function simply configures
    531 **                  the table entry to listen for an incoming channel.
    532 **
    533 **
    534 ** Returns          Nothing.
    535 **
    536 *******************************************************************************/
    537 void avdt_ad_open_req(UINT8 type, tAVDT_CCB *p_ccb, tAVDT_SCB *p_scb, UINT8 role)
    538 {
    539     tAVDT_TC_TBL    *p_tbl;
    540     UINT16          lcid;
    541 
    542     if((p_tbl = avdt_ad_tc_tbl_alloc(p_ccb)) == NULL)
    543     {
    544         AVDT_TRACE_ERROR("avdt_ad_open_req: Cannot allocate p_tbl");
    545         return;
    546     }
    547 
    548 
    549     p_tbl->tcid = avdt_ad_type_to_tcid(type, p_scb);
    550     AVDT_TRACE_DEBUG("avdt_ad_open_req: type: %d, role: %d, tcid:%d",
    551         type, role, p_tbl->tcid);
    552 
    553     if (type == AVDT_CHAN_SIG)
    554     {
    555         /* if signaling, get mtu from registration control block */
    556         p_tbl->my_mtu = avdt_cb.rcb.ctrl_mtu;
    557         p_tbl->my_flush_to = L2CAP_DEFAULT_FLUSH_TO;
    558     }
    559     else
    560     {
    561         /* otherwise get mtu from scb */
    562         p_tbl->my_mtu = p_scb->cs.mtu;
    563         p_tbl->my_flush_to = p_scb->cs.flush_to;
    564 
    565         /* also set scb_hdl in rt_tbl */
    566         avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][p_tbl->tcid].scb_hdl = avdt_scb_to_hdl(p_scb);
    567         AVDT_TRACE_DEBUG("avdt_cb.ad.rt_tbl[%d][%d].scb_hdl = %d",
    568             avdt_ccb_to_idx(p_ccb), p_tbl->tcid,
    569             avdt_scb_to_hdl(p_scb));
    570     }
    571 
    572     /* if we're acceptor, we're done; just sit back and listen */
    573     if (role == AVDT_ACP)
    574     {
    575         p_tbl->state = AVDT_AD_ST_ACP;
    576     }
    577     /* else we're inititator, start the L2CAP connection */
    578     else
    579     {
    580         p_tbl->state = AVDT_AD_ST_CONN;
    581 
    582         /* call l2cap connect req */
    583         if ((lcid = L2CA_ConnectReq(AVDT_PSM, p_ccb->peer_addr)) != 0)
    584         {
    585             /* if connect req ok, store tcid in lcid table  */
    586             avdt_cb.ad.lcid_tbl[lcid - L2CAP_BASE_APPL_CID] = avdt_ad_tc_tbl_to_idx(p_tbl);
    587             AVDT_TRACE_DEBUG("avdt_cb.ad.lcid_tbl[%d] = %d",
    588                 (lcid - L2CAP_BASE_APPL_CID), avdt_ad_tc_tbl_to_idx(p_tbl));
    589 
    590             avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][p_tbl->tcid].lcid = lcid;
    591             AVDT_TRACE_DEBUG("avdt_cb.ad.rt_tbl[%d][%d].lcid = 0x%x",
    592                 avdt_ccb_to_idx(p_ccb), p_tbl->tcid,
    593                 lcid);
    594         }
    595         else
    596         {
    597             /* if connect req failed, call avdt_ad_tc_close_ind() */
    598             avdt_ad_tc_close_ind(p_tbl, 0);
    599         }
    600     }
    601 }
    602 
    603 /*******************************************************************************
    604 **
    605 ** Function         avdt_ad_close_req
    606 **
    607 ** Description      This function is called by a CCB or SCB to close a
    608 **                  transport channel.  The function looks up the LCID for the
    609 **                  channel and calls L2CA_DisconnectReq().
    610 **
    611 **
    612 ** Returns          Nothing.
    613 **
    614 *******************************************************************************/
    615 void avdt_ad_close_req(UINT8 type, tAVDT_CCB *p_ccb, tAVDT_SCB *p_scb)
    616 {
    617     UINT8           tcid;
    618     tAVDT_TC_TBL    *p_tbl;
    619 
    620     p_tbl = avdt_ad_tc_tbl_by_type(type, p_ccb, p_scb);
    621     AVDT_TRACE_DEBUG("avdt_ad_close_req state: %d", p_tbl->state);
    622 
    623     switch(p_tbl->state)
    624     {
    625     case AVDT_AD_ST_UNUSED:
    626         /* probably for reporting */
    627         break;
    628     case AVDT_AD_ST_ACP:
    629         /* if we're listening on this channel, send ourselves a close ind */
    630         avdt_ad_tc_close_ind(p_tbl, 0);
    631         break;
    632     default:
    633         /* get tcid from type, scb */
    634         tcid = avdt_ad_type_to_tcid(type, p_scb);
    635 
    636         /* call l2cap disconnect req */
    637         L2CA_DisconnectReq(avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][tcid].lcid);
    638     }
    639 }
    640 
    641