Line data Source code
1 : /*
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/spinlock.h>
29 : #include <linux/types.h>
30 : #include <drm/drm_modeset_lock.h>
31 : #include <drm/drm_mode_object.h>
32 : #include <drm/drm_modes.h>
33 : #include <drm/drm_device.h>
34 : #include <drm/drm_plane.h>
35 : #include <drm/drm_debugfs_crc.h>
36 : #include <drm/drm_mode_config.h>
37 :
38 : struct drm_connector;
39 : struct drm_device;
40 : struct drm_framebuffer;
41 : struct drm_mode_set;
42 : struct drm_file;
43 : struct drm_printer;
44 : struct drm_self_refresh_data;
45 : struct device_node;
46 : struct edid;
47 :
48 : static inline int64_t U642I64(uint64_t val)
49 : {
50 0 : return (int64_t)*((int64_t *)&val);
51 : }
52 : static inline uint64_t I642U64(int64_t val)
53 : {
54 132 : return (uint64_t)*((uint64_t *)&val);
55 : }
56 :
57 : struct drm_crtc;
58 : struct drm_pending_vblank_event;
59 : struct drm_plane;
60 : struct drm_bridge;
61 : struct drm_atomic_state;
62 :
63 : struct drm_crtc_helper_funcs;
64 : struct drm_plane_helper_funcs;
65 :
66 : /**
67 : * struct drm_crtc_state - mutable CRTC state
68 : *
69 : * Note that the distinction between @enable and @active is rather subtle:
70 : * Flipping @active while @enable is set without changing anything else may
71 : * never return in a failure from the &drm_mode_config_funcs.atomic_check
72 : * callback. Userspace assumes that a DPMS On will always succeed. In other
73 : * words: @enable controls resource assignment, @active controls the actual
74 : * hardware state.
75 : *
76 : * The three booleans active_changed, connectors_changed and mode_changed are
77 : * intended to indicate whether a full modeset is needed, rather than strictly
78 : * describing what has changed in a commit. See also:
79 : * drm_atomic_crtc_needs_modeset()
80 : *
81 : * WARNING: Transitional helpers (like drm_helper_crtc_mode_set() or
82 : * drm_helper_crtc_mode_set_base()) do not maintain many of the derived control
83 : * state like @plane_mask so drivers not converted over to atomic helpers should
84 : * not rely on these being accurate!
85 : */
86 : struct drm_crtc_state {
87 : /** @crtc: backpointer to the CRTC */
88 : struct drm_crtc *crtc;
89 :
90 : /**
91 : * @enable: Whether the CRTC should be enabled, gates all other state.
92 : * This controls reservations of shared resources. Actual hardware state
93 : * is controlled by @active.
94 : */
95 : bool enable;
96 :
97 : /**
98 : * @active: Whether the CRTC is actively displaying (used for DPMS).
99 : * Implies that @enable is set. The driver must not release any shared
100 : * resources if @active is set to false but @enable still true, because
101 : * userspace expects that a DPMS ON always succeeds.
102 : *
103 : * Hence drivers must not consult @active in their various
104 : * &drm_mode_config_funcs.atomic_check callback to reject an atomic
105 : * commit. They can consult it to aid in the computation of derived
106 : * hardware state, since even in the DPMS OFF state the display hardware
107 : * should be as much powered down as when the CRTC is completely
108 : * disabled through setting @enable to false.
109 : */
110 : bool active;
111 :
112 : /**
113 : * @planes_changed: Planes on this crtc are updated. Used by the atomic
114 : * helpers and drivers to steer the atomic commit control flow.
115 : */
116 : bool planes_changed : 1;
117 :
118 : /**
119 : * @mode_changed: @mode or @enable has been changed. Used by the atomic
120 : * helpers and drivers to steer the atomic commit control flow. See also
121 : * drm_atomic_crtc_needs_modeset().
122 : *
123 : * Drivers are supposed to set this for any CRTC state changes that
124 : * require a full modeset. They can also reset it to false if e.g. a
125 : * @mode change can be done without a full modeset by only changing
126 : * scaler settings.
127 : */
128 : bool mode_changed : 1;
129 :
130 : /**
131 : * @active_changed: @active has been toggled. Used by the atomic
132 : * helpers and drivers to steer the atomic commit control flow. See also
133 : * drm_atomic_crtc_needs_modeset().
134 : */
135 : bool active_changed : 1;
136 :
137 : /**
138 : * @connectors_changed: Connectors to this crtc have been updated,
139 : * either in their state or routing. Used by the atomic
140 : * helpers and drivers to steer the atomic commit control flow. See also
141 : * drm_atomic_crtc_needs_modeset().
142 : *
143 : * Drivers are supposed to set this as-needed from their own atomic
144 : * check code, e.g. from &drm_encoder_helper_funcs.atomic_check
145 : */
146 : bool connectors_changed : 1;
147 : /**
148 : * @zpos_changed: zpos values of planes on this crtc have been updated.
149 : * Used by the atomic helpers and drivers to steer the atomic commit
150 : * control flow.
151 : */
152 : bool zpos_changed : 1;
153 : /**
154 : * @color_mgmt_changed: Color management properties have changed
155 : * (@gamma_lut, @degamma_lut or @ctm). Used by the atomic helpers and
156 : * drivers to steer the atomic commit control flow.
157 : */
158 : bool color_mgmt_changed : 1;
159 :
160 : /**
161 : * @no_vblank:
162 : *
163 : * Reflects the ability of a CRTC to send VBLANK events. This state
164 : * usually depends on the pipeline configuration. If set to true, DRM
165 : * atomic helpers will send out a fake VBLANK event during display
166 : * updates after all hardware changes have been committed. This is
167 : * implemented in drm_atomic_helper_fake_vblank().
168 : *
169 : * One usage is for drivers and/or hardware without support for VBLANK
170 : * interrupts. Such drivers typically do not initialize vblanking
171 : * (i.e., call drm_vblank_init() with the number of CRTCs). For CRTCs
172 : * without initialized vblanking, this field is set to true in
173 : * drm_atomic_helper_check_modeset(), and a fake VBLANK event will be
174 : * send out on each update of the display pipeline by
175 : * drm_atomic_helper_fake_vblank().
176 : *
177 : * Another usage is CRTCs feeding a writeback connector operating in
178 : * oneshot mode. In this case the fake VBLANK event is only generated
179 : * when a job is queued to the writeback connector, and we want the
180 : * core to fake VBLANK events when this part of the pipeline hasn't
181 : * changed but others had or when the CRTC and connectors are being
182 : * disabled.
183 : *
184 : * __drm_atomic_helper_crtc_duplicate_state() will not reset the value
185 : * from the current state, the CRTC driver is then responsible for
186 : * updating this field when needed.
187 : *
188 : * Note that the combination of &drm_crtc_state.event == NULL and
189 : * &drm_crtc_state.no_blank == true is valid and usually used when the
190 : * writeback connector attached to the CRTC has a new job queued. In
191 : * this case the driver will send the VBLANK event on its own when the
192 : * writeback job is complete.
193 : */
194 : bool no_vblank : 1;
195 :
196 : /**
197 : * @plane_mask: Bitmask of drm_plane_mask(plane) of planes attached to
198 : * this CRTC.
199 : */
200 : u32 plane_mask;
201 :
202 : /**
203 : * @connector_mask: Bitmask of drm_connector_mask(connector) of
204 : * connectors attached to this CRTC.
205 : */
206 : u32 connector_mask;
207 :
208 : /**
209 : * @encoder_mask: Bitmask of drm_encoder_mask(encoder) of encoders
210 : * attached to this CRTC.
211 : */
212 : u32 encoder_mask;
213 :
214 : /**
215 : * @adjusted_mode:
216 : *
217 : * Internal display timings which can be used by the driver to handle
218 : * differences between the mode requested by userspace in @mode and what
219 : * is actually programmed into the hardware.
220 : *
221 : * For drivers using &drm_bridge, this stores hardware display timings
222 : * used between the CRTC and the first bridge. For other drivers, the
223 : * meaning of the adjusted_mode field is purely driver implementation
224 : * defined information, and will usually be used to store the hardware
225 : * display timings used between the CRTC and encoder blocks.
226 : */
227 : struct drm_display_mode adjusted_mode;
228 :
229 : /**
230 : * @mode:
231 : *
232 : * Display timings requested by userspace. The driver should try to
233 : * match the refresh rate as close as possible (but note that it's
234 : * undefined what exactly is close enough, e.g. some of the HDMI modes
235 : * only differ in less than 1% of the refresh rate). The active width
236 : * and height as observed by userspace for positioning planes must match
237 : * exactly.
238 : *
239 : * For external connectors where the sink isn't fixed (like with a
240 : * built-in panel), this mode here should match the physical mode on the
241 : * wire to the last details (i.e. including sync polarities and
242 : * everything).
243 : */
244 : struct drm_display_mode mode;
245 :
246 : /**
247 : * @mode_blob: &drm_property_blob for @mode, for exposing the mode to
248 : * atomic userspace.
249 : */
250 : struct drm_property_blob *mode_blob;
251 :
252 : /**
253 : * @degamma_lut:
254 : *
255 : * Lookup table for converting framebuffer pixel data before apply the
256 : * color conversion matrix @ctm. See drm_crtc_enable_color_mgmt(). The
257 : * blob (if not NULL) is an array of &struct drm_color_lut.
258 : */
259 : struct drm_property_blob *degamma_lut;
260 :
261 : /**
262 : * @ctm:
263 : *
264 : * Color transformation matrix. See drm_crtc_enable_color_mgmt(). The
265 : * blob (if not NULL) is a &struct drm_color_ctm.
266 : */
267 : struct drm_property_blob *ctm;
268 :
269 : /**
270 : * @gamma_lut:
271 : *
272 : * Lookup table for converting pixel data after the color conversion
273 : * matrix @ctm. See drm_crtc_enable_color_mgmt(). The blob (if not
274 : * NULL) is an array of &struct drm_color_lut.
275 : *
276 : * Note that for mostly historical reasons stemming from Xorg heritage,
277 : * this is also used to store the color map (also sometimes color lut,
278 : * CLUT or color palette) for indexed formats like DRM_FORMAT_C8.
279 : */
280 : struct drm_property_blob *gamma_lut;
281 :
282 : /**
283 : * @target_vblank:
284 : *
285 : * Target vertical blank period when a page flip
286 : * should take effect.
287 : */
288 : u32 target_vblank;
289 :
290 : /**
291 : * @async_flip:
292 : *
293 : * This is set when DRM_MODE_PAGE_FLIP_ASYNC is set in the legacy
294 : * PAGE_FLIP IOCTL. It's not wired up for the atomic IOCTL itself yet.
295 : */
296 : bool async_flip;
297 :
298 : /**
299 : * @vrr_enabled:
300 : *
301 : * Indicates if variable refresh rate should be enabled for the CRTC.
302 : * Support for the requested vrr state will depend on driver and
303 : * hardware capabiltiy - lacking support is not treated as failure.
304 : */
305 : bool vrr_enabled;
306 :
307 : /**
308 : * @self_refresh_active:
309 : *
310 : * Used by the self refresh helpers to denote when a self refresh
311 : * transition is occurring. This will be set on enable/disable callbacks
312 : * when self refresh is being enabled or disabled. In some cases, it may
313 : * not be desirable to fully shut off the crtc during self refresh.
314 : * CRTC's can inspect this flag and determine the best course of action.
315 : */
316 : bool self_refresh_active;
317 :
318 : /**
319 : * @scaling_filter:
320 : *
321 : * Scaling filter to be applied
322 : */
323 : enum drm_scaling_filter scaling_filter;
324 :
325 : /**
326 : * @event:
327 : *
328 : * Optional pointer to a DRM event to signal upon completion of the
329 : * state update. The driver must send out the event when the atomic
330 : * commit operation completes. There are two cases:
331 : *
332 : * - The event is for a CRTC which is being disabled through this
333 : * atomic commit. In that case the event can be send out any time
334 : * after the hardware has stopped scanning out the current
335 : * framebuffers. It should contain the timestamp and counter for the
336 : * last vblank before the display pipeline was shut off. The simplest
337 : * way to achieve that is calling drm_crtc_send_vblank_event()
338 : * somewhen after drm_crtc_vblank_off() has been called.
339 : *
340 : * - For a CRTC which is enabled at the end of the commit (even when it
341 : * undergoes an full modeset) the vblank timestamp and counter must
342 : * be for the vblank right before the first frame that scans out the
343 : * new set of buffers. Again the event can only be sent out after the
344 : * hardware has stopped scanning out the old buffers.
345 : *
346 : * - Events for disabled CRTCs are not allowed, and drivers can ignore
347 : * that case.
348 : *
349 : * For very simple hardware without VBLANK interrupt, enabling
350 : * &struct drm_crtc_state.no_vblank makes DRM's atomic commit helpers
351 : * send a fake VBLANK event at the end of the display update after all
352 : * hardware changes have been applied. See
353 : * drm_atomic_helper_fake_vblank().
354 : *
355 : * For more complex hardware this
356 : * can be handled by the drm_crtc_send_vblank_event() function,
357 : * which the driver should call on the provided event upon completion of
358 : * the atomic commit. Note that if the driver supports vblank signalling
359 : * and timestamping the vblank counters and timestamps must agree with
360 : * the ones returned from page flip events. With the current vblank
361 : * helper infrastructure this can be achieved by holding a vblank
362 : * reference while the page flip is pending, acquired through
363 : * drm_crtc_vblank_get() and released with drm_crtc_vblank_put().
364 : * Drivers are free to implement their own vblank counter and timestamp
365 : * tracking though, e.g. if they have accurate timestamp registers in
366 : * hardware.
367 : *
368 : * For hardware which supports some means to synchronize vblank
369 : * interrupt delivery with committing display state there's also
370 : * drm_crtc_arm_vblank_event(). See the documentation of that function
371 : * for a detailed discussion of the constraints it needs to be used
372 : * safely.
373 : *
374 : * If the device can't notify of flip completion in a race-free way
375 : * at all, then the event should be armed just after the page flip is
376 : * committed. In the worst case the driver will send the event to
377 : * userspace one frame too late. This doesn't allow for a real atomic
378 : * update, but it should avoid tearing.
379 : */
380 : struct drm_pending_vblank_event *event;
381 :
382 : /**
383 : * @commit:
384 : *
385 : * This tracks how the commit for this update proceeds through the
386 : * various phases. This is never cleared, except when we destroy the
387 : * state, so that subsequent commits can synchronize with previous ones.
388 : */
389 : struct drm_crtc_commit *commit;
390 :
391 : /** @state: backpointer to global drm_atomic_state */
392 : struct drm_atomic_state *state;
393 : };
394 :
395 : /**
396 : * struct drm_crtc_funcs - control CRTCs for a given device
397 : *
398 : * The drm_crtc_funcs structure is the central CRTC management structure
399 : * in the DRM. Each CRTC controls one or more connectors (note that the name
400 : * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
401 : * connectors, not just CRTs).
402 : *
403 : * Each driver is responsible for filling out this structure at startup time,
404 : * in addition to providing other modesetting features, like i2c and DDC
405 : * bus accessors.
406 : */
407 : struct drm_crtc_funcs {
408 : /**
409 : * @reset:
410 : *
411 : * Reset CRTC hardware and software state to off. This function isn't
412 : * called by the core directly, only through drm_mode_config_reset().
413 : * It's not a helper hook only for historical reasons.
414 : *
415 : * Atomic drivers can use drm_atomic_helper_crtc_reset() to reset
416 : * atomic state using this hook.
417 : */
418 : void (*reset)(struct drm_crtc *crtc);
419 :
420 : /**
421 : * @cursor_set:
422 : *
423 : * Update the cursor image. The cursor position is relative to the CRTC
424 : * and can be partially or fully outside of the visible area.
425 : *
426 : * Note that contrary to all other KMS functions the legacy cursor entry
427 : * points don't take a framebuffer object, but instead take directly a
428 : * raw buffer object id from the driver's buffer manager (which is
429 : * either GEM or TTM for current drivers).
430 : *
431 : * This entry point is deprecated, drivers should instead implement
432 : * universal plane support and register a proper cursor plane using
433 : * drm_crtc_init_with_planes().
434 : *
435 : * This callback is optional
436 : *
437 : * RETURNS:
438 : *
439 : * 0 on success or a negative error code on failure.
440 : */
441 : int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
442 : uint32_t handle, uint32_t width, uint32_t height);
443 :
444 : /**
445 : * @cursor_set2:
446 : *
447 : * Update the cursor image, including hotspot information. The hotspot
448 : * must not affect the cursor position in CRTC coordinates, but is only
449 : * meant as a hint for virtualized display hardware to coordinate the
450 : * guests and hosts cursor position. The cursor hotspot is relative to
451 : * the cursor image. Otherwise this works exactly like @cursor_set.
452 : *
453 : * This entry point is deprecated, drivers should instead implement
454 : * universal plane support and register a proper cursor plane using
455 : * drm_crtc_init_with_planes().
456 : *
457 : * This callback is optional.
458 : *
459 : * RETURNS:
460 : *
461 : * 0 on success or a negative error code on failure.
462 : */
463 : int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv,
464 : uint32_t handle, uint32_t width, uint32_t height,
465 : int32_t hot_x, int32_t hot_y);
466 :
467 : /**
468 : * @cursor_move:
469 : *
470 : * Update the cursor position. The cursor does not need to be visible
471 : * when this hook is called.
472 : *
473 : * This entry point is deprecated, drivers should instead implement
474 : * universal plane support and register a proper cursor plane using
475 : * drm_crtc_init_with_planes().
476 : *
477 : * This callback is optional.
478 : *
479 : * RETURNS:
480 : *
481 : * 0 on success or a negative error code on failure.
482 : */
483 : int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
484 :
485 : /**
486 : * @gamma_set:
487 : *
488 : * Set gamma on the CRTC.
489 : *
490 : * This callback is optional.
491 : *
492 : * Atomic drivers who want to support gamma tables should implement the
493 : * atomic color management support, enabled by calling
494 : * drm_crtc_enable_color_mgmt(), which then supports the legacy gamma
495 : * interface through the drm_atomic_helper_legacy_gamma_set()
496 : * compatibility implementation.
497 : */
498 : int (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
499 : uint32_t size,
500 : struct drm_modeset_acquire_ctx *ctx);
501 :
502 : /**
503 : * @destroy:
504 : *
505 : * Clean up CRTC resources. This is only called at driver unload time
506 : * through drm_mode_config_cleanup() since a CRTC cannot be hotplugged
507 : * in DRM.
508 : */
509 : void (*destroy)(struct drm_crtc *crtc);
510 :
511 : /**
512 : * @set_config:
513 : *
514 : * This is the main legacy entry point to change the modeset state on a
515 : * CRTC. All the details of the desired configuration are passed in a
516 : * &struct drm_mode_set - see there for details.
517 : *
518 : * Drivers implementing atomic modeset should use
519 : * drm_atomic_helper_set_config() to implement this hook.
520 : *
521 : * RETURNS:
522 : *
523 : * 0 on success or a negative error code on failure.
524 : */
525 : int (*set_config)(struct drm_mode_set *set,
526 : struct drm_modeset_acquire_ctx *ctx);
527 :
528 : /**
529 : * @page_flip:
530 : *
531 : * Legacy entry point to schedule a flip to the given framebuffer.
532 : *
533 : * Page flipping is a synchronization mechanism that replaces the frame
534 : * buffer being scanned out by the CRTC with a new frame buffer during
535 : * vertical blanking, avoiding tearing (except when requested otherwise
536 : * through the DRM_MODE_PAGE_FLIP_ASYNC flag). When an application
537 : * requests a page flip the DRM core verifies that the new frame buffer
538 : * is large enough to be scanned out by the CRTC in the currently
539 : * configured mode and then calls this hook with a pointer to the new
540 : * frame buffer.
541 : *
542 : * The driver must wait for any pending rendering to the new framebuffer
543 : * to complete before executing the flip. It should also wait for any
544 : * pending rendering from other drivers if the underlying buffer is a
545 : * shared dma-buf.
546 : *
547 : * An application can request to be notified when the page flip has
548 : * completed. The drm core will supply a &struct drm_event in the event
549 : * parameter in this case. This can be handled by the
550 : * drm_crtc_send_vblank_event() function, which the driver should call on
551 : * the provided event upon completion of the flip. Note that if
552 : * the driver supports vblank signalling and timestamping the vblank
553 : * counters and timestamps must agree with the ones returned from page
554 : * flip events. With the current vblank helper infrastructure this can
555 : * be achieved by holding a vblank reference while the page flip is
556 : * pending, acquired through drm_crtc_vblank_get() and released with
557 : * drm_crtc_vblank_put(). Drivers are free to implement their own vblank
558 : * counter and timestamp tracking though, e.g. if they have accurate
559 : * timestamp registers in hardware.
560 : *
561 : * This callback is optional.
562 : *
563 : * NOTE:
564 : *
565 : * Very early versions of the KMS ABI mandated that the driver must
566 : * block (but not reject) any rendering to the old framebuffer until the
567 : * flip operation has completed and the old framebuffer is no longer
568 : * visible. This requirement has been lifted, and userspace is instead
569 : * expected to request delivery of an event and wait with recycling old
570 : * buffers until such has been received.
571 : *
572 : * RETURNS:
573 : *
574 : * 0 on success or a negative error code on failure. Note that if a
575 : * page flip operation is already pending the callback should return
576 : * -EBUSY. Pageflips on a disabled CRTC (either by setting a NULL mode
577 : * or just runtime disabled through DPMS respectively the new atomic
578 : * "ACTIVE" state) should result in an -EINVAL error code. Note that
579 : * drm_atomic_helper_page_flip() checks this already for atomic drivers.
580 : */
581 : int (*page_flip)(struct drm_crtc *crtc,
582 : struct drm_framebuffer *fb,
583 : struct drm_pending_vblank_event *event,
584 : uint32_t flags,
585 : struct drm_modeset_acquire_ctx *ctx);
586 :
587 : /**
588 : * @page_flip_target:
589 : *
590 : * Same as @page_flip but with an additional parameter specifying the
591 : * absolute target vertical blank period (as reported by
592 : * drm_crtc_vblank_count()) when the flip should take effect.
593 : *
594 : * Note that the core code calls drm_crtc_vblank_get before this entry
595 : * point, and will call drm_crtc_vblank_put if this entry point returns
596 : * any non-0 error code. It's the driver's responsibility to call
597 : * drm_crtc_vblank_put after this entry point returns 0, typically when
598 : * the flip completes.
599 : */
600 : int (*page_flip_target)(struct drm_crtc *crtc,
601 : struct drm_framebuffer *fb,
602 : struct drm_pending_vblank_event *event,
603 : uint32_t flags, uint32_t target,
604 : struct drm_modeset_acquire_ctx *ctx);
605 :
606 : /**
607 : * @set_property:
608 : *
609 : * This is the legacy entry point to update a property attached to the
610 : * CRTC.
611 : *
612 : * This callback is optional if the driver does not support any legacy
613 : * driver-private properties. For atomic drivers it is not used because
614 : * property handling is done entirely in the DRM core.
615 : *
616 : * RETURNS:
617 : *
618 : * 0 on success or a negative error code on failure.
619 : */
620 : int (*set_property)(struct drm_crtc *crtc,
621 : struct drm_property *property, uint64_t val);
622 :
623 : /**
624 : * @atomic_duplicate_state:
625 : *
626 : * Duplicate the current atomic state for this CRTC and return it.
627 : * The core and helpers guarantee that any atomic state duplicated with
628 : * this hook and still owned by the caller (i.e. not transferred to the
629 : * driver by calling &drm_mode_config_funcs.atomic_commit) will be
630 : * cleaned up by calling the @atomic_destroy_state hook in this
631 : * structure.
632 : *
633 : * This callback is mandatory for atomic drivers.
634 : *
635 : * Atomic drivers which don't subclass &struct drm_crtc_state should use
636 : * drm_atomic_helper_crtc_duplicate_state(). Drivers that subclass the
637 : * state structure to extend it with driver-private state should use
638 : * __drm_atomic_helper_crtc_duplicate_state() to make sure shared state is
639 : * duplicated in a consistent fashion across drivers.
640 : *
641 : * It is an error to call this hook before &drm_crtc.state has been
642 : * initialized correctly.
643 : *
644 : * NOTE:
645 : *
646 : * If the duplicate state references refcounted resources this hook must
647 : * acquire a reference for each of them. The driver must release these
648 : * references again in @atomic_destroy_state.
649 : *
650 : * RETURNS:
651 : *
652 : * Duplicated atomic state or NULL when the allocation failed.
653 : */
654 : struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
655 :
656 : /**
657 : * @atomic_destroy_state:
658 : *
659 : * Destroy a state duplicated with @atomic_duplicate_state and release
660 : * or unreference all resources it references
661 : *
662 : * This callback is mandatory for atomic drivers.
663 : */
664 : void (*atomic_destroy_state)(struct drm_crtc *crtc,
665 : struct drm_crtc_state *state);
666 :
667 : /**
668 : * @atomic_set_property:
669 : *
670 : * Decode a driver-private property value and store the decoded value
671 : * into the passed-in state structure. Since the atomic core decodes all
672 : * standardized properties (even for extensions beyond the core set of
673 : * properties which might not be implemented by all drivers) this
674 : * requires drivers to subclass the state structure.
675 : *
676 : * Such driver-private properties should really only be implemented for
677 : * truly hardware/vendor specific state. Instead it is preferred to
678 : * standardize atomic extension and decode the properties used to expose
679 : * such an extension in the core.
680 : *
681 : * Do not call this function directly, use
682 : * drm_atomic_crtc_set_property() instead.
683 : *
684 : * This callback is optional if the driver does not support any
685 : * driver-private atomic properties.
686 : *
687 : * NOTE:
688 : *
689 : * This function is called in the state assembly phase of atomic
690 : * modesets, which can be aborted for any reason (including on
691 : * userspace's request to just check whether a configuration would be
692 : * possible). Drivers MUST NOT touch any persistent state (hardware or
693 : * software) or data structures except the passed in @state parameter.
694 : *
695 : * Also since userspace controls in which order properties are set this
696 : * function must not do any input validation (since the state update is
697 : * incomplete and hence likely inconsistent). Instead any such input
698 : * validation must be done in the various atomic_check callbacks.
699 : *
700 : * RETURNS:
701 : *
702 : * 0 if the property has been found, -EINVAL if the property isn't
703 : * implemented by the driver (which should never happen, the core only
704 : * asks for properties attached to this CRTC). No other validation is
705 : * allowed by the driver. The core already checks that the property
706 : * value is within the range (integer, valid enum value, ...) the driver
707 : * set when registering the property.
708 : */
709 : int (*atomic_set_property)(struct drm_crtc *crtc,
710 : struct drm_crtc_state *state,
711 : struct drm_property *property,
712 : uint64_t val);
713 : /**
714 : * @atomic_get_property:
715 : *
716 : * Reads out the decoded driver-private property. This is used to
717 : * implement the GETCRTC IOCTL.
718 : *
719 : * Do not call this function directly, use
720 : * drm_atomic_crtc_get_property() instead.
721 : *
722 : * This callback is optional if the driver does not support any
723 : * driver-private atomic properties.
724 : *
725 : * RETURNS:
726 : *
727 : * 0 on success, -EINVAL if the property isn't implemented by the
728 : * driver (which should never happen, the core only asks for
729 : * properties attached to this CRTC).
730 : */
731 : int (*atomic_get_property)(struct drm_crtc *crtc,
732 : const struct drm_crtc_state *state,
733 : struct drm_property *property,
734 : uint64_t *val);
735 :
736 : /**
737 : * @late_register:
738 : *
739 : * This optional hook can be used to register additional userspace
740 : * interfaces attached to the crtc like debugfs interfaces.
741 : * It is called late in the driver load sequence from drm_dev_register().
742 : * Everything added from this callback should be unregistered in
743 : * the early_unregister callback.
744 : *
745 : * Returns:
746 : *
747 : * 0 on success, or a negative error code on failure.
748 : */
749 : int (*late_register)(struct drm_crtc *crtc);
750 :
751 : /**
752 : * @early_unregister:
753 : *
754 : * This optional hook should be used to unregister the additional
755 : * userspace interfaces attached to the crtc from
756 : * @late_register. It is called from drm_dev_unregister(),
757 : * early in the driver unload sequence to disable userspace access
758 : * before data structures are torndown.
759 : */
760 : void (*early_unregister)(struct drm_crtc *crtc);
761 :
762 : /**
763 : * @set_crc_source:
764 : *
765 : * Changes the source of CRC checksums of frames at the request of
766 : * userspace, typically for testing purposes. The sources available are
767 : * specific of each driver and a %NULL value indicates that CRC
768 : * generation is to be switched off.
769 : *
770 : * When CRC generation is enabled, the driver should call
771 : * drm_crtc_add_crc_entry() at each frame, providing any information
772 : * that characterizes the frame contents in the crcN arguments, as
773 : * provided from the configured source. Drivers must accept an "auto"
774 : * source name that will select a default source for this CRTC.
775 : *
776 : * This may trigger an atomic modeset commit if necessary, to enable CRC
777 : * generation.
778 : *
779 : * Note that "auto" can depend upon the current modeset configuration,
780 : * e.g. it could pick an encoder or output specific CRC sampling point.
781 : *
782 : * This callback is optional if the driver does not support any CRC
783 : * generation functionality.
784 : *
785 : * RETURNS:
786 : *
787 : * 0 on success or a negative error code on failure.
788 : */
789 : int (*set_crc_source)(struct drm_crtc *crtc, const char *source);
790 :
791 : /**
792 : * @verify_crc_source:
793 : *
794 : * verifies the source of CRC checksums of frames before setting the
795 : * source for CRC and during crc open. Source parameter can be NULL
796 : * while disabling crc source.
797 : *
798 : * This callback is optional if the driver does not support any CRC
799 : * generation functionality.
800 : *
801 : * RETURNS:
802 : *
803 : * 0 on success or a negative error code on failure.
804 : */
805 : int (*verify_crc_source)(struct drm_crtc *crtc, const char *source,
806 : size_t *values_cnt);
807 : /**
808 : * @get_crc_sources:
809 : *
810 : * Driver callback for getting a list of all the available sources for
811 : * CRC generation. This callback depends upon verify_crc_source, So
812 : * verify_crc_source callback should be implemented before implementing
813 : * this. Driver can pass full list of available crc sources, this
814 : * callback does the verification on each crc-source before passing it
815 : * to userspace.
816 : *
817 : * This callback is optional if the driver does not support exporting of
818 : * possible CRC sources list.
819 : *
820 : * RETURNS:
821 : *
822 : * a constant character pointer to the list of all the available CRC
823 : * sources. On failure driver should return NULL. count should be
824 : * updated with number of sources in list. if zero we don't process any
825 : * source from the list.
826 : */
827 : const char *const *(*get_crc_sources)(struct drm_crtc *crtc,
828 : size_t *count);
829 :
830 : /**
831 : * @atomic_print_state:
832 : *
833 : * If driver subclasses &struct drm_crtc_state, it should implement
834 : * this optional hook for printing additional driver specific state.
835 : *
836 : * Do not call this directly, use drm_atomic_crtc_print_state()
837 : * instead.
838 : */
839 : void (*atomic_print_state)(struct drm_printer *p,
840 : const struct drm_crtc_state *state);
841 :
842 : /**
843 : * @get_vblank_counter:
844 : *
845 : * Driver callback for fetching a raw hardware vblank counter for the
846 : * CRTC. It's meant to be used by new drivers as the replacement of
847 : * &drm_driver.get_vblank_counter hook.
848 : *
849 : * This callback is optional. If a device doesn't have a hardware
850 : * counter, the driver can simply leave the hook as NULL. The DRM core
851 : * will account for missed vblank events while interrupts where disabled
852 : * based on system timestamps.
853 : *
854 : * Wraparound handling and loss of events due to modesetting is dealt
855 : * with in the DRM core code, as long as drivers call
856 : * drm_crtc_vblank_off() and drm_crtc_vblank_on() when disabling or
857 : * enabling a CRTC.
858 : *
859 : * See also &drm_device.vblank_disable_immediate and
860 : * &drm_device.max_vblank_count.
861 : *
862 : * Returns:
863 : *
864 : * Raw vblank counter value.
865 : */
866 : u32 (*get_vblank_counter)(struct drm_crtc *crtc);
867 :
868 : /**
869 : * @enable_vblank:
870 : *
871 : * Enable vblank interrupts for the CRTC. It's meant to be used by
872 : * new drivers as the replacement of &drm_driver.enable_vblank hook.
873 : *
874 : * Returns:
875 : *
876 : * Zero on success, appropriate errno if the vblank interrupt cannot
877 : * be enabled.
878 : */
879 : int (*enable_vblank)(struct drm_crtc *crtc);
880 :
881 : /**
882 : * @disable_vblank:
883 : *
884 : * Disable vblank interrupts for the CRTC. It's meant to be used by
885 : * new drivers as the replacement of &drm_driver.disable_vblank hook.
886 : */
887 : void (*disable_vblank)(struct drm_crtc *crtc);
888 :
889 : /**
890 : * @get_vblank_timestamp:
891 : *
892 : * Called by drm_get_last_vbltimestamp(). Should return a precise
893 : * timestamp when the most recent vblank interval ended or will end.
894 : *
895 : * Specifically, the timestamp in @vblank_time should correspond as
896 : * closely as possible to the time when the first video scanline of
897 : * the video frame after the end of vblank will start scanning out,
898 : * the time immediately after end of the vblank interval. If the
899 : * @crtc is currently inside vblank, this will be a time in the future.
900 : * If the @crtc is currently scanning out a frame, this will be the
901 : * past start time of the current scanout. This is meant to adhere
902 : * to the OpenML OML_sync_control extension specification.
903 : *
904 : * Parameters:
905 : *
906 : * crtc:
907 : * CRTC for which timestamp should be returned.
908 : * max_error:
909 : * Maximum allowable timestamp error in nanoseconds.
910 : * Implementation should strive to provide timestamp
911 : * with an error of at most max_error nanoseconds.
912 : * Returns true upper bound on error for timestamp.
913 : * vblank_time:
914 : * Target location for returned vblank timestamp.
915 : * in_vblank_irq:
916 : * True when called from drm_crtc_handle_vblank(). Some drivers
917 : * need to apply some workarounds for gpu-specific vblank irq quirks
918 : * if flag is set.
919 : *
920 : * Returns:
921 : *
922 : * True on success, false on failure, which means the core should
923 : * fallback to a simple timestamp taken in drm_crtc_handle_vblank().
924 : */
925 : bool (*get_vblank_timestamp)(struct drm_crtc *crtc,
926 : int *max_error,
927 : ktime_t *vblank_time,
928 : bool in_vblank_irq);
929 : };
930 :
931 : /**
932 : * struct drm_crtc - central CRTC control structure
933 : *
934 : * Each CRTC may have one or more connectors associated with it. This structure
935 : * allows the CRTC to be controlled.
936 : */
937 : struct drm_crtc {
938 : /** @dev: parent DRM device */
939 : struct drm_device *dev;
940 : /** @port: OF node used by drm_of_find_possible_crtcs(). */
941 : struct device_node *port;
942 : /**
943 : * @head:
944 : *
945 : * List of all CRTCs on @dev, linked from &drm_mode_config.crtc_list.
946 : * Invariant over the lifetime of @dev and therefore does not need
947 : * locking.
948 : */
949 : struct list_head head;
950 :
951 : /** @name: human readable name, can be overwritten by the driver */
952 : char *name;
953 :
954 : /**
955 : * @mutex:
956 : *
957 : * This provides a read lock for the overall CRTC state (mode, dpms
958 : * state, ...) and a write lock for everything which can be update
959 : * without a full modeset (fb, cursor data, CRTC properties ...). A full
960 : * modeset also need to grab &drm_mode_config.connection_mutex.
961 : *
962 : * For atomic drivers specifically this protects @state.
963 : */
964 : struct drm_modeset_lock mutex;
965 :
966 : /** @base: base KMS object for ID tracking etc. */
967 : struct drm_mode_object base;
968 :
969 : /**
970 : * @primary:
971 : * Primary plane for this CRTC. Note that this is only
972 : * relevant for legacy IOCTL, it specifies the plane implicitly used by
973 : * the SETCRTC and PAGE_FLIP IOCTLs. It does not have any significance
974 : * beyond that.
975 : */
976 : struct drm_plane *primary;
977 :
978 : /**
979 : * @cursor:
980 : * Cursor plane for this CRTC. Note that this is only relevant for
981 : * legacy IOCTL, it specifies the plane implicitly used by the SETCURSOR
982 : * and SETCURSOR2 IOCTLs. It does not have any significance
983 : * beyond that.
984 : */
985 : struct drm_plane *cursor;
986 :
987 : /**
988 : * @index: Position inside the mode_config.list, can be used as an array
989 : * index. It is invariant over the lifetime of the CRTC.
990 : */
991 : unsigned index;
992 :
993 : /**
994 : * @cursor_x: Current x position of the cursor, used for universal
995 : * cursor planes because the SETCURSOR IOCTL only can update the
996 : * framebuffer without supplying the coordinates. Drivers should not use
997 : * this directly, atomic drivers should look at &drm_plane_state.crtc_x
998 : * of the cursor plane instead.
999 : */
1000 : int cursor_x;
1001 : /**
1002 : * @cursor_y: Current y position of the cursor, used for universal
1003 : * cursor planes because the SETCURSOR IOCTL only can update the
1004 : * framebuffer without supplying the coordinates. Drivers should not use
1005 : * this directly, atomic drivers should look at &drm_plane_state.crtc_y
1006 : * of the cursor plane instead.
1007 : */
1008 : int cursor_y;
1009 :
1010 : /**
1011 : * @enabled:
1012 : *
1013 : * Is this CRTC enabled? Should only be used by legacy drivers, atomic
1014 : * drivers should instead consult &drm_crtc_state.enable and
1015 : * &drm_crtc_state.active. Atomic drivers can update this by calling
1016 : * drm_atomic_helper_update_legacy_modeset_state().
1017 : */
1018 : bool enabled;
1019 :
1020 : /**
1021 : * @mode:
1022 : *
1023 : * Current mode timings. Should only be used by legacy drivers, atomic
1024 : * drivers should instead consult &drm_crtc_state.mode. Atomic drivers
1025 : * can update this by calling
1026 : * drm_atomic_helper_update_legacy_modeset_state().
1027 : */
1028 : struct drm_display_mode mode;
1029 :
1030 : /**
1031 : * @hwmode:
1032 : *
1033 : * Programmed mode in hw, after adjustments for encoders, crtc, panel
1034 : * scaling etc. Should only be used by legacy drivers, for high
1035 : * precision vblank timestamps in
1036 : * drm_crtc_vblank_helper_get_vblank_timestamp().
1037 : *
1038 : * Note that atomic drivers should not use this, but instead use
1039 : * &drm_crtc_state.adjusted_mode. And for high-precision timestamps
1040 : * drm_crtc_vblank_helper_get_vblank_timestamp() used
1041 : * &drm_vblank_crtc.hwmode,
1042 : * which is filled out by calling drm_calc_timestamping_constants().
1043 : */
1044 : struct drm_display_mode hwmode;
1045 :
1046 : /**
1047 : * @x:
1048 : * x position on screen. Should only be used by legacy drivers, atomic
1049 : * drivers should look at &drm_plane_state.crtc_x of the primary plane
1050 : * instead. Updated by calling
1051 : * drm_atomic_helper_update_legacy_modeset_state().
1052 : */
1053 : int x;
1054 : /**
1055 : * @y:
1056 : * y position on screen. Should only be used by legacy drivers, atomic
1057 : * drivers should look at &drm_plane_state.crtc_y of the primary plane
1058 : * instead. Updated by calling
1059 : * drm_atomic_helper_update_legacy_modeset_state().
1060 : */
1061 : int y;
1062 :
1063 : /** @funcs: CRTC control functions */
1064 : const struct drm_crtc_funcs *funcs;
1065 :
1066 : /**
1067 : * @gamma_size: Size of legacy gamma ramp reported to userspace. Set up
1068 : * by calling drm_mode_crtc_set_gamma_size().
1069 : *
1070 : * Note that atomic drivers need to instead use
1071 : * &drm_crtc_state.gamma_lut. See drm_crtc_enable_color_mgmt().
1072 : */
1073 : uint32_t gamma_size;
1074 :
1075 : /**
1076 : * @gamma_store: Gamma ramp values used by the legacy SETGAMMA and
1077 : * GETGAMMA IOCTls. Set up by calling drm_mode_crtc_set_gamma_size().
1078 : *
1079 : * Note that atomic drivers need to instead use
1080 : * &drm_crtc_state.gamma_lut. See drm_crtc_enable_color_mgmt().
1081 : */
1082 : uint16_t *gamma_store;
1083 :
1084 : /** @helper_private: mid-layer private data */
1085 : const struct drm_crtc_helper_funcs *helper_private;
1086 :
1087 : /** @properties: property tracking for this CRTC */
1088 : struct drm_object_properties properties;
1089 :
1090 : /**
1091 : * @scaling_filter_property: property to apply a particular filter while
1092 : * scaling.
1093 : */
1094 : struct drm_property *scaling_filter_property;
1095 :
1096 : /**
1097 : * @state:
1098 : *
1099 : * Current atomic state for this CRTC.
1100 : *
1101 : * This is protected by @mutex. Note that nonblocking atomic commits
1102 : * access the current CRTC state without taking locks. Either by going
1103 : * through the &struct drm_atomic_state pointers, see
1104 : * for_each_oldnew_crtc_in_state(), for_each_old_crtc_in_state() and
1105 : * for_each_new_crtc_in_state(). Or through careful ordering of atomic
1106 : * commit operations as implemented in the atomic helpers, see
1107 : * &struct drm_crtc_commit.
1108 : */
1109 : struct drm_crtc_state *state;
1110 :
1111 : /**
1112 : * @commit_list:
1113 : *
1114 : * List of &drm_crtc_commit structures tracking pending commits.
1115 : * Protected by @commit_lock. This list holds its own full reference,
1116 : * as does the ongoing commit.
1117 : *
1118 : * "Note that the commit for a state change is also tracked in
1119 : * &drm_crtc_state.commit. For accessing the immediately preceding
1120 : * commit in an atomic update it is recommended to just use that
1121 : * pointer in the old CRTC state, since accessing that doesn't need
1122 : * any locking or list-walking. @commit_list should only be used to
1123 : * stall for framebuffer cleanup that's signalled through
1124 : * &drm_crtc_commit.cleanup_done."
1125 : */
1126 : struct list_head commit_list;
1127 :
1128 : /**
1129 : * @commit_lock:
1130 : *
1131 : * Spinlock to protect @commit_list.
1132 : */
1133 : spinlock_t commit_lock;
1134 :
1135 : /**
1136 : * @debugfs_entry:
1137 : *
1138 : * Debugfs directory for this CRTC.
1139 : */
1140 : struct dentry *debugfs_entry;
1141 :
1142 : /**
1143 : * @crc:
1144 : *
1145 : * Configuration settings of CRC capture.
1146 : */
1147 : struct drm_crtc_crc crc;
1148 :
1149 : /**
1150 : * @fence_context:
1151 : *
1152 : * timeline context used for fence operations.
1153 : */
1154 : unsigned int fence_context;
1155 :
1156 : /**
1157 : * @fence_lock:
1158 : *
1159 : * spinlock to protect the fences in the fence_context.
1160 : */
1161 : spinlock_t fence_lock;
1162 : /**
1163 : * @fence_seqno:
1164 : *
1165 : * Seqno variable used as monotonic counter for the fences
1166 : * created on the CRTC's timeline.
1167 : */
1168 : unsigned long fence_seqno;
1169 :
1170 : /**
1171 : * @timeline_name:
1172 : *
1173 : * The name of the CRTC's fence timeline.
1174 : */
1175 : char timeline_name[32];
1176 :
1177 : /**
1178 : * @self_refresh_data: Holds the state for the self refresh helpers
1179 : *
1180 : * Initialized via drm_self_refresh_helper_init().
1181 : */
1182 : struct drm_self_refresh_data *self_refresh_data;
1183 : };
1184 :
1185 : /**
1186 : * struct drm_mode_set - new values for a CRTC config change
1187 : * @fb: framebuffer to use for new config
1188 : * @crtc: CRTC whose configuration we're about to change
1189 : * @mode: mode timings to use
1190 : * @x: position of this CRTC relative to @fb
1191 : * @y: position of this CRTC relative to @fb
1192 : * @connectors: array of connectors to drive with this CRTC if possible
1193 : * @num_connectors: size of @connectors array
1194 : *
1195 : * This represents a modeset configuration for the legacy SETCRTC ioctl and is
1196 : * also used internally. Atomic drivers instead use &drm_atomic_state.
1197 : */
1198 : struct drm_mode_set {
1199 : struct drm_framebuffer *fb;
1200 : struct drm_crtc *crtc;
1201 : struct drm_display_mode *mode;
1202 :
1203 : uint32_t x;
1204 : uint32_t y;
1205 :
1206 : struct drm_connector **connectors;
1207 : size_t num_connectors;
1208 : };
1209 :
1210 : #define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
1211 :
1212 : __printf(6, 7)
1213 : int drm_crtc_init_with_planes(struct drm_device *dev,
1214 : struct drm_crtc *crtc,
1215 : struct drm_plane *primary,
1216 : struct drm_plane *cursor,
1217 : const struct drm_crtc_funcs *funcs,
1218 : const char *name, ...);
1219 :
1220 : __printf(6, 7)
1221 : int drmm_crtc_init_with_planes(struct drm_device *dev,
1222 : struct drm_crtc *crtc,
1223 : struct drm_plane *primary,
1224 : struct drm_plane *cursor,
1225 : const struct drm_crtc_funcs *funcs,
1226 : const char *name, ...);
1227 :
1228 : void drm_crtc_cleanup(struct drm_crtc *crtc);
1229 :
1230 : __printf(7, 8)
1231 : void *__drmm_crtc_alloc_with_planes(struct drm_device *dev,
1232 : size_t size, size_t offset,
1233 : struct drm_plane *primary,
1234 : struct drm_plane *cursor,
1235 : const struct drm_crtc_funcs *funcs,
1236 : const char *name, ...);
1237 :
1238 : /**
1239 : * drmm_crtc_alloc_with_planes - Allocate and initialize a new CRTC object with
1240 : * specified primary and cursor planes.
1241 : * @dev: DRM device
1242 : * @type: the type of the struct which contains struct &drm_crtc
1243 : * @member: the name of the &drm_crtc within @type.
1244 : * @primary: Primary plane for CRTC
1245 : * @cursor: Cursor plane for CRTC
1246 : * @funcs: callbacks for the new CRTC
1247 : * @name: printf style format string for the CRTC name, or NULL for default name
1248 : *
1249 : * Allocates and initializes a new crtc object. Cleanup is automatically
1250 : * handled through registering drmm_crtc_cleanup() with drmm_add_action().
1251 : *
1252 : * The @drm_crtc_funcs.destroy hook must be NULL.
1253 : *
1254 : * Returns:
1255 : * Pointer to new crtc, or ERR_PTR on failure.
1256 : */
1257 : #define drmm_crtc_alloc_with_planes(dev, type, member, primary, cursor, funcs, name, ...) \
1258 : ((type *)__drmm_crtc_alloc_with_planes(dev, sizeof(type), \
1259 : offsetof(type, member), \
1260 : primary, cursor, funcs, \
1261 : name, ##__VA_ARGS__))
1262 :
1263 : /**
1264 : * drm_crtc_index - find the index of a registered CRTC
1265 : * @crtc: CRTC to find index for
1266 : *
1267 : * Given a registered CRTC, return the index of that CRTC within a DRM
1268 : * device's list of CRTCs.
1269 : */
1270 : static inline unsigned int drm_crtc_index(const struct drm_crtc *crtc)
1271 : {
1272 : return crtc->index;
1273 : }
1274 :
1275 : /**
1276 : * drm_crtc_mask - find the mask of a registered CRTC
1277 : * @crtc: CRTC to find mask for
1278 : *
1279 : * Given a registered CRTC, return the mask bit of that CRTC for the
1280 : * &drm_encoder.possible_crtcs and &drm_plane.possible_crtcs fields.
1281 : */
1282 : static inline uint32_t drm_crtc_mask(const struct drm_crtc *crtc)
1283 : {
1284 0 : return 1 << drm_crtc_index(crtc);
1285 : }
1286 :
1287 : int drm_mode_set_config_internal(struct drm_mode_set *set);
1288 : struct drm_crtc *drm_crtc_from_index(struct drm_device *dev, int idx);
1289 :
1290 : /**
1291 : * drm_crtc_find - look up a CRTC object from its ID
1292 : * @dev: DRM device
1293 : * @file_priv: drm file to check for lease against.
1294 : * @id: &drm_mode_object ID
1295 : *
1296 : * This can be used to look up a CRTC from its userspace ID. Only used by
1297 : * drivers for legacy IOCTLs and interface, nowadays extensions to the KMS
1298 : * userspace interface should be done using &drm_property.
1299 : */
1300 : static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
1301 : struct drm_file *file_priv,
1302 : uint32_t id)
1303 : {
1304 : struct drm_mode_object *mo;
1305 0 : mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_CRTC);
1306 0 : return mo ? obj_to_crtc(mo) : NULL;
1307 : }
1308 :
1309 : /**
1310 : * drm_for_each_crtc - iterate over all CRTCs
1311 : * @crtc: a &struct drm_crtc as the loop cursor
1312 : * @dev: the &struct drm_device
1313 : *
1314 : * Iterate over all CRTCs of @dev.
1315 : */
1316 : #define drm_for_each_crtc(crtc, dev) \
1317 : list_for_each_entry(crtc, &(dev)->mode_config.crtc_list, head)
1318 :
1319 : /**
1320 : * drm_for_each_crtc_reverse - iterate over all CRTCs in reverse order
1321 : * @crtc: a &struct drm_crtc as the loop cursor
1322 : * @dev: the &struct drm_device
1323 : *
1324 : * Iterate over all CRTCs of @dev.
1325 : */
1326 : #define drm_for_each_crtc_reverse(crtc, dev) \
1327 : list_for_each_entry_reverse(crtc, &(dev)->mode_config.crtc_list, head)
1328 :
1329 : int drm_crtc_create_scaling_filter_property(struct drm_crtc *crtc,
1330 : unsigned int supported_filters);
1331 :
1332 : #endif /* __DRM_CRTC_H__ */
|
