1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "ui/ozone/platform/dri/dri_util.h"
6
7#include <errno.h>
8#include <stdint.h>
9#include <stdlib.h>
10#include <sys/mman.h>
11#include <xf86drm.h>
12#include <xf86drmMode.h>
13
14namespace ui {
15
16namespace {
17
18bool IsCrtcInUse(uint32_t crtc,
19                 const ScopedVector<HardwareDisplayControllerInfo>& displays) {
20  for (size_t i = 0; i < displays.size(); ++i) {
21    if (crtc == displays[i]->crtc()->crtc_id)
22      return true;
23  }
24
25  return false;
26}
27
28uint32_t GetCrtc(int fd,
29                 drmModeConnector* connector,
30                 drmModeRes* resources,
31                 const ScopedVector<HardwareDisplayControllerInfo>& displays) {
32  // If the connector already has an encoder try to re-use.
33  if (connector->encoder_id) {
34    ScopedDrmEncoderPtr encoder(drmModeGetEncoder(fd, connector->encoder_id));
35    if (encoder && encoder->crtc_id && !IsCrtcInUse(encoder->crtc_id, displays))
36      return encoder->crtc_id;
37  }
38
39  // Try to find an encoder for the connector.
40  for (int i = 0; i < connector->count_encoders; ++i) {
41    ScopedDrmEncoderPtr encoder(drmModeGetEncoder(fd, connector->encoders[i]));
42    if (!encoder)
43      continue;
44
45    for (int j = 0; j < resources->count_crtcs; ++j) {
46      // Check if the encoder is compatible with this CRTC
47      if (!(encoder->possible_crtcs & (1 << j)) ||
48          IsCrtcInUse(resources->crtcs[j], displays))
49        continue;
50
51      return resources->crtcs[j];
52    }
53  }
54
55  return 0;
56}
57
58}  // namespace
59
60HardwareDisplayControllerInfo::HardwareDisplayControllerInfo(
61    ScopedDrmConnectorPtr connector,
62    ScopedDrmCrtcPtr crtc)
63    : connector_(connector.Pass()),
64      crtc_(crtc.Pass()) {}
65
66HardwareDisplayControllerInfo::~HardwareDisplayControllerInfo() {}
67
68ScopedVector<HardwareDisplayControllerInfo>
69GetAvailableDisplayControllerInfos(int fd) {
70  ScopedDrmResourcesPtr resources(drmModeGetResources(fd));
71  DCHECK(resources) << "Failed to get DRM resources";
72  ScopedVector<HardwareDisplayControllerInfo> displays;
73
74  for (int i = 0; i < resources->count_connectors; ++i) {
75    ScopedDrmConnectorPtr connector(drmModeGetConnector(
76        fd, resources->connectors[i]));
77
78    if (!connector || connector->connection != DRM_MODE_CONNECTED ||
79        connector->count_modes == 0)
80      continue;
81
82    uint32_t crtc_id = GetCrtc(fd, connector.get(), resources.get(), displays);
83    if (!crtc_id)
84      continue;
85
86    ScopedDrmCrtcPtr crtc(drmModeGetCrtc(fd, crtc_id));
87    displays.push_back(new HardwareDisplayControllerInfo(connector.Pass(),
88                                                         crtc.Pass()));
89  }
90
91  return displays.Pass();
92}
93
94bool SameMode(const drmModeModeInfo& lhs, const drmModeModeInfo& rhs) {
95  return lhs.clock == rhs.clock &&
96         lhs.hdisplay == rhs.hdisplay &&
97         lhs.vdisplay == rhs.vdisplay &&
98         lhs.vrefresh == rhs.vrefresh &&
99         lhs.hsync_start == rhs.hsync_start &&
100         lhs.hsync_end == rhs.hsync_end &&
101         lhs.htotal == rhs.htotal &&
102         lhs.hskew == rhs.hskew &&
103         lhs.vsync_start == rhs.vsync_start &&
104         lhs.vsync_end == rhs.vsync_end &&
105         lhs.vtotal == rhs.vtotal &&
106         lhs.vscan == rhs.vscan &&
107         lhs.flags == rhs.flags &&
108         strcmp(lhs.name, rhs.name) == 0;
109}
110
111bool MapDumbBuffer(int fd,
112                   uint32_t handle,
113                   uint32_t size,
114                   void** pixels) {
115  struct drm_mode_map_dumb map_request;
116  memset(&map_request, 0, sizeof(map_request));
117  map_request.handle = handle;
118  if (drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &map_request)) {
119    VLOG(2) << "Cannot prepare dumb buffer for mapping (" << errno << ") "
120            << strerror(errno);
121    return false;
122  }
123
124  *pixels = mmap(0,
125                 size,
126                 PROT_READ | PROT_WRITE,
127                 MAP_SHARED,
128                 fd,
129                 map_request.offset);
130  if (*pixels == MAP_FAILED) {
131    VLOG(2) << "Cannot mmap dumb buffer (" << errno << ") " << strerror(errno);
132    return false;
133  }
134
135  return true;
136}
137
138}  // namespace ui
139