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