Add hdcp hwc support

1. Add hdcp drm property
2. Add hdcp2.2 support in hwc/libhwcservice
3. Delete libhwcservice hardcode for servie connect
4. Fix type0/type1 switch issue
5. Add libhwcservice for media hdcp api

Test-done:
    Android hdcp daemon test

Tracked-On: OAM-

Signed-off-by: Jialin <lin.a.jia@intel.com>
Signed-off-by: Li, HaihongX <haihongx.li@intel.com>

Author: ljia5

Android.bp

@@ -49,6 +49,9 @@ cc_defaults {
         "libsync",
         "libui",
         "libutils",
+        "libbinder",
+        "libhwcservice",
+        "libutilscallstack",
     ],
 
     include_dirs: ["vendor/intel/external/drm-hwcomposer"],
@@ -68,6 +71,10 @@ cc_defaults {
         "-DHWC2_USE_CPP11",
         "-std=c++17",
         "-DUSE_IMAPPER4_METADATA_API",
+        "-Wno-unused-parameter",
+        "-Wno-unused-private-field",
+        "-Wno-unused-function",
+        "-frtti",
     ],
 
     product_variables: {
@@ -111,6 +118,8 @@ filegroup {
         "hwc2_device/HwcDisplayConfigs.cpp",
         "hwc2_device/HwcLayer.cpp",
         "hwc2_device/hwc2_device.cpp",
+        "hwc2_device/hwcservice.cpp",
+        "hwc2_device/callstack.cpp",
     ],
 }
 

drm/DrmAtomicStateManager.cpp

@@ -675,4 +675,84 @@ auto DrmAtomicStateManager::SetColorBrightnessContrast(void) ->int{
 
   return 0;
 }
+
+void DrmAtomicStateManager::SetHDCPState(HWCContentProtection state,
+                              HWCContentType content_type) {
+  uint64_t value = 3;
+  uint64_t type = 3;
+  int ret =0;
+
+  auto *connector = pipe_->connector->Get();
+
+  if (!connector->IsConnected())
+    return;
+
+  desired_protection_support_ = state;
+  ALOGD("SetHDCPState desired_protection_support_ %d\n",desired_protection_support_);
+  ALOGD("SetHDCPState current_protection_support_ %d\n",current_protection_support_);
+
+  if (desired_protection_support_ == current_protection_support_)
+    return;
+
+  if (pipe_->connector->Get()->GetHdcpTypeProperty().id() <= 0) {
+    ALOGE("Cannot set HDCP state as Type property is not supported \n");
+    return;
+  }
+
+  std::tie(ret, type) = pipe_->connector->Get()->GetHdcpTypeProperty().value();
+  ALOGD("Get Content type %lu \n", type);
+  ALOGD("Get Content content_type %u \n", content_type);
+
+  if ((content_type < 2) && (content_type_ != content_type)) {
+    content_type_ = content_type;
+
+    ALOGD("Set Content type %u \n", content_type);
+    drmModeConnectorSetProperty(pipe_->device->GetFd(),
+		  pipe_->connector->Get()->GetId(),
+		  pipe_->connector->Get()->GetHdcpTypeProperty().id(),
+		  content_type);
+
+  }
+
+  if (pipe_->connector->Get()->GetHdcpProperty().id() <= 0) {
+    ALOGE("Cannot set HDCP state as Connector property is not supported \n");
+    return;
+  }
+
+  std::tie(ret, value) = pipe_->connector->Get()->GetHdcpProperty().value();
+  ALOGD("Get Content Protection value %lu \n", value);
+
+  if (value < 3) {
+    switch (value) {
+      case 0:
+        //current_protection_support_ = HWCContentProtection::kUnDesired;
+        current_protection_support_ = hwcomposer::HWCContentProtection::kUnDesired;
+        ALOGD("%s GetHDCPConnectorProperty value 0", __FUNCTION__);
+        break;
+      case 1:
+        //current_protection_support_ = HWCContentProtection::kDesired;
+        current_protection_support_ = hwcomposer::HWCContentProtection::kDesired;
+        ALOGD("%s GetHDCPConnectorProperty value 1", __FUNCTION__);
+        break;
+      default:
+        ALOGE("%s GetHDCPConnectorProperty default", __FUNCTION__);
+        break;
+    }
+  }
+
+  if (desired_protection_support_ == HWCContentProtection::kUnSupported) {
+    desired_protection_support_ = current_protection_support_;
+  }
+
+  current_protection_support_ = desired_protection_support_;
+  if (current_protection_support_ == kDesired) {
+    value = 1;
+  }
+
+  ALOGD("Set Content Protection %lu \n", value);
+  drmModeConnectorSetProperty(pipe_->device->GetFd(),
+		  pipe_->connector->Get()->GetId(),
+		  pipe_->connector->Get()->GetHdcpProperty().id(),
+		  value);
+}
 }  // namespace android

drm/DrmAtomicStateManager.h

@@ -111,6 +111,8 @@ class DrmAtomicStateManager {
                                     uint32_t brightness_c) ->int;
   auto ApplyPendingLUT(struct drm_color_lut *lut,  uint64_t lut_size) -> int;
 
+  void SetHDCPState(HWCContentProtection state,
+                    HWCContentType content_type);
  private:
   auto CommitFrame(AtomicCommitArgs &args) -> int;
 
@@ -156,6 +158,12 @@ class DrmAtomicStateManager {
   int frames_staged_{};
   int frames_tracked_{};
   bool hdr_mdata_set_ = false;
+
+  hwcomposer::HWCContentProtection current_protection_support_ =
+      hwcomposer::HWCContentProtection::kUnSupported;
+  hwcomposer::HWCContentProtection desired_protection_support_ =
+      hwcomposer::HWCContentProtection::kUnSupported;
+  hwcomposer::HWCContentType content_type_ = hwcomposer::kCONTENT_TYPE0;
 };
 
 }  // namespace android

drm/DrmConnector.cpp

@@ -73,6 +73,16 @@ auto DrmConnector::CreateInstance(DrmDevice &dev, uint32_t connector_id,
   auto c = std::unique_ptr<DrmConnector>(
       new DrmConnector(std::move(conn), &dev, index));
 
+  if (!GetConnectorProperty(dev, *c, "Content Protection", &c->hdcp_id_property_)) {
+      ALOGE("%s GetHDCPConnectorProperty check failed!", __FUNCTION__);
+      return {};
+  }
+
+  if (!GetConnectorProperty(dev, *c, "HDCP Content Type", &c->hdcp_type_property_)) {
+      ALOGE("%s GetHDCPTypeProperty check failed!", __FUNCTION__);
+      return {};
+  }
+
   if (!GetConnectorProperty(dev, *c, "DPMS", &c->dpms_property_) ||
       !GetConnectorProperty(dev, *c, "CRTC_ID", &c->crtc_id_property_) ||
       (dev.IsHdrSupportedDevice() && !GetConnectorProperty(dev, *c, "HDR_OUTPUT_METADATA", &c->hdr_op_metadata_prop_))) {
@@ -601,4 +611,31 @@ void DrmConnector::PrepareHdrMetadata(hdr_md *layer_hdr_metadata,
 const DrmProperty &DrmConnector::link_status_property() const {
   return link_status_property_;
 }
+#if 0
+void DrmConnector::SetHDCPState(HWCContentProtection state,
+                              HWCContentType content_type) {
+  desired_protection_support_ = state;
+  content_type_ = content_type;
+  if (desired_protection_support_ == current_protection_support_)
+    return;
+
+  if (hdcp_id_prop_ <= 0) {
+    ETRACE("Cannot set HDCP state as Connector property is not supported \n");
+    return;
+  }
+
+  if (!(connection_state_ & kConnected)) {
+    return;
+  }
+
+  current_protection_support_ = desired_protection_support_;
+  uint32_t value = 0;
+  if (current_protection_support_ == kDesired) {
+    value = 1;
+  }
+
+  drmModeConnectorSetProperty(gpu_fd_, connector_, hdcp_id_prop_, value);
+  ITRACE("Ignored Content type. \n");
+}
+#endif
 }  // namespace android

drm/DrmConnector.h

@@ -31,6 +31,7 @@
 #include "DrmUnique.h"
 #include "utils/hdr_metadata_defs.h"
 #include "utils/cta_hdr_defs.h"
+#include "utils/hwcdefs.h"
 
 namespace android {
 
@@ -114,6 +115,13 @@ class DrmConnector : public PipelineBindable<DrmConnector> {
     return hdr_metadata_;
   }
 
+  auto &GetHdcpProperty() const {
+    return hdcp_id_property_;
+  }
+
+  auto &GetHdcpTypeProperty() const {
+    return hdcp_type_property_;
+  }
 
   auto IsConnected() const {
     return connector_->connection == DRM_MODE_CONNECTED;
@@ -144,7 +152,8 @@ class DrmConnector : public PipelineBindable<DrmConnector> {
 
   void PrepareHdrMetadata(hdr_md *layer_hdr_metadata,
                           struct hdr_output_metadata *final_hdr_metadata);
-
+  void SetHDCPState(hwcomposer::HWCContentProtection state,
+                    hwcomposer::HWCContentType content_type);
   const DrmProperty &link_status_property() const;
  private:
   DrmConnector(DrmModeConnectorUnique connector, DrmDevice *drm, uint32_t index)
@@ -167,6 +176,8 @@ class DrmConnector : public PipelineBindable<DrmConnector> {
   DrmProperty writeback_fb_id_;
   DrmProperty writeback_out_fence_;
   DrmProperty link_status_property_;
+  DrmProperty hdcp_id_property_;
+  DrmProperty hdcp_type_property_;
 
   uint32_t preferred_mode_id_{};
   //hdr_output_metadata property

drm/DrmDevice.cpp

@@ -276,7 +276,60 @@ bool DrmDevice::IsHdrSupportedDevice() {
 
   return is_hdr_supported_;
 }
+#if 0
+void DrmDevice::EnableHDCPSessionForDisplay(
+    uint32_t connector, HWCContentType content_type) {
+  GetPipe().atomic_state_manager->SetHDCPState(HWCContentProtection::kDesired,
+                                               content_type);
+#if 0
+  size_t size = displays_.size();
+  for (size_t i = 0; i < size; i++) {
+    if (displays_.at(i)->GetConnectorID() == connector) {
+      displays_.at(i)->SetHDCPState(HWCContentProtection::kDesired,
+                                    content_type);
+    }
+  }
+#endif  
+}
+
+void DrmDevice::EnableHDCPSessionForAllDisplays(
+    HWCContentType content_type) {
+  GetPipe().atomic_state_manager->SetHDCPState(HWCContentProtection::kDesired,
+                                               content_type);
+#if 0
+  size_t size = displays_.size();
+  for (size_t i = 0; i < size; i++) {
+    displays_.at(i)->SetHDCPState(HWCContentProtection::kDesired, content_type);
+  }
+#endif
+}
 
+void DrmDevice::DisableHDCPSessionForDisplay(uint32_t connector) {
+  GetPipe().atomic_state_manager->SetHDCPState(HWCContentProtection::kDesired,
+                                               content_type);
+#if 0
+  size_t size = displays_.size();
+  for (size_t i = 0; i < size; i++) {
+    if (displays_.at(i)->GetConnectorID() == connector) {
+      displays_.at(i)->SetHDCPState(HWCContentProtection::kUnDesired,
+                                    HWCContentType::kInvalid);
+    }
+  }
+#endif  
+}
+
+void DrmDevice::DisableHDCPSessionForAllDisplays() {
+  GetPipe().atomic_state_manager->SetHDCPState(HWCContentProtection::kDesired,
+                                               content_type);
+#if 0
+  size_t size = displays_.size();
+  for (size_t i = 0; i < size; i++) {
+    displays_.at(i)->SetHDCPState(HWCContentProtection::kUnDesired,
+                                  HWCContentType::kInvalid);
+  }
+#endif
+}
+#endif
 auto DrmDevice::IsKMSDev(const char *path) -> bool {
   auto fd = UniqueFd(open(path, O_RDWR | O_CLOEXEC));
   if (!fd) {

drm/DrmDevice.h

@@ -26,6 +26,7 @@
 #include "DrmEncoder.h"
 #include "DrmFbImporter.h"
 #include "utils/UniqueFd.h"
+#include "utils/hwcdefs.h"
 
 #define DRM_FORMAT_NV12_Y_TILED_INTEL fourcc_code('9', '9', '9', '6')
 namespace android {
@@ -104,7 +105,31 @@ class DrmDevice {
   void ResetModeId();
   int GetProperty(uint32_t obj_id, uint32_t obj_type, const char *prop_name,
                   DrmProperty *property) const;
-
+#if 0
+  // Enables the usage of HDCP for all planes supporting this feature
+  // on display. Some displays can support latest HDCP specification and also
+  // have ability to fallback to older specifications i.e. HDCP 2.2 and 1.4
+  // in case latest speicification cannot be supported for some reason.
+  // Content type is defined by content_type.
+  void EnableHDCPSessionForDisplay(uint32_t connector,
+                                   hwcomposer::HWCContentType content_type);
+
+  // Enables the usage of HDCP for all planes supporting this feature
+  // on all connected displays. Some displays can support latest HDCP
+  // specification and also have ability to fallback to older
+  // specifications i.e. HDCP 2.2 and 1.4 in case latest speicification
+  // cannot be supported for some reason. Content type is defined by
+  // content_type.
+  void EnableHDCPSessionForAllDisplays(hwcomposer::HWCContentType content_type);
+
+  // The control disables the usage of HDCP for all planes supporting this
+  // feature on display.
+  void DisableHDCPSessionForDisplay(uint32_t connector);
+
+  // The control disables the usage of HDCP for all planes supporting this
+  // feature on all connected displays.
+  void DisableHDCPSessionForAllDisplays();
+#endif
  private:
   explicit DrmDevice(ResourceManager *res_man);
   auto Init(const char *path) -> int;

drm/ResourceManager.cpp

@@ -22,6 +22,8 @@
 
 #include <ctime>
 #include <sstream>
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
 
 #include "bufferinfo/BufferInfoGetter.h"
 #include "drm/DrmAtomicStateManager.h"
@@ -150,10 +152,22 @@ void ResourceManager::Init() {
   });
 
   UpdateFrontendDisplays();
-
+  pt_ = std::thread(&ResourceManager::HwcServiceThread, this);
   initialized_ = true;
 }
 
+void ResourceManager::HwcServiceThread() {
+  this->hwcService_.Start((DrmHwcTwo*)frontend_interface_);
+  sp<ProcessState> proc(ProcessState::self());
+  if (!proc.get())
+  {
+      ALOGE("Error: Fail to new ProcessState.");
+      return ;
+  }
+  proc->startThreadPool();
+  IPCThreadState::self()->joinThreadPool();
+}
+
 void ResourceManager::DeInit() {
   if (!initialized_) {
     ALOGE("Not initialized");

drm/ResourceManager.h

@@ -23,7 +23,7 @@
 #include "DrmDisplayPipeline.h"
 #include "DrmFbImporter.h"
 #include "UEventListener.h"
-
+#include "hwc2_device/hwcservice.h"
 namespace android {
 class HwcDisplay;
 class PipelineToFrontendBindingInterface {
@@ -63,6 +63,7 @@ class ResourceManager {
   auto GetOrderedConnectors() -> std::vector<DrmConnector *>;
   void UpdateFrontendDisplays();
   void DetachAllFrontendDisplays();
+  void HwcServiceThread();
 
   std::vector<std::unique_ptr<DrmDevice>> drms_;
 
@@ -78,6 +79,8 @@ class ResourceManager {
   PipelineToFrontendBindingInterface *const frontend_interface_;
 
   bool initialized_{};
+  android::HwcService hwcService_;
+  std::thread pt_;
 };
 }  // namespace android