blob: e0170bf80bb030356e85489d568bed959749320a [file] [log] [blame]
Dave Airlief453ba02008-11-07 14:05:41 -08001/*
2 * Copyright © 2006 Keith Packard
3 * Copyright © 2007-2008 Dave Airlie
4 * Copyright © 2007-2008 Intel Corporation
5 * Jesse Barnes <jesse.barnes@intel.com>
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 <linux/i2c.h>
29#include <linux/spinlock.h>
30#include <linux/types.h>
31#include <linux/idr.h>
Dave Airlief453ba02008-11-07 14:05:41 -080032#include <linux/fb.h>
Vandana Kannan985e5dc2013-12-19 15:34:07 +053033#include <linux/hdmi.h>
Boris Brezillonb5571e92014-07-22 12:09:10 +020034#include <linux/media-bus-format.h>
David Herrmannd7d2c482014-08-29 12:12:40 +020035#include <uapi/drm/drm_mode.h>
36#include <uapi/drm/drm_fourcc.h>
Rob Clark51fd3712013-11-19 12:10:12 -050037#include <drm/drm_modeset_lock.h>
Jesse Barnes308e5bc2011-11-14 14:51:28 -080038
Dave Airlief453ba02008-11-07 14:05:41 -080039struct drm_device;
40struct drm_mode_set;
41struct drm_framebuffer;
Paulo Zanoni7e3bdf42012-05-15 18:09:01 -030042struct drm_object_properties;
Thierry Reding595887e2012-11-21 15:00:47 +010043struct drm_file;
44struct drm_clip_rect;
Russell King7e435aa2014-06-15 11:07:12 +010045struct device_node;
Daniel Vettere2330f02014-10-29 11:34:56 +010046struct fence;
Dave Airlief453ba02008-11-07 14:05:41 -080047
48#define DRM_MODE_OBJECT_CRTC 0xcccccccc
49#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
50#define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
51#define DRM_MODE_OBJECT_MODE 0xdededede
52#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
53#define DRM_MODE_OBJECT_FB 0xfbfbfbfb
54#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
Jesse Barnes8cf5c912011-11-14 14:51:27 -080055#define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
Rob Clark98f75de2014-05-30 11:37:03 -040056#define DRM_MODE_OBJECT_ANY 0
Dave Airlief453ba02008-11-07 14:05:41 -080057
58struct drm_mode_object {
59 uint32_t id;
60 uint32_t type;
Paulo Zanoni7e3bdf42012-05-15 18:09:01 -030061 struct drm_object_properties *properties;
62};
63
Paulo Zanonife456162012-06-12 11:27:01 -030064#define DRM_OBJECT_MAX_PROPERTY 24
Paulo Zanoni7e3bdf42012-05-15 18:09:01 -030065struct drm_object_properties {
Rob Clark88a48e22014-12-18 16:01:50 -050066 int count, atomic_count;
Rob Clarkb17cd752014-12-16 18:05:30 -050067 /* NOTE: if we ever start dynamically destroying properties (ie.
68 * not at drm_mode_config_cleanup() time), then we'd have to do
69 * a better job of detaching property from mode objects to avoid
70 * dangling property pointers:
71 */
72 struct drm_property *properties[DRM_OBJECT_MAX_PROPERTY];
Rob Clark22b8b132014-12-16 18:05:31 -050073 /* do not read/write values directly, but use drm_object_property_get_value()
74 * and drm_object_property_set_value():
75 */
Paulo Zanoni7e3bdf42012-05-15 18:09:01 -030076 uint64_t values[DRM_OBJECT_MAX_PROPERTY];
Dave Airlief453ba02008-11-07 14:05:41 -080077};
78
Rob Clarkebc44cf2012-09-12 22:22:31 -050079static inline int64_t U642I64(uint64_t val)
80{
81 return (int64_t)*((int64_t *)&val);
82}
83static inline uint64_t I642U64(int64_t val)
84{
85 return (uint64_t)*((uint64_t *)&val);
86}
87
Robert Feketed9c38242015-11-02 16:14:08 +010088/*
89 * Rotation property bits. DRM_ROTATE_<degrees> rotates the image by the
90 * specified amount in degrees in counter clockwise direction. DRM_REFLECT_X and
91 * DRM_REFLECT_Y reflects the image along the specified axis prior to rotation
92 */
Joonas Lahtinen62209072015-10-01 10:00:57 +030093#define DRM_ROTATE_MASK 0x0f
Ville Syrjälä06596962014-07-08 10:31:51 +053094#define DRM_ROTATE_0 0
95#define DRM_ROTATE_90 1
96#define DRM_ROTATE_180 2
97#define DRM_ROTATE_270 3
Joonas Lahtinen62209072015-10-01 10:00:57 +030098#define DRM_REFLECT_MASK (~DRM_ROTATE_MASK)
Ville Syrjälä06596962014-07-08 10:31:51 +053099#define DRM_REFLECT_X 4
100#define DRM_REFLECT_Y 5
101
Daniel Vetter55310002014-01-23 15:52:20 +0100102enum drm_connector_force {
103 DRM_FORCE_UNSPECIFIED,
104 DRM_FORCE_OFF,
105 DRM_FORCE_ON, /* force on analog part normally */
106 DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
Dave Airlief453ba02008-11-07 14:05:41 -0800107};
108
Daniel Vetter55310002014-01-23 15:52:20 +0100109#include <drm/drm_modes.h>
Damien Lespiau4aa17cf2013-09-25 16:45:21 +0100110
Dave Airlief453ba02008-11-07 14:05:41 -0800111enum drm_connector_status {
112 connector_status_connected = 1,
113 connector_status_disconnected = 2,
114 connector_status_unknown = 3,
115};
116
117enum subpixel_order {
118 SubPixelUnknown = 0,
119 SubPixelHorizontalRGB,
120 SubPixelHorizontalBGR,
121 SubPixelVerticalRGB,
122 SubPixelVerticalBGR,
123 SubPixelNone,
124};
125
Jesse Barnesda05a5a72011-04-15 13:48:57 -0700126#define DRM_COLOR_FORMAT_RGB444 (1<<0)
127#define DRM_COLOR_FORMAT_YCRCB444 (1<<1)
128#define DRM_COLOR_FORMAT_YCRCB422 (1<<2)
Dave Airlief453ba02008-11-07 14:05:41 -0800129/*
130 * Describes a given display (e.g. CRT or flat panel) and its limitations.
131 */
132struct drm_display_info {
133 char name[DRM_DISPLAY_INFO_LEN];
Adam Jacksonfb439642010-08-03 14:38:16 -0400134
Dave Airlief453ba02008-11-07 14:05:41 -0800135 /* Physical size */
136 unsigned int width_mm;
137 unsigned int height_mm;
138
Dave Airlief453ba02008-11-07 14:05:41 -0800139 /* Clock limits FIXME: storage format */
140 unsigned int min_vfreq, max_vfreq;
141 unsigned int min_hfreq, max_hfreq;
142 unsigned int pixel_clock;
Jesse Barnes3b112282011-04-15 12:49:23 -0700143 unsigned int bpc;
Dave Airlief453ba02008-11-07 14:05:41 -0800144
Dave Airlief453ba02008-11-07 14:05:41 -0800145 enum subpixel_order subpixel_order;
Jesse Barnesda05a5a72011-04-15 13:48:57 -0700146 u32 color_formats;
Dave Airlief453ba02008-11-07 14:05:41 -0800147
Boris Brezillonb5571e92014-07-22 12:09:10 +0200148 const u32 *bus_formats;
149 unsigned int num_bus_formats;
150
Mario Kleiner5d02626d2014-06-05 09:52:10 -0400151 /* Mask of supported hdmi deep color modes */
152 u8 edid_hdmi_dc_modes;
153
Jesse Barnesebec9a72011-08-03 09:22:54 -0700154 u8 cea_rev;
Dave Airlief453ba02008-11-07 14:05:41 -0800155};
156
Dave Airlie138f9eb2014-10-20 16:17:17 +1000157/* data corresponds to displayid vend/prod/serial */
158struct drm_tile_group {
159 struct kref refcount;
160 struct drm_device *dev;
161 int id;
162 u8 group_data[8];
163};
164
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100165/**
166 * struct drm_framebuffer_funcs - framebuffer hooks
167 */
Dave Airlief453ba02008-11-07 14:05:41 -0800168struct drm_framebuffer_funcs {
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100169 /**
170 * @destroy:
171 *
172 * Clean up framebuffer resources, specifically also unreference the
173 * backing storage. The core guarantees to call this function for every
174 * framebuffer successfully created by ->fb_create() in
Daniel Vetterd55f5322015-12-08 09:49:19 +0100175 * &drm_mode_config_funcs. Drivers must also call
176 * drm_framebuffer_cleanup() to release DRM core resources for this
177 * framebuffer.
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100178 */
Dave Airlief453ba02008-11-07 14:05:41 -0800179 void (*destroy)(struct drm_framebuffer *framebuffer);
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100180
181 /**
182 * @create_handle:
183 *
184 * Create a buffer handle in the driver-specific buffer manager (either
185 * GEM or TTM) valid for the passed-in struct &drm_file. This is used by
186 * the core to implement the GETFB IOCTL, which returns (for
187 * sufficiently priviledged user) also a native buffer handle. This can
188 * be used for seamless transitions between modesetting clients by
189 * copying the current screen contents to a private buffer and blending
190 * between that and the new contents.
191 *
Daniel Vetterd55f5322015-12-08 09:49:19 +0100192 * GEM based drivers should call drm_gem_handle_create() to create the
193 * handle.
194 *
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100195 * RETURNS:
196 *
197 * 0 on success or a negative error code on failure.
198 */
Dave Airlief453ba02008-11-07 14:05:41 -0800199 int (*create_handle)(struct drm_framebuffer *fb,
200 struct drm_file *file_priv,
201 unsigned int *handle);
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100202 /**
203 * @dirty:
Jakob Bornecrantz884840a2009-12-03 23:25:47 +0000204 *
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100205 * Optional callback for the dirty fb IOCTL.
Jakob Bornecrantz884840a2009-12-03 23:25:47 +0000206 *
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100207 * Userspace can notify the driver via this callback that an area of the
208 * framebuffer has changed and should be flushed to the display
209 * hardware. This can also be used internally, e.g. by the fbdev
210 * emulation, though that's not the case currently.
211 *
212 * See documentation in drm_mode.h for the struct drm_mode_fb_dirty_cmd
213 * for more information as all the semantics and arguments have a one to
214 * one mapping on this function.
215 *
216 * RETURNS:
217 *
218 * 0 on success or a negative error code on failure.
Jakob Bornecrantz884840a2009-12-03 23:25:47 +0000219 */
Thomas Hellstrom02b00162010-10-05 12:43:02 +0200220 int (*dirty)(struct drm_framebuffer *framebuffer,
221 struct drm_file *file_priv, unsigned flags,
Jakob Bornecrantz884840a2009-12-03 23:25:47 +0000222 unsigned color, struct drm_clip_rect *clips,
223 unsigned num_clips);
Dave Airlief453ba02008-11-07 14:05:41 -0800224};
225
226struct drm_framebuffer {
227 struct drm_device *dev;
Rob Clarkf7eff602012-09-05 21:48:38 +0000228 /*
229 * Note that the fb is refcounted for the benefit of driver internals,
230 * for example some hw, disabling a CRTC/plane is asynchronous, and
231 * scanout does not actually complete until the next vblank. So some
232 * cleanup (like releasing the reference(s) on the backing GEM bo(s))
233 * should be deferred. In cases like this, the driver would like to
234 * hold a ref to the fb even though it has already been removed from
235 * userspace perspective.
236 */
237 struct kref refcount;
Daniel Vetter4b096ac2012-12-10 21:19:18 +0100238 /*
239 * Place on the dev->mode_config.fb_list, access protected by
240 * dev->mode_config.fb_lock.
241 */
Dave Airlief453ba02008-11-07 14:05:41 -0800242 struct list_head head;
243 struct drm_mode_object base;
244 const struct drm_framebuffer_funcs *funcs;
Ville Syrjälä01f2c772011-12-20 00:06:49 +0200245 unsigned int pitches[4];
246 unsigned int offsets[4];
Rob Clarke3eb3252015-02-05 14:41:52 +0000247 uint64_t modifier[4];
Dave Airlief453ba02008-11-07 14:05:41 -0800248 unsigned int width;
249 unsigned int height;
250 /* depth can be 15 or 16 */
251 unsigned int depth;
252 int bits_per_pixel;
253 int flags;
Jesse Barnes308e5bc2011-11-14 14:51:28 -0800254 uint32_t pixel_format; /* fourcc format */
Dave Airlief453ba02008-11-07 14:05:41 -0800255 struct list_head filp_head;
256};
257
258struct drm_property_blob {
259 struct drm_mode_object base;
Daniel Stone6bcacf52015-04-20 19:22:55 +0100260 struct drm_device *dev;
261 struct kref refcount;
Daniel Stonee2f5d2e2015-05-22 13:34:51 +0100262 struct list_head head_global;
263 struct list_head head_file;
Thierry Redingecbbe592014-05-13 11:36:13 +0200264 size_t length;
Ville Syrjäläd63f5e62012-03-13 12:35:49 +0200265 unsigned char data[];
Dave Airlief453ba02008-11-07 14:05:41 -0800266};
267
268struct drm_property_enum {
269 uint64_t value;
270 struct list_head head;
271 char name[DRM_PROP_NAME_LEN];
272};
273
274struct drm_property {
275 struct list_head head;
276 struct drm_mode_object base;
277 uint32_t flags;
278 char name[DRM_PROP_NAME_LEN];
279 uint32_t num_values;
280 uint64_t *values;
Rob Clark98f75de2014-05-30 11:37:03 -0400281 struct drm_device *dev;
Dave Airlief453ba02008-11-07 14:05:41 -0800282
Daniel Vetter3758b342014-11-19 18:38:10 +0100283 struct list_head enum_list;
Dave Airlief453ba02008-11-07 14:05:41 -0800284};
285
286struct drm_crtc;
287struct drm_connector;
288struct drm_encoder;
Kristian Høgsbergd91d8a32009-11-17 12:43:55 -0500289struct drm_pending_vblank_event;
Jesse Barnes8cf5c912011-11-14 14:51:27 -0800290struct drm_plane;
Sean Paul3b336ec2013-08-14 16:47:37 -0400291struct drm_bridge;
Daniel Vetter144ecb92014-10-27 20:28:44 +0100292struct drm_atomic_state;
293
Daniel Vetter4490d4c2015-12-04 09:45:45 +0100294struct drm_crtc_helper_funcs;
295struct drm_encoder_helper_funcs;
296struct drm_connector_helper_funcs;
297struct drm_plane_helper_funcs;
298
Daniel Vetter144ecb92014-10-27 20:28:44 +0100299/**
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200300 * struct drm_crtc_state - mutable CRTC state
Daniel Vetter07cc0ef2014-11-27 15:49:39 +0100301 * @crtc: backpointer to the CRTC
Daniel Vetter144ecb92014-10-27 20:28:44 +0100302 * @enable: whether the CRTC should be enabled, gates all other state
Daniel Vetterd9b13622014-11-26 16:57:41 +0100303 * @active: whether the CRTC is actively displaying (used for DPMS)
Maarten Lankhorstfc596662015-07-21 13:28:57 +0200304 * @planes_changed: planes on this crtc are updated
305 * @mode_changed: crtc_state->mode or crtc_state->enable has been changed
306 * @active_changed: crtc_state->active has been toggled.
307 * @connectors_changed: connectors to this crtc have been updated
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000308 * @color_mgmt_changed: color management properties have changed (degamma or
309 * gamma LUT or CSC matrix)
Rob Clark6ddd3882014-11-21 15:28:31 -0500310 * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
Maarten Lankhorst4cd9fa52016-01-04 12:53:18 +0100311 * @connector_mask: bitmask of (1 << drm_connector_index(connector)) of attached connectors
Maarten Lankhorste87a52b2016-01-28 15:04:58 +0100312 * @encoder_mask: bitmask of (1 << drm_encoder_index(encoder)) of attached encoders
Daniel Vetter623369e2014-09-16 17:50:47 +0200313 * @last_vblank_count: for helpers and drivers to capture the vblank of the
314 * update to ensure framebuffer cleanup isn't done too early
Daniel Vetter2f324b42014-10-29 11:13:47 +0100315 * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings
Daniel Vetter144ecb92014-10-27 20:28:44 +0100316 * @mode: current mode timings
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000317 * @degamma_lut: Lookup table for converting framebuffer pixel data
318 * before apply the conversion matrix
319 * @ctm: Transformation matrix
320 * @gamma_lut: Lookup table for converting pixel data after the
321 * conversion matrix
Daniel Vetter144ecb92014-10-27 20:28:44 +0100322 * @event: optional pointer to a DRM event to signal upon completion of the
323 * state update
324 * @state: backpointer to global drm_atomic_state
Daniel Vetterd9b13622014-11-26 16:57:41 +0100325 *
326 * Note that the distinction between @enable and @active is rather subtile:
327 * Flipping @active while @enable is set without changing anything else may
328 * never return in a failure from the ->atomic_check callback. Userspace assumes
329 * that a DPMS On will always succeed. In other words: @enable controls resource
330 * assignment, @active controls the actual hardware state.
Daniel Vetter144ecb92014-10-27 20:28:44 +0100331 */
332struct drm_crtc_state {
Daniel Vetter07cc0ef2014-11-27 15:49:39 +0100333 struct drm_crtc *crtc;
334
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200335 bool enable;
Daniel Vetterd9b13622014-11-26 16:57:41 +0100336 bool active;
Daniel Vetter144ecb92014-10-27 20:28:44 +0100337
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100338 /* computed state bits used by helpers and drivers */
339 bool planes_changed : 1;
Daniel Vetter623369e2014-09-16 17:50:47 +0200340 bool mode_changed : 1;
Daniel Vettereab3bbe2015-01-22 16:36:21 +0100341 bool active_changed : 1;
Maarten Lankhorstfc596662015-07-21 13:28:57 +0200342 bool connectors_changed : 1;
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000343 bool color_mgmt_changed : 1;
Daniel Vetter623369e2014-09-16 17:50:47 +0200344
Rob Clark6ddd3882014-11-21 15:28:31 -0500345 /* attached planes bitmask:
346 * WARNING: transitional helpers do not maintain plane_mask so
347 * drivers not converted over to atomic helpers should not rely
348 * on plane_mask being accurate!
349 */
350 u32 plane_mask;
351
Maarten Lankhorst4cd9fa52016-01-04 12:53:18 +0100352 u32 connector_mask;
Maarten Lankhorste87a52b2016-01-28 15:04:58 +0100353 u32 encoder_mask;
Maarten Lankhorst4cd9fa52016-01-04 12:53:18 +0100354
Daniel Vetter623369e2014-09-16 17:50:47 +0200355 /* last_vblank_count: for vblank waits before cleanup */
356 u32 last_vblank_count;
Daniel Vetterc2fcd272014-11-05 00:14:14 +0100357
Daniel Vetter2f324b42014-10-29 11:13:47 +0100358 /* adjusted_mode: for use by helpers and drivers */
359 struct drm_display_mode adjusted_mode;
360
Daniel Vetter144ecb92014-10-27 20:28:44 +0100361 struct drm_display_mode mode;
362
Daniel Stone99cf4a22015-05-25 19:11:51 +0100363 /* blob property to expose current mode to atomic userspace */
364 struct drm_property_blob *mode_blob;
365
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000366 /* blob property to expose color management to userspace */
367 struct drm_property_blob *degamma_lut;
368 struct drm_property_blob *ctm;
369 struct drm_property_blob *gamma_lut;
370
Daniel Vetter144ecb92014-10-27 20:28:44 +0100371 struct drm_pending_vblank_event *event;
372
373 struct drm_atomic_state *state;
374};
Dave Airlief453ba02008-11-07 14:05:41 -0800375
376/**
Daniel Vetter3bf04012014-10-27 16:54:27 +0100377 * struct drm_crtc_funcs - control CRTCs for a given device
Dave Airlief453ba02008-11-07 14:05:41 -0800378 *
379 * The drm_crtc_funcs structure is the central CRTC management structure
380 * in the DRM. Each CRTC controls one or more connectors (note that the name
381 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
382 * connectors, not just CRTs).
383 *
384 * Each driver is responsible for filling out this structure at startup time,
385 * in addition to providing other modesetting features, like i2c and DDC
386 * bus accessors.
387 */
388struct drm_crtc_funcs {
Daniel Vetter88548632015-12-04 09:45:48 +0100389 /**
390 * @reset:
391 *
392 * Reset CRTC hardware and software state to off. This function isn't
393 * called by the core directly, only through drm_mode_config_reset().
394 * It's not a helper hook only for historical reasons.
395 *
396 * Atomic drivers can use drm_atomic_helper_crtc_reset() to reset
397 * atomic state using this hook.
398 */
Chris Wilsoneb033552011-01-24 15:11:08 +0000399 void (*reset)(struct drm_crtc *crtc);
Dave Airlief453ba02008-11-07 14:05:41 -0800400
Daniel Vetterf6da8c62015-12-04 09:46:00 +0100401 /**
402 * @cursor_set:
403 *
404 * Update the cursor image. The cursor position is relative to the CRTC
405 * and can be partially or fully outside of the visible area.
406 *
407 * Note that contrary to all other KMS functions the legacy cursor entry
408 * points don't take a framebuffer object, but instead take directly a
409 * raw buffer object id from the driver's buffer manager (which is
410 * either GEM or TTM for current drivers).
411 *
412 * This entry point is deprecated, drivers should instead implement
413 * universal plane support and register a proper cursor plane using
414 * drm_crtc_init_with_planes().
415 *
416 * This callback is optional
417 *
418 * RETURNS:
419 *
420 * 0 on success or a negative error code on failure.
421 */
Dave Airlief453ba02008-11-07 14:05:41 -0800422 int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
423 uint32_t handle, uint32_t width, uint32_t height);
Daniel Vetterf6da8c62015-12-04 09:46:00 +0100424
425 /**
426 * @cursor_set2:
427 *
428 * Update the cursor image, including hotspot information. The hotspot
429 * must not affect the cursor position in CRTC coordinates, but is only
430 * meant as a hint for virtualized display hardware to coordinate the
431 * guests and hosts cursor position. The cursor hotspot is relative to
432 * the cursor image. Otherwise this works exactly like @cursor_set.
433 *
434 * This entry point is deprecated, drivers should instead implement
435 * universal plane support and register a proper cursor plane using
436 * drm_crtc_init_with_planes().
437 *
438 * This callback is optional.
439 *
440 * RETURNS:
441 *
442 * 0 on success or a negative error code on failure.
443 */
Dave Airlie4c813d42013-06-20 11:48:52 +1000444 int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv,
445 uint32_t handle, uint32_t width, uint32_t height,
446 int32_t hot_x, int32_t hot_y);
Daniel Vetterf6da8c62015-12-04 09:46:00 +0100447
448 /**
449 * @cursor_move:
450 *
451 * Update the cursor position. The cursor does not need to be visible
452 * when this hook is called.
453 *
454 * This entry point is deprecated, drivers should instead implement
455 * universal plane support and register a proper cursor plane using
456 * drm_crtc_init_with_planes().
457 *
458 * This callback is optional.
459 *
460 * RETURNS:
461 *
462 * 0 on success or a negative error code on failure.
463 */
Dave Airlief453ba02008-11-07 14:05:41 -0800464 int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
465
Daniel Vetterf6da8c62015-12-04 09:46:00 +0100466 /**
467 * @gamma_set:
468 *
469 * Set gamma on the CRTC.
470 *
471 * This callback is optional.
472 *
473 * NOTE:
474 *
475 * Drivers that support gamma tables and also fbdev emulation through
476 * the provided helper library need to take care to fill out the gamma
477 * hooks for both. Currently there's a bit an unfortunate duplication
478 * going on, which should eventually be unified to just one set of
479 * hooks.
480 */
Dave Airlief453ba02008-11-07 14:05:41 -0800481 void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
James Simmons72034252010-08-03 01:33:19 +0100482 uint32_t start, uint32_t size);
Daniel Vetter88548632015-12-04 09:45:48 +0100483
484 /**
485 * @destroy:
486 *
487 * Clean up plane resources. This is only called at driver unload time
488 * through drm_mode_config_cleanup() since a CRTC cannot be hotplugged
489 * in DRM.
490 */
Dave Airlief453ba02008-11-07 14:05:41 -0800491 void (*destroy)(struct drm_crtc *crtc);
492
Daniel Vetterf6da8c62015-12-04 09:46:00 +0100493 /**
494 * @set_config:
495 *
496 * This is the main legacy entry point to change the modeset state on a
497 * CRTC. All the details of the desired configuration are passed in a
498 * struct &drm_mode_set - see there for details.
499 *
500 * Drivers implementing atomic modeset should use
501 * drm_atomic_helper_set_config() to implement this hook.
502 *
503 * RETURNS:
504 *
505 * 0 on success or a negative error code on failure.
506 */
Dave Airlief453ba02008-11-07 14:05:41 -0800507 int (*set_config)(struct drm_mode_set *set);
Kristian Høgsbergd91d8a32009-11-17 12:43:55 -0500508
Daniel Vetterf6da8c62015-12-04 09:46:00 +0100509 /**
510 * @page_flip:
511 *
512 * Legacy entry point to schedule a flip to the given framebuffer.
513 *
514 * Page flipping is a synchronization mechanism that replaces the frame
515 * buffer being scanned out by the CRTC with a new frame buffer during
516 * vertical blanking, avoiding tearing (except when requested otherwise
517 * through the DRM_MODE_PAGE_FLIP_ASYNC flag). When an application
518 * requests a page flip the DRM core verifies that the new frame buffer
519 * is large enough to be scanned out by the CRTC in the currently
520 * configured mode and then calls the CRTC ->page_flip() operation with a
521 * pointer to the new frame buffer.
522 *
523 * The driver must wait for any pending rendering to the new framebuffer
524 * to complete before executing the flip. It should also wait for any
525 * pending rendering from other drivers if the underlying buffer is a
526 * shared dma-buf.
527 *
528 * An application can request to be notified when the page flip has
529 * completed. The drm core will supply a struct &drm_event in the event
530 * parameter in this case. This can be handled by the
531 * drm_crtc_send_vblank_event() function, which the driver should call on
532 * the provided event upon completion of the flip. Note that if
533 * the driver supports vblank signalling and timestamping the vblank
534 * counters and timestamps must agree with the ones returned from page
535 * flip events. With the current vblank helper infrastructure this can
536 * be achieved by holding a vblank reference while the page flip is
537 * pending, acquired through drm_crtc_vblank_get() and released with
538 * drm_crtc_vblank_put(). Drivers are free to implement their own vblank
539 * counter and timestamp tracking though, e.g. if they have accurate
540 * timestamp registers in hardware.
541 *
542 * FIXME:
543 *
544 * Up to that point drivers need to manage events themselves and can use
545 * even->base.list freely for that. Specifically they need to ensure
546 * that they don't send out page flip (or vblank) events for which the
547 * corresponding drm file has been closed already. The drm core
548 * unfortunately does not (yet) take care of that. Therefore drivers
549 * currently must clean up and release pending events in their
550 * ->preclose driver function.
551 *
552 * This callback is optional.
553 *
554 * NOTE:
555 *
556 * Very early versions of the KMS ABI mandated that the driver must
557 * block (but not reject) any rendering to the old framebuffer until the
558 * flip operation has completed and the old framebuffer is no longer
559 * visible. This requirement has been lifted, and userspace is instead
560 * expected to request delivery of an event and wait with recycling old
561 * buffers until such has been received.
562 *
563 * RETURNS:
564 *
565 * 0 on success or a negative error code on failure. Note that if a
566 * ->page_flip() operation is already pending the callback should return
567 * -EBUSY. Pageflips on a disabled CRTC (either by setting a NULL mode
568 * or just runtime disabled through DPMS respectively the new atomic
Daniel Vetter4cba6852015-12-08 09:49:20 +0100569 * "ACTIVE" state) should result in an -EINVAL error code. Note that
570 * drm_atomic_helper_page_flip() checks this already for atomic drivers.
Kristian Høgsbergd91d8a32009-11-17 12:43:55 -0500571 */
572 int (*page_flip)(struct drm_crtc *crtc,
573 struct drm_framebuffer *fb,
Keith Packarded8d1972013-07-22 18:49:58 -0700574 struct drm_pending_vblank_event *event,
575 uint32_t flags);
Paulo Zanonibffd9de02012-05-15 18:09:05 -0300576
Daniel Vetter88548632015-12-04 09:45:48 +0100577 /**
578 * @set_property:
579 *
580 * This is the legacy entry point to update a property attached to the
581 * CRTC.
582 *
583 * Drivers implementing atomic modeset should use
584 * drm_atomic_helper_crtc_set_property() to implement this hook.
585 *
586 * This callback is optional if the driver does not support any legacy
587 * driver-private properties.
588 *
589 * RETURNS:
590 *
591 * 0 on success or a negative error code on failure.
592 */
Paulo Zanonibffd9de02012-05-15 18:09:05 -0300593 int (*set_property)(struct drm_crtc *crtc,
594 struct drm_property *property, uint64_t val);
Daniel Vetter144ecb92014-10-27 20:28:44 +0100595
Daniel Vetter88548632015-12-04 09:45:48 +0100596 /**
597 * @atomic_duplicate_state:
598 *
599 * Duplicate the current atomic state for this CRTC and return it.
600 * The core and helpers gurantee that any atomic state duplicated with
601 * this hook and still owned by the caller (i.e. not transferred to the
602 * driver by calling ->atomic_commit() from struct
603 * &drm_mode_config_funcs) will be cleaned up by calling the
604 * @atomic_destroy_state hook in this structure.
605 *
606 * Atomic drivers which don't subclass struct &drm_crtc should use
607 * drm_atomic_helper_crtc_duplicate_state(). Drivers that subclass the
608 * state structure to extend it with driver-private state should use
609 * __drm_atomic_helper_crtc_duplicate_state() to make sure shared state is
610 * duplicated in a consistent fashion across drivers.
611 *
612 * It is an error to call this hook before crtc->state has been
613 * initialized correctly.
614 *
615 * NOTE:
616 *
617 * If the duplicate state references refcounted resources this hook must
618 * acquire a reference for each of them. The driver must release these
619 * references again in @atomic_destroy_state.
620 *
621 * RETURNS:
622 *
623 * Duplicated atomic state or NULL when the allocation failed.
624 */
Daniel Vetter144ecb92014-10-27 20:28:44 +0100625 struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
Daniel Vetter88548632015-12-04 09:45:48 +0100626
627 /**
628 * @atomic_destroy_state:
629 *
630 * Destroy a state duplicated with @atomic_duplicate_state and release
631 * or unreference all resources it references
632 */
Daniel Vetter144ecb92014-10-27 20:28:44 +0100633 void (*atomic_destroy_state)(struct drm_crtc *crtc,
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200634 struct drm_crtc_state *state);
Daniel Vetter88548632015-12-04 09:45:48 +0100635
636 /**
637 * @atomic_set_property:
638 *
639 * Decode a driver-private property value and store the decoded value
640 * into the passed-in state structure. Since the atomic core decodes all
641 * standardized properties (even for extensions beyond the core set of
642 * properties which might not be implemented by all drivers) this
643 * requires drivers to subclass the state structure.
644 *
645 * Such driver-private properties should really only be implemented for
646 * truly hardware/vendor specific state. Instead it is preferred to
647 * standardize atomic extension and decode the properties used to expose
648 * such an extension in the core.
649 *
650 * Do not call this function directly, use
651 * drm_atomic_crtc_set_property() instead.
652 *
653 * This callback is optional if the driver does not support any
654 * driver-private atomic properties.
655 *
656 * NOTE:
657 *
658 * This function is called in the state assembly phase of atomic
659 * modesets, which can be aborted for any reason (including on
660 * userspace's request to just check whether a configuration would be
661 * possible). Drivers MUST NOT touch any persistent state (hardware or
662 * software) or data structures except the passed in @state parameter.
663 *
664 * Also since userspace controls in which order properties are set this
665 * function must not do any input validation (since the state update is
666 * incomplete and hence likely inconsistent). Instead any such input
667 * validation must be done in the various atomic_check callbacks.
668 *
669 * RETURNS:
670 *
671 * 0 if the property has been found, -EINVAL if the property isn't
672 * implemented by the driver (which should never happen, the core only
673 * asks for properties attached to this CRTC). No other validation is
674 * allowed by the driver. The core already checks that the property
675 * value is within the range (integer, valid enum value, ...) the driver
676 * set when registering the property.
677 */
Daniel Vetter144ecb92014-10-27 20:28:44 +0100678 int (*atomic_set_property)(struct drm_crtc *crtc,
679 struct drm_crtc_state *state,
680 struct drm_property *property,
681 uint64_t val);
Daniel Vetter88548632015-12-04 09:45:48 +0100682 /**
683 * @atomic_get_property:
684 *
685 * Reads out the decoded driver-private property. This is used to
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100686 * implement the GETCRTC IOCTL.
Daniel Vetter88548632015-12-04 09:45:48 +0100687 *
688 * Do not call this function directly, use
689 * drm_atomic_crtc_get_property() instead.
690 *
691 * This callback is optional if the driver does not support any
692 * driver-private atomic properties.
693 *
694 * RETURNS:
695 *
696 * 0 on success, -EINVAL if the property isn't implemented by the
697 * driver (which should never happen, the core only asks for
698 * properties attached to this CRTC).
699 */
Rob Clarkac9c9252014-12-18 16:01:47 -0500700 int (*atomic_get_property)(struct drm_crtc *crtc,
701 const struct drm_crtc_state *state,
702 struct drm_property *property,
703 uint64_t *val);
Dave Airlief453ba02008-11-07 14:05:41 -0800704};
705
706/**
Daniel Vetter3bf04012014-10-27 16:54:27 +0100707 * struct drm_crtc - central CRTC control structure
Jesse Barnes77491632011-11-07 12:03:14 -0800708 * @dev: parent DRM device
Daniel Vetter2c0c33d2014-10-27 20:19:38 +0100709 * @port: OF node used by drm_of_find_possible_crtcs()
Jesse Barnes77491632011-11-07 12:03:14 -0800710 * @head: list management
Rob Clark51fd3712013-11-19 12:10:12 -0500711 * @mutex: per-CRTC locking
Jesse Barnes77491632011-11-07 12:03:14 -0800712 * @base: base KMS object for ID tracking etc.
Matt Ropere13161a2014-04-01 15:22:38 -0700713 * @primary: primary plane for this CRTC
714 * @cursor: cursor plane for this CRTC
Daniel Vetter2c0c33d2014-10-27 20:19:38 +0100715 * @cursor_x: current x position of the cursor, used for universal cursor planes
716 * @cursor_y: current y position of the cursor, used for universal cursor planes
Dave Airlief453ba02008-11-07 14:05:41 -0800717 * @enabled: is this CRTC enabled?
Jesse Barnes77491632011-11-07 12:03:14 -0800718 * @mode: current mode timings
719 * @hwmode: mode timings as programmed to hw regs
Dave Airlief453ba02008-11-07 14:05:41 -0800720 * @x: x position on screen
721 * @y: y position on screen
Dave Airlief453ba02008-11-07 14:05:41 -0800722 * @funcs: CRTC control functions
Jesse Barnes77491632011-11-07 12:03:14 -0800723 * @gamma_size: size of gamma ramp
724 * @gamma_store: gamma ramp values
Jesse Barnes77491632011-11-07 12:03:14 -0800725 * @helper_private: mid-layer private data
Paulo Zanonibffd9de02012-05-15 18:09:05 -0300726 * @properties: property tracking for this CRTC
Daniel Vetter144ecb92014-10-27 20:28:44 +0100727 * @state: current atomic state for this CRTC
Daniel Vetter2c0c33d2014-10-27 20:19:38 +0100728 * @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100729 * legacy IOCTLs
Dave Airlief453ba02008-11-07 14:05:41 -0800730 *
731 * Each CRTC may have one or more connectors associated with it. This structure
732 * allows the CRTC to be controlled.
733 */
734struct drm_crtc {
735 struct drm_device *dev;
Russell King7e435aa2014-06-15 11:07:12 +0100736 struct device_node *port;
Dave Airlief453ba02008-11-07 14:05:41 -0800737 struct list_head head;
738
Ville Syrjäläfa3ab4c2015-12-08 18:41:53 +0200739 char *name;
740
Daniel Vetter3bf04012014-10-27 16:54:27 +0100741 /*
Daniel Vetter29494c12012-12-02 02:18:25 +0100742 * crtc mutex
743 *
744 * This provides a read lock for the overall crtc state (mode, dpms
745 * state, ...) and a write lock for everything which can be update
746 * without a full modeset (fb, cursor data, ...)
747 */
Rob Clark51fd3712013-11-19 12:10:12 -0500748 struct drm_modeset_lock mutex;
Daniel Vetter29494c12012-12-02 02:18:25 +0100749
Dave Airlief453ba02008-11-07 14:05:41 -0800750 struct drm_mode_object base;
751
Matt Ropere13161a2014-04-01 15:22:38 -0700752 /* primary and cursor planes for CRTC */
753 struct drm_plane *primary;
754 struct drm_plane *cursor;
755
Matt Roper161d0dc2014-06-10 08:28:10 -0700756 /* position of cursor plane on crtc */
757 int cursor_x;
758 int cursor_y;
759
Dave Airlief453ba02008-11-07 14:05:41 -0800760 bool enabled;
761
Mario Kleiner27641c32010-10-23 04:20:23 +0200762 /* Requested mode from modesetting. */
Dave Airlief453ba02008-11-07 14:05:41 -0800763 struct drm_display_mode mode;
764
Mario Kleiner27641c32010-10-23 04:20:23 +0200765 /* Programmed mode in hw, after adjustments for encoders,
766 * crtc, panel scaling etc. Needed for timestamping etc.
767 */
768 struct drm_display_mode hwmode;
769
Dave Airlief453ba02008-11-07 14:05:41 -0800770 int x, y;
Dave Airlief453ba02008-11-07 14:05:41 -0800771 const struct drm_crtc_funcs *funcs;
772
Lionel Landwerlin5488dc12016-02-26 17:05:00 +0000773 /* Legacy FB CRTC gamma size for reporting to userspace */
Dave Airlief453ba02008-11-07 14:05:41 -0800774 uint32_t gamma_size;
775 uint16_t *gamma_store;
776
777 /* if you are using the helper */
Daniel Vetter4490d4c2015-12-04 09:45:45 +0100778 const struct drm_crtc_helper_funcs *helper_private;
Paulo Zanonibffd9de02012-05-15 18:09:05 -0300779
780 struct drm_object_properties properties;
Daniel Vetterd059f652014-07-25 18:07:40 +0200781
Daniel Vetter144ecb92014-10-27 20:28:44 +0100782 struct drm_crtc_state *state;
783
Daniel Vetterd059f652014-07-25 18:07:40 +0200784 /*
Daniel Vetterc6b0ca32015-12-04 09:46:01 +0100785 * For legacy crtc IOCTLs so that atomic drivers can get at the locking
Daniel Vetterd059f652014-07-25 18:07:40 +0200786 * acquire context.
787 */
788 struct drm_modeset_acquire_ctx *acquire_ctx;
Dave Airlief453ba02008-11-07 14:05:41 -0800789};
790
Daniel Vetter144ecb92014-10-27 20:28:44 +0100791/**
792 * struct drm_connector_state - mutable connector state
Daniel Vetter07cc0ef2014-11-27 15:49:39 +0100793 * @connector: backpointer to the connector
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200794 * @crtc: CRTC to connect connector to, NULL if disabled
Daniel Vetter623369e2014-09-16 17:50:47 +0200795 * @best_encoder: can be used by helpers and drivers to select the encoder
Daniel Vetter144ecb92014-10-27 20:28:44 +0100796 * @state: backpointer to global drm_atomic_state
797 */
798struct drm_connector_state {
Daniel Vetter07cc0ef2014-11-27 15:49:39 +0100799 struct drm_connector *connector;
800
Rob Clark6ddd3882014-11-21 15:28:31 -0500801 struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_connector() */
Daniel Vetter144ecb92014-10-27 20:28:44 +0100802
Daniel Vetter623369e2014-09-16 17:50:47 +0200803 struct drm_encoder *best_encoder;
804
Daniel Vetter144ecb92014-10-27 20:28:44 +0100805 struct drm_atomic_state *state;
806};
Dave Airlief453ba02008-11-07 14:05:41 -0800807
808/**
Daniel Vetter3bf04012014-10-27 16:54:27 +0100809 * struct drm_connector_funcs - control connectors on a given device
Daniel Vetter144ecb92014-10-27 20:28:44 +0100810 *
Dave Airlief453ba02008-11-07 14:05:41 -0800811 * Each CRTC may have one or more connectors attached to it. The functions
812 * below allow the core DRM code to control connectors, enumerate available modes,
813 * etc.
814 */
815struct drm_connector_funcs {
Daniel Vetter6fe14ac2015-12-04 09:45:58 +0100816 /**
817 * @dpms:
818 *
819 * Legacy entry point to set the per-connector DPMS state. Legacy DPMS
820 * is exposed as a standard property on the connector, but diverted to
821 * this callback in the drm core. Note that atomic drivers don't
822 * implement the 4 level DPMS support on the connector any more, but
823 * instead only have an on/off "ACTIVE" property on the CRTC object.
824 *
825 * Drivers implementing atomic modeset should use
826 * drm_atomic_helper_connector_dpms() to implement this hook.
827 *
828 * RETURNS:
829 *
830 * 0 on success or a negative error code on failure.
831 */
Maarten Lankhorst9a69a9a2015-07-21 11:34:55 +0200832 int (*dpms)(struct drm_connector *connector, int mode);
Daniel Vetter88548632015-12-04 09:45:48 +0100833
834 /**
835 * @reset:
836 *
837 * Reset connector hardware and software state to off. This function isn't
838 * called by the core directly, only through drm_mode_config_reset().
839 * It's not a helper hook only for historical reasons.
840 *
841 * Atomic drivers can use drm_atomic_helper_connector_reset() to reset
842 * atomic state using this hook.
843 */
Chris Wilsoneb033552011-01-24 15:11:08 +0000844 void (*reset)(struct drm_connector *connector);
Chris Wilson930a9e22010-09-14 11:07:23 +0100845
Daniel Vetter6fe14ac2015-12-04 09:45:58 +0100846 /**
847 * @detect:
848 *
849 * Check to see if anything is attached to the connector. The parameter
850 * force is set to false whilst polling, true when checking the
851 * connector due to a user request. force can be used by the driver to
852 * avoid expensive, destructive operations during automated probing.
853 *
854 * FIXME:
855 *
856 * Note that this hook is only called by the probe helper. It's not in
857 * the helper library vtable purely for historical reasons. The only DRM
858 * core entry point to probe connector state is @fill_modes.
859 *
860 * RETURNS:
861 *
862 * drm_connector_status indicating the connector's status.
Chris Wilson930a9e22010-09-14 11:07:23 +0100863 */
Chris Wilson7b334fc2010-09-09 23:51:02 +0100864 enum drm_connector_status (*detect)(struct drm_connector *connector,
Chris Wilson930a9e22010-09-14 11:07:23 +0100865 bool force);
Daniel Vetter6fe14ac2015-12-04 09:45:58 +0100866
867 /**
868 * @force:
869 *
870 * This function is called to update internal encoder state when the
871 * connector is forced to a certain state by userspace, either through
872 * the sysfs interfaces or on the kernel cmdline. In that case the
873 * @detect callback isn't called.
874 *
875 * FIXME:
876 *
877 * Note that this hook is only called by the probe helper. It's not in
878 * the helper library vtable purely for historical reasons. The only DRM
879 * core entry point to probe connector state is @fill_modes.
880 */
881 void (*force)(struct drm_connector *connector);
882
883 /**
884 * @fill_modes:
885 *
886 * Entry point for output detection and basic mode validation. The
887 * driver should reprobe the output if needed (e.g. when hotplug
888 * handling is unreliable), add all detected modes to connector->modes
889 * and filter out any the device can't support in any configuration. It
890 * also needs to filter out any modes wider or higher than the
891 * parameters max_width and max_height indicate.
892 *
893 * The drivers must also prune any modes no longer valid from
894 * connector->modes. Furthermore it must update connector->status and
895 * connector->edid. If no EDID has been received for this output
896 * connector->edid must be NULL.
897 *
898 * Drivers using the probe helpers should use
899 * drm_helper_probe_single_connector_modes() or
900 * drm_helper_probe_single_connector_modes_nomerge() to implement this
901 * function.
902 *
903 * RETURNS:
904 *
905 * The number of modes detected and filled into connector->modes.
906 */
Jesse Barnes40a518d2009-01-12 12:05:32 -0800907 int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
Daniel Vetter88548632015-12-04 09:45:48 +0100908
909 /**
910 * @set_property:
911 *
912 * This is the legacy entry point to update a property attached to the
913 * connector.
914 *
915 * Drivers implementing atomic modeset should use
916 * drm_atomic_helper_connector_set_property() to implement this hook.
917 *
918 * This callback is optional if the driver does not support any legacy
919 * driver-private properties.
920 *
921 * RETURNS:
922 *
923 * 0 on success or a negative error code on failure.
924 */
Dave Airlief453ba02008-11-07 14:05:41 -0800925 int (*set_property)(struct drm_connector *connector, struct drm_property *property,
926 uint64_t val);
Daniel Vetter88548632015-12-04 09:45:48 +0100927
928 /**
929 * @destroy:
930 *
931 * Clean up connector resources. This is called at driver unload time
932 * through drm_mode_config_cleanup(). It can also be called at runtime
933 * when a connector is being hot-unplugged for drivers that support
934 * connector hotplugging (e.g. DisplayPort MST).
935 */
Dave Airlief453ba02008-11-07 14:05:41 -0800936 void (*destroy)(struct drm_connector *connector);
Daniel Vetter144ecb92014-10-27 20:28:44 +0100937
Daniel Vetter88548632015-12-04 09:45:48 +0100938 /**
939 * @atomic_duplicate_state:
940 *
941 * Duplicate the current atomic state for this connector and return it.
942 * The core and helpers gurantee that any atomic state duplicated with
943 * this hook and still owned by the caller (i.e. not transferred to the
944 * driver by calling ->atomic_commit() from struct
945 * &drm_mode_config_funcs) will be cleaned up by calling the
946 * @atomic_destroy_state hook in this structure.
947 *
948 * Atomic drivers which don't subclass struct &drm_connector_state should use
949 * drm_atomic_helper_connector_duplicate_state(). Drivers that subclass the
950 * state structure to extend it with driver-private state should use
951 * __drm_atomic_helper_connector_duplicate_state() to make sure shared state is
952 * duplicated in a consistent fashion across drivers.
953 *
954 * It is an error to call this hook before connector->state has been
955 * initialized correctly.
956 *
957 * NOTE:
958 *
959 * If the duplicate state references refcounted resources this hook must
960 * acquire a reference for each of them. The driver must release these
961 * references again in @atomic_destroy_state.
962 *
963 * RETURNS:
964 *
965 * Duplicated atomic state or NULL when the allocation failed.
966 */
Daniel Vetter144ecb92014-10-27 20:28:44 +0100967 struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);
Daniel Vetter88548632015-12-04 09:45:48 +0100968
969 /**
970 * @atomic_destroy_state:
971 *
972 * Destroy a state duplicated with @atomic_duplicate_state and release
973 * or unreference all resources it references
974 */
Daniel Vetter144ecb92014-10-27 20:28:44 +0100975 void (*atomic_destroy_state)(struct drm_connector *connector,
Daniel Vettercc4ceb42014-07-25 21:30:38 +0200976 struct drm_connector_state *state);
Daniel Vetter88548632015-12-04 09:45:48 +0100977
978 /**
979 * @atomic_set_property:
980 *
981 * Decode a driver-private property value and store the decoded value
982 * into the passed-in state structure. Since the atomic core decodes all
983 * standardized properties (even for extensions beyond the core set of
984 * properties which might not be implemented by all drivers) this
985 * requires drivers to subclass the state structure.
986 *
987 * Such driver-private properties should really only be implemented for
988 * truly hardware/vendor specific state. Instead it is preferred to
989 * standardize atomic extension and decode the properties used to expose
990 * such an extension in the core.
991 *
992 * Do not call this function directly, use
993 * drm_atomic_connector_set_property() instead.
994 *
995 * This callback is optional if the driver does not support any
996 * driver-private atomic properties.
997 *
998 * NOTE:
999 *
1000 * This function is called in the state assembly phase of atomic
1001 * modesets, which can be aborted for any reason (including on
1002 * userspace's request to just check whether a configuration would be
1003 * possible). Drivers MUST NOT touch any persistent state (hardware or
1004 * software) or data structures except the passed in @state parameter.
1005 *
1006 * Also since userspace controls in which order properties are set this
1007 * function must not do any input validation (since the state update is
1008 * incomplete and hence likely inconsistent). Instead any such input
1009 * validation must be done in the various atomic_check callbacks.
1010 *
1011 * RETURNS:
1012 *
1013 * 0 if the property has been found, -EINVAL if the property isn't
1014 * implemented by the driver (which shouldn't ever happen, the core only
1015 * asks for properties attached to this connector). No other validation
1016 * is allowed by the driver. The core already checks that the property
1017 * value is within the range (integer, valid enum value, ...) the driver
1018 * set when registering the property.
1019 */
Daniel Vetter144ecb92014-10-27 20:28:44 +01001020 int (*atomic_set_property)(struct drm_connector *connector,
1021 struct drm_connector_state *state,
1022 struct drm_property *property,
1023 uint64_t val);
Daniel Vetter88548632015-12-04 09:45:48 +01001024
1025 /**
1026 * @atomic_get_property:
1027 *
1028 * Reads out the decoded driver-private property. This is used to
Daniel Vetterc6b0ca32015-12-04 09:46:01 +01001029 * implement the GETCONNECTOR IOCTL.
Daniel Vetter88548632015-12-04 09:45:48 +01001030 *
1031 * Do not call this function directly, use
1032 * drm_atomic_connector_get_property() instead.
1033 *
1034 * This callback is optional if the driver does not support any
1035 * driver-private atomic properties.
1036 *
1037 * RETURNS:
1038 *
1039 * 0 on success, -EINVAL if the property isn't implemented by the
1040 * driver (which shouldn't ever happen, the core only asks for
1041 * properties attached to this connector).
1042 */
Rob Clarkac9c9252014-12-18 16:01:47 -05001043 int (*atomic_get_property)(struct drm_connector *connector,
1044 const struct drm_connector_state *state,
1045 struct drm_property *property,
1046 uint64_t *val);
Dave Airlief453ba02008-11-07 14:05:41 -08001047};
1048
Jesse Barnes6c3db922011-11-07 12:03:16 -08001049/**
Daniel Vetter3bf04012014-10-27 16:54:27 +01001050 * struct drm_encoder_funcs - encoder controls
Jesse Barnes6c3db922011-11-07 12:03:16 -08001051 *
1052 * Encoders sit between CRTCs and connectors.
1053 */
Dave Airlief453ba02008-11-07 14:05:41 -08001054struct drm_encoder_funcs {
Daniel Vetter88548632015-12-04 09:45:48 +01001055 /**
1056 * @reset:
1057 *
1058 * Reset encoder hardware and software state to off. This function isn't
1059 * called by the core directly, only through drm_mode_config_reset().
1060 * It's not a helper hook only for historical reasons.
1061 */
Chris Wilsoneb033552011-01-24 15:11:08 +00001062 void (*reset)(struct drm_encoder *encoder);
Daniel Vetter88548632015-12-04 09:45:48 +01001063
1064 /**
1065 * @destroy:
1066 *
1067 * Clean up encoder resources. This is only called at driver unload time
1068 * through drm_mode_config_cleanup() since an encoder cannot be
1069 * hotplugged in DRM.
1070 */
Dave Airlief453ba02008-11-07 14:05:41 -08001071 void (*destroy)(struct drm_encoder *encoder);
1072};
1073
Ben Skeggsafe887d2012-01-12 16:00:57 +10001074#define DRM_CONNECTOR_MAX_ENCODER 3
Dave Airlief453ba02008-11-07 14:05:41 -08001075
1076/**
Daniel Vetter3bf04012014-10-27 16:54:27 +01001077 * struct drm_encoder - central DRM encoder structure
Jesse Barnesdb3e4492011-11-07 12:03:17 -08001078 * @dev: parent DRM device
1079 * @head: list management
1080 * @base: base KMS object
Jani Nikulae5748942014-05-14 16:58:20 +03001081 * @name: encoder name
Jesse Barnesdb3e4492011-11-07 12:03:17 -08001082 * @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h
1083 * @possible_crtcs: bitmask of potential CRTC bindings
1084 * @possible_clones: bitmask of potential sibling encoders for cloning
1085 * @crtc: currently bound CRTC
Sean Paul3b336ec2013-08-14 16:47:37 -04001086 * @bridge: bridge associated to the encoder
Jesse Barnesdb3e4492011-11-07 12:03:17 -08001087 * @funcs: control functions
1088 * @helper_private: mid-layer private data
1089 *
1090 * CRTCs drive pixels to encoders, which convert them into signals
1091 * appropriate for a given connector or set of connectors.
Dave Airlief453ba02008-11-07 14:05:41 -08001092 */
1093struct drm_encoder {
1094 struct drm_device *dev;
1095 struct list_head head;
1096
1097 struct drm_mode_object base;
Jani Nikulae5748942014-05-14 16:58:20 +03001098 char *name;
Dave Airlief453ba02008-11-07 14:05:41 -08001099 int encoder_type;
1100 uint32_t possible_crtcs;
1101 uint32_t possible_clones;
1102
1103 struct drm_crtc *crtc;
Sean Paul3b336ec2013-08-14 16:47:37 -04001104 struct drm_bridge *bridge;
Dave Airlief453ba02008-11-07 14:05:41 -08001105 const struct drm_encoder_funcs *funcs;
Daniel Vetter4490d4c2015-12-04 09:45:45 +01001106 const struct drm_encoder_helper_funcs *helper_private;
Dave Airlief453ba02008-11-07 14:05:41 -08001107};
1108
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001109/* should we poll this connector for connects and disconnects */
1110/* hot plug detectable */
1111#define DRM_CONNECTOR_POLL_HPD (1 << 0)
1112/* poll for connections */
1113#define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
1114/* can cleanly poll for disconnections without flickering the screen */
1115/* DACs should rarely do this without a lot of testing */
1116#define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
1117
Wu Fengguang76adaa342011-09-05 14:23:20 +08001118#define MAX_ELD_BYTES 128
1119
Dave Airlief453ba02008-11-07 14:05:41 -08001120/**
Daniel Vetter3bf04012014-10-27 16:54:27 +01001121 * struct drm_connector - central DRM connector control structure
Jesse Barnes72252542011-11-07 12:03:18 -08001122 * @dev: parent DRM device
1123 * @kdev: kernel device for sysfs attributes
1124 * @attr: sysfs attributes
1125 * @head: list management
1126 * @base: base KMS object
Jani Nikula2abdd312014-05-14 16:58:19 +03001127 * @name: connector name
Jesse Barnes72252542011-11-07 12:03:18 -08001128 * @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
1129 * @connector_type_id: index into connector type enum
Dave Airlief453ba02008-11-07 14:05:41 -08001130 * @interlace_allowed: can this connector handle interlaced modes?
1131 * @doublescan_allowed: can this connector handle doublescan?
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01001132 * @stereo_allowed: can this connector handle stereo modes?
Jesse Barnes72252542011-11-07 12:03:18 -08001133 * @modes: modes available on this connector (from fill_modes() + user)
1134 * @status: one of the drm_connector_status enums (connected, not, or unknown)
1135 * @probed_modes: list of modes derived directly from the display
1136 * @display_info: information about attached display (e.g. from EDID)
Dave Airlief453ba02008-11-07 14:05:41 -08001137 * @funcs: connector control functions
Jesse Barnes72252542011-11-07 12:03:18 -08001138 * @edid_blob_ptr: DRM property containing EDID if present
Paulo Zanoni7e3bdf42012-05-15 18:09:01 -03001139 * @properties: property tracking for this connector
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01001140 * @path_blob_ptr: DRM blob property data for the DP MST path property
Jesse Barnes72252542011-11-07 12:03:18 -08001141 * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling
1142 * @dpms: current dpms state
1143 * @helper_private: mid-layer private data
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01001144 * @cmdline_mode: mode line parsed from the kernel cmdline for this connector
Jesse Barnes72252542011-11-07 12:03:18 -08001145 * @force: a %DRM_FORCE_<foo> state for forced mode sets
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01001146 * @override_edid: has the EDID been overwritten through debugfs for testing?
Jesse Barnes72252542011-11-07 12:03:18 -08001147 * @encoder_ids: valid encoders for this connector
1148 * @encoder: encoder driving this connector, if any
1149 * @eld: EDID-like data, if present
1150 * @dvi_dual: dual link DVI, if found
1151 * @max_tmds_clock: max clock rate, if found
1152 * @latency_present: AV delay info from ELD, if found
1153 * @video_latency: video latency info from ELD, if found
1154 * @audio_latency: audio latency info from ELD, if found
1155 * @null_edid_counter: track sinks that give us all zeros for the EDID
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01001156 * @bad_edid_counter: track sinks that give us an EDID with invalid checksum
Daniel Vetterac6f2e22015-05-08 16:15:41 +02001157 * @edid_corrupt: indicates whether the last read EDID was corrupt
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01001158 * @debugfs_entry: debugfs directory for this connector
Daniel Vetter144ecb92014-10-27 20:28:44 +01001159 * @state: current atomic state for this connector
Dave Airlie40d9b042014-10-20 16:29:33 +10001160 * @has_tile: is this connector connected to a tiled monitor
1161 * @tile_group: tile group for the connected monitor
1162 * @tile_is_single_monitor: whether the tile is one monitor housing
1163 * @num_h_tile: number of horizontal tiles in the tile group
1164 * @num_v_tile: number of vertical tiles in the tile group
1165 * @tile_h_loc: horizontal location of this tile
1166 * @tile_v_loc: vertical location of this tile
1167 * @tile_h_size: horizontal size of this tile.
1168 * @tile_v_size: vertical size of this tile.
Dave Airlief453ba02008-11-07 14:05:41 -08001169 *
1170 * Each connector may be connected to one or more CRTCs, or may be clonable by
1171 * another connector if they can share a CRTC. Each connector also has a specific
1172 * position in the broader display (referred to as a 'screen' though it could
1173 * span multiple monitors).
1174 */
1175struct drm_connector {
1176 struct drm_device *dev;
Dave Airlie5bdebb12013-10-11 14:07:25 +10001177 struct device *kdev;
Dave Airlief453ba02008-11-07 14:05:41 -08001178 struct device_attribute *attr;
1179 struct list_head head;
1180
1181 struct drm_mode_object base;
1182
Jani Nikula2abdd312014-05-14 16:58:19 +03001183 char *name;
Maarten Lankhorst5fff80b2016-02-17 08:32:05 +01001184 int connector_id;
Dave Airlief453ba02008-11-07 14:05:41 -08001185 int connector_type;
1186 int connector_type_id;
1187 bool interlace_allowed;
1188 bool doublescan_allowed;
Damien Lespiau560a0672013-09-25 16:45:29 +01001189 bool stereo_allowed;
Dave Airlief453ba02008-11-07 14:05:41 -08001190 struct list_head modes; /* list of modes on this connector */
1191
Dave Airlief453ba02008-11-07 14:05:41 -08001192 enum drm_connector_status status;
1193
1194 /* these are modes added by probing with DDC or the BIOS */
1195 struct list_head probed_modes;
1196
1197 struct drm_display_info display_info;
1198 const struct drm_connector_funcs *funcs;
1199
Dave Airlief453ba02008-11-07 14:05:41 -08001200 struct drm_property_blob *edid_blob_ptr;
Paulo Zanoni7e3bdf42012-05-15 18:09:01 -03001201 struct drm_object_properties properties;
Dave Airlief453ba02008-11-07 14:05:41 -08001202
Dave Airlie43aba7e2014-06-05 14:01:31 +10001203 struct drm_property_blob *path_blob_ptr;
1204
Dave Airlie6f134d72014-10-20 16:30:50 +10001205 struct drm_property_blob *tile_blob_ptr;
1206
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001207 uint8_t polled; /* DRM_CONNECTOR_POLL_* */
1208
Keith Packardc9fb15f2009-05-30 20:42:28 -07001209 /* requested DPMS state */
1210 int dpms;
1211
Daniel Vetter4490d4c2015-12-04 09:45:45 +01001212 const struct drm_connector_helper_funcs *helper_private;
Dave Airlief453ba02008-11-07 14:05:41 -08001213
Dave Airlied50ba252009-09-23 14:44:08 +10001214 /* forced on connector */
Chris Wilsoneaf99c72014-08-06 10:08:32 +02001215 struct drm_cmdline_mode cmdline_mode;
Dave Airlied50ba252009-09-23 14:44:08 +10001216 enum drm_connector_force force;
Thomas Wood4cf2b282014-06-18 17:52:33 +01001217 bool override_edid;
Dave Airlief453ba02008-11-07 14:05:41 -08001218 uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
Dave Airlief453ba02008-11-07 14:05:41 -08001219 struct drm_encoder *encoder; /* currently active encoder */
Dave Airlie4a9a8b72011-06-14 06:13:55 +00001220
Wu Fengguang76adaa342011-09-05 14:23:20 +08001221 /* EDID bits */
1222 uint8_t eld[MAX_ELD_BYTES];
1223 bool dvi_dual;
1224 int max_tmds_clock; /* in MHz */
1225 bool latency_present[2];
1226 int video_latency[2]; /* [0]: progressive, [1]: interlaced */
1227 int audio_latency[2];
Dave Airlie4a9a8b72011-06-14 06:13:55 +00001228 int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
Jerome Glisse0b2443e2012-08-09 11:25:51 -04001229 unsigned bad_edid_counter;
Thomas Wood30f65702014-06-18 17:52:32 +01001230
Todd Previte6ba2bd32015-04-21 11:09:41 -07001231 /* Flag for raw EDID header corruption - used in Displayport
1232 * compliance testing - * Displayport Link CTS Core 1.2 rev1.1 4.2.2.6
1233 */
1234 bool edid_corrupt;
1235
Thomas Wood30f65702014-06-18 17:52:32 +01001236 struct dentry *debugfs_entry;
Daniel Vetter144ecb92014-10-27 20:28:44 +01001237
1238 struct drm_connector_state *state;
Dave Airlie40d9b042014-10-20 16:29:33 +10001239
1240 /* DisplayID bits */
1241 bool has_tile;
1242 struct drm_tile_group *tile_group;
1243 bool tile_is_single_monitor;
1244
1245 uint8_t num_h_tile, num_v_tile;
1246 uint8_t tile_h_loc, tile_v_loc;
1247 uint16_t tile_h_size, tile_v_size;
Dave Airlief453ba02008-11-07 14:05:41 -08001248};
1249
1250/**
Daniel Vetter144ecb92014-10-27 20:28:44 +01001251 * struct drm_plane_state - mutable plane state
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001252 * @plane: backpointer to the plane
Daniel Vetter144ecb92014-10-27 20:28:44 +01001253 * @crtc: currently bound CRTC, NULL if disabled
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001254 * @fb: currently bound framebuffer
Daniel Vettere2330f02014-10-29 11:34:56 +01001255 * @fence: optional fence to wait for before scanning out @fb
Daniel Vetter144ecb92014-10-27 20:28:44 +01001256 * @crtc_x: left position of visible portion of plane on crtc
1257 * @crtc_y: upper position of visible portion of plane on crtc
1258 * @crtc_w: width of visible portion of plane on crtc
1259 * @crtc_h: height of visible portion of plane on crtc
1260 * @src_x: left position of visible portion of plane within
1261 * plane (in 16.16)
1262 * @src_y: upper position of visible portion of plane within
1263 * plane (in 16.16)
1264 * @src_w: width of visible portion of plane (in 16.16)
1265 * @src_h: height of visible portion of plane (in 16.16)
1266 * @state: backpointer to global drm_atomic_state
1267 */
1268struct drm_plane_state {
Daniel Vetter07cc0ef2014-11-27 15:49:39 +01001269 struct drm_plane *plane;
1270
Rob Clark6ddd3882014-11-21 15:28:31 -05001271 struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_plane() */
1272 struct drm_framebuffer *fb; /* do not write directly, use drm_atomic_set_fb_for_plane() */
Daniel Vettere2330f02014-10-29 11:34:56 +01001273 struct fence *fence;
Daniel Vetter144ecb92014-10-27 20:28:44 +01001274
1275 /* Signed dest location allows it to be partially off screen */
1276 int32_t crtc_x, crtc_y;
1277 uint32_t crtc_w, crtc_h;
1278
1279 /* Source values are 16.16 fixed point */
1280 uint32_t src_x, src_y;
1281 uint32_t src_h, src_w;
1282
Matt Roper1da30622015-01-21 16:35:40 -08001283 /* Plane rotation */
1284 unsigned int rotation;
1285
Daniel Vetter144ecb92014-10-27 20:28:44 +01001286 struct drm_atomic_state *state;
1287};
1288
1289
1290/**
Daniel Vetter3bf04012014-10-27 16:54:27 +01001291 * struct drm_plane_funcs - driver plane control functions
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001292 */
1293struct drm_plane_funcs {
Daniel Vetter88548632015-12-04 09:45:48 +01001294 /**
1295 * @update_plane:
1296 *
1297 * This is the legacy entry point to enable and configure the plane for
1298 * the given CRTC and framebuffer. It is never called to disable the
1299 * plane, i.e. the passed-in crtc and fb paramters are never NULL.
1300 *
1301 * The source rectangle in frame buffer memory coordinates is given by
1302 * the src_x, src_y, src_w and src_h parameters (as 16.16 fixed point
1303 * values). Devices that don't support subpixel plane coordinates can
1304 * ignore the fractional part.
1305 *
1306 * The destination rectangle in CRTC coordinates is given by the
1307 * crtc_x, crtc_y, crtc_w and crtc_h parameters (as integer values).
1308 * Devices scale the source rectangle to the destination rectangle. If
1309 * scaling is not supported, and the source rectangle size doesn't match
1310 * the destination rectangle size, the driver must return a
1311 * -<errorname>EINVAL</errorname> error.
1312 *
1313 * Drivers implementing atomic modeset should use
1314 * drm_atomic_helper_update_plane() to implement this hook.
1315 *
1316 * RETURNS:
1317 *
1318 * 0 on success or a negative error code on failure.
1319 */
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001320 int (*update_plane)(struct drm_plane *plane,
1321 struct drm_crtc *crtc, struct drm_framebuffer *fb,
1322 int crtc_x, int crtc_y,
1323 unsigned int crtc_w, unsigned int crtc_h,
1324 uint32_t src_x, uint32_t src_y,
1325 uint32_t src_w, uint32_t src_h);
Daniel Vetter88548632015-12-04 09:45:48 +01001326
1327 /**
1328 * @disable_plane:
1329 *
1330 * This is the legacy entry point to disable the plane. The DRM core
Daniel Vetterc6b0ca32015-12-04 09:46:01 +01001331 * calls this method in response to a DRM_IOCTL_MODE_SETPLANE IOCTL call
Daniel Vetter88548632015-12-04 09:45:48 +01001332 * with the frame buffer ID set to 0. Disabled planes must not be
1333 * processed by the CRTC.
1334 *
1335 * Drivers implementing atomic modeset should use
1336 * drm_atomic_helper_disable_plane() to implement this hook.
1337 *
1338 * RETURNS:
1339 *
1340 * 0 on success or a negative error code on failure.
1341 */
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001342 int (*disable_plane)(struct drm_plane *plane);
Daniel Vetter88548632015-12-04 09:45:48 +01001343
1344 /**
1345 * @destroy:
1346 *
1347 * Clean up plane resources. This is only called at driver unload time
1348 * through drm_mode_config_cleanup() since a plane cannot be hotplugged
1349 * in DRM.
1350 */
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001351 void (*destroy)(struct drm_plane *plane);
Daniel Vetter88548632015-12-04 09:45:48 +01001352
1353 /**
1354 * @reset:
1355 *
1356 * Reset plane hardware and software state to off. This function isn't
1357 * called by the core directly, only through drm_mode_config_reset().
1358 * It's not a helper hook only for historical reasons.
1359 *
1360 * Atomic drivers can use drm_atomic_helper_plane_reset() to reset
1361 * atomic state using this hook.
1362 */
Daniel Vetter2a0d7cf2014-07-29 15:32:37 +02001363 void (*reset)(struct drm_plane *plane);
Rob Clark4d939142012-05-17 02:23:27 -06001364
Daniel Vetter88548632015-12-04 09:45:48 +01001365 /**
1366 * @set_property:
1367 *
1368 * This is the legacy entry point to update a property attached to the
1369 * plane.
1370 *
1371 * Drivers implementing atomic modeset should use
1372 * drm_atomic_helper_plane_set_property() to implement this hook.
1373 *
1374 * This callback is optional if the driver does not support any legacy
1375 * driver-private properties.
1376 *
1377 * RETURNS:
1378 *
1379 * 0 on success or a negative error code on failure.
1380 */
Rob Clark4d939142012-05-17 02:23:27 -06001381 int (*set_property)(struct drm_plane *plane,
1382 struct drm_property *property, uint64_t val);
Daniel Vetter144ecb92014-10-27 20:28:44 +01001383
Daniel Vetter88548632015-12-04 09:45:48 +01001384 /**
1385 * @atomic_duplicate_state:
1386 *
1387 * Duplicate the current atomic state for this plane and return it.
1388 * The core and helpers gurantee that any atomic state duplicated with
1389 * this hook and still owned by the caller (i.e. not transferred to the
1390 * driver by calling ->atomic_commit() from struct
1391 * &drm_mode_config_funcs) will be cleaned up by calling the
1392 * @atomic_destroy_state hook in this structure.
1393 *
1394 * Atomic drivers which don't subclass struct &drm_plane_state should use
1395 * drm_atomic_helper_plane_duplicate_state(). Drivers that subclass the
1396 * state structure to extend it with driver-private state should use
1397 * __drm_atomic_helper_plane_duplicate_state() to make sure shared state is
1398 * duplicated in a consistent fashion across drivers.
1399 *
1400 * It is an error to call this hook before plane->state has been
1401 * initialized correctly.
1402 *
1403 * NOTE:
1404 *
1405 * If the duplicate state references refcounted resources this hook must
1406 * acquire a reference for each of them. The driver must release these
1407 * references again in @atomic_destroy_state.
1408 *
1409 * RETURNS:
1410 *
1411 * Duplicated atomic state or NULL when the allocation failed.
1412 */
Daniel Vetter144ecb92014-10-27 20:28:44 +01001413 struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane);
Daniel Vetter88548632015-12-04 09:45:48 +01001414
1415 /**
1416 * @atomic_destroy_state:
1417 *
1418 * Destroy a state duplicated with @atomic_duplicate_state and release
1419 * or unreference all resources it references
1420 */
Daniel Vetter144ecb92014-10-27 20:28:44 +01001421 void (*atomic_destroy_state)(struct drm_plane *plane,
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001422 struct drm_plane_state *state);
Daniel Vetter88548632015-12-04 09:45:48 +01001423
1424 /**
1425 * @atomic_set_property:
1426 *
1427 * Decode a driver-private property value and store the decoded value
1428 * into the passed-in state structure. Since the atomic core decodes all
1429 * standardized properties (even for extensions beyond the core set of
1430 * properties which might not be implemented by all drivers) this
1431 * requires drivers to subclass the state structure.
1432 *
1433 * Such driver-private properties should really only be implemented for
1434 * truly hardware/vendor specific state. Instead it is preferred to
1435 * standardize atomic extension and decode the properties used to expose
1436 * such an extension in the core.
1437 *
1438 * Do not call this function directly, use
1439 * drm_atomic_plane_set_property() instead.
1440 *
1441 * This callback is optional if the driver does not support any
1442 * driver-private atomic properties.
1443 *
1444 * NOTE:
1445 *
1446 * This function is called in the state assembly phase of atomic
1447 * modesets, which can be aborted for any reason (including on
1448 * userspace's request to just check whether a configuration would be
1449 * possible). Drivers MUST NOT touch any persistent state (hardware or
1450 * software) or data structures except the passed in @state parameter.
1451 *
1452 * Also since userspace controls in which order properties are set this
1453 * function must not do any input validation (since the state update is
1454 * incomplete and hence likely inconsistent). Instead any such input
1455 * validation must be done in the various atomic_check callbacks.
1456 *
1457 * RETURNS:
1458 *
1459 * 0 if the property has been found, -EINVAL if the property isn't
1460 * implemented by the driver (which shouldn't ever happen, the core only
1461 * asks for properties attached to this plane). No other validation is
1462 * allowed by the driver. The core already checks that the property
1463 * value is within the range (integer, valid enum value, ...) the driver
1464 * set when registering the property.
1465 */
Daniel Vetter144ecb92014-10-27 20:28:44 +01001466 int (*atomic_set_property)(struct drm_plane *plane,
1467 struct drm_plane_state *state,
1468 struct drm_property *property,
1469 uint64_t val);
Daniel Vetter88548632015-12-04 09:45:48 +01001470
1471 /**
1472 * @atomic_get_property:
1473 *
1474 * Reads out the decoded driver-private property. This is used to
Daniel Vetterc6b0ca32015-12-04 09:46:01 +01001475 * implement the GETPLANE IOCTL.
Daniel Vetter88548632015-12-04 09:45:48 +01001476 *
1477 * Do not call this function directly, use
1478 * drm_atomic_plane_get_property() instead.
1479 *
1480 * This callback is optional if the driver does not support any
1481 * driver-private atomic properties.
1482 *
1483 * RETURNS:
1484 *
1485 * 0 on success, -EINVAL if the property isn't implemented by the
1486 * driver (which should never happen, the core only asks for
1487 * properties attached to this plane).
1488 */
Rob Clarkac9c9252014-12-18 16:01:47 -05001489 int (*atomic_get_property)(struct drm_plane *plane,
1490 const struct drm_plane_state *state,
1491 struct drm_property *property,
1492 uint64_t *val);
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001493};
1494
Matt Ropere27dde32014-04-01 15:22:30 -07001495enum drm_plane_type {
1496 DRM_PLANE_TYPE_OVERLAY,
1497 DRM_PLANE_TYPE_PRIMARY,
1498 DRM_PLANE_TYPE_CURSOR,
1499};
1500
Daniel Vetter88548632015-12-04 09:45:48 +01001501
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001502/**
Daniel Vetter3bf04012014-10-27 16:54:27 +01001503 * struct drm_plane - central DRM plane control structure
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001504 * @dev: DRM device this plane belongs to
1505 * @head: for list management
1506 * @base: base mode object
1507 * @possible_crtcs: pipes this plane can be bound to
1508 * @format_types: array of formats supported by this plane
1509 * @format_count: number of formats supported
Laurent Pinchart7eb5f302015-03-09 10:41:07 +02001510 * @format_default: driver hasn't supplied supported formats for the plane
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001511 * @crtc: currently bound CRTC
1512 * @fb: currently bound fb
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01001513 * @old_fb: Temporary tracking of the old fb while a modeset is ongoing. Used by
1514 * drm_mode_set_config_internal() to implement correct refcounting.
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001515 * @funcs: helper functions
Rob Clark4d939142012-05-17 02:23:27 -06001516 * @properties: property tracking for this plane
Matt Ropere27dde32014-04-01 15:22:30 -07001517 * @type: type of plane (overlay, primary, cursor)
Daniel Vetter144ecb92014-10-27 20:28:44 +01001518 * @state: current atomic state for this plane
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001519 */
1520struct drm_plane {
1521 struct drm_device *dev;
1522 struct list_head head;
1523
Ville Syrjälä9f4c97a2015-12-08 18:41:54 +02001524 char *name;
1525
Daniel Vetter4d02e2d2014-11-11 10:12:00 +01001526 struct drm_modeset_lock mutex;
1527
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001528 struct drm_mode_object base;
1529
1530 uint32_t possible_crtcs;
1531 uint32_t *format_types;
Thierry Reding45e37432015-08-12 16:54:28 +02001532 unsigned int format_count;
Laurent Pinchart7eb5f302015-03-09 10:41:07 +02001533 bool format_default;
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001534
1535 struct drm_crtc *crtc;
1536 struct drm_framebuffer *fb;
1537
Daniel Vetter3d30a592014-07-27 13:42:42 +02001538 struct drm_framebuffer *old_fb;
1539
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001540 const struct drm_plane_funcs *funcs;
Rob Clark4d939142012-05-17 02:23:27 -06001541
1542 struct drm_object_properties properties;
Matt Ropere27dde32014-04-01 15:22:30 -07001543
1544 enum drm_plane_type type;
Daniel Vetter144ecb92014-10-27 20:28:44 +01001545
Daniel Vetter4490d4c2015-12-04 09:45:45 +01001546 const struct drm_plane_helper_funcs *helper_private;
Daniel Vetterc2fcd272014-11-05 00:14:14 +01001547
Daniel Vetter144ecb92014-10-27 20:28:44 +01001548 struct drm_plane_state *state;
Jesse Barnes8cf5c912011-11-14 14:51:27 -08001549};
1550
1551/**
Daniel Vetter3bf04012014-10-27 16:54:27 +01001552 * struct drm_bridge_funcs - drm_bridge control functions
Ajay Kumar3d3f8b12015-01-20 22:08:44 +05301553 * @attach: Called during drm_bridge_attach
Sean Paul3b336ec2013-08-14 16:47:37 -04001554 */
1555struct drm_bridge_funcs {
Ajay Kumar3d3f8b12015-01-20 22:08:44 +05301556 int (*attach)(struct drm_bridge *bridge);
Daniel Vetterda024fe2015-12-04 09:45:47 +01001557
1558 /**
1559 * @mode_fixup:
1560 *
1561 * This callback is used to validate and adjust a mode. The paramater
1562 * mode is the display mode that should be fed to the next element in
1563 * the display chain, either the final &drm_connector or the next
1564 * &drm_bridge. The parameter adjusted_mode is the input mode the bridge
1565 * requires. It can be modified by this callback and does not need to
1566 * match mode.
1567 *
1568 * This is the only hook that allows a bridge to reject a modeset. If
1569 * this function passes all other callbacks must succeed for this
1570 * configuration.
1571 *
1572 * NOTE:
1573 *
1574 * This function is called in the check phase of atomic modesets, which
1575 * can be aborted for any reason (including on userspace's request to
1576 * just check whether a configuration would be possible). Drivers MUST
1577 * NOT touch any persistent state (hardware or software) or data
Daniel Vetter88548632015-12-04 09:45:48 +01001578 * structures except the passed in @state parameter.
Daniel Vetterda024fe2015-12-04 09:45:47 +01001579 *
1580 * RETURNS:
1581 *
1582 * True if an acceptable configuration is possible, false if the modeset
1583 * operation should be rejected.
1584 */
Sean Paul3b336ec2013-08-14 16:47:37 -04001585 bool (*mode_fixup)(struct drm_bridge *bridge,
1586 const struct drm_display_mode *mode,
1587 struct drm_display_mode *adjusted_mode);
Daniel Vetterda024fe2015-12-04 09:45:47 +01001588 /**
1589 * @disable:
1590 *
1591 * This callback should disable the bridge. It is called right before
1592 * the preceding element in the display pipe is disabled. If the
1593 * preceding element is a bridge this means it's called before that
1594 * bridge's ->disable() function. If the preceding element is a
1595 * &drm_encoder it's called right before the encoder's ->disable(),
1596 * ->prepare() or ->dpms() hook from struct &drm_encoder_helper_funcs.
1597 *
1598 * The bridge can assume that the display pipe (i.e. clocks and timing
1599 * signals) feeding it is still running when this callback is called.
Laurent Pinchartc8a3b2a2016-02-26 11:51:06 +02001600 *
1601 * The disable callback is optional.
Daniel Vetterda024fe2015-12-04 09:45:47 +01001602 */
Sean Paul3b336ec2013-08-14 16:47:37 -04001603 void (*disable)(struct drm_bridge *bridge);
Daniel Vetterda024fe2015-12-04 09:45:47 +01001604
1605 /**
1606 * @post_disable:
1607 *
1608 * This callback should disable the bridge. It is called right after
1609 * the preceding element in the display pipe is disabled. If the
1610 * preceding element is a bridge this means it's called after that
1611 * bridge's ->post_disable() function. If the preceding element is a
1612 * &drm_encoder it's called right after the encoder's ->disable(),
1613 * ->prepare() or ->dpms() hook from struct &drm_encoder_helper_funcs.
1614 *
1615 * The bridge must assume that the display pipe (i.e. clocks and timing
1616 * singals) feeding it is no longer running when this callback is
1617 * called.
Laurent Pinchartc8a3b2a2016-02-26 11:51:06 +02001618 *
1619 * The post_disable callback is optional.
Daniel Vetterda024fe2015-12-04 09:45:47 +01001620 */
Sean Paul3b336ec2013-08-14 16:47:37 -04001621 void (*post_disable)(struct drm_bridge *bridge);
Daniel Vetterda024fe2015-12-04 09:45:47 +01001622
1623 /**
1624 * @mode_set:
1625 *
1626 * This callback should set the given mode on the bridge. It is called
1627 * after the ->mode_set() callback for the preceding element in the
1628 * display pipeline has been called already. The display pipe (i.e.
1629 * clocks and timing signals) is off when this function is called.
1630 */
Sean Paul3b336ec2013-08-14 16:47:37 -04001631 void (*mode_set)(struct drm_bridge *bridge,
1632 struct drm_display_mode *mode,
1633 struct drm_display_mode *adjusted_mode);
Daniel Vetterda024fe2015-12-04 09:45:47 +01001634 /**
1635 * @pre_enable:
1636 *
1637 * This callback should enable the bridge. It is called right before
1638 * the preceding element in the display pipe is enabled. If the
1639 * preceding element is a bridge this means it's called before that
1640 * bridge's ->pre_enable() function. If the preceding element is a
1641 * &drm_encoder it's called right before the encoder's ->enable(),
1642 * ->commit() or ->dpms() hook from struct &drm_encoder_helper_funcs.
1643 *
1644 * The display pipe (i.e. clocks and timing signals) feeding this bridge
1645 * will not yet be running when this callback is called. The bridge must
1646 * not enable the display link feeding the next bridge in the chain (if
1647 * there is one) when this callback is called.
Laurent Pinchartc8a3b2a2016-02-26 11:51:06 +02001648 *
1649 * The pre_enable callback is optional.
Daniel Vetterda024fe2015-12-04 09:45:47 +01001650 */
Sean Paul3b336ec2013-08-14 16:47:37 -04001651 void (*pre_enable)(struct drm_bridge *bridge);
Daniel Vetterda024fe2015-12-04 09:45:47 +01001652
1653 /**
1654 * @enable:
1655 *
1656 * This callback should enable the bridge. It is called right after
1657 * the preceding element in the display pipe is enabled. If the
1658 * preceding element is a bridge this means it's called after that
1659 * bridge's ->enable() function. If the preceding element is a
1660 * &drm_encoder it's called right after the encoder's ->enable(),
1661 * ->commit() or ->dpms() hook from struct &drm_encoder_helper_funcs.
1662 *
1663 * The bridge can assume that the display pipe (i.e. clocks and timing
1664 * signals) feeding it is running when this callback is called. This
1665 * callback must enable the display link feeding the next bridge in the
1666 * chain if there is one.
Laurent Pinchartc8a3b2a2016-02-26 11:51:06 +02001667 *
1668 * The enable callback is optional.
Daniel Vetterda024fe2015-12-04 09:45:47 +01001669 */
Sean Paul3b336ec2013-08-14 16:47:37 -04001670 void (*enable)(struct drm_bridge *bridge);
Sean Paul3b336ec2013-08-14 16:47:37 -04001671};
1672
1673/**
Daniel Vetter3bf04012014-10-27 16:54:27 +01001674 * struct drm_bridge - central DRM bridge control structure
Sean Paul3b336ec2013-08-14 16:47:37 -04001675 * @dev: DRM device this bridge belongs to
Archit Taneja862e6862015-05-21 11:03:16 +05301676 * @encoder: encoder to which this bridge is connected
1677 * @next: the next bridge in the encoder chain
Ajay Kumar3d3f8b12015-01-20 22:08:44 +05301678 * @of_node: device node pointer to the bridge
1679 * @list: to keep track of all added bridges
Sean Paul3b336ec2013-08-14 16:47:37 -04001680 * @funcs: control functions
1681 * @driver_private: pointer to the bridge driver's internal context
1682 */
1683struct drm_bridge {
1684 struct drm_device *dev;
Ajay Kumar3d3f8b12015-01-20 22:08:44 +05301685 struct drm_encoder *encoder;
Archit Taneja862e6862015-05-21 11:03:16 +05301686 struct drm_bridge *next;
Ajay Kumar3d3f8b12015-01-20 22:08:44 +05301687#ifdef CONFIG_OF
1688 struct device_node *of_node;
1689#endif
1690 struct list_head list;
Sean Paul3b336ec2013-08-14 16:47:37 -04001691
1692 const struct drm_bridge_funcs *funcs;
1693 void *driver_private;
1694};
1695
1696/**
Rob Clark08855fa2015-03-11 10:23:09 -04001697 * struct drm_atomic_state - the global state object for atomic updates
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001698 * @dev: parent DRM device
Rob Clarkd34f20d2014-12-18 16:01:56 -05001699 * @allow_modeset: allow full modeset
Daniel Vetterc6b0ca32015-12-04 09:46:01 +01001700 * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics
Maarten Lankhorst40616a22016-03-03 10:17:39 +01001701 * @legacy_set_config: Disable conflicting encoders instead of failing with -EINVAL.
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001702 * @planes: pointer to array of plane pointers
1703 * @plane_states: pointer to array of plane states pointers
1704 * @crtcs: pointer to array of CRTC pointers
1705 * @crtc_states: pointer to array of CRTC states pointers
Daniel Vetterf52b69f12014-11-19 18:38:08 +01001706 * @num_connector: size of the @connectors and @connector_states arrays
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001707 * @connectors: pointer to array of connector pointers
1708 * @connector_states: pointer to array of connector states pointers
1709 * @acquire_ctx: acquire context for this atomic modeset state update
1710 */
1711struct drm_atomic_state {
1712 struct drm_device *dev;
Rob Clarkd34f20d2014-12-18 16:01:56 -05001713 bool allow_modeset : 1;
Daniel Vetterf02ad902015-01-22 16:36:23 +01001714 bool legacy_cursor_update : 1;
Maarten Lankhorst40616a22016-03-03 10:17:39 +01001715 bool legacy_set_config : 1;
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001716 struct drm_plane **planes;
1717 struct drm_plane_state **plane_states;
1718 struct drm_crtc **crtcs;
1719 struct drm_crtc_state **crtc_states;
Daniel Vetterf52b69f12014-11-19 18:38:08 +01001720 int num_connector;
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001721 struct drm_connector **connectors;
1722 struct drm_connector_state **connector_states;
1723
1724 struct drm_modeset_acquire_ctx *acquire_ctx;
1725};
1726
1727
1728/**
Daniel Vetter3bf04012014-10-27 16:54:27 +01001729 * struct drm_mode_set - new values for a CRTC config change
Jesse Barnesef273512011-11-07 12:03:19 -08001730 * @fb: framebuffer to use for new config
1731 * @crtc: CRTC whose configuration we're about to change
1732 * @mode: mode timings to use
1733 * @x: position of this CRTC relative to @fb
1734 * @y: position of this CRTC relative to @fb
1735 * @connectors: array of connectors to drive with this CRTC if possible
1736 * @num_connectors: size of @connectors array
Dave Airlief453ba02008-11-07 14:05:41 -08001737 *
1738 * Represents a single crtc the connectors that it drives with what mode
1739 * and from which framebuffer it scans out from.
1740 *
1741 * This is used to set modes.
1742 */
1743struct drm_mode_set {
Dave Airlief453ba02008-11-07 14:05:41 -08001744 struct drm_framebuffer *fb;
1745 struct drm_crtc *crtc;
1746 struct drm_display_mode *mode;
1747
1748 uint32_t x;
1749 uint32_t y;
1750
1751 struct drm_connector **connectors;
1752 size_t num_connectors;
1753};
1754
1755/**
Jesse Barnes550cebc2011-11-07 12:03:20 -08001756 * struct drm_mode_config_funcs - basic driver provided mode setting functions
Jesse Barnes550cebc2011-11-07 12:03:20 -08001757 *
1758 * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
1759 * involve drivers.
Dave Airlief453ba02008-11-07 14:05:41 -08001760 */
1761struct drm_mode_config_funcs {
Daniel Vetter9953f412015-12-04 09:46:02 +01001762 /**
1763 * @fb_create:
1764 *
1765 * Create a new framebuffer object. The core does basic checks on the
1766 * requested metadata, but most of that is left to the driver. See
1767 * struct &drm_mode_fb_cmd2 for details.
1768 *
Daniel Vetterd55f5322015-12-08 09:49:19 +01001769 * If the parameters are deemed valid and the backing storage objects in
1770 * the underlying memory manager all exist, then the driver allocates
1771 * a new &drm_framebuffer structure, subclassed to contain
1772 * driver-specific information (like the internal native buffer object
1773 * references). It also needs to fill out all relevant metadata, which
1774 * should be done by calling drm_helper_mode_fill_fb_struct().
1775 *
1776 * The initialization is finalized by calling drm_framebuffer_init(),
1777 * which registers the framebuffer and makes it accessible to other
1778 * threads.
1779 *
Daniel Vetter9953f412015-12-04 09:46:02 +01001780 * RETURNS:
1781 *
1782 * A new framebuffer with an initial reference count of 1 or a negative
1783 * error code encoded with ERR_PTR().
1784 */
Jesse Barnes550cebc2011-11-07 12:03:20 -08001785 struct drm_framebuffer *(*fb_create)(struct drm_device *dev,
1786 struct drm_file *file_priv,
Ville Syrjälä1eb83452015-11-11 19:11:29 +02001787 const struct drm_mode_fb_cmd2 *mode_cmd);
Daniel Vetter9953f412015-12-04 09:46:02 +01001788
1789 /**
1790 * @output_poll_changed:
1791 *
1792 * Callback used by helpers to inform the driver of output configuration
1793 * changes.
1794 *
1795 * Drivers implementing fbdev emulation with the helpers can call
1796 * drm_fb_helper_hotplug_changed from this hook to inform the fbdev
1797 * helper of output changes.
1798 *
1799 * FIXME:
1800 *
1801 * Except that there's no vtable for device-level helper callbacks
1802 * there's no reason this is a core function.
1803 */
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001804 void (*output_poll_changed)(struct drm_device *dev);
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001805
Daniel Vetter9953f412015-12-04 09:46:02 +01001806 /**
1807 * @atomic_check:
1808 *
1809 * This is the only hook to validate an atomic modeset update. This
1810 * function must reject any modeset and state changes which the hardware
1811 * or driver doesn't support. This includes but is of course not limited
1812 * to:
1813 *
1814 * - Checking that the modes, framebuffers, scaling and placement
1815 * requirements and so on are within the limits of the hardware.
1816 *
1817 * - Checking that any hidden shared resources are not oversubscribed.
1818 * This can be shared PLLs, shared lanes, overall memory bandwidth,
1819 * display fifo space (where shared between planes or maybe even
1820 * CRTCs).
1821 *
1822 * - Checking that virtualized resources exported to userspace are not
1823 * oversubscribed. For various reasons it can make sense to expose
1824 * more planes, crtcs or encoders than which are physically there. One
1825 * example is dual-pipe operations (which generally should be hidden
1826 * from userspace if when lockstepped in hardware, exposed otherwise),
1827 * where a plane might need 1 hardware plane (if it's just on one
1828 * pipe), 2 hardware planes (when it spans both pipes) or maybe even
1829 * shared a hardware plane with a 2nd plane (if there's a compatible
1830 * plane requested on the area handled by the other pipe).
1831 *
1832 * - Check that any transitional state is possible and that if
1833 * requested, the update can indeed be done in the vblank period
1834 * without temporarily disabling some functions.
1835 *
1836 * - Check any other constraints the driver or hardware might have.
1837 *
1838 * - This callback also needs to correctly fill out the &drm_crtc_state
1839 * in this update to make sure that drm_atomic_crtc_needs_modeset()
1840 * reflects the nature of the possible update and returns true if and
1841 * only if the update cannot be applied without tearing within one
1842 * vblank on that CRTC. The core uses that information to reject
1843 * updates which require a full modeset (i.e. blanking the screen, or
1844 * at least pausing updates for a substantial amount of time) if
1845 * userspace has disallowed that in its request.
1846 *
1847 * - The driver also does not need to repeat basic input validation
1848 * like done for the corresponding legacy entry points. The core does
1849 * that before calling this hook.
1850 *
1851 * See the documentation of @atomic_commit for an exhaustive list of
1852 * error conditions which don't have to be checked at the
1853 * ->atomic_check() stage?
1854 *
1855 * See the documentation for struct &drm_atomic_state for how exactly
1856 * an atomic modeset update is described.
1857 *
1858 * Drivers using the atomic helpers can implement this hook using
1859 * drm_atomic_helper_check(), or one of the exported sub-functions of
1860 * it.
1861 *
1862 * RETURNS:
1863 *
1864 * 0 on success or one of the below negative error codes:
1865 *
1866 * - -EINVAL, if any of the above constraints are violated.
1867 *
1868 * - -EDEADLK, when returned from an attempt to acquire an additional
1869 * &drm_modeset_lock through drm_modeset_lock().
1870 *
1871 * - -ENOMEM, if allocating additional state sub-structures failed due
1872 * to lack of memory.
1873 *
1874 * - -EINTR, -EAGAIN or -ERESTARTSYS, if the IOCTL should be restarted.
1875 * This can either be due to a pending signal, or because the driver
1876 * needs to completely bail out to recover from an exceptional
1877 * situation like a GPU hang. From a userspace point all errors are
1878 * treated equally.
1879 */
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001880 int (*atomic_check)(struct drm_device *dev,
Daniel Vetter9953f412015-12-04 09:46:02 +01001881 struct drm_atomic_state *state);
1882
1883 /**
1884 * @atomic_commit:
1885 *
1886 * This is the only hook to commit an atomic modeset update. The core
1887 * guarantees that @atomic_check has been called successfully before
1888 * calling this function, and that nothing has been changed in the
1889 * interim.
1890 *
1891 * See the documentation for struct &drm_atomic_state for how exactly
1892 * an atomic modeset update is described.
1893 *
1894 * Drivers using the atomic helpers can implement this hook using
1895 * drm_atomic_helper_commit(), or one of the exported sub-functions of
1896 * it.
1897 *
1898 * Asynchronous commits (as indicated with the async parameter) must
1899 * do any preparatory work which might result in an unsuccessful commit
1900 * in the context of this callback. The only exceptions are hardware
1901 * errors resulting in -EIO. But even in that case the driver must
1902 * ensure that the display pipe is at least running, to avoid
1903 * compositors crashing when pageflips don't work. Anything else,
1904 * specifically committing the update to the hardware, should be done
1905 * without blocking the caller. For updates which do not require a
1906 * modeset this must be guaranteed.
1907 *
1908 * The driver must wait for any pending rendering to the new
1909 * framebuffers to complete before executing the flip. It should also
1910 * wait for any pending rendering from other drivers if the underlying
1911 * buffer is a shared dma-buf. Asynchronous commits must not wait for
1912 * rendering in the context of this callback.
1913 *
1914 * An application can request to be notified when the atomic commit has
1915 * completed. These events are per-CRTC and can be distinguished by the
1916 * CRTC index supplied in &drm_event to userspace.
1917 *
1918 * The drm core will supply a struct &drm_event in the event
1919 * member of each CRTC's &drm_crtc_state structure. This can be handled by the
1920 * drm_crtc_send_vblank_event() function, which the driver should call on
1921 * the provided event upon completion of the atomic commit. Note that if
1922 * the driver supports vblank signalling and timestamping the vblank
1923 * counters and timestamps must agree with the ones returned from page
1924 * flip events. With the current vblank helper infrastructure this can
1925 * be achieved by holding a vblank reference while the page flip is
1926 * pending, acquired through drm_crtc_vblank_get() and released with
1927 * drm_crtc_vblank_put(). Drivers are free to implement their own vblank
1928 * counter and timestamp tracking though, e.g. if they have accurate
1929 * timestamp registers in hardware.
1930 *
1931 * NOTE:
1932 *
1933 * Drivers are not allowed to shut down any display pipe successfully
1934 * enabled through an atomic commit on their own. Doing so can result in
1935 * compositors crashing if a page flip is suddenly rejected because the
1936 * pipe is off.
1937 *
1938 * RETURNS:
1939 *
1940 * 0 on success or one of the below negative error codes:
1941 *
1942 * - -EBUSY, if an asynchronous updated is requested and there is
1943 * an earlier updated pending. Drivers are allowed to support a queue
1944 * of outstanding updates, but currently no driver supports that.
1945 * Note that drivers must wait for preceding updates to complete if a
1946 * synchronous update is requested, they are not allowed to fail the
1947 * commit in that case.
1948 *
1949 * - -ENOMEM, if the driver failed to allocate memory. Specifically
1950 * this can happen when trying to pin framebuffers, which must only
1951 * be done when committing the state.
1952 *
1953 * - -ENOSPC, as a refinement of the more generic -ENOMEM to indicate
1954 * that the driver has run out of vram, iommu space or similar GPU
1955 * address space needed for framebuffer.
1956 *
1957 * - -EIO, if the hardware completely died.
1958 *
1959 * - -EINTR, -EAGAIN or -ERESTARTSYS, if the IOCTL should be restarted.
1960 * This can either be due to a pending signal, or because the driver
1961 * needs to completely bail out to recover from an exceptional
1962 * situation like a GPU hang. From a userspace point of view all errors are
1963 * treated equally.
1964 *
1965 * This list is exhaustive. Specifically this hook is not allowed to
1966 * return -EINVAL (any invalid requests should be caught in
1967 * @atomic_check) or -EDEADLK (this function must not acquire
1968 * additional modeset locks).
1969 */
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001970 int (*atomic_commit)(struct drm_device *dev,
Daniel Vetter9953f412015-12-04 09:46:02 +01001971 struct drm_atomic_state *state,
Daniel Vettercc4ceb42014-07-25 21:30:38 +02001972 bool async);
Daniel Vetter9953f412015-12-04 09:46:02 +01001973
1974 /**
1975 * @atomic_state_alloc:
1976 *
1977 * This optional hook can be used by drivers that want to subclass struct
1978 * &drm_atomic_state to be able to track their own driver-private global
1979 * state easily. If this hook is implemented, drivers must also
1980 * implement @atomic_state_clear and @atomic_state_free.
1981 *
1982 * RETURNS:
1983 *
1984 * A new &drm_atomic_state on success or NULL on failure.
1985 */
Maarten Lankhorst036ef572015-05-18 10:06:40 +02001986 struct drm_atomic_state *(*atomic_state_alloc)(struct drm_device *dev);
Daniel Vetter9953f412015-12-04 09:46:02 +01001987
1988 /**
1989 * @atomic_state_clear:
1990 *
1991 * This hook must clear any driver private state duplicated into the
1992 * passed-in &drm_atomic_state. This hook is called when the caller
1993 * encountered a &drm_modeset_lock deadlock and needs to drop all
1994 * already acquired locks as part of the deadlock avoidance dance
1995 * implemented in drm_modeset_lock_backoff().
1996 *
1997 * Any duplicated state must be invalidated since a concurrent atomic
1998 * update might change it, and the drm atomic interfaces always apply
1999 * updates as relative changes to the current state.
2000 *
2001 * Drivers that implement this must call drm_atomic_state_default_clear()
2002 * to clear common state.
2003 */
Maarten Lankhorst036ef572015-05-18 10:06:40 +02002004 void (*atomic_state_clear)(struct drm_atomic_state *state);
Daniel Vetter9953f412015-12-04 09:46:02 +01002005
2006 /**
2007 * @atomic_state_free:
2008 *
2009 * This hook needs driver private resources and the &drm_atomic_state
2010 * itself. Note that the core first calls drm_atomic_state_clear() to
2011 * avoid code duplicate between the clear and free hooks.
2012 *
2013 * Drivers that implement this must call drm_atomic_state_default_free()
2014 * to release common resources.
2015 */
Maarten Lankhorst036ef572015-05-18 10:06:40 +02002016 void (*atomic_state_free)(struct drm_atomic_state *state);
Dave Airlief453ba02008-11-07 14:05:41 -08002017};
2018
Jesse Barnesc1aaca22011-11-07 12:03:21 -08002019/**
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01002020 * struct drm_mode_config - Mode configuration control structure
Jesse Barnesa62c93d2011-11-07 12:03:22 -08002021 * @mutex: mutex protecting KMS related lists and structures
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01002022 * @connection_mutex: ww mutex protecting connector state and routing
2023 * @acquire_ctx: global implicit acquire context used by atomic drivers for
Daniel Vetterc6b0ca32015-12-04 09:46:01 +01002024 * legacy IOCTLs
Jesse Barnesa62c93d2011-11-07 12:03:22 -08002025 * @idr_mutex: mutex for KMS ID allocation and management
2026 * @crtc_idr: main KMS ID tracking object
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01002027 * @fb_lock: mutex to protect fb state and lists
Jesse Barnesa62c93d2011-11-07 12:03:22 -08002028 * @num_fb: number of fbs available
2029 * @fb_list: list of framebuffers available
2030 * @num_connector: number of connectors on this device
2031 * @connector_list: list of connector objects
2032 * @num_encoder: number of encoders on this device
2033 * @encoder_list: list of encoder objects
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01002034 * @num_overlay_plane: number of overlay planes on this device
2035 * @num_total_plane: number of universal (i.e. with primary/curso) planes on this device
2036 * @plane_list: list of plane objects
Jesse Barnesa62c93d2011-11-07 12:03:22 -08002037 * @num_crtc: number of CRTCs on this device
2038 * @crtc_list: list of CRTC objects
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01002039 * @property_list: list of property objects
Jesse Barnesa62c93d2011-11-07 12:03:22 -08002040 * @min_width: minimum pixel width on this device
2041 * @min_height: minimum pixel height on this device
2042 * @max_width: maximum pixel width on this device
2043 * @max_height: maximum pixel height on this device
2044 * @funcs: core driver provided mode setting functions
2045 * @fb_base: base address of the framebuffer
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01002046 * @poll_enabled: track polling support for this device
2047 * @poll_running: track polling status for this device
Jesse Barnesa62c93d2011-11-07 12:03:22 -08002048 * @output_poll_work: delayed work for polling in process context
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01002049 * @property_blob_list: list of all the blob property objects
Daniel Stone8fb6e7a2015-04-20 19:22:54 +01002050 * @blob_lock: mutex for blob property allocation and management
Jesse Barnesa62c93d2011-11-07 12:03:22 -08002051 * @*_property: core property tracking
Lionel Landwerlin5488dc12016-02-26 17:05:00 +00002052 * @degamma_lut_property: LUT used to convert the framebuffer's colors to linear
2053 * gamma
2054 * @degamma_lut_size_property: size of the degamma LUT as supported by the
2055 * driver (read-only)
2056 * @ctm_property: Matrix used to convert colors after the lookup in the
2057 * degamma LUT
2058 * @gamma_lut_property: LUT used to convert the colors, after the CSC matrix, to
2059 * the gamma space of the connected screen (read-only)
2060 * @gamma_lut_size_property: size of the gamma LUT as supported by the driver
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01002061 * @preferred_depth: preferred RBG pixel depth, used by fb helpers
2062 * @prefer_shadow: hint to userspace to prefer shadow-fb rendering
2063 * @async_page_flip: does this device support async flips on the primary plane?
2064 * @cursor_width: hint to userspace for max cursor width
2065 * @cursor_height: hint to userspace for max cursor height
Dave Airlief453ba02008-11-07 14:05:41 -08002066 *
Jesse Barnesa62c93d2011-11-07 12:03:22 -08002067 * Core mode resource tracking structure. All CRTC, encoders, and connectors
2068 * enumerated by the driver are added here, as are global properties. Some
2069 * global restrictions are also here, e.g. dimension restrictions.
Dave Airlief453ba02008-11-07 14:05:41 -08002070 */
2071struct drm_mode_config {
Jesse Barnesad2563c2009-01-19 17:21:45 +10002072 struct mutex mutex; /* protects configuration (mode lists etc.) */
Rob Clark51fd3712013-11-19 12:10:12 -05002073 struct drm_modeset_lock connection_mutex; /* protects connector->encoder and encoder->crtc links */
2074 struct drm_modeset_acquire_ctx *acquire_ctx; /* for legacy _lock_all() / _unlock_all() */
Jesse Barnesad2563c2009-01-19 17:21:45 +10002075 struct mutex idr_mutex; /* for IDR management */
Dave Airlief453ba02008-11-07 14:05:41 -08002076 struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
Dave Airlie138f9eb2014-10-20 16:17:17 +10002077 struct idr tile_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
Dave Airlief453ba02008-11-07 14:05:41 -08002078 /* this is limited to one for now */
Daniel Vetter4b096ac2012-12-10 21:19:18 +01002079
Daniel Vetter2c0c33d2014-10-27 20:19:38 +01002080 struct mutex fb_lock; /* proctects global and per-file fb lists */
Dave Airlief453ba02008-11-07 14:05:41 -08002081 int num_fb;
2082 struct list_head fb_list;
Daniel Vetter4b096ac2012-12-10 21:19:18 +01002083
Dave Airlief453ba02008-11-07 14:05:41 -08002084 int num_connector;
Maarten Lankhorst5fff80b2016-02-17 08:32:05 +01002085 struct ida connector_ida;
Dave Airlief453ba02008-11-07 14:05:41 -08002086 struct list_head connector_list;
2087 int num_encoder;
2088 struct list_head encoder_list;
Matt Ropere27dde32014-04-01 15:22:30 -07002089
2090 /*
2091 * Track # of overlay planes separately from # of total planes. By
2092 * default we only advertise overlay planes to userspace; if userspace
2093 * sets the "universal plane" capability bit, we'll go ahead and
2094 * expose all planes.
2095 */
2096 int num_overlay_plane;
2097 int num_total_plane;
Jesse Barnes8cf5c912011-11-14 14:51:27 -08002098 struct list_head plane_list;
Dave Airlief453ba02008-11-07 14:05:41 -08002099
2100 int num_crtc;
2101 struct list_head crtc_list;
2102
2103 struct list_head property_list;
2104
Dave Airlief453ba02008-11-07 14:05:41 -08002105 int min_width, min_height;
2106 int max_width, max_height;
Laurent Pincharte6ecefa2012-05-17 13:27:23 +02002107 const struct drm_mode_config_funcs *funcs;
Benjamin Herrenschmidtd883f7f2009-02-02 16:55:45 +11002108 resource_size_t fb_base;
Dave Airlief453ba02008-11-07 14:05:41 -08002109
Dave Airlieeb1f8e42010-05-07 06:42:51 +00002110 /* output poll support */
2111 bool poll_enabled;
Daniel Vetter905bc9f2012-10-23 18:23:36 +00002112 bool poll_running;
Daniel Vetter162b6a52015-01-21 08:45:21 +01002113 bool delayed_event;
Tejun Heo991ea752010-07-20 22:09:02 +02002114 struct delayed_work output_poll_work;
Dave Airlieeb1f8e42010-05-07 06:42:51 +00002115
Daniel Stone8fb6e7a2015-04-20 19:22:54 +01002116 struct mutex blob_lock;
2117
Dave Airlief453ba02008-11-07 14:05:41 -08002118 /* pointers to standard properties */
2119 struct list_head property_blob_list;
2120 struct drm_property *edid_property;
2121 struct drm_property *dpms_property;
Dave Airlie43aba7e2014-06-05 14:01:31 +10002122 struct drm_property *path_property;
Dave Airlie6f134d72014-10-20 16:30:50 +10002123 struct drm_property *tile_property;
Rob Clark9922ab52014-04-01 20:16:57 -04002124 struct drm_property *plane_type_property;
Sonika Jindal2a297cc2014-08-05 11:26:54 +05302125 struct drm_property *rotation_property;
Rob Clark6b4959f2014-12-18 16:01:53 -05002126 struct drm_property *prop_src_x;
2127 struct drm_property *prop_src_y;
2128 struct drm_property *prop_src_w;
2129 struct drm_property *prop_src_h;
2130 struct drm_property *prop_crtc_x;
2131 struct drm_property *prop_crtc_y;
2132 struct drm_property *prop_crtc_w;
2133 struct drm_property *prop_crtc_h;
2134 struct drm_property *prop_fb_id;
2135 struct drm_property *prop_crtc_id;
Daniel Vettereab3bbe2015-01-22 16:36:21 +01002136 struct drm_property *prop_active;
Daniel Stone955f3c32015-05-25 19:11:52 +01002137 struct drm_property *prop_mode_id;
Dave Airlief453ba02008-11-07 14:05:41 -08002138
2139 /* DVI-I properties */
2140 struct drm_property *dvi_i_subconnector_property;
2141 struct drm_property *dvi_i_select_subconnector_property;
2142
2143 /* TV properties */
2144 struct drm_property *tv_subconnector_property;
2145 struct drm_property *tv_select_subconnector_property;
2146 struct drm_property *tv_mode_property;
2147 struct drm_property *tv_left_margin_property;
2148 struct drm_property *tv_right_margin_property;
2149 struct drm_property *tv_top_margin_property;
2150 struct drm_property *tv_bottom_margin_property;
Francisco Jerezb6b79022009-08-02 04:19:20 +02002151 struct drm_property *tv_brightness_property;
2152 struct drm_property *tv_contrast_property;
2153 struct drm_property *tv_flicker_reduction_property;
Francisco Jereza75f0232009-08-12 02:30:10 +02002154 struct drm_property *tv_overscan_property;
2155 struct drm_property *tv_saturation_property;
2156 struct drm_property *tv_hue_property;
Dave Airlief453ba02008-11-07 14:05:41 -08002157
2158 /* Optional properties */
2159 struct drm_property *scaling_mode_property;
Vandana Kannanff587e42014-06-11 10:46:48 +05302160 struct drm_property *aspect_ratio_property;
Jakob Bornecrantz884840a2009-12-03 23:25:47 +00002161 struct drm_property *dirty_info_property;
Dave Airlie019d96c2011-09-29 16:20:42 +01002162
Lionel Landwerlin5488dc12016-02-26 17:05:00 +00002163 /* Optional color correction properties */
2164 struct drm_property *degamma_lut_property;
2165 struct drm_property *degamma_lut_size_property;
2166 struct drm_property *ctm_property;
2167 struct drm_property *gamma_lut_property;
2168 struct drm_property *gamma_lut_size_property;
2169
Dave Airlie5bb2bbf2014-11-10 10:18:15 +10002170 /* properties for virtual machine layout */
2171 struct drm_property *suggested_x_property;
2172 struct drm_property *suggested_y_property;
2173
Dave Airlie019d96c2011-09-29 16:20:42 +01002174 /* dumb ioctl parameters */
2175 uint32_t preferred_depth, prefer_shadow;
Keith Packard62f21042013-07-22 18:50:00 -07002176
2177 /* whether async page flip is supported or not */
2178 bool async_page_flip;
Alex Deucher8716ed42014-02-12 12:48:23 -05002179
Rob Clarke3eb3252015-02-05 14:41:52 +00002180 /* whether the driver supports fb modifiers */
2181 bool allow_fb_modifiers;
2182
Alex Deucher8716ed42014-02-12 12:48:23 -05002183 /* cursor size */
2184 uint32_t cursor_width, cursor_height;
Dave Airlief453ba02008-11-07 14:05:41 -08002185};
2186
Rob Clarkdd275952014-11-25 20:29:46 -05002187/**
2188 * drm_for_each_plane_mask - iterate over planes specified by bitmask
2189 * @plane: the loop cursor
2190 * @dev: the DRM device
2191 * @plane_mask: bitmask of plane indices
2192 *
2193 * Iterate over all planes specified by bitmask.
2194 */
2195#define drm_for_each_plane_mask(plane, dev, plane_mask) \
2196 list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \
Jani Nikula373701b2015-11-24 21:21:55 +02002197 for_each_if ((plane_mask) & (1 << drm_plane_index(plane)))
Rob Clarkdd275952014-11-25 20:29:46 -05002198
Maarten Lankhorstead8b662016-01-07 10:59:19 +01002199/**
2200 * drm_for_each_encoder_mask - iterate over encoders specified by bitmask
2201 * @encoder: the loop cursor
2202 * @dev: the DRM device
2203 * @encoder_mask: bitmask of encoder indices
2204 *
2205 * Iterate over all encoders specified by bitmask.
2206 */
2207#define drm_for_each_encoder_mask(encoder, dev, encoder_mask) \
2208 list_for_each_entry((encoder), &(dev)->mode_config.encoder_list, head) \
2209 for_each_if ((encoder_mask) & (1 << drm_encoder_index(encoder)))
Rob Clarkdd275952014-11-25 20:29:46 -05002210
Dave Airlief453ba02008-11-07 14:05:41 -08002211#define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
2212#define obj_to_connector(x) container_of(x, struct drm_connector, base)
2213#define obj_to_encoder(x) container_of(x, struct drm_encoder, base)
2214#define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
2215#define obj_to_fb(x) container_of(x, struct drm_framebuffer, base)
2216#define obj_to_property(x) container_of(x, struct drm_property, base)
2217#define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
Jesse Barnes8cf5c912011-11-14 14:51:27 -08002218#define obj_to_plane(x) container_of(x, struct drm_plane, base)
Dave Airlief453ba02008-11-07 14:05:41 -08002219
Sascha Hauer4a67d392012-02-06 10:58:17 +01002220struct drm_prop_enum_list {
2221 int type;
2222 char *name;
2223};
Dave Airlief453ba02008-11-07 14:05:41 -08002224
Ville Syrjäläf9882872015-12-09 16:19:31 +02002225extern __printf(6, 7)
2226int drm_crtc_init_with_planes(struct drm_device *dev,
2227 struct drm_crtc *crtc,
2228 struct drm_plane *primary,
2229 struct drm_plane *cursor,
2230 const struct drm_crtc_funcs *funcs,
2231 const char *name, ...);
Dave Airlief453ba02008-11-07 14:05:41 -08002232extern void drm_crtc_cleanup(struct drm_crtc *crtc);
Russell Kingdb5f7a62014-01-02 21:27:33 +00002233extern unsigned int drm_crtc_index(struct drm_crtc *crtc);
2234
2235/**
2236 * drm_crtc_mask - find the mask of a registered CRTC
2237 * @crtc: CRTC to find mask for
2238 *
2239 * Given a registered CRTC, return the mask bit of that CRTC for an
2240 * encoder's possible_crtcs field.
2241 */
2242static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc)
2243{
2244 return 1 << drm_crtc_index(crtc);
2245}
Dave Airlief453ba02008-11-07 14:05:41 -08002246
Ilia Mirkinb21e3af2013-08-07 22:34:48 -04002247extern void drm_connector_ida_init(void);
2248extern void drm_connector_ida_destroy(void);
Ville Syrjälä6bfc56a2012-03-13 12:35:48 +02002249extern int drm_connector_init(struct drm_device *dev,
2250 struct drm_connector *connector,
2251 const struct drm_connector_funcs *funcs,
2252 int connector_type);
Thomas Wood34ea3d32014-05-29 16:57:41 +01002253int drm_connector_register(struct drm_connector *connector);
2254void drm_connector_unregister(struct drm_connector *connector);
Dave Airlief453ba02008-11-07 14:05:41 -08002255
2256extern void drm_connector_cleanup(struct drm_connector *connector);
Maarten Lankhorst5fff80b2016-02-17 08:32:05 +01002257static inline unsigned drm_connector_index(struct drm_connector *connector)
2258{
2259 return connector->connector_id;
2260}
2261
Dave Airliecbc7e222012-02-20 14:16:40 +00002262/* helper to unplug all connectors from sysfs for device */
2263extern void drm_connector_unplug_all(struct drm_device *dev);
Dave Airlief453ba02008-11-07 14:05:41 -08002264
Ajay Kumar3d3f8b12015-01-20 22:08:44 +05302265extern int drm_bridge_add(struct drm_bridge *bridge);
2266extern void drm_bridge_remove(struct drm_bridge *bridge);
2267extern struct drm_bridge *of_drm_find_bridge(struct device_node *np);
2268extern int drm_bridge_attach(struct drm_device *dev, struct drm_bridge *bridge);
Sean Paul3b336ec2013-08-14 16:47:37 -04002269
Archit Taneja862e6862015-05-21 11:03:16 +05302270bool drm_bridge_mode_fixup(struct drm_bridge *bridge,
2271 const struct drm_display_mode *mode,
2272 struct drm_display_mode *adjusted_mode);
2273void drm_bridge_disable(struct drm_bridge *bridge);
2274void drm_bridge_post_disable(struct drm_bridge *bridge);
2275void drm_bridge_mode_set(struct drm_bridge *bridge,
2276 struct drm_display_mode *mode,
2277 struct drm_display_mode *adjusted_mode);
2278void drm_bridge_pre_enable(struct drm_bridge *bridge);
2279void drm_bridge_enable(struct drm_bridge *bridge);
2280
Ville Syrjälä13a3d912015-12-09 16:20:18 +02002281extern __printf(5, 6)
2282int drm_encoder_init(struct drm_device *dev,
2283 struct drm_encoder *encoder,
2284 const struct drm_encoder_funcs *funcs,
2285 int encoder_type, const char *name, ...);
Maarten Lankhorst47d77772016-01-07 10:59:18 +01002286extern unsigned int drm_encoder_index(struct drm_encoder *encoder);
Dave Airlief453ba02008-11-07 14:05:41 -08002287
Thierry Reding3d887362014-01-13 14:33:20 +01002288/**
2289 * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
2290 * @encoder: encoder to test
2291 * @crtc: crtc to test
2292 *
2293 * Return false if @encoder can't be driven by @crtc, true otherwise.
2294 */
2295static inline bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
2296 struct drm_crtc *crtc)
2297{
2298 return !!(encoder->possible_crtcs & drm_crtc_mask(crtc));
2299}
2300
Ville Syrjäläb0b3b792015-12-09 16:19:55 +02002301extern __printf(8, 9)
2302int drm_universal_plane_init(struct drm_device *dev,
2303 struct drm_plane *plane,
2304 unsigned long possible_crtcs,
2305 const struct drm_plane_funcs *funcs,
2306 const uint32_t *formats,
2307 unsigned int format_count,
2308 enum drm_plane_type type,
2309 const char *name, ...);
Jesse Barnes8cf5c912011-11-14 14:51:27 -08002310extern int drm_plane_init(struct drm_device *dev,
2311 struct drm_plane *plane,
2312 unsigned long possible_crtcs,
2313 const struct drm_plane_funcs *funcs,
Thierry Reding45e37432015-08-12 16:54:28 +02002314 const uint32_t *formats, unsigned int format_count,
Matt Roperdc415ff2014-04-01 15:22:36 -07002315 bool is_primary);
Jesse Barnes8cf5c912011-11-14 14:51:27 -08002316extern void drm_plane_cleanup(struct drm_plane *plane);
Daniel Vetter10f637b2014-07-29 13:47:11 +02002317extern unsigned int drm_plane_index(struct drm_plane *plane);
Chandra Konduruf81338a2015-04-09 17:36:21 -07002318extern struct drm_plane * drm_plane_from_index(struct drm_device *dev, int idx);
Ville Syrjälä9125e612013-06-03 16:10:40 +03002319extern void drm_plane_force_disable(struct drm_plane *plane);
Laurent Pinchartead86102015-03-05 02:25:43 +02002320extern int drm_plane_check_pixel_format(const struct drm_plane *plane,
2321 u32 format);
Gustavo Padovanecb7e162014-12-01 15:40:09 -08002322extern void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
2323 int *hdisplay, int *vdisplay);
Matt Roperaf936292014-04-01 15:22:34 -07002324extern int drm_crtc_check_viewport(const struct drm_crtc *crtc,
2325 int x, int y,
2326 const struct drm_display_mode *mode,
2327 const struct drm_framebuffer *fb);
Jesse Barnes8cf5c912011-11-14 14:51:27 -08002328
Dave Airlief453ba02008-11-07 14:05:41 -08002329extern void drm_encoder_cleanup(struct drm_encoder *encoder);
2330
Ville Syrjäläd20d3172013-06-07 15:43:07 +00002331extern const char *drm_get_connector_status_name(enum drm_connector_status status);
Jesse Barnesac1bb362014-02-10 15:32:44 -08002332extern const char *drm_get_subpixel_order_name(enum subpixel_order order);
Ville Syrjäläd20d3172013-06-07 15:43:07 +00002333extern const char *drm_get_dpms_name(int val);
2334extern const char *drm_get_dvi_i_subconnector_name(int val);
2335extern const char *drm_get_dvi_i_select_name(int val);
2336extern const char *drm_get_tv_subconnector_name(int val);
2337extern const char *drm_get_tv_select_name(int val);
Kristian Høgsbergea39f832009-02-12 14:37:56 -05002338extern void drm_fb_release(struct drm_file *file_priv);
Daniel Stonee2f5d2e2015-05-22 13:34:51 +01002339extern void drm_property_destroy_user_blobs(struct drm_device *dev,
2340 struct drm_file *file_priv);
Adam Jacksonfbff4692012-09-18 10:58:47 -04002341extern bool drm_probe_ddc(struct i2c_adapter *adapter);
Dave Airlief453ba02008-11-07 14:05:41 -08002342extern struct edid *drm_get_edid(struct drm_connector *connector,
2343 struct i2c_adapter *adapter);
Lukas Wunner5cb8eaa2016-01-11 20:09:20 +01002344extern struct edid *drm_get_edid_switcheroo(struct drm_connector *connector,
2345 struct i2c_adapter *adapter);
Jani Nikula51f8da52013-09-27 15:08:27 +03002346extern struct edid *drm_edid_duplicate(const struct edid *edid);
Dave Airlief453ba02008-11-07 14:05:41 -08002347extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
Dave Airlief453ba02008-11-07 14:05:41 -08002348extern void drm_mode_config_init(struct drm_device *dev);
Chris Wilsoneb033552011-01-24 15:11:08 +00002349extern void drm_mode_config_reset(struct drm_device *dev);
Dave Airlief453ba02008-11-07 14:05:41 -08002350extern void drm_mode_config_cleanup(struct drm_device *dev);
Dave Airlief453ba02008-11-07 14:05:41 -08002351
Dave Airlie43aba7e2014-06-05 14:01:31 +10002352extern int drm_mode_connector_set_path_property(struct drm_connector *connector,
Thierry Reding12e6cec2014-05-13 11:38:36 +02002353 const char *path);
Dave Airlie6f134d72014-10-20 16:30:50 +10002354int drm_mode_connector_set_tile_property(struct drm_connector *connector);
Dave Airlief453ba02008-11-07 14:05:41 -08002355extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
Thierry Reding12e6cec2014-05-13 11:38:36 +02002356 const struct edid *edid);
Rob Clark5ea22f22014-05-30 11:34:01 -04002357
Boris Brezillonb5571e92014-07-22 12:09:10 +02002358extern int drm_display_info_set_bus_formats(struct drm_display_info *info,
2359 const u32 *formats,
2360 unsigned int num_formats);
2361
Rob Clark5ea22f22014-05-30 11:34:01 -04002362static inline bool drm_property_type_is(struct drm_property *property,
2363 uint32_t type)
2364{
2365 /* instanceof for props.. handles extended type vs original types: */
2366 if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
2367 return (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) == type;
2368 return property->flags & type;
2369}
2370
2371static inline bool drm_property_type_valid(struct drm_property *property)
2372{
2373 if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
2374 return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
2375 return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
2376}
2377
Paulo Zanonic5431882012-05-15 18:09:02 -03002378extern int drm_object_property_set_value(struct drm_mode_object *obj,
2379 struct drm_property *property,
2380 uint64_t val);
2381extern int drm_object_property_get_value(struct drm_mode_object *obj,
2382 struct drm_property *property,
2383 uint64_t *value);
Dave Airlief453ba02008-11-07 14:05:41 -08002384extern int drm_framebuffer_init(struct drm_device *dev,
2385 struct drm_framebuffer *fb,
2386 const struct drm_framebuffer_funcs *funcs);
Daniel Vetter786b99e2012-12-02 21:53:40 +01002387extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
2388 uint32_t id);
Rob Clarkf7eff602012-09-05 21:48:38 +00002389extern void drm_framebuffer_unreference(struct drm_framebuffer *fb);
2390extern void drm_framebuffer_reference(struct drm_framebuffer *fb);
2391extern void drm_framebuffer_remove(struct drm_framebuffer *fb);
Dave Airlief453ba02008-11-07 14:05:41 -08002392extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
Daniel Vetter36206362012-12-10 20:42:17 +01002393extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb);
Dave Airlief453ba02008-11-07 14:05:41 -08002394
Paulo Zanonic5431882012-05-15 18:09:02 -03002395extern void drm_object_attach_property(struct drm_mode_object *obj,
2396 struct drm_property *property,
2397 uint64_t init_val);
Dave Airlief453ba02008-11-07 14:05:41 -08002398extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
2399 const char *name, int num_values);
Sascha Hauer4a67d392012-02-06 10:58:17 +01002400extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
2401 const char *name,
2402 const struct drm_prop_enum_list *props,
2403 int num_values);
Rob Clark49e27542012-05-17 02:23:26 -06002404struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
2405 int flags, const char *name,
2406 const struct drm_prop_enum_list *props,
Ville Syrjälä7689ffb2014-07-08 10:31:52 +05302407 int num_props,
2408 uint64_t supported_bits);
Sascha Hauerd9bc3c02012-02-06 10:58:18 +01002409struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
2410 const char *name,
2411 uint64_t min, uint64_t max);
Rob Clarkebc44cf2012-09-12 22:22:31 -05002412struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
2413 int flags, const char *name,
2414 int64_t min, int64_t max);
Rob Clark98f75de2014-05-30 11:37:03 -04002415struct drm_property *drm_property_create_object(struct drm_device *dev,
2416 int flags, const char *name, uint32_t type);
Daniel Vetter960cd9d2015-01-21 08:47:38 +01002417struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
2418 const char *name);
Daniel Stone6bcacf52015-04-20 19:22:55 +01002419struct drm_property_blob *drm_property_create_blob(struct drm_device *dev,
2420 size_t length,
2421 const void *data);
2422struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
2423 uint32_t id);
2424struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob);
2425void drm_property_unreference_blob(struct drm_property_blob *blob);
Dave Airlief453ba02008-11-07 14:05:41 -08002426extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
2427extern int drm_property_add_enum(struct drm_property *property, int index,
2428 uint64_t value, const char *name);
2429extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
Thierry Reding2f763312014-10-13 12:45:57 +02002430extern int drm_mode_create_tv_properties(struct drm_device *dev,
2431 unsigned int num_modes,
Ville Syrjäläb7c914b2015-08-31 15:09:26 +03002432 const char * const modes[]);
Dave Airlief453ba02008-11-07 14:05:41 -08002433extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
Vandana Kannanff587e42014-06-11 10:46:48 +05302434extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
Jakob Bornecrantz884840a2009-12-03 23:25:47 +00002435extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
Dave Airlie5bb2bbf2014-11-10 10:18:15 +10002436extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
Rob Clarkd34f20d2014-12-18 16:01:56 -05002437extern bool drm_property_change_valid_get(struct drm_property *property,
2438 uint64_t value, struct drm_mode_object **ref);
2439extern void drm_property_change_valid_put(struct drm_property *property,
2440 struct drm_mode_object *ref);
Dave Airlief453ba02008-11-07 14:05:41 -08002441
2442extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
2443 struct drm_encoder *encoder);
Sascha Hauer4cae5b82012-02-01 11:38:23 +01002444extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
Dave Airlief453ba02008-11-07 14:05:41 -08002445 int gamma_size);
Daniel Vetter7a9c9062009-09-15 22:57:31 +02002446extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
2447 uint32_t id, uint32_t type);
Rob Clark98f75de2014-05-30 11:37:03 -04002448
Dave Airlief453ba02008-11-07 14:05:41 -08002449/* IOCTLs */
2450extern int drm_mode_getresources(struct drm_device *dev,
2451 void *data, struct drm_file *file_priv);
Jesse Barnes8cf5c912011-11-14 14:51:27 -08002452extern int drm_mode_getplane_res(struct drm_device *dev, void *data,
2453 struct drm_file *file_priv);
Dave Airlief453ba02008-11-07 14:05:41 -08002454extern int drm_mode_getcrtc(struct drm_device *dev,
2455 void *data, struct drm_file *file_priv);
2456extern int drm_mode_getconnector(struct drm_device *dev,
2457 void *data, struct drm_file *file_priv);
Daniel Vetter2d13b672012-12-11 13:47:23 +01002458extern int drm_mode_set_config_internal(struct drm_mode_set *set);
Dave Airlief453ba02008-11-07 14:05:41 -08002459extern int drm_mode_setcrtc(struct drm_device *dev,
2460 void *data, struct drm_file *file_priv);
Jesse Barnes8cf5c912011-11-14 14:51:27 -08002461extern int drm_mode_getplane(struct drm_device *dev,
2462 void *data, struct drm_file *file_priv);
2463extern int drm_mode_setplane(struct drm_device *dev,
2464 void *data, struct drm_file *file_priv);
Dave Airlief453ba02008-11-07 14:05:41 -08002465extern int drm_mode_cursor_ioctl(struct drm_device *dev,
2466 void *data, struct drm_file *file_priv);
Dave Airlie4c813d42013-06-20 11:48:52 +10002467extern int drm_mode_cursor2_ioctl(struct drm_device *dev,
2468 void *data, struct drm_file *file_priv);
Dave Airlief453ba02008-11-07 14:05:41 -08002469extern int drm_mode_addfb(struct drm_device *dev,
2470 void *data, struct drm_file *file_priv);
Jesse Barnes308e5bc2011-11-14 14:51:28 -08002471extern int drm_mode_addfb2(struct drm_device *dev,
2472 void *data, struct drm_file *file_priv);
2473extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth);
Dave Airlief453ba02008-11-07 14:05:41 -08002474extern int drm_mode_rmfb(struct drm_device *dev,
2475 void *data, struct drm_file *file_priv);
2476extern int drm_mode_getfb(struct drm_device *dev,
2477 void *data, struct drm_file *file_priv);
Jakob Bornecrantz884840a2009-12-03 23:25:47 +00002478extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
2479 void *data, struct drm_file *file_priv);
Dave Airlief453ba02008-11-07 14:05:41 -08002480
2481extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
2482 void *data, struct drm_file *file_priv);
2483extern int drm_mode_getblob_ioctl(struct drm_device *dev,
2484 void *data, struct drm_file *file_priv);
Daniel Stonee2f5d2e2015-05-22 13:34:51 +01002485extern int drm_mode_createblob_ioctl(struct drm_device *dev,
2486 void *data, struct drm_file *file_priv);
2487extern int drm_mode_destroyblob_ioctl(struct drm_device *dev,
2488 void *data, struct drm_file *file_priv);
Dave Airlief453ba02008-11-07 14:05:41 -08002489extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
2490 void *data, struct drm_file *file_priv);
Dave Airlief453ba02008-11-07 14:05:41 -08002491extern int drm_mode_getencoder(struct drm_device *dev,
2492 void *data, struct drm_file *file_priv);
2493extern int drm_mode_gamma_get_ioctl(struct drm_device *dev,
2494 void *data, struct drm_file *file_priv);
2495extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
2496 void *data, struct drm_file *file_priv);
Thierry Reding18316c82012-12-20 15:41:44 +01002497extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match);
Vandana Kannan0967e6a2014-04-01 16:26:59 +05302498extern enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code);
Ma Lingf23c20c2009-03-26 19:26:23 +08002499extern bool drm_detect_hdmi_monitor(struct edid *edid);
Zhenyu Wang8fe97902010-09-19 14:27:28 +08002500extern bool drm_detect_monitor_audio(struct edid *edid);
Ville Syrjäläb1edd6a2013-01-17 16:31:30 +02002501extern bool drm_rgb_quant_range_selectable(struct edid *edid);
Kristian Høgsbergd91d8a32009-11-17 12:43:55 -05002502extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
2503 void *data, struct drm_file *file_priv);
Zhao Yakuif0fda0a2009-09-03 09:33:48 +08002504extern int drm_add_modes_noedid(struct drm_connector *connector,
2505 int hdisplay, int vdisplay);
Gerd Hoffmann3cf70da2013-10-11 10:01:08 +02002506extern void drm_set_preferred_mode(struct drm_connector *connector,
2507 int hpref, int vpref);
Alex Deucher3c537882010-02-05 04:21:19 -05002508
Thomas Reim051963d2011-07-29 14:28:57 +00002509extern int drm_edid_header_is_valid(const u8 *raw_edid);
Todd Previte6ba2bd32015-04-21 11:09:41 -07002510extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid,
2511 bool *edid_corrupt);
Alex Deucher3c537882010-02-05 04:21:19 -05002512extern bool drm_edid_is_valid(struct edid *edid);
Dave Airlie138f9eb2014-10-20 16:17:17 +10002513
2514extern struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
2515 char topology[8]);
2516extern struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
2517 char topology[8]);
2518extern void drm_mode_put_tile_group(struct drm_device *dev,
2519 struct drm_tile_group *tg);
Dave Airlie1d42bbc2010-05-07 05:02:30 +00002520struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
Adam Jacksonf6e252b2012-04-13 16:33:31 -04002521 int hsize, int vsize, int fresh,
2522 bool rb);
Dave Airlieff72145b2011-02-07 12:16:14 +10002523
2524extern int drm_mode_create_dumb_ioctl(struct drm_device *dev,
2525 void *data, struct drm_file *file_priv);
2526extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
2527 void *data, struct drm_file *file_priv);
2528extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
2529 void *data, struct drm_file *file_priv);
Paulo Zanonic5431882012-05-15 18:09:02 -03002530extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
2531 struct drm_file *file_priv);
2532extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
2533 struct drm_file *file_priv);
Thomas Wood3a5f87c2014-08-20 14:45:00 +01002534extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
2535 struct drm_property *property,
2536 uint64_t value);
Rob Clarkd34f20d2014-12-18 16:01:56 -05002537extern int drm_mode_atomic_ioctl(struct drm_device *dev,
2538 void *data, struct drm_file *file_priv);
Dave Airlie248dbc22011-11-29 20:02:54 +00002539
2540extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
2541 int *bpp);
Ville Syrjälä141670e2012-04-05 21:35:15 +03002542extern int drm_format_num_planes(uint32_t format);
Ville Syrjälä5a86bd52012-04-05 21:35:16 +03002543extern int drm_format_plane_cpp(uint32_t format, int plane);
Ville Syrjälä01b68b02012-04-05 21:35:17 +03002544extern int drm_format_horz_chroma_subsampling(uint32_t format);
2545extern int drm_format_vert_chroma_subsampling(uint32_t format);
Ville Syrjälä4c617162016-02-09 17:29:44 +02002546extern int drm_format_plane_width(int width, uint32_t format, int plane);
2547extern int drm_format_plane_height(int height, uint32_t format, int plane);
Ville Syrjäläd20d3172013-06-07 15:43:07 +00002548extern const char *drm_get_format_name(uint32_t format);
Ville Syrjäläc1df5f32014-07-08 10:31:53 +05302549extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
2550 unsigned int supported_rotations);
Ville Syrjälä3c9855f2014-07-08 10:31:56 +05302551extern unsigned int drm_rotation_simplify(unsigned int rotation,
2552 unsigned int supported_rotations);
Ville Syrjälä141670e2012-04-05 21:35:15 +03002553
Russell King96f60e32012-08-15 13:59:49 +01002554/* Helpers */
Rob Clarka2b34e22013-10-05 16:36:52 -04002555
2556static inline struct drm_plane *drm_plane_find(struct drm_device *dev,
2557 uint32_t id)
2558{
2559 struct drm_mode_object *mo;
2560 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PLANE);
2561 return mo ? obj_to_plane(mo) : NULL;
2562}
2563
Russell King96f60e32012-08-15 13:59:49 +01002564static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
2565 uint32_t id)
2566{
2567 struct drm_mode_object *mo;
2568 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC);
2569 return mo ? obj_to_crtc(mo) : NULL;
2570}
2571
2572static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev,
2573 uint32_t id)
2574{
2575 struct drm_mode_object *mo;
2576 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
2577 return mo ? obj_to_encoder(mo) : NULL;
2578}
2579
Rob Clarka2b34e22013-10-05 16:36:52 -04002580static inline struct drm_connector *drm_connector_find(struct drm_device *dev,
2581 uint32_t id)
2582{
2583 struct drm_mode_object *mo;
2584 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CONNECTOR);
2585 return mo ? obj_to_connector(mo) : NULL;
2586}
2587
2588static inline struct drm_property *drm_property_find(struct drm_device *dev,
2589 uint32_t id)
2590{
2591 struct drm_mode_object *mo;
2592 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PROPERTY);
2593 return mo ? obj_to_property(mo) : NULL;
2594}
2595
Lionel Landwerlin5488dc12016-02-26 17:05:00 +00002596/*
2597 * Extract a degamma/gamma LUT value provided by user and round it to the
2598 * precision supported by the hardware.
2599 */
2600static inline uint32_t drm_color_lut_extract(uint32_t user_input,
2601 uint32_t bit_precision)
2602{
2603 uint32_t val = user_input + (1 << (16 - bit_precision - 1));
2604 uint32_t max = 0xffff >> (16 - bit_precision);
2605
2606 val >>= 16 - bit_precision;
2607
2608 return clamp_val(val, 0, max);
2609}
2610
Matt Ropere27dde32014-04-01 15:22:30 -07002611/* Plane list iterator for legacy (overlay only) planes. */
Daniel Vetter4ea50e92015-07-09 23:44:24 +02002612#define drm_for_each_legacy_plane(plane, dev) \
2613 list_for_each_entry(plane, &(dev)->mode_config.plane_list, head) \
Jani Nikula373701b2015-11-24 21:21:55 +02002614 for_each_if (plane->type == DRM_PLANE_TYPE_OVERLAY)
Matt Ropere27dde32014-04-01 15:22:30 -07002615
Daniel Vetter6295d602015-07-09 23:44:25 +02002616#define drm_for_each_plane(plane, dev) \
2617 list_for_each_entry(plane, &(dev)->mode_config.plane_list, head)
2618
2619#define drm_for_each_crtc(crtc, dev) \
2620 list_for_each_entry(crtc, &(dev)->mode_config.crtc_list, head)
2621
Daniel Vetter7a3f3d62015-07-09 23:44:28 +02002622static inline void
2623assert_drm_connector_list_read_locked(struct drm_mode_config *mode_config)
2624{
Daniel Vettercff20ba2015-07-09 23:44:33 +02002625 /*
2626 * The connector hotadd/remove code currently grabs both locks when
2627 * updating lists. Hence readers need only hold either of them to be
2628 * safe and the check amounts to
2629 *
2630 * WARN_ON(not_holding(A) && not_holding(B)).
2631 */
2632 WARN_ON(!mutex_is_locked(&mode_config->mutex) &&
2633 !drm_modeset_is_locked(&mode_config->connection_mutex));
Daniel Vetter7a3f3d62015-07-09 23:44:28 +02002634}
2635
Daniel Vetter6295d602015-07-09 23:44:25 +02002636#define drm_for_each_connector(connector, dev) \
Daniel Vetter7a3f3d62015-07-09 23:44:28 +02002637 for (assert_drm_connector_list_read_locked(&(dev)->mode_config), \
2638 connector = list_first_entry(&(dev)->mode_config.connector_list, \
2639 struct drm_connector, head); \
2640 &connector->head != (&(dev)->mode_config.connector_list); \
2641 connector = list_next_entry(connector, head))
Daniel Vetter6295d602015-07-09 23:44:25 +02002642
2643#define drm_for_each_encoder(encoder, dev) \
2644 list_for_each_entry(encoder, &(dev)->mode_config.encoder_list, head)
2645
2646#define drm_for_each_fb(fb, dev) \
Daniel Vetter4676ba02015-07-09 23:44:30 +02002647 for (WARN_ON(!mutex_is_locked(&(dev)->mode_config.fb_lock)), \
2648 fb = list_first_entry(&(dev)->mode_config.fb_list, \
2649 struct drm_framebuffer, head); \
2650 &fb->head != (&(dev)->mode_config.fb_list); \
2651 fb = list_next_entry(fb, head))
Daniel Vetter6295d602015-07-09 23:44:25 +02002652
Dave Airlief453ba02008-11-07 14:05:41 -08002653#endif /* __DRM_CRTC_H__ */