| /****************************************************************************** |
| * |
| * Copyright (C) 2006-2012 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| /****************************************************************************** |
| * |
| * This module contains the action functions associated with the channel |
| * control block state machine. |
| * |
| ******************************************************************************/ |
| |
| #include <string.h> |
| #include "bt_types.h" |
| #include "bt_target.h" |
| #include "bt_utils.h" |
| #include "avdt_api.h" |
| #include "avdtc_api.h" |
| #include "avdt_int.h" |
| #include "bt_common.h" |
| #include "btu.h" |
| #include "btm_api.h" |
| |
| extern fixed_queue_t *btu_general_alarm_queue; |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_clear_ccb |
| ** |
| ** Description This function clears out certain buffers, queues, and |
| ** other data elements of a ccb. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| static void avdt_ccb_clear_ccb(tAVDT_CCB *p_ccb) |
| { |
| BT_HDR *p_buf; |
| |
| /* clear certain ccb variables */ |
| p_ccb->cong = FALSE; |
| p_ccb->ret_count = 0; |
| |
| /* free message being fragmented */ |
| osi_free_and_reset((void **)&p_ccb->p_curr_msg); |
| |
| /* free message being reassembled */ |
| osi_free_and_reset((void **)&p_ccb->p_rx_msg); |
| |
| /* clear out response queue */ |
| while ((p_buf = (BT_HDR *) fixed_queue_try_dequeue(p_ccb->rsp_q)) != NULL) |
| osi_free(p_buf); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_chan_open |
| ** |
| ** Description This function calls avdt_ad_open_req() to |
| ** initiate a signaling channel connection. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_chan_open(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UNUSED(p_data); |
| |
| BTM_SetOutService(p_ccb->peer_addr, BTM_SEC_SERVICE_AVDTP, AVDT_CHAN_SIG); |
| avdt_ad_open_req(AVDT_CHAN_SIG, p_ccb, NULL, AVDT_INT); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_chan_close |
| ** |
| ** Description This function calls avdt_ad_close_req() to close a |
| ** signaling channel connection. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_chan_close(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UNUSED(p_data); |
| |
| /* close the transport channel used by this CCB */ |
| avdt_ad_close_req(AVDT_CHAN_SIG, p_ccb, NULL); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_chk_close |
| ** |
| ** Description This function checks for active streams on this CCB. |
| ** If there are none, it starts an idle timer. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_chk_close(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| int i; |
| tAVDT_SCB *p_scb = &avdt_cb.scb[0]; |
| UNUSED(p_data); |
| |
| /* see if there are any active scbs associated with this ccb */ |
| for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++) |
| { |
| if ((p_scb->allocated) && (p_scb->p_ccb == p_ccb)) |
| { |
| break; |
| } |
| } |
| |
| /* if no active scbs start idle timer */ |
| if (i == AVDT_NUM_SEPS) |
| { |
| alarm_cancel(p_ccb->ret_ccb_timer); |
| alarm_cancel(p_ccb->rsp_ccb_timer); |
| period_ms_t interval_ms = avdt_cb.rcb.idle_tout * 1000; |
| alarm_set_on_queue(p_ccb->idle_ccb_timer, interval_ms, |
| avdt_ccb_idle_ccb_timer_timeout, p_ccb, |
| btu_general_alarm_queue); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_hdl_discover_cmd |
| ** |
| ** Description This function is called when a discover command is |
| ** received from the peer. It gathers up the stream |
| ** information for all allocated streams and initiates |
| ** sending of a discover response. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_hdl_discover_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| tAVDT_SEP_INFO sep_info[AVDT_NUM_SEPS]; |
| tAVDT_SCB *p_scb = &avdt_cb.scb[0]; |
| int i; |
| |
| p_data->msg.discover_rsp.p_sep_info = sep_info; |
| p_data->msg.discover_rsp.num_seps = 0; |
| |
| /* for all allocated scbs */ |
| for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++) |
| { |
| if (p_scb->allocated) |
| { |
| /* copy sep info */ |
| sep_info[p_data->msg.discover_rsp.num_seps].in_use = p_scb->in_use; |
| sep_info[p_data->msg.discover_rsp.num_seps].seid = i + 1; |
| sep_info[p_data->msg.discover_rsp.num_seps].media_type = p_scb->cs.media_type; |
| sep_info[p_data->msg.discover_rsp.num_seps].tsep = p_scb->cs.tsep; |
| |
| p_data->msg.discover_rsp.num_seps++; |
| } |
| } |
| |
| /* send response */ |
| avdt_ccb_event(p_ccb, AVDT_CCB_API_DISCOVER_RSP_EVT, p_data); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_hdl_discover_rsp |
| ** |
| ** Description This function is called when a discover response or |
| ** reject is received from the peer. It calls the application |
| ** callback function with the results. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_hdl_discover_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| /* we're done with procedure */ |
| p_ccb->proc_busy = FALSE; |
| |
| /* call app callback with results */ |
| (*p_ccb->proc_cback)(0, p_ccb->peer_addr, AVDT_DISCOVER_CFM_EVT, |
| (tAVDT_CTRL *)(&p_data->msg.discover_rsp)); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_hdl_getcap_cmd |
| ** |
| ** Description This function is called when a get capabilities command |
| ** is received from the peer. It retrieves the stream |
| ** configuration for the requested stream and initiates |
| ** sending of a get capabilities response. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_hdl_getcap_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| tAVDT_SCB *p_scb; |
| |
| /* look up scb for seid sent to us */ |
| p_scb = avdt_scb_by_hdl(p_data->msg.single.seid); |
| |
| p_data->msg.svccap.p_cfg = &p_scb->cs.cfg; |
| |
| avdt_ccb_event(p_ccb, AVDT_CCB_API_GETCAP_RSP_EVT, p_data); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_hdl_getcap_rsp |
| ** |
| ** Description This function is called with a get capabilities response |
| ** or reject is received from the peer. It calls the |
| ** application callback function with the results. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_hdl_getcap_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| /* we're done with procedure */ |
| p_ccb->proc_busy = FALSE; |
| |
| /* call app callback with results */ |
| (*p_ccb->proc_cback)(0, p_ccb->peer_addr, AVDT_GETCAP_CFM_EVT, |
| (tAVDT_CTRL *)(&p_data->msg.svccap)); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_hdl_start_cmd |
| ** |
| ** Description This function is called when a start command is received |
| ** from the peer. It verifies that all requested streams |
| ** are in the proper state. If so, it initiates sending of |
| ** a start response. Otherwise it sends a start reject. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_hdl_start_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UINT8 err_code = 0; |
| |
| /* verify all streams in the right state */ |
| UINT8 seid = avdt_scb_verify(p_ccb, AVDT_VERIFY_START, p_data->msg.multi.seid_list, |
| p_data->msg.multi.num_seps, &err_code); |
| if (seid == 0 && err_code == 0) |
| { |
| /* we're ok, send response */ |
| avdt_ccb_event(p_ccb, AVDT_CCB_API_START_RSP_EVT, p_data); |
| } else { |
| /* not ok, send reject */ |
| p_data->msg.hdr.err_code = err_code; |
| p_data->msg.hdr.err_param = seid; |
| avdt_msg_send_rej(p_ccb, AVDT_SIG_START, &p_data->msg); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_hdl_start_rsp |
| ** |
| ** Description This function is called when a start response or reject |
| ** is received from the peer. Using the SEIDs stored in the |
| ** current command message, it sends a start response or start |
| ** reject event to each SCB associated with the command. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_hdl_start_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UINT8 event; |
| int i; |
| UINT8 *p; |
| tAVDT_SCB *p_scb; |
| |
| /* determine rsp or rej event */ |
| event = (p_data->msg.hdr.err_code == 0) ? |
| AVDT_SCB_MSG_START_RSP_EVT : AVDT_SCB_MSG_START_REJ_EVT; |
| |
| /* get to where seid's are stashed in current cmd */ |
| p = (UINT8 *)(p_ccb->p_curr_cmd + 1); |
| |
| /* little trick here; length of current command equals number of streams */ |
| for (i = 0; i < p_ccb->p_curr_cmd->len; i++) |
| { |
| if ((p_scb = avdt_scb_by_hdl(p[i])) != NULL) |
| { |
| avdt_scb_event(p_scb, event, (tAVDT_SCB_EVT *) &p_data->msg); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_hdl_suspend_cmd |
| ** |
| ** Description This function is called when a suspend command is received |
| ** from the peer. It verifies that all requested streams are |
| ** in the proper state. If so, it initiates sending of a |
| ** suspend response. Otherwise it sends a suspend reject. |
| |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_hdl_suspend_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UINT8 seid; |
| UINT8 err_code = 0; |
| |
| /* verify all streams in the right state */ |
| if ((seid = avdt_scb_verify(p_ccb, AVDT_VERIFY_SUSPEND, p_data->msg.multi.seid_list, |
| p_data->msg.multi.num_seps, &err_code)) == 0 && |
| err_code == 0) |
| { |
| /* we're ok, send response */ |
| avdt_ccb_event(p_ccb, AVDT_CCB_API_SUSPEND_RSP_EVT, p_data); |
| } |
| else |
| { |
| /* not ok, send reject */ |
| p_data->msg.hdr.err_code = err_code; |
| p_data->msg.hdr.err_param = seid; |
| avdt_msg_send_rej(p_ccb, AVDT_SIG_SUSPEND, &p_data->msg); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_hdl_suspend_rsp |
| ** |
| ** Description This function is called when a suspend response or reject |
| ** is received from the peer. Using the SEIDs stored in the |
| ** current command message, it sends a suspend response or |
| ** suspend reject event to each SCB associated with the command. |
| ** |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_hdl_suspend_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UINT8 event; |
| int i; |
| UINT8 *p; |
| tAVDT_SCB *p_scb; |
| |
| /* determine rsp or rej event */ |
| event = (p_data->msg.hdr.err_code == 0) ? |
| AVDT_SCB_MSG_SUSPEND_RSP_EVT : AVDT_SCB_MSG_SUSPEND_REJ_EVT; |
| |
| /* get to where seid's are stashed in current cmd */ |
| p = (UINT8 *)(p_ccb->p_curr_cmd + 1); |
| |
| /* little trick here; length of current command equals number of streams */ |
| for (i = 0; i < p_ccb->p_curr_cmd->len; i++) |
| { |
| if ((p_scb = avdt_scb_by_hdl(p[i])) != NULL) |
| { |
| avdt_scb_event(p_scb, event, (tAVDT_SCB_EVT *) &p_data->msg); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_discover_cmd |
| ** |
| ** Description This function is called to send a discover command to the |
| ** peer. It copies variables needed for the procedure from |
| ** the event to the CCB. It marks the CCB as busy and then |
| ** sends a discover command. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_discover_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| /* store info in ccb struct */ |
| p_ccb->p_proc_data = p_data->discover.p_sep_info; |
| p_ccb->proc_cback = p_data->discover.p_cback; |
| p_ccb->proc_param = p_data->discover.num_seps; |
| |
| /* we're busy */ |
| p_ccb->proc_busy = TRUE; |
| |
| /* build and queue discover req */ |
| avdt_msg_send_cmd(p_ccb, NULL, AVDT_SIG_DISCOVER, NULL); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_discover_rsp |
| ** |
| ** Description This function is called to send a discover response to |
| ** the peer. It takes the stream information passed in the |
| ** event and sends a discover response. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_discover_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| /* send response */ |
| avdt_msg_send_rsp(p_ccb, AVDT_SIG_DISCOVER, &p_data->msg); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_getcap_cmd |
| ** |
| ** Description This function is called to send a get capabilities command |
| ** to the peer. It copies variables needed for the procedure |
| ** from the event to the CCB. It marks the CCB as busy and |
| ** then sends a get capabilities command. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_getcap_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UINT8 sig_id = AVDT_SIG_GETCAP; |
| |
| /* store info in ccb struct */ |
| p_ccb->p_proc_data = p_data->getcap.p_cfg; |
| p_ccb->proc_cback = p_data->getcap.p_cback; |
| |
| /* we're busy */ |
| p_ccb->proc_busy = TRUE; |
| |
| /* build and queue discover req */ |
| if (p_data->msg.hdr.sig_id == AVDT_SIG_GET_ALLCAP) |
| sig_id = AVDT_SIG_GET_ALLCAP; |
| |
| avdt_msg_send_cmd(p_ccb, NULL, sig_id, (tAVDT_MSG *) &p_data->getcap.single); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_getcap_rsp |
| ** |
| ** Description This function is called to send a get capabilities response |
| ** to the peer. It takes the stream information passed in the |
| ** event and sends a get capabilities response. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_getcap_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UINT8 sig_id = AVDT_SIG_GETCAP; |
| |
| if (p_data->msg.hdr.sig_id == AVDT_SIG_GET_ALLCAP) |
| sig_id = AVDT_SIG_GET_ALLCAP; |
| |
| /* send response */ |
| avdt_msg_send_rsp(p_ccb, sig_id, &p_data->msg); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_start_cmd |
| ** |
| ** Description This function is called to send a start command to the |
| ** peer. It verifies that all requested streams are in the |
| ** proper state. If so, it sends a start command. Otherwise |
| ** send ourselves back a start reject. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_start_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| int i; |
| tAVDT_SCB *p_scb; |
| tAVDT_MSG avdt_msg; |
| UINT8 seid_list[AVDT_NUM_SEPS]; |
| |
| /* make copy of our seid list */ |
| memcpy(seid_list, p_data->msg.multi.seid_list, p_data->msg.multi.num_seps); |
| |
| /* verify all streams in the right state */ |
| if ((avdt_msg.hdr.err_param = avdt_scb_verify(p_ccb, AVDT_VERIFY_OPEN, p_data->msg.multi.seid_list, |
| p_data->msg.multi.num_seps, &avdt_msg.hdr.err_code)) == 0) |
| { |
| /* set peer seid list in messsage */ |
| avdt_scb_peer_seid_list(&p_data->msg.multi); |
| |
| /* send command */ |
| avdt_msg_send_cmd(p_ccb, seid_list, AVDT_SIG_START, &p_data->msg); |
| } |
| else |
| { |
| /* failed; send ourselves a reject for each stream */ |
| for (i = 0; i < p_data->msg.multi.num_seps; i++) |
| { |
| if ((p_scb = avdt_scb_by_hdl(seid_list[i])) != NULL) |
| { |
| avdt_scb_event(p_scb, AVDT_SCB_MSG_START_REJ_EVT, (tAVDT_SCB_EVT *) &avdt_msg.hdr); |
| } |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_start_rsp |
| ** |
| ** Description This function is called to send a start response to the |
| ** peer. It takes the stream information passed in the event |
| ** and sends a start response. Then it sends a start event |
| ** to the SCB for each stream. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_start_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| tAVDT_SCB *p_scb; |
| int i; |
| |
| /* send response message */ |
| avdt_msg_send_rsp(p_ccb, AVDT_SIG_START, &p_data->msg); |
| |
| /* send start event to each scb */ |
| for (i = 0; i < p_data->msg.multi.num_seps; i++) |
| { |
| if ((p_scb = avdt_scb_by_hdl(p_data->msg.multi.seid_list[i])) != NULL) |
| { |
| avdt_scb_event(p_scb, AVDT_SCB_MSG_START_CMD_EVT, NULL); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_suspend_cmd |
| ** |
| ** Description This function is called to send a suspend command to the |
| ** peer. It verifies that all requested streams are in the |
| ** proper state. If so, it sends a suspend command. |
| ** Otherwise it calls the callback function for each requested |
| ** stream and sends a suspend confirmation with failure. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_suspend_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| int i; |
| tAVDT_SCB *p_scb; |
| tAVDT_MSG avdt_msg; |
| UINT8 seid_list[AVDT_NUM_SEPS]; |
| |
| /* make copy of our seid list */ |
| memcpy(seid_list, p_data->msg.multi.seid_list, p_data->msg.multi.num_seps); |
| |
| /* verify all streams in the right state */ |
| if ((avdt_msg.hdr.err_param = avdt_scb_verify(p_ccb, AVDT_VERIFY_STREAMING, p_data->msg.multi.seid_list, |
| p_data->msg.multi.num_seps, &avdt_msg.hdr.err_code)) == 0) |
| { |
| /* set peer seid list in messsage */ |
| avdt_scb_peer_seid_list(&p_data->msg.multi); |
| |
| /* send command */ |
| avdt_msg_send_cmd(p_ccb, seid_list, AVDT_SIG_SUSPEND, &p_data->msg); |
| } |
| else |
| { |
| /* failed; send ourselves a reject for each stream */ |
| for (i = 0; i < p_data->msg.multi.num_seps; i++) |
| { |
| if ((p_scb = avdt_scb_by_hdl(seid_list[i])) != NULL) |
| { |
| avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_REJ_EVT, (tAVDT_SCB_EVT *) &avdt_msg.hdr); |
| } |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_suspend_rsp |
| ** |
| ** Description This function is called to send a suspend response to the |
| ** peer. It takes the stream information passed in the event |
| ** and sends a suspend response. Then it sends a suspend event |
| ** to the SCB for each stream. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_suspend_rsp(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| tAVDT_SCB *p_scb; |
| int i; |
| |
| /* send response message */ |
| avdt_msg_send_rsp(p_ccb, AVDT_SIG_SUSPEND, &p_data->msg); |
| |
| /* send start event to each scb */ |
| for (i = 0; i < p_data->msg.multi.num_seps; i++) |
| { |
| if ((p_scb = avdt_scb_by_hdl(p_data->msg.multi.seid_list[i])) != NULL) |
| { |
| avdt_scb_event(p_scb, AVDT_SCB_MSG_SUSPEND_CMD_EVT, NULL); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_clear_cmds |
| ** |
| ** Description This function is called when the signaling channel is |
| ** closed to clean up any pending commands. For each pending |
| ** command in the command queue, it frees the command and |
| ** calls the application callback function indicating failure. |
| ** Certain CCB variables are also initialized. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_clear_cmds(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| int i; |
| tAVDT_SCB *p_scb = &avdt_cb.scb[0]; |
| UINT8 err_code = AVDT_ERR_CONNECT; |
| UNUSED(p_data); |
| |
| /* clear the ccb */ |
| avdt_ccb_clear_ccb(p_ccb); |
| |
| /* clear out command queue; this is a little tricky here; we need |
| ** to handle the case where there is a command on deck in p_curr_cmd, |
| ** plus we need to clear out the queue |
| */ |
| do |
| { |
| /* we know p_curr_cmd = NULL after this */ |
| avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT *) &err_code); |
| |
| /* set up next message */ |
| p_ccb->p_curr_cmd = (BT_HDR *) fixed_queue_try_dequeue(p_ccb->cmd_q); |
| |
| } while (p_ccb->p_curr_cmd != NULL); |
| |
| /* send a CC_CLOSE_EVT any active scbs associated with this ccb */ |
| for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++) |
| { |
| if ((p_scb->allocated) && (p_scb->p_ccb == p_ccb)) |
| { |
| avdt_scb_event(p_scb, AVDT_SCB_CC_CLOSE_EVT, NULL); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_cmd_fail |
| ** |
| ** Description This function is called when there is a response timeout. |
| ** The currently pending command is freed and we fake a |
| ** reject message back to ourselves. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_cmd_fail(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| tAVDT_MSG msg; |
| UINT8 evt; |
| tAVDT_SCB *p_scb; |
| |
| if (p_ccb->p_curr_cmd != NULL) |
| { |
| /* set up data */ |
| msg.hdr.err_code = p_data->err_code; |
| msg.hdr.err_param = 0; |
| msg.hdr.ccb_idx = avdt_ccb_to_idx(p_ccb); |
| |
| /* pretend that we received a rej message */ |
| evt = avdt_msg_rej_2_evt[p_ccb->p_curr_cmd->event - 1]; |
| |
| if (evt & AVDT_CCB_MKR) |
| { |
| avdt_ccb_event(p_ccb, (UINT8) (evt & ~AVDT_CCB_MKR), (tAVDT_CCB_EVT *) &msg); |
| } |
| else |
| { |
| /* we get the scb out of the current cmd */ |
| p_scb = avdt_scb_by_hdl(*((UINT8 *)(p_ccb->p_curr_cmd + 1))); |
| if (p_scb != NULL) |
| { |
| avdt_scb_event(p_scb, evt, (tAVDT_SCB_EVT *) &msg); |
| } |
| } |
| |
| osi_free_and_reset((void **)&p_ccb->p_curr_cmd); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_free_cmd |
| ** |
| ** Description This function is called when a response is received for a |
| ** currently pending command. The command is freed. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_free_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UNUSED(p_data); |
| osi_free_and_reset((void **)&p_ccb->p_curr_cmd); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_cong_state |
| ** |
| ** Description This function is called to set the congestion state for |
| ** the CCB. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_cong_state(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| p_ccb->cong = p_data->llcong; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_ret_cmd |
| ** |
| ** Description This function is called to retransmit the currently |
| ** pending command. The retransmission count is incremented. |
| ** If the count reaches the maximum number of retransmissions, |
| ** the event is treated as a response timeout. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_ret_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UINT8 err_code = AVDT_ERR_TIMEOUT; |
| |
| p_ccb->ret_count++; |
| if (p_ccb->ret_count == AVDT_RET_MAX) |
| { |
| /* command failed */ |
| p_ccb->ret_count = 0; |
| avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT *) &err_code); |
| |
| /* go to next queued command */ |
| avdt_ccb_snd_cmd(p_ccb, p_data); |
| } |
| else |
| { |
| /* if command pending and we're not congested and not sending a fragment */ |
| if ((!p_ccb->cong) && (p_ccb->p_curr_msg == NULL) && (p_ccb->p_curr_cmd != NULL)) |
| { |
| /* make copy of message in p_curr_cmd and send it */ |
| BT_HDR *p_msg = (BT_HDR *)osi_malloc(AVDT_CMD_BUF_SIZE); |
| memcpy(p_msg, p_ccb->p_curr_cmd, |
| (sizeof(BT_HDR) + p_ccb->p_curr_cmd->offset + p_ccb->p_curr_cmd->len)); |
| avdt_msg_send(p_ccb, p_msg); |
| } |
| |
| /* restart ret timer */ |
| alarm_cancel(p_ccb->idle_ccb_timer); |
| alarm_cancel(p_ccb->rsp_ccb_timer); |
| period_ms_t interval_ms = avdt_cb.rcb.ret_tout * 1000; |
| alarm_set_on_queue(p_ccb->ret_ccb_timer, interval_ms, |
| avdt_ccb_ret_ccb_timer_timeout, p_ccb, |
| btu_general_alarm_queue); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_cmd |
| ** |
| ** Description This function is called the send the next command, |
| ** if any, in the command queue. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_cmd(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| BT_HDR *p_msg; |
| UNUSED(p_data); |
| |
| /* do we have commands to send? send next command; make sure we're clear; |
| ** not congested, not sending fragment, not waiting for response |
| */ |
| if ((!p_ccb->cong) && (p_ccb->p_curr_msg == NULL) && (p_ccb->p_curr_cmd == NULL)) |
| { |
| if ((p_msg = (BT_HDR *) fixed_queue_try_dequeue(p_ccb->cmd_q)) != NULL) |
| { |
| /* make a copy of buffer in p_curr_cmd */ |
| p_ccb->p_curr_cmd = (BT_HDR *)osi_malloc(AVDT_CMD_BUF_SIZE); |
| memcpy(p_ccb->p_curr_cmd, p_msg, |
| (sizeof(BT_HDR) + p_msg->offset + p_msg->len)); |
| avdt_msg_send(p_ccb, p_msg); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_snd_msg |
| ** |
| ** Description |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_snd_msg(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| BT_HDR *p_msg; |
| UNUSED(p_data); |
| |
| /* if not congested */ |
| if (!p_ccb->cong) |
| { |
| /* are we sending a fragmented message? continue sending fragment */ |
| if (p_ccb->p_curr_msg != NULL) |
| { |
| avdt_msg_send(p_ccb, NULL); |
| } |
| /* do we have responses to send? send them */ |
| else if (!fixed_queue_is_empty(p_ccb->rsp_q)) |
| { |
| while ((p_msg = (BT_HDR *)fixed_queue_try_dequeue(p_ccb->rsp_q)) != NULL) |
| { |
| if (avdt_msg_send(p_ccb, p_msg) == TRUE) |
| { |
| /* break out if congested */ |
| break; |
| } |
| } |
| } |
| |
| /* do we have commands to send? send next command */ |
| avdt_ccb_snd_cmd(p_ccb, NULL); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_set_reconn |
| ** |
| ** Description This function is called to enable a reconnect attempt when |
| ** a channel transitions from closing to idle state. It sets |
| ** the reconn variable to TRUE. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_set_reconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UNUSED(p_data); |
| |
| p_ccb->reconn = TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_clr_reconn |
| ** |
| ** Description This function is called to clear the reconn variable. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_clr_reconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UNUSED(p_data); |
| |
| p_ccb->reconn = FALSE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_chk_reconn |
| ** |
| ** Description This function is called to check if a reconnect attempt |
| ** is enabled. If enabled, it sends an AVDT_CCB_UL_OPEN_EVT |
| ** to the CCB. If disabled, the CCB is deallocated. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_chk_reconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UINT8 err_code = AVDT_ERR_CONNECT; |
| UNUSED(p_data); |
| |
| if (p_ccb->reconn) |
| { |
| p_ccb->reconn = FALSE; |
| |
| /* clear out ccb */ |
| avdt_ccb_clear_ccb(p_ccb); |
| |
| /* clear out current command, if any */ |
| avdt_ccb_cmd_fail(p_ccb, (tAVDT_CCB_EVT *) &err_code); |
| |
| /* reopen the signaling channel */ |
| avdt_ccb_event(p_ccb, AVDT_CCB_UL_OPEN_EVT, NULL); |
| } |
| else |
| { |
| avdt_ccb_ll_closed(p_ccb, NULL); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_chk_timer |
| ** |
| ** Description This function stops the CCB timer if the idle timer is |
| ** running. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_chk_timer(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UNUSED(p_data); |
| |
| alarm_cancel(p_ccb->idle_ccb_timer); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_set_conn |
| ** |
| ** Description Set CCB variables associated with AVDT_ConnectReq(). |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_set_conn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| /* save callback */ |
| p_ccb->p_conn_cback = p_data->connect.p_cback; |
| |
| /* set security level */ |
| BTM_SetSecurityLevel(TRUE, "", BTM_SEC_SERVICE_AVDTP, p_data->connect.sec_mask, |
| AVDT_PSM, BTM_SEC_PROTO_AVDT, AVDT_CHAN_SIG); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_set_disconn |
| ** |
| ** Description Set CCB variables associated with AVDT_DisconnectReq(). |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_set_disconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| /* |
| AVDT_TRACE_EVENT("avdt_ccb_set_disconn:conn:x%x, api:x%x", |
| p_ccb->p_conn_cback, p_data->disconnect.p_cback); |
| */ |
| /* save callback */ |
| if (p_data->disconnect.p_cback) |
| p_ccb->p_conn_cback = p_data->disconnect.p_cback; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_do_disconn |
| ** |
| ** Description Do action associated with AVDT_DisconnectReq(). |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_do_disconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| UNUSED(p_data); |
| |
| /* clear any pending commands */ |
| avdt_ccb_clear_cmds(p_ccb, NULL); |
| |
| /* close channel */ |
| avdt_ccb_chan_close(p_ccb, NULL); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_ll_closed |
| ** |
| ** Description Clear commands from and deallocate CCB. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_ll_closed(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| tAVDT_CTRL_CBACK *p_cback; |
| BD_ADDR bd_addr; |
| tAVDT_CTRL avdt_ctrl; |
| UNUSED(p_data); |
| |
| /* clear any pending commands */ |
| avdt_ccb_clear_cmds(p_ccb, NULL); |
| |
| /* save callback pointer, bd addr */ |
| p_cback = p_ccb->p_conn_cback; |
| if (!p_cback) |
| p_cback = avdt_cb.p_conn_cback; |
| memcpy(bd_addr, p_ccb->peer_addr, BD_ADDR_LEN); |
| |
| /* dealloc ccb */ |
| avdt_ccb_dealloc(p_ccb, NULL); |
| |
| /* call callback */ |
| if (p_cback) |
| { |
| avdt_ctrl.hdr.err_code = 0; |
| (*p_cback)(0, bd_addr, AVDT_DISCONNECT_IND_EVT, &avdt_ctrl); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function avdt_ccb_ll_opened |
| ** |
| ** Description Call callback on open. |
| ** |
| ** |
| ** Returns void. |
| ** |
| *******************************************************************************/ |
| void avdt_ccb_ll_opened(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data) |
| { |
| tAVDT_CTRL avdt_ctrl; |
| |
| p_ccb->ll_opened = TRUE; |
| |
| if (!p_ccb->p_conn_cback) |
| p_ccb->p_conn_cback = avdt_cb.p_conn_cback; |
| |
| /* call callback */ |
| if (p_ccb->p_conn_cback) |
| { |
| avdt_ctrl.hdr.err_code = 0; |
| avdt_ctrl.hdr.err_param = p_data->msg.hdr.err_param; |
| (*p_ccb->p_conn_cback)(0, p_ccb->peer_addr, AVDT_CONNECT_IND_EVT, &avdt_ctrl); |
| } |
| } |
