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