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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 *******************************************************************************/ 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 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 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 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 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 *******************************************************************************/ 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
