Merge "SF: Revamp frequencyScale backdoor" (4a410c0d) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/DisplayHardware/HWC2.cpp

+14 −0

Original line number	Diff line number	Diff line
		@@ -184,6 +184,7 @@ void Device::onHotplug(hwc2_display_t displayId, Connection connection) {

		auto newDisplay = std::make_unique<Display>(
		*mComposer.get(), mPowerAdvisor, mCapabilities, displayId, displayType);
		newDisplay->setFrequencyScaleParameters(mFrequencyScaler);
		newDisplay->setConnected(true);
		mDisplays.emplace(displayId, std::move(newDisplay));
		} else if (connection == Connection::Disconnected) {
		@@ -223,6 +224,14 @@ Error Device::flushCommands()
		return static_cast<Error>(mComposer->executeCommands());
		}

		void Device::setDisplayFrequencyScaleParameters(Device::FrequencyScaler frequencyScaler) {
		mFrequencyScaler = frequencyScaler;
		}

		Device::FrequencyScaler Device::getDisplayFrequencyScaleParameters() {
		return mFrequencyScaler;
		}

		// Display methods

		Display::Display(android::Hwc2::Composer& composer, android::Hwc2::PowerAdvisor& advisor,
		@@ -262,6 +271,7 @@ Display::Config::Config(Display& display, hwc2_config_t id)
		mWidth(-1),
		mHeight(-1),
		mVsyncPeriod(-1),
		mFrequencyScaler(display.mFrequencyScaler),
		mDpiX(-1),
		mDpiY(-1) {}

		@@ -701,6 +711,10 @@ void Display::setConnected(bool connected) {
		mIsConnected = connected;
		}

		void Display::setFrequencyScaleParameters(Device::FrequencyScaler frequencyScaler) {
		mFrequencyScaler = frequencyScaler;
		}

		int32_t Display::getAttribute(hwc2_config_t configId, Attribute attribute)
		{
		int32_t value = 0;

services/surfaceflinger/DisplayHardware/HWC2.h

+13 −9

Original line number	Diff line number	Diff line
		@@ -85,6 +85,11 @@ class Device
		public:
		explicit Device(std::unique_ptr<android::Hwc2::Composer> composer);

		struct FrequencyScaler {
		int32_t multiplier = 1;
		int32_t divisor = 1;
		};

		void registerCallback(ComposerCallback* callback, int32_t sequenceId);

		// Required by HWC2
		@@ -116,6 +121,9 @@ public:
		// This method provides an explicit way to flush state changes to HWC.
		Error flushCommands();

		void setDisplayFrequencyScaleParameters(FrequencyScaler frequecyScaler);
		FrequencyScaler getDisplayFrequencyScaleParameters();

		private:
		// Initialization methods

		@@ -126,6 +134,7 @@ private:
		std::unordered_set<Capability> mCapabilities;
		std::unordered_map<hwc2_display_t, std::unique_ptr<Display>> mDisplays;
		android::Hwc2::impl::PowerAdvisor mPowerAdvisor;
		FrequencyScaler mFrequencyScaler;
		bool mRegisteredCallback = false;
		};

		@@ -161,8 +170,6 @@ public:
		}
		Builder& setVsyncPeriod(int32_t vsyncPeriod) {
		mConfig->mVsyncPeriod = vsyncPeriod;
		mConfig->mPeriodMultiplier = 1;
		mConfig->mPeriodDivisor = 1;
		return *this;
		}
		Builder& setDpiX(int32_t dpiX) {
		@@ -193,11 +200,7 @@ public:
		int32_t getWidth() const { return mWidth; }
		int32_t getHeight() const { return mHeight; }
		nsecs_t getVsyncPeriod() const {
		return mVsyncPeriod * mPeriodMultiplier / mPeriodDivisor; }
		void scalePanelFrequency(int32_t multiplier, int32_t divisor) const {
		mPeriodMultiplier = multiplier;
		mPeriodDivisor = divisor;
		}
		return mVsyncPeriod * mFrequencyScaler.multiplier / mFrequencyScaler.divisor; }
		float getDpiX() const { return mDpiX; }
		float getDpiY() const { return mDpiY; }

		@@ -210,8 +213,7 @@ public:
		int32_t mWidth;
		int32_t mHeight;
		nsecs_t mVsyncPeriod;
		mutable int32_t mPeriodMultiplier;
		mutable int32_t mPeriodDivisor;
		Device::FrequencyScaler mFrequencyScaler;
		float mDpiX;
		float mDpiY;
		};
		@@ -279,6 +281,7 @@ public:
		hwc2_display_t getId() const { return mId; }
		bool isConnected() const { return mIsConnected; }
		void setConnected(bool connected); // For use by Device only
		void setFrequencyScaleParameters(Device::FrequencyScaler frequencyScaler);

		private:
		int32_t getAttribute(hwc2_config_t configId, Attribute attribute);
		@@ -303,6 +306,7 @@ private:
		hwc2_display_t mId;
		bool mIsConnected;
		DisplayType mType;
		Device::FrequencyScaler mFrequencyScaler;
		std::unordered_map<hwc2_layer_t, std::unique_ptr<Layer>> mLayers;
		std::unordered_map<hwc2_config_t, std::shared_ptr<const Config>> mConfigs;
		};

services/surfaceflinger/DisplayHardware/HWComposer.cpp

+11 −0

Original line number	Diff line number	Diff line
		@@ -807,4 +807,15 @@ HWComposer::getHwcDisplayId(int32_t displayId) const {
		return mDisplayData[displayId].hwcDisplay->getId();
		}

		void HWComposer::setDisplayFrequencyScaleParameters(
		HWC2::Device::FrequencyScaler frequencyScaler)
		{
		mHwcDevice->setDisplayFrequencyScaleParameters(frequencyScaler);
		}

		HWC2::Device::FrequencyScaler HWComposer::getDisplayFrequencyScaleParameters()
		{
		return mHwcDevice->getDisplayFrequencyScaleParameters();
		}

		} // namespace android

services/surfaceflinger/DisplayHardware/HWComposer.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -184,6 +184,14 @@ public:
		android::Hwc2::Composer* getComposer() const { return mHwcDevice->getComposer(); }

		std::optional<hwc2_display_t> getHwcDisplayId(int32_t displayId) const;

		// ------------------------------------------------------------------------
		// These functions set and get the frequencyScaler. The frequencyScaler holds
		// a multiplier and divisor for virtually scaling the panel frequency in
		// software. This is used to simulate different panel frequencies when
		// panel hardware is not available.
		void setDisplayFrequencyScaleParameters(HWC2::Device::FrequencyScaler frequencyScaler);
		HWC2::Device::FrequencyScaler getDisplayFrequencyScaleParameters();
		private:
		// For unit tests
		friend TestableSurfaceFlinger;

services/surfaceflinger/Scheduler/DispSync.cpp

+5 −3

Original line number	Diff line number	Diff line
		@@ -521,16 +521,18 @@ void DispSync::setPeriod(nsecs_t period) {
		mThread->updateModel(mPeriod, mPhase, mReferenceTime);
		}

		void DispSync::scalePeriod(uint32_t multiplier, uint32_t divisor) {
		void DispSync::scalePeriod(HWC2::Device::FrequencyScaler frequencyScaler) {
		Mutex::Autolock lock(mMutex);

		// if only 1 of the properties is updated, we will get to this
		// point "attempting" to set the scale to 1 when it is already
		// 1. Check that special case so that we don't do a useless
		// update of the model.
		if ((multiplier == 1) && (divisor == 1) && (mPeriod == mPeriodBase)) return;
		if ((frequencyScaler.multiplier == 1) &&
		(frequencyScaler.divisor == 1) &&
		(mPeriod == mPeriodBase)) return;

		mPeriod = mPeriodBase * multiplier / divisor;
		mPeriod = mPeriodBase * frequencyScaler.multiplier / frequencyScaler.divisor;
		mThread->updateModel(mPeriod, mPhase, mReferenceTime);
		}