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