1/*
2 * \file xf86drmMode.h
3 * Header for DRM modesetting interface.
4 *
5 * \author Jakob Bornecrantz <[email protected]>
6 *
7 * \par Acknowledgements:
8 * Feb 2007, Dave Airlie <[email protected]>
9 */
10
11/*
12 * Copyright (c) 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
13 * Copyright (c) 2007-2008 Dave Airlie <[email protected]>
14 * Copyright (c) 2007-2008 Jakob Bornecrantz <[email protected]>
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#ifndef _XF86DRMMODE_H_
37#define _XF86DRMMODE_H_
38
39#if defined(__cplusplus)
40extern "C" {
41#endif
42
43#include <drm.h>
44#include <drm_mode.h>
45#include <stdbool.h>
46#include <stddef.h>
47#include <stdint.h>
48
49/*
50 * This is the interface for modesetting for drm.
51 *
52 * It aims to provide a randr1.2 compatible interface for modesettings in the
53 * kernel, the interface is also meant to be used by libraries like EGL.
54 *
55 * More information can be found in randrproto.txt which can be found here:
56 * http://gitweb.freedesktop.org/?p=xorg/proto/randrproto.git
57 *
58 * There are some major differences to be noted. Unlike the randr1.2 proto you
59 * need to create the memory object of the framebuffer yourself with the ttm
60 * buffer object interface. This object needs to be pinned.
61 */
62
63/*
64 * Feature defines
65 *
66 * Just because these are defined doesn't mean that the kernel
67 * can do that feature, its just for new code vs old libdrm.
68 */
69#define DRM_MODE_FEATURE_KMS 1
70#define DRM_MODE_FEATURE_DIRTYFB 1
71
72
73typedef struct _drmModeRes {
74
75 int count_fbs;
76 uint32_t *fbs;
77
78 int count_crtcs;
79 uint32_t *crtcs;
80
81 int count_connectors;
82 uint32_t *connectors;
83
84 int count_encoders;
85 uint32_t *encoders;
86
87 uint32_t min_width, max_width;
88 uint32_t min_height, max_height;
89} drmModeRes, *drmModeResPtr;
90
91typedef struct _drmModeModeInfo {
92 uint32_t clock;
93 uint16_t hdisplay, hsync_start, hsync_end, htotal, hskew;
94 uint16_t vdisplay, vsync_start, vsync_end, vtotal, vscan;
95
96 uint32_t vrefresh;
97
98 uint32_t flags;
99 uint32_t type;
100 char name[DRM_DISPLAY_MODE_LEN];
101} drmModeModeInfo, *drmModeModeInfoPtr;
102
103typedef struct _drmModeFB {
104 uint32_t fb_id;
105 uint32_t width, height;
106 uint32_t pitch;
107 uint32_t bpp;
108 uint32_t depth;
109 /* driver specific handle */
110 uint32_t handle;
111} drmModeFB, *drmModeFBPtr;
112
113typedef struct _drmModeFB2 {
114 uint32_t fb_id;
115 uint32_t width, height;
116 uint32_t pixel_format; /* fourcc code from drm_fourcc.h */
117 uint64_t modifier; /* applies to all buffers */
118 uint32_t flags;
119
120 /* per-plane GEM handle; may be duplicate entries for multiple planes */
121 uint32_t handles[4];
122 uint32_t pitches[4]; /* bytes */
123 uint32_t offsets[4]; /* bytes */
124} drmModeFB2, *drmModeFB2Ptr;
125
126typedef struct drm_clip_rect drmModeClip, *drmModeClipPtr;
127
128typedef struct _drmModePropertyBlob {
129 uint32_t id;
130 uint32_t length;
131 void *data;
132} drmModePropertyBlobRes, *drmModePropertyBlobPtr;
133
134typedef struct _drmModeProperty {
135 uint32_t prop_id;
136 uint32_t flags;
137 char name[DRM_PROP_NAME_LEN];
138 int count_values;
139 uint64_t *values; /* store the blob lengths */
140 int count_enums;
141 struct drm_mode_property_enum *enums;
142 int count_blobs;
143 uint32_t *blob_ids; /* store the blob IDs */
144} drmModePropertyRes, *drmModePropertyPtr;
145
146static inline uint32_t drmModeGetPropertyType(const drmModePropertyRes *prop)
147{
148 return prop->flags & (DRM_MODE_PROP_LEGACY_TYPE | DRM_MODE_PROP_EXTENDED_TYPE);
149}
150
151static inline int drm_property_type_is(const drmModePropertyPtr property,
152 uint32_t type)
153{
154 return drmModeGetPropertyType(prop: property) == type;
155}
156
157typedef struct _drmModeCrtc {
158 uint32_t crtc_id;
159 uint32_t buffer_id; /**< FB id to connect to 0 = disconnect */
160
161 uint32_t x, y; /**< Position on the framebuffer */
162 uint32_t width, height;
163 int mode_valid;
164 drmModeModeInfo mode;
165
166 int gamma_size; /**< Number of gamma stops */
167
168} drmModeCrtc, *drmModeCrtcPtr;
169
170typedef struct _drmModeEncoder {
171 uint32_t encoder_id;
172 uint32_t encoder_type;
173 uint32_t crtc_id;
174 uint32_t possible_crtcs;
175 uint32_t possible_clones;
176} drmModeEncoder, *drmModeEncoderPtr;
177
178/**
179 * Describes the connector status.
180 *
181 * DRM_MODE_CONNECTED means that the connector has a sink plugged in.
182 * DRM_MODE_DISCONNECTED means the contrary. DRM_MODE_UNKNOWNCONNECTION is used
183 * when it could be either.
184 *
185 * User-space should first try to enable DRM_MODE_CONNECTED connectors and
186 * ignore other connectors. If there are no DRM_MODE_CONNECTED connectors,
187 * user-space should then try to probe and enable DRM_MODE_UNKNOWNCONNECTION
188 * connectors.
189 */
190typedef enum {
191 DRM_MODE_CONNECTED = 1,
192 DRM_MODE_DISCONNECTED = 2,
193 DRM_MODE_UNKNOWNCONNECTION = 3
194} drmModeConnection;
195
196typedef enum {
197 DRM_MODE_SUBPIXEL_UNKNOWN = 1,
198 DRM_MODE_SUBPIXEL_HORIZONTAL_RGB = 2,
199 DRM_MODE_SUBPIXEL_HORIZONTAL_BGR = 3,
200 DRM_MODE_SUBPIXEL_VERTICAL_RGB = 4,
201 DRM_MODE_SUBPIXEL_VERTICAL_BGR = 5,
202 DRM_MODE_SUBPIXEL_NONE = 6
203} drmModeSubPixel;
204
205typedef struct _drmModeConnector {
206 uint32_t connector_id;
207 uint32_t encoder_id; /**< Encoder currently connected to */
208 uint32_t connector_type;
209 uint32_t connector_type_id;
210 drmModeConnection connection;
211 uint32_t mmWidth, mmHeight; /**< HxW in millimeters */
212 drmModeSubPixel subpixel;
213
214 int count_modes;
215 drmModeModeInfoPtr modes;
216
217 int count_props;
218 uint32_t *props; /**< List of property ids */
219 uint64_t *prop_values; /**< List of property values */
220
221 int count_encoders;
222 uint32_t *encoders; /**< List of encoder ids */
223} drmModeConnector, *drmModeConnectorPtr;
224
225#define DRM_PLANE_TYPE_OVERLAY 0
226#define DRM_PLANE_TYPE_PRIMARY 1
227#define DRM_PLANE_TYPE_CURSOR 2
228
229typedef struct _drmModeObjectProperties {
230 uint32_t count_props;
231 uint32_t *props;
232 uint64_t *prop_values;
233} drmModeObjectProperties, *drmModeObjectPropertiesPtr;
234
235typedef struct _drmModeFormatModifierIterator {
236 uint32_t fmt_idx, mod_idx;
237 uint32_t fmt;
238 uint64_t mod;
239} drmModeFormatModifierIterator;
240
241typedef struct _drmModePlane {
242 uint32_t count_formats;
243 uint32_t *formats;
244 uint32_t plane_id;
245
246 uint32_t crtc_id;
247 uint32_t fb_id;
248
249 uint32_t crtc_x, crtc_y;
250 uint32_t x, y;
251
252 uint32_t possible_crtcs;
253 uint32_t gamma_size;
254} drmModePlane, *drmModePlanePtr;
255
256typedef struct _drmModePlaneRes {
257 uint32_t count_planes;
258 uint32_t *planes;
259} drmModePlaneRes, *drmModePlaneResPtr;
260
261extern void drmModeFreeModeInfo( drmModeModeInfoPtr ptr );
262extern void drmModeFreeResources( drmModeResPtr ptr );
263extern void drmModeFreeFB( drmModeFBPtr ptr );
264extern void drmModeFreeFB2( drmModeFB2Ptr ptr );
265extern void drmModeFreeCrtc( drmModeCrtcPtr ptr );
266extern void drmModeFreeConnector( drmModeConnectorPtr ptr );
267extern void drmModeFreeEncoder( drmModeEncoderPtr ptr );
268extern void drmModeFreePlane( drmModePlanePtr ptr );
269extern void drmModeFreePlaneResources(drmModePlaneResPtr ptr);
270
271/**
272 * Check whether the DRM node supports Kernel Mode-Setting.
273 *
274 * Returns 1 if suitable for KMS, 0 otherwise.
275 */
276extern int drmIsKMS(int fd);
277
278/**
279 * Retrieves all of the resources associated with a card.
280 */
281extern drmModeResPtr drmModeGetResources(int fd);
282
283/*
284 * FrameBuffer manipulation.
285 */
286
287/**
288 * Retrieve information about framebuffer bufferId
289 */
290extern drmModeFBPtr drmModeGetFB(int fd, uint32_t bufferId);
291extern drmModeFB2Ptr drmModeGetFB2(int fd, uint32_t bufferId);
292
293/**
294 * Creates a new framebuffer with an buffer object as its scanout buffer.
295 */
296extern int drmModeAddFB(int fd, uint32_t width, uint32_t height, uint8_t depth,
297 uint8_t bpp, uint32_t pitch, uint32_t bo_handle,
298 uint32_t *buf_id);
299/* ...with a specific pixel format */
300extern int drmModeAddFB2(int fd, uint32_t width, uint32_t height,
301 uint32_t pixel_format, const uint32_t bo_handles[4],
302 const uint32_t pitches[4], const uint32_t offsets[4],
303 uint32_t *buf_id, uint32_t flags);
304
305/* ...with format modifiers */
306int drmModeAddFB2WithModifiers(int fd, uint32_t width, uint32_t height,
307 uint32_t pixel_format, const uint32_t bo_handles[4],
308 const uint32_t pitches[4], const uint32_t offsets[4],
309 const uint64_t modifier[4], uint32_t *buf_id,
310 uint32_t flags);
311
312/**
313 * Destroies the given framebuffer.
314 */
315extern int drmModeRmFB(int fd, uint32_t bufferId);
316
317/**
318 * Mark a region of a framebuffer as dirty.
319 */
320extern int drmModeDirtyFB(int fd, uint32_t bufferId,
321 drmModeClipPtr clips, uint32_t num_clips);
322
323
324/*
325 * Crtc functions
326 */
327
328/**
329 * Retrieve information about the ctrt crtcId
330 */
331extern drmModeCrtcPtr drmModeGetCrtc(int fd, uint32_t crtcId);
332
333/**
334 * Set the mode on a crtc crtcId with the given mode modeId.
335 */
336int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
337 uint32_t x, uint32_t y, uint32_t *connectors, int count,
338 drmModeModeInfoPtr mode);
339
340/*
341 * Cursor functions
342 */
343
344/**
345 * Set the cursor on crtc
346 */
347int drmModeSetCursor(int fd, uint32_t crtcId, uint32_t bo_handle, uint32_t width, uint32_t height);
348
349int drmModeSetCursor2(int fd, uint32_t crtcId, uint32_t bo_handle, uint32_t width, uint32_t height, int32_t hot_x, int32_t hot_y);
350/**
351 * Move the cursor on crtc
352 */
353int drmModeMoveCursor(int fd, uint32_t crtcId, int x, int y);
354
355/**
356 * Encoder functions
357 */
358drmModeEncoderPtr drmModeGetEncoder(int fd, uint32_t encoder_id);
359
360/*
361 * Connector manipulation
362 */
363
364/**
365 * Retrieve all information about the connector connectorId. This will do a
366 * forced probe on the connector to retrieve remote information such as EDIDs
367 * from the display device.
368 */
369extern drmModeConnectorPtr drmModeGetConnector(int fd,
370 uint32_t connectorId);
371
372/**
373 * Retrieve current information, i.e the currently active mode and encoder,
374 * about the connector connectorId. This will not do any probing on the
375 * connector or remote device, and only reports what is currently known.
376 * For the complete set of modes and encoders associated with the connector
377 * use drmModeGetConnector() which will do a probe to determine any display
378 * link changes first.
379 */
380extern drmModeConnectorPtr drmModeGetConnectorCurrent(int fd,
381 uint32_t connector_id);
382
383/**
384 * Get a bitmask of CRTCs a connector is compatible with.
385 *
386 * The bits reference CRTC indices. If the n-th CRTC is compatible with the
387 * connector, the n-th bit will be set. The indices are taken from the array
388 * returned by drmModeGetResources(). The indices are different from the object
389 * IDs.
390 *
391 * Zero is returned on error.
392 */
393extern uint32_t drmModeConnectorGetPossibleCrtcs(int fd,
394 const drmModeConnector *connector);
395
396/**
397 * Attaches the given mode to an connector.
398 */
399extern int drmModeAttachMode(int fd, uint32_t connectorId, drmModeModeInfoPtr mode_info);
400
401/**
402 * Detaches a mode from the connector
403 * must be unused, by the given mode.
404 */
405extern int drmModeDetachMode(int fd, uint32_t connectorId, drmModeModeInfoPtr mode_info);
406
407extern drmModePropertyPtr drmModeGetProperty(int fd, uint32_t propertyId);
408extern void drmModeFreeProperty(drmModePropertyPtr ptr);
409
410extern drmModePropertyBlobPtr drmModeGetPropertyBlob(int fd, uint32_t blob_id);
411extern bool drmModeFormatModifierBlobIterNext(const drmModePropertyBlobRes *blob,
412 drmModeFormatModifierIterator *iter);
413extern void drmModeFreePropertyBlob(drmModePropertyBlobPtr ptr);
414extern int drmModeConnectorSetProperty(int fd, uint32_t connector_id, uint32_t property_id,
415 uint64_t value);
416extern int drmCheckModesettingSupported(const char *busid);
417
418extern int drmModeCrtcSetGamma(int fd, uint32_t crtc_id, uint32_t size,
419 uint16_t *red, uint16_t *green, uint16_t *blue);
420extern int drmModeCrtcGetGamma(int fd, uint32_t crtc_id, uint32_t size,
421 uint16_t *red, uint16_t *green, uint16_t *blue);
422extern int drmModePageFlip(int fd, uint32_t crtc_id, uint32_t fb_id,
423 uint32_t flags, void *user_data);
424extern int drmModePageFlipTarget(int fd, uint32_t crtc_id, uint32_t fb_id,
425 uint32_t flags, void *user_data,
426 uint32_t target_vblank);
427
428extern drmModePlaneResPtr drmModeGetPlaneResources(int fd);
429extern drmModePlanePtr drmModeGetPlane(int fd, uint32_t plane_id);
430extern int drmModeSetPlane(int fd, uint32_t plane_id, uint32_t crtc_id,
431 uint32_t fb_id, uint32_t flags,
432 int32_t crtc_x, int32_t crtc_y,
433 uint32_t crtc_w, uint32_t crtc_h,
434 uint32_t src_x, uint32_t src_y,
435 uint32_t src_w, uint32_t src_h);
436
437extern drmModeObjectPropertiesPtr drmModeObjectGetProperties(int fd,
438 uint32_t object_id,
439 uint32_t object_type);
440extern void drmModeFreeObjectProperties(drmModeObjectPropertiesPtr ptr);
441extern int drmModeObjectSetProperty(int fd, uint32_t object_id,
442 uint32_t object_type, uint32_t property_id,
443 uint64_t value);
444
445
446typedef struct _drmModeAtomicReq drmModeAtomicReq, *drmModeAtomicReqPtr;
447
448extern drmModeAtomicReqPtr drmModeAtomicAlloc(void);
449extern drmModeAtomicReqPtr drmModeAtomicDuplicate(const drmModeAtomicReqPtr req);
450extern int drmModeAtomicMerge(drmModeAtomicReqPtr base,
451 const drmModeAtomicReqPtr augment);
452extern void drmModeAtomicFree(drmModeAtomicReqPtr req);
453extern int drmModeAtomicGetCursor(const drmModeAtomicReqPtr req);
454extern void drmModeAtomicSetCursor(drmModeAtomicReqPtr req, int cursor);
455extern int drmModeAtomicAddProperty(drmModeAtomicReqPtr req,
456 uint32_t object_id,
457 uint32_t property_id,
458 uint64_t value);
459extern int drmModeAtomicCommit(int fd,
460 const drmModeAtomicReqPtr req,
461 uint32_t flags,
462 void *user_data);
463
464extern int drmModeCreatePropertyBlob(int fd, const void *data, size_t size,
465 uint32_t *id);
466extern int drmModeDestroyPropertyBlob(int fd, uint32_t id);
467
468/*
469 * DRM mode lease APIs. These create and manage new drm_masters with
470 * access to a subset of the available DRM resources
471 */
472
473extern int drmModeCreateLease(int fd, const uint32_t *objects, int num_objects, int flags, uint32_t *lessee_id);
474
475typedef struct drmModeLesseeList {
476 uint32_t count;
477 uint32_t lessees[];
478} drmModeLesseeListRes, *drmModeLesseeListPtr;
479
480extern drmModeLesseeListPtr drmModeListLessees(int fd);
481
482typedef struct drmModeObjectList {
483 uint32_t count;
484 uint32_t objects[];
485} drmModeObjectListRes, *drmModeObjectListPtr;
486
487extern drmModeObjectListPtr drmModeGetLease(int fd);
488
489extern int drmModeRevokeLease(int fd, uint32_t lessee_id);
490
491/**
492 * Get a string describing a connector type.
493 *
494 * NULL is returned if the connector type is unsupported. Callers should handle
495 * this gracefully, e.g. by falling back to "Unknown" or printing the raw value.
496 */
497extern const char *
498drmModeGetConnectorTypeName(uint32_t connector_type);
499
500#if defined(__cplusplus)
501}
502#endif
503
504#endif
505

source code of include/xf86drmMode.h