Subversion Repositories Kolibri OS

Rev

Rev 5270 | Rev 6936 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  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/idr.h>
  32. #include <linux/fb.h>
  33. #include <linux/hdmi.h>
  34. #include <linux/media-bus-format.h>
  35. #include <uapi/drm/drm_mode.h>
  36. #include <uapi/drm/drm_fourcc.h>
  37. #include <drm/drm_modeset_lock.h>
  38.  
  39. struct drm_device;
  40. struct drm_mode_set;
  41. struct drm_framebuffer;
  42. struct drm_object_properties;
  43. struct drm_file;
  44. struct drm_clip_rect;
  45. struct device_node;
  46. struct fence;
  47.  
  48. #define DRM_MODE_OBJECT_CRTC 0xcccccccc
  49. #define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
  50. #define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
  51. #define DRM_MODE_OBJECT_MODE 0xdededede
  52. #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
  53. #define DRM_MODE_OBJECT_FB 0xfbfbfbfb
  54. #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
  55. #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
  56. #define DRM_MODE_OBJECT_ANY 0
  57.  
  58. struct drm_mode_object {
  59.         uint32_t id;
  60.         uint32_t type;
  61.         struct drm_object_properties *properties;
  62. };
  63.  
  64. #define DRM_OBJECT_MAX_PROPERTY 24
  65. struct drm_object_properties {
  66.         int count, atomic_count;
  67.         /* NOTE: if we ever start dynamically destroying properties (ie.
  68.          * not at drm_mode_config_cleanup() time), then we'd have to do
  69.          * a better job of detaching property from mode objects to avoid
  70.          * dangling property pointers:
  71.          */
  72.         struct drm_property *properties[DRM_OBJECT_MAX_PROPERTY];
  73.         /* do not read/write values directly, but use drm_object_property_get_value()
  74.          * and drm_object_property_set_value():
  75.          */
  76.         uint64_t values[DRM_OBJECT_MAX_PROPERTY];
  77. };
  78.  
  79. static inline int64_t U642I64(uint64_t val)
  80. {
  81.         return (int64_t)*((int64_t *)&val);
  82. }
  83. static inline uint64_t I642U64(int64_t val)
  84. {
  85.         return (uint64_t)*((uint64_t *)&val);
  86. }
  87.  
  88. /* rotation property bits */
  89. #define DRM_ROTATE_MASK 0x0f
  90. #define DRM_ROTATE_0    0
  91. #define DRM_ROTATE_90   1
  92. #define DRM_ROTATE_180  2
  93. #define DRM_ROTATE_270  3
  94. #define DRM_REFLECT_MASK (~DRM_ROTATE_MASK)
  95. #define DRM_REFLECT_X   4
  96. #define DRM_REFLECT_Y   5
  97.  
  98. enum drm_connector_force {
  99.         DRM_FORCE_UNSPECIFIED,
  100.         DRM_FORCE_OFF,
  101.         DRM_FORCE_ON,         /* force on analog part normally */
  102.         DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
  103. };
  104.  
  105. #include <drm/drm_modes.h>
  106.  
  107. enum drm_connector_status {
  108.         connector_status_connected = 1,
  109.         connector_status_disconnected = 2,
  110.         connector_status_unknown = 3,
  111. };
  112.  
  113. enum subpixel_order {
  114.         SubPixelUnknown = 0,
  115.         SubPixelHorizontalRGB,
  116.         SubPixelHorizontalBGR,
  117.         SubPixelVerticalRGB,
  118.         SubPixelVerticalBGR,
  119.         SubPixelNone,
  120. };
  121.  
  122. #define DRM_COLOR_FORMAT_RGB444         (1<<0)
  123. #define DRM_COLOR_FORMAT_YCRCB444       (1<<1)
  124. #define DRM_COLOR_FORMAT_YCRCB422       (1<<2)
  125. /*
  126.  * Describes a given display (e.g. CRT or flat panel) and its limitations.
  127.  */
  128. struct drm_display_info {
  129.         char name[DRM_DISPLAY_INFO_LEN];
  130.  
  131.         /* Physical size */
  132.         unsigned int width_mm;
  133.         unsigned int height_mm;
  134.  
  135.         /* Clock limits FIXME: storage format */
  136.         unsigned int min_vfreq, max_vfreq;
  137.         unsigned int min_hfreq, max_hfreq;
  138.         unsigned int pixel_clock;
  139.         unsigned int bpc;
  140.  
  141.         enum subpixel_order subpixel_order;
  142.         u32 color_formats;
  143.  
  144.         const u32 *bus_formats;
  145.         unsigned int num_bus_formats;
  146.  
  147.         /* Mask of supported hdmi deep color modes */
  148.         u8 edid_hdmi_dc_modes;
  149.  
  150.         u8 cea_rev;
  151. };
  152.  
  153. /* data corresponds to displayid vend/prod/serial */
  154. struct drm_tile_group {
  155.         struct kref refcount;
  156.         struct drm_device *dev;
  157.         int id;
  158.         u8 group_data[8];
  159. };
  160.  
  161. struct drm_framebuffer_funcs {
  162.         /* note: use drm_framebuffer_remove() */
  163.         void (*destroy)(struct drm_framebuffer *framebuffer);
  164.         int (*create_handle)(struct drm_framebuffer *fb,
  165.                              struct drm_file *file_priv,
  166.                              unsigned int *handle);
  167.         /*
  168.          * Optional callback for the dirty fb ioctl.
  169.          *
  170.          * Userspace can notify the driver via this callback
  171.          * that a area of the framebuffer has changed and should
  172.          * be flushed to the display hardware.
  173.          *
  174.          * See documentation in drm_mode.h for the struct
  175.          * drm_mode_fb_dirty_cmd for more information as all
  176.          * the semantics and arguments have a one to one mapping
  177.          * on this function.
  178.          */
  179.         int (*dirty)(struct drm_framebuffer *framebuffer,
  180.                      struct drm_file *file_priv, unsigned flags,
  181.                      unsigned color, struct drm_clip_rect *clips,
  182.                      unsigned num_clips);
  183. };
  184.  
  185. struct drm_framebuffer {
  186.         struct drm_device *dev;
  187.         /*
  188.          * Note that the fb is refcounted for the benefit of driver internals,
  189.          * for example some hw, disabling a CRTC/plane is asynchronous, and
  190.          * scanout does not actually complete until the next vblank.  So some
  191.          * cleanup (like releasing the reference(s) on the backing GEM bo(s))
  192.          * should be deferred.  In cases like this, the driver would like to
  193.          * hold a ref to the fb even though it has already been removed from
  194.          * userspace perspective.
  195.          */
  196.         struct kref refcount;
  197.         /*
  198.          * Place on the dev->mode_config.fb_list, access protected by
  199.          * dev->mode_config.fb_lock.
  200.          */
  201.         struct list_head head;
  202.         struct drm_mode_object base;
  203.         const struct drm_framebuffer_funcs *funcs;
  204.         unsigned int pitches[4];
  205.         unsigned int offsets[4];
  206.         uint64_t modifier[4];
  207.         unsigned int width;
  208.         unsigned int height;
  209.         /* depth can be 15 or 16 */
  210.         unsigned int depth;
  211.         int bits_per_pixel;
  212.         int flags;
  213.         uint32_t pixel_format; /* fourcc format */
  214.         struct list_head filp_head;
  215. };
  216.  
  217. struct drm_property_blob {
  218.         struct drm_mode_object base;
  219.         struct drm_device *dev;
  220.         struct kref refcount;
  221.         struct list_head head_global;
  222.         struct list_head head_file;
  223.         size_t length;
  224.         unsigned char data[];
  225. };
  226.  
  227. struct drm_property_enum {
  228.         uint64_t value;
  229.         struct list_head head;
  230.         char name[DRM_PROP_NAME_LEN];
  231. };
  232.  
  233. struct drm_property {
  234.         struct list_head head;
  235.         struct drm_mode_object base;
  236.         uint32_t flags;
  237.         char name[DRM_PROP_NAME_LEN];
  238.         uint32_t num_values;
  239.         uint64_t *values;
  240.         struct drm_device *dev;
  241.  
  242.         struct list_head enum_list;
  243. };
  244.  
  245. struct drm_crtc;
  246. struct drm_connector;
  247. struct drm_encoder;
  248. struct drm_pending_vblank_event;
  249. struct drm_plane;
  250. struct drm_bridge;
  251. struct drm_atomic_state;
  252.  
  253. /**
  254.  * struct drm_crtc_state - mutable CRTC state
  255.  * @crtc: backpointer to the CRTC
  256.  * @enable: whether the CRTC should be enabled, gates all other state
  257.  * @active: whether the CRTC is actively displaying (used for DPMS)
  258.  * @planes_changed: planes on this crtc are updated
  259.  * @mode_changed: crtc_state->mode or crtc_state->enable has been changed
  260.  * @active_changed: crtc_state->active has been toggled.
  261.  * @connectors_changed: connectors to this crtc have been updated
  262.  * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
  263.  * @last_vblank_count: for helpers and drivers to capture the vblank of the
  264.  *      update to ensure framebuffer cleanup isn't done too early
  265.  * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings
  266.  * @mode: current mode timings
  267.  * @event: optional pointer to a DRM event to signal upon completion of the
  268.  *      state update
  269.  * @state: backpointer to global drm_atomic_state
  270.  *
  271.  * Note that the distinction between @enable and @active is rather subtile:
  272.  * Flipping @active while @enable is set without changing anything else may
  273.  * never return in a failure from the ->atomic_check callback. Userspace assumes
  274.  * that a DPMS On will always succeed. In other words: @enable controls resource
  275.  * assignment, @active controls the actual hardware state.
  276.  */
  277. struct drm_crtc_state {
  278.         struct drm_crtc *crtc;
  279.  
  280.         bool enable;
  281.         bool active;
  282.  
  283.         /* computed state bits used by helpers and drivers */
  284.         bool planes_changed : 1;
  285.         bool mode_changed : 1;
  286.         bool active_changed : 1;
  287.         bool connectors_changed : 1;
  288.  
  289.         /* attached planes bitmask:
  290.          * WARNING: transitional helpers do not maintain plane_mask so
  291.          * drivers not converted over to atomic helpers should not rely
  292.          * on plane_mask being accurate!
  293.          */
  294.         u32 plane_mask;
  295.  
  296.         /* last_vblank_count: for vblank waits before cleanup */
  297.         u32 last_vblank_count;
  298.  
  299.         /* adjusted_mode: for use by helpers and drivers */
  300.         struct drm_display_mode adjusted_mode;
  301.  
  302.         struct drm_display_mode mode;
  303.  
  304.         /* blob property to expose current mode to atomic userspace */
  305.         struct drm_property_blob *mode_blob;
  306.  
  307.         struct drm_pending_vblank_event *event;
  308.  
  309.         struct drm_atomic_state *state;
  310. };
  311.  
  312. /**
  313.  * struct drm_crtc_funcs - control CRTCs for a given device
  314.  * @save: save CRTC state
  315.  * @restore: restore CRTC state
  316.  * @reset: reset CRTC after state has been invalidated (e.g. resume)
  317.  * @cursor_set: setup the cursor
  318.  * @cursor_set2: setup the cursor with hotspot, superseeds @cursor_set if set
  319.  * @cursor_move: move the cursor
  320.  * @gamma_set: specify color ramp for CRTC
  321.  * @destroy: deinit and free object
  322.  * @set_property: called when a property is changed
  323.  * @set_config: apply a new CRTC configuration
  324.  * @page_flip: initiate a page flip
  325.  * @atomic_duplicate_state: duplicate the atomic state for this CRTC
  326.  * @atomic_destroy_state: destroy an atomic state for this CRTC
  327.  * @atomic_set_property: set a property on an atomic state for this CRTC
  328.  *    (do not call directly, use drm_atomic_crtc_set_property())
  329.  * @atomic_get_property: get a property on an atomic state for this CRTC
  330.  *    (do not call directly, use drm_atomic_crtc_get_property())
  331.  *
  332.  * The drm_crtc_funcs structure is the central CRTC management structure
  333.  * in the DRM.  Each CRTC controls one or more connectors (note that the name
  334.  * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
  335.  * connectors, not just CRTs).
  336.  *
  337.  * Each driver is responsible for filling out this structure at startup time,
  338.  * in addition to providing other modesetting features, like i2c and DDC
  339.  * bus accessors.
  340.  */
  341. struct drm_crtc_funcs {
  342.         /* Save CRTC state */
  343.         void (*save)(struct drm_crtc *crtc); /* suspend? */
  344.         /* Restore CRTC state */
  345.         void (*restore)(struct drm_crtc *crtc); /* resume? */
  346.         /* Reset CRTC state */
  347.         void (*reset)(struct drm_crtc *crtc);
  348.  
  349.         /* cursor controls */
  350.         int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
  351.                           uint32_t handle, uint32_t width, uint32_t height);
  352.         int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv,
  353.                            uint32_t handle, uint32_t width, uint32_t height,
  354.                            int32_t hot_x, int32_t hot_y);
  355.         int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
  356.  
  357.         /* Set gamma on the CRTC */
  358.         void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
  359.                           uint32_t start, uint32_t size);
  360.         /* Object destroy routine */
  361.         void (*destroy)(struct drm_crtc *crtc);
  362.  
  363.         int (*set_config)(struct drm_mode_set *set);
  364.  
  365.         /*
  366.          * Flip to the given framebuffer.  This implements the page
  367.          * flip ioctl described in drm_mode.h, specifically, the
  368.          * implementation must return immediately and block all
  369.          * rendering to the current fb until the flip has completed.
  370.          * If userspace set the event flag in the ioctl, the event
  371.          * argument will point to an event to send back when the flip
  372.          * completes, otherwise it will be NULL.
  373.          */
  374.         int (*page_flip)(struct drm_crtc *crtc,
  375.                          struct drm_framebuffer *fb,
  376.                          struct drm_pending_vblank_event *event,
  377.                          uint32_t flags);
  378.  
  379.         int (*set_property)(struct drm_crtc *crtc,
  380.                             struct drm_property *property, uint64_t val);
  381.  
  382.         /* atomic update handling */
  383.         struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
  384.         void (*atomic_destroy_state)(struct drm_crtc *crtc,
  385.                                      struct drm_crtc_state *state);
  386.         int (*atomic_set_property)(struct drm_crtc *crtc,
  387.                                    struct drm_crtc_state *state,
  388.                                    struct drm_property *property,
  389.                                    uint64_t val);
  390.         int (*atomic_get_property)(struct drm_crtc *crtc,
  391.                                    const struct drm_crtc_state *state,
  392.                                    struct drm_property *property,
  393.                                    uint64_t *val);
  394. };
  395.  
  396. /**
  397.  * struct drm_crtc - central CRTC control structure
  398.  * @dev: parent DRM device
  399.  * @port: OF node used by drm_of_find_possible_crtcs()
  400.  * @head: list management
  401.  * @mutex: per-CRTC locking
  402.  * @base: base KMS object for ID tracking etc.
  403.  * @primary: primary plane for this CRTC
  404.  * @cursor: cursor plane for this CRTC
  405.  * @cursor_x: current x position of the cursor, used for universal cursor planes
  406.  * @cursor_y: current y position of the cursor, used for universal cursor planes
  407.  * @enabled: is this CRTC enabled?
  408.  * @mode: current mode timings
  409.  * @hwmode: mode timings as programmed to hw regs
  410.  * @x: x position on screen
  411.  * @y: y position on screen
  412.  * @funcs: CRTC control functions
  413.  * @gamma_size: size of gamma ramp
  414.  * @gamma_store: gamma ramp values
  415.  * @helper_private: mid-layer private data
  416.  * @properties: property tracking for this CRTC
  417.  * @state: current atomic state for this CRTC
  418.  * @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for
  419.  *      legacy ioctls
  420.  *
  421.  * Each CRTC may have one or more connectors associated with it.  This structure
  422.  * allows the CRTC to be controlled.
  423.  */
  424. struct drm_crtc {
  425.         struct drm_device *dev;
  426.         struct device_node *port;
  427.         struct list_head head;
  428.  
  429.         /*
  430.          * crtc mutex
  431.          *
  432.          * This provides a read lock for the overall crtc state (mode, dpms
  433.          * state, ...) and a write lock for everything which can be update
  434.          * without a full modeset (fb, cursor data, ...)
  435.          */
  436.         struct drm_modeset_lock mutex;
  437.  
  438.         struct drm_mode_object base;
  439.  
  440.         /* primary and cursor planes for CRTC */
  441.         struct drm_plane *primary;
  442.         struct drm_plane *cursor;
  443.  
  444.         /* position of cursor plane on crtc */
  445.         int cursor_x;
  446.         int cursor_y;
  447.  
  448.         bool enabled;
  449.  
  450.         /* Requested mode from modesetting. */
  451.         struct drm_display_mode mode;
  452.  
  453.         /* Programmed mode in hw, after adjustments for encoders,
  454.          * crtc, panel scaling etc. Needed for timestamping etc.
  455.          */
  456.         struct drm_display_mode hwmode;
  457.  
  458.         int x, y;
  459.         const struct drm_crtc_funcs *funcs;
  460.  
  461.         /* CRTC gamma size for reporting to userspace */
  462.         uint32_t gamma_size;
  463.         uint16_t *gamma_store;
  464.  
  465.         /* if you are using the helper */
  466.         const void *helper_private;
  467.  
  468.         struct drm_object_properties properties;
  469.  
  470.         struct drm_crtc_state *state;
  471.  
  472.         /*
  473.          * For legacy crtc ioctls so that atomic drivers can get at the locking
  474.          * acquire context.
  475.          */
  476.         struct drm_modeset_acquire_ctx *acquire_ctx;
  477. };
  478.  
  479. /**
  480.  * struct drm_connector_state - mutable connector state
  481.  * @connector: backpointer to the connector
  482.  * @crtc: CRTC to connect connector to, NULL if disabled
  483.  * @best_encoder: can be used by helpers and drivers to select the encoder
  484.  * @state: backpointer to global drm_atomic_state
  485.  */
  486. struct drm_connector_state {
  487.         struct drm_connector *connector;
  488.  
  489.         struct drm_crtc *crtc;  /* do not write directly, use drm_atomic_set_crtc_for_connector() */
  490.  
  491.         struct drm_encoder *best_encoder;
  492.  
  493.         struct drm_atomic_state *state;
  494. };
  495.  
  496. /**
  497.  * struct drm_connector_funcs - control connectors on a given device
  498.  * @dpms: set power state
  499.  * @save: save connector state
  500.  * @restore: restore connector state
  501.  * @reset: reset connector after state has been invalidated (e.g. resume)
  502.  * @detect: is this connector active?
  503.  * @fill_modes: fill mode list for this connector
  504.  * @set_property: property for this connector may need an update
  505.  * @destroy: make object go away
  506.  * @force: notify the driver that the connector is forced on
  507.  * @atomic_duplicate_state: duplicate the atomic state for this connector
  508.  * @atomic_destroy_state: destroy an atomic state for this connector
  509.  * @atomic_set_property: set a property on an atomic state for this connector
  510.  *    (do not call directly, use drm_atomic_connector_set_property())
  511.  * @atomic_get_property: get a property on an atomic state for this connector
  512.  *    (do not call directly, use drm_atomic_connector_get_property())
  513.  *
  514.  * Each CRTC may have one or more connectors attached to it.  The functions
  515.  * below allow the core DRM code to control connectors, enumerate available modes,
  516.  * etc.
  517.  */
  518. struct drm_connector_funcs {
  519.         int (*dpms)(struct drm_connector *connector, int mode);
  520.         void (*save)(struct drm_connector *connector);
  521.         void (*restore)(struct drm_connector *connector);
  522.         void (*reset)(struct drm_connector *connector);
  523.  
  524.         /* Check to see if anything is attached to the connector.
  525.          * @force is set to false whilst polling, true when checking the
  526.          * connector due to user request. @force can be used by the driver
  527.          * to avoid expensive, destructive operations during automated
  528.          * probing.
  529.          */
  530.         enum drm_connector_status (*detect)(struct drm_connector *connector,
  531.                                             bool force);
  532.         int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
  533.         int (*set_property)(struct drm_connector *connector, struct drm_property *property,
  534.                              uint64_t val);
  535.         void (*destroy)(struct drm_connector *connector);
  536.         void (*force)(struct drm_connector *connector);
  537.  
  538.         /* atomic update handling */
  539.         struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);
  540.         void (*atomic_destroy_state)(struct drm_connector *connector,
  541.                                      struct drm_connector_state *state);
  542.         int (*atomic_set_property)(struct drm_connector *connector,
  543.                                    struct drm_connector_state *state,
  544.                                    struct drm_property *property,
  545.                                    uint64_t val);
  546.         int (*atomic_get_property)(struct drm_connector *connector,
  547.                                    const struct drm_connector_state *state,
  548.                                    struct drm_property *property,
  549.                                    uint64_t *val);
  550. };
  551.  
  552. /**
  553.  * struct drm_encoder_funcs - encoder controls
  554.  * @reset: reset state (e.g. at init or resume time)
  555.  * @destroy: cleanup and free associated data
  556.  *
  557.  * Encoders sit between CRTCs and connectors.
  558.  */
  559. struct drm_encoder_funcs {
  560.         void (*reset)(struct drm_encoder *encoder);
  561.         void (*destroy)(struct drm_encoder *encoder);
  562. };
  563.  
  564. #define DRM_CONNECTOR_MAX_ENCODER 3
  565.  
  566. /**
  567.  * struct drm_encoder - central DRM encoder structure
  568.  * @dev: parent DRM device
  569.  * @head: list management
  570.  * @base: base KMS object
  571.  * @name: encoder name
  572.  * @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h
  573.  * @possible_crtcs: bitmask of potential CRTC bindings
  574.  * @possible_clones: bitmask of potential sibling encoders for cloning
  575.  * @crtc: currently bound CRTC
  576.  * @bridge: bridge associated to the encoder
  577.  * @funcs: control functions
  578.  * @helper_private: mid-layer private data
  579.  *
  580.  * CRTCs drive pixels to encoders, which convert them into signals
  581.  * appropriate for a given connector or set of connectors.
  582.  */
  583. struct drm_encoder {
  584.         struct drm_device *dev;
  585.         struct list_head head;
  586.  
  587.         struct drm_mode_object base;
  588.         char *name;
  589.         int encoder_type;
  590.         uint32_t possible_crtcs;
  591.         uint32_t possible_clones;
  592.  
  593.         struct drm_crtc *crtc;
  594.         struct drm_bridge *bridge;
  595.         const struct drm_encoder_funcs *funcs;
  596.         const void *helper_private;
  597. };
  598.  
  599. /* should we poll this connector for connects and disconnects */
  600. /* hot plug detectable */
  601. #define DRM_CONNECTOR_POLL_HPD (1 << 0)
  602. /* poll for connections */
  603. #define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
  604. /* can cleanly poll for disconnections without flickering the screen */
  605. /* DACs should rarely do this without a lot of testing */
  606. #define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
  607.  
  608. #define MAX_ELD_BYTES   128
  609.  
  610. /**
  611.  * struct drm_connector - central DRM connector control structure
  612.  * @dev: parent DRM device
  613.  * @kdev: kernel device for sysfs attributes
  614.  * @attr: sysfs attributes
  615.  * @head: list management
  616.  * @base: base KMS object
  617.  * @name: connector name
  618.  * @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
  619.  * @connector_type_id: index into connector type enum
  620.  * @interlace_allowed: can this connector handle interlaced modes?
  621.  * @doublescan_allowed: can this connector handle doublescan?
  622.  * @stereo_allowed: can this connector handle stereo modes?
  623.  * @modes: modes available on this connector (from fill_modes() + user)
  624.  * @status: one of the drm_connector_status enums (connected, not, or unknown)
  625.  * @probed_modes: list of modes derived directly from the display
  626.  * @display_info: information about attached display (e.g. from EDID)
  627.  * @funcs: connector control functions
  628.  * @edid_blob_ptr: DRM property containing EDID if present
  629.  * @properties: property tracking for this connector
  630.  * @path_blob_ptr: DRM blob property data for the DP MST path property
  631.  * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling
  632.  * @dpms: current dpms state
  633.  * @helper_private: mid-layer private data
  634.  * @cmdline_mode: mode line parsed from the kernel cmdline for this connector
  635.  * @force: a %DRM_FORCE_<foo> state for forced mode sets
  636.  * @override_edid: has the EDID been overwritten through debugfs for testing?
  637.  * @encoder_ids: valid encoders for this connector
  638.  * @encoder: encoder driving this connector, if any
  639.  * @eld: EDID-like data, if present
  640.  * @dvi_dual: dual link DVI, if found
  641.  * @max_tmds_clock: max clock rate, if found
  642.  * @latency_present: AV delay info from ELD, if found
  643.  * @video_latency: video latency info from ELD, if found
  644.  * @audio_latency: audio latency info from ELD, if found
  645.  * @null_edid_counter: track sinks that give us all zeros for the EDID
  646.  * @bad_edid_counter: track sinks that give us an EDID with invalid checksum
  647.  * @edid_corrupt: indicates whether the last read EDID was corrupt
  648.  * @debugfs_entry: debugfs directory for this connector
  649.  * @state: current atomic state for this connector
  650.  * @has_tile: is this connector connected to a tiled monitor
  651.  * @tile_group: tile group for the connected monitor
  652.  * @tile_is_single_monitor: whether the tile is one monitor housing
  653.  * @num_h_tile: number of horizontal tiles in the tile group
  654.  * @num_v_tile: number of vertical tiles in the tile group
  655.  * @tile_h_loc: horizontal location of this tile
  656.  * @tile_v_loc: vertical location of this tile
  657.  * @tile_h_size: horizontal size of this tile.
  658.  * @tile_v_size: vertical size of this tile.
  659.  *
  660.  * Each connector may be connected to one or more CRTCs, or may be clonable by
  661.  * another connector if they can share a CRTC.  Each connector also has a specific
  662.  * position in the broader display (referred to as a 'screen' though it could
  663.  * span multiple monitors).
  664.  */
  665. struct drm_connector {
  666.         struct drm_device *dev;
  667.         struct device *kdev;
  668.         struct device_attribute *attr;
  669.         struct list_head head;
  670.  
  671.         struct drm_mode_object base;
  672.  
  673.         char *name;
  674.         int connector_type;
  675.         int connector_type_id;
  676.         bool interlace_allowed;
  677.         bool doublescan_allowed;
  678.         bool stereo_allowed;
  679.         struct list_head modes; /* list of modes on this connector */
  680.  
  681.         enum drm_connector_status status;
  682.  
  683.         /* these are modes added by probing with DDC or the BIOS */
  684.         struct list_head probed_modes;
  685.  
  686.         struct drm_display_info display_info;
  687.         const struct drm_connector_funcs *funcs;
  688.  
  689.         struct drm_property_blob *edid_blob_ptr;
  690.         struct drm_object_properties properties;
  691.  
  692.         struct drm_property_blob *path_blob_ptr;
  693.  
  694.         struct drm_property_blob *tile_blob_ptr;
  695.  
  696.         uint8_t polled; /* DRM_CONNECTOR_POLL_* */
  697.  
  698.         /* requested DPMS state */
  699.         int dpms;
  700.  
  701.         const void *helper_private;
  702.  
  703.         /* forced on connector */
  704.         struct drm_cmdline_mode cmdline_mode;
  705.         enum drm_connector_force force;
  706.         bool override_edid;
  707.         uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
  708.         struct drm_encoder *encoder; /* currently active encoder */
  709.  
  710.         /* EDID bits */
  711.         uint8_t eld[MAX_ELD_BYTES];
  712.         bool dvi_dual;
  713.         int max_tmds_clock;     /* in MHz */
  714.         bool latency_present[2];
  715.         int video_latency[2];   /* [0]: progressive, [1]: interlaced */
  716.         int audio_latency[2];
  717.         int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
  718.         unsigned bad_edid_counter;
  719.  
  720.         /* Flag for raw EDID header corruption - used in Displayport
  721.          * compliance testing - * Displayport Link CTS Core 1.2 rev1.1 4.2.2.6
  722.          */
  723.         bool edid_corrupt;
  724.  
  725.         struct dentry *debugfs_entry;
  726.  
  727.         struct drm_connector_state *state;
  728.  
  729.         /* DisplayID bits */
  730.         bool has_tile;
  731.         struct drm_tile_group *tile_group;
  732.         bool tile_is_single_monitor;
  733.  
  734.         uint8_t num_h_tile, num_v_tile;
  735.         uint8_t tile_h_loc, tile_v_loc;
  736.         uint16_t tile_h_size, tile_v_size;
  737. };
  738.  
  739. /**
  740.  * struct drm_plane_state - mutable plane state
  741.  * @plane: backpointer to the plane
  742.  * @crtc: currently bound CRTC, NULL if disabled
  743.  * @fb: currently bound framebuffer
  744.  * @fence: optional fence to wait for before scanning out @fb
  745.  * @crtc_x: left position of visible portion of plane on crtc
  746.  * @crtc_y: upper position of visible portion of plane on crtc
  747.  * @crtc_w: width of visible portion of plane on crtc
  748.  * @crtc_h: height of visible portion of plane on crtc
  749.  * @src_x: left position of visible portion of plane within
  750.  *      plane (in 16.16)
  751.  * @src_y: upper position of visible portion of plane within
  752.  *      plane (in 16.16)
  753.  * @src_w: width of visible portion of plane (in 16.16)
  754.  * @src_h: height of visible portion of plane (in 16.16)
  755.  * @state: backpointer to global drm_atomic_state
  756.  */
  757. struct drm_plane_state {
  758.         struct drm_plane *plane;
  759.  
  760.         struct drm_crtc *crtc;   /* do not write directly, use drm_atomic_set_crtc_for_plane() */
  761.         struct drm_framebuffer *fb;  /* do not write directly, use drm_atomic_set_fb_for_plane() */
  762.         struct fence *fence;
  763.  
  764.         /* Signed dest location allows it to be partially off screen */
  765.         int32_t crtc_x, crtc_y;
  766.         uint32_t crtc_w, crtc_h;
  767.  
  768.         /* Source values are 16.16 fixed point */
  769.         uint32_t src_x, src_y;
  770.         uint32_t src_h, src_w;
  771.  
  772.         /* Plane rotation */
  773.         unsigned int rotation;
  774.  
  775.         struct drm_atomic_state *state;
  776. };
  777.  
  778.  
  779. /**
  780.  * struct drm_plane_funcs - driver plane control functions
  781.  * @update_plane: update the plane configuration
  782.  * @disable_plane: shut down the plane
  783.  * @destroy: clean up plane resources
  784.  * @reset: reset plane after state has been invalidated (e.g. resume)
  785.  * @set_property: called when a property is changed
  786.  * @atomic_duplicate_state: duplicate the atomic state for this plane
  787.  * @atomic_destroy_state: destroy an atomic state for this plane
  788.  * @atomic_set_property: set a property on an atomic state for this plane
  789.  *    (do not call directly, use drm_atomic_plane_set_property())
  790.  * @atomic_get_property: get a property on an atomic state for this plane
  791.  *    (do not call directly, use drm_atomic_plane_get_property())
  792.  */
  793. struct drm_plane_funcs {
  794.         int (*update_plane)(struct drm_plane *plane,
  795.                             struct drm_crtc *crtc, struct drm_framebuffer *fb,
  796.                             int crtc_x, int crtc_y,
  797.                             unsigned int crtc_w, unsigned int crtc_h,
  798.                             uint32_t src_x, uint32_t src_y,
  799.                             uint32_t src_w, uint32_t src_h);
  800.         int (*disable_plane)(struct drm_plane *plane);
  801.         void (*destroy)(struct drm_plane *plane);
  802.         void (*reset)(struct drm_plane *plane);
  803.  
  804.         int (*set_property)(struct drm_plane *plane,
  805.                             struct drm_property *property, uint64_t val);
  806.  
  807.         /* atomic update handling */
  808.         struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane);
  809.         void (*atomic_destroy_state)(struct drm_plane *plane,
  810.                                      struct drm_plane_state *state);
  811.         int (*atomic_set_property)(struct drm_plane *plane,
  812.                                    struct drm_plane_state *state,
  813.                                    struct drm_property *property,
  814.                                    uint64_t val);
  815.         int (*atomic_get_property)(struct drm_plane *plane,
  816.                                    const struct drm_plane_state *state,
  817.                                    struct drm_property *property,
  818.                                    uint64_t *val);
  819. };
  820.  
  821. enum drm_plane_type {
  822.         DRM_PLANE_TYPE_OVERLAY,
  823.         DRM_PLANE_TYPE_PRIMARY,
  824.         DRM_PLANE_TYPE_CURSOR,
  825. };
  826.  
  827. /**
  828.  * struct drm_plane - central DRM plane control structure
  829.  * @dev: DRM device this plane belongs to
  830.  * @head: for list management
  831.  * @base: base mode object
  832.  * @possible_crtcs: pipes this plane can be bound to
  833.  * @format_types: array of formats supported by this plane
  834.  * @format_count: number of formats supported
  835.  * @format_default: driver hasn't supplied supported formats for the plane
  836.  * @crtc: currently bound CRTC
  837.  * @fb: currently bound fb
  838.  * @old_fb: Temporary tracking of the old fb while a modeset is ongoing. Used by
  839.  *      drm_mode_set_config_internal() to implement correct refcounting.
  840.  * @funcs: helper functions
  841.  * @properties: property tracking for this plane
  842.  * @type: type of plane (overlay, primary, cursor)
  843.  * @state: current atomic state for this plane
  844.  */
  845. struct drm_plane {
  846.         struct drm_device *dev;
  847.         struct list_head head;
  848.  
  849.         struct drm_modeset_lock mutex;
  850.  
  851.         struct drm_mode_object base;
  852.  
  853.         uint32_t possible_crtcs;
  854.         uint32_t *format_types;
  855.         unsigned int format_count;
  856.         bool format_default;
  857.  
  858.         struct drm_crtc *crtc;
  859.         struct drm_framebuffer *fb;
  860.  
  861.         struct drm_framebuffer *old_fb;
  862.  
  863.         const struct drm_plane_funcs *funcs;
  864.  
  865.         struct drm_object_properties properties;
  866.  
  867.         enum drm_plane_type type;
  868.  
  869.         const void *helper_private;
  870.  
  871.         struct drm_plane_state *state;
  872. };
  873.  
  874. /**
  875.  * struct drm_bridge_funcs - drm_bridge control functions
  876.  * @attach: Called during drm_bridge_attach
  877.  * @mode_fixup: Try to fixup (or reject entirely) proposed mode for this bridge
  878.  * @disable: Called right before encoder prepare, disables the bridge
  879.  * @post_disable: Called right after encoder prepare, for lockstepped disable
  880.  * @mode_set: Set this mode to the bridge
  881.  * @pre_enable: Called right before encoder commit, for lockstepped commit
  882.  * @enable: Called right after encoder commit, enables the bridge
  883.  */
  884. struct drm_bridge_funcs {
  885.         int (*attach)(struct drm_bridge *bridge);
  886.         bool (*mode_fixup)(struct drm_bridge *bridge,
  887.                            const struct drm_display_mode *mode,
  888.                            struct drm_display_mode *adjusted_mode);
  889.         void (*disable)(struct drm_bridge *bridge);
  890.         void (*post_disable)(struct drm_bridge *bridge);
  891.         void (*mode_set)(struct drm_bridge *bridge,
  892.                          struct drm_display_mode *mode,
  893.                          struct drm_display_mode *adjusted_mode);
  894.         void (*pre_enable)(struct drm_bridge *bridge);
  895.         void (*enable)(struct drm_bridge *bridge);
  896. };
  897.  
  898. /**
  899.  * struct drm_bridge - central DRM bridge control structure
  900.  * @dev: DRM device this bridge belongs to
  901.  * @encoder: encoder to which this bridge is connected
  902.  * @next: the next bridge in the encoder chain
  903.  * @of_node: device node pointer to the bridge
  904.  * @list: to keep track of all added bridges
  905.  * @funcs: control functions
  906.  * @driver_private: pointer to the bridge driver's internal context
  907.  */
  908. struct drm_bridge {
  909.         struct drm_device *dev;
  910.         struct drm_encoder *encoder;
  911.         struct drm_bridge *next;
  912. #ifdef CONFIG_OF
  913.         struct device_node *of_node;
  914. #endif
  915.         struct list_head list;
  916.  
  917.         const struct drm_bridge_funcs *funcs;
  918.         void *driver_private;
  919. };
  920.  
  921. /**
  922.  * struct drm_atomic_state - the global state object for atomic updates
  923.  * @dev: parent DRM device
  924.  * @allow_modeset: allow full modeset
  925.  * @legacy_cursor_update: hint to enforce legacy cursor ioctl semantics
  926.  * @planes: pointer to array of plane pointers
  927.  * @plane_states: pointer to array of plane states pointers
  928.  * @crtcs: pointer to array of CRTC pointers
  929.  * @crtc_states: pointer to array of CRTC states pointers
  930.  * @num_connector: size of the @connectors and @connector_states arrays
  931.  * @connectors: pointer to array of connector pointers
  932.  * @connector_states: pointer to array of connector states pointers
  933.  * @acquire_ctx: acquire context for this atomic modeset state update
  934.  */
  935. struct drm_atomic_state {
  936.         struct drm_device *dev;
  937.         bool allow_modeset : 1;
  938.         bool legacy_cursor_update : 1;
  939.         struct drm_plane **planes;
  940.         struct drm_plane_state **plane_states;
  941.         struct drm_crtc **crtcs;
  942.         struct drm_crtc_state **crtc_states;
  943.         int num_connector;
  944.         struct drm_connector **connectors;
  945.         struct drm_connector_state **connector_states;
  946.  
  947.         struct drm_modeset_acquire_ctx *acquire_ctx;
  948. };
  949.  
  950.  
  951. /**
  952.  * struct drm_mode_set - new values for a CRTC config change
  953.  * @fb: framebuffer to use for new config
  954.  * @crtc: CRTC whose configuration we're about to change
  955.  * @mode: mode timings to use
  956.  * @x: position of this CRTC relative to @fb
  957.  * @y: position of this CRTC relative to @fb
  958.  * @connectors: array of connectors to drive with this CRTC if possible
  959.  * @num_connectors: size of @connectors array
  960.  *
  961.  * Represents a single crtc the connectors that it drives with what mode
  962.  * and from which framebuffer it scans out from.
  963.  *
  964.  * This is used to set modes.
  965.  */
  966. struct drm_mode_set {
  967.         struct drm_framebuffer *fb;
  968.         struct drm_crtc *crtc;
  969.         struct drm_display_mode *mode;
  970.  
  971.         uint32_t x;
  972.         uint32_t y;
  973.  
  974.         struct drm_connector **connectors;
  975.         size_t num_connectors;
  976. };
  977.  
  978. /**
  979.  * struct drm_mode_config_funcs - basic driver provided mode setting functions
  980.  * @fb_create: create a new framebuffer object
  981.  * @output_poll_changed: function to handle output configuration changes
  982.  * @atomic_check: check whether a given atomic state update is possible
  983.  * @atomic_commit: commit an atomic state update previously verified with
  984.  *      atomic_check()
  985.  * @atomic_state_alloc: allocate a new atomic state
  986.  * @atomic_state_clear: clear the atomic state
  987.  * @atomic_state_free: free the atomic state
  988.  *
  989.  * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
  990.  * involve drivers.
  991.  */
  992. struct drm_mode_config_funcs {
  993.         struct drm_framebuffer *(*fb_create)(struct drm_device *dev,
  994.                                              struct drm_file *file_priv,
  995.                                              struct drm_mode_fb_cmd2 *mode_cmd);
  996.         void (*output_poll_changed)(struct drm_device *dev);
  997.  
  998.         int (*atomic_check)(struct drm_device *dev,
  999.                             struct drm_atomic_state *a);
  1000.         int (*atomic_commit)(struct drm_device *dev,
  1001.                              struct drm_atomic_state *a,
  1002.                              bool async);
  1003.         struct drm_atomic_state *(*atomic_state_alloc)(struct drm_device *dev);
  1004.         void (*atomic_state_clear)(struct drm_atomic_state *state);
  1005.         void (*atomic_state_free)(struct drm_atomic_state *state);
  1006. };
  1007.  
  1008. /**
  1009.  * struct drm_mode_config - Mode configuration control structure
  1010.  * @mutex: mutex protecting KMS related lists and structures
  1011.  * @connection_mutex: ww mutex protecting connector state and routing
  1012.  * @acquire_ctx: global implicit acquire context used by atomic drivers for
  1013.  *      legacy ioctls
  1014.  * @idr_mutex: mutex for KMS ID allocation and management
  1015.  * @crtc_idr: main KMS ID tracking object
  1016.  * @fb_lock: mutex to protect fb state and lists
  1017.  * @num_fb: number of fbs available
  1018.  * @fb_list: list of framebuffers available
  1019.  * @num_connector: number of connectors on this device
  1020.  * @connector_list: list of connector objects
  1021.  * @num_encoder: number of encoders on this device
  1022.  * @encoder_list: list of encoder objects
  1023.  * @num_overlay_plane: number of overlay planes on this device
  1024.  * @num_total_plane: number of universal (i.e. with primary/curso) planes on this device
  1025.  * @plane_list: list of plane objects
  1026.  * @num_crtc: number of CRTCs on this device
  1027.  * @crtc_list: list of CRTC objects
  1028.  * @property_list: list of property objects
  1029.  * @min_width: minimum pixel width on this device
  1030.  * @min_height: minimum pixel height on this device
  1031.  * @max_width: maximum pixel width on this device
  1032.  * @max_height: maximum pixel height on this device
  1033.  * @funcs: core driver provided mode setting functions
  1034.  * @fb_base: base address of the framebuffer
  1035.  * @poll_enabled: track polling support for this device
  1036.  * @poll_running: track polling status for this device
  1037.  * @output_poll_work: delayed work for polling in process context
  1038.  * @property_blob_list: list of all the blob property objects
  1039.  * @blob_lock: mutex for blob property allocation and management
  1040.  * @*_property: core property tracking
  1041.  * @preferred_depth: preferred RBG pixel depth, used by fb helpers
  1042.  * @prefer_shadow: hint to userspace to prefer shadow-fb rendering
  1043.  * @async_page_flip: does this device support async flips on the primary plane?
  1044.  * @cursor_width: hint to userspace for max cursor width
  1045.  * @cursor_height: hint to userspace for max cursor height
  1046.  *
  1047.  * Core mode resource tracking structure.  All CRTC, encoders, and connectors
  1048.  * enumerated by the driver are added here, as are global properties.  Some
  1049.  * global restrictions are also here, e.g. dimension restrictions.
  1050.  */
  1051. struct drm_mode_config {
  1052.         struct mutex mutex; /* protects configuration (mode lists etc.) */
  1053.         struct drm_modeset_lock connection_mutex; /* protects connector->encoder and encoder->crtc links */
  1054.         struct drm_modeset_acquire_ctx *acquire_ctx; /* for legacy _lock_all() / _unlock_all() */
  1055.         struct mutex idr_mutex; /* for IDR management */
  1056.         struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
  1057.         struct idr tile_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
  1058.         /* this is limited to one for now */
  1059.  
  1060.         struct mutex fb_lock; /* proctects global and per-file fb lists */
  1061.         int num_fb;
  1062.         struct list_head fb_list;
  1063.  
  1064.         int num_connector;
  1065.         struct list_head connector_list;
  1066.         int num_encoder;
  1067.         struct list_head encoder_list;
  1068.  
  1069.         /*
  1070.          * Track # of overlay planes separately from # of total planes.  By
  1071.          * default we only advertise overlay planes to userspace; if userspace
  1072.          * sets the "universal plane" capability bit, we'll go ahead and
  1073.          * expose all planes.
  1074.          */
  1075.         int num_overlay_plane;
  1076.         int num_total_plane;
  1077.         struct list_head plane_list;
  1078.  
  1079.         int num_crtc;
  1080.         struct list_head crtc_list;
  1081.  
  1082.         struct list_head property_list;
  1083.  
  1084.         int min_width, min_height;
  1085.         int max_width, max_height;
  1086.         const struct drm_mode_config_funcs *funcs;
  1087.         resource_size_t fb_base;
  1088.  
  1089.         /* output poll support */
  1090.         bool poll_enabled;
  1091.         bool poll_running;
  1092.         bool delayed_event;
  1093.         struct delayed_work output_poll_work;
  1094.  
  1095.         struct mutex blob_lock;
  1096.  
  1097.         /* pointers to standard properties */
  1098.         struct list_head property_blob_list;
  1099.         struct drm_property *edid_property;
  1100.         struct drm_property *dpms_property;
  1101.         struct drm_property *path_property;
  1102.         struct drm_property *tile_property;
  1103.         struct drm_property *plane_type_property;
  1104.         struct drm_property *rotation_property;
  1105.         struct drm_property *prop_src_x;
  1106.         struct drm_property *prop_src_y;
  1107.         struct drm_property *prop_src_w;
  1108.         struct drm_property *prop_src_h;
  1109.         struct drm_property *prop_crtc_x;
  1110.         struct drm_property *prop_crtc_y;
  1111.         struct drm_property *prop_crtc_w;
  1112.         struct drm_property *prop_crtc_h;
  1113.         struct drm_property *prop_fb_id;
  1114.         struct drm_property *prop_crtc_id;
  1115.         struct drm_property *prop_active;
  1116.         struct drm_property *prop_mode_id;
  1117.  
  1118.         /* DVI-I properties */
  1119.         struct drm_property *dvi_i_subconnector_property;
  1120.         struct drm_property *dvi_i_select_subconnector_property;
  1121.  
  1122.         /* TV properties */
  1123.         struct drm_property *tv_subconnector_property;
  1124.         struct drm_property *tv_select_subconnector_property;
  1125.         struct drm_property *tv_mode_property;
  1126.         struct drm_property *tv_left_margin_property;
  1127.         struct drm_property *tv_right_margin_property;
  1128.         struct drm_property *tv_top_margin_property;
  1129.         struct drm_property *tv_bottom_margin_property;
  1130.         struct drm_property *tv_brightness_property;
  1131.         struct drm_property *tv_contrast_property;
  1132.         struct drm_property *tv_flicker_reduction_property;
  1133.         struct drm_property *tv_overscan_property;
  1134.         struct drm_property *tv_saturation_property;
  1135.         struct drm_property *tv_hue_property;
  1136.  
  1137.         /* Optional properties */
  1138.         struct drm_property *scaling_mode_property;
  1139.         struct drm_property *aspect_ratio_property;
  1140.         struct drm_property *dirty_info_property;
  1141.  
  1142.         /* properties for virtual machine layout */
  1143.         struct drm_property *suggested_x_property;
  1144.         struct drm_property *suggested_y_property;
  1145.  
  1146.         /* dumb ioctl parameters */
  1147.         uint32_t preferred_depth, prefer_shadow;
  1148.  
  1149.         /* whether async page flip is supported or not */
  1150.         bool async_page_flip;
  1151.  
  1152.         /* whether the driver supports fb modifiers */
  1153.         bool allow_fb_modifiers;
  1154.  
  1155.         /* cursor size */
  1156.         uint32_t cursor_width, cursor_height;
  1157. };
  1158.  
  1159. /**
  1160.  * drm_for_each_plane_mask - iterate over planes specified by bitmask
  1161.  * @plane: the loop cursor
  1162.  * @dev: the DRM device
  1163.  * @plane_mask: bitmask of plane indices
  1164.  *
  1165.  * Iterate over all planes specified by bitmask.
  1166.  */
  1167. #define drm_for_each_plane_mask(plane, dev, plane_mask) \
  1168.         list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \
  1169.                 if ((plane_mask) & (1 << drm_plane_index(plane)))
  1170.  
  1171.  
  1172. #define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
  1173. #define obj_to_connector(x) container_of(x, struct drm_connector, base)
  1174. #define obj_to_encoder(x) container_of(x, struct drm_encoder, base)
  1175. #define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
  1176. #define obj_to_fb(x) container_of(x, struct drm_framebuffer, base)
  1177. #define obj_to_property(x) container_of(x, struct drm_property, base)
  1178. #define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
  1179. #define obj_to_plane(x) container_of(x, struct drm_plane, base)
  1180.  
  1181. struct drm_prop_enum_list {
  1182.         int type;
  1183.         char *name;
  1184. };
  1185.  
  1186. extern int drm_crtc_init_with_planes(struct drm_device *dev,
  1187.                                      struct drm_crtc *crtc,
  1188.                                      struct drm_plane *primary,
  1189.                                      struct drm_plane *cursor,
  1190.                                      const struct drm_crtc_funcs *funcs);
  1191. extern void drm_crtc_cleanup(struct drm_crtc *crtc);
  1192. extern unsigned int drm_crtc_index(struct drm_crtc *crtc);
  1193.  
  1194. /**
  1195.  * drm_crtc_mask - find the mask of a registered CRTC
  1196.  * @crtc: CRTC to find mask for
  1197.  *
  1198.  * Given a registered CRTC, return the mask bit of that CRTC for an
  1199.  * encoder's possible_crtcs field.
  1200.  */
  1201. static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc)
  1202. {
  1203.         return 1 << drm_crtc_index(crtc);
  1204. }
  1205.  
  1206. extern void drm_connector_ida_init(void);
  1207. extern void drm_connector_ida_destroy(void);
  1208. extern int drm_connector_init(struct drm_device *dev,
  1209.                               struct drm_connector *connector,
  1210.                               const struct drm_connector_funcs *funcs,
  1211.                               int connector_type);
  1212. int drm_connector_register(struct drm_connector *connector);
  1213. void drm_connector_unregister(struct drm_connector *connector);
  1214.  
  1215. extern void drm_connector_cleanup(struct drm_connector *connector);
  1216. extern unsigned int drm_connector_index(struct drm_connector *connector);
  1217. /* helper to unplug all connectors from sysfs for device */
  1218. extern void drm_connector_unplug_all(struct drm_device *dev);
  1219.  
  1220. extern int drm_bridge_add(struct drm_bridge *bridge);
  1221. extern void drm_bridge_remove(struct drm_bridge *bridge);
  1222. extern struct drm_bridge *of_drm_find_bridge(struct device_node *np);
  1223. extern int drm_bridge_attach(struct drm_device *dev, struct drm_bridge *bridge);
  1224.  
  1225. bool drm_bridge_mode_fixup(struct drm_bridge *bridge,
  1226.                         const struct drm_display_mode *mode,
  1227.                         struct drm_display_mode *adjusted_mode);
  1228. void drm_bridge_disable(struct drm_bridge *bridge);
  1229. void drm_bridge_post_disable(struct drm_bridge *bridge);
  1230. void drm_bridge_mode_set(struct drm_bridge *bridge,
  1231.                         struct drm_display_mode *mode,
  1232.                         struct drm_display_mode *adjusted_mode);
  1233. void drm_bridge_pre_enable(struct drm_bridge *bridge);
  1234. void drm_bridge_enable(struct drm_bridge *bridge);
  1235.  
  1236. extern int drm_encoder_init(struct drm_device *dev,
  1237.                             struct drm_encoder *encoder,
  1238.                             const struct drm_encoder_funcs *funcs,
  1239.                             int encoder_type);
  1240.  
  1241. /**
  1242.  * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
  1243.  * @encoder: encoder to test
  1244.  * @crtc: crtc to test
  1245.  *
  1246.  * Return false if @encoder can't be driven by @crtc, true otherwise.
  1247.  */
  1248. static inline bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
  1249.                                        struct drm_crtc *crtc)
  1250. {
  1251.         return !!(encoder->possible_crtcs & drm_crtc_mask(crtc));
  1252. }
  1253.  
  1254. extern int drm_universal_plane_init(struct drm_device *dev,
  1255.                                     struct drm_plane *plane,
  1256.                                     unsigned long possible_crtcs,
  1257.                                     const struct drm_plane_funcs *funcs,
  1258.                                     const uint32_t *formats,
  1259.                                     unsigned int format_count,
  1260.                                     enum drm_plane_type type);
  1261. extern int drm_plane_init(struct drm_device *dev,
  1262.                           struct drm_plane *plane,
  1263.                           unsigned long possible_crtcs,
  1264.                           const struct drm_plane_funcs *funcs,
  1265.                           const uint32_t *formats, unsigned int format_count,
  1266.                           bool is_primary);
  1267. extern void drm_plane_cleanup(struct drm_plane *plane);
  1268. extern unsigned int drm_plane_index(struct drm_plane *plane);
  1269. extern struct drm_plane * drm_plane_from_index(struct drm_device *dev, int idx);
  1270. extern void drm_plane_force_disable(struct drm_plane *plane);
  1271. extern int drm_plane_check_pixel_format(const struct drm_plane *plane,
  1272.                                         u32 format);
  1273. extern void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
  1274.                                    int *hdisplay, int *vdisplay);
  1275. extern int drm_crtc_check_viewport(const struct drm_crtc *crtc,
  1276.                                    int x, int y,
  1277.                                    const struct drm_display_mode *mode,
  1278.                                    const struct drm_framebuffer *fb);
  1279.  
  1280. extern void drm_encoder_cleanup(struct drm_encoder *encoder);
  1281.  
  1282. extern const char *drm_get_connector_status_name(enum drm_connector_status status);
  1283. extern const char *drm_get_subpixel_order_name(enum subpixel_order order);
  1284. extern const char *drm_get_dpms_name(int val);
  1285. extern const char *drm_get_dvi_i_subconnector_name(int val);
  1286. extern const char *drm_get_dvi_i_select_name(int val);
  1287. extern const char *drm_get_tv_subconnector_name(int val);
  1288. extern const char *drm_get_tv_select_name(int val);
  1289. extern void drm_fb_release(struct drm_file *file_priv);
  1290. extern void drm_property_destroy_user_blobs(struct drm_device *dev,
  1291.                                             struct drm_file *file_priv);
  1292. extern bool drm_probe_ddc(struct i2c_adapter *adapter);
  1293. extern struct edid *drm_get_edid(struct drm_connector *connector,
  1294.                                  struct i2c_adapter *adapter);
  1295. extern struct edid *drm_edid_duplicate(const struct edid *edid);
  1296. extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
  1297. extern void drm_mode_config_init(struct drm_device *dev);
  1298. extern void drm_mode_config_reset(struct drm_device *dev);
  1299. extern void drm_mode_config_cleanup(struct drm_device *dev);
  1300.  
  1301. extern int drm_mode_connector_set_path_property(struct drm_connector *connector,
  1302.                                                 const char *path);
  1303. int drm_mode_connector_set_tile_property(struct drm_connector *connector);
  1304. extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
  1305.                                                    const struct edid *edid);
  1306.  
  1307. extern int drm_display_info_set_bus_formats(struct drm_display_info *info,
  1308.                                             const u32 *formats,
  1309.                                             unsigned int num_formats);
  1310.  
  1311. static inline bool drm_property_type_is(struct drm_property *property,
  1312.                 uint32_t type)
  1313. {
  1314.         /* instanceof for props.. handles extended type vs original types: */
  1315.         if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
  1316.                 return (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) == type;
  1317.         return property->flags & type;
  1318. }
  1319.  
  1320. static inline bool drm_property_type_valid(struct drm_property *property)
  1321. {
  1322.         if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
  1323.                 return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
  1324.         return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
  1325. }
  1326.  
  1327. extern int drm_object_property_set_value(struct drm_mode_object *obj,
  1328.                                          struct drm_property *property,
  1329.                                          uint64_t val);
  1330. extern int drm_object_property_get_value(struct drm_mode_object *obj,
  1331.                                          struct drm_property *property,
  1332.                                          uint64_t *value);
  1333. extern int drm_framebuffer_init(struct drm_device *dev,
  1334.                                 struct drm_framebuffer *fb,
  1335.                                 const struct drm_framebuffer_funcs *funcs);
  1336. extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
  1337.                                                       uint32_t id);
  1338. extern void drm_framebuffer_unreference(struct drm_framebuffer *fb);
  1339. extern void drm_framebuffer_reference(struct drm_framebuffer *fb);
  1340. extern void drm_framebuffer_remove(struct drm_framebuffer *fb);
  1341. extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
  1342. extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb);
  1343.  
  1344. extern void drm_object_attach_property(struct drm_mode_object *obj,
  1345.                                        struct drm_property *property,
  1346.                                        uint64_t init_val);
  1347. extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
  1348.                                                 const char *name, int num_values);
  1349. extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
  1350.                                          const char *name,
  1351.                                          const struct drm_prop_enum_list *props,
  1352.                                          int num_values);
  1353. struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
  1354.                                          int flags, const char *name,
  1355.                                          const struct drm_prop_enum_list *props,
  1356.                                          int num_props,
  1357.                                          uint64_t supported_bits);
  1358. struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
  1359.                                          const char *name,
  1360.                                          uint64_t min, uint64_t max);
  1361. struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
  1362.                                          int flags, const char *name,
  1363.                                          int64_t min, int64_t max);
  1364. struct drm_property *drm_property_create_object(struct drm_device *dev,
  1365.                                          int flags, const char *name, uint32_t type);
  1366. struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
  1367.                                          const char *name);
  1368. struct drm_property_blob *drm_property_create_blob(struct drm_device *dev,
  1369.                                                    size_t length,
  1370.                                                    const void *data);
  1371. struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
  1372.                                                    uint32_t id);
  1373. struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob);
  1374. void drm_property_unreference_blob(struct drm_property_blob *blob);
  1375. extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
  1376. extern int drm_property_add_enum(struct drm_property *property, int index,
  1377.                                  uint64_t value, const char *name);
  1378. extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
  1379. extern int drm_mode_create_tv_properties(struct drm_device *dev,
  1380.                                          unsigned int num_modes,
  1381.                                          const char * const modes[]);
  1382. extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
  1383. extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
  1384. extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
  1385. extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
  1386. extern bool drm_property_change_valid_get(struct drm_property *property,
  1387.                                          uint64_t value, struct drm_mode_object **ref);
  1388. extern void drm_property_change_valid_put(struct drm_property *property,
  1389.                 struct drm_mode_object *ref);
  1390.  
  1391. extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
  1392.                                              struct drm_encoder *encoder);
  1393. extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
  1394.                                          int gamma_size);
  1395. extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
  1396.                 uint32_t id, uint32_t type);
  1397.  
  1398. /* IOCTLs */
  1399. extern int drm_mode_getresources(struct drm_device *dev,
  1400.                                  void *data, struct drm_file *file_priv);
  1401. extern int drm_mode_getplane_res(struct drm_device *dev, void *data,
  1402.                                    struct drm_file *file_priv);
  1403. extern int drm_mode_getcrtc(struct drm_device *dev,
  1404.                             void *data, struct drm_file *file_priv);
  1405. extern int drm_mode_getconnector(struct drm_device *dev,
  1406.                               void *data, struct drm_file *file_priv);
  1407. extern int drm_mode_set_config_internal(struct drm_mode_set *set);
  1408. extern int drm_mode_setcrtc(struct drm_device *dev,
  1409.                             void *data, struct drm_file *file_priv);
  1410. extern int drm_mode_getplane(struct drm_device *dev,
  1411.                                void *data, struct drm_file *file_priv);
  1412. extern int drm_mode_setplane(struct drm_device *dev,
  1413.                                void *data, struct drm_file *file_priv);
  1414. extern int drm_mode_cursor_ioctl(struct drm_device *dev,
  1415.                                 void *data, struct drm_file *file_priv);
  1416. extern int drm_mode_cursor2_ioctl(struct drm_device *dev,
  1417.                                 void *data, struct drm_file *file_priv);
  1418. extern int drm_mode_addfb(struct drm_device *dev,
  1419.                           void *data, struct drm_file *file_priv);
  1420. extern int drm_mode_addfb2(struct drm_device *dev,
  1421.                            void *data, struct drm_file *file_priv);
  1422. extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth);
  1423. extern int drm_mode_rmfb(struct drm_device *dev,
  1424.                          void *data, struct drm_file *file_priv);
  1425. extern int drm_mode_getfb(struct drm_device *dev,
  1426.                           void *data, struct drm_file *file_priv);
  1427. extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
  1428.                                   void *data, struct drm_file *file_priv);
  1429.  
  1430. extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
  1431.                                       void *data, struct drm_file *file_priv);
  1432. extern int drm_mode_getblob_ioctl(struct drm_device *dev,
  1433.                                   void *data, struct drm_file *file_priv);
  1434. extern int drm_mode_createblob_ioctl(struct drm_device *dev,
  1435.                                      void *data, struct drm_file *file_priv);
  1436. extern int drm_mode_destroyblob_ioctl(struct drm_device *dev,
  1437.                                       void *data, struct drm_file *file_priv);
  1438. extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
  1439.                                               void *data, struct drm_file *file_priv);
  1440. extern int drm_mode_getencoder(struct drm_device *dev,
  1441.                                void *data, struct drm_file *file_priv);
  1442. extern int drm_mode_gamma_get_ioctl(struct drm_device *dev,
  1443.                                     void *data, struct drm_file *file_priv);
  1444. extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
  1445.                                     void *data, struct drm_file *file_priv);
  1446. extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match);
  1447. extern enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code);
  1448. extern bool drm_detect_hdmi_monitor(struct edid *edid);
  1449. extern bool drm_detect_monitor_audio(struct edid *edid);
  1450. extern bool drm_rgb_quant_range_selectable(struct edid *edid);
  1451. extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
  1452.                                     void *data, struct drm_file *file_priv);
  1453. extern int drm_add_modes_noedid(struct drm_connector *connector,
  1454.                                 int hdisplay, int vdisplay);
  1455. extern void drm_set_preferred_mode(struct drm_connector *connector,
  1456.                                    int hpref, int vpref);
  1457.  
  1458. extern int drm_edid_header_is_valid(const u8 *raw_edid);
  1459. extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid,
  1460.                                  bool *edid_corrupt);
  1461. extern bool drm_edid_is_valid(struct edid *edid);
  1462.  
  1463. extern struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
  1464.                                                          char topology[8]);
  1465. extern struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
  1466.                                                char topology[8]);
  1467. extern void drm_mode_put_tile_group(struct drm_device *dev,
  1468.                                    struct drm_tile_group *tg);
  1469. struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
  1470.                                            int hsize, int vsize, int fresh,
  1471.                                            bool rb);
  1472.  
  1473. extern int drm_mode_create_dumb_ioctl(struct drm_device *dev,
  1474.                                       void *data, struct drm_file *file_priv);
  1475. extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
  1476.                                     void *data, struct drm_file *file_priv);
  1477. extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
  1478.                                       void *data, struct drm_file *file_priv);
  1479. extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
  1480.                                              struct drm_file *file_priv);
  1481. extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
  1482.                                            struct drm_file *file_priv);
  1483. extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
  1484.                                        struct drm_property *property,
  1485.                                        uint64_t value);
  1486. extern int drm_mode_atomic_ioctl(struct drm_device *dev,
  1487.                                  void *data, struct drm_file *file_priv);
  1488.  
  1489. extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
  1490.                                  int *bpp);
  1491. extern int drm_format_num_planes(uint32_t format);
  1492. extern int drm_format_plane_cpp(uint32_t format, int plane);
  1493. extern int drm_format_horz_chroma_subsampling(uint32_t format);
  1494. extern int drm_format_vert_chroma_subsampling(uint32_t format);
  1495. extern const char *drm_get_format_name(uint32_t format);
  1496. extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
  1497.                                                               unsigned int supported_rotations);
  1498. extern unsigned int drm_rotation_simplify(unsigned int rotation,
  1499.                                           unsigned int supported_rotations);
  1500.  
  1501. /* Helpers */
  1502.  
  1503. static inline struct drm_plane *drm_plane_find(struct drm_device *dev,
  1504.                 uint32_t id)
  1505. {
  1506.         struct drm_mode_object *mo;
  1507.         mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PLANE);
  1508.         return mo ? obj_to_plane(mo) : NULL;
  1509. }
  1510.  
  1511. static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
  1512.         uint32_t id)
  1513. {
  1514.         struct drm_mode_object *mo;
  1515.         mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC);
  1516.         return mo ? obj_to_crtc(mo) : NULL;
  1517. }
  1518.  
  1519. static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev,
  1520.         uint32_t id)
  1521. {
  1522.         struct drm_mode_object *mo;
  1523.         mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
  1524.         return mo ? obj_to_encoder(mo) : NULL;
  1525. }
  1526.  
  1527. static inline struct drm_connector *drm_connector_find(struct drm_device *dev,
  1528.                 uint32_t id)
  1529. {
  1530.         struct drm_mode_object *mo;
  1531.         mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CONNECTOR);
  1532.         return mo ? obj_to_connector(mo) : NULL;
  1533. }
  1534.  
  1535. static inline struct drm_property *drm_property_find(struct drm_device *dev,
  1536.                 uint32_t id)
  1537. {
  1538.         struct drm_mode_object *mo;
  1539.         mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PROPERTY);
  1540.         return mo ? obj_to_property(mo) : NULL;
  1541. }
  1542.  
  1543. /* Plane list iterator for legacy (overlay only) planes. */
  1544. #define drm_for_each_legacy_plane(plane, dev) \
  1545.         list_for_each_entry(plane, &(dev)->mode_config.plane_list, head) \
  1546.                 if (plane->type == DRM_PLANE_TYPE_OVERLAY)
  1547.  
  1548. #define drm_for_each_plane(plane, dev) \
  1549.         list_for_each_entry(plane, &(dev)->mode_config.plane_list, head)
  1550.  
  1551. #define drm_for_each_crtc(crtc, dev) \
  1552.         list_for_each_entry(crtc, &(dev)->mode_config.crtc_list, head)
  1553.  
  1554. static inline void
  1555. assert_drm_connector_list_read_locked(struct drm_mode_config *mode_config)
  1556. {
  1557.         /*
  1558.          * The connector hotadd/remove code currently grabs both locks when
  1559.          * updating lists. Hence readers need only hold either of them to be
  1560.          * safe and the check amounts to
  1561.          *
  1562.          * WARN_ON(not_holding(A) && not_holding(B)).
  1563.          */
  1564.         WARN_ON(!mutex_is_locked(&mode_config->mutex) &&
  1565.                 !drm_modeset_is_locked(&mode_config->connection_mutex));
  1566. }
  1567.  
  1568. #define drm_for_each_connector(connector, dev) \
  1569.         for (assert_drm_connector_list_read_locked(&(dev)->mode_config),        \
  1570.              connector = list_first_entry(&(dev)->mode_config.connector_list,   \
  1571.                                           struct drm_connector, head);          \
  1572.              &connector->head != (&(dev)->mode_config.connector_list);          \
  1573.              connector = list_next_entry(connector, head))
  1574.  
  1575. #define drm_for_each_encoder(encoder, dev) \
  1576.         list_for_each_entry(encoder, &(dev)->mode_config.encoder_list, head)
  1577.  
  1578. #define drm_for_each_fb(fb, dev) \
  1579.         for (WARN_ON(!mutex_is_locked(&(dev)->mode_config.fb_lock)),            \
  1580.              fb = list_first_entry(&(dev)->mode_config.fb_list, \
  1581.                                           struct drm_framebuffer, head);        \
  1582.              &fb->head != (&(dev)->mode_config.fb_list);                        \
  1583.              fb = list_next_entry(fb, head))
  1584.  
  1585. #endif /* __DRM_CRTC_H__ */
  1586.