1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "graphics_drm.h"
18
19 #include <fcntl.h>
20 #include <poll.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <sys/mman.h>
24 #include <sys/types.h>
25 #include <unistd.h>
26
27 #include <memory>
28
29 #include <android-base/macros.h>
30 #include <android-base/stringprintf.h>
31 #include <android-base/unique_fd.h>
32 #include <drm_fourcc.h>
33 #include <xf86drm.h>
34 #include <xf86drmMode.h>
35
36 #include "minui/minui.h"
37
~GRSurfaceDrm()38 GRSurfaceDrm::~GRSurfaceDrm() {
39 if (mmapped_buffer_) {
40 munmap(mmapped_buffer_, row_bytes * height);
41 }
42
43 if (fb_id) {
44 if (drmModeRmFB(drm_fd_, fb_id) != 0) {
45 perror("Failed to drmModeRmFB");
46 // Falling through to free other resources.
47 }
48 }
49
50 if (handle) {
51 drm_gem_close gem_close = {};
52 gem_close.handle = handle;
53
54 if (drmIoctl(drm_fd_, DRM_IOCTL_GEM_CLOSE, &gem_close) != 0) {
55 perror("Failed to DRM_IOCTL_GEM_CLOSE");
56 }
57 }
58 }
59
drm_format_to_bpp(uint32_t format)60 static int drm_format_to_bpp(uint32_t format) {
61 switch (format) {
62 case DRM_FORMAT_ABGR8888:
63 case DRM_FORMAT_BGRA8888:
64 case DRM_FORMAT_RGBX8888:
65 case DRM_FORMAT_BGRX8888:
66 case DRM_FORMAT_XBGR8888:
67 case DRM_FORMAT_XRGB8888:
68 return 32;
69 case DRM_FORMAT_RGB565:
70 return 16;
71 default:
72 printf("Unknown format %d\n", format);
73 return 32;
74 }
75 }
76
Create(int drm_fd,int width,int height)77 std::unique_ptr<GRSurfaceDrm> GRSurfaceDrm::Create(int drm_fd, int width, int height) {
78 uint32_t format;
79 PixelFormat pixel_format = gr_pixel_format();
80 // PixelFormat comes in byte order, whereas DRM_FORMAT_* uses little-endian
81 // (external/libdrm/include/drm/drm_fourcc.h). Note that although drm_fourcc.h also defines a
82 // macro of DRM_FORMAT_BIG_ENDIAN, it doesn't seem to be actually supported (see the discussion
83 // in https://lists.freedesktop.org/archives/amd-gfx/2017-May/008560.html).
84 if (pixel_format == PixelFormat::ABGR) {
85 format = DRM_FORMAT_RGBA8888;
86 } else if (pixel_format == PixelFormat::BGRA) {
87 format = DRM_FORMAT_ARGB8888;
88 } else if (pixel_format == PixelFormat::RGBX) {
89 format = DRM_FORMAT_XBGR8888;
90 } else {
91 format = DRM_FORMAT_RGB565;
92 }
93
94 drm_mode_create_dumb create_dumb = {};
95 create_dumb.height = height;
96 create_dumb.width = width;
97 create_dumb.bpp = drm_format_to_bpp(format);
98 create_dumb.flags = 0;
99
100 if (drmIoctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb) != 0) {
101 perror("Failed to DRM_IOCTL_MODE_CREATE_DUMB");
102 return nullptr;
103 }
104
105 // Cannot use std::make_unique to access non-public ctor.
106 auto surface = std::unique_ptr<GRSurfaceDrm>(new GRSurfaceDrm(
107 width, height, create_dumb.pitch, create_dumb.bpp / 8, drm_fd, create_dumb.handle));
108
109 uint32_t handles[4], pitches[4], offsets[4];
110
111 handles[0] = surface->handle;
112 pitches[0] = create_dumb.pitch;
113 offsets[0] = 0;
114 if (drmModeAddFB2(drm_fd, width, height, format, handles, pitches, offsets, &surface->fb_id, 0) !=
115 0) {
116 perror("Failed to drmModeAddFB2");
117 return nullptr;
118 }
119
120 drm_mode_map_dumb map_dumb = {};
121 map_dumb.handle = create_dumb.handle;
122 if (drmIoctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb) != 0) {
123 perror("Failed to DRM_IOCTL_MODE_MAP_DUMB");
124 return nullptr;
125 }
126
127 auto mmapped = mmap(nullptr, surface->height * surface->row_bytes, PROT_READ | PROT_WRITE,
128 MAP_SHARED, drm_fd, map_dumb.offset);
129 if (mmapped == MAP_FAILED) {
130 perror("Failed to mmap()");
131 return nullptr;
132 }
133 surface->mmapped_buffer_ = static_cast<uint8_t*>(mmapped);
134 return surface;
135 }
136
DrmDisableCrtc(int drm_fd,drmModeCrtc * crtc)137 void MinuiBackendDrm::DrmDisableCrtc(int drm_fd, drmModeCrtc* crtc) {
138 if (crtc) {
139 drmModeSetCrtc(drm_fd, crtc->crtc_id,
140 0, // fb_id
141 0, 0, // x,y
142 nullptr, // connectors
143 0, // connector_count
144 nullptr); // mode
145 }
146 }
147
DrmEnableCrtc(int drm_fd,drmModeCrtc * crtc,const std::unique_ptr<GRSurfaceDrm> & surface)148 bool MinuiBackendDrm::DrmEnableCrtc(int drm_fd, drmModeCrtc* crtc,
149 const std::unique_ptr<GRSurfaceDrm>& surface) {
150 if (drmModeSetCrtc(drm_fd, crtc->crtc_id, surface->fb_id, 0, 0, // x,y
151 &main_monitor_connector->connector_id,
152 1, // connector_count
153 &main_monitor_crtc->mode) != 0) {
154 perror("Failed to drmModeSetCrtc");
155 return false;
156 }
157 return true;
158 }
159
Blank(bool blank)160 void MinuiBackendDrm::Blank(bool blank) {
161 if (blank) {
162 DrmDisableCrtc(drm_fd, main_monitor_crtc);
163 } else {
164 DrmEnableCrtc(drm_fd, main_monitor_crtc, GRSurfaceDrms[current_buffer]);
165 }
166 }
167
find_crtc_for_connector(int fd,drmModeRes * resources,drmModeConnector * connector)168 static drmModeCrtc* find_crtc_for_connector(int fd, drmModeRes* resources,
169 drmModeConnector* connector) {
170 // Find the encoder. If we already have one, just use it.
171 drmModeEncoder* encoder;
172 if (connector->encoder_id) {
173 encoder = drmModeGetEncoder(fd, connector->encoder_id);
174 } else {
175 encoder = nullptr;
176 }
177
178 int32_t crtc;
179 if (encoder && encoder->crtc_id) {
180 crtc = encoder->crtc_id;
181 drmModeFreeEncoder(encoder);
182 return drmModeGetCrtc(fd, crtc);
183 }
184
185 // Didn't find anything, try to find a crtc and encoder combo.
186 crtc = -1;
187 for (int i = 0; i < connector->count_encoders; i++) {
188 encoder = drmModeGetEncoder(fd, connector->encoders[i]);
189
190 if (encoder) {
191 for (int j = 0; j < resources->count_crtcs; j++) {
192 if (!(encoder->possible_crtcs & (1 << j))) continue;
193 crtc = resources->crtcs[j];
194 break;
195 }
196 if (crtc >= 0) {
197 drmModeFreeEncoder(encoder);
198 return drmModeGetCrtc(fd, crtc);
199 }
200 }
201 }
202
203 return nullptr;
204 }
205
find_used_connector_by_type(int fd,drmModeRes * resources,unsigned type)206 static drmModeConnector* find_used_connector_by_type(int fd, drmModeRes* resources, unsigned type) {
207 for (int i = 0; i < resources->count_connectors; i++) {
208 drmModeConnector* connector = drmModeGetConnector(fd, resources->connectors[i]);
209 if (connector) {
210 if ((connector->connector_type == type) && (connector->connection == DRM_MODE_CONNECTED) &&
211 (connector->count_modes > 0)) {
212 return connector;
213 }
214 drmModeFreeConnector(connector);
215 }
216 }
217 return nullptr;
218 }
219
find_first_connected_connector(int fd,drmModeRes * resources)220 static drmModeConnector* find_first_connected_connector(int fd, drmModeRes* resources) {
221 for (int i = 0; i < resources->count_connectors; i++) {
222 drmModeConnector* connector;
223
224 connector = drmModeGetConnector(fd, resources->connectors[i]);
225 if (connector) {
226 if ((connector->count_modes > 0) && (connector->connection == DRM_MODE_CONNECTED))
227 return connector;
228
229 drmModeFreeConnector(connector);
230 }
231 }
232 return nullptr;
233 }
234
FindMainMonitor(int fd,drmModeRes * resources,uint32_t * mode_index)235 drmModeConnector* MinuiBackendDrm::FindMainMonitor(int fd, drmModeRes* resources,
236 uint32_t* mode_index) {
237 /* Look for LVDS/eDP/DSI connectors. Those are the main screens. */
238 static constexpr unsigned kConnectorPriority[] = {
239 DRM_MODE_CONNECTOR_LVDS,
240 DRM_MODE_CONNECTOR_eDP,
241 DRM_MODE_CONNECTOR_DSI,
242 };
243
244 drmModeConnector* main_monitor_connector = nullptr;
245 unsigned i = 0;
246 do {
247 main_monitor_connector = find_used_connector_by_type(fd, resources, kConnectorPriority[i]);
248 i++;
249 } while (!main_monitor_connector && i < arraysize(kConnectorPriority));
250
251 /* If we didn't find a connector, grab the first one that is connected. */
252 if (!main_monitor_connector) {
253 main_monitor_connector = find_first_connected_connector(fd, resources);
254 }
255
256 /* If we still didn't find a connector, give up and return. */
257 if (!main_monitor_connector) return nullptr;
258
259 *mode_index = 0;
260 for (int modes = 0; modes < main_monitor_connector->count_modes; modes++) {
261 if (main_monitor_connector->modes[modes].type & DRM_MODE_TYPE_PREFERRED) {
262 *mode_index = modes;
263 break;
264 }
265 }
266
267 return main_monitor_connector;
268 }
269
DisableNonMainCrtcs(int fd,drmModeRes * resources,drmModeCrtc * main_crtc)270 void MinuiBackendDrm::DisableNonMainCrtcs(int fd, drmModeRes* resources, drmModeCrtc* main_crtc) {
271 for (int i = 0; i < resources->count_connectors; i++) {
272 drmModeConnector* connector = drmModeGetConnector(fd, resources->connectors[i]);
273 drmModeCrtc* crtc = find_crtc_for_connector(fd, resources, connector);
274 if (crtc->crtc_id != main_crtc->crtc_id) {
275 DrmDisableCrtc(fd, crtc);
276 }
277 drmModeFreeCrtc(crtc);
278 }
279 }
280
Init()281 GRSurface* MinuiBackendDrm::Init() {
282 drmModeRes* res = nullptr;
283 drm_fd = -1;
284
285 /* Consider DRM devices in order. */
286 for (int i = 0; i < DRM_MAX_MINOR; i++) {
287 auto dev_name = android::base::StringPrintf(DRM_DEV_NAME, DRM_DIR_NAME, i);
288 android::base::unique_fd fd(open(dev_name.c_str(), O_RDWR | O_CLOEXEC));
289 if (fd == -1) continue;
290
291 /* We need dumb buffers. */
292 if (uint64_t cap = 0; drmGetCap(fd.get(), DRM_CAP_DUMB_BUFFER, &cap) != 0 || cap == 0) {
293 continue;
294 }
295
296 res = drmModeGetResources(fd.get());
297 if (!res) {
298 continue;
299 }
300
301 /* Use this device if it has at least one connected monitor. */
302 if (res->count_crtcs > 0 && res->count_connectors > 0) {
303 if (find_first_connected_connector(fd.get(), res)) {
304 drm_fd = fd.release();
305 break;
306 }
307 }
308
309 drmModeFreeResources(res);
310 res = nullptr;
311 }
312
313 if (drm_fd == -1 || res == nullptr) {
314 perror("Failed to find/open a drm device");
315 return nullptr;
316 }
317
318 uint32_t selected_mode;
319 main_monitor_connector = FindMainMonitor(drm_fd, res, &selected_mode);
320 if (!main_monitor_connector) {
321 fprintf(stderr, "Failed to find main_monitor_connector\n");
322 drmModeFreeResources(res);
323 close(drm_fd);
324 return nullptr;
325 }
326
327 main_monitor_crtc = find_crtc_for_connector(drm_fd, res, main_monitor_connector);
328 if (!main_monitor_crtc) {
329 fprintf(stderr, "Failed to find main_monitor_crtc\n");
330 drmModeFreeResources(res);
331 close(drm_fd);
332 return nullptr;
333 }
334
335 DisableNonMainCrtcs(drm_fd, res, main_monitor_crtc);
336
337 main_monitor_crtc->mode = main_monitor_connector->modes[selected_mode];
338
339 int width = main_monitor_crtc->mode.hdisplay;
340 int height = main_monitor_crtc->mode.vdisplay;
341
342 drmModeFreeResources(res);
343
344 GRSurfaceDrms[0] = GRSurfaceDrm::Create(drm_fd, width, height);
345 GRSurfaceDrms[1] = GRSurfaceDrm::Create(drm_fd, width, height);
346 if (!GRSurfaceDrms[0] || !GRSurfaceDrms[1]) {
347 return nullptr;
348 }
349
350 current_buffer = 0;
351
352 // We will likely encounter errors in the backend functions (i.e. Flip) if EnableCrtc fails.
353 if (!DrmEnableCrtc(drm_fd, main_monitor_crtc, GRSurfaceDrms[1])) {
354 return nullptr;
355 }
356
357 return GRSurfaceDrms[0].get();
358 }
359
page_flip_complete(__unused int fd,__unused unsigned int sequence,__unused unsigned int tv_sec,__unused unsigned int tv_usec,void * user_data)360 static void page_flip_complete(__unused int fd,
361 __unused unsigned int sequence,
362 __unused unsigned int tv_sec,
363 __unused unsigned int tv_usec,
364 void *user_data) {
365 *static_cast<bool*>(user_data) = false;
366 }
367
Flip()368 GRSurface* MinuiBackendDrm::Flip() {
369 bool ongoing_flip = true;
370 if (drmModePageFlip(drm_fd, main_monitor_crtc->crtc_id, GRSurfaceDrms[current_buffer]->fb_id,
371 DRM_MODE_PAGE_FLIP_EVENT, &ongoing_flip) != 0) {
372 perror("Failed to drmModePageFlip");
373 return nullptr;
374 }
375
376 while (ongoing_flip) {
377 struct pollfd fds = {
378 .fd = drm_fd,
379 .events = POLLIN
380 };
381
382 if (poll(&fds, 1, -1) == -1 || !(fds.revents & POLLIN)) {
383 perror("Failed to poll() on drm fd");
384 break;
385 }
386
387 drmEventContext evctx = {
388 .version = DRM_EVENT_CONTEXT_VERSION,
389 .page_flip_handler = page_flip_complete
390 };
391
392 if (drmHandleEvent(drm_fd, &evctx) != 0) {
393 perror("Failed to drmHandleEvent");
394 break;
395 }
396 }
397
398 current_buffer = 1 - current_buffer;
399 return GRSurfaceDrms[current_buffer].get();
400 }
401
~MinuiBackendDrm()402 MinuiBackendDrm::~MinuiBackendDrm() {
403 DrmDisableCrtc(drm_fd, main_monitor_crtc);
404 drmModeFreeCrtc(main_monitor_crtc);
405 drmModeFreeConnector(main_monitor_connector);
406 close(drm_fd);
407 drm_fd = -1;
408 }
409