exo: Use use-drm flag to pick a driver.

components/exo/wayland/clients/motion_events.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Implementation of a client that produces output in the form of RGBA
 // buffers when receiving pointer/touch events. RGB contains the lower
 // 24 bits of the event timestamp and A is 0xff.
 
 #include <fcntl.h>
 #include <linux-dmabuf-unstable-v1-client-protocol.h>
 #include <wayland-client-core.h>
 #include <wayland-client-protocol.h>
 
 #include <iostream>
+#include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/scoped_generic.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLAssembleInterface.h"
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_enums.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/init/gl_factory.h"
 #include "ui/gl/scoped_make_current.h"
 
 #if defined(OZONE_PLATFORM_GBM)
 #include <drm_fourcc.h>
 #include <gbm.h>
+#include <xf86drm.h>
 #endif
 
 // Convenient macro that is used to define default deleters for object
 // types allowing them to be used with std::unique_ptr.
 #define DEFAULT_DELETER(TypeName, DeleteFunction)           \
   namespace std {                                           \
   template <>                                               \
   struct default_delete<TypeName> {                         \
     void operator()(TypeName* ptr) { DeleteFunction(ptr); } \
   };                                                        \
@@ skipping 31 matching lines @@
 // Buffer format.
 const int32_t kShmFormat = WL_SHM_FORMAT_ARGB8888;
 const SkColorType kColorType = kBGRA_8888_SkColorType;
 #if defined(OZONE_PLATFORM_GBM)
 const GrPixelConfig kGrPixelConfig = kBGRA_8888_GrPixelConfig;
 const int32_t kDrmFormat = DRM_FORMAT_ABGR8888;
 #endif
 const size_t kBytesPerPixel = 4;
 
 #if defined(OZONE_PLATFORM_GBM)
-// DRI render node path.
-const char kDriRenderNode[] = "/dev/dri/renderD128";
+// DRI render node path template.
+const char kDriRenderNodeTemplate[] = "/dev/dri/renderD%u";
 #endif
 
 // Number of buffers.
 const size_t kBuffers = 3;
 
 // Rotation speed (degrees/second).
 const double kRotationSpeed = 360.0;
 
 // Benchmark interval in seconds.
 const int kBenchmarkInterval = 5;
@@ skipping 185 matching lines @@
 #endif
 
 }  // namespace
 
 class MotionEvents {
  public:
   MotionEvents(size_t width,
                size_t height,
                int scale,
                size_t num_rects,
-               bool use_drm,
+               const std::string* use_drm,
                bool fullscreen)
       : width_(width),
         height_(height),
         scale_(scale),
         num_rects_(num_rects),
         use_drm_(use_drm),
         fullscreen_(fullscreen) {}
 
   // Initialize and run client main loop.
   int Run();
 
  private:
   bool CreateBuffer(Buffer* buffer);
   size_t stride() const { return width_ * kBytesPerPixel; }
   size_t buffer_size() const { return stride() * height_; }
 
   const size_t width_;
   const size_t height_;
   const int scale_;
   const size_t num_rects_;
-  const bool use_drm_;
+  const std::string* use_drm_;
   const bool fullscreen_;
 
   Globals globals_;
   std::unique_ptr<wl_display> display_;
 
 #if defined(OZONE_PLATFORM_GBM)
   base::ScopedFD drm_fd_;
   std::unique_ptr<gbm_device> device_;
 #endif
 
@@ skipping 45 matching lines @@
   if (!globals_.shell) {
     LOG(ERROR) << "Can't find shell interface";
     return 1;
   }
   if (!globals_.seat) {
     LOG(ERROR) << "Can't find seat interface";
     return 1;
   }
 
 #if defined(OZONE_PLATFORM_GBM)
-  drm_fd_.reset(open(kDriRenderNode, O_RDWR));
-  if (drm_fd_.get() < 0) {
-    LOG(ERROR) << "Can't open drm device '" << kDriRenderNode << "'";
-    return 1;
+  if (use_drm_) {
+    // Number of files to look for when discovering DRM devices.
+    const uint32_t kDrmMaxMinor = 15;
+    const uint32_t kRenderNodeStart = 128;
+    const uint32_t kRenderNodeEnd = kRenderNodeStart + kDrmMaxMinor;
+
+    for (uint32_t i = kRenderNodeStart; i < kRenderNodeEnd; i++) {
+      std::string dri_render_node(
+          base::StringPrintf(kDriRenderNodeTemplate, i));
+      base::ScopedFD drm_fd(open(dri_render_node.c_str(), O_RDWR));
+      if (drm_fd.get() < 0)
+        continue;
+      drmVersionPtr drm_version = drmGetVersion(drm_fd.get());
+      if (!drm_version) {
+        LOG(ERROR) << "Can't get version for device: '" << dri_render_node
+                   << "'";
+        return 1;
+      }
+      if (strstr(drm_version->name, use_drm_->c_str())) {
+        drm_fd_ = std::move(drm_fd);
+        break;
+      }
+    }
+
+    if (drm_fd_.get() < 0) {
+      LOG_IF(ERROR, use_drm_) << "Can't find drm device: '" << *use_drm_ << "'";
+      LOG_IF(ERROR, !use_drm_) << "Can't find drm device";
+      return 1;
+    }
+
+    device_.reset(gbm_create_device(drm_fd_.get()));
+    if (!device_) {
+      LOG(ERROR) << "Can't create gbm device";
+      return 1;
+    }
   }
 
-  device_.reset(gbm_create_device(drm_fd_.get()));
-  if (!device_) {
-    LOG(ERROR) << "Can't create gbm device";
-    return 1;
-  }
   sk_sp<const GrGLInterface> native_interface(GrGLCreateNativeInterface());
   DCHECK(native_interface);
   gr_context_ = sk_sp<GrContext>(GrContext::Create(
       kOpenGL_GrBackend,
       reinterpret_cast<GrBackendContext>(native_interface.get())));
   DCHECK(gr_context_);
 #endif
 
   wl_buffer_listener buffer_listener = {BufferRelease};
 
@@ skipping 292 matching lines @@
   }
 
   size_t num_rects = 1;
   if (command_line->HasSwitch(switches::kNumRects) &&
       !base::StringToSizeT(
           command_line->GetSwitchValueASCII(switches::kNumRects), &num_rects)) {
     LOG(ERROR) << "Invalid value for " << switches::kNumRects;
     return 1;
   }
 
-  bool use_drm = command_line->HasSwitch(switches::kUseDrm);
+  std::unique_ptr<std::string> use_drm;
+  if (command_line->HasSwitch(switches::kUseDrm)) {
+    use_drm.reset(
+        new std::string(command_line->GetSwitchValueASCII(switches::kUseDrm)));
+  }
+
   bool fullscreen = command_line->HasSwitch(switches::kFullscreen);
 
   exo::wayland::clients::MotionEvents client(width, height, scale, num_rects,
-                                             use_drm, fullscreen);
+                                             use_drm.get(), fullscreen);
   return client.Run();
 }