1 /* 2 * Copyright (C) 2015 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 17 #define LOG_TAG "hwc-vsync-worker" 18 19 #include "drmresources.h" 20 #include "vsyncworker.h" 21 #include "worker.h" 22 23 #include <map> 24 #include <stdlib.h> 25 #include <time.h> 26 #include <xf86drm.h> 27 #include <xf86drmMode.h> 28 29 #include <cutils/log.h> 30 #include <hardware/hardware.h> 31 32 namespace android { 33 34 VSyncWorker::VSyncWorker() 35 : Worker("vsync", HAL_PRIORITY_URGENT_DISPLAY), 36 drm_(NULL), 37 procs_(NULL), 38 display_(-1), 39 last_timestamp_(-1) { 40 } 41 42 VSyncWorker::~VSyncWorker() { 43 } 44 45 int VSyncWorker::Init(DrmResources *drm, int display) { 46 drm_ = drm; 47 display_ = display; 48 49 return InitWorker(); 50 } 51 52 int VSyncWorker::SetProcs(hwc_procs_t const *procs) { 53 int ret = Lock(); 54 if (ret) { 55 ALOGE("Failed to lock vsync worker lock %d\n", ret); 56 return ret; 57 } 58 59 procs_ = procs; 60 61 ret = Unlock(); 62 if (ret) { 63 ALOGE("Failed to unlock vsync worker lock %d\n", ret); 64 return ret; 65 } 66 return 0; 67 } 68 69 int VSyncWorker::VSyncControl(bool enabled) { 70 int ret = Lock(); 71 if (ret) { 72 ALOGE("Failed to lock vsync worker lock %d\n", ret); 73 return ret; 74 } 75 76 enabled_ = enabled; 77 last_timestamp_ = -1; 78 int signal_ret = SignalLocked(); 79 80 ret = Unlock(); 81 if (ret) { 82 ALOGE("Failed to unlock vsync worker lock %d\n", ret); 83 return ret; 84 } 85 86 return signal_ret; 87 } 88 89 /* 90 * Returns the timestamp of the next vsync in phase with last_timestamp_. 91 * For example: 92 * last_timestamp_ = 137 93 * frame_ns = 50 94 * current = 683 95 * 96 * ret = (50 * ((683 - 137)/50 + 1)) + 137 97 * ret = 687 98 * 99 * Thus, we must sleep until timestamp 687 to maintain phase with the last 100 * timestamp. 101 */ 102 int64_t VSyncWorker::GetPhasedVSync(int64_t frame_ns, int64_t current) { 103 if (last_timestamp_ < 0) 104 return current + frame_ns; 105 106 return frame_ns * ((current - last_timestamp_) / frame_ns + 1) + 107 last_timestamp_; 108 } 109 110 static const int64_t kOneSecondNs = 1 * 1000 * 1000 * 1000; 111 112 int VSyncWorker::SyntheticWaitVBlank(int64_t *timestamp) { 113 struct timespec vsync; 114 int ret = clock_gettime(CLOCK_MONOTONIC, &vsync); 115 116 int64_t refresh = 60; // Default to 60Hz refresh rate 117 DrmConnector *conn = drm_->GetConnectorForDisplay(display_); 118 if (conn && conn->active_mode().v_refresh()) 119 refresh = conn->active_mode().v_refresh(); 120 else 121 ALOGW("Vsync worker active with conn=%p refresh=%d\n", conn, 122 conn ? conn->active_mode().v_refresh() : -1); 123 124 int64_t phased_timestamp = GetPhasedVSync( 125 kOneSecondNs / refresh, vsync.tv_sec * kOneSecondNs + vsync.tv_nsec); 126 vsync.tv_sec = phased_timestamp / kOneSecondNs; 127 vsync.tv_nsec = phased_timestamp - (vsync.tv_sec * kOneSecondNs); 128 do { 129 ret = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &vsync, NULL); 130 } while (ret == -1 && errno == EINTR); 131 if (ret) 132 return ret; 133 134 *timestamp = (int64_t)vsync.tv_sec * kOneSecondNs + (int64_t)vsync.tv_nsec; 135 return 0; 136 } 137 138 void VSyncWorker::Routine() { 139 int ret = Lock(); 140 if (ret) { 141 ALOGE("Failed to lock worker %d", ret); 142 return; 143 } 144 145 if (!enabled_) { 146 ret = WaitForSignalOrExitLocked(); 147 if (ret == -EINTR) { 148 return; 149 } 150 } 151 152 bool enabled = enabled_; 153 int display = display_; 154 hwc_procs_t const *procs = procs_; 155 156 ret = Unlock(); 157 if (ret) { 158 ALOGE("Failed to unlock worker %d", ret); 159 } 160 161 if (!enabled) 162 return; 163 164 DrmCrtc *crtc = drm_->GetCrtcForDisplay(display); 165 if (!crtc) { 166 ALOGE("Failed to get crtc for display"); 167 return; 168 } 169 uint32_t high_crtc = (crtc->pipe() << DRM_VBLANK_HIGH_CRTC_SHIFT); 170 171 drmVBlank vblank; 172 memset(&vblank, 0, sizeof(vblank)); 173 vblank.request.type = (drmVBlankSeqType)( 174 DRM_VBLANK_RELATIVE | (high_crtc & DRM_VBLANK_HIGH_CRTC_MASK)); 175 vblank.request.sequence = 1; 176 177 int64_t timestamp; 178 ret = drmWaitVBlank(drm_->fd(), &vblank); 179 if (ret == -EINTR) { 180 return; 181 } else if (ret) { 182 ret = SyntheticWaitVBlank(×tamp); 183 if (ret) 184 return; 185 } else { 186 timestamp = (int64_t)vblank.reply.tval_sec * kOneSecondNs + 187 (int64_t)vblank.reply.tval_usec * 1000; 188 } 189 190 /* 191 * There's a race here where a change in procs_ will not take effect until 192 * the next subsequent requested vsync. This is unavoidable since we can't 193 * call the vsync hook while holding the thread lock. 194 * 195 * We could shorten the race window by caching procs_ right before calling 196 * the hook. However, in practice, procs_ is only updated once, so it's not 197 * worth the overhead. 198 */ 199 if (procs && procs->vsync) 200 procs->vsync(procs, display, timestamp); 201 last_timestamp_ = timestamp; 202 } 203 } 204
