1 /****************************************************************************** 2 * 3 * Copyright (C) 2003-2012 Broadcom Corporation 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 /****************************************************************************** 20 * 21 * This file contains the action functions for device manager state 22 * machine. 23 * 24 ******************************************************************************/ 25 26 #include "gki.h" 27 #include "bd.h" 28 #include "bta_sys.h" 29 #include "bta_api.h" 30 #include "bta_dm_int.h" 31 #include "btm_api.h" 32 33 #include <string.h> 34 35 36 static void bta_dm_pm_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr); 37 static void bta_dm_pm_set_mode(BD_ADDR peer_addr, BOOLEAN timed_out ); 38 static void bta_dm_pm_timer_cback(void *p_tle); 39 static void bta_dm_pm_btm_cback(BD_ADDR bd_addr, tBTM_PM_STATUS status, UINT16 value, UINT8 hci_status); 40 static BOOLEAN bta_dm_pm_park(BD_ADDR peer_addr); 41 static BOOLEAN bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE *p_peer_dev, UINT8 index); 42 static BOOLEAN bta_dm_pm_is_sco_active (); 43 static void bta_dm_pm_hid_check(BOOLEAN bScoActive); 44 static void bta_dm_pm_set_sniff_policy(tBTA_DM_PEER_DEVICE *p_dev, BOOLEAN bDisable); 45 46 #if (BTM_SSR_INCLUDED == TRUE) 47 #if (defined BTA_HH_INCLUDED && BTA_HH_INCLUDED == TRUE) 48 #include "../hh/bta_hh_int.h" 49 /* BTA_DM_PM_SSR1 will be dedicated for HH SSR setting entry, no other profile can use it */ 50 #define BTA_DM_PM_SSR_HH BTA_DM_PM_SSR1 51 #endif 52 static void bta_dm_pm_ssr(BD_ADDR peer_addr); 53 #endif 54 55 tBTA_DM_CONNECTED_SRVCS bta_dm_conn_srvcs; 56 57 58 /******************************************************************************* 59 ** 60 ** Function bta_dm_init_pm 61 ** 62 ** Description Initialises the BT low power manager 63 ** 64 ** 65 ** Returns void 66 ** 67 *******************************************************************************/ 68 void bta_dm_init_pm(void) 69 { 70 71 memset(&bta_dm_conn_srvcs, 0x00, sizeof(bta_dm_conn_srvcs)); 72 73 /* if there are no power manger entries, so not register */ 74 if(p_bta_dm_pm_cfg[0].app_id != 0) 75 { 76 bta_sys_pm_register((tBTA_SYS_CONN_CBACK*)bta_dm_pm_cback); 77 78 BTM_PmRegister((BTM_PM_REG_SET | BTM_PM_REG_NOTIF), &bta_dm_cb.pm_id, 79 bta_dm_pm_btm_cback); 80 } 81 82 83 } 84 85 86 /******************************************************************************* 87 ** 88 ** Function bta_dm_disable_pm 89 ** 90 ** Description Disable PM 91 ** 92 ** 93 ** Returns void 94 ** 95 *******************************************************************************/ 96 void bta_dm_disable_pm(void) 97 { 98 UINT8 i; 99 100 bta_sys_pm_register(NULL); 101 BTM_PmRegister( BTM_PM_DEREG, &bta_dm_cb.pm_id, NULL); 102 103 /* Need to stop all active timers. */ 104 for(i=0; i<BTA_DM_NUM_PM_TIMER; i++) 105 { 106 if(bta_dm_cb.pm_timer[i].in_use) 107 { 108 APPL_TRACE_DEBUG("stop dm_pm_timer:%d", i); 109 bta_sys_stop_timer(&bta_dm_cb.pm_timer[i].timer); 110 bta_dm_cb.pm_timer[i].in_use = FALSE; 111 } 112 } 113 } 114 115 /******************************************************************************* 116 ** 117 ** Function bta_dm_pm_stop_timer 118 ** 119 ** Description stop a PM timer 120 ** 121 ** 122 ** Returns void 123 ** 124 *******************************************************************************/ 125 static void bta_dm_pm_stop_timer(BD_ADDR peer_addr) 126 { 127 UINT8 i; 128 129 for(i=0; i<BTA_DM_NUM_PM_TIMER; i++) 130 { 131 132 if(bta_dm_cb.pm_timer[i].in_use && !bdcmp(bta_dm_cb.pm_timer[i].peer_bdaddr, peer_addr)) 133 { 134 APPL_TRACE_DEBUG("stop dm_pm_timer:%d", i); 135 bta_sys_stop_timer(&bta_dm_cb.pm_timer[i].timer); 136 bta_dm_cb.pm_timer[i].in_use = FALSE; 137 break; 138 } 139 140 } 141 } 142 143 /******************************************************************************* 144 ** 145 ** Function bta_dm_pm_cback 146 ** 147 ** Description Conn change callback from sys for low power management 148 ** 149 ** 150 ** Returns void 151 ** 152 *******************************************************************************/ 153 static void bta_dm_pm_cback(tBTA_SYS_CONN_STATUS status, UINT8 id, UINT8 app_id, BD_ADDR peer_addr) 154 { 155 156 UINT8 i,j; 157 UINT16 policy_setting; 158 tBTM_STATUS btm_status; 159 tBTM_VERSION_INFO vers; 160 #if (BTM_SSR_INCLUDED == TRUE) 161 int index = BTA_DM_PM_SSR0; 162 #endif 163 tBTA_DM_PEER_DEVICE *p_dev; 164 165 APPL_TRACE_DEBUG("bta_dm_pm_cback: st(%d), id(%d), app(%d)", status, id, app_id); 166 167 btm_status = BTM_ReadLocalVersion (&vers); 168 p_dev = bta_dm_find_peer_device(peer_addr); 169 170 /* Disable/Enable sniff policy on the SCO link if sco Up/Down. Will be removed in 2.2*/ 171 if ((p_dev) && 172 ((status == BTA_SYS_SCO_OPEN) || (status == BTA_SYS_SCO_CLOSE)) ) 173 { 174 if ((btm_status == BTM_SUCCESS) && 175 (vers.manufacturer == LMP_COMPID_BROADCOM) && 176 (vers.hci_version < HCI_PROTO_VERSION_2_0)) 177 { 178 bta_dm_pm_set_sniff_policy(p_dev, (status == BTA_SYS_SCO_OPEN)); 179 } 180 } 181 182 /* find if there is an power mode entry for the service */ 183 for(i=1; i<=p_bta_dm_pm_cfg[0].app_id; i++) 184 { 185 186 if((p_bta_dm_pm_cfg[i].id == id) 187 && ((p_bta_dm_pm_cfg[i].app_id == BTA_ALL_APP_ID ) || (p_bta_dm_pm_cfg[i].app_id == app_id ))) 188 break; 189 190 } 191 192 /* if no entries are there for the app_id and subystem in p_bta_dm_pm_spec*/ 193 if(i> p_bta_dm_pm_cfg[0].app_id) 194 return; 195 196 bta_dm_pm_stop_timer(peer_addr); 197 /*p_dev = bta_dm_find_peer_device(peer_addr);*/ 198 199 #if (BTM_SSR_INCLUDED == TRUE) 200 /* set SSR parameters on SYS CONN OPEN */ 201 if((BTA_SYS_CONN_OPEN == status) && p_dev && (p_dev->info & BTA_DM_DI_USE_SSR)) 202 { 203 index = p_bta_dm_pm_spec[p_bta_dm_pm_cfg[i].spec_idx].ssr; 204 } 205 #endif 206 207 /* if no action for the event */ 208 if(p_bta_dm_pm_spec[p_bta_dm_pm_cfg[i].spec_idx].actn_tbl[status][0].power_mode == BTA_DM_PM_NO_ACTION) 209 { 210 #if (BTM_SSR_INCLUDED == TRUE) 211 if(BTA_DM_PM_SSR0 == index) /* and do not need to set SSR, return. */ 212 #endif 213 return; 214 } 215 216 for(j=0; j<bta_dm_conn_srvcs.count ; j++) 217 { 218 /* check if an entry already present */ 219 if((bta_dm_conn_srvcs.conn_srvc[j].id == id) 220 && (bta_dm_conn_srvcs.conn_srvc[j].app_id == app_id ) 221 && !bdcmp(bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr, peer_addr)) 222 break; 223 224 } 225 226 /* if subsystem has no more preference on the power mode remove 227 the cb */ 228 if(p_bta_dm_pm_spec[p_bta_dm_pm_cfg[i].spec_idx].actn_tbl[status][0].power_mode == BTA_DM_PM_NO_PREF) 229 { 230 231 if(j != bta_dm_conn_srvcs.count) 232 { 233 bta_dm_conn_srvcs.count--; 234 235 for(; j<bta_dm_conn_srvcs.count ; j++) 236 { 237 238 memcpy(&bta_dm_conn_srvcs.conn_srvc[j], &bta_dm_conn_srvcs.conn_srvc[j+1], sizeof(bta_dm_conn_srvcs.conn_srvc[j])); 239 240 } 241 } 242 else 243 { 244 APPL_TRACE_WARNING("bta_dm_act no entry for connected service cbs"); 245 return; 246 } 247 } 248 else if(j == bta_dm_conn_srvcs.count ) 249 { 250 /* check if we have more connected service that cbs */ 251 if(bta_dm_conn_srvcs.count == BTA_DM_NUM_CONN_SRVS) 252 { 253 APPL_TRACE_WARNING("bta_dm_act no more connected service cbs"); 254 return; 255 } 256 257 /* fill in a new cb */ 258 bta_dm_conn_srvcs.conn_srvc[j].id = id; 259 bta_dm_conn_srvcs.conn_srvc[j].app_id = app_id; 260 bdcpy(bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr, peer_addr); 261 262 APPL_TRACE_WARNING("new conn_srvc id:%d, app_id:%d", id, app_id); 263 264 bta_dm_conn_srvcs.count++; 265 bta_dm_conn_srvcs.conn_srvc[j].state = status; 266 } 267 else 268 { 269 /* no service is added or removed. only updating status. */ 270 bta_dm_conn_srvcs.conn_srvc[j].state = status; 271 } 272 273 if(p_dev) 274 { 275 p_dev->pm_mode_attempted = 0; 276 p_dev->pm_mode_failed = 0; 277 } 278 279 #if (BTM_SSR_INCLUDED == TRUE) 280 if(p_bta_dm_ssr_spec[index].max_lat 281 #if (defined BTA_HH_INCLUDED && BTA_HH_INCLUDED == TRUE) 282 || index == BTA_DM_PM_SSR_HH 283 #endif 284 ) 285 { 286 bta_dm_pm_ssr(peer_addr); 287 } 288 #endif 289 290 bta_dm_pm_set_mode(peer_addr, FALSE); 291 292 /* perform the HID link workaround if needed 293 ** 1. If SCO up/down event is received OR 294 ** 2. If HID connection open is received and SCO is already active. 295 ** This will handle the case where HID connects when SCO already active 296 */ 297 if ( (btm_status == BTM_SUCCESS) && 298 ( ((status == BTA_SYS_SCO_OPEN) || (status == BTA_SYS_SCO_CLOSE)) || 299 ((status == BTA_SYS_CONN_OPEN) && (id == BTA_ID_HH) && bta_dm_pm_is_sco_active()) ) ) 300 { 301 BOOLEAN bScoActive; 302 if (status == BTA_SYS_CONN_OPEN) 303 bScoActive = TRUE; 304 else 305 bScoActive = (status == BTA_SYS_SCO_OPEN); 306 307 bta_dm_pm_hid_check(bScoActive); 308 } 309 310 } 311 312 313 /******************************************************************************* 314 ** 315 ** Function bta_dm_pm_set_mode 316 ** 317 ** Description Set the power mode for the device 318 ** 319 ** 320 ** Returns void 321 ** 322 *******************************************************************************/ 323 static void bta_dm_pm_set_mode(BD_ADDR peer_addr, BOOLEAN timed_out ) 324 { 325 326 tBTA_DM_PM_ACTTION pm_action = BTA_DM_PM_NO_ACTION; 327 UINT16 timeout = 0; 328 UINT8 i,j; 329 tBTA_DM_PM_ACTTION failed_pm = 0; 330 tBTA_DM_PEER_DEVICE *p_peer_device = NULL; 331 tBTA_DM_PM_ACTTION allowed_modes = 0; 332 tBTA_DM_PM_ACTTION pref_modes = 0; 333 tBTA_DM_PM_CFG *p_pm_cfg; 334 tBTA_DM_PM_SPEC *p_pm_spec; 335 tBTA_DM_PM_ACTN *p_act0, *p_act1; 336 tBTA_DM_SRVCS *p_srvcs; 337 338 339 if(!bta_dm_cb.device_list.count) 340 return; 341 342 /* see if any attempt to put device in low power mode failed */ 343 p_peer_device = bta_dm_find_peer_device(peer_addr); 344 /* if no peer device found return */ 345 if (p_peer_device == NULL) 346 return; 347 348 failed_pm = p_peer_device->pm_mode_failed; 349 350 for(i=0; i<bta_dm_conn_srvcs.count ; i++) 351 { 352 353 p_srvcs = &bta_dm_conn_srvcs.conn_srvc[i]; 354 if(!bdcmp(p_srvcs->peer_bdaddr, peer_addr)) 355 { 356 357 /* p_bta_dm_pm_cfg[0].app_id is the number of entries */ 358 for(j=1; j<=p_bta_dm_pm_cfg[0].app_id; j++) 359 { 360 if((p_bta_dm_pm_cfg[j].id == p_srvcs->id) 361 && ((p_bta_dm_pm_cfg[j].app_id == BTA_ALL_APP_ID ) || 362 (p_bta_dm_pm_cfg[j].app_id == p_srvcs->app_id))) 363 break; 364 } 365 366 p_pm_cfg = &p_bta_dm_pm_cfg[j]; 367 p_pm_spec = &p_bta_dm_pm_spec[p_pm_cfg->spec_idx]; 368 p_act0 = &p_pm_spec->actn_tbl[p_srvcs->state][0]; 369 p_act1 = &p_pm_spec->actn_tbl[p_srvcs->state][1]; 370 371 APPL_TRACE_DEBUG("bta_dm_pm_set_mode: srvcsid: %d, state: %d, j: %d", p_srvcs->id, p_srvcs->state, j); 372 allowed_modes |= p_pm_spec->allow_mask; 373 374 /* PM actions are in the order of strictness */ 375 376 /* first check if the first preference is ok */ 377 if(!(failed_pm & p_act0->power_mode)) 378 { 379 pref_modes |= p_act0->power_mode; 380 381 if(p_act0->power_mode > pm_action) 382 { 383 pm_action = p_act0->power_mode; 384 timeout = p_act0->timeout; 385 386 } 387 } 388 /* if first preference has already failed, try second preference */ 389 else if(!(failed_pm & p_act1->power_mode)) 390 { 391 pref_modes |= p_act1->power_mode; 392 393 if(p_act1->power_mode > pm_action) 394 { 395 pm_action = p_act1->power_mode; 396 timeout = p_act1->timeout; 397 398 } 399 } 400 } 401 } 402 403 if(pm_action & (BTA_DM_PM_PARK | BTA_DM_PM_SNIFF)) 404 { 405 406 /* some service don't like the mode */ 407 if(!(allowed_modes & pm_action)) 408 { 409 410 /* select the other mode if its allowed and preferred, otherwise 0 which is BTA_DM_PM_NO_ACTION */ 411 pm_action = (allowed_modes & (BTA_DM_PM_PARK | BTA_DM_PM_SNIFF) & pref_modes); 412 413 /* no timeout needed if no action is required */ 414 if(pm_action == BTA_DM_PM_NO_ACTION) 415 { 416 timeout = 0; 417 } 418 419 } 420 421 422 } 423 424 if(!timed_out && timeout) 425 { 426 427 for(i=0; i<BTA_DM_NUM_PM_TIMER; i++) 428 { 429 430 if(!bta_dm_cb.pm_timer[i].in_use) 431 { 432 bta_dm_cb.pm_timer[i].in_use = TRUE; 433 bdcpy(bta_dm_cb.pm_timer[i].peer_bdaddr, peer_addr); 434 bta_dm_cb.pm_timer[i].timer.p_cback = bta_dm_pm_timer_cback; 435 bta_sys_start_timer(&bta_dm_cb.pm_timer[i].timer, 0, timeout); 436 APPL_TRACE_DEBUG("start dm_pm_timer:%d, %d", i, timeout); 437 return; 438 439 } 440 441 } 442 443 /* no more timers */ 444 if(i==BTA_DM_NUM_PM_TIMER) 445 { 446 APPL_TRACE_WARNING("bta_dm_act dm_pm_timer no more"); 447 return; 448 } 449 } 450 451 if(pm_action == BTA_DM_PM_NO_ACTION) 452 { 453 454 455 } 456 else if(pm_action == BTA_DM_PM_PARK) 457 { 458 p_peer_device->pm_mode_attempted = BTA_DM_PM_PARK; 459 bta_dm_pm_park(peer_addr); 460 461 } 462 else if(pm_action & BTA_DM_PM_SNIFF) 463 { 464 /* dont initiate SNIFF, if link_policy has it disabled */ 465 if (p_peer_device->link_policy & HCI_ENABLE_SNIFF_MODE) 466 { 467 p_peer_device->pm_mode_attempted = BTA_DM_PM_SNIFF; 468 bta_dm_pm_sniff(p_peer_device, (UINT8)(pm_action & 0x0F) ); 469 } 470 else 471 { 472 APPL_TRACE_DEBUG("bta_dm_pm_set_mode: Link policy disallows SNIFF, ignore request"); 473 } 474 } 475 else if(pm_action == BTA_DM_PM_ACTIVE) 476 { 477 478 bta_dm_pm_active(peer_addr); 479 480 } 481 482 483 } 484 485 486 /******************************************************************************* 487 ** 488 ** Function bta_ag_pm_park 489 ** 490 ** Description Switch to park mode. 491 ** 492 ** 493 ** Returns TRUE if park attempted, FALSE otherwise. 494 ** 495 *******************************************************************************/ 496 static BOOLEAN bta_dm_pm_park(BD_ADDR peer_addr) 497 { 498 499 tBTM_PM_MODE mode = BTM_PM_STS_ACTIVE; 500 501 /* if not in park mode, switch to park */ 502 BTM_ReadPowerMode(peer_addr, &mode); 503 504 if(mode != BTM_PM_MD_PARK) 505 { 506 BTM_SetPowerMode (bta_dm_cb.pm_id, peer_addr, &p_bta_dm_pm_md[BTA_DM_PM_PARK_IDX]); 507 } 508 return TRUE; 509 510 } 511 512 513 /******************************************************************************* 514 ** 515 ** Function bta_ag_pm_sniff 516 ** 517 ** Description Switch to sniff mode. 518 ** 519 ** 520 ** Returns TRUE if sniff attempted, FALSE otherwise. 521 ** 522 *******************************************************************************/ 523 static BOOLEAN bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE *p_peer_dev, UINT8 index) 524 { 525 tBTM_PM_MODE mode = BTM_PM_STS_ACTIVE; 526 tBTM_PM_PWR_MD pwr_md; 527 tBTM_STATUS status; 528 529 BTM_ReadPowerMode(p_peer_dev->peer_bdaddr, &mode); 530 531 #if (BTM_SSR_INCLUDED == TRUE) 532 APPL_TRACE_DEBUG("bta_dm_pm_sniff cur:%d, idx:%d, info:x%x", mode, index, p_peer_dev->info); 533 if (mode != BTM_PM_MD_SNIFF || 534 (HCI_SNIFF_SUB_RATE_SUPPORTED(BTM_ReadLocalFeatures ()) && 535 HCI_SNIFF_SUB_RATE_SUPPORTED(BTM_ReadRemoteFeatures (p_peer_dev->peer_bdaddr)) && 536 !(p_peer_dev->info & BTA_DM_DI_USE_SSR))) 537 #else 538 APPL_TRACE_DEBUG("bta_dm_pm_sniff cur:%d, idx:%d", mode, index); 539 if(mode != BTM_PM_MD_SNIFF) 540 #endif 541 { 542 /* if the current mode is not sniff, issue the sniff command. 543 * If sniff, but SSR is not used in this link, still issue the command */ 544 memcpy(&pwr_md, &p_bta_dm_pm_md[index], sizeof (tBTM_PM_PWR_MD)); 545 if (p_peer_dev->info & BTA_DM_DI_INT_SNIFF) 546 { 547 pwr_md.mode |= BTM_PM_MD_FORCE; 548 } 549 status = BTM_SetPowerMode (bta_dm_cb.pm_id, p_peer_dev->peer_bdaddr, &pwr_md); 550 if (status == BTM_CMD_STORED|| status == BTM_CMD_STARTED) 551 { 552 p_peer_dev->info &= ~(BTA_DM_DI_INT_SNIFF|BTA_DM_DI_ACP_SNIFF); 553 p_peer_dev->info |= BTA_DM_DI_SET_SNIFF; 554 } 555 else if (status == BTM_SUCCESS) 556 { 557 APPL_TRACE_DEBUG("bta_dm_pm_sniff BTM_SetPowerMode() returns BTM_SUCCESS"); 558 p_peer_dev->info &= ~(BTA_DM_DI_INT_SNIFF|BTA_DM_DI_ACP_SNIFF|BTA_DM_DI_SET_SNIFF); 559 } 560 else /* error */ 561 { 562 APPL_TRACE_ERROR("bta_dm_pm_sniff BTM_SetPowerMode() returns ERROR status=%d", status); 563 p_peer_dev->info &= ~(BTA_DM_DI_INT_SNIFF|BTA_DM_DI_ACP_SNIFF|BTA_DM_DI_SET_SNIFF); 564 } 565 } 566 /* else already in sniff and is using SSR, do nothing */ 567 568 return TRUE; 569 570 } 571 /******************************************************************************* 572 ** 573 ** Function bta_dm_pm_ssr 574 ** 575 ** Description checks and sends SSR parameters 576 ** 577 ** Returns void 578 ** 579 *******************************************************************************/ 580 #if (BTM_SSR_INCLUDED == TRUE) 581 static void bta_dm_pm_ssr(BD_ADDR peer_addr) 582 { 583 tBTA_DM_SSR_SPEC *p_spec, *p_spec_cur; 584 UINT8 i,j; 585 int ssr = BTA_DM_PM_SSR0; 586 587 /* go through the connected services */ 588 for(i=0; i<bta_dm_conn_srvcs.count ; i++) 589 { 590 if(!bdcmp(bta_dm_conn_srvcs.conn_srvc[i].peer_bdaddr, peer_addr)) 591 { 592 /* p_bta_dm_pm_cfg[0].app_id is the number of entries */ 593 for(j=1; j<=p_bta_dm_pm_cfg[0].app_id; j++) 594 { 595 /* find the associated p_bta_dm_pm_cfg */ 596 if((p_bta_dm_pm_cfg[j].id == bta_dm_conn_srvcs.conn_srvc[i].id) 597 && ((p_bta_dm_pm_cfg[j].app_id == BTA_ALL_APP_ID ) 598 || (p_bta_dm_pm_cfg[j].app_id == bta_dm_conn_srvcs.conn_srvc[i].app_id))) 599 { 600 APPL_TRACE_WARNING("bta_dm_pm_ssr conn_srvc id:%d, app_id:%d", 601 bta_dm_conn_srvcs.conn_srvc[i].id, bta_dm_conn_srvcs.conn_srvc[i].app_id); 602 break; 603 } 604 } 605 606 /* find the ssr index with the smallest max latency. */ 607 p_spec_cur = &p_bta_dm_ssr_spec[p_bta_dm_pm_spec[p_bta_dm_pm_cfg[j].spec_idx].ssr]; 608 p_spec = &p_bta_dm_ssr_spec[ssr]; 609 610 #if (defined BTA_HH_INCLUDED && BTA_HH_INCLUDED == TRUE) 611 /* HH has the per connection SSR preference, already read the SSR params from BTA HH */ 612 if (p_bta_dm_pm_spec[p_bta_dm_pm_cfg[j].spec_idx].ssr == BTA_DM_PM_SSR_HH) 613 { 614 if (bta_hh_read_ssr_param(peer_addr, &p_spec_cur->max_lat, &p_spec_cur->min_rmt_to) == BTA_HH_ERR) 615 continue; 616 } 617 #endif 618 if (p_spec_cur->max_lat < p_spec->max_lat || 619 (ssr == BTA_DM_PM_SSR0 && p_bta_dm_pm_spec[p_bta_dm_pm_cfg[j].spec_idx].ssr != BTA_DM_PM_SSR0)) 620 { 621 ssr = p_bta_dm_pm_spec[p_bta_dm_pm_cfg[j].spec_idx].ssr; 622 } 623 624 } 625 } 626 627 p_spec = &p_bta_dm_ssr_spec[ssr]; 628 APPL_TRACE_WARNING("bta_dm_pm_ssr:%d, lat:%d", ssr, p_spec->max_lat); 629 if(p_spec->max_lat) 630 { 631 /* set the SSR parameters. */ 632 BTM_SetSsrParams (peer_addr, p_spec->max_lat, 633 p_spec->min_rmt_to, p_spec->min_loc_to); 634 } 635 } 636 #endif 637 /******************************************************************************* 638 ** 639 ** Function bta_dm_pm_active 640 ** 641 ** Description Brings connection to active mode 642 ** 643 ** 644 ** Returns void 645 ** 646 *******************************************************************************/ 647 void bta_dm_pm_active(BD_ADDR peer_addr) 648 { 649 tBTM_PM_PWR_MD pm; 650 651 memset( (void*)&pm, 0, sizeof(pm)); 652 653 /* switch to active mode */ 654 pm.mode = BTM_PM_MD_ACTIVE; 655 BTM_SetPowerMode (bta_dm_cb.pm_id, peer_addr, &pm); 656 657 658 } 659 660 661 /******************************************************************************* 662 ** 663 ** Function bta_dm_pm_btm_cback 664 ** 665 ** Description BTM power manager callback. 666 ** 667 ** 668 ** Returns void 669 ** 670 *******************************************************************************/ 671 static void bta_dm_pm_btm_cback(BD_ADDR bd_addr, tBTM_PM_STATUS status, UINT16 value, UINT8 hci_status) 672 { 673 tBTA_DM_PM_BTM_STATUS *p_buf; 674 675 if ((p_buf = (tBTA_DM_PM_BTM_STATUS *) GKI_getbuf(sizeof(tBTA_DM_PM_BTM_STATUS))) != NULL) 676 { 677 p_buf->hdr.event = BTA_DM_PM_BTM_STATUS_EVT; 678 p_buf->status = status; 679 p_buf->value = value; 680 p_buf->hci_status = hci_status; 681 bdcpy(p_buf->bd_addr, bd_addr); 682 bta_sys_sendmsg(p_buf); 683 } 684 } 685 686 /******************************************************************************* 687 ** 688 ** Function bta_dm_pm_timer_cback 689 ** 690 ** Description Power management timer callback. 691 ** 692 ** 693 ** Returns void 694 ** 695 *******************************************************************************/ 696 static void bta_dm_pm_timer_cback(void *p_tle) 697 { 698 tBTA_DM_PM_TIMER *p_buf; 699 UINT8 i; 700 701 APPL_TRACE_WARNING("dm_pm_timer expires"); 702 703 for(i=0; i<BTA_DM_NUM_PM_TIMER; i++) 704 { 705 706 if(bta_dm_cb.pm_timer[i].in_use) 707 { 708 709 if(&bta_dm_cb.pm_timer[i].timer == (TIMER_LIST_ENT*) p_tle) 710 { 711 APPL_TRACE_WARNING("dm_pm_timer expires %d", i); 712 bta_dm_cb.pm_timer[i].in_use = FALSE; 713 break; 714 } 715 716 } 717 718 } 719 720 721 /* no more timers */ 722 if(i==BTA_DM_NUM_PM_TIMER) 723 { 724 return; 725 } 726 727 if ((p_buf = (tBTA_DM_PM_TIMER *) GKI_getbuf(sizeof(tBTA_DM_PM_TIMER))) != NULL) 728 { 729 p_buf->hdr.event = BTA_DM_PM_TIMER_EVT; 730 bdcpy(p_buf->bd_addr, bta_dm_cb.pm_timer[i].peer_bdaddr); 731 bta_sys_sendmsg(p_buf); 732 } 733 } 734 735 /******************************************************************************* 736 ** 737 ** Function bta_dm_pm_btm_status 738 ** 739 ** Description Process pm status event from btm 740 ** 741 ** 742 ** Returns void 743 ** 744 *******************************************************************************/ 745 void bta_dm_pm_btm_status(tBTA_DM_MSG *p_data) 746 { 747 748 tBTA_DM_PEER_DEVICE *p_dev; 749 tBTA_DM_DEV_INFO info; 750 751 APPL_TRACE_DEBUG("bta_dm_pm_btm_status:%d", p_data->pm_status.status); 752 p_dev = bta_dm_find_peer_device(p_data->pm_status.bd_addr); 753 if(NULL == p_dev) 754 return; 755 756 info = p_dev->info; 757 /* check new mode */ 758 switch (p_data->pm_status.status) 759 { 760 case BTM_PM_STS_ACTIVE: 761 /* if our sniff or park attempt failed 762 we should not try it again*/ 763 if (p_data->pm_status.hci_status != 0) 764 { 765 APPL_TRACE_ERROR("bta_dm_pm_btm_status hci_status=%d", p_data->pm_status.hci_status); 766 p_dev->info &= ~(BTA_DM_DI_INT_SNIFF|BTA_DM_DI_ACP_SNIFF|BTA_DM_DI_SET_SNIFF); 767 768 if(p_dev->pm_mode_attempted &(BTA_DM_PM_PARK | BTA_DM_PM_SNIFF)) 769 { 770 p_dev->pm_mode_failed 771 |= ((BTA_DM_PM_PARK | BTA_DM_PM_SNIFF) & p_dev->pm_mode_attempted); 772 bta_dm_pm_stop_timer(p_data->pm_status.bd_addr); 773 bta_dm_pm_set_mode(p_data->pm_status.bd_addr, FALSE); 774 } 775 } 776 else 777 { 778 #if (BTM_SSR_INCLUDED == TRUE) 779 if(p_dev->prev_low) 780 { 781 /* need to send the SSR paramaters to controller again */ 782 bta_dm_pm_ssr(p_dev->peer_bdaddr); 783 } 784 p_dev->prev_low = BTM_PM_STS_ACTIVE; 785 #endif 786 bta_dm_pm_stop_timer(p_data->pm_status.bd_addr); 787 bta_dm_pm_set_mode(p_data->pm_status.bd_addr, FALSE); 788 } 789 break; 790 791 #if (BTM_SSR_INCLUDED == TRUE) 792 case BTM_PM_STS_PARK: 793 case BTM_PM_STS_HOLD: 794 /* save the previous low power mode - for SSR. 795 * SSR parameters are sent to controller on "conn open". 796 * the numbers stay good until park/hold/detach */ 797 if(p_dev->info & BTA_DM_DI_USE_SSR) 798 p_dev->prev_low = p_data->pm_status.status; 799 break; 800 801 case BTM_PM_STS_SSR: 802 if(p_data->pm_status.value) 803 p_dev->info |= BTA_DM_DI_USE_SSR; 804 else 805 p_dev->info &= ~BTA_DM_DI_USE_SSR; 806 break; 807 #endif 808 case BTM_PM_STS_SNIFF: 809 if (p_data->pm_status.hci_status == 0) 810 { 811 /* Stop PM timer now if already active for 812 * particular device since link is already 813 * put in sniff mode by remote device, and 814 * PM timer sole purpose is to put the link 815 * in sniff mode from host side. 816 */ 817 bta_dm_pm_stop_timer(p_data->pm_status.bd_addr); 818 } 819 p_dev->info &= ~(BTA_DM_DI_SET_SNIFF|BTA_DM_DI_INT_SNIFF|BTA_DM_DI_ACP_SNIFF); 820 if (info & BTA_DM_DI_SET_SNIFF) 821 p_dev->info |= BTA_DM_DI_INT_SNIFF; 822 else 823 p_dev->info |= BTA_DM_DI_ACP_SNIFF; 824 break; 825 826 case BTM_PM_STS_ERROR: 827 p_dev->info &= ~BTA_DM_DI_SET_SNIFF; 828 break; 829 830 default: 831 break; 832 } 833 834 835 836 } 837 838 /******************************************************************************* 839 ** 840 ** Function bta_dm_pm_timer 841 ** 842 ** Description Process pm timer event from btm 843 ** 844 ** 845 ** Returns void 846 ** 847 *******************************************************************************/ 848 void bta_dm_pm_timer(tBTA_DM_MSG *p_data) 849 { 850 851 APPL_TRACE_WARNING("proc dm_pm_timer expires"); 852 bta_dm_pm_set_mode(p_data->pm_status.bd_addr, TRUE); 853 854 855 } 856 857 /******************************************************************************* 858 ** 859 ** Function bta_dm_find_peer_device 860 ** 861 ** Description Given an address, find the associated control block. 862 ** 863 ** Returns tBTA_DM_PEER_DEVICE 864 ** 865 *******************************************************************************/ 866 tBTA_DM_PEER_DEVICE * bta_dm_find_peer_device(BD_ADDR peer_addr) 867 { 868 tBTA_DM_PEER_DEVICE *p_dev = NULL; 869 int i; 870 871 for(i=0; i<bta_dm_cb.device_list.count; i++) 872 { 873 if(!bdcmp( bta_dm_cb.device_list.peer_device[i].peer_bdaddr, peer_addr)) 874 { 875 p_dev = &bta_dm_cb.device_list.peer_device[i]; 876 break; 877 } 878 879 } 880 return p_dev; 881 } 882 883 /******************************************************************************* 884 ** 885 ** Function bta_dm_is_sco_active 886 ** 887 ** Description Loop through connected services for HFP+State=SCO 888 ** 889 ** Returns BOOLEAN. TRUE if SCO active, else FALSE 890 ** 891 *******************************************************************************/ 892 static BOOLEAN bta_dm_pm_is_sco_active () 893 { 894 int j; 895 BOOLEAN bScoActive = FALSE; 896 897 for(j=0; j<bta_dm_conn_srvcs.count ; j++) 898 { 899 /* check if an entry already present */ 900 if ( (bta_dm_conn_srvcs.conn_srvc[j].id == BTA_ID_AG ) && (bta_dm_conn_srvcs.conn_srvc[j].state == BTA_SYS_SCO_OPEN) ) 901 { 902 bScoActive = TRUE; 903 break; 904 } 905 } 906 907 APPL_TRACE_DEBUG("bta_dm_is_sco_active: SCO active: %d", bScoActive); 908 return bScoActive; 909 } 910 911 912 /******************************************************************************* 913 ** 914 ** Function bta_dm_pm_hid_check 915 ** 916 ** Description Disables/Enables sniff in link policy based on SCO Up/Down 917 ** 918 ** Returns None 919 ** 920 *******************************************************************************/ 921 922 static void bta_dm_pm_hid_check(BOOLEAN bScoActive) 923 { 924 int j; 925 926 /* if HID is active, disable the link policy */ 927 for(j=0; j<bta_dm_conn_srvcs.count ; j++) 928 { 929 /* check if an entry already present */ 930 if(bta_dm_conn_srvcs.conn_srvc[j].id == BTA_ID_HH ) 931 { 932 APPL_TRACE_DEBUG ("SCO status change(Active: %d), modify HID link policy. state: %d", 933 bScoActive, bta_dm_conn_srvcs.conn_srvc[j].state); 934 bta_dm_pm_set_sniff_policy( bta_dm_find_peer_device(bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr), bScoActive); 935 936 /* if we had disabled link policy, seems like the hid device stop retrying SNIFF after a few tries. force sniff if needed */ 937 if (!bScoActive) 938 bta_dm_pm_set_mode(bta_dm_conn_srvcs.conn_srvc[j].peer_bdaddr, FALSE); 939 } 940 } 941 942 } 943 944 /******************************************************************************* 945 ** 946 ** Function bta_dm_pm_set_sniff_policy 947 ** 948 ** Description Disables/Enables sniff in link policy for the give device 949 ** 950 ** Returns None 951 ** 952 *******************************************************************************/ 953 static void bta_dm_pm_set_sniff_policy(tBTA_DM_PEER_DEVICE *p_dev, BOOLEAN bDisable) 954 { 955 UINT16 policy_setting; 956 957 if (!p_dev) 958 return; 959 960 if (bDisable) 961 { 962 policy_setting = bta_dm_cb.cur_policy & 963 (HCI_ENABLE_MASTER_SLAVE_SWITCH | 964 HCI_ENABLE_HOLD_MODE | 965 HCI_ENABLE_PARK_MODE); 966 967 } 968 else 969 { 970 /* allow sniff after sco is closed */ 971 policy_setting= bta_dm_cb.cur_policy; 972 } 973 974 /* if disabling SNIFF, make sure link is Active */ 975 if (bDisable) 976 bta_dm_pm_active(p_dev->peer_bdaddr); 977 978 /* update device record and set link policy */ 979 p_dev->link_policy = policy_setting; 980 BTM_SetLinkPolicy(p_dev->peer_bdaddr, &policy_setting); 981 982 } 983 984 #if ((defined BLE_INCLUDED) && (BLE_INCLUDED == TRUE)) 985 /******************************************************************************* 986 ** 987 ** Function bta_dm_pm_obtain_controller_state 988 ** 989 ** Description This function obtains the consolidated controller power state 990 ** 991 ** Parameters: 992 ** 993 *******************************************************************************/ 994 tBTA_DM_CONTRL_STATE bta_dm_pm_obtain_controller_state(void) 995 { 996 /* Did not use counts as it is not sure, how accurate the count values are in 997 ** bta_dm_cb.device_list.count > 0 || bta_dm_cb.device_list.le_count > 0 */ 998 999 tBTA_DM_CONTRL_STATE cur_state = BTA_DM_CONTRL_UNKNOWN; 1000 cur_state = BTM_PM_ReadControllerState(); 1001 1002 APPL_TRACE_DEBUG("bta_dm_pm_obtain_controller_state: %d", cur_state); 1003 return cur_state; 1004 } 1005 #endif 1006
