| /* |
| * Copyright (C) 2021 The Android Open Source Project |
| * |
| * 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. |
| */ |
| |
| #include "pixel-display.h" |
| |
| #include <aidlcommonsupport/NativeHandle.h> |
| #include <android-base/logging.h> |
| #include <android/binder_manager.h> |
| #include <android/binder_process.h> |
| #include <sys/types.h> |
| #include <utils/Errors.h> |
| #include <cstdint> |
| |
| #include "BrightnessController.h" |
| #include "ExynosDisplay.h" |
| #include "ExynosPrimaryDisplay.h" |
| #include "HistogramController.h" |
| |
| extern int32_t load_png_image(const char *filepath, buffer_handle_t buffer); |
| |
| using ::aidl::com::google::hardware::pixel::display::Display; |
| |
| void PixelDisplayInit(ExynosDisplay *exynos_display, const std::string_view instance_str) { |
| ABinderProcess_setThreadPoolMaxThreadCount(0); |
| |
| std::shared_ptr<Display> display = ndk::SharedRefBase::make<Display>(exynos_display); |
| const std::string instance = std::string() + Display::descriptor + "/" + std::string(instance_str).c_str(); |
| binder_status_t status = |
| AServiceManager_addService(display->asBinder().get(), instance.c_str()); |
| LOG(INFO) << instance.c_str() << " service start..."; |
| CHECK(status == STATUS_OK); |
| |
| ABinderProcess_startThreadPool(); |
| } |
| |
| int32_t readCompensationImage(const aidl::android::hardware::common::NativeHandle &handle, |
| const std::string &imageName) { |
| ALOGI("setCompensationImageHandle, imageName = %s", imageName.c_str()); |
| |
| std::string shadowCompensationImage("/mnt/vendor/persist/display/"); |
| shadowCompensationImage.append(imageName); |
| |
| native_handle_t *clone = makeFromAidl(handle); |
| |
| return load_png_image(shadowCompensationImage.c_str(), static_cast<buffer_handle_t>(clone)); |
| } |
| |
| namespace aidl { |
| namespace com { |
| namespace google { |
| namespace hardware { |
| namespace pixel { |
| namespace display { |
| |
| // ---------------------------------------------------------------------------- |
| |
| ndk::ScopedAStatus Display::isHbmSupported(bool *_aidl_return) { |
| *_aidl_return = false; |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus Display::setHbmState(HbmState state) { |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::getHbmState(HbmState *_aidl_return) { |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::isLbeSupported(bool *_aidl_return) { |
| if (mDisplay) { |
| *_aidl_return = mDisplay->isLbeSupported(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| *_aidl_return = false; |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus Display::setLbeState(LbeState state) { |
| if (mDisplay) { |
| mDisplay->setLbeState(state); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::setLbeAmbientLight(int ambientLux) { |
| if (mDisplay) { |
| mDisplay->setLbeAmbientLight(ambientLux); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::getLbeState(LbeState *_aidl_return) { |
| if (mDisplay) { |
| *_aidl_return = mDisplay->getLbeState(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::isLhbmSupported(bool *_aidl_return) { |
| if (mDisplay) { |
| *_aidl_return = mDisplay->isLhbmSupported(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::setLhbmState(bool enabled) { |
| if (mDisplay && mDisplay->isLhbmSupported()) { |
| int32_t ret = mDisplay->setLhbmState(enabled); |
| if (!ret) |
| return ndk::ScopedAStatus::ok(); |
| else if (ret == TIMED_OUT) |
| return ndk::ScopedAStatus::fromExceptionCode(STATUS_TIMED_OUT); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::getLhbmState(bool *_aidl_return) { |
| if (mDisplay && mDisplay->isLhbmSupported()) { |
| *_aidl_return = mDisplay->getLhbmState(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::setPeakRefreshRate(int rate) { |
| if (mDisplay && mDisplay->mOperationRateManager) { |
| mDisplay->mOperationRateManager->onPeakRefreshRate(rate); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::setLowPowerMode(bool enabled) { |
| if (mDisplay && mDisplay->mOperationRateManager) { |
| mDisplay->mOperationRateManager->onLowPowerMode(enabled); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::isOperationRateSupported(bool *_aidl_return) { |
| if (mDisplay) { |
| *_aidl_return = mDisplay->isOperationRateSupported(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::setCompensationImageHandle(const NativeHandle &native_handle, |
| const std::string &imageName, |
| int *_aidl_return) { |
| if (mDisplay && mDisplay->getPanelCalibrationStatus() == PanelCalibrationStatus::ORIGINAL) { |
| *_aidl_return = readCompensationImage(native_handle, imageName); |
| } else { |
| *_aidl_return = -1; |
| } |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus Display::setMinIdleRefreshRate(int fps, int *_aidl_return) { |
| if (mDisplay) { |
| *_aidl_return = mDisplay->setMinIdleRefreshRate(fps, RrThrottleRequester::PIXEL_DISP); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::setRefreshRateThrottle(int delayMs, int *_aidl_return) { |
| if (mDisplay) { |
| if (delayMs < 0) { |
| *_aidl_return = BAD_VALUE; |
| ALOGW("%s fail: delayMs(%d) is less than 0", __func__, delayMs); |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| *_aidl_return = |
| mDisplay->setRefreshRateThrottleNanos(std::chrono::duration_cast< |
| std::chrono::nanoseconds>( |
| std::chrono::milliseconds(delayMs)) |
| .count(), |
| RrThrottleRequester::PIXEL_DISP); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| bool Display::runMediator(const RoiRect &roi, const Weight &weight, const HistogramPos &pos, |
| std::vector<char16_t> *histogrambuffer) { |
| bool isConfigChanged; |
| histogram::HistogramMediator::HistogramConfig pendingConfig(roi, weight, pos); |
| |
| { |
| std::scoped_lock lock(mMediator.mConfigMutex); |
| isConfigChanged = mMediator.mConfig != pendingConfig; |
| |
| if (isConfigChanged) { |
| if (mMediator.setRoiWeightThreshold(roi, weight, pos) != HistogramErrorCode::NONE) { |
| ALOGE("histogram error, SET_ROI_WEIGHT_THRESHOLD ERROR\n"); |
| return false; |
| } |
| mMediator.mConfig = pendingConfig; |
| } |
| } |
| |
| if (!mMediator.histRequested() && |
| mMediator.requestHist() == HistogramErrorCode::ENABLE_HIST_ERROR) { |
| ALOGE("histogram error, ENABLE_HIST ERROR\n"); |
| } |
| |
| /* |
| * DPU driver maintains always-on histogram engine state with up to date histogram data. |
| * Therefore we don't have explicitly to trigger onRefresh in case histogram configuration |
| * does not change. |
| */ |
| if (isConfigChanged) { |
| mDisplay->mDevice->onRefresh(mDisplay->mDisplayId); |
| } |
| |
| if (mMediator.collectRoiLuma(histogrambuffer) != HistogramErrorCode::NONE) { |
| ALOGE("histogram error, COLLECT_ROI_LUMA ERROR\n"); |
| return false; |
| } |
| return true; |
| } |
| |
| ndk::ScopedAStatus Display::histogramSample(const RoiRect &roi, const Weight &weight, |
| HistogramPos pos, Priority pri, |
| std::vector<char16_t> *histogrambuffer, |
| HistogramErrorCode *_aidl_return) { |
| if (!mDisplay) { |
| ALOGI("mDisplay is NULL \n"); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| if (histogrambuffer == nullptr) { |
| ALOGE("histogrambuffer is null"); |
| *_aidl_return = HistogramErrorCode::BAD_HIST_DATA; |
| return ndk::ScopedAStatus::ok(); |
| } |
| if (mDisplay->isPowerModeOff() == true) { |
| *_aidl_return = HistogramErrorCode::DISPLAY_POWEROFF; // panel is off |
| return ndk::ScopedAStatus::ok(); |
| } |
| if (mDisplay->isSecureContentPresenting() == true) { |
| *_aidl_return = HistogramErrorCode::DRM_PLAYING; // panel is playing DRM content |
| return ndk::ScopedAStatus::ok(); |
| } |
| if ((roi.left < 0) || (roi.top < 0) || ((roi.right - roi.left) <= 0) || |
| ((roi.bottom - roi.top) <= 0)) { |
| *_aidl_return = HistogramErrorCode::BAD_ROI; |
| ALOGE("histogram error, BAD_ROI (%d, %d, %d, %d) \n", roi.left, roi.top, roi.right, |
| roi.bottom); |
| return ndk::ScopedAStatus::ok(); |
| } |
| if ((weight.weightR + weight.weightG + weight.weightB) != (histogram::WEIGHT_SUM)) { |
| *_aidl_return = HistogramErrorCode::BAD_WEIGHT; |
| ALOGE("histogram error, BAD_WEIGHT(%d, %d, %d)\n", weight.weightR, weight.weightG, |
| weight.weightB); |
| return ndk::ScopedAStatus::ok(); |
| } |
| if (pos != HistogramPos::POST && pos != HistogramPos::PRE) { |
| *_aidl_return = HistogramErrorCode::BAD_POSITION; |
| ALOGE("histogram error, BAD_POSITION(%d)\n", (int)pos); |
| return ndk::ScopedAStatus::ok(); |
| } |
| if (pri != Priority::NORMAL && pri != Priority::PRIORITY) { |
| *_aidl_return = HistogramErrorCode::BAD_PRIORITY; |
| ALOGE("histogram error, BAD_PRIORITY(%d)\n", (int)pri); |
| return ndk::ScopedAStatus::ok(); |
| } |
| RoiRect roiCaled = mMediator.calRoi(roi); // fit roi coordinates to RRS |
| runMediator(roiCaled, weight, pos, histogrambuffer); |
| if (mDisplay->isSecureContentPresenting() == true) { |
| /* clear data to avoid leakage */ |
| std::fill(histogrambuffer->begin(), histogrambuffer->end(), 0); |
| histogrambuffer->clear(); |
| *_aidl_return = HistogramErrorCode::DRM_PLAYING; // panel is playing DRM content |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| *_aidl_return = HistogramErrorCode::NONE; |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus Display::getPanelCalibrationStatus(PanelCalibrationStatus *_aidl_return){ |
| if (mDisplay) { |
| *_aidl_return = mDisplay->getPanelCalibrationStatus(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::isDbmSupported(bool *_aidl_return) { |
| if (!mDisplay) { |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| *_aidl_return = mDisplay->isDbmSupported(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus Display::setDbmState(bool enabled) { |
| if (!mDisplay) { |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| mDisplay->setDbmState(enabled); |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus Display::getHistogramCapability(HistogramCapability *_aidl_return) { |
| if (mDisplay && mDisplay->mHistogramController) { |
| return mDisplay->mHistogramController->getHistogramCapability(_aidl_return); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::registerHistogram(const ndk::SpAIBinder &token, |
| const HistogramConfig &histogramConfig, |
| HistogramErrorCode *_aidl_return) { |
| if (mDisplay && mDisplay->mHistogramController) { |
| return mDisplay->mHistogramController->registerHistogram(token, histogramConfig, |
| _aidl_return); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::queryHistogram(const ndk::SpAIBinder &token, |
| std::vector<char16_t> *histogramBuffer, |
| HistogramErrorCode *_aidl_return) { |
| if (mDisplay && mDisplay->mHistogramController) { |
| return mDisplay->mHistogramController->queryHistogram(token, histogramBuffer, _aidl_return); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::reconfigHistogram(const ndk::SpAIBinder &token, |
| const HistogramConfig &histogramConfig, |
| HistogramErrorCode *_aidl_return) { |
| if (mDisplay && mDisplay->mHistogramController) { |
| return mDisplay->mHistogramController->reconfigHistogram(token, histogramConfig, |
| _aidl_return); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::unregisterHistogram(const ndk::SpAIBinder &token, |
| HistogramErrorCode *_aidl_return) { |
| if (mDisplay && mDisplay->mHistogramController) { |
| return mDisplay->mHistogramController->unregisterHistogram(token, _aidl_return); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::setFixedTe2Rate(int rateHz, int* _aidl_return) { |
| if (mDisplay) { |
| *_aidl_return = mDisplay->setFixedTe2Rate(rateHz); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::queryStats(DisplayStats::Tag tag, |
| std::optional<DisplayStats>* _aidl_return) { |
| ATRACE_NAME( |
| String8::format("%s(%s)", __func__, |
| aidl::com::google::hardware::pixel::display::toString(tag).c_str())); |
| if (!mDisplay) { |
| ALOGW("%s: mDisplay is NULL", __func__); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| switch (tag) { |
| case DisplayStats::brightnessNits: |
| if (mDisplay->mBrightnessController != nullptr) { |
| auto res = mDisplay->mBrightnessController->getBrightnessNitsAndMode(); |
| if (res != std::nullopt) { |
| double nits = std::get<float>(res.value()); |
| (*_aidl_return) = DisplayStats::make<DisplayStats::brightnessNits>(nits); |
| } else { |
| ALOGW("%s: getBrightnessNitsAndMode returned nullopt!", __func__); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); |
| } |
| } else { |
| ALOGW("%s: mBrightnessController is null!", __func__); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| break; |
| case DisplayStats::brightnessDbv: |
| if (mDisplay->mBrightnessController != nullptr) { |
| int dbv = mDisplay->mBrightnessController->getBrightnessLevel(); |
| (*_aidl_return) = DisplayStats::make<DisplayStats::brightnessDbv>(dbv); |
| } else { |
| ALOGW("%s: mBrightnessController is null!", __func__); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| break; |
| case DisplayStats::operationRate: |
| if (mDisplay->isOperationRateSupported()) { |
| int op_hz = mDisplay->mOperationRateManager->getTargetOperationRate(); |
| (*_aidl_return) = DisplayStats::make<DisplayStats::operationRate>(op_hz); |
| } else { |
| ALOGW("%s: operation rate not supported!", __func__); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| break; |
| case DisplayStats::opr: |
| if (mDisplay->mHistogramController) { |
| std::array<double, HistogramController::kOPRConfigsCount> oprVals; |
| ndk::ScopedAStatus status = mDisplay->mHistogramController->queryOPR(oprVals); |
| if (!status.isOk()) return status; |
| (*_aidl_return) = DisplayStats::make<DisplayStats::opr>(oprVals); |
| } else { |
| ALOGW("%s: mHistogramController is null!", __func__); |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| break; |
| default: |
| ALOGW("%s: invalid stats tag: %u", __func__, (uint32_t)tag); |
| *_aidl_return = std::nullopt; |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| }; |
| return ndk::ScopedAStatus::ok(); |
| } |
| |
| ndk::ScopedAStatus Display::isProximitySensorStateCallbackSupported(bool* _aidl_return) { |
| if (mDisplay) { |
| *_aidl_return = mDisplay->isProximitySensorStateCallbackSupported(); |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| ndk::ScopedAStatus Display::registerProximitySensorStateChangeCallback( |
| const std::shared_ptr<IDisplayProximitySensorCallback>& callback) { |
| if (mDisplay && callback) { |
| mDisplay->mProximitySensorStateChangeCallback = callback; |
| return ndk::ScopedAStatus::ok(); |
| } |
| return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); |
| } |
| |
| } // namespace display |
| } // namespace pixel |
| } // namespace hardware |
| } // namespace google |
| } // namespace com |
| } // namespace aidl |
