1 /******************************************************************************
2 *
3 * Copyright (C) 2003-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 * Interface to AVRCP mandatory commands
22 *
23 ******************************************************************************/
24 #include <assert.h>
25 #include <string.h>
26
27 #include "bt_common.h"
28 #include "avrc_api.h"
29 #include "avrc_int.h"
30
31 /*****************************************************************************
32 ** Global data
33 *****************************************************************************/
34
35
36 #define AVRC_MAX_RCV_CTRL_EVT AVCT_BROWSE_UNCONG_IND_EVT
37
38 #ifndef MAX
39 #define MAX(a, b) ((a) > (b) ? (a) : (b))
40 #endif
41
42 static const UINT8 avrc_ctrl_event_map[] =
43 {
44 AVRC_OPEN_IND_EVT, /* AVCT_CONNECT_CFM_EVT */
45 AVRC_OPEN_IND_EVT, /* AVCT_CONNECT_IND_EVT */
46 AVRC_CLOSE_IND_EVT, /* AVCT_DISCONNECT_CFM_EVT */
47 AVRC_CLOSE_IND_EVT, /* AVCT_DISCONNECT_IND_EVT */
48 AVRC_CONG_IND_EVT, /* AVCT_CONG_IND_EVT */
49 AVRC_UNCONG_IND_EVT,/* AVCT_UNCONG_IND_EVT */
50 AVRC_BROWSE_OPEN_IND_EVT, /* AVCT_BROWSE_CONN_CFM_EVT */
51 AVRC_BROWSE_OPEN_IND_EVT, /* AVCT_BROWSE_CONN_IND_EVT */
52 AVRC_BROWSE_CLOSE_IND_EVT, /* AVCT_BROWSE_DISCONN_CFM_EVT */
53 AVRC_BROWSE_CLOSE_IND_EVT, /* AVCT_BROWSE_DISCONN_IND_EVT */
54 AVRC_BROWSE_CONG_IND_EVT, /* AVCT_BROWSE_CONG_IND_EVT */
55 AVRC_BROWSE_UNCONG_IND_EVT /* AVCT_BROWSE_UNCONG_IND_EVT */
56 };
57
58 #define AVRC_OP_DROP 0xFE /* use this unused opcode to indication no need to call the callback function */
59 #define AVRC_OP_DROP_N_FREE 0xFD /* use this unused opcode to indication no need to call the callback function & free buffer */
60
61 #define AVRC_OP_UNIT_INFO_RSP_LEN 8
62 #define AVRC_OP_SUB_UNIT_INFO_RSP_LEN 8
63 #define AVRC_OP_REJ_MSG_LEN 11
64
65 /******************************************************************************
66 **
67 ** Function avrc_ctrl_cback
68 **
69 ** Description This is the callback function used by AVCTP to report
70 ** received link events.
71 **
72 ** Returns Nothing.
73 **
74 ******************************************************************************/
avrc_ctrl_cback(UINT8 handle,UINT8 event,UINT16 result,BD_ADDR peer_addr)75 static void avrc_ctrl_cback(UINT8 handle, UINT8 event, UINT16 result,
76 BD_ADDR peer_addr)
77 {
78 UINT8 avrc_event;
79
80 if (event <= AVRC_MAX_RCV_CTRL_EVT && avrc_cb.ccb[handle].p_ctrl_cback)
81 {
82 avrc_event = avrc_ctrl_event_map[event];
83 if (event == AVCT_CONNECT_CFM_EVT)
84 {
85 if (result != 0) /* failed */
86 avrc_event = AVRC_CLOSE_IND_EVT;
87 }
88 (*avrc_cb.ccb[handle].p_ctrl_cback)(handle, avrc_event, result, peer_addr);
89 }
90 /* else drop the unknown event*/
91 }
92
93 /******************************************************************************
94 **
95 ** Function avrc_get_data_ptr
96 **
97 ** Description Gets a pointer to the data payload in the packet.
98 **
99 ** Returns A pointer to the data payload.
100 **
101 ******************************************************************************/
avrc_get_data_ptr(BT_HDR * p_pkt)102 static UINT8 * avrc_get_data_ptr(BT_HDR *p_pkt)
103 {
104 return (UINT8 *)(p_pkt + 1) + p_pkt->offset;
105 }
106
107 /******************************************************************************
108 **
109 ** Function avrc_copy_packet
110 **
111 ** Description Copies an AVRC packet to a new buffer. In the new buffer,
112 ** the payload offset is at least AVCT_MSG_OFFSET octets.
113 **
114 ** Returns The buffer with the copied data.
115 **
116 ******************************************************************************/
avrc_copy_packet(BT_HDR * p_pkt,int rsp_pkt_len)117 static BT_HDR * avrc_copy_packet(BT_HDR *p_pkt, int rsp_pkt_len)
118 {
119 const int offset = MAX(AVCT_MSG_OFFSET, p_pkt->offset);
120 const int pkt_len = MAX(rsp_pkt_len, p_pkt->len);
121 BT_HDR *p_pkt_copy = (BT_HDR *)osi_malloc(BT_HDR_SIZE + offset + pkt_len);
122
123 /* Copy the packet header, set the new offset, and copy the payload */
124 memcpy(p_pkt_copy, p_pkt, BT_HDR_SIZE);
125 p_pkt_copy->offset = offset;
126 UINT8 *p_data = avrc_get_data_ptr(p_pkt);
127 UINT8 *p_data_copy = avrc_get_data_ptr(p_pkt_copy);
128 memcpy(p_data_copy, p_data, p_pkt->len);
129
130 return p_pkt_copy;
131 }
132
133 #if (AVRC_METADATA_INCLUDED == TRUE)
134 /******************************************************************************
135 **
136 ** Function avrc_prep_end_frag
137 **
138 ** Description This function prepares an end response fragment
139 **
140 ** Returns Nothing.
141 **
142 ******************************************************************************/
avrc_prep_end_frag(UINT8 handle)143 static void avrc_prep_end_frag(UINT8 handle)
144 {
145 tAVRC_FRAG_CB *p_fcb;
146 BT_HDR *p_pkt_new;
147 UINT8 *p_data, *p_orig_data;
148 UINT8 rsp_type;
149
150 AVRC_TRACE_DEBUG ("avrc_prep_end_frag" );
151 p_fcb = &avrc_cb.fcb[handle];
152
153 /* The response type of the end fragment should be the same as the the PDU of "End Fragment
154 ** Response" Errata: https://www.bluetooth.org/errata/errata_view.cfm?errata_id=4383
155 */
156 p_orig_data = ((UINT8 *)(p_fcb->p_fmsg + 1) + p_fcb->p_fmsg->offset);
157 rsp_type = ((*p_orig_data) & AVRC_CTYPE_MASK);
158
159 p_pkt_new = p_fcb->p_fmsg;
160 p_pkt_new->len -= (AVRC_MAX_CTRL_DATA_LEN - AVRC_VENDOR_HDR_SIZE - AVRC_MIN_META_HDR_SIZE);
161 p_pkt_new->offset += (AVRC_MAX_CTRL_DATA_LEN - AVRC_VENDOR_HDR_SIZE - AVRC_MIN_META_HDR_SIZE);
162 p_data = (UINT8 *)(p_pkt_new+1) + p_pkt_new->offset;
163 *p_data++ = rsp_type;
164 *p_data++ = (AVRC_SUB_PANEL << AVRC_SUBTYPE_SHIFT);
165 *p_data++ = AVRC_OP_VENDOR;
166 AVRC_CO_ID_TO_BE_STREAM(p_data, AVRC_CO_METADATA);
167 *p_data++ = p_fcb->frag_pdu;
168 *p_data++ = AVRC_PKT_END;
169
170 /* 4=pdu, pkt_type & len */
171 UINT16_TO_BE_STREAM(p_data, (p_pkt_new->len - AVRC_VENDOR_HDR_SIZE - AVRC_MIN_META_HDR_SIZE));
172 }
173
174 /******************************************************************************
175 **
176 ** Function avrc_send_continue_frag
177 **
178 ** Description This function sends a continue response fragment
179 **
180 ** Returns Nothing.
181 **
182 ******************************************************************************/
avrc_send_continue_frag(UINT8 handle,UINT8 label)183 static void avrc_send_continue_frag(UINT8 handle, UINT8 label)
184 {
185 tAVRC_FRAG_CB *p_fcb;
186 BT_HDR *p_pkt_old, *p_pkt;
187 UINT8 *p_old, *p_data;
188 UINT8 cr = AVCT_RSP;
189
190 p_fcb = &avrc_cb.fcb[handle];
191 p_pkt = p_fcb->p_fmsg;
192
193 AVRC_TRACE_DEBUG("%s handle = %u label = %u len = %d",
194 __func__, handle, label, p_pkt->len);
195 if (p_pkt->len > AVRC_MAX_CTRL_DATA_LEN) {
196 int offset_len = MAX(AVCT_MSG_OFFSET, p_pkt->offset);
197 p_pkt_old = p_fcb->p_fmsg;
198 p_pkt = (BT_HDR *)osi_malloc(AVRC_PACKET_LEN + offset_len + BT_HDR_SIZE);
199 p_pkt->len = AVRC_MAX_CTRL_DATA_LEN;
200 p_pkt->offset = AVCT_MSG_OFFSET;
201 p_pkt->layer_specific = p_pkt_old->layer_specific;
202 p_pkt->event = p_pkt_old->event;
203 p_old = (UINT8 *)(p_pkt_old + 1) + p_pkt_old->offset;
204 p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
205 memcpy (p_data, p_old, AVRC_MAX_CTRL_DATA_LEN);
206 /* use AVRC continue packet type */
207 p_data += AVRC_VENDOR_HDR_SIZE;
208 p_data++; /* pdu */
209 *p_data++ = AVRC_PKT_CONTINUE;
210 /* 4=pdu, pkt_type & len */
211 UINT16_TO_BE_STREAM(p_data, (AVRC_MAX_CTRL_DATA_LEN - AVRC_VENDOR_HDR_SIZE - 4));
212
213 /* prepare the left over for as an end fragment */
214 avrc_prep_end_frag (handle);
215 } else {
216 /* end fragment. clean the control block */
217 p_fcb->frag_enabled = FALSE;
218 p_fcb->p_fmsg = NULL;
219 }
220 AVCT_MsgReq( handle, label, cr, p_pkt);
221 }
222
223 /******************************************************************************
224 **
225 ** Function avrc_proc_vendor_command
226 **
227 ** Description This function processes received vendor command.
228 **
229 ** Returns if not NULL, the response to send right away.
230 **
231 ******************************************************************************/
avrc_proc_vendor_command(UINT8 handle,UINT8 label,BT_HDR * p_pkt,tAVRC_MSG_VENDOR * p_msg)232 static BT_HDR * avrc_proc_vendor_command(UINT8 handle, UINT8 label,
233 BT_HDR *p_pkt, tAVRC_MSG_VENDOR *p_msg)
234 {
235 BT_HDR *p_rsp = NULL;
236 UINT8 *p_data;
237 UINT8 *p_begin;
238 UINT8 pkt_type;
239 BOOLEAN abort_frag = FALSE;
240 tAVRC_STS status = AVRC_STS_NO_ERROR;
241 tAVRC_FRAG_CB *p_fcb;
242
243 p_begin = (UINT8 *)(p_pkt+1) + p_pkt->offset;
244 p_data = p_begin + AVRC_VENDOR_HDR_SIZE;
245 pkt_type = *(p_data + 1) & AVRC_PKT_TYPE_MASK;
246
247 if (pkt_type != AVRC_PKT_SINGLE)
248 {
249 /* reject - commands can only be in single packets at AVRCP level */
250 AVRC_TRACE_ERROR ("commands must be in single packet pdu:0x%x", *p_data );
251 /* use the current GKI buffer to send the reject */
252 status = AVRC_STS_BAD_CMD;
253 }
254 /* check if there are fragments waiting to be sent */
255 else if (avrc_cb.fcb[handle].frag_enabled)
256 {
257 p_fcb = &avrc_cb.fcb[handle];
258 if (p_msg->company_id == AVRC_CO_METADATA)
259 {
260 switch (*p_data)
261 {
262 case AVRC_PDU_ABORT_CONTINUATION_RSP:
263 /* aborted by CT - send accept response */
264 abort_frag = TRUE;
265 p_begin = (UINT8 *)(p_pkt+1) + p_pkt->offset;
266 *p_begin = (AVRC_RSP_ACCEPT & AVRC_CTYPE_MASK);
267 if (*(p_data + 4) != p_fcb->frag_pdu)
268 {
269 *p_begin = (AVRC_RSP_REJ & AVRC_CTYPE_MASK);
270 *(p_data + 4) = AVRC_STS_BAD_PARAM;
271 }
272 else
273 {
274 p_data = (p_begin + AVRC_VENDOR_HDR_SIZE + 2);
275 UINT16_TO_BE_STREAM(p_data, 0);
276 p_pkt->len = (p_data - p_begin);
277 }
278 AVCT_MsgReq( handle, label, AVCT_RSP, p_pkt);
279 p_msg->hdr.opcode = AVRC_OP_DROP; /* used the p_pkt to send response */
280 break;
281
282 case AVRC_PDU_REQUEST_CONTINUATION_RSP:
283 if (*(p_data + 4) == p_fcb->frag_pdu)
284 {
285 avrc_send_continue_frag(handle, label);
286 p_msg->hdr.opcode = AVRC_OP_DROP_N_FREE;
287 }
288 else
289 {
290 /* the pdu id does not match - reject the command using the current GKI buffer */
291 AVRC_TRACE_ERROR("avrc_proc_vendor_command continue pdu: 0x%x does not match \
292 current re-assembly pdu: 0x%x",
293 *(p_data + 4), p_fcb->frag_pdu);
294 status = AVRC_STS_BAD_PARAM;
295 abort_frag = TRUE;
296 }
297 break;
298
299 default:
300 /* implicit abort */
301 abort_frag = TRUE;
302 }
303 }
304 else
305 {
306 abort_frag = TRUE;
307 /* implicit abort */
308 }
309
310 if (abort_frag)
311 {
312 osi_free_and_reset((void **)&p_fcb->p_fmsg);
313 p_fcb->frag_enabled = FALSE;
314 }
315 }
316
317 if (status != AVRC_STS_NO_ERROR)
318 {
319 /* use the current GKI buffer to build/send the reject message */
320 p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
321 *p_data++ = AVRC_RSP_REJ;
322 p_data += AVRC_VENDOR_HDR_SIZE; /* pdu */
323 *p_data++ = 0; /* pkt_type */
324 UINT16_TO_BE_STREAM(p_data, 1); /* len */
325 *p_data++ = status; /* error code */
326 p_pkt->len = AVRC_VENDOR_HDR_SIZE + 5;
327 p_rsp = p_pkt;
328 }
329
330 return p_rsp;
331 }
332
333 /******************************************************************************
334 **
335 ** Function avrc_proc_far_msg
336 **
337 ** Description This function processes metadata fragmenation
338 ** and reassembly
339 **
340 ** Returns 0, to report the message with msg_cback .
341 **
342 ******************************************************************************/
avrc_proc_far_msg(UINT8 handle,UINT8 label,UINT8 cr,BT_HDR ** pp_pkt,tAVRC_MSG_VENDOR * p_msg)343 static UINT8 avrc_proc_far_msg(UINT8 handle, UINT8 label, UINT8 cr, BT_HDR **pp_pkt,
344 tAVRC_MSG_VENDOR *p_msg)
345 {
346 BT_HDR *p_pkt = *pp_pkt;
347 UINT8 *p_data;
348 UINT8 drop_code = 0;
349 BOOLEAN buf_overflow = FALSE;
350 BT_HDR *p_rsp = NULL;
351 BT_HDR *p_cmd = NULL;
352 BOOLEAN req_continue = FALSE;
353 BT_HDR *p_pkt_new = NULL;
354 UINT8 pkt_type;
355 tAVRC_RASM_CB *p_rcb;
356 tAVRC_NEXT_CMD avrc_cmd;
357
358 p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
359
360 /* Skip over vendor header (ctype, subunit*, opcode, CO_ID) */
361 p_data += AVRC_VENDOR_HDR_SIZE;
362
363 pkt_type = *(p_data + 1) & AVRC_PKT_TYPE_MASK;
364 AVRC_TRACE_DEBUG ("pkt_type %d", pkt_type );
365 p_rcb = &avrc_cb.rcb[handle];
366 if (p_msg->company_id == AVRC_CO_METADATA)
367 {
368 /* check if the message needs to be re-assembled */
369 if (pkt_type == AVRC_PKT_SINGLE || pkt_type == AVRC_PKT_START)
370 {
371 /* previous fragments need to be dropped, when received another new message */
372 p_rcb->rasm_offset = 0;
373 osi_free_and_reset((void **)&p_rcb->p_rmsg);
374 }
375
376 if (pkt_type != AVRC_PKT_SINGLE && cr == AVCT_RSP)
377 {
378 /* not a single response packet - need to re-assemble metadata messages */
379 if (pkt_type == AVRC_PKT_START) {
380 /* Allocate buffer for re-assembly */
381 p_rcb->rasm_pdu = *p_data;
382 p_rcb->p_rmsg = (BT_HDR *)osi_malloc(BT_DEFAULT_BUFFER_SIZE);
383 /* Copy START packet to buffer for re-assembling fragments */
384 memcpy(p_rcb->p_rmsg, p_pkt, sizeof(BT_HDR)); /* Copy bt hdr */
385
386 /* Copy metadata message */
387 memcpy((UINT8 *)(p_rcb->p_rmsg + 1),
388 (UINT8 *)(p_pkt+1) + p_pkt->offset, p_pkt->len);
389
390 /* offset of start of metadata response in reassembly buffer */
391 p_rcb->p_rmsg->offset = p_rcb->rasm_offset = 0;
392
393 /*
394 * Free original START packet, replace with pointer to
395 * reassembly buffer.
396 */
397 osi_free(p_pkt);
398 *pp_pkt = p_rcb->p_rmsg;
399
400 /*
401 * Set offset to point to where to copy next - use the same
402 * reassembly logic as AVCT.
403 */
404 p_rcb->p_rmsg->offset += p_rcb->p_rmsg->len;
405 req_continue = TRUE;
406 } else if (p_rcb->p_rmsg == NULL) {
407 /* Received a CONTINUE/END, but no corresponding START
408 (or previous fragmented response was dropped) */
409 AVRC_TRACE_DEBUG ("Received a CONTINUE/END without no corresponding START \
410 (or previous fragmented response was dropped)");
411 drop_code = 5;
412 osi_free(p_pkt);
413 *pp_pkt = NULL;
414 }
415 else
416 {
417 /* get size of buffer holding assembled message */
418 /*
419 * NOTE: The buffer is allocated above at the beginning of the
420 * reassembly, and is always of size BT_DEFAULT_BUFFER_SIZE.
421 */
422 UINT16 buf_len = BT_DEFAULT_BUFFER_SIZE - sizeof(BT_HDR);
423 /* adjust offset and len of fragment for header byte */
424 p_pkt->offset += (AVRC_VENDOR_HDR_SIZE + AVRC_MIN_META_HDR_SIZE);
425 p_pkt->len -= (AVRC_VENDOR_HDR_SIZE + AVRC_MIN_META_HDR_SIZE);
426 /* verify length */
427 if ((p_rcb->p_rmsg->offset + p_pkt->len) > buf_len)
428 {
429 AVRC_TRACE_WARNING("Fragmented message too big! - report the partial message");
430 p_pkt->len = buf_len - p_rcb->p_rmsg->offset;
431 pkt_type = AVRC_PKT_END;
432 buf_overflow = true;
433 }
434
435 /* copy contents of p_pkt to p_rx_msg */
436 memcpy((UINT8 *)(p_rcb->p_rmsg + 1) + p_rcb->p_rmsg->offset,
437 (UINT8 *)(p_pkt + 1) + p_pkt->offset, p_pkt->len);
438
439 if (pkt_type == AVRC_PKT_END)
440 {
441 p_rcb->p_rmsg->offset = p_rcb->rasm_offset;
442 p_rcb->p_rmsg->len += p_pkt->len;
443 p_pkt_new = p_rcb->p_rmsg;
444 p_rcb->rasm_offset = 0;
445 p_rcb->p_rmsg = NULL;
446 p_msg->p_vendor_data = (UINT8 *)(p_pkt_new+1) + p_pkt_new->offset;
447 p_msg->hdr.ctype = p_msg->p_vendor_data[0] & AVRC_CTYPE_MASK;
448 /* 6 = ctype, subunit*, opcode & CO_ID */
449 p_msg->p_vendor_data += AVRC_VENDOR_HDR_SIZE;
450 p_msg->vendor_len = p_pkt_new->len - AVRC_VENDOR_HDR_SIZE;
451 p_data = p_msg->p_vendor_data + 1; /* skip pdu */
452 *p_data++ = AVRC_PKT_SINGLE;
453 UINT16_TO_BE_STREAM(p_data, (p_msg->vendor_len - AVRC_MIN_META_HDR_SIZE));
454 AVRC_TRACE_DEBUG("end frag:%d, total len:%d, offset:%d", p_pkt->len,
455 p_pkt_new->len, p_pkt_new->offset);
456 }
457 else
458 {
459 p_rcb->p_rmsg->offset += p_pkt->len;
460 p_rcb->p_rmsg->len += p_pkt->len;
461 p_pkt_new = NULL;
462 req_continue = TRUE;
463 }
464 osi_free(p_pkt);
465 *pp_pkt = p_pkt_new;
466 }
467 }
468
469 if (cr == AVCT_CMD)
470 {
471 p_rsp = avrc_proc_vendor_command(handle, label, *pp_pkt, p_msg);
472 if (p_rsp)
473 {
474 AVCT_MsgReq( handle, label, AVCT_RSP, p_rsp);
475 drop_code = 3;
476 }
477 else if (p_msg->hdr.opcode == AVRC_OP_DROP)
478 {
479 drop_code = 1;
480 }
481 else if (p_msg->hdr.opcode == AVRC_OP_DROP_N_FREE)
482 drop_code = 4;
483
484 }
485 else if (cr == AVCT_RSP && req_continue == TRUE)
486 {
487 avrc_cmd.pdu = AVRC_PDU_REQUEST_CONTINUATION_RSP;
488 avrc_cmd.status = AVRC_STS_NO_ERROR;
489 avrc_cmd.target_pdu = p_rcb->rasm_pdu;
490 if (AVRC_BldCommand ((tAVRC_COMMAND *)&avrc_cmd, &p_cmd) == AVRC_STS_NO_ERROR)
491 {
492 drop_code = 2;
493 AVRC_MsgReq (handle, (UINT8)(label), AVRC_CMD_CTRL, p_cmd);
494 }
495 }
496 /*
497 * Drop it if we are out of buffer
498 */
499 else if (cr == AVCT_RSP && req_continue == FALSE && buf_overflow == TRUE)
500 {
501 avrc_cmd.pdu = AVRC_PDU_ABORT_CONTINUATION_RSP;
502 avrc_cmd.status = AVRC_STS_NO_ERROR;
503 avrc_cmd.target_pdu = p_rcb->rasm_pdu;
504 if (AVRC_BldCommand ((tAVRC_COMMAND *)&avrc_cmd, &p_cmd) == AVRC_STS_NO_ERROR)
505 {
506 drop_code = 4;
507 AVRC_MsgReq (handle, (UINT8)(label), AVRC_CMD_CTRL, p_cmd);
508 }
509 }
510 }
511
512 return drop_code;
513 }
514 #endif /* (AVRC_METADATA_INCLUDED == TRUE) */
515
516 /******************************************************************************
517 **
518 ** Function avrc_msg_cback
519 **
520 ** Description This is the callback function used by AVCTP to report
521 ** received AV control messages.
522 **
523 ** Returns Nothing.
524 **
525 ******************************************************************************/
avrc_msg_cback(UINT8 handle,UINT8 label,UINT8 cr,BT_HDR * p_pkt)526 static void avrc_msg_cback(UINT8 handle, UINT8 label, UINT8 cr,
527 BT_HDR *p_pkt)
528 {
529 UINT8 opcode;
530 tAVRC_MSG msg;
531 UINT8 *p_data;
532 UINT8 *p_begin;
533 BOOLEAN drop = FALSE;
534 BOOLEAN do_free = TRUE;
535 BT_HDR *p_rsp = NULL;
536 UINT8 *p_rsp_data;
537 int xx;
538 BOOLEAN reject = FALSE;
539 #if (BT_USE_TRACES == TRUE)
540 char *p_drop_msg = "dropped";
541 #endif
542 tAVRC_MSG_VENDOR *p_msg = &msg.vendor;
543
544 if (cr == AVCT_CMD &&
545 (p_pkt->layer_specific & AVCT_DATA_CTRL && AVRC_PACKET_LEN < sizeof(p_pkt->len)))
546 {
547 /* Ignore the invalid AV/C command frame */
548 #if (BT_USE_TRACES == TRUE)
549 p_drop_msg = "dropped - too long AV/C cmd frame size";
550 #endif
551 osi_free(p_pkt);
552 return;
553 }
554
555 if (cr == AVCT_REJ)
556 {
557 /* The peer thinks that this PID is no longer open - remove this handle */
558 /* */
559 osi_free(p_pkt);
560 AVCT_RemoveConn(handle);
561 return;
562 }
563
564 p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
565 memset(&msg, 0, sizeof(tAVRC_MSG) );
566 {
567 msg.hdr.ctype = p_data[0] & AVRC_CTYPE_MASK;
568 AVRC_TRACE_DEBUG("avrc_msg_cback handle:%d, ctype:%d, offset:%d, len: %d",
569 handle, msg.hdr.ctype, p_pkt->offset, p_pkt->len);
570 msg.hdr.subunit_type = (p_data[1] & AVRC_SUBTYPE_MASK) >> AVRC_SUBTYPE_SHIFT;
571 msg.hdr.subunit_id = p_data[1] & AVRC_SUBID_MASK;
572 opcode = p_data[2];
573 }
574
575 if ( ((avrc_cb.ccb[handle].control & AVRC_CT_TARGET) && (cr == AVCT_CMD)) ||
576 ((avrc_cb.ccb[handle].control & AVRC_CT_CONTROL) && (cr == AVCT_RSP)) )
577 {
578
579 switch(opcode)
580 {
581 case AVRC_OP_UNIT_INFO:
582 if (cr == AVCT_CMD)
583 {
584 /* send the response to the peer */
585 p_rsp = avrc_copy_packet(p_pkt, AVRC_OP_UNIT_INFO_RSP_LEN);
586 p_rsp_data = avrc_get_data_ptr(p_rsp);
587 *p_rsp_data = AVRC_RSP_IMPL_STBL;
588 /* check & set the offset. set response code, set subunit_type & subunit_id,
589 set AVRC_OP_UNIT_INFO */
590 /* 3 bytes: ctype, subunit*, opcode */
591 p_rsp_data += AVRC_AVC_HDR_SIZE;
592 *p_rsp_data++ = 7;
593 /* Panel subunit & id=0 */
594 *p_rsp_data++ = (AVRC_SUB_PANEL << AVRC_SUBTYPE_SHIFT);
595 AVRC_CO_ID_TO_BE_STREAM(p_rsp_data, avrc_cb.ccb[handle].company_id);
596 p_rsp->len = (UINT16) (p_rsp_data - (UINT8 *)(p_rsp + 1) - p_rsp->offset);
597 cr = AVCT_RSP;
598 #if (BT_USE_TRACES == TRUE)
599 p_drop_msg = "auto respond";
600 #endif
601 }
602 else
603 {
604 /* parse response */
605 p_data += 4; /* 3 bytes: ctype, subunit*, opcode + octet 3 (is 7)*/
606 msg.unit.unit_type = (*p_data & AVRC_SUBTYPE_MASK) >> AVRC_SUBTYPE_SHIFT;
607 msg.unit.unit = *p_data & AVRC_SUBID_MASK;
608 p_data++;
609 AVRC_BE_STREAM_TO_CO_ID(msg.unit.company_id, p_data);
610 }
611 break;
612
613 case AVRC_OP_SUB_INFO:
614 if (cr == AVCT_CMD)
615 {
616 /* send the response to the peer */
617 p_rsp = avrc_copy_packet(p_pkt, AVRC_OP_SUB_UNIT_INFO_RSP_LEN);
618 p_rsp_data = avrc_get_data_ptr(p_rsp);
619 *p_rsp_data = AVRC_RSP_IMPL_STBL;
620 /* check & set the offset. set response code, set (subunit_type & subunit_id),
621 set AVRC_OP_SUB_INFO, set (page & extention code) */
622 p_rsp_data += 4;
623 /* Panel subunit & id=0 */
624 *p_rsp_data++ = (AVRC_SUB_PANEL << AVRC_SUBTYPE_SHIFT);
625 memset(p_rsp_data, AVRC_CMD_OPRND_PAD, AVRC_SUBRSP_OPRND_BYTES);
626 p_rsp_data += AVRC_SUBRSP_OPRND_BYTES;
627 p_rsp->len = (UINT16) (p_rsp_data - (UINT8 *)(p_rsp + 1) - p_rsp->offset);
628 cr = AVCT_RSP;
629 #if (BT_USE_TRACES == TRUE)
630 p_drop_msg = "auto responded";
631 #endif
632 }
633 else
634 {
635 /* parse response */
636 p_data += AVRC_AVC_HDR_SIZE; /* 3 bytes: ctype, subunit*, opcode */
637 msg.sub.page = (*p_data++ >> AVRC_SUB_PAGE_SHIFT) & AVRC_SUB_PAGE_MASK;
638 xx = 0;
639 while (*p_data != AVRC_CMD_OPRND_PAD && xx<AVRC_SUB_TYPE_LEN)
640 {
641 msg.sub.subunit_type[xx] = *p_data++ >> AVRC_SUBTYPE_SHIFT;
642 if (msg.sub.subunit_type[xx] == AVRC_SUB_PANEL)
643 msg.sub.panel = TRUE;
644 xx++;
645 }
646 }
647 break;
648
649 case AVRC_OP_VENDOR:
650 p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
651 p_begin = p_data;
652 if (p_pkt->len < AVRC_VENDOR_HDR_SIZE) /* 6 = ctype, subunit*, opcode & CO_ID */
653 {
654 if (cr == AVCT_CMD)
655 reject = TRUE;
656 else
657 drop = TRUE;
658 break;
659 }
660 p_data += AVRC_AVC_HDR_SIZE; /* skip the first 3 bytes: ctype, subunit*, opcode */
661 AVRC_BE_STREAM_TO_CO_ID(p_msg->company_id, p_data);
662 p_msg->p_vendor_data = p_data;
663 p_msg->vendor_len = p_pkt->len - (p_data - p_begin);
664
665 #if (AVRC_METADATA_INCLUDED == TRUE)
666 UINT8 drop_code = 0;
667 if (p_msg->company_id == AVRC_CO_METADATA)
668 {
669 /* Validate length for metadata message */
670 if (p_pkt->len < (AVRC_VENDOR_HDR_SIZE + AVRC_MIN_META_HDR_SIZE))
671 {
672 if (cr == AVCT_CMD)
673 reject = TRUE;
674 else
675 drop = TRUE;
676 break;
677 }
678
679 /* Check+handle fragmented messages */
680 drop_code = avrc_proc_far_msg(handle, label, cr, &p_pkt, p_msg);
681 if (drop_code > 0)
682 drop = TRUE;
683 }
684 if (drop_code > 0)
685 {
686 if (drop_code != 4)
687 do_free = FALSE;
688 #if (BT_USE_TRACES == TRUE)
689 switch (drop_code)
690 {
691 case 1:
692 p_drop_msg = "sent_frag";
693 break;
694 case 2:
695 p_drop_msg = "req_cont";
696 break;
697 case 3:
698 p_drop_msg = "sent_frag3";
699 break;
700 case 4:
701 p_drop_msg = "sent_frag_free";
702 break;
703 default:
704 p_drop_msg = "sent_fragd";
705 }
706 #endif
707 }
708 #endif /* (AVRC_METADATA_INCLUDED == TRUE) */
709 break;
710
711 case AVRC_OP_PASS_THRU:
712 if (p_pkt->len < 5) /* 3 bytes: ctype, subunit*, opcode & op_id & len */
713 {
714 if (cr == AVCT_CMD)
715 reject = TRUE;
716 else
717 drop = TRUE;
718 break;
719 }
720 p_data += AVRC_AVC_HDR_SIZE; /* skip the first 3 bytes: ctype, subunit*, opcode */
721 msg.pass.op_id = (AVRC_PASS_OP_ID_MASK & *p_data);
722 if (AVRC_PASS_STATE_MASK & *p_data)
723 msg.pass.state = TRUE;
724 else
725 msg.pass.state = FALSE;
726 p_data++;
727 msg.pass.pass_len = *p_data++;
728 if (msg.pass.pass_len != p_pkt->len - 5)
729 msg.pass.pass_len = p_pkt->len - 5;
730 if (msg.pass.pass_len)
731 msg.pass.p_pass_data = p_data;
732 else
733 msg.pass.p_pass_data = NULL;
734 break;
735
736
737 default:
738 if ((avrc_cb.ccb[handle].control & AVRC_CT_TARGET) && (cr == AVCT_CMD))
739 {
740 /* reject unsupported opcode */
741 reject = TRUE;
742 }
743 drop = TRUE;
744 break;
745 }
746 }
747 else /* drop the event */
748 {
749 drop = TRUE;
750 }
751
752 if (reject)
753 {
754 /* reject unsupported opcode */
755 p_rsp = avrc_copy_packet(p_pkt, AVRC_OP_REJ_MSG_LEN);
756 p_rsp_data = avrc_get_data_ptr(p_rsp);
757 *p_rsp_data = AVRC_RSP_REJ;
758 #if (BT_USE_TRACES == TRUE)
759 p_drop_msg = "rejected";
760 #endif
761 cr = AVCT_RSP;
762 drop = TRUE;
763 }
764
765 if (p_rsp)
766 {
767 /* set to send response right away */
768 AVCT_MsgReq( handle, label, cr, p_rsp);
769 drop = TRUE;
770 }
771
772 if (drop == FALSE)
773 {
774 msg.hdr.opcode = opcode;
775 (*avrc_cb.ccb[handle].p_msg_cback)(handle, label, opcode, &msg);
776 }
777 #if (BT_USE_TRACES == TRUE)
778 else
779 {
780 AVRC_TRACE_WARNING("avrc_msg_cback %s msg handle:%d, control:%d, cr:%d, opcode:x%x",
781 p_drop_msg,
782 handle, avrc_cb.ccb[handle].control, cr, opcode);
783 }
784 #endif
785
786
787 if (do_free)
788 osi_free(p_pkt);
789 }
790
791
792
793
794 /******************************************************************************
795 **
796 ** Function avrc_pass_msg
797 **
798 ** Description Compose a PASS THROUGH command according to p_msg
799 **
800 ** Input Parameters:
801 ** p_msg: Pointer to PASS THROUGH message structure.
802 **
803 ** Output Parameters:
804 ** None.
805 **
806 ** Returns pointer to a valid GKI buffer if successful.
807 ** NULL if p_msg is NULL.
808 **
809 ******************************************************************************/
avrc_pass_msg(tAVRC_MSG_PASS * p_msg)810 static BT_HDR * avrc_pass_msg(tAVRC_MSG_PASS *p_msg)
811 {
812 assert(p_msg != NULL);
813 assert(AVRC_CMD_BUF_SIZE > (AVRC_MIN_CMD_LEN+p_msg->pass_len));
814
815 BT_HDR *p_cmd = (BT_HDR *)osi_malloc(AVRC_CMD_BUF_SIZE);
816 p_cmd->offset = AVCT_MSG_OFFSET;
817 p_cmd->layer_specific = AVCT_DATA_CTRL;
818
819 UINT8 *p_data = (UINT8 *)(p_cmd + 1) + p_cmd->offset;
820 *p_data++ = (p_msg->hdr.ctype & AVRC_CTYPE_MASK);
821 *p_data++ = (AVRC_SUB_PANEL << AVRC_SUBTYPE_SHIFT); /* Panel subunit & id=0 */
822 *p_data++ = AVRC_OP_PASS_THRU;
823 *p_data = (AVRC_PASS_OP_ID_MASK&p_msg->op_id);
824 if (p_msg->state)
825 *p_data |= AVRC_PASS_STATE_MASK;
826 p_data++;
827
828 if (p_msg->op_id == AVRC_ID_VENDOR) {
829 *p_data++ = p_msg->pass_len;
830 if (p_msg->pass_len && p_msg->p_pass_data) {
831 memcpy(p_data, p_msg->p_pass_data, p_msg->pass_len);
832 p_data += p_msg->pass_len;
833 }
834 } else {
835 /* set msg len to 0 for other op_id */
836 *p_data++ = 0;
837 }
838 p_cmd->len = (UINT16) (p_data - (UINT8 *)(p_cmd + 1) - p_cmd->offset);
839
840 return p_cmd;
841 }
842
843 /******************************************************************************
844 **
845 ** Function AVRC_Open
846 **
847 ** Description This function is called to open a connection to AVCTP.
848 ** The connection can be either an initiator or acceptor, as
849 ** determined by the p_ccb->stream parameter.
850 ** The connection can be a target, a controller or for both role,
851 ** as determined by the p_ccb->control parameter.
852 ** By definition, a target connection is an acceptor connection
853 ** that waits for an incoming AVCTP connection from the peer.
854 ** The connection remains available to the application until
855 ** the application closes it by calling AVRC_Close(). The
856 ** application does not need to reopen the connection after an
857 ** AVRC_CLOSE_IND_EVT is received.
858 **
859 ** Input Parameters:
860 ** p_ccb->company_id: Company Identifier.
861 **
862 ** p_ccb->p_ctrl_cback: Pointer to control callback function.
863 **
864 ** p_ccb->p_msg_cback: Pointer to message callback function.
865 **
866 ** p_ccb->conn: AVCTP connection role. This is set to
867 ** AVCTP_INT for initiator connections and AVCTP_ACP
868 ** for acceptor connections.
869 **
870 ** p_ccb->control: Control role. This is set to
871 ** AVRC_CT_TARGET for target connections, AVRC_CT_CONTROL
872 ** for control connections or (AVRC_CT_TARGET|AVRC_CT_CONTROL)
873 ** for connections that support both roles.
874 **
875 ** peer_addr: BD address of peer device. This value is
876 ** only used for initiator connections; for acceptor
877 ** connections it can be set to NULL.
878 **
879 ** Output Parameters:
880 ** p_handle: Pointer to handle. This parameter is only
881 ** valid if AVRC_SUCCESS is returned.
882 **
883 ** Returns AVRC_SUCCESS if successful.
884 ** AVRC_NO_RESOURCES if there are not enough resources to open
885 ** the connection.
886 **
887 ******************************************************************************/
AVRC_Open(UINT8 * p_handle,tAVRC_CONN_CB * p_ccb,BD_ADDR_PTR peer_addr)888 UINT16 AVRC_Open(UINT8 *p_handle, tAVRC_CONN_CB *p_ccb, BD_ADDR_PTR peer_addr)
889 {
890 UINT16 status;
891 tAVCT_CC cc;
892
893 cc.p_ctrl_cback = avrc_ctrl_cback; /* Control callback */
894 cc.p_msg_cback = avrc_msg_cback; /* Message callback */
895 cc.pid = UUID_SERVCLASS_AV_REMOTE_CONTROL; /* Profile ID */
896 cc.role = p_ccb->conn; /* Initiator/acceptor role */
897 cc.control = p_ccb->control; /* Control role (Control/Target) */
898
899 status = AVCT_CreateConn(p_handle, &cc, peer_addr);
900 if (status == AVCT_SUCCESS)
901 {
902 memcpy(&avrc_cb.ccb[*p_handle], p_ccb, sizeof(tAVRC_CONN_CB));
903 #if (AVRC_METADATA_INCLUDED == TRUE)
904 memset(&avrc_cb.fcb[*p_handle], 0, sizeof(tAVRC_FRAG_CB));
905 memset(&avrc_cb.rcb[*p_handle], 0, sizeof(tAVRC_RASM_CB));
906 #endif
907 }
908 AVRC_TRACE_DEBUG("AVRC_Open role: %d, control:%d status:%d, handle:%d", cc.role, cc.control,
909 status, *p_handle);
910
911 return status;
912 }
913
914 /******************************************************************************
915 **
916 ** Function AVRC_Close
917 **
918 ** Description Close a connection opened with AVRC_Open().
919 ** This function is called when the
920 ** application is no longer using a connection.
921 **
922 ** Input Parameters:
923 ** handle: Handle of this connection.
924 **
925 ** Output Parameters:
926 ** None.
927 **
928 ** Returns AVRC_SUCCESS if successful.
929 ** AVRC_BAD_HANDLE if handle is invalid.
930 **
931 ******************************************************************************/
AVRC_Close(UINT8 handle)932 UINT16 AVRC_Close(UINT8 handle)
933 {
934 AVRC_TRACE_DEBUG("AVRC_Close handle:%d", handle);
935 return AVCT_RemoveConn(handle);
936 }
937
938
939 /******************************************************************************
940 **
941 ** Function AVRC_MsgReq
942 **
943 ** Description This function is used to send the AVRCP byte stream in p_pkt
944 ** down to AVCTP.
945 **
946 ** It is expected that p_pkt->offset is at least AVCT_MSG_OFFSET
947 ** p_pkt->layer_specific is AVCT_DATA_CTRL or AVCT_DATA_BROWSE
948 ** p_pkt->event is AVRC_OP_VENDOR, AVRC_OP_PASS_THRU or AVRC_OP_BROWSE
949 ** The above BT_HDR settings are set by the AVRC_Bld* functions.
950 **
951 ** Returns AVRC_SUCCESS if successful.
952 ** AVRC_BAD_HANDLE if handle is invalid.
953 **
954 ******************************************************************************/
AVRC_MsgReq(UINT8 handle,UINT8 label,UINT8 ctype,BT_HDR * p_pkt)955 UINT16 AVRC_MsgReq (UINT8 handle, UINT8 label, UINT8 ctype, BT_HDR *p_pkt)
956 {
957 #if (AVRC_METADATA_INCLUDED == TRUE)
958 UINT8 *p_data;
959 UINT8 cr = AVCT_CMD;
960 BOOLEAN chk_frag = TRUE;
961 UINT8 *p_start = NULL;
962 tAVRC_FRAG_CB *p_fcb;
963 UINT16 len;
964
965 if (!p_pkt)
966 return AVRC_BAD_PARAM;
967
968 AVRC_TRACE_DEBUG("%s handle = %u label = %u ctype = %u len = %d",
969 __func__, handle, label, ctype, p_pkt->len);
970
971 if (ctype >= AVRC_RSP_NOT_IMPL)
972 cr = AVCT_RSP;
973
974 if (p_pkt->event == AVRC_OP_VENDOR)
975 {
976 /* add AVRCP Vendor Dependent headers */
977 p_start = ((UINT8 *)(p_pkt + 1) + p_pkt->offset);
978 p_pkt->offset -= AVRC_VENDOR_HDR_SIZE;
979 p_pkt->len += AVRC_VENDOR_HDR_SIZE;
980 p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
981 *p_data++ = (ctype & AVRC_CTYPE_MASK);
982 *p_data++ = (AVRC_SUB_PANEL << AVRC_SUBTYPE_SHIFT);
983 *p_data++ = AVRC_OP_VENDOR;
984 AVRC_CO_ID_TO_BE_STREAM(p_data, AVRC_CO_METADATA);
985 }
986 else if (p_pkt->event == AVRC_OP_PASS_THRU)
987 {
988 /* add AVRCP Pass Through headers */
989 p_start = ((UINT8 *)(p_pkt + 1) + p_pkt->offset);
990 p_pkt->offset -= AVRC_PASS_THRU_SIZE;
991 p_pkt->len += AVRC_PASS_THRU_SIZE;
992 p_data = (UINT8 *)(p_pkt + 1) + p_pkt->offset;
993 *p_data++ = (ctype & AVRC_CTYPE_MASK);
994 *p_data++ = (AVRC_SUB_PANEL << AVRC_SUBTYPE_SHIFT);
995 *p_data++ = AVRC_OP_PASS_THRU;/* opcode */
996 *p_data++ = AVRC_ID_VENDOR; /* operation id */
997 *p_data++ = 5; /* operation data len */
998 AVRC_CO_ID_TO_BE_STREAM(p_data, AVRC_CO_METADATA);
999 }
1000
1001 /* abandon previous fragments */
1002 p_fcb = &avrc_cb.fcb[handle];
1003 if (p_fcb->frag_enabled)
1004 p_fcb->frag_enabled = FALSE;
1005
1006 osi_free_and_reset((void **)&p_fcb->p_fmsg);
1007
1008 /* AVRCP spec has not defined any control channel commands that needs fragmentation at this level
1009 * check for fragmentation only on the response */
1010 if ((cr == AVCT_RSP) && (chk_frag == TRUE))
1011 {
1012 if (p_pkt->len > AVRC_MAX_CTRL_DATA_LEN)
1013 {
1014 int offset_len = MAX(AVCT_MSG_OFFSET, p_pkt->offset);
1015 BT_HDR *p_pkt_new =
1016 (BT_HDR *)osi_malloc(AVRC_PACKET_LEN + offset_len + BT_HDR_SIZE);
1017 if (p_start != NULL) {
1018 p_fcb->frag_enabled = TRUE;
1019 p_fcb->p_fmsg = p_pkt;
1020 p_fcb->frag_pdu = *p_start;
1021 p_pkt = p_pkt_new;
1022 p_pkt_new = p_fcb->p_fmsg;
1023 p_pkt->len = AVRC_MAX_CTRL_DATA_LEN;
1024 p_pkt->offset = p_pkt_new->offset;
1025 p_pkt->layer_specific = p_pkt_new->layer_specific;
1026 p_pkt->event = p_pkt_new->event;
1027 p_data = (UINT8 *)(p_pkt+1) + p_pkt->offset;
1028 p_start -= AVRC_VENDOR_HDR_SIZE;
1029 memcpy (p_data, p_start, AVRC_MAX_CTRL_DATA_LEN);
1030 /* use AVRC start packet type */
1031 p_data += AVRC_VENDOR_HDR_SIZE;
1032 p_data++; /* pdu */
1033 *p_data++ = AVRC_PKT_START;
1034 /* 4 pdu, pkt_type & len */
1035 len = (AVRC_MAX_CTRL_DATA_LEN - AVRC_VENDOR_HDR_SIZE - AVRC_MIN_META_HDR_SIZE);
1036 UINT16_TO_BE_STREAM(p_data, len);
1037
1038 /* prepare the left over for as an end fragment */
1039 avrc_prep_end_frag (handle);
1040 AVRC_TRACE_DEBUG ("%s p_pkt len:%d/%d, next len:%d", __func__,
1041 p_pkt->len, len, p_fcb->p_fmsg->len );
1042 } else {
1043 /* TODO: Is this "else" block valid? Remove it? */
1044 AVRC_TRACE_ERROR ("AVRC_MsgReq no buffers for fragmentation" );
1045 osi_free(p_pkt);
1046 return AVRC_NO_RESOURCES;
1047 }
1048 }
1049 }
1050
1051 return AVCT_MsgReq( handle, label, cr, p_pkt);
1052 #else
1053 return AVRC_NO_RESOURCES;
1054 #endif
1055 }
1056
1057
1058 /******************************************************************************
1059 **
1060 ** Function AVRC_PassCmd
1061 **
1062 ** Description Send a PASS THROUGH command to the peer device. This
1063 ** function can only be called for controller role connections.
1064 ** Any response message from the peer is passed back through
1065 ** the tAVRC_MSG_CBACK callback function.
1066 **
1067 ** Input Parameters:
1068 ** handle: Handle of this connection.
1069 **
1070 ** label: Transaction label.
1071 **
1072 ** p_msg: Pointer to PASS THROUGH message structure.
1073 **
1074 ** Output Parameters:
1075 ** None.
1076 **
1077 ** Returns AVRC_SUCCESS if successful.
1078 ** AVRC_BAD_HANDLE if handle is invalid.
1079 **
1080 ******************************************************************************/
AVRC_PassCmd(UINT8 handle,UINT8 label,tAVRC_MSG_PASS * p_msg)1081 UINT16 AVRC_PassCmd(UINT8 handle, UINT8 label, tAVRC_MSG_PASS *p_msg)
1082 {
1083 BT_HDR *p_buf;
1084 assert(p_msg != NULL);
1085 if (p_msg)
1086 {
1087 p_msg->hdr.ctype = AVRC_CMD_CTRL;
1088 p_buf = avrc_pass_msg(p_msg);
1089 if (p_buf)
1090 return AVCT_MsgReq( handle, label, AVCT_CMD, p_buf);
1091 }
1092 return AVRC_NO_RESOURCES;
1093 }
1094
1095 /******************************************************************************
1096 **
1097 ** Function AVRC_PassRsp
1098 **
1099 ** Description Send a PASS THROUGH response to the peer device. This
1100 ** function can only be called for target role connections.
1101 ** This function must be called when a PASS THROUGH command
1102 ** message is received from the peer through the
1103 ** tAVRC_MSG_CBACK callback function.
1104 **
1105 ** Input Parameters:
1106 ** handle: Handle of this connection.
1107 **
1108 ** label: Transaction label. Must be the same value as
1109 ** passed with the command message in the callback function.
1110 **
1111 ** p_msg: Pointer to PASS THROUGH message structure.
1112 **
1113 ** Output Parameters:
1114 ** None.
1115 **
1116 ** Returns AVRC_SUCCESS if successful.
1117 ** AVRC_BAD_HANDLE if handle is invalid.
1118 **
1119 ******************************************************************************/
AVRC_PassRsp(UINT8 handle,UINT8 label,tAVRC_MSG_PASS * p_msg)1120 UINT16 AVRC_PassRsp(UINT8 handle, UINT8 label, tAVRC_MSG_PASS *p_msg)
1121 {
1122 BT_HDR *p_buf;
1123 assert(p_msg != NULL);
1124 if (p_msg)
1125 {
1126 p_buf = avrc_pass_msg(p_msg);
1127 if (p_buf)
1128 return AVCT_MsgReq( handle, label, AVCT_RSP, p_buf);
1129 }
1130 return AVRC_NO_RESOURCES;
1131 }
1132
1133