blob: 2b3887b39ca62e2566d86994e326045862ff10fa [file] [log] [blame]
Jesse Barnes731cd552008-12-17 10:09:49 -08001/*
2 * \file xf86drmMode.c
3 * Header for DRM modesetting interface.
4 *
5 * \author Jakob Bornecrantz <wallbraker@gmail.com>
6 *
7 * \par Acknowledgements:
8 * Feb 2007, Dave Airlie <airlied@linux.ie>
9 */
10
11/*
12 * Copyright (c) 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
13 * Copyright (c) 2007-2008 Dave Airlie <airlied@linux.ie>
14 * Copyright (c) 2007-2008 Jakob Bornecrantz <wallbraker@gmail.com>
15 *
16 * Permission is hereby granted, free of charge, to any person obtaining a
17 * copy of this software and associated documentation files (the "Software"),
18 * to deal in the Software without restriction, including without limitation
19 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
20 * and/or sell copies of the Software, and to permit persons to whom the
21 * Software is furnished to do so, subject to the following conditions:
22 *
23 * The above copyright notice and this permission notice shall be included in
24 * all copies or substantial portions of the Software.
25 *
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
31 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
32 * IN THE SOFTWARE.
33 *
34 */
35
36/*
Eric Engestromce975072016-04-03 19:48:12 +010037 * TODO the types we are after are defined in different headers on different
Jesse Barnes731cd552008-12-17 10:09:49 -080038 * platforms find which headers to include to get uint32_t
39 */
Emil Velikov5f762732015-06-29 17:32:21 +010040
41#ifdef HAVE_CONFIG_H
42#include "config.h"
43#endif
44
Ville Syrjäläed44e0b2015-06-22 17:26:02 +010045#include <limits.h>
Jesse Barnes731cd552008-12-17 10:09:49 -080046#include <stdint.h>
Ville Syrjäläed44e0b2015-06-22 17:26:02 +010047#include <stdlib.h>
Jesse Barnes731cd552008-12-17 10:09:49 -080048#include <sys/ioctl.h>
Julien Cristaufc8c3e22015-07-06 12:45:31 +010049#ifdef HAVE_SYS_SYSCTL_H
50#include <sys/sysctl.h>
51#endif
Jesse Barnes731cd552008-12-17 10:09:49 -080052#include <stdio.h>
Ville Syrjäläed44e0b2015-06-22 17:26:02 +010053#include <stdbool.h>
Jesse Barnes731cd552008-12-17 10:09:49 -080054
55#include "xf86drmMode.h"
56#include "xf86drm.h"
57#include <drm.h>
58#include <string.h>
59#include <dirent.h>
Kristian Høgsbergb0b96632009-09-11 13:27:35 -040060#include <unistd.h>
Jesse Barnes731cd552008-12-17 10:09:49 -080061#include <errno.h>
62
Daniel Vetter7e0460c2015-02-11 12:03:12 +010063#define memclear(s) memset(&s, 0, sizeof(s))
Eric Anholt734de702013-12-28 22:06:51 -080064
Jesse Barnes731cd552008-12-17 10:09:49 -080065#define U642VOID(x) ((void *)(unsigned long)(x))
66#define VOID2U64(x) ((uint64_t)(unsigned long)(x))
67
Marcin Slusarz763b6182011-06-05 18:53:16 +020068static inline int DRM_IOCTL(int fd, unsigned long cmd, void *arg)
Chris Wilsonb8039182010-07-01 22:38:54 +010069{
70 int ret = drmIoctl(fd, cmd, arg);
71 return ret < 0 ? -errno : ret;
72}
73
Jesse Barnes731cd552008-12-17 10:09:49 -080074/*
75 * Util functions
76 */
77
Jan Vesely65041c42015-02-27 11:51:05 -050078static void* drmAllocCpy(char *array, int count, int entry_size)
Jesse Barnes731cd552008-12-17 10:09:49 -080079{
80 char *r;
81 int i;
82
83 if (!count || !array || !entry_size)
84 return 0;
85
86 if (!(r = drmMalloc(count*entry_size)))
87 return 0;
88
89 for (i = 0; i < count; i++)
90 memcpy(r+(entry_size*i), array+(entry_size*i), entry_size);
91
92 return r;
93}
94
95/*
96 * A couple of free functions.
97 */
98
Jakob Bornecrantzeb78c532009-02-11 16:43:20 +010099void drmModeFreeModeInfo(drmModeModeInfoPtr ptr)
Jesse Barnes731cd552008-12-17 10:09:49 -0800100{
101 if (!ptr)
102 return;
103
104 drmFree(ptr);
105}
106
107void drmModeFreeResources(drmModeResPtr ptr)
108{
109 if (!ptr)
110 return;
111
Ville Syrjälädf497e92012-02-02 14:53:39 -0500112 drmFree(ptr->fbs);
113 drmFree(ptr->crtcs);
114 drmFree(ptr->connectors);
115 drmFree(ptr->encoders);
Jesse Barnes731cd552008-12-17 10:09:49 -0800116 drmFree(ptr);
Jesse Barnes731cd552008-12-17 10:09:49 -0800117}
118
119void drmModeFreeFB(drmModeFBPtr ptr)
120{
121 if (!ptr)
122 return;
123
124 /* we might add more frees later. */
125 drmFree(ptr);
126}
127
128void drmModeFreeCrtc(drmModeCrtcPtr ptr)
129{
130 if (!ptr)
131 return;
132
133 drmFree(ptr);
Jesse Barnes731cd552008-12-17 10:09:49 -0800134}
135
136void drmModeFreeConnector(drmModeConnectorPtr ptr)
137{
138 if (!ptr)
139 return;
140
Keith Packard0a246542009-09-17 17:28:08 -0700141 drmFree(ptr->encoders);
142 drmFree(ptr->prop_values);
143 drmFree(ptr->props);
Jesse Barnes731cd552008-12-17 10:09:49 -0800144 drmFree(ptr->modes);
145 drmFree(ptr);
Jesse Barnes731cd552008-12-17 10:09:49 -0800146}
147
148void drmModeFreeEncoder(drmModeEncoderPtr ptr)
149{
150 drmFree(ptr);
151}
152
153/*
154 * ModeSetting functions.
155 */
156
157drmModeResPtr drmModeGetResources(int fd)
158{
Chris Wilsond1308f42010-01-06 15:19:25 +0000159 struct drm_mode_card_res res, counts;
Jesse Barnes731cd552008-12-17 10:09:49 -0800160 drmModeResPtr r = 0;
161
Chris Wilsond1308f42010-01-06 15:19:25 +0000162retry:
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100163 memclear(res);
Jesse Barnes731cd552008-12-17 10:09:49 -0800164 if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res))
165 return 0;
166
Chris Wilsond1308f42010-01-06 15:19:25 +0000167 counts = res;
168
Chris Wilson85fb3e52010-01-06 15:39:49 +0000169 if (res.count_fbs) {
Jesse Barnes731cd552008-12-17 10:09:49 -0800170 res.fb_id_ptr = VOID2U64(drmMalloc(res.count_fbs*sizeof(uint32_t)));
Chris Wilson85fb3e52010-01-06 15:39:49 +0000171 if (!res.fb_id_ptr)
172 goto err_allocs;
173 }
174 if (res.count_crtcs) {
Jesse Barnes731cd552008-12-17 10:09:49 -0800175 res.crtc_id_ptr = VOID2U64(drmMalloc(res.count_crtcs*sizeof(uint32_t)));
Chris Wilson85fb3e52010-01-06 15:39:49 +0000176 if (!res.crtc_id_ptr)
177 goto err_allocs;
178 }
179 if (res.count_connectors) {
Jesse Barnes731cd552008-12-17 10:09:49 -0800180 res.connector_id_ptr = VOID2U64(drmMalloc(res.count_connectors*sizeof(uint32_t)));
Chris Wilson85fb3e52010-01-06 15:39:49 +0000181 if (!res.connector_id_ptr)
182 goto err_allocs;
183 }
184 if (res.count_encoders) {
Jesse Barnes731cd552008-12-17 10:09:49 -0800185 res.encoder_id_ptr = VOID2U64(drmMalloc(res.count_encoders*sizeof(uint32_t)));
Chris Wilson85fb3e52010-01-06 15:39:49 +0000186 if (!res.encoder_id_ptr)
187 goto err_allocs;
188 }
Jesse Barnes731cd552008-12-17 10:09:49 -0800189
Chris Wilsond1308f42010-01-06 15:19:25 +0000190 if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res))
Jesse Barnes731cd552008-12-17 10:09:49 -0800191 goto err_allocs;
Chris Wilsond1308f42010-01-06 15:19:25 +0000192
193 /* The number of available connectors and etc may have changed with a
194 * hotplug event in between the ioctls, in which case the field is
195 * silently ignored by the kernel.
196 */
197 if (counts.count_fbs < res.count_fbs ||
198 counts.count_crtcs < res.count_crtcs ||
199 counts.count_connectors < res.count_connectors ||
200 counts.count_encoders < res.count_encoders)
201 {
202 drmFree(U642VOID(res.fb_id_ptr));
203 drmFree(U642VOID(res.crtc_id_ptr));
204 drmFree(U642VOID(res.connector_id_ptr));
205 drmFree(U642VOID(res.encoder_id_ptr));
206
207 goto retry;
Jesse Barnes731cd552008-12-17 10:09:49 -0800208 }
209
210 /*
211 * return
212 */
Jesse Barnes731cd552008-12-17 10:09:49 -0800213 if (!(r = drmMalloc(sizeof(*r))))
Chris Wilsond1308f42010-01-06 15:19:25 +0000214 goto err_allocs;
Jesse Barnes731cd552008-12-17 10:09:49 -0800215
216 r->min_width = res.min_width;
217 r->max_width = res.max_width;
218 r->min_height = res.min_height;
219 r->max_height = res.max_height;
220 r->count_fbs = res.count_fbs;
221 r->count_crtcs = res.count_crtcs;
222 r->count_connectors = res.count_connectors;
223 r->count_encoders = res.count_encoders;
Chris Wilson85fb3e52010-01-06 15:39:49 +0000224
225 r->fbs = drmAllocCpy(U642VOID(res.fb_id_ptr), res.count_fbs, sizeof(uint32_t));
226 r->crtcs = drmAllocCpy(U642VOID(res.crtc_id_ptr), res.count_crtcs, sizeof(uint32_t));
227 r->connectors = drmAllocCpy(U642VOID(res.connector_id_ptr), res.count_connectors, sizeof(uint32_t));
228 r->encoders = drmAllocCpy(U642VOID(res.encoder_id_ptr), res.count_encoders, sizeof(uint32_t));
Chris Wilsone6c136c2010-01-06 16:53:33 +0000229 if ((res.count_fbs && !r->fbs) ||
230 (res.count_crtcs && !r->crtcs) ||
231 (res.count_connectors && !r->connectors) ||
232 (res.count_encoders && !r->encoders))
233 {
Chris Wilson85fb3e52010-01-06 15:39:49 +0000234 drmFree(r->fbs);
235 drmFree(r->crtcs);
236 drmFree(r->connectors);
237 drmFree(r->encoders);
238 drmFree(r);
239 r = 0;
240 }
Jesse Barnes731cd552008-12-17 10:09:49 -0800241
242err_allocs:
243 drmFree(U642VOID(res.fb_id_ptr));
244 drmFree(U642VOID(res.crtc_id_ptr));
245 drmFree(U642VOID(res.connector_id_ptr));
246 drmFree(U642VOID(res.encoder_id_ptr));
247
248 return r;
249}
250
251int drmModeAddFB(int fd, uint32_t width, uint32_t height, uint8_t depth,
Thierry Reding5e5a3c42014-04-09 09:00:49 +0200252 uint8_t bpp, uint32_t pitch, uint32_t bo_handle,
Jesse Barnes731cd552008-12-17 10:09:49 -0800253 uint32_t *buf_id)
254{
255 struct drm_mode_fb_cmd f;
256 int ret;
257
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100258 memclear(f);
Jesse Barnes731cd552008-12-17 10:09:49 -0800259 f.width = width;
260 f.height = height;
261 f.pitch = pitch;
262 f.bpp = bpp;
263 f.depth = depth;
264 f.handle = bo_handle;
265
Chris Wilsonb8039182010-07-01 22:38:54 +0100266 if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB, &f)))
Jesse Barnes731cd552008-12-17 10:09:49 -0800267 return ret;
268
269 *buf_id = f.fb_id;
270 return 0;
271}
272
Kristian H. Kristensenabfa6802016-09-08 13:08:59 -0700273int drmModeAddFB2WithModifiers(int fd, uint32_t width, uint32_t height,
Tobias Jakobi09be5412017-10-10 12:12:52 +0200274 uint32_t pixel_format, const uint32_t bo_handles[4],
275 const uint32_t pitches[4], const uint32_t offsets[4],
276 const uint64_t modifier[4], uint32_t *buf_id, uint32_t flags)
Jesse Barnesac168bf2011-04-29 08:53:53 -0700277{
278 struct drm_mode_fb_cmd2 f;
279 int ret;
280
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100281 memclear(f);
Jesse Barnesac168bf2011-04-29 08:53:53 -0700282 f.width = width;
283 f.height = height;
284 f.pixel_format = pixel_format;
285 f.flags = flags;
Ville Syrjälä76b4a692012-02-02 14:53:43 -0500286 memcpy(f.handles, bo_handles, 4 * sizeof(bo_handles[0]));
287 memcpy(f.pitches, pitches, 4 * sizeof(pitches[0]));
288 memcpy(f.offsets, offsets, 4 * sizeof(offsets[0]));
Kristian H. Kristensenabfa6802016-09-08 13:08:59 -0700289 if (modifier)
290 memcpy(f.modifier, modifier, 4 * sizeof(modifier[0]));
Jesse Barnesac168bf2011-04-29 08:53:53 -0700291
292 if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB2, &f)))
293 return ret;
294
295 *buf_id = f.fb_id;
296 return 0;
297}
298
Kristian H. Kristensenabfa6802016-09-08 13:08:59 -0700299int drmModeAddFB2(int fd, uint32_t width, uint32_t height,
Tobias Jakobi09be5412017-10-10 12:12:52 +0200300 uint32_t pixel_format, const uint32_t bo_handles[4],
301 const uint32_t pitches[4], const uint32_t offsets[4],
Kristian H. Kristensenabfa6802016-09-08 13:08:59 -0700302 uint32_t *buf_id, uint32_t flags)
303{
304 return drmModeAddFB2WithModifiers(fd, width, height,
305 pixel_format, bo_handles,
306 pitches, offsets, NULL,
307 buf_id, flags);
308}
309
Jesse Barnes731cd552008-12-17 10:09:49 -0800310int drmModeRmFB(int fd, uint32_t bufferId)
311{
Chris Wilsonb8039182010-07-01 22:38:54 +0100312 return DRM_IOCTL(fd, DRM_IOCTL_MODE_RMFB, &bufferId);
Jesse Barnes731cd552008-12-17 10:09:49 -0800313}
314
315drmModeFBPtr drmModeGetFB(int fd, uint32_t buf)
316{
317 struct drm_mode_fb_cmd info;
318 drmModeFBPtr r;
319
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100320 memclear(info);
Jesse Barnes731cd552008-12-17 10:09:49 -0800321 info.fb_id = buf;
322
323 if (drmIoctl(fd, DRM_IOCTL_MODE_GETFB, &info))
324 return NULL;
325
326 if (!(r = drmMalloc(sizeof(*r))))
327 return NULL;
328
329 r->fb_id = info.fb_id;
330 r->width = info.width;
331 r->height = info.height;
332 r->pitch = info.pitch;
333 r->bpp = info.bpp;
334 r->handle = info.handle;
335 r->depth = info.depth;
336
337 return r;
338}
339
Jakob Bornecrantz3e486132009-11-24 18:00:12 +0100340int drmModeDirtyFB(int fd, uint32_t bufferId,
341 drmModeClipPtr clips, uint32_t num_clips)
342{
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100343 struct drm_mode_fb_dirty_cmd dirty;
Jakob Bornecrantz3e486132009-11-24 18:00:12 +0100344
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100345 memclear(dirty);
Jakob Bornecrantz3e486132009-11-24 18:00:12 +0100346 dirty.fb_id = bufferId;
347 dirty.clips_ptr = VOID2U64(clips);
348 dirty.num_clips = num_clips;
349
Chris Wilsonb8039182010-07-01 22:38:54 +0100350 return DRM_IOCTL(fd, DRM_IOCTL_MODE_DIRTYFB, &dirty);
Jakob Bornecrantz3e486132009-11-24 18:00:12 +0100351}
352
Jesse Barnes731cd552008-12-17 10:09:49 -0800353/*
354 * Crtc functions
355 */
356
357drmModeCrtcPtr drmModeGetCrtc(int fd, uint32_t crtcId)
358{
359 struct drm_mode_crtc crtc;
360 drmModeCrtcPtr r;
361
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100362 memclear(crtc);
Jesse Barnes731cd552008-12-17 10:09:49 -0800363 crtc.crtc_id = crtcId;
364
365 if (drmIoctl(fd, DRM_IOCTL_MODE_GETCRTC, &crtc))
366 return 0;
367
368 /*
369 * return
370 */
371
372 if (!(r = drmMalloc(sizeof(*r))))
373 return 0;
374
375 r->crtc_id = crtc.crtc_id;
376 r->x = crtc.x;
377 r->y = crtc.y;
378 r->mode_valid = crtc.mode_valid;
Rob Clarke81acf52012-10-14 16:55:32 -0500379 if (r->mode_valid) {
Jesse Barnes731cd552008-12-17 10:09:49 -0800380 memcpy(&r->mode, &crtc.mode, sizeof(struct drm_mode_modeinfo));
Rob Clarke81acf52012-10-14 16:55:32 -0500381 r->width = crtc.mode.hdisplay;
382 r->height = crtc.mode.vdisplay;
383 }
Jesse Barnes731cd552008-12-17 10:09:49 -0800384 r->buffer_id = crtc.fb_id;
385 r->gamma_size = crtc.gamma_size;
386 return r;
387}
388
Jesse Barnes731cd552008-12-17 10:09:49 -0800389int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
Thierry Reding5e5a3c42014-04-09 09:00:49 +0200390 uint32_t x, uint32_t y, uint32_t *connectors, int count,
Jakob Bornecrantzeb78c532009-02-11 16:43:20 +0100391 drmModeModeInfoPtr mode)
Jesse Barnes731cd552008-12-17 10:09:49 -0800392{
393 struct drm_mode_crtc crtc;
394
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100395 memclear(crtc);
Jesse Barnes731cd552008-12-17 10:09:49 -0800396 crtc.x = x;
397 crtc.y = y;
398 crtc.crtc_id = crtcId;
399 crtc.fb_id = bufferId;
400 crtc.set_connectors_ptr = VOID2U64(connectors);
401 crtc.count_connectors = count;
402 if (mode) {
403 memcpy(&crtc.mode, mode, sizeof(struct drm_mode_modeinfo));
404 crtc.mode_valid = 1;
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100405 }
Jesse Barnes731cd552008-12-17 10:09:49 -0800406
Chris Wilsonb8039182010-07-01 22:38:54 +0100407 return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETCRTC, &crtc);
Jesse Barnes731cd552008-12-17 10:09:49 -0800408}
409
410/*
411 * Cursor manipulation
412 */
413
414int drmModeSetCursor(int fd, uint32_t crtcId, uint32_t bo_handle, uint32_t width, uint32_t height)
415{
416 struct drm_mode_cursor arg;
417
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100418 memclear(arg);
Jesse Barnes731cd552008-12-17 10:09:49 -0800419 arg.flags = DRM_MODE_CURSOR_BO;
420 arg.crtc_id = crtcId;
421 arg.width = width;
422 arg.height = height;
423 arg.handle = bo_handle;
424
Chris Wilsonb8039182010-07-01 22:38:54 +0100425 return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR, &arg);
Jesse Barnes731cd552008-12-17 10:09:49 -0800426}
427
Dave Airlie2e0ab622013-07-02 09:21:06 +0100428int drmModeSetCursor2(int fd, uint32_t crtcId, uint32_t bo_handle, uint32_t width, uint32_t height, int32_t hot_x, int32_t hot_y)
429{
430 struct drm_mode_cursor2 arg;
431
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100432 memclear(arg);
Dave Airlie2e0ab622013-07-02 09:21:06 +0100433 arg.flags = DRM_MODE_CURSOR_BO;
434 arg.crtc_id = crtcId;
435 arg.width = width;
436 arg.height = height;
437 arg.handle = bo_handle;
438 arg.hot_x = hot_x;
439 arg.hot_y = hot_y;
440
441 return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR2, &arg);
442}
443
Jesse Barnes731cd552008-12-17 10:09:49 -0800444int drmModeMoveCursor(int fd, uint32_t crtcId, int x, int y)
445{
446 struct drm_mode_cursor arg;
447
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100448 memclear(arg);
Jesse Barnes731cd552008-12-17 10:09:49 -0800449 arg.flags = DRM_MODE_CURSOR_MOVE;
450 arg.crtc_id = crtcId;
451 arg.x = x;
452 arg.y = y;
453
Chris Wilsonb8039182010-07-01 22:38:54 +0100454 return DRM_IOCTL(fd, DRM_IOCTL_MODE_CURSOR, &arg);
Jesse Barnes731cd552008-12-17 10:09:49 -0800455}
456
457/*
458 * Encoder get
459 */
460drmModeEncoderPtr drmModeGetEncoder(int fd, uint32_t encoder_id)
461{
462 struct drm_mode_get_encoder enc;
463 drmModeEncoderPtr r = NULL;
464
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100465 memclear(enc);
Jesse Barnes731cd552008-12-17 10:09:49 -0800466 enc.encoder_id = encoder_id;
Jesse Barnes731cd552008-12-17 10:09:49 -0800467
468 if (drmIoctl(fd, DRM_IOCTL_MODE_GETENCODER, &enc))
469 return 0;
470
471 if (!(r = drmMalloc(sizeof(*r))))
472 return 0;
473
474 r->encoder_id = enc.encoder_id;
475 r->crtc_id = enc.crtc_id;
476 r->encoder_type = enc.encoder_type;
477 r->possible_crtcs = enc.possible_crtcs;
478 r->possible_clones = enc.possible_clones;
479
480 return r;
481}
482
483/*
484 * Connector manipulation
485 */
Chris Wilson5ed5fa12015-03-04 10:07:19 +0000486static drmModeConnectorPtr
487_drmModeGetConnector(int fd, uint32_t connector_id, int probe)
Jesse Barnes731cd552008-12-17 10:09:49 -0800488{
Peter Clifton04f90a42010-01-06 20:44:11 +0000489 struct drm_mode_get_connector conn, counts;
Jesse Barnes731cd552008-12-17 10:09:49 -0800490 drmModeConnectorPtr r = NULL;
Ville Syrjäläe342c0f2015-12-15 14:18:32 +0200491 struct drm_mode_modeinfo stack_mode;
Jesse Barnes731cd552008-12-17 10:09:49 -0800492
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100493 memclear(conn);
Jesse Barnes731cd552008-12-17 10:09:49 -0800494 conn.connector_id = connector_id;
Chris Wilson5ed5fa12015-03-04 10:07:19 +0000495 if (!probe) {
496 conn.count_modes = 1;
Ville Syrjäläe342c0f2015-12-15 14:18:32 +0200497 conn.modes_ptr = VOID2U64(&stack_mode);
Chris Wilson5ed5fa12015-03-04 10:07:19 +0000498 }
Jesse Barnes731cd552008-12-17 10:09:49 -0800499
500 if (drmIoctl(fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn))
501 return 0;
502
Chris Wilson5ed5fa12015-03-04 10:07:19 +0000503retry:
Peter Clifton04f90a42010-01-06 20:44:11 +0000504 counts = conn;
505
Jesse Barnes731cd552008-12-17 10:09:49 -0800506 if (conn.count_props) {
507 conn.props_ptr = VOID2U64(drmMalloc(conn.count_props*sizeof(uint32_t)));
Peter Clifton04f90a42010-01-06 20:44:11 +0000508 if (!conn.props_ptr)
509 goto err_allocs;
Jesse Barnes731cd552008-12-17 10:09:49 -0800510 conn.prop_values_ptr = VOID2U64(drmMalloc(conn.count_props*sizeof(uint64_t)));
Peter Clifton04f90a42010-01-06 20:44:11 +0000511 if (!conn.prop_values_ptr)
512 goto err_allocs;
Jesse Barnes731cd552008-12-17 10:09:49 -0800513 }
514
Peter Clifton04f90a42010-01-06 20:44:11 +0000515 if (conn.count_modes) {
Jesse Barnes731cd552008-12-17 10:09:49 -0800516 conn.modes_ptr = VOID2U64(drmMalloc(conn.count_modes*sizeof(struct drm_mode_modeinfo)));
Peter Clifton04f90a42010-01-06 20:44:11 +0000517 if (!conn.modes_ptr)
518 goto err_allocs;
Chris Wilson5ed5fa12015-03-04 10:07:19 +0000519 } else {
520 conn.count_modes = 1;
Ville Syrjäläe342c0f2015-12-15 14:18:32 +0200521 conn.modes_ptr = VOID2U64(&stack_mode);
Peter Clifton04f90a42010-01-06 20:44:11 +0000522 }
Jesse Barnes731cd552008-12-17 10:09:49 -0800523
Peter Clifton04f90a42010-01-06 20:44:11 +0000524 if (conn.count_encoders) {
Jesse Barnes731cd552008-12-17 10:09:49 -0800525 conn.encoders_ptr = VOID2U64(drmMalloc(conn.count_encoders*sizeof(uint32_t)));
Peter Clifton04f90a42010-01-06 20:44:11 +0000526 if (!conn.encoders_ptr)
527 goto err_allocs;
528 }
Jesse Barnes731cd552008-12-17 10:09:49 -0800529
530 if (drmIoctl(fd, DRM_IOCTL_MODE_GETCONNECTOR, &conn))
531 goto err_allocs;
532
Peter Clifton04f90a42010-01-06 20:44:11 +0000533 /* The number of available connectors and etc may have changed with a
534 * hotplug event in between the ioctls, in which case the field is
535 * silently ignored by the kernel.
536 */
537 if (counts.count_props < conn.count_props ||
538 counts.count_modes < conn.count_modes ||
539 counts.count_encoders < conn.count_encoders) {
540 drmFree(U642VOID(conn.props_ptr));
541 drmFree(U642VOID(conn.prop_values_ptr));
Ville Syrjäläe342c0f2015-12-15 14:18:32 +0200542 if (U642VOID(conn.modes_ptr) != &stack_mode)
543 drmFree(U642VOID(conn.modes_ptr));
Peter Clifton04f90a42010-01-06 20:44:11 +0000544 drmFree(U642VOID(conn.encoders_ptr));
545
546 goto retry;
547 }
548
Jesse Barnes731cd552008-12-17 10:09:49 -0800549 if(!(r = drmMalloc(sizeof(*r)))) {
550 goto err_allocs;
551 }
552
553 r->connector_id = conn.connector_id;
554 r->encoder_id = conn.encoder_id;
555 r->connection = conn.connection;
556 r->mmWidth = conn.mm_width;
557 r->mmHeight = conn.mm_height;
Dave Airlie412d3702009-04-22 20:25:40 +1000558 /* convert subpixel from kernel to userspace */
559 r->subpixel = conn.subpixel + 1;
Jesse Barnes731cd552008-12-17 10:09:49 -0800560 r->count_modes = conn.count_modes;
Jesse Barnes731cd552008-12-17 10:09:49 -0800561 r->count_props = conn.count_props;
562 r->props = drmAllocCpy(U642VOID(conn.props_ptr), conn.count_props, sizeof(uint32_t));
563 r->prop_values = drmAllocCpy(U642VOID(conn.prop_values_ptr), conn.count_props, sizeof(uint64_t));
564 r->modes = drmAllocCpy(U642VOID(conn.modes_ptr), conn.count_modes, sizeof(struct drm_mode_modeinfo));
565 r->count_encoders = conn.count_encoders;
566 r->encoders = drmAllocCpy(U642VOID(conn.encoders_ptr), conn.count_encoders, sizeof(uint32_t));
567 r->connector_type = conn.connector_type;
568 r->connector_type_id = conn.connector_type_id;
569
Peter Clifton04f90a42010-01-06 20:44:11 +0000570 if ((r->count_props && !r->props) ||
571 (r->count_props && !r->prop_values) ||
572 (r->count_modes && !r->modes) ||
573 (r->count_encoders && !r->encoders)) {
574 drmFree(r->props);
575 drmFree(r->prop_values);
576 drmFree(r->modes);
577 drmFree(r->encoders);
578 drmFree(r);
579 r = 0;
580 }
Jesse Barnes731cd552008-12-17 10:09:49 -0800581
582err_allocs:
583 drmFree(U642VOID(conn.prop_values_ptr));
584 drmFree(U642VOID(conn.props_ptr));
Ville Syrjäläe342c0f2015-12-15 14:18:32 +0200585 if (U642VOID(conn.modes_ptr) != &stack_mode)
586 drmFree(U642VOID(conn.modes_ptr));
Jesse Barnes731cd552008-12-17 10:09:49 -0800587 drmFree(U642VOID(conn.encoders_ptr));
588
589 return r;
590}
591
Chris Wilson5ed5fa12015-03-04 10:07:19 +0000592drmModeConnectorPtr drmModeGetConnector(int fd, uint32_t connector_id)
593{
594 return _drmModeGetConnector(fd, connector_id, 1);
595}
596
597drmModeConnectorPtr drmModeGetConnectorCurrent(int fd, uint32_t connector_id)
598{
599 return _drmModeGetConnector(fd, connector_id, 0);
600}
601
Jakob Bornecrantzeb78c532009-02-11 16:43:20 +0100602int drmModeAttachMode(int fd, uint32_t connector_id, drmModeModeInfoPtr mode_info)
Jesse Barnes731cd552008-12-17 10:09:49 -0800603{
604 struct drm_mode_mode_cmd res;
605
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100606 memclear(res);
Jesse Barnes731cd552008-12-17 10:09:49 -0800607 memcpy(&res.mode, mode_info, sizeof(struct drm_mode_modeinfo));
608 res.connector_id = connector_id;
609
Chris Wilsonb8039182010-07-01 22:38:54 +0100610 return DRM_IOCTL(fd, DRM_IOCTL_MODE_ATTACHMODE, &res);
Jesse Barnes731cd552008-12-17 10:09:49 -0800611}
612
Jakob Bornecrantzeb78c532009-02-11 16:43:20 +0100613int drmModeDetachMode(int fd, uint32_t connector_id, drmModeModeInfoPtr mode_info)
Jesse Barnes731cd552008-12-17 10:09:49 -0800614{
615 struct drm_mode_mode_cmd res;
616
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100617 memclear(res);
Jesse Barnes731cd552008-12-17 10:09:49 -0800618 memcpy(&res.mode, mode_info, sizeof(struct drm_mode_modeinfo));
619 res.connector_id = connector_id;
620
Chris Wilsonb8039182010-07-01 22:38:54 +0100621 return DRM_IOCTL(fd, DRM_IOCTL_MODE_DETACHMODE, &res);
Jesse Barnes731cd552008-12-17 10:09:49 -0800622}
623
Jesse Barnes731cd552008-12-17 10:09:49 -0800624drmModePropertyPtr drmModeGetProperty(int fd, uint32_t property_id)
625{
626 struct drm_mode_get_property prop;
627 drmModePropertyPtr r;
628
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100629 memclear(prop);
Jesse Barnes731cd552008-12-17 10:09:49 -0800630 prop.prop_id = property_id;
Jesse Barnes731cd552008-12-17 10:09:49 -0800631
632 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop))
633 return 0;
634
635 if (prop.count_values)
636 prop.values_ptr = VOID2U64(drmMalloc(prop.count_values * sizeof(uint64_t)));
637
Rob Clark7b228e92012-06-05 12:28:22 -0500638 if (prop.count_enum_blobs && (prop.flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)))
Jesse Barnes731cd552008-12-17 10:09:49 -0800639 prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(struct drm_mode_property_enum)));
640
641 if (prop.count_enum_blobs && (prop.flags & DRM_MODE_PROP_BLOB)) {
642 prop.values_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t)));
643 prop.enum_blob_ptr = VOID2U64(drmMalloc(prop.count_enum_blobs * sizeof(uint32_t)));
644 }
645
646 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPERTY, &prop)) {
647 r = NULL;
648 goto err_allocs;
649 }
650
651 if (!(r = drmMalloc(sizeof(*r))))
652 return NULL;
653
654 r->prop_id = prop.prop_id;
655 r->count_values = prop.count_values;
656
657 r->flags = prop.flags;
658 if (prop.count_values)
659 r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_values, sizeof(uint64_t));
Rob Clark7b228e92012-06-05 12:28:22 -0500660 if (prop.flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) {
Jesse Barnes731cd552008-12-17 10:09:49 -0800661 r->count_enums = prop.count_enum_blobs;
662 r->enums = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(struct drm_mode_property_enum));
663 } else if (prop.flags & DRM_MODE_PROP_BLOB) {
664 r->values = drmAllocCpy(U642VOID(prop.values_ptr), prop.count_enum_blobs, sizeof(uint32_t));
665 r->blob_ids = drmAllocCpy(U642VOID(prop.enum_blob_ptr), prop.count_enum_blobs, sizeof(uint32_t));
666 r->count_blobs = prop.count_enum_blobs;
667 }
668 strncpy(r->name, prop.name, DRM_PROP_NAME_LEN);
669 r->name[DRM_PROP_NAME_LEN-1] = 0;
670
671err_allocs:
672 drmFree(U642VOID(prop.values_ptr));
673 drmFree(U642VOID(prop.enum_blob_ptr));
674
675 return r;
676}
677
678void drmModeFreeProperty(drmModePropertyPtr ptr)
679{
680 if (!ptr)
681 return;
682
683 drmFree(ptr->values);
684 drmFree(ptr->enums);
685 drmFree(ptr);
686}
687
688drmModePropertyBlobPtr drmModeGetPropertyBlob(int fd, uint32_t blob_id)
689{
690 struct drm_mode_get_blob blob;
691 drmModePropertyBlobPtr r;
692
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100693 memclear(blob);
Jesse Barnes731cd552008-12-17 10:09:49 -0800694 blob.blob_id = blob_id;
695
696 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob))
697 return NULL;
698
699 if (blob.length)
700 blob.data = VOID2U64(drmMalloc(blob.length));
701
702 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPROPBLOB, &blob)) {
703 r = NULL;
704 goto err_allocs;
705 }
706
707 if (!(r = drmMalloc(sizeof(*r))))
Chris Wilson8a762442010-08-24 21:29:31 +0100708 goto err_allocs;
Jesse Barnes731cd552008-12-17 10:09:49 -0800709
710 r->id = blob.blob_id;
711 r->length = blob.length;
712 r->data = drmAllocCpy(U642VOID(blob.data), 1, blob.length);
713
714err_allocs:
715 drmFree(U642VOID(blob.data));
716 return r;
717}
718
719void drmModeFreePropertyBlob(drmModePropertyBlobPtr ptr)
720{
721 if (!ptr)
722 return;
723
724 drmFree(ptr->data);
725 drmFree(ptr);
726}
727
728int drmModeConnectorSetProperty(int fd, uint32_t connector_id, uint32_t property_id,
729 uint64_t value)
730{
731 struct drm_mode_connector_set_property osp;
Jesse Barnes731cd552008-12-17 10:09:49 -0800732
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100733 memclear(osp);
Jesse Barnes731cd552008-12-17 10:09:49 -0800734 osp.connector_id = connector_id;
735 osp.prop_id = property_id;
736 osp.value = value;
737
Chris Wilsonb8039182010-07-01 22:38:54 +0100738 return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETPROPERTY, &osp);
Jesse Barnes731cd552008-12-17 10:09:49 -0800739}
740
741/*
742 * checks if a modesetting capable driver has attached to the pci id
743 * returns 0 if modesetting supported.
744 * -EINVAL or invalid bus id
745 * -ENOSYS if no modesetting support
746*/
747int drmCheckModesettingSupported(const char *busid)
748{
Robert Millancbb31f22014-01-23 14:46:05 +0000749#if defined (__linux__)
Jesse Barnes731cd552008-12-17 10:09:49 -0800750 char pci_dev_dir[1024];
751 int domain, bus, dev, func;
752 DIR *sysdir;
753 struct dirent *dent;
754 int found = 0, ret;
755
756 ret = sscanf(busid, "pci:%04x:%02x:%02x.%d", &domain, &bus, &dev, &func);
757 if (ret != 4)
758 return -EINVAL;
759
760 sprintf(pci_dev_dir, "/sys/bus/pci/devices/%04x:%02x:%02x.%d/drm",
761 domain, bus, dev, func);
762
763 sysdir = opendir(pci_dev_dir);
764 if (sysdir) {
765 dent = readdir(sysdir);
766 while (dent) {
767 if (!strncmp(dent->d_name, "controlD", 8)) {
768 found = 1;
769 break;
770 }
771
772 dent = readdir(sysdir);
773 }
774 closedir(sysdir);
775 if (found)
776 return 0;
777 }
778
779 sprintf(pci_dev_dir, "/sys/bus/pci/devices/%04x:%02x:%02x.%d/",
780 domain, bus, dev, func);
781
782 sysdir = opendir(pci_dev_dir);
783 if (!sysdir)
784 return -EINVAL;
785
786 dent = readdir(sysdir);
787 while (dent) {
788 if (!strncmp(dent->d_name, "drm:controlD", 12)) {
789 found = 1;
790 break;
791 }
792
793 dent = readdir(sysdir);
794 }
795
796 closedir(sysdir);
797 if (found)
798 return 0;
Robert Millancbb31f22014-01-23 14:46:05 +0000799#elif defined (__FreeBSD__) || defined (__FreeBSD_kernel__)
800 char kbusid[1024], sbusid[1024];
801 char oid[128];
802 int domain, bus, dev, func;
803 int i, modesetting, ret;
804 size_t len;
805
806 ret = sscanf(busid, "pci:%04x:%02x:%02x.%d", &domain, &bus, &dev,
807 &func);
808 if (ret != 4)
809 return -EINVAL;
810 snprintf(kbusid, sizeof(kbusid), "pci:%04x:%02x:%02x.%d", domain, bus,
811 dev, func);
812
813 /* How many GPUs do we expect in the machine ? */
814 for (i = 0; i < 16; i++) {
815 snprintf(oid, sizeof(oid), "hw.dri.%d.busid", i);
816 len = sizeof(sbusid);
817 ret = sysctlbyname(oid, sbusid, &len, NULL, 0);
818 if (ret == -1) {
819 if (errno == ENOENT)
820 continue;
821 return -EINVAL;
822 }
823 if (strcmp(sbusid, kbusid) != 0)
824 continue;
825 snprintf(oid, sizeof(oid), "hw.dri.%d.modesetting", i);
826 len = sizeof(modesetting);
827 ret = sysctlbyname(oid, &modesetting, &len, NULL, 0);
828 if (ret == -1 || len != sizeof(modesetting))
829 return -EINVAL;
830 return (modesetting ? 0 : -ENOSYS);
831 }
François Tigeotedbb4e52014-07-26 13:39:58 +0200832#elif defined(__DragonFly__)
833 return 0;
Jesse Barnes731cd552008-12-17 10:09:49 -0800834#endif
Jonathan Gray1d3b8232015-07-19 07:20:37 +1000835#ifdef __OpenBSD__
836 int fd;
837 struct drm_mode_card_res res;
838 drmModeResPtr r = 0;
Jesse Barnes731cd552008-12-17 10:09:49 -0800839
Jonathan Gray1d3b8232015-07-19 07:20:37 +1000840 if ((fd = drmOpen(NULL, busid)) < 0)
841 return -EINVAL;
842
843 memset(&res, 0, sizeof(struct drm_mode_card_res));
844
845 if (drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &res)) {
846 drmClose(fd);
847 return -errno;
848 }
849
850 drmClose(fd);
851 return 0;
852#endif
853 return -ENOSYS;
Jesse Barnes731cd552008-12-17 10:09:49 -0800854}
855
Jesse Barnes731cd552008-12-17 10:09:49 -0800856int drmModeCrtcGetGamma(int fd, uint32_t crtc_id, uint32_t size,
857 uint16_t *red, uint16_t *green, uint16_t *blue)
858{
Jesse Barnes731cd552008-12-17 10:09:49 -0800859 struct drm_mode_crtc_lut l;
860
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100861 memclear(l);
Jesse Barnes731cd552008-12-17 10:09:49 -0800862 l.crtc_id = crtc_id;
863 l.gamma_size = size;
864 l.red = VOID2U64(red);
865 l.green = VOID2U64(green);
866 l.blue = VOID2U64(blue);
867
Chris Wilsonb8039182010-07-01 22:38:54 +0100868 return DRM_IOCTL(fd, DRM_IOCTL_MODE_GETGAMMA, &l);
Jesse Barnes731cd552008-12-17 10:09:49 -0800869}
870
871int drmModeCrtcSetGamma(int fd, uint32_t crtc_id, uint32_t size,
872 uint16_t *red, uint16_t *green, uint16_t *blue)
873{
Jesse Barnes731cd552008-12-17 10:09:49 -0800874 struct drm_mode_crtc_lut l;
875
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100876 memclear(l);
Jesse Barnes731cd552008-12-17 10:09:49 -0800877 l.crtc_id = crtc_id;
878 l.gamma_size = size;
879 l.red = VOID2U64(red);
880 l.green = VOID2U64(green);
881 l.blue = VOID2U64(blue);
882
Chris Wilsonb8039182010-07-01 22:38:54 +0100883 return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETGAMMA, &l);
Jesse Barnes731cd552008-12-17 10:09:49 -0800884}
Kristian Høgsbergb0b96632009-09-11 13:27:35 -0400885
886int drmHandleEvent(int fd, drmEventContextPtr evctx)
887{
888 char buffer[1024];
889 int len, i;
890 struct drm_event *e;
891 struct drm_event_vblank *vblank;
Ander Conselvan de Oliveira890d43a2015-08-17 16:21:24 +0300892 void *user_data;
Hyungwon Hwang4bac0352015-08-19 09:58:39 +0900893
Kristian Høgsbergb0b96632009-09-11 13:27:35 -0400894 /* The DRM read semantics guarantees that we always get only
895 * complete events. */
896
897 len = read(fd, buffer, sizeof buffer);
898 if (len == 0)
899 return 0;
Jan Veselyde8532d2014-11-30 12:53:18 -0500900 if (len < (int)sizeof *e)
Kristian Høgsbergb0b96632009-09-11 13:27:35 -0400901 return -1;
902
903 i = 0;
904 while (i < len) {
Thierry Redingecc2a092015-04-13 11:36:59 +0200905 e = (struct drm_event *)(buffer + i);
Kristian Høgsbergb0b96632009-09-11 13:27:35 -0400906 switch (e->type) {
907 case DRM_EVENT_VBLANK:
908 if (evctx->version < 1 ||
909 evctx->vblank_handler == NULL)
910 break;
911 vblank = (struct drm_event_vblank *) e;
912 evctx->vblank_handler(fd,
Hyungwon Hwang4bac0352015-08-19 09:58:39 +0900913 vblank->sequence,
Kristian Høgsbergb0b96632009-09-11 13:27:35 -0400914 vblank->tv_sec,
915 vblank->tv_usec,
916 U642VOID (vblank->user_data));
917 break;
Kristian Høgsbergb80bcff2009-11-12 14:06:45 -0500918 case DRM_EVENT_FLIP_COMPLETE:
Kristian Høgsbergb80bcff2009-11-12 14:06:45 -0500919 vblank = (struct drm_event_vblank *) e;
Ander Conselvan de Oliveira890d43a2015-08-17 16:21:24 +0300920 user_data = U642VOID (vblank->user_data);
921
922 if (evctx->version >= 3 && evctx->page_flip_handler2)
923 evctx->page_flip_handler2(fd,
924 vblank->sequence,
925 vblank->tv_sec,
926 vblank->tv_usec,
927 vblank->crtc_id,
928 user_data);
929 else if (evctx->version >= 2 && evctx->page_flip_handler)
930 evctx->page_flip_handler(fd,
931 vblank->sequence,
932 vblank->tv_sec,
933 vblank->tv_usec,
934 user_data);
Kristian Høgsbergb80bcff2009-11-12 14:06:45 -0500935 break;
Kristian Høgsbergb0b96632009-09-11 13:27:35 -0400936 default:
937 break;
938 }
939 i += e->length;
940 }
941
942 return 0;
943}
944
Kristian Høgsbergb80bcff2009-11-12 14:06:45 -0500945int drmModePageFlip(int fd, uint32_t crtc_id, uint32_t fb_id,
946 uint32_t flags, void *user_data)
947{
948 struct drm_mode_crtc_page_flip flip;
949
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100950 memclear(flip);
Kristian Høgsbergb80bcff2009-11-12 14:06:45 -0500951 flip.fb_id = fb_id;
952 flip.crtc_id = crtc_id;
953 flip.user_data = VOID2U64(user_data);
954 flip.flags = flags;
Kristian Høgsbergb80bcff2009-11-12 14:06:45 -0500955
Chris Wilsonb8039182010-07-01 22:38:54 +0100956 return DRM_IOCTL(fd, DRM_IOCTL_MODE_PAGE_FLIP, &flip);
Kristian Høgsbergb80bcff2009-11-12 14:06:45 -0500957}
Jesse Barnesac168bf2011-04-29 08:53:53 -0700958
Michel Dänzer7dd28472016-06-29 18:07:25 +0900959int drmModePageFlipTarget(int fd, uint32_t crtc_id, uint32_t fb_id,
960 uint32_t flags, void *user_data,
961 uint32_t target_vblank)
962{
963 struct drm_mode_crtc_page_flip_target flip_target;
964
965 memclear(flip_target);
966 flip_target.fb_id = fb_id;
967 flip_target.crtc_id = crtc_id;
968 flip_target.user_data = VOID2U64(user_data);
969 flip_target.flags = flags;
970 flip_target.sequence = target_vblank;
971
972 return DRM_IOCTL(fd, DRM_IOCTL_MODE_PAGE_FLIP, &flip_target);
973}
974
Jesse Barnesac168bf2011-04-29 08:53:53 -0700975int drmModeSetPlane(int fd, uint32_t plane_id, uint32_t crtc_id,
976 uint32_t fb_id, uint32_t flags,
Daniel Kurtz828c3e82014-05-01 19:56:43 +0800977 int32_t crtc_x, int32_t crtc_y,
Jesse Barnesac168bf2011-04-29 08:53:53 -0700978 uint32_t crtc_w, uint32_t crtc_h,
979 uint32_t src_x, uint32_t src_y,
980 uint32_t src_w, uint32_t src_h)
Jesse Barnesac168bf2011-04-29 08:53:53 -0700981{
982 struct drm_mode_set_plane s;
983
Daniel Vetter7e0460c2015-02-11 12:03:12 +0100984 memclear(s);
Jesse Barnesac168bf2011-04-29 08:53:53 -0700985 s.plane_id = plane_id;
986 s.crtc_id = crtc_id;
987 s.fb_id = fb_id;
988 s.flags = flags;
989 s.crtc_x = crtc_x;
990 s.crtc_y = crtc_y;
991 s.crtc_w = crtc_w;
992 s.crtc_h = crtc_h;
993 s.src_x = src_x;
994 s.src_y = src_y;
995 s.src_w = src_w;
996 s.src_h = src_h;
997
998 return DRM_IOCTL(fd, DRM_IOCTL_MODE_SETPLANE, &s);
999}
1000
Jesse Barnesac168bf2011-04-29 08:53:53 -07001001drmModePlanePtr drmModeGetPlane(int fd, uint32_t plane_id)
1002{
1003 struct drm_mode_get_plane ovr, counts;
1004 drmModePlanePtr r = 0;
1005
1006retry:
Daniel Vetter7e0460c2015-02-11 12:03:12 +01001007 memclear(ovr);
Jesse Barnesac168bf2011-04-29 08:53:53 -07001008 ovr.plane_id = plane_id;
1009 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANE, &ovr))
1010 return 0;
1011
1012 counts = ovr;
1013
1014 if (ovr.count_format_types) {
1015 ovr.format_type_ptr = VOID2U64(drmMalloc(ovr.count_format_types *
1016 sizeof(uint32_t)));
1017 if (!ovr.format_type_ptr)
1018 goto err_allocs;
1019 }
1020
1021 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANE, &ovr))
1022 goto err_allocs;
1023
1024 if (counts.count_format_types < ovr.count_format_types) {
1025 drmFree(U642VOID(ovr.format_type_ptr));
1026 goto retry;
1027 }
1028
1029 if (!(r = drmMalloc(sizeof(*r))))
1030 goto err_allocs;
1031
1032 r->count_formats = ovr.count_format_types;
1033 r->plane_id = ovr.plane_id;
1034 r->crtc_id = ovr.crtc_id;
1035 r->fb_id = ovr.fb_id;
1036 r->possible_crtcs = ovr.possible_crtcs;
1037 r->gamma_size = ovr.gamma_size;
1038 r->formats = drmAllocCpy(U642VOID(ovr.format_type_ptr),
1039 ovr.count_format_types, sizeof(uint32_t));
1040 if (ovr.count_format_types && !r->formats) {
1041 drmFree(r->formats);
Ville Syrjälädf497e92012-02-02 14:53:39 -05001042 drmFree(r);
Jesse Barnesac168bf2011-04-29 08:53:53 -07001043 r = 0;
1044 }
1045
1046err_allocs:
1047 drmFree(U642VOID(ovr.format_type_ptr));
1048
1049 return r;
1050}
1051
1052void drmModeFreePlane(drmModePlanePtr ptr)
1053{
1054 if (!ptr)
1055 return;
1056
1057 drmFree(ptr->formats);
1058 drmFree(ptr);
1059}
1060
1061drmModePlaneResPtr drmModeGetPlaneResources(int fd)
1062{
1063 struct drm_mode_get_plane_res res, counts;
1064 drmModePlaneResPtr r = 0;
1065
1066retry:
Daniel Vetter7e0460c2015-02-11 12:03:12 +01001067 memclear(res);
Jesse Barnesac168bf2011-04-29 08:53:53 -07001068 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &res))
1069 return 0;
1070
1071 counts = res;
1072
1073 if (res.count_planes) {
1074 res.plane_id_ptr = VOID2U64(drmMalloc(res.count_planes *
1075 sizeof(uint32_t)));
1076 if (!res.plane_id_ptr)
1077 goto err_allocs;
1078 }
1079
1080 if (drmIoctl(fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &res))
1081 goto err_allocs;
1082
1083 if (counts.count_planes < res.count_planes) {
1084 drmFree(U642VOID(res.plane_id_ptr));
1085 goto retry;
1086 }
1087
1088 if (!(r = drmMalloc(sizeof(*r))))
1089 goto err_allocs;
1090
1091 r->count_planes = res.count_planes;
1092 r->planes = drmAllocCpy(U642VOID(res.plane_id_ptr),
1093 res.count_planes, sizeof(uint32_t));
1094 if (res.count_planes && !r->planes) {
1095 drmFree(r->planes);
Ville Syrjälädf497e92012-02-02 14:53:39 -05001096 drmFree(r);
Jesse Barnesac168bf2011-04-29 08:53:53 -07001097 r = 0;
1098 }
1099
1100err_allocs:
1101 drmFree(U642VOID(res.plane_id_ptr));
1102
1103 return r;
1104}
Ville Syrjäläa14c3dd2012-02-02 14:53:41 -05001105
1106void drmModeFreePlaneResources(drmModePlaneResPtr ptr)
1107{
1108 if (!ptr)
1109 return;
1110
1111 drmFree(ptr->planes);
1112 drmFree(ptr);
1113}
Paulo Zanoni8c757032012-05-15 18:38:28 -03001114
1115drmModeObjectPropertiesPtr drmModeObjectGetProperties(int fd,
1116 uint32_t object_id,
1117 uint32_t object_type)
1118{
1119 struct drm_mode_obj_get_properties properties;
1120 drmModeObjectPropertiesPtr ret = NULL;
1121 uint32_t count;
1122
1123retry:
Daniel Vetter7e0460c2015-02-11 12:03:12 +01001124 memclear(properties);
Paulo Zanoni8c757032012-05-15 18:38:28 -03001125 properties.obj_id = object_id;
1126 properties.obj_type = object_type;
1127
1128 if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties))
1129 return 0;
1130
1131 count = properties.count_props;
1132
1133 if (count) {
1134 properties.props_ptr = VOID2U64(drmMalloc(count *
1135 sizeof(uint32_t)));
1136 if (!properties.props_ptr)
1137 goto err_allocs;
1138 properties.prop_values_ptr = VOID2U64(drmMalloc(count *
1139 sizeof(uint64_t)));
1140 if (!properties.prop_values_ptr)
1141 goto err_allocs;
1142 }
1143
1144 if (drmIoctl(fd, DRM_IOCTL_MODE_OBJ_GETPROPERTIES, &properties))
1145 goto err_allocs;
1146
1147 if (count < properties.count_props) {
1148 drmFree(U642VOID(properties.props_ptr));
1149 drmFree(U642VOID(properties.prop_values_ptr));
1150 goto retry;
1151 }
1152 count = properties.count_props;
1153
1154 ret = drmMalloc(sizeof(*ret));
1155 if (!ret)
1156 goto err_allocs;
1157
1158 ret->count_props = count;
1159 ret->props = drmAllocCpy(U642VOID(properties.props_ptr),
1160 count, sizeof(uint32_t));
1161 ret->prop_values = drmAllocCpy(U642VOID(properties.prop_values_ptr),
1162 count, sizeof(uint64_t));
1163 if (ret->count_props && (!ret->props || !ret->prop_values)) {
1164 drmFree(ret->props);
1165 drmFree(ret->prop_values);
1166 drmFree(ret);
1167 ret = NULL;
1168 }
1169
1170err_allocs:
1171 drmFree(U642VOID(properties.props_ptr));
1172 drmFree(U642VOID(properties.prop_values_ptr));
1173 return ret;
1174}
1175
1176void drmModeFreeObjectProperties(drmModeObjectPropertiesPtr ptr)
1177{
1178 if (!ptr)
1179 return;
1180 drmFree(ptr->props);
1181 drmFree(ptr->prop_values);
1182 drmFree(ptr);
1183}
1184
1185int drmModeObjectSetProperty(int fd, uint32_t object_id, uint32_t object_type,
1186 uint32_t property_id, uint64_t value)
1187{
1188 struct drm_mode_obj_set_property prop;
1189
Daniel Vetter7e0460c2015-02-11 12:03:12 +01001190 memclear(prop);
Paulo Zanoni8c757032012-05-15 18:38:28 -03001191 prop.value = value;
1192 prop.prop_id = property_id;
1193 prop.obj_id = object_id;
1194 prop.obj_type = object_type;
1195
1196 return DRM_IOCTL(fd, DRM_IOCTL_MODE_OBJ_SETPROPERTY, &prop);
1197}
Ville Syrjäläed44e0b2015-06-22 17:26:02 +01001198
1199typedef struct _drmModeAtomicReqItem drmModeAtomicReqItem, *drmModeAtomicReqItemPtr;
1200
1201struct _drmModeAtomicReqItem {
1202 uint32_t object_id;
1203 uint32_t property_id;
1204 uint64_t value;
1205};
1206
1207struct _drmModeAtomicReq {
1208 uint32_t cursor;
1209 uint32_t size_items;
1210 drmModeAtomicReqItemPtr items;
1211};
1212
1213drmModeAtomicReqPtr drmModeAtomicAlloc(void)
1214{
1215 drmModeAtomicReqPtr req;
1216
1217 req = drmMalloc(sizeof *req);
1218 if (!req)
1219 return NULL;
1220
1221 req->items = NULL;
1222 req->cursor = 0;
1223 req->size_items = 0;
1224
1225 return req;
1226}
1227
1228drmModeAtomicReqPtr drmModeAtomicDuplicate(drmModeAtomicReqPtr old)
1229{
1230 drmModeAtomicReqPtr new;
1231
Emil Velikoved3c6652015-09-05 17:20:53 +01001232 if (!old)
1233 return NULL;
1234
Ville Syrjäläed44e0b2015-06-22 17:26:02 +01001235 new = drmMalloc(sizeof *new);
1236 if (!new)
1237 return NULL;
1238
1239 new->cursor = old->cursor;
1240 new->size_items = old->size_items;
1241
1242 if (old->size_items) {
1243 new->items = drmMalloc(old->size_items * sizeof(*new->items));
1244 if (!new->items) {
1245 free(new);
1246 return NULL;
1247 }
1248 memcpy(new->items, old->items,
1249 old->size_items * sizeof(*new->items));
1250 } else {
1251 new->items = NULL;
1252 }
1253
1254 return new;
1255}
1256
1257int drmModeAtomicMerge(drmModeAtomicReqPtr base, drmModeAtomicReqPtr augment)
1258{
Emil Velikoved3c6652015-09-05 17:20:53 +01001259 if (!base)
1260 return -EINVAL;
1261
Ville Syrjäläed44e0b2015-06-22 17:26:02 +01001262 if (!augment || augment->cursor == 0)
1263 return 0;
1264
1265 if (base->cursor + augment->cursor >= base->size_items) {
1266 drmModeAtomicReqItemPtr new;
1267 int saved_size = base->size_items;
1268
1269 base->size_items = base->cursor + augment->cursor;
1270 new = realloc(base->items,
1271 base->size_items * sizeof(*base->items));
1272 if (!new) {
1273 base->size_items = saved_size;
1274 return -ENOMEM;
1275 }
1276 base->items = new;
1277 }
1278
1279 memcpy(&base->items[base->cursor], augment->items,
1280 augment->cursor * sizeof(*augment->items));
1281 base->cursor += augment->cursor;
1282
1283 return 0;
1284}
1285
1286int drmModeAtomicGetCursor(drmModeAtomicReqPtr req)
1287{
Emil Velikoved3c6652015-09-05 17:20:53 +01001288 if (!req)
1289 return -EINVAL;
Ville Syrjäläed44e0b2015-06-22 17:26:02 +01001290 return req->cursor;
1291}
1292
1293void drmModeAtomicSetCursor(drmModeAtomicReqPtr req, int cursor)
1294{
Emil Velikoved3c6652015-09-05 17:20:53 +01001295 if (req)
1296 req->cursor = cursor;
Ville Syrjäläed44e0b2015-06-22 17:26:02 +01001297}
1298
1299int drmModeAtomicAddProperty(drmModeAtomicReqPtr req,
1300 uint32_t object_id,
1301 uint32_t property_id,
1302 uint64_t value)
1303{
Emil Velikoved3c6652015-09-05 17:20:53 +01001304 if (!req)
1305 return -EINVAL;
1306
Ville Syrjäläed44e0b2015-06-22 17:26:02 +01001307 if (req->cursor >= req->size_items) {
1308 drmModeAtomicReqItemPtr new;
1309
1310 req->size_items += 16;
1311 new = realloc(req->items, req->size_items * sizeof(*req->items));
1312 if (!new) {
1313 req->size_items -= 16;
1314 return -ENOMEM;
1315 }
1316 req->items = new;
1317 }
1318
1319 req->items[req->cursor].object_id = object_id;
1320 req->items[req->cursor].property_id = property_id;
1321 req->items[req->cursor].value = value;
1322 req->cursor++;
1323
1324 return req->cursor;
1325}
1326
1327void drmModeAtomicFree(drmModeAtomicReqPtr req)
1328{
1329 if (!req)
1330 return;
1331
1332 if (req->items)
1333 drmFree(req->items);
1334 drmFree(req);
1335}
1336
1337static int sort_req_list(const void *misc, const void *other)
1338{
1339 const drmModeAtomicReqItem *first = misc;
1340 const drmModeAtomicReqItem *second = other;
1341
1342 if (first->object_id < second->object_id)
1343 return -1;
1344 else if (first->object_id > second->object_id)
1345 return 1;
1346 else
1347 return second->property_id - first->property_id;
1348}
1349
1350int drmModeAtomicCommit(int fd, drmModeAtomicReqPtr req, uint32_t flags,
1351 void *user_data)
1352{
Chris Wilson1a6efaf2015-07-21 13:46:45 +01001353 drmModeAtomicReqPtr sorted;
Ville Syrjäläed44e0b2015-06-22 17:26:02 +01001354 struct drm_mode_atomic atomic;
1355 uint32_t *objs_ptr = NULL;
1356 uint32_t *count_props_ptr = NULL;
1357 uint32_t *props_ptr = NULL;
1358 uint64_t *prop_values_ptr = NULL;
1359 uint32_t last_obj_id = 0;
1360 uint32_t i;
1361 int obj_idx = -1;
1362 int ret = -1;
1363
Emil Velikoved3c6652015-09-05 17:20:53 +01001364 if (!req)
1365 return -EINVAL;
1366
Chris Wilson1a6efaf2015-07-21 13:46:45 +01001367 if (req->cursor == 0)
1368 return 0;
1369
1370 sorted = drmModeAtomicDuplicate(req);
1371 if (sorted == NULL)
Ville Syrjäläed44e0b2015-06-22 17:26:02 +01001372 return -ENOMEM;
1373
1374 memclear(atomic);
1375
1376 /* Sort the list by object ID, then by property ID. */
1377 qsort(sorted->items, sorted->cursor, sizeof(*sorted->items),
1378 sort_req_list);
1379
1380 /* Now the list is sorted, eliminate duplicate property sets. */
1381 for (i = 0; i < sorted->cursor; i++) {
1382 if (sorted->items[i].object_id != last_obj_id) {
1383 atomic.count_objs++;
1384 last_obj_id = sorted->items[i].object_id;
1385 }
1386
1387 if (i == sorted->cursor - 1)
1388 continue;
1389
1390 if (sorted->items[i].object_id != sorted->items[i + 1].object_id ||
1391 sorted->items[i].property_id != sorted->items[i + 1].property_id)
1392 continue;
1393
1394 memmove(&sorted->items[i], &sorted->items[i + 1],
1395 (sorted->cursor - i - 1) * sizeof(*sorted->items));
1396 sorted->cursor--;
1397 }
1398
1399 objs_ptr = drmMalloc(atomic.count_objs * sizeof objs_ptr[0]);
1400 if (!objs_ptr) {
1401 errno = ENOMEM;
1402 goto out;
1403 }
1404
1405 count_props_ptr = drmMalloc(atomic.count_objs * sizeof count_props_ptr[0]);
1406 if (!count_props_ptr) {
1407 errno = ENOMEM;
1408 goto out;
1409 }
1410
1411 props_ptr = drmMalloc(sorted->cursor * sizeof props_ptr[0]);
1412 if (!props_ptr) {
1413 errno = ENOMEM;
1414 goto out;
1415 }
1416
1417 prop_values_ptr = drmMalloc(sorted->cursor * sizeof prop_values_ptr[0]);
1418 if (!prop_values_ptr) {
1419 errno = ENOMEM;
1420 goto out;
1421 }
1422
1423 for (i = 0, last_obj_id = 0; i < sorted->cursor; i++) {
1424 if (sorted->items[i].object_id != last_obj_id) {
1425 obj_idx++;
1426 objs_ptr[obj_idx] = sorted->items[i].object_id;
1427 last_obj_id = objs_ptr[obj_idx];
1428 }
1429
1430 count_props_ptr[obj_idx]++;
1431 props_ptr[i] = sorted->items[i].property_id;
1432 prop_values_ptr[i] = sorted->items[i].value;
1433
1434 }
1435
1436 atomic.flags = flags;
1437 atomic.objs_ptr = VOID2U64(objs_ptr);
1438 atomic.count_props_ptr = VOID2U64(count_props_ptr);
1439 atomic.props_ptr = VOID2U64(props_ptr);
1440 atomic.prop_values_ptr = VOID2U64(prop_values_ptr);
1441 atomic.user_data = VOID2U64(user_data);
1442
1443 ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ATOMIC, &atomic);
1444
1445out:
1446 drmFree(objs_ptr);
1447 drmFree(count_props_ptr);
1448 drmFree(props_ptr);
1449 drmFree(prop_values_ptr);
1450 drmModeAtomicFree(sorted);
1451
1452 return ret;
1453}
Daniel Stone32471b22015-06-22 17:26:03 +01001454
1455int
1456drmModeCreatePropertyBlob(int fd, const void *data, size_t length, uint32_t *id)
1457{
1458 struct drm_mode_create_blob create;
1459 int ret;
1460
1461 if (length >= 0xffffffff)
1462 return -ERANGE;
1463
1464 memclear(create);
1465
1466 create.length = length;
1467 create.data = (uintptr_t) data;
1468 create.blob_id = 0;
1469 *id = 0;
1470
1471 ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_CREATEPROPBLOB, &create);
1472 if (ret != 0)
1473 return ret;
1474
1475 *id = create.blob_id;
1476 return 0;
1477}
1478
1479int
1480drmModeDestroyPropertyBlob(int fd, uint32_t id)
1481{
1482 struct drm_mode_destroy_blob destroy;
1483
1484 memclear(destroy);
1485 destroy.blob_id = id;
1486 return DRM_IOCTL(fd, DRM_IOCTL_MODE_DESTROYPROPBLOB, &destroy);
1487}