1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 * Copyright (C) 2012-2013, The Linux Foundation. All rights reserved.
4 *
5 * Not a Contribution, Apache license notifications and license are
6 * retained for attribution purposes only.
7
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21 #include <cutils/properties.h>
22 #include <utils/Log.h>
23 #include <fcntl.h>
24 #include <sys/ioctl.h>
25 #include <linux/msm_mdp.h>
26 #include <sys/resource.h>
27 #include <sys/prctl.h>
28 #include "hwc_utils.h"
29 #include "string.h"
30 #include "external.h"
31
32 namespace qhwc {
33
34 #define HWC_VSYNC_THREAD_NAME "hwcVsyncThread"
35
hwc_vsync_control(hwc_context_t * ctx,int dpy,int enable)36 int hwc_vsync_control(hwc_context_t* ctx, int dpy, int enable)
37 {
38 int ret = 0;
39 if(!ctx->vstate.fakevsync &&
40 ioctl(ctx->dpyAttr[dpy].fd, MSMFB_OVERLAY_VSYNC_CTRL,
41 &enable) < 0) {
42 ALOGE("%s: vsync control failed. Dpy=%d, enable=%d : %s",
43 __FUNCTION__, dpy, enable, strerror(errno));
44 ret = -errno;
45 }
46 return ret;
47 }
48
vsync_loop(void * param)49 static void *vsync_loop(void *param)
50 {
51 const char* vsync_timestamp_fb0 = "/sys/class/graphics/fb0/vsync_event";
52 const char* vsync_timestamp_fb1 = "/sys/class/graphics/fb1/vsync_event";
53 int dpy = HWC_DISPLAY_PRIMARY;
54
55 hwc_context_t * ctx = reinterpret_cast<hwc_context_t *>(param);
56
57 char thread_name[64] = HWC_VSYNC_THREAD_NAME;
58 prctl(PR_SET_NAME, (unsigned long) &thread_name, 0, 0, 0);
59 setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY +
60 android::PRIORITY_MORE_FAVORABLE);
61
62 const int MAX_DATA = 64;
63 static char vdata[MAX_DATA];
64
65 uint64_t cur_timestamp=0;
66 ssize_t len = -1;
67 int fd_timestamp = -1;
68 int ret = 0;
69 bool fb1_vsync = false;
70 bool logvsync = false;
71
72 char property[PROPERTY_VALUE_MAX];
73 if(property_get("debug.hwc.fakevsync", property, NULL) > 0) {
74 if(atoi(property) == 1)
75 ctx->vstate.fakevsync = true;
76 }
77
78 if(property_get("debug.hwc.logvsync", property, 0) > 0) {
79 if(atoi(property) == 1)
80 logvsync = true;
81 }
82
83 /* Currently read vsync timestamp from drivers
84 e.g. VSYNC=41800875994
85 */
86 fd_timestamp = open(vsync_timestamp_fb0, O_RDONLY);
87 if (fd_timestamp < 0) {
88 // Make sure fb device is opened before starting this thread so this
89 // never happens.
90 ALOGE ("FATAL:%s:not able to open file:%s, %s", __FUNCTION__,
91 (fb1_vsync) ? vsync_timestamp_fb1 : vsync_timestamp_fb0,
92 strerror(errno));
93 ctx->vstate.fakevsync = true;
94 }
95
96 do {
97 if (LIKELY(!ctx->vstate.fakevsync)) {
98 len = pread(fd_timestamp, vdata, MAX_DATA, 0);
99 if (len < 0) {
100 // If the read was just interrupted - it is not a fatal error
101 // In either case, just continue.
102 if (errno != EAGAIN &&
103 errno != EINTR &&
104 errno != EBUSY) {
105 ALOGE ("FATAL:%s:not able to read file:%s, %s",
106 __FUNCTION__,
107 vsync_timestamp_fb0, strerror(errno));
108 }
109 continue;
110 }
111 // extract timestamp
112 const char *str = vdata;
113 if (!strncmp(str, "VSYNC=", strlen("VSYNC="))) {
114 cur_timestamp = strtoull(str + strlen("VSYNC="), NULL, 0);
115 }
116 } else {
117 usleep(16666);
118 cur_timestamp = systemTime();
119 }
120 // send timestamp to HAL
121 if(ctx->vstate.enable) {
122 ALOGD_IF (logvsync, "%s: timestamp %llu sent to HWC for %s",
123 __FUNCTION__, cur_timestamp, "fb0");
124 ctx->proc->vsync(ctx->proc, dpy, cur_timestamp);
125 }
126
127 } while (true);
128 if(fd_timestamp >= 0)
129 close (fd_timestamp);
130
131 return NULL;
132 }
133
init_vsync_thread(hwc_context_t * ctx)134 void init_vsync_thread(hwc_context_t* ctx)
135 {
136 int ret;
137 pthread_t vsync_thread;
138 ALOGI("Initializing VSYNC Thread");
139 ret = pthread_create(&vsync_thread, NULL, vsync_loop, (void*) ctx);
140 if (ret) {
141 ALOGE("%s: failed to create %s: %s", __FUNCTION__,
142 HWC_VSYNC_THREAD_NAME, strerror(ret));
143 }
144 }
145
146 }; //namespace
147