libdisplaymodule/ExynosPrimaryDisplay.cpp

   1 #include "ExynosPrimaryDisplay.h"
   2 #include "ExynosHWCModule.h"
   3 #include "ExynosHWCUtils.h"
   4 #include "ExynosMPPModule.h"
   5
   6 #define DISPLAY_LOGD(msg, ...) ALOGD("[%s] " msg, mDisplayName.string(), ##__VA_ARGS__)
   7 #define DISPLAY_LOGV(msg, ...) ALOGV("[%s] " msg, mDisplayName.string(), ##__VA_ARGS__)
   8 #define DISPLAY_LOGI(msg, ...) ALOGI("[%s] " msg, mDisplayName.string(), ##__VA_ARGS__)
   9 #define DISPLAY_LOGW(msg, ...) ALOGW("[%s] " msg, mDisplayName.string(), ##__VA_ARGS__)
  10 #define DISPLAY_LOGE(msg, ...) ALOGE("[%s] " msg, mDisplayName.string(), ##__VA_ARGS__)
  11
  12 ExynosPrimaryDisplay::ExynosPrimaryDisplay(int numGSCs, struct exynos5_hwc_composer_device_1_t *pdev) :
  13     ExynosOverlayDisplay(numGSCs, pdev)
  14 {
  15 }
  16
  17 ExynosPrimaryDisplay::~ExynosPrimaryDisplay()
  18 {
  19 }
  20
  21 int ExynosPrimaryDisplay::getDeconWinMap(int overlayIndex, int totalOverlays)
  22 {
  23         return 0;
  24 }
  25
  26 void ExynosPrimaryDisplay::forceYuvLayersToFb(hwc_display_contents_1_t __unused *contents)
  27 {
  28 }
  29
  30 int ExynosPrimaryDisplay::getMPPForUHD(hwc_layer_1_t __unused &layer)
  31 {
  32     return 0;
  33 }
  34
  35 int ExynosPrimaryDisplay::getRGBMPPIndex(int index)
  36 {
  37     return index;
  38 }
  39
  40 bool ExynosPrimaryDisplay::isOverlaySupported(hwc_layer_1_t &layer, size_t index, bool useVPPOverlay,
  41         ExynosMPPModule** supportedInternalMPP, ExynosMPPModule** supportedExternalMPP)
  42 {
  43     // Exynos755555oesn't have any VPP Overlays
  44     return ExynosDisplay::isOverlaySupported(layer, index, false, supportedInternalMPP, supportedExternalMPP);
  45 }
  46 bool ExynosPrimaryDisplay::isYuvDmaAvailable(int format, uint32_t dma)
  47 {
  48     return (format == HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP_M_FULL &&
  49         dma == IDMA_G2);
  50 }
  51
  52 void ExynosPrimaryDisplay::assignWindows(hwc_display_contents_1_t *contents)
  53 {
  54     // call the ExynosDisplay default implementation of assignWindows()
  55     ExynosDisplay::assignWindows(contents);
  56
  57     // allocate the max bandwidth non-rgb layer to IDMA_G2
  58     // consider only non-secure dma case - secure dma is already allocated to IDMA_G2
  59
  60     bool videoLayerFound = 0, curDmaYuvFound = 0, hasDRMlayer = 0;
  61     uint32_t videoLayerIndex = 0, curDmaYuvIndex = 0;
  62     uint32_t mTemp = 0, bandWidth = 0;
  63     int fbLayerIndex = -1;
  64
  65     for (size_t i = 0; i < contents->numHwLayers; i++) {
  66         hwc_layer_1_t &layer = contents->hwLayers[i];
  67
  68         if (!layer.handle)
  69             continue;
  70
  71         private_handle_t *handle = private_handle_t::dynamicCast(layer.handle);
  72
  73         if (layer.compositionType == HWC_FRAMEBUFFER_TARGET)
  74             fbLayerIndex = i;
  75
  76         // If there is DRM layer available, it has to go to IDMA_G2 channel.
  77         if (layer.compositionType == HWC_OVERLAY &&
  78                 getDrmMode(handle->flags) == SECURE_DRM &&
  79                 !(layer.flags & HWC_SKIP_RENDERING)) {
  80             hasDRMlayer = 1;
  81             videoLayerFound = 1;
  82             videoLayerIndex = i;
  83         }
  84
  85         // If no DRM layer, find non-rgb overlay layer which can be supported by IDMA_G2.
  86         if ((layer.compositionType == HWC_OVERLAY) &&
  87                     isYuvDmaAvailable(handle->format, IDMA_G2) &&
  88                     !(layer.flags & HWC_SKIP_RENDERING) &&
  89                     !hasDRMlayer) {
  90
  91             mTemp = (layer.sourceCropf.right - layer.sourceCropf.left) *
  92                 (layer.sourceCropf.bottom - layer.sourceCropf.top);
  93             if (mTemp > bandWidth) {
  94                 bandWidth = mTemp;
  95                 videoLayerFound = 1;
  96                 videoLayerIndex = i;
  97             }
  98         }
  99
 100         if (((layer.compositionType == HWC_OVERLAY) ||
 101             (layer.compositionType == HWC_FRAMEBUFFER_TARGET)) &&
 102             (!curDmaYuvFound) &&
 103             (mLayerInfos[i]->mDmaType == IDMA_G2)) {
 104             curDmaYuvFound = 1;
 105             curDmaYuvIndex = i;
 106         }
 107     }
 108
 109     if (curDmaYuvFound && videoLayerFound) {
 110         mTemp = mLayerInfos[videoLayerIndex]->mDmaType;
 111         mLayerInfos[videoLayerIndex]->mDmaType = mLayerInfos[curDmaYuvIndex]->mDmaType;
 112         mLayerInfos[curDmaYuvIndex]->mDmaType = mTemp;
 113     }
 114
 115     if (videoLayerFound && !curDmaYuvFound) {
 116         if (prevfbTargetIdma == IDMA_G2) {
 117             prevfbTargetIdma = (enum decon_idma_type) mLayerInfos[videoLayerIndex]->mDmaType;
 118             mLayerInfos[videoLayerIndex]->mDmaType = IDMA_G2;
 119             return;
 120         }
 121         mLayerInfos[videoLayerIndex]->mDmaType = IDMA_G2;
 122     }
 123
 124     if (mFbNeeded && mFbWindow < NUM_HW_WINDOWS && fbLayerIndex >= 0)
 125        prevfbTargetIdma = (enum decon_idma_type) mLayerInfos[fbLayerIndex]->mDmaType;
 126 }
 127
 128 int ExynosPrimaryDisplay::postMPPM2M(hwc_layer_1_t &layer, struct decon_win_config *config, int win_map, int index)
 129 {
 130     int dst_format = mExternalMPPDstFormat;
 131     private_handle_t *handle = private_handle_t::dynamicCast(layer.handle);
 132     ExynosMPPModule *exynosMPP = mLayerInfos[index]->mExternalMPP;
 133
 134     if (exynosMPP == NULL) {
 135         DISPLAY_LOGE("postMPPM2M is called but externMPP is NULL");
 136         if (layer.acquireFenceFd >= 0)
 137             close(layer.acquireFenceFd);
 138         layer.acquireFenceFd = -1;
 139         layer.releaseFenceFd = -1;
 140         return -1;
 141     }
 142
 143     hwc_frect_t sourceCrop = { 0, 0,
 144             (float)WIDTH(layer.displayFrame), (float)HEIGHT(layer.displayFrame) };
 145     int originalTransform = layer.transform;
 146     hwc_rect_t originalDisplayFrame = layer.displayFrame;
 147
 148     /* OFF_Screen to ON_Screen changes */
 149     if (getDrmMode(handle->flags) == SECURE_DRM)
 150         recalculateDisplayFrame(layer, mXres, mYres);
 151
 152     if (mType != EXYNOS_VIRTUAL_DISPLAY &&
 153         (isFormatRgb(handle->format) ||
 154          (isYuvDmaAvailable(handle->format, mLayerInfos[index]->mDmaType) &&
 155           WIDTH(layer.displayFrame) % getIDMAWidthAlign(handle->format) == 0 &&
 156           HEIGHT(layer.displayFrame) % getIDMAHeightAlign(handle->format) == 0)))
 157         dst_format = handle->format;
 158
 159     int err = exynosMPP->processM2M(layer, dst_format, &sourceCrop);
 160
 161     /* Restore displayFrame*/
 162     layer.displayFrame = originalDisplayFrame;
 163
 164     if (err < 0) {
 165         DISPLAY_LOGE("failed to configure MPP (type:%u, index:%u) for layer %u",
 166                 exynosMPP->mType, exynosMPP->mIndex, index);
 167         return -1;
 168     }
 169
 170     buffer_handle_t dst_buf = exynosMPP->mDstBuffers[exynosMPP->mCurrentBuf];
 171     private_handle_t *dst_handle =
 172             private_handle_t::dynamicCast(dst_buf);
 173     int fence = exynosMPP->mDstConfig.releaseFenceFd;
 174     hwc_frect originalCrop = layer.sourceCropf;
 175
 176     /* ExtMPP out is the input of Decon
 177      * and Trsform was processed by ExtMPP
 178      */
 179     layer.sourceCropf = sourceCrop;
 180     layer.transform = 0;
 181     configureHandle(dst_handle, index, layer,  fence, config[win_map]);
 182
 183     /* Restore sourceCropf and transform */
 184     layer.sourceCropf = originalCrop;
 185     layer.transform = originalTransform;
 186     return 0;
 187 }
 188
 189 void ExynosPrimaryDisplay::handleStaticLayers(hwc_display_contents_1_t *contents,
 190     struct decon_win_config_data &win_data, int __unused tot_ovly_wins)
 191 {
 192     unsigned int bitmap = 0;
 193     bool incorrect_mapping = false;
 194
 195     ExynosDisplay::handleStaticLayers(contents, win_data, tot_ovly_wins);
 196
 197     if (mLastFbWindow >= NUM_HW_WINDOWS) {
 198         DISPLAY_LOGE("handleStaticLayers:: invalid mLastFbWindow(%d)", mLastFbWindow);
 199         return;
 200     }
 201
 202     win_data.config[mLastFbWindow].idma_type = prevfbTargetIdma;
 203
 204     for (size_t i = 0; i < NUM_HW_WINDOWS; i++) {
 205         if (win_data.config[i].state == win_data.config[i].DECON_WIN_STATE_BUFFER) {
 206             if (bitmap & (1 << win_data.config[i].idma_type)) {
 207                 ALOGE("handleStaticLayers: Channel-%d is mapped to multiple windows\n", win_data.config[i].idma_type);
 208                 incorrect_mapping = true;
 209             }
 210
 211             bitmap |= 1 << win_data.config[i].idma_type;
 212         }
 213     }
 214
 215     if (incorrect_mapping) {
 216         android::String8 result;
 217         result.clear();
 218         dump(result);
 219         ALOGE("%s", result.string());
 220         result.clear();
 221         dumpLayerInfo(result);
 222         ALOGE("%s", result.string());
 223         ALOGE("Display Config:");
 224         dump_win_config(&win_data.config[0]);
 225     }
 226 }
 227
 228 void ExynosPrimaryDisplay::dump_win_config(struct decon_win_config *config)
 229 {
 230     int win;
 231     struct decon_win_config *cfg;
 232     const char *state[] = { "DSBL", "COLR", "BUFF", "UPDT" };
 233     const char *blending[] = { "NOBL", "PMUL", "COVR" };
 234     const char *idma[] = { "G0", "G1", "V0", "V1", "VR0", "VR1", "G2" };
 235
 236     for (win = 0; win < MAX_DECON_WIN; win++) {
 237         cfg = &config[win];
 238
 239         if (cfg->state == cfg->DECON_WIN_STATE_DISABLED)
 240         continue;
 241
 242         if (cfg->state == cfg->DECON_WIN_STATE_COLOR) {
 243             ALOGE("Win[%d]: %s, C(%d), Dst(%d,%d,%d,%d) "
 244                 "P(%d)\n",
 245                 win, state[cfg->state], cfg->color,
 246                 cfg->dst.x, cfg->dst.y,
 247                 cfg->dst.x + cfg->dst.w,
 248                 cfg->dst.y + cfg->dst.h,
 249                 cfg->protection);
 250         } else {
 251             ALOGE("Win[%d]: %s,(%d,%d,%d), F(%d) P(%d)"
 252                 " A(%d), %s, %s, fmt(%d) Src(%d,%d,%d,%d,f_w=%d,f_h=%d) ->"
 253                 " Dst(%d,%d,%d,%d,f_w=%d,f_h=%d) T(%d,%d,%d,%d) B(%d,%d,%d,%d)\n",
 254                 win, state[cfg->state], cfg->fd_idma[0],
 255                 cfg->fd_idma[1], cfg->fd_idma[2],
 256                 cfg->fence_fd, cfg->protection,
 257                 cfg->plane_alpha, blending[cfg->blending],
 258                 idma[cfg->idma_type], cfg->format,
 259                 cfg->src.x, cfg->src.y, cfg->src.x + cfg->src.w, cfg->src.y + cfg->src.h,
 260                 cfg->src.f_w, cfg->src.f_h,
 261                 cfg->dst.x, cfg->dst.y, cfg->dst.x + cfg->dst.w, cfg->dst.y + cfg->dst.h,
 262                 cfg->dst.f_w, cfg->dst.f_h,
 263                 cfg->transparent_area.x, cfg->transparent_area.y,
 264                 cfg->transparent_area.w, cfg->transparent_area.h,
 265                 cfg->covered_opaque_area.x, cfg->covered_opaque_area.y,
 266                 cfg->covered_opaque_area.w, cfg->covered_opaque_area.h);
 267         }
 268     }
 269 }
 270
 271 int ExynosPrimaryDisplay::handleWindowUpdate(hwc_display_contents_1_t __unused *contents,
 272     struct decon_win_config __unused *config)
 273 {
 274     int layerIdx = -1;
 275     int updatedWinCnt = 0;
 276     int totalWinCnt = 0;
 277     int bitsPerPixel = 0;
 278     size_t winUpdateInfoIdx;
 279     hwc_rect updateRect = {this->mXres, this->mYres, 0, 0};
 280     hwc_rect currentRect = {0, 0, 0, 0};
 281     bool burstLengthCheckDone = false;
 282     int alignAdjustment = 0;
 283     int intersectionWidth = 0;
 284
 285     char value[PROPERTY_VALUE_MAX];
 286     property_get("debug.hwc.winupdate", value, NULL);
 287
 288     if (!(!strcmp(value, "1") || !strcmp(value, "true")))
 289         return -eWindowUpdateDisabled;
 290
 291     if (DECON_WIN_UPDATE_IDX < 0)
 292         return -eWindowUpdateInvalidIndex;
 293     winUpdateInfoIdx = DECON_WIN_UPDATE_IDX;
 294
 295     if (contents->flags & HWC_GEOMETRY_CHANGED)
 296         return -eWindowUpdateGeometryChanged;
 297
 298     for (size_t i = 0; i < contents->numHwLayers; i++) {
 299         if (contents->hwLayers[i].compositionType == HWC_FRAMEBUFFER)
 300             continue;
 301
 302         if (!mFbNeeded && contents->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET)
 303             continue;
 304         int32_t windowIndex = mLayerInfos[i]->mWindowIndex;
 305         if (config[windowIndex].state != config[windowIndex].DECON_WIN_STATE_DISABLED) {
 306             totalWinCnt++;
 307
 308             if (winConfigChanged(&config[windowIndex], &this->mLastConfigData.config[windowIndex])) {
 309                 updatedWinCnt++;
 310
 311                 currentRect.left   = config[windowIndex].dst.x;
 312                 currentRect.right  = config[windowIndex].dst.x + config[windowIndex].dst.w;
 313                 currentRect.top    = config[windowIndex].dst.y;
 314                 currentRect.bottom = config[windowIndex].dst.y + config[windowIndex].dst.h;
 315
 316                 if (hwcHasApiVersion((hwc_composer_device_1_t*)mHwc, HWC_DEVICE_API_VERSION_1_5))
 317                 {
 318                     private_handle_t *handle = NULL;
 319                     hwc_rect damageRect = {0, 0, 0, 0};
 320                     hwc_layer_1_t &layer = contents->hwLayers[i];
 321                     if (layer.handle)
 322                         handle = private_handle_t::dynamicCast(layer.handle);
 323                     getLayerRegion(layer, damageRect, eDamageRegion);
 324
 325                     if (handle && !isScaled(layer) && !isRotated(layer)
 326                             && !(!(damageRect.left) && !(damageRect.top) && !(damageRect.right) && !(damageRect.bottom))) {
 327                         HLOGD("[WIN_UPDATE][surfaceDamage]  layer w(%4d) h(%4d),  dirty (%4d, %4d) - (%4d, %4d)",
 328                                 handle->width, handle->height, damageRect.left, damageRect.top, damageRect.right, damageRect.bottom);
 329
 330                         currentRect.left   = config[windowIndex].dst.x - (int32_t)layer.sourceCropf.left + damageRect.left;
 331                         currentRect.right  = config[windowIndex].dst.x - (int32_t)layer.sourceCropf.left + damageRect.right;
 332                         currentRect.top    = config[windowIndex].dst.y - (int32_t)layer.sourceCropf.top  + damageRect.top;
 333                         currentRect.bottom = config[windowIndex].dst.y - (int32_t)layer.sourceCropf.top  + damageRect.bottom;
 334
 335                     }
 336                 }
 337
 338                 if ((currentRect.left > currentRect.right) || (currentRect.top > currentRect.bottom)) {
 339                     HLOGD("[WIN_UPDATE] window(%d) layer(%d) invalid region (%4d, %4d) - (%4d, %4d)",
 340                         i, layerIdx, currentRect.left, currentRect.top, currentRect.right, currentRect.bottom);
 341                     return -eWindowUpdateInvalidRegion;
 342                 }
 343                 HLOGD("[WIN_UPDATE] Updated Window(%d) Layer(%d)  (%4d, %4d) - (%4d, %4d)",
 344                     windowIndex, i, currentRect.left, currentRect.top, currentRect.right, currentRect.bottom);
 345                 updateRect = expand(updateRect, currentRect);
 346             }
 347         }
 348     }
 349     if (updatedWinCnt == 0)
 350         return -eWindowUpdateNotUpdated;
 351
 352     updateRect.left  = ALIGN_DOWN(updateRect.left, WINUPDATE_X_ALIGNMENT);
 353     updateRect.right = updateRect.left + ALIGN_UP(WIDTH(updateRect), WINUPDATE_W_ALIGNMENT);
 354
 355     if (HEIGHT(updateRect) < WINUPDATE_MIN_HEIGHT) {
 356         if (updateRect.top + WINUPDATE_MIN_HEIGHT <= mYres)
 357             updateRect.bottom = updateRect.top + WINUPDATE_MIN_HEIGHT;
 358         else
 359             updateRect.top = updateRect.bottom - WINUPDATE_MIN_HEIGHT;
 360     }
 361
 362     if ((100 * (WIDTH(updateRect) * HEIGHT(updateRect)) / (this->mXres * this->mYres)) > WINUPDATE_THRESHOLD)
 363         return -eWindowUpdateOverThreshold;
 364
 365     alignAdjustment = max(WINUPDATE_X_ALIGNMENT, WINUPDATE_W_ALIGNMENT);
 366
 367     while (1) {
 368         burstLengthCheckDone = true;
 369
 370         for (size_t i = 0; i < contents->numHwLayers; i++) {
 371             if (contents->hwLayers[i].compositionType == HWC_FRAMEBUFFER)
 372                 continue;
 373             if (!mFbNeeded && contents->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET)
 374                 continue;
 375             int32_t windowIndex = mLayerInfos[i]->mWindowIndex;
 376             if (config[windowIndex].state != config[windowIndex].DECON_WIN_STATE_DISABLED) {
 377                 enum decon_pixel_format fmt = config[windowIndex].format;
 378
 379                 if (fmt == DECON_PIXEL_FORMAT_RGBA_5551 || fmt == DECON_PIXEL_FORMAT_RGB_565 )
 380                         bitsPerPixel = 16;
 381                 else if (fmt == DECON_PIXEL_FORMAT_NV12 || fmt == DECON_PIXEL_FORMAT_NV21 ||
 382                     fmt == DECON_PIXEL_FORMAT_NV12M || fmt == DECON_PIXEL_FORMAT_NV21M)
 383                         bitsPerPixel = 12;
 384                 else
 385                         bitsPerPixel = 32;
 386
 387                 currentRect.left   = config[windowIndex].dst.x;
 388                 currentRect.right  = config[windowIndex].dst.x + config[windowIndex].dst.w;
 389                 currentRect.top    = config[windowIndex].dst.y;
 390                 currentRect.bottom = config[windowIndex].dst.y + config[windowIndex].dst.h;
 391
 392                 intersectionWidth = WIDTH(intersection(currentRect, updateRect));
 393
 394                 HLOGV("[WIN_UPDATE] win[%d] left(%d) right(%d) intersection(%d)", windowIndex, currentRect.left, currentRect.right, intersectionWidth);
 395
 396                 if (intersectionWidth != 0 && (size_t)((intersectionWidth * bitsPerPixel) / 8) < BURSTLEN_BYTES) {
 397                     HLOGV("[WIN_UPDATE] win[%d] insufficient burst length ((%d)*(%d)/8) < %d", windowIndex, intersectionWidth, bitsPerPixel, BURSTLEN_BYTES);
 398                     burstLengthCheckDone = false;
 399                     break;
 400                 }
 401             }
 402         }
 403
 404         if (burstLengthCheckDone)
 405             break;
 406         HLOGD("[WIN_UPDATE] Adjusting update width. current left(%d) right(%d)", updateRect.left, updateRect.right);
 407         if (updateRect.left >= alignAdjustment) {
 408             updateRect.left -= alignAdjustment;
 409         } else if (updateRect.right + alignAdjustment <= this->mXres) {
 410             updateRect.right += alignAdjustment;
 411         } else {
 412             DISPLAY_LOGD("[WIN_UPDATE] Error during update width adjustment");
 413             return -eWindowUpdateAdjustmentFail;
 414         }
 415     }
 416
 417     config[winUpdateInfoIdx].state = config[winUpdateInfoIdx].DECON_WIN_STATE_UPDATE;
 418     config[winUpdateInfoIdx].dst.x = updateRect.left;
 419     config[winUpdateInfoIdx].dst.y = updateRect.top;
 420     config[winUpdateInfoIdx].dst.w = ALIGN_UP(WIDTH(updateRect), WINUPDATE_W_ALIGNMENT);
 421     config[winUpdateInfoIdx].dst.h = HEIGHT(updateRect);
 422
 423     HLOGD("[WIN_UPDATE] UpdateRegion cfg  (%4d, %4d) w(%4d) h(%4d) updatedWindowCnt(%d)",
 424         config[winUpdateInfoIdx].dst.x, config[winUpdateInfoIdx].dst.y, config[winUpdateInfoIdx].dst.w, config[winUpdateInfoIdx].dst.h, updatedWinCnt);
 425
 426     /* Disable block mode if window update region is not full screen */
 427     if ((config[winUpdateInfoIdx].dst.x != 0) || (config[winUpdateInfoIdx].dst.y != 0) ||
 428         (config[winUpdateInfoIdx].dst.w != (uint32_t)mXres) || (config[winUpdateInfoIdx].dst.h != (uint32_t)mXres)) {
 429         for (size_t i = 0; i < NUM_HW_WINDOWS; i++) {
 430             memset(&config[i].transparent_area, 0, sizeof(config[i].transparent_area));
 431             memset(&config[i].covered_opaque_area, 0, sizeof(config[i].covered_opaque_area));
 432         }
 433     }
 434
 435     return 1;
 436 }
 437
 438 int ExynosPrimaryDisplay::getIDMAWidthAlign(int format)
 439 {
 440     if (isFormatRgb(format))
 441         return 1;
 442     else
 443         return 2;
 444 }
 445
 446 int ExynosPrimaryDisplay::getIDMAHeightAlign(int format)
 447 {
 448     if (isFormatRgb(format))
 449         return 1;
 450     else
 451         return 2;
 452 }