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 GKI_disable();
584 /* if timer list is currently empty, start periodic GKI timer */
585 if (btu_cb.timer_queue.p_first == NULL)
586 {
587 /* if timer starts on other than BTU task */
588 if (GKI_get_taskid() != BTU_TASK)
589 {
590 /* post event to start timer in BTU task */
591 if ((p_msg = (BT_HDR *)GKI_getbuf(BT_HDR_SIZE)) != NULL)
592 {
593 p_msg->event = BT_EVT_TO_START_TIMER;
594 GKI_send_msg (BTU_TASK, TASK_MBOX_0, p_msg);
595 }
596 }
597 else
598 {
599 /* Start free running 1 second timer for list management */
600 GKI_start_timer (TIMER_0, GKI_SECS_TO_TICKS (1), TRUE);
601 }
602 }
603
604 GKI_remove_from_timer_list (&btu_cb.timer_queue, p_tle);
605
606 p_tle->event = type;
607 p_tle->ticks = timeout; /* Save the number of seconds for the timer */
608
609 GKI_add_to_timer_list (&btu_cb.timer_queue, p_tle);
610 GKI_enable();
611 }
612
613 /*******************************************************************************
614 **
615 ** Function btu_remaining_time
616 **
617 ** Description Return amount of time to expire
618 **
619 ** Returns time in second
620 **
621 *******************************************************************************/
btu_remaining_time(TIMER_LIST_ENT * p_tle)622 UINT32 btu_remaining_time (TIMER_LIST_ENT *p_tle)
623 {
624 return(GKI_get_remaining_ticks (&btu_cb.timer_queue, p_tle));
625 }
626
627 /*******************************************************************************
628 **
629 ** Function btu_stop_timer
630 **
631 ** Description Stop a timer.
632 **
633 ** Returns void
634 **
635 *******************************************************************************/
btu_stop_timer(TIMER_LIST_ENT * p_tle)636 void btu_stop_timer (TIMER_LIST_ENT *p_tle)
637 {
638 BT_HDR *p_msg;
639 GKI_disable();
640 GKI_remove_from_timer_list (&btu_cb.timer_queue, p_tle);
641
642 /* if timer is stopped on other than BTU task */
643 if (GKI_get_taskid() != BTU_TASK)
644 {
645 /* post event to stop timer in BTU task */
646 if ((p_msg = (BT_HDR *)GKI_getbuf(BT_HDR_SIZE)) != NULL)
647 {
648 p_msg->event = BT_EVT_TO_STOP_TIMER;
649 GKI_send_msg (BTU_TASK, TASK_MBOX_0, p_msg);
650 }
651 }
652 else
653 {
654 /* if timer list is empty stop periodic GKI timer */
655 if (btu_cb.timer_queue.p_first == NULL)
656 {
657 GKI_stop_timer(TIMER_0);
658 }
659 }
660 GKI_enable();
661 }
662
663 #if defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0)
664 /*******************************************************************************
665 **
666 ** Function btu_start_quick_timer
667 **
668 ** Description Start a timer for the specified amount of time.
669 ** NOTE: The timeout resolution depends on including modules.
670 ** QUICK_TIMER_TICKS_PER_SEC should be used to convert from
671 ** time to ticks.
672 **
673 **
674 ** Returns void
675 **
676 *******************************************************************************/
btu_start_quick_timer(TIMER_LIST_ENT * p_tle,UINT16 type,UINT32 timeout)677 void btu_start_quick_timer (TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout)
678 {
679 BT_HDR *p_msg;
680
681 GKI_disable();
682 /* if timer list is currently empty, start periodic GKI timer */
683 if (btu_cb.quick_timer_queue.p_first == NULL)
684 {
685 /* script test calls stack API without posting event */
686 if (GKI_get_taskid() != BTU_TASK)
687 {
688 /* post event to start timer in BTU task */
689 if ((p_msg = (BT_HDR *)GKI_getbuf(BT_HDR_SIZE)) != NULL)
690 {
691 p_msg->event = BT_EVT_TO_START_QUICK_TIMER;
692 GKI_send_msg (BTU_TASK, TASK_MBOX_0, p_msg);
693 }
694 }
695 else
696 GKI_start_timer(TIMER_2, QUICK_TIMER_TICKS, TRUE);
697 }
698
699 GKI_remove_from_timer_list (&btu_cb.quick_timer_queue, p_tle);
700
701 p_tle->event = type;
702 p_tle->ticks = timeout; /* Save the number of ticks for the timer */
703
704 GKI_add_to_timer_list (&btu_cb.quick_timer_queue, p_tle);
705 GKI_enable();
706 }
707
708
709 /*******************************************************************************
710 **
711 ** Function btu_stop_quick_timer
712 **
713 ** Description Stop a timer.
714 **
715 ** Returns void
716 **
717 *******************************************************************************/
btu_stop_quick_timer(TIMER_LIST_ENT * p_tle)718 void btu_stop_quick_timer (TIMER_LIST_ENT *p_tle)
719 {
720 GKI_disable();
721 GKI_remove_from_timer_list (&btu_cb.quick_timer_queue, p_tle);
722
723 /* if timer list is empty stop periodic GKI timer */
724 if (btu_cb.quick_timer_queue.p_first == NULL)
725 {
726 GKI_stop_timer(TIMER_2);
727 }
728 GKI_enable();
729 }
730
731 /*******************************************************************************
732 **
733 ** Function btu_process_quick_timer_evt
734 **
735 ** Description Process quick timer event
736 **
737 ** Returns void
738 **
739 *******************************************************************************/
btu_process_quick_timer_evt(void)740 void btu_process_quick_timer_evt(void)
741 {
742 process_quick_timer_evt(&btu_cb.quick_timer_queue);
743
744 /* if timer list is empty stop periodic GKI timer */
745 if (btu_cb.quick_timer_queue.p_first == NULL)
746 {
747 GKI_stop_timer(TIMER_2);
748 }
749 }
750
751 /*******************************************************************************
752 **
753 ** Function process_quick_timer_evt
754 **
755 ** Description Process quick timer event
756 **
757 ** Returns void
758 **
759 *******************************************************************************/
process_quick_timer_evt(TIMER_LIST_Q * p_tlq)760 void process_quick_timer_evt(TIMER_LIST_Q *p_tlq)
761 {
762 TIMER_LIST_ENT *p_tle;
763
764 GKI_update_timer_list (p_tlq, 1);
765
766 while ((p_tlq->p_first) && (!p_tlq->p_first->ticks))
767 {
768 p_tle = p_tlq->p_first;
769 GKI_remove_from_timer_list (p_tlq, p_tle);
770
771 switch (p_tle->event)
772 {
773 case BTU_TTYPE_L2CAP_CHNL: /* monitor or retransmission timer */
774 case BTU_TTYPE_L2CAP_FCR_ACK: /* ack timer */
775 l2c_process_timeout (p_tle);
776 break;
777
778 default:
779 break;
780 }
781 }
782 }
783 #endif /* defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0) */
784
785
786
btu_register_timer(TIMER_LIST_ENT * p_tle,UINT16 type,UINT32 timeout,tBTU_TIMER_CALLBACK timer_cb)787 void btu_register_timer (TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout, tBTU_TIMER_CALLBACK timer_cb)
788 {
789 UINT8 i = 0;
790 INT8 first = -1;
791 for (; i < BTU_MAX_REG_TIMER; i++)
792 {
793 if (btu_cb.timer_reg[i].p_tle == NULL && first < 0)
794 first = i;
795 if (btu_cb.timer_reg[i].p_tle == p_tle)
796 {
797 btu_cb.timer_reg[i].timer_cb = timer_cb;
798 btu_start_timer(p_tle, type, timeout);
799 first = -1;
800 break;
801 }
802 }
803
804 if (first >= 0 && first < BTU_MAX_REG_TIMER)
805 {
806 btu_cb.timer_reg[first].timer_cb = timer_cb;
807 btu_cb.timer_reg[first].p_tle = p_tle;
808 btu_start_timer(p_tle, type, timeout);
809 }
810
811 }
812
813
btu_deregister_timer(TIMER_LIST_ENT * p_tle)814 void btu_deregister_timer(TIMER_LIST_ENT *p_tle)
815 {
816 UINT8 i = 0;
817
818 for (; i < BTU_MAX_REG_TIMER; i++)
819 {
820 if (btu_cb.timer_reg[i].p_tle == p_tle)
821 {
822 btu_stop_timer(p_tle);
823 btu_cb.timer_reg[i].timer_cb = NULL;
824 btu_cb.timer_reg[i].p_tle = NULL;
825 break;
826 }
827 }
828 }
829
btu_register_event_range(UINT16 start,tBTU_EVENT_CALLBACK event_cb)830 void btu_register_event_range (UINT16 start, tBTU_EVENT_CALLBACK event_cb)
831 {
832 UINT8 i = 0;
833 INT8 first = -1;
834
835 for (; i < BTU_MAX_REG_EVENT; i++)
836 {
837 if (btu_cb.event_reg[i].event_cb == NULL && first < 0)
838 first = i;
839
840 if (btu_cb.event_reg[i].event_range == start)
841 {
842 btu_cb.event_reg[i].event_cb = event_cb;
843
844 if (!event_cb)
845 btu_cb.event_reg[i].event_range = 0;
846
847 first = -1;
848 }
849 }
850
851 /* if not deregistering && an empty index was found in range, register */
852 if (event_cb && first >= 0 && first < BTU_MAX_REG_EVENT)
853 {
854 btu_cb.event_reg[first].event_range = start;
855 btu_cb.event_reg[first].event_cb = event_cb;
856 }
857 }
858
859
btu_deregister_event_range(UINT16 range)860 void btu_deregister_event_range (UINT16 range)
861 {
862 btu_register_event_range(range, NULL);
863 }
864
865 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
866 /*******************************************************************************
867 **
868 ** Function btu_check_bt_sleep
869 **
870 ** Description This function is called to check if controller can go to sleep.
871 **
872 ** Returns void
873 **
874 *******************************************************************************/
btu_check_bt_sleep(void)875 void btu_check_bt_sleep (void)
876 {
877 if ((btu_cb.hci_cmd_cb[LOCAL_BR_EDR_CONTROLLER_ID].cmd_cmpl_q.count == 0)
878 &&(btu_cb.hci_cmd_cb[LOCAL_BR_EDR_CONTROLLER_ID].cmd_xmit_q.count == 0))
879 {
880 if (l2cb.controller_xmit_window == l2cb.num_lm_acl_bufs)
881 {
882 /* enable dev to sleep in the cmd cplt and cmd status only and num cplt packet */
883 HCI_LP_ALLOW_BT_DEVICE_SLEEP();
884 }
885 }
886 }
887 #endif
888