diff --git a/include/powermanager/PowerHalController.h b/include/powermanager/PowerHalController.h
index 71a36d09e59f81b0311b183de9dc0eadac7781d9..c53ce15212f555e54b40316226656749c4008f89 100644
--- a/include/powermanager/PowerHalController.h
+++ b/include/powermanager/PowerHalController.h
@@ -23,6 +23,9 @@
 #include <android/hardware/power/IPowerHintSession.h>
 #include <android/hardware/power/Mode.h>
 #include <powermanager/PowerHalWrapper.h>
+#include <google/hardware/power/extension/pixel/IPowerExt.h>
+
+using ::google::hardware::power::extension::pixel::IPowerExt;
 
 namespace android {
 
@@ -55,6 +58,11 @@ public:
 
     void init();
 
+    virtual HalResult<bool> isPowerExtAvailable() override;
+    virtual HalResult<bool> isExtModeSupported(const ::std::string& mode) override;
+    virtual HalResult<bool> isExtBoostSupported(const ::std::string& boost) override;
+    virtual HalResult<void> setExtMode(const ::std::string& mode, bool enabled) override;
+    virtual HalResult<void> setExtBoost(const ::std::string& boost, int32_t durationMs) override;
     virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;
     virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;
     virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
diff --git a/include/powermanager/PowerHalLoader.h b/include/powermanager/PowerHalLoader.h
index ed6f6f35f507cf86ff81e57b22e335e89b93b54e..d839559f60c8015513b58e2fb4458ccdb3692137 100644
--- a/include/powermanager/PowerHalLoader.h
+++ b/include/powermanager/PowerHalLoader.h
@@ -20,6 +20,9 @@
 #include <android-base/thread_annotations.h>
 #include <android/hardware/power/1.1/IPower.h>
 #include <android/hardware/power/IPower.h>
+#include <google/hardware/power/extension/pixel/IPowerExt.h>
+
+using ::google::hardware::power::extension::pixel::IPowerExt;
 
 namespace android {
 
@@ -29,12 +32,13 @@ namespace power {
 class PowerHalLoader {
 public:
     static void unloadAll();
-    static sp<hardware::power::IPower> loadAidl();
+    static std::pair<sp<hardware::power::IPower>, sp<IPowerExt>> loadAidlAndExt();
     static sp<hardware::power::V1_0::IPower> loadHidlV1_0();
     static sp<hardware::power::V1_1::IPower> loadHidlV1_1();
 
 private:
     static std::mutex gHalMutex;
+    static sp<IPowerExt> gHalAidlExt GUARDED_BY(gHalMutex);
     static sp<hardware::power::IPower> gHalAidl GUARDED_BY(gHalMutex);
     static sp<hardware::power::V1_0::IPower> gHalHidlV1_0 GUARDED_BY(gHalMutex);
     static sp<hardware::power::V1_1::IPower> gHalHidlV1_1 GUARDED_BY(gHalMutex);
diff --git a/include/powermanager/PowerHalWrapper.h b/include/powermanager/PowerHalWrapper.h
index dfb0ff59a0432c693ac43ca39b577d69449196c3..2ed82b511ac9f19f41b189805a5d503e444c7c58 100644
--- a/include/powermanager/PowerHalWrapper.h
+++ b/include/powermanager/PowerHalWrapper.h
@@ -23,6 +23,9 @@
 #include <android/hardware/power/IPower.h>
 #include <android/hardware/power/IPowerHintSession.h>
 #include <android/hardware/power/Mode.h>
+#include <google/hardware/power/extension/pixel/IPowerExt.h>
+
+using ::google::hardware::power::extension::pixel::IPowerExt;
 
 namespace android {
 
@@ -117,6 +120,11 @@ class HalWrapper {
 public:
     virtual ~HalWrapper() = default;
 
+    virtual HalResult<bool> isPowerExtAvailable() = 0;
+    virtual HalResult<bool> isExtModeSupported(const ::std::string& mode) = 0;
+    virtual HalResult<bool> isExtBoostSupported(const ::std::string& boost) = 0;
+    virtual HalResult<void> setExtMode(const ::std::string& mode, bool enabled) = 0;
+    virtual HalResult<void> setExtBoost(const ::std::string& boost, int32_t durationMs) = 0;
     virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) = 0;
     virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) = 0;
     virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
@@ -131,6 +139,11 @@ public:
     EmptyHalWrapper() = default;
     ~EmptyHalWrapper() = default;
 
+    virtual HalResult<bool> isPowerExtAvailable() override;
+    virtual HalResult<bool> isExtModeSupported(const ::std::string& mode) override;
+    virtual HalResult<bool> isExtBoostSupported(const ::std::string& boost) override;
+    virtual HalResult<void> setExtMode(const ::std::string& mode, bool enabled) override;
+    virtual HalResult<void> setExtBoost(const ::std::string& boost, int32_t durationMs) override;
     virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;
     virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;
     virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
@@ -146,6 +159,11 @@ public:
           : mHandleV1_0(std::move(Hal)) {}
     virtual ~HidlHalWrapperV1_0() = default;
 
+    virtual HalResult<bool> isPowerExtAvailable() override;
+    virtual HalResult<bool> isExtModeSupported(const ::std::string& mode) override;
+    virtual HalResult<bool> isExtBoostSupported(const ::std::string& boost) override;
+    virtual HalResult<void> setExtMode(const ::std::string& mode, bool enabled) override;
+    virtual HalResult<void> setExtBoost(const ::std::string& boost, int32_t durationMs) override;
     virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;
     virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;
     virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
@@ -182,8 +200,15 @@ private:
 class AidlHalWrapper : public HalWrapper {
 public:
     explicit AidlHalWrapper(sp<hardware::power::IPower> handle) : mHandle(std::move(handle)) {}
+    explicit AidlHalWrapper(sp<hardware::power::IPower> handle, sp<IPowerExt> handleExt)
+        : mHandle(std::move(handle)), mHandleExt(std::move(handleExt)) {}
     virtual ~AidlHalWrapper() = default;
 
+    virtual HalResult<bool> isPowerExtAvailable() override;
+    virtual HalResult<bool> isExtModeSupported(const ::std::string& mode) override;
+    virtual HalResult<bool> isExtBoostSupported(const ::std::string& boost) override;
+    virtual HalResult<void> setExtMode(const ::std::string& mode, bool enabled) override;
+    virtual HalResult<void> setExtBoost(const ::std::string& boost, int32_t durationMs) override;
     virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;
     virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;
     virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
@@ -196,6 +221,7 @@ private:
     std::mutex mBoostMutex;
     std::mutex mModeMutex;
     sp<hardware::power::IPower> mHandle;
+    sp<IPowerExt> mHandleExt;
     // Android framework only sends boost upto DISPLAY_UPDATE_IMMINENT.
     // Need to increase the array size if more boost supported.
     std::array<std::atomic<HalSupport>,
diff --git a/services/powermanager/Android.bp b/services/powermanager/Android.bp
index 6fbba3f568eafce82ad502eebbd6a873450d74ac..34e9e843063038f83a075753692834c77f93f8fe 100644
--- a/services/powermanager/Android.bp
+++ b/services/powermanager/Android.bp
@@ -39,6 +39,10 @@ cc_library_shared {
         "android.hardware.power@1.0",
         "android.hardware.power@1.1",
         "android.hardware.power-V3-cpp",
+    ], 
+
+    static_libs: [
+        "//hardware/google/interfaces:pixel-power-ext-V1-cpp"
     ],
 
     cflags: [
diff --git a/services/powermanager/PowerHalController.cpp b/services/powermanager/PowerHalController.cpp
index 8c225d5d02319ab59db713dde975f98386f4dd01..e321f8202da87d1d0498ac7dc33cebc74fcbd32e 100644
--- a/services/powermanager/PowerHalController.cpp
+++ b/services/powermanager/PowerHalController.cpp
@@ -33,9 +33,15 @@ namespace power {
 // -------------------------------------------------------------------------------------------------
 
 std::unique_ptr<HalWrapper> HalConnector::connect() {
-    sp<IPower> halAidl = PowerHalLoader::loadAidl();
-    if (halAidl) {
-        return std::make_unique<AidlHalWrapper>(halAidl);
+    std::pair<sp<IPower>, sp<IPowerExt>> halAidlAndExt = PowerHalLoader::loadAidlAndExt();
+    sp<IPower> powerHal = halAidlAndExt.first;
+    sp<IPowerExt> powerExtHal = halAidlAndExt.second;
+    // Check validity of aidl power hal as well as the extension hal
+    if (powerHal && powerExtHal) {
+        return std::make_unique<AidlHalWrapper>(powerHal, powerExtHal);
+    }
+    if (powerHal) {
+        return std::make_unique<AidlHalWrapper>(powerHal);
     }
     sp<V1_0::IPower> halHidlV1_0 = PowerHalLoader::loadHidlV1_0();
     sp<V1_1::IPower> halHidlV1_1 = PowerHalLoader::loadHidlV1_1();
@@ -86,6 +92,36 @@ HalResult<T> PowerHalController::processHalResult(HalResult<T> result, const cha
     return result;
 }
 
+HalResult<bool> PowerHalController::isPowerExtAvailable() {
+    std::shared_ptr<HalWrapper> handle = initHal();
+    auto result = handle->isPowerExtAvailable();
+    return processHalResult(result, "isPowerExtAvailable");
+}
+
+HalResult<bool> PowerHalController::isExtModeSupported(const ::std::string& mode) {
+    std::shared_ptr<HalWrapper> handle = initHal();
+    auto result = handle->isExtModeSupported(mode);
+    return processHalResult(result, "isExtModeSupported");
+}
+
+HalResult<bool> PowerHalController::isExtBoostSupported(const ::std::string& boost) {
+    std::shared_ptr<HalWrapper> handle = initHal();
+    auto result = handle->isExtBoostSupported(boost);
+    return processHalResult(result, "isPowerExtAvailable");
+}
+
+HalResult<void> PowerHalController::setExtMode(const ::std::string& mode, bool enabled) {
+    std::shared_ptr<HalWrapper> handle = initHal();
+    auto result = handle->setExtMode(mode, enabled);
+    return processHalResult(result, "setExtMode");
+}
+
+HalResult<void> PowerHalController::setExtBoost(const ::std::string& boost, int32_t durationMs) {
+    std::shared_ptr<HalWrapper> handle = initHal();
+    auto result = handle->setExtBoost(boost, durationMs);
+    return processHalResult(result, "setExtBoost");
+}
+
 HalResult<void> PowerHalController::setBoost(Boost boost, int32_t durationMs) {
     std::shared_ptr<HalWrapper> handle = initHal();
     auto result = handle->setBoost(boost, durationMs);
diff --git a/services/powermanager/PowerHalLoader.cpp b/services/powermanager/PowerHalLoader.cpp
index 1f1b43a607bca27295c0135aa1e79dbd2d316ac6..d963547453baae295c2a8761dd672dbbc2e4e48e 100644
--- a/services/powermanager/PowerHalLoader.cpp
+++ b/services/powermanager/PowerHalLoader.cpp
@@ -52,22 +52,34 @@ sp<T> loadHal(bool& exists, sp<T>& hal, F& loadFn, const char* halName) {
 // -------------------------------------------------------------------------------------------------
 
 std::mutex PowerHalLoader::gHalMutex;
+sp<IPowerExt> PowerHalLoader::gHalAidlExt = nullptr;
 sp<IPower> PowerHalLoader::gHalAidl = nullptr;
 sp<V1_0::IPower> PowerHalLoader::gHalHidlV1_0 = nullptr;
 sp<V1_1::IPower> PowerHalLoader::gHalHidlV1_1 = nullptr;
 
 void PowerHalLoader::unloadAll() {
     std::lock_guard<std::mutex> lock(gHalMutex);
+    gHalAidlExt = nullptr;
     gHalAidl = nullptr;
     gHalHidlV1_0 = nullptr;
     gHalHidlV1_1 = nullptr;
 }
 
-sp<IPower> PowerHalLoader::loadAidl() {
+std::pair<sp<IPower>, sp<IPowerExt>> PowerHalLoader::loadAidlAndExt() {
     std::lock_guard<std::mutex> lock(gHalMutex);
     static bool gHalExists = true;
     static auto loadFn = []() { return waitForVintfService<IPower>(); };
-    return loadHal<IPower>(gHalExists, gHalAidl, loadFn, "AIDL");
+
+    sp<IPower> pwBinder = loadHal<IPower>(gHalExists, gHalAidl, loadFn, "AIDL");
+    sp<IPowerExt> pwExtHal = nullptr;
+    if (gHalExists) {
+        sp<IBinder> pwExtBinder;
+        IPower::asBinder(pwBinder)->getExtension(&pwExtBinder);
+        gHalAidlExt = interface_cast<IPowerExt>(pwExtBinder);
+        pwExtHal = gHalAidlExt;
+    }
+
+    return std::make_pair(pwBinder, pwExtHal);
 }
 
 sp<V1_0::IPower> PowerHalLoader::loadHidlV1_0() {
diff --git a/services/powermanager/PowerHalWrapper.cpp b/services/powermanager/PowerHalWrapper.cpp
index d74bd23a8d7d09177e9c45c56d88bc8b58deb581..897cf55f945b3f39a4c8c1e67ef1445df4d2059a 100644
--- a/services/powermanager/PowerHalWrapper.cpp
+++ b/services/powermanager/PowerHalWrapper.cpp
@@ -80,6 +80,35 @@ HalResult<void> HalResult<void>::fromReturn(hardware::Return<R>& ret) {
 }
 // -------------------------------------------------------------------------------------------------
 
+HalResult<bool> EmptyHalWrapper::isPowerExtAvailable() {
+    ALOGV("Skipped isPowerExtAvailable because Power HAL not available");
+    return HalResult<bool>::unsupported();
+};
+
+HalResult<bool> EmptyHalWrapper::isExtModeSupported(const ::std::string& mode) {
+    ALOGV("Skipped isExtModeSupported with %s because Power HAL not available",
+          mode.c_str());
+    return HalResult<bool>::unsupported();
+};
+
+HalResult<bool> EmptyHalWrapper::isExtBoostSupported(const ::std::string& boost) {
+    ALOGV("Skipped isExtBoostSupported with %s because Power HAL not available",
+          boost.c_str());
+    return HalResult<bool>::unsupported();
+};
+
+HalResult<void> EmptyHalWrapper::setExtMode(const ::std::string& mode, bool enabled) {
+    ALOGV("Skipped setExtMode %s to %s because Power HAL not available", mode.c_str(),
+          enabled ? "true" : "false");
+    return HalResult<void>::unsupported();
+};
+
+HalResult<void> EmptyHalWrapper::setExtBoost(const ::std::string& boost, int32_t durationMs) {
+    ALOGV("Skipped setExtBoost %s with duration %dms because Power HAL not available",
+          boost.c_str(), durationMs);
+    return HalResult<void>::unsupported();
+};
+
 HalResult<void> EmptyHalWrapper::setBoost(Boost boost, int32_t durationMs) {
     ALOGV("Skipped setBoost %s with duration %dms because Power HAL not available",
           toString(boost).c_str(), durationMs);
@@ -106,6 +135,34 @@ HalResult<int64_t> EmptyHalWrapper::getHintSessionPreferredRate() {
 
 // -------------------------------------------------------------------------------------------------
 
+HalResult<bool> HidlHalWrapperV1_0::isPowerExtAvailable() {
+    ALOGV("Skipped isPowerExtAvailable because Power HAL AIDL not available");
+    return HalResult<bool>::unsupported();
+};
+
+HalResult<bool> HidlHalWrapperV1_0::isExtModeSupported(const ::std::string& mode) {
+    ALOGV("Skipped isExtModeSupported with %s because Power HAL not available",
+          mode.c_str());
+    return HalResult<bool>::unsupported();
+};
+
+HalResult<bool> HidlHalWrapperV1_0::isExtBoostSupported(const ::std::string& boost) {
+    ALOGV("Skipped isExtBoostSupported with %s because Power HAL not available",
+          boost.c_str());
+    return HalResult<bool>::unsupported();
+};
+
+HalResult<void> HidlHalWrapperV1_0::setExtMode(const ::std::string& mode, bool enabled) {
+    ALOGV("Skipped setExtMode %s to %s because Power HAL AIDL not available", mode.c_str(),
+          enabled ? "true" : "false");
+    return HalResult<void>::unsupported();
+}
+
+HalResult<void> HidlHalWrapperV1_0::setExtBoost(const ::std::string& boost, int32_t durationMs) {
+    ALOGV("Skipped setExtBoost %s duration %dms because Power HAL AIDL not available", boost.c_str(), durationMs);
+    return HalResult<void>::unsupported();
+}
+
 HalResult<void> HidlHalWrapperV1_0::setBoost(Boost boost, int32_t durationMs) {
     if (boost == Boost::INTERACTION) {
         return sendPowerHint(V1_0::PowerHint::INTERACTION, durationMs);
@@ -173,6 +230,50 @@ HalResult<void> HidlHalWrapperV1_1::sendPowerHint(V1_0::PowerHint hintId, uint32
 
 // -------------------------------------------------------------------------------------------------
 
+HalResult<bool> AidlHalWrapper::isPowerExtAvailable() {
+    if (mHandleExt) {
+        return HalResult<bool>::ok(true);
+    }
+    return HalResult<bool>::unsupported();
+};
+
+HalResult<bool> AidlHalWrapper::isExtModeSupported(const ::std::string& mode) {
+    if (mHandleExt) {
+        bool supported = false;
+        auto result = mHandleExt->isModeSupported(mode, &supported);
+        return HalResult<bool>::fromStatus(result, supported);
+    }
+    return HalResult<bool>::unsupported();
+};
+
+HalResult<bool> AidlHalWrapper::isExtBoostSupported(const ::std::string& boost) {
+    if (mHandleExt) {
+        bool supported = false;
+        auto result = mHandleExt->isBoostSupported(boost, &supported);
+        return HalResult<bool>::fromStatus(result, supported);
+    }
+    return HalResult<bool>::unsupported();
+};
+
+HalResult<void> AidlHalWrapper::setExtMode(const ::std::string& mode, bool enabled) {
+    std::unique_lock<std::mutex> lock(mModeMutex);
+    if (mHandleExt) {
+        return toHalResult(mHandleExt->setMode(mode, enabled));
+    }
+    ALOGV("Skipped setExtMode %s to %d because Power HAL AIDL not available", mode.c_str(), enabled);
+    return HalResult<void>::unsupported();
+}
+
+HalResult<void> AidlHalWrapper::setExtBoost(const ::std::string& boost, int32_t durationMs) {
+    std::unique_lock<std::mutex> lock(mBoostMutex);
+    if (mHandleExt) {
+        return toHalResult(mHandleExt->setBoost(boost, durationMs));
+    }
+    ALOGV("Skipped setExtBoost %s duration %dms because Power HAL AIDL not available",
+          boost.c_str(), durationMs);
+    return HalResult<void>::unsupported();
+}
+
 HalResult<void> AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) {
     std::unique_lock<std::mutex> lock(mBoostMutex);
     size_t idx = static_cast<size_t>(boost);