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 GKI_wait(0xFFFF, 0); 173 #endif 174 /* Initialize the mandatory core stack control blocks 175 (BTU, BTM, L2CAP, and SDP) 176 */ 177 btu_init_core(); 178 179 /* Initialize any optional stack components */ 180 BTE_InitStack(); 181 182 #if (defined(BTU_BTA_INCLUDED) && BTU_BTA_INCLUDED == TRUE) 183 bta_sys_init(); 184 #endif 185 186 /* Initialise platform trace levels at this point as BTE_InitStack() and bta_sys_init() 187 * reset the control blocks and preset the trace level with XXX_INITIAL_TRACE_LEVEL 188 */ 189 #if ( BT_USE_TRACES==TRUE ) 190 BTE_InitTraceLevels(); 191 #endif 192 193 /* Send a startup evt message to BTIF_TASK to kickstart the init procedure */ 194 GKI_send_event(BTIF_TASK, BT_EVT_TRIGGER_STACK_INIT); 195 196 raise_priority_a2dp(TASK_HIGH_BTU); 197 198 /* Wait for, and process, events */ 199 for (;;) 200 { 201 event = GKI_wait (0xFFFF, 0); 202 203 if (event & TASK_MBOX_0_EVT_MASK) 204 { 205 /* Process all messages in the queue */ 206 while ((p_msg = (BT_HDR *) GKI_read_mbox (BTU_HCI_RCV_MBOX)) != NULL) 207 { 208 /* Determine the input message type. */ 209 switch (p_msg->event & BT_EVT_MASK) 210 { 211 case BT_EVT_TO_BTU_HCI_ACL: 212 /* All Acl Data goes to L2CAP */ 213 l2c_rcv_acl_data (p_msg); 214 break; 215 216 case BT_EVT_TO_BTU_L2C_SEG_XMIT: 217 /* L2CAP segment transmit complete */ 218 l2c_link_segments_xmitted (p_msg); 219 break; 220 221 case BT_EVT_TO_BTU_HCI_SCO: 222 #if BTM_SCO_INCLUDED == TRUE 223 btm_route_sco_data (p_msg); 224 break; 225 #endif 226 227 case BT_EVT_TO_BTU_HCI_EVT: 228 btu_hcif_process_event ((UINT8)(p_msg->event & BT_SUB_EVT_MASK), p_msg); 229 GKI_freebuf(p_msg); 230 231 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 232 /* If host receives events which it doesn't response to, */ 233 /* host should start idle timer to enter sleep mode. */ 234 btu_check_bt_sleep (); 235 #endif 236 break; 237 238 case BT_EVT_TO_BTU_HCI_CMD: 239 btu_hcif_send_cmd ((UINT8)(p_msg->event & BT_SUB_EVT_MASK), p_msg); 240 break; 241 242 #if (defined(OBX_INCLUDED) && OBX_INCLUDED == TRUE) 243 #if (defined(OBX_SERVER_INCLUDED) && OBX_SERVER_INCLUDED == TRUE) 244 case BT_EVT_TO_OBX_SR_MSG: 245 obx_sr_proc_evt((tOBX_PORT_EVT *)(p_msg + 1)); 246 GKI_freebuf (p_msg); 247 break; 248 249 case BT_EVT_TO_OBX_SR_L2C_MSG: 250 obx_sr_proc_l2c_evt((tOBX_L2C_EVT_MSG *)(p_msg + 1)); 251 GKI_freebuf (p_msg); 252 break; 253 #endif 254 255 #if (defined(OBX_CLIENT_INCLUDED) && OBX_CLIENT_INCLUDED == TRUE) 256 case BT_EVT_TO_OBX_CL_MSG: 257 obx_cl_proc_evt((tOBX_PORT_EVT *)(p_msg + 1)); 258 GKI_freebuf (p_msg); 259 break; 260 261 case BT_EVT_TO_OBX_CL_L2C_MSG: 262 obx_cl_proc_l2c_evt((tOBX_L2C_EVT_MSG *)(p_msg + 1)); 263 GKI_freebuf (p_msg); 264 break; 265 #endif 266 267 #if (defined(BIP_INCLUDED) && BIP_INCLUDED == TRUE) 268 case BT_EVT_TO_BIP_CMDS : 269 bip_proc_btu_event(p_msg); 270 GKI_freebuf (p_msg); 271 break; 272 #endif /* BIP */ 273 #if (BPP_SND_INCLUDED == TRUE || BPP_INCLUDED == TRUE) 274 case BT_EVT_TO_BPP_PR_CMDS: 275 bpp_pr_proc_event(p_msg); 276 GKI_freebuf (p_msg); 277 break; 278 case BT_EVT_TO_BPP_SND_CMDS: 279 bpp_snd_proc_event(p_msg); 280 GKI_freebuf (p_msg); 281 break; 282 283 #endif /* BPP */ 284 285 #endif /* OBX */ 286 287 #if (defined(SAP_SERVER_INCLUDED) && SAP_SERVER_INCLUDED == TRUE) 288 case BT_EVT_TO_BTU_SAP : 289 sap_proc_btu_event(p_msg); 290 GKI_freebuf (p_msg); 291 break; 292 #endif /* SAP */ 293 #if (defined(GAP_CONN_INCLUDED) && GAP_CONN_INCLUDED == TRUE && GAP_CONN_POST_EVT_INCLUDED == TRUE) 294 case BT_EVT_TO_GAP_MSG : 295 gap_proc_btu_event(p_msg); 296 GKI_freebuf (p_msg); 297 break; 298 #endif 299 case BT_EVT_TO_START_TIMER : 300 /* Start free running 1 second timer for list management */ 301 GKI_start_timer (TIMER_0, GKI_SECS_TO_TICKS (1), TRUE); 302 GKI_freebuf (p_msg); 303 break; 304 305 #if defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0) 306 case BT_EVT_TO_START_QUICK_TIMER : 307 GKI_start_timer (TIMER_2, QUICK_TIMER_TICKS, TRUE); 308 GKI_freebuf (p_msg); 309 break; 310 #endif 311 312 default: 313 i = 0; 314 mask = (UINT16) (p_msg->event & BT_EVT_MASK); 315 handled = FALSE; 316 317 for (; !handled && i < BTU_MAX_REG_EVENT; i++) 318 { 319 if (btu_cb.event_reg[i].event_cb == NULL) 320 continue; 321 322 if (mask == btu_cb.event_reg[i].event_range) 323 { 324 if (btu_cb.event_reg[i].event_cb) 325 { 326 btu_cb.event_reg[i].event_cb(p_msg); 327 handled = TRUE; 328 } 329 } 330 } 331 332 if (handled == FALSE) 333 GKI_freebuf (p_msg); 334 335 break; 336 } 337 } 338 } 339 340 341 if (event & TIMER_0_EVT_MASK) 342 { 343 TIMER_LIST_ENT *p_tle; 344 345 GKI_update_timer_list (&btu_cb.timer_queue, 1); 346 347 while ((btu_cb.timer_queue.p_first) && (!btu_cb.timer_queue.p_first->ticks)) 348 { 349 p_tle = btu_cb.timer_queue.p_first; 350 GKI_remove_from_timer_list (&btu_cb.timer_queue, p_tle); 351 352 switch (p_tle->event) 353 { 354 case BTU_TTYPE_BTM_DEV_CTL: 355 btm_dev_timeout(p_tle); 356 break; 357 358 case BTU_TTYPE_BTM_ACL: 359 btm_acl_timeout(p_tle); 360 break; 361 362 case BTU_TTYPE_L2CAP_LINK: 363 case BTU_TTYPE_L2CAP_CHNL: 364 case BTU_TTYPE_L2CAP_HOLD: 365 case BTU_TTYPE_L2CAP_INFO: 366 case BTU_TTYPE_L2CAP_FCR_ACK: 367 368 l2c_process_timeout (p_tle); 369 break; 370 371 case BTU_TTYPE_SDP: 372 sdp_conn_timeout ((tCONN_CB *)p_tle->param); 373 break; 374 375 case BTU_TTYPE_BTM_RMT_NAME: 376 btm_inq_rmt_name_failed(); 377 break; 378 379 #if (defined(RFCOMM_INCLUDED) && RFCOMM_INCLUDED == TRUE) 380 case BTU_TTYPE_RFCOMM_MFC: 381 case BTU_TTYPE_RFCOMM_PORT: 382 rfcomm_process_timeout (p_tle); 383 break; 384 385 #endif /* If defined(RFCOMM_INCLUDED) && RFCOMM_INCLUDED == TRUE */ 386 387 #if ((defined(BNEP_INCLUDED) && BNEP_INCLUDED == TRUE)) 388 case BTU_TTYPE_BNEP: 389 bnep_process_timeout(p_tle); 390 break; 391 #endif 392 393 394 #if (defined(AVDT_INCLUDED) && AVDT_INCLUDED == TRUE) 395 case BTU_TTYPE_AVDT_CCB_RET: 396 case BTU_TTYPE_AVDT_CCB_RSP: 397 case BTU_TTYPE_AVDT_CCB_IDLE: 398 case BTU_TTYPE_AVDT_SCB_TC: 399 avdt_process_timeout(p_tle); 400 break; 401 #endif 402 403 #if (defined(OBX_INCLUDED) && OBX_INCLUDED == TRUE) 404 #if (defined(OBX_CLIENT_INCLUDED) && OBX_CLIENT_INCLUDED == TRUE) 405 case BTU_TTYPE_OBX_CLIENT_TO: 406 obx_cl_timeout(p_tle); 407 break; 408 #endif 409 #if (defined(OBX_SERVER_INCLUDED) && OBX_SERVER_INCLUDED == TRUE) 410 case BTU_TTYPE_OBX_SERVER_TO: 411 obx_sr_timeout(p_tle); 412 break; 413 414 case BTU_TTYPE_OBX_SVR_SESS_TO: 415 obx_sr_sess_timeout(p_tle); 416 break; 417 #endif 418 #endif 419 420 #if (defined(SAP_SERVER_INCLUDED) && SAP_SERVER_INCLUDED == TRUE) 421 case BTU_TTYPE_SAP_TO: 422 sap_process_timeout(p_tle); 423 break; 424 #endif 425 426 case BTU_TTYPE_BTU_CMD_CMPL: 427 btu_hcif_cmd_timeout((UINT8)(p_tle->event - BTU_TTYPE_BTU_CMD_CMPL)); 428 break; 429 430 #if (defined(HID_HOST_INCLUDED) && HID_HOST_INCLUDED == TRUE) 431 case BTU_TTYPE_HID_HOST_REPAGE_TO : 432 hidh_proc_repage_timeout(p_tle); 433 break; 434 #endif 435 436 #if (defined(BLE_INCLUDED) && BLE_INCLUDED == TRUE) 437 case BTU_TTYPE_BLE_INQUIRY: 438 case BTU_TTYPE_BLE_GAP_LIM_DISC: 439 case BTU_TTYPE_BLE_RANDOM_ADDR: 440 btm_ble_timeout(p_tle); 441 break; 442 443 case BTU_TTYPE_BLE_SCAN_PARAM_IDLE: 444 btm_ble_scan_param_idle(); 445 break; 446 447 case BTU_TTYPE_ATT_WAIT_FOR_RSP: 448 gatt_rsp_timeout(p_tle); 449 break; 450 451 case BTU_TTYPE_ATT_WAIT_FOR_IND_ACK: 452 gatt_ind_ack_timeout(p_tle); 453 break; 454 #if (defined(SMP_INCLUDED) && SMP_INCLUDED == TRUE) 455 case BTU_TTYPE_SMP_PAIRING_CMD: 456 smp_rsp_timeout(p_tle); 457 break; 458 #endif 459 460 #endif 461 462 #if (MCA_INCLUDED == TRUE) 463 case BTU_TTYPE_MCA_CCB_RSP: 464 mca_process_timeout(p_tle); 465 break; 466 #endif 467 case BTU_TTYPE_USER_FUNC: 468 { 469 tUSER_TIMEOUT_FUNC *p_uf = (tUSER_TIMEOUT_FUNC *)p_tle->param; 470 (*p_uf)(p_tle); 471 } 472 break; 473 474 default: 475 i = 0; 476 handled = FALSE; 477 478 for (; !handled && i < BTU_MAX_REG_TIMER; i++) 479 { 480 if (btu_cb.timer_reg[i].timer_cb == NULL) 481 continue; 482 if (btu_cb.timer_reg[i].p_tle == p_tle) 483 { 484 btu_cb.timer_reg[i].timer_cb(p_tle); 485 handled = TRUE; 486 } 487 } 488 break; 489 } 490 } 491 492 /* if timer list is empty stop periodic GKI timer */ 493 if (btu_cb.timer_queue.p_first == NULL) 494 { 495 GKI_stop_timer(TIMER_0); 496 } 497 } 498 499 #if defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0) 500 if (event & TIMER_2_EVT_MASK) 501 { 502 btu_process_quick_timer_evt(); 503 } 504 #endif 505 506 507 #if (RPC_INCLUDED == TRUE) 508 /* if RPC message queue event */ 509 if (event & RPCGEN_MSG_EVT) 510 { 511 if ((p_msg = (BT_HDR *) GKI_read_mbox(RPCGEN_MSG_MBOX)) != NULL) 512 RPCT_RpcgenMsg(p_msg); /* handle RPC message queue */ 513 } 514 #endif 515 516 #if (defined(BTU_BTA_INCLUDED) && BTU_BTA_INCLUDED == TRUE) 517 if (event & TASK_MBOX_2_EVT_MASK) 518 { 519 while ((p_msg = (BT_HDR *) GKI_read_mbox(TASK_MBOX_2)) != NULL) 520 { 521 bta_sys_event(p_msg); 522 } 523 } 524 525 if (event & TIMER_1_EVT_MASK) 526 { 527 bta_sys_timer_update(); 528 } 529 #endif 530 531 if (event & EVENT_MASK(APPL_EVT_7)) 532 break; 533 } 534 535 return(0); 536 } 537 538 /******************************************************************************* 539 ** 540 ** Function btu_start_timer 541 ** 542 ** Description Start a timer for the specified amount of time. 543 ** NOTE: The timeout resolution is in SECONDS! (Even 544 ** though the timer structure field is ticks) 545 ** 546 ** Returns void 547 ** 548 *******************************************************************************/ 549 void btu_start_timer (TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout) 550 { 551 BT_HDR *p_msg; 552 /* if timer list is currently empty, start periodic GKI timer */ 553 if (btu_cb.timer_queue.p_first == NULL) 554 { 555 /* if timer starts on other than BTU task */ 556 if (GKI_get_taskid() != BTU_TASK) 557 { 558 /* post event to start timer in BTU task */ 559 if ((p_msg = (BT_HDR *)GKI_getbuf(BT_HDR_SIZE)) != NULL) 560 { 561 p_msg->event = BT_EVT_TO_START_TIMER; 562 GKI_send_msg (BTU_TASK, TASK_MBOX_0, p_msg); 563 } 564 } 565 else 566 { 567 /* Start free running 1 second timer for list management */ 568 GKI_start_timer (TIMER_0, GKI_SECS_TO_TICKS (1), TRUE); 569 } 570 } 571 572 GKI_remove_from_timer_list (&btu_cb.timer_queue, p_tle); 573 574 p_tle->event = type; 575 p_tle->ticks = timeout; /* Save the number of seconds for the timer */ 576 577 GKI_add_to_timer_list (&btu_cb.timer_queue, p_tle); 578 } 579 580 /******************************************************************************* 581 ** 582 ** Function btu_remaining_time 583 ** 584 ** Description Return amount of time to expire 585 ** 586 ** Returns time in second 587 ** 588 *******************************************************************************/ 589 UINT32 btu_remaining_time (TIMER_LIST_ENT *p_tle) 590 { 591 return(GKI_get_remaining_ticks (&btu_cb.timer_queue, p_tle)); 592 } 593 594 /******************************************************************************* 595 ** 596 ** Function btu_stop_timer 597 ** 598 ** Description Stop a timer. 599 ** 600 ** Returns void 601 ** 602 *******************************************************************************/ 603 void btu_stop_timer (TIMER_LIST_ENT *p_tle) 604 { 605 GKI_remove_from_timer_list (&btu_cb.timer_queue, p_tle); 606 607 /* if timer list is empty stop periodic GKI timer */ 608 if (btu_cb.timer_queue.p_first == NULL) 609 { 610 GKI_stop_timer(TIMER_0); 611 } 612 613 } 614 615 #if defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0) 616 /******************************************************************************* 617 ** 618 ** Function btu_start_quick_timer 619 ** 620 ** Description Start a timer for the specified amount of time. 621 ** NOTE: The timeout resolution depends on including modules. 622 ** QUICK_TIMER_TICKS_PER_SEC should be used to convert from 623 ** time to ticks. 624 ** 625 ** 626 ** Returns void 627 ** 628 *******************************************************************************/ 629 void btu_start_quick_timer (TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout) 630 { 631 BT_HDR *p_msg; 632 633 /* if timer list is currently empty, start periodic GKI timer */ 634 if (btu_cb.quick_timer_queue.p_first == NULL) 635 { 636 /* script test calls stack API without posting event */ 637 if (GKI_get_taskid() != BTU_TASK) 638 { 639 /* post event to start timer in BTU task */ 640 if ((p_msg = (BT_HDR *)GKI_getbuf(BT_HDR_SIZE)) != NULL) 641 { 642 p_msg->event = BT_EVT_TO_START_QUICK_TIMER; 643 GKI_send_msg (BTU_TASK, TASK_MBOX_0, p_msg); 644 } 645 } 646 else 647 GKI_start_timer(TIMER_2, QUICK_TIMER_TICKS, TRUE); 648 } 649 650 GKI_remove_from_timer_list (&btu_cb.quick_timer_queue, p_tle); 651 652 p_tle->event = type; 653 p_tle->ticks = timeout; /* Save the number of ticks for the timer */ 654 655 GKI_add_to_timer_list (&btu_cb.quick_timer_queue, p_tle); 656 } 657 658 659 /******************************************************************************* 660 ** 661 ** Function btu_stop_quick_timer 662 ** 663 ** Description Stop a timer. 664 ** 665 ** Returns void 666 ** 667 *******************************************************************************/ 668 void btu_stop_quick_timer (TIMER_LIST_ENT *p_tle) 669 { 670 GKI_remove_from_timer_list (&btu_cb.quick_timer_queue, p_tle); 671 672 /* if timer list is empty stop periodic GKI timer */ 673 if (btu_cb.quick_timer_queue.p_first == NULL) 674 { 675 GKI_stop_timer(TIMER_2); 676 } 677 } 678 679 /******************************************************************************* 680 ** 681 ** Function btu_process_quick_timer_evt 682 ** 683 ** Description Process quick timer event 684 ** 685 ** Returns void 686 ** 687 *******************************************************************************/ 688 void btu_process_quick_timer_evt(void) 689 { 690 process_quick_timer_evt(&btu_cb.quick_timer_queue); 691 692 /* if timer list is empty stop periodic GKI timer */ 693 if (btu_cb.quick_timer_queue.p_first == NULL) 694 { 695 GKI_stop_timer(TIMER_2); 696 } 697 } 698 699 /******************************************************************************* 700 ** 701 ** Function process_quick_timer_evt 702 ** 703 ** Description Process quick timer event 704 ** 705 ** Returns void 706 ** 707 *******************************************************************************/ 708 void process_quick_timer_evt(TIMER_LIST_Q *p_tlq) 709 { 710 TIMER_LIST_ENT *p_tle; 711 712 GKI_update_timer_list (p_tlq, 1); 713 714 while ((p_tlq->p_first) && (!p_tlq->p_first->ticks)) 715 { 716 p_tle = p_tlq->p_first; 717 GKI_remove_from_timer_list (p_tlq, p_tle); 718 719 switch (p_tle->event) 720 { 721 case BTU_TTYPE_L2CAP_CHNL: /* monitor or retransmission timer */ 722 case BTU_TTYPE_L2CAP_FCR_ACK: /* ack timer */ 723 l2c_process_timeout (p_tle); 724 break; 725 726 default: 727 break; 728 } 729 } 730 } 731 #endif /* defined(QUICK_TIMER_TICKS_PER_SEC) && (QUICK_TIMER_TICKS_PER_SEC > 0) */ 732 733 734 735 void btu_register_timer (TIMER_LIST_ENT *p_tle, UINT16 type, UINT32 timeout, tBTU_TIMER_CALLBACK timer_cb) 736 { 737 UINT8 i = 0; 738 INT8 first = -1; 739 for (; i < BTU_MAX_REG_TIMER; i++) 740 { 741 if (btu_cb.timer_reg[i].p_tle == NULL && first < 0) 742 first = i; 743 if (btu_cb.timer_reg[i].p_tle == p_tle) 744 { 745 btu_cb.timer_reg[i].timer_cb = timer_cb; 746 btu_start_timer(p_tle, type, timeout); 747 first = -1; 748 break; 749 } 750 } 751 752 if (first >= 0 && first < BTU_MAX_REG_TIMER) 753 { 754 btu_cb.timer_reg[first].timer_cb = timer_cb; 755 btu_cb.timer_reg[first].p_tle = p_tle; 756 btu_start_timer(p_tle, type, timeout); 757 } 758 759 } 760 761 762 void btu_deregister_timer(TIMER_LIST_ENT *p_tle) 763 { 764 UINT8 i = 0; 765 766 for (; i < BTU_MAX_REG_TIMER; i++) 767 { 768 if (btu_cb.timer_reg[i].p_tle == p_tle) 769 { 770 btu_stop_timer(p_tle); 771 btu_cb.timer_reg[i].timer_cb = NULL; 772 btu_cb.timer_reg[i].p_tle = NULL; 773 break; 774 } 775 } 776 } 777 778 void btu_register_event_range (UINT16 start, tBTU_EVENT_CALLBACK event_cb) 779 { 780 UINT8 i = 0; 781 INT8 first = -1; 782 783 for (; i < BTU_MAX_REG_EVENT; i++) 784 { 785 if (btu_cb.event_reg[i].event_cb == NULL && first < 0) 786 first = i; 787 788 if (btu_cb.event_reg[i].event_range == start) 789 { 790 btu_cb.event_reg[i].event_cb = event_cb; 791 792 if (!event_cb) 793 btu_cb.event_reg[i].event_range = 0; 794 795 first = -1; 796 } 797 } 798 799 /* if not deregistering && an empty index was found in range, register */ 800 if (event_cb && first >= 0 && first < BTU_MAX_REG_EVENT) 801 { 802 btu_cb.event_reg[first].event_range = start; 803 btu_cb.event_reg[first].event_cb = event_cb; 804 } 805 } 806 807 808 void btu_deregister_event_range (UINT16 range) 809 { 810 btu_register_event_range(range, NULL); 811 } 812 813 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 814 /******************************************************************************* 815 ** 816 ** Function btu_check_bt_sleep 817 ** 818 ** Description This function is called to check if controller can go to sleep. 819 ** 820 ** Returns void 821 ** 822 *******************************************************************************/ 823 void btu_check_bt_sleep (void) 824 { 825 if ((btu_cb.hci_cmd_cb[LOCAL_BR_EDR_CONTROLLER_ID].cmd_cmpl_q.count == 0) 826 &&(btu_cb.hci_cmd_cb[LOCAL_BR_EDR_CONTROLLER_ID].cmd_xmit_q.count == 0)) 827 { 828 if (l2cb.controller_xmit_window == l2cb.num_lm_acl_bufs) 829 { 830 /* enable dev to sleep in the cmd cplt and cmd status only and num cplt packet */ 831 HCI_LP_ALLOW_BT_DEVICE_SLEEP(); 832 } 833 } 834 } 835 #endif 836
