Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2007 Dave Airlie <airlied@linux.ie> |
| 3 | * Copyright (c) 2007 Jakob Bornecrantz <wallbraker@gmail.com> |
| 4 | * Copyright (c) 2008 Red Hat Inc. |
| 5 | * Copyright (c) 2007-2008 Tungsten Graphics, Inc., Cedar Park, TX., USA |
| 6 | * Copyright (c) 2007-2008 Intel Corporation |
| 7 | * |
| 8 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 9 | * copy of this software and associated documentation files (the "Software"), |
| 10 | * to deal in the Software without restriction, including without limitation |
| 11 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 12 | * and/or sell copies of the Software, and to permit persons to whom the |
| 13 | * Software is furnished to do so, subject to the following conditions: |
| 14 | * |
| 15 | * The above copyright notice and this permission notice shall be included in |
| 16 | * all copies or substantial portions of the Software. |
| 17 | * |
| 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 21 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 23 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| 24 | * IN THE SOFTWARE. |
| 25 | */ |
| 26 | |
| 27 | #ifndef _DRM_MODE_H |
| 28 | #define _DRM_MODE_H |
| 29 | |
Gabriel Laskar | abd5422 | 2015-11-30 15:10:43 +0100 | [diff] [blame] | 30 | #include "drm.h" |
Bobby Powers | 10db4e1 | 2012-03-23 15:01:51 -0700 | [diff] [blame] | 31 | |
Emil Velikov | ebbb0e5 | 2016-04-07 18:49:00 +0100 | [diff] [blame] | 32 | #if defined(__cplusplus) |
| 33 | extern "C" { |
| 34 | #endif |
| 35 | |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 36 | #define DRM_DISPLAY_INFO_LEN 32 |
| 37 | #define DRM_CONNECTOR_NAME_LEN 32 |
| 38 | #define DRM_DISPLAY_MODE_LEN 32 |
| 39 | #define DRM_PROP_NAME_LEN 32 |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 40 | |
| 41 | #define DRM_MODE_TYPE_BUILTIN (1<<0) |
| 42 | #define DRM_MODE_TYPE_CLOCK_C ((1<<1) | DRM_MODE_TYPE_BUILTIN) |
| 43 | #define DRM_MODE_TYPE_CRTC_C ((1<<2) | DRM_MODE_TYPE_BUILTIN) |
| 44 | #define DRM_MODE_TYPE_PREFERRED (1<<3) |
| 45 | #define DRM_MODE_TYPE_DEFAULT (1<<4) |
| 46 | #define DRM_MODE_TYPE_USERDEF (1<<5) |
| 47 | #define DRM_MODE_TYPE_DRIVER (1<<6) |
| 48 | |
| 49 | /* Video mode flags */ |
| 50 | /* bit compatible with the xorg definitions. */ |
Damien Lespiau | 4aa17cf | 2013-09-25 16:45:21 +0100 | [diff] [blame] | 51 | #define DRM_MODE_FLAG_PHSYNC (1<<0) |
| 52 | #define DRM_MODE_FLAG_NHSYNC (1<<1) |
| 53 | #define DRM_MODE_FLAG_PVSYNC (1<<2) |
| 54 | #define DRM_MODE_FLAG_NVSYNC (1<<3) |
| 55 | #define DRM_MODE_FLAG_INTERLACE (1<<4) |
| 56 | #define DRM_MODE_FLAG_DBLSCAN (1<<5) |
| 57 | #define DRM_MODE_FLAG_CSYNC (1<<6) |
| 58 | #define DRM_MODE_FLAG_PCSYNC (1<<7) |
| 59 | #define DRM_MODE_FLAG_NCSYNC (1<<8) |
| 60 | #define DRM_MODE_FLAG_HSKEW (1<<9) /* hskew provided */ |
| 61 | #define DRM_MODE_FLAG_BCAST (1<<10) |
| 62 | #define DRM_MODE_FLAG_PIXMUX (1<<11) |
| 63 | #define DRM_MODE_FLAG_DBLCLK (1<<12) |
| 64 | #define DRM_MODE_FLAG_CLKDIV2 (1<<13) |
Damien Lespiau | 5848ad4 | 2013-09-27 12:11:50 +0100 | [diff] [blame] | 65 | /* |
| 66 | * When adding a new stereo mode don't forget to adjust DRM_MODE_FLAGS_3D_MAX |
| 67 | * (define not exposed to user space). |
| 68 | */ |
Damien Lespiau | f7e121b | 2013-09-27 12:11:48 +0100 | [diff] [blame] | 69 | #define DRM_MODE_FLAG_3D_MASK (0x1f<<14) |
| 70 | #define DRM_MODE_FLAG_3D_NONE (0<<14) |
| 71 | #define DRM_MODE_FLAG_3D_FRAME_PACKING (1<<14) |
| 72 | #define DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE (2<<14) |
| 73 | #define DRM_MODE_FLAG_3D_LINE_ALTERNATIVE (3<<14) |
| 74 | #define DRM_MODE_FLAG_3D_SIDE_BY_SIDE_FULL (4<<14) |
| 75 | #define DRM_MODE_FLAG_3D_L_DEPTH (5<<14) |
| 76 | #define DRM_MODE_FLAG_3D_L_DEPTH_GFX_GFX_DEPTH (6<<14) |
| 77 | #define DRM_MODE_FLAG_3D_TOP_AND_BOTTOM (7<<14) |
| 78 | #define DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF (8<<14) |
| 79 | |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 80 | |
| 81 | /* DPMS flags */ |
| 82 | /* bit compatible with the xorg definitions. */ |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 83 | #define DRM_MODE_DPMS_ON 0 |
| 84 | #define DRM_MODE_DPMS_STANDBY 1 |
| 85 | #define DRM_MODE_DPMS_SUSPEND 2 |
| 86 | #define DRM_MODE_DPMS_OFF 3 |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 87 | |
| 88 | /* Scaling mode options */ |
Jesse Barnes | 53bd838 | 2009-07-01 10:04:40 -0700 | [diff] [blame] | 89 | #define DRM_MODE_SCALE_NONE 0 /* Unmodified timing (display or |
| 90 | software can still scale) */ |
| 91 | #define DRM_MODE_SCALE_FULLSCREEN 1 /* Full screen, ignore aspect */ |
| 92 | #define DRM_MODE_SCALE_CENTER 2 /* Centered, no scaling */ |
| 93 | #define DRM_MODE_SCALE_ASPECT 3 /* Full screen, preserve aspect */ |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 94 | |
Vandana Kannan | ff587e4 | 2014-06-11 10:46:48 +0530 | [diff] [blame] | 95 | /* Picture aspect ratio options */ |
| 96 | #define DRM_MODE_PICTURE_ASPECT_NONE 0 |
| 97 | #define DRM_MODE_PICTURE_ASPECT_4_3 1 |
| 98 | #define DRM_MODE_PICTURE_ASPECT_16_9 2 |
| 99 | |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 100 | /* Dithering mode options */ |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 101 | #define DRM_MODE_DITHERING_OFF 0 |
| 102 | #define DRM_MODE_DITHERING_ON 1 |
Ben Skeggs | 92897b5 | 2010-07-16 15:09:17 +1000 | [diff] [blame] | 103 | #define DRM_MODE_DITHERING_AUTO 2 |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 104 | |
Jakob Bornecrantz | 884840a | 2009-12-03 23:25:47 +0000 | [diff] [blame] | 105 | /* Dirty info options */ |
| 106 | #define DRM_MODE_DIRTY_OFF 0 |
| 107 | #define DRM_MODE_DIRTY_ON 1 |
| 108 | #define DRM_MODE_DIRTY_ANNOTATE 2 |
| 109 | |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 110 | struct drm_mode_modeinfo { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 111 | __u32 clock; |
Rob Clark | bbda9c1 | 2015-08-19 19:21:14 -0400 | [diff] [blame] | 112 | __u16 hdisplay; |
| 113 | __u16 hsync_start; |
| 114 | __u16 hsync_end; |
| 115 | __u16 htotal; |
| 116 | __u16 hskew; |
| 117 | __u16 vdisplay; |
| 118 | __u16 vsync_start; |
| 119 | __u16 vsync_end; |
| 120 | __u16 vtotal; |
| 121 | __u16 vscan; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 122 | |
Marcin Kościelnicki | fa5829b | 2010-01-23 10:25:28 +1000 | [diff] [blame] | 123 | __u32 vrefresh; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 124 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 125 | __u32 flags; |
| 126 | __u32 type; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 127 | char name[DRM_DISPLAY_MODE_LEN]; |
| 128 | }; |
| 129 | |
| 130 | struct drm_mode_card_res { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 131 | __u64 fb_id_ptr; |
| 132 | __u64 crtc_id_ptr; |
| 133 | __u64 connector_id_ptr; |
| 134 | __u64 encoder_id_ptr; |
| 135 | __u32 count_fbs; |
| 136 | __u32 count_crtcs; |
| 137 | __u32 count_connectors; |
| 138 | __u32 count_encoders; |
Rob Clark | bbda9c1 | 2015-08-19 19:21:14 -0400 | [diff] [blame] | 139 | __u32 min_width; |
| 140 | __u32 max_width; |
| 141 | __u32 min_height; |
| 142 | __u32 max_height; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 143 | }; |
| 144 | |
| 145 | struct drm_mode_crtc { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 146 | __u64 set_connectors_ptr; |
| 147 | __u32 count_connectors; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 148 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 149 | __u32 crtc_id; /**< Id */ |
| 150 | __u32 fb_id; /**< Id of framebuffer */ |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 151 | |
Rob Clark | bbda9c1 | 2015-08-19 19:21:14 -0400 | [diff] [blame] | 152 | __u32 x; /**< x Position on the framebuffer */ |
| 153 | __u32 y; /**< y Position on the framebuffer */ |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 154 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 155 | __u32 gamma_size; |
| 156 | __u32 mode_valid; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 157 | struct drm_mode_modeinfo mode; |
| 158 | }; |
| 159 | |
Jesse Barnes | 8cf5c91 | 2011-11-14 14:51:27 -0800 | [diff] [blame] | 160 | #define DRM_MODE_PRESENT_TOP_FIELD (1<<0) |
| 161 | #define DRM_MODE_PRESENT_BOTTOM_FIELD (1<<1) |
| 162 | |
| 163 | /* Planes blend with or override other bits on the CRTC */ |
| 164 | struct drm_mode_set_plane { |
| 165 | __u32 plane_id; |
| 166 | __u32 crtc_id; |
| 167 | __u32 fb_id; /* fb object contains surface format type */ |
| 168 | __u32 flags; /* see above flags */ |
| 169 | |
| 170 | /* Signed dest location allows it to be partially off screen */ |
Rob Clark | bbda9c1 | 2015-08-19 19:21:14 -0400 | [diff] [blame] | 171 | __s32 crtc_x; |
| 172 | __s32 crtc_y; |
| 173 | __u32 crtc_w; |
| 174 | __u32 crtc_h; |
Jesse Barnes | 8cf5c91 | 2011-11-14 14:51:27 -0800 | [diff] [blame] | 175 | |
| 176 | /* Source values are 16.16 fixed point */ |
Rob Clark | bbda9c1 | 2015-08-19 19:21:14 -0400 | [diff] [blame] | 177 | __u32 src_x; |
| 178 | __u32 src_y; |
| 179 | __u32 src_h; |
| 180 | __u32 src_w; |
Jesse Barnes | 8cf5c91 | 2011-11-14 14:51:27 -0800 | [diff] [blame] | 181 | }; |
| 182 | |
| 183 | struct drm_mode_get_plane { |
| 184 | __u32 plane_id; |
| 185 | |
| 186 | __u32 crtc_id; |
| 187 | __u32 fb_id; |
| 188 | |
| 189 | __u32 possible_crtcs; |
| 190 | __u32 gamma_size; |
| 191 | |
| 192 | __u32 count_format_types; |
| 193 | __u64 format_type_ptr; |
| 194 | }; |
| 195 | |
| 196 | struct drm_mode_get_plane_res { |
| 197 | __u64 plane_id_ptr; |
| 198 | __u32 count_planes; |
| 199 | }; |
| 200 | |
| 201 | #define DRM_MODE_ENCODER_NONE 0 |
| 202 | #define DRM_MODE_ENCODER_DAC 1 |
| 203 | #define DRM_MODE_ENCODER_TMDS 2 |
| 204 | #define DRM_MODE_ENCODER_LVDS 3 |
| 205 | #define DRM_MODE_ENCODER_TVDAC 4 |
Thomas Hellstrom | a7331e5 | 2011-10-22 10:36:19 +0200 | [diff] [blame] | 206 | #define DRM_MODE_ENCODER_VIRTUAL 5 |
Shobhit Kumar | b892327 | 2013-08-27 15:12:13 +0300 | [diff] [blame] | 207 | #define DRM_MODE_ENCODER_DSI 6 |
Dave Airlie | 182407a | 2014-05-02 11:09:54 +1000 | [diff] [blame] | 208 | #define DRM_MODE_ENCODER_DPMST 7 |
Eric Anholt | 0b27c02 | 2016-03-18 12:34:59 -0700 | [diff] [blame] | 209 | #define DRM_MODE_ENCODER_DPI 8 |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 210 | |
| 211 | struct drm_mode_get_encoder { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 212 | __u32 encoder_id; |
| 213 | __u32 encoder_type; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 214 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 215 | __u32 crtc_id; /**< Id of crtc */ |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 216 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 217 | __u32 possible_crtcs; |
| 218 | __u32 possible_clones; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 219 | }; |
| 220 | |
| 221 | /* This is for connectors with multiple signal types. */ |
| 222 | /* Try to match DRM_MODE_CONNECTOR_X as closely as possible. */ |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 223 | #define DRM_MODE_SUBCONNECTOR_Automatic 0 |
| 224 | #define DRM_MODE_SUBCONNECTOR_Unknown 0 |
| 225 | #define DRM_MODE_SUBCONNECTOR_DVID 3 |
| 226 | #define DRM_MODE_SUBCONNECTOR_DVIA 4 |
| 227 | #define DRM_MODE_SUBCONNECTOR_Composite 5 |
| 228 | #define DRM_MODE_SUBCONNECTOR_SVIDEO 6 |
| 229 | #define DRM_MODE_SUBCONNECTOR_Component 8 |
Francisco Jerez | aeaa1ad | 2009-08-02 04:19:19 +0200 | [diff] [blame] | 230 | #define DRM_MODE_SUBCONNECTOR_SCART 9 |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 231 | |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 232 | #define DRM_MODE_CONNECTOR_Unknown 0 |
| 233 | #define DRM_MODE_CONNECTOR_VGA 1 |
| 234 | #define DRM_MODE_CONNECTOR_DVII 2 |
| 235 | #define DRM_MODE_CONNECTOR_DVID 3 |
| 236 | #define DRM_MODE_CONNECTOR_DVIA 4 |
| 237 | #define DRM_MODE_CONNECTOR_Composite 5 |
| 238 | #define DRM_MODE_CONNECTOR_SVIDEO 6 |
| 239 | #define DRM_MODE_CONNECTOR_LVDS 7 |
| 240 | #define DRM_MODE_CONNECTOR_Component 8 |
| 241 | #define DRM_MODE_CONNECTOR_9PinDIN 9 |
| 242 | #define DRM_MODE_CONNECTOR_DisplayPort 10 |
| 243 | #define DRM_MODE_CONNECTOR_HDMIA 11 |
| 244 | #define DRM_MODE_CONNECTOR_HDMIB 12 |
Francisco Jerez | 74bd3c2 | 2009-08-02 04:19:18 +0200 | [diff] [blame] | 245 | #define DRM_MODE_CONNECTOR_TV 13 |
Alex Deucher | 7970e67 | 2010-01-07 13:47:47 -0500 | [diff] [blame] | 246 | #define DRM_MODE_CONNECTOR_eDP 14 |
Thomas Hellstrom | a7331e5 | 2011-10-22 10:36:19 +0200 | [diff] [blame] | 247 | #define DRM_MODE_CONNECTOR_VIRTUAL 15 |
Shobhit Kumar | b892327 | 2013-08-27 15:12:13 +0300 | [diff] [blame] | 248 | #define DRM_MODE_CONNECTOR_DSI 16 |
Eric Anholt | 0b27c02 | 2016-03-18 12:34:59 -0700 | [diff] [blame] | 249 | #define DRM_MODE_CONNECTOR_DPI 17 |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 250 | |
| 251 | struct drm_mode_get_connector { |
| 252 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 253 | __u64 encoders_ptr; |
| 254 | __u64 modes_ptr; |
| 255 | __u64 props_ptr; |
| 256 | __u64 prop_values_ptr; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 257 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 258 | __u32 count_modes; |
| 259 | __u32 count_props; |
| 260 | __u32 count_encoders; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 261 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 262 | __u32 encoder_id; /**< Current Encoder */ |
| 263 | __u32 connector_id; /**< Id */ |
| 264 | __u32 connector_type; |
| 265 | __u32 connector_type_id; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 266 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 267 | __u32 connection; |
Rob Clark | bbda9c1 | 2015-08-19 19:21:14 -0400 | [diff] [blame] | 268 | __u32 mm_width; /**< width in millimeters */ |
| 269 | __u32 mm_height; /**< height in millimeters */ |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 270 | __u32 subpixel; |
Chris Wilson | bc5bd37 | 2013-10-16 09:49:02 +0100 | [diff] [blame] | 271 | |
| 272 | __u32 pad; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 273 | }; |
| 274 | |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 275 | #define DRM_MODE_PROP_PENDING (1<<0) |
| 276 | #define DRM_MODE_PROP_RANGE (1<<1) |
| 277 | #define DRM_MODE_PROP_IMMUTABLE (1<<2) |
| 278 | #define DRM_MODE_PROP_ENUM (1<<3) /* enumerated type with text strings */ |
| 279 | #define DRM_MODE_PROP_BLOB (1<<4) |
Rob Clark | 49e2754 | 2012-05-17 02:23:26 -0600 | [diff] [blame] | 280 | #define DRM_MODE_PROP_BITMASK (1<<5) /* bitmask of enumerated types */ |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 281 | |
Rob Clark | 5ea22f2 | 2014-05-30 11:34:01 -0400 | [diff] [blame] | 282 | /* non-extended types: legacy bitmask, one bit per type: */ |
| 283 | #define DRM_MODE_PROP_LEGACY_TYPE ( \ |
| 284 | DRM_MODE_PROP_RANGE | \ |
| 285 | DRM_MODE_PROP_ENUM | \ |
| 286 | DRM_MODE_PROP_BLOB | \ |
| 287 | DRM_MODE_PROP_BITMASK) |
| 288 | |
| 289 | /* extended-types: rather than continue to consume a bit per type, |
| 290 | * grab a chunk of the bits to use as integer type id. |
| 291 | */ |
| 292 | #define DRM_MODE_PROP_EXTENDED_TYPE 0x0000ffc0 |
| 293 | #define DRM_MODE_PROP_TYPE(n) ((n) << 6) |
Rob Clark | 98f75de | 2014-05-30 11:37:03 -0400 | [diff] [blame] | 294 | #define DRM_MODE_PROP_OBJECT DRM_MODE_PROP_TYPE(1) |
Rob Clark | ebc44cf | 2012-09-12 22:22:31 -0500 | [diff] [blame] | 295 | #define DRM_MODE_PROP_SIGNED_RANGE DRM_MODE_PROP_TYPE(2) |
Rob Clark | 5ea22f2 | 2014-05-30 11:34:01 -0400 | [diff] [blame] | 296 | |
Rob Clark | 88a48e2 | 2014-12-18 16:01:50 -0500 | [diff] [blame] | 297 | /* the PROP_ATOMIC flag is used to hide properties from userspace that |
| 298 | * is not aware of atomic properties. This is mostly to work around |
| 299 | * older userspace (DDX drivers) that read/write each prop they find, |
| 300 | * witout being aware that this could be triggering a lengthy modeset. |
| 301 | */ |
| 302 | #define DRM_MODE_PROP_ATOMIC 0x80000000 |
| 303 | |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 304 | struct drm_mode_property_enum { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 305 | __u64 value; |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 306 | char name[DRM_PROP_NAME_LEN]; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 307 | }; |
| 308 | |
| 309 | struct drm_mode_get_property { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 310 | __u64 values_ptr; /* values and blob lengths */ |
| 311 | __u64 enum_blob_ptr; /* enum and blob id ptrs */ |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 312 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 313 | __u32 prop_id; |
| 314 | __u32 flags; |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 315 | char name[DRM_PROP_NAME_LEN]; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 316 | |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 317 | __u32 count_values; |
Daniel Vetter | 3758b34 | 2014-11-19 18:38:10 +0100 | [diff] [blame] | 318 | /* This is only used to count enum values, not blobs. The _blobs is |
| 319 | * simply because of a historical reason, i.e. backwards compat. */ |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 320 | __u32 count_enum_blobs; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 321 | }; |
| 322 | |
| 323 | struct drm_mode_connector_set_property { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 324 | __u64 value; |
| 325 | __u32 prop_id; |
| 326 | __u32 connector_id; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 327 | }; |
| 328 | |
Daniel Vetter | 8812f38 | 2016-03-30 16:19:44 +0200 | [diff] [blame] | 329 | #define DRM_MODE_OBJECT_CRTC 0xcccccccc |
| 330 | #define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0 |
| 331 | #define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0 |
| 332 | #define DRM_MODE_OBJECT_MODE 0xdededede |
| 333 | #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0 |
| 334 | #define DRM_MODE_OBJECT_FB 0xfbfbfbfb |
| 335 | #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb |
| 336 | #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee |
| 337 | #define DRM_MODE_OBJECT_ANY 0 |
| 338 | |
Paulo Zanoni | c543188 | 2012-05-15 18:09:02 -0300 | [diff] [blame] | 339 | struct drm_mode_obj_get_properties { |
| 340 | __u64 props_ptr; |
| 341 | __u64 prop_values_ptr; |
| 342 | __u32 count_props; |
| 343 | __u32 obj_id; |
| 344 | __u32 obj_type; |
| 345 | }; |
| 346 | |
| 347 | struct drm_mode_obj_set_property { |
| 348 | __u64 value; |
| 349 | __u32 prop_id; |
| 350 | __u32 obj_id; |
| 351 | __u32 obj_type; |
| 352 | }; |
| 353 | |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 354 | struct drm_mode_get_blob { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 355 | __u32 blob_id; |
| 356 | __u32 length; |
| 357 | __u64 data; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 358 | }; |
| 359 | |
| 360 | struct drm_mode_fb_cmd { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 361 | __u32 fb_id; |
Rob Clark | bbda9c1 | 2015-08-19 19:21:14 -0400 | [diff] [blame] | 362 | __u32 width; |
| 363 | __u32 height; |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 364 | __u32 pitch; |
| 365 | __u32 bpp; |
| 366 | __u32 depth; |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 367 | /* driver specific handle */ |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 368 | __u32 handle; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 369 | }; |
| 370 | |
Ville Syrjälä | cc5b6f0 | 2011-12-20 00:06:38 +0200 | [diff] [blame] | 371 | #define DRM_MODE_FB_INTERLACED (1<<0) /* for interlaced framebuffers */ |
Rob Clark | e3eb325 | 2015-02-05 14:41:52 +0000 | [diff] [blame] | 372 | #define DRM_MODE_FB_MODIFIERS (1<<1) /* enables ->modifer[] */ |
Jesse Barnes | 308e5bc | 2011-11-14 14:51:28 -0800 | [diff] [blame] | 373 | |
| 374 | struct drm_mode_fb_cmd2 { |
| 375 | __u32 fb_id; |
Rob Clark | bbda9c1 | 2015-08-19 19:21:14 -0400 | [diff] [blame] | 376 | __u32 width; |
| 377 | __u32 height; |
Jesse Barnes | 308e5bc | 2011-11-14 14:51:28 -0800 | [diff] [blame] | 378 | __u32 pixel_format; /* fourcc code from drm_fourcc.h */ |
| 379 | __u32 flags; /* see above flags */ |
| 380 | |
| 381 | /* |
| 382 | * In case of planar formats, this ioctl allows up to 4 |
Rob Clark | ae28290 | 2014-12-10 12:17:41 -0500 | [diff] [blame] | 383 | * buffer objects with offsets and pitches per plane. |
Jesse Barnes | 308e5bc | 2011-11-14 14:51:28 -0800 | [diff] [blame] | 384 | * The pitch and offset order is dictated by the fourcc, |
| 385 | * e.g. NV12 (http://fourcc.org/yuv.php#NV12) is described as: |
| 386 | * |
| 387 | * YUV 4:2:0 image with a plane of 8 bit Y samples |
| 388 | * followed by an interleaved U/V plane containing |
| 389 | * 8 bit 2x2 subsampled colour difference samples. |
| 390 | * |
Rob Clark | ae28290 | 2014-12-10 12:17:41 -0500 | [diff] [blame] | 391 | * So it would consist of Y as offsets[0] and UV as |
| 392 | * offsets[1]. Note that offsets[0] will generally |
| 393 | * be 0 (but this is not required). |
Rob Clark | e3eb325 | 2015-02-05 14:41:52 +0000 | [diff] [blame] | 394 | * |
| 395 | * To accommodate tiled, compressed, etc formats, a per-plane |
| 396 | * modifier can be specified. The default value of zero |
| 397 | * indicates "native" format as specified by the fourcc. |
| 398 | * Vendor specific modifier token. This allows, for example, |
| 399 | * different tiling/swizzling pattern on different planes. |
| 400 | * See discussion above of DRM_FORMAT_MOD_xxx. |
Jesse Barnes | 308e5bc | 2011-11-14 14:51:28 -0800 | [diff] [blame] | 401 | */ |
| 402 | __u32 handles[4]; |
| 403 | __u32 pitches[4]; /* pitch for each plane */ |
| 404 | __u32 offsets[4]; /* offset of each plane */ |
Rob Clark | e3eb325 | 2015-02-05 14:41:52 +0000 | [diff] [blame] | 405 | __u64 modifier[4]; /* ie, tiling, compressed (per plane) */ |
Jesse Barnes | 308e5bc | 2011-11-14 14:51:28 -0800 | [diff] [blame] | 406 | }; |
| 407 | |
Jakob Bornecrantz | 884840a | 2009-12-03 23:25:47 +0000 | [diff] [blame] | 408 | #define DRM_MODE_FB_DIRTY_ANNOTATE_COPY 0x01 |
| 409 | #define DRM_MODE_FB_DIRTY_ANNOTATE_FILL 0x02 |
| 410 | #define DRM_MODE_FB_DIRTY_FLAGS 0x03 |
| 411 | |
Xi Wang | a5cd335 | 2011-11-23 01:12:01 -0500 | [diff] [blame] | 412 | #define DRM_MODE_FB_DIRTY_MAX_CLIPS 256 |
| 413 | |
Jakob Bornecrantz | 884840a | 2009-12-03 23:25:47 +0000 | [diff] [blame] | 414 | /* |
| 415 | * Mark a region of a framebuffer as dirty. |
| 416 | * |
| 417 | * Some hardware does not automatically update display contents |
| 418 | * as a hardware or software draw to a framebuffer. This ioctl |
| 419 | * allows userspace to tell the kernel and the hardware what |
| 420 | * regions of the framebuffer have changed. |
| 421 | * |
| 422 | * The kernel or hardware is free to update more then just the |
| 423 | * region specified by the clip rects. The kernel or hardware |
| 424 | * may also delay and/or coalesce several calls to dirty into a |
| 425 | * single update. |
| 426 | * |
| 427 | * Userspace may annotate the updates, the annotates are a |
| 428 | * promise made by the caller that the change is either a copy |
| 429 | * of pixels or a fill of a single color in the region specified. |
| 430 | * |
| 431 | * If the DRM_MODE_FB_DIRTY_ANNOTATE_COPY flag is given then |
| 432 | * the number of updated regions are half of num_clips given, |
| 433 | * where the clip rects are paired in src and dst. The width and |
| 434 | * height of each one of the pairs must match. |
| 435 | * |
| 436 | * If the DRM_MODE_FB_DIRTY_ANNOTATE_FILL flag is given the caller |
| 437 | * promises that the region specified of the clip rects is filled |
| 438 | * completely with a single color as given in the color argument. |
| 439 | */ |
| 440 | |
| 441 | struct drm_mode_fb_dirty_cmd { |
| 442 | __u32 fb_id; |
| 443 | __u32 flags; |
| 444 | __u32 color; |
| 445 | __u32 num_clips; |
| 446 | __u64 clips_ptr; |
| 447 | }; |
| 448 | |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 449 | struct drm_mode_mode_cmd { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 450 | __u32 connector_id; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 451 | struct drm_mode_modeinfo mode; |
| 452 | }; |
| 453 | |
Jakob Bornecrantz | 7c4eaca | 2012-08-16 08:29:03 +0000 | [diff] [blame] | 454 | #define DRM_MODE_CURSOR_BO 0x01 |
| 455 | #define DRM_MODE_CURSOR_MOVE 0x02 |
| 456 | #define DRM_MODE_CURSOR_FLAGS 0x03 |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 457 | |
| 458 | /* |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 459 | * depending on the value in flags different members are used. |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 460 | * |
| 461 | * CURSOR_BO uses |
Christopher Harvey | 715f59c | 2013-04-05 15:28:32 +0000 | [diff] [blame] | 462 | * crtc_id |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 463 | * width |
| 464 | * height |
Christopher Harvey | 715f59c | 2013-04-05 15:28:32 +0000 | [diff] [blame] | 465 | * handle - if 0 turns the cursor off |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 466 | * |
| 467 | * CURSOR_MOVE uses |
Christopher Harvey | 715f59c | 2013-04-05 15:28:32 +0000 | [diff] [blame] | 468 | * crtc_id |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 469 | * x |
| 470 | * y |
| 471 | */ |
| 472 | struct drm_mode_cursor { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 473 | __u32 flags; |
| 474 | __u32 crtc_id; |
| 475 | __s32 x; |
| 476 | __s32 y; |
| 477 | __u32 width; |
| 478 | __u32 height; |
Jakob Bornecrantz | e0c8463 | 2008-12-19 14:50:50 +1000 | [diff] [blame] | 479 | /* driver specific handle */ |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 480 | __u32 handle; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 481 | }; |
| 482 | |
Dave Airlie | 4c813d4 | 2013-06-20 11:48:52 +1000 | [diff] [blame] | 483 | struct drm_mode_cursor2 { |
| 484 | __u32 flags; |
| 485 | __u32 crtc_id; |
| 486 | __s32 x; |
| 487 | __s32 y; |
| 488 | __u32 width; |
| 489 | __u32 height; |
| 490 | /* driver specific handle */ |
| 491 | __u32 handle; |
| 492 | __s32 hot_x; |
| 493 | __s32 hot_y; |
| 494 | }; |
| 495 | |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 496 | struct drm_mode_crtc_lut { |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 497 | __u32 crtc_id; |
| 498 | __u32 gamma_size; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 499 | |
| 500 | /* pointers to arrays */ |
Arnd Bergmann | 1d7f83d | 2009-02-26 00:51:42 +0100 | [diff] [blame] | 501 | __u64 red; |
| 502 | __u64 green; |
| 503 | __u64 blue; |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 504 | }; |
| 505 | |
Lionel Landwerlin | 5488dc1 | 2016-02-26 17:05:00 +0000 | [diff] [blame] | 506 | struct drm_color_ctm { |
| 507 | /* Conversion matrix in S31.32 format. */ |
| 508 | __s64 matrix[9]; |
| 509 | }; |
| 510 | |
| 511 | struct drm_color_lut { |
| 512 | /* |
| 513 | * Data is U0.16 fixed point format. |
| 514 | */ |
| 515 | __u16 red; |
| 516 | __u16 green; |
| 517 | __u16 blue; |
| 518 | __u16 reserved; |
| 519 | }; |
| 520 | |
Kristian Høgsberg | d91d8a3 | 2009-11-17 12:43:55 -0500 | [diff] [blame] | 521 | #define DRM_MODE_PAGE_FLIP_EVENT 0x01 |
Keith Packard | 9bba0c4 | 2013-07-22 18:49:59 -0700 | [diff] [blame] | 522 | #define DRM_MODE_PAGE_FLIP_ASYNC 0x02 |
| 523 | #define DRM_MODE_PAGE_FLIP_FLAGS (DRM_MODE_PAGE_FLIP_EVENT|DRM_MODE_PAGE_FLIP_ASYNC) |
Kristian Høgsberg | d91d8a3 | 2009-11-17 12:43:55 -0500 | [diff] [blame] | 524 | |
| 525 | /* |
| 526 | * Request a page flip on the specified crtc. |
| 527 | * |
| 528 | * This ioctl will ask KMS to schedule a page flip for the specified |
| 529 | * crtc. Once any pending rendering targeting the specified fb (as of |
| 530 | * ioctl time) has completed, the crtc will be reprogrammed to display |
| 531 | * that fb after the next vertical refresh. The ioctl returns |
| 532 | * immediately, but subsequent rendering to the current fb will block |
| 533 | * in the execbuffer ioctl until the page flip happens. If a page |
| 534 | * flip is already pending as the ioctl is called, EBUSY will be |
| 535 | * returned. |
| 536 | * |
Keith Packard | 9bba0c4 | 2013-07-22 18:49:59 -0700 | [diff] [blame] | 537 | * Flag DRM_MODE_PAGE_FLIP_EVENT requests that drm sends back a vblank |
| 538 | * event (see drm.h: struct drm_event_vblank) when the page flip is |
| 539 | * done. The user_data field passed in with this ioctl will be |
| 540 | * returned as the user_data field in the vblank event struct. |
| 541 | * |
| 542 | * Flag DRM_MODE_PAGE_FLIP_ASYNC requests that the flip happen |
| 543 | * 'as soon as possible', meaning that it not delay waiting for vblank. |
| 544 | * This may cause tearing on the screen. |
Kristian Høgsberg | d91d8a3 | 2009-11-17 12:43:55 -0500 | [diff] [blame] | 545 | * |
| 546 | * The reserved field must be zero until we figure out something |
| 547 | * clever to use it for. |
| 548 | */ |
| 549 | |
| 550 | struct drm_mode_crtc_page_flip { |
| 551 | __u32 crtc_id; |
| 552 | __u32 fb_id; |
| 553 | __u32 flags; |
| 554 | __u32 reserved; |
| 555 | __u64 user_data; |
| 556 | }; |
| 557 | |
Dave Airlie | ff72145b | 2011-02-07 12:16:14 +1000 | [diff] [blame] | 558 | /* create a dumb scanout buffer */ |
| 559 | struct drm_mode_create_dumb { |
Mikko Rapeli | 05623b7 | 2014-08-31 13:01:09 +0200 | [diff] [blame] | 560 | __u32 height; |
| 561 | __u32 width; |
| 562 | __u32 bpp; |
| 563 | __u32 flags; |
Dave Airlie | ff72145b | 2011-02-07 12:16:14 +1000 | [diff] [blame] | 564 | /* handle, pitch, size will be returned */ |
Mikko Rapeli | 05623b7 | 2014-08-31 13:01:09 +0200 | [diff] [blame] | 565 | __u32 handle; |
| 566 | __u32 pitch; |
| 567 | __u64 size; |
Dave Airlie | ff72145b | 2011-02-07 12:16:14 +1000 | [diff] [blame] | 568 | }; |
| 569 | |
| 570 | /* set up for mmap of a dumb scanout buffer */ |
| 571 | struct drm_mode_map_dumb { |
| 572 | /** Handle for the object being mapped. */ |
| 573 | __u32 handle; |
| 574 | __u32 pad; |
| 575 | /** |
| 576 | * Fake offset to use for subsequent mmap call |
| 577 | * |
| 578 | * This is a fixed-size type for 32/64 compatibility. |
| 579 | */ |
| 580 | __u64 offset; |
| 581 | }; |
| 582 | |
| 583 | struct drm_mode_destroy_dumb { |
Mikko Rapeli | 05623b7 | 2014-08-31 13:01:09 +0200 | [diff] [blame] | 584 | __u32 handle; |
Dave Airlie | ff72145b | 2011-02-07 12:16:14 +1000 | [diff] [blame] | 585 | }; |
| 586 | |
Rob Clark | d34f20d | 2014-12-18 16:01:56 -0500 | [diff] [blame] | 587 | /* page-flip flags are valid, plus: */ |
| 588 | #define DRM_MODE_ATOMIC_TEST_ONLY 0x0100 |
| 589 | #define DRM_MODE_ATOMIC_NONBLOCK 0x0200 |
| 590 | #define DRM_MODE_ATOMIC_ALLOW_MODESET 0x0400 |
| 591 | |
| 592 | #define DRM_MODE_ATOMIC_FLAGS (\ |
| 593 | DRM_MODE_PAGE_FLIP_EVENT |\ |
| 594 | DRM_MODE_PAGE_FLIP_ASYNC |\ |
| 595 | DRM_MODE_ATOMIC_TEST_ONLY |\ |
| 596 | DRM_MODE_ATOMIC_NONBLOCK |\ |
| 597 | DRM_MODE_ATOMIC_ALLOW_MODESET) |
| 598 | |
| 599 | struct drm_mode_atomic { |
| 600 | __u32 flags; |
| 601 | __u32 count_objs; |
| 602 | __u64 objs_ptr; |
| 603 | __u64 count_props_ptr; |
| 604 | __u64 props_ptr; |
| 605 | __u64 prop_values_ptr; |
| 606 | __u64 reserved; |
| 607 | __u64 user_data; |
| 608 | }; |
| 609 | |
Daniel Stone | e2f5d2e | 2015-05-22 13:34:51 +0100 | [diff] [blame] | 610 | /** |
| 611 | * Create a new 'blob' data property, copying length bytes from data pointer, |
| 612 | * and returning new blob ID. |
| 613 | */ |
| 614 | struct drm_mode_create_blob { |
| 615 | /** Pointer to data to copy. */ |
| 616 | __u64 data; |
| 617 | /** Length of data to copy. */ |
| 618 | __u32 length; |
| 619 | /** Return: new property ID. */ |
| 620 | __u32 blob_id; |
| 621 | }; |
| 622 | |
| 623 | /** |
| 624 | * Destroy a user-created blob property. |
| 625 | */ |
| 626 | struct drm_mode_destroy_blob { |
| 627 | __u32 blob_id; |
| 628 | }; |
| 629 | |
Emil Velikov | ebbb0e5 | 2016-04-07 18:49:00 +0100 | [diff] [blame] | 630 | #if defined(__cplusplus) |
| 631 | } |
| 632 | #endif |
| 633 | |
Dave Airlie | f453ba0 | 2008-11-07 14:05:41 -0800 | [diff] [blame] | 634 | #endif |