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 #define _GNU_SOURCE //enable GUN extension for asprintf
18 #include <drm_fourcc.h>
19 #include <fcntl.h>
20 #include <stdbool.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/cdefs.h>
25 #include <sys/ioctl.h>
26 #include <sys/mman.h>
27 #include <sys/types.h>
28 #include <unistd.h>
29 #include <xf86drm.h>
30 #include <xf86drmMode.h>
31
32 #include "minui.h"
33 #include "graphics.h"
34
35 #define ARRAY_SIZE(A) (sizeof(A)/sizeof(*(A)))
36
37 struct drm_surface {
38 GRSurface base;
39 uint32_t fb_id;
40 uint32_t handle;
41 };
42
43 static struct drm_surface *drm_surfaces[2];
44 static int current_buffer;
45
46 static drmModeCrtc *main_monitor_crtc;
47 static drmModeConnector *main_monitor_connector;
48
49 static int drm_fd = -1;
50
drm_disable_crtc(int drm_fd,drmModeCrtc * crtc)51 static void drm_disable_crtc(int drm_fd, drmModeCrtc *crtc)
52 {
53 if (crtc) {
54 drmModeSetCrtc(drm_fd, crtc->crtc_id,
55 0, // fb_id
56 0, 0, // x,y
57 NULL, // connectors
58 0, // connector_count
59 NULL); // mode
60 }
61 }
62
drm_enable_crtc(int drm_fd,drmModeCrtc * crtc,struct drm_surface * surface)63 static void drm_enable_crtc(int drm_fd, drmModeCrtc *crtc,
64 struct drm_surface *surface)
65 {
66 int32_t ret;
67
68 ret = drmModeSetCrtc(drm_fd, crtc->crtc_id,
69 surface->fb_id,
70 0, 0, // x,y
71 &main_monitor_connector->connector_id,
72 1, // connector_count
73 &main_monitor_crtc->mode);
74
75 if (ret)
76 printf("drmModeSetCrtc failed ret=%d\n", ret);
77 }
78
drm_blank(minui_backend * backend,bool blank)79 static void drm_blank(minui_backend* backend, bool blank)
80 {
81 if (blank)
82 drm_disable_crtc(drm_fd, main_monitor_crtc);
83 else
84 drm_enable_crtc(drm_fd, main_monitor_crtc,
85 drm_surfaces[current_buffer]);
86 }
87
drm_destroy_surface(struct drm_surface * surface)88 static void drm_destroy_surface(struct drm_surface *surface)
89 {
90 struct drm_gem_close gem_close;
91 int ret;
92
93 if (!surface)
94 return;
95
96 if (surface->base.data)
97 munmap(surface->base.data,
98 surface->base.row_bytes * surface->base.height);
99
100 if (surface->fb_id) {
101 ret = drmModeRmFB(drm_fd, surface->fb_id);
102 if (ret)
103 printf("drmModeRmFB failed ret=%d\n", ret);
104 }
105
106 if (surface->handle) {
107 memset(&gem_close, 0, sizeof(gem_close));
108 gem_close.handle = surface->handle;
109
110 ret = drmIoctl(drm_fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
111 if (ret)
112 printf("DRM_IOCTL_GEM_CLOSE failed ret=%d\n", ret);
113 }
114
115 free(surface);
116 }
117
drm_format_to_bpp(uint32_t format)118 static int drm_format_to_bpp(uint32_t format)
119 {
120 switch (format) {
121 case DRM_FORMAT_ABGR8888:
122 case DRM_FORMAT_BGRA8888:
123 case DRM_FORMAT_RGBX8888:
124 case DRM_FORMAT_BGRX8888:
125 case DRM_FORMAT_XBGR8888:
126 case DRM_FORMAT_XRGB8888:
127 return 32;
128 case DRM_FORMAT_RGB565:
129 return 16;
130 default:
131 printf("Unknown format %d\n", format);
132 return 32;
133 }
134 }
135
drm_create_surface(int width,int height)136 static struct drm_surface *drm_create_surface(int width, int height)
137 {
138 struct drm_surface *surface;
139 struct drm_mode_create_dumb create_dumb;
140 uint32_t format;
141 int ret;
142
143 surface = (struct drm_surface*)calloc(1, sizeof(*surface));
144 if (!surface) {
145 printf("Can't allocate memory\n");
146 return NULL;
147 }
148 #define RECOVERY_RGBX
149 #if defined(RECOVERY_ABGR)
150 format = DRM_FORMAT_RGBA8888;
151 #elif defined(RECOVERY_BGRA)
152 format = DRM_FORMAT_ARGB8888;
153 #elif defined(RECOVERY_RGBX)
154 format = DRM_FORMAT_XBGR8888;
155 #else
156 format = DRM_FORMAT_RGB565;
157 #endif
158
159 memset(&create_dumb, 0, sizeof(create_dumb));
160 create_dumb.height = height;
161 create_dumb.width = width;
162 create_dumb.bpp = drm_format_to_bpp(format);
163 create_dumb.flags = 0;
164
165 ret = drmIoctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
166 if (ret) {
167 printf("DRM_IOCTL_MODE_CREATE_DUMB failed ret=%d\n", ret);
168 drm_destroy_surface(surface);
169 return NULL;
170 }
171 surface->handle = create_dumb.handle;
172
173 uint32_t handles[4], pitches[4], offsets[4];
174
175 handles[0] = surface->handle;
176 pitches[0] = create_dumb.pitch;
177 offsets[0] = 0;
178
179 ret = drmModeAddFB2(drm_fd, width, height,
180 format, handles, pitches, offsets,
181 &(surface->fb_id), 0);
182 if (ret) {
183 printf("drmModeAddFB2 failed ret=%d\n", ret);
184 drm_destroy_surface(surface);
185 return NULL;
186 }
187
188 struct drm_mode_map_dumb map_dumb;
189 memset(&map_dumb, 0, sizeof(map_dumb));
190 map_dumb.handle = create_dumb.handle;
191 ret = drmIoctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb);
192 if (ret) {
193 printf("DRM_IOCTL_MODE_MAP_DUMB failed ret=%d\n", ret);
194 drm_destroy_surface(surface);
195 return NULL;;
196 }
197
198 surface->base.height = height;
199 surface->base.width = width;
200 surface->base.row_bytes = create_dumb.pitch;
201 surface->base.pixel_bytes = create_dumb.bpp / 8;
202 surface->base.data = (unsigned char*)
203 mmap(NULL,
204 surface->base.height * surface->base.row_bytes,
205 PROT_READ | PROT_WRITE, MAP_SHARED,
206 drm_fd, map_dumb.offset);
207 if (surface->base.data == MAP_FAILED) {
208 perror("mmap() failed");
209 drm_destroy_surface(surface);
210 return NULL;
211 }
212
213 return surface;
214 }
215
find_crtc_for_connector(int fd,drmModeRes * resources,drmModeConnector * connector)216 static drmModeCrtc *find_crtc_for_connector(int fd,
217 drmModeRes *resources,
218 drmModeConnector *connector)
219 {
220 int i, j;
221 drmModeEncoder *encoder;
222 int32_t crtc;
223
224 /*
225 * Find the encoder. If we already have one, just use it.
226 */
227 if (connector->encoder_id)
228 encoder = drmModeGetEncoder(fd, connector->encoder_id);
229 else
230 encoder = NULL;
231
232 if (encoder && encoder->crtc_id) {
233 crtc = encoder->crtc_id;
234 drmModeFreeEncoder(encoder);
235 return drmModeGetCrtc(fd, crtc);
236 }
237
238 /*
239 * Didn't find anything, try to find a crtc and encoder combo.
240 */
241 crtc = -1;
242 for (i = 0; i < connector->count_encoders; i++) {
243 encoder = drmModeGetEncoder(fd, connector->encoders[i]);
244
245 if (encoder) {
246 for (j = 0; j < resources->count_crtcs; j++) {
247 if (!(encoder->possible_crtcs & (1 << j)))
248 continue;
249 crtc = resources->crtcs[j];
250 break;
251 }
252 if (crtc >= 0) {
253 drmModeFreeEncoder(encoder);
254 return drmModeGetCrtc(fd, crtc);
255 }
256 }
257 }
258
259 return NULL;
260 }
261
find_used_connector_by_type(int fd,drmModeRes * resources,unsigned type)262 static drmModeConnector *find_used_connector_by_type(int fd,
263 drmModeRes *resources,
264 unsigned type)
265 {
266 int i;
267 for (i = 0; i < resources->count_connectors; i++) {
268 drmModeConnector *connector;
269
270 connector = drmModeGetConnector(fd, resources->connectors[i]);
271 if (connector) {
272 if ((connector->connector_type == type) &&
273 (connector->connection == DRM_MODE_CONNECTED) &&
274 (connector->count_modes > 0))
275 return connector;
276
277 drmModeFreeConnector(connector);
278 }
279 }
280 return NULL;
281 }
282
find_first_connected_connector(int fd,drmModeRes * resources)283 static drmModeConnector *find_first_connected_connector(int fd,
284 drmModeRes *resources)
285 {
286 int i;
287 for (i = 0; i < resources->count_connectors; i++) {
288 drmModeConnector *connector;
289
290 connector = drmModeGetConnector(fd, resources->connectors[i]);
291 if (connector) {
292 if ((connector->count_modes > 0) &&
293 (connector->connection == DRM_MODE_CONNECTED))
294 return connector;
295
296 drmModeFreeConnector(connector);
297 }
298 }
299 return NULL;
300 }
301
find_main_monitor(int fd,drmModeRes * resources,uint32_t * mode_index)302 static drmModeConnector *find_main_monitor(int fd, drmModeRes *resources,
303 uint32_t *mode_index)
304 {
305 unsigned i = 0;
306 int modes;
307 /* Look for LVDS/eDP/DSI connectors. Those are the main screens. */
308 unsigned kConnectorPriority[] = {
309 DRM_MODE_CONNECTOR_LVDS,
310 DRM_MODE_CONNECTOR_eDP,
311 DRM_MODE_CONNECTOR_DSI,
312 };
313
314 drmModeConnector *main_monitor_connector = NULL;
315 do {
316 main_monitor_connector = find_used_connector_by_type(fd,
317 resources,
318 kConnectorPriority[i]);
319 i++;
320 } while (!main_monitor_connector && i < ARRAY_SIZE(kConnectorPriority));
321
322 /* If we didn't find a connector, grab the first one that is connected. */
323 if (!main_monitor_connector)
324 main_monitor_connector =
325 find_first_connected_connector(fd, resources);
326
327 /* If we still didn't find a connector, give up and return. */
328 if (!main_monitor_connector)
329 return NULL;
330
331 *mode_index = 0;
332 for (modes = 0; modes < main_monitor_connector->count_modes; modes++) {
333 if (main_monitor_connector->modes[modes].type &
334 DRM_MODE_TYPE_PREFERRED) {
335 *mode_index = modes;
336 break;
337 }
338 }
339
340 return main_monitor_connector;
341 }
342
disable_non_main_crtcs(int fd,drmModeRes * resources,drmModeCrtc * main_crtc)343 static void disable_non_main_crtcs(int fd,
344 drmModeRes *resources,
345 drmModeCrtc* main_crtc)
346 {
347 int i;
348 drmModeCrtc* crtc;
349
350 for (i = 0; i < resources->count_connectors; i++) {
351 drmModeConnector *connector;
352
353 connector = drmModeGetConnector(fd, resources->connectors[i]);
354 crtc = find_crtc_for_connector(fd, resources, connector);
355 if (crtc->crtc_id != main_crtc->crtc_id)
356 drm_disable_crtc(fd, crtc);
357 drmModeFreeCrtc(crtc);
358 }
359 }
360
drm_init(minui_backend * backend)361 static GRSurface* drm_init(minui_backend* backend)
362 {
363 drmModeRes *res = NULL;
364 uint32_t selected_mode;
365 char *dev_name;
366 int width, height;
367 int ret, i;
368
369 /* Consider DRM devices in order. */
370 for (i = 0; i < DRM_MAX_MINOR; i++) {
371 uint64_t cap = 0;
372
373 ret = asprintf(&dev_name, DRM_DEV_NAME, DRM_DIR_NAME, i);
374 if (ret < 0)
375 continue;
376
377 drm_fd = open(dev_name, O_RDWR, 0);
378 free(dev_name);
379 if (drm_fd < 0)
380 continue;
381
382 /* We need dumb buffers. */
383 ret = drmGetCap(drm_fd, DRM_CAP_DUMB_BUFFER, &cap);
384 if (ret || cap == 0) {
385 close(drm_fd);
386 continue;
387 }
388
389 res = drmModeGetResources(drm_fd);
390 if (!res) {
391 close(drm_fd);
392 continue;
393 }
394
395 /* Use this device if it has at least one connected monitor. */
396 if (res->count_crtcs > 0 && res->count_connectors > 0)
397 if (find_first_connected_connector(drm_fd, res))
398 break;
399
400 drmModeFreeResources(res);
401 close(drm_fd);
402 res = NULL;
403 }
404
405 if (drm_fd < 0 || res == NULL) {
406 perror("cannot find/open a drm device");
407 return NULL;
408 }
409
410 main_monitor_connector = find_main_monitor(drm_fd,
411 res, &selected_mode);
412
413 if (!main_monitor_connector) {
414 printf("main_monitor_connector not found\n");
415 drmModeFreeResources(res);
416 close(drm_fd);
417 return NULL;
418 }
419
420 main_monitor_crtc = find_crtc_for_connector(drm_fd, res,
421 main_monitor_connector);
422
423 if (!main_monitor_crtc) {
424 printf("main_monitor_crtc not found\n");
425 drmModeFreeResources(res);
426 close(drm_fd);
427 return NULL;
428 }
429
430 disable_non_main_crtcs(drm_fd,
431 res, main_monitor_crtc);
432
433 main_monitor_crtc->mode = main_monitor_connector->modes[selected_mode];
434
435 width = main_monitor_crtc->mode.hdisplay;
436 height = main_monitor_crtc->mode.vdisplay;
437
438 drmModeFreeResources(res);
439
440 drm_surfaces[0] = drm_create_surface(width, height);
441 drm_surfaces[1] = drm_create_surface(width, height);
442 if (!drm_surfaces[0] || !drm_surfaces[1]) {
443 drm_destroy_surface(drm_surfaces[0]);
444 drm_destroy_surface(drm_surfaces[1]);
445 drmModeFreeResources(res);
446 close(drm_fd);
447 return NULL;
448 }
449
450 current_buffer = 0;
451
452 drm_enable_crtc(drm_fd, main_monitor_crtc, drm_surfaces[1]);
453
454 return &(drm_surfaces[0]->base);
455 }
456
drm_flip(minui_backend * backend)457 static GRSurface* drm_flip(minui_backend* backend)
458 {
459 int ret;
460
461 ret = drmModePageFlip(drm_fd, main_monitor_crtc->crtc_id,
462 drm_surfaces[current_buffer]->fb_id, 0, NULL);
463 if (ret < 0) {
464 printf("drmModePageFlip failed ret=%d\n", ret);
465 return NULL;
466 }
467 current_buffer = 1 - current_buffer;
468 return &(drm_surfaces[current_buffer]->base);
469 }
470
drm_exit(minui_backend * backend)471 static void drm_exit(minui_backend* backend)
472 {
473 drm_disable_crtc(drm_fd, main_monitor_crtc);
474 drm_destroy_surface(drm_surfaces[0]);
475 drm_destroy_surface(drm_surfaces[1]);
476 drmModeFreeCrtc(main_monitor_crtc);
477 drmModeFreeConnector(main_monitor_connector);
478 close(drm_fd);
479 drm_fd = -1;
480 }
481
482 static minui_backend drm_backend = {
483 .init = drm_init,
484 .flip = drm_flip,
485 .blank = drm_blank,
486 .exit = drm_exit,
487 };
488
open_drm()489 minui_backend* open_drm()
490 {
491 return &drm_backend;
492 }
493