~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/drm/drm_crtc.h

Version: ~ [ linux-6.1-rc7 ] ~ [ linux-6.0.10 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.80 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.156 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.225 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.267 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.300 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.334 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp