1 /******************************************************************************
2 *
3 * Copyright (C) 1999-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 file contains the main Bluetooth Upper Layer processing loop.
22 * The Broadcom implementations of L2CAP RFCOMM, SDP and the BTIf run as one
23 * GKI task. This btu_task switches between them.
24 *
25 * Note that there will always be an L2CAP, but there may or may not be an
26 * RFCOMM or SDP. Whether these layers are present or not is determined by
27 * compile switches.
28 *
29 ******************************************************************************/
30
31 #include <stdlib.h>
32 #include <string.h>
33 #include <stdio.h>
34
35 #include "bt_target.h"
36 #include "gki.h"
37 #include "bt_types.h"
38 #include "hcimsgs.h"
39 #include "l2c_int.h"
40 #include "btu.h"
41 #include "bt_utils.h"
42
43 #include "sdpint.h"
44
45 #if ( defined(RFCOMM_INCLUDED) && RFCOMM_INCLUDED == TRUE )
46 #include "port_api.h"
47 #include "port_ext.h"
48 #endif
49
50 #include "btm_api.h"
51 #include "btm_int.h"
52
53 #if (defined(EVAL) && EVAL == TRUE)
54 #include "btu_eval.h"
55 #endif
56
57 #if GAP_INCLUDED == TRUE
58 #include "gap_int.h"
59 #endif
60
61 #if (defined(OBX_INCLUDED) && OBX_INCLUDED == TRUE)
62 #include "obx_int.h"
63
64 #if (defined(BIP_INCLUDED) && BIP_INCLUDED == TRUE)
65 #include "bip_int.h"
66 #endif /* BIP */
67
68 #if (BPP_SND_INCLUDED == TRUE || BPP_INCLUDED == TRUE)
69 #include "bpp_int.h"
70 #endif /* BPP */
71
72 #endif /* OBX */
73
74 #include "bt_trace.h"
75
76 /* BTE application task */
77 #if APPL_INCLUDED == TRUE
78 #include "bte_appl.h"
79 #endif
80
81 #if (defined(RPC_INCLUDED) && RPC_INCLUDED == TRUE)
82 #include "rpct_main.h"
83 #endif
84
85 #if (defined(BNEP_INCLUDED) && BNEP_INCLUDED == TRUE)
86 #include "bnep_int.h"
87 #endif
88
89 #if (defined(PAN_INCLUDED) && PAN_INCLUDED == TRUE)
90 #include "pan_int.h"
91 #endif
92
93 #if (defined(SAP_SERVER_INCLUDED) && SAP_SERVER_INCLUDED == TRUE)
94 #include "sap_int.h"
95 #endif
96
97 #if (defined(HID_DEV_INCLUDED) && HID_DEV_INCLUDED == TRUE )
98 #include "hidd_int.h"
99 #endif
100
101 #if (defined(HID_HOST_INCLUDED) && HID_HOST_INCLUDED == TRUE )
102 #include "hidh_int.h"
103 #endif
104
105 #if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE)
106 #include "avdt_int.h"
107 #else
108 extern void avdt_rcv_sync_info (BT_HDR *p_buf); /* this is for hci_test */
109 #endif
110
111 #if (defined(MCA_INCLUDED) && MCA_INCLUDED == TRUE)
112 #include "mca_api.h"
113 #include "mca_defs.h"
114 #include "mca_int.h"
115 #endif
116
117
118 #if (defined(BTU_BTA_INCLUDED) && BTU_BTA_INCLUDED == TRUE)
119 #include "bta_sys.h"
120 #endif
121
122 #if (BLE_INCLUDED == TRUE)
123 #include "gatt_int.h"
124 #if (SMP_INCLUDED == TRUE)
125 #include "smp_int.h"
126 #endif
127 #include "btm_ble_int.h"
128 #endif
129
130 #ifdef __cplusplus
131 extern "C"
132 {
133 #endif
134
135 BT_API extern void BTE_InitStack(void);
136
137 #ifdef __cplusplus
138 }
139 #endif
140
141 /* Define BTU storage area
142 */
143 #if BTU_DYNAMIC_MEMORY == FALSE
144 tBTU_CB btu_cb;
145 #endif
146
147
148 /* Define a function prototype to allow a generic timeout handler */
149 typedef void (tUSER_TIMEOUT_FUNC) (TIMER_LIST_ENT *p_tle);
150
151 /*******************************************************************************
152 **
153 ** Function btu_task
154 **
155 ** Description This is the main task of the Bluetooth Upper Layers unit.
156 ** It sits in a loop waiting for messages, and dispatches them
157 ** to the appropiate handlers.
158 **
159 ** Returns should never return
160 **
161 *******************************************************************************/
btu_task(UINT32 param)162 BTU_API UINT32 btu_task (UINT32 param)
163 {
164 UINT16 event;
165 BT_HDR *p_msg;
166 UINT8 i;
167 UINT16 mask;
168 BOOLEAN handled;
169
170 #if (defined(HCISU_H4_INCLUDED) && HCISU_H4_INCLUDED == TRUE)
171 /* wait an event that HCISU is ready */
172 BT_TRACE_0(TRACE_LAYER_BTU, TRACE_TYPE_API,
173 "btu_task pending for preload complete event");
174
175 for (;;)
176 {
177 event = GKI_wait (0xFFFF, 0);
178 if (event & EVENT_MASK(GKI_SHUTDOWN_EVT))
179 {
180 /* indicates BT ENABLE abort */
181 BT_TRACE_0(TRACE_LAYER_BTU, TRACE_TYPE_WARNING,
182 "btu_task start abort!");
183 return (0);
184 }
185 else if (event & BT_EVT_PRELOAD_CMPL)
186 {
187 break;
188 }
189 else
190 {
191 BT_TRACE_1(TRACE_LAYER_BTU, TRACE_TYPE_WARNING,
192 "btu_task ignore evt %04x while pending for preload complete",
193 event);
194 }
195 }
196
197 BT_TRACE_0(TRACE_LAYER_BTU, TRACE_TYPE_API,
198 "btu_task received preload complete event");
199 #endif
200
201 /* Initialize the mandatory core stack control blocks
202 (BTU, BTM, L2CAP, and SDP)
203 */
204 btu_init_core();
205
206 /* Initialize any optional stack components */
207 BTE_InitStack();
208
209 #if (defined(BTU_BTA_INCLUDED) && BTU_BTA_INCLUDED == TRUE)
210 bta_sys_init();
211 #endif
212
213 /* Initialise platform trace levels at this point as BTE_InitStack() and bta_sys_init()
214 * reset the control blocks and preset the trace level with XXX_INITIAL_TRACE_LEVEL
215 */
216 #if ( BT_USE_TRACES==TRUE )
217 BTE_InitTraceLevels();
218 #endif
219
220 /* Send a startup evt message to BTIF_TASK to kickstart the init procedure */
221 GKI_send_event(BTIF_TASK, BT_EVT_TRIGGER_STACK_INIT);
222
223 raise_priority_a2dp(TASK_HIGH_BTU);
224
225 /* Wait for, and process, events */
226 for (;;)
227 {
228 event = GKI_wait (0xFFFF, 0);
229
230 if (event & TASK_MBOX_0_EVT_MASK)
231 {
232 /* Process all messages in the queue */
233 while ((p_msg = (BT_HDR *) GKI_read_mbox (BTU_HCI_RCV_MBOX)) != NULL)
234 {
235 /* Determine the input message type. */
236 switch (p_msg->event & BT_EVT_MASK)
237 {
238 case BT_EVT_TO_BTU_HCI_ACL:
239 /* All Acl Data goes to L2CAP */
240 l2c_rcv_acl_data (p_msg);
241 break;
242
243 case BT_EVT_TO_BTU_L2C_SEG_XMIT:
244 /* L2CAP segment transmit complete */
245 l2c_link_segments_xmitted (p_msg);
246 break;
247
248 case BT_EVT_TO_BTU_HCI_SCO:
249 #if BTM_SCO_INCLUDED == TRUE
250 btm_route_sco_data (p_msg);
251 break;
252 #endif
253
254 case BT_EVT_TO_BTU_HCI_EVT:
255 btu_hcif_process_event ((UINT8)(p_msg->event & BT_SUB_EVT_MASK), p_msg);
256 GKI_freebuf(p_msg);
257
258 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
259 /* If host receives events which it doesn't response to, */
260 /* host should start idle timer to enter sleep mode. */
261 btu_check_bt_sleep ();
262 #endif
263 break;
264
265 case BT_EVT_TO_BTU_HCI_CMD:
266 btu_hcif_send_cmd ((UINT8)(p_msg->event & BT_SUB_EVT_MASK), p_msg);
267 break;
268
269 #if (defined(OBX_INCLUDED) && OBX_INCLUDED == TRUE)
270 #if (defined(OBX_SERVER_INCLUDED) && OBX_SERVER_INCLUDED == TRUE)
271 case BT_EVT_TO_OBX_SR_MSG:
272 obx_sr_proc_evt((tOBX_PORT_EVT *)(p_msg + 1));
273 GKI_freebuf (p_msg);
274 break;
275
276 case BT_EVT_TO_OBX_SR_L2C_MSG:
277 obx_sr_proc_l2c_evt((tOBX_L2C_EVT_MSG *)(p_msg + 1));
278 GKI_freebuf (p_msg);
279 break;
280 #endif
281
282 #if (defined(OBX_CLIENT_INCLUDED) && OBX_CLIENT_INCLUDED == TRUE)
283 case BT_EVT_TO_OBX_CL_MSG:
284 obx_cl_proc_evt((tOBX_PORT_EVT *)(p_msg + 1));
285 GKI_freebuf (p_msg);
286 break;
287
288 case BT_EVT_TO_OBX_CL_L2C_MSG:
289 obx_cl_proc_l2c_evt((tOBX_L2C_EVT_MSG *)(p_msg + 1));
290 GKI_freebuf (p_msg);
291 break;
292 #endif
293
294 #if (defined(BIP_INCLUDED) && BIP_INCLUDED == TRUE)
295 case BT_EVT_TO_BIP_CMDS :
296 bip_proc_btu_event(p_msg);
297 GKI_freebuf (p_msg);
298 break;
299 #endif /* BIP */
300 #if (BPP_SND_INCLUDED == TRUE || BPP_INCLUDED == TRUE)
301 case BT_EVT_TO_BPP_PR_CMDS:
302 bpp_pr_proc_event(p_msg);
303 GKI_freebuf (p_msg);
304 break;
305 case BT_EVT_TO_BPP_SND_CMDS:
306 bpp_snd_proc_event(p_msg);
307 GKI_freebuf (p_msg);
308 break;
309
310 #endif /* BPP */
311
312 #endif /* OBX */
313
314 #if (defined(SAP_SERVER_INCLUDED) && SAP_SERVER_INCLUDED == TRUE)
315 case BT_EVT_TO_BTU_SAP :
316 sap_proc_btu_event(p_msg);
317 GKI_freebuf (p_msg);
318 break;
319 #endif /* SAP */
320 #if (defined(GAP_CONN_INCLUDED) && GAP_CONN_INCLUDED == TRUE && GAP_CONN_POST_EVT_INCLUDED == TRUE)
321 case BT_EVT_TO_GAP_MSG :
322 gap_proc_btu_event(p_msg);
323 GKI_freebuf (p_msg);
324 break;
325 #endif
326 case BT_EVT_TO_START_TIMER :
327 /* Start free running 1 second timer for list management */
328 GKI_start_timer (TIMER_0, GKI_SECS_TO_TICKS (1), TRUE);
329 GKI_freebuf (p_msg);
330 break;
331
332 case BT_EVT_TO_STOP_TIMER:
333 if (btu_cb.timer_queue.p_first == NULL)
334 {
335 GKI_stop_timer(TIMER_0);
336 }
337 GKI_freebuf (p_msg);
338 break;
339
340 #if defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0)
341 case BT_EVT_TO_START_QUICK_TIMER :
342 GKI_start_timer (TIMER_2, QUICK_TIMER_TICKS, TRUE);
343 GKI_freebuf (p_msg);
344 break;
345 #endif
346
347 default:
348 i = 0;
349 mask = (UINT16) (p_msg->event & BT_EVT_MASK);
350 handled = FALSE;
351
352 for (; !handled && i < BTU_MAX_REG_EVENT; i++)
353 {
354 if (btu_cb.event_reg[i].event_cb == NULL)
355 continue;
356
357 if (mask == btu_cb.event_reg[i].event_range)
358 {
359 if (btu_cb.event_reg[i].event_cb)
360 {
361 btu_cb.event_reg[i].event_cb(p_msg);
362 handled = TRUE;
363 }
364 }
365 }
366
367 if (handled == FALSE)
368 GKI_freebuf (p_msg);
369
370 break;
371 }
372 }
373 }
374
375
376 if (event & TIMER_0_EVT_MASK)
377 {
378 TIMER_LIST_ENT *p_tle;
379
380 GKI_update_timer_list (&btu_cb.timer_queue, 1);
381
382 while ((btu_cb.timer_queue.p_first) && (!btu_cb.timer_queue.p_first->ticks))
383 {
384 p_tle = btu_cb.timer_queue.p_first;
385 GKI_remove_from_timer_list (&btu_cb.timer_queue, p_tle);
386
387 switch (p_tle->event)
388 {
389 case BTU_TTYPE_BTM_DEV_CTL:
390 btm_dev_timeout(p_tle);
391 break;
392
393 case BTU_TTYPE_BTM_ACL:
394 btm_acl_timeout(p_tle);
395 break;
396
397 case BTU_TTYPE_L2CAP_LINK:
398 case BTU_TTYPE_L2CAP_CHNL:
399 case BTU_TTYPE_L2CAP_HOLD:
400 case BTU_TTYPE_L2CAP_INFO:
401 case BTU_TTYPE_L2CAP_FCR_ACK:
402
403 l2c_process_timeout (p_tle);
404 break;
405
406 case BTU_TTYPE_SDP:
407 sdp_conn_timeout ((tCONN_CB *)p_tle->param);
408 break;
409
410 case BTU_TTYPE_BTM_RMT_NAME:
411 btm_inq_rmt_name_failed();
412 break;
413
414 #if (defined(RFCOMM_INCLUDED) && RFCOMM_INCLUDED == TRUE)
415 case BTU_TTYPE_RFCOMM_MFC:
416 case BTU_TTYPE_RFCOMM_PORT:
417 rfcomm_process_timeout (p_tle);
418 break;
419
420 #endif /* If defined(RFCOMM_INCLUDED) && RFCOMM_INCLUDED == TRUE */
421
422 #if ((defined(BNEP_INCLUDED) && BNEP_INCLUDED == TRUE))
423 case BTU_TTYPE_BNEP:
424 bnep_process_timeout(p_tle);
425 break;
426 #endif
427
428
429 #if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE)
430 case BTU_TTYPE_AVDT_CCB_RET:
431 case BTU_TTYPE_AVDT_CCB_RSP:
432 case BTU_TTYPE_AVDT_CCB_IDLE:
433 case BTU_TTYPE_AVDT_SCB_TC:
434 avdt_process_timeout(p_tle);
435 break;
436 #endif
437
438 #if (defined(OBX_INCLUDED) && OBX_INCLUDED == TRUE)
439 #if (defined(OBX_CLIENT_INCLUDED) && OBX_CLIENT_INCLUDED == TRUE)
440 case BTU_TTYPE_OBX_CLIENT_TO:
441 obx_cl_timeout(p_tle);
442 break;
443 #endif
444 #if (defined(OBX_SERVER_INCLUDED) && OBX_SERVER_INCLUDED == TRUE)
445 case BTU_TTYPE_OBX_SERVER_TO:
446 obx_sr_timeout(p_tle);
447 break;
448
449 case BTU_TTYPE_OBX_SVR_SESS_TO:
450 obx_sr_sess_timeout(p_tle);
451 break;
452 #endif
453 #endif
454
455 #if (defined(SAP_SERVER_INCLUDED) && SAP_SERVER_INCLUDED == TRUE)
456 case BTU_TTYPE_SAP_TO:
457 sap_process_timeout(p_tle);
458 break;
459 #endif
460
461 case BTU_TTYPE_BTU_CMD_CMPL:
462 btu_hcif_cmd_timeout((UINT8)(p_tle->event - BTU_TTYPE_BTU_CMD_CMPL));
463 break;
464
465 #if (defined(HID_HOST_INCLUDED) && HID_HOST_INCLUDED == TRUE)
466 case BTU_TTYPE_HID_HOST_REPAGE_TO :
467 hidh_proc_repage_timeout(p_tle);
468 break;
469 #endif
470
471 #if (defined(BLE_INCLUDED) && BLE_INCLUDED == TRUE)
472 case BTU_TTYPE_BLE_INQUIRY:
473 case BTU_TTYPE_BLE_GAP_LIM_DISC:
474 case BTU_TTYPE_BLE_RANDOM_ADDR:
475 btm_ble_timeout(p_tle);
476 break;
477
478 case BTU_TTYPE_ATT_WAIT_FOR_RSP:
479 gatt_rsp_timeout(p_tle);
480 break;
481
482 case BTU_TTYPE_ATT_WAIT_FOR_IND_ACK:
483 gatt_ind_ack_timeout(p_tle);
484 break;
485 #if (defined(SMP_INCLUDED) && SMP_INCLUDED == TRUE)
486 case BTU_TTYPE_SMP_PAIRING_CMD:
487 smp_rsp_timeout(p_tle);
488 break;
489 #endif
490
491 #endif
492
493 #if (MCA_INCLUDED == TRUE)
494 case BTU_TTYPE_MCA_CCB_RSP:
495 mca_process_timeout(p_tle);
496 break;
497 #endif
498 case BTU_TTYPE_USER_FUNC:
499 {
500 tUSER_TIMEOUT_FUNC *p_uf = (tUSER_TIMEOUT_FUNC *)p_tle->param;
501 (*p_uf)(p_tle);
502 }
503 break;
504
505 default:
506 i = 0;
507 handled = FALSE;
508
509 for (; !handled && i < BTU_MAX_REG_TIMER; i++)
510 {
511 if (btu_cb.timer_reg[i].timer_cb == NULL)
512 continue;
513 if (btu_cb.timer_reg[i].p_tle == p_tle)
514 {
515 btu_cb.timer_reg[i].timer_cb(p_tle);
516 handled = TRUE;
517 }
518 }
519 break;
520 }
521 }
522
523 /* if timer list is empty stop periodic GKI timer */
524 if (btu_cb.timer_queue.p_first == NULL)
525 {
526 GKI_stop_timer(TIMER_0);
527 }
528 }
529
530 #if defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0)
531 if (event & TIMER_2_EVT_MASK)
532 {
533 btu_process_quick_timer_evt();
534 }
535 #endif
536
537
538 #if (RPC_INCLUDED == TRUE)
539 /* if RPC message queue event */
540 if (event & RPCGEN_MSG_EVT)
541 {
542 if ((p_msg = (BT_HDR *) GKI_read_mbox(RPCGEN_MSG_MBOX)) != NULL)
543 RPCT_RpcgenMsg(p_msg); /* handle RPC message queue */
544 }
545 #endif
546
547 #if (defined(BTU_BTA_INCLUDED) && BTU_BTA_INCLUDED == TRUE)
548 if (event & TASK_MBOX_2_EVT_MASK)
549 {
550 while ((p_msg = (BT_HDR *) GKI_read_mbox(TASK_MBOX_2)) != NULL)
551 {
552 bta_sys_event(p_msg);
553 }
554 }
555
556 if (event & TIMER_1_EVT_MASK)
557 {
558 bta_sys_timer_update();
559 }
560 #endif
561
562 if (event & EVENT_MASK(APPL_EVT_7))
563 break;
564 }
565
566 return(0);
567 }
568
569 /*******************************************************************************
570 **
571 ** Function btu_start_timer
572 **
573 ** Description Start a timer for the specified amount of time.
574 ** NOTE: The timeout resolution is in SECONDS! (Even
575 ** though the timer structure field is ticks)
576 **
577 ** Returns void
578 **
579 *******************************************************************************/
btu_start_timer(TIMER_LIST_ENT * p_tle,UINT16 type,UINT32 timeout)580 void btu_start_timer (TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout)
581 {
582 BT_HDR *p_msg;
583 /* if timer list is currently empty, start periodic GKI timer */
584 if (btu_cb.timer_queue.p_first == NULL)
585 {
586 /* if timer starts on other than BTU task */
587 if (GKI_get_taskid() != BTU_TASK)
588 {
589 /* post event to start timer in BTU task */
590 if ((p_msg = (BT_HDR *)GKI_getbuf(BT_HDR_SIZE)) != NULL)
591 {
592 p_msg->event = BT_EVT_TO_START_TIMER;
593 GKI_send_msg (BTU_TASK, TASK_MBOX_0, p_msg);
594 }
595 }
596 else
597 {
598 /* Start free running 1 second timer for list management */
599 GKI_start_timer (TIMER_0, GKI_SECS_TO_TICKS (1), TRUE);
600 }
601 }
602
603 GKI_remove_from_timer_list (&btu_cb.timer_queue, p_tle);
604
605 p_tle->event = type;
606 p_tle->ticks = timeout; /* Save the number of seconds for the timer */
607
608 GKI_add_to_timer_list (&btu_cb.timer_queue, p_tle);
609 }
610
611 /*******************************************************************************
612 **
613 ** Function btu_remaining_time
614 **
615 ** Description Return amount of time to expire
616 **
617 ** Returns time in second
618 **
619 *******************************************************************************/
btu_remaining_time(TIMER_LIST_ENT * p_tle)620 UINT32 btu_remaining_time (TIMER_LIST_ENT *p_tle)
621 {
622 return(GKI_get_remaining_ticks (&btu_cb.timer_queue, p_tle));
623 }
624
625 /*******************************************************************************
626 **
627 ** Function btu_stop_timer
628 **
629 ** Description Stop a timer.
630 **
631 ** Returns void
632 **
633 *******************************************************************************/
btu_stop_timer(TIMER_LIST_ENT * p_tle)634 void btu_stop_timer (TIMER_LIST_ENT *p_tle)
635 {
636 BT_HDR *p_msg;
637 GKI_remove_from_timer_list (&btu_cb.timer_queue, p_tle);
638
639 /* if timer is stopped on other than BTU task */
640 if (GKI_get_taskid() != BTU_TASK)
641 {
642 /* post event to stop timer in BTU task */
643 if ((p_msg = (BT_HDR *)GKI_getbuf(BT_HDR_SIZE)) != NULL)
644 {
645 p_msg->event = BT_EVT_TO_STOP_TIMER;
646 GKI_send_msg (BTU_TASK, TASK_MBOX_0, p_msg);
647 }
648 }
649 else
650 {
651 /* if timer list is empty stop periodic GKI timer */
652 if (btu_cb.timer_queue.p_first == NULL)
653 {
654 GKI_stop_timer(TIMER_0);
655 }
656 }
657 }
658
659 #if defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0)
660 /*******************************************************************************
661 **
662 ** Function btu_start_quick_timer
663 **
664 ** Description Start a timer for the specified amount of time.
665 ** NOTE: The timeout resolution depends on including modules.
666 ** QUICK_TIMER_TICKS_PER_SEC should be used to convert from
667 ** time to ticks.
668 **
669 **
670 ** Returns void
671 **
672 *******************************************************************************/
btu_start_quick_timer(TIMER_LIST_ENT * p_tle,UINT16 type,UINT32 timeout)673 void btu_start_quick_timer (TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout)
674 {
675 BT_HDR *p_msg;
676
677 /* if timer list is currently empty, start periodic GKI timer */
678 if (btu_cb.quick_timer_queue.p_first == NULL)
679 {
680 /* script test calls stack API without posting event */
681 if (GKI_get_taskid() != BTU_TASK)
682 {
683 /* post event to start timer in BTU task */
684 if ((p_msg = (BT_HDR *)GKI_getbuf(BT_HDR_SIZE)) != NULL)
685 {
686 p_msg->event = BT_EVT_TO_START_QUICK_TIMER;
687 GKI_send_msg (BTU_TASK, TASK_MBOX_0, p_msg);
688 }
689 }
690 else
691 GKI_start_timer(TIMER_2, QUICK_TIMER_TICKS, TRUE);
692 }
693
694 GKI_remove_from_timer_list (&btu_cb.quick_timer_queue, p_tle);
695
696 p_tle->event = type;
697 p_tle->ticks = timeout; /* Save the number of ticks for the timer */
698
699 GKI_add_to_timer_list (&btu_cb.quick_timer_queue, p_tle);
700 }
701
702
703 /*******************************************************************************
704 **
705 ** Function btu_stop_quick_timer
706 **
707 ** Description Stop a timer.
708 **
709 ** Returns void
710 **
711 *******************************************************************************/
btu_stop_quick_timer(TIMER_LIST_ENT * p_tle)712 void btu_stop_quick_timer (TIMER_LIST_ENT *p_tle)
713 {
714 GKI_remove_from_timer_list (&btu_cb.quick_timer_queue, p_tle);
715
716 /* if timer list is empty stop periodic GKI timer */
717 if (btu_cb.quick_timer_queue.p_first == NULL)
718 {
719 GKI_stop_timer(TIMER_2);
720 }
721 }
722
723 /*******************************************************************************
724 **
725 ** Function btu_process_quick_timer_evt
726 **
727 ** Description Process quick timer event
728 **
729 ** Returns void
730 **
731 *******************************************************************************/
btu_process_quick_timer_evt(void)732 void btu_process_quick_timer_evt(void)
733 {
734 process_quick_timer_evt(&btu_cb.quick_timer_queue);
735
736 /* if timer list is empty stop periodic GKI timer */
737 if (btu_cb.quick_timer_queue.p_first == NULL)
738 {
739 GKI_stop_timer(TIMER_2);
740 }
741 }
742
743 /*******************************************************************************
744 **
745 ** Function process_quick_timer_evt
746 **
747 ** Description Process quick timer event
748 **
749 ** Returns void
750 **
751 *******************************************************************************/
process_quick_timer_evt(TIMER_LIST_Q * p_tlq)752 void process_quick_timer_evt(TIMER_LIST_Q *p_tlq)
753 {
754 TIMER_LIST_ENT *p_tle;
755
756 GKI_update_timer_list (p_tlq, 1);
757
758 while ((p_tlq->p_first) && (!p_tlq->p_first->ticks))
759 {
760 p_tle = p_tlq->p_first;
761 GKI_remove_from_timer_list (p_tlq, p_tle);
762
763 switch (p_tle->event)
764 {
765 case BTU_TTYPE_L2CAP_CHNL: /* monitor or retransmission timer */
766 case BTU_TTYPE_L2CAP_FCR_ACK: /* ack timer */
767 l2c_process_timeout (p_tle);
768 break;
769
770 default:
771 break;
772 }
773 }
774 }
775 #endif /* defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0) */
776
777
778
btu_register_timer(TIMER_LIST_ENT * p_tle,UINT16 type,UINT32 timeout,tBTU_TIMER_CALLBACK timer_cb)779 void btu_register_timer (TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout, tBTU_TIMER_CALLBACK timer_cb)
780 {
781 UINT8 i = 0;
782 INT8 first = -1;
783 for (; i < BTU_MAX_REG_TIMER; i++)
784 {
785 if (btu_cb.timer_reg[i].p_tle == NULL && first < 0)
786 first = i;
787 if (btu_cb.timer_reg[i].p_tle == p_tle)
788 {
789 btu_cb.timer_reg[i].timer_cb = timer_cb;
790 btu_start_timer(p_tle, type, timeout);
791 first = -1;
792 break;
793 }
794 }
795
796 if (first >= 0 && first < BTU_MAX_REG_TIMER)
797 {
798 btu_cb.timer_reg[first].timer_cb = timer_cb;
799 btu_cb.timer_reg[first].p_tle = p_tle;
800 btu_start_timer(p_tle, type, timeout);
801 }
802
803 }
804
805
btu_deregister_timer(TIMER_LIST_ENT * p_tle)806 void btu_deregister_timer(TIMER_LIST_ENT *p_tle)
807 {
808 UINT8 i = 0;
809
810 for (; i < BTU_MAX_REG_TIMER; i++)
811 {
812 if (btu_cb.timer_reg[i].p_tle == p_tle)
813 {
814 btu_stop_timer(p_tle);
815 btu_cb.timer_reg[i].timer_cb = NULL;
816 btu_cb.timer_reg[i].p_tle = NULL;
817 break;
818 }
819 }
820 }
821
btu_register_event_range(UINT16 start,tBTU_EVENT_CALLBACK event_cb)822 void btu_register_event_range (UINT16 start, tBTU_EVENT_CALLBACK event_cb)
823 {
824 UINT8 i = 0;
825 INT8 first = -1;
826
827 for (; i < BTU_MAX_REG_EVENT; i++)
828 {
829 if (btu_cb.event_reg[i].event_cb == NULL && first < 0)
830 first = i;
831
832 if (btu_cb.event_reg[i].event_range == start)
833 {
834 btu_cb.event_reg[i].event_cb = event_cb;
835
836 if (!event_cb)
837 btu_cb.event_reg[i].event_range = 0;
838
839 first = -1;
840 }
841 }
842
843 /* if not deregistering && an empty index was found in range, register */
844 if (event_cb && first >= 0 && first < BTU_MAX_REG_EVENT)
845 {
846 btu_cb.event_reg[first].event_range = start;
847 btu_cb.event_reg[first].event_cb = event_cb;
848 }
849 }
850
851
btu_deregister_event_range(UINT16 range)852 void btu_deregister_event_range (UINT16 range)
853 {
854 btu_register_event_range(range, NULL);
855 }
856
857 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
858 /*******************************************************************************
859 **
860 ** Function btu_check_bt_sleep
861 **
862 ** Description This function is called to check if controller can go to sleep.
863 **
864 ** Returns void
865 **
866 *******************************************************************************/
btu_check_bt_sleep(void)867 void btu_check_bt_sleep (void)
868 {
869 if ((btu_cb.hci_cmd_cb[LOCAL_BR_EDR_CONTROLLER_ID].cmd_cmpl_q.count == 0)
870 &&(btu_cb.hci_cmd_cb[LOCAL_BR_EDR_CONTROLLER_ID].cmd_xmit_q.count == 0))
871 {
872 if (l2cb.controller_xmit_window == l2cb.num_lm_acl_bufs)
873 {
874 /* enable dev to sleep in the cmd cplt and cmd status only and num cplt packet */
875 HCI_LP_ALLOW_BT_DEVICE_SLEEP();
876 }
877 }
878 }
879 #endif
880