/* * Copyright (C) 2010 The Android Open Source Project * Copyright (C) 2012-2015, The Linux Foundation. All rights reserved. * * Not a Contribution, Apache license notifications and license are retained * for attribution purposes only. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL) #include #include #include #include #include #include #include #include #include #include #include #include "hwc_utils.h" #include "hwc_fbupdate.h" #include "hwc_mdpcomp.h" #include "hwc_dump_layers.h" #include "hdmi.h" #include "hwc_copybit.h" #include "hwc_ad.h" #include "profiler.h" #include "hwc_virtual.h" using namespace qhwc; using namespace overlay; #define VSYNC_DEBUG 0 #define POWER_MODE_DEBUG 1 static int hwc_device_open(const struct hw_module_t* module, const char* name, struct hw_device_t** device); static struct hw_module_methods_t hwc_module_methods = { open: hwc_device_open }; static void reset_panel(struct hwc_composer_device_1* dev); hwc_module_t HAL_MODULE_INFO_SYM = { common: { tag: HARDWARE_MODULE_TAG, version_major: 2, version_minor: 0, id: HWC_HARDWARE_MODULE_ID, name: "Qualcomm Hardware Composer Module", author: "CodeAurora Forum", methods: &hwc_module_methods, dso: 0, reserved: {0}, } }; /* * Save callback functions registered to HWC */ static void hwc_registerProcs(struct hwc_composer_device_1* dev, hwc_procs_t const* procs) { ALOGI("%s", __FUNCTION__); hwc_context_t* ctx = (hwc_context_t*)(dev); if(!ctx) { ALOGE("%s: Invalid context", __FUNCTION__); return; } ctx->proc = procs; // Now that we have the functions needed, kick off // the uevent & vsync threads init_uevent_thread(ctx); init_vsync_thread(ctx); } static void setPaddingRound(hwc_context_t *ctx, int numDisplays, hwc_display_contents_1_t** displays) { ctx->isPaddingRound = false; for(int i = 0; i < numDisplays; i++) { hwc_display_contents_1_t *list = displays[i]; if (LIKELY(list && list->numHwLayers > 0)) { if((ctx->mPrevHwLayerCount[i] == 1 or ctx->mPrevHwLayerCount[i] == 0) and (list->numHwLayers > 1)) { /* If the previous cycle for dpy 'i' has 0 AppLayers and the * current cycle has atleast 1 AppLayer, padding round needs * to be invoked in current cycle on all the active displays * to free up the resources. */ ctx->isPaddingRound = true; } ctx->mPrevHwLayerCount[i] = (int)list->numHwLayers; } else { ctx->mPrevHwLayerCount[i] = 0; } } } /* Based on certain conditions, isDMAStateChanging will be set * to make this function self-contained */ static void setDMAState(hwc_context_t *ctx, int numDisplays, hwc_display_contents_1_t** displays) { ctx->isDMAStateChanging = false; if(ctx->mRotMgr->getNumActiveSessions() == 0) Overlay::setDMAMode(Overlay::DMA_LINE_MODE); for(int dpy = 0; dpy < numDisplays; dpy++) { hwc_display_contents_1_t *list = displays[dpy]; if (LIKELY(list && list->numHwLayers > 0)) { for(size_t layerIndex = 0; layerIndex < list->numHwLayers; layerIndex++) { if(list->hwLayers[layerIndex].compositionType != HWC_FRAMEBUFFER_TARGET) { hwc_layer_1_t const* layer = &list->hwLayers[layerIndex]; private_handle_t *hnd = (private_handle_t *)layer->handle; /* If a layer requires rotation, set the DMA state * to BLOCK_MODE */ if (canUseRotator(ctx, dpy) && (has90Transform(layer) || getRotDownscale(ctx, layer)) && isRotationDoable(ctx, hnd)) { if(not (ctx->mOverlay->isDMAMultiplexingSupported() && dpy)) { if(ctx->mOverlay->isPipeTypeAttached( overlay::utils::OV_MDP_PIPE_DMA)) ctx->isDMAStateChanging = true; } Overlay::setDMAMode(Overlay::DMA_BLOCK_MODE); } } } if(dpy) { /* Uncomment the below code for testing purpose. Assuming the orientation value is in terms of HAL_TRANSFORM, this needs mapping to HAL, if its in different convention */ /* char value[PROPERTY_VALUE_MAX]; property_get("sys.ext_orientation", value, "0"); ctx->mExtOrientation = atoi(value);*/ if(ctx->mExtOrientation || ctx->mBufferMirrorMode) { if(ctx->mOverlay->isPipeTypeAttached( overlay::utils::OV_MDP_PIPE_DMA)) { ctx->isDMAStateChanging = true; } Overlay::setDMAMode(Overlay::DMA_BLOCK_MODE); } } } } } static void setNumActiveDisplays(hwc_context_t *ctx, int numDisplays, hwc_display_contents_1_t** displays) { ctx->numActiveDisplays = 0; for(int i = 0; i < numDisplays; i++) { hwc_display_contents_1_t *list = displays[i]; if (LIKELY(list && list->numHwLayers > 0)) { /* For display devices like SSD and screenrecord, we cannot * rely on isActive and connected attributes of dpyAttr to * determine if the displaydevice is active. Hence in case if * the layer-list is non-null and numHwLayers > 0, we assume * the display device to be active. */ ctx->numActiveDisplays += 1; } } } static bool isHotPluggable(hwc_context_t *ctx, int dpy) { return ((dpy == HWC_DISPLAY_EXTERNAL) || ((dpy == HWC_DISPLAY_PRIMARY) && ctx->mHDMIDisplay->isHDMIPrimaryDisplay())); } static void reset(hwc_context_t *ctx, int numDisplays, hwc_display_contents_1_t** displays) { for(int i = 0; i < numDisplays; i++) { hwc_display_contents_1_t *list = displays[i]; // XXX:SurfaceFlinger no longer guarantees that this // value is reset on every prepare. However, for the layer // cache we need to reset it. // We can probably rethink that later on if (LIKELY(list && list->numHwLayers > 0)) { for(size_t j = 0; j < list->numHwLayers; j++) { if(list->hwLayers[j].compositionType != HWC_FRAMEBUFFER_TARGET) list->hwLayers[j].compositionType = HWC_FRAMEBUFFER; } } if(ctx->mMDPComp[i]) ctx->mMDPComp[i]->reset(); if(ctx->mFBUpdate[i]) ctx->mFBUpdate[i]->reset(); if(ctx->mCopyBit[i]) ctx->mCopyBit[i]->reset(); if(ctx->mLayerRotMap[i]) ctx->mLayerRotMap[i]->reset(); } ctx->mAD->reset(); } static void scaleDisplayFrame(hwc_context_t *ctx, int dpy, hwc_display_contents_1_t *list) { uint32_t origXres = ctx->dpyAttr[dpy].xres; uint32_t origYres = ctx->dpyAttr[dpy].yres; uint32_t newXres = ctx->dpyAttr[dpy].xres_new; uint32_t newYres = ctx->dpyAttr[dpy].yres_new; float xresRatio = (float)origXres / (float)newXres; float yresRatio = (float)origYres / (float)newYres; for (size_t i = 0; i < list->numHwLayers; i++) { hwc_layer_1_t *layer = &list->hwLayers[i]; hwc_rect_t& displayFrame = layer->displayFrame; hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf); uint32_t layerWidth = displayFrame.right - displayFrame.left; uint32_t layerHeight = displayFrame.bottom - displayFrame.top; displayFrame.left = (int)(xresRatio * (float)displayFrame.left); displayFrame.top = (int)(yresRatio * (float)displayFrame.top); displayFrame.right = (int)((float)displayFrame.left + (float)layerWidth * xresRatio); displayFrame.bottom = (int)((float)displayFrame.top + (float)layerHeight * yresRatio); } } static void hwc_configure_color_temp(hwc_composer_device_1* dev) { hwc_context_t* ctx = (hwc_context_t*)(dev); char value[PROPERTY_VALUE_MAX]; bool cool; property_get("persist.sys.debug.color_temp", value, "x"); cool = (value[0] == '1'); if ((value[0] == '0' || value[0] == '1') && cool != ctx->mCoolColorTemperatureEnabled) { ctx->mCoolColorTemperatureEnabled = cool; ALOGI("Color temperature change. Cool = %d", cool ? 1 : 0); int fd = open("/sys/class/graphics/fb0/color_temp", O_WRONLY); if (fd >= 0) { if (cool) write(fd, "1", 2); else write(fd, "0", 2); close(fd); } else { ALOGE("Failed to open color_temp file with result=%d", fd); } } } static int hwc_prepare_primary(hwc_composer_device_1 *dev, hwc_display_contents_1_t *list) { ATRACE_CALL(); hwc_context_t* ctx = (hwc_context_t*)(dev); const int dpy = HWC_DISPLAY_PRIMARY; bool fbComp = false; if (!ctx->mDefaultModeApplied) applyDefaultMode(ctx); if (LIKELY(list && list->numHwLayers > 1) && ctx->dpyAttr[dpy].connected && (ctx->dpyAttr[dpy].isActive || ctx->mHDMIDisplay->isHDMIPrimaryDisplay()) && !ctx->dpyAttr[dpy].isPause) { // When HDMI is primary we should rely on the first valid // draw call in order to activate the display if (!ctx->dpyAttr[dpy].isActive) { // If the cable is connected after HWC initialization and before // the UEvent thread is initialized then we will miss the ONLINE // event. We need to update the display appropriately when we get // the first valid frame. int cableConnected = ctx->mHDMIDisplay->getConnectedState(); if ((cableConnected == 1) && !ctx->dpyAttr[dpy].connected) { qhwc::handle_online(ctx, dpy); } ctx->mHDMIDisplay->activateDisplay(); ctx->dpyAttr[dpy].isActive = true; } if (ctx->dpyAttr[dpy].customFBSize && list->flags & HWC_GEOMETRY_CHANGED) scaleDisplayFrame(ctx, dpy, list); reset_layer_prop(ctx, dpy, (int)list->numHwLayers - 1); setListStats(ctx, list, dpy); fbComp = (ctx->mMDPComp[dpy]->prepare(ctx, list) < 0); if (fbComp) { const int fbZ = 0; if(not ctx->mFBUpdate[dpy]->prepareAndValidate(ctx, list, fbZ)) { ctx->mOverlay->clear(dpy); ctx->mLayerRotMap[dpy]->clear(); } } if (ctx->mMDP.version < qdutils::MDP_V4_0) { if(ctx->mCopyBit[dpy]) ctx->mCopyBit[dpy]->prepare(ctx, list, dpy); } setGPUHint(ctx, list); } return 0; } static int hwc_prepare_external(hwc_composer_device_1 *dev, hwc_display_contents_1_t *list) { ATRACE_CALL(); hwc_context_t* ctx = (hwc_context_t*)(dev); const int dpy = HWC_DISPLAY_EXTERNAL; if (LIKELY(list && list->numHwLayers > 1) && ctx->dpyAttr[dpy].isActive && ctx->dpyAttr[dpy].connected) { reset_layer_prop(ctx, dpy, (int)list->numHwLayers - 1); if(!ctx->dpyAttr[dpy].isPause) { ctx->dpyAttr[dpy].isConfiguring = false; setListStats(ctx, list, dpy); if(ctx->mMDPComp[dpy]->prepare(ctx, list) < 0) { const int fbZ = 0; if(not ctx->mFBUpdate[dpy]->prepareAndValidate(ctx, list, fbZ)) { ctx->mOverlay->clear(dpy); ctx->mLayerRotMap[dpy]->clear(); } } } else { /* External Display is in Pause state. * Mark all application layers as OVERLAY so that * GPU will not compose. */ for(size_t i = 0 ;i < (size_t)(list->numHwLayers - 1); i++) { hwc_layer_1_t *layer = &list->hwLayers[i]; layer->compositionType = HWC_OVERLAY; } } } return 0; } static int hwc_prepare(hwc_composer_device_1 *dev, size_t numDisplays, hwc_display_contents_1_t** displays) { int ret = 0; hwc_context_t* ctx = (hwc_context_t*)(dev); if (ctx->mPanelResetStatus) { ALOGW("%s: panel is in bad state. reset the panel", __FUNCTION__); reset_panel(dev); } //Will be unlocked at the end of set ctx->mDrawLock.lock(); setPaddingRound(ctx, (int)numDisplays, displays); setDMAState(ctx, (int)numDisplays, displays); setNumActiveDisplays(ctx, (int)numDisplays, displays); reset(ctx, (int)numDisplays, displays); ctx->mOverlay->configBegin(); ctx->mRotMgr->configBegin(); overlay::Writeback::configBegin(); for (int32_t dpy = ((int32_t)numDisplays-1); dpy >=0 ; dpy--) { hwc_display_contents_1_t *list = displays[dpy]; resetROI(ctx, dpy); switch(dpy) { case HWC_DISPLAY_PRIMARY: ret = hwc_prepare_primary(dev, list); break; case HWC_DISPLAY_EXTERNAL: ret = hwc_prepare_external(dev, list); break; case HWC_DISPLAY_VIRTUAL: if(ctx->mHWCVirtual) ret = ctx->mHWCVirtual->prepare(dev, list); break; default: ret = -EINVAL; } } ctx->mOverlay->configDone(); ctx->mRotMgr->configDone(); overlay::Writeback::configDone(); // If VD list is deleted, mdp overlay pipe objects and writeback object // are deleted as part of configDone functions. // Proceed with HWCVirtualVDS object deletion. if(ctx->mHWCVirtual) ctx->mHWCVirtual->destroy(ctx, numDisplays, displays); return ret; } static int hwc_eventControl(struct hwc_composer_device_1* dev, int dpy, int event, int enable) { ATRACE_CALL(); int ret = 0; hwc_context_t* ctx = (hwc_context_t*)(dev); switch(event) { case HWC_EVENT_VSYNC: if (ctx->vstate.enable == enable) break; ret = hwc_vsync_control(ctx, dpy, enable); if(ret == 0) ctx->vstate.enable = !!enable; ALOGD_IF (VSYNC_DEBUG, "VSYNC state changed to %s", (enable)?"ENABLED":"DISABLED"); break; #ifdef QCOM_BSP case HWC_EVENT_ORIENTATION: if(dpy == HWC_DISPLAY_PRIMARY) { Locker::Autolock _l(ctx->mDrawLock); // store the primary display orientation ctx->deviceOrientation = enable; } break; #endif default: ret = -EINVAL; } return ret; } static int hwc_setPowerMode(struct hwc_composer_device_1* dev, int dpy, int mode) { ATRACE_CALL(); hwc_context_t* ctx = (hwc_context_t*)(dev); int ret = 0, value = 0; Locker::Autolock _l(ctx->mDrawLock); ALOGD_IF(POWER_MODE_DEBUG, "%s: Setting mode %d on display: %d", __FUNCTION__, mode, dpy); switch(mode) { case HWC_POWER_MODE_OFF: // free up all the overlay pipes in use // when we get a blank for either display // makes sure that all pipes are freed ctx->mOverlay->configBegin(); ctx->mOverlay->configDone(); ctx->mRotMgr->clear(); // If VDS is connected, do not clear WB object as it // will end up detaching IOMMU. This is required // to send black frame to WFD sink on power suspend. // Note: With this change, we keep the WriteBack object // alive on power suspend for AD use case. value = FB_BLANK_POWERDOWN; break; case HWC_POWER_MODE_DOZE: case HWC_POWER_MODE_DOZE_SUSPEND: value = FB_BLANK_VSYNC_SUSPEND; break; case HWC_POWER_MODE_NORMAL: value = FB_BLANK_UNBLANK; break; } switch(dpy) { case HWC_DISPLAY_PRIMARY: if(ctx->mHDMIDisplay->isHDMIPrimaryDisplay()) { if(ctx->dpyAttr[dpy].connected) { // When HDMI is connected as primary we clean up resources // and call commit to generate a black frame on the interface. // However, we do not call blank since we need the timing // generator and HDMI core to remain turned on. if((mode == HWC_POWER_MODE_OFF) && (!Overlay::displayCommit(ctx->dpyAttr[dpy].fd))) { ALOGE("%s: display commit fail for %d", __FUNCTION__, dpy); ret = -1; } } } else { if(ioctl(ctx->dpyAttr[dpy].fd, FBIOBLANK, value) < 0 ) { ALOGE("%s: ioctl FBIOBLANK failed for Primary with error %s" " value %d", __FUNCTION__, strerror(errno), value); return -errno; } if(mode == HWC_POWER_MODE_NORMAL && !ctx->mHPDEnabled) { // Enable HPD here, as during bootup POWER_MODE_NORMAL is set // when SF is completely initialized ctx->mHDMIDisplay->setHPD(1); ctx->mHPDEnabled = true; } ctx->dpyAttr[dpy].isActive = not(mode == HWC_POWER_MODE_OFF); } //Deliberate fall through since there is no explicit power mode for //virtual displays. case HWC_DISPLAY_VIRTUAL: if(ctx->dpyAttr[HWC_DISPLAY_VIRTUAL].connected) { const int dpy = HWC_DISPLAY_VIRTUAL; if(mode == HWC_POWER_MODE_OFF and (not ctx->dpyAttr[dpy].isPause)) { if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd)) { ALOGE("%s: displayCommit failed for virtual", __FUNCTION__); ret = -1; } } ctx->dpyAttr[dpy].isActive = not(mode == HWC_POWER_MODE_OFF); } break; case HWC_DISPLAY_EXTERNAL: if(mode == HWC_POWER_MODE_OFF) { if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd)) { ALOGE("%s: displayCommit failed for external", __FUNCTION__); ret = -1; } } ctx->dpyAttr[dpy].isActive = not(mode == HWC_POWER_MODE_OFF); break; default: return -EINVAL; } // Configure the color temperature hwc_configure_color_temp(dev); ALOGD_IF(POWER_MODE_DEBUG, "%s: Done setting mode %d on display %d", __FUNCTION__, mode, dpy); return ret; } static void reset_panel(struct hwc_composer_device_1* dev) { int ret = 0; hwc_context_t* ctx = (hwc_context_t*)(dev); if (!ctx->dpyAttr[HWC_DISPLAY_PRIMARY].isActive) { ALOGD ("%s : Display OFF - Skip BLANK & UNBLANK", __FUNCTION__); ctx->mPanelResetStatus = false; return; } ALOGD("%s: setting power mode off", __FUNCTION__); ret = hwc_setPowerMode(dev, HWC_DISPLAY_PRIMARY, HWC_POWER_MODE_OFF); if (ret < 0) { ALOGE("%s: FBIOBLANK failed to BLANK: %s", __FUNCTION__, strerror(errno)); } ALOGD("%s: setting power mode normal and enabling vsync", __FUNCTION__); ret = hwc_setPowerMode(dev, HWC_DISPLAY_PRIMARY, HWC_POWER_MODE_NORMAL); if (ret < 0) { ALOGE("%s: FBIOBLANK failed to UNBLANK : %s", __FUNCTION__, strerror(errno)); } hwc_vsync_control(ctx, HWC_DISPLAY_PRIMARY, 1); ctx->mPanelResetStatus = false; } static int hwc_query(struct hwc_composer_device_1* dev, int param, int* value) { hwc_context_t* ctx = (hwc_context_t*)(dev); int supported = HWC_DISPLAY_PRIMARY_BIT; switch (param) { case HWC_BACKGROUND_LAYER_SUPPORTED: // Not supported for now value[0] = 0; break; case HWC_DISPLAY_TYPES_SUPPORTED: if(ctx->mMDP.hasOverlay) { supported |= HWC_DISPLAY_VIRTUAL_BIT; if(!(qdutils::MDPVersion::getInstance().is8x26() || qdutils::MDPVersion::getInstance().is8x16() || qdutils::MDPVersion::getInstance().is8x39())) supported |= HWC_DISPLAY_EXTERNAL_BIT; } value[0] = supported; break; case HWC_FORMAT_RB_SWAP: value[0] = 1; break; case HWC_COLOR_FILL: value[0] = 1; break; default: return -EINVAL; } return 0; } static int hwc_set_primary(hwc_context_t *ctx, hwc_display_contents_1_t* list) { ATRACE_CALL(); int ret = 0; const int dpy = HWC_DISPLAY_PRIMARY; if (LIKELY(list) && ctx->dpyAttr[dpy].isActive && !ctx->dpyAttr[dpy].isPause) { size_t last = list->numHwLayers - 1; hwc_layer_1_t *fbLayer = &list->hwLayers[last]; int fd = -1; //FenceFD from the Copybit(valid in async mode) bool copybitDone = false; if (ctx->mCopyBit[dpy]) { if (ctx->mMDP.version < qdutils::MDP_V4_0) copybitDone = ctx->mCopyBit[dpy]->draw(ctx, list, dpy, &fd); else fd = ctx->mMDPComp[dpy]->drawOverlap(ctx, list); } if(list->numHwLayers > 1) hwc_sync(ctx, list, dpy, fd); // Dump the layers for primary if(ctx->mHwcDebug[dpy]) ctx->mHwcDebug[dpy]->dumpLayers(list); if (!ctx->mMDPComp[dpy]->draw(ctx, list)) { ALOGE("%s: MDPComp draw failed", __FUNCTION__); ret = -1; } //TODO We dont check for SKIP flag on this layer because we need PAN //always. Last layer is always FB private_handle_t *hnd = (private_handle_t *)fbLayer->handle; if(copybitDone && ctx->mMDP.version >= qdutils::MDP_V4_0) { hnd = ctx->mCopyBit[dpy]->getCurrentRenderBuffer(); } if(isAbcInUse(ctx) == true) { int index = ctx->listStats[dpy].renderBufIndexforABC; hwc_layer_1_t *tempLayer = &list->hwLayers[index]; hnd = (private_handle_t *)tempLayer->handle; } if(hnd) { if (!ctx->mFBUpdate[dpy]->draw(ctx, hnd)) { ALOGE("%s: FBUpdate draw failed", __FUNCTION__); ret = -1; } } /* When source split is enabled, right ROI will always be NULL since the * ROI for the whole panel generated in a single coordinate system will * be populuated in left ROI. So leave the right ROI untouched */ int lSplit = qdutils::MDPVersion::getInstance().isSrcSplit() ? 0 : (isDisplaySplit(ctx, dpy) ? getLeftSplit(ctx, dpy) : 0); qhwc::ovutils::Dim lRoi = qhwc::ovutils::Dim( ctx->listStats[dpy].lRoi.left, ctx->listStats[dpy].lRoi.top, ctx->listStats[dpy].lRoi.right - ctx->listStats[dpy].lRoi.left, ctx->listStats[dpy].lRoi.bottom - ctx->listStats[dpy].lRoi.top); qhwc::ovutils::Dim rRoi = qhwc::ovutils::Dim( ctx->listStats[dpy].rRoi.left - lSplit, ctx->listStats[dpy].rRoi.top, ctx->listStats[dpy].rRoi.right - ctx->listStats[dpy].rRoi.left, ctx->listStats[dpy].rRoi.bottom - ctx->listStats[dpy].rRoi.top); if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd, lRoi, rRoi)) { ALOGE("%s: display commit fail for %d dpy!", __FUNCTION__, dpy); ret = -1; } } closeAcquireFds(list); return ret; } static int hwc_set_external(hwc_context_t *ctx, hwc_display_contents_1_t* list) { ATRACE_CALL(); int ret = 0; const int dpy = HWC_DISPLAY_EXTERNAL; if (LIKELY(list) && ctx->dpyAttr[dpy].isActive && ctx->dpyAttr[dpy].connected && !ctx->dpyAttr[dpy].isPause) { size_t last = list->numHwLayers - 1; hwc_layer_1_t *fbLayer = &list->hwLayers[last]; int fd = -1; //FenceFD from the Copybit(valid in async mode) bool copybitDone = false; if(ctx->mCopyBit[dpy]) copybitDone = ctx->mCopyBit[dpy]->draw(ctx, list, dpy, &fd); if(list->numHwLayers > 1) hwc_sync(ctx, list, dpy, fd); // Dump the layers for external if(ctx->mHwcDebug[dpy]) ctx->mHwcDebug[dpy]->dumpLayers(list); if (!ctx->mMDPComp[dpy]->draw(ctx, list)) { ALOGE("%s: MDPComp draw failed", __FUNCTION__); ret = -1; } private_handle_t *hnd = (private_handle_t *)fbLayer->handle; if(copybitDone) { hnd = ctx->mCopyBit[dpy]->getCurrentRenderBuffer(); } if(hnd) { if (!ctx->mFBUpdate[dpy]->draw(ctx, hnd)) { ALOGE("%s: FBUpdate::draw fail!", __FUNCTION__); ret = -1; } } if(!Overlay::displayCommit(ctx->dpyAttr[dpy].fd)) { ALOGE("%s: display commit fail for %d dpy!", __FUNCTION__, dpy); ret = -1; } } closeAcquireFds(list); return ret; } static int hwc_set(hwc_composer_device_1 *dev, size_t numDisplays, hwc_display_contents_1_t** displays) { int ret = 0; hwc_context_t* ctx = (hwc_context_t*)(dev); for (int dpy = 0; dpy < (int)numDisplays; dpy++) { hwc_display_contents_1_t* list = displays[dpy]; switch(dpy) { case HWC_DISPLAY_PRIMARY: ret = hwc_set_primary(ctx, list); break; case HWC_DISPLAY_EXTERNAL: ret = hwc_set_external(ctx, list); break; case HWC_DISPLAY_VIRTUAL: if(ctx->mHWCVirtual) ret = ctx->mHWCVirtual->set(ctx, list); break; default: ret = -EINVAL; } } // This is only indicative of how many times SurfaceFlinger posts // frames to the display. CALC_FPS(); MDPComp::resetIdleFallBack(); ctx->mVideoTransFlag = false; //Was locked at the beginning of prepare ctx->mDrawLock.unlock(); return ret; } int hwc_getDisplayConfigs(struct hwc_composer_device_1* dev, int disp, uint32_t* configs, size_t* numConfigs) { hwc_context_t* ctx = (hwc_context_t*)(dev); Locker::Autolock _l(ctx->mDrawLock); bool hotPluggable = isHotPluggable(ctx, disp); bool isVirtualDisplay = (disp == HWC_DISPLAY_VIRTUAL); // If hotpluggable or virtual displays are inactive return error if ((hotPluggable || isVirtualDisplay) && !ctx->dpyAttr[disp].connected) { ALOGE("%s display (%d) is inactive", __FUNCTION__, disp); return -EINVAL; } if (*numConfigs <= 0) { ALOGE("%s Invalid number of configs (%zu)", __FUNCTION__, *numConfigs); return -EINVAL; } switch(disp) { case HWC_DISPLAY_PRIMARY: if (hotPluggable) { ctx->mHDMIDisplay->getDisplayConfigs(configs, numConfigs); } else { if(ctx->mColorMode->getNumModes() > 0) { *numConfigs = ctx->mColorMode->getNumModes(); for (size_t i = 0; i < *numConfigs; i++) configs[i] = (uint32_t) i; } else { configs[0] = 0; *numConfigs = 1; } } break; case HWC_DISPLAY_EXTERNAL: ctx->mHDMIDisplay->getDisplayConfigs(configs, numConfigs); break; case HWC_DISPLAY_VIRTUAL: configs[0] = 0; *numConfigs = 1; break; } return 0; } int hwc_getDisplayAttributes(struct hwc_composer_device_1* dev, int disp, uint32_t config, const uint32_t* attributes, int32_t* values) { hwc_context_t* ctx = (hwc_context_t*)(dev); Locker::Autolock _l(ctx->mDrawLock); bool hotPluggable = isHotPluggable(ctx, disp); bool isVirtualDisplay = (disp == HWC_DISPLAY_VIRTUAL); // If hotpluggable or virtual displays are inactive return error if ((hotPluggable || isVirtualDisplay) && !ctx->dpyAttr[disp].connected) { ALOGE("%s display (%d) is inactive", __FUNCTION__, disp); return -EINVAL; } uint32_t xres = 0, yres = 0, refresh = 0; int ret = 0; if (hotPluggable) { ret = ctx->mHDMIDisplay->getAttrForConfig(config, xres, yres, refresh); if(ret < 0) { ALOGE("%s Error getting attributes for config %d", __FUNCTION__, config); return ret; } } for (size_t i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++) { switch (attributes[i]) { case HWC_DISPLAY_VSYNC_PERIOD: values[i] = hotPluggable ? refresh : ctx->dpyAttr[disp].vsync_period; break; case HWC_DISPLAY_WIDTH: if (ctx->dpyAttr[disp].customFBSize) values[i] = ctx->dpyAttr[disp].xres_new; else values[i] = hotPluggable ? xres : ctx->dpyAttr[disp].xres; ALOGD("%s disp = %d, width = %d",__FUNCTION__, disp, values[i]); break; case HWC_DISPLAY_HEIGHT: if (ctx->dpyAttr[disp].customFBSize) values[i] = ctx->dpyAttr[disp].yres_new; else values[i] = hotPluggable ? yres : ctx->dpyAttr[disp].yres; ALOGD("%s disp = %d, height = %d",__FUNCTION__, disp, values[i]); break; case HWC_DISPLAY_DPI_X: values[i] = (int32_t) (ctx->dpyAttr[disp].xdpi*1000.0); break; case HWC_DISPLAY_DPI_Y: values[i] = (int32_t) (ctx->dpyAttr[disp].ydpi*1000.0); break; case HWC_DISPLAY_COLOR_TRANSFORM: values[i] = ctx->mColorMode->getModeForIndex(config); break; default: ALOGE("Unknown display attribute %d", attributes[i]); return -EINVAL; } } return 0; } void hwc_dump(struct hwc_composer_device_1* dev, char *buff, int buff_len) { hwc_context_t* ctx = (hwc_context_t*)(dev); Locker::Autolock _l(ctx->mDrawLock); android::String8 aBuf(""); dumpsys_log(aBuf, "Qualcomm HWC state:\n"); dumpsys_log(aBuf, " MDPVersion=%d\n", ctx->mMDP.version); dumpsys_log(aBuf, " DisplayPanel=%c\n", ctx->mMDP.panel); dumpsys_log(aBuf, " DynRefreshRate=%d\n", ctx->dpyAttr[HWC_DISPLAY_PRIMARY].dynRefreshRate); for(int dpy = 0; dpy < HWC_NUM_DISPLAY_TYPES; dpy++) { if(ctx->mMDPComp[dpy]) ctx->mMDPComp[dpy]->dump(aBuf, ctx); } char ovDump[2048] = {'\0'}; ctx->mOverlay->getDump(ovDump, 2048); dumpsys_log(aBuf, ovDump); ovDump[0] = '\0'; ctx->mRotMgr->getDump(ovDump, 1024); dumpsys_log(aBuf, ovDump); ovDump[0] = '\0'; if(Writeback::getDump(ovDump, 1024)) { dumpsys_log(aBuf, ovDump); ovDump[0] = '\0'; } strlcpy(buff, aBuf.string(), buff_len); } int hwc_getActiveConfig(struct hwc_composer_device_1* dev, int disp) { hwc_context_t* ctx = (hwc_context_t*)(dev); Locker::Autolock _l(ctx->mDrawLock); bool hotPluggable = isHotPluggable(ctx, disp); bool isVirtualDisplay = (disp == HWC_DISPLAY_VIRTUAL); // If hotpluggable or virtual displays are inactive return error if ((hotPluggable || isVirtualDisplay) && !ctx->dpyAttr[disp].connected) { ALOGE("%s display (%d) is inactive", __FUNCTION__, disp); return -EINVAL; } // For use cases when primary panel is the default interface we only have // the default config (0th index) if (!hotPluggable && disp == HWC_DISPLAY_PRIMARY) { return ctx->mColorMode->getActiveModeIndex(); } else if (isVirtualDisplay) { return 0; } return ctx->mHDMIDisplay->getActiveConfig(); } int hwc_setActiveConfig(struct hwc_composer_device_1* dev, int disp, int index) { hwc_context_t* ctx = (hwc_context_t*)(dev); Locker::Autolock _l(ctx->mDrawLock); bool hotPluggable = isHotPluggable(ctx, disp); bool isVirtualDisplay = (disp == HWC_DISPLAY_VIRTUAL); // If hotpluggable or virtual displays are inactive return error if ((hotPluggable || isVirtualDisplay) && !ctx->dpyAttr[disp].connected) { ALOGE("%s display (%d) is inactive", __FUNCTION__, disp); return -EINVAL; } // For use cases when primary panel is the default interface we only switch // color modes if(!hotPluggable && disp == HWC_DISPLAY_PRIMARY) { return ctx->mColorMode->applyModeByIndex(index); } else if (isVirtualDisplay) { // virtual supports only the default config (0th index) return (index == 0) ? index : -EINVAL; } return ctx->mHDMIDisplay->setActiveConfig(index); } static int hwc_device_close(struct hw_device_t *dev) { if(!dev) { ALOGE("%s: NULL device pointer", __FUNCTION__); return -1; } closeContext((hwc_context_t*)dev); free(dev); return 0; } static int hwc_device_open(const struct hw_module_t* module, const char* name, struct hw_device_t** device) { int status = -EINVAL; if (!strcmp(name, HWC_HARDWARE_COMPOSER)) { struct hwc_context_t *dev; dev = (hwc_context_t*)malloc(sizeof(*dev)); if(dev == NULL) return status; memset(dev, 0, sizeof(*dev)); //Initialize hwc context initContext(dev); //Setup HWC methods dev->device.common.tag = HARDWARE_DEVICE_TAG; dev->device.common.version = HWC_DEVICE_API_VERSION_1_5; dev->device.common.module = const_cast(module); dev->device.common.close = hwc_device_close; dev->device.prepare = hwc_prepare; dev->device.set = hwc_set; dev->device.eventControl = hwc_eventControl; dev->device.setPowerMode = hwc_setPowerMode; dev->device.query = hwc_query; dev->device.registerProcs = hwc_registerProcs; dev->device.dump = hwc_dump; dev->device.getDisplayConfigs = hwc_getDisplayConfigs; dev->device.getDisplayAttributes = hwc_getDisplayAttributes; dev->device.getActiveConfig = hwc_getActiveConfig; dev->device.setActiveConfig = hwc_setActiveConfig; *device = &dev->device.common; status = 0; } return status; }