LXR linux/include/drm/drm

   1/*
   2 * Copyright (C) 2014 Red Hat
   3 * Copyright (C) 2014 Intel Corp.
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining a
   6 * copy of this software and associated documentation files (the "Software"),
   7 * to deal in the Software without restriction, including without limitation
   8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9 * and/or sell copies of the Software, and to permit persons to whom the
  10 * Software is furnished to do so, subject to the following conditions:
  11 *
  12 * The above copyright notice and this permission notice shall be included in
  13 * all copies or substantial portions of the Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21 * OTHER DEALINGS IN THE SOFTWARE.
  22 *
  23 * Authors:
  24 * Rob Clark <robdclark@gmail.com>
  25 * Daniel Vetter <daniel.vetter@ffwll.ch>
  26 */
  27
  28#ifndef DRM_ATOMIC_H_
  29#define DRM_ATOMIC_H_
  30
  31#include <drm/drm_crtc.h>
  32
  33struct drm_atomic_state * __must_check
  34drm_atomic_state_alloc(struct drm_device *dev);
  35void drm_atomic_state_clear(struct drm_atomic_state *state);
  36void drm_atomic_state_free(struct drm_atomic_state *state);
  37
  38int  __must_check
  39drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state);
  40void drm_atomic_state_default_clear(struct drm_atomic_state *state);
  41void drm_atomic_state_default_release(struct drm_atomic_state *state);
  42
  43struct drm_crtc_state * __must_check
  44drm_atomic_get_crtc_state(struct drm_atomic_state *state,
  45                          struct drm_crtc *crtc);
  46int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
  47                struct drm_crtc_state *state, struct drm_property *property,
  48                uint64_t val);
  49struct drm_plane_state * __must_check
  50drm_atomic_get_plane_state(struct drm_atomic_state *state,
  51                           struct drm_plane *plane);
  52int drm_atomic_plane_set_property(struct drm_plane *plane,
  53                struct drm_plane_state *state, struct drm_property *property,
  54                uint64_t val);
  55struct drm_connector_state * __must_check
  56drm_atomic_get_connector_state(struct drm_atomic_state *state,
  57                               struct drm_connector *connector);
  58int drm_atomic_connector_set_property(struct drm_connector *connector,
  59                struct drm_connector_state *state, struct drm_property *property,
  60                uint64_t val);
  61
  62/**
  63 * drm_atomic_get_existing_crtc_state - get crtc state, if it exists
  64 * @state: global atomic state object
  65 * @crtc: crtc to grab
  66 *
  67 * This function returns the crtc state for the given crtc, or NULL
  68 * if the crtc is not part of the global atomic state.
  69 */
  70static inline struct drm_crtc_state *
  71drm_atomic_get_existing_crtc_state(struct drm_atomic_state *state,
  72                                   struct drm_crtc *crtc)
  73{
  74        return state->crtc_states[drm_crtc_index(crtc)];
  75}
  76
  77/**
  78 * drm_atomic_get_existing_plane_state - get plane state, if it exists
  79 * @state: global atomic state object
  80 * @plane: plane to grab
  81 *
  82 * This function returns the plane state for the given plane, or NULL
  83 * if the plane is not part of the global atomic state.
  84 */
  85static inline struct drm_plane_state *
  86drm_atomic_get_existing_plane_state(struct drm_atomic_state *state,
  87                                    struct drm_plane *plane)
  88{
  89        return state->plane_states[drm_plane_index(plane)];
  90}
  91
  92/**
  93 * drm_atomic_get_existing_connector_state - get connector state, if it exists
  94 * @state: global atomic state object
  95 * @connector: connector to grab
  96 *
  97 * This function returns the connector state for the given connector,
  98 * or NULL if the connector is not part of the global atomic state.
  99 */
 100static inline struct drm_connector_state *
 101drm_atomic_get_existing_connector_state(struct drm_atomic_state *state,
 102                                        struct drm_connector *connector)
 103{
 104        int index = drm_connector_index(connector);
 105
 106        if (index >= state->num_connector)
 107                return NULL;
 108
 109        return state->connector_states[index];
 110}
 111
 112int __must_check
 113drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
 114                             struct drm_display_mode *mode);
 115int __must_check
 116drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
 117                                  struct drm_property_blob *blob);
 118int __must_check
 119drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
 120                              struct drm_crtc *crtc);
 121void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
 122                                 struct drm_framebuffer *fb);
 123int __must_check
 124drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
 125                                  struct drm_crtc *crtc);
 126int __must_check
 127drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
 128                                   struct drm_crtc *crtc);
 129int __must_check
 130drm_atomic_add_affected_planes(struct drm_atomic_state *state,
 131                               struct drm_crtc *crtc);
 132
 133void drm_atomic_legacy_backoff(struct drm_atomic_state *state);
 134
 135void
 136drm_atomic_clean_old_fb(struct drm_device *dev, unsigned plane_mask, int ret);
 137
 138int __must_check drm_atomic_check_only(struct drm_atomic_state *state);
 139int __must_check drm_atomic_commit(struct drm_atomic_state *state);
 140int __must_check drm_atomic_async_commit(struct drm_atomic_state *state);
 141
 142#define for_each_connector_in_state(state, connector, connector_state, __i) \
 143        for ((__i) = 0;                                                 \
 144             (__i) < (state)->num_connector &&                          \
 145             ((connector) = (state)->connectors[__i],                   \
 146             (connector_state) = (state)->connector_states[__i], 1);    \
 147             (__i)++)                                                   \
 148                for_each_if (connector)
 149
 150#define for_each_crtc_in_state(state, crtc, crtc_state, __i)    \
 151        for ((__i) = 0;                                         \
 152             (__i) < (state)->dev->mode_config.num_crtc &&      \
 153             ((crtc) = (state)->crtcs[__i],                     \
 154             (crtc_state) = (state)->crtc_states[__i], 1);      \
 155             (__i)++)                                           \
 156                for_each_if (crtc_state)
 157
 158#define for_each_plane_in_state(state, plane, plane_state, __i)         \
 159        for ((__i) = 0;                                                 \
 160             (__i) < (state)->dev->mode_config.num_total_plane &&       \
 161             ((plane) = (state)->planes[__i],                           \
 162             (plane_state) = (state)->plane_states[__i], 1);            \
 163             (__i)++)                                                   \
 164                for_each_if (plane_state)
 165static inline bool
 166drm_atomic_crtc_needs_modeset(struct drm_crtc_state *state)
 167{
 168        return state->mode_changed || state->active_changed ||
 169               state->connectors_changed;
 170}
 171
 172
 173#endif /* DRM_ATOMIC_H_ */
 174