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