Rev 5056 | Rev 6082 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1408 | serge | 1 | /* |
2 | * Copyright © 2006 Keith Packard |
||
3 | * Copyright © 2007-2008 Dave Airlie |
||
4 | * Copyright © 2007-2008 Intel Corporation |
||
5 | * Jesse Barnes |
||
6 | * |
||
7 | * Permission is hereby granted, free of charge, to any person obtaining a |
||
8 | * copy of this software and associated documentation files (the "Software"), |
||
9 | * to deal in the Software without restriction, including without limitation |
||
10 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||
11 | * and/or sell copies of the Software, and to permit persons to whom the |
||
12 | * Software is furnished to do so, subject to the following conditions: |
||
13 | * |
||
14 | * The above copyright notice and this permission notice shall be included in |
||
15 | * all copies or substantial portions of the Software. |
||
16 | * |
||
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||
18 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||
20 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR |
||
21 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
||
22 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
||
23 | * OTHER DEALINGS IN THE SOFTWARE. |
||
24 | */ |
||
25 | #ifndef __DRM_CRTC_H__ |
||
26 | #define __DRM_CRTC_H__ |
||
27 | |||
28 | #include |
||
1630 | serge | 29 | #include |
1408 | serge | 30 | #include |
31 | #include |
||
32 | #include |
||
4559 | Serge | 33 | #include |
5270 | serge | 34 | #include |
35 | #include |
||
5056 | serge | 36 | #include |
2967 | Serge | 37 | |
1408 | serge | 38 | struct drm_device; |
39 | struct drm_mode_set; |
||
40 | struct drm_framebuffer; |
||
3031 | serge | 41 | struct drm_object_properties; |
3391 | Serge | 42 | struct drm_file; |
43 | struct drm_clip_rect; |
||
5056 | serge | 44 | struct device_node; |
5270 | serge | 45 | struct fence; |
1408 | serge | 46 | |
47 | #define DRM_MODE_OBJECT_CRTC 0xcccccccc |
||
48 | #define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0 |
||
49 | #define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0 |
||
50 | #define DRM_MODE_OBJECT_MODE 0xdededede |
||
51 | #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0 |
||
52 | #define DRM_MODE_OBJECT_FB 0xfbfbfbfb |
||
53 | #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb |
||
2967 | Serge | 54 | #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee |
4103 | Serge | 55 | #define DRM_MODE_OBJECT_BRIDGE 0xbdbdbdbd |
5056 | serge | 56 | #define DRM_MODE_OBJECT_ANY 0 |
1408 | serge | 57 | |
58 | struct drm_mode_object { |
||
59 | uint32_t id; |
||
60 | uint32_t type; |
||
3031 | serge | 61 | struct drm_object_properties *properties; |
1408 | serge | 62 | }; |
63 | |||
3031 | serge | 64 | #define DRM_OBJECT_MAX_PROPERTY 24 |
65 | struct drm_object_properties { |
||
66 | int count; |
||
67 | uint32_t ids[DRM_OBJECT_MAX_PROPERTY]; |
||
68 | uint64_t values[DRM_OBJECT_MAX_PROPERTY]; |
||
69 | }; |
||
70 | |||
5056 | serge | 71 | static inline int64_t U642I64(uint64_t val) |
72 | { |
||
73 | return (int64_t)*((int64_t *)&val); |
||
74 | } |
||
75 | static inline uint64_t I642U64(int64_t val) |
||
76 | { |
||
77 | return (uint64_t)*((uint64_t *)&val); |
||
78 | } |
||
1408 | serge | 79 | |
5056 | serge | 80 | /* rotation property bits */ |
81 | #define DRM_ROTATE_0 0 |
||
82 | #define DRM_ROTATE_90 1 |
||
83 | #define DRM_ROTATE_180 2 |
||
84 | #define DRM_ROTATE_270 3 |
||
85 | #define DRM_REFLECT_X 4 |
||
86 | #define DRM_REFLECT_Y 5 |
||
1408 | serge | 87 | |
5056 | serge | 88 | enum drm_connector_force { |
89 | DRM_FORCE_UNSPECIFIED, |
||
90 | DRM_FORCE_OFF, |
||
91 | DRM_FORCE_ON, /* force on analog part normally */ |
||
92 | DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */ |
||
1408 | serge | 93 | }; |
94 | |||
5056 | serge | 95 | #include |
4559 | Serge | 96 | |
1408 | serge | 97 | enum drm_connector_status { |
98 | connector_status_connected = 1, |
||
99 | connector_status_disconnected = 2, |
||
100 | connector_status_unknown = 3, |
||
101 | }; |
||
102 | |||
103 | enum subpixel_order { |
||
104 | SubPixelUnknown = 0, |
||
105 | SubPixelHorizontalRGB, |
||
106 | SubPixelHorizontalBGR, |
||
107 | SubPixelVerticalRGB, |
||
108 | SubPixelVerticalBGR, |
||
109 | SubPixelNone, |
||
110 | }; |
||
111 | |||
1964 | serge | 112 | #define DRM_COLOR_FORMAT_RGB444 (1<<0) |
113 | #define DRM_COLOR_FORMAT_YCRCB444 (1<<1) |
||
114 | #define DRM_COLOR_FORMAT_YCRCB422 (1<<2) |
||
1408 | serge | 115 | /* |
116 | * Describes a given display (e.g. CRT or flat panel) and its limitations. |
||
117 | */ |
||
118 | struct drm_display_info { |
||
119 | char name[DRM_DISPLAY_INFO_LEN]; |
||
1964 | serge | 120 | |
1408 | serge | 121 | /* Physical size */ |
122 | unsigned int width_mm; |
||
123 | unsigned int height_mm; |
||
124 | |||
125 | /* Clock limits FIXME: storage format */ |
||
126 | unsigned int min_vfreq, max_vfreq; |
||
127 | unsigned int min_hfreq, max_hfreq; |
||
128 | unsigned int pixel_clock; |
||
1964 | serge | 129 | unsigned int bpc; |
1408 | serge | 130 | |
131 | enum subpixel_order subpixel_order; |
||
1964 | serge | 132 | u32 color_formats; |
1408 | serge | 133 | |
5056 | serge | 134 | /* Mask of supported hdmi deep color modes */ |
135 | u8 edid_hdmi_dc_modes; |
||
136 | |||
2161 | serge | 137 | u8 cea_rev; |
1408 | serge | 138 | }; |
139 | |||
5270 | serge | 140 | /* data corresponds to displayid vend/prod/serial */ |
141 | struct drm_tile_group { |
||
142 | struct kref refcount; |
||
143 | struct drm_device *dev; |
||
144 | int id; |
||
145 | u8 group_data[8]; |
||
146 | }; |
||
147 | |||
1408 | serge | 148 | struct drm_framebuffer_funcs { |
3031 | serge | 149 | /* note: use drm_framebuffer_remove() */ |
1408 | serge | 150 | void (*destroy)(struct drm_framebuffer *framebuffer); |
151 | int (*create_handle)(struct drm_framebuffer *fb, |
||
152 | struct drm_file *file_priv, |
||
153 | unsigned int *handle); |
||
5270 | serge | 154 | /* |
155 | * Optional callback for the dirty fb ioctl. |
||
1408 | serge | 156 | * |
157 | * Userspace can notify the driver via this callback |
||
158 | * that a area of the framebuffer has changed and should |
||
159 | * be flushed to the display hardware. |
||
160 | * |
||
161 | * See documentation in drm_mode.h for the struct |
||
162 | * drm_mode_fb_dirty_cmd for more information as all |
||
163 | * the semantics and arguments have a one to one mapping |
||
164 | * on this function. |
||
165 | */ |
||
1964 | serge | 166 | int (*dirty)(struct drm_framebuffer *framebuffer, |
167 | struct drm_file *file_priv, unsigned flags, |
||
1408 | serge | 168 | unsigned color, struct drm_clip_rect *clips, |
169 | unsigned num_clips); |
||
170 | }; |
||
171 | |||
172 | struct drm_framebuffer { |
||
173 | struct drm_device *dev; |
||
3262 | Serge | 174 | /* |
175 | * Note that the fb is refcounted for the benefit of driver internals, |
||
176 | * for example some hw, disabling a CRTC/plane is asynchronous, and |
||
177 | * scanout does not actually complete until the next vblank. So some |
||
178 | * cleanup (like releasing the reference(s) on the backing GEM bo(s)) |
||
179 | * should be deferred. In cases like this, the driver would like to |
||
180 | * hold a ref to the fb even though it has already been removed from |
||
181 | * userspace perspective. |
||
182 | */ |
||
183 | struct kref refcount; |
||
3391 | Serge | 184 | /* |
185 | * Place on the dev->mode_config.fb_list, access protected by |
||
186 | * dev->mode_config.fb_lock. |
||
187 | */ |
||
1408 | serge | 188 | struct list_head head; |
189 | struct drm_mode_object base; |
||
190 | const struct drm_framebuffer_funcs *funcs; |
||
2967 | Serge | 191 | unsigned int pitches[4]; |
192 | unsigned int offsets[4]; |
||
1408 | serge | 193 | unsigned int width; |
194 | unsigned int height; |
||
195 | /* depth can be 15 or 16 */ |
||
196 | unsigned int depth; |
||
197 | int bits_per_pixel; |
||
198 | int flags; |
||
2967 | Serge | 199 | uint32_t pixel_format; /* fourcc format */ |
1408 | serge | 200 | struct list_head filp_head; |
201 | /* if you are using the helper */ |
||
202 | void *helper_private; |
||
203 | }; |
||
204 | |||
205 | struct drm_property_blob { |
||
206 | struct drm_mode_object base; |
||
207 | struct list_head head; |
||
5270 | serge | 208 | size_t length; |
3031 | serge | 209 | unsigned char data[]; |
1408 | serge | 210 | }; |
211 | |||
212 | struct drm_property_enum { |
||
213 | uint64_t value; |
||
214 | struct list_head head; |
||
215 | char name[DRM_PROP_NAME_LEN]; |
||
216 | }; |
||
217 | |||
218 | struct drm_property { |
||
219 | struct list_head head; |
||
220 | struct drm_mode_object base; |
||
221 | uint32_t flags; |
||
222 | char name[DRM_PROP_NAME_LEN]; |
||
223 | uint32_t num_values; |
||
224 | uint64_t *values; |
||
5056 | serge | 225 | struct drm_device *dev; |
1408 | serge | 226 | |
5270 | serge | 227 | struct list_head enum_list; |
1408 | serge | 228 | }; |
229 | |||
230 | struct drm_crtc; |
||
231 | struct drm_connector; |
||
232 | struct drm_encoder; |
||
233 | struct drm_pending_vblank_event; |
||
2967 | Serge | 234 | struct drm_plane; |
4103 | Serge | 235 | struct drm_bridge; |
5270 | serge | 236 | struct drm_atomic_state; |
1408 | serge | 237 | |
238 | /** |
||
5270 | serge | 239 | * struct drm_crtc_state - mutable CRTC state |
240 | * @enable: whether the CRTC should be enabled, gates all other state |
||
241 | * @mode_changed: for use by helpers and drivers when computing state updates |
||
242 | * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes |
||
243 | * @last_vblank_count: for helpers and drivers to capture the vblank of the |
||
244 | * update to ensure framebuffer cleanup isn't done too early |
||
245 | * @planes_changed: for use by helpers and drivers when computing state updates |
||
246 | * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings |
||
247 | * @mode: current mode timings |
||
248 | * @event: optional pointer to a DRM event to signal upon completion of the |
||
249 | * state update |
||
250 | * @state: backpointer to global drm_atomic_state |
||
251 | */ |
||
252 | struct drm_crtc_state { |
||
253 | bool enable; |
||
254 | |||
255 | /* computed state bits used by helpers and drivers */ |
||
256 | bool planes_changed : 1; |
||
257 | bool mode_changed : 1; |
||
258 | |||
259 | /* attached planes bitmask: |
||
260 | * WARNING: transitional helpers do not maintain plane_mask so |
||
261 | * drivers not converted over to atomic helpers should not rely |
||
262 | * on plane_mask being accurate! |
||
263 | */ |
||
264 | u32 plane_mask; |
||
265 | |||
266 | /* last_vblank_count: for vblank waits before cleanup */ |
||
267 | u32 last_vblank_count; |
||
268 | |||
269 | /* adjusted_mode: for use by helpers and drivers */ |
||
270 | struct drm_display_mode adjusted_mode; |
||
271 | |||
272 | struct drm_display_mode mode; |
||
273 | |||
274 | struct drm_pending_vblank_event *event; |
||
275 | |||
276 | struct drm_atomic_state *state; |
||
277 | }; |
||
278 | |||
279 | /** |
||
280 | * struct drm_crtc_funcs - control CRTCs for a given device |
||
3031 | serge | 281 | * @save: save CRTC state |
282 | * @restore: restore CRTC state |
||
3747 | Serge | 283 | * @reset: reset CRTC after state has been invalidated (e.g. resume) |
3031 | serge | 284 | * @cursor_set: setup the cursor |
5270 | serge | 285 | * @cursor_set2: setup the cursor with hotspot, superseeds @cursor_set if set |
3031 | serge | 286 | * @cursor_move: move the cursor |
1408 | serge | 287 | * @gamma_set: specify color ramp for CRTC |
3031 | serge | 288 | * @destroy: deinit and free object |
289 | * @set_property: called when a property is changed |
||
290 | * @set_config: apply a new CRTC configuration |
||
291 | * @page_flip: initiate a page flip |
||
5270 | serge | 292 | * @atomic_duplicate_state: duplicate the atomic state for this CRTC |
293 | * @atomic_destroy_state: destroy an atomic state for this CRTC |
||
294 | * @atomic_set_property: set a property on an atomic state for this CRTC |
||
1408 | serge | 295 | * |
296 | * The drm_crtc_funcs structure is the central CRTC management structure |
||
297 | * in the DRM. Each CRTC controls one or more connectors (note that the name |
||
298 | * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc. |
||
299 | * connectors, not just CRTs). |
||
300 | * |
||
301 | * Each driver is responsible for filling out this structure at startup time, |
||
302 | * in addition to providing other modesetting features, like i2c and DDC |
||
303 | * bus accessors. |
||
304 | */ |
||
305 | struct drm_crtc_funcs { |
||
306 | /* Save CRTC state */ |
||
307 | void (*save)(struct drm_crtc *crtc); /* suspend? */ |
||
308 | /* Restore CRTC state */ |
||
309 | void (*restore)(struct drm_crtc *crtc); /* resume? */ |
||
1964 | serge | 310 | /* Reset CRTC state */ |
311 | void (*reset)(struct drm_crtc *crtc); |
||
1408 | serge | 312 | |
313 | /* cursor controls */ |
||
314 | int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv, |
||
315 | uint32_t handle, uint32_t width, uint32_t height); |
||
4065 | Serge | 316 | int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv, |
317 | uint32_t handle, uint32_t width, uint32_t height, |
||
318 | int32_t hot_x, int32_t hot_y); |
||
1408 | serge | 319 | int (*cursor_move)(struct drm_crtc *crtc, int x, int y); |
320 | |||
321 | /* Set gamma on the CRTC */ |
||
322 | void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b, |
||
1964 | serge | 323 | uint32_t start, uint32_t size); |
1408 | serge | 324 | /* Object destroy routine */ |
325 | void (*destroy)(struct drm_crtc *crtc); |
||
326 | |||
327 | int (*set_config)(struct drm_mode_set *set); |
||
328 | |||
329 | /* |
||
330 | * Flip to the given framebuffer. This implements the page |
||
1964 | serge | 331 | * flip ioctl described in drm_mode.h, specifically, the |
1408 | serge | 332 | * implementation must return immediately and block all |
333 | * rendering to the current fb until the flip has completed. |
||
334 | * If userspace set the event flag in the ioctl, the event |
||
335 | * argument will point to an event to send back when the flip |
||
336 | * completes, otherwise it will be NULL. |
||
337 | */ |
||
338 | int (*page_flip)(struct drm_crtc *crtc, |
||
339 | struct drm_framebuffer *fb, |
||
4103 | Serge | 340 | struct drm_pending_vblank_event *event, |
341 | uint32_t flags); |
||
3031 | serge | 342 | |
343 | int (*set_property)(struct drm_crtc *crtc, |
||
344 | struct drm_property *property, uint64_t val); |
||
5270 | serge | 345 | |
346 | /* atomic update handling */ |
||
347 | struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc); |
||
348 | void (*atomic_destroy_state)(struct drm_crtc *crtc, |
||
349 | struct drm_crtc_state *state); |
||
350 | int (*atomic_set_property)(struct drm_crtc *crtc, |
||
351 | struct drm_crtc_state *state, |
||
352 | struct drm_property *property, |
||
353 | uint64_t val); |
||
1408 | serge | 354 | }; |
355 | |||
356 | /** |
||
5270 | serge | 357 | * struct drm_crtc - central CRTC control structure |
2967 | Serge | 358 | * @dev: parent DRM device |
5270 | serge | 359 | * @port: OF node used by drm_of_find_possible_crtcs() |
2967 | Serge | 360 | * @head: list management |
5056 | serge | 361 | * @mutex: per-CRTC locking |
2967 | Serge | 362 | * @base: base KMS object for ID tracking etc. |
5056 | serge | 363 | * @primary: primary plane for this CRTC |
364 | * @cursor: cursor plane for this CRTC |
||
5270 | serge | 365 | * @cursor_x: current x position of the cursor, used for universal cursor planes |
366 | * @cursor_y: current y position of the cursor, used for universal cursor planes |
||
1408 | serge | 367 | * @enabled: is this CRTC enabled? |
2967 | Serge | 368 | * @mode: current mode timings |
369 | * @hwmode: mode timings as programmed to hw regs |
||
3031 | serge | 370 | * @invert_dimensions: for purposes of error checking crtc vs fb sizes, |
371 | * invert the width/height of the crtc. This is used if the driver |
||
372 | * is performing 90 or 270 degree rotated scanout |
||
1408 | serge | 373 | * @x: x position on screen |
374 | * @y: y position on screen |
||
375 | * @funcs: CRTC control functions |
||
2967 | Serge | 376 | * @gamma_size: size of gamma ramp |
377 | * @gamma_store: gamma ramp values |
||
378 | * @framedur_ns: precise frame timing |
||
5270 | serge | 379 | * @linedur_ns: precise line timing |
2967 | Serge | 380 | * @pixeldur_ns: precise pixel timing |
381 | * @helper_private: mid-layer private data |
||
3031 | serge | 382 | * @properties: property tracking for this CRTC |
5270 | serge | 383 | * @state: current atomic state for this CRTC |
384 | * @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for |
||
385 | * legacy ioctls |
||
1408 | serge | 386 | * |
387 | * Each CRTC may have one or more connectors associated with it. This structure |
||
388 | * allows the CRTC to be controlled. |
||
389 | */ |
||
390 | struct drm_crtc { |
||
391 | struct drm_device *dev; |
||
5056 | serge | 392 | struct device_node *port; |
1408 | serge | 393 | struct list_head head; |
394 | |||
5270 | serge | 395 | /* |
3391 | Serge | 396 | * crtc mutex |
397 | * |
||
398 | * This provides a read lock for the overall crtc state (mode, dpms |
||
399 | * state, ...) and a write lock for everything which can be update |
||
400 | * without a full modeset (fb, cursor data, ...) |
||
401 | */ |
||
5056 | serge | 402 | struct drm_modeset_lock mutex; |
3391 | Serge | 403 | |
1408 | serge | 404 | struct drm_mode_object base; |
405 | |||
5056 | serge | 406 | /* primary and cursor planes for CRTC */ |
407 | struct drm_plane *primary; |
||
408 | struct drm_plane *cursor; |
||
1408 | serge | 409 | |
5056 | serge | 410 | /* position of cursor plane on crtc */ |
411 | int cursor_x; |
||
412 | int cursor_y; |
||
413 | |||
1408 | serge | 414 | bool enabled; |
415 | |||
1964 | serge | 416 | /* Requested mode from modesetting. */ |
1408 | serge | 417 | struct drm_display_mode mode; |
418 | |||
1964 | serge | 419 | /* Programmed mode in hw, after adjustments for encoders, |
420 | * crtc, panel scaling etc. Needed for timestamping etc. |
||
421 | */ |
||
422 | struct drm_display_mode hwmode; |
||
423 | |||
3031 | serge | 424 | bool invert_dimensions; |
425 | |||
1408 | serge | 426 | int x, y; |
427 | const struct drm_crtc_funcs *funcs; |
||
428 | |||
429 | /* CRTC gamma size for reporting to userspace */ |
||
430 | uint32_t gamma_size; |
||
431 | uint16_t *gamma_store; |
||
432 | |||
1964 | serge | 433 | /* Constants needed for precise vblank and swap timestamping. */ |
4559 | Serge | 434 | int framedur_ns, linedur_ns, pixeldur_ns; |
1964 | serge | 435 | |
1408 | serge | 436 | /* if you are using the helper */ |
437 | void *helper_private; |
||
3031 | serge | 438 | |
439 | struct drm_object_properties properties; |
||
5270 | serge | 440 | |
441 | struct drm_crtc_state *state; |
||
442 | |||
443 | /* |
||
444 | * For legacy crtc ioctls so that atomic drivers can get at the locking |
||
445 | * acquire context. |
||
446 | */ |
||
447 | struct drm_modeset_acquire_ctx *acquire_ctx; |
||
1408 | serge | 448 | }; |
449 | |||
5270 | serge | 450 | /** |
451 | * struct drm_connector_state - mutable connector state |
||
452 | * @crtc: CRTC to connect connector to, NULL if disabled |
||
453 | * @best_encoder: can be used by helpers and drivers to select the encoder |
||
454 | * @state: backpointer to global drm_atomic_state |
||
455 | */ |
||
456 | struct drm_connector_state { |
||
457 | struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_connector() */ |
||
1408 | serge | 458 | |
5270 | serge | 459 | struct drm_encoder *best_encoder; |
460 | |||
461 | struct drm_atomic_state *state; |
||
462 | }; |
||
463 | |||
1408 | serge | 464 | /** |
5270 | serge | 465 | * struct drm_connector_funcs - control connectors on a given device |
1408 | serge | 466 | * @dpms: set power state (see drm_crtc_funcs above) |
467 | * @save: save connector state |
||
468 | * @restore: restore connector state |
||
3391 | Serge | 469 | * @reset: reset connector after state has been invalidated (e.g. resume) |
1408 | serge | 470 | * @detect: is this connector active? |
3031 | serge | 471 | * @fill_modes: fill mode list for this connector |
3391 | Serge | 472 | * @set_property: property for this connector may need an update |
1408 | serge | 473 | * @destroy: make object go away |
3391 | Serge | 474 | * @force: notify the driver that the connector is forced on |
5270 | serge | 475 | * @atomic_duplicate_state: duplicate the atomic state for this connector |
476 | * @atomic_destroy_state: destroy an atomic state for this connector |
||
477 | * @atomic_set_property: set a property on an atomic state for this connector |
||
1408 | serge | 478 | * |
479 | * Each CRTC may have one or more connectors attached to it. The functions |
||
480 | * below allow the core DRM code to control connectors, enumerate available modes, |
||
481 | * etc. |
||
482 | */ |
||
483 | struct drm_connector_funcs { |
||
484 | void (*dpms)(struct drm_connector *connector, int mode); |
||
485 | void (*save)(struct drm_connector *connector); |
||
486 | void (*restore)(struct drm_connector *connector); |
||
1964 | serge | 487 | void (*reset)(struct drm_connector *connector); |
488 | |||
489 | /* Check to see if anything is attached to the connector. |
||
490 | * @force is set to false whilst polling, true when checking the |
||
491 | * connector due to user request. @force can be used by the driver |
||
492 | * to avoid expensive, destructive operations during automated |
||
493 | * probing. |
||
494 | */ |
||
495 | enum drm_connector_status (*detect)(struct drm_connector *connector, |
||
496 | bool force); |
||
1408 | serge | 497 | int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height); |
498 | int (*set_property)(struct drm_connector *connector, struct drm_property *property, |
||
499 | uint64_t val); |
||
500 | void (*destroy)(struct drm_connector *connector); |
||
501 | void (*force)(struct drm_connector *connector); |
||
5270 | serge | 502 | |
503 | /* atomic update handling */ |
||
504 | struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector); |
||
505 | void (*atomic_destroy_state)(struct drm_connector *connector, |
||
506 | struct drm_connector_state *state); |
||
507 | int (*atomic_set_property)(struct drm_connector *connector, |
||
508 | struct drm_connector_state *state, |
||
509 | struct drm_property *property, |
||
510 | uint64_t val); |
||
1408 | serge | 511 | }; |
512 | |||
2967 | Serge | 513 | /** |
5270 | serge | 514 | * struct drm_encoder_funcs - encoder controls |
2967 | Serge | 515 | * @reset: reset state (e.g. at init or resume time) |
516 | * @destroy: cleanup and free associated data |
||
517 | * |
||
518 | * Encoders sit between CRTCs and connectors. |
||
519 | */ |
||
1408 | serge | 520 | struct drm_encoder_funcs { |
1964 | serge | 521 | void (*reset)(struct drm_encoder *encoder); |
1408 | serge | 522 | void (*destroy)(struct drm_encoder *encoder); |
523 | }; |
||
524 | |||
2967 | Serge | 525 | #define DRM_CONNECTOR_MAX_ENCODER 3 |
1408 | serge | 526 | |
527 | /** |
||
5270 | serge | 528 | * struct drm_encoder - central DRM encoder structure |
2967 | Serge | 529 | * @dev: parent DRM device |
530 | * @head: list management |
||
531 | * @base: base KMS object |
||
5056 | serge | 532 | * @name: encoder name |
2967 | Serge | 533 | * @encoder_type: one of the %DRM_MODE_ENCODER_ |
534 | * @possible_crtcs: bitmask of potential CRTC bindings |
||
535 | * @possible_clones: bitmask of potential sibling encoders for cloning |
||
536 | * @crtc: currently bound CRTC |
||
4103 | Serge | 537 | * @bridge: bridge associated to the encoder |
2967 | Serge | 538 | * @funcs: control functions |
539 | * @helper_private: mid-layer private data |
||
540 | * |
||
541 | * CRTCs drive pixels to encoders, which convert them into signals |
||
542 | * appropriate for a given connector or set of connectors. |
||
1408 | serge | 543 | */ |
544 | struct drm_encoder { |
||
545 | struct drm_device *dev; |
||
546 | struct list_head head; |
||
547 | |||
548 | struct drm_mode_object base; |
||
5056 | serge | 549 | char *name; |
1408 | serge | 550 | int encoder_type; |
551 | uint32_t possible_crtcs; |
||
552 | uint32_t possible_clones; |
||
553 | |||
554 | struct drm_crtc *crtc; |
||
4103 | Serge | 555 | struct drm_bridge *bridge; |
1408 | serge | 556 | const struct drm_encoder_funcs *funcs; |
557 | void *helper_private; |
||
558 | }; |
||
559 | |||
1964 | serge | 560 | /* should we poll this connector for connects and disconnects */ |
561 | /* hot plug detectable */ |
||
562 | #define DRM_CONNECTOR_POLL_HPD (1 << 0) |
||
563 | /* poll for connections */ |
||
564 | #define DRM_CONNECTOR_POLL_CONNECT (1 << 1) |
||
565 | /* can cleanly poll for disconnections without flickering the screen */ |
||
566 | /* DACs should rarely do this without a lot of testing */ |
||
567 | #define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2) |
||
568 | |||
2967 | Serge | 569 | #define MAX_ELD_BYTES 128 |
570 | |||
1408 | serge | 571 | /** |
5270 | serge | 572 | * struct drm_connector - central DRM connector control structure |
2967 | Serge | 573 | * @dev: parent DRM device |
574 | * @kdev: kernel device for sysfs attributes |
||
575 | * @attr: sysfs attributes |
||
576 | * @head: list management |
||
577 | * @base: base KMS object |
||
5056 | serge | 578 | * @name: connector name |
2967 | Serge | 579 | * @connector_type: one of the %DRM_MODE_CONNECTOR_ |
580 | * @connector_type_id: index into connector type enum |
||
1408 | serge | 581 | * @interlace_allowed: can this connector handle interlaced modes? |
582 | * @doublescan_allowed: can this connector handle doublescan? |
||
5270 | serge | 583 | * @stereo_allowed: can this connector handle stereo modes? |
2967 | Serge | 584 | * @modes: modes available on this connector (from fill_modes() + user) |
585 | * @status: one of the drm_connector_status enums (connected, not, or unknown) |
||
586 | * @probed_modes: list of modes derived directly from the display |
||
587 | * @display_info: information about attached display (e.g. from EDID) |
||
1408 | serge | 588 | * @funcs: connector control functions |
2967 | Serge | 589 | * @edid_blob_ptr: DRM property containing EDID if present |
3031 | serge | 590 | * @properties: property tracking for this connector |
5270 | serge | 591 | * @path_blob_ptr: DRM blob property data for the DP MST path property |
2967 | Serge | 592 | * @polled: a %DRM_CONNECTOR_POLL_ |
593 | * @dpms: current dpms state |
||
594 | * @helper_private: mid-layer private data |
||
5270 | serge | 595 | * @cmdline_mode: mode line parsed from the kernel cmdline for this connector |
2967 | Serge | 596 | * @force: a %DRM_FORCE_ |
5270 | serge | 597 | * @override_edid: has the EDID been overwritten through debugfs for testing? |
2967 | Serge | 598 | * @encoder_ids: valid encoders for this connector |
599 | * @encoder: encoder driving this connector, if any |
||
600 | * @eld: EDID-like data, if present |
||
601 | * @dvi_dual: dual link DVI, if found |
||
602 | * @max_tmds_clock: max clock rate, if found |
||
603 | * @latency_present: AV delay info from ELD, if found |
||
604 | * @video_latency: video latency info from ELD, if found |
||
605 | * @audio_latency: audio latency info from ELD, if found |
||
606 | * @null_edid_counter: track sinks that give us all zeros for the EDID |
||
5270 | serge | 607 | * @bad_edid_counter: track sinks that give us an EDID with invalid checksum |
608 | * @debugfs_entry: debugfs directory for this connector |
||
609 | * @state: current atomic state for this connector |
||
610 | * @has_tile: is this connector connected to a tiled monitor |
||
611 | * @tile_group: tile group for the connected monitor |
||
612 | * @tile_is_single_monitor: whether the tile is one monitor housing |
||
613 | * @num_h_tile: number of horizontal tiles in the tile group |
||
614 | * @num_v_tile: number of vertical tiles in the tile group |
||
615 | * @tile_h_loc: horizontal location of this tile |
||
616 | * @tile_v_loc: vertical location of this tile |
||
617 | * @tile_h_size: horizontal size of this tile. |
||
618 | * @tile_v_size: vertical size of this tile. |
||
1408 | serge | 619 | * |
620 | * Each connector may be connected to one or more CRTCs, or may be clonable by |
||
621 | * another connector if they can share a CRTC. Each connector also has a specific |
||
622 | * position in the broader display (referred to as a 'screen' though it could |
||
623 | * span multiple monitors). |
||
624 | */ |
||
625 | struct drm_connector { |
||
626 | struct drm_device *dev; |
||
4559 | Serge | 627 | struct device *kdev; |
1408 | serge | 628 | struct device_attribute *attr; |
629 | struct list_head head; |
||
630 | |||
631 | struct drm_mode_object base; |
||
632 | |||
5056 | serge | 633 | char *name; |
1408 | serge | 634 | int connector_type; |
635 | int connector_type_id; |
||
636 | bool interlace_allowed; |
||
637 | bool doublescan_allowed; |
||
4559 | Serge | 638 | bool stereo_allowed; |
1408 | serge | 639 | struct list_head modes; /* list of modes on this connector */ |
640 | |||
641 | enum drm_connector_status status; |
||
642 | |||
643 | /* these are modes added by probing with DDC or the BIOS */ |
||
644 | struct list_head probed_modes; |
||
645 | |||
646 | struct drm_display_info display_info; |
||
647 | const struct drm_connector_funcs *funcs; |
||
648 | |||
649 | struct drm_property_blob *edid_blob_ptr; |
||
3031 | serge | 650 | struct drm_object_properties properties; |
1408 | serge | 651 | |
5056 | serge | 652 | struct drm_property_blob *path_blob_ptr; |
653 | |||
5270 | serge | 654 | struct drm_property_blob *tile_blob_ptr; |
655 | |||
1964 | serge | 656 | uint8_t polled; /* DRM_CONNECTOR_POLL_* */ |
657 | |||
1408 | serge | 658 | /* requested DPMS state */ |
659 | int dpms; |
||
660 | |||
661 | void *helper_private; |
||
662 | |||
663 | /* forced on connector */ |
||
5270 | serge | 664 | struct drm_cmdline_mode cmdline_mode; |
1408 | serge | 665 | enum drm_connector_force force; |
5056 | serge | 666 | bool override_edid; |
1408 | serge | 667 | uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER]; |
668 | struct drm_encoder *encoder; /* currently active encoder */ |
||
1987 | serge | 669 | |
2967 | Serge | 670 | /* EDID bits */ |
671 | uint8_t eld[MAX_ELD_BYTES]; |
||
672 | bool dvi_dual; |
||
673 | int max_tmds_clock; /* in MHz */ |
||
674 | bool latency_present[2]; |
||
675 | int video_latency[2]; /* [0]: progressive, [1]: interlaced */ |
||
676 | int audio_latency[2]; |
||
1987 | serge | 677 | int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */ |
3031 | serge | 678 | unsigned bad_edid_counter; |
5056 | serge | 679 | |
680 | struct dentry *debugfs_entry; |
||
5270 | serge | 681 | |
682 | struct drm_connector_state *state; |
||
683 | |||
684 | /* DisplayID bits */ |
||
685 | bool has_tile; |
||
686 | struct drm_tile_group *tile_group; |
||
687 | bool tile_is_single_monitor; |
||
688 | |||
689 | uint8_t num_h_tile, num_v_tile; |
||
690 | uint8_t tile_h_loc, tile_v_loc; |
||
691 | uint16_t tile_h_size, tile_v_size; |
||
1408 | serge | 692 | }; |
693 | |||
694 | /** |
||
5270 | serge | 695 | * struct drm_plane_state - mutable plane state |
696 | * @crtc: currently bound CRTC, NULL if disabled |
||
697 | * @fb: currently bound framebuffer |
||
698 | * @fence: optional fence to wait for before scanning out @fb |
||
699 | * @crtc_x: left position of visible portion of plane on crtc |
||
700 | * @crtc_y: upper position of visible portion of plane on crtc |
||
701 | * @crtc_w: width of visible portion of plane on crtc |
||
702 | * @crtc_h: height of visible portion of plane on crtc |
||
703 | * @src_x: left position of visible portion of plane within |
||
704 | * plane (in 16.16) |
||
705 | * @src_y: upper position of visible portion of plane within |
||
706 | * plane (in 16.16) |
||
707 | * @src_w: width of visible portion of plane (in 16.16) |
||
708 | * @src_h: height of visible portion of plane (in 16.16) |
||
709 | * @state: backpointer to global drm_atomic_state |
||
710 | */ |
||
711 | struct drm_plane_state { |
||
712 | struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_plane() */ |
||
713 | struct drm_framebuffer *fb; /* do not write directly, use drm_atomic_set_fb_for_plane() */ |
||
714 | struct fence *fence; |
||
715 | |||
716 | /* Signed dest location allows it to be partially off screen */ |
||
717 | int32_t crtc_x, crtc_y; |
||
718 | uint32_t crtc_w, crtc_h; |
||
719 | |||
720 | /* Source values are 16.16 fixed point */ |
||
721 | uint32_t src_x, src_y; |
||
722 | uint32_t src_h, src_w; |
||
723 | |||
724 | struct drm_atomic_state *state; |
||
725 | }; |
||
726 | |||
727 | |||
728 | /** |
||
729 | * struct drm_plane_funcs - driver plane control functions |
||
2967 | Serge | 730 | * @update_plane: update the plane configuration |
731 | * @disable_plane: shut down the plane |
||
732 | * @destroy: clean up plane resources |
||
5270 | serge | 733 | * @reset: reset plane after state has been invalidated (e.g. resume) |
3031 | serge | 734 | * @set_property: called when a property is changed |
5270 | serge | 735 | * @atomic_duplicate_state: duplicate the atomic state for this plane |
736 | * @atomic_destroy_state: destroy an atomic state for this plane |
||
737 | * @atomic_set_property: set a property on an atomic state for this plane |
||
2967 | Serge | 738 | */ |
739 | struct drm_plane_funcs { |
||
740 | int (*update_plane)(struct drm_plane *plane, |
||
741 | struct drm_crtc *crtc, struct drm_framebuffer *fb, |
||
742 | int crtc_x, int crtc_y, |
||
743 | unsigned int crtc_w, unsigned int crtc_h, |
||
744 | uint32_t src_x, uint32_t src_y, |
||
745 | uint32_t src_w, uint32_t src_h); |
||
746 | int (*disable_plane)(struct drm_plane *plane); |
||
747 | void (*destroy)(struct drm_plane *plane); |
||
5270 | serge | 748 | void (*reset)(struct drm_plane *plane); |
3031 | serge | 749 | |
750 | int (*set_property)(struct drm_plane *plane, |
||
751 | struct drm_property *property, uint64_t val); |
||
5270 | serge | 752 | |
753 | /* atomic update handling */ |
||
754 | struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane); |
||
755 | void (*atomic_destroy_state)(struct drm_plane *plane, |
||
756 | struct drm_plane_state *state); |
||
757 | int (*atomic_set_property)(struct drm_plane *plane, |
||
758 | struct drm_plane_state *state, |
||
759 | struct drm_property *property, |
||
760 | uint64_t val); |
||
2967 | Serge | 761 | }; |
762 | |||
5056 | serge | 763 | enum drm_plane_type { |
764 | DRM_PLANE_TYPE_OVERLAY, |
||
765 | DRM_PLANE_TYPE_PRIMARY, |
||
766 | DRM_PLANE_TYPE_CURSOR, |
||
767 | }; |
||
768 | |||
2967 | Serge | 769 | /** |
5270 | serge | 770 | * struct drm_plane - central DRM plane control structure |
2967 | Serge | 771 | * @dev: DRM device this plane belongs to |
772 | * @head: for list management |
||
773 | * @base: base mode object |
||
774 | * @possible_crtcs: pipes this plane can be bound to |
||
775 | * @format_types: array of formats supported by this plane |
||
776 | * @format_count: number of formats supported |
||
777 | * @crtc: currently bound CRTC |
||
778 | * @fb: currently bound fb |
||
5270 | serge | 779 | * @old_fb: Temporary tracking of the old fb while a modeset is ongoing. Used by |
780 | * drm_mode_set_config_internal() to implement correct refcounting. |
||
2967 | Serge | 781 | * @funcs: helper functions |
3031 | serge | 782 | * @properties: property tracking for this plane |
5056 | serge | 783 | * @type: type of plane (overlay, primary, cursor) |
5270 | serge | 784 | * @state: current atomic state for this plane |
2967 | Serge | 785 | */ |
786 | struct drm_plane { |
||
787 | struct drm_device *dev; |
||
788 | struct list_head head; |
||
789 | |||
5270 | serge | 790 | struct drm_modeset_lock mutex; |
791 | |||
2967 | Serge | 792 | struct drm_mode_object base; |
793 | |||
794 | uint32_t possible_crtcs; |
||
795 | uint32_t *format_types; |
||
796 | uint32_t format_count; |
||
797 | |||
798 | struct drm_crtc *crtc; |
||
799 | struct drm_framebuffer *fb; |
||
800 | |||
5270 | serge | 801 | struct drm_framebuffer *old_fb; |
802 | |||
2967 | Serge | 803 | const struct drm_plane_funcs *funcs; |
3031 | serge | 804 | |
805 | struct drm_object_properties properties; |
||
5056 | serge | 806 | |
807 | enum drm_plane_type type; |
||
5270 | serge | 808 | |
809 | void *helper_private; |
||
810 | |||
811 | struct drm_plane_state *state; |
||
2967 | Serge | 812 | }; |
813 | |||
814 | /** |
||
5270 | serge | 815 | * struct drm_bridge_funcs - drm_bridge control functions |
4103 | Serge | 816 | * @mode_fixup: Try to fixup (or reject entirely) proposed mode for this bridge |
817 | * @disable: Called right before encoder prepare, disables the bridge |
||
818 | * @post_disable: Called right after encoder prepare, for lockstepped disable |
||
819 | * @mode_set: Set this mode to the bridge |
||
820 | * @pre_enable: Called right before encoder commit, for lockstepped commit |
||
821 | * @enable: Called right after encoder commit, enables the bridge |
||
822 | * @destroy: make object go away |
||
823 | */ |
||
824 | struct drm_bridge_funcs { |
||
825 | bool (*mode_fixup)(struct drm_bridge *bridge, |
||
826 | const struct drm_display_mode *mode, |
||
827 | struct drm_display_mode *adjusted_mode); |
||
828 | void (*disable)(struct drm_bridge *bridge); |
||
829 | void (*post_disable)(struct drm_bridge *bridge); |
||
830 | void (*mode_set)(struct drm_bridge *bridge, |
||
831 | struct drm_display_mode *mode, |
||
832 | struct drm_display_mode *adjusted_mode); |
||
833 | void (*pre_enable)(struct drm_bridge *bridge); |
||
834 | void (*enable)(struct drm_bridge *bridge); |
||
835 | void (*destroy)(struct drm_bridge *bridge); |
||
836 | }; |
||
837 | |||
838 | /** |
||
5270 | serge | 839 | * struct drm_bridge - central DRM bridge control structure |
4103 | Serge | 840 | * @dev: DRM device this bridge belongs to |
841 | * @head: list management |
||
842 | * @base: base mode object |
||
843 | * @funcs: control functions |
||
844 | * @driver_private: pointer to the bridge driver's internal context |
||
845 | */ |
||
846 | struct drm_bridge { |
||
847 | struct drm_device *dev; |
||
848 | struct list_head head; |
||
849 | |||
850 | struct drm_mode_object base; |
||
851 | |||
852 | const struct drm_bridge_funcs *funcs; |
||
853 | void *driver_private; |
||
854 | }; |
||
855 | |||
856 | /** |
||
5270 | serge | 857 | * struct struct drm_atomic_state - the global state object for atomic updates |
858 | * @dev: parent DRM device |
||
859 | * @flags: state flags like async update |
||
860 | * @planes: pointer to array of plane pointers |
||
861 | * @plane_states: pointer to array of plane states pointers |
||
862 | * @crtcs: pointer to array of CRTC pointers |
||
863 | * @crtc_states: pointer to array of CRTC states pointers |
||
864 | * @num_connector: size of the @connectors and @connector_states arrays |
||
865 | * @connectors: pointer to array of connector pointers |
||
866 | * @connector_states: pointer to array of connector states pointers |
||
867 | * @acquire_ctx: acquire context for this atomic modeset state update |
||
868 | */ |
||
869 | struct drm_atomic_state { |
||
870 | struct drm_device *dev; |
||
871 | uint32_t flags; |
||
872 | struct drm_plane **planes; |
||
873 | struct drm_plane_state **plane_states; |
||
874 | struct drm_crtc **crtcs; |
||
875 | struct drm_crtc_state **crtc_states; |
||
876 | int num_connector; |
||
877 | struct drm_connector **connectors; |
||
878 | struct drm_connector_state **connector_states; |
||
879 | |||
880 | struct drm_modeset_acquire_ctx *acquire_ctx; |
||
881 | }; |
||
882 | |||
883 | |||
884 | /** |
||
885 | * struct drm_mode_set - new values for a CRTC config change |
||
2967 | Serge | 886 | * @fb: framebuffer to use for new config |
887 | * @crtc: CRTC whose configuration we're about to change |
||
888 | * @mode: mode timings to use |
||
889 | * @x: position of this CRTC relative to @fb |
||
890 | * @y: position of this CRTC relative to @fb |
||
891 | * @connectors: array of connectors to drive with this CRTC if possible |
||
892 | * @num_connectors: size of @connectors array |
||
1408 | serge | 893 | * |
894 | * Represents a single crtc the connectors that it drives with what mode |
||
895 | * and from which framebuffer it scans out from. |
||
896 | * |
||
897 | * This is used to set modes. |
||
898 | */ |
||
899 | struct drm_mode_set { |
||
900 | struct drm_framebuffer *fb; |
||
901 | struct drm_crtc *crtc; |
||
902 | struct drm_display_mode *mode; |
||
903 | |||
904 | uint32_t x; |
||
905 | uint32_t y; |
||
906 | |||
907 | struct drm_connector **connectors; |
||
908 | size_t num_connectors; |
||
909 | }; |
||
910 | |||
911 | /** |
||
2967 | Serge | 912 | * struct drm_mode_config_funcs - basic driver provided mode setting functions |
913 | * @fb_create: create a new framebuffer object |
||
914 | * @output_poll_changed: function to handle output configuration changes |
||
5270 | serge | 915 | * @atomic_check: check whether a give atomic state update is possible |
916 | * @atomic_commit: commit an atomic state update previously verified with |
||
917 | * atomic_check() |
||
2967 | Serge | 918 | * |
919 | * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that |
||
920 | * involve drivers. |
||
1408 | serge | 921 | */ |
922 | struct drm_mode_config_funcs { |
||
2967 | Serge | 923 | struct drm_framebuffer *(*fb_create)(struct drm_device *dev, |
924 | struct drm_file *file_priv, |
||
925 | struct drm_mode_fb_cmd2 *mode_cmd); |
||
1964 | serge | 926 | void (*output_poll_changed)(struct drm_device *dev); |
5270 | serge | 927 | |
928 | int (*atomic_check)(struct drm_device *dev, |
||
929 | struct drm_atomic_state *a); |
||
930 | int (*atomic_commit)(struct drm_device *dev, |
||
931 | struct drm_atomic_state *a, |
||
932 | bool async); |
||
1408 | serge | 933 | }; |
934 | |||
2967 | Serge | 935 | /** |
5270 | serge | 936 | * struct drm_mode_group - group of mode setting resources for potential sub-grouping |
2967 | Serge | 937 | * @num_crtcs: CRTC count |
938 | * @num_encoders: encoder count |
||
939 | * @num_connectors: connector count |
||
5270 | serge | 940 | * @num_bridges: bridge count |
2967 | Serge | 941 | * @id_list: list of KMS object IDs in this group |
942 | * |
||
943 | * Currently this simply tracks the global mode setting state. But in the |
||
944 | * future it could allow groups of objects to be set aside into independent |
||
945 | * control groups for use by different user level processes (e.g. two X servers |
||
946 | * running simultaneously on different heads, each with their own mode |
||
947 | * configuration and freedom of mode setting). |
||
948 | */ |
||
1408 | serge | 949 | struct drm_mode_group { |
950 | uint32_t num_crtcs; |
||
951 | uint32_t num_encoders; |
||
952 | uint32_t num_connectors; |
||
4103 | Serge | 953 | uint32_t num_bridges; |
1408 | serge | 954 | |
955 | /* list of object IDs for this group */ |
||
956 | uint32_t *id_list; |
||
957 | }; |
||
958 | |||
959 | /** |
||
5270 | serge | 960 | * struct drm_mode_config - Mode configuration control structure |
2967 | Serge | 961 | * @mutex: mutex protecting KMS related lists and structures |
5270 | serge | 962 | * @connection_mutex: ww mutex protecting connector state and routing |
963 | * @acquire_ctx: global implicit acquire context used by atomic drivers for |
||
964 | * legacy ioctls |
||
2967 | Serge | 965 | * @idr_mutex: mutex for KMS ID allocation and management |
966 | * @crtc_idr: main KMS ID tracking object |
||
5270 | serge | 967 | * @fb_lock: mutex to protect fb state and lists |
2967 | Serge | 968 | * @num_fb: number of fbs available |
969 | * @fb_list: list of framebuffers available |
||
970 | * @num_connector: number of connectors on this device |
||
971 | * @connector_list: list of connector objects |
||
4103 | Serge | 972 | * @num_bridge: number of bridges on this device |
973 | * @bridge_list: list of bridge objects |
||
2967 | Serge | 974 | * @num_encoder: number of encoders on this device |
975 | * @encoder_list: list of encoder objects |
||
5270 | serge | 976 | * @num_overlay_plane: number of overlay planes on this device |
977 | * @num_total_plane: number of universal (i.e. with primary/curso) planes on this device |
||
978 | * @plane_list: list of plane objects |
||
2967 | Serge | 979 | * @num_crtc: number of CRTCs on this device |
980 | * @crtc_list: list of CRTC objects |
||
5270 | serge | 981 | * @property_list: list of property objects |
2967 | Serge | 982 | * @min_width: minimum pixel width on this device |
983 | * @min_height: minimum pixel height on this device |
||
984 | * @max_width: maximum pixel width on this device |
||
985 | * @max_height: maximum pixel height on this device |
||
986 | * @funcs: core driver provided mode setting functions |
||
987 | * @fb_base: base address of the framebuffer |
||
5270 | serge | 988 | * @poll_enabled: track polling support for this device |
989 | * @poll_running: track polling status for this device |
||
2967 | Serge | 990 | * @output_poll_work: delayed work for polling in process context |
5270 | serge | 991 | * @property_blob_list: list of all the blob property objects |
2967 | Serge | 992 | * @*_property: core property tracking |
5270 | serge | 993 | * @preferred_depth: preferred RBG pixel depth, used by fb helpers |
994 | * @prefer_shadow: hint to userspace to prefer shadow-fb rendering |
||
995 | * @async_page_flip: does this device support async flips on the primary plane? |
||
996 | * @cursor_width: hint to userspace for max cursor width |
||
997 | * @cursor_height: hint to userspace for max cursor height |
||
1408 | serge | 998 | * |
2967 | Serge | 999 | * Core mode resource tracking structure. All CRTC, encoders, and connectors |
1000 | * enumerated by the driver are added here, as are global properties. Some |
||
1001 | * global restrictions are also here, e.g. dimension restrictions. |
||
1408 | serge | 1002 | */ |
1003 | struct drm_mode_config { |
||
1630 | serge | 1004 | struct mutex mutex; /* protects configuration (mode lists etc.) */ |
5056 | serge | 1005 | struct drm_modeset_lock connection_mutex; /* protects connector->encoder and encoder->crtc links */ |
1006 | struct drm_modeset_acquire_ctx *acquire_ctx; /* for legacy _lock_all() / _unlock_all() */ |
||
1630 | serge | 1007 | struct mutex idr_mutex; /* for IDR management */ |
1408 | serge | 1008 | struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */ |
5270 | serge | 1009 | struct idr tile_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */ |
1408 | serge | 1010 | /* this is limited to one for now */ |
3391 | Serge | 1011 | |
5270 | serge | 1012 | struct mutex fb_lock; /* proctects global and per-file fb lists */ |
1408 | serge | 1013 | int num_fb; |
1014 | struct list_head fb_list; |
||
3391 | Serge | 1015 | |
1408 | serge | 1016 | int num_connector; |
1017 | struct list_head connector_list; |
||
4103 | Serge | 1018 | int num_bridge; |
1019 | struct list_head bridge_list; |
||
1408 | serge | 1020 | int num_encoder; |
1021 | struct list_head encoder_list; |
||
5056 | serge | 1022 | |
1023 | /* |
||
1024 | * Track # of overlay planes separately from # of total planes. By |
||
1025 | * default we only advertise overlay planes to userspace; if userspace |
||
1026 | * sets the "universal plane" capability bit, we'll go ahead and |
||
1027 | * expose all planes. |
||
1028 | */ |
||
1029 | int num_overlay_plane; |
||
1030 | int num_total_plane; |
||
2967 | Serge | 1031 | struct list_head plane_list; |
1408 | serge | 1032 | |
1033 | int num_crtc; |
||
1034 | struct list_head crtc_list; |
||
1035 | |||
1036 | struct list_head property_list; |
||
1037 | |||
1038 | int min_width, min_height; |
||
1039 | int max_width, max_height; |
||
3031 | serge | 1040 | const struct drm_mode_config_funcs *funcs; |
1408 | serge | 1041 | resource_size_t fb_base; |
1042 | |||
1964 | serge | 1043 | /* output poll support */ |
1044 | bool poll_enabled; |
||
3192 | Serge | 1045 | bool poll_running; |
3480 | Serge | 1046 | struct delayed_work output_poll_work; |
1964 | serge | 1047 | |
1408 | serge | 1048 | /* pointers to standard properties */ |
1049 | struct list_head property_blob_list; |
||
1050 | struct drm_property *edid_property; |
||
1051 | struct drm_property *dpms_property; |
||
5056 | serge | 1052 | struct drm_property *path_property; |
5270 | serge | 1053 | struct drm_property *tile_property; |
5056 | serge | 1054 | struct drm_property *plane_type_property; |
5270 | serge | 1055 | struct drm_property *rotation_property; |
1408 | serge | 1056 | |
1057 | /* DVI-I properties */ |
||
1058 | struct drm_property *dvi_i_subconnector_property; |
||
1059 | struct drm_property *dvi_i_select_subconnector_property; |
||
1060 | |||
1061 | /* TV properties */ |
||
1062 | struct drm_property *tv_subconnector_property; |
||
1063 | struct drm_property *tv_select_subconnector_property; |
||
1064 | struct drm_property *tv_mode_property; |
||
1065 | struct drm_property *tv_left_margin_property; |
||
1066 | struct drm_property *tv_right_margin_property; |
||
1067 | struct drm_property *tv_top_margin_property; |
||
1068 | struct drm_property *tv_bottom_margin_property; |
||
1069 | struct drm_property *tv_brightness_property; |
||
1070 | struct drm_property *tv_contrast_property; |
||
1071 | struct drm_property *tv_flicker_reduction_property; |
||
1072 | struct drm_property *tv_overscan_property; |
||
1073 | struct drm_property *tv_saturation_property; |
||
1074 | struct drm_property *tv_hue_property; |
||
1075 | |||
1076 | /* Optional properties */ |
||
1077 | struct drm_property *scaling_mode_property; |
||
5056 | serge | 1078 | struct drm_property *aspect_ratio_property; |
1408 | serge | 1079 | struct drm_property *dirty_info_property; |
3031 | serge | 1080 | |
5270 | serge | 1081 | /* properties for virtual machine layout */ |
1082 | struct drm_property *suggested_x_property; |
||
1083 | struct drm_property *suggested_y_property; |
||
1084 | |||
3031 | serge | 1085 | /* dumb ioctl parameters */ |
1086 | uint32_t preferred_depth, prefer_shadow; |
||
4103 | Serge | 1087 | |
1088 | /* whether async page flip is supported or not */ |
||
1089 | bool async_page_flip; |
||
5056 | serge | 1090 | |
1091 | /* cursor size */ |
||
1092 | uint32_t cursor_width, cursor_height; |
||
1408 | serge | 1093 | }; |
1094 | |||
5270 | serge | 1095 | /** |
1096 | * drm_for_each_plane_mask - iterate over planes specified by bitmask |
||
1097 | * @plane: the loop cursor |
||
1098 | * @dev: the DRM device |
||
1099 | * @plane_mask: bitmask of plane indices |
||
1100 | * |
||
1101 | * Iterate over all planes specified by bitmask. |
||
1102 | */ |
||
1103 | #define drm_for_each_plane_mask(plane, dev, plane_mask) \ |
||
1104 | list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \ |
||
1105 | if ((plane_mask) & (1 << drm_plane_index(plane))) |
||
1106 | |||
1107 | |||
1408 | serge | 1108 | #define obj_to_crtc(x) container_of(x, struct drm_crtc, base) |
1109 | #define obj_to_connector(x) container_of(x, struct drm_connector, base) |
||
1110 | #define obj_to_encoder(x) container_of(x, struct drm_encoder, base) |
||
1111 | #define obj_to_mode(x) container_of(x, struct drm_display_mode, base) |
||
1112 | #define obj_to_fb(x) container_of(x, struct drm_framebuffer, base) |
||
1113 | #define obj_to_property(x) container_of(x, struct drm_property, base) |
||
1114 | #define obj_to_blob(x) container_of(x, struct drm_property_blob, base) |
||
2967 | Serge | 1115 | #define obj_to_plane(x) container_of(x, struct drm_plane, base) |
1408 | serge | 1116 | |
3031 | serge | 1117 | struct drm_prop_enum_list { |
1118 | int type; |
||
1119 | char *name; |
||
1120 | }; |
||
1408 | serge | 1121 | |
5056 | serge | 1122 | extern int drm_crtc_init_with_planes(struct drm_device *dev, |
1123 | struct drm_crtc *crtc, |
||
1124 | struct drm_plane *primary, |
||
1125 | struct drm_plane *cursor, |
||
1126 | const struct drm_crtc_funcs *funcs); |
||
1408 | serge | 1127 | extern void drm_crtc_cleanup(struct drm_crtc *crtc); |
4559 | Serge | 1128 | extern unsigned int drm_crtc_index(struct drm_crtc *crtc); |
1408 | serge | 1129 | |
4559 | Serge | 1130 | /** |
1131 | * drm_crtc_mask - find the mask of a registered CRTC |
||
1132 | * @crtc: CRTC to find mask for |
||
1133 | * |
||
1134 | * Given a registered CRTC, return the mask bit of that CRTC for an |
||
1135 | * encoder's possible_crtcs field. |
||
1136 | */ |
||
1137 | static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc) |
||
1138 | { |
||
1139 | return 1 << drm_crtc_index(crtc); |
||
1140 | } |
||
1141 | |||
4103 | Serge | 1142 | extern void drm_connector_ida_init(void); |
1143 | extern void drm_connector_ida_destroy(void); |
||
3031 | serge | 1144 | extern int drm_connector_init(struct drm_device *dev, |
1408 | serge | 1145 | struct drm_connector *connector, |
1146 | const struct drm_connector_funcs *funcs, |
||
1147 | int connector_type); |
||
5056 | serge | 1148 | int drm_connector_register(struct drm_connector *connector); |
1149 | void drm_connector_unregister(struct drm_connector *connector); |
||
1408 | serge | 1150 | |
1151 | extern void drm_connector_cleanup(struct drm_connector *connector); |
||
5270 | serge | 1152 | extern unsigned int drm_connector_index(struct drm_connector *connector); |
3031 | serge | 1153 | /* helper to unplug all connectors from sysfs for device */ |
1154 | extern void drm_connector_unplug_all(struct drm_device *dev); |
||
1408 | serge | 1155 | |
4103 | Serge | 1156 | extern int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge, |
1157 | const struct drm_bridge_funcs *funcs); |
||
1158 | extern void drm_bridge_cleanup(struct drm_bridge *bridge); |
||
1159 | |||
3031 | serge | 1160 | extern int drm_encoder_init(struct drm_device *dev, |
1408 | serge | 1161 | struct drm_encoder *encoder, |
1162 | const struct drm_encoder_funcs *funcs, |
||
1163 | int encoder_type); |
||
1164 | |||
4559 | Serge | 1165 | /** |
1166 | * drm_encoder_crtc_ok - can a given crtc drive a given encoder? |
||
1167 | * @encoder: encoder to test |
||
1168 | * @crtc: crtc to test |
||
1169 | * |
||
1170 | * Return false if @encoder can't be driven by @crtc, true otherwise. |
||
1171 | */ |
||
1172 | static inline bool drm_encoder_crtc_ok(struct drm_encoder *encoder, |
||
1173 | struct drm_crtc *crtc) |
||
1174 | { |
||
1175 | return !!(encoder->possible_crtcs & drm_crtc_mask(crtc)); |
||
1176 | } |
||
1177 | |||
5056 | serge | 1178 | extern int drm_universal_plane_init(struct drm_device *dev, |
1179 | struct drm_plane *plane, |
||
1180 | unsigned long possible_crtcs, |
||
1181 | const struct drm_plane_funcs *funcs, |
||
1182 | const uint32_t *formats, |
||
1183 | uint32_t format_count, |
||
1184 | enum drm_plane_type type); |
||
2967 | Serge | 1185 | extern int drm_plane_init(struct drm_device *dev, |
1186 | struct drm_plane *plane, |
||
1187 | unsigned long possible_crtcs, |
||
1188 | const struct drm_plane_funcs *funcs, |
||
1189 | const uint32_t *formats, uint32_t format_count, |
||
5056 | serge | 1190 | bool is_primary); |
2967 | Serge | 1191 | extern void drm_plane_cleanup(struct drm_plane *plane); |
5270 | serge | 1192 | extern unsigned int drm_plane_index(struct drm_plane *plane); |
4065 | Serge | 1193 | extern void drm_plane_force_disable(struct drm_plane *plane); |
5056 | serge | 1194 | extern int drm_crtc_check_viewport(const struct drm_crtc *crtc, |
1195 | int x, int y, |
||
1196 | const struct drm_display_mode *mode, |
||
1197 | const struct drm_framebuffer *fb); |
||
2967 | Serge | 1198 | |
1408 | serge | 1199 | extern void drm_encoder_cleanup(struct drm_encoder *encoder); |
1200 | |||
4065 | Serge | 1201 | extern const char *drm_get_connector_status_name(enum drm_connector_status status); |
5056 | serge | 1202 | extern const char *drm_get_subpixel_order_name(enum subpixel_order order); |
4065 | Serge | 1203 | extern const char *drm_get_dpms_name(int val); |
1204 | extern const char *drm_get_dvi_i_subconnector_name(int val); |
||
1205 | extern const char *drm_get_dvi_i_select_name(int val); |
||
1206 | extern const char *drm_get_tv_subconnector_name(int val); |
||
1207 | extern const char *drm_get_tv_select_name(int val); |
||
1987 | serge | 1208 | extern void drm_fb_release(struct drm_file *file_priv); |
1408 | serge | 1209 | extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group); |
5056 | serge | 1210 | extern void drm_mode_group_destroy(struct drm_mode_group *group); |
1211 | extern void drm_reinit_primary_mode_group(struct drm_device *dev); |
||
3031 | serge | 1212 | extern bool drm_probe_ddc(struct i2c_adapter *adapter); |
1408 | serge | 1213 | extern struct edid *drm_get_edid(struct drm_connector *connector, |
1214 | struct i2c_adapter *adapter); |
||
4559 | Serge | 1215 | extern struct edid *drm_edid_duplicate(const struct edid *edid); |
1408 | serge | 1216 | extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid); |
1217 | extern void drm_mode_config_init(struct drm_device *dev); |
||
1964 | serge | 1218 | extern void drm_mode_config_reset(struct drm_device *dev); |
1408 | serge | 1219 | extern void drm_mode_config_cleanup(struct drm_device *dev); |
1220 | |||
5056 | serge | 1221 | extern int drm_mode_connector_set_path_property(struct drm_connector *connector, |
5270 | serge | 1222 | const char *path); |
1223 | int drm_mode_connector_set_tile_property(struct drm_connector *connector); |
||
1408 | serge | 1224 | extern int drm_mode_connector_update_edid_property(struct drm_connector *connector, |
5270 | serge | 1225 | const struct edid *edid); |
5056 | serge | 1226 | |
1227 | static inline bool drm_property_type_is(struct drm_property *property, |
||
1228 | uint32_t type) |
||
1229 | { |
||
1230 | /* instanceof for props.. handles extended type vs original types: */ |
||
1231 | if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) |
||
1232 | return (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) == type; |
||
1233 | return property->flags & type; |
||
1234 | } |
||
1235 | |||
1236 | static inline bool drm_property_type_valid(struct drm_property *property) |
||
1237 | { |
||
1238 | if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) |
||
1239 | return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE); |
||
1240 | return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE); |
||
1241 | } |
||
1242 | |||
3031 | serge | 1243 | extern int drm_object_property_set_value(struct drm_mode_object *obj, |
1244 | struct drm_property *property, |
||
1245 | uint64_t val); |
||
1246 | extern int drm_object_property_get_value(struct drm_mode_object *obj, |
||
1247 | struct drm_property *property, |
||
1248 | uint64_t *value); |
||
1408 | serge | 1249 | extern int drm_framebuffer_init(struct drm_device *dev, |
1250 | struct drm_framebuffer *fb, |
||
1251 | const struct drm_framebuffer_funcs *funcs); |
||
3391 | Serge | 1252 | extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev, |
1253 | uint32_t id); |
||
3031 | serge | 1254 | extern void drm_framebuffer_unreference(struct drm_framebuffer *fb); |
1255 | extern void drm_framebuffer_reference(struct drm_framebuffer *fb); |
||
1256 | extern void drm_framebuffer_remove(struct drm_framebuffer *fb); |
||
1408 | serge | 1257 | extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb); |
3391 | Serge | 1258 | extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb); |
1408 | serge | 1259 | |
3031 | serge | 1260 | extern void drm_object_attach_property(struct drm_mode_object *obj, |
1261 | struct drm_property *property, |
||
1262 | uint64_t init_val); |
||
1408 | serge | 1263 | extern struct drm_property *drm_property_create(struct drm_device *dev, int flags, |
1264 | const char *name, int num_values); |
||
3031 | serge | 1265 | extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags, |
1266 | const char *name, |
||
1267 | const struct drm_prop_enum_list *props, |
||
1268 | int num_values); |
||
1269 | struct drm_property *drm_property_create_bitmask(struct drm_device *dev, |
||
1270 | int flags, const char *name, |
||
1271 | const struct drm_prop_enum_list *props, |
||
5056 | serge | 1272 | int num_props, |
1273 | uint64_t supported_bits); |
||
3031 | serge | 1274 | struct drm_property *drm_property_create_range(struct drm_device *dev, int flags, |
1275 | const char *name, |
||
1276 | uint64_t min, uint64_t max); |
||
5056 | serge | 1277 | struct drm_property *drm_property_create_signed_range(struct drm_device *dev, |
1278 | int flags, const char *name, |
||
1279 | int64_t min, int64_t max); |
||
1280 | struct drm_property *drm_property_create_object(struct drm_device *dev, |
||
1281 | int flags, const char *name, uint32_t type); |
||
1408 | serge | 1282 | extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property); |
1283 | extern int drm_property_add_enum(struct drm_property *property, int index, |
||
1284 | uint64_t value, const char *name); |
||
1285 | extern int drm_mode_create_dvi_i_properties(struct drm_device *dev); |
||
5270 | serge | 1286 | extern int drm_mode_create_tv_properties(struct drm_device *dev, |
1287 | unsigned int num_modes, |
||
1288 | char *modes[]); |
||
1408 | serge | 1289 | extern int drm_mode_create_scaling_mode_property(struct drm_device *dev); |
5056 | serge | 1290 | extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev); |
1408 | serge | 1291 | extern int drm_mode_create_dirty_info_property(struct drm_device *dev); |
5270 | serge | 1292 | extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev); |
1408 | serge | 1293 | |
1294 | extern int drm_mode_connector_attach_encoder(struct drm_connector *connector, |
||
1295 | struct drm_encoder *encoder); |
||
3031 | serge | 1296 | extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc, |
1408 | serge | 1297 | int gamma_size); |
1298 | extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev, |
||
1299 | uint32_t id, uint32_t type); |
||
5056 | serge | 1300 | |
1408 | serge | 1301 | /* IOCTLs */ |
1302 | extern int drm_mode_getresources(struct drm_device *dev, |
||
1303 | void *data, struct drm_file *file_priv); |
||
2967 | Serge | 1304 | extern int drm_mode_getplane_res(struct drm_device *dev, void *data, |
1305 | struct drm_file *file_priv); |
||
1408 | serge | 1306 | extern int drm_mode_getcrtc(struct drm_device *dev, |
1307 | void *data, struct drm_file *file_priv); |
||
1308 | extern int drm_mode_getconnector(struct drm_device *dev, |
||
1309 | void *data, struct drm_file *file_priv); |
||
3391 | Serge | 1310 | extern int drm_mode_set_config_internal(struct drm_mode_set *set); |
1408 | serge | 1311 | extern int drm_mode_setcrtc(struct drm_device *dev, |
1312 | void *data, struct drm_file *file_priv); |
||
2967 | Serge | 1313 | extern int drm_mode_getplane(struct drm_device *dev, |
1314 | void *data, struct drm_file *file_priv); |
||
1315 | extern int drm_mode_setplane(struct drm_device *dev, |
||
1316 | void *data, struct drm_file *file_priv); |
||
1408 | serge | 1317 | extern int drm_mode_cursor_ioctl(struct drm_device *dev, |
1318 | void *data, struct drm_file *file_priv); |
||
4065 | Serge | 1319 | extern int drm_mode_cursor2_ioctl(struct drm_device *dev, |
1320 | void *data, struct drm_file *file_priv); |
||
1408 | serge | 1321 | extern int drm_mode_addfb(struct drm_device *dev, |
1322 | void *data, struct drm_file *file_priv); |
||
2967 | Serge | 1323 | extern int drm_mode_addfb2(struct drm_device *dev, |
1324 | void *data, struct drm_file *file_priv); |
||
1325 | extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth); |
||
1408 | serge | 1326 | extern int drm_mode_rmfb(struct drm_device *dev, |
1327 | void *data, struct drm_file *file_priv); |
||
1328 | extern int drm_mode_getfb(struct drm_device *dev, |
||
1329 | void *data, struct drm_file *file_priv); |
||
1330 | extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev, |
||
1331 | void *data, struct drm_file *file_priv); |
||
1332 | |||
1333 | extern int drm_mode_getproperty_ioctl(struct drm_device *dev, |
||
1334 | void *data, struct drm_file *file_priv); |
||
1335 | extern int drm_mode_getblob_ioctl(struct drm_device *dev, |
||
1336 | void *data, struct drm_file *file_priv); |
||
1337 | extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev, |
||
1338 | void *data, struct drm_file *file_priv); |
||
1339 | extern int drm_mode_getencoder(struct drm_device *dev, |
||
1340 | void *data, struct drm_file *file_priv); |
||
1341 | extern int drm_mode_gamma_get_ioctl(struct drm_device *dev, |
||
1342 | void *data, struct drm_file *file_priv); |
||
1343 | extern int drm_mode_gamma_set_ioctl(struct drm_device *dev, |
||
1344 | void *data, struct drm_file *file_priv); |
||
3391 | Serge | 1345 | extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match); |
5056 | serge | 1346 | extern enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code); |
1408 | serge | 1347 | extern bool drm_detect_hdmi_monitor(struct edid *edid); |
1964 | serge | 1348 | extern bool drm_detect_monitor_audio(struct edid *edid); |
3391 | Serge | 1349 | extern bool drm_rgb_quant_range_selectable(struct edid *edid); |
1408 | serge | 1350 | extern int drm_mode_page_flip_ioctl(struct drm_device *dev, |
1351 | void *data, struct drm_file *file_priv); |
||
1352 | extern int drm_add_modes_noedid(struct drm_connector *connector, |
||
1353 | int hdisplay, int vdisplay); |
||
4559 | Serge | 1354 | extern void drm_set_preferred_mode(struct drm_connector *connector, |
1355 | int hpref, int vpref); |
||
1430 | serge | 1356 | |
2161 | serge | 1357 | extern int drm_edid_header_is_valid(const u8 *raw_edid); |
3031 | serge | 1358 | extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid); |
1430 | serge | 1359 | extern bool drm_edid_is_valid(struct edid *edid); |
5270 | serge | 1360 | |
1361 | extern struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev, |
||
1362 | char topology[8]); |
||
1363 | extern struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev, |
||
1364 | char topology[8]); |
||
1365 | extern void drm_mode_put_tile_group(struct drm_device *dev, |
||
1366 | struct drm_tile_group *tg); |
||
1964 | serge | 1367 | struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev, |
3031 | serge | 1368 | int hsize, int vsize, int fresh, |
1369 | bool rb); |
||
1370 | |||
1371 | extern int drm_mode_create_dumb_ioctl(struct drm_device *dev, |
||
1372 | void *data, struct drm_file *file_priv); |
||
1373 | extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev, |
||
1374 | void *data, struct drm_file *file_priv); |
||
1375 | extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev, |
||
1376 | void *data, struct drm_file *file_priv); |
||
1377 | extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data, |
||
1378 | struct drm_file *file_priv); |
||
1379 | extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, |
||
1380 | struct drm_file *file_priv); |
||
5270 | serge | 1381 | extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane, |
1382 | struct drm_property *property, |
||
1383 | uint64_t value); |
||
3031 | serge | 1384 | |
1385 | extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth, |
||
1386 | int *bpp); |
||
1387 | extern int drm_format_num_planes(uint32_t format); |
||
1388 | extern int drm_format_plane_cpp(uint32_t format, int plane); |
||
1389 | extern int drm_format_horz_chroma_subsampling(uint32_t format); |
||
1390 | extern int drm_format_vert_chroma_subsampling(uint32_t format); |
||
4065 | Serge | 1391 | extern const char *drm_get_format_name(uint32_t format); |
5056 | serge | 1392 | extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev, |
1393 | unsigned int supported_rotations); |
||
1394 | extern unsigned int drm_rotation_simplify(unsigned int rotation, |
||
1395 | unsigned int supported_rotations); |
||
3031 | serge | 1396 | |
4559 | Serge | 1397 | /* Helpers */ |
5056 | serge | 1398 | |
1399 | static inline struct drm_plane *drm_plane_find(struct drm_device *dev, |
||
1400 | uint32_t id) |
||
1401 | { |
||
1402 | struct drm_mode_object *mo; |
||
1403 | mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PLANE); |
||
1404 | return mo ? obj_to_plane(mo) : NULL; |
||
1405 | } |
||
1406 | |||
4559 | Serge | 1407 | static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev, |
1408 | uint32_t id) |
||
1409 | { |
||
1410 | struct drm_mode_object *mo; |
||
1411 | mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC); |
||
1412 | return mo ? obj_to_crtc(mo) : NULL; |
||
1413 | } |
||
1414 | |||
1415 | static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev, |
||
1416 | uint32_t id) |
||
1417 | { |
||
1418 | struct drm_mode_object *mo; |
||
1419 | mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER); |
||
1420 | return mo ? obj_to_encoder(mo) : NULL; |
||
1421 | } |
||
1422 | |||
5056 | serge | 1423 | static inline struct drm_connector *drm_connector_find(struct drm_device *dev, |
1424 | uint32_t id) |
||
1425 | { |
||
1426 | struct drm_mode_object *mo; |
||
1427 | mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CONNECTOR); |
||
1428 | return mo ? obj_to_connector(mo) : NULL; |
||
1429 | } |
||
1430 | |||
1431 | static inline struct drm_property *drm_property_find(struct drm_device *dev, |
||
1432 | uint32_t id) |
||
1433 | { |
||
1434 | struct drm_mode_object *mo; |
||
1435 | mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PROPERTY); |
||
1436 | return mo ? obj_to_property(mo) : NULL; |
||
1437 | } |
||
1438 | |||
1439 | static inline struct drm_property_blob * |
||
1440 | drm_property_blob_find(struct drm_device *dev, uint32_t id) |
||
1441 | { |
||
1442 | struct drm_mode_object *mo; |
||
1443 | mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_BLOB); |
||
1444 | return mo ? obj_to_blob(mo) : NULL; |
||
1445 | } |
||
1446 | |||
1447 | /* Plane list iterator for legacy (overlay only) planes. */ |
||
1448 | #define drm_for_each_legacy_plane(plane, planelist) \ |
||
1449 | list_for_each_entry(plane, planelist, head) \ |
||
1450 | if (plane->type == DRM_PLANE_TYPE_OVERLAY) |
||
1451 | |||
1408 | serge | 1452 | #endif /* __DRM_CRTC_H__ */><>><>><>><>><>><>2) |