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