1 /*
2 * Copyright (C) 2010 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 ATRACE_TAG ATRACE_TAG_GRAPHICS
18
19 // Uncomment this to remove support for HWC_DEVICE_API_VERSION_0_3 and older
20 #define HWC_REMOVE_DEPRECATED_VERSIONS 1
21
22 #include <stdint.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/types.h>
27
28 #include <utils/Errors.h>
29 #include <utils/misc.h>
30 #include <utils/String8.h>
31 #include <utils/Thread.h>
32 #include <utils/Trace.h>
33 #include <utils/Vector.h>
34
35 #include <ui/GraphicBuffer.h>
36
37 #include <hardware/hardware.h>
38 #include <hardware/hwcomposer.h>
39
40 #include <cutils/log.h>
41 #include <cutils/properties.h>
42
43 #include "Layer.h" // needed only for debugging
44 #include "LayerBase.h"
45 #include "HWComposer.h"
46 #include "SurfaceFlinger.h"
47 #include <utils/CallStack.h>
48
49 namespace android {
50
51 #define MIN_HWC_HEADER_VERSION 0
52
hwcApiVersion(const hwc_composer_device_1_t * hwc)53 static uint32_t hwcApiVersion(const hwc_composer_device_1_t* hwc) {
54 uint32_t hwcVersion = hwc->common.version;
55 if (MIN_HWC_HEADER_VERSION == 0 &&
56 (hwcVersion & HARDWARE_API_VERSION_2_MAJ_MIN_MASK) == 0) {
57 // legacy version encoding
58 hwcVersion <<= 16;
59 }
60 return hwcVersion & HARDWARE_API_VERSION_2_MAJ_MIN_MASK;
61 }
62
hwcHeaderVersion(const hwc_composer_device_1_t * hwc)63 static uint32_t hwcHeaderVersion(const hwc_composer_device_1_t* hwc) {
64 uint32_t hwcVersion = hwc->common.version;
65 if (MIN_HWC_HEADER_VERSION == 0 &&
66 (hwcVersion & HARDWARE_API_VERSION_2_MAJ_MIN_MASK) == 0) {
67 // legacy version encoding
68 hwcVersion <<= 16;
69 }
70 return hwcVersion & HARDWARE_API_VERSION_2_HEADER_MASK;
71 }
72
hwcHasApiVersion(const hwc_composer_device_1_t * hwc,uint32_t version)73 static bool hwcHasApiVersion(const hwc_composer_device_1_t* hwc,
74 uint32_t version) {
75 return hwcApiVersion(hwc) >= (version & HARDWARE_API_VERSION_2_MAJ_MIN_MASK);
76 }
77
78 // ---------------------------------------------------------------------------
79
80 struct HWComposer::cb_context {
81 struct callbacks : public hwc_procs_t {
82 // these are here to facilitate the transition when adding
83 // new callbacks (an implementation can check for NULL before
84 // calling a new callback).
85 void (*zero[4])(void);
86 };
87 callbacks procs;
88 HWComposer* hwc;
89 };
90
91 // ---------------------------------------------------------------------------
92
HWComposer(const sp<SurfaceFlinger> & flinger,EventHandler & handler)93 HWComposer::HWComposer(
94 const sp<SurfaceFlinger>& flinger,
95 EventHandler& handler)
96 : mFlinger(flinger),
97 mFbDev(0), mHwc(0), mNumDisplays(1),
98 mCBContext(new cb_context),
99 mEventHandler(handler),
100 mVSyncCount(0), mDebugForceFakeVSync(false)
101 {
102 for (size_t i =0 ; i<MAX_DISPLAYS ; i++) {
103 mLists[i] = 0;
104 }
105
106 char value[PROPERTY_VALUE_MAX];
107 property_get("debug.sf.no_hw_vsync", value, "0");
108 mDebugForceFakeVSync = atoi(value);
109
110 bool needVSyncThread = true;
111
112 // Note: some devices may insist that the FB HAL be opened before HWC.
113 loadFbHalModule();
114 loadHwcModule();
115
116 if (mFbDev && mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
117 // close FB HAL if we don't needed it.
118 // FIXME: this is temporary until we're not forced to open FB HAL
119 // before HWC.
120 framebuffer_close(mFbDev);
121 mFbDev = NULL;
122 }
123
124 // If we have no HWC, or a pre-1.1 HWC, an FB dev is mandatory.
125 if ((!mHwc || !hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))
126 && !mFbDev) {
127 ALOGE("ERROR: failed to open framebuffer, aborting");
128 abort();
129 }
130
131 // these display IDs are always reserved
132 for (size_t i=0 ; i<HWC_NUM_DISPLAY_TYPES ; i++) {
133 mAllocatedDisplayIDs.markBit(i);
134 }
135
136 if (mHwc) {
137 ALOGI("Using %s version %u.%u", HWC_HARDWARE_COMPOSER,
138 (hwcApiVersion(mHwc) >> 24) & 0xff,
139 (hwcApiVersion(mHwc) >> 16) & 0xff);
140 if (mHwc->registerProcs) {
141 mCBContext->hwc = this;
142 mCBContext->procs.invalidate = &hook_invalidate;
143 mCBContext->procs.vsync = &hook_vsync;
144 if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))
145 mCBContext->procs.hotplug = &hook_hotplug;
146 else
147 mCBContext->procs.hotplug = NULL;
148 memset(mCBContext->procs.zero, 0, sizeof(mCBContext->procs.zero));
149 mHwc->registerProcs(mHwc, &mCBContext->procs);
150 }
151
152 // don't need a vsync thread if we have a hardware composer
153 needVSyncThread = false;
154 // always turn vsync off when we start
155 eventControl(HWC_DISPLAY_PRIMARY, HWC_EVENT_VSYNC, 0);
156
157 // the number of displays we actually have depends on the
158 // hw composer version
159 if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_2)) {
160 // 1.2 adds support for virtual displays
161 mNumDisplays = MAX_DISPLAYS;
162 } else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
163 // 1.1 adds support for multiple displays
164 mNumDisplays = HWC_NUM_DISPLAY_TYPES;
165 } else {
166 mNumDisplays = 1;
167 }
168 }
169
170 if (mFbDev) {
171 ALOG_ASSERT(!(mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)),
172 "should only have fbdev if no hwc or hwc is 1.0");
173
174 DisplayData& disp(mDisplayData[HWC_DISPLAY_PRIMARY]);
175 disp.connected = true;
176 disp.width = mFbDev->width;
177 disp.height = mFbDev->height;
178 disp.format = mFbDev->format;
179 disp.xdpi = mFbDev->xdpi;
180 disp.ydpi = mFbDev->ydpi;
181 if (disp.refresh == 0) {
182 disp.refresh = nsecs_t(1e9 / mFbDev->fps);
183 ALOGW("getting VSYNC period from fb HAL: %lld", disp.refresh);
184 }
185 if (disp.refresh == 0) {
186 disp.refresh = nsecs_t(1e9 / 60.0);
187 ALOGW("getting VSYNC period from thin air: %lld",
188 mDisplayData[HWC_DISPLAY_PRIMARY].refresh);
189 }
190 } else if (mHwc) {
191 // here we're guaranteed to have at least HWC 1.1
192 for (size_t i =0 ; i<HWC_NUM_DISPLAY_TYPES ; i++) {
193 queryDisplayProperties(i);
194 }
195 }
196
197 if (needVSyncThread) {
198 // we don't have VSYNC support, we need to fake it
199 mVSyncThread = new VSyncThread(*this);
200 }
201 }
202
~HWComposer()203 HWComposer::~HWComposer() {
204 if (mHwc) {
205 eventControl(HWC_DISPLAY_PRIMARY, HWC_EVENT_VSYNC, 0);
206 }
207 if (mVSyncThread != NULL) {
208 mVSyncThread->requestExitAndWait();
209 }
210 if (mHwc) {
211 hwc_close_1(mHwc);
212 }
213 if (mFbDev) {
214 framebuffer_close(mFbDev);
215 }
216 delete mCBContext;
217 }
218
219 // Load and prepare the hardware composer module. Sets mHwc.
loadHwcModule()220 void HWComposer::loadHwcModule()
221 {
222 hw_module_t const* module;
223
224 if (hw_get_module(HWC_HARDWARE_MODULE_ID, &module) != 0) {
225 ALOGE("%s module not found", HWC_HARDWARE_MODULE_ID);
226 return;
227 }
228
229 int err = hwc_open_1(module, &mHwc);
230 if (err) {
231 ALOGE("%s device failed to initialize (%s)",
232 HWC_HARDWARE_COMPOSER, strerror(-err));
233 return;
234 }
235
236 if (!hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_0) ||
237 hwcHeaderVersion(mHwc) < MIN_HWC_HEADER_VERSION ||
238 hwcHeaderVersion(mHwc) > HWC_HEADER_VERSION) {
239 ALOGE("%s device version %#x unsupported, will not be used",
240 HWC_HARDWARE_COMPOSER, mHwc->common.version);
241 hwc_close_1(mHwc);
242 mHwc = NULL;
243 return;
244 }
245 }
246
247 // Load and prepare the FB HAL, which uses the gralloc module. Sets mFbDev.
loadFbHalModule()248 void HWComposer::loadFbHalModule()
249 {
250 hw_module_t const* module;
251
252 if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) != 0) {
253 ALOGE("%s module not found", GRALLOC_HARDWARE_MODULE_ID);
254 return;
255 }
256
257 int err = framebuffer_open(module, &mFbDev);
258 if (err) {
259 ALOGE("framebuffer_open failed (%s)", strerror(-err));
260 return;
261 }
262 }
263
initCheck() const264 status_t HWComposer::initCheck() const {
265 return mHwc ? NO_ERROR : NO_INIT;
266 }
267
hook_invalidate(const struct hwc_procs * procs)268 void HWComposer::hook_invalidate(const struct hwc_procs* procs) {
269 cb_context* ctx = reinterpret_cast<cb_context*>(
270 const_cast<hwc_procs_t*>(procs));
271 ctx->hwc->invalidate();
272 }
273
hook_vsync(const struct hwc_procs * procs,int disp,int64_t timestamp)274 void HWComposer::hook_vsync(const struct hwc_procs* procs, int disp,
275 int64_t timestamp) {
276 cb_context* ctx = reinterpret_cast<cb_context*>(
277 const_cast<hwc_procs_t*>(procs));
278 ctx->hwc->vsync(disp, timestamp);
279 }
280
hook_hotplug(const struct hwc_procs * procs,int disp,int connected)281 void HWComposer::hook_hotplug(const struct hwc_procs* procs, int disp,
282 int connected) {
283 cb_context* ctx = reinterpret_cast<cb_context*>(
284 const_cast<hwc_procs_t*>(procs));
285 ctx->hwc->hotplug(disp, connected);
286 }
287
invalidate()288 void HWComposer::invalidate() {
289 mFlinger->repaintEverything();
290 }
291
vsync(int disp,int64_t timestamp)292 void HWComposer::vsync(int disp, int64_t timestamp) {
293 ATRACE_INT("VSYNC", ++mVSyncCount&1);
294 mEventHandler.onVSyncReceived(disp, timestamp);
295 Mutex::Autolock _l(mLock);
296 mLastHwVSync = timestamp;
297 }
298
hotplug(int disp,int connected)299 void HWComposer::hotplug(int disp, int connected) {
300 if (disp == HWC_DISPLAY_PRIMARY || disp >= HWC_NUM_DISPLAY_TYPES) {
301 ALOGE("hotplug event received for invalid display: disp=%d connected=%d",
302 disp, connected);
303 return;
304 }
305 queryDisplayProperties(disp);
306 mEventHandler.onHotplugReceived(disp, bool(connected));
307 }
308
309 static const uint32_t DISPLAY_ATTRIBUTES[] = {
310 HWC_DISPLAY_VSYNC_PERIOD,
311 HWC_DISPLAY_WIDTH,
312 HWC_DISPLAY_HEIGHT,
313 HWC_DISPLAY_DPI_X,
314 HWC_DISPLAY_DPI_Y,
315 HWC_DISPLAY_NO_ATTRIBUTE,
316 };
317 #define NUM_DISPLAY_ATTRIBUTES (sizeof(DISPLAY_ATTRIBUTES) / sizeof(DISPLAY_ATTRIBUTES)[0])
318
319 // http://developer.android.com/reference/android/util/DisplayMetrics.html
320 #define ANDROID_DENSITY_TV 213
321 #define ANDROID_DENSITY_XHIGH 320
322
queryDisplayProperties(int disp)323 status_t HWComposer::queryDisplayProperties(int disp) {
324
325 LOG_ALWAYS_FATAL_IF(!mHwc || !hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1));
326
327 // use zero as default value for unspecified attributes
328 int32_t values[NUM_DISPLAY_ATTRIBUTES - 1];
329 memset(values, 0, sizeof(values));
330
331 uint32_t config;
332 size_t numConfigs = 1;
333 status_t err = mHwc->getDisplayConfigs(mHwc, disp, &config, &numConfigs);
334 if (err != NO_ERROR) {
335 // this can happen if an unpluggable display is not connected
336 mDisplayData[disp].connected = false;
337 return err;
338 }
339
340 err = mHwc->getDisplayAttributes(mHwc, disp, config, DISPLAY_ATTRIBUTES, values);
341 if (err != NO_ERROR) {
342 // we can't get this display's info. turn it off.
343 mDisplayData[disp].connected = false;
344 return err;
345 }
346
347 int32_t w = 0, h = 0;
348 for (size_t i = 0; i < NUM_DISPLAY_ATTRIBUTES - 1; i++) {
349 switch (DISPLAY_ATTRIBUTES[i]) {
350 case HWC_DISPLAY_VSYNC_PERIOD:
351 mDisplayData[disp].refresh = nsecs_t(values[i]);
352 break;
353 case HWC_DISPLAY_WIDTH:
354 mDisplayData[disp].width = values[i];
355 break;
356 case HWC_DISPLAY_HEIGHT:
357 mDisplayData[disp].height = values[i];
358 break;
359 case HWC_DISPLAY_DPI_X:
360 mDisplayData[disp].xdpi = values[i] / 1000.0f;
361 break;
362 case HWC_DISPLAY_DPI_Y:
363 mDisplayData[disp].ydpi = values[i] / 1000.0f;
364 break;
365 default:
366 ALOG_ASSERT(false, "unknown display attribute[%d] %#x",
367 i, DISPLAY_ATTRIBUTES[i]);
368 break;
369 }
370 }
371
372 // FIXME: what should we set the format to?
373 mDisplayData[disp].format = HAL_PIXEL_FORMAT_RGBA_8888;
374 mDisplayData[disp].connected = true;
375 if (mDisplayData[disp].xdpi == 0.0f || mDisplayData[disp].ydpi == 0.0f) {
376 // is there anything smarter we can do?
377 if (h >= 1080) {
378 mDisplayData[disp].xdpi = ANDROID_DENSITY_XHIGH;
379 mDisplayData[disp].ydpi = ANDROID_DENSITY_XHIGH;
380 } else {
381 mDisplayData[disp].xdpi = ANDROID_DENSITY_TV;
382 mDisplayData[disp].ydpi = ANDROID_DENSITY_TV;
383 }
384 }
385 return NO_ERROR;
386 }
387
allocateDisplayId()388 int32_t HWComposer::allocateDisplayId() {
389 if (mAllocatedDisplayIDs.count() >= mNumDisplays) {
390 return NO_MEMORY;
391 }
392 int32_t id = mAllocatedDisplayIDs.firstUnmarkedBit();
393 mAllocatedDisplayIDs.markBit(id);
394 return id;
395 }
396
freeDisplayId(int32_t id)397 status_t HWComposer::freeDisplayId(int32_t id) {
398 if (id < HWC_NUM_DISPLAY_TYPES) {
399 // cannot free the reserved IDs
400 return BAD_VALUE;
401 }
402 if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {
403 return BAD_INDEX;
404 }
405 mAllocatedDisplayIDs.clearBit(id);
406 return NO_ERROR;
407 }
408
getRefreshPeriod(int disp) const409 nsecs_t HWComposer::getRefreshPeriod(int disp) const {
410 return mDisplayData[disp].refresh;
411 }
412
getRefreshTimestamp(int disp) const413 nsecs_t HWComposer::getRefreshTimestamp(int disp) const {
414 // this returns the last refresh timestamp.
415 // if the last one is not available, we estimate it based on
416 // the refresh period and whatever closest timestamp we have.
417 Mutex::Autolock _l(mLock);
418 nsecs_t now = systemTime(CLOCK_MONOTONIC);
419 return now - ((now - mLastHwVSync) % mDisplayData[disp].refresh);
420 }
421
getWidth(int disp) const422 uint32_t HWComposer::getWidth(int disp) const {
423 return mDisplayData[disp].width;
424 }
425
getHeight(int disp) const426 uint32_t HWComposer::getHeight(int disp) const {
427 return mDisplayData[disp].height;
428 }
429
getFormat(int disp) const430 uint32_t HWComposer::getFormat(int disp) const {
431 return mDisplayData[disp].format;
432 }
433
getDpiX(int disp) const434 float HWComposer::getDpiX(int disp) const {
435 return mDisplayData[disp].xdpi;
436 }
437
getDpiY(int disp) const438 float HWComposer::getDpiY(int disp) const {
439 return mDisplayData[disp].ydpi;
440 }
441
isConnected(int disp) const442 bool HWComposer::isConnected(int disp) const {
443 return mDisplayData[disp].connected;
444 }
445
eventControl(int disp,int event,int enabled)446 void HWComposer::eventControl(int disp, int event, int enabled) {
447 if (uint32_t(disp)>31 || !mAllocatedDisplayIDs.hasBit(disp)) {
448 ALOGD("eventControl ignoring event %d on unallocated disp %d (en=%d)",
449 event, disp, enabled);
450 return;
451 }
452 if (event != EVENT_VSYNC) {
453 ALOGW("eventControl got unexpected event %d (disp=%d en=%d)",
454 event, disp, enabled);
455 return;
456 }
457 status_t err = NO_ERROR;
458 if (mHwc && !mDebugForceFakeVSync) {
459 // NOTE: we use our own internal lock here because we have to call
460 // into the HWC with the lock held, and we want to make sure
461 // that even if HWC blocks (which it shouldn't), it won't
462 // affect other threads.
463 Mutex::Autolock _l(mEventControlLock);
464 const int32_t eventBit = 1UL << event;
465 const int32_t newValue = enabled ? eventBit : 0;
466 const int32_t oldValue = mDisplayData[disp].events & eventBit;
467 if (newValue != oldValue) {
468 ATRACE_CALL();
469 err = mHwc->eventControl(mHwc, disp, event, enabled);
470 if (!err) {
471 int32_t& events(mDisplayData[disp].events);
472 events = (events & ~eventBit) | newValue;
473 }
474 }
475 // error here should not happen -- not sure what we should
476 // do if it does.
477 ALOGE_IF(err, "eventControl(%d, %d) failed %s",
478 event, enabled, strerror(-err));
479 }
480
481 if (err == NO_ERROR && mVSyncThread != NULL) {
482 mVSyncThread->setEnabled(enabled);
483 }
484 }
485
createWorkList(int32_t id,size_t numLayers)486 status_t HWComposer::createWorkList(int32_t id, size_t numLayers) {
487 if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {
488 return BAD_INDEX;
489 }
490
491 if (mHwc) {
492 DisplayData& disp(mDisplayData[id]);
493 if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
494 // we need space for the HWC_FRAMEBUFFER_TARGET
495 numLayers++;
496 }
497 if (disp.capacity < numLayers || disp.list == NULL) {
498 size_t size = sizeof(hwc_display_contents_1_t)
499 + numLayers * sizeof(hwc_layer_1_t);
500 free(disp.list);
501 disp.list = (hwc_display_contents_1_t*)malloc(size);
502 disp.capacity = numLayers;
503 }
504 if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
505 disp.framebufferTarget = &disp.list->hwLayers[numLayers - 1];
506 memset(disp.framebufferTarget, 0, sizeof(hwc_layer_1_t));
507 const hwc_rect_t r = { 0, 0, disp.width, disp.height };
508 disp.framebufferTarget->compositionType = HWC_FRAMEBUFFER_TARGET;
509 disp.framebufferTarget->hints = 0;
510 disp.framebufferTarget->flags = 0;
511 disp.framebufferTarget->handle = disp.fbTargetHandle;
512 disp.framebufferTarget->transform = 0;
513 disp.framebufferTarget->blending = HWC_BLENDING_PREMULT;
514 disp.framebufferTarget->sourceCrop = r;
515 disp.framebufferTarget->displayFrame = r;
516 disp.framebufferTarget->visibleRegionScreen.numRects = 1;
517 disp.framebufferTarget->visibleRegionScreen.rects =
518 &disp.framebufferTarget->displayFrame;
519 disp.framebufferTarget->acquireFenceFd = -1;
520 disp.framebufferTarget->releaseFenceFd = -1;
521 }
522 disp.list->retireFenceFd = -1;
523 disp.list->flags = HWC_GEOMETRY_CHANGED;
524 disp.list->numHwLayers = numLayers;
525 }
526 return NO_ERROR;
527 }
528
setFramebufferTarget(int32_t id,const sp<Fence> & acquireFence,const sp<GraphicBuffer> & buf)529 status_t HWComposer::setFramebufferTarget(int32_t id,
530 const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buf) {
531 if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {
532 return BAD_INDEX;
533 }
534 DisplayData& disp(mDisplayData[id]);
535 if (!disp.framebufferTarget) {
536 // this should never happen, but apparently eglCreateWindowSurface()
537 // triggers a SurfaceTextureClient::queueBuffer() on some
538 // devices (!?) -- log and ignore.
539 ALOGE("HWComposer: framebufferTarget is null");
540 // CallStack stack;
541 // stack.update();
542 // stack.dump("");
543 return NO_ERROR;
544 }
545
546 int acquireFenceFd = -1;
547 if (acquireFence != NULL) {
548 acquireFenceFd = acquireFence->dup();
549 }
550
551 // ALOGD("fbPost: handle=%p, fence=%d", buf->handle, acquireFenceFd);
552 disp.fbTargetHandle = buf->handle;
553 disp.framebufferTarget->handle = disp.fbTargetHandle;
554 disp.framebufferTarget->acquireFenceFd = acquireFenceFd;
555 return NO_ERROR;
556 }
557
prepare()558 status_t HWComposer::prepare() {
559 for (size_t i=0 ; i<mNumDisplays ; i++) {
560 DisplayData& disp(mDisplayData[i]);
561 if (disp.framebufferTarget) {
562 // make sure to reset the type to HWC_FRAMEBUFFER_TARGET
563 // DO NOT reset the handle field to NULL, because it's possible
564 // that we have nothing to redraw (eg: eglSwapBuffers() not called)
565 // in which case, we should continue to use the same buffer.
566 LOG_FATAL_IF(disp.list == NULL);
567 disp.framebufferTarget->compositionType = HWC_FRAMEBUFFER_TARGET;
568 }
569 if (!disp.connected && disp.list != NULL) {
570 ALOGW("WARNING: disp %d: connected, non-null list, layers=%d",
571 i, disp.list->numHwLayers);
572 }
573 mLists[i] = disp.list;
574 if (mLists[i]) {
575 if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_2)) {
576 mLists[i]->outbuf = NULL;
577 mLists[i]->outbufAcquireFenceFd = -1;
578 } else if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
579 // garbage data to catch improper use
580 mLists[i]->dpy = (hwc_display_t)0xDEADBEEF;
581 mLists[i]->sur = (hwc_surface_t)0xDEADBEEF;
582 } else {
583 mLists[i]->dpy = EGL_NO_DISPLAY;
584 mLists[i]->sur = EGL_NO_SURFACE;
585 }
586 }
587 }
588
589 int err = mHwc->prepare(mHwc, mNumDisplays, mLists);
590 ALOGE_IF(err, "HWComposer: prepare failed (%s)", strerror(-err));
591
592 if (err == NO_ERROR) {
593 // here we're just making sure that "skip" layers are set
594 // to HWC_FRAMEBUFFER and we're also counting how many layers
595 // we have of each type.
596 for (size_t i=0 ; i<mNumDisplays ; i++) {
597 DisplayData& disp(mDisplayData[i]);
598 disp.hasFbComp = false;
599 disp.hasOvComp = false;
600 if (disp.list) {
601 for (size_t i=0 ; i<disp.list->numHwLayers ; i++) {
602 hwc_layer_1_t& l = disp.list->hwLayers[i];
603
604 //ALOGD("prepare: %d, type=%d, handle=%p",
605 // i, l.compositionType, l.handle);
606
607 if (l.flags & HWC_SKIP_LAYER) {
608 l.compositionType = HWC_FRAMEBUFFER;
609 }
610 if (l.compositionType == HWC_FRAMEBUFFER) {
611 disp.hasFbComp = true;
612 }
613 if (l.compositionType == HWC_OVERLAY) {
614 disp.hasOvComp = true;
615 }
616 }
617 }
618 }
619 }
620 return (status_t)err;
621 }
622
hasHwcComposition(int32_t id) const623 bool HWComposer::hasHwcComposition(int32_t id) const {
624 if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
625 return false;
626 return mDisplayData[id].hasOvComp;
627 }
628
hasGlesComposition(int32_t id) const629 bool HWComposer::hasGlesComposition(int32_t id) const {
630 if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
631 return false;
632 return mDisplayData[id].hasFbComp;
633 }
634
getAndResetReleaseFenceFd(int32_t id)635 int HWComposer::getAndResetReleaseFenceFd(int32_t id) {
636 if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id))
637 return BAD_INDEX;
638
639 int fd = INVALID_OPERATION;
640 if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
641 const DisplayData& disp(mDisplayData[id]);
642 if (disp.framebufferTarget) {
643 fd = disp.framebufferTarget->releaseFenceFd;
644 disp.framebufferTarget->acquireFenceFd = -1;
645 disp.framebufferTarget->releaseFenceFd = -1;
646 }
647 }
648 return fd;
649 }
650
commit()651 status_t HWComposer::commit() {
652 int err = NO_ERROR;
653 if (mHwc) {
654 if (!hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
655 // On version 1.0, the OpenGL ES target surface is communicated
656 // by the (dpy, sur) fields and we are guaranteed to have only
657 // a single display.
658 mLists[0]->dpy = eglGetCurrentDisplay();
659 mLists[0]->sur = eglGetCurrentSurface(EGL_DRAW);
660 }
661
662 err = mHwc->set(mHwc, mNumDisplays, mLists);
663
664 for (size_t i=0 ; i<mNumDisplays ; i++) {
665 DisplayData& disp(mDisplayData[i]);
666 if (disp.list) {
667 if (disp.list->retireFenceFd != -1) {
668 close(disp.list->retireFenceFd);
669 disp.list->retireFenceFd = -1;
670 }
671 disp.list->flags &= ~HWC_GEOMETRY_CHANGED;
672 }
673 }
674 }
675 return (status_t)err;
676 }
677
release(int disp)678 status_t HWComposer::release(int disp) {
679 LOG_FATAL_IF(disp >= HWC_NUM_DISPLAY_TYPES);
680 if (mHwc) {
681 eventControl(disp, HWC_EVENT_VSYNC, 0);
682 return (status_t)mHwc->blank(mHwc, disp, 1);
683 }
684 return NO_ERROR;
685 }
686
acquire(int disp)687 status_t HWComposer::acquire(int disp) {
688 LOG_FATAL_IF(disp >= HWC_NUM_DISPLAY_TYPES);
689 if (mHwc) {
690 return (status_t)mHwc->blank(mHwc, disp, 0);
691 }
692 return NO_ERROR;
693 }
694
disconnectDisplay(int disp)695 void HWComposer::disconnectDisplay(int disp) {
696 LOG_ALWAYS_FATAL_IF(disp < 0 || disp == HWC_DISPLAY_PRIMARY);
697 if (disp >= HWC_NUM_DISPLAY_TYPES) {
698 // nothing to do for these yet
699 return;
700 }
701 DisplayData& dd(mDisplayData[disp]);
702 if (dd.list != NULL) {
703 free(dd.list);
704 dd.list = NULL;
705 dd.framebufferTarget = NULL; // points into dd.list
706 dd.fbTargetHandle = NULL;
707 }
708 }
709
getVisualID() const710 int HWComposer::getVisualID() const {
711 if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
712 // FIXME: temporary hack until HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED
713 // is supported by the implementation. we can only be in this case
714 // if we have HWC 1.1
715 return HAL_PIXEL_FORMAT_RGBA_8888;
716 //return HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;
717 } else {
718 return mFbDev->format;
719 }
720 }
721
supportsFramebufferTarget() const722 bool HWComposer::supportsFramebufferTarget() const {
723 return (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1));
724 }
725
fbPost(int32_t id,const sp<Fence> & acquireFence,const sp<GraphicBuffer> & buffer)726 int HWComposer::fbPost(int32_t id,
727 const sp<Fence>& acquireFence, const sp<GraphicBuffer>& buffer) {
728 if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
729 return setFramebufferTarget(id, acquireFence, buffer);
730 } else {
731 if (acquireFence != NULL) {
732 acquireFence->waitForever(1000, "HWComposer::fbPost");
733 }
734 return mFbDev->post(mFbDev, buffer->handle);
735 }
736 }
737
fbCompositionComplete()738 int HWComposer::fbCompositionComplete() {
739 if (mHwc && hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1))
740 return NO_ERROR;
741
742 if (mFbDev->compositionComplete) {
743 return mFbDev->compositionComplete(mFbDev);
744 } else {
745 return INVALID_OPERATION;
746 }
747 }
748
fbDump(String8 & result)749 void HWComposer::fbDump(String8& result) {
750 if (mFbDev && mFbDev->common.version >= 1 && mFbDev->dump) {
751 const size_t SIZE = 4096;
752 char buffer[SIZE];
753 mFbDev->dump(mFbDev, buffer, SIZE);
754 result.append(buffer);
755 }
756 }
757
758 /*
759 * Helper template to implement a concrete HWCLayer
760 * This holds the pointer to the concrete hwc layer type
761 * and implements the "iterable" side of HWCLayer.
762 */
763 template<typename CONCRETE, typename HWCTYPE>
764 class Iterable : public HWComposer::HWCLayer {
765 protected:
766 HWCTYPE* const mLayerList;
767 HWCTYPE* mCurrentLayer;
Iterable(HWCTYPE * layer)768 Iterable(HWCTYPE* layer) : mLayerList(layer), mCurrentLayer(layer) { }
getLayer() const769 inline HWCTYPE const * getLayer() const { return mCurrentLayer; }
getLayer()770 inline HWCTYPE* getLayer() { return mCurrentLayer; }
~Iterable()771 virtual ~Iterable() { }
772 private:
773 // returns a copy of ourselves
dup()774 virtual HWComposer::HWCLayer* dup() {
775 return new CONCRETE( static_cast<const CONCRETE&>(*this) );
776 }
setLayer(size_t index)777 virtual status_t setLayer(size_t index) {
778 mCurrentLayer = &mLayerList[index];
779 return NO_ERROR;
780 }
781 };
782
783 /*
784 * Concrete implementation of HWCLayer for HWC_DEVICE_API_VERSION_1_0.
785 * This implements the HWCLayer side of HWCIterableLayer.
786 */
787 class HWCLayerVersion1 : public Iterable<HWCLayerVersion1, hwc_layer_1_t> {
788 public:
HWCLayerVersion1(hwc_layer_1_t * layer)789 HWCLayerVersion1(hwc_layer_1_t* layer)
790 : Iterable<HWCLayerVersion1, hwc_layer_1_t>(layer) { }
791
getCompositionType() const792 virtual int32_t getCompositionType() const {
793 return getLayer()->compositionType;
794 }
getHints() const795 virtual uint32_t getHints() const {
796 return getLayer()->hints;
797 }
getAndResetReleaseFenceFd()798 virtual int getAndResetReleaseFenceFd() {
799 int fd = getLayer()->releaseFenceFd;
800 getLayer()->releaseFenceFd = -1;
801 return fd;
802 }
setAcquireFenceFd(int fenceFd)803 virtual void setAcquireFenceFd(int fenceFd) {
804 getLayer()->acquireFenceFd = fenceFd;
805 }
setPerFrameDefaultState()806 virtual void setPerFrameDefaultState() {
807 //getLayer()->compositionType = HWC_FRAMEBUFFER;
808 }
setDefaultState()809 virtual void setDefaultState() {
810 getLayer()->compositionType = HWC_FRAMEBUFFER;
811 getLayer()->hints = 0;
812 getLayer()->flags = HWC_SKIP_LAYER;
813 getLayer()->handle = 0;
814 getLayer()->transform = 0;
815 getLayer()->blending = HWC_BLENDING_NONE;
816 getLayer()->visibleRegionScreen.numRects = 0;
817 getLayer()->visibleRegionScreen.rects = NULL;
818 getLayer()->acquireFenceFd = -1;
819 getLayer()->releaseFenceFd = -1;
820 }
setSkip(bool skip)821 virtual void setSkip(bool skip) {
822 if (skip) {
823 getLayer()->flags |= HWC_SKIP_LAYER;
824 } else {
825 getLayer()->flags &= ~HWC_SKIP_LAYER;
826 }
827 }
setBlending(uint32_t blending)828 virtual void setBlending(uint32_t blending) {
829 getLayer()->blending = blending;
830 }
setTransform(uint32_t transform)831 virtual void setTransform(uint32_t transform) {
832 getLayer()->transform = transform;
833 }
setFrame(const Rect & frame)834 virtual void setFrame(const Rect& frame) {
835 reinterpret_cast<Rect&>(getLayer()->displayFrame) = frame;
836 }
setCrop(const Rect & crop)837 virtual void setCrop(const Rect& crop) {
838 reinterpret_cast<Rect&>(getLayer()->sourceCrop) = crop;
839 }
setVisibleRegionScreen(const Region & reg)840 virtual void setVisibleRegionScreen(const Region& reg) {
841 // Region::getSharedBuffer creates a reference to the underlying
842 // SharedBuffer of this Region, this reference is freed
843 // in onDisplayed()
844 hwc_region_t& visibleRegion = getLayer()->visibleRegionScreen;
845 SharedBuffer const* sb = reg.getSharedBuffer(&visibleRegion.numRects);
846 visibleRegion.rects = reinterpret_cast<hwc_rect_t const *>(sb->data());
847 }
setBuffer(const sp<GraphicBuffer> & buffer)848 virtual void setBuffer(const sp<GraphicBuffer>& buffer) {
849 if (buffer == 0 || buffer->handle == 0) {
850 getLayer()->compositionType = HWC_FRAMEBUFFER;
851 getLayer()->flags |= HWC_SKIP_LAYER;
852 getLayer()->handle = 0;
853 } else {
854 getLayer()->handle = buffer->handle;
855 }
856 }
onDisplayed()857 virtual void onDisplayed() {
858 hwc_region_t& visibleRegion = getLayer()->visibleRegionScreen;
859 SharedBuffer const* sb = SharedBuffer::bufferFromData(visibleRegion.rects);
860 if (sb) {
861 sb->release();
862 // not technically needed but safer
863 visibleRegion.numRects = 0;
864 visibleRegion.rects = NULL;
865 }
866
867 getLayer()->acquireFenceFd = -1;
868 }
869 };
870
871 /*
872 * returns an iterator initialized at a given index in the layer list
873 */
getLayerIterator(int32_t id,size_t index)874 HWComposer::LayerListIterator HWComposer::getLayerIterator(int32_t id, size_t index) {
875 if (uint32_t(id)>31 || !mAllocatedDisplayIDs.hasBit(id)) {
876 return LayerListIterator();
877 }
878 const DisplayData& disp(mDisplayData[id]);
879 if (!mHwc || !disp.list || index > disp.list->numHwLayers) {
880 return LayerListIterator();
881 }
882 return LayerListIterator(new HWCLayerVersion1(disp.list->hwLayers), index);
883 }
884
885 /*
886 * returns an iterator on the beginning of the layer list
887 */
begin(int32_t id)888 HWComposer::LayerListIterator HWComposer::begin(int32_t id) {
889 return getLayerIterator(id, 0);
890 }
891
892 /*
893 * returns an iterator on the end of the layer list
894 */
end(int32_t id)895 HWComposer::LayerListIterator HWComposer::end(int32_t id) {
896 size_t numLayers = 0;
897 if (uint32_t(id) <= 31 && mAllocatedDisplayIDs.hasBit(id)) {
898 const DisplayData& disp(mDisplayData[id]);
899 if (mHwc && disp.list) {
900 numLayers = disp.list->numHwLayers;
901 if (hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
902 // with HWC 1.1, the last layer is always the HWC_FRAMEBUFFER_TARGET,
903 // which we ignore when iterating through the layer list.
904 ALOGE_IF(!numLayers, "mDisplayData[%d].list->numHwLayers is 0", id);
905 if (numLayers) {
906 numLayers--;
907 }
908 }
909 }
910 }
911 return getLayerIterator(id, numLayers);
912 }
913
dump(String8 & result,char * buffer,size_t SIZE) const914 void HWComposer::dump(String8& result, char* buffer, size_t SIZE) const {
915 if (mHwc) {
916 result.appendFormat("Hardware Composer state (version %8x):\n", hwcApiVersion(mHwc));
917 result.appendFormat(" mDebugForceFakeVSync=%d\n", mDebugForceFakeVSync);
918 for (size_t i=0 ; i<mNumDisplays ; i++) {
919 const DisplayData& disp(mDisplayData[i]);
920
921 const Vector< sp<LayerBase> >& visibleLayersSortedByZ =
922 mFlinger->getLayerSortedByZForHwcDisplay(i);
923
924 if (disp.connected) {
925 result.appendFormat(
926 " Display[%d] : %ux%u, xdpi=%f, ydpi=%f, refresh=%lld\n",
927 i, disp.width, disp.height, disp.xdpi, disp.ydpi, disp.refresh);
928 }
929
930 if (disp.list && disp.connected) {
931 result.appendFormat(
932 " numHwLayers=%u, flags=%08x\n",
933 disp.list->numHwLayers, disp.list->flags);
934
935 result.append(
936 " type | handle | hints | flags | tr | blend | format | source crop | frame name \n"
937 "------------+----------+----------+----------+----+-------+----------+---------------------------+--------------------------------\n");
938 // " __________ | ________ | ________ | ________ | __ | _____ | ________ | [_____,_____,_____,_____] | [_____,_____,_____,_____]
939 for (size_t i=0 ; i<disp.list->numHwLayers ; i++) {
940 const hwc_layer_1_t&l = disp.list->hwLayers[i];
941 int32_t format = -1;
942 String8 name("unknown");
943
944 if (i < visibleLayersSortedByZ.size()) {
945 const sp<LayerBase>& layer(visibleLayersSortedByZ[i]);
946 if (layer->getLayer() != NULL) {
947 const sp<GraphicBuffer>& buffer(
948 layer->getLayer()->getActiveBuffer());
949 if (buffer != NULL) {
950 format = buffer->getPixelFormat();
951 }
952 }
953 name = layer->getName();
954 }
955
956 int type = l.compositionType;
957 if (type == HWC_FRAMEBUFFER_TARGET) {
958 name = "HWC_FRAMEBUFFER_TARGET";
959 format = disp.format;
960 }
961
962 static char const* compositionTypeName[] = {
963 "GLES",
964 "HWC",
965 "BACKGROUND",
966 "FB TARGET",
967 "UNKNOWN"};
968 if (type >= NELEM(compositionTypeName))
969 type = NELEM(compositionTypeName) - 1;
970
971 result.appendFormat(
972 " %10s | %08x | %08x | %08x | %02x | %05x | %08x | [%5d,%5d,%5d,%5d] | [%5d,%5d,%5d,%5d] %s\n",
973 compositionTypeName[type],
974 intptr_t(l.handle), l.hints, l.flags, l.transform, l.blending, format,
975 l.sourceCrop.left, l.sourceCrop.top, l.sourceCrop.right, l.sourceCrop.bottom,
976 l.displayFrame.left, l.displayFrame.top, l.displayFrame.right, l.displayFrame.bottom,
977 name.string());
978 }
979 }
980 }
981 }
982
983 if (mHwc && mHwc->dump) {
984 mHwc->dump(mHwc, buffer, SIZE);
985 result.append(buffer);
986 }
987 }
988
989 // ---------------------------------------------------------------------------
990
VSyncThread(HWComposer & hwc)991 HWComposer::VSyncThread::VSyncThread(HWComposer& hwc)
992 : mHwc(hwc), mEnabled(false),
993 mNextFakeVSync(0),
994 mRefreshPeriod(hwc.getRefreshPeriod(HWC_DISPLAY_PRIMARY))
995 {
996 }
997
setEnabled(bool enabled)998 void HWComposer::VSyncThread::setEnabled(bool enabled) {
999 Mutex::Autolock _l(mLock);
1000 if (mEnabled != enabled) {
1001 mEnabled = enabled;
1002 mCondition.signal();
1003 }
1004 }
1005
onFirstRef()1006 void HWComposer::VSyncThread::onFirstRef() {
1007 run("VSyncThread", PRIORITY_URGENT_DISPLAY + PRIORITY_MORE_FAVORABLE);
1008 }
1009
threadLoop()1010 bool HWComposer::VSyncThread::threadLoop() {
1011 { // scope for lock
1012 Mutex::Autolock _l(mLock);
1013 while (!mEnabled) {
1014 mCondition.wait(mLock);
1015 }
1016 }
1017
1018 const nsecs_t period = mRefreshPeriod;
1019 const nsecs_t now = systemTime(CLOCK_MONOTONIC);
1020 nsecs_t next_vsync = mNextFakeVSync;
1021 nsecs_t sleep = next_vsync - now;
1022 if (sleep < 0) {
1023 // we missed, find where the next vsync should be
1024 sleep = (period - ((now - next_vsync) % period));
1025 next_vsync = now + sleep;
1026 }
1027 mNextFakeVSync = next_vsync + period;
1028
1029 struct timespec spec;
1030 spec.tv_sec = next_vsync / 1000000000;
1031 spec.tv_nsec = next_vsync % 1000000000;
1032
1033 int err;
1034 do {
1035 err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL);
1036 } while (err<0 && errno == EINTR);
1037
1038 if (err == 0) {
1039 mHwc.mEventHandler.onVSyncReceived(0, next_vsync);
1040 }
1041
1042 return true;
1043 }
1044
1045 // ---------------------------------------------------------------------------
1046 }; // namespace android
1047