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