Merge 5744537267a91bf728069dd4bf81f59e845aec44 on remote branch

Change-Id: Iafa9b00cb8d40727b6c314da7d4ca37e8575662a

8 files changed, 299 insertions, 5 deletions

diff --git a/Android.bp b/Android.bp
index d7139426..fba358fd 100644
--- a/Android.bp
+++ b/Android.bp
@@ -117,6 +117,7 @@ cc_defaults {
         "libsnapshot_nobinder",
         "libsnapshot_cow",
         "liblz4",
+        "libzstd",
         "update_metadata-protos",
     ],
 }
diff --git a/etc/init.rc b/etc/init.rc
index 03df27b0..c7ff2b2b 100644
--- a/etc/init.rc
+++ b/etc/init.rc
@@ -110,6 +110,8 @@ on fs && property:sys.usb.configfs=1
     mkdir /config/usb_gadget/g1/functions/ffs.adb
     mkdir /config/usb_gadget/g1/functions/ffs.fastboot
     mkdir /config/usb_gadget/g1/configs/b.1 0777 shell shell
+    # Set current limit to 900mA (b/277022505)
+    write /config/usb_gadget/g1/configs/b.1/MaxPower 0x384
     mkdir /config/usb_gadget/g1/configs/b.1/strings/0x409 0770 shell shell
 
 on fs && property:sys.usb.configfs=0
diff --git a/install/include/install/wipe_device.h b/install/include/install/wipe_device.h
index 903ddfdc..19e7c65b 100644
--- a/install/include/install/wipe_device.h
+++ b/install/include/install/wipe_device.h
@@ -24,6 +24,7 @@
 
 // Wipes the current A/B device, with a secure wipe of all the partitions in RECOVERY_WIPE.
 bool WipeAbDevice(Device* device, size_t wipe_package_size);
+bool WipeAbDevice(Device* device, Package* wipe_package);
 
 // Reads the "recovery.wipe" entry in the zip archive returns a list of partitions to wipe.
 std::vector<std::string> GetWipePartitionList(Package* wipe_package);
diff --git a/install/install.cpp b/install/install.cpp
index 2535b887..2e4661b8 100644
--- a/install/install.cpp
+++ b/install/install.cpp
@@ -48,6 +48,7 @@
 
 #include "install/spl_check.h"
 #include "install/wipe_data.h"
+#include "install/wipe_device.h"
 #include "otautil/error_code.h"
 #include "otautil/package.h"
 #include "otautil/paths.h"
@@ -70,6 +71,10 @@ static constexpr int VERIFICATION_PROGRESS_TIME = 60;
 static constexpr float VERIFICATION_PROGRESS_FRACTION = 0.25;
 // The charater used to separate dynamic fingerprints. e.x. sargo|aosp-sargo
 static const char* FINGERPRING_SEPARATOR = "|";
+static constexpr auto&& RELEASE_KEYS_TAG = "release-keys";
+// If brick packages are smaller than |MEMORY_PACKAGE_LIMIT|, read the entire package into memory
+static constexpr size_t MEMORY_PACKAGE_LIMIT = 1024 * 1024;
+
 static std::condition_variable finish_log_temperature;
 static bool isInStringList(const std::string& target_token, const std::string& str_list,
                            const std::string& deliminator);
@@ -213,6 +218,7 @@ bool CheckPackageMetadata(const std::map<std::string, std::string>& metadata, Ot
   // We allow the package to not have any serialno; and we also allow it to carry multiple serial
   // numbers split by "|"; e.g. serialno=serialno1|serialno2|serialno3 ... We will fail the
   // verification if the device's serialno doesn't match any of these carried numbers.
+
   auto pkg_serial_no = get_value(metadata, "serialno");
   if (!pkg_serial_no.empty()) {
     auto device_serial_no = android::base::GetProperty("ro.serialno", "");
@@ -226,6 +232,21 @@ bool CheckPackageMetadata(const std::map<std::string, std::string>& metadata, Ot
       LOG(ERROR) << "Package is for serial " << pkg_serial_no;
       return false;
     }
+  } else if (ota_type == OtaType::BRICK) {
+    const auto device_build_tag = android::base::GetProperty("ro.build.tags", "");
+    if (device_build_tag.empty()) {
+      LOG(ERROR) << "Unable to determine device build tags, serial number is missing from package. "
+                    "Rejecting the brick OTA package.";
+      return false;
+    }
+    if (device_build_tag == RELEASE_KEYS_TAG) {
+      LOG(ERROR) << "Device is release key build, serial number is missing from package. "
+                    "Rejecting the brick OTA package.";
+      return false;
+    }
+    LOG(INFO)
+        << "Serial number is missing from brick OTA package, permitting anyway because device is "
+        << device_build_tag;
   }
 
   if (ota_type == OtaType::AB) {
@@ -364,7 +385,20 @@ static InstallResult TryUpdateBinary(Package* package, bool* wipe_cache,
     return INSTALL_CORRUPT;
   }
 
-  bool package_is_ab = get_value(metadata, "ota-type") == OtaTypeToString(OtaType::AB);
+  const bool package_is_ab = get_value(metadata, "ota-type") == OtaTypeToString(OtaType::AB);
+  const bool package_is_brick = get_value(metadata, "ota-type") == OtaTypeToString(OtaType::BRICK);
+  if (package_is_brick) {
+    LOG(INFO) << "Installing a brick package";
+    if (package->GetType() == PackageType::kFile &&
+        package->GetPackageSize() < MEMORY_PACKAGE_LIMIT) {
+      std::vector<uint8_t> content(package->GetPackageSize());
+      if (package->ReadFullyAtOffset(content.data(), content.size(), 0)) {
+        auto memory_package = Package::CreateMemoryPackage(std::move(content), {});
+        return WipeAbDevice(device, memory_package.get()) ? INSTALL_SUCCESS : INSTALL_ERROR;
+      }
+    }
+    return WipeAbDevice(device, package) ? INSTALL_SUCCESS : INSTALL_ERROR;
+  }
   bool device_supports_ab = android::base::GetBoolProperty("ro.build.ab_update", false);
   bool ab_device_supports_nonab =
       android::base::GetBoolProperty("ro.virtual_ab.allow_non_ab", false);
diff --git a/install/wipe_device.cpp b/install/wipe_device.cpp
index 0a525fa9..2656580f 100644
--- a/install/wipe_device.cpp
+++ b/install/wipe_device.cpp
@@ -182,13 +182,17 @@ bool WipeAbDevice(Device* device, size_t wipe_package_size) {
     LOG(ERROR) << "Failed to open wipe package";
     return false;
   }
+  return WipeAbDevice(device, wipe_package.get());
+}
 
-  if (!CheckWipePackage(wipe_package.get(), ui)) {
+bool WipeAbDevice(Device* device, Package* wipe_package) {
+  auto ui = device->GetUI();
+  if (!CheckWipePackage(wipe_package, ui)) {
     LOG(ERROR) << "Failed to verify wipe package";
     return false;
   }
 
-  auto partition_list = GetWipePartitionList(wipe_package.get());
+  auto partition_list = GetWipePartitionList(wipe_package);
   if (partition_list.empty()) {
     LOG(ERROR) << "Empty wipe ab partition list";
     return false;
diff --git a/minui/graphics_drm.cpp b/minui/graphics_drm.cpp
index c17cef95..a8cd5a95 100644
--- a/minui/graphics_drm.cpp
+++ b/minui/graphics_drm.cpp
@@ -54,6 +54,7 @@
 #include <memory>
 
 #include <android-base/macros.h>
+#include <android-base/properties.h>
 #include <android-base/stringprintf.h>
 #include <android-base/unique_fd.h>
 #include <string>
@@ -189,6 +190,98 @@ static int atomic_add_prop_to_plane(Plane *plane_res, drmModeAtomicReq *req,
   return 0;
 }
 
+static int SetupSprBlobV1(int fd, uint32_t* blob_id) {
+  SPRPackType pack_type = SPRPackType::kPentile;
+  SPRFilterType filter_type = SPRFilterType::kFourTap;
+  SPRAdaptiveModeType adpative_mode = SPRAdaptiveModeType::kYYGM;
+
+  drm_msm_spr_init_cfg spr_init_cfg;
+  spr_init_cfg.cfg0 = 1;
+  spr_init_cfg.cfg1 = 1;
+  spr_init_cfg.cfg2 = 1;
+  spr_init_cfg.cfg3 = 0;
+  spr_init_cfg.flags = 0;
+  spr_init_cfg.cfg4 = (pack_type == SPRPackType::kRGBW);
+  spr_init_cfg.cfg5 = kDefaultColorPhaseIncrement.at(pack_type);
+  spr_init_cfg.cfg6 = kDefaultColorPhaseRepeat.at(pack_type);
+  spr_init_cfg.cfg7 = static_cast<uint16_t>(filter_type);
+  spr_init_cfg.cfg8 = static_cast<uint16_t>(adpative_mode);
+  if (pack_type == SPRPackType::kRGBW) {
+    spr_init_cfg.cfg9 = 512;
+    std::copy(kDefaultRGBWGains.begin(), kDefaultRGBWGains.end(), spr_init_cfg.cfg11);
+  }
+  spr_init_cfg.cfg10 = 0;
+  std::copy(kDecimationRatioMap.at(pack_type).begin(), kDecimationRatioMap.at(pack_type).end(),
+            spr_init_cfg.cfg11);
+  std::copy(kDefaultOPRGains.begin(), kDefaultOPRGains.end(), spr_init_cfg.cfg13);
+  std::copy(kDefaultAdaptiveStrengths.begin(), kDefaultAdaptiveStrengths.end(), spr_init_cfg.cfg14);
+  std::copy(kDefaultOPROffsets.begin(), kDefaultOPROffsets.end(), spr_init_cfg.cfg15);
+  std::copy(kDefaultFilterCoeffsMap.at(filter_type).begin(),
+            kDefaultFilterCoeffsMap.at(filter_type).end(), spr_init_cfg.cfg16);
+  std::copy(kDefaultColorPhaseMap.at(pack_type).begin(), kDefaultColorPhaseMap.at(pack_type).end(),
+            spr_init_cfg.cfg17);
+
+  if (drmModeCreatePropertyBlob(fd, &spr_init_cfg, sizeof(drm_msm_spr_init_cfg), blob_id)) {
+    printf("failed to create spr blob\n");
+    return -EINVAL;
+  }
+
+  return 0;
+}
+
+static int SetupSprBlobV2(int fd, uint32_t* blob_id) {
+  SPRPackType pack_type = SPRPackType::kPentile;
+  SPRFilterType filter_type = SPRFilterType::kFourTap;
+  SPRAdaptiveModeType adpative_mode = SPRAdaptiveModeType::kYYGM;
+
+  drm_msm_spr_init_cfg_v2 spr_init_cfg_v2;
+  spr_init_cfg_v2.cfg0 = 1;
+  spr_init_cfg_v2.cfg1 = 1;
+  spr_init_cfg_v2.cfg2 = 1;
+  spr_init_cfg_v2.cfg3 = 0;
+  spr_init_cfg_v2.flags = 0;
+  spr_init_cfg_v2.cfg4 = (pack_type == SPRPackType::kRGBW);
+  spr_init_cfg_v2.cfg5 = kDefaultColorPhaseIncrement.at(pack_type);
+  spr_init_cfg_v2.cfg6 = kDefaultColorPhaseRepeat.at(pack_type);
+  spr_init_cfg_v2.cfg7 = static_cast<uint16_t>(filter_type);
+  spr_init_cfg_v2.cfg8 = static_cast<uint16_t>(adpative_mode);
+  if (pack_type == SPRPackType::kRGBW) {
+    spr_init_cfg_v2.cfg9 = 512;
+    std::copy(kDefaultRGBWGains.begin(), kDefaultRGBWGains.end(), spr_init_cfg_v2.cfg11);
+  }
+  spr_init_cfg_v2.cfg10 = 0;
+  std::copy(kDecimationRatioMap.at(pack_type).begin(), kDecimationRatioMap.at(pack_type).end(),
+            spr_init_cfg_v2.cfg11);
+  std::copy(kDefaultOPRGains.begin(), kDefaultOPRGains.end(), spr_init_cfg_v2.cfg13);
+  std::copy(kDefaultAdaptiveStrengths.begin(), kDefaultAdaptiveStrengths.end(),
+            spr_init_cfg_v2.cfg14);
+  std::copy(kDefaultOPROffsets.begin(), kDefaultOPROffsets.end(), spr_init_cfg_v2.cfg15);
+  std::copy(kDefaultFilterCoeffsMap.at(filter_type).begin(),
+            kDefaultFilterCoeffsMap.at(filter_type).end(), spr_init_cfg_v2.cfg16);
+  std::copy(kDefaultColorPhaseMap.at(pack_type).begin(), kDefaultColorPhaseMap.at(pack_type).end(),
+            spr_init_cfg_v2.cfg17);
+
+  if (drmModeCreatePropertyBlob(fd, &spr_init_cfg_v2, sizeof(drm_msm_spr_init_cfg_v2), blob_id)) {
+    printf("failed to create spr blob\n");
+    return -EINVAL;
+  }
+
+  return 0;
+}
+
+static int SetupSprBlob(int fd, const std::string& prop_name, uint32_t* blob_id) {
+  int ret = 0;
+  if (prop_name == "SDE_SPR_INIT_CFG_V1") {
+    ret = SetupSprBlobV1(fd, blob_id);
+  } else if (prop_name == "SDE_SPR_INIT_CFG_V2") {
+    ret = SetupSprBlobV2(fd, blob_id);
+  } else {
+    ret = -ENOENT;
+  }
+
+  return ret;
+}
+
 int MinuiBackendDrm::AtomicPopulatePlane(int plane, drmModeAtomicReqPtr atomic_req, DrmConnector index) {
   uint32_t src_x, src_y, src_w, src_h;
   uint32_t crtc_x, crtc_y, crtc_w, crtc_h;
@@ -265,6 +358,10 @@ int MinuiBackendDrm::TeardownPipeline(drmModeAtomicReqPtr atomic_req, DrmConnect
   add_prop(&conn_res, connector, Connector, drm[index].monitor_connector->connector_id, "CRTC_ID", 0, index);
   add_prop(&crtc_res, crtc, Crtc, drm[index].monitor_crtc->crtc_id, "MODE_ID", 0, index);
   add_prop(&crtc_res, crtc, Crtc, drm[index].monitor_crtc->crtc_id, "ACTIVE", 0, index);
+  if (spr_enabled) {
+    add_prop(&crtc_res, crtc, Crtc, drm[index].monitor_crtc->crtc_id, spr_prop_name.c_str(), 0,
+             index);
+  }
 
   for(i = 0; i < number_of_lms; i++) {
     ret = atomic_add_prop_to_plane(plane_res, atomic_req,
@@ -292,6 +389,10 @@ int MinuiBackendDrm::SetupPipeline(drmModeAtomicReqPtr atomic_req, DrmConnector
          "CRTC_ID", drm[index].monitor_crtc->crtc_id, index);
     add_prop(&crtc_res, crtc, Crtc, drm[index].monitor_crtc->crtc_id, "MODE_ID", crtc_res.mode_blob_id, index);
     add_prop(&crtc_res, crtc, Crtc, drm[index].monitor_crtc->crtc_id, "ACTIVE", 1, index);
+    if (spr_enabled) {
+      add_prop(&crtc_res, crtc, Crtc, drm[index].monitor_crtc->crtc_id, spr_prop_name.c_str(),
+               crtc_res.spr_blob_id, index);
+    }
   }
 
   /* Setup planes */
@@ -652,6 +753,7 @@ GRSurface* MinuiBackendDrm::Init() {
   drmModeRes* res = nullptr;
   drm_fd = -1;
 
+  spr_enabled = android::base::GetIntProperty("vendor.display.enable_spr", 0);
   number_of_lms = DEFAULT_NUM_LMS;
   /* Consider DRM devices in order. */
   for (int i = 0; i < DRM_MAX_MINOR; i++) {
@@ -743,9 +845,15 @@ GRSurface* MinuiBackendDrm::Init() {
   if (!crtc_res.props_info)
     return NULL;
   else
-    for (int j = 0; j < (int)crtc_res.props->count_props; ++j)
+    for (int j = 0; j < (int)crtc_res.props->count_props; ++j) {
       crtc_res.props_info[j] = drmModeGetProperty(drm_fd,
                                    crtc_res.props->props[j]);
+      /* Get spr property name */
+      if (!strcmp(crtc_res.props_info[j]->name, "SDE_SPR_INIT_CFG_V1") ||
+          !strcmp(crtc_res.props_info[j]->name, "SDE_SPR_INIT_CFG_V2")) {
+        spr_prop_name = crtc_res.props_info[j]->name;
+      }
+    }
 
   /* Set connector resources */
   conn_res.props = drmModeObjectGetProperties(drm_fd,
@@ -800,6 +908,13 @@ GRSurface* MinuiBackendDrm::Init() {
   drmModeFreePlaneResources(plane_options);
   plane_options = NULL;
 
+  /* Setup spr blob id if enabled */
+  if (spr_enabled) {
+    if (SetupSprBlob(drm_fd, spr_prop_name, &crtc_res.spr_blob_id)) {
+      return NULL;
+    }
+  }
+
   /* Setup pipe and blob_id */
   if (drmModeCreatePropertyBlob(drm_fd, &drm[DRM_MAIN].monitor_crtc->mode, sizeof(drmModeModeInfo),
       &crtc_res.mode_blob_id)) {
diff --git a/minui/graphics_drm.h b/minui/graphics_drm.h
index 5124dbe9..a883e84d 100644
--- a/minui/graphics_drm.h
+++ b/minui/graphics_drm.h
@@ -19,6 +19,8 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <array>
+#include <map>
 #include <memory>
 
 #include <xf86drmMode.h>
@@ -30,10 +32,97 @@
 #define NUM_PLANES 4
 #define DEFAULT_NUM_LMS 2
 
+#define SPR_INIT_PARAM_SIZE_1 4
+#define SPR_INIT_PARAM_SIZE_2 5
+#define SPR_INIT_PARAM_SIZE_3 16
+#define SPR_INIT_PARAM_SIZE_4 24
+#define SPR_INIT_PARAM_SIZE_5 32
+#define SPR_INIT_PARAM_SIZE_6 7
+
+enum class SPRPackType {
+  kPentile,
+  kRGBW,
+  kYYGW,
+  kYYGM,
+  kDelta3,
+  kMax = 0xFF,
+};
+
+enum class SPRFilterType {
+  kPixelDrop,
+  kBilinear,
+  kFourTap,
+  kAdaptive,
+  k2DAvg,
+  kMax = 0xFF,
+};
+
+enum class SPRAdaptiveModeType {
+  kYYGM,
+  kYYGW,
+  kMax = 0xFF,
+};
+
+static const std::map<SPRPackType, uint32_t> kDefaultColorPhaseIncrement = {
+  { { { SPRPackType::kPentile }, { 8 } },
+    { { SPRPackType::kYYGM }, { 6 } },
+    { { SPRPackType::kYYGW }, { 6 } },
+    { { SPRPackType::kDelta3 }, { 6 } },
+    { { SPRPackType::kRGBW }, { 8 } } }
+};
+static const std::map<SPRPackType, uint32_t> kDefaultColorPhaseRepeat = {
+  { { { SPRPackType::kPentile }, { 2 } },
+    { { SPRPackType::kYYGM }, { 2 } },
+    { { SPRPackType::kYYGW }, { 2 } },
+    { { SPRPackType::kDelta3 }, { 2 } },
+    { { SPRPackType::kRGBW }, { 2 } } }
+};
+static const std::map<SPRPackType, std::array<uint16_t, SPR_INIT_PARAM_SIZE_1>> kDecimationRatioMap{
+  {
+      { { SPRPackType::kPentile }, { 1, 0, 1, 0 } },
+      { { SPRPackType::kYYGM }, { 2, 2, 2, 0 } },
+      { { SPRPackType::kYYGW }, { 2, 2, 2, 0 } },
+      { { SPRPackType::kRGBW }, { 1, 1, 1, 1 } },
+  }
+};
+static const std::map<SPRFilterType, std::array<int16_t, SPR_INIT_PARAM_SIZE_3>>
+    kDefaultFilterCoeffsMap{
+      { { { SPRFilterType::kPixelDrop }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+        { { SPRFilterType::kBilinear },
+          { 0, 512, 0, 0, -33, 443, 110, -8, -23, 279, 279, -23, -8, 110, 443, -33 } },
+        { { SPRFilterType::kFourTap },
+          { 128, 256, 128, 0, 86, 241, 164, 21, 52, 204, 204, 52, 21, 164, 241, 86 } },
+        { { SPRFilterType::kAdaptive },
+          { 0, 256, 256, 0, 0, 256, 256, 0, 0, 256, 256, 0, 0, 256, 256, 0 } } }
+    };
+static const std::map<SPRPackType, std::array<int16_t, SPR_INIT_PARAM_SIZE_4>>
+    kDefaultColorPhaseMap{
+      { { { SPRPackType::kPentile },
+          { -2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+        { { SPRPackType::kYYGM },
+          { -3, 0, 0, 0, 0, 0, -1, 2, 1, 1, 0, 0, 1, -2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 } },
+        { { SPRPackType::kYYGW },
+          { -4, 2, 0, 0, 0, -1, 2, 2, 0, -1, -1, -1, 2, 2, -1, -1, -1, 2, 0, 0, 0, 0, 0, 0 } },
+        { { SPRPackType::kDelta3 },
+          { -3, 0, 0, 0, 0, 0, 0, -3, 0, 0, 0, 0, -3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } },
+        { { SPRPackType::kRGBW },
+          { -4, 0, 0, 0, 0, 0, -2, 2, 0, 0, 0, 0, 0, -4, 0, 0, 0, 0, 2, -2, 0, 0, 0, 0 } } }
+    };
+static const std::array<uint16_t, SPR_INIT_PARAM_SIZE_1> kDefaultRGBWGains = { 1024, 1024, 1024,
+                                                                               341 };
+static const std::array<uint16_t, SPR_INIT_PARAM_SIZE_1> kDefaultOPRGains = { 341, 341, 341, 0 };
+static const std::array<uint16_t, SPR_INIT_PARAM_SIZE_2> kDefaultAdaptiveStrengths = { 0, 4, 8, 12,
+                                                                                       16 };
+static const std::array<uint16_t, SPR_INIT_PARAM_SIZE_5> kDefaultOPROffsets = {
+  0,    132,  264,  396,  529,  661,  793,  925,  1057, 1189, 1321, 1453, 1586, 1718, 1850, 1982,
+  2114, 2246, 2378, 2510, 2643, 2775, 2907, 3039, 3171, 3303, 3435, 3567, 3700, 3832, 3964, 4095
+};
+
 struct Crtc {
   drmModeObjectProperties *props;
   drmModePropertyRes **props_info;
   uint32_t mode_blob_id;
+  uint32_t spr_blob_id;
 };
 
 struct Connector {
@@ -47,6 +136,52 @@ struct Plane {
   drmModePropertyRes ** props_info;
 };
 
+struct drm_msm_spr_init_cfg {
+  __u64 flags;
+  __u16 cfg0;
+  __u16 cfg1;
+  __u16 cfg2;
+  __u16 cfg3;
+  __u16 cfg4;
+  __u16 cfg5;
+  __u16 cfg6;
+  __u16 cfg7;
+  __u16 cfg8;
+  __u16 cfg9;
+  __u32 cfg10;
+  __u16 cfg11[SPR_INIT_PARAM_SIZE_1];
+  __u16 cfg12[SPR_INIT_PARAM_SIZE_1];
+  __u16 cfg13[SPR_INIT_PARAM_SIZE_1];
+  __u16 cfg14[SPR_INIT_PARAM_SIZE_2];
+  __u16 cfg15[SPR_INIT_PARAM_SIZE_5];
+  int cfg16[SPR_INIT_PARAM_SIZE_3];
+  int cfg17[SPR_INIT_PARAM_SIZE_4];
+};
+
+struct drm_msm_spr_init_cfg_v2 {
+  __u64 flags;
+  __u16 cfg0;
+  __u16 cfg1;
+  __u16 cfg2;
+  __u16 cfg3;
+  __u16 cfg4;
+  __u16 cfg5;
+  __u16 cfg6;
+  __u16 cfg7;
+  __u16 cfg8;
+  __u16 cfg9;
+  __u32 cfg10;
+  __u16 cfg11[SPR_INIT_PARAM_SIZE_1];
+  __u16 cfg12[SPR_INIT_PARAM_SIZE_1];
+  __u16 cfg13[SPR_INIT_PARAM_SIZE_1];
+  __u16 cfg14[SPR_INIT_PARAM_SIZE_2];
+  __u16 cfg15[SPR_INIT_PARAM_SIZE_5];
+  int cfg16[SPR_INIT_PARAM_SIZE_3];
+  int cfg17[SPR_INIT_PARAM_SIZE_4];
+  __u16 cfg18_en;
+  __u8 cfg18[SPR_INIT_PARAM_SIZE_6];
+};
+
 class GRSurfaceDrm : public GRSurface {
  public:
   ~GRSurfaceDrm() override;
@@ -111,4 +246,6 @@ class MinuiBackendDrm : public MinuiBackend {
   struct Connector conn_res;
   struct Plane plane_res[NUM_PLANES];
   uint32_t number_of_lms;
+  uint32_t spr_enabled;
+  std::string spr_prop_name;
 };
diff --git a/tools/recovery_l10n/res/values-te/strings.xml b/tools/recovery_l10n/res/values-te/strings.xml
index 57470752..513ae9d5 100644
--- a/tools/recovery_l10n/res/values-te/strings.xml
+++ b/tools/recovery_l10n/res/values-te/strings.xml
@@ -6,7 +6,7 @@
     <string name="recovery_no_command" msgid="4465476568623024327">"ఆదేశం లేదు"</string>
     <string name="recovery_error" msgid="5748178989622716736">"ఎర్రర్ ఏర్పడింది!"</string>
     <string name="recovery_installing_security" msgid="9184031299717114342">"సెక్యూరిటీ అప్‌డేట్‌ను ఇన్‌స్టాల్ చేస్తోంది"</string>
-    <string name="recovery_wipe_data_menu_header" msgid="550255032058254478">"Android సిస్టమ్‌ని లోడ్ చేయడం సాధ్యం కాదు. మీ డేటా పాడై ఉండవచ్చు. మీకు ఈ మెసేజ్‌ వస్తూనే ఉంటే, మీరు ఫ్యాక్టరీ డేటా రీసెట్ చేసి, పరికరంలో నిల్వ అయిన వినియోగదారు డేటా మొత్తాన్ని తొలగించాల్సి రావచ్చు."</string>
+    <string name="recovery_wipe_data_menu_header" msgid="550255032058254478">"Android సిస్టమ్‌ని లోడ్ చేయడం సాధ్యం కాదు. మీ డేటా పాడై ఉండవచ్చు. మీకు ఈ మెసేజ్‌ వస్తూనే ఉంటే, మీరు ఫ్యాక్టరీ డేటా రీసెట్ చేసి, పరికరంలో స్టోరేజ్‌ అయిన వినియోగదారు డేటా మొత్తాన్ని తొలగించాల్సి రావచ్చు."</string>
     <string name="recovery_try_again" msgid="7168248750158873496">"మళ్లీ ప్రయత్నించు"</string>
     <string name="recovery_factory_data_reset" msgid="7321351565602894783">"ఫ్యాక్టరీ డేటా రీసెట్"</string>
     <string name="recovery_wipe_data_confirmation" msgid="5439823343348043954">"వినియోగదారు డేటా మొత్తాన్ని తొలగించాలా?\n\n ఈ చర్యను రద్దు చేయలేరు!"</string>