1 /******************************************************************************
3 * Copyright (C) 2014 Google, Inc.
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:
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 ******************************************************************************/
19 #define LOG_TAG "bt_low_power_manager"
21 #include "low_power_manager.h"
26 #include "osi/include/alarm.h"
27 #include "osi/include/log.h"
28 #include "osi/include/osi.h"
29 #include "osi/include/thread.h"
37 } low_power_mode_state_t;
40 LPM_WAKE_DEASSERTED = 0,
46 // Our interface and modules we import
47 static const low_power_manager_t interface;
48 static const vendor_t *vendor;
50 static void vendor_enable_disable_callback(bool success);
52 static void event_disable(void *context);
53 static void event_enable(void *context);
54 static void event_wake_assert(void *context);
55 static void event_allow_device_sleep(void *context);
56 static void event_idle_timeout(void *context);
58 static void reset_state();
59 static void start_idle_timer();
60 static void stop_idle_timer();
62 static thread_fn event_functions[] = {
66 event_allow_device_sleep
69 static thread_t *thread;
70 static low_power_mode_state_t state;
71 static wake_state_t wake_state;
72 static uint32_t idle_timeout_ms;
73 static alarm_t *idle_alarm;
74 static bool transmit_is_done;
76 // Interface functions
78 static void init(thread_t *post_thread) {
79 assert(post_thread != NULL);
82 vendor->set_callback(VENDOR_SET_LPM_MODE, vendor_enable_disable_callback);
83 vendor->send_command(VENDOR_GET_LPM_IDLE_TIMEOUT, &idle_timeout_ms);
85 idle_alarm = alarm_new();
87 LOG_ERROR(LOG_TAG, "%s could not create idle alarm.", __func__);
93 static void cleanup() {
95 alarm_free(idle_alarm);
99 static void post_command(low_power_command_t command) {
100 if (command > LPM_WAKE_DEASSERT) {
101 LOG_ERROR(LOG_TAG, "%s unknown low power command %d", __func__, command);
105 thread_post(thread, event_functions[command], NULL);
108 static void wake_assert() {
109 if (state != LPM_DISABLED) {
112 uint8_t new_state = BT_VND_LPM_WAKE_ASSERT;
113 vendor->send_command(VENDOR_SET_LPM_WAKE_STATE, &new_state);
114 wake_state = LPM_WAKE_ASSERTED;
117 // TODO(zachoverflow): investigate this interaction. If someone above
118 // HCI asserts wake, we'll wait until we transmit before deasserting.
119 // That doesn't seem quite right.
120 transmit_is_done = false;
123 static void transmit_done() {
124 transmit_is_done = true;
125 if (wake_state == LPM_WAKE_W4_TX_DONE) {
126 wake_state = LPM_WAKE_W4_TIMEOUT;
131 // Internal functions
133 static void enable(bool enable) {
134 if (state == LPM_DISABLING) {
136 LOG_ERROR(LOG_TAG, "%s still processing prior disable request, cannot enable.", __func__);
138 LOG_WARN(LOG_TAG, "%s still processing prior disable request, ignoring new request to disable.", __func__);
139 } else if (state == LPM_ENABLING) {
141 LOG_ERROR(LOG_TAG, "%s still processing prior enable request, ignoring new request to enable.", __func__);
143 LOG_WARN(LOG_TAG, "%s still processing prior enable request, cannot disable.", __func__);
144 } else if (state == LPM_ENABLED && enable) {
145 LOG_INFO(LOG_TAG, "%s already enabled.", __func__);
146 } else if (state == LPM_DISABLED && !enable) {
147 LOG_INFO(LOG_TAG, "%s already disabled.", __func__);
149 uint8_t command = enable ? BT_VND_LPM_ENABLE : BT_VND_LPM_DISABLE;
150 state = enable ? LPM_ENABLING : LPM_DISABLING;
151 vendor->send_async_command(VENDOR_SET_LPM_MODE, &command);
155 static void allow_device_sleep() {
156 if (state == LPM_ENABLED && wake_state == LPM_WAKE_ASSERTED) {
157 if (transmit_is_done) {
158 wake_state = LPM_WAKE_W4_TIMEOUT;
161 wake_state = LPM_WAKE_W4_TX_DONE;
166 static void wake_deassert() {
167 if (state == LPM_ENABLED && transmit_is_done) {
168 uint8_t new_state = BT_VND_LPM_WAKE_DEASSERT;
169 vendor->send_command(VENDOR_SET_LPM_WAKE_STATE, &new_state);
170 wake_state = LPM_WAKE_DEASSERTED;
174 static void reset_state() {
175 state = LPM_DISABLED;
176 wake_state = LPM_WAKE_DEASSERTED;
177 transmit_is_done = true;
181 static void idle_timer_expired(UNUSED_ATTR void *context) {
182 if (state == LPM_ENABLED && wake_state == LPM_WAKE_W4_TIMEOUT)
183 thread_post(thread, event_idle_timeout, NULL);
186 static void start_idle_timer() {
187 if (state == LPM_ENABLED) {
188 alarm_set(idle_alarm, idle_timeout_ms, idle_timer_expired, NULL);
192 static void stop_idle_timer() {
193 alarm_cancel(idle_alarm);
196 static void event_disable(UNUSED_ATTR void *context) {
200 static void event_enable(UNUSED_ATTR void *context) {
204 static void event_wake_assert(UNUSED_ATTR void *context) {
208 static void event_allow_device_sleep(UNUSED_ATTR void *context) {
209 allow_device_sleep();
212 static void event_idle_timeout(UNUSED_ATTR void *context) {
216 static void vendor_enable_disable_callback(bool success) {
218 state = (state == LPM_ENABLING) ? LPM_ENABLED : LPM_DISABLED;
220 state = (state == LPM_ENABLING) ? LPM_DISABLED : LPM_ENABLED;
222 if (state == LPM_DISABLED) {
227 static const low_power_manager_t interface = {
235 const low_power_manager_t *low_power_manager_get_interface() {
236 vendor = vendor_get_interface();
240 const low_power_manager_t *low_power_manager_get_test_interface(const vendor_t *vendor_interface) {
241 vendor = vendor_interface;