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