Ensure we have internal display first in list of connected displays.

We connect possible displays, than iterate through all of them to
populate connected displays. This was fine when pipe 0 was always
connected to internal/primary display. However on devices which
use pipe 1 as primary we ended up still using pipe 0. Now,
we populated connected displays list as we make the connection.

Jira: AIA-120
Test: Boots to Android Screenshot on BDW device. No regressions on
      Linux.

Signed-off-by: Kalyan Kondapally <kalyan.kondapally@intel.com>

diff --git a/common/core/gpudevice.cpp b/common/core/gpudevice.cpp
index 61b12fe..f67ca30 100644 (file)
--- a/common/core/gpudevice.cpp
+++ b/common/core/gpudevice.cpp
@@ -326,6 +326,8 @@ bool GpuDevice::DisplayManager::UpdateDisplayState() {
   for (auto &display : displays_) {
     display->DisConnect();
   }
+
+  std::vector<NativeDisplay *>().swap(connected_displays_);
   for (int32_t i = 0; i < res->count_connectors; ++i) {
     ScopedDrmConnectorPtr connector(
         drmModeGetConnector(fd_, res->connectors[i]));
@@ -361,45 +363,38 @@ bool GpuDevice::DisplayManager::UpdateDisplayState() {
         for (auto &display : displays_) {
           if (encoder->crtc_id == display->CrtcId() &&
               display->Connect(mode, connector.get())) {
+            connected_displays_.emplace_back(display.get());
             break;
           }
         }
       }
-    }
-
-    // Try to find an encoder for the connector.
-    for (int32_t i = 0; i < connector->count_encoders; ++i) {
-      ScopedDrmEncoderPtr encoder(
-          drmModeGetEncoder(fd_, connector->encoders[i]));
-      if (!encoder)
-        continue;
-
-      // Check for compatible CRTC
-      int crtc_bit = 1 << i;
-      if (!(encoder->possible_crtcs & crtc_bit))
-        continue;
-
-      for (auto &display : displays_) {
-        if (!display->IsConnected() && (1 << display->Pipe() & crtc_bit) &&
-            display->Connect(mode, connector.get())) {
-          break;
+    } else {
+      // Try to find an encoder for the connector.
+      for (int32_t j = 0; j < connector->count_encoders; ++j) {
+        ScopedDrmEncoderPtr encoder(
+            drmModeGetEncoder(fd_, connector->encoders[j]));
+        if (!encoder)
+          continue;
+        for (auto &display : displays_) {
+          if (!display->IsConnected() &&
+              (encoder->possible_crtcs & (1 << display->Pipe())) &&
+              display->Connect(mode, connector.get())) {
+            IHOTPLUGEVENTTRACE("connected pipe:%d \n", display->Pipe());
+            connected_displays_.emplace_back(display.get());
+            break;
+          }
         }
       }
     }
   }
 
-  bool headless_mode = true;
-  std::vector<NativeDisplay *>().swap(connected_displays_);
   for (auto &display : displays_) {
     if (!display->IsConnected()) {
       display->ShutDown();
-    } else {
-      connected_displays_.emplace_back(display.get());
-      headless_mode = false;
     }
   }
 
-  if (headless_mode) {
+  if (connected_displays_.empty()) {
     if (!headless_)
       headless_.reset(new Headless(fd_, *(buffer_handler_.get()), 0, 0));
   } else if (headless_) {

diff --git a/common/core/internaldisplay.cpp b/common/core/internaldisplay.cpp
index 5adac32..8273835 100644 (file)
--- a/common/core/internaldisplay.cpp
+++ b/common/core/internaldisplay.cpp
@@ -120,31 +120,10 @@ void InternalDisplay::ShutDown() {
   ScopedSpinLock lock(spin_lock_);
   IHOTPLUGEVENTTRACE("InternalDisplay::ShutDown recieved.");
   is_powered_off_ = true;
-  pending_operations_ |= kModeset;
-  dpms_mode_ = DRM_MODE_DPMS_OFF;
-  pending_operations_ |= PendingModeset::kDpms;
-  uint64_t fence = 0;
-  // Do the actual commit.
-  ScopedDrmAtomicReqPtr pset(drmModeAtomicAlloc());
+  drmModeConnectorSetProperty(gpu_fd_, connector_, dpms_prop_,
+                              DRM_MODE_DPMS_OFF);
 
-  // Create a Sync object for this Composition.
-  std::unique_ptr<NativeSync> sync_object(new NativeSync());
-  if (!sync_object->Init()) {
-    ETRACE("Failed to create sync object.");
-    return;
-  }
-
-  if (!ApplyPendingModeset(pset.get(), sync_object.get(), &fence)) {
-    ETRACE("Failed to Modeset");
-    return;
-  }
-
-  DisplayPlaneStateList current_composition_planes;
-  if (!display_plane_manager_->CommitFrame(current_composition_planes,
-                                           pset.get(), true, sync_object,
-                                           out_fence_)) {
-    ETRACE("Failed to shut down the display.");
-  }
+  display_plane_manager_->DisablePipe();
 
   display_plane_manager_.reset(nullptr);
 }

diff --git a/common/display/displayplanemanager.cpp b/common/display/displayplanemanager.cpp
index 9bff5a1..714164b 100644 (file)
--- a/common/display/displayplanemanager.cpp
+++ b/common/display/displayplanemanager.cpp
@@ -330,6 +330,33 @@ bool DisplayPlaneManager::CommitFrame(DisplayPlaneStateList &comp_planes,
   return true;
 }
 
+void DisplayPlaneManager::DisablePipe() {
+  CTRACE();
+  ScopedDrmAtomicReqPtr pset(drmModeAtomicAlloc());
+  if (!pset) {
+    ETRACE("Failed to allocate property set %d", -ENOMEM);
+    return;
+  }
+
+  // Disable planes.
+  for (auto i = cursor_planes_.begin(); i != cursor_planes_.end(); ++i) {
+    (*i)->Disable(pset.get());
+  }
+
+  for (auto i = overlay_planes_.begin(); i != overlay_planes_.end(); ++i) {
+    (*i)->Disable(pset.get());
+  }
+
+  for (auto i = primary_planes_.begin(); i != primary_planes_.end(); ++i) {
+    (*i)->Disable(pset.get());
+  }
+
+  int ret = drmModeAtomicCommit(gpu_fd_, pset.get(),
+                                DRM_MODE_ATOMIC_ALLOW_MODESET, NULL);
+  if (ret)
+    ETRACE("Failed to disable pipe:%s\n", PRINTERROR());
+}
+
 bool DisplayPlaneManager::TestCommit(
     const std::vector<OverlayPlane> &commit_planes) const {
   ScopedDrmAtomicReqPtr pset(drmModeAtomicAlloc());

diff --git a/common/display/displayplanemanager.h b/common/display/displayplanemanager.h
index aa0dc7e..1d9be88 100644 (file)
--- a/common/display/displayplanemanager.h
+++ b/common/display/displayplanemanager.h
@@ -53,10 +53,11 @@ class DisplayPlaneManager {
   std::tuple<bool, DisplayPlaneStateList> ValidateLayers(
       std::vector<OverlayLayer> &layers, bool pending_modeset);
 
-  virtual bool CommitFrame(DisplayPlaneStateList &planes,
-                           drmModeAtomicReqPtr property_set, bool needs_modeset,
-                           std::unique_ptr<NativeSync> &sync_object,
-                           ScopedFd &fence);
+  bool CommitFrame(DisplayPlaneStateList &planes,
+                   drmModeAtomicReqPtr property_set, bool needs_modeset,
+                   std::unique_ptr<NativeSync> &sync_object, ScopedFd &fence);
+
+  void DisablePipe();
 
   void EndFrameUpdate();
 

diff --git a/tests/apps/kmscube.cpp b/tests/apps/kmscube.cpp
index ed2cc36..c2c35fd 100644 (file)
--- a/tests/apps/kmscube.cpp
+++ b/tests/apps/kmscube.cpp
@@ -101,12 +101,16 @@ class HotPlugEventCallback : public hwcomposer::DisplayHotPlugEventCallback {
     connected_displays_.swap(connected_displays);
   }
 
-  const std::vector<hwcomposer::NativeDisplay *> &GetConnectedDisplays() {
+  void PresentLayers(std::vector<hwcomposer::HwcLayer *> &layers) {
     hwcomposer::ScopedSpinLock lock(spin_lock_);
     if (connected_displays_.empty())
       connected_displays_ = device_->GetConnectedPhysicalDisplays();
 
-    return connected_displays_;
+    if (connected_displays_.empty())
+      return;
+
+    for (auto &display : connected_displays_)
+      display->Present(layers);
   }
 
  private:
@@ -735,14 +739,7 @@ int main(int argc, char *argv[]) {
     frame->layer.acquire_fence = gpu_fence_fd;
     std::vector<hwcomposer::HwcLayer *>().swap(layers);
     layers.emplace_back(&frame->layer);
-
-    const std::vector<hwcomposer::NativeDisplay *> &displays =
-        callback->GetConnectedDisplays();
-    if (displays.empty())
-      return 0;
-
-    for (auto &display : displays)
-      display->Present(layers);
+    callback->PresentLayers(layers);
   }
 
   close(fd);

diff --git a/tests/third_party/json-c/autogen.sh b/tests/third_party/json-c/autogen.sh
old mode 100644 (file)
new mode 100755 (executable)