1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #include <hardware_legacy/power.h> 17 #include <fcntl.h> 18 #include <errno.h> 19 #include <stdlib.h> 20 #include <stdio.h> 21 #include <unistd.h> 22 #include <sys/time.h> 23 #include <time.h> 24 #include <errno.h> 25 #include <string.h> 26 #include <sys/stat.h> 27 #include <sys/types.h> 28 #include <pthread.h> 29 30 #define LOG_TAG "power" 31 #include <utils/Log.h> 32 33 #include "qemu.h" 34 #ifdef QEMU_POWER 35 #include "power_qemu.h" 36 #endif 37 38 enum { 39 ACQUIRE_PARTIAL_WAKE_LOCK = 0, 40 RELEASE_WAKE_LOCK, 41 REQUEST_STATE, 42 OUR_FD_COUNT 43 }; 44 45 const char * const OLD_PATHS[] = { 46 "/sys/android_power/acquire_partial_wake_lock", 47 "/sys/android_power/release_wake_lock", 48 "/sys/android_power/request_state" 49 }; 50 51 const char * const NEW_PATHS[] = { 52 "/sys/power/wake_lock", 53 "/sys/power/wake_unlock", 54 "/sys/power/state" 55 }; 56 57 const char * const AUTO_OFF_TIMEOUT_DEV = "/sys/android_power/auto_off_timeout"; 58 59 //XXX static pthread_once_t g_initialized = THREAD_ONCE_INIT; 60 static int g_initialized = 0; 61 static int g_fds[OUR_FD_COUNT]; 62 static int g_error = 1; 63 64 static const char *off_state = "mem"; 65 static const char *on_state = "on"; 66 67 static int64_t systemTime() 68 { 69 struct timespec t; 70 t.tv_sec = t.tv_nsec = 0; 71 clock_gettime(CLOCK_MONOTONIC, &t); 72 return t.tv_sec*1000000000LL + t.tv_nsec; 73 } 74 75 static int 76 open_file_descriptors(const char * const paths[]) 77 { 78 int i; 79 for (i=0; i<OUR_FD_COUNT; i++) { 80 int fd = open(paths[i], O_RDWR); 81 if (fd < 0) { 82 fprintf(stderr, "fatal error opening \"%s\"\n", paths[i]); 83 g_error = errno; 84 return -1; 85 } 86 g_fds[i] = fd; 87 } 88 89 g_error = 0; 90 return 0; 91 } 92 93 static inline void 94 initialize_fds(void) 95 { 96 // XXX: should be this: 97 //pthread_once(&g_initialized, open_file_descriptors); 98 // XXX: not this: 99 if (g_initialized == 0) { 100 if(open_file_descriptors(NEW_PATHS) < 0) { 101 open_file_descriptors(OLD_PATHS); 102 on_state = "wake"; 103 off_state = "standby"; 104 } 105 g_initialized = 1; 106 } 107 } 108 109 int 110 acquire_wake_lock(int lock, const char* id) 111 { 112 initialize_fds(); 113 114 // LOGI("acquire_wake_lock lock=%d id='%s'\n", lock, id); 115 116 if (g_error) return g_error; 117 118 int fd; 119 120 if (lock == PARTIAL_WAKE_LOCK) { 121 fd = g_fds[ACQUIRE_PARTIAL_WAKE_LOCK]; 122 } 123 else { 124 return EINVAL; 125 } 126 127 return write(fd, id, strlen(id)); 128 } 129 130 int 131 release_wake_lock(const char* id) 132 { 133 initialize_fds(); 134 135 // LOGI("release_wake_lock id='%s'\n", id); 136 137 if (g_error) return g_error; 138 139 ssize_t len = write(g_fds[RELEASE_WAKE_LOCK], id, strlen(id)); 140 return len >= 0; 141 } 142 143 int 144 set_last_user_activity_timeout(int64_t delay) 145 { 146 // LOGI("set_last_user_activity_timeout delay=%d\n", ((int)(delay))); 147 148 int fd = open(AUTO_OFF_TIMEOUT_DEV, O_RDWR); 149 if (fd >= 0) { 150 char buf[32]; 151 ssize_t len; 152 len = snprintf(buf, sizeof(buf), "%d", ((int)(delay))); 153 buf[sizeof(buf) - 1] = '\0'; 154 len = write(fd, buf, len); 155 close(fd); 156 return 0; 157 } else { 158 return errno; 159 } 160 } 161 162 int 163 set_screen_state(int on) 164 { 165 QEMU_FALLBACK(set_screen_state(on)); 166 167 LOGI("*** set_screen_state %d", on); 168 169 initialize_fds(); 170 171 //LOGI("go_to_sleep eventTime=%lld now=%lld g_error=%s\n", eventTime, 172 // systemTime(), strerror(g_error)); 173 174 if (g_error) return g_error; 175 176 char buf[32]; 177 int len; 178 if(on) 179 len = snprintf(buf, sizeof(buf), "%s", on_state); 180 else 181 len = snprintf(buf, sizeof(buf), "%s", off_state); 182 183 buf[sizeof(buf) - 1] = '\0'; 184 len = write(g_fds[REQUEST_STATE], buf, len); 185 if(len < 0) { 186 LOGE("Failed setting last user activity: g_error=%d\n", g_error); 187 } 188 return 0; 189 } 190